From 743d8abeaffe55cefbddbd2b264be4adcac4d19c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 17 Oct 2019 00:23:46 +0200
Subject: [PATCH 0001/1774] first attempt to document and explain serialization
 tools for application developers

---
 serialize/SerialLinkedListAdapter.h | 16 +++++++++++++++-
 serialize/SerializeAdapter.h        | 14 +++++++++++++-
 serialize/SerializeIF.h             |  2 +-
 3 files changed, 29 insertions(+), 3 deletions(-)

diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 29952c4a3..44d9e15bc 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -13,7 +13,21 @@
 #include <framework/serialize/SerializeIF.h>
 //This is where we need the SerializeAdapter!
 
-/**
+ /**
+ * An alternative to the AutoSerializeAdapter functions to implement the conversion
+ * of object data to data streams or vice-versa, using linked lists.
+ *
+ * All object members with a datatype are declared as SerializeElement<element_type> inside the class.
+ *
+ * Buffers with a size header inside that class can be declared with
+ * SerialFixedArrayListAdapter<uint8_t,MAX_BUFFER_LENGTH,typeOfMaxData>.
+ * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows
+ * and MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
+ * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
+ *
+ * The serialization and deserialization process is done by instantiating the class and
+ * calling the serialize or deserialize function.
+ *
  * \ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index fd9e1b6af..67c37493a 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -7,7 +7,19 @@
 #include <framework/serialize/SerializeIF.h>
 #include <string.h>
 
-/**
+ /**
+ * This adapter 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 vice-versa.
+ *
+ * Examples:
+ * A report class is converted into a TM buffer. The report class implements a serialize functions and calls
+ * the AutoSerializeAdapter::serialize function repeatedly on all object data fields.
+ * The getSerializedSize function is implemented by calling the
+ * AutoSerializeAdapter::getSerializedSize function repeatedly on all data fields.
+ *
+ * The AutoSerializeAdapter functions can also be used as an alternative to memcpy
+ * to retrieve data out of a buffer directly into a class variable with data type T while being able to specify endianness.
  * \ingroup serialize
  */
 template<typename T, int>
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 701fbf563..50555d379 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -9,7 +9,7 @@
  */
 
 /**
- * Translation of objects into data streams.
+ * An interface for alle classes which require translation of objects data into data streams and vice-versa.
  * \ingroup serialize
  */
 class SerializeIF {

From 5e3b7c36257314bab40b36c78c13c0525b08eb86 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Oct 2019 13:37:09 +0200
Subject: [PATCH 0002/1774] explanation of cookie purpose added, device handler
 base indentation

---
 devicehandlers/Cookie.h              |  3 +++
 devicehandlers/DeviceHandlerBase.cpp | 27 +++++++++++++--------------
 2 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/devicehandlers/Cookie.h b/devicehandlers/Cookie.h
index 495c8c403..618c901ff 100644
--- a/devicehandlers/Cookie.h
+++ b/devicehandlers/Cookie.h
@@ -1,6 +1,9 @@
 #ifndef COOKIE_H_
 #define COOKIE_H_
 
+/**
+ * This datatype is used to identify different connection over a single interface (like RMAP or I2C)
+ */
 class Cookie{
 public:
 	virtual ~Cookie(){}
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ae9199f2c..750d4d4ad 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -21,20 +21,19 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
 		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
-		SystemObject(setObjectId), rawPacket(0), rawPacketLen(0), mode(
-				MODE_OFF), submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(
-				maxDeviceReplyLen), wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(
-				StorageManagerIF::INVALID_ADDRESS), requestedRawTraffic(0), powerSwitcher(
-		NULL), IPCStore(NULL), deviceCommunicationId(deviceCommunication), communicationInterface(
-		NULL), cookie(
-		NULL), commandQueue(NULL), deviceThermalStatePoolId(thermalStatePoolId), deviceThermalRequestPoolId(
-				thermalRequestPoolId), healthHelper(this, setObjectId), modeHelper(
-				this), parameterHelper(this), childTransitionFailure(RETURN_OK), ignoreMissedRepliesCount(
-				0), fdirInstance(fdirInstance), hkSwitcher(this), defaultFDIRUsed(
-				fdirInstance == NULL), switchOffWasReported(false),executingTask(NULL), actionHelper(this, NULL), cookieInfo(), ioBoardAddress(
-				ioBoardAddress), timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(
-				_MODE_POWER_DOWN), transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(
-				setDeviceSwitch) {
+		SystemObject(setObjectId), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
+		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
+		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
+		requestedRawTraffic(0), powerSwitcher(NULL), IPCStore(NULL),
+		deviceCommunicationId(deviceCommunication), communicationInterface(NULL),
+		cookie(NULL), commandQueue(NULL), deviceThermalStatePoolId(thermalStatePoolId),
+		deviceThermalRequestPoolId(thermalRequestPoolId), healthHelper(this, setObjectId),
+		modeHelper(this), parameterHelper(this), childTransitionFailure(RETURN_OK),
+		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
+		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
+		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), ioBoardAddress(ioBoardAddress),
+		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;

From 907664cea9958f1259ed19560839c26533481cf7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 21 Oct 2019 11:38:13 +0200
Subject: [PATCH 0003/1774] added do performOperation where the comIF functions
 are called, some comments added in DeviceHandlerIF

---
 devicehandlers/DeviceHandlerBase.h | 18 +++++++++++-------
 devicehandlers/DeviceHandlerIF.h   |  7 ++++++-
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 756ad530d..70fefe8aa 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -33,6 +33,7 @@ class StorageManagerIF;
  * Contains all devices and the DeviceHandlerBase class.
  */
 
+// Robin: We're not really using RMAP, right? Maybe we should adapt class description for that?
 /**
  * \brief This is the abstract base class for device handlers.
  *
@@ -81,7 +82,7 @@ public:
 
 
 	/**
-		 * This function is a core component and is called periodically.
+		 * This function is the device handler base core component and is called periodically.
 		 * General sequence:
 		 * If the State is SEND_WRITE:
 		 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
@@ -95,13 +96,16 @@ public:
 		 *   7. If the device mode is MODE_OFF, return RETURN_OK. Otherwise, perform the Action property
 		 *   	and performs depending on value specified
 		 *      by input value counter. The child class tells base class what to do by setting this value.
-		 *     - SEND_WRITE: Send data or commands to device by calling doSendWrite()
-		 *     	 Calls abstract funtions buildNomalDeviceCommand()
-		 *     	 or buildTransitionDeviceCommand()
-		 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite().
+		 *     - SEND_WRITE: Send data or commands to device by calling doSendWrite() which calls
+		 *       sendMessage function of #communicationInterface
+		 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
+		 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite() which calls
+		 *       getSendSuccess of #communicationInterface.
 		 *       Calls abstract functions scanForReply() and interpretDeviceReply().
-		 *     - SEND_READ: Request reading data from device by calling doSendRead()
-		 *     - GET_READ: Access requested reading data by calling doGetRead()
+		 *     - SEND_READ: Request reading data from device by calling doSendRead() which calls
+		 *       requestReceiveMessage of #communcationInterface
+		 *     - GET_READ: Access requested reading data by calling doGetRead() which calls
+		 *       readReceivedMessage of #communicationInterface
 		 * @param counter Specifies which Action to perform
 		 * @return RETURN_OK for successful execution
 		 */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index fe0ee8e8b..8fdd04fe9 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -23,6 +23,11 @@ public:
 	 * @details The mode of the device handler must not be confused with the mode the device is in.
 	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
 	 */
+		// Robin: The first two modes (MODE_ON, MODE_OFF) are specified in hasModesIF.
+		// We could mention in a comment where those modes are located.
+		// The comments for _MODE_TO_ON have been taken from the comments in DeviceHandlerBase.cpp file.
+		// Is the same explanation valid for _MODE_TO_RAW and MODE_TO_NORMAL?
+
 //		MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 //		MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
 		static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
@@ -30,7 +35,7 @@ public:
 		static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
 		static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The device handler performs all commands to get the device in a state ready to perform commands. When this is completed, the mode changes to @c MODE_ON.
 		static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6; //!< This is a transitional state which can not be commanded. The device handler performs all actions and commands to get the device shut down. When the device is off, the mode changes to @c MODE_OFF.
-		static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+		static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON; //!< It is possible to set the mode to _MODE_TO_ON to use the to on transition if available.
 		static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
 		static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
 		static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1; //!< This is a transitional state which can not be commanded. The device is shut down and ready to be switched off. After the command to set the switch off has been sent, the mode changes to @c MODE_WAIT_OFF

From cbc8012198da6e94870f2b5fe63b799587092bc8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Oct 2019 00:06:11 +0200
Subject: [PATCH 0004/1774] ioBoardAddress protected instead of private to
 allow custom initialize

---
 devicehandlers/DeviceHandlerBase.cpp |  4 ++--
 devicehandlers/DeviceHandlerBase.h   | 14 ++++++++++----
 devicehandlers/DeviceHandlerIF.h     |  6 ++----
 health/HealthHelper.h                |  2 +-
 osal/FreeRTOS/FixedTimeslotTask.cpp  |  3 +--
 5 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 750d4d4ad..bc87422d8 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -21,7 +21,7 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
 		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
-		SystemObject(setObjectId), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
+		SystemObject(setObjectId),ioBoardAddress(ioBoardAddress), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
 		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
 		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		requestedRawTraffic(0), powerSwitcher(NULL), IPCStore(NULL),
@@ -31,7 +31,7 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
 		modeHelper(this), parameterHelper(this), childTransitionFailure(RETURN_OK),
 		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
 		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
-		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), ioBoardAddress(ioBoardAddress),
+		executingTask(NULL), actionHelper(this, NULL), cookieInfo(),
 		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
 		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 70fefe8aa..45a87a8aa 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -141,6 +141,11 @@ public:
 	 */
 	virtual  void setTaskIF(PeriodicTaskIF* task_);
 protected:
+	/**
+	* cached from ctor for initialize()
+	*/
+	const uint32_t ioBoardAddress;
+
 	/**
 	 * The Returnvalues id of this class, required by HasReturnvaluesIF
 	 */
@@ -163,6 +168,8 @@ 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.
 	 */
@@ -833,6 +840,9 @@ protected:
 	DeviceCommandMap deviceCommandMap;
 
 	ActionHelper actionHelper;
+
+
+
 private:
 
 	/**
@@ -865,10 +875,6 @@ private:
 	 */
 	CookieInfo cookieInfo;
 
-	/**
-	 * cached from ctor for initialize()
-	 */
-	const uint32_t ioBoardAddress;
 
 	/**
 	 * Used for timing out mode transitions.
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 8fdd04fe9..bfa7c7b24 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -22,11 +22,9 @@ public:
 	 *
 	 * @details The mode of the device handler must not be confused with the mode the device is in.
 	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
+	 * MODE_ON and MODE_OFF are included in hasModesIF.h
 	 */
-		// Robin: The first two modes (MODE_ON, MODE_OFF) are specified in hasModesIF.
-		// We could mention in a comment where those modes are located.
-		// The comments for _MODE_TO_ON have been taken from the comments in DeviceHandlerBase.cpp file.
-		// Is the same explanation valid for _MODE_TO_RAW and MODE_TO_NORMAL?
+
 
 //		MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 //		MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index a1ca2c525..24fd0d14a 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -27,8 +27,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);
 
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 00fd73d35..5bf09f136 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -19,8 +19,7 @@ FixedTimeslotTask::~FixedTimeslotTask() {
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
 
 	//The argument is re-interpreted as FixedTimeslotTask. The Task object is global, so it is found from any place.
-	FixedTimeslotTask *originalTask(
-			reinterpret_cast<FixedTimeslotTask*>(argument));
+	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
 	// Task should not start until explicitly requested
 	// in FreeRTOS, tasks start as soon as they are created if the scheduler is running
 	// but not if the scheduler is not running.

From 4db655e4898de934f6388365ec036d9d6e6b1bbe Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Oct 2019 14:01:17 +0200
Subject: [PATCH 0005/1774] task priority order comment

---
 osal/FreeRTOS/TaskFactory.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 7b2f70a3a..753da60f7 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -15,6 +15,7 @@ TaskFactory* TaskFactory::instance() {
 }
 /***
  * Keep in Mind that you need to call before this vTaskStartScheduler()!
+ * High taskPriority_ number means high priority.
  */
 PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
 		TaskPriority taskPriority_, TaskStackSize stackSize_,

From c6e34cada64f59757e420347dec8373401d73c7a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Oct 2019 17:15:29 +0200
Subject: [PATCH 0006/1774] documentation for DHB init function, ioBoard addres
 has default value 0 now, order in ctor changed (not used in source)

---
 devicehandlers/ChildHandlerBase.cpp  |  4 ++--
 devicehandlers/DeviceHandlerBase.cpp |  9 ++++-----
 devicehandlers/DeviceHandlerBase.h   | 21 ++++++++++++++++++---
 3 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 50a5c07e5..fb9238f7e 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -7,8 +7,8 @@ ChildHandlerBase::ChildHandlerBase(uint32_t ioBoardAddress,
 		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		uint32_t parent, FailureIsolationBase* customFdir, uint32_t cmdQueueSize) :
-		DeviceHandlerBase(ioBoardAddress, setObjectId, maxDeviceReplyLen,
-				setDeviceSwitch, deviceCommunication, thermalStatePoolId,
+		DeviceHandlerBase(setObjectId, maxDeviceReplyLen,
+				setDeviceSwitch, deviceCommunication,ioBoardAddress, thermalStatePoolId,
 				thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir), cmdQueueSize), parentId(
 				parent), childHandlerFdir(setObjectId) {
 }
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index bc87422d8..d0f9d8b24 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,11 +16,10 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
-		object_id_t setObjectId, uint32_t maxDeviceReplyLen,
-		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
+DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
+		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
+		object_id_t deviceCommunication, uint32_t ioBoardAddress, uint32_t thermalStatePoolId,
+		uint32_t thermalRequestPoolId, FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
 		SystemObject(setObjectId),ioBoardAddress(ioBoardAddress), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
 		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
 		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 45a87a8aa..2278e1f5d 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -71,10 +71,10 @@ public:
 	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
 	 * @param setDeviceSwitch the switch the device is connected to, for devices using two switches, overwrite getSwitches()
 	 */
-	DeviceHandlerBase(uint32_t ioBoardAddress, object_id_t setObjectId,
+	DeviceHandlerBase(object_id_t setObjectId,
 			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-			object_id_t deviceCommunication, uint32_t thermalStatePoolId =
-					PoolVariableIF::NO_PARAMETER,
+			object_id_t deviceCommunication,uint32_t ioBoardAddress = 0,
+			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = NULL, uint32_t cmdQueueSize = 20);
 
@@ -111,6 +111,21 @@ public:
 		 */
 	virtual ReturnValue_t performOperation(uint8_t counter);
 
+	/**
+	 * Prerequisites to call initialize function without custom implementation:
+	 *   1. The three static framework IDs are set to respective objects in the Factory function
+	 *  	- First ID: Power Switcher ID. Example: PCDU Handler Object
+	 *  	- Second ID: Raw Data Receiver. Example: PUS Service 2 Object
+	 *  	- Third ID: Default FDIR parent ID. Example: ?
+	 *   2. Communication Interface Object for respective device.
+	 *      Example: UART Communication Interface which calls respective UART drivers
+	 *   3. Health table class has been instantiated in Factory
+	 *   4. deviceThermalRequestPoolId and deviceThermalStatePoolId are set to the respective data pool entries.
+	 *   	This is only required if thermal checking is needed. Otherwise, set both variables to
+	 *   	PoolVariableIF::NO_PARAMETER
+	 *
+	 * @return
+	 */
 	virtual ReturnValue_t initialize();
 
 	/**

From 07950b0c2bb9c3822729a225302cb685cb62ea7a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 23 Oct 2019 00:31:45 +0200
Subject: [PATCH 0007/1774] documentation for object manager IF get function

---
 fdir/FailureIsolationBase.cpp   | 7 ++++---
 objectmanager/ObjectManagerIF.h | 7 +++++++
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index 4b7caac53..c65640c27 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -5,9 +5,10 @@
 #include <framework/ipc/QueueFactory.h>
 #include <framework/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) {
+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);
 }
 
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index aca24a24a..9f58f600c 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -78,6 +78,13 @@ public:
 	virtual void printList() = 0;
 };
 
+/**
+ * Used to retrieve Target Interface Pointers of objects.
+ * The object has to implement the SystemObject or SystemObjectIF at the very least,
+ * otherwise NULL will be returned.
+ * @param id
+ * @return NULL or pointer to target interface specified by template object
+ */
 template <typename T>
 T* ObjectManagerIF::get( object_id_t id ) {
 	SystemObjectIF* temp = this->getSystemObject(id);

From 1631e739b8c0b3b7ab0af314309da898df7e2eae Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 23 Oct 2019 12:03:32 +0200
Subject: [PATCH 0008/1774] at91sam9g20 uses custom stdio.c, unsigned long cast
 in sprintf does not seem to work, casting (unsigned int) does, timestamp now
 visible in debug output

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 58065994a..d5ce60568 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -5,6 +5,8 @@
 // to be implemented by bsp
 extern "C" void printChar(const char*);
 
+
+
 int ServiceInterfaceBuffer::overflow(int c) {
 	// Handle output
 	putChars(pbase(), pptr());
@@ -19,16 +21,18 @@ int ServiceInterfaceBuffer::overflow(int c) {
 	return 0;
 }
 
+// custom stdio.c library for at91sam9g20 chip which does not support unsigned long
+// So I cast (unsigned int) on loggerTimes
 int ServiceInterfaceBuffer::sync(void) {
 	if (this->isActive) {
 		Clock::TimeOfDay_t loggerTime;
 		Clock::getDateAndTime(&loggerTime);
 		char preamble[96] = { 0 };
-		sprintf(preamble, "%s: | %lu:%02lu:%02lu.%03lu | ",
-				this->log_message.c_str(), (unsigned long) loggerTime.hour,
-				(unsigned long) loggerTime.minute,
-				(unsigned long) loggerTime.second,
-				(unsigned long) loggerTime.usecond /1000);
+		sprintf(preamble, "%s: | %u:%02u:%02u.%03u | ",
+				this->log_message.c_str(), (unsigned int) loggerTime.hour,
+				(unsigned int)  loggerTime.minute,
+				(unsigned int)  loggerTime.second,
+				(unsigned int)  loggerTime.usecond /1000);
 		// Write log_message and time
 		this->putChars(preamble, preamble + sizeof(preamble));
 		// Handle output

From 8f1517d276aac56dc260b8ea4609204ab8e1036a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 25 Oct 2019 21:12:11 +0200
Subject: [PATCH 0009/1774] additional comments on endianness (I hope this is
 correct)

---
 devicehandlers/DeviceHandlerBase.cpp | 2 --
 serialize/SerializeAdapter.h         | 7 +++++++
 serialize/SerializeIF.h              | 7 +++++++
 3 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d0f9d8b24..4eb9f5049 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -53,7 +53,6 @@ DeviceHandlerBase::~DeviceHandlerBase() {
 
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	this->pstStep = counter;
-
 	if (counter == 0) {
 		cookieInfo.state = COOKIE_UNUSED;
 		readCommandQueue();
@@ -670,7 +669,6 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 	}
 
 	CommandMessage message;
-
 	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&message,
 			getObjectId(), address, isCommand);
 
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 67c37493a..6e2f3e5fb 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -20,6 +20,13 @@
  *
  * The AutoSerializeAdapter functions can also be used as an alternative to memcpy
  * to retrieve data out of a buffer directly into a class variable with data type T while being able to specify endianness.
+ *
+ * In the SOURCE mission , the target architecture is little endian,
+ * so any buffers must be deSerialized with bool bigEndian = false if
+ * the parameters are used in the FSFW.
+ * When serializing for downlink, the packets are generally serialized into big endian for the network when using a TC/UDP client
+ * like seen in TmPacketStored.cpp for example.
+ *
  * \ingroup serialize
  */
 template<typename T, int>
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 50555d379..14f6995e5 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -10,6 +10,13 @@
 
 /**
  * An interface for alle classes which require translation of objects data into data streams and vice-versa.
+ *
+ * In the SOURCE mission , the target architecture is little endian,
+ * so any buffers must be deSerialized with bool bigEndian = false if
+ * the parameters are used in the FSFW.
+ * When serializing for downlink, the packets are generally serialized into big endian for the network when using a TC/UDP client
+ * like seen in TmPacketStored.cpp for example.
+ *
  * \ingroup serialize
  */
 class SerializeIF {

From 64f84d9d9ffbf2d4b357ac72ad24956b8540db07 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 27 Oct 2019 03:21:38 +0100
Subject: [PATCH 0010/1774] doc for dhb, serializeIF and SerializeAdapter

---
 devicehandlers/DeviceCommunicationIF.h |  2 +-
 devicehandlers/DeviceHandlerBase.cpp   | 11 ++++++----
 devicehandlers/DeviceHandlerBase.h     | 11 ++++++----
 serialize/SerializeAdapter.h           | 28 ++++++++++++++++++++++----
 serialize/SerializeIF.h                | 14 +++++++++----
 tmtcservices/PusServiceBase.h          |  4 ++--
 6 files changed, 51 insertions(+), 19 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index e0aca5731..88f0d1240 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -40,7 +40,7 @@ public:
 	virtual void close(Cookie *cookie) = 0;
 
 	//SHOULDDO can data be const?
-	virtual ReturnValue_t sendMessage(Cookie *cookie, uint8_t *data,
+	virtual ReturnValue_t sendMessage(Cookie *cookie,const uint8_t *data,
 			uint32_t len) = 0;
 
 	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4eb9f5049..2f16f8462 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -11,6 +11,7 @@
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <mission/test/DummyCookie.h>
 
 object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
@@ -452,7 +453,7 @@ void DeviceHandlerBase::doGetWrite() {
 		if (wiretappingMode == RAW) {
 			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
 		}
-		//We need to distinguish here, because a raw command never expects a reply. (Could be done in eRIRM, but then child implementations need to be careful.
+		// We need to distinguish here, because a raw command never expects a reply. (Could be done in eRIRM, but then child implementations need to be careful.
 		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
 	} else {
 		//always generate a failure event, so that FDIR knows what's up
@@ -473,9 +474,9 @@ void DeviceHandlerBase::doSendRead() {
 		cookieInfo.state = COOKIE_READ_SENT;
 	} else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
-		//We can't inform anyone, because we don't know which command was sent last.
-		//So, we need to wait for a timeout.
-		//but I think we can allow to ignore one missedReply.
+		// We can't inform anyone, because we don't know which command was sent last.
+		// So, we need to wait for a timeout.
+		// but I think we can allow to ignore one missedReply.
 		ignoreMissedRepliesCount++;
 		cookieInfo.state = COOKIE_UNUSED;
 	}
@@ -1266,3 +1267,5 @@ void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 			executingTask = task_;
 }
+
+
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 2278e1f5d..6abfb675c 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -167,7 +167,7 @@ protected:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
 
 	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5); //!< This is used to specify for replies from a device which are not replies to requests
 	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6);
 //	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
 //	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
@@ -626,9 +626,9 @@ protected:
 	 * @param[out] foundLen length of the packet found
 	 * @return
 	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *     - @c NO_VALID_REPLY no reply could be found starting at @c start, implies @c foundLen is not valid, base class will call scanForReply() again with ++start
-	 *     - @c INVALID_REPLY a packet was found but it is invalid, eg checksum error, implies @c foundLen is valid, can be used to skip some bytes
-	 *     - @c TOO_SHORT @c len is too short for any valid packet
+	 *     - @c RETURN_FAILED no reply could be found starting at @c start, implies @c foundLen is not valid, base class will call scanForReply() again with ++start
+	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid, eg checksum error, implies @c foundLen is valid, can be used to skip some bytes
+	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
 	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
 	 */
 	virtual ReturnValue_t scanForReply(const uint8_t *start, uint32_t len,
@@ -954,6 +954,7 @@ private:
 	 *
 	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
 	 * but not received).
+	 * In case the reply is periodic, the counter is simply set back to a specified value.
 	 */
 	void decrementDeviceReplyMap(void);
 
@@ -1053,6 +1054,8 @@ private:
 	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
+
+
 };
 
 #endif /* DEVICEHANDLERBASE_H_ */
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 6e2f3e5fb..04216c897 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -20,11 +20,31 @@
  *
  * The AutoSerializeAdapter functions can also be used as an alternative to memcpy
  * to retrieve data out of a buffer directly into a class variable with data type T while being able to specify endianness.
+ * The boolean bigEndian specifies the endiness of the data to serialize or deSerialize.
  *
- * In the SOURCE mission , the target architecture is little endian,
- * so any buffers must be deSerialized with bool bigEndian = false if
- * the parameters are used in the FSFW.
- * When serializing for downlink, the packets are generally serialized into big endian for the network when using a TC/UDP client
+ * If the target architecture is little endian (ARM), any data types created might
+ * have the wrong endiness if they are to be used for the FSFW.
+ * there are three ways to retrieve data out of a buffer to be used in the FSFW to use regular aligned (big endian) data.
+ * This can also be applied to uint32_t and uint64_t:
+ *
+ *   1. Use the AutoSerializeAdapter::deSerialize function with bool bigEndian = true:
+ *
+ *   	uint16_t data;
+ *   	int32_t dataLen = sizeof(data);
+ *   	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
+ *
+ *   2. Perform a bitshift operation:
+ *
+ *   	uint16_t data;
+ *   	data = buffer[targetByte1] >> 8 | buffer[targetByte2];
+ *
+ *   3. Memcpy can be used when data is little-endian. Otherwise, endian-swapper has to be used.
+ *
+ *   	uint16_t data;
+ *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
+ *   	data = EndianSwapper::swap(data);
+ *
+ * When serializing for downlink, the packets are generally serialized assuming big endian data format
  * like seen in TmPacketStored.cpp for example.
  *
  * \ingroup serialize
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 14f6995e5..d86349ab5 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -11,10 +11,16 @@
 /**
  * An interface for alle classes which require translation of objects data into data streams and vice-versa.
  *
- * In the SOURCE mission , the target architecture is little endian,
- * so any buffers must be deSerialized with bool bigEndian = false if
- * the parameters are used in the FSFW.
- * When serializing for downlink, the packets are generally serialized into big endian for the network when using a TC/UDP client
+ * If the target architecture is little endian (ARM), any data types created might
+ * have the wrong endiness if they are to be used for the FSFW.
+ * there are three ways to retrieve data out of a buffer to be used in the FSFW to use regular aligned (big endian) data.
+ * This can also be applied to uint32_t and uint64_t:
+ *
+ *   1. Use the @c AutoSerializeAdapter::deSerialize function with @c bigEndian = true
+ *   2. Perform a bitshift operation
+ *   3. @c memcpy can be used when data is little-endian. Otherwise, @c EndianSwapper has to be used.
+ *
+ * When serializing for downlink, the packets are generally serialized assuming big endian data format
  * like seen in TmPacketStored.cpp for example.
  *
  * \ingroup serialize
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 782d375ff..4fe13ca91 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -68,8 +68,8 @@ public:
 	 * It checks for new requests, and, if found, calls handleRequest, sends completion verification messages and deletes
 	 * the TC requests afterwards.
 	 * performService is always executed afterwards.
-	 * @return	- \c RETURN_OK if the periodic performService was successful.
-	 * 			- \c RETURN_FAILED else.
+	 * @return	\c RETURN_OK if the periodic performService was successful.
+	 * 			\c RETURN_FAILED else.
 	 */
 	ReturnValue_t performOperation(uint8_t opCode);
 	virtual uint16_t getIdentifier();

From d79f072851264ec3f9e369f2b2ccbfa7fddd3145 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 27 Oct 2019 13:38:08 +0100
Subject: [PATCH 0011/1774] Additional documentation for DHB and CSB

---
 devicehandlers/DeviceHandlerBase.h   | 19 ++++++----
 tmtcservices/CommandingServiceBase.h | 54 +++++++++++++++++++++++++---
 2 files changed, 62 insertions(+), 11 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 6abfb675c..be488d354 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -33,24 +33,29 @@ class StorageManagerIF;
  * Contains all devices and the DeviceHandlerBase class.
  */
 
-// Robin: We're not really using RMAP, right? Maybe we should adapt class description for that?
+
 /**
  * \brief This is the abstract base class for device handlers.
  *
  * Documentation: Dissertation Baetz p.138,139, p.141-149
- * SpaceWire Remote Memory Access Protocol (RMAP)
  *
- * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink, the RMAP communication and the
- * communication with commanding objects.
+ * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink, communication with
+ * physical devices, using the @link DeviceCommunicationIF, and communication with commanding objects.
+ *
+ * NOTE: RMAP is a legacy 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.
+ *
  * It inherits SystemObject and thus can be created by the ObjectManagerIF.
  *
  * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
- * For each step an RMAP action is selected and executed. If data has been received (eg in case of an RMAP 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 (Read-getRead-write-getWrite) structure,
- * a default implementation is provided.
+ * For each step an RMAP action is selected and executed. 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.
  *
  * 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).
  *
  * \ingroup devices
  */
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index ee59ffe44..f662072fd 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -180,20 +180,65 @@ protected:
 	 */
 	void sendTmPacket(uint8_t subservice, SerializeIF* content,
 			SerializeIF* header = NULL);
+
+	/**
+	 * Check the target subservice
+	 * @param subservice
+	 * @return
+	 */
 	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
 
+	/**
+	 * Once a TC Request is valid, the existence of the destination and its target interface is checked and retrieved.
+	 * The target message queue ID can then be acquired by using the target interface.
+	 * @param subservice
+	 * @param tcData Application Data of TC Packet
+	 * @param tcDataLen
+	 * @param id MessageQueue ID is stored here
+	 * @param objectId
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED
+	 *         - @c CSB or implementation specific return codes
+	 */
+	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, uint32_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) = 0;
+
+	/**
+	 * After the Message Queue and Object ID are determined,
+	 * the command is prepared by using an implementation specific CommandMessage type which is sent to
+	 * the target device. It contains all necessary information for the device to
+	 * execute telecommands.
+	 * @param message
+	 * @param subservice
+	 * @param tcData
+	 * @param tcDataLen
+	 * @param state
+	 * @param objectId
+	 * @return
+	 */
 	virtual ReturnValue_t prepareCommand(CommandMessage *message,
 			uint8_t subservice, const uint8_t *tcData, uint32_t tcDataLen,
 			uint32_t *state, object_id_t objectId) = 0;
 
+	/**
+	 * This function is responsible for the communication between the Command Service Base
+	 * and the respective PUS Commanding Service once the execution has started.
+	 * The PUS Commanding Service receives replies from the target device and forwards them by calling this function.
+	 * There are different translations of these replies to specify how the Command Service proceeds.
+	 * @param reply Command Message which determines how CommandServiceBase proceeds
+	 * @param previousCommand
+	 * @param state
+	 * @param optionalNextCommand
+	 * @param objectId
+	 * @param isStep Flag value to mark steps of command execution
+	 * @return
+	 */
 	virtual ReturnValue_t handleReply(const CommandMessage *reply,
 			Command_t previousCommand, uint32_t *state,
 			CommandMessage *optionalNextCommand, object_id_t objectId,
 			bool *isStep) = 0;
 
-	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, uint32_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) = 0;
 
 	virtual void handleUnrequestedReply(CommandMessage *reply);
 
@@ -209,7 +254,8 @@ private:
 	 * It handles replies generated by the devices and relayed by the specific service implementation.
 	 * This means that it determines further course of action depending on the return values specified
 	 * in the service implementation.
-	 * This includes the generation of TC verification messages:
+	 * This includes the generation of TC verification messages. Note that
+	 * the static framework object ID @c VerificationReporter::messageReceiver needs to be set.
 	 *   - TM[1,5] Step Successs
 	 *   - TM[1,6] Step Failure
 	 *   - TM[1,7] Completion Success

From b51536c772c9d058b7c7a4449f8cf8ca107773ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Oct 2019 12:48:41 +0100
Subject: [PATCH 0012/1774] CSB doc correction

---
 fdir/FailureIsolationBase.h          | 4 ++++
 tmtcservices/CommandingServiceBase.h | 8 +++++---
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index cd582e399..894f63562 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -21,6 +21,10 @@ public:
 			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();
 	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index f662072fd..8ce25f007 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -64,7 +64,7 @@ public:
 	virtual ~CommandingServiceBase();
 
 	/***
-	 * This is the periodic called function
+	 * This is the periodically called function.
 	 * Handle request queue for external commands.
 	 * Handle command Queue for internal commands.
 	 * @param opCode is unused here at the moment
@@ -226,13 +226,15 @@ protected:
 	 * and the respective PUS Commanding Service once the execution has started.
 	 * The PUS Commanding Service receives replies from the target device and forwards them by calling this function.
 	 * There are different translations of these replies to specify how the Command Service proceeds.
-	 * @param reply Command Message which determines how CommandServiceBase proceeds
+	 * @param reply Command Message which contains information about the command
 	 * @param previousCommand
 	 * @param state
 	 * @param optionalNextCommand
 	 * @param objectId
 	 * @param isStep Flag value to mark steps of command execution
-	 * @return
+	 * @return - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to generate TC verification success
+	 *         - @c INVALID_REPLY can handle unrequested replies
+	 *         - Anything else triggers a TC verification failure
 	 */
 	virtual ReturnValue_t handleReply(const CommandMessage *reply,
 			Command_t previousCommand, uint32_t *state,

From 1ee445ce245b0383a3d770b44f971693ff37542f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Oct 2019 11:17:07 +0100
Subject: [PATCH 0013/1774] fifo typo

---
 container/FIFO.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/container/FIFO.h b/container/FIFO.h
index 670a50d74..134da9b80 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -21,7 +21,7 @@ public:
 			readIndex(0), writeIndex(0), currentSize(0) {
 	}
 
-	bool emtpy() {
+	bool empty() {
 		return (currentSize == 0);
 	}
 
@@ -45,7 +45,7 @@ public:
 	}
 
 	ReturnValue_t retrieve(T *value) {
-		if (emtpy()) {
+		if (empty()) {
 			return EMPTY;
 		} else {
 			*value = data[readIndex];

From e8a16ac59cf87d27d1e79a6571a6ee11f0edc3c2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 29 Oct 2019 18:21:01 +0100
Subject: [PATCH 0014/1774] dummy com if sendMessage data const

---
 devicehandlers/DeviceCommunicationIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index e0aca5731..88f0d1240 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -40,7 +40,7 @@ public:
 	virtual void close(Cookie *cookie) = 0;
 
 	//SHOULDDO can data be const?
-	virtual ReturnValue_t sendMessage(Cookie *cookie, uint8_t *data,
+	virtual ReturnValue_t sendMessage(Cookie *cookie,const uint8_t *data,
 			uint32_t len) = 0;
 
 	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;

From 3887cb8ca14f4a12a2fd446e1779b66c76096962 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 29 Oct 2019 18:22:34 +0100
Subject: [PATCH 0015/1774] removed wrong include in dhb

---
 devicehandlers/DeviceHandlerBase.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 2f16f8462..1bb411b7d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -11,7 +11,6 @@
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <mission/test/DummyCookie.h>
 
 object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;

From 16af33a7bb52e3d9363e1e6f61e16a67783f74df Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Oct 2019 19:31:18 +0100
Subject: [PATCH 0016/1774] doc for fifo, device com if..

---
 container/FIFO.h                       |  4 +--
 container/SimpleRingBuffer.h           | 28 +++++++++++++++++++++
 devicehandlers/DeviceCommunicationIF.h | 35 +++++++++++++++++++++++++-
 serialize/SerializeAdapter.h           |  2 ++
 4 files changed, 66 insertions(+), 3 deletions(-)

diff --git a/container/FIFO.h b/container/FIFO.h
index 670a50d74..134da9b80 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -21,7 +21,7 @@ public:
 			readIndex(0), writeIndex(0), currentSize(0) {
 	}
 
-	bool emtpy() {
+	bool empty() {
 		return (currentSize == 0);
 	}
 
@@ -45,7 +45,7 @@ public:
 	}
 
 	ReturnValue_t retrieve(T *value) {
-		if (emtpy()) {
+		if (empty()) {
 			return EMPTY;
 		} else {
 			*value = data[readIndex];
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 6d7d67e1d..45cb09277 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -4,12 +4,40 @@
 #include <framework/container/RingBufferBase.h>
 #include <stddef.h>
 
+/**
+ * Circular buffer implementation, useful for buffering into data streams.
+ * Note that the deleteData() has to be called to increment the read pointer
+ */
 class SimpleRingBuffer: public RingBufferBase<> {
 public:
 	SimpleRingBuffer(uint32_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);
+
+	/**
+	 * 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 = NULL);
+
+	/**
+	 * 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 = NULL);
 private:
 //	static const uint8_t TEMP_READ_PTR = 1;
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 88f0d1240..59420861e 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -4,6 +4,22 @@
 #include <framework/devicehandlers/Cookie.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
+/**
+ * Documentation: Dissertation Baetz p.138
+ *
+ * This is an interface to decouple device communication from
+ * the device handler to allow reuse of these components.
+ * It works with the assumption that received data
+ * is polled by a component. There are four generic steps of device communication:
+ *
+ *   1. Send data to a device
+ *   2. Get acknowledgement for sending
+ *   3. Request reading data from a device
+ *   4. Read received data
+ *
+ *  To identify different connection over a single interface can return so-called cookies to components.
+ *
+ */
 class DeviceCommunicationIF: public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
@@ -39,7 +55,15 @@ public:
 
 	virtual void close(Cookie *cookie) = 0;
 
-	//SHOULDDO can data be const?
+	/**
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return
+	 */
 	virtual ReturnValue_t sendMessage(Cookie *cookie,const uint8_t *data,
 			uint32_t len) = 0;
 
@@ -47,6 +71,15 @@ public:
 
 	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie) = 0;
 
+	/**
+	 * Called by DHB in the GET_WIRTE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return
+	 */
 	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
 			uint32_t *size) = 0;
 
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 04216c897..a0aab9e98 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -28,6 +28,8 @@
  * This can also be applied to uint32_t and uint64_t:
  *
  *   1. Use the AutoSerializeAdapter::deSerialize function with bool bigEndian = true:
+ *		The pointer *buffer will be incremented automatically by the typeSize of data,
+ *		so this function can be called on &buffer without adjusting pointer position
  *
  *   	uint16_t data;
  *   	int32_t dataLen = sizeof(data);

From 46986f69e4a17923717464c120f4d227df561618 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 2 Nov 2019 23:30:12 +0100
Subject: [PATCH 0017/1774] serialize tools more documentation

---
 serialize/SerialBufferAdapter.cpp       |  8 ++++----
 serialize/SerialBufferAdapter.h         |  8 ++++++++
 serialize/SerialFixedArrayListAdapter.h | 11 +++++++++++
 serialize/SerialLinkedListAdapter.h     | 10 +++++++++-
 serialize/SerializeIF.h                 |  6 +++---
 5 files changed, 35 insertions(+), 8 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 3ed083bf5..c5fcfb57e 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -5,15 +5,15 @@
 
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
-		T bufferLength, bool serializeLenght) :
-		serializeLength(serializeLenght), constBuffer(buffer), buffer(NULL), bufferLength(
+		T bufferLength, bool serializeLength) :
+		serializeLength(serializeLength), 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(
+		bool serializeLength) :
+		serializeLength(serializeLength), constBuffer(NULL), buffer(buffer), bufferLength(
 				bufferLength) {
 }
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 7cd75d556..7d192bb45 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -5,6 +5,14 @@
 #include <framework/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<T(will be uint8_t mostly)>> serialBufferElement
+ *
  * \ingroup serialize
  */
 template<typename T>
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 16919b623..821e87104 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -5,6 +5,17 @@
 #include <framework/serialize/SerialArrayListAdapter.h>
 
 /**
+ * This adapter provides an interface for SerializeIF to serialize and deserialize
+ * buffers with a header containing the buffer length.
+ *
+ * Can be used by SerialLinkedListAdapter.
+ *
+ * Buffers with a size header inside that class can be declared with
+ * SerialFixedArrayListAdapter<uint8_t,MAX_BUFFER_LENGTH,typeOfMaxData>.
+ * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows
+ * and MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
+ * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
+ *
  * \ingroup serialize
  */
 template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 44d9e15bc..08d385eec 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -17,12 +17,20 @@
  * An alternative to the AutoSerializeAdapter functions to implement the conversion
  * of object data to data streams or vice-versa, using linked lists.
  *
- * All object members with a datatype are declared as SerializeElement<element_type> inside the class.
+ * All object members with a datatype are declared as SerializeElement<element_type> inside the class
+ * implementing this adapter.
  *
  * Buffers with a size header inside that class can be declared with
  * SerialFixedArrayListAdapter<uint8_t,MAX_BUFFER_LENGTH,typeOfMaxData>.
  * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows
  * and MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
+ * Please note that a direct link from a linked element to a SerialFixedArrayListAdapter element is not possible and a
+ * helper needs to be used by calling <LinkedElement>.setNext(&linkHelper)
+ * and initialising the link helper as linkHelper(&SerialFixedArrayListAdapterElement).
+ *
+ * For buffers with no size header, declare
+ * SerializeElement<SerializeBufferAdapter<T>> and initialise the buffer adapter in the constructor.
+ *
  * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
  *
  * The serialization and deserialization process is done by instantiating the class and
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index d86349ab5..cada1e72a 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -11,14 +11,14 @@
 /**
  * An interface for alle classes which require translation of objects data into data streams and vice-versa.
  *
- * If the target architecture is little endian (ARM), any data types created might
+ * If the target architecture is little endian (e.g. ARM), any data types created might
  * have the wrong endiness if they are to be used for the FSFW.
- * there are three ways to retrieve data out of a buffer to be used in the FSFW to use regular aligned (big endian) data.
+ * There are three ways to retrieve data out of a buffer to be used in the FSFW to use regular aligned (big endian) data.
  * This can also be applied to uint32_t and uint64_t:
  *
  *   1. Use the @c AutoSerializeAdapter::deSerialize function with @c bigEndian = true
  *   2. Perform a bitshift operation
- *   3. @c memcpy can be used when data is little-endian. Otherwise, @c EndianSwapper has to be used.
+ *   3. @c memcpy can be used when data is in little-endian format. Otherwise, @c EndianSwapper has to be used in conjuction.
  *
  * When serializing for downlink, the packets are generally serialized assuming big endian data format
  * like seen in TmPacketStored.cpp for example.

From 8eb1a5b13e2fccf21176aed9a6a27287196fd236 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Nov 2019 00:47:46 +0100
Subject: [PATCH 0018/1774] proposal 1: expectedReplies parameter is set in
 insertInCommandAndReplyMap, default value stays one. overriding
 enableReplyInReplyMap is not necessary anymore.second proposal: the commander
 id is supplied in the interpretDeviceReply function, so we don't have to look
 for it in the DeviceCommandMap. was it removed at some point because it is
 listed in the documentation?

---
 action/ActionHelper.h                  |  2 +-
 devicehandlers/DeviceHandlerBase.cpp   | 32 +++++++++++++++++---------
 devicehandlers/DeviceHandlerBase.h     | 16 ++++++++-----
 modes/ModeHelper.h                     | 13 ++++++++++-
 tmtcservices/CommandingServiceBase.cpp | 11 ++++-----
 5 files changed, 49 insertions(+), 25 deletions(-)

diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index 6ba6dd89b..a72e3654a 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -74,7 +74,7 @@ public:
 protected:
 	static const uint8_t STEP_OFFSET = 1;//!< Increase of value of this per step
 	HasActionsIF* owner;//!< Pointer to the owner
-	MessageQueueIF* queueToUse;//!< Queue to be used as response sender, has to be set with
+	MessageQueueIF* queueToUse;//!< Queue to be used as response sender, has to be set with @c setQueueToUse
 	StorageManagerIF* ipcStore;//!< Pointer to an IPC Store, initialized during construction or initialize(MessageQueueIF* queueToUse_) or with setQueueToUse(MessageQueueIF *queue)
 	/**
 	 *Internal function called by handleActionMessage(CommandMessage* command)
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1bb411b7d..c92cac332 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -255,9 +255,9 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 
 ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
 		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-		uint8_t periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
-//No need to check, as we may try to insert multiple times.
-	insertInCommandMap(deviceCommand);
+		uint8_t periodic, uint8_t expectedReplies, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
+	//No need to check, as we may try to insert multiple times.
+	insertInCommandMap(deviceCommand,expectedReplies);
 	if (hasDifferentReplyId) {
 		return insertInReplyMap(replyId, maxDelayCycles, periodic);
 	} else {
@@ -283,9 +283,9 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
 }
 
 ReturnValue_t DeviceHandlerBase::insertInCommandMap(
-		DeviceCommandId_t deviceCommand) {
+		DeviceCommandId_t deviceCommand, uint8_t expectedReplies) {
 	DeviceCommandInfo info;
-	info.expectedReplies = 0;
+	info.expectedReplies = expectedReplies;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
 	std::pair<std::map<DeviceCommandId_t, DeviceCommandInfo>::iterator, bool> returnValue;
@@ -712,6 +712,7 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 		DeviceCommandId_t foundId, uint32_t foundLen) {
 	ReturnValue_t result;
 	DeviceReplyMap::iterator iter = deviceReplyMap.find(foundId);
+	MessageQueueId_t commander;
 
 	if (iter == deviceReplyMap.end()) {
 		replyRawReplyIfnotWiretapped(receivedData, foundLen);
@@ -728,7 +729,17 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 		} else {
 			info->delayCycles = 0;
 		}
-		result = interpretDeviceReply(foundId, receivedData);
+
+		DeviceCommandMap::iterator commandIter = deviceCommandMap.find(foundId);
+		// could be a reply only packet
+		if(commandIter == deviceCommandMap.end()) {
+			commander = 0;
+		}
+		else {
+			commander = commandIter->second.sendReplyTo;
+		}
+
+		result = interpretDeviceReply(foundId, receivedData,commander);
 		if (result != RETURN_OK) {
 			//Report failed interpretation to FDIR.
 			replyRawReplyIfnotWiretapped(receivedData, foundLen);
@@ -798,7 +809,7 @@ void DeviceHandlerBase::modeChanged(void) {
 }
 
 ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
-		DeviceCommandMap::iterator command, uint8_t expectedReplies,
+		DeviceCommandMap::iterator command,/* uint8_t expectedReplies, */
 		bool useAlternativeId, DeviceCommandId_t alternativeReply) {
 	DeviceReplyMap::iterator iter;
 	if (useAlternativeId) {
@@ -810,7 +821,7 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		DeviceReplyInfo *info = &(iter->second);
 		info->delayCycles = info->maxDelayCycles;
 		info->command = command;
-		command->second.expectedReplies = expectedReplies;
+		// command->second.expectedReplies = expectedReplies;
 		return RETURN_OK;
 	} else {
 		return NO_REPLY_EXPECTED;
@@ -1108,8 +1119,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 
 			// 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);
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper);
 
 		}
 	} else { //unrequested/aperiodic replies
@@ -1122,7 +1132,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 			true);
 		}
 	}
-//Try to cast to DataSet and commit data.
+	//Try to cast to DataSet and commit data.
 	if (!neverInDataPool) {
 		DataSet* dataSet = dynamic_cast<DataSet*>(data);
 		if (dataSet != NULL) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index be488d354..89f965036 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -576,8 +576,9 @@ protected:
 	 *		 			Default is aperiodic (0)
 	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
 	 */
+	// Proposal: Set expected replies for a command in insertInCommandAndReplyMap so we don't have to overwrite enableReplyInReplyMap
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, uint8_t periodic = 0,
+			uint16_t maxDelayCycles, uint8_t periodic = 0, uint8_t expectedReplies = 1,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 	/**
 	 * This is a helper method to insert replies in the reply map.
@@ -594,7 +595,7 @@ protected:
 	 * @param deviceCommand The command to add
 	 * @return RETURN_OK if the command was successfully inserted, RETURN_FAILED else.
 	 */
-	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
+	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand, uint8_t expectedReplies = 1);
 	/**
 	 * This is a helper method to facilitate updating entries in the reply map.
 	 * @param deviceCommand		Identifier of the reply to update.
@@ -644,18 +645,19 @@ protected:
 	 *
 	 * This is called after scanForReply() found a valid packet, it can be assumed that the length and structure is valid.
 	 * This routine extracts the data from the packet into a DataSet and then calls handleDeviceTM(), which either sends
-	 * a TM packet or stores the data in the DataPool depending on whether the it was an external command.
+	 * a TM packet or stores the data in the DataPool depending on whether it was an external command.
 	 * No packet length is given, as it should be defined implicitly by the id.
 	 *
 	 * @param id the id found by scanForReply()
 	 * @param packet
-	 * @param commander the one who initiated the command, is 0 if not external commanded
+	 * @param commander the one who initiated the command, is 0 if not external commanded.
+	 *        UPDATE: This parameter does not exist anymore. Why?
 	 * @return
 	 *     - @c RETURN_OK when the reply was interpreted.
 	 *     - @c RETURN_FAILED when the reply could not be interpreted, eg. logical errors or range violations occurred
 	 */
 	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet) = 0;
+			const uint8_t *packet, MessageQueueId_t commander = 0) = 0;
 
 	/**
 	 * Construct a command reply containing a raw reply.
@@ -723,13 +725,15 @@ protected:
 	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
 	 * 	- A failure code may be returned if something went fundamentally wrong.
 	 *
+	 *
 	 * @param deviceCommand
 	 * @return 	- RETURN_OK if a reply was activated.
 	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an error case as many commands
 	 * 				do not expect a reply.
 	 */
+	// Proposal: Set expected replies in insertInCommandAndReplyMap so we don't have to overwrite that function anymore.
 	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
-			uint8_t expectedReplies = 1, bool useAlternateId = false,
+			/* uint8_t expectedReplies = 0 */ bool useAlternateId = false,
 			DeviceCommandId_t alternateReplyID = 0);
 
 	/**
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index 87f6d4112..b23eb69e5 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -16,11 +16,17 @@ public:
 	ModeHelper(HasModesIF *owner);
 	virtual ~ModeHelper();
 
+	/**
+	 * This is used by DHB to handle all mode messages issued by a service
+	 * @param message
+	 * @return
+	 */
 	ReturnValue_t handleModeCommand(CommandMessage *message);
 
 	/**
 	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @param parentQueue the Queue id of the parent object (assembly or subsystem object).
+	 *        Set to 0 if no parent present
 	 */
 	void setParentQueue(MessageQueueId_t parentQueueId);
 
@@ -28,6 +34,11 @@ public:
 
 	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
 
+	/**
+	 * Used to notify
+	 * @param mode
+	 * @param submode
+	 */
 	void modeChanged(Mode_t mode, Submode_t submode);
 
 	void startTimer(uint32_t timeoutMs);
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index d70b90428..ec65492de 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -11,12 +11,11 @@ CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
 		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
 		uint16_t commandTimeout_seconds, object_id_t setPacketSource,
 		object_id_t setPacketDestination, size_t queueDepth) :
-		SystemObject(setObjectId), apid(apid), service(service), timeout_seconds(
-				commandTimeout_seconds), tmPacketCounter(0), IPCStore(NULL), TCStore(
-		NULL), commandQueue(NULL), requestQueue(NULL), commandMap(
-				numberOfParallelCommands), failureParameter1(0), failureParameter2(
-				0), packetSource(setPacketSource), packetDestination(
-				setPacketDestination),executingTask(NULL) {
+		SystemObject(setObjectId), apid(apid), service(service),
+		timeout_seconds(commandTimeout_seconds), tmPacketCounter(0), IPCStore(NULL),
+		TCStore(NULL), commandQueue(NULL), requestQueue(NULL), commandMap(numberOfParallelCommands),
+		failureParameter1(0), failureParameter2(0), packetSource(setPacketSource),
+		packetDestination(setPacketDestination),executingTask(NULL) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 }

From 12f51575eb42bffc9e2cf5a72a5678975f87db34 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Nov 2019 00:53:05 +0100
Subject: [PATCH 0019/1774] removed a flag by accident, fixed now

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index c92cac332..3018a076f 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1119,7 +1119,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 
 			// 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);
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper, true);
 
 		}
 	} else { //unrequested/aperiodic replies

From cb919ada2a99b818624d05a4e4fdfeb85e9b8174 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Nov 2019 01:55:40 +0100
Subject: [PATCH 0020/1774] assuming that a default value of 0 for
 expectedReplies is needed, I introduced a new variable into
 DeviceCommandInfo, which stores another number of replies expected. this
 value is assigned in enableReplyInReplyMap. That way, the initial value of 0
 remains the same (if it was needed), and is only set to another desired value
 if a write was sent

---
 devicehandlers/DeviceHandlerBase.cpp | 5 +++--
 devicehandlers/DeviceHandlerBase.h   | 9 +++++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 3018a076f..491d792b5 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -285,7 +285,8 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
 ReturnValue_t DeviceHandlerBase::insertInCommandMap(
 		DeviceCommandId_t deviceCommand, uint8_t expectedReplies) {
 	DeviceCommandInfo info;
-	info.expectedReplies = expectedReplies;
+	info.expectedReplies = 0;
+	info.expectedRepliesWhenEnablingReplyMap = expectedReplies;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
 	std::pair<std::map<DeviceCommandId_t, DeviceCommandInfo>::iterator, bool> returnValue;
@@ -821,7 +822,7 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		DeviceReplyInfo *info = &(iter->second);
 		info->delayCycles = info->maxDelayCycles;
 		info->command = command;
-		// command->second.expectedReplies = expectedReplies;
+		command->second.expectedReplies = command->second.expectedRepliesWhenEnablingReplyMap;
 		return RETURN_OK;
 	} else {
 		return NO_REPLY_EXPECTED;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 89f965036..ad4a22035 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -704,7 +704,8 @@ protected:
 
 	struct DeviceCommandInfo {
 		bool isExecuting; //!< Indicates if the command is already executing.
-		uint8_t expectedReplies; //!< Dynamic value to indicate how many replies are expected.
+		uint8_t expectedReplies; //!< Dynamic value to indicate how many replies are expected. Inititated with 0.
+		uint8_t expectedRepliesWhenEnablingReplyMap; //!< Constant value which specifies expected replies when enabling reply map. Inititated in insertInCommandAndReplyMap()
 		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
 	};
 
@@ -732,8 +733,12 @@ protected:
 	 * 				do not expect a reply.
 	 */
 	// Proposal: Set expected replies in insertInCommandAndReplyMap so we don't have to overwrite that function anymore.
+	// Replies are only checked when a write was issued and the default value here was one, so
+	// it should be possible to set this in the DeviceCommandMap with default value one.
+	// UPDATE: The default value of 0 when inserting into command and reply map is retained now by introducing a new
+	// variable in the DeviceCommandInfo which specifies expected replies if this function is called.
 	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
-			/* uint8_t expectedReplies = 0 */ bool useAlternateId = false,
+			/* uint8_t expectedReplies = 1, */ bool useAlternateId = false,
 			DeviceCommandId_t alternateReplyID = 0);
 
 	/**

From e7f7625adf27263aec16580fa70ca137e412aef6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 4 Nov 2019 11:06:59 +0100
Subject: [PATCH 0021/1774] removed wrong include

---
 devicehandlers/DeviceHandlerBase.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 2f16f8462..1bb411b7d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -11,7 +11,6 @@
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <mission/test/DummyCookie.h>
 
 object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;

From b594bc2a9719b6ffb99cb3fdaf4813c688576158 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 5 Nov 2019 19:25:00 +0100
Subject: [PATCH 0022/1774] removed obsolete comment

---
 action/ActionHelper.h                  |  2 +-
 devicehandlers/DeviceHandlerBase.cpp   | 28 ++++++++------------------
 devicehandlers/DeviceHandlerBase.h     | 19 +++++------------
 modes/ModeHelper.h                     | 13 +-----------
 tmtcservices/CommandingServiceBase.cpp | 11 +++++-----
 5 files changed, 21 insertions(+), 52 deletions(-)

diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index a72e3654a..6ba6dd89b 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -74,7 +74,7 @@ public:
 protected:
 	static const uint8_t STEP_OFFSET = 1;//!< Increase of value of this per step
 	HasActionsIF* owner;//!< Pointer to the owner
-	MessageQueueIF* queueToUse;//!< Queue to be used as response sender, has to be set with @c setQueueToUse
+	MessageQueueIF* queueToUse;//!< Queue to be used as response sender, has to be set with
 	StorageManagerIF* ipcStore;//!< Pointer to an IPC Store, initialized during construction or initialize(MessageQueueIF* queueToUse_) or with setQueueToUse(MessageQueueIF *queue)
 	/**
 	 *Internal function called by handleActionMessage(CommandMessage* command)
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 491d792b5..6150954d9 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -255,9 +255,9 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 
 ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
 		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-		uint8_t periodic, uint8_t expectedReplies, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
-	//No need to check, as we may try to insert multiple times.
-	insertInCommandMap(deviceCommand,expectedReplies);
+		uint8_t periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
+//No need to check, as we may try to insert multiple times.
+	insertInCommandMap(deviceCommand);
 	if (hasDifferentReplyId) {
 		return insertInReplyMap(replyId, maxDelayCycles, periodic);
 	} else {
@@ -283,10 +283,9 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
 }
 
 ReturnValue_t DeviceHandlerBase::insertInCommandMap(
-		DeviceCommandId_t deviceCommand, uint8_t expectedReplies) {
+		DeviceCommandId_t deviceCommand) {
 	DeviceCommandInfo info;
 	info.expectedReplies = 0;
-	info.expectedRepliesWhenEnablingReplyMap = expectedReplies;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
 	std::pair<std::map<DeviceCommandId_t, DeviceCommandInfo>::iterator, bool> returnValue;
@@ -713,7 +712,6 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 		DeviceCommandId_t foundId, uint32_t foundLen) {
 	ReturnValue_t result;
 	DeviceReplyMap::iterator iter = deviceReplyMap.find(foundId);
-	MessageQueueId_t commander;
 
 	if (iter == deviceReplyMap.end()) {
 		replyRawReplyIfnotWiretapped(receivedData, foundLen);
@@ -730,17 +728,7 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 		} else {
 			info->delayCycles = 0;
 		}
-
-		DeviceCommandMap::iterator commandIter = deviceCommandMap.find(foundId);
-		// could be a reply only packet
-		if(commandIter == deviceCommandMap.end()) {
-			commander = 0;
-		}
-		else {
-			commander = commandIter->second.sendReplyTo;
-		}
-
-		result = interpretDeviceReply(foundId, receivedData,commander);
+		result = interpretDeviceReply(foundId, receivedData);
 		if (result != RETURN_OK) {
 			//Report failed interpretation to FDIR.
 			replyRawReplyIfnotWiretapped(receivedData, foundLen);
@@ -810,7 +798,7 @@ void DeviceHandlerBase::modeChanged(void) {
 }
 
 ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
-		DeviceCommandMap::iterator command,/* uint8_t expectedReplies, */
+		DeviceCommandMap::iterator command, uint8_t expectedReplies,
 		bool useAlternativeId, DeviceCommandId_t alternativeReply) {
 	DeviceReplyMap::iterator iter;
 	if (useAlternativeId) {
@@ -822,7 +810,7 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		DeviceReplyInfo *info = &(iter->second);
 		info->delayCycles = info->maxDelayCycles;
 		info->command = command;
-		command->second.expectedReplies = command->second.expectedRepliesWhenEnablingReplyMap;
+		command->second.expectedReplies = expectedReplies;
 		return RETURN_OK;
 	} else {
 		return NO_REPLY_EXPECTED;
@@ -1133,7 +1121,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 			true);
 		}
 	}
-	//Try to cast to DataSet and commit data.
+//Try to cast to DataSet and commit data.
 	if (!neverInDataPool) {
 		DataSet* dataSet = dynamic_cast<DataSet*>(data);
 		if (dataSet != NULL) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index ad4a22035..040c21903 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -576,9 +576,8 @@ protected:
 	 *		 			Default is aperiodic (0)
 	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
 	 */
-	// Proposal: Set expected replies for a command in insertInCommandAndReplyMap so we don't have to overwrite enableReplyInReplyMap
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, uint8_t periodic = 0, uint8_t expectedReplies = 1,
+			uint16_t maxDelayCycles, uint8_t periodic = 0,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 	/**
 	 * This is a helper method to insert replies in the reply map.
@@ -595,7 +594,7 @@ protected:
 	 * @param deviceCommand The command to add
 	 * @return RETURN_OK if the command was successfully inserted, RETURN_FAILED else.
 	 */
-	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand, uint8_t expectedReplies = 1);
+	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
 	/**
 	 * This is a helper method to facilitate updating entries in the reply map.
 	 * @param deviceCommand		Identifier of the reply to update.
@@ -645,19 +644,17 @@ protected:
 	 *
 	 * This is called after scanForReply() found a valid packet, it can be assumed that the length and structure is valid.
 	 * This routine extracts the data from the packet into a DataSet and then calls handleDeviceTM(), which either sends
-	 * a TM packet or stores the data in the DataPool depending on whether it was an external command.
+	 * a TM packet or stores the data in the DataPool depending on whether the it was an external command.
 	 * No packet length is given, as it should be defined implicitly by the id.
 	 *
 	 * @param id the id found by scanForReply()
 	 * @param packet
-	 * @param commander the one who initiated the command, is 0 if not external commanded.
-	 *        UPDATE: This parameter does not exist anymore. Why?
 	 * @return
 	 *     - @c RETURN_OK when the reply was interpreted.
 	 *     - @c RETURN_FAILED when the reply could not be interpreted, eg. logical errors or range violations occurred
 	 */
 	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet, MessageQueueId_t commander = 0) = 0;
+			const uint8_t *packet) = 0;
 
 	/**
 	 * Construct a command reply containing a raw reply.
@@ -726,19 +723,13 @@ protected:
 	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
 	 * 	- A failure code may be returned if something went fundamentally wrong.
 	 *
-	 *
 	 * @param deviceCommand
 	 * @return 	- RETURN_OK if a reply was activated.
 	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an error case as many commands
 	 * 				do not expect a reply.
 	 */
-	// Proposal: Set expected replies in insertInCommandAndReplyMap so we don't have to overwrite that function anymore.
-	// Replies are only checked when a write was issued and the default value here was one, so
-	// it should be possible to set this in the DeviceCommandMap with default value one.
-	// UPDATE: The default value of 0 when inserting into command and reply map is retained now by introducing a new
-	// variable in the DeviceCommandInfo which specifies expected replies if this function is called.
 	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
-			/* uint8_t expectedReplies = 1, */ bool useAlternateId = false,
+			uint8_t expectedReplies = 1, bool useAlternateId = false,
 			DeviceCommandId_t alternateReplyID = 0);
 
 	/**
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index b23eb69e5..87f6d4112 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -16,17 +16,11 @@ public:
 	ModeHelper(HasModesIF *owner);
 	virtual ~ModeHelper();
 
-	/**
-	 * This is used by DHB to handle all mode messages issued by a service
-	 * @param message
-	 * @return
-	 */
 	ReturnValue_t handleModeCommand(CommandMessage *message);
 
 	/**
 	 *
-	 * @param parentQueue the Queue id of the parent object (assembly or subsystem object).
-	 *        Set to 0 if no parent present
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
 	 */
 	void setParentQueue(MessageQueueId_t parentQueueId);
 
@@ -34,11 +28,6 @@ public:
 
 	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
 
-	/**
-	 * Used to notify
-	 * @param mode
-	 * @param submode
-	 */
 	void modeChanged(Mode_t mode, Submode_t submode);
 
 	void startTimer(uint32_t timeoutMs);
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index ec65492de..d70b90428 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -11,11 +11,12 @@ CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
 		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
 		uint16_t commandTimeout_seconds, object_id_t setPacketSource,
 		object_id_t setPacketDestination, size_t queueDepth) :
-		SystemObject(setObjectId), apid(apid), service(service),
-		timeout_seconds(commandTimeout_seconds), tmPacketCounter(0), IPCStore(NULL),
-		TCStore(NULL), commandQueue(NULL), requestQueue(NULL), commandMap(numberOfParallelCommands),
-		failureParameter1(0), failureParameter2(0), packetSource(setPacketSource),
-		packetDestination(setPacketDestination),executingTask(NULL) {
+		SystemObject(setObjectId), apid(apid), service(service), timeout_seconds(
+				commandTimeout_seconds), tmPacketCounter(0), IPCStore(NULL), TCStore(
+		NULL), commandQueue(NULL), requestQueue(NULL), commandMap(
+				numberOfParallelCommands), failureParameter1(0), failureParameter2(
+				0), packetSource(setPacketSource), packetDestination(
+				setPacketDestination),executingTask(NULL) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 }

From bf7bc342ff2bb816d910bd2c142661fecd25c867 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 5 Nov 2019 19:30:02 +0100
Subject: [PATCH 0023/1774] Revert "documentation for DHB init function,
 ioBoard addres has default value 0 now, order in ctor changed (not used in
 source)"

This reverts commit c6e34cada64f59757e420347dec8373401d73c7a.
---
 devicehandlers/ChildHandlerBase.cpp  |  4 ++--
 devicehandlers/DeviceHandlerBase.cpp |  9 +++++----
 devicehandlers/DeviceHandlerBase.h   | 21 +++------------------
 3 files changed, 10 insertions(+), 24 deletions(-)

diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index fb9238f7e..50a5c07e5 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -7,8 +7,8 @@ ChildHandlerBase::ChildHandlerBase(uint32_t ioBoardAddress,
 		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		uint32_t parent, FailureIsolationBase* customFdir, uint32_t cmdQueueSize) :
-		DeviceHandlerBase(setObjectId, maxDeviceReplyLen,
-				setDeviceSwitch, deviceCommunication,ioBoardAddress, thermalStatePoolId,
+		DeviceHandlerBase(ioBoardAddress, setObjectId, maxDeviceReplyLen,
+				setDeviceSwitch, deviceCommunication, thermalStatePoolId,
 				thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir), cmdQueueSize), parentId(
 				parent), childHandlerFdir(setObjectId) {
 }
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 6150954d9..def9a7245 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,10 +16,11 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
-		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-		object_id_t deviceCommunication, uint32_t ioBoardAddress, uint32_t thermalStatePoolId,
-		uint32_t thermalRequestPoolId, FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
+DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
+		object_id_t setObjectId, uint32_t maxDeviceReplyLen,
+		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
 		SystemObject(setObjectId),ioBoardAddress(ioBoardAddress), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
 		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
 		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 040c21903..03e35727e 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -76,10 +76,10 @@ public:
 	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
 	 * @param setDeviceSwitch the switch the device is connected to, for devices using two switches, overwrite getSwitches()
 	 */
-	DeviceHandlerBase(object_id_t setObjectId,
+	DeviceHandlerBase(uint32_t ioBoardAddress, object_id_t setObjectId,
 			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-			object_id_t deviceCommunication,uint32_t ioBoardAddress = 0,
-			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
+			object_id_t deviceCommunication, uint32_t thermalStatePoolId =
+					PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = NULL, uint32_t cmdQueueSize = 20);
 
@@ -116,21 +116,6 @@ public:
 		 */
 	virtual ReturnValue_t performOperation(uint8_t counter);
 
-	/**
-	 * Prerequisites to call initialize function without custom implementation:
-	 *   1. The three static framework IDs are set to respective objects in the Factory function
-	 *  	- First ID: Power Switcher ID. Example: PCDU Handler Object
-	 *  	- Second ID: Raw Data Receiver. Example: PUS Service 2 Object
-	 *  	- Third ID: Default FDIR parent ID. Example: ?
-	 *   2. Communication Interface Object for respective device.
-	 *      Example: UART Communication Interface which calls respective UART drivers
-	 *   3. Health table class has been instantiated in Factory
-	 *   4. deviceThermalRequestPoolId and deviceThermalStatePoolId are set to the respective data pool entries.
-	 *   	This is only required if thermal checking is needed. Otherwise, set both variables to
-	 *   	PoolVariableIF::NO_PARAMETER
-	 *
-	 * @return
-	 */
 	virtual ReturnValue_t initialize();
 
 	/**

From 801bd4d7ebce3ce32eab46e561dec5bc95401c4a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 Nov 2019 13:07:26 +0100
Subject: [PATCH 0024/1774] debug interface for dhb created. This is useful to
 track states or values in child handler. some documentation added. New
 doxygen group for interfaced added.

---
 action/HasActionsIF.h                |  6 +++++-
 devicehandlers/DeviceHandlerBase.cpp |  8 ++++++--
 devicehandlers/DeviceHandlerBase.h   | 12 ++++++++++++
 events/EventManager.cpp              |  7 ++++---
 modes/ModeHelper.cpp                 |  2 +-
 power/PowerSwitchIF.h                |  9 +++++++--
 6 files changed, 35 insertions(+), 9 deletions(-)

diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index f30fcb45e..4d66ad1f6 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -7,8 +7,10 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 /**
- * \brief Interface for component which uses actions
+ * @brief
+ * Interface for component which uses actions
  *
+ * @details
  * This interface is used to execute actions in the component. Actions, in the sense of this interface, are activities with a well-defined beginning and
  * end in time. They may adjust sub-states of components, but are not supposed to change
  * the main mode of operation, which is handled with the HasModesIF described below.
@@ -23,6 +25,8 @@
  * parameters and immediately start execution of the action. It is, however, not required to
  * immediately finish execution. Instead, this may be deferred to a later point in time, at
  * which the component needs to inform the caller about finished or failed execution.
+ *
+ * \ingroup interfaces
  */
 class HasActionsIF {
 public:
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index def9a7245..35a987f33 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -834,8 +834,9 @@ ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
 	if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
 		while (numberOfSwitches > 0) {
-			if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1])
-					== PowerSwitchIF::SWITCH_OFF) {
+			if (powerSwitcher-> getSwitchState(switches[numberOfSwitches - 1])
+				== PowerSwitchIF::SWITCH_OFF)
+			{
 				return PowerSwitchIF::SWITCH_OFF;
 			}
 			numberOfSwitches--;
@@ -1267,4 +1268,7 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 			executingTask = task_;
 }
 
+void DeviceHandlerBase::debugInterface(uint8_t positionTracker) {
+}
+
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 03e35727e..4938e0196 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -553,6 +553,18 @@ protected:
 	 */
 	virtual void fillCommandAndReplyMap() = 0;
 
+
+	/**
+	 * @brief   Can be implemented by child handler to
+	 *          perform debugging
+	 * @details Example: Calling this in performOperation
+	 *          to track values like mode. An optional position tracker can be supplied
+	 *          to provide the child handler a way to know where the debugInterface was called
+	 *
+	 * Please delete all debugInterface calls in DHB after debugging is finished !
+	 */
+	virtual void debugInterface(uint8_t positionTracker = 0);
+
 	/**
 	 * This is a helper method to facilitate inserting entries in the command map.
 	 * @param deviceCommand	Identifier of the command to add.
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 01334bac9..46c537520 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -137,9 +137,10 @@ void EventManager::printEvent(EventMessage* message) {
 			error << "0x" << std::hex << message->getReporter() << std::dec;
 		}
 		error << " reported " << translateEvents(message->getEvent()) << " ("
-				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
-				<< message->getParameter1() << " P2: 0x"
-				<< message->getParameter2() << std::dec << std::endl;
+				<< std::dec << message->getEventId() << ") " << std::endl;
+
+		error << std::hex << "P1 Hex: 0x" << message->getParameter1() << ", P1 Dec: " << std::dec << message->getParameter1() << std::endl;
+		error << std::hex << "P2 Hex: 0x" << message->getParameter2() << ", P2 Dec: " <<  std::dec << message->getParameter2() << std::endl;
 		break;
 	}
 
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index 7b98bdc64..d9266c354 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,6 +1,7 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/modes/ModeHelper.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 ModeHelper::ModeHelper(HasModesIF *owner) :
 		theOneWhoCommandedAMode(0), commandedMode(HasModesIF::MODE_OFF), commandedSubmode(
@@ -42,7 +43,6 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
 		}
 
 		countdown.setTimeout(timeout);
-
 		owner->startTransition(mode, submode);
 	}
 		break;
diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h
index 1c4c06f7f..f25589c4d 100644
--- a/power/PowerSwitchIF.h
+++ b/power/PowerSwitchIF.h
@@ -11,8 +11,13 @@
 #include <framework/events/Event.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 /**
- * This interface defines a connection to a device that is capable of turning on and off
- * switches of devices identified by a switch ID.
+ *
+ * @brief   This interface defines a connection to a device that is capable of turning on and off
+ *          switches of devices identified by a switch ID.
+ * @details The virtual functions of this interface do not allow to make any assignments
+ *          because they can be called asynchronosuly (const ending).
+ *
+ * @ingroup interfaces
  */
 class PowerSwitchIF : public HasReturnvaluesIF {
 public:

From ee765eafc766d9a4a1053d3d685d7d63e6f9f95f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 Nov 2019 13:17:54 +0100
Subject: [PATCH 0025/1774] ioBoardAddress renamed to logicalAddress

---
 devicehandlers/DeviceHandlerBase.cpp | 8 ++++----
 devicehandlers/DeviceHandlerBase.h   | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 35a987f33..fd8d61410 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,12 +16,12 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
+DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
 		object_id_t setObjectId, uint32_t maxDeviceReplyLen,
 		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
-		SystemObject(setObjectId),ioBoardAddress(ioBoardAddress), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
+		SystemObject(setObjectId),logicalAddress(logicalAddress_), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
 		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
 		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		requestedRawTraffic(0), powerSwitcher(NULL), IPCStore(NULL),
@@ -589,7 +589,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return RETURN_FAILED;
 	}
 
-	result = communicationInterface->open(&cookie, ioBoardAddress,
+	result = communicationInterface->open(&cookie, logicalAddress,
 			maxDeviceReplyLen);
 	if (result != RETURN_OK) {
 		return result;
@@ -750,7 +750,7 @@ ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
 			DeviceCommunicationIF>(newChannelId);
 
 	if (newCommunication != NULL) {
-		ReturnValue_t result = newCommunication->reOpen(cookie, ioBoardAddress,
+		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
 				maxDeviceReplyLen);
 		if (result != RETURN_OK) {
 			return result;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 4938e0196..8f7f065a4 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -76,7 +76,7 @@ public:
 	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
 	 * @param setDeviceSwitch the switch the device is connected to, for devices using two switches, overwrite getSwitches()
 	 */
-	DeviceHandlerBase(uint32_t ioBoardAddress, object_id_t setObjectId,
+	DeviceHandlerBase(uint32_t logicalAddress, object_id_t setObjectId,
 			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 			object_id_t deviceCommunication, uint32_t thermalStatePoolId =
 					PoolVariableIF::NO_PARAMETER,
@@ -149,7 +149,7 @@ protected:
 	/**
 	* cached from ctor for initialize()
 	*/
-	const uint32_t ioBoardAddress;
+	const uint32_t logicalAddress;
 
 	/**
 	 * The Returnvalues id of this class, required by HasReturnvaluesIF

From 537e2ceb18ddd360176fddec37331bb952f8c674 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 Nov 2019 13:29:12 +0100
Subject: [PATCH 0026/1774] Getter method for logicalAddress

---
 devicehandlers/DeviceHandlerBase.cpp |  9 ++++++---
 devicehandlers/DeviceHandlerBase.h   | 17 +++++++++++------
 2 files changed, 17 insertions(+), 9 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index fd8d61410..09c27c87d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -21,7 +21,7 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
 		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
-		SystemObject(setObjectId),logicalAddress(logicalAddress_), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
+		SystemObject(setObjectId), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
 		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
 		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		requestedRawTraffic(0), powerSwitcher(NULL), IPCStore(NULL),
@@ -31,7 +31,7 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
 		modeHelper(this), parameterHelper(this), childTransitionFailure(RETURN_OK),
 		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
 		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
-		executingTask(NULL), actionHelper(this, NULL), cookieInfo(),
+		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), logicalAddress(logicalAddress_),
 		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
 		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
@@ -1018,6 +1018,7 @@ void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
 	}
 }
 
+
 ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		CommandMessage * message) {
 	ReturnValue_t result;
@@ -1271,4 +1272,6 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 void DeviceHandlerBase::debugInterface(uint8_t positionTracker) {
 }
 
-
+uint32_t DeviceHandlerBase::getLogicalAddress() {
+	return logicalAddress;
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 8f7f065a4..4c83b230d 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -146,11 +146,6 @@ public:
 	 */
 	virtual  void setTaskIF(PeriodicTaskIF* task_);
 protected:
-	/**
-	* cached from ctor for initialize()
-	*/
-	const uint32_t logicalAddress;
-
 	/**
 	 * The Returnvalues id of this class, required by HasReturnvaluesIF
 	 */
@@ -763,6 +758,11 @@ protected:
 	 */
 	virtual bool dontCheckQueue();
 
+	/**
+	 * Used to retrieve logical address
+	 * @return
+	 */
+	virtual uint32_t getLogicalAddress();
 	Mode_t getBaseMode(Mode_t transitionMode);
 
 	bool isAwaitingReply();
@@ -775,7 +775,6 @@ protected:
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 	virtual void setToExternalControl();
 	virtual void announceMode(bool recursive);
-
 	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
 	/**
@@ -862,6 +861,8 @@ protected:
 
 private:
 
+
+
 	/**
 	 * State a cookie is in.
 	 *
@@ -892,6 +893,10 @@ private:
 	 */
 	CookieInfo cookieInfo;
 
+	/**
+	* cached from ctor for initialize()
+	*/
+	const uint32_t logicalAddress;
 
 	/**
 	 * Used for timing out mode transitions.

From b8af3b5e3df66e67c8fa7e0e99b6d5b2554deef4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 Nov 2019 18:15:45 +0100
Subject: [PATCH 0027/1774] debugInterface extended

---
 devicehandlers/DeviceHandlerBase.cpp | 14 +++++++-------
 devicehandlers/DeviceHandlerBase.h   |  9 +++++----
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 09c27c87d..92232e3d4 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -33,14 +33,15 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
 		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
 		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), logicalAddress(logicalAddress_),
 		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
-			CommandMessage::MAX_MESSAGE_SIZE);
+		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
+{
+	commandQueue = QueueFactory::instance()->
+			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
 	if (this->fdirInstance == NULL) {
-		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
-				defaultFDIRParentId);
+		this->fdirInstance =
+				new DeviceHandlerFailureIsolation(setObjectId, defaultFDIRParentId);
 	}
 }
 
@@ -468,7 +469,6 @@ void DeviceHandlerBase::doGetWrite() {
 
 void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
-
 	result = communicationInterface->requestReceiveMessage(cookie);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
@@ -1269,7 +1269,7 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 			executingTask = task_;
 }
 
-void DeviceHandlerBase::debugInterface(uint8_t positionTracker) {
+void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t objectId, uint32_t parameter) {
 }
 
 uint32_t DeviceHandlerBase::getLogicalAddress() {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 4c83b230d..c50823d92 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -553,12 +553,13 @@ protected:
 	 * @brief   Can be implemented by child handler to
 	 *          perform debugging
 	 * @details Example: Calling this in performOperation
-	 *          to track values like mode. An optional position tracker can be supplied
-	 *          to provide the child handler a way to know where the debugInterface was called
-	 *
+	 *          to track values like mode.
+	 * @param positionTracker Provide the child handler a way to know where the debugInterface was called
+	 * @param objectId Provide the child handler object Id to specify actions for spefic devices
+	 * @param parameter Supply a parameter of interest
 	 * Please delete all debugInterface calls in DHB after debugging is finished !
 	 */
-	virtual void debugInterface(uint8_t positionTracker = 0);
+	virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0, uint32_t parameter = 0);
 
 	/**
 	 * This is a helper method to facilitate inserting entries in the command map.

From 2b44e1c9c4aa5e516114a6adb922e860c5044417 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 10 Nov 2019 13:08:02 +0100
Subject: [PATCH 0028/1774] CCSDS sscanf function adapted for atmel stdio.c
 (see comments)

---
 timemanager/CCSDSTime.cpp | 43 +++++++++++++++++++++++----------------
 1 file changed, 26 insertions(+), 17 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 320327161..2eb6c4b54 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -154,32 +154,41 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	if (length < 19) {
 		return RETURN_FAILED;
 	}
-	uint16_t year;
-	uint8_t month;
-	uint16_t day;
-	uint8_t hour;
-	uint8_t minute;
-	float second;
-//try Code A (yyyy-mm-dd)
-	int count = sscanf((char *) from, "%4hi-%2hhi-%2hiT%2hhi:%2hhi:%fZ", &year,
-			&month, &day, &hour, &minute, &second);
-	if (count == 6) {
+	// In the size optimized nano library used by ATMEL, floating point conversion
+	// is not allowed. There is a linker flag to allow it apparently, but I
+	// could not manage to make it run (removing -specs=nano.specs in linker flags works though,
+	// but we propably should include this). Using floats with sscanf is also expensive.
+	// Furthermore, the stdio.c library by ATMEL can't resolve the %hhi specifiers
+	// Therefore, I adapted this function.
+	int year;
+	int month;
+	int day;
+	int hour;
+	int minute;
+	int second;
+	int usecond;
+	// try Code A (yyyy-mm-dd)
+	//int count = sscanf((char *) from, "%4hi-%2hi-%2hiT%2hi:%2hi:%fZ", &year,
+	//		&month, &day, &hour, &minute, &second);
+	int count = sscanf((char *) from, "%4d-%2d-%2dT%2d:%2d:%2d.%dZ", &year,
+				&month, &day, &hour, &minute, &second, &usecond);
+	if (count == 7) {
 		to->year = year;
 		to->month = month;
 		to->day = day;
 		to->hour = hour;
 		to->minute = minute;
 		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
+		to->usecond = usecond;//(second - floor(second)) * 1000000;
 		return RETURN_OK;
 	}
 
-	//try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4hi-%3hiT%2hhi:%2hhi:%fZ", &year, &day,
-			&hour, &minute, &second);
-	if (count == 5) {
+	// try Code B (yyyy-ddd)
+	count = sscanf((char *) from, "%4i-%3iT%2i:%2i:%2i.%iZ", &year, &day,
+			&hour, &minute, &second, &usecond);
+	if (count == 6) {
 		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear((uint16_t)day,(uint16_t) year,(uint8_t *) &month,
 				&tempDay);
 		if (result != RETURN_OK) {
 			return RETURN_FAILED;
@@ -190,7 +199,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		to->hour = hour;
 		to->minute = minute;
 		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
+		to->usecond = usecond;
 		return RETURN_OK;
 	}
 

From 2f14fd5d4d67d2b8223b115d2c5d421cccecffb5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Nov 2019 22:45:53 +0100
Subject: [PATCH 0029/1774] Cant reach mode reason getter function added

---
 modes/ModeMessage.cpp | 4 ++++
 modes/ModeMessage.h   | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/modes/ModeMessage.cpp b/modes/ModeMessage.cpp
index 62fea7e43..1d3baad54 100644
--- a/modes/ModeMessage.cpp
+++ b/modes/ModeMessage.cpp
@@ -16,6 +16,10 @@ ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t com
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
+	return message->getParameter();
+}
+
 void ModeMessage::clear(CommandMessage* message) {
 	message->setCommand(CommandMessage::CMD_NONE);
 }
diff --git a/modes/ModeMessage.h b/modes/ModeMessage.h
index fad347264..0a72aee04 100644
--- a/modes/ModeMessage.h
+++ b/modes/ModeMessage.h
@@ -24,6 +24,7 @@ public:
 	static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);	//!> Unrequested info about the current mode (used for composites to inform their container of a changed mode)
 	static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04); //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
 	//SHOULDDO is there a way we can transmit a returnvalue when responding that the mode is wrong, so we can give a nice failure code when commanded by PUS?
+	// shouldn't that possible with parameter 2 when submode only takes 1 byte?
 	static const Command_t REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);//!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded and a transition started but was aborted; the parameters contain the mode that was reached
 	static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);//!> Command to read the current mode and reply with a REPLY_MODE_REPLY
 	static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);//!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
@@ -34,6 +35,7 @@ public:
 	static ReturnValue_t setModeMessage(CommandMessage* message,
 			Command_t command, Mode_t mode, Submode_t submode);
 	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
+	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
 	static void clear(CommandMessage* message);
 };
 

From 2039aa56658923cb4127fddb409c251fdb8d55af Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 Nov 2019 00:14:39 +0100
Subject: [PATCH 0030/1774] Service Interface Stream buffer size higher to
 print long buffers (like nav data)

---
 serviceinterface/ServiceInterfaceBuffer.h |  2 +-
 tmtcservices/PusServiceBase.cpp           | 10 +++++-----
 tmtcservices/PusServiceBase.h             |  2 +-
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index b42c8a197..9a5f4ef8e 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ private:
 	typedef std::char_traits<char> Traits;
 
 	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 128;
+	static size_t const BUF_SIZE = 255;
 	char buf[BUF_SIZE];
 
 	// In this function, the characters are parsed.
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index c8f6accf8..6e1053252 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -23,14 +23,14 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
 	TmTcMessage message;
 	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
 		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
-		//	debug << "PusServiceBase::performOperation: Receiving from MQ ID: " << std::hex << this->requestQueue.getId() << std::dec << " returned: " << status << std::endl;
+		//	debug << "PusServiceBase::performOperation: Receiving from MQ ID: " << std::hex << this->requestQueue.getId()
+		// << std::dec << " returned: " << status << std::endl;
 		if (status == RETURN_OK) {
 			this->currentPacket.setStoreAddress(message.getStorageId());
-//			info << "Service " << (uint16_t) this->serviceId << ": new packet!"
-//					<< std::endl;
+			//	info << "Service " << (uint16_t) this->serviceId << ": new packet!" << std::endl;
 
 			ReturnValue_t return_code = this->handleRequest();
-			//		debug << "Service " << (uint16_t)this->serviceId << ": handleRequest returned: " << (int)return_code << std::endl;
+			// debug << "Service " << (uint16_t)this->serviceId << ": handleRequest returned: " << (int)return_code << std::endl;
 			if (return_code == RETURN_OK) {
 				this->verifyReporter.sendSuccessReport(
 						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
@@ -44,7 +44,7 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
 			errorParameter2 = 0;
 		} else if (status == MessageQueueIF::EMPTY) {
 			status = RETURN_OK;
-			//		debug << "PusService " << (uint16_t)this->serviceId << ": no new packet." << std::endl;
+			// debug << "PusService " << (uint16_t)this->serviceId << ": no new packet." << std::endl;
 			break;
 		} else {
 
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 4fe13ca91..2b5e8b67c 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -52,7 +52,7 @@ public:
 	 * Success or Failure Reports are generated automatically after execution of this method.
 	 * If a Telecommand can not be executed within one call cycle, this Base class is not the right parent.
 	 * The child class may add additional error information in #errorParameters which are attached to the generated
-	 * verification message.
+	 * verification message. Subservice checking should be implemented in this method.
 	 * @return	The returned status_code is directly taken as main error code in the Verification Report.
 	 * 			On success, RETURN_OK shall be returned.
 	 */

From 10c24e39a31293ba54ee8bfdbb2f3835b91dad9e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 Nov 2019 19:56:05 +0100
Subject: [PATCH 0031/1774] new returnvalue for scanForReply to ignore full
 packet

---
 devicehandlers/DeviceCommunicationIF.h |  6 ++++--
 devicehandlers/DeviceHandlerBase.cpp   |  2 ++
 devicehandlers/DeviceHandlerBase.h     | 14 +++++++++-----
 3 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 59420861e..10ad27760 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -62,7 +62,8 @@ public:
 	 * @param cookie
 	 * @param data
 	 * @param len
-	 * @return
+	 * @return @c RETURN_OK for successfull send
+	 *         Everything else triggers sending failed event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t sendMessage(Cookie *cookie,const uint8_t *data,
 			uint32_t len) = 0;
@@ -78,7 +79,8 @@ public:
 	 * @param cookie
 	 * @param data
 	 * @param len
-	 * @return
+	 * @return @c RETURN_OK for successfull receive
+	 *         Everything else triggers receiving failed with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
 			uint32_t *size) = 0;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 92232e3d4..0b35effd5 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -537,6 +537,8 @@ void DeviceHandlerBase::doGetRead() {
 				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);
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index c50823d92..b5ffa2eec 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -153,7 +153,8 @@ protected:
 
 	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(4);
 	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5); //!< This is used to specify for replies from a device which are not replies to requests
-	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6); //!< Ignore parts of the received packet
+	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(7); //!< Ignore full received packet
 //	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
 //	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
 	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(10);
@@ -607,6 +608,7 @@ protected:
 	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
 	 */
 	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
+
 	/**
 	 * Scans a buffer for a valid reply.
 	 *
@@ -618,15 +620,17 @@ protected:
 	 * Errors should be reported directly, the base class does NOT report any errors based on the return
 	 * value of this function.
 	 *
-	 * @param start start of data
-	 * @param len length of data
-	 * @param[out] foundId the id of the packet starting at @c start
-	 * @param[out] foundLen length of the packet found
+	 * @param start start of remaining buffer to be scanned
+	 * @param len length of remaining buffer to be scanned
+	 * @param[out] foundId the id of the data found in the buffer.
+	 * @param[out] foundLen length of the data found. Is to be set in function, buffer is scanned at previous position + foundLen.
 	 * @return
 	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
 	 *     - @c RETURN_FAILED no reply could be found starting at @c start, implies @c foundLen is not valid, base class will call scanForReply() again with ++start
 	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid, eg checksum error, implies @c foundLen is valid, can be used to skip some bytes
 	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
+	 *     - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of the packet
+	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
 	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
 	 */
 	virtual ReturnValue_t scanForReply(const uint8_t *start, uint32_t len,

From 37a70df24496dd0924969c4f52c960ed80d5a1d1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 1 Dec 2019 17:48:05 +0100
Subject: [PATCH 0032/1774] SerialBufferAdapter can process uint32_t * buffers
 now

---
 datapool/DataPool.h                     |  2 +-
 internalError/InternalErrorReporter.cpp |  7 +++---
 serialize/SerialBufferAdapter.cpp       | 13 ++++++++--
 serialize/SerialBufferAdapter.h         | 33 ++++++++++++++++++++++---
 4 files changed, 44 insertions(+), 11 deletions(-)

diff --git a/datapool/DataPool.h b/datapool/DataPool.h
index 6e38dc1b9..a9af8af0b 100644
--- a/datapool/DataPool.h
+++ b/datapool/DataPool.h
@@ -29,7 +29,7 @@
  *	\brief		This class represents the OBSW global data-pool.
  *
  *	\details	All variables are registered and space is allocated in an initialization
- *				function, which is passed do the constructor.
+ *				function, which is passed to the constructor.
  *				Space for the variables is allocated on the heap (with a new call).
  *				The data is found by a data pool id, which uniquely represents a variable.
  *				Data pool variables should be used with a blackboard logic in mind,
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 9a8ede002..81c4a0e58 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -8,10 +8,9 @@
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
 		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
-		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId), tmPoolId(
-				tmPoolId), storePoolId(
-				storePoolId), queueHits(0), tmHits(0), storeHits(
-				0) {
+		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
+		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
+		storeHits(0) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index c5fcfb57e..9a8e6f069 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,8 +1,6 @@
 #include <framework/serialize/SerialBufferAdapter.h>
 #include <cstring>
 
-
-
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
 		T bufferLength, bool serializeLength) :
@@ -17,6 +15,13 @@ SerialBufferAdapter<T>::SerialBufferAdapter(uint8_t* buffer, T bufferLength,
 				bufferLength) {
 }
 
+template<typename T>
+SerialBufferAdapter<T>::SerialBufferAdapter(uint32_t* buffer,
+		T bufferLength, bool serializeLength) :
+		serializeLength(serializeLength), constBuffer(NULL), buffer(reinterpret_cast<uint8_t *>(buffer)),
+		bufferLength(bufferLength*4) {
+}
+
 template<typename T>
 SerialBufferAdapter<T>::~SerialBufferAdapter() {
 }
@@ -86,6 +91,10 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 	}
 }
 
+template<typename T>
+uint8_t * SerialBufferAdapter<T>::getBuffer() {
+	return buffer;
+}
 
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 7d192bb45..7496c1376 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -11,16 +11,39 @@
  * 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<T(will be uint8_t mostly)>> serialBufferElement
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>> serialBufferElement
  *
  * \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);
+	/**
+	 * 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, T bufferLength, bool serializeLength = false);
+
+	/**
+	 * Constructoor 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
+	 */
+	SerialBufferAdapter(uint8_t* buffer, T bufferLength, bool serializeLength = false);
+
+	/**
+	 * Constructoor for non-constant uint32_t buffer. Length field can be serialized optionally.
+	 * Type of length can be supplied as template type.
+	 * @param buffer
+	 * @param bufferLength
+	 * @param serializeLength
+	 */
+	SerialBufferAdapter(uint32_t* buffer,T bufferLength, bool serializeLength = false);
 
 	virtual ~SerialBufferAdapter();
 
@@ -31,6 +54,8 @@ public:
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
+
+	uint8_t * getBuffer();
 private:
 	bool serializeLength;
 	const uint8_t *constBuffer;

From 9c3a9323b7ee50685fd23b57c9d1b39445c43a18 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 3 Dec 2019 19:30:37 +0100
Subject: [PATCH 0033/1774] some doc change proposals while writing hk service.
 Added Type.h in PoolRawAccess.h, compiler error when not doing that

---
 datapool/PoolRawAccess.h             |  6 +--
 datapool/PoolVariable.h              |  3 +-
 devicehandlers/DeviceHandlerBase.h   | 63 ++++++++++++++--------------
 objectmanager/ObjectManagerIF.h      |  6 +--
 tmtcservices/AcceptsTelecommandsIF.h |  2 +-
 5 files changed, 38 insertions(+), 42 deletions(-)

diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 3e2bd7ae3..9a3000c0e 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -3,6 +3,7 @@
 
 #include <framework/datapool/DataSetIF.h>
 #include <framework/datapool/PoolVariableIF.h>
+#include <framework/globalfunctions/Type.h>
 
 /**
  * This class allows accessing Data Pool variables as raw bytes.
@@ -79,9 +80,8 @@ public:
 	~PoolRawAccess();
 	/**
 	 * \brief	This operation returns a pointer to the entry fetched.
-	 * \details	This means, it does not return a pointer to byte "index", but to the start byte of
-	 * 			array entry "index". Example: If the original data pool array consists of an double
-	 * 			array of size four, getEntry(1) returns &(this->value[8]).
+	 * \details	Return pointer to the buffer containing the raw data
+	 *          Size and number of data can be retrieved by other means.
 	 */
 	uint8_t* getEntry();
 	/**
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index 25345c0ac..2c48ca3e1 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -112,8 +112,7 @@ public:
 	 * 					corresponds to.
 	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
 	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
+	 * \param setReadWriteMode
 	 */
 	PoolVariable(uint32_t set_id, DataSetIF* dataSet,
 			ReadWriteMode_t setReadWriteMode) :
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index b5ffa2eec..d489ada1c 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -35,14 +35,14 @@ class StorageManagerIF;
 
 
 /**
- * \brief This is the abstract base class for device handlers.
- *
+ * @brief This is the abstract base class for device handlers.
+ * @details
  * Documentation: Dissertation Baetz p.138,139, p.141-149
  *
  * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink, communication with
  * physical devices, using the @link DeviceCommunicationIF, and communication with commanding objects.
  *
- * NOTE: RMAP is a legacy standard which is used for FLP.
+ * 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.
  *
@@ -57,7 +57,7 @@ class StorageManagerIF;
  * 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).
  *
- * \ingroup devices
+ * @ingroup devices
  */
 class DeviceHandlerBase: public DeviceHandlerIF,
 		public HasReturnvaluesIF,
@@ -87,33 +87,34 @@ public:
 
 
 	/**
-		 * This function is the device handler base core component and is called periodically.
-		 * General sequence:
-		 * If the State is SEND_WRITE:
-		 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
-		 *   2. Handles Device State Modes by calling doStateMachine().
-		 *      This function calls callChildStatemachine() which calls the abstract functions
-		 *      doStartUp() and doShutDown()
-		 *   3. Check switch states by calling checkSwitchStates()
-		 *   4. Decrements counter for timeout of replies by calling decrementDeviceReplyMap()
-		 *   5. Performs FDIR check for failures
-		 *   6. Calls hkSwitcher.performOperation()
-		 *   7. If the device mode is MODE_OFF, return RETURN_OK. Otherwise, perform the Action property
-		 *   	and performs depending on value specified
-		 *      by input value counter. The child class tells base class what to do by setting this value.
-		 *     - SEND_WRITE: Send data or commands to device by calling doSendWrite() which calls
-		 *       sendMessage function of #communicationInterface
-		 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
-		 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite() which calls
-		 *       getSendSuccess of #communicationInterface.
-		 *       Calls abstract functions scanForReply() and interpretDeviceReply().
-		 *     - SEND_READ: Request reading data from device by calling doSendRead() which calls
-		 *       requestReceiveMessage of #communcationInterface
-		 *     - GET_READ: Access requested reading data by calling doGetRead() which calls
-		 *       readReceivedMessage of #communicationInterface
-		 * @param counter Specifies which Action to perform
-		 * @return RETURN_OK for successful execution
-		 */
+	 * @brief This function is the device handler base core component and is called periodically.
+	 * @details
+	 * General sequence, showing where abstract virtual functions are called:
+	 * If the State is SEND_WRITE:
+	 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
+	 *   2. Handles Device State Modes by calling doStateMachine().
+	 *      This function calls callChildStatemachine() which calls the abstract functions
+	 *      doStartUp() and doShutDown()
+	 *   3. Check switch states by calling checkSwitchStates()
+	 *   4. Decrements counter for timeout of replies by calling decrementDeviceReplyMap()
+	 *   5. Performs FDIR check for failures
+	 *   6. Calls hkSwitcher.performOperation()
+	 *   7. If the device mode is MODE_OFF, return RETURN_OK. Otherwise, perform the Action property
+	 *   	and performs depending on value specified
+	 *      by input value counter. The child class tells base class what to do by setting this value.
+	 *     - SEND_WRITE: Send data or commands to device by calling doSendWrite() which calls
+	 *       sendMessage function of #communicationInterface
+	 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
+	 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite() which calls
+	 *       getSendSuccess of #communicationInterface.
+	 *       Calls abstract functions scanForReply() and interpretDeviceReply().
+	 *     - SEND_READ: Request reading data from device by calling doSendRead() which calls
+	 *       requestReceiveMessage of #communcationInterface
+	 *     - GET_READ: Access requested reading data by calling doGetRead() which calls
+	 *       readReceivedMessage of #communicationInterface
+	 * @param counter Specifies which Action to perform
+	 * @return RETURN_OK for successful execution
+	 */
 	virtual ReturnValue_t performOperation(uint8_t counter);
 
 	virtual ReturnValue_t initialize();
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 9f58f600c..5fbce2824 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -79,11 +79,7 @@ public:
 };
 
 /**
- * Used to retrieve Target Interface Pointers of objects.
- * The object has to implement the SystemObject or SystemObjectIF at the very least,
- * otherwise NULL will be returned.
- * @param id
- * @return NULL or pointer to target interface specified by template object
+ * @brief Documentation can be found in the class method declration.
  */
 template <typename T>
 T* ObjectManagerIF::get( object_id_t id ) {
diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h
index 03a57aaeb..0952d3a60 100644
--- a/tmtcservices/AcceptsTelecommandsIF.h
+++ b/tmtcservices/AcceptsTelecommandsIF.h
@@ -12,7 +12,7 @@
 class AcceptsTelecommandsIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
-	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
 	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
 	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
 	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);

From 950a48078c6464decada0262f5590c75c5d35a6f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 5 Dec 2019 12:21:06 +0100
Subject: [PATCH 0034/1774] some documentation, question about HasParametersIF,
 variable in ParameterHelper intialized (compiler warning)

---
 devicehandlers/DeviceCommunicationIF.h |  6 ++---
 devicehandlers/DeviceHandlerBase.h     | 36 ++++++++++++--------------
 parameters/HasParametersIF.h           |  1 +
 parameters/ParameterHelper.cpp         |  2 +-
 4 files changed, 21 insertions(+), 24 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 10ad27760..ca0e9fe27 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -5,10 +5,10 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
 /**
- * Documentation: Dissertation Baetz p.138
- *
- * This is an interface to decouple device communication from
+ * @brief This is an interface to decouple device communication from
  * the device handler to allow reuse of these components.
+ * @details
+ * Documentation: Dissertation Baetz p.138
  * It works with the assumption that received data
  * is polled by a component. There are four generic steps of device communication:
  *
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index d489ada1c..e7ac3aa63 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -331,9 +331,10 @@ protected:
 			uint32_t parameter = 0);
 
 	/**
-	 *
-
-	 * @param parameter2 additional parameter
+	 * Send reply to a command, differentiate between raw command
+	 * and normal command.
+	 * @param status
+	 * @param parameter
 	 */
 	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
 
@@ -532,10 +533,9 @@ protected:
 			size_t commandDataLen) = 0;
 
 	/**
-	 * fill the #deviceCommandMap
-	 *
-	 * called by the initialize() of the base class
-	 *
+	 * @brief fill the #deviceCommandMap
+	 *	 	  called by the initialize() of the base class
+	 * @details
 	 * This is used to let the base class know which replies are expected.
 	 * There are different scenarios regarding this:
 	 * - "Normal" commands. These are commands, that trigger a direct reply from the device. In this case, the id of the command should be added to the command map
@@ -556,9 +556,9 @@ protected:
 	 *          perform debugging
 	 * @details Example: Calling this in performOperation
 	 *          to track values like mode.
-	 * @param positionTracker Provide the child handler a way to know where the debugInterface was called
-	 * @param objectId Provide the child handler object Id to specify actions for spefic devices
-	 * @param parameter Supply a parameter of interest
+	 * @param 	positionTracker Provide the child handler a way to know where the debugInterface was called
+	 * @param 	objectId Provide the child handler object Id to specify actions for spefic devices
+	 * @param 	parameter Supply a parameter of interest
 	 * Please delete all debugInterface calls in DHB after debugging is finished !
 	 */
 	virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0, uint32_t parameter = 0);
@@ -766,7 +766,7 @@ protected:
 
 	/**
 	 * Used to retrieve logical address
-	 * @return
+	 * @return logicalAddress
 	 */
 	virtual uint32_t getLogicalAddress();
 	Mode_t getBaseMode(Mode_t transitionMode);
@@ -863,12 +863,8 @@ protected:
 
 	ActionHelper actionHelper;
 
-
-
 private:
 
-
-
 	/**
 	 * State a cookie is in.
 	 *
@@ -957,11 +953,6 @@ private:
 	void buildRawDeviceCommand(CommandMessage* message);
 	void buildInternalCommand(void);
 
-//	/**
-//	 * Send a reply with the current mode and submode.
-//	 */
-//	void announceMode(void);
-
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
@@ -1066,6 +1057,11 @@ private:
 	 */
 	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
+	/**
+	 * Handle device handler messages (e.g. commands sent by PUS Service 2)
+	 * @param message
+	 * @return
+	 */
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
 
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index fbb694454..cd053feeb 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -46,6 +46,7 @@ public:
 	 * @param startAtIndex
 	 * @return
 	 */
+	// shouldnt startAtIndex be uint8?
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 75b71a7e9..6ebc9e629 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -3,7 +3,7 @@
 #include <framework/parameters/ParameterMessage.h>
 
 ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-		owner(owner), storage(NULL) {
+		owner(owner), ownerQueueId(0), storage(NULL){
 
 }
 

From d99ed4715017fddab2c1f80610c9c72d3b428315 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 8 Dec 2019 19:04:53 +0100
Subject: [PATCH 0035/1774] fixed map bugfix (fist instead of first), new
 access functions for fixed maP (first(), second()), some documentation, raw
 pool access read() call public because call is necessary before using public
 serialize function. maybe integrate read() call into serialize function?

---
 container/FixedMap.h                    | 13 +++++++++++--
 datapool/PoolRawAccess.h                | 22 ++++++++++++----------
 parameters/HasParametersIF.h            |  1 -
 serialize/SerialArrayListAdapter.h      |  1 +
 serialize/SerialFixedArrayListAdapter.h |  2 ++
 storagemanager/LocalPool.h              | 25 +++++++++++++++++++++++++
 6 files changed, 51 insertions(+), 13 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 0b84bf4ea..4e1dc6291 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -6,7 +6,9 @@
 #include <utility>
 
 /**
- * \ingroup container
+ * @brief 	Implementation of a fixed map using an array list
+ * @details Initialize with desired fixed size
+ * @ingroup container
  */
 template<typename key_t, typename T>
 class FixedMap: public SerializeIF {
@@ -56,6 +58,13 @@ public:
 			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
 		}
 
+		key_t first() {
+			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->first;
+		}
+
+		T second() {
+			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
 	};
 
 	Iterator begin() const {
@@ -87,7 +96,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 {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 9a3000c0e..8b81894a4 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -31,7 +31,7 @@ private:
 	 */
 	Type type;
 	/**
-	 * \brief	This value contains the size of the data pool entry in bytes.
+	 * \brief	This value contains the size of the data pool entry type in bytes.
 	 */
 	uint8_t typeSize;
 	/**
@@ -48,15 +48,7 @@ private:
 	ReadWriteMode_t readWriteMode;
 	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 protected:
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read();
+
 	/**
 	 * \brief	The commit call writes back the variable's value to the data pool.
 	 * \details	It checks type and size, as well as if the variable is writable. If so,
@@ -66,6 +58,7 @@ protected:
 	 */
 	ReturnValue_t commit();
 public:
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
 	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
@@ -78,6 +71,15 @@ public:
 	 * 			discarded and not written back to the data pool.
 	 */
 	~PoolRawAccess();
+	/**
+	 * \brief	This is a call to read the value from the global data pool.
+	 * \details	When executed, this operation tries to fetch the pool entry with matching
+	 * 			data pool id from the global data pool and copies the value and the valid
+	 * 			information to its local attributes. In case of a failure (wrong type or
+	 * 			pool id not found), the variable is set to zero and invalid.
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 */
+	ReturnValue_t read();
 	/**
 	 * \brief	This operation returns a pointer to the entry fetched.
 	 * \details	Return pointer to the buffer containing the raw data
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index cd053feeb..fbb694454 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -46,7 +46,6 @@ public:
 	 * @param startAtIndex
 	 * @return
 	 */
-	// shouldnt startAtIndex be uint8?
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 5ffbc3757..7e2e527bc 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -27,6 +27,7 @@ public:
 
 	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) {
+		// Serialize length field first
 		ReturnValue_t result = SerializeAdapter<count_t>::serialize(&list->size,
 				buffer, size, max_size, bigEndian);
 		count_t i = 0;
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 821e87104..18093e451 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -24,10 +24,12 @@ public:
 	template<typename... Args>
 	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
 	}
+
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
 		return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, max_size, bigEndian);
 	}
+
 	uint32_t getSerializedSize() const {
 		return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
 	}
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 08cb017fc..425ba005e 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -159,6 +159,15 @@ public:
 	 * @brief	In the LocalPool's destructor all allocated memory is freed.
 	 */
 	virtual ~LocalPool(void);
+
+	/**
+	 * Add data to local data pool, performs range check
+	 * @param storageId [out] Store ID in which the data will be stored
+	 * @param data
+	 * @param size
+	 * @param ignoreFault
+	 * @return @c RETURN_OK if write was successful
+	 */
 	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
 			uint32_t size, bool ignoreFault = false);
 
@@ -171,8 +180,24 @@ public:
 	 */
 	ReturnValue_t getFreeElement(store_address_t* storageId,
 			const uint32_t size, uint8_t** p_data, bool ignoreFault = false);
+
+	/**
+	 * Retrieve data from local pool
+	 * @param packet_id
+	 * @param packet_ptr
+	 * @param size [out] Size of retrieved data
+	 * @return @c RETURN_OK if data retrieval was successfull
+	 */
 	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
 			uint32_t* size);
+
+	/**
+	 * Modify data by supplying a previously obtaind packet pointer
+	 * @param packet_id Store ID of data to modify
+	 * @param packet_ptr
+	 * @param size [out] size of changed data
+	 * @return
+	 */
 	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
 			uint32_t* size);
 	virtual ReturnValue_t deleteData(store_address_t);

From 3159ccbc4017f7a9662b82054ac3adbce3aa6261 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 8 Dec 2019 22:26:42 +0100
Subject: [PATCH 0036/1774] fixed map and local pool doc

---
 container/FixedMap.h       | 11 +++++++++--
 storagemanager/LocalPool.h |  2 ++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 4e1dc6291..5e8ca9c35 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -6,8 +6,10 @@
 #include <utility>
 
 /**
- * @brief 	Implementation of a fixed map using an array list
- * @details Initialize with desired fixed size
+ * @brief 	Map implementation for maps with a pre-defined size.
+ * @details Can be initialized with desired maximum size.
+ * 	        Iterator is used to access <key,value> pair and
+ * 	        iterate through map entries.
  * @ingroup container
  */
 template<typename key_t, typename T>
@@ -54,19 +56,24 @@ public:
 			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
 		}
 
+		// -> operator overloaded, can be used to access value
 		T *operator->() {
 			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
 		}
 
+		// Can be used to access the key of the iterator
 		key_t first() {
 			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->first;
 		}
 
+		// Alternative to access value, similar to std::map implementation
 		T second() {
 			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
 		}
 	};
 
+
+
 	Iterator begin() const {
 		return Iterator(&theMap[0]);
 	}
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 425ba005e..57c80c2e7 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -149,6 +149,8 @@ public:
 	 * 						The position of these values correspond to those in
 	 * 						element_sizes.
 	 * @param registered	Register the pool in object manager or not. Default is false (local pool).
+	 * @param spillsToHigherPools
+	 * 						A variable to determine whether higher n pools are used if the store is full.
 	 */
 	LocalPool(object_id_t setObjectId,
 			const uint16_t element_sizes[NUMBER_OF_POOLS],

From 8168885dd905992920029c38444b9abf27541d52 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 8 Dec 2019 22:57:03 +0100
Subject: [PATCH 0037/1774] Serialization documentation update

---
 serialize/EndianSwapper.h               |  4 ++
 serialize/SerialFixedArrayListAdapter.h | 14 +++----
 serialize/SerialLinkedListAdapter.h     | 56 ++++++++++++++++---------
 serialize/SerializeAdapter.h            | 12 +++---
 serialize/SerializeElement.h            | 10 ++++-
 serialize/SerializeIF.h                 | 13 +++---
 6 files changed, 70 insertions(+), 39 deletions(-)

diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index 6ff544447..dfd93484e 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -5,6 +5,10 @@
 #include <cstring>
 #include <iostream>
 
+/**
+ * @brief Can be used to swap endianness of data
+ *        into big endian
+ */
 class EndianSwapper {
 private:
 	EndianSwapper() {
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 18093e451..593a0ec1d 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -5,18 +5,18 @@
 #include <framework/serialize/SerialArrayListAdapter.h>
 
 /**
- * This adapter provides an interface for SerializeIF to serialize and deserialize
- * buffers with a header containing the buffer length.
- *
- * Can be used by SerialLinkedListAdapter.
- *
+ * @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 using this type in
+ * SerializeElement<>
  * Buffers with a size header inside that class can be declared with
- * SerialFixedArrayListAdapter<uint8_t,MAX_BUFFER_LENGTH,typeOfMaxData>.
+ * SerialFixedArrayListAdapter<bufferType,MAX_BUFFER_LENGTH,typeOfMaxData>.
  * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows
  * and MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
  * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
  *
- * \ingroup serialize
+ * @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 {
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 08d385eec..c135a2d38 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -14,29 +14,30 @@
 //This is where we need the SerializeAdapter!
 
  /**
- * An alternative to the AutoSerializeAdapter functions to implement the conversion
- * of object data to data streams or vice-versa, using linked lists.
+ * @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>
+ * 	   inside the class implementing this adapter.
+ *   - The element type can also be a SerialBufferAdapter to de-/serialize buffers,
+ *     with a known size, where the size can also be serialized
+ *   - The element type can also be a SerialFixedArrayListAdapter to de-/serialize buffers
+ *     with a size header, which is scanned automatically
  *
- * All object members with a datatype are declared as SerializeElement<element_type> inside the class
- * implementing this adapter.
+ * The sequence of objects is defined in the constructor by using
+ * the setStart and setNext functions.
  *
- * Buffers with a size header inside that class can be declared with
- * SerialFixedArrayListAdapter<uint8_t,MAX_BUFFER_LENGTH,typeOfMaxData>.
- * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows
- * and MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
- * Please note that a direct link from a linked element to a SerialFixedArrayListAdapter element is not possible and a
- * helper needs to be used by calling <LinkedElement>.setNext(&linkHelper)
- * and initialising the link helper as linkHelper(&SerialFixedArrayListAdapterElement).
+ * - The serialization process is done by instantiating the class and
+ *   calling the serialize after all SerializeElement entries have been set by
+ *   using a constructor or setter functions. An additional size variable can be supplied
+ *   which is calculated/incremented automatically
+ * - 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
  *
- * For buffers with no size header, declare
- * SerializeElement<SerializeBufferAdapter<T>> and initialise the buffer adapter in the constructor.
  *
- * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
- *
- * The serialization and deserialization process is done by instantiating the class and
- * calling the serialize or deserialize function.
- *
- * \ingroup serialize
+ * @ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
 class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
@@ -53,6 +54,16 @@ public:
 			SinglyLinkedList<T>(), printCount(printCount) {
 	}
 
+	/**
+	 * Serialize object implementing this adapter into the supplied buffer
+	 * and calculate the serialized size
+	 * @param buffer [out] Object is serialized into this buffer. Note that the buffer pointer
+	 *               *buffer is incremented automatically inside the respective serialize functions
+	 * @param size [out] Calculated serialized size. Don't forget to set to 0.
+	 * @param max_size
+	 * @param bigEndian Specify endianness
+	 * @return
+	 */
 	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
 		if (printCount) {
@@ -95,6 +106,13 @@ public:
 		return size;
 	}
 
+	/**
+	 * Deserialize supplied buffer with supplied size into object implementing this adapter
+	 * @param buffer
+	 * @param size Decremented in respective deSerialize functions automatically
+	 * @param bigEndian Specify endianness
+	 * @return
+	 */
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
 		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index a0aab9e98..385f40d33 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -8,10 +8,10 @@
 #include <string.h>
 
  /**
- * This adapter 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 vice-versa.
- *
+ * @brief This adapter 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 vice-versa.
+ * @details
  * Examples:
  * A report class is converted into a TM buffer. The report class implements a serialize functions and calls
  * the AutoSerializeAdapter::serialize function repeatedly on all object data fields.
@@ -49,7 +49,7 @@
  * When serializing for downlink, the packets are generally serialized assuming big endian data format
  * like seen in TmPacketStored.cpp for example.
  *
- * \ingroup serialize
+ * @ingroup serialize
  */
 template<typename T, int>
 class SerializeAdapter_ {
@@ -141,7 +141,7 @@ public:
 	}
 };
 
-
+// No type specification necessary here.
 class AutoSerializeAdapter {
 public:
 	template<typename T>
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index db7db20a9..4f5a22b6e 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -6,7 +6,15 @@
 #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().
+ * Serilization and Deserialization is then performed automatically in
+ * specified sequence order.
+ * @ingroup serialize
  */
 template<typename T>
 class SerializeElement : public SerializeIF, public LinkedElement<SerializeIF> {
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index cada1e72a..fb750a083 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -4,17 +4,18 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
 /**
- * \defgroup serialize Serialization
+ * @defgroup serialize Serialization
  * Contains serialisation services.
  */
 
 /**
- * An interface for alle classes which require translation of objects data into data streams and vice-versa.
- *
+ * @brief An interface for alle classes which require
+ *        translation of objects data into data streams and vice-versa.
+ * @details
  * If the target architecture is little endian (e.g. ARM), any data types created might
  * have the wrong endiness if they are to be used for the FSFW.
- * There are three ways to retrieve data out of a buffer to be used in the FSFW to use regular aligned (big endian) data.
- * This can also be applied to uint32_t and uint64_t:
+ * There are three ways to retrieve data out of a buffer to be used in the FSFW to use
+ * regular aligned (big endian) data. This can also be applied to uint32_t and uint64_t:
  *
  *   1. Use the @c AutoSerializeAdapter::deSerialize function with @c bigEndian = true
  *   2. Perform a bitshift operation
@@ -23,7 +24,7 @@
  * When serializing for downlink, the packets are generally serialized assuming big endian data format
  * like seen in TmPacketStored.cpp for example.
  *
- * \ingroup serialize
+ * @ingroup serialize
  */
 class SerializeIF {
 public:

From e765f8c99bbe6827b44a8ea21a9808ca51471cf1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 9 Dec 2019 12:27:14 +0100
Subject: [PATCH 0038/1774] pool raw access modified so vectors are properly
 serialized now Endian swapper can swap the entries of a uint16,uint32 buffers
 now. Some documentation for functions added. setter function for serial
 buffer adapter written but does not appear to compile, commented out

---
 datapool/PoolRawAccess.cpp        | 20 +++++++++++++-------
 datapool/PoolRawAccess.h          | 18 ++++++++++++++----
 serialize/EndianSwapper.h         | 21 +++++++++++++++++++++
 serialize/SerialBufferAdapter.cpp |  5 +++++
 serialize/SerialBufferAdapter.h   |  1 +
 serialize/SerializeAdapter.h      |  8 ++++++++
 6 files changed, 62 insertions(+), 11 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 555896bb2..6e9b3d08f 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -31,7 +31,10 @@ ReturnValue_t PoolRawAccess::read() {
 				sizeTillEnd = read_out->getByteSize() - arrayPosition;
 				uint8_t* ptr =
 						&((uint8_t*) read_out->getRawData())[arrayPosition];
-				memcpy(value, ptr, typeSize);
+				for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
+					memcpy(value + typeSize * arrayCount, ptr + typeSize * arrayCount, typeSize);
+				}
+
 				return HasReturnvaluesIF::RETURN_OK;
 			} else {
 				//Error value type too large.
@@ -152,17 +155,20 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for (uint8_t count = 0; count < typeSize; count++) {
-				(*buffer)[count] = value[typeSize - count - 1];
+			for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
+				for (uint8_t count = 0; count < typeSize; count++) {
+					(*buffer)[typeSize * (arrayCount + 1) - count - 1] =
+							value[typeSize * arrayCount + count];
+				}
 			}
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(*buffer, value, typeSize);
+			memcpy(*buffer, value, typeSize * arraySize);
 #endif
 		} else {
-			memcpy(*buffer, value, typeSize);
+			memcpy(*buffer, value, typeSize * arraySize);
 		}
-		*size += typeSize;
-		(*buffer) += typeSize;
+		*size += typeSize * arraySize;
+		(*buffer) += typeSize * arraySize;
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
 		return SerializeIF::BUFFER_TOO_SHORT;
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 8b81894a4..2a634fa85 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -48,7 +48,6 @@ private:
 	ReadWriteMode_t readWriteMode;
 	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 protected:
-
 	/**
 	 * \brief	The commit call writes back the variable's value to the data pool.
 	 * \details	It checks type and size, as well as if the variable is writable. If so,
@@ -80,6 +79,20 @@ public:
 	 * 			The operation does NOT provide any mutual exclusive protection by itself.
 	 */
 	ReturnValue_t read();
+
+	/**
+	 * @brief 	Serialize raw pool entry into provided buffer directly
+	 * @details Should be called after read() call. Endianness can be specified too
+	 * @param buffer Provided buffer. Raw pool data will be copied here
+	 * @param size [out] Increment provided size value by serialized size
+	 * @param max_size Maximum allowed serialization size
+	 * @param bigEndian Specify endianess
+	 * @return - @c RETURN_OK if serialization was successfull
+	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
+	 */
+	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const;
+
 	/**
 	 * \brief	This operation returns a pointer to the entry fetched.
 	 * \details	Return pointer to the buffer containing the raw data
@@ -142,9 +155,6 @@ public:
 	 */
 	uint16_t getSizeTillEnd() const;
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
-
 	uint32_t getSerializedSize() const;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index dfd93484e..db170c0b2 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -44,6 +44,27 @@ public:
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 		memcpy(out, in, size);
 		return;
+#endif
+	}
+
+	template<typename T>
+	static void swap(T * out, const T * in, uint32_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		const uint8_t * in_buffer = reinterpret_cast<const uint8_t *>(in);
+		uint8_t * out_buffer = reinterpret_cast<uint8_t *>(out);
+		for (uint8_t count = 0; count < size; count++) {
+			for(uint8_t i = 0; i < sizeof(T);i++) {
+				out_buffer[sizeof(T)* (count + 1) - i - 1] = in_buffer[count * sizeof(T) + i];
+			}
+
+		}
+
+		return;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		memcpy(out, in, size*sizeof(T));
+		return;
 #endif
 	}
 };
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 9a8e6f069..d7ab0d880 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -96,6 +96,11 @@ uint8_t * SerialBufferAdapter<T>::getBuffer() {
 	return buffer;
 }
 
+//template<typename T>
+//void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_) {
+//	buffer = buffer_;
+//}
+
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
 template class SerialBufferAdapter<uint16_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 7496c1376..0438f8841 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -56,6 +56,7 @@ public:
 			bool bigEndian);
 
 	uint8_t * getBuffer();
+	//void setBuffer(uint8_t * buffer_);
 private:
 	bool serializeLength;
 	const uint8_t *constBuffer;
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 385f40d33..933d933de 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -76,6 +76,14 @@ public:
 		}
 	}
 
+	/**
+	 * Deserialize buffer into object
+	 * @param object [out] Object to be deserialized with buffer data
+	 * @param buffer buffer containing the data
+	 * @param size int32_t type to allow value to be values smaller than 0, needed for range/size checking
+	 * @param bigEndian Specify endianness
+	 * @return
+	 */
 	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
 		T tmp;

From 356d1d35dc97232e92778a4d0602947db812dc59 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 10 Dec 2019 13:29:16 +0100
Subject: [PATCH 0039/1774] experimenting with recursive constructor to enable
 automatic vector registering

---
 datapool/PoolRawAccess.cpp | 46 +++++++++++++++++++++++++++-----------
 datapool/PoolRawAccess.h   | 44 +++++++++++++++++++++++++-----------
 2 files changed, 64 insertions(+), 26 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 6e9b3d08f..41efdd7a1 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -5,13 +5,27 @@
 #include <framework/osal/Endiness.h>
 
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode) :
+		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode,
+		bool registerVectors) :
 		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false), type(Type::UNKNOWN_TYPE), typeSize(
 				0), arraySize(0), sizeTillEnd(0), readWriteMode(setReadWriteMode) {
 	memset(value, 0, sizeof(value));
 	if (data_set != NULL) {
 		data_set->registerVariable(this);
 	}
+	if(registerVectors == true) {
+		this->read();
+		if(arraySize > 1) {
+			for(uint16_t vectorCount = typeSize;vectorCount < arraySize;vectorCount += typeSize)
+			{
+				PoolRawAccess * newPoolRawAccess =
+						new PoolRawAccess(set_id, setArrayEntry + typeSize,
+								          data_set,setReadWriteMode,true);
+				if(newPoolRawAccess) {};
+			}
+		}
+	}
+
 }
 
 PoolRawAccess::~PoolRawAccess() {
@@ -31,9 +45,10 @@ ReturnValue_t PoolRawAccess::read() {
 				sizeTillEnd = read_out->getByteSize() - arrayPosition;
 				uint8_t* ptr =
 						&((uint8_t*) read_out->getRawData())[arrayPosition];
-				for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
-					memcpy(value + typeSize * arrayCount, ptr + typeSize * arrayCount, typeSize);
-				}
+				memcpy(value, ptr, typeSize);
+				//for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
+				//	memcpy(value + typeSize * arrayCount, ptr + typeSize * arrayCount, typeSize);
+				//}
 
 				return HasReturnvaluesIF::RETURN_OK;
 			} else {
@@ -155,20 +170,25 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
-				for (uint8_t count = 0; count < typeSize; count++) {
-					(*buffer)[typeSize * (arrayCount + 1) - count - 1] =
-							value[typeSize * arrayCount + count];
-				}
+			for (uint8_t count = 0; count < typeSize; count++) {
+				(*buffer)[count] = value[typeSize - count - 1];
 			}
+			//for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
+			//	for (uint8_t count = 0; count < typeSize; count++) {
+			//		(*buffer)[typeSize * (arrayCount + 1) - count - 1] =
+			//				value[typeSize * arrayCount + count];
+			//	}
+			//}
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(*buffer, value, typeSize * arraySize);
+			memcpy(*buffer, value, typeSize);
+			//memcpy(*buffer, value, typeSize * arraySize);
 #endif
 		} else {
-			memcpy(*buffer, value, typeSize * arraySize);
+			memcpy(*buffer, value, typeSize);
+			//memcpy(*buffer, value, typeSize * arraySize);
 		}
-		*size += typeSize * arraySize;
-		(*buffer) += typeSize * arraySize;
+		*size += typeSize;// * arraySize;
+		(*buffer) += typeSize;// * arraySize;
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
 		return SerializeIF::BUFFER_TOO_SHORT;
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 2a634fa85..e85bef247 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -6,10 +6,14 @@
 #include <framework/globalfunctions/Type.h>
 
 /**
- * This class allows accessing Data Pool variables as raw bytes.
+ * @brief This class allows accessing Data Pool variables as raw bytes.
+ * @details
  * This is necessary to have an access method for HK data, as the PID's alone do not
- * provide a type information.
- *	\ingroup data_pool
+ * provide a type information. Please note that the the raw pool access read() and commit()
+ * calls are not thread-safe and therefore private.
+ * Please supply a data set and use the data set read(), commit() calls for thread-safe
+ * data pool access.
+ * @ingroup data_pool
  */
 class PoolRawAccess: public PoolVariableIF {
 private:
@@ -48,6 +52,18 @@ private:
 	ReadWriteMode_t readWriteMode;
 	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 protected:
+	/**
+	 * \brief	This is a call to read the value from the global data pool.
+	 * \details	When executed, this operation tries to fetch the pool entry with matching
+	 * 			data pool id from the global data pool and copies the value and the valid
+	 * 			information to its local attributes. In case of a failure (wrong type or
+	 * 			pool id not found), the variable is set to zero and invalid.
+	 * 			The operation does NOT provide any mutual exclusive protection by itself !
+	 * 			If reading from the data pool without information about the type is desired,
+	 * 			initialize the raw pool access by supplying a data set and using the data set
+	 * 			read function, which calls this read function.
+	 */
+	ReturnValue_t read();
 	/**
 	 * \brief	The commit call writes back the variable's value to the data pool.
 	 * \details	It checks type and size, as well as if the variable is writable. If so,
@@ -62,23 +78,25 @@ public:
 	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
 	uint8_t value[RAW_MAX_SIZE];
+	//uint8_t value[RAW_MAX_SIZE*3];
+
+	/**
+	 * This constructor is used to access a data pool entry with a
+	 * given ID if the target type is not known. A DataSet object is supplied
+	 * and the data pool entry with the given ID is registered to that data set
+	 * @param data_pool_id Target data pool entry ID
+	 * @param arrayEntry
+	 * @param data_set Dataset to register data pool entry to
+	 * @param setReadWriteMode
+	 */
 	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
 			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-					PoolVariableIF::VAR_READ);
+			PoolVariableIF::VAR_READ,bool registerVectors = false);
 	/**
 	 * \brief	The classes destructor is empty. If commit() was not called, the local value is
 	 * 			discarded and not written back to the data pool.
 	 */
 	~PoolRawAccess();
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read();
 
 	/**
 	 * @brief 	Serialize raw pool entry into provided buffer directly

From f33949ba4b2e7ef3784d712af06e94a04c45ebac Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 10 Dec 2019 14:54:17 +0100
Subject: [PATCH 0040/1774] doc adapted, merging

---
 datapool/PoolRawAccess.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 2a634fa85..3b9144a20 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -82,7 +82,6 @@ public:
 
 	/**
 	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @details Should be called after read() call. Endianness can be specified too
 	 * @param buffer Provided buffer. Raw pool data will be copied here
 	 * @param size [out] Increment provided size value by serialized size
 	 * @param max_size Maximum allowed serialization size

From f7d8f0c1617295aae5ed652ee99566f98d84111c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 10 Dec 2019 23:26:48 +0100
Subject: [PATCH 0041/1774] Reverted changed  pool raw access commit

---
 datapool/PoolRawAccess.cpp | 31 ++++++++-----------------------
 datapool/PoolRawAccess.h   |  9 +++++++--
 2 files changed, 15 insertions(+), 25 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 41efdd7a1..0c31565ac 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -15,17 +15,14 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 	}
 	if(registerVectors == true) {
 		this->read();
-		if(arraySize > 1) {
-			for(uint16_t vectorCount = typeSize;vectorCount < arraySize;vectorCount += typeSize)
-			{
-				PoolRawAccess * newPoolRawAccess =
-						new PoolRawAccess(set_id, setArrayEntry + typeSize,
-								          data_set,setReadWriteMode,true);
-				if(newPoolRawAccess) {};
-			}
+		if(arrayEntry < arraySize - 1) {
+			uint8_t nextArrayEntry = arrayEntry + 1;
+			PoolRawAccess * newPoolRawAccess =
+				new PoolRawAccess(set_id, nextArrayEntry,
+								  data_set,setReadWriteMode,true);
+			if(newPoolRawAccess) {};
 		}
 	}
-
 }
 
 PoolRawAccess::~PoolRawAccess() {
@@ -46,10 +43,6 @@ ReturnValue_t PoolRawAccess::read() {
 				uint8_t* ptr =
 						&((uint8_t*) read_out->getRawData())[arrayPosition];
 				memcpy(value, ptr, typeSize);
-				//for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
-				//	memcpy(value + typeSize * arrayCount, ptr + typeSize * arrayCount, typeSize);
-				//}
-
 				return HasReturnvaluesIF::RETURN_OK;
 			} else {
 				//Error value type too large.
@@ -173,22 +166,14 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
 			for (uint8_t count = 0; count < typeSize; count++) {
 				(*buffer)[count] = value[typeSize - count - 1];
 			}
-			//for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
-			//	for (uint8_t count = 0; count < typeSize; count++) {
-			//		(*buffer)[typeSize * (arrayCount + 1) - count - 1] =
-			//				value[typeSize * arrayCount + count];
-			//	}
-			//}
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 			memcpy(*buffer, value, typeSize);
-			//memcpy(*buffer, value, typeSize * arraySize);
 #endif
 		} else {
 			memcpy(*buffer, value, typeSize);
-			//memcpy(*buffer, value, typeSize * arraySize);
 		}
-		*size += typeSize;// * arraySize;
-		(*buffer) += typeSize;// * arraySize;
+		*size += typeSize;
+		(*buffer) += typeSize;
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
 		return SerializeIF::BUFFER_TOO_SHORT;
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index cdead93a8..9bf09d0a7 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -78,16 +78,21 @@ public:
 	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
 	uint8_t value[RAW_MAX_SIZE];
-	//uint8_t value[RAW_MAX_SIZE*3];
 
 	/**
 	 * This constructor is used to access a data pool entry with a
 	 * given ID if the target type is not known. A DataSet object is supplied
-	 * and the data pool entry with the given ID is registered to that data set
+	 * and the data pool entry with the given ID is registered to that data set.
+	 * Please note that a pool raw access buffer only has a buffer
+	 * with a size of double. As such, for vector entries which have
 	 * @param data_pool_id Target data pool entry ID
 	 * @param arrayEntry
 	 * @param data_set Dataset to register data pool entry to
 	 * @param setReadWriteMode
+	 * @param registerVectors If set to true, the constructor checks if
+	 *                        there are multiple vector entries to registers
+	 *                        and registers all of them recursively into the data_set
+	 *
 	 */
 	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
 			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =

From 138cac98d100affabc0916e27f8189c42af3f3b9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 11 Dec 2019 01:57:36 +0100
Subject: [PATCH 0042/1774] experimenting with recursive constructor and
 dataset call

---
 datapool/PoolRawAccess.cpp | 9 +++++----
 datapool/PoolRawAccess.h   | 1 +
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 0c31565ac..6be4b7838 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -3,6 +3,7 @@
 #include <framework/datapool/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
+#include "DataSet.h"
 
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode,
@@ -15,12 +16,12 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 	}
 	if(registerVectors == true) {
 		this->read();
+//		DataSet * myDataSetTest = (DataSet *) data_set;
+//		myDataSetTest->read();
 		if(arrayEntry < arraySize - 1) {
 			uint8_t nextArrayEntry = arrayEntry + 1;
-			PoolRawAccess * newPoolRawAccess =
-				new PoolRawAccess(set_id, nextArrayEntry,
-								  data_set,setReadWriteMode,true);
-			if(newPoolRawAccess) {};
+			nextPoolRawAccess = new PoolRawAccess(set_id, nextArrayEntry,
+					data_set,setReadWriteMode,true);
 		}
 	}
 }
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 9bf09d0a7..ac7d6702f 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -50,6 +50,7 @@ private:
 	 * \brief	The information whether the class is read-write or read-only is stored here.
 	 */
 	ReadWriteMode_t readWriteMode;
+	PoolRawAccess * nextPoolRawAccess;
 	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 protected:
 	/**

From 29a15e8154d5de81d5dff878f6e54f413f5fe12d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 11 Dec 2019 13:03:51 +0100
Subject: [PATCH 0043/1774] commented out functions which will propably not be
 needed and removed

---
 datapool/PoolRawAccess.cpp | 22 +++++++++++-----------
 datapool/PoolRawAccess.h   |  4 ++--
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 6be4b7838..c99d80691 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -3,7 +3,9 @@
 #include <framework/datapool/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
-#include "DataSet.h"
+
+//PoolRawAccess::PoolRawAccess() {
+//}
 
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode,
@@ -14,16 +16,14 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 	if (data_set != NULL) {
 		data_set->registerVariable(this);
 	}
-	if(registerVectors == true) {
-		this->read();
-//		DataSet * myDataSetTest = (DataSet *) data_set;
-//		myDataSetTest->read();
-		if(arrayEntry < arraySize - 1) {
-			uint8_t nextArrayEntry = arrayEntry + 1;
-			nextPoolRawAccess = new PoolRawAccess(set_id, nextArrayEntry,
-					data_set,setReadWriteMode,true);
-		}
-	}
+//	if(registerVectors == true) {
+//		this->read();
+//		if(arrayEntry < arraySize - 1) {
+//			uint8_t nextArrayEntry = arrayEntry + 1;
+//			nextPoolRawAccess = new PoolRawAccess(set_id, nextArrayEntry,
+//					data_set,setReadWriteMode,true);
+//		}
+//	}
 }
 
 PoolRawAccess::~PoolRawAccess() {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index ac7d6702f..7207518cc 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -50,7 +50,7 @@ private:
 	 * \brief	The information whether the class is read-write or read-only is stored here.
 	 */
 	ReadWriteMode_t readWriteMode;
-	PoolRawAccess * nextPoolRawAccess;
+	//PoolRawAccess * nextPoolRawAccess;
 	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 protected:
 	/**
@@ -79,7 +79,7 @@ public:
 	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
 	uint8_t value[RAW_MAX_SIZE];
-
+	//PoolRawAccess();
 	/**
 	 * This constructor is used to access a data pool entry with a
 	 * given ID if the target type is not known. A DataSet object is supplied

From 9382eb03e6cfb0985d78587df3f4696e52ead038 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 11 Dec 2019 22:50:08 +0100
Subject: [PATCH 0044/1774] function to serialize pool ID buffers into dataset
 created

---
 datapool/DataSet.cpp     |  6 ++++++
 datapool/DataSet.h       | 11 +++++++++++
 datapool/PoolRawAccess.h |  2 +-
 3 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index b4725c735..55d8d6700 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -148,3 +148,9 @@ ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, int32_t* size,
 	}
 	return result;
 }
+
+ReturnValue_t DataSet::serializeRawFromIdBuffer(uint8_t ** buffer, uint32_t * size,
+		const uint32_t max_size, bool bigEndian, uint32_t * poolIdBuffer,
+		uint32_t poolIdSize) {
+	return RETURN_OK;
+}
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index 982be6928..deee8ca66 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -146,6 +146,14 @@ public:
 	 */
 	void setValid(uint8_t valid);
 
+	/**
+	 * Serialize all registered pool variables into the provided buffer
+	 * @param buffer
+	 * @param size Is incremented by serialized size
+	 * @param max_size
+	 * @param bigEndian
+	 * @return
+	 */
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const;
 
@@ -154,6 +162,9 @@ public:
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
 
+	ReturnValue_t serializeRawFromIdBuffer(uint8_t ** buffer, uint32_t * size,
+			const uint32_t max_size, bool bigEndian, uint32_t * poolIdBuffer,
+			uint32_t poolIdSize);
 };
 
 #endif /* DATASET_H_ */
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 7207518cc..3735868f7 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -10,7 +10,7 @@
  * @details
  * This is necessary to have an access method for HK data, as the PID's alone do not
  * provide a type information. Please note that the the raw pool access read() and commit()
- * calls are not thread-safe and therefore private.
+ * calls are not thread-safe.
  * Please supply a data set and use the data set read(), commit() calls for thread-safe
  * data pool access.
  * @ingroup data_pool

From 625f3dc79c33794c041bf91af87bd0a2d271e67b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 11 Dec 2019 23:15:34 +0100
Subject: [PATCH 0045/1774] local pool modify data doc modifided

---
 storagemanager/LocalPool.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 57c80c2e7..80e6a4956 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -194,10 +194,11 @@ public:
 			uint32_t* size);
 
 	/**
-	 * Modify data by supplying a previously obtaind packet pointer
+	 * Modify data by supplying a packet pointer and using that packet pointer
+	 * to access and modify the pool entry (via *pointer call)
 	 * @param packet_id Store ID of data to modify
-	 * @param packet_ptr
-	 * @param size [out] size of changed data
+	 * @param packet_ptr [out] pointer to the pool entry to modify
+	 * @param size [out] size of pool entry
 	 * @return
 	 */
 	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,

From fa6cbe7e0c8862f903e7c78bdf938c8caff93863 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 11 Dec 2019 23:18:28 +0100
Subject: [PATCH 0046/1774] pool raw access changed reverted

---
 datapool/PoolRawAccess.cpp | 11 -----------
 datapool/PoolRawAccess.h   |  1 -
 2 files changed, 12 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index c99d80691..7cc618528 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -4,9 +4,6 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
 
-//PoolRawAccess::PoolRawAccess() {
-//}
-
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode,
 		bool registerVectors) :
@@ -16,14 +13,6 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 	if (data_set != NULL) {
 		data_set->registerVariable(this);
 	}
-//	if(registerVectors == true) {
-//		this->read();
-//		if(arrayEntry < arraySize - 1) {
-//			uint8_t nextArrayEntry = arrayEntry + 1;
-//			nextPoolRawAccess = new PoolRawAccess(set_id, nextArrayEntry,
-//					data_set,setReadWriteMode,true);
-//		}
-//	}
 }
 
 PoolRawAccess::~PoolRawAccess() {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 3735868f7..603bae239 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -50,7 +50,6 @@ private:
 	 * \brief	The information whether the class is read-write or read-only is stored here.
 	 */
 	ReadWriteMode_t readWriteMode;
-	//PoolRawAccess * nextPoolRawAccess;
 	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 protected:
 	/**

From d17146d847610b403118c7992908a94deb361e1c Mon Sep 17 00:00:00 2001
From: Maximilian Luz <luzmaximilian@gmail.com>
Date: Thu, 19 Dec 2019 16:09:50 +0100
Subject: [PATCH 0047/1774] Check object existence before adding it to the PST

Currently, adding new objects/components to the FixedSlotSequence PST is
not being checked, meaning that it is possible to add NULL objects here
without any warning. This causes NULL-pointer errors when non-existent
components are added, which can be hard to debug.

To solve this, add a check for the object existence before adding it to
PST and emit an error message.

Signed-off-by: Maximilian Luz <luzmaximilian@gmail.com>
---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 5 +++++
 osal/linux/FixedTimeslotTask.cpp    | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 5bf09f136..4a30774aa 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -57,6 +57,11 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
+	if (!objectManager->get<ExecutableObjectIF>(componentId)) {
+		error << "Component " << std::hex << componentId << " not found, not adding it to pst" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	pst.addSlot(componentId, slotTimeMs, executionStep, this);
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 99cbf8185..21040e6ef 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -40,6 +40,11 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
+	if (!objectManager->get<ExecutableObjectIF>(componentId)) {
+		error << "Component " << std::hex << componentId << " not found, not adding it to pst" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	pst.addSlot(componentId, slotTimeMs, executionStep, this);
 	return HasReturnvaluesIF::RETURN_OK;
 }

From 89f490ac36dd3178616cbdfa712adea389ab15ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 20 Dec 2019 23:09:35 +0100
Subject: [PATCH 0048/1774] assembly constructor formatting

---
 devicehandlers/AssemblyBase.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index c250cf735..bd85d1de5 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -2,10 +2,10 @@
 
 AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
 		uint16_t commandQueueDepth) :
-		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth), internalState(
-				STATE_NONE), recoveryState(RECOVERY_IDLE), recoveringDevice(
-				childrenMap.end()), targetMode(MODE_OFF), targetSubmode(
-				SUBMODE_NONE) {
+		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
+		internalState(STATE_NONE), recoveryState(RECOVERY_IDLE),
+		recoveringDevice(childrenMap.end()), targetMode(MODE_OFF),
+		targetSubmode(SUBMODE_NONE) {
 	recoveryOffTimer.setTimeout(POWER_OFF_TIME_MS);
 }
 

From f6b9b232877d29d6a68640967f131d6091c7f2de Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 24 Dec 2019 01:41:04 +0100
Subject: [PATCH 0049/1774] pool raw access init

---
 datapool/PoolRawAccessHelper.cpp | 68 ++++++++++++++++++++++++++++++
 datapool/PoolRawAccessHelper.h   | 71 ++++++++++++++++++++++++++++++++
 2 files changed, 139 insertions(+)
 create mode 100644 datapool/PoolRawAccessHelper.cpp
 create mode 100644 datapool/PoolRawAccessHelper.h

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
new file mode 100644
index 000000000..24bcc1d49
--- /dev/null
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -0,0 +1,68 @@
+/**
+ * @file PoolRawAccessHelper.cpp
+ *
+ * @date 22.12.2019
+ */
+
+#include <framework/datapool/PoolRawAccessHelper.h>
+
+PoolRawAccessHelper::PoolRawAccessHelper(DataSet *dataSet_,
+		const uint8_t * poolIdBuffer_, uint8_t  numberOfParameters_):
+		dataSet(dataSet_), poolIdBuffer(poolIdBuffer_),
+		numberOfParameters(numberOfParameters_){
+}
+
+PoolRawAccessHelper::~PoolRawAccessHelper() {
+}
+
+ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
+		const uint32_t max_size, bool bigEndian) {
+	const uint8_t ** pPoolIdBuffer = &poolIdBuffer;
+	int32_t remainingParametersSize = numberOfParameters * 4;
+	for(uint8_t count=0; count < numberOfParameters; count++) {
+		serializeCurrentPoolEntryIntoBuffer(pPoolIdBuffer,buffer,
+				&remainingParametersSize,size,max_size, bigEndian, false);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t **buffer,
+		uint32_t *size, const uint32_t max_size, bool bigEndian) {
+	return RETURN_OK;
+}
+
+void PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,
+		uint8_t ** buffer, int32_t * remainingParameters, uint32_t * hkDataSize,
+		const uint32_t max_size, bool bigEndian, bool withValidMask) {
+	uint32_t currentPoolId;
+	// Deserialize current pool ID from pool ID buffer
+	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
+			pPoolIdBuffer,remainingParameters,true);
+	if(result != RETURN_OK) {
+		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing pool IDs" << std::dec << std::endl;
+		return;
+	}
+	PoolRawAccess currentPoolRawAccess(currentPoolId,0,dataSet,PoolVariableIF::VAR_READ);
+	result = dataSet->read();
+
+	if (result != RETURN_OK) {
+		debug << std::hex << "Pool Raw Access Helper: Error read raw dataset" << std::dec << std::endl;
+		return;
+	}
+	result = dataSet->serialize(buffer, hkDataSize,
+			max_size, bigEndian);
+	if (result != RETURN_OK) {
+		debug << "Service 3: Error serializing pool data into send buffer" << std::endl;
+		return;
+	}
+}
+
+uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position, bool value) {
+	if(position < 1 or position > 8) {
+		debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+		return byte;
+	}
+	uint8_t shiftNumber = position + (6 - 2 * (position - 1));
+	byte = (byte | value) <<  shiftNumber;
+	return byte;
+}
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
new file mode 100644
index 000000000..bb19a3cec
--- /dev/null
+++ b/datapool/PoolRawAccessHelper.h
@@ -0,0 +1,71 @@
+/**
+ * @file PoolRawAccessHelper.h
+ *
+ * @date 22.12.2019
+ */
+
+#ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
+#define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/datapool/DataSet.h>
+
+/**
+ * @brief 	This helper function simplifies accessing data pool entries
+ *  	  	via PoolRawAccess
+ * @details Can be used for a Housekeeping Service
+ * 			like PUS Service 3 if the type of the datapool entries is unknown.
+ * 			The provided dataset is serialized into a provided buffer automatically.
+ */
+class PoolRawAccessHelper: public HasReturnvaluesIF {
+public:
+	/**
+	 * Call this constructor if a dataset needs to be serialized via
+	 * Pool Raw Access
+	 * @param dataSet_ This dataset will be used to perform thread-safe reading
+	 * @param poolIdBuffer_ A buffer of uint32_t pool IDs
+	 * @param numberOfParameters_ The number of parameters / pool IDs
+	 */
+	PoolRawAccessHelper(DataSet * dataSet_, const uint8_t * poolIdBuffer_,
+			uint8_t numberOfParameters_);
+	virtual ~PoolRawAccessHelper();
+
+	/**
+	 * Serialize the datapool entries derived from the pool ID buffer
+	 * directly into a provided buffer
+	 * @param [out] buffer
+	 * @param [out] size Size of the serialized buffer
+	 * @param max_size
+	 * @param bigEndian
+	 * @return 	@c RETURN_OK On success
+	 * 			@c RETURN_FAILED on failure
+	 */
+	ReturnValue_t serialize(uint8_t ** buffer, uint32_t * size,
+			const uint32_t max_size, bool bigEndian);
+
+	/**
+	 * Serializes data pool entries into provided buffer with the validity mask buffer
+	 * at the end of the buffer. Every bit of the validity mask denotes
+	 * the validity of a corresponding data pool entry from left to right.
+	 * @param [out] buffer
+	 * @param [out] size Size of the serialized buffer plus size
+	 *                   of the validity mask
+	 * @return 	@c RETURN_OK On success
+	 * 			@c RETURN_FAILED on failure
+	 */
+	ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, uint32_t * size,
+			const uint32_t max_size, bool bigEndian);
+
+
+private:
+	DataSet * dataSet;
+	const uint8_t * poolIdBuffer;
+	uint8_t numberOfParameters;
+
+	void serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,uint8_t ** buffer,
+				int32_t * remainingParameters, uint32_t * hkDataSize,const uint32_t max_size,
+				bool bigEndian, bool withValidMask);
+	uint8_t bitSetter(uint8_t byte, uint8_t position, bool value);
+};
+
+#endif /* FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_ */

From 1f1831c4a14ddf806a6a360e1f60b1c46e90d968 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 24 Dec 2019 22:15:39 +0100
Subject: [PATCH 0050/1774] pool raw access init

---
 datapool/PoolRawAccessHelper.cpp | 53 ++++++++++++++++++++++++++------
 datapool/PoolRawAccessHelper.h   | 33 +++++++++++++++++---
 2 files changed, 73 insertions(+), 13 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 24bcc1d49..5a43e43c7 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -2,6 +2,7 @@
  * @file PoolRawAccessHelper.cpp
  *
  * @date 22.12.2019
+ * @author R. Mueller
  */
 
 #include <framework/datapool/PoolRawAccessHelper.h>
@@ -9,7 +10,7 @@
 PoolRawAccessHelper::PoolRawAccessHelper(DataSet *dataSet_,
 		const uint8_t * poolIdBuffer_, uint8_t  numberOfParameters_):
 		dataSet(dataSet_), poolIdBuffer(poolIdBuffer_),
-		numberOfParameters(numberOfParameters_){
+		numberOfParameters(numberOfParameters_), validBufferIndex(0), validBufferIndexBit(1){
 }
 
 PoolRawAccessHelper::~PoolRawAccessHelper() {
@@ -17,44 +18,78 @@ PoolRawAccessHelper::~PoolRawAccessHelper() {
 
 ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
 		const uint32_t max_size, bool bigEndian) {
+	ReturnValue_t result;
 	const uint8_t ** pPoolIdBuffer = &poolIdBuffer;
 	int32_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
-		serializeCurrentPoolEntryIntoBuffer(pPoolIdBuffer,buffer,
+		result = serializeCurrentPoolEntryIntoBuffer(pPoolIdBuffer,buffer,
 				&remainingParametersSize,size,max_size, bigEndian, false);
+		if(result != RETURN_OK) {
+			return result;
+		}
 	}
 	return RETURN_OK;
 }
 
 ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t **buffer,
 		uint32_t *size, const uint32_t max_size, bool bigEndian) {
+	ReturnValue_t result;
+	const uint8_t ** pPoolIdBuffer = &poolIdBuffer;
+	int32_t remainingParametersSize = numberOfParameters * 4;
+	uint8_t validityMaskSize = numberOfParameters/8;
+	uint8_t validityMask[validityMaskSize];
+	memset(validityMask,0, validityMaskSize);
+	for(uint8_t count=0; count < numberOfParameters; count++) {
+		result = serializeCurrentPoolEntryIntoBuffer(pPoolIdBuffer,buffer,
+				&remainingParametersSize,size,max_size, bigEndian,true,validityMask);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	memcpy(*buffer + *size, validityMask, validityMaskSize);
+	*size += validityMaskSize;
+	validBufferIndex = 1;
+	validBufferIndexBit = 0;
 	return RETURN_OK;
 }
 
-void PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,
+ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,
 		uint8_t ** buffer, int32_t * remainingParameters, uint32_t * hkDataSize,
-		const uint32_t max_size, bool bigEndian, bool withValidMask) {
+		const uint32_t max_size, bool bigEndian, bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
 	// Deserialize current pool ID from pool ID buffer
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
 			pPoolIdBuffer,remainingParameters,true);
 	if(result != RETURN_OK) {
 		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing pool IDs" << std::dec << std::endl;
-		return;
+		return result;
 	}
 	PoolRawAccess currentPoolRawAccess(currentPoolId,0,dataSet,PoolVariableIF::VAR_READ);
-	result = dataSet->read();
 
+	// set valid mask bit if necessary
+	if(withValidMask) {
+		if(currentPoolRawAccess.isValid()) {
+			validityMask[validBufferIndex] =
+					bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
+			validBufferIndexBit ++;
+			if(validBufferIndexBit == 8) {
+				validBufferIndex ++;
+				validBufferIndexBit = 1;
+			}
+		}
+	}
+
+	result = dataSet->read();
 	if (result != RETURN_OK) {
 		debug << std::hex << "Pool Raw Access Helper: Error read raw dataset" << std::dec << std::endl;
-		return;
+		return result;
 	}
 	result = dataSet->serialize(buffer, hkDataSize,
 			max_size, bigEndian);
 	if (result != RETURN_OK) {
-		debug << "Service 3: Error serializing pool data into send buffer" << std::endl;
-		return;
+		debug << "Pool Raw Access Helper: Error serializing pool data into send buffer" << std::endl;
 	}
+	return result;
 }
 
 uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position, bool value) {
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index bb19a3cec..36f42f83d 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -14,8 +14,10 @@
  * @brief 	This helper function simplifies accessing data pool entries
  *  	  	via PoolRawAccess
  * @details Can be used for a Housekeeping Service
- * 			like PUS Service 3 if the type of the datapool entries is unknown.
- * 			The provided dataset is serialized into a provided buffer automatically.
+ * 			like  ECSS PUS Service 3 if the type of the datapool entries is unknown.
+ * 			The provided dataset can be serialized into a provided buffer automatically by
+ * 			providing a buffer of pool IDs
+ * @ingroup data_pool
  */
 class PoolRawAccessHelper: public HasReturnvaluesIF {
 public:
@@ -62,9 +64,32 @@ private:
 	const uint8_t * poolIdBuffer;
 	uint8_t numberOfParameters;
 
-	void serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,uint8_t ** buffer,
+	uint8_t validBufferIndex;
+	uint8_t validBufferIndexBit;
+
+	/**
+	 * Helper function to serialize single pool entries
+	 * @param pPoolIdBuffer
+	 * @param buffer
+	 * @param remainingParameters
+	 * @param hkDataSize
+	 * @param max_size
+	 * @param bigEndian
+	 * @param withValidMask Can be set optionally to set a provided validity mask
+	 * @param validityMask Can be supplied and will be set if @c withValidMask is set to true
+	 * @return
+	 */
+	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,uint8_t ** buffer,
 				int32_t * remainingParameters, uint32_t * hkDataSize,const uint32_t max_size,
-				bool bigEndian, bool withValidMask);
+				bool bigEndian, bool withValidMask = false, uint8_t * validityMask = NULL);
+
+	/**
+	 * Sets specific bit of a byte
+	 * @param byte
+	 * @param position Position of byte to set from 1 to 8
+	 * @param value Binary value to set
+	 * @return
+	 */
 	uint8_t bitSetter(uint8_t byte, uint8_t position, bool value);
 };
 

From e24f9b89e4c1965387de84520c80d2439337a9e3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 16:44:50 +0100
Subject: [PATCH 0051/1774] Pool Raw Access Helper tested, appesrs to work.
 SerializeAdapter doc changes, tm packet stored debug output if not enough
 storage available

---
 datapool/PoolRawAccessHelper.cpp  | 42 +++++++++++++++++++------------
 datapool/PoolRawAccessHelper.h    |  7 +++---
 osal/FreeRTOS/MessageQueue.cpp    | 21 ++++++++--------
 serialize/SerializeAdapter.h      | 24 ++++++++++--------
 tmtcpacket/pus/TmPacketStored.cpp |  1 +
 5 files changed, 55 insertions(+), 40 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 5a43e43c7..bacf8ea51 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -6,10 +6,11 @@
  */
 
 #include <framework/datapool/PoolRawAccessHelper.h>
+#include <framework/datapool/DataSet.h>
 
-PoolRawAccessHelper::PoolRawAccessHelper(DataSet *dataSet_,
-		const uint8_t * poolIdBuffer_, uint8_t  numberOfParameters_):
-		dataSet(dataSet_), poolIdBuffer(poolIdBuffer_),
+PoolRawAccessHelper::PoolRawAccessHelper(uint8_t * poolIdBuffer_,
+		uint8_t  numberOfParameters_):
+		poolIdBuffer(poolIdBuffer_),
 		numberOfParameters(numberOfParameters_), validBufferIndex(0), validBufferIndexBit(1){
 }
 
@@ -19,52 +20,61 @@ PoolRawAccessHelper::~PoolRawAccessHelper() {
 ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
 		const uint32_t max_size, bool bigEndian) {
 	ReturnValue_t result;
-	const uint8_t ** pPoolIdBuffer = &poolIdBuffer;
 	int32_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(pPoolIdBuffer,buffer,
+		result = serializeCurrentPoolEntryIntoBuffer(buffer,
 				&remainingParametersSize,size,max_size, bigEndian, false);
 		if(result != RETURN_OK) {
 			return result;
 		}
 	}
-	return RETURN_OK;
+	if(remainingParametersSize != 0) {
+		debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
+		result = RETURN_FAILED;
+	}
+	return result;
 }
 
 ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t **buffer,
 		uint32_t *size, const uint32_t max_size, bool bigEndian) {
 	ReturnValue_t result;
-	const uint8_t ** pPoolIdBuffer = &poolIdBuffer;
 	int32_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = numberOfParameters/8;
 	uint8_t validityMask[validityMaskSize];
 	memset(validityMask,0, validityMaskSize);
-	for(uint8_t count=0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(pPoolIdBuffer,buffer,
+	for(uint8_t count = 0; count < numberOfParameters; count++) {
+		result = serializeCurrentPoolEntryIntoBuffer(buffer,
 				&remainingParametersSize,size,max_size, bigEndian,true,validityMask);
 		if (result != RETURN_OK) {
 			return result;
 		}
 	}
+	if(remainingParametersSize != 0) {
+		debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
+		result = RETURN_FAILED;
+	}
 	memcpy(*buffer + *size, validityMask, validityMaskSize);
 	*size += validityMaskSize;
 	validBufferIndex = 1;
 	validBufferIndexBit = 0;
-	return RETURN_OK;
+	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,
-		uint8_t ** buffer, int32_t * remainingParameters, uint32_t * hkDataSize,
+ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(uint8_t ** buffer,
+		int32_t * remainingParameters, uint32_t * hkDataSize,
 		const uint32_t max_size, bool bigEndian, bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
+	DataSet currentDataSet = DataSet();
 	// Deserialize current pool ID from pool ID buffer
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
-			pPoolIdBuffer,remainingParameters,true);
+			&poolIdBuffer,remainingParameters,true);
 	if(result != RETURN_OK) {
 		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing pool IDs" << std::dec << std::endl;
 		return result;
 	}
-	PoolRawAccess currentPoolRawAccess(currentPoolId,0,dataSet,PoolVariableIF::VAR_READ);
+
+	// info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
+	PoolRawAccess currentPoolRawAccess(currentPoolId,0,&currentDataSet,PoolVariableIF::VAR_READ);
 
 	// set valid mask bit if necessary
 	if(withValidMask) {
@@ -79,12 +89,12 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(const uin
 		}
 	}
 
-	result = dataSet->read();
+	result = currentDataSet.read();
 	if (result != RETURN_OK) {
 		debug << std::hex << "Pool Raw Access Helper: Error read raw dataset" << std::dec << std::endl;
 		return result;
 	}
-	result = dataSet->serialize(buffer, hkDataSize,
+	result = currentDataSet.serialize(buffer, hkDataSize,
 			max_size, bigEndian);
 	if (result != RETURN_OK) {
 		debug << "Pool Raw Access Helper: Error serializing pool data into send buffer" << std::endl;
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 36f42f83d..756ae2863 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -28,8 +28,7 @@ public:
 	 * @param poolIdBuffer_ A buffer of uint32_t pool IDs
 	 * @param numberOfParameters_ The number of parameters / pool IDs
 	 */
-	PoolRawAccessHelper(DataSet * dataSet_, const uint8_t * poolIdBuffer_,
-			uint8_t numberOfParameters_);
+	PoolRawAccessHelper(uint8_t * poolIdBuffer_, uint8_t numberOfParameters_);
 	virtual ~PoolRawAccessHelper();
 
 	/**
@@ -60,7 +59,7 @@ public:
 
 
 private:
-	DataSet * dataSet;
+	// DataSet * dataSet;
 	const uint8_t * poolIdBuffer;
 	uint8_t numberOfParameters;
 
@@ -79,7 +78,7 @@ private:
 	 * @param validityMask Can be supplied and will be set if @c withValidMask is set to true
 	 * @return
 	 */
-	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,uint8_t ** buffer,
+	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(uint8_t ** buffer,
 				int32_t * remainingParameters, uint32_t * hkDataSize,const uint32_t max_size,
 				bool bigEndian, bool withValidMask = false, uint8_t * validityMask = NULL);
 
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index f3aebcd1c..1f514cf38 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -89,23 +89,24 @@ MessageQueueId_t MessageQueue::getDefaultDestination() const {
 bool MessageQueue::isDefaultDestinationSet() const {
 	return 0;
 }
+
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		MessageQueueMessage *message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	message->setSender(sentFrom);
 
-		BaseType_t result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),reinterpret_cast<const void*>(message->getBuffer()), 0);
-		if (result != pdPASS) {
-			if (!ignoreFault) {
-				InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-							objects::INTERNAL_ERROR_REPORTER);
-				if (internalErrorReporter != NULL) {
-					internalErrorReporter->queueMessageNotSent();
-				}
+	BaseType_t result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),reinterpret_cast<const void*>(message->getBuffer()), 0);
+	if (result != pdPASS) {
+		if (!ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != NULL) {
+				internalErrorReporter->queueMessageNotSent();
 			}
-			return MessageQueueIF::FULL;
 		}
-		return HasReturnvaluesIF::RETURN_OK;
+		return MessageQueueIF::FULL;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 
 }
 
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 933d933de..18240a95e 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -10,7 +10,7 @@
  /**
  * @brief This adapter 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 vice-versa.
+ * 		  with different multiple different data types into buffers and vice-versa.
  * @details
  * Examples:
  * A report class is converted into a TM buffer. The report class implements a serialize functions and calls
@@ -20,27 +20,31 @@
  *
  * The AutoSerializeAdapter functions can also be used as an alternative to memcpy
  * to retrieve data out of a buffer directly into a class variable with data type T while being able to specify endianness.
- * The boolean bigEndian specifies the endiness of the data to serialize or deSerialize.
+ * The boolean bigEndian specifies whether an endian swap is performed on the data before
+ * serialization or deserialization.
  *
  * If the target architecture is little endian (ARM), any data types created might
  * have the wrong endiness if they are to be used for the FSFW.
- * there are three ways to retrieve data out of a buffer to be used in the FSFW to use regular aligned (big endian) data.
+ * There are three ways to retrieve data out of a buffer to be used in the FSFW
+ * to use regular aligned (big endian) data.
  * This can also be applied to uint32_t and uint64_t:
  *
- *   1. Use the AutoSerializeAdapter::deSerialize function with bool bigEndian = true:
- *		The pointer *buffer will be incremented automatically by the typeSize of data,
- *		so this function can be called on &buffer without adjusting pointer position
+ *   1. Use the AutoSerializeAdapter::deSerialize function
+ *		The pointer *buffer will be incremented automatically by the typeSize of the object,
+ *		so this function can be called on &buffer repeatedly without adjusting pointer position.
+ *		Set bigEndian parameter to true to perform endian swapping.
  *
  *   	uint16_t data;
  *   	int32_t dataLen = sizeof(data);
  *   	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
  *
- *   2. Perform a bitshift operation:
+ *   2. Perform a bitshift operation. Perform endian swapping if necessary:
  *
  *   	uint16_t data;
- *   	data = buffer[targetByte1] >> 8 | buffer[targetByte2];
+ *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
+ *   	data = EndianSwapper::swap(data);
  *
- *   3. Memcpy can be used when data is little-endian. Otherwise, endian-swapper has to be used.
+ *   3. Memcpy can be used when data is little-endian. Perform endian-swapping if necessary.
  *
  *   	uint16_t data;
  *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
@@ -79,7 +83,7 @@ public:
 	/**
 	 * Deserialize buffer into object
 	 * @param object [out] Object to be deserialized with buffer data
-	 * @param buffer buffer containing the data
+	 * @param buffer buffer containing the data. Non-Const pointer to non-const pointer to const buffer.
 	 * @param size int32_t type to allow value to be values smaller than 0, needed for range/size checking
 	 * @param bigEndian Specify endianness
 	 * @return
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index f2c1eb28a..b1c1ec624 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -22,6 +22,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
 
 	if (returnValue != store->RETURN_OK) {
+		debug << "TM Packet Stored: Issue getting free storage" << std::endl;
 		checkAndReportLostTm();
 		return;
 	}

From 29b4480fc4f6d752e1236e6b9172dc622ea640ba Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 18:55:31 +0100
Subject: [PATCH 0052/1774] include adapted

---
 osal/FreeRTOS/QueueFactory.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index 5c7087dee..eaf245d37 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -1,6 +1,6 @@
 #include <framework/ipc/QueueFactory.h>
 
-#include "../FreeRTOS/MessageQueue.h"
+#include <framework/osal/FreeRTOS/MessageQueue.h>
 
 
 QueueFactory* QueueFactory::factoryInstance = NULL;

From 0066a6b78819777a62f8f1b0ec8512f56b4a49d4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 19:47:46 +0100
Subject: [PATCH 0053/1774] Generic TMTC Bridge added

---
 tmtcservices/TmTcBridge.cpp | 173 ++++++++++++++++++++++++++++++++++++
 tmtcservices/TmTcBridge.h   | 121 +++++++++++++++++++++++++
 2 files changed, 294 insertions(+)
 create mode 100644 tmtcservices/TmTcBridge.cpp
 create mode 100644 tmtcservices/TmTcBridge.h

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
new file mode 100644
index 000000000..e79283173
--- /dev/null
+++ b/tmtcservices/TmTcBridge.cpp
@@ -0,0 +1,173 @@
+/**
+ * @file TmTcBridge.cpp
+ *
+ * @date 26.12.2019
+ */
+
+#include <framework/tmtcservices/TmTcBridge.h>
+
+#include <framework/ipc/QueueFactory.h>
+#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+TmTcBridge::TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_):
+	SystemObject(objectId_),tcStore(NULL), tmStore(NULL),
+	ccsdsPacketDistributor(ccsdsPacketDistributor_), communicationLinkUp(false),
+	tmStored(false) {
+	TmTcReceptionQueue = QueueFactory::instance()->
+			createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
+
+}
+
+TmTcBridge::~TmTcBridge() {
+}
+
+ReturnValue_t TmTcBridge::initialize() {
+	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	if (tcStore == NULL) {
+		return RETURN_FAILED;
+	}
+	tmStore = objectManager->get<StorageManagerIF>(objects::TM_STORE);
+	if (tmStore == NULL) {
+		return RETURN_FAILED;
+	}
+	AcceptsTelecommandsIF* tcDistributor =
+			objectManager->get<AcceptsTelecommandsIF>(ccsdsPacketDistributor);
+	if (tcDistributor == NULL) {
+		return RETURN_FAILED;
+	}
+	TmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
+	return RETURN_OK;
+}
+
+ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
+	ReturnValue_t result;
+	result = handleTc();
+	if(result != RETURN_OK) {
+		error << "TMTC Bridge: Error handling TCs" << std::endl;
+	}
+	result = handleTm();
+	if (result != RETURN_OK) {
+		error << "TMTC Bridge: Error handling TMs" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t TmTcBridge::handleTc() {
+	ReturnValue_t result = receiveTc();
+	return result;
+}
+
+ReturnValue_t TmTcBridge::handleTm() {
+	ReturnValue_t result = readTmQueue();
+	if(result != RETURN_OK) {
+		error << "TMTC Bridge: Reading TM Queue failed" << std::endl;
+		return RETURN_FAILED;
+	}
+
+	if(tmStored && communicationLinkUp) {
+		result = sendStoredTm();
+	}
+	return result;
+
+}
+
+ReturnValue_t TmTcBridge::readTmQueue() {
+	TmTcMessage message;
+	const uint8_t* data = NULL;
+	uint32_t size = 0;
+	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
+		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
+	{
+		if(not communicationLinkUp) {
+			result = storeDownlinkData(&message);
+			return result;
+		}
+
+		result = tmStore->getData(message.getStorageId(), &data, &size);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			continue;
+		}
+
+		result = sendTm(data, size);
+		if (result != RETURN_OK) {
+			error << "UDP Server: Could not send TM packet"<< std::endl;
+			tmStore->deleteData(message.getStorageId());
+			return result;
+
+		}
+		tmStore->deleteData(message.getStorageId());
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
+	info << "UDP Server: Client address not bound yet. Packet can not be sent. "
+			"Saving packet to be sent later " << std::endl;
+	store_address_t storeId;
+
+	if(fifo.full()) {
+		info << "UDP Server: TM downlink store is full. Overwriting old data" << std::endl;
+		fifo.retrieve(&storeId);
+	}
+	storeId = message->getStorageId();
+	fifo.insert(storeId);
+	//storageIdBufferCounter ++;
+	tmStored = true;
+	return RETURN_OK;
+}
+
+ReturnValue_t TmTcBridge::sendStoredTm() {
+	uint8_t counter = 0;
+	ReturnValue_t result = RETURN_OK;
+	while(!fifo.empty() && counter < MAX_STORED_DATA_SENT_PER_CYCLE) {
+		info << "UDP Server: Sending stored TM data. There are "
+				<< (int) fifo.size() << " left to send" << std::endl;
+		store_address_t storeId;
+		const uint8_t* data = NULL;
+		uint32_t size = 0;
+		fifo.retrieve(&storeId);
+		result = tmStore->getData(storeId, &data, &size);
+		sendTm(data,size);
+		if(result != RETURN_OK) {
+			error << "UDP Server: Could not send stored downlink data" << std::endl;
+			result = RETURN_FAILED;
+		}
+		counter ++;
+
+		if(fifo.empty()) {
+			tmStored = false;
+		}
+		tmStore->deleteData(storeId);
+	}
+	return result;
+}
+
+void TmTcBridge::registerCommConnect() {
+	info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
+	if(not communicationLinkUp) {
+		communicationLinkUp = true;
+	}
+}
+
+void TmTcBridge::registerCommDisconnect() {
+	info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
+	if(communicationLinkUp) {
+		communicationLinkUp = false;
+	}
+}
+
+MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
+	return TmTcReceptionQueue->getId();
+}
+
+void TmTcBridge::printData(uint8_t * data, uint32_t dataLen) {
+	info << "TMTC Bridge: Printing data: [";
+	for(uint32_t i=0;i<dataLen;i++) {
+		info << std::hex << (int)data[i];
+		if(i < dataLen-1){
+			info << " , ";
+		}
+	}
+	info << " ] " << std::endl;
+}
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
new file mode 100644
index 000000000..ad09bf7ce
--- /dev/null
+++ b/tmtcservices/TmTcBridge.h
@@ -0,0 +1,121 @@
+/**
+ * @file TmTcBridge.h
+ *
+ * @date 26.12.2019
+ */
+
+#ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
+#define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
+
+#include <framework/tmtcservices/AcceptsTelemetryIF.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+#include <framework/ipc/MessageQueueIF.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/objectmanager/SystemObject.h>
+
+#include <framework/tmtcservices/TmTcMessage.h>
+#include <framework/container/FIFO.h>
+
+class TmTcBridge : public AcceptsTelemetryIF,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF,
+		public SystemObject {
+public:
+	TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_);
+	virtual ~TmTcBridge();
+
+	/**
+	 * Initializes basic FSFW components for TMTC Bridge
+	 * @return
+	 */
+	virtual ReturnValue_t initialize();
+
+	/**
+	 * @brief	The performOperation method is executed in a task.
+	 * @details	There are no restrictions for calls within this method, so any
+	 * 			other member of the class can be used.
+	 * @return	Currently, the return value is ignored.
+	 */
+	virtual ReturnValue_t performOperation(uint8_t operationCode = 0);
+
+	/**
+	 * Return TMTC Reception Queue
+	 * @param virtualChannel
+	 * @return
+	 */
+	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0);
+
+protected:
+	MessageQueueIF* TmTcReceptionQueue; //!< Used to send and receive TMTC messages. TmTcMessage is used to transport messages between tasks.
+	StorageManagerIF* tcStore;
+	StorageManagerIF* tmStore;
+	object_id_t ccsdsPacketDistributor;
+	bool communicationLinkUp; //!< Used to specify whether communication link is up
+	bool tmStored;
+
+	/**
+	 * Handle TC reception. Default implementation provided
+	 * @return
+	 */
+	virtual ReturnValue_t handleTc();
+
+	/**
+	 * Implemented by child class. Perform receiving of Telecommand
+	 * @return
+	 */
+	virtual ReturnValue_t receiveTc() = 0;
+
+	/**
+	 * Handle Telemetry. Default implementation provided.
+	 * Calls sendTm()
+	 * @return
+	 */
+	virtual ReturnValue_t handleTm();
+
+	/**
+	 * Read the TM Queue and send TM if necessary. Default implementation provided
+	 * @return
+	 */
+	virtual ReturnValue_t readTmQueue();
+
+	/**
+	 * Implemented by child class. Perform sending of Telemetry
+	 * @param data
+	 * @param dataLen
+	 * @return
+	 */
+	virtual ReturnValue_t sendTm(const uint8_t * data, uint32_t dataLen) = 0;
+
+	/**
+	 * Store data to be sent later if communication link is not up.
+	 * @param message
+	 * @return
+	 */
+	ReturnValue_t storeDownlinkData(TmTcMessage * message);
+
+	/**
+	 * Send stored data if communication link is active
+	 * @return
+	 */
+	ReturnValue_t sendStoredTm();
+
+	/**
+	 * Print data as hexidecimal array
+	 * @param data
+	 * @param dataLen
+	 */
+	void printData(uint8_t * data, uint32_t dataLen);
+
+	void registerCommConnect();
+	void registerCommDisconnect();
+
+private:
+	static const uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
+	static const uint8_t MAX_STORED_DATA_SENT_PER_CYCLE = 10;
+	static const uint8_t MAX_DOWNLINK_PACKETS_STORED = 20;
+
+	FIFO<store_address_t, MAX_DOWNLINK_PACKETS_STORED> fifo;
+};
+
+
+#endif /* FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ */

From 8397f5b2b1961bc875282829fa687adb6cdb6d97 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 20:17:21 +0100
Subject: [PATCH 0054/1774] tmtc bridge bugfix

---
 tmtcservices/TmTcBridge.cpp | 5 +++--
 tmtcservices/TmTcBridge.h   | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index e79283173..9e863ffd0 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -2,6 +2,7 @@
  * @file TmTcBridge.cpp
  *
  * @date 26.12.2019
+ * @author R. Mueller
  */
 
 #include <framework/tmtcservices/TmTcBridge.h>
@@ -144,8 +145,8 @@ ReturnValue_t TmTcBridge::sendStoredTm() {
 }
 
 void TmTcBridge::registerCommConnect() {
-	info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
-	if(not communicationLinkUp) {
+	if(!communicationLinkUp) {
+		info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
 		communicationLinkUp = true;
 	}
 }
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index ad09bf7ce..0f045e474 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -25,7 +25,7 @@ public:
 	virtual ~TmTcBridge();
 
 	/**
-	 * Initializes basic FSFW components for TMTC Bridge
+	 * Initializes basic FSFW components for the TMTC Bridge
 	 * @return
 	 */
 	virtual ReturnValue_t initialize();

From 19e257a90aa57622732177166a9b1ff547da9456 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 20:35:11 +0100
Subject: [PATCH 0055/1774] tmtc bridge debug output corrected

---
 tmtcservices/TmTcBridge.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 9e863ffd0..6415cb358 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -103,12 +103,13 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 }
 
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
-	info << "UDP Server: Client address not bound yet. Packet can not be sent. "
-			"Saving packet to be sent later " << std::endl;
+	info << "TMTC Bridge: Comm Link down. "
+			"Saving packet ID to be sent later " << std::endl;
 	store_address_t storeId;
 
 	if(fifo.full()) {
-		info << "UDP Server: TM downlink store is full. Overwriting old data" << std::endl;
+		info << "TMTC Bridge: TM downlink max. number of stored packet IDs reached."
+				" Overwriting old data" << std::endl;
 		fifo.retrieve(&storeId);
 	}
 	storeId = message->getStorageId();

From 33a7c033a27dd741ebbec31f5d517b6acabd342a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 20:38:15 +0100
Subject: [PATCH 0056/1774] doc extended, instructions for sendTm and receiveTc

---
 tmtcservices/TmTcBridge.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 0f045e474..216dae8ba 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -60,7 +60,8 @@ protected:
 	virtual ReturnValue_t handleTc();
 
 	/**
-	 * Implemented by child class. Perform receiving of Telecommand
+	 * Implemented by child class. Perform receiving of Telecommand, for example by implementing
+	 * specific drivers or wrappers, e.g. UART Communication or lwIP stack
 	 * @return
 	 */
 	virtual ReturnValue_t receiveTc() = 0;
@@ -79,7 +80,8 @@ protected:
 	virtual ReturnValue_t readTmQueue();
 
 	/**
-	 * Implemented by child class. Perform sending of Telemetry
+	 * Implemented by child class. Perform sending of Telemetry by implementing
+	 * communication drivers or wrappers, e.g. UART communication or lwIP stack.
 	 * @param data
 	 * @param dataLen
 	 * @return

From a38a2f4b3a4e07b77e4989300871c91705496718 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 22:07:17 +0100
Subject: [PATCH 0057/1774] tmtc bridge bugfix: tm data deleted when
 overwriting old data

---
 tmtcservices/TmTcBridge.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 6415cb358..860589c5a 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -111,6 +111,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 		info << "TMTC Bridge: TM downlink max. number of stored packet IDs reached."
 				" Overwriting old data" << std::endl;
 		fifo.retrieve(&storeId);
+		tmStore->deleteData(storeId);
 	}
 	storeId = message->getStorageId();
 	fifo.insert(storeId);

From 79e7fee8072abbf40d65d2114157f35d856bbb5d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 22:15:19 +0100
Subject: [PATCH 0058/1774] comment deleted

---
 tmtcservices/TmTcBridge.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 860589c5a..6af6d5248 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -115,7 +115,6 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	}
 	storeId = message->getStorageId();
 	fifo.insert(storeId);
-	//storageIdBufferCounter ++;
 	tmStored = true;
 	return RETURN_OK;
 }

From 666341d03ddbe1394e452b0f15af2a4457a0f148 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 27 Dec 2019 22:43:09 +0100
Subject: [PATCH 0059/1774] new bool datatype for possible pool entries

---
 datapool/DataPool.cpp  | 1 +
 datapool/PoolEntry.cpp | 1 +
 2 files changed, 2 insertions(+)

diff --git a/datapool/DataPool.cpp b/datapool/DataPool.cpp
index 89543d776..1d3af7423 100644
--- a/datapool/DataPool.cpp
+++ b/datapool/DataPool.cpp
@@ -79,6 +79,7 @@ void DataPool::print() {
 	}
 }
 
+template PoolEntry<bool>* DataPool::getData<bool>( uint32_t data_pool_id,  uint8_t size );
 template PoolEntry<uint8_t>* DataPool::getData<uint8_t>( uint32_t data_pool_id,  uint8_t size );
 template PoolEntry<uint16_t>* DataPool::getData<uint16_t>( uint32_t data_pool_id,  uint8_t size );
 template PoolEntry<uint32_t>* DataPool::getData<uint32_t>( uint32_t data_pool_id,  uint8_t size );
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index c303e56b8..f2968c329 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -56,6 +56,7 @@ Type PoolEntry<T>::getType() {
 	return PodTypeConversion<T>::type;
 }
 
+template class PoolEntry<bool>;
 template class PoolEntry<uint8_t>;
 template class PoolEntry<uint16_t>;
 template class PoolEntry<uint32_t>;

From 2425685e446ec9a0dae320ea6f0cf0ca95e0cd33 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 29 Dec 2019 01:59:02 +0100
Subject: [PATCH 0060/1774] Pool Raw Access Helper serialization of vectors
 implemented

---
 datapool/PoolRawAccessHelper.cpp        | 91 ++++++++++++++++---------
 datapool/PoolRawAccessHelper.h          | 15 +++-
 serialize/SerialFixedArrayListAdapter.h |  2 +-
 3 files changed, 71 insertions(+), 37 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index bacf8ea51..b17666712 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -19,11 +19,12 @@ PoolRawAccessHelper::~PoolRawAccessHelper() {
 
 ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
 		const uint32_t max_size, bool bigEndian) {
+	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
 	ReturnValue_t result;
 	int32_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(buffer,
-				&remainingParametersSize,size,max_size, bigEndian, false);
+		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
+				&remainingParametersSize, false);
 		if(result != RETURN_OK) {
 			return result;
 		}
@@ -35,16 +36,17 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t **buffer,
-		uint32_t *size, const uint32_t max_size, bool bigEndian) {
+ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer, uint32_t * size,
+		const uint32_t max_size, bool bigEndian) {
 	ReturnValue_t result;
+	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
 	int32_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = numberOfParameters/8;
 	uint8_t validityMask[validityMaskSize];
 	memset(validityMask,0, validityMaskSize);
 	for(uint8_t count = 0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(buffer,
-				&remainingParametersSize,size,max_size, bigEndian,true,validityMask);
+		result = serializeCurrentPoolEntryIntoBuffer(argStruct,
+				&remainingParametersSize,true,validityMask);
 		if (result != RETURN_OK) {
 			return result;
 		}
@@ -60,11 +62,9 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t **buffer,
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(uint8_t ** buffer,
-		int32_t * remainingParameters, uint32_t * hkDataSize,
-		const uint32_t max_size, bool bigEndian, bool withValidMask, uint8_t * validityMask) {
+ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
+		int32_t * remainingParameters, bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
-	DataSet currentDataSet = DataSet();
 	// Deserialize current pool ID from pool ID buffer
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
 			&poolIdBuffer,remainingParameters,true);
@@ -72,36 +72,61 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(uint8_t *
 		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing pool IDs" << std::dec << std::endl;
 		return result;
 	}
+	result = handlePoolEntrySerialization(currentPoolId, argStruct, withValidMask, validityMask);
+	return result;
+}
 
-	// info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
-	PoolRawAccess currentPoolRawAccess(currentPoolId,0,&currentDataSet,PoolVariableIF::VAR_READ);
-
-	// set valid mask bit if necessary
-	if(withValidMask) {
-		if(currentPoolRawAccess.isValid()) {
-			validityMask[validBufferIndex] =
-					bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
-			validBufferIndexBit ++;
-			if(validBufferIndexBit == 8) {
-				validBufferIndex ++;
-				validBufferIndexBit = 1;
+ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
+		bool withValidMask, uint8_t * validityMask) {
+	ReturnValue_t result;
+	uint8_t arrayPosition = 0;
+	bool poolEntrySerialized = false;
+	info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
+	while(not poolEntrySerialized) {
+		DataSet currentDataSet = DataSet();
+		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);
+		result = currentDataSet.read();
+		if (result != RETURN_OK) {
+			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset" << std::dec << std::endl;
+			return result;
+		}
+		uint8_t remainingSize = currentPoolRawAccess.getSizeTillEnd() - currentPoolRawAccess.getSizeOfType();
+		if(remainingSize == 0) {
+			poolEntrySerialized = true;
+		}
+		else if(remainingSize > 0) {
+			arrayPosition += currentPoolRawAccess.getSizeOfType() / 8;
+		}
+		else {
+			error << "Pool Raw Access Helper: Configuration Error. Size till end smaller than 0" << std::endl;
+			return result;
+		}
+		// set valid mask bit if necessary
+		if(withValidMask) {
+			if(currentPoolRawAccess.isValid()) {
+				handleMaskModification(validityMask);
 			}
 		}
-	}
-
-	result = currentDataSet.read();
-	if (result != RETURN_OK) {
-		debug << std::hex << "Pool Raw Access Helper: Error read raw dataset" << std::dec << std::endl;
-		return result;
-	}
-	result = currentDataSet.serialize(buffer, hkDataSize,
-			max_size, bigEndian);
-	if (result != RETURN_OK) {
-		debug << "Pool Raw Access Helper: Error serializing pool data into send buffer" << std::endl;
+		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
+				argStruct.max_size, argStruct.bigEndian);
+		if (result != RETURN_OK) {
+			debug << "Pool Raw Access Helper: Error serializing pool data into send buffer" << std::endl;
+			return result;
+		}
 	}
 	return result;
 }
 
+void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
+	validityMask[validBufferIndex] =
+			bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
+	validBufferIndexBit ++;
+	if(validBufferIndexBit == 8) {
+		validBufferIndex ++;
+		validBufferIndexBit = 1;
+	}
+}
+
 uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position, bool value) {
 	if(position < 1 or position > 8) {
 		debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 756ae2863..25d8b1635 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -66,6 +66,12 @@ private:
 	uint8_t validBufferIndex;
 	uint8_t validBufferIndexBit;
 
+	struct SerializationArgs {
+		uint8_t ** buffer;
+		uint32_t * size;
+		const uint32_t max_size;
+		bool bigEndian;
+	};
 	/**
 	 * Helper function to serialize single pool entries
 	 * @param pPoolIdBuffer
@@ -78,10 +84,13 @@ private:
 	 * @param validityMask Can be supplied and will be set if @c withValidMask is set to true
 	 * @return
 	 */
-	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(uint8_t ** buffer,
-				int32_t * remainingParameters, uint32_t * hkDataSize,const uint32_t max_size,
-				bool bigEndian, bool withValidMask = false, uint8_t * validityMask = NULL);
+	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
+				int32_t * remainingParameters, bool withValidMask = false, uint8_t * validityMask = NULL);
 
+	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
+				bool withValidMask = false, uint8_t * validityMask = NULL);
+
+	void handleMaskModification(uint8_t * validityMask);
 	/**
 	 * Sets specific bit of a byte
 	 * @param byte
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 593a0ec1d..c8424f05d 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -9,7 +9,7 @@
  *        buffers with a header containing the buffer length.
  * @details
  * Can be used by SerialLinkedListAdapter by using this type in
- * SerializeElement<>
+ * SerializeElement<>.
  * Buffers with a size header inside that class can be declared with
  * SerialFixedArrayListAdapter<bufferType,MAX_BUFFER_LENGTH,typeOfMaxData>.
  * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows

From a762c159fe334f1e1be6f448dd9ed6ea2519246b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Dec 2019 01:13:33 +0100
Subject: [PATCH 0061/1774] pool raw access helper info output commented out

---
 datapool/PoolRawAccessHelper.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index b17666712..fae45b535 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -81,7 +81,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 	ReturnValue_t result;
 	uint8_t arrayPosition = 0;
 	bool poolEntrySerialized = false;
-	info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
+	//info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
 	while(not poolEntrySerialized) {
 		DataSet currentDataSet = DataSet();
 		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);

From c73cb90c3645f50794cd2919ef73fc755cc93948 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Jan 2020 16:54:05 +0100
Subject: [PATCH 0062/1774] receiveTc function adapted

---
 tmtcservices/TmTcBridge.cpp | 4 ++--
 tmtcservices/TmTcBridge.h   | 6 +++++-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 6af6d5248..ddd63d477 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -14,7 +14,7 @@
 TmTcBridge::TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_):
 	SystemObject(objectId_),tcStore(NULL), tmStore(NULL),
 	ccsdsPacketDistributor(ccsdsPacketDistributor_), communicationLinkUp(false),
-	tmStored(false) {
+	tmStored(false), size(0) {
 	TmTcReceptionQueue = QueueFactory::instance()->
 			createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
 
@@ -55,7 +55,7 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 }
 
 ReturnValue_t TmTcBridge::handleTc() {
-	ReturnValue_t result = receiveTc();
+	ReturnValue_t result = receiveTc(&recvBuffer, &size);
 	return result;
 }
 
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 216dae8ba..8edf3f376 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -62,9 +62,11 @@ protected:
 	/**
 	 * Implemented by child class. Perform receiving of Telecommand, for example by implementing
 	 * specific drivers or wrappers, e.g. UART Communication or lwIP stack
+	 * @param recvBuffer [out] Received data
+	 * @param size [out] Size of received data
 	 * @return
 	 */
-	virtual ReturnValue_t receiveTc() = 0;
+	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer, uint32_t * size) = 0;
 
 	/**
 	 * Handle Telemetry. Default implementation provided.
@@ -117,6 +119,8 @@ private:
 	static const uint8_t MAX_DOWNLINK_PACKETS_STORED = 20;
 
 	FIFO<store_address_t, MAX_DOWNLINK_PACKETS_STORED> fifo;
+	uint8_t * recvBuffer;
+	uint32_t size;
 };
 
 

From 831a01e79ef7d5c5fd6885486f9a9fc7333d504e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Jan 2020 17:31:17 +0100
Subject: [PATCH 0063/1774] recvBuffer and recvSize initialized

---
 tmtcservices/TmTcBridge.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index ddd63d477..7cc97d0d0 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -14,7 +14,7 @@
 TmTcBridge::TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_):
 	SystemObject(objectId_),tcStore(NULL), tmStore(NULL),
 	ccsdsPacketDistributor(ccsdsPacketDistributor_), communicationLinkUp(false),
-	tmStored(false), size(0) {
+	tmStored(false),recvBuffer(NULL), size(0) {
 	TmTcReceptionQueue = QueueFactory::instance()->
 			createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
 

From e2f07cbcd1436176c45ad8c846657436b0aed832 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 2 Jan 2020 14:01:21 +0100
Subject: [PATCH 0064/1774] connect and disconnect functions public

---
 tmtcservices/TmTcBridge.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 8edf3f376..7870e79b7 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -45,6 +45,8 @@ public:
 	 */
 	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0);
 
+	void registerCommConnect();
+	void registerCommDisconnect();
 protected:
 	MessageQueueIF* TmTcReceptionQueue; //!< Used to send and receive TMTC messages. TmTcMessage is used to transport messages between tasks.
 	StorageManagerIF* tcStore;
@@ -110,9 +112,6 @@ protected:
 	 */
 	void printData(uint8_t * data, uint32_t dataLen);
 
-	void registerCommConnect();
-	void registerCommDisconnect();
-
 private:
 	static const uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
 	static const uint8_t MAX_STORED_DATA_SENT_PER_CYCLE = 10;

From f6e88e83db014f529151126d7ba5fe681604981c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 2 Jan 2020 21:12:21 +0100
Subject: [PATCH 0065/1774] debug output change

---
 tmtcservices/TmTcBridge.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 7cc97d0d0..e402d79eb 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -80,7 +80,7 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
 	{
-		if(not communicationLinkUp) {
+		if(communicationLinkUp == false) {
 			result = storeDownlinkData(&message);
 			return result;
 		}
@@ -92,7 +92,7 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 
 		result = sendTm(data, size);
 		if (result != RETURN_OK) {
-			error << "UDP Server: Could not send TM packet"<< std::endl;
+			error << "TMTC Bridge: Could not send TM packet"<< std::endl;
 			tmStore->deleteData(message.getStorageId());
 			return result;
 

From a7450144de20cb086ba5a9602bd5a7ad44fb83af Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 3 Jan 2020 15:39:32 +0100
Subject: [PATCH 0066/1774] doxygen group definitions moved to framework

---
 devicehandlers/DeviceCommunicationIF.h | 4 ++++
 subsystem/SubsystemBase.h              | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index ca0e9fe27..06c228f72 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -3,6 +3,10 @@
 
 #include <framework/devicehandlers/Cookie.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+/**
+ * @defgroup interfaces Interfaces
+ * @brief Communication interfaces for flight software objects
+ */
 
 /**
  * @brief This is an interface to decouple device communication from
diff --git a/subsystem/SubsystemBase.h b/subsystem/SubsystemBase.h
index 3294c46d7..1a050a9aa 100644
--- a/subsystem/SubsystemBase.h
+++ b/subsystem/SubsystemBase.h
@@ -12,6 +12,10 @@
 #include <framework/ipc/MessageQueueIF.h>
 #include <map>
 
+/**
+ * @defgroup subsystems Subsystem Objects
+ * Contains all Subsystem and Assemblies
+ */
 class SubsystemBase: public SystemObject,
 		public HasModesIF,
 		public HasHealthIF,

From 827f185e20788b0b72eaf4cd5d322e78fb7cadd6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 4 Jan 2020 16:37:08 +0100
Subject: [PATCH 0067/1774] Some bugfixes(?) for PusServiceBase. Getter
 Function for Serial Buffer Adapter.

---
 container/FixedMap.h              |  8 ++++----
 container/FixedOrderedMultimap.h  |  2 +-
 returnvalues/FwClassIds.h         |  1 +
 serialize/SerialBufferAdapter.cpp |  8 ++++----
 serialize/SerialBufferAdapter.h   |  2 +-
 tmtcservices/PusServiceBase.h     | 18 +++++++++++++-----
 6 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 5e8ca9c35..d664a0861 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -16,8 +16,8 @@ template<typename key_t, typename T>
 class FixedMap: public SerializeIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01); //!< P1: SID for HK packets
+	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02); //!< P1: SID for HK packets
 	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
 
 private:
@@ -88,10 +88,10 @@ public:
 
 	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
 		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
-			return KEY_ALREADY_EXISTS;
+			return FixedMap::KEY_ALREADY_EXISTS;
 		}
 		if (_size == theMap.maxSize()) {
-			return MAP_FULL;
+			return FixedMap::MAP_FULL;
 		}
 		theMap[_size].first = key;
 		theMap[_size].second = value;
diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 21629664b..3dd20a749 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -10,7 +10,7 @@
 template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
 class FixedOrderedMultimap {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
+	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
 	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
 	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index d21861c08..beef04754 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -24,6 +24,7 @@ enum {
 	MEMORY_HELPER, //MH
 	SERIALIZE_IF, //SE
 	FIXED_MAP, //FM
+	FIXED_MULTIMAP, //FMM
 	HAS_HEALTH_IF, //HHI
 	FIFO_CLASS, //FF
 	MESSAGE_PROXY, //MQP
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index d7ab0d880..a365cc993 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -96,10 +96,10 @@ uint8_t * SerialBufferAdapter<T>::getBuffer() {
 	return buffer;
 }
 
-//template<typename T>
-//void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_) {
-//	buffer = buffer_;
-//}
+template<typename T>
+void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_) {
+	buffer = buffer_;
+}
 
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 0438f8841..cee2cb263 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -56,7 +56,7 @@ public:
 			bool bigEndian);
 
 	uint8_t * getBuffer();
-	//void setBuffer(uint8_t * buffer_);
+	void setBuffer(uint8_t * buffer_);
 private:
 	bool serializeLength;
 	const uint8_t *constBuffer;
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 2b5e8b67c..6c8c5f617 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -46,13 +46,20 @@ public:
 	 */
 	virtual ~PusServiceBase();
 	/**
-	 * The handleRequest method shall handle any kind of Telecommand Request immediately.
+	 * @brief The handleRequest method shall handle any kind of Telecommand Request immediately.
+	 * @details
 	 * Implemetations can take the Telecommand in currentPacket and perform any kind of operation.
 	 * They may send additional "Start Success (1,3)" messages with the verifyReporter, but Completion
 	 * Success or Failure Reports are generated automatically after execution of this method.
-	 * If a Telecommand can not be executed within one call cycle, this Base class is not the right parent.
-	 * The child class may add additional error information in #errorParameters which are attached to the generated
-	 * verification message. Subservice checking should be implemented in this method.
+	 *
+	 * If a Telecommand can not be executed within one call cycle,
+	 * this Base class is not the right parent.
+	 *
+	 * The child class may add additional error information by setting #errorParameters which are
+	 * attached to the generated verification message.
+	 *
+	 * Subservice checking should be implemented in this method.
+	 *
 	 * @return	The returned status_code is directly taken as main error code in the Verification Report.
 	 * 			On success, RETURN_OK shall be returned.
 	 */
@@ -91,7 +98,8 @@ protected:
 	/**
 	 * One of two error parameters for additional error information.
 	 */
-	uint8_t errorParameter2;
+	// shouldn't this be uint32_t ? The PUS Verification Message structure param2 has the size 4
+	uint32_t errorParameter2;
 	/**
 	 * This is a complete instance of the Telecommand reception queue of the class.
 	 * It is initialized on construction of the class.

From 2ec486a8806f9c0bdf287ef81b04c6b494c592ef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jan 2020 18:20:57 +0100
Subject: [PATCH 0068/1774] max number of stored packets lowered

---
 tmtcservices/TmTcBridge.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 7870e79b7..8e4124e08 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -115,7 +115,7 @@ protected:
 private:
 	static const uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
 	static const uint8_t MAX_STORED_DATA_SENT_PER_CYCLE = 10;
-	static const uint8_t MAX_DOWNLINK_PACKETS_STORED = 20;
+	static const uint8_t MAX_DOWNLINK_PACKETS_STORED = 15;
 
 	FIFO<store_address_t, MAX_DOWNLINK_PACKETS_STORED> fifo;
 	uint8_t * recvBuffer;

From 59b25bee863987dd8a38517f95ac3dc2b780be1a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 9 Jan 2020 19:04:33 +0100
Subject: [PATCH 0069/1774] pool raw helper input buffer type changed to
 uint32_t

---
 datapool/PoolRawAccessHelper.cpp | 4 ++--
 datapool/PoolRawAccessHelper.h   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index fae45b535..e1ae56bf1 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -8,9 +8,9 @@
 #include <framework/datapool/PoolRawAccessHelper.h>
 #include <framework/datapool/DataSet.h>
 
-PoolRawAccessHelper::PoolRawAccessHelper(uint8_t * poolIdBuffer_,
+PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
 		uint8_t  numberOfParameters_):
-		poolIdBuffer(poolIdBuffer_),
+		poolIdBuffer(reinterpret_cast<uint8_t * >(poolIdBuffer_)),
 		numberOfParameters(numberOfParameters_), validBufferIndex(0), validBufferIndexBit(1){
 }
 
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 25d8b1635..e9e9c8ec5 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -28,7 +28,7 @@ public:
 	 * @param poolIdBuffer_ A buffer of uint32_t pool IDs
 	 * @param numberOfParameters_ The number of parameters / pool IDs
 	 */
-	PoolRawAccessHelper(uint8_t * poolIdBuffer_, uint8_t numberOfParameters_);
+	PoolRawAccessHelper(uint32_t * poolIdBuffer_, uint8_t numberOfParameters_);
 	virtual ~PoolRawAccessHelper();
 
 	/**

From 0ce67de8c8eb8f4eb532e4445e3a1e3765ff07f2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jan 2020 00:57:09 +0100
Subject: [PATCH 0070/1774] Changes to pool access classes

1. PoolRawAccessHelper is more robust now and has better error handling
2. PoolRawAccess: Removed an unneeded constructor value, moved serialize
further to the top. Added new returnvalues and more precise error
handling for read() call
3. DataSet: Made MAX Number of data pool entries public so it can be
used by pool raw access error handling
---
 datapool/DataSet.h               |  71 +++++++-------
 datapool/PoolRawAccess.cpp       |  72 +++++++++------
 datapool/PoolRawAccess.h         | 153 ++++++++++++++++---------------
 datapool/PoolRawAccessHelper.cpp |  51 ++++++++---
 datapool/PoolRawAccessHelper.h   |   2 +
 5 files changed, 199 insertions(+), 150 deletions(-)

diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index deee8ca66..e8e1a5972 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -37,44 +37,11 @@
  *	\ingroup data_pool
  */
 class DataSet: public DataSetIF, public HasReturnvaluesIF, public SerializeIF {
-private:
+
+public:
 	//SHOULDDO we could use a linked list of datapool variables
 	static const uint8_t DATA_SET_MAX_SIZE = 63; //!< This definition sets the maximum number of variables to register in one DataSet.
 
-	/**
-	 * \brief	This array represents all pool variables registered in this set.
-	 * \details	It has a maximum size of DATA_SET_MAX_SIZE.
-	 */
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-	/**
-	 * \brief	The fill_count attribute ensures that the variables register in the correct array
-	 * 			position and that the maximum number of variables is not exceeded.
-	 */
-	uint16_t fill_count;
-	/**
-	 * States of the seet.
-	 */
-	enum States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
-	};
-	/**
-	 * \brief	state manages the internal state of the data set, which is important e.g. for the
-	 * 			behavior on destruction.
-	 */
-	States state;
-	/**
-	 * \brief	This is a small helper function to facilitate locking the global data pool.
-	 * \details	It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	uint8_t lockDataPool();
-	/**
-	 * \brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * \details	It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	uint8_t freeDataPoolLock();
-
-public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
 	static const ReturnValue_t INVALID_PARAMETER_DEFINITION =
 			MAKE_RETURN_CODE( 0x01 );
@@ -165,6 +132,40 @@ public:
 	ReturnValue_t serializeRawFromIdBuffer(uint8_t ** buffer, uint32_t * size,
 			const uint32_t max_size, bool bigEndian, uint32_t * poolIdBuffer,
 			uint32_t poolIdSize);
+private:
+	/**
+	 * \brief	This array represents all pool variables registered in this set.
+	 * \details	It has a maximum size of DATA_SET_MAX_SIZE.
+	 */
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
+	/**
+	 * \brief	The fill_count attribute ensures that the variables register in the correct array
+	 * 			position and that the maximum number of variables is not exceeded.
+	 */
+	uint16_t fill_count;
+	/**
+	 * States of the seet.
+	 */
+	enum States {
+		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
+		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
+	};
+	/**
+	 * \brief	state manages the internal state of the data set, which is important e.g. for the
+	 * 			behavior on destruction.
+	 */
+	States state;
+	/**
+	 * \brief	This is a small helper function to facilitate locking the global data pool.
+	 * \details	It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	uint8_t lockDataPool();
+	/**
+	 * \brief	This is a small helper function to facilitate unlocking the global data pool.
+	 * \details	It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	uint8_t freeDataPoolLock();
+
 };
 
 #endif /* DATASET_H_ */
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 7cc618528..c4e327b19 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -5,8 +5,7 @@
 #include <framework/osal/Endiness.h>
 
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode,
-		bool registerVectors) :
+		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode) :
 		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false), type(Type::UNKNOWN_TYPE), typeSize(
 				0), arraySize(0), sizeTillEnd(0), readWriteMode(setReadWriteMode) {
 	memset(value, 0, sizeof(value));
@@ -20,6 +19,7 @@ PoolRawAccess::~PoolRawAccess() {
 }
 
 ReturnValue_t PoolRawAccess::read() {
+	ReturnValue_t result = RETURN_FAILED;
 	PoolEntryIF* read_out = ::dataPool.getRawData(dataPoolId);
 	if (read_out != NULL) {
 		valid = read_out->getValid();
@@ -35,21 +35,30 @@ ReturnValue_t PoolRawAccess::read() {
 				memcpy(value, ptr, typeSize);
 				return HasReturnvaluesIF::RETURN_OK;
 			} else {
-				//Error value type too large.
+				result = READ_TYPE_TOO_LARGE;
 			}
 		} else {
-			//Error index requested too large
+			result = READ_INDEX_TOO_LARGE;
 		}
 	} else {
-		//Error entry does not exist.
+		result = READ_ENTRY_NON_EXISTENT;
 	}
 	error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed." << std::endl;
+			<< std::dec << " failed, ";
+	if(result == READ_TYPE_TOO_LARGE) {
+		error << "type too large." << std::endl;
+	}
+	else if(result == READ_INDEX_TOO_LARGE) {
+		error << "index too large." << std::endl;
+	}
+	else {
+		error << "entry does not exist." << std::endl;
+	}
 	valid = INVALID;
 	typeSize = 0;
 	sizeTillEnd = 0;
 	memset(value, 0, sizeof(value));
-	return HasReturnvaluesIF::RETURN_FAILED;
+	return result;
 }
 
 ReturnValue_t PoolRawAccess::commit() {
@@ -90,6 +99,32 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
+		const uint32_t max_size, bool bigEndian) const {
+	if (typeSize + *size <= max_size) {
+		if (bigEndian) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+			for (uint8_t count = 0; count < typeSize; count++) {
+				(*buffer)[count] = value[typeSize - count - 1];
+			}
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			memcpy(*buffer, value, typeSize);
+#endif
+		} else {
+			memcpy(*buffer, value, typeSize);
+		}
+		*size += typeSize;
+		(*buffer) += typeSize;
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SerializeIF::BUFFER_TOO_SHORT;
+	}
+}
+
+
 Type PoolRawAccess::getType() {
 	return type;
 }
@@ -146,29 +181,6 @@ uint16_t PoolRawAccess::getSizeTillEnd() const {
 	return sizeTillEnd;
 }
 
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
-	if (typeSize + *size <= max_size) {
-		if (bigEndian) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for (uint8_t count = 0; count < typeSize; count++) {
-				(*buffer)[count] = value[typeSize - count - 1];
-			}
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(*buffer, value, typeSize);
-#endif
-		} else {
-			memcpy(*buffer, value, typeSize);
-		}
-		*size += typeSize;
-		(*buffer) += typeSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SerializeIF::BUFFER_TOO_SHORT;
-	}
-}
 
 uint32_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 603bae239..432d9ad95 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -15,70 +15,17 @@
  * data pool access.
  * @ingroup data_pool
  */
-class PoolRawAccess: public PoolVariableIF {
-private:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The array entry that is fetched from the data pool.
-	 */
-	uint8_t arrayEntry;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 *  \brief	This value contains the type of the data pool entry.
-	 */
-	Type type;
-	/**
-	 * \brief	This value contains the size of the data pool entry type in bytes.
-	 */
-	uint8_t typeSize;
-	/**
-	 * The size of the DP array (single values return 1)
-	 */
-	uint8_t arraySize;
-	/**
-	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
-	 */
-	uint16_t sizeTillEnd;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
-protected:
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself !
-	 * 			If reading from the data pool without information about the type is desired,
-	 * 			initialize the raw pool access by supplying a data set and using the data set
-	 * 			read function, which calls this read function.
-	 */
-	ReturnValue_t read();
-	/**
-	 * \brief	The commit call writes back the variable's value to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit();
+class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
 public:
-
 	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
 	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
+	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 	uint8_t value[RAW_MAX_SIZE];
-	//PoolRawAccess();
+
 	/**
 	 * This constructor is used to access a data pool entry with a
 	 * given ID if the target type is not known. A DataSet object is supplied
@@ -96,25 +43,13 @@ public:
 	 */
 	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
 			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-			PoolVariableIF::VAR_READ,bool registerVectors = false);
+			PoolVariableIF::VAR_READ);
 	/**
 	 * \brief	The classes destructor is empty. If commit() was not called, the local value is
 	 * 			discarded and not written back to the data pool.
 	 */
 	~PoolRawAccess();
 
-	/**
-	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @param buffer Provided buffer. Raw pool data will be copied here
-	 * @param size [out] Increment provided size value by serialized size
-	 * @param max_size Maximum allowed serialization size
-	 * @param bigEndian Specify endianess
-	 * @return - @c RETURN_OK if serialization was successfull
-	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
-
 	/**
 	 * \brief	This operation returns a pointer to the entry fetched.
 	 * \details	Return pointer to the buffer containing the raw data
@@ -136,6 +71,19 @@ public:
 	 */
 	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
 			uint32_t max_size);
+
+	/**
+	 * @brief 	Serialize raw pool entry into provided buffer directly
+	 * @param buffer Provided buffer. Raw pool data will be copied here
+	 * @param size [out] Increment provided size value by serialized size
+	 * @param max_size Maximum allowed serialization size
+	 * @param bigEndian Specify endianess
+	 * @return - @c RETURN_OK if serialization was successfull
+	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
+	 */
+	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const;
+
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
 	 * @param buffer	Pointer to the data to set
@@ -181,6 +129,67 @@ public:
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
+
+protected:
+	/**
+	 * \brief	This is a call to read the value from the global data pool.
+	 * \details	When executed, this operation tries to fetch the pool entry with matching
+	 * 			data pool id from the global data pool and copies the value and the valid
+	 * 			information to its local attributes. In case of a failure (wrong type or
+	 * 			pool id not found), the variable is set to zero and invalid.
+	 * 			The operation does NOT provide any mutual exclusive protection by itself !
+	 * 			If reading from the data pool without information about the type is desired,
+	 * 			initialize the raw pool access by supplying a data set and using the data set
+	 * 			read function, which calls this read function.
+	 * @return -@c RETURN_OK Read successfull
+	 * 		   -@c READ_TYPE_TOO_LARGE
+	 * 		   -@c READ_INDEX_TOO_LARGE
+	 * 		   -@c READ_ENTRY_NON_EXISTENT
+	 */
+	ReturnValue_t read();
+	/**
+	 * \brief	The commit call writes back the variable's value to the data pool.
+	 * \details	It checks type and size, as well as if the variable is writable. If so,
+	 * 			the value is copied and the valid flag is automatically set to "valid".
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 *
+	 */
+	ReturnValue_t commit();
+
+private:
+	/**
+	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * 			is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * \brief	The array entry that is fetched from the data pool.
+	 */
+	uint8_t arrayEntry;
+	/**
+	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 *  \brief	This value contains the type of the data pool entry.
+	 */
+	Type type;
+	/**
+	 * \brief	This value contains the size of the data pool entry type in bytes.
+	 */
+	uint8_t typeSize;
+	/**
+	 * The size of the DP array (single values return 1)
+	 */
+	uint8_t arraySize;
+	/**
+	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
+	 */
+	uint16_t sizeTillEnd;
+	/**
+	 * \brief	The information whether the class is read-write or read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
 };
 
 #endif /* POOLRAWACCESS_H_ */
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index e1ae56bf1..8c7502700 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -78,45 +78,70 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(Serializa
 
 ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
 		bool withValidMask, uint8_t * validityMask) {
-	ReturnValue_t result;
+	ReturnValue_t result = RETURN_FAILED;
 	uint8_t arrayPosition = 0;
+	uint8_t counter = 0;
 	bool poolEntrySerialized = false;
-	//info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
+	info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
 	while(not poolEntrySerialized) {
+
+		if(counter > DataSet::DATA_SET_MAX_SIZE) {
+			error << "Pool Raw Access Helper: Config error, max. number of possible data set variables exceeded" << std::endl;
+			return result;
+		}
+		counter ++;
+
 		DataSet currentDataSet = DataSet();
 		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);
+
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
-			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset" << std::dec << std::endl;
+			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset with returncode "
+				  << result << std::dec << std::endl;
 			return result;
 		}
-		uint8_t remainingSize = currentPoolRawAccess.getSizeTillEnd() - currentPoolRawAccess.getSizeOfType();
-		if(remainingSize == 0) {
-			poolEntrySerialized = true;
-		}
-		else if(remainingSize > 0) {
-			arrayPosition += currentPoolRawAccess.getSizeOfType() / 8;
-		}
-		else {
-			error << "Pool Raw Access Helper: Configuration Error. Size till end smaller than 0" << std::endl;
+
+		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized, &arrayPosition);
+		if(result != RETURN_OK) {
+			error << "Pool Raw Access Helper: Configuration Error at pool ID " << std::hex << currentPoolId
+				  << ". Size till end smaller than 0" << std::dec << std::endl;
 			return result;
 		}
+
 		// set valid mask bit if necessary
 		if(withValidMask) {
 			if(currentPoolRawAccess.isValid()) {
 				handleMaskModification(validityMask);
 			}
 		}
+
 		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
 				argStruct.max_size, argStruct.bigEndian);
 		if (result != RETURN_OK) {
-			debug << "Pool Raw Access Helper: Error serializing pool data into send buffer" << std::endl;
+			debug << "Pool Raw Access Helper: Error serializing pool data with ID 0x" << std::hex <<
+					currentPoolId << " into send buffer with return code " << result << std::dec << std::endl;
 			return result;
 		}
+
 	}
 	return result;
 }
 
+ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess * currentPoolRawAccess,
+		bool * isSerialized, uint8_t * arrayPosition) {
+	int8_t remainingSize = currentPoolRawAccess->getSizeTillEnd() - currentPoolRawAccess->getSizeOfType();
+	if(remainingSize == 0) {
+		*isSerialized = true;
+	}
+	else if(remainingSize > 0) {
+		*arrayPosition += currentPoolRawAccess->getSizeOfType();
+	}
+	else {
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
 void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
 	validityMask[validBufferIndex] =
 			bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index e9e9c8ec5..72f2324c6 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -90,6 +90,8 @@ private:
 	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
 				bool withValidMask = false, uint8_t * validityMask = NULL);
 
+	ReturnValue_t checkRemainingSize(PoolRawAccess * currentPoolRawAccess,
+			bool * isSerialized, uint8_t * arrayPosition);
 	void handleMaskModification(uint8_t * validityMask);
 	/**
 	 * Sets specific bit of a byte

From a8247eb2f0406ea78259f9a5c3f70f7b02cef15a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 12 Jan 2020 14:18:12 +0100
Subject: [PATCH 0071/1774] Some more debugging output switched on

---
 container/SimpleRingBuffer.h      | 5 +++--
 storagemanager/LocalPool.h        | 4 ++--
 tcdistribution/PUSDistributor.cpp | 2 +-
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 45cb09277..4552a1c0a 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -5,8 +5,9 @@
 #include <stddef.h>
 
 /**
- * Circular buffer implementation, useful for buffering into data streams.
- * Note that the deleteData() has to be called to increment the read pointer
+ * @brief 	Circular buffer implementation, useful for buffering into data streams.
+ * @details Note that the deleteData() has to be called to increment the read pointer
+ * @ingroup containers
  */
 class SimpleRingBuffer: public RingBufferBase<> {
 public:
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 80e6a4956..f8b2b7302 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -294,8 +294,8 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
 		if (!ignoreFault) {
 			internalErrorReporter->storeFull();
 		}
-//		error << "LocalPool( " << std::hex << getObjectId() << std::dec
-//				<< " )::reserveSpace: Packet store is full." << std::endl;
+		error << "LocalPool( " << std::hex << getObjectId() << std::dec
+				<< " )::reserveSpace: Packet store is full." << std::endl;
 	}
 	return status;
 }
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index a209620f9..0f1aa7f03 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -31,7 +31,7 @@ iterator_t PUSDistributor::selectDestination() {
 	}
 
 	if (tcStatus != RETURN_OK) {
-		debug << "PUSDistributor::handlePacket: error with " << (int) tcStatus
+		debug << "PUSDistributor::handlePacket: error with 0x" << std::hex << (int) tcStatus
 				<< std::endl;
 		return this->queueMap.end();
 	} else {

From d2325e60b69650b5dde10f28dc88a929decf6527 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 12 Jan 2020 15:51:59 +0100
Subject: [PATCH 0072/1774] Import bugfix in MessageQueue.cpp

lastPartner is only assigned if receiveMessage is successful
---
 osal/FreeRTOS/MessageQueue.cpp    | 4 +++-
 tcdistribution/PUSDistributor.cpp | 1 +
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 1f514cf38..887df3926 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -38,7 +38,9 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
-	*receivedFrom = this->lastPartner;
+	if(status == HasReturnvaluesIF::RETURN_OK) {
+		*receivedFrom = this->lastPartner;
+	}
 	return status;
 }
 
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 0f1aa7f03..7b413eab7 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -48,6 +48,7 @@ ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
 	ReturnValue_t returnValue = RETURN_OK;
 	bool errorCode = true;
 	uint16_t serviceId = service->getIdentifier();
+	//info << "Service ID: " << (int)serviceId << std::endl;
 	MessageQueueId_t queue = service->getRequestQueue();
 	errorCode = this->queueMap.insert(
 			std::pair<uint32_t, MessageQueueId_t>(serviceId, queue)).second;

From 1369e792b4c1f3327923c1e7418641c687bb512e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Jan 2020 00:14:14 +0100
Subject: [PATCH 0073/1774] CommandingServiceBase documentation

---
 tmtcservices/CommandingServiceBase.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 8ce25f007..279f9ab43 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -195,7 +195,7 @@ protected:
 	 * @param tcData Application Data of TC Packet
 	 * @param tcDataLen
 	 * @param id MessageQueue ID is stored here
-	 * @param objectId
+	 * @param objectId Object ID is extracted and stored here
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED
 	 *         - @c CSB or implementation specific return codes
@@ -206,15 +206,15 @@ protected:
 
 	/**
 	 * After the Message Queue and Object ID are determined,
-	 * the command is prepared by using an implementation specific CommandMessage type which is sent to
-	 * the target device. It contains all necessary information for the device to
-	 * execute telecommands.
+	 * the command is prepared by using an implementation specific CommandMessage type
+	 * which is sent to the target object.
+	 * It contains all necessary information for the device to execute telecommands.
 	 * @param message
 	 * @param subservice
 	 * @param tcData
 	 * @param tcDataLen
 	 * @param state
-	 * @param objectId
+	 * @param objectId Target object ID
 	 * @return
 	 */
 	virtual ReturnValue_t prepareCommand(CommandMessage *message,
@@ -226,11 +226,11 @@ protected:
 	 * and the respective PUS Commanding Service once the execution has started.
 	 * The PUS Commanding Service receives replies from the target device and forwards them by calling this function.
 	 * There are different translations of these replies to specify how the Command Service proceeds.
-	 * @param reply Command Message which contains information about the command
-	 * @param previousCommand
+	 * @param reply[out] Command Message which contains information about the command
+	 * @param previousCommand [out]
 	 * @param state
 	 * @param optionalNextCommand
-	 * @param objectId
+	 * @param objectId Source object ID
 	 * @param isStep Flag value to mark steps of command execution
 	 * @return - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to generate TC verification success
 	 *         - @c INVALID_REPLY can handle unrequested replies

From 01551b8fa5bf642bac0ec124eef94f192087188a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Jan 2020 01:21:53 +0100
Subject: [PATCH 0074/1774] Getter function in SerialBufferAdapter

For const uint8_t *
---
 serialize/SerialBufferAdapter.cpp | 27 ++++++++++++++++++++++-----
 serialize/SerialBufferAdapter.h   | 10 +++++++++-
 2 files changed, 31 insertions(+), 6 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index a365cc993..a045d37ab 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,24 +1,27 @@
 #include <framework/serialize/SerialBufferAdapter.h>
 #include <cstring>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
 		T bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), constBuffer(buffer), buffer(NULL), bufferLength(
-				bufferLength) {
+		currentBufferType(bufferType::CONST), serializeLength(serializeLength),
+		constBuffer(buffer), buffer(NULL), bufferLength(bufferLength) {
+
 }
 
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(uint8_t* buffer, T bufferLength,
 		bool serializeLength) :
-		serializeLength(serializeLength), constBuffer(NULL), buffer(buffer), bufferLength(
-				bufferLength) {
+		currentBufferType(bufferType::NORMAL),serializeLength(serializeLength), constBuffer(NULL), buffer(buffer),
+		bufferLength(bufferLength) {
 }
 
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(uint32_t* buffer,
 		T bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), constBuffer(NULL), buffer(reinterpret_cast<uint8_t *>(buffer)),
+		currentBufferType(bufferType::NORMAL),serializeLength(serializeLength),
+		constBuffer(NULL), buffer(reinterpret_cast<uint8_t *>(buffer)),
 		bufferLength(bufferLength*4) {
 }
 
@@ -93,14 +96,28 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 
 template<typename T>
 uint8_t * SerialBufferAdapter<T>::getBuffer() {
+	if(currentBufferType != NORMAL) {
+		warning << "Wrong access function for stored type ! Use getConstBuffer()" << std::endl;
+		return 0;
+	}
 	return buffer;
 }
 
+template<typename T>
+const uint8_t * SerialBufferAdapter<T>::getConstBuffer() {
+	if(currentBufferType != CONST) {
+		warning << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
+		return 0;
+	}
+	return constBuffer;
+}
+
 template<typename T>
 void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_) {
 	buffer = buffer_;
 }
 
+
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
 template class SerialBufferAdapter<uint16_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index cee2cb263..6623beb3b 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -28,7 +28,7 @@ public:
 	SerialBufferAdapter(const uint8_t * buffer, T bufferLength, bool serializeLength = false);
 
 	/**
-	 * Constructoor for non-constant uint8_t buffer. Length field can be serialized optionally.
+	 * 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
@@ -56,8 +56,16 @@ public:
 			bool bigEndian);
 
 	uint8_t * getBuffer();
+	const uint8_t * getConstBuffer();
 	void setBuffer(uint8_t * buffer_);
 private:
+
+	enum bufferType {
+		NORMAL,
+		CONST
+	};
+	bufferType currentBufferType;
+
 	bool serializeLength;
 	const uint8_t *constBuffer;
 	uint8_t *buffer;

From c7479523363c83db5e1c3c9a207a5eeee5cf5a65 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Jan 2020 00:49:09 +0100
Subject: [PATCH 0075/1774] fixed map full() function added.

Pool raw access debugging
---
 container/FixedMap.h             | 9 +++++++++
 datapool/PoolRawAccess.cpp       | 1 +
 datapool/PoolRawAccessHelper.cpp | 5 +++--
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index d664a0861..55a435338 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -164,6 +164,15 @@ public:
 		return theMap.maxSize();
 	}
 
+	bool full() {
+		if(_size == theMap.maxSize()) {
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
 	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
 		ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&this->_size,
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index c4e327b19..66ba6218b 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -38,6 +38,7 @@ ReturnValue_t PoolRawAccess::read() {
 				result = READ_TYPE_TOO_LARGE;
 			}
 		} else {
+			info << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
 			result = READ_INDEX_TOO_LARGE;
 		}
 	} else {
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 8c7502700..de6e4802f 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -92,11 +92,12 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 		counter ++;
 
 		DataSet currentDataSet = DataSet();
+		info << "Current array position: " << (int)arrayPosition << std::endl;
 		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);
 
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
-			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset with returncode "
+			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset with returncode 0x"
 				  << result << std::dec << std::endl;
 			return result;
 		}
@@ -134,7 +135,7 @@ ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess * currentPoo
 		*isSerialized = true;
 	}
 	else if(remainingSize > 0) {
-		*arrayPosition += currentPoolRawAccess->getSizeOfType();
+		*arrayPosition += 1;
 	}
 	else {
 		return RETURN_FAILED;

From b0d88129db48db94d4d8ed4526408c62c962e2f0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Jan 2020 01:39:47 +0100
Subject: [PATCH 0076/1774] Pool Raw Access Helper bugfix

debug output commented
---
 datapool/PoolRawAccessHelper.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index de6e4802f..646ffbb1a 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -82,7 +82,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 	uint8_t arrayPosition = 0;
 	uint8_t counter = 0;
 	bool poolEntrySerialized = false;
-	info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
+	//debug << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
 	while(not poolEntrySerialized) {
 
 		if(counter > DataSet::DATA_SET_MAX_SIZE) {
@@ -92,7 +92,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 		counter ++;
 
 		DataSet currentDataSet = DataSet();
-		info << "Current array position: " << (int)arrayPosition << std::endl;
+		//debug << "Current array position: " << (int)arrayPosition << std::endl;
 		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);
 
 		result = currentDataSet.read();

From f16cce8be11be06f704fd0f141cb28dea233d802 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 15 Jan 2020 13:32:21 +0100
Subject: [PATCH 0077/1774] Basic doc for thermal modules started

---
 thermal/ThermalComponent.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 932438684..7482bd9b8 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -14,6 +14,9 @@ public:
 		float hysteresis;
 		float heaterSwitchoff;
 	};
+
+	// TODO: Documentaiton ,what is NOP?
+	// propably Non-operational?
 	struct NopParameters {
 		float lowerNopLimit;
 		float upperNopLimit;

From 9aa57f29b81d066429f77cd163043f661062d7ed Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 15 Jan 2020 13:52:18 +0100
Subject: [PATCH 0078/1774] basic documentation thermal

---
 thermal/AbstractTemperatureSensor.h | 9 +++++++++
 thermal/CoreComponent.h             | 1 +
 thermal/TemperatureSensor.h         | 8 ++++++++
 thermal/ThermalModule.h             | 3 +++
 4 files changed, 21 insertions(+)

diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h
index 75437dca8..3bebbe73c 100644
--- a/thermal/AbstractTemperatureSensor.h
+++ b/thermal/AbstractTemperatureSensor.h
@@ -10,6 +10,15 @@
 #include "ThermalModuleIF.h"
 #include "tcsDefinitions.h"
 
+/**
+ * @defgroup thermal Thermal Components
+ * @brief Contains all components related to thermal tasks (sensors, heaters)
+ */
+
+/**
+ * @brief Base class for Temperature Sensor, implements all important interfaces
+ * @ingroup thermal
+ */
 class AbstractTemperatureSensor: public HasHealthIF,
 		public SystemObject,
 		public ExecutableObjectIF,
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index f7e7aff8d..e21ee113b 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -8,6 +8,7 @@
 #include <framework/thermal/ThermalModule.h>
 #include <framework/thermal/ThermalMonitor.h>
 
+// TODO: Documentaiton, how to use this? only use Thermal COmponent, which inherits core component?
 class CoreComponent: public ThermalComponentIF {
 public:
 	struct Parameters {
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index de280d877..cbf8ea30f 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -5,6 +5,14 @@
 #include "AbstractTemperatureSensor.h"
 #include <framework/monitoring/LimitMonitor.h>
 
+/**
+ * @brief 	This building block handles non-linear value conversion and
+ * 			range checks for analog temperature sensors.
+ * @details
+ *
+ *
+ */
+
 template<typename T>
 class TemperatureSensor: public AbstractTemperatureSensor {
 public:
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index d8ac7d732..e65560cd6 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -11,6 +11,9 @@
 #include "RedundantHeater.h"
 class PowerSwitchIF;
 
+/**
+ * @brief Allows creation of different thermal control domains within a system.
+ */
 class ThermalModule: public ThermalModuleIF {
 	friend class ThermalController;
 public:

From 1437f33027cf60c8561eb3517418df2b16194016 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 15 Jan 2020 17:30:23 +0100
Subject: [PATCH 0079/1774] Serial Fixed Array List template type
 clarifications

---
 serialize/SerialArrayListAdapter.h      |  1 +
 serialize/SerialBufferAdapter.h         |  3 ++-
 serialize/SerialFixedArrayListAdapter.h | 22 +++++++++++++---------
 3 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 7e2e527bc..72b8d97f6 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -12,6 +12,7 @@
 #include <utility>
 
 /**
+ * Also serializes length field !
  * \ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 6623beb3b..b7729e316 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -11,7 +11,8 @@
  * 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)>> serialBufferElement
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>> serialBufferElement.
+ * Right now, the SerialBufferAdapter must always be initialized with the buffer and size !
  *
  * \ingroup serialize
  */
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index c8424f05d..4c4ec56fd 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -8,34 +8,38 @@
  * @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 using this type in
  * SerializeElement<>.
+ *
  * Buffers with a size header inside that class can be declared with
- * SerialFixedArrayListAdapter<bufferType,MAX_BUFFER_LENGTH,typeOfMaxData>.
- * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows
- * and MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
+ * SerialFixedArrayListAdapter<BUFFER_TYPE, MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE>.
+ * LENGTH_FIELD_TYPE specifies the data type of the buffer header containing the buffer size
+ * (defaults to 1 byte length field) that follows and MAX_BUFFER_LENGTH specifies
+ * the maximum allowed value for the buffer size.
+ *
  * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
  *
  * @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:
 	template<typename... Args>
-	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
+	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
 	}
 
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, max_size, bigEndian);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this, buffer, size, max_size, bigEndian);
 	}
 
 	uint32_t getSerializedSize() const {
-		return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
-		return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, bigEndian);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this, buffer, size, bigEndian);
 	}
 };
 

From 9bdbc2c380780ae7f523c4367560a13f1c64ca66 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 16 Jan 2020 18:46:29 +0100
Subject: [PATCH 0080/1774] Endian swapper changes, Serial buffer adapter

New Serial Buffer Adapter with complete template class for buffer type.
Endian Swapper input now standard uint8_t * pointers instead of template
type. Fixed Array List new ctor, but commented out for now
---
 container/FixedArrayList.h       |   8 ++
 serialize/EndianSwapper.h        |   7 +-
 serialize/SerialBufferAdapter2.h | 139 +++++++++++++++++++++++++++++++
 3 files changed, 149 insertions(+), 5 deletions(-)
 create mode 100644 serialize/SerialBufferAdapter2.h

diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index eeffcc870..ef2a82f5c 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -14,6 +14,14 @@ public:
 			ArrayList<T, count_t>(data, MAX_SIZE) {
 	}
 
+	//We could create a constructor to initialize the fixed array list with data and the known size field
+	//so it can be used for serialization too (with SerialFixedArrrayListAdapter)
+	//is this feasible?
+//	FixedArrayList(T * data_, count_t count):
+//		ArrayList<T, count_t>(data, MAX_SIZE) {
+//		memcpy(data, data_, count);
+//	}
+
 	FixedArrayList(const FixedArrayList& other) :
 			ArrayList<T, count_t>(data, MAX_SIZE) {
 		memcpy(this->data, other.data, sizeof(this->data));
diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index db170c0b2..6c391316a 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -48,17 +48,14 @@ public:
 	}
 
 	template<typename T>
-	static void swap(T * out, const T * in, uint32_t size) {
+	static void swap(uint8_t * out, const uint8_t * in, uint32_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		const uint8_t * in_buffer = reinterpret_cast<const uint8_t *>(in);
-		uint8_t * out_buffer = reinterpret_cast<uint8_t *>(out);
 		for (uint8_t count = 0; count < size; count++) {
 			for(uint8_t i = 0; i < sizeof(T);i++) {
-				out_buffer[sizeof(T)* (count + 1) - i - 1] = in_buffer[count * sizeof(T) + i];
+				out[sizeof(T)* (count + 1) - i - 1] = in[count * sizeof(T) + i];
 			}
-
 		}
 
 		return;
diff --git a/serialize/SerialBufferAdapter2.h b/serialize/SerialBufferAdapter2.h
new file mode 100644
index 000000000..a9613d940
--- /dev/null
+++ b/serialize/SerialBufferAdapter2.h
@@ -0,0 +1,139 @@
+#ifndef SERIALBUFFERADAPTER2_H_
+#define SERIALBUFFERADAPTER2_H_
+
+#include <framework/serialize/SerializeIF.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+#include <cstring>
+
+/**
+ * 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)>> serialBufferElement.
+ * Right now, the SerialBufferAdapter must always be initialized with the buffer and size !
+ *
+ * \ingroup serialize
+ */
+template<typename BUFFER_TYPE = uint8_t, typename count_t = uint8_t>
+class SerialBufferAdapter2: 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
+	 */
+	SerialBufferAdapter2(BUFFER_TYPE * buffer_, count_t bufferLength_, bool serializeLength_ = false):
+				buffer(buffer_),bufferLength(bufferLength_), serializeLength(serializeLength_) {
+		determineLengthMultiplier(sizeof(count_t));
+		if(std::is_const<BUFFER_TYPE>::value) {
+			isConst = true;
+		}
+	}
+
+	ReturnValue_t serialize(uint8_t ** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const {
+		uint32_t serializedLength = bufferLength;
+		if (serializeLength) {
+			serializedLength += AutoSerializeAdapter::getSerializedSize(
+					&bufferLength);
+		}
+		if (*size + serializedLength > max_size) {
+			return BUFFER_TOO_SHORT;
+		} else {
+			if (serializeLength) {
+				AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
+						max_size, bigEndian);
+			}
+			memcpy(*buffer, this->buffer, bufferLength);
+			*size += bufferLength;
+			(*buffer) += bufferLength;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+
+	uint32_t getSerializedSize() const {
+		if (serializeLength) {
+			return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
+		} else {
+			return bufferLength;
+		}
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer,
+			int32_t* size, bool bigEndian) {
+		//TODO Ignores Endian flag!
+		//UPDATE: Endian swapper introduced. Must be tested..
+		if (buffer != NULL) {
+			if(serializeLength){
+				count_t serializedSize = AutoSerializeAdapter::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) {
+				uint8_t tmp [bufferLength];
+				uint8_t * pTmp = tmp;
+				if (bigEndian) {
+					EndianSwapper::swap<BUFFER_TYPE>(pTmp,*buffer, bufferLength);
+				} else {
+					pTmp = const_cast<uint8_t *>(*buffer);
+				}
+				*size -= bufferLength;
+				memcpy(const_cast<void *>(reinterpret_cast<const void*>(this->buffer)), pTmp, bufferLength);
+				(*buffer) += bufferLength;
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return STREAM_TOO_SHORT;
+			}
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+
+
+	uint8_t * getBuffer() {
+		return reinterpret_cast<uint8_t *>(buffer);
+	}
+
+	void setBuffer(BUFFER_TYPE * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
+		buffer = buffer_;
+		bufferLength = bufferLength_;
+		serializeLength = serializeLength_;
+		determineLengthMultiplier(sizeof(count_t));
+	}
+private:
+	BUFFER_TYPE * buffer;
+	count_t bufferLength;
+	bool serializeLength;
+
+	bool isConst = false;
+
+	void determineLengthMultiplier(uint8_t typeSize) {
+		switch(typeSize) {
+		case(2):
+			bufferLength *= 2; break;
+		case(4):
+			bufferLength *= 4; break;
+		case(8):
+			bufferLength *= 8; break;
+		default:
+			warning << "Invalid type size, assuming regular uint8_t." << std::endl;
+		}
+	}
+};
+
+
+
+#endif /* SERIALBUFFERADAPTER2_H_ */

From 1d1bb88a6f173ba3426a176fb6609e27740928cd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 16 Jan 2020 19:07:53 +0100
Subject: [PATCH 0081/1774] Merge request check

---
 container/FixedMap.h                    |   4 +-
 datapool/DataSet.cpp                    |   6 --
 datapool/DataSet.h                      |   3 -
 datapool/PoolRawAccess.cpp              |   2 +-
 devicehandlers/DeviceHandlerBase.h      |   2 -
 devicehandlers/DeviceHandlerIF.h        | 133 ++++++++++++------------
 objectmanager/ObjectManagerIF.h         |   5 +-
 serialize/SerialBufferAdapter.cpp       |   2 +-
 serialize/SerialFixedArrayListAdapter.h |  17 ++-
 serialize/SerialLinkedListAdapter.h     |   7 +-
 10 files changed, 83 insertions(+), 98 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 55a435338..39e9106d1 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -16,8 +16,8 @@ template<typename key_t, typename T>
 class FixedMap: public SerializeIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01); //!< P1: SID for HK packets
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02); //!< P1: SID for HK packets
+	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
 	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
 
 private:
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index 55d8d6700..b4725c735 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -148,9 +148,3 @@ ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, int32_t* size,
 	}
 	return result;
 }
-
-ReturnValue_t DataSet::serializeRawFromIdBuffer(uint8_t ** buffer, uint32_t * size,
-		const uint32_t max_size, bool bigEndian, uint32_t * poolIdBuffer,
-		uint32_t poolIdSize) {
-	return RETURN_OK;
-}
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index e8e1a5972..8e0132239 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -129,9 +129,6 @@ public:
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
 
-	ReturnValue_t serializeRawFromIdBuffer(uint8_t ** buffer, uint32_t * size,
-			const uint32_t max_size, bool bigEndian, uint32_t * poolIdBuffer,
-			uint32_t poolIdSize);
 private:
 	/**
 	 * \brief	This array represents all pool variables registered in this set.
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 66ba6218b..4eeba4f58 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -38,7 +38,7 @@ ReturnValue_t PoolRawAccess::read() {
 				result = READ_TYPE_TOO_LARGE;
 			}
 		} else {
-			info << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
+			//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
 			result = READ_INDEX_TOO_LARGE;
 		}
 	} else {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index e7ac3aa63..95e972b65 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -170,8 +170,6 @@ 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.
 	 */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index bfa7c7b24..ed0260d60 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -25,80 +25,79 @@ public:
 	 * MODE_ON and MODE_OFF are included in hasModesIF.h
 	 */
 
+	//		MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	//		MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
+	static const Mode_t MODE_RAW = 3; //!< The device is powered on and ready to perform operations. In this mode, raw commands can be sent. The device handler will send all replies received from the command back to the commanding object.
+	static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
+	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The device handler performs all commands to get the device in a state ready to perform commands. When this is completed, the mode changes to @c MODE_ON.
+	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6; //!< This is a transitional state which can not be commanded. The device handler performs all actions and commands to get the device shut down. When the device is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON; //!< It is possible to set the mode to _MODE_TO_ON to use the to on transition if available.
+	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
+	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1; //!< This is a transitional state which can not be commanded. The device is shut down and ready to be switched off. After the command to set the switch off has been sent, the mode changes to @c MODE_WAIT_OFF
+	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2; //!< This is a transitional state which can not be commanded. The device will be switched on in this state. After the command to set the switch on has been sent, the mode changes to @c MODE_WAIT_ON
+	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3; //!< This is a transitional state which can not be commanded. The switch has been commanded off and the handler waits for it to be off. When the switch is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4; //!< This is a transitional state which can not be commanded. The switch has been commanded on and the handler waits for it to be on. When the switch is on, the mode changes to @c MODE_TO_ON.
+	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The switch has been commanded off and is off now. This state is only to do an RMAP cycle once more where the doSendRead() function will set the mode to MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board
 
-//		MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-//		MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-		static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
-		static const Mode_t MODE_RAW = 3; //!< The device is powered on and ready to perform operations. In this mode, raw commands can be sent. The device handler will send all replies received from the command back to the commanding object.
-		static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
-		static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The device handler performs all commands to get the device in a state ready to perform commands. When this is completed, the mode changes to @c MODE_ON.
-		static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6; //!< This is a transitional state which can not be commanded. The device handler performs all actions and commands to get the device shut down. When the device is off, the mode changes to @c MODE_OFF.
-		static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON; //!< It is possible to set the mode to _MODE_TO_ON to use the to on transition if available.
-		static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
-		static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
-		static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1; //!< This is a transitional state which can not be commanded. The device is shut down and ready to be switched off. After the command to set the switch off has been sent, the mode changes to @c MODE_WAIT_OFF
-		static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2; //!< This is a transitional state which can not be commanded. The device will be switched on in this state. After the command to set the switch on has been sent, the mode changes to @c MODE_WAIT_ON
-		static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3; //!< This is a transitional state which can not be commanded. The switch has been commanded off and the handler waits for it to be off. When the switch is off, the mode changes to @c MODE_OFF.
-		static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4; //!< This is a transitional state which can not be commanded. The switch has been commanded on and the handler waits for it to be on. When the switch is on, the mode changes to @c MODE_TO_ON.
-		static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The switch has been commanded off and is off now. This state is only to do an RMAP cycle once more where the doSendRead() function will set the mode to MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
+	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
+	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
+	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
+	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
+	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
+	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
 
-		static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
-		static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-		static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-		static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
-		static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-		static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
-		static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
-		static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
-		static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
-		static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
-		static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
-		static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0);
+	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1);
+	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2);
+	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t CANT_SWITCH_IOBOARD = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
+	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
+	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
+	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
 
-		static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
-		static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0);
-		static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1);
-		static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2);
-		static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
-		static const ReturnValue_t CANT_SWITCH_IOBOARD = MAKE_RETURN_CODE(0xA4);
-		static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
-		static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
-		static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
-		static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
-		static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
-		static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
-
-		//standard codes used in scan for reply
+	//standard codes used in scan for reply
 	//	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE(0xB1);
-		static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB2);
-		static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB3);
-		static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB4);
-		static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB5);
+	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB2);
+	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB3);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB4);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB5);
 
-		//standard codes used in  interpret device reply
-		static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC1); //the device reported, that it did not execute the command
-		static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC2);
-		static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC3); //the deviceCommandId reported by scanforReply is unknown
-		static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC4); //syntax etc is correct but still not ok, eg parameters where none are expected
+	//standard codes used in  interpret device reply
+	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC1); //the device reported, that it did not execute the command
+	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC2);
+	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC3); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC4); //syntax etc is correct but still not ok, eg parameters where none are expected
 
-		//Standard codes used in buildCommandFromCommand
-		static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(
-				0xD0);
-		static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS =
-				MAKE_RETURN_CODE(0xD1);
+	//Standard codes used in buildCommandFromCommand
+	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(
+			0xD0);
+	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS =
+			MAKE_RETURN_CODE(0xD1);
 
-		/**
-		 * RMAP Action that will be executed.
-		 *
-		 * This is used by the child class to tell the base class what to do.
-		 */
-		enum RmapAction_t {
-			SEND_WRITE,//!< RMAP send write
-			GET_WRITE, //!< RMAP get write
-			SEND_READ, //!< RMAP send read
-			GET_READ,  //!< RMAP get read
-			NOTHING    //!< Do nothing.
-		};
+	/**
+	 * RMAP Action that will be executed.
+	 *
+	 * This is used by the child class to tell the base class what to do.
+	 */
+	enum RmapAction_t {
+		SEND_WRITE,//!< RMAP send write
+		GET_WRITE, //!< RMAP get write
+		SEND_READ, //!< RMAP send read
+		GET_READ,  //!< RMAP get read
+		NOTHING    //!< Do nothing.
+	};
 	/**
 	 * Default Destructor
 	 */
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 5fbce2824..1d7674c64 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -78,9 +78,8 @@ public:
 	virtual void printList() = 0;
 };
 
-/**
- * @brief Documentation can be found in the class method declration.
- */
+
+/*Documentation can be found in the class method declaration above.*/
 template <typename T>
 T* ObjectManagerIF::get( object_id_t id ) {
 	SystemObjectIF* temp = this->getSystemObject(id);
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index a045d37ab..895e9461d 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,6 +1,6 @@
 #include <framework/serialize/SerialBufferAdapter.h>
-#include <cstring>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <cstring>
 
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 4c4ec56fd..e6db56e1b 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -9,17 +9,16 @@
  *        buffers with a header containing the buffer length.
  * @details
  *
- * Can be used by SerialLinkedListAdapter by using this type in
- * SerializeElement<>.
- *
- * Buffers with a size header inside that class can be declared with
- * SerialFixedArrayListAdapter<BUFFER_TYPE, MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE>.
- * LENGTH_FIELD_TYPE specifies the data type of the buffer header containing the buffer size
- * (defaults to 1 byte length field) that follows and MAX_BUFFER_LENGTH specifies
- * the maximum allowed value for the buffer size.
- *
+ * 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.
  *
+ *  1. Buffers with a size header inside that class can be declared with
+ *     SerialFixedArrayListAdapter<BUFFER_TYPE, MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE>.
+ *  2. MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
+ *  3. LENGTH_FIELD_TYPE specifies the data type of the buffer header containing the buffer size
+ *     (defaults to 1 byte length field) that follows
+ *
  * @ingroup serialize
  */
 template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index c135a2d38..ef1fa2007 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -19,7 +19,7 @@
  * @details
  * An alternative to the AutoSerializeAdapter functions
  *   - All object members with a datatype are declared as SerializeElement<element_type>
- * 	   inside the class implementing this adapter.
+ * 	   members inside the class implementing this adapter.
  *   - The element type can also be a SerialBufferAdapter to de-/serialize buffers,
  *     with a known size, where the size can also be serialized
  *   - The element type can also be a SerialFixedArrayListAdapter to de-/serialize buffers
@@ -29,14 +29,13 @@
  * the setStart and setNext functions.
  *
  * - The serialization process is done by instantiating the class and
- *   calling the serialize after all SerializeElement entries have been set by
- *   using a constructor or setter functions. An additional size variable can be supplied
+ *   calling serializ 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
  * - 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
  *
- *
  * @ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>

From 1f4391f56e5f95a44529bf89661c69c821fbb5c4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 17 Jan 2020 21:11:39 +0100
Subject: [PATCH 0082/1774] Endian Swapper buffer swapper changes reverted

---
 serialize/EndianSwapper.h | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index 6c391316a..25fb681e9 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -47,17 +47,25 @@ public:
 #endif
 	}
 
+	/**
+	 * Swap endianness of buffer entries
+	 * Template argument specifies buffer type
+	 * @param out
+	 * @param in
+	 * @param size
+	 */
 	template<typename T>
-	static void swap(uint8_t * out, const uint8_t * in, uint32_t size) {
+	static void swap(T * out, const T * in, uint32_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		const uint8_t * in_buffer = reinterpret_cast<const uint8_t *>(in);
+		uint8_t * out_buffer = reinterpret_cast<uint8_t *>(out);
 		for (uint8_t count = 0; count < size; count++) {
 			for(uint8_t i = 0; i < sizeof(T);i++) {
-				out[sizeof(T)* (count + 1) - i - 1] = in[count * sizeof(T) + i];
+				out_buffer[sizeof(T)* (count + 1) - i - 1] = in_buffer[count * sizeof(T) + i];
 			}
 		}
-
 		return;
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 		memcpy(out, in, size*sizeof(T));

From c9e4c73bd251b15c05c7d3140413ca39a2617919 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Jan 2020 15:03:22 +0100
Subject: [PATCH 0083/1774] Local pool public members/functions moved to top

---
 container/FixedArrayList.h        |   9 +-
 serialize/SerialBufferAdapter.cpp |   8 +-
 serialize/SerialBufferAdapter.h   |   2 +-
 serialize/SerialBufferAdapter2.h  |  57 +++++-----
 storagemanager/LocalPool.h        | 179 +++++++++++++++---------------
 5 files changed, 135 insertions(+), 120 deletions(-)

diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index ef2a82f5c..b9394cfec 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -17,10 +17,11 @@ public:
 	//We could create a constructor to initialize the fixed array list with data and the known size field
 	//so it can be used for serialization too (with SerialFixedArrrayListAdapter)
 	//is this feasible?
-//	FixedArrayList(T * data_, count_t count):
-//		ArrayList<T, count_t>(data, MAX_SIZE) {
-//		memcpy(data, data_, count);
-//	}
+	FixedArrayList(T * data_, count_t count):
+		ArrayList<T, count_t>(data, MAX_SIZE) {
+		memcpy(this->data, data_, count);
+		this->size = count;
+	}
 
 	FixedArrayList(const FixedArrayList& other) :
 			ArrayList<T, count_t>(data, MAX_SIZE) {
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 895e9461d..ab9dae073 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -71,6 +71,11 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
 		if(serializeLength){
+			// Suggestion (would require removing rest of the block inside this if clause !):
+			//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
+			//if (result != HasReturnvaluesIF::RETURN_OK) {
+			//	return result;
+			//}
 			T serializedSize = AutoSerializeAdapter::getSerializedSize(
 					&bufferLength);
 			if((*size - bufferLength - serializedSize) >= 0){
@@ -113,8 +118,9 @@ const uint8_t * SerialBufferAdapter<T>::getConstBuffer() {
 }
 
 template<typename T>
-void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_) {
+void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_, T bufferLength_) {
 	buffer = buffer_;
+	bufferLength = bufferLength_;
 }
 
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index b7729e316..53c5dc72f 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -58,7 +58,7 @@ public:
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
-	void setBuffer(uint8_t * buffer_);
+	void setBuffer(uint8_t * buffer_, T bufferLength_);
 private:
 
 	enum bufferType {
diff --git a/serialize/SerialBufferAdapter2.h b/serialize/SerialBufferAdapter2.h
index a9613d940..59c79dc2e 100644
--- a/serialize/SerialBufferAdapter2.h
+++ b/serialize/SerialBufferAdapter2.h
@@ -29,12 +29,18 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter2(BUFFER_TYPE * buffer_, count_t bufferLength_, bool serializeLength_ = false):
-				buffer(buffer_),bufferLength(bufferLength_), serializeLength(serializeLength_) {
-		determineLengthMultiplier(sizeof(count_t));
-		if(std::is_const<BUFFER_TYPE>::value) {
-			isConst = true;
-		}
+	SerialBufferAdapter2(void * buffer_, count_t bufferLength_, bool serializeLength_ = false):
+				bufferLength(bufferLength_), serializeLength(serializeLength_) {
+		determineLengthInBytes(sizeof(BUFFER_TYPE));
+		buffer = reinterpret_cast<const uint8_t *>(buffer_);
+		constBuffer = NULL;
+	}
+
+	SerialBufferAdapter2(const void * buffer_, count_t bufferLength_, bool serializeLength_ = false):
+					bufferLength(bufferLength_), serializeLength(serializeLength_) {
+		determineLengthInBytes(sizeof(BUFFER_TYPE));
+		constBuffer = reinterpret_cast<const uint8_t *>(buffer_);
+		buffer = NULL;
 	}
 
 	ReturnValue_t serialize(uint8_t ** buffer, uint32_t* size,
@@ -69,9 +75,13 @@ public:
 	ReturnValue_t deSerialize(const uint8_t** buffer,
 			int32_t* size, bool bigEndian) {
 		//TODO Ignores Endian flag!
-		//UPDATE: Endian swapper introduced. Must be tested..
 		if (buffer != NULL) {
 			if(serializeLength){
+				// Suggestion (would require removing rest of the block inside this if clause !):
+				//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
+				//if (result != HasReturnvaluesIF::RETURN_OK) {
+				//	return result;
+				//}
 				count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
 						&bufferLength);
 				if((*size - bufferLength - serializedSize) >= 0){
@@ -83,15 +93,8 @@ public:
 			}
 			//No Else If, go on with buffer
 			if (*size - bufferLength >= 0) {
-				uint8_t tmp [bufferLength];
-				uint8_t * pTmp = tmp;
-				if (bigEndian) {
-					EndianSwapper::swap<BUFFER_TYPE>(pTmp,*buffer, bufferLength);
-				} else {
-					pTmp = const_cast<uint8_t *>(*buffer);
-				}
 				*size -= bufferLength;
-				memcpy(const_cast<void *>(reinterpret_cast<const void*>(this->buffer)), pTmp, bufferLength);
+				memcpy(this->buffer, *buffer, bufferLength);
 				(*buffer) += bufferLength;
 				return HasReturnvaluesIF::RETURN_OK;
 			} else {
@@ -103,24 +106,30 @@ public:
 	}
 
 
-	uint8_t * getBuffer() {
-		return reinterpret_cast<uint8_t *>(buffer);
+	BUFFER_TYPE * getBuffer() {
+		return reinterpret_cast<BUFFER_TYPE *>(buffer);
 	}
 
-	void setBuffer(BUFFER_TYPE * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
+	void setBuffer(void * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
 		buffer = buffer_;
 		bufferLength = bufferLength_;
 		serializeLength = serializeLength_;
-		determineLengthMultiplier(sizeof(count_t));
+		determineLengthInBytes(sizeof(BUFFER_TYPE));
+	}
+
+	void setConstBuffer(const void * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
+		constBuffer = buffer_;
+		bufferLength = bufferLength_;
+		serializeLength = serializeLength_;
+		determineLengthInBytes(sizeof(BUFFER_TYPE));
 	}
 private:
-	BUFFER_TYPE * buffer;
+	uint8_t * buffer;
+	const uint8_t * constBuffer;
 	count_t bufferLength;
 	bool serializeLength;
 
-	bool isConst = false;
-
-	void determineLengthMultiplier(uint8_t typeSize) {
+	void determineLengthInBytes(uint8_t typeSize) {
 		switch(typeSize) {
 		case(2):
 			bufferLength *= 2; break;
@@ -134,6 +143,4 @@ private:
 	}
 };
 
-
-
 #endif /* SERIALBUFFERADAPTER2_H_ */
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index f8b2b7302..f6d5ba8ac 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -39,7 +39,95 @@ public:
 	 * @brief	This definition generally sets the number of different sized pools.
 	 * @details This must be less than the maximum number of pools (currently 0xff).
 	 */
-//	static const uint32_t NUMBER_OF_POOLS;
+	//	static const uint32_t NUMBER_OF_POOLS;
+	/**
+	 * @brief	This is the default constructor for a pool manager instance.
+	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
+	 * 			allocates memory (with \c new) for store and size_list. These
+	 * 			regions are all set to zero on start up.
+	 * @param setObjectId	The object identifier to be set. This allows for
+	 * 						multiple instances of LocalPool in the system.
+	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
+	 * 						of a single element in each pool is determined.
+	 * 						<b>The sizes must be provided in ascending order.
+	 * 						</b>
+	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
+	 * 						number of elements for each pool is determined.
+	 * 						The position of these values correspond to those in
+	 * 						element_sizes.
+	 * @param registered	Register the pool in object manager or not. Default is false (local pool).
+	 * @param spillsToHigherPools
+	 * 						A variable to determine whether higher n pools are used if the store is full.
+	 */
+	LocalPool(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS],
+			bool registered = false,
+			bool spillsToHigherPools = false);
+	/**
+	 * @brief	In the LocalPool's destructor all allocated memory is freed.
+	 */
+	virtual ~LocalPool(void);
+
+	/**
+	 * Add data to local data pool, performs range check
+	 * @param storageId [out] Store ID in which the data will be stored
+	 * @param data
+	 * @param size
+	 * @param ignoreFault
+	 * @return @c RETURN_OK if write was successful
+	 */
+	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
+			uint32_t size, bool ignoreFault = false);
+
+	/**
+	 * With this helper method, a free element of \c size is reserved.
+	 * @param storageId [out] storeID of the free element
+	 * @param size	The minimum packet size that shall be reserved.
+	 * @param p_data [out] pointer to the pointer of free element
+	 * @param ignoreFault
+	 * @return	Returns the storage identifier within the storage or
+	 * 			StorageManagerIF::INVALID_ADDRESS (in raw).
+	 */
+	ReturnValue_t getFreeElement(store_address_t* storageId,
+			const uint32_t size, uint8_t** p_data, bool ignoreFault = false);
+
+	/**
+	 * Retrieve data from local pool
+	 * @param packet_id
+	 * @param packet_ptr
+	 * @param size [out] Size of retrieved data
+	 * @return @c RETURN_OK if data retrieval was successfull
+	 */
+	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
+			uint32_t* size);
+
+	/**
+	 * Modify data by supplying a packet pointer and using that packet pointer
+	 * to access and modify the pool entry (via *pointer call)
+	 * @param packet_id Store ID of data to modify
+	 * @param packet_ptr [out] pointer to the pool entry to modify
+	 * @param size [out] size of pool entry
+	 * @return
+	 */
+	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
+			uint32_t* size);
+	virtual ReturnValue_t deleteData(store_address_t);
+	virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size,
+			store_address_t* storeId = NULL);
+	void clearStore();
+	ReturnValue_t initialize();
+protected:
+	/**
+	 * With this helper method, a free element of \c size is reserved.
+	 * @param size	The minimum packet size that shall be reserved.
+	 * @param[out] address Storage ID of the reserved data.
+	 * @return	- #RETURN_OK on success,
+	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
+	 */
+	virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault);
+
+	InternalErrorReporterIF *internalErrorReporter;
 private:
 	/**
 	 * Indicates that this element is free.
@@ -121,93 +209,6 @@ private:
 	 * 			- #DATA_STORAGE_FULL if the store is full
 	 */
 	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
-protected:
-	/**
-	 * With this helper method, a free element of \c size is reserved.
-	 * @param size	The minimum packet size that shall be reserved.
-	 * @param[out] address Storage ID of the reserved data.
-	 * @return	- #RETURN_OK on success,
-	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
-	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault);
-
-	InternalErrorReporterIF *internalErrorReporter;
-public:
-	/**
-	 * @brief	This is the default constructor for a pool manager instance.
-	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
-	 * 			allocates memory (with \c new) for store and size_list. These
-	 * 			regions are all set to zero on start up.
-	 * @param setObjectId	The object identifier to be set. This allows for
-	 * 						multiple instances of LocalPool in the system.
-	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
-	 * 						of a single element in each pool is determined.
-	 * 						<b>The sizes must be provided in ascending order.
-	 * 						</b>
-	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
-	 * 						number of elements for each pool is determined.
-	 * 						The position of these values correspond to those in
-	 * 						element_sizes.
-	 * @param registered	Register the pool in object manager or not. Default is false (local pool).
-	 * @param spillsToHigherPools
-	 * 						A variable to determine whether higher n pools are used if the store is full.
-	 */
-	LocalPool(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS],
-			bool registered = false,
-			bool spillsToHigherPools = false);
-	/**
-	 * @brief	In the LocalPool's destructor all allocated memory is freed.
-	 */
-	virtual ~LocalPool(void);
-
-	/**
-	 * Add data to local data pool, performs range check
-	 * @param storageId [out] Store ID in which the data will be stored
-	 * @param data
-	 * @param size
-	 * @param ignoreFault
-	 * @return @c RETURN_OK if write was successful
-	 */
-	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
-			uint32_t size, bool ignoreFault = false);
-
-	/**
-	 * With this helper method, a free element of \c size is reserved.
-	 *
-	 * @param size	The minimum packet size that shall be reserved.
-	 * @return	Returns the storage identifier within the storage or
-	 * 			StorageManagerIF::INVALID_ADDRESS (in raw).
-	 */
-	ReturnValue_t getFreeElement(store_address_t* storageId,
-			const uint32_t size, uint8_t** p_data, bool ignoreFault = false);
-
-	/**
-	 * Retrieve data from local pool
-	 * @param packet_id
-	 * @param packet_ptr
-	 * @param size [out] Size of retrieved data
-	 * @return @c RETURN_OK if data retrieval was successfull
-	 */
-	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
-			uint32_t* size);
-
-	/**
-	 * Modify data by supplying a packet pointer and using that packet pointer
-	 * to access and modify the pool entry (via *pointer call)
-	 * @param packet_id Store ID of data to modify
-	 * @param packet_ptr [out] pointer to the pool entry to modify
-	 * @param size [out] size of pool entry
-	 * @return
-	 */
-	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			uint32_t* size);
-	virtual ReturnValue_t deleteData(store_address_t);
-	virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size,
-			store_address_t* storeId = NULL);
-	void clearStore();
-	ReturnValue_t initialize();
 };
 
 template<uint8_t NUMBER_OF_POOLS>
@@ -304,7 +305,7 @@ template<uint8_t NUMBER_OF_POOLS>
 inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
 		const uint16_t element_sizes[NUMBER_OF_POOLS],
 		const uint16_t n_elements[NUMBER_OF_POOLS], bool registered, bool spillsToHigherPools) :
-		SystemObject(setObjectId, registered), spillsToHigherPools(spillsToHigherPools), internalErrorReporter(NULL) {
+		SystemObject(setObjectId, registered), internalErrorReporter(NULL), spillsToHigherPools(spillsToHigherPools){
 	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
 		this->element_sizes[n] = element_sizes[n];
 		this->n_elements[n] = n_elements[n];

From 6fe0f45c278e51b4a54a7f3a105edcafaad9f89a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Jan 2020 16:48:33 +0100
Subject: [PATCH 0084/1774] SerialBufferAdapter new setBuffer function

Serial Fixed Array List Adapter documentation adapted
SinglyLinkedList setEnd() function added
---
 container/SinglyLinkedList.h            | 5 +++++
 serialize/SerialBufferAdapter.cpp       | 5 +++++
 serialize/SerialBufferAdapter.h         | 1 +
 serialize/SerialFixedArrayListAdapter.h | 2 +-
 4 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 0a2e0531d..5c9de6cfe 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -58,6 +58,11 @@ public:
 	virtual void setNext(LinkedElement* next) {
 		this->next = next;
 	}
+
+	void setEnd() {
+		this->next = NULL;
+	}
+
 	LinkedElement* begin() {
 		return this;
 	}
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index ab9dae073..6ac2894fe 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -123,6 +123,11 @@ void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_, T bufferLength_) {
 	bufferLength = bufferLength_;
 }
 
+template<typename T>
+void SerialBufferAdapter<T>::setBuffer(uint32_t * buffer_, T bufferLength_) {
+	buffer = reinterpret_cast<uint8_t *>(buffer_);
+	bufferLength = 4 * bufferLength_;
+}
 
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 53c5dc72f..600bd692a 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -59,6 +59,7 @@ public:
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
 	void setBuffer(uint8_t * buffer_, T bufferLength_);
+	void setBuffer(uint32_t * buffer_, T bufferLength_);
 private:
 
 	enum bufferType {
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index e6db56e1b..18a970b80 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -15,7 +15,7 @@
  *
  *  1. Buffers with a size header inside that class can be declared with
  *     SerialFixedArrayListAdapter<BUFFER_TYPE, MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE>.
- *  2. MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
+ *  2. MAX_BUFFER_LENGTH specifies the maximum allowed number of elements in FixedArrayList
  *  3. LENGTH_FIELD_TYPE specifies the data type of the buffer header containing the buffer size
  *     (defaults to 1 byte length field) that follows
  *

From 5cb591a063cb9df22954a26e490806b5648d4061 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Jan 2020 18:01:37 +0100
Subject: [PATCH 0085/1774] Array List swapper for SerialFixedArrayList

---
 serialize/SerialArrayListAdapter.h      | 16 ++++++++++++++++
 serialize/SerialFixedArrayListAdapter.h |  4 ++++
 2 files changed, 20 insertions(+)

diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 72b8d97f6..21cbbc4d6 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -78,6 +78,22 @@ public:
 		}
 		return result;
 	}
+
+	/**
+	 * Swap the endianness of the Array list (not the length field !)
+	 * Useful if the case the buffer type is large than uint8_t and the endianness
+	 * is inconsistent with other SerializeElements.
+	 * @param list
+	 */
+	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		count_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
+			T newEntry = EndianSwapper::swap(list->entries[i]);
+			list->entries[i] = newEntry;
+			++i;
+		}
+	}
 private:
 	ArrayList<T, count_t> *adaptee;
 };
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 18a970b80..9613f6c13 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -40,6 +40,10 @@ public:
 			bool bigEndian) {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this, buffer, size, bigEndian);
 	}
+
+	void swapArrayListEndianness() {
+		SerialArrayListAdapter<BUFFER_TYPE, count_t>::swapArrayListEndianness(this);
+	}
 };
 
 

From 424c82ce165e1da122729ce058be19a32ade7dfa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Jan 2020 23:07:43 +0100
Subject: [PATCH 0086/1774] Extracted one logic block

To increase readability
---
 datapool/PoolRawAccess.cpp | 47 ++++++++++++++++++++------------------
 datapool/PoolRawAccess.h   |  1 +
 2 files changed, 26 insertions(+), 22 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 4eeba4f58..899eedd69 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -14,33 +14,13 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 	}
 }
 
-PoolRawAccess::~PoolRawAccess() {
-
-}
+PoolRawAccess::~PoolRawAccess() {}
 
 ReturnValue_t PoolRawAccess::read() {
 	ReturnValue_t result = RETURN_FAILED;
 	PoolEntryIF* read_out = ::dataPool.getRawData(dataPoolId);
 	if (read_out != NULL) {
-		valid = read_out->getValid();
-		if (read_out->getSize() > arrayEntry) {
-			arraySize = read_out->getSize();
-			typeSize = read_out->getByteSize() / read_out->getSize();
-			type = read_out->getType();
-			if (typeSize <= sizeof(value)) {
-				uint16_t arrayPosition = arrayEntry * typeSize;
-				sizeTillEnd = read_out->getByteSize() - arrayPosition;
-				uint8_t* ptr =
-						&((uint8_t*) read_out->getRawData())[arrayPosition];
-				memcpy(value, ptr, typeSize);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				result = READ_TYPE_TOO_LARGE;
-			}
-		} else {
-			//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
-			result = READ_INDEX_TOO_LARGE;
-		}
+		result = handleReadOut(read_out);
 	} else {
 		result = READ_ENTRY_NON_EXISTENT;
 	}
@@ -62,6 +42,29 @@ ReturnValue_t PoolRawAccess::read() {
 	return result;
 }
 
+ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* read_out) {
+	ReturnValue_t result = RETURN_FAILED;
+	valid = read_out->getValid();
+	if (read_out->getSize() > arrayEntry) {
+		arraySize = read_out->getSize();
+		typeSize = read_out->getByteSize() / read_out->getSize();
+		type = read_out->getType();
+		if (typeSize <= sizeof(value)) {
+			uint16_t arrayPosition = arrayEntry * typeSize;
+			sizeTillEnd = read_out->getByteSize() - arrayPosition;
+			uint8_t* ptr = &((uint8_t*) read_out->getRawData())[arrayPosition];
+			memcpy(value, ptr, typeSize);
+			return RETURN_OK;
+		} else {
+			result = READ_TYPE_TOO_LARGE;
+		}
+	} else {
+		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
+		result = READ_INDEX_TOO_LARGE;
+	}
+	return result;
+}
+
 ReturnValue_t PoolRawAccess::commit() {
 	PoolEntryIF* write_back = ::dataPool.getRawData(dataPoolId);
 	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 432d9ad95..5fb482f09 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -156,6 +156,7 @@ protected:
 	 */
 	ReturnValue_t commit();
 
+	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
 private:
 	/**
 	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id

From dba26baee6b4df5c0379f6886c7eaf12a387683d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 20 Jan 2020 23:00:23 +0100
Subject: [PATCH 0087/1774] Restructured header file

Abstract functions are closer to the top
because they must be implemented and documentation
should be near the top.
Important virtual functions moved up too.
Additional documentation added
---
 devicehandlers/DeviceHandlerBase.cpp | 167 +++++------
 devicehandlers/DeviceHandlerBase.h   | 425 ++++++++++++++-------------
 2 files changed, 306 insertions(+), 286 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 0b35effd5..c4f7465d9 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -90,6 +90,85 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	return RETURN_OK;
 }
 
+ReturnValue_t DeviceHandlerBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	communicationInterface = objectManager->get<DeviceCommunicationIF>(
+			deviceCommunicationId);
+	if (communicationInterface == NULL) {
+		return RETURN_FAILED;
+	}
+
+	result = communicationInterface->open(&cookie, logicalAddress,
+			maxDeviceReplyLen);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (IPCStore == NULL) {
+		return RETURN_FAILED;
+	}
+
+	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
+			AcceptsDeviceResponsesIF>(rawDataReceiverId);
+
+	if (rawReceiver == NULL) {
+		return RETURN_FAILED;
+	}
+
+	defaultRawReceiver = rawReceiver->getDeviceQueue();
+
+	powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
+	if (powerSwitcher == NULL) {
+		return RETURN_FAILED;
+	}
+
+	result = healthHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	result = modeHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = actionHelper.initialize(commandQueue);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = fdirInstance->initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = hkSwitcher.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	fillCommandAndReplyMap();
+
+	//Set temperature target state to NON_OP.
+	DataSet mySet;
+	PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
+			PoolVariableIF::VAR_WRITE);
+	mySet.read();
+	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+	mySet.commit(PoolVariableIF::VALID);
+
+	return RETURN_OK;
+
+}
+
 void DeviceHandlerBase::decrementDeviceReplyMap() {
 	for (std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
 			deviceReplyMap.begin(); iter != deviceReplyMap.end(); iter++) {
@@ -454,7 +533,8 @@ void DeviceHandlerBase::doGetWrite() {
 		if (wiretappingMode == RAW) {
 			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
 		}
-		// We need to distinguish here, because a raw command never expects a reply. (Could be done in eRIRM, but then child implementations need to be careful.
+		//We need to distinguish here, because a raw command never expects a reply.
+		//(Could be done in eRIRM, but then child implementations need to be careful.
 		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
 	} else {
 		//always generate a failure event, so that FDIR knows what's up
@@ -474,9 +554,9 @@ void DeviceHandlerBase::doSendRead() {
 		cookieInfo.state = COOKIE_READ_SENT;
 	} else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
-		// We can't inform anyone, because we don't know which command was sent last.
-		// So, we need to wait for a timeout.
-		// but I think we can allow to ignore one missedReply.
+		//We can't inform anyone, because we don't know which command was sent last.
+		//So, we need to wait for a timeout.
+		//but I think we can allow to ignore one missedReply.
 		ignoreMissedRepliesCount++;
 		cookieInfo.state = COOKIE_UNUSED;
 	}
@@ -579,84 +659,6 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 
 }
 
-ReturnValue_t DeviceHandlerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	communicationInterface = objectManager->get<DeviceCommunicationIF>(
-			deviceCommunicationId);
-	if (communicationInterface == NULL) {
-		return RETURN_FAILED;
-	}
-
-	result = communicationInterface->open(&cookie, logicalAddress,
-			maxDeviceReplyLen);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (IPCStore == NULL) {
-		return RETURN_FAILED;
-	}
-
-	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
-			AcceptsDeviceResponsesIF>(rawDataReceiverId);
-
-	if (rawReceiver == NULL) {
-		return RETURN_FAILED;
-	}
-
-	defaultRawReceiver = rawReceiver->getDeviceQueue();
-
-	powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
-	if (powerSwitcher == NULL) {
-		return RETURN_FAILED;
-	}
-
-	result = healthHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	result = modeHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = actionHelper.initialize(commandQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = fdirInstance->initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = hkSwitcher.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	fillCommandAndReplyMap();
-
-	//Set temperature target state to NON_OP.
-	DataSet mySet;
-	PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
-			PoolVariableIF::VAR_WRITE);
-	mySet.read();
-	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-	mySet.commit(PoolVariableIF::VALID);
-
-	return RETURN_OK;
-
-}
 
 void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		MessageQueueId_t sendTo, bool isCommand) {
@@ -1020,7 +1022,6 @@ void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
 	}
 }
 
-
 ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		CommandMessage * message) {
 	ReturnValue_t result;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 95e972b65..7503faf9f 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -33,7 +33,6 @@ class StorageManagerIF;
  * Contains all devices and the DeviceHandlerBase class.
  */
 
-
 /**
  * @brief This is the abstract base class for device handlers.
  * @details
@@ -56,6 +55,17 @@ class StorageManagerIF;
  * 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()
+ *  3. buildTransitionDeviceCommand()
+ *  4. buildNormalDeviceCommand()
+ *  5. buildCommandFromCommand()
+ *  6. fillCommandAndReplyMap()
+ *  7. scanForReply()
+ *  8. interpretDeviceReply()
+ * Other important virtual methods with a default implementation
+ * are the getTransitionDelay() function and the getSwitches() function
  *
  * @ingroup devices
  */
@@ -75,17 +85,19 @@ public:
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
 	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
 	 * @param setDeviceSwitch the switch the device is connected to, for devices using two switches, overwrite getSwitches()
+	 * @param deviceCommuncation Communcation Interface object which is used to implement communication functions
+	 * @param thermalStatePoolId
+	 * @param thermalRequestPoolId
+	 * @param fdirInstance
+	 * @param cmdQueueSize
 	 */
 	DeviceHandlerBase(uint32_t logicalAddress, object_id_t setObjectId,
 			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-			object_id_t deviceCommunication, uint32_t thermalStatePoolId =
-					PoolVariableIF::NO_PARAMETER,
+			object_id_t deviceCommunication,
+			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = NULL, uint32_t cmdQueueSize = 20);
 
-	virtual MessageQueueId_t getCommandQueue(void) const;
-
-
 	/**
 	 * @brief This function is the device handler base core component and is called periodically.
 	 * @details
@@ -117,17 +129,214 @@ public:
 	 */
 	virtual ReturnValue_t performOperation(uint8_t counter);
 
+	/**
+	 * @brief  Initializes the device handler
+	 * @details
+	 * Initialize Device Handler as system object and
+	 * initializes all important helper classes.
+	 * Calls fillCommandAndReplyMap().
+	 * @return
+	 */
 	virtual ReturnValue_t initialize();
 
-	/**
-	 *
-	 * @param parentQueueId
-	 */
-	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 	/**
 	 * Destructor.
 	 */
 	virtual ~DeviceHandlerBase();
+protected:
+	/**
+	 * This is used to let the child class handle the transition from mode @c _MODE_START_UP to @c MODE_ON
+	 *
+	 * It is only called when the device handler is in mode @c _MODE_START_UP. That means, the device switch(es) are already set to on.
+	 * Device handler commands are read and can be handled by the child class. If the child class handles a command, it should also send
+	 * an reply accordingly.
+	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE, the base class handles rejecting the command and sends a reply.
+	 * The replies for mode transitions are handled by the base class.
+	 *
+	 * If the device is started and ready for operation, the mode should be set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
+	 * use the to on transition if available.
+	 * If the power-up fails, the mode should be set to _MODE_POWER_DOWN which will lead to the device being powered off.
+	 * If the device does not change the mode, the mode will be changed to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay()) has passed.
+	 *
+	 * #transitionFailure can be set to a failure code indicating the reason for a failed transition
+	 */
+	virtual void doStartUp() = 0;
+
+	/**
+	 * This is used to let the child class handle the transition from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
+	 *
+	 * It is only called when the device handler is in mode @c _MODE_SHUT_DOWN.
+	 * Device handler commands are read and can be handled by the child class. If the child class handles a command, it should also send
+	 * an reply accordingly.
+	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE, the base class handles rejecting the command and sends a reply.
+	 * The replies for mode transitions are handled by the base class.
+	 *
+	 * If the device ready to be switched off, the mode should be set to _MODE_POWER_DOWN.
+	 * If the device should not be switched off, the mode can be changed to _MODE_TO_ON (or MODE_ON if no transition is needed).
+	 * If the device does not change the mode, the mode will be changed to _MODE_POWER_DOWN, when the timeout (from getTransitionDelay()) has passed.
+	 *
+	 * #transitionFailure can be set to a failure code indicating the reason for a failed transition
+	 */
+	virtual void doShutDown() = 0;
+
+	/**
+	 * Build the device command to send for normal mode.
+	 *
+	 * This is only called in @c MODE_NORMAL. If multiple submodes for @c MODE_NORMAL are supported,
+	 * different commands can built returned depending on the submode.
+	 *
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 *
+	 * @param[out] id the device command id that has been built
+	 * @return
+	 *    - @c RETURN_OK when a command is to be sent
+	 *    - not @c RETURN_OK when no command is to be sent
+	 */
+	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
+
+	/**
+	 * 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()
+	 *
+	 * 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
+	 * and filling them in doStartUp(), doShutDown() and doTransition() so no modes have to be checked here.
+	 *
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 *
+	 * @param[out] id the device command id built
+	 * @return
+	 *    - @c RETURN_OK when a command is to be sent
+	 *    - not @c RETURN_OK when no command is to be sent
+	 */
+	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
+
+	/**
+	 * Build a device command packet from data supplied by a direct command.
+	 *
+	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
+	 *
+	 * @param deviceCommand the command to build, already checked against deviceCommandMap
+	 * @param commandData pointer to the data from the direct command
+	 * @param commandDataLen length of commandData
+	 * @return
+	 *     - @c RETURN_OK when #rawPacket is valid
+	 *     - @c RETURN_FAILED when #rawPacket is invalid and no data should be sent
+	 */
+	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+			const uint8_t * commandData, size_t commandDataLen) = 0;
+
+	/**
+	 * @brief fill the #deviceCommandMap
+	 *	 	  called by the initialize() of the base class
+	 * @details
+	 * This is used to let the base class know which replies are expected.
+	 * There are different scenarios regarding this:
+	 * - "Normal" commands. These are commands, that trigger a direct reply from the device. In this case, the id of the command should be added to the command map
+	 * with a commandData_t where maxDelayCycles is set to the maximum expected number of PST cycles the reply will take. Then, scanForReply returns the id of the command and the base class can handle time-out and missing replies.
+	 * - Periodic, unrequested replies. These are replies that, once enabled, are sent by the device on its own in a defined interval. In this case, the id of the reply or a placeholder id should be added to the deviceCommandMap
+	 * with a commandData_t where maxDelayCycles is set to the maximum expected number of PST cycles between two replies (also a tolerance should be added, as an FDIR message will be generated if it is missed).
+	 * As soon as the replies are enabled, DeviceCommandInfo.periodic must be set to 1, DeviceCommandInfo.delayCycles to DeviceCommandInfo.MaxDelayCycles. From then on, the base class handles the reception.
+	 * Then, scanForReply returns the id of the reply or the placeholder id and the base class will take care of checking that all replies are received and the interval is correct.
+	 * When the replies are disabled, DeviceCommandInfo.periodic must be set to 0, DeviceCommandInfo.delayCycles to 0;
+	 * - Aperiodic, unrequested replies. These are replies that are sent by the device without any preceding command and not in a defined interval. These are not entered in the deviceCommandMap but handled by returning @c APERIODIC_REPLY in scanForReply().
+	 *
+	 */
+	virtual void fillCommandAndReplyMap() = 0;
+
+	/**
+	 * @brief Scans a buffer for a valid reply.
+	 * @details
+	 * This is used by the base class to check the data received for valid packets.
+	 * It only checks if a valid packet starts at @c start.
+	 * It also only checks the structural validy of the packet, eg checksums lengths and protocol data.
+	 * No information check is done, e.g. range checks etc.
+	 *
+	 * Errors should be reported directly, the base class does NOT report any errors based on the return
+	 * value of this function.
+	 *
+	 * @param start start of remaining buffer to be scanned
+	 * @param len length of remaining buffer to be scanned
+	 * @param[out] foundId the id of the data found in the buffer.
+	 * @param[out] foundLen length of the data found. Is to be set in function, buffer is scanned at previous position + foundLen.
+	 * @return
+	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
+	 *     - @c RETURN_FAILED no reply could be found starting at @c start, implies @c foundLen is not valid, base class will call scanForReply() again with ++start
+	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid, eg checksum error, implies @c foundLen is valid, can be used to skip some bytes
+	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
+	 *     - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of the packet
+	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
+	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
+	 */
+	virtual ReturnValue_t scanForReply(const uint8_t *start, uint32_t len,
+			DeviceCommandId_t *foundId, uint32_t *foundLen) = 0;
+
+	/**
+	 * @brief Interpret a reply from the device.
+	 * @details
+	 * This is called after scanForReply() found a valid packet, it can be assumed that the length and structure is valid.
+	 * This routine extracts the data from the packet into a DataSet and then calls handleDeviceTM(), which either sends
+	 * a TM packet or stores the data in the DataPool depending on whether the it was an external command.
+	 * No packet length is given, as it should be defined implicitly by the id.
+	 *
+	 * @param id the id found by scanForReply()
+	 * @param packet
+	 * @return
+	 *     - @c RETURN_OK when the reply was interpreted.
+	 *     - @c RETURN_FAILED when the reply could not be interpreted, eg. logical errors or range violations occurred
+	 */
+	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
+			const uint8_t *packet) = 0;
+
+	/**
+	 * @brief   Can be implemented by child handler to
+	 *          perform debugging
+	 * @details Example: Calling this in performOperation
+	 *          to track values like mode.
+	 * @param 	positionTracker Provide the child handler a way to know where the debugInterface was called
+	 * @param 	objectId Provide the child handler object Id to specify actions for spefic devices
+	 * @param 	parameter Supply a parameter of interest
+	 * Please delete all debugInterface calls in DHB after debugging is finished !
+	 */
+	virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0, uint32_t parameter = 0);
+
+	/**
+	 * Get the time needed to transit from modeFrom to modeTo.
+	 *
+	 * Used for the following transitions:
+	 * modeFrom -> modeTo:
+	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches, the base class got you covered)
+	 *
+	 * The default implementation returns 0 !
+	 * @param modeFrom
+	 * @param modeTo
+	 * @return time in ms
+	 */
+	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo);
+
+	/**
+	 * Return the switches connected to the device.
+	 *
+	 * The default implementation returns one switch set in the ctor.
+	 *
+	 * @param[out] switches pointer to an array of switches
+	 * @param[out] numberOfSwitches length of returned array
+	 * @return
+	 *      - @c RETURN_OK if the parameters were set
+	 *      - @c RETURN_FAILED if no switches exist
+	 */
+	virtual ReturnValue_t getSwitches(const uint8_t **switches,
+			uint8_t *numberOfSwitches);
+
+public:
+	/**
+	 * @param parentQueueId
+	 */
+	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
 	ReturnValue_t executeAction(ActionId_t actionId,
 			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
@@ -146,6 +355,8 @@ public:
 	 * @param task_ Pointer to the taskIF of this task
 	 */
 	virtual  void setTaskIF(PeriodicTaskIF* task_);
+	virtual MessageQueueId_t getCommandQueue(void) const;
+
 protected:
 	/**
 	 * The Returnvalues id of this class, required by HasReturnvaluesIF
@@ -357,41 +568,6 @@ protected:
 	 */
 	void setMode(Mode_t newMode, Submode_t submode);
 
-	/**
-	 * This is used to let the child class handle the transition from mode @c _MODE_START_UP to @c MODE_ON
-	 *
-	 * It is only called when the device handler is in mode @c _MODE_START_UP. That means, the device switch(es) are already set to on.
-	 * Device handler commands are read and can be handled by the child class. If the child class handles a command, it should also send
-	 * an reply accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE, the base class handles rejecting the command and sends a reply.
-	 * The replies for mode transitions are handled by the base class.
-	 *
-	 * If the device is started and ready for operation, the mode should be set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
-	 * use the to on transition if available.
-	 * If the power-up fails, the mode should be set to _MODE_POWER_DOWN which will lead to the device being powered off.
-	 * If the device does not change the mode, the mode will be changed to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay()) has passed.
-	 *
-	 * #transitionFailure can be set to a failure code indicating the reason for a failed transition
-	 */
-	virtual void doStartUp() = 0;
-
-	/**
-	 * This is used to let the child class handle the transition from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
-	 *
-	 * It is only called when the device handler is in mode @c _MODE_SHUT_DOWN.
-	 * Device handler commands are read and can be handled by the child class. If the child class handles a command, it should also send
-	 * an reply accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE, the base class handles rejecting the command and sends a reply.
-	 * The replies for mode transitions are handled by the base class.
-	 *
-	 * If the device ready to be switched off, the mode should be set to _MODE_POWER_DOWN.
-	 * If the device should not be switched off, the mode can be changed to _MODE_TO_ON (or MODE_ON if no transition is needed).
-	 * If the device does not change the mode, the mode will be changed to _MODE_POWER_DOWN, when the timeout (from getTransitionDelay()) has passed.
-	 *
-	 * #transitionFailure can be set to a failure code indicating the reason for a failed transition
-	 */
-	virtual void doShutDown() = 0;
-
 	/**
 	 * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
 	 *
@@ -421,24 +597,6 @@ protected:
 	 */
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
 
-	/**
-	 * Get the time needed to transit from modeFrom to modeTo.
-	 *
-	 * Used for the following transitions:
-	 * modeFrom -> modeTo:
-	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches, the base class got you covered)
-	 *
-	 * The default implementation returns 0;
-	 *
-	 * @param modeFrom
-	 * @param modeTo
-	 * @return time in ms
-	 */
-	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo);
-
 	/**
 	 * Is the combination of mode and submode valid?
 	 *
@@ -460,40 +618,6 @@ protected:
 	 */
 	virtual RmapAction_t getRmapAction();
 
-	/**
-	 * Build the device command to send for normal mode.
-	 *
-	 * This is only called in @c MODE_NORMAL. If multiple submodes for @c MODE_NORMAL are supported,
-	 * different commands can built returned depending on the submode.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 *
-	 * @param[out] id the device command id that has been built
-	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c RETURN_OK when no command is to be sent
-	 */
-	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
-
-	/**
-	 * 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()
-	 *
-	 * 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
-	 * and filling them in doStartUp(), doShutDown() and doTransition() so no modes have to be checked here.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 *
-	 * @param[out] id the device command id built
-	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c RETURN_OK when no command is to be sent
-	 */
-	virtual ReturnValue_t buildTransitionDeviceCommand(
-			DeviceCommandId_t * id) = 0;
-
 	/**
 	 * Build the device command to send for raw mode.
 	 *
@@ -514,52 +638,6 @@ protected:
 	 */
 	virtual ReturnValue_t buildChildRawCommand();
 
-	/**
-	 * Build a device command packet from data supplied by a direct command.
-	 *
-	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
-	 *
-	 * @param deviceCommand the command to build, already checked against deviceCommandMap
-	 * @param commandData pointer to the data from the direct command
-	 * @param commandDataLen length of commandData
-	 * @return
-	 *     - @c RETURN_OK when #rawPacket is valid
-	 *     - @c RETURN_FAILED when #rawPacket is invalid and no data should be sent
-	 */
-	virtual ReturnValue_t buildCommandFromCommand(
-			DeviceCommandId_t deviceCommand, const uint8_t * commandData,
-			size_t commandDataLen) = 0;
-
-	/**
-	 * @brief fill the #deviceCommandMap
-	 *	 	  called by the initialize() of the base class
-	 * @details
-	 * This is used to let the base class know which replies are expected.
-	 * There are different scenarios regarding this:
-	 * - "Normal" commands. These are commands, that trigger a direct reply from the device. In this case, the id of the command should be added to the command map
-	 * with a commandData_t where maxDelayCycles is set to the maximum expected number of PST cycles the reply will take. Then, scanForReply returns the id of the command and the base class can handle time-out and missing replies.
-	 * - Periodic, unrequested replies. These are replies that, once enabled, are sent by the device on its own in a defined interval. In this case, the id of the reply or a placeholder id should be added to the deviceCommandMap
-	 * with a commandData_t where maxDelayCycles is set to the maximum expected number of PST cycles between two replies (also a tolerance should be added, as an FDIR message will be generated if it is missed).
-	 * As soon as the replies are enabled, DeviceCommandInfo.periodic must be set to 1, DeviceCommandInfo.delayCycles to DeviceCommandInfo.MaxDelayCycles. From then on, the base class handles the reception.
-	 * Then, scanForReply returns the id of the reply or the placeholder id and the base class will take care of checking that all replies are received and the interval is correct.
-	 * When the replies are disabled, DeviceCommandInfo.periodic must be set to 0, DeviceCommandInfo.delayCycles to 0;
-	 * - Aperiodic, unrequested replies. These are replies that are sent by the device without any preceding command and not in a defined interval. These are not entered in the deviceCommandMap but handled by returning @c APERIODIC_REPLY in scanForReply().
-	 *
-	 */
-	virtual void fillCommandAndReplyMap() = 0;
-
-
-	/**
-	 * @brief   Can be implemented by child handler to
-	 *          perform debugging
-	 * @details Example: Calling this in performOperation
-	 *          to track values like mode.
-	 * @param 	positionTracker Provide the child handler a way to know where the debugInterface was called
-	 * @param 	objectId Provide the child handler object Id to specify actions for spefic devices
-	 * @param 	parameter Supply a parameter of interest
-	 * Please delete all debugInterface calls in DHB after debugging is finished !
-	 */
-	virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0, uint32_t parameter = 0);
 
 	/**
 	 * This is a helper method to facilitate inserting entries in the command map.
@@ -608,50 +686,6 @@ protected:
 	 */
 	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
 
-	/**
-	 * Scans a buffer for a valid reply.
-	 *
-	 * This is used by the base class to check the data received from the RMAP stack for valid packets.
-	 * It only checks if a valid packet starts at @c start.
-	 * It also only checks the structural validy of the packet, eg checksums lengths and protocol data. No
-	 * information check is done, eg range checks etc.
-	 *
-	 * Errors should be reported directly, the base class does NOT report any errors based on the return
-	 * value of this function.
-	 *
-	 * @param start start of remaining buffer to be scanned
-	 * @param len length of remaining buffer to be scanned
-	 * @param[out] foundId the id of the data found in the buffer.
-	 * @param[out] foundLen length of the data found. Is to be set in function, buffer is scanned at previous position + foundLen.
-	 * @return
-	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *     - @c RETURN_FAILED no reply could be found starting at @c start, implies @c foundLen is not valid, base class will call scanForReply() again with ++start
-	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid, eg checksum error, implies @c foundLen is valid, can be used to skip some bytes
-	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
-	 *     - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of the packet
-	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
-	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
-	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, uint32_t len,
-			DeviceCommandId_t *foundId, uint32_t *foundLen) = 0;
-
-	/**
-	 * Interpret a reply from the device.
-	 *
-	 * This is called after scanForReply() found a valid packet, it can be assumed that the length and structure is valid.
-	 * This routine extracts the data from the packet into a DataSet and then calls handleDeviceTM(), which either sends
-	 * a TM packet or stores the data in the DataPool depending on whether the it was an external command.
-	 * No packet length is given, as it should be defined implicitly by the id.
-	 *
-	 * @param id the id found by scanForReply()
-	 * @param packet
-	 * @return
-	 *     - @c RETURN_OK when the reply was interpreted.
-	 *     - @c RETURN_FAILED when the reply could not be interpreted, eg. logical errors or range violations occurred
-	 */
-	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet) = 0;
-
 	/**
 	 * Construct a command reply containing a raw reply.
 	 *
@@ -675,21 +709,6 @@ protected:
 	 */
 	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
 
-	/**
-	 * Return the switches connected to the device.
-	 *
-	 * The default implementation returns one switch set in the ctor.
-	 *
-	 *
-	 * @param[out] switches pointer to an array of switches
-	 * @param[out] numberOfSwitches length of returned array
-	 * @return
-	 *      - @c RETURN_OK if the parameters were set
-	 *      - @c RETURN_FAILED if no switches exist
-	 */
-	virtual ReturnValue_t getSwitches(const uint8_t **switches,
-			uint8_t *numberOfSwitches);
-
 	/**
 	 * notify child about mode change
 	 */

From 3d2bdae14df5427251b59bd81dc44a82f7667a34 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 20 Jan 2020 23:29:36 +0100
Subject: [PATCH 0088/1774] CSB abstract functions moved to top

So documentation of functions to implement is closer to the top
---
 devicehandlers/DeviceHandlerBase.h   |  52 +++++++-----
 tmtcservices/CommandingServiceBase.h | 121 +++++++++++++--------------
 2 files changed, 92 insertions(+), 81 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 7503faf9f..f16a4ff96 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -39,18 +39,17 @@ class StorageManagerIF;
  * Documentation: Dissertation Baetz p.138,139, p.141-149
  *
  * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink, communication with
- * physical devices, using the @link DeviceCommunicationIF, and communication with commanding objects.
- *
- * 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.
- *
+ * physical devices, using the @link DeviceCommunicationIF @endlink, and communication with commanding objects.
  * It inherits SystemObject and thus can be created by the ObjectManagerIF.
  *
  * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
- * For each step an RMAP action is selected and executed. If data has been received (GET_READ), the data will be interpreted.
+ * For each step an RMAP action is selected and executed.
+ * 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.
+ * 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
@@ -64,8 +63,9 @@ class StorageManagerIF;
  *  6. fillCommandAndReplyMap()
  *  7. scanForReply()
  *  8. interpretDeviceReply()
+ *
  * Other important virtual methods with a default implementation
- * are the getTransitionDelay() function and the getSwitches() function
+ * are the getTransitionDelayMs() function and the getSwitches() function.
  *
  * @ingroup devices
  */
@@ -233,14 +233,26 @@ protected:
 	 * @details
 	 * This is used to let the base class know which replies are expected.
 	 * There are different scenarios regarding this:
-	 * - "Normal" commands. These are commands, that trigger a direct reply from the device. In this case, the id of the command should be added to the command map
-	 * with a commandData_t where maxDelayCycles is set to the maximum expected number of PST cycles the reply will take. Then, scanForReply returns the id of the command and the base class can handle time-out and missing replies.
-	 * - Periodic, unrequested replies. These are replies that, once enabled, are sent by the device on its own in a defined interval. In this case, the id of the reply or a placeholder id should be added to the deviceCommandMap
-	 * with a commandData_t where maxDelayCycles is set to the maximum expected number of PST cycles between two replies (also a tolerance should be added, as an FDIR message will be generated if it is missed).
-	 * As soon as the replies are enabled, DeviceCommandInfo.periodic must be set to 1, DeviceCommandInfo.delayCycles to DeviceCommandInfo.MaxDelayCycles. From then on, the base class handles the reception.
-	 * Then, scanForReply returns the id of the reply or the placeholder id and the base class will take care of checking that all replies are received and the interval is correct.
-	 * When the replies are disabled, DeviceCommandInfo.periodic must be set to 0, DeviceCommandInfo.delayCycles to 0;
-	 * - Aperiodic, unrequested replies. These are replies that are sent by the device without any preceding command and not in a defined interval. These are not entered in the deviceCommandMap but handled by returning @c APERIODIC_REPLY in scanForReply().
+	 *  - "Normal" commands. These are commands, that trigger a direct reply from the device.
+	 *    In this case, the id of the command should be added to the command map
+	 *    with a commandData_t where maxDelayCycles is set to the maximum expected
+	 *    number of PST cycles the reply will take. Then, scanForReply returns
+	 *    the id of the command and the base class can handle time-out and missing replies.
+	 *  - Periodic, unrequested replies. These are replies that, once enabled, are sent by the device
+	 *    on its own in a defined interval. In this case, the id of the reply
+	 *    or a placeholder id should be added to the deviceCommandMap with a commandData_t
+	 *    where maxDelayCycles is set to the maximum expected number of PST cycles between
+	 *    two replies (also a tolerance should be added, as an FDIR message will be generated if it is missed).
+	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must be set to 1,
+	 *    DeviceCommandInfo.delayCycles to DeviceCommandInfo.MaxDelayCycles.
+	 *    From then on, the base class handles the reception.
+	 *    Then, scanForReply returns the id of the reply or the placeholder id and the base class will
+	 *    take care of checking that all replies are received and the interval is correct.
+	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set to 0,
+	 *    DeviceCommandInfo.delayCycles to 0;
+	 *  - Aperiodic, unrequested replies. These are replies that are sent
+	 *    by the device without any preceding command and not in a defined interval.
+	 *    These are not entered in the deviceCommandMap but handled by returning @c APERIODIC_REPLY in scanForReply().
 	 *
 	 */
 	virtual void fillCommandAndReplyMap() = 0;
@@ -306,10 +318,10 @@ protected:
 	 *
 	 * Used for the following transitions:
 	 * modeFrom -> modeTo:
-	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches, the base class got you covered)
+	 *  - MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 *  - MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 *  - MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 *  - _MODE_START_UP -> MODE_ON (do not include time to set the switches, the base class got you covered)
 	 *
 	 * The default implementation returns 0 !
 	 * @param modeFrom
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 279f9ab43..a62b7397d 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -104,6 +104,66 @@ public:
 	};
 
 protected:
+	/**
+	 * Check the target subservice
+	 * @param subservice
+	 * @return
+	 */
+	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
+
+	/**
+	 * Once a TC Request is valid, the existence of the destination and its target interface is checked and retrieved.
+	 * The target message queue ID can then be acquired by using the target interface.
+	 * @param subservice
+	 * @param tcData Application Data of TC Packet
+	 * @param tcDataLen
+	 * @param id MessageQueue ID is stored here
+	 * @param objectId Object ID is extracted and stored here
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED
+	 *         - @c CSB or implementation specific return codes
+	 */
+	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, uint32_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) = 0;
+
+	/**
+	 * After the Message Queue and Object ID are determined,
+	 * the command is prepared by using an implementation specific CommandMessage type
+	 * which is sent to the target object.
+	 * It contains all necessary information for the device to execute telecommands.
+	 * @param message
+	 * @param subservice
+	 * @param tcData
+	 * @param tcDataLen
+	 * @param state
+	 * @param objectId Target object ID
+	 * @return
+	 */
+	virtual ReturnValue_t prepareCommand(CommandMessage *message,
+			uint8_t subservice, const uint8_t *tcData, uint32_t tcDataLen,
+			uint32_t *state, object_id_t objectId) = 0;
+
+	/**
+	 * This function is responsible for the communication between the Command Service Base
+	 * and the respective PUS Commanding Service once the execution has started.
+	 * The PUS Commanding Service receives replies from the target device and forwards them by calling this function.
+	 * There are different translations of these replies to specify how the Command Service proceeds.
+	 * @param reply[out] Command Message which contains information about the command
+	 * @param previousCommand [out]
+	 * @param state
+	 * @param optionalNextCommand
+	 * @param objectId Source object ID
+	 * @param isStep Flag value to mark steps of command execution
+	 * @return - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to generate TC verification success
+	 *         - @c INVALID_REPLY can handle unrequested replies
+	 *         - Anything else triggers a TC verification failure
+	 */
+	virtual ReturnValue_t handleReply(const CommandMessage *reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage *optionalNextCommand, object_id_t objectId,
+			bool *isStep) = 0;
+
 	struct CommandInfo {
 		struct tcInfo {
 			uint8_t ackFlags;
@@ -181,67 +241,6 @@ protected:
 	void sendTmPacket(uint8_t subservice, SerializeIF* content,
 			SerializeIF* header = NULL);
 
-	/**
-	 * Check the target subservice
-	 * @param subservice
-	 * @return
-	 */
-	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
-
-	/**
-	 * Once a TC Request is valid, the existence of the destination and its target interface is checked and retrieved.
-	 * The target message queue ID can then be acquired by using the target interface.
-	 * @param subservice
-	 * @param tcData Application Data of TC Packet
-	 * @param tcDataLen
-	 * @param id MessageQueue ID is stored here
-	 * @param objectId Object ID is extracted and stored here
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED
-	 *         - @c CSB or implementation specific return codes
-	 */
-	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, uint32_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) = 0;
-
-	/**
-	 * After the Message Queue and Object ID are determined,
-	 * the command is prepared by using an implementation specific CommandMessage type
-	 * which is sent to the target object.
-	 * It contains all necessary information for the device to execute telecommands.
-	 * @param message
-	 * @param subservice
-	 * @param tcData
-	 * @param tcDataLen
-	 * @param state
-	 * @param objectId Target object ID
-	 * @return
-	 */
-	virtual ReturnValue_t prepareCommand(CommandMessage *message,
-			uint8_t subservice, const uint8_t *tcData, uint32_t tcDataLen,
-			uint32_t *state, object_id_t objectId) = 0;
-
-	/**
-	 * This function is responsible for the communication between the Command Service Base
-	 * and the respective PUS Commanding Service once the execution has started.
-	 * The PUS Commanding Service receives replies from the target device and forwards them by calling this function.
-	 * There are different translations of these replies to specify how the Command Service proceeds.
-	 * @param reply[out] Command Message which contains information about the command
-	 * @param previousCommand [out]
-	 * @param state
-	 * @param optionalNextCommand
-	 * @param objectId Source object ID
-	 * @param isStep Flag value to mark steps of command execution
-	 * @return - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to generate TC verification success
-	 *         - @c INVALID_REPLY can handle unrequested replies
-	 *         - Anything else triggers a TC verification failure
-	 */
-	virtual ReturnValue_t handleReply(const CommandMessage *reply,
-			Command_t previousCommand, uint32_t *state,
-			CommandMessage *optionalNextCommand, object_id_t objectId,
-			bool *isStep) = 0;
-
-
 	virtual void handleUnrequestedReply(CommandMessage *reply);
 
 	virtual void doPeriodicOperation();

From 1977942c4b2a785e503c21f5cd5cc235ee69e9ed Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 22 Jan 2020 14:24:48 +0100
Subject: [PATCH 0089/1774] Array List Entry swapper function

And respective SerialAdapter functions to use it
---
 container/ArrayList.h                   | 19 +++++++++++++++++++
 container/FixedArrayList.h              |  9 +++++++--
 serialize/SerialArrayListAdapter.h      | 15 ++-------------
 serialize/SerialFixedArrayListAdapter.h |  4 ++++
 serialize/SerializeElement.h            |  4 ++++
 5 files changed, 36 insertions(+), 15 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 9c4c4cebc..0a2c2ff7e 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -223,6 +223,25 @@ public:
 	count_t remaining() {
 		return (maxSize_ - size);
 	}
+
+	/**
+	 * Swap the endianness of the Array list (not the length field !)
+	 * Useful if the case the buffer type is larger than uint8_t
+	 * @param list
+	 */
+	void swapArrayListEndianness() {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		count_t i = 0;
+		// uint8_t buffer does not require swapping of entries.
+		if(sizeof(T) == 1) {
+			return;
+		}
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < size)) {
+			T newEntry = EndianSwapper::swap(entries[i]);
+			entries[i] = newEntry;
+			++i;
+		}
+	}
 private:
 	/**
 	 * This is the copy constructor
diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index b9394cfec..36d379793 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -2,8 +2,10 @@
 #define FIXEDARRAYLIST_H_
 
 #include <framework/container/ArrayList.h>
+
 /**
- * \ingroup container
+ * @brief 	Array List with a fixed maximum size
+ * @ingroup container
  */
 template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList: public ArrayList<T, count_t> {
@@ -17,10 +19,13 @@ public:
 	//We could create a constructor to initialize the fixed array list with data and the known size field
 	//so it can be used for serialization too (with SerialFixedArrrayListAdapter)
 	//is this feasible?
-	FixedArrayList(T * data_, count_t count):
+	FixedArrayList(T * data_, count_t count, bool swapArrayListEndianess = false):
 		ArrayList<T, count_t>(data, MAX_SIZE) {
 		memcpy(this->data, data_, count);
 		this->size = count;
+		if(swapArrayListEndianess) {
+			ArrayList<T, count_t>::swapArrayListEndianness();
+		}
 	}
 
 	FixedArrayList(const FixedArrayList& other) :
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 21cbbc4d6..3f80e97b6 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -79,20 +79,9 @@ public:
 		return result;
 	}
 
-	/**
-	 * Swap the endianness of the Array list (not the length field !)
-	 * Useful if the case the buffer type is large than uint8_t and the endianness
-	 * is inconsistent with other SerializeElements.
-	 * @param list
-	 */
+
 	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		count_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			T newEntry = EndianSwapper::swap(list->entries[i]);
-			list->entries[i] = newEntry;
-			++i;
-		}
+		list->swapArrayListEndianness();
 	}
 private:
 	ArrayList<T, count_t> *adaptee;
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 9613f6c13..67954d685 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -24,6 +24,10 @@
 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
+	 * @param args
+	 */
 	template<typename... Args>
 	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
 	}
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 4f5a22b6e..cd040c0f7 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -19,6 +19,10 @@
 template<typename T>
 class SerializeElement : public SerializeIF, public LinkedElement<SerializeIF> {
 public:
+	/**
+	 * Arguments are forwarded to the element datatype constructor
+	 * @param args
+	 */
 	template<typename... Args>
 	SerializeElement(Args... args) : LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
 

From d330958abb5813261936198700a2fac535aa1884 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 22 Jan 2020 14:27:11 +0100
Subject: [PATCH 0090/1774] Array List endian swapper protected now

---
 container/ArrayList.h | 55 ++++++++++++++++++++++---------------------
 1 file changed, 28 insertions(+), 27 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 0a2c2ff7e..59e5eef4a 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -224,6 +224,34 @@ public:
 		return (maxSize_ - size);
 	}
 
+
+private:
+	/**
+	 * This is the copy constructor
+	 *
+	 * It is private, as copying is too ambigous in this case. (Allocate a new backend? Use the same?
+	 * What to do in an modifying call?)
+	 *
+	 * @param other
+	 */
+	ArrayList(const ArrayList& other) :
+			size(other.size), entries(other.entries), maxSize_(other.maxSize_),
+			allocated(false) {}
+protected:
+	/**
+	 * pointer to the array in which the entries are stored
+	 */
+	T *entries;
+	/**
+	 * remembering the maximum size
+	 */
+	uint32_t maxSize_;
+
+	/**
+	 * true if the array was allocated and needs to be deleted in the destructor.
+	 */
+	bool allocated;
+
 	/**
 	 * Swap the endianness of the Array list (not the length field !)
 	 * Useful if the case the buffer type is larger than uint8_t
@@ -242,33 +270,6 @@ public:
 			++i;
 		}
 	}
-private:
-	/**
-	 * This is the copy constructor
-	 *
-	 * It is private, as copying is too ambigous in this case. (Allocate a new backend? Use the same?
-	 * What to do in an modifying call?)
-	 *
-	 * @param other
-	 */
-	ArrayList(const ArrayList& other) :
-			size(other.size), entries(other.entries), maxSize_(other.maxSize_), allocated(
-					false) {
-	}
-protected:
-	/**
-	 * pointer to the array in which the entries are stored
-	 */
-	T *entries;
-	/**
-	 * remembering the maximum size
-	 */
-	uint32_t maxSize_;
-
-	/**
-	 * true if the array was allocated and needs to be deleted in the destructor.
-	 */
-	bool allocated;
 
 };
 #endif /* ARRAYLIST_H_ */

From 6eedb3f09748ed698ece38cb9fc5be6ebe1d3c66 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 23 Jan 2020 15:45:21 +0100
Subject: [PATCH 0091/1774] New Pool List Initializer.

Needs testing !!!
---
 datapool/PoolEntry.cpp | 11 ++++++-----
 datapool/PoolEntry.h   |  3 ++-
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index f2968c329..af5584d81 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -2,12 +2,13 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t set_length, uint8_t set_valid ) : length(set_length), valid(set_valid) {
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t set_length, uint8_t set_valid ) : length(set_length), valid(set_valid) {
 	this->address = new T[this->length];
-	if (initValue != NULL) {
-		memcpy(this->address, initValue, this->getByteSize() );
-	} else {
-		memset(this->address, 0, this->getByteSize() );
+	if(initValue.size() == 0) {
+		memset(this->address, 0, this->getByteSize());
+	}
+	else {
+		memcpy(this->address, initValue.begin(), this->getByteSize());
 	}
 }
 
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index ce41a9917..97364bf0f 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -5,6 +5,7 @@
 #include <framework/datapool/PoolEntryIF.h>
 #include <stddef.h>
 #include <cstring>
+#include <initializer_list>
 /**
  * \brief		This is a small helper class that defines a single data pool entry.
  *
@@ -31,7 +32,7 @@ public:
 	 * \param set_length	Defines the array length of this entry.
 	 * \param set_valid		Sets the initialization flag. It is invalid (0) by default.
 	 */
-	PoolEntry( T* initValue = NULL, uint8_t set_length = 1, uint8_t set_valid = 0 );
+	PoolEntry( std::initializer_list<T> initValue = {}, uint8_t set_length = 1, uint8_t set_valid = 0 );
 	/**
 	 * \brief	The allocated memory for the variable is freed in the destructor.
 	 * \details	As the data pool is global, this dtor is only called on program exit.

From d9fa13b6ebd597b6c23f5768405dc757b467028e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 26 Jan 2020 18:31:17 +0100
Subject: [PATCH 0092/1774] ADDED old pool entry constructor

---
 datapool/PoolEntry.cpp | 11 +++++++++++
 datapool/PoolEntry.h   |  1 +
 2 files changed, 12 insertions(+)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index af5584d81..898d226e2 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -12,6 +12,17 @@ PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t set_length,
 	}
 }
 
+template <typename T>
+PoolEntry<T>::PoolEntry( T* initValue, uint8_t set_length, uint8_t set_valid ) : length(set_length), valid(set_valid) {
+	this->address = new T[this->length];
+	if (initValue != NULL) {
+		memcpy(this->address, initValue, this->getByteSize() );
+	} else {
+		memset(this->address, 0, this->getByteSize() );
+	}
+}
+
+
 //As the data pool is global, this dtor is only be called on program exit.
 //Warning! Never copy pool entries!
 template <typename T>
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 97364bf0f..a02c6c60d 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -33,6 +33,7 @@ public:
 	 * \param set_valid		Sets the initialization flag. It is invalid (0) by default.
 	 */
 	PoolEntry( std::initializer_list<T> initValue = {}, uint8_t set_length = 1, uint8_t set_valid = 0 );
+	PoolEntry( T* initValue = NULL, uint8_t set_length = 1, uint8_t set_valid = 0 );
 	/**
 	 * \brief	The allocated memory for the variable is freed in the destructor.
 	 * \details	As the data pool is global, this dtor is only called on program exit.

From 85048cc9ee180ce6ba14485d18d85bf694e1e51f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 26 Jan 2020 22:13:56 +0100
Subject: [PATCH 0093/1774] Pool Raw Access change bugfix

---
 datapool/PoolRawAccess.cpp | 37 ++++++++++++++++++++++---------------
 datapool/PoolRawAccess.h   |  1 +
 2 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 899eedd69..ff8fb9561 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -21,24 +21,13 @@ ReturnValue_t PoolRawAccess::read() {
 	PoolEntryIF* read_out = ::dataPool.getRawData(dataPoolId);
 	if (read_out != NULL) {
 		result = handleReadOut(read_out);
+		if(result == RETURN_OK) {
+			return result;
+		}
 	} else {
 		result = READ_ENTRY_NON_EXISTENT;
 	}
-	error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed, ";
-	if(result == READ_TYPE_TOO_LARGE) {
-		error << "type too large." << std::endl;
-	}
-	else if(result == READ_INDEX_TOO_LARGE) {
-		error << "index too large." << std::endl;
-	}
-	else {
-		error << "entry does not exist." << std::endl;
-	}
-	valid = INVALID;
-	typeSize = 0;
-	sizeTillEnd = 0;
-	memset(value, 0, sizeof(value));
+	handleReadError(result);
 	return result;
 }
 
@@ -65,6 +54,24 @@ ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* read_out) {
 	return result;
 }
 
+void PoolRawAccess::handleReadError(ReturnValue_t result) {
+	error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
+			<< std::dec << " failed, ";
+	if(result == READ_TYPE_TOO_LARGE) {
+		error << "type too large." << std::endl;
+	}
+	else if(result == READ_INDEX_TOO_LARGE) {
+		error << "index too large." << std::endl;
+	}
+	else if(result == READ_ENTRY_NON_EXISTENT) {
+		error << "entry does not exist." << std::endl;
+	}
+	valid = INVALID;
+	typeSize = 0;
+	sizeTillEnd = 0;
+	memset(value, 0, sizeof(value));
+}
+
 ReturnValue_t PoolRawAccess::commit() {
 	PoolEntryIF* write_back = ::dataPool.getRawData(dataPoolId);
 	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 5fb482f09..52ba8b210 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -157,6 +157,7 @@ protected:
 	ReturnValue_t commit();
 
 	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
+	void handleReadError(ReturnValue_t result);
 private:
 	/**
 	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id

From 8f17d5147e7b13179c32fa47f2c2bdc7408e4ef5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 27 Jan 2020 00:43:01 +0100
Subject: [PATCH 0094/1774] SerialFixedArrayList constructor bugfix

---
 container/FixedArrayList.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index 36d379793..12e292b4a 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -21,7 +21,7 @@ public:
 	//is this feasible?
 	FixedArrayList(T * data_, count_t count, bool swapArrayListEndianess = false):
 		ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, data_, count);
+		memcpy(this->data, data_, count * sizeof(T));
 		this->size = count;
 		if(swapArrayListEndianess) {
 			ArrayList<T, count_t>::swapArrayListEndianness();

From 7dd4694d9d9e25114c6b52f7539ced43b8bdca3f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Jan 2020 23:19:19 +0100
Subject: [PATCH 0095/1774] CCSDS time extra defined for avr lib

---
 timemanager/CCSDSTime.cpp        | 47 +++++++++++++++++++++++++++++---
 timemanager/ReceivesTimeInfoIF.h |  1 +
 2 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 2eb6c4b54..c3a28df71 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -154,6 +154,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	if (length < 19) {
 		return RETURN_FAILED;
 	}
+#ifdef AVR_STDIO
 	// In the size optimized nano library used by ATMEL, floating point conversion
 	// is not allowed. There is a linker flag to allow it apparently, but I
 	// could not manage to make it run (removing -specs=nano.specs in linker flags works though,
@@ -167,11 +168,8 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	int minute;
 	int second;
 	int usecond;
-	// try Code A (yyyy-mm-dd)
-	//int count = sscanf((char *) from, "%4hi-%2hi-%2hiT%2hi:%2hi:%fZ", &year,
-	//		&month, &day, &hour, &minute, &second);
 	int count = sscanf((char *) from, "%4d-%2d-%2dT%2d:%2d:%2d.%dZ", &year,
-				&month, &day, &hour, &minute, &second, &usecond);
+			&month, &day, &hour, &minute, &second, &usecond);
 	if (count == 7) {
 		to->year = year;
 		to->month = month;
@@ -202,6 +200,47 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		to->usecond = usecond;
 		return RETURN_OK;
 	}
+#else
+	uint16_t year;
+	uint8_t month;
+	uint16_t day;
+	uint8_t hour;
+	uint8_t minute;
+	float second;
+	//try Code A (yyyy-mm-dd)
+	int count = sscanf((char *) from, "%4hi-%2hhi-%2hiT%2hhi:%2hhi:%fZ", &year,
+			&month, &day, &hour, &minute, &second);
+	if (count == 6) {
+		to->year = year;
+		to->month = month;
+		to->day = day;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+
+	//try Code B (yyyy-ddd)
+	count = sscanf((char *) from, "%4hi-%3hiT%2hhi:%2hhi:%fZ", &year, &day,
+			&hour, &minute, &second);
+	if (count == 5) {
+		uint8_t tempDay;
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
+				&tempDay);
+		if (result != RETURN_OK) {
+			return RETURN_FAILED;
+		}
+		to->year = year;
+		to->month = month;
+		to->day = tempDay;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+#endif
 
 	return UNSUPPORTED_TIME_FORMAT;
 }
diff --git a/timemanager/ReceivesTimeInfoIF.h b/timemanager/ReceivesTimeInfoIF.h
index 14a750c56..f65f9dadd 100644
--- a/timemanager/ReceivesTimeInfoIF.h
+++ b/timemanager/ReceivesTimeInfoIF.h
@@ -7,6 +7,7 @@
 
 #ifndef RECEIVESTIMEINFOIF_H_
 #define RECEIVESTIMEINFOIF_H_
+#include <framework/ipc/MessageQueueSenderIF.h>
 
 /**
  * This is a Interface for classes that receive timing information

From 09144b18c4fad1c9c92510f3c99ad377ddbbac58 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 29 Jan 2020 01:03:20 +0100
Subject: [PATCH 0096/1774] ccsds time changes changed

---
 timemanager/CCSDSTime.cpp | 43 +++++++++++++++++----------------------
 1 file changed, 19 insertions(+), 24 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index c3a28df71..a81f55967 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,5 +1,6 @@
 #include <framework/timemanager/CCSDSTime.h>
 #include <stdio.h>
+#include <inttypes.h>
 #include <math.h>
 
 CCSDSTime::CCSDSTime() {
@@ -154,39 +155,33 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	if (length < 19) {
 		return RETURN_FAILED;
 	}
-#ifdef AVR_STDIO
-	// In the size optimized nano library used by ATMEL, floating point conversion
-	// is not allowed. There is a linker flag to allow it apparently, but I
-	// could not manage to make it run (removing -specs=nano.specs in linker flags works though,
-	// but we propably should include this). Using floats with sscanf is also expensive.
-	// Furthermore, the stdio.c library by ATMEL can't resolve the %hhi specifiers
-	// Therefore, I adapted this function.
-	int year;
-	int month;
-	int day;
-	int hour;
-	int minute;
-	int second;
-	int usecond;
-	int count = sscanf((char *) from, "%4d-%2d-%2dT%2d:%2d:%2d.%dZ", &year,
-			&month, &day, &hour, &minute, &second, &usecond);
-	if (count == 7) {
+// Newlib can't parse uint8 (there is a configure option but I still need to figure out how to make it work..)
+#ifdef NEWLIB_NO_C99_IO
+	uint16_t year;
+	uint16_t month;
+	uint16_t day;
+	uint16_t hour;
+	uint16_t minute;
+	float second;
+	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
+				&month, &day, &hour, &minute, &second);
+	if (count == 6) {
 		to->year = year;
 		to->month = month;
 		to->day = day;
 		to->hour = hour;
 		to->minute = minute;
 		to->second = second;
-		to->usecond = usecond;//(second - floor(second)) * 1000000;
+		to->usecond = (second - floor(second)) * 1000000;
 		return RETURN_OK;
 	}
 
 	// try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4i-%3iT%2i:%2i:%2i.%iZ", &year, &day,
-			&hour, &minute, &second, &usecond);
-	if (count == 6) {
+	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
+			&hour, &minute, &second);
+	if (count == 5) {
 		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear((uint16_t)day,(uint16_t) year,(uint8_t *) &month,
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,(uint8_t *) &month,
 				&tempDay);
 		if (result != RETURN_OK) {
 			return RETURN_FAILED;
@@ -197,7 +192,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		to->hour = hour;
 		to->minute = minute;
 		to->second = second;
-		to->usecond = usecond;
+		to->usecond = (second - floor(second)) * 1000000;
 		return RETURN_OK;
 	}
 #else
@@ -208,7 +203,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	uint8_t minute;
 	float second;
 	//try Code A (yyyy-mm-dd)
-	int count = sscanf((char *) from, "%4hi-%2hhi-%2hiT%2hhi:%2hhi:%fZ", &year,
+	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16 "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year,
 			&month, &day, &hour, &minute, &second);
 	if (count == 6) {
 		to->year = year;

From 5190e4c16e0f6618cd1c6b3a3b8f8ad7683172f7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 31 Jan 2020 00:54:34 +0100
Subject: [PATCH 0097/1774] Serial Buffer dapter changes reverted

CCSDS time bugfixes in separate section (for C98)
Serial buffer adapter 2 bugfixes
---
 serialize/SerialBufferAdapter2.h            |  4 +++-
 serviceinterface/ServiceInterfaceBuffer.cpp | 14 +++++++-------
 timemanager/CCSDSTime.cpp                   | 10 ++++++----
 3 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/serialize/SerialBufferAdapter2.h b/serialize/SerialBufferAdapter2.h
index 59c79dc2e..98e2d187d 100644
--- a/serialize/SerialBufferAdapter2.h
+++ b/serialize/SerialBufferAdapter2.h
@@ -131,6 +131,7 @@ private:
 
 	void determineLengthInBytes(uint8_t typeSize) {
 		switch(typeSize) {
+		case(1): break;
 		case(2):
 			bufferLength *= 2; break;
 		case(4):
@@ -138,7 +139,8 @@ private:
 		case(8):
 			bufferLength *= 8; break;
 		default:
-			warning << "Invalid type size, assuming regular uint8_t." << std::endl;
+			error << "Serial Buffer Adapter 2: Invalid type size, assuming regular uint8_t." << std::endl;
+			error << "Detected type size: " << (int) typeSize << std::endl;
 		}
 	}
 };
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index d5ce60568..6798b776d 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,6 +1,7 @@
 #include <framework/timemanager/Clock.h>
 #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
 #include <cstring>
+#include <inttypes.h>
 
 // to be implemented by bsp
 extern "C" void printChar(const char*);
@@ -21,18 +22,17 @@ int ServiceInterfaceBuffer::overflow(int c) {
 	return 0;
 }
 
-// custom stdio.c library for at91sam9g20 chip which does not support unsigned long
-// So I cast (unsigned int) on loggerTimes
 int ServiceInterfaceBuffer::sync(void) {
 	if (this->isActive) {
 		Clock::TimeOfDay_t loggerTime;
 		Clock::getDateAndTime(&loggerTime);
 		char preamble[96] = { 0 };
-		sprintf(preamble, "%s: | %u:%02u:%02u.%03u | ",
-				this->log_message.c_str(), (unsigned int) loggerTime.hour,
-				(unsigned int)  loggerTime.minute,
-				(unsigned int)  loggerTime.second,
-				(unsigned int)  loggerTime.usecond /1000);
+		sprintf(preamble, "%s: | %" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ".%03" PRIu32 " | ",
+				this->log_message.c_str(),
+				loggerTime.hour,
+				loggerTime.minute,
+				loggerTime.second,
+				loggerTime.usecond /1000);
 		// Write log_message and time
 		this->putChars(preamble, preamble + sizeof(preamble));
 		// Handle output
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index a81f55967..8a123f854 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -155,8 +155,9 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	if (length < 19) {
 		return RETURN_FAILED;
 	}
-// Newlib can't parse uint8 (there is a configure option but I still need to figure out how to make it work..)
-#ifdef NEWLIB_NO_C99_IO
+// Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
+// Suggestion: use uint16 all the time. This should work on all systems.
+#ifdef NEWLIB_NANO_NO_C99_IO
 	uint16_t year;
 	uint16_t month;
 	uint16_t day;
@@ -181,8 +182,8 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 			&hour, &minute, &second);
 	if (count == 5) {
 		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,(uint8_t *) &month,
-				&tempDay);
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
+				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
 		if (result != RETURN_OK) {
 			return RETURN_FAILED;
 		}
@@ -195,6 +196,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		to->usecond = (second - floor(second)) * 1000000;
 		return RETURN_OK;
 	}
+// Warning: Compiler/Linker fails ambiguously if library does not implement C99 I/O
 #else
 	uint16_t year;
 	uint8_t month;

From b3faf1e4adee4097b9bcc15ad61c299adacc33a2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 31 Jan 2020 23:42:11 +0100
Subject: [PATCH 0098/1774] old timestring used

---
 timemanager/CCSDSTime.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 8a123f854..29aafb68d 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -205,8 +205,8 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	uint8_t minute;
 	float second;
 	//try Code A (yyyy-mm-dd)
-	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16 "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year,
-			&month, &day, &hour, &minute, &second);
+	int count = sscanf((char *) from, "%4hi-%2hhi-%2hiT%2hhi:%2hhi:%fZ", &year,
+				&month, &day, &hour, &minute, &second);
 	if (count == 6) {
 		to->year = year;
 		to->month = month;

From e15839b3a6cdccf3f437991262c0c2eddb6b4ba6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 15 Feb 2020 18:26:25 +0100
Subject: [PATCH 0099/1774] Thermal: Some formatting stuff, doc to do

Need to find out how to use the thermal components
---
 thermal/AbstractTemperatureSensor.h |  3 +-
 thermal/CoreComponent.h             |  2 +-
 thermal/RedundantHeater.h           | 11 +++---
 thermal/TemperatureSensor.h         | 56 +++++++++++++++++------------
 thermal/ThermalComponent.cpp        | 10 +++---
 thermal/ThermalComponent.h          | 25 +++++++++++--
 thermal/ThermalMonitor.h            |  3 ++
 7 files changed, 72 insertions(+), 38 deletions(-)

diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h
index 3bebbe73c..4b8693655 100644
--- a/thermal/AbstractTemperatureSensor.h
+++ b/thermal/AbstractTemperatureSensor.h
@@ -16,7 +16,8 @@
  */
 
 /**
- * @brief Base class for Temperature Sensor, implements all important interfaces
+ * @brief Base class for Temperature Sensor, implements all important interfaces.
+ *        Please use the TemperatureSensor class to implement the actual sensors.
  * @ingroup thermal
  */
 class AbstractTemperatureSensor: public HasHealthIF,
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index e21ee113b..da77c65b3 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -8,7 +8,7 @@
 #include <framework/thermal/ThermalModule.h>
 #include <framework/thermal/ThermalMonitor.h>
 
-// TODO: Documentaiton, how to use this? only use Thermal COmponent, which inherits core component?
+// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
 class CoreComponent: public ThermalComponentIF {
 public:
 	struct Parameters {
diff --git a/thermal/RedundantHeater.h b/thermal/RedundantHeater.h
index 29791a9a1..55d402d75 100644
--- a/thermal/RedundantHeater.h
+++ b/thermal/RedundantHeater.h
@@ -10,15 +10,14 @@ public:
 		Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
 				uint8_t switch0Heater0, uint8_t switch1Heater0,
 				uint8_t switch0Heater1, uint8_t switch1Heater1) :
-				objectIdHeater0(objectIdHeater0), objectIdHeater1(
-						objectIdHeater1), switch0Heater0(switch0Heater0), switch1Heater0(
-						switch1Heater0), switch0Heater1(switch0Heater1), switch1Heater1(
-						switch1Heater1) {
+				objectIdHeater0(objectIdHeater0), objectIdHeater1(objectIdHeater1),
+				switch0Heater0(switch0Heater0),switch1Heater0(switch1Heater0),
+				switch0Heater1(switch0Heater1), switch1Heater1(switch1Heater1) {
 		}
 
 		Parameters() :
-				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0), switch1Heater0(
-						0), switch0Heater1(0), switch1Heater1(0) {
+				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0),
+				switch1Heater0(0), switch0Heater1(0), switch1Heater1(0) {
 		}
 
 		uint32_t objectIdHeater0;
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index cbf8ea30f..2f64f7721 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -8,14 +8,17 @@
 /**
  * @brief 	This building block handles non-linear value conversion and
  * 			range checks for analog temperature sensors.
- * @details
- *
+ * @details HOW TO USE
  *
  */
 
 template<typename T>
 class TemperatureSensor: public AbstractTemperatureSensor {
 public:
+
+	/**
+	 * What are a,b and c?
+	 */
 	struct Parameters {
 		float a;
 		float b;
@@ -24,11 +27,37 @@ public:
 		T upperLimit;
 		float gradient;
 	};
+
+	/**
+	 * How to use me.
+	 * @param setObjectid
+	 * @param inputTemperature
+	 * @param poolVariable
+	 * @param vectorIndex
+	 * @param parameters
+	 * @param datapoolId
+	 * @param outputSet
+	 * @param thermalModule
+	 */
+	TemperatureSensor(object_id_t setObjectid,
+		T *inputTemperature, PoolVariableIF *poolVariable,
+		uint8_t vectorIndex, Parameters parameters, uint32_t datapoolId,
+		DataSet *outputSet, ThermalModuleIF *thermalModule) :
+
+		AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
+		inputTemperature(inputTemperature), poolVariable(poolVariable),
+		outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
+		sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
+			DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+			DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit,parameters.upperLimit,
+			TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
+		oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
+	}
+
 	struct UsedParameters {
 		UsedParameters(Parameters parameters) :
-				a(parameters.a), b(parameters.b), c(parameters.c), gradient(
-						parameters.gradient) {
-		}
+			a(parameters.a), b(parameters.b), c(parameters.c),
+			gradient(parameters.gradient) {}
 		float a;
 		float b;
 		float c;
@@ -118,23 +147,6 @@ protected:
 	}
 
 public:
-	TemperatureSensor(object_id_t setObjectid,
-			T *inputTemperature, PoolVariableIF *poolVariable,
-			uint8_t vectorIndex, Parameters parameters, uint32_t datapoolId,
-			DataSet *outputSet, ThermalModuleIF *thermalModule) :
-			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(
-					parameters), inputTemperature(inputTemperature), poolVariable(
-					poolVariable), outputTemperature(datapoolId, outputSet,
-					PoolVariableIF::VAR_WRITE), sensorMonitor(setObjectid,
-							DOMAIN_ID_SENSOR,
-					DataPool::poolIdAndPositionToPid(
-							poolVariable->getDataPoolId(), vectorIndex),
-					DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit,
-					parameters.upperLimit, TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH), oldTemperature(
-					20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
-
-	}
-
 	float getTemperature() {
 		return outputTemperature;
 	}
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index bf6f73986..15a2bbc9c 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -12,12 +12,10 @@ ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
 		CoreComponent(reportingObjectId, domainId, temperaturePoolId,
 				targetStatePoolId, currentStatePoolId, requestPoolId, dataSet,
 				sensor, firstRedundantSensor, secondRedundantSensor,
-				thermalModule,
-				{ parameters.lowerOpLimit, parameters.upperOpLimit,
-						parameters.heaterOn, parameters.hysteresis,
-						parameters.heaterSwitchoff }, priority,
-				ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL), nopParameters(
-				{ parameters.lowerNopLimit, parameters.upperNopLimit }) {
+				thermalModule,{ parameters.lowerOpLimit, parameters.upperOpLimit,
+				parameters.heaterOn, parameters.hysteresis, parameters.heaterSwitchoff },
+				priority, ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL),
+		nopParameters({ parameters.lowerNopLimit, parameters.upperNopLimit }) {
 }
 
 ThermalComponent::~ThermalComponent() {
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 7482bd9b8..4e32e97cd 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -3,6 +3,9 @@
 
 #include "CoreComponent.h"
 
+/**
+ * What is it. How to use
+ */
 class ThermalComponent: public CoreComponent {
 public:
 	struct Parameters {
@@ -15,12 +18,30 @@ public:
 		float heaterSwitchoff;
 	};
 
-	// TODO: Documentaiton ,what is NOP?
-	// propably Non-operational?
+	/**
+	 * Non-Operational Temperatures
+	 */
 	struct NopParameters {
 		float lowerNopLimit;
 		float upperNopLimit;
 	};
+
+	/**
+	 * How to use.
+	 * @param reportingObjectId
+	 * @param domainId
+	 * @param temperaturePoolId
+	 * @param targetStatePoolId
+	 * @param currentStatePoolId
+	 * @param requestPoolId
+	 * @param dataSet
+	 * @param sensor
+	 * @param firstRedundantSensor
+	 * @param secondRedundantSensor
+	 * @param thermalModule
+	 * @param parameters
+	 * @param priority
+	 */
 	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
 			uint32_t targetStatePoolId, uint32_t currentStatePoolId, uint32_t requestPoolId,
 			DataSet *dataSet, AbstractTemperatureSensor *sensor,
diff --git a/thermal/ThermalMonitor.h b/thermal/ThermalMonitor.h
index 6aca55abc..a38889d01 100644
--- a/thermal/ThermalMonitor.h
+++ b/thermal/ThermalMonitor.h
@@ -4,6 +4,9 @@
 #include <framework/monitoring/MonitorReporter.h>
 #include <framework/thermal/ThermalComponentIF.h>
 
+/**
+ * What does it do. How to use it.
+ */
 class ThermalMonitor: public MonitorReporter<float> {
 public:
 	template<typename ... Args>

From d8ed5bb1c15587ef853432a84a3c0334350f9ebd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 15 Feb 2020 18:55:22 +0100
Subject: [PATCH 0100/1774] some comments for missing doc

---
 tmstorage/TmStoreBackendIF.h  | 19 +++++++++++++++++++
 tmstorage/TmStoreFrontendIF.h |  8 ++++++++
 2 files changed, 27 insertions(+)

diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index 162bd7665..9b913b35a 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -49,14 +49,33 @@ public:
 	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
 
 	virtual ~TmStoreBackendIF() {}
+
+	/**
+	 * What do I need to implement here ?
+	 * @param opCode
+	 * @return
+	 */
 	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
 	virtual ReturnValue_t initialize() = 0;
+
+	/**
+	 * Implement the storage of TM packets to mass memory
+	 * @param tmPacket
+	 * @return
+	 */
 	virtual ReturnValue_t storePacket(TmPacketMinimal* tmPacket) = 0;
 	virtual ReturnValue_t setFetchLimitTime(const timeval* loverLimit, const timeval* upperLimit) = 0;
 	virtual ReturnValue_t setFetchLimitBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
 	virtual ReturnValue_t fetchPackets(bool fromBegin = false) = 0;
 	virtual ReturnValue_t initializeStore(object_id_t dumpTarget) = 0;
 	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
+
+	/**
+	 * TODO: Adapt for file management system?
+	 * @param startAddress
+	 * @param endAddress
+	 * @return
+	 */
 	virtual ReturnValue_t deleteBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
 	virtual ReturnValue_t deleteTime(const timeval* timeUntil,
 				uint32_t* deletedPackets) = 0;
diff --git a/tmstorage/TmStoreFrontendIF.h b/tmstorage/TmStoreFrontendIF.h
index 787c35972..7d38cfc6b 100644
--- a/tmstorage/TmStoreFrontendIF.h
+++ b/tmstorage/TmStoreFrontendIF.h
@@ -11,6 +11,14 @@ class TmStoreBackendIF;
 class TmStoreFrontendIF {
 public:
 	virtual TmStoreBackendIF* getBackend() const = 0;
+
+	/**
+	 * What do I need to implement here?
+	 * This is propably used by PUS Service 15 so we should propably check for messages..
+	 * Provide base implementation?
+	 * @param opCode
+	 * @return
+	 */
 	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
 	/**
 	 * Callback from the back-end to indicate a certain packet was received.

From ddae9ee80f2c74383fa4efa91082c3871b60f6d3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 16 Feb 2020 14:59:45 +0100
Subject: [PATCH 0101/1774] =?UTF-8?q?adapted=20temp=20sensor=20to=20use=20?=
 =?UTF-8?q?=C2=B0C=20limits,=20doc=20added?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 monitoring/LimitMonitor.h   |  11 +--
 thermal/TemperatureSensor.h | 152 +++++++++++++++++++++++-------------
 2 files changed, 105 insertions(+), 58 deletions(-)

diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index 45abe48bf..c24629a35 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -16,12 +16,13 @@ public:
 			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
 			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
 			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), lowerLimit(
-					lowerLimit), upperLimit(upperLimit), belowLowEvent(
-					belowLowEvent), aboveHighEvent(aboveHighEvent) {
-	}
-	virtual ~LimitMonitor() {
+			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit),
+			lowerLimit(lowerLimit), upperLimit(upperLimit), belowLowEvent(belowLowEvent),
+			aboveHighEvent(aboveHighEvent) {
 	}
+
+	virtual ~LimitMonitor() {}
+
 	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
 		*crossedLimit = 0.0;
 		if (sample > upperLimit) {
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 2f64f7721..ca0dbce61 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -1,105 +1,142 @@
 #ifndef TEMPERATURESENSOR_H_
 #define TEMPERATURESENSOR_H_
 
+#include <framework/thermal/AbstractTemperatureSensor.h>
 #include <framework/datapool/DataSet.h>
-#include "AbstractTemperatureSensor.h"
 #include <framework/monitoring/LimitMonitor.h>
 
 /**
  * @brief 	This building block handles non-linear value conversion and
  * 			range checks for analog temperature sensors.
- * @details HOW TO USE
+ * @details This class can be used to perform all necessary tasks for temperature sensors.
+ *          A sensor can be instantiated by calling the constructor.
+ *          The temperature is calculated from an input value with
+ *			the calculateOutputTemperature() function. Range checking and
+ *			limit monitoring is performed automatically.
  *
+ * @ingroup thermal
  */
 
 template<typename T>
 class TemperatureSensor: public AbstractTemperatureSensor {
 public:
-
 	/**
-	 * What are a,b and c?
+	 * This structure contains parameters required for range checking
+	 * and the conversion from the input value to the output temperature.
+	 * a, b and c can be any parameters required to calculate the output
+	 * temperature from the input value, for example parameters for the
+	 * Callendar-Van-Dusen equation(see datasheet of used sensor / ADC)
+	 *
+	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
+	 *
+	 * The lower and upper limits can be specified in °C or in the input value
+	 * format
 	 */
 	struct Parameters {
 		float a;
 		float b;
 		float c;
-		T lowerLimit;
-		T upperLimit;
-		float gradient;
+		float maxGradient;
 	};
 
 	/**
-	 * How to use me.
-	 * @param setObjectid
-	 * @param inputTemperature
-	 * @param poolVariable
-	 * @param vectorIndex
-	 * @param parameters
-	 * @param datapoolId
-	 * @param outputSet
-	 * @param thermalModule
+	 * Forward declaration for explicit instantiation of used parameters.
 	 */
-	TemperatureSensor(object_id_t setObjectid,
-		T *inputTemperature, PoolVariableIF *poolVariable,
-		uint8_t vectorIndex, Parameters parameters, uint32_t datapoolId,
-		DataSet *outputSet, ThermalModuleIF *thermalModule) :
-
-		AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
-		inputTemperature(inputTemperature), poolVariable(poolVariable),
-		outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
-		sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
-			DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
-			DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit,parameters.upperLimit,
-			TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
-		oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
-	}
-
 	struct UsedParameters {
 		UsedParameters(Parameters parameters) :
 			a(parameters.a), b(parameters.b), c(parameters.c),
-			gradient(parameters.gradient) {}
+			gradient(parameters.maxGradient) {}
 		float a;
 		float b;
 		float c;
 		float gradient;
 	};
 
-	static const uint16_t ADDRESS_A = 0;
-	static const uint16_t ADDRESS_B = 1;
-	static const uint16_t ADDRESS_C = 2;
-	static const uint16_t ADDRESS_GRADIENT = 3;
+	/**
+	 * Constructor to check against raw input values
+	 * @param setObjectid objectId of the sensor object
+	 * @param inputValue Input value which is converted to a temperature
+	 * @param poolVariable Pool Variable to store the temperature value
+	 * @param vectorIndex Vector Index for the sensor monitor
+	 * @param parameters Calculation parameters, temperature limits, gradient limit
+	 * @param datapoolId Datapool ID of the output temperature
+	 * @param outputSet Output dataset for the output temperature to fetch it with read()
+	 * @param thermalModule respective thermal module, if it has one
+	 */
+	TemperatureSensor(object_id_t setObjectid,
+			T *inputValue, T lowerLimit, T upperLimit, PoolVariableIF *poolVariable,
+			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0},
+			DataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
+			inputValue(inputValue), poolVariable(poolVariable),
+			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
+			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 })
+	{
+		sensorMonitorRaw = new LimitMonitor<T>(setObjectid, DOMAIN_ID_SENSOR,
+				DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+				DEFAULT_CONFIRMATION_COUNT, lowerLimit, upperLimit,
+				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH);
+		delete sensorMonitor;
+	}
+
+	/**
+	 * Constructor do check against °C values
+	 */
+	TemperatureSensor(object_id_t setObjectid,
+		T *inputValue, float lowerLimit, float upperLimit, PoolVariableIF *poolVariable,
+		uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0},
+		DataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+		AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
+		inputValue(inputValue), poolVariable(poolVariable),
+		outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
+		oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 })
+	{
+		sensorMonitor = new LimitMonitor<float>(setObjectid, DOMAIN_ID_SENSOR,
+				DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+				DEFAULT_CONFIRMATION_COUNT, lowerLimit, upperLimit,
+				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH);
+		delete sensorMonitorRaw;
+	}
+
+protected:
+	/**
+	 * This formula is used to calculate the temperature from an input value
+	 * with an arbitrary type.
+	 * A default implementation is provided but can be replaced depending
+	 * on the required calculation.
+	 * @param inputTemperature
+	 * @return
+	 */
+	virtual float calculateOutputTemperature(T inputValue) {
+		return parameters.a * inputValue * inputValue
+				+ parameters.b * inputValue + parameters.c;
+	}
 
-	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
 
-	static const uint8_t DOMAIN_ID_SENSOR = 1;
 private:
 	void setInvalid() {
 		outputTemperature = INVALID_TEMPERATURE;
 		outputTemperature.setValid(false);
 		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
-		sensorMonitor.setToInvalid();
+		sensorMonitor->setToInvalid();
 	}
 protected:
 	static const int32_t INVALID_UPTIME = 0;
 
 	UsedParameters parameters;
 
-	T *inputTemperature;
+	T * inputValue;
 
 	PoolVariableIF *poolVariable;
 
 	PoolVariable<float> outputTemperature;
 
-	LimitMonitor<T> sensorMonitor;
+	LimitMonitor<T> * sensorMonitorRaw;
+	LimitMonitor<float> * sensorMonitor;
 
 	float oldTemperature;
 	timeval uptimeOfOldTemperature;
 
-	virtual float calculateOutputTemperature(T inputTemperature) {
-		return parameters.a * inputTemperature * inputTemperature
-				+ parameters.b * inputTemperature + parameters.c;
-	}
-
 	void doChildOperation() {
 		if (!poolVariable->isValid()
 				|| !healthHelper.healthTable->isHealthy(getObjectId())) {
@@ -107,7 +144,7 @@ protected:
 			return;
 		}
 
-		outputTemperature = calculateOutputTemperature(*inputTemperature);
+		outputTemperature = calculateOutputTemperature(*inputValue);
 		outputTemperature.setValid(PoolVariableIF::VALID);
 
 		timeval uptime;
@@ -115,7 +152,7 @@ protected:
 
 		if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
 			//In theory, we could use an AbsValueMonitor to monitor the gradient.
-			//But this would require storing the gradient in DP and quite some overhead.
+			//But this would require storing the maxGradient in DP and quite some overhead.
 			//The concept of delta limits is a bit strange anyway.
 			float deltaTime;
 			float deltaTemp;
@@ -133,10 +170,10 @@ protected:
 			}
 		}
 
-		//Check is done against raw limits. SHOULDDO: Why? Using °C would be more easy to handle.
-		sensorMonitor.doCheck(*inputTemperature);
+		//Check is done against raw limits. SHOULDDO: Why? Using °C would be more easy to handle.
+		sensorMonitor->doCheck(outputTemperature.value);
 
-		if (sensorMonitor.isOutOfLimits()) {
+		if (sensorMonitor->isOutOfLimits()) {
 			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
 			outputTemperature.setValid(PoolVariableIF::INVALID);
 			outputTemperature = INVALID_TEMPERATURE;
@@ -155,10 +192,19 @@ public:
 		return outputTemperature.isValid();
 	}
 
+	static const uint16_t ADDRESS_A = 0;
+	static const uint16_t ADDRESS_B = 1;
+	static const uint16_t ADDRESS_C = 2;
+	static const uint16_t ADDRESS_GRADIENT = 3;
+
+	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
+
+	static const uint8_t DOMAIN_ID_SENSOR = 1;
+
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
+		ReturnValue_t result = sensorMonitor->getParameter(domainId, parameterId,
 				parameterWrapper, newValues, startAtIndex);
 		if (result != INVALID_DOMAIN_ID) {
 			return result;
@@ -186,7 +232,7 @@ public:
 	}
 
 	virtual void resetOldState() {
-		sensorMonitor.setToUnchecked();
+		sensorMonitor->setToUnchecked();
 	}
 
 };

From 99b90e625d916dafe30cda283c7d75ec772376a8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 16 Feb 2020 16:14:29 +0100
Subject: [PATCH 0102/1774] refactored: limit type specified separately

---
 thermal/TemperatureSensor.h | 60 +++++++++++++------------------------
 1 file changed, 21 insertions(+), 39 deletions(-)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index ca0dbce61..00f77b242 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -13,11 +13,12 @@
  *          The temperature is calculated from an input value with
  *			the calculateOutputTemperature() function. Range checking and
  *			limit monitoring is performed automatically.
- *
+ *			The inputType specifies the type of the raw input while the
+ *			limitType specifies the type of the upper and lower limit to check against.
  * @ingroup thermal
  */
 
-template<typename T>
+template<typename inputType, typename limitType = inputType>
 class TemperatureSensor: public AbstractTemperatureSensor {
 public:
 	/**
@@ -29,13 +30,15 @@ public:
 	 *
 	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
 	 *
-	 * The lower and upper limits can be specified in °C or in the input value
-	 * format
+	 * The lower and upper limits can be specified in any type, for example float for C° values
+	 * or any other type for raw values.
 	 */
 	struct Parameters {
 		float a;
 		float b;
 		float c;
+		limitType lowerLimit;
+		limitType upperLimit;
 		float maxGradient;
 	};
 
@@ -64,39 +67,19 @@ public:
 	 * @param thermalModule respective thermal module, if it has one
 	 */
 	TemperatureSensor(object_id_t setObjectid,
-			T *inputValue, T lowerLimit, T upperLimit, PoolVariableIF *poolVariable,
-			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0},
+			inputType *inputValue, PoolVariableIF *poolVariable,
+			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
 			DataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
 			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
 			inputValue(inputValue), poolVariable(poolVariable),
 			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
-			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 })
-	{
-		sensorMonitorRaw = new LimitMonitor<T>(setObjectid, DOMAIN_ID_SENSOR,
+			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
 				DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
-				DEFAULT_CONFIRMATION_COUNT, lowerLimit, upperLimit,
-				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH);
-		delete sensorMonitor;
+				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
+				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
+			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
 	}
 
-	/**
-	 * Constructor do check against °C values
-	 */
-	TemperatureSensor(object_id_t setObjectid,
-		T *inputValue, float lowerLimit, float upperLimit, PoolVariableIF *poolVariable,
-		uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0},
-		DataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
-		AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
-		inputValue(inputValue), poolVariable(poolVariable),
-		outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
-		oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 })
-	{
-		sensorMonitor = new LimitMonitor<float>(setObjectid, DOMAIN_ID_SENSOR,
-				DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
-				DEFAULT_CONFIRMATION_COUNT, lowerLimit, upperLimit,
-				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH);
-		delete sensorMonitorRaw;
-	}
 
 protected:
 	/**
@@ -107,7 +90,7 @@ protected:
 	 * @param inputTemperature
 	 * @return
 	 */
-	virtual float calculateOutputTemperature(T inputValue) {
+	virtual float calculateOutputTemperature(inputType inputValue) {
 		return parameters.a * inputValue * inputValue
 				+ parameters.b * inputValue + parameters.c;
 	}
@@ -118,21 +101,20 @@ private:
 		outputTemperature = INVALID_TEMPERATURE;
 		outputTemperature.setValid(false);
 		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
-		sensorMonitor->setToInvalid();
+		sensorMonitor.setToInvalid();
 	}
 protected:
 	static const int32_t INVALID_UPTIME = 0;
 
 	UsedParameters parameters;
 
-	T * inputValue;
+	inputType * inputValue;
 
 	PoolVariableIF *poolVariable;
 
 	PoolVariable<float> outputTemperature;
 
-	LimitMonitor<T> * sensorMonitorRaw;
-	LimitMonitor<float> * sensorMonitor;
+	LimitMonitor<limitType> sensorMonitor;
 
 	float oldTemperature;
 	timeval uptimeOfOldTemperature;
@@ -171,9 +153,9 @@ protected:
 		}
 
 		//Check is done against raw limits. SHOULDDO: Why? Using °C would be more easy to handle.
-		sensorMonitor->doCheck(outputTemperature.value);
+		sensorMonitor.doCheck(outputTemperature.value);
 
-		if (sensorMonitor->isOutOfLimits()) {
+		if (sensorMonitor.isOutOfLimits()) {
 			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
 			outputTemperature.setValid(PoolVariableIF::INVALID);
 			outputTemperature = INVALID_TEMPERATURE;
@@ -204,7 +186,7 @@ public:
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = sensorMonitor->getParameter(domainId, parameterId,
+		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
 				parameterWrapper, newValues, startAtIndex);
 		if (result != INVALID_DOMAIN_ID) {
 			return result;
@@ -232,7 +214,7 @@ public:
 	}
 
 	virtual void resetOldState() {
-		sensorMonitor->setToUnchecked();
+		sensorMonitor.setToUnchecked();
 	}
 
 };

From 1001c1d48bc7aff5a88bcd58028e6f6d58777265 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 16 Feb 2020 17:21:06 +0100
Subject: [PATCH 0103/1774] added new IF for thermal messages

---
 thermal/AcceptsThermalMessagesIF.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 thermal/AcceptsThermalMessagesIF.h

diff --git a/thermal/AcceptsThermalMessagesIF.h b/thermal/AcceptsThermalMessagesIF.h
new file mode 100644
index 000000000..e95faaaf2
--- /dev/null
+++ b/thermal/AcceptsThermalMessagesIF.h
@@ -0,0 +1,18 @@
+/**
+ * \file AcceptsThermalMessagesIF.h
+ *
+ * \date 16.02.2020
+ */
+
+#ifndef FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
+#define FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
+#include <framework/ipc/MessageQueueSenderIF.h>
+
+class AcceptsThermalMessagesIF {
+public:
+	virtual ~AcceptsThermalMessagesIF();
+
+	virtual MessageQueueId_t getReceptionQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_ */

From 6ab07aeb1978d7a630944a698abebca1097b1d71 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 16 Feb 2020 21:04:17 +0100
Subject: [PATCH 0104/1774] valid mask bugfixes

---
 datapool/PoolRawAccessHelper.cpp | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 646ffbb1a..07ea44651 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -6,6 +6,9 @@
  */
 
 #include <framework/datapool/PoolRawAccessHelper.h>
+
+#include <cmath>
+
 #include <framework/datapool/DataSet.h>
 
 PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
@@ -41,7 +44,7 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 	ReturnValue_t result;
 	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
 	int32_t remainingParametersSize = numberOfParameters * 4;
-	uint8_t validityMaskSize = numberOfParameters/8;
+	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
 	uint8_t validityMask[validityMaskSize];
 	memset(validityMask,0, validityMaskSize);
 	for(uint8_t count = 0; count < numberOfParameters; count++) {
@@ -55,7 +58,8 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
 		result = RETURN_FAILED;
 	}
-	memcpy(*buffer + *size, validityMask, validityMaskSize);
+
+	memcpy(*argStruct.buffer, validityMask, validityMaskSize);
 	*size += validityMaskSize;
 	validBufferIndex = 1;
 	validBufferIndexBit = 0;
@@ -114,6 +118,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 			if(currentPoolRawAccess.isValid()) {
 				handleMaskModification(validityMask);
 			}
+			validBufferIndexBit ++;
 		}
 
 		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
@@ -146,7 +151,6 @@ ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess * currentPoo
 void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
 	validityMask[validBufferIndex] =
 			bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
-	validBufferIndexBit ++;
 	if(validBufferIndexBit == 8) {
 		validBufferIndex ++;
 		validBufferIndexBit = 1;
@@ -159,6 +163,6 @@ uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position, bool valu
 		return byte;
 	}
 	uint8_t shiftNumber = position + (6 - 2 * (position - 1));
-	byte = (byte | value) <<  shiftNumber;
+	byte |= 1UL << shiftNumber;
 	return byte;
 }

From 54eeb71f02d1c4c4e49f25e25ed0821a7325b093 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 17 Feb 2020 21:20:51 +0100
Subject: [PATCH 0105/1774] bugfix: added implementation

---
 thermal/AcceptsThermalMessagesIF.h | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/thermal/AcceptsThermalMessagesIF.h b/thermal/AcceptsThermalMessagesIF.h
index e95faaaf2..28c62af6a 100644
--- a/thermal/AcceptsThermalMessagesIF.h
+++ b/thermal/AcceptsThermalMessagesIF.h
@@ -10,7 +10,11 @@
 
 class AcceptsThermalMessagesIF {
 public:
-	virtual ~AcceptsThermalMessagesIF();
+
+	/**
+	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~AcceptsThermalMessagesIF() { }
 
 	virtual MessageQueueId_t getReceptionQueue() const = 0;
 };

From 7a426acece7e6fb6135f48b62f1431c894c8e711 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 21 Feb 2020 16:08:43 +0100
Subject: [PATCH 0106/1774] therm sensor doc correction

---
 thermal/TemperatureSensor.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 00f77b242..b4172670e 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -25,8 +25,7 @@ public:
 	 * This structure contains parameters required for range checking
 	 * and the conversion from the input value to the output temperature.
 	 * a, b and c can be any parameters required to calculate the output
-	 * temperature from the input value, for example parameters for the
-	 * Callendar-Van-Dusen equation(see datasheet of used sensor / ADC)
+	 * temperature from the input value, depending on the formula used.
 	 *
 	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
 	 *
@@ -56,7 +55,7 @@ public:
 	};
 
 	/**
-	 * Constructor to check against raw input values
+	 * Instantiate Temperature Sensor Object.
 	 * @param setObjectid objectId of the sensor object
 	 * @param inputValue Input value which is converted to a temperature
 	 * @param poolVariable Pool Variable to store the temperature value

From bfc7a768ce73b1db2a535d7919f24cc1b3244736 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Feb 2020 12:54:28 +0100
Subject: [PATCH 0107/1774] message queue adaptions for calls from ISR

functions moved to top
binary sempahore file init
mutex return values
---
 ipc/MessageQueueIF.h                      |  6 +-
 ipc/MessageQueueSenderIF.h                |  4 +-
 osal/Endiness.h                           |  4 +
 osal/FreeRTOS/BinarySemaphore.cpp         |  9 +++
 osal/FreeRTOS/BinarySempahore.h           | 14 ++++
 osal/FreeRTOS/MessageQueue.cpp            | 90 +++++++++++++++--------
 osal/FreeRTOS/MessageQueue.h              | 90 +++++++++++++++++------
 osal/FreeRTOS/Mutex.cpp                   | 13 ++--
 osal/FreeRTOS/Mutex.h                     |  6 +-
 serviceinterface/ServiceInterfaceBuffer.h |  2 +-
 10 files changed, 171 insertions(+), 67 deletions(-)
 create mode 100644 osal/FreeRTOS/BinarySemaphore.cpp
 create mode 100644 osal/FreeRTOS/BinarySempahore.h

diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 18e2d99ab..ee2479bfd 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -3,12 +3,16 @@
 
 // COULDDO: We could support blocking calls
 
+/**
+ * @defgroup message_queue Message Queue
+ * @brief Message Queue related software components
+ */
+
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 class MessageQueueIF {
 public:
-
 	static const MessageQueueId_t NO_QUEUE = MessageQueueSenderIF::NO_QUEUE; //!< Ugly hack.
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 9e7e11c03..6eb7733d1 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -26,8 +26,8 @@ public:
 	 * Must be implemented by a subclass.
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom =
-					MessageQueueSenderIF::NO_QUEUE, bool ignoreFault=false);
+			MessageQueueMessage* message, MessageQueueId_t sentFrom = MessageQueueSenderIF::NO_QUEUE,
+			bool ignoreFault=false);
 private:
 	MessageQueueSenderIF() {}
 };
diff --git a/osal/Endiness.h b/osal/Endiness.h
index 65cc0a10f..55d0aeb33 100644
--- a/osal/Endiness.h
+++ b/osal/Endiness.h
@@ -1,6 +1,10 @@
 #ifndef FRAMEWORK_OSAL_ENDINESS_H_
 #define FRAMEWORK_OSAL_ENDINESS_H_
 
+/**
+ * @defgroup osal Operating System Abstraction Layer
+ * @brief Provides clean interfaces to use OS functionalities
+ */
 
 /*
  * BSD-style endian declaration
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
new file mode 100644
index 000000000..0422f105e
--- /dev/null
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -0,0 +1,9 @@
+/**
+ * @file BinarySemaphore.cpp
+ *
+ * @date 25.02.2020
+ */
+
+
+
+
diff --git a/osal/FreeRTOS/BinarySempahore.h b/osal/FreeRTOS/BinarySempahore.h
new file mode 100644
index 000000000..ab32d7b76
--- /dev/null
+++ b/osal/FreeRTOS/BinarySempahore.h
@@ -0,0 +1,14 @@
+/**
+ * @file BinarySempahore.h
+ *
+ * @date 25.02.2020
+ */
+
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+
+
+
+
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 887df3926..883cf2614 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -1,11 +1,13 @@
 #include "MessageQueue.h"
+#include "task.h"
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 // TODO I guess we should have a way of checking if we are in an ISR and then use the "fromISR" versions of all calls
-
+// As a first step towards this, introduces system context variable which needs to be switched manually
+// Haven't found function to find system context.
 MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-defaultDestination(0),lastPartner(0)  {
+defaultDestination(0),lastPartner(0), callContext(SystemContext::task_context)  {
 	handle = xQueueCreate(message_depth, max_message_size);
 	if (handle == NULL) {
 		error << "MessageQueue creation failed" << std::endl;
@@ -18,6 +20,10 @@ MessageQueue::~MessageQueue() {
 	}
 }
 
+void MessageQueue::switchSystemContext(SystemContext callContext) {
+	this->callContext = callContext;
+}
+
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
@@ -27,6 +33,11 @@ ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
+}
+
 ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	if (this->lastPartner != 0) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
@@ -35,6 +46,52 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	}
 }
 
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault, callContext);
+}
+
+ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+		MessageQueueMessage *message, MessageQueueId_t sentFrom,
+		bool ignoreFault, SystemContext callContext) {
+	message->setSender(sentFrom);
+	BaseType_t result;
+	if(callContext == SystemContext::task_context) {
+		result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),
+				reinterpret_cast<const void*>(message->getBuffer()), 0);
+	}
+	else {
+		BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+		result = xQueueSendFromISR(reinterpret_cast<void*>(sendTo),
+				reinterpret_cast<const void*>(message->getBuffer()), &xHigherPriorityTaskWoken);
+		if(xHigherPriorityTaskWoken == pdTRUE) {
+			requestContextSwitch(callContext);
+		}
+	}
+	return handleSendResult(result, ignoreFault);
+}
+
+void MessageQueue::requestContextSwitch(SystemContext callContext) {
+	if(callContext == SystemContext::isr_context) {
+		portYIELD_FROM_ISR();
+	}
+}
+
+ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
+	if (result != pdPASS) {
+		if (!ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != NULL) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		return MessageQueueIF::FULL;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
@@ -73,17 +130,6 @@ void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
 	this->defaultDestination = defaultDestination;
 }
 
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
-}
-
 MessageQueueId_t MessageQueue::getDefaultDestination() const {
 	return defaultDestination;
 }
@@ -92,23 +138,5 @@ bool MessageQueue::isDefaultDestinationSet() const {
 	return 0;
 }
 
-ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessage *message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	message->setSender(sentFrom);
 
-	BaseType_t result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),reinterpret_cast<const void*>(message->getBuffer()), 0);
-	if (result != pdPASS) {
-		if (!ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-					objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != NULL) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		return MessageQueueIF::FULL;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
 
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 32f41b44d..9e2d7790e 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -6,7 +6,8 @@
 #include <framework/ipc/MessageQueueMessage.h>
 
 #include <FreeRTOS.h>
-#include <queue.h>
+#include "queue.h"
+#include "portmacro.h"
 
 //TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution
 // https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
@@ -21,11 +22,17 @@
  *				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.
- *	\ingroup message_queue
+ *
+ *				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;
@@ -43,11 +50,30 @@ public:
 	 * 							This should be left default.
 	 */
 	MessageQueue( size_t message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+
 	/**
 	 * @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();
+
+	/*!
+	 * Used by calling function to tell the callbacks 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 from within an ISR and task.
+	 */
+	typedef enum _SystemContext {
+		task_context = 0x00,//!< task_context
+		isr_context = 0xFF  //!< isr_context
+	} SystemContext;
+
+	/**
+	 * This function is used to specify whether a message queue operation is called
+	 * from within an ISR or a task. FreeRTOS offers different functions for this task.
+	 * @param callContext
+	 */
+	void switchSystemContext(SystemContext callContext);
+
 	/**
 	 * @brief	This operation sends a message to the given destination.
 	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
@@ -74,6 +100,29 @@ public:
 	 */
 	ReturnValue_t reply( MessageQueueMessage* message );
 
+	/**
+	 * \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, MessageQueueMessage* message,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+
+	/**
+	 * \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( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+
 	/**
 	 * @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
@@ -107,26 +156,7 @@ public:
 	 * @brief	This method returns the message queue id of this class's message queue.
 	 */
 	MessageQueueId_t getId() const;
-	/**
-	 * \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, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \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( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+
 	/**
 	 * \brief	This method is a simple setter for the default destination.
 	 */
@@ -148,12 +178,26 @@ protected:
 	 * \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
 	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,bool ignoreFault=false);
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false, SystemContext callContex = SystemContext::task_context);
+
+	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
+	/**
+	 * 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(SystemContext callContext);
 private:
 	QueueHandle_t handle;
 	MessageQueueId_t defaultDestination;
 	MessageQueueId_t lastPartner;
+	SystemContext callContext; //!< Stores the current system context
 };
 
 #endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 7c5110915..456506ea4 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -6,7 +6,9 @@ const uint32_t MutexIF::NO_TIMEOUT = 0;
 
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
-	//TODO print error
+	if(handle == NULL) {
+		error << "Mutex creation failure" << std::endl;
+	}
 }
 
 Mutex::~Mutex() {
@@ -18,8 +20,7 @@ Mutex::~Mutex() {
 
 ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 	if (handle == 0) {
-		//TODO Does not exist
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return MutexIF::MUTEX_NOT_FOUND;
 	}
 	TickType_t timeout = portMAX_DELAY;
 	if (timeoutMs != NO_TIMEOUT) {
@@ -30,8 +31,7 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		//TODO could not be acquired/timeout
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return MutexIF::MUTEX_TIMEOUT;
 	}
 }
 
@@ -44,7 +44,6 @@ ReturnValue_t Mutex::unlockMutex() {
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		//TODO is not owner
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
 	}
 }
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 91f295853..471b1113e 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -7,8 +7,10 @@
 #include <FreeRTOS.h>
 #include "semphr.h"
 
-
-
+/**
+ *
+ * @ingroup osal
+ */
 class Mutex : public MutexIF {
 public:
 	Mutex();
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 9a5f4ef8e..b42c8a197 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ private:
 	typedef std::char_traits<char> Traits;
 
 	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 255;
+	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
 
 	// In this function, the characters are parsed.

From 083cc7c50ac017a12061e66d6d937a82b2908c92 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Feb 2020 17:04:21 +0100
Subject: [PATCH 0108/1774] sempahore wrapper extended

---
 ipc/MutexIF.h                     |  7 +++
 osal/FreeRTOS/BinarySemaphore.cpp | 86 ++++++++++++++++++++++++++++
 osal/FreeRTOS/BinarySemaphore.h   | 94 +++++++++++++++++++++++++++++++
 osal/FreeRTOS/BinarySempahore.h   | 14 -----
 osal/FreeRTOS/MessageQueue.cpp    | 13 +++--
 osal/FreeRTOS/MessageQueue.h      |  1 +
 osal/FreeRTOS/Mutex.cpp           |  3 +-
 osal/FreeRTOS/Mutex.h             | 10 +++-
 returnvalues/FwClassIds.h         |  1 +
 9 files changed, 204 insertions(+), 25 deletions(-)
 create mode 100644 osal/FreeRTOS/BinarySemaphore.h
 delete mode 100644 osal/FreeRTOS/BinarySempahore.h

diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 35786d6a3..a4aff1cd8 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -3,6 +3,13 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
+/**
+ * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
+ *
+ * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
+ * @ingroup osal
+ * @ingroup interface
+ */
 class MutexIF {
 public:
 	static const uint32_t NO_TIMEOUT; //!< Needs to be defined in implementation.
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 0422f105e..dd73c5b0f 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -3,7 +3,93 @@
  *
  * @date 25.02.2020
  */
+#include <framework/osal/FreeRTOS/BinarySemaphore.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "portmacro.h"
+#include "task.h"
 
+BinarySemaphore::BinarySemaphore() {
+	vSemaphoreCreateBinary(handle);
+	if(handle == NULL) {
+		error << "Binary semaphore creation failure" << std::endl;
+	}
+}
 
+BinarySemaphore::~BinarySemaphore() {
+	vSemaphoreDelete(handle);
+}
 
+ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+	if(handle == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	TickType_t timeout = portMAX_DELAY;
+	if(timeoutMs != 0) {
+		timeout = pdMS_TO_TICKS(timeoutMs);
+	}
 
+	BaseType_t returncode = xSemaphoreTake(handle, timeout);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_FOUND;
+	}
+}
+
+ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks) {
+	if(handle == NULL) {
+		return SEMAPHORE_NOT_FOUND;
+	}
+
+	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
+	if (handle == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	BaseType_t returncode = xSemaphoreGive(handle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
+
+SemaphoreHandle_t BinarySemaphore::getSemaphore() {
+	return handle;
+}
+
+ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+	if (semaphore == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	BaseType_t returncode = xSemaphoreGive(semaphore);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+		BaseType_t * higherPriorityTaskWoken) {
+	if (semaphore == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);
+	if (returncode == pdPASS) {
+		if(*higherPriorityTaskWoken == pdPASS) {
+			// Request context switch
+			portYIELD_FROM_ISR();
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
new file mode 100644
index 000000000..afc01adfe
--- /dev/null
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -0,0 +1,94 @@
+/**
+ * @file BinarySempahore.h
+ *
+ * @date 25.02.2020
+ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <FreeRTOS.h>
+#include "semphr.h"
+
+/**
+ * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
+ * @details
+ * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
+ * @ingroup osal
+ */
+class BinarySemaphore: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	/** Semaphore object not found */
+	static const ReturnValue_t SEMAPHORE_NOT_FOUND = MAKE_RETURN_CODE(1);
+	/** Semaphore timeout */
+	static const ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(2);
+	/** The current semaphore can not be given, because it is not owned */
+	static const ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(3);
+
+	/**
+	 * Create a binary semaphore
+	 */
+	BinarySemaphore();
+
+	/**
+	 * Delete the binary semaphore to prevent a memory leak
+	 */
+	~BinarySemaphore();
+
+	/**
+	 * 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 RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs);
+
+	/**
+	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return -@c RETURN_OK on success
+	 *         -@c RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks);
+
+	/**
+	 * Give back the binary semaphore
+	 * @return -@c RETURN_OK on success
+	 *         -@c RETURN_FAILED on failure
+	 */
+	ReturnValue_t giveBinarySemaphore();
+
+	/**
+	 * Get Handle to the semaphore.
+	 * @return
+	 */
+	SemaphoreHandle_t getSemaphore();
+private:
+	SemaphoreHandle_t handle;
+};
+
+/**
+ * Wrapper function to give back semaphore from handle
+ * @param semaphore
+ * @return -@c RETURN_OK on success
+ *         -@c RETURN_FAILED on failure
+ */
+ReturnValue_t giveBinarySemaphore(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
+ * @return -@c RETURN_OK on success
+ *         -@c RETURN_FAILED on failure
+ */
+ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+			BaseType_t * higherPriorityTaskWoken);
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/BinarySempahore.h b/osal/FreeRTOS/BinarySempahore.h
deleted file mode 100644
index ab32d7b76..000000000
--- a/osal/FreeRTOS/BinarySempahore.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/**
- * @file BinarySempahore.h
- *
- * @date 25.02.2020
- */
-
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
-
-
-
-
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 883cf2614..fdca80c7c 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -1,5 +1,4 @@
 #include "MessageQueue.h"
-#include "task.h"
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
@@ -24,6 +23,12 @@ void MessageQueue::switchSystemContext(SystemContext callContext) {
 	this->callContext = callContext;
 }
 
+void MessageQueue::requestContextSwitch(SystemContext callContext) {
+	if(callContext == SystemContext::isr_context) {
+		portYIELD_FROM_ISR();
+	}
+}
+
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
@@ -72,11 +77,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	return handleSendResult(result, ignoreFault);
 }
 
-void MessageQueue::requestContextSwitch(SystemContext callContext) {
-	if(callContext == SystemContext::isr_context) {
-		portYIELD_FROM_ISR();
-	}
-}
+
 
 ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
 	if (result != pdPASS) {
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 9e2d7790e..cdb2a7983 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -8,6 +8,7 @@
 #include <FreeRTOS.h>
 #include "queue.h"
 #include "portmacro.h"
+#include "task.h"
 
 //TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution
 // https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 456506ea4..616ef7b85 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -37,8 +37,7 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 
 ReturnValue_t Mutex::unlockMutex() {
 	if (handle == 0) {
-		//TODO Does not exist
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return MutexIF::MUTEX_NOT_FOUND;
 	}
 	BaseType_t returncode = xSemaphoreGive(handle);
 	if (returncode == pdPASS) {
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 471b1113e..2703df4eb 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
+#ifndef FRAMEWORK_FREERTOS_MUTEX_H_
+#define FRAMEWORK_FREERTOS_MUTEX_H_
 
 #include <framework/ipc/MutexIF.h>
 
@@ -8,7 +8,11 @@
 #include "semphr.h"
 
 /**
+ * @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 {
@@ -21,4 +25,4 @@ private:
 	SemaphoreHandle_t handle;
 };
 
-#endif /* OS_RTEMS_MUTEX_H_ */
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index beef04754..120d8b8c9 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -60,6 +60,7 @@ enum {
 	SGP4PROPAGATOR_CLASS, //SGP4 53
 	MUTEX_IF, //MUX 54
 	MESSAGE_QUEUE_IF,//MQI 55
+	SEMAPHORE_IF, //SPH 56
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From abccd81fdfddb1fc065af32bf6c603c4c3722430 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 26 Feb 2020 16:55:35 +0100
Subject: [PATCH 0109/1774] new file for freeRTOS task management functions

---
 osal/FreeRTOS/FixedTimeslotTask.cpp |  1 -
 osal/FreeRTOS/FixedTimeslotTask.h   |  1 +
 osal/FreeRTOS/MessageQueue.cpp      |  6 -----
 osal/FreeRTOS/MessageQueue.h        | 22 +++---------------
 osal/FreeRTOS/PeriodicTask.h        |  6 ++---
 osal/FreeRTOS/TaskManagement.cpp    | 24 ++++++++++++++++++++
 osal/FreeRTOS/TaskManagement.h      | 35 +++++++++++++++++++++++++++++
 7 files changed, 66 insertions(+), 29 deletions(-)
 create mode 100644 osal/FreeRTOS/TaskManagement.cpp
 create mode 100644 osal/FreeRTOS/TaskManagement.h

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 413d7596b..a2c2e5c68 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -114,4 +114,3 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	vTaskDelay(pdMS_TO_TICKS(ms));
 	return HasReturnvaluesIF::RETURN_OK;
 }
-
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index bed130511..1ab8724f6 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -51,6 +51,7 @@ public:
 	ReturnValue_t checkSequence() const;
 
 	ReturnValue_t sleepFor(uint32_t ms);
+
 protected:
 	bool started;
 	TaskHandle_t handle;
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index fdca80c7c..92c691ea7 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -23,12 +23,6 @@ void MessageQueue::switchSystemContext(SystemContext callContext) {
 	this->callContext = callContext;
 }
 
-void MessageQueue::requestContextSwitch(SystemContext callContext) {
-	if(callContext == SystemContext::isr_context) {
-		portYIELD_FROM_ISR();
-	}
-}
-
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index cdb2a7983..9406fdefe 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -4,11 +4,11 @@
 #include <framework/internalError/InternalErrorReporterIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MessageQueueMessage.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
 
 #include <FreeRTOS.h>
 #include "queue.h"
-#include "portmacro.h"
-#include "task.h"
+
 
 //TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution
 // https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
@@ -58,16 +58,6 @@ public:
 	 */
 	virtual ~MessageQueue();
 
-	/*!
-	 * Used by calling function to tell the callbacks 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 from within an ISR and task.
-	 */
-	typedef enum _SystemContext {
-		task_context = 0x00,//!< task_context
-		isr_context = 0xFF  //!< isr_context
-	} SystemContext;
-
 	/**
 	 * This function is used to specify whether a message queue operation is called
 	 * from within an ISR or a task. FreeRTOS offers different functions for this task.
@@ -187,13 +177,7 @@ protected:
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
-	/**
-	 * 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(SystemContext callContext);
+
 private:
 	QueueHandle_t handle;
 	MessageQueueId_t defaultDestination;
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index e7ba8dd26..4cbffd5a2 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -1,5 +1,5 @@
-#ifndef MULTIOBJECTTASK_H_
-#define MULTIOBJECTTASK_H_
+#ifndef PERIODICTASK_H_
+#define PERIODICTASK_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/tasks/PeriodicTaskIF.h>
@@ -107,4 +107,4 @@ protected:
 	void taskFunctionality(void);
 };
 
-#endif /* MULTIOBJECTTASK_H_ */
+#endif /* PERIODICTASK_H_ */
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
new file mode 100644
index 000000000..e97817691
--- /dev/null
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -0,0 +1,24 @@
+/**
+ * @file TaskManagement.cpp
+ *
+ * @date 26.02.2020
+ *
+ */
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+#include <FreeRTOS.h>
+#include "portmacro.h"
+#include "task.h"
+
+void requestContextSwitchFromTask() {
+	vTaskDelay(0);
+}
+
+void requestContextSwitch(SystemContext callContext) {
+	if(callContext == SystemContext::isr_context) {
+		// This function depends on the partmacro.h definition for the specific device
+		portYIELD_FROM_ISR();
+	} else {
+		requestContextSwitchFromTask();
+	}
+}
+
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
new file mode 100644
index 000000000..74e2316fc
--- /dev/null
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -0,0 +1,35 @@
+/**
+ * @file TaskManagement.h
+ *
+ * @date 26.02.2020
+ */
+
+#ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+#define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+
+/*!
+ * 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.
+ */
+typedef enum _SystemContext {
+	task_context = 0x00,//!< task_context
+	isr_context = 0xFF  //!< isr_context
+} SystemContext;
+
+/**
+ * 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.
+ */
+void requestContextSwitch(SystemContext callContext);
+
+/**
+ * If task preemption in FreeRTOS is disabled, a context switch
+ * can be requested manually by calling this function.
+ */
+void requestContextSwitch(void);
+
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */

From c93ee5c6cdc0098dbcf41ff3fe4c5511534e6c69 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 27 Feb 2020 19:00:51 +0100
Subject: [PATCH 0110/1774] message queue IF return values

---
 devicehandlers/DeviceCommunicationIF.h | 16 ++++++++--
 ipc/CommandMessage.h                   |  3 ++
 ipc/MessageQueueIF.h                   | 43 ++++++++++++++++----------
 osal/FreeRTOS/MutexFactory.cpp         |  3 +-
 4 files changed, 43 insertions(+), 22 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 06c228f72..546081ba5 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -36,9 +36,7 @@ public:
 	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x06);
 	static const ReturnValue_t CANT_CHANGE_REPLY_LEN = MAKE_RETURN_CODE(0x07);
 
-	virtual ~DeviceCommunicationIF() {
-
-	}
+	virtual ~DeviceCommunicationIF() {}
 
 	virtual ReturnValue_t open(Cookie **cookie, uint32_t address,
 			uint32_t maxReplyLen) = 0;
@@ -93,8 +91,20 @@ public:
 
 	virtual uint32_t getAddress(Cookie *cookie) = 0;
 
+	/**
+	 * Can be used by DeviceHandlerBase getParameter() call to set DeviceComIF parameters
+	 * @param cookie
+	 * @param parameter
+	 * @return
+	 */
 	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter) = 0;
 
+	/**
+	 * Can be used by DeviceHandlerBase getParameter() call to set DeviceComIF parameters
+	 * @param cookie
+	 * @param parameter
+	 * @return
+	 */
 	virtual uint32_t getParameter(Cookie *cookie) = 0;
 
 };
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 2d966063a..21c393e59 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -17,6 +17,9 @@
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef ReturnValue_t Command_t;
 
+/**
+ * @brief Used to pass command messages between tasks
+ */
 class CommandMessage : public MessageQueueMessage {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index ee2479bfd..47da694cd 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -58,6 +58,8 @@ public:
 	 * 			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.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::EMPTY if queue is empty
 	 */
 	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) = 0;
 	/**
@@ -76,33 +78,38 @@ public:
 	virtual MessageQueueId_t getId() const = 0;
 
 	/**
-	 * \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
+	 * @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.
+	 * @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 (if implemented).
+	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full (if implemented).
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
 	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
+
 	/**
-		 * @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.
-		 */
+	 * @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.
+	 */
 	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo, MessageQueueMessage* message, bool ignoreFault = false ) = 0;
 
 	/**
-	 * \brief	The sendToDefaultFrom 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.
+	 * @brief	The sendToDefaultFrom 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.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
 	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
 	/**
@@ -110,6 +117,8 @@ public:
 	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
 	 * 			Implementation class and adds its queue id as "sentFrom" information.
 	 * @param message	A pointer to a previously created message, which is sent.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
 	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message )  = 0;
 	/**
diff --git a/osal/FreeRTOS/MutexFactory.cpp b/osal/FreeRTOS/MutexFactory.cpp
index cadb54fbd..b3e3f02c9 100644
--- a/osal/FreeRTOS/MutexFactory.cpp
+++ b/osal/FreeRTOS/MutexFactory.cpp
@@ -1,6 +1,5 @@
 #include <framework/ipc/MutexFactory.h>
-
-#include "../FreeRTOS/Mutex.h"
+#include <framework/osal/FreeRTOS/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();

From fa38a3760448e28109b6a73bb46e3ee50bb583a8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Feb 2020 22:55:25 +0100
Subject: [PATCH 0111/1774] all context switches calls to TaskManagement.h now

---
 osal/FreeRTOS/BinarySemaphore.cpp |  8 ++++---
 osal/FreeRTOS/BinarySemaphore.h   | 38 +++++++++++++++++--------------
 osal/FreeRTOS/MessageQueue.cpp    |  2 +-
 osal/FreeRTOS/MessageQueue.h      |  5 ----
 osal/FreeRTOS/TaskManagement.cpp  |  6 +++--
 osal/FreeRTOS/TaskManagement.h    | 32 ++++++++++++++------------
 6 files changed, 48 insertions(+), 43 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index dd73c5b0f..09e71f6d5 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -4,6 +4,8 @@
  * @date 25.02.2020
  */
 #include <framework/osal/FreeRTOS/BinarySemaphore.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include "portmacro.h"
 #include "task.h"
@@ -65,7 +67,7 @@ SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 	return handle;
 }
 
-ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	if (semaphore == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -77,7 +79,7 @@ ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	}
 }
 
-ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
@@ -86,7 +88,7 @@ ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 	if (returncode == pdPASS) {
 		if(*higherPriorityTaskWoken == pdPASS) {
 			// Request context switch
-			portYIELD_FROM_ISR();
+			TaskManagement::requestContextSwitch(SystemContext::isr_context);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index afc01adfe..7ead0d2fe 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -68,27 +68,31 @@ public:
 	 * @return
 	 */
 	SemaphoreHandle_t getSemaphore();
+
+	 /**
+	 * Wrapper function to give back semaphore from handle
+	 * @param semaphore
+	 * @return -@c RETURN_OK on success
+	 *         -@c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphore(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
+	 * @return -@c RETURN_OK on success
+	 *         -@c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+				BaseType_t * higherPriorityTaskWoken);
 private:
 	SemaphoreHandle_t handle;
 };
 
-/**
- * Wrapper function to give back semaphore from handle
- * @param semaphore
- * @return -@c RETURN_OK on success
- *         -@c RETURN_FAILED on failure
- */
-ReturnValue_t giveBinarySemaphore(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
- * @return -@c RETURN_OK on success
- *         -@c RETURN_FAILED on failure
- */
-ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
-			BaseType_t * higherPriorityTaskWoken);
+
+
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 92c691ea7..f23d9d9d1 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -65,7 +65,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		result = xQueueSendFromISR(reinterpret_cast<void*>(sendTo),
 				reinterpret_cast<const void*>(message->getBuffer()), &xHigherPriorityTaskWoken);
 		if(xHigherPriorityTaskWoken == pdTRUE) {
-			requestContextSwitch(callContext);
+			TaskManagement::requestContextSwitch(callContext);
 		}
 	}
 	return handleSendResult(result, ignoreFault);
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 9406fdefe..d8e149611 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -58,11 +58,6 @@ public:
 	 */
 	virtual ~MessageQueue();
 
-	/**
-	 * This function is used to specify whether a message queue operation is called
-	 * from within an ISR or a task. FreeRTOS offers different functions for this task.
-	 * @param callContext
-	 */
 	void switchSystemContext(SystemContext callContext);
 
 	/**
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index e97817691..573a7d7d9 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -9,11 +9,11 @@
 #include "portmacro.h"
 #include "task.h"
 
-void requestContextSwitchFromTask() {
+void TaskManagement::requestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
 
-void requestContextSwitch(SystemContext callContext) {
+void TaskManagement::requestContextSwitch(SystemContext callContext = SystemContext::task_context) {
 	if(callContext == SystemContext::isr_context) {
 		// This function depends on the partmacro.h definition for the specific device
 		portYIELD_FROM_ISR();
@@ -22,3 +22,5 @@ void requestContextSwitch(SystemContext callContext) {
 	}
 }
 
+
+
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 74e2316fc..381e06f9a 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -12,24 +12,26 @@
  * 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.
  */
-typedef enum _SystemContext {
+enum SystemContext {
 	task_context = 0x00,//!< task_context
 	isr_context = 0xFF  //!< isr_context
-} SystemContext;
+};
 
-/**
- * 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.
- */
-void requestContextSwitch(SystemContext callContext);
-
-/**
- * If task preemption in FreeRTOS is disabled, a context switch
- * can be requested manually by calling this function.
- */
-void requestContextSwitch(void);
+class TaskManagement {
+public:
+	/**
+	 * 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(SystemContext callContext);
 
+	/**
+	 * If task preemption in FreeRTOS is disabled, a context switch
+	 * can be requested manually by calling this function.
+	 */
+	static void requestContextSwitchFromTask(void);
+};
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */

From 6d6c78b255407dc08979dbfbf927b9e4dd54db44 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 29 Feb 2020 01:21:36 +0100
Subject: [PATCH 0112/1774] task management doc

---
 osal/FreeRTOS/TaskManagement.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index e97817691..f94c0fde6 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -9,6 +9,12 @@
 #include "portmacro.h"
 #include "task.h"
 
+/**
+ * TODO: This stuff is hardware and architecture and mission dependant...
+ * 	     Some FreeRTOS implementations might be able to determine their own task context for example.
+ * 	     If not ISRs are used, or task preemption is enabled, some of this stuff might
+ * 	     not be necessary anyway. Maybe there is a better solution?
+ */
 void requestContextSwitchFromTask() {
 	vTaskDelay(0);
 }

From d0e8eb386ce45b3aa99f8d1413b2c05b1db079d7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 2 Mar 2020 01:00:17 +0100
Subject: [PATCH 0113/1774] renamed system context to call context

to avoid conflicts with ISIS library, I don't want to fiddle with
it if we don't have source code
---
 devicehandlers/CommunicationMessage.cpp |  9 +++
 devicehandlers/CommunicationMessage.h   | 82 +++++++++++++++++++++++++
 osal/FreeRTOS/BinarySemaphore.cpp       |  2 +-
 osal/FreeRTOS/MessageQueue.cpp          |  8 +--
 osal/FreeRTOS/MessageQueue.h            |  6 +-
 osal/FreeRTOS/TaskManagement.cpp        |  4 +-
 osal/FreeRTOS/TaskManagement.h          |  9 +--
 7 files changed, 106 insertions(+), 14 deletions(-)
 create mode 100644 devicehandlers/CommunicationMessage.cpp
 create mode 100644 devicehandlers/CommunicationMessage.h

diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
new file mode 100644
index 000000000..6dddc5be5
--- /dev/null
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -0,0 +1,9 @@
+/**
+ * @file CommunicationMessage.cpp
+ *
+ * @date 28.02.2020
+ */
+
+
+
+
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
new file mode 100644
index 000000000..70c1052aa
--- /dev/null
+++ b/devicehandlers/CommunicationMessage.h
@@ -0,0 +1,82 @@
+/**
+ * @file CommunicationMessage.h
+ *
+ * @date 28.02.2020
+ */
+
+#ifndef FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
+#define FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
+#include <framework/ipc/MessageQueueMessage.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+
+/**
+ * @brief Used to pass communication information between tasks
+ *
+ * @details
+ * Can be used to pass information like data pointers and
+ * data sizes between communication tasks
+ * like the Device Handler Comm Interfaces and Polling Tasks.
+ *
+ * Can also be used to exchange actual data if its not too large
+ * (e.g. Sensor values).
+ *
+ */
+class CommunicationMessage: public MessageQueueMessage {
+public:
+	enum communicationStatus {
+		SEND_DATA,
+		PROCESS_DATA,
+		FAULTY,
+	};
+
+	//Add other messageIDs here if necessary.
+	static const uint8_t COMMUNICATION_MESSAGE_SIZE = HEADER_SIZE + 4 * sizeof(uint32_t);
+
+	CommunicationMessage();
+
+	/**
+	 * Send requests with pointer to the data to be sent and send data length
+	 * @param address Target Address
+	 * @param sendData
+	 * @param length
+	 */
+	void setSendRequest(uint32_t address, const uint8_t * sendData, uint32_t length);
+
+	/**
+	 * Data message with data stored in IPC store
+	 * @param address
+	 * @param length
+	 * @param storeId
+	 */
+	void setDataMessage(uint32_t address, uint32_t length, store_address_t * storeId);
+
+	/**
+	 * Data message with data stored in actual message.
+	 * 4 byte datafield is intialized with 0.
+	 * Set data with specific setter functions.
+	 */
+	void setDataMessage(uint32_t address, uint32_t length);
+
+private:
+	void setCommunicationStatus(communicationStatus status);
+	void setAddress(uint32_t address);
+	void setSendData(const uint8_t * sendData);
+	void setDataLen(uint32_t length);
+
+	/** For low size data, maximum of 4 bytes can be sent */
+	void setDataByte1(uint8_t byte1);
+	void setDataByte2(uint8_t byte2);
+	void setDataByte3(uint8_t byte3);
+	void setDataByte4(uint8_t byte4);
+
+	void setDataUINT16_1(uint16_t data1);
+	void setDataUINT16_2(uint16_t data2);
+
+	void setData(uint32_t data);
+
+	virtual ~CommunicationMessage();
+};
+
+
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 09e71f6d5..c3d573870 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -88,7 +88,7 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 	if (returncode == pdPASS) {
 		if(*higherPriorityTaskWoken == pdPASS) {
 			// Request context switch
-			TaskManagement::requestContextSwitch(SystemContext::isr_context);
+			TaskManagement::requestContextSwitch(CallContext::isr);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index f23d9d9d1..cc38e77d3 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -6,7 +6,7 @@
 // As a first step towards this, introduces system context variable which needs to be switched manually
 // Haven't found function to find system context.
 MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-defaultDestination(0),lastPartner(0), callContext(SystemContext::task_context)  {
+defaultDestination(0),lastPartner(0), callContext(CallContext::task)  {
 	handle = xQueueCreate(message_depth, max_message_size);
 	if (handle == NULL) {
 		error << "MessageQueue creation failed" << std::endl;
@@ -19,7 +19,7 @@ MessageQueue::~MessageQueue() {
 	}
 }
 
-void MessageQueue::switchSystemContext(SystemContext callContext) {
+void MessageQueue::switchSystemContext(CallContext callContext) {
 	this->callContext = callContext;
 }
 
@@ -53,10 +53,10 @@ ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		MessageQueueMessage *message, MessageQueueId_t sentFrom,
-		bool ignoreFault, SystemContext callContext) {
+		bool ignoreFault, CallContext callContext) {
 	message->setSender(sentFrom);
 	BaseType_t result;
-	if(callContext == SystemContext::task_context) {
+	if(callContext == CallContext::task) {
 		result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),
 				reinterpret_cast<const void*>(message->getBuffer()), 0);
 	}
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index d8e149611..8edfed10c 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -58,7 +58,7 @@ public:
 	 */
 	virtual ~MessageQueue();
 
-	void switchSystemContext(SystemContext callContext);
+	void switchSystemContext(CallContext callContext);
 
 	/**
 	 * @brief	This operation sends a message to the given destination.
@@ -168,7 +168,7 @@ protected:
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false, SystemContext callContex = SystemContext::task_context);
+			bool ignoreFault=false, CallContext callContex = CallContext::task);
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
@@ -177,7 +177,7 @@ private:
 	QueueHandle_t handle;
 	MessageQueueId_t defaultDestination;
 	MessageQueueId_t lastPartner;
-	SystemContext callContext; //!< Stores the current system context
+	CallContext callContext; //!< Stores the current system context
 };
 
 #endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 573a7d7d9..40a0f3955 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -13,8 +13,8 @@ void TaskManagement::requestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
 
-void TaskManagement::requestContextSwitch(SystemContext callContext = SystemContext::task_context) {
-	if(callContext == SystemContext::isr_context) {
+void TaskManagement::requestContextSwitch(CallContext callContext = CallContext::task) {
+	if(callContext == CallContext::isr) {
 		// This function depends on the partmacro.h definition for the specific device
 		portYIELD_FROM_ISR();
 	} else {
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 381e06f9a..fd2bfc0b1 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -12,9 +12,10 @@
  * 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 SystemContext {
-	task_context = 0x00,//!< task_context
-	isr_context = 0xFF  //!< isr_context
+
+enum CallContext {
+	task = 0x00,//!< task_context
+	isr = 0xFF  //!< isr_context
 };
 
 class TaskManagement {
@@ -25,7 +26,7 @@ public:
 	 * 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(SystemContext callContext);
+	static void requestContextSwitch(CallContext callContext);
 
 	/**
 	 * If task preemption in FreeRTOS is disabled, a context switch

From dd4a5a45e3a25ce5bbbedfdd37a407273b62ac54 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 3 Mar 2020 21:20:08 +0100
Subject: [PATCH 0114/1774] communication message extended

---
 devicehandlers/CommunicationMessage.cpp |  95 +++++++++++++++++++++
 devicehandlers/CommunicationMessage.h   | 105 +++++++++++++++++++-----
 devicehandlers/DeviceCommunicationIF.h  |   3 +-
 devicehandlers/FixedSequenceSlot.h      |   2 +-
 4 files changed, 183 insertions(+), 22 deletions(-)

diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index 6dddc5be5..8f9d1eb6c 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -4,6 +4,101 @@
  * @date 28.02.2020
  */
 
+#include <framework/devicehandlers/CommunicationMessage.h>
+#include <cstring>
+
+CommunicationMessage::CommunicationMessage(): uninitialized(true) {
+}
+
+void CommunicationMessage::setSendRequestFromPointer(uint32_t address,
+		uint32_t dataLen, const uint8_t * data) {
+	setMessageType(SEND_DATA_FROM_POINTER);
+	setAddress(address);
+	setDataLen(dataLen);
+	setDataPointer(data);
+}
+
+void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_address_t storeId) {
+	setMessageType(SEND_DATA_FROM_IPC_STORE);
+	setAddress(address);
+	setStoreId(storeId);
+}
+
+void CommunicationMessage::setSendRequestRaw(uint32_t address) {
+}
+
+void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) {
+	setMessageType(REPLY_DATA_IPC_STORE);
+	setAddress(address);
+	setStoreId(storeId);
+}
+void CommunicationMessage::setDataReplyFromPointer(uint32_t address,
+		uint32_t dataLen, uint8_t *data) {
+}
+
+void CommunicationMessage::setDataReplyRaw(uint32_t address,
+		uint32_t length, uint16_t receiveBufferPosition) {
+	setMessageType(REPLY_DATA_RAW);
+	setAddress(address);
+	setDataLen(length);
+	if(receiveBufferPosition != 0) {
+		setReceiveBufferPosition(receiveBufferPosition);
+	}
+}
+
+
+
+void CommunicationMessage::setMessageType(messageType status) {
+	uint8_t status_uint8 = status;
+	memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8));
+}
+
+void CommunicationMessage::setAddress(uint32_t address) {
+	memcpy(getData(),&address,sizeof(address));
+}
+
+void CommunicationMessage::setReceiveBufferPosition(uint16_t bufferPosition) {
+	memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t),
+			&bufferPosition, sizeof(bufferPosition));
+}
+
+void CommunicationMessage::setDataPointer(const uint8_t *sendData) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &sendData, sizeof(uint32_t));
+}
+
+void CommunicationMessage::setStoreId(store_address_t storeId) {
+	memcpy(getData() + 2 * sizeof(uint32_t), &storeId, sizeof(store_address_t));
+}
+
+void CommunicationMessage::setDataLen(uint32_t length) {
+	memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length));
+}
+
+void CommunicationMessage::setDataByte1(uint8_t byte1) {
+}
+
+void CommunicationMessage::setDataByte2(uint8_t byte2) {
+}
+
+void CommunicationMessage::setDataByte3(uint8_t byte3) {
+}
+
+void CommunicationMessage::setDataByte4(uint8_t byte4) {
+}
+
+void CommunicationMessage::setDataUINT16_1(uint16_t data1) {
+}
+
+void CommunicationMessage::setDataUINT16_2(uint16_t data2) {
+}
+
+void CommunicationMessage::setData(uint32_t data) {
+}
+
+CommunicationMessage::~CommunicationMessage() {
+}
+
+
 
 
 
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
index 70c1052aa..fe744fd65 100644
--- a/devicehandlers/CommunicationMessage.h
+++ b/devicehandlers/CommunicationMessage.h
@@ -6,6 +6,8 @@
 
 #ifndef FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
 #define FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
+#include <framework/devicehandlers/CommunicationMessage.h>
+
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/storagemanager/StorageManagerIF.h>
 
@@ -23,9 +25,13 @@
  */
 class CommunicationMessage: public MessageQueueMessage {
 public:
-	enum communicationStatus {
-		SEND_DATA,
-		PROCESS_DATA,
+	enum messageType {
+		SEND_DATA_FROM_POINTER,
+		SEND_DATA_FROM_IPC_STORE,
+		SEND_DATA_RAW,
+		REPLY_DATA_FROM_POINTER,
+		REPLY_DATA_IPC_STORE,
+		REPLY_DATA_RAW,
 		FAULTY,
 	};
 
@@ -36,34 +42,60 @@ public:
 
 	/**
 	 * Send requests with pointer to the data to be sent and send data length
-	 * @param address Target Address
-	 * @param sendData
-	 * @param length
+	 * @param address Target Address, first four bytes
+	 * @param dataLen Length of data to send, next four bytes
+	 * @param data Pointer to data to send
+	 *
 	 */
-	void setSendRequest(uint32_t address, const uint8_t * sendData, uint32_t length);
+	void setSendRequestFromPointer(uint32_t address, uint32_t dataLen, const uint8_t * data);
+
+	/**
+	 * Send requests with a store ID, using the IPC store
+	 * @param address Target Address, first four bytes
+	 * @param storeId Store ID in the IPC store
+	 *
+	 */
+	void setSendRequestFromIpcStore(uint32_t address, store_address_t storeId);
+
+	/**
+	 * Send requests with data length and data in message (max. 4 bytes)
+	 * @param address Target Address, first four bytes
+	 * @param dataLen Length of data to send, next four bytes
+	 * @param data Pointer to data to send
+	 *
+	 */
+	void setSendRequestRaw(uint32_t address);
 
 	/**
 	 * Data message with data stored in IPC store
-	 * @param address
+	 * @param address Target Address, first four bytes
 	 * @param length
 	 * @param storeId
 	 */
-	void setDataMessage(uint32_t address, uint32_t length, store_address_t * storeId);
+	void setDataReplyFromIpcStore(uint32_t address, store_address_t storeId);
+
+	/**
+	 * Data reply with data stored in buffer, passing the pointer to
+	 * the buffer and the data size
+	 * @param address Target Address, first four bytes
+	 * @param dataLen Length of data to send, next four bytes
+	 * @param data Pointer to the data
+	 */
+	void setDataReplyFromPointer(uint32_t address, uint32_t dataLen, uint8_t * data);
 
 	/**
 	 * Data message with data stored in actual message.
 	 * 4 byte datafield is intialized with 0.
-	 * Set data with specific setter functions.
+	 * Set data with specific setter functions below.
+	 * Can also be used to supply information at which position the raw data should be stored
+	 * in a receive buffer.
 	 */
-	void setDataMessage(uint32_t address, uint32_t length);
+	void setDataReplyRaw(uint32_t address, uint32_t length, uint16_t receiveBufferPosition = 0);
 
-private:
-	void setCommunicationStatus(communicationStatus status);
-	void setAddress(uint32_t address);
-	void setSendData(const uint8_t * sendData);
-	void setDataLen(uint32_t length);
-
-	/** For low size data, maximum of 4 bytes can be sent */
+	/*
+	 * The following functions can be used to
+	 * set the data field (4 bytes possible);
+	 */
 	void setDataByte1(uint8_t byte1);
 	void setDataByte2(uint8_t byte2);
 	void setDataByte3(uint8_t byte3);
@@ -74,9 +106,42 @@ private:
 
 	void setData(uint32_t data);
 
+private:
+	/**
+	 * Message Type is stored as the fifth byte of the message data
+	 * @param status
+	 */
+	void setMessageType(messageType status);
+
+	/**
+	 * First four bytes of message data
+	 * @param address
+	 */
+	void setAddress(uint32_t address);
+
+	/**
+	 * Stored in Bytes 13-16 of message data
+	 * @param length
+	 */
+	void setDataLen(uint32_t length);
+
+	/**
+	 * Stored in last four bytes (Bytes 17-20) of message data
+	 * @param sendData
+	 */
+	void setDataPointer(const uint8_t * sendData);
+
+	/**
+	 * Buffer Position is stored as the seventh and eigth byte of
+	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now
+	 * @param bufferPosition
+	 */
+	void setReceiveBufferPosition(uint16_t bufferPosition);
+	void setStoreId(store_address_t storeId);
+
 	virtual ~CommunicationMessage();
+
+	bool uninitialized;
 };
 
-
-
 #endif /* FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 546081ba5..e03db26be 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -22,7 +22,8 @@
  *   4. Read received data
  *
  *  To identify different connection over a single interface can return so-called cookies to components.
- *
+ *  The CommunicationMessage message type can be used to extend the functionality of the
+ *  ComIF if a separate polling task is required.
  */
 class DeviceCommunicationIF: public HasReturnvaluesIF {
 public:
diff --git a/devicehandlers/FixedSequenceSlot.h b/devicehandlers/FixedSequenceSlot.h
index 5aff0f4f3..0ed285b38 100644
--- a/devicehandlers/FixedSequenceSlot.h
+++ b/devicehandlers/FixedSequenceSlot.h
@@ -31,7 +31,7 @@ public:
 	 * \brief	This attribute defines when a device handler object is executed.
 	 *
 	 * \details	The pollingTime attribute identifies the time the handler is executed in ms. It must be
-	 * 			smaller than the period length of the polling sequence, what is ensured by automated calculation
+	 * 			smaller than the period length of the polling sequence, which is ensured by automated calculation
 	 * 			from a database.
 	 */
 	uint32_t	pollingTimeMs;

From fb6172fdc51a6e76513437ec74ed733da3847e1f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 4 Mar 2020 00:37:58 +0100
Subject: [PATCH 0115/1774] communication message continued.

Some fixed timeslot task improvements
---
 devicehandlers/CommunicationMessage.cpp | 40 +++++++++++++++-------
 devicehandlers/CommunicationMessage.h   | 44 +++++++++++++++----------
 devicehandlers/DeviceHandlerBase.h      |  7 +++-
 devicehandlers/FixedSlotSequence.h      |  2 +-
 osal/FreeRTOS/FixedTimeslotTask.cpp     |  4 +++
 5 files changed, 65 insertions(+), 32 deletions(-)

diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index 8f9d1eb6c..5c0424879 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -10,6 +10,8 @@
 CommunicationMessage::CommunicationMessage(): uninitialized(true) {
 }
 
+CommunicationMessage::~CommunicationMessage() {}
+
 void CommunicationMessage::setSendRequestFromPointer(uint32_t address,
 		uint32_t dataLen, const uint8_t * data) {
 	setMessageType(SEND_DATA_FROM_POINTER);
@@ -24,7 +26,10 @@ void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_ad
 	setStoreId(storeId);
 }
 
-void CommunicationMessage::setSendRequestRaw(uint32_t address) {
+void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length) {
+	setMessageType(SEND_DATA_RAW);
+	setAddress(address);
+	setDataLen(length);
 }
 
 void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) {
@@ -34,6 +39,10 @@ void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_addr
 }
 void CommunicationMessage::setDataReplyFromPointer(uint32_t address,
 		uint32_t dataLen, uint8_t *data) {
+	setMessageType(REPLY_DATA_FROM_POINTER);
+	setAddress(address);
+	setDataLen(dataLen);
+	setDataPointer(data);
 }
 
 void CommunicationMessage::setDataReplyRaw(uint32_t address,
@@ -46,8 +55,6 @@ void CommunicationMessage::setDataReplyRaw(uint32_t address,
 	}
 }
 
-
-
 void CommunicationMessage::setMessageType(messageType status) {
 	uint8_t status_uint8 = status;
 	memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8));
@@ -62,8 +69,8 @@ void CommunicationMessage::setReceiveBufferPosition(uint16_t bufferPosition) {
 			&bufferPosition, sizeof(bufferPosition));
 }
 
-void CommunicationMessage::setDataPointer(const uint8_t *sendData) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &sendData, sizeof(uint32_t));
+void CommunicationMessage::setDataPointer(const void * data) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(uint32_t));
 }
 
 void CommunicationMessage::setStoreId(store_address_t storeId) {
@@ -74,31 +81,40 @@ void CommunicationMessage::setDataLen(uint32_t length) {
 	memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length));
 }
 
+void CommunicationMessage::setData(uint32_t data) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(data));
+}
+
 void CommunicationMessage::setDataByte1(uint8_t byte1) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &byte1, sizeof(byte1));
 }
 
 void CommunicationMessage::setDataByte2(uint8_t byte2) {
+	memcpy(getData() + 3 * sizeof(uint32_t) + sizeof(uint8_t), &byte2, sizeof(byte2));
 }
 
 void CommunicationMessage::setDataByte3(uint8_t byte3) {
+	memcpy(getData() + 3 * sizeof(uint32_t) + 2* sizeof(uint8_t), &byte3, sizeof(byte3));
 }
 
 void CommunicationMessage::setDataByte4(uint8_t byte4) {
+	memcpy(getData() + 3 * sizeof(uint32_t) + 3* sizeof(uint8_t), &byte4, sizeof(byte4));
 }
 
 void CommunicationMessage::setDataUINT16_1(uint16_t data1) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &data1, sizeof(data1));
 }
 
 void CommunicationMessage::setDataUINT16_2(uint16_t data2) {
+	memcpy(getData() + 3 * sizeof(uint32_t) + sizeof(uint16_t), &data2, sizeof(data2));
 }
 
-void CommunicationMessage::setData(uint32_t data) {
+CommunicationMessage::messageType CommunicationMessage::getMessageType() {
+	messageType messageType;
+	memcpy(&messageType, getData() + sizeof(uint32_t),sizeof(uint8_t));
+	return messageType;
 }
 
-CommunicationMessage::~CommunicationMessage() {
+void CommunicationMessage::clearCommunicationMessage() {
+	messageType messageType = getMessageType();
 }
-
-
-
-
-
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
index fe744fd65..805dd9a88 100644
--- a/devicehandlers/CommunicationMessage.h
+++ b/devicehandlers/CommunicationMessage.h
@@ -39,6 +39,7 @@ public:
 	static const uint8_t COMMUNICATION_MESSAGE_SIZE = HEADER_SIZE + 4 * sizeof(uint32_t);
 
 	CommunicationMessage();
+	virtual ~CommunicationMessage();
 
 	/**
 	 * Send requests with pointer to the data to be sent and send data length
@@ -64,7 +65,7 @@ public:
 	 * @param data Pointer to data to send
 	 *
 	 */
-	void setSendRequestRaw(uint32_t address);
+	void setSendRequestRaw(uint32_t address, uint32_t length);
 
 	/**
 	 * Data message with data stored in IPC store
@@ -92,6 +93,22 @@ public:
 	 */
 	void setDataReplyRaw(uint32_t address, uint32_t length, uint16_t receiveBufferPosition = 0);
 
+	/**
+	 * First four bytes of message data
+	 * @param address
+	 */
+	void setAddress(uint32_t address);
+
+	/**
+	 * Message Type is stored as the fifth byte of the message data
+	 * @param status
+	 */
+	void setMessageType(messageType status);
+	messageType getMessageType();
+
+	void setMessageId(uint8_t messageId);
+	messageType getMessageId();
+
 	/*
 	 * The following functions can be used to
 	 * set the data field (4 bytes possible);
@@ -106,19 +123,6 @@ public:
 
 	void setData(uint32_t data);
 
-private:
-	/**
-	 * Message Type is stored as the fifth byte of the message data
-	 * @param status
-	 */
-	void setMessageType(messageType status);
-
-	/**
-	 * First four bytes of message data
-	 * @param address
-	 */
-	void setAddress(uint32_t address);
-
 	/**
 	 * Stored in Bytes 13-16 of message data
 	 * @param length
@@ -129,19 +133,23 @@ private:
 	 * Stored in last four bytes (Bytes 17-20) of message data
 	 * @param sendData
 	 */
-	void setDataPointer(const uint8_t * sendData);
+	void setDataPointer(const void * data);
 
 	/**
 	 * Buffer Position is stored as the seventh and eigth byte of
-	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now
+	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now.
 	 * @param bufferPosition
 	 */
 	void setReceiveBufferPosition(uint16_t bufferPosition);
 	void setStoreId(store_address_t storeId);
 
-	virtual ~CommunicationMessage();
+	/**
+	 * Clear the message
+	 */
+	void clearCommunicationMessage();
+private:
 
-	bool uninitialized;
+	bool uninitialized; //!< Could be used to warn if data has not been set.
 };
 
 #endif /* FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index f16a4ff96..98808d87e 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -33,6 +33,11 @@ class StorageManagerIF;
  * Contains all devices and the DeviceHandlerBase class.
  */
 
+/**
+ * Physical address type
+ */
+typedef uint32_t address_t;
+
 /**
  * @brief This is the abstract base class for device handlers.
  * @details
@@ -91,7 +96,7 @@ public:
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
-	DeviceHandlerBase(uint32_t logicalAddress, object_id_t setObjectId,
+	DeviceHandlerBase(address_t logicalAddress, object_id_t setObjectId,
 			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 			object_id_t deviceCommunication,
 			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h
index f8fd9a36f..d72de9131 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -104,7 +104,7 @@ protected:
 	 * \brief	This list contains all OPUSPollingSlot objects, defining order and execution time of the
 	 * 			device handler objects.
 	 *
-	 * \details	The slot list is a std:list object that contains all created OPUSPollingSlot instances.
+	 * @details	The slot list is a std:list object that contains all created PollingSlot instances.
 	 * 			They are NOT ordered automatically, so by adding entries, the correct order needs to be ensured.
 	 * 			By iterating through this list the polling sequence is executed. Two entries with identical
 	 * 			polling times are executed immediately one after another.
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index a2c2e5c68..604a10b86 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -58,6 +58,10 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	if (objectManager->get<ExecutableObjectIF>(componentId) != NULL) {
+		if(slotTimeMs == 0) {
+			// FreeRTOS throws errors for zero values
+			slotTimeMs = 1;
+		}
 		pst.addSlot(componentId, slotTimeMs, executionStep, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}

From 43ac0ec04bbaffc1f7a23b478fd747396a3a4ad4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 4 Mar 2020 23:07:54 +0100
Subject: [PATCH 0116/1774] Communication Message continued

---
 devicehandlers/CommunicationMessage.cpp | 129 +++++++++++++++++++-----
 devicehandlers/CommunicationMessage.h   |  76 +++++++++-----
 devicehandlers/DeviceCommunicationIF.h  |   7 +-
 3 files changed, 160 insertions(+), 52 deletions(-)

diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index 5c0424879..028e8a2e1 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -5,6 +5,7 @@
  */
 
 #include <framework/devicehandlers/CommunicationMessage.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <cstring>
 
 CommunicationMessage::CommunicationMessage(): uninitialized(true) {
@@ -23,19 +24,23 @@ void CommunicationMessage::setSendRequestFromPointer(uint32_t address,
 void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_address_t storeId) {
 	setMessageType(SEND_DATA_FROM_IPC_STORE);
 	setAddress(address);
-	setStoreId(storeId);
+	setStoreId(storeId.raw);
 }
 
-void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length) {
+void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length,
+		uint16_t sendBufferPosition) {
 	setMessageType(SEND_DATA_RAW);
 	setAddress(address);
 	setDataLen(length);
+	if(sendBufferPosition != 0) {
+		setBufferPosition(sendBufferPosition);
+	}
 }
 
 void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) {
 	setMessageType(REPLY_DATA_IPC_STORE);
 	setAddress(address);
-	setStoreId(storeId);
+	setStoreId(storeId.raw);
 }
 void CommunicationMessage::setDataReplyFromPointer(uint32_t address,
 		uint32_t dataLen, uint8_t *data) {
@@ -51,7 +56,7 @@ void CommunicationMessage::setDataReplyRaw(uint32_t address,
 	setAddress(address);
 	setDataLen(length);
 	if(receiveBufferPosition != 0) {
-		setReceiveBufferPosition(receiveBufferPosition);
+		setBufferPosition(receiveBufferPosition);
 	}
 }
 
@@ -60,61 +65,137 @@ void CommunicationMessage::setMessageType(messageType status) {
 	memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8));
 }
 
-void CommunicationMessage::setAddress(uint32_t address) {
+void CommunicationMessage::setAddress(address_t address) {
 	memcpy(getData(),&address,sizeof(address));
 }
 
-void CommunicationMessage::setReceiveBufferPosition(uint16_t bufferPosition) {
-	memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t),
+address_t CommunicationMessage::getAddress() const {
+	address_t address;
+	memcpy(&address,getData(),sizeof(address));
+	return address;
+}
+
+void CommunicationMessage::setBufferPosition(uint16_t bufferPosition) {
+	memcpy(getData() + sizeof(uint32_t) + sizeof(uint16_t),
 			&bufferPosition, sizeof(bufferPosition));
 }
 
+uint16_t CommunicationMessage::getBufferPosition() const {
+	uint16_t bufferPosition;
+	memcpy(&bufferPosition,
+			getData() + sizeof(uint32_t) + sizeof(uint16_t), sizeof(bufferPosition));
+	return bufferPosition;
+}
+
 void CommunicationMessage::setDataPointer(const void * data) {
 	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(uint32_t));
 }
 
 void CommunicationMessage::setStoreId(store_address_t storeId) {
-	memcpy(getData() + 2 * sizeof(uint32_t), &storeId, sizeof(store_address_t));
+	memcpy(getData() + 2 * sizeof(uint32_t), &storeId.raw, sizeof(uint32_t));
+}
+
+store_address_t CommunicationMessage::getStoreId() const{
+	store_address_t temp;
+	memcpy(&temp.raw,getData() + 2 * sizeof(uint32_t), sizeof(uint32_t));
+	return temp;
 }
 
 void CommunicationMessage::setDataLen(uint32_t length) {
 	memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length));
 }
 
-void CommunicationMessage::setData(uint32_t data) {
+uint32_t CommunicationMessage::getDataLen() const {
+	uint32_t len;
+	memcpy(&len, getData() + 2 * sizeof(uint32_t), sizeof(len));
+	return len;
+}
+
+void CommunicationMessage::setUint32Data(uint32_t data) {
 	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(data));
 }
 
-void CommunicationMessage::setDataByte1(uint8_t byte1) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &byte1, sizeof(byte1));
+uint32_t CommunicationMessage::getUint32Data() const{
+	uint32_t data;
+	memcpy(&data,getData() + 3 * sizeof(uint32_t),  sizeof(data));
+	return data;
 }
 
-void CommunicationMessage::setDataByte2(uint8_t byte2) {
-	memcpy(getData() + 3 * sizeof(uint32_t) + sizeof(uint8_t), &byte2, sizeof(byte2));
+void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
+	if(0 <= position && position <= 3) {
+		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte));
+	}
+	else {
+		error << "Comm Message: Invalid byte position" << std::endl;
+	}
 }
 
-void CommunicationMessage::setDataByte3(uint8_t byte3) {
-	memcpy(getData() + 3 * sizeof(uint32_t) + 2* sizeof(uint8_t), &byte3, sizeof(byte3));
+uint8_t CommunicationMessage::getDataByte(uint8_t position) const {
+	if(0 <= position && position <= 3) {
+		uint8_t byte;
+		memcpy(&byte, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), sizeof(byte));
+		return byte;
+	}
+	else {
+		return 0;
+		error << "Comm Message: Invalid byte position" << std::endl;
+	}
 }
 
-void CommunicationMessage::setDataByte4(uint8_t byte4) {
-	memcpy(getData() + 3 * sizeof(uint32_t) + 3* sizeof(uint8_t), &byte4, sizeof(byte4));
+void CommunicationMessage::setDataUint16(uint16_t data, uint8_t position) {
+	if(position == 0 || position == 1) {
+		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), &data, sizeof(data));
+	}
+	else {
+		error << "Comm Message: Invalid byte position" << std::endl;
+	}
+
 }
 
-void CommunicationMessage::setDataUINT16_1(uint16_t data1) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &data1, sizeof(data1));
+uint16_t CommunicationMessage::getDataUint16(uint8_t position) const{
+	if(position == 0 || position == 1) {
+		uint16_t data;
+		memcpy(&data, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), sizeof(data));
+		return data;
+	}
+	else {
+		return 0;
+		error << "Comm Message: Invalid byte position" << std::endl;
+	}
 }
 
-void CommunicationMessage::setDataUINT16_2(uint16_t data2) {
-	memcpy(getData() + 3 * sizeof(uint32_t) + sizeof(uint16_t), &data2, sizeof(data2));
-}
-
-CommunicationMessage::messageType CommunicationMessage::getMessageType() {
+CommunicationMessage::messageType CommunicationMessage::getMessageType() const{
 	messageType messageType;
 	memcpy(&messageType, getData() + sizeof(uint32_t),sizeof(uint8_t));
 	return messageType;
 }
 
+void CommunicationMessage::setMessageId(uint8_t messageId) {
+	memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t), &messageId, sizeof(messageId));
+}
+
+uint8_t CommunicationMessage::getMessageId() const {
+	uint8_t messageId;
+	memcpy(&messageId, getData() + sizeof(uint32_t) + sizeof(uint8_t), sizeof(messageId));
+	return messageId;
+}
+
 void CommunicationMessage::clearCommunicationMessage() {
 	messageType messageType = getMessageType();
+	switch(messageType) {
+	case(messageType::REPLY_DATA_IPC_STORE):
+	case(messageType::SEND_DATA_FROM_IPC_STORE): {
+		store_address_t storeId = getStoreId();
+		StorageManagerIF *ipcStore = objectManager->
+				get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(storeId);
+		}
+	}
+	/* NO BREAK falls through*/
+	default:
+		memset(getData(),0,4*sizeof(uint32_t));
+		break;
+	}
 }
+
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
index 805dd9a88..a92c4b5cf 100644
--- a/devicehandlers/CommunicationMessage.h
+++ b/devicehandlers/CommunicationMessage.h
@@ -10,6 +10,7 @@
 
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/devicehandlers/DeviceHandlerBase.h>
 
 /**
  * @brief Used to pass communication information between tasks
@@ -26,6 +27,7 @@
 class CommunicationMessage: public MessageQueueMessage {
 public:
 	enum messageType {
+		NONE,
 		SEND_DATA_FROM_POINTER,
 		SEND_DATA_FROM_IPC_STORE,
 		SEND_DATA_RAW,
@@ -41,6 +43,24 @@ public:
 	CommunicationMessage();
 	virtual ~CommunicationMessage();
 
+	/**
+	 * Message Type is stored as the fifth byte of the message data
+	 * @param status
+	 */
+	void setMessageType(messageType status);
+	messageType getMessageType() const;
+
+	/**
+	 * This is a unique ID which can be used to handle different kinds of messages.
+	 * For example, the same interface (e.g. SPI) could be used to exchange raw data
+	 * (e.g. sensor values) and data stored in the IPC store.
+	 * The ID can be used to distinguish the messages in child implementations.
+	 * The message ID is stored as the sixth byte of the message data.
+	 * @param messageId
+	 */
+	void setMessageId(uint8_t messageId);
+	uint8_t getMessageId() const;
+
 	/**
 	 * Send requests with pointer to the data to be sent and send data length
 	 * @param address Target Address, first four bytes
@@ -65,7 +85,8 @@ public:
 	 * @param data Pointer to data to send
 	 *
 	 */
-	void setSendRequestRaw(uint32_t address, uint32_t length);
+	void setSendRequestRaw(uint32_t address, uint32_t length,
+			uint16_t sendBufferPosition = 0);
 
 	/**
 	 * Data message with data stored in IPC store
@@ -97,31 +118,27 @@ public:
 	 * First four bytes of message data
 	 * @param address
 	 */
-	void setAddress(uint32_t address);
+	void setAddress(address_t address);
+
+	address_t getAddress() const;
+	/**
+	 * Set byte as position of 4 byte data field
+	 * @param byte
+	 * @param position Position, 0 to 3 possible
+	 */
+	void setDataByte(uint8_t byte, uint8_t position);
+	uint8_t getDataByte(uint8_t position) const;
 
 	/**
-	 * Message Type is stored as the fifth byte of the message data
-	 * @param status
+	 * Set 2 byte value at position 1 or 2 of data field
+	 * @param data
+	 * @param position 0 or 1 possible
 	 */
-	void setMessageType(messageType status);
-	messageType getMessageType();
+	void setDataUint16(uint16_t data, uint8_t position);
+	uint16_t getDataUint16(uint8_t position) const;
 
-	void setMessageId(uint8_t messageId);
-	messageType getMessageId();
-
-	/*
-	 * The following functions can be used to
-	 * set the data field (4 bytes possible);
-	 */
-	void setDataByte1(uint8_t byte1);
-	void setDataByte2(uint8_t byte2);
-	void setDataByte3(uint8_t byte3);
-	void setDataByte4(uint8_t byte4);
-
-	void setDataUINT16_1(uint16_t data1);
-	void setDataUINT16_2(uint16_t data2);
-
-	void setData(uint32_t data);
+	void setUint32Data(uint32_t data);
+	uint32_t getUint32Data() const;
 
 	/**
 	 * Stored in Bytes 13-16 of message data
@@ -129,6 +146,8 @@ public:
 	 */
 	void setDataLen(uint32_t length);
 
+	uint32_t getDataLen() const;
+
 	/**
 	 * Stored in last four bytes (Bytes 17-20) of message data
 	 * @param sendData
@@ -136,19 +155,22 @@ public:
 	void setDataPointer(const void * data);
 
 	/**
-	 * Buffer Position is stored as the seventh and eigth byte of
+	 * In case the send request data or reply data is to be stored in a buffer,
+	 * a buffer Position can be stored here as the seventh and eigth byte of
 	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now.
-	 * @param bufferPosition
+	 * @param bufferPosition In case the data is stored in a buffer, the position can be supplied here
 	 */
-	void setReceiveBufferPosition(uint16_t bufferPosition);
+	void setBufferPosition(uint16_t bufferPosition);
+	uint16_t getBufferPosition() const;
 	void setStoreId(store_address_t storeId);
+	store_address_t getStoreId() const;
 
 	/**
-	 * Clear the message
+	 * Clear the message. Deletes IPC Store data
+	 * and sets all data to 0. Also sets message type to NONE
 	 */
 	void clearCommunicationMessage();
 private:
-
 	bool uninitialized; //!< Could be used to warn if data has not been set.
 };
 
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index e03db26be..999045105 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -73,10 +73,15 @@ public:
 
 	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
 
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * @param cookie
+	 * @return
+	 */
 	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie) = 0;
 
 	/**
-	 * Called by DHB in the GET_WIRTE doGetRead().
+	 * Called by DHB in the GET_WRITE doGetRead().
 	 * This function is used to receive data from the physical device
 	 * by implementing and calling related drivers or wrapper functions.
 	 * @param cookie

From 22e4dabd1bf778c1a4c32aa76d8bf72b99936576 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 6 Mar 2020 15:39:42 +0100
Subject: [PATCH 0117/1774] BinSemaphore reset function added

---
 osal/FreeRTOS/BinarySemaphore.cpp | 5 +++++
 osal/FreeRTOS/BinarySemaphore.h   | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index c3d573870..d429f1a07 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -79,6 +79,11 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 	}
 }
 
+void BinarySemaphore::resetSemaphore() {
+	vSemaphoreDelete(handle);
+	vSemaphoreCreateBinary(handle);
+}
+
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == NULL) {
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 7ead0d2fe..a809f0bb1 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -69,6 +69,11 @@ public:
 	 */
 	SemaphoreHandle_t getSemaphore();
 
+	/**
+	 * Reset the semaphore.
+	 */
+	void resetSemaphore();
+
 	 /**
 	 * Wrapper function to give back semaphore from handle
 	 * @param semaphore

From 68cda479d699ef0f5c73b9ee95c352e178171896 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 6 Mar 2020 18:48:48 +0100
Subject: [PATCH 0118/1774] DHB: performOperation Hook + polling counter

polling counter to specify how often communication opertions are
performed, however this still needs to be changed..
---
 container/FixedMap.h                 |  2 +-
 container/group.h                    |  8 +++-----
 devicehandlers/DeviceHandlerBase.cpp | 20 +++++++++++++++++---
 devicehandlers/DeviceHandlerBase.h   | 25 +++++++++++++++++++++++--
 4 files changed, 44 insertions(+), 11 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 39e9106d1..f5ee42445 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -9,7 +9,7 @@
  * @brief 	Map implementation for maps with a pre-defined size.
  * @details Can be initialized with desired maximum size.
  * 	        Iterator is used to access <key,value> pair and
- * 	        iterate through map entries.
+ * 	        iterate through map entries. Complexity O(n).
  * @ingroup container
  */
 template<typename key_t, typename T>
diff --git a/container/group.h b/container/group.h
index 5a39d34ec..9c70d5236 100644
--- a/container/group.h
+++ b/container/group.h
@@ -4,11 +4,9 @@
 /**
  * @defgroup container Container
  *
- * General Purpose Container to store various elements.
- *
- * Also contains Adapter classes to print elements to a
- * bytestream and to read them from a bytestream, as well
- * as an Adapter to swap the endianness.
+ * General Purpose Containers to store various elements.
+ * As opposed to the STL library implementation, these implementations
+ * don't  allocate memory dynamically.
  */
 
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index c4f7465d9..1252d61f5 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -32,8 +32,9 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
 		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
 		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
 		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), logicalAddress(logicalAddress_),
-		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
+		pollingFrequency(1), pollingCounter(1), timeoutStart(0), childTransitionDelay(5000),
+		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(SUBMODE_NONE),
+		deviceSwitch(setDeviceSwitch)
 {
 	commandQueue = QueueFactory::instance()->
 			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
@@ -63,10 +64,20 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		decrementDeviceReplyMap();
 		fdirInstance->checkForFailures();
 		hkSwitcher.performOperation();
+		performOperationHook();
 	}
 	if (mode == MODE_OFF) {
 		return RETURN_OK;
 	}
+
+	if (pollingCounter != pollingFrequency) {
+		pollingCounter ++;
+		return RETURN_OK;
+	}
+	else {
+		pollingCounter = 1;
+	}
+
 	switch (getRmapAction()) {
 	case SEND_WRITE:
 		if ((cookieInfo.state == COOKIE_UNUSED)) {
@@ -87,6 +98,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	default:
 		break;
 	}
+
 	return RETURN_OK;
 }
 
@@ -166,7 +178,6 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	mySet.commit(PoolVariableIF::VALID);
 
 	return RETURN_OK;
-
 }
 
 void DeviceHandlerBase::decrementDeviceReplyMap() {
@@ -1278,3 +1289,6 @@ void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t obje
 uint32_t DeviceHandlerBase::getLogicalAddress() {
 	return logicalAddress;
 }
+
+void DeviceHandlerBase::performOperationHook() {
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 98808d87e..130aedb96 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -18,9 +18,9 @@
 #include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
 #include <framework/datapool/HkSwitchHelper.h>
 #include <framework/serialize/SerialFixedArrayListAdapter.h>
-#include <map>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/tasks/PeriodicTaskIF.h>
+#include <map>
 
 namespace Factory{
 void setStaticFrameworkObjectIds();
@@ -88,7 +88,7 @@ public:
 	 * The constructor passes the objectId to the SystemObject().
 	 *
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
+	 * @param maxDeviceReplyLen the largest allowed reply size
 	 * @param setDeviceSwitch the switch the device is connected to, for devices using two switches, overwrite getSwitches()
 	 * @param deviceCommuncation Communcation Interface object which is used to implement communication functions
 	 * @param thermalStatePoolId
@@ -349,6 +349,12 @@ protected:
 	virtual ReturnValue_t getSwitches(const uint8_t **switches,
 			uint8_t *numberOfSwitches);
 
+	/**
+	 * Can be used to perform device specific periodic operations.
+	 * This is called on the SEND_READ step of the performOperation() call
+	 */
+	virtual void performOperationHook();
+
 public:
 	/**
 	 * @param parentQueueId
@@ -934,6 +940,19 @@ private:
 	*/
 	const uint32_t logicalAddress;
 
+	/**
+	 * Polling Frequency which specifies how often the communication functions
+	 * and functionalities are called.
+	 *
+	 * This is not a time value. The time value depends on the
+	 * respective period time of the polling sequence table.
+	 * The actual time frequency can be calculated by multiplying that period
+	 * with the polling frequency value. Defaults to 1 (communication operations called
+	 * in each performOperation()).
+	 */
+	uint32_t pollingFrequency;
+	uint32_t pollingCounter;
+
 	/**
 	 * Used for timing out mode transitions.
 	 *
@@ -981,6 +1000,8 @@ private:
 	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
 	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
 	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
+	 * - Maybe export this into own class to increase modularity of software
+	 *   and reduce the massive class size ?
 	 */
 	void doStateMachine(void);
 

From 6579200f5551f93349ce018127b249ab7cdb3739 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 6 Mar 2020 19:01:31 +0100
Subject: [PATCH 0119/1774] removed counter, will be implemented in childclass

---
 devicehandlers/DeviceHandlerBase.cpp | 13 ++-----------
 devicehandlers/DeviceHandlerBase.h   | 15 ++-------------
 2 files changed, 4 insertions(+), 24 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1252d61f5..e7b4c6844 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -32,9 +32,8 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
 		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
 		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
 		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), logicalAddress(logicalAddress_),
-		pollingFrequency(1), pollingCounter(1), timeoutStart(0), childTransitionDelay(5000),
-		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(SUBMODE_NONE),
-		deviceSwitch(setDeviceSwitch)
+		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
 {
 	commandQueue = QueueFactory::instance()->
 			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
@@ -70,14 +69,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		return RETURN_OK;
 	}
 
-	if (pollingCounter != pollingFrequency) {
-		pollingCounter ++;
-		return RETURN_OK;
-	}
-	else {
-		pollingCounter = 1;
-	}
-
 	switch (getRmapAction()) {
 	case SEND_WRITE:
 		if ((cookieInfo.state == COOKIE_UNUSED)) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 130aedb96..7586cc0f4 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -668,6 +668,8 @@ protected:
 	 * @param maxDelayCycles The maximum number of delay cycles the command waits until it times out.
 	 * @param periodic	Indicates if the command is periodic (i.e. it is sent by the device repeatedly without request) or not.
 	 *		 			Default is aperiodic (0)
+	 * @param hasDifferentReplyId
+	 * @param replyId
 	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
@@ -940,19 +942,6 @@ private:
 	*/
 	const uint32_t logicalAddress;
 
-	/**
-	 * Polling Frequency which specifies how often the communication functions
-	 * and functionalities are called.
-	 *
-	 * This is not a time value. The time value depends on the
-	 * respective period time of the polling sequence table.
-	 * The actual time frequency can be calculated by multiplying that period
-	 * with the polling frequency value. Defaults to 1 (communication operations called
-	 * in each performOperation()).
-	 */
-	uint32_t pollingFrequency;
-	uint32_t pollingCounter;
-
 	/**
 	 * Used for timing out mode transitions.
 	 *

From b5fe1fa530ed9fd91b5936b0cb617a9774861a6a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 9 Mar 2020 22:15:52 +0100
Subject: [PATCH 0120/1774] dhb virtual function moved to top

---
 devicehandlers/DeviceHandlerBase.h | 18 +++++++++---------
 devicehandlers/DeviceHandlerIF.h   |  8 ++++----
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 7586cc0f4..53eaa7dd0 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -306,6 +306,14 @@ protected:
 	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
 			const uint8_t *packet) = 0;
 
+	/**
+	 * set all datapool variables that are update periodically in normal mode invalid
+	 *
+	 * Child classes should provide an implementation which sets all those variables invalid
+	 * which are set periodically during any normal mode.
+	 */
+	virtual void setNormalDatapoolEntriesInvalid() = 0;
+
 	/**
 	 * @brief   Can be implemented by child handler to
 	 *          perform debugging
@@ -666,7 +674,7 @@ protected:
 	 * This is a helper method to facilitate inserting entries in the command map.
 	 * @param deviceCommand	Identifier of the command to add.
 	 * @param maxDelayCycles The maximum number of delay cycles the command waits until it times out.
-	 * @param periodic	Indicates if the command is periodic (i.e. it is sent by the device repeatedly without request) or not.
+	 * @param periodic	Indicates if the reply is periodic (i.e. it is sent by the device repeatedly without request) or not.
 	 *		 			Default is aperiodic (0)
 	 * @param hasDifferentReplyId
 	 * @param replyId
@@ -782,14 +790,6 @@ protected:
 	 */
 	ReturnValue_t getStateOfSwitches(void);
 
-	/**
-	 * set all datapool variables that are update periodically in normal mode invalid
-	 *
-	 * Child classes should provide an implementation which sets all those variables invalid
-	 * which are set periodically during any normal mode.
-	 */
-	virtual void setNormalDatapoolEntriesInvalid() = 0;
-
 	/**
 	 * build a list of sids and pass it to the #hkSwitcher
 	 */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index ed0260d60..cce403493 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -67,20 +67,20 @@ public:
 	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
 	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
 
-	//standard codes used in scan for reply
-	//	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE(0xB1);
+	// Standard codes used in scan for reply
+	//static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE(0xB1);
 	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB2);
 	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB3);
 	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB4);
 	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB5);
 
-	//standard codes used in  interpret device reply
+	// Standard codes used in  interpret device reply
 	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC1); //the device reported, that it did not execute the command
 	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC2);
 	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC3); //the deviceCommandId reported by scanforReply is unknown
 	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC4); //syntax etc is correct but still not ok, eg parameters where none are expected
 
-	//Standard codes used in buildCommandFromCommand
+	// Standard codes used in buildCommandFromCommand
 	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(
 			0xD0);
 	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS =

From a3903f80fb915a046eb69e1492254ef4e69b5987 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 19 Mar 2020 00:49:47 +0100
Subject: [PATCH 0121/1774] typedef address_t moved to deviceComIF

---
 devicehandlers/Cookie.h                |  8 ++++-
 devicehandlers/DeviceCommunicationIF.h | 41 +++++++++++++++++++-------
 devicehandlers/DeviceHandlerBase.h     | 24 +++++++--------
 rmap/RmapDeviceCommunicationIF.h       |  6 ++--
 4 files changed, 52 insertions(+), 27 deletions(-)

diff --git a/devicehandlers/Cookie.h b/devicehandlers/Cookie.h
index 618c901ff..ec22ec3a5 100644
--- a/devicehandlers/Cookie.h
+++ b/devicehandlers/Cookie.h
@@ -2,7 +2,13 @@
 #define COOKIE_H_
 
 /**
- * This datatype is used to identify different connection over a single interface (like RMAP or I2C)
+ * @brief This datatype is used to identify different connection over a single interface
+ *        (like RMAP or I2C)
+ * @details
+ * To use this class, implement a communication specific child cookie. This cookie
+ * can be used in the device communication interface by performing
+ * a C++ dynamic cast. The cookie can be used to store all kinds of information
+ * about the communication between read and send calls.
  */
 class Cookie{
 public:
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 999045105..9b0e0a3a9 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -8,6 +8,11 @@
  * @brief Communication interfaces for flight software objects
  */
 
+/**
+ * Physical address type
+ */
+typedef uint32_t address_t;
+
 /**
  * @brief This is an interface to decouple device communication from
  * the device handler to allow reuse of these components.
@@ -39,23 +44,36 @@ public:
 
 	virtual ~DeviceCommunicationIF() {}
 
-	virtual ReturnValue_t open(Cookie **cookie, uint32_t address,
+	/**
+	 * Open a connection. Define a communication specific cookie which can
+	 * be used to store information about the communication.
+	 *
+	 * @param cookie [in/out] This data class stores information about the communication.
+	 * @param address Logical device address
+	 * @param maxReplyLen Maximum length of expected reply
+	 * @return
+	 */
+	virtual ReturnValue_t open(Cookie **cookie, address_t address,
 			uint32_t maxReplyLen) = 0;
 
 	/**
 	 * Use an existing cookie to open a connection to a new DeviceCommunication.
 	 * The previous connection must not be closed.
-	 * If the returnvalue is not RETURN_OK, the cookie is unchanged and
-	 * can be used with the previous connection.
 	 *
 	 * @param cookie
 	 * @param address
 	 * @param maxReplyLen
-	 * @return
+	 * @return -@c RETURN_OK New communication set up successfully
+	 *         - Everything else: Cookie is unchanged and can be used with
+	 *           previous connection
 	 */
-	virtual ReturnValue_t reOpen(Cookie *cookie, uint32_t address,
+	virtual ReturnValue_t reOpen(Cookie *cookie, address_t address,
 			uint32_t maxReplyLen) = 0;
 
+	/**
+	 * Closing call of connection. Don't forget to free memory of cookie.
+	 * @param cookie
+	 */
 	virtual void close(Cookie *cookie) = 0;
 
 	/**
@@ -65,16 +83,18 @@ public:
 	 * @param cookie
 	 * @param data
 	 * @param len
-	 * @return @c RETURN_OK for successfull send
-	 *         Everything else triggers sending failed event with returnvalue as parameter 1
+	 * @return -@c RETURN_OK for successfull send
+	 *         -Everything else triggers sending failed event with
+	 *          returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t sendMessage(Cookie *cookie,const uint8_t *data,
+	virtual ReturnValue_t sendMessage(Cookie *cookie, const uint8_t *data,
 			uint32_t len) = 0;
 
 	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
 
 	/**
 	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * Instructs the Communication Interface to prepare
 	 * @param cookie
 	 * @return
 	 */
@@ -93,9 +113,9 @@ public:
 	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
 			uint32_t *size) = 0;
 
-	virtual ReturnValue_t setAddress(Cookie *cookie, uint32_t address) = 0;
+	virtual ReturnValue_t setAddress(Cookie *cookie, address_t address) = 0;
 
-	virtual uint32_t getAddress(Cookie *cookie) = 0;
+	virtual address_t getAddress(Cookie *cookie) = 0;
 
 	/**
 	 * Can be used by DeviceHandlerBase getParameter() call to set DeviceComIF parameters
@@ -112,7 +132,6 @@ public:
 	 * @return
 	 */
 	virtual uint32_t getParameter(Cookie *cookie) = 0;
-
 };
 
 #endif /* DEVICECOMMUNICATIONIF_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 53eaa7dd0..60e8888e2 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -33,28 +33,25 @@ class StorageManagerIF;
  * Contains all devices and the DeviceHandlerBase class.
  */
 
-/**
- * Physical address type
- */
-typedef uint32_t address_t;
-
 /**
  * @brief This is the abstract base class for device handlers.
  * @details
  * Documentation: Dissertation Baetz p.138,139, p.141-149
  *
- * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink, communication with
- * physical devices, using the @link DeviceCommunicationIF @endlink, and communication with commanding objects.
+ * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink,
+ * communication with physical devices, using the @link DeviceCommunicationIF @endlink,
+ * and communication with commanding objects.
  * It inherits SystemObject and thus can be created by the ObjectManagerIF.
  *
  * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
  * For each step an RMAP action is selected and executed.
  * 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.
+ * 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.
  * 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.
+ * 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
@@ -495,7 +492,8 @@ protected:
 	DeviceCommunicationIF *communicationInterface;
 
 	/**
-	 * Cookie used for communication
+	 * Cookie used for communication. This is passed to the communication
+	 * interface.
 	 */
 	Cookie *cookie;
 
@@ -910,7 +908,7 @@ private:
 	/**
 	 * State a cookie is in.
 	 *
-	 * Used to keep track of the state of the RMAP communication.
+	 * Used to keep track of the state of the communication.
 	 */
 	enum CookieState_t {
 		COOKIE_UNUSED,    //!< The Cookie is unused
diff --git a/rmap/RmapDeviceCommunicationIF.h b/rmap/RmapDeviceCommunicationIF.h
index 12ae67e4a..45963d860 100644
--- a/rmap/RmapDeviceCommunicationIF.h
+++ b/rmap/RmapDeviceCommunicationIF.h
@@ -4,7 +4,8 @@
 #include <framework/devicehandlers/DeviceCommunicationIF.h>
 
 /**
- * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls. It expects RMAPCookies or a derived class of RMAPCookies
+ * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls.
+ *          It expects RMAPCookies or a derived class of RMAPCookies
  *
  * @details	The open, close and reOpen calls are mission specific
  * 			The open call might return any child of RMAPCookies
@@ -44,7 +45,8 @@ public:
 
 
 	/**
-	 * Closing call of connection and memory free of cookie. Mission dependent call
+	 * Closing call of connection and free memory of cookie.
+	 * Mission dependent call
 	 * @param cookie
 	 */
 	virtual void close(Cookie *cookie) = 0;

From b7e3449b04c48ff65e6e21767667c328938701dd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 19 Mar 2020 12:38:11 +0100
Subject: [PATCH 0122/1774] some more doc for containers

---
 container/ArrayList.h              |  7 ++-
 container/FIFO.h                   |  5 ++
 container/HybridIterator.h         |  2 +-
 container/IndexedRingMemoryArray.h | 87 ++++++++++++++++++------------
 container/SinglyLinkedList.h       |  4 +-
 5 files changed, 66 insertions(+), 39 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 59e5eef4a..57b2f94df 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -6,10 +6,9 @@
 #include <framework/serialize/SerializeIF.h>
 
 /**
- * A List that stores its values in an array.
- *
- * The backend is an array that can be allocated by the class itself or supplied via ctor.
- *
+ * @brief 	A List that stores its values in an array.
+ * @details The backend is an array that can be allocated
+ * 			by the class itself or supplied via ctor.
  *
  * @ingroup container
  */
diff --git a/container/FIFO.h b/container/FIFO.h
index 134da9b80..00f56993a 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -3,6 +3,11 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
+/**
+ * @brief Simple First-In-First-Out data structure
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
 template<typename T, uint8_t capacity>
 class FIFO {
 private:
diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index b34fdfd01..1c56aa13b 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -67,7 +67,7 @@ public:
 	}
 
 	bool operator==(HybridIterator other) {
-		return value == other->value;
+		return value == other.value;
 	}
 
 	bool operator!=(HybridIterator other) {
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index eacfe3e5d..4ab174f4b 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -8,20 +8,27 @@
 #include <framework/globalfunctions/crc_ccitt.h>
 #include <cmath>
 
+/**
+ * Index is the Type used for the list of indices.
+ *
+ * @tparam T Type which destribes the index. Needs to be a child of SerializeIF
+ * 			 to be able to make it persistent
+ */
 template<typename T>
 class Index: public SerializeIF{
 	/**
-	 * Index is the Type used for the list of indices. The template parameter is the type which describes the index, it needs to be a child of SerializeIF to be able to make it persistent
+	 *
 	 */
-	static_assert(std::is_base_of<SerializeIF,T>::value,"Wrong Type for Index, Type must implement SerializeIF");
+	static_assert(std::is_base_of<SerializeIF,T>::value,
+			"Wrong Type for Index, Type must implement SerializeIF");
 public:
 	Index():blockStartAddress(0),size(0),storedPackets(0){}
 
-	Index(uint32_t startAddress):blockStartAddress(startAddress),size(0),storedPackets(0){
-
+	Index(uint32_t startAddress):blockStartAddress(startAddress),
+			size(0),storedPackets(0) {
 	}
 
-	void setBlockStartAddress(uint32_t newAddress){
+	void setBlockStartAddress(uint32_t newAddress) {
 		this->blockStartAddress = newAddress;
 	}
 
@@ -33,7 +40,7 @@ public:
 		return &indexType;
 	}
 
-	T* modifyIndexType(){
+	T* modifyIndexType() {
 		return &indexType;
 	}
 	/**
@@ -128,26 +135,35 @@ private:
 };
 
 
-
+/**
+ * @brief Indexed Ring Memory Array is a class for a ring memory with indices.
+ * @details
+ * It assumes that the newest data comes in last
+ * It uses the currentWriteBlock as pointer to the current writing position
+ * The currentReadBlock must be set manually
+ * @tparam T
+ */
 template<typename T>
 class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
 	/**
-	 * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest data comes in last
-	 * It uses the currentWriteBlock as pointer to the current writing position
-	 * The currentReadBlock must be set manually
+	 *
 	 */
 public:
-	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock, SerializeIF* additionalInfo,
-			bool overwriteOld) :ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld){
-
+	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
+			SerializeIF* additionalInfo, bool overwriteOld):
+			ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),
+			indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),
+			lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld)
+	{
 		//Calculate the maximum number of indices needed for this blocksize
 		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
 
 		//Calculate the Size needeed for the index itself
 		uint32_t serializedSize = 0;
-		if(additionalInfo!=NULL){
+		if(additionalInfo!=NULL) {
 			serializedSize += additionalInfo->getSerializedSize();
 		}
+
 		//Size of current iterator type
 		Index<T> tempIndex;
 		serializedSize += tempIndex.getSerializedSize();
@@ -162,6 +178,7 @@ public:
 			error << "IndexedRingMemory: Store is too small for index" << std::endl;
 		}
 		uint32_t useableSize = totalSize - serializedSize;
+
 		//Update the totalSize for calculations
 		totalSize = useableSize;
 
@@ -178,12 +195,10 @@ public:
 		this->allocated = true;
 
 		//Check trueNumberOfBlocks
-		if(trueNumberOfBlocks<1){
+		if(trueNumberOfBlocks<1) {
 			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
 		}
 
-
-
 		//Fill address into index
 		uint32_t address = trueStartAddress;
 		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
@@ -193,7 +208,6 @@ public:
 			address += bytesPerBlock;
 		}
 
-
 		//Initialize iterators
 		currentWriteBlock = this->begin();
 		currentReadBlock = this->begin();
@@ -232,10 +246,10 @@ public:
 		(*typeResetFnc)(it->modifyIndexType());
 	}
 
-	/*
+	/**
 	 * Reading
+	 * @param it
 	 */
-
 	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
 		currentReadBlock = it;
 		currentReadBlockSizeCached = it->getSize();
@@ -248,6 +262,7 @@ public:
 		lastBlockToRead = currentWriteBlock;
 		lastBlockToReadSize = currentWriteBlock->getSize();
 	}
+
 	/**
 	 * Sets the last block to read to this iterator.
 	 * Can be used to dump until block x
@@ -292,33 +307,39 @@ public:
 	uint32_t getCurrentReadAddress() const {
 		return getAddressOfCurrentReadBlock() + currentReadSize;
 	}
+
 	/**
-	 * Adds readSize to the current size and checks if the read has no more data left and advances the read block
+	 * Adds readSize to the current size and checks if the read has no more data
+	 * left and advances the read block.
 	 * @param readSize The size that was read
 	 * @return Returns true if the read can go on
 	 */
 	bool addReadSize(uint32_t readSize) {
-		if(currentReadBlock == lastBlockToRead){
+		if(currentReadBlock == lastBlockToRead) {
 			//The current read block is the last to read
-			if((currentReadSize+readSize)<lastBlockToReadSize){
+			if((currentReadSize+readSize)<lastBlockToReadSize) {
 				//the block has more data -> return true
 				currentReadSize += readSize;
 				return true;
-			}else{
+			}
+			else {
 				//Reached end of read -> return false
 				currentReadSize = lastBlockToReadSize;
 				return false;
 			}
-		}else{
+		}
+		else {
 			//We are not in the last Block
-			if((currentReadSize + readSize)<currentReadBlockSizeCached){
+			if((currentReadSize + readSize)<currentReadBlockSizeCached) {
 				//The current Block has more data
 				currentReadSize += readSize;
 				return true;
-			}else{
+			}
+			// TODO: Maybe some logic blocks should be extracted
+			else {
 				//The current block is written completely
 				readNext();
-				if(currentReadBlockSizeCached==0){
+				if(currentReadBlockSizeCached==0) {
 					//Next block is empty
 					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
 					//Search if any block between this and the last block is not empty
@@ -421,13 +442,13 @@ public:
 	T* modifyCurrentWriteBlockIndexType(){
 		return currentWriteBlock->modifyIndexType();
 	}
+
 	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
 		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
 		it->addSize(size);
 		it->addStoredPackets(storedPackets);
 	}
 
-
 	/**
 	 * Checks if the block has enough space for sizeToWrite
 	 * @param sizeToWrite The data to be written in the Block
@@ -436,7 +457,10 @@ public:
 	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
 		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
 		uint32_t addressOfNextBlock = next->getBlockStartAddress();
-		uint32_t availableSize = ((addressOfNextBlock+totalSize) - (getAddressOfCurrentWriteBlock()+getSizeOfCurrentWriteBlock()))%totalSize;
+		uint32_t availableSize =
+				( ( addressOfNextBlock + totalSize ) -
+				(getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock()))
+				% totalSize;
 		return (sizeToWrite < availableSize);
 	}
 
@@ -694,7 +718,4 @@ private:
 
 };
 
-
-
-
 #endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */
diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 5c9de6cfe..b926bd007 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -4,7 +4,9 @@
 #include <stddef.h>
 #include <stdint.h>
 /**
- * \ingroup container
+ * @brief	Linked list data structure,
+ * 			each entry has a pointer to the next entry (singly)
+ * @ingroup container
  */
 template<typename T>
 class LinkedElement {

From 52c05e2f3da8043336f77deba36e1fefa53e61fd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 19 Mar 2020 12:44:24 +0100
Subject: [PATCH 0123/1774] minor formatting for pull request

---
 container/ArrayList.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 57b2f94df..f978c984d 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -223,7 +223,6 @@ public:
 		return (maxSize_ - size);
 	}
 
-
 private:
 	/**
 	 * This is the copy constructor
@@ -236,6 +235,7 @@ private:
 	ArrayList(const ArrayList& other) :
 			size(other.size), entries(other.entries), maxSize_(other.maxSize_),
 			allocated(false) {}
+
 protected:
 	/**
 	 * pointer to the array in which the entries are stored
@@ -269,6 +269,6 @@ protected:
 			++i;
 		}
 	}
-
 };
+
 #endif /* ARRAYLIST_H_ */

From af6d18d60b323ea2759e1ca5af5980bd25673015 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 20 Mar 2020 22:47:07 +0100
Subject: [PATCH 0124/1774] added additional parameter form open/reopen call

---
 devicehandlers/DeviceCommunicationIF.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 9b0e0a3a9..4f98dd6d6 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -54,7 +54,7 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t open(Cookie **cookie, address_t address,
-			uint32_t maxReplyLen) = 0;
+			uint32_t maxReplyLen, uint32_t comParameter = 0) = 0;
 
 	/**
 	 * Use an existing cookie to open a connection to a new DeviceCommunication.
@@ -68,7 +68,7 @@ public:
 	 *           previous connection
 	 */
 	virtual ReturnValue_t reOpen(Cookie *cookie, address_t address,
-			uint32_t maxReplyLen) = 0;
+			uint32_t maxReplyLen, uint32_t comParameter = 0) = 0;
 
 	/**
 	 * Closing call of connection. Don't forget to free memory of cookie.

From c50d9d90d61a727ddc90e64d75ee98a4d3679bd0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 23 Mar 2020 13:14:23 +0100
Subject: [PATCH 0125/1774] replaced std::variant by two uint32 parameters

---
 devicehandlers/DeviceCommunicationIF.h | 18 ++++----
 devicehandlers/DeviceHandlerBase.cpp   |  6 +--
 devicehandlers/DeviceHandlerBase.h     | 61 ++++++++++++++++----------
 devicehandlers/DeviceHandlerIF.h       | 32 +++++++++++++-
 4 files changed, 82 insertions(+), 35 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 4f98dd6d6..1e307b6c0 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -2,17 +2,13 @@
 #define DEVICECOMMUNICATIONIF_H_
 
 #include <framework/devicehandlers/Cookie.h>
+#include <framework/devicehandlers/DeviceHandlerIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 /**
  * @defgroup interfaces Interfaces
  * @brief Communication interfaces for flight software objects
  */
 
-/**
- * Physical address type
- */
-typedef uint32_t address_t;
-
 /**
  * @brief This is an interface to decouple device communication from
  * the device handler to allow reuse of these components.
@@ -47,14 +43,20 @@ public:
 	/**
 	 * Open a connection. Define a communication specific cookie which can
 	 * be used to store information about the communication.
+	 * The two optional parameter provide additional flexibility to
+	 * set up the communication interface as desired. If there are a lot of
+	 * variables to set, a store ID to the parameters stored in the IPC store
+	 * can also be passed.
 	 *
-	 * @param cookie [in/out] This data class stores information about the communication.
+	 * @param cookie [out] This data class stores information about the communication.
 	 * @param address Logical device address
 	 * @param maxReplyLen Maximum length of expected reply
+	 * @param comParameter1 Arbitrary parameter which can be used to set up the cookie or comIF.
+	 * @param comParameter2 Arbitrary parameter which can be used to set up the cookie or comIF.
 	 * @return
 	 */
 	virtual ReturnValue_t open(Cookie **cookie, address_t address,
-			uint32_t maxReplyLen, uint32_t comParameter = 0) = 0;
+			uint32_t maxReplyLen, uint32_t comParameter1, uint32_t comParameter2) = 0;
 
 	/**
 	 * Use an existing cookie to open a connection to a new DeviceCommunication.
@@ -68,7 +70,7 @@ public:
 	 *           previous connection
 	 */
 	virtual ReturnValue_t reOpen(Cookie *cookie, address_t address,
-			uint32_t maxReplyLen, uint32_t comParameter = 0) = 0;
+			uint32_t maxReplyLen, uint32_t comParameter1, uint32_t comParameter2) = 0;
 
 	/**
 	 * Closing call of connection. Don't forget to free memory of cookie.
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index e7b4c6844..ca883e837 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -106,7 +106,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	}
 
 	result = communicationInterface->open(&cookie, logicalAddress,
-			maxDeviceReplyLen);
+			maxDeviceReplyLen, comParameter1, comParameter2);
 	if (result != RETURN_OK) {
 		return result;
 	}
@@ -691,7 +691,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 
 //Default child implementations
 
-DeviceHandlerBase::RmapAction_t DeviceHandlerBase::getRmapAction() {
+DeviceHandlerBase::CommunicationAction_t DeviceHandlerBase::getRmapAction() {
 	switch (pstStep) {
 	case 0:
 		return SEND_WRITE;
@@ -757,7 +757,7 @@ ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
 
 	if (newCommunication != NULL) {
 		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
-				maxDeviceReplyLen);
+				maxDeviceReplyLen, comParameter1, comParameter2);
 		if (result != RETURN_OK) {
 			return result;
 		}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 60e8888e2..868412edf 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -418,6 +418,22 @@ protected:
 	 */
 	uint32_t rawPacketLen;
 
+//	/**
+//	 * This union (or std::variant) type can be used to set comParameters which
+//	 * are passed in the open() and reOpen() calls to the communication
+//	 * interface
+//	 * TODO: I don't know if we should use C++17 features but if we do we propably
+//	 *		 should also write a function to get either a storeId handle
+//	 *		 or an array handle so these values can be set conveniently.
+//	 * The good think is that if there are many parameters, they can
+//	 * be stored in the IPC pool. But maybe two uint32_t parameters are enough.
+//	 * Simple = Good. It is downwards compatible and one can still store
+//	 * 4 bytes of parameters AND a store ID.
+//	 */
+//	comParameters_t comParameters;
+	uint32_t comParameter1 = 0;
+	uint32_t comParameter2 = 0;
+
 	/**
 	 * The mode the device handler is currently in.
 	 *
@@ -548,6 +564,28 @@ protected:
 	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.
+
+	/**
+	 * Set the device handler mode
+	 *
+	 * Sets #timeoutStart with every call.
+	 *
+	 * Sets #transitionTargetMode if necessary so transitional states can be entered from everywhere without breaking the state machine
+	 * (which relies on a correct #transitionTargetMode).
+	 *
+	 * The submode is left unchanged.
+	 *
+	 *
+	 * @param newMode
+	 */
+	void setMode(Mode_t newMode);
+
+	/**
+	 * @overload
+	 * @param submode
+	 */
+	void setMode(Mode_t newMode, Submode_t submode);
+
 	/**
 	 * Helper function to report a missed reply
 	 *
@@ -576,27 +614,6 @@ protected:
 	 */
 	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
 
-	/**
-	 * Set the device handler mode
-	 *
-	 * Sets #timeoutStart with every call.
-	 *
-	 * Sets #transitionTargetMode if necessary so transitional states can be entered from everywhere without breaking the state machine
-	 * (which relies on a correct #transitionTargetMode).
-	 *
-	 * The submode is left unchanged.
-	 *
-	 *
-	 * @param newMode
-	 */
-	void setMode(Mode_t newMode);
-
-	/**
-	 * @overload
-	 * @param submode
-	 */
-	void setMode(Mode_t newMode, Submode_t submode);
-
 	/**
 	 * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
 	 *
@@ -645,7 +662,7 @@ protected:
 	 *
 	 * @return The Rmap action to execute in this step
 	 */
-	virtual RmapAction_t getRmapAction();
+	virtual CommunicationAction_t getRmapAction();
 
 	/**
 	 * Build the device command to send for raw mode.
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index cce403493..c453e7e87 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -7,6 +7,33 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
 
+#if __cplusplus >= 201703L
+#include <array>
+#include <variant>
+#endif
+
+/**
+ * Physical address type
+ */
+typedef uint32_t address_t;
+
+///**
+// * This type safe union cold be used if C++17 or newer is used to transfer
+// * comIF settings to the communication interface object.
+// */
+//
+//#if __cplusplus >= 201703L
+//using comParameterArray_t = std::array<uint8_t, 4>;
+//using comParameters_t = std::variant<store_address_t, comParameterArray_t>;
+//#else
+//using comParameters_t = union comParameters {
+//		comParameters() = default;
+//		comParameters(uint32_t initValue): storeIdRaw(initValue) {}
+//		uint32_t storeIdRaw;
+//		uint8_t comParameter[4];
+//	};
+//#endif
+
 /**
  * This is the Interface used to communicate with a device handler.
  *
@@ -87,17 +114,18 @@ public:
 			MAKE_RETURN_CODE(0xD1);
 
 	/**
-	 * RMAP Action that will be executed.
+	 * Communication action that will be executed.
 	 *
 	 * This is used by the child class to tell the base class what to do.
 	 */
-	enum RmapAction_t {
+	enum CommunicationAction_t: uint8_t {
 		SEND_WRITE,//!< RMAP send write
 		GET_WRITE, //!< RMAP get write
 		SEND_READ, //!< RMAP send read
 		GET_READ,  //!< RMAP get read
 		NOTHING    //!< Do nothing.
 	};
+
 	/**
 	 * Default Destructor
 	 */

From d3e2652078913332c407845920b14cd0c5e459a6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 23 Mar 2020 17:58:23 +0100
Subject: [PATCH 0126/1774] replaced DHB sizes by size_t, rework

Cookie now passed to DHB, rework in progress
---
 action/ActionHelper.cpp                 |   2 +-
 action/CommandActionHelper.cpp          |   2 +-
 action/SimpleActionHelper.cpp           |   2 +-
 datapool/DataPoolAdmin.cpp              |   2 +-
 devicehandlers/ChildHandlerBase.cpp     |  15 ++--
 devicehandlers/ChildHandlerBase.h       |  12 +--
 devicehandlers/Cookie.cpp               |  24 ++++++
 devicehandlers/Cookie.h                 |  21 ++++-
 devicehandlers/DeviceCommunicationIF.h  | 103 +++++++-----------------
 devicehandlers/DeviceHandlerBase.cpp    |  92 +++++++++++----------
 devicehandlers/DeviceHandlerBase.h      |  56 +++++++------
 devicehandlers/DeviceHandlerMessage.cpp |   4 +-
 devicehandlers/DeviceHandlerMessage.h   |   2 +-
 memory/MemoryHelper.cpp                 |   2 +-
 osal/FreeRTOS/BinarySemaphore.cpp       |   4 +-
 parameters/ParameterHelper.cpp          |   2 +-
 storagemanager/LocalPool.h              |   8 +-
 storagemanager/StorageManagerIF.h       |   4 +-
 subsystem/Subsystem.cpp                 |   4 +-
 tcdistribution/CCSDSDistributor.cpp     |   2 +-
 tmtcpacket/pus/TcPacketStored.cpp       |   4 +-
 tmtcpacket/pus/TmPacketStored.cpp       |   2 +-
 tmtcservices/TmTcBridge.cpp             |   4 +-
 23 files changed, 186 insertions(+), 187 deletions(-)
 create mode 100644 devicehandlers/Cookie.cpp

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 9c1475f12..18e46fba9 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -49,7 +49,7 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
 		store_address_t dataAddress) {
 	const uint8_t* dataPtr = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		CommandMessage reply;
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index 05eb93461..ceb97d3b9 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -113,7 +113,7 @@ uint8_t CommandActionHelper::getCommandCount() const {
 
 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
 	const uint8_t * data = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return;
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index 6de372fbf..6861fc28c 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -44,7 +44,7 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
 		queueToUse->sendMessage(commandedBy, &reply);
 	}
 	const uint8_t* dataPtr = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
diff --git a/datapool/DataPoolAdmin.cpp b/datapool/DataPoolAdmin.cpp
index fe6b92152..99d2b51b2 100644
--- a/datapool/DataPoolAdmin.cpp
+++ b/datapool/DataPoolAdmin.cpp
@@ -215,7 +215,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 				ParameterMessage::getParameterId(command));
 
 		const uint8_t *storedStream;
-		uint32_t storedStreamSize;
+		size_t storedStreamSize;
 		result = storage->getData(ParameterMessage::getStoreId(command),
 				&storedStream, &storedStreamSize);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 50a5c07e5..a0630fc64 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -2,15 +2,16 @@
 #include <framework/devicehandlers/ChildHandlerBase.h>
 #include <framework/subsystem/SubsystemBase.h>
 
-ChildHandlerBase::ChildHandlerBase(uint32_t ioBoardAddress,
-		object_id_t setObjectId, object_id_t deviceCommunication,
+ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId, address_t logicalAddress,
+		object_id_t deviceCommunication, Cookie * cookie,
 		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		uint32_t parent, FailureIsolationBase* customFdir, uint32_t cmdQueueSize) :
-		DeviceHandlerBase(ioBoardAddress, setObjectId, maxDeviceReplyLen,
-				setDeviceSwitch, deviceCommunication, thermalStatePoolId,
-				thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir), cmdQueueSize), parentId(
-				parent), childHandlerFdir(setObjectId) {
+		uint32_t parent, FailureIsolationBase* customFdir, size_t cmdQueueSize) :
+		DeviceHandlerBase(setObjectId, logicalAddress, deviceCommunication, cookie,
+			maxDeviceReplyLen, setDeviceSwitch,  thermalStatePoolId,
+			thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir),
+			cmdQueueSize),
+		parentId(parent), childHandlerFdir(setObjectId) {
 }
 
 ChildHandlerBase::~ChildHandlerBase() {
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 3879f66fe..4e9eee493 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -6,12 +6,12 @@
 
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
-	ChildHandlerBase(uint32_t ioBoardAddress, object_id_t setObjectId,
-			object_id_t deviceCommunication, uint32_t maxDeviceReplyLen,
-			uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId, uint32_t parent,
-			FailureIsolationBase* customFdir = NULL,
-			uint32_t cmdQueueSize = 20);
+	ChildHandlerBase(object_id_t setObjectId, uint32_t logicalAddress,
+			object_id_t deviceCommunication, Cookie * cookie,
+			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
+			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+			uint32_t parent, FailureIsolationBase* customFdir = nullptr,
+			size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
 
 	virtual ReturnValue_t initialize();
diff --git a/devicehandlers/Cookie.cpp b/devicehandlers/Cookie.cpp
new file mode 100644
index 000000000..f0748b5d5
--- /dev/null
+++ b/devicehandlers/Cookie.cpp
@@ -0,0 +1,24 @@
+/**
+ * @file Cookie.cpp
+ *
+ * @date 23.03.2020
+ */
+#include <framework/devicehandlers/Cookie.h>
+
+//Cookie::Cookie(address_t logicalAddress_, size_t maxReplyLen_):
+//	logicalAddress(logicalAddress_), maxReplyLen(maxReplyLen_){}
+
+Cookie::Cookie(address_t logicalAddress_): logicalAddress(logicalAddress_) {
+}
+
+void Cookie::setMaxReplyLen(size_t maxReplyLen_) {
+	maxReplyLen = maxReplyLen_;
+}
+
+address_t Cookie::getAddress() const {
+	return logicalAddress;
+}
+
+size_t Cookie::getMaxReplyLen() const {
+	return maxReplyLen;
+}
diff --git a/devicehandlers/Cookie.h b/devicehandlers/Cookie.h
index ec22ec3a5..60f20ff19 100644
--- a/devicehandlers/Cookie.h
+++ b/devicehandlers/Cookie.h
@@ -1,5 +1,6 @@
 #ifndef COOKIE_H_
 #define COOKIE_H_
+#include <framework/devicehandlers/DeviceHandlerIF.h>
 
 /**
  * @brief This datatype is used to identify different connection over a single interface
@@ -7,13 +8,27 @@
  * @details
  * To use this class, implement a communication specific child cookie. This cookie
  * can be used in the device communication interface by performing
- * a C++ dynamic cast. The cookie can be used to store all kinds of information
- * about the communication between read and send calls.
+ * a C++ dynamic cast and passing it to a child device handler, which stores
+ * it and passes the Cookie to the communication interface where it can be used
+ * by again performing a dynamic cast.
+ * The cookie can be used to store all kinds of information
+ * about the communication, like slave addresses, communication status,
+ * communication parameters etc.
+ * @ingroup comm
  */
 class Cookie{
 public:
+	Cookie() = default;
+	Cookie(address_t logicalAddress_);
 	virtual ~Cookie(){}
+
+	void setMaxReplyLen(size_t maxReplyLen_);
+
+	address_t getAddress() const;
+	size_t getMaxReplyLen() const;
+private:
+	address_t logicalAddress = 0;
+	size_t maxReplyLen = 0;
 };
 
-
 #endif /* COOKIE_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 1e307b6c0..43aa7965b 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -6,7 +6,12 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 /**
  * @defgroup interfaces Interfaces
- * @brief Communication interfaces for flight software objects
+ * @brief Interfaces for flight software objects
+ */
+
+/**
+ * @defgroup communication comm
+ * @brief Communication software components.
  */
 
 /**
@@ -22,9 +27,12 @@
  *   3. Request reading data from a device
  *   4. Read received data
  *
- *  To identify different connection over a single interface can return so-called cookies to components.
+ *  To identify different connection over a single interface can return
+ *  so-called cookies to components.
  *  The CommunicationMessage message type can be used to extend the functionality of the
  *  ComIF if a separate polling task is required.
+ *  @ingroup interfaces
+ *  @ingroup comm
  */
 class DeviceCommunicationIF: public HasReturnvaluesIF {
 public:
@@ -32,52 +40,12 @@ public:
 
 	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x06);
-	static const ReturnValue_t CANT_CHANGE_REPLY_LEN = MAKE_RETURN_CODE(0x07);
+	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x05);
 
 	virtual ~DeviceCommunicationIF() {}
 
-	/**
-	 * Open a connection. Define a communication specific cookie which can
-	 * be used to store information about the communication.
-	 * The two optional parameter provide additional flexibility to
-	 * set up the communication interface as desired. If there are a lot of
-	 * variables to set, a store ID to the parameters stored in the IPC store
-	 * can also be passed.
-	 *
-	 * @param cookie [out] This data class stores information about the communication.
-	 * @param address Logical device address
-	 * @param maxReplyLen Maximum length of expected reply
-	 * @param comParameter1 Arbitrary parameter which can be used to set up the cookie or comIF.
-	 * @param comParameter2 Arbitrary parameter which can be used to set up the cookie or comIF.
-	 * @return
-	 */
-	virtual ReturnValue_t open(Cookie **cookie, address_t address,
-			uint32_t maxReplyLen, uint32_t comParameter1, uint32_t comParameter2) = 0;
-
-	/**
-	 * Use an existing cookie to open a connection to a new DeviceCommunication.
-	 * The previous connection must not be closed.
-	 *
-	 * @param cookie
-	 * @param address
-	 * @param maxReplyLen
-	 * @return -@c RETURN_OK New communication set up successfully
-	 *         - Everything else: Cookie is unchanged and can be used with
-	 *           previous connection
-	 */
-	virtual ReturnValue_t reOpen(Cookie *cookie, address_t address,
-			uint32_t maxReplyLen, uint32_t comParameter1, uint32_t comParameter2) = 0;
-
-	/**
-	 * Closing call of connection. Don't forget to free memory of cookie.
-	 * @param cookie
-	 */
-	virtual void close(Cookie *cookie) = 0;
-
 	/**
 	 * Called by DHB in the SEND_WRITE doSendWrite().
 	 * This function is used to send data to the physical device
@@ -86,21 +54,29 @@ public:
 	 * @param data
 	 * @param len
 	 * @return -@c RETURN_OK for successfull send
-	 *         -Everything else triggers sending failed event with
-	 *          returnvalue as parameter 1
+	 *         - Everything else triggers sending failed event with
+	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t sendMessage(Cookie *cookie, const uint8_t *data,
-			uint32_t len) = 0;
+	virtual ReturnValue_t sendMessage(Cookie *cookie, const uint8_t * sendData,
+			size_t sendLen) = 0;
 
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return -@c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers sending failed event with
+	 *           returnvalue as parameter 1
+	 */
 	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
 
 	/**
 	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * Instructs the Communication Interface to prepare
+	 * Request a reply.
 	 * @param cookie
 	 * @return
 	 */
-	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie) = 0;
+	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie, size_t requestLen) = 0;
 
 	/**
 	 * Called by DHB in the GET_WRITE doGetRead().
@@ -110,30 +86,11 @@ public:
 	 * @param data
 	 * @param len
 	 * @return @c RETURN_OK for successfull receive
-	 *         Everything else triggers receiving failed with returnvalue as parameter 1
+	 *         - Everything else triggers receiving failed with
+	 *           returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
-			uint32_t *size) = 0;
-
-	virtual ReturnValue_t setAddress(Cookie *cookie, address_t address) = 0;
-
-	virtual address_t getAddress(Cookie *cookie) = 0;
-
-	/**
-	 * Can be used by DeviceHandlerBase getParameter() call to set DeviceComIF parameters
-	 * @param cookie
-	 * @param parameter
-	 * @return
-	 */
-	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter) = 0;
-
-	/**
-	 * Can be used by DeviceHandlerBase getParameter() call to set DeviceComIF parameters
-	 * @param cookie
-	 * @param parameter
-	 * @return
-	 */
-	virtual uint32_t getParameter(Cookie *cookie) = 0;
+			size_t *size) = 0;
 };
 
 #endif /* DEVICECOMMUNICATIONIF_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ca883e837..5834db2f5 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,37 +16,34 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
-		object_id_t setObjectId, uint32_t maxDeviceReplyLen,
-		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
-		SystemObject(setObjectId), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
-		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
-		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-		requestedRawTraffic(0), powerSwitcher(NULL), IPCStore(NULL),
-		deviceCommunicationId(deviceCommunication), communicationInterface(NULL),
-		cookie(NULL), commandQueue(NULL), deviceThermalStatePoolId(thermalStatePoolId),
-		deviceThermalRequestPoolId(thermalRequestPoolId), healthHelper(this, setObjectId),
-		modeHelper(this), parameterHelper(this), childTransitionFailure(RETURN_OK),
-		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
-		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
-		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), logicalAddress(logicalAddress_),
-		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
+DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, address_t logicalAddress_,
+		object_id_t deviceCommunication, Cookie * cookie_, size_t maxReplyLen,
+		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
+		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
+		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
+	    deviceCommunicationId(deviceCommunication), cookie(cookie_),
+		deviceThermalStatePoolId(thermalStatePoolId), deviceThermalRequestPoolId(thermalRequestPoolId),
+		healthHelper(this, setObjectId), modeHelper(this), parameterHelper(this),
+		fdirInstance(fdirInstance), hkSwitcher(this),
+		defaultFDIRUsed(fdirInstance == nullptr), switchOffWasReported(false),
+		executingTask(nullptr), actionHelper(this, nullptr), cookieInfo(),
+		logicalAddress(logicalAddress_), childTransitionDelay(5000),
+		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(SUBMODE_NONE),
+		deviceSwitch(setDeviceSwitch)
 {
+	this->cookie->setMaxReplyLen(maxReplyLen);
 	commandQueue = QueueFactory::instance()->
 			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
-	if (this->fdirInstance == NULL) {
+	if (this->fdirInstance == nullptr) {
 		this->fdirInstance =
 				new DeviceHandlerFailureIsolation(setObjectId, defaultFDIRParentId);
 	}
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-	communicationInterface->close(cookie);
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
 	}
@@ -105,11 +102,11 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return RETURN_FAILED;
 	}
 
-	result = communicationInterface->open(&cookie, logicalAddress,
-			maxDeviceReplyLen, comParameter1, comParameter2);
-	if (result != RETURN_OK) {
-		return result;
-	}
+//	result = communicationInterface->open(&cookie, logicalAddress,
+//			maxDeviceReplyLen, comParameter1, comParameter2);
+//	if (result != RETURN_OK) {
+//		return result;
+//	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == NULL) {
@@ -551,7 +548,7 @@ void DeviceHandlerBase::doGetWrite() {
 
 void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
-	result = communicationInterface->requestReceiveMessage(cookie);
+	result = communicationInterface->requestReceiveMessage(cookie, requestLen);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
 	} else {
@@ -565,10 +562,10 @@ void DeviceHandlerBase::doSendRead() {
 }
 
 void DeviceHandlerBase::doGetRead() {
-	uint32_t receivedDataLen;
+	size_t receivedDataLen;
 	uint8_t *receivedData;
 	DeviceCommandId_t foundId = 0xFFFFFFFF;
-	uint32_t foundLen = 0;
+	size_t foundLen = 0;
 	ReturnValue_t result;
 
 	if (cookieInfo.state != COOKIE_READ_SENT) {
@@ -639,8 +636,8 @@ void DeviceHandlerBase::doGetRead() {
 }
 
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
-		uint8_t * *data, uint32_t * len) {
-	uint32_t lenTmp;
+		uint8_t ** data, size_t * len) {
+	size_t lenTmp;
 
 	if (IPCStore == NULL) {
 		*data = NULL;
@@ -751,20 +748,20 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
-	DeviceCommunicationIF *newCommunication = objectManager->get<
-			DeviceCommunicationIF>(newChannelId);
-
-	if (newCommunication != NULL) {
-		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
-				maxDeviceReplyLen, comParameter1, comParameter2);
-		if (result != RETURN_OK) {
-			return result;
-		}
-		return RETURN_OK;
-	}
-	return RETURN_FAILED;
-}
+//ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
+//	DeviceCommunicationIF *newCommunication = objectManager->get<
+//			DeviceCommunicationIF>(newChannelId);
+//
+//	if (newCommunication != NULL) {
+//		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
+//				maxDeviceReplyLen, comParameter1, comParameter2);
+//		if (result != RETURN_OK) {
+//			return result;
+//		}
+//		return RETURN_OK;
+//	}
+//	return RETURN_FAILED;
+//}
 
 void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 	storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
@@ -1048,12 +1045,13 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
+	case DeviceHandlerMessage::CMD_SWITCH_ADDRESS:
 		if (mode != MODE_OFF) {
 			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
 		} else {
-			result = switchCookieChannel(
-					DeviceHandlerMessage::getIoBoardObjectId(message));
+			// rework in progress
+			//result = switchCookieChannel(
+			//		DeviceHandlerMessage::getIoBoardObjectId(message));
 			if (result == RETURN_OK) {
 				replyReturnvalueToCommand(RETURN_OK);
 			} else {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 868412edf..e9288921d 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -29,7 +29,7 @@ void setStaticFrameworkObjectIds();
 class StorageManagerIF;
 
 /**
- * \defgroup devices Devices
+ * @defgroup devices Devices
  * Contains all devices and the DeviceHandlerBase class.
  */
 
@@ -93,12 +93,11 @@ public:
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
-	DeviceHandlerBase(address_t logicalAddress, object_id_t setObjectId,
-			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-			object_id_t deviceCommunication,
-			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
+	DeviceHandlerBase(object_id_t setObjectId, address_t logicalAddress_,
+			object_id_t deviceCommunication, Cookie* cookie_, size_t maxReplyLen,
+			uint8_t setDeviceSwitch, uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
-			FailureIsolationBase* fdirInstance = NULL, uint32_t cmdQueueSize = 20);
+			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
 
 	/**
 	 * @brief This function is the device handler base core component and is called periodically.
@@ -283,8 +282,8 @@ protected:
 	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
 	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
 	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, uint32_t len,
-			DeviceCommandId_t *foundId, uint32_t *foundLen) = 0;
+	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
 
 	/**
 	 * @brief Interpret a reply from the device.
@@ -412,11 +411,16 @@ protected:
 	/**
 	 * Pointer to the raw packet that will be sent.
 	 */
-	uint8_t *rawPacket;
+	uint8_t *rawPacket = nullptr;
 	/**
 	 * Size of the #rawPacket.
 	 */
-	uint32_t rawPacketLen;
+	size_t rawPacketLen = 0;
+
+	/**
+	 * Size of data to request.
+	 */
+	size_t requestLen = 0;
 
 //	/**
 //	 * This union (or std::variant) type can be used to set comParameters which
@@ -431,8 +435,8 @@ protected:
 //	 * 4 bytes of parameters AND a store ID.
 //	 */
 //	comParameters_t comParameters;
-	uint32_t comParameter1 = 0;
-	uint32_t comParameter2 = 0;
+	// uint32_t comParameter1 = 0;
+	// uint32_t comParameter2 = 0;
 
 	/**
 	 * The mode the device handler is currently in.
@@ -451,12 +455,12 @@ protected:
 	/**
 	 * This is the counter value from performOperation().
 	 */
-	uint8_t pstStep;
+	uint8_t pstStep = 0;
 
 	/**
 	 * This will be used in the RMAP getRead command as expected length, is set by the constructor, can be modiefied at will.
 	 */
-	const uint32_t maxDeviceReplyLen;
+	const uint32_t maxDeviceReplyLen = 0;
 
 	/**
 	 * wiretapping flag:
@@ -474,7 +478,7 @@ protected:
 	 * 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
 	 */
-	MessageQueueId_t defaultRawReceiver;
+	MessageQueueId_t defaultRawReceiver = 0;
 
 	store_address_t storedRawData;
 
@@ -483,19 +487,19 @@ protected:
 	 *
 	 * if #isWiretappingActive all raw communication from and to the device will be sent to this queue
 	 */
-	MessageQueueId_t requestedRawTraffic;
+	MessageQueueId_t requestedRawTraffic = 0;
 
 	/**
 	 * the object used to set power switches
 	 */
-	PowerSwitchIF *powerSwitcher;
+	PowerSwitchIF *powerSwitcher = nullptr;
 
 	/**
 	 * Pointer to the IPCStore.
 	 *
 	 * This caches the pointer received from the objectManager in the constructor.
 	 */
-	StorageManagerIF *IPCStore;
+	StorageManagerIF *IPCStore = nullptr;
 
 	/**
 	 * cached for init
@@ -505,7 +509,7 @@ protected:
 	/**
 	 * Communication object used for device communication
 	 */
-	DeviceCommunicationIF *communicationInterface;
+	DeviceCommunicationIF *communicationInterface = nullptr;
 
 	/**
 	 * Cookie used for communication. This is passed to the communication
@@ -516,7 +520,7 @@ protected:
 	/**
 	 * The MessageQueue used to receive device handler commands and to send replies.
 	 */
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 
 	/**
 	 * this is the datapool variable with the thermal state of the device
@@ -545,9 +549,9 @@ protected:
 	 * Optional Error code
 	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
 	 */
-	ReturnValue_t childTransitionFailure;
+	ReturnValue_t childTransitionFailure = RETURN_OK;
 
-	uint32_t ignoreMissedRepliesCount; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
+	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
 
 	FailureIsolationBase* fdirInstance; //!< Pointer to the used FDIR instance. If not provided by child, default class is instantiated.
 
@@ -962,7 +966,7 @@ private:
 	 *
 	 * Set when setMode() is called.
 	 */
-	uint32_t timeoutStart;
+	uint32_t timeoutStart = 0;
 
 	/**
 	 * Delay for the current mode transition, used for time out
@@ -1084,8 +1088,8 @@ private:
 	 *   - @c RETURN_FAILED IPCStore is NULL
 	 *   - the return value from the IPCStore if it was not @c RETURN_OK
 	 */
-	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
-			uint32_t *len);
+	ReturnValue_t getStorageData(store_address_t storageAddress,
+			uint8_t ** data, size_t * len);
 
 	/**
 	 * set all switches returned by getSwitches()
@@ -1114,7 +1118,7 @@ private:
 	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
 	 *     - @c returnvalues of RMAPChannelIF::isActive()
 	 */
-	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
+	//ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
 	/**
 	 * Handle device handler messages (e.g. commands sent by PUS Service 2)
diff --git a/devicehandlers/DeviceHandlerMessage.cpp b/devicehandlers/DeviceHandlerMessage.cpp
index 58a6d3126..97abcac52 100644
--- a/devicehandlers/DeviceHandlerMessage.cpp
+++ b/devicehandlers/DeviceHandlerMessage.cpp
@@ -47,7 +47,7 @@ void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
 
 void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
 		CommandMessage* message, uint32_t ioBoardIdentifier) {
-	message->setCommand(CMD_SWITCH_IOBOARD);
+	message->setCommand(CMD_SWITCH_ADDRESS);
 	message->setParameter(ioBoardIdentifier);
 }
 
@@ -90,7 +90,7 @@ void DeviceHandlerMessage::clear(CommandMessage* message) {
 		}
 	}
 		/* NO BREAK falls through*/
-	case CMD_SWITCH_IOBOARD:
+	case CMD_SWITCH_ADDRESS:
 	case CMD_WIRETAPPING:
 		message->setCommand(CommandMessage::CMD_NONE);
 		message->setParameter(0);
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index fad0f1b1c..c91bb0a4c 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -28,7 +28,7 @@ public:
 	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::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
+	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
 	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
 
 	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 4905875e7..9bebb597a 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -152,7 +152,7 @@ void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
 	ipcAddress = MemoryMessage::getStoreID(message);
 	const uint8_t* p_data = NULL;
 	uint8_t* dataPointer = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
 	if (returnCode == RETURN_OK) {
 		returnCode = workOnThis->handleMemoryLoad(address, p_data, size,
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index d429f1a07..4ec61ff7a 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -11,7 +11,7 @@
 #include "task.h"
 
 BinarySemaphore::BinarySemaphore() {
-	vSemaphoreCreateBinary(handle);
+	xSemaphoreCreateBinary(handle); // @suppress("Function cannot be resolved")
 	if(handle == NULL) {
 		error << "Binary semaphore creation failure" << std::endl;
 	}
@@ -81,7 +81,7 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 
 void BinarySemaphore::resetSemaphore() {
 	vSemaphoreDelete(handle);
-	vSemaphoreCreateBinary(handle);
+	xSemaphoreCreateBinary(handle);
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 6ebc9e629..e260465ae 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -37,7 +37,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 				ParameterMessage::getParameterId(message));
 
 		const uint8_t *storedStream;
-		uint32_t storedStreamSize;
+		size_t storedStreamSize;
 		result = storage->getData(
 				ParameterMessage::getStoreId(message), &storedStream,
 				&storedStreamSize);
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index f6d5ba8ac..c2fab82b6 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -100,7 +100,7 @@ public:
 	 * @return @c RETURN_OK if data retrieval was successfull
 	 */
 	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
-			uint32_t* size);
+			size_t * size);
 
 	/**
 	 * Modify data by supplying a packet pointer and using that packet pointer
@@ -111,7 +111,7 @@ public:
 	 * @return
 	 */
 	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			uint32_t* size);
+			size_t * size);
 	virtual ReturnValue_t deleteData(store_address_t);
 	virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size,
 			store_address_t* storeId = NULL);
@@ -348,7 +348,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
 
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
-		store_address_t packet_id, const uint8_t** packet_ptr, uint32_t* size) {
+		store_address_t packet_id, const uint8_t** packet_ptr, size_t * size) {
 	uint8_t* tempData = NULL;
 	ReturnValue_t status = modifyData(packet_id, &tempData, size);
 	*packet_ptr = tempData;
@@ -357,7 +357,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
 
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(store_address_t packet_id,
-		uint8_t** packet_ptr, uint32_t* size) {
+		uint8_t** packet_ptr, size_t * size) {
 	ReturnValue_t status = RETURN_FAILED;
 	if (packet_id.pool_index >= NUMBER_OF_POOLS) {
 		return ILLEGAL_STORAGE_ID;
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 575e9caa4..e8d8b413a 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -125,12 +125,12 @@ public:
 	 * 				(e.g. an illegal packet_id was passed).
 	 */
 	virtual ReturnValue_t getData(store_address_t packet_id,
-			const uint8_t** packet_ptr, uint32_t* size) = 0;
+			const uint8_t** packet_ptr, size_t * size) = 0;
 	/**
 	 * Same as above, but not const and therefore modifiable.
 	 */
 	virtual ReturnValue_t modifyData(store_address_t packet_id,
-			uint8_t** packet_ptr, uint32_t* size) = 0;
+			uint8_t** packet_ptr, size_t * size) = 0;
 	/**
 	 * This method reserves an element of \c size.
 	 *
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index e1ec544b0..2d7d9c443 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -162,7 +162,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 	case ModeSequenceMessage::ADD_SEQUENCE: {
 		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
 		const uint8_t *pointer;
-		uint32_t sizeRead;
+		size_t sizeRead;
 		result = IPCStore->getData(
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
@@ -188,7 +188,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 	case ModeSequenceMessage::ADD_TABLE: {
 		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
 		const uint8_t *pointer;
-		uint32_t sizeRead;
+		size_t sizeRead;
 		result = IPCStore->getData(
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index ecd7702e6..878b8f7d5 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -13,7 +13,7 @@ CCSDSDistributor::~CCSDSDistributor() {
 iterator_t CCSDSDistributor::selectDestination() {
 //	debug << "CCSDSDistributor::selectDestination received: " << this->currentMessage.getStorageId().pool_index << ", " << this->currentMessage.getStorageId().packet_index << std::endl;
 	const uint8_t* p_packet = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	//TODO check returncode?
 	this->tcStore->getData( this->currentMessage.getStorageId(), &p_packet, &size );
 	SpacePacketBase current_packet( p_packet );
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 1f31a7638..4bfd0e37e 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -59,7 +59,7 @@ bool TcPacketStored::checkAndSetStore() {
 void TcPacketStored::setStoreAddress(store_address_t setAddress) {
 	this->storeAddress = setAddress;
 	const uint8_t* temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
 	if (this->checkAndSetStore()) {
 		status = this->store->getData(this->storeAddress, &temp_data,
@@ -79,7 +79,7 @@ store_address_t TcPacketStored::getStoreAddress() {
 
 bool TcPacketStored::isSizeCorrect() {
 	const uint8_t* temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
 			&temp_size);
 	if (status == StorageManagerIF::RETURN_OK) {
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index b1c1ec624..bb9326418 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -82,7 +82,7 @@ void TmPacketStored::deletePacket() {
 void TmPacketStored::setStoreAddress(store_address_t setAddress) {
 	storeAddress = setAddress;
 	const uint8_t* temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	if (!checkAndSetStore()) {
 		return;
 	}
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index e402d79eb..6b563f983 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -76,7 +76,7 @@ ReturnValue_t TmTcBridge::handleTm() {
 ReturnValue_t TmTcBridge::readTmQueue() {
 	TmTcMessage message;
 	const uint8_t* data = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
 	{
@@ -127,7 +127,7 @@ ReturnValue_t TmTcBridge::sendStoredTm() {
 				<< (int) fifo.size() << " left to send" << std::endl;
 		store_address_t storeId;
 		const uint8_t* data = NULL;
-		uint32_t size = 0;
+		size_t size = 0;
 		fifo.retrieve(&storeId);
 		result = tmStore->getData(storeId, &data, &size);
 		sendTm(data,size);

From fa058ee6025cfe03e0a60f62ebb744d80b676637 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 23 Mar 2020 18:05:39 +0100
Subject: [PATCH 0127/1774] renamed rmap to com (more generic)

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 devicehandlers/DeviceHandlerBase.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 5834db2f5..4c2ae5684 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -688,7 +688,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 
 //Default child implementations
 
-DeviceHandlerBase::CommunicationAction_t DeviceHandlerBase::getRmapAction() {
+DeviceHandlerBase::CommunicationAction_t DeviceHandlerBase::getComAction() {
 	switch (pstStep) {
 	case 0:
 		return SEND_WRITE;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index e9288921d..3e5881150 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -666,7 +666,7 @@ protected:
 	 *
 	 * @return The Rmap action to execute in this step
 	 */
-	virtual CommunicationAction_t getRmapAction();
+	virtual CommunicationAction_t getComAction();
 
 	/**
 	 * Build the device command to send for raw mode.

From f7bd661e6923713740c77e91c2602caa74e6abe5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 23 Mar 2020 18:08:24 +0100
Subject: [PATCH 0128/1774] small fixes

---
 devicehandlers/DeviceHandlerBase.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4c2ae5684..4b88355ac 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -66,7 +66,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		return RETURN_OK;
 	}
 
-	switch (getRmapAction()) {
+	switch (getComAction()) {
 	case SEND_WRITE:
 		if ((cookieInfo.state == COOKIE_UNUSED)) {
 			buildInternalCommand();
@@ -1050,6 +1050,7 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
 		} else {
 			// rework in progress
+			result = RETURN_OK;
 			//result = switchCookieChannel(
 			//		DeviceHandlerMessage::getIoBoardObjectId(message));
 			if (result == RETURN_OK) {

From b6bf9d71477b3695b1a3dfe7253137c5936c7ebc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 23 Mar 2020 19:09:42 +0100
Subject: [PATCH 0129/1774] to avoid dynamic casting, introuced CookieIF

---
 devicehandlers/AcceptsDeviceResponsesIF.h |  5 ++--
 devicehandlers/ChildHandlerBase.cpp       |  6 ++---
 devicehandlers/ChildHandlerBase.h         |  5 ++--
 devicehandlers/Cookie.cpp                 |  8 ++++---
 devicehandlers/Cookie.h                   | 28 +++++++++++++----------
 devicehandlers/CookieIF.h                 | 25 ++++++++++++++++++++
 devicehandlers/DeviceCommunicationIF.h    |  8 +++----
 devicehandlers/DeviceHandlerBase.cpp      | 26 ++++++++++-----------
 devicehandlers/DeviceHandlerBase.h        | 27 +++++-----------------
 rmap/RMAPCookie.cpp                       |  8 +++----
 rmap/RMAPCookie.h                         |  4 ++--
 11 files changed, 82 insertions(+), 68 deletions(-)
 create mode 100644 devicehandlers/CookieIF.h

diff --git a/devicehandlers/AcceptsDeviceResponsesIF.h b/devicehandlers/AcceptsDeviceResponsesIF.h
index 0eedae889..c811158f6 100644
--- a/devicehandlers/AcceptsDeviceResponsesIF.h
+++ b/devicehandlers/AcceptsDeviceResponsesIF.h
@@ -15,9 +15,8 @@ public:
 	/**
 	 * Default empty virtual destructor.
 	 */
-	virtual ~AcceptsDeviceResponsesIF() {
-}
-virtual MessageQueueId_t getDeviceQueue() = 0;
+	virtual ~AcceptsDeviceResponsesIF() {}
+	virtual MessageQueueId_t getDeviceQueue() = 0;
 };
 
 #endif /* ACCEPTSDEVICERESPONSESIF_H_ */
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index a0630fc64..ac0b24384 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -2,12 +2,12 @@
 #include <framework/devicehandlers/ChildHandlerBase.h>
 #include <framework/subsystem/SubsystemBase.h>
 
-ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId, address_t logicalAddress,
-		object_id_t deviceCommunication, Cookie * cookie,
+ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
+		object_id_t deviceCommunication, CookieIF * cookie,
 		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		uint32_t parent, FailureIsolationBase* customFdir, size_t cmdQueueSize) :
-		DeviceHandlerBase(setObjectId, logicalAddress, deviceCommunication, cookie,
+		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
 			maxDeviceReplyLen, setDeviceSwitch,  thermalStatePoolId,
 			thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir),
 			cmdQueueSize),
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 4e9eee493..493b22ee2 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -6,9 +6,8 @@
 
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
-	ChildHandlerBase(object_id_t setObjectId, uint32_t logicalAddress,
-			object_id_t deviceCommunication, Cookie * cookie,
-			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
+	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+			CookieIF * cookie, uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 			uint32_t parent, FailureIsolationBase* customFdir = nullptr,
 			size_t cmdQueueSize = 20);
diff --git a/devicehandlers/Cookie.cpp b/devicehandlers/Cookie.cpp
index f0748b5d5..05b9425ca 100644
--- a/devicehandlers/Cookie.cpp
+++ b/devicehandlers/Cookie.cpp
@@ -5,12 +5,12 @@
  */
 #include <framework/devicehandlers/Cookie.h>
 
-//Cookie::Cookie(address_t logicalAddress_, size_t maxReplyLen_):
-//	logicalAddress(logicalAddress_), maxReplyLen(maxReplyLen_){}
-
 Cookie::Cookie(address_t logicalAddress_): logicalAddress(logicalAddress_) {
 }
 
+void Cookie::setAddress(address_t logicalAddress_) {
+	logicalAddress = logicalAddress_;
+}
 void Cookie::setMaxReplyLen(size_t maxReplyLen_) {
 	maxReplyLen = maxReplyLen_;
 }
@@ -22,3 +22,5 @@ address_t Cookie::getAddress() const {
 size_t Cookie::getMaxReplyLen() const {
 	return maxReplyLen;
 }
+
+
diff --git a/devicehandlers/Cookie.h b/devicehandlers/Cookie.h
index 60f20ff19..d76facc0d 100644
--- a/devicehandlers/Cookie.h
+++ b/devicehandlers/Cookie.h
@@ -1,31 +1,35 @@
 #ifndef COOKIE_H_
 #define COOKIE_H_
-#include <framework/devicehandlers/DeviceHandlerIF.h>
+#include <framework/devicehandlers/CookieIF.h>
 
 /**
  * @brief This datatype is used to identify different connection over a single interface
  *        (like RMAP or I2C)
  * @details
- * To use this class, implement a communication specific child cookie. This cookie
- * can be used in the device communication interface by performing
- * a C++ dynamic cast and passing it to a child device handler, which stores
- * it and passes the Cookie to the communication interface where it can be used
- * by again performing a dynamic cast.
+ * To use this class, implement a communication specific child cookie which
+ * inherits Cookie. Cookie instances are created in config/ Factory.cpp by calling
+ * CookieIF* childCookie = new ChildCookie(...).´
+ *
+ * This cookie is then passed to the child device handlers, which stores the
+ * pointer and passes it to the communication interface functions.
+ *
  * The cookie can be used to store all kinds of information
  * about the communication, like slave addresses, communication status,
  * communication parameters etc.
+ *
  * @ingroup comm
  */
-class Cookie{
+class Cookie: public CookieIF {
 public:
-	Cookie() = default;
+	Cookie();
 	Cookie(address_t logicalAddress_);
-	virtual ~Cookie(){}
+	virtual ~Cookie() {};
 
-	void setMaxReplyLen(size_t maxReplyLen_);
+	virtual void setAddress(address_t logicalAddres_);
+	virtual void setMaxReplyLen(size_t maxReplyLen_);
 
-	address_t getAddress() const;
-	size_t getMaxReplyLen() const;
+	virtual address_t getAddress() const;
+	virtual size_t getMaxReplyLen() const;
 private:
 	address_t logicalAddress = 0;
 	size_t maxReplyLen = 0;
diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
new file mode 100644
index 000000000..3e08709bd
--- /dev/null
+++ b/devicehandlers/CookieIF.h
@@ -0,0 +1,25 @@
+/**
+ * @file CookieIF.h
+ *
+ * @date 23 Mar 2020
+ */
+
+#ifndef FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_
+#define FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_
+#include <framework/devicehandlers/DeviceHandlerIF.h>
+
+class CookieIF {
+public:
+	/**
+	 * Default empty virtual destructor.
+	 */
+	virtual ~CookieIF() {};
+
+	virtual void setAddress(address_t logicalAddress_) = 0;
+	virtual address_t getAddress() const = 0;
+
+	virtual void setMaxReplyLen(size_t maxReplyLen_) = 0;
+	virtual size_t getMaxReplyLen() const = 0;
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 43aa7965b..6f2715041 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -57,7 +57,7 @@ public:
 	 *         - Everything else triggers sending failed event with
 	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t sendMessage(Cookie *cookie, const uint8_t * sendData,
+	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
 			size_t sendLen) = 0;
 
 	/**
@@ -68,7 +68,7 @@ public:
 	 * 		   - Everything else triggers sending failed event with
 	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
 
 	/**
 	 * Called by DHB in the SEND_WRITE doSendRead().
@@ -76,7 +76,7 @@ public:
 	 * @param cookie
 	 * @return
 	 */
-	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie, size_t requestLen) = 0;
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
 
 	/**
 	 * Called by DHB in the GET_WRITE doGetRead().
@@ -89,7 +89,7 @@ public:
 	 *         - Everything else triggers receiving failed with
 	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
 			size_t *size) = 0;
 };
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4b88355ac..33e441460 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,23 +16,22 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, address_t logicalAddress_,
-		object_id_t deviceCommunication, Cookie * cookie_, size_t maxReplyLen,
-		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+		CookieIF * comCookie_, size_t maxReplyLen, uint8_t setDeviceSwitch,
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-	    deviceCommunicationId(deviceCommunication), cookie(cookie_),
+	    deviceCommunicationId(deviceCommunication), comCookie(comCookie_),
 		deviceThermalStatePoolId(thermalStatePoolId), deviceThermalRequestPoolId(thermalRequestPoolId),
 		healthHelper(this, setObjectId), modeHelper(this), parameterHelper(this),
 		fdirInstance(fdirInstance), hkSwitcher(this),
 		defaultFDIRUsed(fdirInstance == nullptr), switchOffWasReported(false),
 		executingTask(nullptr), actionHelper(this, nullptr), cookieInfo(),
-		logicalAddress(logicalAddress_), childTransitionDelay(5000),
-		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(SUBMODE_NONE),
-		deviceSwitch(setDeviceSwitch)
+		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
 {
-	this->cookie->setMaxReplyLen(maxReplyLen);
+	this->comCookie->setMaxReplyLen(maxReplyLen);
 	commandQueue = QueueFactory::instance()->
 			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
@@ -44,6 +43,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, address_t logicalA
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
+	delete comCookie;
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
 	}
@@ -506,7 +506,7 @@ void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 void DeviceHandlerBase::doSendWrite() {
 	if (cookieInfo.state == COOKIE_WRITE_READY) {
 
-		ReturnValue_t result = communicationInterface->sendMessage(cookie,
+		ReturnValue_t result = communicationInterface->sendMessage(comCookie,
 				rawPacket, rawPacketLen);
 
 		if (result == RETURN_OK) {
@@ -527,7 +527,7 @@ void DeviceHandlerBase::doGetWrite() {
 		return;
 	}
 	cookieInfo.state = COOKIE_UNUSED;
-	ReturnValue_t result = communicationInterface->getSendSuccess(cookie);
+	ReturnValue_t result = communicationInterface->getSendSuccess(comCookie);
 	if (result == RETURN_OK) {
 		if (wiretappingMode == RAW) {
 			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
@@ -548,7 +548,7 @@ void DeviceHandlerBase::doGetWrite() {
 
 void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
-	result = communicationInterface->requestReceiveMessage(cookie, requestLen);
+	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
 	} else {
@@ -575,7 +575,7 @@ void DeviceHandlerBase::doGetRead() {
 
 	cookieInfo.state = COOKIE_UNUSED;
 
-	result = communicationInterface->readReceivedMessage(cookie, &receivedData,
+	result = communicationInterface->readReceivedMessage(comCookie, &receivedData,
 			&receivedDataLen);
 
 	if (result != RETURN_OK) {
@@ -1277,7 +1277,7 @@ void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t obje
 }
 
 uint32_t DeviceHandlerBase::getLogicalAddress() {
-	return logicalAddress;
+	return this->comCookie->getAddress();
 }
 
 void DeviceHandlerBase::performOperationHook() {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3e5881150..05be2d458 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -17,6 +17,7 @@
 #include <framework/tasks/ExecutableObjectIF.h>
 #include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
 #include <framework/datapool/HkSwitchHelper.h>
+#include <framework/devicehandlers/CookieIF.h>
 #include <framework/serialize/SerialFixedArrayListAdapter.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/tasks/PeriodicTaskIF.h>
@@ -93,9 +94,9 @@ public:
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
-	DeviceHandlerBase(object_id_t setObjectId, address_t logicalAddress_,
-			object_id_t deviceCommunication, Cookie* cookie_, size_t maxReplyLen,
-			uint8_t setDeviceSwitch, uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
+	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+			CookieIF * comCookie_, size_t maxReplyLen, uint8_t setDeviceSwitch,
+			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
 
@@ -422,22 +423,6 @@ protected:
 	 */
 	size_t requestLen = 0;
 
-//	/**
-//	 * This union (or std::variant) type can be used to set comParameters which
-//	 * are passed in the open() and reOpen() calls to the communication
-//	 * interface
-//	 * TODO: I don't know if we should use C++17 features but if we do we propably
-//	 *		 should also write a function to get either a storeId handle
-//	 *		 or an array handle so these values can be set conveniently.
-//	 * The good think is that if there are many parameters, they can
-//	 * be stored in the IPC pool. But maybe two uint32_t parameters are enough.
-//	 * Simple = Good. It is downwards compatible and one can still store
-//	 * 4 bytes of parameters AND a store ID.
-//	 */
-//	comParameters_t comParameters;
-	// uint32_t comParameter1 = 0;
-	// uint32_t comParameter2 = 0;
-
 	/**
 	 * The mode the device handler is currently in.
 	 *
@@ -515,7 +500,7 @@ protected:
 	 * Cookie used for communication. This is passed to the communication
 	 * interface.
 	 */
-	Cookie *cookie;
+	CookieIF *comCookie;
 
 	/**
 	 * The MessageQueue used to receive device handler commands and to send replies.
@@ -959,7 +944,7 @@ private:
 	/**
 	* cached from ctor for initialize()
 	*/
-	const uint32_t logicalAddress;
+	//const uint32_t logicalAddress = 0;
 
 	/**
 	 * Used for timing out mode transitions.
diff --git a/rmap/RMAPCookie.cpp b/rmap/RMAPCookie.cpp
index 5bf2ba9f5..84e407ba2 100644
--- a/rmap/RMAPCookie.cpp
+++ b/rmap/RMAPCookie.cpp
@@ -93,10 +93,10 @@ RMAPCookie::~RMAPCookie() {
 
 }
 
-uint32_t RMAPCookie::getMaxReplyLen() const {
-	return maxReplyLen;
-}
-
+//uint32_t RMAPCookie::getMaxReplyLen() const {
+//	return maxReplyLen;
+//}
+//
 void RMAPCookie::setMaxReplyLen(uint32_t maxReplyLen) {
 	this->maxReplyLen = maxReplyLen;
 }
diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h
index c091ba182..cf033bae8 100644
--- a/rmap/RMAPCookie.h
+++ b/rmap/RMAPCookie.h
@@ -6,7 +6,7 @@
 
 class RMAPChannelIF;
 
-class RMAPCookie : public Cookie{
+class RMAPCookie : public Cookie {
 public:
 	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
 	RMAPCookie();
@@ -28,7 +28,7 @@ public:
 	void setCommandMask(uint8_t commandMask);
 	uint8_t getCommandMask();
 
-	uint32_t getMaxReplyLen() const;
+	//size_t getMaxReplyLen() const;
 	void setMaxReplyLen(uint32_t maxReplyLen);
 
 	uint16_t getTransactionIdentifier() const;

From f7b7e10d05224dcd6ab5e2c0c4e778ce5585c544 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 23 Mar 2020 19:14:36 +0100
Subject: [PATCH 0130/1774] date format changed

---
 devicehandlers/CookieIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index 3e08709bd..d8781cd73 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -1,7 +1,7 @@
 /**
  * @file CookieIF.h
  *
- * @date 23 Mar 2020
+ * @date 23.03.2020
  */
 
 #ifndef FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_

From 7e8d92f956220734c4d65dc026550595cfbf577f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 24 Mar 2020 00:22:17 +0100
Subject: [PATCH 0131/1774] replaced std::list by std::set for fixedSlotSequen

---
 devicehandlers/DeviceHandlerBase.h   |  8 ++-
 devicehandlers/DeviceHandlerIF.h     | 22 --------
 devicehandlers/FixedSequenceSlot.h   | 19 ++++---
 devicehandlers/FixedSlotSequence.cpp | 84 ++++++++++++++--------------
 devicehandlers/FixedSlotSequence.h   | 48 ++++++++++------
 osal/FreeRTOS/FixedTimeslotTask.cpp  |  4 +-
 tasks/FixedTimeslotTaskIF.h          |  4 +-
 7 files changed, 95 insertions(+), 94 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 05be2d458..3bfb07aec 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -69,6 +69,12 @@ class StorageManagerIF;
  *
  * Other important virtual methods with a default implementation
  * are the getTransitionDelayMs() function and the getSwitches() function.
+ * Please ensure that getSwitches() returns DeviceHandlerIF::NO_SWITCHES if
+ * power switches are not implemented yet. Otherwise, the device handler will
+ * not transition to MODE_ON, even if setMode(MODE_ON) is called.
+ * If a transition to MODE_ON is desired without commanding, override the
+ * intialize() function and call setMode(_MODE_START_UP) before calling
+ * DeviceHandlerBase::initialize().
  *
  * @ingroup devices
  */
@@ -349,7 +355,7 @@ protected:
 	 * @param[out] numberOfSwitches length of returned array
 	 * @return
 	 *      - @c RETURN_OK if the parameters were set
-	 *      - @c RETURN_FAILED if no switches exist
+	 *      - @c NO_SWITCH or any other returnvalue if no switches exist
 	 */
 	virtual ReturnValue_t getSwitches(const uint8_t **switches,
 			uint8_t *numberOfSwitches);
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index c453e7e87..f0f7adfdc 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -7,33 +7,11 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
 
-#if __cplusplus >= 201703L
-#include <array>
-#include <variant>
-#endif
-
 /**
  * Physical address type
  */
 typedef uint32_t address_t;
 
-///**
-// * This type safe union cold be used if C++17 or newer is used to transfer
-// * comIF settings to the communication interface object.
-// */
-//
-//#if __cplusplus >= 201703L
-//using comParameterArray_t = std::array<uint8_t, 4>;
-//using comParameters_t = std::variant<store_address_t, comParameterArray_t>;
-//#else
-//using comParameters_t = union comParameters {
-//		comParameters() = default;
-//		comParameters(uint32_t initValue): storeIdRaw(initValue) {}
-//		uint32_t storeIdRaw;
-//		uint8_t comParameter[4];
-//	};
-//#endif
-
 /**
  * This is the Interface used to communicate with a device handler.
  *
diff --git a/devicehandlers/FixedSequenceSlot.h b/devicehandlers/FixedSequenceSlot.h
index 0ed285b38..b3bac08f9 100644
--- a/devicehandlers/FixedSequenceSlot.h
+++ b/devicehandlers/FixedSequenceSlot.h
@@ -19,29 +19,34 @@ class PeriodicTaskIF;
  */
 class FixedSequenceSlot {
 public:
-			FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs, int8_t setSequenceId, PeriodicTaskIF* executingTask );
+	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
+			int8_t setSequenceId, PeriodicTaskIF* executingTask );
 	virtual ~FixedSequenceSlot();
 
 	/**
-	 * \brief	\c handler identifies which device handler object is executed in this slot.
+	 * @brief	Handler identifies which device handler object is executed in this slot.
 	 */
 	ExecutableObjectIF*	handler;
 
 	/**
-	 * \brief	This attribute defines when a device handler object is executed.
+	 * @brief	This attribute defines when a device handler object is executed.
 	 *
-	 * \details	The pollingTime attribute identifies the time the handler is executed in ms. It must be
-	 * 			smaller than the period length of the polling sequence, which is ensured by automated calculation
-	 * 			from a database.
+	 * @details	The pollingTime attribute identifies the time the handler is executed in ms.
+	 * 			It must be smaller than the period length of the polling sequence.
 	 */
 	uint32_t	pollingTimeMs;
 
 	/**
 	 * \brief	This value defines the type of device communication.
 	 *
-	 * \details	The state of this value decides what communication routine is called in the PST executable or the device handler object.
+	 * \details	The state of this value decides what communication routine is
+	 * 			called in the PST executable or the device handler object.
 	 */
 	uint8_t			opcode;
+
+	bool operator <(const FixedSequenceSlot & fixedSequenceSlot) const {
+		return pollingTimeMs < fixedSequenceSlot.pollingTimeMs;
+	}
 };
 
 
diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index a65dd929e..f01b13992 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -2,22 +2,23 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
-		lengthMs(setLengthMs) {
+		slotLengthMs(setLengthMs) {
 	current = slotList.begin();
 }
 
 FixedSlotSequence::~FixedSlotSequence() {
-	std::list<FixedSequenceSlot*>::iterator slotIt;
-	//Iterate through slotList and delete all entries.
-	slotIt = this->slotList.begin();
-	while (slotIt != this->slotList.end()) {
-		delete (*slotIt);
-		slotIt++;
-	}
+	// This should call the destructor on each list entry.
+	slotList.clear();
+//	SlotListIter slotListIter = this->slotList.begin();
+//	//Iterate through slotList and delete all entries.
+//	while (slotListIter != this->slotList.end()) {
+//		delete (*slotIt);
+//		slotIt++;
+//	}
 }
 
 void FixedSlotSequence::executeAndAdvance() {
-	(*this->current)->handler->performOperation((*this->current)->opcode);
+	current->handler->performOperation(current->opcode);
 //	if (returnValue != RETURN_OK) {
 //		this->sendErrorMessage( returnValue );
 //	}
@@ -31,53 +32,50 @@ void FixedSlotSequence::executeAndAdvance() {
 
 uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
 	uint32_t oldTime;
-	std::list<FixedSequenceSlot*>::iterator it;
-	it = current;
+	SlotListIter slotListIter = current;
 	// Get the pollingTimeMs of the current slot object.
-	oldTime = (*it)->pollingTimeMs;
+	oldTime = slotListIter->pollingTimeMs;
 	// Advance to the next object.
-	it++;
+	slotListIter++;
 	// Find the next interval which is not 0.
-	while (it != slotList.end()) {
-		if (oldTime != (*it)->pollingTimeMs) {
-			return (*it)->pollingTimeMs - oldTime;
+	while (slotListIter != slotList.end()) {
+		if (oldTime != slotListIter->pollingTimeMs) {
+			return slotListIter->pollingTimeMs - oldTime;
 		} else {
-			it++;
+			slotListIter++;
 		}
 	}
 	// If the list end is reached (this is definitely an interval != 0),
 	// the interval is calculated by subtracting the remaining time of the PST
 	// and adding the start time of the first handler in the list.
-	it = slotList.begin();
-	return lengthMs - oldTime + (*it)->pollingTimeMs;
+	slotListIter = slotList.begin();
+	return slotLengthMs - oldTime + slotListIter->pollingTimeMs;
 }
 
 uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
 	uint32_t currentTime;
-	std::list<FixedSequenceSlot*>::iterator it;
-	it = current;
+	SlotListIter slotListIter = current;
 	// Get the pollingTimeMs of the current slot object.
-	currentTime = (*it)->pollingTimeMs;
+	currentTime = slotListIter->pollingTimeMs;
 
 	//if it is the first slot, calculate difference to last slot
-	if (it == slotList.begin()){
-		return lengthMs - (*(--slotList.end()))->pollingTimeMs + currentTime;
+	if (slotListIter == slotList.begin()){
+		return slotLengthMs - (--slotList.end())->pollingTimeMs + currentTime;
 	}
 	// get previous slot
-	it--;
+	slotListIter--;
 
-	return currentTime - (*it)->pollingTimeMs;
+	return currentTime - slotListIter->pollingTimeMs;
 }
 
 bool FixedSlotSequence::slotFollowsImmediately() {
-	uint32_t currentTime = (*current)->pollingTimeMs;
-	std::list<FixedSequenceSlot*>::iterator it;
-	it = this->current;
+	uint32_t currentTime = current->pollingTimeMs;
+	SlotListIter fixedSequenceIter = this->current;
 	// Get the pollingTimeMs of the current slot object.
-	if (it == slotList.begin())
+	if (fixedSequenceIter == slotList.begin())
 		return false;
-	it--;
-	if ((*it)->pollingTimeMs == currentTime) {
+	fixedSequenceIter--;
+	if (fixedSequenceIter->pollingTimeMs == currentTime) {
 		return true;
 	} else {
 		return false;
@@ -85,29 +83,30 @@ bool FixedSlotSequence::slotFollowsImmediately() {
 }
 
 uint32_t FixedSlotSequence::getLengthMs() const {
-	return this->lengthMs;
+	return this->slotLengthMs;
 }
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
-	//Iterate through slotList and check successful creation. Checks if timing is ok (must be ascending) and if all handlers were found.
+	// Iterate through slotList and check successful creation.
+	// Checks if timing is ok (must be ascending) and if all handlers were found.
 	auto slotIt = slotList.begin();
 	uint32_t count = 0;
 	uint32_t time = 0;
 	while (slotIt != slotList.end()) {
-		if ((*slotIt)->handler == NULL) {
+		if (slotIt->handler == NULL) {
 			error << "FixedSlotSequene::initialize: ObjectId does not exist!"
 					<< std::endl;
 			count++;
-		} else if ((*slotIt)->pollingTimeMs < time) {
+		} else if (slotIt->pollingTimeMs < time) {
 			error << "FixedSlotSequence::initialize: Time: "
-					<< (*slotIt)->pollingTimeMs
+					<< slotIt->pollingTimeMs
 					<< " is smaller than previous with " << time << std::endl;
 			count++;
 		} else {
-			//All ok, print slot.
-//			(*slotIt)->print();
+			// All ok, print slot.
+			// (*slotIt)->print();
 		}
-		time = (*slotIt)->pollingTimeMs;
+		time = slotIt->pollingTimeMs;
 		slotIt++;
 	}
 	if (count > 0) {
@@ -118,8 +117,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 
 void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
 		int8_t executionStep, PeriodicTaskIF* executingTask) {
-	this->slotList.push_back(
-			new FixedSequenceSlot(componentId, slotTimeMs, executionStep,
-					executingTask));
+	this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs, executionStep,
+			executingTask));
 	this->current = slotList.begin();
 }
diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h
index d72de9131..974dbb2bd 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -4,11 +4,15 @@
 #include <framework/devicehandlers/FixedSequenceSlot.h>
 #include <framework/objectmanager/SystemObject.h>
 #include <list>
+#include <set>
+
+using SlotList = std::set<FixedSequenceSlot>;
+using SlotListIter = std::set<FixedSequenceSlot>::iterator;
 
 /**
- * \brief	This class is the representation of a Polling Sequence Table in software.
+ * @brief	This class is the representation of a Polling Sequence Table in software.
  *
- * \details	The FixedSlotSequence object maintains the dynamic execution of device handler objects.
+ * @details	The FixedSlotSequence object maintains the dynamic execution of device handler objects.
  * 			The main idea is to create a list of device handlers, to announce all handlers to the
  * 			polling sequence and to maintain a list of polling slot objects. This slot list represents the
  * 			Polling Sequence Table in software. Each polling slot contains information to indicate when and
@@ -19,29 +23,37 @@
 class FixedSlotSequence {
 public:
 
+
 	/**
-	 * \brief	The constructor of the FixedSlotSequence object.
+	 * @brief	The constructor of the FixedSlotSequence object.
 	 *
-	 * \details	The constructor takes two arguments, the period length and the init function.
+	 * @details	The constructor takes two arguments, the period length and the init function.
 	 *
-	 * \param	setLength	The period length, expressed in ms.
+	 * @param	setLength	The period length, expressed in ms.
 	 */
 	FixedSlotSequence(uint32_t setLengthMs);
 
 	/**
-	 * \brief	The destructor of the FixedSlotSequence object.
+	 * @brief	The destructor of the FixedSlotSequence object.
 	 *
-	 * \details	The destructor frees all allocated memory by iterating through the slotList
+	 * @details	The destructor frees all allocated memory by iterating through the slotList
 	 *  		and deleting all allocated resources.
 	 */
 	virtual ~FixedSlotSequence();
 
 	/**
-	 * \brief	This is a method to add an PollingSlot object to slotList.
+	 * @brief	This is a method to add an PollingSlot object to slotList.
 	 *
-	 * \details	Here, a polling slot object is added to the slot list. It is appended
+	 * @details	Here, a polling slot object is added to the slot list. It is appended
 	 * 			to the end of the list. The list is currently NOT reordered.
 	 * 			Afterwards, the iterator current is set to the beginning of the list.
+	 * 	@param Object ID of the object to add
+	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
+	 * 				   will be called inside the slot period.
+	 * 	@param setSequenceId ID which can be used to distinguish
+	 * 	                     different task operations
+	 * 	@param
+	 * 	@param
 	 */
 	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
 			PeriodicTaskIF* executingTask);
@@ -75,12 +87,12 @@ public:
 	uint32_t getIntervalToPreviousSlotMs();
 
 	/**
-	 * \brief	This method returns the length of this FixedSlotSequence instance.
+	 * @brief	This method returns the length of this FixedSlotSequence instance.
 	 */
 	uint32_t getLengthMs() const;
 
 	/**
-	 * \brief	The method to execute the device handler entered in the current OPUSPollingSlot object.
+	 * \brief	The method to execute the device handler entered in the current PollingSlot object.
 	 *
 	 * \details	Within this method the device handler object to be executed is chosen by looking up the
 	 * 			handler address of the current slot in the handlerMap. Either the device handler's
@@ -91,17 +103,17 @@ public:
 	void executeAndAdvance();
 
 	/**
-	 * \brief	An iterator that indicates the current polling slot to execute.
+	 * @brief	An iterator that indicates the current polling slot to execute.
 	 *
-	 * \details	This is an iterator for slotList and always points to the polling slot which is executed next.
+	 * @details	This is an iterator for slotList and always points to the polling slot which is executed next.
 	 */
-	std::list<FixedSequenceSlot*>::iterator current;
+	SlotListIter current;
 
-	ReturnValue_t checkSequence() const;
+	virtual ReturnValue_t checkSequence() const;
 protected:
 
 	/**
-	 * \brief	This list contains all OPUSPollingSlot objects, defining order and execution time of the
+	 * @brief	This list contains all PollingSlot objects, defining order and execution time of the
 	 * 			device handler objects.
 	 *
 	 * @details	The slot list is a std:list object that contains all created PollingSlot instances.
@@ -109,9 +121,9 @@ protected:
 	 * 			By iterating through this list the polling sequence is executed. Two entries with identical
 	 * 			polling times are executed immediately one after another.
 	 */
-	std::list<FixedSequenceSlot*> slotList;
+	SlotList slotList;
 
-	uint32_t lengthMs;
+	uint32_t slotLengthMs;
 };
 
 #endif /* FIXEDSLOTSEQUENCE_H_ */
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 604a10b86..71e166a52 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -80,10 +80,10 @@ 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.
-	std::list<FixedSequenceSlot*>::iterator it = pst.current;
+	SlotListIter slotListIter = pst.current;
 
 	//The start time for the first entry is read.
-	uint32_t intervalMs = (*it)->pollingTimeMs;
+	uint32_t intervalMs = slotListIter->pollingTimeMs;
 	TickType_t interval = pdMS_TO_TICKS(intervalMs);
 
 	TickType_t xLastWakeTime;
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index 3a3582fbc..d29801841 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -5,11 +5,13 @@
 #include <framework/tasks/PeriodicTaskIF.h>
 
 /**
- * Following the same principle as the base class IF. This is the interface for a Fixed timeslot task
+ * @brief Following the same principle as the base class IF.
+ *        This is the interface for a Fixed timeslot task
  */
 class FixedTimeslotTaskIF : public PeriodicTaskIF {
 public:
 	virtual ~FixedTimeslotTaskIF() {}
+
 	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep) = 0;
 	virtual ReturnValue_t checkSequence() const = 0;
 };

From ea49d88c4be5929208192fd86d9f2ccf99889cb8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 24 Mar 2020 14:21:57 +0100
Subject: [PATCH 0132/1774] moved all return values to DH IF

---
 action/HasActionsIF.h                |  7 +--
 datapool/DataPoolAdmin.cpp           |  2 +-
 datapool/DataPoolAdmin.h             |  4 +-
 devicehandlers/DeviceHandlerBase.cpp | 22 ++++++---
 devicehandlers/DeviceHandlerBase.h   | 49 ++++++++++---------
 devicehandlers/DeviceHandlerIF.h     | 73 ++++++++++++++++------------
 returnvalues/HasReturnvaluesIF.h     |  8 +--
 7 files changed, 92 insertions(+), 73 deletions(-)

diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 4d66ad1f6..12ecb89a8 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -44,10 +44,11 @@ public:
 	/**
 	 * Execute or initialize the execution of a certain function.
 	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to be done.
-	 * When needing more steps, return RETURN_OK and issue steps and completion manually. One "step failed" or completion report must
-	 * be issued!
+	 * When needing more steps, return RETURN_OK and issue steps and completion manually.
+	 * One "step failed" or completion report must be issued!
 	 */
-	virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+			const uint8_t* data, size_t size) = 0;
 };
 
 
diff --git a/datapool/DataPoolAdmin.cpp b/datapool/DataPoolAdmin.cpp
index 99d2b51b2..e66a44e96 100644
--- a/datapool/DataPoolAdmin.cpp
+++ b/datapool/DataPoolAdmin.cpp
@@ -26,7 +26,7 @@ MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
 }
 
 ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
 	if (actionId != SET_VALIDITY) {
 		return INVALID_ACTION_ID;
 	}
diff --git a/datapool/DataPoolAdmin.h b/datapool/DataPoolAdmin.h
index 448d78fbc..dffcd4625 100644
--- a/datapool/DataPoolAdmin.h
+++ b/datapool/DataPoolAdmin.h
@@ -33,8 +33,8 @@ public:
 	ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size,
 			uint8_t** dataPointer, uint8_t* copyHere);
 
-	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
+	virtual ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
 
 	//not implemented as ParameterHelper is no used
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 33e441460..ebb361d97 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -811,9 +811,9 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		iter = deviceReplyMap.find(command->first);
 	}
 	if (iter != deviceReplyMap.end()) {
-		DeviceReplyInfo *info = &(iter->second);
-		info->delayCycles = info->maxDelayCycles;
-		info->command = command;
+		DeviceReplyInfo & info = iter->second;
+		info.delayCycles = info.maxDelayCycles;
+		info.command = command;
 		command->second.expectedReplies = expectedReplies;
 		return RETURN_OK;
 	} else {
@@ -1056,7 +1056,7 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 			if (result == RETURN_OK) {
 				replyReturnvalueToCommand(RETURN_OK);
 			} else {
-				replyReturnvalueToCommand(CANT_SWITCH_IOBOARD);
+				replyReturnvalueToCommand(CANT_SWITCH_ADDRESS);
 			}
 		}
 		return RETURN_OK;
@@ -1138,11 +1138,15 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 }
 
 ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
 	ReturnValue_t result = acceptExternalDeviceCommands();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
+	if(size == 0) {
+		return NO_COMMAND_DATA;
+	}
+
 	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
 	if (iter == deviceCommandMap.end()) {
 		result = COMMAND_NOT_SUPPORTED;
@@ -1161,7 +1165,7 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
 }
 
 void DeviceHandlerBase::buildInternalCommand(void) {
-//Neither Raw nor Direct could build a command
+	// Neither Raw nor Direct could build a command
 	ReturnValue_t result = NOTHING_TO_SEND;
 	DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
 	if (mode == MODE_NORMAL) {
@@ -1179,12 +1183,13 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 	} else {
 		return;
 	}
+
 	if (result == NOTHING_TO_SEND) {
 		return;
 	}
 	if (result == RETURN_OK) {
-		DeviceCommandMap::iterator iter = deviceCommandMap.find(
-				deviceCommandId);
+		DeviceCommandMap::iterator iter =
+				deviceCommandMap.find(deviceCommandId);
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
@@ -1199,6 +1204,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 			cookieInfo.state = COOKIE_WRITE_READY;
 		}
 	}
+
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
 	}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3bfb07aec..5faaa8e01 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -197,8 +197,9 @@ protected:
 	 *
 	 * @param[out] id the device command id that has been built
 	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c RETURN_OK when no command is to be sent
+	 *    - @c RETURN_OK to send command after setting #rawPacket and #rawPacketLen.
+	 *    - @c NOTHING_TO_SEND when no command is to be sent.
+	 *    - Anything else triggers an even with the returnvalue as a parameter.
 	 */
 	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
 
@@ -216,21 +217,25 @@ protected:
 	 * @param[out] id the device command id built
 	 * @return
 	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c RETURN_OK when no command is to be sent
+	 *    - @c NOTHING_TO_SEND when no command is to be sent
+	 *    - Anything else triggers an even with the returnvalue as a parameter
 	 */
 	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
 
 	/**
-	 * Build a device command packet from data supplied by a direct command.
+	 * @brief Build a device command packet from data supplied by a direct command.
 	 *
+	 * @details
 	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
+	 * The existence of the command in the command map and the command size check
+	 * against 0 are done by the base class.
 	 *
 	 * @param deviceCommand the command to build, already checked against deviceCommandMap
 	 * @param commandData pointer to the data from the direct command
 	 * @param commandDataLen length of commandData
 	 * @return
-	 *     - @c RETURN_OK when #rawPacket is valid
-	 *     - @c RETURN_FAILED when #rawPacket is invalid and no data should be sent
+	 *     - @c RETURN_OK to send command after #rawPacket and #rawPacketLen have been set.
+	 *     - Anything else triggers an event with the returnvalue as a parameter
 	 */
 	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
 			const uint8_t * commandData, size_t commandDataLen) = 0;
@@ -366,14 +371,29 @@ protected:
 	 */
 	virtual void performOperationHook();
 
+	/**
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
+	 */
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
+
 public:
 	/**
 	 * @param parentQueueId
 	 */
 	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
+	/**
+	 * This function call handles the execution of external commands as required
+	 * by the HasActionIF.
+	 * @param actionId
+	 * @param commandedBy
+	 * @param data
+	 * @param size
+	 * @return
+	 */
 	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
+
 	Mode_t getTransitionSourceMode() const;
 	Submode_t getTransitionSourceSubMode() const;
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
@@ -392,21 +412,6 @@ public:
 	virtual MessageQueueId_t getCommandQueue(void) const;
 
 protected:
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
-
-	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5); //!< This is used to specify for replies from a device which are not replies to requests
-	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6); //!< Ignore parts of the received packet
-	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(7); //!< Ignore full received packet
-//	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
-//	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
-	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(10);
-	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(11);
-	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(12);
-
 	//Mode handling error Codes
 	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE1);
 	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE2);
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index f0f7adfdc..5ea527e95 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -8,12 +8,13 @@
 #include <framework/ipc/MessageQueueSenderIF.h>
 
 /**
- * Physical address type
+ * @brief Physical address type
  */
 typedef uint32_t address_t;
 
 /**
- * This is the Interface used to communicate with a device handler.
+ * @brief 	This is the Interface used to communicate with a device handler.
+ * @details Includes all expected return values, events and modes.
  *
  */
 class DeviceHandlerIF {
@@ -30,8 +31,8 @@ public:
 	 * MODE_ON and MODE_OFF are included in hasModesIF.h
 	 */
 
-	//		MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-	//		MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
 	static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
 	static const Mode_t MODE_RAW = 3; //!< The device is powered on and ready to perform operations. In this mode, raw commands can be sent. The device handler will send all replies received from the command back to the commanding object.
 	static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
@@ -60,36 +61,48 @@ public:
 	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0);
-	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1);
-	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2);
-	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
-	static const ReturnValue_t CANT_SWITCH_IOBOARD = MAKE_RETURN_CODE(0xA4);
-	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
-	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
-	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
-	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
 
-	// Standard codes used in scan for reply
-	//static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE(0xB1);
-	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB2);
-	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB3);
-	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB4);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB5);
+	// Standard codes used when building commands.
+	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xA0); //!< Return this if no command sending in required
+	// Mostly used for internal handling.
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA2); //!< If the command size is 0. Checked in DHB
+	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA3); //!< Used to indicate that this is a command-only command.
+	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA4); //!< Command ID not in commandMap. Checked in DHB
+	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA5); //!< Command was already executed. Checked in DHB
+	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA7);
+	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA8);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA9);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xAA);
+	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xAB);
+	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAC);
 
-	// Standard codes used in  interpret device reply
+	// Standard codes used in scanForReply
+	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB1); //!< This is used to specify for replies from a device which are not replies to requests
+	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB2);
+	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB3); //!< Ignore parts of the received packet
+	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB4); //!< Ignore full received packet
+	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB5);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB6);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB7);
+
+	// Standard codes used in  interpretDeviceReply
 	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC1); //the device reported, that it did not execute the command
 	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC2);
 	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC3); //the deviceCommandId reported by scanforReply is unknown
 	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC4); //syntax etc is correct but still not ok, eg parameters where none are expected
 
 	// Standard codes used in buildCommandFromCommand
-	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(
-			0xD0);
-	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS =
-			MAKE_RETURN_CODE(0xD1);
+	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
+	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
+
+	// Standard codes used in getSwitches
+	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xE1); //!< Return in getSwitches() to specify there are no switches
+
+	//	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
+	//	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
+	// where is this used?
+	// static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(11);
 
 	/**
 	 * Communication action that will be executed.
@@ -97,10 +110,10 @@ public:
 	 * This is used by the child class to tell the base class what to do.
 	 */
 	enum CommunicationAction_t: uint8_t {
-		SEND_WRITE,//!< RMAP send write
-		GET_WRITE, //!< RMAP get write
-		SEND_READ, //!< RMAP send read
-		GET_READ,  //!< RMAP get read
+		SEND_WRITE,//!< Send write
+		GET_WRITE, //!< Get write
+		SEND_READ, //!< Send read
+		GET_READ,  //!< Get read
 		NOTHING    //!< Do nothing.
 	};
 
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 5adbca3fc..b8b72a9fc 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -9,19 +9,13 @@
 typedef uint16_t ReturnValue_t;
 
 
-
-
-
-
 class HasReturnvaluesIF {
 public:
 	static const ReturnValue_t RETURN_OK = 0;
-	static const ReturnValue_t RETURN_FAILED = 1;
+	static const ReturnValue_t RETURN_FAILED = 0xFFFF;
 	virtual ~HasReturnvaluesIF() {
 	}
 
 };
 
-
-
 #endif /* HASRETURNVALUESIF_H_ */

From b2b6b8ee23bc1ed05a4b1e1fc583a9c3f1f71cef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 24 Mar 2020 15:33:18 +0100
Subject: [PATCH 0133/1774] added initializeInterface for comIF/cookie

---
 devicehandlers/DeviceCommunicationIF.h | 12 ++++++++++++
 devicehandlers/DeviceHandlerBase.cpp   |  9 ++++-----
 devicehandlers/DeviceHandlerBase.h     |  2 +-
 3 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 6f2715041..931fc8b5e 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -46,6 +46,18 @@ public:
 
 	virtual ~DeviceCommunicationIF() {}
 
+	/**
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return
+	 */
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
+
 	/**
 	 * Called by DHB in the SEND_WRITE doSendWrite().
 	 * This function is used to send data to the physical device
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ebb361d97..ad699508f 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -102,11 +102,10 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return RETURN_FAILED;
 	}
 
-//	result = communicationInterface->open(&cookie, logicalAddress,
-//			maxDeviceReplyLen, comParameter1, comParameter2);
-//	if (result != RETURN_OK) {
-//		return result;
-//	}
+	result = communicationInterface->initializeInterface(comCookie);
+	if (result != RETURN_OK) {
+		return result;
+	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == NULL) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 5faaa8e01..dcca2cc4b 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -464,7 +464,7 @@ protected:
 	 * 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
 	 */
-	enum WiretappingMode {
+	enum WiretappingMode: uint8_t {
 		OFF = 0, RAW = 1, TM = 2
 	} wiretappingMode;
 

From 163779622fd9b7d367a0fe05d236928e2727d06e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 25 Mar 2020 02:08:35 +0100
Subject: [PATCH 0134/1774] DHB: replyLen in replyMap now

---
 devicehandlers/DeviceHandlerBase.cpp | 38 +++++++------
 devicehandlers/DeviceHandlerBase.h   | 83 +++++++++++++++-------------
 2 files changed, 67 insertions(+), 54 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ad699508f..068a62de6 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -332,37 +332,35 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
-		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-		uint8_t periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
-//No need to check, as we may try to insert multiple times.
+ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
+		uint16_t maxDelayCycles, size_t replyLen, uint8_t periodic,
+		bool hasDifferentReplyId, DeviceCommandId_t replyId) {
+	//No need to check, as we may try to insert multiple times.
 	insertInCommandMap(deviceCommand);
 	if (hasDifferentReplyId) {
-		return insertInReplyMap(replyId, maxDelayCycles, periodic);
+		return insertInReplyMap(replyId, maxDelayCycles, replyLen, periodic);
 	} else {
-		return insertInReplyMap(deviceCommand, maxDelayCycles, periodic);
+		return insertInReplyMap(deviceCommand, maxDelayCycles, replyLen, periodic);
 	}
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, uint8_t periodic) {
+		uint16_t maxDelayCycles, size_t replyLen, uint8_t periodic) {
 	DeviceReplyInfo info;
 	info.maxDelayCycles = maxDelayCycles;
 	info.periodic = periodic;
 	info.delayCycles = 0;
+	info.replyLen = replyLen;
 	info.command = deviceCommandMap.end();
-	std::pair<std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator, bool> returnValue;
-	returnValue = deviceReplyMap.insert(
-			std::pair<DeviceCommandId_t, DeviceReplyInfo>(replyId, info));
-	if (returnValue.second) {
+	std::pair<DeviceReplyIter, bool> result = deviceReplyMap.emplace(replyId, info);
+	if (result.second) {
 		return RETURN_OK;
 	} else {
 		return RETURN_FAILED;
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::insertInCommandMap(
-		DeviceCommandId_t deviceCommand) {
+ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceCommand) {
 	DeviceCommandInfo info;
 	info.expectedReplies = 0;
 	info.isExecuting = false;
@@ -378,9 +376,8 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(
-		DeviceCommandId_t deviceReply, uint16_t delayCycles,
-		uint16_t maxDelayCycles, uint8_t periodic) {
+ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
+		uint16_t delayCycles, uint16_t maxDelayCycles, uint8_t periodic) {
 	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
 			deviceReplyMap.find(deviceReply);
 	if (iter == deviceReplyMap.end()) {
@@ -547,6 +544,15 @@ void DeviceHandlerBase::doGetWrite() {
 
 void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
+
+	DeviceReplyIter iter = deviceReplyMap.find(cookieInfo.pendingCommand->first);
+	if(iter != deviceReplyMap.end()) {
+		requestLen = iter->second.replyLen;
+	}
+	else {
+		requestLen = 0;
+	}
+
 	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index dcca2cc4b..b4882b9d1 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -275,26 +275,33 @@ protected:
 	 * @details
 	 * This is used by the base class to check the data received for valid packets.
 	 * It only checks if a valid packet starts at @c start.
-	 * It also only checks the structural validy of the packet, eg checksums lengths and protocol data.
+	 * It also only checks the structural validy of the packet,
+	 * e.g. checksums lengths and protocol data.
 	 * No information check is done, e.g. range checks etc.
 	 *
-	 * Errors should be reported directly, the base class does NOT report any errors based on the return
-	 * value of this function.
+	 * Errors should be reported directly,  the base class does NOT report
+	 * any errors based on the returnvalue of this function.
 	 *
 	 * @param start start of remaining buffer to be scanned
 	 * @param len length of remaining buffer to be scanned
 	 * @param[out] foundId the id of the data found in the buffer.
-	 * @param[out] foundLen length of the data found. Is to be set in function, buffer is scanned at previous position + foundLen.
+	 * @param[out] foundLen length of the data found. Is to be set in function,
+	 * 						buffer is scanned at previous position + foundLen.
 	 * @return
 	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *     - @c RETURN_FAILED no reply could be found starting at @c start, implies @c foundLen is not valid, base class will call scanForReply() again with ++start
-	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid, eg checksum error, implies @c foundLen is valid, can be used to skip some bytes
+	 *     - @c RETURN_FAILED no reply could be found starting at @c start,
+	 *             implies @c foundLen is not valid,
+	 *             base class will call scanForReply() again with ++start
+	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
+	 *             e.g. checksum error, implies @c foundLen is valid, can be used to skip some bytes
 	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
 	 *     - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of the packet
 	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
-	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
+	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been
+	 *             requested by a command, but should be handled anyway
+	 *             (@see also fillCommandAndCookieMap() )
 	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
 			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
 
 	/**
@@ -513,6 +520,30 @@ protected:
 	 */
 	CookieIF *comCookie;
 
+	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.
+		uint8_t expectedRepliesWhenEnablingReplyMap; //!< Constant value which specifies expected replies when enabling reply map. Inititated in insertInCommandAndReplyMap()
+		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
+	};
+	typedef std::map<DeviceCommandId_t, DeviceCommandInfo> DeviceCommandMap;
+
+	/**
+	 * @brief Information about expected 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
+		size_t replyLen = 0; //!< Expected size of the reply.
+		uint8_t 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.
+	};
+
+	typedef std::map<DeviceCommandId_t, DeviceReplyInfo> DeviceReplyMap;
+	typedef DeviceReplyMap::iterator DeviceReplyIter;
+
 	/**
 	 * The MessageQueue used to receive device handler commands and to send replies.
 	 */
@@ -696,7 +727,7 @@ protected:
 	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, uint8_t periodic = 0,
+			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 	/**
 	 * This is a helper method to insert replies in the reply map.
@@ -707,7 +738,7 @@ protected:
 	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
 	 */
 	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, uint8_t periodic = 0);
+			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0);
 	/**
 	 * A simple command to add a command to the commandList.
 	 * @param deviceCommand The command to add
@@ -762,14 +793,6 @@ protected:
 	 */
 	virtual void modeChanged(void);
 
-	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.
-		uint8_t expectedRepliesWhenEnablingReplyMap; //!< Constant value which specifies expected replies when enabling reply map. Inititated in insertInCommandAndReplyMap()
-		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
-	};
-
-	typedef std::map<DeviceCommandId_t, DeviceCommandInfo> DeviceCommandMap;
 	/**
 	 * Enable the reply checking for a command
 	 *
@@ -780,16 +803,16 @@ protected:
 	 * When found, copies maxDelayCycles to delayCycles in the reply information and sets the command to
 	 * expect one reply.
 	 *
-	 * Can be overwritten by the child, if a command activates multiple replies or replyId differs from
-	 * commandId.
+	 * Can be overwritten by the child, if a command activates multiple replies
+	 * or replyId differs from commandId.
 	 * Notes for child implementations:
 	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
 	 * 	- A failure code may be returned if something went fundamentally wrong.
 	 *
 	 * @param deviceCommand
 	 * @return 	- RETURN_OK if a reply was activated.
-	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an error case as many commands
-	 * 				do not expect a reply.
+	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an
+	 * 			  error case as many commands do not expect a reply.
 	 */
 	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
 			uint8_t expectedReplies = 1, bool useAlternateId = false,
@@ -884,22 +907,6 @@ protected:
 
 	bool commandIsExecuting(DeviceCommandId_t commandId);
 
-	/**
-	 * Information about expected 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
-		uint8_t 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.
-	};
-
-	/**
-	 * Definition for the important reply Map.
-	 */
-	typedef std::map<DeviceCommandId_t, DeviceReplyInfo> DeviceReplyMap;
 	/**
 	 * This map is used to check and track correct reception of all replies.
 	 *

From 093fef5d6f2aea6589abe45077037057bfb879ba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 26 Mar 2020 15:20:17 +0100
Subject: [PATCH 0135/1774] moved address_t typedef to cookieImoved address_t
 typedef to cookieIFF

---
 devicehandlers/CookieIF.h            |  5 ++
 devicehandlers/DeviceHandlerBase.cpp | 23 ++++----
 devicehandlers/DeviceHandlerBase.h   | 87 ++++++++++++++--------------
 devicehandlers/DeviceHandlerIF.h     |  7 +--
 4 files changed, 64 insertions(+), 58 deletions(-)

diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index d8781cd73..fc89c1af8 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -8,6 +8,11 @@
 #define FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_
 #include <framework/devicehandlers/DeviceHandlerIF.h>
 
+/**
+ * @brief Physical address type
+ */
+typedef uint32_t address_t;
+
 class CookieIF {
 public:
 	/**
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 068a62de6..b1af2689c 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -365,11 +365,8 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
 	info.expectedReplies = 0;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
-	std::pair<std::map<DeviceCommandId_t, DeviceCommandInfo>::iterator, bool> returnValue;
-	returnValue = deviceCommandMap.insert(
-			std::pair<DeviceCommandId_t, DeviceCommandInfo>(deviceCommand,
-					info));
-	if (returnValue.second) {
+	std::pair<DeviceCommandIter, bool> result = deviceCommandMap.emplace(deviceCommand,info);
+	if (result.second) {
 		return RETURN_OK;
 	} else {
 		return RETURN_FAILED;
@@ -489,7 +486,7 @@ void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 		return;
 	}
 //Check if more replies are expected. If so, do nothing.
-	DeviceCommandInfo* info = &(iter->second.command->second);
+	DeviceCommandInfo * info = &(iter->second.command->second);
 	if (--info->expectedReplies == 0) {
 		//Check if it was transition or internal command. Don't send any replies in that case.
 		if (info->sendReplyTo != NO_COMMANDER) {
@@ -550,13 +547,17 @@ void DeviceHandlerBase::doSendRead() {
 		requestLen = iter->second.replyLen;
 	}
 	else {
-		requestLen = 0;
+		requestLen = comCookie->getMaxReplyLen();
 	}
 
 	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
-	} else {
+	}
+	else if(result == NO_READ_REQUEST) {
+		return;
+	}
+	else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
 		//We can't inform anyone, because we don't know which command was sent last.
 		//So, we need to wait for a timeout.
@@ -816,9 +817,9 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		iter = deviceReplyMap.find(command->first);
 	}
 	if (iter != deviceReplyMap.end()) {
-		DeviceReplyInfo & info = iter->second;
-		info.delayCycles = info.maxDelayCycles;
-		info.command = command;
+		DeviceReplyInfo * info = &(iter->second);
+		info->delayCycles = info->maxDelayCycles;
+		info->command = command;
 		command->second.expectedReplies = expectedReplies;
 		return RETURN_OK;
 	} else {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index b4882b9d1..129fb288b 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -194,6 +194,9 @@ protected:
 	 * different commands can built returned depending on the submode.
 	 *
 	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 * If variable command frequence is required, a counter can be used and
+	 * the frequency in the reply map has to be set manually
+	 * by calling updateReplyMap().
 	 *
 	 * @param[out] id the device command id that has been built
 	 * @return
@@ -527,6 +530,7 @@ protected:
 		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
 	};
 	typedef std::map<DeviceCommandId_t, DeviceCommandInfo> DeviceCommandMap;
+	typedef DeviceCommandMap::iterator DeviceCommandIter;
 
 	/**
 	 * @brief Information about expected replies
@@ -674,48 +678,6 @@ protected:
 	 */
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
 
-	/**
-	 * Is the combination of mode and submode valid?
-	 *
-	 * @param mode
-	 * @param submode
-	 * @return
-	 *    - @c RETURN_OK if valid
-	 *    - @c RETURN_FAILED if invalid
-	 */
-	virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
-			Submode_t submode);
-
-	/**
-	 * Get the Rmap action for the current step.
-	 *
-	 * The step number can be read from #pstStep.
-	 *
-	 * @return The Rmap action to execute in this step
-	 */
-	virtual CommunicationAction_t getComAction();
-
-	/**
-	 * Build the device command to send for raw mode.
-	 *
-	 * This is only called in @c MODE_RAW. It is for the rare case that in raw mode packets
-	 * are to be sent by the handler itself. It is NOT needed for the raw commanding service.
-	 * Its only current use is in the STR handler which gets its raw packets from a different
-	 * source.
-	 * Also it can be used for transitional commands, to get the device ready for @c MODE_RAW
-	 *
-	 * As it is almost never used, there is a default implementation returning @c NOTHING_TO_SEND.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 *
-	 * @param[out] id the device command id built
-	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c NOTHING_TO_SEND when no command is to be sent
-	 */
-	virtual ReturnValue_t buildChildRawCommand();
-
-
 	/**
 	 * This is a helper method to facilitate inserting entries in the command map.
 	 * @param deviceCommand	Identifier of the command to add.
@@ -765,6 +727,47 @@ protected:
 	 */
 	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
 
+	/**
+	 * Is the combination of mode and submode valid?
+	 *
+	 * @param mode
+	 * @param submode
+	 * @return
+	 *    - @c RETURN_OK if valid
+	 *    - @c RETURN_FAILED if invalid
+	 */
+	virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+			Submode_t submode);
+
+	/**
+	 * Get the Rmap action for the current step.
+	 *
+	 * The step number can be read from #pstStep.
+	 *
+	 * @return The Rmap action to execute in this step
+	 */
+	virtual CommunicationAction_t getComAction();
+
+	/**
+	 * Build the device command to send for raw mode.
+	 *
+	 * This is only called in @c MODE_RAW. It is for the rare case that in raw mode packets
+	 * are to be sent by the handler itself. It is NOT needed for the raw commanding service.
+	 * Its only current use is in the STR handler which gets its raw packets from a different
+	 * source.
+	 * Also it can be used for transitional commands, to get the device ready for @c MODE_RAW
+	 *
+	 * As it is almost never used, there is a default implementation returning @c NOTHING_TO_SEND.
+	 *
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 *
+	 * @param[out] id the device command id built
+	 * @return
+	 *    - @c RETURN_OK when a command is to be sent
+	 *    - not @c NOTHING_TO_SEND when no command is to be sent
+	 */
+	virtual ReturnValue_t buildChildRawCommand();
+
 	/**
 	 * Construct a command reply containing a raw reply.
 	 *
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 5ea527e95..c6baf7af0 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -7,11 +7,6 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
 
-/**
- * @brief Physical address type
- */
-typedef uint32_t address_t;
-
 /**
  * @brief 	This is the Interface used to communicate with a device handler.
  * @details Includes all expected return values, events and modes.
@@ -95,6 +90,8 @@ public:
 	// Standard codes used in buildCommandFromCommand
 	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
 	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
+	// Standard codes used in buildNomalDeviceCommand
+	static const ReturnValue_t NO_READ_REQUEST = MAKE_RETURN_CODE(0xD2);
 
 	// Standard codes used in getSwitches
 	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xE1); //!< Return in getSwitches() to specify there are no switches

From e252a5b795147d11371514b9defad39d91a596ed Mon Sep 17 00:00:00 2001
From: "jakob.meier" <jakob.meier@outlook.de>
Date: Thu, 26 Mar 2020 19:20:16 +0100
Subject: [PATCH 0136/1774] file system support

---
 memory/FileSystemMessage.cpp | 28 ++++++++++++++++++++++++++++
 memory/FileSystemMessage.h   | 30 ++++++++++++++++++++++++++++++
 memory/HasFileSystemIF.h     | 36 ++++++++++++++++++++++++++++++++++++
 3 files changed, 94 insertions(+)
 create mode 100644 memory/FileSystemMessage.cpp
 create mode 100644 memory/FileSystemMessage.h
 create mode 100644 memory/HasFileSystemIF.h

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
new file mode 100644
index 000000000..efbc80097
--- /dev/null
+++ b/memory/FileSystemMessage.cpp
@@ -0,0 +1,28 @@
+/*
+ * FileSystemMessage.cpp
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#include "FileSystemMessage.h"
+#include <framework/objectmanager/ObjectManagerIF.h>
+
+ReturnValue_t FileSystemMessage::setWriteToFileCommand(CommandMessage* message,
+		MessageQueueId_t replyQueueId, store_address_t storageID) {
+	message->setCommand(WRITE_TO_FILE);
+	message->setParameter(replyQueueId);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+store_address_t FileSystemMessage::getStoreID(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+MessageQueueId_t FileSystemMessage::getReplyQueueId(const CommandMessage* message){
+	return message->getParameter();
+}
+
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
new file mode 100644
index 000000000..b6fd7309e
--- /dev/null
+++ b/memory/FileSystemMessage.h
@@ -0,0 +1,30 @@
+/*
+ * FileSystemMessage.h
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
+#define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
+
+#include <framework/ipc/CommandMessage.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/objectmanager/SystemObject.h>
+
+class FileSystemMessage {
+private:
+	FileSystemMessage(); //A private ctor inhibits instantiation
+public:
+	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::FILE_SYSTEM_MESSAGE;
+	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
+	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
+	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
+
+	static ReturnValue_t setWriteToFileCommand(CommandMessage* message, MessageQueueId_t replyToQueue, store_address_t storageID );
+	static store_address_t getStoreID( const CommandMessage* message );
+	static MessageQueueId_t getReplyQueueId(const CommandMessage* message);
+
+};
+
+#endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */
diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
new file mode 100644
index 000000000..8b66f88b7
--- /dev/null
+++ b/memory/HasFileSystemIF.h
@@ -0,0 +1,36 @@
+/*
+ * HasFileSystemIF.h
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#ifndef FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+#define FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+class HasFileSystemIF {
+public:
+
+	virtual ~HasFileSystemIF() {}
+	/**
+	 * Function to get the MessageQueueId_t of the implementing object
+	 * @return MessageQueueId_t of the object
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	/**
+	 * Function to write to a file
+	 * @param dirname Directory of the file
+	 * @param filename The filename of the file
+	 * @param data The data to write to the file
+	 * @param size The size of the data to write
+	 * @param packetNumber Counts the number of packets. For large files the write procedure must be split in multiple calls to writeToFile
+	 */
+	virtual ReturnValue_t writeToFile(const char* dirname, char* filename, const uint8_t* data, uint32_t size, uint16_t packetNumber) = 0;
+	virtual ReturnValue_t createFile(const char* dirname, const char* filename, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t deleteFile(const char* dirname, const char* filename) = 0;
+};
+
+
+#endif /* FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_ */

From 0e56a094d305a35b80bdb20cc0c3cdcd533bd888 Mon Sep 17 00:00:00 2001
From: "jakob.meier" <jakob.meier@outlook.de>
Date: Thu, 26 Mar 2020 19:43:38 +0100
Subject: [PATCH 0137/1774] merged FwMessageTypes

---
 ipc/FwMessageTypes.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/ipc/FwMessageTypes.h b/ipc/FwMessageTypes.h
index ec1c9aa28..07e3d2458 100644
--- a/ipc/FwMessageTypes.h
+++ b/ipc/FwMessageTypes.h
@@ -14,7 +14,8 @@ enum FW_MESSAGE_TYPE {
 	MONITORING,
 	MEMORY,
 	PARAMETER,
-	FW_MESSAGES_COUNT
+	FW_MESSAGES_COUNT,
+	FILE_SYSTEM_MESSAGE
 };
 }
 

From 5d071a1cf1e4160386566cd1bcd1eeb70e65e5f7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 26 Mar 2020 19:53:05 +0100
Subject: [PATCH 0138/1774] new device comIF return value in DHB

request receive message
---
 devicehandlers/DeviceCommunicationIF.h | 32 +++++++++++++++-----------
 devicehandlers/DeviceHandlerBase.cpp   |  6 ++---
 devicehandlers/DeviceHandlerIF.h       |  2 --
 osal/FreeRTOS/BinarySemaphore.cpp      | 20 ++++++++--------
 4 files changed, 33 insertions(+), 27 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 931fc8b5e..ddd27d10c 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -38,11 +38,16 @@ class DeviceCommunicationIF: public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
 
-	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x05);
+	//!< This is used if no read request is to be made by the device handler.
+	static const ReturnValue_t NO_READ_REQUEST = MAKE_RETURN_CODE(0x01);
+	//! General protocol error. Define more concrete errors in child handler
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
+	//! If cookie is a null pointer
+	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x04);
+	// is this needed if there is no open/close call?
+	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
 
 	virtual ~DeviceCommunicationIF() {}
 
@@ -54,7 +59,8 @@ public:
 	 * this can be performed in this function, which is called on device handler
 	 * initialization.
 	 * @param cookie
-	 * @return
+	 * @return -@c RETURN_OK if initialization was successfull
+	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
 
@@ -66,8 +72,7 @@ public:
 	 * @param data
 	 * @param len
 	 * @return -@c RETURN_OK for successfull send
-	 *         - Everything else triggers sending failed event with
-	 *           returnvalue as parameter 1
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
 			size_t sendLen) = 0;
@@ -77,8 +82,7 @@ public:
 	 * Get send confirmation that the data in sendMessage() was sent successfully.
 	 * @param cookie
 	 * @return -@c RETURN_OK if data was sent successfull
-	 * 		   - Everything else triggers sending failed event with
-	 *           returnvalue as parameter 1
+	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
 
@@ -86,7 +90,10 @@ public:
 	 * Called by DHB in the SEND_WRITE doSendRead().
 	 * Request a reply.
 	 * @param cookie
-	 * @return
+	 * @return -@c RETURN_OK to confirm the request for data has been sent.
+	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
+	 *         	   will not be called in the respective communication cycle.
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
 
@@ -98,8 +105,7 @@ public:
 	 * @param data
 	 * @param len
 	 * @return @c RETURN_OK for successfull receive
-	 *         - Everything else triggers receiving failed with
-	 *           returnvalue as parameter 1
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
 			size_t *size) = 0;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index b1af2689c..8187ffdef 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -554,7 +554,7 @@ void DeviceHandlerBase::doSendRead() {
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
 	}
-	else if(result == NO_READ_REQUEST) {
+	else if(result == DeviceCommunicationIF::NO_READ_REQUEST) {
 		return;
 	}
 	else {
@@ -777,8 +777,8 @@ void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 		replyReturnvalueToCommand(result, RAW_COMMAND_ID);
 		storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
 	} else {
-		cookieInfo.pendingCommand = deviceCommandMap.find(
-				(DeviceCommandId_t) RAW_COMMAND_ID);
+		cookieInfo.pendingCommand = deviceCommandMap.
+				find((DeviceCommandId_t) RAW_COMMAND_ID);
 		cookieInfo.pendingCommand->second.isExecuting = true;
 		cookieInfo.state = COOKIE_WRITE_READY;
 	}
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index c6baf7af0..34aa41144 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -90,8 +90,6 @@ public:
 	// Standard codes used in buildCommandFromCommand
 	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
 	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
-	// Standard codes used in buildNomalDeviceCommand
-	static const ReturnValue_t NO_READ_REQUEST = MAKE_RETURN_CODE(0xD2);
 
 	// Standard codes used in getSwitches
 	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xE1); //!< Return in getSwitches() to specify there are no switches
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 4ec61ff7a..631e4742d 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -11,8 +11,8 @@
 #include "task.h"
 
 BinarySemaphore::BinarySemaphore() {
-	xSemaphoreCreateBinary(handle); // @suppress("Function cannot be resolved")
-	if(handle == NULL) {
+	xSemaphoreCreateBinary(handle);
+	if(handle == nullptr) {
 		error << "Binary semaphore creation failure" << std::endl;
 	}
 }
@@ -22,7 +22,7 @@ BinarySemaphore::~BinarySemaphore() {
 }
 
 ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
-	if(handle == NULL) {
+	if(handle == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	TickType_t timeout = portMAX_DELAY;
@@ -39,7 +39,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 }
 
 ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks) {
-	if(handle == NULL) {
+	if(handle == nullptr) {
 		return SEMAPHORE_NOT_FOUND;
 	}
 
@@ -52,7 +52,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(TickType_t timeout
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
-	if (handle == NULL) {
+	if (handle == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	BaseType_t returncode = xSemaphoreGive(handle);
@@ -68,7 +68,7 @@ SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
-	if (semaphore == NULL) {
+	if (semaphore == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	BaseType_t returncode = xSemaphoreGive(semaphore);
@@ -80,13 +80,15 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 }
 
 void BinarySemaphore::resetSemaphore() {
-	vSemaphoreDelete(handle);
-	xSemaphoreCreateBinary(handle);
+	if(handle != nullptr) {
+		vSemaphoreDelete(handle);
+		xSemaphoreCreateBinary(handle);
+	}
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
-	if (semaphore == NULL) {
+	if (semaphore == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);

From 93678adc5a8570f444e82259c991f8b5e378cae8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 28 Mar 2020 00:09:15 +0100
Subject: [PATCH 0139/1774] replace std::set by std::multiset

so there can be multiple entries with same pollignTime
---
 devicehandlers/FixedSlotSequence.cpp |  5 ++++-
 devicehandlers/FixedSlotSequence.h   | 17 ++++++++++-------
 tasks/FixedTimeslotTaskIF.h          |  3 ++-
 3 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index f01b13992..23bb0e78a 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -104,11 +104,14 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 			count++;
 		} else {
 			// All ok, print slot.
-			// (*slotIt)->print();
+			//info << "Current slot polling time: " << std::endl;
+			//info << std::dec << slotIt->pollingTimeMs << std::endl;
 		}
 		time = slotIt->pollingTimeMs;
 		slotIt++;
 	}
+	//info << "Number of elements in slot list: "
+	//	   << slotList.size() << std::endl;
 	if (count > 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h
index 974dbb2bd..813d2fce2 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -6,8 +6,8 @@
 #include <list>
 #include <set>
 
-using SlotList = std::set<FixedSequenceSlot>;
-using SlotListIter = std::set<FixedSequenceSlot>::iterator;
+using SlotList = std::multiset<FixedSequenceSlot>;
+using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
 
 /**
  * @brief	This class is the representation of a Polling Sequence Table in software.
@@ -69,11 +69,14 @@ public:
 	/**
 	 * \brief	This method returns the time until the next software component is invoked.
 	 *
-	 * \details	This method is vitally important for the operation of the PST. By fetching the polling time
-	 * 			of the current slot and that of the next one (or the first one, if the list end is reached)
-	 * 			it calculates and returns the interval in milliseconds within which the handler execution
-	 * 			shall take place. If the next slot has the same time as the current one, it is ignored until
-	 * 			a slot with different time or the end of the PST is found.
+	 * \details
+	 * This method is vitally important for the operation of the PST.
+	 * By fetching the polling time of the current slot and that of the
+	 * next one (or the first one, if the list end is reached)
+	 * it calculates and returns the interval in milliseconds within
+	 * which the handler execution shall take place.
+	 * If the next slot has the same time as the current one, it is ignored
+	 * until a slot with different time or the end of the PST is found.
 	 */
 	uint32_t getIntervalToNextSlotMs();
 
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index d29801841..7edd67519 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -12,7 +12,8 @@ class FixedTimeslotTaskIF : public PeriodicTaskIF {
 public:
 	virtual ~FixedTimeslotTaskIF() {}
 
-	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep) = 0;
+	virtual ReturnValue_t addSlot(object_id_t componentId,
+			uint32_t slotTimeMs, int8_t executionStep) = 0;
 	virtual ReturnValue_t checkSequence() const = 0;
 };
 

From 5218a0d84f987272ac2281c6a09ac4ef431dceb6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 28 Mar 2020 19:42:24 +0100
Subject: [PATCH 0140/1774] doc fix

---
 devicehandlers/DeviceCommunicationIF.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index ddd27d10c..68db82e60 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -10,7 +10,7 @@
  */
 
 /**
- * @defgroup communication comm
+ * @defgroup comm Communication
  * @brief Communication software components.
  */
 
@@ -18,7 +18,7 @@
  * @brief This is an interface to decouple device communication from
  * the device handler to allow reuse of these components.
  * @details
- * Documentation: Dissertation Baetz p.138
+ * Documentation: Dissertation Baetz p.138.
  * It works with the assumption that received data
  * is polled by a component. There are four generic steps of device communication:
  *

From 996dbc9e4b952fa208b1e4b12d1ee291701ddf57 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Apr 2020 12:41:54 +0200
Subject: [PATCH 0141/1774] DHB/Cookie refactoring

---
 devicehandlers/ChildHandlerBase.cpp    |   2 +-
 devicehandlers/Cookie.cpp              |  26 -------
 devicehandlers/Cookie.h                |  38 ---------
 devicehandlers/CookieIF.h              |  63 ++++++++-------
 devicehandlers/DeviceCommunicationIF.h |  11 ++-
 devicehandlers/DeviceHandlerBase.cpp   |  31 ++++----
 devicehandlers/DeviceHandlerBase.h     |  23 +-----
 rmap/RMAP.cpp                          |   6 +-
 rmap/RMAP.h                            |   6 +-
 rmap/RMAPChannelIF.h                   |   5 +-
 rmap/RMAPCookie.cpp                    |  10 +--
 rmap/RMAPCookie.h                      |   9 ++-
 rmap/RmapDeviceCommunicationIF.cpp     |  22 +++---
 rmap/RmapDeviceCommunicationIF.h       | 103 +++++++++++++------------
 14 files changed, 142 insertions(+), 213 deletions(-)
 delete mode 100644 devicehandlers/Cookie.cpp
 delete mode 100644 devicehandlers/Cookie.h

diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index ac0b24384..c34846769 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -8,7 +8,7 @@ ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		uint32_t parent, FailureIsolationBase* customFdir, size_t cmdQueueSize) :
 		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
-			maxDeviceReplyLen, setDeviceSwitch,  thermalStatePoolId,
+			setDeviceSwitch,  thermalStatePoolId,
 			thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir),
 			cmdQueueSize),
 		parentId(parent), childHandlerFdir(setObjectId) {
diff --git a/devicehandlers/Cookie.cpp b/devicehandlers/Cookie.cpp
deleted file mode 100644
index 05b9425ca..000000000
--- a/devicehandlers/Cookie.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-/**
- * @file Cookie.cpp
- *
- * @date 23.03.2020
- */
-#include <framework/devicehandlers/Cookie.h>
-
-Cookie::Cookie(address_t logicalAddress_): logicalAddress(logicalAddress_) {
-}
-
-void Cookie::setAddress(address_t logicalAddress_) {
-	logicalAddress = logicalAddress_;
-}
-void Cookie::setMaxReplyLen(size_t maxReplyLen_) {
-	maxReplyLen = maxReplyLen_;
-}
-
-address_t Cookie::getAddress() const {
-	return logicalAddress;
-}
-
-size_t Cookie::getMaxReplyLen() const {
-	return maxReplyLen;
-}
-
-
diff --git a/devicehandlers/Cookie.h b/devicehandlers/Cookie.h
deleted file mode 100644
index d76facc0d..000000000
--- a/devicehandlers/Cookie.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef COOKIE_H_
-#define COOKIE_H_
-#include <framework/devicehandlers/CookieIF.h>
-
-/**
- * @brief This datatype is used to identify different connection over a single interface
- *        (like RMAP or I2C)
- * @details
- * To use this class, implement a communication specific child cookie which
- * inherits Cookie. Cookie instances are created in config/ Factory.cpp by calling
- * CookieIF* childCookie = new ChildCookie(...).´
- *
- * This cookie is then passed to the child device handlers, which stores the
- * pointer and passes it to the communication interface functions.
- *
- * The cookie can be used to store all kinds of information
- * about the communication, like slave addresses, communication status,
- * communication parameters etc.
- *
- * @ingroup comm
- */
-class Cookie: public CookieIF {
-public:
-	Cookie();
-	Cookie(address_t logicalAddress_);
-	virtual ~Cookie() {};
-
-	virtual void setAddress(address_t logicalAddres_);
-	virtual void setMaxReplyLen(size_t maxReplyLen_);
-
-	virtual address_t getAddress() const;
-	virtual size_t getMaxReplyLen() const;
-private:
-	address_t logicalAddress = 0;
-	size_t maxReplyLen = 0;
-};
-
-#endif /* COOKIE_H_ */
diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index fc89c1af8..55fdb44b1 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -1,30 +1,33 @@
-/**
- * @file CookieIF.h
- *
- * @date 23.03.2020
- */
-
-#ifndef FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_
-#define FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-
-/**
- * @brief Physical address type
- */
-typedef uint32_t address_t;
-
-class CookieIF {
-public:
-	/**
-	 * Default empty virtual destructor.
-	 */
-	virtual ~CookieIF() {};
-
-	virtual void setAddress(address_t logicalAddress_) = 0;
-	virtual address_t getAddress() const = 0;
-
-	virtual void setMaxReplyLen(size_t maxReplyLen_) = 0;
-	virtual size_t getMaxReplyLen() const = 0;
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_ */
+#ifndef COOKIE_H_
+#define COOKIE_H_
+#include <framework/devicehandlers/CookieIF.h>
+#include <stdint.h>
+
+/**
+ * @brief Physical address type
+ */
+typedef uint32_t address_t;
+
+/**
+ * @brief This datatype is used to identify different connection over a single interface
+ *        (like RMAP or I2C)
+ * @details
+ * To use this class, implement a communication specific child cookie which
+ * inherits Cookie. Cookie instances are created in config/ Factory.cpp by calling
+ * CookieIF* childCookie = new ChildCookie(...).
+ *
+ * This cookie is then passed to the child device handlers, which stores the
+ * pointer and passes it to the communication interface functions.
+ *
+ * The cookie can be used to store all kinds of information
+ * about the communication, like slave addresses, communication status,
+ * communication parameters etc.
+ *
+ * @ingroup comm
+ */
+class CookieIF {
+public:
+	virtual ~CookieIF() {};
+};
+
+#endif /* COOKIE_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 68db82e60..657f7232a 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -1,7 +1,7 @@
 #ifndef DEVICECOMMUNICATIONIF_H_
 #define DEVICECOMMUNICATIONIF_H_
 
-#include <framework/devicehandlers/Cookie.h>
+#include <framework/devicehandlers/CookieIF.h>
 #include <framework/devicehandlers/DeviceHandlerIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 /**
@@ -88,11 +88,14 @@ public:
 
 	/**
 	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * Request a reply.
+	 * It is assumed that it is always possible to request a reply
+	 * from a device. If a requestLen of 0 is supplied, no reply was enabled
+	 * and communication specific action should be taken (e.g. read nothing
+	 * or read everything).
+	 *
 	 * @param cookie
+	 * @param requestLen Size of data to read
 	 * @return -@c RETURN_OK to confirm the request for data has been sent.
-	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
-	 *         	   will not be called in the respective communication cycle.
 	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 8187ffdef..9691ac2f0 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -17,7 +17,7 @@ object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-		CookieIF * comCookie_, size_t maxReplyLen, uint8_t setDeviceSwitch,
+		CookieIF * comCookie_, uint8_t setDeviceSwitch,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
@@ -31,7 +31,6 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
 		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
 		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
 {
-	this->comCookie->setMaxReplyLen(maxReplyLen);
 	commandQueue = QueueFactory::instance()->
 			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
@@ -540,23 +539,27 @@ void DeviceHandlerBase::doGetWrite() {
 }
 
 void DeviceHandlerBase::doSendRead() {
-	ReturnValue_t result;
-
-	DeviceReplyIter iter = deviceReplyMap.find(cookieInfo.pendingCommand->first);
-	if(iter != deviceReplyMap.end()) {
-		requestLen = iter->second.replyLen;
-	}
-	else {
-		requestLen = comCookie->getMaxReplyLen();
+	ReturnValue_t result = RETURN_FAILED;
+	size_t requestLen = 0;
+	// If the device handler can only request replies after a command
+	// has been sent, there should be only one reply enabled and the
+	// correct reply length will be mapped.
+	for(DeviceReplyIter iter = deviceReplyMap.begin();
+			iter != deviceReplyMap.end();iter++)
+	{
+		if(iter->second.delayCycles != 0) {
+			requestLen = iter->second.replyLen;
+			break;
+		}
 	}
 
 	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
 	}
-	else if(result == DeviceCommunicationIF::NO_READ_REQUEST) {
+/*	else if(result == DeviceCommunicationIF::NO_READ_REQUEST) {
 		return;
-	}
+	}*/
 	else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
 		//We can't inform anyone, because we don't know which command was sent last.
@@ -1288,9 +1291,5 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t objectId, uint32_t parameter) {
 }
 
-uint32_t DeviceHandlerBase::getLogicalAddress() {
-	return this->comCookie->getAddress();
-}
-
 void DeviceHandlerBase::performOperationHook() {
 }
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 129fb288b..c162210c9 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -101,7 +101,7 @@ public:
 	 * @param cmdQueueSize
 	 */
 	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * comCookie_, size_t maxReplyLen, uint8_t setDeviceSwitch,
+			CookieIF * comCookie_, uint8_t setDeviceSwitch,
 			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
@@ -439,11 +439,6 @@ protected:
 	 */
 	size_t rawPacketLen = 0;
 
-	/**
-	 * Size of data to request.
-	 */
-	size_t requestLen = 0;
-
 	/**
 	 * The mode the device handler is currently in.
 	 *
@@ -463,11 +458,6 @@ protected:
 	 */
 	uint8_t pstStep = 0;
 
-	/**
-	 * This will be used in the RMAP getRead command as expected length, is set by the constructor, can be modiefied at will.
-	 */
-	const uint32_t maxDeviceReplyLen = 0;
-
 	/**
 	 * wiretapping flag:
 	 *
@@ -526,7 +516,6 @@ protected:
 	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.
-		uint8_t expectedRepliesWhenEnablingReplyMap; //!< Constant value which specifies expected replies when enabling reply map. Inititated in insertInCommandAndReplyMap()
 		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
 	};
 	typedef std::map<DeviceCommandId_t, DeviceCommandInfo> DeviceCommandMap;
@@ -847,11 +836,6 @@ protected:
 	 */
 	virtual bool dontCheckQueue();
 
-	/**
-	 * Used to retrieve logical address
-	 * @return logicalAddress
-	 */
-	virtual uint32_t getLogicalAddress();
 	Mode_t getBaseMode(Mode_t transitionMode);
 
 	bool isAwaitingReply();
@@ -962,11 +946,6 @@ private:
 	 */
 	CookieInfo cookieInfo;
 
-	/**
-	* cached from ctor for initialize()
-	*/
-	//const uint32_t logicalAddress = 0;
-
 	/**
 	 * Used for timing out mode transitions.
 	 *
diff --git a/rmap/RMAP.cpp b/rmap/RMAP.cpp
index 4c95f6c9e..927fe746f 100644
--- a/rmap/RMAP.cpp
+++ b/rmap/RMAP.cpp
@@ -12,8 +12,8 @@ RMAP::RMAP(){
 
 }
 
-ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, uint8_t* buffer,
-		uint32_t length) {
+ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+		size_t length) {
 	uint8_t instruction;
 
 	if ((buffer == NULL) && (length != 0)) {
@@ -61,7 +61,7 @@ ReturnValue_t RMAP::sendReadCommand(RMAPCookie *cookie, uint32_t expLength) {
 }
 
 ReturnValue_t RMAP::getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-		uint32_t *size) {
+		size_t *size) {
 	if (cookie->getChannel() == NULL) {
 		return COMMAND_NO_CHANNEL;
 	}
diff --git a/rmap/RMAP.h b/rmap/RMAP.h
index 195574f85..91aa123e2 100644
--- a/rmap/RMAP.h
+++ b/rmap/RMAP.h
@@ -153,8 +153,8 @@ public:
 	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command
 	 *      - return codes of RMAPChannelIF::sendCommand()
 	 */
-	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, uint8_t* buffer,
-			uint32_t length);
+	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+			size_t length);
 
 	/**
 	 * get the reply to a write command
@@ -204,7 +204,7 @@ public:
 	 *      - return codes of RMAPChannelIF::getReply()
 	 */
 	static ReturnValue_t getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-			uint32_t *size);
+			size_t *size);
 
 	/**
 	 * @see sendReadCommand()
diff --git a/rmap/RMAPChannelIF.h b/rmap/RMAPChannelIF.h
index 6549c8ef9..34623bb35 100644
--- a/rmap/RMAPChannelIF.h
+++ b/rmap/RMAPChannelIF.h
@@ -3,6 +3,7 @@
 
 #include <framework/rmap/RMAPCookie.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
 
 class RMAPChannelIF {
 public:
@@ -73,7 +74,7 @@ public:
 	 *      - @c NOT_SUPPORTED						if you dont feel like implementing something...
 	 */
 	virtual ReturnValue_t sendCommand(RMAPCookie *cookie, uint8_t instruction,
-			uint8_t *data, uint32_t datalen)=0;
+			const uint8_t *data, size_t datalen)=0;
 
 	/**
 	 * get the reply to an rmap command
@@ -92,7 +93,7 @@ public:
 	 *      - all RMAP standard replies
 	 */
 	virtual ReturnValue_t getReply(RMAPCookie *cookie, uint8_t **databuffer,
-			uint32_t *len)=0;
+			size_t *len)=0;
 
 	/**
 	 *
diff --git a/rmap/RMAPCookie.cpp b/rmap/RMAPCookie.cpp
index 84e407ba2..223b5165d 100644
--- a/rmap/RMAPCookie.cpp
+++ b/rmap/RMAPCookie.cpp
@@ -93,11 +93,11 @@ RMAPCookie::~RMAPCookie() {
 
 }
 
-//uint32_t RMAPCookie::getMaxReplyLen() const {
-//	return maxReplyLen;
-//}
-//
-void RMAPCookie::setMaxReplyLen(uint32_t maxReplyLen) {
+size_t RMAPCookie::getMaxReplyLen() const {
+	return maxReplyLen;
+}
+
+void RMAPCookie::setMaxReplyLen(size_t maxReplyLen) {
 	this->maxReplyLen = maxReplyLen;
 }
 
diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h
index cf033bae8..99ebd6a20 100644
--- a/rmap/RMAPCookie.h
+++ b/rmap/RMAPCookie.h
@@ -1,12 +1,13 @@
 #ifndef RMAPCOOKIE_H_
 #define RMAPCOOKIE_H_
 
-#include <framework/devicehandlers/Cookie.h>
+#include <framework/devicehandlers/CookieIF.h>
 #include <framework/rmap/rmapStructs.h>
+#include <cstddef>
 
 class RMAPChannelIF;
 
-class RMAPCookie : public Cookie {
+class RMAPCookie : public CookieIF {
 public:
 	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
 	RMAPCookie();
@@ -28,8 +29,8 @@ public:
 	void setCommandMask(uint8_t commandMask);
 	uint8_t getCommandMask();
 
-	//size_t getMaxReplyLen() const;
-	void setMaxReplyLen(uint32_t maxReplyLen);
+	size_t getMaxReplyLen() const;
+	void setMaxReplyLen(size_t maxReplyLen);
 
 	uint16_t getTransactionIdentifier() const;
 	void setTransactionIdentifier(uint16_t id_);
diff --git a/rmap/RmapDeviceCommunicationIF.cpp b/rmap/RmapDeviceCommunicationIF.cpp
index 4958b3ed7..6dc91339f 100644
--- a/rmap/RmapDeviceCommunicationIF.cpp
+++ b/rmap/RmapDeviceCommunicationIF.cpp
@@ -5,43 +5,43 @@
 RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::sendMessage(Cookie* cookie,
-		uint8_t* data, uint32_t len) {
-	return RMAP::sendWriteCommand((RMAPCookie *) cookie, data, len);
+ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF *cookie,
+		const uint8_t * sendData, size_t sendLen) {
+	return RMAP::sendWriteCommand((RMAPCookie *) cookie, sendData, sendLen);
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(Cookie* cookie) {
+ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
 	return RMAP::getWriteReply((RMAPCookie *) cookie);
 }
 
 ReturnValue_t RmapDeviceCommunicationIF::requestReceiveMessage(
-		Cookie* cookie) {
+		CookieIF *cookie, size_t requestLen) {
 	return RMAP::sendReadCommand((RMAPCookie *) cookie,
 				((RMAPCookie *) cookie)->getMaxReplyLen());
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(Cookie* cookie,
-		uint8_t** buffer, uint32_t* size) {
+ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
+		uint8_t** buffer, size_t * size) {
 	return RMAP::getReadReply((RMAPCookie *) cookie, buffer, size);
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::setAddress(Cookie* cookie,
+ReturnValue_t RmapDeviceCommunicationIF::setAddress(CookieIF* cookie,
 		uint32_t address) {
 
 	((RMAPCookie *) cookie)->setAddress(address);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-uint32_t RmapDeviceCommunicationIF::getAddress(Cookie* cookie) {
+uint32_t RmapDeviceCommunicationIF::getAddress(CookieIF* cookie) {
 	return ((RMAPCookie *) cookie)->getAddress();
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::setParameter(Cookie* cookie,
+ReturnValue_t RmapDeviceCommunicationIF::setParameter(CookieIF* cookie,
 		uint32_t parameter) {
 	//TODO Empty?
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-uint32_t RmapDeviceCommunicationIF::getParameter(Cookie* cookie) {
+uint32_t RmapDeviceCommunicationIF::getParameter(CookieIF* cookie) {
 	return 0;
 }
diff --git a/rmap/RmapDeviceCommunicationIF.h b/rmap/RmapDeviceCommunicationIF.h
index 45963d860..12bac57ae 100644
--- a/rmap/RmapDeviceCommunicationIF.h
+++ b/rmap/RmapDeviceCommunicationIF.h
@@ -17,66 +17,73 @@ class RmapDeviceCommunicationIF: public DeviceCommunicationIF {
 public:
 	virtual ~RmapDeviceCommunicationIF();
 
-
 	/**
-	 * This method is mission specific as the open call will return a mission specific cookie
-	 *
-	 * @param cookie A cookie, can be mission specific subclass of RMAP Cookie
-	 * @param address The address of the RMAP Cookie
-	 * @param maxReplyLen Maximum length of expected reply
-	 * @return
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return -@c RETURN_OK if initialization was successfull
+	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t open(Cookie **cookie, uint32_t address,
-			uint32_t maxReplyLen) = 0;
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
 
 	/**
-	 * Use an existing cookie to open a connection to a new DeviceCommunication.
-	 * The previous connection must not be closed.
-	 * If the returnvalue is not RETURN_OK, the cookie is unchanged and
-	 * can be used with the previous connection.
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return -@c RETURN_OK for successfull send
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
+			size_t sendLen);
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return -@c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device.
 	 *
 	 * @param cookie
-	 * @param address
-	 * @param maxReplyLen
-	 * @return
+	 * @return -@c RETURN_OK to confirm the request for data has been sent.
+	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
+	 *         	   will not be called in the respective communication cycle.
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t reOpen(Cookie *cookie, uint32_t address,
-			uint32_t maxReplyLen) = 0;
-
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen);
 
 	/**
-	 * Closing call of connection and free memory of cookie.
-	 * Mission dependent call
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
 	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return @c RETURN_OK for successfull receive
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
-	virtual void close(Cookie *cookie) = 0;
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+			size_t *size);
 
-	//SHOULDDO can data be const?
-	/**
-	 *
-	 *
-	 * @param cookie Expects an RMAPCookie or derived from RMAPCookie Class
-	 * @param data Data to be send
-	 * @param len Length of the data to be send
-	 * @return - Return codes of RMAP::sendWriteCommand()
-	 */
-	virtual ReturnValue_t sendMessage(Cookie *cookie, uint8_t *data,
-			uint32_t len);
-
-	virtual ReturnValue_t getSendSuccess(Cookie *cookie);
-
-	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie);
-
-	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
-			uint32_t *size);
-
-	virtual ReturnValue_t setAddress(Cookie *cookie, uint32_t address);
-
-	virtual uint32_t getAddress(Cookie *cookie);
-
-	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter);
-
-	virtual uint32_t getParameter(Cookie *cookie);
+	ReturnValue_t setAddress(CookieIF* cookie,
+			uint32_t address);
+	uint32_t getAddress(CookieIF* cookie);
+	ReturnValue_t setParameter(CookieIF* cookie,
+			uint32_t parameter);
+	uint32_t getParameter(CookieIF* cookie);
 };
 
 #endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */

From 8f39820ace6ecd146b5ac8e0ce10797c79159801 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Apr 2020 17:05:55 +0200
Subject: [PATCH 0142/1774] doc formatting

---
 devicehandlers/CookieIF.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index 55fdb44b1..ca171ff40 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -9,8 +9,8 @@
 typedef uint32_t address_t;
 
 /**
- * @brief This datatype is used to identify different connection over a single interface
- *        (like RMAP or I2C)
+ * @brief 	This datatype is used to identify different connection over a
+ * 			single interface (like RMAP or I2C)
  * @details
  * To use this class, implement a communication specific child cookie which
  * inherits Cookie. Cookie instances are created in config/ Factory.cpp by calling

From 335df7787ab118078b1a22a26cdd1259d46240ed Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Apr 2020 17:15:27 +0200
Subject: [PATCH 0143/1774] testing timeslot task 0

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 71e166a52..c33c4ef04 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -58,10 +58,6 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	if (objectManager->get<ExecutableObjectIF>(componentId) != NULL) {
-		if(slotTimeMs == 0) {
-			// FreeRTOS throws errors for zero values
-			slotTimeMs = 1;
-		}
 		pst.addSlot(componentId, slotTimeMs, executionStep, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}

From bd468a1b7498d217ca681e25c1932a39639f155f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Apr 2020 17:19:03 +0200
Subject: [PATCH 0144/1774] timeslot time 0 definitely leads to error

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index c33c4ef04..7bfee7e6d 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -58,6 +58,11 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	if (objectManager->get<ExecutableObjectIF>(componentId) != NULL) {
+		if(slotTimeMs == 0) {
+			// TODO: FreeRTOS throws errors for zero values.
+			// maybe there is a better solution than this.
+			slotTimeMs = 1;
+		}
 		pst.addSlot(componentId, slotTimeMs, executionStep, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}

From 80b1d28bc84ed4d9e86791b6e1c3e74abae3a4d4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 00:23:29 +0200
Subject: [PATCH 0145/1774] new dvice com IF return value

---
 devicehandlers/DeviceCommunicationIF.h | 33 ++++++++++++++++----------
 devicehandlers/DeviceHandlerBase.cpp   |  5 +---
 2 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 657f7232a..39cfadd75 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -29,8 +29,8 @@
  *
  *  To identify different connection over a single interface can return
  *  so-called cookies to components.
- *  The CommunicationMessage message type can be used to extend the functionality of the
- *  ComIF if a separate polling task is required.
+ *  The CommunicationMessage message type can be used to extend the
+ *  functionality of the ComIF if a separate polling task is required.
  *  @ingroup interfaces
  *  @ingroup comm
  */
@@ -38,8 +38,9 @@ class DeviceCommunicationIF: public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
 
-	//!< This is used if no read request is to be made by the device handler.
-	static const ReturnValue_t NO_READ_REQUEST = MAKE_RETURN_CODE(0x01);
+	//! This is returned in readReceivedMessage() if no reply was reived.
+	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0x01);
+
 	//! General protocol error. Define more concrete errors in child handler
 	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
 	//! If cookie is a null pointer
@@ -60,7 +61,8 @@ public:
 	 * initialization.
 	 * @param cookie
 	 * @return -@c RETURN_OK if initialization was successfull
-	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
+	 * 		   - Everything else triggers failure event with
+	 * 		   returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
 
@@ -72,7 +74,8 @@ public:
 	 * @param data
 	 * @param len
 	 * @return -@c RETURN_OK for successfull send
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 *         - Everything else triggers failure event with
+	 *         returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
 			size_t sendLen) = 0;
@@ -82,7 +85,8 @@ public:
 	 * Get send confirmation that the data in sendMessage() was sent successfully.
 	 * @param cookie
 	 * @return -@c RETURN_OK if data was sent successfull
-	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
+	 * 		   - Everything else triggers falure event with
+	 * 		   returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
 
@@ -96,7 +100,8 @@ public:
 	 * @param cookie
 	 * @param requestLen Size of data to read
 	 * @return -@c RETURN_OK to confirm the request for data has been sent.
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 *         - Everything else triggers failure event with
+	 *         returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
 
@@ -105,10 +110,14 @@ public:
 	 * This function is used to receive data from the physical device
 	 * by implementing and calling related drivers or wrapper functions.
 	 * @param cookie
-	 * @param data
-	 * @param len
-	 * @return @c RETURN_OK for successfull receive
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 * @param buffer [out] Set reply here (by using *buffer = ...)
+	 * @param size [out] size pointer to set (by using *size = ...).
+	 * 	           Set to 0 if no reply was received
+	 * @return -@c RETURN_OK for successfull receive
+	 * 		   -@c NO_REPLY_RECEIVED if not reply was received. Setting size to
+	 * 		   	   0 has the same effect
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
 			size_t *size) = 0;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 9691ac2f0..9f23dd7f5 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -557,9 +557,6 @@ void DeviceHandlerBase::doSendRead() {
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
 	}
-/*	else if(result == DeviceCommunicationIF::NO_READ_REQUEST) {
-		return;
-	}*/
 	else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
 		//We can't inform anyone, because we don't know which command was sent last.
@@ -594,7 +591,7 @@ void DeviceHandlerBase::doGetRead() {
 		return;
 	}
 
-	if (receivedDataLen == 0)
+	if (receivedDataLen == 0 or result == DeviceCommunicationIF::NO_REPLY_RECEIVED)
 		return;
 
 	if (wiretappingMode == RAW) {

From 4a35035b2890f3491d096afb22ad3421bc4d1e60 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 15:30:31 +0200
Subject: [PATCH 0146/1774] serial buffer adapted improvements

---
 serialize/SerialBufferAdapter.cpp | 127 ++++++++++++++----------------
 serialize/SerialBufferAdapter.h   |  34 +++-----
 2 files changed, 68 insertions(+), 93 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 6ac2894fe..978d8029a 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -2,83 +2,79 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <cstring>
 
-template<typename T>
-SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
-		T bufferLength, bool serializeLength) :
-		currentBufferType(bufferType::CONST), serializeLength(serializeLength),
-		constBuffer(buffer), buffer(NULL), bufferLength(bufferLength) {
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer,
+		count_t bufferLength, bool serializeLength) :
+		m_serialize_length(serializeLength),
+		m_const_buffer(static_cast<const uint8_t *>(buffer)), m_buffer(nullptr),
+		m_buffer_length(bufferLength) {
 
 }
 
-template<typename T>
-SerialBufferAdapter<T>::SerialBufferAdapter(uint8_t* buffer, T bufferLength,
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer, count_t bufferLength,
 		bool serializeLength) :
-		currentBufferType(bufferType::NORMAL),serializeLength(serializeLength), constBuffer(NULL), buffer(buffer),
-		bufferLength(bufferLength) {
+		m_serialize_length(serializeLength), m_buffer_length(bufferLength) {
+	uint8_t * member_buffer = static_cast<uint8_t *>(buffer);
+	m_buffer = member_buffer;
+	m_const_buffer = member_buffer;
 }
 
-template<typename T>
-SerialBufferAdapter<T>::SerialBufferAdapter(uint32_t* buffer,
-		T bufferLength, bool serializeLength) :
-		currentBufferType(bufferType::NORMAL),serializeLength(serializeLength),
-		constBuffer(NULL), buffer(reinterpret_cast<uint8_t *>(buffer)),
-		bufferLength(bufferLength*4) {
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
-template<typename T>
-SerialBufferAdapter<T>::~SerialBufferAdapter() {
-}
-
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size,
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, uint32_t* size,
 		const uint32_t max_size, bool bigEndian) const {
-	uint32_t serializedLength = bufferLength;
-	if (serializeLength) {
+	uint32_t serializedLength = m_buffer_length;
+	if (m_serialize_length) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
-				&bufferLength);
+				&m_buffer_length);
 	}
 	if (*size + serializedLength > max_size) {
 		return BUFFER_TOO_SHORT;
 	} else {
-		if (serializeLength) {
-			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
+		if (m_serialize_length) {
+			AutoSerializeAdapter::serialize(&m_buffer_length, buffer, size,
 					max_size, bigEndian);
 		}
-		if (this->constBuffer != NULL) {
-			memcpy(*buffer, this->constBuffer, bufferLength);
-		} else if (this->buffer != NULL) {
-			memcpy(*buffer, this->buffer, bufferLength);
+		if (this->m_const_buffer != nullptr) {
+			memcpy(*buffer, m_const_buffer, m_buffer_length);
+		} else if (this->m_buffer != nullptr) {
+			memcpy(*buffer, m_buffer, m_buffer_length);
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
-		*size += bufferLength;
-		(*buffer) += bufferLength;
+		*size += m_buffer_length;
+		(*buffer) += m_buffer_length;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 }
 
-template<typename T>
-uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
-	if (serializeLength) {
-		return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
+template<typename count_t>
+uint32_t SerialBufferAdapter<count_t>::getSerializedSize() const {
+	if (m_serialize_length) {
+		return m_buffer_length + AutoSerializeAdapter::getSerializedSize(&m_buffer_length);
 	} else {
-		return bufferLength;
+		return m_buffer_length;
 	}
 }
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		int32_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
-		if(serializeLength){
+		if(m_serialize_length){
 			// Suggestion (would require removing rest of the block inside this if clause !):
 			//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
 			//if (result != HasReturnvaluesIF::RETURN_OK) {
 			//	return result;
 			//}
-			T serializedSize = AutoSerializeAdapter::getSerializedSize(
-					&bufferLength);
-			if((*size - bufferLength - serializedSize) >= 0){
+			count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
+					&m_buffer_length);
+			if((*size - m_buffer_length - serializedSize) >= 0){
 				*buffer +=  serializedSize;
 				*size -= serializedSize;
 			}else{
@@ -86,10 +82,10 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 			}
 		}
 		//No Else If, go on with buffer
-		if (*size - bufferLength >= 0) {
-			*size -= bufferLength;
-			memcpy(this->buffer, *buffer, bufferLength);
-			(*buffer) += bufferLength;
+		if (*size - m_buffer_length >= 0) {
+			*size -= m_buffer_length;
+			memcpy(m_buffer, *buffer, m_buffer_length);
+			(*buffer) += m_buffer_length;
 			return HasReturnvaluesIF::RETURN_OK;
 		} else {
 			return STREAM_TOO_SHORT;
@@ -99,35 +95,30 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 	}
 }
 
-template<typename T>
-uint8_t * SerialBufferAdapter<T>::getBuffer() {
-	if(currentBufferType != NORMAL) {
-		warning << "Wrong access function for stored type ! Use getConstBuffer()" << std::endl;
-		return 0;
+template<typename count_t>
+uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
+	if(m_buffer == nullptr) {
+		error << "Wrong access function for stored type ! Use getConstBuffer()" << std::endl;
+		return nullptr;
 	}
-	return buffer;
+	return m_buffer;
 }
 
-template<typename T>
-const uint8_t * SerialBufferAdapter<T>::getConstBuffer() {
-	if(currentBufferType != CONST) {
-		warning << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
-		return 0;
+template<typename count_t>
+const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
+	if(m_const_buffer == nullptr) {
+		error << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
+		return nullptr;
 	}
-	return constBuffer;
+	return m_const_buffer;
 }
 
-template<typename T>
-void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_, T bufferLength_) {
-	buffer = buffer_;
-	bufferLength = bufferLength_;
+template<typename count_t>
+void SerialBufferAdapter<count_t>::setBuffer(void * buffer, count_t buffer_length) {
+	m_buffer = static_cast<uint8_t *>(buffer);
+	m_buffer_length = buffer_length;
 }
 
-template<typename T>
-void SerialBufferAdapter<T>::setBuffer(uint32_t * buffer_, T bufferLength_) {
-	buffer = reinterpret_cast<uint8_t *>(buffer_);
-	bufferLength = 4 * bufferLength_;
-}
 
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 600bd692a..4ee4ca0b8 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -16,9 +16,10 @@
  *
  * \ingroup serialize
  */
-template<typename T>
+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.
@@ -26,7 +27,7 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter(const uint8_t * buffer, T bufferLength, bool serializeLength = false);
+	SerialBufferAdapter(const void* buffer, count_t bufferLength, bool serializeLength = false);
 
 	/**
 	 * Constructor for non-constant uint8_t buffer. Length field can be serialized optionally.
@@ -35,16 +36,7 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter(uint8_t* buffer, T bufferLength, bool serializeLength = false);
-
-	/**
-	 * Constructoor for non-constant uint32_t buffer. Length field can be serialized optionally.
-	 * Type of length can be supplied as template type.
-	 * @param buffer
-	 * @param bufferLength
-	 * @param serializeLength
-	 */
-	SerialBufferAdapter(uint32_t* buffer,T bufferLength, bool serializeLength = false);
+	SerialBufferAdapter(void* buffer, count_t bufferLength, bool serializeLength = false);
 
 	virtual ~SerialBufferAdapter();
 
@@ -58,20 +50,12 @@ public:
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
-	void setBuffer(uint8_t * buffer_, T bufferLength_);
-	void setBuffer(uint32_t * buffer_, T bufferLength_);
+	void setBuffer(void* buffer_, count_t bufferLength_);
 private:
-
-	enum bufferType {
-		NORMAL,
-		CONST
-	};
-	bufferType currentBufferType;
-
-	bool serializeLength;
-	const uint8_t *constBuffer;
-	uint8_t *buffer;
-	T bufferLength;
+	bool m_serialize_length = false;
+	const uint8_t *m_const_buffer = nullptr;
+	uint8_t *m_buffer = nullptr;
+	count_t m_buffer_length = 0;
 };
 
 

From a65a19f583b4f71b4c13e3d553fc6e990fd49ba9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 15:33:24 +0200
Subject: [PATCH 0147/1774] deletd serial buffer adapter2

---
 serialize/SerialBufferAdapter.cpp |   4 +-
 serialize/SerialBufferAdapter2.h  | 148 ------------------------------
 2 files changed, 2 insertions(+), 150 deletions(-)
 delete mode 100644 serialize/SerialBufferAdapter2.h

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 978d8029a..859e7edfc 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -40,9 +40,9 @@ ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, uint32_t
 			AutoSerializeAdapter::serialize(&m_buffer_length, buffer, size,
 					max_size, bigEndian);
 		}
-		if (this->m_const_buffer != nullptr) {
+		if (m_const_buffer != nullptr) {
 			memcpy(*buffer, m_const_buffer, m_buffer_length);
-		} else if (this->m_buffer != nullptr) {
+		} else if (m_buffer != nullptr) {
 			memcpy(*buffer, m_buffer, m_buffer_length);
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
diff --git a/serialize/SerialBufferAdapter2.h b/serialize/SerialBufferAdapter2.h
deleted file mode 100644
index 98e2d187d..000000000
--- a/serialize/SerialBufferAdapter2.h
+++ /dev/null
@@ -1,148 +0,0 @@
-#ifndef SERIALBUFFERADAPTER2_H_
-#define SERIALBUFFERADAPTER2_H_
-
-#include <framework/serialize/SerializeIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-#include <cstring>
-
-/**
- * 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)>> serialBufferElement.
- * Right now, the SerialBufferAdapter must always be initialized with the buffer and size !
- *
- * \ingroup serialize
- */
-template<typename BUFFER_TYPE = uint8_t, typename count_t = uint8_t>
-class SerialBufferAdapter2: 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
-	 */
-	SerialBufferAdapter2(void * buffer_, count_t bufferLength_, bool serializeLength_ = false):
-				bufferLength(bufferLength_), serializeLength(serializeLength_) {
-		determineLengthInBytes(sizeof(BUFFER_TYPE));
-		buffer = reinterpret_cast<const uint8_t *>(buffer_);
-		constBuffer = NULL;
-	}
-
-	SerialBufferAdapter2(const void * buffer_, count_t bufferLength_, bool serializeLength_ = false):
-					bufferLength(bufferLength_), serializeLength(serializeLength_) {
-		determineLengthInBytes(sizeof(BUFFER_TYPE));
-		constBuffer = reinterpret_cast<const uint8_t *>(buffer_);
-		buffer = NULL;
-	}
-
-	ReturnValue_t serialize(uint8_t ** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		uint32_t serializedLength = bufferLength;
-		if (serializeLength) {
-			serializedLength += AutoSerializeAdapter::getSerializedSize(
-					&bufferLength);
-		}
-		if (*size + serializedLength > max_size) {
-			return BUFFER_TOO_SHORT;
-		} else {
-			if (serializeLength) {
-				AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
-						max_size, bigEndian);
-			}
-			memcpy(*buffer, this->buffer, bufferLength);
-			*size += bufferLength;
-			(*buffer) += bufferLength;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-
-	uint32_t getSerializedSize() const {
-		if (serializeLength) {
-			return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
-		} else {
-			return bufferLength;
-		}
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer,
-			int32_t* size, bool bigEndian) {
-		//TODO Ignores Endian flag!
-		if (buffer != NULL) {
-			if(serializeLength){
-				// Suggestion (would require removing rest of the block inside this if clause !):
-				//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
-				//if (result != HasReturnvaluesIF::RETURN_OK) {
-				//	return result;
-				//}
-				count_t serializedSize = AutoSerializeAdapter::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;
-		}
-	}
-
-
-	BUFFER_TYPE * getBuffer() {
-		return reinterpret_cast<BUFFER_TYPE *>(buffer);
-	}
-
-	void setBuffer(void * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
-		buffer = buffer_;
-		bufferLength = bufferLength_;
-		serializeLength = serializeLength_;
-		determineLengthInBytes(sizeof(BUFFER_TYPE));
-	}
-
-	void setConstBuffer(const void * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
-		constBuffer = buffer_;
-		bufferLength = bufferLength_;
-		serializeLength = serializeLength_;
-		determineLengthInBytes(sizeof(BUFFER_TYPE));
-	}
-private:
-	uint8_t * buffer;
-	const uint8_t * constBuffer;
-	count_t bufferLength;
-	bool serializeLength;
-
-	void determineLengthInBytes(uint8_t typeSize) {
-		switch(typeSize) {
-		case(1): break;
-		case(2):
-			bufferLength *= 2; break;
-		case(4):
-			bufferLength *= 4; break;
-		case(8):
-			bufferLength *= 8; break;
-		default:
-			error << "Serial Buffer Adapter 2: Invalid type size, assuming regular uint8_t." << std::endl;
-			error << "Detected type size: " << (int) typeSize << std::endl;
-		}
-	}
-};
-
-#endif /* SERIALBUFFERADAPTER2_H_ */

From 06ae64d59c7de1bfaa63c63249cc56c53c47d829 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 15:46:10 +0200
Subject: [PATCH 0148/1774] CSB: replaced some uint32 with size_t

---
 tmtcservices/CommandingServiceBase.cpp |  6 +++---
 tmtcservices/CommandingServiceBase.h   | 12 ++++++------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index d70b90428..8d207d9c2 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -219,8 +219,8 @@ void CommandingServiceBase::handleRequestQueue() {
 
 
 void CommandingServiceBase::sendTmPacket(uint8_t subservice,
-		const uint8_t* data, uint32_t dataLen, const uint8_t* headerData,
-		uint32_t headerSize) {
+		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
+		size_t headerSize) {
 	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
 			this->tmPacketCounter, data, dataLen, headerData, headerSize);
 	ReturnValue_t result = tmPacketStored.sendPacket(
@@ -232,7 +232,7 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
 
 
 void CommandingServiceBase::sendTmPacket(uint8_t subservice,
-		object_id_t objectId, const uint8_t *data, uint32_t dataLen) {
+		object_id_t objectId, const uint8_t *data, size_t dataLen) {
 	uint8_t buffer[sizeof(object_id_t)];
 	uint8_t* pBuffer = buffer;
 	uint32_t size = 0;
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index a62b7397d..56e9b87de 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -124,7 +124,7 @@ protected:
 	 *         - @c CSB or implementation specific return codes
 	 */
 	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, uint32_t tcDataLen, MessageQueueId_t *id,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
 			object_id_t *objectId) = 0;
 
 	/**
@@ -141,7 +141,7 @@ protected:
 	 * @return
 	 */
 	virtual ReturnValue_t prepareCommand(CommandMessage *message,
-			uint8_t subservice, const uint8_t *tcData, uint32_t tcDataLen,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
 			uint32_t *state, object_id_t objectId) = 0;
 
 	/**
@@ -219,8 +219,8 @@ protected:
 	 * @param headerData HeaderData will be placed before data
 	 * @param headerSize Size of HeaderData
 	 */
-	void sendTmPacket(uint8_t subservice, const uint8_t *data, uint32_t dataLen,
-			const uint8_t* headerData = NULL, uint32_t headerSize = 0);
+	void sendTmPacket(uint8_t subservice, const uint8_t *data, size_t dataLen,
+			const uint8_t* headerData = nullptr,size_t headerSize = 0);
 
 	/**
 	 * To send TM packets of objects that still need to be serialized and consist of an object ID with appended data
@@ -230,7 +230,7 @@ protected:
 	 * @param dataLen Length of Data
 	 */
 	void sendTmPacket(uint8_t subservice, object_id_t objectId,
-			const uint8_t *data, uint32_t dataLen);
+			const uint8_t *data, size_t dataLen);
 
 	/**
 	 * To send packets has data which is in form of a SerializeIF or Adapters implementing it
@@ -239,7 +239,7 @@ protected:
 	 * @param header Serialize IF header which will be placed before content
 	 */
 	void sendTmPacket(uint8_t subservice, SerializeIF* content,
-			SerializeIF* header = NULL);
+			SerializeIF* header = nullptr);
 
 	virtual void handleUnrequestedReply(CommandMessage *reply);
 

From 7079c9c56dc03bc1eb89311b831ff9f622257f81 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 17:58:39 +0200
Subject: [PATCH 0149/1774] replaced serializeIF serialize sizes with size_t

---
 action/ActionHelper.cpp                      |  5 +++--
 action/CommandActionHelper.cpp               |  2 +-
 container/FixedMap.h                         |  4 ++--
 datapool/DataPoolAdmin.cpp                   |  2 +-
 datapool/DataPoolParameterWrapper.cpp        |  2 +-
 datapool/DataPoolParameterWrapper.h          |  4 ++--
 datapool/DataSet.cpp                         |  4 ++--
 datapool/DataSet.h                           |  4 ++--
 datapool/PIDReader.h                         |  4 ++--
 datapool/PoolRawAccess.cpp                   |  4 ++--
 datapool/PoolRawAccess.h                     |  4 ++--
 datapool/PoolRawAccessHelper.cpp             | 11 ++++++-----
 datapool/PoolRawAccessHelper.h               | 10 +++++-----
 datapool/PoolVariable.h                      |  4 ++--
 datapool/PoolVector.h                        |  4 ++--
 devicehandlers/DeviceTmReportingWrapper.cpp  |  2 +-
 devicehandlers/DeviceTmReportingWrapper.h    |  4 ++--
 events/eventmatching/EventRangeMatcherBase.h |  4 ++--
 globalfunctions/Type.cpp                     |  4 ++--
 globalfunctions/Type.h                       |  4 ++--
 globalfunctions/matching/MatchTree.h         |  4 ++--
 globalfunctions/matching/RangeMatcher.h      |  4 ++--
 health/HealthTable.cpp                       |  2 +-
 monitoring/LimitViolationReporter.cpp        |  2 +-
 parameters/ParameterHelper.cpp               |  2 +-
 parameters/ParameterWrapper.cpp              |  8 ++++----
 parameters/ParameterWrapper.h                |  8 ++++----
 power/Fuse.cpp                               |  4 ++--
 power/Fuse.h                                 |  4 ++--
 power/PowerComponent.cpp                     |  4 ++--
 power/PowerComponent.h                       |  4 ++--
 serialize/SerialArrayListAdapter.h           |  9 +++++----
 serialize/SerialBufferAdapter.cpp            |  4 ++--
 serialize/SerialBufferAdapter.h              |  4 ++--
 serialize/SerialFixedArrayListAdapter.h      |  4 ++--
 serialize/SerialLinkedListAdapter.h          |  6 +++---
 serialize/SerializeAdapter.h                 | 14 +++++++-------
 serialize/SerializeElement.h                 |  6 ++++--
 serialize/SerializeIF.h                      |  5 +++--
 subsystem/Subsystem.cpp                      |  2 +-
 subsystem/modes/ModeDefinitions.h            |  4 ++--
 tmstorage/TmStorePackets.h                   |  8 ++++----
 tmtcpacket/packetmatcher/ApidMatcher.h       |  7 ++++---
 tmtcpacket/packetmatcher/ServiceMatcher.h    |  7 ++++---
 tmtcpacket/packetmatcher/SubserviceMatcher.h |  7 ++++---
 tmtcpacket/pus/TmPacketStored.cpp            |  2 +-
 tmtcservices/CommandingServiceBase.cpp       |  2 +-
 tmtcservices/PusVerificationReport.h         |  4 ++--
 48 files changed, 118 insertions(+), 109 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 18e46fba9..96a4824c1 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -67,7 +67,8 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 	}
 }
 
-ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data, bool hideSender) {
+ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
+		ActionId_t replyId, SerializeIF* data, bool hideSender) {
 	CommandMessage reply;
 	store_address_t storeAddress;
 	uint8_t *dataPtr;
@@ -76,7 +77,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
 		//No error, there's simply nothing to report.
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
 			&dataPtr);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index ceb97d3b9..e670121f4 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -26,7 +26,7 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	uint32_t size = 0;
+	size_t size = 0;
 	result = data->serialize(&storePointer, &size, maxSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/container/FixedMap.h b/container/FixedMap.h
index f5ee42445..314fb45a4 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -173,8 +173,8 @@ public:
 		}
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&this->_size,
 				buffer, size, max_size, bigEndian);
 		uint32_t i = 0;
diff --git a/datapool/DataPoolAdmin.cpp b/datapool/DataPoolAdmin.cpp
index e66a44e96..250137265 100644
--- a/datapool/DataPoolAdmin.cpp
+++ b/datapool/DataPoolAdmin.cpp
@@ -272,7 +272,7 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	uint32_t storeElementSize = 0;
+	size_t storeElementSize = 0;
 
 	result = wrapper->serialize(&storeElement, &storeElementSize,
 			serializedSize, true);
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index 0ff2121d6..88ac51a6a 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapool/DataPoolParameterWrapper.cpp
@@ -36,7 +36,7 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 }
 
 ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
+		size_t* size, const size_t max_size, bool bigEndian) const {
 	ReturnValue_t result;
 
 	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
diff --git a/datapool/DataPoolParameterWrapper.h b/datapool/DataPoolParameterWrapper.h
index faadf6599..32ba65098 100644
--- a/datapool/DataPoolParameterWrapper.h
+++ b/datapool/DataPoolParameterWrapper.h
@@ -11,8 +11,8 @@ public:
 
 	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	virtual uint32_t getSerializedSize() const;
 
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index b4725c735..ccd9fd3cb 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -106,8 +106,8 @@ uint8_t DataSet::lockDataPool() {
 	return ::dataPool.lockDataPool();
 }
 
-ReturnValue_t DataSet::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t DataSet::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {
 		result = registeredVariables[count]->serialize(buffer, size, max_size,
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index 8e0132239..0732feb30 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -121,8 +121,8 @@ public:
 	 * @param bigEndian
 	 * @return
 	 */
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	uint32_t getSerializedSize() const;
 
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index 299cc2fe6..68e70e869 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -126,8 +126,8 @@ public:
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
 				bigEndian);
 	}
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index ff8fb9561..63dc5b49e 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -111,8 +111,8 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 }
 
 
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	if (typeSize + *size <= max_size) {
 		if (bigEndian) {
 #ifndef BYTE_ORDER_SYSTEM
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 52ba8b210..1599a40e1 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -81,8 +81,8 @@ public:
 	 * @return - @c RETURN_OK if serialization was successfull
 	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
 	 */
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 07ea44651..7ea3576f1 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -14,14 +14,15 @@
 PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
 		uint8_t  numberOfParameters_):
 		poolIdBuffer(reinterpret_cast<uint8_t * >(poolIdBuffer_)),
-		numberOfParameters(numberOfParameters_), validBufferIndex(0), validBufferIndexBit(1){
+		numberOfParameters(numberOfParameters_), validBufferIndex(0),
+		validBufferIndexBit(1) {
 }
 
 PoolRawAccessHelper::~PoolRawAccessHelper() {
 }
 
-ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
-		const uint32_t max_size, bool bigEndian) {
+ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
+		const size_t max_size, bool bigEndian) {
 	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
 	ReturnValue_t result;
 	int32_t remainingParametersSize = numberOfParameters * 4;
@@ -39,8 +40,8 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer, uint32_t * size,
-		const uint32_t max_size, bool bigEndian) {
+ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
+		size_t * size, const size_t max_size, bool bigEndian) {
 	ReturnValue_t result;
 	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
 	int32_t remainingParametersSize = numberOfParameters * 4;
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 72f2324c6..4a4a1fabf 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -41,8 +41,8 @@ public:
 	 * @return 	@c RETURN_OK On success
 	 * 			@c RETURN_FAILED on failure
 	 */
-	ReturnValue_t serialize(uint8_t ** buffer, uint32_t * size,
-			const uint32_t max_size, bool bigEndian);
+	ReturnValue_t serialize(uint8_t ** buffer, size_t * size,
+			const size_t max_size, bool bigEndian);
 
 	/**
 	 * Serializes data pool entries into provided buffer with the validity mask buffer
@@ -54,8 +54,8 @@ public:
 	 * @return 	@c RETURN_OK On success
 	 * 			@c RETURN_FAILED on failure
 	 */
-	ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, uint32_t * size,
-			const uint32_t max_size, bool bigEndian);
+	ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, size_t * size,
+			const size_t max_size, bool bigEndian);
 
 
 private:
@@ -68,7 +68,7 @@ private:
 
 	struct SerializationArgs {
 		uint8_t ** buffer;
-		uint32_t * size;
+		size_t * size;
 		const uint32_t max_size;
 		bool bigEndian;
 	};
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index 2c48ca3e1..76418ab82 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -193,8 +193,8 @@ public:
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
 				bigEndian);
 	}
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
index d3617d17a..154cb18aa 100644
--- a/datapool/PoolVector.h
+++ b/datapool/PoolVector.h
@@ -197,8 +197,8 @@ public:
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		uint16_t i;
 		ReturnValue_t result;
 		for (i = 0; i < vector_size; i++) {
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 2c9e820fe..2be37dd4e 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -12,7 +12,7 @@ DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
 }
 
 ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
-		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
+		size_t* size, const size_t max_size, bool bigEndian) const {
 	ReturnValue_t result = SerializeAdapter<object_id_t>::serialize(&objectId,
 			buffer, size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index 1cd9470d8..ecdeca495 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -11,8 +11,8 @@ public:
 			SerializeIF *data);
 	virtual ~DeviceTmReportingWrapper();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	virtual uint32_t getSerializedSize() const;
 
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index 921a5d6a1..3906b6278 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -11,8 +11,8 @@ class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
 public:
 	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
 	virtual ~EventRangeMatcherBase() { }
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		return rangeMatcher.serialize(buffer, size, max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index 814d26f4e..e9bbab52d 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -59,8 +59,8 @@ uint8_t Type::getSize() const {
 	}
 }
 
-ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	uint8_t ptc;
 	uint8_t pfc;
 	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 88df07b6f..8d595dafb 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -39,8 +39,8 @@ public:
 
 	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	virtual uint32_t getSerializedSize() const;
 
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 398cf3f0b..ccf464f09 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -45,8 +45,8 @@ public:
 		return matchSubtree(iter, number);
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		iterator iter = this->begin();
 		uint8_t count = this->countRight(iter);
 		ReturnValue_t result = SerializeAdapter<uint8_t>::serialize(&count,
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index 10e07173b..8e0ae850f 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -27,8 +27,8 @@ public:
 		}
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound, buffer, size, max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index a575b2828..94b7cf0bf 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -65,7 +65,7 @@ bool HealthTable::hasHealth(object_id_t object) {
 
 void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
 	mutex->lockMutex(MutexIF::NO_TIMEOUT);
-	uint32_t size = 0;
+	size_t size = 0;
 	uint16_t count = healthMap.size();
 	ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
 			&pointer, &size, maxSize, true);
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 760e8b93d..77c3dad13 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -26,7 +26,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	uint32_t size = 0;
+	size_t size = 0;
 	result = data->serialize(&dataTarget, &size, maxSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index e260465ae..4ba2a1d99 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -94,7 +94,7 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	uint32_t storeElementSize = 0;
+	size_t storeElementSize = 0;
 
 	result = description->serialize(&storeElement, &storeElementSize,
 			serializedSize, true);
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 8f661bb32..501c7c4d9 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -20,8 +20,8 @@ ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
 ParameterWrapper::~ParameterWrapper() {
 }
 
-ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	ReturnValue_t result;
 
 	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
@@ -88,8 +88,8 @@ uint32_t ParameterWrapper::getSerializedSize() const {
 }
 
 template<typename T>
-ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	const T *element = (const T*) readonlyData;
 	ReturnValue_t result;
 	uint16_t dataSize = columns * rows;
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index f61786b8a..a78e586d9 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -25,8 +25,8 @@ public:
 			const void *data);
 	virtual ~ParameterWrapper();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	virtual uint32_t getSerializedSize() const;
 
@@ -128,8 +128,8 @@ private:
 	const void *readonlyData;
 
 	template<typename T>
-	ReturnValue_t serializeData(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	template<typename T>
 	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index dd5d3e3f4..93e982902 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -86,8 +86,8 @@ ReturnValue_t Fuse::check() {
 	return result;
 }
 
-ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
diff --git a/power/Fuse.h b/power/Fuse.h
index 6da241788..a9542167c 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -49,8 +49,8 @@ public:
 	uint8_t getFuseId() const;
 	ReturnValue_t initialize();
 	DeviceList devices;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 	uint32_t getSerializedSize() const;
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 	bool bigEndian);
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 6a87d88b8..83ed0e68e 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -17,8 +17,8 @@ PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, f
 				twoSwitches), min(min), max(max), moduleId(moduleId) {
 }
 
-ReturnValue_t PowerComponent::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	ReturnValue_t result = SerializeAdapter<float>::serialize(&min, buffer,
 			size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index a82fe1d7f..de08e5ec1 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -19,8 +19,8 @@ public:
 	float getMin();
 	float getMax();
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	uint32_t getSerializedSize() const;
 
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 3f80e97b6..0bc0a97b5 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -21,13 +21,14 @@ public:
 	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		return serialize(adaptee, buffer, size, max_size, bigEndian);
 	}
 
-	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) {
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list,
+			uint8_t** buffer, size_t* size, const size_t max_size,
+			bool bigEndian) {
 		// Serialize length field first
 		ReturnValue_t result = SerializeAdapter<count_t>::serialize(&list->size,
 				buffer, size, max_size, bigEndian);
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 859e7edfc..a125ef44c 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -26,8 +26,8 @@ SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
 template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	uint32_t serializedLength = m_buffer_length;
 	if (m_serialize_length) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 4ee4ca0b8..f8ff122e7 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -40,8 +40,8 @@ public:
 
 	virtual ~SerialBufferAdapter();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	virtual uint32_t getSerializedSize() const;
 
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 67954d685..e10322f9c 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -32,8 +32,8 @@ public:
 	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this, buffer, size, max_size, bigEndian);
 	}
 
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index ef1fa2007..196432af5 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -63,8 +63,8 @@ public:
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		if (printCount) {
 			count_t mySize = SinglyLinkedList<T>::getSize();
 			ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize,
@@ -78,7 +78,7 @@ public:
 	}
 
 	static ReturnValue_t serialize(const LinkedElement<T>* element,
-			uint8_t** buffer, uint32_t* size, const uint32_t max_size,
+			uint8_t** buffer, size_t* size, const size_t max_size,
 			bool bigEndian) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 18240a95e..7654eb0d9 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -59,8 +59,8 @@ template<typename T, int>
 class SerializeAdapter_ {
 public:
 	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
-		uint32_t ignoredSize = 0;
+			size_t* size, const size_t max_size, bool bigEndian) {
+		size_t ignoredSize = 0;
 		if (size == NULL) {
 			size = &ignoredSize;
 		}
@@ -115,9 +115,9 @@ public:
 template<typename T>
 class SerializeAdapter_<T, 1> {
 public:
-	ReturnValue_t serialize(const T* object, uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		uint32_t ignoredSize = 0;
+	ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
+		size_t ignoredSize = 0;
 		if (size == NULL) {
 			size = &ignoredSize;
 		}
@@ -137,7 +137,7 @@ template<typename T>
 class SerializeAdapter {
 public:
 	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
+			size_t* size, const size_t max_size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.serialize(object, buffer, size, max_size, bigEndian);
 	}
@@ -158,7 +158,7 @@ class AutoSerializeAdapter {
 public:
 	template<typename T>
 	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
+			size_t* size, const size_t max_size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.serialize(object, buffer, size, max_size, bigEndian);
 	}
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index cd040c0f7..81f557a5b 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -29,9 +29,11 @@ public:
 	}
 	SerializeElement() : LinkedElement<SerializeIF>(this) {
 	}
+
 	T entry;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		return SerializeAdapter<T>::serialize(&entry, buffer, size, max_size, bigEndian);
 	}
 
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index fb750a083..d9d361c10 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -2,6 +2,7 @@
 #define SERIALIZEIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
 
 /**
  * @defgroup serialize Serialization
@@ -36,8 +37,8 @@ public:
 	virtual ~SerializeIF() {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const = 0;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const = 0;
 
 	virtual uint32_t getSerializedSize() const = 0;
 
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 2d7d9c443..8b7f3851a 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -607,7 +607,7 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 	}
 	uint8_t *storeBuffer;
 	store_address_t address;
-	uint32_t size = 0;
+	size_t size = 0;
 
 	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 8e7531f3d..8a88eb92e 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -18,8 +18,8 @@ public:
 	uint8_t value3;
 	uint8_t value4;
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 
 		ReturnValue_t result;
 
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 6eea6f586..b31b37cb1 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -32,8 +32,8 @@ public:
 	}
 	uint16_t apid;
 	uint16_t ssc;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&apid,
 				buffer, size, max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -218,8 +218,8 @@ public:
 	}
 
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		ReturnValue_t result = AutoSerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 1f1949682..0140340bd 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -22,9 +22,10 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<uint16_t>::serialize(&apid, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
+		return SerializeAdapter<uint16_t>::serialize(&apid, buffer,
+				size, max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
 		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index 1a6781b40..be2dd2f56 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -22,9 +22,10 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<uint8_t>::serialize(&service, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
+		return SerializeAdapter<uint8_t>::serialize(&service, buffer,
+				size, max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 1b589b201..de62e1835 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -20,9 +20,10 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
+		return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size,
+				max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index bb9326418..c66e33245 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -58,7 +58,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	setData(p_data);
 	initializeTmPacket(apid, service, subservice, packetSubcounter);
 	uint8_t* putDataHere = getSourceData();
-	uint32_t size = 0;
+	size_t size = 0;
 	if (header != NULL) {
 		header->serialize(&putDataHere, &size, sourceDataSize, true);
 	}
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 8d207d9c2..5b3977567 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -235,7 +235,7 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
 		object_id_t objectId, const uint8_t *data, size_t dataLen) {
 	uint8_t buffer[sizeof(object_id_t)];
 	uint8_t* pBuffer = buffer;
-	uint32_t size = 0;
+	size_t size = 0;
 	SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
 			sizeof(object_id_t), true);
 	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h
index 7a173be9f..f8913627f 100644
--- a/tmtcservices/PusVerificationReport.h
+++ b/tmtcservices/PusVerificationReport.h
@@ -49,7 +49,7 @@ class PusSuccessReport {
 private:
 	static const uint16_t MAX_SIZE = 7;
 	uint8_t reportBuffer[MAX_SIZE];
-	uint32_t reportSize;
+	size_t reportSize;
 	uint8_t * pBuffer;
 public:
 	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
@@ -63,7 +63,7 @@ class PusFailureReport {
 private:
 	static const uint16_t MAX_SIZE = 16;
 	uint8_t reportBuffer[MAX_SIZE];
-	uint32_t reportSize;
+	size_t reportSize;
 	uint8_t * pBuffer;
 public:
 	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,

From 87852e5f2a3983e21c99a18f8503a511a158cecd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 21:54:11 +0200
Subject: [PATCH 0150/1774] replaced getSerializedSize returnvalue with size_t

---
 action/ActionHelper.cpp                      | 2 +-
 action/CommandActionHelper.cpp               | 2 +-
 container/FixedMap.h                         | 2 +-
 container/IndexedRingMemoryArray.h           | 6 +++---
 datapool/DataPoolParameterWrapper.cpp        | 2 +-
 datapool/DataPoolParameterWrapper.h          | 2 +-
 datapool/DataSet.cpp                         | 4 ++--
 datapool/DataSet.h                           | 2 +-
 datapool/PIDReader.h                         | 2 +-
 datapool/PoolRawAccess.cpp                   | 2 +-
 datapool/PoolRawAccess.h                     | 2 +-
 datapool/PoolVariable.h                      | 2 +-
 datapool/PoolVector.h                        | 2 +-
 devicehandlers/DeviceTmReportingWrapper.cpp  | 2 +-
 devicehandlers/DeviceTmReportingWrapper.h    | 2 +-
 events/eventmatching/EventRangeMatcherBase.h | 2 +-
 globalfunctions/Type.cpp                     | 2 +-
 globalfunctions/Type.h                       | 2 +-
 globalfunctions/matching/MatchTree.h         | 2 +-
 globalfunctions/matching/RangeMatcher.h      | 2 +-
 monitoring/LimitViolationReporter.cpp        | 2 +-
 parameters/ParameterWrapper.cpp              | 2 +-
 parameters/ParameterWrapper.h                | 2 +-
 power/Fuse.cpp                               | 2 +-
 power/PowerComponent.cpp                     | 2 +-
 power/PowerComponent.h                       | 2 +-
 serialize/SerialArrayListAdapter.h           | 2 +-
 serialize/SerialBufferAdapter.cpp            | 2 +-
 serialize/SerialBufferAdapter.h              | 2 +-
 serialize/SerialFixedArrayListAdapter.h      | 2 +-
 serialize/SerialLinkedListAdapter.h          | 2 +-
 serialize/SerializeElement.h                 | 2 +-
 serialize/SerializeIF.h                      | 2 +-
 subsystem/Subsystem.cpp                      | 2 +-
 subsystem/modes/ModeDefinitions.h            | 2 +-
 tmstorage/TmStorePackets.h                   | 4 ++--
 tmtcpacket/packetmatcher/ApidMatcher.h       | 2 +-
 tmtcpacket/packetmatcher/ServiceMatcher.h    | 2 +-
 tmtcpacket/packetmatcher/SubserviceMatcher.h | 2 +-
 tmtcpacket/pus/TmPacketStored.cpp            | 2 +-
 40 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 96a4824c1..ef9f06a9e 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -72,7 +72,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 	CommandMessage reply;
 	store_address_t storeAddress;
 	uint8_t *dataPtr;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	if (maxSize == 0) {
 		//No error, there's simply nothing to report.
 		return HasReturnvaluesIF::RETURN_OK;
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index e670121f4..772954014 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -20,7 +20,7 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 	}
 	store_address_t storeId;
 	uint8_t* storePointer;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
 			&storePointer);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/container/FixedMap.h b/container/FixedMap.h
index 314fb45a4..23a79aefc 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -188,7 +188,7 @@ public:
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		uint32_t printSize = sizeof(_size);
 		uint32_t i = 0;
 
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 4ab174f4b..8682780ad 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -159,7 +159,7 @@ public:
 		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
 
 		//Calculate the Size needeed for the index itself
-		uint32_t serializedSize = 0;
+		size_t serializedSize = 0;
 		if(additionalInfo!=NULL) {
 			serializedSize += additionalInfo->getSerializedSize();
 		}
@@ -548,9 +548,9 @@ public:
 	 * Get the serialized Size of the index
 	 * @return The serialized size of the index
 	 */
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 
-		uint32_t size = 0;
+		size_t size = 0;
 		if(additionalInfo!=NULL){
 			size += additionalInfo->getSerializedSize();
 		}
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index 88ac51a6a..aa194b61c 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapool/DataPoolParameterWrapper.cpp
@@ -69,7 +69,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 }
 
 //same as ParameterWrapper
-uint32_t DataPoolParameterWrapper::getSerializedSize() const {
+size_t DataPoolParameterWrapper::getSerializedSize() const {
 	uint32_t serializedSize = 0;
 	serializedSize += type.getSerializedSize();
 	serializedSize += sizeof(rows);
diff --git a/datapool/DataPoolParameterWrapper.h b/datapool/DataPoolParameterWrapper.h
index 32ba65098..c9631b9c4 100644
--- a/datapool/DataPoolParameterWrapper.h
+++ b/datapool/DataPoolParameterWrapper.h
@@ -14,7 +14,7 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index ccd9fd3cb..90baf063a 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -119,8 +119,8 @@ ReturnValue_t DataSet::serialize(uint8_t** buffer, size_t* size,
 	return result;
 }
 
-uint32_t DataSet::getSerializedSize() const {
-	uint32_t size = 0;
+size_t DataSet::getSerializedSize() const {
+	size_t size = 0;
 	for (uint16_t count = 0; count < fill_count; count++) {
 		size += registeredVariables[count]->getSerializedSize();
 	}
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index 0732feb30..9bcdb8920 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -124,7 +124,7 @@ public:
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index 68e70e869..d6b10b653 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -132,7 +132,7 @@ public:
 				bigEndian);
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 63dc5b49e..16d6562e5 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -193,7 +193,7 @@ uint16_t PoolRawAccess::getSizeTillEnd() const {
 }
 
 
-uint32_t PoolRawAccess::getSerializedSize() const {
+size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
 }
 
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 1599a40e1..73a609ff0 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -125,7 +125,7 @@ public:
 	 */
 	uint16_t getSizeTillEnd() const;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index 76418ab82..351ffec3a 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -199,7 +199,7 @@ public:
 				bigEndian);
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
index 154cb18aa..a21f31d2d 100644
--- a/datapool/PoolVector.h
+++ b/datapool/PoolVector.h
@@ -211,7 +211,7 @@ public:
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
 	}
 
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 2be37dd4e..344a1dc12 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -26,7 +26,7 @@ ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
 	return data->serialize(buffer, size, max_size, bigEndian);
 }
 
-uint32_t DeviceTmReportingWrapper::getSerializedSize() const {
+size_t DeviceTmReportingWrapper::getSerializedSize() const {
 	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
 }
 
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index ecdeca495..1582ff484 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -14,7 +14,7 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index 3906b6278..0f096b9c8 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -15,7 +15,7 @@ public:
 			const size_t max_size, bool bigEndian) const {
 		return rangeMatcher.serialize(buffer, size, max_size, bigEndian);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return rangeMatcher.getSerializedSize();
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index e9bbab52d..0d6d7c1d8 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -81,7 +81,7 @@ ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
 
 }
 
-uint32_t Type::getSerializedSize() const {
+size_t Type::getSerializedSize() const {
 	uint8_t dontcare = 0;
 	return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
 }
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 8d595dafb..e6413d2d5 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -42,7 +42,7 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index ccf464f09..3b8e1942f 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -86,7 +86,7 @@ public:
 		return result;
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		//Analogous to serialize!
 		uint32_t size = 1; //One for count
 		iterator iter = this->begin();
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index 8e0ae850f..c93e79197 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -40,7 +40,7 @@ public:
 		return SerializeAdapter<bool>::serialize(&inverted, buffer, size, max_size, bigEndian);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 77c3dad13..234a0bffb 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -17,7 +17,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	}
 	store_address_t storeId;
 	uint8_t* dataTarget = NULL;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
 		return MonitoringIF::INVALID_SIZE;
 	}
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 501c7c4d9..f359a7450 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -77,7 +77,7 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, size_t* size,
 	return result;
 }
 
-uint32_t ParameterWrapper::getSerializedSize() const {
+size_t ParameterWrapper::getSerializedSize() const {
 	uint32_t serializedSize = 0;
 	serializedSize += type.getSerializedSize();
 	serializedSize += sizeof(rows);
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index a78e586d9..6681f7c43 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -28,7 +28,7 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 93e982902..04adac804 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -100,7 +100,7 @@ ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
 }
 
 uint32_t Fuse::getSerializedSize() const {
-	uint32_t size = 0;
+	size_t size = 0;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
 		size += (*iter)->getSerializedSize();
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 83ed0e68e..b7158e624 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -28,7 +28,7 @@ ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
 			bigEndian);
 }
 
-uint32_t PowerComponent::getSerializedSize() const {
+size_t PowerComponent::getSerializedSize() const {
 	return sizeof(min) + sizeof(max);
 }
 
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index de08e5ec1..973416672 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -22,7 +22,7 @@ public:
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 0bc0a97b5..5274c4889 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -41,7 +41,7 @@ public:
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return getSerializedSize(adaptee);
 	}
 
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index a125ef44c..83fda418b 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -54,7 +54,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t*
 }
 
 template<typename count_t>
-uint32_t SerialBufferAdapter<count_t>::getSerializedSize() const {
+size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
 	if (m_serialize_length) {
 		return m_buffer_length + AutoSerializeAdapter::getSerializedSize(&m_buffer_length);
 	} else {
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index f8ff122e7..0c3d4dd69 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -43,7 +43,7 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index e10322f9c..573d33147 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -37,7 +37,7 @@ public:
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this, buffer, size, max_size, bigEndian);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 196432af5..0865faa5e 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -88,7 +88,7 @@ public:
 		}
 		return result;
 	}
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		if (printCount) {
 			return SerialLinkedListAdapter<T>::getSerializedSize()
 					+ sizeof(count_t);
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 81f557a5b..fe9d5d713 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -37,7 +37,7 @@ public:
 		return SerializeAdapter<T>::serialize(&entry, buffer, size, max_size, bigEndian);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter<T>::getSerializedSize(&entry);
 	}
 
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index d9d361c10..a9f40a080 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -40,7 +40,7 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const = 0;
 
-	virtual uint32_t getSerializedSize() const = 0;
+	virtual size_t getSerializedSize() const = 0;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) = 0;
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 8b7f3851a..1c4bee335 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -601,7 +601,7 @@ void Subsystem::transitionFailed(ReturnValue_t failureCode,
 void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 		SerializeIF** elements, uint8_t count) {
 	ReturnValue_t result;
-	uint32_t maxSize = 0;
+	size_t maxSize = 0;
 	for (uint8_t i = 0; i < count; i++) {
 		maxSize += elements[i]->getSerializedSize();
 	}
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 8a88eb92e..406f95835 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -49,7 +49,7 @@ public:
 
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
 	}
 
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index b31b37cb1..b6c63b917 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -44,7 +44,7 @@ public:
 
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return sizeof(apid) + sizeof(ssc);
 	}
 
@@ -244,7 +244,7 @@ public:
 		return adapter.serialize(buffer,size,max_size,bigEndian);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		uint32_t size = 0;
 		size += AutoSerializeAdapter::getSerializedSize(&apid);
 		size += AutoSerializeAdapter::getSerializedSize(&sourceSequenceCount);
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 0140340bd..37b91bd30 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -27,7 +27,7 @@ public:
 		return SerializeAdapter<uint16_t>::serialize(&apid, buffer,
 				size, max_size, bigEndian);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index be2dd2f56..31502053b 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -27,7 +27,7 @@ public:
 		return SerializeAdapter<uint8_t>::serialize(&service, buffer,
 				size, max_size, bigEndian);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index de62e1835..8b872876a 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -25,7 +25,7 @@ public:
 		return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size,
 				max_size, bigEndian);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index c66e33245..b60f6c7e0 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -42,7 +42,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	if (!checkAndSetStore()) {
 		return;
 	}
-	uint32_t sourceDataSize = 0;
+	size_t sourceDataSize = 0;
 	if (content != NULL) {
 		sourceDataSize += content->getSerializedSize();
 	}

From 42838272a522b76c9e055f93bdf7af6d00b84b01 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 22:42:48 +0200
Subject: [PATCH 0151/1774] replaced int32_t size by ssize_t (type trait trick)

---
 container/FixedMap.h                         |  2 +-
 datapool/DataPoolParameterWrapper.cpp        |  2 +-
 datapool/DataPoolParameterWrapper.h          |  2 +-
 datapool/DataSet.cpp                         |  2 +-
 datapool/DataSet.h                           |  2 +-
 datapool/PIDReader.h                         |  2 +-
 datapool/PoolRawAccess.cpp                   |  2 +-
 datapool/PoolRawAccess.h                     |  2 +-
 datapool/PoolRawAccessHelper.cpp             |  6 +++---
 datapool/PoolRawAccessHelper.h               |  8 +++++---
 datapool/PoolVariable.h                      |  2 +-
 datapool/PoolVector.h                        |  2 +-
 devicehandlers/DeviceTmReportingWrapper.cpp  |  2 +-
 devicehandlers/DeviceTmReportingWrapper.h    |  2 +-
 events/eventmatching/EventRangeMatcherBase.h |  2 +-
 globalfunctions/Type.cpp                     |  3 +--
 globalfunctions/Type.h                       |  2 +-
 globalfunctions/matching/MatchTree.h         |  2 +-
 globalfunctions/matching/RangeMatcher.h      |  2 +-
 parameters/ParameterWrapper.cpp              | 10 +++++-----
 parameters/ParameterWrapper.h                |  8 ++++----
 power/Fuse.cpp                               |  2 +-
 power/Fuse.h                                 |  4 ++--
 power/PowerComponent.cpp                     |  4 ++--
 power/PowerComponent.h                       |  2 +-
 serialize/SerialArrayListAdapter.h           |  6 +++---
 serialize/SerialBufferAdapter.cpp            |  2 +-
 serialize/SerialBufferAdapter.h              |  2 +-
 serialize/SerialFixedArrayListAdapter.h      |  5 +++--
 serialize/SerialLinkedListAdapter.h          |  4 ++--
 serialize/SerializeAdapter.h                 |  8 ++++----
 serialize/SerializeElement.h                 |  3 ++-
 serialize/SerializeIF.h                      |  4 +++-
 subsystem/Subsystem.cpp                      |  4 ++--
 subsystem/modes/ModeDefinitions.h            |  2 +-
 thermal/ThermalComponent.cpp                 |  4 ++--
 thermal/ThermalComponent.h                   |  2 +-
 tmstorage/TmStorePackets.h                   |  4 ++--
 tmtcpacket/packetmatcher/ApidMatcher.h       |  2 +-
 tmtcpacket/packetmatcher/ServiceMatcher.h    |  2 +-
 tmtcpacket/packetmatcher/SubserviceMatcher.h |  2 +-
 41 files changed, 70 insertions(+), 65 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 23a79aefc..7f3d28f7d 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -201,7 +201,7 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size,
 				buffer, size, bigEndian);
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index aa194b61c..7139a0d89 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapool/DataPoolParameterWrapper.cpp
@@ -80,7 +80,7 @@ size_t DataPoolParameterWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		ssize_t* size, bool bigEndian) {
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/datapool/DataPoolParameterWrapper.h b/datapool/DataPoolParameterWrapper.h
index c9631b9c4..45d3de537 100644
--- a/datapool/DataPoolParameterWrapper.h
+++ b/datapool/DataPoolParameterWrapper.h
@@ -16,7 +16,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index 90baf063a..eabb4b8c1 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -136,7 +136,7 @@ void DataSet::setValid(uint8_t valid) {
 	}
 }
 
-ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, ssize_t* size,
 		bool bigEndian) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index 9bcdb8920..888d45e65 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -126,7 +126,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
 private:
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index d6b10b653..26a9e2a80 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -136,7 +136,7 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 	bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
 	}
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 16d6562e5..b5f94c8c5 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -197,7 +197,7 @@ size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
 }
 
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, ssize_t* size,
 		bool bigEndian) {
 	*size -= typeSize;
 	if (*size >= 0) {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 73a609ff0..955c640ba 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -127,7 +127,7 @@ public:
 
 	size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
 protected:
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 7ea3576f1..cac6e5064 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -25,7 +25,7 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 		const size_t max_size, bool bigEndian) {
 	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
 	ReturnValue_t result;
-	int32_t remainingParametersSize = numberOfParameters * 4;
+	ssize_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
 		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
 				&remainingParametersSize, false);
@@ -44,7 +44,7 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		size_t * size, const size_t max_size, bool bigEndian) {
 	ReturnValue_t result;
 	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
-	int32_t remainingParametersSize = numberOfParameters * 4;
+	ssize_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
 	uint8_t validityMask[validityMaskSize];
 	memset(validityMask,0, validityMaskSize);
@@ -68,7 +68,7 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 }
 
 ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
-		int32_t * remainingParameters, bool withValidMask, uint8_t * validityMask) {
+		ssize_t * remainingParameters, bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
 	// Deserialize current pool ID from pool ID buffer
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 4a4a1fabf..89974ea4f 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -85,10 +85,12 @@ private:
 	 * @return
 	 */
 	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
-				int32_t * remainingParameters, bool withValidMask = false, uint8_t * validityMask = NULL);
+				ssize_t * remainingParameters, bool withValidMask = false,
+				uint8_t * validityMask = nullptr);
 
-	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
-				bool withValidMask = false, uint8_t * validityMask = NULL);
+	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,
+			SerializationArgs argStruct, bool withValidMask = false,
+			uint8_t * validityMask = nullptr);
 
 	ReturnValue_t checkRemainingSize(PoolRawAccess * currentPoolRawAccess,
 			bool * isSerialized, uint8_t * arrayPosition);
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index 351ffec3a..d32cdf22a 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -203,7 +203,7 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
 	}
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
index a21f31d2d..3e82a721a 100644
--- a/datapool/PoolVector.h
+++ b/datapool/PoolVector.h
@@ -215,7 +215,7 @@ public:
 		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		uint16_t i;
 		ReturnValue_t result;
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 344a1dc12..4987c7fb5 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -31,7 +31,7 @@ size_t DeviceTmReportingWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		ssize_t* size, bool bigEndian) {
 	ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
 			buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index 1582ff484..fce748147 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -16,7 +16,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 private:
 	object_id_t objectId;
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index 0f096b9c8..8dea3e101 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -18,7 +18,7 @@ public:
 	size_t getSerializedSize() const {
 		return rangeMatcher.getSerializedSize();
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return rangeMatcher.deSerialize(buffer, size, bigEndian);
 	}
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index 0d6d7c1d8..ea2ad896f 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -1,4 +1,3 @@
-#include <framework/serialize/SerializeAdapter.h>
 #include <framework/globalfunctions/Type.h>
 #include <framework/serialize/SerializeAdapter.h>
 
@@ -86,7 +85,7 @@ size_t Type::getSerializedSize() const {
 	return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
 }
 
-ReturnValue_t Type::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t Type::deSerialize(const uint8_t** buffer, ssize_t* size,
 		bool bigEndian) {
 	uint8_t ptc;
 	uint8_t pfc;
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index e6413d2d5..244091f71 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -44,7 +44,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
 private:
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 3b8e1942f..498fe8603 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -115,7 +115,7 @@ public:
 		return size;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index c93e79197..c09802554 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -44,7 +44,7 @@ public:
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound, buffer, size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index f359a7450..1420c0761 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -112,7 +112,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 
 	//treat from as a continuous Stream as we copy all of it
 	const uint8_t *fromAsStream = (const uint8_t *) from;
-	int32_t streamSize = fromRows * fromColumns * sizeof(T);
+	ssize_t streamSize = fromRows * fromColumns * sizeof(T);
 
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
@@ -137,12 +137,12 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		ssize_t* size, bool bigEndian) {
 	return deSerialize(buffer, size, bigEndian, 0);
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
+		ssize_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
 	ParameterWrapper streamDescription;
 
 	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
@@ -153,8 +153,8 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
 	return copyFrom(&streamDescription, startWritingAtIndex);
 }
 
-ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
-		const uint8_t **remainingStream, int32_t *remainingSize) {
+ReturnValue_t ParameterWrapper::set(const uint8_t* stream, ssize_t streamSize,
+		const uint8_t **remainingStream, ssize_t *remainingSize) {
 	ReturnValue_t result = SerializeAdapter<Type>::deSerialize(&type, &stream,
 			&streamSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 6681f7c43..6f8f6fc97 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -30,10 +30,10 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian, uint16_t startWritingAtIndex = 0);
 
 	template<typename T>
@@ -111,8 +111,8 @@ 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, int32_t streamSize,
-			const uint8_t **remainingStream = NULL, int32_t *remainingSize =
+	ReturnValue_t set(const uint8_t *stream, ssize_t streamSize,
+			const uint8_t **remainingStream = NULL, ssize_t *remainingSize =
 					NULL);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 04adac804..6a4e6caf6 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -108,7 +108,7 @@ uint32_t Fuse::getSerializedSize() const {
 	return size;
 }
 
-ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, ssize_t* size,
 bool bigEndian) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
diff --git a/power/Fuse.h b/power/Fuse.h
index a9542167c..b3c9547ac 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -52,8 +52,8 @@ public:
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 	uint32_t getSerializedSize() const;
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+				bool bigEndian);
 	void setAllMonitorsToUnchecked();
 	ReturnValue_t performOperation(uint8_t opCode);
 	MessageQueueId_t getCommandQueue() const;
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index b7158e624..77e60d0e1 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -56,8 +56,8 @@ float PowerComponent::getMax() {
 	return max;
 }
 
-ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, int32_t* size,
-bool bigEndian) {
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, ssize_t* size,
+			bool bigEndian) {
 	ReturnValue_t result = SerializeAdapter<float>::deSerialize(&min, buffer,
 			size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 973416672..1410e69d3 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -24,7 +24,7 @@ public:
 
 	size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 5274c4889..21a669c2d 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -56,13 +56,13 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return deSerialize(adaptee, buffer, size, bigEndian);
 	}
 
-	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
+			const uint8_t** buffer, ssize_t* size, bool bigEndian) {
 		count_t tempSize = 0;
 		ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize,
 				buffer, size, bigEndian);
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 83fda418b..618e8a152 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -63,7 +63,7 @@ size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
 }
 template<typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		ssize_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
 		if(m_serialize_length){
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 0c3d4dd69..ff2083de1 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -45,7 +45,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
 	uint8_t * getBuffer();
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 573d33147..8bcbf09e7 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -40,9 +40,10 @@ public:
 	size_t getSerializedSize() const {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
-		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this, buffer, size, bigEndian);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
+				buffer, size, bigEndian);
 	}
 
 	void swapArrayListEndianness() {
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 0865faa5e..80dbcaf1c 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -112,13 +112,13 @@ public:
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
 	}
 
 	static ReturnValue_t deSerialize(LinkedElement<T>* element,
-			const uint8_t** buffer, int32_t* size, bool bigEndian) {
+			const uint8_t** buffer, ssize_t* size, bool bigEndian) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
 			result = element->value->deSerialize(buffer, size, bigEndian);
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 7654eb0d9..81a3730f8 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -88,7 +88,7 @@ public:
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		T tmp;
 		*size -= sizeof(T);
@@ -127,7 +127,7 @@ public:
 		return object->getSerializedSize();
 	}
 
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return object->deSerialize(buffer, size, bigEndian);
 	}
@@ -147,7 +147,7 @@ public:
 	}
 
 	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			int32_t* size, bool bigEndian) {
+			ssize_t* size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.deSerialize(object, buffer, size, bigEndian);
 	}
@@ -169,7 +169,7 @@ public:
 	}
 	template<typename T>
 	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			int32_t* size, bool bigEndian) {
+			ssize_t* size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.deSerialize(object, buffer, size, bigEndian);
 	}
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index fe9d5d713..e2da5c141 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -41,10 +41,11 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&entry);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
 	}
+
 	operator T() {
 		return entry;
 	}
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index a9f40a080..d547daac7 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -3,7 +3,9 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
+#include <type_traits>
 
+typedef std::make_signed<std::size_t>::type ssize_t;
 /**
  * @defgroup serialize Serialization
  * Contains serialisation services.
@@ -42,7 +44,7 @@ public:
 
 	virtual size_t getSerializedSize() const = 0;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) = 0;
 
 };
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 1c4bee335..e4a682bae 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -168,7 +168,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				&sizeRead);
 		if (result == RETURN_OK) {
 			Mode_t fallbackId;
-			int32_t size = sizeRead;
+			ssize_t size = sizeRead;
 			result = SerializeAdapter<Mode_t>::deSerialize(&fallbackId,
 					&pointer, &size, true);
 			if (result == RETURN_OK) {
@@ -193,7 +193,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
 		if (result == RETURN_OK) {
-			int32_t size = sizeRead;
+			ssize_t size = sizeRead;
 			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
 					&pointer, &size, true);
 			if (result == RETURN_OK) {
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 406f95835..4c0c4a261 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -53,7 +53,7 @@ public:
 		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 	bool bigEndian) {
 		ReturnValue_t result;
 
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 15a2bbc9c..737ffd2ea 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -40,11 +40,11 @@ ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
 	}
 }
 
-ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
+ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, ssize_t size) {
 	if (size != 4 * sizeof(parameters.lowerOpLimit)) {
 		return MonitoringIF::INVALID_SIZE;
 	}
-	int32_t readSize = size;
+	ssize_t readSize = size;
 	SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
 			&readSize, true);
 	SerializeAdapter<float>::deSerialize(&parameters.lowerOpLimit, &data,
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 4e32e97cd..37ed01c0f 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -53,7 +53,7 @@ public:
 
 	ReturnValue_t setTargetState(int8_t newState);
 
-	virtual ReturnValue_t setLimits( const uint8_t* data, uint32_t size);
+	virtual ReturnValue_t setLimits( const uint8_t* data, ssize_t size);
 
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index b6c63b917..4e7bc94b4 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -48,7 +48,7 @@ public:
 		return sizeof(apid) + sizeof(ssc);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 	bool bigEndian) {
 		ReturnValue_t result = SerializeAdapter<uint16_t>::deSerialize(&apid,
 				buffer, size, bigEndian);
@@ -257,7 +257,7 @@ public:
 
 	};
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 	bool bigEndian) {
 		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&apid, buffer,
 				size, bigEndian);
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 37b91bd30..1ee444762 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -30,7 +30,7 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer, size, bigEndian);
 	}
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index 31502053b..b69ac7a5d 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -30,7 +30,7 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer, size, bigEndian);
 	}
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 8b872876a..9c93af649 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -28,7 +28,7 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer, size, bigEndian);
 	}

From e791f44c41525bc742c9027bbeb08a530cd5a424 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 23:03:32 +0200
Subject: [PATCH 0152/1774] copy ctor and assgnment op forbidden

for serial linked lists
---
 returnvalues/HasReturnvaluesIF.h    |  2 +-
 serialize/SerialLinkedListAdapter.h | 10 ++++++++++
 serialize/SerializeIF.h             |  3 +++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index b8b72a9fc..d84fc7578 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -1,9 +1,9 @@
 #ifndef HASRETURNVALUESIF_H_
 #define HASRETURNVALUESIF_H_
 
-#include <stdint.h>
 #include <framework/returnvalues/FwClassIds.h>
 #include <config/returnvalues/classIds.h>
+#include <cstdint>
 
 #define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
 typedef uint16_t ReturnValue_t;
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 80dbcaf1c..b5c06a166 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -41,6 +41,16 @@
 template<typename T, typename count_t = uint8_t>
 class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
 public:
+	/**
+	 * 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;
+
 	SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
 			bool printCount = false) :
 			SinglyLinkedList<T>(start), printCount(printCount) {
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index d547daac7..da401b2f9 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -5,7 +5,10 @@
 #include <cstddef>
 #include <type_traits>
 
+#ifndef ssize_t
 typedef std::make_signed<std::size_t>::type ssize_t;
+#endif
+
 /**
  * @defgroup serialize Serialization
  * Contains serialisation services.

From 3654c7bf8162cd176509db6d83241f077bdfb929 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Apr 2020 11:15:44 +0200
Subject: [PATCH 0153/1774] some form stuff

---
 datapool/PoolEntry.cpp              | 6 ++++--
 osal/FreeRTOS/FixedTimeslotTask.cpp | 3 ++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 898d226e2..e5d4ffdef 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -2,7 +2,8 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t set_length, uint8_t set_valid ) : length(set_length), valid(set_valid) {
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t set_length,
+		uint8_t set_valid ) : length(set_length), valid(set_valid) {
 	this->address = new T[this->length];
 	if(initValue.size() == 0) {
 		memset(this->address, 0, this->getByteSize());
@@ -13,7 +14,8 @@ PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t set_length,
 }
 
 template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t set_length, uint8_t set_valid ) : length(set_length), valid(set_valid) {
+PoolEntry<T>::PoolEntry( T* initValue, uint8_t set_length, uint8_t set_valid ) :
+		length(set_length), valid(set_valid) {
 	this->address = new T[this->length];
 	if (initValue != NULL) {
 		memcpy(this->address, initValue, this->getByteSize() );
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 7bfee7e6d..b1c974202 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -67,7 +67,8 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	error << "Component " << std::hex << componentId << " not found, not adding it to pst" << std::endl;
+	error << "Component " << std::hex << componentId
+		  << " not found, not adding it to pst" << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 

From 78aad91aab99ff6123d8575300613dd14a79b81e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Apr 2020 12:38:39 +0200
Subject: [PATCH 0154/1774] PSB subservice passed to handleRequest

---
 tmtcservices/PusServiceBase.cpp | 2 +-
 tmtcservices/PusServiceBase.h   | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index 6e1053252..a0ab17681 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -29,7 +29,7 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
 			this->currentPacket.setStoreAddress(message.getStorageId());
 			//	info << "Service " << (uint16_t) this->serviceId << ": new packet!" << std::endl;
 
-			ReturnValue_t return_code = this->handleRequest();
+			ReturnValue_t return_code = this->handleRequest(currentPacket.getSubService());
 			// debug << "Service " << (uint16_t)this->serviceId << ": handleRequest returned: " << (int)return_code << std::endl;
 			if (return_code == RETURN_OK) {
 				this->verifyReporter.sendSuccessReport(
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 6c8c5f617..de16ebe28 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -30,7 +30,10 @@ void setStaticFrameworkObjectIds();
  * All PUS Services are System Objects, so an Object ID needs to be specified on construction.
  * \ingroup pus_services
  */
-class PusServiceBase : public ExecutableObjectIF, public AcceptsTelecommandsIF, public SystemObject, public HasReturnvaluesIF {
+class PusServiceBase : public ExecutableObjectIF,
+        public AcceptsTelecommandsIF,
+        public SystemObject,
+        public HasReturnvaluesIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	/**
@@ -63,7 +66,7 @@ public:
 	 * @return	The returned status_code is directly taken as main error code in the Verification Report.
 	 * 			On success, RETURN_OK shall be returned.
 	 */
-	virtual ReturnValue_t handleRequest() = 0;
+	virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
 	/**
 	 * In performService, implementations can handle periodic, non-TC-triggered activities.
 	 * The performService method is always called.

From aaabbe8aef2a759d1928b22c6b3acfca2fd9980d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Apr 2020 13:59:57 +0200
Subject: [PATCH 0155/1774] DHB fix

---
 devicehandlers/DeviceHandlerBase.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 9f23dd7f5..5fb5a9e5f 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1149,9 +1149,6 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if(size == 0) {
-		return NO_COMMAND_DATA;
-	}
 
 	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
 	if (iter == deviceCommandMap.end()) {

From c88c6c2a45482d19f51ec0548ffe50e5b1203a82 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Apr 2020 19:51:45 +0200
Subject: [PATCH 0156/1774] binary semaphore info printout added

---
 osal/FreeRTOS/BinarySemaphore.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 631e4742d..546c5a46d 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -86,6 +86,7 @@ void BinarySemaphore::resetSemaphore() {
 	}
 }
 
+// Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
@@ -95,6 +96,10 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 	if (returncode == pdPASS) {
 		if(*higherPriorityTaskWoken == pdPASS) {
 			// Request context switch
+		    // TODO: I don't know if this will ever happen but if it does,
+		    // I want to to know in case this causes issues. If it doesn't
+		    // we should remove this.
+		    TRACE_INFO("Binary Semaphore: Higher priority task unblocked!");
 			TaskManagement::requestContextSwitch(CallContext::isr);
 		}
 		return HasReturnvaluesIF::RETURN_OK;

From 30ed08005fd07cd894a49dee5123e028d1fbeed6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Apr 2020 22:16:43 +0200
Subject: [PATCH 0157/1774] reverted some naming changes

---
 datapool/DataPool.h               |  3 +-
 serialize/SerialBufferAdapter.cpp | 56 +++++++++++++++----------------
 serialize/SerialBufferAdapter.h   |  6 ++--
 3 files changed, 33 insertions(+), 32 deletions(-)

diff --git a/datapool/DataPool.h b/datapool/DataPool.h
index a9af8af0b..857bc3b2c 100644
--- a/datapool/DataPool.h
+++ b/datapool/DataPool.h
@@ -42,7 +42,8 @@ private:
 	/**
 	 * \brief	This is the actual data pool itself.
 	 * \details	It is represented by a map
-	 * 			with the data pool id as index and a pointer to a single PoolEntry as value.
+	 * 			with the data pool id as index and a pointer to a single
+	 * 			PoolEntry as value.
 	 */
 	std::map<uint32_t, PoolEntryIF*> data_pool;
 public:
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 618e8a152..f97d0d588 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -5,19 +5,19 @@
 template<typename count_t>
 SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer,
 		count_t bufferLength, bool serializeLength) :
-		m_serialize_length(serializeLength),
-		m_const_buffer(static_cast<const uint8_t *>(buffer)), m_buffer(nullptr),
-		m_buffer_length(bufferLength) {
+		serializeLength(serializeLength),
+		constBuffer(static_cast<const uint8_t *>(buffer)), m_buffer(nullptr),
+		bufferLength(bufferLength) {
 
 }
 
 template<typename count_t>
 SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer, count_t bufferLength,
 		bool serializeLength) :
-		m_serialize_length(serializeLength), m_buffer_length(bufferLength) {
+		serializeLength(serializeLength), bufferLength(bufferLength) {
 	uint8_t * member_buffer = static_cast<uint8_t *>(buffer);
 	m_buffer = member_buffer;
-	m_const_buffer = member_buffer;
+	constBuffer = member_buffer;
 }
 
 
@@ -28,37 +28,37 @@ SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 template<typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, bool bigEndian) const {
-	uint32_t serializedLength = m_buffer_length;
-	if (m_serialize_length) {
+	uint32_t serializedLength = bufferLength;
+	if (serializeLength) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
-				&m_buffer_length);
+				&bufferLength);
 	}
 	if (*size + serializedLength > max_size) {
 		return BUFFER_TOO_SHORT;
 	} else {
-		if (m_serialize_length) {
-			AutoSerializeAdapter::serialize(&m_buffer_length, buffer, size,
+		if (serializeLength) {
+			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
 					max_size, bigEndian);
 		}
-		if (m_const_buffer != nullptr) {
-			memcpy(*buffer, m_const_buffer, m_buffer_length);
+		if (constBuffer != nullptr) {
+			memcpy(*buffer, constBuffer, bufferLength);
 		} else if (m_buffer != nullptr) {
-			memcpy(*buffer, m_buffer, m_buffer_length);
+			memcpy(*buffer, m_buffer, bufferLength);
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
-		*size += m_buffer_length;
-		(*buffer) += m_buffer_length;
+		*size += bufferLength;
+		(*buffer) += bufferLength;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 }
 
 template<typename count_t>
 size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
-	if (m_serialize_length) {
-		return m_buffer_length + AutoSerializeAdapter::getSerializedSize(&m_buffer_length);
+	if (serializeLength) {
+		return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
-		return m_buffer_length;
+		return bufferLength;
 	}
 }
 template<typename count_t>
@@ -66,15 +66,15 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		ssize_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
-		if(m_serialize_length){
+		if(serializeLength){
 			// Suggestion (would require removing rest of the block inside this if clause !):
 			//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
 			//if (result != HasReturnvaluesIF::RETURN_OK) {
 			//	return result;
 			//}
 			count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
-					&m_buffer_length);
-			if((*size - m_buffer_length - serializedSize) >= 0){
+					&bufferLength);
+			if((*size - bufferLength - serializedSize) >= 0){
 				*buffer +=  serializedSize;
 				*size -= serializedSize;
 			}else{
@@ -82,10 +82,10 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 			}
 		}
 		//No Else If, go on with buffer
-		if (*size - m_buffer_length >= 0) {
-			*size -= m_buffer_length;
-			memcpy(m_buffer, *buffer, m_buffer_length);
-			(*buffer) += m_buffer_length;
+		if (*size - bufferLength >= 0) {
+			*size -= bufferLength;
+			memcpy(m_buffer, *buffer, bufferLength);
+			(*buffer) += bufferLength;
 			return HasReturnvaluesIF::RETURN_OK;
 		} else {
 			return STREAM_TOO_SHORT;
@@ -106,17 +106,17 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
-	if(m_const_buffer == nullptr) {
+	if(constBuffer == nullptr) {
 		error << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
 		return nullptr;
 	}
-	return m_const_buffer;
+	return constBuffer;
 }
 
 template<typename count_t>
 void SerialBufferAdapter<count_t>::setBuffer(void * buffer, count_t buffer_length) {
 	m_buffer = static_cast<uint8_t *>(buffer);
-	m_buffer_length = buffer_length;
+	bufferLength = buffer_length;
 }
 
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index ff2083de1..cf3ae07ed 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -52,10 +52,10 @@ public:
 	const uint8_t * getConstBuffer();
 	void setBuffer(void* buffer_, count_t bufferLength_);
 private:
-	bool m_serialize_length = false;
-	const uint8_t *m_const_buffer = nullptr;
+	bool serializeLength = false;
+	const uint8_t *constBuffer = nullptr;
 	uint8_t *m_buffer = nullptr;
-	count_t m_buffer_length = 0;
+	count_t bufferLength = 0;
 };
 
 

From e0e1e64a092b9a06570149c2c694102230af182c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Apr 2020 18:08:14 +0200
Subject: [PATCH 0158/1774] various changes, stopwatch

Semaphore: Some bugfixes, some constructors added
Stopwatch: First implementation, can measure in ms(double) and
ms(normal)
---
 datalinklayer/Clcw.cpp                    |  3 +-
 datapool/PoolEntry.cpp                    |  3 +-
 health/HealthHelper.cpp                   |  5 +-
 osal/FreeRTOS/BinarySemaphore.cpp         | 68 ++++++++++++++++++-----
 osal/FreeRTOS/BinarySemaphore.h           | 51 +++++++++++++----
 osal/FreeRTOS/Clock.cpp                   |  4 +-
 osal/FreeRTOS/Timekeeper.cpp              | 26 +++++----
 osal/FreeRTOS/Timekeeper.h                |  9 ++-
 serviceinterface/ServiceInterfaceStream.h |  3 +-
 timemanager/CCSDSTime.cpp                 |  3 +-
 timemanager/Clock.h                       |  3 +-
 timemanager/Stopwatch.cpp                 | 62 +++++++++++++++++++++
 timemanager/Stopwatch.h                   | 52 +++++++++++++++++
 13 files changed, 247 insertions(+), 45 deletions(-)
 create mode 100644 timemanager/Stopwatch.cpp
 create mode 100644 timemanager/Stopwatch.h

diff --git a/datalinklayer/Clcw.cpp b/datalinklayer/Clcw.cpp
index 448d4d7bc..0ffa7abf6 100644
--- a/datalinklayer/Clcw.cpp
+++ b/datalinklayer/Clcw.cpp
@@ -55,7 +55,8 @@ void Clcw::setBitLock(bool bitLock) {
 }
 
 void Clcw::print() {
-	debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
+	debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole()
+	        << std::dec << std::endl;
 }
 
 void Clcw::setWhole(uint32_t rawClcw) {
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index e5d4ffdef..655b467a0 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -60,7 +60,8 @@ uint8_t PoolEntry<T>::getValid() {
 template <typename T>
 void PoolEntry<T>::print() {
 	for (uint8_t size = 0; size < this->length; size++ ) {
-		debug << "| " << std::hex << (double)this->address[size] << (this->valid? " (valid) " : " (invalid) ");
+		debug << "| " << std::hex << (double)this->address[size]
+		      << (this->valid? " (valid) " : " (invalid) ");
 	}
 	debug << std::dec << std::endl;
 }
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index 8fc413edd..931645d1a 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -89,8 +89,7 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* message) {
 	}
 	if (MessageQueueSenderIF::sendMessage(message->getSender(), &reply,
 			owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-		debug
-				<< "HealthHelper::handleHealthCommand: sending health reply failed."
-				<< std::endl;
+		debug << "HealthHelper::handleHealthCommand: sending health "
+		        "reply failed." << std::endl;
 	}
 }
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 546c5a46d..05c97ae2e 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -21,26 +21,68 @@ BinarySemaphore::~BinarySemaphore() {
 	vSemaphoreDelete(handle);
 }
 
+// This copy ctor is important as it prevents the assignment to a ressource
+// (other.handle) variable which is later deleted!
+BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
+    xSemaphoreCreateBinary(handle);
+    if(handle == nullptr) {
+        error << "Binary semaphore creation failure" << std::endl;
+    }
+}
+
+BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
+    if(this != &s) {
+        xSemaphoreCreateBinary(handle);
+        if(handle == nullptr) {
+            error << "Binary semaphore creation failure" << std::endl;
+        }
+    }
+    return *this;
+}
+
+BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
+    xSemaphoreCreateBinary(handle);
+    if(handle == nullptr) {
+        error << "Binary semaphore creation failure" << std::endl;
+    }
+}
+
+BinarySemaphore& BinarySemaphore::operator =(
+        BinarySemaphore&& s) {
+    if(&s != this) {
+        xSemaphoreCreateBinary(handle);
+        if(handle == nullptr) {
+            error << "Binary semaphore creation failure" << std::endl;
+        }
+    }
+    return *this;
+}
+
 ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	if(handle == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return SEMAPHORE_NULLPOINTER;
 	}
-	TickType_t timeout = portMAX_DELAY;
-	if(timeoutMs != 0) {
-		timeout = pdMS_TO_TICKS(timeoutMs);
+	TickType_t timeout = BinarySemaphore::NO_BLOCK_TICKS;
+	if(timeoutMs == BinarySemaphore::BLOCK_TIMEOUT) {
+	    timeout = BinarySemaphore::BLOCK_TIMEOUT_TICKS;
+	}
+	else if(timeoutMs > BinarySemaphore::NO_BLOCK_TIMEOUT){
+	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
 	BaseType_t returncode = xSemaphoreTake(handle, timeout);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_NOT_FOUND;
+	}
+	else {
+	    return SEMAPHORE_TIMEOUT;
 	}
 }
 
-ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks) {
+ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
+        TickType_t timeoutTicks) {
 	if(handle == nullptr) {
-		return SEMAPHORE_NOT_FOUND;
+		return SEMAPHORE_NULLPOINTER;
 	}
 
 	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
@@ -53,7 +95,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(TickType_t timeout
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
 	if (handle == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return SEMAPHORE_NULLPOINTER;
 	}
 	BaseType_t returncode = xSemaphoreGive(handle);
 	if (returncode == pdPASS) {
@@ -69,7 +111,7 @@ SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	if (semaphore == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return SEMAPHORE_NULLPOINTER;
 	}
 	BaseType_t returncode = xSemaphoreGive(semaphore);
 	if (returncode == pdPASS) {
@@ -86,11 +128,12 @@ void BinarySemaphore::resetSemaphore() {
 	}
 }
 
+
 // Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return SEMAPHORE_NULLPOINTER;
 	}
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);
 	if (returncode == pdPASS) {
@@ -99,11 +142,10 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 		    // TODO: I don't know if this will ever happen but if it does,
 		    // I want to to know in case this causes issues. If it doesn't
 		    // we should remove this.
-		    TRACE_INFO("Binary Semaphore: Higher priority task unblocked!");
 			TaskManagement::requestContextSwitch(CallContext::isr);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return SEMAPHORE_NOT_OWNED;
 	}
 }
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index a809f0bb1..541266929 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -20,22 +20,51 @@ class BinarySemaphore: public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 
-	/** Semaphore object not found */
-	static const ReturnValue_t SEMAPHORE_NOT_FOUND = MAKE_RETURN_CODE(1);
-	/** Semaphore timeout */
-	static const ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(2);
+	//! No block time, poll the semaphore. Can also be used as tick type.
+	//! Can be passed as tick type and ms value.
+	static constexpr uint32_t NO_BLOCK_TIMEOUT = 0;
+	static constexpr TickType_t NO_BLOCK_TICKS = 0;
+	//! No block time, poll the semaphore.
+	//! Can be passed as tick type and ms value.
+	static constexpr TickType_t BLOCK_TIMEOUT_TICKS = portMAX_DELAY;
+	static constexpr uint32_t BLOCK_TIMEOUT = portMAX_DELAY;
+
+	//! Semaphore timeout
+	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
 	/** The current semaphore can not be given, because it is not owned */
-	static const ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(3);
+	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
 
 	/**
 	 * Create a binary semaphore
 	 */
 	BinarySemaphore();
 
+	/**
+	 * Copy ctor
+	 * @param
+	 */
+	BinarySemaphore(const BinarySemaphore&);
+
+	/**
+	 * Copy assignment
+	 */
+	BinarySemaphore& operator=(const BinarySemaphore&);
+
+	/**
+	 * Move constructor
+	 */
+	BinarySemaphore (BinarySemaphore &&);
+
+	/**
+	 * Move assignment
+	 */
+	BinarySemaphore & operator=(BinarySemaphore &&);
+
 	/**
 	 * Delete the binary semaphore to prevent a memory leak
 	 */
-	~BinarySemaphore();
+	virtual ~BinarySemaphore();
 
 	/**
 	 * Take the binary semaphore.
@@ -46,7 +75,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c RETURN_FAILED on failure
 	 */
-	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs);
+	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
+	        BinarySemaphore::NO_BLOCK_TIMEOUT);
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -54,7 +84,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c RETURN_FAILED on failure
 	 */
-	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks);
+	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
+	        BinarySemaphore::NO_BLOCK_TICKS);
 
 	/**
 	 * Give back the binary semaphore
@@ -96,8 +127,4 @@ private:
 	SemaphoreHandle_t handle;
 };
 
-
-
-
-
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index cffc2125e..5e597f258 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -3,8 +3,11 @@
 #include <stdlib.h>
 #include "Timekeeper.h"
 
+extern "C" {
 #include <FreeRTOS.h>
 #include <task.h>
+}
+
 
 //TODO sanitize input?
 //TODO much of this code can be reused for tick-only systems
@@ -56,7 +59,6 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
 
 timeval Clock::getUptime() {
 	TickType_t ticksSinceStart = xTaskGetTickCount();
-
 	return Timekeeper::ticksToTimeval(ticksSinceStart);
 }
 
diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index 81f7f9979..949e1df3c 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -1,20 +1,24 @@
-#include "Timekeeper.h"
-#include <FreeRTOSConfig.h>
+/**
+ * @file Timekeeper.cpp
+ * @date
+ */
 
-Timekeeper::Timekeeper() :
-		offset( { 0, 0 }) {
-	// TODO Auto-generated constructor stub
+#include <framework/osal/FreeRTOS/Timekeeper.h>
 
+extern "C" {
+#include <task.h>
 }
 
-Timekeeper * Timekeeper::myinstance = NULL;
+Timekeeper * Timekeeper::myinstance = nullptr;
+
+Timekeeper::Timekeeper() : offset( { 0, 0 }) {}
 
 const timeval& Timekeeper::getOffset() const {
 	return offset;
 }
 
 Timekeeper* Timekeeper::instance() {
-	if (myinstance == NULL) {
+	if (myinstance == nullptr) {
 		myinstance = new Timekeeper();
 	}
 	return myinstance;
@@ -24,9 +28,7 @@ void Timekeeper::setOffset(const timeval& offset) {
 	this->offset = offset;
 }
 
-Timekeeper::~Timekeeper() {
-	// TODO Auto-generated destructor stub
-}
+Timekeeper::~Timekeeper() {}
 
 timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
 	timeval uptime;
@@ -40,3 +42,7 @@ timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
 
 	return uptime;
 }
+
+TickType_t Timekeeper::getTicks() {
+    return xTaskGetTickCount();
+}
diff --git a/osal/FreeRTOS/Timekeeper.h b/osal/FreeRTOS/Timekeeper.h
index 2ba3e4a9b..05f0f7011 100644
--- a/osal/FreeRTOS/Timekeeper.h
+++ b/osal/FreeRTOS/Timekeeper.h
@@ -2,8 +2,10 @@
 #define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
 
 #include <framework/timemanager/Clock.h>
-
+extern "C" {
 #include <FreeRTOS.h>
+}
+
 
 /**
  * A Class to basically store the time difference between uptime and UTC
@@ -25,6 +27,11 @@ public:
 	virtual ~Timekeeper();
 
 	static timeval ticksToTimeval(TickType_t ticks);
+    /**
+     * Get elapsed time in system ticks.
+     * @return
+     */
+    static TickType_t getTicks();
 
 	const timeval& getOffset() const;
 	void setOffset(const timeval& offset);
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 32bc263ee..44cf1168f 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -7,7 +7,8 @@
 #include <sstream>
 #include <cstdio>
 
-//Unfortunately, there must be a forward declaration of log_fe (MUST be defined in main), to let the system know where to write to.
+//Unfortunately, there must be a forward declaration of log_fe
+// (MUST be defined in main), to let the system know where to write to.
 extern std::ostream debug;
 extern std::ostream info;
 extern std::ostream warning;
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 29aafb68d..47cab911d 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -196,7 +196,8 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		to->usecond = (second - floor(second)) * 1000000;
 		return RETURN_OK;
 	}
-// Warning: Compiler/Linker fails ambiguously if library does not implement C99 I/O
+// Warning: Compiler/Linker fails ambiguously if library does not implement
+// C99 I/O
 #else
 	uint16_t year;
 	uint8_t month;
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index af6572472..afa9963c5 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -7,7 +7,8 @@
 #include <framework/ipc/MutexFactory.h>
 #include <framework/globalfunctions/timevalOperations.h>
 
-
+typedef uint32_t ms_normal_t;
+typedef double ms_double_t;
 
 class Clock {
 public:
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
new file mode 100644
index 000000000..37133def3
--- /dev/null
+++ b/timemanager/Stopwatch.cpp
@@ -0,0 +1,62 @@
+/**
+ * @file Stopwatch.cpp
+ *
+ * @date 08.04.2020
+ */
+
+#include <framework/timemanager/Stopwatch.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+Stopwatch::Stopwatch(bool displayOnDestruction, DisplayMode displayMode):
+        displayOnDestruction(displayOnDestruction) {
+    Clock::getUptime(&startTime);
+    stopwatchState = StopwatchState::STARTED;
+}
+
+void Stopwatch::start() {
+    startTime = Clock::getUptime();
+}
+
+ms_normal_t Stopwatch::stop() {
+    elapsedTime = Clock::getUptime() - startTime;
+    int32_t elapsedTimeMs = elapsedTime.tv_sec * 1000 +
+            elapsedTime.tv_usec/1000;
+    if(elapsedTimeMs < 0) {
+        error << "Stopwatch: Measured time negative!";
+        return INVALID_TIME;
+    }
+    else {
+        return static_cast<ms_normal_t>(elapsedTimeMs);
+    }
+}
+
+ms_double_t Stopwatch::stopPrecise() {
+    elapsedTime = Clock::getUptime() - startTime;
+    return timevalOperations::toDouble(elapsedTime) * 1000.0;
+}
+
+
+void Stopwatch::display() {
+    if(displayMode == DisplayMode::MS_FLOAT) {
+        info << "Stopwatch: Operation took " <<
+                elapsedTimeMs << " milliseconds" << std::endl;
+    }
+    else {
+        timeval elapsedTime = stopTime - startTime;
+        info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
+                elapsedTime.tv_usec * 1000 << " milliseconds";
+    }
+}
+
+
+Stopwatch::~Stopwatch() {
+    if(displayOnDestruction) {
+        stopInternal();
+        display();
+    }
+}
+
+void Stopwatch::stopInternal() {
+    elapsedTime = Clock::getUptime() - startTime;
+    elapsedTimeMs = timevalOperations::toDouble(elapsedTime) * 1000.0;
+}
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
new file mode 100644
index 000000000..6f58553f1
--- /dev/null
+++ b/timemanager/Stopwatch.h
@@ -0,0 +1,52 @@
+/**
+ * @file Stopwatch.h
+ *
+ * @date 08.04.2020
+ */
+
+#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#include <framework/timemanager/Clock.h>
+
+class Stopwatch {
+    enum class DisplayMode {
+        MS_FLOAT,
+        MS
+    };
+
+    Stopwatch(bool displayOnDestruction = true, DisplayMode displayMode =
+            DisplayMode::MS_FLOAT);
+    virtual~ Stopwatch();
+
+    void start();
+
+    ms_normal_t stop();
+    ms_double_t stopPrecise();
+
+    void display();
+private:
+    static const ms_normal_t INVALID_TIME = 0xFFFFFFFF;
+
+    timeval startTime {0, 0};
+    timeval stopTime {0, 0};
+    timeval elapsedTime {0, 0};
+    double elapsedTimeMs = 0;
+    //ms_normal_t elapsedTimeMs {0};
+
+    bool displayOnDestruction = true;
+
+    enum class StopwatchState {
+        IDLE,
+        STARTED,
+    };
+
+    StopwatchState stopwatchState = StopwatchState::IDLE;
+    DisplayMode displayMode = DisplayMode::MS_FLOAT;
+
+    void stopInternal();
+};
+
+
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ */

From 3af241b9c48f1c0f5685435f198d27e4333caa99 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Apr 2020 18:27:18 +0200
Subject: [PATCH 0159/1774] stopwatch more lightweight now

---
 timemanager/Stopwatch.cpp | 25 ++++++++-----------------
 timemanager/Stopwatch.h   | 27 +++++++++++++--------------
 2 files changed, 21 insertions(+), 31 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 37133def3..fde77540b 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -10,7 +10,6 @@
 Stopwatch::Stopwatch(bool displayOnDestruction, DisplayMode displayMode):
         displayOnDestruction(displayOnDestruction) {
     Clock::getUptime(&startTime);
-    stopwatchState = StopwatchState::STARTED;
 }
 
 void Stopwatch::start() {
@@ -18,31 +17,22 @@ void Stopwatch::start() {
 }
 
 ms_normal_t Stopwatch::stop() {
-    elapsedTime = Clock::getUptime() - startTime;
-    int32_t elapsedTimeMs = elapsedTime.tv_sec * 1000 +
-            elapsedTime.tv_usec/1000;
-    if(elapsedTimeMs < 0) {
-        error << "Stopwatch: Measured time negative!";
-        return INVALID_TIME;
-    }
-    else {
-        return static_cast<ms_normal_t>(elapsedTimeMs);
-    }
+    stopInternal();
+    return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
 }
 
 ms_double_t Stopwatch::stopPrecise() {
-    elapsedTime = Clock::getUptime() - startTime;
-    return timevalOperations::toDouble(elapsedTime) * 1000.0;
+    stopInternal();
+    return elapsedTimeMsDouble;
 }
 
 
 void Stopwatch::display() {
-    if(displayMode == DisplayMode::MS_FLOAT) {
+    if(displayMode == DisplayMode::MS_DOUBLE) {
         info << "Stopwatch: Operation took " <<
-                elapsedTimeMs << " milliseconds" << std::endl;
+                elapsedTimeMsDouble << " milliseconds" << std::endl;
     }
     else {
-        timeval elapsedTime = stopTime - startTime;
         info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
                 elapsedTime.tv_usec * 1000 << " milliseconds";
     }
@@ -56,7 +46,8 @@ Stopwatch::~Stopwatch() {
     }
 }
 
+
 void Stopwatch::stopInternal() {
     elapsedTime = Clock::getUptime() - startTime;
-    elapsedTimeMs = timevalOperations::toDouble(elapsedTime) * 1000.0;
+    elapsedTimeMsDouble = timevalOperations::toDouble(elapsedTime) * 1000.0;
 }
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 6f58553f1..7760fda9c 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -8,14 +8,23 @@
 #define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
 #include <framework/timemanager/Clock.h>
 
+/**
+ * @brief Simple Stopwatch implementation to measure elapsed time
+ * @details
+ * This class can be used to measure elapsed times. It also displays elapsed
+ * times automatically on destruction if not explicitely deactivated in the
+ * constructor. The default time format is the elapsed time in miliseconds
+ * as a float.
+ * This class caches the value
+ */
 class Stopwatch {
     enum class DisplayMode {
-        MS_FLOAT,
+        MS_DOUBLE,
         MS
     };
 
     Stopwatch(bool displayOnDestruction = true, DisplayMode displayMode =
-            DisplayMode::MS_FLOAT);
+            DisplayMode::MS_DOUBLE);
     virtual~ Stopwatch();
 
     void start();
@@ -25,23 +34,13 @@ class Stopwatch {
 
     void display();
 private:
-    static const ms_normal_t INVALID_TIME = 0xFFFFFFFF;
 
     timeval startTime {0, 0};
-    timeval stopTime {0, 0};
     timeval elapsedTime {0, 0};
-    double elapsedTimeMs = 0;
-    //ms_normal_t elapsedTimeMs {0};
+    double elapsedTimeMsDouble = 0;
 
     bool displayOnDestruction = true;
-
-    enum class StopwatchState {
-        IDLE,
-        STARTED,
-    };
-
-    StopwatchState stopwatchState = StopwatchState::IDLE;
-    DisplayMode displayMode = DisplayMode::MS_FLOAT;
+    DisplayMode displayMode = DisplayMode::MS_DOUBLE;
 
     void stopInternal();
 };

From 3dbf35338561897c356a1f949ed2a74ec7e9f311 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Apr 2020 18:33:38 +0200
Subject: [PATCH 0160/1774] some more refactoring for stopwatch

---
 timemanager/Stopwatch.cpp | 13 +++++++++++--
 timemanager/Stopwatch.h   | 35 +++++++++++++++++++++++++++--------
 2 files changed, 38 insertions(+), 10 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index fde77540b..7b08c120d 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -7,8 +7,10 @@
 #include <framework/timemanager/Stopwatch.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-Stopwatch::Stopwatch(bool displayOnDestruction, DisplayMode displayMode):
+Stopwatch::Stopwatch(bool displayOnDestruction,
+        StopwatchDisplayMode displayMode):
         displayOnDestruction(displayOnDestruction) {
+    // Measures start time on initialization.
     Clock::getUptime(&startTime);
 }
 
@@ -28,7 +30,7 @@ ms_double_t Stopwatch::stopPrecise() {
 
 
 void Stopwatch::display() {
-    if(displayMode == DisplayMode::MS_DOUBLE) {
+    if(displayMode == StopwatchDisplayMode::MS_DOUBLE) {
         info << "Stopwatch: Operation took " <<
                 elapsedTimeMsDouble << " milliseconds" << std::endl;
     }
@@ -46,6 +48,13 @@ Stopwatch::~Stopwatch() {
     }
 }
 
+void Stopwatch::setDisplayMode(StopwatchDisplayMode displayMode) {
+    this->displayMode = displayMode;
+}
+
+StopwatchDisplayMode Stopwatch::getDisplayMode() const {
+    return displayMode;
+}
 
 void Stopwatch::stopInternal() {
     elapsedTime = Clock::getUptime() - startTime;
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 7760fda9c..b136019fd 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -8,6 +8,11 @@
 #define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
 #include <framework/timemanager/Clock.h>
 
+enum class StopwatchDisplayMode {
+    MS_DOUBLE,
+    MS
+};
+
 /**
  * @brief Simple Stopwatch implementation to measure elapsed time
  * @details
@@ -15,24 +20,38 @@
  * times automatically on destruction if not explicitely deactivated in the
  * constructor. The default time format is the elapsed time in miliseconds
  * as a float.
- * This class caches the value
  */
 class Stopwatch {
-    enum class DisplayMode {
-        MS_DOUBLE,
-        MS
-    };
 
-    Stopwatch(bool displayOnDestruction = true, DisplayMode displayMode =
-            DisplayMode::MS_DOUBLE);
+    Stopwatch(bool displayOnDestruction = true,
+            StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE);
     virtual~ Stopwatch();
 
+    /**
+     * Caches the start time
+     */
     void start();
 
+    /**
+     * Calculates the elapsed time since start and returns it
+     * @return elapsed time in milliseconds (rounded)
+     */
     ms_normal_t stop();
+
+    /**
+     * Calculates the elapsed time since start and returns it
+     * @return elapsed time in milliseconds (doulbe precision)
+     */
     ms_double_t stopPrecise();
 
+    /**
+     * Displays the elapsed times on the osstream, depending on internal display
+     * mode.
+     */
     void display();
+
+    StopwatchDisplayMode getDisplayMode() const;
+    void setDisplayMode(StopwatchDisplayMode displayMode);
 private:
 
     timeval startTime {0, 0};
@@ -40,7 +59,7 @@ private:
     double elapsedTimeMsDouble = 0;
 
     bool displayOnDestruction = true;
-    DisplayMode displayMode = DisplayMode::MS_DOUBLE;
+    StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE;
 
     void stopInternal();
 };

From da9bb97b23f2519137674a8b352e7b93592f4ef4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Apr 2020 19:05:21 +0200
Subject: [PATCH 0161/1774] added precision for double output

---
 timemanager/Stopwatch.cpp | 12 ++++++++----
 timemanager/Stopwatch.h   | 18 ++++++++++++++----
 2 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 7b08c120d..1ccebc577 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -6,10 +6,11 @@
 
 #include <framework/timemanager/Stopwatch.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <iomanip>
 
 Stopwatch::Stopwatch(bool displayOnDestruction,
-        StopwatchDisplayMode displayMode):
-        displayOnDestruction(displayOnDestruction) {
+        StopwatchDisplayMode displayMode, uint8_t precision):
+        displayOnDestruction(displayOnDestruction), outputPrecision(precision) {
     // Measures start time on initialization.
     Clock::getUptime(&startTime);
 }
@@ -31,8 +32,9 @@ ms_double_t Stopwatch::stopPrecise() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MS_DOUBLE) {
-        info << "Stopwatch: Operation took " <<
-                elapsedTimeMsDouble << " milliseconds" << std::endl;
+        info << "Stopwatch: Operation took "
+             << std::setprecision(outputPrecision) << elapsedTimeMsDouble
+             << " milliseconds" << std::endl;
     }
     else {
         info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
@@ -56,6 +58,8 @@ StopwatchDisplayMode Stopwatch::getDisplayMode() const {
     return displayMode;
 }
 
+
+
 void Stopwatch::stopInternal() {
     elapsedTime = Clock::getUptime() - startTime;
     elapsedTimeMsDouble = timevalOperations::toDouble(elapsedTime) * 1000.0;
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index b136019fd..1e4382724 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -22,9 +22,19 @@ enum class StopwatchDisplayMode {
  * as a float.
  */
 class Stopwatch {
-
+public:
+    /**
+     * Default constructor. Call "Stopwatch stopwatch" without brackets if
+     * no parameters are required!
+     * @param displayOnDestruction If set to true, displays measured time on
+     *        object destruction
+     * @param displayMode Display format is either MS rounded or MS as double
+     *        format
+     * @param outputPrecision If using double format, specify precision here.
+     */
     Stopwatch(bool displayOnDestruction = true,
-            StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE);
+            StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE,
+            uint8_t outputPrecision = 4);
     virtual~ Stopwatch();
 
     /**
@@ -53,12 +63,12 @@ class Stopwatch {
     StopwatchDisplayMode getDisplayMode() const;
     void setDisplayMode(StopwatchDisplayMode displayMode);
 private:
-
     timeval startTime {0, 0};
     timeval elapsedTime {0, 0};
-    double elapsedTimeMsDouble = 0;
+    double elapsedTimeMsDouble {0.0};
 
     bool displayOnDestruction = true;
+    uint8_t outputPrecision = 4;
     StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE;
 
     void stopInternal();

From 5b0f80509f7f8dec258d333c26766dfdf8336ccc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Apr 2020 19:24:24 +0200
Subject: [PATCH 0162/1774] usec replaced by seconds

---
 timemanager/Clock.h       |  4 ++--
 timemanager/Stopwatch.cpp | 27 +++++++++++----------------
 timemanager/Stopwatch.h   | 22 +++++++---------------
 3 files changed, 20 insertions(+), 33 deletions(-)

diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index afa9963c5..5f18de3ee 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -7,8 +7,8 @@
 #include <framework/ipc/MutexFactory.h>
 #include <framework/globalfunctions/timevalOperations.h>
 
-typedef uint32_t ms_normal_t;
-typedef double ms_double_t;
+typedef uint32_t millis_t;
+typedef float seconds_t;
 
 class Clock {
 public:
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 1ccebc577..40b711d9e 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -9,8 +9,8 @@
 #include <iomanip>
 
 Stopwatch::Stopwatch(bool displayOnDestruction,
-        StopwatchDisplayMode displayMode, uint8_t precision):
-        displayOnDestruction(displayOnDestruction), outputPrecision(precision) {
+        StopwatchDisplayMode displayMode):
+        displayOnDestruction(displayOnDestruction) {
     // Measures start time on initialization.
     Clock::getUptime(&startTime);
 }
@@ -19,30 +19,28 @@ void Stopwatch::start() {
     startTime = Clock::getUptime();
 }
 
-ms_normal_t Stopwatch::stop() {
+millis_t Stopwatch::stop() {
     stopInternal();
     return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
 }
 
-ms_double_t Stopwatch::stopPrecise() {
+seconds_t Stopwatch::stopSeconds() {
     stopInternal();
-    return elapsedTimeMsDouble;
+    return timevalOperations::toDouble(elapsedTime);
 }
 
-
 void Stopwatch::display() {
-    if(displayMode == StopwatchDisplayMode::MS_DOUBLE) {
-        info << "Stopwatch: Operation took "
-             << std::setprecision(outputPrecision) << elapsedTimeMsDouble
-             << " milliseconds" << std::endl;
-    }
-    else {
+    if(displayMode == StopwatchDisplayMode::MILLIS) {
         info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
                 elapsedTime.tv_usec * 1000 << " milliseconds";
     }
+    else if(displayMode == StopwatchDisplayMode::SECONDS) {
+        info <<"Stopwatch: Operation took "  << std::setprecision(4)
+             << std::fixed << timevalOperations::toDouble(elapsedTime)
+             << " seconds";
+    }
 }
 
-
 Stopwatch::~Stopwatch() {
     if(displayOnDestruction) {
         stopInternal();
@@ -58,9 +56,6 @@ StopwatchDisplayMode Stopwatch::getDisplayMode() const {
     return displayMode;
 }
 
-
-
 void Stopwatch::stopInternal() {
     elapsedTime = Clock::getUptime() - startTime;
-    elapsedTimeMsDouble = timevalOperations::toDouble(elapsedTime) * 1000.0;
 }
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 1e4382724..aeb612650 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -9,8 +9,8 @@
 #include <framework/timemanager/Clock.h>
 
 enum class StopwatchDisplayMode {
-    MS_DOUBLE,
-    MS
+    MILLIS,
+    SECONDS
 };
 
 /**
@@ -32,9 +32,8 @@ public:
      *        format
      * @param outputPrecision If using double format, specify precision here.
      */
-    Stopwatch(bool displayOnDestruction = true,
-            StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE,
-            uint8_t outputPrecision = 4);
+    Stopwatch(bool displayOnDestruction = true, StopwatchDisplayMode displayMode
+              = StopwatchDisplayMode::MILLIS);
     virtual~ Stopwatch();
 
     /**
@@ -46,13 +45,8 @@ public:
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in milliseconds (rounded)
      */
-    ms_normal_t stop();
-
-    /**
-     * Calculates the elapsed time since start and returns it
-     * @return elapsed time in milliseconds (doulbe precision)
-     */
-    ms_double_t stopPrecise();
+    millis_t stop();
+    seconds_t stopSeconds();
 
     /**
      * Displays the elapsed times on the osstream, depending on internal display
@@ -65,11 +59,9 @@ public:
 private:
     timeval startTime {0, 0};
     timeval elapsedTime {0, 0};
-    double elapsedTimeMsDouble {0.0};
 
     bool displayOnDestruction = true;
-    uint8_t outputPrecision = 4;
-    StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE;
+    StopwatchDisplayMode displayMode = StopwatchDisplayMode::MILLIS;
 
     void stopInternal();
 };

From 640cc1ddec6fa6e53c8dca212b06b61604e5a6da Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Apr 2020 19:30:39 +0200
Subject: [PATCH 0163/1774] some more bugfixes

---
 timemanager/Stopwatch.cpp | 8 ++++----
 timemanager/Stopwatch.h   | 3 +--
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 40b711d9e..6c50f0de9 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -9,7 +9,7 @@
 #include <iomanip>
 
 Stopwatch::Stopwatch(bool displayOnDestruction,
-        StopwatchDisplayMode displayMode):
+        StopwatchDisplayMode displayMode): displayMode(displayMode),
         displayOnDestruction(displayOnDestruction) {
     // Measures start time on initialization.
     Clock::getUptime(&startTime);
@@ -32,12 +32,12 @@ seconds_t Stopwatch::stopSeconds() {
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
         info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
-                elapsedTime.tv_usec * 1000 << " milliseconds";
+                elapsedTime.tv_usec * 1000 << " milliseconds" << std::endl;
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {
-        info <<"Stopwatch: Operation took "  << std::setprecision(4)
+        info <<"Stopwatch: Operation took "  << std::setprecision(3)
              << std::fixed << timevalOperations::toDouble(elapsedTime)
-             << " seconds";
+             << " seconds" << std::endl;
     }
 }
 
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index aeb612650..786a9d571 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -60,9 +60,8 @@ private:
     timeval startTime {0, 0};
     timeval elapsedTime {0, 0};
 
-    bool displayOnDestruction = true;
     StopwatchDisplayMode displayMode = StopwatchDisplayMode::MILLIS;
-
+    bool displayOnDestruction = true;
     void stopInternal();
 };
 

From 8a8761ea88e361ff610dd18ba22e59f3f5a9140b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Apr 2020 17:56:48 +0200
Subject: [PATCH 0164/1774] stopwatch bugfix

---
 devicehandlers/CookieIF.h              |  5 +++--
 devicehandlers/DeviceCommunicationIF.h | 24 ++++++++++++------------
 osal/FreeRTOS/BinarySemaphore.h        | 26 +++++++++++---------------
 serialize/SerializeDoc.h               | 16 ++++++++++++++++
 timemanager/Stopwatch.cpp              |  2 +-
 5 files changed, 43 insertions(+), 30 deletions(-)
 create mode 100644 serialize/SerializeDoc.h

diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index ca171ff40..6b2bb5598 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -13,8 +13,9 @@ typedef uint32_t address_t;
  * 			single interface (like RMAP or I2C)
  * @details
  * To use this class, implement a communication specific child cookie which
- * inherits Cookie. Cookie instances are created in config/ Factory.cpp by calling
- * CookieIF* childCookie = new ChildCookie(...).
+ * inherits Cookie. Cookie instances are created in config/Factory.cpp by
+ * calling @code{.cpp} CookieIF* childCookie = new ChildCookie(...)
+ * @endcode .
  *
  * This cookie is then passed to the child device handlers, which stores the
  * pointer and passes it to the communication interface functions.
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 39cfadd75..bb0951164 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -60,9 +60,9 @@ public:
 	 * this can be performed in this function, which is called on device handler
 	 * initialization.
 	 * @param cookie
-	 * @return -@c RETURN_OK if initialization was successfull
-	 * 		   - Everything else triggers failure event with
-	 * 		   returnvalue as parameter 1
+	 * @return
+	 *  - @c RETURN_OK if initialization was successfull
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
 
@@ -73,9 +73,9 @@ public:
 	 * @param cookie
 	 * @param data
 	 * @param len
-	 * @return -@c RETURN_OK for successfull send
-	 *         - Everything else triggers failure event with
-	 *         returnvalue as parameter 1
+	 * @return
+	 *  - @c RETURN_OK for successfull send
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
 			size_t sendLen) = 0;
@@ -84,9 +84,9 @@ public:
 	 * Called by DHB in the GET_WRITE doGetWrite().
 	 * Get send confirmation that the data in sendMessage() was sent successfully.
 	 * @param cookie
-	 * @return -@c RETURN_OK if data was sent successfull
+	 * @return - @c RETURN_OK if data was sent successfull
 	 * 		   - Everything else triggers falure event with
-	 * 		   returnvalue as parameter 1
+	 * 		     returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
 
@@ -99,9 +99,9 @@ public:
 	 *
 	 * @param cookie
 	 * @param requestLen Size of data to read
-	 * @return -@c RETURN_OK to confirm the request for data has been sent.
+	 * @return - @c RETURN_OK to confirm the request for data has been sent.
 	 *         - Everything else triggers failure event with
-	 *         returnvalue as parameter 1
+	 *           returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
 
@@ -113,8 +113,8 @@ public:
 	 * @param buffer [out] Set reply here (by using *buffer = ...)
 	 * @param size [out] size pointer to set (by using *size = ...).
 	 * 	           Set to 0 if no reply was received
-	 * @return -@c RETURN_OK for successfull receive
-	 * 		   -@c NO_REPLY_RECEIVED if not reply was received. Setting size to
+	 * @return - @c RETURN_OK for successfull receive
+	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
 	 * 		   	   0 has the same effect
 	 *         - Everything else triggers failure event with
 	 *           returnvalue as parameter 1
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 541266929..373e26bfc 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -35,24 +35,20 @@ public:
 	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
 	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
 
-	/**
-	 * Create a binary semaphore
-	 */
 	BinarySemaphore();
 
 	/**
-	 * Copy ctor
-	 * @param
+	 * @brief Copy ctor
 	 */
 	BinarySemaphore(const BinarySemaphore&);
 
 	/**
-	 * Copy assignment
+	 * @brief Copy assignment
 	 */
 	BinarySemaphore& operator=(const BinarySemaphore&);
 
 	/**
-	 * Move constructor
+	 * @brief Move constructor
 	 */
 	BinarySemaphore (BinarySemaphore &&);
 
@@ -81,16 +77,16 @@ public:
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
 	 * @param timeoutTicks
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
 	        BinarySemaphore::NO_BLOCK_TICKS);
 
 	/**
 	 * Give back the binary semaphore
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t giveBinarySemaphore();
 
@@ -108,8 +104,8 @@ public:
 	 /**
 	 * Wrapper function to give back semaphore from handle
 	 * @param semaphore
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
 	 */
 	static ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore);
 
@@ -118,8 +114,8 @@ public:
 	 * @param semaphore
 	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
 	 *        was unblocked
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
 	 */
 	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 				BaseType_t * higherPriorityTaskWoken);
diff --git a/serialize/SerializeDoc.h b/serialize/SerializeDoc.h
new file mode 100644
index 000000000..6186b77b7
--- /dev/null
+++ b/serialize/SerializeDoc.h
@@ -0,0 +1,16 @@
+/**
+ * @page    serialPage Serialization Tools
+ * This page refers to the serialization tools included in framework/serialize.
+ * The serialization tools are a useful tool to convert object data into raw
+ * buffers and vice-versa. Here is a rough overview which tool to use for
+ * which purpose.
+ *
+ * @section endSwapper  Endian Swapper
+ * This header file includes tools to do simple serial order swapping
+ *
+ * @section serialiezIF SerializeIF
+ *
+ * @section serElement  SerializeElement
+ *
+ */
+
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 6c50f0de9..a7cbfa7cc 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -31,7 +31,7 @@ seconds_t Stopwatch::stopSeconds() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
-        info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
+        info << "Stopwatch: Operation took " << elapsedTime.tv_sec / 1000 +
                 elapsedTime.tv_usec * 1000 << " milliseconds" << std::endl;
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {

From 841b28b65d3c46a175d283d01e92729495f218d9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Apr 2020 18:02:10 +0200
Subject: [PATCH 0165/1774] stopwatch ms now working

---
 timemanager/Stopwatch.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index a7cbfa7cc..3f0755fd7 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -12,7 +12,7 @@ Stopwatch::Stopwatch(bool displayOnDestruction,
         StopwatchDisplayMode displayMode): displayMode(displayMode),
         displayOnDestruction(displayOnDestruction) {
     // Measures start time on initialization.
-    Clock::getUptime(&startTime);
+    startTime = Clock::getUptime();
 }
 
 void Stopwatch::start() {
@@ -31,8 +31,8 @@ seconds_t Stopwatch::stopSeconds() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
-        info << "Stopwatch: Operation took " << elapsedTime.tv_sec / 1000 +
-                elapsedTime.tv_usec * 1000 << " milliseconds" << std::endl;
+        info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
+                elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {
         info <<"Stopwatch: Operation took "  << std::setprecision(3)

From 69e9710bf17013f974188ee420279107b472e822 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Apr 2020 17:06:06 +0200
Subject: [PATCH 0166/1774] added intial carriage return im preamble

---
 osal/FreeRTOS/BinarySemaphore.cpp           |  6 ++----
 serviceinterface/ServiceInterfaceBuffer.cpp |  9 +++++----
 serviceinterface/ServiceInterfaceBuffer.h   | 10 +++++-----
 serviceinterface/ServiceInterfaceStream.cpp |  4 ++--
 serviceinterface/ServiceInterfaceStream.h   |  4 ++--
 tmtcservices/TmTcBridge.cpp                 |  4 ++--
 6 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 05c97ae2e..e2cddacc0 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -138,10 +138,8 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);
 	if (returncode == pdPASS) {
 		if(*higherPriorityTaskWoken == pdPASS) {
-			// Request context switch
-		    // TODO: I don't know if this will ever happen but if it does,
-		    // I want to to know in case this causes issues. If it doesn't
-		    // we should remove this.
+			// Request context switch because unblocking the semaphore
+		    // caused a high priority task unblock.
 			TaskManagement::requestContextSwitch(CallContext::isr);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 6798b776d..527db07b1 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -27,8 +27,8 @@ int ServiceInterfaceBuffer::sync(void) {
 		Clock::TimeOfDay_t loggerTime;
 		Clock::getDateAndTime(&loggerTime);
 		char preamble[96] = { 0 };
-		sprintf(preamble, "%s: | %" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ".%03" PRIu32 " | ",
-				this->log_message.c_str(),
+		sprintf(preamble, "\r%s: | %" PRIu32 ":%02" PRIu32 ":%02" PRIu32
+		        ".%03" PRIu32 " | ", this->log_message.c_str(),
 				loggerTime.hour,
 				loggerTime.minute,
 				loggerTime.second,
@@ -45,7 +45,8 @@ int ServiceInterfaceBuffer::sync(void) {
 
 #ifndef UT699
 
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+        uint16_t port) {
 	this->log_message = set_message;
 	this->isActive = true;
 	setp( buf, buf + BUF_SIZE );
@@ -59,7 +60,7 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 	}
 	memcpy(array, begin, length);
 
-	for( ; begin != end; begin++){
+	for(; begin != end; begin++){
 		printChar(begin);
 	}
 
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index b42c8a197..b4756d417 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -7,8 +7,8 @@
 #include <cstdio>
 
 #ifndef UT699
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
+class ServiceInterfaceBuffer:
+        public std::basic_streambuf<char,std::char_traits<char>> {
 	friend class ServiceInterfaceStream;
 public:
 	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
@@ -17,11 +17,11 @@ protected:
 	// This is called when buffer becomes full. If
 	// buffer is not used, then this is called every
 	// time when characters are put to stream.
-	virtual int overflow(int c = Traits::eof());
+	int overflow(int c = Traits::eof()) override;
 
 	// This function is called when stream is flushed,
 	// for example when std::endl is put to stream.
-	virtual int sync(void);
+	int sync(void) override;
 
 private:
 	// For additional message information
@@ -30,7 +30,7 @@ private:
 	typedef std::char_traits<char> Traits;
 
 	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 128;
+	static size_t const BUF_SIZE = 150;
 	char buf[BUF_SIZE];
 
 	// In this function, the characters are parsed.
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index c2979f369..f52413a44 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -6,6 +6,6 @@ void ServiceInterfaceStream::setActive( bool myActive) {
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string set_message,
 		uint16_t port) :
-		std::basic_ostream<char, std::char_traits<char> >(&buf), buf(
-				set_message, port) {
+		std::basic_ostream<char, std::char_traits<char>>(&buf),
+		buf(set_message, port) {
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 44cf1168f..4a5b709fb 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -14,7 +14,8 @@ extern std::ostream info;
 extern std::ostream warning;
 extern std::ostream error;
 
-class ServiceInterfaceStream : public std::basic_ostream< char, std::char_traits< char > > {
+class ServiceInterfaceStream :
+        public std::basic_ostream<char, std::char_traits<char>> {
 protected:
     ServiceInterfaceBuffer buf;
 public:
@@ -23,5 +24,4 @@ public:
 };
 
 
-
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 6b563f983..8450494a6 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -104,7 +104,7 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	info << "TMTC Bridge: Comm Link down. "
-			"Saving packet ID to be sent later " << std::endl;
+			"Saving packet ID to be sent later\r\n" << std::flush;
 	store_address_t storeId;
 
 	if(fifo.full()) {
@@ -124,7 +124,7 @@ ReturnValue_t TmTcBridge::sendStoredTm() {
 	ReturnValue_t result = RETURN_OK;
 	while(!fifo.empty() && counter < MAX_STORED_DATA_SENT_PER_CYCLE) {
 		info << "UDP Server: Sending stored TM data. There are "
-				<< (int) fifo.size() << " left to send" << std::endl;
+				<< (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
 		const uint8_t* data = NULL;
 		size_t size = 0;

From eb2df3d88cc3bc2c70bda89208bf4e392bbef860 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 12 Apr 2020 23:06:57 +0200
Subject: [PATCH 0167/1774] Using C++ to implement preamble. adding optional
 flag for carriage return

---
 datapool/PoolRawAccessHelper.h              |  2 +-
 osal/linux/FixedTimeslotTask.cpp            |  4 ++-
 serviceinterface/ServiceInterfaceBuffer.cpp | 32 ++++++++++++---------
 serviceinterface/ServiceInterfaceBuffer.h   | 22 ++++++++++++--
 serviceinterface/ServiceInterfaceStream.cpp |  4 +--
 serviceinterface/ServiceInterfaceStream.h   |  5 ++--
 6 files changed, 47 insertions(+), 22 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 89974ea4f..7d9b9b487 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -69,7 +69,7 @@ private:
 	struct SerializationArgs {
 		uint8_t ** buffer;
 		size_t * size;
-		const uint32_t max_size;
+		const size_t max_size;
 		bool bigEndian;
 	};
 	/**
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 21040e6ef..7f117301a 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -9,7 +9,9 @@
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
 
-FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_, uint32_t periodMs_):PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
+FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_,
+		size_t stackSize_, uint32_t periodMs_):
+		PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
 }
 
 FixedTimeslotTask::~FixedTimeslotTask() {
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 527db07b1..a2365d000 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,13 +1,10 @@
 #include <framework/timemanager/Clock.h>
 #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
 #include <cstring>
-#include <inttypes.h>
 
 // to be implemented by bsp
 extern "C" void printChar(const char*);
 
-
-
 int ServiceInterfaceBuffer::overflow(int c) {
 	// Handle output
 	putChars(pbase(), pptr());
@@ -26,15 +23,16 @@ int ServiceInterfaceBuffer::sync(void) {
 	if (this->isActive) {
 		Clock::TimeOfDay_t loggerTime;
 		Clock::getDateAndTime(&loggerTime);
-		char preamble[96] = { 0 };
-		sprintf(preamble, "\r%s: | %" PRIu32 ":%02" PRIu32 ":%02" PRIu32
-		        ".%03" PRIu32 " | ", this->log_message.c_str(),
-				loggerTime.hour,
-				loggerTime.minute,
-				loggerTime.second,
-				loggerTime.usecond /1000);
+		std::string preamble;
+		if(addCrToPreamble) {
+			preamble += "\r";
+		}
+		preamble += log_message + ": | " + zero_padded(loggerTime.hour, 2)
+				+ ":" + zero_padded(loggerTime.minute, 2) + ":"
+				+ zero_padded(loggerTime.second, 2) + "."
+				+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
 		// Write log_message and time
-		this->putChars(preamble, preamble + sizeof(preamble));
+		this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
 		// Handle output
 		this->putChars(pbase(), pptr());
 	}
@@ -43,10 +41,13 @@ int ServiceInterfaceBuffer::sync(void) {
 	return 0;
 }
 
+
+
 #ifndef UT699
 
 ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-        uint16_t port) {
+        uint16_t port, bool addCrToPreamble) {
+	this->addCrToPreamble = addCrToPreamble;
 	this->log_message = set_message;
 	this->isActive = true;
 	setp( buf, buf + BUF_SIZE );
@@ -67,10 +68,15 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 }
 #endif
 
+/**
+ * TODO: This is architecture specific. Maybe there is a better solution
+ * to move this into the Bsp folder..
+ */
 #ifdef UT699
 #include <framework/osal/rtems/Interrupt.h>
 
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+		uint16_t port) {
 	this->log_message = set_message;
 	this->isActive = true;
 	setp( buf, buf + BUF_SIZE );
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index b4756d417..a2bc4f4b1 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -2,16 +2,17 @@
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 
 #include <iostream>
-#include <iosfwd>
 #include <sstream>
 #include <cstdio>
+#include <iomanip>
 
 #ifndef UT699
 class ServiceInterfaceBuffer:
         public std::basic_streambuf<char,std::char_traits<char>> {
 	friend class ServiceInterfaceStream;
 public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+	ServiceInterfaceBuffer(std::string set_message, uint16_t port,
+			bool addCrToPreamble);
 protected:
 	bool isActive;
 	// This is called when buffer becomes full. If
@@ -28,13 +29,28 @@ private:
 	std::string log_message;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
+	// This is useful for some terminal programs which do not have
+	// implicit carriage return with newline characters.
+	bool addCrToPreamble;
 
 	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 150;
+	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
 
 	// In this function, the characters are parsed.
 	void putChars(char const* begin, char const* end);
+
+	template<typename T>
+	std::string zero_padded(const T& num, uint8_t width) {
+	    std::ostringstream string_to_pad;
+	    string_to_pad << std::setw(width) << std::setfill('0') << num;
+	    std::string result = string_to_pad.str();
+	    if (result.length() > width)
+	    {
+	        result.erase(0, result.length() - width);
+	    }
+	    return result;
+	}
 };
 #endif
 
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index f52413a44..40f52f1fe 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -5,7 +5,7 @@ void ServiceInterfaceStream::setActive( bool myActive) {
 }
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string set_message,
-		uint16_t port) :
+		bool addCrToPreamble, uint16_t port) :
 		std::basic_ostream<char, std::char_traits<char>>(&buf),
-		buf(set_message, port) {
+		buf(set_message, port, addCrToPreamble) {
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 4a5b709fb..5e223f0eb 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -7,7 +7,7 @@
 #include <sstream>
 #include <cstdio>
 
-//Unfortunately, there must be a forward declaration of log_fe
+// Unfortunately, there must be a forward declaration of log_fe
 // (MUST be defined in main), to let the system know where to write to.
 extern std::ostream debug;
 extern std::ostream info;
@@ -19,7 +19,8 @@ class ServiceInterfaceStream :
 protected:
     ServiceInterfaceBuffer buf;
 public:
-    ServiceInterfaceStream( std::string set_message, uint16_t port = 1234 );
+    ServiceInterfaceStream( std::string set_message,
+    		bool addCrToPreamble = false, uint16_t port = 1234);
 	void setActive( bool );
 };
 

From a0ee010926eb3870c61c8eaa8cd39f9601b1fa86 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 13 Apr 2020 16:27:05 +0200
Subject: [PATCH 0168/1774] Added test folder.

---
 framework.mk                      |   1 +
 serialize/EndianSwapper.h         |   4 +-
 serialize/SerialBufferAdapter.cpp |  17 ++-
 serialize/SerialBufferAdapter.h   |  18 +--
 serialize/SerializeAdapter.h      |  37 ++---
 test/UnitTestClass.cpp            | 217 ++++++++++++++++++++++++++++++
 test/UnitTestClass.h              |  78 +++++++++++
 7 files changed, 338 insertions(+), 34 deletions(-)
 create mode 100644 test/UnitTestClass.cpp
 create mode 100644 test/UnitTestClass.h

diff --git a/framework.mk b/framework.mk
index a5a653641..2e7e57e93 100644
--- a/framework.mk
+++ b/framework.mk
@@ -54,3 +54,4 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/test/*.cpp)
diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index 25fb681e9..9f621902f 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -11,9 +11,7 @@
  */
 class EndianSwapper {
 private:
-	EndianSwapper() {
-	}
-	;
+	EndianSwapper() {};
 public:
 	template<typename T>
 	static T swap(T in) {
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index f97d0d588..42ea3dada 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -12,8 +12,8 @@ SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer,
 }
 
 template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer, count_t bufferLength,
-		bool serializeLength) :
+SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer,
+		count_t bufferLength, bool serializeLength) :
 		serializeLength(serializeLength), bufferLength(bufferLength) {
 	uint8_t * member_buffer = static_cast<uint8_t *>(buffer);
 	m_buffer = member_buffer;
@@ -26,8 +26,8 @@ SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
 template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
+		size_t* size, const size_t max_size, bool bigEndian) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
@@ -98,7 +98,8 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 template<typename count_t>
 uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 	if(m_buffer == nullptr) {
-		error << "Wrong access function for stored type ! Use getConstBuffer()" << std::endl;
+		error << "Wrong access function for stored type !"
+				 " Use getConstBuffer()" << std::endl;
 		return nullptr;
 	}
 	return m_buffer;
@@ -107,14 +108,16 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
-		error << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
+		error << "Wrong access function for stored type !"
+				 " Use getBuffer()" << std::endl;
 		return nullptr;
 	}
 	return constBuffer;
 }
 
 template<typename count_t>
-void SerialBufferAdapter<count_t>::setBuffer(void * buffer, count_t buffer_length) {
+void SerialBufferAdapter<count_t>::setBuffer(void * buffer,
+		count_t buffer_length) {
 	m_buffer = static_cast<uint8_t *>(buffer);
 	bufferLength = buffer_length;
 }
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index cf3ae07ed..4a886cbaa 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -8,11 +8,13 @@
  * 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.
+ * 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)>> serialBufferElement.
- * Right now, the SerialBufferAdapter must always be initialized with the buffer and size !
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
+ * Right now, the SerialBufferAdapter must always
+ * be initialized with the buffer and size !
  *
  * \ingroup serialize
  */
@@ -27,14 +29,16 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter(const void* buffer, count_t bufferLength, bool serializeLength = false);
+	SerialBufferAdapter(const void* buffer, count_t bufferLength,
+			bool serializeLength = false);
 
 	/**
-	 * Constructor for non-constant uint8_t buffer. Length field can be serialized optionally.
+	 * 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
+	 * @param serializeLength Length field will be serialized with size count_t
 	 */
 	SerialBufferAdapter(void* buffer, count_t bufferLength, bool serializeLength = false);
 
@@ -58,6 +62,4 @@ private:
 	count_t bufferLength = 0;
 };
 
-
-
 #endif /* SERIALBUFFERADAPTER_H_ */
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 81a3730f8..fce8651b5 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -9,18 +9,21 @@
 
  /**
  * @brief This adapter 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.
+ * 		  with arbitrary template objects to facilitate and simplify the
+ * 		  serialization of classes with different multiple different data types
+ * 		  into buffers and vice-versa.
  * @details
  * Examples:
- * A report class is converted into a TM buffer. The report class implements a serialize functions and calls
- * the AutoSerializeAdapter::serialize function repeatedly on all object data fields.
- * The getSerializedSize function is implemented by calling the
- * AutoSerializeAdapter::getSerializedSize function repeatedly on all data fields.
+ * A report class is converted into a TM buffer. The report class implements a
+ * serialize functions and calls the AutoSerializeAdapter::serialize function
+ * repeatedly on all object data fields. The getSerializedSize function is
+ * implemented by calling the AutoSerializeAdapter::getSerializedSize function
+ * repeatedly on all data fields.
  *
- * The AutoSerializeAdapter functions can also be used as an alternative to memcpy
- * to retrieve data out of a buffer directly into a class variable with data type T while being able to specify endianness.
- * The boolean bigEndian specifies whether an endian swap is performed on the data before
+ * The AutoSerializeAdapter functions can also be used as an alternative to
+ * memcpy to retrieve data out of a buffer directly into a class variable
+ * with data type T while being able to specify endianness. The boolean
+ * bigEndian specifies whether an endian swap is performed on the data before
  * serialization or deserialization.
  *
  * If the target architecture is little endian (ARM), any data types created might
@@ -50,8 +53,8 @@
  *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
  *   	data = EndianSwapper::swap(data);
  *
- * When serializing for downlink, the packets are generally serialized assuming big endian data format
- * like seen in TmPacketStored.cpp for example.
+ * When serializing for downlink, the packets are generally serialized assuming
+ * big endian data format like seen in TmPacketStored.cpp for example.
  *
  * @ingroup serialize
  */
@@ -83,8 +86,10 @@ public:
 	/**
 	 * Deserialize buffer into object
 	 * @param object [out] Object to be deserialized with buffer data
-	 * @param buffer buffer containing the data. Non-Const pointer to non-const pointer to const buffer.
-	 * @param size int32_t type to allow value to be values smaller than 0, needed for range/size checking
+	 * @param buffer buffer containing the data. Non-Const pointer to non-const
+	 * 						pointer to const buffer.
+	 * @param size int32_t type to allow value to be values smaller than 0,
+	 * 						needed for range/size checking
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
@@ -106,7 +111,7 @@ public:
 		}
 	}
 
-	uint32_t getSerializedSize(const T * object) {
+	size_t getSerializedSize(const T * object) {
 		return sizeof(T);
 	}
 
@@ -123,7 +128,7 @@ public:
 		}
 		return object->serialize(buffer, size, max_size, bigEndian);
 	}
-	uint32_t getSerializedSize(const T* object) const {
+	size_t getSerializedSize(const T* object) const {
 		return object->getSerializedSize();
 	}
 
@@ -163,7 +168,7 @@ public:
 		return adapter.serialize(object, buffer, size, max_size, bigEndian);
 	}
 	template<typename T>
-	static uint32_t getSerializedSize(const T* object) {
+	static size_t getSerializedSize(const T* object) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.getSerializedSize(object);
 	}
diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
new file mode 100644
index 000000000..7050dece0
--- /dev/null
+++ b/test/UnitTestClass.cpp
@@ -0,0 +1,217 @@
+/**
+ * @file 	UnitTestClass.cpp
+ *
+ * @date 	11.04.2020
+ * @author 	R. Mueller
+ */
+#include <framework/test/UnitTestClass.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/serialize/SerializeElement.h>
+#include <framework/serialize/SerialBufferAdapter.h>
+
+#include <cstdlib>
+
+UnitTestClass::UnitTestClass() {
+}
+
+UnitTestClass::~UnitTestClass() {
+}
+
+ReturnValue_t UnitTestClass::performTests() {
+	ReturnValue_t result = test_serialization();
+	if(result != RETURN_OK) {
+		return result;
+	}
+
+	return RETURN_OK;
+}
+
+ReturnValue_t UnitTestClass::test_serialization() {
+	// Here, we test all serialization tools. First test basic cases.
+	ReturnValue_t result = test_autoserialization();
+	if(result != RETURN_OK) {
+		return result;
+	}
+	result = test_serial_buffer_adapter();
+	if(result != RETURN_OK) {
+		return result;
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t UnitTestClass::test_autoserialization() {
+	current_id = TestIds::AUTO_SERIALIZATION_SIZE;
+	// Unit Test getSerializedSize
+	if(AutoSerializeAdapter::
+			getSerializedSize(&test_value_bool) != sizeof(test_value_bool) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_uint8) != sizeof(tv_uint8) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_uint16) != sizeof(tv_uint16) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_uint32) != sizeof(tv_uint32) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_uint64) != sizeof(tv_uint64) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_int8) != sizeof(tv_int8) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_double) != sizeof(tv_double) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_int16) != sizeof(tv_int16) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_int32) != sizeof(tv_int32) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_float) != sizeof(tv_float))
+	{
+		return put_error(current_id);
+	}
+
+	// Unit Test AutoSerializeAdapter deserialize
+	current_id = TestIds::AUTO_SERIALIZATION_SERIALIZE;
+
+	size_t serialized_size = 0;
+	uint8_t * p_array = test_array.data();
+
+	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint8, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint16, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint32, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_int8, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_int16, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_int32, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint64, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_float, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_double, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_sfloat, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_sdouble, &p_array,
+			&serialized_size, test_array.size(), false);
+	// expected size is 1 + 1 + 2 + 4 + 1 + 2 + 4 + 8 + 4 + 8 + 4 + 8
+	if(serialized_size != 47) {
+		return put_error(current_id);
+	}
+
+	// Unit Test AutoSerializeAdapter serialize
+	current_id = TestIds::AUTO_SERIALIZATION_DESERIALIZE;
+	p_array = test_array.data();
+	ssize_t remaining_size = serialized_size;
+	AutoSerializeAdapter::deSerialize(&test_value_bool,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_uint8,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_uint16,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_uint32,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_int8,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_int16,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_int32,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_uint64,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_float,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_double,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_sfloat,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_sdouble,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+
+	//	uint16_t tv_uint16 {283};
+	//	uint32_t tv_uint32 {929221};
+	//	uint64_t tv_uint64 {2929329429};
+	//	int8_t tv_int8 {-16};
+	//	int16_t tv_int16 {-829};
+	//	int32_t tv_int32 {-2312};
+	//	float tv_float {8.2149214};
+	//	float tv_sfloat = {-922.2321321};
+	//	double tv_double {9.2132142141e8};
+	//	double tv_sdouble {-2.2421e19};
+	if(test_value_bool != true or tv_uint8 != 5 or tv_uint16 != 283 or
+			tv_uint32 != 929221 or tv_uint64 != 2929329429 or tv_int8 != -16 or
+			tv_int16 != -829 or tv_int32 != -2312 or tv_float != 8.214921 or
+			tv_double != 9.2132142141e8 or tv_sfloat != -922.2321321 or
+			tv_sdouble != -2.2421e19)
+	{
+		return put_error(current_id);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t UnitTestClass::test_serial_buffer_adapter() {
+	current_id = TestIds::SERIALIZATION_BUFFER_ADAPTER;
+
+	// I will skip endian swapper testing, its going to be changed anyway..
+	// uint8_t tv_uint8_swapped = EndianSwapper::swap(tv_uint8);
+
+	size_t serialized_size = 0;
+	test_value_bool = true;
+	uint8_t * p_array = test_array.data();
+	std::array<uint8_t, 5> test_serial_buffer {5, 4, 3, 2, 1};
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter =
+			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+					test_serial_buffer.size(), false);
+	tv_uint16 = 16;
+
+	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
+			test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
+			test_array.size(), false);
+
+	if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
+			or test_array[5] != 1)
+	{
+		return put_error(current_id);
+	}
+	memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
+	if(tv_uint16 != 16) {
+		return put_error(current_id);
+	}
+
+	// Serialize with size field
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter2 =
+			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+					test_serial_buffer.size(), true);
+	serialized_size = 0;
+	p_array = test_array.data();
+	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
+			test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter2, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
+			test_array.size(), false);
+
+	if(serialized_size != 9 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 5 or test_array[3] != 4 or test_array[4] != 3
+			or test_array[5] != 2 or test_array[6] != 1)
+	{
+		return put_error(current_id);
+	}
+	memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
+	if(tv_uint16 != 16) {
+		return put_error(current_id);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t UnitTestClass::put_error(TestIds current_id) {
+	error << "Unit Tester failed at test ID "
+			<< static_cast<uint32_t>(current_id) << "\r\n" << std::flush;
+	return RETURN_FAILED;
+}
diff --git a/test/UnitTestClass.h b/test/UnitTestClass.h
new file mode 100644
index 000000000..c93ea0bc8
--- /dev/null
+++ b/test/UnitTestClass.h
@@ -0,0 +1,78 @@
+/**
+ * @file 	UnitTestClass.h
+ *
+ * @date 	11.04.2020
+ * @author 	R. Mueller
+ */
+
+#ifndef FRAMEWORK_TEST_UNITTESTCLASS_H_
+#define FRAMEWORK_TEST_UNITTESTCLASS_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <map>
+#include <vector>
+
+/**
+ * We could start doing basic forms of Unit Testing (without a framework, first)
+ * for framework components. This could include:
+ *
+ *  1. TMTC Services
+ *  2. Serialization tools
+ *  3. Framework internal algorithms
+ */
+
+class UnitTestClass: public HasReturnvaluesIF {
+public:
+	UnitTestClass();
+	virtual~ UnitTestClass();
+
+	enum class TestIds {
+		AUTO_SERIALIZATION_SIZE = 0,
+		AUTO_SERIALIZATION_SERIALIZE = 1,
+		AUTO_SERIALIZATION_DESERIALIZE = 2,
+		SERIALIZATION_BUFFER_ADAPTER = 3,
+		SERIALIZATION_FIXED_ARRAY_LIST_ADAPTER = 4,
+		SERIALIZATION_COMBINATION = 5,
+		TMTC_SERVICES ,
+		MISC
+	};
+
+	/**
+	 * Some function which calls all other tests
+	 * @return
+	 */
+	ReturnValue_t performTests();
+
+	ReturnValue_t test_serialization();
+	ReturnValue_t test_autoserialization();
+	ReturnValue_t test_serial_buffer_adapter();
+private:
+	uint32_t errorCounter = 0;
+	TestIds current_id = TestIds::MISC;
+	std::array<uint8_t, 512> test_array;
+
+	using TestResultMap = std::map<uint32_t, ReturnValue_t>;
+	using TestBuffer = std::vector<uint8_t>;
+	TestResultMap testResultMap;
+
+	// POD test values
+	bool test_value_bool = true;
+	uint8_t tv_uint8   {5};
+	uint16_t tv_uint16 {283};
+	uint32_t tv_uint32 {929221};
+	uint64_t tv_uint64 {2929329429};
+
+	int8_t tv_int8 {-16};
+	int16_t tv_int16 {-829};
+	int32_t tv_int32 {-2312};
+
+	float tv_float {8.2149214};
+	float tv_sfloat = {-922.2321321};
+	double tv_double {9.2132142141e8};
+	double tv_sdouble {-2.2421e19};
+
+	ReturnValue_t put_error(TestIds currentId);
+};
+
+
+#endif /* FRAMEWORK_TEST_UNITTESTCLASS_H_ */

From 0d016e5a2b2e5b566c7c7f2a11e64c1c93dcc4d3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Apr 2020 16:37:25 +0200
Subject: [PATCH 0169/1774] slight formatting

---
 osal/linux/PeriodicPosixTask.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index e3fa57229..43647eda1 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -9,7 +9,8 @@
 
 class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
 public:
-	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, uint32_t period_, void(*deadlineMissedFunc_)());
+	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t period_, void(*deadlineMissedFunc_)());
 	virtual ~PeriodicPosixTask();
 	/**
 	 * @brief	The method to start the task.

From b48a0a4a4ce5ea9b4e85b76223e357fe49ce6907 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Apr 2020 22:45:23 +0200
Subject: [PATCH 0170/1774] unit test class continued. serialize adapter

functions which are internal, extracted to separate class
---
 container/IsDerivedFrom.h            |   9 ++
 serialize/SerializeAdapter.h         | 162 +++++++--------------------
 serialize/SerializeAdapterInternal.h | 114 +++++++++++++++++++
 test/UnitTestClass.cpp               |  87 +++++++++++++-
 test/UnitTestClass.h                 |  18 +--
 5 files changed, 259 insertions(+), 131 deletions(-)
 create mode 100644 serialize/SerializeAdapterInternal.h

diff --git a/container/IsDerivedFrom.h b/container/IsDerivedFrom.h
index 520033dbd..8142a3781 100644
--- a/container/IsDerivedFrom.h
+++ b/container/IsDerivedFrom.h
@@ -1,6 +1,13 @@
 #ifndef ISDERIVEDFROM_H_
 #define ISDERIVEDFROM_H_
 
+/**
+ * These template type checks are based on SFINAE
+ * (https://en.cppreference.com/w/cpp/language/sfinae)
+ *
+ * @tparam D Derived Type
+ * @tparam B Base Type
+ */
 template<typename D, typename B>
 class IsDerivedFrom {
 	class No {
@@ -9,7 +16,9 @@ class IsDerivedFrom {
 		No no[3];
 	};
 
+	// This will be chosen if B is the base type
 	static Yes Test(B*); // declared, but not defined
+	// This will be chosen for anything else
 	static No Test(... ); // declared, but not defined
 
 public:
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index fce8651b5..d926bfcec 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -1,19 +1,18 @@
 #ifndef SERIALIZEADAPTER_H_
 #define SERIALIZEADAPTER_H_
 
-#include <framework/container/IsDerivedFrom.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/EndianSwapper.h>
 #include <framework/serialize/SerializeIF.h>
-#include <string.h>
+#include <framework/serialize/SerializeAdapterInternal.h>
+#include <type_traits>
 
  /**
- * @brief This adapter provides an interface to use the SerializeIF functions
+ * @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
- * Examples:
+ *
  * A report class is converted into a TM buffer. The report class implements a
  * serialize functions and calls the AutoSerializeAdapter::serialize function
  * repeatedly on all object data fields. The getSerializedSize function is
@@ -26,137 +25,42 @@
  * bigEndian specifies whether an endian swap is performed on the data before
  * serialization or deserialization.
  *
- * If the target architecture is little endian (ARM), any data types created might
- * have the wrong endiness if they are to be used for the FSFW.
  * There are three ways to retrieve data out of a buffer to be used in the FSFW
- * to use regular aligned (big endian) data.
- * This can also be applied to uint32_t and uint64_t:
+ * to use regular aligned (big endian) data. Examples:
  *
  *   1. Use the AutoSerializeAdapter::deSerialize function
- *		The pointer *buffer will be incremented automatically by the typeSize of the object,
- *		so this function can be called on &buffer repeatedly without adjusting pointer position.
- *		Set bigEndian parameter to true to perform endian swapping.
- *
+ *		The pointer *buffer will be incremented automatically by the typeSize
+ *		 of the object, so this function can be called on &buffer repeatedly
+ *		without adjusting pointer position. Set bigEndian parameter to true
+ *		to perform endian swapping, if necessary
+ *		@code
  *   	uint16_t data;
  *   	int32_t dataLen = sizeof(data);
- *   	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
- *
- *   2. Perform a bitshift operation. Perform endian swapping if necessary:
+ *   	ReturnValue_t result =
+ *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
+ *   	@endcode
  *
+ *   2. Perform a bitshift operation. Watch for for endianness:
+ *		@code
  *   	uint16_t data;
  *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
- *   	data = EndianSwapper::swap(data);
- *
- *   3. Memcpy can be used when data is little-endian. Perform endian-swapping if necessary.
+ *   	data = EndianSwapper::swap(data); //optional, or swap order above
+ *   	@endcode
  *
+ *   3. memcpy or std::copy can also be used, but watch out if system
+ *   	endianness is different from required data endianness.
+ *   	Perform endian-swapping if necessary.
+ *		@code
  *   	uint16_t data;
  *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
- *   	data = EndianSwapper::swap(data);
+ *   	data = EndianSwapper::swap(data); //optional
+ *   	@endcode
  *
  * When serializing for downlink, the packets are generally serialized assuming
  * big endian data format like seen in TmPacketStored.cpp for example.
  *
  * @ingroup serialize
  */
-template<typename T, int>
-class SerializeAdapter_ {
-public:
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			size_t* size, const size_t max_size, bool bigEndian) {
-		size_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		if (sizeof(T) + *size <= max_size) {
-			T tmp;
-			if (bigEndian) {
-				tmp = EndianSwapper::swap<T>(*object);
-			} else {
-				tmp = *object;
-			}
-			memcpy(*buffer, &tmp, sizeof(T));
-			*size += sizeof(T);
-			(*buffer) += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::BUFFER_TOO_SHORT;
-		}
-	}
-
-	/**
-	 * Deserialize buffer into object
-	 * @param object [out] Object to be deserialized with buffer data
-	 * @param buffer buffer containing the data. Non-Const pointer to non-const
-	 * 						pointer to const buffer.
-	 * @param size int32_t type to allow value to be values smaller than 0,
-	 * 						needed for range/size checking
-	 * @param bigEndian Specify endianness
-	 * @return
-	 */
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
-			bool bigEndian) {
-		T tmp;
-		*size -= sizeof(T);
-		if (*size >= 0) {
-			memcpy(&tmp, *buffer, sizeof(T));
-			if (bigEndian) {
-				*object = EndianSwapper::swap<T>(tmp);
-			} else {
-				*object = tmp;
-			}
-			*buffer += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::STREAM_TOO_SHORT;
-		}
-	}
-
-	size_t getSerializedSize(const T * object) {
-		return sizeof(T);
-	}
-
-};
-
-template<typename T>
-class SerializeAdapter_<T, 1> {
-public:
-	ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		size_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		return object->serialize(buffer, size, max_size, bigEndian);
-	}
-	size_t getSerializedSize(const T* object) const {
-		return object->getSerializedSize();
-	}
-
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
-			bool bigEndian) {
-		return object->deSerialize(buffer, size, bigEndian);
-	}
-};
-
-template<typename T>
-class SerializeAdapter {
-public:
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			size_t* size, const size_t max_size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.serialize(object, buffer, size, max_size, bigEndian);
-	}
-	static uint32_t getSerializedSize(const T* object) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.getSerializedSize(object);
-	}
-
-	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			ssize_t* size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.deSerialize(object, buffer, size, bigEndian);
-	}
-};
 
 // No type specification necessary here.
 class AutoSerializeAdapter {
@@ -180,4 +84,24 @@ public:
 	}
 };
 
+template<typename T>
+class SerializeAdapter {
+public:
+	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
+			size_t* size, const size_t max_size, bool bigEndian) {
+		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.serialize(object, buffer, size, max_size, bigEndian);
+	}
+	static uint32_t getSerializedSize(const T* object) {
+		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.getSerializedSize(object);
+	}
+
+	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
+			ssize_t* size, bool bigEndian) {
+		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.deSerialize(object, buffer, size, bigEndian);
+	}
+};
+
 #endif /* SERIALIZEADAPTER_H_ */
diff --git a/serialize/SerializeAdapterInternal.h b/serialize/SerializeAdapterInternal.h
new file mode 100644
index 000000000..46dbdf191
--- /dev/null
+++ b/serialize/SerializeAdapterInternal.h
@@ -0,0 +1,114 @@
+/**
+ * @file 	SerializeAdapterInternal.h
+ *
+ * @date	13.04.2020
+ * @author	R. Mueller
+ */
+
+#ifndef FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
+#define FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/container/IsDerivedFrom.h>
+#include <framework/serialize/EndianSwapper.h>
+
+/**
+ * This template specialization will be chosen for fundamental types.
+ * @tparam T
+ * @tparam
+ */
+template<typename T, int>
+class SerializeAdapter_ {
+public:
+	/**
+	 *
+	 * @param object
+	 * @param buffer
+	 * @param size
+	 * @param max_size
+	 * @param bigEndian
+	 * @return
+	 */
+	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
+			size_t* size, const size_t max_size, bool bigEndian) {
+		size_t ignoredSize = 0;
+		if (size == nullptr) {
+			size = &ignoredSize;
+		}
+		if (sizeof(T) + *size <= max_size) {
+			T tmp;
+			if (bigEndian) {
+				tmp = EndianSwapper::swap<T>(*object);
+			} else {
+				tmp = *object;
+			}
+			memcpy(*buffer, &tmp, sizeof(T));
+			*size += sizeof(T);
+			(*buffer) += sizeof(T);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return SerializeIF::BUFFER_TOO_SHORT;
+		}
+	}
+
+	/**
+	 * Deserialize buffer into object
+	 * @param object [out] Object to be deserialized with buffer data
+	 * @param buffer buffer containing the data. Non-Const pointer to non-const
+	 * 						pointer to const buffer.
+	 * @param size int32_t type to allow value to be values smaller than 0,
+	 * 						needed for range/size checking
+	 * @param bigEndian Specify endianness
+	 * @return
+	 */
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
+			bool bigEndian) {
+		T tmp;
+		*size -= sizeof(T);
+		if (*size >= 0) {
+			memcpy(&tmp, *buffer, sizeof(T));
+			if (bigEndian) {
+				*object = EndianSwapper::swap<T>(tmp);
+			} else {
+				*object = tmp;
+			}
+			*buffer += sizeof(T);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return SerializeIF::STREAM_TOO_SHORT;
+		}
+	}
+
+	size_t getSerializedSize(const T * object) {
+		return sizeof(T);
+	}
+};
+
+/**
+ * This template specialization will be chosen for class derived from
+ * SerializeIF.
+ * @tparam T
+ * @tparam
+ */
+template<typename T>
+class SerializeAdapter_<T, true> {
+public:
+	ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
+		size_t ignoredSize = 0;
+		if (size == NULL) {
+			size = &ignoredSize;
+		}
+		return object->serialize(buffer, size, max_size, bigEndian);
+	}
+
+	size_t getSerializedSize(const T* object) const {
+		return object->getSerializedSize();
+	}
+
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
+			bool bigEndian) {
+		return object->deSerialize(buffer, size, bigEndian);
+	}
+};
+
+#endif /* FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_ */
diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
index 7050dece0..ac570b21e 100644
--- a/test/UnitTestClass.cpp
+++ b/test/UnitTestClass.cpp
@@ -17,7 +17,7 @@ UnitTestClass::UnitTestClass() {
 UnitTestClass::~UnitTestClass() {
 }
 
-ReturnValue_t UnitTestClass::performTests() {
+ReturnValue_t UnitTestClass::perform_tests() {
 	ReturnValue_t result = test_serialization();
 	if(result != RETURN_OK) {
 		return result;
@@ -28,7 +28,11 @@ ReturnValue_t UnitTestClass::performTests() {
 
 ReturnValue_t UnitTestClass::test_serialization() {
 	// Here, we test all serialization tools. First test basic cases.
-	ReturnValue_t result = test_autoserialization();
+	ReturnValue_t result = test_endianness_tools();
+	if(result != RETURN_OK) {
+		return result;
+	}
+	result = test_autoserialization();
 	if(result != RETURN_OK) {
 		return result;
 	}
@@ -39,6 +43,47 @@ ReturnValue_t UnitTestClass::test_serialization() {
 	return RETURN_OK;
 }
 
+ReturnValue_t UnitTestClass::test_endianness_tools() {
+	test_array[0] = 0;
+	test_array[1] = 0;
+	uint16_t two_byte_value = 1;
+	size_t size = 0;
+	uint8_t* p_array = test_array.data();
+	AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, false);
+	// Little endian: Value one on first byte
+	if(test_array[0] != 1 and test_array[1] != 0) {
+		return put_error(TestIds::ENDIANNESS_TOOLS);
+
+	}
+	p_array = test_array.data();
+	size = 0;
+	AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, true);
+	// Big endian: Value one on second byte
+	if(test_array[0] != 0 and test_array[1] != 1) {
+		return put_error(TestIds::ENDIANNESS_TOOLS);
+	}
+
+	// Endianness paameter will be changed later.
+//	p_array = test_array.data();
+//	ssize_t ssize = size;
+//	// Resulting parameter should be big endian
+//	AutoSerializeAdapter::deSerialize(&two_byte_value,
+//			const_cast<const uint8_t **>(&p_array), &ssize, true);
+//	if(two_byte_value != 1) {
+//		return put_error(TestIds::ENDIANNESS_TOOLS);
+//	}
+//
+//	ssize = size;
+//	p_array = test_array.data();
+//	// Resulting parameter should be little endian
+//	AutoSerializeAdapter::deSerialize(&two_byte_value,
+//			const_cast<const uint8_t **>(&p_array), &ssize, false);
+//	if(two_byte_value != 256) {
+//		return put_error(TestIds::ENDIANNESS_TOOLS);
+//	}
+	return RETURN_OK;
+}
+
 ReturnValue_t UnitTestClass::test_autoserialization() {
 	current_id = TestIds::AUTO_SERIALIZATION_SIZE;
 	// Unit Test getSerializedSize
@@ -142,15 +187,21 @@ ReturnValue_t UnitTestClass::test_autoserialization() {
 	//	double tv_sdouble {-2.2421e19};
 	if(test_value_bool != true or tv_uint8 != 5 or tv_uint16 != 283 or
 			tv_uint32 != 929221 or tv_uint64 != 2929329429 or tv_int8 != -16 or
-			tv_int16 != -829 or tv_int32 != -2312 or tv_float != 8.214921 or
-			tv_double != 9.2132142141e8 or tv_sfloat != -922.2321321 or
-			tv_sdouble != -2.2421e19)
+			tv_int16 != -829 or tv_int32 != -2312)
 	{
 		return put_error(current_id);
 	}
+
+	if(abs(tv_float - 8.214921) > 0.0001 or
+			abs(tv_double - 9.2132142141e8) > 0.01 or
+			abs(tv_sfloat - (-922.2321321)) > 0.0001 or
+			abs(tv_sdouble - (-2.2421e19)) > 0.01) {
+		return put_error(current_id);
+	}
 	return RETURN_OK;
 }
 
+// TODO: Also test for constant buffers.
 ReturnValue_t UnitTestClass::test_serial_buffer_adapter() {
 	current_id = TestIds::SERIALIZATION_BUFFER_ADAPTER;
 
@@ -203,6 +254,31 @@ ReturnValue_t UnitTestClass::test_serial_buffer_adapter() {
 	{
 		return put_error(current_id);
 	}
+	memcpy(&tv_uint16, test_array.data() + 7, sizeof(tv_uint16));
+	if(tv_uint16 != 16) {
+		return put_error(current_id);
+	}
+
+	// Serialize with size field
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter3 =
+			SerialBufferAdapter<uint8_t>(
+			const_cast<const uint8_t*>(test_serial_buffer.data()),
+			test_serial_buffer.size(), false);
+	serialized_size = 0;
+	p_array = test_array.data();
+	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
+			test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter3, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
+			test_array.size(), false);
+
+	if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
+			or test_array[5] != 1)
+	{
+		return put_error(current_id);
+	}
 	memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
 	if(tv_uint16 != 16) {
 		return put_error(current_id);
@@ -215,3 +291,4 @@ ReturnValue_t UnitTestClass::put_error(TestIds current_id) {
 			<< static_cast<uint32_t>(current_id) << "\r\n" << std::flush;
 	return RETURN_FAILED;
 }
+
diff --git a/test/UnitTestClass.h b/test/UnitTestClass.h
index c93ea0bc8..078cf3c9f 100644
--- a/test/UnitTestClass.h
+++ b/test/UnitTestClass.h
@@ -19,6 +19,8 @@
  *  1. TMTC Services
  *  2. Serialization tools
  *  3. Framework internal algorithms
+ *
+ *  TODO: Maybe use specialized framework.
  */
 
 class UnitTestClass: public HasReturnvaluesIF {
@@ -27,12 +29,13 @@ public:
 	virtual~ UnitTestClass();
 
 	enum class TestIds {
-		AUTO_SERIALIZATION_SIZE = 0,
-		AUTO_SERIALIZATION_SERIALIZE = 1,
-		AUTO_SERIALIZATION_DESERIALIZE = 2,
-		SERIALIZATION_BUFFER_ADAPTER = 3,
-		SERIALIZATION_FIXED_ARRAY_LIST_ADAPTER = 4,
-		SERIALIZATION_COMBINATION = 5,
+		ENDIANNESS_TOOLS,
+		AUTO_SERIALIZATION_SIZE,
+		AUTO_SERIALIZATION_SERIALIZE,
+		AUTO_SERIALIZATION_DESERIALIZE ,
+		SERIALIZATION_BUFFER_ADAPTER,
+		SERIALIZATION_FIXED_ARRAY_LIST_ADAPTER,
+		SERIALIZATION_COMBINATION,
 		TMTC_SERVICES ,
 		MISC
 	};
@@ -41,11 +44,12 @@ public:
 	 * Some function which calls all other tests
 	 * @return
 	 */
-	ReturnValue_t performTests();
+	ReturnValue_t perform_tests();
 
 	ReturnValue_t test_serialization();
 	ReturnValue_t test_autoserialization();
 	ReturnValue_t test_serial_buffer_adapter();
+	ReturnValue_t test_endianness_tools();
 private:
 	uint32_t errorCounter = 0;
 	TestIds current_id = TestIds::MISC;

From 03b0ae7b68541f8d6268c0dcc8b763e04870d185 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Apr 2020 11:16:51 +0200
Subject: [PATCH 0171/1774] unit test fixes

---
 test/UnitTestClass.cpp | 2 +-
 test/UnitTestClass.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
index 7050dece0..f2925a240 100644
--- a/test/UnitTestClass.cpp
+++ b/test/UnitTestClass.cpp
@@ -17,7 +17,7 @@ UnitTestClass::UnitTestClass() {
 UnitTestClass::~UnitTestClass() {
 }
 
-ReturnValue_t UnitTestClass::performTests() {
+ReturnValue_t UnitTestClass::perform_tests() {
 	ReturnValue_t result = test_serialization();
 	if(result != RETURN_OK) {
 		return result;
diff --git a/test/UnitTestClass.h b/test/UnitTestClass.h
index c93ea0bc8..f11842695 100644
--- a/test/UnitTestClass.h
+++ b/test/UnitTestClass.h
@@ -41,7 +41,7 @@ public:
 	 * Some function which calls all other tests
 	 * @return
 	 */
-	ReturnValue_t performTests();
+	ReturnValue_t perform_tests();
 
 	ReturnValue_t test_serialization();
 	ReturnValue_t test_autoserialization();

From c5e5de1530acb3f3212514c254dea65635ece647 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Apr 2020 12:24:26 +0200
Subject: [PATCH 0172/1774] deleted example values

---
 test/UnitTestClass.cpp | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
index ac570b21e..89d4001d3 100644
--- a/test/UnitTestClass.cpp
+++ b/test/UnitTestClass.cpp
@@ -11,11 +11,9 @@
 
 #include <cstdlib>
 
-UnitTestClass::UnitTestClass() {
-}
+UnitTestClass::UnitTestClass() {}
 
-UnitTestClass::~UnitTestClass() {
-}
+UnitTestClass::~UnitTestClass() {}
 
 ReturnValue_t UnitTestClass::perform_tests() {
 	ReturnValue_t result = test_serialization();
@@ -175,16 +173,6 @@ ReturnValue_t UnitTestClass::test_autoserialization() {
 	AutoSerializeAdapter::deSerialize(&tv_sdouble,
 			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
 
-	//	uint16_t tv_uint16 {283};
-	//	uint32_t tv_uint32 {929221};
-	//	uint64_t tv_uint64 {2929329429};
-	//	int8_t tv_int8 {-16};
-	//	int16_t tv_int16 {-829};
-	//	int32_t tv_int32 {-2312};
-	//	float tv_float {8.2149214};
-	//	float tv_sfloat = {-922.2321321};
-	//	double tv_double {9.2132142141e8};
-	//	double tv_sdouble {-2.2421e19};
 	if(test_value_bool != true or tv_uint8 != 5 or tv_uint16 != 283 or
 			tv_uint32 != 929221 or tv_uint64 != 2929329429 or tv_int8 != -16 or
 			tv_int16 != -829 or tv_int32 != -2312)

From af27a2441affb1923a4a2ff33c044ce825549094 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Apr 2020 16:19:13 +0200
Subject: [PATCH 0173/1774] added catch framework for basic testing

---
 framework.mk                             |     2 +-
 serialize/SerializeAdapterInternal.h     |     8 +-
 test/CatchExample.cpp                    |    49 +
 test/UnitTestClass.cpp                   |    11 +
 test/UnitTestClass.h                     |     1 +
 test/catch2/catch.hpp                    | 17618 +++++++++++++++++++++
 test/catch2/catch_reporter_automake.hpp  |    62 +
 test/catch2/catch_reporter_sonarqube.hpp |   181 +
 test/catch2/catch_reporter_tap.hpp       |   253 +
 test/catch2/catch_reporter_teamcity.hpp  |   219 +
 10 files changed, 18401 insertions(+), 3 deletions(-)
 create mode 100644 test/CatchExample.cpp
 create mode 100644 test/catch2/catch.hpp
 create mode 100644 test/catch2/catch_reporter_automake.hpp
 create mode 100644 test/catch2/catch_reporter_sonarqube.hpp
 create mode 100644 test/catch2/catch_reporter_tap.hpp
 create mode 100644 test/catch2/catch_reporter_teamcity.hpp

diff --git a/framework.mk b/framework.mk
index 2e7e57e93..6f64b7205 100644
--- a/framework.mk
+++ b/framework.mk
@@ -54,4 +54,4 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/test/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/test/*.cpp)
\ No newline at end of file
diff --git a/serialize/SerializeAdapterInternal.h b/serialize/SerializeAdapterInternal.h
index 46dbdf191..ed0f6c3b8 100644
--- a/serialize/SerializeAdapterInternal.h
+++ b/serialize/SerializeAdapterInternal.h
@@ -12,7 +12,8 @@
 #include <framework/serialize/EndianSwapper.h>
 
 /**
- * This template specialization will be chosen for fundamental types.
+ * This template specialization will be chosen for fundamental types,
+ * based on partial template specialization
  * @tparam T
  * @tparam
  */
@@ -30,6 +31,9 @@ public:
 	 */
 	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
 			size_t* size, const size_t max_size, bool bigEndian) {
+	    // function eventuelly serializes structs here.
+	    // does this work on every architecture?
+	    //static_assert(std::is_fundamental<T>::value);
 		size_t ignoredSize = 0;
 		if (size == nullptr) {
 			size = &ignoredSize;
@@ -85,7 +89,7 @@ public:
 
 /**
  * This template specialization will be chosen for class derived from
- * SerializeIF.
+ * SerializeIF, based on partial template specialization.
  * @tparam T
  * @tparam
  */
diff --git a/test/CatchExample.cpp b/test/CatchExample.cpp
new file mode 100644
index 000000000..4db6a5c2a
--- /dev/null
+++ b/test/CatchExample.cpp
@@ -0,0 +1,49 @@
+// Catch Example.
+// Does not work yet. Problems with linker without main and config folder.
+// Let Catch provide main():
+
+#if defined(UNIT_TEST)
+#define CATCH_CONFIG_MAIN
+
+#include <framework/test/catch2/catch.hpp>
+#include <framework/test/UnitTestClass.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+int Factorial( int number ) {
+   return number <= 1 ? number : Factorial( number - 1 ) * number;  // fail
+// return number <= 1 ? 1      : Factorial( number - 1 ) * number;  // pass
+}
+
+
+
+TEST_CASE( "Factorial of 0 is 1 (fail)", "[single-file]" ) {
+    REQUIRE( Factorial(0) == 1 );
+}
+
+TEST_CASE( "Factorials of 1 and higher are computed (pass)", "[single-file]" ) {
+    REQUIRE( Factorial(1) == 1 );
+    REQUIRE( Factorial(2) == 2 );
+    REQUIRE( Factorial(3) == 6 );
+    REQUIRE( Factorial(10) == 3628800 );
+}
+
+TEST_CASE( "Custom test", "[single-file]" ) {
+    UnitTestClass unitTestClass;
+    REQUIRE( unitTestClass.test_autoserialization() == HasReturnvaluesIF::RETURN_OK );
+}
+
+// Compile & run:
+// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 010-TestCase 010-TestCase.cpp && ./010-TestCase --success
+// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 010-TestCase.cpp && 010-TestCase --success
+
+// Expected compact output (all assertions):
+//
+// prompt> 010-TestCase --reporter compact --success
+// 010-TestCase.cpp:14: failed: Factorial(0) == 1 for: 0 == 1
+// 010-TestCase.cpp:18: passed: Factorial(1) == 1 for: 1 == 1
+// 010-TestCase.cpp:19: passed: Factorial(2) == 2 for: 2 == 2
+// 010-TestCase.cpp:20: passed: Factorial(3) == 6 for: 6 == 6
+// 010-TestCase.cpp:21: passed: Factorial(10) == 3628800 for: 3628800 (0x375f00) == 3628800 (0x375f00)
+// Failed 1 test case, failed 1 assertion.
+
+#endif
diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
index 89d4001d3..d20dfb0a0 100644
--- a/test/UnitTestClass.cpp
+++ b/test/UnitTestClass.cpp
@@ -11,6 +11,15 @@
 
 #include <cstdlib>
 
+#if defined(UNIT_TEST)
+#include "catch.hpp"
+#define CATCH_CONFIG_MAIN
+
+TEST_CASE( "Serialization Size tests", "[single-file]") {
+   //REQUIRE(UnitTestClass::test_serialization == RETURN_OK );
+}
+#endif
+
 UnitTestClass::UnitTestClass() {}
 
 UnitTestClass::~UnitTestClass() {}
@@ -53,6 +62,7 @@ ReturnValue_t UnitTestClass::test_endianness_tools() {
 		return put_error(TestIds::ENDIANNESS_TOOLS);
 
 	}
+
 	p_array = test_array.data();
 	size = 0;
 	AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, true);
@@ -180,6 +190,7 @@ ReturnValue_t UnitTestClass::test_autoserialization() {
 		return put_error(current_id);
 	}
 
+	// These epsilon values were just guessed.. It appears to work though.
 	if(abs(tv_float - 8.214921) > 0.0001 or
 			abs(tv_double - 9.2132142141e8) > 0.01 or
 			abs(tv_sfloat - (-922.2321321)) > 0.0001 or
diff --git a/test/UnitTestClass.h b/test/UnitTestClass.h
index 078cf3c9f..d9ba9d1c6 100644
--- a/test/UnitTestClass.h
+++ b/test/UnitTestClass.h
@@ -9,6 +9,7 @@
 #define FRAMEWORK_TEST_UNITTESTCLASS_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+
 #include <map>
 #include <vector>
 
diff --git a/test/catch2/catch.hpp b/test/catch2/catch.hpp
new file mode 100644
index 000000000..51618b38e
--- /dev/null
+++ b/test/catch2/catch.hpp
@@ -0,0 +1,17618 @@
+/*
+ *  Catch v2.11.3
+ *  Generated: 2020-03-19 13:44:21.042491
+ *  ----------------------------------------------------------
+ *  This file has been merged from multiple headers. Please don't edit it directly
+ *  Copyright (c) 2020 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+// start catch.hpp
+
+
+#define CATCH_VERSION_MAJOR 2
+#define CATCH_VERSION_MINOR 11
+#define CATCH_VERSION_PATCH 3
+
+#ifdef __clang__
+#    pragma clang system_header
+#elif defined __GNUC__
+#    pragma GCC system_header
+#endif
+
+// start catch_suppress_warnings.h
+
+#ifdef __clang__
+#   ifdef __ICC // icpc defines the __clang__ macro
+#       pragma warning(push)
+#       pragma warning(disable: 161 1682)
+#   else // __ICC
+#       pragma clang diagnostic push
+#       pragma clang diagnostic ignored "-Wpadded"
+#       pragma clang diagnostic ignored "-Wswitch-enum"
+#       pragma clang diagnostic ignored "-Wcovered-switch-default"
+#    endif
+#elif defined __GNUC__
+     // Because REQUIREs trigger GCC's -Wparentheses, and because still
+     // supported version of g++ have only buggy support for _Pragmas,
+     // Wparentheses have to be suppressed globally.
+#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
+
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wunused-variable"
+#    pragma GCC diagnostic ignored "-Wpadded"
+#endif
+// end catch_suppress_warnings.h
+#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
+#  define CATCH_IMPL
+#  define CATCH_CONFIG_ALL_PARTS
+#endif
+
+// In the impl file, we want to have access to all parts of the headers
+// Can also be used to sanely support PCHs
+#if defined(CATCH_CONFIG_ALL_PARTS)
+#  define CATCH_CONFIG_EXTERNAL_INTERFACES
+#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#    undef CATCH_CONFIG_DISABLE_MATCHERS
+#  endif
+#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  endif
+#endif
+
+#if !defined(CATCH_CONFIG_IMPL_ONLY)
+// start catch_platform.h
+
+#ifdef __APPLE__
+# include <TargetConditionals.h>
+# if TARGET_OS_OSX == 1
+#  define CATCH_PLATFORM_MAC
+# elif TARGET_OS_IPHONE == 1
+#  define CATCH_PLATFORM_IPHONE
+# endif
+
+#elif defined(linux) || defined(__linux) || defined(__linux__)
+#  define CATCH_PLATFORM_LINUX
+
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
+#  define CATCH_PLATFORM_WINDOWS
+#endif
+
+// end catch_platform.h
+
+#ifdef CATCH_IMPL
+#  ifndef CLARA_CONFIG_MAIN
+#    define CLARA_CONFIG_MAIN_NOT_DEFINED
+#    define CLARA_CONFIG_MAIN
+#  endif
+#endif
+
+// start catch_user_interfaces.h
+
+namespace Catch {
+    unsigned int rngSeed();
+}
+
+// end catch_user_interfaces.h
+// start catch_tag_alias_autoregistrar.h
+
+// start catch_common.h
+
+// start catch_compiler_capabilities.h
+
+// Detect a number of compiler features - by compiler
+// The following features are defined:
+//
+// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
+// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
+// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
+// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
+// ****************
+// Note to maintainers: if new toggles are added please document them
+// in configuration.md, too
+// ****************
+
+// In general each macro has a _NO_<feature name> form
+// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
+// Many features, at point of detection, define an _INTERNAL_ macro, so they
+// can be combined, en-mass, with the _NO_ forms later.
+
+#ifdef __cplusplus
+
+#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
+#    define CATCH_CPP14_OR_GREATER
+#  endif
+
+#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#    define CATCH_CPP17_OR_GREATER
+#  endif
+
+#endif
+
+#if defined(CATCH_CPP17_OR_GREATER)
+#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+// We have to avoid both ICC and Clang, because they try to mask themselves
+// as gcc, and we want only GCC in this block
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
+
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+#endif
+
+#if defined(__clang__)
+
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
+
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+
+#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
+
+#endif // __clang__
+
+////////////////////////////////////////////////////////////////////////////////
+// Assume that non-Windows platforms support posix signals by default
+#if !defined(CATCH_PLATFORM_WINDOWS)
+    #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// We know some environments not to support full POSIX signals
+#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
+    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#endif
+
+#ifdef __OS400__
+#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#       define CATCH_CONFIG_COLOUR_NONE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Android somehow still does not support std::to_string
+#if defined(__ANDROID__)
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Not all Windows environments support SEH properly
+#if defined(__MINGW32__)
+#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// PS4
+#if defined(__ORBIS__)
+#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Cygwin
+#ifdef __CYGWIN__
+
+// Required for some versions of Cygwin to declare gettimeofday
+// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
+#   define _BSD_SOURCE
+// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
+// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
+# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
+           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+
+# endif
+#endif // __CYGWIN__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#if defined(_MSC_VER)
+
+#  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
+#  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
+
+#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
+#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#  endif
+
+// Universal Windows platform does not support SEH
+// Or console colours (or console at all...)
+#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#    define CATCH_CONFIG_COLOUR_NONE
+#  else
+#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+#  endif
+
+// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
+// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
+// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
+#  if !defined(__clang__) // Handle Clang masquerading for msvc
+#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#    endif // MSVC_TRADITIONAL
+#  endif // __clang__
+
+#endif // _MSC_VER
+
+#if defined(_REENTRANT) || defined(_MSC_VER)
+// Enable async processing, as -pthread is specified or no additional linking is required
+# define CATCH_INTERNAL_CONFIG_USE_ASYNC
+#endif // _MSC_VER
+
+////////////////////////////////////////////////////////////////////////////////
+// Check if we are compiled with -fno-exceptions or equivalent
+#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
+#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// DJGPP
+#ifdef __DJGPP__
+#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
+#endif // __DJGPP__
+
+////////////////////////////////////////////////////////////////////////////////
+// Embarcadero C++Build
+#if defined(__BORLANDC__)
+    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Use of __COUNTER__ is suppressed during code analysis in
+// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
+// handled by it.
+// Otherwise all supported compilers support COUNTER macro,
+// but user still might want to turn it off
+#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
+    #define CATCH_INTERNAL_CONFIG_COUNTER
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// RTX is a special version of Windows that is real time.
+// This means that it is detected as Windows, but does not provide
+// the same set of capabilities as real Windows does.
+#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
+    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
+    #define CATCH_CONFIG_COLOUR_NONE
+#endif
+
+#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
+#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Various stdlib support checks that require __has_include
+#if defined(__has_include)
+  // Check if string_view is available and usable
+  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
+  #endif
+
+  // Check if optional is available and usable
+  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if byte is available and usable
+  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if variant is available and usable
+  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+  #    if defined(__clang__) && (__clang_major__ < 8)
+         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+         // fix should be in clang 8, workaround in libstdc++ 8.2
+  #      include <ciso646>
+  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #        define CATCH_CONFIG_NO_CPP17_VARIANT
+  #      else
+  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #    else
+  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #    endif // defined(__clang__) && (__clang_major__ < 8)
+  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // defined(__has_include)
+
+#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
+#   define CATCH_CONFIG_COUNTER
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
+#   define CATCH_CONFIG_WINDOWS_SEH
+#endif
+// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
+#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#   define CATCH_CONFIG_POSIX_SIGNALS
+#endif
+// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
+#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
+#   define CATCH_CONFIG_WCHAR
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
+#    define CATCH_CONFIG_CPP11_TO_STRING
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#  define CATCH_CONFIG_CPP17_OPTIONAL
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
+#  define CATCH_CONFIG_CPP17_STRING_VIEW
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
+#  define CATCH_CONFIG_CPP17_VARIANT
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
+#  define CATCH_CONFIG_CPP17_BYTE
+#endif
+
+#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
+#  define CATCH_CONFIG_NEW_CAPTURE
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+#  define CATCH_CONFIG_POLYFILL_ISNAN
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+#  define CATCH_CONFIG_USE_ASYNC
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#  define CATCH_CONFIG_ANDROID_LOGWRITE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Even if we do not think the compiler has that warning, we still have
+// to provide a macro that can be used by the code.
+#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
+#endif
+
+// The goal of this macro is to avoid evaluation of the arguments, but
+// still have the compiler warn on problems inside...
+#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
+#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
+#endif
+
+#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#elif defined(__clang__) && (__clang_major__ < 5)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#define CATCH_TRY if ((true))
+#define CATCH_CATCH_ALL if ((false))
+#define CATCH_CATCH_ANON(type) if ((false))
+#else
+#define CATCH_TRY try
+#define CATCH_CATCH_ALL catch (...)
+#define CATCH_CATCH_ANON(type) catch (type)
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
+#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#endif
+
+// end catch_compiler_capabilities.h
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+#ifdef CATCH_CONFIG_COUNTER
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
+#else
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+#endif
+
+#include <iosfwd>
+#include <string>
+#include <cstdint>
+
+// We need a dummy global operator<< so we can bring it into Catch namespace later
+struct Catch_global_namespace_dummy {};
+std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
+
+namespace Catch {
+
+    struct CaseSensitive { enum Choice {
+        Yes,
+        No
+    }; };
+
+    class NonCopyable {
+        NonCopyable( NonCopyable const& )              = delete;
+        NonCopyable( NonCopyable && )                  = delete;
+        NonCopyable& operator = ( NonCopyable const& ) = delete;
+        NonCopyable& operator = ( NonCopyable && )     = delete;
+
+    protected:
+        NonCopyable();
+        virtual ~NonCopyable();
+    };
+
+    struct SourceLineInfo {
+
+        SourceLineInfo() = delete;
+        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
+        :   file( _file ),
+            line( _line )
+        {}
+
+        SourceLineInfo( SourceLineInfo const& other )            = default;
+        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
+        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
+        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
+
+        bool empty() const noexcept { return file[0] == '\0'; }
+        bool operator == ( SourceLineInfo const& other ) const noexcept;
+        bool operator < ( SourceLineInfo const& other ) const noexcept;
+
+        char const* file;
+        std::size_t line;
+    };
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
+
+    // Bring in operator<< from global namespace into Catch namespace
+    // This is necessary because the overload of operator<< above makes
+    // lookup stop at namespace Catch
+    using ::operator<<;
+
+    // Use this in variadic streaming macros to allow
+    //    >> +StreamEndStop
+    // as well as
+    //    >> stuff +StreamEndStop
+    struct StreamEndStop {
+        std::string operator+() const;
+    };
+    template<typename T>
+    T const& operator + ( T const& value, StreamEndStop ) {
+        return value;
+    }
+}
+
+#define CATCH_INTERNAL_LINEINFO \
+    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+
+// end catch_common.h
+namespace Catch {
+
+    struct RegistrarForTagAliases {
+        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+    };
+
+} // end namespace Catch
+
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+// end catch_tag_alias_autoregistrar.h
+// start catch_test_registry.h
+
+// start catch_interfaces_testcase.h
+
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec;
+
+    struct ITestInvoker {
+        virtual void invoke () const = 0;
+        virtual ~ITestInvoker();
+    };
+
+    class TestCase;
+    struct IConfig;
+
+    struct ITestCaseRegistry {
+        virtual ~ITestCaseRegistry();
+        virtual std::vector<TestCase> const& getAllTests() const = 0;
+        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
+    };
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+
+}
+
+// end catch_interfaces_testcase.h
+// start catch_stringref.h
+
+#include <cstddef>
+#include <string>
+#include <iosfwd>
+#include <cassert>
+
+namespace Catch {
+
+    /// A non-owning string class (similar to the forthcoming std::string_view)
+    /// Note that, because a StringRef may be a substring of another string,
+    /// it may not be null terminated.
+    class StringRef {
+    public:
+        using size_type = std::size_t;
+        using const_iterator = const char*;
+
+    private:
+        static constexpr char const* const s_empty = "";
+
+        char const* m_start = s_empty;
+        size_type m_size = 0;
+
+    public: // construction
+        constexpr StringRef() noexcept = default;
+
+        StringRef( char const* rawChars ) noexcept;
+
+        constexpr StringRef( char const* rawChars, size_type size ) noexcept
+        :   m_start( rawChars ),
+            m_size( size )
+        {}
+
+        StringRef( std::string const& stdString ) noexcept
+        :   m_start( stdString.c_str() ),
+            m_size( stdString.size() )
+        {}
+
+        explicit operator std::string() const {
+            return std::string(m_start, m_size);
+        }
+
+    public: // operators
+        auto operator == ( StringRef const& other ) const noexcept -> bool;
+        auto operator != (StringRef const& other) const noexcept -> bool {
+            return !(*this == other);
+        }
+
+        auto operator[] ( size_type index ) const noexcept -> char {
+            assert(index < m_size);
+            return m_start[index];
+        }
+
+    public: // named queries
+        constexpr auto empty() const noexcept -> bool {
+            return m_size == 0;
+        }
+        constexpr auto size() const noexcept -> size_type {
+            return m_size;
+        }
+
+        // Returns the current start pointer. If the StringRef is not
+        // null-terminated, throws std::domain_exception
+        auto c_str() const -> char const*;
+
+    public: // substrings and searches
+        // Returns a substring of [start, start + length).
+        // If start + length > size(), then the substring is [start, size()).
+        // If start > size(), then the substring is empty.
+        auto substr( size_type start, size_type length ) const noexcept -> StringRef;
+
+        // Returns the current start pointer. May not be null-terminated.
+        auto data() const noexcept -> char const*;
+
+        constexpr auto isNullTerminated() const noexcept -> bool {
+            return m_start[m_size] == '\0';
+        }
+
+    public: // iterators
+        constexpr const_iterator begin() const { return m_start; }
+        constexpr const_iterator end() const { return m_start + m_size; }
+    };
+
+    auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
+    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
+
+    constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
+        return StringRef( rawChars, size );
+    }
+} // namespace Catch
+
+constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
+    return Catch::StringRef( rawChars, size );
+}
+
+// end catch_stringref.h
+// start catch_preprocessor.hpp
+
+
+#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
+#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
+
+#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
+// MSVC needs more evaluations
+#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
+#else
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
+#endif
+
+#define CATCH_REC_END(...)
+#define CATCH_REC_OUT
+
+#define CATCH_EMPTY()
+#define CATCH_DEFER(id) id CATCH_EMPTY()
+
+#define CATCH_REC_GET_END2() 0, CATCH_REC_END
+#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
+#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
+#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
+#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
+#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
+
+#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+
+#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+
+// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
+// and passes userdata as the first parameter to each invocation,
+// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
+#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
+#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
+#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
+#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
+#else
+// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
+#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
+#endif
+
+#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
+#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
+
+#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#else
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#endif
+
+#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
+    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
+
+#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
+#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
+#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
+#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
+#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
+#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
+#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6)
+#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
+#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
+#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
+#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
+
+#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
+
+#define INTERNAL_CATCH_TYPE_GEN\
+    template<typename...> struct TypeList {};\
+    template<typename...Ts>\
+    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
+    template<template<typename...> class...> struct TemplateTypeList{};\
+    template<template<typename...> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
+    template<typename...>\
+    struct append;\
+    template<typename...>\
+    struct rewrap;\
+    template<template<typename...> class, typename...>\
+    struct create;\
+    template<template<typename...> class, typename>\
+    struct convert;\
+    \
+    template<typename T> \
+    struct append<T> { using type = T; };\
+    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
+    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
+    template< template<typename...> class L1, typename...E1, typename...Rest>\
+    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
+    \
+    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
+    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
+    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
+    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
+    \
+    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
+    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
+    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
+    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
+
+#define INTERNAL_CATCH_NTTP_1(signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
+    \
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
+    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
+    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
+    template<typename TestType> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
+    template<typename TestType> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_NTTP_0
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
+#else
+#define INTERNAL_CATCH_NTTP_0(signature)
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
+#endif
+
+// end catch_preprocessor.hpp
+// start catch_meta.hpp
+
+
+#include <type_traits>
+
+namespace Catch {
+    template<typename T>
+    struct always_false : std::false_type {};
+
+    template <typename> struct true_given : std::true_type {};
+    struct is_callable_tester {
+        template <typename Fun, typename... Args>
+        true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
+        template <typename...>
+        std::false_type static test(...);
+    };
+
+    template <typename T>
+    struct is_callable;
+
+    template <typename Fun, typename... Args>
+    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
+
+#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
+    // replaced with std::invoke_result here. Also *_t format is preferred over
+    // typename *::type format.
+    template <typename Func, typename U>
+    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
+#else
+    template <typename Func, typename U>
+    using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
+#endif
+
+} // namespace Catch
+
+namespace mpl_{
+    struct na;
+}
+
+// end catch_meta.hpp
+namespace Catch {
+
+template<typename C>
+class TestInvokerAsMethod : public ITestInvoker {
+    void (C::*m_testAsMethod)();
+public:
+    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
+
+    void invoke() const override {
+        C obj;
+        (obj.*m_testAsMethod)();
+    }
+};
+
+auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
+
+template<typename C>
+auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
+    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
+}
+
+struct NameAndTags {
+    NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
+    StringRef name;
+    StringRef tags;
+};
+
+struct AutoReg : NonCopyable {
+    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
+    ~AutoReg();
+};
+
+} // end namespace Catch
+
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
+        namespace{                        \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+                void test();              \
+            };                            \
+        }                                 \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
+        namespace{                                                                                  \
+            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        }                                                                                           \
+        }                                                                                           \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+#endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
+        static void TestName(); \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE( ... ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+        } \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
+        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestName{\
+                TestName(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+            return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS              \
+        template<typename TestType> static void TestFuncName();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
+            INTERNAL_CATCH_TYPE_GEN                                                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
+            template<typename... Types>                               \
+            struct TestName {                                         \
+                void reg_tests() {                                          \
+                    int index = 0;                                    \
+                    using expander = int[];                           \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */\
+                }                                                     \
+            };                                                        \
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }                                                             \
+        }                                                             \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFuncName()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> static void TestFunc();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+        INTERNAL_CATCH_TYPE_GEN\
+        template<typename... Types>                               \
+        struct TestName {                                         \
+            void reg_tests() {                                          \
+                int index = 0;                                    \
+                using expander = int[];                           \
+                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */\
+            }                                                     \
+        };\
+        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename convert<TestName, TmplList>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFunc()
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
+
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestNameClass{\
+                TestNameClass(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+                return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+                void test();\
+            };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
+            INTERNAL_CATCH_TYPE_GEN                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> \
+        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+            void test();\
+        };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename convert<TestNameClass, TmplList>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
+
+// end catch_test_registry.h
+// start catch_capture.hpp
+
+// start catch_assertionhandler.h
+
+// start catch_assertioninfo.h
+
+// start catch_result_type.h
+
+namespace Catch {
+
+    // ResultWas::OfType enum
+    struct ResultWas { enum OfType {
+        Unknown = -1,
+        Ok = 0,
+        Info = 1,
+        Warning = 2,
+
+        FailureBit = 0x10,
+
+        ExpressionFailed = FailureBit | 1,
+        ExplicitFailure = FailureBit | 2,
+
+        Exception = 0x100 | FailureBit,
+
+        ThrewException = Exception | 1,
+        DidntThrowException = Exception | 2,
+
+        FatalErrorCondition = 0x200 | FailureBit
+
+    }; };
+
+    bool isOk( ResultWas::OfType resultType );
+    bool isJustInfo( int flags );
+
+    // ResultDisposition::Flags enum
+    struct ResultDisposition { enum Flags {
+        Normal = 0x01,
+
+        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
+        FalseTest = 0x04,           // Prefix expression with !
+        SuppressFail = 0x08         // Failures are reported but do not fail the test
+    }; };
+
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
+
+    bool shouldContinueOnFailure( int flags );
+    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
+    bool shouldSuppressFailure( int flags );
+
+} // end namespace Catch
+
+// end catch_result_type.h
+namespace Catch {
+
+    struct AssertionInfo
+    {
+        StringRef macroName;
+        SourceLineInfo lineInfo;
+        StringRef capturedExpression;
+        ResultDisposition::Flags resultDisposition;
+
+        // We want to delete this constructor but a compiler bug in 4.8 means
+        // the struct is then treated as non-aggregate
+        //AssertionInfo() = delete;
+    };
+
+} // end namespace Catch
+
+// end catch_assertioninfo.h
+// start catch_decomposer.h
+
+// start catch_tostring.h
+
+#include <vector>
+#include <cstddef>
+#include <type_traits>
+#include <string>
+// start catch_stream.h
+
+#include <iosfwd>
+#include <cstddef>
+#include <ostream>
+
+namespace Catch {
+
+    std::ostream& cout();
+    std::ostream& cerr();
+    std::ostream& clog();
+
+    class StringRef;
+
+    struct IStream {
+        virtual ~IStream();
+        virtual std::ostream& stream() const = 0;
+    };
+
+    auto makeStream( StringRef const &filename ) -> IStream const*;
+
+    class ReusableStringStream : NonCopyable {
+        std::size_t m_index;
+        std::ostream* m_oss;
+    public:
+        ReusableStringStream();
+        ~ReusableStringStream();
+
+        auto str() const -> std::string;
+
+        template<typename T>
+        auto operator << ( T const& value ) -> ReusableStringStream& {
+            *m_oss << value;
+            return *this;
+        }
+        auto get() -> std::ostream& { return *m_oss; }
+    };
+}
+
+// end catch_stream.h
+// start catch_interfaces_enum_values_registry.h
+
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+        struct EnumInfo {
+            StringRef m_name;
+            std::vector<std::pair<int, StringRef>> m_values;
+
+            ~EnumInfo();
+
+            StringRef lookup( int value ) const;
+        };
+    } // namespace Detail
+
+    struct IMutableEnumValuesRegistry {
+        virtual ~IMutableEnumValuesRegistry();
+
+        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+
+        template<typename E>
+        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
+            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
+            std::vector<int> intValues;
+            intValues.reserve( values.size() );
+            for( auto enumValue : values )
+                intValues.push_back( static_cast<int>( enumValue ) );
+            return registerEnum( enumName, allEnums, intValues );
+        }
+    };
+
+} // Catch
+
+// end catch_interfaces_enum_values_registry.h
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+#include <string_view>
+#endif
+
+#ifdef __OBJC__
+// start catch_objc_arc.hpp
+
+#import <Foundation/Foundation.h>
+
+#ifdef __has_feature
+#define CATCH_ARC_ENABLED __has_feature(objc_arc)
+#else
+#define CATCH_ARC_ENABLED 0
+#endif
+
+void arcSafeRelease( NSObject* obj );
+id performOptionalSelector( id obj, SEL sel );
+
+#if !CATCH_ARC_ENABLED
+inline void arcSafeRelease( NSObject* obj ) {
+    [obj release];
+}
+inline id performOptionalSelector( id obj, SEL sel ) {
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED
+#define CATCH_ARC_STRONG
+#else
+inline void arcSafeRelease( NSObject* ){}
+inline id performOptionalSelector( id obj, SEL sel ) {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+#endif
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
+#define CATCH_ARC_STRONG __strong
+#endif
+
+// end catch_objc_arc.hpp
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
+#endif
+
+namespace Catch {
+    namespace Detail {
+
+        extern const std::string unprintableString;
+
+        std::string rawMemoryToString( const void *object, std::size_t size );
+
+        template<typename T>
+        std::string rawMemoryToString( const T& object ) {
+          return rawMemoryToString( &object, sizeof(object) );
+        }
+
+        template<typename T>
+        class IsStreamInsertable {
+            template<typename Stream, typename U>
+            static auto test(int)
+                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
+
+            template<typename, typename>
+            static auto test(...)->std::false_type;
+
+        public:
+            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
+        };
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e );
+
+        template<typename T>
+        typename std::enable_if<
+            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
+        std::string>::type convertUnstreamable( T const& ) {
+            return Detail::unprintableString;
+        }
+        template<typename T>
+        typename std::enable_if<
+            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
+         std::string>::type convertUnstreamable(T const& ex) {
+            return ex.what();
+        }
+
+        template<typename T>
+        typename std::enable_if<
+            std::is_enum<T>::value
+        , std::string>::type convertUnstreamable( T const& value ) {
+            return convertUnknownEnumToString( value );
+        }
+
+#if defined(_MANAGED)
+        //! Convert a CLR string to a utf8 std::string
+        template<typename T>
+        std::string clrReferenceToString( T^ ref ) {
+            if (ref == nullptr)
+                return std::string("null");
+            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
+            cli::pin_ptr<System::Byte> p = &bytes[0];
+            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
+        }
+#endif
+
+    } // namespace Detail
+
+    // If we decide for C++14, change these to enable_if_ts
+    template <typename T, typename = void>
+    struct StringMaker {
+        template <typename Fake = T>
+        static
+        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+            convert(const Fake& value) {
+                ReusableStringStream rss;
+                // NB: call using the function-like syntax to avoid ambiguity with
+                // user-defined templated operator<< under clang.
+                rss.operator<<(value);
+                return rss.str();
+        }
+
+        template <typename Fake = T>
+        static
+        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+            convert( const Fake& value ) {
+#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
+            return Detail::convertUnstreamable(value);
+#else
+            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
+#endif
+        }
+    };
+
+    namespace Detail {
+
+        // This function dispatches all stringification requests inside of Catch.
+        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
+        template <typename T>
+        std::string stringify(const T& e) {
+            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
+        }
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e ) {
+            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
+        }
+
+#if defined(_MANAGED)
+        template <typename T>
+        std::string stringify( T^ e ) {
+            return ::Catch::StringMaker<T^>::convert(e);
+        }
+#endif
+
+    } // namespace Detail
+
+    // Some predefined specializations
+
+    template<>
+    struct StringMaker<std::string> {
+        static std::string convert(const std::string& str);
+    };
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::string_view> {
+        static std::string convert(std::string_view str);
+    };
+#endif
+
+    template<>
+    struct StringMaker<char const *> {
+        static std::string convert(char const * str);
+    };
+    template<>
+    struct StringMaker<char *> {
+        static std::string convert(char * str);
+    };
+
+#ifdef CATCH_CONFIG_WCHAR
+    template<>
+    struct StringMaker<std::wstring> {
+        static std::string convert(const std::wstring& wstr);
+    };
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::wstring_view> {
+        static std::string convert(std::wstring_view str);
+    };
+# endif
+
+    template<>
+    struct StringMaker<wchar_t const *> {
+        static std::string convert(wchar_t const * str);
+    };
+    template<>
+    struct StringMaker<wchar_t *> {
+        static std::string convert(wchar_t * str);
+    };
+#endif
+
+    // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
+    //      while keeping string semantics?
+    template<int SZ>
+    struct StringMaker<char[SZ]> {
+        static std::string convert(char const* str) {
+            return ::Catch::Detail::stringify(std::string{ str });
+        }
+    };
+    template<int SZ>
+    struct StringMaker<signed char[SZ]> {
+        static std::string convert(signed char const* str) {
+            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
+        }
+    };
+    template<int SZ>
+    struct StringMaker<unsigned char[SZ]> {
+        static std::string convert(unsigned char const* str) {
+            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
+        }
+    };
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<std::byte> {
+        static std::string convert(std::byte value);
+    };
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<int> {
+        static std::string convert(int value);
+    };
+    template<>
+    struct StringMaker<long> {
+        static std::string convert(long value);
+    };
+    template<>
+    struct StringMaker<long long> {
+        static std::string convert(long long value);
+    };
+    template<>
+    struct StringMaker<unsigned int> {
+        static std::string convert(unsigned int value);
+    };
+    template<>
+    struct StringMaker<unsigned long> {
+        static std::string convert(unsigned long value);
+    };
+    template<>
+    struct StringMaker<unsigned long long> {
+        static std::string convert(unsigned long long value);
+    };
+
+    template<>
+    struct StringMaker<bool> {
+        static std::string convert(bool b);
+    };
+
+    template<>
+    struct StringMaker<char> {
+        static std::string convert(char c);
+    };
+    template<>
+    struct StringMaker<signed char> {
+        static std::string convert(signed char c);
+    };
+    template<>
+    struct StringMaker<unsigned char> {
+        static std::string convert(unsigned char c);
+    };
+
+    template<>
+    struct StringMaker<std::nullptr_t> {
+        static std::string convert(std::nullptr_t);
+    };
+
+    template<>
+    struct StringMaker<float> {
+        static std::string convert(float value);
+        static int precision;
+    };
+
+    template<>
+    struct StringMaker<double> {
+        static std::string convert(double value);
+        static int precision;
+    };
+
+    template <typename T>
+    struct StringMaker<T*> {
+        template <typename U>
+        static std::string convert(U* p) {
+            if (p) {
+                return ::Catch::Detail::rawMemoryToString(p);
+            } else {
+                return "nullptr";
+            }
+        }
+    };
+
+    template <typename R, typename C>
+    struct StringMaker<R C::*> {
+        static std::string convert(R C::* p) {
+            if (p) {
+                return ::Catch::Detail::rawMemoryToString(p);
+            } else {
+                return "nullptr";
+            }
+        }
+    };
+
+#if defined(_MANAGED)
+    template <typename T>
+    struct StringMaker<T^> {
+        static std::string convert( T^ ref ) {
+            return ::Catch::Detail::clrReferenceToString(ref);
+        }
+    };
+#endif
+
+    namespace Detail {
+        template<typename InputIterator>
+        std::string rangeToString(InputIterator first, InputIterator last) {
+            ReusableStringStream rss;
+            rss << "{ ";
+            if (first != last) {
+                rss << ::Catch::Detail::stringify(*first);
+                for (++first; first != last; ++first)
+                    rss << ", " << ::Catch::Detail::stringify(*first);
+            }
+            rss << " }";
+            return rss.str();
+        }
+    }
+
+#ifdef __OBJC__
+    template<>
+    struct StringMaker<NSString*> {
+        static std::string convert(NSString * nsstring) {
+            if (!nsstring)
+                return "nil";
+            return std::string("@") + [nsstring UTF8String];
+        }
+    };
+    template<>
+    struct StringMaker<NSObject*> {
+        static std::string convert(NSObject* nsObject) {
+            return ::Catch::Detail::stringify([nsObject description]);
+        }
+
+    };
+    namespace Detail {
+        inline std::string stringify( NSString* nsstring ) {
+            return StringMaker<NSString*>::convert( nsstring );
+        }
+
+    } // namespace Detail
+#endif // __OBJC__
+
+} // namespace Catch
+
+//////////////////////////////////////////////////////
+// Separate std-lib types stringification, so it can be selectively enabled
+// This means that we do not bring in
+
+#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
+#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+#endif
+
+// Separate std::pair specialization
+#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
+#include <utility>
+namespace Catch {
+    template<typename T1, typename T2>
+    struct StringMaker<std::pair<T1, T2> > {
+        static std::string convert(const std::pair<T1, T2>& pair) {
+            ReusableStringStream rss;
+            rss << "{ "
+                << ::Catch::Detail::stringify(pair.first)
+                << ", "
+                << ::Catch::Detail::stringify(pair.second)
+                << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#include <optional>
+namespace Catch {
+    template<typename T>
+    struct StringMaker<std::optional<T> > {
+        static std::string convert(const std::optional<T>& optional) {
+            ReusableStringStream rss;
+            if (optional.has_value()) {
+                rss << ::Catch::Detail::stringify(*optional);
+            } else {
+                rss << "{ }";
+            }
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+
+// Separate std::tuple specialization
+#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
+#include <tuple>
+namespace Catch {
+    namespace Detail {
+        template<
+            typename Tuple,
+            std::size_t N = 0,
+            bool = (N < std::tuple_size<Tuple>::value)
+            >
+            struct TupleElementPrinter {
+            static void print(const Tuple& tuple, std::ostream& os) {
+                os << (N ? ", " : " ")
+                    << ::Catch::Detail::stringify(std::get<N>(tuple));
+                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
+            }
+        };
+
+        template<
+            typename Tuple,
+            std::size_t N
+        >
+            struct TupleElementPrinter<Tuple, N, false> {
+            static void print(const Tuple&, std::ostream&) {}
+        };
+
+    }
+
+    template<typename ...Types>
+    struct StringMaker<std::tuple<Types...>> {
+        static std::string convert(const std::tuple<Types...>& tuple) {
+            ReusableStringStream rss;
+            rss << '{';
+            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
+            rss << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
+#include <variant>
+namespace Catch {
+    template<>
+    struct StringMaker<std::monostate> {
+        static std::string convert(const std::monostate&) {
+            return "{ }";
+        }
+    };
+
+    template<typename... Elements>
+    struct StringMaker<std::variant<Elements...>> {
+        static std::string convert(const std::variant<Elements...>& variant) {
+            if (variant.valueless_by_exception()) {
+                return "{valueless variant}";
+            } else {
+                return std::visit(
+                    [](const auto& value) {
+                        return ::Catch::Detail::stringify(value);
+                    },
+                    variant
+                );
+            }
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+
+namespace Catch {
+    struct not_this_one {}; // Tag type for detecting which begin/ end are being selected
+
+    // Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
+    using std::begin;
+    using std::end;
+
+    not_this_one begin( ... );
+    not_this_one end( ... );
+
+    template <typename T>
+    struct is_range {
+        static const bool value =
+            !std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
+            !std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
+    };
+
+#if defined(_MANAGED) // Managed types are never ranges
+    template <typename T>
+    struct is_range<T^> {
+        static const bool value = false;
+    };
+#endif
+
+    template<typename Range>
+    std::string rangeToString( Range const& range ) {
+        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
+    }
+
+    // Handle vector<bool> specially
+    template<typename Allocator>
+    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
+        ReusableStringStream rss;
+        rss << "{ ";
+        bool first = true;
+        for( bool b : v ) {
+            if( first )
+                first = false;
+            else
+                rss << ", ";
+            rss << ::Catch::Detail::stringify( b );
+        }
+        rss << " }";
+        return rss.str();
+    }
+
+    template<typename R>
+    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
+        static std::string convert( R const& range ) {
+            return rangeToString( range );
+        }
+    };
+
+    template <typename T, int SZ>
+    struct StringMaker<T[SZ]> {
+        static std::string convert(T const(&arr)[SZ]) {
+            return rangeToString(arr);
+        }
+    };
+
+} // namespace Catch
+
+// Separate std::chrono::duration specialization
+#if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#include <ctime>
+#include <ratio>
+#include <chrono>
+
+namespace Catch {
+
+template <class Ratio>
+struct ratio_string {
+    static std::string symbol();
+};
+
+template <class Ratio>
+std::string ratio_string<Ratio>::symbol() {
+    Catch::ReusableStringStream rss;
+    rss << '[' << Ratio::num << '/'
+        << Ratio::den << ']';
+    return rss.str();
+}
+template <>
+struct ratio_string<std::atto> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::femto> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::pico> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::nano> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::micro> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::milli> {
+    static std::string symbol();
+};
+
+    ////////////
+    // std::chrono::duration specializations
+    template<typename Value, typename Ratio>
+    struct StringMaker<std::chrono::duration<Value, Ratio>> {
+        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " s";
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " m";
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " h";
+            return rss.str();
+        }
+    };
+
+    ////////////
+    // std::chrono::time_point specialization
+    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
+    template<typename Clock, typename Duration>
+    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
+        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
+            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
+        }
+    };
+    // std::chrono::time_point<system_clock> specialization
+    template<typename Duration>
+    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
+        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
+            auto converted = std::chrono::system_clock::to_time_t(time_point);
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &converted);
+#else
+            std::tm* timeInfo = std::gmtime(&converted);
+#endif
+
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp);
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+
+#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
+namespace Catch { \
+    template<> struct StringMaker<enumName> { \
+        static std::string convert( enumName value ) { \
+            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
+            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
+        } \
+    }; \
+}
+
+#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// end catch_tostring.h
+#include <iosfwd>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#pragma warning(disable:4018) // more "signed/unsigned mismatch"
+#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
+#pragma warning(disable:4180) // qualifier applied to function type has no meaning
+#pragma warning(disable:4800) // Forcing result to true or false
+#endif
+
+namespace Catch {
+
+    struct ITransientExpression {
+        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
+        auto getResult() const -> bool { return m_result; }
+        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
+
+        ITransientExpression( bool isBinaryExpression, bool result )
+        :   m_isBinaryExpression( isBinaryExpression ),
+            m_result( result )
+        {}
+
+        // We don't actually need a virtual destructor, but many static analysers
+        // complain if it's not here :-(
+        virtual ~ITransientExpression();
+
+        bool m_isBinaryExpression;
+        bool m_result;
+
+    };
+
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
+
+    template<typename LhsT, typename RhsT>
+    class BinaryExpr  : public ITransientExpression {
+        LhsT m_lhs;
+        StringRef m_op;
+        RhsT m_rhs;
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            formatReconstructedExpression
+                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
+        }
+
+    public:
+        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
+        :   ITransientExpression{ true, comparisonResult },
+            m_lhs( lhs ),
+            m_op( op ),
+            m_rhs( rhs )
+        {}
+
+        template<typename T>
+        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+    };
+
+    template<typename LhsT>
+    class UnaryExpr : public ITransientExpression {
+        LhsT m_lhs;
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            os << Catch::Detail::stringify( m_lhs );
+        }
+
+    public:
+        explicit UnaryExpr( LhsT lhs )
+        :   ITransientExpression{ false, static_cast<bool>(lhs) },
+            m_lhs( lhs )
+        {}
+    };
+
+    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
+    template<typename LhsT, typename RhsT>
+    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
+    template<typename T>
+    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
+    template<typename T>
+    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
+
+    template<typename LhsT, typename RhsT>
+    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
+    template<typename T>
+    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
+    template<typename T>
+    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
+
+    template<typename LhsT>
+    class ExprLhs {
+        LhsT m_lhs;
+    public:
+        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
+
+        template<typename RhsT>
+        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
+        }
+        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
+            return { m_lhs == rhs, m_lhs, "==", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
+        }
+        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
+            return { m_lhs != rhs, m_lhs, "!=", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
+        }
+        template<typename RhsT>
+        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
+        }
+        template<typename RhsT>
+        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
+        }
+        template<typename RhsT>
+        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator&& is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename RhsT>
+        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator|| is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
+            return UnaryExpr<LhsT>{ m_lhs };
+        }
+    };
+
+    void handleExpression( ITransientExpression const& expr );
+
+    template<typename T>
+    void handleExpression( ExprLhs<T> const& expr ) {
+        handleExpression( expr.makeUnaryExpr() );
+    }
+
+    struct Decomposer {
+        template<typename T>
+        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
+            return ExprLhs<T const&>{ lhs };
+        }
+
+        auto operator <=( bool value ) -> ExprLhs<bool> {
+            return ExprLhs<bool>{ value };
+        }
+    };
+
+} // end namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// end catch_decomposer.h
+// start catch_interfaces_capture.h
+
+#include <string>
+#include <chrono>
+
+namespace Catch {
+
+    class AssertionResult;
+    struct AssertionInfo;
+    struct SectionInfo;
+    struct SectionEndInfo;
+    struct MessageInfo;
+    struct MessageBuilder;
+    struct Counts;
+    struct AssertionReaction;
+    struct SourceLineInfo;
+
+    struct ITransientExpression;
+    struct IGeneratorTracker;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo;
+    template <typename Duration = std::chrono::duration<double, std::nano>>
+    struct BenchmarkStats;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    struct IResultCapture {
+
+        virtual ~IResultCapture();
+
+        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
+                                        Counts& assertions ) = 0;
+        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
+        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
+
+        virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& name ) = 0;
+        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
+        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
+        virtual void benchmarkFailed( std::string const& error ) = 0;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
+
+        virtual void handleFatalErrorCondition( StringRef message ) = 0;
+
+        virtual void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    StringRef const& message,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleUnexpectedExceptionNotThrown
+                (   AssertionInfo const& info,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleUnexpectedInflightException
+                (   AssertionInfo const& info,
+                    std::string const& message,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleIncomplete
+                (   AssertionInfo const& info ) = 0;
+        virtual void handleNonExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    AssertionReaction &reaction ) = 0;
+
+        virtual bool lastAssertionPassed() = 0;
+        virtual void assertionPassed() = 0;
+
+        // Deprecated, do not use:
+        virtual std::string getCurrentTestName() const = 0;
+        virtual const AssertionResult* getLastResult() const = 0;
+        virtual void exceptionEarlyReported() = 0;
+    };
+
+    IResultCapture& getResultCapture();
+}
+
+// end catch_interfaces_capture.h
+namespace Catch {
+
+    struct TestFailureException{};
+    struct AssertionResultData;
+    struct IResultCapture;
+    class RunContext;
+
+    class LazyExpression {
+        friend class AssertionHandler;
+        friend struct AssertionStats;
+        friend class RunContext;
+
+        ITransientExpression const* m_transientExpression = nullptr;
+        bool m_isNegated;
+    public:
+        LazyExpression( bool isNegated );
+        LazyExpression( LazyExpression const& other );
+        LazyExpression& operator = ( LazyExpression const& ) = delete;
+
+        explicit operator bool() const;
+
+        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
+    };
+
+    struct AssertionReaction {
+        bool shouldDebugBreak = false;
+        bool shouldThrow = false;
+    };
+
+    class AssertionHandler {
+        AssertionInfo m_assertionInfo;
+        AssertionReaction m_reaction;
+        bool m_completed = false;
+        IResultCapture& m_resultCapture;
+
+    public:
+        AssertionHandler
+            (   StringRef const& macroName,
+                SourceLineInfo const& lineInfo,
+                StringRef capturedExpression,
+                ResultDisposition::Flags resultDisposition );
+        ~AssertionHandler() {
+            if ( !m_completed ) {
+                m_resultCapture.handleIncomplete( m_assertionInfo );
+            }
+        }
+
+        template<typename T>
+        void handleExpr( ExprLhs<T> const& expr ) {
+            handleExpr( expr.makeUnaryExpr() );
+        }
+        void handleExpr( ITransientExpression const& expr );
+
+        void handleMessage(ResultWas::OfType resultType, StringRef const& message);
+
+        void handleExceptionThrownAsExpected();
+        void handleUnexpectedExceptionNotThrown();
+        void handleExceptionNotThrownAsExpected();
+        void handleThrowingCallSkipped();
+        void handleUnexpectedInflightException();
+
+        void complete();
+        void setCompleted();
+
+        // query
+        auto allowThrows() const -> bool;
+    };
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
+
+} // namespace Catch
+
+// end catch_assertionhandler.h
+// start catch_message.h
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    struct MessageInfo {
+        MessageInfo(    StringRef const& _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        ResultWas::OfType _type );
+
+        StringRef macroName;
+        std::string message;
+        SourceLineInfo lineInfo;
+        ResultWas::OfType type;
+        unsigned int sequence;
+
+        bool operator == ( MessageInfo const& other ) const;
+        bool operator < ( MessageInfo const& other ) const;
+    private:
+        static unsigned int globalCount;
+    };
+
+    struct MessageStream {
+
+        template<typename T>
+        MessageStream& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        ReusableStringStream m_stream;
+    };
+
+    struct MessageBuilder : MessageStream {
+        MessageBuilder( StringRef const& macroName,
+                        SourceLineInfo const& lineInfo,
+                        ResultWas::OfType type );
+
+        template<typename T>
+        MessageBuilder& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        MessageInfo m_info;
+    };
+
+    class ScopedMessage {
+    public:
+        explicit ScopedMessage( MessageBuilder const& builder );
+        ScopedMessage( ScopedMessage& duplicate ) = delete;
+        ScopedMessage( ScopedMessage&& old );
+        ~ScopedMessage();
+
+        MessageInfo m_info;
+        bool m_moved;
+    };
+
+    class Capturer {
+        std::vector<MessageInfo> m_messages;
+        IResultCapture& m_resultCapture = getResultCapture();
+        size_t m_captured = 0;
+    public:
+        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
+        ~Capturer();
+
+        void captureValue( size_t index, std::string const& value );
+
+        template<typename T>
+        void captureValues( size_t index, T const& value ) {
+            captureValue( index, Catch::Detail::stringify( value ) );
+        }
+
+        template<typename T, typename... Ts>
+        void captureValues( size_t index, T const& value, Ts const&... values ) {
+            captureValue( index, Catch::Detail::stringify(value) );
+            captureValues( index+1, values... );
+        }
+    };
+
+} // end namespace Catch
+
+// end catch_message.h
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
+  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
+#else
+  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+#endif
+
+#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+
+///////////////////////////////////////////////////////////////////////////////
+// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
+// macros.
+#define INTERNAL_CATCH_TRY
+#define INTERNAL_CATCH_CATCH( capturer )
+
+#else // CATCH_CONFIG_FAST_COMPILE
+
+#define INTERNAL_CATCH_TRY try
+#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
+
+#endif
+
+#define INTERNAL_CATCH_REACT( handler ) handler.complete();
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
+    do { \
+        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+    if( Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+    if( !Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        try { \
+            static_cast<void>(__VA_ARGS__); \
+            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
+        } \
+        catch( ... ) { \
+            catchAssertionHandler.handleUnexpectedInflightException(); \
+        } \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(expr); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
+        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
+    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
+    varName.captureValues( 0, __VA_ARGS__ )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_INFO( macroName, log ) \
+    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
+    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+
+///////////////////////////////////////////////////////////////////////////////
+// Although this is matcher-based, it can be used with just a string
+#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+#endif // CATCH_CONFIG_DISABLE
+
+// end catch_capture.hpp
+// start catch_section.h
+
+// start catch_section_info.h
+
+// start catch_totals.h
+
+#include <cstddef>
+
+namespace Catch {
+
+    struct Counts {
+        Counts operator - ( Counts const& other ) const;
+        Counts& operator += ( Counts const& other );
+
+        std::size_t total() const;
+        bool allPassed() const;
+        bool allOk() const;
+
+        std::size_t passed = 0;
+        std::size_t failed = 0;
+        std::size_t failedButOk = 0;
+    };
+
+    struct Totals {
+
+        Totals operator - ( Totals const& other ) const;
+        Totals& operator += ( Totals const& other );
+
+        Totals delta( Totals const& prevTotals ) const;
+
+        int error = 0;
+        Counts assertions;
+        Counts testCases;
+    };
+}
+
+// end catch_totals.h
+#include <string>
+
+namespace Catch {
+
+    struct SectionInfo {
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name );
+
+        // Deprecated
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name,
+                std::string const& ) : SectionInfo( _lineInfo, _name ) {}
+
+        std::string name;
+        std::string description; // !Deprecated: this will always be empty
+        SourceLineInfo lineInfo;
+    };
+
+    struct SectionEndInfo {
+        SectionInfo sectionInfo;
+        Counts prevAssertions;
+        double durationInSeconds;
+    };
+
+} // end namespace Catch
+
+// end catch_section_info.h
+// start catch_timer.h
+
+#include <cstdint>
+
+namespace Catch {
+
+    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
+    auto getEstimatedClockResolution() -> uint64_t;
+
+    class Timer {
+        uint64_t m_nanoseconds = 0;
+    public:
+        void start();
+        auto getElapsedNanoseconds() const -> uint64_t;
+        auto getElapsedMicroseconds() const -> uint64_t;
+        auto getElapsedMilliseconds() const -> unsigned int;
+        auto getElapsedSeconds() const -> double;
+    };
+
+} // namespace Catch
+
+// end catch_timer.h
+#include <string>
+
+namespace Catch {
+
+    class Section : NonCopyable {
+    public:
+        Section( SectionInfo const& info );
+        ~Section();
+
+        // This indicates whether the section should be executed or not
+        explicit operator bool() const;
+
+    private:
+        SectionInfo m_info;
+
+        std::string m_name;
+        Counts m_assertions;
+        bool m_sectionIncluded;
+        Timer m_timer;
+    };
+
+} // end namespace Catch
+
+#define INTERNAL_CATCH_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+// end catch_section.h
+// start catch_interfaces_exception.h
+
+// start catch_interfaces_registry_hub.h
+
+#include <string>
+#include <memory>
+
+namespace Catch {
+
+    class TestCase;
+    struct ITestCaseRegistry;
+    struct IExceptionTranslatorRegistry;
+    struct IExceptionTranslator;
+    struct IReporterRegistry;
+    struct IReporterFactory;
+    struct ITagAliasRegistry;
+    struct IMutableEnumValuesRegistry;
+
+    class StartupExceptionRegistry;
+
+    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+    struct IRegistryHub {
+        virtual ~IRegistryHub();
+
+        virtual IReporterRegistry const& getReporterRegistry() const = 0;
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
+
+        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
+    };
+
+    struct IMutableRegistryHub {
+        virtual ~IMutableRegistryHub();
+        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
+        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
+        virtual void registerTest( TestCase const& testInfo ) = 0;
+        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
+        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
+        virtual void registerStartupException() noexcept = 0;
+        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
+    };
+
+    IRegistryHub const& getRegistryHub();
+    IMutableRegistryHub& getMutableRegistryHub();
+    void cleanUp();
+    std::string translateActiveException();
+
+}
+
+// end catch_interfaces_registry_hub.h
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
+        static std::string translatorName( signature )
+#endif
+
+#include <exception>
+#include <string>
+#include <vector>
+
+namespace Catch {
+    using exceptionTranslateFunction = std::string(*)();
+
+    struct IExceptionTranslator;
+    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
+
+    struct IExceptionTranslator {
+        virtual ~IExceptionTranslator();
+        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
+    };
+
+    struct IExceptionTranslatorRegistry {
+        virtual ~IExceptionTranslatorRegistry();
+
+        virtual std::string translateActiveException() const = 0;
+    };
+
+    class ExceptionTranslatorRegistrar {
+        template<typename T>
+        class ExceptionTranslator : public IExceptionTranslator {
+        public:
+
+            ExceptionTranslator( std::string(*translateFunction)( T& ) )
+            : m_translateFunction( translateFunction )
+            {}
+
+            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
+                try {
+                    if( it == itEnd )
+                        std::rethrow_exception(std::current_exception());
+                    else
+                        return (*it)->translate( it+1, itEnd );
+                }
+                catch( T& ex ) {
+                    return m_translateFunction( ex );
+                }
+            }
+
+        protected:
+            std::string(*m_translateFunction)( T& );
+        };
+
+    public:
+        template<typename T>
+        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
+            getMutableRegistryHub().registerTranslator
+                ( new ExceptionTranslator<T>( translateFunction ) );
+        }
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
+    static std::string translatorName( signature ); \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+    static std::string translatorName( signature )
+
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+// end catch_interfaces_exception.h
+// start catch_approx.h
+
+#include <type_traits>
+
+namespace Catch {
+namespace Detail {
+
+    class Approx {
+    private:
+        bool equalityComparisonImpl(double other) const;
+        // Validates the new margin (margin >= 0)
+        // out-of-line to avoid including stdexcept in the header
+        void setMargin(double margin);
+        // Validates the new epsilon (0 < epsilon < 1)
+        // out-of-line to avoid including stdexcept in the header
+        void setEpsilon(double epsilon);
+
+    public:
+        explicit Approx ( double value );
+
+        static Approx custom();
+
+        Approx operator-() const;
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx operator()( T const& value ) {
+            Approx approx( static_cast<double>(value) );
+            approx.m_epsilon = m_epsilon;
+            approx.m_margin = m_margin;
+            approx.m_scale = m_scale;
+            return approx;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        explicit Approx( T const& value ): Approx(static_cast<double>(value))
+        {}
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( const T& lhs, Approx const& rhs ) {
+            auto lhs_v = static_cast<double>(lhs);
+            return rhs.equalityComparisonImpl(lhs_v);
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( Approx const& lhs, const T& rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( T const& lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( Approx const& lhs, T const& rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& epsilon( T const& newEpsilon ) {
+            double epsilonAsDouble = static_cast<double>(newEpsilon);
+            setEpsilon(epsilonAsDouble);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& margin( T const& newMargin ) {
+            double marginAsDouble = static_cast<double>(newMargin);
+            setMargin(marginAsDouble);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& scale( T const& newScale ) {
+            m_scale = static_cast<double>(newScale);
+            return *this;
+        }
+
+        std::string toString() const;
+
+    private:
+        double m_epsilon;
+        double m_margin;
+        double m_scale;
+        double m_value;
+    };
+} // end namespace Detail
+
+namespace literals {
+    Detail::Approx operator "" _a(long double val);
+    Detail::Approx operator "" _a(unsigned long long val);
+} // end namespace literals
+
+template<>
+struct StringMaker<Catch::Detail::Approx> {
+    static std::string convert(Catch::Detail::Approx const& value);
+};
+
+} // end namespace Catch
+
+// end catch_approx.h
+// start catch_string_manip.h
+
+#include <string>
+#include <iosfwd>
+#include <vector>
+
+namespace Catch {
+
+    bool startsWith( std::string const& s, std::string const& prefix );
+    bool startsWith( std::string const& s, char prefix );
+    bool endsWith( std::string const& s, std::string const& suffix );
+    bool endsWith( std::string const& s, char suffix );
+    bool contains( std::string const& s, std::string const& infix );
+    void toLowerInPlace( std::string& s );
+    std::string toLower( std::string const& s );
+    //! Returns a new string without whitespace at the start/end
+    std::string trim( std::string const& str );
+    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
+    StringRef trim(StringRef ref);
+
+    // !!! Be aware, returns refs into original string - make sure original string outlives them
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+
+    struct pluralise {
+        pluralise( std::size_t count, std::string const& label );
+
+        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+
+        std::size_t m_count;
+        std::string m_label;
+    };
+}
+
+// end catch_string_manip.h
+#ifndef CATCH_CONFIG_DISABLE_MATCHERS
+// start catch_capture_matchers.h
+
+// start catch_matchers.h
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+        template<typename ArgT> struct MatchAllOf;
+        template<typename ArgT> struct MatchAnyOf;
+        template<typename ArgT> struct MatchNotOf;
+
+        class MatcherUntypedBase {
+        public:
+            MatcherUntypedBase() = default;
+            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
+            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
+            std::string toString() const;
+
+        protected:
+            virtual ~MatcherUntypedBase();
+            virtual std::string describe() const = 0;
+            mutable std::string m_cachedToString;
+        };
+
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+        template<typename ObjectT>
+        struct MatcherMethod {
+            virtual bool match( ObjectT const& arg ) const = 0;
+        };
+
+#if defined(__OBJC__)
+        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
+        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
+        template<>
+        struct MatcherMethod<NSString*> {
+            virtual bool match( NSString* arg ) const = 0;
+        };
+#endif
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
+        template<typename T>
+        struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
+
+            MatchAllOf<T> operator && ( MatcherBase const& other ) const;
+            MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
+            MatchNotOf<T> operator ! () const;
+        };
+
+        template<typename ArgT>
+        struct MatchAllOf : MatcherBase<ArgT> {
+            bool match( ArgT const& arg ) const override {
+                for( auto matcher : m_matchers ) {
+                    if (!matcher->match(arg))
+                        return false;
+                }
+                return true;
+            }
+            std::string describe() const override {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                bool first = true;
+                for( auto matcher : m_matchers ) {
+                    if( first )
+                        first = false;
+                    else
+                        description += " and ";
+                    description += matcher->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+        template<typename ArgT>
+        struct MatchAnyOf : MatcherBase<ArgT> {
+
+            bool match( ArgT const& arg ) const override {
+                for( auto matcher : m_matchers ) {
+                    if (matcher->match(arg))
+                        return true;
+                }
+                return false;
+            }
+            std::string describe() const override {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                bool first = true;
+                for( auto matcher : m_matchers ) {
+                    if( first )
+                        first = false;
+                    else
+                        description += " or ";
+                    description += matcher->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+
+        template<typename ArgT>
+        struct MatchNotOf : MatcherBase<ArgT> {
+
+            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
+
+            bool match( ArgT const& arg ) const override {
+                return !m_underlyingMatcher.match( arg );
+            }
+
+            std::string describe() const override {
+                return "not " + m_underlyingMatcher.toString();
+            }
+            MatcherBase<ArgT> const& m_underlyingMatcher;
+        };
+
+        template<typename T>
+        MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
+            return MatchAllOf<T>() && *this && other;
+        }
+        template<typename T>
+        MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
+            return MatchAnyOf<T>() || *this || other;
+        }
+        template<typename T>
+        MatchNotOf<T> MatcherBase<T>::operator ! () const {
+            return MatchNotOf<T>( *this );
+        }
+
+    } // namespace Impl
+
+} // namespace Matchers
+
+using namespace Matchers;
+using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+
+// end catch_matchers.h
+// start catch_matchers_exception.hpp
+
+namespace Catch {
+namespace Matchers {
+namespace Exception {
+
+class ExceptionMessageMatcher : public MatcherBase<std::exception> {
+    std::string m_message;
+public:
+
+    ExceptionMessageMatcher(std::string const& message):
+        m_message(message)
+    {}
+
+    bool match(std::exception const& ex) const override;
+
+    std::string describe() const override;
+};
+
+} // namespace Exception
+
+Exception::ExceptionMessageMatcher Message(std::string const& message);
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_exception.hpp
+// start catch_matchers_floating.h
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Floating {
+
+        enum class FloatingPointKind : uint8_t;
+
+        struct WithinAbsMatcher : MatcherBase<double> {
+            WithinAbsMatcher(double target, double margin);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            double m_margin;
+        };
+
+        struct WithinUlpsMatcher : MatcherBase<double> {
+            WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            uint64_t m_ulps;
+            FloatingPointKind m_type;
+        };
+
+        // Given IEEE-754 format for floats and doubles, we can assume
+        // that float -> double promotion is lossless. Given this, we can
+        // assume that if we do the standard relative comparison of
+        // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
+        // the same result if we do this for floats, as if we do this for
+        // doubles that were promoted from floats.
+        struct WithinRelMatcher : MatcherBase<double> {
+            WithinRelMatcher(double target, double epsilon);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            double m_epsilon;
+        };
+
+    } // namespace Floating
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
+    Floating::WithinAbsMatcher WithinAbs(double target, double margin);
+    Floating::WithinRelMatcher WithinRel(double target, double eps);
+    // defaults epsilon to 100*numeric_limits<double>::epsilon()
+    Floating::WithinRelMatcher WithinRel(double target);
+    Floating::WithinRelMatcher WithinRel(float target, float eps);
+    // defaults epsilon to 100*numeric_limits<float>::epsilon()
+    Floating::WithinRelMatcher WithinRel(float target);
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_floating.h
+// start catch_matchers_generic.hpp
+
+#include <functional>
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+namespace Generic {
+
+namespace Detail {
+    std::string finalizeDescription(const std::string& desc);
+}
+
+template <typename T>
+class PredicateMatcher : public MatcherBase<T> {
+    std::function<bool(T const&)> m_predicate;
+    std::string m_description;
+public:
+
+    PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
+        :m_predicate(std::move(elem)),
+        m_description(Detail::finalizeDescription(descr))
+    {}
+
+    bool match( T const& item ) const override {
+        return m_predicate(item);
+    }
+
+    std::string describe() const override {
+        return m_description;
+    }
+};
+
+} // namespace Generic
+
+    // The following functions create the actual matcher objects.
+    // The user has to explicitly specify type to the function, because
+    // inferring std::function<bool(T const&)> is hard (but possible) and
+    // requires a lot of TMP.
+    template<typename T>
+    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
+        return Generic::PredicateMatcher<T>(predicate, description);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_generic.hpp
+// start catch_matchers_string.h
+
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        struct CasedString
+        {
+            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
+            std::string adjustString( std::string const& str ) const;
+            std::string caseSensitivitySuffix() const;
+
+            CaseSensitive::Choice m_caseSensitivity;
+            std::string m_str;
+        };
+
+        struct StringMatcherBase : MatcherBase<std::string> {
+            StringMatcherBase( std::string const& operation, CasedString const& comparator );
+            std::string describe() const override;
+
+            CasedString m_comparator;
+            std::string m_operation;
+        };
+
+        struct EqualsMatcher : StringMatcherBase {
+            EqualsMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+        struct ContainsMatcher : StringMatcherBase {
+            ContainsMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+        struct StartsWithMatcher : StringMatcherBase {
+            StartsWithMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+        struct EndsWithMatcher : StringMatcherBase {
+            EndsWithMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+
+        struct RegexMatcher : MatcherBase<std::string> {
+            RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
+            bool match( std::string const& matchee ) const override;
+            std::string describe() const override;
+
+        private:
+            std::string m_regex;
+            CaseSensitive::Choice m_caseSensitivity;
+        };
+
+    } // namespace StdString
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_string.h
+// start catch_matchers_vector.h
+
+#include <algorithm>
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Vector {
+        template<typename T>
+        struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
+
+            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
+
+            bool match(std::vector<T> const &v) const override {
+                for (auto const& el : v) {
+                    if (el == m_comparator) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            std::string describe() const override {
+                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+            }
+
+            T const& m_comparator;
+        };
+
+        template<typename T>
+        struct ContainsMatcher : MatcherBase<std::vector<T>> {
+
+            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                // !TBD: see note in EqualsMatcher
+                if (m_comparator.size() > v.size())
+                    return false;
+                for (auto const& comparator : m_comparator) {
+                    auto present = false;
+                    for (const auto& el : v) {
+                        if (el == comparator) {
+                            present = true;
+                            break;
+                        }
+                    }
+                    if (!present) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            std::string describe() const override {
+                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+            }
+
+            std::vector<T> const& m_comparator;
+        };
+
+        template<typename T>
+        struct EqualsMatcher : MatcherBase<std::vector<T>> {
+
+            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                // !TBD: This currently works if all elements can be compared using !=
+                // - a more general approach would be via a compare template that defaults
+                // to using !=. but could be specialised for, e.g. std::vector<T> etc
+                // - then just call that directly
+                if (m_comparator.size() != v.size())
+                    return false;
+                for (std::size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != v[i])
+                        return false;
+                return true;
+            }
+            std::string describe() const override {
+                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
+            }
+            std::vector<T> const& m_comparator;
+        };
+
+        template<typename T>
+        struct ApproxMatcher : MatcherBase<std::vector<T>> {
+
+            ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                if (m_comparator.size() != v.size())
+                    return false;
+                for (std::size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != approx(v[i]))
+                        return false;
+                return true;
+            }
+            std::string describe() const override {
+                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& epsilon( T const& newEpsilon ) {
+                approx.epsilon(newEpsilon);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& margin( T const& newMargin ) {
+                approx.margin(newMargin);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& scale( T const& newScale ) {
+                approx.scale(newScale);
+                return *this;
+            }
+
+            std::vector<T> const& m_comparator;
+            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
+        };
+
+        template<typename T>
+        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
+            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
+            bool match(std::vector<T> const& vec) const override {
+                // Note: This is a reimplementation of std::is_permutation,
+                //       because I don't want to include <algorithm> inside the common path
+                if (m_target.size() != vec.size()) {
+                    return false;
+                }
+                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
+            }
+
+            std::string describe() const override {
+                return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
+            }
+        private:
+            std::vector<T> const& m_target;
+        };
+
+    } // namespace Vector
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    template<typename T>
+    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
+        return Vector::ContainsMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
+        return Vector::ContainsElementMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
+        return Vector::EqualsMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::ApproxMatcher<T> Approx( std::vector<T> const& comparator ) {
+        return Vector::ApproxMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
+        return Vector::UnorderedEqualsMatcher<T>(target);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_vector.h
+namespace Catch {
+
+    template<typename ArgT, typename MatcherT>
+    class MatchExpr : public ITransientExpression {
+        ArgT const& m_arg;
+        MatcherT m_matcher;
+        StringRef m_matcherString;
+    public:
+        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
+        :   ITransientExpression{ true, matcher.match( arg ) },
+            m_arg( arg ),
+            m_matcher( matcher ),
+            m_matcherString( matcherString )
+        {}
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            auto matcherAsString = m_matcher.toString();
+            os << Catch::Detail::stringify( m_arg ) << ' ';
+            if( matcherAsString == Detail::unprintableString )
+                os << m_matcherString;
+            else
+                os << matcherAsString;
+        }
+    };
+
+    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
+
+    template<typename ArgT, typename MatcherT>
+    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
+        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
+    }
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__ ); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ex ) { \
+                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+// end catch_capture_matchers.h
+#endif
+// start catch_generators.hpp
+
+// start catch_interfaces_generatortracker.h
+
+
+#include <memory>
+
+namespace Catch {
+
+    namespace Generators {
+        class GeneratorUntypedBase {
+        public:
+            GeneratorUntypedBase() = default;
+            virtual ~GeneratorUntypedBase();
+            // Attempts to move the generator to the next element
+             //
+             // Returns true iff the move succeeded (and a valid element
+             // can be retrieved).
+            virtual bool next() = 0;
+        };
+        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
+
+    } // namespace Generators
+
+    struct IGeneratorTracker {
+        virtual ~IGeneratorTracker();
+        virtual auto hasGenerator() const -> bool = 0;
+        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
+        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
+    };
+
+} // namespace Catch
+
+// end catch_interfaces_generatortracker.h
+// start catch_enforce.h
+
+#include <exception>
+
+namespace Catch {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    template <typename Ex>
+    [[noreturn]]
+    void throw_exception(Ex const& e) {
+        throw e;
+    }
+#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
+    [[noreturn]]
+    void throw_exception(std::exception const& e);
+#endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg);
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg);
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg);
+
+} // namespace Catch;
+
+#define CATCH_MAKE_MSG(...) \
+    (Catch::ReusableStringStream() << __VA_ARGS__).str()
+
+#define CATCH_INTERNAL_ERROR(...) \
+    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
+
+#define CATCH_ERROR(...) \
+    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_RUNTIME_ERROR(...) \
+    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_ENFORCE( condition, ... ) \
+    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
+
+// end catch_enforce.h
+#include <memory>
+#include <vector>
+#include <cassert>
+
+#include <utility>
+#include <exception>
+
+namespace Catch {
+
+class GeneratorException : public std::exception {
+    const char* const m_msg = "";
+
+public:
+    GeneratorException(const char* msg):
+        m_msg(msg)
+    {}
+
+    const char* what() const noexcept override final;
+};
+
+namespace Generators {
+
+    // !TBD move this into its own location?
+    namespace pf{
+        template<typename T, typename... Args>
+        std::unique_ptr<T> make_unique( Args&&... args ) {
+            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+        }
+    }
+
+    template<typename T>
+    struct IGenerator : GeneratorUntypedBase {
+        virtual ~IGenerator() = default;
+
+        // Returns the current element of the generator
+        //
+        // \Precondition The generator is either freshly constructed,
+        // or the last call to `next()` returned true
+        virtual T const& get() const = 0;
+        using type = T;
+    };
+
+    template<typename T>
+    class SingleValueGenerator final : public IGenerator<T> {
+        T m_value;
+    public:
+        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
+
+        T const& get() const override {
+            return m_value;
+        }
+        bool next() override {
+            return false;
+        }
+    };
+
+    template<typename T>
+    class FixedValuesGenerator final : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "FixedValuesGenerator does not support bools because of std::vector<bool>"
+            "specialization, use SingleValue Generator instead.");
+        std::vector<T> m_values;
+        size_t m_idx = 0;
+    public:
+        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
+
+        T const& get() const override {
+            return m_values[m_idx];
+        }
+        bool next() override {
+            ++m_idx;
+            return m_idx < m_values.size();
+        }
+    };
+
+    template <typename T>
+    class GeneratorWrapper final {
+        std::unique_ptr<IGenerator<T>> m_generator;
+    public:
+        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
+            m_generator(std::move(generator))
+        {}
+        T const& get() const {
+            return m_generator->get();
+        }
+        bool next() {
+            return m_generator->next();
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> value(T&& value) {
+        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
+    }
+    template <typename T>
+    GeneratorWrapper<T> values(std::initializer_list<T> values) {
+        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
+    }
+
+    template<typename T>
+    class Generators : public IGenerator<T> {
+        std::vector<GeneratorWrapper<T>> m_generators;
+        size_t m_current = 0;
+
+        void populate(GeneratorWrapper<T>&& generator) {
+            m_generators.emplace_back(std::move(generator));
+        }
+        void populate(T&& val) {
+            m_generators.emplace_back(value(std::forward<T>(val)));
+        }
+        template<typename U>
+        void populate(U&& val) {
+            populate(T(std::forward<U>(val)));
+        }
+        template<typename U, typename... Gs>
+        void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
+            populate(std::forward<U>(valueOrGenerator));
+            populate(std::forward<Gs>(moreGenerators)...);
+        }
+
+    public:
+        template <typename... Gs>
+        Generators(Gs &&... moreGenerators) {
+            m_generators.reserve(sizeof...(Gs));
+            populate(std::forward<Gs>(moreGenerators)...);
+        }
+
+        T const& get() const override {
+            return m_generators[m_current].get();
+        }
+
+        bool next() override {
+            if (m_current >= m_generators.size()) {
+                return false;
+            }
+            const bool current_status = m_generators[m_current].next();
+            if (!current_status) {
+                ++m_current;
+            }
+            return m_current < m_generators.size();
+        }
+    };
+
+    template<typename... Ts>
+    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
+        return values<std::tuple<Ts...>>( tuples );
+    }
+
+    // Tag type to signal that a generator sequence should convert arguments to a specific type
+    template <typename T>
+    struct as {};
+
+    template<typename T, typename... Gs>
+    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
+        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
+    }
+    template<typename T>
+    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
+        return Generators<T>(std::move(generator));
+    }
+    template<typename T, typename... Gs>
+    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
+    }
+    template<typename T, typename U, typename... Gs>
+    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
+    }
+
+    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
+
+    template<typename L>
+    // Note: The type after -> is weird, because VS2015 cannot parse
+    //       the expression used in the typedef inside, when it is in
+    //       return type. Yeah.
+    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
+        using UnderlyingType = typename decltype(generatorExpression())::type;
+
+        IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
+        if (!tracker.hasGenerator()) {
+            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
+        }
+
+        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
+        return generator.get();
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+#define GENERATE( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_COPY( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_REF( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+
+// end catch_generators.hpp
+// start catch_generators_generic.hpp
+
+namespace Catch {
+namespace Generators {
+
+    template <typename T>
+    class TakeGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        size_t m_returned = 0;
+        size_t m_target;
+    public:
+        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target(target)
+        {
+            assert(target != 0 && "Empty generators are not allowed");
+        }
+        T const& get() const override {
+            return m_generator.get();
+        }
+        bool next() override {
+            ++m_returned;
+            if (m_returned >= m_target) {
+                return false;
+            }
+
+            const auto success = m_generator.next();
+            // If the underlying generator does not contain enough values
+            // then we cut short as well
+            if (!success) {
+                m_returned = m_target;
+            }
+            return success;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
+    }
+
+    template <typename T, typename Predicate>
+    class FilterGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        Predicate m_predicate;
+    public:
+        template <typename P = Predicate>
+        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_predicate(std::forward<P>(pred))
+        {
+            if (!m_predicate(m_generator.get())) {
+                // It might happen that there are no values that pass the
+                // filter. In that case we throw an exception.
+                auto has_initial_value = next();
+                if (!has_initial_value) {
+                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
+                }
+            }
+        }
+
+        T const& get() const override {
+            return m_generator.get();
+        }
+
+        bool next() override {
+            bool success = m_generator.next();
+            if (!success) {
+                return false;
+            }
+            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
+            return success;
+        }
+    };
+
+    template <typename T, typename Predicate>
+    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
+    }
+
+    template <typename T>
+    class RepeatGenerator : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "RepeatGenerator currently does not support bools"
+            "because of std::vector<bool> specialization");
+        GeneratorWrapper<T> m_generator;
+        mutable std::vector<T> m_returned;
+        size_t m_target_repeats;
+        size_t m_current_repeat = 0;
+        size_t m_repeat_index = 0;
+    public:
+        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target_repeats(repeats)
+        {
+            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
+        }
+
+        T const& get() const override {
+            if (m_current_repeat == 0) {
+                m_returned.push_back(m_generator.get());
+                return m_returned.back();
+            }
+            return m_returned[m_repeat_index];
+        }
+
+        bool next() override {
+            // There are 2 basic cases:
+            // 1) We are still reading the generator
+            // 2) We are reading our own cache
+
+            // In the first case, we need to poke the underlying generator.
+            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
+            if (m_current_repeat == 0) {
+                const auto success = m_generator.next();
+                if (!success) {
+                    ++m_current_repeat;
+                }
+                return m_current_repeat < m_target_repeats;
+            }
+
+            // In the second case, we need to move indices forward and check that we haven't run up against the end
+            ++m_repeat_index;
+            if (m_repeat_index == m_returned.size()) {
+                m_repeat_index = 0;
+                ++m_current_repeat;
+            }
+            return m_current_repeat < m_target_repeats;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
+    }
+
+    template <typename T, typename U, typename Func>
+    class MapGenerator : public IGenerator<T> {
+        // TBD: provide static assert for mapping function, for friendly error message
+        GeneratorWrapper<U> m_generator;
+        Func m_function;
+        // To avoid returning dangling reference, we have to save the values
+        T m_cache;
+    public:
+        template <typename F2 = Func>
+        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
+            m_generator(std::move(generator)),
+            m_function(std::forward<F2>(function)),
+            m_cache(m_function(m_generator.get()))
+        {}
+
+        T const& get() const override {
+            return m_cache;
+        }
+        bool next() override {
+            const auto success = m_generator.next();
+            if (success) {
+                m_cache = m_function(m_generator.get());
+            }
+            return success;
+        }
+    };
+
+    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
+
+    template <typename T, typename U, typename Func>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
+
+    template <typename T>
+    class ChunkGenerator final : public IGenerator<std::vector<T>> {
+        std::vector<T> m_chunk;
+        size_t m_chunk_size;
+        GeneratorWrapper<T> m_generator;
+        bool m_used_up = false;
+    public:
+        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
+            m_chunk_size(size), m_generator(std::move(generator))
+        {
+            m_chunk.reserve(m_chunk_size);
+            if (m_chunk_size != 0) {
+                m_chunk.push_back(m_generator.get());
+                for (size_t i = 1; i < m_chunk_size; ++i) {
+                    if (!m_generator.next()) {
+                        Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
+                    }
+                    m_chunk.push_back(m_generator.get());
+                }
+            }
+        }
+        std::vector<T> const& get() const override {
+            return m_chunk;
+        }
+        bool next() override {
+            m_chunk.clear();
+            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
+                if (!m_generator.next()) {
+                    return false;
+                }
+                m_chunk.push_back(m_generator.get());
+            }
+            return true;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<std::vector<T>>(
+            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
+        );
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+// end catch_generators_generic.hpp
+// start catch_generators_specific.hpp
+
+// start catch_context.h
+
+#include <memory>
+
+namespace Catch {
+
+    struct IResultCapture;
+    struct IRunner;
+    struct IConfig;
+    struct IMutableContext;
+
+    using IConfigPtr = std::shared_ptr<IConfig const>;
+
+    struct IContext
+    {
+        virtual ~IContext();
+
+        virtual IResultCapture* getResultCapture() = 0;
+        virtual IRunner* getRunner() = 0;
+        virtual IConfigPtr const& getConfig() const = 0;
+    };
+
+    struct IMutableContext : IContext
+    {
+        virtual ~IMutableContext();
+        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+        virtual void setRunner( IRunner* runner ) = 0;
+        virtual void setConfig( IConfigPtr const& config ) = 0;
+
+    private:
+        static IMutableContext *currentContext;
+        friend IMutableContext& getCurrentMutableContext();
+        friend void cleanUpContext();
+        static void createContext();
+    };
+
+    inline IMutableContext& getCurrentMutableContext()
+    {
+        if( !IMutableContext::currentContext )
+            IMutableContext::createContext();
+        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+        return *IMutableContext::currentContext;
+    }
+
+    inline IContext& getCurrentContext()
+    {
+        return getCurrentMutableContext();
+    }
+
+    void cleanUpContext();
+
+    class SimplePcg32;
+    SimplePcg32& rng();
+}
+
+// end catch_context.h
+// start catch_interfaces_config.h
+
+// start catch_option.hpp
+
+namespace Catch {
+
+    // An optional type
+    template<typename T>
+    class Option {
+    public:
+        Option() : nullableValue( nullptr ) {}
+        Option( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Option( Option const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
+        {}
+
+        ~Option() {
+            reset();
+        }
+
+        Option& operator= ( Option const& _other ) {
+            if( &_other != this ) {
+                reset();
+                if( _other )
+                    nullableValue = new( storage ) T( *_other );
+            }
+            return *this;
+        }
+        Option& operator = ( T const& _value ) {
+            reset();
+            nullableValue = new( storage ) T( _value );
+            return *this;
+        }
+
+        void reset() {
+            if( nullableValue )
+                nullableValue->~T();
+            nullableValue = nullptr;
+        }
+
+        T& operator*() { return *nullableValue; }
+        T const& operator*() const { return *nullableValue; }
+        T* operator->() { return nullableValue; }
+        const T* operator->() const { return nullableValue; }
+
+        T valueOr( T const& defaultValue ) const {
+            return nullableValue ? *nullableValue : defaultValue;
+        }
+
+        bool some() const { return nullableValue != nullptr; }
+        bool none() const { return nullableValue == nullptr; }
+
+        bool operator !() const { return nullableValue == nullptr; }
+        explicit operator bool() const {
+            return some();
+        }
+
+    private:
+        T *nullableValue;
+        alignas(alignof(T)) char storage[sizeof(T)];
+    };
+
+} // end namespace Catch
+
+// end catch_option.hpp
+#include <chrono>
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    enum class Verbosity {
+        Quiet = 0,
+        Normal,
+        High
+    };
+
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        NoAssertions = 0x01,
+        NoTests = 0x02
+    }; };
+
+    struct ShowDurations { enum OrNot {
+        DefaultForReporter,
+        Always,
+        Never
+    }; };
+    struct RunTests { enum InWhatOrder {
+        InDeclarationOrder,
+        InLexicographicalOrder,
+        InRandomOrder
+    }; };
+    struct UseColour { enum YesOrNo {
+        Auto,
+        Yes,
+        No
+    }; };
+    struct WaitForKeypress { enum When {
+        Never,
+        BeforeStart = 1,
+        BeforeExit = 2,
+        BeforeStartAndExit = BeforeStart | BeforeExit
+    }; };
+
+    class TestSpec;
+
+    struct IConfig : NonCopyable {
+
+        virtual ~IConfig();
+
+        virtual bool allowThrows() const = 0;
+        virtual std::ostream& stream() const = 0;
+        virtual std::string name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual bool warnAboutNoTests() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations::OrNot showDurations() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+        virtual bool hasTestFilters() const = 0;
+        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
+        virtual RunTests::InWhatOrder runOrder() const = 0;
+        virtual unsigned int rngSeed() const = 0;
+        virtual UseColour::YesOrNo useColour() const = 0;
+        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+        virtual Verbosity verbosity() const = 0;
+
+        virtual bool benchmarkNoAnalysis() const = 0;
+        virtual int benchmarkSamples() const = 0;
+        virtual double benchmarkConfidenceInterval() const = 0;
+        virtual unsigned int benchmarkResamples() const = 0;
+        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
+    };
+
+    using IConfigPtr = std::shared_ptr<IConfig const>;
+}
+
+// end catch_interfaces_config.h
+// start catch_random_number_generator.h
+
+#include <cstdint>
+
+namespace Catch {
+
+    // This is a simple implementation of C++11 Uniform Random Number
+    // Generator. It does not provide all operators, because Catch2
+    // does not use it, but it should behave as expected inside stdlib's
+    // distributions.
+    // The implementation is based on the PCG family (http://pcg-random.org)
+    class SimplePcg32 {
+        using state_type = std::uint64_t;
+    public:
+        using result_type = std::uint32_t;
+        static constexpr result_type (min)() {
+            return 0;
+        }
+        static constexpr result_type (max)() {
+            return static_cast<result_type>(-1);
+        }
+
+        // Provide some default initial state for the default constructor
+        SimplePcg32():SimplePcg32(0xed743cc4U) {}
+
+        explicit SimplePcg32(result_type seed_);
+
+        void seed(result_type seed_);
+        void discard(uint64_t skip);
+
+        result_type operator()();
+
+    private:
+        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+
+        // In theory we also need operator<< and operator>>
+        // In practice we do not use them, so we will skip them for now
+
+        std::uint64_t m_state;
+        // This part of the state determines which "stream" of the numbers
+        // is chosen -- we take it as a constant for Catch2, so we only
+        // need to deal with seeding the main state.
+        // Picked by reading 8 bytes from `/dev/random` :-)
+        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
+    };
+
+} // end namespace Catch
+
+// end catch_random_number_generator.h
+#include <random>
+
+namespace Catch {
+namespace Generators {
+
+template <typename Float>
+class RandomFloatingGenerator final : public IGenerator<Float> {
+    Catch::SimplePcg32& m_rng;
+    std::uniform_real_distribution<Float> m_dist;
+    Float m_current_number;
+public:
+
+    RandomFloatingGenerator(Float a, Float b):
+        m_rng(rng()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Float const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+template <typename Integer>
+class RandomIntegerGenerator final : public IGenerator<Integer> {
+    Catch::SimplePcg32& m_rng;
+    std::uniform_int_distribution<Integer> m_dist;
+    Integer m_current_number;
+public:
+
+    RandomIntegerGenerator(Integer a, Integer b):
+        m_rng(rng()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Integer const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+// TODO: Ideally this would be also constrained against the various char types,
+//       but I don't expect users to run into that in practice.
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
+    );
+}
+
+template <typename T>
+typename std::enable_if<std::is_floating_point<T>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
+    );
+}
+
+template <typename T>
+class RangeGenerator final : public IGenerator<T> {
+    T m_current;
+    T m_end;
+    T m_step;
+    bool m_positive;
+
+public:
+    RangeGenerator(T const& start, T const& end, T const& step):
+        m_current(start),
+        m_end(end),
+        m_step(step),
+        m_positive(m_step > T(0))
+    {
+        assert(m_current != m_end && "Range start and end cannot be equal");
+        assert(m_step != T(0) && "Step size cannot be zero");
+        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
+    }
+
+    RangeGenerator(T const& start, T const& end):
+        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
+    {}
+
+    T const& get() const override {
+        return m_current;
+    }
+
+    bool next() override {
+        m_current += m_step;
+        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
+    }
+};
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
+    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
+}
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end) {
+    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
+}
+
+template <typename T>
+class IteratorGenerator final : public IGenerator<T> {
+    static_assert(!std::is_same<T, bool>::value,
+        "IteratorGenerator currently does not support bools"
+        "because of std::vector<bool> specialization");
+
+    std::vector<T> m_elems;
+    size_t m_current = 0;
+public:
+    template <typename InputIterator, typename InputSentinel>
+    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
+        if (m_elems.empty()) {
+            Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
+        }
+    }
+
+    T const& get() const override {
+        return m_elems[m_current];
+    }
+
+    bool next() override {
+        ++m_current;
+        return m_current != m_elems.size();
+    }
+};
+
+template <typename InputIterator,
+          typename InputSentinel,
+          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
+GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
+    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
+}
+
+template <typename Container,
+          typename ResultType = typename Container::value_type>
+GeneratorWrapper<ResultType> from_range(Container const& cnt) {
+    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
+}
+
+} // namespace Generators
+} // namespace Catch
+
+// end catch_generators_specific.hpp
+
+// These files are included here so the single_include script doesn't put them
+// in the conditionally compiled sections
+// start catch_test_case_info.h
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct ITestInvoker;
+
+    struct TestCaseInfo {
+        enum SpecialProperties{
+            None = 0,
+            IsHidden = 1 << 1,
+            ShouldFail = 1 << 2,
+            MayFail = 1 << 3,
+            Throws = 1 << 4,
+            NonPortable = 1 << 5,
+            Benchmark = 1 << 6
+        };
+
+        TestCaseInfo(   std::string const& _name,
+                        std::string const& _className,
+                        std::string const& _description,
+                        std::vector<std::string> const& _tags,
+                        SourceLineInfo const& _lineInfo );
+
+        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
+
+        bool isHidden() const;
+        bool throws() const;
+        bool okToFail() const;
+        bool expectedToFail() const;
+
+        std::string tagsAsString() const;
+
+        std::string name;
+        std::string className;
+        std::string description;
+        std::vector<std::string> tags;
+        std::vector<std::string> lcaseTags;
+        SourceLineInfo lineInfo;
+        SpecialProperties properties;
+    };
+
+    class TestCase : public TestCaseInfo {
+    public:
+
+        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
+
+        TestCase withName( std::string const& _newName ) const;
+
+        void invoke() const;
+
+        TestCaseInfo const& getTestCaseInfo() const;
+
+        bool operator == ( TestCase const& other ) const;
+        bool operator < ( TestCase const& other ) const;
+
+    private:
+        std::shared_ptr<ITestInvoker> test;
+    };
+
+    TestCase makeTestCase(  ITestInvoker* testCase,
+                            std::string const& className,
+                            NameAndTags const& nameAndTags,
+                            SourceLineInfo const& lineInfo );
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_case_info.h
+// start catch_interfaces_runner.h
+
+namespace Catch {
+
+    struct IRunner {
+        virtual ~IRunner();
+        virtual bool aborting() const = 0;
+    };
+}
+
+// end catch_interfaces_runner.h
+
+#ifdef __OBJC__
+// start catch_objc.hpp
+
+#import <objc/runtime.h>
+
+#include <string>
+
+// NB. Any general catch headers included here must be included
+// in catch.hpp first to make sure they are included by the single
+// header for non obj-usage
+
+///////////////////////////////////////////////////////////////////////////////
+// This protocol is really only here for (self) documenting purposes, since
+// all its methods are optional.
+@protocol OcFixture
+
+@optional
+
+-(void) setUp;
+-(void) tearDown;
+
+@end
+
+namespace Catch {
+
+    class OcMethod : public ITestInvoker {
+
+    public:
+        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+
+        virtual void invoke() const {
+            id obj = [[m_cls alloc] init];
+
+            performOptionalSelector( obj, @selector(setUp)  );
+            performOptionalSelector( obj, m_sel );
+            performOptionalSelector( obj, @selector(tearDown)  );
+
+            arcSafeRelease( obj );
+        }
+    private:
+        virtual ~OcMethod() {}
+
+        Class m_cls;
+        SEL m_sel;
+    };
+
+    namespace Detail{
+
+        inline std::string getAnnotation(   Class cls,
+                                            std::string const& annotationName,
+                                            std::string const& testCaseName ) {
+            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+            SEL sel = NSSelectorFromString( selStr );
+            arcSafeRelease( selStr );
+            id value = performOptionalSelector( cls, sel );
+            if( value )
+                return [(NSString*)value UTF8String];
+            return "";
+        }
+    }
+
+    inline std::size_t registerTestMethods() {
+        std::size_t noTestMethods = 0;
+        int noClasses = objc_getClassList( nullptr, 0 );
+
+        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
+        objc_getClassList( classes, noClasses );
+
+        for( int c = 0; c < noClasses; c++ ) {
+            Class cls = classes[c];
+            {
+                u_int count;
+                Method* methods = class_copyMethodList( cls, &count );
+                for( u_int m = 0; m < count ; m++ ) {
+                    SEL selector = method_getName(methods[m]);
+                    std::string methodName = sel_getName(selector);
+                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
+                        std::string testCaseName = methodName.substr( 15 );
+                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
+                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
+                        const char* className = class_getName( cls );
+
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
+                        noTestMethods++;
+                    }
+                }
+                free(methods);
+            }
+        }
+        return noTestMethods;
+    }
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+
+    namespace Matchers {
+        namespace Impl {
+        namespace NSStringMatchers {
+
+            struct StringHolder : MatcherBase<NSString*>{
+                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
+                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
+                StringHolder() {
+                    arcSafeRelease( m_substr );
+                }
+
+                bool match( NSString* str ) const override {
+                    return false;
+                }
+
+                NSString* CATCH_ARC_STRONG m_substr;
+            };
+
+            struct Equals : StringHolder {
+                Equals( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str isEqualToString:m_substr];
+                }
+
+                std::string describe() const override {
+                    return "equals string: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+            struct Contains : StringHolder {
+                Contains( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location != NSNotFound;
+                }
+
+                std::string describe() const override {
+                    return "contains string: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+            struct StartsWith : StringHolder {
+                StartsWith( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == 0;
+                }
+
+                std::string describe() const override {
+                    return "starts with: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+            struct EndsWith : StringHolder {
+                EndsWith( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
+                }
+
+                std::string describe() const override {
+                    return "ends with: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+        } // namespace NSStringMatchers
+        } // namespace Impl
+
+        inline Impl::NSStringMatchers::Equals
+            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+
+        inline Impl::NSStringMatchers::Contains
+            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+
+        inline Impl::NSStringMatchers::StartsWith
+            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+
+        inline Impl::NSStringMatchers::EndsWith
+            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+
+    } // namespace Matchers
+
+    using namespace Matchers;
+
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
+#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
+{ \
+return @ name; \
+} \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
+{ \
+return @ desc; \
+} \
+-(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
+
+#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
+
+// end catch_objc.hpp
+#endif
+
+// Benchmarking needs the externally-facing parts of reporters to work
+#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_external_interfaces.h
+
+// start catch_reporter_bases.hpp
+
+// start catch_interfaces_reporter.h
+
+// start catch_config.hpp
+
+// start catch_test_spec_parser.h
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// start catch_test_spec.h
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// start catch_wildcard_pattern.h
+
+namespace Catch
+{
+    class WildcardPattern {
+        enum WildcardPosition {
+            NoWildcard = 0,
+            WildcardAtStart = 1,
+            WildcardAtEnd = 2,
+            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+        };
+
+    public:
+
+        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
+        virtual ~WildcardPattern() = default;
+        virtual bool matches( std::string const& str ) const;
+
+    private:
+        std::string normaliseString( std::string const& str ) const;
+        CaseSensitive::Choice m_caseSensitivity;
+        WildcardPosition m_wildcard = NoWildcard;
+        std::string m_pattern;
+    };
+}
+
+// end catch_wildcard_pattern.h
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    struct IConfig;
+
+    class TestSpec {
+        class Pattern {
+        public:
+            explicit Pattern( std::string const& name );
+            virtual ~Pattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+            std::string const& name() const;
+        private:
+            std::string const m_name;
+        };
+        using PatternPtr = std::shared_ptr<Pattern>;
+
+        class NamePattern : public Pattern {
+        public:
+            explicit NamePattern( std::string const& name, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            WildcardPattern m_wildcardPattern;
+        };
+
+        class TagPattern : public Pattern {
+        public:
+            explicit TagPattern( std::string const& tag, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            std::string m_tag;
+        };
+
+        class ExcludedPattern : public Pattern {
+        public:
+            explicit ExcludedPattern( PatternPtr const& underlyingPattern );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            PatternPtr m_underlyingPattern;
+        };
+
+        struct Filter {
+            std::vector<PatternPtr> m_patterns;
+
+            bool matches( TestCaseInfo const& testCase ) const;
+            std::string name() const;
+        };
+
+    public:
+        struct FilterMatch {
+            std::string name;
+            std::vector<TestCase const*> tests;
+        };
+        using Matches = std::vector<FilterMatch>;
+        using vectorStrings = std::vector<std::string>;
+
+        bool hasFilters() const;
+        bool matches( TestCaseInfo const& testCase ) const;
+        Matches matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const;
+        const vectorStrings & getInvalidArgs() const;
+
+    private:
+        std::vector<Filter> m_filters;
+        std::vector<std::string> m_invalidArgs;
+        friend class TestSpecParser;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_spec.h
+// start catch_interfaces_tag_alias_registry.h
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias;
+
+    struct ITagAliasRegistry {
+        virtual ~ITagAliasRegistry();
+        // Nullptr if not present
+        virtual TagAlias const* find( std::string const& alias ) const = 0;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+        static ITagAliasRegistry const& get();
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_tag_alias_registry.h
+namespace Catch {
+
+    class TestSpecParser {
+        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+        Mode m_mode = None;
+        Mode lastMode = None;
+        bool m_exclusion = false;
+        std::size_t m_pos = 0;
+        std::size_t m_realPatternPos = 0;
+        std::string m_arg;
+        std::string m_substring;
+        std::string m_patternName;
+        std::vector<std::size_t> m_escapeChars;
+        TestSpec::Filter m_currentFilter;
+        TestSpec m_testSpec;
+        ITagAliasRegistry const* m_tagAliases = nullptr;
+
+    public:
+        TestSpecParser( ITagAliasRegistry const& tagAliases );
+
+        TestSpecParser& parse( std::string const& arg );
+        TestSpec testSpec();
+
+    private:
+        bool visitChar( char c );
+        void startNewMode( Mode mode );
+        bool processNoneChar( char c );
+        void processNameChar( char c );
+        bool processOtherChar( char c );
+        void endMode();
+        void escape();
+        bool isControlChar( char c ) const;
+        void saveLastMode();
+        void revertBackToLastMode();
+        void addFilter();
+        bool separate();
+
+        // Handles common preprocessing of the pattern for name/tag patterns
+        std::string preprocessPattern();
+        // Adds the current pattern as a test name
+        void addNamePattern();
+        // Adds the current pattern as a tag
+        void addTagPattern();
+
+        inline void addCharToPattern(char c) {
+            m_substring += c;
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+
+    };
+    TestSpec parseTestSpec( std::string const& arg );
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_spec_parser.h
+// Libstdc++ doesn't like incomplete classes for unique_ptr
+
+#include <memory>
+#include <vector>
+#include <string>
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+
+    struct IStream;
+
+    struct ConfigData {
+        bool listTests = false;
+        bool listTags = false;
+        bool listReporters = false;
+        bool listTestNamesOnly = false;
+
+        bool showSuccessfulTests = false;
+        bool shouldDebugBreak = false;
+        bool noThrow = false;
+        bool showHelp = false;
+        bool showInvisibles = false;
+        bool filenamesAsTags = false;
+        bool libIdentify = false;
+
+        int abortAfter = -1;
+        unsigned int rngSeed = 0;
+
+        bool benchmarkNoAnalysis = false;
+        unsigned int benchmarkSamples = 100;
+        double benchmarkConfidenceInterval = 0.95;
+        unsigned int benchmarkResamples = 100000;
+        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
+
+        Verbosity verbosity = Verbosity::Normal;
+        WarnAbout::What warnings = WarnAbout::Nothing;
+        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
+        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
+        UseColour::YesOrNo useColour = UseColour::Auto;
+        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+
+        std::string outputFilename;
+        std::string name;
+        std::string processName;
+#ifndef CATCH_CONFIG_DEFAULT_REPORTER
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
+#undef CATCH_CONFIG_DEFAULT_REPORTER
+
+        std::vector<std::string> testsOrTags;
+        std::vector<std::string> sectionsToRun;
+    };
+
+    class Config : public IConfig {
+    public:
+
+        Config() = default;
+        Config( ConfigData const& data );
+        virtual ~Config() = default;
+
+        std::string const& getFilename() const;
+
+        bool listTests() const;
+        bool listTestNamesOnly() const;
+        bool listTags() const;
+        bool listReporters() const;
+
+        std::string getProcessName() const;
+        std::string const& getReporterName() const;
+
+        std::vector<std::string> const& getTestsOrTags() const override;
+        std::vector<std::string> const& getSectionsToRun() const override;
+
+        TestSpec const& testSpec() const override;
+        bool hasTestFilters() const override;
+
+        bool showHelp() const;
+
+        // IConfig interface
+        bool allowThrows() const override;
+        std::ostream& stream() const override;
+        std::string name() const override;
+        bool includeSuccessfulResults() const override;
+        bool warnAboutMissingAssertions() const override;
+        bool warnAboutNoTests() const override;
+        ShowDurations::OrNot showDurations() const override;
+        RunTests::InWhatOrder runOrder() const override;
+        unsigned int rngSeed() const override;
+        UseColour::YesOrNo useColour() const override;
+        bool shouldDebugBreak() const override;
+        int abortAfter() const override;
+        bool showInvisibles() const override;
+        Verbosity verbosity() const override;
+        bool benchmarkNoAnalysis() const override;
+        int benchmarkSamples() const override;
+        double benchmarkConfidenceInterval() const override;
+        unsigned int benchmarkResamples() const override;
+        std::chrono::milliseconds benchmarkWarmupTime() const override;
+
+    private:
+
+        IStream const* openStream();
+        ConfigData m_data;
+
+        std::unique_ptr<IStream const> m_stream;
+        TestSpec m_testSpec;
+        bool m_hasTestFilters = false;
+    };
+
+} // end namespace Catch
+
+// end catch_config.hpp
+// start catch_assertionresult.h
+
+#include <string>
+
+namespace Catch {
+
+    struct AssertionResultData
+    {
+        AssertionResultData() = delete;
+
+        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+
+        std::string message;
+        mutable std::string reconstructedExpression;
+        LazyExpression lazyExpression;
+        ResultWas::OfType resultType;
+
+        std::string reconstructExpression() const;
+    };
+
+    class AssertionResult {
+    public:
+        AssertionResult() = delete;
+        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+
+        bool isOk() const;
+        bool succeeded() const;
+        ResultWas::OfType getResultType() const;
+        bool hasExpression() const;
+        bool hasMessage() const;
+        std::string getExpression() const;
+        std::string getExpressionInMacro() const;
+        bool hasExpandedExpression() const;
+        std::string getExpandedExpression() const;
+        std::string getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        StringRef getTestMacroName() const;
+
+    //protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+// end catch_assertionresult.h
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_estimate.hpp
+
+ // Statistics estimates
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct Estimate {
+            Duration point;
+            Duration lower_bound;
+            Duration upper_bound;
+            double confidence_interval;
+
+            template <typename Duration2>
+            operator Estimate<Duration2>() const {
+                return { point, lower_bound, upper_bound, confidence_interval };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_estimate.hpp
+// start catch_outlier_classification.hpp
+
+// Outlier information
+
+namespace Catch {
+    namespace Benchmark {
+        struct OutlierClassification {
+            int samples_seen = 0;
+            int low_severe = 0;     // more than 3 times IQR below Q1
+            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
+            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
+            int high_severe = 0;    // more than 3 times IQR above Q3
+
+            int total() const {
+                return low_severe + low_mild + high_mild + high_severe;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_outlier_classification.hpp
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+#include <string>
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <memory>
+#include <algorithm>
+
+namespace Catch {
+
+    struct ReporterConfig {
+        explicit ReporterConfig( IConfigPtr const& _fullConfig );
+
+        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
+
+        std::ostream& stream() const;
+        IConfigPtr fullConfig() const;
+
+    private:
+        std::ostream* m_stream;
+        IConfigPtr m_fullConfig;
+    };
+
+    struct ReporterPreferences {
+        bool shouldRedirectStdOut = false;
+        bool shouldReportAllAssertions = false;
+    };
+
+    template<typename T>
+    struct LazyStat : Option<T> {
+        LazyStat& operator=( T const& _value ) {
+            Option<T>::operator=( _value );
+            used = false;
+            return *this;
+        }
+        void reset() {
+            Option<T>::reset();
+            used = false;
+        }
+        bool used = false;
+    };
+
+    struct TestRunInfo {
+        TestRunInfo( std::string const& _name );
+        std::string name;
+    };
+    struct GroupInfo {
+        GroupInfo(  std::string const& _name,
+                    std::size_t _groupIndex,
+                    std::size_t _groupsCount );
+
+        std::string name;
+        std::size_t groupIndex;
+        std::size_t groupsCounts;
+    };
+
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals );
+
+        AssertionStats( AssertionStats const& )              = default;
+        AssertionStats( AssertionStats && )                  = default;
+        AssertionStats& operator = ( AssertionStats const& ) = delete;
+        AssertionStats& operator = ( AssertionStats && )     = delete;
+        virtual ~AssertionStats();
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions );
+        SectionStats( SectionStats const& )              = default;
+        SectionStats( SectionStats && )                  = default;
+        SectionStats& operator = ( SectionStats const& ) = default;
+        SectionStats& operator = ( SectionStats && )     = default;
+        virtual ~SectionStats();
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        double durationInSeconds;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string const& _stdOut,
+                        std::string const& _stdErr,
+                        bool _aborting );
+
+        TestCaseStats( TestCaseStats const& )              = default;
+        TestCaseStats( TestCaseStats && )                  = default;
+        TestCaseStats& operator = ( TestCaseStats const& ) = default;
+        TestCaseStats& operator = ( TestCaseStats && )     = default;
+        virtual ~TestCaseStats();
+
+        TestCaseInfo testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestGroupStats {
+        TestGroupStats( GroupInfo const& _groupInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+        TestGroupStats( GroupInfo const& _groupInfo );
+
+        TestGroupStats( TestGroupStats const& )              = default;
+        TestGroupStats( TestGroupStats && )                  = default;
+        TestGroupStats& operator = ( TestGroupStats const& ) = default;
+        TestGroupStats& operator = ( TestGroupStats && )     = default;
+        virtual ~TestGroupStats();
+
+        GroupInfo groupInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+
+        TestRunStats( TestRunStats const& )              = default;
+        TestRunStats( TestRunStats && )                  = default;
+        TestRunStats& operator = ( TestRunStats const& ) = default;
+        TestRunStats& operator = ( TestRunStats && )     = default;
+        virtual ~TestRunStats();
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo {
+        std::string name;
+        double estimatedDuration;
+        int iterations;
+        int samples;
+        unsigned int resamples;
+        double clockResolution;
+        double clockCost;
+    };
+
+    template <class Duration>
+    struct BenchmarkStats {
+        BenchmarkInfo info;
+
+        std::vector<Duration> samples;
+        Benchmark::Estimate<Duration> mean;
+        Benchmark::Estimate<Duration> standardDeviation;
+        Benchmark::OutlierClassification outliers;
+        double outlierVariance;
+
+        template <typename Duration2>
+        operator BenchmarkStats<Duration2>() const {
+            std::vector<Duration2> samples2;
+            samples2.reserve(samples.size());
+            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+            return {
+                info,
+                std::move(samples2),
+                mean,
+                standardDeviation,
+                outliers,
+                outlierVariance,
+            };
+        }
+    };
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    struct IStreamingReporter {
+        virtual ~IStreamingReporter() = default;
+
+        // Implementing class must also provide the following static methods:
+        // static std::string getDescription();
+        // static std::set<Verbosity> getSupportedVerbosities()
+
+        virtual ReporterPreferences getPreferences() const = 0;
+
+        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+
+        virtual void reportInvalidArguments(std::string const&) {}
+
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& ) {}
+        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
+        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
+        virtual void benchmarkFailed( std::string const& ) {}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        // The return value indicates if the messages buffer should be cleared:
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+
+        // Default empty implementation provided
+        virtual void fatalErrorEncountered( StringRef name );
+
+        virtual bool isMulti() const;
+    };
+    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
+
+    struct IReporterFactory {
+        virtual ~IReporterFactory();
+        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+    struct IReporterRegistry {
+        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
+        using Listeners = std::vector<IReporterFactoryPtr>;
+
+        virtual ~IReporterRegistry();
+        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
+        virtual FactoryMap const& getFactories() const = 0;
+        virtual Listeners const& getListeners() const = 0;
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_reporter.h
+#include <algorithm>
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <cassert>
+#include <memory>
+#include <ostream>
+
+namespace Catch {
+    void prepareExpandedExpression(AssertionResult& result);
+
+    // Returns double formatted as %.3f (format expected on output)
+    std::string getFormattedDuration( double duration );
+
+    std::string serializeFilters( std::vector<std::string> const& container );
+
+    template<typename DerivedT>
+    struct StreamingReporterBase : IStreamingReporter {
+
+        StreamingReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        ~StreamingReporterBase() override = default;
+
+        void noMatchingTestCases(std::string const&) override {}
+
+        void reportInvalidArguments(std::string const&) override {}
+
+        void testRunStarting(TestRunInfo const& _testRunInfo) override {
+            currentTestRunInfo = _testRunInfo;
+        }
+
+        void testGroupStarting(GroupInfo const& _groupInfo) override {
+            currentGroupInfo = _groupInfo;
+        }
+
+        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
+            currentTestCaseInfo = _testInfo;
+        }
+        void sectionStarting(SectionInfo const& _sectionInfo) override {
+            m_sectionStack.push_back(_sectionInfo);
+        }
+
+        void sectionEnded(SectionStats const& /* _sectionStats */) override {
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+            currentTestCaseInfo.reset();
+        }
+        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
+            currentGroupInfo.reset();
+        }
+        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
+            currentTestCaseInfo.reset();
+            currentGroupInfo.reset();
+            currentTestRunInfo.reset();
+        }
+
+        void skipTest(TestCaseInfo const&) override {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+
+        LazyStat<TestRunInfo> currentTestRunInfo;
+        LazyStat<GroupInfo> currentGroupInfo;
+        LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+        std::vector<SectionInfo> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<typename DerivedT>
+    struct CumulativeReporterBase : IStreamingReporter {
+        template<typename T, typename ChildNodeT>
+        struct Node {
+            explicit Node( T const& _value ) : value( _value ) {}
+            virtual ~Node() {}
+
+            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode {
+            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+            virtual ~SectionNode() = default;
+
+            bool operator == (SectionNode const& other) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+            bool operator == (std::shared_ptr<SectionNode> const& other) const {
+                return operator==(*other);
+            }
+
+            SectionStats stats;
+            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
+            using Assertions = std::vector<AssertionStats>;
+            ChildSections childSections;
+            Assertions assertions;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
+            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
+            bool operator() (std::shared_ptr<SectionNode> const& node) const {
+                return ((node->stats.sectionInfo.name == m_other.name) &&
+                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
+            }
+            void operator=(BySectionInfo const&) = delete;
+
+        private:
+            SectionInfo const& m_other;
+        };
+
+        using TestCaseNode = Node<TestCaseStats, SectionNode>;
+        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
+        using TestRunNode = Node<TestRunStats, TestGroupNode>;
+
+        CumulativeReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+        ~CumulativeReporterBase() override = default;
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void testRunStarting( TestRunInfo const& ) override {}
+        void testGroupStarting( GroupInfo const& ) override {}
+
+        void testCaseStarting( TestCaseInfo const& ) override {}
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
+            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+            std::shared_ptr<SectionNode> node;
+            if( m_sectionStack.empty() ) {
+                if( !m_rootSection )
+                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
+                node = m_rootSection;
+            }
+            else {
+                SectionNode& parentNode = *m_sectionStack.back();
+                auto it =
+                    std::find_if(   parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+                if( it == parentNode.childSections.end() ) {
+                    node = std::make_shared<SectionNode>( incompleteStats );
+                    parentNode.childSections.push_back( node );
+                }
+                else
+                    node = *it;
+            }
+            m_sectionStack.push_back( node );
+            m_deepestSection = std::move(node);
+        }
+
+        void assertionStarting(AssertionInfo const&) override {}
+
+        bool assertionEnded(AssertionStats const& assertionStats) override {
+            assert(!m_sectionStack.empty());
+            // AssertionResult holds a pointer to a temporary DecomposedExpression,
+            // which getExpandedExpression() calls to build the expression string.
+            // Our section stack copy of the assertionResult will likely outlive the
+            // temporary, so it must be expanded or discarded now to avoid calling
+            // a destroyed object later.
+            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
+            SectionNode& sectionNode = *m_sectionStack.back();
+            sectionNode.assertions.push_back(assertionStats);
+            return true;
+        }
+        void sectionEnded(SectionStats const& sectionStats) override {
+            assert(!m_sectionStack.empty());
+            SectionNode& node = *m_sectionStack.back();
+            node.stats = sectionStats;
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& testCaseStats) override {
+            auto node = std::make_shared<TestCaseNode>(testCaseStats);
+            assert(m_sectionStack.size() == 0);
+            node->children.push_back(m_rootSection);
+            m_testCases.push_back(node);
+            m_rootSection.reset();
+
+            assert(m_deepestSection);
+            m_deepestSection->stdOut = testCaseStats.stdOut;
+            m_deepestSection->stdErr = testCaseStats.stdErr;
+        }
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            auto node = std::make_shared<TestGroupNode>(testGroupStats);
+            node->children.swap(m_testCases);
+            m_testGroups.push_back(node);
+        }
+        void testRunEnded(TestRunStats const& testRunStats) override {
+            auto node = std::make_shared<TestRunNode>(testRunStats);
+            node->children.swap(m_testGroups);
+            m_testRuns.push_back(node);
+            testRunEndedCumulative();
+        }
+        virtual void testRunEndedCumulative() = 0;
+
+        void skipTest(TestCaseInfo const&) override {}
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+        std::vector<AssertionStats> m_assertions;
+        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
+        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
+        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
+
+        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
+
+        std::shared_ptr<SectionNode> m_rootSection;
+        std::shared_ptr<SectionNode> m_deepestSection;
+        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<char C>
+    char const* getLineOfChars() {
+        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+        if( !*line ) {
+            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+        }
+        return line;
+    }
+
+    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
+        TestEventListenerBase( ReporterConfig const& _config );
+
+        static std::set<Verbosity> getSupportedVerbosities();
+
+        void assertionStarting(AssertionInfo const&) override;
+        bool assertionEnded(AssertionStats const&) override;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_bases.hpp
+// start catch_console_colour.h
+
+namespace Catch {
+
+    struct Colour {
+        enum Code {
+            None = 0,
+
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
+
+            Bright = 0x10,
+
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
+            BrightYellow = Bright | Yellow,
+
+            // By intention
+            FileName = LightGrey,
+            Warning = BrightYellow,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            ResultExpectedFailure = Warning,
+
+            Error = BrightRed,
+            Success = Green,
+
+            OriginalExpression = Cyan,
+            ReconstructedExpression = BrightYellow,
+
+            SecondaryText = LightGrey,
+            Headers = White
+        };
+
+        // Use constructed object for RAII guard
+        Colour( Code _colourCode );
+        Colour( Colour&& other ) noexcept;
+        Colour& operator=( Colour&& other ) noexcept;
+        ~Colour();
+
+        // Use static method for one-shot changes
+        static void use( Code _colourCode );
+
+    private:
+        bool m_moved = false;
+    };
+
+    std::ostream& operator << ( std::ostream& os, Colour const& );
+
+} // end namespace Catch
+
+// end catch_console_colour.h
+// start catch_reporter_registrars.hpp
+
+
+namespace Catch {
+
+    template<typename T>
+    class ReporterRegistrar {
+
+        class ReporterFactory : public IReporterFactory {
+
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
+            }
+
+            std::string getDescription() const override {
+                return T::getDescription();
+            }
+        };
+
+    public:
+
+        explicit ReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
+        }
+    };
+
+    template<typename T>
+    class ListenerRegistrar {
+
+        class ListenerFactory : public IReporterFactory {
+
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
+            }
+            std::string getDescription() const override {
+                return std::string();
+            }
+        };
+
+    public:
+
+        ListenerRegistrar() {
+            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
+        }
+    };
+}
+
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#define CATCH_REGISTER_REPORTER( name, reporterType ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION         \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
+    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#define CATCH_REGISTER_LISTENER( listenerType ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION   \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS    \
+    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#else // CATCH_CONFIG_DISABLE
+
+#define CATCH_REGISTER_REPORTER(name, reporterType)
+#define CATCH_REGISTER_LISTENER(listenerType)
+
+#endif // CATCH_CONFIG_DISABLE
+
+// end catch_reporter_registrars.hpp
+// Allow users to base their work off existing reporters
+// start catch_reporter_compact.h
+
+namespace Catch {
+
+    struct CompactReporter : StreamingReporterBase<CompactReporter> {
+
+        using StreamingReporterBase::StreamingReporterBase;
+
+        ~CompactReporter() override;
+
+        static std::string getDescription();
+
+        ReporterPreferences getPreferences() const override;
+
+        void noMatchingTestCases(std::string const& spec) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_compact.h
+// start catch_reporter_console.h
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
+
+namespace Catch {
+    // Fwd decls
+    struct SummaryColumn;
+    class TablePrinter;
+
+    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
+        std::unique_ptr<TablePrinter> m_tablePrinter;
+
+        ConsoleReporter(ReporterConfig const& config);
+        ~ConsoleReporter() override;
+        static std::string getDescription();
+
+        void noMatchingTestCases(std::string const& spec) override;
+
+        void reportInvalidArguments(std::string const&arg) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionStarting(SectionInfo const& _sectionInfo) override;
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const& info) override;
+        void benchmarkEnded(BenchmarkStats<> const& stats) override;
+        void benchmarkFailed(std::string const& error) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+        void testRunStarting(TestRunInfo const& _testRunInfo) override;
+    private:
+
+        void lazyPrint();
+
+        void lazyPrintWithoutClosingBenchmarkTable();
+        void lazyPrintRunInfo();
+        void lazyPrintGroupInfo();
+        void printTestCaseAndSectionHeader();
+
+        void printClosedHeader(std::string const& _name);
+        void printOpenHeader(std::string const& _name);
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString(std::string const& _string, std::size_t indent = 0);
+
+        void printTotals(Totals const& totals);
+        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
+
+        void printTotalsDivider(Totals const& totals);
+        void printSummaryDivider();
+        void printTestFilters();
+
+    private:
+        bool m_headerPrinted = false;
+    };
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+// end catch_reporter_console.h
+// start catch_reporter_junit.h
+
+// start catch_xmlwriter.h
+
+#include <vector>
+
+namespace Catch {
+    enum class XmlFormatting {
+        None = 0x00,
+        Indent = 0x01,
+        Newline = 0x02,
+    };
+
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
+
+    class XmlEncode {
+    public:
+        enum ForWhat { ForTextNodes, ForAttributes };
+
+        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
+
+        void encodeTo( std::ostream& os ) const;
+
+        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+
+    private:
+        std::string m_str;
+        ForWhat m_forWhat;
+    };
+
+    class XmlWriter {
+    public:
+
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
+
+            ScopedElement( ScopedElement&& other ) noexcept;
+            ScopedElement& operator=( ScopedElement&& other ) noexcept;
+
+            ~ScopedElement();
+
+            ScopedElement& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent );
+
+            template<typename T>
+            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
+
+        private:
+            mutable XmlWriter* m_writer = nullptr;
+            XmlFormatting m_fmt;
+        };
+
+        XmlWriter( std::ostream& os = Catch::cout() );
+        ~XmlWriter();
+
+        XmlWriter( XmlWriter const& ) = delete;
+        XmlWriter& operator=( XmlWriter const& ) = delete;
+
+        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
+
+        XmlWriter& writeAttribute( std::string const& name, bool attribute );
+
+        template<typename T>
+        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+            ReusableStringStream rss;
+            rss << attribute;
+            return writeAttribute( name, rss.str() );
+        }
+
+        XmlWriter& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& writeComment(std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        void writeStylesheetRef( std::string const& url );
+
+        XmlWriter& writeBlankLine();
+
+        void ensureTagClosed();
+
+    private:
+
+        void applyFormatting(XmlFormatting fmt);
+
+        void writeDeclaration();
+
+        void newlineIfNecessary();
+
+        bool m_tagIsOpen = false;
+        bool m_needsNewline = false;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream& m_os;
+    };
+
+}
+
+// end catch_xmlwriter.h
+namespace Catch {
+
+    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
+    public:
+        JunitReporter(ReporterConfig const& _config);
+
+        ~JunitReporter() override;
+
+        static std::string getDescription();
+
+        void noMatchingTestCases(std::string const& /*spec*/) override;
+
+        void testRunStarting(TestRunInfo const& runInfo) override;
+
+        void testGroupStarting(GroupInfo const& groupInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
+        bool assertionEnded(AssertionStats const& assertionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+
+        void testRunEndedCumulative() override;
+
+        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
+
+        void writeTestCase(TestCaseNode const& testCaseNode);
+
+        void writeSection(std::string const& className,
+                          std::string const& rootName,
+                          SectionNode const& sectionNode);
+
+        void writeAssertions(SectionNode const& sectionNode);
+        void writeAssertion(AssertionStats const& stats);
+
+        XmlWriter xml;
+        Timer suiteTimer;
+        std::string stdOutForSuite;
+        std::string stdErrForSuite;
+        unsigned int unexpectedExceptions = 0;
+        bool m_okToFail = false;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_junit.h
+// start catch_reporter_xml.h
+
+namespace Catch {
+    class XmlReporter : public StreamingReporterBase<XmlReporter> {
+    public:
+        XmlReporter(ReporterConfig const& _config);
+
+        ~XmlReporter() override;
+
+        static std::string getDescription();
+
+        virtual std::string getStylesheetRef() const;
+
+        void writeSourceInfo(SourceLineInfo const& sourceInfo);
+
+    public: // StreamingReporterBase
+
+        void noMatchingTestCases(std::string const& s) override;
+
+        void testRunStarting(TestRunInfo const& testInfo) override;
+
+        void testGroupStarting(GroupInfo const& groupInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testInfo) override;
+
+        void sectionStarting(SectionInfo const& sectionInfo) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& assertionStats) override;
+
+        void sectionEnded(SectionStats const& sectionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+
+        void testRunEnded(TestRunStats const& testRunStats) override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const&) override;
+        void benchmarkEnded(BenchmarkStats<> const&) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    private:
+        Timer m_testCaseTimer;
+        XmlWriter m_xml;
+        int m_sectionDepth = 0;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_xml.h
+
+// end catch_external_interfaces.h
+#endif
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_benchmarking_all.hpp
+
+// A proxy header that includes all of the benchmarking headers to allow
+// concise include of the benchmarking features. You should prefer the
+// individual includes in standard use.
+
+// start catch_benchmark.hpp
+
+ // Benchmark
+
+// start catch_chronometer.hpp
+
+// User-facing chronometer
+
+
+// start catch_clock.hpp
+
+// Clocks
+
+
+#include <chrono>
+#include <ratio>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Clock>
+        using ClockDuration = typename Clock::duration;
+        template <typename Clock>
+        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
+
+        template <typename Clock>
+        using TimePoint = typename Clock::time_point;
+
+        using default_clock = std::chrono::steady_clock;
+
+        template <typename Clock>
+        struct now {
+            TimePoint<Clock> operator()() const {
+                return Clock::now();
+            }
+        };
+
+        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_clock.hpp
+// start catch_optimizer.hpp
+
+ // Hinting the optimizer
+
+
+#if defined(_MSC_VER)
+#   include <atomic> // atomic_thread_fence
+#endif
+
+namespace Catch {
+    namespace Benchmark {
+#if defined(__GNUC__) || defined(__clang__)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            asm volatile("" : : "g"(p) : "memory");
+        }
+        inline void keep_memory() {
+            asm volatile("" : : : "memory");
+        }
+
+        namespace Detail {
+            inline void optimizer_barrier() { keep_memory(); }
+        } // namespace Detail
+#elif defined(_MSC_VER)
+
+#pragma optimize("", off)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            // thanks @milleniumbug
+            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
+        }
+        // TODO equivalent keep_memory()
+#pragma optimize("", on)
+
+        namespace Detail {
+            inline void optimizer_barrier() {
+                std::atomic_thread_fence(std::memory_order_seq_cst);
+            }
+        } // namespace Detail
+
+#endif
+
+        template <typename T>
+        inline void deoptimize_value(T&& x) {
+            keep_memory(&x);
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
+            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
+            std::forward<Fn>(fn) (std::forward<Args...>(args...));
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_optimizer.hpp
+// start catch_complete_invoke.hpp
+
+// Invoke with a special case for void
+
+
+#include <type_traits>
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            struct CompleteType { using type = T; };
+            template <>
+            struct CompleteType<void> { struct type {}; };
+
+            template <typename T>
+            using CompleteType_t = typename CompleteType<T>::type;
+
+            template <typename Result>
+            struct CompleteInvoker {
+                template <typename Fun, typename... Args>
+                static Result invoke(Fun&& fun, Args&&... args) {
+                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                }
+            };
+            template <>
+            struct CompleteInvoker<void> {
+                template <typename Fun, typename... Args>
+                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
+                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                    return {};
+                }
+            };
+            template <typename Sig>
+            using ResultOf_t = typename std::result_of<Sig>::type;
+
+            // invoke and not return void :(
+            template <typename Fun, typename... Args>
+            CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun&& fun, Args&&... args) {
+                return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
+            }
+
+            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
+        } // namespace Detail
+
+        template <typename Fun>
+        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
+            CATCH_TRY{
+                return Detail::complete_invoke(std::forward<Fun>(fun));
+            } CATCH_CATCH_ALL{
+                getResultCapture().benchmarkFailed(translateActiveException());
+                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
+            }
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_complete_invoke.hpp
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct ChronometerConcept {
+                virtual void start() = 0;
+                virtual void finish() = 0;
+                virtual ~ChronometerConcept() = default;
+            };
+            template <typename Clock>
+            struct ChronometerModel final : public ChronometerConcept {
+                void start() override { started = Clock::now(); }
+                void finish() override { finished = Clock::now(); }
+
+                ClockDuration<Clock> elapsed() const { return finished - started; }
+
+                TimePoint<Clock> started;
+                TimePoint<Clock> finished;
+            };
+        } // namespace Detail
+
+        struct Chronometer {
+        public:
+            template <typename Fun>
+            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
+
+            int runs() const { return k; }
+
+            Chronometer(Detail::ChronometerConcept& meter, int k)
+                : impl(&meter)
+                , k(k) {}
+
+        private:
+            template <typename Fun>
+            void measure(Fun&& fun, std::false_type) {
+                measure([&fun](int) { return fun(); }, std::true_type());
+            }
+
+            template <typename Fun>
+            void measure(Fun&& fun, std::true_type) {
+                Detail::optimizer_barrier();
+                impl->start();
+                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
+                impl->finish();
+                Detail::optimizer_barrier();
+            }
+
+            Detail::ChronometerConcept* impl;
+            int k;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_chronometer.hpp
+// start catch_environment.hpp
+
+// Environment information
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct EnvironmentEstimate {
+            Duration mean;
+            OutlierClassification outliers;
+
+            template <typename Duration2>
+            operator EnvironmentEstimate<Duration2>() const {
+                return { mean, outliers };
+            }
+        };
+        template <typename Clock>
+        struct Environment {
+            using clock_type = Clock;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_environment.hpp
+// start catch_execution_plan.hpp
+
+ // Execution plan
+
+
+// start catch_benchmark_function.hpp
+
+ // Dumb std::function implementation for consistent call overhead
+
+
+#include <cassert>
+#include <type_traits>
+#include <utility>
+#include <memory>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            using Decay = typename std::decay<T>::type;
+            template <typename T, typename U>
+            struct is_related
+                : std::is_same<Decay<T>, Decay<U>> {};
+
+            /// We need to reinvent std::function because every piece of code that might add overhead
+            /// in a measurement context needs to have consistent performance characteristics so that we
+            /// can account for it in the measurement.
+            /// Implementations of std::function with optimizations that aren't always applicable, like
+            /// small buffer optimizations, are not uncommon.
+            /// This is effectively an implementation of std::function without any such optimizations;
+            /// it may be slow, but it is consistently slow.
+            struct BenchmarkFunction {
+            private:
+                struct callable {
+                    virtual void call(Chronometer meter) const = 0;
+                    virtual callable* clone() const = 0;
+                    virtual ~callable() = default;
+                };
+                template <typename Fun>
+                struct model : public callable {
+                    model(Fun&& fun) : fun(std::move(fun)) {}
+                    model(Fun const& fun) : fun(fun) {}
+
+                    model<Fun>* clone() const override { return new model<Fun>(*this); }
+
+                    void call(Chronometer meter) const override {
+                        call(meter, is_callable<Fun(Chronometer)>());
+                    }
+                    void call(Chronometer meter, std::true_type) const {
+                        fun(meter);
+                    }
+                    void call(Chronometer meter, std::false_type) const {
+                        meter.measure(fun);
+                    }
+
+                    Fun fun;
+                };
+
+                struct do_nothing { void operator()() const {} };
+
+                template <typename T>
+                BenchmarkFunction(model<T>* c) : f(c) {}
+
+            public:
+                BenchmarkFunction()
+                    : f(new model<do_nothing>{ {} }) {}
+
+                template <typename Fun,
+                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
+                    BenchmarkFunction(Fun&& fun)
+                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
+
+                BenchmarkFunction(BenchmarkFunction&& that)
+                    : f(std::move(that.f)) {}
+
+                BenchmarkFunction(BenchmarkFunction const& that)
+                    : f(that.f->clone()) {}
+
+                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
+                    f = std::move(that.f);
+                    return *this;
+                }
+
+                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
+                    f.reset(that.f->clone());
+                    return *this;
+                }
+
+                void operator()(Chronometer meter) const { f->call(meter); }
+
+            private:
+                std::unique_ptr<callable> f;
+            };
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_benchmark_function.hpp
+// start catch_repeat.hpp
+
+// repeat algorithm
+
+
+#include <type_traits>
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Fun>
+            struct repeater {
+                void operator()(int k) const {
+                    for (int i = 0; i < k; ++i) {
+                        fun();
+                    }
+                }
+                Fun fun;
+            };
+            template <typename Fun>
+            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
+                return { std::forward<Fun>(fun) };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_repeat.hpp
+// start catch_run_for_at_least.hpp
+
+// Run a function for a minimum amount of time
+
+
+// start catch_measure.hpp
+
+// Measure
+
+
+// start catch_timing.hpp
+
+// Timing
+
+
+#include <tuple>
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration, typename Result>
+        struct Timing {
+            Duration elapsed;
+            Result result;
+            int iterations;
+        };
+        template <typename Clock, typename Sig>
+        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_timing.hpp
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun, typename... Args>
+            TimingOf<Clock, Fun(Args...)> measure(Fun&& fun, Args&&... args) {
+                auto start = Clock::now();
+                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
+                auto end = Clock::now();
+                auto delta = end - start;
+                return { delta, std::forward<decltype(r)>(r), 1 };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_measure.hpp
+#include <utility>
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(int)> measure_one(Fun&& fun, int iters, std::false_type) {
+                return Detail::measure<Clock>(fun, iters);
+            }
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(Chronometer)> measure_one(Fun&& fun, int iters, std::true_type) {
+                Detail::ChronometerModel<Clock> meter;
+                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
+
+                return { meter.elapsed(), std::move(result), iters };
+            }
+
+            template <typename Clock, typename Fun>
+            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
+
+            struct optimized_away_error : std::exception {
+                const char* what() const noexcept override {
+                    return "could not measure benchmark, maybe it was optimized away";
+                }
+            };
+
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
+                auto iters = seed;
+                while (iters < (1 << 30)) {
+                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
+
+                    if (Timing.elapsed >= how_long) {
+                        return { Timing.elapsed, std::move(Timing.result), iters };
+                    }
+                    iters *= 2;
+                }
+                throw optimized_away_error{};
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_run_for_at_least.hpp
+#include <algorithm>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct ExecutionPlan {
+            int iterations_per_sample;
+            Duration estimated_duration;
+            Detail::BenchmarkFunction benchmark;
+            Duration warmup_time;
+            int warmup_iterations;
+
+            template <typename Duration2>
+            operator ExecutionPlan<Duration2>() const {
+                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
+            }
+
+            template <typename Clock>
+            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                // warmup a bit
+                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
+
+                std::vector<FloatDuration<Clock>> times;
+                times.reserve(cfg.benchmarkSamples());
+                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
+                    Detail::ChronometerModel<Clock> model;
+                    this->benchmark(Chronometer(model, iterations_per_sample));
+                    auto sample_time = model.elapsed() - env.clock_cost.mean;
+                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
+                    return sample_time / iterations_per_sample;
+                });
+                return times;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_execution_plan.hpp
+// start catch_estimate_clock.hpp
+
+ // Environment measurement
+
+
+// start catch_stats.hpp
+
+// Statistical analysis tools
+
+
+#include <algorithm>
+#include <functional>
+#include <vector>
+#include <iterator>
+#include <numeric>
+#include <tuple>
+#include <cmath>
+#include <utility>
+#include <cstddef>
+#include <random>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            using sample = std::vector<double>;
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
+
+            template <typename Iterator>
+            OutlierClassification classify_outliers(Iterator first, Iterator last) {
+                std::vector<double> copy(first, last);
+
+                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
+                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
+                auto iqr = q3 - q1;
+                auto los = q1 - (iqr * 3.);
+                auto lom = q1 - (iqr * 1.5);
+                auto him = q3 + (iqr * 1.5);
+                auto his = q3 + (iqr * 3.);
+
+                OutlierClassification o;
+                for (; first != last; ++first) {
+                    auto&& t = *first;
+                    if (t < los) ++o.low_severe;
+                    else if (t < lom) ++o.low_mild;
+                    else if (t > his) ++o.high_severe;
+                    else if (t > him) ++o.high_mild;
+                    ++o.samples_seen;
+                }
+                return o;
+            }
+
+            template <typename Iterator>
+            double mean(Iterator first, Iterator last) {
+                auto count = last - first;
+                double sum = std::accumulate(first, last, 0.);
+                return sum / count;
+            }
+
+            template <typename URng, typename Iterator, typename Estimator>
+            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
+                auto n = last - first;
+                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
+
+                sample out;
+                out.reserve(resamples);
+                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
+                    std::vector<double> resampled;
+                    resampled.reserve(n);
+                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
+                    return estimator(resampled.begin(), resampled.end());
+                });
+                std::sort(out.begin(), out.end());
+                return out;
+            }
+
+            template <typename Estimator, typename Iterator>
+            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
+                auto n = last - first;
+                auto second = std::next(first);
+                sample results;
+                results.reserve(n);
+
+                for (auto it = first; it != last; ++it) {
+                    std::iter_swap(it, first);
+                    results.push_back(estimator(second, last));
+                }
+
+                return results;
+            }
+
+            inline double normal_cdf(double x) {
+                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
+            }
+
+            double erfc_inv(double x);
+
+            double normal_quantile(double p);
+
+            template <typename Iterator, typename Estimator>
+            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
+                auto n_samples = last - first;
+
+                double point = estimator(first, last);
+                // Degenerate case with a single sample
+                if (n_samples == 1) return { point, point, point, confidence_level };
+
+                sample jack = jackknife(estimator, first, last);
+                double jack_mean = mean(jack.begin(), jack.end());
+                double sum_squares, sum_cubes;
+                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
+                    auto d = jack_mean - x;
+                    auto d2 = d * d;
+                    auto d3 = d2 * d;
+                    return { sqcb.first + d2, sqcb.second + d3 };
+                });
+
+                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
+                int n = static_cast<int>(resample.size());
+                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
+                // degenerate case with uniform samples
+                if (prob_n == 0) return { point, point, point, confidence_level };
+
+                double bias = normal_quantile(prob_n);
+                double z1 = normal_quantile((1. - confidence_level) / 2.);
+
+                auto cumn = [n](double x) -> int {
+                    return std::lround(normal_cdf(x) * n); };
+                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
+                double b1 = bias + z1;
+                double b2 = bias - z1;
+                double a1 = a(b1);
+                double a2 = a(b2);
+                auto lo = std::max(cumn(a1), 0);
+                auto hi = std::min(cumn(a2), n - 1);
+
+                return { point, resample[lo], resample[hi], confidence_level };
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
+
+            struct bootstrap_analysis {
+                Estimate<double> mean;
+                Estimate<double> standard_deviation;
+                double outlier_variance;
+            };
+
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_stats.hpp
+#include <algorithm>
+#include <iterator>
+#include <tuple>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock>
+            std::vector<double> resolution(int k) {
+                std::vector<TimePoint<Clock>> times;
+                times.reserve(k + 1);
+                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
+
+                std::vector<double> deltas;
+                deltas.reserve(k);
+                std::transform(std::next(times.begin()), times.end(), times.begin(),
+                    std::back_inserter(deltas),
+                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
+
+                return deltas;
+            }
+
+            const auto warmup_iterations = 10000;
+            const auto warmup_time = std::chrono::milliseconds(100);
+            const auto minimum_ticks = 1000;
+            const auto warmup_seed = 10000;
+            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+            const auto clock_cost_estimation_tick_limit = 100000;
+            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+            const auto clock_cost_estimation_iterations = 10000;
+
+            template <typename Clock>
+            int warmup() {
+                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
+                    .iterations;
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
+                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
+                    .result;
+                return {
+                    FloatDuration<Clock>(mean(r.begin(), r.end())),
+                    classify_outliers(r.begin(), r.end()),
+                };
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
+                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));
+                auto time_clock = [](int k) {
+                    return Detail::measure<Clock>([k] {
+                        for (int i = 0; i < k; ++i) {
+                            volatile auto ignored = Clock::now();
+                            (void)ignored;
+                        }
+                    }).elapsed;
+                };
+                time_clock(1);
+                int iters = clock_cost_estimation_iterations;
+                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
+                std::vector<double> times;
+                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
+                times.reserve(nsamples);
+                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
+                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
+                });
+                return {
+                    FloatDuration<Clock>(mean(times.begin(), times.end())),
+                    classify_outliers(times.begin(), times.end()),
+                };
+            }
+
+            template <typename Clock>
+            Environment<FloatDuration<Clock>> measure_environment() {
+                static Environment<FloatDuration<Clock>>* env = nullptr;
+                if (env) {
+                    return *env;
+                }
+
+                auto iters = Detail::warmup<Clock>();
+                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
+                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
+
+                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
+                return *env;
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_estimate_clock.hpp
+// start catch_analyse.hpp
+
+ // Run and analyse one benchmark
+
+
+// start catch_sample_analysis.hpp
+
+// Benchmark results
+
+
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <iterator>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct SampleAnalysis {
+            std::vector<Duration> samples;
+            Estimate<Duration> mean;
+            Estimate<Duration> standard_deviation;
+            OutlierClassification outliers;
+            double outlier_variance;
+
+            template <typename Duration2>
+            operator SampleAnalysis<Duration2>() const {
+                std::vector<Duration2> samples2;
+                samples2.reserve(samples.size());
+                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+                return {
+                    std::move(samples2),
+                    mean,
+                    standard_deviation,
+                    outliers,
+                    outlier_variance,
+                };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_sample_analysis.hpp
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Duration, typename Iterator>
+            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
+                if (!cfg.benchmarkNoAnalysis()) {
+                    std::vector<double> samples;
+                    samples.reserve(last - first);
+                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
+
+                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
+                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
+
+                    auto wrap_estimate = [](Estimate<double> e) {
+                        return Estimate<Duration> {
+                            Duration(e.point),
+                                Duration(e.lower_bound),
+                                Duration(e.upper_bound),
+                                e.confidence_interval,
+                        };
+                    };
+                    std::vector<Duration> samples2;
+                    samples2.reserve(samples.size());
+                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
+                    return {
+                        std::move(samples2),
+                        wrap_estimate(analysis.mean),
+                        wrap_estimate(analysis.standard_deviation),
+                        outliers,
+                        analysis.outlier_variance,
+                    };
+                } else {
+                    std::vector<Duration> samples;
+                    samples.reserve(last - first);
+
+                    Duration mean = Duration(0);
+                    int i = 0;
+                    for (auto it = first; it < last; ++it, ++i) {
+                        samples.push_back(Duration(*it));
+                        mean += Duration(*it);
+                    }
+                    mean /= i;
+
+                    return {
+                        std::move(samples),
+                        Estimate<Duration>{mean, mean, mean, 0.0},
+                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
+                        OutlierClassification{},
+                        0.0
+                    };
+                }
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_analyse.hpp
+#include <algorithm>
+#include <functional>
+#include <string>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        struct Benchmark {
+            Benchmark(std::string &&name)
+                : name(std::move(name)) {}
+
+            template <class FUN>
+            Benchmark(std::string &&name, FUN &&func)
+                : fun(std::move(func)), name(std::move(name)) {}
+
+            template <typename Clock>
+            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
+                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
+                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
+                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+            }
+
+            template <typename Clock = default_clock>
+            void run() {
+                IConfigPtr cfg = getCurrentContext().getConfig();
+
+                auto env = Detail::measure_environment<Clock>();
+
+                getResultCapture().benchmarkPreparing(name);
+                CATCH_TRY{
+                    auto plan = user_code([&] {
+                        return prepare<Clock>(*cfg, env);
+                    });
+
+                    BenchmarkInfo info {
+                        name,
+                        plan.estimated_duration.count(),
+                        plan.iterations_per_sample,
+                        cfg->benchmarkSamples(),
+                        cfg->benchmarkResamples(),
+                        env.clock_resolution.mean.count(),
+                        env.clock_cost.mean.count()
+                    };
+
+                    getResultCapture().benchmarkStarting(info);
+
+                    auto samples = user_code([&] {
+                        return plan.template run<Clock>(*cfg, env);
+                    });
+
+                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
+                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    getResultCapture().benchmarkEnded(stats);
+
+                } CATCH_CATCH_ALL{
+                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
+                        std::rethrow_exception(std::current_exception());
+                }
+            }
+
+            // sets lambda to be used in fun *and* executes benchmark!
+            template <typename Fun,
+                typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
+                Benchmark & operator=(Fun func) {
+                fun = Detail::BenchmarkFunction(func);
+                run();
+                return *this;
+            }
+
+            explicit operator bool() {
+                return true;
+            }
+
+        private:
+            Detail::BenchmarkFunction fun;
+            std::string name;
+        };
+    }
+} // namespace Catch
+
+#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
+#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
+
+#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&](int benchmarkIndex)
+
+#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&]
+
+// end catch_benchmark.hpp
+// start catch_constructor.hpp
+
+// Constructor and destructor helpers
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T, bool Destruct>
+            struct ObjectStorage
+            {
+                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
+
+                ObjectStorage() : data() {}
+
+                ObjectStorage(const ObjectStorage& other)
+                {
+                    new(&data) T(other.stored_object());
+                }
+
+                ObjectStorage(ObjectStorage&& other)
+                {
+                    new(&data) T(std::move(other.stored_object()));
+                }
+
+                ~ObjectStorage() { destruct_on_exit<T>(); }
+
+                template <typename... Args>
+                void construct(Args&&... args)
+                {
+                    new (&data) T(std::forward<Args>(args)...);
+                }
+
+                template <bool AllowManualDestruction = !Destruct>
+                typename std::enable_if<AllowManualDestruction>::type destruct()
+                {
+                    stored_object().~T();
+                }
+
+            private:
+                // If this is a constructor benchmark, destruct the underlying object
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
+                // Otherwise, don't
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
+
+                T& stored_object() {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
+
+                T const& stored_object() const {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
+
+                TStorage data;
+            };
+        }
+
+        template <typename T>
+        using storage_for = Detail::ObjectStorage<T, true>;
+
+        template <typename T>
+        using destructable_object = Detail::ObjectStorage<T, false>;
+    }
+}
+
+// end catch_constructor.hpp
+// end catch_benchmarking_all.hpp
+#endif
+
+#endif // ! CATCH_CONFIG_IMPL_ONLY
+
+#ifdef CATCH_IMPL
+// start catch_impl.hpp
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+// Keep these here for external reporters
+// start catch_test_case_tracker.h
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    struct NameAndLocation {
+        std::string name;
+        SourceLineInfo location;
+
+        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
+    };
+
+    struct ITracker;
+
+    using ITrackerPtr = std::shared_ptr<ITracker>;
+
+    struct ITracker {
+        virtual ~ITracker();
+
+        // static queries
+        virtual NameAndLocation const& nameAndLocation() const = 0;
+
+        // dynamic queries
+        virtual bool isComplete() const = 0; // Successfully completed or failed
+        virtual bool isSuccessfullyCompleted() const = 0;
+        virtual bool isOpen() const = 0; // Started but not complete
+        virtual bool hasChildren() const = 0;
+
+        virtual ITracker& parent() = 0;
+
+        // actions
+        virtual void close() = 0; // Successfully complete
+        virtual void fail() = 0;
+        virtual void markAsNeedingAnotherRun() = 0;
+
+        virtual void addChild( ITrackerPtr const& child ) = 0;
+        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
+        virtual void openChild() = 0;
+
+        // Debug/ checking
+        virtual bool isSectionTracker() const = 0;
+        virtual bool isGeneratorTracker() const = 0;
+    };
+
+    class TrackerContext {
+
+        enum RunState {
+            NotStarted,
+            Executing,
+            CompletedCycle
+        };
+
+        ITrackerPtr m_rootTracker;
+        ITracker* m_currentTracker = nullptr;
+        RunState m_runState = NotStarted;
+
+    public:
+
+        ITracker& startRun();
+        void endRun();
+
+        void startCycle();
+        void completeCycle();
+
+        bool completedCycle() const;
+        ITracker& currentTracker();
+        void setCurrentTracker( ITracker* tracker );
+    };
+
+    class TrackerBase : public ITracker {
+    protected:
+        enum CycleState {
+            NotStarted,
+            Executing,
+            ExecutingChildren,
+            NeedsAnotherRun,
+            CompletedSuccessfully,
+            Failed
+        };
+
+        using Children = std::vector<ITrackerPtr>;
+        NameAndLocation m_nameAndLocation;
+        TrackerContext& m_ctx;
+        ITracker* m_parent;
+        Children m_children;
+        CycleState m_runState = NotStarted;
+
+    public:
+        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+        NameAndLocation const& nameAndLocation() const override;
+        bool isComplete() const override;
+        bool isSuccessfullyCompleted() const override;
+        bool isOpen() const override;
+        bool hasChildren() const override;
+
+        void addChild( ITrackerPtr const& child ) override;
+
+        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
+        ITracker& parent() override;
+
+        void openChild() override;
+
+        bool isSectionTracker() const override;
+        bool isGeneratorTracker() const override;
+
+        void open();
+
+        void close() override;
+        void fail() override;
+        void markAsNeedingAnotherRun() override;
+
+    private:
+        void moveToParent();
+        void moveToThis();
+    };
+
+    class SectionTracker : public TrackerBase {
+        std::vector<std::string> m_filters;
+        std::string m_trimmed_name;
+    public:
+        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+        bool isSectionTracker() const override;
+
+        bool isComplete() const override;
+
+        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
+
+        void tryOpen();
+
+        void addInitialFilters( std::vector<std::string> const& filters );
+        void addNextFilters( std::vector<std::string> const& filters );
+    };
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+
+} // namespace Catch
+
+// end catch_test_case_tracker.h
+
+// start catch_leak_detector.h
+
+namespace Catch {
+
+    struct LeakDetector {
+        LeakDetector();
+        ~LeakDetector();
+    };
+
+}
+// end catch_leak_detector.h
+// Cpp files will be included in the single-header file here
+// start catch_stats.cpp
+
+// Statistical analysis tools
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+
+#include <cassert>
+#include <random>
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <future>
+#endif
+
+namespace {
+    double erf_inv(double x) {
+        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
+        double w, p;
+
+        w = -log((1.0 - x) * (1.0 + x));
+
+        if (w < 6.250000) {
+            w = w - 3.125000;
+            p = -3.6444120640178196996e-21;
+            p = -1.685059138182016589e-19 + p * w;
+            p = 1.2858480715256400167e-18 + p * w;
+            p = 1.115787767802518096e-17 + p * w;
+            p = -1.333171662854620906e-16 + p * w;
+            p = 2.0972767875968561637e-17 + p * w;
+            p = 6.6376381343583238325e-15 + p * w;
+            p = -4.0545662729752068639e-14 + p * w;
+            p = -8.1519341976054721522e-14 + p * w;
+            p = 2.6335093153082322977e-12 + p * w;
+            p = -1.2975133253453532498e-11 + p * w;
+            p = -5.4154120542946279317e-11 + p * w;
+            p = 1.051212273321532285e-09 + p * w;
+            p = -4.1126339803469836976e-09 + p * w;
+            p = -2.9070369957882005086e-08 + p * w;
+            p = 4.2347877827932403518e-07 + p * w;
+            p = -1.3654692000834678645e-06 + p * w;
+            p = -1.3882523362786468719e-05 + p * w;
+            p = 0.0001867342080340571352 + p * w;
+            p = -0.00074070253416626697512 + p * w;
+            p = -0.0060336708714301490533 + p * w;
+            p = 0.24015818242558961693 + p * w;
+            p = 1.6536545626831027356 + p * w;
+        } else if (w < 16.000000) {
+            w = sqrt(w) - 3.250000;
+            p = 2.2137376921775787049e-09;
+            p = 9.0756561938885390979e-08 + p * w;
+            p = -2.7517406297064545428e-07 + p * w;
+            p = 1.8239629214389227755e-08 + p * w;
+            p = 1.5027403968909827627e-06 + p * w;
+            p = -4.013867526981545969e-06 + p * w;
+            p = 2.9234449089955446044e-06 + p * w;
+            p = 1.2475304481671778723e-05 + p * w;
+            p = -4.7318229009055733981e-05 + p * w;
+            p = 6.8284851459573175448e-05 + p * w;
+            p = 2.4031110387097893999e-05 + p * w;
+            p = -0.0003550375203628474796 + p * w;
+            p = 0.00095328937973738049703 + p * w;
+            p = -0.0016882755560235047313 + p * w;
+            p = 0.0024914420961078508066 + p * w;
+            p = -0.0037512085075692412107 + p * w;
+            p = 0.005370914553590063617 + p * w;
+            p = 1.0052589676941592334 + p * w;
+            p = 3.0838856104922207635 + p * w;
+        } else {
+            w = sqrt(w) - 5.000000;
+            p = -2.7109920616438573243e-11;
+            p = -2.5556418169965252055e-10 + p * w;
+            p = 1.5076572693500548083e-09 + p * w;
+            p = -3.7894654401267369937e-09 + p * w;
+            p = 7.6157012080783393804e-09 + p * w;
+            p = -1.4960026627149240478e-08 + p * w;
+            p = 2.9147953450901080826e-08 + p * w;
+            p = -6.7711997758452339498e-08 + p * w;
+            p = 2.2900482228026654717e-07 + p * w;
+            p = -9.9298272942317002539e-07 + p * w;
+            p = 4.5260625972231537039e-06 + p * w;
+            p = -1.9681778105531670567e-05 + p * w;
+            p = 7.5995277030017761139e-05 + p * w;
+            p = -0.00021503011930044477347 + p * w;
+            p = -0.00013871931833623122026 + p * w;
+            p = 1.0103004648645343977 + p * w;
+            p = 4.8499064014085844221 + p * w;
+        }
+        return p * x;
+    }
+
+    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
+        auto m = Catch::Benchmark::Detail::mean(first, last);
+        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
+            double diff = b - m;
+            return a + diff * diff;
+            }) / (last - first);
+            return std::sqrt(variance);
+    }
+
+}
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                auto count = last - first;
+                double idx = (count - 1) * k / static_cast<double>(q);
+                int j = static_cast<int>(idx);
+                double g = idx - j;
+                std::nth_element(first, first + j, last);
+                auto xj = first[j];
+                if (g == 0) return xj;
+
+                auto xj1 = *std::min_element(first + (j + 1), last);
+                return xj + g * (xj1 - xj);
+            }
+
+            double erfc_inv(double x) {
+                return erf_inv(1.0 - x);
+            }
+
+            double normal_quantile(double p) {
+                static const double ROOT_TWO = std::sqrt(2.0);
+
+                double result = 0.0;
+                assert(p >= 0 && p <= 1);
+                if (p < 0 || p > 1) {
+                    return result;
+                }
+
+                result = -erfc_inv(2.0 * p);
+                // result *= normal distribution standard deviation (1.0) * sqrt(2)
+                result *= /*sd * */ ROOT_TWO;
+                // result += normal disttribution mean (0)
+                return result;
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
+                double sb = stddev.point;
+                double mn = mean.point / n;
+                double mg_min = mn / 2.;
+                double sg = std::min(mg_min / 4., sb / std::sqrt(n));
+                double sg2 = sg * sg;
+                double sb2 = sb * sb;
+
+                auto c_max = [n, mn, sb2, sg2](double x) -> double {
+                    double k = mn - x;
+                    double d = k * k;
+                    double nd = n * d;
+                    double k0 = -n * nd;
+                    double k1 = sb2 - n * sg2 + nd;
+                    double det = k1 * k1 - 4 * sg2 * k0;
+                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
+                };
+
+                auto var_out = [n, sb2, sg2](double c) {
+                    double nc = n - c;
+                    return (nc / n) * (sb2 - nc * sg2);
+                };
+
+                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
+            }
+
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+                static std::random_device entropy;
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
+
+                auto mean = &Detail::mean<std::vector<double>::iterator>;
+                auto stddev = &standard_deviation;
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    return std::async(std::launch::async, [=] {
+                        std::mt19937 rng(seed);
+                        auto resampled = resample(rng, n_resamples, first, last, f);
+                        return bootstrap(confidence_level, first, last, resampled, f);
+                    });
+                };
+
+                auto mean_future = Estimate(mean);
+                auto stddev_future = Estimate(stddev);
+
+                auto mean_estimate = mean_future.get();
+                auto stddev_estimate = stddev_future.get();
+#else
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    std::mt19937 rng(seed);
+                    auto resampled = resample(rng, n_resamples, first, last, f);
+                    return bootstrap(confidence_level, first, last, resampled, f);
+                };
+
+                auto mean_estimate = Estimate(mean);
+                auto stddev_estimate = Estimate(stddev);
+#endif // CATCH_USE_ASYNC
+
+                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
+
+                return { mean_estimate, stddev_estimate, outlier_variance };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+// end catch_stats.cpp
+// start catch_approx.cpp
+
+#include <cmath>
+#include <limits>
+
+namespace {
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+}
+
+namespace Catch {
+namespace Detail {
+
+    Approx::Approx ( double value )
+    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
+        m_margin( 0.0 ),
+        m_scale( 0.0 ),
+        m_value( value )
+    {}
+
+    Approx Approx::custom() {
+        return Approx( 0 );
+    }
+
+    Approx Approx::operator-() const {
+        auto temp(*this);
+        temp.m_value = -temp.m_value;
+        return temp;
+    }
+
+    std::string Approx::toString() const {
+        ReusableStringStream rss;
+        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
+        return rss.str();
+    }
+
+    bool Approx::equalityComparisonImpl(const double other) const {
+        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
+        // Thanks to Richard Harris for his help refining the scaled margin value
+        return marginComparison(m_value, other, m_margin)
+            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
+    }
+
+    void Approx::setMargin(double newMargin) {
+        CATCH_ENFORCE(newMargin >= 0,
+            "Invalid Approx::margin: " << newMargin << '.'
+            << " Approx::Margin has to be non-negative.");
+        m_margin = newMargin;
+    }
+
+    void Approx::setEpsilon(double newEpsilon) {
+        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+            "Invalid Approx::epsilon: " << newEpsilon << '.'
+            << " Approx::epsilon has to be in [0, 1]");
+        m_epsilon = newEpsilon;
+    }
+
+} // end namespace Detail
+
+namespace literals {
+    Detail::Approx operator "" _a(long double val) {
+        return Detail::Approx(val);
+    }
+    Detail::Approx operator "" _a(unsigned long long val) {
+        return Detail::Approx(val);
+    }
+} // end namespace literals
+
+std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
+    return value.toString();
+}
+
+} // end namespace Catch
+// end catch_approx.cpp
+// start catch_assertionhandler.cpp
+
+// start catch_debugger.h
+
+namespace Catch {
+    bool isDebuggerActive();
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
+
+#elif defined(CATCH_PLATFORM_IPHONE)
+
+    // use inline assembler
+    #if defined(__i386__) || defined(__x86_64__)
+        #define CATCH_TRAP()  __asm__("int $3")
+    #elif defined(__aarch64__)
+        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
+    #elif defined(__arm__) && !defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
+    #elif defined(__arm__) &&  defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xde01")
+    #endif
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    // If we can use inline assembler, do it because this allows us to break
+    // directly at the location of the failing check instead of breaking inside
+    // raise() called from it, i.e. one stack frame below.
+    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
+    #else // Fall back to the generic way.
+        #include <signal.h>
+
+        #define CATCH_TRAP() raise(SIGTRAP)
+    #endif
+#elif defined(_MSC_VER)
+    #define CATCH_TRAP() __debugbreak()
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+    #define CATCH_TRAP() DebugBreak()
+#endif
+
+#ifndef CATCH_BREAK_INTO_DEBUGGER
+    #ifdef CATCH_TRAP
+        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
+    #else
+        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
+    #endif
+#endif
+
+// end catch_debugger.h
+// start catch_run_context.h
+
+// start catch_fatal_condition.h
+
+// start catch_windows_h_proxy.h
+
+
+#if defined(CATCH_PLATFORM_WINDOWS)
+
+#if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
+#  define CATCH_DEFINED_NOMINMAX
+#  define NOMINMAX
+#endif
+#if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
+#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+#endif
+
+#ifdef __AFXDLL
+#include <AfxWin.h>
+#else
+#include <windows.h>
+#endif
+
+#ifdef CATCH_DEFINED_NOMINMAX
+#  undef NOMINMAX
+#endif
+#ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN
+#  undef WIN32_LEAN_AND_MEAN
+#endif
+
+#endif // defined(CATCH_PLATFORM_WINDOWS)
+
+// end catch_windows_h_proxy.h
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+
+    struct FatalConditionHandler {
+
+        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
+        FatalConditionHandler();
+        static void reset();
+        ~FatalConditionHandler();
+
+    private:
+        static bool isSet;
+        static ULONG guaranteeSize;
+        static PVOID exceptionHandlerHandle;
+    };
+
+} // namespace Catch
+
+#elif defined ( CATCH_CONFIG_POSIX_SIGNALS )
+
+#include <signal.h>
+
+namespace Catch {
+
+    struct FatalConditionHandler {
+
+        static bool isSet;
+        static struct sigaction oldSigActions[];
+        static stack_t oldSigStack;
+        static char altStackMem[];
+
+        static void handleSignal( int sig );
+
+        FatalConditionHandler();
+        ~FatalConditionHandler();
+        static void reset();
+    };
+
+} // namespace Catch
+
+#else
+
+namespace Catch {
+    struct FatalConditionHandler {
+        void reset();
+    };
+}
+
+#endif
+
+// end catch_fatal_condition.h
+#include <string>
+
+namespace Catch {
+
+    struct IMutableContext;
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class RunContext : public IResultCapture, public IRunner {
+
+    public:
+        RunContext( RunContext const& ) = delete;
+        RunContext& operator =( RunContext const& ) = delete;
+
+        explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
+
+        ~RunContext() override;
+
+        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
+        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
+
+        Totals runTest(TestCase const& testCase);
+
+        IConfigPtr config() const;
+        IStreamingReporter& reporter() const;
+
+    public: // IResultCapture
+
+        // Assertion handlers
+        void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) override;
+        void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    StringRef const& message,
+                    AssertionReaction& reaction ) override;
+        void handleUnexpectedExceptionNotThrown
+                (   AssertionInfo const& info,
+                    AssertionReaction& reaction ) override;
+        void handleUnexpectedInflightException
+                (   AssertionInfo const& info,
+                    std::string const& message,
+                    AssertionReaction& reaction ) override;
+        void handleIncomplete
+                (   AssertionInfo const& info ) override;
+        void handleNonExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    AssertionReaction &reaction ) override;
+
+        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
+
+        void sectionEnded( SectionEndInfo const& endInfo ) override;
+        void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
+
+        auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing( std::string const& name ) override;
+        void benchmarkStarting( BenchmarkInfo const& info ) override;
+        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
+        void benchmarkFailed( std::string const& error ) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void pushScopedMessage( MessageInfo const& message ) override;
+        void popScopedMessage( MessageInfo const& message ) override;
+
+        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
+
+        std::string getCurrentTestName() const override;
+
+        const AssertionResult* getLastResult() const override;
+
+        void exceptionEarlyReported() override;
+
+        void handleFatalErrorCondition( StringRef message ) override;
+
+        bool lastAssertionPassed() override;
+
+        void assertionPassed() override;
+
+    public:
+        // !TBD We need to do this another way!
+        bool aborting() const final;
+
+    private:
+
+        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
+        void invokeActiveTestCase();
+
+        void resetAssertionInfo();
+        bool testForMissingAssertions( Counts& assertions );
+
+        void assertionEnded( AssertionResult const& result );
+        void reportExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    ITransientExpression const *expr,
+                    bool negated );
+
+        void populateReaction( AssertionReaction& reaction );
+
+    private:
+
+        void handleUnfinishedSections();
+
+        TestRunInfo m_runInfo;
+        IMutableContext& m_context;
+        TestCase const* m_activeTestCase = nullptr;
+        ITracker* m_testCaseTracker = nullptr;
+        Option<AssertionResult> m_lastResult;
+
+        IConfigPtr m_config;
+        Totals m_totals;
+        IStreamingReporterPtr m_reporter;
+        std::vector<MessageInfo> m_messages;
+        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
+        AssertionInfo m_lastAssertionInfo;
+        std::vector<SectionEndInfo> m_unfinishedSections;
+        std::vector<ITracker*> m_activeSections;
+        TrackerContext m_trackerContext;
+        bool m_lastAssertionPassed = false;
+        bool m_shouldReportUnexpected = true;
+        bool m_includeSuccessfulResults;
+    };
+
+    void seedRng(IConfig const& config);
+    unsigned int rngSeed();
+} // end namespace Catch
+
+// end catch_run_context.h
+namespace Catch {
+
+    namespace {
+        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
+            expr.streamReconstructedExpression( os );
+            return os;
+        }
+    }
+
+    LazyExpression::LazyExpression( bool isNegated )
+    :   m_isNegated( isNegated )
+    {}
+
+    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
+
+    LazyExpression::operator bool() const {
+        return m_transientExpression != nullptr;
+    }
+
+    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
+        if( lazyExpr.m_isNegated )
+            os << "!";
+
+        if( lazyExpr ) {
+            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
+                os << "(" << *lazyExpr.m_transientExpression << ")";
+            else
+                os << *lazyExpr.m_transientExpression;
+        }
+        else {
+            os << "{** error - unchecked empty expression requested **}";
+        }
+        return os;
+    }
+
+    AssertionHandler::AssertionHandler
+        (   StringRef const& macroName,
+            SourceLineInfo const& lineInfo,
+            StringRef capturedExpression,
+            ResultDisposition::Flags resultDisposition )
+    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
+        m_resultCapture( getResultCapture() )
+    {}
+
+    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
+        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
+    }
+    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
+        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
+    }
+
+    auto AssertionHandler::allowThrows() const -> bool {
+        return getCurrentContext().getConfig()->allowThrows();
+    }
+
+    void AssertionHandler::complete() {
+        setCompleted();
+        if( m_reaction.shouldDebugBreak ) {
+
+            // If you find your debugger stopping you here then go one level up on the
+            // call-stack for the code that caused it (typically a failed assertion)
+
+            // (To go back to the test and change execution, jump over the throw, next)
+            CATCH_BREAK_INTO_DEBUGGER();
+        }
+        if (m_reaction.shouldThrow) {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+            throw Catch::TestFailureException();
+#else
+            CATCH_ERROR( "Test failure requires aborting test!" );
+#endif
+        }
+    }
+    void AssertionHandler::setCompleted() {
+        m_completed = true;
+    }
+
+    void AssertionHandler::handleUnexpectedInflightException() {
+        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
+    }
+
+    void AssertionHandler::handleExceptionThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+    void AssertionHandler::handleExceptionNotThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
+        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
+    }
+
+    void AssertionHandler::handleThrowingCallSkipped() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    // This is the overload that takes a string and infers the Equals matcher from it
+    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
+        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
+    }
+
+} // namespace Catch
+// end catch_assertionhandler.cpp
+// start catch_assertionresult.cpp
+
+namespace Catch {
+    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
+        lazyExpression(_lazyExpression),
+        resultType(_resultType) {}
+
+    std::string AssertionResultData::reconstructExpression() const {
+
+        if( reconstructedExpression.empty() ) {
+            if( lazyExpression ) {
+                ReusableStringStream rss;
+                rss << lazyExpression;
+                reconstructedExpression = rss.str();
+            }
+        }
+        return reconstructedExpression;
+    }
+
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+    :   m_info( info ),
+        m_resultData( data )
+    {}
+
+    // Result was a success
+    bool AssertionResult::succeeded() const {
+        return Catch::isOk( m_resultData.resultType );
+    }
+
+    // Result was a success, or failure is suppressed
+    bool AssertionResult::isOk() const {
+        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+    }
+
+    ResultWas::OfType AssertionResult::getResultType() const {
+        return m_resultData.resultType;
+    }
+
+    bool AssertionResult::hasExpression() const {
+        return !m_info.capturedExpression.empty();
+    }
+
+    bool AssertionResult::hasMessage() const {
+        return !m_resultData.message.empty();
+    }
+
+    std::string AssertionResult::getExpression() const {
+        // Possibly overallocating by 3 characters should be basically free
+        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += "!(";
+        }
+        expr += m_info.capturedExpression;
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += ')';
+        }
+        return expr;
+    }
+
+    std::string AssertionResult::getExpressionInMacro() const {
+        std::string expr;
+        if( m_info.macroName.empty() )
+            expr = static_cast<std::string>(m_info.capturedExpression);
+        else {
+            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
+            expr += m_info.macroName;
+            expr += "( ";
+            expr += m_info.capturedExpression;
+            expr += " )";
+        }
+        return expr;
+    }
+
+    bool AssertionResult::hasExpandedExpression() const {
+        return hasExpression() && getExpandedExpression() != getExpression();
+    }
+
+    std::string AssertionResult::getExpandedExpression() const {
+        std::string expr = m_resultData.reconstructExpression();
+        return expr.empty()
+                ? getExpression()
+                : expr;
+    }
+
+    std::string AssertionResult::getMessage() const {
+        return m_resultData.message;
+    }
+    SourceLineInfo AssertionResult::getSourceInfo() const {
+        return m_info.lineInfo;
+    }
+
+    StringRef AssertionResult::getTestMacroName() const {
+        return m_info.macroName;
+    }
+
+} // end namespace Catch
+// end catch_assertionresult.cpp
+// start catch_capture_matchers.cpp
+
+namespace Catch {
+
+    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+    // This is the general overload that takes a any string matcher
+    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
+    // the Equals matcher (so the header does not mention matchers)
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
+        std::string exceptionMessage = Catch::translateActiveException();
+        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
+        handler.handleExpr( expr );
+    }
+
+} // namespace Catch
+// end catch_capture_matchers.cpp
+// start catch_commandline.cpp
+
+// start catch_commandline.h
+
+// start catch_clara.h
+
+// Use Catch's value for console width (store Clara's off to the side, if present)
+#ifdef CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#endif
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic ignored "-Wshadow"
+#endif
+
+// start clara.hpp
+// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See https://github.com/philsquared/Clara for more details
+
+// Clara v1.1.5
+
+
+#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+#ifndef CLARA_CONFIG_OPTIONAL_TYPE
+#ifdef __has_include
+#if __has_include(<optional>) && __cplusplus >= 201703L
+#include <optional>
+#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
+#endif
+#endif
+#endif
+
+// ----------- #included from clara_textflow.hpp -----------
+
+// TextFlowCpp
+//
+// A single-header library for wrapping and laying out basic text, by Phil Nash
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// This project is hosted at https://github.com/philsquared/textflowcpp
+
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+#include <vector>
+
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+namespace clara {
+namespace TextFlow {
+
+inline auto isWhitespace(char c) -> bool {
+	static std::string chars = " \t\n\r";
+	return chars.find(c) != std::string::npos;
+}
+inline auto isBreakableBefore(char c) -> bool {
+	static std::string chars = "[({<|";
+	return chars.find(c) != std::string::npos;
+}
+inline auto isBreakableAfter(char c) -> bool {
+	static std::string chars = "])}>.,:;*+-=&/\\";
+	return chars.find(c) != std::string::npos;
+}
+
+class Columns;
+
+class Column {
+	std::vector<std::string> m_strings;
+	size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
+	size_t m_indent = 0;
+	size_t m_initialIndent = std::string::npos;
+
+public:
+	class iterator {
+		friend Column;
+
+		Column const& m_column;
+		size_t m_stringIndex = 0;
+		size_t m_pos = 0;
+
+		size_t m_len = 0;
+		size_t m_end = 0;
+		bool m_suffix = false;
+
+		iterator(Column const& column, size_t stringIndex)
+			: m_column(column),
+			m_stringIndex(stringIndex) {}
+
+		auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
+
+		auto isBoundary(size_t at) const -> bool {
+			assert(at > 0);
+			assert(at <= line().size());
+
+			return at == line().size() ||
+				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
+				isBreakableBefore(line()[at]) ||
+				isBreakableAfter(line()[at - 1]);
+		}
+
+		void calcLength() {
+			assert(m_stringIndex < m_column.m_strings.size());
+
+			m_suffix = false;
+			auto width = m_column.m_width - indent();
+			m_end = m_pos;
+			if (line()[m_pos] == '\n') {
+				++m_end;
+			}
+			while (m_end < line().size() && line()[m_end] != '\n')
+				++m_end;
+
+			if (m_end < m_pos + width) {
+				m_len = m_end - m_pos;
+			} else {
+				size_t len = width;
+				while (len > 0 && !isBoundary(m_pos + len))
+					--len;
+				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
+					--len;
+
+				if (len > 0) {
+					m_len = len;
+				} else {
+					m_suffix = true;
+					m_len = width - 1;
+				}
+			}
+		}
+
+		auto indent() const -> size_t {
+			auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
+			return initial == std::string::npos ? m_column.m_indent : initial;
+		}
+
+		auto addIndentAndSuffix(std::string const &plain) const -> std::string {
+			return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
+		}
+
+	public:
+		using difference_type = std::ptrdiff_t;
+		using value_type = std::string;
+		using pointer = value_type * ;
+		using reference = value_type & ;
+		using iterator_category = std::forward_iterator_tag;
+
+		explicit iterator(Column const& column) : m_column(column) {
+			assert(m_column.m_width > m_column.m_indent);
+			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
+			calcLength();
+			if (m_len == 0)
+				m_stringIndex++; // Empty string
+		}
+
+		auto operator *() const -> std::string {
+			assert(m_stringIndex < m_column.m_strings.size());
+			assert(m_pos <= m_end);
+			return addIndentAndSuffix(line().substr(m_pos, m_len));
+		}
+
+		auto operator ++() -> iterator& {
+			m_pos += m_len;
+			if (m_pos < line().size() && line()[m_pos] == '\n')
+				m_pos += 1;
+			else
+				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
+					++m_pos;
+
+			if (m_pos == line().size()) {
+				m_pos = 0;
+				++m_stringIndex;
+			}
+			if (m_stringIndex < m_column.m_strings.size())
+				calcLength();
+			return *this;
+		}
+		auto operator ++(int) -> iterator {
+			iterator prev(*this);
+			operator++();
+			return prev;
+		}
+
+		auto operator ==(iterator const& other) const -> bool {
+			return
+				m_pos == other.m_pos &&
+				m_stringIndex == other.m_stringIndex &&
+				&m_column == &other.m_column;
+		}
+		auto operator !=(iterator const& other) const -> bool {
+			return !operator==(other);
+		}
+	};
+	using const_iterator = iterator;
+
+	explicit Column(std::string const& text) { m_strings.push_back(text); }
+
+	auto width(size_t newWidth) -> Column& {
+		assert(newWidth > 0);
+		m_width = newWidth;
+		return *this;
+	}
+	auto indent(size_t newIndent) -> Column& {
+		m_indent = newIndent;
+		return *this;
+	}
+	auto initialIndent(size_t newIndent) -> Column& {
+		m_initialIndent = newIndent;
+		return *this;
+	}
+
+	auto width() const -> size_t { return m_width; }
+	auto begin() const -> iterator { return iterator(*this); }
+	auto end() const -> iterator { return { *this, m_strings.size() }; }
+
+	inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
+		bool first = true;
+		for (auto line : col) {
+			if (first)
+				first = false;
+			else
+				os << "\n";
+			os << line;
+		}
+		return os;
+	}
+
+	auto operator + (Column const& other)->Columns;
+
+	auto toString() const -> std::string {
+		std::ostringstream oss;
+		oss << *this;
+		return oss.str();
+	}
+};
+
+class Spacer : public Column {
+
+public:
+	explicit Spacer(size_t spaceWidth) : Column("") {
+		width(spaceWidth);
+	}
+};
+
+class Columns {
+	std::vector<Column> m_columns;
+
+public:
+
+	class iterator {
+		friend Columns;
+		struct EndTag {};
+
+		std::vector<Column> const& m_columns;
+		std::vector<Column::iterator> m_iterators;
+		size_t m_activeIterators;
+
+		iterator(Columns const& columns, EndTag)
+			: m_columns(columns.m_columns),
+			m_activeIterators(0) {
+			m_iterators.reserve(m_columns.size());
+
+			for (auto const& col : m_columns)
+				m_iterators.push_back(col.end());
+		}
+
+	public:
+		using difference_type = std::ptrdiff_t;
+		using value_type = std::string;
+		using pointer = value_type * ;
+		using reference = value_type & ;
+		using iterator_category = std::forward_iterator_tag;
+
+		explicit iterator(Columns const& columns)
+			: m_columns(columns.m_columns),
+			m_activeIterators(m_columns.size()) {
+			m_iterators.reserve(m_columns.size());
+
+			for (auto const& col : m_columns)
+				m_iterators.push_back(col.begin());
+		}
+
+		auto operator ==(iterator const& other) const -> bool {
+			return m_iterators == other.m_iterators;
+		}
+		auto operator !=(iterator const& other) const -> bool {
+			return m_iterators != other.m_iterators;
+		}
+		auto operator *() const -> std::string {
+			std::string row, padding;
+
+			for (size_t i = 0; i < m_columns.size(); ++i) {
+				auto width = m_columns[i].width();
+				if (m_iterators[i] != m_columns[i].end()) {
+					std::string col = *m_iterators[i];
+					row += padding + col;
+					if (col.size() < width)
+						padding = std::string(width - col.size(), ' ');
+					else
+						padding = "";
+				} else {
+					padding += std::string(width, ' ');
+				}
+			}
+			return row;
+		}
+		auto operator ++() -> iterator& {
+			for (size_t i = 0; i < m_columns.size(); ++i) {
+				if (m_iterators[i] != m_columns[i].end())
+					++m_iterators[i];
+			}
+			return *this;
+		}
+		auto operator ++(int) -> iterator {
+			iterator prev(*this);
+			operator++();
+			return prev;
+		}
+	};
+	using const_iterator = iterator;
+
+	auto begin() const -> iterator { return iterator(*this); }
+	auto end() const -> iterator { return { *this, iterator::EndTag() }; }
+
+	auto operator += (Column const& col) -> Columns& {
+		m_columns.push_back(col);
+		return *this;
+	}
+	auto operator + (Column const& col) -> Columns {
+		Columns combined = *this;
+		combined += col;
+		return combined;
+	}
+
+	inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
+
+		bool first = true;
+		for (auto line : cols) {
+			if (first)
+				first = false;
+			else
+				os << "\n";
+			os << line;
+		}
+		return os;
+	}
+
+	auto toString() const -> std::string {
+		std::ostringstream oss;
+		oss << *this;
+		return oss.str();
+	}
+};
+
+inline auto Column::operator + (Column const& other) -> Columns {
+	Columns cols;
+	cols += *this;
+	cols += other;
+	return cols;
+}
+}
+
+}
+}
+
+// ----------- end of #include from clara_textflow.hpp -----------
+// ........... back in clara.hpp
+
+#include <cctype>
+#include <string>
+#include <memory>
+#include <set>
+#include <algorithm>
+
+#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
+#define CATCH_PLATFORM_WINDOWS
+#endif
+
+namespace Catch { namespace clara {
+namespace detail {
+
+    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
+    template<typename L>
+    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
+
+    template<typename ClassT, typename ReturnT, typename... Args>
+    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
+        static const bool isValid = false;
+    };
+
+    template<typename ClassT, typename ReturnT, typename ArgT>
+    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
+        static const bool isValid = true;
+        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
+        using ReturnType = ReturnT;
+    };
+
+    class TokenStream;
+
+    // Transport for raw args (copied from main args, or supplied via init list for testing)
+    class Args {
+        friend TokenStream;
+        std::string m_exeName;
+        std::vector<std::string> m_args;
+
+    public:
+        Args( int argc, char const* const* argv )
+            : m_exeName(argv[0]),
+              m_args(argv + 1, argv + argc) {}
+
+        Args( std::initializer_list<std::string> args )
+        :   m_exeName( *args.begin() ),
+            m_args( args.begin()+1, args.end() )
+        {}
+
+        auto exeName() const -> std::string {
+            return m_exeName;
+        }
+    };
+
+    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
+    // may encode an option + its argument if the : or = form is used
+    enum class TokenType {
+        Option, Argument
+    };
+    struct Token {
+        TokenType type;
+        std::string token;
+    };
+
+    inline auto isOptPrefix( char c ) -> bool {
+        return c == '-'
+#ifdef CATCH_PLATFORM_WINDOWS
+            || c == '/'
+#endif
+        ;
+    }
+
+    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
+    class TokenStream {
+        using Iterator = std::vector<std::string>::const_iterator;
+        Iterator it;
+        Iterator itEnd;
+        std::vector<Token> m_tokenBuffer;
+
+        void loadBuffer() {
+            m_tokenBuffer.resize( 0 );
+
+            // Skip any empty strings
+            while( it != itEnd && it->empty() )
+                ++it;
+
+            if( it != itEnd ) {
+                auto const &next = *it;
+                if( isOptPrefix( next[0] ) ) {
+                    auto delimiterPos = next.find_first_of( " :=" );
+                    if( delimiterPos != std::string::npos ) {
+                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
+                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
+                    } else {
+                        if( next[1] != '-' && next.size() > 2 ) {
+                            std::string opt = "- ";
+                            for( size_t i = 1; i < next.size(); ++i ) {
+                                opt[1] = next[i];
+                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
+                            }
+                        } else {
+                            m_tokenBuffer.push_back( { TokenType::Option, next } );
+                        }
+                    }
+                } else {
+                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
+                }
+            }
+        }
+
+    public:
+        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
+
+        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
+            loadBuffer();
+        }
+
+        explicit operator bool() const {
+            return !m_tokenBuffer.empty() || it != itEnd;
+        }
+
+        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
+
+        auto operator*() const -> Token {
+            assert( !m_tokenBuffer.empty() );
+            return m_tokenBuffer.front();
+        }
+
+        auto operator->() const -> Token const * {
+            assert( !m_tokenBuffer.empty() );
+            return &m_tokenBuffer.front();
+        }
+
+        auto operator++() -> TokenStream & {
+            if( m_tokenBuffer.size() >= 2 ) {
+                m_tokenBuffer.erase( m_tokenBuffer.begin() );
+            } else {
+                if( it != itEnd )
+                    ++it;
+                loadBuffer();
+            }
+            return *this;
+        }
+    };
+
+    class ResultBase {
+    public:
+        enum Type {
+            Ok, LogicError, RuntimeError
+        };
+
+    protected:
+        ResultBase( Type type ) : m_type( type ) {}
+        virtual ~ResultBase() = default;
+
+        virtual void enforceOk() const = 0;
+
+        Type m_type;
+    };
+
+    template<typename T>
+    class ResultValueBase : public ResultBase {
+    public:
+        auto value() const -> T const & {
+            enforceOk();
+            return m_value;
+        }
+
+    protected:
+        ResultValueBase( Type type ) : ResultBase( type ) {}
+
+        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
+            if( m_type == ResultBase::Ok )
+                new( &m_value ) T( other.m_value );
+        }
+
+        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
+            new( &m_value ) T( value );
+        }
+
+        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
+            if( m_type == ResultBase::Ok )
+                m_value.~T();
+            ResultBase::operator=(other);
+            if( m_type == ResultBase::Ok )
+                new( &m_value ) T( other.m_value );
+            return *this;
+        }
+
+        ~ResultValueBase() override {
+            if( m_type == Ok )
+                m_value.~T();
+        }
+
+        union {
+            T m_value;
+        };
+    };
+
+    template<>
+    class ResultValueBase<void> : public ResultBase {
+    protected:
+        using ResultBase::ResultBase;
+    };
+
+    template<typename T = void>
+    class BasicResult : public ResultValueBase<T> {
+    public:
+        template<typename U>
+        explicit BasicResult( BasicResult<U> const &other )
+        :   ResultValueBase<T>( other.type() ),
+            m_errorMessage( other.errorMessage() )
+        {
+            assert( type() != ResultBase::Ok );
+        }
+
+        template<typename U>
+        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
+        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
+        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
+        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
+
+        explicit operator bool() const { return m_type == ResultBase::Ok; }
+        auto type() const -> ResultBase::Type { return m_type; }
+        auto errorMessage() const -> std::string { return m_errorMessage; }
+
+    protected:
+        void enforceOk() const override {
+
+            // Errors shouldn't reach this point, but if they do
+            // the actual error message will be in m_errorMessage
+            assert( m_type != ResultBase::LogicError );
+            assert( m_type != ResultBase::RuntimeError );
+            if( m_type != ResultBase::Ok )
+                std::abort();
+        }
+
+        std::string m_errorMessage; // Only populated if resultType is an error
+
+        BasicResult( ResultBase::Type type, std::string const &message )
+        :   ResultValueBase<T>(type),
+            m_errorMessage(message)
+        {
+            assert( m_type != ResultBase::Ok );
+        }
+
+        using ResultValueBase<T>::ResultValueBase;
+        using ResultBase::m_type;
+    };
+
+    enum class ParseResultType {
+        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
+    };
+
+    class ParseState {
+    public:
+
+        ParseState( ParseResultType type, TokenStream const &remainingTokens )
+        : m_type(type),
+          m_remainingTokens( remainingTokens )
+        {}
+
+        auto type() const -> ParseResultType { return m_type; }
+        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
+
+    private:
+        ParseResultType m_type;
+        TokenStream m_remainingTokens;
+    };
+
+    using Result = BasicResult<void>;
+    using ParserResult = BasicResult<ParseResultType>;
+    using InternalParseResult = BasicResult<ParseState>;
+
+    struct HelpColumns {
+        std::string left;
+        std::string right;
+    };
+
+    template<typename T>
+    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
+        std::stringstream ss;
+        ss << source;
+        ss >> target;
+        if( ss.fail() )
+            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
+        else
+            return ParserResult::ok( ParseResultType::Matched );
+    }
+    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
+        target = source;
+        return ParserResult::ok( ParseResultType::Matched );
+    }
+    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
+        std::string srcLC = source;
+        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
+        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
+            target = true;
+        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
+            target = false;
+        else
+            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
+        return ParserResult::ok( ParseResultType::Matched );
+    }
+#ifdef CLARA_CONFIG_OPTIONAL_TYPE
+    template<typename T>
+    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
+        T temp;
+        auto result = convertInto( source, temp );
+        if( result )
+            target = std::move(temp);
+        return result;
+    }
+#endif // CLARA_CONFIG_OPTIONAL_TYPE
+
+    struct NonCopyable {
+        NonCopyable() = default;
+        NonCopyable( NonCopyable const & ) = delete;
+        NonCopyable( NonCopyable && ) = delete;
+        NonCopyable &operator=( NonCopyable const & ) = delete;
+        NonCopyable &operator=( NonCopyable && ) = delete;
+    };
+
+    struct BoundRef : NonCopyable {
+        virtual ~BoundRef() = default;
+        virtual auto isContainer() const -> bool { return false; }
+        virtual auto isFlag() const -> bool { return false; }
+    };
+    struct BoundValueRefBase : BoundRef {
+        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
+    };
+    struct BoundFlagRefBase : BoundRef {
+        virtual auto setFlag( bool flag ) -> ParserResult = 0;
+        virtual auto isFlag() const -> bool { return true; }
+    };
+
+    template<typename T>
+    struct BoundValueRef : BoundValueRefBase {
+        T &m_ref;
+
+        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            return convertInto( arg, m_ref );
+        }
+    };
+
+    template<typename T>
+    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
+        std::vector<T> &m_ref;
+
+        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
+
+        auto isContainer() const -> bool override { return true; }
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            T temp;
+            auto result = convertInto( arg, temp );
+            if( result )
+                m_ref.push_back( temp );
+            return result;
+        }
+    };
+
+    struct BoundFlagRef : BoundFlagRefBase {
+        bool &m_ref;
+
+        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
+
+        auto setFlag( bool flag ) -> ParserResult override {
+            m_ref = flag;
+            return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    template<typename ReturnType>
+    struct LambdaInvoker {
+        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
+
+        template<typename L, typename ArgType>
+        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+            return lambda( arg );
+        }
+    };
+
+    template<>
+    struct LambdaInvoker<void> {
+        template<typename L, typename ArgType>
+        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+            lambda( arg );
+            return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    template<typename ArgType, typename L>
+    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
+        ArgType temp{};
+        auto result = convertInto( arg, temp );
+        return !result
+           ? result
+           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
+    }
+
+    template<typename L>
+    struct BoundLambda : BoundValueRefBase {
+        L m_lambda;
+
+        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
+        }
+    };
+
+    template<typename L>
+    struct BoundFlagLambda : BoundFlagRefBase {
+        L m_lambda;
+
+        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
+
+        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+        auto setFlag( bool flag ) -> ParserResult override {
+            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
+        }
+    };
+
+    enum class Optionality { Optional, Required };
+
+    struct Parser;
+
+    class ParserBase {
+    public:
+        virtual ~ParserBase() = default;
+        virtual auto validate() const -> Result { return Result::ok(); }
+        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
+        virtual auto cardinality() const -> size_t { return 1; }
+
+        auto parse( Args const &args ) const -> InternalParseResult {
+            return parse( args.exeName(), TokenStream( args ) );
+        }
+    };
+
+    template<typename DerivedT>
+    class ComposableParserImpl : public ParserBase {
+    public:
+        template<typename T>
+        auto operator|( T const &other ) const -> Parser;
+
+		template<typename T>
+        auto operator+( T const &other ) const -> Parser;
+    };
+
+    // Common code and state for Args and Opts
+    template<typename DerivedT>
+    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
+    protected:
+        Optionality m_optionality = Optionality::Optional;
+        std::shared_ptr<BoundRef> m_ref;
+        std::string m_hint;
+        std::string m_description;
+
+        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
+
+    public:
+        template<typename T>
+        ParserRefImpl( T &ref, std::string const &hint )
+        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
+            m_hint( hint )
+        {}
+
+        template<typename LambdaT>
+        ParserRefImpl( LambdaT const &ref, std::string const &hint )
+        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
+            m_hint(hint)
+        {}
+
+        auto operator()( std::string const &description ) -> DerivedT & {
+            m_description = description;
+            return static_cast<DerivedT &>( *this );
+        }
+
+        auto optional() -> DerivedT & {
+            m_optionality = Optionality::Optional;
+            return static_cast<DerivedT &>( *this );
+        };
+
+        auto required() -> DerivedT & {
+            m_optionality = Optionality::Required;
+            return static_cast<DerivedT &>( *this );
+        };
+
+        auto isOptional() const -> bool {
+            return m_optionality == Optionality::Optional;
+        }
+
+        auto cardinality() const -> size_t override {
+            if( m_ref->isContainer() )
+                return 0;
+            else
+                return 1;
+        }
+
+        auto hint() const -> std::string { return m_hint; }
+    };
+
+    class ExeName : public ComposableParserImpl<ExeName> {
+        std::shared_ptr<std::string> m_name;
+        std::shared_ptr<BoundValueRefBase> m_ref;
+
+        template<typename LambdaT>
+        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
+            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
+        }
+
+    public:
+        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
+
+        explicit ExeName( std::string &ref ) : ExeName() {
+            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
+        }
+
+        template<typename LambdaT>
+        explicit ExeName( LambdaT const& lambda ) : ExeName() {
+            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
+        }
+
+        // The exe name is not parsed out of the normal tokens, but is handled specially
+        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+        }
+
+        auto name() const -> std::string { return *m_name; }
+        auto set( std::string const& newName ) -> ParserResult {
+
+            auto lastSlash = newName.find_last_of( "\\/" );
+            auto filename = ( lastSlash == std::string::npos )
+                    ? newName
+                    : newName.substr( lastSlash+1 );
+
+            *m_name = filename;
+            if( m_ref )
+                return m_ref->setValue( filename );
+            else
+                return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    class Arg : public ParserRefImpl<Arg> {
+    public:
+        using ParserRefImpl::ParserRefImpl;
+
+        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
+            auto validationResult = validate();
+            if( !validationResult )
+                return InternalParseResult( validationResult );
+
+            auto remainingTokens = tokens;
+            auto const &token = *remainingTokens;
+            if( token.type != TokenType::Argument )
+                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+
+            assert( !m_ref->isFlag() );
+            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+
+            auto result = valueRef->setValue( remainingTokens->token );
+            if( !result )
+                return InternalParseResult( result );
+            else
+                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+        }
+    };
+
+    inline auto normaliseOpt( std::string const &optName ) -> std::string {
+#ifdef CATCH_PLATFORM_WINDOWS
+        if( optName[0] == '/' )
+            return "-" + optName.substr( 1 );
+        else
+#endif
+            return optName;
+    }
+
+    class Opt : public ParserRefImpl<Opt> {
+    protected:
+        std::vector<std::string> m_optNames;
+
+    public:
+        template<typename LambdaT>
+        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
+
+        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
+
+        template<typename LambdaT>
+        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+        template<typename T>
+        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+        auto operator[]( std::string const &optName ) -> Opt & {
+            m_optNames.push_back( optName );
+            return *this;
+        }
+
+        auto getHelpColumns() const -> std::vector<HelpColumns> {
+            std::ostringstream oss;
+            bool first = true;
+            for( auto const &opt : m_optNames ) {
+                if (first)
+                    first = false;
+                else
+                    oss << ", ";
+                oss << opt;
+            }
+            if( !m_hint.empty() )
+                oss << " <" << m_hint << ">";
+            return { { oss.str(), m_description } };
+        }
+
+        auto isMatch( std::string const &optToken ) const -> bool {
+            auto normalisedToken = normaliseOpt( optToken );
+            for( auto const &name : m_optNames ) {
+                if( normaliseOpt( name ) == normalisedToken )
+                    return true;
+            }
+            return false;
+        }
+
+        using ParserBase::parse;
+
+        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+            auto validationResult = validate();
+            if( !validationResult )
+                return InternalParseResult( validationResult );
+
+            auto remainingTokens = tokens;
+            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
+                auto const &token = *remainingTokens;
+                if( isMatch(token.token ) ) {
+                    if( m_ref->isFlag() ) {
+                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
+                        auto result = flagRef->setFlag( true );
+                        if( !result )
+                            return InternalParseResult( result );
+                        if( result.value() == ParseResultType::ShortCircuitAll )
+                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+                    } else {
+                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+                        ++remainingTokens;
+                        if( !remainingTokens )
+                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+                        auto const &argToken = *remainingTokens;
+                        if( argToken.type != TokenType::Argument )
+                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+                        auto result = valueRef->setValue( argToken.token );
+                        if( !result )
+                            return InternalParseResult( result );
+                        if( result.value() == ParseResultType::ShortCircuitAll )
+                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+                    }
+                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+                }
+            }
+            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+        }
+
+        auto validate() const -> Result override {
+            if( m_optNames.empty() )
+                return Result::logicError( "No options supplied to Opt" );
+            for( auto const &name : m_optNames ) {
+                if( name.empty() )
+                    return Result::logicError( "Option name cannot be empty" );
+#ifdef CATCH_PLATFORM_WINDOWS
+                if( name[0] != '-' && name[0] != '/' )
+                    return Result::logicError( "Option name must begin with '-' or '/'" );
+#else
+                if( name[0] != '-' )
+                    return Result::logicError( "Option name must begin with '-'" );
+#endif
+            }
+            return ParserRefImpl::validate();
+        }
+    };
+
+    struct Help : Opt {
+        Help( bool &showHelpFlag )
+        :   Opt([&]( bool flag ) {
+                showHelpFlag = flag;
+                return ParserResult::ok( ParseResultType::ShortCircuitAll );
+            })
+        {
+            static_cast<Opt &>( *this )
+                    ("display usage information")
+                    ["-?"]["-h"]["--help"]
+                    .optional();
+        }
+    };
+
+    struct Parser : ParserBase {
+
+        mutable ExeName m_exeName;
+        std::vector<Opt> m_options;
+        std::vector<Arg> m_args;
+
+        auto operator|=( ExeName const &exeName ) -> Parser & {
+            m_exeName = exeName;
+            return *this;
+        }
+
+        auto operator|=( Arg const &arg ) -> Parser & {
+            m_args.push_back(arg);
+            return *this;
+        }
+
+        auto operator|=( Opt const &opt ) -> Parser & {
+            m_options.push_back(opt);
+            return *this;
+        }
+
+        auto operator|=( Parser const &other ) -> Parser & {
+            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
+            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
+            return *this;
+        }
+
+        template<typename T>
+        auto operator|( T const &other ) const -> Parser {
+            return Parser( *this ) |= other;
+        }
+
+        // Forward deprecated interface with '+' instead of '|'
+        template<typename T>
+        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
+        template<typename T>
+        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
+
+        auto getHelpColumns() const -> std::vector<HelpColumns> {
+            std::vector<HelpColumns> cols;
+            for (auto const &o : m_options) {
+                auto childCols = o.getHelpColumns();
+                cols.insert( cols.end(), childCols.begin(), childCols.end() );
+            }
+            return cols;
+        }
+
+        void writeToStream( std::ostream &os ) const {
+            if (!m_exeName.name().empty()) {
+                os << "usage:\n" << "  " << m_exeName.name() << " ";
+                bool required = true, first = true;
+                for( auto const &arg : m_args ) {
+                    if (first)
+                        first = false;
+                    else
+                        os << " ";
+                    if( arg.isOptional() && required ) {
+                        os << "[";
+                        required = false;
+                    }
+                    os << "<" << arg.hint() << ">";
+                    if( arg.cardinality() == 0 )
+                        os << " ... ";
+                }
+                if( !required )
+                    os << "]";
+                if( !m_options.empty() )
+                    os << " options";
+                os << "\n\nwhere options are:" << std::endl;
+            }
+
+            auto rows = getHelpColumns();
+            size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
+            size_t optWidth = 0;
+            for( auto const &cols : rows )
+                optWidth = (std::max)(optWidth, cols.left.size() + 2);
+
+            optWidth = (std::min)(optWidth, consoleWidth/2);
+
+            for( auto const &cols : rows ) {
+                auto row =
+                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
+                        TextFlow::Spacer(4) +
+                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
+                os << row << std::endl;
+            }
+        }
+
+        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
+            parser.writeToStream( os );
+            return os;
+        }
+
+        auto validate() const -> Result override {
+            for( auto const &opt : m_options ) {
+                auto result = opt.validate();
+                if( !result )
+                    return result;
+            }
+            for( auto const &arg : m_args ) {
+                auto result = arg.validate();
+                if( !result )
+                    return result;
+            }
+            return Result::ok();
+        }
+
+        using ParserBase::parse;
+
+        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
+
+            struct ParserInfo {
+                ParserBase const* parser = nullptr;
+                size_t count = 0;
+            };
+            const size_t totalParsers = m_options.size() + m_args.size();
+            assert( totalParsers < 512 );
+            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
+            ParserInfo parseInfos[512];
+
+            {
+                size_t i = 0;
+                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
+                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
+            }
+
+            m_exeName.set( exeName );
+
+            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+            while( result.value().remainingTokens() ) {
+                bool tokenParsed = false;
+
+                for( size_t i = 0; i < totalParsers; ++i ) {
+                    auto&  parseInfo = parseInfos[i];
+                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
+                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
+                        if (!result)
+                            return result;
+                        if (result.value().type() != ParseResultType::NoMatch) {
+                            tokenParsed = true;
+                            ++parseInfo.count;
+                            break;
+                        }
+                    }
+                }
+
+                if( result.value().type() == ParseResultType::ShortCircuitAll )
+                    return result;
+                if( !tokenParsed )
+                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
+            }
+            // !TBD Check missing required options
+            return result;
+        }
+    };
+
+    template<typename DerivedT>
+    template<typename T>
+    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
+        return Parser() | static_cast<DerivedT const &>( *this ) | other;
+    }
+} // namespace detail
+
+// A Combined parser
+using detail::Parser;
+
+// A parser for options
+using detail::Opt;
+
+// A parser for arguments
+using detail::Arg;
+
+// Wrapper for argc, argv from main()
+using detail::Args;
+
+// Specifies the name of the executable
+using detail::ExeName;
+
+// Convenience wrapper for option parser that specifies the help option
+using detail::Help;
+
+// enum of result types from a parse
+using detail::ParseResultType;
+
+// Result type for parser operation
+using detail::ParserResult;
+
+}} // namespace Catch::clara
+
+// end clara.hpp
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// Restore Clara's value for console width, if present
+#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+// end catch_clara.h
+namespace Catch {
+
+    clara::Parser makeCommandLineParser( ConfigData& config );
+
+} // end namespace Catch
+
+// end catch_commandline.h
+#include <fstream>
+#include <ctime>
+
+namespace Catch {
+
+    clara::Parser makeCommandLineParser( ConfigData& config ) {
+
+        using namespace clara;
+
+        auto const setWarning = [&]( std::string const& warning ) {
+                auto warningSet = [&]() {
+                    if( warning == "NoAssertions" )
+                        return WarnAbout::NoAssertions;
+
+                    if ( warning == "NoTests" )
+                        return WarnAbout::NoTests;
+
+                    return WarnAbout::Nothing;
+                }();
+
+                if (warningSet == WarnAbout::Nothing)
+                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
+                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
+                std::ifstream f( filename.c_str() );
+                if( !f.is_open() )
+                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
+
+                std::string line;
+                while( std::getline( f, line ) ) {
+                    line = trim(line);
+                    if( !line.empty() && !startsWith( line, '#' ) ) {
+                        if( !startsWith( line, '"' ) )
+                            line = '"' + line + '"';
+                        config.testsOrTags.push_back( line );
+                        config.testsOrTags.emplace_back( "," );
+                    }
+                }
+                //Remove comma in the end
+                if(!config.testsOrTags.empty())
+                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
+
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setTestOrder = [&]( std::string const& order ) {
+                if( startsWith( "declared", order ) )
+                    config.runOrder = RunTests::InDeclarationOrder;
+                else if( startsWith( "lexical", order ) )
+                    config.runOrder = RunTests::InLexicographicalOrder;
+                else if( startsWith( "random", order ) )
+                    config.runOrder = RunTests::InRandomOrder;
+                else
+                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setRngSeed = [&]( std::string const& seed ) {
+                if( seed != "time" )
+                    return clara::detail::convertInto( seed, config.rngSeed );
+                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setColourUsage = [&]( std::string const& useColour ) {
+                    auto mode = toLower( useColour );
+
+                    if( mode == "yes" )
+                        config.useColour = UseColour::Yes;
+                    else if( mode == "no" )
+                        config.useColour = UseColour::No;
+                    else if( mode == "auto" )
+                        config.useColour = UseColour::Auto;
+                    else
+                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
+                auto keypressLc = toLower( keypress );
+                if (keypressLc == "never")
+                    config.waitForKeypress = WaitForKeypress::Never;
+                else if( keypressLc == "start" )
+                    config.waitForKeypress = WaitForKeypress::BeforeStart;
+                else if( keypressLc == "exit" )
+                    config.waitForKeypress = WaitForKeypress::BeforeExit;
+                else if( keypressLc == "both" )
+                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+                else
+                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
+            return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setVerbosity = [&]( std::string const& verbosity ) {
+            auto lcVerbosity = toLower( verbosity );
+            if( lcVerbosity == "quiet" )
+                config.verbosity = Verbosity::Quiet;
+            else if( lcVerbosity == "normal" )
+                config.verbosity = Verbosity::Normal;
+            else if( lcVerbosity == "high" )
+                config.verbosity = Verbosity::High;
+            else
+                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+        auto const setReporter = [&]( std::string const& reporter ) {
+            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+
+            auto lcReporter = toLower( reporter );
+            auto result = factories.find( lcReporter );
+
+            if( factories.end() != result )
+                config.reporterName = lcReporter;
+            else
+                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+
+        auto cli
+            = ExeName( config.processName )
+            | Help( config.showHelp )
+            | Opt( config.listTests )
+                ["-l"]["--list-tests"]
+                ( "list all/matching test cases" )
+            | Opt( config.listTags )
+                ["-t"]["--list-tags"]
+                ( "list all/matching tags" )
+            | Opt( config.showSuccessfulTests )
+                ["-s"]["--success"]
+                ( "include successful tests in output" )
+            | Opt( config.shouldDebugBreak )
+                ["-b"]["--break"]
+                ( "break into debugger on failure" )
+            | Opt( config.noThrow )
+                ["-e"]["--nothrow"]
+                ( "skip exception tests" )
+            | Opt( config.showInvisibles )
+                ["-i"]["--invisibles"]
+                ( "show invisibles (tabs, newlines)" )
+            | Opt( config.outputFilename, "filename" )
+                ["-o"]["--out"]
+                ( "output filename" )
+            | Opt( setReporter, "name" )
+                ["-r"]["--reporter"]
+                ( "reporter to use (defaults to console)" )
+            | Opt( config.name, "name" )
+                ["-n"]["--name"]
+                ( "suite name" )
+            | Opt( [&]( bool ){ config.abortAfter = 1; } )
+                ["-a"]["--abort"]
+                ( "abort at first failure" )
+            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
+                ["-x"]["--abortx"]
+                ( "abort after x failures" )
+            | Opt( setWarning, "warning name" )
+                ["-w"]["--warn"]
+                ( "enable warnings" )
+            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
+                ["-d"]["--durations"]
+                ( "show test durations" )
+            | Opt( loadTestNamesFromFile, "filename" )
+                ["-f"]["--input-file"]
+                ( "load test names to run from a file" )
+            | Opt( config.filenamesAsTags )
+                ["-#"]["--filenames-as-tags"]
+                ( "adds a tag for the filename" )
+            | Opt( config.sectionsToRun, "section name" )
+                ["-c"]["--section"]
+                ( "specify section to run" )
+            | Opt( setVerbosity, "quiet|normal|high" )
+                ["-v"]["--verbosity"]
+                ( "set output verbosity" )
+            | Opt( config.listTestNamesOnly )
+                ["--list-test-names-only"]
+                ( "list all/matching test cases names only" )
+            | Opt( config.listReporters )
+                ["--list-reporters"]
+                ( "list all reporters" )
+            | Opt( setTestOrder, "decl|lex|rand" )
+                ["--order"]
+                ( "test case order (defaults to decl)" )
+            | Opt( setRngSeed, "'time'|number" )
+                ["--rng-seed"]
+                ( "set a specific seed for random numbers" )
+            | Opt( setColourUsage, "yes|no" )
+                ["--use-colour"]
+                ( "should output be colourised" )
+            | Opt( config.libIdentify )
+                ["--libidentify"]
+                ( "report name and version according to libidentify standard" )
+            | Opt( setWaitForKeypress, "never|start|exit|both" )
+                ["--wait-for-keypress"]
+                ( "waits for a keypress before exiting" )
+            | Opt( config.benchmarkSamples, "samples" )
+                ["--benchmark-samples"]
+                ( "number of samples to collect (default: 100)" )
+            | Opt( config.benchmarkResamples, "resamples" )
+                ["--benchmark-resamples"]
+                ( "number of resamples for the bootstrap (default: 100000)" )
+            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
+                ["--benchmark-confidence-interval"]
+                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
+            | Opt( config.benchmarkNoAnalysis )
+                ["--benchmark-no-analysis"]
+                ( "perform only measurements; do not perform any analysis" )
+            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
+                ["--benchmark-warmup-time"]
+                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
+            | Arg( config.testsOrTags, "test name|pattern|tags" )
+                ( "which test or tests to use" );
+
+        return cli;
+    }
+
+} // end namespace Catch
+// end catch_commandline.cpp
+// start catch_common.cpp
+
+#include <cstring>
+#include <ostream>
+
+namespace Catch {
+
+    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
+        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
+    }
+    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
+        // We can assume that the same file will usually have the same pointer.
+        // Thus, if the pointers are the same, there is no point in calling the strcmp
+        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
+    }
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+#ifndef __GNUG__
+        os << info.file << '(' << info.line << ')';
+#else
+        os << info.file << ':' << info.line;
+#endif
+        return os;
+    }
+
+    std::string StreamEndStop::operator+() const {
+        return std::string();
+    }
+
+    NonCopyable::NonCopyable() = default;
+    NonCopyable::~NonCopyable() = default;
+
+}
+// end catch_common.cpp
+// start catch_config.cpp
+
+namespace Catch {
+
+    Config::Config( ConfigData const& data )
+    :   m_data( data ),
+        m_stream( openStream() )
+    {
+        // We need to trim filter specs to avoid trouble with superfluous
+        // whitespace (esp. important for bdd macros, as those are manually
+        // aligned with whitespace).
+
+        for (auto& elem : m_data.testsOrTags) {
+            elem = trim(elem);
+        }
+        for (auto& elem : m_data.sectionsToRun) {
+            elem = trim(elem);
+        }
+
+        TestSpecParser parser(ITagAliasRegistry::get());
+        if (!m_data.testsOrTags.empty()) {
+            m_hasTestFilters = true;
+            for (auto const& testOrTags : m_data.testsOrTags) {
+                parser.parse(testOrTags);
+            }
+        }
+        m_testSpec = parser.testSpec();
+    }
+
+    std::string const& Config::getFilename() const {
+        return m_data.outputFilename ;
+    }
+
+    bool Config::listTests() const          { return m_data.listTests; }
+    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
+    bool Config::listTags() const           { return m_data.listTags; }
+    bool Config::listReporters() const      { return m_data.listReporters; }
+
+    std::string Config::getProcessName() const { return m_data.processName; }
+    std::string const& Config::getReporterName() const { return m_data.reporterName; }
+
+    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
+    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
+
+    TestSpec const& Config::testSpec() const { return m_testSpec; }
+    bool Config::hasTestFilters() const { return m_hasTestFilters; }
+
+    bool Config::showHelp() const { return m_data.showHelp; }
+
+    // IConfig interface
+    bool Config::allowThrows() const                   { return !m_data.noThrow; }
+    std::ostream& Config::stream() const               { return m_stream->stream(); }
+    std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
+    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
+    bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
+    bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
+    ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
+    RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
+    unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
+    UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
+    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
+    int Config::abortAfter() const                     { return m_data.abortAfter; }
+    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
+    Verbosity Config::verbosity() const                { return m_data.verbosity; }
+
+    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
+    int Config::benchmarkSamples() const                          { return m_data.benchmarkSamples; }
+    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
+    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
+    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+
+    IStream const* Config::openStream() {
+        return Catch::makeStream(m_data.outputFilename);
+    }
+
+} // end namespace Catch
+// end catch_config.cpp
+// start catch_console_colour.cpp
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+// start catch_errno_guard.h
+
+namespace Catch {
+
+    class ErrnoGuard {
+    public:
+        ErrnoGuard();
+        ~ErrnoGuard();
+    private:
+        int m_oldErrno;
+    };
+
+}
+
+// end catch_errno_guard.h
+#include <sstream>
+
+namespace Catch {
+    namespace {
+
+        struct IColourImpl {
+            virtual ~IColourImpl() = default;
+            virtual void use( Colour::Code _colourCode ) = 0;
+        };
+
+        struct NoColourImpl : IColourImpl {
+            void use( Colour::Code ) override {}
+
+            static IColourImpl* instance() {
+                static NoColourImpl s_instance;
+                return &s_instance;
+            }
+        };
+
+    } // anon namespace
+} // namespace Catch
+
+#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
+#   ifdef CATCH_PLATFORM_WINDOWS
+#       define CATCH_CONFIG_COLOUR_WINDOWS
+#   else
+#       define CATCH_CONFIG_COLOUR_ANSI
+#   endif
+#endif
+
+#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
+
+namespace Catch {
+namespace {
+
+    class Win32ColourImpl : public IColourImpl {
+    public:
+        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
+        {
+            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
+            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
+            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
+        }
+
+        void use( Colour::Code _colourCode ) override {
+            switch( _colourCode ) {
+                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
+                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
+                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
+                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
+                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+                case Colour::Grey:      return setTextAttribute( 0 );
+
+                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
+                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
+
+                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+
+                default:
+                    CATCH_ERROR( "Unknown colour requested" );
+            }
+        }
+
+    private:
+        void setTextAttribute( WORD _textAttribute ) {
+            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
+        }
+        HANDLE stdoutHandle;
+        WORD originalForegroundAttributes;
+        WORD originalBackgroundAttributes;
+    };
+
+    IColourImpl* platformColourInstance() {
+        static Win32ColourImpl s_instance;
+
+        IConfigPtr config = getCurrentContext().getConfig();
+        UseColour::YesOrNo colourMode = config
+            ? config->useColour()
+            : UseColour::Auto;
+        if( colourMode == UseColour::Auto )
+            colourMode = UseColour::Yes;
+        return colourMode == UseColour::Yes
+            ? &s_instance
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
+
+#include <unistd.h>
+
+namespace Catch {
+namespace {
+
+    // use POSIX/ ANSI console terminal codes
+    // Thanks to Adam Strzelecki for original contribution
+    // (http://github.com/nanoant)
+    // https://github.com/philsquared/Catch/pull/131
+    class PosixColourImpl : public IColourImpl {
+    public:
+        void use( Colour::Code _colourCode ) override {
+            switch( _colourCode ) {
+                case Colour::None:
+                case Colour::White:     return setColour( "[0m" );
+                case Colour::Red:       return setColour( "[0;31m" );
+                case Colour::Green:     return setColour( "[0;32m" );
+                case Colour::Blue:      return setColour( "[0;34m" );
+                case Colour::Cyan:      return setColour( "[0;36m" );
+                case Colour::Yellow:    return setColour( "[0;33m" );
+                case Colour::Grey:      return setColour( "[1;30m" );
+
+                case Colour::LightGrey:     return setColour( "[0;37m" );
+                case Colour::BrightRed:     return setColour( "[1;31m" );
+                case Colour::BrightGreen:   return setColour( "[1;32m" );
+                case Colour::BrightWhite:   return setColour( "[1;37m" );
+                case Colour::BrightYellow:  return setColour( "[1;33m" );
+
+                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
+            }
+        }
+        static IColourImpl* instance() {
+            static PosixColourImpl s_instance;
+            return &s_instance;
+        }
+
+    private:
+        void setColour( const char* _escapeCode ) {
+            getCurrentContext().getConfig()->stream()
+                << '\033' << _escapeCode;
+        }
+    };
+
+    bool useColourOnPlatform() {
+        return
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+            !isDebuggerActive() &&
+#endif
+#if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
+            isatty(STDOUT_FILENO)
+#else
+            false
+#endif
+            ;
+    }
+    IColourImpl* platformColourInstance() {
+        ErrnoGuard guard;
+        IConfigPtr config = getCurrentContext().getConfig();
+        UseColour::YesOrNo colourMode = config
+            ? config->useColour()
+            : UseColour::Auto;
+        if( colourMode == UseColour::Auto )
+            colourMode = useColourOnPlatform()
+                ? UseColour::Yes
+                : UseColour::No;
+        return colourMode == UseColour::Yes
+            ? PosixColourImpl::instance()
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#else  // not Windows or ANSI ///////////////////////////////////////////////
+
+namespace Catch {
+
+    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
+
+} // end namespace Catch
+
+#endif // Windows/ ANSI/ None
+
+namespace Catch {
+
+    Colour::Colour( Code _colourCode ) { use( _colourCode ); }
+    Colour::Colour( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.m_moved = true;
+    }
+    Colour& Colour::operator=( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.m_moved  = true;
+        return *this;
+    }
+
+    Colour::~Colour(){ if( !m_moved ) use( None ); }
+
+    void Colour::use( Code _colourCode ) {
+        static IColourImpl* impl = platformColourInstance();
+        // Strictly speaking, this cannot possibly happen.
+        // However, under some conditions it does happen (see #1626),
+        // and this change is small enough that we can let practicality
+        // triumph over purity in this case.
+        if (impl != nullptr) {
+            impl->use( _colourCode );
+        }
+    }
+
+    std::ostream& operator << ( std::ostream& os, Colour const& ) {
+        return os;
+    }
+
+} // end namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+// end catch_console_colour.cpp
+// start catch_context.cpp
+
+namespace Catch {
+
+    class Context : public IMutableContext, NonCopyable {
+
+    public: // IContext
+        IResultCapture* getResultCapture() override {
+            return m_resultCapture;
+        }
+        IRunner* getRunner() override {
+            return m_runner;
+        }
+
+        IConfigPtr const& getConfig() const override {
+            return m_config;
+        }
+
+        ~Context() override;
+
+    public: // IMutableContext
+        void setResultCapture( IResultCapture* resultCapture ) override {
+            m_resultCapture = resultCapture;
+        }
+        void setRunner( IRunner* runner ) override {
+            m_runner = runner;
+        }
+        void setConfig( IConfigPtr const& config ) override {
+            m_config = config;
+        }
+
+        friend IMutableContext& getCurrentMutableContext();
+
+    private:
+        IConfigPtr m_config;
+        IRunner* m_runner = nullptr;
+        IResultCapture* m_resultCapture = nullptr;
+    };
+
+    IMutableContext *IMutableContext::currentContext = nullptr;
+
+    void IMutableContext::createContext()
+    {
+        currentContext = new Context();
+    }
+
+    void cleanUpContext() {
+        delete IMutableContext::currentContext;
+        IMutableContext::currentContext = nullptr;
+    }
+    IContext::~IContext() = default;
+    IMutableContext::~IMutableContext() = default;
+    Context::~Context() = default;
+
+    SimplePcg32& rng() {
+        static SimplePcg32 s_rng;
+        return s_rng;
+    }
+
+}
+// end catch_context.cpp
+// start catch_debug_console.cpp
+
+// start catch_debug_console.h
+
+#include <string>
+
+namespace Catch {
+    void writeToDebugConsole( std::string const& text );
+}
+
+// end catch_debug_console.h
+#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#include <android/log.h>
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
+        }
+    }
+
+#elif defined(CATCH_PLATFORM_WINDOWS)
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            ::OutputDebugStringA( text.c_str() );
+        }
+    }
+
+#else
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            // !TBD: Need a version for Mac/ XCode and other IDEs
+            Catch::cout() << text;
+        }
+    }
+
+#endif // Platform
+// end catch_debug_console.cpp
+// start catch_debugger.cpp
+
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+
+#  include <assert.h>
+#  include <stdbool.h>
+#  include <sys/types.h>
+#  include <unistd.h>
+#  include <cstddef>
+#  include <ostream>
+
+#ifdef __apple_build_version__
+    // These headers will only compile with AppleClang (XCode)
+    // For other compilers (Clang, GCC, ... ) we need to exclude them
+#  include <sys/sysctl.h>
+#endif
+
+    namespace Catch {
+        #ifdef __apple_build_version__
+        // The following function is taken directly from the following technical note:
+        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
+
+        // Returns true if the current process is being debugged (either
+        // running under the debugger or has a debugger attached post facto).
+        bool isDebuggerActive(){
+            int                 mib[4];
+            struct kinfo_proc   info;
+            std::size_t         size;
+
+            // Initialize the flags so that, if sysctl fails for some bizarre
+            // reason, we get a predictable result.
+
+            info.kp_proc.p_flag = 0;
+
+            // Initialize mib, which tells sysctl the info we want, in this case
+            // we're looking for information about a specific process ID.
+
+            mib[0] = CTL_KERN;
+            mib[1] = KERN_PROC;
+            mib[2] = KERN_PROC_PID;
+            mib[3] = getpid();
+
+            // Call sysctl.
+
+            size = sizeof(info);
+            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
+                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
+                return false;
+            }
+
+            // We're being debugged if the P_TRACED flag is set.
+
+            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+        }
+        #else
+        bool isDebuggerActive() {
+            // We need to find another way to determine this for non-appleclang compilers on macOS
+            return false;
+        }
+        #endif
+    } // namespace Catch
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    #include <fstream>
+    #include <string>
+
+    namespace Catch{
+        // The standard POSIX way of detecting a debugger is to attempt to
+        // ptrace() the process, but this needs to be done from a child and not
+        // this process itself to still allow attaching to this process later
+        // if wanted, so is rather heavy. Under Linux we have the PID of the
+        // "debugger" (which doesn't need to be gdb, of course, it could also
+        // be strace, for example) in /proc/$PID/status, so just get it from
+        // there instead.
+        bool isDebuggerActive(){
+            // Libstdc++ has a bug, where std::ifstream sets errno to 0
+            // This way our users can properly assert over errno values
+            ErrnoGuard guard;
+            std::ifstream in("/proc/self/status");
+            for( std::string line; std::getline(in, line); ) {
+                static const int PREFIX_LEN = 11;
+                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
+                    // We're traced if the PID is not 0 and no other PID starts
+                    // with 0 digit, so it's enough to check for just a single
+                    // character.
+                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
+                }
+            }
+
+            return false;
+        }
+    } // namespace Catch
+#elif defined(_MSC_VER)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#else
+    namespace Catch {
+       bool isDebuggerActive() { return false; }
+    }
+#endif // Platform
+// end catch_debugger.cpp
+// start catch_decomposer.cpp
+
+namespace Catch {
+
+    ITransientExpression::~ITransientExpression() = default;
+
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
+        if( lhs.size() + rhs.size() < 40 &&
+                lhs.find('\n') == std::string::npos &&
+                rhs.find('\n') == std::string::npos )
+            os << lhs << " " << op << " " << rhs;
+        else
+            os << lhs << "\n" << op << "\n" << rhs;
+    }
+}
+// end catch_decomposer.cpp
+// start catch_enforce.cpp
+
+#include <stdexcept>
+
+namespace Catch {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
+    [[noreturn]]
+    void throw_exception(std::exception const& e) {
+        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
+                      << "The message was: " << e.what() << '\n';
+        std::terminate();
+    }
+#endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg) {
+        throw_exception(std::logic_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg) {
+        throw_exception(std::domain_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg) {
+        throw_exception(std::runtime_error(msg));
+    }
+
+} // namespace Catch;
+// end catch_enforce.cpp
+// start catch_enum_values_registry.cpp
+// start catch_enum_values_registry.h
+
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    namespace Detail {
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+
+        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
+
+            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
+
+            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
+        };
+
+        std::vector<StringRef> parseEnums( StringRef enums );
+
+    } // Detail
+
+} // Catch
+
+// end catch_enum_values_registry.h
+
+#include <map>
+#include <cassert>
+
+namespace Catch {
+
+    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
+
+    namespace Detail {
+
+        namespace {
+            // Extracts the actual name part of an enum instance
+            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
+            StringRef extractInstanceName(StringRef enumInstance) {
+                // Find last occurence of ":"
+                size_t name_start = enumInstance.size();
+                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
+                    --name_start;
+                }
+                return enumInstance.substr(name_start, enumInstance.size() - name_start);
+            }
+        }
+
+        std::vector<StringRef> parseEnums( StringRef enums ) {
+            auto enumValues = splitStringRef( enums, ',' );
+            std::vector<StringRef> parsed;
+            parsed.reserve( enumValues.size() );
+            for( auto const& enumValue : enumValues ) {
+                parsed.push_back(trim(extractInstanceName(enumValue)));
+            }
+            return parsed;
+        }
+
+        EnumInfo::~EnumInfo() {}
+
+        StringRef EnumInfo::lookup( int value ) const {
+            for( auto const& valueToName : m_values ) {
+                if( valueToName.first == value )
+                    return valueToName.second;
+            }
+            return "{** unexpected enum value **}"_sr;
+        }
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
+            enumInfo->m_name = enumName;
+            enumInfo->m_values.reserve( values.size() );
+
+            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
+            assert( valueNames.size() == values.size() );
+            std::size_t i = 0;
+            for( auto value : values )
+                enumInfo->m_values.emplace_back(value, valueNames[i++]);
+
+            return enumInfo;
+        }
+
+        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
+            return *m_enumInfos.back();
+        }
+
+    } // Detail
+} // Catch
+
+// end catch_enum_values_registry.cpp
+// start catch_errno_guard.cpp
+
+#include <cerrno>
+
+namespace Catch {
+        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
+        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
+}
+// end catch_errno_guard.cpp
+// start catch_exception_translator_registry.cpp
+
+// start catch_exception_translator_registry.h
+
+#include <vector>
+#include <string>
+#include <memory>
+
+namespace Catch {
+
+    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+    public:
+        ~ExceptionTranslatorRegistry();
+        virtual void registerTranslator( const IExceptionTranslator* translator );
+        std::string translateActiveException() const override;
+        std::string tryTranslators() const;
+
+    private:
+        std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
+    };
+}
+
+// end catch_exception_translator_registry.h
+#ifdef __OBJC__
+#import "Foundation/Foundation.h"
+#endif
+
+namespace Catch {
+
+    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
+    }
+
+    void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
+        m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
+    }
+
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        try {
+#ifdef __OBJC__
+            // In Objective-C try objective-c exceptions first
+            @try {
+                return tryTranslators();
+            }
+            @catch (NSException *exception) {
+                return Catch::Detail::stringify( [exception description] );
+            }
+#else
+            // Compiling a mixed mode project with MSVC means that CLR
+            // exceptions will be caught in (...) as well. However, these
+            // do not fill-in std::current_exception and thus lead to crash
+            // when attempting rethrow.
+            // /EHa switch also causes structured exceptions to be caught
+            // here, but they fill-in current_exception properly, so
+            // at worst the output should be a little weird, instead of
+            // causing a crash.
+            if (std::current_exception() == nullptr) {
+                return "Non C++ exception. Possibly a CLR exception.";
+            }
+            return tryTranslators();
+#endif
+        }
+        catch( TestFailureException& ) {
+            std::rethrow_exception(std::current_exception());
+        }
+        catch( std::exception& ex ) {
+            return ex.what();
+        }
+        catch( std::string& msg ) {
+            return msg;
+        }
+        catch( const char* msg ) {
+            return msg;
+        }
+        catch(...) {
+            return "Unknown exception";
+        }
+    }
+
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        if (m_translators.empty()) {
+            std::rethrow_exception(std::current_exception());
+        } else {
+            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
+        }
+    }
+
+#else // ^^ Exceptions are enabled // Exceptions are disabled vv
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+    }
+
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+    }
+#endif
+
+}
+// end catch_exception_translator_registry.cpp
+// start catch_fatal_condition.cpp
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace {
+    // Report the error condition
+    void reportFatal( char const * const message ) {
+        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
+    }
+}
+
+#endif // signals/SEH handling
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+    struct SignalDefs { DWORD id; const char* name; };
+
+    // There is no 1-1 mapping between signals and windows exceptions.
+    // Windows can easily distinguish between SO and SigSegV,
+    // but SigInt, SigTerm, etc are handled differently.
+    static SignalDefs signalDefs[] = {
+        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
+        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
+        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
+        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
+    };
+
+    LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
+        for (auto const& def : signalDefs) {
+            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
+                reportFatal(def.name);
+            }
+        }
+        // If its not an exception we care about, pass it along.
+        // This stops us from eating debugger breaks etc.
+        return EXCEPTION_CONTINUE_SEARCH;
+    }
+
+    FatalConditionHandler::FatalConditionHandler() {
+        isSet = true;
+        // 32k seems enough for Catch to handle stack overflow,
+        // but the value was found experimentally, so there is no strong guarantee
+        guaranteeSize = 32 * 1024;
+        exceptionHandlerHandle = nullptr;
+        // Register as first handler in current chain
+        exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+        // Pass in guarantee size to be filled
+        SetThreadStackGuarantee(&guaranteeSize);
+    }
+
+    void FatalConditionHandler::reset() {
+        if (isSet) {
+            RemoveVectoredExceptionHandler(exceptionHandlerHandle);
+            SetThreadStackGuarantee(&guaranteeSize);
+            exceptionHandlerHandle = nullptr;
+            isSet = false;
+        }
+    }
+
+    FatalConditionHandler::~FatalConditionHandler() {
+        reset();
+    }
+
+bool FatalConditionHandler::isSet = false;
+ULONG FatalConditionHandler::guaranteeSize = 0;
+PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
+
+} // namespace Catch
+
+#elif defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace Catch {
+
+    struct SignalDefs {
+        int id;
+        const char* name;
+    };
+
+    // 32kb for the alternate stack seems to be sufficient. However, this value
+    // is experimentally determined, so that's not guaranteed.
+    static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
+
+    static SignalDefs signalDefs[] = {
+        { SIGINT,  "SIGINT - Terminal interrupt signal" },
+        { SIGILL,  "SIGILL - Illegal instruction signal" },
+        { SIGFPE,  "SIGFPE - Floating point error signal" },
+        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+        { SIGTERM, "SIGTERM - Termination request signal" },
+        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+    };
+
+    void FatalConditionHandler::handleSignal( int sig ) {
+        char const * name = "<unknown signal>";
+        for (auto const& def : signalDefs) {
+            if (sig == def.id) {
+                name = def.name;
+                break;
+            }
+        }
+        reset();
+        reportFatal(name);
+        raise( sig );
+    }
+
+    FatalConditionHandler::FatalConditionHandler() {
+        isSet = true;
+        stack_t sigStack;
+        sigStack.ss_sp = altStackMem;
+        sigStack.ss_size = sigStackSize;
+        sigStack.ss_flags = 0;
+        sigaltstack(&sigStack, &oldSigStack);
+        struct sigaction sa = { };
+
+        sa.sa_handler = handleSignal;
+        sa.sa_flags = SA_ONSTACK;
+        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
+            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
+        }
+    }
+
+    FatalConditionHandler::~FatalConditionHandler() {
+        reset();
+    }
+
+    void FatalConditionHandler::reset() {
+        if( isSet ) {
+            // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
+            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
+                sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
+            }
+            // Return the old stack
+            sigaltstack(&oldSigStack, nullptr);
+            isSet = false;
+        }
+    }
+
+    bool FatalConditionHandler::isSet = false;
+    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
+    stack_t FatalConditionHandler::oldSigStack = {};
+    char FatalConditionHandler::altStackMem[sigStackSize] = {};
+
+} // namespace Catch
+
+#else
+
+namespace Catch {
+    void FatalConditionHandler::reset() {}
+}
+
+#endif // signals/SEH handling
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+// end catch_fatal_condition.cpp
+// start catch_generators.cpp
+
+#include <limits>
+#include <set>
+
+namespace Catch {
+
+IGeneratorTracker::~IGeneratorTracker() {}
+
+const char* GeneratorException::what() const noexcept {
+    return m_msg;
+}
+
+namespace Generators {
+
+    GeneratorUntypedBase::~GeneratorUntypedBase() {}
+
+    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        return getResultCapture().acquireGeneratorTracker( lineInfo );
+    }
+
+} // namespace Generators
+} // namespace Catch
+// end catch_generators.cpp
+// start catch_interfaces_capture.cpp
+
+namespace Catch {
+    IResultCapture::~IResultCapture() = default;
+}
+// end catch_interfaces_capture.cpp
+// start catch_interfaces_config.cpp
+
+namespace Catch {
+    IConfig::~IConfig() = default;
+}
+// end catch_interfaces_config.cpp
+// start catch_interfaces_exception.cpp
+
+namespace Catch {
+    IExceptionTranslator::~IExceptionTranslator() = default;
+    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
+}
+// end catch_interfaces_exception.cpp
+// start catch_interfaces_registry_hub.cpp
+
+namespace Catch {
+    IRegistryHub::~IRegistryHub() = default;
+    IMutableRegistryHub::~IMutableRegistryHub() = default;
+}
+// end catch_interfaces_registry_hub.cpp
+// start catch_interfaces_reporter.cpp
+
+// start catch_reporter_listening.h
+
+namespace Catch {
+
+    class ListeningReporter : public IStreamingReporter {
+        using Reporters = std::vector<IStreamingReporterPtr>;
+        Reporters m_listeners;
+        IStreamingReporterPtr m_reporter = nullptr;
+        ReporterPreferences m_preferences;
+
+    public:
+        ListeningReporter();
+
+        void addListener( IStreamingReporterPtr&& listener );
+        void addReporter( IStreamingReporterPtr&& reporter );
+
+    public: // IStreamingReporter
+
+        ReporterPreferences getPreferences() const override;
+
+        void noMatchingTestCases( std::string const& spec ) override;
+
+        void reportInvalidArguments(std::string const&arg) override;
+
+        static std::set<Verbosity> getSupportedVerbosities();
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void testRunStarting( TestRunInfo const& testRunInfo ) override;
+        void testGroupStarting( GroupInfo const& groupInfo ) override;
+        void testCaseStarting( TestCaseInfo const& testInfo ) override;
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+        void assertionStarting( AssertionInfo const& assertionInfo ) override;
+
+        // The return value indicates if the messages buffer should be cleared:
+        bool assertionEnded( AssertionStats const& assertionStats ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
+        void testRunEnded( TestRunStats const& testRunStats ) override;
+
+        void skipTest( TestCaseInfo const& testInfo ) override;
+        bool isMulti() const override;
+
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_listening.h
+namespace Catch {
+
+    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
+    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
+
+    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
+    :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
+
+    std::ostream& ReporterConfig::stream() const { return *m_stream; }
+    IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
+
+    TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
+
+    GroupInfo::GroupInfo(  std::string const& _name,
+                           std::size_t _groupIndex,
+                           std::size_t _groupsCount )
+    :   name( _name ),
+        groupIndex( _groupIndex ),
+        groupsCounts( _groupsCount )
+    {}
+
+     AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
+                                     std::vector<MessageInfo> const& _infoMessages,
+                                     Totals const& _totals )
+    :   assertionResult( _assertionResult ),
+        infoMessages( _infoMessages ),
+        totals( _totals )
+    {
+        assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
+
+        if( assertionResult.hasMessage() ) {
+            // Copy message into messages list.
+            // !TBD This should have been done earlier, somewhere
+            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+            builder << assertionResult.getMessage();
+            builder.m_info.message = builder.m_stream.str();
+
+            infoMessages.push_back( builder.m_info );
+        }
+    }
+
+     AssertionStats::~AssertionStats() = default;
+
+    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
+                                 Counts const& _assertions,
+                                 double _durationInSeconds,
+                                 bool _missingAssertions )
+    :   sectionInfo( _sectionInfo ),
+        assertions( _assertions ),
+        durationInSeconds( _durationInSeconds ),
+        missingAssertions( _missingAssertions )
+    {}
+
+    SectionStats::~SectionStats() = default;
+
+    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
+                                   Totals const& _totals,
+                                   std::string const& _stdOut,
+                                   std::string const& _stdErr,
+                                   bool _aborting )
+    : testInfo( _testInfo ),
+        totals( _totals ),
+        stdOut( _stdOut ),
+        stdErr( _stdErr ),
+        aborting( _aborting )
+    {}
+
+    TestCaseStats::~TestCaseStats() = default;
+
+    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
+                                    Totals const& _totals,
+                                    bool _aborting )
+    :   groupInfo( _groupInfo ),
+        totals( _totals ),
+        aborting( _aborting )
+    {}
+
+    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
+    :   groupInfo( _groupInfo ),
+        aborting( false )
+    {}
+
+    TestGroupStats::~TestGroupStats() = default;
+
+    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
+                    Totals const& _totals,
+                    bool _aborting )
+    :   runInfo( _runInfo ),
+        totals( _totals ),
+        aborting( _aborting )
+    {}
+
+    TestRunStats::~TestRunStats() = default;
+
+    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
+    bool IStreamingReporter::isMulti() const { return false; }
+
+    IReporterFactory::~IReporterFactory() = default;
+    IReporterRegistry::~IReporterRegistry() = default;
+
+} // end namespace Catch
+// end catch_interfaces_reporter.cpp
+// start catch_interfaces_runner.cpp
+
+namespace Catch {
+    IRunner::~IRunner() = default;
+}
+// end catch_interfaces_runner.cpp
+// start catch_interfaces_testcase.cpp
+
+namespace Catch {
+    ITestInvoker::~ITestInvoker() = default;
+    ITestCaseRegistry::~ITestCaseRegistry() = default;
+}
+// end catch_interfaces_testcase.cpp
+// start catch_leak_detector.cpp
+
+#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+#include <crtdbg.h>
+
+namespace Catch {
+
+    LeakDetector::LeakDetector() {
+        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flag |= _CRTDBG_LEAK_CHECK_DF;
+        flag |= _CRTDBG_ALLOC_MEM_DF;
+        _CrtSetDbgFlag(flag);
+        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+        // Change this to leaking allocation's number to break there
+        _CrtSetBreakAlloc(-1);
+    }
+}
+
+#else
+
+    Catch::LeakDetector::LeakDetector() {}
+
+#endif
+
+Catch::LeakDetector::~LeakDetector() {
+    Catch::cleanUp();
+}
+// end catch_leak_detector.cpp
+// start catch_list.cpp
+
+// start catch_list.h
+
+#include <set>
+
+namespace Catch {
+
+    std::size_t listTests( Config const& config );
+
+    std::size_t listTestsNamesOnly( Config const& config );
+
+    struct TagInfo {
+        void add( std::string const& spelling );
+        std::string all() const;
+
+        std::set<std::string> spellings;
+        std::size_t count = 0;
+    };
+
+    std::size_t listTags( Config const& config );
+
+    std::size_t listReporters();
+
+    Option<std::size_t> list( std::shared_ptr<Config> const& config );
+
+} // end namespace Catch
+
+// end catch_list.h
+// start catch_text.h
+
+namespace Catch {
+    using namespace clara::TextFlow;
+}
+
+// end catch_text.h
+#include <limits>
+#include <algorithm>
+#include <iomanip>
+
+namespace Catch {
+
+    std::size_t listTests( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        if( config.hasTestFilters() )
+            Catch::cout() << "Matching test cases:\n";
+        else {
+            Catch::cout() << "All available test cases:\n";
+        }
+
+        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCaseInfo : matchedTestCases ) {
+            Colour::Code colour = testCaseInfo.isHidden()
+                ? Colour::SecondaryText
+                : Colour::None;
+            Colour colourGuard( colour );
+
+            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
+            if( config.verbosity() >= Verbosity::High ) {
+                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
+                std::string description = testCaseInfo.description;
+                if( description.empty() )
+                    description = "(NO DESCRIPTION)";
+                Catch::cout() << Column( description ).indent(4) << std::endl;
+            }
+            if( !testCaseInfo.tags.empty() )
+                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
+        }
+
+        if( !config.hasTestFilters() )
+            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
+        else
+            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
+        return matchedTestCases.size();
+    }
+
+    std::size_t listTestsNamesOnly( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        std::size_t matchedTests = 0;
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCaseInfo : matchedTestCases ) {
+            matchedTests++;
+            if( startsWith( testCaseInfo.name, '#' ) )
+               Catch::cout() << '"' << testCaseInfo.name << '"';
+            else
+               Catch::cout() << testCaseInfo.name;
+            if ( config.verbosity() >= Verbosity::High )
+                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
+            Catch::cout() << std::endl;
+        }
+        return matchedTests;
+    }
+
+    void TagInfo::add( std::string const& spelling ) {
+        ++count;
+        spellings.insert( spelling );
+    }
+
+    std::string TagInfo::all() const {
+        size_t size = 0;
+        for (auto const& spelling : spellings) {
+            // Add 2 for the brackes
+            size += spelling.size() + 2;
+        }
+
+        std::string out; out.reserve(size);
+        for (auto const& spelling : spellings) {
+            out += '[';
+            out += spelling;
+            out += ']';
+        }
+        return out;
+    }
+
+    std::size_t listTags( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        if( config.hasTestFilters() )
+            Catch::cout() << "Tags for matching test cases:\n";
+        else {
+            Catch::cout() << "All available tags:\n";
+        }
+
+        std::map<std::string, TagInfo> tagCounts;
+
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCase : matchedTestCases ) {
+            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
+                std::string lcaseTagName = toLower( tagName );
+                auto countIt = tagCounts.find( lcaseTagName );
+                if( countIt == tagCounts.end() )
+                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
+                countIt->second.add( tagName );
+            }
+        }
+
+        for( auto const& tagCount : tagCounts ) {
+            ReusableStringStream rss;
+            rss << "  " << std::setw(2) << tagCount.second.count << "  ";
+            auto str = rss.str();
+            auto wrapper = Column( tagCount.second.all() )
+                                                    .initialIndent( 0 )
+                                                    .indent( str.size() )
+                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
+            Catch::cout() << str << wrapper << '\n';
+        }
+        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
+        return tagCounts.size();
+    }
+
+    std::size_t listReporters() {
+        Catch::cout() << "Available reporters:\n";
+        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+        std::size_t maxNameLen = 0;
+        for( auto const& factoryKvp : factories )
+            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
+
+        for( auto const& factoryKvp : factories ) {
+            Catch::cout()
+                    << Column( factoryKvp.first + ":" )
+                            .indent(2)
+                            .width( 5+maxNameLen )
+                    +  Column( factoryKvp.second->getDescription() )
+                            .initialIndent(0)
+                            .indent(2)
+                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
+                    << "\n";
+        }
+        Catch::cout() << std::endl;
+        return factories.size();
+    }
+
+    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
+        Option<std::size_t> listedCount;
+        getCurrentMutableContext().setConfig( config );
+        if( config->listTests() )
+            listedCount = listedCount.valueOr(0) + listTests( *config );
+        if( config->listTestNamesOnly() )
+            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
+        if( config->listTags() )
+            listedCount = listedCount.valueOr(0) + listTags( *config );
+        if( config->listReporters() )
+            listedCount = listedCount.valueOr(0) + listReporters();
+        return listedCount;
+    }
+
+} // end namespace Catch
+// end catch_list.cpp
+// start catch_matchers.cpp
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+        std::string MatcherUntypedBase::toString() const {
+            if( m_cachedToString.empty() )
+                m_cachedToString = describe();
+            return m_cachedToString;
+        }
+
+        MatcherUntypedBase::~MatcherUntypedBase() = default;
+
+    } // namespace Impl
+} // namespace Matchers
+
+using namespace Matchers;
+using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+// end catch_matchers.cpp
+// start catch_matchers_exception.cpp
+
+namespace Catch {
+namespace Matchers {
+namespace Exception {
+
+bool ExceptionMessageMatcher::match(std::exception const& ex) const {
+    return ex.what() == m_message;
+}
+
+std::string ExceptionMessageMatcher::describe() const {
+    return "exception message matches \"" + m_message + "\"";
+}
+
+}
+Exception::ExceptionMessageMatcher Message(std::string const& message) {
+    return Exception::ExceptionMessageMatcher(message);
+}
+
+// namespace Exception
+} // namespace Matchers
+} // namespace Catch
+// end catch_matchers_exception.cpp
+// start catch_matchers_floating.cpp
+
+// start catch_polyfills.hpp
+
+namespace Catch {
+    bool isnan(float f);
+    bool isnan(double d);
+}
+
+// end catch_polyfills.hpp
+// start catch_to_string.hpp
+
+#include <string>
+
+namespace Catch {
+    template <typename T>
+    std::string to_string(T const& t) {
+#if defined(CATCH_CONFIG_CPP11_TO_STRING)
+        return std::to_string(t);
+#else
+        ReusableStringStream rss;
+        rss << t;
+        return rss.str();
+#endif
+    }
+} // end namespace Catch
+
+// end catch_to_string.hpp
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstdint>
+#include <cstring>
+#include <sstream>
+#include <type_traits>
+#include <iomanip>
+#include <limits>
+
+namespace Catch {
+namespace {
+
+    int32_t convert(float f) {
+        static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
+        int32_t i;
+        std::memcpy(&i, &f, sizeof(f));
+        return i;
+    }
+
+    int64_t convert(double d) {
+        static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
+        int64_t i;
+        std::memcpy(&i, &d, sizeof(d));
+        return i;
+    }
+
+    template <typename FP>
+    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
+        // Comparison with NaN should always be false.
+        // This way we can rule it out before getting into the ugly details
+        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
+            return false;
+        }
+
+        auto lc = convert(lhs);
+        auto rc = convert(rhs);
+
+        if ((lc < 0) != (rc < 0)) {
+            // Potentially we can have +0 and -0
+            return lhs == rhs;
+        }
+
+        auto ulpDiff = std::abs(lc - rc);
+        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
+    }
+
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+
+    float nextafter(float x, float y) {
+        return ::nextafterf(x, y);
+    }
+
+    double nextafter(double x, double y) {
+        return ::nextafter(x, y);
+    }
+
+#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
+
+template <typename FP>
+FP step(FP start, FP direction, uint64_t steps) {
+    for (uint64_t i = 0; i < steps; ++i) {
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+        start = Catch::nextafter(start, direction);
+#else
+        start = std::nextafter(start, direction);
+#endif
+    }
+    return start;
+}
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+template <typename FloatingPoint>
+void write(std::ostream& out, FloatingPoint num) {
+    out << std::scientific
+        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
+        << num;
+}
+
+} // end anonymous namespace
+
+namespace Matchers {
+namespace Floating {
+
+    enum class FloatingPointKind : uint8_t {
+        Float,
+        Double
+    };
+
+    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
+        :m_target{ target }, m_margin{ margin } {
+        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
+            << " Margin has to be non-negative.");
+    }
+
+    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
+    // But without the subtraction to allow for INFINITY in comparison
+    bool WithinAbsMatcher::match(double const& matchee) const {
+        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
+    }
+
+    std::string WithinAbsMatcher::describe() const {
+        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
+    }
+
+    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
+        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
+        CATCH_ENFORCE(m_type == FloatingPointKind::Double
+                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
+            "Provided ULP is impossibly large for a float comparison.");
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Clang <3.5 reports on the default branch in the switch below
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+
+    bool WithinUlpsMatcher::match(double const& matchee) const {
+        switch (m_type) {
+        case FloatingPointKind::Float:
+            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
+        case FloatingPointKind::Double:
+            return almostEqualUlps<double>(matchee, m_target, m_ulps);
+        default:
+            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
+        }
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+    std::string WithinUlpsMatcher::describe() const {
+        std::stringstream ret;
+
+        ret << "is within " << m_ulps << " ULPs of ";
+
+        if (m_type == FloatingPointKind::Float) {
+            write(ret, static_cast<float>(m_target));
+            ret << 'f';
+        } else {
+            write(ret, m_target);
+        }
+
+        ret << " ([";
+        if (m_type == FloatingPointKind::Double) {
+            write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
+            ret << ", ";
+            write(ret, step(m_target, static_cast<double>( INFINITY), m_ulps));
+        } else {
+            // We have to cast INFINITY to float because of MinGW, see #1782
+            write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
+            ret << ", ";
+            write(ret, step(static_cast<float>(m_target), static_cast<float>( INFINITY), m_ulps));
+        }
+        ret << "])";
+
+        return ret.str();
+    }
+
+    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
+        m_target(target),
+        m_epsilon(epsilon){
+        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
+        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
+    }
+
+    bool WithinRelMatcher::match(double const& matchee) const {
+        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
+        return marginComparison(matchee, m_target,
+                                std::isinf(relMargin)? 0 : relMargin);
+    }
+
+    std::string WithinRelMatcher::describe() const {
+        Catch::ReusableStringStream sstr;
+        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
+        return sstr.str();
+    }
+
+}// namespace Floating
+
+Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
+    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
+}
+
+Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
+    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
+}
+
+Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
+    return Floating::WithinAbsMatcher(target, margin);
+}
+
+Floating::WithinRelMatcher WithinRel(double target, double eps) {
+    return Floating::WithinRelMatcher(target, eps);
+}
+
+Floating::WithinRelMatcher WithinRel(double target) {
+    return Floating::WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
+}
+
+Floating::WithinRelMatcher WithinRel(float target, float eps) {
+    return Floating::WithinRelMatcher(target, eps);
+}
+
+Floating::WithinRelMatcher WithinRel(float target) {
+    return Floating::WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
+}
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_floating.cpp
+// start catch_matchers_generic.cpp
+
+std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
+    if (desc.empty()) {
+        return "matches undescribed predicate";
+    } else {
+        return "matches predicate: \"" + desc + '"';
+    }
+}
+// end catch_matchers_generic.cpp
+// start catch_matchers_string.cpp
+
+#include <regex>
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
+        :   m_caseSensitivity( caseSensitivity ),
+            m_str( adjustString( str ) )
+        {}
+        std::string CasedString::adjustString( std::string const& str ) const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? toLower( str )
+                   : str;
+        }
+        std::string CasedString::caseSensitivitySuffix() const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? " (case insensitive)"
+                   : std::string();
+        }
+
+        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
+        : m_comparator( comparator ),
+          m_operation( operation ) {
+        }
+
+        std::string StringMatcherBase::describe() const {
+            std::string description;
+            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
+                                        m_comparator.caseSensitivitySuffix().size());
+            description += m_operation;
+            description += ": \"";
+            description += m_comparator.m_str;
+            description += "\"";
+            description += m_comparator.caseSensitivitySuffix();
+            return description;
+        }
+
+        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
+
+        bool EqualsMatcher::match( std::string const& source ) const {
+            return m_comparator.adjustString( source ) == m_comparator.m_str;
+        }
+
+        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
+
+        bool ContainsMatcher::match( std::string const& source ) const {
+            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
+
+        bool StartsWithMatcher::match( std::string const& source ) const {
+            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
+
+        bool EndsWithMatcher::match( std::string const& source ) const {
+            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
+
+        bool RegexMatcher::match(std::string const& matchee) const {
+            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
+            if (m_caseSensitivity == CaseSensitive::Choice::No) {
+                flags |= std::regex::icase;
+            }
+            auto reg = std::regex(m_regex, flags);
+            return std::regex_match(matchee, reg);
+        }
+
+        std::string RegexMatcher::describe() const {
+            return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
+        }
+
+    } // namespace StdString
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+
+    StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
+        return StdString::RegexMatcher(regex, caseSensitivity);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+// end catch_matchers_string.cpp
+// start catch_message.cpp
+
+// start catch_uncaught_exceptions.h
+
+namespace Catch {
+    bool uncaught_exceptions();
+} // end namespace Catch
+
+// end catch_uncaught_exceptions.h
+#include <cassert>
+#include <stack>
+
+namespace Catch {
+
+    MessageInfo::MessageInfo(   StringRef const& _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        type( _type ),
+        sequence( ++globalCount )
+    {}
+
+    bool MessageInfo::operator==( MessageInfo const& other ) const {
+        return sequence == other.sequence;
+    }
+
+    bool MessageInfo::operator<( MessageInfo const& other ) const {
+        return sequence < other.sequence;
+    }
+
+    // This may need protecting if threading support is added
+    unsigned int MessageInfo::globalCount = 0;
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
+                                           SourceLineInfo const& lineInfo,
+                                           ResultWas::OfType type )
+        :m_info(macroName, lineInfo, type) {}
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
+    : m_info( builder.m_info ), m_moved()
+    {
+        m_info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( m_info );
+    }
+
+    ScopedMessage::ScopedMessage( ScopedMessage&& old )
+    : m_info( old.m_info ), m_moved()
+    {
+        old.m_moved = true;
+    }
+
+    ScopedMessage::~ScopedMessage() {
+        if ( !uncaught_exceptions() && !m_moved ){
+            getResultCapture().popScopedMessage(m_info);
+        }
+    }
+
+    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
+        auto trimmed = [&] (size_t start, size_t end) {
+            while (names[start] == ',' || isspace(names[start])) {
+                ++start;
+            }
+            while (names[end] == ',' || isspace(names[end])) {
+                --end;
+            }
+            return names.substr(start, end - start + 1);
+        };
+        auto skipq = [&] (size_t start, char quote) {
+            for (auto i = start + 1; i < names.size() ; ++i) {
+                if (names[i] == quote)
+                    return i;
+                if (names[i] == '\\')
+                    ++i;
+            }
+            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
+        };
+
+        size_t start = 0;
+        std::stack<char> openings;
+        for (size_t pos = 0; pos < names.size(); ++pos) {
+            char c = names[pos];
+            switch (c) {
+            case '[':
+            case '{':
+            case '(':
+            // It is basically impossible to disambiguate between
+            // comparison and start of template args in this context
+//            case '<':
+                openings.push(c);
+                break;
+            case ']':
+            case '}':
+            case ')':
+//           case '>':
+                openings.pop();
+                break;
+            case '"':
+            case '\'':
+                pos = skipq(pos, c);
+                break;
+            case ',':
+                if (start != pos && openings.empty()) {
+                    m_messages.emplace_back(macroName, lineInfo, resultType);
+                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
+                    m_messages.back().message += " := ";
+                    start = pos;
+                }
+            }
+        }
+        assert(openings.empty() && "Mismatched openings");
+        m_messages.emplace_back(macroName, lineInfo, resultType);
+        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
+        m_messages.back().message += " := ";
+    }
+    Capturer::~Capturer() {
+        if ( !uncaught_exceptions() ){
+            assert( m_captured == m_messages.size() );
+            for( size_t i = 0; i < m_captured; ++i  )
+                m_resultCapture.popScopedMessage( m_messages[i] );
+        }
+    }
+
+    void Capturer::captureValue( size_t index, std::string const& value ) {
+        assert( index < m_messages.size() );
+        m_messages[index].message += value;
+        m_resultCapture.pushScopedMessage( m_messages[index] );
+        m_captured++;
+    }
+
+} // end namespace Catch
+// end catch_message.cpp
+// start catch_output_redirect.cpp
+
+// start catch_output_redirect.h
+#ifndef TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+#define TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+
+#include <cstdio>
+#include <iosfwd>
+#include <string>
+
+namespace Catch {
+
+    class RedirectedStream {
+        std::ostream& m_originalStream;
+        std::ostream& m_redirectionStream;
+        std::streambuf* m_prevBuf;
+
+    public:
+        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
+        ~RedirectedStream();
+    };
+
+    class RedirectedStdOut {
+        ReusableStringStream m_rss;
+        RedirectedStream m_cout;
+    public:
+        RedirectedStdOut();
+        auto str() const -> std::string;
+    };
+
+    // StdErr has two constituent streams in C++, std::cerr and std::clog
+    // This means that we need to redirect 2 streams into 1 to keep proper
+    // order of writes
+    class RedirectedStdErr {
+        ReusableStringStream m_rss;
+        RedirectedStream m_cerr;
+        RedirectedStream m_clog;
+    public:
+        RedirectedStdErr();
+        auto str() const -> std::string;
+    };
+
+    class RedirectedStreams {
+    public:
+        RedirectedStreams(RedirectedStreams const&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
+        RedirectedStreams(RedirectedStreams&&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
+
+        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
+        ~RedirectedStreams();
+    private:
+        std::string& m_redirectedCout;
+        std::string& m_redirectedCerr;
+        RedirectedStdOut m_redirectedStdOut;
+        RedirectedStdErr m_redirectedStdErr;
+    };
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+    // Windows's implementation of std::tmpfile is terrible (it tries
+    // to create a file inside system folder, thus requiring elevated
+    // privileges for the binary), so we have to use tmpnam(_s) and
+    // create the file ourselves there.
+    class TempFile {
+    public:
+        TempFile(TempFile const&) = delete;
+        TempFile& operator=(TempFile const&) = delete;
+        TempFile(TempFile&&) = delete;
+        TempFile& operator=(TempFile&&) = delete;
+
+        TempFile();
+        ~TempFile();
+
+        std::FILE* getFile();
+        std::string getContents();
+
+    private:
+        std::FILE* m_file = nullptr;
+    #if defined(_MSC_VER)
+        char m_buffer[L_tmpnam] = { 0 };
+    #endif
+    };
+
+    class OutputRedirect {
+    public:
+        OutputRedirect(OutputRedirect const&) = delete;
+        OutputRedirect& operator=(OutputRedirect const&) = delete;
+        OutputRedirect(OutputRedirect&&) = delete;
+        OutputRedirect& operator=(OutputRedirect&&) = delete;
+
+        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
+        ~OutputRedirect();
+
+    private:
+        int m_originalStdout = -1;
+        int m_originalStderr = -1;
+        TempFile m_stdoutFile;
+        TempFile m_stderrFile;
+        std::string& m_stdoutDest;
+        std::string& m_stderrDest;
+    };
+
+#endif
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+// end catch_output_redirect.h
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #include <io.h>      //_dup and _dup2
+    #define dup _dup
+    #define dup2 _dup2
+    #define fileno _fileno
+    #else
+    #include <unistd.h>  // dup and dup2
+    #endif
+#endif
+
+namespace Catch {
+
+    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
+    :   m_originalStream( originalStream ),
+        m_redirectionStream( redirectionStream ),
+        m_prevBuf( m_originalStream.rdbuf() )
+    {
+        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
+    }
+
+    RedirectedStream::~RedirectedStream() {
+        m_originalStream.rdbuf( m_prevBuf );
+    }
+
+    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
+    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
+
+    RedirectedStdErr::RedirectedStdErr()
+    :   m_cerr( Catch::cerr(), m_rss.get() ),
+        m_clog( Catch::clog(), m_rss.get() )
+    {}
+    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
+
+    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
+    :   m_redirectedCout(redirectedCout),
+        m_redirectedCerr(redirectedCerr)
+    {}
+
+    RedirectedStreams::~RedirectedStreams() {
+        m_redirectedCout += m_redirectedStdOut.str();
+        m_redirectedCerr += m_redirectedStdErr.str();
+    }
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+#if defined(_MSC_VER)
+    TempFile::TempFile() {
+        if (tmpnam_s(m_buffer)) {
+            CATCH_RUNTIME_ERROR("Could not get a temp filename");
+        }
+        if (fopen_s(&m_file, m_buffer, "w")) {
+            char buffer[100];
+            if (strerror_s(buffer, errno)) {
+                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
+            }
+            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
+        }
+    }
+#else
+    TempFile::TempFile() {
+        m_file = std::tmpfile();
+        if (!m_file) {
+            CATCH_RUNTIME_ERROR("Could not create a temp file.");
+        }
+    }
+
+#endif
+
+    TempFile::~TempFile() {
+         // TBD: What to do about errors here?
+         std::fclose(m_file);
+         // We manually create the file on Windows only, on Linux
+         // it will be autodeleted
+#if defined(_MSC_VER)
+         std::remove(m_buffer);
+#endif
+    }
+
+    FILE* TempFile::getFile() {
+        return m_file;
+    }
+
+    std::string TempFile::getContents() {
+        std::stringstream sstr;
+        char buffer[100] = {};
+        std::rewind(m_file);
+        while (std::fgets(buffer, sizeof(buffer), m_file)) {
+            sstr << buffer;
+        }
+        return sstr.str();
+    }
+
+    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
+        m_originalStdout(dup(1)),
+        m_originalStderr(dup(2)),
+        m_stdoutDest(stdout_dest),
+        m_stderrDest(stderr_dest) {
+        dup2(fileno(m_stdoutFile.getFile()), 1);
+        dup2(fileno(m_stderrFile.getFile()), 2);
+    }
+
+    OutputRedirect::~OutputRedirect() {
+        Catch::cout() << std::flush;
+        fflush(stdout);
+        // Since we support overriding these streams, we flush cerr
+        // even though std::cerr is unbuffered
+        Catch::cerr() << std::flush;
+        Catch::clog() << std::flush;
+        fflush(stderr);
+
+        dup2(m_originalStdout, 1);
+        dup2(m_originalStderr, 2);
+
+        m_stdoutDest += m_stdoutFile.getContents();
+        m_stderrDest += m_stderrFile.getContents();
+    }
+
+#endif // CATCH_CONFIG_NEW_CAPTURE
+
+} // namespace Catch
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #undef dup
+    #undef dup2
+    #undef fileno
+    #endif
+#endif
+// end catch_output_redirect.cpp
+// start catch_polyfills.cpp
+
+#include <cmath>
+
+namespace Catch {
+
+#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+    bool isnan(float f) {
+        return std::isnan(f);
+    }
+    bool isnan(double d) {
+        return std::isnan(d);
+    }
+#else
+    // For now we only use this for embarcadero
+    bool isnan(float f) {
+        return std::_isnan(f);
+    }
+    bool isnan(double d) {
+        return std::_isnan(d);
+    }
+#endif
+
+} // end namespace Catch
+// end catch_polyfills.cpp
+// start catch_random_number_generator.cpp
+
+namespace Catch {
+
+namespace {
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4146) // we negate uint32 during the rotate
+#endif
+        // Safe rotr implementation thanks to John Regehr
+        uint32_t rotate_right(uint32_t val, uint32_t count) {
+            const uint32_t mask = 31;
+            count &= mask;
+            return (val >> count) | (val << (-count & mask));
+        }
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}
+
+    SimplePcg32::SimplePcg32(result_type seed_) {
+        seed(seed_);
+    }
+
+    void SimplePcg32::seed(result_type seed_) {
+        m_state = 0;
+        (*this)();
+        m_state += seed_;
+        (*this)();
+    }
+
+    void SimplePcg32::discard(uint64_t skip) {
+        // We could implement this to run in O(log n) steps, but this
+        // should suffice for our use case.
+        for (uint64_t s = 0; s < skip; ++s) {
+            static_cast<void>((*this)());
+        }
+    }
+
+    SimplePcg32::result_type SimplePcg32::operator()() {
+        // prepare the output value
+        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
+        const auto output = rotate_right(xorshifted, m_state >> 59u);
+
+        // advance state
+        m_state = m_state * 6364136223846793005ULL + s_inc;
+
+        return output;
+    }
+
+    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state == rhs.m_state;
+    }
+
+    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state != rhs.m_state;
+    }
+}
+// end catch_random_number_generator.cpp
+// start catch_registry_hub.cpp
+
+// start catch_test_case_registry_impl.h
+
+#include <vector>
+#include <set>
+#include <algorithm>
+#include <ios>
+
+namespace Catch {
+
+    class TestCase;
+    struct IConfig;
+
+    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+
+    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
+
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+
+    class TestRegistry : public ITestCaseRegistry {
+    public:
+        virtual ~TestRegistry() = default;
+
+        virtual void registerTest( TestCase const& testCase );
+
+        std::vector<TestCase> const& getAllTests() const override;
+        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
+
+    private:
+        std::vector<TestCase> m_functions;
+        mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
+        mutable std::vector<TestCase> m_sortedFunctions;
+        std::size_t m_unnamedCount = 0;
+        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class TestInvokerAsFunction : public ITestInvoker {
+        void(*m_testAsFunction)();
+    public:
+        TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
+
+        void invoke() const override;
+    };
+
+    std::string extractClassName( StringRef const& classOrQualifiedMethodName );
+
+    ///////////////////////////////////////////////////////////////////////////
+
+} // end namespace Catch
+
+// end catch_test_case_registry_impl.h
+// start catch_reporter_registry.h
+
+#include <map>
+
+namespace Catch {
+
+    class ReporterRegistry : public IReporterRegistry {
+
+    public:
+
+        ~ReporterRegistry() override;
+
+        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
+
+        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
+        void registerListener( IReporterFactoryPtr const& factory );
+
+        FactoryMap const& getFactories() const override;
+        Listeners const& getListeners() const override;
+
+    private:
+        FactoryMap m_factories;
+        Listeners m_listeners;
+    };
+}
+
+// end catch_reporter_registry.h
+// start catch_tag_alias_registry.h
+
+// start catch_tag_alias.h
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias {
+        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
+
+        std::string tag;
+        SourceLineInfo lineInfo;
+    };
+
+} // end namespace Catch
+
+// end catch_tag_alias.h
+#include <map>
+
+namespace Catch {
+
+    class TagAliasRegistry : public ITagAliasRegistry {
+    public:
+        ~TagAliasRegistry() override;
+        TagAlias const* find( std::string const& alias ) const override;
+        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
+        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
+
+    private:
+        std::map<std::string, TagAlias> m_registry;
+    };
+
+} // end namespace Catch
+
+// end catch_tag_alias_registry.h
+// start catch_startup_exception_registry.h
+
+#include <vector>
+#include <exception>
+
+namespace Catch {
+
+    class StartupExceptionRegistry {
+    public:
+        void add(std::exception_ptr const& exception) noexcept;
+        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
+    private:
+        std::vector<std::exception_ptr> m_exceptions;
+    };
+
+} // end namespace Catch
+
+// end catch_startup_exception_registry.h
+// start catch_singletons.hpp
+
+namespace Catch {
+
+    struct ISingleton {
+        virtual ~ISingleton();
+    };
+
+    void addSingleton( ISingleton* singleton );
+    void cleanupSingletons();
+
+    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
+    class Singleton : SingletonImplT, public ISingleton {
+
+        static auto getInternal() -> Singleton* {
+            static Singleton* s_instance = nullptr;
+            if( !s_instance ) {
+                s_instance = new Singleton;
+                addSingleton( s_instance );
+            }
+            return s_instance;
+        }
+
+    public:
+        static auto get() -> InterfaceT const& {
+            return *getInternal();
+        }
+        static auto getMutable() -> MutableInterfaceT& {
+            return *getInternal();
+        }
+    };
+
+} // namespace Catch
+
+// end catch_singletons.hpp
+namespace Catch {
+
+    namespace {
+
+        class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
+                            private NonCopyable {
+
+        public: // IRegistryHub
+            RegistryHub() = default;
+            IReporterRegistry const& getReporterRegistry() const override {
+                return m_reporterRegistry;
+            }
+            ITestCaseRegistry const& getTestCaseRegistry() const override {
+                return m_testCaseRegistry;
+            }
+            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
+                return m_exceptionTranslatorRegistry;
+            }
+            ITagAliasRegistry const& getTagAliasRegistry() const override {
+                return m_tagAliasRegistry;
+            }
+            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
+                return m_exceptionRegistry;
+            }
+
+        public: // IMutableRegistryHub
+            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
+                m_reporterRegistry.registerReporter( name, factory );
+            }
+            void registerListener( IReporterFactoryPtr const& factory ) override {
+                m_reporterRegistry.registerListener( factory );
+            }
+            void registerTest( TestCase const& testInfo ) override {
+                m_testCaseRegistry.registerTest( testInfo );
+            }
+            void registerTranslator( const IExceptionTranslator* translator ) override {
+                m_exceptionTranslatorRegistry.registerTranslator( translator );
+            }
+            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
+                m_tagAliasRegistry.add( alias, tag, lineInfo );
+            }
+            void registerStartupException() noexcept override {
+                m_exceptionRegistry.add(std::current_exception());
+            }
+            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
+                return m_enumValuesRegistry;
+            }
+
+        private:
+            TestRegistry m_testCaseRegistry;
+            ReporterRegistry m_reporterRegistry;
+            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+            TagAliasRegistry m_tagAliasRegistry;
+            StartupExceptionRegistry m_exceptionRegistry;
+            Detail::EnumValuesRegistry m_enumValuesRegistry;
+        };
+    }
+
+    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
+
+    IRegistryHub const& getRegistryHub() {
+        return RegistryHubSingleton::get();
+    }
+    IMutableRegistryHub& getMutableRegistryHub() {
+        return RegistryHubSingleton::getMutable();
+    }
+    void cleanUp() {
+        cleanupSingletons();
+        cleanUpContext();
+    }
+    std::string translateActiveException() {
+        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+} // end namespace Catch
+// end catch_registry_hub.cpp
+// start catch_reporter_registry.cpp
+
+namespace Catch {
+
+    ReporterRegistry::~ReporterRegistry() = default;
+
+    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
+        auto it =  m_factories.find( name );
+        if( it == m_factories.end() )
+            return nullptr;
+        return it->second->create( ReporterConfig( config ) );
+    }
+
+    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
+        m_factories.emplace(name, factory);
+    }
+    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
+        m_listeners.push_back( factory );
+    }
+
+    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
+        return m_factories;
+    }
+    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
+        return m_listeners;
+    }
+
+}
+// end catch_reporter_registry.cpp
+// start catch_result_type.cpp
+
+namespace Catch {
+
+    bool isOk( ResultWas::OfType resultType ) {
+        return ( resultType & ResultWas::FailureBit ) == 0;
+    }
+    bool isJustInfo( int flags ) {
+        return flags == ResultWas::Info;
+    }
+
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+    }
+
+    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+
+} // end namespace Catch
+// end catch_result_type.cpp
+// start catch_run_context.cpp
+
+#include <cassert>
+#include <algorithm>
+#include <sstream>
+
+namespace Catch {
+
+    namespace Generators {
+        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
+            GeneratorBasePtr m_generator;
+
+            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+            :   TrackerBase( nameAndLocation, ctx, parent )
+            {}
+            ~GeneratorTracker();
+
+            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
+                std::shared_ptr<GeneratorTracker> tracker;
+
+                ITracker& currentTracker = ctx.currentTracker();
+                if( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+                    assert( childTracker );
+                    assert( childTracker->isGeneratorTracker() );
+                    tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
+                }
+                else {
+                    tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
+                    currentTracker.addChild( tracker );
+                }
+
+                if( !ctx.completedCycle() && !tracker->isComplete() ) {
+                    tracker->open();
+                }
+
+                return *tracker;
+            }
+
+            // TrackerBase interface
+            bool isGeneratorTracker() const override { return true; }
+            auto hasGenerator() const -> bool override {
+                return !!m_generator;
+            }
+            void close() override {
+                TrackerBase::close();
+                // Generator interface only finds out if it has another item on atual move
+                if (m_runState == CompletedSuccessfully && m_generator->next()) {
+                    m_children.clear();
+                    m_runState = Executing;
+                }
+            }
+
+            // IGeneratorTracker interface
+            auto getGenerator() const -> GeneratorBasePtr const& override {
+                return m_generator;
+            }
+            void setGenerator( GeneratorBasePtr&& generator ) override {
+                m_generator = std::move( generator );
+            }
+        };
+        GeneratorTracker::~GeneratorTracker() {}
+    }
+
+    RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
+    :   m_runInfo(_config->name()),
+        m_context(getCurrentMutableContext()),
+        m_config(_config),
+        m_reporter(std::move(reporter)),
+        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
+        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
+    {
+        m_context.setRunner(this);
+        m_context.setConfig(m_config);
+        m_context.setResultCapture(this);
+        m_reporter->testRunStarting(m_runInfo);
+    }
+
+    RunContext::~RunContext() {
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+    }
+
+    void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
+        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
+    }
+
+    void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
+        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
+    }
+
+    Totals RunContext::runTest(TestCase const& testCase) {
+        Totals prevTotals = m_totals;
+
+        std::string redirectedCout;
+        std::string redirectedCerr;
+
+        auto const& testInfo = testCase.getTestCaseInfo();
+
+        m_reporter->testCaseStarting(testInfo);
+
+        m_activeTestCase = &testCase;
+
+        ITracker& rootTracker = m_trackerContext.startRun();
+        assert(rootTracker.isSectionTracker());
+        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
+        do {
+            m_trackerContext.startCycle();
+            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
+            runCurrentTest(redirectedCout, redirectedCerr);
+        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
+
+        Totals deltaTotals = m_totals.delta(prevTotals);
+        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
+            deltaTotals.assertions.failed++;
+            deltaTotals.testCases.passed--;
+            deltaTotals.testCases.failed++;
+        }
+        m_totals.testCases += deltaTotals.testCases;
+        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+                                  deltaTotals,
+                                  redirectedCout,
+                                  redirectedCerr,
+                                  aborting()));
+
+        m_activeTestCase = nullptr;
+        m_testCaseTracker = nullptr;
+
+        return deltaTotals;
+    }
+
+    IConfigPtr RunContext::config() const {
+        return m_config;
+    }
+
+    IStreamingReporter& RunContext::reporter() const {
+        return *m_reporter;
+    }
+
+    void RunContext::assertionEnded(AssertionResult const & result) {
+        if (result.getResultType() == ResultWas::Ok) {
+            m_totals.assertions.passed++;
+            m_lastAssertionPassed = true;
+        } else if (!result.isOk()) {
+            m_lastAssertionPassed = false;
+            if( m_activeTestCase->getTestCaseInfo().okToFail() )
+                m_totals.assertions.failedButOk++;
+            else
+                m_totals.assertions.failed++;
+        }
+        else {
+            m_lastAssertionPassed = true;
+        }
+
+        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
+        // and should be let to clear themselves out.
+        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
+
+        if (result.getResultType() != ResultWas::Warning)
+            m_messageScopes.clear();
+
+        // Reset working state
+        resetAssertionInfo();
+        m_lastResult = result;
+    }
+    void RunContext::resetAssertionInfo() {
+        m_lastAssertionInfo.macroName = StringRef();
+        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
+    }
+
+    bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
+        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
+        if (!sectionTracker.isOpen())
+            return false;
+        m_activeSections.push_back(&sectionTracker);
+
+        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+        m_reporter->sectionStarting(sectionInfo);
+
+        assertions = m_totals.assertions;
+
+        return true;
+    }
+    auto RunContext::acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        using namespace Generators;
+        GeneratorTracker& tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( "generator", lineInfo ) );
+        assert( tracker.isOpen() );
+        m_lastAssertionInfo.lineInfo = lineInfo;
+        return tracker;
+    }
+
+    bool RunContext::testForMissingAssertions(Counts& assertions) {
+        if (assertions.total() != 0)
+            return false;
+        if (!m_config->warnAboutMissingAssertions())
+            return false;
+        if (m_trackerContext.currentTracker().hasChildren())
+            return false;
+        m_totals.assertions.failed++;
+        assertions.failed++;
+        return true;
+    }
+
+    void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
+        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
+        bool missingAssertions = testForMissingAssertions(assertions);
+
+        if (!m_activeSections.empty()) {
+            m_activeSections.back()->close();
+            m_activeSections.pop_back();
+        }
+
+        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
+        m_messages.clear();
+        m_messageScopes.clear();
+    }
+
+    void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
+        if (m_unfinishedSections.empty())
+            m_activeSections.back()->fail();
+        else
+            m_activeSections.back()->close();
+        m_activeSections.pop_back();
+
+        m_unfinishedSections.push_back(endInfo);
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void RunContext::benchmarkPreparing(std::string const& name) {
+		m_reporter->benchmarkPreparing(name);
+	}
+    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
+        m_reporter->benchmarkStarting( info );
+    }
+    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
+        m_reporter->benchmarkEnded( stats );
+    }
+	void RunContext::benchmarkFailed(std::string const & error) {
+		m_reporter->benchmarkFailed(error);
+	}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    void RunContext::pushScopedMessage(MessageInfo const & message) {
+        m_messages.push_back(message);
+    }
+
+    void RunContext::popScopedMessage(MessageInfo const & message) {
+        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
+    }
+
+    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
+        m_messageScopes.emplace_back( builder );
+    }
+
+    std::string RunContext::getCurrentTestName() const {
+        return m_activeTestCase
+            ? m_activeTestCase->getTestCaseInfo().name
+            : std::string();
+    }
+
+    const AssertionResult * RunContext::getLastResult() const {
+        return &(*m_lastResult);
+    }
+
+    void RunContext::exceptionEarlyReported() {
+        m_shouldReportUnexpected = false;
+    }
+
+    void RunContext::handleFatalErrorCondition( StringRef message ) {
+        // First notify reporter that bad things happened
+        m_reporter->fatalErrorEncountered(message);
+
+        // Don't rebuild the result -- the stringification itself can cause more fatal errors
+        // Instead, fake a result data.
+        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
+        tempResult.message = static_cast<std::string>(message);
+        AssertionResult result(m_lastAssertionInfo, tempResult);
+
+        assertionEnded(result);
+
+        handleUnfinishedSections();
+
+        // Recreate section for test case (as we will lose the one that was in scope)
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+
+        Counts assertions;
+        assertions.failed = 1;
+        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
+        m_reporter->sectionEnded(testCaseSectionStats);
+
+        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
+
+        Totals deltaTotals;
+        deltaTotals.testCases.failed = 1;
+        deltaTotals.assertions.failed = 1;
+        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+                                  deltaTotals,
+                                  std::string(),
+                                  std::string(),
+                                  false));
+        m_totals.testCases.failed++;
+        testGroupEnded(std::string(), m_totals, 1, 1);
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
+    }
+
+    bool RunContext::lastAssertionPassed() {
+         return m_lastAssertionPassed;
+    }
+
+    void RunContext::assertionPassed() {
+        m_lastAssertionPassed = true;
+        ++m_totals.assertions.passed;
+        resetAssertionInfo();
+        m_messageScopes.clear();
+    }
+
+    bool RunContext::aborting() const {
+        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
+    }
+
+    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+        m_reporter->sectionStarting(testCaseSection);
+        Counts prevAssertions = m_totals.assertions;
+        double duration = 0;
+        m_shouldReportUnexpected = true;
+        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
+
+        seedRng(*m_config);
+
+        Timer timer;
+        CATCH_TRY {
+            if (m_reporter->getPreferences().shouldRedirectStdOut) {
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
+
+                timer.start();
+                invokeActiveTestCase();
+#else
+                OutputRedirect r(redirectedCout, redirectedCerr);
+                timer.start();
+                invokeActiveTestCase();
+#endif
+            } else {
+                timer.start();
+                invokeActiveTestCase();
+            }
+            duration = timer.getElapsedSeconds();
+        } CATCH_CATCH_ANON (TestFailureException&) {
+            // This just means the test was aborted due to failure
+        } CATCH_CATCH_ALL {
+            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
+            // are reported without translation at the point of origin.
+            if( m_shouldReportUnexpected ) {
+                AssertionReaction dummyReaction;
+                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
+            }
+        }
+        Counts assertions = m_totals.assertions - prevAssertions;
+        bool missingAssertions = testForMissingAssertions(assertions);
+
+        m_testCaseTracker->close();
+        handleUnfinishedSections();
+        m_messages.clear();
+        m_messageScopes.clear();
+
+        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
+        m_reporter->sectionEnded(testCaseSectionStats);
+    }
+
+    void RunContext::invokeActiveTestCase() {
+        FatalConditionHandler fatalConditionHandler; // Handle signals
+        m_activeTestCase->invoke();
+        fatalConditionHandler.reset();
+    }
+
+    void RunContext::handleUnfinishedSections() {
+        // If sections ended prematurely due to an exception we stored their
+        // infos here so we can tear them down outside the unwind process.
+        for (auto it = m_unfinishedSections.rbegin(),
+             itEnd = m_unfinishedSections.rend();
+             it != itEnd;
+             ++it)
+            sectionEnded(*it);
+        m_unfinishedSections.clear();
+    }
+
+    void RunContext::handleExpr(
+        AssertionInfo const& info,
+        ITransientExpression const& expr,
+        AssertionReaction& reaction
+    ) {
+        m_reporter->assertionStarting( info );
+
+        bool negated = isFalseTest( info.resultDisposition );
+        bool result = expr.getResult() != negated;
+
+        if( result ) {
+            if (!m_includeSuccessfulResults) {
+                assertionPassed();
+            }
+            else {
+                reportExpr(info, ResultWas::Ok, &expr, negated);
+            }
+        }
+        else {
+            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
+            populateReaction( reaction );
+        }
+    }
+    void RunContext::reportExpr(
+            AssertionInfo const &info,
+            ResultWas::OfType resultType,
+            ITransientExpression const *expr,
+            bool negated ) {
+
+        m_lastAssertionInfo = info;
+        AssertionResultData data( resultType, LazyExpression( negated ) );
+
+        AssertionResult assertionResult{ info, data };
+        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
+
+        assertionEnded( assertionResult );
+    }
+
+    void RunContext::handleMessage(
+            AssertionInfo const& info,
+            ResultWas::OfType resultType,
+            StringRef const& message,
+            AssertionReaction& reaction
+    ) {
+        m_reporter->assertionStarting( info );
+
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        data.message = static_cast<std::string>(message);
+        AssertionResult assertionResult{ m_lastAssertionInfo, data };
+        assertionEnded( assertionResult );
+        if( !assertionResult.isOk() )
+            populateReaction( reaction );
+    }
+    void RunContext::handleUnexpectedExceptionNotThrown(
+            AssertionInfo const& info,
+            AssertionReaction& reaction
+    ) {
+        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
+    }
+
+    void RunContext::handleUnexpectedInflightException(
+            AssertionInfo const& info,
+            std::string const& message,
+            AssertionReaction& reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+        data.message = message;
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+        populateReaction( reaction );
+    }
+
+    void RunContext::populateReaction( AssertionReaction& reaction ) {
+        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
+        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
+    }
+
+    void RunContext::handleIncomplete(
+            AssertionInfo const& info
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+    }
+    void RunContext::handleNonExpr(
+            AssertionInfo const &info,
+            ResultWas::OfType resultType,
+            AssertionReaction &reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+
+        if( !assertionResult.isOk() )
+            populateReaction( reaction );
+    }
+
+    IResultCapture& getResultCapture() {
+        if (auto* capture = getCurrentContext().getResultCapture())
+            return *capture;
+        else
+            CATCH_INTERNAL_ERROR("No result capture instance");
+    }
+
+    void seedRng(IConfig const& config) {
+        if (config.rngSeed() != 0) {
+            std::srand(config.rngSeed());
+            rng().seed(config.rngSeed());
+        }
+    }
+
+    unsigned int rngSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+
+}
+// end catch_run_context.cpp
+// start catch_section.cpp
+
+namespace Catch {
+
+    Section::Section( SectionInfo const& info )
+    :   m_info( info ),
+        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
+    {
+        m_timer.start();
+    }
+
+    Section::~Section() {
+        if( m_sectionIncluded ) {
+            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
+            if( uncaught_exceptions() )
+                getResultCapture().sectionEndedEarly( endInfo );
+            else
+                getResultCapture().sectionEnded( endInfo );
+        }
+    }
+
+    // This indicates whether the section should be executed or not
+    Section::operator bool() const {
+        return m_sectionIncluded;
+    }
+
+} // end namespace Catch
+// end catch_section.cpp
+// start catch_section_info.cpp
+
+namespace Catch {
+
+    SectionInfo::SectionInfo
+        (   SourceLineInfo const& _lineInfo,
+            std::string const& _name )
+    :   name( _name ),
+        lineInfo( _lineInfo )
+    {}
+
+} // end namespace Catch
+// end catch_section_info.cpp
+// start catch_session.cpp
+
+// start catch_session.h
+
+#include <memory>
+
+namespace Catch {
+
+    class Session : NonCopyable {
+    public:
+
+        Session();
+        ~Session() override;
+
+        void showHelp() const;
+        void libIdentify();
+
+        int applyCommandLine( int argc, char const * const * argv );
+    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+        int applyCommandLine( int argc, wchar_t const * const * argv );
+    #endif
+
+        void useConfigData( ConfigData const& configData );
+
+        template<typename CharT>
+        int run(int argc, CharT const * const argv[]) {
+            if (m_startupExceptions)
+                return 1;
+            int returnCode = applyCommandLine(argc, argv);
+            if (returnCode == 0)
+                returnCode = run();
+            return returnCode;
+        }
+
+        int run();
+
+        clara::Parser const& cli() const;
+        void cli( clara::Parser const& newParser );
+        ConfigData& configData();
+        Config& config();
+    private:
+        int runInternal();
+
+        clara::Parser m_cli;
+        ConfigData m_configData;
+        std::shared_ptr<Config> m_config;
+        bool m_startupExceptions = false;
+    };
+
+} // end namespace Catch
+
+// end catch_session.h
+// start catch_version.h
+
+#include <iosfwd>
+
+namespace Catch {
+
+    // Versioning information
+    struct Version {
+        Version( Version const& ) = delete;
+        Version& operator=( Version const& ) = delete;
+        Version(    unsigned int _majorVersion,
+                    unsigned int _minorVersion,
+                    unsigned int _patchNumber,
+                    char const * const _branchName,
+                    unsigned int _buildNumber );
+
+        unsigned int const majorVersion;
+        unsigned int const minorVersion;
+        unsigned int const patchNumber;
+
+        // buildNumber is only used if branchName is not null
+        char const * const branchName;
+        unsigned int const buildNumber;
+
+        friend std::ostream& operator << ( std::ostream& os, Version const& version );
+    };
+
+    Version const& libraryVersion();
+}
+
+// end catch_version.h
+#include <cstdlib>
+#include <iomanip>
+#include <set>
+#include <iterator>
+
+namespace Catch {
+
+    namespace {
+        const int MaxExitCode = 255;
+
+        IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
+            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
+            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
+
+            return reporter;
+        }
+
+        IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
+            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
+                return createReporter(config->getReporterName(), config);
+            }
+
+            // On older platforms, returning std::unique_ptr<ListeningReporter>
+            // when the return type is std::unique_ptr<IStreamingReporter>
+            // doesn't compile without a std::move call. However, this causes
+            // a warning on newer platforms. Thus, we have to work around
+            // it a bit and downcast the pointer manually.
+            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
+            auto& multi = static_cast<ListeningReporter&>(*ret);
+            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
+            for (auto const& listener : listeners) {
+                multi.addListener(listener->create(Catch::ReporterConfig(config)));
+            }
+            multi.addReporter(createReporter(config->getReporterName(), config));
+            return ret;
+        }
+
+        class TestGroup {
+        public:
+            explicit TestGroup(std::shared_ptr<Config> const& config)
+            : m_config{config}
+            , m_context{config, makeReporter(config)}
+            {
+                auto const& allTestCases = getAllTestCasesSorted(*m_config);
+                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
+                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
+
+                if (m_matches.empty() && invalidArgs.empty()) {
+                    for (auto const& test : allTestCases)
+                        if (!test.isHidden())
+                            m_tests.emplace(&test);
+                } else {
+                    for (auto const& match : m_matches)
+                        m_tests.insert(match.tests.begin(), match.tests.end());
+                }
+            }
+
+            Totals execute() {
+                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
+                Totals totals;
+                m_context.testGroupStarting(m_config->name(), 1, 1);
+                for (auto const& testCase : m_tests) {
+                    if (!m_context.aborting())
+                        totals += m_context.runTest(*testCase);
+                    else
+                        m_context.reporter().skipTest(*testCase);
+                }
+
+                for (auto const& match : m_matches) {
+                    if (match.tests.empty()) {
+                        m_context.reporter().noMatchingTestCases(match.name);
+                        totals.error = -1;
+                    }
+                }
+
+                if (!invalidArgs.empty()) {
+                    for (auto const& invalidArg: invalidArgs)
+                         m_context.reporter().reportInvalidArguments(invalidArg);
+                }
+
+                m_context.testGroupEnded(m_config->name(), totals, 1, 1);
+                return totals;
+            }
+
+        private:
+            using Tests = std::set<TestCase const*>;
+
+            std::shared_ptr<Config> m_config;
+            RunContext m_context;
+            Tests m_tests;
+            TestSpec::Matches m_matches;
+        };
+
+        void applyFilenamesAsTags(Catch::IConfig const& config) {
+            auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
+            for (auto& testCase : tests) {
+                auto tags = testCase.tags;
+
+                std::string filename = testCase.lineInfo.file;
+                auto lastSlash = filename.find_last_of("\\/");
+                if (lastSlash != std::string::npos) {
+                    filename.erase(0, lastSlash);
+                    filename[0] = '#';
+                }
+
+                auto lastDot = filename.find_last_of('.');
+                if (lastDot != std::string::npos) {
+                    filename.erase(lastDot);
+                }
+
+                tags.push_back(std::move(filename));
+                setTags(testCase, tags);
+            }
+        }
+
+    } // anon namespace
+
+    Session::Session() {
+        static bool alreadyInstantiated = false;
+        if( alreadyInstantiated ) {
+            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
+            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
+        }
+
+        // There cannot be exceptions at startup in no-exception mode.
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
+        if ( !exceptions.empty() ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
+
+            m_startupExceptions = true;
+            Colour colourGuard( Colour::Red );
+            Catch::cerr() << "Errors occurred during startup!" << '\n';
+            // iterate over all exceptions and notify user
+            for ( const auto& ex_ptr : exceptions ) {
+                try {
+                    std::rethrow_exception(ex_ptr);
+                } catch ( std::exception const& ex ) {
+                    Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
+                }
+            }
+        }
+#endif
+
+        alreadyInstantiated = true;
+        m_cli = makeCommandLineParser( m_configData );
+    }
+    Session::~Session() {
+        Catch::cleanUp();
+    }
+
+    void Session::showHelp() const {
+        Catch::cout()
+                << "\nCatch v" << libraryVersion() << "\n"
+                << m_cli << std::endl
+                << "For more detailed usage please see the project docs\n" << std::endl;
+    }
+    void Session::libIdentify() {
+        Catch::cout()
+                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
+                << std::left << std::setw(16) << "category: " << "testframework\n"
+                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
+                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
+    }
+
+    int Session::applyCommandLine( int argc, char const * const * argv ) {
+        if( m_startupExceptions )
+            return 1;
+
+        auto result = m_cli.parse( clara::Args( argc, argv ) );
+        if( !result ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
+            Catch::cerr()
+                << Colour( Colour::Red )
+                << "\nError(s) in input:\n"
+                << Column( result.errorMessage() ).indent( 2 )
+                << "\n\n";
+            Catch::cerr() << "Run with -? for usage\n" << std::endl;
+            return MaxExitCode;
+        }
+
+        if( m_configData.showHelp )
+            showHelp();
+        if( m_configData.libIdentify )
+            libIdentify();
+        m_config.reset();
+        return 0;
+    }
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
+
+        char **utf8Argv = new char *[ argc ];
+
+        for ( int i = 0; i < argc; ++i ) {
+            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
+
+            utf8Argv[ i ] = new char[ bufSize ];
+
+            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
+        }
+
+        int returnCode = applyCommandLine( argc, utf8Argv );
+
+        for ( int i = 0; i < argc; ++i )
+            delete [] utf8Argv[ i ];
+
+        delete [] utf8Argv;
+
+        return returnCode;
+    }
+#endif
+
+    void Session::useConfigData( ConfigData const& configData ) {
+        m_configData = configData;
+        m_config.reset();
+    }
+
+    int Session::run() {
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
+            static_cast<void>(std::getchar());
+        }
+        int exitCode = runInternal();
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
+            static_cast<void>(std::getchar());
+        }
+        return exitCode;
+    }
+
+    clara::Parser const& Session::cli() const {
+        return m_cli;
+    }
+    void Session::cli( clara::Parser const& newParser ) {
+        m_cli = newParser;
+    }
+    ConfigData& Session::configData() {
+        return m_configData;
+    }
+    Config& Session::config() {
+        if( !m_config )
+            m_config = std::make_shared<Config>( m_configData );
+        return *m_config;
+    }
+
+    int Session::runInternal() {
+        if( m_startupExceptions )
+            return 1;
+
+        if (m_configData.showHelp || m_configData.libIdentify) {
+            return 0;
+        }
+
+        CATCH_TRY {
+            config(); // Force config to be constructed
+
+            seedRng( *m_config );
+
+            if( m_configData.filenamesAsTags )
+                applyFilenamesAsTags( *m_config );
+
+            // Handle list request
+            if( Option<std::size_t> listed = list( m_config ) )
+                return static_cast<int>( *listed );
+
+            TestGroup tests { m_config };
+            auto const totals = tests.execute();
+
+            if( m_config->warnAboutNoTests() && totals.error == -1 )
+                return 2;
+
+            // Note that on unices only the lower 8 bits are usually used, clamping
+            // the return value to 255 prevents false negative when some multiple
+            // of 256 tests has failed
+            return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
+        }
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        catch( std::exception& ex ) {
+            Catch::cerr() << ex.what() << std::endl;
+            return MaxExitCode;
+        }
+#endif
+    }
+
+} // end namespace Catch
+// end catch_session.cpp
+// start catch_singletons.cpp
+
+#include <vector>
+
+namespace Catch {
+
+    namespace {
+        static auto getSingletons() -> std::vector<ISingleton*>*& {
+            static std::vector<ISingleton*>* g_singletons = nullptr;
+            if( !g_singletons )
+                g_singletons = new std::vector<ISingleton*>();
+            return g_singletons;
+        }
+    }
+
+    ISingleton::~ISingleton() {}
+
+    void addSingleton(ISingleton* singleton ) {
+        getSingletons()->push_back( singleton );
+    }
+    void cleanupSingletons() {
+        auto& singletons = getSingletons();
+        for( auto singleton : *singletons )
+            delete singleton;
+        delete singletons;
+        singletons = nullptr;
+    }
+
+} // namespace Catch
+// end catch_singletons.cpp
+// start catch_startup_exception_registry.cpp
+
+namespace Catch {
+void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
+        CATCH_TRY {
+            m_exceptions.push_back(exception);
+        } CATCH_CATCH_ALL {
+            // If we run out of memory during start-up there's really not a lot more we can do about it
+            std::terminate();
+        }
+    }
+
+    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
+        return m_exceptions;
+    }
+
+} // end namespace Catch
+// end catch_startup_exception_registry.cpp
+// start catch_stream.cpp
+
+#include <cstdio>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    Catch::IStream::~IStream() = default;
+
+    namespace Detail { namespace {
+        template<typename WriterF, std::size_t bufferSize=256>
+        class StreamBufImpl : public std::streambuf {
+            char data[bufferSize];
+            WriterF m_writer;
+
+        public:
+            StreamBufImpl() {
+                setp( data, data + sizeof(data) );
+            }
+
+            ~StreamBufImpl() noexcept {
+                StreamBufImpl::sync();
+            }
+
+        private:
+            int overflow( int c ) override {
+                sync();
+
+                if( c != EOF ) {
+                    if( pbase() == epptr() )
+                        m_writer( std::string( 1, static_cast<char>( c ) ) );
+                    else
+                        sputc( static_cast<char>( c ) );
+                }
+                return 0;
+            }
+
+            int sync() override {
+                if( pbase() != pptr() ) {
+                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+                    setp( pbase(), epptr() );
+                }
+                return 0;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        struct OutputDebugWriter {
+
+            void operator()( std::string const&str ) {
+                writeToDebugConsole( str );
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class FileStream : public IStream {
+            mutable std::ofstream m_ofs;
+        public:
+            FileStream( StringRef filename ) {
+                m_ofs.open( filename.c_str() );
+                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
+            }
+            ~FileStream() override = default;
+        public: // IStream
+            std::ostream& stream() const override {
+                return m_ofs;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class CoutStream : public IStream {
+            mutable std::ostream m_os;
+        public:
+            // Store the streambuf from cout up-front because
+            // cout may get redirected when running tests
+            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
+            ~CoutStream() override = default;
+
+        public: // IStream
+            std::ostream& stream() const override { return m_os; }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class DebugOutStream : public IStream {
+            std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
+            mutable std::ostream m_os;
+        public:
+            DebugOutStream()
+            :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
+                m_os( m_streamBuf.get() )
+            {}
+
+            ~DebugOutStream() override = default;
+
+        public: // IStream
+            std::ostream& stream() const override { return m_os; }
+        };
+
+    }} // namespace anon::detail
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    auto makeStream( StringRef const &filename ) -> IStream const* {
+        if( filename.empty() )
+            return new Detail::CoutStream();
+        else if( filename[0] == '%' ) {
+            if( filename == "%debug" )
+                return new Detail::DebugOutStream();
+            else
+                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
+        }
+        else
+            return new Detail::FileStream( filename );
+    }
+
+    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
+    struct StringStreams {
+        std::vector<std::unique_ptr<std::ostringstream>> m_streams;
+        std::vector<std::size_t> m_unused;
+        std::ostringstream m_referenceStream; // Used for copy state/ flags from
+
+        auto add() -> std::size_t {
+            if( m_unused.empty() ) {
+                m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
+                return m_streams.size()-1;
+            }
+            else {
+                auto index = m_unused.back();
+                m_unused.pop_back();
+                return index;
+            }
+        }
+
+        void release( std::size_t index ) {
+            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
+            m_unused.push_back(index);
+        }
+    };
+
+    ReusableStringStream::ReusableStringStream()
+    :   m_index( Singleton<StringStreams>::getMutable().add() ),
+        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
+    {}
+
+    ReusableStringStream::~ReusableStringStream() {
+        static_cast<std::ostringstream*>( m_oss )->str("");
+        m_oss->clear();
+        Singleton<StringStreams>::getMutable().release( m_index );
+    }
+
+    auto ReusableStringStream::str() const -> std::string {
+        return static_cast<std::ostringstream*>( m_oss )->str();
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
+    std::ostream& cout() { return std::cout; }
+    std::ostream& cerr() { return std::cerr; }
+    std::ostream& clog() { return std::clog; }
+#endif
+}
+// end catch_stream.cpp
+// start catch_string_manip.cpp
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cctype>
+#include <vector>
+
+namespace Catch {
+
+    namespace {
+        char toLowerCh(char c) {
+            return static_cast<char>( std::tolower( c ) );
+        }
+    }
+
+    bool startsWith( std::string const& s, std::string const& prefix ) {
+        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
+    }
+    bool startsWith( std::string const& s, char prefix ) {
+        return !s.empty() && s[0] == prefix;
+    }
+    bool endsWith( std::string const& s, std::string const& suffix ) {
+        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
+    }
+    bool endsWith( std::string const& s, char suffix ) {
+        return !s.empty() && s[s.size()-1] == suffix;
+    }
+    bool contains( std::string const& s, std::string const& infix ) {
+        return s.find( infix ) != std::string::npos;
+    }
+    void toLowerInPlace( std::string& s ) {
+        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
+    }
+    std::string toLower( std::string const& s ) {
+        std::string lc = s;
+        toLowerInPlace( lc );
+        return lc;
+    }
+    std::string trim( std::string const& str ) {
+        static char const* whitespaceChars = "\n\r\t ";
+        std::string::size_type start = str.find_first_not_of( whitespaceChars );
+        std::string::size_type end = str.find_last_not_of( whitespaceChars );
+
+        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
+    }
+
+    StringRef trim(StringRef ref) {
+        const auto is_ws = [](char c) {
+            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+        };
+        size_t real_begin = 0;
+        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
+        size_t real_end = ref.size();
+        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
+
+        return ref.substr(real_begin, real_end - real_begin);
+    }
+
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+        bool replaced = false;
+        std::size_t i = str.find( replaceThis );
+        while( i != std::string::npos ) {
+            replaced = true;
+            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
+            if( i < str.size()-withThis.size() )
+                i = str.find( replaceThis, i+withThis.size() );
+            else
+                i = std::string::npos;
+        }
+        return replaced;
+    }
+
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
+        std::vector<StringRef> subStrings;
+        std::size_t start = 0;
+        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
+            if( str[pos] == delimiter ) {
+                if( pos - start > 1 )
+                    subStrings.push_back( str.substr( start, pos-start ) );
+                start = pos+1;
+            }
+        }
+        if( start < str.size() )
+            subStrings.push_back( str.substr( start, str.size()-start ) );
+        return subStrings;
+    }
+
+    pluralise::pluralise( std::size_t count, std::string const& label )
+    :   m_count( count ),
+        m_label( label )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+        os << pluraliser.m_count << ' ' << pluraliser.m_label;
+        if( pluraliser.m_count != 1 )
+            os << 's';
+        return os;
+    }
+
+}
+// end catch_string_manip.cpp
+// start catch_stringref.cpp
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cstdint>
+
+namespace Catch {
+    StringRef::StringRef( char const* rawChars ) noexcept
+    : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
+    {}
+
+    auto StringRef::c_str() const -> char const* {
+        CATCH_ENFORCE(isNullTerminated(), "Called StringRef::c_str() on a non-null-terminated instance");
+        return m_start;
+    }
+    auto StringRef::data() const noexcept -> char const* {
+        return m_start;
+    }
+
+    auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
+        if (start < m_size) {
+            return StringRef(m_start + start, (std::min)(m_size - start, size));
+        } else {
+            return StringRef();
+        }
+    }
+    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
+        return m_size == other.m_size
+            && (std::memcmp( m_start, other.m_start, m_size ) == 0);
+    }
+
+    auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
+        return os.write(str.data(), str.size());
+    }
+
+    auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
+        lhs.append(rhs.data(), rhs.size());
+        return lhs;
+    }
+
+} // namespace Catch
+// end catch_stringref.cpp
+// start catch_tag_alias.cpp
+
+namespace Catch {
+    TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
+}
+// end catch_tag_alias.cpp
+// start catch_tag_alias_autoregistrar.cpp
+
+namespace Catch {
+
+    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
+        CATCH_TRY {
+            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+
+}
+// end catch_tag_alias_autoregistrar.cpp
+// start catch_tag_alias_registry.cpp
+
+#include <sstream>
+
+namespace Catch {
+
+    TagAliasRegistry::~TagAliasRegistry() {}
+
+    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
+        auto it = m_registry.find( alias );
+        if( it != m_registry.end() )
+            return &(it->second);
+        else
+            return nullptr;
+    }
+
+    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+        std::string expandedTestSpec = unexpandedTestSpec;
+        for( auto const& registryKvp : m_registry ) {
+            std::size_t pos = expandedTestSpec.find( registryKvp.first );
+            if( pos != std::string::npos ) {
+                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
+                                    registryKvp.second.tag +
+                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
+            }
+        }
+        return expandedTestSpec;
+    }
+
+    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
+        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
+                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
+
+        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
+                      "error: tag alias, '" << alias << "' already registered.\n"
+                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
+                      << "\tRedefined at: " << lineInfo );
+    }
+
+    ITagAliasRegistry::~ITagAliasRegistry() {}
+
+    ITagAliasRegistry const& ITagAliasRegistry::get() {
+        return getRegistryHub().getTagAliasRegistry();
+    }
+
+} // end namespace Catch
+// end catch_tag_alias_registry.cpp
+// start catch_test_case_info.cpp
+
+#include <cctype>
+#include <exception>
+#include <algorithm>
+#include <sstream>
+
+namespace Catch {
+
+    namespace {
+        TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
+            if( startsWith( tag, '.' ) ||
+                tag == "!hide" )
+                return TestCaseInfo::IsHidden;
+            else if( tag == "!throws" )
+                return TestCaseInfo::Throws;
+            else if( tag == "!shouldfail" )
+                return TestCaseInfo::ShouldFail;
+            else if( tag == "!mayfail" )
+                return TestCaseInfo::MayFail;
+            else if( tag == "!nonportable" )
+                return TestCaseInfo::NonPortable;
+            else if( tag == "!benchmark" )
+                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
+            else
+                return TestCaseInfo::None;
+        }
+        bool isReservedTag( std::string const& tag ) {
+            return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
+        }
+        void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
+            CATCH_ENFORCE( !isReservedTag(tag),
+                          "Tag name: [" << tag << "] is not allowed.\n"
+                          << "Tag names starting with non alphanumeric characters are reserved\n"
+                          << _lineInfo );
+        }
+    }
+
+    TestCase makeTestCase(  ITestInvoker* _testCase,
+                            std::string const& _className,
+                            NameAndTags const& nameAndTags,
+                            SourceLineInfo const& _lineInfo )
+    {
+        bool isHidden = false;
+
+        // Parse out tags
+        std::vector<std::string> tags;
+        std::string desc, tag;
+        bool inTag = false;
+        for (char c : nameAndTags.tags) {
+            if( !inTag ) {
+                if( c == '[' )
+                    inTag = true;
+                else
+                    desc += c;
+            }
+            else {
+                if( c == ']' ) {
+                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
+                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
+                        isHidden = true;
+                    else if( prop == TestCaseInfo::None )
+                        enforceNotReservedTag( tag, _lineInfo );
+
+                    // Merged hide tags like `[.approvals]` should be added as
+                    // `[.][approvals]`. The `[.]` is added at later point, so
+                    // we only strip the prefix
+                    if (startsWith(tag, '.') && tag.size() > 1) {
+                        tag.erase(0, 1);
+                    }
+                    tags.push_back( tag );
+                    tag.clear();
+                    inTag = false;
+                }
+                else
+                    tag += c;
+            }
+        }
+        if( isHidden ) {
+            // Add all "hidden" tags to make them behave identically
+            tags.insert( tags.end(), { ".", "!hide" } );
+        }
+
+        TestCaseInfo info( static_cast<std::string>(nameAndTags.name), _className, desc, tags, _lineInfo );
+        return TestCase( _testCase, std::move(info) );
+    }
+
+    void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
+        std::sort(begin(tags), end(tags));
+        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
+        testCaseInfo.lcaseTags.clear();
+
+        for( auto const& tag : tags ) {
+            std::string lcaseTag = toLower( tag );
+            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
+            testCaseInfo.lcaseTags.push_back( lcaseTag );
+        }
+        testCaseInfo.tags = std::move(tags);
+    }
+
+    TestCaseInfo::TestCaseInfo( std::string const& _name,
+                                std::string const& _className,
+                                std::string const& _description,
+                                std::vector<std::string> const& _tags,
+                                SourceLineInfo const& _lineInfo )
+    :   name( _name ),
+        className( _className ),
+        description( _description ),
+        lineInfo( _lineInfo ),
+        properties( None )
+    {
+        setTags( *this, _tags );
+    }
+
+    bool TestCaseInfo::isHidden() const {
+        return ( properties & IsHidden ) != 0;
+    }
+    bool TestCaseInfo::throws() const {
+        return ( properties & Throws ) != 0;
+    }
+    bool TestCaseInfo::okToFail() const {
+        return ( properties & (ShouldFail | MayFail ) ) != 0;
+    }
+    bool TestCaseInfo::expectedToFail() const {
+        return ( properties & (ShouldFail ) ) != 0;
+    }
+
+    std::string TestCaseInfo::tagsAsString() const {
+        std::string ret;
+        // '[' and ']' per tag
+        std::size_t full_size = 2 * tags.size();
+        for (const auto& tag : tags) {
+            full_size += tag.size();
+        }
+        ret.reserve(full_size);
+        for (const auto& tag : tags) {
+            ret.push_back('[');
+            ret.append(tag);
+            ret.push_back(']');
+        }
+
+        return ret;
+    }
+
+    TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
+
+    TestCase TestCase::withName( std::string const& _newName ) const {
+        TestCase other( *this );
+        other.name = _newName;
+        return other;
+    }
+
+    void TestCase::invoke() const {
+        test->invoke();
+    }
+
+    bool TestCase::operator == ( TestCase const& other ) const {
+        return  test.get() == other.test.get() &&
+                name == other.name &&
+                className == other.className;
+    }
+
+    bool TestCase::operator < ( TestCase const& other ) const {
+        return name < other.name;
+    }
+
+    TestCaseInfo const& TestCase::getTestCaseInfo() const
+    {
+        return *this;
+    }
+
+} // end namespace Catch
+// end catch_test_case_info.cpp
+// start catch_test_case_registry_impl.cpp
+
+#include <sstream>
+
+namespace Catch {
+
+    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
+
+        std::vector<TestCase> sorted = unsortedTestCases;
+
+        switch( config.runOrder() ) {
+            case RunTests::InLexicographicalOrder:
+                std::sort( sorted.begin(), sorted.end() );
+                break;
+            case RunTests::InRandomOrder:
+                seedRng( config );
+                std::shuffle( sorted.begin(), sorted.end(), rng() );
+                break;
+            case RunTests::InDeclarationOrder:
+                // already in declaration order
+                break;
+        }
+        return sorted;
+    }
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config ) {
+        return !testCase.throws() || config.allowThrows();
+    }
+
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
+        return testSpec.matches( testCase ) && isThrowSafe( testCase, config );
+    }
+
+    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
+        std::set<TestCase> seenFunctions;
+        for( auto const& function : functions ) {
+            auto prev = seenFunctions.insert( function );
+            CATCH_ENFORCE( prev.second,
+                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
+                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
+                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
+        }
+    }
+
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
+        std::vector<TestCase> filtered;
+        filtered.reserve( testCases.size() );
+        for (auto const& testCase : testCases) {
+            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
+                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
+                filtered.push_back(testCase);
+            }
+        }
+        return filtered;
+    }
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
+        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
+    }
+
+    void TestRegistry::registerTest( TestCase const& testCase ) {
+        std::string name = testCase.getTestCaseInfo().name;
+        if( name.empty() ) {
+            ReusableStringStream rss;
+            rss << "Anonymous test case " << ++m_unnamedCount;
+            return registerTest( testCase.withName( rss.str() ) );
+        }
+        m_functions.push_back( testCase );
+    }
+
+    std::vector<TestCase> const& TestRegistry::getAllTests() const {
+        return m_functions;
+    }
+    std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
+        if( m_sortedFunctions.empty() )
+            enforceNoDuplicateTestCases( m_functions );
+
+        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
+            m_sortedFunctions = sortTests( config, m_functions );
+            m_currentSortOrder = config.runOrder();
+        }
+        return m_sortedFunctions;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
+
+    void TestInvokerAsFunction::invoke() const {
+        m_testAsFunction();
+    }
+
+    std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
+        std::string className(classOrQualifiedMethodName);
+        if( startsWith( className, '&' ) )
+        {
+            std::size_t lastColons = className.rfind( "::" );
+            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
+            if( penultimateColons == std::string::npos )
+                penultimateColons = 1;
+            className = className.substr( penultimateColons, lastColons-penultimateColons );
+        }
+        return className;
+    }
+
+} // end namespace Catch
+// end catch_test_case_registry_impl.cpp
+// start catch_test_case_tracker.cpp
+
+#include <algorithm>
+#include <cassert>
+#include <stdexcept>
+#include <memory>
+#include <sstream>
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
+    :   name( _name ),
+        location( _location )
+    {}
+
+    ITracker::~ITracker() = default;
+
+    ITracker& TrackerContext::startRun() {
+        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
+        m_currentTracker = nullptr;
+        m_runState = Executing;
+        return *m_rootTracker;
+    }
+
+    void TrackerContext::endRun() {
+        m_rootTracker.reset();
+        m_currentTracker = nullptr;
+        m_runState = NotStarted;
+    }
+
+    void TrackerContext::startCycle() {
+        m_currentTracker = m_rootTracker.get();
+        m_runState = Executing;
+    }
+    void TrackerContext::completeCycle() {
+        m_runState = CompletedCycle;
+    }
+
+    bool TrackerContext::completedCycle() const {
+        return m_runState == CompletedCycle;
+    }
+    ITracker& TrackerContext::currentTracker() {
+        return *m_currentTracker;
+    }
+    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
+        m_currentTracker = tracker;
+    }
+
+    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+    :   m_nameAndLocation( nameAndLocation ),
+        m_ctx( ctx ),
+        m_parent( parent )
+    {}
+
+    NameAndLocation const& TrackerBase::nameAndLocation() const {
+        return m_nameAndLocation;
+    }
+    bool TrackerBase::isComplete() const {
+        return m_runState == CompletedSuccessfully || m_runState == Failed;
+    }
+    bool TrackerBase::isSuccessfullyCompleted() const {
+        return m_runState == CompletedSuccessfully;
+    }
+    bool TrackerBase::isOpen() const {
+        return m_runState != NotStarted && !isComplete();
+    }
+    bool TrackerBase::hasChildren() const {
+        return !m_children.empty();
+    }
+
+    void TrackerBase::addChild( ITrackerPtr const& child ) {
+        m_children.push_back( child );
+    }
+
+    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
+        auto it = std::find_if( m_children.begin(), m_children.end(),
+            [&nameAndLocation]( ITrackerPtr const& tracker ){
+                return
+                    tracker->nameAndLocation().location == nameAndLocation.location &&
+                    tracker->nameAndLocation().name == nameAndLocation.name;
+            } );
+        return( it != m_children.end() )
+            ? *it
+            : nullptr;
+    }
+    ITracker& TrackerBase::parent() {
+        assert( m_parent ); // Should always be non-null except for root
+        return *m_parent;
+    }
+
+    void TrackerBase::openChild() {
+        if( m_runState != ExecutingChildren ) {
+            m_runState = ExecutingChildren;
+            if( m_parent )
+                m_parent->openChild();
+        }
+    }
+
+    bool TrackerBase::isSectionTracker() const { return false; }
+    bool TrackerBase::isGeneratorTracker() const { return false; }
+
+    void TrackerBase::open() {
+        m_runState = Executing;
+        moveToThis();
+        if( m_parent )
+            m_parent->openChild();
+    }
+
+    void TrackerBase::close() {
+
+        // Close any still open children (e.g. generators)
+        while( &m_ctx.currentTracker() != this )
+            m_ctx.currentTracker().close();
+
+        switch( m_runState ) {
+            case NeedsAnotherRun:
+                break;
+
+            case Executing:
+                m_runState = CompletedSuccessfully;
+                break;
+            case ExecutingChildren:
+                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
+                    m_runState = CompletedSuccessfully;
+                break;
+
+            case NotStarted:
+            case CompletedSuccessfully:
+            case Failed:
+                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
+
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
+        }
+        moveToParent();
+        m_ctx.completeCycle();
+    }
+    void TrackerBase::fail() {
+        m_runState = Failed;
+        if( m_parent )
+            m_parent->markAsNeedingAnotherRun();
+        moveToParent();
+        m_ctx.completeCycle();
+    }
+    void TrackerBase::markAsNeedingAnotherRun() {
+        m_runState = NeedsAnotherRun;
+    }
+
+    void TrackerBase::moveToParent() {
+        assert( m_parent );
+        m_ctx.setCurrentTracker( m_parent );
+    }
+    void TrackerBase::moveToThis() {
+        m_ctx.setCurrentTracker( this );
+    }
+
+    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+    :   TrackerBase( nameAndLocation, ctx, parent ),
+        m_trimmed_name(trim(nameAndLocation.name))
+    {
+        if( parent ) {
+            while( !parent->isSectionTracker() )
+                parent = &parent->parent();
+
+            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
+            addNextFilters( parentSection.m_filters );
+        }
+    }
+
+    bool SectionTracker::isComplete() const {
+        bool complete = true;
+
+        if ((m_filters.empty() || m_filters[0] == "")
+            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
+            complete = TrackerBase::isComplete();
+        }
+        return complete;
+    }
+
+    bool SectionTracker::isSectionTracker() const { return true; }
+
+    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
+        std::shared_ptr<SectionTracker> section;
+
+        ITracker& currentTracker = ctx.currentTracker();
+        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+            assert( childTracker );
+            assert( childTracker->isSectionTracker() );
+            section = std::static_pointer_cast<SectionTracker>( childTracker );
+        }
+        else {
+            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
+            currentTracker.addChild( section );
+        }
+        if( !ctx.completedCycle() )
+            section->tryOpen();
+        return *section;
+    }
+
+    void SectionTracker::tryOpen() {
+        if( !isComplete() )
+            open();
+    }
+
+    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
+        if( !filters.empty() ) {
+            m_filters.reserve( m_filters.size() + filters.size() + 2 );
+            m_filters.emplace_back(""); // Root - should never be consulted
+            m_filters.emplace_back(""); // Test Case - not a section filter
+            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
+        }
+    }
+    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
+        if( filters.size() > 1 )
+            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
+    }
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+
+} // namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+// end catch_test_case_tracker.cpp
+// start catch_test_registry.cpp
+
+namespace Catch {
+
+    auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
+        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
+    }
+
+    NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
+
+    AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
+        CATCH_TRY {
+            getMutableRegistryHub()
+                    .registerTest(
+                        makeTestCase(
+                            invoker,
+                            extractClassName( classOrMethod ),
+                            nameAndTags,
+                            lineInfo));
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+
+    AutoReg::~AutoReg() = default;
+}
+// end catch_test_registry.cpp
+// start catch_test_spec.cpp
+
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    TestSpec::Pattern::Pattern( std::string const& name )
+    : m_name( name )
+    {}
+
+    TestSpec::Pattern::~Pattern() = default;
+
+    std::string const& TestSpec::Pattern::name() const {
+        return m_name;
+    }
+
+    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
+    : Pattern( filterString )
+    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
+    {}
+
+    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
+        return m_wildcardPattern.matches( testCase.name );
+    }
+
+    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
+    : Pattern( filterString )
+    , m_tag( toLower( tag ) )
+    {}
+
+    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
+        return std::find(begin(testCase.lcaseTags),
+                         end(testCase.lcaseTags),
+                         m_tag) != end(testCase.lcaseTags);
+    }
+
+    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern )
+    : Pattern( underlyingPattern->name() )
+    , m_underlyingPattern( underlyingPattern )
+    {}
+
+    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const {
+        return !m_underlyingPattern->matches( testCase );
+    }
+
+    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
+        return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
+    }
+
+    std::string TestSpec::Filter::name() const {
+        std::string name;
+        for( auto const& p : m_patterns )
+            name += p->name();
+        return name;
+    }
+
+    bool TestSpec::hasFilters() const {
+        return !m_filters.empty();
+    }
+
+    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
+        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
+    }
+
+    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
+    {
+        Matches matches( m_filters.size() );
+        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
+            std::vector<TestCase const*> currentMatches;
+            for( auto const& test : testCases )
+                if( isThrowSafe( test, config ) && filter.matches( test ) )
+                    currentMatches.emplace_back( &test );
+            return FilterMatch{ filter.name(), currentMatches };
+        } );
+        return matches;
+    }
+
+    const TestSpec::vectorStrings& TestSpec::getInvalidArgs() const{
+        return  (m_invalidArgs);
+    }
+
+}
+// end catch_test_spec.cpp
+// start catch_test_spec_parser.cpp
+
+namespace Catch {
+
+    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+
+    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
+        m_mode = None;
+        m_exclusion = false;
+        m_arg = m_tagAliases->expandAliases( arg );
+        m_escapeChars.clear();
+        m_substring.reserve(m_arg.size());
+        m_patternName.reserve(m_arg.size());
+        m_realPatternPos = 0;
+
+        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+          //if visitChar fails
+           if( !visitChar( m_arg[m_pos] ) ){
+               m_testSpec.m_invalidArgs.push_back(arg);
+               break;
+           }
+        endMode();
+        return *this;
+    }
+    TestSpec TestSpecParser::testSpec() {
+        addFilter();
+        return m_testSpec;
+    }
+    bool TestSpecParser::visitChar( char c ) {
+        if( (m_mode != EscapedName) && (c == '\\') ) {
+            escape();
+            addCharToPattern(c);
+            return true;
+        }else if((m_mode != EscapedName) && (c == ',') )  {
+            return separate();
+        }
+
+        switch( m_mode ) {
+        case None:
+            if( processNoneChar( c ) )
+                return true;
+            break;
+        case Name:
+            processNameChar( c );
+            break;
+        case EscapedName:
+            endMode();
+            addCharToPattern(c);
+            return true;
+        default:
+        case Tag:
+        case QuotedName:
+            if( processOtherChar( c ) )
+                return true;
+            break;
+        }
+
+        m_substring += c;
+        if( !isControlChar( c ) ) {
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+        return true;
+    }
+    // Two of the processing methods return true to signal the caller to return
+    // without adding the given character to the current pattern strings
+    bool TestSpecParser::processNoneChar( char c ) {
+        switch( c ) {
+        case ' ':
+            return true;
+        case '~':
+            m_exclusion = true;
+            return false;
+        case '[':
+            startNewMode( Tag );
+            return false;
+        case '"':
+            startNewMode( QuotedName );
+            return false;
+        default:
+            startNewMode( Name );
+            return false;
+        }
+    }
+    void TestSpecParser::processNameChar( char c ) {
+        if( c == '[' ) {
+            if( m_substring == "exclude:" )
+                m_exclusion = true;
+            else
+                endMode();
+            startNewMode( Tag );
+        }
+    }
+    bool TestSpecParser::processOtherChar( char c ) {
+        if( !isControlChar( c ) )
+            return false;
+        m_substring += c;
+        endMode();
+        return true;
+    }
+    void TestSpecParser::startNewMode( Mode mode ) {
+        m_mode = mode;
+    }
+    void TestSpecParser::endMode() {
+        switch( m_mode ) {
+        case Name:
+        case QuotedName:
+            return addNamePattern();
+        case Tag:
+            return addTagPattern();
+        case EscapedName:
+            revertBackToLastMode();
+            return;
+        case None:
+        default:
+            return startNewMode( None );
+        }
+    }
+    void TestSpecParser::escape() {
+        saveLastMode();
+        m_mode = EscapedName;
+        m_escapeChars.push_back(m_realPatternPos);
+    }
+    bool TestSpecParser::isControlChar( char c ) const {
+        switch( m_mode ) {
+            default:
+                return false;
+            case None:
+                return c == '~';
+            case Name:
+                return c == '[';
+            case EscapedName:
+                return true;
+            case QuotedName:
+                return c == '"';
+            case Tag:
+                return c == '[' || c == ']';
+        }
+    }
+
+    void TestSpecParser::addFilter() {
+        if( !m_currentFilter.m_patterns.empty() ) {
+            m_testSpec.m_filters.push_back( m_currentFilter );
+            m_currentFilter = TestSpec::Filter();
+        }
+    }
+
+    void TestSpecParser::saveLastMode() {
+      lastMode = m_mode;
+    }
+
+    void TestSpecParser::revertBackToLastMode() {
+      m_mode = lastMode;
+    }
+
+    bool TestSpecParser::separate() {
+      if( (m_mode==QuotedName) || (m_mode==Tag) ){
+         //invalid argument, signal failure to previous scope.
+         m_mode = None;
+         m_pos = m_arg.size();
+         m_substring.clear();
+         m_patternName.clear();
+         return false;
+      }
+      endMode();
+      addFilter();
+      return true; //success
+    }
+
+    std::string TestSpecParser::preprocessPattern() {
+        std::string token = m_patternName;
+        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
+            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
+        m_escapeChars.clear();
+        if (startsWith(token, "exclude:")) {
+            m_exclusion = true;
+            token = token.substr(8);
+        }
+
+        m_patternName.clear();
+
+        return token;
+    }
+
+    void TestSpecParser::addNamePattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
+            if (m_exclusion)
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    void TestSpecParser::addTagPattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
+            // we have to create a separate hide tag and shorten the real one
+            if (token.size() > 1 && token[0] == '.') {
+                token.erase(token.begin());
+                TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
+                if (m_exclusion) {
+                    pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+                }
+                m_currentFilter.m_patterns.push_back(pattern);
+            }
+
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);
+
+            if (m_exclusion) {
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            }
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    TestSpec parseTestSpec( std::string const& arg ) {
+        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
+    }
+
+} // namespace Catch
+// end catch_test_spec_parser.cpp
+// start catch_timer.cpp
+
+#include <chrono>
+
+static const uint64_t nanosecondsInSecond = 1000000000;
+
+namespace Catch {
+
+    auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
+        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
+    }
+
+    namespace {
+        auto estimateClockResolution() -> uint64_t {
+            uint64_t sum = 0;
+            static const uint64_t iterations = 1000000;
+
+            auto startTime = getCurrentNanosecondsSinceEpoch();
+
+            for( std::size_t i = 0; i < iterations; ++i ) {
+
+                uint64_t ticks;
+                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
+                do {
+                    ticks = getCurrentNanosecondsSinceEpoch();
+                } while( ticks == baseTicks );
+
+                auto delta = ticks - baseTicks;
+                sum += delta;
+
+                // If we have been calibrating for over 3 seconds -- the clock
+                // is terrible and we should move on.
+                // TBD: How to signal that the measured resolution is probably wrong?
+                if (ticks > startTime + 3 * nanosecondsInSecond) {
+                    return sum / ( i + 1u );
+                }
+            }
+
+            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
+            // - and potentially do more iterations if there's a high variance.
+            return sum/iterations;
+        }
+    }
+    auto getEstimatedClockResolution() -> uint64_t {
+        static auto s_resolution = estimateClockResolution();
+        return s_resolution;
+    }
+
+    void Timer::start() {
+       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
+    }
+    auto Timer::getElapsedNanoseconds() const -> uint64_t {
+        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
+    }
+    auto Timer::getElapsedMicroseconds() const -> uint64_t {
+        return getElapsedNanoseconds()/1000;
+    }
+    auto Timer::getElapsedMilliseconds() const -> unsigned int {
+        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
+    }
+    auto Timer::getElapsedSeconds() const -> double {
+        return getElapsedMicroseconds()/1000000.0;
+    }
+
+} // namespace Catch
+// end catch_timer.cpp
+// start catch_tostring.cpp
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#    pragma clang diagnostic ignored "-Wglobal-constructors"
+#endif
+
+// Enable specific decls locally
+#if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#endif
+
+#include <cmath>
+#include <iomanip>
+
+namespace Catch {
+
+namespace Detail {
+
+    const std::string unprintableString = "{?}";
+
+    namespace {
+        const int hexThreshold = 255;
+
+        struct Endianness {
+            enum Arch { Big, Little };
+
+            static Arch which() {
+                int one = 1;
+                // If the lowest byte we read is non-zero, we can assume
+                // that little endian format is used.
+                auto value = *reinterpret_cast<char*>(&one);
+                return value ? Little : Big;
+            }
+        };
+    }
+
+    std::string rawMemoryToString( const void *object, std::size_t size ) {
+        // Reverse order for little endian architectures
+        int i = 0, end = static_cast<int>( size ), inc = 1;
+        if( Endianness::which() == Endianness::Little ) {
+            i = end-1;
+            end = inc = -1;
+        }
+
+        unsigned char const *bytes = static_cast<unsigned char const *>(object);
+        ReusableStringStream rss;
+        rss << "0x" << std::setfill('0') << std::hex;
+        for( ; i != end; i += inc )
+             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
+       return rss.str();
+    }
+}
+
+template<typename T>
+std::string fpToString( T value, int precision ) {
+    if (Catch::isnan(value)) {
+        return "nan";
+    }
+
+    ReusableStringStream rss;
+    rss << std::setprecision( precision )
+        << std::fixed
+        << value;
+    std::string d = rss.str();
+    std::size_t i = d.find_last_not_of( '0' );
+    if( i != std::string::npos && i != d.size()-1 ) {
+        if( d[i] == '.' )
+            i++;
+        d = d.substr( 0, i+1 );
+    }
+    return d;
+}
+
+//// ======================================================= ////
+//
+//   Out-of-line defs for full specialization of StringMaker
+//
+//// ======================================================= ////
+
+std::string StringMaker<std::string>::convert(const std::string& str) {
+    if (!getCurrentContext().getConfig()->showInvisibles()) {
+        return '"' + str + '"';
+    }
+
+    std::string s("\"");
+    for (char c : str) {
+        switch (c) {
+        case '\n':
+            s.append("\\n");
+            break;
+        case '\t':
+            s.append("\\t");
+            break;
+        default:
+            s.push_back(c);
+            break;
+        }
+    }
+    s.append("\"");
+    return s;
+}
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::string_view>::convert(std::string_view str) {
+    return ::Catch::Detail::stringify(std::string{ str });
+}
+#endif
+
+std::string StringMaker<char const*>::convert(char const* str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::string{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<char*>::convert(char* str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::string{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+
+#ifdef CATCH_CONFIG_WCHAR
+std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
+    std::string s;
+    s.reserve(wstr.size());
+    for (auto c : wstr) {
+        s += (c <= 0xff) ? static_cast<char>(c) : '?';
+    }
+    return ::Catch::Detail::stringify(s);
+}
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
+    return StringMaker<std::wstring>::convert(std::wstring(str));
+}
+# endif
+
+std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::wstring{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::wstring{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+#endif
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+#include <cstddef>
+std::string StringMaker<std::byte>::convert(std::byte value) {
+    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
+}
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+
+std::string StringMaker<int>::convert(int value) {
+    return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long>::convert(long value) {
+    return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long long>::convert(long long value) {
+    ReusableStringStream rss;
+    rss << value;
+    if (value > Detail::hexThreshold) {
+        rss << " (0x" << std::hex << value << ')';
+    }
+    return rss.str();
+}
+
+std::string StringMaker<unsigned int>::convert(unsigned int value) {
+    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long>::convert(unsigned long value) {
+    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
+    ReusableStringStream rss;
+    rss << value;
+    if (value > Detail::hexThreshold) {
+        rss << " (0x" << std::hex << value << ')';
+    }
+    return rss.str();
+}
+
+std::string StringMaker<bool>::convert(bool b) {
+    return b ? "true" : "false";
+}
+
+std::string StringMaker<signed char>::convert(signed char value) {
+    if (value == '\r') {
+        return "'\\r'";
+    } else if (value == '\f') {
+        return "'\\f'";
+    } else if (value == '\n') {
+        return "'\\n'";
+    } else if (value == '\t') {
+        return "'\\t'";
+    } else if ('\0' <= value && value < ' ') {
+        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
+    } else {
+        char chstr[] = "' '";
+        chstr[1] = value;
+        return chstr;
+    }
+}
+std::string StringMaker<char>::convert(char c) {
+    return ::Catch::Detail::stringify(static_cast<signed char>(c));
+}
+std::string StringMaker<unsigned char>::convert(unsigned char c) {
+    return ::Catch::Detail::stringify(static_cast<char>(c));
+}
+
+std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
+    return "nullptr";
+}
+
+int StringMaker<float>::precision = 5;
+
+std::string StringMaker<float>::convert(float value) {
+    return fpToString(value, precision) + 'f';
+}
+
+int StringMaker<double>::precision = 10;
+
+std::string StringMaker<double>::convert(double value) {
+    return fpToString(value, precision);
+}
+
+std::string ratio_string<std::atto>::symbol() { return "a"; }
+std::string ratio_string<std::femto>::symbol() { return "f"; }
+std::string ratio_string<std::pico>::symbol() { return "p"; }
+std::string ratio_string<std::nano>::symbol() { return "n"; }
+std::string ratio_string<std::micro>::symbol() { return "u"; }
+std::string ratio_string<std::milli>::symbol() { return "m"; }
+
+} // end namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+// end catch_tostring.cpp
+// start catch_totals.cpp
+
+namespace Catch {
+
+    Counts Counts::operator - ( Counts const& other ) const {
+        Counts diff;
+        diff.passed = passed - other.passed;
+        diff.failed = failed - other.failed;
+        diff.failedButOk = failedButOk - other.failedButOk;
+        return diff;
+    }
+
+    Counts& Counts::operator += ( Counts const& other ) {
+        passed += other.passed;
+        failed += other.failed;
+        failedButOk += other.failedButOk;
+        return *this;
+    }
+
+    std::size_t Counts::total() const {
+        return passed + failed + failedButOk;
+    }
+    bool Counts::allPassed() const {
+        return failed == 0 && failedButOk == 0;
+    }
+    bool Counts::allOk() const {
+        return failed == 0;
+    }
+
+    Totals Totals::operator - ( Totals const& other ) const {
+        Totals diff;
+        diff.assertions = assertions - other.assertions;
+        diff.testCases = testCases - other.testCases;
+        return diff;
+    }
+
+    Totals& Totals::operator += ( Totals const& other ) {
+        assertions += other.assertions;
+        testCases += other.testCases;
+        return *this;
+    }
+
+    Totals Totals::delta( Totals const& prevTotals ) const {
+        Totals diff = *this - prevTotals;
+        if( diff.assertions.failed > 0 )
+            ++diff.testCases.failed;
+        else if( diff.assertions.failedButOk > 0 )
+            ++diff.testCases.failedButOk;
+        else
+            ++diff.testCases.passed;
+        return diff;
+    }
+
+}
+// end catch_totals.cpp
+// start catch_uncaught_exceptions.cpp
+
+#include <exception>
+
+namespace Catch {
+    bool uncaught_exceptions() {
+#if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+        return std::uncaught_exceptions() > 0;
+#else
+        return std::uncaught_exception();
+#endif
+  }
+} // end namespace Catch
+// end catch_uncaught_exceptions.cpp
+// start catch_version.cpp
+
+#include <ostream>
+
+namespace Catch {
+
+    Version::Version
+        (   unsigned int _majorVersion,
+            unsigned int _minorVersion,
+            unsigned int _patchNumber,
+            char const * const _branchName,
+            unsigned int _buildNumber )
+    :   majorVersion( _majorVersion ),
+        minorVersion( _minorVersion ),
+        patchNumber( _patchNumber ),
+        branchName( _branchName ),
+        buildNumber( _buildNumber )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, Version const& version ) {
+        os  << version.majorVersion << '.'
+            << version.minorVersion << '.'
+            << version.patchNumber;
+        // branchName is never null -> 0th char is \0 if it is empty
+        if (version.branchName[0]) {
+            os << '-' << version.branchName
+               << '.' << version.buildNumber;
+        }
+        return os;
+    }
+
+    Version const& libraryVersion() {
+        static Version version( 2, 11, 3, "", 0 );
+        return version;
+    }
+
+}
+// end catch_version.cpp
+// start catch_wildcard_pattern.cpp
+
+namespace Catch {
+
+    WildcardPattern::WildcardPattern( std::string const& pattern,
+                                      CaseSensitive::Choice caseSensitivity )
+    :   m_caseSensitivity( caseSensitivity ),
+        m_pattern( normaliseString( pattern ) )
+    {
+        if( startsWith( m_pattern, '*' ) ) {
+            m_pattern = m_pattern.substr( 1 );
+            m_wildcard = WildcardAtStart;
+        }
+        if( endsWith( m_pattern, '*' ) ) {
+            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
+            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+        }
+    }
+
+    bool WildcardPattern::matches( std::string const& str ) const {
+        switch( m_wildcard ) {
+            case NoWildcard:
+                return m_pattern == normaliseString( str );
+            case WildcardAtStart:
+                return endsWith( normaliseString( str ), m_pattern );
+            case WildcardAtEnd:
+                return startsWith( normaliseString( str ), m_pattern );
+            case WildcardAtBothEnds:
+                return contains( normaliseString( str ), m_pattern );
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown enum" );
+        }
+    }
+
+    std::string WildcardPattern::normaliseString( std::string const& str ) const {
+        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
+    }
+}
+// end catch_wildcard_pattern.cpp
+// start catch_xmlwriter.cpp
+
+#include <iomanip>
+#include <type_traits>
+
+namespace Catch {
+
+namespace {
+
+    size_t trailingBytes(unsigned char c) {
+        if ((c & 0xE0) == 0xC0) {
+            return 2;
+        }
+        if ((c & 0xF0) == 0xE0) {
+            return 3;
+        }
+        if ((c & 0xF8) == 0xF0) {
+            return 4;
+        }
+        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    uint32_t headerValue(unsigned char c) {
+        if ((c & 0xE0) == 0xC0) {
+            return c & 0x1F;
+        }
+        if ((c & 0xF0) == 0xE0) {
+            return c & 0x0F;
+        }
+        if ((c & 0xF8) == 0xF0) {
+            return c & 0x07;
+        }
+        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    void hexEscapeChar(std::ostream& os, unsigned char c) {
+        std::ios_base::fmtflags f(os.flags());
+        os << "\\x"
+            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+            << static_cast<int>(c);
+        os.flags(f);
+    }
+
+    bool shouldNewline(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Newline));
+    }
+
+    bool shouldIndent(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Indent));
+    }
+
+} // anonymous namespace
+
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) |
+            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+        );
+    }
+
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) &
+            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+        );
+    }
+
+    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
+    :   m_str( str ),
+        m_forWhat( forWhat )
+    {}
+
+    void XmlEncode::encodeTo( std::ostream& os ) const {
+        // Apostrophe escaping not necessary if we always use " to write attributes
+        // (see: http://www.w3.org/TR/xml/#syntax)
+
+        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
+            unsigned char c = m_str[idx];
+            switch (c) {
+            case '<':   os << "&lt;"; break;
+            case '&':   os << "&amp;"; break;
+
+            case '>':
+                // See: http://www.w3.org/TR/xml/#syntax
+                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
+                    os << "&gt;";
+                else
+                    os << c;
+                break;
+
+            case '\"':
+                if (m_forWhat == ForAttributes)
+                    os << "&quot;";
+                else
+                    os << c;
+                break;
+
+            default:
+                // Check for control characters and invalid utf-8
+
+                // Escape control characters in standard ascii
+                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                // Plain ASCII: Write it to stream
+                if (c < 0x7F) {
+                    os << c;
+                    break;
+                }
+
+                // UTF-8 territory
+                // Check if the encoding is valid and if it is not, hex escape bytes.
+                // Important: We do not check the exact decoded values for validity, only the encoding format
+                // First check that this bytes is a valid lead byte:
+                // This means that it is not encoded as 1111 1XXX
+                // Or as 10XX XXXX
+                if (c <  0xC0 ||
+                    c >= 0xF8) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                auto encBytes = trailingBytes(c);
+                // Are there enough bytes left to avoid accessing out-of-bounds memory?
+                if (idx + encBytes - 1 >= m_str.size()) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+                // The header is valid, check data
+                // The next encBytes bytes must together be a valid utf-8
+                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
+                bool valid = true;
+                uint32_t value = headerValue(c);
+                for (std::size_t n = 1; n < encBytes; ++n) {
+                    unsigned char nc = m_str[idx + n];
+                    valid &= ((nc & 0xC0) == 0x80);
+                    value = (value << 6) | (nc & 0x3F);
+                }
+
+                if (
+                    // Wrong bit pattern of following bytes
+                    (!valid) ||
+                    // Overlong encodings
+                    (value < 0x80) ||
+                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
+                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
+                    // Encoded value out of range
+                    (value >= 0x110000)
+                    ) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                // If we got here, this is in fact a valid(ish) utf-8 sequence
+                for (std::size_t n = 0; n < encBytes; ++n) {
+                    os << m_str[idx + n];
+                }
+                idx += encBytes - 1;
+                break;
+            }
+        }
+    }
+
+    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
+        xmlEncode.encodeTo( os );
+        return os;
+    }
+
+    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
+    :   m_writer( writer ),
+        m_fmt(fmt)
+    {}
+
+    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
+    :   m_writer( other.m_writer ),
+        m_fmt(other.m_fmt)
+    {
+        other.m_writer = nullptr;
+        other.m_fmt = XmlFormatting::None;
+    }
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
+        if ( m_writer ) {
+            m_writer->endElement();
+        }
+        m_writer = other.m_writer;
+        other.m_writer = nullptr;
+        m_fmt = other.m_fmt;
+        other.m_fmt = XmlFormatting::None;
+        return *this;
+    }
+
+    XmlWriter::ScopedElement::~ScopedElement() {
+        if (m_writer) {
+            m_writer->endElement(m_fmt);
+        }
+    }
+
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, XmlFormatting fmt ) {
+        m_writer->writeText( text, fmt );
+        return *this;
+    }
+
+    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
+    {
+        writeDeclaration();
+    }
+
+    XmlWriter::~XmlWriter() {
+        while (!m_tags.empty()) {
+            endElement();
+        }
+        newlineIfNecessary();
+    }
+
+    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
+        ensureTagClosed();
+        newlineIfNecessary();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+            m_indent += "  ";
+        }
+        m_os << '<' << name;
+        m_tags.push_back( name );
+        m_tagIsOpen = true;
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
+        ScopedElement scoped( this, fmt );
+        startElement( name, fmt );
+        return scoped;
+    }
+
+    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
+        m_indent = m_indent.substr(0, m_indent.size() - 2);
+
+        if( m_tagIsOpen ) {
+            m_os << "/>";
+            m_tagIsOpen = false;
+        } else {
+            newlineIfNecessary();
+            if (shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << "</" << m_tags.back() << ">";
+        }
+        m_os << std::flush;
+        applyFormatting(fmt);
+        m_tags.pop_back();
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
+        if( !name.empty() && !attribute.empty() )
+            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
+        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
+        if( !text.empty() ){
+            bool tagWasOpen = m_tagIsOpen;
+            ensureTagClosed();
+            if (tagWasOpen && shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << XmlEncode( text );
+            applyFormatting(fmt);
+        }
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
+        ensureTagClosed();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+        }
+        m_os << "<!--" << text << "-->";
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    void XmlWriter::writeStylesheetRef( std::string const& url ) {
+        m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
+    }
+
+    XmlWriter& XmlWriter::writeBlankLine() {
+        ensureTagClosed();
+        m_os << '\n';
+        return *this;
+    }
+
+    void XmlWriter::ensureTagClosed() {
+        if( m_tagIsOpen ) {
+            m_os << '>' << std::flush;
+            newlineIfNecessary();
+            m_tagIsOpen = false;
+        }
+    }
+
+    void XmlWriter::applyFormatting(XmlFormatting fmt) {
+        m_needsNewline = shouldNewline(fmt);
+    }
+
+    void XmlWriter::writeDeclaration() {
+        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+    }
+
+    void XmlWriter::newlineIfNecessary() {
+        if( m_needsNewline ) {
+            m_os << std::endl;
+            m_needsNewline = false;
+        }
+    }
+}
+// end catch_xmlwriter.cpp
+// start catch_reporter_bases.cpp
+
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <cassert>
+#include <memory>
+
+namespace Catch {
+    void prepareExpandedExpression(AssertionResult& result) {
+        result.getExpandedExpression();
+    }
+
+    // Because formatting using c++ streams is stateful, drop down to C is required
+    // Alternatively we could use stringstream, but its performance is... not good.
+    std::string getFormattedDuration( double duration ) {
+        // Max exponent + 1 is required to represent the whole part
+        // + 1 for decimal point
+        // + 3 for the 3 decimal places
+        // + 1 for null terminator
+        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
+        char buffer[maxDoubleSize];
+
+        // Save previous errno, to prevent sprintf from overwriting it
+        ErrnoGuard guard;
+#ifdef _MSC_VER
+        sprintf_s(buffer, "%.3f", duration);
+#else
+        std::sprintf(buffer, "%.3f", duration);
+#endif
+        return std::string(buffer);
+    }
+
+    std::string serializeFilters( std::vector<std::string> const& container ) {
+        ReusableStringStream oss;
+        bool first = true;
+        for (auto&& filter : container)
+        {
+            if (!first)
+                oss << ' ';
+            else
+                first = false;
+
+            oss << filter;
+        }
+        return oss.str();
+    }
+
+    TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
+        :StreamingReporterBase(_config) {}
+
+    std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
+        return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
+    }
+
+    void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
+
+    bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
+        return false;
+    }
+
+} // end namespace Catch
+// end catch_reporter_bases.cpp
+// start catch_reporter_compact.cpp
+
+namespace {
+
+#ifdef CATCH_PLATFORM_MAC
+    const char* failedString() { return "FAILED"; }
+    const char* passedString() { return "PASSED"; }
+#else
+    const char* failedString() { return "failed"; }
+    const char* passedString() { return "passed"; }
+#endif
+
+    // Colour::LightGrey
+    Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
+
+    std::string bothOrAll( std::size_t count ) {
+        return count == 1 ? std::string() :
+               count == 2 ? "both " : "all " ;
+    }
+
+} // anon namespace
+
+namespace Catch {
+namespace {
+// Colour, message variants:
+// - white: No tests ran.
+// -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
+// - white: Passed [both/all] N test cases (no assertions).
+// -   red: Failed N tests cases, failed M assertions.
+// - green: Passed [both/all] N tests cases with M assertions.
+void printTotals(std::ostream& out, const Totals& totals) {
+    if (totals.testCases.total() == 0) {
+        out << "No tests ran.";
+    } else if (totals.testCases.failed == totals.testCases.total()) {
+        Colour colour(Colour::ResultError);
+        const std::string qualify_assertions_failed =
+            totals.assertions.failed == totals.assertions.total() ?
+            bothOrAll(totals.assertions.failed) : std::string();
+        out <<
+            "Failed " << bothOrAll(totals.testCases.failed)
+            << pluralise(totals.testCases.failed, "test case") << ", "
+            "failed " << qualify_assertions_failed <<
+            pluralise(totals.assertions.failed, "assertion") << '.';
+    } else if (totals.assertions.total() == 0) {
+        out <<
+            "Passed " << bothOrAll(totals.testCases.total())
+            << pluralise(totals.testCases.total(), "test case")
+            << " (no assertions).";
+    } else if (totals.assertions.failed) {
+        Colour colour(Colour::ResultError);
+        out <<
+            "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
+            "failed " << pluralise(totals.assertions.failed, "assertion") << '.';
+    } else {
+        Colour colour(Colour::ResultSuccess);
+        out <<
+            "Passed " << bothOrAll(totals.testCases.passed)
+            << pluralise(totals.testCases.passed, "test case") <<
+            " with " << pluralise(totals.assertions.passed, "assertion") << '.';
+    }
+}
+
+// Implementation of CompactReporter formatting
+class AssertionPrinter {
+public:
+    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
+    AssertionPrinter(AssertionPrinter const&) = delete;
+    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+        : stream(_stream)
+        , result(_stats.assertionResult)
+        , messages(_stats.infoMessages)
+        , itMessage(_stats.infoMessages.begin())
+        , printInfoMessages(_printInfoMessages) {}
+
+    void print() {
+        printSourceInfo();
+
+        itMessage = messages.begin();
+
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            printResultType(Colour::ResultSuccess, passedString());
+            printOriginalExpression();
+            printReconstructedExpression();
+            if (!result.hasExpression())
+                printRemainingMessages(Colour::None);
+            else
+                printRemainingMessages();
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk())
+                printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
+            else
+                printResultType(Colour::Error, failedString());
+            printOriginalExpression();
+            printReconstructedExpression();
+            printRemainingMessages();
+            break;
+        case ResultWas::ThrewException:
+            printResultType(Colour::Error, failedString());
+            printIssue("unexpected exception with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::FatalErrorCondition:
+            printResultType(Colour::Error, failedString());
+            printIssue("fatal error condition with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::DidntThrowException:
+            printResultType(Colour::Error, failedString());
+            printIssue("expected exception, got none");
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::Info:
+            printResultType(Colour::None, "info");
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::Warning:
+            printResultType(Colour::None, "warning");
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::ExplicitFailure:
+            printResultType(Colour::Error, failedString());
+            printIssue("explicitly");
+            printRemainingMessages(Colour::None);
+            break;
+            // These cases are here to prevent compiler warnings
+        case ResultWas::Unknown:
+        case ResultWas::FailureBit:
+        case ResultWas::Exception:
+            printResultType(Colour::Error, "** internal error **");
+            break;
+        }
+    }
+
+private:
+    void printSourceInfo() const {
+        Colour colourGuard(Colour::FileName);
+        stream << result.getSourceInfo() << ':';
+    }
+
+    void printResultType(Colour::Code colour, std::string const& passOrFail) const {
+        if (!passOrFail.empty()) {
+            {
+                Colour colourGuard(colour);
+                stream << ' ' << passOrFail;
+            }
+            stream << ':';
+        }
+    }
+
+    void printIssue(std::string const& issue) const {
+        stream << ' ' << issue;
+    }
+
+    void printExpressionWas() {
+        if (result.hasExpression()) {
+            stream << ';';
+            {
+                Colour colour(dimColour());
+                stream << " expression was:";
+            }
+            printOriginalExpression();
+        }
+    }
+
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            stream << ' ' << result.getExpression();
+        }
+    }
+
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            {
+                Colour colour(dimColour());
+                stream << " for: ";
+            }
+            stream << result.getExpandedExpression();
+        }
+    }
+
+    void printMessage() {
+        if (itMessage != messages.end()) {
+            stream << " '" << itMessage->message << '\'';
+            ++itMessage;
+        }
+    }
+
+    void printRemainingMessages(Colour::Code colour = dimColour()) {
+        if (itMessage == messages.end())
+            return;
+
+        const auto itEnd = messages.cend();
+        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+
+        {
+            Colour colourGuard(colour);
+            stream << " with " << pluralise(N, "message") << ':';
+        }
+
+        while (itMessage != itEnd) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || itMessage->type != ResultWas::Info) {
+                printMessage();
+                if (itMessage != itEnd) {
+                    Colour colourGuard(dimColour());
+                    stream << " and";
+                }
+                continue;
+            }
+            ++itMessage;
+        }
+    }
+
+private:
+    std::ostream& stream;
+    AssertionResult const& result;
+    std::vector<MessageInfo> messages;
+    std::vector<MessageInfo>::const_iterator itMessage;
+    bool printInfoMessages;
+};
+
+} // anon namespace
+
+        std::string CompactReporter::getDescription() {
+            return "Reports test results on a single line, suitable for IDEs";
+        }
+
+        ReporterPreferences CompactReporter::getPreferences() const {
+            return m_reporterPrefs;
+        }
+
+        void CompactReporter::noMatchingTestCases( std::string const& spec ) {
+            stream << "No test cases matched '" << spec << '\'' << std::endl;
+        }
+
+        void CompactReporter::assertionStarting( AssertionInfo const& ) {}
+
+        bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool printInfoMessages = true;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+                if( result.getResultType() != ResultWas::Warning )
+                    return false;
+                printInfoMessages = false;
+            }
+
+            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
+            if (m_config->showDurations() == ShowDurations::Always) {
+                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+            }
+        }
+
+        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
+            printTotals( stream, _testRunStats.totals );
+            stream << '\n' << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+        CompactReporter::~CompactReporter() {}
+
+    CATCH_REGISTER_REPORTER( "compact", CompactReporter )
+
+} // end namespace Catch
+// end catch_reporter_compact.cpp
+// start catch_reporter_console.cpp
+
+#include <cfloat>
+#include <cstdio>
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+ // Note that 4062 (not all labels are handled and default is missing) is enabled
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic push
+// For simplicity, benchmarking-only helpers are always enabled
+#  pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+namespace Catch {
+
+namespace {
+
+// Formatter impl for ConsoleReporter
+class ConsoleAssertionPrinter {
+public:
+    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+        : stream(_stream),
+        stats(_stats),
+        result(_stats.assertionResult),
+        colour(Colour::None),
+        message(result.getMessage()),
+        messages(_stats.infoMessages),
+        printInfoMessages(_printInfoMessages) {
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            colour = Colour::Success;
+            passOrFail = "PASSED";
+            //if( result.hasMessage() )
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "with messages";
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk()) {
+                colour = Colour::Success;
+                passOrFail = "FAILED - but was ok";
+            } else {
+                colour = Colour::Error;
+                passOrFail = "FAILED";
+            }
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "with messages";
+            break;
+        case ResultWas::ThrewException:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "due to unexpected exception with ";
+            if (_stats.infoMessages.size() == 1)
+                messageLabel += "message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel += "messages";
+            break;
+        case ResultWas::FatalErrorCondition:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "due to a fatal error condition";
+            break;
+        case ResultWas::DidntThrowException:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "because no exception was thrown where one was expected";
+            break;
+        case ResultWas::Info:
+            messageLabel = "info";
+            break;
+        case ResultWas::Warning:
+            messageLabel = "warning";
+            break;
+        case ResultWas::ExplicitFailure:
+            passOrFail = "FAILED";
+            colour = Colour::Error;
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "explicitly with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "explicitly with messages";
+            break;
+            // These cases are here to prevent compiler warnings
+        case ResultWas::Unknown:
+        case ResultWas::FailureBit:
+        case ResultWas::Exception:
+            passOrFail = "** internal error **";
+            colour = Colour::Error;
+            break;
+        }
+    }
+
+    void print() const {
+        printSourceInfo();
+        if (stats.totals.assertions.total() > 0) {
+            printResultType();
+            printOriginalExpression();
+            printReconstructedExpression();
+        } else {
+            stream << '\n';
+        }
+        printMessage();
+    }
+
+private:
+    void printResultType() const {
+        if (!passOrFail.empty()) {
+            Colour colourGuard(colour);
+            stream << passOrFail << ":\n";
+        }
+    }
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            Colour colourGuard(Colour::OriginalExpression);
+            stream << "  ";
+            stream << result.getExpressionInMacro();
+            stream << '\n';
+        }
+    }
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            stream << "with expansion:\n";
+            Colour colourGuard(Colour::ReconstructedExpression);
+            stream << Column(result.getExpandedExpression()).indent(2) << '\n';
+        }
+    }
+    void printMessage() const {
+        if (!messageLabel.empty())
+            stream << messageLabel << ':' << '\n';
+        for (auto const& msg : messages) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || msg.type != ResultWas::Info)
+                stream << Column(msg.message).indent(2) << '\n';
+        }
+    }
+    void printSourceInfo() const {
+        Colour colourGuard(Colour::FileName);
+        stream << result.getSourceInfo() << ": ";
+    }
+
+    std::ostream& stream;
+    AssertionStats const& stats;
+    AssertionResult const& result;
+    Colour::Code colour;
+    std::string passOrFail;
+    std::string messageLabel;
+    std::string message;
+    std::vector<MessageInfo> messages;
+    bool printInfoMessages;
+};
+
+std::size_t makeRatio(std::size_t number, std::size_t total) {
+    std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
+    return (ratio == 0 && number > 0) ? 1 : ratio;
+}
+
+std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
+    if (i > j && i > k)
+        return i;
+    else if (j > k)
+        return j;
+    else
+        return k;
+}
+
+struct ColumnInfo {
+    enum Justification { Left, Right };
+    std::string name;
+    int width;
+    Justification justification;
+};
+struct ColumnBreak {};
+struct RowBreak {};
+
+class Duration {
+    enum class Unit {
+        Auto,
+        Nanoseconds,
+        Microseconds,
+        Milliseconds,
+        Seconds,
+        Minutes
+    };
+    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
+    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
+    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
+    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
+
+    double m_inNanoseconds;
+    Unit m_units;
+
+public:
+    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
+        : m_inNanoseconds(inNanoseconds),
+        m_units(units) {
+        if (m_units == Unit::Auto) {
+            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
+                m_units = Unit::Nanoseconds;
+            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
+                m_units = Unit::Microseconds;
+            else if (m_inNanoseconds < s_nanosecondsInASecond)
+                m_units = Unit::Milliseconds;
+            else if (m_inNanoseconds < s_nanosecondsInAMinute)
+                m_units = Unit::Seconds;
+            else
+                m_units = Unit::Minutes;
+        }
+
+    }
+
+    auto value() const -> double {
+        switch (m_units) {
+        case Unit::Microseconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
+        case Unit::Milliseconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
+        case Unit::Seconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
+        case Unit::Minutes:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
+        default:
+            return m_inNanoseconds;
+        }
+    }
+    auto unitsAsString() const -> std::string {
+        switch (m_units) {
+        case Unit::Nanoseconds:
+            return "ns";
+        case Unit::Microseconds:
+            return "us";
+        case Unit::Milliseconds:
+            return "ms";
+        case Unit::Seconds:
+            return "s";
+        case Unit::Minutes:
+            return "m";
+        default:
+            return "** internal error **";
+        }
+
+    }
+    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
+        return os << duration.value() << ' ' << duration.unitsAsString();
+    }
+};
+} // end anon namespace
+
+class TablePrinter {
+    std::ostream& m_os;
+    std::vector<ColumnInfo> m_columnInfos;
+    std::ostringstream m_oss;
+    int m_currentColumn = -1;
+    bool m_isOpen = false;
+
+public:
+    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
+    :   m_os( os ),
+        m_columnInfos( std::move( columnInfos ) ) {}
+
+    auto columnInfos() const -> std::vector<ColumnInfo> const& {
+        return m_columnInfos;
+    }
+
+    void open() {
+        if (!m_isOpen) {
+            m_isOpen = true;
+            *this << RowBreak();
+
+			Columns headerCols;
+			Spacer spacer(2);
+			for (auto const& info : m_columnInfos) {
+				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
+				headerCols += spacer;
+			}
+			m_os << headerCols << '\n';
+
+            m_os << Catch::getLineOfChars<'-'>() << '\n';
+        }
+    }
+    void close() {
+        if (m_isOpen) {
+            *this << RowBreak();
+            m_os << std::endl;
+            m_isOpen = false;
+        }
+    }
+
+    template<typename T>
+    friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
+        tp.m_oss << value;
+        return tp;
+    }
+
+    friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
+        auto colStr = tp.m_oss.str();
+        const auto strSize = colStr.size();
+        tp.m_oss.str("");
+        tp.open();
+        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
+            tp.m_currentColumn = -1;
+            tp.m_os << '\n';
+        }
+        tp.m_currentColumn++;
+
+        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
+        auto padding = (strSize + 1 < static_cast<std::size_t>(colInfo.width))
+            ? std::string(colInfo.width - (strSize + 1), ' ')
+            : std::string();
+        if (colInfo.justification == ColumnInfo::Left)
+            tp.m_os << colStr << padding << ' ';
+        else
+            tp.m_os << padding << colStr << ' ';
+        return tp;
+    }
+
+    friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
+        if (tp.m_currentColumn > 0) {
+            tp.m_os << '\n';
+            tp.m_currentColumn = -1;
+        }
+        return tp;
+    }
+};
+
+ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
+    : StreamingReporterBase(config),
+    m_tablePrinter(new TablePrinter(config.stream(),
+        [&config]() -> std::vector<ColumnInfo> {
+        if (config.fullConfig()->benchmarkNoAnalysis())
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
+                { "     samples", 14, ColumnInfo::Right },
+                { "  iterations", 14, ColumnInfo::Right },
+                { "        mean", 14, ColumnInfo::Right }
+            };
+        }
+        else
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
+                { "samples      mean       std dev", 14, ColumnInfo::Right },
+                { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
+                { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
+            };
+        }
+    }())) {}
+ConsoleReporter::~ConsoleReporter() = default;
+
+std::string ConsoleReporter::getDescription() {
+    return "Reports test results as plain lines of text";
+}
+
+void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
+    stream << "No test cases matched '" << spec << '\'' << std::endl;
+}
+
+void ConsoleReporter::reportInvalidArguments(std::string const&arg){
+    stream << "Invalid Filter: " << arg << std::endl;
+}
+
+void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
+
+bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
+    AssertionResult const& result = _assertionStats.assertionResult;
+
+    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+    // Drop out if result was successful but we're not printing them.
+    if (!includeResults && result.getResultType() != ResultWas::Warning)
+        return false;
+
+    lazyPrint();
+
+    ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
+    printer.print();
+    stream << std::endl;
+    return true;
+}
+
+void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+    m_tablePrinter->close();
+    m_headerPrinted = false;
+    StreamingReporterBase::sectionStarting(_sectionInfo);
+}
+void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
+    m_tablePrinter->close();
+    if (_sectionStats.missingAssertions) {
+        lazyPrint();
+        Colour colour(Colour::ResultError);
+        if (m_sectionStack.size() > 1)
+            stream << "\nNo assertions in section";
+        else
+            stream << "\nNo assertions in test case";
+        stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+    }
+    if (m_config->showDurations() == ShowDurations::Always) {
+        stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+    }
+    if (m_headerPrinted) {
+        m_headerPrinted = false;
+    }
+    StreamingReporterBase::sectionEnded(_sectionStats);
+}
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+void ConsoleReporter::benchmarkPreparing(std::string const& name) {
+	lazyPrintWithoutClosingBenchmarkTable();
+
+	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
+
+	bool firstLine = true;
+	for (auto line : nameCol) {
+		if (!firstLine)
+			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
+		else
+			firstLine = false;
+
+		(*m_tablePrinter) << line << ColumnBreak();
+	}
+}
+
+void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
+    (*m_tablePrinter) << info.samples << ColumnBreak()
+        << info.iterations << ColumnBreak();
+    if (!m_config->benchmarkNoAnalysis())
+        (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
+}
+void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
+    if (m_config->benchmarkNoAnalysis())
+    {
+        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
+    }
+    else
+    {
+        (*m_tablePrinter) << ColumnBreak()
+            << Duration(stats.mean.point.count()) << ColumnBreak()
+            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
+            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
+    }
+}
+
+void ConsoleReporter::benchmarkFailed(std::string const& error) {
+	Colour colour(Colour::Red);
+    (*m_tablePrinter)
+        << "Benchmark failed (" << error << ')'
+        << ColumnBreak() << RowBreak();
+}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+    m_tablePrinter->close();
+    StreamingReporterBase::testCaseEnded(_testCaseStats);
+    m_headerPrinted = false;
+}
+void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
+    if (currentGroupInfo.used) {
+        printSummaryDivider();
+        stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+        printTotals(_testGroupStats.totals);
+        stream << '\n' << std::endl;
+    }
+    StreamingReporterBase::testGroupEnded(_testGroupStats);
+}
+void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
+    printTotalsDivider(_testRunStats.totals);
+    printTotals(_testRunStats.totals);
+    stream << std::endl;
+    StreamingReporterBase::testRunEnded(_testRunStats);
+}
+void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
+    StreamingReporterBase::testRunStarting(_testInfo);
+    printTestFilters();
+}
+
+void ConsoleReporter::lazyPrint() {
+
+    m_tablePrinter->close();
+    lazyPrintWithoutClosingBenchmarkTable();
+}
+
+void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
+
+    if (!currentTestRunInfo.used)
+        lazyPrintRunInfo();
+    if (!currentGroupInfo.used)
+        lazyPrintGroupInfo();
+
+    if (!m_headerPrinted) {
+        printTestCaseAndSectionHeader();
+        m_headerPrinted = true;
+    }
+}
+void ConsoleReporter::lazyPrintRunInfo() {
+    stream << '\n' << getLineOfChars<'~'>() << '\n';
+    Colour colour(Colour::SecondaryText);
+    stream << currentTestRunInfo->name
+        << " is a Catch v" << libraryVersion() << " host application.\n"
+        << "Run with -? for options\n\n";
+
+    if (m_config->rngSeed() != 0)
+        stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
+
+    currentTestRunInfo.used = true;
+}
+void ConsoleReporter::lazyPrintGroupInfo() {
+    if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
+        printClosedHeader("Group: " + currentGroupInfo->name);
+        currentGroupInfo.used = true;
+    }
+}
+void ConsoleReporter::printTestCaseAndSectionHeader() {
+    assert(!m_sectionStack.empty());
+    printOpenHeader(currentTestCaseInfo->name);
+
+    if (m_sectionStack.size() > 1) {
+        Colour colourGuard(Colour::Headers);
+
+        auto
+            it = m_sectionStack.begin() + 1, // Skip first section (test case)
+            itEnd = m_sectionStack.end();
+        for (; it != itEnd; ++it)
+            printHeaderString(it->name, 2);
+    }
+
+    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
+
+    stream << getLineOfChars<'-'>() << '\n';
+    Colour colourGuard(Colour::FileName);
+    stream << lineInfo << '\n';
+    stream << getLineOfChars<'.'>() << '\n' << std::endl;
+}
+
+void ConsoleReporter::printClosedHeader(std::string const& _name) {
+    printOpenHeader(_name);
+    stream << getLineOfChars<'.'>() << '\n';
+}
+void ConsoleReporter::printOpenHeader(std::string const& _name) {
+    stream << getLineOfChars<'-'>() << '\n';
+    {
+        Colour colourGuard(Colour::Headers);
+        printHeaderString(_name);
+    }
+}
+
+// if string has a : in first line will set indent to follow it on
+// subsequent lines
+void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
+    std::size_t i = _string.find(": ");
+    if (i != std::string::npos)
+        i += 2;
+    else
+        i = 0;
+    stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
+}
+
+struct SummaryColumn {
+
+    SummaryColumn( std::string _label, Colour::Code _colour )
+    :   label( std::move( _label ) ),
+        colour( _colour ) {}
+    SummaryColumn addRow( std::size_t count ) {
+        ReusableStringStream rss;
+        rss << count;
+        std::string row = rss.str();
+        for (auto& oldRow : rows) {
+            while (oldRow.size() < row.size())
+                oldRow = ' ' + oldRow;
+            while (oldRow.size() > row.size())
+                row = ' ' + row;
+        }
+        rows.push_back(row);
+        return *this;
+    }
+
+    std::string label;
+    Colour::Code colour;
+    std::vector<std::string> rows;
+
+};
+
+void ConsoleReporter::printTotals( Totals const& totals ) {
+    if (totals.testCases.total() == 0) {
+        stream << Colour(Colour::Warning) << "No tests ran\n";
+    } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
+        stream << Colour(Colour::ResultSuccess) << "All tests passed";
+        stream << " ("
+            << pluralise(totals.assertions.passed, "assertion") << " in "
+            << pluralise(totals.testCases.passed, "test case") << ')'
+            << '\n';
+    } else {
+
+        std::vector<SummaryColumn> columns;
+        columns.push_back(SummaryColumn("", Colour::None)
+                          .addRow(totals.testCases.total())
+                          .addRow(totals.assertions.total()));
+        columns.push_back(SummaryColumn("passed", Colour::Success)
+                          .addRow(totals.testCases.passed)
+                          .addRow(totals.assertions.passed));
+        columns.push_back(SummaryColumn("failed", Colour::ResultError)
+                          .addRow(totals.testCases.failed)
+                          .addRow(totals.assertions.failed));
+        columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
+                          .addRow(totals.testCases.failedButOk)
+                          .addRow(totals.assertions.failedButOk));
+
+        printSummaryRow("test cases", columns, 0);
+        printSummaryRow("assertions", columns, 1);
+    }
+}
+void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
+    for (auto col : cols) {
+        std::string value = col.rows[row];
+        if (col.label.empty()) {
+            stream << label << ": ";
+            if (value != "0")
+                stream << value;
+            else
+                stream << Colour(Colour::Warning) << "- none -";
+        } else if (value != "0") {
+            stream << Colour(Colour::LightGrey) << " | ";
+            stream << Colour(col.colour)
+                << value << ' ' << col.label;
+        }
+    }
+    stream << '\n';
+}
+
+void ConsoleReporter::printTotalsDivider(Totals const& totals) {
+    if (totals.testCases.total() > 0) {
+        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
+        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
+        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
+        while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+            findMax(failedRatio, failedButOkRatio, passedRatio)++;
+        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
+            findMax(failedRatio, failedButOkRatio, passedRatio)--;
+
+        stream << Colour(Colour::Error) << std::string(failedRatio, '=');
+        stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
+        if (totals.testCases.allPassed())
+            stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
+        else
+            stream << Colour(Colour::Success) << std::string(passedRatio, '=');
+    } else {
+        stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
+    }
+    stream << '\n';
+}
+void ConsoleReporter::printSummaryDivider() {
+    stream << getLineOfChars<'-'>() << '\n';
+}
+
+void ConsoleReporter::printTestFilters() {
+    if (m_config->testSpec().hasFilters()) {
+        Colour guard(Colour::BrightYellow);
+        stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
+    }
+}
+
+CATCH_REGISTER_REPORTER("console", ConsoleReporter)
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic pop
+#endif
+// end catch_reporter_console.cpp
+// start catch_reporter_junit.cpp
+
+#include <cassert>
+#include <sstream>
+#include <ctime>
+#include <algorithm>
+
+namespace Catch {
+
+    namespace {
+        std::string getCurrentTimestamp() {
+            // Beware, this is not reentrant because of backward compatibility issues
+            // Also, UTC only, again because of backward compatibility (%z is C++11)
+            time_t rawtime;
+            std::time(&rawtime);
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &rawtime);
+#else
+            std::tm* timeInfo;
+            timeInfo = std::gmtime(&rawtime);
+#endif
+
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp);
+        }
+
+        std::string fileNameTag(const std::vector<std::string> &tags) {
+            auto it = std::find_if(begin(tags),
+                                   end(tags),
+                                   [] (std::string const& tag) {return tag.front() == '#'; });
+            if (it != tags.end())
+                return it->substr(1);
+            return std::string();
+        }
+    } // anonymous namespace
+
+    JunitReporter::JunitReporter( ReporterConfig const& _config )
+        :   CumulativeReporterBase( _config ),
+            xml( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+            m_reporterPrefs.shouldReportAllAssertions = true;
+        }
+
+    JunitReporter::~JunitReporter() {}
+
+    std::string JunitReporter::getDescription() {
+        return "Reports test results in an XML format that looks like Ant's junitreport target";
+    }
+
+    void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
+
+    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
+        CumulativeReporterBase::testRunStarting( runInfo );
+        xml.startElement( "testsuites" );
+    }
+
+    void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        suiteTimer.start();
+        stdOutForSuite.clear();
+        stdErrForSuite.clear();
+        unexpectedExceptions = 0;
+        CumulativeReporterBase::testGroupStarting( groupInfo );
+    }
+
+    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
+        m_okToFail = testCaseInfo.okToFail();
+    }
+
+    bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
+            unexpectedExceptions++;
+        return CumulativeReporterBase::assertionEnded( assertionStats );
+    }
+
+    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        stdOutForSuite += testCaseStats.stdOut;
+        stdErrForSuite += testCaseStats.stdErr;
+        CumulativeReporterBase::testCaseEnded( testCaseStats );
+    }
+
+    void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        double suiteTime = suiteTimer.getElapsedSeconds();
+        CumulativeReporterBase::testGroupEnded( testGroupStats );
+        writeGroup( *m_testGroups.back(), suiteTime );
+    }
+
+    void JunitReporter::testRunEndedCumulative() {
+        xml.endElement();
+    }
+
+    void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
+        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+
+        TestGroupStats const& stats = groupNode.value;
+        xml.writeAttribute( "name", stats.groupInfo.name );
+        xml.writeAttribute( "errors", unexpectedExceptions );
+        xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
+        xml.writeAttribute( "tests", stats.totals.assertions.total() );
+        xml.writeAttribute( "hostname", "tbd" ); // !TBD
+        if( m_config->showDurations() == ShowDurations::Never )
+            xml.writeAttribute( "time", "" );
+        else
+            xml.writeAttribute( "time", suiteTime );
+        xml.writeAttribute( "timestamp", getCurrentTimestamp() );
+
+        // Write properties if there are any
+        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
+            auto properties = xml.scopedElement("properties");
+            if (m_config->hasTestFilters()) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "filters")
+                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
+            }
+            if (m_config->rngSeed() != 0) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "random-seed")
+                    .writeAttribute("value", m_config->rngSeed());
+            }
+        }
+
+        // Write test cases
+        for( auto const& child : groupNode.children )
+            writeTestCase( *child );
+
+        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
+        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
+    }
+
+    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
+        TestCaseStats const& stats = testCaseNode.value;
+
+        // All test cases have exactly one section - which represents the
+        // test case itself. That section may have 0-n nested sections
+        assert( testCaseNode.children.size() == 1 );
+        SectionNode const& rootSection = *testCaseNode.children.front();
+
+        std::string className = stats.testInfo.className;
+
+        if( className.empty() ) {
+            className = fileNameTag(stats.testInfo.tags);
+            if ( className.empty() )
+                className = "global";
+        }
+
+        if ( !m_config->name().empty() )
+            className = m_config->name() + "." + className;
+
+        writeSection( className, "", rootSection );
+    }
+
+    void JunitReporter::writeSection(  std::string const& className,
+                        std::string const& rootName,
+                        SectionNode const& sectionNode ) {
+        std::string name = trim( sectionNode.stats.sectionInfo.name );
+        if( !rootName.empty() )
+            name = rootName + '/' + name;
+
+        if( !sectionNode.assertions.empty() ||
+            !sectionNode.stdOut.empty() ||
+            !sectionNode.stdErr.empty() ) {
+            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+            if( className.empty() ) {
+                xml.writeAttribute( "classname", name );
+                xml.writeAttribute( "name", "root" );
+            }
+            else {
+                xml.writeAttribute( "classname", className );
+                xml.writeAttribute( "name", name );
+            }
+            xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
+
+            writeAssertions( sectionNode );
+
+            if( !sectionNode.stdOut.empty() )
+                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
+            if( !sectionNode.stdErr.empty() )
+                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
+        }
+        for( auto const& childNode : sectionNode.childSections )
+            if( className.empty() )
+                writeSection( name, "", *childNode );
+            else
+                writeSection( className, name, *childNode );
+    }
+
+    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
+        for( auto const& assertion : sectionNode.assertions )
+            writeAssertion( assertion );
+    }
+
+    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
+        AssertionResult const& result = stats.assertionResult;
+        if( !result.isOk() ) {
+            std::string elementName;
+            switch( result.getResultType() ) {
+                case ResultWas::ThrewException:
+                case ResultWas::FatalErrorCondition:
+                    elementName = "error";
+                    break;
+                case ResultWas::ExplicitFailure:
+                case ResultWas::ExpressionFailed:
+                case ResultWas::DidntThrowException:
+                    elementName = "failure";
+                    break;
+
+                // We should never see these here:
+                case ResultWas::Info:
+                case ResultWas::Warning:
+                case ResultWas::Ok:
+                case ResultWas::Unknown:
+                case ResultWas::FailureBit:
+                case ResultWas::Exception:
+                    elementName = "internalError";
+                    break;
+            }
+
+            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+
+            xml.writeAttribute( "message", result.getExpression() );
+            xml.writeAttribute( "type", result.getTestMacroName() );
+
+            ReusableStringStream rss;
+            if (stats.totals.assertions.total() > 0) {
+                rss << "FAILED" << ":\n";
+                if (result.hasExpression()) {
+                    rss << "  ";
+                    rss << result.getExpressionInMacro();
+                    rss << '\n';
+                }
+                if (result.hasExpandedExpression()) {
+                    rss << "with expansion:\n";
+                    rss << Column(result.getExpandedExpression()).indent(2) << '\n';
+                }
+            } else {
+                rss << '\n';
+            }
+
+            if( !result.getMessage().empty() )
+                rss << result.getMessage() << '\n';
+            for( auto const& msg : stats.infoMessages )
+                if( msg.type == ResultWas::Info )
+                    rss << msg.message << '\n';
+
+            rss << "at " << result.getSourceInfo();
+            xml.writeText( rss.str(), XmlFormatting::Newline );
+        }
+    }
+
+    CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+
+} // end namespace Catch
+// end catch_reporter_junit.cpp
+// start catch_reporter_listening.cpp
+
+#include <cassert>
+
+namespace Catch {
+
+    ListeningReporter::ListeningReporter() {
+        // We will assume that listeners will always want all assertions
+        m_preferences.shouldReportAllAssertions = true;
+    }
+
+    void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
+        m_listeners.push_back( std::move( listener ) );
+    }
+
+    void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
+        assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
+        m_reporter = std::move( reporter );
+        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
+    }
+
+    ReporterPreferences ListeningReporter::getPreferences() const {
+        return m_preferences;
+    }
+
+    std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
+        return std::set<Verbosity>{ };
+    }
+
+    void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->noMatchingTestCases( spec );
+        }
+        m_reporter->noMatchingTestCases( spec );
+    }
+
+    void ListeningReporter::reportInvalidArguments(std::string const&arg){
+        for ( auto const& listener : m_listeners ) {
+            listener->reportInvalidArguments( arg );
+        }
+        m_reporter->reportInvalidArguments( arg );
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkPreparing(name);
+		}
+		m_reporter->benchmarkPreparing(name);
+	}
+    void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->benchmarkStarting( benchmarkInfo );
+        }
+        m_reporter->benchmarkStarting( benchmarkInfo );
+    }
+    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->benchmarkEnded( benchmarkStats );
+        }
+        m_reporter->benchmarkEnded( benchmarkStats );
+    }
+
+	void ListeningReporter::benchmarkFailed( std::string const& error ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkFailed(error);
+		}
+		m_reporter->benchmarkFailed(error);
+	}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testRunStarting( testRunInfo );
+        }
+        m_reporter->testRunStarting( testRunInfo );
+    }
+
+    void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testGroupStarting( groupInfo );
+        }
+        m_reporter->testGroupStarting( groupInfo );
+    }
+
+    void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testCaseStarting( testInfo );
+        }
+        m_reporter->testCaseStarting( testInfo );
+    }
+
+    void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->sectionStarting( sectionInfo );
+        }
+        m_reporter->sectionStarting( sectionInfo );
+    }
+
+    void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->assertionStarting( assertionInfo );
+        }
+        m_reporter->assertionStarting( assertionInfo );
+    }
+
+    // The return value indicates if the messages buffer should be cleared:
+    bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        for( auto const& listener : m_listeners ) {
+            static_cast<void>( listener->assertionEnded( assertionStats ) );
+        }
+        return m_reporter->assertionEnded( assertionStats );
+    }
+
+    void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->sectionEnded( sectionStats );
+        }
+        m_reporter->sectionEnded( sectionStats );
+    }
+
+    void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testCaseEnded( testCaseStats );
+        }
+        m_reporter->testCaseEnded( testCaseStats );
+    }
+
+    void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testGroupEnded( testGroupStats );
+        }
+        m_reporter->testGroupEnded( testGroupStats );
+    }
+
+    void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testRunEnded( testRunStats );
+        }
+        m_reporter->testRunEnded( testRunStats );
+    }
+
+    void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->skipTest( testInfo );
+        }
+        m_reporter->skipTest( testInfo );
+    }
+
+    bool ListeningReporter::isMulti() const {
+        return true;
+    }
+
+} // end namespace Catch
+// end catch_reporter_listening.cpp
+// start catch_reporter_xml.cpp
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
+
+namespace Catch {
+    XmlReporter::XmlReporter( ReporterConfig const& _config )
+    :   StreamingReporterBase( _config ),
+        m_xml(_config.stream())
+    {
+        m_reporterPrefs.shouldRedirectStdOut = true;
+        m_reporterPrefs.shouldReportAllAssertions = true;
+    }
+
+    XmlReporter::~XmlReporter() = default;
+
+    std::string XmlReporter::getDescription() {
+        return "Reports test results as an XML document";
+    }
+
+    std::string XmlReporter::getStylesheetRef() const {
+        return std::string();
+    }
+
+    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
+        m_xml
+            .writeAttribute( "filename", sourceInfo.file )
+            .writeAttribute( "line", sourceInfo.line );
+    }
+
+    void XmlReporter::noMatchingTestCases( std::string const& s ) {
+        StreamingReporterBase::noMatchingTestCases( s );
+    }
+
+    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
+        StreamingReporterBase::testRunStarting( testInfo );
+        std::string stylesheetRef = getStylesheetRef();
+        if( !stylesheetRef.empty() )
+            m_xml.writeStylesheetRef( stylesheetRef );
+        m_xml.startElement( "Catch" );
+        if( !m_config->name().empty() )
+            m_xml.writeAttribute( "name", m_config->name() );
+        if (m_config->testSpec().hasFilters())
+            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
+        if( m_config->rngSeed() != 0 )
+            m_xml.scopedElement( "Randomness" )
+                .writeAttribute( "seed", m_config->rngSeed() );
+    }
+
+    void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        StreamingReporterBase::testGroupStarting( groupInfo );
+        m_xml.startElement( "Group" )
+            .writeAttribute( "name", groupInfo.name );
+    }
+
+    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        StreamingReporterBase::testCaseStarting(testInfo);
+        m_xml.startElement( "TestCase" )
+            .writeAttribute( "name", trim( testInfo.name ) )
+            .writeAttribute( "description", testInfo.description )
+            .writeAttribute( "tags", testInfo.tagsAsString() );
+
+        writeSourceInfo( testInfo.lineInfo );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            m_testCaseTimer.start();
+        m_xml.ensureTagClosed();
+    }
+
+    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        StreamingReporterBase::sectionStarting( sectionInfo );
+        if( m_sectionDepth++ > 0 ) {
+            m_xml.startElement( "Section" )
+                .writeAttribute( "name", trim( sectionInfo.name ) );
+            writeSourceInfo( sectionInfo.lineInfo );
+            m_xml.ensureTagClosed();
+        }
+    }
+
+    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
+
+    bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
+
+        AssertionResult const& result = assertionStats.assertionResult;
+
+        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+        if( includeResults || result.getResultType() == ResultWas::Warning ) {
+            // Print any info messages in <Info> tags.
+            for( auto const& msg : assertionStats.infoMessages ) {
+                if( msg.type == ResultWas::Info && includeResults ) {
+                    m_xml.scopedElement( "Info" )
+                            .writeText( msg.message );
+                } else if ( msg.type == ResultWas::Warning ) {
+                    m_xml.scopedElement( "Warning" )
+                            .writeText( msg.message );
+                }
+            }
+        }
+
+        // Drop out if result was successful but we're not printing them.
+        if( !includeResults && result.getResultType() != ResultWas::Warning )
+            return true;
+
+        // Print the expression if there is one.
+        if( result.hasExpression() ) {
+            m_xml.startElement( "Expression" )
+                .writeAttribute( "success", result.succeeded() )
+                .writeAttribute( "type", result.getTestMacroName() );
+
+            writeSourceInfo( result.getSourceInfo() );
+
+            m_xml.scopedElement( "Original" )
+                .writeText( result.getExpression() );
+            m_xml.scopedElement( "Expanded" )
+                .writeText( result.getExpandedExpression() );
+        }
+
+        // And... Print a result applicable to each result type.
+        switch( result.getResultType() ) {
+            case ResultWas::ThrewException:
+                m_xml.startElement( "Exception" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::FatalErrorCondition:
+                m_xml.startElement( "FatalErrorCondition" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::Info:
+                m_xml.scopedElement( "Info" )
+                    .writeText( result.getMessage() );
+                break;
+            case ResultWas::Warning:
+                // Warning will already have been written
+                break;
+            case ResultWas::ExplicitFailure:
+                m_xml.startElement( "Failure" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            default:
+                break;
+        }
+
+        if( result.hasExpression() )
+            m_xml.endElement();
+
+        return true;
+    }
+
+    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
+        StreamingReporterBase::sectionEnded( sectionStats );
+        if( --m_sectionDepth > 0 ) {
+            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+            e.writeAttribute( "successes", sectionStats.assertions.passed );
+            e.writeAttribute( "failures", sectionStats.assertions.failed );
+            e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
+
+            m_xml.endElement();
+        }
+    }
+
+    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        StreamingReporterBase::testCaseEnded( testCaseStats );
+        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+        e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
+
+        if( !testCaseStats.stdOut.empty() )
+            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
+        if( !testCaseStats.stdErr.empty() )
+            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
+
+        m_xml.endElement();
+    }
+
+    void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        StreamingReporterBase::testGroupEnded( testGroupStats );
+        // TODO: Check testGroupStats.aborting and act accordingly.
+        m_xml.scopedElement( "OverallResults" )
+            .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
+            .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
+            .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
+        m_xml.endElement();
+    }
+
+    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        StreamingReporterBase::testRunEnded( testRunStats );
+        m_xml.scopedElement( "OverallResults" )
+            .writeAttribute( "successes", testRunStats.totals.assertions.passed )
+            .writeAttribute( "failures", testRunStats.totals.assertions.failed )
+            .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
+        m_xml.endElement();
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void XmlReporter::benchmarkPreparing(std::string const& name) {
+        m_xml.startElement("BenchmarkResults")
+            .writeAttribute("name", name);
+    }
+
+    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
+        m_xml.writeAttribute("samples", info.samples)
+            .writeAttribute("resamples", info.resamples)
+            .writeAttribute("iterations", info.iterations)
+            .writeAttribute("clockResolution", info.clockResolution)
+            .writeAttribute("estimatedDuration", info.estimatedDuration)
+            .writeComment("All values in nano seconds");
+    }
+
+    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+        m_xml.startElement("mean")
+            .writeAttribute("value", benchmarkStats.mean.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.mean.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.mean.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("standardDeviation")
+            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("outliers")
+            .writeAttribute("variance", benchmarkStats.outlierVariance)
+            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
+            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
+            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
+            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
+        m_xml.endElement();
+        m_xml.endElement();
+    }
+
+    void XmlReporter::benchmarkFailed(std::string const &error) {
+        m_xml.scopedElement("failed").
+            writeAttribute("message", error);
+        m_xml.endElement();
+    }
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    CATCH_REGISTER_REPORTER( "xml", XmlReporter )
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+// end catch_reporter_xml.cpp
+
+namespace Catch {
+    LeakDetector leakDetector;
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_impl.hpp
+#endif
+
+#ifdef CATCH_CONFIG_MAIN
+// start catch_default_main.hpp
+
+#ifndef __OBJC__
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+// Standard C/C++ Win32 Unicode wmain entry point
+extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
+#else
+// Standard C/C++ main entry point
+int main (int argc, char * argv[]) {
+#endif
+
+    return Catch::Session().run( argc, argv );
+}
+
+#else // __OBJC__
+
+// Objective-C entry point
+int main (int argc, char * const argv[]) {
+#if !CATCH_ARC_ENABLED
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+#endif
+
+    Catch::registerTestMethods();
+    int result = Catch::Session().run( argc, (char**)argv );
+
+#if !CATCH_ARC_ENABLED
+    [pool drain];
+#endif
+
+    return result;
+}
+
+#endif // __OBJC__
+
+// end catch_default_main.hpp
+#endif
+
+#if !defined(CATCH_CONFIG_IMPL_ONLY)
+
+#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
+#  undef CLARA_CONFIG_MAIN
+#endif
+
+#if !defined(CATCH_CONFIG_DISABLE)
+//////
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+#endif// CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
+#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
+
+#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#endif
+
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+#else
+#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
+#endif
+
+// "BDD-style" convenience wrappers
+#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define CATCH_BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define CATCH_BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
+#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
+#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
+
+#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#endif
+
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+#else
+#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
+#endif
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+
+// "BDD-style" convenience wrappers
+#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+
+#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+using Catch::Detail::Approx;
+
+#else // CATCH_CONFIG_DISABLE
+
+//////
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#define CATCH_REQUIRE( ... )        (void)(0)
+#define CATCH_REQUIRE_FALSE( ... )  (void)(0)
+
+#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher )     (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif// CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
+
+#define CATCH_CHECK( ... )         (void)(0)
+#define CATCH_CHECK_FALSE( ... )   (void)(0)
+#define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
+#define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
+#define CATCH_CHECK_NOFAIL( ... )  (void)(0)
+
+#define CATCH_CHECK_THROWS( ... )  (void)(0)
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CATCH_CHECK_THROWS_WITH( expr, matcher )     (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
+
+#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define CATCH_INFO( msg )          (void)(0)
+#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
+#define CATCH_WARN( msg )          (void)(0)
+#define CATCH_CAPTURE( msg )       (void)(0)
+
+#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_METHOD_AS_TEST_CASE( method, ... )
+#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
+#define CATCH_SECTION( ... )
+#define CATCH_DYNAMIC_SECTION( ... )
+#define CATCH_FAIL( ... ) (void)(0)
+#define CATCH_FAIL_CHECK( ... ) (void)(0)
+#define CATCH_SUCCEED( ... ) (void)(0)
+
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#endif
+
+// "BDD-style" convenience wrappers
+#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
+#define CATCH_GIVEN( desc )
+#define CATCH_AND_GIVEN( desc )
+#define CATCH_WHEN( desc )
+#define CATCH_AND_WHEN( desc )
+#define CATCH_THEN( desc )
+#define CATCH_AND_THEN( desc )
+
+#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE( ... )       (void)(0)
+#define REQUIRE_FALSE( ... ) (void)(0)
+
+#define REQUIRE_THROWS( ... ) (void)(0)
+#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define REQUIRE_NOTHROW( ... ) (void)(0)
+
+#define CHECK( ... ) (void)(0)
+#define CHECK_FALSE( ... ) (void)(0)
+#define CHECKED_IF( ... ) if (__VA_ARGS__)
+#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
+#define CHECK_NOFAIL( ... ) (void)(0)
+
+#define CHECK_THROWS( ... )  (void)(0)
+#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CHECK_NOTHROW( ... ) (void)(0)
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THAT( arg, matcher ) (void)(0)
+
+#define REQUIRE_THAT( arg, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define INFO( msg ) (void)(0)
+#define UNSCOPED_INFO( msg ) (void)(0)
+#define WARN( msg ) (void)(0)
+#define CAPTURE( msg ) (void)(0)
+
+#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define METHOD_AS_TEST_CASE( method, ... )
+#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
+#define SECTION( ... )
+#define DYNAMIC_SECTION( ... )
+#define FAIL( ... ) (void)(0)
+#define FAIL_CHECK( ... ) (void)(0)
+#define SUCCEED( ... ) (void)(0)
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#endif
+
+#define STATIC_REQUIRE( ... )       (void)(0)
+#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+// "BDD-style" convenience wrappers
+#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
+
+#define GIVEN( desc )
+#define AND_GIVEN( desc )
+#define WHEN( desc )
+#define AND_WHEN( desc )
+#define THEN( desc )
+#define AND_THEN( desc )
+
+using Catch::Detail::Approx;
+
+#endif
+
+#endif // ! CATCH_CONFIG_IMPL_ONLY
+
+// start catch_reenable_warnings.h
+
+
+#ifdef __clang__
+#    ifdef __ICC // icpc defines the __clang__ macro
+#        pragma warning(pop)
+#    else
+#        pragma clang diagnostic pop
+#    endif
+#elif defined __GNUC__
+#    pragma GCC diagnostic pop
+#endif
+
+// end catch_reenable_warnings.h
+// end catch.hpp
+#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
diff --git a/test/catch2/catch_reporter_automake.hpp b/test/catch2/catch_reporter_automake.hpp
new file mode 100644
index 000000000..dbebe9751
--- /dev/null
+++ b/test/catch2/catch_reporter_automake.hpp
@@ -0,0 +1,62 @@
+/*
+ *  Created by Justin R. Wilson on 2/19/2017.
+ *  Copyright 2017 Justin R. Wilson. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+namespace Catch {
+
+    struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
+        AutomakeReporter( ReporterConfig const& _config )
+          :   StreamingReporterBase( _config )
+        {}
+
+        ~AutomakeReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in the format of Automake .trs files";
+        }
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
+
+        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
+            // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
+            stream << ":test-result: ";
+            if (_testCaseStats.totals.assertions.allPassed()) {
+                stream << "PASS";
+            } else if (_testCaseStats.totals.assertions.allOk()) {
+                stream << "XFAIL";
+            } else {
+                stream << "FAIL";
+            }
+            stream << ' ' << _testCaseStats.testInfo.name << '\n';
+            StreamingReporterBase::testCaseEnded( _testCaseStats );
+        }
+
+        void skipTest( TestCaseInfo const& testInfo ) override {
+            stream << ":test-result: SKIP " << testInfo.name << '\n';
+        }
+
+    };
+
+#ifdef CATCH_IMPL
+    AutomakeReporter::~AutomakeReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
diff --git a/test/catch2/catch_reporter_sonarqube.hpp b/test/catch2/catch_reporter_sonarqube.hpp
new file mode 100644
index 000000000..bf7d9299a
--- /dev/null
+++ b/test/catch2/catch_reporter_sonarqube.hpp
@@ -0,0 +1,181 @@
+/*
+ *  Created by Daniel Garcia on 2018-12-04.
+ *  Copyright Social Point SL. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <map>
+
+namespace Catch {
+
+    struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
+
+        SonarQubeReporter(ReporterConfig const& config)
+        : CumulativeReporterBase(config)
+        , xml(config.stream()) {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+            m_reporterPrefs.shouldReportAllAssertions = true;
+        }
+
+        ~SonarQubeReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in the Generic Test Data SonarQube XML format";
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void noMatchingTestCases(std::string const& /*spec*/) override {}
+
+        void testRunStarting(TestRunInfo const& testRunInfo) override {
+            CumulativeReporterBase::testRunStarting(testRunInfo);
+            xml.startElement("testExecutions");
+            xml.writeAttribute("version", "1");
+        }
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            CumulativeReporterBase::testGroupEnded(testGroupStats);
+            writeGroup(*m_testGroups.back());
+        }
+
+        void testRunEndedCumulative() override {
+            xml.endElement();
+        }
+
+        void writeGroup(TestGroupNode const& groupNode) {
+            std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
+            for(auto const& child : groupNode.children)
+                testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
+
+            for(auto const& kv : testsPerFile)
+                writeTestFile(kv.first.c_str(), kv.second);
+        }
+
+        void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
+            XmlWriter::ScopedElement e = xml.scopedElement("file");
+            xml.writeAttribute("path", filename);
+
+            for(auto const& child : testCaseNodes)
+                writeTestCase(*child);
+        }
+
+        void writeTestCase(TestCaseNode const& testCaseNode) {
+            // All test cases have exactly one section - which represents the
+            // test case itself. That section may have 0-n nested sections
+            assert(testCaseNode.children.size() == 1);
+            SectionNode const& rootSection = *testCaseNode.children.front();
+            writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
+        }
+
+        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
+            std::string name = trim(sectionNode.stats.sectionInfo.name);
+            if(!rootName.empty())
+                name = rootName + '/' + name;
+
+            if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
+                XmlWriter::ScopedElement e = xml.scopedElement("testCase");
+                xml.writeAttribute("name", name);
+                xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
+
+                writeAssertions(sectionNode, okToFail);
+            }
+
+            for(auto const& childNode : sectionNode.childSections)
+                writeSection(name, *childNode, okToFail);
+        }
+
+        void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
+            for(auto const& assertion : sectionNode.assertions)
+                writeAssertion( assertion, okToFail);
+        }
+
+        void writeAssertion(AssertionStats const& stats, bool okToFail) {
+            AssertionResult const& result = stats.assertionResult;
+            if(!result.isOk()) {
+                std::string elementName;
+                if(okToFail) {
+                    elementName = "skipped";
+                }
+                else {
+                    switch(result.getResultType()) {
+                        case ResultWas::ThrewException:
+                        case ResultWas::FatalErrorCondition:
+                            elementName = "error";
+                            break;
+                        case ResultWas::ExplicitFailure:
+                            elementName = "failure";
+                            break;
+                        case ResultWas::ExpressionFailed:
+                            elementName = "failure";
+                            break;
+                        case ResultWas::DidntThrowException:
+                            elementName = "failure";
+                            break;
+
+                            // We should never see these here:
+                        case ResultWas::Info:
+                        case ResultWas::Warning:
+                        case ResultWas::Ok:
+                        case ResultWas::Unknown:
+                        case ResultWas::FailureBit:
+                        case ResultWas::Exception:
+                            elementName = "internalError";
+                            break;
+                    }
+                }
+
+                XmlWriter::ScopedElement e = xml.scopedElement(elementName);
+
+                ReusableStringStream messageRss;
+                messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
+                xml.writeAttribute("message", messageRss.str());
+
+                ReusableStringStream textRss;
+                if (stats.totals.assertions.total() > 0) {
+                    textRss << "FAILED:\n";
+                    if (result.hasExpression()) {
+                        textRss << "\t" << result.getExpressionInMacro() << "\n";
+                    }
+                    if (result.hasExpandedExpression()) {
+                        textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
+                    }
+                }
+
+                if(!result.getMessage().empty())
+                    textRss << result.getMessage() << "\n";
+
+                for(auto const& msg : stats.infoMessages)
+                    if(msg.type == ResultWas::Info)
+                        textRss << msg.message << "\n";
+
+                textRss << "at " << result.getSourceInfo();
+                xml.writeText(textRss.str(), XmlFormatting::Newline);
+            }
+        }
+
+    private:
+        XmlWriter xml;
+    };
+
+#ifdef CATCH_IMPL
+    SonarQubeReporter::~SonarQubeReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
\ No newline at end of file
diff --git a/test/catch2/catch_reporter_tap.hpp b/test/catch2/catch_reporter_tap.hpp
new file mode 100644
index 000000000..1bfe4f5e1
--- /dev/null
+++ b/test/catch2/catch_reporter_tap.hpp
@@ -0,0 +1,253 @@
+/*
+ *  Created by Colton Wolkins on 2015-08-15.
+ *  Copyright 2015 Martin Moene. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
+
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <algorithm>
+
+namespace Catch {
+
+    struct TAPReporter : StreamingReporterBase<TAPReporter> {
+
+        using StreamingReporterBase::StreamingReporterBase;
+
+        ~TAPReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in TAP format, suitable for test harnesses";
+        }
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        void noMatchingTestCases( std::string const& spec ) override {
+            stream << "# No test cases matched '" << spec << "'" << std::endl;
+        }
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& _assertionStats ) override {
+            ++counter;
+
+            stream << "# " << currentTestCaseInfo->name << std::endl;
+            AssertionPrinter printer( stream, _assertionStats, counter );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        void testRunEnded( TestRunStats const& _testRunStats ) override {
+            printTotals( _testRunStats.totals );
+            stream << "\n" << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+        std::size_t counter = 0;
+        class AssertionPrinter {
+        public:
+            AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
+            AssertionPrinter( AssertionPrinter const& ) = delete;
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
+            : stream( _stream )
+            , result( _stats.assertionResult )
+            , messages( _stats.infoMessages )
+            , itMessage( _stats.infoMessages.begin() )
+            , printInfoMessages( true )
+            , counter(_counter)
+            {}
+
+            void print() {
+                itMessage = messages.begin();
+
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        printResultType( passedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if ( ! result.hasExpression() )
+                            printRemainingMessages( Colour::None );
+                        else
+                            printRemainingMessages();
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if (result.isOk()) {
+                            printResultType(passedString());
+                        } else {
+                            printResultType(failedString());
+                        }
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if (result.isOk()) {
+                            printIssue(" # TODO");
+                        }
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ThrewException:
+                        printResultType( failedString() );
+                        printIssue( "unexpected exception with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        printResultType( failedString() );
+                        printIssue( "fatal error condition with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::DidntThrowException:
+                        printResultType( failedString() );
+                        printIssue( "expected exception, got none" );
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Info:
+                        printResultType( "info" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Warning:
+                        printResultType( "warning" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        printResultType( failedString() );
+                        printIssue( "explicitly" );
+                        printRemainingMessages( Colour::None );
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        printResultType( "** internal error **" );
+                        break;
+                }
+            }
+
+        private:
+            static Colour::Code dimColour() { return Colour::FileName; }
+
+            static const char* failedString() { return "not ok"; }
+            static const char* passedString() { return "ok"; }
+
+            void printSourceInfo() const {
+                Colour colourGuard( dimColour() );
+                stream << result.getSourceInfo() << ":";
+            }
+
+            void printResultType( std::string const& passOrFail ) const {
+                if( !passOrFail.empty() ) {
+                    stream << passOrFail << ' ' << counter << " -";
+                }
+            }
+
+            void printIssue( std::string const& issue ) const {
+                stream << " " << issue;
+            }
+
+            void printExpressionWas() {
+                if( result.hasExpression() ) {
+                    stream << ";";
+                    {
+                        Colour colour( dimColour() );
+                        stream << " expression was:";
+                    }
+                    printOriginalExpression();
+                }
+            }
+
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    stream << " " << result.getExpression();
+                }
+            }
+
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    {
+                        Colour colour( dimColour() );
+                        stream << " for: ";
+                    }
+                    std::string expr = result.getExpandedExpression();
+                    std::replace( expr.begin(), expr.end(), '\n', ' ');
+                    stream << expr;
+                }
+            }
+
+            void printMessage() {
+                if ( itMessage != messages.end() ) {
+                    stream << " '" << itMessage->message << "'";
+                    ++itMessage;
+                }
+            }
+
+            void printRemainingMessages( Colour::Code colour = dimColour() ) {
+                if (itMessage == messages.end()) {
+                    return;
+                }
+
+                // using messages.end() directly (or auto) yields compilation error:
+                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
+
+                {
+                    Colour colourGuard( colour );
+                    stream << " with " << pluralise( N, "message" ) << ":";
+                }
+
+                for(; itMessage != itEnd; ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
+                        stream << " '" << itMessage->message << "'";
+                        if ( ++itMessage != itEnd ) {
+                            Colour colourGuard( dimColour() );
+                            stream << " and";
+                        }
+                    }
+                }
+            }
+
+        private:
+            std::ostream& stream;
+            AssertionResult const& result;
+            std::vector<MessageInfo> messages;
+            std::vector<MessageInfo>::const_iterator itMessage;
+            bool printInfoMessages;
+            std::size_t counter;
+        };
+
+        void printTotals( const Totals& totals ) const {
+            if( totals.testCases.total() == 0 ) {
+                stream << "1..0 # Skipped: No tests ran.";
+            } else {
+                stream << "1.." << counter;
+            }
+        }
+    };
+
+#ifdef CATCH_IMPL
+    TAPReporter::~TAPReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "tap", TAPReporter )
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
diff --git a/test/catch2/catch_reporter_teamcity.hpp b/test/catch2/catch_reporter_teamcity.hpp
new file mode 100644
index 000000000..47b7e4aac
--- /dev/null
+++ b/test/catch2/catch_reporter_teamcity.hpp
@@ -0,0 +1,219 @@
+/*
+ *  Created by Phil Nash on 19th December 2014
+ *  Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <cstring>
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
+        TeamCityReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+        }
+
+        static std::string escape( std::string const& str ) {
+            std::string escaped = str;
+            replaceInPlace( escaped, "|", "||" );
+            replaceInPlace( escaped, "'", "|'" );
+            replaceInPlace( escaped, "\n", "|n" );
+            replaceInPlace( escaped, "\r", "|r" );
+            replaceInPlace( escaped, "[", "|[" );
+            replaceInPlace( escaped, "]", "|]" );
+            return escaped;
+        }
+        ~TeamCityReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results as TeamCity service messages";
+        }
+
+        void skipTest( TestCaseInfo const& /* testInfo */ ) override {
+        }
+
+        void noMatchingTestCases( std::string const& /* spec */ ) override {}
+
+        void testGroupStarting( GroupInfo const& groupInfo ) override {
+            StreamingReporterBase::testGroupStarting( groupInfo );
+            stream << "##teamcity[testSuiteStarted name='"
+                << escape( groupInfo.name ) << "']\n";
+        }
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
+            StreamingReporterBase::testGroupEnded( testGroupStats );
+            stream << "##teamcity[testSuiteFinished name='"
+                << escape( testGroupStats.groupInfo.name ) << "']\n";
+        }
+
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& assertionStats ) override {
+            AssertionResult const& result = assertionStats.assertionResult;
+            if( !result.isOk() ) {
+
+                ReusableStringStream msg;
+                if( !m_headerPrintedForThisSection )
+                    printSectionHeader( msg.get() );
+                m_headerPrintedForThisSection = true;
+
+                msg << result.getSourceInfo() << "\n";
+
+                switch( result.getResultType() ) {
+                    case ResultWas::ExpressionFailed:
+                        msg << "expression failed";
+                        break;
+                    case ResultWas::ThrewException:
+                        msg << "unexpected exception";
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        msg << "fatal error condition";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        msg << "no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        msg << "explicit failure";
+                        break;
+
+                    // We shouldn't get here because of the isOk() test
+                    case ResultWas::Ok:
+                    case ResultWas::Info:
+                    case ResultWas::Warning:
+                        CATCH_ERROR( "Internal error in TeamCity reporter" );
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        CATCH_ERROR( "Not implemented" );
+                }
+                if( assertionStats.infoMessages.size() == 1 )
+                    msg << " with message:";
+                if( assertionStats.infoMessages.size() > 1 )
+                    msg << " with messages:";
+                for( auto const& messageInfo : assertionStats.infoMessages )
+                    msg << "\n  \"" << messageInfo.message << "\"";
+
+
+                if( result.hasExpression() ) {
+                    msg <<
+                        "\n  " << result.getExpressionInMacro() << "\n"
+                        "with expansion:\n" <<
+                        "  " << result.getExpandedExpression() << "\n";
+                }
+
+                if( currentTestCaseInfo->okToFail() ) {
+                    msg << "- failure ignore as test marked as 'ok to fail'\n";
+                    stream << "##teamcity[testIgnored"
+                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
+                           << " message='" << escape( msg.str() ) << "'"
+                           << "]\n";
+                }
+                else {
+                    stream << "##teamcity[testFailed"
+                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
+                           << " message='" << escape( msg.str() ) << "'"
+                           << "]\n";
+                }
+            }
+            stream.flush();
+            return true;
+        }
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
+            m_headerPrintedForThisSection = false;
+            StreamingReporterBase::sectionStarting( sectionInfo );
+        }
+
+        void testCaseStarting( TestCaseInfo const& testInfo ) override {
+            m_testTimer.start();
+            StreamingReporterBase::testCaseStarting( testInfo );
+            stream << "##teamcity[testStarted name='"
+                << escape( testInfo.name ) << "']\n";
+            stream.flush();
+        }
+
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
+            StreamingReporterBase::testCaseEnded( testCaseStats );
+            if( !testCaseStats.stdOut.empty() )
+                stream << "##teamcity[testStdOut name='"
+                    << escape( testCaseStats.testInfo.name )
+                    << "' out='" << escape( testCaseStats.stdOut ) << "']\n";
+            if( !testCaseStats.stdErr.empty() )
+                stream << "##teamcity[testStdErr name='"
+                    << escape( testCaseStats.testInfo.name )
+                    << "' out='" << escape( testCaseStats.stdErr ) << "']\n";
+            stream << "##teamcity[testFinished name='"
+                    << escape( testCaseStats.testInfo.name ) << "' duration='"
+                    << m_testTimer.getElapsedMilliseconds() << "']\n";
+            stream.flush();
+        }
+
+    private:
+        void printSectionHeader( std::ostream& os ) {
+            assert( !m_sectionStack.empty() );
+
+            if( m_sectionStack.size() > 1 ) {
+                os << getLineOfChars<'-'>() << "\n";
+
+                std::vector<SectionInfo>::const_iterator
+                it = m_sectionStack.begin()+1, // Skip first section (test case)
+                itEnd = m_sectionStack.end();
+                for( ; it != itEnd; ++it )
+                    printHeaderString( os, it->name );
+                os << getLineOfChars<'-'>() << "\n";
+            }
+
+            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+            os << lineInfo << "\n";
+            os << getLineOfChars<'.'>() << "\n\n";
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        static void printHeaderString( std::ostream& os, std::string const& _string, std::size_t indent = 0 ) {
+            std::size_t i = _string.find( ": " );
+            if( i != std::string::npos )
+                i+=2;
+            else
+                i = 0;
+            os << Column( _string )
+                           .indent( indent+i)
+                           .initialIndent( indent ) << "\n";
+        }
+    private:
+        bool m_headerPrintedForThisSection = false;
+        Timer m_testTimer;
+    };
+
+#ifdef CATCH_IMPL
+    TeamCityReporter::~TeamCityReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
+
+} // end namespace Catch
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED

From 906f941f32bc949edf899e5e8b9ededf45797793 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 15 Apr 2020 15:53:46 +0200
Subject: [PATCH 0174/1774] ssize_t in deSerialize replaced by size_t

---
 container/FixedMap.h                         |  2 +-
 datapool/DataPoolParameterWrapper.cpp        |  2 +-
 datapool/DataPoolParameterWrapper.h          |  2 +-
 datapool/DataSet.cpp                         |  2 +-
 datapool/DataSet.h                           |  2 +-
 datapool/PIDReader.h                         |  2 +-
 datapool/PoolRawAccess.cpp                   | 14 ++---
 datapool/PoolRawAccess.h                     |  2 +-
 datapool/PoolRawAccessHelper.cpp             | 54 ++++++++++++--------
 datapool/PoolRawAccessHelper.h               | 12 +++--
 datapool/PoolVariable.h                      |  2 +-
 datapool/PoolVector.h                        |  2 +-
 devicehandlers/DeviceTmReportingWrapper.cpp  |  2 +-
 devicehandlers/DeviceTmReportingWrapper.h    |  2 +-
 events/eventmatching/EventRangeMatcherBase.h |  2 +-
 globalfunctions/Type.cpp                     |  2 +-
 globalfunctions/Type.h                       |  2 +-
 globalfunctions/matching/MatchTree.h         |  2 +-
 globalfunctions/matching/RangeMatcher.h      | 20 +++++---
 parameters/ParameterWrapper.cpp              | 20 ++++----
 parameters/ParameterWrapper.h                |  8 +--
 power/Fuse.cpp                               |  2 +-
 power/Fuse.h                                 |  2 +-
 power/PowerComponent.cpp                     |  2 +-
 power/PowerComponent.h                       |  2 +-
 serialize/SerialArrayListAdapter.h           |  7 ++-
 serialize/SerialBufferAdapter.cpp            | 28 +++++-----
 serialize/SerialBufferAdapter.h              | 14 ++++-
 serialize/SerialFixedArrayListAdapter.h      | 20 +++++---
 serialize/SerialLinkedListAdapter.h          |  4 +-
 serialize/SerializeAdapter.h                 |  4 +-
 serialize/SerializeAdapterInternal.h         | 17 +++---
 serialize/SerializeElement.h                 |  2 +-
 serialize/SerializeIF.h                      |  2 +-
 storagemanager/StorageManagerIF.h            |  3 +-
 subsystem/Subsystem.cpp                      |  4 +-
 subsystem/modes/ModeDefinitions.h            |  2 +-
 test/UnitTestClass.cpp                       | 15 ++++--
 test/UnitTestClass.h                         |  3 +-
 thermal/ThermalComponent.cpp                 |  4 +-
 thermal/ThermalComponent.h                   |  2 +-
 tmstorage/TmStorePackets.h                   |  4 +-
 tmtcpacket/packetmatcher/ApidMatcher.h       |  5 +-
 tmtcpacket/packetmatcher/ServiceMatcher.h    |  5 +-
 tmtcpacket/packetmatcher/SubserviceMatcher.h |  5 +-
 tmtcpacket/pus/TcPacketBase.cpp              |  2 +-
 tmtcpacket/pus/TcPacketBase.h                |  2 +-
 47 files changed, 191 insertions(+), 129 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 7f3d28f7d..c0eb90b2a 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -201,7 +201,7 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size,
 				buffer, size, bigEndian);
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index 7139a0d89..11399fb6e 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapool/DataPoolParameterWrapper.cpp
@@ -80,7 +80,7 @@ size_t DataPoolParameterWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian) {
+		size_t* size, bool bigEndian) {
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/datapool/DataPoolParameterWrapper.h b/datapool/DataPoolParameterWrapper.h
index 45d3de537..99593310e 100644
--- a/datapool/DataPoolParameterWrapper.h
+++ b/datapool/DataPoolParameterWrapper.h
@@ -16,7 +16,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index eabb4b8c1..28cc45009 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -136,7 +136,7 @@ void DataSet::setValid(uint8_t valid) {
 	}
 }
 
-ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index 888d45e65..1e34e07c9 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -126,7 +126,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 private:
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index 26a9e2a80..7572cd2c8 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -136,7 +136,7 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
 	}
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index b5f94c8c5..a2f79343e 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -197,11 +197,11 @@ size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
 }
 
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
-	*size -= typeSize;
-	if (*size >= 0) {
-
+	// TODO: Needs to be tested!!!
+	if (*size >= typeSize) {
+		*size -= typeSize;
 		if (bigEndian) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
@@ -212,12 +212,14 @@ ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, ssize_t* size,
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 			memcpy(value, *buffer, typeSize);
 #endif
-		} else {
+		}
+		else {
 			memcpy(value, *buffer, typeSize);
 		}
 		*buffer += typeSize;
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
+	}
+	else {
 		return SerializeIF::STREAM_TOO_SHORT;
 	}
 }
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 955c640ba..b491d949a 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -127,7 +127,7 @@ public:
 
 	size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 protected:
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index cac6e5064..643c76099 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -25,7 +25,7 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 		const size_t max_size, bool bigEndian) {
 	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
 	ReturnValue_t result;
-	ssize_t remainingParametersSize = numberOfParameters * 4;
+	size_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
 		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
 				&remainingParametersSize, false);
@@ -44,7 +44,7 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		size_t * size, const size_t max_size, bool bigEndian) {
 	ReturnValue_t result;
 	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
-	ssize_t remainingParametersSize = numberOfParameters * 4;
+	size_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
 	uint8_t validityMask[validityMaskSize];
 	memset(validityMask,0, validityMaskSize);
@@ -67,49 +67,60 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
-		ssize_t * remainingParameters, bool withValidMask, uint8_t * validityMask) {
+ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
+		SerializationArgs argStruct, size_t * remainingParameters,
+		bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
 	// Deserialize current pool ID from pool ID buffer
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
 			&poolIdBuffer,remainingParameters,true);
 	if(result != RETURN_OK) {
-		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing pool IDs" << std::dec << std::endl;
+		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing "
+				"pool IDs" << std::dec << std::endl;
 		return result;
 	}
-	result = handlePoolEntrySerialization(currentPoolId, argStruct, withValidMask, validityMask);
+	result = handlePoolEntrySerialization(currentPoolId, argStruct,
+			withValidMask, validityMask);
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
-		bool withValidMask, uint8_t * validityMask) {
+ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
+		uint32_t currentPoolId,SerializationArgs argStruct, bool withValidMask,
+		uint8_t * validityMask) {
 	ReturnValue_t result = RETURN_FAILED;
 	uint8_t arrayPosition = 0;
 	uint8_t counter = 0;
 	bool poolEntrySerialized = false;
-	//debug << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
+	//debug << "Pool Raw Access Helper: Handling Pool ID: "
+	//      << std::hex <<  currentPoolId << std::endl;
 	while(not poolEntrySerialized) {
 
 		if(counter > DataSet::DATA_SET_MAX_SIZE) {
-			error << "Pool Raw Access Helper: Config error, max. number of possible data set variables exceeded" << std::endl;
+			error << "Pool Raw Access Helper: Config error, "
+					 "max. number of possible data set variables exceeded"
+				  << std::endl;
 			return result;
 		}
 		counter ++;
 
 		DataSet currentDataSet = DataSet();
 		//debug << "Current array position: " << (int)arrayPosition << std::endl;
-		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);
+		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,
+				&currentDataSet,PoolVariableIF::VAR_READ);
 
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
-			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset with returncode 0x"
+			debug << std::hex << "Pool Raw Access Helper: Error reading raw "
+					"dataset with returncode 0x"
 				  << result << std::dec << std::endl;
 			return result;
 		}
 
-		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized, &arrayPosition);
+		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized,
+				&arrayPosition);
 		if(result != RETURN_OK) {
-			error << "Pool Raw Access Helper: Configuration Error at pool ID " << std::hex << currentPoolId
+			error << "Pool Raw Access Helper: Configuration Error at pool ID "
+				  << std::hex << currentPoolId
 				  << ". Size till end smaller than 0" << std::dec << std::endl;
 			return result;
 		}
@@ -125,8 +136,9 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
 				argStruct.max_size, argStruct.bigEndian);
 		if (result != RETURN_OK) {
-			debug << "Pool Raw Access Helper: Error serializing pool data with ID 0x" << std::hex <<
-					currentPoolId << " into send buffer with return code " << result << std::dec << std::endl;
+			debug << "Pool Raw Access Helper: Error serializing pool data with "
+					 "ID 0x" << std::hex << currentPoolId << " into send buffer "
+					 "with return code " << result << std::dec << std::endl;
 			return result;
 		}
 
@@ -134,9 +146,10 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess * currentPoolRawAccess,
-		bool * isSerialized, uint8_t * arrayPosition) {
-	int8_t remainingSize = currentPoolRawAccess->getSizeTillEnd() - currentPoolRawAccess->getSizeOfType();
+ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess*
+		currentPoolRawAccess, bool * isSerialized, uint8_t * arrayPosition) {
+	int8_t remainingSize = currentPoolRawAccess->getSizeTillEnd() -
+			currentPoolRawAccess->getSizeOfType();
 	if(remainingSize == 0) {
 		*isSerialized = true;
 	}
@@ -158,7 +171,8 @@ void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
 	}
 }
 
-uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position, bool value) {
+uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position,
+		bool value) {
 	if(position < 1 or position > 8) {
 		debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
 		return byte;
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 7d9b9b487..61d79731a 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -80,13 +80,15 @@ private:
 	 * @param hkDataSize
 	 * @param max_size
 	 * @param bigEndian
-	 * @param withValidMask Can be set optionally to set a provided validity mask
-	 * @param validityMask Can be supplied and will be set if @c withValidMask is set to true
+	 * @param withValidMask Can be set optionally to set a
+	 *        provided validity mask
+	 * @param validityMask Can be supplied and will be set if
+	 *  	  @c withValidMask is set to true
 	 * @return
 	 */
-	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
-				ssize_t * remainingParameters, bool withValidMask = false,
-				uint8_t * validityMask = nullptr);
+	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(
+			SerializationArgs argStruct, size_t * remainingParameters,
+			bool withValidMask = false, uint8_t * validityMask = nullptr);
 
 	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,
 			SerializationArgs argStruct, bool withValidMask = false,
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index d32cdf22a..e85e3b159 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -203,7 +203,7 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
 	}
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
index 3e82a721a..3e5482111 100644
--- a/datapool/PoolVector.h
+++ b/datapool/PoolVector.h
@@ -215,7 +215,7 @@ public:
 		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		uint16_t i;
 		ReturnValue_t result;
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 4987c7fb5..adddf4f3f 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -31,7 +31,7 @@ size_t DeviceTmReportingWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian) {
+		size_t* size, bool bigEndian) {
 	ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
 			buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index fce748147..e2fa43164 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -16,7 +16,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 private:
 	object_id_t objectId;
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index 8dea3e101..328a6b690 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -18,7 +18,7 @@ public:
 	size_t getSerializedSize() const {
 		return rangeMatcher.getSerializedSize();
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return rangeMatcher.deSerialize(buffer, size, bigEndian);
 	}
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index ea2ad896f..11269dc23 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -85,7 +85,7 @@ size_t Type::getSerializedSize() const {
 	return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
 }
 
-ReturnValue_t Type::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
 	uint8_t ptc;
 	uint8_t pfc;
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 244091f71..f4146f4ea 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -44,7 +44,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 private:
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 498fe8603..5a897f407 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -115,7 +115,7 @@ public:
 		return size;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index c09802554..3342cc276 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -29,32 +29,38 @@ public:
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound, buffer, size, max_size, bigEndian);
+		ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound,
+				buffer, size, max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::serialize(&upperBound, buffer, size, max_size, bigEndian);
+		result = SerializeAdapter<T>::serialize(&upperBound, buffer, size,
+				max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::serialize(&inverted, buffer, size, max_size, bigEndian);
+		return SerializeAdapter<bool>::serialize(&inverted, buffer, size,
+				max_size, bigEndian);
 	}
 
 	size_t getSerializedSize() const {
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
-		ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound, buffer, size, bigEndian);
+		ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound,
+				buffer, size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::deSerialize(&upperBound, buffer, size, bigEndian);
+		result = SerializeAdapter<T>::deSerialize(&upperBound, buffer,
+				size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::deSerialize(&inverted, buffer, size, bigEndian);
+		return SerializeAdapter<bool>::deSerialize(&inverted, buffer,
+				size, bigEndian);
 	}
 protected:
 	bool doMatch(T input) {
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 1420c0761..475764c58 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -112,7 +112,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 
 	//treat from as a continuous Stream as we copy all of it
 	const uint8_t *fromAsStream = (const uint8_t *) from;
-	ssize_t streamSize = fromRows * fromColumns * sizeof(T);
+	size_t streamSize = fromRows * fromColumns * sizeof(T);
 
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
@@ -137,12 +137,12 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian) {
+		size_t* size, bool bigEndian) {
 	return deSerialize(buffer, size, bigEndian, 0);
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
+		size_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
 	ParameterWrapper streamDescription;
 
 	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
@@ -153,8 +153,10 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
 	return copyFrom(&streamDescription, startWritingAtIndex);
 }
 
-ReturnValue_t ParameterWrapper::set(const uint8_t* stream, ssize_t streamSize,
-		const uint8_t **remainingStream, ssize_t *remainingSize) {
+ReturnValue_t ParameterWrapper::set(const uint8_t* stream, size_t streamSize,
+		const uint8_t **remainingStream, size_t *remainingSize) {
+	// TODO: Replaced ssize_t for remainingSize and streamSize
+	// is the logic here correct?
 	ReturnValue_t result = SerializeAdapter<Type>::deSerialize(&type, &stream,
 			&streamSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -172,22 +174,22 @@ ReturnValue_t ParameterWrapper::set(const uint8_t* stream, ssize_t streamSize,
 		return result;
 	}
 
-	int32_t dataSize = type.getSize() * rows * columns;
+	size_t dataSize = type.getSize() * rows * columns;
 
 	if (streamSize < dataSize) {
 		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;
 	}
 
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 6f8f6fc97..ef54fe6d7 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -30,10 +30,10 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian, uint16_t startWritingAtIndex = 0);
 
 	template<typename T>
@@ -111,8 +111,8 @@ 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, ssize_t streamSize,
-			const uint8_t **remainingStream = NULL, ssize_t *remainingSize =
+	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
+			const uint8_t **remainingStream = NULL, size_t *remainingSize =
 					NULL);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 6a4e6caf6..04079bb06 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -108,7 +108,7 @@ uint32_t Fuse::getSerializedSize() const {
 	return size;
 }
 
-ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
 bool bigEndian) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
diff --git a/power/Fuse.h b/power/Fuse.h
index b3c9547ac..aee03778a 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -52,7 +52,7 @@ public:
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 	uint32_t getSerializedSize() const;
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 				bool bigEndian);
 	void setAllMonitorsToUnchecked();
 	ReturnValue_t performOperation(uint8_t opCode);
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 77e60d0e1..0375adf0a 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -56,7 +56,7 @@ float PowerComponent::getMax() {
 	return max;
 }
 
-ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 	ReturnValue_t result = SerializeAdapter<float>::deSerialize(&min, buffer,
 			size, bigEndian);
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 1410e69d3..6ddc067f9 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -24,7 +24,7 @@ public:
 
 	size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 21a669c2d..6a3a276d9 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -56,16 +56,19 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return deSerialize(adaptee, buffer, size, bigEndian);
 	}
 
 	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
-			const uint8_t** buffer, ssize_t* size, bool bigEndian) {
+			const uint8_t** buffer, size_t* size, bool bigEndian) {
 		count_t tempSize = 0;
 		ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize,
 				buffer, size, bigEndian);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 42ea3dada..5fb5e3873 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -61,36 +61,38 @@ size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
 		return bufferLength;
 	}
 }
+
 template<typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian) {
+		size_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
-	if (buffer != NULL) {
-		if(serializeLength){
-			// Suggestion (would require removing rest of the block inside this if clause !):
-			//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
-			//if (result != HasReturnvaluesIF::RETURN_OK) {
-			//	return result;
-			//}
+	// (Robin) the one of the buffer? wouldn't that be an issue for serialize
+	// as well? SerialFixedArrayListAdapter implements swapping of buffer
+	// fields (if buffer type is not uint8_t)
+	if (buffer != nullptr) {
+		if(serializeLength) {
 			count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
 					&bufferLength);
-			if((*size - bufferLength - serializedSize) >= 0){
+			if(bufferLength + serializedSize >= *size) {
 				*buffer +=  serializedSize;
 				*size -= serializedSize;
-			}else{
+			}
+			else {
 				return STREAM_TOO_SHORT;
 			}
 		}
 		//No Else If, go on with buffer
-		if (*size - bufferLength >= 0) {
+		if (bufferLength >= *size) {
 			*size -= bufferLength;
 			memcpy(m_buffer, *buffer, bufferLength);
 			(*buffer) += bufferLength;
 			return HasReturnvaluesIF::RETURN_OK;
-		} else {
+		}
+		else {
 			return STREAM_TOO_SHORT;
 		}
-	} else {
+	}
+	else {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 4a886cbaa..4421f3414 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -49,7 +49,19 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	/**
+	 * @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,
 			bool bigEndian);
 
 	uint8_t * getBuffer();
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 8bcbf09e7..22c4b3a8b 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -22,32 +22,38 @@
  * @ingroup serialize
  */
 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 {
+class SerialFixedArrayListAdapter :
+		public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>,
+		public SerializeIF {
 public:
 	/**
 	 * Constructor Arguments are forwarded to FixedArrayList constructor
 	 * @param args
 	 */
 	template<typename... Args>
-	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
-	}
+	SerialFixedArrayListAdapter(Args... args) :
+	FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...)
+	{}
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const {
-		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this, buffer, size, max_size, bigEndian);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
+				buffer, size, max_size, bigEndian);
 	}
 
 	size_t getSerializedSize() const {
-		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
+				getSerializedSize(this);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
 				buffer, size, bigEndian);
 	}
 
 	void swapArrayListEndianness() {
-		SerialArrayListAdapter<BUFFER_TYPE, count_t>::swapArrayListEndianness(this);
+		SerialArrayListAdapter<BUFFER_TYPE, count_t>::
+				swapArrayListEndianness(this);
 	}
 };
 
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index b5c06a166..85f239b3c 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -122,13 +122,13 @@ public:
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
 	}
 
 	static ReturnValue_t deSerialize(LinkedElement<T>* element,
-			const uint8_t** buffer, ssize_t* size, bool bigEndian) {
+			const uint8_t** buffer, size_t* size, bool bigEndian) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
 			result = element->value->deSerialize(buffer, size, bigEndian);
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index d926bfcec..87e4457ae 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -78,7 +78,7 @@ public:
 	}
 	template<typename T>
 	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			ssize_t* size, bool bigEndian) {
+			size_t* size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.deSerialize(object, buffer, size, bigEndian);
 	}
@@ -98,7 +98,7 @@ public:
 	}
 
 	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			ssize_t* size, bool bigEndian) {
+			size_t* size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.deSerialize(object, buffer, size, bigEndian);
 	}
diff --git a/serialize/SerializeAdapterInternal.h b/serialize/SerializeAdapterInternal.h
index ed0f6c3b8..0caf67868 100644
--- a/serialize/SerializeAdapterInternal.h
+++ b/serialize/SerializeAdapterInternal.h
@@ -33,7 +33,7 @@ public:
 			size_t* size, const size_t max_size, bool bigEndian) {
 	    // function eventuelly serializes structs here.
 	    // does this work on every architecture?
-	    //static_assert(std::is_fundamental<T>::value);
+	    // static_assert(std::is_fundamental<T>::value);
 		size_t ignoredSize = 0;
 		if (size == nullptr) {
 			size = &ignoredSize;
@@ -57,18 +57,17 @@ public:
 	/**
 	 * Deserialize buffer into object
 	 * @param object [out] Object to be deserialized with buffer data
-	 * @param buffer buffer containing the data. Non-Const pointer to non-const
-	 * 						pointer to const buffer.
-	 * @param size int32_t type to allow value to be values smaller than 0,
-	 * 						needed for range/size checking
+	 * @param buffer contains the data. Non-Const pointer to non-const
+	 * 				 pointer to const data.
+	 * @param size Size to deSerialize. wil be decremented by sizeof(T)
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		T tmp;
-		*size -= sizeof(T);
-		if (*size >= 0) {
+		if (*size >= sizeof(T)) {
+			*size -= sizeof(T);
 			memcpy(&tmp, *buffer, sizeof(T));
 			if (bigEndian) {
 				*object = EndianSwapper::swap<T>(tmp);
@@ -109,7 +108,7 @@ public:
 		return object->getSerializedSize();
 	}
 
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return object->deSerialize(buffer, size, bigEndian);
 	}
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index e2da5c141..592968c1f 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -41,7 +41,7 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&entry);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
 	}
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index da401b2f9..6036518a8 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -47,7 +47,7 @@ public:
 
 	virtual size_t getSerializedSize() const = 0;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) = 0;
 
 };
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index e8d8b413a..bb88931be 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -144,7 +144,8 @@ public:
 	 * 					@li	RETURN_FAILED if data could not be added.
 	 * 						storageId is unchanged then.
 	 */
-	virtual ReturnValue_t getFreeElement(store_address_t* storageId, const uint32_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
+			const uint32_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
 	/**
 	 * Clears the whole store.
 	 * Use with care!
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index e4a682bae..52f2c4741 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -168,7 +168,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				&sizeRead);
 		if (result == RETURN_OK) {
 			Mode_t fallbackId;
-			ssize_t size = sizeRead;
+			size_t size = sizeRead;
 			result = SerializeAdapter<Mode_t>::deSerialize(&fallbackId,
 					&pointer, &size, true);
 			if (result == RETURN_OK) {
@@ -193,7 +193,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
 		if (result == RETURN_OK) {
-			ssize_t size = sizeRead;
+			size_t size = sizeRead;
 			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
 					&pointer, &size, true);
 			if (result == RETURN_OK) {
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 4c0c4a261..5e5631b2c 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -53,7 +53,7 @@ public:
 		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	bool bigEndian) {
 		ReturnValue_t result;
 
diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
index d20dfb0a0..a0f65a088 100644
--- a/test/UnitTestClass.cpp
+++ b/test/UnitTestClass.cpp
@@ -157,7 +157,7 @@ ReturnValue_t UnitTestClass::test_autoserialization() {
 	// Unit Test AutoSerializeAdapter serialize
 	current_id = TestIds::AUTO_SERIALIZATION_DESERIALIZE;
 	p_array = test_array.data();
-	ssize_t remaining_size = serialized_size;
+	size_t remaining_size = serialized_size;
 	AutoSerializeAdapter::deSerialize(&test_value_bool,
 			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
 	AutoSerializeAdapter::deSerialize(&tv_uint8,
@@ -197,6 +197,8 @@ ReturnValue_t UnitTestClass::test_autoserialization() {
 			abs(tv_sdouble - (-2.2421e19)) > 0.01) {
 		return put_error(current_id);
 	}
+
+	// Check overflow
 	return RETURN_OK;
 }
 
@@ -285,9 +287,16 @@ ReturnValue_t UnitTestClass::test_serial_buffer_adapter() {
 	return RETURN_OK;
 }
 
-ReturnValue_t UnitTestClass::put_error(TestIds current_id) {
+ReturnValue_t UnitTestClass::put_error(TestIds currentId) {
+	auto errorIter = testResultMap.find(currentId);
+	if(errorIter != testResultMap.end()) {
+		testResultMap.emplace(currentId, 1);
+	}
+	else {
+		errorIter->second ++;
+	}
 	error << "Unit Tester failed at test ID "
-			<< static_cast<uint32_t>(current_id) << "\r\n" << std::flush;
+			<< static_cast<uint32_t>(currentId) << "\r\n" << std::flush;
 	return RETURN_FAILED;
 }
 
diff --git a/test/UnitTestClass.h b/test/UnitTestClass.h
index d9ba9d1c6..ffc7a2a2b 100644
--- a/test/UnitTestClass.h
+++ b/test/UnitTestClass.h
@@ -56,7 +56,8 @@ private:
 	TestIds current_id = TestIds::MISC;
 	std::array<uint8_t, 512> test_array;
 
-	using TestResultMap = std::map<uint32_t, ReturnValue_t>;
+	using error_count_t =  uint8_t;
+	using TestResultMap = std::map<TestIds, error_count_t>;
 	using TestBuffer = std::vector<uint8_t>;
 	TestResultMap testResultMap;
 
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 737ffd2ea..ffe7ba7b9 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -40,11 +40,11 @@ ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
 	}
 }
 
-ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, ssize_t size) {
+ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
 	if (size != 4 * sizeof(parameters.lowerOpLimit)) {
 		return MonitoringIF::INVALID_SIZE;
 	}
-	ssize_t readSize = size;
+	size_t readSize = size;
 	SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
 			&readSize, true);
 	SerializeAdapter<float>::deSerialize(&parameters.lowerOpLimit, &data,
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 37ed01c0f..afe9aa10a 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -53,7 +53,7 @@ public:
 
 	ReturnValue_t setTargetState(int8_t newState);
 
-	virtual ReturnValue_t setLimits( const uint8_t* data, ssize_t size);
+	virtual ReturnValue_t setLimits( const uint8_t* data, size_t size);
 
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 4e7bc94b4..2c70ca781 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -48,7 +48,7 @@ public:
 		return sizeof(apid) + sizeof(ssc);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	bool bigEndian) {
 		ReturnValue_t result = SerializeAdapter<uint16_t>::deSerialize(&apid,
 				buffer, size, bigEndian);
@@ -257,7 +257,7 @@ public:
 
 	};
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	bool bigEndian) {
 		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&apid, buffer,
 				size, bigEndian);
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 1ee444762..577425ccd 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -30,9 +30,10 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer, size, bigEndian);
+		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer,
+				size, bigEndian);
 	}
 };
 
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index b69ac7a5d..698027da6 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -30,9 +30,10 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer, size, bigEndian);
+		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer,
+				size, bigEndian);
 	}
 };
 
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 9c93af649..5a8f7954d 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -28,9 +28,10 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer, size, bigEndian);
+		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer,
+				size, bigEndian);
 	}
 private:
 	uint8_t subService;
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 630394f8f..ba64689aa 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -28,7 +28,7 @@ const uint8_t* TcPacketBase::getApplicationData() const {
 	return &tcData->data;
 }
 
-uint16_t TcPacketBase::getApplicationDataSize() {
+size_t TcPacketBase::getApplicationDataSize() {
 	return getPacketDataLength() - sizeof(tcData->data_field) - CRC_SIZE + 1;
 }
 
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index e6e6bdad4..d84d6c45c 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -151,7 +151,7 @@ public:
 	 * @return	The size of the PUS Application Data (without Error Control
 	 * 		field)
 	 */
-	uint16_t getApplicationDataSize();
+	size_t getApplicationDataSize();
 	/**
 	 * This getter returns the Error Control Field of the packet.
 	 *

From 9284fe81da14628f26001536e22a66c1873517f3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 15 Apr 2020 20:53:03 +0200
Subject: [PATCH 0175/1774] added override specifiers, some doc fixes

---
 container/FixedArrayList.h              | 20 ++++++++--
 serialize/EndianSwapper.h               | 27 +++++++++++---
 serialize/SerialArrayListAdapter.h      |  8 ++--
 serialize/SerialBufferAdapter.h         |  4 +-
 serialize/SerialFixedArrayListAdapter.h | 33 ++++++++++-------
 serialize/SerialLinkedListAdapter.h     | 49 +++++++++++++++----------
 serialize/SerializeAdapterInternal.h    |  5 ++-
 serialize/SerializeDoc.h                | 16 --------
 serialize/SerializeElement.h            | 17 +++++----
 serialize/SerializeIF.h                 | 27 +++++++-------
 10 files changed, 117 insertions(+), 89 deletions(-)
 delete mode 100644 serialize/SerializeDoc.h

diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index 12e292b4a..5d93db90c 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -12,14 +12,26 @@ class FixedArrayList: public ArrayList<T, count_t> {
 private:
 	T data[MAX_SIZE];
 public:
+	/**
+	 * (Robin) Maybe we should also implement move assignment and move ctor.
+	 * Or at least delete them.
+	 */
 	FixedArrayList() :
 			ArrayList<T, count_t>(data, MAX_SIZE) {
 	}
 
-	//We could create a constructor to initialize the fixed array list with data and the known size field
-	//so it can be used for serialization too (with SerialFixedArrrayListAdapter)
-	//is this feasible?
-	FixedArrayList(T * data_, count_t count, bool swapArrayListEndianess = false):
+	// (Robin): We could create a constructor to initialize the fixed array list with data and the known size field
+	// so it can be used for serialization too (with SerialFixedArrrayListAdapter)
+	// is this feasible?
+	/**
+	 * Initialize a fixed array list with data and number of data fields.
+	 * Endianness of entries can be swapped optionally.
+	 * @param data_
+	 * @param count
+	 * @param swapArrayListEndianess
+	 */
+	FixedArrayList(T * data_, count_t count,
+			bool swapArrayListEndianess = false):
 		ArrayList<T, count_t>(data, MAX_SIZE) {
 		memcpy(this->data, data_, count * sizeof(T));
 		this->size = count;
diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index 9f621902f..5ba6fd324 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -13,6 +13,12 @@ class EndianSwapper {
 private:
 	EndianSwapper() {};
 public:
+	/**
+	 * Swap the endianness of a variable with arbitrary type
+	 * @tparam T Type of variable
+	 * @param in variable
+	 * @return Variable with swapped endianness
+	 */
 	template<typename T>
 	static T swap(T in) {
 #ifndef BYTE_ORDER_SYSTEM
@@ -31,7 +37,14 @@ public:
 #error Unknown Byte Order
 #endif
 	}
-	static void swap(uint8_t* out, const uint8_t* in, uint32_t size) {
+
+	/**
+	 * Swap the endianness of a buffer.
+	 * @param out
+	 * @param in
+	 * @param size
+	 */
+	static void swap(uint8_t* out, const uint8_t* in, size_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
@@ -47,21 +60,23 @@ public:
 
 	/**
 	 * Swap endianness of buffer entries
-	 * Template argument specifies buffer type
+	 * Template argument specifies buffer type. The number of entries
+	 * (not the buffer size!) must be supplied
 	 * @param out
 	 * @param in
-	 * @param size
+	 * @param size Number of buffer entries (not size of buffer in bytes!)
 	 */
 	template<typename T>
-	static void swap(T * out, const T * in, uint32_t size) {
+	static void swap(T * out, const T * in, uint32_t entries) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
 		const uint8_t * in_buffer = reinterpret_cast<const uint8_t *>(in);
 		uint8_t * out_buffer = reinterpret_cast<uint8_t *>(out);
-		for (uint8_t count = 0; count < size; count++) {
+		for (uint8_t count = 0; count < entries; count++) {
 			for(uint8_t i = 0; i < sizeof(T);i++) {
-				out_buffer[sizeof(T)* (count + 1) - i - 1] = in_buffer[count * sizeof(T) + i];
+				out_buffer[sizeof(T)* (count + 1) - i - 1] =
+						in_buffer[count * sizeof(T) + i];
 			}
 		}
 		return;
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 6a3a276d9..4f3b82e68 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -13,7 +13,7 @@
 
 /**
  * Also serializes length field !
- * \ingroup serialize
+ * @ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
 class SerialArrayListAdapter : public SerializeIF {
@@ -22,7 +22,7 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			const size_t max_size, bool bigEndian) const  override {
 		return serialize(adaptee, buffer, size, max_size, bigEndian);
 	}
 
@@ -41,7 +41,7 @@ public:
 		return result;
 	}
 
-	virtual size_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const override {
 		return getSerializedSize(adaptee);
 	}
 
@@ -57,7 +57,7 @@ public:
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			bool bigEndian) override {
 		return deSerialize(adaptee, buffer, size, bigEndian);
 	}
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 4421f3414..d414573cb 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -45,7 +45,7 @@ public:
 	virtual ~SerialBufferAdapter();
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
+			const size_t max_size, bool bigEndian) const override;
 
 	virtual size_t getSerializedSize() const;
 
@@ -62,7 +62,7 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			bool bigEndian) override;
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 22c4b3a8b..6e13ff6f4 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -5,19 +5,24 @@
 #include <framework/serialize/SerialArrayListAdapter.h>
 
 /**
- * @brief This adapter provides an interface for SerializeIF to serialize and deserialize
- *        buffers with a header containing the buffer length.
+ * @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.
+ * The sequence of objects is defined in the constructor by
+ * using the setStart and setNext functions.
  *
  *  1. Buffers with a size header inside that class can be declared with
- *     SerialFixedArrayListAdapter<BUFFER_TYPE, MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE>.
- *  2. MAX_BUFFER_LENGTH specifies the maximum allowed number of elements in FixedArrayList
- *  3. LENGTH_FIELD_TYPE specifies the data type of the buffer header containing the buffer size
- *     (defaults to 1 byte length field) that follows
+ *     @code
+ *     SerialFixedArrayListAdapter<BUFFER_TYPE,
+ *     		MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE> mySerialFixedArrayList(...).
+ *     @endcode
+ *  2. MAX_BUFFER_LENGTH specifies the maximum allowed number of elements
+ *     in FixedArrayList.
+ *  3. LENGTH_FIELD_TYPE specifies the data type of the buffer header
+ *     containing the buffer size (defaults to 1 byte length field)
+ *     that follows.
  *
  * @ingroup serialize
  */
@@ -27,7 +32,8 @@ class SerialFixedArrayListAdapter :
 		public SerializeIF {
 public:
 	/**
-	 * Constructor Arguments are forwarded to FixedArrayList constructor
+	 * Constructor Arguments are forwarded to FixedArrayList constructor.
+	 * Refer to the fixed array list constructors for different options.
 	 * @param args
 	 */
 	template<typename... Args>
@@ -35,8 +41,8 @@ public:
 	FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...)
 	{}
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const  override {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
 				buffer, size, max_size, bigEndian);
 	}
@@ -45,8 +51,9 @@ public:
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
 				getSerializedSize(this);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
 				buffer, size, bigEndian);
 	}
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 85f239b3c..8cb9afc8b 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -18,23 +18,25 @@
  * 		   	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,
- *     with a known size, where the size can also be serialized
- *   - The element type can also be a SerialFixedArrayListAdapter to de-/serialize buffers
- *     with a size header, which is scanned automatically
+ *   - 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 with a known size
+ *   - 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.
  *
- * - The serialization process is done by instantiating the class and
- *   calling serializ 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
- * - 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
+ * 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.
  *
  * @ingroup serialize
  */
@@ -55,10 +57,12 @@ public:
 			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) {
 	}
@@ -66,15 +70,16 @@ public:
 	/**
 	 * Serialize object implementing this adapter into the supplied buffer
 	 * and calculate the serialized size
-	 * @param buffer [out] Object is serialized into this buffer. Note that the buffer pointer
-	 *               *buffer is incremented automatically inside the respective serialize functions
+	 * @param buffer [out] Object is serialized into this buffer.
+	 *    Note that the buffer pointer *buffer is incremented automatically
+	 *    inside the respective serialize functions
 	 * @param size [out] Calculated serialized size. Don't forget to set to 0.
 	 * @param max_size
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			const size_t max_size, bool bigEndian) const override{
 		if (printCount) {
 			count_t mySize = SinglyLinkedList<T>::getSize();
 			ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize,
@@ -98,7 +103,9 @@ public:
 		}
 		return result;
 	}
-	virtual size_t getSerializedSize() const {
+
+
+	virtual size_t getSerializedSize() const override {
 		if (printCount) {
 			return SerialLinkedListAdapter<T>::getSerializedSize()
 					+ sizeof(count_t);
@@ -106,6 +113,7 @@ public:
 			return getSerializedSize(SinglyLinkedList<T>::start);
 		}
 	}
+
 	static uint32_t getSerializedSize(const LinkedElement<T> *element) {
 		uint32_t size = 0;
 		while (element != NULL) {
@@ -115,15 +123,17 @@ public:
 		return size;
 	}
 
+
 	/**
-	 * Deserialize supplied buffer with supplied size into object implementing this adapter
+	 * Deserialize supplied buffer with supplied size into object
+	 * implementing this adapter.
 	 * @param buffer
 	 * @param size Decremented in respective deSerialize functions automatically
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			bool bigEndian) override {
 		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
 	}
 
@@ -138,7 +148,6 @@ public:
 	}
 
 	bool printCount;
-
 };
 
 #endif /* SERIALLINKEDLISTADAPTER_H_ */
diff --git a/serialize/SerializeAdapterInternal.h b/serialize/SerializeAdapterInternal.h
index 0caf67868..c57af0c95 100644
--- a/serialize/SerializeAdapterInternal.h
+++ b/serialize/SerializeAdapterInternal.h
@@ -12,8 +12,9 @@
 #include <framework/serialize/EndianSwapper.h>
 
 /**
- * This template specialization will be chosen for fundamental types,
- * based on partial template specialization
+ * This template specialization will be chosen for fundamental types or
+ * anything else not implementing SerializeIF, based on partial
+ * template specialization.
  * @tparam T
  * @tparam
  */
diff --git a/serialize/SerializeDoc.h b/serialize/SerializeDoc.h
deleted file mode 100644
index 6186b77b7..000000000
--- a/serialize/SerializeDoc.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
- * @page    serialPage Serialization Tools
- * This page refers to the serialization tools included in framework/serialize.
- * The serialization tools are a useful tool to convert object data into raw
- * buffers and vice-versa. Here is a rough overview which tool to use for
- * which purpose.
- *
- * @section endSwapper  Endian Swapper
- * This header file includes tools to do simple serial order swapping
- *
- * @section serialiezIF SerializeIF
- *
- * @section serElement  SerializeElement
- *
- */
-
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 592968c1f..4717ae17f 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -24,17 +24,18 @@ public:
 	 * @param args
 	 */
 	template<typename... Args>
-	SerializeElement(Args... args) : LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
+	SerializeElement(Args... args):
+			LinkedElement<SerializeIF>(this),
+			entry(std::forward<Args>(args)...) {}
 
-	}
-	SerializeElement() : LinkedElement<SerializeIF>(this) {
-	}
+	SerializeElement() : LinkedElement<SerializeIF>(this) {}
 
 	T entry;
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		return SerializeAdapter<T>::serialize(&entry, buffer, size, max_size, bigEndian);
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override {
+		return SerializeAdapter<T>::serialize(&entry, buffer, size,
+				max_size, bigEndian);
 	}
 
 	size_t getSerializedSize() const {
@@ -42,7 +43,7 @@ public:
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			bool bigEndian) override {
 		return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
 	}
 
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 6036518a8..5f8102c86 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -3,11 +3,6 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
-#include <type_traits>
-
-#ifndef ssize_t
-typedef std::make_signed<std::size_t>::type ssize_t;
-#endif
 
 /**
  * @defgroup serialize Serialization
@@ -18,17 +13,21 @@ typedef std::make_signed<std::size_t>::type ssize_t;
  * @brief An interface for alle classes which require
  *        translation of objects data into data streams and vice-versa.
  * @details
- * If the target architecture is little endian (e.g. ARM), any data types created might
- * have the wrong endiness if they are to be used for the FSFW.
- * There are three ways to retrieve data out of a buffer to be used in the FSFW to use
- * regular aligned (big endian) data. This can also be applied to uint32_t and uint64_t:
+ * If the target architecture is little endian (e.g. ARM), any data types
+ * created might  have the wrong endianess if they are to be used for the FSFW.
+ * Depending on the system architecture, endian correctness must be assured,
+ * This is important for incoming and outgoing data. The internal handling
+ * of data should be performed in the native system endianness.
+ * There are three ways to copy data (with different options to ensure
+ * endian correctness):
  *
- *   1. Use the @c AutoSerializeAdapter::deSerialize function with @c bigEndian = true
- *   2. Perform a bitshift operation
- *   3. @c memcpy can be used when data is in little-endian format. Otherwise, @c EndianSwapper has to be used in conjuction.
+ *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
+ *      the endian flag)
+ *   2. Perform a bitshift operation (with correct order)
+ *   3. @c memcpy (with @c EndianSwapper if necessary)
  *
- * When serializing for downlink, the packets are generally serialized assuming big endian data format
- * like seen in TmPacketStored.cpp for example.
+ * When serializing for downlink, the packets are generally serialized
+ * assuming big endian data format like seen in TmPacketStored.cpp for example.
  *
  * @ingroup serialize
  */

From fc08754b98698708dfd36b0f2d1f121e1755922f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 15 Apr 2020 23:28:45 +0200
Subject: [PATCH 0176/1774] some doc unclarities comment added

---
 devicehandlers/DeviceHandlerBase.cpp |  12 ++-
 devicehandlers/DeviceHandlerBase.h   | 155 +++++++++++++++++----------
 2 files changed, 105 insertions(+), 62 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 5fb5a9e5f..6c4be8dfb 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,10 +16,11 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-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) :
+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) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 	    deviceCommunicationId(deviceCommunication), comCookie(comCookie_),
@@ -37,7 +38,8 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
 	insertInCommandMap(RAW_COMMAND_ID);
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance =
-				new DeviceHandlerFailureIsolation(setObjectId, defaultFDIRParentId);
+				new DeviceHandlerFailureIsolation(setObjectId,
+						defaultFDIRParentId);
 	}
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index c162210c9..729eac0b5 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -93,8 +93,10 @@ public:
 	 *
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
 	 * @param maxDeviceReplyLen the largest allowed reply size
-	 * @param setDeviceSwitch the switch the device is connected to, for devices using two switches, overwrite getSwitches()
-	 * @param deviceCommuncation Communcation Interface object which is used to implement communication functions
+	 * @param setDeviceSwitch the switch the device is connected to,
+	 *    for devices using two switches, overwrite getSwitches()
+	 * @param deviceCommuncation Communcation Interface object which is
+	 *    used to implement communication functions
 	 * @param thermalStatePoolId
 	 * @param thermalRequestPoolId
 	 * @param fdirInstance
@@ -107,31 +109,35 @@ public:
 			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
 
 	/**
-	 * @brief This function is the device handler base core component and is called periodically.
+	 * @brief 	This function is the device handler base core component and is
+	 * 			called periodically.
 	 * @details
 	 * General sequence, showing where abstract virtual functions are called:
 	 * If the State is SEND_WRITE:
 	 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
 	 *   2. Handles Device State Modes by calling doStateMachine().
-	 *      This function calls callChildStatemachine() which calls the abstract functions
-	 *      doStartUp() and doShutDown()
+	 *      This function calls callChildStatemachine() which calls the
+	 *      abstract functions doStartUp() and doShutDown()
 	 *   3. Check switch states by calling checkSwitchStates()
-	 *   4. Decrements counter for timeout of replies by calling decrementDeviceReplyMap()
+	 *   4. Decrements counter for timeout of replies by calling
+	 *      decrementDeviceReplyMap()
 	 *   5. Performs FDIR check for failures
 	 *   6. Calls hkSwitcher.performOperation()
-	 *   7. If the device mode is MODE_OFF, return RETURN_OK. Otherwise, perform the Action property
-	 *   	and performs depending on value specified
-	 *      by input value counter. The child class tells base class what to do by setting this value.
-	 *     - SEND_WRITE: Send data or commands to device by calling doSendWrite() which calls
-	 *       sendMessage function of #communicationInterface
+	 *   7. If the device mode is MODE_OFF, return RETURN_OK.
+     *      Otherwise, perform the Action property and performs depending
+     *      on value specified by input value counter (incremented in PST).
+     *      The child class tells base class what to do by setting this value.
+	 *     - SEND_WRITE: Send data or commands to device by calling
+	 *       doSendWrite() which calls sendMessage function
+	 *       of #communicationInterface
 	 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
-	 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite() which calls
-	 *       getSendSuccess of #communicationInterface.
+	 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite()
+	 *       which calls getSendSuccess of #communicationInterface.
 	 *       Calls abstract functions scanForReply() and interpretDeviceReply().
-	 *     - SEND_READ: Request reading data from device by calling doSendRead() which calls
-	 *       requestReceiveMessage of #communcationInterface
-	 *     - GET_READ: Access requested reading data by calling doGetRead() which calls
-	 *       readReceivedMessage of #communicationInterface
+	 *     - SEND_READ: Request reading data from device by calling doSendRead()
+	 *       which calls requestReceiveMessage of #communcationInterface
+	 *     - GET_READ: Access requested reading data by calling doGetRead()
+	 *       which calls readReceivedMessage of #communicationInterface
 	 * @param counter Specifies which Action to perform
 	 * @return RETURN_OK for successful execution
 	 */
@@ -153,37 +159,54 @@ public:
 	virtual ~DeviceHandlerBase();
 protected:
 	/**
-	 * This is used to let the child class handle the transition from mode @c _MODE_START_UP to @c MODE_ON
-	 *
-	 * It is only called when the device handler is in mode @c _MODE_START_UP. That means, the device switch(es) are already set to on.
-	 * Device handler commands are read and can be handled by the child class. If the child class handles a command, it should also send
+	 * @brief 	This is used to let the child class handle the transition from
+	 * 			mode @c _MODE_START_UP to @c MODE_ON
+	 * @details
+	 * It is only called when the device handler is in mode @c _MODE_START_UP.
+	 * That means, the device switch(es) are already set to on.
+	 * Device handler commands are read and can be handled by the child class.
+	 * If the child class handles a command, it should also send
 	 * an reply accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE, the base class handles rejecting the command and sends a reply.
+	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE,
+	 * the base class handles rejecting the command and sends a reply.
 	 * The replies for mode transitions are handled by the base class.
 	 *
-	 * If the device is started and ready for operation, the mode should be set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
-	 * use the to on transition if available.
-	 * If the power-up fails, the mode should be set to _MODE_POWER_DOWN which will lead to the device being powered off.
-	 * If the device does not change the mode, the mode will be changed to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay()) has passed.
+	 *  - If the device is started and ready for operation, the mode should be
+	 *    set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
+	 *    use the to on transition if available.
+	 *  - If the power-up fails, the mode should be set to _MODE_POWER_DOWN
+	 *    which will lead to the device being powered off.
+	 *  - If the device does not change the mode, the mode will be changed
+	 *    to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay())
+	 *    has passed.
 	 *
-	 * #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
 	 */
 	virtual void doStartUp() = 0;
 
 	/**
-	 * This is used to let the child class handle the transition from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
-	 *
+	 * @brief 	This is used to let the child class handle the transition
+	 * 			from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
+	 * @details
 	 * It is only called when the device handler is in mode @c _MODE_SHUT_DOWN.
-	 * Device handler commands are read and can be handled by the child class. If the child class handles a command, it should also send
-	 * an reply accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE, the base class handles rejecting the command and sends a reply.
-	 * The replies for mode transitions are handled by the base class.
+	 * Device handler commands are read and can be handled by the child class.
+	 * If the child class handles a command, it should also send an reply
+	 * accordingly.
+	 * If an Command is not handled (ie #DeviceHandlerCommand is not
+	 * @c CMD_NONE, the base class handles rejecting the command and sends a
+	 * reply. The replies for mode transitions are handled by the base class.
 	 *
-	 * If the device ready to be switched off, the mode should be set to _MODE_POWER_DOWN.
-	 * If the device should not be switched off, the mode can be changed to _MODE_TO_ON (or MODE_ON if no transition is needed).
-	 * If the device does not change the mode, the mode will be changed to _MODE_POWER_DOWN, when the timeout (from getTransitionDelay()) has passed.
+	 *  - If the device ready to be switched off,
+	 *    the mode should be set to _MODE_POWER_DOWN.
+	 *  - If the device should not be switched off, the mode can be changed to
+	 *     _MODE_TO_ON (or MODE_ON if no transition is needed).
+	 *  - If the device does not change the mode, the mode will be changed to
+	 *    _MODE_POWER_DOWN, when the timeout (from getTransitionDelay())
+	 *    has passed.
 	 *
-	 * #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
 	 */
 	virtual void doShutDown() = 0;
 
@@ -249,27 +272,42 @@ protected:
 	 * @details
 	 * This is used to let the base class know which replies are expected.
 	 * There are different scenarios regarding this:
-	 *  - "Normal" commands. These are commands, that trigger a direct reply from the device.
-	 *    In this case, the id of the command should be added to the command map
-	 *    with a commandData_t where maxDelayCycles is set to the maximum expected
-	 *    number of PST cycles the reply will take. Then, scanForReply returns
-	 *    the id of the command and the base class can handle time-out and missing replies.
-	 *  - Periodic, unrequested replies. These are replies that, once enabled, are sent by the device
-	 *    on its own in a defined interval. In this case, the id of the reply
-	 *    or a placeholder id should be added to the deviceCommandMap with a commandData_t
-	 *    where maxDelayCycles is set to the maximum expected number of PST cycles between
-	 *    two replies (also a tolerance should be added, as an FDIR message will be generated if it is missed).
-	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must be set to 1,
-	 *    DeviceCommandInfo.delayCycles to DeviceCommandInfo.MaxDelayCycles.
-	 *    From then on, the base class handles the reception.
-	 *    Then, scanForReply returns the id of the reply or the placeholder id and the base class will
-	 *    take care of checking that all replies are received and the interval is correct.
-	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set to 0,
-	 *    DeviceCommandInfo.delayCycles to 0;
-	 *  - Aperiodic, unrequested replies. These are replies that are sent
-	 *    by the device without any preceding command and not in a defined interval.
-	 *    These are not entered in the deviceCommandMap but handled by returning @c APERIODIC_REPLY in scanForReply().
 	 *
+	 *  - "Normal" commands. These are commands, that trigger a direct reply
+	 *    from the device. In this case, the id of the command should be added
+	 *    to the command map with a commandData_t where maxDelayCycles is set
+	 *    to the maximum expected number of PST cycles the reply will take.
+	 *    Then, scanForReply returns the id of the command and the base class
+	 *    can handle time-out and missing replies.
+	 *
+	 *  - Periodic, unrequested replies. These are replies that, once enabled,
+	 *    are sent by the device on its own in a defined interval.
+	 *    In this case, the id of the reply or a placeholder id should be added
+	 *    to the deviceCommandMap with a commandData_t where maxDelayCycles is
+	 *    set to the maximum expected number of PST cycles between two replies
+	 *    (also a tolerance should be added, as an FDIR message will be
+	 *    generated if it is missed).
+	 *
+	 *    (Robin) This part confuses me. "must do as soon as" implies that
+	 *    the developer must do something somewhere else in the code. Is
+	 *    that really the case? If I understood correctly, DHB performs
+	 *    almost everything (e.g. in erirm function) as long as the commands
+	 *    are inserted correctly.
+	 *
+	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must
+	 *    be set to true, DeviceCommandInfo.delayCycles to
+	 *    DeviceCommandInfo.maxDelayCycles.
+	 *    From then on, the base class handles the reception.
+	 *    Then, scanForReply returns the id of the reply or the placeholder id
+	 *    and the base class will take care of checking that all replies are
+	 *    received and the interval is correct.
+	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set
+	 *    to 0, DeviceCommandInfo.delayCycles to 0;
+	 *
+	 *  - Aperiodic, unrequested replies. These are replies that are sent
+	 *    by the device without any preceding command and not in a defined
+	 *    interval. These are not entered in the deviceCommandMap but
+	 *    handled by returning @c APERIODIC_REPLY in scanForReply().
 	 */
 	virtual void fillCommandAndReplyMap() = 0;
 
@@ -530,6 +568,9 @@ protected:
 		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
 		size_t replyLen = 0; //!< Expected size of the reply.
+		//(Robin): This is a flag, isnt it? could we declare it bool? uint8_t always
+		// gives away the impression that this variable is more than a simple flag
+		// and true/false are also more explicit.
 		uint8_t 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.
 	};

From bd0b9cb877ec6138d6d83727480748d4a676975e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Apr 2020 09:30:02 +0200
Subject: [PATCH 0177/1774] catch example informative comment

---
 test/CatchExample.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/CatchExample.cpp b/test/CatchExample.cpp
index 4db6a5c2a..90fd1ed55 100644
--- a/test/CatchExample.cpp
+++ b/test/CatchExample.cpp
@@ -1,5 +1,7 @@
 // Catch Example.
 // Does not work yet. Problems with linker without main and config folder.
+// propably because global object manager and some config files are not supplied
+// but mandatory for full compilation of the framework.
 // Let Catch provide main():
 
 #if defined(UNIT_TEST)

From 33b834ad910ca269c4131d8b796c2deba94a2eed Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Apr 2020 10:43:50 +0200
Subject: [PATCH 0178/1774] null replaced by nullptr

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 5fb5a9e5f..374ebaf6e 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -114,7 +114,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
 			AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
-	if (rawReceiver == NULL) {
+	if (rawReceiver == nullptr) {
 		return RETURN_FAILED;
 	}
 

From f45a8cc17193fb3176a8410bd8b00e4ca351bad9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Apr 2020 13:17:26 +0200
Subject: [PATCH 0179/1774] fixed slot sequence safety check added

---
 devicehandlers/FixedSlotSequence.cpp | 11 ++++++++++-
 devicehandlers/FixedSlotSequence.h   |  4 +++-
 osal/FreeRTOS/FixedTimeslotTask.cpp  |  1 -
 3 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index 23bb0e78a..f11de94b4 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -1,5 +1,6 @@
 #include <framework/devicehandlers/FixedSlotSequence.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <cstdlib>
 
 FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
 		slotLengthMs(setLengthMs) {
@@ -87,7 +88,15 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 }
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
-	// Iterate through slotList and check successful creation.
+	if(slotList.empty()) {
+	    error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
+	    // does check sequence have to be const?
+	    // if I want to check a class, I need the ability to set
+	    // internal class states.
+	    //isEmpty = true;
+	    std::exit(0);
+	}
+    // Iterate through slotList and check successful creation.
 	// Checks if timing is ok (must be ascending) and if all handlers were found.
 	auto slotIt = slotList.begin();
 	uint32_t count = 0;
diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h
index 813d2fce2..cad7ee875 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -3,6 +3,7 @@
 
 #include <framework/devicehandlers/FixedSequenceSlot.h>
 #include <framework/objectmanager/SystemObject.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <list>
 #include <set>
 
@@ -23,7 +24,6 @@ using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
 class FixedSlotSequence {
 public:
 
-
 	/**
 	 * @brief	The constructor of the FixedSlotSequence object.
 	 *
@@ -127,6 +127,8 @@ protected:
 	SlotList slotList;
 
 	uint32_t slotLengthMs;
+
+	bool isEmpty = false;
 };
 
 #endif /* FIXEDSLOTSEQUENCE_H_ */
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index b1c974202..db0247a4a 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -112,7 +112,6 @@ void FixedTimeslotTask::taskFunctionality() {
 			vTaskDelayUntil(&xLastWakeTime, interval);
 			//TODO deadline missed check
 		}
-
 	}
 }
 

From eb362dcad2adb126156d19c558794892526a8791 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Apr 2020 17:02:04 +0200
Subject: [PATCH 0180/1774] some comment line break

---
 devicehandlers/DeviceHandlerBase.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 6c4be8dfb..a371b4139 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -690,7 +690,8 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 
 	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.
 	}
 }
 

From ea1d55b0336dd860c7c5ab7a2a6b62d408d3244c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Apr 2020 13:16:00 +0200
Subject: [PATCH 0181/1774] null replaced by nullptr.

storeID initialization added, all nullptr/0 initializations in header
---
 tmtcservices/TmTcBridge.cpp | 19 +++++++++----------
 tmtcservices/TmTcBridge.h   | 25 ++++++++++++++-----------
 2 files changed, 23 insertions(+), 21 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 8450494a6..38d900dd4 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -11,17 +11,15 @@
 #include <framework/tmtcservices/AcceptsTelecommandsIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-TmTcBridge::TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_):
-	SystemObject(objectId_),tcStore(NULL), tmStore(NULL),
-	ccsdsPacketDistributor(ccsdsPacketDistributor_), communicationLinkUp(false),
-	tmStored(false),recvBuffer(NULL), size(0) {
-	TmTcReceptionQueue = QueueFactory::instance()->
+TmTcBridge::TmTcBridge(object_id_t objectId_,
+        object_id_t ccsdsPacketDistributor_): SystemObject(objectId_),
+        ccsdsPacketDistributor(ccsdsPacketDistributor_)
+{
+	    TmTcReceptionQueue = QueueFactory::instance()->
 			createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
-
 }
 
-TmTcBridge::~TmTcBridge() {
-}
+TmTcBridge::~TmTcBridge() {}
 
 ReturnValue_t TmTcBridge::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
@@ -75,8 +73,9 @@ ReturnValue_t TmTcBridge::handleTm() {
 
 ReturnValue_t TmTcBridge::readTmQueue() {
 	TmTcMessage message;
-	const uint8_t* data = NULL;
+	const uint8_t* data = nullptr;
 	size_t size = 0;
+
 	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
 	{
@@ -105,7 +104,7 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	info << "TMTC Bridge: Comm Link down. "
 			"Saving packet ID to be sent later\r\n" << std::flush;
-	store_address_t storeId;
+	store_address_t storeId = 0;
 
 	if(fifo.full()) {
 		info << "TMTC Bridge: TM downlink max. number of stored packet IDs reached."
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 8e4124e08..e0634098e 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -48,12 +48,15 @@ public:
 	void registerCommConnect();
 	void registerCommDisconnect();
 protected:
-	MessageQueueIF* TmTcReceptionQueue; //!< Used to send and receive TMTC messages. TmTcMessage is used to transport messages between tasks.
-	StorageManagerIF* tcStore;
-	StorageManagerIF* tmStore;
-	object_id_t ccsdsPacketDistributor;
-	bool communicationLinkUp; //!< Used to specify whether communication link is up
-	bool tmStored;
+	//! Used to send and receive TMTC messages.
+	//! TmTcMessage is used to transport messages between tasks.
+	MessageQueueIF* TmTcReceptionQueue = nullptr;
+	StorageManagerIF* tcStore = nullptr;
+	StorageManagerIF* tmStore = nullptr;
+	object_id_t ccsdsPacketDistributor = 0;
+	//! Used to specify whether communication link is up
+	bool communicationLinkUp = false;
+	bool tmStored = false;
 
 	/**
 	 * Handle TC reception. Default implementation provided
@@ -113,13 +116,13 @@ protected:
 	void printData(uint8_t * data, uint32_t dataLen);
 
 private:
-	static const uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
-	static const uint8_t MAX_STORED_DATA_SENT_PER_CYCLE = 10;
-	static const uint8_t MAX_DOWNLINK_PACKETS_STORED = 15;
+	static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
+	static constexpr uint8_t MAX_STORED_DATA_SENT_PER_CYCLE = 10;
+	static constexpr uint8_t MAX_DOWNLINK_PACKETS_STORED = 15;
 
 	FIFO<store_address_t, MAX_DOWNLINK_PACKETS_STORED> fifo;
-	uint8_t * recvBuffer;
-	uint32_t size;
+	uint8_t * recvBuffer = nullptr;
+	uint32_t size = 0;
 };
 
 

From 4d8aca8417f722ab6fcf15f3defd73652cc0a18a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Apr 2020 13:32:40 +0200
Subject: [PATCH 0182/1774] message queue adaptation for ISRs

---
 osal/FreeRTOS/MessageQueue.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 3546a99b7..6082bb159 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -124,6 +124,9 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
                 reinterpret_cast<const void*>(message->getBuffer()), 0);
     }
     else {
+        // If the call context is from an interrupt,
+        // request a context switch if a higher priority task
+        // was blocked by the interrupt.
         BaseType_t xHigherPriorityTaskWoken = pdFALSE;
         result = xQueueSendFromISR(reinterpret_cast<void*>(sendTo),
                 reinterpret_cast<const void*>(message->getBuffer()),

From e34a438e774aee4dfe39ab881519e01e8735cb52 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Apr 2020 13:38:05 +0200
Subject: [PATCH 0183/1774] using size_t

---
 tmtcservices/TmTcBridge.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 38d900dd4..c984a6a8a 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -16,7 +16,7 @@ TmTcBridge::TmTcBridge(object_id_t objectId_,
         ccsdsPacketDistributor(ccsdsPacketDistributor_)
 {
 	    TmTcReceptionQueue = QueueFactory::instance()->
-			createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
+	            createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
 }
 
 TmTcBridge::~TmTcBridge() {}
@@ -75,7 +75,6 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 	TmTcMessage message;
 	const uint8_t* data = nullptr;
 	size_t size = 0;
-
 	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
 	{
@@ -122,8 +121,8 @@ ReturnValue_t TmTcBridge::sendStoredTm() {
 	uint8_t counter = 0;
 	ReturnValue_t result = RETURN_OK;
 	while(!fifo.empty() && counter < MAX_STORED_DATA_SENT_PER_CYCLE) {
-		info << "UDP Server: Sending stored TM data. There are "
-				<< (int) fifo.size() << " left to send\r\n" << std::flush;
+		info << "TMTC Bridge: Sending stored TM data. There are "
+		     << (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
 		const uint8_t* data = NULL;
 		size_t size = 0;
@@ -131,7 +130,8 @@ ReturnValue_t TmTcBridge::sendStoredTm() {
 		result = tmStore->getData(storeId, &data, &size);
 		sendTm(data,size);
 		if(result != RETURN_OK) {
-			error << "UDP Server: Could not send stored downlink data" << std::endl;
+			error << "TMTC Bridge: Could not send stored downlink data"
+			      << std::endl;
 			result = RETURN_FAILED;
 		}
 		counter ++;

From 9580f51c30590617084b2ef21b8c4fa4a23e0d92 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Apr 2020 14:16:46 +0200
Subject: [PATCH 0184/1774] removed self-inclusion

---
 devicehandlers/CookieIF.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index 6b2bb5598..715a8fd40 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -1,7 +1,6 @@
 #ifndef COOKIE_H_
 #define COOKIE_H_
-#include <framework/devicehandlers/CookieIF.h>
-#include <stdint.h>
+#include <cstdint>
 
 /**
  * @brief Physical address type

From a7d3b4c4a03a0ec2afee9ab0ec5021750fc80dca Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Apr 2020 15:05:51 +0200
Subject: [PATCH 0185/1774] added std:: before uint32_t typedef

---
 devicehandlers/CookieIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index 715a8fd40..5fbcd1980 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -5,7 +5,7 @@
 /**
  * @brief Physical address type
  */
-typedef uint32_t address_t;
+typedef std::uint32_t address_t;
 
 /**
  * @brief 	This datatype is used to identify different connection over a

From e77ca55b1d383afd0079152a4d6809d3e79a6a93 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Apr 2020 17:12:26 +0200
Subject: [PATCH 0186/1774] serial fixed array list adapter doc fix

---
 serialize/SerialFixedArrayListAdapter.h | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 6e13ff6f4..841e9b7aa 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -13,16 +13,17 @@
  * The sequence of objects is defined in the constructor by
  * using the setStart and setNext functions.
  *
- *  1. Buffers with a size header inside that class can be declared with
- *     @code
- *     SerialFixedArrayListAdapter<BUFFER_TYPE,
- *     		MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE> mySerialFixedArrayList(...).
- *     @endcode
- *  2. MAX_BUFFER_LENGTH specifies the maximum allowed number of elements
- *     in FixedArrayList.
- *  3. LENGTH_FIELD_TYPE specifies the data type of the buffer header
- *     containing the buffer size (defaults to 1 byte length field)
- *     that follows.
+ *  - Buffers with a size header inside that class can be declared with
+ *    @code
+ *    SerialFixedArrayListAdapter<BUFFER_TYPE,
+ *          MAX_SIZE, count_t> mySerialFixedArrayList(...).
+ *    @endcode
+ *
+ *  - MAX_SIZE: specifies the maximum allowed number of elements
+ *    in FixedArrayList.
+ *  - BUFFER_TYPE: specifies the data type of the buffer
+ *  - count_t: specifies the type/size of the length field
+ *    which defaults to one byte.
  *
  * @ingroup serialize
  */

From 36715e3f4cf98cb21049eaf2001129fe3acbe625 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 19 Apr 2020 12:06:28 +0200
Subject: [PATCH 0187/1774] test folder moved to separate test folder

for fsfw for now
---
 test/CatchExample.cpp                    |    51 -
 test/UnitTestClass.cpp                   |   302 -
 test/UnitTestClass.h                     |    84 -
 test/catch2/catch.hpp                    | 17618 ---------------------
 test/catch2/catch_reporter_automake.hpp  |    62 -
 test/catch2/catch_reporter_sonarqube.hpp |   181 -
 test/catch2/catch_reporter_tap.hpp       |   253 -
 test/catch2/catch_reporter_teamcity.hpp  |   219 -
 8 files changed, 18770 deletions(-)
 delete mode 100644 test/CatchExample.cpp
 delete mode 100644 test/UnitTestClass.cpp
 delete mode 100644 test/UnitTestClass.h
 delete mode 100644 test/catch2/catch.hpp
 delete mode 100644 test/catch2/catch_reporter_automake.hpp
 delete mode 100644 test/catch2/catch_reporter_sonarqube.hpp
 delete mode 100644 test/catch2/catch_reporter_tap.hpp
 delete mode 100644 test/catch2/catch_reporter_teamcity.hpp

diff --git a/test/CatchExample.cpp b/test/CatchExample.cpp
deleted file mode 100644
index 90fd1ed55..000000000
--- a/test/CatchExample.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-// Catch Example.
-// Does not work yet. Problems with linker without main and config folder.
-// propably because global object manager and some config files are not supplied
-// but mandatory for full compilation of the framework.
-// Let Catch provide main():
-
-#if defined(UNIT_TEST)
-#define CATCH_CONFIG_MAIN
-
-#include <framework/test/catch2/catch.hpp>
-#include <framework/test/UnitTestClass.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-int Factorial( int number ) {
-   return number <= 1 ? number : Factorial( number - 1 ) * number;  // fail
-// return number <= 1 ? 1      : Factorial( number - 1 ) * number;  // pass
-}
-
-
-
-TEST_CASE( "Factorial of 0 is 1 (fail)", "[single-file]" ) {
-    REQUIRE( Factorial(0) == 1 );
-}
-
-TEST_CASE( "Factorials of 1 and higher are computed (pass)", "[single-file]" ) {
-    REQUIRE( Factorial(1) == 1 );
-    REQUIRE( Factorial(2) == 2 );
-    REQUIRE( Factorial(3) == 6 );
-    REQUIRE( Factorial(10) == 3628800 );
-}
-
-TEST_CASE( "Custom test", "[single-file]" ) {
-    UnitTestClass unitTestClass;
-    REQUIRE( unitTestClass.test_autoserialization() == HasReturnvaluesIF::RETURN_OK );
-}
-
-// Compile & run:
-// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 010-TestCase 010-TestCase.cpp && ./010-TestCase --success
-// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 010-TestCase.cpp && 010-TestCase --success
-
-// Expected compact output (all assertions):
-//
-// prompt> 010-TestCase --reporter compact --success
-// 010-TestCase.cpp:14: failed: Factorial(0) == 1 for: 0 == 1
-// 010-TestCase.cpp:18: passed: Factorial(1) == 1 for: 1 == 1
-// 010-TestCase.cpp:19: passed: Factorial(2) == 2 for: 2 == 2
-// 010-TestCase.cpp:20: passed: Factorial(3) == 6 for: 6 == 6
-// 010-TestCase.cpp:21: passed: Factorial(10) == 3628800 for: 3628800 (0x375f00) == 3628800 (0x375f00)
-// Failed 1 test case, failed 1 assertion.
-
-#endif
diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
deleted file mode 100644
index a0f65a088..000000000
--- a/test/UnitTestClass.cpp
+++ /dev/null
@@ -1,302 +0,0 @@
-/**
- * @file 	UnitTestClass.cpp
- *
- * @date 	11.04.2020
- * @author 	R. Mueller
- */
-#include <framework/test/UnitTestClass.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerialBufferAdapter.h>
-
-#include <cstdlib>
-
-#if defined(UNIT_TEST)
-#include "catch.hpp"
-#define CATCH_CONFIG_MAIN
-
-TEST_CASE( "Serialization Size tests", "[single-file]") {
-   //REQUIRE(UnitTestClass::test_serialization == RETURN_OK );
-}
-#endif
-
-UnitTestClass::UnitTestClass() {}
-
-UnitTestClass::~UnitTestClass() {}
-
-ReturnValue_t UnitTestClass::perform_tests() {
-	ReturnValue_t result = test_serialization();
-	if(result != RETURN_OK) {
-		return result;
-	}
-
-	return RETURN_OK;
-}
-
-ReturnValue_t UnitTestClass::test_serialization() {
-	// Here, we test all serialization tools. First test basic cases.
-	ReturnValue_t result = test_endianness_tools();
-	if(result != RETURN_OK) {
-		return result;
-	}
-	result = test_autoserialization();
-	if(result != RETURN_OK) {
-		return result;
-	}
-	result = test_serial_buffer_adapter();
-	if(result != RETURN_OK) {
-		return result;
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t UnitTestClass::test_endianness_tools() {
-	test_array[0] = 0;
-	test_array[1] = 0;
-	uint16_t two_byte_value = 1;
-	size_t size = 0;
-	uint8_t* p_array = test_array.data();
-	AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, false);
-	// Little endian: Value one on first byte
-	if(test_array[0] != 1 and test_array[1] != 0) {
-		return put_error(TestIds::ENDIANNESS_TOOLS);
-
-	}
-
-	p_array = test_array.data();
-	size = 0;
-	AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, true);
-	// Big endian: Value one on second byte
-	if(test_array[0] != 0 and test_array[1] != 1) {
-		return put_error(TestIds::ENDIANNESS_TOOLS);
-	}
-
-	// Endianness paameter will be changed later.
-//	p_array = test_array.data();
-//	ssize_t ssize = size;
-//	// Resulting parameter should be big endian
-//	AutoSerializeAdapter::deSerialize(&two_byte_value,
-//			const_cast<const uint8_t **>(&p_array), &ssize, true);
-//	if(two_byte_value != 1) {
-//		return put_error(TestIds::ENDIANNESS_TOOLS);
-//	}
-//
-//	ssize = size;
-//	p_array = test_array.data();
-//	// Resulting parameter should be little endian
-//	AutoSerializeAdapter::deSerialize(&two_byte_value,
-//			const_cast<const uint8_t **>(&p_array), &ssize, false);
-//	if(two_byte_value != 256) {
-//		return put_error(TestIds::ENDIANNESS_TOOLS);
-//	}
-	return RETURN_OK;
-}
-
-ReturnValue_t UnitTestClass::test_autoserialization() {
-	current_id = TestIds::AUTO_SERIALIZATION_SIZE;
-	// Unit Test getSerializedSize
-	if(AutoSerializeAdapter::
-			getSerializedSize(&test_value_bool) != sizeof(test_value_bool) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_uint8) != sizeof(tv_uint8) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_uint16) != sizeof(tv_uint16) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_uint32) != sizeof(tv_uint32) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_uint64) != sizeof(tv_uint64) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_int8) != sizeof(tv_int8) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_double) != sizeof(tv_double) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_int16) != sizeof(tv_int16) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_int32) != sizeof(tv_int32) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_float) != sizeof(tv_float))
-	{
-		return put_error(current_id);
-	}
-
-	// Unit Test AutoSerializeAdapter deserialize
-	current_id = TestIds::AUTO_SERIALIZATION_SERIALIZE;
-
-	size_t serialized_size = 0;
-	uint8_t * p_array = test_array.data();
-
-	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint8, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint16, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint32, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_int8, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_int16, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_int32, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint64, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_float, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_double, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_sfloat, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_sdouble, &p_array,
-			&serialized_size, test_array.size(), false);
-	// expected size is 1 + 1 + 2 + 4 + 1 + 2 + 4 + 8 + 4 + 8 + 4 + 8
-	if(serialized_size != 47) {
-		return put_error(current_id);
-	}
-
-	// Unit Test AutoSerializeAdapter serialize
-	current_id = TestIds::AUTO_SERIALIZATION_DESERIALIZE;
-	p_array = test_array.data();
-	size_t remaining_size = serialized_size;
-	AutoSerializeAdapter::deSerialize(&test_value_bool,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_uint8,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_uint16,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_uint32,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_int8,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_int16,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_int32,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_uint64,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_float,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_double,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_sfloat,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_sdouble,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-
-	if(test_value_bool != true or tv_uint8 != 5 or tv_uint16 != 283 or
-			tv_uint32 != 929221 or tv_uint64 != 2929329429 or tv_int8 != -16 or
-			tv_int16 != -829 or tv_int32 != -2312)
-	{
-		return put_error(current_id);
-	}
-
-	// These epsilon values were just guessed.. It appears to work though.
-	if(abs(tv_float - 8.214921) > 0.0001 or
-			abs(tv_double - 9.2132142141e8) > 0.01 or
-			abs(tv_sfloat - (-922.2321321)) > 0.0001 or
-			abs(tv_sdouble - (-2.2421e19)) > 0.01) {
-		return put_error(current_id);
-	}
-
-	// Check overflow
-	return RETURN_OK;
-}
-
-// TODO: Also test for constant buffers.
-ReturnValue_t UnitTestClass::test_serial_buffer_adapter() {
-	current_id = TestIds::SERIALIZATION_BUFFER_ADAPTER;
-
-	// I will skip endian swapper testing, its going to be changed anyway..
-	// uint8_t tv_uint8_swapped = EndianSwapper::swap(tv_uint8);
-
-	size_t serialized_size = 0;
-	test_value_bool = true;
-	uint8_t * p_array = test_array.data();
-	std::array<uint8_t, 5> test_serial_buffer {5, 4, 3, 2, 1};
-	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter =
-			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
-					test_serial_buffer.size(), false);
-	tv_uint16 = 16;
-
-	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
-			test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
-			test_array.size(), false);
-
-	if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
-			or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
-			or test_array[5] != 1)
-	{
-		return put_error(current_id);
-	}
-	memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
-	if(tv_uint16 != 16) {
-		return put_error(current_id);
-	}
-
-	// Serialize with size field
-	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter2 =
-			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
-					test_serial_buffer.size(), true);
-	serialized_size = 0;
-	p_array = test_array.data();
-	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
-			test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter2, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
-			test_array.size(), false);
-
-	if(serialized_size != 9 or test_array[0] != true or test_array[1] != 5
-			or test_array[2] != 5 or test_array[3] != 4 or test_array[4] != 3
-			or test_array[5] != 2 or test_array[6] != 1)
-	{
-		return put_error(current_id);
-	}
-	memcpy(&tv_uint16, test_array.data() + 7, sizeof(tv_uint16));
-	if(tv_uint16 != 16) {
-		return put_error(current_id);
-	}
-
-	// Serialize with size field
-	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter3 =
-			SerialBufferAdapter<uint8_t>(
-			const_cast<const uint8_t*>(test_serial_buffer.data()),
-			test_serial_buffer.size(), false);
-	serialized_size = 0;
-	p_array = test_array.data();
-	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
-			test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter3, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
-			test_array.size(), false);
-
-	if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
-			or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
-			or test_array[5] != 1)
-	{
-		return put_error(current_id);
-	}
-	memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
-	if(tv_uint16 != 16) {
-		return put_error(current_id);
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t UnitTestClass::put_error(TestIds currentId) {
-	auto errorIter = testResultMap.find(currentId);
-	if(errorIter != testResultMap.end()) {
-		testResultMap.emplace(currentId, 1);
-	}
-	else {
-		errorIter->second ++;
-	}
-	error << "Unit Tester failed at test ID "
-			<< static_cast<uint32_t>(currentId) << "\r\n" << std::flush;
-	return RETURN_FAILED;
-}
-
diff --git a/test/UnitTestClass.h b/test/UnitTestClass.h
deleted file mode 100644
index ffc7a2a2b..000000000
--- a/test/UnitTestClass.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/**
- * @file 	UnitTestClass.h
- *
- * @date 	11.04.2020
- * @author 	R. Mueller
- */
-
-#ifndef FRAMEWORK_TEST_UNITTESTCLASS_H_
-#define FRAMEWORK_TEST_UNITTESTCLASS_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-#include <map>
-#include <vector>
-
-/**
- * We could start doing basic forms of Unit Testing (without a framework, first)
- * for framework components. This could include:
- *
- *  1. TMTC Services
- *  2. Serialization tools
- *  3. Framework internal algorithms
- *
- *  TODO: Maybe use specialized framework.
- */
-
-class UnitTestClass: public HasReturnvaluesIF {
-public:
-	UnitTestClass();
-	virtual~ UnitTestClass();
-
-	enum class TestIds {
-		ENDIANNESS_TOOLS,
-		AUTO_SERIALIZATION_SIZE,
-		AUTO_SERIALIZATION_SERIALIZE,
-		AUTO_SERIALIZATION_DESERIALIZE ,
-		SERIALIZATION_BUFFER_ADAPTER,
-		SERIALIZATION_FIXED_ARRAY_LIST_ADAPTER,
-		SERIALIZATION_COMBINATION,
-		TMTC_SERVICES ,
-		MISC
-	};
-
-	/**
-	 * Some function which calls all other tests
-	 * @return
-	 */
-	ReturnValue_t perform_tests();
-
-	ReturnValue_t test_serialization();
-	ReturnValue_t test_autoserialization();
-	ReturnValue_t test_serial_buffer_adapter();
-	ReturnValue_t test_endianness_tools();
-private:
-	uint32_t errorCounter = 0;
-	TestIds current_id = TestIds::MISC;
-	std::array<uint8_t, 512> test_array;
-
-	using error_count_t =  uint8_t;
-	using TestResultMap = std::map<TestIds, error_count_t>;
-	using TestBuffer = std::vector<uint8_t>;
-	TestResultMap testResultMap;
-
-	// POD test values
-	bool test_value_bool = true;
-	uint8_t tv_uint8   {5};
-	uint16_t tv_uint16 {283};
-	uint32_t tv_uint32 {929221};
-	uint64_t tv_uint64 {2929329429};
-
-	int8_t tv_int8 {-16};
-	int16_t tv_int16 {-829};
-	int32_t tv_int32 {-2312};
-
-	float tv_float {8.2149214};
-	float tv_sfloat = {-922.2321321};
-	double tv_double {9.2132142141e8};
-	double tv_sdouble {-2.2421e19};
-
-	ReturnValue_t put_error(TestIds currentId);
-};
-
-
-#endif /* FRAMEWORK_TEST_UNITTESTCLASS_H_ */
diff --git a/test/catch2/catch.hpp b/test/catch2/catch.hpp
deleted file mode 100644
index 51618b38e..000000000
--- a/test/catch2/catch.hpp
+++ /dev/null
@@ -1,17618 +0,0 @@
-/*
- *  Catch v2.11.3
- *  Generated: 2020-03-19 13:44:21.042491
- *  ----------------------------------------------------------
- *  This file has been merged from multiple headers. Please don't edit it directly
- *  Copyright (c) 2020 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-// start catch.hpp
-
-
-#define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 11
-#define CATCH_VERSION_PATCH 3
-
-#ifdef __clang__
-#    pragma clang system_header
-#elif defined __GNUC__
-#    pragma GCC system_header
-#endif
-
-// start catch_suppress_warnings.h
-
-#ifdef __clang__
-#   ifdef __ICC // icpc defines the __clang__ macro
-#       pragma warning(push)
-#       pragma warning(disable: 161 1682)
-#   else // __ICC
-#       pragma clang diagnostic push
-#       pragma clang diagnostic ignored "-Wpadded"
-#       pragma clang diagnostic ignored "-Wswitch-enum"
-#       pragma clang diagnostic ignored "-Wcovered-switch-default"
-#    endif
-#elif defined __GNUC__
-     // Because REQUIREs trigger GCC's -Wparentheses, and because still
-     // supported version of g++ have only buggy support for _Pragmas,
-     // Wparentheses have to be suppressed globally.
-#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
-
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wunused-variable"
-#    pragma GCC diagnostic ignored "-Wpadded"
-#endif
-// end catch_suppress_warnings.h
-#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
-#  define CATCH_IMPL
-#  define CATCH_CONFIG_ALL_PARTS
-#endif
-
-// In the impl file, we want to have access to all parts of the headers
-// Can also be used to sanely support PCHs
-#if defined(CATCH_CONFIG_ALL_PARTS)
-#  define CATCH_CONFIG_EXTERNAL_INTERFACES
-#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#    undef CATCH_CONFIG_DISABLE_MATCHERS
-#  endif
-#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  endif
-#endif
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-// start catch_platform.h
-
-#ifdef __APPLE__
-# include <TargetConditionals.h>
-# if TARGET_OS_OSX == 1
-#  define CATCH_PLATFORM_MAC
-# elif TARGET_OS_IPHONE == 1
-#  define CATCH_PLATFORM_IPHONE
-# endif
-
-#elif defined(linux) || defined(__linux) || defined(__linux__)
-#  define CATCH_PLATFORM_LINUX
-
-#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
-#  define CATCH_PLATFORM_WINDOWS
-#endif
-
-// end catch_platform.h
-
-#ifdef CATCH_IMPL
-#  ifndef CLARA_CONFIG_MAIN
-#    define CLARA_CONFIG_MAIN_NOT_DEFINED
-#    define CLARA_CONFIG_MAIN
-#  endif
-#endif
-
-// start catch_user_interfaces.h
-
-namespace Catch {
-    unsigned int rngSeed();
-}
-
-// end catch_user_interfaces.h
-// start catch_tag_alias_autoregistrar.h
-
-// start catch_common.h
-
-// start catch_compiler_capabilities.h
-
-// Detect a number of compiler features - by compiler
-// The following features are defined:
-//
-// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
-// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
-// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
-// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
-// ****************
-// Note to maintainers: if new toggles are added please document them
-// in configuration.md, too
-// ****************
-
-// In general each macro has a _NO_<feature name> form
-// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
-// Many features, at point of detection, define an _INTERNAL_ macro, so they
-// can be combined, en-mass, with the _NO_ forms later.
-
-#ifdef __cplusplus
-
-#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
-#    define CATCH_CPP14_OR_GREATER
-#  endif
-
-#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-#    define CATCH_CPP17_OR_GREATER
-#  endif
-
-#endif
-
-#if defined(CATCH_CPP17_OR_GREATER)
-#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif
-
-// We have to avoid both ICC and Clang, because they try to mask themselves
-// as gcc, and we want only GCC in this block
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
-
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
-
-#endif
-
-#if defined(__clang__)
-
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
-
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
-
-#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
-         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
-
-#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
-
-#endif // __clang__
-
-////////////////////////////////////////////////////////////////////////////////
-// Assume that non-Windows platforms support posix signals by default
-#if !defined(CATCH_PLATFORM_WINDOWS)
-    #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// We know some environments not to support full POSIX signals
-#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
-    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#endif
-
-#ifdef __OS400__
-#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#       define CATCH_CONFIG_COLOUR_NONE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Android somehow still does not support std::to_string
-#if defined(__ANDROID__)
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Not all Windows environments support SEH properly
-#if defined(__MINGW32__)
-#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// PS4
-#if defined(__ORBIS__)
-#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Cygwin
-#ifdef __CYGWIN__
-
-// Required for some versions of Cygwin to declare gettimeofday
-// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
-#   define _BSD_SOURCE
-// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
-// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
-# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
-           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
-
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-
-# endif
-#endif // __CYGWIN__
-
-////////////////////////////////////////////////////////////////////////////////
-// Visual C++
-#if defined(_MSC_VER)
-
-#  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
-#  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
-
-#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
-#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#  endif
-
-// Universal Windows platform does not support SEH
-// Or console colours (or console at all...)
-#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
-#    define CATCH_CONFIG_COLOUR_NONE
-#  else
-#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
-#  endif
-
-// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
-// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
-// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
-#  if !defined(__clang__) // Handle Clang masquerading for msvc
-#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
-#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#    endif // MSVC_TRADITIONAL
-#  endif // __clang__
-
-#endif // _MSC_VER
-
-#if defined(_REENTRANT) || defined(_MSC_VER)
-// Enable async processing, as -pthread is specified or no additional linking is required
-# define CATCH_INTERNAL_CONFIG_USE_ASYNC
-#endif // _MSC_VER
-
-////////////////////////////////////////////////////////////////////////////////
-// Check if we are compiled with -fno-exceptions or equivalent
-#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
-#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// DJGPP
-#ifdef __DJGPP__
-#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
-#endif // __DJGPP__
-
-////////////////////////////////////////////////////////////////////////////////
-// Embarcadero C++Build
-#if defined(__BORLANDC__)
-    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Use of __COUNTER__ is suppressed during code analysis in
-// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
-// handled by it.
-// Otherwise all supported compilers support COUNTER macro,
-// but user still might want to turn it off
-#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
-    #define CATCH_INTERNAL_CONFIG_COUNTER
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-// RTX is a special version of Windows that is real time.
-// This means that it is detected as Windows, but does not provide
-// the same set of capabilities as real Windows does.
-#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
-    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
-    #define CATCH_CONFIG_COLOUR_NONE
-#endif
-
-#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
-#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-// Various stdlib support checks that require __has_include
-#if defined(__has_include)
-  // Check if string_view is available and usable
-  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
-  #endif
-
-  // Check if optional is available and usable
-  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
-  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if byte is available and usable
-  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
-  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if variant is available and usable
-  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-  #    if defined(__clang__) && (__clang_major__ < 8)
-         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
-         // fix should be in clang 8, workaround in libstdc++ 8.2
-  #      include <ciso646>
-  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #        define CATCH_CONFIG_NO_CPP17_VARIANT
-  #      else
-  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #    else
-  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #    endif // defined(__clang__) && (__clang_major__ < 8)
-  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // defined(__has_include)
-
-#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
-#   define CATCH_CONFIG_COUNTER
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
-#   define CATCH_CONFIG_WINDOWS_SEH
-#endif
-// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
-#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
-#   define CATCH_CONFIG_POSIX_SIGNALS
-#endif
-// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
-#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
-#   define CATCH_CONFIG_WCHAR
-#endif
-
-#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
-#    define CATCH_CONFIG_CPP11_TO_STRING
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#  define CATCH_CONFIG_CPP17_OPTIONAL
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
-#  define CATCH_CONFIG_CPP17_STRING_VIEW
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
-#  define CATCH_CONFIG_CPP17_VARIANT
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
-#  define CATCH_CONFIG_CPP17_BYTE
-#endif
-
-#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
-#  define CATCH_CONFIG_NEW_CAPTURE
-#endif
-
-#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-#  define CATCH_CONFIG_POLYFILL_ISNAN
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
-#  define CATCH_CONFIG_USE_ASYNC
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#  define CATCH_CONFIG_ANDROID_LOGWRITE
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-// Even if we do not think the compiler has that warning, we still have
-// to provide a macro that can be used by the code.
-#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-#endif
-#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
-#endif
-
-// The goal of this macro is to avoid evaluation of the arguments, but
-// still have the compiler warn on problems inside...
-#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
-#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
-#endif
-
-#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#elif defined(__clang__) && (__clang_major__ < 5)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-#define CATCH_TRY if ((true))
-#define CATCH_CATCH_ALL if ((false))
-#define CATCH_CATCH_ANON(type) if ((false))
-#else
-#define CATCH_TRY try
-#define CATCH_CATCH_ALL catch (...)
-#define CATCH_CATCH_ANON(type) catch (type)
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
-#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#endif
-
-// end catch_compiler_capabilities.h
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
-#ifdef CATCH_CONFIG_COUNTER
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
-#else
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
-#endif
-
-#include <iosfwd>
-#include <string>
-#include <cstdint>
-
-// We need a dummy global operator<< so we can bring it into Catch namespace later
-struct Catch_global_namespace_dummy {};
-std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
-
-namespace Catch {
-
-    struct CaseSensitive { enum Choice {
-        Yes,
-        No
-    }; };
-
-    class NonCopyable {
-        NonCopyable( NonCopyable const& )              = delete;
-        NonCopyable( NonCopyable && )                  = delete;
-        NonCopyable& operator = ( NonCopyable const& ) = delete;
-        NonCopyable& operator = ( NonCopyable && )     = delete;
-
-    protected:
-        NonCopyable();
-        virtual ~NonCopyable();
-    };
-
-    struct SourceLineInfo {
-
-        SourceLineInfo() = delete;
-        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
-        :   file( _file ),
-            line( _line )
-        {}
-
-        SourceLineInfo( SourceLineInfo const& other )            = default;
-        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
-        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
-        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
-
-        bool empty() const noexcept { return file[0] == '\0'; }
-        bool operator == ( SourceLineInfo const& other ) const noexcept;
-        bool operator < ( SourceLineInfo const& other ) const noexcept;
-
-        char const* file;
-        std::size_t line;
-    };
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
-
-    // Bring in operator<< from global namespace into Catch namespace
-    // This is necessary because the overload of operator<< above makes
-    // lookup stop at namespace Catch
-    using ::operator<<;
-
-    // Use this in variadic streaming macros to allow
-    //    >> +StreamEndStop
-    // as well as
-    //    >> stuff +StreamEndStop
-    struct StreamEndStop {
-        std::string operator+() const;
-    };
-    template<typename T>
-    T const& operator + ( T const& value, StreamEndStop ) {
-        return value;
-    }
-}
-
-#define CATCH_INTERNAL_LINEINFO \
-    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
-
-// end catch_common.h
-namespace Catch {
-
-    struct RegistrarForTagAliases {
-        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
-    };
-
-} // end namespace Catch
-
-#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-// end catch_tag_alias_autoregistrar.h
-// start catch_test_registry.h
-
-// start catch_interfaces_testcase.h
-
-#include <vector>
-
-namespace Catch {
-
-    class TestSpec;
-
-    struct ITestInvoker {
-        virtual void invoke () const = 0;
-        virtual ~ITestInvoker();
-    };
-
-    class TestCase;
-    struct IConfig;
-
-    struct ITestCaseRegistry {
-        virtual ~ITestCaseRegistry();
-        virtual std::vector<TestCase> const& getAllTests() const = 0;
-        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
-    };
-
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
-
-}
-
-// end catch_interfaces_testcase.h
-// start catch_stringref.h
-
-#include <cstddef>
-#include <string>
-#include <iosfwd>
-#include <cassert>
-
-namespace Catch {
-
-    /// A non-owning string class (similar to the forthcoming std::string_view)
-    /// Note that, because a StringRef may be a substring of another string,
-    /// it may not be null terminated.
-    class StringRef {
-    public:
-        using size_type = std::size_t;
-        using const_iterator = const char*;
-
-    private:
-        static constexpr char const* const s_empty = "";
-
-        char const* m_start = s_empty;
-        size_type m_size = 0;
-
-    public: // construction
-        constexpr StringRef() noexcept = default;
-
-        StringRef( char const* rawChars ) noexcept;
-
-        constexpr StringRef( char const* rawChars, size_type size ) noexcept
-        :   m_start( rawChars ),
-            m_size( size )
-        {}
-
-        StringRef( std::string const& stdString ) noexcept
-        :   m_start( stdString.c_str() ),
-            m_size( stdString.size() )
-        {}
-
-        explicit operator std::string() const {
-            return std::string(m_start, m_size);
-        }
-
-    public: // operators
-        auto operator == ( StringRef const& other ) const noexcept -> bool;
-        auto operator != (StringRef const& other) const noexcept -> bool {
-            return !(*this == other);
-        }
-
-        auto operator[] ( size_type index ) const noexcept -> char {
-            assert(index < m_size);
-            return m_start[index];
-        }
-
-    public: // named queries
-        constexpr auto empty() const noexcept -> bool {
-            return m_size == 0;
-        }
-        constexpr auto size() const noexcept -> size_type {
-            return m_size;
-        }
-
-        // Returns the current start pointer. If the StringRef is not
-        // null-terminated, throws std::domain_exception
-        auto c_str() const -> char const*;
-
-    public: // substrings and searches
-        // Returns a substring of [start, start + length).
-        // If start + length > size(), then the substring is [start, size()).
-        // If start > size(), then the substring is empty.
-        auto substr( size_type start, size_type length ) const noexcept -> StringRef;
-
-        // Returns the current start pointer. May not be null-terminated.
-        auto data() const noexcept -> char const*;
-
-        constexpr auto isNullTerminated() const noexcept -> bool {
-            return m_start[m_size] == '\0';
-        }
-
-    public: // iterators
-        constexpr const_iterator begin() const { return m_start; }
-        constexpr const_iterator end() const { return m_start + m_size; }
-    };
-
-    auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
-    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
-
-    constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
-        return StringRef( rawChars, size );
-    }
-} // namespace Catch
-
-constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
-    return Catch::StringRef( rawChars, size );
-}
-
-// end catch_stringref.h
-// start catch_preprocessor.hpp
-
-
-#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
-#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
-
-#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
-// MSVC needs more evaluations
-#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
-#else
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
-#endif
-
-#define CATCH_REC_END(...)
-#define CATCH_REC_OUT
-
-#define CATCH_EMPTY()
-#define CATCH_DEFER(id) id CATCH_EMPTY()
-
-#define CATCH_REC_GET_END2() 0, CATCH_REC_END
-#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
-#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
-#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
-#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
-#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
-
-#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-
-#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-
-// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
-// and passes userdata as the first parameter to each invocation,
-// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
-#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
-#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
-#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
-#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
-#else
-// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
-#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
-#endif
-
-#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
-#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
-
-#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
-#else
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
-#endif
-
-#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
-    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
-
-#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
-#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
-#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
-#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
-#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
-#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
-#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6)
-#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
-#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
-#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
-#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
-
-#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
-
-#define INTERNAL_CATCH_TYPE_GEN\
-    template<typename...> struct TypeList {};\
-    template<typename...Ts>\
-    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
-    template<template<typename...> class...> struct TemplateTypeList{};\
-    template<template<typename...> class...Cs>\
-    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
-    template<typename...>\
-    struct append;\
-    template<typename...>\
-    struct rewrap;\
-    template<template<typename...> class, typename...>\
-    struct create;\
-    template<template<typename...> class, typename>\
-    struct convert;\
-    \
-    template<typename T> \
-    struct append<T> { using type = T; };\
-    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
-    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
-    template< template<typename...> class L1, typename...E1, typename...Rest>\
-    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
-    \
-    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
-    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
-    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
-    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
-    \
-    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
-    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
-    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
-    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
-
-#define INTERNAL_CATCH_NTTP_1(signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
-    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
-    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
-    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
-    \
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
-    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
-    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
-    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
-    template<typename TestType> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
-        void test();\
-    }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
-        void test();\
-    }
-
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
-    template<typename TestType> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_NTTP_0
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
-#else
-#define INTERNAL_CATCH_NTTP_0(signature)
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
-#endif
-
-// end catch_preprocessor.hpp
-// start catch_meta.hpp
-
-
-#include <type_traits>
-
-namespace Catch {
-    template<typename T>
-    struct always_false : std::false_type {};
-
-    template <typename> struct true_given : std::true_type {};
-    struct is_callable_tester {
-        template <typename Fun, typename... Args>
-        true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
-        template <typename...>
-        std::false_type static test(...);
-    };
-
-    template <typename T>
-    struct is_callable;
-
-    template <typename Fun, typename... Args>
-    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
-
-#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
-    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
-    // replaced with std::invoke_result here. Also *_t format is preferred over
-    // typename *::type format.
-    template <typename Func, typename U>
-    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
-#else
-    template <typename Func, typename U>
-    using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
-#endif
-
-} // namespace Catch
-
-namespace mpl_{
-    struct na;
-}
-
-// end catch_meta.hpp
-namespace Catch {
-
-template<typename C>
-class TestInvokerAsMethod : public ITestInvoker {
-    void (C::*m_testAsMethod)();
-public:
-    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
-
-    void invoke() const override {
-        C obj;
-        (obj.*m_testAsMethod)();
-    }
-};
-
-auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
-
-template<typename C>
-auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
-    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
-}
-
-struct NameAndTags {
-    NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
-    StringRef name;
-    StringRef tags;
-};
-
-struct AutoReg : NonCopyable {
-    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
-    ~AutoReg();
-};
-
-} // end namespace Catch
-
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
-        namespace{                        \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test();              \
-            };                            \
-        }                                 \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
-        namespace{                                                                                  \
-            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        }                                                                                           \
-        }                                                                                           \
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-#endif
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
-        static void TestName(); \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE( ... ) \
-        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test(); \
-            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        } \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
-        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestName{\
-                TestName(){\
-                    int index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = int[];\
-                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-            return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS              \
-        template<typename TestType> static void TestFuncName();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
-            INTERNAL_CATCH_TYPE_GEN                                                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
-            template<typename... Types>                               \
-            struct TestName {                                         \
-                void reg_tests() {                                          \
-                    int index = 0;                                    \
-                    using expander = int[];                           \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */\
-                }                                                     \
-            };                                                        \
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                      \
-        }                                                             \
-        }                                                             \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
-        template<typename TestType>                                   \
-        static void TestFuncName()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        template<typename TestType> static void TestFunc();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-        INTERNAL_CATCH_TYPE_GEN\
-        template<typename... Types>                               \
-        struct TestName {                                         \
-            void reg_tests() {                                          \
-                int index = 0;                                    \
-                using expander = int[];                           \
-                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */\
-            }                                                     \
-        };\
-        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = typename convert<TestName, TmplList>::type; \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                      \
-        }}\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
-        template<typename TestType>                                   \
-        static void TestFunc()
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
-
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestNameClass{\
-                TestNameClass(){\
-                    int index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = int[];\
-                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-                return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        template<typename TestType> \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-                void test();\
-            };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
-            INTERNAL_CATCH_TYPE_GEN                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    int index = 0;\
-                    using expander = int[];\
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        template<typename TestType> \
-        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-            void test();\
-        };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    int index = 0;\
-                    using expander = int[];\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = typename convert<TestNameClass, TmplList>::type;\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }}\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
-
-// end catch_test_registry.h
-// start catch_capture.hpp
-
-// start catch_assertionhandler.h
-
-// start catch_assertioninfo.h
-
-// start catch_result_type.h
-
-namespace Catch {
-
-    // ResultWas::OfType enum
-    struct ResultWas { enum OfType {
-        Unknown = -1,
-        Ok = 0,
-        Info = 1,
-        Warning = 2,
-
-        FailureBit = 0x10,
-
-        ExpressionFailed = FailureBit | 1,
-        ExplicitFailure = FailureBit | 2,
-
-        Exception = 0x100 | FailureBit,
-
-        ThrewException = Exception | 1,
-        DidntThrowException = Exception | 2,
-
-        FatalErrorCondition = 0x200 | FailureBit
-
-    }; };
-
-    bool isOk( ResultWas::OfType resultType );
-    bool isJustInfo( int flags );
-
-    // ResultDisposition::Flags enum
-    struct ResultDisposition { enum Flags {
-        Normal = 0x01,
-
-        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
-        FalseTest = 0x04,           // Prefix expression with !
-        SuppressFail = 0x08         // Failures are reported but do not fail the test
-    }; };
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
-
-    bool shouldContinueOnFailure( int flags );
-    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
-    bool shouldSuppressFailure( int flags );
-
-} // end namespace Catch
-
-// end catch_result_type.h
-namespace Catch {
-
-    struct AssertionInfo
-    {
-        StringRef macroName;
-        SourceLineInfo lineInfo;
-        StringRef capturedExpression;
-        ResultDisposition::Flags resultDisposition;
-
-        // We want to delete this constructor but a compiler bug in 4.8 means
-        // the struct is then treated as non-aggregate
-        //AssertionInfo() = delete;
-    };
-
-} // end namespace Catch
-
-// end catch_assertioninfo.h
-// start catch_decomposer.h
-
-// start catch_tostring.h
-
-#include <vector>
-#include <cstddef>
-#include <type_traits>
-#include <string>
-// start catch_stream.h
-
-#include <iosfwd>
-#include <cstddef>
-#include <ostream>
-
-namespace Catch {
-
-    std::ostream& cout();
-    std::ostream& cerr();
-    std::ostream& clog();
-
-    class StringRef;
-
-    struct IStream {
-        virtual ~IStream();
-        virtual std::ostream& stream() const = 0;
-    };
-
-    auto makeStream( StringRef const &filename ) -> IStream const*;
-
-    class ReusableStringStream : NonCopyable {
-        std::size_t m_index;
-        std::ostream* m_oss;
-    public:
-        ReusableStringStream();
-        ~ReusableStringStream();
-
-        auto str() const -> std::string;
-
-        template<typename T>
-        auto operator << ( T const& value ) -> ReusableStringStream& {
-            *m_oss << value;
-            return *this;
-        }
-        auto get() -> std::ostream& { return *m_oss; }
-    };
-}
-
-// end catch_stream.h
-// start catch_interfaces_enum_values_registry.h
-
-#include <vector>
-
-namespace Catch {
-
-    namespace Detail {
-        struct EnumInfo {
-            StringRef m_name;
-            std::vector<std::pair<int, StringRef>> m_values;
-
-            ~EnumInfo();
-
-            StringRef lookup( int value ) const;
-        };
-    } // namespace Detail
-
-    struct IMutableEnumValuesRegistry {
-        virtual ~IMutableEnumValuesRegistry();
-
-        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
-
-        template<typename E>
-        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
-            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
-            std::vector<int> intValues;
-            intValues.reserve( values.size() );
-            for( auto enumValue : values )
-                intValues.push_back( static_cast<int>( enumValue ) );
-            return registerEnum( enumName, allEnums, intValues );
-        }
-    };
-
-} // Catch
-
-// end catch_interfaces_enum_values_registry.h
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-#include <string_view>
-#endif
-
-#ifdef __OBJC__
-// start catch_objc_arc.hpp
-
-#import <Foundation/Foundation.h>
-
-#ifdef __has_feature
-#define CATCH_ARC_ENABLED __has_feature(objc_arc)
-#else
-#define CATCH_ARC_ENABLED 0
-#endif
-
-void arcSafeRelease( NSObject* obj );
-id performOptionalSelector( id obj, SEL sel );
-
-#if !CATCH_ARC_ENABLED
-inline void arcSafeRelease( NSObject* obj ) {
-    [obj release];
-}
-inline id performOptionalSelector( id obj, SEL sel ) {
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED
-#define CATCH_ARC_STRONG
-#else
-inline void arcSafeRelease( NSObject* ){}
-inline id performOptionalSelector( id obj, SEL sel ) {
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
-#endif
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
-#define CATCH_ARC_STRONG __strong
-#endif
-
-// end catch_objc_arc.hpp
-#endif
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
-#endif
-
-namespace Catch {
-    namespace Detail {
-
-        extern const std::string unprintableString;
-
-        std::string rawMemoryToString( const void *object, std::size_t size );
-
-        template<typename T>
-        std::string rawMemoryToString( const T& object ) {
-          return rawMemoryToString( &object, sizeof(object) );
-        }
-
-        template<typename T>
-        class IsStreamInsertable {
-            template<typename Stream, typename U>
-            static auto test(int)
-                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
-
-            template<typename, typename>
-            static auto test(...)->std::false_type;
-
-        public:
-            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
-        };
-
-        template<typename E>
-        std::string convertUnknownEnumToString( E e );
-
-        template<typename T>
-        typename std::enable_if<
-            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
-        std::string>::type convertUnstreamable( T const& ) {
-            return Detail::unprintableString;
-        }
-        template<typename T>
-        typename std::enable_if<
-            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
-         std::string>::type convertUnstreamable(T const& ex) {
-            return ex.what();
-        }
-
-        template<typename T>
-        typename std::enable_if<
-            std::is_enum<T>::value
-        , std::string>::type convertUnstreamable( T const& value ) {
-            return convertUnknownEnumToString( value );
-        }
-
-#if defined(_MANAGED)
-        //! Convert a CLR string to a utf8 std::string
-        template<typename T>
-        std::string clrReferenceToString( T^ ref ) {
-            if (ref == nullptr)
-                return std::string("null");
-            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
-            cli::pin_ptr<System::Byte> p = &bytes[0];
-            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
-        }
-#endif
-
-    } // namespace Detail
-
-    // If we decide for C++14, change these to enable_if_ts
-    template <typename T, typename = void>
-    struct StringMaker {
-        template <typename Fake = T>
-        static
-        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert(const Fake& value) {
-                ReusableStringStream rss;
-                // NB: call using the function-like syntax to avoid ambiguity with
-                // user-defined templated operator<< under clang.
-                rss.operator<<(value);
-                return rss.str();
-        }
-
-        template <typename Fake = T>
-        static
-        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert( const Fake& value ) {
-#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
-            return Detail::convertUnstreamable(value);
-#else
-            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
-#endif
-        }
-    };
-
-    namespace Detail {
-
-        // This function dispatches all stringification requests inside of Catch.
-        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
-        template <typename T>
-        std::string stringify(const T& e) {
-            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
-        }
-
-        template<typename E>
-        std::string convertUnknownEnumToString( E e ) {
-            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
-        }
-
-#if defined(_MANAGED)
-        template <typename T>
-        std::string stringify( T^ e ) {
-            return ::Catch::StringMaker<T^>::convert(e);
-        }
-#endif
-
-    } // namespace Detail
-
-    // Some predefined specializations
-
-    template<>
-    struct StringMaker<std::string> {
-        static std::string convert(const std::string& str);
-    };
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::string_view> {
-        static std::string convert(std::string_view str);
-    };
-#endif
-
-    template<>
-    struct StringMaker<char const *> {
-        static std::string convert(char const * str);
-    };
-    template<>
-    struct StringMaker<char *> {
-        static std::string convert(char * str);
-    };
-
-#ifdef CATCH_CONFIG_WCHAR
-    template<>
-    struct StringMaker<std::wstring> {
-        static std::string convert(const std::wstring& wstr);
-    };
-
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::wstring_view> {
-        static std::string convert(std::wstring_view str);
-    };
-# endif
-
-    template<>
-    struct StringMaker<wchar_t const *> {
-        static std::string convert(wchar_t const * str);
-    };
-    template<>
-    struct StringMaker<wchar_t *> {
-        static std::string convert(wchar_t * str);
-    };
-#endif
-
-    // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
-    //      while keeping string semantics?
-    template<int SZ>
-    struct StringMaker<char[SZ]> {
-        static std::string convert(char const* str) {
-            return ::Catch::Detail::stringify(std::string{ str });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<signed char[SZ]> {
-        static std::string convert(signed char const* str) {
-            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<unsigned char[SZ]> {
-        static std::string convert(unsigned char const* str) {
-            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
-        }
-    };
-
-#if defined(CATCH_CONFIG_CPP17_BYTE)
-    template<>
-    struct StringMaker<std::byte> {
-        static std::string convert(std::byte value);
-    };
-#endif // defined(CATCH_CONFIG_CPP17_BYTE)
-    template<>
-    struct StringMaker<int> {
-        static std::string convert(int value);
-    };
-    template<>
-    struct StringMaker<long> {
-        static std::string convert(long value);
-    };
-    template<>
-    struct StringMaker<long long> {
-        static std::string convert(long long value);
-    };
-    template<>
-    struct StringMaker<unsigned int> {
-        static std::string convert(unsigned int value);
-    };
-    template<>
-    struct StringMaker<unsigned long> {
-        static std::string convert(unsigned long value);
-    };
-    template<>
-    struct StringMaker<unsigned long long> {
-        static std::string convert(unsigned long long value);
-    };
-
-    template<>
-    struct StringMaker<bool> {
-        static std::string convert(bool b);
-    };
-
-    template<>
-    struct StringMaker<char> {
-        static std::string convert(char c);
-    };
-    template<>
-    struct StringMaker<signed char> {
-        static std::string convert(signed char c);
-    };
-    template<>
-    struct StringMaker<unsigned char> {
-        static std::string convert(unsigned char c);
-    };
-
-    template<>
-    struct StringMaker<std::nullptr_t> {
-        static std::string convert(std::nullptr_t);
-    };
-
-    template<>
-    struct StringMaker<float> {
-        static std::string convert(float value);
-        static int precision;
-    };
-
-    template<>
-    struct StringMaker<double> {
-        static std::string convert(double value);
-        static int precision;
-    };
-
-    template <typename T>
-    struct StringMaker<T*> {
-        template <typename U>
-        static std::string convert(U* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-    template <typename R, typename C>
-    struct StringMaker<R C::*> {
-        static std::string convert(R C::* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-#if defined(_MANAGED)
-    template <typename T>
-    struct StringMaker<T^> {
-        static std::string convert( T^ ref ) {
-            return ::Catch::Detail::clrReferenceToString(ref);
-        }
-    };
-#endif
-
-    namespace Detail {
-        template<typename InputIterator>
-        std::string rangeToString(InputIterator first, InputIterator last) {
-            ReusableStringStream rss;
-            rss << "{ ";
-            if (first != last) {
-                rss << ::Catch::Detail::stringify(*first);
-                for (++first; first != last; ++first)
-                    rss << ", " << ::Catch::Detail::stringify(*first);
-            }
-            rss << " }";
-            return rss.str();
-        }
-    }
-
-#ifdef __OBJC__
-    template<>
-    struct StringMaker<NSString*> {
-        static std::string convert(NSString * nsstring) {
-            if (!nsstring)
-                return "nil";
-            return std::string("@") + [nsstring UTF8String];
-        }
-    };
-    template<>
-    struct StringMaker<NSObject*> {
-        static std::string convert(NSObject* nsObject) {
-            return ::Catch::Detail::stringify([nsObject description]);
-        }
-
-    };
-    namespace Detail {
-        inline std::string stringify( NSString* nsstring ) {
-            return StringMaker<NSString*>::convert( nsstring );
-        }
-
-    } // namespace Detail
-#endif // __OBJC__
-
-} // namespace Catch
-
-//////////////////////////////////////////////////////
-// Separate std-lib types stringification, so it can be selectively enabled
-// This means that we do not bring in
-
-#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
-#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
-#endif
-
-// Separate std::pair specialization
-#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
-#include <utility>
-namespace Catch {
-    template<typename T1, typename T2>
-    struct StringMaker<std::pair<T1, T2> > {
-        static std::string convert(const std::pair<T1, T2>& pair) {
-            ReusableStringStream rss;
-            rss << "{ "
-                << ::Catch::Detail::stringify(pair.first)
-                << ", "
-                << ::Catch::Detail::stringify(pair.second)
-                << " }";
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-
-#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#include <optional>
-namespace Catch {
-    template<typename T>
-    struct StringMaker<std::optional<T> > {
-        static std::string convert(const std::optional<T>& optional) {
-            ReusableStringStream rss;
-            if (optional.has_value()) {
-                rss << ::Catch::Detail::stringify(*optional);
-            } else {
-                rss << "{ }";
-            }
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
-
-// Separate std::tuple specialization
-#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
-#include <tuple>
-namespace Catch {
-    namespace Detail {
-        template<
-            typename Tuple,
-            std::size_t N = 0,
-            bool = (N < std::tuple_size<Tuple>::value)
-            >
-            struct TupleElementPrinter {
-            static void print(const Tuple& tuple, std::ostream& os) {
-                os << (N ? ", " : " ")
-                    << ::Catch::Detail::stringify(std::get<N>(tuple));
-                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
-            }
-        };
-
-        template<
-            typename Tuple,
-            std::size_t N
-        >
-            struct TupleElementPrinter<Tuple, N, false> {
-            static void print(const Tuple&, std::ostream&) {}
-        };
-
-    }
-
-    template<typename ...Types>
-    struct StringMaker<std::tuple<Types...>> {
-        static std::string convert(const std::tuple<Types...>& tuple) {
-            ReusableStringStream rss;
-            rss << '{';
-            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
-            rss << " }";
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-
-#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
-#include <variant>
-namespace Catch {
-    template<>
-    struct StringMaker<std::monostate> {
-        static std::string convert(const std::monostate&) {
-            return "{ }";
-        }
-    };
-
-    template<typename... Elements>
-    struct StringMaker<std::variant<Elements...>> {
-        static std::string convert(const std::variant<Elements...>& variant) {
-            if (variant.valueless_by_exception()) {
-                return "{valueless variant}";
-            } else {
-                return std::visit(
-                    [](const auto& value) {
-                        return ::Catch::Detail::stringify(value);
-                    },
-                    variant
-                );
-            }
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-
-namespace Catch {
-    struct not_this_one {}; // Tag type for detecting which begin/ end are being selected
-
-    // Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
-    using std::begin;
-    using std::end;
-
-    not_this_one begin( ... );
-    not_this_one end( ... );
-
-    template <typename T>
-    struct is_range {
-        static const bool value =
-            !std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
-            !std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
-    };
-
-#if defined(_MANAGED) // Managed types are never ranges
-    template <typename T>
-    struct is_range<T^> {
-        static const bool value = false;
-    };
-#endif
-
-    template<typename Range>
-    std::string rangeToString( Range const& range ) {
-        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
-    }
-
-    // Handle vector<bool> specially
-    template<typename Allocator>
-    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
-        ReusableStringStream rss;
-        rss << "{ ";
-        bool first = true;
-        for( bool b : v ) {
-            if( first )
-                first = false;
-            else
-                rss << ", ";
-            rss << ::Catch::Detail::stringify( b );
-        }
-        rss << " }";
-        return rss.str();
-    }
-
-    template<typename R>
-    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
-        static std::string convert( R const& range ) {
-            return rangeToString( range );
-        }
-    };
-
-    template <typename T, int SZ>
-    struct StringMaker<T[SZ]> {
-        static std::string convert(T const(&arr)[SZ]) {
-            return rangeToString(arr);
-        }
-    };
-
-} // namespace Catch
-
-// Separate std::chrono::duration specialization
-#if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#include <ctime>
-#include <ratio>
-#include <chrono>
-
-namespace Catch {
-
-template <class Ratio>
-struct ratio_string {
-    static std::string symbol();
-};
-
-template <class Ratio>
-std::string ratio_string<Ratio>::symbol() {
-    Catch::ReusableStringStream rss;
-    rss << '[' << Ratio::num << '/'
-        << Ratio::den << ']';
-    return rss.str();
-}
-template <>
-struct ratio_string<std::atto> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::femto> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::pico> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::nano> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::micro> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::milli> {
-    static std::string symbol();
-};
-
-    ////////////
-    // std::chrono::duration specializations
-    template<typename Value, typename Ratio>
-    struct StringMaker<std::chrono::duration<Value, Ratio>> {
-        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " s";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " m";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " h";
-            return rss.str();
-        }
-    };
-
-    ////////////
-    // std::chrono::time_point specialization
-    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
-    template<typename Clock, typename Duration>
-    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
-        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
-            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
-        }
-    };
-    // std::chrono::time_point<system_clock> specialization
-    template<typename Duration>
-    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
-        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
-            auto converted = std::chrono::system_clock::to_time_t(time_point);
-
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &converted);
-#else
-            std::tm* timeInfo = std::gmtime(&converted);
-#endif
-
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-
-#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
-namespace Catch { \
-    template<> struct StringMaker<enumName> { \
-        static std::string convert( enumName value ) { \
-            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
-            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
-        } \
-    }; \
-}
-
-#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// end catch_tostring.h
-#include <iosfwd>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
-#pragma warning(disable:4018) // more "signed/unsigned mismatch"
-#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
-#pragma warning(disable:4180) // qualifier applied to function type has no meaning
-#pragma warning(disable:4800) // Forcing result to true or false
-#endif
-
-namespace Catch {
-
-    struct ITransientExpression {
-        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
-        auto getResult() const -> bool { return m_result; }
-        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
-
-        ITransientExpression( bool isBinaryExpression, bool result )
-        :   m_isBinaryExpression( isBinaryExpression ),
-            m_result( result )
-        {}
-
-        // We don't actually need a virtual destructor, but many static analysers
-        // complain if it's not here :-(
-        virtual ~ITransientExpression();
-
-        bool m_isBinaryExpression;
-        bool m_result;
-
-    };
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
-
-    template<typename LhsT, typename RhsT>
-    class BinaryExpr  : public ITransientExpression {
-        LhsT m_lhs;
-        StringRef m_op;
-        RhsT m_rhs;
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            formatReconstructedExpression
-                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
-        }
-
-    public:
-        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
-        :   ITransientExpression{ true, comparisonResult },
-            m_lhs( lhs ),
-            m_op( op ),
-            m_rhs( rhs )
-        {}
-
-        template<typename T>
-        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-    };
-
-    template<typename LhsT>
-    class UnaryExpr : public ITransientExpression {
-        LhsT m_lhs;
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            os << Catch::Detail::stringify( m_lhs );
-        }
-
-    public:
-        explicit UnaryExpr( LhsT lhs )
-        :   ITransientExpression{ false, static_cast<bool>(lhs) },
-            m_lhs( lhs )
-        {}
-    };
-
-    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
-    template<typename LhsT, typename RhsT>
-    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-    template<typename T>
-    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-
-    template<typename LhsT, typename RhsT>
-    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-    template<typename T>
-    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-
-    template<typename LhsT>
-    class ExprLhs {
-        LhsT m_lhs;
-    public:
-        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
-
-        template<typename RhsT>
-        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
-        }
-        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs == rhs, m_lhs, "==", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
-        }
-        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs != rhs, m_lhs, "!=", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
-        }
-        template<typename RhsT>
-        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
-        }
-        template<typename RhsT>
-        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
-        }
-        template<typename RhsT>
-        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<RhsT>::value,
-            "operator&& is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename RhsT>
-        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<RhsT>::value,
-            "operator|| is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
-            return UnaryExpr<LhsT>{ m_lhs };
-        }
-    };
-
-    void handleExpression( ITransientExpression const& expr );
-
-    template<typename T>
-    void handleExpression( ExprLhs<T> const& expr ) {
-        handleExpression( expr.makeUnaryExpr() );
-    }
-
-    struct Decomposer {
-        template<typename T>
-        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
-            return ExprLhs<T const&>{ lhs };
-        }
-
-        auto operator <=( bool value ) -> ExprLhs<bool> {
-            return ExprLhs<bool>{ value };
-        }
-    };
-
-} // end namespace Catch
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// end catch_decomposer.h
-// start catch_interfaces_capture.h
-
-#include <string>
-#include <chrono>
-
-namespace Catch {
-
-    class AssertionResult;
-    struct AssertionInfo;
-    struct SectionInfo;
-    struct SectionEndInfo;
-    struct MessageInfo;
-    struct MessageBuilder;
-    struct Counts;
-    struct AssertionReaction;
-    struct SourceLineInfo;
-
-    struct ITransientExpression;
-    struct IGeneratorTracker;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    struct BenchmarkInfo;
-    template <typename Duration = std::chrono::duration<double, std::nano>>
-    struct BenchmarkStats;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    struct IResultCapture {
-
-        virtual ~IResultCapture();
-
-        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
-                                        Counts& assertions ) = 0;
-        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
-        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
-
-        virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        virtual void benchmarkPreparing( std::string const& name ) = 0;
-        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
-        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
-        virtual void benchmarkFailed( std::string const& error ) = 0;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
-
-        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
-
-        virtual void handleFatalErrorCondition( StringRef message ) = 0;
-
-        virtual void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef const& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string const& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleIncomplete
-                (   AssertionInfo const& info ) = 0;
-        virtual void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) = 0;
-
-        virtual bool lastAssertionPassed() = 0;
-        virtual void assertionPassed() = 0;
-
-        // Deprecated, do not use:
-        virtual std::string getCurrentTestName() const = 0;
-        virtual const AssertionResult* getLastResult() const = 0;
-        virtual void exceptionEarlyReported() = 0;
-    };
-
-    IResultCapture& getResultCapture();
-}
-
-// end catch_interfaces_capture.h
-namespace Catch {
-
-    struct TestFailureException{};
-    struct AssertionResultData;
-    struct IResultCapture;
-    class RunContext;
-
-    class LazyExpression {
-        friend class AssertionHandler;
-        friend struct AssertionStats;
-        friend class RunContext;
-
-        ITransientExpression const* m_transientExpression = nullptr;
-        bool m_isNegated;
-    public:
-        LazyExpression( bool isNegated );
-        LazyExpression( LazyExpression const& other );
-        LazyExpression& operator = ( LazyExpression const& ) = delete;
-
-        explicit operator bool() const;
-
-        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
-    };
-
-    struct AssertionReaction {
-        bool shouldDebugBreak = false;
-        bool shouldThrow = false;
-    };
-
-    class AssertionHandler {
-        AssertionInfo m_assertionInfo;
-        AssertionReaction m_reaction;
-        bool m_completed = false;
-        IResultCapture& m_resultCapture;
-
-    public:
-        AssertionHandler
-            (   StringRef const& macroName,
-                SourceLineInfo const& lineInfo,
-                StringRef capturedExpression,
-                ResultDisposition::Flags resultDisposition );
-        ~AssertionHandler() {
-            if ( !m_completed ) {
-                m_resultCapture.handleIncomplete( m_assertionInfo );
-            }
-        }
-
-        template<typename T>
-        void handleExpr( ExprLhs<T> const& expr ) {
-            handleExpr( expr.makeUnaryExpr() );
-        }
-        void handleExpr( ITransientExpression const& expr );
-
-        void handleMessage(ResultWas::OfType resultType, StringRef const& message);
-
-        void handleExceptionThrownAsExpected();
-        void handleUnexpectedExceptionNotThrown();
-        void handleExceptionNotThrownAsExpected();
-        void handleThrowingCallSkipped();
-        void handleUnexpectedInflightException();
-
-        void complete();
-        void setCompleted();
-
-        // query
-        auto allowThrows() const -> bool;
-    };
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
-
-} // namespace Catch
-
-// end catch_assertionhandler.h
-// start catch_message.h
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    struct MessageInfo {
-        MessageInfo(    StringRef const& _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        ResultWas::OfType _type );
-
-        StringRef macroName;
-        std::string message;
-        SourceLineInfo lineInfo;
-        ResultWas::OfType type;
-        unsigned int sequence;
-
-        bool operator == ( MessageInfo const& other ) const;
-        bool operator < ( MessageInfo const& other ) const;
-    private:
-        static unsigned int globalCount;
-    };
-
-    struct MessageStream {
-
-        template<typename T>
-        MessageStream& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        ReusableStringStream m_stream;
-    };
-
-    struct MessageBuilder : MessageStream {
-        MessageBuilder( StringRef const& macroName,
-                        SourceLineInfo const& lineInfo,
-                        ResultWas::OfType type );
-
-        template<typename T>
-        MessageBuilder& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        MessageInfo m_info;
-    };
-
-    class ScopedMessage {
-    public:
-        explicit ScopedMessage( MessageBuilder const& builder );
-        ScopedMessage( ScopedMessage& duplicate ) = delete;
-        ScopedMessage( ScopedMessage&& old );
-        ~ScopedMessage();
-
-        MessageInfo m_info;
-        bool m_moved;
-    };
-
-    class Capturer {
-        std::vector<MessageInfo> m_messages;
-        IResultCapture& m_resultCapture = getResultCapture();
-        size_t m_captured = 0;
-    public:
-        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
-        ~Capturer();
-
-        void captureValue( size_t index, std::string const& value );
-
-        template<typename T>
-        void captureValues( size_t index, T const& value ) {
-            captureValue( index, Catch::Detail::stringify( value ) );
-        }
-
-        template<typename T, typename... Ts>
-        void captureValues( size_t index, T const& value, Ts const&... values ) {
-            captureValue( index, Catch::Detail::stringify(value) );
-            captureValues( index+1, values... );
-        }
-    };
-
-} // end namespace Catch
-
-// end catch_message.h
-#if !defined(CATCH_CONFIG_DISABLE)
-
-#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
-#else
-  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
-#endif
-
-#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-
-///////////////////////////////////////////////////////////////////////////////
-// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
-// macros.
-#define INTERNAL_CATCH_TRY
-#define INTERNAL_CATCH_CATCH( capturer )
-
-#else // CATCH_CONFIG_FAST_COMPILE
-
-#define INTERNAL_CATCH_TRY try
-#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
-
-#endif
-
-#define INTERNAL_CATCH_REACT( handler ) handler.complete();
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
-    do { \
-        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
-            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( !Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        try { \
-            static_cast<void>(__VA_ARGS__); \
-            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
-        } \
-        catch( ... ) { \
-            catchAssertionHandler.handleUnexpectedInflightException(); \
-        } \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(expr); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
-        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
-    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
-    varName.captureValues( 0, __VA_ARGS__ )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_INFO( macroName, log ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
-    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
-
-///////////////////////////////////////////////////////////////////////////////
-// Although this is matcher-based, it can be used with just a string
-#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-#endif // CATCH_CONFIG_DISABLE
-
-// end catch_capture.hpp
-// start catch_section.h
-
-// start catch_section_info.h
-
-// start catch_totals.h
-
-#include <cstddef>
-
-namespace Catch {
-
-    struct Counts {
-        Counts operator - ( Counts const& other ) const;
-        Counts& operator += ( Counts const& other );
-
-        std::size_t total() const;
-        bool allPassed() const;
-        bool allOk() const;
-
-        std::size_t passed = 0;
-        std::size_t failed = 0;
-        std::size_t failedButOk = 0;
-    };
-
-    struct Totals {
-
-        Totals operator - ( Totals const& other ) const;
-        Totals& operator += ( Totals const& other );
-
-        Totals delta( Totals const& prevTotals ) const;
-
-        int error = 0;
-        Counts assertions;
-        Counts testCases;
-    };
-}
-
-// end catch_totals.h
-#include <string>
-
-namespace Catch {
-
-    struct SectionInfo {
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name );
-
-        // Deprecated
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name,
-                std::string const& ) : SectionInfo( _lineInfo, _name ) {}
-
-        std::string name;
-        std::string description; // !Deprecated: this will always be empty
-        SourceLineInfo lineInfo;
-    };
-
-    struct SectionEndInfo {
-        SectionInfo sectionInfo;
-        Counts prevAssertions;
-        double durationInSeconds;
-    };
-
-} // end namespace Catch
-
-// end catch_section_info.h
-// start catch_timer.h
-
-#include <cstdint>
-
-namespace Catch {
-
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
-    auto getEstimatedClockResolution() -> uint64_t;
-
-    class Timer {
-        uint64_t m_nanoseconds = 0;
-    public:
-        void start();
-        auto getElapsedNanoseconds() const -> uint64_t;
-        auto getElapsedMicroseconds() const -> uint64_t;
-        auto getElapsedMilliseconds() const -> unsigned int;
-        auto getElapsedSeconds() const -> double;
-    };
-
-} // namespace Catch
-
-// end catch_timer.h
-#include <string>
-
-namespace Catch {
-
-    class Section : NonCopyable {
-    public:
-        Section( SectionInfo const& info );
-        ~Section();
-
-        // This indicates whether the section should be executed or not
-        explicit operator bool() const;
-
-    private:
-        SectionInfo m_info;
-
-        std::string m_name;
-        Counts m_assertions;
-        bool m_sectionIncluded;
-        Timer m_timer;
-    };
-
-} // end namespace Catch
-
-#define INTERNAL_CATCH_SECTION( ... ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-// end catch_section.h
-// start catch_interfaces_exception.h
-
-// start catch_interfaces_registry_hub.h
-
-#include <string>
-#include <memory>
-
-namespace Catch {
-
-    class TestCase;
-    struct ITestCaseRegistry;
-    struct IExceptionTranslatorRegistry;
-    struct IExceptionTranslator;
-    struct IReporterRegistry;
-    struct IReporterFactory;
-    struct ITagAliasRegistry;
-    struct IMutableEnumValuesRegistry;
-
-    class StartupExceptionRegistry;
-
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
-
-    struct IRegistryHub {
-        virtual ~IRegistryHub();
-
-        virtual IReporterRegistry const& getReporterRegistry() const = 0;
-        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
-        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
-        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
-
-        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
-    };
-
-    struct IMutableRegistryHub {
-        virtual ~IMutableRegistryHub();
-        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerTest( TestCase const& testInfo ) = 0;
-        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
-        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
-        virtual void registerStartupException() noexcept = 0;
-        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
-    };
-
-    IRegistryHub const& getRegistryHub();
-    IMutableRegistryHub& getMutableRegistryHub();
-    void cleanUp();
-    std::string translateActiveException();
-
-}
-
-// end catch_interfaces_registry_hub.h
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
-        static std::string translatorName( signature )
-#endif
-
-#include <exception>
-#include <string>
-#include <vector>
-
-namespace Catch {
-    using exceptionTranslateFunction = std::string(*)();
-
-    struct IExceptionTranslator;
-    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
-
-    struct IExceptionTranslator {
-        virtual ~IExceptionTranslator();
-        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
-    };
-
-    struct IExceptionTranslatorRegistry {
-        virtual ~IExceptionTranslatorRegistry();
-
-        virtual std::string translateActiveException() const = 0;
-    };
-
-    class ExceptionTranslatorRegistrar {
-        template<typename T>
-        class ExceptionTranslator : public IExceptionTranslator {
-        public:
-
-            ExceptionTranslator( std::string(*translateFunction)( T& ) )
-            : m_translateFunction( translateFunction )
-            {}
-
-            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
-                try {
-                    if( it == itEnd )
-                        std::rethrow_exception(std::current_exception());
-                    else
-                        return (*it)->translate( it+1, itEnd );
-                }
-                catch( T& ex ) {
-                    return m_translateFunction( ex );
-                }
-            }
-
-        protected:
-            std::string(*m_translateFunction)( T& );
-        };
-
-    public:
-        template<typename T>
-        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
-            getMutableRegistryHub().registerTranslator
-                ( new ExceptionTranslator<T>( translateFunction ) );
-        }
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
-    static std::string translatorName( signature ); \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-    static std::string translatorName( signature )
-
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// end catch_interfaces_exception.h
-// start catch_approx.h
-
-#include <type_traits>
-
-namespace Catch {
-namespace Detail {
-
-    class Approx {
-    private:
-        bool equalityComparisonImpl(double other) const;
-        // Validates the new margin (margin >= 0)
-        // out-of-line to avoid including stdexcept in the header
-        void setMargin(double margin);
-        // Validates the new epsilon (0 < epsilon < 1)
-        // out-of-line to avoid including stdexcept in the header
-        void setEpsilon(double epsilon);
-
-    public:
-        explicit Approx ( double value );
-
-        static Approx custom();
-
-        Approx operator-() const;
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx operator()( T const& value ) {
-            Approx approx( static_cast<double>(value) );
-            approx.m_epsilon = m_epsilon;
-            approx.m_margin = m_margin;
-            approx.m_scale = m_scale;
-            return approx;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        explicit Approx( T const& value ): Approx(static_cast<double>(value))
-        {}
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( const T& lhs, Approx const& rhs ) {
-            auto lhs_v = static_cast<double>(lhs);
-            return rhs.equalityComparisonImpl(lhs_v);
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( Approx const& lhs, const T& rhs ) {
-            return operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( T const& lhs, Approx const& rhs ) {
-            return !operator==( lhs, rhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( Approx const& lhs, T const& rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& epsilon( T const& newEpsilon ) {
-            double epsilonAsDouble = static_cast<double>(newEpsilon);
-            setEpsilon(epsilonAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& margin( T const& newMargin ) {
-            double marginAsDouble = static_cast<double>(newMargin);
-            setMargin(marginAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& scale( T const& newScale ) {
-            m_scale = static_cast<double>(newScale);
-            return *this;
-        }
-
-        std::string toString() const;
-
-    private:
-        double m_epsilon;
-        double m_margin;
-        double m_scale;
-        double m_value;
-    };
-} // end namespace Detail
-
-namespace literals {
-    Detail::Approx operator "" _a(long double val);
-    Detail::Approx operator "" _a(unsigned long long val);
-} // end namespace literals
-
-template<>
-struct StringMaker<Catch::Detail::Approx> {
-    static std::string convert(Catch::Detail::Approx const& value);
-};
-
-} // end namespace Catch
-
-// end catch_approx.h
-// start catch_string_manip.h
-
-#include <string>
-#include <iosfwd>
-#include <vector>
-
-namespace Catch {
-
-    bool startsWith( std::string const& s, std::string const& prefix );
-    bool startsWith( std::string const& s, char prefix );
-    bool endsWith( std::string const& s, std::string const& suffix );
-    bool endsWith( std::string const& s, char suffix );
-    bool contains( std::string const& s, std::string const& infix );
-    void toLowerInPlace( std::string& s );
-    std::string toLower( std::string const& s );
-    //! Returns a new string without whitespace at the start/end
-    std::string trim( std::string const& str );
-    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
-    StringRef trim(StringRef ref);
-
-    // !!! Be aware, returns refs into original string - make sure original string outlives them
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
-
-    struct pluralise {
-        pluralise( std::size_t count, std::string const& label );
-
-        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
-
-        std::size_t m_count;
-        std::string m_label;
-    };
-}
-
-// end catch_string_manip.h
-#ifndef CATCH_CONFIG_DISABLE_MATCHERS
-// start catch_capture_matchers.h
-
-// start catch_matchers.h
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-        template<typename ArgT> struct MatchAllOf;
-        template<typename ArgT> struct MatchAnyOf;
-        template<typename ArgT> struct MatchNotOf;
-
-        class MatcherUntypedBase {
-        public:
-            MatcherUntypedBase() = default;
-            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
-            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
-            std::string toString() const;
-
-        protected:
-            virtual ~MatcherUntypedBase();
-            virtual std::string describe() const = 0;
-            mutable std::string m_cachedToString;
-        };
-
-#ifdef __clang__
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
-#endif
-
-        template<typename ObjectT>
-        struct MatcherMethod {
-            virtual bool match( ObjectT const& arg ) const = 0;
-        };
-
-#if defined(__OBJC__)
-        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
-        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
-        template<>
-        struct MatcherMethod<NSString*> {
-            virtual bool match( NSString* arg ) const = 0;
-        };
-#endif
-
-#ifdef __clang__
-#    pragma clang diagnostic pop
-#endif
-
-        template<typename T>
-        struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
-
-            MatchAllOf<T> operator && ( MatcherBase const& other ) const;
-            MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
-            MatchNotOf<T> operator ! () const;
-        };
-
-        template<typename ArgT>
-        struct MatchAllOf : MatcherBase<ArgT> {
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (!matcher->match(arg))
-                        return false;
-                }
-                return true;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " and ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
-                auto copy(*this);
-                copy.m_matchers.push_back( &other );
-                return copy;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-        template<typename ArgT>
-        struct MatchAnyOf : MatcherBase<ArgT> {
-
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (matcher->match(arg))
-                        return true;
-                }
-                return false;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " or ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
-                auto copy(*this);
-                copy.m_matchers.push_back( &other );
-                return copy;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-
-        template<typename ArgT>
-        struct MatchNotOf : MatcherBase<ArgT> {
-
-            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
-
-            bool match( ArgT const& arg ) const override {
-                return !m_underlyingMatcher.match( arg );
-            }
-
-            std::string describe() const override {
-                return "not " + m_underlyingMatcher.toString();
-            }
-            MatcherBase<ArgT> const& m_underlyingMatcher;
-        };
-
-        template<typename T>
-        MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
-            return MatchAllOf<T>() && *this && other;
-        }
-        template<typename T>
-        MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
-            return MatchAnyOf<T>() || *this || other;
-        }
-        template<typename T>
-        MatchNotOf<T> MatcherBase<T>::operator ! () const {
-            return MatchNotOf<T>( *this );
-        }
-
-    } // namespace Impl
-
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
-
-} // namespace Catch
-
-// end catch_matchers.h
-// start catch_matchers_exception.hpp
-
-namespace Catch {
-namespace Matchers {
-namespace Exception {
-
-class ExceptionMessageMatcher : public MatcherBase<std::exception> {
-    std::string m_message;
-public:
-
-    ExceptionMessageMatcher(std::string const& message):
-        m_message(message)
-    {}
-
-    bool match(std::exception const& ex) const override;
-
-    std::string describe() const override;
-};
-
-} // namespace Exception
-
-Exception::ExceptionMessageMatcher Message(std::string const& message);
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_exception.hpp
-// start catch_matchers_floating.h
-
-namespace Catch {
-namespace Matchers {
-
-    namespace Floating {
-
-        enum class FloatingPointKind : uint8_t;
-
-        struct WithinAbsMatcher : MatcherBase<double> {
-            WithinAbsMatcher(double target, double margin);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            double m_margin;
-        };
-
-        struct WithinUlpsMatcher : MatcherBase<double> {
-            WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            uint64_t m_ulps;
-            FloatingPointKind m_type;
-        };
-
-        // Given IEEE-754 format for floats and doubles, we can assume
-        // that float -> double promotion is lossless. Given this, we can
-        // assume that if we do the standard relative comparison of
-        // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
-        // the same result if we do this for floats, as if we do this for
-        // doubles that were promoted from floats.
-        struct WithinRelMatcher : MatcherBase<double> {
-            WithinRelMatcher(double target, double epsilon);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            double m_epsilon;
-        };
-
-    } // namespace Floating
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
-    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
-    Floating::WithinAbsMatcher WithinAbs(double target, double margin);
-    Floating::WithinRelMatcher WithinRel(double target, double eps);
-    // defaults epsilon to 100*numeric_limits<double>::epsilon()
-    Floating::WithinRelMatcher WithinRel(double target);
-    Floating::WithinRelMatcher WithinRel(float target, float eps);
-    // defaults epsilon to 100*numeric_limits<float>::epsilon()
-    Floating::WithinRelMatcher WithinRel(float target);
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_floating.h
-// start catch_matchers_generic.hpp
-
-#include <functional>
-#include <string>
-
-namespace Catch {
-namespace Matchers {
-namespace Generic {
-
-namespace Detail {
-    std::string finalizeDescription(const std::string& desc);
-}
-
-template <typename T>
-class PredicateMatcher : public MatcherBase<T> {
-    std::function<bool(T const&)> m_predicate;
-    std::string m_description;
-public:
-
-    PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
-        :m_predicate(std::move(elem)),
-        m_description(Detail::finalizeDescription(descr))
-    {}
-
-    bool match( T const& item ) const override {
-        return m_predicate(item);
-    }
-
-    std::string describe() const override {
-        return m_description;
-    }
-};
-
-} // namespace Generic
-
-    // The following functions create the actual matcher objects.
-    // The user has to explicitly specify type to the function, because
-    // inferring std::function<bool(T const&)> is hard (but possible) and
-    // requires a lot of TMP.
-    template<typename T>
-    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
-        return Generic::PredicateMatcher<T>(predicate, description);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_generic.hpp
-// start catch_matchers_string.h
-
-#include <string>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace StdString {
-
-        struct CasedString
-        {
-            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
-            std::string adjustString( std::string const& str ) const;
-            std::string caseSensitivitySuffix() const;
-
-            CaseSensitive::Choice m_caseSensitivity;
-            std::string m_str;
-        };
-
-        struct StringMatcherBase : MatcherBase<std::string> {
-            StringMatcherBase( std::string const& operation, CasedString const& comparator );
-            std::string describe() const override;
-
-            CasedString m_comparator;
-            std::string m_operation;
-        };
-
-        struct EqualsMatcher : StringMatcherBase {
-            EqualsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct ContainsMatcher : StringMatcherBase {
-            ContainsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct StartsWithMatcher : StringMatcherBase {
-            StartsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct EndsWithMatcher : StringMatcherBase {
-            EndsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-
-        struct RegexMatcher : MatcherBase<std::string> {
-            RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
-            bool match( std::string const& matchee ) const override;
-            std::string describe() const override;
-
-        private:
-            std::string m_regex;
-            CaseSensitive::Choice m_caseSensitivity;
-        };
-
-    } // namespace StdString
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_string.h
-// start catch_matchers_vector.h
-
-#include <algorithm>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace Vector {
-        template<typename T>
-        struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
-
-            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
-
-            bool match(std::vector<T> const &v) const override {
-                for (auto const& el : v) {
-                    if (el == m_comparator) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
-
-            T const& m_comparator;
-        };
-
-        template<typename T>
-        struct ContainsMatcher : MatcherBase<std::vector<T>> {
-
-            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: see note in EqualsMatcher
-                if (m_comparator.size() > v.size())
-                    return false;
-                for (auto const& comparator : m_comparator) {
-                    auto present = false;
-                    for (const auto& el : v) {
-                        if (el == comparator) {
-                            present = true;
-                            break;
-                        }
-                    }
-                    if (!present) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
-
-            std::vector<T> const& m_comparator;
-        };
-
-        template<typename T>
-        struct EqualsMatcher : MatcherBase<std::vector<T>> {
-
-            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: This currently works if all elements can be compared using !=
-                // - a more general approach would be via a compare template that defaults
-                // to using !=. but could be specialised for, e.g. std::vector<T> etc
-                // - then just call that directly
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != v[i])
-                        return false;
-                return true;
-            }
-            std::string describe() const override {
-                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
-            }
-            std::vector<T> const& m_comparator;
-        };
-
-        template<typename T>
-        struct ApproxMatcher : MatcherBase<std::vector<T>> {
-
-            ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != approx(v[i]))
-                        return false;
-                return true;
-            }
-            std::string describe() const override {
-                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& epsilon( T const& newEpsilon ) {
-                approx.epsilon(newEpsilon);
-                return *this;
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& margin( T const& newMargin ) {
-                approx.margin(newMargin);
-                return *this;
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& scale( T const& newScale ) {
-                approx.scale(newScale);
-                return *this;
-            }
-
-            std::vector<T> const& m_comparator;
-            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
-        };
-
-        template<typename T>
-        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
-            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
-            bool match(std::vector<T> const& vec) const override {
-                // Note: This is a reimplementation of std::is_permutation,
-                //       because I don't want to include <algorithm> inside the common path
-                if (m_target.size() != vec.size()) {
-                    return false;
-                }
-                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
-            }
-
-            std::string describe() const override {
-                return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
-            }
-        private:
-            std::vector<T> const& m_target;
-        };
-
-    } // namespace Vector
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    template<typename T>
-    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
-        return Vector::ContainsMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
-        return Vector::ContainsElementMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
-        return Vector::EqualsMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::ApproxMatcher<T> Approx( std::vector<T> const& comparator ) {
-        return Vector::ApproxMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
-        return Vector::UnorderedEqualsMatcher<T>(target);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_vector.h
-namespace Catch {
-
-    template<typename ArgT, typename MatcherT>
-    class MatchExpr : public ITransientExpression {
-        ArgT const& m_arg;
-        MatcherT m_matcher;
-        StringRef m_matcherString;
-    public:
-        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
-        :   ITransientExpression{ true, matcher.match( arg ) },
-            m_arg( arg ),
-            m_matcher( matcher ),
-            m_matcherString( matcherString )
-        {}
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            auto matcherAsString = m_matcher.toString();
-            os << Catch::Detail::stringify( m_arg ) << ' ';
-            if( matcherAsString == Detail::unprintableString )
-                os << m_matcherString;
-            else
-                os << matcherAsString;
-        }
-    };
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
-
-    template<typename ArgT, typename MatcherT>
-    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
-        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
-    }
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__ ); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ex ) { \
-                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-// end catch_capture_matchers.h
-#endif
-// start catch_generators.hpp
-
-// start catch_interfaces_generatortracker.h
-
-
-#include <memory>
-
-namespace Catch {
-
-    namespace Generators {
-        class GeneratorUntypedBase {
-        public:
-            GeneratorUntypedBase() = default;
-            virtual ~GeneratorUntypedBase();
-            // Attempts to move the generator to the next element
-             //
-             // Returns true iff the move succeeded (and a valid element
-             // can be retrieved).
-            virtual bool next() = 0;
-        };
-        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
-
-    } // namespace Generators
-
-    struct IGeneratorTracker {
-        virtual ~IGeneratorTracker();
-        virtual auto hasGenerator() const -> bool = 0;
-        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
-        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
-    };
-
-} // namespace Catch
-
-// end catch_interfaces_generatortracker.h
-// start catch_enforce.h
-
-#include <exception>
-
-namespace Catch {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    template <typename Ex>
-    [[noreturn]]
-    void throw_exception(Ex const& e) {
-        throw e;
-    }
-#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
-    [[noreturn]]
-    void throw_exception(std::exception const& e);
-#endif
-
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg);
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg);
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg);
-
-} // namespace Catch;
-
-#define CATCH_MAKE_MSG(...) \
-    (Catch::ReusableStringStream() << __VA_ARGS__).str()
-
-#define CATCH_INTERNAL_ERROR(...) \
-    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
-
-#define CATCH_ERROR(...) \
-    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
-
-#define CATCH_RUNTIME_ERROR(...) \
-    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
-
-#define CATCH_ENFORCE( condition, ... ) \
-    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
-
-// end catch_enforce.h
-#include <memory>
-#include <vector>
-#include <cassert>
-
-#include <utility>
-#include <exception>
-
-namespace Catch {
-
-class GeneratorException : public std::exception {
-    const char* const m_msg = "";
-
-public:
-    GeneratorException(const char* msg):
-        m_msg(msg)
-    {}
-
-    const char* what() const noexcept override final;
-};
-
-namespace Generators {
-
-    // !TBD move this into its own location?
-    namespace pf{
-        template<typename T, typename... Args>
-        std::unique_ptr<T> make_unique( Args&&... args ) {
-            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-        }
-    }
-
-    template<typename T>
-    struct IGenerator : GeneratorUntypedBase {
-        virtual ~IGenerator() = default;
-
-        // Returns the current element of the generator
-        //
-        // \Precondition The generator is either freshly constructed,
-        // or the last call to `next()` returned true
-        virtual T const& get() const = 0;
-        using type = T;
-    };
-
-    template<typename T>
-    class SingleValueGenerator final : public IGenerator<T> {
-        T m_value;
-    public:
-        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
-
-        T const& get() const override {
-            return m_value;
-        }
-        bool next() override {
-            return false;
-        }
-    };
-
-    template<typename T>
-    class FixedValuesGenerator final : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
-            "FixedValuesGenerator does not support bools because of std::vector<bool>"
-            "specialization, use SingleValue Generator instead.");
-        std::vector<T> m_values;
-        size_t m_idx = 0;
-    public:
-        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
-
-        T const& get() const override {
-            return m_values[m_idx];
-        }
-        bool next() override {
-            ++m_idx;
-            return m_idx < m_values.size();
-        }
-    };
-
-    template <typename T>
-    class GeneratorWrapper final {
-        std::unique_ptr<IGenerator<T>> m_generator;
-    public:
-        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
-            m_generator(std::move(generator))
-        {}
-        T const& get() const {
-            return m_generator->get();
-        }
-        bool next() {
-            return m_generator->next();
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> value(T&& value) {
-        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
-    }
-    template <typename T>
-    GeneratorWrapper<T> values(std::initializer_list<T> values) {
-        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
-    }
-
-    template<typename T>
-    class Generators : public IGenerator<T> {
-        std::vector<GeneratorWrapper<T>> m_generators;
-        size_t m_current = 0;
-
-        void populate(GeneratorWrapper<T>&& generator) {
-            m_generators.emplace_back(std::move(generator));
-        }
-        void populate(T&& val) {
-            m_generators.emplace_back(value(std::forward<T>(val)));
-        }
-        template<typename U>
-        void populate(U&& val) {
-            populate(T(std::forward<U>(val)));
-        }
-        template<typename U, typename... Gs>
-        void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
-            populate(std::forward<U>(valueOrGenerator));
-            populate(std::forward<Gs>(moreGenerators)...);
-        }
-
-    public:
-        template <typename... Gs>
-        Generators(Gs &&... moreGenerators) {
-            m_generators.reserve(sizeof...(Gs));
-            populate(std::forward<Gs>(moreGenerators)...);
-        }
-
-        T const& get() const override {
-            return m_generators[m_current].get();
-        }
-
-        bool next() override {
-            if (m_current >= m_generators.size()) {
-                return false;
-            }
-            const bool current_status = m_generators[m_current].next();
-            if (!current_status) {
-                ++m_current;
-            }
-            return m_current < m_generators.size();
-        }
-    };
-
-    template<typename... Ts>
-    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
-        return values<std::tuple<Ts...>>( tuples );
-    }
-
-    // Tag type to signal that a generator sequence should convert arguments to a specific type
-    template <typename T>
-    struct as {};
-
-    template<typename T, typename... Gs>
-    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
-        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
-    }
-    template<typename T>
-    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
-        return Generators<T>(std::move(generator));
-    }
-    template<typename T, typename... Gs>
-    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
-    }
-    template<typename T, typename U, typename... Gs>
-    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
-    }
-
-    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
-
-    template<typename L>
-    // Note: The type after -> is weird, because VS2015 cannot parse
-    //       the expression used in the typedef inside, when it is in
-    //       return type. Yeah.
-    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
-        using UnderlyingType = typename decltype(generatorExpression())::type;
-
-        IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
-        if (!tracker.hasGenerator()) {
-            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
-        }
-
-        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
-        return generator.get();
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-#define GENERATE( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-#define GENERATE_COPY( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-#define GENERATE_REF( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-
-// end catch_generators.hpp
-// start catch_generators_generic.hpp
-
-namespace Catch {
-namespace Generators {
-
-    template <typename T>
-    class TakeGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        size_t m_returned = 0;
-        size_t m_target;
-    public:
-        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_target(target)
-        {
-            assert(target != 0 && "Empty generators are not allowed");
-        }
-        T const& get() const override {
-            return m_generator.get();
-        }
-        bool next() override {
-            ++m_returned;
-            if (m_returned >= m_target) {
-                return false;
-            }
-
-            const auto success = m_generator.next();
-            // If the underlying generator does not contain enough values
-            // then we cut short as well
-            if (!success) {
-                m_returned = m_target;
-            }
-            return success;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
-    }
-
-    template <typename T, typename Predicate>
-    class FilterGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        Predicate m_predicate;
-    public:
-        template <typename P = Predicate>
-        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_predicate(std::forward<P>(pred))
-        {
-            if (!m_predicate(m_generator.get())) {
-                // It might happen that there are no values that pass the
-                // filter. In that case we throw an exception.
-                auto has_initial_value = next();
-                if (!has_initial_value) {
-                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
-                }
-            }
-        }
-
-        T const& get() const override {
-            return m_generator.get();
-        }
-
-        bool next() override {
-            bool success = m_generator.next();
-            if (!success) {
-                return false;
-            }
-            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
-            return success;
-        }
-    };
-
-    template <typename T, typename Predicate>
-    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
-    }
-
-    template <typename T>
-    class RepeatGenerator : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
-            "RepeatGenerator currently does not support bools"
-            "because of std::vector<bool> specialization");
-        GeneratorWrapper<T> m_generator;
-        mutable std::vector<T> m_returned;
-        size_t m_target_repeats;
-        size_t m_current_repeat = 0;
-        size_t m_repeat_index = 0;
-    public:
-        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_target_repeats(repeats)
-        {
-            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
-        }
-
-        T const& get() const override {
-            if (m_current_repeat == 0) {
-                m_returned.push_back(m_generator.get());
-                return m_returned.back();
-            }
-            return m_returned[m_repeat_index];
-        }
-
-        bool next() override {
-            // There are 2 basic cases:
-            // 1) We are still reading the generator
-            // 2) We are reading our own cache
-
-            // In the first case, we need to poke the underlying generator.
-            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
-            if (m_current_repeat == 0) {
-                const auto success = m_generator.next();
-                if (!success) {
-                    ++m_current_repeat;
-                }
-                return m_current_repeat < m_target_repeats;
-            }
-
-            // In the second case, we need to move indices forward and check that we haven't run up against the end
-            ++m_repeat_index;
-            if (m_repeat_index == m_returned.size()) {
-                m_repeat_index = 0;
-                ++m_current_repeat;
-            }
-            return m_current_repeat < m_target_repeats;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
-    }
-
-    template <typename T, typename U, typename Func>
-    class MapGenerator : public IGenerator<T> {
-        // TBD: provide static assert for mapping function, for friendly error message
-        GeneratorWrapper<U> m_generator;
-        Func m_function;
-        // To avoid returning dangling reference, we have to save the values
-        T m_cache;
-    public:
-        template <typename F2 = Func>
-        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
-            m_generator(std::move(generator)),
-            m_function(std::forward<F2>(function)),
-            m_cache(m_function(m_generator.get()))
-        {}
-
-        T const& get() const override {
-            return m_cache;
-        }
-        bool next() override {
-            const auto success = m_generator.next();
-            if (success) {
-                m_cache = m_function(m_generator.get());
-            }
-            return success;
-        }
-    };
-
-    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
-        );
-    }
-
-    template <typename T, typename U, typename Func>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
-        );
-    }
-
-    template <typename T>
-    class ChunkGenerator final : public IGenerator<std::vector<T>> {
-        std::vector<T> m_chunk;
-        size_t m_chunk_size;
-        GeneratorWrapper<T> m_generator;
-        bool m_used_up = false;
-    public:
-        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
-            m_chunk_size(size), m_generator(std::move(generator))
-        {
-            m_chunk.reserve(m_chunk_size);
-            if (m_chunk_size != 0) {
-                m_chunk.push_back(m_generator.get());
-                for (size_t i = 1; i < m_chunk_size; ++i) {
-                    if (!m_generator.next()) {
-                        Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
-                    }
-                    m_chunk.push_back(m_generator.get());
-                }
-            }
-        }
-        std::vector<T> const& get() const override {
-            return m_chunk;
-        }
-        bool next() override {
-            m_chunk.clear();
-            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
-                if (!m_generator.next()) {
-                    return false;
-                }
-                m_chunk.push_back(m_generator.get());
-            }
-            return true;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<std::vector<T>>(
-            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
-        );
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-// end catch_generators_generic.hpp
-// start catch_generators_specific.hpp
-
-// start catch_context.h
-
-#include <memory>
-
-namespace Catch {
-
-    struct IResultCapture;
-    struct IRunner;
-    struct IConfig;
-    struct IMutableContext;
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-
-    struct IContext
-    {
-        virtual ~IContext();
-
-        virtual IResultCapture* getResultCapture() = 0;
-        virtual IRunner* getRunner() = 0;
-        virtual IConfigPtr const& getConfig() const = 0;
-    };
-
-    struct IMutableContext : IContext
-    {
-        virtual ~IMutableContext();
-        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
-        virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( IConfigPtr const& config ) = 0;
-
-    private:
-        static IMutableContext *currentContext;
-        friend IMutableContext& getCurrentMutableContext();
-        friend void cleanUpContext();
-        static void createContext();
-    };
-
-    inline IMutableContext& getCurrentMutableContext()
-    {
-        if( !IMutableContext::currentContext )
-            IMutableContext::createContext();
-        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
-        return *IMutableContext::currentContext;
-    }
-
-    inline IContext& getCurrentContext()
-    {
-        return getCurrentMutableContext();
-    }
-
-    void cleanUpContext();
-
-    class SimplePcg32;
-    SimplePcg32& rng();
-}
-
-// end catch_context.h
-// start catch_interfaces_config.h
-
-// start catch_option.hpp
-
-namespace Catch {
-
-    // An optional type
-    template<typename T>
-    class Option {
-    public:
-        Option() : nullableValue( nullptr ) {}
-        Option( T const& _value )
-        : nullableValue( new( storage ) T( _value ) )
-        {}
-        Option( Option const& _other )
-        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
-        {}
-
-        ~Option() {
-            reset();
-        }
-
-        Option& operator= ( Option const& _other ) {
-            if( &_other != this ) {
-                reset();
-                if( _other )
-                    nullableValue = new( storage ) T( *_other );
-            }
-            return *this;
-        }
-        Option& operator = ( T const& _value ) {
-            reset();
-            nullableValue = new( storage ) T( _value );
-            return *this;
-        }
-
-        void reset() {
-            if( nullableValue )
-                nullableValue->~T();
-            nullableValue = nullptr;
-        }
-
-        T& operator*() { return *nullableValue; }
-        T const& operator*() const { return *nullableValue; }
-        T* operator->() { return nullableValue; }
-        const T* operator->() const { return nullableValue; }
-
-        T valueOr( T const& defaultValue ) const {
-            return nullableValue ? *nullableValue : defaultValue;
-        }
-
-        bool some() const { return nullableValue != nullptr; }
-        bool none() const { return nullableValue == nullptr; }
-
-        bool operator !() const { return nullableValue == nullptr; }
-        explicit operator bool() const {
-            return some();
-        }
-
-    private:
-        T *nullableValue;
-        alignas(alignof(T)) char storage[sizeof(T)];
-    };
-
-} // end namespace Catch
-
-// end catch_option.hpp
-#include <chrono>
-#include <iosfwd>
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    enum class Verbosity {
-        Quiet = 0,
-        Normal,
-        High
-    };
-
-    struct WarnAbout { enum What {
-        Nothing = 0x00,
-        NoAssertions = 0x01,
-        NoTests = 0x02
-    }; };
-
-    struct ShowDurations { enum OrNot {
-        DefaultForReporter,
-        Always,
-        Never
-    }; };
-    struct RunTests { enum InWhatOrder {
-        InDeclarationOrder,
-        InLexicographicalOrder,
-        InRandomOrder
-    }; };
-    struct UseColour { enum YesOrNo {
-        Auto,
-        Yes,
-        No
-    }; };
-    struct WaitForKeypress { enum When {
-        Never,
-        BeforeStart = 1,
-        BeforeExit = 2,
-        BeforeStartAndExit = BeforeStart | BeforeExit
-    }; };
-
-    class TestSpec;
-
-    struct IConfig : NonCopyable {
-
-        virtual ~IConfig();
-
-        virtual bool allowThrows() const = 0;
-        virtual std::ostream& stream() const = 0;
-        virtual std::string name() const = 0;
-        virtual bool includeSuccessfulResults() const = 0;
-        virtual bool shouldDebugBreak() const = 0;
-        virtual bool warnAboutMissingAssertions() const = 0;
-        virtual bool warnAboutNoTests() const = 0;
-        virtual int abortAfter() const = 0;
-        virtual bool showInvisibles() const = 0;
-        virtual ShowDurations::OrNot showDurations() const = 0;
-        virtual TestSpec const& testSpec() const = 0;
-        virtual bool hasTestFilters() const = 0;
-        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
-        virtual RunTests::InWhatOrder runOrder() const = 0;
-        virtual unsigned int rngSeed() const = 0;
-        virtual UseColour::YesOrNo useColour() const = 0;
-        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
-        virtual Verbosity verbosity() const = 0;
-
-        virtual bool benchmarkNoAnalysis() const = 0;
-        virtual int benchmarkSamples() const = 0;
-        virtual double benchmarkConfidenceInterval() const = 0;
-        virtual unsigned int benchmarkResamples() const = 0;
-        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
-    };
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-}
-
-// end catch_interfaces_config.h
-// start catch_random_number_generator.h
-
-#include <cstdint>
-
-namespace Catch {
-
-    // This is a simple implementation of C++11 Uniform Random Number
-    // Generator. It does not provide all operators, because Catch2
-    // does not use it, but it should behave as expected inside stdlib's
-    // distributions.
-    // The implementation is based on the PCG family (http://pcg-random.org)
-    class SimplePcg32 {
-        using state_type = std::uint64_t;
-    public:
-        using result_type = std::uint32_t;
-        static constexpr result_type (min)() {
-            return 0;
-        }
-        static constexpr result_type (max)() {
-            return static_cast<result_type>(-1);
-        }
-
-        // Provide some default initial state for the default constructor
-        SimplePcg32():SimplePcg32(0xed743cc4U) {}
-
-        explicit SimplePcg32(result_type seed_);
-
-        void seed(result_type seed_);
-        void discard(uint64_t skip);
-
-        result_type operator()();
-
-    private:
-        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
-        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
-
-        // In theory we also need operator<< and operator>>
-        // In practice we do not use them, so we will skip them for now
-
-        std::uint64_t m_state;
-        // This part of the state determines which "stream" of the numbers
-        // is chosen -- we take it as a constant for Catch2, so we only
-        // need to deal with seeding the main state.
-        // Picked by reading 8 bytes from `/dev/random` :-)
-        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
-    };
-
-} // end namespace Catch
-
-// end catch_random_number_generator.h
-#include <random>
-
-namespace Catch {
-namespace Generators {
-
-template <typename Float>
-class RandomFloatingGenerator final : public IGenerator<Float> {
-    Catch::SimplePcg32& m_rng;
-    std::uniform_real_distribution<Float> m_dist;
-    Float m_current_number;
-public:
-
-    RandomFloatingGenerator(Float a, Float b):
-        m_rng(rng()),
-        m_dist(a, b) {
-        static_cast<void>(next());
-    }
-
-    Float const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rng);
-        return true;
-    }
-};
-
-template <typename Integer>
-class RandomIntegerGenerator final : public IGenerator<Integer> {
-    Catch::SimplePcg32& m_rng;
-    std::uniform_int_distribution<Integer> m_dist;
-    Integer m_current_number;
-public:
-
-    RandomIntegerGenerator(Integer a, Integer b):
-        m_rng(rng()),
-        m_dist(a, b) {
-        static_cast<void>(next());
-    }
-
-    Integer const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rng);
-        return true;
-    }
-};
-
-// TODO: Ideally this would be also constrained against the various char types,
-//       but I don't expect users to run into that in practice.
-template <typename T>
-typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
-GeneratorWrapper<T>>::type
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
-    );
-}
-
-template <typename T>
-typename std::enable_if<std::is_floating_point<T>::value,
-GeneratorWrapper<T>>::type
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
-    );
-}
-
-template <typename T>
-class RangeGenerator final : public IGenerator<T> {
-    T m_current;
-    T m_end;
-    T m_step;
-    bool m_positive;
-
-public:
-    RangeGenerator(T const& start, T const& end, T const& step):
-        m_current(start),
-        m_end(end),
-        m_step(step),
-        m_positive(m_step > T(0))
-    {
-        assert(m_current != m_end && "Range start and end cannot be equal");
-        assert(m_step != T(0) && "Step size cannot be zero");
-        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
-    }
-
-    RangeGenerator(T const& start, T const& end):
-        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
-    {}
-
-    T const& get() const override {
-        return m_current;
-    }
-
-    bool next() override {
-        m_current += m_step;
-        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
-    }
-};
-
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
-    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
-}
-
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end) {
-    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
-}
-
-template <typename T>
-class IteratorGenerator final : public IGenerator<T> {
-    static_assert(!std::is_same<T, bool>::value,
-        "IteratorGenerator currently does not support bools"
-        "because of std::vector<bool> specialization");
-
-    std::vector<T> m_elems;
-    size_t m_current = 0;
-public:
-    template <typename InputIterator, typename InputSentinel>
-    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
-        if (m_elems.empty()) {
-            Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
-        }
-    }
-
-    T const& get() const override {
-        return m_elems[m_current];
-    }
-
-    bool next() override {
-        ++m_current;
-        return m_current != m_elems.size();
-    }
-};
-
-template <typename InputIterator,
-          typename InputSentinel,
-          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
-GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
-    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
-}
-
-template <typename Container,
-          typename ResultType = typename Container::value_type>
-GeneratorWrapper<ResultType> from_range(Container const& cnt) {
-    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
-}
-
-} // namespace Generators
-} // namespace Catch
-
-// end catch_generators_specific.hpp
-
-// These files are included here so the single_include script doesn't put them
-// in the conditionally compiled sections
-// start catch_test_case_info.h
-
-#include <string>
-#include <vector>
-#include <memory>
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    struct ITestInvoker;
-
-    struct TestCaseInfo {
-        enum SpecialProperties{
-            None = 0,
-            IsHidden = 1 << 1,
-            ShouldFail = 1 << 2,
-            MayFail = 1 << 3,
-            Throws = 1 << 4,
-            NonPortable = 1 << 5,
-            Benchmark = 1 << 6
-        };
-
-        TestCaseInfo(   std::string const& _name,
-                        std::string const& _className,
-                        std::string const& _description,
-                        std::vector<std::string> const& _tags,
-                        SourceLineInfo const& _lineInfo );
-
-        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
-
-        bool isHidden() const;
-        bool throws() const;
-        bool okToFail() const;
-        bool expectedToFail() const;
-
-        std::string tagsAsString() const;
-
-        std::string name;
-        std::string className;
-        std::string description;
-        std::vector<std::string> tags;
-        std::vector<std::string> lcaseTags;
-        SourceLineInfo lineInfo;
-        SpecialProperties properties;
-    };
-
-    class TestCase : public TestCaseInfo {
-    public:
-
-        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
-
-        TestCase withName( std::string const& _newName ) const;
-
-        void invoke() const;
-
-        TestCaseInfo const& getTestCaseInfo() const;
-
-        bool operator == ( TestCase const& other ) const;
-        bool operator < ( TestCase const& other ) const;
-
-    private:
-        std::shared_ptr<ITestInvoker> test;
-    };
-
-    TestCase makeTestCase(  ITestInvoker* testCase,
-                            std::string const& className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& lineInfo );
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_case_info.h
-// start catch_interfaces_runner.h
-
-namespace Catch {
-
-    struct IRunner {
-        virtual ~IRunner();
-        virtual bool aborting() const = 0;
-    };
-}
-
-// end catch_interfaces_runner.h
-
-#ifdef __OBJC__
-// start catch_objc.hpp
-
-#import <objc/runtime.h>
-
-#include <string>
-
-// NB. Any general catch headers included here must be included
-// in catch.hpp first to make sure they are included by the single
-// header for non obj-usage
-
-///////////////////////////////////////////////////////////////////////////////
-// This protocol is really only here for (self) documenting purposes, since
-// all its methods are optional.
-@protocol OcFixture
-
-@optional
-
--(void) setUp;
--(void) tearDown;
-
-@end
-
-namespace Catch {
-
-    class OcMethod : public ITestInvoker {
-
-    public:
-        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
-
-        virtual void invoke() const {
-            id obj = [[m_cls alloc] init];
-
-            performOptionalSelector( obj, @selector(setUp)  );
-            performOptionalSelector( obj, m_sel );
-            performOptionalSelector( obj, @selector(tearDown)  );
-
-            arcSafeRelease( obj );
-        }
-    private:
-        virtual ~OcMethod() {}
-
-        Class m_cls;
-        SEL m_sel;
-    };
-
-    namespace Detail{
-
-        inline std::string getAnnotation(   Class cls,
-                                            std::string const& annotationName,
-                                            std::string const& testCaseName ) {
-            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
-            SEL sel = NSSelectorFromString( selStr );
-            arcSafeRelease( selStr );
-            id value = performOptionalSelector( cls, sel );
-            if( value )
-                return [(NSString*)value UTF8String];
-            return "";
-        }
-    }
-
-    inline std::size_t registerTestMethods() {
-        std::size_t noTestMethods = 0;
-        int noClasses = objc_getClassList( nullptr, 0 );
-
-        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
-        objc_getClassList( classes, noClasses );
-
-        for( int c = 0; c < noClasses; c++ ) {
-            Class cls = classes[c];
-            {
-                u_int count;
-                Method* methods = class_copyMethodList( cls, &count );
-                for( u_int m = 0; m < count ; m++ ) {
-                    SEL selector = method_getName(methods[m]);
-                    std::string methodName = sel_getName(selector);
-                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
-                        std::string testCaseName = methodName.substr( 15 );
-                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
-                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
-                        const char* className = class_getName( cls );
-
-                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
-                        noTestMethods++;
-                    }
-                }
-                free(methods);
-            }
-        }
-        return noTestMethods;
-    }
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-
-    namespace Matchers {
-        namespace Impl {
-        namespace NSStringMatchers {
-
-            struct StringHolder : MatcherBase<NSString*>{
-                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
-                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
-                StringHolder() {
-                    arcSafeRelease( m_substr );
-                }
-
-                bool match( NSString* str ) const override {
-                    return false;
-                }
-
-                NSString* CATCH_ARC_STRONG m_substr;
-            };
-
-            struct Equals : StringHolder {
-                Equals( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str isEqualToString:m_substr];
-                }
-
-                std::string describe() const override {
-                    return "equals string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-            struct Contains : StringHolder {
-                Contains( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location != NSNotFound;
-                }
-
-                std::string describe() const override {
-                    return "contains string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-            struct StartsWith : StringHolder {
-                StartsWith( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == 0;
-                }
-
-                std::string describe() const override {
-                    return "starts with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-            struct EndsWith : StringHolder {
-                EndsWith( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
-                }
-
-                std::string describe() const override {
-                    return "ends with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-        } // namespace NSStringMatchers
-        } // namespace Impl
-
-        inline Impl::NSStringMatchers::Equals
-            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
-
-        inline Impl::NSStringMatchers::Contains
-            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
-
-        inline Impl::NSStringMatchers::StartsWith
-            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
-
-        inline Impl::NSStringMatchers::EndsWith
-            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
-
-    } // namespace Matchers
-
-    using namespace Matchers;
-
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
-#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
-{ \
-return @ name; \
-} \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
-{ \
-return @ desc; \
-} \
--(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
-
-#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
-
-// end catch_objc.hpp
-#endif
-
-// Benchmarking needs the externally-facing parts of reporters to work
-#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_external_interfaces.h
-
-// start catch_reporter_bases.hpp
-
-// start catch_interfaces_reporter.h
-
-// start catch_config.hpp
-
-// start catch_test_spec_parser.h
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// start catch_test_spec.h
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// start catch_wildcard_pattern.h
-
-namespace Catch
-{
-    class WildcardPattern {
-        enum WildcardPosition {
-            NoWildcard = 0,
-            WildcardAtStart = 1,
-            WildcardAtEnd = 2,
-            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
-        };
-
-    public:
-
-        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
-        virtual ~WildcardPattern() = default;
-        virtual bool matches( std::string const& str ) const;
-
-    private:
-        std::string normaliseString( std::string const& str ) const;
-        CaseSensitive::Choice m_caseSensitivity;
-        WildcardPosition m_wildcard = NoWildcard;
-        std::string m_pattern;
-    };
-}
-
-// end catch_wildcard_pattern.h
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    struct IConfig;
-
-    class TestSpec {
-        class Pattern {
-        public:
-            explicit Pattern( std::string const& name );
-            virtual ~Pattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
-            std::string const& name() const;
-        private:
-            std::string const m_name;
-        };
-        using PatternPtr = std::shared_ptr<Pattern>;
-
-        class NamePattern : public Pattern {
-        public:
-            explicit NamePattern( std::string const& name, std::string const& filterString );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            WildcardPattern m_wildcardPattern;
-        };
-
-        class TagPattern : public Pattern {
-        public:
-            explicit TagPattern( std::string const& tag, std::string const& filterString );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            std::string m_tag;
-        };
-
-        class ExcludedPattern : public Pattern {
-        public:
-            explicit ExcludedPattern( PatternPtr const& underlyingPattern );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            PatternPtr m_underlyingPattern;
-        };
-
-        struct Filter {
-            std::vector<PatternPtr> m_patterns;
-
-            bool matches( TestCaseInfo const& testCase ) const;
-            std::string name() const;
-        };
-
-    public:
-        struct FilterMatch {
-            std::string name;
-            std::vector<TestCase const*> tests;
-        };
-        using Matches = std::vector<FilterMatch>;
-        using vectorStrings = std::vector<std::string>;
-
-        bool hasFilters() const;
-        bool matches( TestCaseInfo const& testCase ) const;
-        Matches matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const;
-        const vectorStrings & getInvalidArgs() const;
-
-    private:
-        std::vector<Filter> m_filters;
-        std::vector<std::string> m_invalidArgs;
-        friend class TestSpecParser;
-    };
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_spec.h
-// start catch_interfaces_tag_alias_registry.h
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias;
-
-    struct ITagAliasRegistry {
-        virtual ~ITagAliasRegistry();
-        // Nullptr if not present
-        virtual TagAlias const* find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
-
-        static ITagAliasRegistry const& get();
-    };
-
-} // end namespace Catch
-
-// end catch_interfaces_tag_alias_registry.h
-namespace Catch {
-
-    class TestSpecParser {
-        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
-        Mode m_mode = None;
-        Mode lastMode = None;
-        bool m_exclusion = false;
-        std::size_t m_pos = 0;
-        std::size_t m_realPatternPos = 0;
-        std::string m_arg;
-        std::string m_substring;
-        std::string m_patternName;
-        std::vector<std::size_t> m_escapeChars;
-        TestSpec::Filter m_currentFilter;
-        TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases = nullptr;
-
-    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases );
-
-        TestSpecParser& parse( std::string const& arg );
-        TestSpec testSpec();
-
-    private:
-        bool visitChar( char c );
-        void startNewMode( Mode mode );
-        bool processNoneChar( char c );
-        void processNameChar( char c );
-        bool processOtherChar( char c );
-        void endMode();
-        void escape();
-        bool isControlChar( char c ) const;
-        void saveLastMode();
-        void revertBackToLastMode();
-        void addFilter();
-        bool separate();
-
-        // Handles common preprocessing of the pattern for name/tag patterns
-        std::string preprocessPattern();
-        // Adds the current pattern as a test name
-        void addNamePattern();
-        // Adds the current pattern as a tag
-        void addTagPattern();
-
-        inline void addCharToPattern(char c) {
-            m_substring += c;
-            m_patternName += c;
-            m_realPatternPos++;
-        }
-
-    };
-    TestSpec parseTestSpec( std::string const& arg );
-
-} // namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_spec_parser.h
-// Libstdc++ doesn't like incomplete classes for unique_ptr
-
-#include <memory>
-#include <vector>
-#include <string>
-
-#ifndef CATCH_CONFIG_CONSOLE_WIDTH
-#define CATCH_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch {
-
-    struct IStream;
-
-    struct ConfigData {
-        bool listTests = false;
-        bool listTags = false;
-        bool listReporters = false;
-        bool listTestNamesOnly = false;
-
-        bool showSuccessfulTests = false;
-        bool shouldDebugBreak = false;
-        bool noThrow = false;
-        bool showHelp = false;
-        bool showInvisibles = false;
-        bool filenamesAsTags = false;
-        bool libIdentify = false;
-
-        int abortAfter = -1;
-        unsigned int rngSeed = 0;
-
-        bool benchmarkNoAnalysis = false;
-        unsigned int benchmarkSamples = 100;
-        double benchmarkConfidenceInterval = 0.95;
-        unsigned int benchmarkResamples = 100000;
-        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
-
-        Verbosity verbosity = Verbosity::Normal;
-        WarnAbout::What warnings = WarnAbout::Nothing;
-        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
-        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
-        UseColour::YesOrNo useColour = UseColour::Auto;
-        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
-
-        std::string outputFilename;
-        std::string name;
-        std::string processName;
-#ifndef CATCH_CONFIG_DEFAULT_REPORTER
-#define CATCH_CONFIG_DEFAULT_REPORTER "console"
-#endif
-        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
-#undef CATCH_CONFIG_DEFAULT_REPORTER
-
-        std::vector<std::string> testsOrTags;
-        std::vector<std::string> sectionsToRun;
-    };
-
-    class Config : public IConfig {
-    public:
-
-        Config() = default;
-        Config( ConfigData const& data );
-        virtual ~Config() = default;
-
-        std::string const& getFilename() const;
-
-        bool listTests() const;
-        bool listTestNamesOnly() const;
-        bool listTags() const;
-        bool listReporters() const;
-
-        std::string getProcessName() const;
-        std::string const& getReporterName() const;
-
-        std::vector<std::string> const& getTestsOrTags() const override;
-        std::vector<std::string> const& getSectionsToRun() const override;
-
-        TestSpec const& testSpec() const override;
-        bool hasTestFilters() const override;
-
-        bool showHelp() const;
-
-        // IConfig interface
-        bool allowThrows() const override;
-        std::ostream& stream() const override;
-        std::string name() const override;
-        bool includeSuccessfulResults() const override;
-        bool warnAboutMissingAssertions() const override;
-        bool warnAboutNoTests() const override;
-        ShowDurations::OrNot showDurations() const override;
-        RunTests::InWhatOrder runOrder() const override;
-        unsigned int rngSeed() const override;
-        UseColour::YesOrNo useColour() const override;
-        bool shouldDebugBreak() const override;
-        int abortAfter() const override;
-        bool showInvisibles() const override;
-        Verbosity verbosity() const override;
-        bool benchmarkNoAnalysis() const override;
-        int benchmarkSamples() const override;
-        double benchmarkConfidenceInterval() const override;
-        unsigned int benchmarkResamples() const override;
-        std::chrono::milliseconds benchmarkWarmupTime() const override;
-
-    private:
-
-        IStream const* openStream();
-        ConfigData m_data;
-
-        std::unique_ptr<IStream const> m_stream;
-        TestSpec m_testSpec;
-        bool m_hasTestFilters = false;
-    };
-
-} // end namespace Catch
-
-// end catch_config.hpp
-// start catch_assertionresult.h
-
-#include <string>
-
-namespace Catch {
-
-    struct AssertionResultData
-    {
-        AssertionResultData() = delete;
-
-        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
-
-        std::string message;
-        mutable std::string reconstructedExpression;
-        LazyExpression lazyExpression;
-        ResultWas::OfType resultType;
-
-        std::string reconstructExpression() const;
-    };
-
-    class AssertionResult {
-    public:
-        AssertionResult() = delete;
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
-
-        bool isOk() const;
-        bool succeeded() const;
-        ResultWas::OfType getResultType() const;
-        bool hasExpression() const;
-        bool hasMessage() const;
-        std::string getExpression() const;
-        std::string getExpressionInMacro() const;
-        bool hasExpandedExpression() const;
-        std::string getExpandedExpression() const;
-        std::string getMessage() const;
-        SourceLineInfo getSourceInfo() const;
-        StringRef getTestMacroName() const;
-
-    //protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
-    };
-
-} // end namespace Catch
-
-// end catch_assertionresult.h
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_estimate.hpp
-
- // Statistics estimates
-
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct Estimate {
-            Duration point;
-            Duration lower_bound;
-            Duration upper_bound;
-            double confidence_interval;
-
-            template <typename Duration2>
-            operator Estimate<Duration2>() const {
-                return { point, lower_bound, upper_bound, confidence_interval };
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_estimate.hpp
-// start catch_outlier_classification.hpp
-
-// Outlier information
-
-namespace Catch {
-    namespace Benchmark {
-        struct OutlierClassification {
-            int samples_seen = 0;
-            int low_severe = 0;     // more than 3 times IQR below Q1
-            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
-            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
-            int high_severe = 0;    // more than 3 times IQR above Q3
-
-            int total() const {
-                return low_severe + low_mild + high_mild + high_severe;
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_outlier_classification.hpp
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-#include <string>
-#include <iosfwd>
-#include <map>
-#include <set>
-#include <memory>
-#include <algorithm>
-
-namespace Catch {
-
-    struct ReporterConfig {
-        explicit ReporterConfig( IConfigPtr const& _fullConfig );
-
-        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
-
-        std::ostream& stream() const;
-        IConfigPtr fullConfig() const;
-
-    private:
-        std::ostream* m_stream;
-        IConfigPtr m_fullConfig;
-    };
-
-    struct ReporterPreferences {
-        bool shouldRedirectStdOut = false;
-        bool shouldReportAllAssertions = false;
-    };
-
-    template<typename T>
-    struct LazyStat : Option<T> {
-        LazyStat& operator=( T const& _value ) {
-            Option<T>::operator=( _value );
-            used = false;
-            return *this;
-        }
-        void reset() {
-            Option<T>::reset();
-            used = false;
-        }
-        bool used = false;
-    };
-
-    struct TestRunInfo {
-        TestRunInfo( std::string const& _name );
-        std::string name;
-    };
-    struct GroupInfo {
-        GroupInfo(  std::string const& _name,
-                    std::size_t _groupIndex,
-                    std::size_t _groupsCount );
-
-        std::string name;
-        std::size_t groupIndex;
-        std::size_t groupsCounts;
-    };
-
-    struct AssertionStats {
-        AssertionStats( AssertionResult const& _assertionResult,
-                        std::vector<MessageInfo> const& _infoMessages,
-                        Totals const& _totals );
-
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = delete;
-        AssertionStats& operator = ( AssertionStats && )     = delete;
-        virtual ~AssertionStats();
-
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
-
-    struct SectionStats {
-        SectionStats(   SectionInfo const& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions );
-        SectionStats( SectionStats const& )              = default;
-        SectionStats( SectionStats && )                  = default;
-        SectionStats& operator = ( SectionStats const& ) = default;
-        SectionStats& operator = ( SectionStats && )     = default;
-        virtual ~SectionStats();
-
-        SectionInfo sectionInfo;
-        Counts assertions;
-        double durationInSeconds;
-        bool missingAssertions;
-    };
-
-    struct TestCaseStats {
-        TestCaseStats(  TestCaseInfo const& _testInfo,
-                        Totals const& _totals,
-                        std::string const& _stdOut,
-                        std::string const& _stdErr,
-                        bool _aborting );
-
-        TestCaseStats( TestCaseStats const& )              = default;
-        TestCaseStats( TestCaseStats && )                  = default;
-        TestCaseStats& operator = ( TestCaseStats const& ) = default;
-        TestCaseStats& operator = ( TestCaseStats && )     = default;
-        virtual ~TestCaseStats();
-
-        TestCaseInfo testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
-    };
-
-    struct TestGroupStats {
-        TestGroupStats( GroupInfo const& _groupInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-        TestGroupStats( GroupInfo const& _groupInfo );
-
-        TestGroupStats( TestGroupStats const& )              = default;
-        TestGroupStats( TestGroupStats && )                  = default;
-        TestGroupStats& operator = ( TestGroupStats const& ) = default;
-        TestGroupStats& operator = ( TestGroupStats && )     = default;
-        virtual ~TestGroupStats();
-
-        GroupInfo groupInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-
-        TestRunStats( TestRunStats const& )              = default;
-        TestRunStats( TestRunStats && )                  = default;
-        TestRunStats& operator = ( TestRunStats const& ) = default;
-        TestRunStats& operator = ( TestRunStats && )     = default;
-        virtual ~TestRunStats();
-
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    struct BenchmarkInfo {
-        std::string name;
-        double estimatedDuration;
-        int iterations;
-        int samples;
-        unsigned int resamples;
-        double clockResolution;
-        double clockCost;
-    };
-
-    template <class Duration>
-    struct BenchmarkStats {
-        BenchmarkInfo info;
-
-        std::vector<Duration> samples;
-        Benchmark::Estimate<Duration> mean;
-        Benchmark::Estimate<Duration> standardDeviation;
-        Benchmark::OutlierClassification outliers;
-        double outlierVariance;
-
-        template <typename Duration2>
-        operator BenchmarkStats<Duration2>() const {
-            std::vector<Duration2> samples2;
-            samples2.reserve(samples.size());
-            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
-            return {
-                info,
-                std::move(samples2),
-                mean,
-                standardDeviation,
-                outliers,
-                outlierVariance,
-            };
-        }
-    };
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    struct IStreamingReporter {
-        virtual ~IStreamingReporter() = default;
-
-        // Implementing class must also provide the following static methods:
-        // static std::string getDescription();
-        // static std::set<Verbosity> getSupportedVerbosities()
-
-        virtual ReporterPreferences getPreferences() const = 0;
-
-        virtual void noMatchingTestCases( std::string const& spec ) = 0;
-
-        virtual void reportInvalidArguments(std::string const&) {}
-
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
-
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        virtual void benchmarkPreparing( std::string const& ) {}
-        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
-        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
-        virtual void benchmarkFailed( std::string const& ) {}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
-
-        // The return value indicates if the messages buffer should be cleared:
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
-
-        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
-        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
-
-        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
-
-        // Default empty implementation provided
-        virtual void fatalErrorEncountered( StringRef name );
-
-        virtual bool isMulti() const;
-    };
-    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
-
-    struct IReporterFactory {
-        virtual ~IReporterFactory();
-        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
-
-    struct IReporterRegistry {
-        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
-        using Listeners = std::vector<IReporterFactoryPtr>;
-
-        virtual ~IReporterRegistry();
-        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
-        virtual FactoryMap const& getFactories() const = 0;
-        virtual Listeners const& getListeners() const = 0;
-    };
-
-} // end namespace Catch
-
-// end catch_interfaces_reporter.h
-#include <algorithm>
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <cassert>
-#include <memory>
-#include <ostream>
-
-namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result);
-
-    // Returns double formatted as %.3f (format expected on output)
-    std::string getFormattedDuration( double duration );
-
-    std::string serializeFilters( std::vector<std::string> const& container );
-
-    template<typename DerivedT>
-    struct StreamingReporterBase : IStreamingReporter {
-
-        StreamingReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        ~StreamingReporterBase() override = default;
-
-        void noMatchingTestCases(std::string const&) override {}
-
-        void reportInvalidArguments(std::string const&) override {}
-
-        void testRunStarting(TestRunInfo const& _testRunInfo) override {
-            currentTestRunInfo = _testRunInfo;
-        }
-
-        void testGroupStarting(GroupInfo const& _groupInfo) override {
-            currentGroupInfo = _groupInfo;
-        }
-
-        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
-            currentTestCaseInfo = _testInfo;
-        }
-        void sectionStarting(SectionInfo const& _sectionInfo) override {
-            m_sectionStack.push_back(_sectionInfo);
-        }
-
-        void sectionEnded(SectionStats const& /* _sectionStats */) override {
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
-            currentTestCaseInfo.reset();
-        }
-        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
-            currentGroupInfo.reset();
-        }
-        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
-            currentTestCaseInfo.reset();
-            currentGroupInfo.reset();
-            currentTestRunInfo.reset();
-        }
-
-        void skipTest(TestCaseInfo const&) override {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-
-        LazyStat<TestRunInfo> currentTestRunInfo;
-        LazyStat<GroupInfo> currentGroupInfo;
-        LazyStat<TestCaseInfo> currentTestCaseInfo;
-
-        std::vector<SectionInfo> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    template<typename DerivedT>
-    struct CumulativeReporterBase : IStreamingReporter {
-        template<typename T, typename ChildNodeT>
-        struct Node {
-            explicit Node( T const& _value ) : value( _value ) {}
-            virtual ~Node() {}
-
-            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode {
-            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
-            virtual ~SectionNode() = default;
-
-            bool operator == (SectionNode const& other) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-            bool operator == (std::shared_ptr<SectionNode> const& other) const {
-                return operator==(*other);
-            }
-
-            SectionStats stats;
-            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
-            using Assertions = std::vector<AssertionStats>;
-            ChildSections childSections;
-            Assertions assertions;
-            std::string stdOut;
-            std::string stdErr;
-        };
-
-        struct BySectionInfo {
-            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
-            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
-            bool operator() (std::shared_ptr<SectionNode> const& node) const {
-                return ((node->stats.sectionInfo.name == m_other.name) &&
-                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
-            }
-            void operator=(BySectionInfo const&) = delete;
-
-        private:
-            SectionInfo const& m_other;
-        };
-
-        using TestCaseNode = Node<TestCaseStats, SectionNode>;
-        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
-        using TestRunNode = Node<TestRunStats, TestGroupNode>;
-
-        CumulativeReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-        ~CumulativeReporterBase() override = default;
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        void testRunStarting( TestRunInfo const& ) override {}
-        void testGroupStarting( GroupInfo const& ) override {}
-
-        void testCaseStarting( TestCaseInfo const& ) override {}
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
-            std::shared_ptr<SectionNode> node;
-            if( m_sectionStack.empty() ) {
-                if( !m_rootSection )
-                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
-                node = m_rootSection;
-            }
-            else {
-                SectionNode& parentNode = *m_sectionStack.back();
-                auto it =
-                    std::find_if(   parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-                if( it == parentNode.childSections.end() ) {
-                    node = std::make_shared<SectionNode>( incompleteStats );
-                    parentNode.childSections.push_back( node );
-                }
-                else
-                    node = *it;
-            }
-            m_sectionStack.push_back( node );
-            m_deepestSection = std::move(node);
-        }
-
-        void assertionStarting(AssertionInfo const&) override {}
-
-        bool assertionEnded(AssertionStats const& assertionStats) override {
-            assert(!m_sectionStack.empty());
-            // AssertionResult holds a pointer to a temporary DecomposedExpression,
-            // which getExpandedExpression() calls to build the expression string.
-            // Our section stack copy of the assertionResult will likely outlive the
-            // temporary, so it must be expanded or discarded now to avoid calling
-            // a destroyed object later.
-            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
-            SectionNode& sectionNode = *m_sectionStack.back();
-            sectionNode.assertions.push_back(assertionStats);
-            return true;
-        }
-        void sectionEnded(SectionStats const& sectionStats) override {
-            assert(!m_sectionStack.empty());
-            SectionNode& node = *m_sectionStack.back();
-            node.stats = sectionStats;
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& testCaseStats) override {
-            auto node = std::make_shared<TestCaseNode>(testCaseStats);
-            assert(m_sectionStack.size() == 0);
-            node->children.push_back(m_rootSection);
-            m_testCases.push_back(node);
-            m_rootSection.reset();
-
-            assert(m_deepestSection);
-            m_deepestSection->stdOut = testCaseStats.stdOut;
-            m_deepestSection->stdErr = testCaseStats.stdErr;
-        }
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            auto node = std::make_shared<TestGroupNode>(testGroupStats);
-            node->children.swap(m_testCases);
-            m_testGroups.push_back(node);
-        }
-        void testRunEnded(TestRunStats const& testRunStats) override {
-            auto node = std::make_shared<TestRunNode>(testRunStats);
-            node->children.swap(m_testGroups);
-            m_testRuns.push_back(node);
-            testRunEndedCumulative();
-        }
-        virtual void testRunEndedCumulative() = 0;
-
-        void skipTest(TestCaseInfo const&) override {}
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-        std::vector<AssertionStats> m_assertions;
-        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
-        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
-        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
-
-        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
-
-        std::shared_ptr<SectionNode> m_rootSection;
-        std::shared_ptr<SectionNode> m_deepestSection;
-        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    template<char C>
-    char const* getLineOfChars() {
-        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
-        if( !*line ) {
-            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
-            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
-        }
-        return line;
-    }
-
-    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
-        TestEventListenerBase( ReporterConfig const& _config );
-
-        static std::set<Verbosity> getSupportedVerbosities();
-
-        void assertionStarting(AssertionInfo const&) override;
-        bool assertionEnded(AssertionStats const&) override;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_bases.hpp
-// start catch_console_colour.h
-
-namespace Catch {
-
-    struct Colour {
-        enum Code {
-            None = 0,
-
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
-
-            Bright = 0x10,
-
-            BrightRed = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey = Bright | Grey,
-            BrightWhite = Bright | White,
-            BrightYellow = Bright | Yellow,
-
-            // By intention
-            FileName = LightGrey,
-            Warning = BrightYellow,
-            ResultError = BrightRed,
-            ResultSuccess = BrightGreen,
-            ResultExpectedFailure = Warning,
-
-            Error = BrightRed,
-            Success = Green,
-
-            OriginalExpression = Cyan,
-            ReconstructedExpression = BrightYellow,
-
-            SecondaryText = LightGrey,
-            Headers = White
-        };
-
-        // Use constructed object for RAII guard
-        Colour( Code _colourCode );
-        Colour( Colour&& other ) noexcept;
-        Colour& operator=( Colour&& other ) noexcept;
-        ~Colour();
-
-        // Use static method for one-shot changes
-        static void use( Code _colourCode );
-
-    private:
-        bool m_moved = false;
-    };
-
-    std::ostream& operator << ( std::ostream& os, Colour const& );
-
-} // end namespace Catch
-
-// end catch_console_colour.h
-// start catch_reporter_registrars.hpp
-
-
-namespace Catch {
-
-    template<typename T>
-    class ReporterRegistrar {
-
-        class ReporterFactory : public IReporterFactory {
-
-            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-
-            std::string getDescription() const override {
-                return T::getDescription();
-            }
-        };
-
-    public:
-
-        explicit ReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
-        }
-    };
-
-    template<typename T>
-    class ListenerRegistrar {
-
-        class ListenerFactory : public IReporterFactory {
-
-            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-            std::string getDescription() const override {
-                return std::string();
-            }
-        };
-
-    public:
-
-        ListenerRegistrar() {
-            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
-        }
-    };
-}
-
-#if !defined(CATCH_CONFIG_DISABLE)
-
-#define CATCH_REGISTER_REPORTER( name, reporterType ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION         \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
-    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#define CATCH_REGISTER_LISTENER( listenerType ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION   \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS    \
-    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-#else // CATCH_CONFIG_DISABLE
-
-#define CATCH_REGISTER_REPORTER(name, reporterType)
-#define CATCH_REGISTER_LISTENER(listenerType)
-
-#endif // CATCH_CONFIG_DISABLE
-
-// end catch_reporter_registrars.hpp
-// Allow users to base their work off existing reporters
-// start catch_reporter_compact.h
-
-namespace Catch {
-
-    struct CompactReporter : StreamingReporterBase<CompactReporter> {
-
-        using StreamingReporterBase::StreamingReporterBase;
-
-        ~CompactReporter() override;
-
-        static std::string getDescription();
-
-        ReporterPreferences getPreferences() const override;
-
-        void noMatchingTestCases(std::string const& spec) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void sectionEnded(SectionStats const& _sectionStats) override;
-
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_compact.h
-// start catch_reporter_console.h
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-    // Fwd decls
-    struct SummaryColumn;
-    class TablePrinter;
-
-    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
-        std::unique_ptr<TablePrinter> m_tablePrinter;
-
-        ConsoleReporter(ReporterConfig const& config);
-        ~ConsoleReporter() override;
-        static std::string getDescription();
-
-        void noMatchingTestCases(std::string const& spec) override;
-
-        void reportInvalidArguments(std::string const&arg) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void sectionStarting(SectionInfo const& _sectionInfo) override;
-        void sectionEnded(SectionStats const& _sectionStats) override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting(BenchmarkInfo const& info) override;
-        void benchmarkEnded(BenchmarkStats<> const& stats) override;
-        void benchmarkFailed(std::string const& error) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
-        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-        void testRunStarting(TestRunInfo const& _testRunInfo) override;
-    private:
-
-        void lazyPrint();
-
-        void lazyPrintWithoutClosingBenchmarkTable();
-        void lazyPrintRunInfo();
-        void lazyPrintGroupInfo();
-        void printTestCaseAndSectionHeader();
-
-        void printClosedHeader(std::string const& _name);
-        void printOpenHeader(std::string const& _name);
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString(std::string const& _string, std::size_t indent = 0);
-
-        void printTotals(Totals const& totals);
-        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
-
-        void printTotalsDivider(Totals const& totals);
-        void printSummaryDivider();
-        void printTestFilters();
-
-    private:
-        bool m_headerPrinted = false;
-    };
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-// end catch_reporter_console.h
-// start catch_reporter_junit.h
-
-// start catch_xmlwriter.h
-
-#include <vector>
-
-namespace Catch {
-    enum class XmlFormatting {
-        None = 0x00,
-        Indent = 0x01,
-        Newline = 0x02,
-    };
-
-    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
-    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
-
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
-
-        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
-
-        void encodeTo( std::ostream& os ) const;
-
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
-
-    private:
-        std::string m_str;
-        ForWhat m_forWhat;
-    };
-
-    class XmlWriter {
-    public:
-
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
-
-            ScopedElement( ScopedElement&& other ) noexcept;
-            ScopedElement& operator=( ScopedElement&& other ) noexcept;
-
-            ~ScopedElement();
-
-            ScopedElement& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent );
-
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
-            }
-
-        private:
-            mutable XmlWriter* m_writer = nullptr;
-            XmlFormatting m_fmt;
-        };
-
-        XmlWriter( std::ostream& os = Catch::cout() );
-        ~XmlWriter();
-
-        XmlWriter( XmlWriter const& ) = delete;
-        XmlWriter& operator=( XmlWriter const& ) = delete;
-
-        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
-
-        XmlWriter& writeAttribute( std::string const& name, bool attribute );
-
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-            ReusableStringStream rss;
-            rss << attribute;
-            return writeAttribute( name, rss.str() );
-        }
-
-        XmlWriter& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& writeComment(std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        void writeStylesheetRef( std::string const& url );
-
-        XmlWriter& writeBlankLine();
-
-        void ensureTagClosed();
-
-    private:
-
-        void applyFormatting(XmlFormatting fmt);
-
-        void writeDeclaration();
-
-        void newlineIfNecessary();
-
-        bool m_tagIsOpen = false;
-        bool m_needsNewline = false;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-    };
-
-}
-
-// end catch_xmlwriter.h
-namespace Catch {
-
-    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
-    public:
-        JunitReporter(ReporterConfig const& _config);
-
-        ~JunitReporter() override;
-
-        static std::string getDescription();
-
-        void noMatchingTestCases(std::string const& /*spec*/) override;
-
-        void testRunStarting(TestRunInfo const& runInfo) override;
-
-        void testGroupStarting(GroupInfo const& groupInfo) override;
-
-        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
-        bool assertionEnded(AssertionStats const& assertionStats) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
-
-        void testRunEndedCumulative() override;
-
-        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
-
-        void writeTestCase(TestCaseNode const& testCaseNode);
-
-        void writeSection(std::string const& className,
-                          std::string const& rootName,
-                          SectionNode const& sectionNode);
-
-        void writeAssertions(SectionNode const& sectionNode);
-        void writeAssertion(AssertionStats const& stats);
-
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::string stdOutForSuite;
-        std::string stdErrForSuite;
-        unsigned int unexpectedExceptions = 0;
-        bool m_okToFail = false;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_junit.h
-// start catch_reporter_xml.h
-
-namespace Catch {
-    class XmlReporter : public StreamingReporterBase<XmlReporter> {
-    public:
-        XmlReporter(ReporterConfig const& _config);
-
-        ~XmlReporter() override;
-
-        static std::string getDescription();
-
-        virtual std::string getStylesheetRef() const;
-
-        void writeSourceInfo(SourceLineInfo const& sourceInfo);
-
-    public: // StreamingReporterBase
-
-        void noMatchingTestCases(std::string const& s) override;
-
-        void testRunStarting(TestRunInfo const& testInfo) override;
-
-        void testGroupStarting(GroupInfo const& groupInfo) override;
-
-        void testCaseStarting(TestCaseInfo const& testInfo) override;
-
-        void sectionStarting(SectionInfo const& sectionInfo) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& assertionStats) override;
-
-        void sectionEnded(SectionStats const& sectionStats) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
-
-        void testRunEnded(TestRunStats const& testRunStats) override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting(BenchmarkInfo const&) override;
-        void benchmarkEnded(BenchmarkStats<> const&) override;
-        void benchmarkFailed(std::string const&) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    private:
-        Timer m_testCaseTimer;
-        XmlWriter m_xml;
-        int m_sectionDepth = 0;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_xml.h
-
-// end catch_external_interfaces.h
-#endif
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_benchmarking_all.hpp
-
-// A proxy header that includes all of the benchmarking headers to allow
-// concise include of the benchmarking features. You should prefer the
-// individual includes in standard use.
-
-// start catch_benchmark.hpp
-
- // Benchmark
-
-// start catch_chronometer.hpp
-
-// User-facing chronometer
-
-
-// start catch_clock.hpp
-
-// Clocks
-
-
-#include <chrono>
-#include <ratio>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Clock>
-        using ClockDuration = typename Clock::duration;
-        template <typename Clock>
-        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
-
-        template <typename Clock>
-        using TimePoint = typename Clock::time_point;
-
-        using default_clock = std::chrono::steady_clock;
-
-        template <typename Clock>
-        struct now {
-            TimePoint<Clock> operator()() const {
-                return Clock::now();
-            }
-        };
-
-        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_clock.hpp
-// start catch_optimizer.hpp
-
- // Hinting the optimizer
-
-
-#if defined(_MSC_VER)
-#   include <atomic> // atomic_thread_fence
-#endif
-
-namespace Catch {
-    namespace Benchmark {
-#if defined(__GNUC__) || defined(__clang__)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            asm volatile("" : : "g"(p) : "memory");
-        }
-        inline void keep_memory() {
-            asm volatile("" : : : "memory");
-        }
-
-        namespace Detail {
-            inline void optimizer_barrier() { keep_memory(); }
-        } // namespace Detail
-#elif defined(_MSC_VER)
-
-#pragma optimize("", off)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            // thanks @milleniumbug
-            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
-        }
-        // TODO equivalent keep_memory()
-#pragma optimize("", on)
-
-        namespace Detail {
-            inline void optimizer_barrier() {
-                std::atomic_thread_fence(std::memory_order_seq_cst);
-            }
-        } // namespace Detail
-
-#endif
-
-        template <typename T>
-        inline void deoptimize_value(T&& x) {
-            keep_memory(&x);
-        }
-
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
-            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
-        }
-
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
-            std::forward<Fn>(fn) (std::forward<Args...>(args...));
-        }
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_optimizer.hpp
-// start catch_complete_invoke.hpp
-
-// Invoke with a special case for void
-
-
-#include <type_traits>
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            struct CompleteType { using type = T; };
-            template <>
-            struct CompleteType<void> { struct type {}; };
-
-            template <typename T>
-            using CompleteType_t = typename CompleteType<T>::type;
-
-            template <typename Result>
-            struct CompleteInvoker {
-                template <typename Fun, typename... Args>
-                static Result invoke(Fun&& fun, Args&&... args) {
-                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
-                }
-            };
-            template <>
-            struct CompleteInvoker<void> {
-                template <typename Fun, typename... Args>
-                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
-                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
-                    return {};
-                }
-            };
-            template <typename Sig>
-            using ResultOf_t = typename std::result_of<Sig>::type;
-
-            // invoke and not return void :(
-            template <typename Fun, typename... Args>
-            CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun&& fun, Args&&... args) {
-                return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
-            }
-
-            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
-        } // namespace Detail
-
-        template <typename Fun>
-        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
-            CATCH_TRY{
-                return Detail::complete_invoke(std::forward<Fun>(fun));
-            } CATCH_CATCH_ALL{
-                getResultCapture().benchmarkFailed(translateActiveException());
-                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
-            }
-        }
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_complete_invoke.hpp
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            struct ChronometerConcept {
-                virtual void start() = 0;
-                virtual void finish() = 0;
-                virtual ~ChronometerConcept() = default;
-            };
-            template <typename Clock>
-            struct ChronometerModel final : public ChronometerConcept {
-                void start() override { started = Clock::now(); }
-                void finish() override { finished = Clock::now(); }
-
-                ClockDuration<Clock> elapsed() const { return finished - started; }
-
-                TimePoint<Clock> started;
-                TimePoint<Clock> finished;
-            };
-        } // namespace Detail
-
-        struct Chronometer {
-        public:
-            template <typename Fun>
-            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
-
-            int runs() const { return k; }
-
-            Chronometer(Detail::ChronometerConcept& meter, int k)
-                : impl(&meter)
-                , k(k) {}
-
-        private:
-            template <typename Fun>
-            void measure(Fun&& fun, std::false_type) {
-                measure([&fun](int) { return fun(); }, std::true_type());
-            }
-
-            template <typename Fun>
-            void measure(Fun&& fun, std::true_type) {
-                Detail::optimizer_barrier();
-                impl->start();
-                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
-                impl->finish();
-                Detail::optimizer_barrier();
-            }
-
-            Detail::ChronometerConcept* impl;
-            int k;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_chronometer.hpp
-// start catch_environment.hpp
-
-// Environment information
-
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct EnvironmentEstimate {
-            Duration mean;
-            OutlierClassification outliers;
-
-            template <typename Duration2>
-            operator EnvironmentEstimate<Duration2>() const {
-                return { mean, outliers };
-            }
-        };
-        template <typename Clock>
-        struct Environment {
-            using clock_type = Clock;
-            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
-            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_environment.hpp
-// start catch_execution_plan.hpp
-
- // Execution plan
-
-
-// start catch_benchmark_function.hpp
-
- // Dumb std::function implementation for consistent call overhead
-
-
-#include <cassert>
-#include <type_traits>
-#include <utility>
-#include <memory>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            using Decay = typename std::decay<T>::type;
-            template <typename T, typename U>
-            struct is_related
-                : std::is_same<Decay<T>, Decay<U>> {};
-
-            /// We need to reinvent std::function because every piece of code that might add overhead
-            /// in a measurement context needs to have consistent performance characteristics so that we
-            /// can account for it in the measurement.
-            /// Implementations of std::function with optimizations that aren't always applicable, like
-            /// small buffer optimizations, are not uncommon.
-            /// This is effectively an implementation of std::function without any such optimizations;
-            /// it may be slow, but it is consistently slow.
-            struct BenchmarkFunction {
-            private:
-                struct callable {
-                    virtual void call(Chronometer meter) const = 0;
-                    virtual callable* clone() const = 0;
-                    virtual ~callable() = default;
-                };
-                template <typename Fun>
-                struct model : public callable {
-                    model(Fun&& fun) : fun(std::move(fun)) {}
-                    model(Fun const& fun) : fun(fun) {}
-
-                    model<Fun>* clone() const override { return new model<Fun>(*this); }
-
-                    void call(Chronometer meter) const override {
-                        call(meter, is_callable<Fun(Chronometer)>());
-                    }
-                    void call(Chronometer meter, std::true_type) const {
-                        fun(meter);
-                    }
-                    void call(Chronometer meter, std::false_type) const {
-                        meter.measure(fun);
-                    }
-
-                    Fun fun;
-                };
-
-                struct do_nothing { void operator()() const {} };
-
-                template <typename T>
-                BenchmarkFunction(model<T>* c) : f(c) {}
-
-            public:
-                BenchmarkFunction()
-                    : f(new model<do_nothing>{ {} }) {}
-
-                template <typename Fun,
-                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
-                    BenchmarkFunction(Fun&& fun)
-                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
-
-                BenchmarkFunction(BenchmarkFunction&& that)
-                    : f(std::move(that.f)) {}
-
-                BenchmarkFunction(BenchmarkFunction const& that)
-                    : f(that.f->clone()) {}
-
-                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
-                    f = std::move(that.f);
-                    return *this;
-                }
-
-                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
-                    f.reset(that.f->clone());
-                    return *this;
-                }
-
-                void operator()(Chronometer meter) const { f->call(meter); }
-
-            private:
-                std::unique_ptr<callable> f;
-            };
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_benchmark_function.hpp
-// start catch_repeat.hpp
-
-// repeat algorithm
-
-
-#include <type_traits>
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Fun>
-            struct repeater {
-                void operator()(int k) const {
-                    for (int i = 0; i < k; ++i) {
-                        fun();
-                    }
-                }
-                Fun fun;
-            };
-            template <typename Fun>
-            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
-                return { std::forward<Fun>(fun) };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_repeat.hpp
-// start catch_run_for_at_least.hpp
-
-// Run a function for a minimum amount of time
-
-
-// start catch_measure.hpp
-
-// Measure
-
-
-// start catch_timing.hpp
-
-// Timing
-
-
-#include <tuple>
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration, typename Result>
-        struct Timing {
-            Duration elapsed;
-            Result result;
-            int iterations;
-        };
-        template <typename Clock, typename Sig>
-        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_timing.hpp
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun, typename... Args>
-            TimingOf<Clock, Fun(Args...)> measure(Fun&& fun, Args&&... args) {
-                auto start = Clock::now();
-                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
-                auto end = Clock::now();
-                auto delta = end - start;
-                return { delta, std::forward<decltype(r)>(r), 1 };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_measure.hpp
-#include <utility>
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(int)> measure_one(Fun&& fun, int iters, std::false_type) {
-                return Detail::measure<Clock>(fun, iters);
-            }
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(Chronometer)> measure_one(Fun&& fun, int iters, std::true_type) {
-                Detail::ChronometerModel<Clock> meter;
-                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
-
-                return { meter.elapsed(), std::move(result), iters };
-            }
-
-            template <typename Clock, typename Fun>
-            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
-
-            struct optimized_away_error : std::exception {
-                const char* what() const noexcept override {
-                    return "could not measure benchmark, maybe it was optimized away";
-                }
-            };
-
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
-                auto iters = seed;
-                while (iters < (1 << 30)) {
-                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
-
-                    if (Timing.elapsed >= how_long) {
-                        return { Timing.elapsed, std::move(Timing.result), iters };
-                    }
-                    iters *= 2;
-                }
-                throw optimized_away_error{};
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_run_for_at_least.hpp
-#include <algorithm>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct ExecutionPlan {
-            int iterations_per_sample;
-            Duration estimated_duration;
-            Detail::BenchmarkFunction benchmark;
-            Duration warmup_time;
-            int warmup_iterations;
-
-            template <typename Duration2>
-            operator ExecutionPlan<Duration2>() const {
-                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
-            }
-
-            template <typename Clock>
-            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
-                // warmup a bit
-                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
-
-                std::vector<FloatDuration<Clock>> times;
-                times.reserve(cfg.benchmarkSamples());
-                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
-                    Detail::ChronometerModel<Clock> model;
-                    this->benchmark(Chronometer(model, iterations_per_sample));
-                    auto sample_time = model.elapsed() - env.clock_cost.mean;
-                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
-                    return sample_time / iterations_per_sample;
-                });
-                return times;
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_execution_plan.hpp
-// start catch_estimate_clock.hpp
-
- // Environment measurement
-
-
-// start catch_stats.hpp
-
-// Statistical analysis tools
-
-
-#include <algorithm>
-#include <functional>
-#include <vector>
-#include <iterator>
-#include <numeric>
-#include <tuple>
-#include <cmath>
-#include <utility>
-#include <cstddef>
-#include <random>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            using sample = std::vector<double>;
-
-            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
-
-            template <typename Iterator>
-            OutlierClassification classify_outliers(Iterator first, Iterator last) {
-                std::vector<double> copy(first, last);
-
-                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
-                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
-                auto iqr = q3 - q1;
-                auto los = q1 - (iqr * 3.);
-                auto lom = q1 - (iqr * 1.5);
-                auto him = q3 + (iqr * 1.5);
-                auto his = q3 + (iqr * 3.);
-
-                OutlierClassification o;
-                for (; first != last; ++first) {
-                    auto&& t = *first;
-                    if (t < los) ++o.low_severe;
-                    else if (t < lom) ++o.low_mild;
-                    else if (t > his) ++o.high_severe;
-                    else if (t > him) ++o.high_mild;
-                    ++o.samples_seen;
-                }
-                return o;
-            }
-
-            template <typename Iterator>
-            double mean(Iterator first, Iterator last) {
-                auto count = last - first;
-                double sum = std::accumulate(first, last, 0.);
-                return sum / count;
-            }
-
-            template <typename URng, typename Iterator, typename Estimator>
-            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
-                auto n = last - first;
-                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
-
-                sample out;
-                out.reserve(resamples);
-                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
-                    std::vector<double> resampled;
-                    resampled.reserve(n);
-                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
-                    return estimator(resampled.begin(), resampled.end());
-                });
-                std::sort(out.begin(), out.end());
-                return out;
-            }
-
-            template <typename Estimator, typename Iterator>
-            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
-                auto n = last - first;
-                auto second = std::next(first);
-                sample results;
-                results.reserve(n);
-
-                for (auto it = first; it != last; ++it) {
-                    std::iter_swap(it, first);
-                    results.push_back(estimator(second, last));
-                }
-
-                return results;
-            }
-
-            inline double normal_cdf(double x) {
-                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
-            }
-
-            double erfc_inv(double x);
-
-            double normal_quantile(double p);
-
-            template <typename Iterator, typename Estimator>
-            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
-                auto n_samples = last - first;
-
-                double point = estimator(first, last);
-                // Degenerate case with a single sample
-                if (n_samples == 1) return { point, point, point, confidence_level };
-
-                sample jack = jackknife(estimator, first, last);
-                double jack_mean = mean(jack.begin(), jack.end());
-                double sum_squares, sum_cubes;
-                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
-                    auto d = jack_mean - x;
-                    auto d2 = d * d;
-                    auto d3 = d2 * d;
-                    return { sqcb.first + d2, sqcb.second + d3 };
-                });
-
-                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
-                int n = static_cast<int>(resample.size());
-                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
-                // degenerate case with uniform samples
-                if (prob_n == 0) return { point, point, point, confidence_level };
-
-                double bias = normal_quantile(prob_n);
-                double z1 = normal_quantile((1. - confidence_level) / 2.);
-
-                auto cumn = [n](double x) -> int {
-                    return std::lround(normal_cdf(x) * n); };
-                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
-                double b1 = bias + z1;
-                double b2 = bias - z1;
-                double a1 = a(b1);
-                double a2 = a(b2);
-                auto lo = std::max(cumn(a1), 0);
-                auto hi = std::min(cumn(a2), n - 1);
-
-                return { point, resample[lo], resample[hi], confidence_level };
-            }
-
-            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
-
-            struct bootstrap_analysis {
-                Estimate<double> mean;
-                Estimate<double> standard_deviation;
-                double outlier_variance;
-            };
-
-            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_stats.hpp
-#include <algorithm>
-#include <iterator>
-#include <tuple>
-#include <vector>
-#include <cmath>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock>
-            std::vector<double> resolution(int k) {
-                std::vector<TimePoint<Clock>> times;
-                times.reserve(k + 1);
-                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
-
-                std::vector<double> deltas;
-                deltas.reserve(k);
-                std::transform(std::next(times.begin()), times.end(), times.begin(),
-                    std::back_inserter(deltas),
-                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
-
-                return deltas;
-            }
-
-            const auto warmup_iterations = 10000;
-            const auto warmup_time = std::chrono::milliseconds(100);
-            const auto minimum_ticks = 1000;
-            const auto warmup_seed = 10000;
-            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
-            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
-            const auto clock_cost_estimation_tick_limit = 100000;
-            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
-            const auto clock_cost_estimation_iterations = 10000;
-
-            template <typename Clock>
-            int warmup() {
-                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
-                    .iterations;
-            }
-            template <typename Clock>
-            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
-                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
-                    .result;
-                return {
-                    FloatDuration<Clock>(mean(r.begin(), r.end())),
-                    classify_outliers(r.begin(), r.end()),
-                };
-            }
-            template <typename Clock>
-            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
-                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));
-                auto time_clock = [](int k) {
-                    return Detail::measure<Clock>([k] {
-                        for (int i = 0; i < k; ++i) {
-                            volatile auto ignored = Clock::now();
-                            (void)ignored;
-                        }
-                    }).elapsed;
-                };
-                time_clock(1);
-                int iters = clock_cost_estimation_iterations;
-                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
-                std::vector<double> times;
-                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
-                times.reserve(nsamples);
-                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
-                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
-                });
-                return {
-                    FloatDuration<Clock>(mean(times.begin(), times.end())),
-                    classify_outliers(times.begin(), times.end()),
-                };
-            }
-
-            template <typename Clock>
-            Environment<FloatDuration<Clock>> measure_environment() {
-                static Environment<FloatDuration<Clock>>* env = nullptr;
-                if (env) {
-                    return *env;
-                }
-
-                auto iters = Detail::warmup<Clock>();
-                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
-                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
-
-                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
-                return *env;
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_estimate_clock.hpp
-// start catch_analyse.hpp
-
- // Run and analyse one benchmark
-
-
-// start catch_sample_analysis.hpp
-
-// Benchmark results
-
-
-#include <algorithm>
-#include <vector>
-#include <string>
-#include <iterator>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct SampleAnalysis {
-            std::vector<Duration> samples;
-            Estimate<Duration> mean;
-            Estimate<Duration> standard_deviation;
-            OutlierClassification outliers;
-            double outlier_variance;
-
-            template <typename Duration2>
-            operator SampleAnalysis<Duration2>() const {
-                std::vector<Duration2> samples2;
-                samples2.reserve(samples.size());
-                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
-                return {
-                    std::move(samples2),
-                    mean,
-                    standard_deviation,
-                    outliers,
-                    outlier_variance,
-                };
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_sample_analysis.hpp
-#include <algorithm>
-#include <iterator>
-#include <vector>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Duration, typename Iterator>
-            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
-                if (!cfg.benchmarkNoAnalysis()) {
-                    std::vector<double> samples;
-                    samples.reserve(last - first);
-                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
-
-                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
-                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
-
-                    auto wrap_estimate = [](Estimate<double> e) {
-                        return Estimate<Duration> {
-                            Duration(e.point),
-                                Duration(e.lower_bound),
-                                Duration(e.upper_bound),
-                                e.confidence_interval,
-                        };
-                    };
-                    std::vector<Duration> samples2;
-                    samples2.reserve(samples.size());
-                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
-                    return {
-                        std::move(samples2),
-                        wrap_estimate(analysis.mean),
-                        wrap_estimate(analysis.standard_deviation),
-                        outliers,
-                        analysis.outlier_variance,
-                    };
-                } else {
-                    std::vector<Duration> samples;
-                    samples.reserve(last - first);
-
-                    Duration mean = Duration(0);
-                    int i = 0;
-                    for (auto it = first; it < last; ++it, ++i) {
-                        samples.push_back(Duration(*it));
-                        mean += Duration(*it);
-                    }
-                    mean /= i;
-
-                    return {
-                        std::move(samples),
-                        Estimate<Duration>{mean, mean, mean, 0.0},
-                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
-                        OutlierClassification{},
-                        0.0
-                    };
-                }
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_analyse.hpp
-#include <algorithm>
-#include <functional>
-#include <string>
-#include <vector>
-#include <cmath>
-
-namespace Catch {
-    namespace Benchmark {
-        struct Benchmark {
-            Benchmark(std::string &&name)
-                : name(std::move(name)) {}
-
-            template <class FUN>
-            Benchmark(std::string &&name, FUN &&func)
-                : fun(std::move(func)), name(std::move(name)) {}
-
-            template <typename Clock>
-            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
-                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
-                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
-                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
-                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
-                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
-            }
-
-            template <typename Clock = default_clock>
-            void run() {
-                IConfigPtr cfg = getCurrentContext().getConfig();
-
-                auto env = Detail::measure_environment<Clock>();
-
-                getResultCapture().benchmarkPreparing(name);
-                CATCH_TRY{
-                    auto plan = user_code([&] {
-                        return prepare<Clock>(*cfg, env);
-                    });
-
-                    BenchmarkInfo info {
-                        name,
-                        plan.estimated_duration.count(),
-                        plan.iterations_per_sample,
-                        cfg->benchmarkSamples(),
-                        cfg->benchmarkResamples(),
-                        env.clock_resolution.mean.count(),
-                        env.clock_cost.mean.count()
-                    };
-
-                    getResultCapture().benchmarkStarting(info);
-
-                    auto samples = user_code([&] {
-                        return plan.template run<Clock>(*cfg, env);
-                    });
-
-                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
-                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
-                    getResultCapture().benchmarkEnded(stats);
-
-                } CATCH_CATCH_ALL{
-                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
-                        std::rethrow_exception(std::current_exception());
-                }
-            }
-
-            // sets lambda to be used in fun *and* executes benchmark!
-            template <typename Fun,
-                typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
-                Benchmark & operator=(Fun func) {
-                fun = Detail::BenchmarkFunction(func);
-                run();
-                return *this;
-            }
-
-            explicit operator bool() {
-                return true;
-            }
-
-        private:
-            Detail::BenchmarkFunction fun;
-            std::string name;
-        };
-    }
-} // namespace Catch
-
-#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
-#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
-
-#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&](int benchmarkIndex)
-
-#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&]
-
-// end catch_benchmark.hpp
-// start catch_constructor.hpp
-
-// Constructor and destructor helpers
-
-
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T, bool Destruct>
-            struct ObjectStorage
-            {
-                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
-
-                ObjectStorage() : data() {}
-
-                ObjectStorage(const ObjectStorage& other)
-                {
-                    new(&data) T(other.stored_object());
-                }
-
-                ObjectStorage(ObjectStorage&& other)
-                {
-                    new(&data) T(std::move(other.stored_object()));
-                }
-
-                ~ObjectStorage() { destruct_on_exit<T>(); }
-
-                template <typename... Args>
-                void construct(Args&&... args)
-                {
-                    new (&data) T(std::forward<Args>(args)...);
-                }
-
-                template <bool AllowManualDestruction = !Destruct>
-                typename std::enable_if<AllowManualDestruction>::type destruct()
-                {
-                    stored_object().~T();
-                }
-
-            private:
-                // If this is a constructor benchmark, destruct the underlying object
-                template <typename U>
-                void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
-                // Otherwise, don't
-                template <typename U>
-                void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
-
-                T& stored_object() {
-                    return *static_cast<T*>(static_cast<void*>(&data));
-                }
-
-                T const& stored_object() const {
-                    return *static_cast<T*>(static_cast<void*>(&data));
-                }
-
-                TStorage data;
-            };
-        }
-
-        template <typename T>
-        using storage_for = Detail::ObjectStorage<T, true>;
-
-        template <typename T>
-        using destructable_object = Detail::ObjectStorage<T, false>;
-    }
-}
-
-// end catch_constructor.hpp
-// end catch_benchmarking_all.hpp
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
-#ifdef CATCH_IMPL
-// start catch_impl.hpp
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
-// Keep these here for external reporters
-// start catch_test_case_tracker.h
-
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    struct NameAndLocation {
-        std::string name;
-        SourceLineInfo location;
-
-        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
-    };
-
-    struct ITracker;
-
-    using ITrackerPtr = std::shared_ptr<ITracker>;
-
-    struct ITracker {
-        virtual ~ITracker();
-
-        // static queries
-        virtual NameAndLocation const& nameAndLocation() const = 0;
-
-        // dynamic queries
-        virtual bool isComplete() const = 0; // Successfully completed or failed
-        virtual bool isSuccessfullyCompleted() const = 0;
-        virtual bool isOpen() const = 0; // Started but not complete
-        virtual bool hasChildren() const = 0;
-
-        virtual ITracker& parent() = 0;
-
-        // actions
-        virtual void close() = 0; // Successfully complete
-        virtual void fail() = 0;
-        virtual void markAsNeedingAnotherRun() = 0;
-
-        virtual void addChild( ITrackerPtr const& child ) = 0;
-        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
-        virtual void openChild() = 0;
-
-        // Debug/ checking
-        virtual bool isSectionTracker() const = 0;
-        virtual bool isGeneratorTracker() const = 0;
-    };
-
-    class TrackerContext {
-
-        enum RunState {
-            NotStarted,
-            Executing,
-            CompletedCycle
-        };
-
-        ITrackerPtr m_rootTracker;
-        ITracker* m_currentTracker = nullptr;
-        RunState m_runState = NotStarted;
-
-    public:
-
-        ITracker& startRun();
-        void endRun();
-
-        void startCycle();
-        void completeCycle();
-
-        bool completedCycle() const;
-        ITracker& currentTracker();
-        void setCurrentTracker( ITracker* tracker );
-    };
-
-    class TrackerBase : public ITracker {
-    protected:
-        enum CycleState {
-            NotStarted,
-            Executing,
-            ExecutingChildren,
-            NeedsAnotherRun,
-            CompletedSuccessfully,
-            Failed
-        };
-
-        using Children = std::vector<ITrackerPtr>;
-        NameAndLocation m_nameAndLocation;
-        TrackerContext& m_ctx;
-        ITracker* m_parent;
-        Children m_children;
-        CycleState m_runState = NotStarted;
-
-    public:
-        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-
-        NameAndLocation const& nameAndLocation() const override;
-        bool isComplete() const override;
-        bool isSuccessfullyCompleted() const override;
-        bool isOpen() const override;
-        bool hasChildren() const override;
-
-        void addChild( ITrackerPtr const& child ) override;
-
-        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
-        ITracker& parent() override;
-
-        void openChild() override;
-
-        bool isSectionTracker() const override;
-        bool isGeneratorTracker() const override;
-
-        void open();
-
-        void close() override;
-        void fail() override;
-        void markAsNeedingAnotherRun() override;
-
-    private:
-        void moveToParent();
-        void moveToThis();
-    };
-
-    class SectionTracker : public TrackerBase {
-        std::vector<std::string> m_filters;
-        std::string m_trimmed_name;
-    public:
-        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-
-        bool isSectionTracker() const override;
-
-        bool isComplete() const override;
-
-        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
-
-        void tryOpen();
-
-        void addInitialFilters( std::vector<std::string> const& filters );
-        void addNextFilters( std::vector<std::string> const& filters );
-    };
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-
-} // namespace Catch
-
-// end catch_test_case_tracker.h
-
-// start catch_leak_detector.h
-
-namespace Catch {
-
-    struct LeakDetector {
-        LeakDetector();
-        ~LeakDetector();
-    };
-
-}
-// end catch_leak_detector.h
-// Cpp files will be included in the single-header file here
-// start catch_stats.cpp
-
-// Statistical analysis tools
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-
-#include <cassert>
-#include <random>
-
-#if defined(CATCH_CONFIG_USE_ASYNC)
-#include <future>
-#endif
-
-namespace {
-    double erf_inv(double x) {
-        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
-        double w, p;
-
-        w = -log((1.0 - x) * (1.0 + x));
-
-        if (w < 6.250000) {
-            w = w - 3.125000;
-            p = -3.6444120640178196996e-21;
-            p = -1.685059138182016589e-19 + p * w;
-            p = 1.2858480715256400167e-18 + p * w;
-            p = 1.115787767802518096e-17 + p * w;
-            p = -1.333171662854620906e-16 + p * w;
-            p = 2.0972767875968561637e-17 + p * w;
-            p = 6.6376381343583238325e-15 + p * w;
-            p = -4.0545662729752068639e-14 + p * w;
-            p = -8.1519341976054721522e-14 + p * w;
-            p = 2.6335093153082322977e-12 + p * w;
-            p = -1.2975133253453532498e-11 + p * w;
-            p = -5.4154120542946279317e-11 + p * w;
-            p = 1.051212273321532285e-09 + p * w;
-            p = -4.1126339803469836976e-09 + p * w;
-            p = -2.9070369957882005086e-08 + p * w;
-            p = 4.2347877827932403518e-07 + p * w;
-            p = -1.3654692000834678645e-06 + p * w;
-            p = -1.3882523362786468719e-05 + p * w;
-            p = 0.0001867342080340571352 + p * w;
-            p = -0.00074070253416626697512 + p * w;
-            p = -0.0060336708714301490533 + p * w;
-            p = 0.24015818242558961693 + p * w;
-            p = 1.6536545626831027356 + p * w;
-        } else if (w < 16.000000) {
-            w = sqrt(w) - 3.250000;
-            p = 2.2137376921775787049e-09;
-            p = 9.0756561938885390979e-08 + p * w;
-            p = -2.7517406297064545428e-07 + p * w;
-            p = 1.8239629214389227755e-08 + p * w;
-            p = 1.5027403968909827627e-06 + p * w;
-            p = -4.013867526981545969e-06 + p * w;
-            p = 2.9234449089955446044e-06 + p * w;
-            p = 1.2475304481671778723e-05 + p * w;
-            p = -4.7318229009055733981e-05 + p * w;
-            p = 6.8284851459573175448e-05 + p * w;
-            p = 2.4031110387097893999e-05 + p * w;
-            p = -0.0003550375203628474796 + p * w;
-            p = 0.00095328937973738049703 + p * w;
-            p = -0.0016882755560235047313 + p * w;
-            p = 0.0024914420961078508066 + p * w;
-            p = -0.0037512085075692412107 + p * w;
-            p = 0.005370914553590063617 + p * w;
-            p = 1.0052589676941592334 + p * w;
-            p = 3.0838856104922207635 + p * w;
-        } else {
-            w = sqrt(w) - 5.000000;
-            p = -2.7109920616438573243e-11;
-            p = -2.5556418169965252055e-10 + p * w;
-            p = 1.5076572693500548083e-09 + p * w;
-            p = -3.7894654401267369937e-09 + p * w;
-            p = 7.6157012080783393804e-09 + p * w;
-            p = -1.4960026627149240478e-08 + p * w;
-            p = 2.9147953450901080826e-08 + p * w;
-            p = -6.7711997758452339498e-08 + p * w;
-            p = 2.2900482228026654717e-07 + p * w;
-            p = -9.9298272942317002539e-07 + p * w;
-            p = 4.5260625972231537039e-06 + p * w;
-            p = -1.9681778105531670567e-05 + p * w;
-            p = 7.5995277030017761139e-05 + p * w;
-            p = -0.00021503011930044477347 + p * w;
-            p = -0.00013871931833623122026 + p * w;
-            p = 1.0103004648645343977 + p * w;
-            p = 4.8499064014085844221 + p * w;
-        }
-        return p * x;
-    }
-
-    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
-        auto m = Catch::Benchmark::Detail::mean(first, last);
-        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
-            double diff = b - m;
-            return a + diff * diff;
-            }) / (last - first);
-            return std::sqrt(variance);
-    }
-
-}
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-
-            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                auto count = last - first;
-                double idx = (count - 1) * k / static_cast<double>(q);
-                int j = static_cast<int>(idx);
-                double g = idx - j;
-                std::nth_element(first, first + j, last);
-                auto xj = first[j];
-                if (g == 0) return xj;
-
-                auto xj1 = *std::min_element(first + (j + 1), last);
-                return xj + g * (xj1 - xj);
-            }
-
-            double erfc_inv(double x) {
-                return erf_inv(1.0 - x);
-            }
-
-            double normal_quantile(double p) {
-                static const double ROOT_TWO = std::sqrt(2.0);
-
-                double result = 0.0;
-                assert(p >= 0 && p <= 1);
-                if (p < 0 || p > 1) {
-                    return result;
-                }
-
-                result = -erfc_inv(2.0 * p);
-                // result *= normal distribution standard deviation (1.0) * sqrt(2)
-                result *= /*sd * */ ROOT_TWO;
-                // result += normal disttribution mean (0)
-                return result;
-            }
-
-            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
-                double sb = stddev.point;
-                double mn = mean.point / n;
-                double mg_min = mn / 2.;
-                double sg = std::min(mg_min / 4., sb / std::sqrt(n));
-                double sg2 = sg * sg;
-                double sb2 = sb * sb;
-
-                auto c_max = [n, mn, sb2, sg2](double x) -> double {
-                    double k = mn - x;
-                    double d = k * k;
-                    double nd = n * d;
-                    double k0 = -n * nd;
-                    double k1 = sb2 - n * sg2 + nd;
-                    double det = k1 * k1 - 4 * sg2 * k0;
-                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
-                };
-
-                auto var_out = [n, sb2, sg2](double c) {
-                    double nc = n - c;
-                    return (nc / n) * (sb2 - nc * sg2);
-                };
-
-                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
-            }
-
-            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-                static std::random_device entropy;
-                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
-
-                auto mean = &Detail::mean<std::vector<double>::iterator>;
-                auto stddev = &standard_deviation;
-
-#if defined(CATCH_CONFIG_USE_ASYNC)
-                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
-                    auto seed = entropy();
-                    return std::async(std::launch::async, [=] {
-                        std::mt19937 rng(seed);
-                        auto resampled = resample(rng, n_resamples, first, last, f);
-                        return bootstrap(confidence_level, first, last, resampled, f);
-                    });
-                };
-
-                auto mean_future = Estimate(mean);
-                auto stddev_future = Estimate(stddev);
-
-                auto mean_estimate = mean_future.get();
-                auto stddev_estimate = stddev_future.get();
-#else
-                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
-                    auto seed = entropy();
-                    std::mt19937 rng(seed);
-                    auto resampled = resample(rng, n_resamples, first, last, f);
-                    return bootstrap(confidence_level, first, last, resampled, f);
-                };
-
-                auto mean_estimate = Estimate(mean);
-                auto stddev_estimate = Estimate(stddev);
-#endif // CATCH_USE_ASYNC
-
-                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
-
-                return { mean_estimate, stddev_estimate, outlier_variance };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-// end catch_stats.cpp
-// start catch_approx.cpp
-
-#include <cmath>
-#include <limits>
-
-namespace {
-
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
-
-}
-
-namespace Catch {
-namespace Detail {
-
-    Approx::Approx ( double value )
-    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
-        m_margin( 0.0 ),
-        m_scale( 0.0 ),
-        m_value( value )
-    {}
-
-    Approx Approx::custom() {
-        return Approx( 0 );
-    }
-
-    Approx Approx::operator-() const {
-        auto temp(*this);
-        temp.m_value = -temp.m_value;
-        return temp;
-    }
-
-    std::string Approx::toString() const {
-        ReusableStringStream rss;
-        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
-        return rss.str();
-    }
-
-    bool Approx::equalityComparisonImpl(const double other) const {
-        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
-        // Thanks to Richard Harris for his help refining the scaled margin value
-        return marginComparison(m_value, other, m_margin)
-            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
-    }
-
-    void Approx::setMargin(double newMargin) {
-        CATCH_ENFORCE(newMargin >= 0,
-            "Invalid Approx::margin: " << newMargin << '.'
-            << " Approx::Margin has to be non-negative.");
-        m_margin = newMargin;
-    }
-
-    void Approx::setEpsilon(double newEpsilon) {
-        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
-            "Invalid Approx::epsilon: " << newEpsilon << '.'
-            << " Approx::epsilon has to be in [0, 1]");
-        m_epsilon = newEpsilon;
-    }
-
-} // end namespace Detail
-
-namespace literals {
-    Detail::Approx operator "" _a(long double val) {
-        return Detail::Approx(val);
-    }
-    Detail::Approx operator "" _a(unsigned long long val) {
-        return Detail::Approx(val);
-    }
-} // end namespace literals
-
-std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
-    return value.toString();
-}
-
-} // end namespace Catch
-// end catch_approx.cpp
-// start catch_assertionhandler.cpp
-
-// start catch_debugger.h
-
-namespace Catch {
-    bool isDebuggerActive();
-}
-
-#ifdef CATCH_PLATFORM_MAC
-
-    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
-
-#elif defined(CATCH_PLATFORM_IPHONE)
-
-    // use inline assembler
-    #if defined(__i386__) || defined(__x86_64__)
-        #define CATCH_TRAP()  __asm__("int $3")
-    #elif defined(__aarch64__)
-        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
-    #elif defined(__arm__) && !defined(__thumb__)
-        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
-    #elif defined(__arm__) &&  defined(__thumb__)
-        #define CATCH_TRAP()  __asm__(".inst 0xde01")
-    #endif
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    // If we can use inline assembler, do it because this allows us to break
-    // directly at the location of the failing check instead of breaking inside
-    // raise() called from it, i.e. one stack frame below.
-    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
-        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
-    #else // Fall back to the generic way.
-        #include <signal.h>
-
-        #define CATCH_TRAP() raise(SIGTRAP)
-    #endif
-#elif defined(_MSC_VER)
-    #define CATCH_TRAP() __debugbreak()
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
-    #define CATCH_TRAP() DebugBreak()
-#endif
-
-#ifndef CATCH_BREAK_INTO_DEBUGGER
-    #ifdef CATCH_TRAP
-        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
-    #else
-        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
-    #endif
-#endif
-
-// end catch_debugger.h
-// start catch_run_context.h
-
-// start catch_fatal_condition.h
-
-// start catch_windows_h_proxy.h
-
-
-#if defined(CATCH_PLATFORM_WINDOWS)
-
-#if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
-#  define CATCH_DEFINED_NOMINMAX
-#  define NOMINMAX
-#endif
-#if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
-#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
-#endif
-
-#ifdef __AFXDLL
-#include <AfxWin.h>
-#else
-#include <windows.h>
-#endif
-
-#ifdef CATCH_DEFINED_NOMINMAX
-#  undef NOMINMAX
-#endif
-#ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN
-#  undef WIN32_LEAN_AND_MEAN
-#endif
-
-#endif // defined(CATCH_PLATFORM_WINDOWS)
-
-// end catch_windows_h_proxy.h
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-
-    struct FatalConditionHandler {
-
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
-        FatalConditionHandler();
-        static void reset();
-        ~FatalConditionHandler();
-
-    private:
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
-    };
-
-} // namespace Catch
-
-#elif defined ( CATCH_CONFIG_POSIX_SIGNALS )
-
-#include <signal.h>
-
-namespace Catch {
-
-    struct FatalConditionHandler {
-
-        static bool isSet;
-        static struct sigaction oldSigActions[];
-        static stack_t oldSigStack;
-        static char altStackMem[];
-
-        static void handleSignal( int sig );
-
-        FatalConditionHandler();
-        ~FatalConditionHandler();
-        static void reset();
-    };
-
-} // namespace Catch
-
-#else
-
-namespace Catch {
-    struct FatalConditionHandler {
-        void reset();
-    };
-}
-
-#endif
-
-// end catch_fatal_condition.h
-#include <string>
-
-namespace Catch {
-
-    struct IMutableContext;
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class RunContext : public IResultCapture, public IRunner {
-
-    public:
-        RunContext( RunContext const& ) = delete;
-        RunContext& operator =( RunContext const& ) = delete;
-
-        explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
-
-        ~RunContext() override;
-
-        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
-        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
-
-        Totals runTest(TestCase const& testCase);
-
-        IConfigPtr config() const;
-        IStreamingReporter& reporter() const;
-
-    public: // IResultCapture
-
-        // Assertion handlers
-        void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) override;
-        void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef const& message,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string const& message,
-                    AssertionReaction& reaction ) override;
-        void handleIncomplete
-                (   AssertionInfo const& info ) override;
-        void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) override;
-
-        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
-
-        void sectionEnded( SectionEndInfo const& endInfo ) override;
-        void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
-
-        auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing( std::string const& name ) override;
-        void benchmarkStarting( BenchmarkInfo const& info ) override;
-        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
-        void benchmarkFailed( std::string const& error ) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void pushScopedMessage( MessageInfo const& message ) override;
-        void popScopedMessage( MessageInfo const& message ) override;
-
-        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
-
-        std::string getCurrentTestName() const override;
-
-        const AssertionResult* getLastResult() const override;
-
-        void exceptionEarlyReported() override;
-
-        void handleFatalErrorCondition( StringRef message ) override;
-
-        bool lastAssertionPassed() override;
-
-        void assertionPassed() override;
-
-    public:
-        // !TBD We need to do this another way!
-        bool aborting() const final;
-
-    private:
-
-        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
-        void invokeActiveTestCase();
-
-        void resetAssertionInfo();
-        bool testForMissingAssertions( Counts& assertions );
-
-        void assertionEnded( AssertionResult const& result );
-        void reportExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    ITransientExpression const *expr,
-                    bool negated );
-
-        void populateReaction( AssertionReaction& reaction );
-
-    private:
-
-        void handleUnfinishedSections();
-
-        TestRunInfo m_runInfo;
-        IMutableContext& m_context;
-        TestCase const* m_activeTestCase = nullptr;
-        ITracker* m_testCaseTracker = nullptr;
-        Option<AssertionResult> m_lastResult;
-
-        IConfigPtr m_config;
-        Totals m_totals;
-        IStreamingReporterPtr m_reporter;
-        std::vector<MessageInfo> m_messages;
-        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
-        AssertionInfo m_lastAssertionInfo;
-        std::vector<SectionEndInfo> m_unfinishedSections;
-        std::vector<ITracker*> m_activeSections;
-        TrackerContext m_trackerContext;
-        bool m_lastAssertionPassed = false;
-        bool m_shouldReportUnexpected = true;
-        bool m_includeSuccessfulResults;
-    };
-
-    void seedRng(IConfig const& config);
-    unsigned int rngSeed();
-} // end namespace Catch
-
-// end catch_run_context.h
-namespace Catch {
-
-    namespace {
-        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
-            expr.streamReconstructedExpression( os );
-            return os;
-        }
-    }
-
-    LazyExpression::LazyExpression( bool isNegated )
-    :   m_isNegated( isNegated )
-    {}
-
-    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
-
-    LazyExpression::operator bool() const {
-        return m_transientExpression != nullptr;
-    }
-
-    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
-        if( lazyExpr.m_isNegated )
-            os << "!";
-
-        if( lazyExpr ) {
-            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
-                os << "(" << *lazyExpr.m_transientExpression << ")";
-            else
-                os << *lazyExpr.m_transientExpression;
-        }
-        else {
-            os << "{** error - unchecked empty expression requested **}";
-        }
-        return os;
-    }
-
-    AssertionHandler::AssertionHandler
-        (   StringRef const& macroName,
-            SourceLineInfo const& lineInfo,
-            StringRef capturedExpression,
-            ResultDisposition::Flags resultDisposition )
-    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
-        m_resultCapture( getResultCapture() )
-    {}
-
-    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
-        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
-    }
-    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
-    }
-
-    auto AssertionHandler::allowThrows() const -> bool {
-        return getCurrentContext().getConfig()->allowThrows();
-    }
-
-    void AssertionHandler::complete() {
-        setCompleted();
-        if( m_reaction.shouldDebugBreak ) {
-
-            // If you find your debugger stopping you here then go one level up on the
-            // call-stack for the code that caused it (typically a failed assertion)
-
-            // (To go back to the test and change execution, jump over the throw, next)
-            CATCH_BREAK_INTO_DEBUGGER();
-        }
-        if (m_reaction.shouldThrow) {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-            throw Catch::TestFailureException();
-#else
-            CATCH_ERROR( "Test failure requires aborting test!" );
-#endif
-        }
-    }
-    void AssertionHandler::setCompleted() {
-        m_completed = true;
-    }
-
-    void AssertionHandler::handleUnexpectedInflightException() {
-        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
-    }
-
-    void AssertionHandler::handleExceptionThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-    void AssertionHandler::handleExceptionNotThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
-        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
-    }
-
-    void AssertionHandler::handleThrowingCallSkipped() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    // This is the overload that takes a string and infers the Equals matcher from it
-    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
-        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
-    }
-
-} // namespace Catch
-// end catch_assertionhandler.cpp
-// start catch_assertionresult.cpp
-
-namespace Catch {
-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
-        lazyExpression(_lazyExpression),
-        resultType(_resultType) {}
-
-    std::string AssertionResultData::reconstructExpression() const {
-
-        if( reconstructedExpression.empty() ) {
-            if( lazyExpression ) {
-                ReusableStringStream rss;
-                rss << lazyExpression;
-                reconstructedExpression = rss.str();
-            }
-        }
-        return reconstructedExpression;
-    }
-
-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
-    :   m_info( info ),
-        m_resultData( data )
-    {}
-
-    // Result was a success
-    bool AssertionResult::succeeded() const {
-        return Catch::isOk( m_resultData.resultType );
-    }
-
-    // Result was a success, or failure is suppressed
-    bool AssertionResult::isOk() const {
-        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
-    }
-
-    ResultWas::OfType AssertionResult::getResultType() const {
-        return m_resultData.resultType;
-    }
-
-    bool AssertionResult::hasExpression() const {
-        return !m_info.capturedExpression.empty();
-    }
-
-    bool AssertionResult::hasMessage() const {
-        return !m_resultData.message.empty();
-    }
-
-    std::string AssertionResult::getExpression() const {
-        // Possibly overallocating by 3 characters should be basically free
-        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += "!(";
-        }
-        expr += m_info.capturedExpression;
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += ')';
-        }
-        return expr;
-    }
-
-    std::string AssertionResult::getExpressionInMacro() const {
-        std::string expr;
-        if( m_info.macroName.empty() )
-            expr = static_cast<std::string>(m_info.capturedExpression);
-        else {
-            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
-            expr += m_info.macroName;
-            expr += "( ";
-            expr += m_info.capturedExpression;
-            expr += " )";
-        }
-        return expr;
-    }
-
-    bool AssertionResult::hasExpandedExpression() const {
-        return hasExpression() && getExpandedExpression() != getExpression();
-    }
-
-    std::string AssertionResult::getExpandedExpression() const {
-        std::string expr = m_resultData.reconstructExpression();
-        return expr.empty()
-                ? getExpression()
-                : expr;
-    }
-
-    std::string AssertionResult::getMessage() const {
-        return m_resultData.message;
-    }
-    SourceLineInfo AssertionResult::getSourceInfo() const {
-        return m_info.lineInfo;
-    }
-
-    StringRef AssertionResult::getTestMacroName() const {
-        return m_info.macroName;
-    }
-
-} // end namespace Catch
-// end catch_assertionresult.cpp
-// start catch_capture_matchers.cpp
-
-namespace Catch {
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    // This is the general overload that takes a any string matcher
-    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
-    // the Equals matcher (so the header does not mention matchers)
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
-        std::string exceptionMessage = Catch::translateActiveException();
-        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
-        handler.handleExpr( expr );
-    }
-
-} // namespace Catch
-// end catch_capture_matchers.cpp
-// start catch_commandline.cpp
-
-// start catch_commandline.h
-
-// start catch_clara.h
-
-// Use Catch's value for console width (store Clara's off to the side, if present)
-#ifdef CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#endif
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#pragma clang diagnostic ignored "-Wexit-time-destructors"
-#pragma clang diagnostic ignored "-Wshadow"
-#endif
-
-// start clara.hpp
-// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See https://github.com/philsquared/Clara for more details
-
-// Clara v1.1.5
-
-
-#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-#ifndef CLARA_CONFIG_OPTIONAL_TYPE
-#ifdef __has_include
-#if __has_include(<optional>) && __cplusplus >= 201703L
-#include <optional>
-#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
-#endif
-#endif
-#endif
-
-// ----------- #included from clara_textflow.hpp -----------
-
-// TextFlowCpp
-//
-// A single-header library for wrapping and laying out basic text, by Phil Nash
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// This project is hosted at https://github.com/philsquared/textflowcpp
-
-
-#include <cassert>
-#include <ostream>
-#include <sstream>
-#include <vector>
-
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch {
-namespace clara {
-namespace TextFlow {
-
-inline auto isWhitespace(char c) -> bool {
-	static std::string chars = " \t\n\r";
-	return chars.find(c) != std::string::npos;
-}
-inline auto isBreakableBefore(char c) -> bool {
-	static std::string chars = "[({<|";
-	return chars.find(c) != std::string::npos;
-}
-inline auto isBreakableAfter(char c) -> bool {
-	static std::string chars = "])}>.,:;*+-=&/\\";
-	return chars.find(c) != std::string::npos;
-}
-
-class Columns;
-
-class Column {
-	std::vector<std::string> m_strings;
-	size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
-	size_t m_indent = 0;
-	size_t m_initialIndent = std::string::npos;
-
-public:
-	class iterator {
-		friend Column;
-
-		Column const& m_column;
-		size_t m_stringIndex = 0;
-		size_t m_pos = 0;
-
-		size_t m_len = 0;
-		size_t m_end = 0;
-		bool m_suffix = false;
-
-		iterator(Column const& column, size_t stringIndex)
-			: m_column(column),
-			m_stringIndex(stringIndex) {}
-
-		auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
-
-		auto isBoundary(size_t at) const -> bool {
-			assert(at > 0);
-			assert(at <= line().size());
-
-			return at == line().size() ||
-				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
-				isBreakableBefore(line()[at]) ||
-				isBreakableAfter(line()[at - 1]);
-		}
-
-		void calcLength() {
-			assert(m_stringIndex < m_column.m_strings.size());
-
-			m_suffix = false;
-			auto width = m_column.m_width - indent();
-			m_end = m_pos;
-			if (line()[m_pos] == '\n') {
-				++m_end;
-			}
-			while (m_end < line().size() && line()[m_end] != '\n')
-				++m_end;
-
-			if (m_end < m_pos + width) {
-				m_len = m_end - m_pos;
-			} else {
-				size_t len = width;
-				while (len > 0 && !isBoundary(m_pos + len))
-					--len;
-				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
-					--len;
-
-				if (len > 0) {
-					m_len = len;
-				} else {
-					m_suffix = true;
-					m_len = width - 1;
-				}
-			}
-		}
-
-		auto indent() const -> size_t {
-			auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
-			return initial == std::string::npos ? m_column.m_indent : initial;
-		}
-
-		auto addIndentAndSuffix(std::string const &plain) const -> std::string {
-			return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
-		}
-
-	public:
-		using difference_type = std::ptrdiff_t;
-		using value_type = std::string;
-		using pointer = value_type * ;
-		using reference = value_type & ;
-		using iterator_category = std::forward_iterator_tag;
-
-		explicit iterator(Column const& column) : m_column(column) {
-			assert(m_column.m_width > m_column.m_indent);
-			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
-			calcLength();
-			if (m_len == 0)
-				m_stringIndex++; // Empty string
-		}
-
-		auto operator *() const -> std::string {
-			assert(m_stringIndex < m_column.m_strings.size());
-			assert(m_pos <= m_end);
-			return addIndentAndSuffix(line().substr(m_pos, m_len));
-		}
-
-		auto operator ++() -> iterator& {
-			m_pos += m_len;
-			if (m_pos < line().size() && line()[m_pos] == '\n')
-				m_pos += 1;
-			else
-				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
-					++m_pos;
-
-			if (m_pos == line().size()) {
-				m_pos = 0;
-				++m_stringIndex;
-			}
-			if (m_stringIndex < m_column.m_strings.size())
-				calcLength();
-			return *this;
-		}
-		auto operator ++(int) -> iterator {
-			iterator prev(*this);
-			operator++();
-			return prev;
-		}
-
-		auto operator ==(iterator const& other) const -> bool {
-			return
-				m_pos == other.m_pos &&
-				m_stringIndex == other.m_stringIndex &&
-				&m_column == &other.m_column;
-		}
-		auto operator !=(iterator const& other) const -> bool {
-			return !operator==(other);
-		}
-	};
-	using const_iterator = iterator;
-
-	explicit Column(std::string const& text) { m_strings.push_back(text); }
-
-	auto width(size_t newWidth) -> Column& {
-		assert(newWidth > 0);
-		m_width = newWidth;
-		return *this;
-	}
-	auto indent(size_t newIndent) -> Column& {
-		m_indent = newIndent;
-		return *this;
-	}
-	auto initialIndent(size_t newIndent) -> Column& {
-		m_initialIndent = newIndent;
-		return *this;
-	}
-
-	auto width() const -> size_t { return m_width; }
-	auto begin() const -> iterator { return iterator(*this); }
-	auto end() const -> iterator { return { *this, m_strings.size() }; }
-
-	inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
-		bool first = true;
-		for (auto line : col) {
-			if (first)
-				first = false;
-			else
-				os << "\n";
-			os << line;
-		}
-		return os;
-	}
-
-	auto operator + (Column const& other)->Columns;
-
-	auto toString() const -> std::string {
-		std::ostringstream oss;
-		oss << *this;
-		return oss.str();
-	}
-};
-
-class Spacer : public Column {
-
-public:
-	explicit Spacer(size_t spaceWidth) : Column("") {
-		width(spaceWidth);
-	}
-};
-
-class Columns {
-	std::vector<Column> m_columns;
-
-public:
-
-	class iterator {
-		friend Columns;
-		struct EndTag {};
-
-		std::vector<Column> const& m_columns;
-		std::vector<Column::iterator> m_iterators;
-		size_t m_activeIterators;
-
-		iterator(Columns const& columns, EndTag)
-			: m_columns(columns.m_columns),
-			m_activeIterators(0) {
-			m_iterators.reserve(m_columns.size());
-
-			for (auto const& col : m_columns)
-				m_iterators.push_back(col.end());
-		}
-
-	public:
-		using difference_type = std::ptrdiff_t;
-		using value_type = std::string;
-		using pointer = value_type * ;
-		using reference = value_type & ;
-		using iterator_category = std::forward_iterator_tag;
-
-		explicit iterator(Columns const& columns)
-			: m_columns(columns.m_columns),
-			m_activeIterators(m_columns.size()) {
-			m_iterators.reserve(m_columns.size());
-
-			for (auto const& col : m_columns)
-				m_iterators.push_back(col.begin());
-		}
-
-		auto operator ==(iterator const& other) const -> bool {
-			return m_iterators == other.m_iterators;
-		}
-		auto operator !=(iterator const& other) const -> bool {
-			return m_iterators != other.m_iterators;
-		}
-		auto operator *() const -> std::string {
-			std::string row, padding;
-
-			for (size_t i = 0; i < m_columns.size(); ++i) {
-				auto width = m_columns[i].width();
-				if (m_iterators[i] != m_columns[i].end()) {
-					std::string col = *m_iterators[i];
-					row += padding + col;
-					if (col.size() < width)
-						padding = std::string(width - col.size(), ' ');
-					else
-						padding = "";
-				} else {
-					padding += std::string(width, ' ');
-				}
-			}
-			return row;
-		}
-		auto operator ++() -> iterator& {
-			for (size_t i = 0; i < m_columns.size(); ++i) {
-				if (m_iterators[i] != m_columns[i].end())
-					++m_iterators[i];
-			}
-			return *this;
-		}
-		auto operator ++(int) -> iterator {
-			iterator prev(*this);
-			operator++();
-			return prev;
-		}
-	};
-	using const_iterator = iterator;
-
-	auto begin() const -> iterator { return iterator(*this); }
-	auto end() const -> iterator { return { *this, iterator::EndTag() }; }
-
-	auto operator += (Column const& col) -> Columns& {
-		m_columns.push_back(col);
-		return *this;
-	}
-	auto operator + (Column const& col) -> Columns {
-		Columns combined = *this;
-		combined += col;
-		return combined;
-	}
-
-	inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
-
-		bool first = true;
-		for (auto line : cols) {
-			if (first)
-				first = false;
-			else
-				os << "\n";
-			os << line;
-		}
-		return os;
-	}
-
-	auto toString() const -> std::string {
-		std::ostringstream oss;
-		oss << *this;
-		return oss.str();
-	}
-};
-
-inline auto Column::operator + (Column const& other) -> Columns {
-	Columns cols;
-	cols += *this;
-	cols += other;
-	return cols;
-}
-}
-
-}
-}
-
-// ----------- end of #include from clara_textflow.hpp -----------
-// ........... back in clara.hpp
-
-#include <cctype>
-#include <string>
-#include <memory>
-#include <set>
-#include <algorithm>
-
-#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
-#define CATCH_PLATFORM_WINDOWS
-#endif
-
-namespace Catch { namespace clara {
-namespace detail {
-
-    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
-    template<typename L>
-    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
-
-    template<typename ClassT, typename ReturnT, typename... Args>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
-        static const bool isValid = false;
-    };
-
-    template<typename ClassT, typename ReturnT, typename ArgT>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
-        static const bool isValid = true;
-        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
-        using ReturnType = ReturnT;
-    };
-
-    class TokenStream;
-
-    // Transport for raw args (copied from main args, or supplied via init list for testing)
-    class Args {
-        friend TokenStream;
-        std::string m_exeName;
-        std::vector<std::string> m_args;
-
-    public:
-        Args( int argc, char const* const* argv )
-            : m_exeName(argv[0]),
-              m_args(argv + 1, argv + argc) {}
-
-        Args( std::initializer_list<std::string> args )
-        :   m_exeName( *args.begin() ),
-            m_args( args.begin()+1, args.end() )
-        {}
-
-        auto exeName() const -> std::string {
-            return m_exeName;
-        }
-    };
-
-    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
-    // may encode an option + its argument if the : or = form is used
-    enum class TokenType {
-        Option, Argument
-    };
-    struct Token {
-        TokenType type;
-        std::string token;
-    };
-
-    inline auto isOptPrefix( char c ) -> bool {
-        return c == '-'
-#ifdef CATCH_PLATFORM_WINDOWS
-            || c == '/'
-#endif
-        ;
-    }
-
-    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
-    class TokenStream {
-        using Iterator = std::vector<std::string>::const_iterator;
-        Iterator it;
-        Iterator itEnd;
-        std::vector<Token> m_tokenBuffer;
-
-        void loadBuffer() {
-            m_tokenBuffer.resize( 0 );
-
-            // Skip any empty strings
-            while( it != itEnd && it->empty() )
-                ++it;
-
-            if( it != itEnd ) {
-                auto const &next = *it;
-                if( isOptPrefix( next[0] ) ) {
-                    auto delimiterPos = next.find_first_of( " :=" );
-                    if( delimiterPos != std::string::npos ) {
-                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
-                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
-                    } else {
-                        if( next[1] != '-' && next.size() > 2 ) {
-                            std::string opt = "- ";
-                            for( size_t i = 1; i < next.size(); ++i ) {
-                                opt[1] = next[i];
-                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
-                            }
-                        } else {
-                            m_tokenBuffer.push_back( { TokenType::Option, next } );
-                        }
-                    }
-                } else {
-                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
-                }
-            }
-        }
-
-    public:
-        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
-
-        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
-            loadBuffer();
-        }
-
-        explicit operator bool() const {
-            return !m_tokenBuffer.empty() || it != itEnd;
-        }
-
-        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
-
-        auto operator*() const -> Token {
-            assert( !m_tokenBuffer.empty() );
-            return m_tokenBuffer.front();
-        }
-
-        auto operator->() const -> Token const * {
-            assert( !m_tokenBuffer.empty() );
-            return &m_tokenBuffer.front();
-        }
-
-        auto operator++() -> TokenStream & {
-            if( m_tokenBuffer.size() >= 2 ) {
-                m_tokenBuffer.erase( m_tokenBuffer.begin() );
-            } else {
-                if( it != itEnd )
-                    ++it;
-                loadBuffer();
-            }
-            return *this;
-        }
-    };
-
-    class ResultBase {
-    public:
-        enum Type {
-            Ok, LogicError, RuntimeError
-        };
-
-    protected:
-        ResultBase( Type type ) : m_type( type ) {}
-        virtual ~ResultBase() = default;
-
-        virtual void enforceOk() const = 0;
-
-        Type m_type;
-    };
-
-    template<typename T>
-    class ResultValueBase : public ResultBase {
-    public:
-        auto value() const -> T const & {
-            enforceOk();
-            return m_value;
-        }
-
-    protected:
-        ResultValueBase( Type type ) : ResultBase( type ) {}
-
-        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-        }
-
-        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
-            new( &m_value ) T( value );
-        }
-
-        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
-            if( m_type == ResultBase::Ok )
-                m_value.~T();
-            ResultBase::operator=(other);
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-            return *this;
-        }
-
-        ~ResultValueBase() override {
-            if( m_type == Ok )
-                m_value.~T();
-        }
-
-        union {
-            T m_value;
-        };
-    };
-
-    template<>
-    class ResultValueBase<void> : public ResultBase {
-    protected:
-        using ResultBase::ResultBase;
-    };
-
-    template<typename T = void>
-    class BasicResult : public ResultValueBase<T> {
-    public:
-        template<typename U>
-        explicit BasicResult( BasicResult<U> const &other )
-        :   ResultValueBase<T>( other.type() ),
-            m_errorMessage( other.errorMessage() )
-        {
-            assert( type() != ResultBase::Ok );
-        }
-
-        template<typename U>
-        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
-        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
-        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
-        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
-
-        explicit operator bool() const { return m_type == ResultBase::Ok; }
-        auto type() const -> ResultBase::Type { return m_type; }
-        auto errorMessage() const -> std::string { return m_errorMessage; }
-
-    protected:
-        void enforceOk() const override {
-
-            // Errors shouldn't reach this point, but if they do
-            // the actual error message will be in m_errorMessage
-            assert( m_type != ResultBase::LogicError );
-            assert( m_type != ResultBase::RuntimeError );
-            if( m_type != ResultBase::Ok )
-                std::abort();
-        }
-
-        std::string m_errorMessage; // Only populated if resultType is an error
-
-        BasicResult( ResultBase::Type type, std::string const &message )
-        :   ResultValueBase<T>(type),
-            m_errorMessage(message)
-        {
-            assert( m_type != ResultBase::Ok );
-        }
-
-        using ResultValueBase<T>::ResultValueBase;
-        using ResultBase::m_type;
-    };
-
-    enum class ParseResultType {
-        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
-    };
-
-    class ParseState {
-    public:
-
-        ParseState( ParseResultType type, TokenStream const &remainingTokens )
-        : m_type(type),
-          m_remainingTokens( remainingTokens )
-        {}
-
-        auto type() const -> ParseResultType { return m_type; }
-        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
-
-    private:
-        ParseResultType m_type;
-        TokenStream m_remainingTokens;
-    };
-
-    using Result = BasicResult<void>;
-    using ParserResult = BasicResult<ParseResultType>;
-    using InternalParseResult = BasicResult<ParseState>;
-
-    struct HelpColumns {
-        std::string left;
-        std::string right;
-    };
-
-    template<typename T>
-    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
-        std::stringstream ss;
-        ss << source;
-        ss >> target;
-        if( ss.fail() )
-            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
-        else
-            return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
-        target = source;
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
-        std::string srcLC = source;
-        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
-        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
-            target = true;
-        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
-            target = false;
-        else
-            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-#ifdef CLARA_CONFIG_OPTIONAL_TYPE
-    template<typename T>
-    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
-        T temp;
-        auto result = convertInto( source, temp );
-        if( result )
-            target = std::move(temp);
-        return result;
-    }
-#endif // CLARA_CONFIG_OPTIONAL_TYPE
-
-    struct NonCopyable {
-        NonCopyable() = default;
-        NonCopyable( NonCopyable const & ) = delete;
-        NonCopyable( NonCopyable && ) = delete;
-        NonCopyable &operator=( NonCopyable const & ) = delete;
-        NonCopyable &operator=( NonCopyable && ) = delete;
-    };
-
-    struct BoundRef : NonCopyable {
-        virtual ~BoundRef() = default;
-        virtual auto isContainer() const -> bool { return false; }
-        virtual auto isFlag() const -> bool { return false; }
-    };
-    struct BoundValueRefBase : BoundRef {
-        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
-    };
-    struct BoundFlagRefBase : BoundRef {
-        virtual auto setFlag( bool flag ) -> ParserResult = 0;
-        virtual auto isFlag() const -> bool { return true; }
-    };
-
-    template<typename T>
-    struct BoundValueRef : BoundValueRefBase {
-        T &m_ref;
-
-        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return convertInto( arg, m_ref );
-        }
-    };
-
-    template<typename T>
-    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
-        std::vector<T> &m_ref;
-
-        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
-
-        auto isContainer() const -> bool override { return true; }
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            T temp;
-            auto result = convertInto( arg, temp );
-            if( result )
-                m_ref.push_back( temp );
-            return result;
-        }
-    };
-
-    struct BoundFlagRef : BoundFlagRefBase {
-        bool &m_ref;
-
-        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
-
-        auto setFlag( bool flag ) -> ParserResult override {
-            m_ref = flag;
-            return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    template<typename ReturnType>
-    struct LambdaInvoker {
-        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
-
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            return lambda( arg );
-        }
-    };
-
-    template<>
-    struct LambdaInvoker<void> {
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            lambda( arg );
-            return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    template<typename ArgType, typename L>
-    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
-        ArgType temp{};
-        auto result = convertInto( arg, temp );
-        return !result
-           ? result
-           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
-    }
-
-    template<typename L>
-    struct BoundLambda : BoundValueRefBase {
-        L m_lambda;
-
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
-        }
-    };
-
-    template<typename L>
-    struct BoundFlagLambda : BoundFlagRefBase {
-        L m_lambda;
-
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
-
-        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
-
-        auto setFlag( bool flag ) -> ParserResult override {
-            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
-        }
-    };
-
-    enum class Optionality { Optional, Required };
-
-    struct Parser;
-
-    class ParserBase {
-    public:
-        virtual ~ParserBase() = default;
-        virtual auto validate() const -> Result { return Result::ok(); }
-        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
-        virtual auto cardinality() const -> size_t { return 1; }
-
-        auto parse( Args const &args ) const -> InternalParseResult {
-            return parse( args.exeName(), TokenStream( args ) );
-        }
-    };
-
-    template<typename DerivedT>
-    class ComposableParserImpl : public ParserBase {
-    public:
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser;
-
-		template<typename T>
-        auto operator+( T const &other ) const -> Parser;
-    };
-
-    // Common code and state for Args and Opts
-    template<typename DerivedT>
-    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
-    protected:
-        Optionality m_optionality = Optionality::Optional;
-        std::shared_ptr<BoundRef> m_ref;
-        std::string m_hint;
-        std::string m_description;
-
-        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
-
-    public:
-        template<typename T>
-        ParserRefImpl( T &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
-            m_hint( hint )
-        {}
-
-        template<typename LambdaT>
-        ParserRefImpl( LambdaT const &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
-            m_hint(hint)
-        {}
-
-        auto operator()( std::string const &description ) -> DerivedT & {
-            m_description = description;
-            return static_cast<DerivedT &>( *this );
-        }
-
-        auto optional() -> DerivedT & {
-            m_optionality = Optionality::Optional;
-            return static_cast<DerivedT &>( *this );
-        };
-
-        auto required() -> DerivedT & {
-            m_optionality = Optionality::Required;
-            return static_cast<DerivedT &>( *this );
-        };
-
-        auto isOptional() const -> bool {
-            return m_optionality == Optionality::Optional;
-        }
-
-        auto cardinality() const -> size_t override {
-            if( m_ref->isContainer() )
-                return 0;
-            else
-                return 1;
-        }
-
-        auto hint() const -> std::string { return m_hint; }
-    };
-
-    class ExeName : public ComposableParserImpl<ExeName> {
-        std::shared_ptr<std::string> m_name;
-        std::shared_ptr<BoundValueRefBase> m_ref;
-
-        template<typename LambdaT>
-        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
-            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
-        }
-
-    public:
-        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
-
-        explicit ExeName( std::string &ref ) : ExeName() {
-            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
-        }
-
-        template<typename LambdaT>
-        explicit ExeName( LambdaT const& lambda ) : ExeName() {
-            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
-        }
-
-        // The exe name is not parsed out of the normal tokens, but is handled specially
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-        }
-
-        auto name() const -> std::string { return *m_name; }
-        auto set( std::string const& newName ) -> ParserResult {
-
-            auto lastSlash = newName.find_last_of( "\\/" );
-            auto filename = ( lastSlash == std::string::npos )
-                    ? newName
-                    : newName.substr( lastSlash+1 );
-
-            *m_name = filename;
-            if( m_ref )
-                return m_ref->setValue( filename );
-            else
-                return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    class Arg : public ParserRefImpl<Arg> {
-    public:
-        using ParserRefImpl::ParserRefImpl;
-
-        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            auto const &token = *remainingTokens;
-            if( token.type != TokenType::Argument )
-                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
-
-            assert( !m_ref->isFlag() );
-            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
-
-            auto result = valueRef->setValue( remainingTokens->token );
-            if( !result )
-                return InternalParseResult( result );
-            else
-                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-        }
-    };
-
-    inline auto normaliseOpt( std::string const &optName ) -> std::string {
-#ifdef CATCH_PLATFORM_WINDOWS
-        if( optName[0] == '/' )
-            return "-" + optName.substr( 1 );
-        else
-#endif
-            return optName;
-    }
-
-    class Opt : public ParserRefImpl<Opt> {
-    protected:
-        std::vector<std::string> m_optNames;
-
-    public:
-        template<typename LambdaT>
-        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
-
-        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
-
-        template<typename LambdaT>
-        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
-
-        template<typename T>
-        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
-
-        auto operator[]( std::string const &optName ) -> Opt & {
-            m_optNames.push_back( optName );
-            return *this;
-        }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::ostringstream oss;
-            bool first = true;
-            for( auto const &opt : m_optNames ) {
-                if (first)
-                    first = false;
-                else
-                    oss << ", ";
-                oss << opt;
-            }
-            if( !m_hint.empty() )
-                oss << " <" << m_hint << ">";
-            return { { oss.str(), m_description } };
-        }
-
-        auto isMatch( std::string const &optToken ) const -> bool {
-            auto normalisedToken = normaliseOpt( optToken );
-            for( auto const &name : m_optNames ) {
-                if( normaliseOpt( name ) == normalisedToken )
-                    return true;
-            }
-            return false;
-        }
-
-        using ParserBase::parse;
-
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
-                auto const &token = *remainingTokens;
-                if( isMatch(token.token ) ) {
-                    if( m_ref->isFlag() ) {
-                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
-                        auto result = flagRef->setFlag( true );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    } else {
-                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
-                        ++remainingTokens;
-                        if( !remainingTokens )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto const &argToken = *remainingTokens;
-                        if( argToken.type != TokenType::Argument )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto result = valueRef->setValue( argToken.token );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    }
-                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-                }
-            }
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
-        }
-
-        auto validate() const -> Result override {
-            if( m_optNames.empty() )
-                return Result::logicError( "No options supplied to Opt" );
-            for( auto const &name : m_optNames ) {
-                if( name.empty() )
-                    return Result::logicError( "Option name cannot be empty" );
-#ifdef CATCH_PLATFORM_WINDOWS
-                if( name[0] != '-' && name[0] != '/' )
-                    return Result::logicError( "Option name must begin with '-' or '/'" );
-#else
-                if( name[0] != '-' )
-                    return Result::logicError( "Option name must begin with '-'" );
-#endif
-            }
-            return ParserRefImpl::validate();
-        }
-    };
-
-    struct Help : Opt {
-        Help( bool &showHelpFlag )
-        :   Opt([&]( bool flag ) {
-                showHelpFlag = flag;
-                return ParserResult::ok( ParseResultType::ShortCircuitAll );
-            })
-        {
-            static_cast<Opt &>( *this )
-                    ("display usage information")
-                    ["-?"]["-h"]["--help"]
-                    .optional();
-        }
-    };
-
-    struct Parser : ParserBase {
-
-        mutable ExeName m_exeName;
-        std::vector<Opt> m_options;
-        std::vector<Arg> m_args;
-
-        auto operator|=( ExeName const &exeName ) -> Parser & {
-            m_exeName = exeName;
-            return *this;
-        }
-
-        auto operator|=( Arg const &arg ) -> Parser & {
-            m_args.push_back(arg);
-            return *this;
-        }
-
-        auto operator|=( Opt const &opt ) -> Parser & {
-            m_options.push_back(opt);
-            return *this;
-        }
-
-        auto operator|=( Parser const &other ) -> Parser & {
-            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
-            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
-            return *this;
-        }
-
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser {
-            return Parser( *this ) |= other;
-        }
-
-        // Forward deprecated interface with '+' instead of '|'
-        template<typename T>
-        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
-        template<typename T>
-        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::vector<HelpColumns> cols;
-            for (auto const &o : m_options) {
-                auto childCols = o.getHelpColumns();
-                cols.insert( cols.end(), childCols.begin(), childCols.end() );
-            }
-            return cols;
-        }
-
-        void writeToStream( std::ostream &os ) const {
-            if (!m_exeName.name().empty()) {
-                os << "usage:\n" << "  " << m_exeName.name() << " ";
-                bool required = true, first = true;
-                for( auto const &arg : m_args ) {
-                    if (first)
-                        first = false;
-                    else
-                        os << " ";
-                    if( arg.isOptional() && required ) {
-                        os << "[";
-                        required = false;
-                    }
-                    os << "<" << arg.hint() << ">";
-                    if( arg.cardinality() == 0 )
-                        os << " ... ";
-                }
-                if( !required )
-                    os << "]";
-                if( !m_options.empty() )
-                    os << " options";
-                os << "\n\nwhere options are:" << std::endl;
-            }
-
-            auto rows = getHelpColumns();
-            size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
-            size_t optWidth = 0;
-            for( auto const &cols : rows )
-                optWidth = (std::max)(optWidth, cols.left.size() + 2);
-
-            optWidth = (std::min)(optWidth, consoleWidth/2);
-
-            for( auto const &cols : rows ) {
-                auto row =
-                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
-                        TextFlow::Spacer(4) +
-                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
-                os << row << std::endl;
-            }
-        }
-
-        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
-            parser.writeToStream( os );
-            return os;
-        }
-
-        auto validate() const -> Result override {
-            for( auto const &opt : m_options ) {
-                auto result = opt.validate();
-                if( !result )
-                    return result;
-            }
-            for( auto const &arg : m_args ) {
-                auto result = arg.validate();
-                if( !result )
-                    return result;
-            }
-            return Result::ok();
-        }
-
-        using ParserBase::parse;
-
-        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
-
-            struct ParserInfo {
-                ParserBase const* parser = nullptr;
-                size_t count = 0;
-            };
-            const size_t totalParsers = m_options.size() + m_args.size();
-            assert( totalParsers < 512 );
-            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
-            ParserInfo parseInfos[512];
-
-            {
-                size_t i = 0;
-                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
-                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
-            }
-
-            m_exeName.set( exeName );
-
-            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-            while( result.value().remainingTokens() ) {
-                bool tokenParsed = false;
-
-                for( size_t i = 0; i < totalParsers; ++i ) {
-                    auto&  parseInfo = parseInfos[i];
-                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
-                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
-                        if (!result)
-                            return result;
-                        if (result.value().type() != ParseResultType::NoMatch) {
-                            tokenParsed = true;
-                            ++parseInfo.count;
-                            break;
-                        }
-                    }
-                }
-
-                if( result.value().type() == ParseResultType::ShortCircuitAll )
-                    return result;
-                if( !tokenParsed )
-                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
-            }
-            // !TBD Check missing required options
-            return result;
-        }
-    };
-
-    template<typename DerivedT>
-    template<typename T>
-    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
-        return Parser() | static_cast<DerivedT const &>( *this ) | other;
-    }
-} // namespace detail
-
-// A Combined parser
-using detail::Parser;
-
-// A parser for options
-using detail::Opt;
-
-// A parser for arguments
-using detail::Arg;
-
-// Wrapper for argc, argv from main()
-using detail::Args;
-
-// Specifies the name of the executable
-using detail::ExeName;
-
-// Convenience wrapper for option parser that specifies the help option
-using detail::Help;
-
-// enum of result types from a parse
-using detail::ParseResultType;
-
-// Result type for parser operation
-using detail::ParserResult;
-
-}} // namespace Catch::clara
-
-// end clara.hpp
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// Restore Clara's value for console width, if present
-#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-// end catch_clara.h
-namespace Catch {
-
-    clara::Parser makeCommandLineParser( ConfigData& config );
-
-} // end namespace Catch
-
-// end catch_commandline.h
-#include <fstream>
-#include <ctime>
-
-namespace Catch {
-
-    clara::Parser makeCommandLineParser( ConfigData& config ) {
-
-        using namespace clara;
-
-        auto const setWarning = [&]( std::string const& warning ) {
-                auto warningSet = [&]() {
-                    if( warning == "NoAssertions" )
-                        return WarnAbout::NoAssertions;
-
-                    if ( warning == "NoTests" )
-                        return WarnAbout::NoTests;
-
-                    return WarnAbout::Nothing;
-                }();
-
-                if (warningSet == WarnAbout::Nothing)
-                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
-                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
-                std::ifstream f( filename.c_str() );
-                if( !f.is_open() )
-                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
-
-                std::string line;
-                while( std::getline( f, line ) ) {
-                    line = trim(line);
-                    if( !line.empty() && !startsWith( line, '#' ) ) {
-                        if( !startsWith( line, '"' ) )
-                            line = '"' + line + '"';
-                        config.testsOrTags.push_back( line );
-                        config.testsOrTags.emplace_back( "," );
-                    }
-                }
-                //Remove comma in the end
-                if(!config.testsOrTags.empty())
-                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
-
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setTestOrder = [&]( std::string const& order ) {
-                if( startsWith( "declared", order ) )
-                    config.runOrder = RunTests::InDeclarationOrder;
-                else if( startsWith( "lexical", order ) )
-                    config.runOrder = RunTests::InLexicographicalOrder;
-                else if( startsWith( "random", order ) )
-                    config.runOrder = RunTests::InRandomOrder;
-                else
-                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setRngSeed = [&]( std::string const& seed ) {
-                if( seed != "time" )
-                    return clara::detail::convertInto( seed, config.rngSeed );
-                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setColourUsage = [&]( std::string const& useColour ) {
-                    auto mode = toLower( useColour );
-
-                    if( mode == "yes" )
-                        config.useColour = UseColour::Yes;
-                    else if( mode == "no" )
-                        config.useColour = UseColour::No;
-                    else if( mode == "auto" )
-                        config.useColour = UseColour::Auto;
-                    else
-                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
-                auto keypressLc = toLower( keypress );
-                if (keypressLc == "never")
-                    config.waitForKeypress = WaitForKeypress::Never;
-                else if( keypressLc == "start" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStart;
-                else if( keypressLc == "exit" )
-                    config.waitForKeypress = WaitForKeypress::BeforeExit;
-                else if( keypressLc == "both" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
-                else
-                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
-            return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setVerbosity = [&]( std::string const& verbosity ) {
-            auto lcVerbosity = toLower( verbosity );
-            if( lcVerbosity == "quiet" )
-                config.verbosity = Verbosity::Quiet;
-            else if( lcVerbosity == "normal" )
-                config.verbosity = Verbosity::Normal;
-            else if( lcVerbosity == "high" )
-                config.verbosity = Verbosity::High;
-            else
-                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-        auto const setReporter = [&]( std::string const& reporter ) {
-            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-
-            auto lcReporter = toLower( reporter );
-            auto result = factories.find( lcReporter );
-
-            if( factories.end() != result )
-                config.reporterName = lcReporter;
-            else
-                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-
-        auto cli
-            = ExeName( config.processName )
-            | Help( config.showHelp )
-            | Opt( config.listTests )
-                ["-l"]["--list-tests"]
-                ( "list all/matching test cases" )
-            | Opt( config.listTags )
-                ["-t"]["--list-tags"]
-                ( "list all/matching tags" )
-            | Opt( config.showSuccessfulTests )
-                ["-s"]["--success"]
-                ( "include successful tests in output" )
-            | Opt( config.shouldDebugBreak )
-                ["-b"]["--break"]
-                ( "break into debugger on failure" )
-            | Opt( config.noThrow )
-                ["-e"]["--nothrow"]
-                ( "skip exception tests" )
-            | Opt( config.showInvisibles )
-                ["-i"]["--invisibles"]
-                ( "show invisibles (tabs, newlines)" )
-            | Opt( config.outputFilename, "filename" )
-                ["-o"]["--out"]
-                ( "output filename" )
-            | Opt( setReporter, "name" )
-                ["-r"]["--reporter"]
-                ( "reporter to use (defaults to console)" )
-            | Opt( config.name, "name" )
-                ["-n"]["--name"]
-                ( "suite name" )
-            | Opt( [&]( bool ){ config.abortAfter = 1; } )
-                ["-a"]["--abort"]
-                ( "abort at first failure" )
-            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
-                ["-x"]["--abortx"]
-                ( "abort after x failures" )
-            | Opt( setWarning, "warning name" )
-                ["-w"]["--warn"]
-                ( "enable warnings" )
-            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
-                ["-d"]["--durations"]
-                ( "show test durations" )
-            | Opt( loadTestNamesFromFile, "filename" )
-                ["-f"]["--input-file"]
-                ( "load test names to run from a file" )
-            | Opt( config.filenamesAsTags )
-                ["-#"]["--filenames-as-tags"]
-                ( "adds a tag for the filename" )
-            | Opt( config.sectionsToRun, "section name" )
-                ["-c"]["--section"]
-                ( "specify section to run" )
-            | Opt( setVerbosity, "quiet|normal|high" )
-                ["-v"]["--verbosity"]
-                ( "set output verbosity" )
-            | Opt( config.listTestNamesOnly )
-                ["--list-test-names-only"]
-                ( "list all/matching test cases names only" )
-            | Opt( config.listReporters )
-                ["--list-reporters"]
-                ( "list all reporters" )
-            | Opt( setTestOrder, "decl|lex|rand" )
-                ["--order"]
-                ( "test case order (defaults to decl)" )
-            | Opt( setRngSeed, "'time'|number" )
-                ["--rng-seed"]
-                ( "set a specific seed for random numbers" )
-            | Opt( setColourUsage, "yes|no" )
-                ["--use-colour"]
-                ( "should output be colourised" )
-            | Opt( config.libIdentify )
-                ["--libidentify"]
-                ( "report name and version according to libidentify standard" )
-            | Opt( setWaitForKeypress, "never|start|exit|both" )
-                ["--wait-for-keypress"]
-                ( "waits for a keypress before exiting" )
-            | Opt( config.benchmarkSamples, "samples" )
-                ["--benchmark-samples"]
-                ( "number of samples to collect (default: 100)" )
-            | Opt( config.benchmarkResamples, "resamples" )
-                ["--benchmark-resamples"]
-                ( "number of resamples for the bootstrap (default: 100000)" )
-            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
-                ["--benchmark-confidence-interval"]
-                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
-            | Opt( config.benchmarkNoAnalysis )
-                ["--benchmark-no-analysis"]
-                ( "perform only measurements; do not perform any analysis" )
-            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
-                ["--benchmark-warmup-time"]
-                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
-            | Arg( config.testsOrTags, "test name|pattern|tags" )
-                ( "which test or tests to use" );
-
-        return cli;
-    }
-
-} // end namespace Catch
-// end catch_commandline.cpp
-// start catch_common.cpp
-
-#include <cstring>
-#include <ostream>
-
-namespace Catch {
-
-    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
-        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
-    }
-    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
-        // We can assume that the same file will usually have the same pointer.
-        // Thus, if the pointers are the same, there is no point in calling the strcmp
-        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
-    }
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
-#ifndef __GNUG__
-        os << info.file << '(' << info.line << ')';
-#else
-        os << info.file << ':' << info.line;
-#endif
-        return os;
-    }
-
-    std::string StreamEndStop::operator+() const {
-        return std::string();
-    }
-
-    NonCopyable::NonCopyable() = default;
-    NonCopyable::~NonCopyable() = default;
-
-}
-// end catch_common.cpp
-// start catch_config.cpp
-
-namespace Catch {
-
-    Config::Config( ConfigData const& data )
-    :   m_data( data ),
-        m_stream( openStream() )
-    {
-        // We need to trim filter specs to avoid trouble with superfluous
-        // whitespace (esp. important for bdd macros, as those are manually
-        // aligned with whitespace).
-
-        for (auto& elem : m_data.testsOrTags) {
-            elem = trim(elem);
-        }
-        for (auto& elem : m_data.sectionsToRun) {
-            elem = trim(elem);
-        }
-
-        TestSpecParser parser(ITagAliasRegistry::get());
-        if (!m_data.testsOrTags.empty()) {
-            m_hasTestFilters = true;
-            for (auto const& testOrTags : m_data.testsOrTags) {
-                parser.parse(testOrTags);
-            }
-        }
-        m_testSpec = parser.testSpec();
-    }
-
-    std::string const& Config::getFilename() const {
-        return m_data.outputFilename ;
-    }
-
-    bool Config::listTests() const          { return m_data.listTests; }
-    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
-    bool Config::listTags() const           { return m_data.listTags; }
-    bool Config::listReporters() const      { return m_data.listReporters; }
-
-    std::string Config::getProcessName() const { return m_data.processName; }
-    std::string const& Config::getReporterName() const { return m_data.reporterName; }
-
-    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
-    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
-
-    TestSpec const& Config::testSpec() const { return m_testSpec; }
-    bool Config::hasTestFilters() const { return m_hasTestFilters; }
-
-    bool Config::showHelp() const { return m_data.showHelp; }
-
-    // IConfig interface
-    bool Config::allowThrows() const                   { return !m_data.noThrow; }
-    std::ostream& Config::stream() const               { return m_stream->stream(); }
-    std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
-    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
-    bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
-    bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
-    ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
-    RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
-    unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
-    UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
-    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
-    int Config::abortAfter() const                     { return m_data.abortAfter; }
-    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
-    Verbosity Config::verbosity() const                { return m_data.verbosity; }
-
-    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
-    int Config::benchmarkSamples() const                          { return m_data.benchmarkSamples; }
-    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
-    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
-    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
-
-    IStream const* Config::openStream() {
-        return Catch::makeStream(m_data.outputFilename);
-    }
-
-} // end namespace Catch
-// end catch_config.cpp
-// start catch_console_colour.cpp
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-// start catch_errno_guard.h
-
-namespace Catch {
-
-    class ErrnoGuard {
-    public:
-        ErrnoGuard();
-        ~ErrnoGuard();
-    private:
-        int m_oldErrno;
-    };
-
-}
-
-// end catch_errno_guard.h
-#include <sstream>
-
-namespace Catch {
-    namespace {
-
-        struct IColourImpl {
-            virtual ~IColourImpl() = default;
-            virtual void use( Colour::Code _colourCode ) = 0;
-        };
-
-        struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) override {}
-
-            static IColourImpl* instance() {
-                static NoColourImpl s_instance;
-                return &s_instance;
-            }
-        };
-
-    } // anon namespace
-} // namespace Catch
-
-#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
-#   ifdef CATCH_PLATFORM_WINDOWS
-#       define CATCH_CONFIG_COLOUR_WINDOWS
-#   else
-#       define CATCH_CONFIG_COLOUR_ANSI
-#   endif
-#endif
-
-#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
-
-namespace Catch {
-namespace {
-
-    class Win32ColourImpl : public IColourImpl {
-    public:
-        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
-        {
-            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
-            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
-            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
-            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
-        }
-
-        void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
-                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
-                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
-                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
-                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
-                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
-                case Colour::Grey:      return setTextAttribute( 0 );
-
-                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
-                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
-                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
-                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-
-                default:
-                    CATCH_ERROR( "Unknown colour requested" );
-            }
-        }
-
-    private:
-        void setTextAttribute( WORD _textAttribute ) {
-            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
-        }
-        HANDLE stdoutHandle;
-        WORD originalForegroundAttributes;
-        WORD originalBackgroundAttributes;
-    };
-
-    IColourImpl* platformColourInstance() {
-        static Win32ColourImpl s_instance;
-
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = UseColour::Yes;
-        return colourMode == UseColour::Yes
-            ? &s_instance
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
-
-#include <unistd.h>
-
-namespace Catch {
-namespace {
-
-    // use POSIX/ ANSI console terminal codes
-    // Thanks to Adam Strzelecki for original contribution
-    // (http://github.com/nanoant)
-    // https://github.com/philsquared/Catch/pull/131
-    class PosixColourImpl : public IColourImpl {
-    public:
-        void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:
-                case Colour::White:     return setColour( "[0m" );
-                case Colour::Red:       return setColour( "[0;31m" );
-                case Colour::Green:     return setColour( "[0;32m" );
-                case Colour::Blue:      return setColour( "[0;34m" );
-                case Colour::Cyan:      return setColour( "[0;36m" );
-                case Colour::Yellow:    return setColour( "[0;33m" );
-                case Colour::Grey:      return setColour( "[1;30m" );
-
-                case Colour::LightGrey:     return setColour( "[0;37m" );
-                case Colour::BrightRed:     return setColour( "[1;31m" );
-                case Colour::BrightGreen:   return setColour( "[1;32m" );
-                case Colour::BrightWhite:   return setColour( "[1;37m" );
-                case Colour::BrightYellow:  return setColour( "[1;33m" );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
-            }
-        }
-        static IColourImpl* instance() {
-            static PosixColourImpl s_instance;
-            return &s_instance;
-        }
-
-    private:
-        void setColour( const char* _escapeCode ) {
-            getCurrentContext().getConfig()->stream()
-                << '\033' << _escapeCode;
-        }
-    };
-
-    bool useColourOnPlatform() {
-        return
-#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
-            !isDebuggerActive() &&
-#endif
-#if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
-            isatty(STDOUT_FILENO)
-#else
-            false
-#endif
-            ;
-    }
-    IColourImpl* platformColourInstance() {
-        ErrnoGuard guard;
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = useColourOnPlatform()
-                ? UseColour::Yes
-                : UseColour::No;
-        return colourMode == UseColour::Yes
-            ? PosixColourImpl::instance()
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#else  // not Windows or ANSI ///////////////////////////////////////////////
-
-namespace Catch {
-
-    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
-
-} // end namespace Catch
-
-#endif // Windows/ ANSI/ None
-
-namespace Catch {
-
-    Colour::Colour( Code _colourCode ) { use( _colourCode ); }
-    Colour::Colour( Colour&& other ) noexcept {
-        m_moved = other.m_moved;
-        other.m_moved = true;
-    }
-    Colour& Colour::operator=( Colour&& other ) noexcept {
-        m_moved = other.m_moved;
-        other.m_moved  = true;
-        return *this;
-    }
-
-    Colour::~Colour(){ if( !m_moved ) use( None ); }
-
-    void Colour::use( Code _colourCode ) {
-        static IColourImpl* impl = platformColourInstance();
-        // Strictly speaking, this cannot possibly happen.
-        // However, under some conditions it does happen (see #1626),
-        // and this change is small enough that we can let practicality
-        // triumph over purity in this case.
-        if (impl != nullptr) {
-            impl->use( _colourCode );
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, Colour const& ) {
-        return os;
-    }
-
-} // end namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-
-// end catch_console_colour.cpp
-// start catch_context.cpp
-
-namespace Catch {
-
-    class Context : public IMutableContext, NonCopyable {
-
-    public: // IContext
-        IResultCapture* getResultCapture() override {
-            return m_resultCapture;
-        }
-        IRunner* getRunner() override {
-            return m_runner;
-        }
-
-        IConfigPtr const& getConfig() const override {
-            return m_config;
-        }
-
-        ~Context() override;
-
-    public: // IMutableContext
-        void setResultCapture( IResultCapture* resultCapture ) override {
-            m_resultCapture = resultCapture;
-        }
-        void setRunner( IRunner* runner ) override {
-            m_runner = runner;
-        }
-        void setConfig( IConfigPtr const& config ) override {
-            m_config = config;
-        }
-
-        friend IMutableContext& getCurrentMutableContext();
-
-    private:
-        IConfigPtr m_config;
-        IRunner* m_runner = nullptr;
-        IResultCapture* m_resultCapture = nullptr;
-    };
-
-    IMutableContext *IMutableContext::currentContext = nullptr;
-
-    void IMutableContext::createContext()
-    {
-        currentContext = new Context();
-    }
-
-    void cleanUpContext() {
-        delete IMutableContext::currentContext;
-        IMutableContext::currentContext = nullptr;
-    }
-    IContext::~IContext() = default;
-    IMutableContext::~IMutableContext() = default;
-    Context::~Context() = default;
-
-    SimplePcg32& rng() {
-        static SimplePcg32 s_rng;
-        return s_rng;
-    }
-
-}
-// end catch_context.cpp
-// start catch_debug_console.cpp
-
-// start catch_debug_console.h
-
-#include <string>
-
-namespace Catch {
-    void writeToDebugConsole( std::string const& text );
-}
-
-// end catch_debug_console.h
-#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#include <android/log.h>
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
-        }
-    }
-
-#elif defined(CATCH_PLATFORM_WINDOWS)
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            ::OutputDebugStringA( text.c_str() );
-        }
-    }
-
-#else
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            // !TBD: Need a version for Mac/ XCode and other IDEs
-            Catch::cout() << text;
-        }
-    }
-
-#endif // Platform
-// end catch_debug_console.cpp
-// start catch_debugger.cpp
-
-#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
-
-#  include <assert.h>
-#  include <stdbool.h>
-#  include <sys/types.h>
-#  include <unistd.h>
-#  include <cstddef>
-#  include <ostream>
-
-#ifdef __apple_build_version__
-    // These headers will only compile with AppleClang (XCode)
-    // For other compilers (Clang, GCC, ... ) we need to exclude them
-#  include <sys/sysctl.h>
-#endif
-
-    namespace Catch {
-        #ifdef __apple_build_version__
-        // The following function is taken directly from the following technical note:
-        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
-
-        // Returns true if the current process is being debugged (either
-        // running under the debugger or has a debugger attached post facto).
-        bool isDebuggerActive(){
-            int                 mib[4];
-            struct kinfo_proc   info;
-            std::size_t         size;
-
-            // Initialize the flags so that, if sysctl fails for some bizarre
-            // reason, we get a predictable result.
-
-            info.kp_proc.p_flag = 0;
-
-            // Initialize mib, which tells sysctl the info we want, in this case
-            // we're looking for information about a specific process ID.
-
-            mib[0] = CTL_KERN;
-            mib[1] = KERN_PROC;
-            mib[2] = KERN_PROC_PID;
-            mib[3] = getpid();
-
-            // Call sysctl.
-
-            size = sizeof(info);
-            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
-                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
-                return false;
-            }
-
-            // We're being debugged if the P_TRACED flag is set.
-
-            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
-        }
-        #else
-        bool isDebuggerActive() {
-            // We need to find another way to determine this for non-appleclang compilers on macOS
-            return false;
-        }
-        #endif
-    } // namespace Catch
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    #include <fstream>
-    #include <string>
-
-    namespace Catch{
-        // The standard POSIX way of detecting a debugger is to attempt to
-        // ptrace() the process, but this needs to be done from a child and not
-        // this process itself to still allow attaching to this process later
-        // if wanted, so is rather heavy. Under Linux we have the PID of the
-        // "debugger" (which doesn't need to be gdb, of course, it could also
-        // be strace, for example) in /proc/$PID/status, so just get it from
-        // there instead.
-        bool isDebuggerActive(){
-            // Libstdc++ has a bug, where std::ifstream sets errno to 0
-            // This way our users can properly assert over errno values
-            ErrnoGuard guard;
-            std::ifstream in("/proc/self/status");
-            for( std::string line; std::getline(in, line); ) {
-                static const int PREFIX_LEN = 11;
-                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
-                    // We're traced if the PID is not 0 and no other PID starts
-                    // with 0 digit, so it's enough to check for just a single
-                    // character.
-                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
-                }
-            }
-
-            return false;
-        }
-    } // namespace Catch
-#elif defined(_MSC_VER)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#else
-    namespace Catch {
-       bool isDebuggerActive() { return false; }
-    }
-#endif // Platform
-// end catch_debugger.cpp
-// start catch_decomposer.cpp
-
-namespace Catch {
-
-    ITransientExpression::~ITransientExpression() = default;
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
-        if( lhs.size() + rhs.size() < 40 &&
-                lhs.find('\n') == std::string::npos &&
-                rhs.find('\n') == std::string::npos )
-            os << lhs << " " << op << " " << rhs;
-        else
-            os << lhs << "\n" << op << "\n" << rhs;
-    }
-}
-// end catch_decomposer.cpp
-// start catch_enforce.cpp
-
-#include <stdexcept>
-
-namespace Catch {
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
-    [[noreturn]]
-    void throw_exception(std::exception const& e) {
-        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
-                      << "The message was: " << e.what() << '\n';
-        std::terminate();
-    }
-#endif
-
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg) {
-        throw_exception(std::logic_error(msg));
-    }
-
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg) {
-        throw_exception(std::domain_error(msg));
-    }
-
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg) {
-        throw_exception(std::runtime_error(msg));
-    }
-
-} // namespace Catch;
-// end catch_enforce.cpp
-// start catch_enum_values_registry.cpp
-// start catch_enum_values_registry.h
-
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    namespace Detail {
-
-        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
-
-        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
-
-            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
-
-            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
-        };
-
-        std::vector<StringRef> parseEnums( StringRef enums );
-
-    } // Detail
-
-} // Catch
-
-// end catch_enum_values_registry.h
-
-#include <map>
-#include <cassert>
-
-namespace Catch {
-
-    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
-
-    namespace Detail {
-
-        namespace {
-            // Extracts the actual name part of an enum instance
-            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
-            StringRef extractInstanceName(StringRef enumInstance) {
-                // Find last occurence of ":"
-                size_t name_start = enumInstance.size();
-                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
-                    --name_start;
-                }
-                return enumInstance.substr(name_start, enumInstance.size() - name_start);
-            }
-        }
-
-        std::vector<StringRef> parseEnums( StringRef enums ) {
-            auto enumValues = splitStringRef( enums, ',' );
-            std::vector<StringRef> parsed;
-            parsed.reserve( enumValues.size() );
-            for( auto const& enumValue : enumValues ) {
-                parsed.push_back(trim(extractInstanceName(enumValue)));
-            }
-            return parsed;
-        }
-
-        EnumInfo::~EnumInfo() {}
-
-        StringRef EnumInfo::lookup( int value ) const {
-            for( auto const& valueToName : m_values ) {
-                if( valueToName.first == value )
-                    return valueToName.second;
-            }
-            return "{** unexpected enum value **}"_sr;
-        }
-
-        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
-            enumInfo->m_name = enumName;
-            enumInfo->m_values.reserve( values.size() );
-
-            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
-            assert( valueNames.size() == values.size() );
-            std::size_t i = 0;
-            for( auto value : values )
-                enumInfo->m_values.emplace_back(value, valueNames[i++]);
-
-            return enumInfo;
-        }
-
-        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
-            return *m_enumInfos.back();
-        }
-
-    } // Detail
-} // Catch
-
-// end catch_enum_values_registry.cpp
-// start catch_errno_guard.cpp
-
-#include <cerrno>
-
-namespace Catch {
-        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
-        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
-}
-// end catch_errno_guard.cpp
-// start catch_exception_translator_registry.cpp
-
-// start catch_exception_translator_registry.h
-
-#include <vector>
-#include <string>
-#include <memory>
-
-namespace Catch {
-
-    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
-    public:
-        ~ExceptionTranslatorRegistry();
-        virtual void registerTranslator( const IExceptionTranslator* translator );
-        std::string translateActiveException() const override;
-        std::string tryTranslators() const;
-
-    private:
-        std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
-    };
-}
-
-// end catch_exception_translator_registry.h
-#ifdef __OBJC__
-#import "Foundation/Foundation.h"
-#endif
-
-namespace Catch {
-
-    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
-    }
-
-    void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
-        m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
-    }
-
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        try {
-#ifdef __OBJC__
-            // In Objective-C try objective-c exceptions first
-            @try {
-                return tryTranslators();
-            }
-            @catch (NSException *exception) {
-                return Catch::Detail::stringify( [exception description] );
-            }
-#else
-            // Compiling a mixed mode project with MSVC means that CLR
-            // exceptions will be caught in (...) as well. However, these
-            // do not fill-in std::current_exception and thus lead to crash
-            // when attempting rethrow.
-            // /EHa switch also causes structured exceptions to be caught
-            // here, but they fill-in current_exception properly, so
-            // at worst the output should be a little weird, instead of
-            // causing a crash.
-            if (std::current_exception() == nullptr) {
-                return "Non C++ exception. Possibly a CLR exception.";
-            }
-            return tryTranslators();
-#endif
-        }
-        catch( TestFailureException& ) {
-            std::rethrow_exception(std::current_exception());
-        }
-        catch( std::exception& ex ) {
-            return ex.what();
-        }
-        catch( std::string& msg ) {
-            return msg;
-        }
-        catch( const char* msg ) {
-            return msg;
-        }
-        catch(...) {
-            return "Unknown exception";
-        }
-    }
-
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        if (m_translators.empty()) {
-            std::rethrow_exception(std::current_exception());
-        } else {
-            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
-        }
-    }
-
-#else // ^^ Exceptions are enabled // Exceptions are disabled vv
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
-
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
-#endif
-
-}
-// end catch_exception_translator_registry.cpp
-// start catch_fatal_condition.cpp
-
-#if defined(__GNUC__)
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#endif
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-namespace {
-    // Report the error condition
-    void reportFatal( char const * const message ) {
-        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
-    }
-}
-
-#endif // signals/SEH handling
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-    struct SignalDefs { DWORD id; const char* name; };
-
-    // There is no 1-1 mapping between signals and windows exceptions.
-    // Windows can easily distinguish between SO and SigSegV,
-    // but SigInt, SigTerm, etc are handled differently.
-    static SignalDefs signalDefs[] = {
-        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
-        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
-        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
-        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
-    };
-
-    LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
-        for (auto const& def : signalDefs) {
-            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
-                reportFatal(def.name);
-            }
-        }
-        // If its not an exception we care about, pass it along.
-        // This stops us from eating debugger breaks etc.
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        // 32k seems enough for Catch to handle stack overflow,
-        // but the value was found experimentally, so there is no strong guarantee
-        guaranteeSize = 32 * 1024;
-        exceptionHandlerHandle = nullptr;
-        // Register as first handler in current chain
-        exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
-        // Pass in guarantee size to be filled
-        SetThreadStackGuarantee(&guaranteeSize);
-    }
-
-    void FatalConditionHandler::reset() {
-        if (isSet) {
-            RemoveVectoredExceptionHandler(exceptionHandlerHandle);
-            SetThreadStackGuarantee(&guaranteeSize);
-            exceptionHandlerHandle = nullptr;
-            isSet = false;
-        }
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
-
-bool FatalConditionHandler::isSet = false;
-ULONG FatalConditionHandler::guaranteeSize = 0;
-PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
-
-} // namespace Catch
-
-#elif defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-namespace Catch {
-
-    struct SignalDefs {
-        int id;
-        const char* name;
-    };
-
-    // 32kb for the alternate stack seems to be sufficient. However, this value
-    // is experimentally determined, so that's not guaranteed.
-    static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
-
-    static SignalDefs signalDefs[] = {
-        { SIGINT,  "SIGINT - Terminal interrupt signal" },
-        { SIGILL,  "SIGILL - Illegal instruction signal" },
-        { SIGFPE,  "SIGFPE - Floating point error signal" },
-        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
-        { SIGTERM, "SIGTERM - Termination request signal" },
-        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
-    };
-
-    void FatalConditionHandler::handleSignal( int sig ) {
-        char const * name = "<unknown signal>";
-        for (auto const& def : signalDefs) {
-            if (sig == def.id) {
-                name = def.name;
-                break;
-            }
-        }
-        reset();
-        reportFatal(name);
-        raise( sig );
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        stack_t sigStack;
-        sigStack.ss_sp = altStackMem;
-        sigStack.ss_size = sigStackSize;
-        sigStack.ss_flags = 0;
-        sigaltstack(&sigStack, &oldSigStack);
-        struct sigaction sa = { };
-
-        sa.sa_handler = handleSignal;
-        sa.sa_flags = SA_ONSTACK;
-        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
-            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
-        }
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
-
-    void FatalConditionHandler::reset() {
-        if( isSet ) {
-            // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
-            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
-                sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
-            }
-            // Return the old stack
-            sigaltstack(&oldSigStack, nullptr);
-            isSet = false;
-        }
-    }
-
-    bool FatalConditionHandler::isSet = false;
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
-    stack_t FatalConditionHandler::oldSigStack = {};
-    char FatalConditionHandler::altStackMem[sigStackSize] = {};
-
-} // namespace Catch
-
-#else
-
-namespace Catch {
-    void FatalConditionHandler::reset() {}
-}
-
-#endif // signals/SEH handling
-
-#if defined(__GNUC__)
-#    pragma GCC diagnostic pop
-#endif
-// end catch_fatal_condition.cpp
-// start catch_generators.cpp
-
-#include <limits>
-#include <set>
-
-namespace Catch {
-
-IGeneratorTracker::~IGeneratorTracker() {}
-
-const char* GeneratorException::what() const noexcept {
-    return m_msg;
-}
-
-namespace Generators {
-
-    GeneratorUntypedBase::~GeneratorUntypedBase() {}
-
-    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        return getResultCapture().acquireGeneratorTracker( lineInfo );
-    }
-
-} // namespace Generators
-} // namespace Catch
-// end catch_generators.cpp
-// start catch_interfaces_capture.cpp
-
-namespace Catch {
-    IResultCapture::~IResultCapture() = default;
-}
-// end catch_interfaces_capture.cpp
-// start catch_interfaces_config.cpp
-
-namespace Catch {
-    IConfig::~IConfig() = default;
-}
-// end catch_interfaces_config.cpp
-// start catch_interfaces_exception.cpp
-
-namespace Catch {
-    IExceptionTranslator::~IExceptionTranslator() = default;
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
-}
-// end catch_interfaces_exception.cpp
-// start catch_interfaces_registry_hub.cpp
-
-namespace Catch {
-    IRegistryHub::~IRegistryHub() = default;
-    IMutableRegistryHub::~IMutableRegistryHub() = default;
-}
-// end catch_interfaces_registry_hub.cpp
-// start catch_interfaces_reporter.cpp
-
-// start catch_reporter_listening.h
-
-namespace Catch {
-
-    class ListeningReporter : public IStreamingReporter {
-        using Reporters = std::vector<IStreamingReporterPtr>;
-        Reporters m_listeners;
-        IStreamingReporterPtr m_reporter = nullptr;
-        ReporterPreferences m_preferences;
-
-    public:
-        ListeningReporter();
-
-        void addListener( IStreamingReporterPtr&& listener );
-        void addReporter( IStreamingReporterPtr&& reporter );
-
-    public: // IStreamingReporter
-
-        ReporterPreferences getPreferences() const override;
-
-        void noMatchingTestCases( std::string const& spec ) override;
-
-        void reportInvalidArguments(std::string const&arg) override;
-
-        static std::set<Verbosity> getSupportedVerbosities();
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
-        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
-        void benchmarkFailed(std::string const&) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void testRunStarting( TestRunInfo const& testRunInfo ) override;
-        void testGroupStarting( GroupInfo const& groupInfo ) override;
-        void testCaseStarting( TestCaseInfo const& testInfo ) override;
-        void sectionStarting( SectionInfo const& sectionInfo ) override;
-        void assertionStarting( AssertionInfo const& assertionInfo ) override;
-
-        // The return value indicates if the messages buffer should be cleared:
-        bool assertionEnded( AssertionStats const& assertionStats ) override;
-        void sectionEnded( SectionStats const& sectionStats ) override;
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
-        void testRunEnded( TestRunStats const& testRunStats ) override;
-
-        void skipTest( TestCaseInfo const& testInfo ) override;
-        bool isMulti() const override;
-
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_listening.h
-namespace Catch {
-
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
-    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
-
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
-    :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
-
-    std::ostream& ReporterConfig::stream() const { return *m_stream; }
-    IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
-
-    TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
-
-    GroupInfo::GroupInfo(  std::string const& _name,
-                           std::size_t _groupIndex,
-                           std::size_t _groupsCount )
-    :   name( _name ),
-        groupIndex( _groupIndex ),
-        groupsCounts( _groupsCount )
-    {}
-
-     AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
-                                     std::vector<MessageInfo> const& _infoMessages,
-                                     Totals const& _totals )
-    :   assertionResult( _assertionResult ),
-        infoMessages( _infoMessages ),
-        totals( _totals )
-    {
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
-
-        if( assertionResult.hasMessage() ) {
-            // Copy message into messages list.
-            // !TBD This should have been done earlier, somewhere
-            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
-            builder << assertionResult.getMessage();
-            builder.m_info.message = builder.m_stream.str();
-
-            infoMessages.push_back( builder.m_info );
-        }
-    }
-
-     AssertionStats::~AssertionStats() = default;
-
-    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
-                                 Counts const& _assertions,
-                                 double _durationInSeconds,
-                                 bool _missingAssertions )
-    :   sectionInfo( _sectionInfo ),
-        assertions( _assertions ),
-        durationInSeconds( _durationInSeconds ),
-        missingAssertions( _missingAssertions )
-    {}
-
-    SectionStats::~SectionStats() = default;
-
-    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
-                                   Totals const& _totals,
-                                   std::string const& _stdOut,
-                                   std::string const& _stdErr,
-                                   bool _aborting )
-    : testInfo( _testInfo ),
-        totals( _totals ),
-        stdOut( _stdOut ),
-        stdErr( _stdErr ),
-        aborting( _aborting )
-    {}
-
-    TestCaseStats::~TestCaseStats() = default;
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
-                                    Totals const& _totals,
-                                    bool _aborting )
-    :   groupInfo( _groupInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
-    :   groupInfo( _groupInfo ),
-        aborting( false )
-    {}
-
-    TestGroupStats::~TestGroupStats() = default;
-
-    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
-                    Totals const& _totals,
-                    bool _aborting )
-    :   runInfo( _runInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestRunStats::~TestRunStats() = default;
-
-    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
-    bool IStreamingReporter::isMulti() const { return false; }
-
-    IReporterFactory::~IReporterFactory() = default;
-    IReporterRegistry::~IReporterRegistry() = default;
-
-} // end namespace Catch
-// end catch_interfaces_reporter.cpp
-// start catch_interfaces_runner.cpp
-
-namespace Catch {
-    IRunner::~IRunner() = default;
-}
-// end catch_interfaces_runner.cpp
-// start catch_interfaces_testcase.cpp
-
-namespace Catch {
-    ITestInvoker::~ITestInvoker() = default;
-    ITestCaseRegistry::~ITestCaseRegistry() = default;
-}
-// end catch_interfaces_testcase.cpp
-// start catch_leak_detector.cpp
-
-#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
-#include <crtdbg.h>
-
-namespace Catch {
-
-    LeakDetector::LeakDetector() {
-        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-        flag |= _CRTDBG_LEAK_CHECK_DF;
-        flag |= _CRTDBG_ALLOC_MEM_DF;
-        _CrtSetDbgFlag(flag);
-        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-        // Change this to leaking allocation's number to break there
-        _CrtSetBreakAlloc(-1);
-    }
-}
-
-#else
-
-    Catch::LeakDetector::LeakDetector() {}
-
-#endif
-
-Catch::LeakDetector::~LeakDetector() {
-    Catch::cleanUp();
-}
-// end catch_leak_detector.cpp
-// start catch_list.cpp
-
-// start catch_list.h
-
-#include <set>
-
-namespace Catch {
-
-    std::size_t listTests( Config const& config );
-
-    std::size_t listTestsNamesOnly( Config const& config );
-
-    struct TagInfo {
-        void add( std::string const& spelling );
-        std::string all() const;
-
-        std::set<std::string> spellings;
-        std::size_t count = 0;
-    };
-
-    std::size_t listTags( Config const& config );
-
-    std::size_t listReporters();
-
-    Option<std::size_t> list( std::shared_ptr<Config> const& config );
-
-} // end namespace Catch
-
-// end catch_list.h
-// start catch_text.h
-
-namespace Catch {
-    using namespace clara::TextFlow;
-}
-
-// end catch_text.h
-#include <limits>
-#include <algorithm>
-#include <iomanip>
-
-namespace Catch {
-
-    std::size_t listTests( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
-        if( config.hasTestFilters() )
-            Catch::cout() << "Matching test cases:\n";
-        else {
-            Catch::cout() << "All available test cases:\n";
-        }
-
-        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            Colour::Code colour = testCaseInfo.isHidden()
-                ? Colour::SecondaryText
-                : Colour::None;
-            Colour colourGuard( colour );
-
-            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
-            if( config.verbosity() >= Verbosity::High ) {
-                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
-                std::string description = testCaseInfo.description;
-                if( description.empty() )
-                    description = "(NO DESCRIPTION)";
-                Catch::cout() << Column( description ).indent(4) << std::endl;
-            }
-            if( !testCaseInfo.tags.empty() )
-                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
-        }
-
-        if( !config.hasTestFilters() )
-            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
-        else
-            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
-        return matchedTestCases.size();
-    }
-
-    std::size_t listTestsNamesOnly( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
-        std::size_t matchedTests = 0;
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            matchedTests++;
-            if( startsWith( testCaseInfo.name, '#' ) )
-               Catch::cout() << '"' << testCaseInfo.name << '"';
-            else
-               Catch::cout() << testCaseInfo.name;
-            if ( config.verbosity() >= Verbosity::High )
-                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
-            Catch::cout() << std::endl;
-        }
-        return matchedTests;
-    }
-
-    void TagInfo::add( std::string const& spelling ) {
-        ++count;
-        spellings.insert( spelling );
-    }
-
-    std::string TagInfo::all() const {
-        size_t size = 0;
-        for (auto const& spelling : spellings) {
-            // Add 2 for the brackes
-            size += spelling.size() + 2;
-        }
-
-        std::string out; out.reserve(size);
-        for (auto const& spelling : spellings) {
-            out += '[';
-            out += spelling;
-            out += ']';
-        }
-        return out;
-    }
-
-    std::size_t listTags( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
-        if( config.hasTestFilters() )
-            Catch::cout() << "Tags for matching test cases:\n";
-        else {
-            Catch::cout() << "All available tags:\n";
-        }
-
-        std::map<std::string, TagInfo> tagCounts;
-
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCase : matchedTestCases ) {
-            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
-                std::string lcaseTagName = toLower( tagName );
-                auto countIt = tagCounts.find( lcaseTagName );
-                if( countIt == tagCounts.end() )
-                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
-                countIt->second.add( tagName );
-            }
-        }
-
-        for( auto const& tagCount : tagCounts ) {
-            ReusableStringStream rss;
-            rss << "  " << std::setw(2) << tagCount.second.count << "  ";
-            auto str = rss.str();
-            auto wrapper = Column( tagCount.second.all() )
-                                                    .initialIndent( 0 )
-                                                    .indent( str.size() )
-                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
-            Catch::cout() << str << wrapper << '\n';
-        }
-        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
-        return tagCounts.size();
-    }
-
-    std::size_t listReporters() {
-        Catch::cout() << "Available reporters:\n";
-        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-        std::size_t maxNameLen = 0;
-        for( auto const& factoryKvp : factories )
-            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
-
-        for( auto const& factoryKvp : factories ) {
-            Catch::cout()
-                    << Column( factoryKvp.first + ":" )
-                            .indent(2)
-                            .width( 5+maxNameLen )
-                    +  Column( factoryKvp.second->getDescription() )
-                            .initialIndent(0)
-                            .indent(2)
-                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
-                    << "\n";
-        }
-        Catch::cout() << std::endl;
-        return factories.size();
-    }
-
-    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
-        Option<std::size_t> listedCount;
-        getCurrentMutableContext().setConfig( config );
-        if( config->listTests() )
-            listedCount = listedCount.valueOr(0) + listTests( *config );
-        if( config->listTestNamesOnly() )
-            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
-        if( config->listTags() )
-            listedCount = listedCount.valueOr(0) + listTags( *config );
-        if( config->listReporters() )
-            listedCount = listedCount.valueOr(0) + listReporters();
-        return listedCount;
-    }
-
-} // end namespace Catch
-// end catch_list.cpp
-// start catch_matchers.cpp
-
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-        std::string MatcherUntypedBase::toString() const {
-            if( m_cachedToString.empty() )
-                m_cachedToString = describe();
-            return m_cachedToString;
-        }
-
-        MatcherUntypedBase::~MatcherUntypedBase() = default;
-
-    } // namespace Impl
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
-
-} // namespace Catch
-// end catch_matchers.cpp
-// start catch_matchers_exception.cpp
-
-namespace Catch {
-namespace Matchers {
-namespace Exception {
-
-bool ExceptionMessageMatcher::match(std::exception const& ex) const {
-    return ex.what() == m_message;
-}
-
-std::string ExceptionMessageMatcher::describe() const {
-    return "exception message matches \"" + m_message + "\"";
-}
-
-}
-Exception::ExceptionMessageMatcher Message(std::string const& message) {
-    return Exception::ExceptionMessageMatcher(message);
-}
-
-// namespace Exception
-} // namespace Matchers
-} // namespace Catch
-// end catch_matchers_exception.cpp
-// start catch_matchers_floating.cpp
-
-// start catch_polyfills.hpp
-
-namespace Catch {
-    bool isnan(float f);
-    bool isnan(double d);
-}
-
-// end catch_polyfills.hpp
-// start catch_to_string.hpp
-
-#include <string>
-
-namespace Catch {
-    template <typename T>
-    std::string to_string(T const& t) {
-#if defined(CATCH_CONFIG_CPP11_TO_STRING)
-        return std::to_string(t);
-#else
-        ReusableStringStream rss;
-        rss << t;
-        return rss.str();
-#endif
-    }
-} // end namespace Catch
-
-// end catch_to_string.hpp
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
-#include <cstdint>
-#include <cstring>
-#include <sstream>
-#include <type_traits>
-#include <iomanip>
-#include <limits>
-
-namespace Catch {
-namespace {
-
-    int32_t convert(float f) {
-        static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
-        int32_t i;
-        std::memcpy(&i, &f, sizeof(f));
-        return i;
-    }
-
-    int64_t convert(double d) {
-        static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
-        int64_t i;
-        std::memcpy(&i, &d, sizeof(d));
-        return i;
-    }
-
-    template <typename FP>
-    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
-        // Comparison with NaN should always be false.
-        // This way we can rule it out before getting into the ugly details
-        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
-            return false;
-        }
-
-        auto lc = convert(lhs);
-        auto rc = convert(rhs);
-
-        if ((lc < 0) != (rc < 0)) {
-            // Potentially we can have +0 and -0
-            return lhs == rhs;
-        }
-
-        auto ulpDiff = std::abs(lc - rc);
-        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
-    }
-
-#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-
-    float nextafter(float x, float y) {
-        return ::nextafterf(x, y);
-    }
-
-    double nextafter(double x, double y) {
-        return ::nextafter(x, y);
-    }
-
-#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
-
-template <typename FP>
-FP step(FP start, FP direction, uint64_t steps) {
-    for (uint64_t i = 0; i < steps; ++i) {
-#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-        start = Catch::nextafter(start, direction);
-#else
-        start = std::nextafter(start, direction);
-#endif
-    }
-    return start;
-}
-
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
-
-template <typename FloatingPoint>
-void write(std::ostream& out, FloatingPoint num) {
-    out << std::scientific
-        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
-        << num;
-}
-
-} // end anonymous namespace
-
-namespace Matchers {
-namespace Floating {
-
-    enum class FloatingPointKind : uint8_t {
-        Float,
-        Double
-    };
-
-    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
-        :m_target{ target }, m_margin{ margin } {
-        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
-            << " Margin has to be non-negative.");
-    }
-
-    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
-    // But without the subtraction to allow for INFINITY in comparison
-    bool WithinAbsMatcher::match(double const& matchee) const {
-        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
-    }
-
-    std::string WithinAbsMatcher::describe() const {
-        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
-    }
-
-    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
-        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
-        CATCH_ENFORCE(m_type == FloatingPointKind::Double
-                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
-            "Provided ULP is impossibly large for a float comparison.");
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-// Clang <3.5 reports on the default branch in the switch below
-#pragma clang diagnostic ignored "-Wunreachable-code"
-#endif
-
-    bool WithinUlpsMatcher::match(double const& matchee) const {
-        switch (m_type) {
-        case FloatingPointKind::Float:
-            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
-        case FloatingPointKind::Double:
-            return almostEqualUlps<double>(matchee, m_target, m_ulps);
-        default:
-            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
-        }
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-    std::string WithinUlpsMatcher::describe() const {
-        std::stringstream ret;
-
-        ret << "is within " << m_ulps << " ULPs of ";
-
-        if (m_type == FloatingPointKind::Float) {
-            write(ret, static_cast<float>(m_target));
-            ret << 'f';
-        } else {
-            write(ret, m_target);
-        }
-
-        ret << " ([";
-        if (m_type == FloatingPointKind::Double) {
-            write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
-            ret << ", ";
-            write(ret, step(m_target, static_cast<double>( INFINITY), m_ulps));
-        } else {
-            // We have to cast INFINITY to float because of MinGW, see #1782
-            write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
-            ret << ", ";
-            write(ret, step(static_cast<float>(m_target), static_cast<float>( INFINITY), m_ulps));
-        }
-        ret << "])";
-
-        return ret.str();
-    }
-
-    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
-        m_target(target),
-        m_epsilon(epsilon){
-        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
-        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
-    }
-
-    bool WithinRelMatcher::match(double const& matchee) const {
-        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
-        return marginComparison(matchee, m_target,
-                                std::isinf(relMargin)? 0 : relMargin);
-    }
-
-    std::string WithinRelMatcher::describe() const {
-        Catch::ReusableStringStream sstr;
-        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
-        return sstr.str();
-    }
-
-}// namespace Floating
-
-Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
-    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
-}
-
-Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
-    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
-}
-
-Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
-    return Floating::WithinAbsMatcher(target, margin);
-}
-
-Floating::WithinRelMatcher WithinRel(double target, double eps) {
-    return Floating::WithinRelMatcher(target, eps);
-}
-
-Floating::WithinRelMatcher WithinRel(double target) {
-    return Floating::WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
-}
-
-Floating::WithinRelMatcher WithinRel(float target, float eps) {
-    return Floating::WithinRelMatcher(target, eps);
-}
-
-Floating::WithinRelMatcher WithinRel(float target) {
-    return Floating::WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
-}
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_floating.cpp
-// start catch_matchers_generic.cpp
-
-std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
-    if (desc.empty()) {
-        return "matches undescribed predicate";
-    } else {
-        return "matches predicate: \"" + desc + '"';
-    }
-}
-// end catch_matchers_generic.cpp
-// start catch_matchers_string.cpp
-
-#include <regex>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace StdString {
-
-        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
-        :   m_caseSensitivity( caseSensitivity ),
-            m_str( adjustString( str ) )
-        {}
-        std::string CasedString::adjustString( std::string const& str ) const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? toLower( str )
-                   : str;
-        }
-        std::string CasedString::caseSensitivitySuffix() const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? " (case insensitive)"
-                   : std::string();
-        }
-
-        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
-        : m_comparator( comparator ),
-          m_operation( operation ) {
-        }
-
-        std::string StringMatcherBase::describe() const {
-            std::string description;
-            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
-                                        m_comparator.caseSensitivitySuffix().size());
-            description += m_operation;
-            description += ": \"";
-            description += m_comparator.m_str;
-            description += "\"";
-            description += m_comparator.caseSensitivitySuffix();
-            return description;
-        }
-
-        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
-
-        bool EqualsMatcher::match( std::string const& source ) const {
-            return m_comparator.adjustString( source ) == m_comparator.m_str;
-        }
-
-        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
-
-        bool ContainsMatcher::match( std::string const& source ) const {
-            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
-
-        bool StartsWithMatcher::match( std::string const& source ) const {
-            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
-
-        bool EndsWithMatcher::match( std::string const& source ) const {
-            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
-
-        bool RegexMatcher::match(std::string const& matchee) const {
-            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
-            if (m_caseSensitivity == CaseSensitive::Choice::No) {
-                flags |= std::regex::icase;
-            }
-            auto reg = std::regex(m_regex, flags);
-            return std::regex_match(matchee, reg);
-        }
-
-        std::string RegexMatcher::describe() const {
-            return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
-        }
-
-    } // namespace StdString
-
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-
-    StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
-        return StdString::RegexMatcher(regex, caseSensitivity);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-// end catch_matchers_string.cpp
-// start catch_message.cpp
-
-// start catch_uncaught_exceptions.h
-
-namespace Catch {
-    bool uncaught_exceptions();
-} // end namespace Catch
-
-// end catch_uncaught_exceptions.h
-#include <cassert>
-#include <stack>
-
-namespace Catch {
-
-    MessageInfo::MessageInfo(   StringRef const& _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        type( _type ),
-        sequence( ++globalCount )
-    {}
-
-    bool MessageInfo::operator==( MessageInfo const& other ) const {
-        return sequence == other.sequence;
-    }
-
-    bool MessageInfo::operator<( MessageInfo const& other ) const {
-        return sequence < other.sequence;
-    }
-
-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
-                                           SourceLineInfo const& lineInfo,
-                                           ResultWas::OfType type )
-        :m_info(macroName, lineInfo, type) {}
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
-    : m_info( builder.m_info ), m_moved()
-    {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
-    }
-
-    ScopedMessage::ScopedMessage( ScopedMessage&& old )
-    : m_info( old.m_info ), m_moved()
-    {
-        old.m_moved = true;
-    }
-
-    ScopedMessage::~ScopedMessage() {
-        if ( !uncaught_exceptions() && !m_moved ){
-            getResultCapture().popScopedMessage(m_info);
-        }
-    }
-
-    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
-        auto trimmed = [&] (size_t start, size_t end) {
-            while (names[start] == ',' || isspace(names[start])) {
-                ++start;
-            }
-            while (names[end] == ',' || isspace(names[end])) {
-                --end;
-            }
-            return names.substr(start, end - start + 1);
-        };
-        auto skipq = [&] (size_t start, char quote) {
-            for (auto i = start + 1; i < names.size() ; ++i) {
-                if (names[i] == quote)
-                    return i;
-                if (names[i] == '\\')
-                    ++i;
-            }
-            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
-        };
-
-        size_t start = 0;
-        std::stack<char> openings;
-        for (size_t pos = 0; pos < names.size(); ++pos) {
-            char c = names[pos];
-            switch (c) {
-            case '[':
-            case '{':
-            case '(':
-            // It is basically impossible to disambiguate between
-            // comparison and start of template args in this context
-//            case '<':
-                openings.push(c);
-                break;
-            case ']':
-            case '}':
-            case ')':
-//           case '>':
-                openings.pop();
-                break;
-            case '"':
-            case '\'':
-                pos = skipq(pos, c);
-                break;
-            case ',':
-                if (start != pos && openings.empty()) {
-                    m_messages.emplace_back(macroName, lineInfo, resultType);
-                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
-                    m_messages.back().message += " := ";
-                    start = pos;
-                }
-            }
-        }
-        assert(openings.empty() && "Mismatched openings");
-        m_messages.emplace_back(macroName, lineInfo, resultType);
-        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
-        m_messages.back().message += " := ";
-    }
-    Capturer::~Capturer() {
-        if ( !uncaught_exceptions() ){
-            assert( m_captured == m_messages.size() );
-            for( size_t i = 0; i < m_captured; ++i  )
-                m_resultCapture.popScopedMessage( m_messages[i] );
-        }
-    }
-
-    void Capturer::captureValue( size_t index, std::string const& value ) {
-        assert( index < m_messages.size() );
-        m_messages[index].message += value;
-        m_resultCapture.pushScopedMessage( m_messages[index] );
-        m_captured++;
-    }
-
-} // end namespace Catch
-// end catch_message.cpp
-// start catch_output_redirect.cpp
-
-// start catch_output_redirect.h
-#ifndef TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-#define TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-
-#include <cstdio>
-#include <iosfwd>
-#include <string>
-
-namespace Catch {
-
-    class RedirectedStream {
-        std::ostream& m_originalStream;
-        std::ostream& m_redirectionStream;
-        std::streambuf* m_prevBuf;
-
-    public:
-        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
-        ~RedirectedStream();
-    };
-
-    class RedirectedStdOut {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cout;
-    public:
-        RedirectedStdOut();
-        auto str() const -> std::string;
-    };
-
-    // StdErr has two constituent streams in C++, std::cerr and std::clog
-    // This means that we need to redirect 2 streams into 1 to keep proper
-    // order of writes
-    class RedirectedStdErr {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cerr;
-        RedirectedStream m_clog;
-    public:
-        RedirectedStdErr();
-        auto str() const -> std::string;
-    };
-
-    class RedirectedStreams {
-    public:
-        RedirectedStreams(RedirectedStreams const&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
-        RedirectedStreams(RedirectedStreams&&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
-
-        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
-        ~RedirectedStreams();
-    private:
-        std::string& m_redirectedCout;
-        std::string& m_redirectedCerr;
-        RedirectedStdOut m_redirectedStdOut;
-        RedirectedStdErr m_redirectedStdErr;
-    };
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-    // Windows's implementation of std::tmpfile is terrible (it tries
-    // to create a file inside system folder, thus requiring elevated
-    // privileges for the binary), so we have to use tmpnam(_s) and
-    // create the file ourselves there.
-    class TempFile {
-    public:
-        TempFile(TempFile const&) = delete;
-        TempFile& operator=(TempFile const&) = delete;
-        TempFile(TempFile&&) = delete;
-        TempFile& operator=(TempFile&&) = delete;
-
-        TempFile();
-        ~TempFile();
-
-        std::FILE* getFile();
-        std::string getContents();
-
-    private:
-        std::FILE* m_file = nullptr;
-    #if defined(_MSC_VER)
-        char m_buffer[L_tmpnam] = { 0 };
-    #endif
-    };
-
-    class OutputRedirect {
-    public:
-        OutputRedirect(OutputRedirect const&) = delete;
-        OutputRedirect& operator=(OutputRedirect const&) = delete;
-        OutputRedirect(OutputRedirect&&) = delete;
-        OutputRedirect& operator=(OutputRedirect&&) = delete;
-
-        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
-        ~OutputRedirect();
-
-    private:
-        int m_originalStdout = -1;
-        int m_originalStderr = -1;
-        TempFile m_stdoutFile;
-        TempFile m_stderrFile;
-        std::string& m_stdoutDest;
-        std::string& m_stderrDest;
-    };
-
-#endif
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-// end catch_output_redirect.h
-#include <cstdio>
-#include <cstring>
-#include <fstream>
-#include <sstream>
-#include <stdexcept>
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #include <io.h>      //_dup and _dup2
-    #define dup _dup
-    #define dup2 _dup2
-    #define fileno _fileno
-    #else
-    #include <unistd.h>  // dup and dup2
-    #endif
-#endif
-
-namespace Catch {
-
-    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
-    :   m_originalStream( originalStream ),
-        m_redirectionStream( redirectionStream ),
-        m_prevBuf( m_originalStream.rdbuf() )
-    {
-        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
-    }
-
-    RedirectedStream::~RedirectedStream() {
-        m_originalStream.rdbuf( m_prevBuf );
-    }
-
-    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
-    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStdErr::RedirectedStdErr()
-    :   m_cerr( Catch::cerr(), m_rss.get() ),
-        m_clog( Catch::clog(), m_rss.get() )
-    {}
-    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
-    :   m_redirectedCout(redirectedCout),
-        m_redirectedCerr(redirectedCerr)
-    {}
-
-    RedirectedStreams::~RedirectedStreams() {
-        m_redirectedCout += m_redirectedStdOut.str();
-        m_redirectedCerr += m_redirectedStdErr.str();
-    }
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-#if defined(_MSC_VER)
-    TempFile::TempFile() {
-        if (tmpnam_s(m_buffer)) {
-            CATCH_RUNTIME_ERROR("Could not get a temp filename");
-        }
-        if (fopen_s(&m_file, m_buffer, "w")) {
-            char buffer[100];
-            if (strerror_s(buffer, errno)) {
-                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
-            }
-            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
-        }
-    }
-#else
-    TempFile::TempFile() {
-        m_file = std::tmpfile();
-        if (!m_file) {
-            CATCH_RUNTIME_ERROR("Could not create a temp file.");
-        }
-    }
-
-#endif
-
-    TempFile::~TempFile() {
-         // TBD: What to do about errors here?
-         std::fclose(m_file);
-         // We manually create the file on Windows only, on Linux
-         // it will be autodeleted
-#if defined(_MSC_VER)
-         std::remove(m_buffer);
-#endif
-    }
-
-    FILE* TempFile::getFile() {
-        return m_file;
-    }
-
-    std::string TempFile::getContents() {
-        std::stringstream sstr;
-        char buffer[100] = {};
-        std::rewind(m_file);
-        while (std::fgets(buffer, sizeof(buffer), m_file)) {
-            sstr << buffer;
-        }
-        return sstr.str();
-    }
-
-    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
-        m_originalStdout(dup(1)),
-        m_originalStderr(dup(2)),
-        m_stdoutDest(stdout_dest),
-        m_stderrDest(stderr_dest) {
-        dup2(fileno(m_stdoutFile.getFile()), 1);
-        dup2(fileno(m_stderrFile.getFile()), 2);
-    }
-
-    OutputRedirect::~OutputRedirect() {
-        Catch::cout() << std::flush;
-        fflush(stdout);
-        // Since we support overriding these streams, we flush cerr
-        // even though std::cerr is unbuffered
-        Catch::cerr() << std::flush;
-        Catch::clog() << std::flush;
-        fflush(stderr);
-
-        dup2(m_originalStdout, 1);
-        dup2(m_originalStderr, 2);
-
-        m_stdoutDest += m_stdoutFile.getContents();
-        m_stderrDest += m_stderrFile.getContents();
-    }
-
-#endif // CATCH_CONFIG_NEW_CAPTURE
-
-} // namespace Catch
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #undef dup
-    #undef dup2
-    #undef fileno
-    #endif
-#endif
-// end catch_output_redirect.cpp
-// start catch_polyfills.cpp
-
-#include <cmath>
-
-namespace Catch {
-
-#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-    bool isnan(float f) {
-        return std::isnan(f);
-    }
-    bool isnan(double d) {
-        return std::isnan(d);
-    }
-#else
-    // For now we only use this for embarcadero
-    bool isnan(float f) {
-        return std::_isnan(f);
-    }
-    bool isnan(double d) {
-        return std::_isnan(d);
-    }
-#endif
-
-} // end namespace Catch
-// end catch_polyfills.cpp
-// start catch_random_number_generator.cpp
-
-namespace Catch {
-
-namespace {
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4146) // we negate uint32 during the rotate
-#endif
-        // Safe rotr implementation thanks to John Regehr
-        uint32_t rotate_right(uint32_t val, uint32_t count) {
-            const uint32_t mask = 31;
-            count &= mask;
-            return (val >> count) | (val << (-count & mask));
-        }
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-}
-
-    SimplePcg32::SimplePcg32(result_type seed_) {
-        seed(seed_);
-    }
-
-    void SimplePcg32::seed(result_type seed_) {
-        m_state = 0;
-        (*this)();
-        m_state += seed_;
-        (*this)();
-    }
-
-    void SimplePcg32::discard(uint64_t skip) {
-        // We could implement this to run in O(log n) steps, but this
-        // should suffice for our use case.
-        for (uint64_t s = 0; s < skip; ++s) {
-            static_cast<void>((*this)());
-        }
-    }
-
-    SimplePcg32::result_type SimplePcg32::operator()() {
-        // prepare the output value
-        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
-        const auto output = rotate_right(xorshifted, m_state >> 59u);
-
-        // advance state
-        m_state = m_state * 6364136223846793005ULL + s_inc;
-
-        return output;
-    }
-
-    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
-        return lhs.m_state == rhs.m_state;
-    }
-
-    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
-        return lhs.m_state != rhs.m_state;
-    }
-}
-// end catch_random_number_generator.cpp
-// start catch_registry_hub.cpp
-
-// start catch_test_case_registry_impl.h
-
-#include <vector>
-#include <set>
-#include <algorithm>
-#include <ios>
-
-namespace Catch {
-
-    class TestCase;
-    struct IConfig;
-
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
-
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
-
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
-
-    class TestRegistry : public ITestCaseRegistry {
-    public:
-        virtual ~TestRegistry() = default;
-
-        virtual void registerTest( TestCase const& testCase );
-
-        std::vector<TestCase> const& getAllTests() const override;
-        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
-
-    private:
-        std::vector<TestCase> m_functions;
-        mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
-        mutable std::vector<TestCase> m_sortedFunctions;
-        std::size_t m_unnamedCount = 0;
-        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class TestInvokerAsFunction : public ITestInvoker {
-        void(*m_testAsFunction)();
-    public:
-        TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
-
-        void invoke() const override;
-    };
-
-    std::string extractClassName( StringRef const& classOrQualifiedMethodName );
-
-    ///////////////////////////////////////////////////////////////////////////
-
-} // end namespace Catch
-
-// end catch_test_case_registry_impl.h
-// start catch_reporter_registry.h
-
-#include <map>
-
-namespace Catch {
-
-    class ReporterRegistry : public IReporterRegistry {
-
-    public:
-
-        ~ReporterRegistry() override;
-
-        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
-
-        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
-        void registerListener( IReporterFactoryPtr const& factory );
-
-        FactoryMap const& getFactories() const override;
-        Listeners const& getListeners() const override;
-
-    private:
-        FactoryMap m_factories;
-        Listeners m_listeners;
-    };
-}
-
-// end catch_reporter_registry.h
-// start catch_tag_alias_registry.h
-
-// start catch_tag_alias.h
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias {
-        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
-
-        std::string tag;
-        SourceLineInfo lineInfo;
-    };
-
-} // end namespace Catch
-
-// end catch_tag_alias.h
-#include <map>
-
-namespace Catch {
-
-    class TagAliasRegistry : public ITagAliasRegistry {
-    public:
-        ~TagAliasRegistry() override;
-        TagAlias const* find( std::string const& alias ) const override;
-        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
-        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
-
-    private:
-        std::map<std::string, TagAlias> m_registry;
-    };
-
-} // end namespace Catch
-
-// end catch_tag_alias_registry.h
-// start catch_startup_exception_registry.h
-
-#include <vector>
-#include <exception>
-
-namespace Catch {
-
-    class StartupExceptionRegistry {
-    public:
-        void add(std::exception_ptr const& exception) noexcept;
-        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
-    private:
-        std::vector<std::exception_ptr> m_exceptions;
-    };
-
-} // end namespace Catch
-
-// end catch_startup_exception_registry.h
-// start catch_singletons.hpp
-
-namespace Catch {
-
-    struct ISingleton {
-        virtual ~ISingleton();
-    };
-
-    void addSingleton( ISingleton* singleton );
-    void cleanupSingletons();
-
-    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
-    class Singleton : SingletonImplT, public ISingleton {
-
-        static auto getInternal() -> Singleton* {
-            static Singleton* s_instance = nullptr;
-            if( !s_instance ) {
-                s_instance = new Singleton;
-                addSingleton( s_instance );
-            }
-            return s_instance;
-        }
-
-    public:
-        static auto get() -> InterfaceT const& {
-            return *getInternal();
-        }
-        static auto getMutable() -> MutableInterfaceT& {
-            return *getInternal();
-        }
-    };
-
-} // namespace Catch
-
-// end catch_singletons.hpp
-namespace Catch {
-
-    namespace {
-
-        class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
-                            private NonCopyable {
-
-        public: // IRegistryHub
-            RegistryHub() = default;
-            IReporterRegistry const& getReporterRegistry() const override {
-                return m_reporterRegistry;
-            }
-            ITestCaseRegistry const& getTestCaseRegistry() const override {
-                return m_testCaseRegistry;
-            }
-            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
-                return m_exceptionTranslatorRegistry;
-            }
-            ITagAliasRegistry const& getTagAliasRegistry() const override {
-                return m_tagAliasRegistry;
-            }
-            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
-                return m_exceptionRegistry;
-            }
-
-        public: // IMutableRegistryHub
-            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerReporter( name, factory );
-            }
-            void registerListener( IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerListener( factory );
-            }
-            void registerTest( TestCase const& testInfo ) override {
-                m_testCaseRegistry.registerTest( testInfo );
-            }
-            void registerTranslator( const IExceptionTranslator* translator ) override {
-                m_exceptionTranslatorRegistry.registerTranslator( translator );
-            }
-            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
-                m_tagAliasRegistry.add( alias, tag, lineInfo );
-            }
-            void registerStartupException() noexcept override {
-                m_exceptionRegistry.add(std::current_exception());
-            }
-            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
-                return m_enumValuesRegistry;
-            }
-
-        private:
-            TestRegistry m_testCaseRegistry;
-            ReporterRegistry m_reporterRegistry;
-            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
-            TagAliasRegistry m_tagAliasRegistry;
-            StartupExceptionRegistry m_exceptionRegistry;
-            Detail::EnumValuesRegistry m_enumValuesRegistry;
-        };
-    }
-
-    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
-
-    IRegistryHub const& getRegistryHub() {
-        return RegistryHubSingleton::get();
-    }
-    IMutableRegistryHub& getMutableRegistryHub() {
-        return RegistryHubSingleton::getMutable();
-    }
-    void cleanUp() {
-        cleanupSingletons();
-        cleanUpContext();
-    }
-    std::string translateActiveException() {
-        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
-    }
-
-} // end namespace Catch
-// end catch_registry_hub.cpp
-// start catch_reporter_registry.cpp
-
-namespace Catch {
-
-    ReporterRegistry::~ReporterRegistry() = default;
-
-    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
-        auto it =  m_factories.find( name );
-        if( it == m_factories.end() )
-            return nullptr;
-        return it->second->create( ReporterConfig( config ) );
-    }
-
-    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
-        m_factories.emplace(name, factory);
-    }
-    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
-        m_listeners.push_back( factory );
-    }
-
-    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
-        return m_factories;
-    }
-    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
-        return m_listeners;
-    }
-
-}
-// end catch_reporter_registry.cpp
-// start catch_result_type.cpp
-
-namespace Catch {
-
-    bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    bool isJustInfo( int flags ) {
-        return flags == ResultWas::Info;
-    }
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
-    }
-
-    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
-    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
-
-} // end namespace Catch
-// end catch_result_type.cpp
-// start catch_run_context.cpp
-
-#include <cassert>
-#include <algorithm>
-#include <sstream>
-
-namespace Catch {
-
-    namespace Generators {
-        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
-            GeneratorBasePtr m_generator;
-
-            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-            :   TrackerBase( nameAndLocation, ctx, parent )
-            {}
-            ~GeneratorTracker();
-
-            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
-                std::shared_ptr<GeneratorTracker> tracker;
-
-                ITracker& currentTracker = ctx.currentTracker();
-                if( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-                    assert( childTracker );
-                    assert( childTracker->isGeneratorTracker() );
-                    tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
-                }
-                else {
-                    tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
-                    currentTracker.addChild( tracker );
-                }
-
-                if( !ctx.completedCycle() && !tracker->isComplete() ) {
-                    tracker->open();
-                }
-
-                return *tracker;
-            }
-
-            // TrackerBase interface
-            bool isGeneratorTracker() const override { return true; }
-            auto hasGenerator() const -> bool override {
-                return !!m_generator;
-            }
-            void close() override {
-                TrackerBase::close();
-                // Generator interface only finds out if it has another item on atual move
-                if (m_runState == CompletedSuccessfully && m_generator->next()) {
-                    m_children.clear();
-                    m_runState = Executing;
-                }
-            }
-
-            // IGeneratorTracker interface
-            auto getGenerator() const -> GeneratorBasePtr const& override {
-                return m_generator;
-            }
-            void setGenerator( GeneratorBasePtr&& generator ) override {
-                m_generator = std::move( generator );
-            }
-        };
-        GeneratorTracker::~GeneratorTracker() {}
-    }
-
-    RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
-    :   m_runInfo(_config->name()),
-        m_context(getCurrentMutableContext()),
-        m_config(_config),
-        m_reporter(std::move(reporter)),
-        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
-        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
-    {
-        m_context.setRunner(this);
-        m_context.setConfig(m_config);
-        m_context.setResultCapture(this);
-        m_reporter->testRunStarting(m_runInfo);
-    }
-
-    RunContext::~RunContext() {
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
-    }
-
-    void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
-    }
-
-    void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
-    }
-
-    Totals RunContext::runTest(TestCase const& testCase) {
-        Totals prevTotals = m_totals;
-
-        std::string redirectedCout;
-        std::string redirectedCerr;
-
-        auto const& testInfo = testCase.getTestCaseInfo();
-
-        m_reporter->testCaseStarting(testInfo);
-
-        m_activeTestCase = &testCase;
-
-        ITracker& rootTracker = m_trackerContext.startRun();
-        assert(rootTracker.isSectionTracker());
-        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
-        do {
-            m_trackerContext.startCycle();
-            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
-            runCurrentTest(redirectedCout, redirectedCerr);
-        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
-
-        Totals deltaTotals = m_totals.delta(prevTotals);
-        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
-            deltaTotals.assertions.failed++;
-            deltaTotals.testCases.passed--;
-            deltaTotals.testCases.failed++;
-        }
-        m_totals.testCases += deltaTotals.testCases;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  redirectedCout,
-                                  redirectedCerr,
-                                  aborting()));
-
-        m_activeTestCase = nullptr;
-        m_testCaseTracker = nullptr;
-
-        return deltaTotals;
-    }
-
-    IConfigPtr RunContext::config() const {
-        return m_config;
-    }
-
-    IStreamingReporter& RunContext::reporter() const {
-        return *m_reporter;
-    }
-
-    void RunContext::assertionEnded(AssertionResult const & result) {
-        if (result.getResultType() == ResultWas::Ok) {
-            m_totals.assertions.passed++;
-            m_lastAssertionPassed = true;
-        } else if (!result.isOk()) {
-            m_lastAssertionPassed = false;
-            if( m_activeTestCase->getTestCaseInfo().okToFail() )
-                m_totals.assertions.failedButOk++;
-            else
-                m_totals.assertions.failed++;
-        }
-        else {
-            m_lastAssertionPassed = true;
-        }
-
-        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
-        // and should be let to clear themselves out.
-        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
-
-        if (result.getResultType() != ResultWas::Warning)
-            m_messageScopes.clear();
-
-        // Reset working state
-        resetAssertionInfo();
-        m_lastResult = result;
-    }
-    void RunContext::resetAssertionInfo() {
-        m_lastAssertionInfo.macroName = StringRef();
-        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
-    }
-
-    bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
-        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
-        if (!sectionTracker.isOpen())
-            return false;
-        m_activeSections.push_back(&sectionTracker);
-
-        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
-
-        m_reporter->sectionStarting(sectionInfo);
-
-        assertions = m_totals.assertions;
-
-        return true;
-    }
-    auto RunContext::acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        using namespace Generators;
-        GeneratorTracker& tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( "generator", lineInfo ) );
-        assert( tracker.isOpen() );
-        m_lastAssertionInfo.lineInfo = lineInfo;
-        return tracker;
-    }
-
-    bool RunContext::testForMissingAssertions(Counts& assertions) {
-        if (assertions.total() != 0)
-            return false;
-        if (!m_config->warnAboutMissingAssertions())
-            return false;
-        if (m_trackerContext.currentTracker().hasChildren())
-            return false;
-        m_totals.assertions.failed++;
-        assertions.failed++;
-        return true;
-    }
-
-    void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
-        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        if (!m_activeSections.empty()) {
-            m_activeSections.back()->close();
-            m_activeSections.pop_back();
-        }
-
-        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
-        m_messages.clear();
-        m_messageScopes.clear();
-    }
-
-    void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
-        if (m_unfinishedSections.empty())
-            m_activeSections.back()->fail();
-        else
-            m_activeSections.back()->close();
-        m_activeSections.pop_back();
-
-        m_unfinishedSections.push_back(endInfo);
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void RunContext::benchmarkPreparing(std::string const& name) {
-		m_reporter->benchmarkPreparing(name);
-	}
-    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
-        m_reporter->benchmarkStarting( info );
-    }
-    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
-        m_reporter->benchmarkEnded( stats );
-    }
-	void RunContext::benchmarkFailed(std::string const & error) {
-		m_reporter->benchmarkFailed(error);
-	}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    void RunContext::pushScopedMessage(MessageInfo const & message) {
-        m_messages.push_back(message);
-    }
-
-    void RunContext::popScopedMessage(MessageInfo const & message) {
-        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
-    }
-
-    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
-        m_messageScopes.emplace_back( builder );
-    }
-
-    std::string RunContext::getCurrentTestName() const {
-        return m_activeTestCase
-            ? m_activeTestCase->getTestCaseInfo().name
-            : std::string();
-    }
-
-    const AssertionResult * RunContext::getLastResult() const {
-        return &(*m_lastResult);
-    }
-
-    void RunContext::exceptionEarlyReported() {
-        m_shouldReportUnexpected = false;
-    }
-
-    void RunContext::handleFatalErrorCondition( StringRef message ) {
-        // First notify reporter that bad things happened
-        m_reporter->fatalErrorEncountered(message);
-
-        // Don't rebuild the result -- the stringification itself can cause more fatal errors
-        // Instead, fake a result data.
-        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
-        tempResult.message = static_cast<std::string>(message);
-        AssertionResult result(m_lastAssertionInfo, tempResult);
-
-        assertionEnded(result);
-
-        handleUnfinishedSections();
-
-        // Recreate section for test case (as we will lose the one that was in scope)
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-
-        Counts assertions;
-        assertions.failed = 1;
-        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
-        m_reporter->sectionEnded(testCaseSectionStats);
-
-        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
-
-        Totals deltaTotals;
-        deltaTotals.testCases.failed = 1;
-        deltaTotals.assertions.failed = 1;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  std::string(),
-                                  std::string(),
-                                  false));
-        m_totals.testCases.failed++;
-        testGroupEnded(std::string(), m_totals, 1, 1);
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
-    }
-
-    bool RunContext::lastAssertionPassed() {
-         return m_lastAssertionPassed;
-    }
-
-    void RunContext::assertionPassed() {
-        m_lastAssertionPassed = true;
-        ++m_totals.assertions.passed;
-        resetAssertionInfo();
-        m_messageScopes.clear();
-    }
-
-    bool RunContext::aborting() const {
-        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
-    }
-
-    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-        m_reporter->sectionStarting(testCaseSection);
-        Counts prevAssertions = m_totals.assertions;
-        double duration = 0;
-        m_shouldReportUnexpected = true;
-        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
-
-        seedRng(*m_config);
-
-        Timer timer;
-        CATCH_TRY {
-            if (m_reporter->getPreferences().shouldRedirectStdOut) {
-#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
-
-                timer.start();
-                invokeActiveTestCase();
-#else
-                OutputRedirect r(redirectedCout, redirectedCerr);
-                timer.start();
-                invokeActiveTestCase();
-#endif
-            } else {
-                timer.start();
-                invokeActiveTestCase();
-            }
-            duration = timer.getElapsedSeconds();
-        } CATCH_CATCH_ANON (TestFailureException&) {
-            // This just means the test was aborted due to failure
-        } CATCH_CATCH_ALL {
-            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
-            // are reported without translation at the point of origin.
-            if( m_shouldReportUnexpected ) {
-                AssertionReaction dummyReaction;
-                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
-            }
-        }
-        Counts assertions = m_totals.assertions - prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        m_testCaseTracker->close();
-        handleUnfinishedSections();
-        m_messages.clear();
-        m_messageScopes.clear();
-
-        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
-        m_reporter->sectionEnded(testCaseSectionStats);
-    }
-
-    void RunContext::invokeActiveTestCase() {
-        FatalConditionHandler fatalConditionHandler; // Handle signals
-        m_activeTestCase->invoke();
-        fatalConditionHandler.reset();
-    }
-
-    void RunContext::handleUnfinishedSections() {
-        // If sections ended prematurely due to an exception we stored their
-        // infos here so we can tear them down outside the unwind process.
-        for (auto it = m_unfinishedSections.rbegin(),
-             itEnd = m_unfinishedSections.rend();
-             it != itEnd;
-             ++it)
-            sectionEnded(*it);
-        m_unfinishedSections.clear();
-    }
-
-    void RunContext::handleExpr(
-        AssertionInfo const& info,
-        ITransientExpression const& expr,
-        AssertionReaction& reaction
-    ) {
-        m_reporter->assertionStarting( info );
-
-        bool negated = isFalseTest( info.resultDisposition );
-        bool result = expr.getResult() != negated;
-
-        if( result ) {
-            if (!m_includeSuccessfulResults) {
-                assertionPassed();
-            }
-            else {
-                reportExpr(info, ResultWas::Ok, &expr, negated);
-            }
-        }
-        else {
-            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
-            populateReaction( reaction );
-        }
-    }
-    void RunContext::reportExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            ITransientExpression const *expr,
-            bool negated ) {
-
-        m_lastAssertionInfo = info;
-        AssertionResultData data( resultType, LazyExpression( negated ) );
-
-        AssertionResult assertionResult{ info, data };
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
-
-        assertionEnded( assertionResult );
-    }
-
-    void RunContext::handleMessage(
-            AssertionInfo const& info,
-            ResultWas::OfType resultType,
-            StringRef const& message,
-            AssertionReaction& reaction
-    ) {
-        m_reporter->assertionStarting( info );
-
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        data.message = static_cast<std::string>(message);
-        AssertionResult assertionResult{ m_lastAssertionInfo, data };
-        assertionEnded( assertionResult );
-        if( !assertionResult.isOk() )
-            populateReaction( reaction );
-    }
-    void RunContext::handleUnexpectedExceptionNotThrown(
-            AssertionInfo const& info,
-            AssertionReaction& reaction
-    ) {
-        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
-    }
-
-    void RunContext::handleUnexpectedInflightException(
-            AssertionInfo const& info,
-            std::string const& message,
-            AssertionReaction& reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = message;
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-        populateReaction( reaction );
-    }
-
-    void RunContext::populateReaction( AssertionReaction& reaction ) {
-        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
-        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
-    }
-
-    void RunContext::handleIncomplete(
-            AssertionInfo const& info
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-    }
-    void RunContext::handleNonExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            AssertionReaction &reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-
-        if( !assertionResult.isOk() )
-            populateReaction( reaction );
-    }
-
-    IResultCapture& getResultCapture() {
-        if (auto* capture = getCurrentContext().getResultCapture())
-            return *capture;
-        else
-            CATCH_INTERNAL_ERROR("No result capture instance");
-    }
-
-    void seedRng(IConfig const& config) {
-        if (config.rngSeed() != 0) {
-            std::srand(config.rngSeed());
-            rng().seed(config.rngSeed());
-        }
-    }
-
-    unsigned int rngSeed() {
-        return getCurrentContext().getConfig()->rngSeed();
-    }
-
-}
-// end catch_run_context.cpp
-// start catch_section.cpp
-
-namespace Catch {
-
-    Section::Section( SectionInfo const& info )
-    :   m_info( info ),
-        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
-    {
-        m_timer.start();
-    }
-
-    Section::~Section() {
-        if( m_sectionIncluded ) {
-            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
-            if( uncaught_exceptions() )
-                getResultCapture().sectionEndedEarly( endInfo );
-            else
-                getResultCapture().sectionEnded( endInfo );
-        }
-    }
-
-    // This indicates whether the section should be executed or not
-    Section::operator bool() const {
-        return m_sectionIncluded;
-    }
-
-} // end namespace Catch
-// end catch_section.cpp
-// start catch_section_info.cpp
-
-namespace Catch {
-
-    SectionInfo::SectionInfo
-        (   SourceLineInfo const& _lineInfo,
-            std::string const& _name )
-    :   name( _name ),
-        lineInfo( _lineInfo )
-    {}
-
-} // end namespace Catch
-// end catch_section_info.cpp
-// start catch_session.cpp
-
-// start catch_session.h
-
-#include <memory>
-
-namespace Catch {
-
-    class Session : NonCopyable {
-    public:
-
-        Session();
-        ~Session() override;
-
-        void showHelp() const;
-        void libIdentify();
-
-        int applyCommandLine( int argc, char const * const * argv );
-    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
-        int applyCommandLine( int argc, wchar_t const * const * argv );
-    #endif
-
-        void useConfigData( ConfigData const& configData );
-
-        template<typename CharT>
-        int run(int argc, CharT const * const argv[]) {
-            if (m_startupExceptions)
-                return 1;
-            int returnCode = applyCommandLine(argc, argv);
-            if (returnCode == 0)
-                returnCode = run();
-            return returnCode;
-        }
-
-        int run();
-
-        clara::Parser const& cli() const;
-        void cli( clara::Parser const& newParser );
-        ConfigData& configData();
-        Config& config();
-    private:
-        int runInternal();
-
-        clara::Parser m_cli;
-        ConfigData m_configData;
-        std::shared_ptr<Config> m_config;
-        bool m_startupExceptions = false;
-    };
-
-} // end namespace Catch
-
-// end catch_session.h
-// start catch_version.h
-
-#include <iosfwd>
-
-namespace Catch {
-
-    // Versioning information
-    struct Version {
-        Version( Version const& ) = delete;
-        Version& operator=( Version const& ) = delete;
-        Version(    unsigned int _majorVersion,
-                    unsigned int _minorVersion,
-                    unsigned int _patchNumber,
-                    char const * const _branchName,
-                    unsigned int _buildNumber );
-
-        unsigned int const majorVersion;
-        unsigned int const minorVersion;
-        unsigned int const patchNumber;
-
-        // buildNumber is only used if branchName is not null
-        char const * const branchName;
-        unsigned int const buildNumber;
-
-        friend std::ostream& operator << ( std::ostream& os, Version const& version );
-    };
-
-    Version const& libraryVersion();
-}
-
-// end catch_version.h
-#include <cstdlib>
-#include <iomanip>
-#include <set>
-#include <iterator>
-
-namespace Catch {
-
-    namespace {
-        const int MaxExitCode = 255;
-
-        IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
-            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
-            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
-
-            return reporter;
-        }
-
-        IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
-            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
-                return createReporter(config->getReporterName(), config);
-            }
-
-            // On older platforms, returning std::unique_ptr<ListeningReporter>
-            // when the return type is std::unique_ptr<IStreamingReporter>
-            // doesn't compile without a std::move call. However, this causes
-            // a warning on newer platforms. Thus, we have to work around
-            // it a bit and downcast the pointer manually.
-            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
-            auto& multi = static_cast<ListeningReporter&>(*ret);
-            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
-            for (auto const& listener : listeners) {
-                multi.addListener(listener->create(Catch::ReporterConfig(config)));
-            }
-            multi.addReporter(createReporter(config->getReporterName(), config));
-            return ret;
-        }
-
-        class TestGroup {
-        public:
-            explicit TestGroup(std::shared_ptr<Config> const& config)
-            : m_config{config}
-            , m_context{config, makeReporter(config)}
-            {
-                auto const& allTestCases = getAllTestCasesSorted(*m_config);
-                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
-                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
-
-                if (m_matches.empty() && invalidArgs.empty()) {
-                    for (auto const& test : allTestCases)
-                        if (!test.isHidden())
-                            m_tests.emplace(&test);
-                } else {
-                    for (auto const& match : m_matches)
-                        m_tests.insert(match.tests.begin(), match.tests.end());
-                }
-            }
-
-            Totals execute() {
-                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
-                Totals totals;
-                m_context.testGroupStarting(m_config->name(), 1, 1);
-                for (auto const& testCase : m_tests) {
-                    if (!m_context.aborting())
-                        totals += m_context.runTest(*testCase);
-                    else
-                        m_context.reporter().skipTest(*testCase);
-                }
-
-                for (auto const& match : m_matches) {
-                    if (match.tests.empty()) {
-                        m_context.reporter().noMatchingTestCases(match.name);
-                        totals.error = -1;
-                    }
-                }
-
-                if (!invalidArgs.empty()) {
-                    for (auto const& invalidArg: invalidArgs)
-                         m_context.reporter().reportInvalidArguments(invalidArg);
-                }
-
-                m_context.testGroupEnded(m_config->name(), totals, 1, 1);
-                return totals;
-            }
-
-        private:
-            using Tests = std::set<TestCase const*>;
-
-            std::shared_ptr<Config> m_config;
-            RunContext m_context;
-            Tests m_tests;
-            TestSpec::Matches m_matches;
-        };
-
-        void applyFilenamesAsTags(Catch::IConfig const& config) {
-            auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
-            for (auto& testCase : tests) {
-                auto tags = testCase.tags;
-
-                std::string filename = testCase.lineInfo.file;
-                auto lastSlash = filename.find_last_of("\\/");
-                if (lastSlash != std::string::npos) {
-                    filename.erase(0, lastSlash);
-                    filename[0] = '#';
-                }
-
-                auto lastDot = filename.find_last_of('.');
-                if (lastDot != std::string::npos) {
-                    filename.erase(lastDot);
-                }
-
-                tags.push_back(std::move(filename));
-                setTags(testCase, tags);
-            }
-        }
-
-    } // anon namespace
-
-    Session::Session() {
-        static bool alreadyInstantiated = false;
-        if( alreadyInstantiated ) {
-            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
-            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
-        }
-
-        // There cannot be exceptions at startup in no-exception mode.
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
-        if ( !exceptions.empty() ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config);
-
-            m_startupExceptions = true;
-            Colour colourGuard( Colour::Red );
-            Catch::cerr() << "Errors occurred during startup!" << '\n';
-            // iterate over all exceptions and notify user
-            for ( const auto& ex_ptr : exceptions ) {
-                try {
-                    std::rethrow_exception(ex_ptr);
-                } catch ( std::exception const& ex ) {
-                    Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
-                }
-            }
-        }
-#endif
-
-        alreadyInstantiated = true;
-        m_cli = makeCommandLineParser( m_configData );
-    }
-    Session::~Session() {
-        Catch::cleanUp();
-    }
-
-    void Session::showHelp() const {
-        Catch::cout()
-                << "\nCatch v" << libraryVersion() << "\n"
-                << m_cli << std::endl
-                << "For more detailed usage please see the project docs\n" << std::endl;
-    }
-    void Session::libIdentify() {
-        Catch::cout()
-                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
-                << std::left << std::setw(16) << "category: " << "testframework\n"
-                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
-                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
-    }
-
-    int Session::applyCommandLine( int argc, char const * const * argv ) {
-        if( m_startupExceptions )
-            return 1;
-
-        auto result = m_cli.parse( clara::Args( argc, argv ) );
-        if( !result ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config);
-            Catch::cerr()
-                << Colour( Colour::Red )
-                << "\nError(s) in input:\n"
-                << Column( result.errorMessage() ).indent( 2 )
-                << "\n\n";
-            Catch::cerr() << "Run with -? for usage\n" << std::endl;
-            return MaxExitCode;
-        }
-
-        if( m_configData.showHelp )
-            showHelp();
-        if( m_configData.libIdentify )
-            libIdentify();
-        m_config.reset();
-        return 0;
-    }
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
-    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
-
-        char **utf8Argv = new char *[ argc ];
-
-        for ( int i = 0; i < argc; ++i ) {
-            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
-
-            utf8Argv[ i ] = new char[ bufSize ];
-
-            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
-        }
-
-        int returnCode = applyCommandLine( argc, utf8Argv );
-
-        for ( int i = 0; i < argc; ++i )
-            delete [] utf8Argv[ i ];
-
-        delete [] utf8Argv;
-
-        return returnCode;
-    }
-#endif
-
-    void Session::useConfigData( ConfigData const& configData ) {
-        m_configData = configData;
-        m_config.reset();
-    }
-
-    int Session::run() {
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        int exitCode = runInternal();
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        return exitCode;
-    }
-
-    clara::Parser const& Session::cli() const {
-        return m_cli;
-    }
-    void Session::cli( clara::Parser const& newParser ) {
-        m_cli = newParser;
-    }
-    ConfigData& Session::configData() {
-        return m_configData;
-    }
-    Config& Session::config() {
-        if( !m_config )
-            m_config = std::make_shared<Config>( m_configData );
-        return *m_config;
-    }
-
-    int Session::runInternal() {
-        if( m_startupExceptions )
-            return 1;
-
-        if (m_configData.showHelp || m_configData.libIdentify) {
-            return 0;
-        }
-
-        CATCH_TRY {
-            config(); // Force config to be constructed
-
-            seedRng( *m_config );
-
-            if( m_configData.filenamesAsTags )
-                applyFilenamesAsTags( *m_config );
-
-            // Handle list request
-            if( Option<std::size_t> listed = list( m_config ) )
-                return static_cast<int>( *listed );
-
-            TestGroup tests { m_config };
-            auto const totals = tests.execute();
-
-            if( m_config->warnAboutNoTests() && totals.error == -1 )
-                return 2;
-
-            // Note that on unices only the lower 8 bits are usually used, clamping
-            // the return value to 255 prevents false negative when some multiple
-            // of 256 tests has failed
-            return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
-        }
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        catch( std::exception& ex ) {
-            Catch::cerr() << ex.what() << std::endl;
-            return MaxExitCode;
-        }
-#endif
-    }
-
-} // end namespace Catch
-// end catch_session.cpp
-// start catch_singletons.cpp
-
-#include <vector>
-
-namespace Catch {
-
-    namespace {
-        static auto getSingletons() -> std::vector<ISingleton*>*& {
-            static std::vector<ISingleton*>* g_singletons = nullptr;
-            if( !g_singletons )
-                g_singletons = new std::vector<ISingleton*>();
-            return g_singletons;
-        }
-    }
-
-    ISingleton::~ISingleton() {}
-
-    void addSingleton(ISingleton* singleton ) {
-        getSingletons()->push_back( singleton );
-    }
-    void cleanupSingletons() {
-        auto& singletons = getSingletons();
-        for( auto singleton : *singletons )
-            delete singleton;
-        delete singletons;
-        singletons = nullptr;
-    }
-
-} // namespace Catch
-// end catch_singletons.cpp
-// start catch_startup_exception_registry.cpp
-
-namespace Catch {
-void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
-        CATCH_TRY {
-            m_exceptions.push_back(exception);
-        } CATCH_CATCH_ALL {
-            // If we run out of memory during start-up there's really not a lot more we can do about it
-            std::terminate();
-        }
-    }
-
-    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
-        return m_exceptions;
-    }
-
-} // end namespace Catch
-// end catch_startup_exception_registry.cpp
-// start catch_stream.cpp
-
-#include <cstdio>
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    Catch::IStream::~IStream() = default;
-
-    namespace Detail { namespace {
-        template<typename WriterF, std::size_t bufferSize=256>
-        class StreamBufImpl : public std::streambuf {
-            char data[bufferSize];
-            WriterF m_writer;
-
-        public:
-            StreamBufImpl() {
-                setp( data, data + sizeof(data) );
-            }
-
-            ~StreamBufImpl() noexcept {
-                StreamBufImpl::sync();
-            }
-
-        private:
-            int overflow( int c ) override {
-                sync();
-
-                if( c != EOF ) {
-                    if( pbase() == epptr() )
-                        m_writer( std::string( 1, static_cast<char>( c ) ) );
-                    else
-                        sputc( static_cast<char>( c ) );
-                }
-                return 0;
-            }
-
-            int sync() override {
-                if( pbase() != pptr() ) {
-                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
-                    setp( pbase(), epptr() );
-                }
-                return 0;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        struct OutputDebugWriter {
-
-            void operator()( std::string const&str ) {
-                writeToDebugConsole( str );
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class FileStream : public IStream {
-            mutable std::ofstream m_ofs;
-        public:
-            FileStream( StringRef filename ) {
-                m_ofs.open( filename.c_str() );
-                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
-            }
-            ~FileStream() override = default;
-        public: // IStream
-            std::ostream& stream() const override {
-                return m_ofs;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class CoutStream : public IStream {
-            mutable std::ostream m_os;
-        public:
-            // Store the streambuf from cout up-front because
-            // cout may get redirected when running tests
-            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
-            ~CoutStream() override = default;
-
-        public: // IStream
-            std::ostream& stream() const override { return m_os; }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class DebugOutStream : public IStream {
-            std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
-            mutable std::ostream m_os;
-        public:
-            DebugOutStream()
-            :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
-                m_os( m_streamBuf.get() )
-            {}
-
-            ~DebugOutStream() override = default;
-
-        public: // IStream
-            std::ostream& stream() const override { return m_os; }
-        };
-
-    }} // namespace anon::detail
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    auto makeStream( StringRef const &filename ) -> IStream const* {
-        if( filename.empty() )
-            return new Detail::CoutStream();
-        else if( filename[0] == '%' ) {
-            if( filename == "%debug" )
-                return new Detail::DebugOutStream();
-            else
-                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
-        }
-        else
-            return new Detail::FileStream( filename );
-    }
-
-    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
-    struct StringStreams {
-        std::vector<std::unique_ptr<std::ostringstream>> m_streams;
-        std::vector<std::size_t> m_unused;
-        std::ostringstream m_referenceStream; // Used for copy state/ flags from
-
-        auto add() -> std::size_t {
-            if( m_unused.empty() ) {
-                m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
-                return m_streams.size()-1;
-            }
-            else {
-                auto index = m_unused.back();
-                m_unused.pop_back();
-                return index;
-            }
-        }
-
-        void release( std::size_t index ) {
-            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
-            m_unused.push_back(index);
-        }
-    };
-
-    ReusableStringStream::ReusableStringStream()
-    :   m_index( Singleton<StringStreams>::getMutable().add() ),
-        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
-    {}
-
-    ReusableStringStream::~ReusableStringStream() {
-        static_cast<std::ostringstream*>( m_oss )->str("");
-        m_oss->clear();
-        Singleton<StringStreams>::getMutable().release( m_index );
-    }
-
-    auto ReusableStringStream::str() const -> std::string {
-        return static_cast<std::ostringstream*>( m_oss )->str();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
-    std::ostream& cout() { return std::cout; }
-    std::ostream& cerr() { return std::cerr; }
-    std::ostream& clog() { return std::clog; }
-#endif
-}
-// end catch_stream.cpp
-// start catch_string_manip.cpp
-
-#include <algorithm>
-#include <ostream>
-#include <cstring>
-#include <cctype>
-#include <vector>
-
-namespace Catch {
-
-    namespace {
-        char toLowerCh(char c) {
-            return static_cast<char>( std::tolower( c ) );
-        }
-    }
-
-    bool startsWith( std::string const& s, std::string const& prefix ) {
-        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
-    }
-    bool startsWith( std::string const& s, char prefix ) {
-        return !s.empty() && s[0] == prefix;
-    }
-    bool endsWith( std::string const& s, std::string const& suffix ) {
-        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
-    }
-    bool endsWith( std::string const& s, char suffix ) {
-        return !s.empty() && s[s.size()-1] == suffix;
-    }
-    bool contains( std::string const& s, std::string const& infix ) {
-        return s.find( infix ) != std::string::npos;
-    }
-    void toLowerInPlace( std::string& s ) {
-        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
-    }
-    std::string toLower( std::string const& s ) {
-        std::string lc = s;
-        toLowerInPlace( lc );
-        return lc;
-    }
-    std::string trim( std::string const& str ) {
-        static char const* whitespaceChars = "\n\r\t ";
-        std::string::size_type start = str.find_first_not_of( whitespaceChars );
-        std::string::size_type end = str.find_last_not_of( whitespaceChars );
-
-        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
-    }
-
-    StringRef trim(StringRef ref) {
-        const auto is_ws = [](char c) {
-            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
-        };
-        size_t real_begin = 0;
-        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
-        size_t real_end = ref.size();
-        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
-
-        return ref.substr(real_begin, real_end - real_begin);
-    }
-
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
-        bool replaced = false;
-        std::size_t i = str.find( replaceThis );
-        while( i != std::string::npos ) {
-            replaced = true;
-            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
-            if( i < str.size()-withThis.size() )
-                i = str.find( replaceThis, i+withThis.size() );
-            else
-                i = std::string::npos;
-        }
-        return replaced;
-    }
-
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
-        std::vector<StringRef> subStrings;
-        std::size_t start = 0;
-        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
-            if( str[pos] == delimiter ) {
-                if( pos - start > 1 )
-                    subStrings.push_back( str.substr( start, pos-start ) );
-                start = pos+1;
-            }
-        }
-        if( start < str.size() )
-            subStrings.push_back( str.substr( start, str.size()-start ) );
-        return subStrings;
-    }
-
-    pluralise::pluralise( std::size_t count, std::string const& label )
-    :   m_count( count ),
-        m_label( label )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
-        os << pluraliser.m_count << ' ' << pluraliser.m_label;
-        if( pluraliser.m_count != 1 )
-            os << 's';
-        return os;
-    }
-
-}
-// end catch_string_manip.cpp
-// start catch_stringref.cpp
-
-#include <algorithm>
-#include <ostream>
-#include <cstring>
-#include <cstdint>
-
-namespace Catch {
-    StringRef::StringRef( char const* rawChars ) noexcept
-    : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
-    {}
-
-    auto StringRef::c_str() const -> char const* {
-        CATCH_ENFORCE(isNullTerminated(), "Called StringRef::c_str() on a non-null-terminated instance");
-        return m_start;
-    }
-    auto StringRef::data() const noexcept -> char const* {
-        return m_start;
-    }
-
-    auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
-        if (start < m_size) {
-            return StringRef(m_start + start, (std::min)(m_size - start, size));
-        } else {
-            return StringRef();
-        }
-    }
-    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
-        return m_size == other.m_size
-            && (std::memcmp( m_start, other.m_start, m_size ) == 0);
-    }
-
-    auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
-        return os.write(str.data(), str.size());
-    }
-
-    auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
-        lhs.append(rhs.data(), rhs.size());
-        return lhs;
-    }
-
-} // namespace Catch
-// end catch_stringref.cpp
-// start catch_tag_alias.cpp
-
-namespace Catch {
-    TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
-}
-// end catch_tag_alias.cpp
-// start catch_tag_alias_autoregistrar.cpp
-
-namespace Catch {
-
-    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
-        CATCH_TRY {
-            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
-
-}
-// end catch_tag_alias_autoregistrar.cpp
-// start catch_tag_alias_registry.cpp
-
-#include <sstream>
-
-namespace Catch {
-
-    TagAliasRegistry::~TagAliasRegistry() {}
-
-    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
-        auto it = m_registry.find( alias );
-        if( it != m_registry.end() )
-            return &(it->second);
-        else
-            return nullptr;
-    }
-
-    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
-        std::string expandedTestSpec = unexpandedTestSpec;
-        for( auto const& registryKvp : m_registry ) {
-            std::size_t pos = expandedTestSpec.find( registryKvp.first );
-            if( pos != std::string::npos ) {
-                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
-                                    registryKvp.second.tag +
-                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
-            }
-        }
-        return expandedTestSpec;
-    }
-
-    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
-        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
-                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
-
-        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
-                      "error: tag alias, '" << alias << "' already registered.\n"
-                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
-                      << "\tRedefined at: " << lineInfo );
-    }
-
-    ITagAliasRegistry::~ITagAliasRegistry() {}
-
-    ITagAliasRegistry const& ITagAliasRegistry::get() {
-        return getRegistryHub().getTagAliasRegistry();
-    }
-
-} // end namespace Catch
-// end catch_tag_alias_registry.cpp
-// start catch_test_case_info.cpp
-
-#include <cctype>
-#include <exception>
-#include <algorithm>
-#include <sstream>
-
-namespace Catch {
-
-    namespace {
-        TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
-            if( startsWith( tag, '.' ) ||
-                tag == "!hide" )
-                return TestCaseInfo::IsHidden;
-            else if( tag == "!throws" )
-                return TestCaseInfo::Throws;
-            else if( tag == "!shouldfail" )
-                return TestCaseInfo::ShouldFail;
-            else if( tag == "!mayfail" )
-                return TestCaseInfo::MayFail;
-            else if( tag == "!nonportable" )
-                return TestCaseInfo::NonPortable;
-            else if( tag == "!benchmark" )
-                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
-            else
-                return TestCaseInfo::None;
-        }
-        bool isReservedTag( std::string const& tag ) {
-            return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
-        }
-        void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
-            CATCH_ENFORCE( !isReservedTag(tag),
-                          "Tag name: [" << tag << "] is not allowed.\n"
-                          << "Tag names starting with non alphanumeric characters are reserved\n"
-                          << _lineInfo );
-        }
-    }
-
-    TestCase makeTestCase(  ITestInvoker* _testCase,
-                            std::string const& _className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& _lineInfo )
-    {
-        bool isHidden = false;
-
-        // Parse out tags
-        std::vector<std::string> tags;
-        std::string desc, tag;
-        bool inTag = false;
-        for (char c : nameAndTags.tags) {
-            if( !inTag ) {
-                if( c == '[' )
-                    inTag = true;
-                else
-                    desc += c;
-            }
-            else {
-                if( c == ']' ) {
-                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
-                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
-                        isHidden = true;
-                    else if( prop == TestCaseInfo::None )
-                        enforceNotReservedTag( tag, _lineInfo );
-
-                    // Merged hide tags like `[.approvals]` should be added as
-                    // `[.][approvals]`. The `[.]` is added at later point, so
-                    // we only strip the prefix
-                    if (startsWith(tag, '.') && tag.size() > 1) {
-                        tag.erase(0, 1);
-                    }
-                    tags.push_back( tag );
-                    tag.clear();
-                    inTag = false;
-                }
-                else
-                    tag += c;
-            }
-        }
-        if( isHidden ) {
-            // Add all "hidden" tags to make them behave identically
-            tags.insert( tags.end(), { ".", "!hide" } );
-        }
-
-        TestCaseInfo info( static_cast<std::string>(nameAndTags.name), _className, desc, tags, _lineInfo );
-        return TestCase( _testCase, std::move(info) );
-    }
-
-    void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
-        std::sort(begin(tags), end(tags));
-        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
-        testCaseInfo.lcaseTags.clear();
-
-        for( auto const& tag : tags ) {
-            std::string lcaseTag = toLower( tag );
-            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
-            testCaseInfo.lcaseTags.push_back( lcaseTag );
-        }
-        testCaseInfo.tags = std::move(tags);
-    }
-
-    TestCaseInfo::TestCaseInfo( std::string const& _name,
-                                std::string const& _className,
-                                std::string const& _description,
-                                std::vector<std::string> const& _tags,
-                                SourceLineInfo const& _lineInfo )
-    :   name( _name ),
-        className( _className ),
-        description( _description ),
-        lineInfo( _lineInfo ),
-        properties( None )
-    {
-        setTags( *this, _tags );
-    }
-
-    bool TestCaseInfo::isHidden() const {
-        return ( properties & IsHidden ) != 0;
-    }
-    bool TestCaseInfo::throws() const {
-        return ( properties & Throws ) != 0;
-    }
-    bool TestCaseInfo::okToFail() const {
-        return ( properties & (ShouldFail | MayFail ) ) != 0;
-    }
-    bool TestCaseInfo::expectedToFail() const {
-        return ( properties & (ShouldFail ) ) != 0;
-    }
-
-    std::string TestCaseInfo::tagsAsString() const {
-        std::string ret;
-        // '[' and ']' per tag
-        std::size_t full_size = 2 * tags.size();
-        for (const auto& tag : tags) {
-            full_size += tag.size();
-        }
-        ret.reserve(full_size);
-        for (const auto& tag : tags) {
-            ret.push_back('[');
-            ret.append(tag);
-            ret.push_back(']');
-        }
-
-        return ret;
-    }
-
-    TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
-
-    TestCase TestCase::withName( std::string const& _newName ) const {
-        TestCase other( *this );
-        other.name = _newName;
-        return other;
-    }
-
-    void TestCase::invoke() const {
-        test->invoke();
-    }
-
-    bool TestCase::operator == ( TestCase const& other ) const {
-        return  test.get() == other.test.get() &&
-                name == other.name &&
-                className == other.className;
-    }
-
-    bool TestCase::operator < ( TestCase const& other ) const {
-        return name < other.name;
-    }
-
-    TestCaseInfo const& TestCase::getTestCaseInfo() const
-    {
-        return *this;
-    }
-
-} // end namespace Catch
-// end catch_test_case_info.cpp
-// start catch_test_case_registry_impl.cpp
-
-#include <sstream>
-
-namespace Catch {
-
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
-
-        std::vector<TestCase> sorted = unsortedTestCases;
-
-        switch( config.runOrder() ) {
-            case RunTests::InLexicographicalOrder:
-                std::sort( sorted.begin(), sorted.end() );
-                break;
-            case RunTests::InRandomOrder:
-                seedRng( config );
-                std::shuffle( sorted.begin(), sorted.end(), rng() );
-                break;
-            case RunTests::InDeclarationOrder:
-                // already in declaration order
-                break;
-        }
-        return sorted;
-    }
-
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config ) {
-        return !testCase.throws() || config.allowThrows();
-    }
-
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
-        return testSpec.matches( testCase ) && isThrowSafe( testCase, config );
-    }
-
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
-        std::set<TestCase> seenFunctions;
-        for( auto const& function : functions ) {
-            auto prev = seenFunctions.insert( function );
-            CATCH_ENFORCE( prev.second,
-                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
-                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
-                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
-        }
-    }
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
-        std::vector<TestCase> filtered;
-        filtered.reserve( testCases.size() );
-        for (auto const& testCase : testCases) {
-            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
-                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
-                filtered.push_back(testCase);
-            }
-        }
-        return filtered;
-    }
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
-        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
-    }
-
-    void TestRegistry::registerTest( TestCase const& testCase ) {
-        std::string name = testCase.getTestCaseInfo().name;
-        if( name.empty() ) {
-            ReusableStringStream rss;
-            rss << "Anonymous test case " << ++m_unnamedCount;
-            return registerTest( testCase.withName( rss.str() ) );
-        }
-        m_functions.push_back( testCase );
-    }
-
-    std::vector<TestCase> const& TestRegistry::getAllTests() const {
-        return m_functions;
-    }
-    std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
-        if( m_sortedFunctions.empty() )
-            enforceNoDuplicateTestCases( m_functions );
-
-        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
-            m_sortedFunctions = sortTests( config, m_functions );
-            m_currentSortOrder = config.runOrder();
-        }
-        return m_sortedFunctions;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
-
-    void TestInvokerAsFunction::invoke() const {
-        m_testAsFunction();
-    }
-
-    std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
-        std::string className(classOrQualifiedMethodName);
-        if( startsWith( className, '&' ) )
-        {
-            std::size_t lastColons = className.rfind( "::" );
-            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
-            if( penultimateColons == std::string::npos )
-                penultimateColons = 1;
-            className = className.substr( penultimateColons, lastColons-penultimateColons );
-        }
-        return className;
-    }
-
-} // end namespace Catch
-// end catch_test_case_registry_impl.cpp
-// start catch_test_case_tracker.cpp
-
-#include <algorithm>
-#include <cassert>
-#include <stdexcept>
-#include <memory>
-#include <sstream>
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
-    :   name( _name ),
-        location( _location )
-    {}
-
-    ITracker::~ITracker() = default;
-
-    ITracker& TrackerContext::startRun() {
-        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
-        m_currentTracker = nullptr;
-        m_runState = Executing;
-        return *m_rootTracker;
-    }
-
-    void TrackerContext::endRun() {
-        m_rootTracker.reset();
-        m_currentTracker = nullptr;
-        m_runState = NotStarted;
-    }
-
-    void TrackerContext::startCycle() {
-        m_currentTracker = m_rootTracker.get();
-        m_runState = Executing;
-    }
-    void TrackerContext::completeCycle() {
-        m_runState = CompletedCycle;
-    }
-
-    bool TrackerContext::completedCycle() const {
-        return m_runState == CompletedCycle;
-    }
-    ITracker& TrackerContext::currentTracker() {
-        return *m_currentTracker;
-    }
-    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
-        m_currentTracker = tracker;
-    }
-
-    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   m_nameAndLocation( nameAndLocation ),
-        m_ctx( ctx ),
-        m_parent( parent )
-    {}
-
-    NameAndLocation const& TrackerBase::nameAndLocation() const {
-        return m_nameAndLocation;
-    }
-    bool TrackerBase::isComplete() const {
-        return m_runState == CompletedSuccessfully || m_runState == Failed;
-    }
-    bool TrackerBase::isSuccessfullyCompleted() const {
-        return m_runState == CompletedSuccessfully;
-    }
-    bool TrackerBase::isOpen() const {
-        return m_runState != NotStarted && !isComplete();
-    }
-    bool TrackerBase::hasChildren() const {
-        return !m_children.empty();
-    }
-
-    void TrackerBase::addChild( ITrackerPtr const& child ) {
-        m_children.push_back( child );
-    }
-
-    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
-        auto it = std::find_if( m_children.begin(), m_children.end(),
-            [&nameAndLocation]( ITrackerPtr const& tracker ){
-                return
-                    tracker->nameAndLocation().location == nameAndLocation.location &&
-                    tracker->nameAndLocation().name == nameAndLocation.name;
-            } );
-        return( it != m_children.end() )
-            ? *it
-            : nullptr;
-    }
-    ITracker& TrackerBase::parent() {
-        assert( m_parent ); // Should always be non-null except for root
-        return *m_parent;
-    }
-
-    void TrackerBase::openChild() {
-        if( m_runState != ExecutingChildren ) {
-            m_runState = ExecutingChildren;
-            if( m_parent )
-                m_parent->openChild();
-        }
-    }
-
-    bool TrackerBase::isSectionTracker() const { return false; }
-    bool TrackerBase::isGeneratorTracker() const { return false; }
-
-    void TrackerBase::open() {
-        m_runState = Executing;
-        moveToThis();
-        if( m_parent )
-            m_parent->openChild();
-    }
-
-    void TrackerBase::close() {
-
-        // Close any still open children (e.g. generators)
-        while( &m_ctx.currentTracker() != this )
-            m_ctx.currentTracker().close();
-
-        switch( m_runState ) {
-            case NeedsAnotherRun:
-                break;
-
-            case Executing:
-                m_runState = CompletedSuccessfully;
-                break;
-            case ExecutingChildren:
-                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
-                    m_runState = CompletedSuccessfully;
-                break;
-
-            case NotStarted:
-            case CompletedSuccessfully:
-            case Failed:
-                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
-
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
-        }
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::fail() {
-        m_runState = Failed;
-        if( m_parent )
-            m_parent->markAsNeedingAnotherRun();
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::markAsNeedingAnotherRun() {
-        m_runState = NeedsAnotherRun;
-    }
-
-    void TrackerBase::moveToParent() {
-        assert( m_parent );
-        m_ctx.setCurrentTracker( m_parent );
-    }
-    void TrackerBase::moveToThis() {
-        m_ctx.setCurrentTracker( this );
-    }
-
-    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   TrackerBase( nameAndLocation, ctx, parent ),
-        m_trimmed_name(trim(nameAndLocation.name))
-    {
-        if( parent ) {
-            while( !parent->isSectionTracker() )
-                parent = &parent->parent();
-
-            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
-            addNextFilters( parentSection.m_filters );
-        }
-    }
-
-    bool SectionTracker::isComplete() const {
-        bool complete = true;
-
-        if ((m_filters.empty() || m_filters[0] == "")
-            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
-            complete = TrackerBase::isComplete();
-        }
-        return complete;
-    }
-
-    bool SectionTracker::isSectionTracker() const { return true; }
-
-    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
-        std::shared_ptr<SectionTracker> section;
-
-        ITracker& currentTracker = ctx.currentTracker();
-        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-            assert( childTracker );
-            assert( childTracker->isSectionTracker() );
-            section = std::static_pointer_cast<SectionTracker>( childTracker );
-        }
-        else {
-            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
-            currentTracker.addChild( section );
-        }
-        if( !ctx.completedCycle() )
-            section->tryOpen();
-        return *section;
-    }
-
-    void SectionTracker::tryOpen() {
-        if( !isComplete() )
-            open();
-    }
-
-    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
-        if( !filters.empty() ) {
-            m_filters.reserve( m_filters.size() + filters.size() + 2 );
-            m_filters.emplace_back(""); // Root - should never be consulted
-            m_filters.emplace_back(""); // Test Case - not a section filter
-            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
-        }
-    }
-    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
-        if( filters.size() > 1 )
-            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
-    }
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-
-} // namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-// end catch_test_case_tracker.cpp
-// start catch_test_registry.cpp
-
-namespace Catch {
-
-    auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
-        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
-    }
-
-    NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
-
-    AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
-        CATCH_TRY {
-            getMutableRegistryHub()
-                    .registerTest(
-                        makeTestCase(
-                            invoker,
-                            extractClassName( classOrMethod ),
-                            nameAndTags,
-                            lineInfo));
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
-
-    AutoReg::~AutoReg() = default;
-}
-// end catch_test_registry.cpp
-// start catch_test_spec.cpp
-
-#include <algorithm>
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    TestSpec::Pattern::Pattern( std::string const& name )
-    : m_name( name )
-    {}
-
-    TestSpec::Pattern::~Pattern() = default;
-
-    std::string const& TestSpec::Pattern::name() const {
-        return m_name;
-    }
-
-    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
-    : Pattern( filterString )
-    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
-    {}
-
-    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
-        return m_wildcardPattern.matches( testCase.name );
-    }
-
-    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
-    : Pattern( filterString )
-    , m_tag( toLower( tag ) )
-    {}
-
-    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
-        return std::find(begin(testCase.lcaseTags),
-                         end(testCase.lcaseTags),
-                         m_tag) != end(testCase.lcaseTags);
-    }
-
-    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern )
-    : Pattern( underlyingPattern->name() )
-    , m_underlyingPattern( underlyingPattern )
-    {}
-
-    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const {
-        return !m_underlyingPattern->matches( testCase );
-    }
-
-    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
-        return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
-    }
-
-    std::string TestSpec::Filter::name() const {
-        std::string name;
-        for( auto const& p : m_patterns )
-            name += p->name();
-        return name;
-    }
-
-    bool TestSpec::hasFilters() const {
-        return !m_filters.empty();
-    }
-
-    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
-        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
-    }
-
-    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
-    {
-        Matches matches( m_filters.size() );
-        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
-            std::vector<TestCase const*> currentMatches;
-            for( auto const& test : testCases )
-                if( isThrowSafe( test, config ) && filter.matches( test ) )
-                    currentMatches.emplace_back( &test );
-            return FilterMatch{ filter.name(), currentMatches };
-        } );
-        return matches;
-    }
-
-    const TestSpec::vectorStrings& TestSpec::getInvalidArgs() const{
-        return  (m_invalidArgs);
-    }
-
-}
-// end catch_test_spec.cpp
-// start catch_test_spec_parser.cpp
-
-namespace Catch {
-
-    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
-
-    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
-        m_mode = None;
-        m_exclusion = false;
-        m_arg = m_tagAliases->expandAliases( arg );
-        m_escapeChars.clear();
-        m_substring.reserve(m_arg.size());
-        m_patternName.reserve(m_arg.size());
-        m_realPatternPos = 0;
-
-        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
-          //if visitChar fails
-           if( !visitChar( m_arg[m_pos] ) ){
-               m_testSpec.m_invalidArgs.push_back(arg);
-               break;
-           }
-        endMode();
-        return *this;
-    }
-    TestSpec TestSpecParser::testSpec() {
-        addFilter();
-        return m_testSpec;
-    }
-    bool TestSpecParser::visitChar( char c ) {
-        if( (m_mode != EscapedName) && (c == '\\') ) {
-            escape();
-            addCharToPattern(c);
-            return true;
-        }else if((m_mode != EscapedName) && (c == ',') )  {
-            return separate();
-        }
-
-        switch( m_mode ) {
-        case None:
-            if( processNoneChar( c ) )
-                return true;
-            break;
-        case Name:
-            processNameChar( c );
-            break;
-        case EscapedName:
-            endMode();
-            addCharToPattern(c);
-            return true;
-        default:
-        case Tag:
-        case QuotedName:
-            if( processOtherChar( c ) )
-                return true;
-            break;
-        }
-
-        m_substring += c;
-        if( !isControlChar( c ) ) {
-            m_patternName += c;
-            m_realPatternPos++;
-        }
-        return true;
-    }
-    // Two of the processing methods return true to signal the caller to return
-    // without adding the given character to the current pattern strings
-    bool TestSpecParser::processNoneChar( char c ) {
-        switch( c ) {
-        case ' ':
-            return true;
-        case '~':
-            m_exclusion = true;
-            return false;
-        case '[':
-            startNewMode( Tag );
-            return false;
-        case '"':
-            startNewMode( QuotedName );
-            return false;
-        default:
-            startNewMode( Name );
-            return false;
-        }
-    }
-    void TestSpecParser::processNameChar( char c ) {
-        if( c == '[' ) {
-            if( m_substring == "exclude:" )
-                m_exclusion = true;
-            else
-                endMode();
-            startNewMode( Tag );
-        }
-    }
-    bool TestSpecParser::processOtherChar( char c ) {
-        if( !isControlChar( c ) )
-            return false;
-        m_substring += c;
-        endMode();
-        return true;
-    }
-    void TestSpecParser::startNewMode( Mode mode ) {
-        m_mode = mode;
-    }
-    void TestSpecParser::endMode() {
-        switch( m_mode ) {
-        case Name:
-        case QuotedName:
-            return addNamePattern();
-        case Tag:
-            return addTagPattern();
-        case EscapedName:
-            revertBackToLastMode();
-            return;
-        case None:
-        default:
-            return startNewMode( None );
-        }
-    }
-    void TestSpecParser::escape() {
-        saveLastMode();
-        m_mode = EscapedName;
-        m_escapeChars.push_back(m_realPatternPos);
-    }
-    bool TestSpecParser::isControlChar( char c ) const {
-        switch( m_mode ) {
-            default:
-                return false;
-            case None:
-                return c == '~';
-            case Name:
-                return c == '[';
-            case EscapedName:
-                return true;
-            case QuotedName:
-                return c == '"';
-            case Tag:
-                return c == '[' || c == ']';
-        }
-    }
-
-    void TestSpecParser::addFilter() {
-        if( !m_currentFilter.m_patterns.empty() ) {
-            m_testSpec.m_filters.push_back( m_currentFilter );
-            m_currentFilter = TestSpec::Filter();
-        }
-    }
-
-    void TestSpecParser::saveLastMode() {
-      lastMode = m_mode;
-    }
-
-    void TestSpecParser::revertBackToLastMode() {
-      m_mode = lastMode;
-    }
-
-    bool TestSpecParser::separate() {
-      if( (m_mode==QuotedName) || (m_mode==Tag) ){
-         //invalid argument, signal failure to previous scope.
-         m_mode = None;
-         m_pos = m_arg.size();
-         m_substring.clear();
-         m_patternName.clear();
-         return false;
-      }
-      endMode();
-      addFilter();
-      return true; //success
-    }
-
-    std::string TestSpecParser::preprocessPattern() {
-        std::string token = m_patternName;
-        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
-            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
-        m_escapeChars.clear();
-        if (startsWith(token, "exclude:")) {
-            m_exclusion = true;
-            token = token.substr(8);
-        }
-
-        m_patternName.clear();
-
-        return token;
-    }
-
-    void TestSpecParser::addNamePattern() {
-        auto token = preprocessPattern();
-
-        if (!token.empty()) {
-            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
-            if (m_exclusion)
-                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
-            m_currentFilter.m_patterns.push_back(pattern);
-        }
-        m_substring.clear();
-        m_exclusion = false;
-        m_mode = None;
-    }
-
-    void TestSpecParser::addTagPattern() {
-        auto token = preprocessPattern();
-
-        if (!token.empty()) {
-            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
-            // we have to create a separate hide tag and shorten the real one
-            if (token.size() > 1 && token[0] == '.') {
-                token.erase(token.begin());
-                TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
-                if (m_exclusion) {
-                    pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
-                }
-                m_currentFilter.m_patterns.push_back(pattern);
-            }
-
-            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);
-
-            if (m_exclusion) {
-                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
-            }
-            m_currentFilter.m_patterns.push_back(pattern);
-        }
-        m_substring.clear();
-        m_exclusion = false;
-        m_mode = None;
-    }
-
-    TestSpec parseTestSpec( std::string const& arg ) {
-        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
-    }
-
-} // namespace Catch
-// end catch_test_spec_parser.cpp
-// start catch_timer.cpp
-
-#include <chrono>
-
-static const uint64_t nanosecondsInSecond = 1000000000;
-
-namespace Catch {
-
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
-        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
-    }
-
-    namespace {
-        auto estimateClockResolution() -> uint64_t {
-            uint64_t sum = 0;
-            static const uint64_t iterations = 1000000;
-
-            auto startTime = getCurrentNanosecondsSinceEpoch();
-
-            for( std::size_t i = 0; i < iterations; ++i ) {
-
-                uint64_t ticks;
-                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
-                do {
-                    ticks = getCurrentNanosecondsSinceEpoch();
-                } while( ticks == baseTicks );
-
-                auto delta = ticks - baseTicks;
-                sum += delta;
-
-                // If we have been calibrating for over 3 seconds -- the clock
-                // is terrible and we should move on.
-                // TBD: How to signal that the measured resolution is probably wrong?
-                if (ticks > startTime + 3 * nanosecondsInSecond) {
-                    return sum / ( i + 1u );
-                }
-            }
-
-            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
-            // - and potentially do more iterations if there's a high variance.
-            return sum/iterations;
-        }
-    }
-    auto getEstimatedClockResolution() -> uint64_t {
-        static auto s_resolution = estimateClockResolution();
-        return s_resolution;
-    }
-
-    void Timer::start() {
-       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
-    }
-    auto Timer::getElapsedNanoseconds() const -> uint64_t {
-        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
-    }
-    auto Timer::getElapsedMicroseconds() const -> uint64_t {
-        return getElapsedNanoseconds()/1000;
-    }
-    auto Timer::getElapsedMilliseconds() const -> unsigned int {
-        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
-    }
-    auto Timer::getElapsedSeconds() const -> double {
-        return getElapsedMicroseconds()/1000000.0;
-    }
-
-} // namespace Catch
-// end catch_timer.cpp
-// start catch_tostring.cpp
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#    pragma clang diagnostic ignored "-Wglobal-constructors"
-#endif
-
-// Enable specific decls locally
-#if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#endif
-
-#include <cmath>
-#include <iomanip>
-
-namespace Catch {
-
-namespace Detail {
-
-    const std::string unprintableString = "{?}";
-
-    namespace {
-        const int hexThreshold = 255;
-
-        struct Endianness {
-            enum Arch { Big, Little };
-
-            static Arch which() {
-                int one = 1;
-                // If the lowest byte we read is non-zero, we can assume
-                // that little endian format is used.
-                auto value = *reinterpret_cast<char*>(&one);
-                return value ? Little : Big;
-            }
-        };
-    }
-
-    std::string rawMemoryToString( const void *object, std::size_t size ) {
-        // Reverse order for little endian architectures
-        int i = 0, end = static_cast<int>( size ), inc = 1;
-        if( Endianness::which() == Endianness::Little ) {
-            i = end-1;
-            end = inc = -1;
-        }
-
-        unsigned char const *bytes = static_cast<unsigned char const *>(object);
-        ReusableStringStream rss;
-        rss << "0x" << std::setfill('0') << std::hex;
-        for( ; i != end; i += inc )
-             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
-       return rss.str();
-    }
-}
-
-template<typename T>
-std::string fpToString( T value, int precision ) {
-    if (Catch::isnan(value)) {
-        return "nan";
-    }
-
-    ReusableStringStream rss;
-    rss << std::setprecision( precision )
-        << std::fixed
-        << value;
-    std::string d = rss.str();
-    std::size_t i = d.find_last_not_of( '0' );
-    if( i != std::string::npos && i != d.size()-1 ) {
-        if( d[i] == '.' )
-            i++;
-        d = d.substr( 0, i+1 );
-    }
-    return d;
-}
-
-//// ======================================================= ////
-//
-//   Out-of-line defs for full specialization of StringMaker
-//
-//// ======================================================= ////
-
-std::string StringMaker<std::string>::convert(const std::string& str) {
-    if (!getCurrentContext().getConfig()->showInvisibles()) {
-        return '"' + str + '"';
-    }
-
-    std::string s("\"");
-    for (char c : str) {
-        switch (c) {
-        case '\n':
-            s.append("\\n");
-            break;
-        case '\t':
-            s.append("\\t");
-            break;
-        default:
-            s.push_back(c);
-            break;
-        }
-    }
-    s.append("\"");
-    return s;
-}
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::string_view>::convert(std::string_view str) {
-    return ::Catch::Detail::stringify(std::string{ str });
-}
-#endif
-
-std::string StringMaker<char const*>::convert(char const* str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<char*>::convert(char* str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-
-#ifdef CATCH_CONFIG_WCHAR
-std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
-    std::string s;
-    s.reserve(wstr.size());
-    for (auto c : wstr) {
-        s += (c <= 0xff) ? static_cast<char>(c) : '?';
-    }
-    return ::Catch::Detail::stringify(s);
-}
-
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
-    return StringMaker<std::wstring>::convert(std::wstring(str));
-}
-# endif
-
-std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-#endif
-
-#if defined(CATCH_CONFIG_CPP17_BYTE)
-#include <cstddef>
-std::string StringMaker<std::byte>::convert(std::byte value) {
-    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
-}
-#endif // defined(CATCH_CONFIG_CPP17_BYTE)
-
-std::string StringMaker<int>::convert(int value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long>::convert(long value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long long>::convert(long long value) {
-    ReusableStringStream rss;
-    rss << value;
-    if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
-    }
-    return rss.str();
-}
-
-std::string StringMaker<unsigned int>::convert(unsigned int value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long>::convert(unsigned long value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
-    ReusableStringStream rss;
-    rss << value;
-    if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
-    }
-    return rss.str();
-}
-
-std::string StringMaker<bool>::convert(bool b) {
-    return b ? "true" : "false";
-}
-
-std::string StringMaker<signed char>::convert(signed char value) {
-    if (value == '\r') {
-        return "'\\r'";
-    } else if (value == '\f') {
-        return "'\\f'";
-    } else if (value == '\n') {
-        return "'\\n'";
-    } else if (value == '\t') {
-        return "'\\t'";
-    } else if ('\0' <= value && value < ' ') {
-        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
-    } else {
-        char chstr[] = "' '";
-        chstr[1] = value;
-        return chstr;
-    }
-}
-std::string StringMaker<char>::convert(char c) {
-    return ::Catch::Detail::stringify(static_cast<signed char>(c));
-}
-std::string StringMaker<unsigned char>::convert(unsigned char c) {
-    return ::Catch::Detail::stringify(static_cast<char>(c));
-}
-
-std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
-    return "nullptr";
-}
-
-int StringMaker<float>::precision = 5;
-
-std::string StringMaker<float>::convert(float value) {
-    return fpToString(value, precision) + 'f';
-}
-
-int StringMaker<double>::precision = 10;
-
-std::string StringMaker<double>::convert(double value) {
-    return fpToString(value, precision);
-}
-
-std::string ratio_string<std::atto>::symbol() { return "a"; }
-std::string ratio_string<std::femto>::symbol() { return "f"; }
-std::string ratio_string<std::pico>::symbol() { return "p"; }
-std::string ratio_string<std::nano>::symbol() { return "n"; }
-std::string ratio_string<std::micro>::symbol() { return "u"; }
-std::string ratio_string<std::milli>::symbol() { return "m"; }
-
-} // end namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-
-// end catch_tostring.cpp
-// start catch_totals.cpp
-
-namespace Catch {
-
-    Counts Counts::operator - ( Counts const& other ) const {
-        Counts diff;
-        diff.passed = passed - other.passed;
-        diff.failed = failed - other.failed;
-        diff.failedButOk = failedButOk - other.failedButOk;
-        return diff;
-    }
-
-    Counts& Counts::operator += ( Counts const& other ) {
-        passed += other.passed;
-        failed += other.failed;
-        failedButOk += other.failedButOk;
-        return *this;
-    }
-
-    std::size_t Counts::total() const {
-        return passed + failed + failedButOk;
-    }
-    bool Counts::allPassed() const {
-        return failed == 0 && failedButOk == 0;
-    }
-    bool Counts::allOk() const {
-        return failed == 0;
-    }
-
-    Totals Totals::operator - ( Totals const& other ) const {
-        Totals diff;
-        diff.assertions = assertions - other.assertions;
-        diff.testCases = testCases - other.testCases;
-        return diff;
-    }
-
-    Totals& Totals::operator += ( Totals const& other ) {
-        assertions += other.assertions;
-        testCases += other.testCases;
-        return *this;
-    }
-
-    Totals Totals::delta( Totals const& prevTotals ) const {
-        Totals diff = *this - prevTotals;
-        if( diff.assertions.failed > 0 )
-            ++diff.testCases.failed;
-        else if( diff.assertions.failedButOk > 0 )
-            ++diff.testCases.failedButOk;
-        else
-            ++diff.testCases.passed;
-        return diff;
-    }
-
-}
-// end catch_totals.cpp
-// start catch_uncaught_exceptions.cpp
-
-#include <exception>
-
-namespace Catch {
-    bool uncaught_exceptions() {
-#if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-        return std::uncaught_exceptions() > 0;
-#else
-        return std::uncaught_exception();
-#endif
-  }
-} // end namespace Catch
-// end catch_uncaught_exceptions.cpp
-// start catch_version.cpp
-
-#include <ostream>
-
-namespace Catch {
-
-    Version::Version
-        (   unsigned int _majorVersion,
-            unsigned int _minorVersion,
-            unsigned int _patchNumber,
-            char const * const _branchName,
-            unsigned int _buildNumber )
-    :   majorVersion( _majorVersion ),
-        minorVersion( _minorVersion ),
-        patchNumber( _patchNumber ),
-        branchName( _branchName ),
-        buildNumber( _buildNumber )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, Version const& version ) {
-        os  << version.majorVersion << '.'
-            << version.minorVersion << '.'
-            << version.patchNumber;
-        // branchName is never null -> 0th char is \0 if it is empty
-        if (version.branchName[0]) {
-            os << '-' << version.branchName
-               << '.' << version.buildNumber;
-        }
-        return os;
-    }
-
-    Version const& libraryVersion() {
-        static Version version( 2, 11, 3, "", 0 );
-        return version;
-    }
-
-}
-// end catch_version.cpp
-// start catch_wildcard_pattern.cpp
-
-namespace Catch {
-
-    WildcardPattern::WildcardPattern( std::string const& pattern,
-                                      CaseSensitive::Choice caseSensitivity )
-    :   m_caseSensitivity( caseSensitivity ),
-        m_pattern( normaliseString( pattern ) )
-    {
-        if( startsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 1 );
-            m_wildcard = WildcardAtStart;
-        }
-        if( endsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
-            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
-        }
-    }
-
-    bool WildcardPattern::matches( std::string const& str ) const {
-        switch( m_wildcard ) {
-            case NoWildcard:
-                return m_pattern == normaliseString( str );
-            case WildcardAtStart:
-                return endsWith( normaliseString( str ), m_pattern );
-            case WildcardAtEnd:
-                return startsWith( normaliseString( str ), m_pattern );
-            case WildcardAtBothEnds:
-                return contains( normaliseString( str ), m_pattern );
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown enum" );
-        }
-    }
-
-    std::string WildcardPattern::normaliseString( std::string const& str ) const {
-        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
-    }
-}
-// end catch_wildcard_pattern.cpp
-// start catch_xmlwriter.cpp
-
-#include <iomanip>
-#include <type_traits>
-
-namespace Catch {
-
-namespace {
-
-    size_t trailingBytes(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return 2;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return 3;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return 4;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    uint32_t headerValue(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return c & 0x1F;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return c & 0x0F;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return c & 0x07;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    void hexEscapeChar(std::ostream& os, unsigned char c) {
-        std::ios_base::fmtflags f(os.flags());
-        os << "\\x"
-            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
-            << static_cast<int>(c);
-        os.flags(f);
-    }
-
-    bool shouldNewline(XmlFormatting fmt) {
-        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Newline));
-    }
-
-    bool shouldIndent(XmlFormatting fmt) {
-        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Indent));
-    }
-
-} // anonymous namespace
-
-    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
-        return static_cast<XmlFormatting>(
-            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) |
-            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
-        );
-    }
-
-    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
-        return static_cast<XmlFormatting>(
-            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) &
-            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
-        );
-    }
-
-    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
-    :   m_str( str ),
-        m_forWhat( forWhat )
-    {}
-
-    void XmlEncode::encodeTo( std::ostream& os ) const {
-        // Apostrophe escaping not necessary if we always use " to write attributes
-        // (see: http://www.w3.org/TR/xml/#syntax)
-
-        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
-            unsigned char c = m_str[idx];
-            switch (c) {
-            case '<':   os << "&lt;"; break;
-            case '&':   os << "&amp;"; break;
-
-            case '>':
-                // See: http://www.w3.org/TR/xml/#syntax
-                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
-                    os << "&gt;";
-                else
-                    os << c;
-                break;
-
-            case '\"':
-                if (m_forWhat == ForAttributes)
-                    os << "&quot;";
-                else
-                    os << c;
-                break;
-
-            default:
-                // Check for control characters and invalid utf-8
-
-                // Escape control characters in standard ascii
-                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
-                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // Plain ASCII: Write it to stream
-                if (c < 0x7F) {
-                    os << c;
-                    break;
-                }
-
-                // UTF-8 territory
-                // Check if the encoding is valid and if it is not, hex escape bytes.
-                // Important: We do not check the exact decoded values for validity, only the encoding format
-                // First check that this bytes is a valid lead byte:
-                // This means that it is not encoded as 1111 1XXX
-                // Or as 10XX XXXX
-                if (c <  0xC0 ||
-                    c >= 0xF8) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                auto encBytes = trailingBytes(c);
-                // Are there enough bytes left to avoid accessing out-of-bounds memory?
-                if (idx + encBytes - 1 >= m_str.size()) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-                // The header is valid, check data
-                // The next encBytes bytes must together be a valid utf-8
-                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
-                bool valid = true;
-                uint32_t value = headerValue(c);
-                for (std::size_t n = 1; n < encBytes; ++n) {
-                    unsigned char nc = m_str[idx + n];
-                    valid &= ((nc & 0xC0) == 0x80);
-                    value = (value << 6) | (nc & 0x3F);
-                }
-
-                if (
-                    // Wrong bit pattern of following bytes
-                    (!valid) ||
-                    // Overlong encodings
-                    (value < 0x80) ||
-                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
-                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
-                    // Encoded value out of range
-                    (value >= 0x110000)
-                    ) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // If we got here, this is in fact a valid(ish) utf-8 sequence
-                for (std::size_t n = 0; n < encBytes; ++n) {
-                    os << m_str[idx + n];
-                }
-                idx += encBytes - 1;
-                break;
-            }
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
-        xmlEncode.encodeTo( os );
-        return os;
-    }
-
-    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
-    :   m_writer( writer ),
-        m_fmt(fmt)
-    {}
-
-    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
-    :   m_writer( other.m_writer ),
-        m_fmt(other.m_fmt)
-    {
-        other.m_writer = nullptr;
-        other.m_fmt = XmlFormatting::None;
-    }
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
-        if ( m_writer ) {
-            m_writer->endElement();
-        }
-        m_writer = other.m_writer;
-        other.m_writer = nullptr;
-        m_fmt = other.m_fmt;
-        other.m_fmt = XmlFormatting::None;
-        return *this;
-    }
-
-    XmlWriter::ScopedElement::~ScopedElement() {
-        if (m_writer) {
-            m_writer->endElement(m_fmt);
-        }
-    }
-
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, XmlFormatting fmt ) {
-        m_writer->writeText( text, fmt );
-        return *this;
-    }
-
-    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
-    {
-        writeDeclaration();
-    }
-
-    XmlWriter::~XmlWriter() {
-        while (!m_tags.empty()) {
-            endElement();
-        }
-        newlineIfNecessary();
-    }
-
-    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
-        ensureTagClosed();
-        newlineIfNecessary();
-        if (shouldIndent(fmt)) {
-            m_os << m_indent;
-            m_indent += "  ";
-        }
-        m_os << '<' << name;
-        m_tags.push_back( name );
-        m_tagIsOpen = true;
-        applyFormatting(fmt);
-        return *this;
-    }
-
-    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
-        ScopedElement scoped( this, fmt );
-        startElement( name, fmt );
-        return scoped;
-    }
-
-    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
-        m_indent = m_indent.substr(0, m_indent.size() - 2);
-
-        if( m_tagIsOpen ) {
-            m_os << "/>";
-            m_tagIsOpen = false;
-        } else {
-            newlineIfNecessary();
-            if (shouldIndent(fmt)) {
-                m_os << m_indent;
-            }
-            m_os << "</" << m_tags.back() << ">";
-        }
-        m_os << std::flush;
-        applyFormatting(fmt);
-        m_tags.pop_back();
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
-        if( !name.empty() && !attribute.empty() )
-            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
-        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
-        if( !text.empty() ){
-            bool tagWasOpen = m_tagIsOpen;
-            ensureTagClosed();
-            if (tagWasOpen && shouldIndent(fmt)) {
-                m_os << m_indent;
-            }
-            m_os << XmlEncode( text );
-            applyFormatting(fmt);
-        }
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
-        ensureTagClosed();
-        if (shouldIndent(fmt)) {
-            m_os << m_indent;
-        }
-        m_os << "<!--" << text << "-->";
-        applyFormatting(fmt);
-        return *this;
-    }
-
-    void XmlWriter::writeStylesheetRef( std::string const& url ) {
-        m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
-    }
-
-    XmlWriter& XmlWriter::writeBlankLine() {
-        ensureTagClosed();
-        m_os << '\n';
-        return *this;
-    }
-
-    void XmlWriter::ensureTagClosed() {
-        if( m_tagIsOpen ) {
-            m_os << '>' << std::flush;
-            newlineIfNecessary();
-            m_tagIsOpen = false;
-        }
-    }
-
-    void XmlWriter::applyFormatting(XmlFormatting fmt) {
-        m_needsNewline = shouldNewline(fmt);
-    }
-
-    void XmlWriter::writeDeclaration() {
-        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-    }
-
-    void XmlWriter::newlineIfNecessary() {
-        if( m_needsNewline ) {
-            m_os << std::endl;
-            m_needsNewline = false;
-        }
-    }
-}
-// end catch_xmlwriter.cpp
-// start catch_reporter_bases.cpp
-
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <cassert>
-#include <memory>
-
-namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result) {
-        result.getExpandedExpression();
-    }
-
-    // Because formatting using c++ streams is stateful, drop down to C is required
-    // Alternatively we could use stringstream, but its performance is... not good.
-    std::string getFormattedDuration( double duration ) {
-        // Max exponent + 1 is required to represent the whole part
-        // + 1 for decimal point
-        // + 3 for the 3 decimal places
-        // + 1 for null terminator
-        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
-        char buffer[maxDoubleSize];
-
-        // Save previous errno, to prevent sprintf from overwriting it
-        ErrnoGuard guard;
-#ifdef _MSC_VER
-        sprintf_s(buffer, "%.3f", duration);
-#else
-        std::sprintf(buffer, "%.3f", duration);
-#endif
-        return std::string(buffer);
-    }
-
-    std::string serializeFilters( std::vector<std::string> const& container ) {
-        ReusableStringStream oss;
-        bool first = true;
-        for (auto&& filter : container)
-        {
-            if (!first)
-                oss << ' ';
-            else
-                first = false;
-
-            oss << filter;
-        }
-        return oss.str();
-    }
-
-    TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
-        :StreamingReporterBase(_config) {}
-
-    std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
-        return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
-    }
-
-    void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
-
-    bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
-        return false;
-    }
-
-} // end namespace Catch
-// end catch_reporter_bases.cpp
-// start catch_reporter_compact.cpp
-
-namespace {
-
-#ifdef CATCH_PLATFORM_MAC
-    const char* failedString() { return "FAILED"; }
-    const char* passedString() { return "PASSED"; }
-#else
-    const char* failedString() { return "failed"; }
-    const char* passedString() { return "passed"; }
-#endif
-
-    // Colour::LightGrey
-    Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
-
-    std::string bothOrAll( std::size_t count ) {
-        return count == 1 ? std::string() :
-               count == 2 ? "both " : "all " ;
-    }
-
-} // anon namespace
-
-namespace Catch {
-namespace {
-// Colour, message variants:
-// - white: No tests ran.
-// -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
-// - white: Passed [both/all] N test cases (no assertions).
-// -   red: Failed N tests cases, failed M assertions.
-// - green: Passed [both/all] N tests cases with M assertions.
-void printTotals(std::ostream& out, const Totals& totals) {
-    if (totals.testCases.total() == 0) {
-        out << "No tests ran.";
-    } else if (totals.testCases.failed == totals.testCases.total()) {
-        Colour colour(Colour::ResultError);
-        const std::string qualify_assertions_failed =
-            totals.assertions.failed == totals.assertions.total() ?
-            bothOrAll(totals.assertions.failed) : std::string();
-        out <<
-            "Failed " << bothOrAll(totals.testCases.failed)
-            << pluralise(totals.testCases.failed, "test case") << ", "
-            "failed " << qualify_assertions_failed <<
-            pluralise(totals.assertions.failed, "assertion") << '.';
-    } else if (totals.assertions.total() == 0) {
-        out <<
-            "Passed " << bothOrAll(totals.testCases.total())
-            << pluralise(totals.testCases.total(), "test case")
-            << " (no assertions).";
-    } else if (totals.assertions.failed) {
-        Colour colour(Colour::ResultError);
-        out <<
-            "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
-            "failed " << pluralise(totals.assertions.failed, "assertion") << '.';
-    } else {
-        Colour colour(Colour::ResultSuccess);
-        out <<
-            "Passed " << bothOrAll(totals.testCases.passed)
-            << pluralise(totals.testCases.passed, "test case") <<
-            " with " << pluralise(totals.assertions.passed, "assertion") << '.';
-    }
-}
-
-// Implementation of CompactReporter formatting
-class AssertionPrinter {
-public:
-    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
-    AssertionPrinter(AssertionPrinter const&) = delete;
-    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
-        : stream(_stream)
-        , result(_stats.assertionResult)
-        , messages(_stats.infoMessages)
-        , itMessage(_stats.infoMessages.begin())
-        , printInfoMessages(_printInfoMessages) {}
-
-    void print() {
-        printSourceInfo();
-
-        itMessage = messages.begin();
-
-        switch (result.getResultType()) {
-        case ResultWas::Ok:
-            printResultType(Colour::ResultSuccess, passedString());
-            printOriginalExpression();
-            printReconstructedExpression();
-            if (!result.hasExpression())
-                printRemainingMessages(Colour::None);
-            else
-                printRemainingMessages();
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk())
-                printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
-            else
-                printResultType(Colour::Error, failedString());
-            printOriginalExpression();
-            printReconstructedExpression();
-            printRemainingMessages();
-            break;
-        case ResultWas::ThrewException:
-            printResultType(Colour::Error, failedString());
-            printIssue("unexpected exception with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::FatalErrorCondition:
-            printResultType(Colour::Error, failedString());
-            printIssue("fatal error condition with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::DidntThrowException:
-            printResultType(Colour::Error, failedString());
-            printIssue("expected exception, got none");
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::Info:
-            printResultType(Colour::None, "info");
-            printMessage();
-            printRemainingMessages();
-            break;
-        case ResultWas::Warning:
-            printResultType(Colour::None, "warning");
-            printMessage();
-            printRemainingMessages();
-            break;
-        case ResultWas::ExplicitFailure:
-            printResultType(Colour::Error, failedString());
-            printIssue("explicitly");
-            printRemainingMessages(Colour::None);
-            break;
-            // These cases are here to prevent compiler warnings
-        case ResultWas::Unknown:
-        case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            printResultType(Colour::Error, "** internal error **");
-            break;
-        }
-    }
-
-private:
-    void printSourceInfo() const {
-        Colour colourGuard(Colour::FileName);
-        stream << result.getSourceInfo() << ':';
-    }
-
-    void printResultType(Colour::Code colour, std::string const& passOrFail) const {
-        if (!passOrFail.empty()) {
-            {
-                Colour colourGuard(colour);
-                stream << ' ' << passOrFail;
-            }
-            stream << ':';
-        }
-    }
-
-    void printIssue(std::string const& issue) const {
-        stream << ' ' << issue;
-    }
-
-    void printExpressionWas() {
-        if (result.hasExpression()) {
-            stream << ';';
-            {
-                Colour colour(dimColour());
-                stream << " expression was:";
-            }
-            printOriginalExpression();
-        }
-    }
-
-    void printOriginalExpression() const {
-        if (result.hasExpression()) {
-            stream << ' ' << result.getExpression();
-        }
-    }
-
-    void printReconstructedExpression() const {
-        if (result.hasExpandedExpression()) {
-            {
-                Colour colour(dimColour());
-                stream << " for: ";
-            }
-            stream << result.getExpandedExpression();
-        }
-    }
-
-    void printMessage() {
-        if (itMessage != messages.end()) {
-            stream << " '" << itMessage->message << '\'';
-            ++itMessage;
-        }
-    }
-
-    void printRemainingMessages(Colour::Code colour = dimColour()) {
-        if (itMessage == messages.end())
-            return;
-
-        const auto itEnd = messages.cend();
-        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
-
-        {
-            Colour colourGuard(colour);
-            stream << " with " << pluralise(N, "message") << ':';
-        }
-
-        while (itMessage != itEnd) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || itMessage->type != ResultWas::Info) {
-                printMessage();
-                if (itMessage != itEnd) {
-                    Colour colourGuard(dimColour());
-                    stream << " and";
-                }
-                continue;
-            }
-            ++itMessage;
-        }
-    }
-
-private:
-    std::ostream& stream;
-    AssertionResult const& result;
-    std::vector<MessageInfo> messages;
-    std::vector<MessageInfo>::const_iterator itMessage;
-    bool printInfoMessages;
-};
-
-} // anon namespace
-
-        std::string CompactReporter::getDescription() {
-            return "Reports test results on a single line, suitable for IDEs";
-        }
-
-        ReporterPreferences CompactReporter::getPreferences() const {
-            return m_reporterPrefs;
-        }
-
-        void CompactReporter::noMatchingTestCases( std::string const& spec ) {
-            stream << "No test cases matched '" << spec << '\'' << std::endl;
-        }
-
-        void CompactReporter::assertionStarting( AssertionInfo const& ) {}
-
-        bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
-            AssertionResult const& result = _assertionStats.assertionResult;
-
-            bool printInfoMessages = true;
-
-            // Drop out if result was successful and we're not printing those
-            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
-                if( result.getResultType() != ResultWas::Warning )
-                    return false;
-                printInfoMessages = false;
-            }
-
-            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
-            printer.print();
-
-            stream << std::endl;
-            return true;
-        }
-
-        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
-            if (m_config->showDurations() == ShowDurations::Always) {
-                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-            }
-        }
-
-        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
-            printTotals( stream, _testRunStats.totals );
-            stream << '\n' << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-        CompactReporter::~CompactReporter() {}
-
-    CATCH_REGISTER_REPORTER( "compact", CompactReporter )
-
-} // end namespace Catch
-// end catch_reporter_compact.cpp
-// start catch_reporter_console.cpp
-
-#include <cfloat>
-#include <cstdio>
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
- // Note that 4062 (not all labels are handled and default is missing) is enabled
-#endif
-
-#if defined(__clang__)
-#  pragma clang diagnostic push
-// For simplicity, benchmarking-only helpers are always enabled
-#  pragma clang diagnostic ignored "-Wunused-function"
-#endif
-
-namespace Catch {
-
-namespace {
-
-// Formatter impl for ConsoleReporter
-class ConsoleAssertionPrinter {
-public:
-    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
-        : stream(_stream),
-        stats(_stats),
-        result(_stats.assertionResult),
-        colour(Colour::None),
-        message(result.getMessage()),
-        messages(_stats.infoMessages),
-        printInfoMessages(_printInfoMessages) {
-        switch (result.getResultType()) {
-        case ResultWas::Ok:
-            colour = Colour::Success;
-            passOrFail = "PASSED";
-            //if( result.hasMessage() )
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "with messages";
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk()) {
-                colour = Colour::Success;
-                passOrFail = "FAILED - but was ok";
-            } else {
-                colour = Colour::Error;
-                passOrFail = "FAILED";
-            }
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "with messages";
-            break;
-        case ResultWas::ThrewException:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "due to unexpected exception with ";
-            if (_stats.infoMessages.size() == 1)
-                messageLabel += "message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel += "messages";
-            break;
-        case ResultWas::FatalErrorCondition:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "due to a fatal error condition";
-            break;
-        case ResultWas::DidntThrowException:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "because no exception was thrown where one was expected";
-            break;
-        case ResultWas::Info:
-            messageLabel = "info";
-            break;
-        case ResultWas::Warning:
-            messageLabel = "warning";
-            break;
-        case ResultWas::ExplicitFailure:
-            passOrFail = "FAILED";
-            colour = Colour::Error;
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "explicitly with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "explicitly with messages";
-            break;
-            // These cases are here to prevent compiler warnings
-        case ResultWas::Unknown:
-        case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            passOrFail = "** internal error **";
-            colour = Colour::Error;
-            break;
-        }
-    }
-
-    void print() const {
-        printSourceInfo();
-        if (stats.totals.assertions.total() > 0) {
-            printResultType();
-            printOriginalExpression();
-            printReconstructedExpression();
-        } else {
-            stream << '\n';
-        }
-        printMessage();
-    }
-
-private:
-    void printResultType() const {
-        if (!passOrFail.empty()) {
-            Colour colourGuard(colour);
-            stream << passOrFail << ":\n";
-        }
-    }
-    void printOriginalExpression() const {
-        if (result.hasExpression()) {
-            Colour colourGuard(Colour::OriginalExpression);
-            stream << "  ";
-            stream << result.getExpressionInMacro();
-            stream << '\n';
-        }
-    }
-    void printReconstructedExpression() const {
-        if (result.hasExpandedExpression()) {
-            stream << "with expansion:\n";
-            Colour colourGuard(Colour::ReconstructedExpression);
-            stream << Column(result.getExpandedExpression()).indent(2) << '\n';
-        }
-    }
-    void printMessage() const {
-        if (!messageLabel.empty())
-            stream << messageLabel << ':' << '\n';
-        for (auto const& msg : messages) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || msg.type != ResultWas::Info)
-                stream << Column(msg.message).indent(2) << '\n';
-        }
-    }
-    void printSourceInfo() const {
-        Colour colourGuard(Colour::FileName);
-        stream << result.getSourceInfo() << ": ";
-    }
-
-    std::ostream& stream;
-    AssertionStats const& stats;
-    AssertionResult const& result;
-    Colour::Code colour;
-    std::string passOrFail;
-    std::string messageLabel;
-    std::string message;
-    std::vector<MessageInfo> messages;
-    bool printInfoMessages;
-};
-
-std::size_t makeRatio(std::size_t number, std::size_t total) {
-    std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
-    return (ratio == 0 && number > 0) ? 1 : ratio;
-}
-
-std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
-    if (i > j && i > k)
-        return i;
-    else if (j > k)
-        return j;
-    else
-        return k;
-}
-
-struct ColumnInfo {
-    enum Justification { Left, Right };
-    std::string name;
-    int width;
-    Justification justification;
-};
-struct ColumnBreak {};
-struct RowBreak {};
-
-class Duration {
-    enum class Unit {
-        Auto,
-        Nanoseconds,
-        Microseconds,
-        Milliseconds,
-        Seconds,
-        Minutes
-    };
-    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
-    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
-    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
-    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
-
-    double m_inNanoseconds;
-    Unit m_units;
-
-public:
-    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
-        : m_inNanoseconds(inNanoseconds),
-        m_units(units) {
-        if (m_units == Unit::Auto) {
-            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
-                m_units = Unit::Nanoseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
-                m_units = Unit::Microseconds;
-            else if (m_inNanoseconds < s_nanosecondsInASecond)
-                m_units = Unit::Milliseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMinute)
-                m_units = Unit::Seconds;
-            else
-                m_units = Unit::Minutes;
-        }
-
-    }
-
-    auto value() const -> double {
-        switch (m_units) {
-        case Unit::Microseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
-        case Unit::Milliseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
-        case Unit::Seconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
-        case Unit::Minutes:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
-        default:
-            return m_inNanoseconds;
-        }
-    }
-    auto unitsAsString() const -> std::string {
-        switch (m_units) {
-        case Unit::Nanoseconds:
-            return "ns";
-        case Unit::Microseconds:
-            return "us";
-        case Unit::Milliseconds:
-            return "ms";
-        case Unit::Seconds:
-            return "s";
-        case Unit::Minutes:
-            return "m";
-        default:
-            return "** internal error **";
-        }
-
-    }
-    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
-        return os << duration.value() << ' ' << duration.unitsAsString();
-    }
-};
-} // end anon namespace
-
-class TablePrinter {
-    std::ostream& m_os;
-    std::vector<ColumnInfo> m_columnInfos;
-    std::ostringstream m_oss;
-    int m_currentColumn = -1;
-    bool m_isOpen = false;
-
-public:
-    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
-    :   m_os( os ),
-        m_columnInfos( std::move( columnInfos ) ) {}
-
-    auto columnInfos() const -> std::vector<ColumnInfo> const& {
-        return m_columnInfos;
-    }
-
-    void open() {
-        if (!m_isOpen) {
-            m_isOpen = true;
-            *this << RowBreak();
-
-			Columns headerCols;
-			Spacer spacer(2);
-			for (auto const& info : m_columnInfos) {
-				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
-				headerCols += spacer;
-			}
-			m_os << headerCols << '\n';
-
-            m_os << Catch::getLineOfChars<'-'>() << '\n';
-        }
-    }
-    void close() {
-        if (m_isOpen) {
-            *this << RowBreak();
-            m_os << std::endl;
-            m_isOpen = false;
-        }
-    }
-
-    template<typename T>
-    friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
-        tp.m_oss << value;
-        return tp;
-    }
-
-    friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
-        auto colStr = tp.m_oss.str();
-        const auto strSize = colStr.size();
-        tp.m_oss.str("");
-        tp.open();
-        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
-            tp.m_currentColumn = -1;
-            tp.m_os << '\n';
-        }
-        tp.m_currentColumn++;
-
-        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
-        auto padding = (strSize + 1 < static_cast<std::size_t>(colInfo.width))
-            ? std::string(colInfo.width - (strSize + 1), ' ')
-            : std::string();
-        if (colInfo.justification == ColumnInfo::Left)
-            tp.m_os << colStr << padding << ' ';
-        else
-            tp.m_os << padding << colStr << ' ';
-        return tp;
-    }
-
-    friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
-        if (tp.m_currentColumn > 0) {
-            tp.m_os << '\n';
-            tp.m_currentColumn = -1;
-        }
-        return tp;
-    }
-};
-
-ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
-    : StreamingReporterBase(config),
-    m_tablePrinter(new TablePrinter(config.stream(),
-        [&config]() -> std::vector<ColumnInfo> {
-        if (config.fullConfig()->benchmarkNoAnalysis())
-        {
-            return{
-                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
-                { "     samples", 14, ColumnInfo::Right },
-                { "  iterations", 14, ColumnInfo::Right },
-                { "        mean", 14, ColumnInfo::Right }
-            };
-        }
-        else
-        {
-            return{
-                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
-                { "samples      mean       std dev", 14, ColumnInfo::Right },
-                { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
-                { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
-            };
-        }
-    }())) {}
-ConsoleReporter::~ConsoleReporter() = default;
-
-std::string ConsoleReporter::getDescription() {
-    return "Reports test results as plain lines of text";
-}
-
-void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
-    stream << "No test cases matched '" << spec << '\'' << std::endl;
-}
-
-void ConsoleReporter::reportInvalidArguments(std::string const&arg){
-    stream << "Invalid Filter: " << arg << std::endl;
-}
-
-void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
-
-bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
-    AssertionResult const& result = _assertionStats.assertionResult;
-
-    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-    // Drop out if result was successful but we're not printing them.
-    if (!includeResults && result.getResultType() != ResultWas::Warning)
-        return false;
-
-    lazyPrint();
-
-    ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
-    printer.print();
-    stream << std::endl;
-    return true;
-}
-
-void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
-    m_tablePrinter->close();
-    m_headerPrinted = false;
-    StreamingReporterBase::sectionStarting(_sectionInfo);
-}
-void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
-    m_tablePrinter->close();
-    if (_sectionStats.missingAssertions) {
-        lazyPrint();
-        Colour colour(Colour::ResultError);
-        if (m_sectionStack.size() > 1)
-            stream << "\nNo assertions in section";
-        else
-            stream << "\nNo assertions in test case";
-        stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
-    }
-    if (m_config->showDurations() == ShowDurations::Always) {
-        stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-    }
-    if (m_headerPrinted) {
-        m_headerPrinted = false;
-    }
-    StreamingReporterBase::sectionEnded(_sectionStats);
-}
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-void ConsoleReporter::benchmarkPreparing(std::string const& name) {
-	lazyPrintWithoutClosingBenchmarkTable();
-
-	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
-
-	bool firstLine = true;
-	for (auto line : nameCol) {
-		if (!firstLine)
-			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
-		else
-			firstLine = false;
-
-		(*m_tablePrinter) << line << ColumnBreak();
-	}
-}
-
-void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
-    (*m_tablePrinter) << info.samples << ColumnBreak()
-        << info.iterations << ColumnBreak();
-    if (!m_config->benchmarkNoAnalysis())
-        (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
-}
-void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
-    if (m_config->benchmarkNoAnalysis())
-    {
-        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
-    }
-    else
-    {
-        (*m_tablePrinter) << ColumnBreak()
-            << Duration(stats.mean.point.count()) << ColumnBreak()
-            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
-            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
-            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
-            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
-            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
-    }
-}
-
-void ConsoleReporter::benchmarkFailed(std::string const& error) {
-	Colour colour(Colour::Red);
-    (*m_tablePrinter)
-        << "Benchmark failed (" << error << ')'
-        << ColumnBreak() << RowBreak();
-}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
-    m_tablePrinter->close();
-    StreamingReporterBase::testCaseEnded(_testCaseStats);
-    m_headerPrinted = false;
-}
-void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
-    if (currentGroupInfo.used) {
-        printSummaryDivider();
-        stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
-        printTotals(_testGroupStats.totals);
-        stream << '\n' << std::endl;
-    }
-    StreamingReporterBase::testGroupEnded(_testGroupStats);
-}
-void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
-    printTotalsDivider(_testRunStats.totals);
-    printTotals(_testRunStats.totals);
-    stream << std::endl;
-    StreamingReporterBase::testRunEnded(_testRunStats);
-}
-void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
-    StreamingReporterBase::testRunStarting(_testInfo);
-    printTestFilters();
-}
-
-void ConsoleReporter::lazyPrint() {
-
-    m_tablePrinter->close();
-    lazyPrintWithoutClosingBenchmarkTable();
-}
-
-void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
-
-    if (!currentTestRunInfo.used)
-        lazyPrintRunInfo();
-    if (!currentGroupInfo.used)
-        lazyPrintGroupInfo();
-
-    if (!m_headerPrinted) {
-        printTestCaseAndSectionHeader();
-        m_headerPrinted = true;
-    }
-}
-void ConsoleReporter::lazyPrintRunInfo() {
-    stream << '\n' << getLineOfChars<'~'>() << '\n';
-    Colour colour(Colour::SecondaryText);
-    stream << currentTestRunInfo->name
-        << " is a Catch v" << libraryVersion() << " host application.\n"
-        << "Run with -? for options\n\n";
-
-    if (m_config->rngSeed() != 0)
-        stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
-
-    currentTestRunInfo.used = true;
-}
-void ConsoleReporter::lazyPrintGroupInfo() {
-    if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
-        printClosedHeader("Group: " + currentGroupInfo->name);
-        currentGroupInfo.used = true;
-    }
-}
-void ConsoleReporter::printTestCaseAndSectionHeader() {
-    assert(!m_sectionStack.empty());
-    printOpenHeader(currentTestCaseInfo->name);
-
-    if (m_sectionStack.size() > 1) {
-        Colour colourGuard(Colour::Headers);
-
-        auto
-            it = m_sectionStack.begin() + 1, // Skip first section (test case)
-            itEnd = m_sectionStack.end();
-        for (; it != itEnd; ++it)
-            printHeaderString(it->name, 2);
-    }
-
-    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
-
-    stream << getLineOfChars<'-'>() << '\n';
-    Colour colourGuard(Colour::FileName);
-    stream << lineInfo << '\n';
-    stream << getLineOfChars<'.'>() << '\n' << std::endl;
-}
-
-void ConsoleReporter::printClosedHeader(std::string const& _name) {
-    printOpenHeader(_name);
-    stream << getLineOfChars<'.'>() << '\n';
-}
-void ConsoleReporter::printOpenHeader(std::string const& _name) {
-    stream << getLineOfChars<'-'>() << '\n';
-    {
-        Colour colourGuard(Colour::Headers);
-        printHeaderString(_name);
-    }
-}
-
-// if string has a : in first line will set indent to follow it on
-// subsequent lines
-void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
-    std::size_t i = _string.find(": ");
-    if (i != std::string::npos)
-        i += 2;
-    else
-        i = 0;
-    stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
-}
-
-struct SummaryColumn {
-
-    SummaryColumn( std::string _label, Colour::Code _colour )
-    :   label( std::move( _label ) ),
-        colour( _colour ) {}
-    SummaryColumn addRow( std::size_t count ) {
-        ReusableStringStream rss;
-        rss << count;
-        std::string row = rss.str();
-        for (auto& oldRow : rows) {
-            while (oldRow.size() < row.size())
-                oldRow = ' ' + oldRow;
-            while (oldRow.size() > row.size())
-                row = ' ' + row;
-        }
-        rows.push_back(row);
-        return *this;
-    }
-
-    std::string label;
-    Colour::Code colour;
-    std::vector<std::string> rows;
-
-};
-
-void ConsoleReporter::printTotals( Totals const& totals ) {
-    if (totals.testCases.total() == 0) {
-        stream << Colour(Colour::Warning) << "No tests ran\n";
-    } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
-        stream << Colour(Colour::ResultSuccess) << "All tests passed";
-        stream << " ("
-            << pluralise(totals.assertions.passed, "assertion") << " in "
-            << pluralise(totals.testCases.passed, "test case") << ')'
-            << '\n';
-    } else {
-
-        std::vector<SummaryColumn> columns;
-        columns.push_back(SummaryColumn("", Colour::None)
-                          .addRow(totals.testCases.total())
-                          .addRow(totals.assertions.total()));
-        columns.push_back(SummaryColumn("passed", Colour::Success)
-                          .addRow(totals.testCases.passed)
-                          .addRow(totals.assertions.passed));
-        columns.push_back(SummaryColumn("failed", Colour::ResultError)
-                          .addRow(totals.testCases.failed)
-                          .addRow(totals.assertions.failed));
-        columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
-                          .addRow(totals.testCases.failedButOk)
-                          .addRow(totals.assertions.failedButOk));
-
-        printSummaryRow("test cases", columns, 0);
-        printSummaryRow("assertions", columns, 1);
-    }
-}
-void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
-    for (auto col : cols) {
-        std::string value = col.rows[row];
-        if (col.label.empty()) {
-            stream << label << ": ";
-            if (value != "0")
-                stream << value;
-            else
-                stream << Colour(Colour::Warning) << "- none -";
-        } else if (value != "0") {
-            stream << Colour(Colour::LightGrey) << " | ";
-            stream << Colour(col.colour)
-                << value << ' ' << col.label;
-        }
-    }
-    stream << '\n';
-}
-
-void ConsoleReporter::printTotalsDivider(Totals const& totals) {
-    if (totals.testCases.total() > 0) {
-        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
-        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
-        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
-        while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio)++;
-        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio)--;
-
-        stream << Colour(Colour::Error) << std::string(failedRatio, '=');
-        stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
-        if (totals.testCases.allPassed())
-            stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
-        else
-            stream << Colour(Colour::Success) << std::string(passedRatio, '=');
-    } else {
-        stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
-    }
-    stream << '\n';
-}
-void ConsoleReporter::printSummaryDivider() {
-    stream << getLineOfChars<'-'>() << '\n';
-}
-
-void ConsoleReporter::printTestFilters() {
-    if (m_config->testSpec().hasFilters()) {
-        Colour guard(Colour::BrightYellow);
-        stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
-    }
-}
-
-CATCH_REGISTER_REPORTER("console", ConsoleReporter)
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-#if defined(__clang__)
-#  pragma clang diagnostic pop
-#endif
-// end catch_reporter_console.cpp
-// start catch_reporter_junit.cpp
-
-#include <cassert>
-#include <sstream>
-#include <ctime>
-#include <algorithm>
-
-namespace Catch {
-
-    namespace {
-        std::string getCurrentTimestamp() {
-            // Beware, this is not reentrant because of backward compatibility issues
-            // Also, UTC only, again because of backward compatibility (%z is C++11)
-            time_t rawtime;
-            std::time(&rawtime);
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &rawtime);
-#else
-            std::tm* timeInfo;
-            timeInfo = std::gmtime(&rawtime);
-#endif
-
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
-
-        std::string fileNameTag(const std::vector<std::string> &tags) {
-            auto it = std::find_if(begin(tags),
-                                   end(tags),
-                                   [] (std::string const& tag) {return tag.front() == '#'; });
-            if (it != tags.end())
-                return it->substr(1);
-            return std::string();
-        }
-    } // anonymous namespace
-
-    JunitReporter::JunitReporter( ReporterConfig const& _config )
-        :   CumulativeReporterBase( _config ),
-            xml( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-            m_reporterPrefs.shouldReportAllAssertions = true;
-        }
-
-    JunitReporter::~JunitReporter() {}
-
-    std::string JunitReporter::getDescription() {
-        return "Reports test results in an XML format that looks like Ant's junitreport target";
-    }
-
-    void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
-
-    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
-        CumulativeReporterBase::testRunStarting( runInfo );
-        xml.startElement( "testsuites" );
-    }
-
-    void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        suiteTimer.start();
-        stdOutForSuite.clear();
-        stdErrForSuite.clear();
-        unexpectedExceptions = 0;
-        CumulativeReporterBase::testGroupStarting( groupInfo );
-    }
-
-    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
-        m_okToFail = testCaseInfo.okToFail();
-    }
-
-    bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
-            unexpectedExceptions++;
-        return CumulativeReporterBase::assertionEnded( assertionStats );
-    }
-
-    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        stdOutForSuite += testCaseStats.stdOut;
-        stdErrForSuite += testCaseStats.stdErr;
-        CumulativeReporterBase::testCaseEnded( testCaseStats );
-    }
-
-    void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        double suiteTime = suiteTimer.getElapsedSeconds();
-        CumulativeReporterBase::testGroupEnded( testGroupStats );
-        writeGroup( *m_testGroups.back(), suiteTime );
-    }
-
-    void JunitReporter::testRunEndedCumulative() {
-        xml.endElement();
-    }
-
-    void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
-        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
-
-        TestGroupStats const& stats = groupNode.value;
-        xml.writeAttribute( "name", stats.groupInfo.name );
-        xml.writeAttribute( "errors", unexpectedExceptions );
-        xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
-        xml.writeAttribute( "tests", stats.totals.assertions.total() );
-        xml.writeAttribute( "hostname", "tbd" ); // !TBD
-        if( m_config->showDurations() == ShowDurations::Never )
-            xml.writeAttribute( "time", "" );
-        else
-            xml.writeAttribute( "time", suiteTime );
-        xml.writeAttribute( "timestamp", getCurrentTimestamp() );
-
-        // Write properties if there are any
-        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
-            auto properties = xml.scopedElement("properties");
-            if (m_config->hasTestFilters()) {
-                xml.scopedElement("property")
-                    .writeAttribute("name", "filters")
-                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
-            }
-            if (m_config->rngSeed() != 0) {
-                xml.scopedElement("property")
-                    .writeAttribute("name", "random-seed")
-                    .writeAttribute("value", m_config->rngSeed());
-            }
-        }
-
-        // Write test cases
-        for( auto const& child : groupNode.children )
-            writeTestCase( *child );
-
-        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
-        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
-    }
-
-    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
-        TestCaseStats const& stats = testCaseNode.value;
-
-        // All test cases have exactly one section - which represents the
-        // test case itself. That section may have 0-n nested sections
-        assert( testCaseNode.children.size() == 1 );
-        SectionNode const& rootSection = *testCaseNode.children.front();
-
-        std::string className = stats.testInfo.className;
-
-        if( className.empty() ) {
-            className = fileNameTag(stats.testInfo.tags);
-            if ( className.empty() )
-                className = "global";
-        }
-
-        if ( !m_config->name().empty() )
-            className = m_config->name() + "." + className;
-
-        writeSection( className, "", rootSection );
-    }
-
-    void JunitReporter::writeSection(  std::string const& className,
-                        std::string const& rootName,
-                        SectionNode const& sectionNode ) {
-        std::string name = trim( sectionNode.stats.sectionInfo.name );
-        if( !rootName.empty() )
-            name = rootName + '/' + name;
-
-        if( !sectionNode.assertions.empty() ||
-            !sectionNode.stdOut.empty() ||
-            !sectionNode.stdErr.empty() ) {
-            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
-            if( className.empty() ) {
-                xml.writeAttribute( "classname", name );
-                xml.writeAttribute( "name", "root" );
-            }
-            else {
-                xml.writeAttribute( "classname", className );
-                xml.writeAttribute( "name", name );
-            }
-            xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
-
-            writeAssertions( sectionNode );
-
-            if( !sectionNode.stdOut.empty() )
-                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
-            if( !sectionNode.stdErr.empty() )
-                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
-        }
-        for( auto const& childNode : sectionNode.childSections )
-            if( className.empty() )
-                writeSection( name, "", *childNode );
-            else
-                writeSection( className, name, *childNode );
-    }
-
-    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
-        for( auto const& assertion : sectionNode.assertions )
-            writeAssertion( assertion );
-    }
-
-    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
-        AssertionResult const& result = stats.assertionResult;
-        if( !result.isOk() ) {
-            std::string elementName;
-            switch( result.getResultType() ) {
-                case ResultWas::ThrewException:
-                case ResultWas::FatalErrorCondition:
-                    elementName = "error";
-                    break;
-                case ResultWas::ExplicitFailure:
-                case ResultWas::ExpressionFailed:
-                case ResultWas::DidntThrowException:
-                    elementName = "failure";
-                    break;
-
-                // We should never see these here:
-                case ResultWas::Info:
-                case ResultWas::Warning:
-                case ResultWas::Ok:
-                case ResultWas::Unknown:
-                case ResultWas::FailureBit:
-                case ResultWas::Exception:
-                    elementName = "internalError";
-                    break;
-            }
-
-            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
-
-            xml.writeAttribute( "message", result.getExpression() );
-            xml.writeAttribute( "type", result.getTestMacroName() );
-
-            ReusableStringStream rss;
-            if (stats.totals.assertions.total() > 0) {
-                rss << "FAILED" << ":\n";
-                if (result.hasExpression()) {
-                    rss << "  ";
-                    rss << result.getExpressionInMacro();
-                    rss << '\n';
-                }
-                if (result.hasExpandedExpression()) {
-                    rss << "with expansion:\n";
-                    rss << Column(result.getExpandedExpression()).indent(2) << '\n';
-                }
-            } else {
-                rss << '\n';
-            }
-
-            if( !result.getMessage().empty() )
-                rss << result.getMessage() << '\n';
-            for( auto const& msg : stats.infoMessages )
-                if( msg.type == ResultWas::Info )
-                    rss << msg.message << '\n';
-
-            rss << "at " << result.getSourceInfo();
-            xml.writeText( rss.str(), XmlFormatting::Newline );
-        }
-    }
-
-    CATCH_REGISTER_REPORTER( "junit", JunitReporter )
-
-} // end namespace Catch
-// end catch_reporter_junit.cpp
-// start catch_reporter_listening.cpp
-
-#include <cassert>
-
-namespace Catch {
-
-    ListeningReporter::ListeningReporter() {
-        // We will assume that listeners will always want all assertions
-        m_preferences.shouldReportAllAssertions = true;
-    }
-
-    void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
-        m_listeners.push_back( std::move( listener ) );
-    }
-
-    void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
-        assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
-        m_reporter = std::move( reporter );
-        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
-    }
-
-    ReporterPreferences ListeningReporter::getPreferences() const {
-        return m_preferences;
-    }
-
-    std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
-        return std::set<Verbosity>{ };
-    }
-
-    void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->noMatchingTestCases( spec );
-        }
-        m_reporter->noMatchingTestCases( spec );
-    }
-
-    void ListeningReporter::reportInvalidArguments(std::string const&arg){
-        for ( auto const& listener : m_listeners ) {
-            listener->reportInvalidArguments( arg );
-        }
-        m_reporter->reportInvalidArguments( arg );
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
-		for (auto const& listener : m_listeners) {
-			listener->benchmarkPreparing(name);
-		}
-		m_reporter->benchmarkPreparing(name);
-	}
-    void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->benchmarkStarting( benchmarkInfo );
-        }
-        m_reporter->benchmarkStarting( benchmarkInfo );
-    }
-    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->benchmarkEnded( benchmarkStats );
-        }
-        m_reporter->benchmarkEnded( benchmarkStats );
-    }
-
-	void ListeningReporter::benchmarkFailed( std::string const& error ) {
-		for (auto const& listener : m_listeners) {
-			listener->benchmarkFailed(error);
-		}
-		m_reporter->benchmarkFailed(error);
-	}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testRunStarting( testRunInfo );
-        }
-        m_reporter->testRunStarting( testRunInfo );
-    }
-
-    void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testGroupStarting( groupInfo );
-        }
-        m_reporter->testGroupStarting( groupInfo );
-    }
-
-    void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testCaseStarting( testInfo );
-        }
-        m_reporter->testCaseStarting( testInfo );
-    }
-
-    void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->sectionStarting( sectionInfo );
-        }
-        m_reporter->sectionStarting( sectionInfo );
-    }
-
-    void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->assertionStarting( assertionInfo );
-        }
-        m_reporter->assertionStarting( assertionInfo );
-    }
-
-    // The return value indicates if the messages buffer should be cleared:
-    bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        for( auto const& listener : m_listeners ) {
-            static_cast<void>( listener->assertionEnded( assertionStats ) );
-        }
-        return m_reporter->assertionEnded( assertionStats );
-    }
-
-    void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->sectionEnded( sectionStats );
-        }
-        m_reporter->sectionEnded( sectionStats );
-    }
-
-    void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testCaseEnded( testCaseStats );
-        }
-        m_reporter->testCaseEnded( testCaseStats );
-    }
-
-    void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testGroupEnded( testGroupStats );
-        }
-        m_reporter->testGroupEnded( testGroupStats );
-    }
-
-    void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testRunEnded( testRunStats );
-        }
-        m_reporter->testRunEnded( testRunStats );
-    }
-
-    void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->skipTest( testInfo );
-        }
-        m_reporter->skipTest( testInfo );
-    }
-
-    bool ListeningReporter::isMulti() const {
-        return true;
-    }
-
-} // end namespace Catch
-// end catch_reporter_listening.cpp
-// start catch_reporter_xml.cpp
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-    XmlReporter::XmlReporter( ReporterConfig const& _config )
-    :   StreamingReporterBase( _config ),
-        m_xml(_config.stream())
-    {
-        m_reporterPrefs.shouldRedirectStdOut = true;
-        m_reporterPrefs.shouldReportAllAssertions = true;
-    }
-
-    XmlReporter::~XmlReporter() = default;
-
-    std::string XmlReporter::getDescription() {
-        return "Reports test results as an XML document";
-    }
-
-    std::string XmlReporter::getStylesheetRef() const {
-        return std::string();
-    }
-
-    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
-        m_xml
-            .writeAttribute( "filename", sourceInfo.file )
-            .writeAttribute( "line", sourceInfo.line );
-    }
-
-    void XmlReporter::noMatchingTestCases( std::string const& s ) {
-        StreamingReporterBase::noMatchingTestCases( s );
-    }
-
-    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
-        StreamingReporterBase::testRunStarting( testInfo );
-        std::string stylesheetRef = getStylesheetRef();
-        if( !stylesheetRef.empty() )
-            m_xml.writeStylesheetRef( stylesheetRef );
-        m_xml.startElement( "Catch" );
-        if( !m_config->name().empty() )
-            m_xml.writeAttribute( "name", m_config->name() );
-        if (m_config->testSpec().hasFilters())
-            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
-        if( m_config->rngSeed() != 0 )
-            m_xml.scopedElement( "Randomness" )
-                .writeAttribute( "seed", m_config->rngSeed() );
-    }
-
-    void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        StreamingReporterBase::testGroupStarting( groupInfo );
-        m_xml.startElement( "Group" )
-            .writeAttribute( "name", groupInfo.name );
-    }
-
-    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        StreamingReporterBase::testCaseStarting(testInfo);
-        m_xml.startElement( "TestCase" )
-            .writeAttribute( "name", trim( testInfo.name ) )
-            .writeAttribute( "description", testInfo.description )
-            .writeAttribute( "tags", testInfo.tagsAsString() );
-
-        writeSourceInfo( testInfo.lineInfo );
-
-        if ( m_config->showDurations() == ShowDurations::Always )
-            m_testCaseTimer.start();
-        m_xml.ensureTagClosed();
-    }
-
-    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        StreamingReporterBase::sectionStarting( sectionInfo );
-        if( m_sectionDepth++ > 0 ) {
-            m_xml.startElement( "Section" )
-                .writeAttribute( "name", trim( sectionInfo.name ) );
-            writeSourceInfo( sectionInfo.lineInfo );
-            m_xml.ensureTagClosed();
-        }
-    }
-
-    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
-
-    bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
-
-        AssertionResult const& result = assertionStats.assertionResult;
-
-        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-        if( includeResults || result.getResultType() == ResultWas::Warning ) {
-            // Print any info messages in <Info> tags.
-            for( auto const& msg : assertionStats.infoMessages ) {
-                if( msg.type == ResultWas::Info && includeResults ) {
-                    m_xml.scopedElement( "Info" )
-                            .writeText( msg.message );
-                } else if ( msg.type == ResultWas::Warning ) {
-                    m_xml.scopedElement( "Warning" )
-                            .writeText( msg.message );
-                }
-            }
-        }
-
-        // Drop out if result was successful but we're not printing them.
-        if( !includeResults && result.getResultType() != ResultWas::Warning )
-            return true;
-
-        // Print the expression if there is one.
-        if( result.hasExpression() ) {
-            m_xml.startElement( "Expression" )
-                .writeAttribute( "success", result.succeeded() )
-                .writeAttribute( "type", result.getTestMacroName() );
-
-            writeSourceInfo( result.getSourceInfo() );
-
-            m_xml.scopedElement( "Original" )
-                .writeText( result.getExpression() );
-            m_xml.scopedElement( "Expanded" )
-                .writeText( result.getExpandedExpression() );
-        }
-
-        // And... Print a result applicable to each result type.
-        switch( result.getResultType() ) {
-            case ResultWas::ThrewException:
-                m_xml.startElement( "Exception" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::FatalErrorCondition:
-                m_xml.startElement( "FatalErrorCondition" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::Info:
-                m_xml.scopedElement( "Info" )
-                    .writeText( result.getMessage() );
-                break;
-            case ResultWas::Warning:
-                // Warning will already have been written
-                break;
-            case ResultWas::ExplicitFailure:
-                m_xml.startElement( "Failure" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            default:
-                break;
-        }
-
-        if( result.hasExpression() )
-            m_xml.endElement();
-
-        return true;
-    }
-
-    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
-        StreamingReporterBase::sectionEnded( sectionStats );
-        if( --m_sectionDepth > 0 ) {
-            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
-            e.writeAttribute( "successes", sectionStats.assertions.passed );
-            e.writeAttribute( "failures", sectionStats.assertions.failed );
-            e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
-
-            if ( m_config->showDurations() == ShowDurations::Always )
-                e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
-
-            m_xml.endElement();
-        }
-    }
-
-    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        StreamingReporterBase::testCaseEnded( testCaseStats );
-        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
-        e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
-
-        if ( m_config->showDurations() == ShowDurations::Always )
-            e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
-
-        if( !testCaseStats.stdOut.empty() )
-            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
-        if( !testCaseStats.stdErr.empty() )
-            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
-
-        m_xml.endElement();
-    }
-
-    void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        StreamingReporterBase::testGroupEnded( testGroupStats );
-        // TODO: Check testGroupStats.aborting and act accordingly.
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
-            .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
-        m_xml.endElement();
-    }
-
-    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        StreamingReporterBase::testRunEnded( testRunStats );
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes", testRunStats.totals.assertions.passed )
-            .writeAttribute( "failures", testRunStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
-        m_xml.endElement();
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void XmlReporter::benchmarkPreparing(std::string const& name) {
-        m_xml.startElement("BenchmarkResults")
-            .writeAttribute("name", name);
-    }
-
-    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
-        m_xml.writeAttribute("samples", info.samples)
-            .writeAttribute("resamples", info.resamples)
-            .writeAttribute("iterations", info.iterations)
-            .writeAttribute("clockResolution", info.clockResolution)
-            .writeAttribute("estimatedDuration", info.estimatedDuration)
-            .writeComment("All values in nano seconds");
-    }
-
-    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
-        m_xml.startElement("mean")
-            .writeAttribute("value", benchmarkStats.mean.point.count())
-            .writeAttribute("lowerBound", benchmarkStats.mean.lower_bound.count())
-            .writeAttribute("upperBound", benchmarkStats.mean.upper_bound.count())
-            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
-        m_xml.endElement();
-        m_xml.startElement("standardDeviation")
-            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
-            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
-            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
-            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
-        m_xml.endElement();
-        m_xml.startElement("outliers")
-            .writeAttribute("variance", benchmarkStats.outlierVariance)
-            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
-            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
-            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
-            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
-        m_xml.endElement();
-        m_xml.endElement();
-    }
-
-    void XmlReporter::benchmarkFailed(std::string const &error) {
-        m_xml.scopedElement("failed").
-            writeAttribute("message", error);
-        m_xml.endElement();
-    }
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    CATCH_REGISTER_REPORTER( "xml", XmlReporter )
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-// end catch_reporter_xml.cpp
-
-namespace Catch {
-    LeakDetector leakDetector;
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_impl.hpp
-#endif
-
-#ifdef CATCH_CONFIG_MAIN
-// start catch_default_main.hpp
-
-#ifndef __OBJC__
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
-// Standard C/C++ Win32 Unicode wmain entry point
-extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
-#else
-// Standard C/C++ main entry point
-int main (int argc, char * argv[]) {
-#endif
-
-    return Catch::Session().run( argc, argv );
-}
-
-#else // __OBJC__
-
-// Objective-C entry point
-int main (int argc, char * const argv[]) {
-#if !CATCH_ARC_ENABLED
-    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
-#endif
-
-    Catch::registerTestMethods();
-    int result = Catch::Session().run( argc, (char**)argv );
-
-#if !CATCH_ARC_ENABLED
-    [pool drain];
-#endif
-
-    return result;
-}
-
-#endif // __OBJC__
-
-// end catch_default_main.hpp
-#endif
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-
-#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
-#  undef CLARA_CONFIG_MAIN
-#endif
-
-#if !defined(CATCH_CONFIG_DISABLE)
-//////
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
-#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
-#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#endif
-
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
-#else
-#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define CATCH_BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define CATCH_BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
-#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
-#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
-#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
-
-#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#endif
-
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
-#else
-#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
-
-// "BDD-style" convenience wrappers
-#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-
-#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-using Catch::Detail::Approx;
-
-#else // CATCH_CONFIG_DISABLE
-
-//////
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( ... )        (void)(0)
-#define CATCH_REQUIRE_FALSE( ... )  (void)(0)
-
-#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CATCH_CHECK( ... )         (void)(0)
-#define CATCH_CHECK_FALSE( ... )   (void)(0)
-#define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
-#define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
-#define CATCH_CHECK_NOFAIL( ... )  (void)(0)
-
-#define CATCH_CHECK_THROWS( ... )  (void)(0)
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_CHECK_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
-
-#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define CATCH_INFO( msg )          (void)(0)
-#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
-#define CATCH_WARN( msg )          (void)(0)
-#define CATCH_CAPTURE( msg )       (void)(0)
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_METHOD_AS_TEST_CASE( method, ... )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define CATCH_SECTION( ... )
-#define CATCH_DYNAMIC_SECTION( ... )
-#define CATCH_FAIL( ... ) (void)(0)
-#define CATCH_FAIL_CHECK( ... ) (void)(0)
-#define CATCH_SUCCEED( ... ) (void)(0)
-
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-#define CATCH_GIVEN( desc )
-#define CATCH_AND_GIVEN( desc )
-#define CATCH_WHEN( desc )
-#define CATCH_AND_WHEN( desc )
-#define CATCH_THEN( desc )
-#define CATCH_AND_THEN( desc )
-
-#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( ... )       (void)(0)
-#define REQUIRE_FALSE( ... ) (void)(0)
-
-#define REQUIRE_THROWS( ... ) (void)(0)
-#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CHECK( ... ) (void)(0)
-#define CHECK_FALSE( ... ) (void)(0)
-#define CHECKED_IF( ... ) if (__VA_ARGS__)
-#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
-#define CHECK_NOFAIL( ... ) (void)(0)
-
-#define CHECK_THROWS( ... )  (void)(0)
-#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) (void)(0)
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) (void)(0)
-
-#define REQUIRE_THAT( arg, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define INFO( msg ) (void)(0)
-#define UNSCOPED_INFO( msg ) (void)(0)
-#define WARN( msg ) (void)(0)
-#define CAPTURE( msg ) (void)(0)
-
-#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define METHOD_AS_TEST_CASE( method, ... )
-#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define SECTION( ... )
-#define DYNAMIC_SECTION( ... )
-#define FAIL( ... ) (void)(0)
-#define FAIL_CHECK( ... ) (void)(0)
-#define SUCCEED( ... ) (void)(0)
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-#define STATIC_REQUIRE( ... )       (void)(0)
-#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// "BDD-style" convenience wrappers
-#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-
-#define GIVEN( desc )
-#define AND_GIVEN( desc )
-#define WHEN( desc )
-#define AND_WHEN( desc )
-#define THEN( desc )
-#define AND_THEN( desc )
-
-using Catch::Detail::Approx;
-
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
-// start catch_reenable_warnings.h
-
-
-#ifdef __clang__
-#    ifdef __ICC // icpc defines the __clang__ macro
-#        pragma warning(pop)
-#    else
-#        pragma clang diagnostic pop
-#    endif
-#elif defined __GNUC__
-#    pragma GCC diagnostic pop
-#endif
-
-// end catch_reenable_warnings.h
-// end catch.hpp
-#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-
diff --git a/test/catch2/catch_reporter_automake.hpp b/test/catch2/catch_reporter_automake.hpp
deleted file mode 100644
index dbebe9751..000000000
--- a/test/catch2/catch_reporter_automake.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- *  Created by Justin R. Wilson on 2/19/2017.
- *  Copyright 2017 Justin R. Wilson. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-namespace Catch {
-
-    struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
-        AutomakeReporter( ReporterConfig const& _config )
-          :   StreamingReporterBase( _config )
-        {}
-
-        ~AutomakeReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in the format of Automake .trs files";
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
-
-        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
-            // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
-            stream << ":test-result: ";
-            if (_testCaseStats.totals.assertions.allPassed()) {
-                stream << "PASS";
-            } else if (_testCaseStats.totals.assertions.allOk()) {
-                stream << "XFAIL";
-            } else {
-                stream << "FAIL";
-            }
-            stream << ' ' << _testCaseStats.testInfo.name << '\n';
-            StreamingReporterBase::testCaseEnded( _testCaseStats );
-        }
-
-        void skipTest( TestCaseInfo const& testInfo ) override {
-            stream << ":test-result: SKIP " << testInfo.name << '\n';
-        }
-
-    };
-
-#ifdef CATCH_IMPL
-    AutomakeReporter::~AutomakeReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
diff --git a/test/catch2/catch_reporter_sonarqube.hpp b/test/catch2/catch_reporter_sonarqube.hpp
deleted file mode 100644
index bf7d9299a..000000000
--- a/test/catch2/catch_reporter_sonarqube.hpp
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- *  Created by Daniel Garcia on 2018-12-04.
- *  Copyright Social Point SL. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
-#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
-
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <map>
-
-namespace Catch {
-
-    struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
-
-        SonarQubeReporter(ReporterConfig const& config)
-        : CumulativeReporterBase(config)
-        , xml(config.stream()) {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-            m_reporterPrefs.shouldReportAllAssertions = true;
-        }
-
-        ~SonarQubeReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in the Generic Test Data SonarQube XML format";
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        void noMatchingTestCases(std::string const& /*spec*/) override {}
-
-        void testRunStarting(TestRunInfo const& testRunInfo) override {
-            CumulativeReporterBase::testRunStarting(testRunInfo);
-            xml.startElement("testExecutions");
-            xml.writeAttribute("version", "1");
-        }
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            CumulativeReporterBase::testGroupEnded(testGroupStats);
-            writeGroup(*m_testGroups.back());
-        }
-
-        void testRunEndedCumulative() override {
-            xml.endElement();
-        }
-
-        void writeGroup(TestGroupNode const& groupNode) {
-            std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
-            for(auto const& child : groupNode.children)
-                testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
-
-            for(auto const& kv : testsPerFile)
-                writeTestFile(kv.first.c_str(), kv.second);
-        }
-
-        void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
-            XmlWriter::ScopedElement e = xml.scopedElement("file");
-            xml.writeAttribute("path", filename);
-
-            for(auto const& child : testCaseNodes)
-                writeTestCase(*child);
-        }
-
-        void writeTestCase(TestCaseNode const& testCaseNode) {
-            // All test cases have exactly one section - which represents the
-            // test case itself. That section may have 0-n nested sections
-            assert(testCaseNode.children.size() == 1);
-            SectionNode const& rootSection = *testCaseNode.children.front();
-            writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
-        }
-
-        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
-            std::string name = trim(sectionNode.stats.sectionInfo.name);
-            if(!rootName.empty())
-                name = rootName + '/' + name;
-
-            if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
-                XmlWriter::ScopedElement e = xml.scopedElement("testCase");
-                xml.writeAttribute("name", name);
-                xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
-
-                writeAssertions(sectionNode, okToFail);
-            }
-
-            for(auto const& childNode : sectionNode.childSections)
-                writeSection(name, *childNode, okToFail);
-        }
-
-        void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
-            for(auto const& assertion : sectionNode.assertions)
-                writeAssertion( assertion, okToFail);
-        }
-
-        void writeAssertion(AssertionStats const& stats, bool okToFail) {
-            AssertionResult const& result = stats.assertionResult;
-            if(!result.isOk()) {
-                std::string elementName;
-                if(okToFail) {
-                    elementName = "skipped";
-                }
-                else {
-                    switch(result.getResultType()) {
-                        case ResultWas::ThrewException:
-                        case ResultWas::FatalErrorCondition:
-                            elementName = "error";
-                            break;
-                        case ResultWas::ExplicitFailure:
-                            elementName = "failure";
-                            break;
-                        case ResultWas::ExpressionFailed:
-                            elementName = "failure";
-                            break;
-                        case ResultWas::DidntThrowException:
-                            elementName = "failure";
-                            break;
-
-                            // We should never see these here:
-                        case ResultWas::Info:
-                        case ResultWas::Warning:
-                        case ResultWas::Ok:
-                        case ResultWas::Unknown:
-                        case ResultWas::FailureBit:
-                        case ResultWas::Exception:
-                            elementName = "internalError";
-                            break;
-                    }
-                }
-
-                XmlWriter::ScopedElement e = xml.scopedElement(elementName);
-
-                ReusableStringStream messageRss;
-                messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
-                xml.writeAttribute("message", messageRss.str());
-
-                ReusableStringStream textRss;
-                if (stats.totals.assertions.total() > 0) {
-                    textRss << "FAILED:\n";
-                    if (result.hasExpression()) {
-                        textRss << "\t" << result.getExpressionInMacro() << "\n";
-                    }
-                    if (result.hasExpandedExpression()) {
-                        textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
-                    }
-                }
-
-                if(!result.getMessage().empty())
-                    textRss << result.getMessage() << "\n";
-
-                for(auto const& msg : stats.infoMessages)
-                    if(msg.type == ResultWas::Info)
-                        textRss << msg.message << "\n";
-
-                textRss << "at " << result.getSourceInfo();
-                xml.writeText(textRss.str(), XmlFormatting::Newline);
-            }
-        }
-
-    private:
-        XmlWriter xml;
-    };
-
-#ifdef CATCH_IMPL
-    SonarQubeReporter::~SonarQubeReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
\ No newline at end of file
diff --git a/test/catch2/catch_reporter_tap.hpp b/test/catch2/catch_reporter_tap.hpp
deleted file mode 100644
index 1bfe4f5e1..000000000
--- a/test/catch2/catch_reporter_tap.hpp
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- *  Created by Colton Wolkins on 2015-08-15.
- *  Copyright 2015 Martin Moene. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
-
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <algorithm>
-
-namespace Catch {
-
-    struct TAPReporter : StreamingReporterBase<TAPReporter> {
-
-        using StreamingReporterBase::StreamingReporterBase;
-
-        ~TAPReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in TAP format, suitable for test harnesses";
-        }
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        void noMatchingTestCases( std::string const& spec ) override {
-            stream << "# No test cases matched '" << spec << "'" << std::endl;
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& _assertionStats ) override {
-            ++counter;
-
-            stream << "# " << currentTestCaseInfo->name << std::endl;
-            AssertionPrinter printer( stream, _assertionStats, counter );
-            printer.print();
-
-            stream << std::endl;
-            return true;
-        }
-
-        void testRunEnded( TestRunStats const& _testRunStats ) override {
-            printTotals( _testRunStats.totals );
-            stream << "\n" << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-    private:
-        std::size_t counter = 0;
-        class AssertionPrinter {
-        public:
-            AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
-            AssertionPrinter( AssertionPrinter const& ) = delete;
-            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
-            : stream( _stream )
-            , result( _stats.assertionResult )
-            , messages( _stats.infoMessages )
-            , itMessage( _stats.infoMessages.begin() )
-            , printInfoMessages( true )
-            , counter(_counter)
-            {}
-
-            void print() {
-                itMessage = messages.begin();
-
-                switch( result.getResultType() ) {
-                    case ResultWas::Ok:
-                        printResultType( passedString() );
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if ( ! result.hasExpression() )
-                            printRemainingMessages( Colour::None );
-                        else
-                            printRemainingMessages();
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        if (result.isOk()) {
-                            printResultType(passedString());
-                        } else {
-                            printResultType(failedString());
-                        }
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if (result.isOk()) {
-                            printIssue(" # TODO");
-                        }
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ThrewException:
-                        printResultType( failedString() );
-                        printIssue( "unexpected exception with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        printResultType( failedString() );
-                        printIssue( "fatal error condition with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::DidntThrowException:
-                        printResultType( failedString() );
-                        printIssue( "expected exception, got none" );
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Info:
-                        printResultType( "info" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Warning:
-                        printResultType( "warning" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        printResultType( failedString() );
-                        printIssue( "explicitly" );
-                        printRemainingMessages( Colour::None );
-                        break;
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        printResultType( "** internal error **" );
-                        break;
-                }
-            }
-
-        private:
-            static Colour::Code dimColour() { return Colour::FileName; }
-
-            static const char* failedString() { return "not ok"; }
-            static const char* passedString() { return "ok"; }
-
-            void printSourceInfo() const {
-                Colour colourGuard( dimColour() );
-                stream << result.getSourceInfo() << ":";
-            }
-
-            void printResultType( std::string const& passOrFail ) const {
-                if( !passOrFail.empty() ) {
-                    stream << passOrFail << ' ' << counter << " -";
-                }
-            }
-
-            void printIssue( std::string const& issue ) const {
-                stream << " " << issue;
-            }
-
-            void printExpressionWas() {
-                if( result.hasExpression() ) {
-                    stream << ";";
-                    {
-                        Colour colour( dimColour() );
-                        stream << " expression was:";
-                    }
-                    printOriginalExpression();
-                }
-            }
-
-            void printOriginalExpression() const {
-                if( result.hasExpression() ) {
-                    stream << " " << result.getExpression();
-                }
-            }
-
-            void printReconstructedExpression() const {
-                if( result.hasExpandedExpression() ) {
-                    {
-                        Colour colour( dimColour() );
-                        stream << " for: ";
-                    }
-                    std::string expr = result.getExpandedExpression();
-                    std::replace( expr.begin(), expr.end(), '\n', ' ');
-                    stream << expr;
-                }
-            }
-
-            void printMessage() {
-                if ( itMessage != messages.end() ) {
-                    stream << " '" << itMessage->message << "'";
-                    ++itMessage;
-                }
-            }
-
-            void printRemainingMessages( Colour::Code colour = dimColour() ) {
-                if (itMessage == messages.end()) {
-                    return;
-                }
-
-                // using messages.end() directly (or auto) yields compilation error:
-                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
-                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
-
-                {
-                    Colour colourGuard( colour );
-                    stream << " with " << pluralise( N, "message" ) << ":";
-                }
-
-                for(; itMessage != itEnd; ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
-                        stream << " '" << itMessage->message << "'";
-                        if ( ++itMessage != itEnd ) {
-                            Colour colourGuard( dimColour() );
-                            stream << " and";
-                        }
-                    }
-                }
-            }
-
-        private:
-            std::ostream& stream;
-            AssertionResult const& result;
-            std::vector<MessageInfo> messages;
-            std::vector<MessageInfo>::const_iterator itMessage;
-            bool printInfoMessages;
-            std::size_t counter;
-        };
-
-        void printTotals( const Totals& totals ) const {
-            if( totals.testCases.total() == 0 ) {
-                stream << "1..0 # Skipped: No tests ran.";
-            } else {
-                stream << "1.." << counter;
-            }
-        }
-    };
-
-#ifdef CATCH_IMPL
-    TAPReporter::~TAPReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "tap", TAPReporter )
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
diff --git a/test/catch2/catch_reporter_teamcity.hpp b/test/catch2/catch_reporter_teamcity.hpp
deleted file mode 100644
index 47b7e4aac..000000000
--- a/test/catch2/catch_reporter_teamcity.hpp
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
- *  Created by Phil Nash on 19th December 2014
- *  Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <cstring>
-
-#ifdef __clang__
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
-        TeamCityReporter( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-        }
-
-        static std::string escape( std::string const& str ) {
-            std::string escaped = str;
-            replaceInPlace( escaped, "|", "||" );
-            replaceInPlace( escaped, "'", "|'" );
-            replaceInPlace( escaped, "\n", "|n" );
-            replaceInPlace( escaped, "\r", "|r" );
-            replaceInPlace( escaped, "[", "|[" );
-            replaceInPlace( escaped, "]", "|]" );
-            return escaped;
-        }
-        ~TeamCityReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results as TeamCity service messages";
-        }
-
-        void skipTest( TestCaseInfo const& /* testInfo */ ) override {
-        }
-
-        void noMatchingTestCases( std::string const& /* spec */ ) override {}
-
-        void testGroupStarting( GroupInfo const& groupInfo ) override {
-            StreamingReporterBase::testGroupStarting( groupInfo );
-            stream << "##teamcity[testSuiteStarted name='"
-                << escape( groupInfo.name ) << "']\n";
-        }
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
-            StreamingReporterBase::testGroupEnded( testGroupStats );
-            stream << "##teamcity[testSuiteFinished name='"
-                << escape( testGroupStats.groupInfo.name ) << "']\n";
-        }
-
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& assertionStats ) override {
-            AssertionResult const& result = assertionStats.assertionResult;
-            if( !result.isOk() ) {
-
-                ReusableStringStream msg;
-                if( !m_headerPrintedForThisSection )
-                    printSectionHeader( msg.get() );
-                m_headerPrintedForThisSection = true;
-
-                msg << result.getSourceInfo() << "\n";
-
-                switch( result.getResultType() ) {
-                    case ResultWas::ExpressionFailed:
-                        msg << "expression failed";
-                        break;
-                    case ResultWas::ThrewException:
-                        msg << "unexpected exception";
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        msg << "fatal error condition";
-                        break;
-                    case ResultWas::DidntThrowException:
-                        msg << "no exception was thrown where one was expected";
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        msg << "explicit failure";
-                        break;
-
-                    // We shouldn't get here because of the isOk() test
-                    case ResultWas::Ok:
-                    case ResultWas::Info:
-                    case ResultWas::Warning:
-                        CATCH_ERROR( "Internal error in TeamCity reporter" );
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        CATCH_ERROR( "Not implemented" );
-                }
-                if( assertionStats.infoMessages.size() == 1 )
-                    msg << " with message:";
-                if( assertionStats.infoMessages.size() > 1 )
-                    msg << " with messages:";
-                for( auto const& messageInfo : assertionStats.infoMessages )
-                    msg << "\n  \"" << messageInfo.message << "\"";
-
-
-                if( result.hasExpression() ) {
-                    msg <<
-                        "\n  " << result.getExpressionInMacro() << "\n"
-                        "with expansion:\n" <<
-                        "  " << result.getExpandedExpression() << "\n";
-                }
-
-                if( currentTestCaseInfo->okToFail() ) {
-                    msg << "- failure ignore as test marked as 'ok to fail'\n";
-                    stream << "##teamcity[testIgnored"
-                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
-                           << " message='" << escape( msg.str() ) << "'"
-                           << "]\n";
-                }
-                else {
-                    stream << "##teamcity[testFailed"
-                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
-                           << " message='" << escape( msg.str() ) << "'"
-                           << "]\n";
-                }
-            }
-            stream.flush();
-            return true;
-        }
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            m_headerPrintedForThisSection = false;
-            StreamingReporterBase::sectionStarting( sectionInfo );
-        }
-
-        void testCaseStarting( TestCaseInfo const& testInfo ) override {
-            m_testTimer.start();
-            StreamingReporterBase::testCaseStarting( testInfo );
-            stream << "##teamcity[testStarted name='"
-                << escape( testInfo.name ) << "']\n";
-            stream.flush();
-        }
-
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
-            StreamingReporterBase::testCaseEnded( testCaseStats );
-            if( !testCaseStats.stdOut.empty() )
-                stream << "##teamcity[testStdOut name='"
-                    << escape( testCaseStats.testInfo.name )
-                    << "' out='" << escape( testCaseStats.stdOut ) << "']\n";
-            if( !testCaseStats.stdErr.empty() )
-                stream << "##teamcity[testStdErr name='"
-                    << escape( testCaseStats.testInfo.name )
-                    << "' out='" << escape( testCaseStats.stdErr ) << "']\n";
-            stream << "##teamcity[testFinished name='"
-                    << escape( testCaseStats.testInfo.name ) << "' duration='"
-                    << m_testTimer.getElapsedMilliseconds() << "']\n";
-            stream.flush();
-        }
-
-    private:
-        void printSectionHeader( std::ostream& os ) {
-            assert( !m_sectionStack.empty() );
-
-            if( m_sectionStack.size() > 1 ) {
-                os << getLineOfChars<'-'>() << "\n";
-
-                std::vector<SectionInfo>::const_iterator
-                it = m_sectionStack.begin()+1, // Skip first section (test case)
-                itEnd = m_sectionStack.end();
-                for( ; it != itEnd; ++it )
-                    printHeaderString( os, it->name );
-                os << getLineOfChars<'-'>() << "\n";
-            }
-
-            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
-
-            os << lineInfo << "\n";
-            os << getLineOfChars<'.'>() << "\n\n";
-        }
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        static void printHeaderString( std::ostream& os, std::string const& _string, std::size_t indent = 0 ) {
-            std::size_t i = _string.find( ": " );
-            if( i != std::string::npos )
-                i+=2;
-            else
-                i = 0;
-            os << Column( _string )
-                           .indent( indent+i)
-                           .initialIndent( indent ) << "\n";
-        }
-    private:
-        bool m_headerPrintedForThisSection = false;
-        Timer m_testTimer;
-    };
-
-#ifdef CATCH_IMPL
-    TeamCityReporter::~TeamCityReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
-
-} // end namespace Catch
-
-#ifdef __clang__
-#   pragma clang diagnostic pop
-#endif
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED

From 7e3af7cf839ee07cca12093812f323b7b396be04 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 19 Apr 2020 21:36:10 +0200
Subject: [PATCH 0188/1774] replaced slotLengthMs with lengthMs

---
 devicehandlers/FixedSlotSequence.cpp | 8 ++++----
 devicehandlers/FixedSlotSequence.h   | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index f11de94b4..f68733b07 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -3,7 +3,7 @@
 #include <cstdlib>
 
 FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
-		slotLengthMs(setLengthMs) {
+		lengthMs(setLengthMs) {
 	current = slotList.begin();
 }
 
@@ -50,7 +50,7 @@ uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
 	// the interval is calculated by subtracting the remaining time of the PST
 	// and adding the start time of the first handler in the list.
 	slotListIter = slotList.begin();
-	return slotLengthMs - oldTime + slotListIter->pollingTimeMs;
+	return lengthMs - oldTime + slotListIter->pollingTimeMs;
 }
 
 uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
@@ -61,7 +61,7 @@ uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
 
 	//if it is the first slot, calculate difference to last slot
 	if (slotListIter == slotList.begin()){
-		return slotLengthMs - (--slotList.end())->pollingTimeMs + currentTime;
+		return lengthMs - (--slotList.end())->pollingTimeMs + currentTime;
 	}
 	// get previous slot
 	slotListIter--;
@@ -84,7 +84,7 @@ bool FixedSlotSequence::slotFollowsImmediately() {
 }
 
 uint32_t FixedSlotSequence::getLengthMs() const {
-	return this->slotLengthMs;
+	return this->lengthMs;
 }
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h
index cad7ee875..1d872c84f 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -126,7 +126,7 @@ protected:
 	 */
 	SlotList slotList;
 
-	uint32_t slotLengthMs;
+	uint32_t lengthMs;
 
 	bool isEmpty = false;
 };

From a42832ca01d9b5554b3e6b7c274bf16ce5d13f58 Mon Sep 17 00:00:00 2001
From: Uli <uli@vnks.de>
Date: Tue, 21 Apr 2020 21:34:03 +0200
Subject: [PATCH 0189/1774] working on updating SerializeIF, to quote Basti:
 This is going to be horrible

---
 container/FixedMap.h                         |  16 +-
 container/IndexedRingMemoryArray.h           |  32 +--
 datapool/DataPoolParameterWrapper.cpp        |   6 +-
 datapool/PIDReader.h                         |  34 ++--
 datapool/PoolRawAccess.cpp                   |  22 ++-
 datapool/PoolRawAccess.h                     |  16 +-
 datapool/PoolVariable.h                      |  30 +--
 datapool/PoolVector.h                        |   6 +-
 devicehandlers/DeviceTmReportingWrapper.cpp  |   8 +-
 globalfunctions/Type.cpp                     |  10 +-
 globalfunctions/Type.h                       |  16 +-
 globalfunctions/matching/MatchTree.h         |   2 +-
 globalfunctions/matching/RangeMatcher.h      |  29 +--
 health/HealthTable.cpp                       |   6 +-
 memory/MemoryHelper.cpp                      |   6 +-
 osal/rtems/CpuUsage.cpp                      |  16 +-
 parameters/ParameterWrapper.cpp              |  16 +-
 parameters/ParameterWrapper.h                |   2 +-
 power/PowerComponent.cpp                     |   8 +-
 serialize/EndianSwapper.h                    |  46 ++++-
 serialize/SerialArrayListAdapter.h           |  10 +-
 serialize/SerialBufferAdapter.cpp            |   8 +-
 serialize/SerialLinkedListAdapter.h          |  36 ++--
 serialize/SerializeAdapter.h                 | 198 +++++++++----------
 serialize/SerializeElement.h                 |  34 ++--
 serialize/SerializeIF.h                      |  15 +-
 subsystem/Subsystem.cpp                      |   2 +-
 subsystem/modes/ModeDefinitions.h            |  16 +-
 thermal/ThermalComponent.cpp                 |   8 +-
 tmstorage/TmStorePackets.h                   |  38 ++--
 tmtcpacket/packetmatcher/ApidMatcher.h       |   6 +-
 tmtcpacket/packetmatcher/ServiceMatcher.h    |   6 +-
 tmtcpacket/packetmatcher/SubserviceMatcher.h |   6 +-
 tmtcservices/CommandingServiceBase.cpp       |   2 +-
 tmtcservices/PusVerificationReport.cpp       |  18 +-
 35 files changed, 389 insertions(+), 341 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 0b84bf4ea..eaf8a24cd 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -150,13 +150,13 @@ public:
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&this->_size,
+		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
 				buffer, size, max_size, bigEndian);
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter<key_t>::serialize(&theMap[i].first, buffer,
+			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
 					size, max_size, bigEndian);
-			result = SerializeAdapter<T>::serialize(&theMap[i].second, buffer, size,
+			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
 					max_size, bigEndian);
 			++i;
 		}
@@ -168,9 +168,9 @@ public:
 		uint32_t i = 0;
 
 		for (i = 0; i < _size; ++i) {
-			printSize += SerializeAdapter<key_t>::getSerializedSize(
+			printSize += SerializeAdapter::getSerializedSize(
 					&theMap[i].first);
-			printSize += SerializeAdapter<T>::getSerializedSize(&theMap[i].second);
+			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
 		}
 
 		return printSize;
@@ -178,16 +178,16 @@ public:
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
-		ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
 				buffer, size, bigEndian);
 		if (this->_size > theMap.maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter<key_t>::deSerialize(&theMap[i].first, buffer,
+			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
 					size, bigEndian);
-			result = SerializeAdapter<T>::deSerialize(&theMap[i].second, buffer, size,
+			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
 					bigEndian);
 			++i;
 		}
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 992b7489a..32b61c2d1 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -70,7 +70,7 @@ public:
 
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 				const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = AutoSerializeAdapter::serialize(&blockStartAddress,buffer,size,max_size,bigEndian);
+		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,max_size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -78,17 +78,17 @@ public:
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&this->storedPackets,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,max_size,bigEndian);
 		return result;
 	}
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 				bool bigEndian){
-		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&blockStartAddress,buffer,size,bigEndian);
+		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -96,11 +96,11 @@ public:
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&this->storedPackets,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -108,10 +108,10 @@ public:
 	}
 
 	uint32_t getSerializedSize() const {
-		uint32_t size = AutoSerializeAdapter::getSerializedSize(&blockStartAddress);
+		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
 		size += indexType.getSerializedSize();
-		size += AutoSerializeAdapter::getSerializedSize(&this->size);
-		size += AutoSerializeAdapter::getSerializedSize(&this->storedPackets);
+		size += SerializeAdapter::getSerializedSize(&this->size);
+		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
 		return size;
 	}
 
@@ -500,14 +500,14 @@ public:
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
-		result = AutoSerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter<Index<T> >::serialize(&this->entries[i], buffer, size,
+			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
 					max_size, bigEndian);
 			++i;
 		}
@@ -515,7 +515,7 @@ public:
 			return result;
 		}
 		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = AutoSerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian);
 		return result;
 	}
 
@@ -531,10 +531,10 @@ public:
 			size += additionalInfo->getSerializedSize();
 		}
 		size += currentWriteBlock->getSerializedSize();
-		size += AutoSerializeAdapter::getSerializedSize(&this->size);
+		size += SerializeAdapter::getSerializedSize(&this->size);
 		size += (this->entries[0].getSerializedSize()) * this->size;
 		uint16_t crc = 0;
-		size += AutoSerializeAdapter::getSerializedSize(&crc);
+		size += SerializeAdapter::getSerializedSize(&crc);
 		return size;
 	}
 	/**
@@ -563,7 +563,7 @@ public:
 					return result;
 		}
 		uint32_t tempSize = 0;
-		result = AutoSerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
@@ -572,7 +572,7 @@ public:
 		}
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter<Index<T> >::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					&this->entries[i], buffer, size,
 					bigEndian);
 			++i;
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index 0ff2121d6..10fb53921 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapool/DataPoolParameterWrapper.cpp
@@ -39,18 +39,18 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&type, buffer, size, max_size,
 			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
+	result = SerializeAdapter::serialize(&columns, buffer, size,
 			max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::serialize(&rows, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&rows, buffer, size, max_size,
 			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index 299cc2fe6..ac1d169e9 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -17,7 +17,7 @@ protected:
 	uint8_t valid;
 	ReturnValue_t read() {
 		uint8_t arrayIndex = DataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(
+		PoolEntry<T> *read_out = ::dataPool.getData<T>(
 				DataPool::PIDToDataPoolId(parameterId), arrayIndex);
 		if (read_out != NULL) {
 			valid = read_out->valid;
@@ -43,7 +43,8 @@ protected:
 	 * Empty ctor for List initialization
 	 */
 	PIDReader() :
-		parameterId(PoolVariableIF::NO_PARAMETER), valid(PoolVariableIF::INVALID), value(0) {
+			parameterId(PoolVariableIF::NO_PARAMETER), valid(
+					PoolVariableIF::INVALID), value(0) {
 
 	}
 public:
@@ -63,9 +64,9 @@ public:
 	 * \param setWritable If this flag is set to true, changes in the value attribute can be
 	 * 					written back to the data pool, otherwise not.
 	 */
-	PIDReader(uint32_t setParameterId, DataSetIF* dataSet) :
-			parameterId(setParameterId), valid(
-					PoolVariableIF::INVALID), value(0) {
+	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
+			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
+					0) {
 		if (dataSet != NULL) {
 			dataSet->registerVariable(this);
 		}
@@ -74,7 +75,7 @@ public:
 	/**
 	 * Copy ctor to copy classes containing Pool Variables.
 	 */
-	PIDReader(const PIDReader& rhs) :
+	PIDReader(const PIDReader &rhs) :
 			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
 	}
 
@@ -121,24 +122,25 @@ public:
 		return value;
 	}
 
-	PIDReader<T> &operator=(T newValue) {
+	PIDReader<T>& operator=(T newValue) {
 		value = newValue;
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
-				bigEndian);
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
+				streamEndianness);
 	}
 
-	virtual uint32_t getSerializedSize() const {
-		return SerializeAdapter<T>::getSerializedSize(&value);
+	virtual size_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian) {
-		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+				streamEndianness);
 	}
 };
 
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 555896bb2..2053498b1 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -145,10 +145,12 @@ uint16_t PoolRawAccess::getSizeTillEnd() const {
 	return sizeTillEnd;
 }
 
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
-	if (typeSize + *size <= max_size) {
-		if (bigEndian) {
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	//TODO integer overflow
+	if (typeSize + *size <= maxSize) {
+#error use endian swapper
+		if (1) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
@@ -169,16 +171,16 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
 	}
 }
 
-uint32_t PoolRawAccess::getSerializedSize() const {
+size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
 }
 
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, int32_t* size,
-		bool bigEndian) {
-	*size -= typeSize;
-	if (*size >= 0) {
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
 
-		if (bigEndian) {
+	if (*size >= typeSize) {
+		*size -= typeSize;
+		if (1) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 3e2bd7ae3..190c38a99 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -70,7 +70,7 @@ public:
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
 	uint8_t value[RAW_MAX_SIZE];
 	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
-			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
+			DataSetIF *data_set, ReadWriteMode_t setReadWriteMode =
 					PoolVariableIF::VAR_READ);
 	/**
 	 * \brief	The classes destructor is empty. If commit() was not called, the local value is
@@ -97,7 +97,7 @@ public:
 	 * \return	- \c RETURN_OK if entry could be acquired
 	 * 			- \c RETURN_FAILED else.
 	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
+	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, uint32_t *size,
 			uint32_t max_size);
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
@@ -106,7 +106,7 @@ public:
 	 * @return	- \c RETURN_OK on success
 	 * 			- \c RETURN_FAILED on failure
 	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
+	ReturnValue_t setEntryFromBigEndian(const uint8_t *buffer,
 			uint32_t setSize);
 	/**
 	 *  \brief This operation returns the type of the entry currently stored.
@@ -140,13 +140,13 @@ public:
 	 */
 	uint16_t getSizeTillEnd() const;
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			 Endianness streamEndianness) const override;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const override;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			 Endianness streamEndianness) override;
 };
 
 #endif /* POOLRAWACCESS_H_ */
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index 25345c0ac..ce073426a 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -58,7 +58,7 @@ protected:
 	 * 			The operation does NOT provide any mutual exclusive protection by itself.
 	 */
 	ReturnValue_t read() {
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(dataPoolId, 1);
+		PoolEntry<T> *read_out = ::dataPool.getData < T > (dataPoolId, 1);
 		if (read_out != NULL) {
 			valid = read_out->valid;
 			value = *(read_out->address);
@@ -79,7 +79,7 @@ protected:
 	 *
 	 */
 	ReturnValue_t commit() {
-		PoolEntry<T>* write_back = ::dataPool.getData<T>(dataPoolId, 1);
+		PoolEntry<T> *write_back = ::dataPool.getData < T > (dataPoolId, 1);
 		if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
 			write_back->valid = valid;
 			*(write_back->address) = value;
@@ -115,7 +115,7 @@ public:
 	 * \param setWritable If this flag is set to true, changes in the value attribute can be
 	 * 					written back to the data pool, otherwise not.
 	 */
-	PoolVariable(uint32_t set_id, DataSetIF* dataSet,
+	PoolVariable(uint32_t set_id, DataSetIF *dataSet,
 			ReadWriteMode_t setReadWriteMode) :
 			dataPoolId(set_id), valid(PoolVariableIF::INVALID), readWriteMode(
 					setReadWriteMode), value(0) {
@@ -126,7 +126,7 @@ public:
 	/**
 	 * Copy ctor to copy classes containing Pool Variables.
 	 */
-	PoolVariable(const PoolVariable& rhs) :
+	PoolVariable(const PoolVariable &rhs) :
 			dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode(
 					rhs.readWriteMode), value(rhs.value) {
 	}
@@ -184,29 +184,29 @@ public:
 		return value;
 	}
 
-	PoolVariable<T> &operator=(T newValue) {
+	PoolVariable<T>& operator=(T newValue) {
 		value = newValue;
 		return *this;
 	}
 
-	PoolVariable<T> &operator=(PoolVariable<T> newPoolVariable) {
+	PoolVariable<T>& operator=(PoolVariable<T> newPoolVariable) {
 		value = newPoolVariable.value;
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
-				bigEndian);
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t max_size, Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize<T>(&value, buffer, size, max_size,
+				streamEndianness);
 	}
 
-	virtual uint32_t getSerializedSize() const {
-		return SerializeAdapter<T>::getSerializedSize(&value);
+	virtual uint32_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 	}
 };
 
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
index d3617d17a..3809f93b5 100644
--- a/datapool/PoolVector.h
+++ b/datapool/PoolVector.h
@@ -202,7 +202,7 @@ public:
 		uint16_t i;
 		ReturnValue_t result;
 		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
+			result = SerializeAdapter::serialize(&(value[i]), buffer, size,
 					max_size, bigEndian);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
@@ -212,7 +212,7 @@ public:
 	}
 
 	virtual uint32_t getSerializedSize() const {
-		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
+		return vector_size * SerializeAdapter::getSerializedSize(value);
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
@@ -220,7 +220,7 @@ public:
 		uint16_t i;
 		ReturnValue_t result;
 		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
+			result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
 					bigEndian);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 2c9e820fe..55861c3cd 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -13,12 +13,12 @@ DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
 
 ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
 		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
-	ReturnValue_t result = SerializeAdapter<object_id_t>::serialize(&objectId,
+	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
 			buffer, size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<ActionId_t>::serialize(&actionId, buffer,
+	result = SerializeAdapter::serialize(&actionId, buffer,
 			size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -32,12 +32,12 @@ uint32_t DeviceTmReportingWrapper::getSerializedSize() const {
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
 		int32_t* size, bool bigEndian) {
-	ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
 			buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<ActionId_t>::deSerialize(&actionId, buffer,
+	result = SerializeAdapter::deSerialize(&actionId, buffer,
 			size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index 814d26f4e..b7b7fd82f 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -68,13 +68,13 @@ ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&ptc, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&ptc, buffer, size, max_size,
 			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&pfc, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&pfc, buffer, size, max_size,
 			bigEndian);
 
 	return result;
@@ -83,20 +83,20 @@ ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
 
 uint32_t Type::getSerializedSize() const {
 	uint8_t dontcare = 0;
-	return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
+	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
 }
 
 ReturnValue_t Type::deSerialize(const uint8_t** buffer, int32_t* size,
 		bool bigEndian) {
 	uint8_t ptc;
 	uint8_t pfc;
-	ReturnValue_t result = SerializeAdapter<uint8_t>::deSerialize(&ptc, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
 			size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::deSerialize(&pfc, buffer, size,
+	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
 			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 88df07b6f..3ec250b01 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -22,7 +22,7 @@ public:
 
 	Type(ActualType_t actualType);
 
-	Type(const Type& type);
+	Type(const Type &type);
 
 	Type& operator=(Type rhs);
 
@@ -30,8 +30,8 @@ public:
 
 	operator ActualType_t() const;
 
-	bool operator==(const Type& rhs);
-	bool operator!=(const Type& rhs);
+	bool operator==(const Type &rhs);
+	bool operator!=(const Type &rhs);
 
 	uint8_t getSize() const;
 
@@ -39,13 +39,13 @@ public:
 
 	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override;
 
 private:
 	ActualType_t actualType;
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 398cf3f0b..0ee3890ba 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -49,7 +49,7 @@ public:
 			const uint32_t max_size, bool bigEndian) const {
 		iterator iter = this->begin();
 		uint8_t count = this->countRight(iter);
-		ReturnValue_t result = SerializeAdapter<uint8_t>::serialize(&count,
+		ReturnValue_t result = SerializeAdapter::serialize(&count,
 				buffer, size, max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index 10e07173b..c30406f67 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -4,7 +4,6 @@
 #include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
 #include <framework/serialize/SerializeAdapter.h>
 
-
 template<typename T>
 class RangeMatcher: public SerializeableMatcherIF<T> {
 public:
@@ -27,34 +26,40 @@ public:
 		}
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t max_size,
+			SerializeIF::Endianness streamEndianness) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
+				size, max_size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::serialize(&upperBound, buffer, size, max_size, bigEndian);
+		result = SerializeAdapter::serialize(&upperBound, buffer, size,
+				max_size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::serialize(&inverted, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&inverted, buffer, size, max_size,
+				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const {
+	uint32_t getSerializedSize() const override {
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound, buffer, size, bigEndian);
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
+				buffer, size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::deSerialize(&upperBound, buffer, size, bigEndian);
+		result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::deSerialize(&inverted, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&inverted, buffer, size,
+				streamEndianness);
 	}
 protected:
 	bool doMatch(T input) {
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index a575b2828..48ee6679c 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -67,16 +67,16 @@ void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
 	mutex->lockMutex(MutexIF::NO_TIMEOUT);
 	uint32_t size = 0;
 	uint16_t count = healthMap.size();
-	ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
+	ReturnValue_t result = SerializeAdapter::serialize(&count,
 			&pointer, &size, maxSize, true);
 	HealthMap::iterator iter;
 	for (iter = healthMap.begin();
 			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
 			++iter) {
-		result = SerializeAdapter<object_id_t>::serialize(&iter->first,
+		result = SerializeAdapter::serialize(&iter->first,
 				&pointer, &size, maxSize, true);
 		uint8_t health = iter->second;
-		result = SerializeAdapter<uint8_t>::serialize(&health, &pointer, &size,
+		result = SerializeAdapter::serialize(&health, &pointer, &size,
 				maxSize, true);
 	}
 	mutex->unlockMutex();
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 698300843..c89fd5a44 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -53,7 +53,7 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 		memcpy(copyHere, dataToCopy, size);
 		break;
 	case HasMemoryIF::POINTS_TO_VARIABLE:
-		EndianSwapper::swap(copyHere, dataToCopy, size);
+		EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
 		break;
 	case HasMemoryIF::ACTIVITY_COMPLETED:
 	case RETURN_OK:
@@ -86,7 +86,7 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
 	case HasMemoryIF::POINTS_TO_VARIABLE:
 		//"data" must be valid pointer!
 		if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
-			EndianSwapper::swap(reservedSpaceInIPC, dataToCopy, size);
+			EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
 		} else {
 			memcpy(reservedSpaceInIPC, dataToCopy, size);
 		}
@@ -136,7 +136,7 @@ void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
 	}
 
 	while (totalSize > 0){
-		EndianSwapper::swap(out,in,datatypeSize);
+		EndianConverter::convertBigEndian(out,in,datatypeSize);
 		out += datatypeSize;
 		in += datatypeSize;
 		totalSize -= datatypeSize;
diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index 9fc34ff18..903a4d0ed 100644
--- a/osal/rtems/CpuUsage.cpp
+++ b/osal/rtems/CpuUsage.cpp
@@ -91,7 +91,7 @@ void CpuUsage::clear() {
 
 ReturnValue_t CpuUsage::serialize(uint8_t** buffer, uint32_t* size,
 		const uint32_t max_size, bool bigEndian) const {
-	ReturnValue_t result = SerializeAdapter<float>::serialize(
+	ReturnValue_t result = SerializeAdapter::serialize(
 			&timeSinceLastReset, buffer, size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -111,7 +111,7 @@ uint32_t CpuUsage::getSerializedSize() const {
 
 ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, int32_t* size,
 		bool bigEndian) {
-	ReturnValue_t result = SerializeAdapter<float>::deSerialize(
+	ReturnValue_t result = SerializeAdapter::deSerialize(
 			&timeSinceLastReset, buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -122,7 +122,7 @@ ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, int32_t* size,
 
 ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, uint32_t* size,
 		const uint32_t max_size, bool bigEndian) const {
-	ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&id, buffer,
+	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
 			size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -133,12 +133,12 @@ ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, uint32_t* size,
 	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
 	*size += MAX_LENGTH_OF_THREAD_NAME;
 	*buffer += MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter<float>::serialize(&timeRunning,
+	result = SerializeAdapter::serialize(&timeRunning,
 			buffer, size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<float>::serialize(&percentUsage,
+	result = SerializeAdapter::serialize(&percentUsage,
 			buffer, size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -159,7 +159,7 @@ uint32_t CpuUsage::ThreadData::getSerializedSize() const {
 
 ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
 		int32_t* size, bool bigEndian) {
-	ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&id, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
 			size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -169,12 +169,12 @@ ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
 	}
 	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
 	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter<float>::deSerialize(&timeRunning,
+	result = SerializeAdapter::deSerialize(&timeRunning,
 			buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<float>::deSerialize(&percentUsage,
+	result = SerializeAdapter::deSerialize(&percentUsage,
 			buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 8f661bb32..9dcbc6d58 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -24,18 +24,18 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
 		const uint32_t max_size, bool bigEndian) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&type, buffer, size, max_size,
 			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
+	result = SerializeAdapter::serialize(&columns, buffer, size,
 			max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::serialize(&rows, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&rows, buffer, size, max_size,
 			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -94,7 +94,7 @@ ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, uint32_t* size,
 	ReturnValue_t result;
 	uint16_t dataSize = columns * rows;
 	while (dataSize != 0) {
-		result = SerializeAdapter<T>::serialize(element, buffer, size, max_size,
+		result = SerializeAdapter::serialize(element, buffer, size, max_size,
 				bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
@@ -123,7 +123,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 				+ (((startingRow + fromRow) * columns) + startingColumn);
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
-			result = SerializeAdapter<T>::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
 					true);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -155,18 +155,18 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
 
 ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
 		const uint8_t **remainingStream, int32_t *remainingSize) {
-	ReturnValue_t result = SerializeAdapter<Type>::deSerialize(&type, &stream,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
 			&streamSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::deSerialize(&columns, &stream,
+	result = SerializeAdapter::deSerialize(&columns, &stream,
 			&streamSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::deSerialize(&rows, &stream, &streamSize,
+	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
 			true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index f61786b8a..e6d29c59b 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -54,7 +54,7 @@ public:
 			const uint8_t *streamWithtype = (const uint8_t *) readonlyData;
 			streamWithtype += (row * columns + column) * type.getSize();
 			int32_t size = type.getSize();
-			return SerializeAdapter<T>::deSerialize(value, &streamWithtype,
+			return SerializeAdapter::deSerialize(value, &streamWithtype,
 					&size, true);
 		} else {
 			const T *dataWithType = (const T *) readonlyData;
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 6a87d88b8..53bb06c8e 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -19,12 +19,12 @@ PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, f
 
 ReturnValue_t PowerComponent::serialize(uint8_t** buffer, uint32_t* size,
 		const uint32_t max_size, bool bigEndian) const {
-	ReturnValue_t result = SerializeAdapter<float>::serialize(&min, buffer,
+	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
 			size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter<float>::serialize(&max, buffer, size, max_size,
+	return SerializeAdapter::serialize(&max, buffer, size, max_size,
 			bigEndian);
 }
 
@@ -58,12 +58,12 @@ float PowerComponent::getMax() {
 
 ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, int32_t* size,
 bool bigEndian) {
-	ReturnValue_t result = SerializeAdapter<float>::deSerialize(&min, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
 			size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter<float>::deSerialize(&max, buffer, size, bigEndian);
+	return SerializeAdapter::deSerialize(&max, buffer, size, bigEndian);
 }
 
 ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index 6ff544447..e142c2a15 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -5,20 +5,20 @@
 #include <cstring>
 #include <iostream>
 
-class EndianSwapper {
+class EndianConverter {
 private:
-	EndianSwapper() {
+	EndianConverter() {
 	}
 	;
 public:
 	template<typename T>
-	static T swap(T in) {
+	static T convertBigEndian(T in) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
 		T tmp;
-		uint8_t *pointerOut = (uint8_t *) &tmp;
-		uint8_t *pointerIn = (uint8_t *) &in;
+		uint8_t *pointerOut = (uint8_t*) &tmp;
+		uint8_t *pointerIn = (uint8_t*) &in;
 		for (uint8_t count = 0; count < sizeof(T); count++) {
 			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
 		}
@@ -29,7 +29,8 @@ public:
 #error Unknown Byte Order
 #endif
 	}
-	static void swap(uint8_t* out, const uint8_t* in, uint32_t size) {
+	static void convertBigEndian(uint8_t *out, const uint8_t *in,
+			uint32_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
@@ -40,6 +41,39 @@ public:
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 		memcpy(out, in, size);
 		return;
+#endif
+	}
+
+	template<typename T>
+	static T convertLittleEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			T tmp;
+			uint8_t *pointerOut = (uint8_t *) &tmp;
+			uint8_t *pointerIn = (uint8_t *) &in;
+			for (uint8_t count = 0; count < sizeof(T); count++) {
+				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+			}
+			return tmp;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		return in;
+#else
+	#error Unknown Byte Order
+	#endif
+	}
+	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
+			uint32_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			for (uint8_t count = 0; count < size; count++) {
+				out[size - count - 1] = in[count];
+			}
+			return;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		memcpy(out, in, size);
+		return;
 #endif
 	}
 };
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 5ffbc3757..ab0c6c6f3 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -27,11 +27,11 @@ public:
 
 	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) {
-		ReturnValue_t result = SerializeAdapter<count_t>::serialize(&list->size,
+		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
 				buffer, size, max_size, bigEndian);
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter<T>::serialize(&list->entries[i], buffer, size,
+			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
 					max_size, bigEndian);
 			++i;
 		}
@@ -47,7 +47,7 @@ public:
 		count_t i = 0;
 
 		for (i = 0; i < list->size; ++i) {
-			printSize += SerializeAdapter<T>::getSerializedSize(&list->entries[i]);
+			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
 		}
 
 		return printSize;
@@ -61,7 +61,7 @@ public:
 	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
 		count_t tempSize = 0;
-		ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
 				buffer, size, bigEndian);
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
@@ -69,7 +69,7 @@ public:
 		list->size = tempSize;
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter<T>::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					&list->front()[i], buffer, size,
 					bigEndian);
 			++i;
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 3ed083bf5..f78ec8ace 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -26,14 +26,14 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size
 		const uint32_t max_size, bool bigEndian) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
-		serializedLength += AutoSerializeAdapter::getSerializedSize(
+		serializedLength += SerializeAdapter::getSerializedSize(
 				&bufferLength);
 	}
 	if (*size + serializedLength > max_size) {
 		return BUFFER_TOO_SHORT;
 	} else {
 		if (serializeLength) {
-			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
+			SerializeAdapter::serialize(&bufferLength, buffer, size,
 					max_size, bigEndian);
 		}
 		if (this->constBuffer != NULL) {
@@ -52,7 +52,7 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size
 template<typename T>
 uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
 	if (serializeLength) {
-		return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
+		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
 		return bufferLength;
 	}
@@ -63,7 +63,7 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
 		if(serializeLength){
-			T serializedSize = AutoSerializeAdapter::getSerializedSize(
+			T serializedSize = SerializeAdapter::getSerializedSize(
 					&bufferLength);
 			if((*size - bufferLength - serializedSize) >= 0){
 				*buffer +=  serializedSize;
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 29952c4a3..7b10e3317 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -31,32 +31,32 @@ public:
 			SinglyLinkedList<T>(), printCount(printCount) {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override {
 		if (printCount) {
 			count_t mySize = SinglyLinkedList<T>::getSize();
-			ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize,
-					buffer, size, max_size, bigEndian);
+			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
+					buffer, size, maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
 		}
-		return serialize(SinglyLinkedList<T>::start, buffer, size, max_size,
-				bigEndian);
+		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
+				streamEndianness);
 	}
 
 	static ReturnValue_t serialize(const LinkedElement<T>* element,
-			uint8_t** buffer, uint32_t* size, const uint32_t max_size,
-			bool bigEndian) {
+			uint8_t** buffer, size_t* size, size_t maxSize,
+			Endianness streamEndianness) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			result = element->value->serialize(buffer, size, max_size,
-					bigEndian);
+			result = element->value->serialize(buffer, size, maxSize,
+					streamEndianness);
 			element = element->getNext();
 		}
 		return result;
 	}
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const override {
 		if (printCount) {
 			return SerialLinkedListAdapter<T>::getSerializedSize()
 					+ sizeof(count_t);
@@ -64,8 +64,8 @@ public:
 			return getSerializedSize(SinglyLinkedList<T>::start);
 		}
 	}
-	static uint32_t getSerializedSize(const LinkedElement<T> *element) {
-		uint32_t size = 0;
+	static size_t getSerializedSize(const LinkedElement<T> *element) {
+		size_t size = 0;
 		while (element != NULL) {
 			size += element->value->getSerializedSize();
 			element = element->getNext();
@@ -73,16 +73,16 @@ public:
 		return size;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override {
+		return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
 	}
 
 	static ReturnValue_t deSerialize(LinkedElement<T>* element,
-			const uint8_t** buffer, int32_t* size, bool bigEndian) {
+			const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			result = element->value->deSerialize(buffer, size, bigEndian);
+			result = element->value->deSerialize(buffer, size, streamEndianness);
 			element = element->getNext();
 		}
 		return result;
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index fd9e1b6af..73323c2a9 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -10,116 +10,114 @@
 /**
  * \ingroup serialize
  */
-template<typename T, int>
-class SerializeAdapter_ {
-public:
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
-		uint32_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		if (sizeof(T) + *size <= max_size) {
-			T tmp;
-			if (bigEndian) {
-				tmp = EndianSwapper::swap<T>(*object);
-			} else {
-				tmp = *object;
-			}
-			memcpy(*buffer, &tmp, sizeof(T));
-			*size += sizeof(T);
-			(*buffer) += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::BUFFER_TOO_SHORT;
-		}
-	}
 
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		T tmp;
-		*size -= sizeof(T);
-		if (*size >= 0) {
-			memcpy(&tmp, *buffer, sizeof(T));
-			if (bigEndian) {
-				*object = EndianSwapper::swap<T>(tmp);
-			} else {
-				*object = tmp;
-			}
-			*buffer += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::STREAM_TOO_SHORT;
-		}
-	}
-
-	uint32_t getSerializedSize(const T * object) {
-		return sizeof(T);
-	}
-
-};
-
-template<typename T>
-class SerializeAdapter_<T, 1> {
-public:
-	ReturnValue_t serialize(const T* object, uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		uint32_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		return object->serialize(buffer, size, max_size, bigEndian);
-	}
-	uint32_t getSerializedSize(const T* object) const {
-		return object->getSerializedSize();
-	}
-
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return object->deSerialize(buffer, size, bigEndian);
-	}
-};
-
-template<typename T>
 class SerializeAdapter {
-public:
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.serialize(object, buffer, size, max_size, bigEndian);
-	}
-	static uint32_t getSerializedSize(const T* object) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.getSerializedSize(object);
-	}
-
-	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			int32_t* size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.deSerialize(object, buffer, size, bigEndian);
-	}
-};
-
-
-class AutoSerializeAdapter {
 public:
 	template<typename T>
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.serialize(object, buffer, size, max_size, bigEndian);
+	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;
+		return adapter.serialize(object, buffer, size, maxSize,
+				streamEndianness);
 	}
 	template<typename T>
-	static uint32_t getSerializedSize(const T* object) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+	static uint32_t getSerializedSize(const T *object) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.getSerializedSize(object);
 	}
 	template<typename T>
-	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			int32_t* size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.deSerialize(object, buffer, size, bigEndian);
+	static ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+			size_t *size, SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.deSerialize(object, buffer, size, streamEndianness);
 	}
+private:
+	template<typename T, int>
+	class InternalSerializeAdapter {
+	public:
+		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
+			size_t ignoredSize = 0;
+			if (size == NULL) {
+				size = &ignoredSize;
+			}
+			//TODO check integer overflow of *size
+			if (sizeof(T) + *size <= max_size) {
+				T tmp;
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					tmp = EndianConverter::convertBigEndian<T>(*object);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					tmp = EndianConverter::convertLittleEndian<T>(*object);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					tmp = *object;
+					break;
+				}
+				memcpy(*buffer, &tmp, sizeof(T));
+				*size += sizeof(T);
+				(*buffer) += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::BUFFER_TOO_SHORT;
+			}
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			T tmp;
+			if (*size >= sizeof(T)) {
+				*size -= sizeof(T);
+				memcpy(&tmp, *buffer, sizeof(T));
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					*object = EndianConverter::convertBigEndian<T>(tmp);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					*object = EndianConverter::convertLittleEndian<T>(tmp);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					*object = tmp;
+					break;
+				}
+
+				*buffer += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::STREAM_TOO_SHORT;
+			}
+		}
+
+		uint32_t getSerializedSize(const T *object) {
+			return sizeof(T);
+		}
+
+	};
+
+	template<typename T>
+	class InternalSerializeAdapter<T, 1> {
+	public:
+		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) {
+				size = &ignoredSize;
+			}
+			return object->serialize(buffer, size, max_size, streamEndianness);
+		}
+		uint32_t getSerializedSize(const T *object) const {
+			return object->getSerializedSize();
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			return object->deSerialize(buffer, size, streamEndianness);
+		}
+	};
 };
 
 #endif /* SERIALIZEADAPTER_H_ */
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index db7db20a9..22e9838c9 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -9,41 +9,43 @@
  * \ingroup serialize
  */
 template<typename T>
-class SerializeElement : public SerializeIF, public LinkedElement<SerializeIF> {
+class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
 public:
-	template<typename... Args>
-	SerializeElement(Args... args) : LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
+	template<typename ... Args>
+	SerializeElement(Args ... args) :
+			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
 
 	}
-	SerializeElement() : LinkedElement<SerializeIF>(this) {
+	SerializeElement() :
+			LinkedElement<SerializeIF>(this) {
 	}
 	T entry;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<T>::serialize(&entry, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
+				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const {
-		return SerializeAdapter<T>::getSerializedSize(&entry);
+	uint32_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&entry);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&entry, buffer, size,
+				streamEndianness);
 	}
 	operator T() {
 		return entry;
 	}
 
-	SerializeElement<T> &operator=(T newValue) {
+	SerializeElement<T>& operator=(T newValue) {
 		entry = newValue;
 		return *this;
 	}
-	T *operator->() {
+	T* operator->() {
 		return &entry;
 	}
 };
 
-
-
 #endif /* SERIALIZEELEMENT_H_ */
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 701fbf563..6c875a5c7 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -2,6 +2,7 @@
 #define SERIALIZEIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <stddef.h>
 
 /**
  * \defgroup serialize Serialization
@@ -14,6 +15,10 @@
  */
 class SerializeIF {
 public:
+	enum class Endianness : uint8_t {
+		BIG, LITTLE, MACHINE
+	};
+
 	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);
@@ -22,13 +27,13 @@ public:
 	virtual ~SerializeIF() {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const = 0;
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t max_size, Endianness streamEndianness) const = 0;
 
-	virtual uint32_t getSerializedSize() const = 0;
+	virtual size_t getSerializedSize() const = 0;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) = 0;
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) = 0;
 
 };
 
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index e1ec544b0..ef706dd76 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -169,7 +169,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 		if (result == RETURN_OK) {
 			Mode_t fallbackId;
 			int32_t size = sizeRead;
-			result = SerializeAdapter<Mode_t>::deSerialize(&fallbackId,
+			result = SerializeAdapter::deSerialize(&fallbackId,
 					&pointer, &size, true);
 			if (result == RETURN_OK) {
 				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 8e7531f3d..3e749dd80 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -23,26 +23,26 @@ public:
 
 		ReturnValue_t result;
 
-		result = SerializeAdapter<uint32_t>::serialize(&value1, buffer, size,
+		result = SerializeAdapter::serialize(&value1, buffer, size,
 				max_size, bigEndian);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint32_t>::serialize(&value2, buffer, size,
+		result = SerializeAdapter::serialize(&value2, buffer, size,
 				max_size, bigEndian);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::serialize(&value3, buffer, size,
+		result = SerializeAdapter::serialize(&value3, buffer, size,
 				max_size, bigEndian);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 
-		result = SerializeAdapter<uint8_t>::serialize(&value4, buffer, size,
+		result = SerializeAdapter::serialize(&value4, buffer, size,
 				max_size, bigEndian);
 
 		return result;
@@ -57,25 +57,25 @@ public:
 	bool bigEndian) {
 		ReturnValue_t result;
 
-		result = SerializeAdapter<uint32_t>::deSerialize(&value1, buffer, size,
+		result = SerializeAdapter::deSerialize(&value1, buffer, size,
 				bigEndian);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint32_t>::deSerialize(&value2, buffer, size,
+		result = SerializeAdapter::deSerialize(&value2, buffer, size,
 				bigEndian);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::deSerialize(&value3, buffer, size,
+		result = SerializeAdapter::deSerialize(&value3, buffer, size,
 				bigEndian);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::deSerialize(&value4, buffer, size,
+		result = SerializeAdapter::deSerialize(&value4, buffer, size,
 				bigEndian);
 
 		return result;
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index bf6f73986..93513e16e 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -47,13 +47,13 @@ ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
 		return MonitoringIF::INVALID_SIZE;
 	}
 	int32_t readSize = size;
-	SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
+	SerializeAdapter::deSerialize(&nopParameters.lowerNopLimit, &data,
 			&readSize, true);
-	SerializeAdapter<float>::deSerialize(&parameters.lowerOpLimit, &data,
+	SerializeAdapter::deSerialize(&parameters.lowerOpLimit, &data,
 			&readSize, true);
-	SerializeAdapter<float>::deSerialize(&parameters.upperOpLimit, &data,
+	SerializeAdapter::deSerialize(&parameters.upperOpLimit, &data,
 			&readSize, true);
-	SerializeAdapter<float>::deSerialize(&nopParameters.upperNopLimit, &data,
+	SerializeAdapter::deSerialize(&nopParameters.upperNopLimit, &data,
 			&readSize, true);
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 6eea6f586..4e7160fb2 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -34,12 +34,12 @@ public:
 	uint16_t ssc;
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&apid,
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,
 				buffer, size, max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<uint16_t>::serialize(&ssc, buffer, size,
+		return SerializeAdapter::serialize(&ssc, buffer, size,
 				max_size, bigEndian);
 
 	}
@@ -50,12 +50,12 @@ public:
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 	bool bigEndian) {
-		ReturnValue_t result = SerializeAdapter<uint16_t>::deSerialize(&apid,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
 				buffer, size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<uint16_t>::deSerialize(&ssc, buffer, size,
+		return SerializeAdapter::deSerialize(&ssc, buffer, size,
 				bigEndian);
 	}
 };
@@ -220,23 +220,23 @@ public:
 
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = AutoSerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian);
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&subCounter,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&subCounter,buffer,size,max_size,bigEndian);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -246,11 +246,11 @@ public:
 
 	uint32_t getSerializedSize() const {
 		uint32_t size = 0;
-		size += AutoSerializeAdapter::getSerializedSize(&apid);
-		size += AutoSerializeAdapter::getSerializedSize(&sourceSequenceCount);
-		size += AutoSerializeAdapter::getSerializedSize(&serviceType);
-		size += AutoSerializeAdapter::getSerializedSize(&serviceSubtype);
-		size += AutoSerializeAdapter::getSerializedSize(&subCounter);
+		size += SerializeAdapter::getSerializedSize(&apid);
+		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
+		size += SerializeAdapter::getSerializedSize(&serviceType);
+		size += SerializeAdapter::getSerializedSize(&serviceSubtype);
+		size += SerializeAdapter::getSerializedSize(&subCounter);
 		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
 		size += adapter.getSerializedSize();
 		return size;
@@ -259,27 +259,27 @@ public:
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 	bool bigEndian) {
-		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&apid, buffer,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
 				size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
+		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
 				size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&serviceType, buffer, size,
+		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
 				bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&serviceSubtype, buffer,
+		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
 				size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&subCounter, buffer, size,
+		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
 				bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 1f1949682..d5d96f2d4 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -24,14 +24,14 @@ public:
 	}
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<uint16_t>::serialize(&apid, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&apid, buffer, size, max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
-		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
+		return SerializeAdapter::getSerializedSize(&apid);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&apid, buffer, size, bigEndian);
 	}
 };
 
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index 1a6781b40..b06237803 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -24,14 +24,14 @@ public:
 	}
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<uint8_t>::serialize(&service, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&service, buffer, size, max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
-		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
+		return SerializeAdapter::getSerializedSize(&service);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&service, buffer, size, bigEndian);
 	}
 };
 
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 1b589b201..90370af1f 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -22,14 +22,14 @@ public:
 	}
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&subService, buffer, size, max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
-		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
+		return SerializeAdapter::getSerializedSize(&subService);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&subService, buffer, size, bigEndian);
 	}
 private:
 	uint8_t subService;
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index d70b90428..5b9e7b68e 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -236,7 +236,7 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
 	uint8_t buffer[sizeof(object_id_t)];
 	uint8_t* pBuffer = buffer;
 	uint32_t size = 0;
-	SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
+	SerializeAdapter::serialize(&objectId, &pBuffer, &size,
 			sizeof(object_id_t), true);
 	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
 			this->tmPacketCounter, data, dataLen, buffer, size);
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index 1bc53c2a8..e1dad2bea 100644
--- a/tmtcservices/PusVerificationReport.cpp
+++ b/tmtcservices/PusVerificationReport.cpp
@@ -108,12 +108,12 @@ PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
 		uint16_t setSequenceControl, uint8_t setStep) :
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter<uint16_t>::serialize(&setPacketId, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
 			sizeof(reportBuffer), true);
-	SerializeAdapter<uint16_t>::serialize(&setSequenceControl, &pBuffer,
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer,
 			&reportSize, sizeof(reportBuffer), true);
 	if (setStep != 0) {
-		SerializeAdapter<uint8_t>::serialize(&setStep, &pBuffer, &reportSize,
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
 				sizeof(reportBuffer), true);
 	}
 }
@@ -135,19 +135,19 @@ PusFailureReport::PusFailureReport(uint16_t setPacketId,
 		uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter<uint16_t>::serialize(&setPacketId, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
 			sizeof(reportBuffer), true);
-	SerializeAdapter<uint16_t>::serialize(&setSequenceControl, &pBuffer,
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer,
 			&reportSize, sizeof(reportBuffer), true);
 	if (setStep != 0) {
-		SerializeAdapter<uint8_t>::serialize(&setStep, &pBuffer, &reportSize,
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
 				sizeof(reportBuffer), true);
 	}
-	SerializeAdapter<ReturnValue_t>::serialize(&setErrorCode, &pBuffer,
+	SerializeAdapter::serialize(&setErrorCode, &pBuffer,
 			&reportSize, sizeof(reportBuffer), true);
-	SerializeAdapter<uint32_t>::serialize(&parameter1, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
 			sizeof(reportBuffer), true);
-	SerializeAdapter<uint32_t>::serialize(&parameter2, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
 			sizeof(reportBuffer), true);
 }
 

From 6553450b4b85ea7ec53e88850195af35d76d85b2 Mon Sep 17 00:00:00 2001
From: Uli <uli@vnks.de>
Date: Tue, 21 Apr 2020 22:28:43 +0200
Subject: [PATCH 0190/1774] Actually, not that horrible, thanks to sed

---
 action/ActionHelper.cpp                      |   6 +-
 action/CommandActionHelper.cpp               |  39 ++++---
 container/FixedMap.h                         |  22 ++--
 container/IndexedRingMemoryArray.h           |  60 +++++------
 datapool/DataPool.cpp                        |   4 +-
 datapool/DataPoolAdmin.cpp                   |   6 +-
 datapool/DataPoolParameterWrapper.cpp        |  20 ++--
 datapool/DataPoolParameterWrapper.h          |  10 +-
 datapool/DataSet.cpp                         |  18 ++--
 datapool/DataSet.h                           |  10 +-
 datapool/PoolRawAccess.cpp                   |   6 +-
 datapool/PoolRawAccess.h                     |   6 +-
 datapool/PoolVariable.h                      |   6 +-
 datapool/PoolVector.h                        |  14 +--
 devicehandlers/DeviceTmReportingWrapper.cpp  |  18 ++--
 devicehandlers/DeviceTmReportingWrapper.h    |  10 +-
 events/eventmatching/EventRangeMatcherBase.h |  14 +--
 globalfunctions/Type.cpp                     |  22 ++--
 globalfunctions/conversion.cpp               | 104 -------------------
 globalfunctions/conversion.h                 |  24 -----
 globalfunctions/matching/MatchTree.h         |  20 ++--
 globalfunctions/matching/RangeMatcher.h      |  10 +-
 health/HealthTable.cpp                       |  10 +-
 health/HealthTable.h                         |   2 +-
 monitoring/LimitViolationReporter.cpp        |   6 +-
 osal/rtems/CpuUsage.cpp                      |  36 +++----
 osal/rtems/CpuUsage.h                        |  20 ++--
 parameters/ParameterHelper.cpp               |   6 +-
 parameters/ParameterWrapper.cpp              |  92 ++++++++--------
 parameters/ParameterWrapper.h                |  22 ++--
 power/Fuse.cpp                               |  14 +--
 power/Fuse.h                                 |  27 ++---
 power/PowerComponent.cpp                     |  20 ++--
 power/PowerComponent.h                       |  10 +-
 serialize/SerialArrayListAdapter.h           |  30 +++---
 serialize/SerialBufferAdapter.cpp            |  12 +--
 serialize/SerialBufferAdapter.h              |  10 +-
 serialize/SerialFixedArrayListAdapter.h      |  14 +--
 serialize/SerializeElement.h                 |   2 +-
 serialize/SerializeIF.h                      |   2 +-
 subsystem/Subsystem.cpp                      |  39 ++++---
 subsystem/modes/ModeDefinitions.h            |  26 ++---
 thermal/ThermalComponent.cpp                 |  10 +-
 tmstorage/TmStorePackets.h                   |  52 +++++-----
 tmtcpacket/packetmatcher/ApidMatcher.h       |  14 +--
 tmtcpacket/packetmatcher/ServiceMatcher.h    |  14 +--
 tmtcpacket/packetmatcher/SubserviceMatcher.h |  14 +--
 tmtcpacket/pus/TmPacketStored.cpp            |  33 +++---
 tmtcservices/CommandingServiceBase.cpp       |   4 +-
 tmtcservices/PusVerificationReport.cpp       |  28 ++---
 tmtcservices/PusVerificationReport.h         |   6 +-
 51 files changed, 458 insertions(+), 566 deletions(-)
 delete mode 100644 globalfunctions/conversion.cpp
 delete mode 100644 globalfunctions/conversion.h

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 9c1475f12..f93afaa8c 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -71,18 +71,18 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
 	CommandMessage reply;
 	store_address_t storeAddress;
 	uint8_t *dataPtr;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	if (maxSize == 0) {
 		//No error, there's simply nothing to report.
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
 			&dataPtr);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = data->serialize(&dataPtr, &size, maxSize, true);
+	result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		ipcStore->deleteData(storeAddress);
 		return result;
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index 05eb93461..6a26453c1 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -4,30 +4,31 @@
 #include <framework/action/HasActionsIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 
-CommandActionHelper::CommandActionHelper(CommandsActionsIF* setOwner) :
+CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
 		owner(setOwner), queueToUse(NULL), ipcStore(
-				NULL), commandCount(0), lastTarget(0) {
+		NULL), commandCount(0), lastTarget(0) {
 }
 
 CommandActionHelper::~CommandActionHelper() {
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, SerializeIF* data) {
-	HasActionsIF* receiver = objectManager->get<HasActionsIF>(commandTo);
+		ActionId_t actionId, SerializeIF *data) {
+	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
 	if (receiver == NULL) {
 		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
 	}
 	store_address_t storeId;
-	uint8_t* storePointer;
-	uint32_t maxSize = data->getSerializedSize();
+	uint8_t *storePointer;
+	size_t maxSize = data->getSerializedSize();
 	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
 			&storePointer);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	uint32_t size = 0;
-	result = data->serialize(&storePointer, &size, maxSize, true);
+	size_t size = 0;
+	result = data->serialize(&storePointer, &size, maxSize,
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -35,11 +36,11 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, const uint8_t* data, uint32_t size) {
+		ActionId_t actionId, const uint8_t *data, uint32_t size) {
 //	if (commandCount != 0) {
 //		return CommandsFunctionsIF::ALREADY_COMMANDING;
 //	}
-	HasActionsIF* receiver = objectManager->get<HasActionsIF>(commandTo);
+	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
 	if (receiver == NULL) {
 		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
 	}
@@ -71,13 +72,13 @@ ReturnValue_t CommandActionHelper::initialize() {
 	}
 
 	queueToUse = owner->getCommandQueuePtr();
-	if(queueToUse == NULL){
+	if (queueToUse == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
+ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
 	if (reply->getSender() != lastTarget) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -88,7 +89,8 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::COMPLETION_FAILED:
 		commandCount--;
-		owner->completionFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getReturnCode(reply));
+		owner->completionFailedReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getReturnCode(reply));
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::STEP_SUCCESS:
 		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
@@ -96,11 +98,13 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::STEP_FAILED:
 		commandCount--;
-		owner->stepFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getStep(reply),
+		owner->stepFailedReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getStep(reply),
 				ActionMessage::getReturnCode(reply));
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::DATA_REPLY:
-		extractDataForOwner(ActionMessage::getActionId(reply), ActionMessage::getStoreId(reply));
+		extractDataForOwner(ActionMessage::getActionId(reply),
+				ActionMessage::getStoreId(reply));
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;
@@ -111,8 +115,9 @@ uint8_t CommandActionHelper::getCommandCount() const {
 	return commandCount;
 }
 
-void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-	const uint8_t * data = NULL;
+void CommandActionHelper::extractDataForOwner(ActionId_t actionId,
+		store_address_t storeId) {
+	const uint8_t *data = NULL;
 	uint32_t size = 0;
 	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/container/FixedMap.h b/container/FixedMap.h
index eaf8a24cd..ac170bd2a 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -148,22 +148,22 @@ public:
 		return theMap.maxSize();
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
 		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
 			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
-					size, max_size, bigEndian);
+					size, maxSize, streamEndianness);
 			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			++i;
 		}
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		uint32_t printSize = sizeof(_size);
 		uint32_t i = 0;
 
@@ -176,19 +176,19 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (this->_size > theMap.maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
 			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
-					size, bigEndian);
+					size, streamEndianness);
 			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		return result;
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 32b61c2d1..6e7f330cb 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -68,46 +68,46 @@ public:
 		return this->storedPackets;
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-				const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,max_size,bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = indexType.serialize(buffer,size,max_size,bigEndian);
+		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
 		return result;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-				bool bigEndian){
-		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness){
+		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = indexType.deSerialize(buffer,size,bigEndian);
+		result = indexType.deSerialize(buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		return result;
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
 		size += indexType.getSerializedSize();
 		size += SerializeAdapter::getSerializedSize(&this->size);
@@ -485,22 +485,22 @@ public:
 	 * Parameters according to HasSerializeIF
 	 * @param buffer
 	 * @param size
-	 * @param max_size
-	 * @param bigEndian
+	 * @param maxSize
+	 * @param streamEndianness
 	 * @return
 	 */
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-				const uint32_t max_size, bool bigEndian) const{
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const{
 		uint8_t* crcBuffer = *buffer;
 		uint32_t oldSize = *size;
 		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,max_size,bigEndian);
+			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
 		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,max_size,bigEndian);
+		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
@@ -508,14 +508,14 @@ public:
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
 			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			++i;
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = SerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
 		return result;
 	}
 
@@ -524,7 +524,7 @@ public:
 	 * Get the serialized Size of the index
 	 * @return The serialized size of the index
 	 */
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 
 		uint32_t size = 0;
 		if(additionalInfo!=NULL){
@@ -542,28 +542,28 @@ public:
 	 * CRC Has to be checked before!
 	 * @param buffer
 	 * @param size
-	 * @param bigEndian
+	 * @param streamEndianness
 	 * @return
 	 */
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-				bool bigEndian){
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness){
 
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,bigEndian);
+			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 
 		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,bigEndian);
+		result = tempIndex.deSerialize(buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 		uint32_t tempSize = 0;
-		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
@@ -574,7 +574,7 @@ public:
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
 			result = SerializeAdapter::deSerialize(
 					&this->entries[i], buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
diff --git a/datapool/DataPool.cpp b/datapool/DataPool.cpp
index 89543d776..6604dc23e 100644
--- a/datapool/DataPool.cpp
+++ b/datapool/DataPool.cpp
@@ -39,10 +39,10 @@ PoolEntryIF* DataPool::getRawData( uint32_t data_pool_id ) {
 	}
 }
 
-//uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t max_size ) {
+//uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t maxSize ) {
 //	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
 //	if ( it != this->data_pool.end() ) {
-//		if ( it->second->getByteSize() <= max_size ) {
+//		if ( it->second->getByteSize() <= maxSize ) {
 //			*size = it->second->getByteSize();
 //			memcpy( address, it->second->getRawData(), *size );
 //			return DP_SUCCESSFUL;
diff --git a/datapool/DataPoolAdmin.cpp b/datapool/DataPoolAdmin.cpp
index fe6b92152..8bf7f6b3e 100644
--- a/datapool/DataPoolAdmin.cpp
+++ b/datapool/DataPoolAdmin.cpp
@@ -261,7 +261,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 //identical to ParameterHelper::sendParameter()
 ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		const DataPoolParameterWrapper* wrapper) {
-	uint32_t serializedSize = wrapper->getSerializedSize();
+	size_t serializedSize = wrapper->getSerializedSize();
 
 	uint8_t *storeElement;
 	store_address_t address;
@@ -272,10 +272,10 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	uint32_t storeElementSize = 0;
+	size_t storeElementSize = 0;
 
 	result = wrapper->serialize(&storeElement, &storeElementSize,
-			serializedSize, true);
+			serializedSize, SerializeIF::Endianness::BIG);
 
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		storage->deleteData(address);
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index 10fb53921..e08eba5bb 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapool/DataPoolParameterWrapper.cpp
@@ -36,22 +36,22 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 }
 
 ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter::serialize(&type, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
 	result = SerializeAdapter::serialize(&columns, buffer, size,
-			max_size, bigEndian);
+			maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -60,7 +60,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 		DataSet mySet;
 		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
 		mySet.read();
-		result = raw.serialize(buffer,size,max_size,bigEndian);
+		result = raw.serialize(buffer,size,maxSize,streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -69,8 +69,8 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 }
 
 //same as ParameterWrapper
-uint32_t DataPoolParameterWrapper::getSerializedSize() const {
-	uint32_t serializedSize = 0;
+size_t DataPoolParameterWrapper::getSerializedSize() const {
+	size_t serializedSize = 0;
 	serializedSize += type.getSerializedSize();
 	serializedSize += sizeof(rows);
 	serializedSize += sizeof(columns);
@@ -80,7 +80,7 @@ uint32_t DataPoolParameterWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		size_t* size, Endianness streamEndianness) {
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/datapool/DataPoolParameterWrapper.h b/datapool/DataPoolParameterWrapper.h
index faadf6599..a3dbdc04d 100644
--- a/datapool/DataPoolParameterWrapper.h
+++ b/datapool/DataPoolParameterWrapper.h
@@ -11,13 +11,13 @@ public:
 
 	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
 			uint16_t startWritingAtIndex);
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index b4725c735..94cdcf0ce 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -106,12 +106,12 @@ uint8_t DataSet::lockDataPool() {
 	return ::dataPool.lockDataPool();
 }
 
-ReturnValue_t DataSet::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t DataSet::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->serialize(buffer, size, max_size,
-				bigEndian);
+		result = registeredVariables[count]->serialize(buffer, size, maxSize,
+				streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}
@@ -119,8 +119,8 @@ ReturnValue_t DataSet::serialize(uint8_t** buffer, uint32_t* size,
 	return result;
 }
 
-uint32_t DataSet::getSerializedSize() const {
-	uint32_t size = 0;
+size_t DataSet::getSerializedSize() const {
+	size_t size = 0;
 	for (uint16_t count = 0; count < fill_count; count++) {
 		size += registeredVariables[count]->getSerializedSize();
 	}
@@ -136,12 +136,12 @@ void DataSet::setValid(uint8_t valid) {
 	}
 }
 
-ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, int32_t* size,
-		bool bigEndian) {
+ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {
 		result = registeredVariables[count]->deSerialize(buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index 982be6928..3d2115379 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -146,13 +146,13 @@ public:
 	 */
 	void setValid(uint8_t valid);
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const override;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 
 };
 
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 2053498b1..94766d87e 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -69,12 +69,12 @@ uint8_t* PoolRawAccess::getEntry() {
 }
 
 ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		uint32_t* writtenBytes, uint32_t max_size) {
+		uint32_t* writtenBytes, uint32_t maxSize) {
 	uint8_t* data_ptr = getEntry();
 //	debug << "PoolRawAccess::getEntry: Array position: " << index * size_of_type << " Size of T: " << (int)size_of_type << " ByteSize: " << byte_size << " Position: " << *size << std::endl;
 	if (typeSize == 0)
 		return DATA_POOL_ACCESS_FAILED;
-	if (typeSize > max_size)
+	if (typeSize > maxSize)
 		return INCORRECT_SIZE;
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
@@ -149,7 +149,7 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
 		size_t maxSize, Endianness streamEndianness) const {
 	//TODO integer overflow
 	if (typeSize + *size <= maxSize) {
-#error use endian swapper
+#warning use endian swapper
 		if (1) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 190c38a99..8cc8f3f08 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -90,15 +90,15 @@ public:
 	 * \details	It makes use of the getEntry call of this function, but additionally flips the
 	 * 			bytes to big endian, which is the default for external communication (as House-
 	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given max_size.
+	 * 			buffer, if it fits in the given maxSize.
 	 * \param buffer	A pointer to a buffer to write to
 	 * \param writtenBytes	The number of bytes written is returned with this value.
-	 * \param max_size	The maximum size that the function may write to buffer.
+	 * \param maxSize	The maximum size that the function may write to buffer.
 	 * \return	- \c RETURN_OK if entry could be acquired
 	 * 			- \c RETURN_FAILED else.
 	 */
 	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, uint32_t *size,
-			uint32_t max_size);
+			uint32_t maxSize);
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
 	 * @param buffer	Pointer to the data to set
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index ce073426a..c1a57539e 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -195,12 +195,12 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t max_size, Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize<T>(&value, buffer, size, max_size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize<T>(&value, buffer, size, maxSize,
 				streamEndianness);
 	}
 
-	virtual uint32_t getSerializedSize() const override {
+	virtual size_t getSerializedSize() const override {
 		return SerializeAdapter::getSerializedSize(&value);
 	}
 
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
index 3809f93b5..507240545 100644
--- a/datapool/PoolVector.h
+++ b/datapool/PoolVector.h
@@ -197,13 +197,13 @@ public:
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
 		uint16_t i;
 		ReturnValue_t result;
 		for (i = 0; i < vector_size; i++) {
 			result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
@@ -211,17 +211,17 @@ public:
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return vector_size * SerializeAdapter::getSerializedSize(value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
 		uint16_t i;
 		ReturnValue_t result;
 		for (i = 0; i < vector_size; i++) {
 			result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
-					bigEndian);
+					streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 55861c3cd..ce5eb1094 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -12,35 +12,35 @@ DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
 }
 
 ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
-		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	result = SerializeAdapter::serialize(&actionId, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return data->serialize(buffer, size, max_size, bigEndian);
+	return data->serialize(buffer, size, maxSize, streamEndianness);
 }
 
-uint32_t DeviceTmReportingWrapper::getSerializedSize() const {
+size_t DeviceTmReportingWrapper::getSerializedSize() const {
 	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
 }
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		size_t* size, Endianness streamEndianness) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	result = SerializeAdapter::deSerialize(&actionId, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return data->deSerialize(buffer, size, bigEndian);
+	return data->deSerialize(buffer, size, streamEndianness);
 }
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index 1cd9470d8..4432b7f15 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -11,13 +11,13 @@ public:
 			SerializeIF *data);
 	virtual ~DeviceTmReportingWrapper();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 private:
 	object_id_t objectId;
 	ActionId_t actionId;
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index 921a5d6a1..587669ba5 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -11,16 +11,16 @@ class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
 public:
 	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
 	virtual ~EventRangeMatcherBase() { }
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return rangeMatcher.serialize(buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return rangeMatcher.getSerializedSize();
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return rangeMatcher.deSerialize(buffer, size, bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
 	}
 protected:
 	RangeMatcher<T> rangeMatcher;
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index b7b7fd82f..a481f7687 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -59,8 +59,8 @@ uint8_t Type::getSize() const {
 	}
 }
 
-ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	uint8_t ptc;
 	uint8_t pfc;
 	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
@@ -68,36 +68,36 @@ ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
 		return result;
 	}
 
-	result = SerializeAdapter::serialize(&ptc, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter::serialize(&pfc, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
+			streamEndianness);
 
 	return result;
 
 }
 
-uint32_t Type::getSerializedSize() const {
+size_t Type::getSerializedSize() const {
 	uint8_t dontcare = 0;
 	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
 }
 
-ReturnValue_t Type::deSerialize(const uint8_t** buffer, int32_t* size,
-		bool bigEndian) {
+ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
 	uint8_t ptc;
 	uint8_t pfc;
 	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
 	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/globalfunctions/conversion.cpp b/globalfunctions/conversion.cpp
deleted file mode 100644
index d4f542bd1..000000000
--- a/globalfunctions/conversion.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-#include <framework/globalfunctions/conversion.h>
-#include <framework/osal/Endiness.h>
-#include <cstring>
-
-
-
-//SHOULDDO: This shall be optimized (later)!
-void convertToByteStream( uint16_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF00) >> 8;
-	buffer[1] = (value & 0x00FF);
-	*size += 2;
-}
-
-void convertToByteStream( uint32_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF000000) >> 24;
-	buffer[1] = (value & 0x00FF0000) >> 16;
-	buffer[2] = (value & 0x0000FF00) >> 8;
-	buffer[3] = (value & 0x000000FF);
-	*size +=4;
-}
-
-void convertToByteStream( int16_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF00) >> 8;
-	buffer[1] = (value & 0x00FF);
-	*size += 2;
-}
-
-void convertToByteStream( int32_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF000000) >> 24;
-	buffer[1] = (value & 0x00FF0000) >> 16;
-	buffer[2] = (value & 0x0000FF00) >> 8;
-	buffer[3] = (value & 0x000000FF);
-	*size += 4;
-}
-
-//void convertToByteStream( uint64_t value, uint8_t* buffer, uint32_t* size ) {
-//	buffer[0] = (value & 0xFF00000000000000) >> 56;
-//	buffer[1] = (value & 0x00FF000000000000) >> 48;
-//	buffer[2] = (value & 0x0000FF0000000000) >> 40;
-//	buffer[3] = (value & 0x000000FF00000000) >> 32;
-//	buffer[4] = (value & 0x00000000FF000000) >> 24;
-//	buffer[5] = (value & 0x0000000000FF0000) >> 16;
-//	buffer[6] = (value & 0x000000000000FF00) >> 8;
-//	buffer[7] = (value & 0x00000000000000FF);
-//	*size+=8;
-//}
-//
-//void convertToByteStream( int64_t value, uint8_t* buffer, uint32_t* size ) {
-//	buffer[0] = (value & 0xFF00000000000000) >> 56;
-//	buffer[1] = (value & 0x00FF000000000000) >> 48;
-//	buffer[2] = (value & 0x0000FF0000000000) >> 40;
-//	buffer[3] = (value & 0x000000FF00000000) >> 32;
-//	buffer[4] = (value & 0x00000000FF000000) >> 24;
-//	buffer[5] = (value & 0x0000000000FF0000) >> 16;
-//	buffer[6] = (value & 0x000000000000FF00) >> 8;
-//	buffer[7] = (value & 0x00000000000000FF);
-//	*size+=8;
-//}
-
-void convertToByteStream( float in_value, uint8_t* buffer, uint32_t* size ) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-	union float_union {
-		float value;
-		uint8_t chars[4];
-	};
-	float_union temp;
-	temp.value = in_value;
-	buffer[0] = temp.chars[3];
-	buffer[1] = temp.chars[2];
-	buffer[2] = temp.chars[1];
-	buffer[3] = temp.chars[0];
-	*size += 4;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-	memcpy(buffer, &in_value, sizeof(in_value));
-	*size += sizeof(in_value);
-#endif
-}
-
-void convertToByteStream( double in_value, uint8_t* buffer, uint32_t* size ) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-	union double_union {
-		double value;
-		uint8_t chars[8];
-	};
-	double_union temp;
-	temp.value = in_value;
-	buffer[0] = temp.chars[7];
-	buffer[1] = temp.chars[6];
-	buffer[2] = temp.chars[5];
-	buffer[3] = temp.chars[4];
-	buffer[4] = temp.chars[3];
-	buffer[5] = temp.chars[2];
-	buffer[6] = temp.chars[1];
-	buffer[7] = temp.chars[0];
-	*size += 8;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-	memcpy(buffer, &in_value, sizeof(in_value));
-	*size += sizeof(in_value);
-#endif
-}
diff --git a/globalfunctions/conversion.h b/globalfunctions/conversion.h
deleted file mode 100644
index 0d1ca1a6b..000000000
--- a/globalfunctions/conversion.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef CONVERSION_H_
-#define CONVERSION_H_
-
-
-#include <stdint.h>
-
-
-void convertToByteStream( uint16_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( uint32_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( int16_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( int32_t value, uint8_t* buffer, uint32_t* size );
-
-//void convertToByteStream( uint64_t value, uint8_t* buffer, uint32_t* size );
-//
-//void convertToByteStream( int64_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( float value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( double value, uint8_t* buffer, uint32_t* size );
-
-#endif /* CONVERSION_H_ */
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 0ee3890ba..b54f5492d 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -45,38 +45,38 @@ public:
 		return matchSubtree(iter, number);
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
 		iterator iter = this->begin();
 		uint8_t count = this->countRight(iter);
 		ReturnValue_t result = SerializeAdapter::serialize(&count,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		if (iter == this->end()) {
 			return HasReturnvaluesIF::RETURN_OK;
 		}
-		result = iter->serialize(buffer, size, max_size, bigEndian);
+		result = iter->serialize(buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		if (maxDepth > 0) {
 			MatchTree<T> temp(iter.left(), maxDepth - 1);
-			result = temp.serialize(buffer, size, max_size, bigEndian);
+			result = temp.serialize(buffer, size, maxSize, streamEndianness);
 		}
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		iter = iter.right();
 		while (iter != this->end()) {
-			result = iter->serialize(buffer, size, max_size, bigEndian);
+			result = iter->serialize(buffer, size, maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
 			if (maxDepth > 0) {
 				MatchTree<T> temp(iter.left(), maxDepth - 1);
-				result = temp.serialize(buffer, size, max_size, bigEndian);
+				result = temp.serialize(buffer, size, maxSize, streamEndianness);
 			}
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
@@ -86,7 +86,7 @@ public:
 		return result;
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const override {
 		//Analogous to serialize!
 		uint32_t size = 1; //One for count
 		iterator iter = this->begin();
@@ -115,8 +115,8 @@ public:
 		return size;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			SerializeIF::Endianness streamEndianness) override {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index c30406f67..6fee1f522 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -26,23 +26,23 @@ public:
 		}
 	}
 
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t max_size,
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
 			SerializeIF::Endianness streamEndianness) const override {
 		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
-				size, max_size, streamEndianness);
+				size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::serialize(&upperBound, buffer, size,
-				max_size, streamEndianness);
+				maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter::serialize(&inverted, buffer, size, max_size,
+		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
 				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const override {
+	size_t getSerializedSize() const override {
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 48ee6679c..bd6606db9 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -63,21 +63,21 @@ bool HealthTable::hasHealth(object_id_t object) {
 	return exits;
 }
 
-void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
+void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
 	mutex->lockMutex(MutexIF::NO_TIMEOUT);
-	uint32_t size = 0;
+	size_t size = 0;
 	uint16_t count = healthMap.size();
 	ReturnValue_t result = SerializeAdapter::serialize(&count,
-			&pointer, &size, maxSize, true);
+			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
 	HealthMap::iterator iter;
 	for (iter = healthMap.begin();
 			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
 			++iter) {
 		result = SerializeAdapter::serialize(&iter->first,
-				&pointer, &size, maxSize, true);
+				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
 		uint8_t health = iter->second;
 		result = SerializeAdapter::serialize(&health, &pointer, &size,
-				maxSize, true);
+				maxSize, SerializeIF::Endianness::BIG);
 	}
 	mutex->unlockMutex();
 }
diff --git a/health/HealthTable.h b/health/HealthTable.h
index 32a7eee2f..2c74bda44 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -21,7 +21,7 @@ public:
 	virtual HasHealthIF::HealthState getHealth(object_id_t);
 
 	virtual uint32_t getPrintSize();
-	virtual void printAll(uint8_t *pointer, uint32_t maxSize);
+	virtual void printAll(uint8_t *pointer, size_t maxSize);
 
 protected:
 	MutexIF* mutex;
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 760e8b93d..489a8f9e9 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -17,7 +17,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	}
 	store_address_t storeId;
 	uint8_t* dataTarget = NULL;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
 		return MonitoringIF::INVALID_SIZE;
 	}
@@ -26,8 +26,8 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	uint32_t size = 0;
-	result = data->serialize(&dataTarget, &size, maxSize, true);
+	size_t size = 0;
+	result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index 903a4d0ed..61b66c3d0 100644
--- a/osal/rtems/CpuUsage.cpp
+++ b/osal/rtems/CpuUsage.cpp
@@ -89,15 +89,15 @@ void CpuUsage::clear() {
 	threadData.clear();
 }
 
-ReturnValue_t CpuUsage::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = SerializeAdapter::serialize(
-			&timeSinceLastReset, buffer, size, max_size, bigEndian);
+			&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 }
 
 uint32_t CpuUsage::getSerializedSize() const {
@@ -109,37 +109,37 @@ uint32_t CpuUsage::getSerializedSize() const {
 	return size;
 }
 
-ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, int32_t* size,
-		bool bigEndian) {
+ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(
-			&timeSinceLastReset, buffer, size, bigEndian);
+			&timeSinceLastReset, buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 }
 
-ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if (*size + MAX_LENGTH_OF_THREAD_NAME > max_size) {
+	if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
 		return BUFFER_TOO_SHORT;
 	}
 	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
 	*size += MAX_LENGTH_OF_THREAD_NAME;
 	*buffer += MAX_LENGTH_OF_THREAD_NAME;
 	result = SerializeAdapter::serialize(&timeRunning,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	result = SerializeAdapter::serialize(&percentUsage,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -158,9 +158,9 @@ uint32_t CpuUsage::ThreadData::getSerializedSize() const {
 }
 
 ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		int32_t* size, Endianness streamEndianness) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -170,12 +170,12 @@ ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
 	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
 	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
 	result = SerializeAdapter::deSerialize(&timeRunning,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	result = SerializeAdapter::deSerialize(&percentUsage,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/rtems/CpuUsage.h b/osal/rtems/CpuUsage.h
index 3d317e4e2..eb03c5e33 100644
--- a/osal/rtems/CpuUsage.h
+++ b/osal/rtems/CpuUsage.h
@@ -18,13 +18,13 @@ public:
 		float timeRunning;
 		float percentUsage;
 
-		virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-				const uint32_t max_size, bool bigEndian) const;
+		virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const override;
 
-		virtual uint32_t getSerializedSize() const;
+		virtual size_t getSerializedSize() const override;
 
-		virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-				bool bigEndian);
+		virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness) override;
 	};
 
 	CpuUsage();
@@ -41,13 +41,13 @@ public:
 
 	void clear();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 };
 
 #endif /* CPUUSAGE_H_ */
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 75b71a7e9..725fa1d7a 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -83,7 +83,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 
 ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		const ParameterWrapper* description) {
-	uint32_t serializedSize = description->getSerializedSize();
+	size_t serializedSize = description->getSerializedSize();
 
 	uint8_t *storeElement;
 	store_address_t address;
@@ -94,10 +94,10 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	uint32_t storeElementSize = 0;
+	size_t storeElementSize = 0;
 
 	result = description->serialize(&storeElement, &storeElementSize,
-			serializedSize, true);
+			serializedSize, SerializeIF::Endianness::BIG);
 
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		storage->deleteData(address);
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 9dcbc6d58..602ec361c 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -2,41 +2,41 @@
 
 ParameterWrapper::ParameterWrapper() :
 		pointsToStream(false), type(Type::UNKNOWN_TYPE), rows(0), columns(0), data(
-				NULL), readonlyData(NULL) {
+		NULL), readonlyData(NULL) {
 }
 
 ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-		void* data) :
+		void *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) :
+		const void *data) :
 		pointsToStream(false), type(type), rows(rows), columns(columns), data(
-				NULL), readonlyData(data) {
+		NULL), readonlyData(data) {
 }
 
 ParameterWrapper::~ParameterWrapper() {
 }
 
-ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter::serialize(&type, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter::serialize(&columns, buffer, size,
-			max_size, bigEndian);
+	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -47,28 +47,33 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
 	}
 	switch (type) {
 	case Type::UINT8_T:
-		result = serializeData<uint8_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<uint8_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::INT8_T:
-		result = serializeData<int8_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
 		break;
 	case Type::UINT16_T:
-		result = serializeData<uint16_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<uint16_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::INT16_T:
-		result = serializeData<int16_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<int16_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::UINT32_T:
-		result = serializeData<uint32_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<uint32_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::INT32_T:
-		result = serializeData<int32_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<int32_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::FLOAT:
-		result = serializeData<float>(buffer, size, max_size, bigEndian);
+		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
 		break;
 	case Type::DOUBLE:
-		result = serializeData<double>(buffer, size, max_size, bigEndian);
+		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
 		break;
 	default:
 		result = UNKNOW_DATATYPE;
@@ -77,7 +82,7 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
 	return result;
 }
 
-uint32_t ParameterWrapper::getSerializedSize() const {
+size_t ParameterWrapper::getSerializedSize() const {
 	uint32_t serializedSize = 0;
 	serializedSize += type.getSerializedSize();
 	serializedSize += sizeof(rows);
@@ -88,14 +93,14 @@ uint32_t ParameterWrapper::getSerializedSize() const {
 }
 
 template<typename T>
-ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
 	const T *element = (const T*) readonlyData;
 	ReturnValue_t result;
 	uint16_t dataSize = columns * rows;
 	while (dataSize != 0) {
-		result = SerializeAdapter::serialize(element, buffer, size, max_size,
-				bigEndian);
+		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
@@ -111,21 +116,21 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 		uint8_t fromColumns) {
 
 	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t *) from;
-	int32_t streamSize = fromRows * fromColumns * sizeof(T);
+	const uint8_t *fromAsStream = (const uint8_t*) from;
+	size_t streamSize = fromRows * fromColumns * sizeof(T);
 
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
 		//get the start element of this row in data
-		T *dataWithDataType = ((T *) data)
+		T *dataWithDataType = ((T*) data)
 				+ (((startingRow + fromRow) * columns) + startingColumn);
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
 			result = SerializeAdapter::deSerialize(
 					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
-					true);
+					SerializeIF::Endianness::BIG);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
@@ -136,13 +141,14 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 
 }
 
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
-	return deSerialize(buffer, size, bigEndian, 0);
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness) {
+	return deSerialize(buffer, size, streamEndianness, 0);
 }
 
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness,
+		uint16_t startWritingAtIndex) {
 	ParameterWrapper streamDescription;
 
 	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
@@ -153,26 +159,26 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
 	return copyFrom(&streamDescription, startWritingAtIndex);
 }
 
-ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
-		const uint8_t **remainingStream, int32_t *remainingSize) {
+ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
+		const uint8_t **remainingStream, size_t *remainingSize) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
-			&streamSize, true);
+			&streamSize, SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter::deSerialize(&columns, &stream,
-			&streamSize, true);
+	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
-			true);
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	int32_t dataSize = type.getSize() * rows * columns;
+	size_t dataSize = type.getSize() * rows * columns;
 
 	if (streamSize < dataSize) {
 		return SerializeIF::STREAM_TOO_SHORT;
@@ -194,7 +200,7 @@ ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from,
+ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		uint16_t startWritingAtIndex) {
 	if (data == NULL) {
 		return READONLY;
@@ -261,7 +267,7 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from,
 		}
 	} else {
 		//need a type to do arithmetic
-		uint8_t *toDataWithType = (uint8_t *) data;
+		uint8_t *toDataWithType = (uint8_t*) data;
 		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
 			memcpy(
 					toDataWithType
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index e6d29c59b..a00c997cc 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -25,16 +25,16 @@ public:
 			const void *data);
 	virtual ~ParameterWrapper();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian, uint16_t startWritingAtIndex = 0);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
 
 	template<typename T>
 	ReturnValue_t getElement(T *value, uint8_t row = 0, uint8_t column = 0) const {
@@ -111,8 +111,8 @@ 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, int32_t streamSize,
-			const uint8_t **remainingStream = NULL, int32_t *remainingSize =
+	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
+			const uint8_t **remainingStream = NULL, size_t *remainingSize =
 					NULL);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
@@ -128,8 +128,8 @@ private:
 	const void *readonlyData;
 
 	template<typename T>
-	ReturnValue_t serializeData(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const;
 
 	template<typename T>
 	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index dd5d3e3f4..db24100bd 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -86,12 +86,12 @@ ReturnValue_t Fuse::check() {
 	return result;
 }
 
-ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
-		result = (*iter)->serialize(buffer, size, max_size, bigEndian);
+		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}
@@ -99,7 +99,7 @@ ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
 	return RETURN_OK;
 }
 
-uint32_t Fuse::getSerializedSize() const {
+size_t Fuse::getSerializedSize() const {
 	uint32_t size = 0;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
@@ -108,12 +108,12 @@ uint32_t Fuse::getSerializedSize() const {
 	return size;
 }
 
-ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, int32_t* size,
-bool bigEndian) {
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
+Endianness streamEndianness) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
 			iter++) {
-		result = (*iter)->deSerialize(buffer, size, bigEndian);
+		result = (*iter)->deSerialize(buffer, size, streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}
diff --git a/power/Fuse.h b/power/Fuse.h
index 6da241788..4e22e3ed0 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -11,14 +11,15 @@
 #include <framework/parameters/ParameterHelper.h>
 #include <list>
 
-namespace Factory{
+namespace Factory {
 void setStaticFrameworkObjectIds();
 }
 
 class Fuse: public SystemObject,
 		public HasHealthIF,
 		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF {
+		public ReceivesParameterMessagesIF,
+		public SerializeIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 private:
 	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
@@ -40,7 +41,7 @@ public:
 	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
 			float maxCurrent, uint16_t confirmationCount = 2);
 	virtual ~Fuse();
-	void addDevice(PowerComponentIF* set);
+	void addDevice(PowerComponentIF *set);
 	float getPower();
 
 	bool isPowerValid();
@@ -49,11 +50,11 @@ public:
 	uint8_t getFuseId() const;
 	ReturnValue_t initialize();
 	DeviceList devices;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
-	uint32_t getSerializedSize() const;
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian);
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override;
+	size_t getSerializedSize() const override;
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override;
 	void setAllMonitorsToUnchecked();
 	ReturnValue_t performOperation(uint8_t opCode);
 	MessageQueueId_t getCommandQueue() const;
@@ -62,13 +63,13 @@ public:
 	HasHealthIF::HealthState getHealth();
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex);
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
 
 private:
 	uint8_t oldFuseState;
 	uint8_t fuseId;
-	PowerSwitchIF* powerIF; //could be static in our case.
+	PowerSwitchIF *powerIF; //could be static in our case.
 	AbsLimitMonitor<float> currentLimit;
 	class PowerMonitor: public MonitorReporter<float> {
 	public:
@@ -88,11 +89,11 @@ private:
 	PIDReader<float> current;
 	PIDReader<uint8_t> state;
 	db_float_t power;
-	MessageQueueIF* commandQueue;
+	MessageQueueIF *commandQueue;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
 	static object_id_t powerSwitchId;
-	void calculatePowerLimits(float* low, float* high);
+	void calculatePowerLimits(float *low, float *high);
 	void calculateFusePower();
 	void checkFuseState();
 	void reportEvents(Event event);
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 53bb06c8e..cd116a86f 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -17,18 +17,18 @@ PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, f
 				twoSwitches), min(min), max(max), moduleId(moduleId) {
 }
 
-ReturnValue_t PowerComponent::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter::serialize(&max, buffer, size, max_size,
-			bigEndian);
+	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
+			streamEndianness);
 }
 
-uint32_t PowerComponent::getSerializedSize() const {
+size_t PowerComponent::getSerializedSize() const {
 	return sizeof(min) + sizeof(max);
 }
 
@@ -56,14 +56,14 @@ float PowerComponent::getMax() {
 	return max;
 }
 
-ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, int32_t* size,
-bool bigEndian) {
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
+Endianness streamEndianness) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter::deSerialize(&max, buffer, size, bigEndian);
+	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
 }
 
 ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index a82fe1d7f..61ab3674e 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -19,13 +19,13 @@ public:
 	float getMin();
 	float getMax();
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const override;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index ab0c6c6f3..bcd998181 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -20,25 +20,25 @@ public:
 	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return serialize(adaptee, buffer, size, max_size, bigEndian);
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
 	}
 
-	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) {
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
 			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			++i;
 		}
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return getSerializedSize(adaptee);
 	}
 
@@ -53,16 +53,16 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return deSerialize(adaptee, buffer, size, bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return deSerialize(adaptee, buffer, size, streamEndianness);
 	}
 
-	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
 		count_t tempSize = 0;
 		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
@@ -71,7 +71,7 @@ public:
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
 			result = SerializeAdapter::deSerialize(
 					&list->front()[i], buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		return result;
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index f78ec8ace..d4d8d1c7c 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -22,19 +22,19 @@ SerialBufferAdapter<T>::~SerialBufferAdapter() {
 }
 
 template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+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 > max_size) {
+	if (*size + serializedLength > maxSize) {
 		return BUFFER_TOO_SHORT;
 	} else {
 		if (serializeLength) {
 			SerializeAdapter::serialize(&bufferLength, buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 		}
 		if (this->constBuffer != NULL) {
 			memcpy(*buffer, this->constBuffer, bufferLength);
@@ -50,7 +50,7 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size
 }
 
 template<typename T>
-uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
+size_t SerialBufferAdapter<T>::getSerializedSize() const {
 	if (serializeLength) {
 		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
@@ -59,7 +59,7 @@ uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
 }
 template<typename T>
 ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		size_t* size, Endianness streamEndianness) {
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
 		if(serializeLength){
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 7cd75d556..78d42b804 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -16,13 +16,13 @@ public:
 
 	virtual ~SerialBufferAdapter();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 private:
 	bool serializeLength;
 	const uint8_t *constBuffer;
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 16919b623..a2e683bf0 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -13,16 +13,16 @@ public:
 	template<typename... Args>
 	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, max_size, bigEndian);
+	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);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, streamEndianness);
 	}
 };
 
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 22e9838c9..3941e9fbb 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -26,7 +26,7 @@ public:
 				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const override {
+	size_t getSerializedSize() const override {
 		return SerializeAdapter::getSerializedSize(&entry);
 	}
 
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 6c875a5c7..14244a7a7 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -28,7 +28,7 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t max_size, Endianness streamEndianness) const = 0;
+			size_t maxSize, Endianness streamEndianness) const = 0;
 
 	virtual size_t getSerializedSize() const = 0;
 
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index ef706dd76..2e8a325aa 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -13,7 +13,7 @@ Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
 				false), uptimeStartTable(0), currentTargetTable(), targetMode(
 				0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables(
 				maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore(
-				NULL)
+		NULL)
 #ifdef USE_MODESTORE
 ,modeStore(NULL)
 #endif
@@ -75,7 +75,8 @@ void Subsystem::performChildOperation() {
 	if (isInTransition) {
 		if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
 			if (currentSequenceIterator.value == NULL) { //we're through with this sequence
-				if (checkStateAgainstTable(currentTargetTable, targetSubmode) == RETURN_OK) {
+				if (checkStateAgainstTable(currentTargetTable, targetSubmode)
+						== RETURN_OK) {
 					setMode(targetMode, targetSubmode);
 					isInTransition = false;
 					return;
@@ -86,7 +87,8 @@ void Subsystem::performChildOperation() {
 				}
 			}
 			if (currentSequenceIterator->checkSuccess()) {
-				if (checkStateAgainstTable(getCurrentTable(), targetSubmode) != RETURN_OK) {
+				if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
+						!= RETURN_OK) {
 					transitionFailed(TABLE_CHECK_FAILED,
 							currentSequenceIterator->getTableId());
 					return;
@@ -117,7 +119,8 @@ void Subsystem::performChildOperation() {
 			childrenChangedHealth = false;
 			startTransition(mode, submode);
 		} else if (childrenChangedMode) {
-			if (checkStateAgainstTable(currentTargetTable, submode) != RETURN_OK) {
+			if (checkStateAgainstTable(currentTargetTable, submode)
+					!= RETURN_OK) {
 				triggerEvent(CANT_KEEP_MODE, mode, submode);
 				cantKeepMode();
 			}
@@ -147,7 +150,7 @@ HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
 	}
 }
 
-ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
+ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
 	ReturnValue_t result;
 	switch (message->getCommand()) {
 	case HealthMessage::HEALTH_INFO: {
@@ -168,12 +171,13 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				&sizeRead);
 		if (result == RETURN_OK) {
 			Mode_t fallbackId;
-			int32_t size = sizeRead;
-			result = SerializeAdapter::deSerialize(&fallbackId,
-					&pointer, &size, true);
+			size_t size = sizeRead;
+			result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
+					SerializeIF::Endianness::BIG);
 			if (result == RETURN_OK) {
 				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
-						&sequence, &pointer, &size, true);
+						&sequence, &pointer, &size,
+						SerializeIF::Endianness::BIG);
 				if (result == RETURN_OK) {
 					result = addSequence(&sequence,
 							ModeSequenceMessage::getSequenceId(message),
@@ -193,9 +197,9 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
 		if (result == RETURN_OK) {
-			int32_t size = sizeRead;
+			size_t size = sizeRead;
 			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
-					&pointer, &size, true);
+					&pointer, &size, SerializeIF::Endianness::BIG);
 			if (result == RETURN_OK) {
 				result = addTable(&table,
 						ModeSequenceMessage::getSequenceId(message));
@@ -339,7 +343,7 @@ void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
 	}
 }
 
-ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry>* sequence,
+ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
 		Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
 
 	ReturnValue_t result;
@@ -507,7 +511,7 @@ MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
 }
 
 ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
-		uint32_t* msToReachTheMode) {
+		uint32_t *msToReachTheMode) {
 	//Need to accept all submodes to be able to inherit submodes
 //	if (submode != SUBMODE_NONE) {
 //		return INVALID_SUBMODE;
@@ -599,15 +603,15 @@ void Subsystem::transitionFailed(ReturnValue_t failureCode,
 }
 
 void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
-		SerializeIF** elements, uint8_t count) {
+		SerializeIF **elements, uint8_t count) {
 	ReturnValue_t result;
-	uint32_t maxSize = 0;
+	size_t maxSize = 0;
 	for (uint8_t i = 0; i < count; i++) {
 		maxSize += elements[i]->getSerializedSize();
 	}
 	uint8_t *storeBuffer;
 	store_address_t address;
-	uint32_t size = 0;
+	size_t size = 0;
 
 	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -615,7 +619,8 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 		return;
 	}
 	for (uint8_t i = 0; i < count; i++) {
-		elements[i]->serialize(&storeBuffer, &size, maxSize, true);
+		elements[i]->serialize(&storeBuffer, &size, maxSize,
+				SerializeIF::Endianness::BIG);
 	}
 	CommandMessage reply;
 	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 3e749dd80..153710afb 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -18,65 +18,65 @@ public:
 	uint8_t value3;
 	uint8_t value4;
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
 
 		ReturnValue_t result;
 
 		result = SerializeAdapter::serialize(&value1, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::serialize(&value2, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::serialize(&value3, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 
 		result = SerializeAdapter::serialize(&value4, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		return result;
 
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian) {
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	Endianness streamEndianness) {
 		ReturnValue_t result;
 
 		result = SerializeAdapter::deSerialize(&value1, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&value2, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&value3, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&value4, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		return result;
 	}
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 93513e16e..5dcd0bc64 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -46,15 +46,15 @@ ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
 	if (size != 4 * sizeof(parameters.lowerOpLimit)) {
 		return MonitoringIF::INVALID_SIZE;
 	}
-	int32_t readSize = size;
+	size_t readSize = size;
 	SerializeAdapter::deSerialize(&nopParameters.lowerNopLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	SerializeAdapter::deSerialize(&parameters.lowerOpLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	SerializeAdapter::deSerialize(&parameters.upperOpLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	SerializeAdapter::deSerialize(&nopParameters.upperNopLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 4e7160fb2..16768e682 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -32,31 +32,31 @@ public:
 	}
 	uint16_t apid;
 	uint16_t ssc;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
 		ReturnValue_t result = SerializeAdapter::serialize(&apid,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		return SerializeAdapter::serialize(&ssc, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return sizeof(apid) + sizeof(ssc);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian) {
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		return SerializeAdapter::deSerialize(&ssc, buffer, size,
-				bigEndian);
+				streamEndianness);
 	}
 };
 
@@ -218,33 +218,33 @@ public:
 	}
 
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&subCounter,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.serialize(buffer,size,max_size,bigEndian);
+		return adapter.serialize(buffer,size,maxSize,streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		uint32_t size = 0;
 		size += SerializeAdapter::getSerializedSize(&apid);
 		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
@@ -257,35 +257,35 @@ public:
 
 	};
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian) {
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.deSerialize(buffer,size,bigEndian);
+		return adapter.deSerialize(buffer,size,streamEndianness);
 	}
 
 private:
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index d5d96f2d4..3080ffef8 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -22,16 +22,16 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter::serialize(&apid, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter::getSerializedSize(&apid);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return SerializeAdapter::deSerialize(&apid, buffer, size, bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
 	}
 };
 
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index b06237803..f6e9e3608 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -22,16 +22,16 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter::serialize(&service, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter::getSerializedSize(&service);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return SerializeAdapter::deSerialize(&service, buffer, size, bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
 	}
 };
 
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 90370af1f..2e8b82b23 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -20,16 +20,16 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter::serialize(&subService, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter::getSerializedSize(&subService);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return SerializeAdapter::deSerialize(&subService, buffer, size, bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
 	}
 private:
 	uint8_t subService;
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index f2c1eb28a..32f9c4310 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -10,14 +10,14 @@ TmPacketStored::TmPacketStored(store_address_t setAddress) :
 }
 
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, const uint8_t* data,
-		uint32_t size, const uint8_t* headerData, uint32_t headerSize) :
+		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
+		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	if (!checkAndSetStore()) {
 		return;
 	}
-	uint8_t* pData = NULL;
+	uint8_t *pData = NULL;
 	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
 
@@ -34,21 +34,21 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 }
 
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, SerializeIF* content,
-		SerializeIF* header) :
+		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
+		SerializeIF *header) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	if (!checkAndSetStore()) {
 		return;
 	}
-	uint32_t sourceDataSize = 0;
+	size_t sourceDataSize = 0;
 	if (content != NULL) {
 		sourceDataSize += content->getSerializedSize();
 	}
 	if (header != NULL) {
 		sourceDataSize += header->getSerializedSize();
 	}
-	uint8_t* p_data = NULL;
+	uint8_t *p_data = NULL;
 	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
 	if (returnValue != store->RETURN_OK) {
@@ -56,13 +56,15 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	}
 	setData(p_data);
 	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	uint8_t* putDataHere = getSourceData();
-	uint32_t size = 0;
+	uint8_t *putDataHere = getSourceData();
+	size_t size = 0;
 	if (header != NULL) {
-		header->serialize(&putDataHere, &size, sourceDataSize, true);
+		header->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
 	}
 	if (content != NULL) {
-		content->serialize(&putDataHere, &size, sourceDataSize, true);
+		content->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
 	}
 	setPacketDataLength(
 			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
@@ -80,7 +82,7 @@ void TmPacketStored::deletePacket() {
 
 void TmPacketStored::setStoreAddress(store_address_t setAddress) {
 	storeAddress = setAddress;
-	const uint8_t* temp_data = NULL;
+	const uint8_t *temp_data = NULL;
 	uint32_t temp_size;
 	if (!checkAndSetStore()) {
 		return;
@@ -106,8 +108,8 @@ bool TmPacketStored::checkAndSetStore() {
 	return true;
 }
 
-StorageManagerIF* TmPacketStored::store = NULL;
-InternalErrorReporterIF* TmPacketStored::internalErrorReporter = NULL;
+StorageManagerIF *TmPacketStored::store = NULL;
+InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
 
 ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 		MessageQueueId_t sentFrom, bool doErrorReporting) {
@@ -116,7 +118,8 @@ ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	TmTcMessage tmMessage(getStoreAddress());
-	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination, &tmMessage, sentFrom);
+	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
+			&tmMessage, sentFrom);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		deletePacket();
 		if (doErrorReporting) {
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 5b9e7b68e..aa41f3340 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -235,9 +235,9 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
 		object_id_t objectId, const uint8_t *data, uint32_t dataLen) {
 	uint8_t buffer[sizeof(object_id_t)];
 	uint8_t* pBuffer = buffer;
-	uint32_t size = 0;
+	size_t size = 0;
 	SerializeAdapter::serialize(&objectId, &pBuffer, &size,
-			sizeof(object_id_t), true);
+			sizeof(object_id_t), SerializeIF::Endianness::BIG);
 	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
 			this->tmPacketCounter, data, dataLen, buffer, size);
 	ReturnValue_t result = tmPacketStored.sendPacket(
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index e1dad2bea..07631801d 100644
--- a/tmtcservices/PusVerificationReport.cpp
+++ b/tmtcservices/PusVerificationReport.cpp
@@ -33,7 +33,7 @@ PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
 		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
 		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
 		uint32_t parameter2) {
-	uint8_t* data = this->getBuffer();
+	uint8_t *data = this->getBuffer();
 	data[messageSize] = set_report_id;
 	messageSize += sizeof(set_report_id);
 	data[messageSize] = ackFlags;
@@ -109,12 +109,12 @@ PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
 	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	if (setStep != 0) {
 		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), true);
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	}
 }
 
@@ -136,25 +136,25 @@ PusFailureReport::PusFailureReport(uint16_t setPacketId,
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
 	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	if (setStep != 0) {
 		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), true);
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	}
-	SerializeAdapter::serialize(&setErrorCode, &pBuffer,
-			&reportSize, sizeof(reportBuffer), true);
+	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 }
 
 PusFailureReport::~PusFailureReport() {
 }
 
-uint32_t PusFailureReport::getSize() {
+size_t PusFailureReport::getSize() {
 	return reportSize;
 }
 
diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h
index 7a173be9f..ee84f0c17 100644
--- a/tmtcservices/PusVerificationReport.h
+++ b/tmtcservices/PusVerificationReport.h
@@ -49,7 +49,7 @@ class PusSuccessReport {
 private:
 	static const uint16_t MAX_SIZE = 7;
 	uint8_t reportBuffer[MAX_SIZE];
-	uint32_t reportSize;
+	size_t reportSize;
 	uint8_t * pBuffer;
 public:
 	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
@@ -63,14 +63,14 @@ class PusFailureReport {
 private:
 	static const uint16_t MAX_SIZE = 16;
 	uint8_t reportBuffer[MAX_SIZE];
-	uint32_t reportSize;
+	size_t reportSize;
 	uint8_t * pBuffer;
 public:
 	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
 			ReturnValue_t setErrorCode, uint8_t setStep = 0,
 			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
 	~PusFailureReport();
-	uint32_t getSize();
+	size_t getSize();
 	uint8_t* getReport();
 };
 

From 326e5cf5febda0dd3ad55cd6c5b181969ebdf9ad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 01:01:32 +0200
Subject: [PATCH 0191/1774] initialized uninitialized variables

---
 datapool/PoolRawAccessHelper.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 643c76099..81a9eb01e 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -24,7 +24,7 @@ PoolRawAccessHelper::~PoolRawAccessHelper() {
 ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 		const size_t max_size, bool bigEndian) {
 	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
-	ReturnValue_t result;
+	ReturnValue_t result = RETURN_OK;
 	size_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
 		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
@@ -42,7 +42,7 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 
 ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		size_t * size, const size_t max_size, bool bigEndian) {
-	ReturnValue_t result;
+	ReturnValue_t result = RETURN_OK;
 	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
 	size_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);

From 4e76b8133e905446c90b3447abfaad3744da5d87 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 01:08:36 +0200
Subject: [PATCH 0192/1774] uninitialized variable

---
 parameters/ParameterWrapper.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 475764c58..e2572acb0 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -91,7 +91,7 @@ template<typename T>
 ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, size_t* size,
 		const size_t max_size, bool bigEndian) const {
 	const T *element = (const T*) readonlyData;
-	ReturnValue_t result;
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	uint16_t dataSize = columns * rows;
 	while (dataSize != 0) {
 		result = SerializeAdapter<T>::serialize(element, buffer, size, max_size,

From fb9a5678fc463aba32a4bbcf01a8cf8994638a30 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 10:24:00 +0200
Subject: [PATCH 0193/1774] removed comment belonging in egit

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index a2365d000..2a97ab90b 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -68,10 +68,7 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 }
 #endif
 
-/**
- * TODO: This is architecture specific. Maybe there is a better solution
- * to move this into the Bsp folder..
- */
+
 #ifdef UT699
 #include <framework/osal/rtems/Interrupt.h>
 

From 9f7f8073f17df0081406804bf2fc84034420da54 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 19:42:42 +0200
Subject: [PATCH 0194/1774] freertos includes in extern "C"

---
 osal/FreeRTOS/BinarySemaphore.cpp | 3 +++
 osal/FreeRTOS/BinarySemaphore.h   | 6 +++++-
 osal/FreeRTOS/Mutex.h             | 4 ++--
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index e2cddacc0..b5f8e6c6c 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -7,8 +7,11 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+extern "C" {
 #include "portmacro.h"
 #include "task.h"
+}
 
 BinarySemaphore::BinarySemaphore() {
 	xSemaphoreCreateBinary(handle);
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 373e26bfc..2203c923a 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -7,8 +7,12 @@
 #define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <FreeRTOS.h>
+
+extern "C" {
+#include "FreeRTOS.h"
 #include "semphr.h"
+}
+
 
 /**
  * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 2703df4eb..604511b5d 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -19,8 +19,8 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs);
-	ReturnValue_t unlockMutex();
+	ReturnValue_t lockMutex(uint32_t timeoutMs) override;
+	ReturnValue_t unlockMutex() override;
 private:
 	SemaphoreHandle_t handle;
 };

From e26f0d54b2828e786c4d91ef38345a7e68d1fbcf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 19:44:03 +0200
Subject: [PATCH 0195/1774] binary semaphore init

---
 osal/FreeRTOS/BinarySemaphore.cpp | 152 ++++++++++++++++++++++++++++++
 osal/FreeRTOS/BinarySemaphore.h   | 130 +++++++++++++++++++++++++
 2 files changed, 282 insertions(+)
 create mode 100644 osal/FreeRTOS/BinarySemaphore.cpp
 create mode 100644 osal/FreeRTOS/BinarySemaphore.h

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
new file mode 100644
index 000000000..b5f8e6c6c
--- /dev/null
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -0,0 +1,152 @@
+/**
+ * @file BinarySemaphore.cpp
+ *
+ * @date 25.02.2020
+ */
+#include <framework/osal/FreeRTOS/BinarySemaphore.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+extern "C" {
+#include "portmacro.h"
+#include "task.h"
+}
+
+BinarySemaphore::BinarySemaphore() {
+	xSemaphoreCreateBinary(handle);
+	if(handle == nullptr) {
+		error << "Binary semaphore creation failure" << std::endl;
+	}
+}
+
+BinarySemaphore::~BinarySemaphore() {
+	vSemaphoreDelete(handle);
+}
+
+// This copy ctor is important as it prevents the assignment to a ressource
+// (other.handle) variable which is later deleted!
+BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
+    xSemaphoreCreateBinary(handle);
+    if(handle == nullptr) {
+        error << "Binary semaphore creation failure" << std::endl;
+    }
+}
+
+BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
+    if(this != &s) {
+        xSemaphoreCreateBinary(handle);
+        if(handle == nullptr) {
+            error << "Binary semaphore creation failure" << std::endl;
+        }
+    }
+    return *this;
+}
+
+BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
+    xSemaphoreCreateBinary(handle);
+    if(handle == nullptr) {
+        error << "Binary semaphore creation failure" << std::endl;
+    }
+}
+
+BinarySemaphore& BinarySemaphore::operator =(
+        BinarySemaphore&& s) {
+    if(&s != this) {
+        xSemaphoreCreateBinary(handle);
+        if(handle == nullptr) {
+            error << "Binary semaphore creation failure" << std::endl;
+        }
+    }
+    return *this;
+}
+
+ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+	if(handle == nullptr) {
+		return SEMAPHORE_NULLPOINTER;
+	}
+	TickType_t timeout = BinarySemaphore::NO_BLOCK_TICKS;
+	if(timeoutMs == BinarySemaphore::BLOCK_TIMEOUT) {
+	    timeout = BinarySemaphore::BLOCK_TIMEOUT_TICKS;
+	}
+	else if(timeoutMs > BinarySemaphore::NO_BLOCK_TIMEOUT){
+	    timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+
+	BaseType_t returncode = xSemaphoreTake(handle, timeout);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+	    return SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
+        TickType_t timeoutTicks) {
+	if(handle == nullptr) {
+		return SEMAPHORE_NULLPOINTER;
+	}
+
+	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
+	if (handle == nullptr) {
+		return SEMAPHORE_NULLPOINTER;
+	}
+	BaseType_t returncode = xSemaphoreGive(handle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
+
+SemaphoreHandle_t BinarySemaphore::getSemaphore() {
+	return handle;
+}
+
+ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+	if (semaphore == nullptr) {
+		return SEMAPHORE_NULLPOINTER;
+	}
+	BaseType_t returncode = xSemaphoreGive(semaphore);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void BinarySemaphore::resetSemaphore() {
+	if(handle != nullptr) {
+		vSemaphoreDelete(handle);
+		xSemaphoreCreateBinary(handle);
+	}
+}
+
+
+// Be careful with the stack size here. This is called from an ISR!
+ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+		BaseType_t * higherPriorityTaskWoken) {
+	if (semaphore == nullptr) {
+		return SEMAPHORE_NULLPOINTER;
+	}
+	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);
+	if (returncode == pdPASS) {
+		if(*higherPriorityTaskWoken == pdPASS) {
+			// Request context switch because unblocking the semaphore
+		    // caused a high priority task unblock.
+			TaskManagement::requestContextSwitch(CallContext::isr);
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
new file mode 100644
index 000000000..2203c923a
--- /dev/null
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -0,0 +1,130 @@
+/**
+ * @file BinarySempahore.h
+ *
+ * @date 25.02.2020
+ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+extern "C" {
+#include "FreeRTOS.h"
+#include "semphr.h"
+}
+
+
+/**
+ * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
+ * @details
+ * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
+ * @ingroup osal
+ */
+class BinarySemaphore: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! No block time, poll the semaphore. Can also be used as tick type.
+	//! Can be passed as tick type and ms value.
+	static constexpr uint32_t NO_BLOCK_TIMEOUT = 0;
+	static constexpr TickType_t NO_BLOCK_TICKS = 0;
+	//! No block time, poll the semaphore.
+	//! Can be passed as tick type and ms value.
+	static constexpr TickType_t BLOCK_TIMEOUT_TICKS = portMAX_DELAY;
+	static constexpr uint32_t BLOCK_TIMEOUT = portMAX_DELAY;
+
+	//! Semaphore timeout
+	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
+	/** The current semaphore can not be given, because it is not owned */
+	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
+
+	BinarySemaphore();
+
+	/**
+	 * @brief Copy ctor
+	 */
+	BinarySemaphore(const BinarySemaphore&);
+
+	/**
+	 * @brief Copy assignment
+	 */
+	BinarySemaphore& operator=(const BinarySemaphore&);
+
+	/**
+	 * @brief Move constructor
+	 */
+	BinarySemaphore (BinarySemaphore &&);
+
+	/**
+	 * Move assignment
+	 */
+	BinarySemaphore & operator=(BinarySemaphore &&);
+
+	/**
+	 * Delete the binary semaphore to prevent a memory leak
+	 */
+	virtual ~BinarySemaphore();
+
+	/**
+	 * 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 RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
+	        BinarySemaphore::NO_BLOCK_TIMEOUT);
+
+	/**
+	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
+	        BinarySemaphore::NO_BLOCK_TICKS);
+
+	/**
+	 * Give back the binary semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t giveBinarySemaphore();
+
+	/**
+	 * Get Handle to the semaphore.
+	 * @return
+	 */
+	SemaphoreHandle_t getSemaphore();
+
+	/**
+	 * Reset the semaphore.
+	 */
+	void resetSemaphore();
+
+	 /**
+	 * Wrapper function to give back semaphore from handle
+	 * @param semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphore(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
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+				BaseType_t * higherPriorityTaskWoken);
+private:
+	SemaphoreHandle_t handle;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */

From 6eda5a08381891907d67e3b23a93e80808585b07 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 19:46:49 +0200
Subject: [PATCH 0196/1774] task management header added

---
 osal/FreeRTOS/TaskManagement.h | 38 ++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 osal/FreeRTOS/TaskManagement.h

diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
new file mode 100644
index 000000000..fd2bfc0b1
--- /dev/null
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -0,0 +1,38 @@
+/**
+ * @file TaskManagement.h
+ *
+ * @date 26.02.2020
+ */
+
+#ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+#define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+
+/*!
+ * 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 CallContext {
+	task = 0x00,//!< task_context
+	isr = 0xFF  //!< isr_context
+};
+
+class TaskManagement {
+public:
+	/**
+	 * 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 requestContextSwitchFromTask(void);
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */

From 1b5127dc85f236d7e02cdb22c722bea4976d531b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 19:50:07 +0200
Subject: [PATCH 0197/1774] added task management implementation

---
 osal/FreeRTOS/TaskManagement.cpp | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 osal/FreeRTOS/TaskManagement.cpp

diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
new file mode 100644
index 000000000..9946833d2
--- /dev/null
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -0,0 +1,32 @@
+/**
+ * @file TaskManagement.cpp
+ *
+ * @date 26.02.2020
+ *
+ */
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+#include <FreeRTOS.h>
+#include "portmacro.h"
+#include "task.h"
+
+/**
+ * TODO: This stuff is hardware and architecture and mission dependant...
+ * 	     Some FreeRTOS implementations might be able to determine their own task context for example.
+ * 	     If not ISRs are used, or task preemption is enabled, some of this stuff might
+ * 	     not be necessary anyway. Maybe there is a better solution?
+ */
+void TaskManagement::requestContextSwitchFromTask() {
+	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
+		portYIELD_FROM_ISR();
+	} else {
+		requestContextSwitchFromTask();
+	}
+}
+
+
+

From 0e6f8d3f821d3fa6907de2310e9102a33d30afb2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 19:53:06 +0200
Subject: [PATCH 0198/1774] comment adapted

---
 osal/FreeRTOS/TaskManagement.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 9946833d2..0c96c62f0 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -5,15 +5,17 @@
  *
  */
 #include <framework/osal/FreeRTOS/TaskManagement.h>
-#include <FreeRTOS.h>
+
+extern "C" {
+#include "FreeRTOS.h"
 #include "portmacro.h"
 #include "task.h"
+}
 
 /**
  * TODO: This stuff is hardware and architecture and mission dependant...
- * 	     Some FreeRTOS implementations might be able to determine their own task context for example.
- * 	     If not ISRs are used, or task preemption is enabled, some of this stuff might
- * 	     not be necessary anyway. Maybe there is a better solution?
+ * 	     Maybe there is a better solution? The request ContextSwitch function
+ * 	     could be declared external for example.
  */
 void TaskManagement::requestContextSwitchFromTask() {
 	vTaskDelay(0);

From c075e1bf2334e6984da63997589c3652d5d39b74 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 10:20:19 +0200
Subject: [PATCH 0199/1774] adapting tmtc bridge

---
 tmtcservices/TmTcBridge.cpp | 26 +++++++++++++++++++++-----
 tmtcservices/TmTcBridge.h   | 34 ++++++++++++++++++++++++----------
 2 files changed, 45 insertions(+), 15 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 26131a20c..646f736aa 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -6,8 +6,7 @@
 
 TmTcBridge::TmTcBridge(object_id_t objectId_,
         object_id_t ccsdsPacketDistributor_): SystemObject(objectId_),
-        ccsdsPacketDistributor(ccsdsPacketDistributor_),
-		sentPacketsPerCycle(5)
+        ccsdsPacketDistributor(ccsdsPacketDistributor_)
 {
     TmTcReceptionQueue = QueueFactory::instance()->
             createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
@@ -17,15 +16,30 @@ TmTcBridge::~TmTcBridge() {}
 
 ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 		uint8_t sentPacketsPerCycle) {
-	if(sentPacketsPerCycle <= MAX_STORED_DATA_SENT_PER_CYCLE) {
+	if(sentPacketsPerCycle <= LIMIT_STORED_DATA_SENT_PER_CYCLE) {
 		this->sentPacketsPerCycle = sentPacketsPerCycle;
 		return RETURN_OK;
 	}
 	else {
+	    warning << "TmTcBridge: Number of packets sent per cycle "
+	               "exceeds limits" << std::endl;
 		return RETURN_FAILED;
 	}
 }
 
+ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
+        uint8_t maxNumberOfPacketsStored) {
+    if(maxNumberOfPacketsStored <= LIMIT_DOWNLINK_PACKETS_STORED) {
+        this->maxNumberOfPacketsStored = maxNumberOfPacketsStored;
+        return RETURN_OK;
+    }
+    else {
+        warning << "TmTcBridge: Number of packets stored "
+                   "exceeds limits" << std::endl;
+        return RETURN_FAILED;
+    }
+}
+
 ReturnValue_t TmTcBridge::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == NULL) {
@@ -72,7 +86,7 @@ ReturnValue_t TmTcBridge::handleTm() {
 	}
 
 	if(tmStored && communicationLinkUp) {
-		result = sendStoredTm();
+		result = handleStoredTm();
 	}
 	return result;
 
@@ -124,7 +138,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	return RETURN_OK;
 }
 
-ReturnValue_t TmTcBridge::sendStoredTm() {
+ReturnValue_t TmTcBridge::handleStoredTm() {
 	uint8_t counter = 0;
 	ReturnValue_t result = RETURN_OK;
 	while(!fifo.empty() && counter < sentPacketsPerCycle) {
@@ -171,6 +185,8 @@ MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
 	return TmTcReceptionQueue->getId();
 }
 
+
+
 void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
 	info << "TMTC Bridge: Printing data: [";
 	for(uint32_t i=0;i<dataLen;i++) {
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index bae2bd69e..f589a4d93 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -16,8 +16,11 @@ class TmTcBridge : public AcceptsTelemetryIF,
 		public SystemObject {
 public:
 	static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
-	static constexpr uint8_t MAX_STORED_DATA_SENT_PER_CYCLE = 10;
-	static constexpr uint8_t MAX_DOWNLINK_PACKETS_STORED = 15;
+	static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15;
+	static constexpr uint8_t LIMIT_DOWNLINK_PACKETS_STORED = 20;
+
+	static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
+	static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
 
 	TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_);
 	virtual ~TmTcBridge();
@@ -31,6 +34,15 @@ public:
 	 */
 	ReturnValue_t setNumberOfSentPacketsPerCycle(uint8_t sentPacketsPerCycle);
 
+	/**
+	 * Set number of packets sent per performOperation().Please note that this
+	 * value must be smaller than MAX_DOWNLINK_PACKETS_STORED
+	 * @param sentPacketsPerCycle
+	 * @return -@c RETURN_OK if value was set successfully
+	 *         -@c RETURN_FAILED otherwise, stored value stays the same
+	 */
+	ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
+
 	void registerCommConnect();
 	void registerCommDisconnect();
 
@@ -94,7 +106,13 @@ protected:
 	 * Read the TM Queue and send TM if necessary. Default implementation provided
 	 * @return
 	 */
-	virtual ReturnValue_t readTmQueue();
+	virtual ReturnValue_t handleTmQueue();
+
+	/**
+	 * Send stored data if communication link is active
+	 * @return
+	 */
+	virtual ReturnValue_t handleStoredTm();
 
 	/**
 	 * Implemented by child class. Perform sending of Telemetry by implementing
@@ -112,11 +130,6 @@ protected:
 	 */
 	virtual ReturnValue_t storeDownlinkData(TmTcMessage * message);
 
-	/**
-	 * Send stored data if communication link is active
-	 * @return
-	 */
-	ReturnValue_t sendStoredTm();
 
 	/**
 	 * Print data as hexidecimal array
@@ -126,8 +139,9 @@ protected:
 	void printData(uint8_t * data, size_t dataLen);
 
 private:
-	FIFO<store_address_t, MAX_DOWNLINK_PACKETS_STORED> fifo;
-	uint8_t sentPacketsPerCycle = 10;
+	FIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> fifo;
+	uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
+	uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };
 
 

From e40c9f42c676ef5fabe55e1392f88e3a8ba11884 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 10:22:25 +0200
Subject: [PATCH 0200/1774] info output commented out

---
 tmtcservices/TmTcBridge.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 646f736aa..53dd422b5 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -169,13 +169,13 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 
 void TmTcBridge::registerCommConnect() {
 	if(!communicationLinkUp) {
-		info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
+		//info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
 		communicationLinkUp = true;
 	}
 }
 
 void TmTcBridge::registerCommDisconnect() {
-	info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
+	//info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
 	if(communicationLinkUp) {
 		communicationLinkUp = false;
 	}

From 40d952a3491f549989f5bfb15da6000b8f77b3d1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 10:24:34 +0200
Subject: [PATCH 0201/1774] minor form changes

---
 tmtcservices/TmTcBridge.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 53dd422b5..547d34544 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -22,7 +22,7 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 	}
 	else {
 	    warning << "TmTcBridge: Number of packets sent per cycle "
-	               "exceeds limits" << std::endl;
+	               "exceeds limits. Keeping default value." << std::endl;
 		return RETURN_FAILED;
 	}
 }
@@ -35,7 +35,7 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
     }
     else {
         warning << "TmTcBridge: Number of packets stored "
-                   "exceeds limits" << std::endl;
+                   "exceeds limits. Keeping default value." << std::endl;
         return RETURN_FAILED;
     }
 }
@@ -141,7 +141,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 ReturnValue_t TmTcBridge::handleStoredTm() {
 	uint8_t counter = 0;
 	ReturnValue_t result = RETURN_OK;
-	while(!fifo.empty() && counter < sentPacketsPerCycle) {
+	while(not fifo.empty() && counter < sentPacketsPerCycle) {
 		//info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
@@ -168,7 +168,7 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 }
 
 void TmTcBridge::registerCommConnect() {
-	if(!communicationLinkUp) {
+	if(not communicationLinkUp) {
 		//info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
 		communicationLinkUp = true;
 	}
@@ -189,7 +189,7 @@ MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
 
 void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
 	info << "TMTC Bridge: Printing data: [";
-	for(uint32_t i=0;i<dataLen;i++) {
+	for(uint32_t i = 0; i < dataLen; i++) {
 		info << std::hex << (int)data[i];
 		if(i < dataLen-1){
 			info << " , ";

From ee2ee745c7329445a408137dd95b7e243a4b5adf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 12:47:59 +0200
Subject: [PATCH 0202/1774] fifo renamed

---
 tmtcservices/TmTcBridge.cpp | 12 ++++++------
 tmtcservices/TmTcBridge.h   | 11 +++++++----
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 547d34544..4e65cefac 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -126,14 +126,14 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	//		 "Saving packet ID to be sent later\r\n" << std::flush;
 	store_address_t storeId = 0;
 
-	if(fifo.full()) {
+	if(tmFifo.full()) {
 		error << "TMTC Bridge: TM downlink max. number of stored packet IDs "
 				 "reached! Overwriting old data" << std::endl;
-		fifo.retrieve(&storeId);
+		tmFifo.retrieve(&storeId);
 		tmStore->deleteData(storeId);
 	}
 	storeId = message->getStorageId();
-	fifo.insert(storeId);
+	tmFifo.insert(storeId);
 	tmStored = true;
 	return RETURN_OK;
 }
@@ -141,13 +141,13 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 ReturnValue_t TmTcBridge::handleStoredTm() {
 	uint8_t counter = 0;
 	ReturnValue_t result = RETURN_OK;
-	while(not fifo.empty() && counter < sentPacketsPerCycle) {
+	while(not tmFifo.empty() && counter < sentPacketsPerCycle) {
 		//info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
 		const uint8_t* data = NULL;
 		size_t size = 0;
-		fifo.retrieve(&storeId);
+		tmFifo.retrieve(&storeId);
 		result = tmStore->getData(storeId, &data, &size);
 
 		sendTm(data,size);
@@ -159,7 +159,7 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 		}
 		counter ++;
 
-		if(fifo.empty()) {
+		if(tmFifo.empty()) {
 			tmStored = false;
 		}
 		tmStore->deleteData(storeId);
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index f589a4d93..0a1fcfaba 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -138,10 +138,13 @@ protected:
 	 */
 	void printData(uint8_t * data, size_t dataLen);
 
-private:
-	FIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> fifo;
-	uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
-	uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
+	/**
+	 * This fifo can be used to store downlink data
+	 * which can not be sent at the moment.
+	 */
+	FIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
+    uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
+    uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };
 
 

From 44d467808939a803f837d188b006cedd332f3d0a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 14:06:48 +0200
Subject: [PATCH 0203/1774] fifo features and stopwatch enhancement

---
 container/FIFO.h        | 20 ++++++++++++++++++++
 timemanager/Stopwatch.h |  3 ++-
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/container/FIFO.h b/container/FIFO.h
index 00f56993a..889d2ade7 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -59,6 +59,26 @@ public:
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
+
+	ReturnValue_t peek(T * value) {
+	    if(empty()) {
+	        return EMPTY;
+	    } else {
+	       *value = data[readIndex];
+	       return HasReturnvaluesIF::RETURN_OK;
+	    }
+	}
+
+	ReturnValue_t pop() {
+	    if(empty()) {
+	        return EMPTY;
+	    } else {
+	        readIndex = next(readIndex);
+	        --currentSize;
+	        return HasReturnvaluesIF::RETURN_OK;
+	    }
+	}
+
 	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);
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 786a9d571..f48c04eca 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -56,12 +56,13 @@ public:
 
     StopwatchDisplayMode getDisplayMode() const;
     void setDisplayMode(StopwatchDisplayMode displayMode);
+    bool displayOnDestruction = true;
 private:
     timeval startTime {0, 0};
     timeval elapsedTime {0, 0};
 
     StopwatchDisplayMode displayMode = StopwatchDisplayMode::MILLIS;
-    bool displayOnDestruction = true;
+
     void stopInternal();
 };
 

From 1415cd2339931cec2dda229782af069459a02f3d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 17:54:41 +0200
Subject: [PATCH 0204/1774] using newer bin semaph create call.

architecture dependant function call is external now and shall
be implemented by developer
---
 osal/FreeRTOS/BinarySemaphore.cpp | 24 +++++++++++++-----------
 osal/FreeRTOS/BinarySemaphore.h   |  8 ++++++--
 osal/FreeRTOS/TaskManagement.cpp  | 16 ++++++----------
 osal/FreeRTOS/TaskManagement.h    |  7 +++++++
 4 files changed, 32 insertions(+), 23 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index b5f8e6c6c..a6a923aaf 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -8,16 +8,13 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-extern "C" {
-#include "portmacro.h"
-#include "task.h"
-}
-
 BinarySemaphore::BinarySemaphore() {
-	xSemaphoreCreateBinary(handle);
+	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
+
 		error << "Binary semaphore creation failure" << std::endl;
 	}
+	xSemaphoreGive(handle);
 }
 
 BinarySemaphore::~BinarySemaphore() {
@@ -27,36 +24,40 @@ BinarySemaphore::~BinarySemaphore() {
 // This copy ctor is important as it prevents the assignment to a ressource
 // (other.handle) variable which is later deleted!
 BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
-    xSemaphoreCreateBinary(handle);
+    handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         error << "Binary semaphore creation failure" << std::endl;
     }
+    xSemaphoreGive(handle);
 }
 
 BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     if(this != &s) {
-        xSemaphoreCreateBinary(handle);
+        handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
             error << "Binary semaphore creation failure" << std::endl;
         }
+        xSemaphoreGive(handle);
     }
     return *this;
 }
 
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
-    xSemaphoreCreateBinary(handle);
+    handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         error << "Binary semaphore creation failure" << std::endl;
     }
+    xSemaphoreGive(handle);
 }
 
 BinarySemaphore& BinarySemaphore::operator =(
         BinarySemaphore&& s) {
     if(&s != this) {
-        xSemaphoreCreateBinary(handle);
+        handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
             error << "Binary semaphore creation failure" << std::endl;
         }
+        xSemaphoreGive(handle);
     }
     return *this;
 }
@@ -127,7 +128,8 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 void BinarySemaphore::resetSemaphore() {
 	if(handle != nullptr) {
 		vSemaphoreDelete(handle);
-		xSemaphoreCreateBinary(handle);
+		handle = xSemaphoreCreateBinary();
+		xSemaphoreGive(handle);
 	}
 }
 
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 2203c923a..0ab9cdea6 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -18,6 +18,10 @@ extern "C" {
  * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
  * @details
  * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
+ *
+ * SHOULDDO: check freeRTOS version and use new task notifications,
+ * if non-ancient freeRTOS version is used.
+ *
  * @ingroup osal
  */
 class BinarySemaphore: public HasReturnvaluesIF {
@@ -68,8 +72,8 @@ public:
 
 	/**
 	 * 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,
+	 * 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
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 9946833d2..d7ddaf384 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -5,16 +5,12 @@
  *
  */
 #include <framework/osal/FreeRTOS/TaskManagement.h>
-#include <FreeRTOS.h>
-#include "portmacro.h"
-#include "task.h"
 
-/**
- * TODO: This stuff is hardware and architecture and mission dependant...
- * 	     Some FreeRTOS implementations might be able to determine their own task context for example.
- * 	     If not ISRs are used, or task preemption is enabled, some of this stuff might
- * 	     not be necessary anyway. Maybe there is a better solution?
- */
+extern "C" {
+#include "FreeRTOS.h"
+#include "task.h"
+}
+
 void TaskManagement::requestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
@@ -22,7 +18,7 @@ void TaskManagement::requestContextSwitchFromTask() {
 void TaskManagement::requestContextSwitch(CallContext callContext = CallContext::task) {
 	if(callContext == CallContext::isr) {
 		// This function depends on the partmacro.h definition for the specific device
-		portYIELD_FROM_ISR();
+		requestContextSwitchFromISR();
 	} else {
 		requestContextSwitchFromTask();
 	}
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index fd2bfc0b1..c122e0fba 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -7,6 +7,12 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 #define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 
+/**
+ * Architecture dependant portmacro.h function call.
+ * Should be implemented in bsp.
+ */
+extern "C" void requestContextSwitchFromISR();
+
 /*!
  * Used by functions to tell if they are being called from
  * within an ISR or from a regular task. This is required because FreeRTOS
@@ -18,6 +24,7 @@ enum CallContext {
 	isr = 0xFF  //!< isr_context
 };
 
+
 class TaskManagement {
 public:
 	/**

From 328737d0ad5d6efb098963fdf0e5088776f50f64 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 18:12:02 +0200
Subject: [PATCH 0205/1774] newer non-deprecated semaphore call used

---
 osal/FreeRTOS/BinarySemaphore.cpp | 24 +++++++++++++-----------
 osal/FreeRTOS/BinarySemaphore.h   |  8 ++++++--
 2 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index b5f8e6c6c..a6a923aaf 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -8,16 +8,13 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-extern "C" {
-#include "portmacro.h"
-#include "task.h"
-}
-
 BinarySemaphore::BinarySemaphore() {
-	xSemaphoreCreateBinary(handle);
+	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
+
 		error << "Binary semaphore creation failure" << std::endl;
 	}
+	xSemaphoreGive(handle);
 }
 
 BinarySemaphore::~BinarySemaphore() {
@@ -27,36 +24,40 @@ BinarySemaphore::~BinarySemaphore() {
 // This copy ctor is important as it prevents the assignment to a ressource
 // (other.handle) variable which is later deleted!
 BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
-    xSemaphoreCreateBinary(handle);
+    handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         error << "Binary semaphore creation failure" << std::endl;
     }
+    xSemaphoreGive(handle);
 }
 
 BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     if(this != &s) {
-        xSemaphoreCreateBinary(handle);
+        handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
             error << "Binary semaphore creation failure" << std::endl;
         }
+        xSemaphoreGive(handle);
     }
     return *this;
 }
 
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
-    xSemaphoreCreateBinary(handle);
+    handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         error << "Binary semaphore creation failure" << std::endl;
     }
+    xSemaphoreGive(handle);
 }
 
 BinarySemaphore& BinarySemaphore::operator =(
         BinarySemaphore&& s) {
     if(&s != this) {
-        xSemaphoreCreateBinary(handle);
+        handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
             error << "Binary semaphore creation failure" << std::endl;
         }
+        xSemaphoreGive(handle);
     }
     return *this;
 }
@@ -127,7 +128,8 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 void BinarySemaphore::resetSemaphore() {
 	if(handle != nullptr) {
 		vSemaphoreDelete(handle);
-		xSemaphoreCreateBinary(handle);
+		handle = xSemaphoreCreateBinary();
+		xSemaphoreGive(handle);
 	}
 }
 
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 2203c923a..0ab9cdea6 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -18,6 +18,10 @@ extern "C" {
  * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
  * @details
  * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
+ *
+ * SHOULDDO: check freeRTOS version and use new task notifications,
+ * if non-ancient freeRTOS version is used.
+ *
  * @ingroup osal
  */
 class BinarySemaphore: public HasReturnvaluesIF {
@@ -68,8 +72,8 @@ public:
 
 	/**
 	 * 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,
+	 * 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

From fc4199c3b12dfc6f7996d75c035fb0767c21a004 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 18:13:14 +0200
Subject: [PATCH 0206/1774] architecture dependant call delcared external

---
 osal/FreeRTOS/TaskManagement.cpp | 8 +-------
 osal/FreeRTOS/TaskManagement.h   | 7 +++++++
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 0c96c62f0..d7ddaf384 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -8,15 +8,9 @@
 
 extern "C" {
 #include "FreeRTOS.h"
-#include "portmacro.h"
 #include "task.h"
 }
 
-/**
- * TODO: This stuff is hardware and architecture and mission dependant...
- * 	     Maybe there is a better solution? The request ContextSwitch function
- * 	     could be declared external for example.
- */
 void TaskManagement::requestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
@@ -24,7 +18,7 @@ void TaskManagement::requestContextSwitchFromTask() {
 void TaskManagement::requestContextSwitch(CallContext callContext = CallContext::task) {
 	if(callContext == CallContext::isr) {
 		// This function depends on the partmacro.h definition for the specific device
-		portYIELD_FROM_ISR();
+		requestContextSwitchFromISR();
 	} else {
 		requestContextSwitchFromTask();
 	}
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index fd2bfc0b1..c122e0fba 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -7,6 +7,12 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 #define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 
+/**
+ * Architecture dependant portmacro.h function call.
+ * Should be implemented in bsp.
+ */
+extern "C" void requestContextSwitchFromISR();
+
 /*!
  * Used by functions to tell if they are being called from
  * within an ISR or from a regular task. This is required because FreeRTOS
@@ -18,6 +24,7 @@ enum CallContext {
 	isr = 0xFF  //!< isr_context
 };
 
+
 class TaskManagement {
 public:
 	/**

From 0ea692a5ea8e5230ccb14ae42156ac74f05ac851 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 20:04:48 +0200
Subject: [PATCH 0207/1774] some more sif changes

---
 datapool/PoolRawAccessHelper.cpp        | 16 ++++++++--------
 devicehandlers/CommunicationMessage.cpp |  8 ++++----
 osal/FreeRTOS/BinarySemaphore.cpp       | 10 +++++-----
 tmtcpacket/pus/TmPacketStored.cpp       |  2 +-
 4 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 81a9eb01e..963835f5f 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -34,7 +34,7 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 		}
 	}
 	if(remainingParametersSize != 0) {
-		debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
+		sif::debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
 		result = RETURN_FAILED;
 	}
 	return result;
@@ -56,7 +56,7 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		}
 	}
 	if(remainingParametersSize != 0) {
-		debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
+		sif::debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
 		result = RETURN_FAILED;
 	}
 
@@ -75,7 +75,7 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
 			&poolIdBuffer,remainingParameters,true);
 	if(result != RETURN_OK) {
-		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing "
+		sif::debug << std::hex << "Pool Raw Access Helper: Error deSeralizing "
 				"pool IDs" << std::dec << std::endl;
 		return result;
 	}
@@ -96,7 +96,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 	while(not poolEntrySerialized) {
 
 		if(counter > DataSet::DATA_SET_MAX_SIZE) {
-			error << "Pool Raw Access Helper: Config error, "
+			sif::error << "Pool Raw Access Helper: Config error, "
 					 "max. number of possible data set variables exceeded"
 				  << std::endl;
 			return result;
@@ -110,7 +110,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
-			debug << std::hex << "Pool Raw Access Helper: Error reading raw "
+			sif::debug << std::hex << "Pool Raw Access Helper: Error reading raw "
 					"dataset with returncode 0x"
 				  << result << std::dec << std::endl;
 			return result;
@@ -119,7 +119,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized,
 				&arrayPosition);
 		if(result != RETURN_OK) {
-			error << "Pool Raw Access Helper: Configuration Error at pool ID "
+			sif::error << "Pool Raw Access Helper: Configuration Error at pool ID "
 				  << std::hex << currentPoolId
 				  << ". Size till end smaller than 0" << std::dec << std::endl;
 			return result;
@@ -136,7 +136,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
 				argStruct.max_size, argStruct.bigEndian);
 		if (result != RETURN_OK) {
-			debug << "Pool Raw Access Helper: Error serializing pool data with "
+			sif::debug << "Pool Raw Access Helper: Error serializing pool data with "
 					 "ID 0x" << std::hex << currentPoolId << " into send buffer "
 					 "with return code " << result << std::dec << std::endl;
 			return result;
@@ -174,7 +174,7 @@ void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
 uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position,
 		bool value) {
 	if(position < 1 or position > 8) {
-		debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+		sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
 		return byte;
 	}
 	uint8_t shiftNumber = position + (6 - 2 * (position - 1));
diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index 028e8a2e1..a80e7de18 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -126,7 +126,7 @@ void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
 		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte));
 	}
 	else {
-		error << "Comm Message: Invalid byte position" << std::endl;
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
 	}
 }
 
@@ -138,7 +138,7 @@ uint8_t CommunicationMessage::getDataByte(uint8_t position) const {
 	}
 	else {
 		return 0;
-		error << "Comm Message: Invalid byte position" << std::endl;
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
 	}
 }
 
@@ -147,7 +147,7 @@ void CommunicationMessage::setDataUint16(uint16_t data, uint8_t position) {
 		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), &data, sizeof(data));
 	}
 	else {
-		error << "Comm Message: Invalid byte position" << std::endl;
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
 	}
 
 }
@@ -160,7 +160,7 @@ uint16_t CommunicationMessage::getDataUint16(uint8_t position) const{
 	}
 	else {
 		return 0;
-		error << "Comm Message: Invalid byte position" << std::endl;
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
 	}
 }
 
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index a6a923aaf..6cacef655 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -12,7 +12,7 @@ BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
 
-		error << "Binary semaphore creation failure" << std::endl;
+		sif::error << "Binary semaphore creation failure" << std::endl;
 	}
 	xSemaphoreGive(handle);
 }
@@ -26,7 +26,7 @@ BinarySemaphore::~BinarySemaphore() {
 BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
-        error << "Binary semaphore creation failure" << std::endl;
+        sif::error << "Binary semaphore creation failure" << std::endl;
     }
     xSemaphoreGive(handle);
 }
@@ -35,7 +35,7 @@ BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     if(this != &s) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
-            error << "Binary semaphore creation failure" << std::endl;
+            sif::error << "Binary semaphore creation failure" << std::endl;
         }
         xSemaphoreGive(handle);
     }
@@ -45,7 +45,7 @@ BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
-        error << "Binary semaphore creation failure" << std::endl;
+        sif::error << "Binary semaphore creation failure" << std::endl;
     }
     xSemaphoreGive(handle);
 }
@@ -55,7 +55,7 @@ BinarySemaphore& BinarySemaphore::operator =(
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
-            error << "Binary semaphore creation failure" << std::endl;
+            sif::error << "Binary semaphore creation failure" << std::endl;
         }
         xSemaphoreGive(handle);
     }
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 1ca872847..42d0d0387 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -22,7 +22,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
 
 	if (returnValue != store->RETURN_OK) {
-		debug << "TM Packet Stored: Issue getting free storage" << std::endl;
+		sif::debug << "TM Packet Stored: Issue getting free storage" << std::endl;
 		checkAndReportLostTm();
 		return;
 	}

From a5d2cbd7db6d6f47e7a3f75cc429ac36070f806e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 21:59:24 +0200
Subject: [PATCH 0208/1774] some more sif replacements

---
 osal/FreeRTOS/FixedTimeslotTask.cpp |  2 +-
 osal/FreeRTOS/Mutex.cpp             |  2 +-
 serialize/SerialBufferAdapter.cpp   |  4 ++--
 storagemanager/LocalPool.h          |  2 +-
 timemanager/Stopwatch.cpp           |  4 ++--
 tmtcservices/TmTcBridge.cpp         | 24 ++++++++++++------------
 6 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index d6fa5936f..aed66349c 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -67,7 +67,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	error << "Component " << std::hex << componentId
+	sif::error << "Component " << std::hex << componentId
 		  << " not found, not adding it to pst" << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 616ef7b85..25513a819 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -7,7 +7,7 @@ const uint32_t MutexIF::NO_TIMEOUT = 0;
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
 	if(handle == NULL) {
-		error << "Mutex creation failure" << std::endl;
+		sif::error << "Mutex creation failure" << std::endl;
 	}
 }
 
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 5fb5e3873..3df2abe91 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -100,7 +100,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 template<typename count_t>
 uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 	if(m_buffer == nullptr) {
-		error << "Wrong access function for stored type !"
+		sif::error << "Wrong access function for stored type !"
 				 " Use getConstBuffer()" << std::endl;
 		return nullptr;
 	}
@@ -110,7 +110,7 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
-		error << "Wrong access function for stored type !"
+		sif::error << "Wrong access function for stored type !"
 				 " Use getBuffer()" << std::endl;
 		return nullptr;
 	}
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index b541c5e12..7e934c406 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -295,7 +295,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
 		if (!ignoreFault) {
 			internalErrorReporter->storeFull();
 		}
-		error << "LocalPool( " << std::hex << getObjectId() << std::dec
+		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
 				<< " )::reserveSpace: Packet store is full." << std::endl;
 	}
 	return status;
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 3f0755fd7..e20184691 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -31,11 +31,11 @@ seconds_t Stopwatch::stopSeconds() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
-        info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
+        sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
                 elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {
-        info <<"Stopwatch: Operation took "  << std::setprecision(3)
+        sif::info <<"Stopwatch: Operation took "  << std::setprecision(3)
              << std::fixed << timevalOperations::toDouble(elapsedTime)
              << " seconds" << std::endl;
     }
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 4e65cefac..c5eaf78b5 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -21,7 +21,7 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 		return RETURN_OK;
 	}
 	else {
-	    warning << "TmTcBridge: Number of packets sent per cycle "
+	    sif::warning << "TmTcBridge: Number of packets sent per cycle "
 	               "exceeds limits. Keeping default value." << std::endl;
 		return RETURN_FAILED;
 	}
@@ -34,7 +34,7 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
         return RETURN_OK;
     }
     else {
-        warning << "TmTcBridge: Number of packets stored "
+        sif::warning << "TmTcBridge: Number of packets stored "
                    "exceeds limits. Keeping default value." << std::endl;
         return RETURN_FAILED;
     }
@@ -62,11 +62,11 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 	ReturnValue_t result;
 	result = handleTc();
 	if(result != RETURN_OK) {
-		error << "TMTC Bridge: Error handling TCs" << std::endl;
+		sif::error << "TMTC Bridge: Error handling TCs" << std::endl;
 	}
 	result = handleTm();
 	if (result != RETURN_OK) {
-		error << "TMTC Bridge: Error handling TMs" << std::endl;
+		sif::error << "TMTC Bridge: Error handling TMs" << std::endl;
 	}
 	return result;
 }
@@ -81,7 +81,7 @@ ReturnValue_t TmTcBridge::handleTc() {
 ReturnValue_t TmTcBridge::handleTm() {
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
-		error << "TMTC Bridge: Reading TM Queue failed" << std::endl;
+		sif::error << "TMTC Bridge: Reading TM Queue failed" << std::endl;
 		return RETURN_FAILED;
 	}
 
@@ -111,7 +111,7 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 
 		result = sendTm(data, size);
 		if (result != RETURN_OK) {
-			error << "TMTC Bridge: Could not send TM packet"<< std::endl;
+			sif::error << "TMTC Bridge: Could not send TM packet"<< std::endl;
 			tmStore->deleteData(message.getStorageId());
 			return result;
 
@@ -127,7 +127,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	store_address_t storeId = 0;
 
 	if(tmFifo.full()) {
-		error << "TMTC Bridge: TM downlink max. number of stored packet IDs "
+		sif::error << "TMTC Bridge: TM downlink max. number of stored packet IDs "
 				 "reached! Overwriting old data" << std::endl;
 		tmFifo.retrieve(&storeId);
 		tmStore->deleteData(storeId);
@@ -153,7 +153,7 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 		sendTm(data,size);
 
 		if(result != RETURN_OK) {
-			error << "TMTC Bridge: Could not send stored downlink data"
+			sif::error << "TMTC Bridge: Could not send stored downlink data"
 			      << std::endl;
 			result = RETURN_FAILED;
 		}
@@ -188,12 +188,12 @@ MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
 
 
 void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
-	info << "TMTC Bridge: Printing data: [";
+	sif::info << "TMTC Bridge: Printing data: [";
 	for(uint32_t i = 0; i < dataLen; i++) {
-		info << std::hex << (int)data[i];
+		sif::info << std::hex << (int)data[i];
 		if(i < dataLen-1){
-			info << " , ";
+			sif::info << " , ";
 		}
 	}
-	info << " ] " << std::endl;
+	sif::info << " ] " << std::endl;
 }

From ecf3b4b535f7becb1adbd8f0ca1619545b04f4ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 22:05:12 +0200
Subject: [PATCH 0209/1774] stopwatch warning fix

---
 timemanager/Stopwatch.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index e20184691..1f287fb38 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -9,8 +9,8 @@
 #include <iomanip>
 
 Stopwatch::Stopwatch(bool displayOnDestruction,
-        StopwatchDisplayMode displayMode): displayMode(displayMode),
-        displayOnDestruction(displayOnDestruction) {
+        StopwatchDisplayMode displayMode): displayOnDestruction(
+        displayOnDestruction), displayMode(displayMode) {
     // Measures start time on initialization.
     startTime = Clock::getUptime();
 }

From 7ec6d2ceaa74f3823db8fe49cef0ff811cbabdd6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Apr 2020 18:58:55 +0200
Subject: [PATCH 0210/1774] remove dspecial character messing with decoding

---
 thermal/TemperatureSensor.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index b4172670e..96dedc991 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -29,7 +29,7 @@ public:
 	 *
 	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
 	 *
-	 * The lower and upper limits can be specified in any type, for example float for C° values
+	 * The lower and upper limits can be specified in any type, for example float for C values
 	 * or any other type for raw values.
 	 */
 	struct Parameters {
@@ -151,7 +151,7 @@ protected:
 			}
 		}
 
-		//Check is done against raw limits. SHOULDDO: Why? Using °C would be more easy to handle.
+		//Check is done against raw limits. SHOULDDO: Why? Using �C would be more easy to handle.
 		sensorMonitor.doCheck(outputTemperature.value);
 
 		if (sensorMonitor.isOutOfLimits()) {

From e1aa285b6db9733c3b302a0c3c1c0231a2a5e561 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 29 Apr 2020 13:46:30 +0200
Subject: [PATCH 0211/1774] linux osal output in namespace

---
 osal/linux/FixedTimeslotTask.cpp |  7 ++---
 osal/linux/MessageQueue.cpp      | 44 ++++++++++++++++++++------------
 osal/linux/Mutex.cpp             |  8 +++---
 osal/linux/PeriodicPosixTask.cpp |  4 +--
 osal/linux/PosixThread.cpp       | 42 +++++++++++++++++++-----------
 osal/linux/Timer.cpp             |  3 ++-
 6 files changed, 67 insertions(+), 41 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 7f117301a..04ceb4e68 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -43,7 +43,8 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	if (!objectManager->get<ExecutableObjectIF>(componentId)) {
-		error << "Component " << std::hex << componentId << " not found, not adding it to pst" << std::endl;
+		sif::error << "Component " << std::hex << componentId
+				   << " not found, not adding it to pst" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -87,7 +88,7 @@ void FixedTimeslotTask::taskFunctionality() {
 void FixedTimeslotTask::missedDeadlineCounter() {
 	FixedTimeslotTask::deadlineMissedCount++;
 	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-		error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
-				<< " deadlines." << std::endl;
+		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
+				   << " deadlines." << std::endl;
 	}
 }
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index a2e878751..edabe9467 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -17,11 +17,11 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 	attributes.mq_maxmsg = message_depth;
 	attributes.mq_msgsize = max_message_size;
 	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
-
 	//Set the name of the queue
 	sprintf(name, "/Q%u\n", queueCounter++);
 
-	//Create a nonblocking queue if the name is available (the queue is Read and writable for the owner as well as the group)
+	//Create a nonblocking queue if the name is available (the queue is Read and
+	// writable for the owner as well as the group)
 	mqd_t tempId = mq_open(name, O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
 	S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH, &attributes);
 	if (tempId == -1) {
@@ -32,8 +32,8 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 			//We unlink the other queue
 			int status = mq_unlink(name);
 			if (status != 0) {
-				error << "mq_unlink Failed with status: " << strerror(errno)
-						<< std::endl;
+				sif::error << "mq_unlink Failed with status: " << strerror(errno)
+						   << std::endl;
 			} else {
 				//Successful unlinking, try to open again
 				mqd_t tempId = mq_open(name,
@@ -47,7 +47,7 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 			}
 		}
 		//Failed either the first time or the second time
-		error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 				<< name << std::dec << " failed with status: "
 				<< strerror(errno) << std::endl;
 	} else {
@@ -59,11 +59,13 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 MessageQueue::~MessageQueue() {
 	int status = mq_close(this->id);
 	if(status != 0){
-		error << "MessageQueue::Destructor: mq_close Failed with status: " << strerror(errno) <<std::endl;
+		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
+				   << strerror(errno) <<std::endl;
 	}
 	status = mq_unlink(name);
 	if(status != 0){
-		error << "MessageQueue::Destructor: mq_unlink Failed with status: " << strerror(errno) <<std::endl;
+		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
+				   << strerror(errno) <<std::endl;
 	}
 }
 
@@ -93,7 +95,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 	unsigned int messagePriority = 0;
-	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),message->MAX_MESSAGE_SIZE,&messagePriority);
+	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
+			message->MAX_MESSAGE_SIZE,&messagePriority);
 	if (status > 0) {
 		this->lastPartner = message->getSender();
 		//Check size of incoming message.
@@ -114,7 +117,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 			return MessageQueueIF::EMPTY;
 		case EBADF:
 			//mqdes doesn't represent a valid queue open for reading.
-			error << "MessageQueue::receive: configuration error " << strerror(errno)  << std::endl;
+			sif::error << "MessageQueue::receive: configuration error "
+			           << strerror(errno)  << std::endl;
 			/*NO BREAK*/
 		case EINVAL:
 			/*
@@ -123,7 +127,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 			 * * The number of bytes requested, msg_len is less than zero.
 			 * * msg_len is anything other than the mq_msgsize of the specified queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't been set in the queue's mq_flags.
 			 */
-			error << "MessageQueue::receive: configuration error " << strerror(errno)  << std::endl;
+			sif::error << "MessageQueue::receive: configuration error "
+					   << strerror(errno)  << std::endl;
 			/*NO BREAK*/
 		case EMSGSIZE:
 			/*
@@ -131,7 +136,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 			 * * the QNX extended option MQ_READBUF_DYNAMIC hasn't been set, and the given msg_len is shorter than the mq_msgsize for the given queue.
 			 * * the extended option MQ_READBUF_DYNAMIC has been set, but the given msg_len is too short for the message that would have been received.
 			 */
-			error << "MessageQueue::receive: configuration error " << strerror(errno)  << std::endl;
+			sif::error << "MessageQueue::receive: configuration error "
+			           << strerror(errno)  << std::endl;
 			/*NO BREAK*/
 		case EINTR:
 			//The operation was interrupted by a signal.
@@ -154,7 +160,8 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		switch(errno){
 		case EBADF:
 			//mqdes doesn't represent a valid message queue.
-			error << "MessageQueue::flush configuration error, called flush with an invalid queue ID" << std::endl;
+			sif::error << "MessageQueue::flush configuration error, "
+					"called flush with an invalid queue ID" << std::endl;
 			/*NO BREAK*/
 		case EINVAL:
 			//mq_attr is NULL
@@ -169,7 +176,8 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		switch(errno){
 		case EBADF:
 			//mqdes doesn't represent a valid message queue.
-			error << "MessageQueue::flush configuration error, called flush with an invalid queue ID" << std::endl;
+			sif::error << "MessageQueue::flush configuration error, "
+					"called flush with an invalid queue ID" << std::endl;
 			/*NO BREAK*/
 		case EINVAL:
 			/*
@@ -237,7 +245,9 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			return MessageQueueIF::FULL;
 		case EBADF:
 			//mq_des doesn't represent a valid message queue descriptor, or mq_des wasn't opened for writing.
-			error << "MessageQueue::sendMessage: Configuration error " << strerror(errno) << " in mq_send mqSendTo: " << sendTo << " sent from " << sentFrom << std::endl;
+			sif::error << "MessageQueue::sendMessage: Configuration error "
+			           << strerror(errno) << " in mq_send mqSendTo: " << sendTo
+					   << " sent from " << sentFrom << std::endl;
 			/*NO BREAK*/
 		case EINTR:
 			//The call was interrupted by a signal.
@@ -248,9 +258,11 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			 * * msg_len is negative.
 			 * * msg_prio is greater than MQ_PRIO_MAX.
 			 * * msg_prio is less than 0.
-			 * * MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and msg_prio is greater than the priority of the calling process.
+			 * * MQ_PRIO_RESTRICT is set in the mq_attr of mq_des,
+			 *   and msg_prio is greater than the priority of the calling process.
 			 * */
-			error << "MessageQueue::sendMessage: Configuration error " << strerror(errno) << " in mq_send" << std::endl;
+			sif::error << "MessageQueue::sendMessage: Configuration error "
+			           << strerror(errno) << " in mq_send" << std::endl;
 			/*NO BREAK*/
 		case EMSGSIZE:
 			//The msg_len is greater than the msgsize associated with the specified queue.
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index 055270b3c..36bb3ce43 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -13,22 +13,22 @@ Mutex::Mutex() {
 	pthread_mutexattr_t mutexAttr;
 	int status = pthread_mutexattr_init(&mutexAttr);
 	if (status != 0) {
-		error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
+		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
 	}
 	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
 	if (status != 0) {
-		error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
+		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
 				<< std::endl;
 	}
 	status = pthread_mutex_init(&mutex, &mutexAttr);
 	if (status != 0) {
-		error << "Mutex: creation with name, id " << mutex.__data.__count
+		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
 				<< ", " << " failed with " << strerror(status) << std::endl;
 	}
 	//After a mutex attributes object has been used to initialize one or more mutexes, any function affecting the attributes object (including destruction) shall not affect any previously initialized mutexes.
 	status = pthread_mutexattr_destroy(&mutexAttr);
 	if (status != 0) {
-		error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
+		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
 	}
 }
 
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index ee3c5c4ac..b754c3f44 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -56,9 +56,9 @@ void PeriodicPosixTask::taskFunctionality(void){
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
 			if(status==0){
-				error << "ObjectTask: " << name << " Deadline missed." << std::endl;
+				sif::error << "ObjectTask: " << name << " Deadline missed." << std::endl;
 			}else{
-				error << "ObjectTask: X Deadline missed. " << status << std::endl;
+				sif::error << "ObjectTask: X Deadline missed. " << status << std::endl;
 			}
 			if (this->deadlineMissedFunc != NULL) {
 				this->deadlineMissedFunc();
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 2f0176c9e..899700f0d 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -22,7 +22,8 @@ ReturnValue_t PosixThread::sleep(uint64_t ns) {
 			//The nanosleep() function was interrupted by a signal.
 			return HasReturnvaluesIF::RETURN_FAILED;
 		case EINVAL:
-			//The rqtp argument specified a nanosecond value less than zero or greater than or equal to 1000 million.
+			//The rqtp argument specified a nanosecond value less than zero or
+			// greater than or equal to 1000 million.
 			return HasReturnvaluesIF::RETURN_FAILED;
 		default:
 			return HasReturnvaluesIF::RETURN_FAILED;
@@ -40,8 +41,8 @@ void PosixThread::suspend() {
 	sigaddset(&waitSignal, SIGUSR1);
 	sigwait(&waitSignal, &caughtSig);
 	if (caughtSig != SIGUSR1) {
-		error << "FixedTimeslotTask: Unknown Signal received: " << caughtSig
-				<< std::endl;
+		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
+				caughtSig << std::endl;
 	}
 }
 
@@ -112,14 +113,15 @@ uint64_t PosixThread::getCurrentMonotonicTimeMs(){
 	return currentTime_ms;
 }
 
-PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):thread(0),priority(priority_),stackSize(stackSize_) {
+PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
+		thread(0),priority(priority_),stackSize(stackSize_) {
 	strcpy(name,name_);
 }
 
 
 
 void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
-	debug << "PosixThread::createTask" << std::endl;
+	//sif::debug << "PosixThread::createTask" << std::endl;
 	/*
 	 * The attr argument points to a pthread_attr_t structure whose contents
        are used at thread creation time to determine attributes for the new
@@ -130,35 +132,41 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	pthread_attr_t attributes;
 	int status = pthread_attr_init(&attributes);
 	if(status != 0){
-			error << "Posix Thread attribute init failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread attribute init failed with: " <<
+				strerror(status) << std::endl;
 	}
 	void* sp;
 	status = posix_memalign(&sp, sysconf(_SC_PAGESIZE), stackSize);
 	if(status != 0){
-			error << "Posix Thread stack init failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread stack init failed with: " <<
+				strerror(status) << std::endl;
 	}
 
 	status = pthread_attr_setstack(&attributes, sp, stackSize);
 	if(status != 0){
-			error << "Posix Thread attribute setStack failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread attribute setStack failed with: " <<
+				strerror(status) << std::endl;
 	}
 
 	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
 	if(status != 0){
-			error << "Posix Thread attribute setinheritsched failed with: " << strerror(status) << std::endl;
+			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
+					strerror(status) << std::endl;
 	}
 
 //TODO FIFO -> This needs root privileges for the process
 	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
 	if(status != 0){
-		error << "Posix Thread attribute schedule policy failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread attribute schedule policy failed with: " <<
+				strerror(status) << std::endl;
 	}
 
 	sched_param scheduleParams;
 	scheduleParams.__sched_priority = priority;
 	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
 	if(status != 0){
-			error << "Posix Thread attribute schedule params failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread attribute schedule params failed with: " <<
+				strerror(status) << std::endl;
 	}
 
 	//Set Signal Mask for suspend until startTask is called
@@ -167,22 +175,26 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	sigaddset(&waitSignal, SIGUSR1);
 	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
 	if(status != 0){
-			error << "Posix Thread sigmask failed failed with: " << strerror(status) << " errno: " << strerror(errno) << std::endl;
+		sif::error << "Posix Thread sigmask failed failed with: " <<
+				strerror(status) << " errno: " << strerror(errno) << std::endl;
 	}
 
 
 	status = pthread_create(&thread,&attributes,fnc_,arg_);
 	if(status != 0){
-		error << "Posix Thread create failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread create failed with: " <<
+				strerror(status) << std::endl;
 	}
 
 	status = pthread_setname_np(thread,name);
 	if(status != 0){
-		error << "Posix Thread setname failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread setname failed with: " <<
+				strerror(status) << std::endl;
 	}
 
 	status = pthread_attr_destroy(&attributes);
 	if(status!=0){
-		error << "Posix Thread attribute destroy failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread attribute destroy failed with: " <<
+				strerror(status) << std::endl;
 	}
 }
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index 2347e39d7..5e27c328e 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -9,7 +9,8 @@ Timer::Timer() {
 	sigEvent.sigev_value.sival_ptr = &timerId;
 	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
 	if(status!=0){
-		error << "Timer creation failed with: " << status << " errno: " << errno << std::endl;
+		sif::error << "Timer creation failed with: " << status <<
+				" errno: " << errno << std::endl;
 	}
 }
 

From 431709a3ecefb0a358726e7f94e2f45131a7d914 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 30 Apr 2020 15:42:33 +0200
Subject: [PATCH 0212/1774] pool raw acces helper bugfix

---
 datapool/PoolRawAccessHelper.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 963835f5f..31c0b6f2e 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -73,7 +73,7 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
 	uint32_t currentPoolId;
 	// Deserialize current pool ID from pool ID buffer
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
-			&poolIdBuffer,remainingParameters,true);
+			&poolIdBuffer,remainingParameters, false);
 	if(result != RETURN_OK) {
 		sif::debug << std::hex << "Pool Raw Access Helper: Error deSeralizing "
 				"pool IDs" << std::dec << std::endl;

From 03333c2af0cc698646f617812fc183a2627ce974 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 30 Apr 2020 21:37:02 +0200
Subject: [PATCH 0213/1774] pool raw acces printout

---
 container/SinglyLinkedList.h     |  2 +-
 datapool/PoolRawAccessHelper.cpp | 15 ++++++++-------
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index b926bd007..54e7687cd 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -62,7 +62,7 @@ public:
 	}
 
 	void setEnd() {
-		this->next = NULL;
+		this->next = nullptr;
 	}
 
 	LinkedElement* begin() {
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 31c0b6f2e..91d6309f4 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -34,7 +34,8 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 		}
 	}
 	if(remainingParametersSize != 0) {
-		sif::debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
+		sif::debug << "PoolRawAccessHelper: "
+				"Remaining parameters size not 0 !" << std::endl;
 		result = RETURN_FAILED;
 	}
 	return result;
@@ -56,7 +57,8 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		}
 	}
 	if(remainingParametersSize != 0) {
-		sif::debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
+		sif::debug << "PoolRawAccessHelper: Remaining "
+				"parameters size not 0 !" << std::endl;
 		result = RETURN_FAILED;
 	}
 
@@ -75,7 +77,7 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
 			&poolIdBuffer,remainingParameters, false);
 	if(result != RETURN_OK) {
-		sif::debug << std::hex << "Pool Raw Access Helper: Error deSeralizing "
+		sif::debug << std::hex << "PoolRawAccessHelper: Error deSeralizing "
 				"pool IDs" << std::dec << std::endl;
 		return result;
 	}
@@ -96,7 +98,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 	while(not poolEntrySerialized) {
 
 		if(counter > DataSet::DATA_SET_MAX_SIZE) {
-			sif::error << "Pool Raw Access Helper: Config error, "
+			sif::error << "PoolRawAccessHelper: Config error, "
 					 "max. number of possible data set variables exceeded"
 				  << std::endl;
 			return result;
@@ -110,9 +112,8 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
-			sif::debug << std::hex << "Pool Raw Access Helper: Error reading raw "
-					"dataset with returncode 0x"
-				  << result << std::dec << std::endl;
+			sif::debug << std::hex << "PoolRawAccessHelper: Error reading raw "
+					"dataset with returncode 0x" << result << std::dec << std::endl;
 			return result;
 		}
 

From 15c03863c008fb6d8b455bed15985ed725df3bc9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 1 May 2020 14:49:52 +0200
Subject: [PATCH 0214/1774] additional docmentation for freeRTOS task factory

---
 osal/FreeRTOS/TaskFactory.cpp    |  8 +++----
 osal/FreeRTOS/TaskManagement.cpp |  6 -----
 osal/FreeRTOS/TaskManagement.h   |  7 +-----
 tasks/TaskFactory.h              | 39 +++++++++++++++++++-------------
 4 files changed, 27 insertions(+), 33 deletions(-)

diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 753da60f7..6b18d7a85 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -13,10 +13,7 @@ TaskFactory::~TaskFactory() {
 TaskFactory* TaskFactory::instance() {
 	return TaskFactory::factoryInstance;
 }
-/***
- * Keep in Mind that you need to call before this vTaskStartScheduler()!
- * High taskPriority_ number means high priority.
- */
+
 PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
 		TaskPriority taskPriority_, TaskStackSize stackSize_,
 		TaskPeriod period_,
@@ -24,7 +21,8 @@ PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
 	return (PeriodicTaskIF*) (new PeriodicTask(name_, taskPriority_, stackSize_,
 			period_, deadLineMissedFunction_));
 }
-/***
+
+/**
  * Keep in Mind that you need to call before this vTaskStartScheduler()!
  */
 FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index d7ddaf384..3e22021a4 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,9 +1,3 @@
-/**
- * @file TaskManagement.cpp
- *
- * @date 26.02.2020
- *
- */
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
 extern "C" {
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index c122e0fba..4c148ca5e 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -1,12 +1,7 @@
-/**
- * @file TaskManagement.h
- *
- * @date 26.02.2020
- */
-
 #ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 #define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 
+// maybe this can be part of the TaskFactory.cpp
 /**
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 8a59adf1c..6716f7ffd 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
 #define FRAMEWORK_TASKS_TASKFACTORY_H_
 
-#include <stdlib.h>
+#include <cstdlib>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
@@ -19,13 +19,16 @@ public:
 	static TaskFactory* instance();
 
 	/**
-	 * Creates a new periodic task and returns the interface pointer.
-	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack Size of the task
-	 * @param period_ Period of the task
-	 * @param deadLineMissedFunction_ Function to be called if a deadline was missed
-	 * @return PeriodicTaskIF* Pointer to the newly created Task
+	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * @param name_ Name of the task, lenght limited by configMAX_TASK_NAME_LEN
+	 * @param taskPriority_ Number of priorities specified by
+	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
+	 * @param stackSize_ 	Stack size in words (not bytes!).
+	 * Lower limit specified by configMINIMAL_STACK_SIZE
+	 * @param period_		Period in seconds.
+	 * @param deadLineMissedFunction_ Callback if a deadline was missed.
+	 * @return Pointer to the newly created task.
 	 */
 	PeriodicTaskIF* createPeriodicTask(TaskName name_,
 			TaskPriority taskPriority_, TaskStackSize stackSize_,
@@ -33,13 +36,16 @@ public:
 			TaskDeadlineMissedFunction deadLineMissedFunction_);
 
 	/**
-	 *
-	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack Size of the task
-	 * @param period_ Period of the task
-	 * @param deadLineMissedFunction_ Function to be called if a deadline was missed
-	 * @return FixedTimeslotTaskIF* Pointer to the newly created Task
+	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * @param name_ Name of the task, lenght limited by configMAX_TASK_NAME_LEN
+	 * @param taskPriority_ Number of priorities specified by
+	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
+	 * @param stackSize_ 	Stack size in words (not bytes!).
+	 * Lower limit specified by configMINIMAL_STACK_SIZE
+	 * @param period_		Period in seconds.
+	 * @param deadLineMissedFunction_ Callback if a deadline was missed.
+	 * @return Pointer to the newly created task.
 	 */
 	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
 			TaskPriority taskPriority_, TaskStackSize stackSize_,
@@ -48,7 +54,8 @@ public:
 
 	/**
 	 * Function to be called to delete a task
-	 * @param task The pointer to the task that shall be deleted, NULL specifies current Task
+	 * @param task The pointer to the task that shall be deleted,
+	 * 				NULL specifies current Task
 	 * @return Success of deletion
 	 */
 	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);

From 281da25bf97f344fd7b7727530208879c9c7a153 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 1 May 2020 16:47:53 +0200
Subject: [PATCH 0215/1774] extended task management for freeRTOS

---
 osal/FreeRTOS/PeriodicTask.cpp   |  7 ++++---
 osal/FreeRTOS/PeriodicTask.h     | 35 ++++++++++++++++----------------
 osal/FreeRTOS/TaskFactory.cpp    |  4 ----
 osal/FreeRTOS/TaskManagement.cpp | 16 ++++++++++-----
 osal/FreeRTOS/TaskManagement.h   | 32 ++++++++++++++++++++++++++++-
 tasks/TaskFactory.h              |  7 -------
 6 files changed, 63 insertions(+), 38 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index deab2dc15..3075be791 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -6,9 +6,10 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 		TaskStackSize setStack, TaskPeriod setPeriod,
 		void (*setDeadlineMissedFunc)()) :
 		started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
-				setDeadlineMissedFunc) {
-
-	BaseType_t status = xTaskCreate(taskEntryPoint, name, setStack, this, setPriority, &handle);
+		setDeadlineMissedFunc)
+{
+	BaseType_t status = xTaskCreate(taskEntryPoint, name,
+			setStack, this, setPriority, &handle);
 	if(status != pdPASS){
 		sif::debug << "PeriodicTask Insufficient heap memory remaining. Status: "
 		           << status << std::endl;
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 4cbffd5a2..02ab71482 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -13,11 +13,9 @@
 class ExecutableObjectIF;
 
 /**
- * @brief This class represents a specialized task for periodic activities of multiple objects.
- *
- * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
- * 			multiple objects that implement the ExecutableObjectIF interface. The objects must be
- * 			added prior to starting the task.
+ * @brief 	This class represents a specialized task for
+ * 			periodic activities of multiple objects.
+ * @details
  *
  * @ingroup task_handling
  */
@@ -25,21 +23,22 @@ 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 #addObject.
-	 * 			In the underlying TaskBase class, a new operating system task is created.
-	 * 			In addition to the TaskBase parameters, the period, the pointer to the
-	 * 			aforementioned initialization function and an optional "deadline-missed"
-	 * 			function pointer is passed.
-	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
+	 * @details
+	 * The class is initialized without allocated objects. These need to be added
+	 * with #addComponent. In the underlying TaskBase class, a new operating
+	 * system task is created. In addition to the TaskBase parameters,
+	 * the period, the pointer to the aforementioned initialization function and
+	 * an optional "deadline-missed" function pointer is passed.
+	 * @param priority		Sets the priority of a task. Values depend on
+	 * freeRTOS configuration, high number means high priority.
 	 * @param stack_size	The stack size reserved by the operating system for the task.
-	 * @param setPeriod 	The length of the period with which the task's functionality will be
-	 * 						executed. It is expressed in clock ticks.
-	 * @param setDeadlineMissedFunc	The function pointer to the deadline missed function
-	 * 								that shall be assigned.
+	 * @param setPeriod The length of the period with which the task's
+	 * functionality will be executed. It is expressed in clock ticks.
+	 * @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)());
+	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.
diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 6b18d7a85..62015a4cb 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -44,10 +44,6 @@ ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
 	}
 }
 
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
-	vTaskDelay(pdMS_TO_TICKS(delayMs));
-	return HasReturnvaluesIF::RETURN_OK;
-}
 
 TaskFactory::TaskFactory() {
 }
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 3e22021a4..bda43d8bc 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,10 +1,5 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
-extern "C" {
-#include "FreeRTOS.h"
-#include "task.h"
-}
-
 void TaskManagement::requestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
@@ -18,5 +13,16 @@ void TaskManagement::requestContextSwitch(CallContext callContext = CallContext:
 	}
 }
 
+TaskHandle_t TaskManagement::getCurrentTaskHandle() {
+	return xTaskGetCurrentTaskHandle();
+}
 
+configSTACK_DEPTH_TYPE TaskManagement::getTaskStackHighWatermark() {
+	return uxTaskGetStackHighWaterMark(TaskManagement::getCurrentTaskHandle());
+}
+
+ReturnValue_t TaskManagement::delayTask(uint32_t delayMs) {
+	vTaskDelay(pdMS_TO_TICKS(delayMs));
+	return HasReturnvaluesIF::RETURN_OK;
+}
 
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 4c148ca5e..11c4c9dce 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -1,7 +1,14 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 #define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 
-// maybe this can be part of the TaskFactory.cpp
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+extern "C" {
+#include "FreeRTOS.h"
+#include "task.h"
+}
+#include <cstdint>
+
 /**
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
@@ -35,6 +42,29 @@ public:
 	 * can be requested manually by calling this function.
 	 */
 	static void requestContextSwitchFromTask(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 configSTACK_DEPTH_TYPE getTaskStackHighWatermark();
+
+	/**
+	 * Function to be called to delay current task
+	 * @param delay The delay in milliseconds
+	 * @return Success of deletion
+	 */
+	static ReturnValue_t delayTask(uint32_t delayMs);
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 6716f7ffd..31b8b1354 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -60,13 +60,6 @@ public:
 	 */
 	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
 
-	/**
-	 * Function to be called to delay current task
-	 * @param delay The delay in milliseconds
-	 * @return Success of deletion
-	 */
-	static ReturnValue_t delayTask(uint32_t delayMs);
-
 private:
 	/**
 	 * External instantiation is not allowed.

From 35594d4b717e5296581f0227e6d952aebf506cf4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 May 2020 00:48:18 +0200
Subject: [PATCH 0216/1774] goofed up, delay function back in task factory

---
 osal/FreeRTOS/TaskFactory.cpp    | 4 ++++
 osal/FreeRTOS/TaskManagement.cpp | 4 ----
 osal/FreeRTOS/TaskManagement.h   | 7 -------
 tasks/TaskFactory.h              | 7 ++++++-
 4 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 62015a4cb..dc6b1c4e3 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -44,6 +44,10 @@ ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
 	}
 }
 
+ReturnValue_t TaskManagement::delayTask(uint32_t delayMs) {
+	vTaskDelay(pdMS_TO_TICKS(delayMs));
+	return HasReturnvaluesIF::RETURN_OK;
+}
 
 TaskFactory::TaskFactory() {
 }
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index bda43d8bc..522225319 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -21,8 +21,4 @@ configSTACK_DEPTH_TYPE TaskManagement::getTaskStackHighWatermark() {
 	return uxTaskGetStackHighWaterMark(TaskManagement::getCurrentTaskHandle());
 }
 
-ReturnValue_t TaskManagement::delayTask(uint32_t delayMs) {
-	vTaskDelay(pdMS_TO_TICKS(delayMs));
-	return HasReturnvaluesIF::RETURN_OK;
-}
 
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 11c4c9dce..da0cce2a8 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -58,13 +58,6 @@ public:
 	 * 		   words.
 	 */
 	static configSTACK_DEPTH_TYPE getTaskStackHighWatermark();
-
-	/**
-	 * Function to be called to delay current task
-	 * @param delay The delay in milliseconds
-	 * @return Success of deletion
-	 */
-	static ReturnValue_t delayTask(uint32_t delayMs);
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 31b8b1354..f7afa4a22 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -60,13 +60,18 @@ public:
 	 */
 	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
 
+	/**
+	 * Function to be called to delay current task
+	 * @param delay The delay in milliseconds
+	 * @return Success of deletion
+	 */
+	static ReturnValue_t delayTask(uint32_t delayMs);
 private:
 	/**
 	 * External instantiation is not allowed.
 	 */
 	TaskFactory();
 	static TaskFactory* factoryInstance;
-
 };
 
 #endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */

From 3e4263f068aa476a608102acccad93f47b0a6d99 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 May 2020 12:27:18 +0200
Subject: [PATCH 0217/1774] freeRTOS task factory fix

---
 osal/FreeRTOS/TaskFactory.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index dc6b1c4e3..6b18d7a85 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -44,7 +44,7 @@ ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
 	}
 }
 
-ReturnValue_t TaskManagement::delayTask(uint32_t delayMs) {
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
 	vTaskDelay(pdMS_TO_TICKS(delayMs));
 	return HasReturnvaluesIF::RETURN_OK;
 }

From 4b65d6e84739ea13e82441768917c530154d656f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 May 2020 12:33:57 +0200
Subject: [PATCH 0218/1774] local pool bugfix

---
 storagemanager/LocalPool.h   | 5 +++--
 storagemanager/PoolManager.h | 3 ++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 7e934c406..112f01112 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -125,7 +125,8 @@ protected:
 	 * @return	- #RETURN_OK on success,
 	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
 	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault);
+	virtual ReturnValue_t reserveSpace(const uint32_t size,
+			store_address_t* address, bool ignoreFault);
 
 	InternalErrorReporterIF *internalErrorReporter;
 private:
@@ -292,7 +293,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
 
 		size_list[address->pool_index][address->packet_index] = size;
 	} else {
-		if (!ignoreFault) {
+		if (!ignoreFault and internalErrorReporter != nullptr) {
 			internalErrorReporter->storeFull();
 		}
 		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 68a7addc1..329235d51 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -57,7 +57,8 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(const uint32_t s
 template<uint8_t NUMBER_OF_POOLS>
 inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
 		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS]) : LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
+		const uint16_t n_elements[NUMBER_OF_POOLS]) :
+		LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 

From b947253ac3107e05ccb85760bb0413d28c46b5c5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 May 2020 16:49:15 +0200
Subject: [PATCH 0219/1774] local pool neat

---
 storagemanager/LocalPool.h        | 313 ++----------------------------
 storagemanager/LocalPool.tpp      | 260 +++++++++++++++++++++++++
 storagemanager/StorageManagerIF.h |  21 +-
 3 files changed, 287 insertions(+), 307 deletions(-)
 create mode 100644 storagemanager/LocalPool.tpp

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 112f01112..a63344581 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -1,15 +1,6 @@
 #ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
 #define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
 
-/**
- *	@file	LocalPool
- *
- *  @date	02.02.2012
- *	@author	Bastian Baetz
- *
- *	@brief	This file contains the definition of the LocalPool class.
- */
-
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/storagemanager/StorageManagerIF.h>
@@ -70,53 +61,21 @@ public:
 	virtual ~LocalPool(void);
 
 	/**
-	 * Add data to local data pool, performs range check
-	 * @param storageId [out] Store ID in which the data will be stored
-	 * @param data
-	 * @param size
-	 * @param ignoreFault
-	 * @return @c RETURN_OK if write was successful
+	 * Documentation: See StorageManagerIF.h
 	 */
 	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
-			uint32_t size, bool ignoreFault = false);
-
-	/**
-	 * With this helper method, a free element of \c size is reserved.
-	 * @param storageId [out] storeID of the free element
-	 * @param size	The minimum packet size that shall be reserved.
-	 * @param p_data [out] pointer to the pointer of free element
-	 * @param ignoreFault
-	 * @return	Returns the storage identifier within the storage or
-	 * 			StorageManagerIF::INVALID_ADDRESS (in raw).
-	 */
-	ReturnValue_t getFreeElement(store_address_t* storageId,
-			const uint32_t size, uint8_t** p_data, bool ignoreFault = false);
-
-	/**
-	 * Retrieve data from local pool
-	 * @param packet_id
-	 * @param packet_ptr
-	 * @param size [out] Size of retrieved data
-	 * @return @c RETURN_OK if data retrieval was successfull
-	 */
+			size_t size, bool ignoreFault = false) override;
+	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
+			uint8_t** p_data, bool ignoreFault = false) override;
 	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
-			size_t * size);
-
-	/**
-	 * Modify data by supplying a packet pointer and using that packet pointer
-	 * to access and modify the pool entry (via *pointer call)
-	 * @param packet_id Store ID of data to modify
-	 * @param packet_ptr [out] pointer to the pool entry to modify
-	 * @param size [out] size of pool entry
-	 * @return
-	 */
+			size_t * size) override;
 	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			size_t * size);
-	virtual ReturnValue_t deleteData(store_address_t);
-	virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size,
-			store_address_t* storeId = NULL);
-	void clearStore();
-	ReturnValue_t initialize();
+			size_t * size) override;
+	virtual ReturnValue_t deleteData(store_address_t) override;
+	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
+			store_address_t* storeId = NULL) override;
+	void clearStore() override;
+	ReturnValue_t initialize() override;
 protected:
 	/**
 	 * With this helper method, a free element of \c size is reserved.
@@ -167,7 +126,7 @@ private:
 	 * @param data		The data to be stored.
 	 * @param size		The size of the data to be stored.
 	 */
-	void write(store_address_t packet_id, const uint8_t* data, uint32_t size);
+	void write(store_address_t packet_id, const uint8_t* data, size_t size);
 	/**
 	 * @brief	A helper method to read the element size of a certain pool.
 	 * @param pool_index	The pool in which to look.
@@ -190,7 +149,8 @@ private:
 	 * @return	- #RETURN_OK on success,
 	 * 			- #DATA_TOO_LARGE otherwise.
 	 */
-	ReturnValue_t getPoolIndex(uint32_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex = 0);
+	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
+			uint16_t startAtIndex = 0);
 	/**
 	 * @brief	This helper method calculates the true array position in store
 	 * 			of a given packet id.
@@ -212,249 +172,6 @@ private:
 	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
 };
 
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
-		uint16_t* element) {
-	ReturnValue_t status = DATA_STORAGE_FULL;
-	for (uint16_t foundElement = 0; foundElement < n_elements[pool_index];
-			foundElement++) {
-		if (size_list[pool_index][foundElement] == STORAGE_FREE) {
-			*element = foundElement;
-			status = RETURN_OK;
-			break;
-		}
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::write(store_address_t packet_id,
-		const uint8_t* data, uint32_t size) {
-	uint8_t* ptr;
-	uint32_t packet_position = getRawPosition(packet_id);
-
-	//check size? -> Not necessary, because size is checked before calling this function.
-	ptr = &store[packet_id.pool_index][packet_position];
-	memcpy(ptr, data, size);
-	size_list[packet_id.pool_index][packet_id.packet_index] = size;
-}
-
-//Returns page size of 0 in case store_index is illegal
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getPageSize(uint16_t pool_index) {
-	if (pool_index < NUMBER_OF_POOLS) {
-		return element_sizes[pool_index];
-	} else {
-		return 0;
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getPoolIndex(
-		uint32_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex) {
-	for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
-//		debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: " << n << ", Element Size: " << element_sizes[n] << std::endl;
-		if (element_sizes[n] >= packet_size) {
-			*poolIndex = n;
-			return RETURN_OK;
-		}
-	}
-	return DATA_TOO_LARGE;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getRawPosition(
-		store_address_t packet_id) {
-	return packet_id.packet_index * element_sizes[packet_id.pool_index];
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
-		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	ReturnValue_t status = getPoolIndex(size, &address->pool_index);
-	if (status != RETURN_OK) {
-		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
-				   << " )::reserveSpace: Packet too large." << std::endl;
-		return status;
-	}
-	status = findEmpty(address->pool_index, &address->packet_index);
-	while (status != RETURN_OK && spillsToHigherPools) {
-		status = getPoolIndex(size, &address->pool_index, address->pool_index + 1);
-		if (status != RETURN_OK) {
-			//We don't find any fitting pool anymore.
-			break;
-		}
-		status = findEmpty(address->pool_index, &address->packet_index);
-	}
-	if (status == RETURN_OK) {
-//		if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
-//			debug << "Reserve: Pool: " << std::dec << address->pool_index << " Index: " << address->packet_index << std::endl;
-//		}
-
-		size_list[address->pool_index][address->packet_index] = size;
-	} else {
-		if (!ignoreFault and internalErrorReporter != nullptr) {
-			internalErrorReporter->storeFull();
-		}
-		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
-				<< " )::reserveSpace: Packet store is full." << std::endl;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
-		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS], bool registered, bool spillsToHigherPools) :
-		SystemObject(setObjectId, registered), internalErrorReporter(NULL), spillsToHigherPools(spillsToHigherPools){
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		this->element_sizes[n] = element_sizes[n];
-		this->n_elements[n] = n_elements[n];
-		store[n] = new uint8_t[n_elements[n] * element_sizes[n]];
-		size_list[n] = new uint32_t[n_elements[n]];
-		memset(store[n], 0x00, (n_elements[n] * element_sizes[n]));
-		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list))); //TODO checkme
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		delete[] store[n];
-		delete[] size_list[n];
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(
-		store_address_t* storageId, const uint8_t* data, uint32_t size, bool ignoreFault) {
-	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
-	if (status == RETURN_OK) {
-		write(*storageId, data, size);
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
-		store_address_t* storageId, const uint32_t size, uint8_t** p_data, bool ignoreFault) {
-	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
-	if (status == RETURN_OK) {
-		*p_data = &store[storageId->pool_index][getRawPosition(*storageId)];
-	} else {
-		*p_data = NULL;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
-		store_address_t packet_id, const uint8_t** packet_ptr, size_t * size) {
-	uint8_t* tempData = NULL;
-	ReturnValue_t status = modifyData(packet_id, &tempData, size);
-	*packet_ptr = tempData;
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(store_address_t packet_id,
-		uint8_t** packet_ptr, size_t * size) {
-	ReturnValue_t status = RETURN_FAILED;
-	if (packet_id.pool_index >= NUMBER_OF_POOLS) {
-		return ILLEGAL_STORAGE_ID;
-	}
-	if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
-		return ILLEGAL_STORAGE_ID;
-	}
-	if (size_list[packet_id.pool_index][packet_id.packet_index]
-			!= STORAGE_FREE) {
-		uint32_t packet_position = getRawPosition(packet_id);
-		*packet_ptr = &store[packet_id.pool_index][packet_position];
-		*size = size_list[packet_id.pool_index][packet_id.packet_index];
-		status = RETURN_OK;
-	} else {
-		status = DATA_DOES_NOT_EXIST;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
-		store_address_t packet_id) {
-
-//	if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
-//		debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: " << packet_id.packet_index << std::endl;
-//	}
-	ReturnValue_t status = RETURN_OK;
-	uint32_t page_size = getPageSize(packet_id.pool_index);
-	if ((page_size != 0)
-			&& (packet_id.packet_index < n_elements[packet_id.pool_index])) {
-		uint16_t packet_position = getRawPosition(packet_id);
-		uint8_t* ptr = &store[packet_id.pool_index][packet_position];
-		memset(ptr, 0, page_size);
-		//Set free list
-		size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
-	} else {
-		//pool_index or packet_index is too large
-		sif::error << "LocalPool:deleteData failed." << std::endl;
-		status = ILLEGAL_STORAGE_ID;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::clearStore() {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));//TODO checkme
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
-		uint32_t size, store_address_t* storeId) {
-	store_address_t localId;
-	ReturnValue_t result = ILLEGAL_ADDRESS;
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		//Not sure if new allocates all stores in order. so better be careful.
-		if ((store[n] <= ptr) && (&store[n][n_elements[n]*element_sizes[n]]) > ptr) {
-			localId.pool_index = n;
-			uint32_t deltaAddress = ptr - store[n];
-			//Getting any data from the right "block" is ok. This is necessary, as IF's sometimes don't point to the first element of an object.
-			localId.packet_index = deltaAddress / element_sizes[n];
-			result = deleteData(localId);
-//			if (deltaAddress % element_sizes[n] != 0) {
-//				error << "Pool::deleteData: address not aligned!" << std::endl;
-//			}
-			break;
-		}
-	}
-	if (storeId != NULL) {
-		*storeId = localId;
-	}
-	return result;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	internalErrorReporter = objectManager->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
-	if (internalErrorReporter == NULL){
-		return RETURN_FAILED;
-	}
-
-	//Check if any pool size is large than the maximum allowed.
-	for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
-		if (element_sizes[count] >= STORAGE_FREE) {
-			sif::error
-					<< "LocalPool::initialize: Pool is too large! Max. allowed size is: "
-					<< (STORAGE_FREE - 1) << std::endl;
-			return RETURN_FAILED;
-		}
-	}
-	return RETURN_OK;
-}
+#include <framework/storagemanager/LocalPool.tpp>
 
 #endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
new file mode 100644
index 000000000..5cead166d
--- /dev/null
+++ b/storagemanager/LocalPool.tpp
@@ -0,0 +1,260 @@
+#ifndef LOCALPOOL_TPP
+#define LOCALPOOL_TPP
+
+template<uint8_t NUMBER_OF_POOLS>
+inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
+		const uint16_t element_sizes[NUMBER_OF_POOLS],
+		const uint16_t n_elements[NUMBER_OF_POOLS], bool registered,
+		bool spillsToHigherPools) :
+		SystemObject(setObjectId, registered),  internalErrorReporter(nullptr),
+		spillsToHigherPools(spillsToHigherPools)
+{
+	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+		this->element_sizes[n] = element_sizes[n];
+		this->n_elements[n] = n_elements[n];
+		store[n] = new uint8_t[n_elements[n] * element_sizes[n]];
+		size_list[n] = new uint32_t[n_elements[n]];
+		memset(store[n], 0x00, (n_elements[n] * element_sizes[n]));
+		//TODO checkme
+		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
+	}
+}
+
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
+		uint16_t* element) {
+	ReturnValue_t status = DATA_STORAGE_FULL;
+	for (uint16_t foundElement = 0; foundElement < n_elements[pool_index];
+			foundElement++) {
+		if (size_list[pool_index][foundElement] == STORAGE_FREE) {
+			*element = foundElement;
+			status = RETURN_OK;
+			break;
+		}
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline void LocalPool<NUMBER_OF_POOLS>::write(store_address_t packet_id,
+		const uint8_t* data, size_t size) {
+	uint8_t* ptr;
+	uint32_t packet_position = getRawPosition(packet_id);
+
+	//check size? -> Not necessary, because size is checked before calling this function.
+	ptr = &store[packet_id.pool_index][packet_position];
+	memcpy(ptr, data, size);
+	size_list[packet_id.pool_index][packet_id.packet_index] = size;
+}
+
+//Returns page size of 0 in case store_index is illegal
+template<uint8_t NUMBER_OF_POOLS>
+inline uint32_t LocalPool<NUMBER_OF_POOLS>::getPageSize(uint16_t pool_index) {
+	if (pool_index < NUMBER_OF_POOLS) {
+		return element_sizes[pool_index];
+	} else {
+		return 0;
+	}
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getPoolIndex(
+		size_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex) {
+	for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
+		//debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: " <<
+		//		n << ", Element Size: " << element_sizes[n] << std::endl;
+		if (element_sizes[n] >= packet_size) {
+			*poolIndex = n;
+			return RETURN_OK;
+		}
+	}
+	return DATA_TOO_LARGE;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline uint32_t LocalPool<NUMBER_OF_POOLS>::getRawPosition(
+		store_address_t packet_id) {
+	return packet_id.packet_index * element_sizes[packet_id.pool_index];
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
+		const uint32_t size, store_address_t* address, bool ignoreFault) {
+	ReturnValue_t status = getPoolIndex(size, &address->pool_index);
+	if (status != RETURN_OK) {
+		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
+				<< " )::reserveSpace: Packet too large." << std::endl;
+		return status;
+	}
+	status = findEmpty(address->pool_index, &address->packet_index);
+	while (status != RETURN_OK && spillsToHigherPools) {
+		status = getPoolIndex(size, &address->pool_index, address->pool_index + 1);
+		if (status != RETURN_OK) {
+			//We don't find any fitting pool anymore.
+			break;
+		}
+		status = findEmpty(address->pool_index, &address->packet_index);
+	}
+	if (status == RETURN_OK) {
+		// if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
+		//	   debug << "Reserve: Pool: " << std::dec << address->pool_index <<
+		//				" Index: " << address->packet_index << std::endl;
+		// }
+
+		size_list[address->pool_index][address->packet_index] = size;
+	} else {
+		if (!ignoreFault and internalErrorReporter != nullptr) {
+			internalErrorReporter->storeFull();
+		}
+		// error << "LocalPool( " << std::hex << getObjectId() << std::dec
+		// 			<< " )::reserveSpace: Packet store is full." << std::endl;
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
+	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+		delete[] store[n];
+		delete[] size_list[n];
+	}
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(store_address_t* storageId,
+		const uint8_t* data, size_t size, bool ignoreFault) {
+	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+	if (status == RETURN_OK) {
+		write(*storageId, data, size);
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
+		store_address_t* storageId, const size_t size,
+		uint8_t** p_data, bool ignoreFault) {
+	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+	if (status == RETURN_OK) {
+		*p_data = &store[storageId->pool_index][getRawPosition(*storageId)];
+	} else {
+		*p_data = NULL;
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
+		store_address_t packet_id, const uint8_t** packet_ptr, size_t* size) {
+	uint8_t* tempData = NULL;
+	ReturnValue_t status = modifyData(packet_id, &tempData, size);
+	*packet_ptr = tempData;
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
+		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
+	ReturnValue_t status = RETURN_FAILED;
+	if (packet_id.pool_index >= NUMBER_OF_POOLS) {
+		return ILLEGAL_STORAGE_ID;
+	}
+	if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
+		return ILLEGAL_STORAGE_ID;
+	}
+	if (size_list[packet_id.pool_index][packet_id.packet_index]
+			!= STORAGE_FREE) {
+		uint32_t packet_position = getRawPosition(packet_id);
+		*packet_ptr = &store[packet_id.pool_index][packet_position];
+		*size = size_list[packet_id.pool_index][packet_id.packet_index];
+		status = RETURN_OK;
+	} else {
+		status = DATA_DOES_NOT_EXIST;
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
+		store_address_t packet_id) {
+	//if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
+	//	debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: "
+	//	         << packet_id.packet_index << std::endl;
+	//}
+	ReturnValue_t status = RETURN_OK;
+	uint32_t page_size = getPageSize(packet_id.pool_index);
+	if ((page_size != 0)
+			&& (packet_id.packet_index < n_elements[packet_id.pool_index])) {
+		uint16_t packet_position = getRawPosition(packet_id);
+		uint8_t* ptr = &store[packet_id.pool_index][packet_position];
+		memset(ptr, 0, page_size);
+		//Set free list
+		size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
+	} else {
+		//pool_index or packet_index is too large
+		sif::error << "LocalPool:deleteData failed." << std::endl;
+		status = ILLEGAL_STORAGE_ID;
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline void LocalPool<NUMBER_OF_POOLS>::clearStore() {
+	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+		//TODO checkme
+		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
+	}
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
+		size_t size, store_address_t* storeId) {
+	store_address_t localId;
+	ReturnValue_t result = ILLEGAL_ADDRESS;
+	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+		//Not sure if new allocates all stores in order. so better be careful.
+		if ((store[n] <= ptr) && (&store[n][n_elements[n]*element_sizes[n]]) > ptr) {
+			localId.pool_index = n;
+			uint32_t deltaAddress = ptr - store[n];
+			// Getting any data from the right "block" is ok.
+			// This is necessary, as IF's sometimes don't point to the first
+			// element of an object.
+			localId.packet_index = deltaAddress / element_sizes[n];
+			result = deleteData(localId);
+			//if (deltaAddress % element_sizes[n] != 0) {
+			//	error << "Pool::deleteData: address not aligned!" << std::endl;
+			//}
+			break;
+		}
+	}
+	if (storeId != NULL) {
+		*storeId = localId;
+	}
+	return result;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+			objects::INTERNAL_ERROR_REPORTER);
+	if (internalErrorReporter == NULL){
+		return RETURN_FAILED;
+	}
+
+	//Check if any pool size is large than the maximum allowed.
+	for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
+		if (element_sizes[count] >= STORAGE_FREE) {
+			sif::error << "LocalPool::initialize: Pool is too large! "
+					"Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
+			return RETURN_FAILED;
+		}
+	}
+	return RETURN_OK;
+}
+
+#endif
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index bb88931be..d85fe86f6 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -6,9 +6,9 @@
 #include <stddef.h>
 
 /**
- * This union defines the type that identifies where a data packet is stored in the store.
- * It comprises of a raw part to read it as raw value and a structured part to use it in
- * pool-like stores.
+ * This union defines the type that identifies where a data packet is
+ * stored in the store. It comprises of a raw part to read it as raw value and
+ * a structured part to use it in pool-like stores.
  */
 union store_address_t {
 	/**
@@ -94,7 +94,8 @@ public:
 	 * 					@li	RETURN_FAILED if data could not be added.
 	 * 						storageId is unchanged then.
 	 */
-	virtual ReturnValue_t addData(store_address_t* storageId, const uint8_t * data, uint32_t size, bool ignoreFault = false) = 0;
+	virtual ReturnValue_t addData(store_address_t* storageId,
+			const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
 	/**
 	 * @brief	With deleteData, the storageManager frees the memory region
 	 * 			identified by packet_id.
@@ -105,14 +106,16 @@ public:
 	 */
 	virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
 	/**
-	 * @brief	Another deleteData which uses the pointer and size of the stored data to delete the content.
+	 * @brief	Another deleteData which uses the pointer and size of the
+	 * 			stored data to delete the content.
 	 * @param buffer	Pointer to the data.
 	 * @param size		Size of data to be stored.
 	 * @param storeId	Store id of the deleted element (optional)
 	 * @return	@li RETURN_OK on success.
 	 * 			@li	failure code if deletion did not work
 	 */
-	virtual ReturnValue_t deleteData(uint8_t* buffer, uint32_t size, store_address_t* storeId = NULL) = 0;
+	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = nullptr) = 0;
 	/**
 	 * @brief	getData returns an address to data and the size of the data
 	 * 			for a given packet_id.
@@ -125,12 +128,12 @@ public:
 	 * 				(e.g. an illegal packet_id was passed).
 	 */
 	virtual ReturnValue_t getData(store_address_t packet_id,
-			const uint8_t** packet_ptr, size_t * size) = 0;
+			const uint8_t** packet_ptr, size_t* size) = 0;
 	/**
 	 * Same as above, but not const and therefore modifiable.
 	 */
 	virtual ReturnValue_t modifyData(store_address_t packet_id,
-			uint8_t** packet_ptr, size_t * size) = 0;
+			uint8_t** packet_ptr, size_t* size) = 0;
 	/**
 	 * This method reserves an element of \c size.
 	 *
@@ -145,7 +148,7 @@ public:
 	 * 						storageId is unchanged then.
 	 */
 	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
-			const uint32_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
 	/**
 	 * Clears the whole store.
 	 * Use with care!

From 6817aa4d03f542939742ef9ccdadd578faaf428a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 May 2020 16:57:08 +0200
Subject: [PATCH 0220/1774] pool manager refactoring

---
 storagemanager/PoolManager.h   | 85 +++++++++-------------------------
 storagemanager/PoolManager.tpp | 50 ++++++++++++++++++++
 2 files changed, 72 insertions(+), 63 deletions(-)
 create mode 100644 storagemanager/PoolManager.tpp

diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 329235d51..6e6c76135 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,12 +1,3 @@
-/**
- *	@file	PoolManager
- *
- *  @date	02.02.2012
- *	@author	Bastian Baetz
- *
- *	@brief	This file contains the definition of the PoolManager class.
- */
-
 #ifndef POOLMANAGER_H_
 #define POOLMANAGER_H_
 
@@ -17,71 +8,39 @@
 /**
  * @brief	The PoolManager class provides an intermediate data storage with
  * 			a fixed pool size policy for inter-process communication.
- * \details	Uses local pool, but is thread-safe.
+ * @details	Uses local pool calls but is thread safe by protecting the call
+ * 			with a lock.
  */
 
 template <uint8_t NUMBER_OF_POOLS = 5>
 class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
-protected:
-	/**
-	 * Overwritten for thread safety.
-	 * Locks during execution.
-	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault);
-
-	/**
-	 * \brief	The mutex is created in the constructor and makes access mutual exclusive.
-	 * \details	Locking and unlocking is done during searching for free slots and deleting existing slots.
-	 */
-	MutexIF*	mutex;
 public:
-	PoolManager( object_id_t setObjectId, const uint16_t element_sizes[NUMBER_OF_POOLS], const uint16_t n_elements[NUMBER_OF_POOLS] );
+	PoolManager( object_id_t setObjectId, const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS] );
 	/**
 	 * @brief	In the PoolManager's destructor all allocated memory is freed.
 	 */
-	virtual ~PoolManager( void );
+	virtual ~PoolManager();
+
+	ReturnValue_t deleteData(store_address_t) override;
+	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = NULL) override;
+
+	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
+				size_t* size) override;
+protected:
+	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
+			bool ignoreFault) override;
+
 	/**
-	 * Overwritten for thread safety.
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking is done during searching for free slots
+	 * 			and deleting existing slots.
 	 */
-	virtual ReturnValue_t deleteData(store_address_t);
-	virtual ReturnValue_t deleteData(uint8_t* buffer, uint32_t size, store_address_t* storeId = NULL);
+	MutexIF* mutex;
 };
 
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,address,ignoreFault);
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
-		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS]) :
-		LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
-		store_address_t packet_id) {
-	//	debug << "PoolManager( " << translateObject(getObjectId()) << " )::deleteData from store " << packet_id.pool_index << ". id is " << packet_id.packet_index << std::endl;
-		MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
-		ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
-		return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer, uint32_t size,
-		store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer, size, storeId);
-	return status;
-}
+#include "PoolManager.tpp"
 
 #endif /* POOLMANAGER_H_ */
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
new file mode 100644
index 000000000..ed340b917
--- /dev/null
+++ b/storagemanager/PoolManager.tpp
@@ -0,0 +1,50 @@
+template<uint8_t NUMBER_OF_POOLS>
+inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
+		const uint16_t element_sizes[NUMBER_OF_POOLS],
+		const uint16_t n_elements[NUMBER_OF_POOLS]) :
+		LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
+		const uint32_t size, store_address_t* address, bool ignoreFault) {
+	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
+			address,ignoreFault);
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
+		store_address_t packet_id) {
+	// debug << "PoolManager( " << translateObject(getObjectId()) <<
+	//       " )::deleteData from store " << packet_id.pool_index <<
+	//       ". id is "<< packet_id.packet_index << std::endl;
+	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
+		size_t size, store_address_t* storeId) {
+	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
+			size, storeId);
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::modifyData(
+		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
+	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::modifyData(packet_id,
+				packet_ptr, size);
+	return status;
+}

From 1825924b7bf46d65fc163ac89921d9d70ddbe33b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 May 2020 10:16:16 +0200
Subject: [PATCH 0221/1774] abbreviation for resultIF

---
 returnvalues/HasReturnvaluesIF.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index d84fc7578..964d081f4 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -18,4 +18,6 @@ public:
 
 };
 
+using ResultIF = HasReturnvaluesIF;
+
 #endif /* HASRETURNVALUESIF_H_ */

From c05b9cbd01b490046f6d7881bf4ff62f7e2a63c2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 May 2020 14:07:27 +0200
Subject: [PATCH 0222/1774] reverted ResultIF. for now, keep using
 HasReturnvaluesIF

---
 returnvalues/HasReturnvaluesIF.h | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 964d081f4..9bbaf6010 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -13,11 +13,7 @@ class HasReturnvaluesIF {
 public:
 	static const ReturnValue_t RETURN_OK = 0;
 	static const ReturnValue_t RETURN_FAILED = 0xFFFF;
-	virtual ~HasReturnvaluesIF() {
-	}
-
+	virtual ~HasReturnvaluesIF() {}
 };
 
-using ResultIF = HasReturnvaluesIF;
-
 #endif /* HASRETURNVALUESIF_H_ */

From bc17b5a907ca3fe2ead9829a1a582bedc84389b1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 May 2020 18:43:28 +0200
Subject: [PATCH 0223/1774] resolved conflict

---
 osal/linux/FixedTimeslotTask.cpp | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 2775e4f63..098753a7a 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -42,25 +42,14 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-<<<<<<< HEAD
-	if (!objectManager->get<ExecutableObjectIF>(componentId)) {
-		sif::error << "Component " << std::hex << componentId
-				   << " not found, not adding it to pst" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	pst.addSlot(componentId, slotTimeMs, executionStep, this);
-	return HasReturnvaluesIF::RETURN_OK;
-=======
 	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
 		pst.addSlot(componentId, slotTimeMs, executionStep, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	error << "Component " << std::hex << componentId <<
+	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
->>>>>>> luz_FixedTimeslotTask_ExistenceCheck
 }
 
 ReturnValue_t FixedTimeslotTask::checkSequence() const {

From 160a09790e112fdd6cc40cbb75b502c9ca057fd8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 May 2020 18:53:25 +0200
Subject: [PATCH 0224/1774] removed c omment for now

---
 devicehandlers/FixedSlotSequence.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index 466d846fc..aa0df9cb5 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -90,10 +90,6 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
 	    sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
-	    // does check sequence have to be const?
-	    // if I want to check a class, I need the ability to set
-	    // internal class states.
-	    //isEmpty = true;
 	    std::exit(0);
 	}
     // Iterate through slotList and check successful creation.

From f09836a9eb4aeb561ae1e6fa13e20c0aa0fc01cf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 May 2020 19:30:03 +0200
Subject: [PATCH 0225/1774] removed exit for empty psremoved exit for empty
 pstt

---
 devicehandlers/FixedSlotSequence.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index aa0df9cb5..00020d682 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -90,7 +90,6 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
 	    sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
-	    std::exit(0);
 	}
     // Iterate through slotList and check successful creation.
 	// Checks if timing is ok (must be ascending) and if all handlers were found.

From cc0469fef6031ebde23583f958fcf1c0b1e5ef3e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 May 2020 20:09:42 +0200
Subject: [PATCH 0226/1774] return failed insteead of exiting

---
 devicehandlers/FixedSlotSequence.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index 00020d682..860a643b6 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -90,6 +90,7 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
 	    sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
+	    return HasReturnvaluesIF::RETURN_FAILED;
 	}
     // Iterate through slotList and check successful creation.
 	// Checks if timing is ok (must be ascending) and if all handlers were found.

From e950051b4ab7edcc6919af226f3c7a1eae63602e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 6 May 2020 14:35:30 +0200
Subject: [PATCH 0227/1774] some object managerIF security measures

objectmanager get function checks whether global object manager was
initialized now.
New returnvalues, which are also used for local pool init
---
 devicehandlers/FixedSlotSequence.cpp |  8 --------
 devicehandlers/FixedSlotSequence.h   | 16 +--------------
 objectmanager/ObjectManagerIF.h      | 29 ++++++++++++++++++----------
 storagemanager/LocalPool.tpp         |  6 +++---
 storagemanager/StorageManagerIF.h    |  1 +
 5 files changed, 24 insertions(+), 36 deletions(-)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index 6db7ee435..8974510ec 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -89,17 +89,9 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
-<<<<<<< HEAD
 	    sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	}
-    // Iterate through slotList and check successful creation.
-	// Checks if timing is ok (must be ascending) and if all handlers were found.
-=======
-		error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
->>>>>>> master
 	auto slotIt = slotList.begin();
 	uint32_t count = 0;
 	uint32_t time = 0;
diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h
index 65ad34515..dd9636c1e 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -12,16 +12,6 @@ using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
 
 /**
  * @brief	This class is the representation of a Polling Sequence Table in software.
- *
-<<<<<<< HEAD
- * @details	The FixedSlotSequence object maintains the dynamic execution of device handler objects.
- * 			The main idea is to create a list of device handlers, to announce all handlers to the
- * 			polling sequence and to maintain a list of polling slot objects. This slot list represents the
- * 			Polling Sequence Table in software. Each polling slot contains information to indicate when and
- * 			which device handler shall be executed within a given polling period.
- * 			The sequence is then executed by iterating through this slot list.
- * 			Handlers are invoking by calling a certain function stored in the handler list.
-=======
  * @details
  * The FixedSlotSequence object maintains the dynamic execution of
  * device handler objects.
@@ -35,7 +25,6 @@ using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
  * which device handler shall be executed within a given polling period.
  * The sequence is then executed by iterating through this slot list.
  * Handlers are invoking by calling a certain function stored in the handler list.
->>>>>>> master
  */
 class FixedSlotSequence {
 public:
@@ -128,16 +117,13 @@ public:
 	 */
 	SlotListIter current;
 
-<<<<<<< HEAD
-	virtual ReturnValue_t checkSequence() const;
-=======
 	/**
 	 * Iterate through slotList and check successful creation.
 	 * Checks if timing is ok (must be ascending) and if all handlers were found.
 	 * @return
 	 */
 	ReturnValue_t checkSequence() const;
->>>>>>> master
+
 protected:
 
 	/**
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 1d7674c64..3a23e3397 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -12,6 +12,7 @@
 #include <config/objects/systemObjectList.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 /**
  * @brief	This class provides an interface to the global object manager.
@@ -24,9 +25,12 @@
  */
 class ObjectManagerIF : public HasReturnvaluesIF {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
-	static const ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
+	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
+	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
+
 protected:
 	/**
 	 * @brief	This method is used to hide the template-based get call from
@@ -79,16 +83,21 @@ public:
 };
 
 
-/*Documentation can be found in the class method declaration above.*/
-template <typename T>
-T* ObjectManagerIF::get( object_id_t id ) {
-	SystemObjectIF* temp = this->getSystemObject(id);
-	return dynamic_cast<T*>(temp);
-}
-
 /**
  * @brief	This is the forward declaration of the global objectManager instance.
  */
 extern ObjectManagerIF *objectManager;
 
+/*Documentation can be found in the class method declaration above.*/
+template <typename T>
+T* ObjectManagerIF::get( object_id_t id ) {
+	if(objectManager == nullptr) {
+		sif::error << "ObjectManagerIF: Global object manager has not "
+				"been initialized yet!" << std::endl;
+		std::exit(0);
+	}
+	SystemObjectIF* temp = this->getSystemObject(id);
+	return dynamic_cast<T*>(temp);
+}
+
 #endif /* OBJECTMANAGERIF_H_ */
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 5cead166d..c46e1a8d1 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -242,8 +242,8 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
 	}
 	internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
 			objects::INTERNAL_ERROR_REPORTER);
-	if (internalErrorReporter == NULL){
-		return RETURN_FAILED;
+	if (internalErrorReporter == nullptr){
+		return ObjectManagerIF::INTERNAL_ERR_REPORTER_UNINIT;
 	}
 
 	//Check if any pool size is large than the maximum allowed.
@@ -251,7 +251,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
 		if (element_sizes[count] >= STORAGE_FREE) {
 			sif::error << "LocalPool::initialize: Pool is too large! "
 					"Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
-			return RETURN_FAILED;
+			return StorageManagerIF::POOL_TOO_LARGE;
 		}
 	}
 	return RETURN_OK;
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index d85fe86f6..d1f9cde5d 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -71,6 +71,7 @@ public:
 	static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
 	static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
 	static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
 	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);

From b016f2995a00a3a5183794bb576820d17b6f078b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 6 May 2020 16:34:43 +0200
Subject: [PATCH 0228/1774] added default vlaue for init function

---
 action/ActionHelper.cpp | 10 ++++++----
 action/ActionHelper.h   |  2 +-
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index ef9f06a9e..19a84d82d 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -1,9 +1,9 @@
 #include <framework/action/ActionHelper.h>
 #include <framework/action/HasActionsIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
+
 ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue), ipcStore(
-				NULL) {
+		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
 }
 
 ActionHelper::~ActionHelper() {
@@ -22,10 +22,12 @@ ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
 
 ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
 	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == NULL) {
+	if (ipcStore == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	setQueueToUse(queueToUse_);
+	if(queueToUse_ != nullptr) {
+		setQueueToUse(queueToUse_);
+	}
 
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index 6ba6dd89b..3d8351d66 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -38,7 +38,7 @@ public:
 	 * @param queueToUse_ Pointer to the messageQueue to be used
 	 * @return Returns RETURN_OK if successful
 	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
+	ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
 	/**
 	 * Function to be called from the owner to send a step message. Success or failure will be determined by the result value.
 	 *

From fe9aa46cf8d33ccb93b570fe77631abb08555829 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 7 May 2020 12:22:17 +0200
Subject: [PATCH 0229/1774] removed system object list include.

makes it difficult for multiple configurations, because the wrong header
might be included
---
 objectmanager/ObjectManagerIF.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 3a23e3397..3575fc162 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -9,7 +9,6 @@
 #define OBJECTMANAGERIF_H_
 
 #include <framework/objectmanager/frameworkObjects.h>
-#include <config/objects/systemObjectList.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>

From 9489b7abc1bee2a2b164e81f178222706a8c2b8e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 7 May 2020 19:23:56 +0200
Subject: [PATCH 0230/1774] modifyData override deleted

is not really thread-safe anyway
---
 devicehandlers/CommunicationMessage.h | 8 ++------
 storagemanager/PoolManager.h          | 3 ---
 storagemanager/PoolManager.tpp        | 8 --------
 3 files changed, 2 insertions(+), 17 deletions(-)

diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
index a92c4b5cf..952663197 100644
--- a/devicehandlers/CommunicationMessage.h
+++ b/devicehandlers/CommunicationMessage.h
@@ -13,15 +13,11 @@
 #include <framework/devicehandlers/DeviceHandlerBase.h>
 
 /**
- * @brief Used to pass communication information between tasks
+ * @brief Message type to send larger messages
  *
  * @details
  * Can be used to pass information like data pointers and
- * data sizes between communication tasks
- * like the Device Handler Comm Interfaces and Polling Tasks.
- *
- * Can also be used to exchange actual data if its not too large
- * (e.g. Sensor values).
+ * data sizes between communication tasks.
  *
  */
 class CommunicationMessage: public MessageQueueMessage {
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 6e6c76135..41325273a 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -25,9 +25,6 @@ public:
 	ReturnValue_t deleteData(store_address_t) override;
 	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = NULL) override;
-
-	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-				size_t* size) override;
 protected:
 	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
 			bool ignoreFault) override;
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index ed340b917..0408d55b9 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -40,11 +40,3 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 	return status;
 }
 
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::modifyData(
-		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::modifyData(packet_id,
-				packet_ptr, size);
-	return status;
-}

From 0f286461d065f25ddda7b63f4f3ae45d2e6b5db3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 May 2020 18:10:26 +0200
Subject: [PATCH 0231/1774] added new storage raw accessor

---
 storagemanager/StorageAccessor.cpp | 154 +++++++++++++++++++++++++
 storagemanager/StorageAccessor.h   | 174 +++++++++++++++++++++++++++++
 2 files changed, 328 insertions(+)
 create mode 100644 storagemanager/StorageAccessor.cpp
 create mode 100644 storagemanager/StorageAccessor.h

diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
new file mode 100644
index 000000000..50e503cf1
--- /dev/null
+++ b/storagemanager/StorageAccessor.cpp
@@ -0,0 +1,154 @@
+#include <test/prototypes/StorageAccessor.h>
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId): storeId(storeId) {}
+
+ConstStorageAccessor::~ConstStorageAccessor() {
+	if(deleteData and store != nullptr) {
+		sif::debug << "deleting store data" << std::endl;
+		store->deleteDataNonLocking(storeId);
+	}
+	if(mutexLock != nullptr) {
+		sif::debug << "unlocking mutex lock" << std::endl;
+		mutexLock.reset();
+	}
+}
+
+ConstStorageAccessor& ConstStorageAccessor::operator=(
+		ConstStorageAccessor&& other) {
+	constDataPointer = other.constDataPointer;
+	storeId = other.storeId;
+	store = other.store;
+	size_ = other.size_;
+	deleteData = other.deleteData;
+	this->store = other.store;
+	// Transfer ownership of the lock.
+	mutexLock = std::move(other.mutexLock);
+	// This prevents double deletion of the resource
+	other.mutexLock = nullptr;
+	// This prevent premature deletion
+	other.store = nullptr;
+	return *this;
+}
+
+StorageAccessor::StorageAccessor(store_address_t storeId):
+		ConstStorageAccessor(storeId) {
+}
+
+StorageAccessor& StorageAccessor::operator =(
+		StorageAccessor&& other) {
+	// Call the parent move assignment and also assign own member.
+	dataPointer = other.dataPointer;
+	StorageAccessor::operator=(std::move(other));
+	return * this;
+}
+
+// Call the parent move ctor and also transfer own member.
+StorageAccessor::StorageAccessor(StorageAccessor&& other):
+		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+}
+
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// Transfer ownership of the lock.
+	mutexLock = std::move(other.mutexLock);
+	// This prevents double deletion of the resource. Not strictly necessary,
+	// from the testing I have conducted so far but I am not familiar enough
+	// with move semantics so I will just set the other lock to nullptr for now.
+	other.mutexLock = nullptr;
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
+const uint8_t* ConstStorageAccessor::data() const {
+	return constDataPointer;
+}
+
+size_t ConstStorageAccessor::size() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return size_;
+}
+
+void ConstStorageAccessor::getDataCopy(uint8_t *pointer) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	std::copy(constDataPointer, constDataPointer + size_, pointer);
+}
+
+void ConstStorageAccessor::release() {
+	deleteData = false;
+}
+
+ReturnValue_t ConstStorageAccessor::lock(MutexIF* mutex, uint32_t mutexTimeout) {
+	if(mutexLock == nullptr) {
+		mutexLock = std::unique_ptr<MutexHelper>(new MutexHelper(mutex, mutexTimeout));
+		return mutexLock.get()->getResult();
+	}
+	else {
+		sif::warning << "StorageAccessor: Attempted to lock twice. Check code!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void ConstStorageAccessor::unlock() {
+	if(mutexLock != nullptr) {
+		mutexLock.reset();
+	}
+}
+
+store_address_t ConstStorageAccessor::getId() const {
+	return storeId;
+}
+
+void ConstStorageAccessor::print() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	sif::info << "StorageAccessor: Printing data: [";
+	for(uint16_t iPool = 0; iPool < size_; iPool++) {
+		sif::info << std::hex << (int)constDataPointer[iPool];
+		if(iPool < size_ - 1){
+			sif::info << " , ";
+		}
+	}
+	sif::info << " ] " << std::endl;
+}
+
+void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+	internalState = AccessState::READ;
+	this->store = store;
+}
+
+
+uint8_t* StorageAccessor::data() {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return dataPointer;
+}
+
+ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
+		uint16_t offset) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(offset + size > size_) {
+		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(data, data + size, dataPointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void StorageAccessor::assignConstPointer() {
+	constDataPointer = dataPointer;
+}
+
+
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
new file mode 100644
index 000000000..f861a2cc9
--- /dev/null
+++ b/storagemanager/StorageAccessor.h
@@ -0,0 +1,174 @@
+/**
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details	These helper can be used together with the
+ * 			StorageManager classes to manage access to a storage.
+ * 			It can take care of thread-safety while also providing
+ * 			mechanisms to automatically clear storage data and unlocking the
+ * 			pool.
+ */
+#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
+#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
+
+#include <framework/ipc/MutexHelper.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <memory>
+
+
+/**
+ * @brief   Accessor class which can be returned by pool managers
+ *          or passed and set by pool managers to have safe access to the pool
+ *          resources.
+ */
+class ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	/**
+	 * @brief	Simple constructor which takes the store ID of the storage
+	 * 			entry to access.
+	 * @param storeId
+	 */
+	ConstStorageAccessor(store_address_t storeId);
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+	ConstStorageAccessor (ConstStorageAccessor&&);
+
+	//! The copy ctor and copy assignemnt should be deleted implicitely
+	//! according to https://foonathan.net/2019/02/special-member-functions/
+	//! but I still deleted them to make it more explicit. (remember rule of 5).
+	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+
+	/**
+	 * @brief 	The destructor in default configuration takes care of
+	 * 			deleting the accessed pool entry and unlocking the mutex
+	 */
+	virtual ~ConstStorageAccessor();
+
+	/**
+	 * @brief	Returns a pointer to the read-only data
+	 * @return
+	 */
+	const uint8_t* data() const;
+
+	/**
+	 * @brief	Copies the read-only data to the supplied pointer
+	 * @param pointer
+	 */
+	void getDataCopy(uint8_t *pointer);
+
+	/**
+	 * @brief   Calling this will prevent the Accessor from deleting the data
+	 *          when the destructor is called.
+	 */
+	void release();
+	/**
+	 * @brief 	Locks the supplied mutex.
+	 * @details
+	 * The mutex will be unlocked automatically
+	 * when this class is destroyed (for example when exiting the scope).
+	 * Only one mutex can be locked at a time!
+	 * @param mutex
+	 * @param mutexTimeout
+	 * @return
+	 */
+	ReturnValue_t lock(MutexIF* mutex,
+			uint32_t mutexTimeout = MutexIF::NO_TIMEOUT);
+	/**
+	 * @brief	Unlocks the mutex (if one has been locked previously).
+	 *          Unless this function is called, the mutex is unlocked
+	 *          when the class exits the scope.
+	 */
+	void unlock();
+
+
+	/**
+	 * Get the size of the data
+	 * @return
+	 */
+	size_t size() const;
+
+	/**
+	 * Get the storage ID.
+	 * @return
+	 */
+	store_address_t getId() const;
+
+	void print() const;
+protected:
+	const uint8_t* constDataPointer = nullptr;
+	store_address_t storeId;
+	size_t size_ = 0;
+	//! Managing pool, has to assign itself.
+	StorageManagerIF* store = nullptr;
+	//! Unique pointer to the mutex lock instance. Is initialized by
+	//! the pool manager.
+	std::unique_ptr<MutexHelper> mutexLock = nullptr;
+	bool deleteData = true;
+
+	enum class AccessState {
+		UNINIT,
+		READ
+	};
+	//! Internal state for safety reasons.
+	AccessState internalState = AccessState::UNINIT;
+	/**
+	 * Used by the pool manager instances to assign themselves to the
+	 * accessor. This is necessary to delete the data when the acessor
+	 * exits the scope ! The internal state will be considered read
+	 * when this function is called, so take care all data is set properly as
+	 * well.
+	 * @param
+	 */
+	void assignStore(StorageManagerIF*);
+
+};
+
+
+/**
+ * @brief   Child class for modifyable data. Also has a normal pointer member.
+ */
+class StorageAccessor: public ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	StorageAccessor(store_address_t storeId);
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * 			 move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	StorageAccessor& operator= (StorageAccessor&&);
+	StorageAccessor (StorageAccessor&&);
+
+	ReturnValue_t write(uint8_t *data, size_t size,
+		uint16_t offset);
+	uint8_t* data();
+
+private:
+	//! Non-const pointer for modifyable data.
+	uint8_t* dataPointer = nullptr;
+	//! For modifyable data, the const pointer is assigned to the normal
+	//! pointer by the pool manager so both access functions can be used safely
+	void assignConstPointer();
+};
+
+#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */

From 2f58c3a3052506e922ba1758e9a7fa4f1c642c9f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 10 May 2020 00:14:00 +0200
Subject: [PATCH 0232/1774] commented out storage accessor

---
 storagemanager/StorageAccessor.cpp | 308 ++++++++++++-------------
 storagemanager/StorageAccessor.h   | 348 ++++++++++++++---------------
 2 files changed, 328 insertions(+), 328 deletions(-)

diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index 50e503cf1..a068d1694 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,154 +1,154 @@
-#include <test/prototypes/StorageAccessor.h>
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId): storeId(storeId) {}
-
-ConstStorageAccessor::~ConstStorageAccessor() {
-	if(deleteData and store != nullptr) {
-		sif::debug << "deleting store data" << std::endl;
-		store->deleteDataNonLocking(storeId);
-	}
-	if(mutexLock != nullptr) {
-		sif::debug << "unlocking mutex lock" << std::endl;
-		mutexLock.reset();
-	}
-}
-
-ConstStorageAccessor& ConstStorageAccessor::operator=(
-		ConstStorageAccessor&& other) {
-	constDataPointer = other.constDataPointer;
-	storeId = other.storeId;
-	store = other.store;
-	size_ = other.size_;
-	deleteData = other.deleteData;
-	this->store = other.store;
-	// Transfer ownership of the lock.
-	mutexLock = std::move(other.mutexLock);
-	// This prevents double deletion of the resource
-	other.mutexLock = nullptr;
-	// This prevent premature deletion
-	other.store = nullptr;
-	return *this;
-}
-
-StorageAccessor::StorageAccessor(store_address_t storeId):
-		ConstStorageAccessor(storeId) {
-}
-
-StorageAccessor& StorageAccessor::operator =(
-		StorageAccessor&& other) {
-	// Call the parent move assignment and also assign own member.
-	dataPointer = other.dataPointer;
-	StorageAccessor::operator=(std::move(other));
-	return * this;
-}
-
-// Call the parent move ctor and also transfer own member.
-StorageAccessor::StorageAccessor(StorageAccessor&& other):
-		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
-}
-
-ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
-		constDataPointer(other.constDataPointer), storeId(other.storeId),
-		size_(other.size_), store(other.store), deleteData(other.deleteData),
-		internalState(other.internalState) {
-	// Transfer ownership of the lock.
-	mutexLock = std::move(other.mutexLock);
-	// This prevents double deletion of the resource. Not strictly necessary,
-	// from the testing I have conducted so far but I am not familiar enough
-	// with move semantics so I will just set the other lock to nullptr for now.
-	other.mutexLock = nullptr;
-	// This prevent premature deletion
-	other.store = nullptr;
-}
-
-const uint8_t* ConstStorageAccessor::data() const {
-	return constDataPointer;
-}
-
-size_t ConstStorageAccessor::size() const {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return size_;
-}
-
-void ConstStorageAccessor::getDataCopy(uint8_t *pointer) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return;
-	}
-	std::copy(constDataPointer, constDataPointer + size_, pointer);
-}
-
-void ConstStorageAccessor::release() {
-	deleteData = false;
-}
-
-ReturnValue_t ConstStorageAccessor::lock(MutexIF* mutex, uint32_t mutexTimeout) {
-	if(mutexLock == nullptr) {
-		mutexLock = std::unique_ptr<MutexHelper>(new MutexHelper(mutex, mutexTimeout));
-		return mutexLock.get()->getResult();
-	}
-	else {
-		sif::warning << "StorageAccessor: Attempted to lock twice. Check code!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-void ConstStorageAccessor::unlock() {
-	if(mutexLock != nullptr) {
-		mutexLock.reset();
-	}
-}
-
-store_address_t ConstStorageAccessor::getId() const {
-	return storeId;
-}
-
-void ConstStorageAccessor::print() const {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return;
-	}
-	sif::info << "StorageAccessor: Printing data: [";
-	for(uint16_t iPool = 0; iPool < size_; iPool++) {
-		sif::info << std::hex << (int)constDataPointer[iPool];
-		if(iPool < size_ - 1){
-			sif::info << " , ";
-		}
-	}
-	sif::info << " ] " << std::endl;
-}
-
-void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
-	internalState = AccessState::READ;
-	this->store = store;
-}
-
-
-uint8_t* StorageAccessor::data() {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return dataPointer;
-}
-
-ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
-		uint16_t offset) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(offset + size > size_) {
-		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(data, data + size, dataPointer);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void StorageAccessor::assignConstPointer() {
-	constDataPointer = dataPointer;
-}
-
-
+//#include <framework/storagemanager/StorageAccessor.h>
+//
+//ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId): storeId(storeId) {}
+//
+//ConstStorageAccessor::~ConstStorageAccessor() {
+//	if(deleteData and store != nullptr) {
+//		sif::debug << "deleting store data" << std::endl;
+//		store->deleteDataNonLocking(storeId);
+//	}
+//	if(mutexLock != nullptr) {
+//		sif::debug << "unlocking mutex lock" << std::endl;
+//		mutexLock.reset();
+//	}
+//}
+//
+//ConstStorageAccessor& ConstStorageAccessor::operator=(
+//		ConstStorageAccessor&& other) {
+//	constDataPointer = other.constDataPointer;
+//	storeId = other.storeId;
+//	store = other.store;
+//	size_ = other.size_;
+//	deleteData = other.deleteData;
+//	this->store = other.store;
+//	// Transfer ownership of the lock.
+//	mutexLock = std::move(other.mutexLock);
+//	// This prevents double deletion of the resource
+//	other.mutexLock = nullptr;
+//	// This prevent premature deletion
+//	other.store = nullptr;
+//	return *this;
+//}
+//
+//StorageAccessor::StorageAccessor(store_address_t storeId):
+//		ConstStorageAccessor(storeId) {
+//}
+//
+//StorageAccessor& StorageAccessor::operator =(
+//		StorageAccessor&& other) {
+//	// Call the parent move assignment and also assign own member.
+//	dataPointer = other.dataPointer;
+//	StorageAccessor::operator=(std::move(other));
+//	return * this;
+//}
+//
+//// Call the parent move ctor and also transfer own member.
+//StorageAccessor::StorageAccessor(StorageAccessor&& other):
+//		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+//}
+//
+//ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+//		constDataPointer(other.constDataPointer), storeId(other.storeId),
+//		size_(other.size_), store(other.store), deleteData(other.deleteData),
+//		internalState(other.internalState) {
+//	// Transfer ownership of the lock.
+//	mutexLock = std::move(other.mutexLock);
+//	// This prevents double deletion of the resource. Not strictly necessary,
+//	// from the testing I have conducted so far but I am not familiar enough
+//	// with move semantics so I will just set the other lock to nullptr for now.
+//	other.mutexLock = nullptr;
+//	// This prevent premature deletion
+//	other.store = nullptr;
+//}
+//
+//const uint8_t* ConstStorageAccessor::data() const {
+//	return constDataPointer;
+//}
+//
+//size_t ConstStorageAccessor::size() const {
+//	if(internalState == AccessState::UNINIT) {
+//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+//	}
+//	return size_;
+//}
+//
+//void ConstStorageAccessor::getDataCopy(uint8_t *pointer) {
+//	if(internalState == AccessState::UNINIT) {
+//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+//		return;
+//	}
+//	std::copy(constDataPointer, constDataPointer + size_, pointer);
+//}
+//
+//void ConstStorageAccessor::release() {
+//	deleteData = false;
+//}
+//
+//ReturnValue_t ConstStorageAccessor::lock(MutexIF* mutex, uint32_t mutexTimeout) {
+//	if(mutexLock == nullptr) {
+//		mutexLock = std::unique_ptr<MutexHelper>(new MutexHelper(mutex, mutexTimeout));
+//		return mutexLock.get()->getResult();
+//	}
+//	else {
+//		sif::warning << "StorageAccessor: Attempted to lock twice. Check code!" << std::endl;
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//}
+//
+//void ConstStorageAccessor::unlock() {
+//	if(mutexLock != nullptr) {
+//		mutexLock.reset();
+//	}
+//}
+//
+//store_address_t ConstStorageAccessor::getId() const {
+//	return storeId;
+//}
+//
+//void ConstStorageAccessor::print() const {
+//	if(internalState == AccessState::UNINIT) {
+//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+//		return;
+//	}
+//	sif::info << "StorageAccessor: Printing data: [";
+//	for(uint16_t iPool = 0; iPool < size_; iPool++) {
+//		sif::info << std::hex << (int)constDataPointer[iPool];
+//		if(iPool < size_ - 1){
+//			sif::info << " , ";
+//		}
+//	}
+//	sif::info << " ] " << std::endl;
+//}
+//
+//void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+//	internalState = AccessState::READ;
+//	this->store = store;
+//}
+//
+//
+//uint8_t* StorageAccessor::data() {
+//	if(internalState == AccessState::UNINIT) {
+//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+//	}
+//	return dataPointer;
+//}
+//
+//ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
+//		uint16_t offset) {
+//	if(internalState == AccessState::UNINIT) {
+//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//	if(offset + size > size_) {
+//		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//	std::copy(data, data + size, dataPointer);
+//	return HasReturnvaluesIF::RETURN_OK;
+//}
+//
+//void StorageAccessor::assignConstPointer() {
+//	constDataPointer = dataPointer;
+//}
+//
+//
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index f861a2cc9..d391c5c26 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,174 +1,174 @@
-/**
- * @brief 	Helper classes to facilitate safe access to storages which is also
- * 			conforming to RAII principles
- * @details	These helper can be used together with the
- * 			StorageManager classes to manage access to a storage.
- * 			It can take care of thread-safety while also providing
- * 			mechanisms to automatically clear storage data and unlocking the
- * 			pool.
- */
-#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
-#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
-
-#include <framework/ipc/MutexHelper.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <memory>
-
-
-/**
- * @brief   Accessor class which can be returned by pool managers
- *          or passed and set by pool managers to have safe access to the pool
- *          resources.
- */
-class ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	/**
-	 * @brief	Simple constructor which takes the store ID of the storage
-	 * 			entry to access.
-	 * @param storeId
-	 */
-	ConstStorageAccessor(store_address_t storeId);
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor (ConstStorageAccessor&&);
-
-	//! The copy ctor and copy assignemnt should be deleted implicitely
-	//! according to https://foonathan.net/2019/02/special-member-functions/
-	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (ConstStorageAccessor&) = delete;
-
-	/**
-	 * @brief 	The destructor in default configuration takes care of
-	 * 			deleting the accessed pool entry and unlocking the mutex
-	 */
-	virtual ~ConstStorageAccessor();
-
-	/**
-	 * @brief	Returns a pointer to the read-only data
-	 * @return
-	 */
-	const uint8_t* data() const;
-
-	/**
-	 * @brief	Copies the read-only data to the supplied pointer
-	 * @param pointer
-	 */
-	void getDataCopy(uint8_t *pointer);
-
-	/**
-	 * @brief   Calling this will prevent the Accessor from deleting the data
-	 *          when the destructor is called.
-	 */
-	void release();
-	/**
-	 * @brief 	Locks the supplied mutex.
-	 * @details
-	 * The mutex will be unlocked automatically
-	 * when this class is destroyed (for example when exiting the scope).
-	 * Only one mutex can be locked at a time!
-	 * @param mutex
-	 * @param mutexTimeout
-	 * @return
-	 */
-	ReturnValue_t lock(MutexIF* mutex,
-			uint32_t mutexTimeout = MutexIF::NO_TIMEOUT);
-	/**
-	 * @brief	Unlocks the mutex (if one has been locked previously).
-	 *          Unless this function is called, the mutex is unlocked
-	 *          when the class exits the scope.
-	 */
-	void unlock();
-
-
-	/**
-	 * Get the size of the data
-	 * @return
-	 */
-	size_t size() const;
-
-	/**
-	 * Get the storage ID.
-	 * @return
-	 */
-	store_address_t getId() const;
-
-	void print() const;
-protected:
-	const uint8_t* constDataPointer = nullptr;
-	store_address_t storeId;
-	size_t size_ = 0;
-	//! Managing pool, has to assign itself.
-	StorageManagerIF* store = nullptr;
-	//! Unique pointer to the mutex lock instance. Is initialized by
-	//! the pool manager.
-	std::unique_ptr<MutexHelper> mutexLock = nullptr;
-	bool deleteData = true;
-
-	enum class AccessState {
-		UNINIT,
-		READ
-	};
-	//! Internal state for safety reasons.
-	AccessState internalState = AccessState::UNINIT;
-	/**
-	 * Used by the pool manager instances to assign themselves to the
-	 * accessor. This is necessary to delete the data when the acessor
-	 * exits the scope ! The internal state will be considered read
-	 * when this function is called, so take care all data is set properly as
-	 * well.
-	 * @param
-	 */
-	void assignStore(StorageManagerIF*);
-
-};
-
-
-/**
- * @brief   Child class for modifyable data. Also has a normal pointer member.
- */
-class StorageAccessor: public ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	StorageAccessor(store_address_t storeId);
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * 			 move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	StorageAccessor& operator= (StorageAccessor&&);
-	StorageAccessor (StorageAccessor&&);
-
-	ReturnValue_t write(uint8_t *data, size_t size,
-		uint16_t offset);
-	uint8_t* data();
-
-private:
-	//! Non-const pointer for modifyable data.
-	uint8_t* dataPointer = nullptr;
-	//! For modifyable data, the const pointer is assigned to the normal
-	//! pointer by the pool manager so both access functions can be used safely
-	void assignConstPointer();
-};
-
-#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
+///**
+// * @brief 	Helper classes to facilitate safe access to storages which is also
+// * 			conforming to RAII principles
+// * @details	These helper can be used together with the
+// * 			StorageManager classes to manage access to a storage.
+// * 			It can take care of thread-safety while also providing
+// * 			mechanisms to automatically clear storage data and unlocking the
+// * 			pool.
+// */
+//#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
+//#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
+//
+//#include <framework/ipc/MutexHelper.h>
+//#include <framework/storagemanager/StorageManagerIF.h>
+//#include <memory>
+//
+//
+///**
+// * @brief   Accessor class which can be returned by pool managers
+// *          or passed and set by pool managers to have safe access to the pool
+// *          resources.
+// */
+//class ConstStorageAccessor {
+//	//! StorageManager classes have exclusive access to private variables.
+//	template<uint8_t NUMBER_OF_POOLS>
+//	friend class PoolManager;
+//	template<uint8_t NUMBER_OF_POOLS>
+//	friend class LocalPool;
+//public:
+//	/**
+//	 * @brief	Simple constructor which takes the store ID of the storage
+//	 * 			entry to access.
+//	 * @param storeId
+//	 */
+//	ConstStorageAccessor(store_address_t storeId);
+//
+//	/**
+//	 * @brief	Move ctor and move assignment allow returning accessors as
+//	 * 			a returnvalue. They prevent resource being free prematurely.
+//	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+//	 * move-constructors-and-move-assignment-operators-cpp.md
+//	 * @param
+//	 * @return
+//	 */
+//	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+//	ConstStorageAccessor (ConstStorageAccessor&&);
+//
+//	//! The copy ctor and copy assignemnt should be deleted implicitely
+//	//! according to https://foonathan.net/2019/02/special-member-functions/
+//	//! but I still deleted them to make it more explicit. (remember rule of 5).
+//	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
+//	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+//
+//	/**
+//	 * @brief 	The destructor in default configuration takes care of
+//	 * 			deleting the accessed pool entry and unlocking the mutex
+//	 */
+//	virtual ~ConstStorageAccessor();
+//
+//	/**
+//	 * @brief	Returns a pointer to the read-only data
+//	 * @return
+//	 */
+//	const uint8_t* data() const;
+//
+//	/**
+//	 * @brief	Copies the read-only data to the supplied pointer
+//	 * @param pointer
+//	 */
+//	void getDataCopy(uint8_t *pointer);
+//
+//	/**
+//	 * @brief   Calling this will prevent the Accessor from deleting the data
+//	 *          when the destructor is called.
+//	 */
+//	void release();
+//	/**
+//	 * @brief 	Locks the supplied mutex.
+//	 * @details
+//	 * The mutex will be unlocked automatically
+//	 * when this class is destroyed (for example when exiting the scope).
+//	 * Only one mutex can be locked at a time!
+//	 * @param mutex
+//	 * @param mutexTimeout
+//	 * @return
+//	 */
+//	ReturnValue_t lock(MutexIF* mutex,
+//			uint32_t mutexTimeout = MutexIF::NO_TIMEOUT);
+//	/**
+//	 * @brief	Unlocks the mutex (if one has been locked previously).
+//	 *          Unless this function is called, the mutex is unlocked
+//	 *          when the class exits the scope.
+//	 */
+//	void unlock();
+//
+//
+//	/**
+//	 * Get the size of the data
+//	 * @return
+//	 */
+//	size_t size() const;
+//
+//	/**
+//	 * Get the storage ID.
+//	 * @return
+//	 */
+//	store_address_t getId() const;
+//
+//	void print() const;
+//protected:
+//	const uint8_t* constDataPointer = nullptr;
+//	store_address_t storeId;
+//	size_t size_ = 0;
+//	//! Managing pool, has to assign itself.
+//	StorageManagerIF* store = nullptr;
+//	//! Unique pointer to the mutex lock instance. Is initialized by
+//	//! the pool manager.
+//	std::unique_ptr<MutexHelper> mutexLock = nullptr;
+//	bool deleteData = true;
+//
+//	enum class AccessState {
+//		UNINIT,
+//		READ
+//	};
+//	//! Internal state for safety reasons.
+//	AccessState internalState = AccessState::UNINIT;
+//	/**
+//	 * Used by the pool manager instances to assign themselves to the
+//	 * accessor. This is necessary to delete the data when the acessor
+//	 * exits the scope ! The internal state will be considered read
+//	 * when this function is called, so take care all data is set properly as
+//	 * well.
+//	 * @param
+//	 */
+//	void assignStore(StorageManagerIF*);
+//
+//};
+//
+//
+///**
+// * @brief   Child class for modifyable data. Also has a normal pointer member.
+// */
+//class StorageAccessor: public ConstStorageAccessor {
+//	//! StorageManager classes have exclusive access to private variables.
+//	template<uint8_t NUMBER_OF_POOLS>
+//	friend class PoolManager;
+//	template<uint8_t NUMBER_OF_POOLS>
+//	friend class LocalPool;
+//public:
+//	StorageAccessor(store_address_t storeId);
+//	/**
+//	 * @brief	Move ctor and move assignment allow returning accessors as
+//	 * 			a returnvalue. They prevent resource being free prematurely.
+//	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+//	 * 			 move-constructors-and-move-assignment-operators-cpp.md
+//	 * @param
+//	 * @return
+//	 */
+//	StorageAccessor& operator= (StorageAccessor&&);
+//	StorageAccessor (StorageAccessor&&);
+//
+//	ReturnValue_t write(uint8_t *data, size_t size,
+//		uint16_t offset);
+//	uint8_t* data();
+//
+//private:
+//	//! Non-const pointer for modifyable data.
+//	uint8_t* dataPointer = nullptr;
+//	//! For modifyable data, the const pointer is assigned to the normal
+//	//! pointer by the pool manager so both access functions can be used safely
+//	void assignConstPointer();
+//};
+//
+//#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */

From d44a06fafc1a63ec38354438910b556e0f1c6b81 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 10 May 2020 12:48:22 +0200
Subject: [PATCH 0233/1774] removed cfg include

---
 objectmanager/ObjectManagerIF.h | 30 +++++++++++++++++++-----------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 1d7674c64..3575fc162 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -9,9 +9,9 @@
 #define OBJECTMANAGERIF_H_
 
 #include <framework/objectmanager/frameworkObjects.h>
-#include <config/objects/systemObjectList.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 /**
  * @brief	This class provides an interface to the global object manager.
@@ -24,9 +24,12 @@
  */
 class ObjectManagerIF : public HasReturnvaluesIF {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
-	static const ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
+	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
+	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
+
 protected:
 	/**
 	 * @brief	This method is used to hide the template-based get call from
@@ -79,16 +82,21 @@ public:
 };
 
 
-/*Documentation can be found in the class method declaration above.*/
-template <typename T>
-T* ObjectManagerIF::get( object_id_t id ) {
-	SystemObjectIF* temp = this->getSystemObject(id);
-	return dynamic_cast<T*>(temp);
-}
-
 /**
  * @brief	This is the forward declaration of the global objectManager instance.
  */
 extern ObjectManagerIF *objectManager;
 
+/*Documentation can be found in the class method declaration above.*/
+template <typename T>
+T* ObjectManagerIF::get( object_id_t id ) {
+	if(objectManager == nullptr) {
+		sif::error << "ObjectManagerIF: Global object manager has not "
+				"been initialized yet!" << std::endl;
+		std::exit(0);
+	}
+	SystemObjectIF* temp = this->getSystemObject(id);
+	return dynamic_cast<T*>(temp);
+}
+
 #endif /* OBJECTMANAGERIF_H_ */

From 43d3ca7e379cf1dd20cd0372cf4883eb468d030a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 10 May 2020 21:56:21 +0200
Subject: [PATCH 0234/1774] memory message: no retval

CSB: retval
---
 memory/MemoryMessage.cpp             | 3 +--
 memory/MemoryMessage.h               | 2 +-
 tmtcservices/CommandingServiceBase.h | 2 ++
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/memory/MemoryMessage.cpp b/memory/MemoryMessage.cpp
index c1116e08a..f978ed4ec 100644
--- a/memory/MemoryMessage.cpp
+++ b/memory/MemoryMessage.cpp
@@ -31,12 +31,11 @@ ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_a
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
+void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
 		uint32_t address, store_address_t storageID) {
 	message->setCommand(CMD_MEMORY_LOAD);
 	message->setParameter( address );
 	message->setParameter2( storageID.raw );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {
diff --git a/memory/MemoryMessage.h b/memory/MemoryMessage.h
index 124fad081..bcc262e9d 100644
--- a/memory/MemoryMessage.h
+++ b/memory/MemoryMessage.h
@@ -24,7 +24,7 @@ public:
 	static ReturnValue_t getErrorCode( const CommandMessage* message );
 	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
 	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
-	static ReturnValue_t setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
+	static void setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
 	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
 	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
 	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 6b76bdabf..259ed1a3b 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -212,6 +212,8 @@ protected:
 	 */
 	PeriodicTaskIF* executingTask;
 
+	// todo: why do these functions not have returnvalues? the caller should be
+	// able to check whether the send operations actually work.
 	/**
 	 * Send TM data from pointer to data. If a header is supplied it is added before data
 	 * @param subservice Number of subservice

From 1946af64af5afb479bda4604b33d712eef99e43a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 12 May 2020 14:11:00 +0200
Subject: [PATCH 0235/1774] storage accessor mutex lock removed

---
 storagemanager/StorageAccessor.cpp | 284 ++++++++++++-------------
 storagemanager/StorageAccessor.h   | 326 ++++++++++++++---------------
 2 files changed, 282 insertions(+), 328 deletions(-)

diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index a068d1694..51b93f110 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,154 +1,130 @@
-//#include <framework/storagemanager/StorageAccessor.h>
-//
-//ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId): storeId(storeId) {}
-//
-//ConstStorageAccessor::~ConstStorageAccessor() {
-//	if(deleteData and store != nullptr) {
-//		sif::debug << "deleting store data" << std::endl;
-//		store->deleteDataNonLocking(storeId);
-//	}
-//	if(mutexLock != nullptr) {
-//		sif::debug << "unlocking mutex lock" << std::endl;
-//		mutexLock.reset();
-//	}
-//}
-//
-//ConstStorageAccessor& ConstStorageAccessor::operator=(
-//		ConstStorageAccessor&& other) {
-//	constDataPointer = other.constDataPointer;
-//	storeId = other.storeId;
-//	store = other.store;
-//	size_ = other.size_;
-//	deleteData = other.deleteData;
-//	this->store = other.store;
-//	// Transfer ownership of the lock.
-//	mutexLock = std::move(other.mutexLock);
-//	// This prevents double deletion of the resource
-//	other.mutexLock = nullptr;
-//	// This prevent premature deletion
-//	other.store = nullptr;
-//	return *this;
-//}
-//
-//StorageAccessor::StorageAccessor(store_address_t storeId):
-//		ConstStorageAccessor(storeId) {
-//}
-//
-//StorageAccessor& StorageAccessor::operator =(
-//		StorageAccessor&& other) {
-//	// Call the parent move assignment and also assign own member.
-//	dataPointer = other.dataPointer;
-//	StorageAccessor::operator=(std::move(other));
-//	return * this;
-//}
-//
-//// Call the parent move ctor and also transfer own member.
-//StorageAccessor::StorageAccessor(StorageAccessor&& other):
-//		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
-//}
-//
-//ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
-//		constDataPointer(other.constDataPointer), storeId(other.storeId),
-//		size_(other.size_), store(other.store), deleteData(other.deleteData),
-//		internalState(other.internalState) {
-//	// Transfer ownership of the lock.
-//	mutexLock = std::move(other.mutexLock);
-//	// This prevents double deletion of the resource. Not strictly necessary,
-//	// from the testing I have conducted so far but I am not familiar enough
-//	// with move semantics so I will just set the other lock to nullptr for now.
-//	other.mutexLock = nullptr;
-//	// This prevent premature deletion
-//	other.store = nullptr;
-//}
-//
-//const uint8_t* ConstStorageAccessor::data() const {
-//	return constDataPointer;
-//}
-//
-//size_t ConstStorageAccessor::size() const {
-//	if(internalState == AccessState::UNINIT) {
-//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-//	}
-//	return size_;
-//}
-//
-//void ConstStorageAccessor::getDataCopy(uint8_t *pointer) {
-//	if(internalState == AccessState::UNINIT) {
-//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-//		return;
-//	}
-//	std::copy(constDataPointer, constDataPointer + size_, pointer);
-//}
-//
-//void ConstStorageAccessor::release() {
-//	deleteData = false;
-//}
-//
-//ReturnValue_t ConstStorageAccessor::lock(MutexIF* mutex, uint32_t mutexTimeout) {
-//	if(mutexLock == nullptr) {
-//		mutexLock = std::unique_ptr<MutexHelper>(new MutexHelper(mutex, mutexTimeout));
-//		return mutexLock.get()->getResult();
-//	}
-//	else {
-//		sif::warning << "StorageAccessor: Attempted to lock twice. Check code!" << std::endl;
-//		return HasReturnvaluesIF::RETURN_FAILED;
-//	}
-//}
-//
-//void ConstStorageAccessor::unlock() {
-//	if(mutexLock != nullptr) {
-//		mutexLock.reset();
-//	}
-//}
-//
-//store_address_t ConstStorageAccessor::getId() const {
-//	return storeId;
-//}
-//
-//void ConstStorageAccessor::print() const {
-//	if(internalState == AccessState::UNINIT) {
-//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-//		return;
-//	}
-//	sif::info << "StorageAccessor: Printing data: [";
-//	for(uint16_t iPool = 0; iPool < size_; iPool++) {
-//		sif::info << std::hex << (int)constDataPointer[iPool];
-//		if(iPool < size_ - 1){
-//			sif::info << " , ";
-//		}
-//	}
-//	sif::info << " ] " << std::endl;
-//}
-//
-//void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
-//	internalState = AccessState::READ;
-//	this->store = store;
-//}
-//
-//
-//uint8_t* StorageAccessor::data() {
-//	if(internalState == AccessState::UNINIT) {
-//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-//	}
-//	return dataPointer;
-//}
-//
-//ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
-//		uint16_t offset) {
-//	if(internalState == AccessState::UNINIT) {
-//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-//		return HasReturnvaluesIF::RETURN_FAILED;
-//	}
-//	if(offset + size > size_) {
-//		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
-//		return HasReturnvaluesIF::RETURN_FAILED;
-//	}
-//	std::copy(data, data + size, dataPointer);
-//	return HasReturnvaluesIF::RETURN_OK;
-//}
-//
-//void StorageAccessor::assignConstPointer() {
-//	constDataPointer = dataPointer;
-//}
-//
-//
+#include <framework/storagemanager/StorageAccessor.h>
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
+		storeId(storeId) {}
+
+ConstStorageAccessor::~ConstStorageAccessor() {
+	if(deleteData and store != nullptr) {
+		sif::debug << "deleting store data" << std::endl;
+		store->deleteData(storeId);
+	}
+}
+
+ConstStorageAccessor& ConstStorageAccessor::operator=(
+		ConstStorageAccessor&& other) {
+	constDataPointer = other.constDataPointer;
+	storeId = other.storeId;
+	store = other.store;
+	size_ = other.size_;
+	deleteData = other.deleteData;
+	this->store = other.store;
+	// This prevents premature deletion
+	other.store = nullptr;
+	return *this;
+}
+
+StorageAccessor::StorageAccessor(store_address_t storeId):
+		ConstStorageAccessor(storeId) {
+}
+
+StorageAccessor& StorageAccessor::operator =(
+		StorageAccessor&& other) {
+	// Call the parent move assignment and also assign own member.
+	dataPointer = other.dataPointer;
+	StorageAccessor::operator=(std::move(other));
+	return * this;
+}
+
+// Call the parent move ctor and also transfer own member.
+StorageAccessor::StorageAccessor(StorageAccessor&& other):
+		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+}
+
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
+const uint8_t* ConstStorageAccessor::data() const {
+	return constDataPointer;
+}
+
+size_t ConstStorageAccessor::size() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return size_;
+}
+
+ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
+		size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(constDataPointer, constDataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ConstStorageAccessor::release() {
+	deleteData = false;
+}
+
+store_address_t ConstStorageAccessor::getId() const {
+	return storeId;
+}
+
+void ConstStorageAccessor::print() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	sif::info << "StorageAccessor: Printing data: [";
+	for(uint16_t iPool = 0; iPool < size_; iPool++) {
+		sif::info << std::hex << (int)constDataPointer[iPool];
+		if(iPool < size_ - 1){
+			sif::info << " , ";
+		}
+	}
+	sif::info << " ] " << std::endl;
+}
+
+void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+	internalState = AccessState::READ;
+	this->store = store;
+}
+
+
+uint8_t* StorageAccessor::data() {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return dataPointer;
+}
+
+ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
+		uint16_t offset) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(offset + size > size_) {
+		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(data, data + size, dataPointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void StorageAccessor::assignConstPointer() {
+	constDataPointer = dataPointer;
+}
+
+
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index d391c5c26..2e1d44bd1 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,174 +1,152 @@
-///**
-// * @brief 	Helper classes to facilitate safe access to storages which is also
-// * 			conforming to RAII principles
-// * @details	These helper can be used together with the
-// * 			StorageManager classes to manage access to a storage.
-// * 			It can take care of thread-safety while also providing
-// * 			mechanisms to automatically clear storage data and unlocking the
-// * 			pool.
-// */
-//#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
-//#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
-//
-//#include <framework/ipc/MutexHelper.h>
-//#include <framework/storagemanager/StorageManagerIF.h>
-//#include <memory>
-//
-//
-///**
-// * @brief   Accessor class which can be returned by pool managers
-// *          or passed and set by pool managers to have safe access to the pool
-// *          resources.
-// */
-//class ConstStorageAccessor {
-//	//! StorageManager classes have exclusive access to private variables.
-//	template<uint8_t NUMBER_OF_POOLS>
-//	friend class PoolManager;
-//	template<uint8_t NUMBER_OF_POOLS>
-//	friend class LocalPool;
-//public:
-//	/**
-//	 * @brief	Simple constructor which takes the store ID of the storage
-//	 * 			entry to access.
-//	 * @param storeId
-//	 */
-//	ConstStorageAccessor(store_address_t storeId);
-//
-//	/**
-//	 * @brief	Move ctor and move assignment allow returning accessors as
-//	 * 			a returnvalue. They prevent resource being free prematurely.
-//	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-//	 * move-constructors-and-move-assignment-operators-cpp.md
-//	 * @param
-//	 * @return
-//	 */
-//	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-//	ConstStorageAccessor (ConstStorageAccessor&&);
-//
-//	//! The copy ctor and copy assignemnt should be deleted implicitely
-//	//! according to https://foonathan.net/2019/02/special-member-functions/
-//	//! but I still deleted them to make it more explicit. (remember rule of 5).
-//	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
-//	ConstStorageAccessor (ConstStorageAccessor&) = delete;
-//
-//	/**
-//	 * @brief 	The destructor in default configuration takes care of
-//	 * 			deleting the accessed pool entry and unlocking the mutex
-//	 */
-//	virtual ~ConstStorageAccessor();
-//
-//	/**
-//	 * @brief	Returns a pointer to the read-only data
-//	 * @return
-//	 */
-//	const uint8_t* data() const;
-//
-//	/**
-//	 * @brief	Copies the read-only data to the supplied pointer
-//	 * @param pointer
-//	 */
-//	void getDataCopy(uint8_t *pointer);
-//
-//	/**
-//	 * @brief   Calling this will prevent the Accessor from deleting the data
-//	 *          when the destructor is called.
-//	 */
-//	void release();
-//	/**
-//	 * @brief 	Locks the supplied mutex.
-//	 * @details
-//	 * The mutex will be unlocked automatically
-//	 * when this class is destroyed (for example when exiting the scope).
-//	 * Only one mutex can be locked at a time!
-//	 * @param mutex
-//	 * @param mutexTimeout
-//	 * @return
-//	 */
-//	ReturnValue_t lock(MutexIF* mutex,
-//			uint32_t mutexTimeout = MutexIF::NO_TIMEOUT);
-//	/**
-//	 * @brief	Unlocks the mutex (if one has been locked previously).
-//	 *          Unless this function is called, the mutex is unlocked
-//	 *          when the class exits the scope.
-//	 */
-//	void unlock();
-//
-//
-//	/**
-//	 * Get the size of the data
-//	 * @return
-//	 */
-//	size_t size() const;
-//
-//	/**
-//	 * Get the storage ID.
-//	 * @return
-//	 */
-//	store_address_t getId() const;
-//
-//	void print() const;
-//protected:
-//	const uint8_t* constDataPointer = nullptr;
-//	store_address_t storeId;
-//	size_t size_ = 0;
-//	//! Managing pool, has to assign itself.
-//	StorageManagerIF* store = nullptr;
-//	//! Unique pointer to the mutex lock instance. Is initialized by
-//	//! the pool manager.
-//	std::unique_ptr<MutexHelper> mutexLock = nullptr;
-//	bool deleteData = true;
-//
-//	enum class AccessState {
-//		UNINIT,
-//		READ
-//	};
-//	//! Internal state for safety reasons.
-//	AccessState internalState = AccessState::UNINIT;
-//	/**
-//	 * Used by the pool manager instances to assign themselves to the
-//	 * accessor. This is necessary to delete the data when the acessor
-//	 * exits the scope ! The internal state will be considered read
-//	 * when this function is called, so take care all data is set properly as
-//	 * well.
-//	 * @param
-//	 */
-//	void assignStore(StorageManagerIF*);
-//
-//};
-//
-//
-///**
-// * @brief   Child class for modifyable data. Also has a normal pointer member.
-// */
-//class StorageAccessor: public ConstStorageAccessor {
-//	//! StorageManager classes have exclusive access to private variables.
-//	template<uint8_t NUMBER_OF_POOLS>
-//	friend class PoolManager;
-//	template<uint8_t NUMBER_OF_POOLS>
-//	friend class LocalPool;
-//public:
-//	StorageAccessor(store_address_t storeId);
-//	/**
-//	 * @brief	Move ctor and move assignment allow returning accessors as
-//	 * 			a returnvalue. They prevent resource being free prematurely.
-//	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-//	 * 			 move-constructors-and-move-assignment-operators-cpp.md
-//	 * @param
-//	 * @return
-//	 */
-//	StorageAccessor& operator= (StorageAccessor&&);
-//	StorageAccessor (StorageAccessor&&);
-//
-//	ReturnValue_t write(uint8_t *data, size_t size,
-//		uint16_t offset);
-//	uint8_t* data();
-//
-//private:
-//	//! Non-const pointer for modifyable data.
-//	uint8_t* dataPointer = nullptr;
-//	//! For modifyable data, the const pointer is assigned to the normal
-//	//! pointer by the pool manager so both access functions can be used safely
-//	void assignConstPointer();
-//};
-//
-//#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
+/**
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details	These helper can be used together with the
+ * 			StorageManager classes to manage access to a storage.
+ * 			It can take care of thread-safety while also providing
+ * 			mechanisms to automatically clear storage data and unlocking the
+ * 			pool.
+ */
+#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
+#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
+
+#include <framework/ipc/MutexHelper.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <memory>
+
+
+/**
+ * @brief   Accessor class which can be returned by pool managers
+ *          or passed and set by pool managers to have safe access to the pool
+ *          resources.
+ */
+class ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	/**
+	 * @brief	Simple constructor which takes the store ID of the storage
+	 * 			entry to access.
+	 * @param storeId
+	 */
+	ConstStorageAccessor(store_address_t storeId);
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+	ConstStorageAccessor (ConstStorageAccessor&&);
+
+	//! The copy ctor and copy assignemnt should be deleted implicitely
+	//! according to https://foonathan.net/2019/02/special-member-functions/
+	//! but I still deleted them to make it more explicit. (remember rule of 5).
+	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+
+	/**
+	 * @brief 	The destructor in default configuration takes care of
+	 * 			deleting the accessed pool entry and unlocking the mutex
+	 */
+	virtual ~ConstStorageAccessor();
+
+	/**
+	 * @brief	Returns a pointer to the read-only data
+	 * @return
+	 */
+	const uint8_t* data() const;
+
+	/**
+	 * @brief	Copies the read-only data to the supplied pointer
+	 * @param pointer
+	 */
+	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
+
+	/**
+	 * @brief   Calling this will prevent the Accessor from deleting the data
+	 *          when the destructor is called.
+	 */
+	void release();
+
+	/**
+	 * Get the size of the data
+	 * @return
+	 */
+	size_t size() const;
+
+	/**
+	 * Get the storage ID.
+	 * @return
+	 */
+	store_address_t getId() const;
+
+	void print() const;
+protected:
+	const uint8_t* constDataPointer = nullptr;
+	store_address_t storeId;
+	size_t size_ = 0;
+	//! Managing pool, has to assign itself.
+	StorageManagerIF* store = nullptr;
+	bool deleteData = true;
+
+	enum class AccessState {
+		UNINIT,
+		READ
+	};
+	//! Internal state for safety reasons.
+	AccessState internalState = AccessState::UNINIT;
+	/**
+	 * Used by the pool manager instances to assign themselves to the
+	 * accessor. This is necessary to delete the data when the acessor
+	 * exits the scope ! The internal state will be considered read
+	 * when this function is called, so take care all data is set properly as
+	 * well.
+	 * @param
+	 */
+	void assignStore(StorageManagerIF*);
+
+};
+
+
+/**
+ * @brief   Child class for modifyable data. Also has a normal pointer member.
+ */
+class StorageAccessor: public ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	StorageAccessor(store_address_t storeId);
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * 			 move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	StorageAccessor& operator= (StorageAccessor&&);
+	StorageAccessor (StorageAccessor&&);
+
+	ReturnValue_t write(uint8_t *data, size_t size,
+		uint16_t offset);
+	uint8_t* data();
+
+private:
+	//! Non-const pointer for modifyable data.
+	uint8_t* dataPointer = nullptr;
+	//! For modifyable data, the const pointer is assigned to the normal
+	//! pointer by the pool manager so both access functions can be used safely
+	void assignConstPointer();
+};
+
+#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */

From 5af0c15dfc6906eb16675e53416c0fe2f95b34b0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 12 May 2020 14:12:39 +0200
Subject: [PATCH 0236/1774] simplified storage accessor

---
 ipc/MutexHelper.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index f76ccec47..671cd5a6a 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -10,11 +10,11 @@ public:
 			internalMutex(mutex) {
 		ReturnValue_t status = mutex->lockMutex(timeoutMs);
 		if(status != HasReturnvaluesIF::RETURN_OK){
-			sif::error << "MutexHelper: Lock of Mutex failed " << status << std::endl;
+			sif::error << "MutexHelper: Lock of Mutex failed " <<
+					status << std::endl;
 		}
 	}
 
-
 	~MutexHelper() {
 		internalMutex->unlockMutex();
 	}

From 6c70abfe1621a83074f21476d680bc808a52576f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 12 May 2020 16:32:01 +0200
Subject: [PATCH 0237/1774] moved pool accessor fuctions to local pool

---
 storagemanager/LocalPool.h        | 10 ++++++-
 storagemanager/LocalPool.tpp      | 43 +++++++++++++++++++++++++++++--
 storagemanager/PoolManager.h      | 19 +++++++-------
 storagemanager/PoolManager.tpp    |  5 ++++
 storagemanager/StorageAccessor.h  |  4 +--
 storagemanager/StorageManagerIF.h | 17 +++++++++++-
 6 files changed, 82 insertions(+), 16 deletions(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index a63344581..6892b881b 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -6,7 +6,8 @@
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/internalError/InternalErrorReporterIF.h>
-#include <string.h>
+#include <framework/storagemanager/StorageAccessor.h>
+#include <cstring>
 
 /**
  * @brief	The LocalPool class provides an intermediate data storage with
@@ -67,10 +68,17 @@ public:
 			size_t size, bool ignoreFault = false) override;
 	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
 			uint8_t** p_data, bool ignoreFault = false) override;
+
+	ConstAccessorPair getData(store_address_t packet_id) override;
+	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
 	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
 			size_t * size) override;
+
+	AccessorPair modifyData(store_address_t packet_id) override;
+	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
 	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
 			size_t * size) override;
+
 	virtual ReturnValue_t deleteData(store_address_t) override;
 	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
 			store_address_t* storeId = NULL) override;
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index c46e1a8d1..310349744 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -121,8 +121,8 @@ inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
 	}
 }
 
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(store_address_t* storageId,
+template<uint8_t NUMBER_OF_POOLS> inline
+ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(store_address_t* storageId,
 		const uint8_t* data, size_t size, bool ignoreFault) {
 	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
 	if (status == RETURN_OK) {
@@ -144,6 +144,25 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
 	return status;
 }
 
+template<uint8_t NUMBER_OF_POOLS>
+inline ConstAccessorPair LocalPool<NUMBER_OF_POOLS>::getData(
+		store_address_t storeId) {
+	uint8_t* tempData = nullptr;
+	ConstStorageAccessor constAccessor(storeId);
+	ReturnValue_t status = modifyData(storeId, &tempData, &constAccessor.size_);
+	constAccessor.constDataPointer = tempData;
+	return ConstAccessorPair(status, std::move(constAccessor));
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(store_address_t storeId,
+		ConstStorageAccessor& storeAccessor) {
+	uint8_t* tempData = nullptr;
+	ReturnValue_t status = modifyData(storeId, &tempData, &storeAccessor.size_);
+	storeAccessor.constDataPointer = tempData;
+	return status;
+}
+
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
 		store_address_t packet_id, const uint8_t** packet_ptr, size_t* size) {
@@ -153,6 +172,26 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
 	return status;
 }
 
+template<uint8_t NUMBER_OF_POOLS>
+inline AccessorPair LocalPool<NUMBER_OF_POOLS>::modifyData(
+		store_address_t storeId) {
+	uint8_t* tempData = nullptr;
+	StorageAccessor accessor(storeId);
+	ReturnValue_t status = modifyData(storeId, &tempData, &accessor.size_);
+	accessor.constDataPointer = tempData;
+	accessor.assignConstPointer();
+	return AccessorPair(status, std::move(accessor));
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
+		store_address_t storeId, StorageAccessor& storeAccessor) {
+	ReturnValue_t status = modifyData(storeId, &storeAccessor.dataPointer,
+			&storeAccessor.size_);
+	storeAccessor.assignConstPointer();
+	return status;
+}
+
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
 		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 41325273a..87670a828 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,9 +1,9 @@
 #ifndef POOLMANAGER_H_
 #define POOLMANAGER_H_
 
-
 #include <framework/storagemanager/LocalPool.h>
 #include <framework/ipc/MutexHelper.h>
+#include <framework/storagemanager/StorageAccessor.h>
 
 /**
  * @brief	The PoolManager class provides an intermediate data storage with
@@ -11,20 +11,21 @@
  * @details	Uses local pool calls but is thread safe by protecting the call
  * 			with a lock.
  */
-
-template <uint8_t NUMBER_OF_POOLS = 5>
+template <uint8_t NUMBER_OF_POOLS>
 class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
 public:
-	PoolManager( object_id_t setObjectId, const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS] );
-	/**
-	 * @brief	In the PoolManager's destructor all allocated memory is freed.
-	 */
+	PoolManager(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS]);
+
+	//! @brief	In the PoolManager's destructor all allocated memory is freed.
 	virtual ~PoolManager();
 
+	//! @brief LocalPool overrides for thread-safety. Decorator function which
+	//! 	   wraps LocalPool calls with a mutex protection.
 	ReturnValue_t deleteData(store_address_t) override;
 	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
-			store_address_t* storeId = NULL) override;
+			store_address_t* storeId = nullptr) override;
 protected:
 	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
 			bool ignoreFault) override;
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 0408d55b9..7025d7959 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -1,3 +1,6 @@
+#ifndef POOLMANAGER_TPP_
+#define POOLMANAGER_TPP_
+
 template<uint8_t NUMBER_OF_POOLS>
 inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
 		const uint16_t element_sizes[NUMBER_OF_POOLS],
@@ -40,3 +43,5 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 	return status;
 }
 
+#endif
+
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 2e1d44bd1..da319a975 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -4,8 +4,7 @@
  * @details	These helper can be used together with the
  * 			StorageManager classes to manage access to a storage.
  * 			It can take care of thread-safety while also providing
- * 			mechanisms to automatically clear storage data and unlocking the
- * 			pool.
+ * 			mechanisms to automatically clear storage data.
  */
 #ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
 #define TEST_PROTOTYPES_STORAGEACCESSOR_H_
@@ -14,7 +13,6 @@
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <memory>
 
-
 /**
  * @brief   Accessor class which can be returned by pool managers
  *          or passed and set by pool managers to have safe access to the pool
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index d1f9cde5d..27448ef7c 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -3,7 +3,14 @@
 
 #include <framework/events/Event.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <stddef.h>
+#include <cstddef>
+#include <utility>
+
+class StorageAccessor;
+class ConstStorageAccessor;
+
+using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
+using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
 
 /**
  * This union defines the type that identifies where a data packet is
@@ -150,6 +157,14 @@ public:
 	 */
 	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
 			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+
+	virtual AccessorPair modifyData(store_address_t storeId) = 0;
+	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
+	virtual ReturnValue_t modifyData(store_address_t storeId,
+			StorageAccessor&) = 0;
+	virtual ReturnValue_t getData(store_address_t storeId,
+			ConstStorageAccessor&) = 0;
+
 	/**
 	 * Clears the whole store.
 	 * Use with care!

From d873fcbf8ece518e1da89500ef8195da4384c1a3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 12 May 2020 16:47:47 +0200
Subject: [PATCH 0238/1774] added documentation for storage manager IF

---
 storagemanager/StorageManagerIF.h | 53 +++++++++++++++++++++++++------
 1 file changed, 44 insertions(+), 9 deletions(-)

diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 27448ef7c..b5508da84 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -124,6 +124,27 @@ public:
 	 */
 	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = nullptr) = 0;
+
+	/**
+	 * @brief 	Access the data by supplying a store ID.
+	 * @details
+	 * A pair consisting of the retrieval result and an instance of a
+	 * ConstStorageAccessor class is returned
+	 * @param storeId
+	 * @return Pair of return value and a ConstStorageAccessor instance
+	 */
+	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
+
+	/**
+	 * @brief 	Access the data by supplying a store ID and a helper
+	 * 			instance
+	 * @param storeId
+	 * @param constAccessor Wrapper function to access store data.
+	 * @return
+	 */
+	virtual ReturnValue_t getData(store_address_t storeId,
+			ConstStorageAccessor& constAccessor) = 0;
+
 	/**
 	 * @brief	getData returns an address to data and the size of the data
 	 * 			for a given packet_id.
@@ -137,8 +158,30 @@ public:
 	 */
 	virtual ReturnValue_t getData(store_address_t packet_id,
 			const uint8_t** packet_ptr, size_t* size) = 0;
+
+
 	/**
-	 * Same as above, but not const and therefore modifiable.
+	 * Modify data by supplying a store ID
+	 * @param storeId
+	 * @return Pair of return value and StorageAccessor helper
+	 */
+	virtual AccessorPair modifyData(store_address_t storeId) = 0;
+
+	/**
+	 * Modify data by supplying a store ID and a StorageAccessor helper instance.
+	 * @param storeId
+	 * @param accessor Helper class to access the modifiable data.
+	 * @return
+	 */
+	virtual ReturnValue_t modifyData(store_address_t storeId,
+				StorageAccessor& accessor) = 0;
+
+	/**
+	 * Get pointer and size of modifiable data by supplying the storeId
+	 * @param packet_id
+	 * @param packet_ptr [out] Pointer to pointer of data to set
+	 * @param size [out] Pointer to size to set
+	 * @return
 	 */
 	virtual ReturnValue_t modifyData(store_address_t packet_id,
 			uint8_t** packet_ptr, size_t* size) = 0;
@@ -158,19 +201,11 @@ public:
 	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
 			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
 
-	virtual AccessorPair modifyData(store_address_t storeId) = 0;
-	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
-	virtual ReturnValue_t modifyData(store_address_t storeId,
-			StorageAccessor&) = 0;
-	virtual ReturnValue_t getData(store_address_t storeId,
-			ConstStorageAccessor&) = 0;
-
 	/**
 	 * Clears the whole store.
 	 * Use with care!
 	 */
 	virtual void clearStore() = 0;
-
 };
 
 #endif /* STORAGEMANAGERIF_H_ */

From 291710f257745e60e8417b2fa3648dcbfa09ed5d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 12 May 2020 17:57:37 +0200
Subject: [PATCH 0239/1774] new ctor and bugfixes

---
 storagemanager/LocalPool.tpp       |  6 +++--
 storagemanager/StorageAccessor.cpp | 13 +++++++++-
 storagemanager/StorageAccessor.h   | 39 +++++++++++++++---------------
 storagemanager/StorageManagerIF.h  |  4 +++
 4 files changed, 40 insertions(+), 22 deletions(-)

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 310349744..98343ea79 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -148,7 +148,7 @@ template<uint8_t NUMBER_OF_POOLS>
 inline ConstAccessorPair LocalPool<NUMBER_OF_POOLS>::getData(
 		store_address_t storeId) {
 	uint8_t* tempData = nullptr;
-	ConstStorageAccessor constAccessor(storeId);
+	ConstStorageAccessor constAccessor(storeId, this);
 	ReturnValue_t status = modifyData(storeId, &tempData, &constAccessor.size_);
 	constAccessor.constDataPointer = tempData;
 	return ConstAccessorPair(status, std::move(constAccessor));
@@ -159,6 +159,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(store_address_t storeId
 		ConstStorageAccessor& storeAccessor) {
 	uint8_t* tempData = nullptr;
 	ReturnValue_t status = modifyData(storeId, &tempData, &storeAccessor.size_);
+	storeAccessor.assignStore(this);
 	storeAccessor.constDataPointer = tempData;
 	return status;
 }
@@ -176,7 +177,7 @@ template<uint8_t NUMBER_OF_POOLS>
 inline AccessorPair LocalPool<NUMBER_OF_POOLS>::modifyData(
 		store_address_t storeId) {
 	uint8_t* tempData = nullptr;
-	StorageAccessor accessor(storeId);
+	StorageAccessor accessor(storeId, this);
 	ReturnValue_t status = modifyData(storeId, &tempData, &accessor.size_);
 	accessor.constDataPointer = tempData;
 	accessor.assignConstPointer();
@@ -188,6 +189,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
 		store_address_t storeId, StorageAccessor& storeAccessor) {
 	ReturnValue_t status = modifyData(storeId, &storeAccessor.dataPointer,
 			&storeAccessor.size_);
+	storeAccessor.assignStore(this);
 	storeAccessor.assignConstPointer();
 	return status;
 }
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index 51b93f110..676930545 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -3,6 +3,12 @@
 ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
 		storeId(storeId) {}
 
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		storeId(storeId), store(store) {
+	internalState = AccessState::ASSIGNED;
+}
+
 ConstStorageAccessor::~ConstStorageAccessor() {
 	if(deleteData and store != nullptr) {
 		sif::debug << "deleting store data" << std::endl;
@@ -27,6 +33,11 @@ StorageAccessor::StorageAccessor(store_address_t storeId):
 		ConstStorageAccessor(storeId) {
 }
 
+StorageAccessor::StorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		ConstStorageAccessor(storeId, store) {
+}
+
 StorageAccessor& StorageAccessor::operator =(
 		StorageAccessor&& other) {
 	// Call the parent move assignment and also assign own member.
@@ -97,7 +108,7 @@ void ConstStorageAccessor::print() const {
 }
 
 void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
-	internalState = AccessState::READ;
+	internalState = AccessState::ASSIGNED;
 	this->store = store;
 }
 
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index da319a975..2be80601a 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -31,23 +31,7 @@ public:
 	 * @param storeId
 	 */
 	ConstStorageAccessor(store_address_t storeId);
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor (ConstStorageAccessor&&);
-
-	//! The copy ctor and copy assignemnt should be deleted implicitely
-	//! according to https://foonathan.net/2019/02/special-member-functions/
-	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
 
 	/**
 	 * @brief 	The destructor in default configuration takes care of
@@ -86,6 +70,23 @@ public:
 	store_address_t getId() const;
 
 	void print() const;
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+	ConstStorageAccessor (ConstStorageAccessor&&);
+
+	//! The copy ctor and copy assignemnt should be deleted implicitely
+	//! according to https://foonathan.net/2019/02/special-member-functions/
+	//! but I still deleted them to make it more explicit. (remember rule of 5).
+	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor (ConstStorageAccessor&) = delete;
 protected:
 	const uint8_t* constDataPointer = nullptr;
 	store_address_t storeId;
@@ -96,7 +97,7 @@ protected:
 
 	enum class AccessState {
 		UNINIT,
-		READ
+		ASSIGNED
 	};
 	//! Internal state for safety reasons.
 	AccessState internalState = AccessState::UNINIT;
@@ -109,7 +110,6 @@ protected:
 	 * @param
 	 */
 	void assignStore(StorageManagerIF*);
-
 };
 
 
@@ -124,6 +124,7 @@ class StorageAccessor: public ConstStorageAccessor {
 	friend class LocalPool;
 public:
 	StorageAccessor(store_address_t storeId);
+	StorageAccessor(store_address_t storeId, StorageManagerIF* store);
 	/**
 	 * @brief	Move ctor and move assignment allow returning accessors as
 	 * 			a returnvalue. They prevent resource being free prematurely.
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index b5508da84..559c4b9a8 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -55,6 +55,10 @@ union store_address_t {
 	 * Alternative access to the raw value.
 	 */
 	uint32_t raw;
+
+	bool operator==(const store_address_t& other) const {
+		return raw == other.raw;
+	}
 };
 
 /**

From 3122f62b0a1e81268ad5f7ac8fa249a5458dc906 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 12 May 2020 19:02:59 +0200
Subject: [PATCH 0240/1774] bugfixes for write() call

---
 storagemanager/LocalPool.tpp       |  7 ++-
 storagemanager/StorageAccessor.cpp | 75 ++++++++++++++++++------------
 storagemanager/StorageAccessor.h   |  5 +-
 3 files changed, 50 insertions(+), 37 deletions(-)

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 98343ea79..59d06ab80 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -176,10 +176,9 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
 template<uint8_t NUMBER_OF_POOLS>
 inline AccessorPair LocalPool<NUMBER_OF_POOLS>::modifyData(
 		store_address_t storeId) {
-	uint8_t* tempData = nullptr;
 	StorageAccessor accessor(storeId, this);
-	ReturnValue_t status = modifyData(storeId, &tempData, &accessor.size_);
-	accessor.constDataPointer = tempData;
+	ReturnValue_t status = modifyData(storeId, &accessor.dataPointer,
+			&accessor.size_);
 	accessor.assignConstPointer();
 	return AccessorPair(status, std::move(accessor));
 }
@@ -187,9 +186,9 @@ inline AccessorPair LocalPool<NUMBER_OF_POOLS>::modifyData(
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
 		store_address_t storeId, StorageAccessor& storeAccessor) {
+	storeAccessor.assignStore(this);
 	ReturnValue_t status = modifyData(storeId, &storeAccessor.dataPointer,
 			&storeAccessor.size_);
-	storeAccessor.assignStore(this);
 	storeAccessor.assignConstPointer();
 	return status;
 }
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index 676930545..cc292d6cc 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -16,6 +16,14 @@ ConstStorageAccessor::~ConstStorageAccessor() {
 	}
 }
 
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
 ConstStorageAccessor& ConstStorageAccessor::operator=(
 		ConstStorageAccessor&& other) {
 	constDataPointer = other.constDataPointer;
@@ -29,36 +37,6 @@ ConstStorageAccessor& ConstStorageAccessor::operator=(
 	return *this;
 }
 
-StorageAccessor::StorageAccessor(store_address_t storeId):
-		ConstStorageAccessor(storeId) {
-}
-
-StorageAccessor::StorageAccessor(store_address_t storeId,
-		StorageManagerIF* store):
-		ConstStorageAccessor(storeId, store) {
-}
-
-StorageAccessor& StorageAccessor::operator =(
-		StorageAccessor&& other) {
-	// Call the parent move assignment and also assign own member.
-	dataPointer = other.dataPointer;
-	StorageAccessor::operator=(std::move(other));
-	return * this;
-}
-
-// Call the parent move ctor and also transfer own member.
-StorageAccessor::StorageAccessor(StorageAccessor&& other):
-		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
-}
-
-ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
-		constDataPointer(other.constDataPointer), storeId(other.storeId),
-		size_(other.size_), store(other.store), deleteData(other.deleteData),
-		internalState(other.internalState) {
-	// This prevent premature deletion
-	other.store = nullptr;
-}
-
 const uint8_t* ConstStorageAccessor::data() const {
 	return constDataPointer;
 }
@@ -113,6 +91,41 @@ void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
 }
 
 
+StorageAccessor::StorageAccessor(store_address_t storeId):
+		ConstStorageAccessor(storeId) {
+}
+
+StorageAccessor::StorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		ConstStorageAccessor(storeId, store) {
+}
+
+StorageAccessor& StorageAccessor::operator =(
+		StorageAccessor&& other) {
+	// Call the parent move assignment and also assign own member.
+	dataPointer = other.dataPointer;
+	StorageAccessor::operator=(std::move(other));
+	return * this;
+}
+
+// Call the parent move ctor and also transfer own member.
+StorageAccessor::StorageAccessor(StorageAccessor&& other):
+		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+}
+
+ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(dataPointer, dataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 uint8_t* StorageAccessor::data() {
 	if(internalState == AccessState::UNINIT) {
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
@@ -130,7 +143,7 @@ ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
 		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	std::copy(data, data + size, dataPointer);
+	std::copy(data, data + size, dataPointer + offset);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 2be80601a..8949642cd 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -49,7 +49,7 @@ public:
 	 * @brief	Copies the read-only data to the supplied pointer
 	 * @param pointer
 	 */
-	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
+	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
 
 	/**
 	 * @brief   Calling this will prevent the Accessor from deleting the data
@@ -137,8 +137,9 @@ public:
 	StorageAccessor (StorageAccessor&&);
 
 	ReturnValue_t write(uint8_t *data, size_t size,
-		uint16_t offset);
+		uint16_t offset = 0);
 	uint8_t* data();
+	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
 
 private:
 	//! Non-const pointer for modifyable data.

From 50a1b5170aa472c143c8a1a349e04316fb399225 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 13 May 2020 18:03:09 +0200
Subject: [PATCH 0241/1774] formatting

---
 devicehandlers/DeviceHandlerBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 729eac0b5..25ec75b93 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -327,7 +327,7 @@ protected:
 	 * @param len length of remaining buffer to be scanned
 	 * @param[out] foundId the id of the data found in the buffer.
 	 * @param[out] foundLen length of the data found. Is to be set in function,
-	 * 						buffer is scanned at previous position + foundLen.
+	 * buffer is scanned at previous position + foundLen.
 	 * @return
 	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
 	 *     - @c RETURN_FAILED no reply could be found starting at @c start,

From 49fa2fe32c6bfc4fba6fc91e8cbf564eb7532658 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 May 2020 16:12:01 +0200
Subject: [PATCH 0242/1774] changed void* cast to QueueHandle_t cast

---
 osal/FreeRTOS/MessageQueue.cpp | 4 ++--
 osal/FreeRTOS/MessageQueue.h   | 7 +++++--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index e7de799cf..aa4b93b7e 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -120,7 +120,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     message->setSender(sentFrom);
     BaseType_t result;
     if(callContext == CallContext::task) {
-        result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),
+        result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
                 reinterpret_cast<const void*>(message->getBuffer()), 0);
     }
     else {
@@ -128,7 +128,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         // request a context switch if a higher priority task
         // was blocked by the interrupt.
         BaseType_t xHigherPriorityTaskWoken = pdFALSE;
-        result = xQueueSendFromISR(reinterpret_cast<void*>(sendTo),
+        result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
                 reinterpret_cast<const void*>(message->getBuffer()),
                 &xHigherPriorityTaskWoken);
         if(xHigherPriorityTaskWoken == pdTRUE) {
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 27076869b..d8a307eab 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -6,8 +6,11 @@
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
-#include <FreeRTOS.h>
-#include "queue.h"
+extern "C" {
+#include "FreeRTOS.h"
+#include "freertos/queue.h"
+}
+
 
 
 //TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution

From 69237bc2e87fba9d5b3c8dfc91d11e328e2bdfc8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 May 2020 21:26:04 +0200
Subject: [PATCH 0243/1774] freertos includes adapted

---
 osal/FreeRTOS/MessageQueue.cpp | 4 ++--
 osal/FreeRTOS/MessageQueue.h   | 4 ++--
 osal/FreeRTOS/Mutex.h          | 6 ++++--
 osal/FreeRTOS/TaskManagement.h | 4 ++--
 4 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index aa4b93b7e..aedf4831d 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -121,7 +121,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     BaseType_t result;
     if(callContext == CallContext::task) {
         result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
-                reinterpret_cast<const void*>(message->getBuffer()), 0);
+                static_cast<const void*>(message->getBuffer()), 0);
     }
     else {
         // If the call context is from an interrupt,
@@ -129,7 +129,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         // was blocked by the interrupt.
         BaseType_t xHigherPriorityTaskWoken = pdFALSE;
         result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
-                reinterpret_cast<const void*>(message->getBuffer()),
+                static_cast<const void*>(message->getBuffer()),
                 &xHigherPriorityTaskWoken);
         if(xHigherPriorityTaskWoken == pdTRUE) {
             TaskManagement::requestContextSwitch(callContext);
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index d8a307eab..ce6ed46b3 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -7,8 +7,8 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
 extern "C" {
-#include "FreeRTOS.h"
-#include "freertos/queue.h"
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
 }
 
 
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 604511b5d..ef93fd344 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -3,9 +3,11 @@
 
 #include <framework/ipc/MutexIF.h>
 
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+}
 
-#include <FreeRTOS.h>
-#include "semphr.h"
 
 /**
  * @brief OS component to implement MUTual EXclusion
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index da0cce2a8..eaaf97e22 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -4,8 +4,8 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
 extern "C" {
-#include "FreeRTOS.h"
-#include "task.h"
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
 }
 #include <cstdint>
 

From 684da2b8d5400ad68a59a59579bbb9244a1be5c3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 15:30:29 +0200
Subject: [PATCH 0244/1774] set application data function added

---
 tmtcpacket/SpacePacketBase.cpp  |  3 ++-
 tmtcpacket/pus/TcPacketBase.cpp | 13 ++++++++++---
 tmtcpacket/pus/TcPacketBase.h   |  9 ++++++++-
 3 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/tmtcpacket/SpacePacketBase.cpp b/tmtcpacket/SpacePacketBase.cpp
index 13c062d8f..a06c3a337 100644
--- a/tmtcpacket/SpacePacketBase.cpp
+++ b/tmtcpacket/SpacePacketBase.cpp
@@ -14,7 +14,8 @@ uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
 	return (this->data->header.packet_id_h & 0b11100000) >> 5;
 }
 
-void SpacePacketBase::initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
+void SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
+		bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
 	//reset header to zero:
 	memset(data,0, sizeof(this->data->header) );
 	//Set TC/TM bit.
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index d7f6636da..cdeef7f84 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -46,9 +46,16 @@ void TcPacketBase::setErrorControl() {
 	(&tcData->data)[size + 1] = (crc) & 0X00FF; 		// CRCL
 }
 
-void TcPacketBase::setData(const uint8_t* p_Data) {
-	SpacePacketBase::setData(p_Data);
-	tcData = (TcPacketPointer*) p_Data;
+void TcPacketBase::setData(const uint8_t* pData) {
+	SpacePacketBase::setData(pData);
+	tcData = (TcPacketPointer*) pData;
+}
+
+void TcPacketBase::setApplicationData(const uint8_t * pData, size_t dataLen) {
+	SpacePacketBase::setData(pData);
+	tcData = (TcPacketPointer*) pData;
+	SpacePacketBase::setPacketDataLength(dataLen +
+			sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE-1);
 }
 
 uint8_t TcPacketBase::getSecondaryHeaderFlag() {
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index d84d6c45c..a7e823fcd 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -2,6 +2,7 @@
 #define TCPACKETBASE_H_
 
 #include <framework/tmtcpacket/SpacePacketBase.h>
+#include <cstddef>
 
 /**
  * This struct defines a byte-wise structured PUS TC Data Field Header.
@@ -175,7 +176,13 @@ public:
 	 *
 	 * @param p_data	A pointer to another PUS Telecommand Packet.
 	 */
-	void setData( const uint8_t* p_data );
+	void setData( const uint8_t* pData );
+	/**
+	 * Set application data and corresponding length field.
+	 * @param pData
+	 * @param dataLen
+	 */
+	void setApplicationData(const uint8_t * pData, size_t dataLen);
 	/**
 	 * This is a debugging helper method that prints the whole packet content
 	 * to the screen.

From 237dd4a256598ed805442a71bef58a4ddc9aabb4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 18:23:57 +0200
Subject: [PATCH 0245/1774] added additonal functions for tc packet base

---
 tmtcpacket/pus/TcPacketBase.cpp | 5 +++++
 tmtcpacket/pus/TcPacketBase.h   | 9 ++++++++-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index cdeef7f84..54ad92bec 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -87,3 +87,8 @@ void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
 	tcData->data_field.service_type = service;
 	tcData->data_field.service_subtype = subservice;
 }
+
+size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
+	return sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) +
+			appDataLen + TcPacketBase::CRC_SIZE;
+}
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index a7e823fcd..69c64b87a 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -100,7 +100,8 @@ public:
 	 * @param service	PUS Service
 	 * @param subservice PUS Subservice
 	 */
-	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack, uint8_t service, uint8_t subservice);
+	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
+			uint8_t service, uint8_t subservice);
 	/**
 	 * This command returns the CCSDS Secondary Header Flag.
 	 * It shall always be zero for PUS Packets. This is the
@@ -188,6 +189,12 @@ public:
 	 * to the screen.
 	 */
 	void print();
+	/**
+	 * Calculate full packet length from application data length.
+	 * @param appDataLen
+	 * @return
+	 */
+	static size_t calculateFullPacketLength(size_t appDataLen);
 };
 
 

From 6e1bb16d4e22f5e4b0b3d9010a5662ffe7f1b16e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 18:46:58 +0200
Subject: [PATCH 0246/1774] printers continued,

possible  bugfix in tc packet base
---
 globalfunctions/printer.cpp     | 25 +++++++++++++++++++++++--
 globalfunctions/printer.h       | 12 +++++++++---
 tmtcpacket/pus/TcPacketBase.cpp |  2 +-
 3 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index d6ede0a5c..d7af30a54 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -1,13 +1,34 @@
 #include <framework/globalfunctions/printer.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-void printer::print(uint8_t *data, size_t size) {
+void printer::print(uint8_t *data, size_t size, OutputType type) {
 	sif::info << "StorageAccessor: Printing data: [";
+	if(type == OutputType::HEX) {
+		printer::printHex(data, size);
+	}
+	else {
+		printer::printDec(data, size);
+	}
+}
+
+void printer::printHex(uint8_t *data, size_t size) {
+	sif::info << std::hex;
 	for(size_t i = 0; i < size; i++) {
-		sif::info << std::hex << (int)data[i];
+		sif::info << "0x" << static_cast<int>(data[i]);
 		if(i < size - 1){
 			sif::info << " , ";
 		}
 	}
+	sif::info << std::dec;
 	sif::info << " ] " << std::endl;
 }
+
+void printer::printDec(uint8_t *data, size_t size) {
+	for(size_t i = 0; i < size; i++) {
+		sif::info << "0x" << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+		}
+	}
+}
+
diff --git a/globalfunctions/printer.h b/globalfunctions/printer.h
index d4a573e92..3c9d6aa08 100644
--- a/globalfunctions/printer.h
+++ b/globalfunctions/printer.h
@@ -4,9 +4,15 @@
 #include <cstddef>
 
 namespace printer {
-void print(uint8_t *data, size_t size);
+
+enum class OutputType {
+	DEC,
+	HEX
+};
+
+void print(uint8_t* data, size_t size, OutputType type = OutputType::HEX);
+void printHex(uint8_t* data, size_t size);
+void printDec(uint8_t* data, size_t size);
 }
 
-
-
 #endif /* FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_ */
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 54ad92bec..b98cf136c 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -79,7 +79,7 @@ void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
 		uint8_t ack, uint8_t service, uint8_t subservice) {
 	initSpacePacketHeader(true, true, apid, sequenceCount);
 	memset(&tcData->data_field, 0, sizeof(tcData->data_field));
-	setPacketDataLength(sizeof(tcData->data_field) + CRC_SIZE);
+	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
 	//Data Field Header:
 	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
 	tcData->data_field.version_type_ack = 0b00010000;

From 80cee2742964485910faa168cb9a1c96e2c0dec3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 18:53:54 +0200
Subject: [PATCH 0247/1774] printer fixes

---
 globalfunctions/printer.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index df98568e5..5af4346b3 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -20,15 +20,17 @@ void printer::printHex(uint8_t *data, size_t size) {
 		}
 	}
 	sif::info << std::dec;
-	sif::info << " ] " << std::endl;
+	sif::info << "]" << std::endl;
 }
 
 void printer::printDec(uint8_t *data, size_t size) {
+	sif::info << std::dec;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
 		if(i < size - 1){
 			sif::info << " , ";
 		}
 	}
+	sif::info << "]" << std::endl;
 }
 

From 24bfbfbd33e93d35dabd716d72d67eefc9512b11 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 18:56:06 +0200
Subject: [PATCH 0248/1774] removed StorageAccessoremoved StorageAccessorr

---
 globalfunctions/printer.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index 5af4346b3..bf4c5848b 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -2,7 +2,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 void printer::print(uint8_t *data, size_t size, OutputType type) {
-	sif::info << "StorageAccessor: Printing data with size " << size << ": [";
+	sif::info << "Printing data with size " << size << ": [";
 	if(type == OutputType::HEX) {
 		printer::printHex(data, size);
 	}

From 3f71babfa995965ef39299f5285ad5990efe6921 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 19:50:51 +0200
Subject: [PATCH 0249/1774] app data len uint16_t, full length size_t

---
 tmtcpacket/SpacePacketBase.cpp  | 2 +-
 tmtcpacket/SpacePacketBase.h    | 5 +++--
 tmtcpacket/pus/TcPacketBase.cpp | 2 +-
 tmtcpacket/pus/TcPacketBase.h   | 2 +-
 4 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/tmtcpacket/SpacePacketBase.cpp b/tmtcpacket/SpacePacketBase.cpp
index a06c3a337..b9ae06843 100644
--- a/tmtcpacket/SpacePacketBase.cpp
+++ b/tmtcpacket/SpacePacketBase.cpp
@@ -82,7 +82,7 @@ void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
 	this->data->header.packet_length_l = ( new_length & 0x00FF );
 }
 
-uint32_t SpacePacketBase::getFullSize() {
+size_t SpacePacketBase::getFullSize() {
 	//+1 is done because size in packet data length field is: size of data field -1
 	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
 }
diff --git a/tmtcpacket/SpacePacketBase.h b/tmtcpacket/SpacePacketBase.h
index cc68f714b..57a5df9c8 100644
--- a/tmtcpacket/SpacePacketBase.h
+++ b/tmtcpacket/SpacePacketBase.h
@@ -2,9 +2,10 @@
 #define SPACEPACKETBASE_H_
 
 #include <framework/tmtcpacket/ccsds_header.h>
+#include <cstddef>
 
 /**
- * \defgroup tmtcpackets Space Packets
+ * @defgroup tmtcpackets Space Packets
  * This is the group, where all classes associated with Telecommand and
  * Telemetry packets belong to.
  * The class hierarchy resembles the dependency between the different standards
@@ -167,7 +168,7 @@ public:
 	 * This method returns the full raw packet size.
 	 * @return	The full size of the packet in bytes.
 	 */
-	uint32_t getFullSize();
+	size_t getFullSize();
 
 	uint32_t getApidAndSequenceCount() const;
 
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index b98cf136c..4ef50c0d4 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -51,7 +51,7 @@ void TcPacketBase::setData(const uint8_t* pData) {
 	tcData = (TcPacketPointer*) pData;
 }
 
-void TcPacketBase::setApplicationData(const uint8_t * pData, size_t dataLen) {
+void TcPacketBase::setApplicationData(const uint8_t * pData, uint16_t dataLen) {
 	SpacePacketBase::setData(pData);
 	tcData = (TcPacketPointer*) pData;
 	SpacePacketBase::setPacketDataLength(dataLen +
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index 69c64b87a..c83428960 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -183,7 +183,7 @@ public:
 	 * @param pData
 	 * @param dataLen
 	 */
-	void setApplicationData(const uint8_t * pData, size_t dataLen);
+	void setApplicationData(const uint8_t * pData, uint16_t dataLen);
 	/**
 	 * This is a debugging helper method that prints the whole packet content
 	 * to the screen.

From c77ec9e7fcbe038a4622b3faf3cf311d6d3cc901 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 19:56:54 +0200
Subject: [PATCH 0250/1774] uint16_t correction

---
 tmtcpacket/pus/TcPacketBase.cpp | 2 +-
 tmtcpacket/pus/TcPacketBase.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 4ef50c0d4..f8dba79f2 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -28,7 +28,7 @@ const uint8_t* TcPacketBase::getApplicationData() const {
 	return &tcData->data;
 }
 
-size_t TcPacketBase::getApplicationDataSize() {
+uint16_t TcPacketBase::getApplicationDataSize() {
 	return getPacketDataLength() - sizeof(tcData->data_field) - CRC_SIZE + 1;
 }
 
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index c83428960..136aaa0b8 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -153,7 +153,7 @@ public:
 	 * @return	The size of the PUS Application Data (without Error Control
 	 * 		field)
 	 */
-	size_t getApplicationDataSize();
+	uint16_t getApplicationDataSize();
 	/**
 	 * This getter returns the Error Control Field of the packet.
 	 *

From 5b41f2a6bd4e91956874fff43774865d9887dab5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 19:58:58 +0200
Subject: [PATCH 0251/1774] optimization

---
 tmtcpacket/pus/TcPacketBase.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index f8dba79f2..3e2b34c23 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -52,8 +52,7 @@ void TcPacketBase::setData(const uint8_t* pData) {
 }
 
 void TcPacketBase::setApplicationData(const uint8_t * pData, uint16_t dataLen) {
-	SpacePacketBase::setData(pData);
-	tcData = (TcPacketPointer*) pData;
+	setData(pData);
 	SpacePacketBase::setPacketDataLength(dataLen +
 			sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE-1);
 }

From 0e2438416d0af245d086175868a5496c679b94ef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 20:00:43 +0200
Subject: [PATCH 0252/1774] added comment

---
 tmtcpacket/pus/TcPacketBase.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 3e2b34c23..0972ffff2 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -53,8 +53,9 @@ void TcPacketBase::setData(const uint8_t* pData) {
 
 void TcPacketBase::setApplicationData(const uint8_t * pData, uint16_t dataLen) {
 	setData(pData);
+	// packet data length is actual size of data field minus 1
 	SpacePacketBase::setPacketDataLength(dataLen +
-			sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE-1);
+			sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
 }
 
 uint8_t TcPacketBase::getSecondaryHeaderFlag() {

From ebcc4742a92c6aa2152aa7cc8953a587f05fec5b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 21:14:21 +0200
Subject: [PATCH 0253/1774] removed conflict markers

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 932bbe8aa..18ec1092f 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -57,10 +57,6 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-<<<<<<< HEAD
-=======
-
->>>>>>> mueller_framework
 	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
 		if(slotTimeMs == 0) {
 			// FreeRTOS throws a sanity error for zero values, so we set

From 20900227f8bc119befa7dcc2bd5ca3fea3d74e1b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 22:53:01 +0200
Subject: [PATCH 0254/1774] periodic posix task ctor format

---
 osal/linux/PeriodicPosixTask.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index b754c3f44..28a0b9461 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -3,9 +3,10 @@
 #include <errno.h>
 #include <framework/osal/linux/PeriodicPosixTask.h>
 
-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_) {
-
+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_) {
 }
 
 PeriodicPosixTask::~PeriodicPosixTask() {

From 7d579889792144e9cf45fdcc332bb3636c69f488 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 16 May 2020 13:09:50 +0200
Subject: [PATCH 0255/1774] added deadline check

---
 osal/FreeRTOS/PeriodicTask.cpp | 18 +++++++++++++++---
 osal/FreeRTOS/PeriodicTask.h   |  6 ++++--
 2 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 3075be791..a8e405613 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -1,6 +1,7 @@
+#include "PeriodicTask.h"
+
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/tasks/ExecutableObjectIF.h>
-#include "PeriodicTask.h"
 
 PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 		TaskStackSize setStack, TaskPeriod setPeriod,
@@ -31,7 +32,7 @@ void PeriodicTask::taskEntryPoint(void* argument) {
 	// if it is not set and we get here, the scheduler was started before #startTask() was called and we need to suspend
 	// if it is set, the scheduler was not running before #startTask() was called and we can continue
 
-	if (!originalTask->started) {
+	if (not originalTask->started) {
 		vTaskSuspend(NULL);
 	}
 
@@ -70,8 +71,19 @@ void PeriodicTask::taskFunctionality() {
 				it != objectList.end(); ++it) {
 			(*it)->performOperation();
 		}
-		//TODO deadline missed check
+
+		/* If all operations are finished and the difference of the
+		 * current time minus the last wake time is larger than the
+		 * wait period, a deadline was missed. */
+		if(xTaskGetTickCount() - xLastWakeTime >= xPeriod) {
+			sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+					" missed deadline!\n" << std::flush;
+			if(deadlineMissedFunc != nullptr) {
+				this->deadlineMissedFunc();
+			}
+		}
 		vTaskDelayUntil(&xLastWakeTime, xPeriod);
+
 	}
 }
 
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 02ab71482..4ece20b33 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -5,8 +5,10 @@
 #include <framework/tasks/PeriodicTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
-#include <FreeRTOS.h>
-#include "task.h"
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+}
 
 #include <vector>
 

From b673e13892cf7aac425569709a140dc4b589ec70 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 16 May 2020 20:58:48 +0200
Subject: [PATCH 0256/1774] some refactoring

---
 ipc/MessageQueueIF.h           |  24 ++++---
 ipc/MessageQueueMessage.cpp    |  28 ++++----
 ipc/MessageQueueMessage.h      | 126 +++++++++++++++++++--------------
 ipc/QueueFactory.h             |   6 +-
 osal/FreeRTOS/MessageQueue.cpp |  10 +--
 osal/FreeRTOS/QueueFactory.cpp |  16 +++--
 osal/linux/MessageQueue.cpp    |  12 ++--
 osal/linux/MessageQueue.h      |  32 +++++----
 osal/linux/QueueFactory.cpp    |  16 +++--
 9 files changed, 156 insertions(+), 114 deletions(-)

diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 47da694cd..c67f3870a 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -36,8 +36,8 @@ public:
 	 * 			lastParnter 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.
-	 * \return RETURN_OK if ok
-	 * \return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
+	 * @return RETURN_OK if ok
+	 * @return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
 	 */
 	virtual ReturnValue_t reply( MessageQueueMessage* message ) = 0;
 
@@ -53,10 +53,12 @@ public:
 
 	/**
 	 * @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.
+	 * @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 theblastPartner 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.
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::EMPTY if queue is empty
@@ -90,7 +92,9 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) = 0;
 
 	/**
 	 * @brief	This operation sends a message to the given destination.
@@ -100,7 +104,8 @@ public:
 	 * @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.
 	 */
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo, MessageQueueMessage* message, bool ignoreFault = false ) = 0;
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessage* message, bool ignoreFault = false ) = 0;
 
 	/**
 	 * @brief	The sendToDefaultFrom method sends a queue message to the default destination.
@@ -111,7 +116,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
 	/**
 	 * @brief	This operation sends a message to the default destination.
 	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index 30e0325cf..544d18e8d 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -8,6 +8,20 @@ MessageQueueMessage::MessageQueueMessage() :
 	memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
 }
 
+MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
+		messageSize(this->HEADER_SIZE + size) {
+	if (size <= this->MAX_DATA_SIZE) {
+		memcpy(this->getData(), data, size);
+		this->messageSize = this->HEADER_SIZE + size;
+	}
+	else {
+		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
+				"allowed size! Setting content to 0" << std::endl;
+		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
+		this->messageSize = this->HEADER_SIZE;
+	}
+}
+
 MessageQueueMessage::~MessageQueueMessage() {
 }
 
@@ -37,23 +51,13 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
 	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
 }
 
-MessageQueueMessage::MessageQueueMessage(uint8_t* data, uint32_t size) :
-		messageSize(this->HEADER_SIZE + size) {
-	if (size <= this->MAX_DATA_SIZE) {
-		memcpy(this->getData(), data, size);
-	} else {
-		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
-		this->messageSize = this->HEADER_SIZE;
-	}
-}
-
 size_t MessageQueueMessage::getMinimumMessageSize() {
 	return this->HEADER_SIZE;
 }
 
 void MessageQueueMessage::print() {
-	sif::debug << "MessageQueueMessage has size: " << this->messageSize << std::hex
-			<< std::endl;
+	sif::debug << "MessageQueueMessage has size: " << this->messageSize <<
+			std::hex << std::endl;
 	for (uint8_t count = 0; count < this->messageSize; count++) {
 		sif::debug << (uint32_t) this->internalBuffer[count] << ":";
 	}
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 8c4ec947b..4d82bd885 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -5,111 +5,129 @@
 #include <stddef.h>
 
 /**
- *	\brief		This class is the representation and data organizer for interprocess messages.
+ *	@brief		This class is the representation and data organizer
+ *				for interprocess messages.
  *
- *	\details	To facilitate and standardize interprocess communication, this class was created
- *				to handle a lightweight "interprocess message protocol". It adds a header with the
- *				sender's queue id to every sent message and defines the maximum total message size.
- *				Specialized messages, such as device commanding messages, can be created by inheriting
- *				from this class and filling the buffer provided by getData with additional content.
- *				If larger amounts of data must be sent between processes, the data shall be stored in
- *				the IPC Store object and only the storage id is passed in a queue message.
- *				The class is used both to generate and send messages and to receive messages from
- *				other tasks.
- *	\ingroup message_queue
+ *	@details
+ *	To facilitate and standardize interprocess communication, this class was
+ *	created to handle a lightweight "interprocess message protocol".
+ *
+ *	It adds a header with the sender's queue id to every sent message and
+ *	defines the maximum total message size. Specialized messages, such as
+ *	device commanding messages, can be created by inheriting from this class
+ *	and filling the buffer provided by getData with additional content.
+ *
+ *	If larger amounts of data must be sent between processes, the data shall
+ *	be stored in the IPC Store object and only the storage id is passed in a
+ *	queue message.The class is used both to generate and send messages and to
+ *	receive messages from other tasks.
+ *	@ingroup message_queue
  */
 class MessageQueueMessage {
 public:
 	/**
-	 * \brief	This constant defines the maximum size of the data content, excluding the header.
-	 * \details	It may be changed if necessary, but in general should be kept as small as possible.
+	 * @brief	The class is initialized empty with this constructor.
+	 * @details	The messageSize attribute is set to the header's size and the
+	 * 			whole content is set to zero.
+	 */
+	MessageQueueMessage();
+	/**
+	 * @brief	With this constructor the class is initialized with the given content.
+	 * @details
+	 * If the passed message size fits into the buffer, the passed data is
+	 * copied to the internal buffer and the messageSize information is set.
+	 * Otherwise, messageSize is set to the header's size and the whole
+	 * content is set to zero.
+	 * @param data	The data to be put in the message.
+	 * @param size	Size of the data to be copied. Must be smaller than
+	 * 				MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
+	 */
+	MessageQueueMessage(uint8_t* data, size_t size);
+	/**
+	 * @brief	The size information of each message is stored in this attribute.
+	 * @details
+	 * It is public to simplify usage and to allow for passing the size
+	 * address as a pointer. Care must be taken when inheriting from this class,
+	 * as every child class is responsible for managing the size information by
+	 * itself. When using the class to receive a message, the size information
+	 * is updated automatically.
+	 *
+	 * Please note that the minimum size is limited by the size of the header
+	 * while the maximum size is limited by the maximum allowed message size.
+	 */
+	size_t messageSize;
+	/**
+	 * @brief	This constant defines the maximum size of the data content, excluding the header.
+	 * @details	It may be changed if necessary, but in general should be kept as small as possible.
 	 */
 	static const size_t MAX_DATA_SIZE = 24;
 	/**
-	 * \brief	This constants defines the size of the header, which is added to every message.
+	 * @brief	This constants defines the size of the header, which is added to every message.
 	 */
 	static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);
 	/**
-	 * \brief	This constant defines the maximum total size in bytes of a sent message.
-	 * \details	It is the sum of the maximum data and the header size. Be aware that this constant
+	 * @brief	This constant defines the maximum total size in bytes of a sent message.
+	 * @details	It is the sum of the maximum data and the header size. Be aware that this constant
 	 * 			is used to define the buffer sizes for every message queue in the system. So, a change
 	 * 			here may have significant impact on the required resources.
 	 */
 	static const size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
+	/**
+	 * @brief Defines the minimum size of a message where only the
+	 * 		  header is included
+	 */
+	static const size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
 private:
 	/**
-	 * \brief	This is the internal buffer that contains the actual message data.
+	 * @brief	This is the internal buffer that contains the actual message data.
 	 */
 	uint8_t internalBuffer[MAX_MESSAGE_SIZE];
 public:
 	/**
-	 * \brief	The size information of each message is stored in this attribute.
-	 * \details	It is public to simplify usage and to allow for passing the variable's address as a
-	 * 			pointer. Care must be taken when inheriting from this class, as every child class is
-	 * 			responsible for managing the size information by itself. When using the class to
-	 * 			receive a message, the size information is updated automatically.
-	 */
-	size_t messageSize;
-	/**
-	 * \brief	The class is initialized empty with this constructor.
-	 * \details	The messageSize attribute is set to the header's size and the whole content is set to
-	 * 			zero.
-	 */
-	MessageQueueMessage();
-	/**
-	 * \brief	With this constructor the class is initialized with the given content.
-	 * \details	If the passed message size fits into the buffer, the passed data is copied to the
-	 * 			internal buffer and the messageSize information is set. Otherwise, messageSize
-	 * 			is set to the header's size and the whole content is set to zero.
-	 * \param data	The data to be put in the message.
-	 * \param size	Size of the data to be copied. Must be smaller than MAX_MESSAGE_SIZE.
-	 */
-	MessageQueueMessage(uint8_t* data, uint32_t size);
-	/**
-	 * \brief	As no memory is allocated in this class, the destructor is empty.
+	 * @brief	As no memory is allocated in this class, the destructor is empty.
 	 */
 	virtual ~MessageQueueMessage();
 	/**
-	 * \brief	This method is used to get the complete data of the message.
+	 * @brief	This method is used to get the complete data of the message.
 	 */
 	const uint8_t* getBuffer() const;
 	/**
-	 * \brief	This method is used to get the complete data of the message.
+	 * @brief	This method is used to get the complete data of the message.
 	 */
 	uint8_t* getBuffer();
 	/**
-	 * \brief	This method is used to fetch the data content of the message.
-	 * \details It shall be used by child classes to add data at the right position.
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details It shall be used by child classes to add data at the right position.
 	 */
 	const uint8_t* getData() const;
 	/**
-	 * \brief	This method is used to fetch the data content of the message.
-	 * \details It shall be used by child classes to add data at the right position.
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details It shall be used by child classes to add data at the right position.
 	 */
 	uint8_t* getData();
 	/**
-	 * \brief	This method is used to extract the sender's message queue id information from a
+	 * @brief	This method is used to extract the sender's message queue id information from a
 	 * 			received message.
 	 */
 	MessageQueueId_t getSender() const;
 	/**
-	 * \brief	With this method, the whole content and the message size is set to zero.
+	 * @brief	With this method, the whole content and the message size is set to zero.
 	 */
 	void clear();
 	/**
-	 * \brief	This is a debug method that prints the content (till messageSize) to the debug output.
+	 * @brief	This is a debug method that prints the content (till messageSize) to the debug output.
 	 */
 	void print();
 	/**
-	 * \brief	This method is used to set the sender's message queue id information prior to
+	 * @brief	This method is used to set the sender's message queue id information prior to
 	 * 			sending the message.
-	 * \param setId	The message queue id that identifies the sending message queue.
+	 * @param setId	The message queue id that identifies the sending message queue.
 	 */
 	void setSender(MessageQueueId_t setId);
 	/**
-	 * \brief	This helper function is used by the MessageQueue class to check the size of an
+	 * @brief	This helper function is used by the MessageQueue class to check the size of an
 	 * 			incoming message.
-	 * \details	The method must be overwritten by child classes if size checks shall be more strict.
+	 * @details	The method must be overwritten by child classes if size checks shall be more strict.
 	 * @return	The default implementation returns HEADER_SIZE.
 	 */
 	virtual size_t getMinimumMessageSize();
diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index c385b15df..9a883fd8a 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_IPC_QUEUEFACTORY_H_
 
 #include <framework/ipc/MessageQueueIF.h>
-#include <stdint.h>
+#include <cstdint>
 /**
  * Creates message queues.
  * This class is a "singleton" interface, i.e. it provides an
@@ -18,8 +18,8 @@ public:
 	 */
 	static QueueFactory* instance();
 
-	MessageQueueIF* createMessageQueue(uint32_t message_depth = 3,
-			uint32_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE);
+	MessageQueueIF* createMessageQueue(size_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
 
 	void deleteMessageQueue(MessageQueueIF* queue);
 private:
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index aedf4831d..38f425a4f 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -2,12 +2,14 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-// TODO I guess we should have a way of checking if we are in an ISR and then use the "fromISR" versions of all calls
-// As a first step towards this, introduces system context variable which needs to be switched manually
+// TODO I guess we should have a way of checking if we are in an ISR and then
+// use the "fromISR" versions of all calls
+// As a first step towards this, introduces system context variable which needs
+// to be switched manually
 // Haven't found function to find system context.
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) :
 defaultDestination(0),lastPartner(0), callContext(CallContext::task)  {
-	handle = xQueueCreate(message_depth, max_message_size);
+	handle = xQueueCreate(messageDepth, maxMessageSize);
 	if (handle == NULL) {
 		sif::error << "MessageQueue creation failed" << std::endl;
 	}
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index eaf245d37..a4ee5cf37 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -3,16 +3,18 @@
 #include <framework/osal/FreeRTOS/MessageQueue.h>
 
 
-QueueFactory* QueueFactory::factoryInstance = NULL;
+QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
 }
 
 QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == NULL) {
+	if (factoryInstance == nullptr) {
 		factoryInstance = new QueueFactory;
 	}
 	return factoryInstance;
@@ -24,9 +26,9 @@ QueueFactory::QueueFactory() {
 QueueFactory::~QueueFactory() {
 }
 
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t message_depth,
-		uint32_t max_message_size) {
-	return new MessageQueue(message_depth, max_message_size);
+MessageQueueIF* QueueFactory::createMessageQueue(size_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index edabe9467..96d9fb4d0 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -7,15 +7,15 @@
 #include <framework/osal/linux/MessageQueue.h>
 
 
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) :
 		id(0), lastPartner(0), defaultDestination(NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
 	this->id = 0;
 	//Set attributes
 	attributes.mq_curmsgs = 0;
-	attributes.mq_maxmsg = message_depth;
-	attributes.mq_msgsize = max_message_size;
+	attributes.mq_maxmsg = messageDepth;
+	attributes.mq_msgsize = maxMessageSize;
 	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
 	//Set the name of the queue
 	sprintf(name, "/Q%u\n", queueCounter++);
@@ -265,7 +265,11 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			           << strerror(errno) << " in mq_send" << std::endl;
 			/*NO BREAK*/
 		case EMSGSIZE:
-			//The msg_len is greater than the msgsize associated with the specified queue.
+			// The msg_len is greater than the msgsize associated with
+			//the specified queue.
+			sif::error << "MessageQueue::sendMessage: Size error [" <<
+					strerror(errno) << "] in mq_send" << std::endl;
+			/*NO BREAK*/
 		default:
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index b8285dc58..fdc8dab19 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -5,20 +5,23 @@
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MessageQueueMessage.h>
 /**
- *	@brief		This class manages sending and receiving of message queue messages.
+ * @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.
- *	\ingroup message_queue
+ * @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".
+ *
+ * The creation of message queues, as well as sending and receiving messages,
+ * makes use of the operating system calls provided.
+ *	@ingroup message_queue
  */
 class MessageQueue : public MessageQueueIF {
 	friend class MessageQueueSenderIF;
@@ -35,7 +38,8 @@ public:
 	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
 	 * 							This should be left default.
 	 */
-	MessageQueue( size_t message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	MessageQueue(size_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
 	/**
 	 * @brief	The destructor deletes the formerly created message queue.
 	 * @details	This is accomplished by using the delete call provided by the operating system.
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index fc4c90261..2bacb815f 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -5,16 +5,18 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <cstring>
 
-QueueFactory* QueueFactory::factoryInstance = NULL;
+QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
 }
 
 QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == NULL) {
+	if (factoryInstance == nullptr) {
 		factoryInstance = new QueueFactory;
 	}
 	return factoryInstance;
@@ -26,9 +28,9 @@ QueueFactory::QueueFactory() {
 QueueFactory::~QueueFactory() {
 }
 
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t message_depth,
-		uint32_t max_message_size) {
-	return new MessageQueue(message_depth, max_message_size);
+MessageQueueIF* QueueFactory::createMessageQueue(size_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {

From cbfa21d45a51bbe97d6d35a6b54ab8f409a8f2d1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 01:17:11 +0200
Subject: [PATCH 0257/1774] merging renaming into main branch

---
 datapool/ControllerSet.h                      |   4 +-
 datapool/DataPool.cpp                         | 132 ------
 datapool/DataPool.h                           | 136 ------
 datapool/DataSet.cpp                          | 150 ------
 datapool/DataSet.h                            | 168 -------
 datapool/DataSetIF.h                          |  39 +-
 datapool/HkSwitchHelper.cpp                   |   1 -
 datapool/PIDReader.h                          |   8 +-
 datapool/PoolEntry.cpp                        |   1 -
 datapool/PoolEntry.h                          |  46 +-
 datapool/PoolEntryIF.h                        |  61 ++-
 datapool/PoolRawAccess.cpp                    | 126 ++---
 datapool/PoolRawAccess.h                      | 172 +++----
 datapool/PoolRawAccessHelper.cpp              |   6 +-
 datapool/PoolRawAccessHelper.h                |   2 +-
 datapool/PoolVarList.h                        |   6 +-
 datapool/PoolVariableIF.h                     |  63 ++-
 {datapool => datapoolglob}/DataPoolAdmin.cpp  |  18 +-
 {datapool => datapoolglob}/DataPoolAdmin.h    |  15 +-
 .../DataPoolParameterWrapper.cpp              |  14 +-
 .../DataPoolParameterWrapper.h                |   0
 datapoolglob/GlobalDataPool.cpp               | 132 ++++++
 datapoolglob/GlobalDataPool.h                 | 146 ++++++
 datapoolglob/GlobalDataSet.cpp                | 166 +++++++
 datapoolglob/GlobalDataSet.h                  | 185 ++++++++
 datapoolglob/GlobalPoolVariable.h             | 189 ++++++++
 datapoolglob/GlobalPoolVariable.tpp           |  84 ++++
 datapoolglob/GlobalPoolVector.h               | 223 +++++++++
 datapoollocal/LocalDataSet.cpp                |  66 +++
 datapoollocal/LocalDataSet.h                  | 187 ++++++++
 datapoollocal/LocalPoolVariable.h             | 103 ++++
 datapoollocal/LocalPoolVariable.tpp           | 109 +++++
 devicehandlers/DeviceHandlerBase.cpp          | 189 ++++----
 devicehandlers/DeviceHandlerBase.h            | 439 +++++++++---------
 housekeeping/HasHkPoolParametersIF.h          |  32 ++
 housekeeping/HousekeepingManager.cpp          |  50 ++
 housekeeping/HousekeepingManager.h            |  95 ++++
 housekeeping/HousekeepingMessage.cpp          |  10 +
 housekeeping/HousekeepingMessage.h            |  87 ++++
 internalError/InternalErrorReporter.cpp       |  10 +-
 monitoring/MonitorBase.h                      |   4 +-
 power/Fuse.cpp                                |   2 +-
 power/Fuse.h                                  |   6 +-
 power/PowerSensor.h                           |   6 +-
 thermal/CoreComponent.cpp                     |  12 +-
 thermal/CoreComponent.h                       |  12 +-
 thermal/ThermalModule.h                       |   6 +-
 47 files changed, 2465 insertions(+), 1253 deletions(-)
 delete mode 100644 datapool/DataPool.cpp
 delete mode 100644 datapool/DataPool.h
 delete mode 100644 datapool/DataSet.cpp
 delete mode 100644 datapool/DataSet.h
 rename {datapool => datapoolglob}/DataPoolAdmin.cpp (96%)
 rename {datapool => datapoolglob}/DataPoolAdmin.h (90%)
 rename {datapool => datapoolglob}/DataPoolParameterWrapper.cpp (96%)
 rename {datapool => datapoolglob}/DataPoolParameterWrapper.h (100%)
 create mode 100644 datapoolglob/GlobalDataPool.cpp
 create mode 100644 datapoolglob/GlobalDataPool.h
 create mode 100644 datapoolglob/GlobalDataSet.cpp
 create mode 100644 datapoolglob/GlobalDataSet.h
 create mode 100644 datapoolglob/GlobalPoolVariable.h
 create mode 100644 datapoolglob/GlobalPoolVariable.tpp
 create mode 100644 datapoolglob/GlobalPoolVector.h
 create mode 100644 datapoollocal/LocalDataSet.cpp
 create mode 100644 datapoollocal/LocalDataSet.h
 create mode 100644 datapoollocal/LocalPoolVariable.h
 create mode 100644 datapoollocal/LocalPoolVariable.tpp
 create mode 100644 housekeeping/HasHkPoolParametersIF.h
 create mode 100644 housekeeping/HousekeepingManager.cpp
 create mode 100644 housekeeping/HousekeepingManager.h
 create mode 100644 housekeeping/HousekeepingMessage.cpp
 create mode 100644 housekeeping/HousekeepingMessage.h

diff --git a/datapool/ControllerSet.h b/datapool/ControllerSet.h
index de06bf918..7625c3d1b 100644
--- a/datapool/ControllerSet.h
+++ b/datapool/ControllerSet.h
@@ -1,9 +1,9 @@
 #ifndef CONTROLLERSET_H_
 #define CONTROLLERSET_H_
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 
-class ControllerSet :public DataSet {
+class ControllerSet :public GlobDataSet {
 public:
 	ControllerSet();
 	virtual ~ControllerSet();
diff --git a/datapool/DataPool.cpp b/datapool/DataPool.cpp
deleted file mode 100644
index c6a1a74e8..000000000
--- a/datapool/DataPool.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-#include <framework/datapool/DataPool.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/ipc/MutexFactory.h>
-
-DataPool::DataPool( void ( *initFunction )( std::map<uint32_t, PoolEntryIF*>* pool_map ) ) {
-	mutex = MutexFactory::instance()->createMutex();
-	if (initFunction != NULL ) {
-		initFunction( &this->data_pool );
-	}
-}
-
-DataPool::~DataPool() {
-	MutexFactory::instance()->deleteMutex(mutex);
-	for ( std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.begin(); it != this->data_pool.end(); ++it ) {
-		delete it->second;
-	}
-}
-
-//The function checks PID, type and array length before returning a copy of the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
-template <typename T> PoolEntry<T>* DataPool::getData( uint32_t data_pool_id,  uint8_t sizeOrPosition ) {
-	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
-	if ( it != this->data_pool.end() ) {
-		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
-		if (entry != NULL ) {
-			if ( sizeOrPosition <= entry->length ) {
-				return entry;
-			}
-		}
-	}
-	return NULL;
-}
-
-PoolEntryIF* DataPool::getRawData( uint32_t data_pool_id ) {
-	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
-	if ( it != this->data_pool.end() ) {
-		return it->second;
-	} else {
-		return NULL;
-	}
-}
-
-//uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t max_size ) {
-//	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
-//	if ( it != this->data_pool.end() ) {
-//		if ( it->second->getByteSize() <= max_size ) {
-//			*size = it->second->getByteSize();
-//			memcpy( address, it->second->getRawData(), *size );
-//			return DP_SUCCESSFUL;
-//		}
-//	}
-//	*size = 0;
-//	return DP_FAILURE;
-//}
-
-ReturnValue_t DataPool::freeDataPoolLock() {
-	ReturnValue_t status = mutex->unlockMutex();
-	if ( status != RETURN_OK ) {
-		sif::error << "DataPool::DataPool: unlock of mutex failed with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-ReturnValue_t DataPool::lockDataPool() {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::NO_TIMEOUT);
-	if ( status != RETURN_OK ) {
-		sif::error << "DataPool::DataPool: lock of mutex failed with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-void DataPool::print() {
-	sif::debug << "DataPool contains: " << std::endl;
-	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
-	dataPoolIt = this->data_pool.begin();
-	while( dataPoolIt != this->data_pool.end() ) {
-		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
-		dataPoolIt->second->print();
-		dataPoolIt++;
-	}
-}
-
-template PoolEntry<bool>* DataPool::getData<bool>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<uint8_t>* DataPool::getData<uint8_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<uint16_t>* DataPool::getData<uint16_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<uint32_t>* DataPool::getData<uint32_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<uint64_t>* DataPool::getData<uint64_t>(uint32_t data_pool_id,
-		uint8_t size);
-template PoolEntry<int8_t>* DataPool::getData<int8_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<int16_t>* DataPool::getData<int16_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<int32_t>* DataPool::getData<int32_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<float>* DataPool::getData<float>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<double>* DataPool::getData<double>(uint32_t data_pool_id,
-		uint8_t size);
-
-
-uint32_t DataPool::PIDToDataPoolId(uint32_t parameter_id) {
-	return (parameter_id >> 8) & 0x00FFFFFF;
-}
-
-uint8_t DataPool::PIDToArrayIndex(uint32_t parameter_id) {
-	return (parameter_id & 0x000000FF);
-}
-
-uint32_t DataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
-	return (poolId << 8) + index;
-}
-
-
-//SHOULDDO: Do we need a mutex lock here... I don't think so, as we only check static const values of elements in a list that do not change.
-//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
-ReturnValue_t DataPool::getType(uint32_t parameter_id, Type* type) {
-	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( PIDToDataPoolId(parameter_id));
-	if ( it != this->data_pool.end() ) {
-		*type = it->second->getType();
-		return RETURN_OK;
-	} else {
-		*type = Type::UNKNOWN_TYPE;
-		return RETURN_FAILED;
-	}
-}
-
-bool DataPool::exists(uint32_t parameterId) {
-	uint32_t poolId = PIDToDataPoolId(parameterId);
-	uint32_t index = PIDToArrayIndex(parameterId);
-	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( poolId );
-	if (it != data_pool.end()) {
-		if (it->second->getSize() >= index) {
-			return true;
-		}
-	}
-	return false;
-}
diff --git a/datapool/DataPool.h b/datapool/DataPool.h
deleted file mode 100644
index 857bc3b2c..000000000
--- a/datapool/DataPool.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/**
- *	\file	DataPool.h
- *
- *  \date	10/17/2012
- *	\author	Bastian Baetz
- *
- *	\brief	This file contains the definition of the DataPool class and (temporarily)
- *			the "extern" definition of the global dataPool instance.
- */
-
-#ifndef DATAPOOL_H_
-#define DATAPOOL_H_
-
-#include <framework/datapool/PoolEntry.h>
-#include <framework/globalfunctions/Type.h>
-#include <framework/ipc/MutexIF.h>
-#include <map>
-
-/**
- * \defgroup data_pool Data Pool
- * This is the group, where all classes associated with Data Pool Handling belong to.
- * This includes classes to access Data Pool variables.
- */
-
-#define DP_SUCCESSFUL	0
-#define DP_FAILURE		1
-
-/**
- *	\brief		This class represents the OBSW global data-pool.
- *
- *	\details	All variables are registered and space is allocated in an initialization
- *				function, which is passed to the constructor.
- *				Space for the variables is allocated on the heap (with a new call).
- *				The data is found by a data pool id, which uniquely represents a variable.
- *				Data pool variables should be used with a blackboard logic in mind,
- *				which means read data is valid (if flagged so), but not necessarily up-to-date.
- *				Variables are either single values or arrays.
- *	\ingroup data_pool
- */
-class DataPool : public HasReturnvaluesIF {
-private:
-	/**
-	 * \brief	This is the actual data pool itself.
-	 * \details	It is represented by a map
-	 * 			with the data pool id as index and a pointer to a single
-	 * 			PoolEntry as value.
-	 */
-	std::map<uint32_t, PoolEntryIF*> data_pool;
-public:
-	/**
-	 * \brief	The mutex is created in the constructor and makes access mutual exclusive.
-	 * \details	Locking and unlocking the pool is only done by the DataSet class.
-	 */
-	MutexIF*	mutex;
-	/**
-	 * \brief	In the classes constructor, the passed initialization function is called.
-	 * \details	To enable filling the pool,
-	 * 			a pointer to the map is passed, allowing direct access to the pool's content.
-	 * 			On runtime, adding or removing variables is forbidden.
-	 */
-	DataPool( void ( *initFunction )( std::map<uint32_t, PoolEntryIF*>* pool_map ) );
-	/**
-	 * 	\brief	The destructor iterates through the data_pool map and calls all Entries destructors to clean up the heap.
-	 */
-	~DataPool();
-	/**
-	 * \brief	This is the default call to access the pool.
-	 * \details	A pointer to the PoolEntry object is returned.
-	 *  		The call checks data pool id, type and array size. Returns NULL in case of failure.
-	 * \param data_pool_id	The data pool id to search.
-	 * \param sizeOrPosition The array size (not byte size!) of the pool entry, or the position the user wants to read.
-	 * 			If smaller than the entry size, everything's ok.
-	 */
-	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id, uint8_t sizeOrPosition );
-	/**
-	 * \brief	An alternative call to get a data pool entry in case the type is not implicitly known
-	 * 			(i.e. in Housekeeping Telemetry).
-	 * \details	It returns a basic interface and does NOT perform
-	 * 			a size check. The caller has to assure he does not copy too much data.
-	 * 			Returns NULL in case the entry is not found.
-	 * \param data_pool_id	The data pool id to search.
-	 */
-	PoolEntryIF* getRawData( uint32_t data_pool_id );
-	/**
-	 * \brief	This is a small helper function to facilitate locking the global data pool.
-	 * \details	It fetches the pool's mutex id and tries to acquire the mutex.
-	 */
-	ReturnValue_t lockDataPool();
-	/**
-	 * \brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * \details	It fetches the pool's mutex id and tries to free the mutex.
-	 */
-	ReturnValue_t freeDataPoolLock();
-	/**
-	 * \brief	The print call is a simple debug method.
-	 * \details	It prints the current content of the data pool.
-	 *  		It iterates through the data_pool map and calls each entry's print() method.
-	 */
-	void print();
-	/**
-	 * Extracts the data pool id from a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The data pool id as used within the OBSW.
-	 */
-	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
-	/**
-	 * Extracts an array index out of a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The index of the corresponding data pool entry.
-	 */
-	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
-	/**
-	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
-	 */
-	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
-
-	/**
-	 * Method to return the type of a pool variable.
-	 * @param parameter_id A parameterID (not pool id) of a DP member.
-	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
-	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
-	 */
-	ReturnValue_t getType( uint32_t parameter_id, Type* type );
-
-	/**
-	 * Method to check if a PID exists.
-	 * Does not lock, as there's no possibility to alter the list that is checked during run-time.
-	 * @param parameterId The PID (not pool id!) of a parameter.
-	 * @return	true if exists, false else.
-	 */
-	bool exists(uint32_t parameterId);
-};
-
-//We assume someone globally instantiates a DataPool.
-extern DataPool dataPool;
-#endif /* DATAPOOL_H_ */
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
deleted file mode 100644
index 303621189..000000000
--- a/datapool/DataSet.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-#include <framework/datapool/DataSet.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-DataSet::DataSet() :
-		fill_count(0), state(DATA_SET_UNINITIALISED) {
-	for (unsigned count = 0; count < DATA_SET_MAX_SIZE; count++) {
-		registeredVariables[count] = NULL;
-	}
-}
-
-DataSet::~DataSet() {
-	//Don't do anything with your variables, they are dead already! (Destructor is already called)
-}
-
-ReturnValue_t DataSet::read() {
-	ReturnValue_t result = RETURN_OK;
-	if (state == DATA_SET_UNINITIALISED) {
-		lockDataPool();
-		for (uint16_t count = 0; count < fill_count; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					!= PoolVariableIF::VAR_WRITE
-					&& registeredVariables[count]->getDataPoolId()
-							!= PoolVariableIF::NO_PARAMETER) {
-				ReturnValue_t status = registeredVariables[count]->read();
-				if (status != RETURN_OK) {
-					result = INVALID_PARAMETER_DEFINITION;
-					break;
-				}
-			}
-		}
-		state = DATA_SET_WAS_READ;
-		freeDataPoolLock();
-	} else {
-		sif::error << "DataSet::read(): Call made in wrong position." << std::endl;
-		result = SET_WAS_ALREADY_READ;
-	}
-	return result;
-}
-
-ReturnValue_t DataSet::commit(uint8_t valid) {
-	setValid(valid);
-	return commit();
-}
-
-ReturnValue_t DataSet::commit() {
-	if (state == DATA_SET_WAS_READ) {
-		lockDataPool();
-		for (uint16_t count = 0; count < fill_count; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					!= PoolVariableIF::VAR_READ
-					&& registeredVariables[count]->getDataPoolId()
-							!= PoolVariableIF::NO_PARAMETER) {
-				registeredVariables[count]->commit();
-			}
-		}
-		state = DATA_SET_UNINITIALISED;
-		freeDataPoolLock();
-		return RETURN_OK;
-	} else {
-		ReturnValue_t result = RETURN_OK;
-		lockDataPool();
-		for (uint16_t count = 0; count < fill_count; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					== PoolVariableIF::VAR_WRITE
-					&& registeredVariables[count]->getDataPoolId()
-							!= PoolVariableIF::NO_PARAMETER) {
-				registeredVariables[count]->commit();
-			} else if (registeredVariables[count]->getDataPoolId()
-					!= PoolVariableIF::NO_PARAMETER) {
-				if (result != COMMITING_WITHOUT_READING) {
-					sif::error <<
-					        "DataSet::commit(): commit-without-read "
-					        "call made with non write-only variable." << std::endl;
-					result = COMMITING_WITHOUT_READING;
-				}
-			}
-		}
-		state = DATA_SET_UNINITIALISED;
-		freeDataPoolLock();
-		return result;
-	}
-
-}
-
-void DataSet::registerVariable(PoolVariableIF* variable) {
-	if (state == DATA_SET_UNINITIALISED) {
-		if (variable != NULL) {
-			if (fill_count < DATA_SET_MAX_SIZE) {
-				registeredVariables[fill_count] = variable;
-				fill_count++;
-				return;
-			}
-		}
-	}
-	sif::error
-			<< "DataSet::registerVariable: failed. Either NULL, or set is full, or call made in wrong position."
-			<< std::endl;
-	return;
-}
-
-uint8_t DataSet::freeDataPoolLock() {
-	return ::dataPool.freeDataPoolLock();
-}
-
-uint8_t DataSet::lockDataPool() {
-	return ::dataPool.lockDataPool();
-}
-
-ReturnValue_t DataSet::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->serialize(buffer, size, max_size,
-				bigEndian);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-size_t DataSet::getSerializedSize() const {
-	size_t size = 0;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		size += registeredVariables[count]->getSerializedSize();
-	}
-	return size;
-}
-
-void DataSet::setValid(uint8_t valid) {
-	for (uint16_t count = 0; count < fill_count; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ) {
-			registeredVariables[count]->setValid(valid);
-		}
-	}
-}
-
-ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->deSerialize(buffer, size,
-				bigEndian);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
deleted file mode 100644
index 1e34e07c9..000000000
--- a/datapool/DataSet.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * \file	DataSet.h
- *
- * \brief	This file contains the DataSet class and a small structure called DataSetContent.
- *
- * \date	10/17/2012
- *
- * \author	Bastian Baetz
- *
- */
-
-#ifndef DATASET_H_
-#define DATASET_H_
-
-#include <framework/datapool/DataPool.h>
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolRawAccess.h>
-#include <framework/datapool/PoolVariable.h>
-#include <framework/datapool/PoolVarList.h>
-#include <framework/datapool/PoolVector.h>
-#include <framework/serialize/SerializeAdapter.h>
-/**
- * \brief	The DataSet class manages a set of locally checked out variables.
- *
- * \details	This class manages a list, where a set of local variables (or pool variables) are
- * 			registered. They are checked-out (i.e. their values are looked up and copied)
- * 			with the read call. After the user finishes working with the pool variables,
- * 			he can write back all variable values to the pool with the commit call.
- * 			The data set manages locking and freeing the data pool, to ensure that all values
- * 			are read and written back at once.
- * 			An internal state manages usage of this class. Variables may only be registered before
- * 			the read call is made, and the commit call only after the read call.
- * 			If pool variables are writable and not committed until destruction of the set, the
- * 			DataSet class automatically sets the valid flag in the data pool to invalid (without)
- * 			changing the variable's value.
- *
- *	\ingroup data_pool
- */
-class DataSet: public DataSetIF, public HasReturnvaluesIF, public SerializeIF {
-
-public:
-	//SHOULDDO we could use a linked list of datapool variables
-	static const uint8_t DATA_SET_MAX_SIZE = 63; //!< This definition sets the maximum number of variables to register in one DataSet.
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
-	static const ReturnValue_t INVALID_PARAMETER_DEFINITION =
-			MAKE_RETURN_CODE( 0x01 );
-	static const ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
-	static const ReturnValue_t COMMITING_WITHOUT_READING =
-			MAKE_RETURN_CODE(0x03);
-
-	/**
-	 * \brief	The constructor simply sets the fill_count to zero and sets the state to "uninitialized".
-	 */
-	DataSet();
-	/**
-	 * \brief	The destructor automatically manages writing the valid information of variables.
-	 * \details	In case the data set was read out, but not committed (indicated by state),
-	 * 			the destructor parses all variables that are still registered to the set.
-	 * 			For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~DataSet();
-	/**
-	 * \brief	The read call initializes reading out all registered variables.
-	 * \details	It iterates through the list of registered variables and calls all read()
-	 * 			functions of the registered pool variables (which read out their values from the
-	 * 			data pool) which are not write-only. In case of an error (e.g. a wrong data type,
-	 * 			or an invalid data pool id), the operation is aborted and
-	 * 			\c INVALID_PARAMETER_DEFINITION returned.
-	 * 			The data pool is locked during the whole read operation and freed afterwards.
-	 * 			The state changes to "was written" after this operation.
-	 * \return	- \c RETURN_OK if all variables were read successfully.
-	 * 			- \c INVALID_PARAMETER_DEFINITION if PID, size or type of the
-	 * 					requested variable is invalid.
-	 * 			- \c SET_WAS_ALREADY_READ if read() is called twice without calling
-	 * 					commit() in between
-	 */
-	ReturnValue_t read();
-	/**
-	 * \brief	The commit call initializes writing back the registered variables.
-	 * \details	It iterates through the list of registered variables and calls
-	 * 			the commit() method of the remaining registered variables (which write back
-	 * 			their values to the pool).
-	 * 			The data pool is locked during the whole commit operation and freed afterwards.
-	 * 			The state changes to "was committed" after this operation.
-	 * 			If the set does contain at least one variable which is not write-only commit()
-	 * 			can only be called after read(). If the set only contains variables which are
-	 * 			write only, commit() can be called without a preceding read() call.
-	 * \return	- \c RETURN_OK if all variables were read successfully.
-	 * 			- \c COMMITING_WITHOUT_READING if set was not read yet and contains non write-only
-	 * 				variables
-	 */
-	ReturnValue_t commit(void);
-	/**
-	 * Variant of method above which sets validity of all elements of the set.
-	 * @param valid Validity information from PoolVariableIF.
-	 * \return	- \c RETURN_OK if all variables were read successfully.
-	 * 			- \c COMMITING_WITHOUT_READING if set was not read yet and contains non write-only
-	 * 				variables
-	 */
-	ReturnValue_t commit(uint8_t valid);
-	/**
-	 * \brief	This operation is used to register the local variables in the set.
-	 * \details	It copies all required information to the currently
-	 * 			free space in the registeredVariables list.
-	 */
-	void registerVariable(PoolVariableIF* variable);
-
-	/**
-	 * Set the valid information of all variables contained in the set which are not readonly
-	 *
-	 * @param valid Validity information from PoolVariableIF.
-	 */
-	void setValid(uint8_t valid);
-
-	/**
-	 * Serialize all registered pool variables into the provided buffer
-	 * @param buffer
-	 * @param size Is incremented by serialized size
-	 * @param max_size
-	 * @param bigEndian
-	 * @return
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
-
-	virtual size_t getSerializedSize() const;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
-
-private:
-	/**
-	 * \brief	This array represents all pool variables registered in this set.
-	 * \details	It has a maximum size of DATA_SET_MAX_SIZE.
-	 */
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-	/**
-	 * \brief	The fill_count attribute ensures that the variables register in the correct array
-	 * 			position and that the maximum number of variables is not exceeded.
-	 */
-	uint16_t fill_count;
-	/**
-	 * States of the seet.
-	 */
-	enum States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
-	};
-	/**
-	 * \brief	state manages the internal state of the data set, which is important e.g. for the
-	 * 			behavior on destruction.
-	 */
-	States state;
-	/**
-	 * \brief	This is a small helper function to facilitate locking the global data pool.
-	 * \details	It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	uint8_t lockDataPool();
-	/**
-	 * \brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * \details	It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	uint8_t freeDataPoolLock();
-
-};
-
-#endif /* DATASET_H_ */
diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index 7741477db..4e3514160 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -1,39 +1,36 @@
-/**
- * \file	DataSetIF.h
- *
- * \brief	This file contains the small interface to access the DataSet class.
- *
- * \date	10/23/2012
- *
- * \author	Bastian Baetz
- *
- */
-
 #ifndef DATASETIF_H_
 #define DATASETIF_H_
 
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 class PoolVariableIF;
 
 /**
- * \brief	This class defines a small interface to register on a DataSet.
+ * @brief	This class defines a small interface to register on a DataSet.
  *
- * \details	Currently, the only purpose of this interface is to provide a method for locally
- * 			checked-out variables to register on a data set. Still, it may become useful for
- * 			other purposes as well.
- *
- *	\ingroup data_pool
+ * @details
+ * Currently, the only purpose of this interface is to provide a
+ * method for locally checked-out variables to register on a data set.
+ * Still, it may become useful for other purposes as well.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
  */
 class DataSetIF {
 public:
 	/**
-	 * \brief	This is an empty virtual destructor, as it is proposed for C++ interfaces.
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is proposed for C++ interfaces.
 	 */
 	virtual ~DataSetIF() {}
+
 	/**
-	 * \brief	This operation provides a method to register local data pool variables
-	 * 			to register in a data set by passing itself to this DataSet operation.
+	 * @brief	This operation provides a method to register local data pool
+	 * 			variables to register in a data set by passing itself
+	 * 			to this DataSet operation.
 	 */
-	virtual void registerVariable( PoolVariableIF* variable ) = 0;
+	virtual ReturnValue_t registerVariable( PoolVariableIF* variable ) = 0;
+
+	virtual ReturnValue_t lockDataPool() = 0;
+	virtual ReturnValue_t unlockDataPool() = 0;
 };
 
 #endif /* DATASETIF_H_ */
diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp
index caae21461..844fcd90e 100644
--- a/datapool/HkSwitchHelper.cpp
+++ b/datapool/HkSwitchHelper.cpp
@@ -1,5 +1,4 @@
 #include <framework/datapool/HkSwitchHelper.h>
-//#include <mission/tmtcservices/HKService_03.h>
 #include <framework/ipc/QueueFactory.h>
 
 HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index 5eb860268..3a815cee6 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -1,9 +1,9 @@
 #ifndef PIDREADER_H_
 #define PIDREADER_H_
-#include <framework/datapool/DataPool.h>
 #include <framework/datapool/DataSetIF.h>
 #include <framework/datapool/PoolEntry.h>
 #include <framework/datapool/PoolVariableIF.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/serialize/SerializeAdapter.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
@@ -16,9 +16,9 @@ protected:
 	uint32_t parameterId;
 	uint8_t valid;
 	ReturnValue_t read() {
-		uint8_t arrayIndex = DataPool::PIDToArrayIndex(parameterId);
+		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
 		PoolEntry<T>* read_out = ::dataPool.getData<T>(
-				DataPool::PIDToDataPoolId(parameterId), arrayIndex);
+				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
 		if (read_out != NULL) {
 			valid = read_out->valid;
 			value = read_out->address[arrayIndex];
@@ -88,7 +88,7 @@ public:
 	 * \brief	This operation returns the data pool id of the variable.
 	 */
 	uint32_t getDataPoolId() const {
-		return DataPool::PIDToDataPoolId(parameterId);
+		return GlobalDataPool::PIDToDataPoolId(parameterId);
 	}
 	uint32_t getParameterId() const {
 		return parameterId;
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index e38af7751..d07c516da 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -71,7 +71,6 @@ Type PoolEntry<T>::getType() {
 	return PodTypeConversion<T>::type;
 }
 
-template class PoolEntry<bool>;
 template class PoolEntry<uint8_t>;
 template class PoolEntry<uint16_t>;
 template class PoolEntry<uint32_t>;
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index a02c6c60d..4971ee455 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -6,34 +6,46 @@
 #include <stddef.h>
 #include <cstring>
 #include <initializer_list>
+#include <type_traits>
 /**
- * \brief		This is a small helper class that defines a single data pool entry.
- *
- * \details		The helper is used to store all information together with the data as a single data pool entry.
- * 				The content's type is defined by the template argument.
- * 				It is prepared for use with plain old data types,
- * 				but may be extended to complex types if necessary.
- * 				It can be initialized with a certain value, size and validity flag.
- * 				It holds a pointer to the real data and offers methods to access this data and to acquire
- * 				additional information (such as validity and array/byte size).
- * 				It is NOT intended to be used outside the DataPool class.
- *
- *	\ingroup data_pool
+ * @brief	This is a small helper class that defines a single data pool entry.
+ * @details
+ * The helper is used to store all information together with the data as a
+ * single data pool entry.The content's type is defined by the template argument.
+ * It is prepared for use with plain old data types, but may be extended to
+ * complex types if necessary. It can be initialized with a certain value,
+ * size and validity flag. It holds a pointer to the real data and offers
+ * methods to access this data and to acquire additional information
+ * (such as validity and array/byte size). It is NOT intended to be used
+ * outside the DataPool class.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
  *
  */
 template <typename T>
 class PoolEntry : public PoolEntryIF {
 public:
+	static_assert(not std::is_same<T, bool>::value,
+			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
+			"Warum? Darum :-)");
 	/**
-	 * \brief	In the classe's constructor, space is allocated on the heap and
+	 * @brief	In the classe's constructor, space is allocated on the heap and
 	 * 			potential init values are copied to that space.
-	 * \param initValue		A pointer to the single value or array that holds the init value.
-	 * 						With the default value (NULL), the entry is initalized with all 0.
-	 * \param set_length	Defines the array length of this entry.
-	 * \param set_valid		Sets the initialization flag. It is invalid (0) by default.
+	 * @param initValue	Initializer list with values to initialize with
+	 * @param set_length	Defines the array length of this entry.
+	 * @param set_valid		Sets the initialization flag. It is invalid (0) by default.
 	 */
 	PoolEntry( std::initializer_list<T> initValue = {}, uint8_t set_length = 1, uint8_t set_valid = 0 );
+	/**
+	 * @brief	In the classe's constructor, space is allocated on the heap and
+	 * 			potential init values are copied to that space.
+	 * @param initValue		A pointer to the single value or array that holds the init value.
+	 * 						With the default value (NULL), the entry is initalized with all 0.
+	 * @param set_length	Defines the array length of this entry.
+	 * @param set_valid		Sets the initialization flag. It is invalid (0) by default.
+	 */
 	PoolEntry( T* initValue = NULL, uint8_t set_length = 1, uint8_t set_valid = 0 );
+
 	/**
 	 * \brief	The allocated memory for the variable is freed in the destructor.
 	 * \details	As the data pool is global, this dtor is only called on program exit.
diff --git a/datapool/PoolEntryIF.h b/datapool/PoolEntryIF.h
index 514e67ef9..d24d553ae 100644
--- a/datapool/PoolEntryIF.h
+++ b/datapool/PoolEntryIF.h
@@ -1,66 +1,63 @@
-/**
- * \file	PoolEntryIF.h
- *
- * \brief	This file holds the class that defines the Interface for Pool Entry elements.
- *
- * \date	10/18/2012
- *
- * \author	Bastian Baetz
- */
-
 #ifndef POOLENTRYIF_H_
 #define POOLENTRYIF_H_
 
 #include <framework/globalfunctions/Type.h>
-#include <stdint.h>
-
-
+#include <cstdint>
 
 /**
- * \brief	This interface defines the access possibilities to a single data pool entry.
- *
- * \details	The interface provides methods to determine the size and the validity information of a value.
- * 			It also defines a method to receive a pointer to the raw data content.
- * 			It is mainly used by DataPool itself, but also as a return pointer.
- *
- *	\ingroup data_pool
- *
+ * @brief	This interface defines the access possibilities to a
+ * 			single data pool entry.
+ * @details
+ * The interface provides methods to determine the size and the validity
+ * information of a value. It also defines a method to receive a pointer to
+ * the raw data content. It is mainly used by DataPool itself, but also as a
+ * return pointer.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
  */
 class PoolEntryIF {
 public:
 	/**
-	 * \brief	This is an empty virtual destructor, as it is proposed for C++ interfaces.
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is proposed for C++ interfaces.
 	 */
-	virtual ~PoolEntryIF() {
-	}
+	virtual ~PoolEntryIF() {}
+
 	/**
-	 * \brief	getSize returns the array size of the entry. A single variable parameter has size 1.
+	 * @brief	getSize returns the array size of the entry.
+	 * 			A single variable parameter has size 1.
 	 */
 	virtual uint8_t getSize() = 0;
+
 	/**
-	 * \brief	This operation returns the size in bytes, which is calculated by
+	 * @brief	This operation returns the size in bytes, which is calculated by
 	 * 			sizeof(type) * array_size.
 	 */
 	virtual uint16_t getByteSize() = 0;
+
 	/**
-	 * \brief	This operation returns a the address pointer casted to void*.
+	 * @brief	This operation returns a the address pointer casted to void*.
 	 */
 	virtual void* getRawData() = 0;
+
 	/**
-	 * \brief	This method allows to set the valid information of the pool entry.
+	 * @brief	This method allows to set the valid information of the pool entry.
 	 */
 	virtual void setValid(uint8_t isValid) = 0;
+
 	/**
-	 * \brief	This method allows to set the valid information of the pool entry.
+	 * @brief	This method allows to set the valid information of the pool entry.
 	 */
 	virtual uint8_t getValid() = 0;
+
 	/**
-	 * \brief	This is a debug method that prints all values and the valid information to the screen.
-	 * 			It prints all array entries in a row.
+	 * @brief	This is a debug method that prints all values and the valid
+	 * 			information to the screen. It prints all array entries in a row.
 	 */
 	virtual void print() = 0;
+
 	/**
-	 * Returns the type of the entry.
+	 * @brief 	Returns the type of the entry.
 	 */
 	virtual Type getType() = 0;
 };
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 592f663f7..97bdc2b39 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -1,6 +1,6 @@
-#include <framework/datapool/DataPool.h>
 #include <framework/datapool/PoolEntryIF.h>
 #include <framework/datapool/PoolRawAccess.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
 
@@ -14,63 +14,41 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 	}
 }
 
-PoolRawAccess::~PoolRawAccess() {}
+PoolRawAccess::~PoolRawAccess() {
+
+}
 
 ReturnValue_t PoolRawAccess::read() {
-	ReturnValue_t result = RETURN_FAILED;
 	PoolEntryIF* read_out = ::dataPool.getRawData(dataPoolId);
 	if (read_out != NULL) {
-		result = handleReadOut(read_out);
-		if(result == RETURN_OK) {
-			return result;
-		}
-	} else {
-		result = READ_ENTRY_NON_EXISTENT;
-	}
-	handleReadError(result);
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* read_out) {
-	ReturnValue_t result = RETURN_FAILED;
-	valid = read_out->getValid();
-	if (read_out->getSize() > arrayEntry) {
-		arraySize = read_out->getSize();
-		typeSize = read_out->getByteSize() / read_out->getSize();
-		type = read_out->getType();
-		if (typeSize <= sizeof(value)) {
-			uint16_t arrayPosition = arrayEntry * typeSize;
-			sizeTillEnd = read_out->getByteSize() - arrayPosition;
-			uint8_t* ptr = &((uint8_t*) read_out->getRawData())[arrayPosition];
-			memcpy(value, ptr, typeSize);
-			return RETURN_OK;
+		valid = read_out->getValid();
+		if (read_out->getSize() > arrayEntry) {
+			arraySize = read_out->getSize();
+			typeSize = read_out->getByteSize() / read_out->getSize();
+			type = read_out->getType();
+			if (typeSize <= sizeof(value)) {
+				uint16_t arrayPosition = arrayEntry * typeSize;
+				sizeTillEnd = read_out->getByteSize() - arrayPosition;
+				uint8_t* ptr =
+						&((uint8_t*) read_out->getRawData())[arrayPosition];
+				memcpy(value, ptr, typeSize);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				//Error value type too large.
+			}
 		} else {
-			result = READ_TYPE_TOO_LARGE;
+			//Error index requested too large
 		}
 	} else {
-		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
-		result = READ_INDEX_TOO_LARGE;
+		//Error entry does not exist.
 	}
-	return result;
-}
-
-void PoolRawAccess::handleReadError(ReturnValue_t result) {
 	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed, ";
-	if(result == READ_TYPE_TOO_LARGE) {
-		sif::error << "type too large." << std::endl;
-	}
-	else if(result == READ_INDEX_TOO_LARGE) {
-		sif::error << "index too large." << std::endl;
-	}
-	else if(result == READ_ENTRY_NON_EXISTENT) {
-		sif::error << "entry does not exist." << std::endl;
-	}
-
+			<< std::dec << " failed." << std::endl;
 	valid = INVALID;
 	typeSize = 0;
 	sizeTillEnd = 0;
 	memset(value, 0, sizeof(value));
+	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t PoolRawAccess::commit() {
@@ -111,32 +89,6 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
-	if (typeSize + *size <= max_size) {
-		if (bigEndian) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for (uint8_t count = 0; count < typeSize; count++) {
-				(*buffer)[count] = value[typeSize - count - 1];
-			}
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(*buffer, value, typeSize);
-#endif
-		} else {
-			memcpy(*buffer, value, typeSize);
-		}
-		*size += typeSize;
-		(*buffer) += typeSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SerializeIF::BUFFER_TOO_SHORT;
-	}
-}
-
-
 Type PoolRawAccess::getType() {
 	return type;
 }
@@ -193,6 +145,29 @@ uint16_t PoolRawAccess::getSizeTillEnd() const {
 	return sizeTillEnd;
 }
 
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
+	if (typeSize + *size <= max_size) {
+		if (bigEndian) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+			for (uint8_t count = 0; count < typeSize; count++) {
+				(*buffer)[count] = value[typeSize - count - 1];
+			}
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			memcpy(*buffer, value, typeSize);
+#endif
+		} else {
+			memcpy(*buffer, value, typeSize);
+		}
+		*size += typeSize;
+		(*buffer) += typeSize;
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SerializeIF::BUFFER_TOO_SHORT;
+	}
+}
 
 size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
@@ -200,9 +175,8 @@ size_t PoolRawAccess::getSerializedSize() const {
 
 ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
-	// TODO: Needs to be tested!!!
 	if (*size >= typeSize) {
-		*size -= typeSize;
+
 		if (bigEndian) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
@@ -213,14 +187,12 @@ ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 			memcpy(value, *buffer, typeSize);
 #endif
-		}
-		else {
+		} else {
 			memcpy(value, *buffer, typeSize);
 		}
 		*buffer += typeSize;
 		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
+	} else {
 		return SerializeIF::STREAM_TOO_SHORT;
 	}
 }
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index b491d949a..f32aac51a 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -6,54 +6,83 @@
 #include <framework/globalfunctions/Type.h>
 
 /**
- * @brief This class allows accessing Data Pool variables as raw bytes.
- * @details
+ * This class allows accessing Data Pool variables as raw bytes.
  * This is necessary to have an access method for HK data, as the PID's alone do not
- * provide a type information. Please note that the the raw pool access read() and commit()
- * calls are not thread-safe.
- * Please supply a data set and use the data set read(), commit() calls for thread-safe
- * data pool access.
- * @ingroup data_pool
+ * provide a type information.
+ *	\ingroup data_pool
  */
-class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
+class PoolRawAccess: public PoolVariableIF {
+private:
+	/**
+	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * 			is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * \brief	The array entry that is fetched from the data pool.
+	 */
+	uint8_t arrayEntry;
+	/**
+	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 *  \brief	This value contains the type of the data pool entry.
+	 */
+	Type type;
+	/**
+	 * \brief	This value contains the size of the data pool entry in bytes.
+	 */
+	uint8_t typeSize;
+	/**
+	 * The size of the DP array (single values return 1)
+	 */
+	uint8_t arraySize;
+	/**
+	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
+	 */
+	uint16_t sizeTillEnd;
+	/**
+	 * \brief	The information whether the class is read-write or read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+	static const uint8_t RAW_MAX_SIZE = sizeof(double);
+protected:
+	/**
+	 * \brief	This is a call to read the value from the global data pool.
+	 * \details	When executed, this operation tries to fetch the pool entry with matching
+	 * 			data pool id from the global data pool and copies the value and the valid
+	 * 			information to its local attributes. In case of a failure (wrong type or
+	 * 			pool id not found), the variable is set to zero and invalid.
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 */
+	ReturnValue_t read();
+	/**
+	 * \brief	The commit call writes back the variable's value to the data pool.
+	 * \details	It checks type and size, as well as if the variable is writable. If so,
+	 * 			the value is copied and the valid flag is automatically set to "valid".
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 *
+	 */
+	ReturnValue_t commit();
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
 	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 	uint8_t value[RAW_MAX_SIZE];
-
-	/**
-	 * This constructor is used to access a data pool entry with a
-	 * given ID if the target type is not known. A DataSet object is supplied
-	 * and the data pool entry with the given ID is registered to that data set.
-	 * Please note that a pool raw access buffer only has a buffer
-	 * with a size of double. As such, for vector entries which have
-	 * @param data_pool_id Target data pool entry ID
-	 * @param arrayEntry
-	 * @param data_set Dataset to register data pool entry to
-	 * @param setReadWriteMode
-	 * @param registerVectors If set to true, the constructor checks if
-	 *                        there are multiple vector entries to registers
-	 *                        and registers all of them recursively into the data_set
-	 *
-	 */
 	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
 			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-			PoolVariableIF::VAR_READ);
+					PoolVariableIF::VAR_READ);
 	/**
 	 * \brief	The classes destructor is empty. If commit() was not called, the local value is
 	 * 			discarded and not written back to the data pool.
 	 */
 	~PoolRawAccess();
-
 	/**
 	 * \brief	This operation returns a pointer to the entry fetched.
-	 * \details	Return pointer to the buffer containing the raw data
-	 *          Size and number of data can be retrieved by other means.
+	 * \details	This means, it does not return a pointer to byte "index", but to the start byte of
+	 * 			array entry "index". Example: If the original data pool array consists of an double
+	 * 			array of size four, getEntry(1) returns &(this->value[8]).
 	 */
 	uint8_t* getEntry();
 	/**
@@ -71,19 +100,6 @@ public:
 	 */
 	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
 			uint32_t max_size);
-
-	/**
-	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @param buffer Provided buffer. Raw pool data will be copied here
-	 * @param size [out] Increment provided size value by serialized size
-	 * @param max_size Maximum allowed serialization size
-	 * @param bigEndian Specify endianess
-	 * @return - @c RETURN_OK if serialization was successfull
-	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
-
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
 	 * @param buffer	Pointer to the data to set
@@ -125,73 +141,13 @@ public:
 	 */
 	uint16_t getSizeTillEnd() const;
 
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
+
 	size_t getSerializedSize() const;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
-
-protected:
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself !
-	 * 			If reading from the data pool without information about the type is desired,
-	 * 			initialize the raw pool access by supplying a data set and using the data set
-	 * 			read function, which calls this read function.
-	 * @return -@c RETURN_OK Read successfull
-	 * 		   -@c READ_TYPE_TOO_LARGE
-	 * 		   -@c READ_INDEX_TOO_LARGE
-	 * 		   -@c READ_ENTRY_NON_EXISTENT
-	 */
-	ReturnValue_t read();
-	/**
-	 * \brief	The commit call writes back the variable's value to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit();
-
-	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
-	void handleReadError(ReturnValue_t result);
-private:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The array entry that is fetched from the data pool.
-	 */
-	uint8_t arrayEntry;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 *  \brief	This value contains the type of the data pool entry.
-	 */
-	Type type;
-	/**
-	 * \brief	This value contains the size of the data pool entry type in bytes.
-	 */
-	uint8_t typeSize;
-	/**
-	 * The size of the DP array (single values return 1)
-	 */
-	uint8_t arraySize;
-	/**
-	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
-	 */
-	uint16_t sizeTillEnd;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
 };
 
 #endif /* POOLRAWACCESS_H_ */
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 91d6309f4..cf02b20a8 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -9,7 +9,7 @@
 
 #include <cmath>
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 
 PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
 		uint8_t  numberOfParameters_):
@@ -97,7 +97,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 	//      << std::hex <<  currentPoolId << std::endl;
 	while(not poolEntrySerialized) {
 
-		if(counter > DataSet::DATA_SET_MAX_SIZE) {
+		if(counter > GlobDataSet::DATA_SET_MAX_SIZE) {
 			sif::error << "PoolRawAccessHelper: Config error, "
 					 "max. number of possible data set variables exceeded"
 				  << std::endl;
@@ -105,7 +105,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 		}
 		counter ++;
 
-		DataSet currentDataSet = DataSet();
+		GlobDataSet currentDataSet;
 		//debug << "Current array position: " << (int)arrayPosition << std::endl;
 		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,
 				&currentDataSet,PoolVariableIF::VAR_READ);
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 61d79731a..ab881a5f2 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -8,7 +8,7 @@
 #define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 
 /**
  * @brief 	This helper function simplifies accessing data pool entries
diff --git a/datapool/PoolVarList.h b/datapool/PoolVarList.h
index 90c9f1785..9d6bc461a 100644
--- a/datapool/PoolVarList.h
+++ b/datapool/PoolVarList.h
@@ -1,12 +1,12 @@
 #ifndef POOLVARLIST_H_
 #define POOLVARLIST_H_
 
-#include <framework/datapool/PoolVariable.h>
 #include <framework/datapool/PoolVariableIF.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 template <class T, uint8_t n_var>
 class PoolVarList {
 private:
-	PoolVariable<T> variables[n_var];
+	GlobPoolVar<T> variables[n_var];
 public:
 	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
 		//I really should have a look at the new init list c++ syntax.
@@ -20,7 +20,7 @@ public:
 		}
 	}
 
-	PoolVariable<T> &operator [](int i) { return variables[i]; }
+	GlobPoolVar<T> &operator [](int i) { return variables[i]; }
 };
 
 
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 7626c9c17..9935ef75c 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -1,71 +1,70 @@
-/*
- * \file	PoolVariableIF.h
- *
- * \brief	This file contains the interface definition for pool variables.
- *
- * \date	10/17/2012
- *
- * \author	Bastian Baetz
- */
-
 #ifndef POOLVARIABLEIF_H_
 #define POOLVARIABLEIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serialize/SerializeIF.h>
 
+
 /**
- * \brief	This interface is used to control local data pool variable representations.
- *
- * \details	To securely handle data pool variables, all pool entries are locally managed by
- * 			data pool variable access classes, which are called pool variables. To ensure a
- * 			common state of a set of variables needed in a function, these local pool variables
- * 			again are managed by other classes, e.g. the DataSet. This interface provides unified
- * 			access to local pool variables for such manager classes.
- *	\ingroup data_pool
+ * @brief	This interface is used to control data pool variable representations.
+ * @details
+ * To securely handle data pool variables, all pool entries are locally
+ * managed by data pool variable access classes, which are called pool
+ * variables. To ensure a common state of a set of variables needed in a
+ * function, these local pool variables again are managed by other classes,
+ * like the DataSet classes. This interface provides unified access to
+ * local pool variables for such manager classes.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
  */
 class PoolVariableIF : public SerializeIF {
-	friend class DataSet;
+	friend class GlobDataSet;
+	friend class LocalDataSet;
 protected:
 	/**
-	 * \brief	The commit call shall write back a newly calculated local value to the data pool.
+	 * @brief	The commit call shall write back a newly calculated local
+	 * 			value to the data pool.
 	 */
 	virtual ReturnValue_t commit() = 0;
 	/**
-	 * \brief	The read call shall read the value of this parameter from the data pool and store
-	 * 			the content locally.
+	 * @brief	The read call shall read the value of this parameter from
+	 * 			the data pool and store the content locally.
 	 */
 	virtual ReturnValue_t read() = 0;
 public:
-	static const uint8_t VALID = 1;
-	static const uint8_t INVALID = 0;
-	static const uint32_t NO_PARAMETER = 0;
+	static constexpr bool VALID = 1;
+	static constexpr bool INVALID = 0;
+	static constexpr uint32_t NO_PARAMETER = 0;
+
 	enum ReadWriteMode_t {
 		VAR_READ, VAR_WRITE, VAR_READ_WRITE
 	};
 
 	/**
-	 * \brief	This is an empty virtual destructor, as it is proposed for C++ interfaces.
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is proposed for C++ interfaces.
 	 */
-	virtual ~PoolVariableIF() {
-	}
+	virtual ~PoolVariableIF() {}
 	/**
-	 * \brief	This method returns if the variable is write-only, read-write or read-only.
+	 * @brief	This method returns if the variable is write-only, read-write or read-only.
 	 */
 	virtual ReadWriteMode_t getReadWriteMode() const = 0;
 	/**
-	 * \brief	This operation shall return the data pool id of the variable.
+	 * @brief	This operation shall return the data pool id of the variable.
 	 */
 	virtual uint32_t getDataPoolId() const = 0;
 	/**
-	 * \brief	With this call, the valid information of the variable is returned.
+	 * @brief	With this call, the valid information of the variable is returned.
 	 */
 	virtual bool isValid() const = 0;
 	/**
-	 * \brief	With this call, the valid information of the variable is set.
+	 * @brief	With this call, the valid information of the variable is set.
 	 */
+	// why not just use a boolean here?
 	virtual void setValid(uint8_t validity) = 0;
 
 };
 
+using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
+
 #endif /* POOLVARIABLEIF_H_ */
diff --git a/datapool/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
similarity index 96%
rename from datapool/DataPoolAdmin.cpp
rename to datapoolglob/DataPoolAdmin.cpp
index 250137265..59bd9f308 100644
--- a/datapool/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,7 +1,5 @@
-#include <framework/datapool/DataPool.h>
-#include <framework/datapool/DataPoolAdmin.h>
-#include <framework/datapool/DataSet.h>
-#include <framework/datapool/PoolRawAccess.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/DataPoolAdmin.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/parameters/ParameterMessage.h>
@@ -26,7 +24,7 @@ MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
 }
 
 ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
 	if (actionId != SET_VALIDITY) {
 		return INVALID_ACTION_ID;
 	}
@@ -42,7 +40,7 @@ ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
 
 	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
 
-	DataSet mySet;
+	GlobDataSet mySet;
 	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
 	ReturnValue_t status = mySet.read();
 	if (status != RETURN_OK) {
@@ -94,7 +92,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 		const uint8_t* data, uint32_t size, uint8_t** dataPointer) {
 	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
 	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
-	DataSet testSet;
+	GlobDataSet testSet;
 	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
 			PoolVariableIF::VAR_READ);
 	ReturnValue_t status = testSet.read();
@@ -113,7 +111,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 	const uint8_t* readPosition = data;
 
 	for (; size > 0; size -= typeSize) {
-		DataSet rawSet;
+		GlobDataSet rawSet;
 		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
 				PoolVariableIF::VAR_READ_WRITE);
 		status = rawSet.read();
@@ -133,7 +131,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
 		uint8_t** dataPointer, uint8_t* copyHere) {
 	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
 	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
-	DataSet testSet;
+	GlobDataSet testSet;
 	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
 			PoolVariableIF::VAR_READ);
 	ReturnValue_t status = testSet.read();
@@ -146,7 +144,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
 	}
 	uint8_t* ptrToCopy = copyHere;
 	for (; size > 0; size -= typeSize) {
-		DataSet rawSet;
+		GlobDataSet rawSet;
 		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
 				PoolVariableIF::VAR_READ);
 		status = rawSet.read();
diff --git a/datapool/DataPoolAdmin.h b/datapoolglob/DataPoolAdmin.h
similarity index 90%
rename from datapool/DataPoolAdmin.h
rename to datapoolglob/DataPoolAdmin.h
index dffcd4625..5f995893b 100644
--- a/datapool/DataPoolAdmin.h
+++ b/datapoolglob/DataPoolAdmin.h
@@ -1,15 +1,16 @@
 #ifndef DATAPOOLADMIN_H_
 #define DATAPOOLADMIN_H_
 
-#include <framework/memory/MemoryHelper.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/action/SimpleActionHelper.h>
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/parameters/ReceivesParameterMessagesIF.h>
-#include <framework/datapool/DataPoolParameterWrapper.h>
+#include <framework/action/HasActionsIF.h>
 #include <framework/ipc/MessageQueueIF.h>
+#include <framework/parameters/ReceivesParameterMessagesIF.h>
+
+#include <framework/memory/MemoryHelper.h>
+#include <framework/action/SimpleActionHelper.h>
+#include <framework/datapoolglob/DataPoolParameterWrapper.h>
 
 class DataPoolAdmin: public HasActionsIF,
 		public ExecutableObjectIF,
@@ -33,8 +34,8 @@ public:
 	ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size,
 			uint8_t** dataPointer, uint8_t* copyHere);
 
-	virtual ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
+	ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
 
 	//not implemented as ParameterHelper is no used
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapoolglob/DataPoolParameterWrapper.cpp
similarity index 96%
rename from datapool/DataPoolParameterWrapper.cpp
rename to datapoolglob/DataPoolParameterWrapper.cpp
index 11399fb6e..d93cd88e5 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapoolglob/DataPoolParameterWrapper.cpp
@@ -1,10 +1,8 @@
-#include "DataPoolParameterWrapper.h"
-
-//for returncodes
+#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/DataPoolParameterWrapper.h>
+#include <framework/datapool/PoolRawAccess.h>
 #include <framework/parameters/HasParametersIF.h>
 
-#include <framework/datapool/DataSet.h>
-#include <framework/datapool/PoolRawAccess.h>
 
 DataPoolParameterWrapper::DataPoolParameterWrapper() :
 		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
@@ -20,7 +18,7 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 		uint16_t parameterId) {
 	poolId = (domainId << 16) + parameterId;
 
-	DataSet mySet;
+	GlobDataSet mySet;
 	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
 	ReturnValue_t status = mySet.read();
 	if (status != HasReturnvaluesIF::RETURN_OK) {
@@ -57,7 +55,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 	}
 
 	for (uint8_t index = 0; index < rows; index++){
-		DataSet mySet;
+		GlobDataSet mySet;
 		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
 		mySet.read();
 		result = raw.serialize(buffer,size,max_size,bigEndian);
@@ -94,7 +92,7 @@ ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
 
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
-		DataSet mySet;
+		GlobDataSet mySet;
 		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
 				PoolVariableIF::VAR_READ_WRITE);
 		mySet.read();
diff --git a/datapool/DataPoolParameterWrapper.h b/datapoolglob/DataPoolParameterWrapper.h
similarity index 100%
rename from datapool/DataPoolParameterWrapper.h
rename to datapoolglob/DataPoolParameterWrapper.h
diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
new file mode 100644
index 000000000..e13765baa
--- /dev/null
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -0,0 +1,132 @@
+#include <framework/datapoolglob/GlobalDataPool.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/ipc/MutexFactory.h>
+
+GlobalDataPool::GlobalDataPool(
+		void(*initFunction)(GlobPoolMap* pool_map)) {
+	mutex = MutexFactory::instance()->createMutex();
+	if (initFunction != NULL ) {
+		initFunction( &this->globDataPool );
+	}
+}
+
+GlobalDataPool::~GlobalDataPool() {
+	MutexFactory::instance()->deleteMutex(mutex);
+	for(GlobPoolMapIter it = this->globDataPool.begin();
+	    it != this->globDataPool.end(); ++it )
+	{
+		delete it->second;
+	}
+}
+
+// The function checks PID, type and array length before returning a copy of
+// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
+template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
+		uint8_t sizeOrPosition ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
+		if (entry != nullptr ) {
+			if ( sizeOrPosition <= entry->length ) {
+				return entry;
+			}
+		}
+	}
+	return nullptr;
+}
+
+PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		return it->second;
+	} else {
+		return nullptr;
+	}
+}
+
+ReturnValue_t GlobalDataPool::freeDataPoolLock() {
+	ReturnValue_t status = mutex->unlockMutex();
+	if ( status != RETURN_OK ) {
+		sif::error << "DataPool::DataPool: unlock of mutex failed with"
+				" error code: " << status << std::endl;
+	}
+	return status;
+}
+
+ReturnValue_t GlobalDataPool::lockDataPool() {
+	ReturnValue_t status = mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	if ( status != RETURN_OK ) {
+		sif::error << "DataPool::DataPool: lock of mutex failed "
+				"with error code: " << status << std::endl;
+	}
+	return status;
+}
+
+void GlobalDataPool::print() {
+	sif::debug << "DataPool contains: " << std::endl;
+	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
+	dataPoolIt = this->globDataPool.begin();
+	while( dataPoolIt != this->globDataPool.end() ) {
+		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
+		dataPoolIt->second->print();
+		dataPoolIt++;
+	}
+}
+
+uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
+	return (parameter_id >> 8) & 0x00FFFFFF;
+}
+
+uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
+	return (parameter_id & 0x000000FF);
+}
+
+uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
+	return (poolId << 8) + index;
+}
+
+
+//SHOULDDO: Do we need a mutex lock here... I don't think so,
+//as we only check static const values of elements in a list that do not change.
+//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
+ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
+	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
+	if ( it != this->globDataPool.end() ) {
+		*type = it->second->getType();
+		return RETURN_OK;
+	} else {
+		*type = Type::UNKNOWN_TYPE;
+		return RETURN_FAILED;
+	}
+}
+
+bool GlobalDataPool::exists(uint32_t parameterId) {
+	uint32_t poolId = PIDToDataPoolId(parameterId);
+	uint32_t index = PIDToArrayIndex(parameterId);
+	GlobPoolMapIter it = this->globDataPool.find( poolId );
+	if (it != globDataPool.end()) {
+		if (it->second->getSize() >= index) {
+			return true;
+		}
+	}
+	return false;
+}
+
+template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
+		uint32_t data_pool_id, uint8_t size);
+template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<float>* GlobalDataPool::getData<float>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<double>* GlobalDataPool::getData<double>(
+		uint32_t data_pool_id, uint8_t size);
diff --git a/datapoolglob/GlobalDataPool.h b/datapoolglob/GlobalDataPool.h
new file mode 100644
index 000000000..e0c086adc
--- /dev/null
+++ b/datapoolglob/GlobalDataPool.h
@@ -0,0 +1,146 @@
+#ifndef GLOBALDATAPOOL_H_
+#define GLOBALDATAPOOL_H_
+
+#include <framework/datapool/PoolEntry.h>
+#include <framework/globalfunctions/Type.h>
+#include <framework/ipc/MutexIF.h>
+#include <map>
+
+/**
+ * @defgroup data_pool Global data pool
+ * This is the group, where all classes associated with global
+ * data pool handling belong to.
+ * This includes classes to access Data Pool variables.
+ */
+
+/**
+ * Typedefs for the global pool representations
+ */
+using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
+using GlobPoolMapIter = GlobPoolMap::iterator;
+
+/**
+ * @brief		This class represents the OBSW global data-pool.
+ *
+ * @details
+ * All variables are registered and space is allocated in an initialization
+ * function, which is passed do the constructor. Space for the variables is
+ * allocated on the heap (with a new call).
+ *
+ * The data is found by a data pool id, which uniquely represents a variable.
+ * Data pool variables should be used with a blackboard logic in mind,
+ * which means read data is valid (if flagged so),
+ * but not necessarily up-to-date.
+ *
+ * Variables are either single values or arrays.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class GlobalDataPool : public HasReturnvaluesIF {
+private:
+	/**
+	 * @brief	This is the actual data pool itself.
+	 * @details	It is represented by a map with the data pool id as index
+	 * 			and a pointer to a single PoolEntry as value.
+	 */
+	GlobPoolMap globDataPool;
+
+	/**
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking the pool is only done by the DataSet class.
+	 */
+	MutexIF*	mutex;
+public:
+	/**
+	 * @brief	In the classes constructor,
+	 * 			the passed initialization function is called.
+	 * @details
+	 * To enable filling the pool, a pointer to the map is passed,
+	 * allowing direct access to the pool's content.
+	 * On runtime, adding or removing variables is forbidden.
+	 */
+	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
+
+	/**
+	 * 	@brief	The destructor iterates through the data_pool map and
+	 * 			calls all entries destructors to clean up the heap.
+	 */
+	~GlobalDataPool();
+
+	/**
+	 * @brief	This is the default call to access the pool.
+	 * @details
+	 * A pointer to the PoolEntry object is returned.
+	 * The call checks data pool id, type and array size.
+	 * Returns NULL in case of failure.
+	 * @param data_pool_id	The data pool id to search.
+	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
+	 * or the position the user wants to read.
+	 * 			If smaller than the entry size, everything's ok.
+	 */
+	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
+			uint8_t sizeOrPosition );
+
+	/**
+	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
+	 * 			(i.e. in Housekeeping Telemetry).
+	 * @details	It returns a basic interface and does NOT perform
+	 * 			a size check. The caller has to assure he does not copy too much data.
+	 * 			Returns NULL in case the entry is not found.
+	 * @param data_pool_id	The data pool id to search.
+	 */
+	PoolEntryIF* getRawData( uint32_t data_pool_id );
+	/**
+	 * @brief	This is a small helper function to facilitate locking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
+	 */
+	ReturnValue_t lockDataPool();
+	/**
+	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to free the mutex.
+	 */
+	ReturnValue_t freeDataPoolLock();
+	/**
+	 * @brief	The print call is a simple debug method.
+	 * @details	It prints the current content of the data pool.
+	 *  		It iterates through the data_pool map and calls each entry's print() method.
+	 */
+	void print();
+	/**
+	 * Extracts the data pool id from a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The data pool id as used within the OBSW.
+	 */
+	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
+	/**
+	 * Extracts an array index out of a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The index of the corresponding data pool entry.
+	 */
+	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
+	/**
+	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
+	 */
+	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
+
+	/**
+	 * Method to return the type of a pool variable.
+	 * @param parameter_id A parameterID (not pool id) of a DP member.
+	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
+	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
+	 */
+	ReturnValue_t getType( uint32_t parameter_id, Type* type );
+
+	/**
+	 * Method to check if a PID exists. Does not lock, as there's no
+	 * possibility to alter the list that is checked during run-time.
+	 * @param parameterId The PID (not pool id!) of a parameter.
+	 * @return	true if exists, false else.
+	 */
+	bool exists(uint32_t parameterId);
+};
+
+//We assume someone globally instantiates a DataPool.
+extern GlobalDataPool dataPool;
+#endif /* DATAPOOL_H_ */
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
new file mode 100644
index 000000000..7409dbbdc
--- /dev/null
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -0,0 +1,166 @@
+#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+GlobDataSet::GlobDataSet() :
+		fill_count(0), state(DATA_SET_UNINITIALISED) {
+	for (unsigned count = 0; count < DATA_SET_MAX_SIZE; count++) {
+		registeredVariables[count] = nullptr;
+	}
+}
+
+GlobDataSet::~GlobDataSet() {
+	//Don't do anything with your variables, they are dead already!
+	// (Destructor is already called)
+}
+
+ReturnValue_t GlobDataSet::registerVariable(PoolVariableIF* variable) {
+	if (state != DATA_SET_UNINITIALISED) {
+		sif::error << "DataSet::registerVariable: Call made in wrong position." << std::endl;
+		return DATA_SET_UNINITIALISED;
+	}
+	if (variable == nullptr) {
+		sif::error << "DataSet::registerVariable: Pool variable is nullptr." << std::endl;
+		return POOL_VAR_NULL;
+	}
+	if (fill_count >= DATA_SET_MAX_SIZE) {
+		sif::error << "DataSet::registerVariable: DataSet is full." << std::endl;
+		return DATA_SET_FULL;
+	}
+	registeredVariables[fill_count] = variable;
+	fill_count++;
+	return RETURN_OK;
+}
+
+ReturnValue_t GlobDataSet::read() {
+	ReturnValue_t result = RETURN_OK;
+	if (state == DATA_SET_UNINITIALISED) {
+		lockDataPool();
+		for (uint16_t count = 0; count < fill_count; count++) {
+			if (registeredVariables[count]->getReadWriteMode()
+					!= PoolVariableIF::VAR_WRITE
+					&& registeredVariables[count]->getDataPoolId()
+							!= PoolVariableIF::NO_PARAMETER) {
+				ReturnValue_t status = registeredVariables[count]->read();
+				if (status != RETURN_OK) {
+					result = INVALID_PARAMETER_DEFINITION;
+					break;
+				}
+			}
+		}
+		state = DATA_SET_WAS_READ;
+		unlockDataPool();
+	} else {
+		sif::error << "DataSet::read(): Call made in wrong position." << std::endl;
+		result = SET_WAS_ALREADY_READ;
+	}
+	return result;
+}
+
+ReturnValue_t GlobDataSet::commit(bool valid) {
+	setEntriesValid(valid);
+	setSetValid(valid);
+	return commit();
+}
+
+ReturnValue_t GlobDataSet::commit() {
+	if (state == DATA_SET_WAS_READ) {
+		handleAlreadyReadDatasetCommit();
+		return RETURN_OK;
+	}
+	else {
+		return handleUnreadDatasetCommit();
+	}
+}
+
+void GlobDataSet::handleAlreadyReadDatasetCommit() {
+	lockDataPool();
+	for (uint16_t count = 0; count < fill_count; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				!= PoolVariableIF::VAR_READ
+				&& registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			registeredVariables[count]->commit();
+		}
+	}
+	state = DATA_SET_UNINITIALISED;
+	unlockDataPool();
+}
+
+ReturnValue_t GlobDataSet::handleUnreadDatasetCommit() {
+	ReturnValue_t result = RETURN_OK;
+	lockDataPool();
+	for (uint16_t count = 0; count < fill_count; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				== PoolVariableIF::VAR_WRITE
+				&& registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			registeredVariables[count]->commit();
+		} else if (registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			if (result != COMMITING_WITHOUT_READING) {
+				sif::error << "DataSet::commit(): commit-without-read call made "
+						"with non write-only variable." << std::endl;
+				result = COMMITING_WITHOUT_READING;
+			}
+		}
+	}
+	state = DATA_SET_UNINITIALISED;
+	unlockDataPool();
+	return result;
+}
+
+ReturnValue_t GlobDataSet::unlockDataPool() {
+	return ::dataPool.freeDataPoolLock();
+}
+
+ReturnValue_t GlobDataSet::lockDataPool() {
+	return ::dataPool.lockDataPool();
+}
+
+ReturnValue_t GlobDataSet::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
+	ReturnValue_t result = RETURN_FAILED;
+	for (uint16_t count = 0; count < fill_count; count++) {
+		result = registeredVariables[count]->serialize(buffer, size, max_size,
+				bigEndian);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+size_t GlobDataSet::getSerializedSize() const {
+	uint32_t size = 0;
+	for (uint16_t count = 0; count < fill_count; count++) {
+		size += registeredVariables[count]->getSerializedSize();
+	}
+	return size;
+}
+
+void GlobDataSet::setEntriesValid(bool valid) {
+	for (uint16_t count = 0; count < fill_count; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				!= PoolVariableIF::VAR_READ) {
+			registeredVariables[count]->setValid(valid);
+		}
+	}
+}
+
+void GlobDataSet::setSetValid(bool valid) {
+	this->valid = valid;
+}
+
+ReturnValue_t GlobDataSet::deSerialize(const uint8_t** buffer, size_t* size,
+		bool bigEndian) {
+	ReturnValue_t result = RETURN_FAILED;
+	for (uint16_t count = 0; count < fill_count; count++) {
+		result = registeredVariables[count]->deSerialize(buffer, size,
+				bigEndian);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
new file mode 100644
index 000000000..365de3801
--- /dev/null
+++ b/datapoolglob/GlobalDataSet.h
@@ -0,0 +1,185 @@
+#ifndef DATASET_H_
+#define DATASET_H_
+
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolRawAccess.h>
+#include <framework/datapool/PoolVarList.h>
+
+#include <framework/serialize/SerializeAdapter.h>
+/**
+ * @brief	The DataSet class manages a set of locally checked out variables
+ * 			for the global data pool.
+ *
+ * @details
+ * This class manages a list, where a set of local variables (or pool variables)
+ * are registered. They are checked-out (i.e. their values are looked
+ * up and copied) with the read call. After the user finishes working with the
+ * pool variables, he can write back all variable values to the pool with
+ * the commit call. The data set manages locking and freeing the data pool,
+ * to ensure that all values are read and written back at once.
+ *
+ * An internal state manages usage of this class. Variables may only be
+ * registered before the read call is made, and the commit call only
+ * after the read call.
+ *
+ * If pool variables are writable and not committed until destruction
+ * of the set, the DataSet class automatically sets the valid flag in the
+ * data pool to invalid (without) changing the variable's value.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class GlobDataSet: public DataSetIF, public HasReturnvaluesIF, public SerializeIF {
+public:
+	//SHOULDDO we could use a linked list of datapool variables
+	//!< This definition sets the maximum number of variables to
+	//! register in one DataSet.
+	static const uint8_t DATA_SET_MAX_SIZE = 63;
+
+
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
+	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION =
+			MAKE_RETURN_CODE( 0x01 );
+	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
+	static constexpr ReturnValue_t COMMITING_WITHOUT_READING =
+			MAKE_RETURN_CODE(0x03);
+
+	static constexpr ReturnValue_t DATA_SET_UNINITIALIZED = MAKE_RETURN_CODE( 0x04 );
+	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE( 0x05 );
+	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE( 0x06 );
+	/**
+	 * @brief	The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
+	 */
+	GlobDataSet();
+
+	/**
+	 * @brief	This operation is used to register the local variables in the set.
+	 * @details	It stores the pool variable pointer in a variable list.
+	 */
+	ReturnValue_t registerVariable(PoolVariableIF* variable) override;
+
+	/**
+	 * @brief	The destructor automatically manages writing the valid
+	 * 			information of variables.
+	 * @details
+	 * In case the data set was read out, but not committed(indicated by state),
+	 * the destructor parses all variables that are still registered to the set.
+	 * For each, the valid flag in the data pool is set to "invalid".
+	 */
+	~GlobDataSet();
+	/**
+	 * @brief	The read call initializes reading out all registered variables.
+	 * @details
+	 * It iterates through the list of registered variables and calls all read()
+	 * functions of the registered pool variables (which read out their values
+	 * from the data pool) which are not write-only.
+	 * In case of an error (e.g. a wrong data type, or an invalid data pool id),
+	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
+	 *
+	 * The data pool is locked during the whole read operation and
+	 * freed afterwards.The state changes to "was written" after this operation.
+	 * @return	- @c RETURN_OK if all variables were read successfully.
+	 * 			- @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
+	 * 					requested variable is invalid.
+	 * 			- @c SET_WAS_ALREADY_READ if read() is called twice without calling
+	 * 					commit() in between
+	 */
+	ReturnValue_t read();
+	/**
+	 * @brief	The commit call initializes writing back the registered variables.
+	 * @details
+	 * It iterates through the list of registered variables and calls the
+	 * commit() method of the remaining registered variables (which write back
+	 * their values to the pool).
+	 *
+	 * The data pool is locked during the whole commit operation and
+	 * freed afterwards. The state changes to "was committed" after this operation.
+	 *
+	 * If the set does contain at least one variable which is not write-only commit()
+	 * can only be called after read(). If the set only contains variables which are
+	 * write only, commit() can be called without a preceding read() call.
+	 * @return	- @c RETURN_OK if all variables were read successfully.
+	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
+	 * 			  contains non write-only variables
+	 */
+	ReturnValue_t commit(void);
+	/**
+	 * Variant of method above which sets validity of all elements of the set.
+	 * @param valid Validity information from PoolVariableIF.
+	 * @return	- @c RETURN_OK if all variables were read successfully.
+	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
+	 * 			     contains non write-only variables
+	 */
+	ReturnValue_t commit(bool valid);
+
+	/**
+	 * Set all entries
+	 * @param valid
+	 */
+	void setSetValid(bool valid);
+
+	/**
+	 * Set the valid information of all variables contained in the set which
+	 * are not read-only
+	 *
+	 * @param valid Validity information from PoolVariableIF.
+	 */
+	void setEntriesValid(bool valid);
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override;
+
+	size_t getSerializedSize() const override;
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override;
+private:
+
+	/**
+	 * @brief	This array represents all pool variables registered in this set.
+	 */
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
+	/**
+	 * \brief	The fill_count attribute ensures that the variables register in the correct array
+	 * 			position and that the maximum number of variables is not exceeded.
+	 */
+	uint16_t fill_count;
+	/**
+	 * States of the seet.
+	 */
+	enum States {
+		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
+		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
+	};
+	/**
+	 * @brief	state manages the internal state of the data set,
+	 *          which is important e.g. for the behavior on destruction.
+	 */
+	States state;
+
+	/**
+	 * If the valid state of a dataset is always relevant to the whole
+	 * data set we can use this flag.
+	 */
+	bool valid = false;
+	/**
+	 * @brief	This is a small helper function to facilitate locking
+	 * 			the underlying data data pool structure
+	 * @details
+	 * It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	ReturnValue_t lockDataPool() override;
+
+	/**
+	 * @brief	This is a small helper function to facilitate
+	 * 			unlocking the underlying data data pool structure
+	 * @details
+	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	ReturnValue_t unlockDataPool() override;
+
+	void handleAlreadyReadDatasetCommit();
+	ReturnValue_t handleUnreadDatasetCommit();
+};
+
+#endif /* DATASET_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
new file mode 100644
index 000000000..9f80492be
--- /dev/null
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -0,0 +1,189 @@
+#ifndef POOLVARIABLE_H_
+#define POOLVARIABLE_H_
+
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolVariableIF.h>
+#include <framework/datapool/PoolEntry.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+template<typename T, uint8_t n_var> class PoolVarList;
+
+
+/**
+ * @brief	This is the access class for non-array data pool entries.
+ *
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly
+ * on the data pool entries, but on local copies. This class provides simple
+ * type-safe access to single data pool entries (i.e. entries with length = 1).
+ * The class can be instantiated as read-write and read only.
+ * It provides a commit-and-roll-back semantic, which means that the
+ * variable's value in the data pool is not changed until the
+ * commit call is executed.
+ * 	@tparam	T The template parameter sets the type of the variable.
+ * 	Currently, all plain data types are supported, but in principle
+ * 	any type is possible.
+ *	@ingroup data_pool
+ */
+template<typename T>
+class GlobPoolVar: public PoolVariableIF {
+	template<typename U, uint8_t n_var> friend class PoolVarList;
+	static_assert(not std::is_same<T, bool>::value,
+			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
+			"Warum? Darum :-)");
+public:
+	/**
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if nullptr is not passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but
+	 * sets the value attribute to default (0).
+	 * The value is fetched within the read() operation.
+	 * @param set_id	This is the id in the global data pool
+	 * 					this instance of the access class corresponds to.
+	 * @param dataSet	The data set in which the variable shall register
+	 * 					itself. If NULL, the variable is not registered.
+	 * @param setWritable If this flag is set to true, changes in the value
+	 * 			attribute can be written back to the data pool, otherwise not.
+	 */
+	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
+			ReadWriteMode_t setReadWriteMode);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a simple local variable.
+	 */
+	T value = 0;
+
+	/**
+	 * @brief 	Copy ctor to copy classes containing Pool Variables.
+	 * 			(Robin): This only copies member variables, which is done
+	 * 			by the default copy ctor. maybe we can ommit this ctor?
+	 */
+	GlobPoolVar(const GlobPoolVar& rhs);
+
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVar() {}
+
+protected:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool is stored.
+	 */
+	uint32_t dataPoolId;
+
+	/**
+	 * @brief	The valid information as it was stored in the data pool is
+	 * 			copied to this attribute.
+	 */
+	uint8_t valid;
+
+	/**
+	 * @brief	The information whether the class is read-write or read-only
+	 * 			is stored here.
+	 */
+	pool_rwm_t readWriteMode;
+
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 */
+	ReturnValue_t read() override;
+
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details	It checks type and size, as well as if the variable is writable. If so,
+	 * 			the value is copied and the valid flag is automatically set to "valid".
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 *
+	 */
+	ReturnValue_t commit() override;
+
+	/**
+	 * Empty ctor for List initialization
+	 */
+	GlobPoolVar();
+public:
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const override;
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const override;
+	/**
+	 * This operation sets the data pool id of the variable.
+	 * The method is necessary to set id's of data pool member variables with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+
+	uint8_t getValid();
+
+	void setValid(uint8_t valid);
+
+	operator T() {
+		return value;
+	}
+
+	operator T() const {
+		return value;
+	}
+
+	GlobPoolVar<T> &operator=(T newValue) {
+		value = newValue;
+		return *this;
+	}
+
+	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
+		value = newPoolVariable.value;
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override {
+		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
+				bigEndian);
+	}
+
+	virtual size_t getSerializedSize() const {
+		return SerializeAdapter<T>::getSerializedSize(&value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) {
+		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
+	}
+};
+
+#include <framework/datapoolglob/GlobalPoolVariable.tpp>
+
+typedef GlobPoolVar<uint8_t> gp_bool_t;
+typedef GlobPoolVar<uint8_t> gp_uint8_t;
+typedef GlobPoolVar<uint16_t> gp_uint16_t;
+typedef GlobPoolVar<uint32_t> gp_uint32_t;
+typedef GlobPoolVar<int8_t> gp_int8_t;
+typedef GlobPoolVar<int16_t> gp_int16_t;
+typedef GlobPoolVar<int32_t> gp_int32_t;
+typedef GlobPoolVar<float> gp_float_t;
+typedef GlobPoolVar<double> gp_double_t;
+
+#endif /* POOLVARIABLE_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.tpp b/datapoolglob/GlobalPoolVariable.tpp
new file mode 100644
index 000000000..287f06dd6
--- /dev/null
+++ b/datapoolglob/GlobalPoolVariable.tpp
@@ -0,0 +1,84 @@
+#pragma once
+
+template <class T>
+inline GlobPoolVar<T>::GlobPoolVar(uint32_t set_id,
+		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode):
+		dataPoolId(set_id), valid(PoolVariableIF::INVALID),
+		readWriteMode(setReadWriteMode)
+{
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template <class T>
+inline ReturnValue_t GlobPoolVar<T>::read() {
+	PoolEntry<T>* read_out = ::dataPool.getData<T>(dataPoolId, 1);
+	if (read_out != NULL) {
+		valid = read_out->valid;
+		value = *(read_out->address);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		value = 0;
+		valid = false;
+		sif::error << "PoolVariable: read of DP Variable 0x" << std::hex
+				<< dataPoolId << std::dec << " failed." << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template <class T>
+inline ReturnValue_t GlobPoolVar<T>::commit() {
+	PoolEntry<T>* write_back = ::dataPool.getData<T>(dataPoolId, 1);
+	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
+		write_back->valid = valid;
+		*(write_back->address) = value;
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template <class T>
+inline GlobPoolVar<T>::GlobPoolVar():
+		dataPoolId(PoolVariableIF::NO_PARAMETER),
+		valid(PoolVariableIF::INVALID),
+		readWriteMode(VAR_READ), value(0) {}
+
+template <class T>
+inline GlobPoolVar<T>::GlobPoolVar(const GlobPoolVar& rhs) :
+		dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode(
+		rhs.readWriteMode), value(rhs.value) {}
+
+template <class T>
+inline pool_rwm_t GlobPoolVar<T>::getReadWriteMode() const  {
+	return readWriteMode;
+}
+
+template <class T>
+inline uint32_t GlobPoolVar<T>::getDataPoolId() const {
+	return dataPoolId;
+}
+
+template <class T>
+inline void GlobPoolVar<T>::setDataPoolId(uint32_t poolId) {
+	dataPoolId = poolId;
+}
+
+template <class T>
+inline bool GlobPoolVar<T>::isValid() const {
+	if (valid)
+		return true;
+	else
+		return false;
+}
+
+template <class T>
+inline uint8_t GlobPoolVar<T>::getValid() {
+	return valid;
+}
+
+template <class T>
+inline void GlobPoolVar<T>::setValid(uint8_t valid) {
+	this->valid = valid;
+}
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
new file mode 100644
index 000000000..47381aec0
--- /dev/null
+++ b/datapoolglob/GlobalPoolVector.h
@@ -0,0 +1,223 @@
+#ifndef POOLVECTOR_H_
+#define POOLVECTOR_H_
+
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolEntry.h>
+#include <framework/datapool/PoolVariableIF.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+/**
+ * \brief	This is the access class for array-type data pool entries.
+ *
+ * \details	To ensure safe usage of the data pool, operation is not done directly on the data pool
+ * 			entries, but on local copies. This class provides simple type- and length-safe access
+ * 			to vector-style data pool entries (i.e. entries with length > 1).
+ * 			The class can be instantiated as read-write and read only.
+ * 			It provides a commit-and-roll-back semantic, which means that no array entry in
+ * 			the data pool is changed until the commit call is executed.
+ * 			There are two template parameters:
+ * 	\tparam	T This template parameter specifies the data type of an array entry. Currently, all
+ * 			plain data types are supported, but in principle any type is possible.
+ * 	\tparam vector_size	This template parameter specifies the vector size of this entry.
+ * 			Using a template parameter for this is not perfect, but avoids dynamic memory allocation.
+ *	\ingroup data_pool
+ */
+template<typename T, uint16_t vector_size>
+class GlobPoolVector: public PoolVariableIF {
+private:
+	/**
+	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * 			is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * \brief	The information whether the class is read-write or read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+
+protected:
+	/**
+	 * \brief	This is a call to read the array's values from the global data pool.
+	 * \details	When executed, this operation tries to fetch the pool entry with matching
+	 * 			data pool id from the global data pool and copies all array values and the valid
+	 * 			information to its local attributes. In case of a failure (wrong type, size or
+	 * 			pool id not found), the variable is set to zero and invalid.
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 */
+	ReturnValue_t read() {
+		PoolEntry<T>* read_out = ::dataPool.getData<T>(this->dataPoolId,
+				vector_size);
+		if (read_out != NULL) {
+			this->valid = read_out->valid;
+			memcpy(this->value, read_out->address, read_out->getByteSize());
+
+			return HasReturnvaluesIF::RETURN_OK;
+
+		} else {
+			memset(this->value, 0, vector_size * sizeof(T));
+			sif::error << "PoolVector: read of DP Variable 0x" << std::hex
+					<< dataPoolId << std::dec << " failed." << std::endl;
+			this->valid = INVALID;
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	/**
+	 * \brief	The commit call copies the array values back to the data pool.
+	 * \details	It checks type and size, as well as if the variable is writable. If so,
+	 * 			the value is copied and the valid flag is automatically set to "valid".
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 *
+	 */
+	ReturnValue_t commit() {
+		PoolEntry<T>* write_back = ::dataPool.getData<T>(this->dataPoolId,
+				vector_size);
+		if ((write_back != NULL) && (this->readWriteMode != VAR_READ)) {
+			write_back->valid = valid;
+			memcpy(write_back->address, this->value, write_back->getByteSize());
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+public:
+	/**
+	 * \brief	This is the local copy of the data pool entry.
+	 * \detials	The user can work on this attribute
+	 * 			just like he would on a local array of this type.
+	 */
+	T value[vector_size];
+	/**
+	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
+	 * 			passed).
+	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
+	 * 			attribute to default (0). The value is fetched within the read() operation.
+	 * \param set_id	This is the id in the global data pool this instance of the access class
+	 * 					corresponds to.
+	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
+	 * 					the variable is not registered.
+	 * \param setWritable If this flag is set to true, changes in the value attribute can be
+	 * 					written back to the data pool, otherwise not.
+	 */
+	GlobPoolVector(uint32_t set_id, DataSetIF* set,
+			ReadWriteMode_t setReadWriteMode) :
+			dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
+		memset(this->value, 0, vector_size * sizeof(T));
+		if (set != NULL) {
+			set->registerVariable(this);
+		}
+	}
+	/**
+	 * Copy ctor to copy classes containing Pool Variables.
+	 */
+//	PoolVector(const PoolVector& rhs) {
+//		PoolVector<T, vector_size> temp(rhs.dataPoolId, rhs.)
+//		memcpy(value, rhs.value, sizeof(T)*vector_size);
+//	}
+	/**
+	 * \brief	The classes destructor is empty.
+	 * \details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVector() {
+	}
+	;
+	/**
+	 * \brief	The operation returns the number of array entries in this variable.
+	 */
+	uint8_t getSize() {
+		return vector_size;
+	}
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const {
+		return dataPoolId;
+	}
+	/**
+	 * This operation sets the data pool id of the variable.
+	 * The method is necessary to set id's of data pool member variables with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId) {
+		dataPoolId = poolId;
+	}
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const {
+		return readWriteMode;
+	}
+	;
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const {
+		if (valid != INVALID)
+			return true;
+		else
+			return false;
+	}
+
+	void setValid(uint8_t valid) {
+		this->valid = valid;
+	}
+
+	uint8_t getValid() {
+		return valid;
+	}
+
+	T &operator [](int i) {
+		return value[i];
+	}
+
+	const T &operator [](int i) const {
+		return value[i];
+	}
+
+	GlobPoolVector<T, vector_size> &operator=(
+			GlobPoolVector<T, vector_size> newPoolVector) {
+
+		for (uint16_t i = 0; i < vector_size; i++) {
+			this->value[i] = newPoolVector.value[i];
+		}
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override {
+		uint16_t i;
+		ReturnValue_t result;
+		for (i = 0; i < vector_size; i++) {
+			result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
+					max_size, bigEndian);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override {
+		uint16_t i;
+		ReturnValue_t result;
+		for (i = 0; i < vector_size; i++) {
+			result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
+					bigEndian);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return result;
+	}
+};
+
+#endif /* POOLVECTOR_H_ */
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
new file mode 100644
index 000000000..07f86e18b
--- /dev/null
+++ b/datapoollocal/LocalDataSet.cpp
@@ -0,0 +1,66 @@
+#include <framework/datapoollocal/LocalDataSet.h>
+
+LocalDataSet::LocalDataSet():
+		fill_count(0), state(DATA_SET_UNINITIALISED)
+{
+	for (unsigned count = 0; count < DATA_SET_MAX_SIZE; count++) {
+		registeredVariables[count] = nullptr;
+	}
+}
+
+// who has the responsibility to lock the mutex? the local pool variable
+// has access to the HK manager and could call its mutex lock function.
+ReturnValue_t LocalDataSet::registerVariable(
+		PoolVariableIF *variable) {
+	return RETURN_OK;
+}
+
+LocalDataSet::~LocalDataSet() {
+}
+
+ReturnValue_t LocalDataSet::read() {
+	return RETURN_OK;
+}
+
+ReturnValue_t LocalDataSet::commit(void) {
+	return RETURN_OK;
+}
+
+ReturnValue_t LocalDataSet::commit(bool valid) {
+	return RETURN_OK;
+}
+
+void LocalDataSet::setSetValid(bool valid) {
+}
+
+void LocalDataSet::setEntriesValid(bool valid) {
+}
+
+ReturnValue_t LocalDataSet::serialize(uint8_t **buffer,
+		size_t *size, const size_t max_size, bool bigEndian) const {
+	return RETURN_OK;
+}
+
+size_t LocalDataSet::getSerializedSize() const {
+	return 0;
+}
+
+ReturnValue_t LocalDataSet::deSerialize(const uint8_t **buffer,
+		size_t *size, bool bigEndian) {
+	return RETURN_OK;
+}
+
+ReturnValue_t LocalDataSet::lockDataPool() {
+	return RETURN_OK;
+}
+
+ReturnValue_t LocalDataSet::unlockDataPool() {
+	return RETURN_OK;
+}
+
+void LocalDataSet::handleAlreadyReadDatasetCommit() {
+}
+
+ReturnValue_t LocalDataSet::handleUnreadDatasetCommit() {
+	return RETURN_OK;
+}
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
new file mode 100644
index 000000000..6110175c4
--- /dev/null
+++ b/datapoollocal/LocalDataSet.h
@@ -0,0 +1,187 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
+#include <framework/datapool/DataSetIF.h>
+#include <framework/serialize/SerializeIF.h>
+
+/**
+ * @brief	The LocalDataSet class manages a set of locally checked out variables
+ * 			for local data pools
+ * @details
+ * This class manages a list, where a set of local variables (or pool variables)
+ * are registered. They are checked-out (i.e. their values are looked
+ * up and copied) with the read call. After the user finishes working with the
+ * pool variables, he can write back all variable values to the pool with
+ * the commit call. The data set manages locking and freeing the local data pools,
+ * to ensure thread-safety.
+ *
+ * An internal state manages usage of this class. Variables may only be
+ * registered before the read call is made, and the commit call only
+ * after the read call.
+ *
+ * If pool variables are writable and not committed until destruction
+ * of the set, the DataSet class automatically sets the valid flag in the
+ * data pool to invalid (without) changing the variable's value.
+ *
+ * @ingroup data_pool
+ */
+class LocalDataSet:
+		public DataSetIF,
+		public HasReturnvaluesIF,
+		public SerializeIF {
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
+	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION =
+			MAKE_RETURN_CODE( 0x01 );
+	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
+	static constexpr ReturnValue_t COMMITING_WITHOUT_READING =
+			MAKE_RETURN_CODE(0x03);
+
+	static constexpr ReturnValue_t DATA_SET_UNINITIALIZED = MAKE_RETURN_CODE( 0x04 );
+	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE( 0x05 );
+	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE( 0x06 );
+	/**
+	 * @brief	The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
+	 */
+	LocalDataSet();
+
+	/**
+	 * @brief	This operation is used to register the local variables in the set.
+	 * @details	It stores the pool variable pointer in a variable list.
+	 */
+	ReturnValue_t registerVariable(PoolVariableIF* variable) override;
+
+	/**
+	 * @brief	The destructor automatically manages writing the valid
+	 * 			information of variables.
+	 * @details
+	 * In case the data set was read out, but not committed(indicated by state),
+	 * the destructor parses all variables that are still registered to the set.
+	 * For each, the valid flag in the data pool is set to "invalid".
+	 */
+	~LocalDataSet();
+
+	/**
+	 * @brief	The read call initializes reading out all registered variables.
+	 * @details
+	 * It iterates through the list of registered variables and calls all read()
+	 * functions of the registered pool variables (which read out their values
+	 * from the data pool) which are not write-only.
+	 * In case of an error (e.g. a wrong data type, or an invalid data pool id),
+	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
+	 *
+	 * The data pool is locked during the whole read operation and
+	 * freed afterwards.The state changes to "was written" after this operation.
+	 * @return	- @c RETURN_OK if all variables were read successfully.
+	 * 			- @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
+	 * 					requested variable is invalid.
+	 * 			- @c SET_WAS_ALREADY_READ if read() is called twice without
+	 * 				 	calling commit() in between
+	 */
+	ReturnValue_t read();
+
+	/**
+	 * @brief	The commit call initializes writing back the registered variables.
+	 * @details
+	 * It iterates through the list of registered variables and calls the
+	 * commit() method of the remaining registered variables (which write back
+	 * their values to the pool).
+	 *
+	 * The data pool is locked during the whole commit operation and
+	 * freed afterwards. The state changes to "was committed" after this operation.
+	 *
+	 * If the set does contain at least one variable which is not write-only commit()
+	 * can only be called after read(). If the set only contains variables which are
+	 * write only, commit() can be called without a preceding read() call.
+	 * @return	- @c RETURN_OK if all variables were read successfully.
+	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
+	 * 			  contains non write-only variables
+	 */
+	ReturnValue_t commit(void);
+
+	/**
+	 * Variant of method above which sets validity of all elements of the set.
+	 * @param valid Validity information from PoolVariableIF.
+	 * @return	- @c RETURN_OK if all variables were read successfully.
+	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
+	 * 			     contains non write-only variables
+	 */
+	ReturnValue_t commit(bool valid);
+
+	/**
+	 * Set all entries
+	 * @param valid
+	 */
+	void setSetValid(bool valid);
+
+	/**
+	 * Set the valid information of all variables contained in the set which
+	 * are not read-only
+	 *
+	 * @param valid Validity information from PoolVariableIF.
+	 */
+	void setEntriesValid(bool valid);
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override;
+
+	size_t getSerializedSize() const override;
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override;
+private:
+	// SHOULDDO we could use a linked list of datapool variables
+	//! This definition sets the maximum number of variables
+	//! to register in one DataSet.
+	static const uint8_t DATA_SET_MAX_SIZE = 63;
+	/**
+	 * @brief	This array represents all pool variables registered in this set.
+	 */
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
+	/**
+	 * @brief	The fill_count attribute ensures that the variables register in
+	 * 			the correct array position and that the maximum number of
+	 * 			variables is not exceeded.
+	 */
+	uint16_t fill_count;
+
+	/**
+	 * States of the seet.
+	 */
+	enum States {
+		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
+		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
+	};
+
+	/**
+	 * @brief	state manages the internal state of the data set,
+	 *          which is important e.g. for the behavior on destruction.
+	 */
+	States state;
+
+	/**
+	 * If the valid state of a dataset is always relevant to the whole
+	 * data set we can use this flag.
+	 */
+	bool valid = false;
+	/**
+	 * @brief	This is a small helper function to facilitate locking
+	 * 			the underlying data data pool structure
+	 * @details
+	 * It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	ReturnValue_t lockDataPool() override;
+
+	/**
+	 * @brief	This is a small helper function to facilitate
+	 * 			unlocking the underlying data data pool structure
+	 * @details
+	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	ReturnValue_t unlockDataPool() override;
+
+	void handleAlreadyReadDatasetCommit();
+	ReturnValue_t handleUnreadDatasetCommit();
+};
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
new file mode 100644
index 000000000..44c16a7ce
--- /dev/null
+++ b/datapoollocal/LocalPoolVariable.h
@@ -0,0 +1,103 @@
+#pragma once
+
+#include <framework/datapool/PoolVariableIF.h>
+#include <framework/datapool/DataSetIF.h>
+
+#include <framework/housekeeping/HousekeepingManager.h>
+
+#include <map>
+/**
+ * @brief	This is the access class for non-array local data pool entries.
+ *
+ * @details
+ *
+ * 	@tparam	T The template parameter sets the type of the variable.
+ * 	Currently, all plain data types are supported, but in principle
+ * 	any type is possible.
+ *	@ingroup data_pool
+ */
+
+/**
+ * @brief 	Local Pool Variable class which is used to access the local pools.
+ * @details This class is not stored in the map. Instead, it is used to access
+ * 			the pool entries by using a pointer to the map storing the pool
+ * 			entries. It can also be used to organize these pool entries
+ * 			into data sets.
+ * @tparam T
+ */
+template<typename T>
+class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
+public:
+	static constexpr lp_id_t INVALID_POOL_ID = 0xFFFFFFFF;
+
+	/**
+	 * This constructor is used by the data creators to have pool variable
+	 * instances which can also be stored in datasets.
+	 * @param set_id
+	 * @param setReadWriteMode
+	 * @param localPoolMap
+	 * @param dataSet
+	 */
+	LocalPoolVar(lp_id_t poolId, HasHkPoolParametersIF* hkOwner,
+			pool_rwm_t setReadWriteMode, DataSetIF* dataSet = nullptr);
+
+	/**
+	 * This constructor is used by data users like controllers to have
+	 * access to the local pool variables of data creators by supplying
+	 * the respective creator object ID.
+	 * @param poolId
+	 * @param poolOwner
+	 * @param setReadWriteMode
+	 * @param dataSet
+	 */
+	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+			pool_rwm_t setReadWriteMode, DataSetIF* dataSet = nullptr);
+
+	virtual~ LocalPoolVar() {};
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a simple local variable.
+	 */
+	T value = 0;
+
+	ReturnValue_t commit() override;
+	ReturnValue_t read() override;
+	pool_rwm_t getReadWriteMode() const override;
+	uint32_t getDataPoolId() const override;
+	bool isValid() const override;
+	void setValid(uint8_t validity) override;
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				const size_t max_size, bool bigEndian) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				bool bigEndian) override;
+private:
+	lp_id_t localPoolId = INVALID_POOL_ID;
+	pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
+	bool valid = false;
+
+	bool objectValid = true;
+	//! Pointer to the class which manages the HK pool.
+	HousekeepingManager* hkManager;
+};
+
+#include <framework/datapoollocal/LocalPoolVariable.tpp>
+template<class T>
+using lp_variable = LocalPoolVar<T>;
+
+using lp_bool_t = LocalPoolVar<bool>;
+using lp_uint8_t = LocalPoolVar<uint8_t>;
+using lp_uint16_t = LocalPoolVar<uint16_t>;
+using lp_uint32_t = LocalPoolVar<uint32_t>;
+using lp_uint64_t = LocalPoolVar<uint64_t>;
+using lp_int8_t = LocalPoolVar<int8_t>;
+using lp_int16_t = LocalPoolVar<int16_t>;
+using lp_int32_t = LocalPoolVar<int32_t>;
+using lp_int64_t = LocalPoolVar<int64_t>;
+using lp_float_t = LocalPoolVar<float>;
+using lp_double_t = LocalPoolVar<double>;
+
+
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
new file mode 100644
index 000000000..fdd18bcd7
--- /dev/null
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -0,0 +1,109 @@
+#pragma once
+
+#include <framework/housekeeping/HasHkPoolParametersIF.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
+
+#include <framework/serialize/SerializeAdapter.h>
+
+template<typename T>
+inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
+		HasHkPoolParametersIF* hkOwner, pool_rwm_t setReadWriteMode,
+		DataSetIF* dataSet):
+		localPoolId(poolId),readWriteMode(setReadWriteMode) {
+	hkManager = hkOwner->getHkManagerHandle();
+	if(dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template<typename T>
+inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+		pool_rwm_t setReadWriteMode, DataSetIF *dataSet):
+		readWriteMode(readWriteMode) {
+	HasHkPoolParametersIF* hkOwner =
+			objectManager->get<HasHkPoolParametersIF>(poolOwner);
+	if(hkOwner == nullptr) {
+		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
+				"the correct interface HasHkPoolParametersIF!" << std::endl;
+		objectValid = false;
+		return;
+	}
+	hkManager = hkOwner->getHkManagerHandle();
+	if(dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::read() {
+	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+		sif::debug << "LocalPoolVar: Invalid read write "
+				"mode for read() call." << std::endl;
+		// TODO: special return value
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::NO_TIMEOUT);
+	PoolEntry<T>* poolEntry = nullptr;
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, poolEntry);
+	if(result != RETURN_OK) {
+		return result;
+	}
+	this->value = *(poolEntry->address);
+	return RETURN_OK;
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::commit() {
+	if(readWriteMode == pool_rwm_t::VAR_READ) {
+		sif::debug << "LocalPoolVar: Invalid read write "
+				 "mode for commit() call." << std::endl;
+		// TODO: special return value
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::NO_TIMEOUT);
+	PoolEntry<T>* poolEntry = nullptr;
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, poolEntry);
+	if(result != RETURN_OK) {
+		return result;
+	}
+	*(poolEntry->address) = this->value;
+	return RETURN_OK;
+}
+
+template<typename T>
+inline pool_rwm_t LocalPoolVar<T>::getReadWriteMode() const {
+	return readWriteMode;
+}
+
+template<typename T>
+inline lp_id_t LocalPoolVar<T>::getDataPoolId() const {
+	return localPoolId;
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::isValid() const {
+	return valid;
+}
+
+template<typename T>
+inline void LocalPoolVar<T>::setValid(uint8_t validity) {
+	this->valid = validity;
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
+	return AutoSerializeAdapter::serialize(&value,
+			buffer, size ,max_size, bigEndian);
+}
+
+template<typename T>
+inline size_t LocalPoolVar<T>::getSerializedSize() const {
+	return AutoSerializeAdapter::getSerializedSize(&value);
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
+		size_t* size, bool bigEndian) {
+	return AutoSerializeAdapter::deSerialize(&value, buffer, size, bigEndian);
+}
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 710e97d78..0549bd45d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,14 +1,14 @@
-#include <framework/datapool/DataSet.h>
-#include <framework/datapool/PoolVariable.h>
-#include <framework/datapool/PoolVector.h>
-#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
 #include <framework/devicehandlers/DeviceHandlerBase.h>
-#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
-#include <framework/globalfunctions/CRC.h>
 #include <framework/objectmanager/ObjectManager.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/subsystem/SubsystemBase.h>
 #include <framework/thermal/ThermalComponentIF.h>
+#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
+
+#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapool/PoolVariable.h>
+#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
+#include <framework/globalfunctions/CRC.h>
+#include <framework/subsystem/SubsystemBase.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
@@ -17,34 +17,33 @@ object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
-		object_id_t deviceCommunication, CookieIF * comCookie_,
+		object_id_t deviceCommunication, CookieIF * comCookie,
 		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
 		uint32_t thermalRequestPoolId, 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),
-		fdirInstance(fdirInstance), hkSwitcher(this),
-		defaultFDIRUsed(fdirInstance == nullptr), switchOffWasReported(false),
-		executingTask(nullptr), actionHelper(this, nullptr), cookieInfo(),
-		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
-{
-	commandQueue = QueueFactory::instance()->
-			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
+		deviceCommunicationId(deviceCommunication), 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), cookieInfo(),
+		childTransitionDelay(5000),
+		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
+		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
+			CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
 	if (this->fdirInstance == nullptr) {
-		this->fdirInstance =
-				new DeviceHandlerFailureIsolation(setObjectId,
-						defaultFDIRParentId);
+		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
+				defaultFDIRParentId);
 	}
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-	delete comCookie;
+	//communicationInterface->close(cookie);
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
 	}
@@ -53,7 +52,8 @@ DeviceHandlerBase::~DeviceHandlerBase() {
 
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	this->pstStep = counter;
-	if (counter == 0) {
+
+	if (getComAction() == SEND_WRITE) {
 		cookieInfo.state = COOKIE_UNUSED;
 		readCommandQueue();
 		doStateMachine();
@@ -66,7 +66,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	if (mode == MODE_OFF) {
 		return RETURN_OK;
 	}
-
 	switch (getComAction()) {
 	case SEND_WRITE:
 		if ((cookieInfo.state == COOKIE_UNUSED)) {
@@ -87,7 +86,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	default:
 		break;
 	}
-
 	return RETURN_OK;
 }
 
@@ -116,7 +114,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
 			AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
-	if (rawReceiver == nullptr) {
+	if (rawReceiver == NULL) {
 		return RETURN_FAILED;
 	}
 
@@ -158,14 +156,15 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	fillCommandAndReplyMap();
 
 	//Set temperature target state to NON_OP.
-	DataSet mySet;
-	PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
+	GlobDataSet mySet;
+	gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 			PoolVariableIF::VAR_WRITE);
 	mySet.read();
 	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
 	mySet.commit(PoolVariableIF::VALID);
 
 	return RETURN_OK;
+
 }
 
 void DeviceHandlerBase::decrementDeviceReplyMap() {
@@ -366,8 +365,11 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
 	info.expectedReplies = 0;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
-	std::pair<DeviceCommandIter, bool> result = deviceCommandMap.emplace(deviceCommand,info);
-	if (result.second) {
+	std::pair<std::map<DeviceCommandId_t, DeviceCommandInfo>::iterator, bool> returnValue;
+	returnValue = deviceCommandMap.insert(
+			std::pair<DeviceCommandId_t, DeviceCommandInfo>(deviceCommand,
+					info));
+	if (returnValue.second) {
 		return RETURN_OK;
 	} else {
 		return RETURN_FAILED;
@@ -426,8 +428,8 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	Clock::getUptime(&timeoutStart);
 
 	if (mode == MODE_OFF) {
-		DataSet mySet;
-		PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
+		GlobDataSet mySet;
+		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ_WRITE);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -487,7 +489,7 @@ void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 		return;
 	}
 //Check if more replies are expected. If so, do nothing.
-	DeviceCommandInfo * info = &(iter->second.command->second);
+	DeviceCommandInfo* info = &(iter->second.command->second);
 	if (--info->expectedReplies == 0) {
 		//Check if it was transition or internal command. Don't send any replies in that case.
 		if (info->sendReplyTo != NO_COMMANDER) {
@@ -526,6 +528,7 @@ void DeviceHandlerBase::doGetWrite() {
 		if (wiretappingMode == RAW) {
 			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
 		}
+
 		//We need to distinguish here, because a raw command never expects a reply.
 		//(Could be done in eRIRM, but then child implementations need to be careful.
 		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
@@ -541,25 +544,22 @@ void DeviceHandlerBase::doGetWrite() {
 }
 
 void DeviceHandlerBase::doSendRead() {
-	ReturnValue_t result = RETURN_FAILED;
+	ReturnValue_t result;
+
 	size_t requestLen = 0;
-	// If the device handler can only request replies after a command
-	// has been sent, there should be only one reply enabled and the
-	// correct reply length will be mapped.
-	for(DeviceReplyIter iter = deviceReplyMap.begin();
-			iter != deviceReplyMap.end();iter++)
-	{
-		if(iter->second.delayCycles != 0) {
-			requestLen = iter->second.replyLen;
-			break;
-		}
+	DeviceReplyIter iter = deviceReplyMap.find(cookieInfo.pendingCommand->first);
+	if(iter != deviceReplyMap.end()) {
+		requestLen = iter->second.replyLen;
+	}
+	else {
+		requestLen = 0;
 	}
 
 	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
+
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
-	}
-	else {
+	} else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
 		//We can't inform anyone, because we don't know which command was sent last.
 		//So, we need to wait for a timeout.
@@ -583,8 +583,8 @@ void DeviceHandlerBase::doGetRead() {
 
 	cookieInfo.state = COOKIE_UNUSED;
 
-	result = communicationInterface->readReceivedMessage(comCookie, &receivedData,
-			&receivedDataLen);
+	result = communicationInterface->readReceivedMessage(comCookie,
+			&receivedData, &receivedDataLen);
 
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
@@ -644,7 +644,7 @@ void DeviceHandlerBase::doGetRead() {
 }
 
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
-		uint8_t ** data, size_t * len) {
+		uint8_t * *data, uint32_t * len) {
 	size_t lenTmp;
 
 	if (IPCStore == NULL) {
@@ -663,10 +663,8 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 		*len = 0;
 		return result;
 	}
-
 }
 
-
 void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		MessageQueueId_t sendTo, bool isCommand) {
 	if (IPCStore == NULL || len == 0) {
@@ -681,6 +679,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 	}
 
 	CommandMessage message;
+
 	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&message,
 			getObjectId(), address, isCommand);
 
@@ -690,14 +689,12 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 
 	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.
 	}
 }
 
 //Default child implementations
-
-DeviceHandlerBase::CommunicationAction_t DeviceHandlerBase::getComAction() {
+DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
 	switch (pstStep) {
 	case 0:
 		return SEND_WRITE;
@@ -762,8 +759,8 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 //			DeviceCommunicationIF>(newChannelId);
 //
 //	if (newCommunication != NULL) {
-//		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
-//				maxDeviceReplyLen, comParameter1, comParameter2);
+//		ReturnValue_t result = newCommunication->reOpen(cookie, ioBoardAddress,
+//				maxDeviceReplyLen);
 //		if (result != RETURN_OK) {
 //			return result;
 //		}
@@ -780,8 +777,8 @@ void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 		replyReturnvalueToCommand(result, RAW_COMMAND_ID);
 		storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
 	} else {
-		cookieInfo.pendingCommand = deviceCommandMap.
-				find((DeviceCommandId_t) RAW_COMMAND_ID);
+		cookieInfo.pendingCommand = deviceCommandMap.find(
+				(DeviceCommandId_t) RAW_COMMAND_ID);
 		cookieInfo.pendingCommand->second.isExecuting = true;
 		cookieInfo.state = COOKIE_WRITE_READY;
 	}
@@ -820,7 +817,7 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		iter = deviceReplyMap.find(command->first);
 	}
 	if (iter != deviceReplyMap.end()) {
-		DeviceReplyInfo * info = &(iter->second);
+		DeviceReplyInfo *info = &(iter->second);
 		info->delayCycles = info->maxDelayCycles;
 		info->command = command;
 		command->second.expectedReplies = expectedReplies;
@@ -846,9 +843,8 @@ ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
 	if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
 		while (numberOfSwitches > 0) {
-			if (powerSwitcher-> getSwitchState(switches[numberOfSwitches - 1])
-				== PowerSwitchIF::SWITCH_OFF)
-			{
+			if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1])
+					== PowerSwitchIF::SWITCH_OFF) {
 				return PowerSwitchIF::SWITCH_OFF;
 			}
 			numberOfSwitches--;
@@ -890,10 +886,10 @@ 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,
+		GlobDataSet mySet;
+		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
 				PoolVariableIF::VAR_READ);
-		PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
+		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -920,8 +916,8 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 			childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
 					MODE_ON);
 			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-			DataSet mySet;
-			PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId,
+			GlobDataSet mySet;
+			gp_int8_t thermalRequest(deviceThermalRequestPoolId,
 					&mySet, PoolVariableIF::VAR_READ_WRITE);
 			mySet.read();
 			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -1032,7 +1028,6 @@ void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
 
 ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		CommandMessage * message) {
-	ReturnValue_t result;
 	switch (message->getCommand()) {
 	case DeviceHandlerMessage::CMD_WIRETAPPING:
 		switch (DeviceHandlerMessage::getWiretappingMode(message)) {
@@ -1054,21 +1049,19 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-	case DeviceHandlerMessage::CMD_SWITCH_ADDRESS:
-		if (mode != MODE_OFF) {
-			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-		} else {
-			// rework in progress
-			result = RETURN_OK;
-			//result = switchCookieChannel(
-			//		DeviceHandlerMessage::getIoBoardObjectId(message));
-			if (result == RETURN_OK) {
-				replyReturnvalueToCommand(RETURN_OK);
-			} else {
-				replyReturnvalueToCommand(CANT_SWITCH_ADDRESS);
-			}
-		}
-		return RETURN_OK;
+//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
+//		if (mode != MODE_OFF) {
+//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
+//		} else {
+////			result = switchCookieChannel(
+////					DeviceHandlerMessage::getIoBoardObjectId(message));
+//			if (result == RETURN_OK) {
+//				replyReturnvalueToCommand(RETURN_OK);
+//			} else {
+//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
+//			}
+//		}
+//		return RETURN_OK;
 	case DeviceHandlerMessage::CMD_RAW:
 		if ((mode != MODE_RAW)) {
 			DeviceHandlerMessage::clear(message);
@@ -1124,7 +1117,8 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 
 			// 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);
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
+			true);
 
 		}
 	} else { //unrequested/aperiodic replies
@@ -1137,9 +1131,9 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 			true);
 		}
 	}
-//Try to cast to DataSet and commit data.
+//Try to cast to GlobDataSet and commit data.
 	if (!neverInDataPool) {
-		DataSet* dataSet = dynamic_cast<DataSet*>(data);
+		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
 		if (dataSet != NULL) {
 			dataSet->commit(PoolVariableIF::VALID);
 		}
@@ -1147,12 +1141,11 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 }
 
 ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
 	ReturnValue_t result = acceptExternalDeviceCommands();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-
 	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
 	if (iter == deviceCommandMap.end()) {
 		result = COMMAND_NOT_SUPPORTED;
@@ -1171,7 +1164,7 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
 }
 
 void DeviceHandlerBase::buildInternalCommand(void) {
-	// Neither Raw nor Direct could build a command
+//Neither Raw nor Direct could build a command
 	ReturnValue_t result = NOTHING_TO_SEND;
 	DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
 	if (mode == MODE_NORMAL) {
@@ -1189,13 +1182,12 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 	} else {
 		return;
 	}
-
 	if (result == NOTHING_TO_SEND) {
 		return;
 	}
 	if (result == RETURN_OK) {
-		DeviceCommandMap::iterator iter =
-				deviceCommandMap.find(deviceCommandId);
+		DeviceCommandMap::iterator iter = deviceCommandMap.find(
+				deviceCommandId);
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
@@ -1210,7 +1202,6 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 			cookieInfo.state = COOKIE_WRITE_READY;
 		}
 	}
-
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
 	}
@@ -1285,8 +1276,8 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 			executingTask = task_;
 }
 
-void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t objectId, uint32_t parameter) {
-}
+// Default implementations empty.
+void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
+		object_id_t objectId, uint32_t parameter) {}
 
-void DeviceHandlerBase::performOperationHook() {
-}
+void DeviceHandlerBase::performOperationHook() {}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 25ec75b93..379992b1c 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,26 +1,23 @@
 #ifndef DEVICEHANDLERBASE_H_
 #define DEVICEHANDLERBASE_H_
 
-#include <framework/action/ActionHelper.h>
+#include <framework/objectmanager/SystemObject.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+#include <framework/devicehandlers/DeviceHandlerIF.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/action/HasActionsIF.h>
-#include <framework/datapool/DataSet.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/devicehandlers/DeviceCommunicationIF.h>
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/health/HealthHelper.h>
 #include <framework/modes/HasModesIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/parameters/ParameterHelper.h>
 #include <framework/power/PowerSwitchIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include <framework/datapool/HkSwitchHelper.h>
-#include <framework/devicehandlers/CookieIF.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
 #include <framework/ipc/MessageQueueIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
+
+#include <framework/action/ActionHelper.h>
+#include <framework/health/HealthHelper.h>
+#include <framework/parameters/ParameterHelper.h>
+#include <framework/datapool/HkSwitchHelper.h>
+#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
+
 #include <map>
 
 namespace Factory{
@@ -92,21 +89,22 @@ public:
 	 * The constructor passes the objectId to the SystemObject().
 	 *
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param maxDeviceReplyLen the largest allowed reply size
+	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
 	 * @param setDeviceSwitch the switch the device is connected to,
-	 *    for devices using two switches, overwrite getSwitches()
-	 * @param deviceCommuncation Communcation Interface object which is
-	 *    used to implement communication functions
+	 * for devices using two switches, overwrite getSwitches()
+	 * @param deviceCommuncation Communcation Interface object which is used
+	 * to implement communication functions
 	 * @param thermalStatePoolId
 	 * @param thermalRequestPoolId
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
 	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * comCookie_, uint8_t setDeviceSwitch,
+			CookieIF * comCookie, uint8_t setDeviceSwitch,
 			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
-			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
+			FailureIsolationBase* fdirInstance = nullptr,
+			size_t cmdQueueSize = 20);
 
 	/**
 	 * @brief 	This function is the device handler base core component and is
@@ -213,12 +211,13 @@ protected:
 	/**
 	 * Build the device command to send for normal mode.
 	 *
-	 * This is only called in @c MODE_NORMAL. If multiple submodes for @c MODE_NORMAL are supported,
-	 * different commands can built returned depending on the submode.
+	 * This is only called in @c MODE_NORMAL. If multiple submodes for
+	 * @c MODE_NORMAL are supported, different commands can built,
+	 * depending on the submode.
 	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 * If variable command frequence is required, a counter can be used and
-	 * the frequency in the reply map has to be set manually
+	 * #rawPacket and #rawPacketLen must be set by this method to the
+	 * packet to be sent. If variable command frequence is required, a counter
+	 * can be used and the frequency in the reply map has to be set manually
 	 * by calling updateReplyMap().
 	 *
 	 * @param[out] id the device command id that has been built
@@ -233,10 +232,13 @@ 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_TO_POWER_DOWN. So it is used by doStartUp()
+	 * and doShutDown() as well as doTransition()
 	 *
-	 * 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
-	 * and filling them in doStartUp(), doShutDown() and doTransition() so no modes have to be checked here.
+	 * 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
+	 * and filling them in doStartUp(), doShutDown() and doTransition() so no
+	 * modes have to be checked here.
 	 *
 	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
 	 *
@@ -266,6 +268,63 @@ protected:
 	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
 			const uint8_t * commandData, size_t commandDataLen) = 0;
 
+	/**
+	 * @brief Scans a buffer for a valid reply.
+	 * @details
+	 * This is used by the base class to check the data received for valid packets.
+	 * It only checks if a valid packet starts at @c start.
+	 * It also only checks the structural validy of the packet,
+	 * e.g. checksums lengths and protocol data. No information check is done,
+	 * e.g. range checks etc.
+	 *
+	 * Errors should be reported directly, the base class does NOT report any
+	 * errors based on the return value of this function.
+	 *
+	 * @param start start of remaining buffer to be scanned
+	 * @param len length of remaining buffer to be scanned
+	 * @param[out] foundId the id of the data found in the buffer.
+	 * @param[out] foundLen length of the data found. Is to be set in function,
+	 *                       buffer is scanned at previous position + foundLen.
+	 * @return
+	 *  - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
+	 *  - @c RETURN_FAILED no reply could be found starting at @c start,
+	 *    implies @c foundLen is not valid, base class will call scanForReply()
+	 *    again with ++start
+	 *  - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
+	 *    e.g. checksum error, implies @c foundLen is valid, can be used to
+	 *    skip some bytes
+	 *  - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
+	 *  - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of
+	 *    the packet
+	 *  - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
+	 *  - @c APERIODIC_REPLY if a valid reply is received that has not been
+	 *    requested by a command, but should be handled anyway
+	 *    (@see also fillCommandAndCookieMap() )
+	 */
+	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
+
+	/**
+	 * @brief Interpret a reply from the device.
+	 * @details
+	 * This is called after scanForReply() found a valid packet, it can be
+	 * assumed that the length and structure is valid.
+	 * This routine extracts the data from the packet into a DataSet and then
+	 * calls handleDeviceTM(), which either sends a TM packet or stores the
+	 * data in the DataPool depending on whether it was an external command.
+	 * No packet length is given, as it should be defined implicitly by the id.
+	 *
+	 * @param id the id found by scanForReply()
+	 * @param packet
+	 * @return
+	 *     - @c RETURN_OK when the reply was interpreted.
+	 *     - @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
 	 *	 	  called by the initialize() of the base class
@@ -312,85 +371,83 @@ protected:
 	virtual void fillCommandAndReplyMap() = 0;
 
 	/**
-	 * @brief Scans a buffer for a valid reply.
-	 * @details
-	 * This is used by the base class to check the data received for valid packets.
-	 * It only checks if a valid packet starts at @c start.
-	 * It also only checks the structural validy of the packet,
-	 * e.g. checksums lengths and protocol data.
-	 * No information check is done, e.g. range checks etc.
-	 *
-	 * Errors should be reported directly,  the base class does NOT report
-	 * any errors based on the returnvalue of this function.
-	 *
-	 * @param start start of remaining buffer to be scanned
-	 * @param len length of remaining buffer to be scanned
-	 * @param[out] foundId the id of the data found in the buffer.
-	 * @param[out] foundLen length of the data found. Is to be set in function,
-	 * buffer is scanned at previous position + foundLen.
-	 * @return
-	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *     - @c RETURN_FAILED no reply could be found starting at @c start,
-	 *             implies @c foundLen is not valid,
-	 *             base class will call scanForReply() again with ++start
-	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
-	 *             e.g. checksum error, implies @c foundLen is valid, can be used to skip some bytes
-	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
-	 *     - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of the packet
-	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
-	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been
-	 *             requested by a command, but should be handled anyway
-	 *             (@see also fillCommandAndCookieMap() )
+	 * This is a helper method to facilitate inserting entries in the command map.
+	 * @param deviceCommand	Identifier of the command to add.
+	 * @param maxDelayCycles The maximum number of delay cycles the command
+	 * waits until it times out.
+	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not. Default is aperiodic (0)
+	 * @return	- @c RETURN_OK when the command was successfully inserted,
+	 *          - @c RETURN_FAILED else.
 	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
-			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
+	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
+			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0,
+			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
 	/**
-	 * @brief Interpret a reply from the device.
-	 * @details
-	 * This is called after scanForReply() found a valid packet, it can be assumed that the length and structure is valid.
-	 * This routine extracts the data from the packet into a DataSet and then calls handleDeviceTM(), which either sends
-	 * a TM packet or stores the data in the DataPool depending on whether the it was an external command.
-	 * No packet length is given, as it should be defined implicitly by the id.
-	 *
-	 * @param id the id found by scanForReply()
-	 * @param packet
-	 * @return
-	 *     - @c RETURN_OK when the reply was interpreted.
-	 *     - @c RETURN_FAILED when the reply could not be interpreted, eg. logical errors or range violations occurred
+	 * @brief 	This is a helper method to insert replies in the reply map.
+	 * @param deviceCommand	Identifier of the reply to add.
+	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
+	 * until it times out.
+	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not. Default is aperiodic (0)
+	 * @return	- @c RETURN_OK when the command was successfully inserted,
+	 *          - @c RETURN_FAILED else.
 	 */
-	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet) = 0;
+	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
+			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0);
 
 	/**
-	 * set all datapool variables that are update periodically in normal mode invalid
-	 *
-	 * Child classes should provide an implementation which sets all those variables invalid
-	 * which are set periodically during any normal mode.
+	 * @brief 	A simple command to add a command to the commandList.
+	 * @param deviceCommand The command to add
+	 * @return - @c RETURN_OK when the command was successfully inserted,
+	 *         - @c RETURN_FAILED else.
 	 */
-	virtual void setNormalDatapoolEntriesInvalid() = 0;
+	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
+	/**
+	 * @brief 	This is a helper method to facilitate updating entries
+	 *        	in the reply map.
+	 * @param deviceCommand	Identifier of the reply to update.
+	 * @param delayCycles The current number of delay cycles to wait.
+	 * As stated in #fillCommandAndCookieMap, to disable periodic commands,
+	 * this is set to zero.
+	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
+	 * until it times out. By passing 0 the entry remains untouched.
+	 * @param periodic Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not.Default is aperiodic (0).
+	 * Warning: The setting always overrides the value that was entered in the map.
+	 * @return - @c RETURN_OK when the command was successfully inserted,
+	 *         - @c RETURN_FAILED else.
+	 */
+	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
+			uint16_t delayCycles, uint16_t maxDelayCycles,
+			uint8_t periodic = 0);
 
 	/**
 	 * @brief   Can be implemented by child handler to
 	 *          perform debugging
 	 * @details Example: Calling this in performOperation
 	 *          to track values like mode.
-	 * @param 	positionTracker Provide the child handler a way to know where the debugInterface was called
-	 * @param 	objectId Provide the child handler object Id to specify actions for spefic devices
-	 * @param 	parameter Supply a parameter of interest
+	 * @param positionTracker Provide the child handler a way to know
+	 * where the debugInterface was called
+	 * @param objectId Provide the child handler object Id to
+	 * specify actions for spefic devices
+	 * @param parameter Supply a parameter of interest
 	 * Please delete all debugInterface calls in DHB after debugging is finished !
 	 */
-	virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0, uint32_t parameter = 0);
+	virtual void debugInterface(uint8_t positionTracker = 0,
+			object_id_t objectId = 0, uint32_t parameter = 0);
 
 	/**
 	 * Get the time needed to transit from modeFrom to modeTo.
 	 *
 	 * Used for the following transitions:
 	 * modeFrom -> modeTo:
-	 *  - MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 *  - MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 *  - MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 *  - _MODE_START_UP -> MODE_ON (do not include time to set the switches, the base class got you covered)
+	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches,
+	 * the base class got you covered)
 	 *
 	 * The default implementation returns 0 !
 	 * @param modeFrom
@@ -408,40 +465,24 @@ protected:
 	 * @param[out] numberOfSwitches length of returned array
 	 * @return
 	 *      - @c RETURN_OK if the parameters were set
-	 *      - @c NO_SWITCH or any other returnvalue if no switches exist
+	 *      - @c RETURN_FAILED if no switches exist
 	 */
 	virtual ReturnValue_t getSwitches(const uint8_t **switches,
 			uint8_t *numberOfSwitches);
 
 	/**
-	 * Can be used to perform device specific periodic operations.
-	 * This is called on the SEND_READ step of the performOperation() call
+	 * @brief 	Hook function for child handlers which is called once per
+	 * 			performOperation(). Default implementation is empty.
 	 */
 	virtual void performOperationHook();
-
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
-
 public:
 	/**
 	 * @param parentQueueId
 	 */
 	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
-	/**
-	 * This function call handles the execution of external commands as required
-	 * by the HasActionIF.
-	 * @param actionId
-	 * @param commandedBy
-	 * @param data
-	 * @param size
-	 * @return
-	 */
 	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
-
+			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
 	Mode_t getTransitionSourceMode() const;
 	Submode_t getTransitionSourceSubMode() const;
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
@@ -460,6 +501,28 @@ public:
 	virtual MessageQueueId_t getCommandQueue(void) const;
 
 protected:
+	/**
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
+	 */
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
+
+	/**
+	 * These returnvalues can be returned from abstract functions
+	 * to alter the behaviour of DHB.For error values, refer to
+	 * DeviceHandlerIF.h returnvalues.
+	 */
+	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(4);
+	// Returnvalues for scanForReply()
+	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5); //!< This is used to specify for replies from a device which are not replies to requests
+	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6); //!< Ignore parts of the received packet
+	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(7); //!< Ignore full received packet
+
+//	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
+//	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
+	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(10);
+	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(11);
+	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(12);
+
 	//Mode handling error Codes
 	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE1);
 	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE2);
@@ -475,7 +538,7 @@ protected:
 	/**
 	 * Size of the #rawPacket.
 	 */
-	size_t rawPacketLen = 0;
+	uint32_t rawPacketLen = 0;
 
 	/**
 	 * The mode the device handler is currently in.
@@ -502,7 +565,7 @@ protected:
 	 * 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
 	 */
-	enum WiretappingMode: uint8_t {
+	enum WiretappingMode {
 		OFF = 0, RAW = 1, TM = 2
 	} wiretappingMode;
 
@@ -546,18 +609,16 @@ protected:
 	DeviceCommunicationIF *communicationInterface = nullptr;
 
 	/**
-	 * Cookie used for communication. This is passed to the communication
-	 * interface.
+	 * Cookie used for communication
 	 */
-	CookieIF *comCookie;
+	CookieIF * comCookie = nullptr;
 
 	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.
 	};
-	typedef std::map<DeviceCommandId_t, DeviceCommandInfo> DeviceCommandMap;
-	typedef DeviceCommandMap::iterator DeviceCommandIter;
+	using DeviceCommandMap = std::map<DeviceCommandId_t, DeviceCommandInfo> ;
 
 	/**
 	 * @brief Information about expected replies
@@ -568,15 +629,12 @@ protected:
 		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
 		size_t replyLen = 0; //!< Expected size of the reply.
-		//(Robin): This is a flag, isnt it? could we declare it bool? uint8_t always
-		// gives away the impression that this variable is more than a simple flag
-		// and true/false are also more explicit.
 		uint8_t 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.
 	};
 
-	typedef std::map<DeviceCommandId_t, DeviceReplyInfo> DeviceReplyMap;
-	typedef DeviceReplyMap::iterator DeviceReplyIter;
+	using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
+	using DeviceReplyIter = DeviceReplyMap::iterator;
 
 	/**
 	 * The MessageQueue used to receive device handler commands and to send replies.
@@ -610,7 +668,7 @@ protected:
 	 * Optional Error code
 	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
 	 */
-	ReturnValue_t childTransitionFailure = RETURN_OK;
+	ReturnValue_t childTransitionFailure;
 
 	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
 
@@ -622,35 +680,13 @@ protected:
 
 	bool switchOffWasReported; //!< Indicates if SWITCH_WENT_OFF was already thrown.
 
-	PeriodicTaskIF* executingTask;//!< Pointer to the task which executes this component, is invalid before setTaskIF was called.
+	PeriodicTaskIF* executingTask = nullptr;//!< Pointer to the task which executes this component, is invalid before setTaskIF was called.
 
 	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.
-
-	/**
-	 * Set the device handler mode
-	 *
-	 * Sets #timeoutStart with every call.
-	 *
-	 * Sets #transitionTargetMode if necessary so transitional states can be entered from everywhere without breaking the state machine
-	 * (which relies on a correct #transitionTargetMode).
-	 *
-	 * The submode is left unchanged.
-	 *
-	 *
-	 * @param newMode
-	 */
-	void setMode(Mode_t newMode);
-
-	/**
-	 * @overload
-	 * @param submode
-	 */
-	void setMode(Mode_t newMode, Submode_t submode);
-
 	/**
 	 * Helper function to report a missed reply
 	 *
@@ -671,14 +707,30 @@ protected:
 	void replyReturnvalueToCommand(ReturnValue_t status,
 			uint32_t parameter = 0);
 
-	/**
-	 * Send reply to a command, differentiate between raw command
-	 * and normal command.
-	 * @param status
-	 * @param parameter
-	 */
 	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
 
+	/**
+	 * Set the device handler mode
+	 *
+	 * Sets #timeoutStart with every call.
+	 *
+	 * Sets #transitionTargetMode if necessary so transitional states can be
+	 * entered from everywhere without breaking the state machine
+	 * (which relies on a correct #transitionTargetMode).
+	 *
+	 * The submode is left unchanged.
+	 *
+	 *
+	 * @param newMode
+	 */
+	void setMode(Mode_t newMode);
+
+	/**
+	 * @overload
+	 * @param submode
+	 */
+	void setMode(Mode_t newMode, Submode_t submode);
+
 	/**
 	 * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
 	 *
@@ -708,55 +760,6 @@ protected:
 	 */
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
 
-	/**
-	 * This is a helper method to facilitate inserting entries in the command map.
-	 * @param deviceCommand	Identifier of the command to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the command waits until it times out.
-	 * @param periodic	Indicates if the reply is periodic (i.e. it is sent by the device repeatedly without request) or not.
-	 *		 			Default is aperiodic (0)
-	 * @param hasDifferentReplyId
-	 * @param replyId
-	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
-	 */
-	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0,
-			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
-	/**
-	 * This is a helper method to insert replies in the reply map.
-	 * @param deviceCommand	Identifier of the reply to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the reply waits until it times out.
-	 * @param periodic	Indicates if the command is periodic (i.e. it is sent by the device repeatedly without request) or not.
-	 *		 			Default is aperiodic (0)
-	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
-	 */
-	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0);
-	/**
-	 * A simple command to add a command to the commandList.
-	 * @param deviceCommand The command to add
-	 * @return RETURN_OK if the command was successfully inserted, RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
-	/**
-	 * This is a helper method to facilitate updating entries in the reply map.
-	 * @param deviceCommand		Identifier of the reply to update.
-	 * @param delayCycles		The current number of delay cycles to wait. As stated in #fillCommandAndCookieMap, to disable periodic commands, this is set to zero.
-	 * @param maxDelayCycles	The maximum number of delay cycles the reply waits until it times out. By passing 0 the entry remains untouched.
-	 * @param periodic			Indicates if the command is periodic (i.e. it is sent by the device repeatedly without request) or not.
-	 *		 					Default is aperiodic (0). Warning: The setting always overrides the value that was entered in the map.
-	 * @return	RETURN_OK when the reply was successfully updated, COMMAND_MAP_ERROR else.
-	 */
-	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
-			uint16_t delayCycles, uint16_t maxDelayCycles,
-			uint8_t periodic = 0);
-	/**
-	 * Returns the delay cycle count of a reply.
-	 * A count != 0 indicates that the command is already executed.
-	 * @param deviceCommand	The command to look for
-	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
-	 */
-	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
-
 	/**
 	 * Is the combination of mode and submode valid?
 	 *
@@ -776,6 +779,7 @@ protected:
 	 *
 	 * @return The Rmap action to execute in this step
 	 */
+
 	virtual CommunicationAction_t getComAction();
 
 	/**
@@ -798,6 +802,14 @@ protected:
 	 */
 	virtual ReturnValue_t buildChildRawCommand();
 
+	/**
+	 * Returns the delay cycle count of a reply.
+	 * A count != 0 indicates that the command is already executed.
+	 * @param deviceCommand	The command to look for
+	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
+	 */
+	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
+
 	/**
 	 * Construct a command reply containing a raw reply.
 	 *
@@ -861,6 +873,14 @@ protected:
 	 */
 	ReturnValue_t getStateOfSwitches(void);
 
+	/**
+	 * set all datapool variables that are update periodically in normal mode invalid
+	 *
+	 * Child classes should provide an implementation which sets all those variables invalid
+	 * which are set periodically during any normal mode.
+	 */
+	virtual void setNormalDatapoolEntriesInvalid() = 0;
+
 	/**
 	 * build a list of sids and pass it to the #hkSwitcher
 	 */
@@ -889,6 +909,7 @@ protected:
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 	virtual void setToExternalControl();
 	virtual void announceMode(bool recursive);
+
 	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
 	/**
@@ -954,13 +975,12 @@ protected:
 	DeviceCommandMap deviceCommandMap;
 
 	ActionHelper actionHelper;
-
 private:
 
 	/**
 	 * State a cookie is in.
 	 *
-	 * Used to keep track of the state of the communication.
+	 * Used to keep track of the state of the RMAP communication.
 	 */
 	enum CookieState_t {
 		COOKIE_UNUSED,    //!< The Cookie is unused
@@ -1034,20 +1054,22 @@ private:
 	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
 	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
 	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
-	 * - Maybe export this into own class to increase modularity of software
-	 *   and reduce the massive class size ?
 	 */
 	void doStateMachine(void);
 
 	void buildRawDeviceCommand(CommandMessage* message);
 	void buildInternalCommand(void);
 
+//	/**
+//	 * Send a reply with the current mode and submode.
+//	 */
+//	void announceMode(void);
+
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
 	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
 	 * but not received).
-	 * In case the reply is periodic, the counter is simply set back to a specified value.
 	 */
 	void decrementDeviceReplyMap(void);
 
@@ -1114,8 +1136,8 @@ private:
 	 *   - @c RETURN_FAILED IPCStore is NULL
 	 *   - the return value from the IPCStore if it was not @c RETURN_OK
 	 */
-	ReturnValue_t getStorageData(store_address_t storageAddress,
-			uint8_t ** data, size_t * len);
+	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
+			uint32_t *len);
 
 	/**
 	 * set all switches returned by getSwitches()
@@ -1144,16 +1166,9 @@ private:
 	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
 	 *     - @c returnvalues of RMAPChannelIF::isActive()
 	 */
-	//ReturnValue_t switchCookieChannel(object_id_t newChannelId);
+	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
-	/**
-	 * Handle device handler messages (e.g. commands sent by PUS Service 2)
-	 * @param message
-	 * @return
-	 */
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
-
-
 };
 
 #endif /* DEVICEHANDLERBASE_H_ */
diff --git a/housekeeping/HasHkPoolParametersIF.h b/housekeeping/HasHkPoolParametersIF.h
new file mode 100644
index 000000000..5ec9beef6
--- /dev/null
+++ b/housekeeping/HasHkPoolParametersIF.h
@@ -0,0 +1,32 @@
+#ifndef FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
+#define FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
+#include <framework/datapool/PoolEntryIF.h>
+#include <framework/ipc/MessageQueueSenderIF.h>
+#include <map>
+
+class HousekeepingManager;
+/**
+ * @brief	Type definition for local pool entries.
+ */
+using lp_id_t = uint32_t;
+using LocalDataPoolMap =  std::map<lp_id_t, PoolEntryIF*>;
+using LocalDataPoolMapIter = LocalDataPoolMap::iterator;
+
+/**
+ * @brief 	Interface for the local housekeeping managers used by the device
+ * 			handler.
+ */
+class HasHkPoolParametersIF {
+public:
+	virtual~ HasHkPoolParametersIF() {};
+
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ReturnValue_t initializeHousekeepingPoolEntries(
+			LocalDataPoolMap& localDataPoolMap) = 0;
+	virtual float setMinimalHkSamplingFrequency() = 0;
+	virtual HousekeepingManager* getHkManagerHandle() = 0;
+};
+
+
+
+#endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */
diff --git a/housekeeping/HousekeepingManager.cpp b/housekeeping/HousekeepingManager.cpp
new file mode 100644
index 000000000..05df0ffcf
--- /dev/null
+++ b/housekeeping/HousekeepingManager.cpp
@@ -0,0 +1,50 @@
+#include <framework/housekeeping/HousekeepingManager.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/ipc/MutexFactory.h>
+#include <framework/ipc/MutexHelper.h>
+
+HousekeepingManager::HousekeepingManager(HasHkPoolParametersIF* owner) {
+	//todo :: nullptr check owner.
+	if(owner == nullptr) {
+		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
+		std::exit(0);
+	}
+	this->owner = owner;
+	mutex = MutexFactory::instance()->createMutex();
+	owner->setMinimalHkSamplingFrequency();
+}
+
+HousekeepingManager::~HousekeepingManager() {}
+
+ReturnValue_t HousekeepingManager::initializeHousekeepingPoolEntriesOnce() {
+	if(not mapInitialized) {
+		ReturnValue_t result = owner->initializeHousekeepingPoolEntries(localDpMap);
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			mapInitialized = true;
+		}
+		return result;
+	}
+	sif::warning << "hk manager says no" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t HousekeepingManager::handleHousekeepingMessage(
+		CommandMessage *message) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MutexIF* HousekeepingManager::getMutexHandle() {
+	return mutex;
+}
+
+void HousekeepingManager::setMinimalSamplingFrequency(float frequencySeconds) {
+	this->samplingFrequency = frequencySeconds;
+
+}
+
+void HousekeepingManager::generateHousekeepingPacket(DataSetIF *dataSet) {
+}
+
+void HousekeepingManager::setHkPacketQueue(MessageQueueIF *msgQueue) {
+	this->hkPacketQueue = msgQueue;
+}
diff --git a/housekeeping/HousekeepingManager.h b/housekeeping/HousekeepingManager.h
new file mode 100644
index 000000000..feec69fc0
--- /dev/null
+++ b/housekeeping/HousekeepingManager.h
@@ -0,0 +1,95 @@
+#ifndef FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_
+#define FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_
+#include <framework/datapool/DataSetIF.h>
+#include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/housekeeping/HasHkPoolParametersIF.h>
+#include <framework/ipc/MutexIF.h>
+
+#include <framework/datapool/PoolEntry.h>
+#include <framework/ipc/CommandMessage.h>
+#include <framework/ipc/MessageQueueIF.h>
+#include <framework/ipc/MutexHelper.h>
+
+#include <map>
+
+
+class HousekeepingManager {
+public:
+	static constexpr float MINIMAL_SAMPLING_FREQUENCY = 0.2;
+
+	HousekeepingManager(HasHkPoolParametersIF* owner);
+	virtual~ HousekeepingManager();
+
+	MutexIF* getMutexHandle();
+
+	// propably will just call respective local data set functions.
+	void generateHousekeepingPacket(DataSetIF* dataSet);
+	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
+
+	/**
+	 * Read a variable by supplying its local pool ID and assign the pool
+	 * entry to the supplied PoolEntry pointer. The type of the pool entry
+	 * is deduced automatically. This call is not thread-safe!
+	 * @tparam T Type of the pool entry
+	 * @param localPoolId Pool ID of the variable to read
+	 * @param poolVar [out] Corresponding pool entry will be assigned to the
+	 * 						supplied pointer.
+	 * @return
+	 */
+	template <class T>
+	ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> *poolEntry);
+	void setMinimalSamplingFrequency(float frequencySeconds);
+
+	/**
+	 * This function is used to fill the local data pool map with pool
+	 * entries. The default implementation is empty.
+	 * @param localDataPoolMap
+	 * @return
+	 */
+	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
+
+	void setHkPacketQueue(MessageQueueIF* msgQueue);
+private:
+	//! this depends on the PST frequency.. maybe it would be better to just
+	//! set this manually with a global configuration value which is also
+	//! passed to the PST. Or force setting this in device handler.
+	float samplingFrequency = MINIMAL_SAMPLING_FREQUENCY;
+
+	//! This is the map holding the actual data. Should only be initialized
+	//! once !
+	bool mapInitialized = false;
+	LocalDataPoolMap localDpMap;
+
+	//! Every housekeeping data manager has a mutex to protect access
+	//! to it's data pool.
+	MutexIF * mutex = nullptr;
+
+	//! The class which actually owns the manager (and its datapool).
+	HasHkPoolParametersIF* owner = nullptr;
+
+	//! Used for replies.
+	//! (maybe we dont need this, the sender can be retrieved from command
+	//! message..)
+	MessageQueueIF* hkReplyQueue = nullptr;
+	//! Used for HK packets, which are generated without requests.
+	MessageQueueIF* hkPacketQueue = nullptr;
+};
+
+template<class T> inline
+ReturnValue_t HousekeepingManager::fetchPoolEntry(lp_id_t localPoolId,
+		PoolEntry<T> *poolEntry) {
+	auto poolIter = localDpMap.find(localPoolId);
+	if (poolIter == localDpMap.end()) {
+		// todo: special returnvalue.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
+	if(poolEntry == nullptr) {
+		// todo: special returnvalue.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+#endif /* FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_ */
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
new file mode 100644
index 000000000..65d87e9ee
--- /dev/null
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -0,0 +1,10 @@
+#include <framework/housekeeping/HousekeepingMessage.h>
+
+void HousekeepingMessage::setAddHkReportStructMessage(CommandMessage *message,
+		set_t setId, store_address_t packet) {
+	message->setCommand(ADD_HK_REPORT_STRUCT);
+	message->setParameter(setId);
+	message->setParameter2(packet.raw);
+}
+
+//void Housekeeping
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
new file mode 100644
index 000000000..80dc83a6c
--- /dev/null
+++ b/housekeeping/HousekeepingMessage.h
@@ -0,0 +1,87 @@
+#ifndef FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
+#define FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
+#include <framework/ipc/CommandMessage.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <limits>
+
+/**
+ * the sid consists of the target object ID and... something else I forgot.
+ * Propably a special HK id to distinguish multiple hk pool packages
+ * inside a handler or controller
+ */
+typedef uint32_t set_t;
+
+union sid_t {
+	static constexpr uint64_t INVALID_ADDRESS = std::numeric_limits<uint64_t>::max();
+	sid_t(): raw(INVALID_ADDRESS) {}
+
+	struct {
+		object_id_t objectId ;
+		set_t hkId;
+	};
+	/**
+	 * Alternative access to the raw value.
+	 */
+	uint64_t raw;
+};
+class HousekeepingMessage {
+public:
+	/**
+	 * No instances of a message shall be created, instead
+	 * a CommandMessage instance is manipulated.
+	 */
+	HousekeepingMessage() = delete;
+	HousekeepingMessage(const HousekeepingMessage&) = delete;
+	HousekeepingMessage operator=(const HousekeepingMessage &) = delete;
+
+	static constexpr uint8_t MESSAGE_ID = MESSAGE_TYPE::HOUSEKEEPING;
+	static constexpr Command_t ADD_HK_REPORT_STRUCT =
+			MAKE_COMMAND_ID(1);
+	static constexpr Command_t ADD_DIAGNOSTICS_REPORT_STRUCT =
+			MAKE_COMMAND_ID(2);
+
+	static constexpr Command_t DELETE_HK_REPORT_STRUCT = MAKE_COMMAND_ID(3);
+	static constexpr Command_t DELETE_DIAGNOSTICS_REPORT_STRUCT =
+			MAKE_COMMAND_ID(4);
+
+	static constexpr Command_t ENABLE_PERIODIC_HK_GENERATION =
+			MAKE_COMMAND_ID(5);
+	static constexpr Command_t DISABLE_PERIODIC_HK_REPORT_GENERATION =
+			MAKE_COMMAND_ID(6);
+
+	static constexpr Command_t ENABLE_PERIODIC_DIAGNOSTICS_GENERATION =
+			MAKE_COMMAND_ID(7);
+	static constexpr Command_t DISABLE_PERIODIC_DIAGNOSTICS_GENERATION =
+			MAKE_COMMAND_ID(8);
+
+	static constexpr Command_t REPORT_HK_REPORT_STRUCTURES = MAKE_COMMAND_ID(9);
+	static constexpr Command_t REPORT_DIAGNOSTICS_REPORT_STRUCTURES =
+			MAKE_COMMAND_ID(11);
+
+	static constexpr Command_t HK_DEFINITIONS_REPORT = MAKE_COMMAND_ID(10);
+	static constexpr Command_t DIAGNOSTICS_DEFINITION_REPORT = MAKE_COMMAND_ID(12);
+
+	static constexpr Command_t HK_REPORT = MAKE_COMMAND_ID(25);
+	static constexpr Command_t DIAGNOSTICS_REPORT = MAKE_COMMAND_ID(26);
+
+	static constexpr Command_t GENERATE_ONE_PARAMETER_REPORT  =
+			MAKE_COMMAND_ID(27);
+	static constexpr Command_t GENERATE_ONE_DIAGNOSTICS_REPORT =
+			MAKE_COMMAND_ID(28);
+
+	static constexpr Command_t APPEND_PARAMETERS_TO_PARAMETER_REPORT_STRUCTURE =
+			MAKE_COMMAND_ID(29);
+	static constexpr Command_t APPEND_PARAMETERS_TO_DIAGNOSTICS_REPORT_STRUCTURE =
+			MAKE_COMMAND_ID(30);
+
+	static constexpr Command_t MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL =
+			MAKE_COMMAND_ID(31);
+	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
+			MAKE_COMMAND_ID(32);
+
+	static void setAddHkReportStructMessage(CommandMessage* message,
+			set_t setId, store_address_t packet);
+};
+
+
+#endif /* FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_ */
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 81c4a0e58..72ba434a9 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,6 +1,6 @@
 #include "InternalErrorReporter.h"
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PoolVariable.h>
 #include <framework/ipc/MutexFactory.h>
 
@@ -20,13 +20,13 @@ InternalErrorReporter::~InternalErrorReporter() {
 
 ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 
-	DataSet mySet;
-	PoolVariable<uint32_t> queueHitsInPool(queuePoolId, &mySet,
+	GlobDataSet mySet;
+	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
 			PoolVariableIF::VAR_READ_WRITE);
-	PoolVariable<uint32_t> tmHitsInPool(tmPoolId, &mySet,
+	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
 			PoolVariableIF::VAR_READ_WRITE);
 
-	PoolVariable<uint32_t> storeHitsInPool(storePoolId, &mySet,
+	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
 			PoolVariableIF::VAR_READ_WRITE);
 	mySet.read();
 
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 796226452..d66e956d1 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,7 +1,7 @@
 #ifndef MONITORBASE_H_
 #define MONITORBASE_H_
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PIDReader.h>
 #include <framework/monitoring/LimitViolationReporter.h>
 #include <framework/monitoring/MonitoringIF.h>
@@ -48,7 +48,7 @@ public:
 
 protected:
 	virtual ReturnValue_t fetchSample(T* sample) {
-		DataSet mySet;
+		GlobDataSet mySet;
 		PIDReader<T> parameter(this->parameterId, &mySet);
 		mySet.read();
 		if (!parameter.isValid()) {
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 04079bb06..eee919841 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -12,7 +12,7 @@ Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
 		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
 		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
 				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
-				DataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
+				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
 				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
 				ids.pidCurrent, &set), state(ids.pidState, &set), power(
 				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
diff --git a/power/Fuse.h b/power/Fuse.h
index aee03778a..a826a1255 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -1,7 +1,7 @@
 #ifndef FUSE_H_
 #define FUSE_H_
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PIDReader.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/monitoring/AbsLimitMonitor.h>
@@ -83,11 +83,11 @@ private:
 
 	};
 	PowerMonitor powerMonitor;
-	DataSet set;
+	GlobDataSet set;
 	PIDReader<float> voltage;
 	PIDReader<float> current;
 	PIDReader<uint8_t> state;
-	db_float_t power;
+	gp_float_t power;
 	MessageQueueIF* commandQueue;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index 922560d07..566f93ca0 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -1,7 +1,7 @@
 #ifndef POWERSENSOR_H_
 #define POWERSENSOR_H_
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PIDReader.h>
 #include <framework/datapool/PoolVariable.h>
 #include <framework/devicehandlers/HealthDevice.h>
@@ -53,12 +53,12 @@ private:
 	MessageQueueIF* commandQueue;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
-	DataSet set;
+	GlobDataSet set;
 	//Variables in
 	PIDReader<float> current;
 	PIDReader<float> voltage;
 	//Variables out
-	db_float_t power;
+	gp_float_t power;
 
 	static const uint8_t MODULE_ID_CURRENT = 1;
 	static const uint8_t MODULE_ID_VOLTAGE = 2;
diff --git a/thermal/CoreComponent.cpp b/thermal/CoreComponent.cpp
index 304712ef8..657e79cb0 100644
--- a/thermal/CoreComponent.cpp
+++ b/thermal/CoreComponent.cpp
@@ -2,7 +2,7 @@
 
 CoreComponent::CoreComponent(object_id_t reportingObjectId, uint8_t domainId,
 		uint32_t temperaturePoolId, uint32_t targetStatePoolId,
-		uint32_t currentStatePoolId, uint32_t requestPoolId, DataSet* dataSet,
+		uint32_t currentStatePoolId, uint32_t requestPoolId, GlobDataSet* dataSet,
 		AbstractTemperatureSensor* sensor,
 		AbstractTemperatureSensor* firstRedundantSensor,
 		AbstractTemperatureSensor* secondRedundantSensor,
@@ -18,14 +18,14 @@ CoreComponent::CoreComponent(object_id_t reportingObjectId, uint8_t domainId,
 				AbstractTemperatureSensor::ZERO_KELVIN_C), parameters(
 				parameters), temperatureMonitor(reportingObjectId,
 				domainId + 1,
-				DataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
+				GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
 				COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
 	if (thermalModule != NULL) {
 		thermalModule->registerComponent(this, priority);
 	}
 	//Set thermal state once, then leave to operator.
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetStatePoolId, &mySet,
+	GlobDataSet mySet;
+	gp_uint8_t writableTargetState(targetStatePoolId, &mySet,
 			PoolVariableIF::VAR_WRITE);
 	writableTargetState = initialTargetState;
 	mySet.commit(PoolVariableIF::VALID);
@@ -70,8 +70,8 @@ float CoreComponent::getLowerOpLimit() {
 }
 
 ReturnValue_t CoreComponent::setTargetState(int8_t newState) {
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
+	GlobDataSet mySet;
+	gp_uint8_t writableTargetState(targetState.getDataPoolId(),
 			&mySet, PoolVariableIF::VAR_READ_WRITE);
 	mySet.read();
 	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index da77c65b3..0b87d8890 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -1,7 +1,7 @@
 #ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
 #define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PoolVariable.h>
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/thermal/AbstractTemperatureSensor.h>
@@ -23,7 +23,7 @@ public:
 
 	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
 			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-			uint32_t requestPoolId, DataSet *dataSet,
+			uint32_t requestPoolId, GlobDataSet *dataSet,
 			AbstractTemperatureSensor *sensor,
 			AbstractTemperatureSensor *firstRedundantSensor,
 			AbstractTemperatureSensor *secondRedundantSensor,
@@ -58,10 +58,10 @@ protected:
 	AbstractTemperatureSensor *secondRedundantSensor;
 	ThermalModuleIF *thermalModule;
 
-	db_float_t temperature;
-	db_int8_t targetState;
-	db_int8_t currentState;
-	db_uint8_t heaterRequest;
+	gp_float_t temperature;
+	gp_int8_t targetState;
+	gp_int8_t currentState;
+	gp_uint8_t heaterRequest;
 
 	bool isHeating;
 
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index e65560cd6..65fa13a6f 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -1,7 +1,7 @@
 #ifndef THERMALMODULE_H_
 #define THERMALMODULE_H_
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PoolVariable.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/events/EventReportingProxyIF.h>
@@ -23,10 +23,10 @@ public:
 	};
 
 	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
-			uint32_t targetStatePoolId, DataSet *dataSet, Parameters parameters,
+			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
 			RedundantHeater::Parameters heaterParameters);
 
-	ThermalModule(uint32_t moduleTemperaturePoolId, DataSet *dataSet);
+	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
 
 	virtual ~ThermalModule();
 

From 5b8a6e35dcc3e36715e2eaa39345744e3b2ebaef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 13:37:50 +0200
Subject: [PATCH 0258/1774] renaming complete, pool in namespace

---
 datapool/PIDReader.h                 |  2 +-
 datapool/PoolRawAccess.cpp           |  4 ++--
 datapoolglob/DataPoolAdmin.cpp       | 10 +++++-----
 datapoolglob/GlobalDataPool.h        |  3 +++
 datapoolglob/GlobalDataSet.cpp       |  4 ++--
 datapoolglob/GlobalPoolVariable.tpp  |  4 ++--
 datapoolglob/GlobalPoolVector.h      |  4 ++--
 devicehandlers/DeviceHandlerBase.cpp |  2 +-
 devicehandlers/DeviceHandlerBase.h   |  3 ++-
 framework.mk                         |  2 ++
 thermal/TemperatureSensor.h          |  8 ++++----
 thermal/ThermalComponent.cpp         |  6 +++---
 thermal/ThermalComponent.h           |  2 +-
 thermal/ThermalModule.cpp            |  8 ++++----
 thermal/ThermalModule.h              |  6 +++---
 15 files changed, 37 insertions(+), 31 deletions(-)

diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index 3a815cee6..f83fa3b9f 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -17,7 +17,7 @@ protected:
 	uint8_t valid;
 	ReturnValue_t read() {
 		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(
+		PoolEntry<T>* read_out = glob::dataPool.getData<T>(
 				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
 		if (read_out != NULL) {
 			valid = read_out->valid;
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 97bdc2b39..aea84612a 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -19,7 +19,7 @@ PoolRawAccess::~PoolRawAccess() {
 }
 
 ReturnValue_t PoolRawAccess::read() {
-	PoolEntryIF* read_out = ::dataPool.getRawData(dataPoolId);
+	PoolEntryIF* read_out = glob::dataPool.getRawData(dataPoolId);
 	if (read_out != NULL) {
 		valid = read_out->getValid();
 		if (read_out->getSize() > arrayEntry) {
@@ -52,7 +52,7 @@ ReturnValue_t PoolRawAccess::read() {
 }
 
 ReturnValue_t PoolRawAccess::commit() {
-	PoolEntryIF* write_back = ::dataPool.getRawData(dataPoolId);
+	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
 	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
 		write_back->setValid(valid);
 		uint8_t array_position = arrayEntry * typeSize;
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 59bd9f308..2779ce5c3 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -38,7 +38,7 @@ ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
 
 	uint8_t valid = data[4];
 
-	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
 
 	GlobDataSet mySet;
 	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
@@ -90,8 +90,8 @@ void DataPoolAdmin::handleCommand() {
 
 ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 		const uint8_t* data, uint32_t size, uint8_t** dataPointer) {
-	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
 	GlobDataSet testSet;
 	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
 			PoolVariableIF::VAR_READ);
@@ -129,8 +129,8 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 
 ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
 		uint8_t** dataPointer, uint8_t* copyHere) {
-	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
 	GlobDataSet testSet;
 	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
 			PoolVariableIF::VAR_READ);
diff --git a/datapoolglob/GlobalDataPool.h b/datapoolglob/GlobalDataPool.h
index e0c086adc..42921a777 100644
--- a/datapoolglob/GlobalDataPool.h
+++ b/datapoolglob/GlobalDataPool.h
@@ -142,5 +142,8 @@ public:
 };
 
 //We assume someone globally instantiates a DataPool.
+namespace glob {
 extern GlobalDataPool dataPool;
+}
+
 #endif /* DATAPOOL_H_ */
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
index 7409dbbdc..6e09a3989 100644
--- a/datapoolglob/GlobalDataSet.cpp
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -111,11 +111,11 @@ ReturnValue_t GlobDataSet::handleUnreadDatasetCommit() {
 }
 
 ReturnValue_t GlobDataSet::unlockDataPool() {
-	return ::dataPool.freeDataPoolLock();
+	return glob::dataPool.freeDataPoolLock();
 }
 
 ReturnValue_t GlobDataSet::lockDataPool() {
-	return ::dataPool.lockDataPool();
+	return glob::dataPool.lockDataPool();
 }
 
 ReturnValue_t GlobDataSet::serialize(uint8_t** buffer, size_t* size,
diff --git a/datapoolglob/GlobalPoolVariable.tpp b/datapoolglob/GlobalPoolVariable.tpp
index 287f06dd6..21b648e67 100644
--- a/datapoolglob/GlobalPoolVariable.tpp
+++ b/datapoolglob/GlobalPoolVariable.tpp
@@ -13,7 +13,7 @@ inline GlobPoolVar<T>::GlobPoolVar(uint32_t set_id,
 
 template <class T>
 inline ReturnValue_t GlobPoolVar<T>::read() {
-	PoolEntry<T>* read_out = ::dataPool.getData<T>(dataPoolId, 1);
+	PoolEntry<T>* read_out = glob::dataPool.getData<T>(dataPoolId, 1);
 	if (read_out != NULL) {
 		valid = read_out->valid;
 		value = *(read_out->address);
@@ -29,7 +29,7 @@ inline ReturnValue_t GlobPoolVar<T>::read() {
 
 template <class T>
 inline ReturnValue_t GlobPoolVar<T>::commit() {
-	PoolEntry<T>* write_back = ::dataPool.getData<T>(dataPoolId, 1);
+	PoolEntry<T>* write_back = glob::dataPool.getData<T>(dataPoolId, 1);
 	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
 		write_back->valid = valid;
 		*(write_back->address) = value;
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 47381aec0..8d2488ea4 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -50,7 +50,7 @@ protected:
 	 * 			The operation does NOT provide any mutual exclusive protection by itself.
 	 */
 	ReturnValue_t read() {
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(this->dataPoolId,
+		PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
 				vector_size);
 		if (read_out != NULL) {
 			this->valid = read_out->valid;
@@ -74,7 +74,7 @@ protected:
 	 *
 	 */
 	ReturnValue_t commit() {
-		PoolEntry<T>* write_back = ::dataPool.getData<T>(this->dataPoolId,
+		PoolEntry<T>* write_back = glob::dataPool.getData<T>(this->dataPoolId,
 				vector_size);
 		if ((write_back != NULL) && (this->readWriteMode != VAR_READ)) {
 			write_back->valid = valid;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 0549bd45d..740bb383c 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1141,7 +1141,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 }
 
 ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
 	ReturnValue_t result = acceptExternalDeviceCommands();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 379992b1c..82cf6cab0 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -482,7 +482,8 @@ public:
 	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
 	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
+			MessageQueueId_t commandedBy, const uint8_t* data,
+			size_t size) override;
 	Mode_t getTransitionSourceMode() const;
 	Submode_t getTransitionSourceSubMode() const;
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
diff --git a/framework.mk b/framework.mk
index 6f64b7205..cb3e4f229 100644
--- a/framework.mk
+++ b/framework.mk
@@ -8,6 +8,8 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/controller/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoolglob/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/eventmatching/*.cpp)
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 96dedc991..cd2777842 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -2,7 +2,7 @@
 #define TEMPERATURESENSOR_H_
 
 #include <framework/thermal/AbstractTemperatureSensor.h>
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/monitoring/LimitMonitor.h>
 
 /**
@@ -68,12 +68,12 @@ public:
 	TemperatureSensor(object_id_t setObjectid,
 			inputType *inputValue, PoolVariableIF *poolVariable,
 			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
-			DataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
 			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
 			inputValue(inputValue), poolVariable(poolVariable),
 			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
 			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
-				DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
 				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
 				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
 			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
@@ -111,7 +111,7 @@ protected:
 
 	PoolVariableIF *poolVariable;
 
-	PoolVariable<float> outputTemperature;
+	gp_float_t outputTemperature;
 
 	LimitMonitor<limitType> sensorMonitor;
 
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index ffe7ba7b9..d70246621 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -3,7 +3,7 @@
 ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
 		uint8_t domainId, uint32_t temperaturePoolId,
 		uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-		uint32_t requestPoolId, DataSet* dataSet,
+		uint32_t requestPoolId, GlobDataSet* dataSet,
 		AbstractTemperatureSensor* sensor,
 		AbstractTemperatureSensor* firstRedundantSensor,
 		AbstractTemperatureSensor* secondRedundantSensor,
@@ -22,8 +22,8 @@ ThermalComponent::~ThermalComponent() {
 }
 
 ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
+	GlobDataSet mySet;
+	gp_int8_t writableTargetState(targetState.getDataPoolId(),
 			&mySet, PoolVariableIF::VAR_READ_WRITE);
 	mySet.read();
 	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index afe9aa10a..195f03b10 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -44,7 +44,7 @@ public:
 	 */
 	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
 			uint32_t targetStatePoolId, uint32_t currentStatePoolId, uint32_t requestPoolId,
-			DataSet *dataSet, AbstractTemperatureSensor *sensor,
+			GlobDataSet *dataSet, AbstractTemperatureSensor *sensor,
 			AbstractTemperatureSensor *firstRedundantSensor,
 			AbstractTemperatureSensor *secondRedundantSensor,
 			ThermalModuleIF *thermalModule, Parameters parameters,
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index 24a4c90d9..9dc1f2372 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -6,7 +6,7 @@
 
 ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
 		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
-		DataSet *dataSet, Parameters parameters,
+		GlobDataSet *dataSet, Parameters parameters,
 		RedundantHeater::Parameters heaterParameters) :
 		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
 				false), parameters(parameters), moduleTemperature(
@@ -16,7 +16,7 @@ ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
 	heater = new RedundantHeater(heaterParameters);
 }
 
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, DataSet* dataSet) :
+ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
 		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
 				false), parameters( { 0, 0 }), moduleTemperature(
 				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
@@ -250,8 +250,8 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 }
 
 void ThermalModule::setHeating(bool on) {
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
+	GlobDataSet mySet;
+	gp_int8_t writableTargetState(targetState.getDataPoolId(),
 			&mySet, PoolVariableIF::VAR_WRITE);
 	if (on) {
 		writableTargetState = STATE_REQUEST_HEATING;
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index 65fa13a6f..b9e8d8b83 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -70,12 +70,12 @@ protected:
 
 	Parameters parameters;
 
-	db_float_t moduleTemperature;
+	gp_float_t moduleTemperature;
 
 	RedundantHeater *heater;
 
-	db_int8_t currentState;
-	db_int8_t targetState;
+	gp_int8_t currentState;
+	gp_int8_t targetState;
 
 	std::list<AbstractTemperatureSensor *> sensors;
 	std::list<ComponentData> components;

From 9056ad36ed69575e499376558839d0bc044ca4d3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 14:13:31 +0200
Subject: [PATCH 0259/1774] object manager better output

---
 datapoolglob/GlobalPoolVector.h | 3 +++
 objectmanager/ObjectManager.cpp | 6 +++---
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 8d2488ea4..635369347 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -220,4 +220,7 @@ public:
 	}
 };
 
+template<typename T, uint16_t vectorSize>
+using gp_vec_t = GlobPoolVector<T, vectorSize>;
+
 #endif /* POOLVECTOR_H_ */
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 2f99e1a52..1912715dc 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -67,9 +67,9 @@ void ObjectManager::initialize() {
 		return_value = it->second->initialize();
 		if ( return_value != RETURN_OK ) {
 			object_id_t var = it->first;
-			sif::error << "Object " << std::hex <<  (int) var
-			        << " failed to initialize with code 0x" << return_value
-			        << std::dec << std::endl;
+			sif::error << "Object 0x" << std::hex <<  std::setw(8) <<
+					std::setfill('0')<< var << " failed to initialize " <<
+					"with code 0x" << return_value << std::dec << std::endl;
 			error_count++;
 		}
 	}

From e9a4056deb17756f70973d6f383182fbabdf90b2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 15:19:24 +0200
Subject: [PATCH 0260/1774] added DHB cookie init
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

(why was that never a problem beofre????) ¯\_(ツ)_/¯
---
 devicehandlers/DeviceHandlerBase.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 740bb383c..22224c123 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -23,8 +23,9 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-		deviceCommunicationId(deviceCommunication), deviceThermalStatePoolId(
-		thermalStatePoolId),deviceThermalRequestPoolId(thermalRequestPoolId),
+		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),

From da972e1b5823cde5cfdf4611e42736d6e8bf7b11 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 15:41:42 +0200
Subject: [PATCH 0261/1774] DHB improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 173 +++++------
 devicehandlers/DeviceHandlerBase.h   | 442 ++++++++++++++-------------
 2 files changed, 310 insertions(+), 305 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 710e97d78..63c7951ce 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,14 +1,14 @@
-#include <framework/datapool/DataSet.h>
-#include <framework/datapool/PoolVariable.h>
-#include <framework/datapool/PoolVector.h>
-#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
 #include <framework/devicehandlers/DeviceHandlerBase.h>
-#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
-#include <framework/globalfunctions/CRC.h>
 #include <framework/objectmanager/ObjectManager.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/subsystem/SubsystemBase.h>
 #include <framework/thermal/ThermalComponentIF.h>
+#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
+
+#include <framework/datapool/DataSet.h>
+#include <framework/datapool/PoolVariable.h>
+#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
+#include <framework/globalfunctions/CRC.h>
+#include <framework/subsystem/SubsystemBase.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
@@ -17,29 +17,29 @@ object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
-		object_id_t deviceCommunication, CookieIF * comCookie_,
+		object_id_t deviceCommunication, CookieIF * comCookie,
 		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
 		uint32_t thermalRequestPoolId, 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),
-		fdirInstance(fdirInstance), hkSwitcher(this),
-		defaultFDIRUsed(fdirInstance == nullptr), switchOffWasReported(false),
-		executingTask(nullptr), actionHelper(this, nullptr), cookieInfo(),
-		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
-{
-	commandQueue = QueueFactory::instance()->
-			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
+		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), cookieInfo(),
+		childTransitionDelay(5000),
+		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
+		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
+			CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
 	if (this->fdirInstance == nullptr) {
-		this->fdirInstance =
-				new DeviceHandlerFailureIsolation(setObjectId,
-						defaultFDIRParentId);
+		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
+				defaultFDIRParentId);
 	}
 }
 
@@ -53,7 +53,8 @@ DeviceHandlerBase::~DeviceHandlerBase() {
 
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	this->pstStep = counter;
-	if (counter == 0) {
+
+	if (getComAction() == SEND_WRITE) {
 		cookieInfo.state = COOKIE_UNUSED;
 		readCommandQueue();
 		doStateMachine();
@@ -66,7 +67,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	if (mode == MODE_OFF) {
 		return RETURN_OK;
 	}
-
 	switch (getComAction()) {
 	case SEND_WRITE:
 		if ((cookieInfo.state == COOKIE_UNUSED)) {
@@ -87,7 +87,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	default:
 		break;
 	}
-
 	return RETURN_OK;
 }
 
@@ -116,7 +115,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
 			AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
-	if (rawReceiver == nullptr) {
+	if (rawReceiver == NULL) {
 		return RETURN_FAILED;
 	}
 
@@ -166,6 +165,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	mySet.commit(PoolVariableIF::VALID);
 
 	return RETURN_OK;
+
 }
 
 void DeviceHandlerBase::decrementDeviceReplyMap() {
@@ -353,11 +353,11 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
 	info.delayCycles = 0;
 	info.replyLen = replyLen;
 	info.command = deviceCommandMap.end();
-	std::pair<DeviceReplyIter, bool> result = deviceReplyMap.emplace(replyId, info);
-	if (result.second) {
-		return RETURN_OK;
+	auto resultPair = deviceReplyMap.emplace(replyId, info);
+	if (resultPair.second) {
+		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return RETURN_FAILED;
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
 
@@ -366,11 +366,11 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
 	info.expectedReplies = 0;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
-	std::pair<DeviceCommandIter, bool> result = deviceCommandMap.emplace(deviceCommand,info);
-	if (result.second) {
-		return RETURN_OK;
+	auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
+	if (resultPair.second) {
+		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return RETURN_FAILED;
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
 
@@ -487,7 +487,7 @@ void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 		return;
 	}
 //Check if more replies are expected. If so, do nothing.
-	DeviceCommandInfo * info = &(iter->second.command->second);
+	DeviceCommandInfo* info = &(iter->second.command->second);
 	if (--info->expectedReplies == 0) {
 		//Check if it was transition or internal command. Don't send any replies in that case.
 		if (info->sendReplyTo != NO_COMMANDER) {
@@ -526,6 +526,7 @@ void DeviceHandlerBase::doGetWrite() {
 		if (wiretappingMode == RAW) {
 			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
 		}
+
 		//We need to distinguish here, because a raw command never expects a reply.
 		//(Could be done in eRIRM, but then child implementations need to be careful.
 		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
@@ -541,25 +542,22 @@ void DeviceHandlerBase::doGetWrite() {
 }
 
 void DeviceHandlerBase::doSendRead() {
-	ReturnValue_t result = RETURN_FAILED;
+	ReturnValue_t result;
+
 	size_t requestLen = 0;
-	// If the device handler can only request replies after a command
-	// has been sent, there should be only one reply enabled and the
-	// correct reply length will be mapped.
-	for(DeviceReplyIter iter = deviceReplyMap.begin();
-			iter != deviceReplyMap.end();iter++)
-	{
-		if(iter->second.delayCycles != 0) {
-			requestLen = iter->second.replyLen;
-			break;
-		}
+	DeviceReplyIter iter = deviceReplyMap.find(cookieInfo.pendingCommand->first);
+	if(iter != deviceReplyMap.end()) {
+		requestLen = iter->second.replyLen;
+	}
+	else {
+		requestLen = 0;
 	}
 
 	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
+
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
-	}
-	else {
+	} else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
 		//We can't inform anyone, because we don't know which command was sent last.
 		//So, we need to wait for a timeout.
@@ -583,8 +581,8 @@ void DeviceHandlerBase::doGetRead() {
 
 	cookieInfo.state = COOKIE_UNUSED;
 
-	result = communicationInterface->readReceivedMessage(comCookie, &receivedData,
-			&receivedDataLen);
+	result = communicationInterface->readReceivedMessage(comCookie,
+			&receivedData, &receivedDataLen);
 
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
@@ -644,7 +642,7 @@ void DeviceHandlerBase::doGetRead() {
 }
 
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
-		uint8_t ** data, size_t * len) {
+		uint8_t * *data, uint32_t * len) {
 	size_t lenTmp;
 
 	if (IPCStore == NULL) {
@@ -663,10 +661,8 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 		*len = 0;
 		return result;
 	}
-
 }
 
-
 void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		MessageQueueId_t sendTo, bool isCommand) {
 	if (IPCStore == NULL || len == 0) {
@@ -681,6 +677,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 	}
 
 	CommandMessage message;
+
 	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&message,
 			getObjectId(), address, isCommand);
 
@@ -690,14 +687,12 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 
 	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.
 	}
 }
 
 //Default child implementations
-
-DeviceHandlerBase::CommunicationAction_t DeviceHandlerBase::getComAction() {
+DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
 	switch (pstStep) {
 	case 0:
 		return SEND_WRITE;
@@ -762,8 +757,8 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 //			DeviceCommunicationIF>(newChannelId);
 //
 //	if (newCommunication != NULL) {
-//		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
-//				maxDeviceReplyLen, comParameter1, comParameter2);
+//		ReturnValue_t result = newCommunication->reOpen(cookie, ioBoardAddress,
+//				maxDeviceReplyLen);
 //		if (result != RETURN_OK) {
 //			return result;
 //		}
@@ -780,8 +775,8 @@ void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 		replyReturnvalueToCommand(result, RAW_COMMAND_ID);
 		storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
 	} else {
-		cookieInfo.pendingCommand = deviceCommandMap.
-				find((DeviceCommandId_t) RAW_COMMAND_ID);
+		cookieInfo.pendingCommand = deviceCommandMap.find(
+				(DeviceCommandId_t) RAW_COMMAND_ID);
 		cookieInfo.pendingCommand->second.isExecuting = true;
 		cookieInfo.state = COOKIE_WRITE_READY;
 	}
@@ -820,7 +815,7 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		iter = deviceReplyMap.find(command->first);
 	}
 	if (iter != deviceReplyMap.end()) {
-		DeviceReplyInfo * info = &(iter->second);
+		DeviceReplyInfo *info = &(iter->second);
 		info->delayCycles = info->maxDelayCycles;
 		info->command = command;
 		command->second.expectedReplies = expectedReplies;
@@ -846,9 +841,8 @@ ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
 	if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
 		while (numberOfSwitches > 0) {
-			if (powerSwitcher-> getSwitchState(switches[numberOfSwitches - 1])
-				== PowerSwitchIF::SWITCH_OFF)
-			{
+			if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1])
+					== PowerSwitchIF::SWITCH_OFF) {
 				return PowerSwitchIF::SWITCH_OFF;
 			}
 			numberOfSwitches--;
@@ -1032,7 +1026,6 @@ void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
 
 ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		CommandMessage * message) {
-	ReturnValue_t result;
 	switch (message->getCommand()) {
 	case DeviceHandlerMessage::CMD_WIRETAPPING:
 		switch (DeviceHandlerMessage::getWiretappingMode(message)) {
@@ -1054,21 +1047,19 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-	case DeviceHandlerMessage::CMD_SWITCH_ADDRESS:
-		if (mode != MODE_OFF) {
-			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-		} else {
-			// rework in progress
-			result = RETURN_OK;
-			//result = switchCookieChannel(
-			//		DeviceHandlerMessage::getIoBoardObjectId(message));
-			if (result == RETURN_OK) {
-				replyReturnvalueToCommand(RETURN_OK);
-			} else {
-				replyReturnvalueToCommand(CANT_SWITCH_ADDRESS);
-			}
-		}
-		return RETURN_OK;
+//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
+//		if (mode != MODE_OFF) {
+//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
+//		} else {
+//			result = switchCookieChannel(
+//					DeviceHandlerMessage::getIoBoardObjectId(message));
+//			if (result == RETURN_OK) {
+//				replyReturnvalueToCommand(RETURN_OK);
+//			} else {
+//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
+//			}
+//		}
+//		return RETURN_OK;
 	case DeviceHandlerMessage::CMD_RAW:
 		if ((mode != MODE_RAW)) {
 			DeviceHandlerMessage::clear(message);
@@ -1124,7 +1115,8 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 
 			// 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);
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
+			true);
 
 		}
 	} else { //unrequested/aperiodic replies
@@ -1152,7 +1144,6 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-
 	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
 	if (iter == deviceCommandMap.end()) {
 		result = COMMAND_NOT_SUPPORTED;
@@ -1171,7 +1162,7 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
 }
 
 void DeviceHandlerBase::buildInternalCommand(void) {
-	// Neither Raw nor Direct could build a command
+//Neither Raw nor Direct could build a command
 	ReturnValue_t result = NOTHING_TO_SEND;
 	DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
 	if (mode == MODE_NORMAL) {
@@ -1189,13 +1180,12 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 	} else {
 		return;
 	}
-
 	if (result == NOTHING_TO_SEND) {
 		return;
 	}
 	if (result == RETURN_OK) {
-		DeviceCommandMap::iterator iter =
-				deviceCommandMap.find(deviceCommandId);
+		DeviceCommandMap::iterator iter = deviceCommandMap.find(
+				deviceCommandId);
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
@@ -1210,7 +1200,6 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 			cookieInfo.state = COOKIE_WRITE_READY;
 		}
 	}
-
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
 	}
@@ -1285,8 +1274,8 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 			executingTask = task_;
 }
 
-void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t objectId, uint32_t parameter) {
-}
+// Default implementations empty.
+void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
+		object_id_t objectId, uint32_t parameter) {}
 
-void DeviceHandlerBase::performOperationHook() {
-}
+void DeviceHandlerBase::performOperationHook() {}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 25ec75b93..e7a8032d0 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,26 +1,23 @@
 #ifndef DEVICEHANDLERBASE_H_
 #define DEVICEHANDLERBASE_H_
 
-#include <framework/action/ActionHelper.h>
+#include <framework/objectmanager/SystemObject.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+#include <framework/devicehandlers/DeviceHandlerIF.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/action/HasActionsIF.h>
-#include <framework/datapool/DataSet.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/devicehandlers/DeviceCommunicationIF.h>
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/health/HealthHelper.h>
 #include <framework/modes/HasModesIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/parameters/ParameterHelper.h>
 #include <framework/power/PowerSwitchIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include <framework/datapool/HkSwitchHelper.h>
-#include <framework/devicehandlers/CookieIF.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
 #include <framework/ipc/MessageQueueIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
+
+#include <framework/action/ActionHelper.h>
+#include <framework/health/HealthHelper.h>
+#include <framework/parameters/ParameterHelper.h>
+#include <framework/datapool/HkSwitchHelper.h>
+#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
+
 #include <map>
 
 namespace Factory{
@@ -92,21 +89,22 @@ public:
 	 * The constructor passes the objectId to the SystemObject().
 	 *
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param maxDeviceReplyLen the largest allowed reply size
+	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
 	 * @param setDeviceSwitch the switch the device is connected to,
-	 *    for devices using two switches, overwrite getSwitches()
-	 * @param deviceCommuncation Communcation Interface object which is
-	 *    used to implement communication functions
+	 * for devices using two switches, overwrite getSwitches()
+	 * @param deviceCommuncation Communcation Interface object which is used
+	 * to implement communication functions
 	 * @param thermalStatePoolId
 	 * @param thermalRequestPoolId
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
 	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * comCookie_, uint8_t setDeviceSwitch,
+			CookieIF * comCookie, uint8_t setDeviceSwitch,
 			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
-			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
+			FailureIsolationBase* fdirInstance = nullptr,
+			size_t cmdQueueSize = 20);
 
 	/**
 	 * @brief 	This function is the device handler base core component and is
@@ -213,12 +211,13 @@ protected:
 	/**
 	 * Build the device command to send for normal mode.
 	 *
-	 * This is only called in @c MODE_NORMAL. If multiple submodes for @c MODE_NORMAL are supported,
-	 * different commands can built returned depending on the submode.
+	 * This is only called in @c MODE_NORMAL. If multiple submodes for
+	 * @c MODE_NORMAL are supported, different commands can built,
+	 * depending on the submode.
 	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 * If variable command frequence is required, a counter can be used and
-	 * the frequency in the reply map has to be set manually
+	 * #rawPacket and #rawPacketLen must be set by this method to the
+	 * packet to be sent. If variable command frequence is required, a counter
+	 * can be used and the frequency in the reply map has to be set manually
 	 * by calling updateReplyMap().
 	 *
 	 * @param[out] id the device command id that has been built
@@ -233,10 +232,13 @@ 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_TO_POWER_DOWN. So it is used by doStartUp()
+	 * and doShutDown() as well as doTransition()
 	 *
-	 * 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
-	 * and filling them in doStartUp(), doShutDown() and doTransition() so no modes have to be checked here.
+	 * 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
+	 * and filling them in doStartUp(), doShutDown() and doTransition() so no
+	 * modes have to be checked here.
 	 *
 	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
 	 *
@@ -266,6 +268,63 @@ protected:
 	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
 			const uint8_t * commandData, size_t commandDataLen) = 0;
 
+	/**
+	 * @brief Scans a buffer for a valid reply.
+	 * @details
+	 * This is used by the base class to check the data received for valid packets.
+	 * It only checks if a valid packet starts at @c start.
+	 * It also only checks the structural validy of the packet,
+	 * e.g. checksums lengths and protocol data. No information check is done,
+	 * e.g. range checks etc.
+	 *
+	 * Errors should be reported directly, the base class does NOT report any
+	 * errors based on the return value of this function.
+	 *
+	 * @param start start of remaining buffer to be scanned
+	 * @param len length of remaining buffer to be scanned
+	 * @param[out] foundId the id of the data found in the buffer.
+	 * @param[out] foundLen length of the data found. Is to be set in function,
+	 *                       buffer is scanned at previous position + foundLen.
+	 * @return
+	 *  - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
+	 *  - @c RETURN_FAILED no reply could be found starting at @c start,
+	 *    implies @c foundLen is not valid, base class will call scanForReply()
+	 *    again with ++start
+	 *  - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
+	 *    e.g. checksum error, implies @c foundLen is valid, can be used to
+	 *    skip some bytes
+	 *  - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
+	 *  - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of
+	 *    the packet
+	 *  - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
+	 *  - @c APERIODIC_REPLY if a valid reply is received that has not been
+	 *    requested by a command, but should be handled anyway
+	 *    (@see also fillCommandAndCookieMap() )
+	 */
+	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
+
+	/**
+	 * @brief Interpret a reply from the device.
+	 * @details
+	 * This is called after scanForReply() found a valid packet, it can be
+	 * assumed that the length and structure is valid.
+	 * This routine extracts the data from the packet into a DataSet and then
+	 * calls handleDeviceTM(), which either sends a TM packet or stores the
+	 * data in the DataPool depending on whether it was an external command.
+	 * No packet length is given, as it should be defined implicitly by the id.
+	 *
+	 * @param id the id found by scanForReply()
+	 * @param packet
+	 * @return
+	 *     - @c RETURN_OK when the reply was interpreted.
+	 *     - @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
 	 *	 	  called by the initialize() of the base class
@@ -312,85 +371,83 @@ protected:
 	virtual void fillCommandAndReplyMap() = 0;
 
 	/**
-	 * @brief Scans a buffer for a valid reply.
-	 * @details
-	 * This is used by the base class to check the data received for valid packets.
-	 * It only checks if a valid packet starts at @c start.
-	 * It also only checks the structural validy of the packet,
-	 * e.g. checksums lengths and protocol data.
-	 * No information check is done, e.g. range checks etc.
-	 *
-	 * Errors should be reported directly,  the base class does NOT report
-	 * any errors based on the returnvalue of this function.
-	 *
-	 * @param start start of remaining buffer to be scanned
-	 * @param len length of remaining buffer to be scanned
-	 * @param[out] foundId the id of the data found in the buffer.
-	 * @param[out] foundLen length of the data found. Is to be set in function,
-	 * buffer is scanned at previous position + foundLen.
-	 * @return
-	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *     - @c RETURN_FAILED no reply could be found starting at @c start,
-	 *             implies @c foundLen is not valid,
-	 *             base class will call scanForReply() again with ++start
-	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
-	 *             e.g. checksum error, implies @c foundLen is valid, can be used to skip some bytes
-	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
-	 *     - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of the packet
-	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
-	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been
-	 *             requested by a command, but should be handled anyway
-	 *             (@see also fillCommandAndCookieMap() )
+	 * This is a helper method to facilitate inserting entries in the command map.
+	 * @param deviceCommand	Identifier of the command to add.
+	 * @param maxDelayCycles The maximum number of delay cycles the command
+	 * waits until it times out.
+	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not. Default is aperiodic (0)
+	 * @return	- @c RETURN_OK when the command was successfully inserted,
+	 *          - @c RETURN_FAILED else.
 	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
-			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
+	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
+			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0,
+			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
 	/**
-	 * @brief Interpret a reply from the device.
-	 * @details
-	 * This is called after scanForReply() found a valid packet, it can be assumed that the length and structure is valid.
-	 * This routine extracts the data from the packet into a DataSet and then calls handleDeviceTM(), which either sends
-	 * a TM packet or stores the data in the DataPool depending on whether the it was an external command.
-	 * No packet length is given, as it should be defined implicitly by the id.
-	 *
-	 * @param id the id found by scanForReply()
-	 * @param packet
-	 * @return
-	 *     - @c RETURN_OK when the reply was interpreted.
-	 *     - @c RETURN_FAILED when the reply could not be interpreted, eg. logical errors or range violations occurred
+	 * @brief 	This is a helper method to insert replies in the reply map.
+	 * @param deviceCommand	Identifier of the reply to add.
+	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
+	 * until it times out.
+	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not. Default is aperiodic (0)
+	 * @return	- @c RETURN_OK when the command was successfully inserted,
+	 *          - @c RETURN_FAILED else.
 	 */
-	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet) = 0;
+	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
+			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0);
 
 	/**
-	 * set all datapool variables that are update periodically in normal mode invalid
-	 *
-	 * Child classes should provide an implementation which sets all those variables invalid
-	 * which are set periodically during any normal mode.
+	 * @brief 	A simple command to add a command to the commandList.
+	 * @param deviceCommand The command to add
+	 * @return - @c RETURN_OK when the command was successfully inserted,
+	 *         - @c RETURN_FAILED else.
 	 */
-	virtual void setNormalDatapoolEntriesInvalid() = 0;
+	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
+	/**
+	 * @brief 	This is a helper method to facilitate updating entries
+	 *        	in the reply map.
+	 * @param deviceCommand	Identifier of the reply to update.
+	 * @param delayCycles The current number of delay cycles to wait.
+	 * As stated in #fillCommandAndCookieMap, to disable periodic commands,
+	 * this is set to zero.
+	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
+	 * until it times out. By passing 0 the entry remains untouched.
+	 * @param periodic Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not.Default is aperiodic (0).
+	 * Warning: The setting always overrides the value that was entered in the map.
+	 * @return - @c RETURN_OK when the command was successfully inserted,
+	 *         - @c RETURN_FAILED else.
+	 */
+	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
+			uint16_t delayCycles, uint16_t maxDelayCycles,
+			uint8_t periodic = 0);
 
 	/**
 	 * @brief   Can be implemented by child handler to
 	 *          perform debugging
 	 * @details Example: Calling this in performOperation
 	 *          to track values like mode.
-	 * @param 	positionTracker Provide the child handler a way to know where the debugInterface was called
-	 * @param 	objectId Provide the child handler object Id to specify actions for spefic devices
-	 * @param 	parameter Supply a parameter of interest
+	 * @param positionTracker Provide the child handler a way to know
+	 * where the debugInterface was called
+	 * @param objectId Provide the child handler object Id to
+	 * specify actions for spefic devices
+	 * @param parameter Supply a parameter of interest
 	 * Please delete all debugInterface calls in DHB after debugging is finished !
 	 */
-	virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0, uint32_t parameter = 0);
+	virtual void debugInterface(uint8_t positionTracker = 0,
+			object_id_t objectId = 0, uint32_t parameter = 0);
 
 	/**
 	 * Get the time needed to transit from modeFrom to modeTo.
 	 *
 	 * Used for the following transitions:
 	 * modeFrom -> modeTo:
-	 *  - MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 *  - MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 *  - MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 *  - _MODE_START_UP -> MODE_ON (do not include time to set the switches, the base class got you covered)
+	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches,
+	 * the base class got you covered)
 	 *
 	 * The default implementation returns 0 !
 	 * @param modeFrom
@@ -408,40 +465,25 @@ protected:
 	 * @param[out] numberOfSwitches length of returned array
 	 * @return
 	 *      - @c RETURN_OK if the parameters were set
-	 *      - @c NO_SWITCH or any other returnvalue if no switches exist
+	 *      - @c RETURN_FAILED if no switches exist
 	 */
 	virtual ReturnValue_t getSwitches(const uint8_t **switches,
 			uint8_t *numberOfSwitches);
 
 	/**
-	 * Can be used to perform device specific periodic operations.
-	 * This is called on the SEND_READ step of the performOperation() call
+	 * @brief 	Hook function for child handlers which is called once per
+	 * 			performOperation(). Default implementation is empty.
 	 */
 	virtual void performOperationHook();
-
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
-
 public:
 	/**
 	 * @param parentQueueId
 	 */
 	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
-	/**
-	 * This function call handles the execution of external commands as required
-	 * by the HasActionIF.
-	 * @param actionId
-	 * @param commandedBy
-	 * @param data
-	 * @param size
-	 * @return
-	 */
 	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
-
+			MessageQueueId_t commandedBy, const uint8_t* data,
+			size_t size) override;
 	Mode_t getTransitionSourceMode() const;
 	Submode_t getTransitionSourceSubMode() const;
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
@@ -460,6 +502,28 @@ public:
 	virtual MessageQueueId_t getCommandQueue(void) const;
 
 protected:
+	/**
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
+	 */
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
+
+	/**
+	 * These returnvalues can be returned from abstract functions
+	 * to alter the behaviour of DHB.For error values, refer to
+	 * DeviceHandlerIF.h returnvalues.
+	 */
+	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(4);
+	// Returnvalues for scanForReply()
+	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5); //!< This is used to specify for replies from a device which are not replies to requests
+	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6); //!< Ignore parts of the received packet
+	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(7); //!< Ignore full received packet
+
+//	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
+//	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
+	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(10);
+	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(11);
+	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(12);
+
 	//Mode handling error Codes
 	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE1);
 	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE2);
@@ -475,7 +539,7 @@ protected:
 	/**
 	 * Size of the #rawPacket.
 	 */
-	size_t rawPacketLen = 0;
+	uint32_t rawPacketLen = 0;
 
 	/**
 	 * The mode the device handler is currently in.
@@ -502,7 +566,7 @@ protected:
 	 * 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
 	 */
-	enum WiretappingMode: uint8_t {
+	enum WiretappingMode {
 		OFF = 0, RAW = 1, TM = 2
 	} wiretappingMode;
 
@@ -543,21 +607,19 @@ protected:
 	/**
 	 * Communication object used for device communication
 	 */
-	DeviceCommunicationIF *communicationInterface = nullptr;
+	DeviceCommunicationIF * communicationInterface = nullptr;
 
 	/**
-	 * Cookie used for communication. This is passed to the communication
-	 * interface.
+	 * Cookie used for communication
 	 */
-	CookieIF *comCookie;
+	CookieIF * comCookie;
 
 	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.
 	};
-	typedef std::map<DeviceCommandId_t, DeviceCommandInfo> DeviceCommandMap;
-	typedef DeviceCommandMap::iterator DeviceCommandIter;
+	using DeviceCommandMap = std::map<DeviceCommandId_t, DeviceCommandInfo> ;
 
 	/**
 	 * @brief Information about expected replies
@@ -568,15 +630,12 @@ protected:
 		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
 		size_t replyLen = 0; //!< Expected size of the reply.
-		//(Robin): This is a flag, isnt it? could we declare it bool? uint8_t always
-		// gives away the impression that this variable is more than a simple flag
-		// and true/false are also more explicit.
 		uint8_t 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.
 	};
 
-	typedef std::map<DeviceCommandId_t, DeviceReplyInfo> DeviceReplyMap;
-	typedef DeviceReplyMap::iterator DeviceReplyIter;
+	using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
+	using DeviceReplyIter = DeviceReplyMap::iterator;
 
 	/**
 	 * The MessageQueue used to receive device handler commands and to send replies.
@@ -610,7 +669,7 @@ protected:
 	 * Optional Error code
 	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
 	 */
-	ReturnValue_t childTransitionFailure = RETURN_OK;
+	ReturnValue_t childTransitionFailure = HasReturnvaluesIF::RETURN_OK;
 
 	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
 
@@ -622,35 +681,13 @@ protected:
 
 	bool switchOffWasReported; //!< Indicates if SWITCH_WENT_OFF was already thrown.
 
-	PeriodicTaskIF* executingTask;//!< Pointer to the task which executes this component, is invalid before setTaskIF was called.
+	PeriodicTaskIF* executingTask = nullptr;//!< Pointer to the task which executes this component, is invalid before setTaskIF was called.
 
 	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.
-
-	/**
-	 * Set the device handler mode
-	 *
-	 * Sets #timeoutStart with every call.
-	 *
-	 * Sets #transitionTargetMode if necessary so transitional states can be entered from everywhere without breaking the state machine
-	 * (which relies on a correct #transitionTargetMode).
-	 *
-	 * The submode is left unchanged.
-	 *
-	 *
-	 * @param newMode
-	 */
-	void setMode(Mode_t newMode);
-
-	/**
-	 * @overload
-	 * @param submode
-	 */
-	void setMode(Mode_t newMode, Submode_t submode);
-
 	/**
 	 * Helper function to report a missed reply
 	 *
@@ -671,14 +708,30 @@ protected:
 	void replyReturnvalueToCommand(ReturnValue_t status,
 			uint32_t parameter = 0);
 
-	/**
-	 * Send reply to a command, differentiate between raw command
-	 * and normal command.
-	 * @param status
-	 * @param parameter
-	 */
 	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
 
+	/**
+	 * Set the device handler mode
+	 *
+	 * Sets #timeoutStart with every call.
+	 *
+	 * Sets #transitionTargetMode if necessary so transitional states can be
+	 * entered from everywhere without breaking the state machine
+	 * (which relies on a correct #transitionTargetMode).
+	 *
+	 * The submode is left unchanged.
+	 *
+	 *
+	 * @param newMode
+	 */
+	void setMode(Mode_t newMode);
+
+	/**
+	 * @overload
+	 * @param submode
+	 */
+	void setMode(Mode_t newMode, Submode_t submode);
+
 	/**
 	 * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
 	 *
@@ -708,55 +761,6 @@ protected:
 	 */
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
 
-	/**
-	 * This is a helper method to facilitate inserting entries in the command map.
-	 * @param deviceCommand	Identifier of the command to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the command waits until it times out.
-	 * @param periodic	Indicates if the reply is periodic (i.e. it is sent by the device repeatedly without request) or not.
-	 *		 			Default is aperiodic (0)
-	 * @param hasDifferentReplyId
-	 * @param replyId
-	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
-	 */
-	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0,
-			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
-	/**
-	 * This is a helper method to insert replies in the reply map.
-	 * @param deviceCommand	Identifier of the reply to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the reply waits until it times out.
-	 * @param periodic	Indicates if the command is periodic (i.e. it is sent by the device repeatedly without request) or not.
-	 *		 			Default is aperiodic (0)
-	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
-	 */
-	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0);
-	/**
-	 * A simple command to add a command to the commandList.
-	 * @param deviceCommand The command to add
-	 * @return RETURN_OK if the command was successfully inserted, RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
-	/**
-	 * This is a helper method to facilitate updating entries in the reply map.
-	 * @param deviceCommand		Identifier of the reply to update.
-	 * @param delayCycles		The current number of delay cycles to wait. As stated in #fillCommandAndCookieMap, to disable periodic commands, this is set to zero.
-	 * @param maxDelayCycles	The maximum number of delay cycles the reply waits until it times out. By passing 0 the entry remains untouched.
-	 * @param periodic			Indicates if the command is periodic (i.e. it is sent by the device repeatedly without request) or not.
-	 *		 					Default is aperiodic (0). Warning: The setting always overrides the value that was entered in the map.
-	 * @return	RETURN_OK when the reply was successfully updated, COMMAND_MAP_ERROR else.
-	 */
-	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
-			uint16_t delayCycles, uint16_t maxDelayCycles,
-			uint8_t periodic = 0);
-	/**
-	 * Returns the delay cycle count of a reply.
-	 * A count != 0 indicates that the command is already executed.
-	 * @param deviceCommand	The command to look for
-	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
-	 */
-	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
-
 	/**
 	 * Is the combination of mode and submode valid?
 	 *
@@ -776,6 +780,7 @@ protected:
 	 *
 	 * @return The Rmap action to execute in this step
 	 */
+
 	virtual CommunicationAction_t getComAction();
 
 	/**
@@ -798,6 +803,14 @@ protected:
 	 */
 	virtual ReturnValue_t buildChildRawCommand();
 
+	/**
+	 * Returns the delay cycle count of a reply.
+	 * A count != 0 indicates that the command is already executed.
+	 * @param deviceCommand	The command to look for
+	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
+	 */
+	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
+
 	/**
 	 * Construct a command reply containing a raw reply.
 	 *
@@ -861,6 +874,14 @@ protected:
 	 */
 	ReturnValue_t getStateOfSwitches(void);
 
+	/**
+	 * set all datapool variables that are update periodically in normal mode invalid
+	 *
+	 * Child classes should provide an implementation which sets all those variables invalid
+	 * which are set periodically during any normal mode.
+	 */
+	virtual void setNormalDatapoolEntriesInvalid() = 0;
+
 	/**
 	 * build a list of sids and pass it to the #hkSwitcher
 	 */
@@ -889,6 +910,7 @@ protected:
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 	virtual void setToExternalControl();
 	virtual void announceMode(bool recursive);
+
 	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
 	/**
@@ -954,13 +976,12 @@ protected:
 	DeviceCommandMap deviceCommandMap;
 
 	ActionHelper actionHelper;
-
 private:
 
 	/**
 	 * State a cookie is in.
 	 *
-	 * Used to keep track of the state of the communication.
+	 * Used to keep track of the state of the RMAP communication.
 	 */
 	enum CookieState_t {
 		COOKIE_UNUSED,    //!< The Cookie is unused
@@ -1034,20 +1055,22 @@ private:
 	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
 	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
 	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
-	 * - Maybe export this into own class to increase modularity of software
-	 *   and reduce the massive class size ?
 	 */
 	void doStateMachine(void);
 
 	void buildRawDeviceCommand(CommandMessage* message);
 	void buildInternalCommand(void);
 
+//	/**
+//	 * Send a reply with the current mode and submode.
+//	 */
+//	void announceMode(void);
+
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
 	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
 	 * but not received).
-	 * In case the reply is periodic, the counter is simply set back to a specified value.
 	 */
 	void decrementDeviceReplyMap(void);
 
@@ -1114,8 +1137,8 @@ private:
 	 *   - @c RETURN_FAILED IPCStore is NULL
 	 *   - the return value from the IPCStore if it was not @c RETURN_OK
 	 */
-	ReturnValue_t getStorageData(store_address_t storageAddress,
-			uint8_t ** data, size_t * len);
+	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
+			uint32_t *len);
 
 	/**
 	 * set all switches returned by getSwitches()
@@ -1144,16 +1167,9 @@ private:
 	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
 	 *     - @c returnvalues of RMAPChannelIF::isActive()
 	 */
-	//ReturnValue_t switchCookieChannel(object_id_t newChannelId);
+	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
-	/**
-	 * Handle device handler messages (e.g. commands sent by PUS Service 2)
-	 * @param message
-	 * @return
-	 */
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
-
-
 };
 
 #endif /* DEVICEHANDLERBASE_H_ */

From 9597a0121ba7177b7b18beca9319c37be0f230d7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 15:49:46 +0200
Subject: [PATCH 0262/1774] DHB update

---
 devicehandlers/DeviceHandlerBase.cpp | 9 +++++----
 devicehandlers/DeviceHandlerBase.h   | 4 +++-
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 63c7951ce..16be66faa 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -44,6 +44,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
+	//communicationInterface->close(cookie);
 	delete comCookie;
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
@@ -355,9 +356,9 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
 	info.command = deviceCommandMap.end();
 	auto resultPair = deviceReplyMap.emplace(replyId, info);
 	if (resultPair.second) {
-		return HasReturnvaluesIF::RETURN_OK;
+		return RETURN_OK;
 	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return RETURN_FAILED;
 	}
 }
 
@@ -368,9 +369,9 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
 	info.sendReplyTo = NO_COMMANDER;
 	auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
 	if (resultPair.second) {
-		return HasReturnvaluesIF::RETURN_OK;
+		return RETURN_OK;
 	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return RETURN_FAILED;
 	}
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index e7a8032d0..454f0751f 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -481,9 +481,11 @@ public:
 	 */
 	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
+	/** @brief 	Implementation required for HasActionIF */
 	ReturnValue_t executeAction(ActionId_t actionId,
 			MessageQueueId_t commandedBy, const uint8_t* data,
 			size_t size) override;
+
 	Mode_t getTransitionSourceMode() const;
 	Submode_t getTransitionSourceSubMode() const;
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
@@ -669,7 +671,7 @@ protected:
 	 * Optional Error code
 	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
 	 */
-	ReturnValue_t childTransitionFailure = HasReturnvaluesIF::RETURN_OK;
+	ReturnValue_t childTransitionFailure;
 
 	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
 

From 0467b6a1bf60481b74850096c60fc09304bb7ee6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 17:53:18 +0200
Subject: [PATCH 0263/1774] slight DHB improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 16be66faa..23ec1f189 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -12,6 +12,8 @@
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+#include <iomanip>
+
 object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
@@ -37,6 +39,12 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 			CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
+	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 "
+				"passing a dummy cookie instead!" << std::endl;
+	}
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
 				defaultFDIRParentId);
@@ -44,7 +52,6 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-	//communicationInterface->close(cookie);
 	delete comCookie;
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
@@ -646,8 +653,8 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 		uint8_t * *data, uint32_t * len) {
 	size_t lenTmp;
 
-	if (IPCStore == NULL) {
-		*data = NULL;
+	if (IPCStore == nullptr) {
+		*data = nullptr;
 		*len = 0;
 		return RETURN_FAILED;
 	}
@@ -658,7 +665,7 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 	} else {
 		triggerEvent(StorageManagerIF::GET_DATA_FAILED, result,
 				storageAddress.raw);
-		*data = NULL;
+		*data = nullptr;
 		*len = 0;
 		return result;
 	}

From 8b1fef730dcb4cd4f21c3f90121b1c6a74758f63 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 18:02:58 +0200
Subject: [PATCH 0264/1774] resolved conflict

---
 devicehandlers/DeviceHandlerBase.h | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index c48fbe5e8..454f0751f 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -614,11 +614,7 @@ protected:
 	/**
 	 * Cookie used for communication
 	 */
-<<<<<<< HEAD
-	CookieIF * comCookie = nullptr;
-=======
 	CookieIF * comCookie;
->>>>>>> mueller_framework
 
 	struct DeviceCommandInfo {
 		bool isExecuting; //!< Indicates if the command is already executing.

From 9da0b0b2b299b7abeb9b73dd8fdb624942de996c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 22:16:25 +0200
Subject: [PATCH 0265/1774] glob pool vec implementation in tpp file

---
 datapoolglob/GlobalPoolVector.h   | 270 ++++++++++++------------------
 datapoolglob/GlobalPoolVector.tpp |  83 +++++++++
 2 files changed, 186 insertions(+), 167 deletions(-)
 create mode 100644 datapoolglob/GlobalPoolVector.tpp

diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 635369347..d55fd777e 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -1,5 +1,5 @@
-#ifndef POOLVECTOR_H_
-#define POOLVECTOR_H_
+#ifndef GLOBALPOOLVECTOR_H_
+#define GLOBALPOOLVECTOR_H_
 
 #include <framework/datapool/DataSetIF.h>
 #include <framework/datapool/PoolEntry.h>
@@ -8,139 +8,79 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 /**
- * \brief	This is the access class for array-type data pool entries.
+ * @brief	This is the access class for array-type data pool entries.
  *
- * \details	To ensure safe usage of the data pool, operation is not done directly on the data pool
- * 			entries, but on local copies. This class provides simple type- and length-safe access
- * 			to vector-style data pool entries (i.e. entries with length > 1).
- * 			The class can be instantiated as read-write and read only.
- * 			It provides a commit-and-roll-back semantic, which means that no array entry in
- * 			the data pool is changed until the commit call is executed.
- * 			There are two template parameters:
- * 	\tparam	T This template parameter specifies the data type of an array entry. Currently, all
- * 			plain data types are supported, but in principle any type is possible.
- * 	\tparam vector_size	This template parameter specifies the vector size of this entry.
- * 			Using a template parameter for this is not perfect, but avoids dynamic memory allocation.
- *	\ingroup data_pool
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
  */
-template<typename T, uint16_t vector_size>
+template<typename T, uint16_t vectorSize>
 class GlobPoolVector: public PoolVariableIF {
-private:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-
-protected:
-	/**
-	 * \brief	This is a call to read the array's values from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies all array values and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type, size or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read() {
-		PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
-				vector_size);
-		if (read_out != NULL) {
-			this->valid = read_out->valid;
-			memcpy(this->value, read_out->address, read_out->getByteSize());
-
-			return HasReturnvaluesIF::RETURN_OK;
-
-		} else {
-			memset(this->value, 0, vector_size * sizeof(T));
-			sif::error << "PoolVector: read of DP Variable 0x" << std::hex
-					<< dataPoolId << std::dec << " failed." << std::endl;
-			this->valid = INVALID;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * \brief	The commit call copies the array values back to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit() {
-		PoolEntry<T>* write_back = glob::dataPool.getData<T>(this->dataPoolId,
-				vector_size);
-		if ((write_back != NULL) && (this->readWriteMode != VAR_READ)) {
-			write_back->valid = valid;
-			memcpy(write_back->address, this->value, write_back->getByteSize());
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
 public:
 	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 * \detials	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
-	 */
-	T value[vector_size];
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if no nullptr is passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but sets the
+	 * value attribute to default (0). The value is fetched within the
+	 * read() operation.
+	 * @param set_id
+	 * This is the id in the global data pool this instance of the access
+	 * class corresponds to.
+	 * @param dataSet
+	 * The data set in which the variable shall register itself. If nullptr,
+	 * the variable is not registered.
+	 * @param setWritable
+	 * If this flag is set to true, changes in the value attribute can be
+	 * written back to the data pool, otherwise not.
 	 */
 	GlobPoolVector(uint32_t set_id, DataSetIF* set,
-			ReadWriteMode_t setReadWriteMode) :
-			dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
-		memset(this->value, 0, vector_size * sizeof(T));
-		if (set != NULL) {
-			set->registerVariable(this);
-		}
-	}
+			ReadWriteMode_t setReadWriteMode);
+
 	/**
-	 * Copy ctor to copy classes containing Pool Variables.
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a local array of this type.
 	 */
-//	PoolVector(const PoolVector& rhs) {
-//		PoolVector<T, vector_size> temp(rhs.dataPoolId, rhs.)
-//		memcpy(value, rhs.value, sizeof(T)*vector_size);
-//	}
+	T value[vectorSize];
 	/**
-	 * \brief	The classes destructor is empty.
-	 * \details	If commit() was not called, the local value is
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
 	 * 			discarded and not written back to the data pool.
 	 */
-	~GlobPoolVector() {
-	}
-	;
+	~GlobPoolVector() {};
 	/**
-	 * \brief	The operation returns the number of array entries in this variable.
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
 	 */
 	uint8_t getSize() {
-		return vector_size;
+		return vectorSize;
 	}
 	/**
-	 * \brief	This operation returns the data pool id of the variable.
+	 * @brief	This operation returns the data pool id of the variable.
 	 */
 	uint32_t getDataPoolId() const {
 		return dataPoolId;
 	}
 	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
+	 * @brief This operation sets the data pool id of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
 	 */
 	void setDataPoolId(uint32_t poolId) {
 		dataPoolId = poolId;
@@ -151,9 +91,10 @@ public:
 	ReadWriteMode_t getReadWriteMode() const {
 		return readWriteMode;
 	}
-	;
+
+
 	/**
-	 * \brief	With this call, the valid information of the variable is returned.
+	 * @brief	With this call, the valid information of the variable is returned.
 	 */
 	bool isValid() const {
 		if (valid != INVALID)
@@ -161,65 +102,60 @@ public:
 		else
 			return false;
 	}
+	void setValid(uint8_t valid) {this->valid = valid;}
+	uint8_t getValid() {return valid;}
 
-	void setValid(uint8_t valid) {
-		this->valid = valid;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	T &operator [](int i) {
-		return value[i];
-	}
-
-	const T &operator [](int i) const {
-		return value[i];
-	}
-
-	GlobPoolVector<T, vector_size> &operator=(
-			GlobPoolVector<T, vector_size> newPoolVector) {
-
-		for (uint16_t i = 0; i < vector_size; i++) {
-			this->value[i] = newPoolVector.value[i];
-		}
-		return *this;
-	}
+	T &operator [](int i) {return value[i];}
+	const T &operator [](int i) const {return value[i];}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override {
-		uint16_t i;
-		ReturnValue_t result;
-		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
-					max_size, bigEndian);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
-	}
+			const size_t max_size, bool bigEndian) const override;
+	virtual size_t getSerializedSize() const override;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override {
-		uint16_t i;
-		ReturnValue_t result;
-		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
-					bigEndian);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
+			bool bigEndian) override;
+protected:
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies all array values
+	 * and the valid information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid. The operation does NOT provide
+	 * any mutual exclusive protection by itself.
+	 */
+	ReturnValue_t read();
+
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 */
+	ReturnValue_t commit();
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
 };
 
+#include <framework/datapoolglob/GlobalPoolVector.tpp>
+
 template<typename T, uint16_t vectorSize>
 using gp_vec_t = GlobPoolVector<T, vectorSize>;
 
diff --git a/datapoolglob/GlobalPoolVector.tpp b/datapoolglob/GlobalPoolVector.tpp
new file mode 100644
index 000000000..0b43191bd
--- /dev/null
+++ b/datapoolglob/GlobalPoolVector.tpp
@@ -0,0 +1,83 @@
+#ifndef GLOBALPOOLVECTOR_TPP_
+#define GLOBALPOOLVECTOR_TPP_
+
+
+template<typename T, uint16_t vectorSize>
+inline GlobPoolVector<T, vectorSize>::GlobPoolVector(uint32_t set_id,
+		DataSetIF* set, ReadWriteMode_t setReadWriteMode) :
+		dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
+	memset(this->value, 0, vectorSize * sizeof(T));
+	if (set != nullptr) {
+		set->registerVariable(this);
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::read() {
+	PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
+			vectorSize);
+	if (read_out != nullptr) {
+		this->valid = read_out->valid;
+		memcpy(this->value, read_out->address, read_out->getByteSize());
+
+		return HasReturnvaluesIF::RETURN_OK;
+
+	} else {
+		memset(this->value, 0, vectorSize * sizeof(T));
+		sif::error << "PoolVector: Read of DP Variable 0x" << std::hex
+				<< std::setw(8) << std::setfill('0') << dataPoolId <<
+				std::dec << " failed." << std::endl;
+		this->valid = INVALID;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::commit() {
+	PoolEntry<T>* writeBack = glob::dataPool.getData<T>(this->dataPoolId,
+			vectorSize);
+	if ((writeBack != nullptr) && (this->readWriteMode != VAR_READ)) {
+		writeBack->valid = valid;
+		memcpy(writeBack->address, this->value, writeBack->getByteSize());
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
+		size_t* size, const size_t max_size, bool bigEndian) const {
+	uint16_t i;
+	ReturnValue_t result;
+	for (i = 0; i < vectorSize; i++) {
+		result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
+				max_size, bigEndian);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline size_t GlobPoolVector<T, vectorSize>::getSerializedSize() const {
+	return vectorSize * SerializeAdapter<T>::getSerializedSize(value);
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::deSerialize(
+		const uint8_t** buffer, size_t* size, bool bigEndian) {
+	uint16_t i;
+	ReturnValue_t result;
+	for (i = 0; i < vectorSize; i++) {
+		result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
+				bigEndian);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+#endif

From 71f1722b886d002a0b8fe550771ee1ed4cde1cc3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 22:20:54 +0200
Subject: [PATCH 0266/1774] removed old poolVar file

---
 datapool/PoolVariable.h                 | 294 ------------------------
 datapoolglob/GlobalPoolVariable.h       |   4 +-
 datapoolglob/GlobalPoolVariable.tpp     |   5 +-
 datapoolglob/GlobalPoolVector.h         |   1 -
 devicehandlers/DeviceHandlerBase.cpp    |   2 +-
 internalError/InternalErrorReporter.cpp |   2 +-
 power/PowerSensor.h                     |   2 +-
 thermal/CoreComponent.h                 |   2 +-
 thermal/ThermalModule.h                 |   2 +-
 9 files changed, 11 insertions(+), 303 deletions(-)
 delete mode 100644 datapool/PoolVariable.h

diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
deleted file mode 100644
index f5442a25e..000000000
--- a/datapool/PoolVariable.h
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
- * \file	PoolVariable.h
- *
- * \brief	This file contains the PoolVariable class, which locally represents a non-array data pool variable.
- *
- * \date	10/17/2012
- *
- * \author	Bastian Baetz
- */
-
-#ifndef POOLVARIABLE_H_
-#define POOLVARIABLE_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-template<typename T, uint8_t n_var> class PoolVarList;
-
-/**
- * \brief	This is the access class for non-array data pool entries.
- *
- * \details	To ensure safe usage of the data pool, operation is not done directly on the data pool
- * 			entries, but on local copies. This class provides simple type-safe access to single
- * 			data pool entries (i.e. entries with length = 1).
- * 			The class can be instantiated as read-write and read only.
- * 			It provides a commit-and-roll-back semantic, which means that the variable's value in
- * 			the data pool is not changed until the commit call is executed.
- * 	\tparam	T The template parameter sets the type of the variable. Currently, all plain data types
- * 			are supported, but in principle any type is possible.
- *	\ingroup data_pool
- */
-template<typename T>
-class PoolVariable: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PoolVarList;
-protected:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read() {
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(dataPoolId, 1);
-		if (read_out != NULL) {
-			valid = read_out->valid;
-			value = *(read_out->address);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			value = 0;
-			valid = false;
-			sif::error << "PoolVariable: read of DP Variable 0x" << std::hex
-					<< dataPoolId << std::dec << " failed." << std::endl;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * \brief	The commit call writes back the variable's value to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit() {
-		PoolEntry<T>* write_back = ::dataPool.getData<T>(dataPoolId, 1);
-		if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-			write_back->valid = valid;
-			*(write_back->address) = value;
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * Empty ctor for List initialization
-	 */
-	PoolVariable() :
-			dataPoolId(PoolVariableIF::NO_PARAMETER), valid(
-					PoolVariableIF::INVALID), readWriteMode(VAR_READ), value(0) {
-
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 * \details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value;
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setReadWriteMode
-	 */
-	PoolVariable(uint32_t set_id, DataSetIF* dataSet,
-			ReadWriteMode_t setReadWriteMode) :
-			dataPoolId(set_id), valid(PoolVariableIF::INVALID), readWriteMode(
-					setReadWriteMode), value(0) {
-		if (dataSet != NULL) {
-			dataSet->registerVariable(this);
-		}
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-	PoolVariable(const PoolVariable& rhs) :
-			dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode(
-					rhs.readWriteMode), value(rhs.value) {
-	}
-
-	/**
-	 * \brief	The classes destructor is empty.
-	 * \details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolVariable() {
-
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid)
-			return true;
-		else
-			return false;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	void setValid(uint8_t valid) {
-		this->valid = valid;
-	}
-
-	operator T() {
-		return value;
-	}
-
-	operator T() const {
-		return value;
-	}
-
-	PoolVariable<T> &operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	PoolVariable<T> &operator=(PoolVariable<T> newPoolVariable) {
-		value = newPoolVariable.value;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
-				bigEndian);
-	}
-
-	virtual size_t getSerializedSize() const {
-		return SerializeAdapter<T>::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
-		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
-	}
-};
-
-typedef PoolVariable<uint8_t> db_uint8_t;
-typedef PoolVariable<uint16_t> db_uint16_t;
-typedef PoolVariable<uint32_t> db_uint32_t;
-typedef PoolVariable<int8_t> db_int8_t;
-typedef PoolVariable<int16_t> db_int16_t;
-typedef PoolVariable<int32_t> db_int32_t;
-typedef PoolVariable<uint8_t> db_bool_t;
-typedef PoolVariable<float> db_float_t;
-typedef PoolVariable<double> db_double_t;
-//Alternative (but I thing this is not as useful: code duplication, differences too small):
-
-//template <typename T>
-//class PoolReader : public PoolVariableIF {
-//private:
-//	uint32_t parameter_id;
-//	uint8_t valid;
-//public:
-//	T value;
-//	PoolReader( uint32_t set_id, DataSetIF* set ) : parameter_id(set_id), valid(false), value(0) {
-//		set->registerVariable( this );
-//	}
-//
-//	~PoolReader() {};
-//
-//	uint8_t commit() {
-//			return HasReturnvaluesIF::RETURN_OK;
-//	}
-//
-//	uint8_t read() {
-//		PoolEntry<T>* read_out = ::dataPool.getData<T>( parameter_id, 1 );
-//		if ( read_out != NULL ) {
-//			valid = read_out->valid;
-//			value = *(read_out->address);
-//			return HasReturnvaluesIF::RETURN_OK;
-//		} else {
-//			value = 0;
-//			valid = false;
-//			return CHECKOUT_FAILED;
-//		}
-//	}
-//	uint32_t getParameterId() { return parameter_id; }
-//	bool isWritable() { return false; };
-//	bool isValid() { if (valid) return true; else return false; }
-//};
-//
-//template <typename T>
-//class PoolWriter : public PoolVariableIF {
-//private:
-//	uint32_t parameter_id;
-//public:
-//	T value;
-//	PoolWriter( uint32_t set_id, DataSetIF* set ) : parameter_id(set_id), value(0) {
-//		set->registerVariable( this );
-//	}
-//
-//	~PoolWriter() {};
-//
-//	uint8_t commit() {
-//		PoolEntry<T>* write_back = ::dataPool.getData<T>( parameter_id, 1 );
-//		if ( write_back != NULL ) {
-//			write_back->valid = true;
-//			*(write_back->address) = value;
-//			return HasReturnvaluesIF::RETURN_OK;
-//		} else {
-//			return CHECKOUT_FAILED;
-//		}
-//	}
-//	uint8_t read() {
-//		PoolEntry<T>* read_out = ::dataPool.getData<T>( parameter_id, 1 );
-//		if ( read_out != NULL ) {
-//			value = *(read_out->address);
-//			return HasReturnvaluesIF::RETURN_OK;
-//		} else {
-//			value = 0;
-//			return CHECKOUT_FAILED;
-//		}
-//	}
-//	uint32_t getParameterId() { return parameter_id; }
-//	bool isWritable() { return true; };
-//	bool isValid() { return false; }
-//};
-
-#endif /* POOLVARIABLE_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index 9f80492be..eee9afc10 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -1,5 +1,5 @@
-#ifndef POOLVARIABLE_H_
-#define POOLVARIABLE_H_
+#ifndef GLOBALPOOLVARIABLE_H_
+#define GLOBALPOOLVARIABLE_H_
 
 #include <framework/datapool/DataSetIF.h>
 #include <framework/datapool/PoolVariableIF.h>
diff --git a/datapoolglob/GlobalPoolVariable.tpp b/datapoolglob/GlobalPoolVariable.tpp
index 21b648e67..d55ea4e02 100644
--- a/datapoolglob/GlobalPoolVariable.tpp
+++ b/datapoolglob/GlobalPoolVariable.tpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef GLOBALPOOLVARIABLE_TPP_
+#define GLOBALPOOLVARIABLE_TPP_
 
 template <class T>
 inline GlobPoolVar<T>::GlobPoolVar(uint32_t set_id,
@@ -82,3 +83,5 @@ template <class T>
 inline void GlobPoolVar<T>::setValid(uint8_t valid) {
 	this->valid = valid;
 }
+
+#endif
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index d55fd777e..24303457e 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -111,7 +111,6 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const override;
 	virtual size_t getSerializedSize() const override;
-
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) override;
 protected:
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 5bd4c56ed..f46f854b1 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -5,7 +5,7 @@
 #include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
 
 #include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapool/PoolVariable.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/devicehandlers/DeviceTmReportingWrapper.h>
 #include <framework/globalfunctions/CRC.h>
 #include <framework/subsystem/SubsystemBase.h>
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 72ba434a9..a1e966957 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,7 +1,7 @@
 #include "InternalErrorReporter.h"
 
 #include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapool/PoolVariable.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/ipc/MutexFactory.h>
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index 566f93ca0..f94088a8a 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -3,7 +3,7 @@
 
 #include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PIDReader.h>
-#include <framework/datapool/PoolVariable.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/monitoring/LimitMonitor.h>
 #include <framework/parameters/ParameterHelper.h>
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index 0b87d8890..a0736c714 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -2,7 +2,7 @@
 #define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
 
 #include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapool/PoolVariable.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/thermal/AbstractTemperatureSensor.h>
 #include <framework/thermal/ThermalModule.h>
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index b9e8d8b83..21414f15c 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -2,7 +2,7 @@
 #define THERMALMODULE_H_
 
 #include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapool/PoolVariable.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/events/EventReportingProxyIF.h>
 #include "ThermalModuleIF.h"

From 1d28e1398ea927a74a0fc492e4db468122d41afa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 23:41:28 +0200
Subject: [PATCH 0267/1774] DataSetBase class finished

---
 datapool/DataSetBase.cpp                | 148 ++++++++++++++++++++++++
 datapool/DataSetBase.h                  | 135 +++++++++++++++++++++
 datapool/DataSetIF.h                    |  21 ++++
 datapool/PIDReader.h                    |   2 +-
 datapool/PoolRawAccess.cpp              |   2 +-
 datapool/PoolRawAccessHelper.cpp        |   6 +-
 datapool/PoolRawAccessHelper.h          |   1 +
 datapool/PoolVariableIF.h               |   1 +
 datapoolglob/DataPoolAdmin.cpp          |   4 +-
 datapoolglob/GlobalDataSet.cpp          | 140 ++--------------------
 datapoolglob/GlobalDataSet.h            | 126 +++-----------------
 datapoolglob/GlobalPoolVariable.h       |   2 +-
 devicehandlers/DeviceHandlerBase.cpp    |   2 +-
 internalError/InternalErrorReporter.cpp |   2 +-
 power/Fuse.h                            |   1 +
 thermal/TemperatureSensor.h             |   1 +
 16 files changed, 344 insertions(+), 250 deletions(-)
 create mode 100644 datapool/DataSetBase.cpp
 create mode 100644 datapool/DataSetBase.h

diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
new file mode 100644
index 000000000..6ff2fc83f
--- /dev/null
+++ b/datapool/DataSetBase.cpp
@@ -0,0 +1,148 @@
+#include <framework/datapool/DataSetBase.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+DataSetBase::DataSetBase() {
+	for (uint8_t count = 0; count < DATA_SET_MAX_SIZE; count++) {
+		registeredVariables[count] = nullptr;
+	}
+}
+
+DataSetBase::~DataSetBase() {}
+
+ReturnValue_t DataSetBase::registerVariable(
+		PoolVariableIF *variable) {
+	if (state != States::DATA_SET_UNINITIALISED) {
+		sif::error << "DataSet::registerVariable: "
+				"Call made in wrong position." << std::endl;
+		return DataSetIF::DATA_SET_UNINITIALISED;
+	}
+	if (variable == nullptr) {
+		sif::error << "DataSet::registerVariable: "
+				"Pool variable is nullptr." << std::endl;
+		return DataSetIF::POOL_VAR_NULL;
+	}
+	if (fillCount >= DATA_SET_MAX_SIZE) {
+		sif::error << "DataSet::registerVariable: "
+				"DataSet is full." << std::endl;
+		return DataSetIF::DATA_SET_FULL;
+	}
+	registeredVariables[fillCount] = variable;
+	fillCount++;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataSetBase::read() {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	if (state == States::DATA_SET_UNINITIALISED) {
+		lockDataPool();
+		for (uint16_t count = 0; count < fillCount; count++) {
+			if (registeredVariables[count]->getReadWriteMode()
+					!= PoolVariableIF::VAR_WRITE
+					&& registeredVariables[count]->getDataPoolId()
+					!= PoolVariableIF::NO_PARAMETER) {
+				ReturnValue_t status = registeredVariables[count]->read();
+				if (status !=  HasReturnvaluesIF::RETURN_OK) {
+					result = INVALID_PARAMETER_DEFINITION;
+					break;
+				}
+			}
+		}
+		state = States::DATA_SET_WAS_READ;
+		unlockDataPool();
+	}
+	else {
+		sif::error << "DataSet::read(): "
+				"Call made in wrong position." << std::endl;
+		result = SET_WAS_ALREADY_READ;
+	}
+	return result;
+}
+
+ReturnValue_t DataSetBase::commit() {
+	if (state == States::DATA_SET_WAS_READ) {
+		handleAlreadyReadDatasetCommit();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return handleUnreadDatasetCommit();
+	}
+}
+
+ReturnValue_t DataSetBase::lockDataPool() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataSetBase::unlockDataPool() {
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+void DataSetBase::handleAlreadyReadDatasetCommit() {
+	lockDataPool();
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				!= PoolVariableIF::VAR_READ
+				&& registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			registeredVariables[count]->commit();
+		}
+	}
+	state = States::DATA_SET_UNINITIALISED;
+	unlockDataPool();
+}
+
+ReturnValue_t DataSetBase::handleUnreadDatasetCommit() {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	lockDataPool();
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				== PoolVariableIF::VAR_WRITE
+				&& registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			registeredVariables[count]->commit();
+		} else if (registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			if (result != COMMITING_WITHOUT_READING) {
+				sif::error << "DataSet::commit(): commit-without-read call made "
+						"with non write-only variable." << std::endl;
+				result = COMMITING_WITHOUT_READING;
+			}
+		}
+	}
+	state = States::DATA_SET_UNINITIALISED;
+	unlockDataPool();
+	return result;
+}
+
+ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
+		const size_t maxSize, bool bigEndian) const {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		result = registeredVariables[count]->serialize(buffer, size, maxSize,
+				bigEndian);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
+		bool bigEndian) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		result = registeredVariables[count]->deSerialize(buffer, size,
+				bigEndian);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+size_t DataSetBase::getSerializedSize() const {
+	uint32_t size = 0;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		size += registeredVariables[count]->getSerializedSize();
+	}
+	return size;
+}
diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
new file mode 100644
index 000000000..6b468c118
--- /dev/null
+++ b/datapool/DataSetBase.h
@@ -0,0 +1,135 @@
+#ifndef FRAMEWORK_DATAPOOL_DATASETBASE_H_
+#define FRAMEWORK_DATAPOOL_DATASETBASE_H_
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolVariableIF.h>
+
+/**
+ * @brief	The DataSetBase class manages a set of locally checked out variables.
+ * @details
+ * This class manages a list, where a set of local variables (or pool variables)
+ * are registered. They are checked-out (i.e. their values are looked
+ * up and copied) with the read call. After the user finishes working with the
+ * pool variables, he can write back all variable values to the pool with
+ * the commit call. The data set manages locking and freeing the data pool,
+ * to ensure that all values are read and written back at once.
+ *
+ * An internal state manages usage of this class. Variables may only be
+ * registered before the read call is made, and the commit call only
+ * after the read call.
+ *
+ * If pool variables are writable and not committed until destruction
+ * of the set, the DataSet class automatically sets the valid flag in the
+ * data pool to invalid (without) changing the variable's value.
+ *
+ * The base class lockDataPo
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class DataSetBase: public DataSetIF,
+		public SerializeIF,
+		public HasReturnvaluesIF {
+public:
+
+	/**
+	 * @brief	Creates an empty dataset. Use registerVariable or
+	 * 			supply a pointer to this dataset to PoolVariable
+	 * 			initializations to register pool variables.
+	 */
+	DataSetBase();
+	virtual~ DataSetBase();
+
+	/**
+	 * @brief	The read call initializes reading out all registered variables.
+	 * @details
+	 * It iterates through the list of registered variables and calls all read()
+	 * functions of the registered pool variables (which read out their values
+	 * from the data pool) which are not write-only.
+	 * In case of an error (e.g. a wrong data type, or an invalid data pool id),
+	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
+	 *
+	 * The data pool is locked during the whole read operation and
+	 * freed afterwards.The state changes to "was written" after this operation.
+	 * @return	- @c RETURN_OK if all variables were read successfully.
+	 * 			- @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
+	 * 					requested variable is invalid.
+	 * 			- @c SET_WAS_ALREADY_READ if read() is called twice without calling
+	 * 					commit() in between
+	 */
+	virtual ReturnValue_t read();
+
+	/**
+	 * @brief	The commit call initializes writing back the registered variables.
+	 * @details
+	 * It iterates through the list of registered variables and calls the
+	 * commit() method of the remaining registered variables (which write back
+	 * their values to the pool).
+	 *
+	 * The data pool is locked during the whole commit operation and
+	 * freed afterwards. The state changes to "was committed" after this operation.
+	 *
+	 * If the set does contain at least one variable which is not write-only commit()
+	 * can only be called after read(). If the set only contains variables which are
+	 * write only, commit() can be called without a preceding read() call.
+	 * @return	- @c RETURN_OK if all variables were read successfully.
+	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
+	 * 			  contains non write-only variables
+	 */
+	virtual ReturnValue_t commit();
+
+	/* DataSetIF implementation */
+	virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override;
+	/**
+	 * Provides the means to lock the underlying data structure to ensure
+	 * thread-safety. Default implementation is empty
+	 * @return Always returns -@c RETURN_OK
+	 */
+	virtual ReturnValue_t lockDataPool() override;
+	/**
+	 * Provides the means to unlock the underlying data structure to ensure
+	 * thread-safety. Default implementation is empty
+	 * @return Always returns -@c RETURN_OK
+	 */
+	virtual ReturnValue_t unlockDataPool() override;
+
+	/* SerializeIF implementations */
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				const size_t maxSize, bool bigEndian) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override;
+
+	//SHOULDDO we could use a linked list of datapool variables
+	//!< This definition sets the maximum number of variables to
+	//! register in one DataSet.
+	static const uint8_t DATA_SET_MAX_SIZE = 63;
+protected:
+
+	/**
+	 * @brief	The fill_count attribute ensures that the variables
+	 * 			register in the correct array position and that the maximum
+	 * 			number of variables is not exceeded.
+	 */
+	uint16_t fillCount = 0;
+	/**
+	 * States of the seet.
+	 */
+	enum class States {
+		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
+		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
+	};
+	/**
+	 * @brief	state manages the internal state of the data set,
+	 *          which is important e.g. for the behavior on destruction.
+	 */
+	States state = States::DATA_SET_UNINITIALISED;
+
+	/**
+	 * @brief	This array represents all pool variables registered in this set.
+	 */
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE] = { };
+
+	void handleAlreadyReadDatasetCommit();
+	ReturnValue_t handleUnreadDatasetCommit();
+};
+
+#endif /* FRAMEWORK_DATAPOOL_DATASETBASE_H_ */
diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index 4e3514160..d9cc49669 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -16,6 +16,17 @@ class PoolVariableIF;
  */
 class DataSetIF {
 public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
+	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION =
+			MAKE_RETURN_CODE( 0x01 );
+	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
+	static constexpr ReturnValue_t COMMITING_WITHOUT_READING =
+			MAKE_RETURN_CODE(0x03);
+
+	static constexpr ReturnValue_t DATA_SET_UNINITIALISED = MAKE_RETURN_CODE( 0x04 );
+	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE( 0x05 );
+	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE( 0x06 );
+
 	/**
 	 * @brief	This is an empty virtual destructor,
 	 * 			as it is proposed for C++ interfaces.
@@ -29,7 +40,17 @@ public:
 	 */
 	virtual ReturnValue_t registerVariable( PoolVariableIF* variable ) = 0;
 
+	/**
+	 * @brief 	Most underlying data structures will have a pool like structure
+	 * 			and will require a lock and unlock mechanism to ensure
+	 * 			thread-safety
+	 * @return Lock operation result
+	 */
 	virtual ReturnValue_t lockDataPool() = 0;
+	/**
+	 * @brief   Unlock call corresponding to the lock call.
+	 * @return Unlock operation result
+	 */
 	virtual ReturnValue_t unlockDataPool() = 0;
 };
 
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index f83fa3b9f..112066115 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -1,9 +1,9 @@
 #ifndef PIDREADER_H_
 #define PIDREADER_H_
 #include <framework/datapool/DataSetIF.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/datapool/PoolEntry.h>
 #include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/serialize/SerializeAdapter.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index aea84612a..c0bd3c092 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -1,6 +1,6 @@
+#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/datapool/PoolEntryIF.h>
 #include <framework/datapool/PoolRawAccess.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
 
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index cf02b20a8..6e289303d 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -6,10 +6,12 @@
  */
 
 #include <framework/datapool/PoolRawAccessHelper.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 #include <cmath>
-
-#include <framework/datapoolglob/GlobalDataSet.h>
+#include <cstring>
 
 PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
 		uint8_t  numberOfParameters_):
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index ab881a5f2..f2434241c 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -7,6 +7,7 @@
 #ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
 #define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
 
+#include <framework/datapool/PoolRawAccess.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/datapoolglob/GlobalDataSet.h>
 
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 9935ef75c..0cbc18c5f 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -18,6 +18,7 @@
  * @ingroup data_pool
  */
 class PoolVariableIF : public SerializeIF {
+	friend class DataSetBase;
 	friend class GlobDataSet;
 	friend class LocalDataSet;
 protected:
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 2779ce5c3..f32ff567e 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,5 +1,7 @@
-#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/DataPoolAdmin.h>
+#include <framework/datapool/PoolRawAccess.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/parameters/ParameterMessage.h>
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
index 6e09a3989..503d068e5 100644
--- a/datapoolglob/GlobalDataSet.cpp
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -1,61 +1,12 @@
-#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/GlobalDataPool.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-GlobDataSet::GlobDataSet() :
-		fill_count(0), state(DATA_SET_UNINITIALISED) {
-	for (unsigned count = 0; count < DATA_SET_MAX_SIZE; count++) {
-		registeredVariables[count] = nullptr;
-	}
-}
+GlobDataSet::GlobDataSet(): DataSetBase() {}
 
-GlobDataSet::~GlobDataSet() {
-	//Don't do anything with your variables, they are dead already!
-	// (Destructor is already called)
-}
-
-ReturnValue_t GlobDataSet::registerVariable(PoolVariableIF* variable) {
-	if (state != DATA_SET_UNINITIALISED) {
-		sif::error << "DataSet::registerVariable: Call made in wrong position." << std::endl;
-		return DATA_SET_UNINITIALISED;
-	}
-	if (variable == nullptr) {
-		sif::error << "DataSet::registerVariable: Pool variable is nullptr." << std::endl;
-		return POOL_VAR_NULL;
-	}
-	if (fill_count >= DATA_SET_MAX_SIZE) {
-		sif::error << "DataSet::registerVariable: DataSet is full." << std::endl;
-		return DATA_SET_FULL;
-	}
-	registeredVariables[fill_count] = variable;
-	fill_count++;
-	return RETURN_OK;
-}
-
-ReturnValue_t GlobDataSet::read() {
-	ReturnValue_t result = RETURN_OK;
-	if (state == DATA_SET_UNINITIALISED) {
-		lockDataPool();
-		for (uint16_t count = 0; count < fill_count; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					!= PoolVariableIF::VAR_WRITE
-					&& registeredVariables[count]->getDataPoolId()
-							!= PoolVariableIF::NO_PARAMETER) {
-				ReturnValue_t status = registeredVariables[count]->read();
-				if (status != RETURN_OK) {
-					result = INVALID_PARAMETER_DEFINITION;
-					break;
-				}
-			}
-		}
-		state = DATA_SET_WAS_READ;
-		unlockDataPool();
-	} else {
-		sif::error << "DataSet::read(): Call made in wrong position." << std::endl;
-		result = SET_WAS_ALREADY_READ;
-	}
-	return result;
-}
+// Don't do anything with your variables, they are dead already!
+// (Destructor is already called)
+GlobDataSet::~GlobDataSet() {}
 
 ReturnValue_t GlobDataSet::commit(bool valid) {
 	setEntriesValid(valid);
@@ -64,50 +15,7 @@ ReturnValue_t GlobDataSet::commit(bool valid) {
 }
 
 ReturnValue_t GlobDataSet::commit() {
-	if (state == DATA_SET_WAS_READ) {
-		handleAlreadyReadDatasetCommit();
-		return RETURN_OK;
-	}
-	else {
-		return handleUnreadDatasetCommit();
-	}
-}
-
-void GlobDataSet::handleAlreadyReadDatasetCommit() {
-	lockDataPool();
-	for (uint16_t count = 0; count < fill_count; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ
-				&& registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commit();
-		}
-	}
-	state = DATA_SET_UNINITIALISED;
-	unlockDataPool();
-}
-
-ReturnValue_t GlobDataSet::handleUnreadDatasetCommit() {
-	ReturnValue_t result = RETURN_OK;
-	lockDataPool();
-	for (uint16_t count = 0; count < fill_count; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				== PoolVariableIF::VAR_WRITE
-				&& registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commit();
-		} else if (registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			if (result != COMMITING_WITHOUT_READING) {
-				sif::error << "DataSet::commit(): commit-without-read call made "
-						"with non write-only variable." << std::endl;
-				result = COMMITING_WITHOUT_READING;
-			}
-		}
-	}
-	state = DATA_SET_UNINITIALISED;
-	unlockDataPool();
-	return result;
+	return DataSetBase::commit();
 }
 
 ReturnValue_t GlobDataSet::unlockDataPool() {
@@ -118,29 +26,8 @@ ReturnValue_t GlobDataSet::lockDataPool() {
 	return glob::dataPool.lockDataPool();
 }
 
-ReturnValue_t GlobDataSet::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->serialize(buffer, size, max_size,
-				bigEndian);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-size_t GlobDataSet::getSerializedSize() const {
-	uint32_t size = 0;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		size += registeredVariables[count]->getSerializedSize();
-	}
-	return size;
-}
-
 void GlobDataSet::setEntriesValid(bool valid) {
-	for (uint16_t count = 0; count < fill_count; count++) {
+	for (uint16_t count = 0; count < fillCount; count++) {
 		if (registeredVariables[count]->getReadWriteMode()
 				!= PoolVariableIF::VAR_READ) {
 			registeredVariables[count]->setValid(valid);
@@ -152,15 +39,4 @@ void GlobDataSet::setSetValid(bool valid) {
 	this->valid = valid;
 }
 
-ReturnValue_t GlobDataSet::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->deSerialize(buffer, size,
-				bigEndian);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
+
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index 365de3801..c2e0b577d 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -1,63 +1,32 @@
 #ifndef DATASET_H_
 #define DATASET_H_
 
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolRawAccess.h>
-#include <framework/datapool/PoolVarList.h>
+#include <framework/datapool/DataSetBase.h>
 
-#include <framework/serialize/SerializeAdapter.h>
 /**
  * @brief	The DataSet class manages a set of locally checked out variables
  * 			for the global data pool.
- *
  * @details
- * This class manages a list, where a set of local variables (or pool variables)
- * are registered. They are checked-out (i.e. their values are looked
- * up and copied) with the read call. After the user finishes working with the
- * pool variables, he can write back all variable values to the pool with
- * the commit call. The data set manages locking and freeing the data pool,
- * to ensure that all values are read and written back at once.
+ * This class uses the read-commit() semantic provided by the DataSetBase class.
+ * It extends the base class by using the global data pool,
+ * having a valid state and implementing lock und unlock calls for the global
+ * datapool.
  *
- * An internal state manages usage of this class. Variables may only be
- * registered before the read call is made, and the commit call only
- * after the read call.
- *
- * If pool variables are writable and not committed until destruction
- * of the set, the DataSet class automatically sets the valid flag in the
- * data pool to invalid (without) changing the variable's value.
+ * For more information on how this class works, see the DataSetBase
+ * documentation.
  * @author	Bastian Baetz
  * @ingroup data_pool
  */
-class GlobDataSet: public DataSetIF, public HasReturnvaluesIF, public SerializeIF {
+class GlobDataSet: public DataSetBase {
 public:
-	//SHOULDDO we could use a linked list of datapool variables
-	//!< This definition sets the maximum number of variables to
-	//! register in one DataSet.
-	static const uint8_t DATA_SET_MAX_SIZE = 63;
 
-
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
-	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION =
-			MAKE_RETURN_CODE( 0x01 );
-	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
-	static constexpr ReturnValue_t COMMITING_WITHOUT_READING =
-			MAKE_RETURN_CODE(0x03);
-
-	static constexpr ReturnValue_t DATA_SET_UNINITIALIZED = MAKE_RETURN_CODE( 0x04 );
-	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE( 0x05 );
-	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE( 0x06 );
 	/**
-	 * @brief	The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
+	 * @brief	Creates an empty GlobDataSet. Use registerVariable or
+	 * 			supply a pointer to this dataset to PoolVariable
+	 * 			initializations to register pool variables.
 	 */
 	GlobDataSet();
 
-	/**
-	 * @brief	This operation is used to register the local variables in the set.
-	 * @details	It stores the pool variable pointer in a variable list.
-	 */
-	ReturnValue_t registerVariable(PoolVariableIF* variable) override;
-
 	/**
 	 * @brief	The destructor automatically manages writing the valid
 	 * 			information of variables.
@@ -67,42 +36,7 @@ public:
 	 * For each, the valid flag in the data pool is set to "invalid".
 	 */
 	~GlobDataSet();
-	/**
-	 * @brief	The read call initializes reading out all registered variables.
-	 * @details
-	 * It iterates through the list of registered variables and calls all read()
-	 * functions of the registered pool variables (which read out their values
-	 * from the data pool) which are not write-only.
-	 * In case of an error (e.g. a wrong data type, or an invalid data pool id),
-	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
-	 *
-	 * The data pool is locked during the whole read operation and
-	 * freed afterwards.The state changes to "was written" after this operation.
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
-	 * 					requested variable is invalid.
-	 * 			- @c SET_WAS_ALREADY_READ if read() is called twice without calling
-	 * 					commit() in between
-	 */
-	ReturnValue_t read();
-	/**
-	 * @brief	The commit call initializes writing back the registered variables.
-	 * @details
-	 * It iterates through the list of registered variables and calls the
-	 * commit() method of the remaining registered variables (which write back
-	 * their values to the pool).
-	 *
-	 * The data pool is locked during the whole commit operation and
-	 * freed afterwards. The state changes to "was committed" after this operation.
-	 *
-	 * If the set does contain at least one variable which is not write-only commit()
-	 * can only be called after read(). If the set only contains variables which are
-	 * write only, commit() can be called without a preceding read() call.
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
-	 * 			  contains non write-only variables
-	 */
-	ReturnValue_t commit(void);
+
 	/**
 	 * Variant of method above which sets validity of all elements of the set.
 	 * @param valid Validity information from PoolVariableIF.
@@ -111,6 +45,7 @@ public:
 	 * 			     contains non write-only variables
 	 */
 	ReturnValue_t commit(bool valid);
+	ReturnValue_t commit() override;
 
 	/**
 	 * Set all entries
@@ -126,45 +61,16 @@ public:
 	 */
 	void setEntriesValid(bool valid);
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
-
-	size_t getSerializedSize() const override;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
 private:
-
-	/**
-	 * @brief	This array represents all pool variables registered in this set.
-	 */
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-	/**
-	 * \brief	The fill_count attribute ensures that the variables register in the correct array
-	 * 			position and that the maximum number of variables is not exceeded.
-	 */
-	uint16_t fill_count;
-	/**
-	 * States of the seet.
-	 */
-	enum States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
-	};
-	/**
-	 * @brief	state manages the internal state of the data set,
-	 *          which is important e.g. for the behavior on destruction.
-	 */
-	States state;
-
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
 	 * data set we can use this flag.
 	 */
 	bool valid = false;
+
 	/**
 	 * @brief	This is a small helper function to facilitate locking
-	 * 			the underlying data data pool structure
+	 * 			the global data pool.
 	 * @details
 	 * It makes use of the lockDataPool method offered by the DataPool class.
 	 */
@@ -172,7 +78,7 @@ private:
 
 	/**
 	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the underlying data data pool structure
+	 * 			unlocking the global data pool
 	 * @details
 	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
 	 */
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index eee9afc10..cfa28e114 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -2,9 +2,9 @@
 #define GLOBALPOOLVARIABLE_H_
 
 #include <framework/datapool/DataSetIF.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/datapool/PoolEntry.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/serialize/SerializeAdapter.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index f46f854b1..8efc33d54 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,10 +1,10 @@
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/devicehandlers/DeviceHandlerBase.h>
 #include <framework/objectmanager/ObjectManager.h>
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
 
-#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/devicehandlers/DeviceTmReportingWrapper.h>
 #include <framework/globalfunctions/CRC.h>
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index a1e966957..30a02b442 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,6 +1,6 @@
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include "InternalErrorReporter.h"
 
-#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/ipc/MutexFactory.h>
 
diff --git a/power/Fuse.h b/power/Fuse.h
index a826a1255..44f8964f8 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -2,6 +2,7 @@
 #define FUSE_H_
 
 #include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/datapool/PIDReader.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/monitoring/AbsLimitMonitor.h>
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index cd2777842..27885b8be 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -3,6 +3,7 @@
 
 #include <framework/thermal/AbstractTemperatureSensor.h>
 #include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/monitoring/LimitMonitor.h>
 
 /**

From d1b315c7df5882427c41c77bf732f606c73ab50b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 23:54:56 +0200
Subject: [PATCH 0268/1774] pool raw access adaptions

---
 datapool/PoolRawAccess.cpp | 146 ++++++++++++--------
 datapool/PoolRawAccess.h   | 275 ++++++++++++++++++++++---------------
 2 files changed, 250 insertions(+), 171 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index c0bd3c092..778e1b9c2 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -1,54 +1,76 @@
 #include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapool/PoolEntryIF.h>
 #include <framework/datapool/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
 
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false), type(Type::UNKNOWN_TYPE), typeSize(
-				0), arraySize(0), sizeTillEnd(0), readWriteMode(setReadWriteMode) {
+		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
+		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
+		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
+		readWriteMode(setReadWriteMode) {
 	memset(value, 0, sizeof(value));
-	if (data_set != NULL) {
-		data_set->registerVariable(this);
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
 	}
 }
 
-PoolRawAccess::~PoolRawAccess() {
-
-}
+PoolRawAccess::~PoolRawAccess() {}
 
 ReturnValue_t PoolRawAccess::read() {
-	PoolEntryIF* read_out = glob::dataPool.getRawData(dataPoolId);
-	if (read_out != NULL) {
-		valid = read_out->getValid();
-		if (read_out->getSize() > arrayEntry) {
-			arraySize = read_out->getSize();
-			typeSize = read_out->getByteSize() / read_out->getSize();
-			type = read_out->getType();
-			if (typeSize <= sizeof(value)) {
-				uint16_t arrayPosition = arrayEntry * typeSize;
-				sizeTillEnd = read_out->getByteSize() - arrayPosition;
-				uint8_t* ptr =
-						&((uint8_t*) read_out->getRawData())[arrayPosition];
-				memcpy(value, ptr, typeSize);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				//Error value type too large.
-			}
-		} else {
-			//Error index requested too large
+	ReturnValue_t result = RETURN_FAILED;
+	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
+	if (readOut != nullptr) {
+		result = handleReadOut(readOut);
+		if(result == RETURN_OK) {
+			return result;
 		}
 	} else {
-		//Error entry does not exist.
+		result = READ_ENTRY_NON_EXISTENT;
 	}
+	handleReadError(result);
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
+	ReturnValue_t result = RETURN_FAILED;
+	valid = readOut->getValid();
+	if (readOut->getSize() > arrayEntry) {
+		arraySize = readOut->getSize();
+		typeSize = readOut->getByteSize() / readOut->getSize();
+		type = readOut->getType();
+		if (typeSize <= sizeof(value)) {
+			uint16_t arrayPosition = arrayEntry * typeSize;
+			sizeTillEnd = readOut->getByteSize() - arrayPosition;
+			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
+			memcpy(value, ptr, typeSize);
+			return RETURN_OK;
+		} else {
+			result = READ_TYPE_TOO_LARGE;
+		}
+	} else {
+		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
+		result = READ_INDEX_TOO_LARGE;
+	}
+	return result;
+}
+
+void PoolRawAccess::handleReadError(ReturnValue_t result) {
 	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed." << std::endl;
+			<< std::dec << " failed, ";
+	if(result == READ_TYPE_TOO_LARGE) {
+		sif::error << "type too large." << std::endl;
+	}
+	else if(result == READ_INDEX_TOO_LARGE) {
+		sif::error << "index too large." << std::endl;
+	}
+	else if(result == READ_ENTRY_NON_EXISTENT) {
+		sif::error << "entry does not exist." << std::endl;
+	}
+
 	valid = INVALID;
 	typeSize = 0;
 	sizeTillEnd = 0;
 	memset(value, 0, sizeof(value));
-	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t PoolRawAccess::commit() {
@@ -71,7 +93,9 @@ uint8_t* PoolRawAccess::getEntry() {
 ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 		uint32_t* writtenBytes, uint32_t max_size) {
 	uint8_t* data_ptr = getEntry();
-//	debug << "PoolRawAccess::getEntry: Array position: " << index * size_of_type << " Size of T: " << (int)size_of_type << " ByteSize: " << byte_size << " Position: " << *size << std::endl;
+	// debug << "PoolRawAccess::getEntry: Array position: " <<
+	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
+	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
 	if (typeSize == 0)
 		return DATA_POOL_ACCESS_FAILED;
 	if (typeSize > max_size)
@@ -89,6 +113,32 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
+	if (typeSize + *size <= max_size) {
+		if (bigEndian) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+			for (uint8_t count = 0; count < typeSize; count++) {
+				(*buffer)[count] = value[typeSize - count - 1];
+			}
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			memcpy(*buffer, value, typeSize);
+#endif
+		} else {
+			memcpy(*buffer, value, typeSize);
+		}
+		*size += typeSize;
+		(*buffer) += typeSize;
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SerializeIF::BUFFER_TOO_SHORT;
+	}
+}
+
+
 Type PoolRawAccess::getType() {
 	return type;
 }
@@ -145,29 +195,6 @@ uint16_t PoolRawAccess::getSizeTillEnd() const {
 	return sizeTillEnd;
 }
 
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
-	if (typeSize + *size <= max_size) {
-		if (bigEndian) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for (uint8_t count = 0; count < typeSize; count++) {
-				(*buffer)[count] = value[typeSize - count - 1];
-			}
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(*buffer, value, typeSize);
-#endif
-		} else {
-			memcpy(*buffer, value, typeSize);
-		}
-		*size += typeSize;
-		(*buffer) += typeSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SerializeIF::BUFFER_TOO_SHORT;
-	}
-}
 
 size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
@@ -175,8 +202,9 @@ size_t PoolRawAccess::getSerializedSize() const {
 
 ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
+	// TODO: Needs to be tested!!!
 	if (*size >= typeSize) {
-
+		*size -= typeSize;
 		if (bigEndian) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
@@ -187,12 +215,14 @@ ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 			memcpy(value, *buffer, typeSize);
 #endif
-		} else {
+		}
+		else {
 			memcpy(value, *buffer, typeSize);
 		}
 		*buffer += typeSize;
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
+	}
+	else {
 		return SerializeIF::STREAM_TOO_SHORT;
 	}
 }
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index f32aac51a..452b5397a 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -2,36 +2,187 @@
 #define POOLRAWACCESS_H_
 
 #include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolEntryIF.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/globalfunctions/Type.h>
 
 /**
- * This class allows accessing Data Pool variables as raw bytes.
- * This is necessary to have an access method for HK data, as the PID's alone do not
- * provide a type information.
- *	\ingroup data_pool
+ * @brief This class allows accessing Data Pool variables as raw bytes.
+ * @details
+ * This is necessary to have an access method for HK data, as the PID's alone
+ * do not provide type information. Please note that the the raw pool access
+ * read() and commit() calls are not thread-safe.
+ *
+ * Please supply a data set and use the data set read(), commit() calls for
+ * thread-safe data pool access.
+ * @ingroup data_pool
  */
-class PoolRawAccess: public PoolVariableIF {
+class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
+public:
+	/**
+	 * This constructor is used to access a data pool entry with a
+	 * given ID if the target type is not known. A DataSet object is supplied
+	 * and the data pool entry with the given ID is registered to that data set.
+	 * Please note that a pool raw access buffer only has a buffer
+	 * with a size of double. As such, for vector entries which have
+	 * @param data_pool_id Target data pool entry ID
+	 * @param arrayEntry
+	 * @param data_set Dataset to register data pool entry to
+	 * @param setReadWriteMode
+	 * @param registerVectors If set to true, the constructor checks if
+	 *                        there are multiple vector entries to registers
+	 *                        and registers all of them recursively into the data_set
+	 *
+	 */
+	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
+			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
+					PoolVariableIF::VAR_READ);
+
+	/**
+	 * @brief	This operation returns a pointer to the entry fetched.
+	 * @details	Return pointer to the buffer containing the raw data
+	 *          Size and number of data can be retrieved by other means.
+	 */
+	uint8_t* getEntry();
+	/**
+	 * @brief 	This operation returns the fetched entry from the data pool and
+	 * 			flips the bytes, if necessary.
+	 * @details	It makes use of the getEntry call of this function, but additionally flips the
+	 * 			bytes to big endian, which is the default for external communication (as House-
+	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
+	 * 			buffer, if it fits in the given max_size.
+	 * @param buffer	A pointer to a buffer to write to
+	 * @param writtenBytes	The number of bytes written is returned with this value.
+	 * @param max_size	The maximum size that the function may write to buffer.
+	 * @return	- @c RETURN_OK if entry could be acquired
+	 * 			- @c RETURN_FAILED else.
+	 */
+	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
+			uint32_t max_size);
+
+	/**
+	 * @brief 	Serialize raw pool entry into provided buffer directly
+	 * @param buffer Provided buffer. Raw pool data will be copied here
+	 * @param size [out] Increment provided size value by serialized size
+	 * @param max_size Maximum allowed serialization size
+	 * @param bigEndian Specify endianess
+	 * @return - @c RETURN_OK if serialization was successfull
+	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
+	 */
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
+
+	/**
+	 * With this method, the content can be set from a big endian buffer safely.
+	 * @param buffer	Pointer to the data to set
+	 * @param size		Size of the data to write. Must fit this->size.
+	 * @return	- @c RETURN_OK on success
+	 * 			- @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
+			uint32_t setSize);
+	/**
+	 *  @brief This operation returns the type of the entry currently stored.
+	 */
+	Type getType();
+	/**
+	 *  @brief This operation returns the size of the entry currently stored.
+	 */
+	uint8_t getSizeOfType();
+	/**
+	 *
+	 * @return the size of the datapool array
+	 */
+	uint8_t getArraySize();
+	/**
+	 * @brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
+	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
+	static const uint8_t RAW_MAX_SIZE = sizeof(double);
+	uint8_t value[RAW_MAX_SIZE];
+
+
+	/**
+	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~PoolRawAccess();
+
+	/**
+	 * This method returns if the variable is read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const;
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const;
+
+	void setValid(uint8_t valid);
+	/**
+	 * Getter for the remaining size.
+	 */
+	uint16_t getSizeTillEnd() const;
+
+	size_t getSerializedSize() const;
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian);
+
+protected:
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details	When executed, this operation tries to fetch the pool entry with matching
+	 * 			data pool id from the global data pool and copies the value and the valid
+	 * 			information to its local attributes. In case of a failure (wrong type or
+	 * 			pool id not found), the variable is set to zero and invalid.
+	 * 			The operation does NOT provide any mutual exclusive protection by itself !
+	 * 			If reading from the data pool without information about the type is desired,
+	 * 			initialize the raw pool access by supplying a data set and using the data set
+	 * 			read function, which calls this read function.
+	 * @return -@c RETURN_OK Read successfull
+	 * 		   -@c READ_TYPE_TOO_LARGE
+	 * 		   -@c READ_INDEX_TOO_LARGE
+	 * 		   -@c READ_ENTRY_NON_EXISTENT
+	 */
+	ReturnValue_t read();
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details	It checks type and size, as well as if the variable is writable. If so,
+	 * 			the value is copied and the valid flag is automatically set to "valid".
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 *
+	 */
+	ReturnValue_t commit();
+
+	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
+	void handleReadError(ReturnValue_t result);
 private:
 	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
 	 * 			is stored.
 	 */
 	uint32_t dataPoolId;
 	/**
-	 * \brief	The array entry that is fetched from the data pool.
+	 * @brief	The array entry that is fetched from the data pool.
 	 */
 	uint8_t arrayEntry;
 	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
 	 */
 	uint8_t valid;
 	/**
-	 *  \brief	This value contains the type of the data pool entry.
+	 * @brief	This value contains the type of the data pool entry.
 	 */
 	Type type;
 	/**
-	 * \brief	This value contains the size of the data pool entry in bytes.
+	 * @brief	This value contains the size of the data pool entry type in bytes.
 	 */
 	uint8_t typeSize;
 	/**
@@ -43,111 +194,9 @@ private:
 	 */
 	uint16_t sizeTillEnd;
 	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
+	 * @brief	The information whether the class is read-write or read-only is stored here.
 	 */
 	ReadWriteMode_t readWriteMode;
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
-protected:
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read();
-	/**
-	 * \brief	The commit call writes back the variable's value to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit();
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
-	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
-	uint8_t value[RAW_MAX_SIZE];
-	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
-			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-					PoolVariableIF::VAR_READ);
-	/**
-	 * \brief	The classes destructor is empty. If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolRawAccess();
-	/**
-	 * \brief	This operation returns a pointer to the entry fetched.
-	 * \details	This means, it does not return a pointer to byte "index", but to the start byte of
-	 * 			array entry "index". Example: If the original data pool array consists of an double
-	 * 			array of size four, getEntry(1) returns &(this->value[8]).
-	 */
-	uint8_t* getEntry();
-	/**
-	 * \brief 	This operation returns the fetched entry from the data pool and
-	 * 			flips the bytes, if necessary.
-	 * \details	It makes use of the getEntry call of this function, but additionally flips the
-	 * 			bytes to big endian, which is the default for external communication (as House-
-	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given max_size.
-	 * \param buffer	A pointer to a buffer to write to
-	 * \param writtenBytes	The number of bytes written is returned with this value.
-	 * \param max_size	The maximum size that the function may write to buffer.
-	 * \return	- \c RETURN_OK if entry could be acquired
-	 * 			- \c RETURN_FAILED else.
-	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
-			uint32_t max_size);
-	/**
-	 * With this method, the content can be set from a big endian buffer safely.
-	 * @param buffer	Pointer to the data to set
-	 * @param size		Size of the data to write. Must fit this->size.
-	 * @return	- \c RETURN_OK on success
-	 * 			- \c RETURN_FAILED on failure
-	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			uint32_t setSize);
-	/**
-	 *  \brief This operation returns the type of the entry currently stored.
-	 */
-	Type getType();
-	/**
-	 *  \brief This operation returns the size of the entry currently stored.
-	 */
-	uint8_t getSizeOfType();
-	/**
-	 *
-	 * @return the size of the datapool array
-	 */
-	uint8_t getArraySize();
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const;
-	/**
-	 * This method returns if the variable is read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const;
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const;
-
-	void setValid(uint8_t valid);
-	/**
-	 * Getter for the remaining size.
-	 */
-	uint16_t getSizeTillEnd() const;
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
-
-	size_t getSerializedSize() const;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
 };
 
 #endif /* POOLRAWACCESS_H_ */

From 767850e12546ddb7b17d344ee32a1c5bb389a593 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 23:58:57 +0200
Subject: [PATCH 0269/1774] deleted poolvector

---
 datapool/PoolVector.h | 233 ------------------------------------------
 1 file changed, 233 deletions(-)
 delete mode 100644 datapool/PoolVector.h

diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
deleted file mode 100644
index 3df615282..000000000
--- a/datapool/PoolVector.h
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
- * \file	PoolVector.h
- *
- * \brief	This file contains the PoolVector class, the header only class to handle data pool vectors.
- *
- * \date	10/23/2012
- *
- * \author	Bastian Baetz
- */
-
-#ifndef POOLVECTOR_H_
-#define POOLVECTOR_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-/**
- * \brief	This is the access class for array-type data pool entries.
- *
- * \details	To ensure safe usage of the data pool, operation is not done directly on the data pool
- * 			entries, but on local copies. This class provides simple type- and length-safe access
- * 			to vector-style data pool entries (i.e. entries with length > 1).
- * 			The class can be instantiated as read-write and read only.
- * 			It provides a commit-and-roll-back semantic, which means that no array entry in
- * 			the data pool is changed until the commit call is executed.
- * 			There are two template parameters:
- * 	\tparam	T This template parameter specifies the data type of an array entry. Currently, all
- * 			plain data types are supported, but in principle any type is possible.
- * 	\tparam vector_size	This template parameter specifies the vector size of this entry.
- * 			Using a template parameter for this is not perfect, but avoids dynamic memory allocation.
- *	\ingroup data_pool
- */
-template<typename T, uint16_t vector_size>
-class PoolVector: public PoolVariableIF {
-private:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-
-protected:
-	/**
-	 * \brief	This is a call to read the array's values from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies all array values and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type, size or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read() {
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(this->dataPoolId,
-				vector_size);
-		if (read_out != NULL) {
-			this->valid = read_out->valid;
-			memcpy(this->value, read_out->address, read_out->getByteSize());
-
-			return HasReturnvaluesIF::RETURN_OK;
-
-		} else {
-			memset(this->value, 0, vector_size * sizeof(T));
-			sif::error << "PoolVector: read of DP Variable 0x" << std::hex
-					<< dataPoolId << std::dec << " failed." << std::endl;
-			this->valid = INVALID;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * \brief	The commit call copies the array values back to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit() {
-		PoolEntry<T>* write_back = ::dataPool.getData<T>(this->dataPoolId,
-				vector_size);
-		if ((write_back != NULL) && (this->readWriteMode != VAR_READ)) {
-			write_back->valid = valid;
-			memcpy(write_back->address, this->value, write_back->getByteSize());
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 * \detials	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
-	 */
-	T value[vector_size];
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
-	 */
-	PoolVector(uint32_t set_id, DataSetIF* set,
-			ReadWriteMode_t setReadWriteMode) :
-			dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
-		memset(this->value, 0, vector_size * sizeof(T));
-		if (set != NULL) {
-			set->registerVariable(this);
-		}
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-//	PoolVector(const PoolVector& rhs) {
-//		PoolVector<T, vector_size> temp(rhs.dataPoolId, rhs.)
-//		memcpy(value, rhs.value, sizeof(T)*vector_size);
-//	}
-	/**
-	 * \brief	The classes destructor is empty.
-	 * \details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolVector() {
-	}
-	;
-	/**
-	 * \brief	The operation returns the number of array entries in this variable.
-	 */
-	uint8_t getSize() {
-		return vector_size;
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-	;
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid != INVALID)
-			return true;
-		else
-			return false;
-	}
-
-	void setValid(uint8_t valid) {
-		this->valid = valid;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	T &operator [](int i) {
-		return value[i];
-	}
-
-	const T &operator [](int i) const {
-		return value[i];
-	}
-
-	PoolVector<T, vector_size> &operator=(
-			PoolVector<T, vector_size> newPoolVector) {
-
-		for (uint16_t i = 0; i < vector_size; i++) {
-			this->value[i] = newPoolVector.value[i];
-		}
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		uint16_t i;
-		ReturnValue_t result;
-		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
-					max_size, bigEndian);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const {
-		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
-		uint16_t i;
-		ReturnValue_t result;
-		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
-					bigEndian);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-};
-
-#endif /* POOLVECTOR_H_ */

From 355bc2b9057da4f79ead6aa0e7882b9220edffd7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 15:42:47 +0200
Subject: [PATCH 0270/1774] improvements

---
 datapoolglob/GlobalPoolVariable.h    | 2 +-
 datapoollocal/LocalPoolVariable.h    | 5 +++--
 datapoollocal/LocalPoolVariable.tpp  | 5 ++++-
 globalfunctions/Type.h               | 3 +++
 housekeeping/HasHkPoolParametersIF.h | 5 +----
 5 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index cfa28e114..eb44c3072 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -32,7 +32,7 @@ class GlobPoolVar: public PoolVariableIF {
 	template<typename U, uint8_t n_var> friend class PoolVarList;
 	static_assert(not std::is_same<T, bool>::value,
 			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
-			"Warum? Darum :-)");
+			"There is no boolean type in CCSDS.");
 public:
 	/**
 	 * @brief	In the constructor, the variable can register itself in a
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 44c16a7ce..39c92f604 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/datapool/DataSetIF.h>
@@ -100,4 +101,4 @@ using lp_int64_t = LocalPoolVar<int64_t>;
 using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
-
+#endif
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index fdd18bcd7..4bc4c6621 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
 
 #include <framework/housekeeping/HasHkPoolParametersIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
@@ -107,3 +108,5 @@ inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
 		size_t* size, bool bigEndian) {
 	return AutoSerializeAdapter::deSerialize(&value, buffer, size, bigEndian);
 }
+
+#endif
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index f4146f4ea..e46a37e48 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -4,6 +4,9 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serialize/SerializeIF.h>
 
+/**
+ * @brief 	Type definition for CCSDS or ECSS.
+ */
 class Type: public SerializeIF {
 public:
 	enum ActualType_t {
diff --git a/housekeeping/HasHkPoolParametersIF.h b/housekeeping/HasHkPoolParametersIF.h
index 5ec9beef6..ac248cf35 100644
--- a/housekeeping/HasHkPoolParametersIF.h
+++ b/housekeeping/HasHkPoolParametersIF.h
@@ -13,8 +13,7 @@ using LocalDataPoolMap =  std::map<lp_id_t, PoolEntryIF*>;
 using LocalDataPoolMapIter = LocalDataPoolMap::iterator;
 
 /**
- * @brief 	Interface for the local housekeeping managers used by the device
- * 			handler.
+ * @brief
  */
 class HasHkPoolParametersIF {
 public:
@@ -27,6 +26,4 @@ public:
 	virtual HousekeepingManager* getHkManagerHandle() = 0;
 };
 
-
-
 #endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */

From 7e04c055b353b1cfe6817a2cc2e0fbbca4db631e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 16:13:46 +0200
Subject: [PATCH 0271/1774] tc packet stored formatting

---
 tmtcpacket/pus/TcPacketStored.cpp | 10 +++++-----
 tmtcpacket/pus/TcPacketStored.h   |  4 +++-
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 0187b08f4..6a4d03bec 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -1,22 +1,22 @@
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/tmtcpacket/pus/TcPacketStored.h>
-#include <string.h>
+#include <cstring>
 
 TcPacketStored::TcPacketStored(store_address_t setAddress) :
-		TcPacketBase(NULL), storeAddress(setAddress) {
+		TcPacketBase(nullptr), storeAddress(setAddress) {
 	this->setStoreAddress(this->storeAddress);
 }
 
 TcPacketStored::TcPacketStored(uint16_t apid, uint8_t ack, uint8_t service,
 		uint8_t subservice, uint8_t sequence_count, const uint8_t* data,
-		uint32_t size) :
-		TcPacketBase(NULL) {
+		size_t size) :
+		TcPacketBase(nullptr) {
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	if (!this->checkAndSetStore()) {
 		return;
 	}
-	uint8_t* p_data = NULL;
+	uint8_t* p_data = nullptr;
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
 			(TC_PACKET_MIN_SIZE + size), &p_data);
 	if (returnValue != this->store->RETURN_OK) {
diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h
index c57f0e0fd..506397881 100644
--- a/tmtcpacket/pus/TcPacketStored.h
+++ b/tmtcpacket/pus/TcPacketStored.h
@@ -64,7 +64,9 @@ public:
 	 * @param data		The data to be copied to the Application Data Field.
 	 * @param size		The amount of data to be copied.
 	 */
-	TcPacketStored( uint16_t apid, uint8_t ack, uint8_t service, uint8_t subservice, uint8_t sequence_count = 0, const uint8_t* data = NULL, uint32_t size = 0 );
+	TcPacketStored( uint16_t apid, uint8_t ack, uint8_t service,
+			uint8_t subservice, uint8_t sequence_count = 0,
+			const uint8_t* data = nullptr, size_t size = 0 );
 	/**
 	 * Another constructor to create a TcPacket from a raw packet stream.
 	 * Takes the data and adds it unchecked to the TcStore.

From b12bace3857588cfca51e0b0c8df37fec0d6c31a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 16:40:11 +0200
Subject: [PATCH 0272/1774] changed order of input arguments (relevance)

default argument for ACK
---
 tmtcpacket/pus/TcPacketStored.cpp | 6 +++---
 tmtcpacket/pus/TcPacketStored.h   | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 6a4d03bec..57b90bcc7 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -8,9 +8,9 @@ TcPacketStored::TcPacketStored(store_address_t setAddress) :
 	this->setStoreAddress(this->storeAddress);
 }
 
-TcPacketStored::TcPacketStored(uint16_t apid, uint8_t ack, uint8_t service,
-		uint8_t subservice, uint8_t sequence_count, const uint8_t* data,
-		size_t size) :
+TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
+		uint16_t apid, uint8_t sequence_count, const uint8_t* data,
+		size_t size, uint8_t ack ) :
 		TcPacketBase(nullptr) {
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	if (!this->checkAndSetStore()) {
diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h
index 506397881..a9c49c2e6 100644
--- a/tmtcpacket/pus/TcPacketStored.h
+++ b/tmtcpacket/pus/TcPacketStored.h
@@ -64,9 +64,9 @@ public:
 	 * @param data		The data to be copied to the Application Data Field.
 	 * @param size		The amount of data to be copied.
 	 */
-	TcPacketStored( uint16_t apid, uint8_t ack, uint8_t service,
-			uint8_t subservice, uint8_t sequence_count = 0,
-			const uint8_t* data = nullptr, size_t size = 0 );
+	TcPacketStored( uint8_t service, uint8_t subservice, uint16_t apid,
+			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
+			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL );
 	/**
 	 * Another constructor to create a TcPacket from a raw packet stream.
 	 * Takes the data and adds it unchecked to the TcStore.

From 1d4d01d1906d1300eb7fe4e65d259afe64210a81 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 17:22:10 +0200
Subject: [PATCH 0273/1774] Added ISR calls for MQ and task mgmt

The task management defines an external function which
implements a context switch call from an ISR
---
 osal/FreeRTOS/MessageQueue.cpp   | 95 ++++++++++++++++++++------------
 osal/FreeRTOS/MessageQueue.h     | 75 +++++++++++++++++--------
 osal/FreeRTOS/TaskManagement.cpp | 24 ++++++++
 osal/FreeRTOS/TaskManagement.h   | 63 +++++++++++++++++++++
 4 files changed, 199 insertions(+), 58 deletions(-)
 create mode 100644 osal/FreeRTOS/TaskManagement.cpp
 create mode 100644 osal/FreeRTOS/TaskManagement.h

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index e5da04427..38f425a4f 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -2,11 +2,14 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-// TODO I guess we should have a way of checking if we are in an ISR and then use the "fromISR" versions of all calls
-
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-defaultDestination(0),lastPartner(0)  {
-	handle = xQueueCreate(message_depth, max_message_size);
+// TODO I guess we should have a way of checking if we are in an ISR and then
+// use the "fromISR" versions of all calls
+// As a first step towards this, introduces system context variable which needs
+// to be switched manually
+// Haven't found function to find system context.
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) :
+defaultDestination(0),lastPartner(0), callContext(CallContext::task)  {
+	handle = xQueueCreate(messageDepth, maxMessageSize);
 	if (handle == NULL) {
 		sif::error << "MessageQueue creation failed" << std::endl;
 	}
@@ -18,6 +21,10 @@ MessageQueue::~MessageQueue() {
 	}
 }
 
+void MessageQueue::switchSystemContext(CallContext callContext) {
+	this->callContext = callContext;
+}
+
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
@@ -27,6 +34,11 @@ ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
+}
+
 ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	if (this->lastPartner != 0) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
@@ -35,6 +47,27 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	}
 }
 
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault, callContext);
+}
+
+
+ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
+	if (result != pdPASS) {
+		if (!ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != NULL) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		return MessageQueueIF::FULL;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
@@ -73,17 +106,6 @@ void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
 	this->defaultDestination = defaultDestination;
 }
 
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
-}
-
 MessageQueueId_t MessageQueue::getDefaultDestination() const {
 	return defaultDestination;
 }
@@ -92,23 +114,28 @@ bool MessageQueue::isDefaultDestinationSet() const {
 	return 0;
 }
 
+
+// static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessage *message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	message->setSender(sentFrom);
-
-	BaseType_t result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),reinterpret_cast<const void*>(message->getBuffer()), 0);
-	if (result != pdPASS) {
-		if (!ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-					objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != NULL) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		return MessageQueueIF::FULL;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-
+        MessageQueueMessage *message, MessageQueueId_t sentFrom,
+        bool ignoreFault, CallContext callContext) {
+    message->setSender(sentFrom);
+    BaseType_t result;
+    if(callContext == CallContext::task) {
+        result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
+                static_cast<const void*>(message->getBuffer()), 0);
+    }
+    else {
+        // If the call context is from an interrupt,
+        // request a context switch if a higher priority task
+        // was blocked by the interrupt.
+        BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+        result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
+                static_cast<const void*>(message->getBuffer()),
+                &xHigherPriorityTaskWoken);
+        if(xHigherPriorityTaskWoken == pdTRUE) {
+            TaskManagement::requestContextSwitch(callContext);
+        }
+    }
+    return handleSendResult(result, ignoreFault);
 }
-
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 32f41b44d..ce6ed46b3 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -4,9 +4,14 @@
 #include <framework/internalError/InternalErrorReporterIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MessageQueueMessage.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+}
+
 
-#include <FreeRTOS.h>
-#include <queue.h>
 
 //TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution
 // https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
@@ -21,11 +26,17 @@
  *				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.
- *	\ingroup message_queue
+ *
+ *				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;
@@ -43,11 +54,15 @@ public:
 	 * 							This should be left default.
 	 */
 	MessageQueue( size_t message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+
 	/**
 	 * @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();
+
+	void switchSystemContext(CallContext callContext);
+
 	/**
 	 * @brief	This operation sends a message to the given destination.
 	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
@@ -74,6 +89,29 @@ public:
 	 */
 	ReturnValue_t reply( MessageQueueMessage* message );
 
+	/**
+	 * \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, MessageQueueMessage* message,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+
+	/**
+	 * \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( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+
 	/**
 	 * @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
@@ -107,26 +145,7 @@ public:
 	 * @brief	This method returns the message queue id of this class's message queue.
 	 */
 	MessageQueueId_t getId() const;
-	/**
-	 * \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, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \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( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+
 	/**
 	 * \brief	This method is a simple setter for the default destination.
 	 */
@@ -148,12 +167,20 @@ protected:
 	 * \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
 	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,bool ignoreFault=false);
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false, CallContext callContext = CallContext::task);
+
+	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
+
 private:
 	QueueHandle_t handle;
 	MessageQueueId_t defaultDestination;
 	MessageQueueId_t lastPartner;
+	CallContext callContext; //!< Stores the current system context
 };
 
 #endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
new file mode 100644
index 000000000..522225319
--- /dev/null
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -0,0 +1,24 @@
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+
+void TaskManagement::requestContextSwitchFromTask() {
+	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
+		requestContextSwitchFromISR();
+	} else {
+		requestContextSwitchFromTask();
+	}
+}
+
+TaskHandle_t TaskManagement::getCurrentTaskHandle() {
+	return xTaskGetCurrentTaskHandle();
+}
+
+configSTACK_DEPTH_TYPE TaskManagement::getTaskStackHighWatermark() {
+	return uxTaskGetStackHighWaterMark(TaskManagement::getCurrentTaskHandle());
+}
+
+
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
new file mode 100644
index 000000000..eaaf97e22
--- /dev/null
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -0,0 +1,63 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+#define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+
+#include <framework/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 "C" void requestContextSwitchFromISR();
+
+/*!
+ * 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 CallContext {
+	task = 0x00,//!< task_context
+	isr = 0xFF  //!< isr_context
+};
+
+
+class TaskManagement {
+public:
+	/**
+	 * 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 requestContextSwitchFromTask(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 configSTACK_DEPTH_TYPE getTaskStackHighWatermark();
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */

From d1500a78685d18e05b94419be69f9cb09056c127 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 17:31:05 +0200
Subject: [PATCH 0274/1774] mq doc improvements

---
 osal/FreeRTOS/MessageQueue.cpp |   9 ++-
 osal/FreeRTOS/MessageQueue.h   | 120 ++++++++++++++++++---------------
 2 files changed, 72 insertions(+), 57 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 38f425a4f..12a3173ad 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -50,14 +50,16 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault, callContext);
+	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
+			ignoreFault, callContext);
 }
 
 
 ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
 	if (result != pdPASS) {
 		if (!ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
 					objects::INTERNAL_ERROR_REPORTER);
 			if (internalErrorReporter != NULL) {
 				internalErrorReporter->queueMessageNotSent();
@@ -78,7 +80,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 }
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
-	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(message->getBuffer()), 0);
+	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
+			message->getBuffer()), 0);
 	if (result == pdPASS){
 		this->lastPartner = message->getSender();
 		return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index ce6ed46b3..c278e3296 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -12,52 +12,57 @@ extern "C" {
 }
 
 
-
 //TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution
 // https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
 
 /**
- *	@brief		This class manages sending and receiving of message queue messages.
+ * @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.
  *
- *	@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.
  *
- *				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
+ * 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 i 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.
+	 * @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 i 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 message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	MessageQueue( size_t message_depth = 3,
+			size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
 
 	/**
 	 * @brief	The destructor deletes the formerly created message queue.
-	 * @details	This is accomplished by using the delete call provided by the operating system.
+	 * @details	This is accomplished by using the delete call provided
+	 * 			by the operating system.
 	 */
 	virtual ~MessageQueue();
 
@@ -90,27 +95,28 @@ public:
 	ReturnValue_t reply( MessageQueueMessage* message );
 
 	/**
-	 * \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
+	 * @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.
+	 * @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 ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message,
 			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 
 	/**
-	 * \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.
+	 * @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( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
@@ -147,27 +153,34 @@ public:
 	MessageQueueId_t getId() const;
 
 	/**
-	 * \brief	This method is a simple setter for the default destination.
+	 * @brief	This method is a simple setter for the default destination.
 	 */
 	void setDefaultDestination(MessageQueueId_t defaultDestination);
 	/**
-	 * \brief	This method is a simple getter for the default destination.
+	 * @brief	This method is a simple getter for the default destination.
 	 */
 	MessageQueueId_t getDefaultDestination() const;
 
 	bool isDefaultDestinationSet() const;
 protected:
 	/**
-	 * 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
+	 * @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,
 			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
@@ -175,7 +188,6 @@ protected:
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
-
 private:
 	QueueHandle_t handle;
 	MessageQueueId_t defaultDestination;

From f8614e23a867d21d64922329164920c41ab55c38 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 17:38:19 +0200
Subject: [PATCH 0275/1774] deleted copy ans assignment ctor

---
 osal/FreeRTOS/MessageQueue.cpp | 18 +++++++++---------
 osal/FreeRTOS/MessageQueue.h   | 16 +++++++++++-----
 2 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 12a3173ad..9e4b581be 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -7,11 +7,10 @@
 // As a first step towards this, introduces system context variable which needs
 // to be switched manually
 // Haven't found function to find system context.
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) :
-defaultDestination(0),lastPartner(0), callContext(CallContext::task)  {
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
 	if (handle == NULL) {
-		sif::error << "MessageQueue creation failed" << std::endl;
+		sif::error << "MessageQueue: Creation failed" << std::endl;
 	}
 }
 
@@ -57,11 +56,11 @@ ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 
 ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
 	if (result != pdPASS) {
-		if (!ignoreFault) {
+		if (not ignoreFault) {
 			InternalErrorReporterIF* internalErrorReporter =
 					objectManager->get<InternalErrorReporterIF>(
 					objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != NULL) {
+			if (internalErrorReporter != nullptr) {
 				internalErrorReporter->queueMessageNotSent();
 			}
 		}
@@ -106,6 +105,7 @@ MessageQueueId_t MessageQueue::getId() const {
 }
 
 void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	defaultDestinationSet = true;
 	this->defaultDestination = defaultDestination;
 }
 
@@ -114,7 +114,7 @@ MessageQueueId_t MessageQueue::getDefaultDestination() const {
 }
 
 bool MessageQueue::isDefaultDestinationSet() const {
-	return 0;
+	return defaultDestinationSet;
 }
 
 
@@ -129,9 +129,9 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
                 static_cast<const void*>(message->getBuffer()), 0);
     }
     else {
-        // If the call context is from an interrupt,
-        // request a context switch if a higher priority task
-        // was blocked by the interrupt.
+        /* If the call context is from an interrupt,
+         * request a context switch if a higher priority task
+         * was blocked by the interrupt. */
         BaseType_t xHigherPriorityTaskWoken = pdFALSE;
         result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
                 static_cast<const void*>(message->getBuffer()),
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index c278e3296..e88bbcec5 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -56,8 +56,12 @@ public:
 	 * With this parameter, the maximum message size can be adjusted.
 	 * This should be left default.
 	 */
-	MessageQueue( size_t message_depth = 3,
-			size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	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.
@@ -189,10 +193,12 @@ protected:
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
 private:
+	bool defaultDestinationSet = false;
 	QueueHandle_t handle;
-	MessageQueueId_t defaultDestination;
-	MessageQueueId_t lastPartner;
-	CallContext callContext; //!< Stores the current system context
+	MessageQueueId_t defaultDestination = 0;
+	MessageQueueId_t lastPartner = 0;
+	//!< Stores the current system context
+	CallContext callContext =  CallContext::task;
 };
 
 #endif /* MESSAGEQUEUE_H_ */

From 41c0ca6c52a728ffaf359805efb0df0319b9dcc3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 17:39:10 +0200
Subject: [PATCH 0276/1774] added doc for switchSystemContext

---
 osal/FreeRTOS/MessageQueue.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index e88bbcec5..07e95ddf5 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -70,6 +70,11 @@ public:
 	 */
 	virtual ~MessageQueue();
 
+	/**
+	 * This function is used to switch the call context. This has to be called
+	 * if a message is sent or received from an ISR!
+	 * @param callContext
+	 */
 	void switchSystemContext(CallContext callContext);
 
 	/**

From b23728731548d900b97a70e3d32565ebcfcc50e7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 17:48:16 +0200
Subject: [PATCH 0277/1774] bin semaph sif replacements

---
 osal/FreeRTOS/BinarySemaphore.cpp | 11 +++++------
 returnvalues/FwClassIds.h         |  2 ++
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index a6a923aaf..acfc53bdd 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -11,8 +11,7 @@
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
-
-		error << "Binary semaphore creation failure" << std::endl;
+		sif::error << "Binary semaphore creation failure" << std::endl;
 	}
 	xSemaphoreGive(handle);
 }
@@ -26,7 +25,7 @@ BinarySemaphore::~BinarySemaphore() {
 BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
-        error << "Binary semaphore creation failure" << std::endl;
+        sif::error << "Binary semaphore creation failure" << std::endl;
     }
     xSemaphoreGive(handle);
 }
@@ -35,7 +34,7 @@ BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     if(this != &s) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
-            error << "Binary semaphore creation failure" << std::endl;
+            sif::error << "Binary semaphore creation failure" << std::endl;
         }
         xSemaphoreGive(handle);
     }
@@ -45,7 +44,7 @@ BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
-        error << "Binary semaphore creation failure" << std::endl;
+        sif::error << "Binary semaphore creation failure" << std::endl;
     }
     xSemaphoreGive(handle);
 }
@@ -55,7 +54,7 @@ BinarySemaphore& BinarySemaphore::operator =(
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
-            error << "Binary semaphore creation failure" << std::endl;
+            sif::error << "Binary semaphore creation failure" << std::endl;
         }
         xSemaphoreGive(handle);
     }
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index d21861c08..120d8b8c9 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -24,6 +24,7 @@ enum {
 	MEMORY_HELPER, //MH
 	SERIALIZE_IF, //SE
 	FIXED_MAP, //FM
+	FIXED_MULTIMAP, //FMM
 	HAS_HEALTH_IF, //HHI
 	FIFO_CLASS, //FF
 	MESSAGE_PROXY, //MQP
@@ -59,6 +60,7 @@ enum {
 	SGP4PROPAGATOR_CLASS, //SGP4 53
 	MUTEX_IF, //MUX 54
 	MESSAGE_QUEUE_IF,//MQI 55
+	SEMAPHORE_IF, //SPH 56
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 45b0193ef38b70a4f1d5be76564258bc6ab5c928 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 18:06:40 +0200
Subject: [PATCH 0278/1774] bin semaph todo

---
 osal/FreeRTOS/BinarySemaphore.h | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 0ab9cdea6..865da8a61 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -1,27 +1,24 @@
-/**
- * @file BinarySempahore.h
- *
- * @date 25.02.2020
- */
 #ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 #define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
 extern "C" {
-#include "FreeRTOS.h"
-#include "semphr.h"
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
 }
 
-
+// TODO: Counting semaphores and implement the new (better)
+//		 task notifications. However, those use task notifications require
+//		 the task handle. Maybe it would be better to make a separate class
+// 		 and switch between the classes with #ifdefs.
+//		 Task Notifications require FreeRTOS V8.2 something..
 /**
  * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
  * @details
  * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
  *
- * SHOULDDO: check freeRTOS version and use new task notifications,
- * if non-ancient freeRTOS version is used.
- *
+ * @author 	R. Mueller
  * @ingroup osal
  */
 class BinarySemaphore: public HasReturnvaluesIF {

From 87bf843beffe92f7f535609cb83fcb4378f952be Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 19:19:50 +0200
Subject: [PATCH 0279/1774] binary semaphore IF init

---
 tasks/SemaphoreIF.h | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 tasks/SemaphoreIF.h

diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
new file mode 100644
index 000000000..babac05a3
--- /dev/null
+++ b/tasks/SemaphoreIF.h
@@ -0,0 +1,8 @@
+#ifndef FRAMEWORK_TASKS_SEMAPHOREIF_H_
+#define FRAMEWORK_TASKS_SEMAPHOREIF_H_
+
+
+
+
+
+#endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */

From 9ba21b1e288ba9f8e20fae9c4cc7ea6923b2651f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 19:30:50 +0200
Subject: [PATCH 0280/1774] semaphore if continued

---
 tasks/SemaphoreIF.h | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index babac05a3..cf56f6f90 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -1,8 +1,49 @@
 #ifndef FRAMEWORK_TASKS_SEMAPHOREIF_H_
 #define FRAMEWORK_TASKS_SEMAPHOREIF_H_
+#include <framework/returnvalues/FwClassIds.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstdint>
 
+/**
+ * @brief 	Generic interface for semaphores, which can be used to achieve
+ * 			task synchronization.
+ */
+class SemaphoreIF {
+	//!< Needs to be defined in implementation.
+	static const uint32_t NO_TIMEOUT;
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 
+	//! Semaphore timeout
+	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
+	//! The current semaphore can not be given, because it is not owned
+	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
 
+	/**
+	 * Generic call to acquire a semaphore.
+	 * If there are no more semaphores to be taken (for a counting semaphore,
+	 * a semaphore may be taken more than once), the taks will block
+	 * for a maximum of timeoutMs while trying to acquire the semaphore.
+	 * This can be used to achieve task synchrnization.
+	 * @param timeoutMs
+	 * @return
+	 */
+	ReturnValue_t acquire(uint32_t timeoutMs) = 0;
 
+	/**
+	 * Corrensponding call to release a semaphore.
+	 * @return
+	 */
+	ReturnValue_t release() = 0;
+
+	/**
+	 * If the semaphore is a counting semaphore then the semaphores current
+	 * count value is returned. If the semaphore is a binary semaphore then 1
+	 * is returned if the semaphore is available, and 0 is returned if the
+	 * semaphore is not available.
+	 * @return
+	 */
+	uint8_t getSemaphoreCounter() = 0;
+};
 
 #endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */

From 4dd6594845deb381b80fcb2ba8e0ec27acec27e1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 19:38:02 +0200
Subject: [PATCH 0281/1774] integrated interface into bin semaphore

---
 osal/FreeRTOS/BinarySemaphore.cpp | 11 +++++++++++
 osal/FreeRTOS/BinarySemaphore.h   | 11 +++++++++--
 tasks/SemaphoreIF.h               | 14 +++++++-------
 3 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index acfc53bdd..c0300b817 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -132,6 +132,17 @@ void BinarySemaphore::resetSemaphore() {
 	}
 }
 
+ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
+	return takeBinarySemaphore(timeoutMs);
+}
+
+ReturnValue_t BinarySemaphore::release() {
+	return giveBinarySemaphore();
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounter() {
+	return uxSemaphoreGetCount(handle);
+}
 
 // Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 865da8a61..8271d9d09 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-
+#include <framework/tasks/SemaphoreIF.h>
 extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
@@ -21,7 +21,8 @@ extern "C" {
  * @author 	R. Mueller
  * @ingroup osal
  */
-class BinarySemaphore: public HasReturnvaluesIF {
+class BinarySemaphore: public SemaphoreIF,
+		public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 
@@ -67,6 +68,12 @@ public:
 	 */
 	virtual ~BinarySemaphore();
 
+	ReturnValue_t acquire(uint32_t timeoutMs =
+	        BinarySemaphore::NO_BLOCK_TIMEOUT) override;
+	ReturnValue_t release() override;
+
+	uint8_t getSemaphoreCounter() override;
+
 	/**
 	 * Take the binary semaphore.
 	 * If the semaphore has already been taken, the task will be blocked
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index cf56f6f90..616b992d0 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -9,10 +9,11 @@
  * 			task synchronization.
  */
 class SemaphoreIF {
+public:
+	virtual~ SemaphoreIF() {};
 	//!< Needs to be defined in implementation.
 	static const uint32_t NO_TIMEOUT;
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-
 	//! Semaphore timeout
 	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
 	//! The current semaphore can not be given, because it is not owned
@@ -26,24 +27,23 @@ class SemaphoreIF {
 	 * for a maximum of timeoutMs while trying to acquire the semaphore.
 	 * This can be used to achieve task synchrnization.
 	 * @param timeoutMs
-	 * @return
+	 * @return - c RETURN_OK for successfull acquisition
 	 */
-	ReturnValue_t acquire(uint32_t timeoutMs) = 0;
+	virtual ReturnValue_t acquire(uint32_t timeoutMs) = 0;
 
 	/**
 	 * Corrensponding call to release a semaphore.
-	 * @return
+	 * @return -@c RETURN_OK for successfull release
 	 */
-	ReturnValue_t release() = 0;
+	virtual ReturnValue_t release() = 0;
 
 	/**
 	 * If the semaphore is a counting semaphore then the semaphores current
 	 * count value is returned. If the semaphore is a binary semaphore then 1
 	 * is returned if the semaphore is available, and 0 is returned if the
 	 * semaphore is not available.
-	 * @return
 	 */
-	uint8_t getSemaphoreCounter() = 0;
+	virtual uint8_t getSemaphoreCounter() = 0;
 };
 
 #endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */

From b1d9d55f50a0e242ec57604934659c7fff50eb01 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 19:42:05 +0200
Subject: [PATCH 0282/1774] improved documentation

---
 tasks/SemaphoreIF.h | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index 616b992d0..7dde27f43 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -6,7 +6,16 @@
 
 /**
  * @brief 	Generic interface for semaphores, which can be used to achieve
- * 			task synchronization.
+ * 			task synchronization. This is a generic interface which can be
+ * 			used for both binary semaphores and counting semaphores.
+ * @details
+ * A semaphore is a synchronization primitive.
+ * See: https://en.wikipedia.org/wiki/Semaphore_(programming)
+ * A semaphore can be used to achieve task synchonization and track the
+ * availability of resources.
+ *
+ * If mutual exlcusion of a resource is desired, a mutex should be used,
+ * which is a special form of a semaphore and has an own interface.
  */
 class SemaphoreIF {
 public:

From 067cd9573100952c1398b956a8b7d2cbeab93a3a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 19:42:45 +0200
Subject: [PATCH 0283/1774] removed file header

---
 osal/FreeRTOS/BinarySemaphore.cpp | 5 -----
 osal/FreeRTOS/BinarySemaphore.h   | 1 -
 2 files changed, 6 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index c0300b817..e48507020 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -1,8 +1,3 @@
-/**
- * @file BinarySemaphore.cpp
- *
- * @date 25.02.2020
- */
 #include <framework/osal/FreeRTOS/BinarySemaphore.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 8271d9d09..854cbba42 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -71,7 +71,6 @@ public:
 	ReturnValue_t acquire(uint32_t timeoutMs =
 	        BinarySemaphore::NO_BLOCK_TIMEOUT) override;
 	ReturnValue_t release() override;
-
 	uint8_t getSemaphoreCounter() override;
 
 	/**

From 7227c3a8667a1ead8c4160b8372d350e79617de4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 20:35:13 +0200
Subject: [PATCH 0284/1774] implemented semaph factory

---
 osal/FreeRTOS/BinarySemaphore.cpp   | 45 +++++++++++++------------
 osal/FreeRTOS/BinarySemaphore.h     | 52 +++++++++++------------------
 osal/FreeRTOS/CountingSemaphore.cpp | 26 +++++++++++++++
 osal/FreeRTOS/CountingSemaphore.h   | 21 ++++++++++++
 osal/FreeRTOS/Mutex.h               |  8 ++---
 osal/FreeRTOS/MutexFactory.cpp      |  9 ++---
 osal/FreeRTOS/SemaphoreFactory.cpp  | 33 ++++++++++++++++++
 tasks/SemaphoreFactory.h            | 45 +++++++++++++++++++++++++
 8 files changed, 177 insertions(+), 62 deletions(-)
 create mode 100644 osal/FreeRTOS/CountingSemaphore.cpp
 create mode 100644 osal/FreeRTOS/CountingSemaphore.h
 create mode 100644 osal/FreeRTOS/SemaphoreFactory.cpp
 create mode 100644 tasks/SemaphoreFactory.h

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index e48507020..11e481531 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -3,21 +3,21 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-BinarySemaphore::BinarySemaphore() {
+Semaphore::Semaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
-		sif::error << "Binary semaphore creation failure" << std::endl;
+		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
 	}
 	xSemaphoreGive(handle);
 }
 
-BinarySemaphore::~BinarySemaphore() {
+Semaphore::~Semaphore() {
 	vSemaphoreDelete(handle);
 }
 
 // This copy ctor is important as it prevents the assignment to a ressource
 // (other.handle) variable which is later deleted!
-BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
+Semaphore::Semaphore(const Semaphore& other) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         sif::error << "Binary semaphore creation failure" << std::endl;
@@ -25,7 +25,7 @@ BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
     xSemaphoreGive(handle);
 }
 
-BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
+Semaphore& Semaphore::operator =(const Semaphore& s) {
     if(this != &s) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
@@ -36,7 +36,7 @@ BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     return *this;
 }
 
-BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
+Semaphore::Semaphore(Semaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         sif::error << "Binary semaphore creation failure" << std::endl;
@@ -44,8 +44,8 @@ BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     xSemaphoreGive(handle);
 }
 
-BinarySemaphore& BinarySemaphore::operator =(
-        BinarySemaphore&& s) {
+Semaphore& Semaphore::operator =(
+        Semaphore&& s) {
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
@@ -56,15 +56,15 @@ BinarySemaphore& BinarySemaphore::operator =(
     return *this;
 }
 
-ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+ReturnValue_t Semaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
-	TickType_t timeout = BinarySemaphore::NO_BLOCK_TICKS;
-	if(timeoutMs == BinarySemaphore::BLOCK_TIMEOUT) {
-	    timeout = BinarySemaphore::BLOCK_TIMEOUT_TICKS;
+	TickType_t timeout = Semaphore::NO_BLOCK_TICKS;
+	if(timeoutMs == Semaphore::BLOCK_TIMEOUT) {
+	    timeout = Semaphore::BLOCK_TIMEOUT_TICKS;
 	}
-	else if(timeoutMs > BinarySemaphore::NO_BLOCK_TIMEOUT){
+	else if(timeoutMs > Semaphore::NO_BLOCK_TIMEOUT){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
@@ -77,7 +77,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	}
 }
 
-ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
+ReturnValue_t Semaphore::takeBinarySemaphoreTickTimeout(
         TickType_t timeoutTicks) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
@@ -91,7 +91,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
 	}
 }
 
-ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
+ReturnValue_t Semaphore::giveBinarySemaphore() {
 	if (handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -103,11 +103,11 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
 	}
 }
 
-SemaphoreHandle_t BinarySemaphore::getSemaphore() {
+SemaphoreHandle_t Semaphore::getSemaphore() {
 	return handle;
 }
 
-ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+ReturnValue_t Semaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	if (semaphore == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -119,7 +119,7 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 	}
 }
 
-void BinarySemaphore::resetSemaphore() {
+void Semaphore::resetSemaphore() {
 	if(handle != nullptr) {
 		vSemaphoreDelete(handle);
 		handle = xSemaphoreCreateBinary();
@@ -127,20 +127,20 @@ void BinarySemaphore::resetSemaphore() {
 	}
 }
 
-ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
+ReturnValue_t Semaphore::acquire(uint32_t timeoutMs) {
 	return takeBinarySemaphore(timeoutMs);
 }
 
-ReturnValue_t BinarySemaphore::release() {
+ReturnValue_t Semaphore::release() {
 	return giveBinarySemaphore();
 }
 
-uint8_t BinarySemaphore::getSemaphoreCounter() {
+uint8_t Semaphore::getSemaphoreCounter() {
 	return uxSemaphoreGetCount(handle);
 }
 
 // Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+ReturnValue_t Semaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
@@ -157,3 +157,4 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 		return SEMAPHORE_NOT_OWNED;
 	}
 }
+
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 854cbba42..6383432f7 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -14,14 +14,16 @@ extern "C" {
 // 		 and switch between the classes with #ifdefs.
 //		 Task Notifications require FreeRTOS V8.2 something..
 /**
- * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
+ * @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
  *
  * @author 	R. Mueller
  * @ingroup osal
  */
-class BinarySemaphore: public SemaphoreIF,
+class Semaphore: public SemaphoreIF,
 		public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
@@ -41,35 +43,21 @@ public:
 	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
 	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
 
-	BinarySemaphore();
-
-	/**
-	 * @brief Copy ctor
-	 */
-	BinarySemaphore(const BinarySemaphore&);
-
-	/**
-	 * @brief Copy assignment
-	 */
-	BinarySemaphore& operator=(const BinarySemaphore&);
-
-	/**
-	 * @brief Move constructor
-	 */
-	BinarySemaphore (BinarySemaphore &&);
-
-	/**
-	 * Move assignment
-	 */
-	BinarySemaphore & operator=(BinarySemaphore &&);
-
-	/**
-	 * Delete the binary semaphore to prevent a memory leak
-	 */
-	virtual ~BinarySemaphore();
+	//! @brief Default ctor
+	Semaphore();
+	//! @brief Copy ctor
+	Semaphore(const Semaphore&);
+	//! @brief Copy assignment
+	Semaphore& operator=(const Semaphore&);
+	//! @brief Move ctor
+	Semaphore (Semaphore &&);
+	//! @brief Move assignment
+	Semaphore & operator=(Semaphore &&);
+	//! @brief Destructor
+	virtual ~Semaphore();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	        BinarySemaphore::NO_BLOCK_TIMEOUT) override;
+	        Semaphore::NO_BLOCK_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() override;
 
@@ -83,7 +71,7 @@ public:
 	 *         -@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	        BinarySemaphore::NO_BLOCK_TIMEOUT);
+	        Semaphore::NO_BLOCK_TIMEOUT);
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -92,7 +80,7 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
-	        BinarySemaphore::NO_BLOCK_TICKS);
+	        Semaphore::NO_BLOCK_TICKS);
 
 	/**
 	 * Give back the binary semaphore
@@ -130,7 +118,7 @@ public:
 	 */
 	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 				BaseType_t * higherPriorityTaskWoken);
-private:
+protected:
 	SemaphoreHandle_t handle;
 };
 
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
new file mode 100644
index 000000000..adf3f23c9
--- /dev/null
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -0,0 +1,26 @@
+#include <framework/osal/FreeRTOS/CountingSemaphore.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+CountingSemaphore::CountingSemaphore(uint8_t count, uint8_t initCount):
+		count(count), initCount(initCount) {
+	handle = xSemaphoreCreateCounting(count, initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+}
+
+CountingSemaphore::CountingSemaphore(CountingSemaphore&& other) {
+	handle = xSemaphoreCreateCounting(other.count, other.initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+}
+
+CountingSemaphore& CountingSemaphore::operator =(
+		CountingSemaphore&& other) {
+	handle = xSemaphoreCreateCounting(other.count, other.initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+	return * this;
+}
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
new file mode 100644
index 000000000..8c059af52
--- /dev/null
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -0,0 +1,21 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
+#include <framework/osal/FreeRTOS/BinarySemaphore.h>
+
+class CountingSemaphore: public Semaphore {
+public:
+	CountingSemaphore(uint8_t count, 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 &&);
+private:
+	uint8_t count = 0;
+	uint8_t initCount = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 91f295853..ccbcad26c 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -3,10 +3,10 @@
 
 #include <framework/ipc/MutexIF.h>
 
-
-#include <FreeRTOS.h>
-#include "semphr.h"
-
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+}
 
 
 class Mutex : public MutexIF {
diff --git a/osal/FreeRTOS/MutexFactory.cpp b/osal/FreeRTOS/MutexFactory.cpp
index cadb54fbd..08cd68c8b 100644
--- a/osal/FreeRTOS/MutexFactory.cpp
+++ b/osal/FreeRTOS/MutexFactory.cpp
@@ -1,10 +1,11 @@
 #include <framework/ipc/MutexFactory.h>
 
-#include "../FreeRTOS/Mutex.h"
+#include <framework/osal/FreeRTOS/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
+//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 = NULL;
+MutexFactory* MutexFactory::factoryInstance = nullptr;
 
 MutexFactory::MutexFactory() {
 }
@@ -13,7 +14,7 @@ MutexFactory::~MutexFactory() {
 }
 
 MutexFactory* MutexFactory::instance() {
-	if (factoryInstance == NULL){
+	if (factoryInstance == nullptr){
 		factoryInstance = new MutexFactory();
 	}
 	return MutexFactory::factoryInstance;
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
new file mode 100644
index 000000000..dd319025d
--- /dev/null
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -0,0 +1,33 @@
+#include <framework/osal/FreeRTOS/BinarySemaphore.h>
+#include <framework/osal/FreeRTOS/CountingSemaphore.h>
+#include <framework/tasks/SemaphoreFactory.h>
+#include <framework/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() {
+	return new Semaphore();
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
+		uint8_t initCount) {
+	return new CountingSemaphore(count, initCount);
+}
+
+void SemaphoreFactory::deleteMutex(SemaphoreIF* semaphore) {
+	delete semaphore;
+}
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
new file mode 100644
index 000000000..fa95399a1
--- /dev/null
+++ b/tasks/SemaphoreFactory.h
@@ -0,0 +1,45 @@
+#ifndef FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
+#define FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
+#include <framework/tasks/SemaphoreIF.h>
+
+/**
+ * Creates Semaphore.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class SemaphoreFactory {
+public:
+	virtual ~SemaphoreFactory();
+	/**
+	 * Returns the single instance of SemaphoreFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static SemaphoreFactory* instance();
+
+	/**
+	 * Create a binary semaphore.
+	 * Creator function for a binary semaphore which may only be acquired once
+	 * @return Pointer to newly created semaphore class instance.
+	 */
+	SemaphoreIF* createBinarySemaphore();
+	/**
+	 * Create a counting semaphore.
+	 * Creator functons for a counting semaphore which may be acquired multiple
+	 * times.
+	 * @param count Semaphore can be taken count times.
+	 * @param initCount Initial count value.
+	 * @return
+	 */
+	SemaphoreIF* createCountingSemaphore(uint8_t count, uint8_t initCount);
+	void deleteMutex(SemaphoreIF* mutex);
+
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	SemaphoreFactory();
+	static SemaphoreFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_ */

From 066930b110730c8c781f0b680e1f7b99f1dbe920 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 20:39:48 +0200
Subject: [PATCH 0285/1774] improvements

---
 osal/FreeRTOS/BinarySemaphore.cpp  | 42 +++++++++++++++---------------
 osal/FreeRTOS/BinarySemaphore.h    | 20 +++++++-------
 osal/FreeRTOS/CountingSemaphore.h  | 10 ++++++-
 osal/FreeRTOS/SemaphoreFactory.cpp |  2 +-
 4 files changed, 41 insertions(+), 33 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 11e481531..f08e3b814 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -3,7 +3,7 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-Semaphore::Semaphore() {
+BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
 		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
@@ -11,13 +11,13 @@ Semaphore::Semaphore() {
 	xSemaphoreGive(handle);
 }
 
-Semaphore::~Semaphore() {
+BinarySemaphore::~BinarySemaphore() {
 	vSemaphoreDelete(handle);
 }
 
 // This copy ctor is important as it prevents the assignment to a ressource
 // (other.handle) variable which is later deleted!
-Semaphore::Semaphore(const Semaphore& other) {
+BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         sif::error << "Binary semaphore creation failure" << std::endl;
@@ -25,7 +25,7 @@ Semaphore::Semaphore(const Semaphore& other) {
     xSemaphoreGive(handle);
 }
 
-Semaphore& Semaphore::operator =(const Semaphore& s) {
+BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     if(this != &s) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
@@ -36,7 +36,7 @@ Semaphore& Semaphore::operator =(const Semaphore& s) {
     return *this;
 }
 
-Semaphore::Semaphore(Semaphore&& s) {
+BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         sif::error << "Binary semaphore creation failure" << std::endl;
@@ -44,8 +44,8 @@ Semaphore::Semaphore(Semaphore&& s) {
     xSemaphoreGive(handle);
 }
 
-Semaphore& Semaphore::operator =(
-        Semaphore&& s) {
+BinarySemaphore& BinarySemaphore::operator =(
+        BinarySemaphore&& s) {
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
@@ -56,15 +56,15 @@ Semaphore& Semaphore::operator =(
     return *this;
 }
 
-ReturnValue_t Semaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
-	TickType_t timeout = Semaphore::NO_BLOCK_TICKS;
-	if(timeoutMs == Semaphore::BLOCK_TIMEOUT) {
-	    timeout = Semaphore::BLOCK_TIMEOUT_TICKS;
+	TickType_t timeout = BinarySemaphore::NO_BLOCK_TICKS;
+	if(timeoutMs == BinarySemaphore::BLOCK_TIMEOUT) {
+	    timeout = BinarySemaphore::BLOCK_TIMEOUT_TICKS;
 	}
-	else if(timeoutMs > Semaphore::NO_BLOCK_TIMEOUT){
+	else if(timeoutMs > BinarySemaphore::NO_BLOCK_TIMEOUT){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
@@ -77,7 +77,7 @@ ReturnValue_t Semaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	}
 }
 
-ReturnValue_t Semaphore::takeBinarySemaphoreTickTimeout(
+ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
         TickType_t timeoutTicks) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
@@ -91,7 +91,7 @@ ReturnValue_t Semaphore::takeBinarySemaphoreTickTimeout(
 	}
 }
 
-ReturnValue_t Semaphore::giveBinarySemaphore() {
+ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
 	if (handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -103,11 +103,11 @@ ReturnValue_t Semaphore::giveBinarySemaphore() {
 	}
 }
 
-SemaphoreHandle_t Semaphore::getSemaphore() {
+SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 	return handle;
 }
 
-ReturnValue_t Semaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	if (semaphore == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -119,7 +119,7 @@ ReturnValue_t Semaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	}
 }
 
-void Semaphore::resetSemaphore() {
+void BinarySemaphore::resetSemaphore() {
 	if(handle != nullptr) {
 		vSemaphoreDelete(handle);
 		handle = xSemaphoreCreateBinary();
@@ -127,20 +127,20 @@ void Semaphore::resetSemaphore() {
 	}
 }
 
-ReturnValue_t Semaphore::acquire(uint32_t timeoutMs) {
+ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	return takeBinarySemaphore(timeoutMs);
 }
 
-ReturnValue_t Semaphore::release() {
+ReturnValue_t BinarySemaphore::release() {
 	return giveBinarySemaphore();
 }
 
-uint8_t Semaphore::getSemaphoreCounter() {
+uint8_t BinarySemaphore::getSemaphoreCounter() {
 	return uxSemaphoreGetCount(handle);
 }
 
 // Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t Semaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 6383432f7..bd4ddb953 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -23,7 +23,7 @@ extern "C" {
  * @author 	R. Mueller
  * @ingroup osal
  */
-class Semaphore: public SemaphoreIF,
+class BinarySemaphore: public SemaphoreIF,
 		public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
@@ -44,20 +44,20 @@ public:
 	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
 
 	//! @brief Default ctor
-	Semaphore();
+	BinarySemaphore();
 	//! @brief Copy ctor
-	Semaphore(const Semaphore&);
+	BinarySemaphore(const BinarySemaphore&);
 	//! @brief Copy assignment
-	Semaphore& operator=(const Semaphore&);
+	BinarySemaphore& operator=(const BinarySemaphore&);
 	//! @brief Move ctor
-	Semaphore (Semaphore &&);
+	BinarySemaphore (BinarySemaphore &&);
 	//! @brief Move assignment
-	Semaphore & operator=(Semaphore &&);
+	BinarySemaphore & operator=(BinarySemaphore &&);
 	//! @brief Destructor
-	virtual ~Semaphore();
+	virtual ~BinarySemaphore();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	        Semaphore::NO_BLOCK_TIMEOUT) override;
+	        BinarySemaphore::NO_BLOCK_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() override;
 
@@ -71,7 +71,7 @@ public:
 	 *         -@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	        Semaphore::NO_BLOCK_TIMEOUT);
+	        BinarySemaphore::NO_BLOCK_TIMEOUT);
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -80,7 +80,7 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
-	        Semaphore::NO_BLOCK_TICKS);
+	        BinarySemaphore::NO_BLOCK_TICKS);
 
 	/**
 	 * Give back the binary semaphore
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index 8c059af52..a33a0fa5a 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -2,7 +2,15 @@
 #define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
 #include <framework/osal/FreeRTOS/BinarySemaphore.h>
 
-class CountingSemaphore: public Semaphore {
+/**
+ * @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(uint8_t count, uint8_t initCount);
 	//! @brief Copy ctor, disabled
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index dd319025d..9a3558913 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -20,7 +20,7 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 }
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore() {
-	return new Semaphore();
+	return new BinarySemaphore();
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,

From 2790a40d6c35d27bb8e86121e02c6ca9f0ddf4ef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 18:55:13 +0200
Subject: [PATCH 0286/1774] some renamings

---
 tmtcpacket/pus/TcPacketBase.cpp   | 30 +++++++++++++++---------------
 tmtcpacket/pus/TcPacketBase.h     |  4 ++--
 tmtcpacket/pus/TcPacketStored.cpp |  2 +-
 3 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 0972ffff2..32caf5bbd 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -13,28 +13,28 @@ TcPacketBase::~TcPacketBase() {
 }
 
 uint8_t TcPacketBase::getService() {
-	return tcData->data_field.service_type;
+	return tcData->dataField.service_type;
 }
 
 uint8_t TcPacketBase::getSubService() {
-	return tcData->data_field.service_subtype;
+	return tcData->dataField.service_subtype;
 }
 
 uint8_t TcPacketBase::getAcknowledgeFlags() {
-	return tcData->data_field.version_type_ack & 0b00001111;
+	return tcData->dataField.version_type_ack & 0b00001111;
 }
 
 const uint8_t* TcPacketBase::getApplicationData() const {
-	return &tcData->data;
+	return &tcData->appData;
 }
 
 uint16_t TcPacketBase::getApplicationDataSize() {
-	return getPacketDataLength() - sizeof(tcData->data_field) - CRC_SIZE + 1;
+	return getPacketDataLength() - sizeof(tcData->dataField) - CRC_SIZE + 1;
 }
 
 uint16_t TcPacketBase::getErrorControl() {
 	uint16_t size = getApplicationDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tcData->data;
+	uint8_t* p_to_buffer = &tcData->appData;
 	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
 }
 
@@ -42,8 +42,8 @@ void TcPacketBase::setErrorControl() {
 	uint32_t full_size = getFullSize();
 	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
 	uint32_t size = getApplicationDataSize();
-	(&tcData->data)[size] = (crc & 0XFF00) >> 8;	// CRCH
-	(&tcData->data)[size + 1] = (crc) & 0X00FF; 		// CRCL
+	(&tcData->appData)[size] = (crc & 0XFF00) >> 8;	// CRCH
+	(&tcData->appData)[size + 1] = (crc) & 0X00FF; 		// CRCL
 }
 
 void TcPacketBase::setData(const uint8_t* pData) {
@@ -59,11 +59,11 @@ void TcPacketBase::setApplicationData(const uint8_t * pData, uint16_t dataLen) {
 }
 
 uint8_t TcPacketBase::getSecondaryHeaderFlag() {
-	return (tcData->data_field.version_type_ack & 0b10000000) >> 7;
+	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
 }
 
 uint8_t TcPacketBase::getPusVersionNumber() {
-	return (tcData->data_field.version_type_ack & 0b01110000) >> 4;
+	return (tcData->dataField.version_type_ack & 0b01110000) >> 4;
 }
 
 void TcPacketBase::print() {
@@ -78,14 +78,14 @@ void TcPacketBase::print() {
 void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
 		uint8_t ack, uint8_t service, uint8_t subservice) {
 	initSpacePacketHeader(true, true, apid, sequenceCount);
-	memset(&tcData->data_field, 0, sizeof(tcData->data_field));
+	memset(&tcData->dataField, 0, sizeof(tcData->dataField));
 	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
 	//Data Field Header:
 	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
-	tcData->data_field.version_type_ack = 0b00010000;
-	tcData->data_field.version_type_ack |= (ack & 0x0F);
-	tcData->data_field.service_type = service;
-	tcData->data_field.service_subtype = subservice;
+	tcData->dataField.version_type_ack = 0b00010000;
+	tcData->dataField.version_type_ack |= (ack & 0x0F);
+	tcData->dataField.service_type = service;
+	tcData->dataField.service_subtype = subservice;
 }
 
 size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index 136aaa0b8..9b858bd95 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -24,8 +24,8 @@ struct PUSTcDataFieldHeader {
  */
 struct TcPacketPointer {
 	CCSDSPrimaryHeader primary;
-	PUSTcDataFieldHeader data_field;
-	uint8_t data;
+	PUSTcDataFieldHeader dataField;
+	uint8_t appData;
 };
 
 /**
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 57b90bcc7..47cf2ecd7 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -24,7 +24,7 @@ TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
 	}
 	this->setData(p_data);
 	initializeTcPacket(apid, sequence_count, ack, service, subservice);
-	memcpy(&tcData->data, data, size);
+	memcpy(&tcData->appData, data, size);
 	this->setPacketDataLength(
 			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
 	this->setErrorControl();

From f612b095c1c508466098576866827dc065dc9809 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 19:39:19 +0200
Subject: [PATCH 0287/1774] updated tmtc packet base

---
 tmtcpacket/pus/TcPacketBase.cpp |  7 +++----
 tmtcpacket/pus/TcPacketBase.h   | 15 +++++++++------
 tmtcpacket/pus/TmPacketBase.cpp |  5 +++++
 tmtcpacket/pus/TmPacketBase.h   |  7 +++++++
 4 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 32caf5bbd..733c36dfc 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -51,11 +51,10 @@ void TcPacketBase::setData(const uint8_t* pData) {
 	tcData = (TcPacketPointer*) pData;
 }
 
-void TcPacketBase::setApplicationData(const uint8_t * pData, uint16_t dataLen) {
-	setData(pData);
-	// packet data length is actual size of data field minus 1
+void TcPacketBase::setAppData(uint8_t * appData, uint16_t dataLen) {
+	memcpy(&tcData->appData, appData, dataLen);
 	SpacePacketBase::setPacketDataLength(dataLen +
-			sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
+				sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
 }
 
 uint8_t TcPacketBase::getSecondaryHeaderFlag() {
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index 9b858bd95..730761769 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -168,6 +168,14 @@ public:
 	 * current content of the packet.
 	 */
 	void setErrorControl();
+
+	/**
+	 * Copies the supplied data to the internal TC application data field.
+	 * @param pData
+	 * @param dataLen
+	 */
+	void setAppData(uint8_t * appData, uint16_t dataLen);
+
 	/**
 	 * With this method, the packet data pointer can be redirected to another
 	 * location.
@@ -178,12 +186,7 @@ public:
 	 * @param p_data	A pointer to another PUS Telecommand Packet.
 	 */
 	void setData( const uint8_t* pData );
-	/**
-	 * Set application data and corresponding length field.
-	 * @param pData
-	 * @param dataLen
-	 */
-	void setApplicationData(const uint8_t * pData, uint16_t dataLen);
+
 	/**
 	 * This is a debugging helper method that prints the whole packet content
 	 * to the screen.
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index a7bda5afc..a2c27ce15 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -102,6 +102,11 @@ void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t su
 	}
 }
 
+void TmPacketBase::setSourceData(uint8_t* sourceData, size_t sourceSize) {
+	memcpy(getSourceData(), sourceData, sourceSize);
+	setSourceDataSize(sourceSize);
+}
+
 void TmPacketBase::setSourceDataSize(uint16_t size) {
 	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
 }
diff --git a/tmtcpacket/pus/TmPacketBase.h b/tmtcpacket/pus/TmPacketBase.h
index d03beba52..6f3c4b597 100644
--- a/tmtcpacket/pus/TmPacketBase.h
+++ b/tmtcpacket/pus/TmPacketBase.h
@@ -125,6 +125,13 @@ public:
 	 * current content of the packet.
 	 */
 	void setErrorControl();
+	/**
+	 * This sets the source data. It copies the provided data to
+	 * the internal TmPacketPointer source data location.
+	 * @param sourceData
+	 * @param sourceSize
+	 */
+	void setSourceData(uint8_t* sourceData, size_t sourceSize);
 	/**
 	 * With this method, the packet data pointer can be redirected to another
 	 * location.

From e2418d61a6263f67f2db96ac265f0e271766a28c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 19:53:10 +0200
Subject: [PATCH 0288/1774] improved printer

---
 globalfunctions/printer.cpp | 24 +++++++++++++++++-------
 globalfunctions/printer.h   |  7 ++++---
 2 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index bf4c5848b..01ec532cd 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -1,36 +1,46 @@
 #include <framework/globalfunctions/printer.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-void printer::print(uint8_t *data, size_t size, OutputType type) {
-	sif::info << "Printing data with size " << size << ": [";
+void printer::print(uint8_t *data, size_t size, OutputType type, bool printInfo,
+		size_t maxCharPerLine) {
+	if(printInfo) {
+		sif::info << "Printing data with size " << size << ": ";
+	}
+	sif::info << "[";
 	if(type == OutputType::HEX) {
-		printer::printHex(data, size);
+		printer::printHex(data, size, maxCharPerLine);
 	}
 	else {
-		printer::printDec(data, size);
+		printer::printDec(data, size, maxCharPerLine);
 	}
 }
 
-void printer::printHex(uint8_t *data, size_t size) {
+void printer::printHex(uint8_t *data, size_t size, size_t maxCharPerLine) {
 	sif::info << std::hex;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
 		if(i < size - 1){
 			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
 		}
+
 	}
 	sif::info << std::dec;
 	sif::info << "]" << std::endl;
 }
 
-void printer::printDec(uint8_t *data, size_t size) {
+void printer::printDec(uint8_t *data, size_t size, size_t maxCharPerLine) {
 	sif::info << std::dec;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
 		if(i < size - 1){
 			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
 		}
 	}
 	sif::info << "]" << std::endl;
 }
-
diff --git a/globalfunctions/printer.h b/globalfunctions/printer.h
index 3c9d6aa08..db9f343f1 100644
--- a/globalfunctions/printer.h
+++ b/globalfunctions/printer.h
@@ -10,9 +10,10 @@ enum class OutputType {
 	HEX
 };
 
-void print(uint8_t* data, size_t size, OutputType type = OutputType::HEX);
-void printHex(uint8_t* data, size_t size);
-void printDec(uint8_t* data, size_t size);
+void print(uint8_t* data, size_t size, OutputType type = OutputType::HEX,
+		bool printInfo = true, size_t maxCharPerLine = 12);
+void printHex(uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printDec(uint8_t* data, size_t size, size_t maxCharPerLine = 12);
 }
 
 #endif /* FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_ */

From 1aef000eff336b97917ac4c178d95749ec9cd5dc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 20:24:58 +0200
Subject: [PATCH 0289/1774] printer improvements and fixes

tc packet stored getter function
---
 globalfunctions/printer.cpp       | 10 +++++-----
 globalfunctions/printer.h         |  6 +++---
 tmtcpacket/pus/TcPacketStored.cpp | 12 ++++++++++++
 tmtcpacket/pus/TcPacketStored.h   |  3 +++
 4 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index 01ec532cd..f099113cc 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -1,8 +1,8 @@
 #include <framework/globalfunctions/printer.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-void printer::print(uint8_t *data, size_t size, OutputType type, bool printInfo,
-		size_t maxCharPerLine) {
+void printer::print(const uint8_t *data, size_t size, OutputType type,
+		bool printInfo, size_t maxCharPerLine) {
 	if(printInfo) {
 		sif::info << "Printing data with size " << size << ": ";
 	}
@@ -15,7 +15,7 @@ void printer::print(uint8_t *data, size_t size, OutputType type, bool printInfo,
 	}
 }
 
-void printer::printHex(uint8_t *data, size_t size, size_t maxCharPerLine) {
+void printer::printHex(const uint8_t *data, size_t size, size_t maxCharPerLine) {
 	sif::info << std::hex;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
@@ -31,10 +31,10 @@ void printer::printHex(uint8_t *data, size_t size, size_t maxCharPerLine) {
 	sif::info << "]" << std::endl;
 }
 
-void printer::printDec(uint8_t *data, size_t size, size_t maxCharPerLine) {
+void printer::printDec(const uint8_t *data, size_t size, size_t maxCharPerLine) {
 	sif::info << std::dec;
 	for(size_t i = 0; i < size; i++) {
-		sif::info << "0x" << static_cast<int>(data[i]);
+		sif::info << static_cast<int>(data[i]);
 		if(i < size - 1){
 			sif::info << " , ";
 			if(i > 0 and i % maxCharPerLine == 0) {
diff --git a/globalfunctions/printer.h b/globalfunctions/printer.h
index db9f343f1..76d28e5f7 100644
--- a/globalfunctions/printer.h
+++ b/globalfunctions/printer.h
@@ -10,10 +10,10 @@ enum class OutputType {
 	HEX
 };
 
-void print(uint8_t* data, size_t size, OutputType type = OutputType::HEX,
+void print(const uint8_t* data, size_t size, OutputType type = OutputType::HEX,
 		bool printInfo = true, size_t maxCharPerLine = 12);
-void printHex(uint8_t* data, size_t size, size_t maxCharPerLine = 12);
-void printDec(uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printHex(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printDec(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
 }
 
 #endif /* FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_ */
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 47cf2ecd7..64aa74dca 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -1,6 +1,7 @@
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/tmtcpacket/pus/TcPacketStored.h>
+
 #include <cstring>
 
 TcPacketStored::TcPacketStored(store_address_t setAddress) :
@@ -20,6 +21,8 @@ TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
 			(TC_PACKET_MIN_SIZE + size), &p_data);
 	if (returnValue != this->store->RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get free element from store!"
+				<< std::endl;
 		return;
 	}
 	this->setData(p_data);
@@ -30,6 +33,15 @@ TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
 	this->setErrorControl();
 }
 
+ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
+		size_t* dataSize) {
+	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
+	}
+	return result;
+}
+
 TcPacketStored::TcPacketStored() :
 		TcPacketBase(NULL) {
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h
index a9c49c2e6..de3eb85f7 100644
--- a/tmtcpacket/pus/TcPacketStored.h
+++ b/tmtcpacket/pus/TcPacketStored.h
@@ -74,6 +74,9 @@ public:
 	 * @param Size size of the packet.
 	 */
 	TcPacketStored( const uint8_t* data, uint32_t size);
+
+	ReturnValue_t getData(const uint8_t ** dataPtr,
+			size_t* dataSize);
 	/**
 	 * This is a getter for the current store address of the packet.
 	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if

From 7afaa752f37422254f962982a41038afb0fbe8da Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 20:25:54 +0200
Subject: [PATCH 0290/1774] form improvement

---
 globalfunctions/printer.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index f099113cc..b71d70b80 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -15,7 +15,8 @@ void printer::print(const uint8_t *data, size_t size, OutputType type,
 	}
 }
 
-void printer::printHex(const uint8_t *data, size_t size, size_t maxCharPerLine) {
+void printer::printHex(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
 	sif::info << std::hex;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
@@ -31,7 +32,8 @@ void printer::printHex(const uint8_t *data, size_t size, size_t maxCharPerLine)
 	sif::info << "]" << std::endl;
 }
 
-void printer::printDec(const uint8_t *data, size_t size, size_t maxCharPerLine) {
+void printer::printDec(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
 	sif::info << std::dec;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << static_cast<int>(data[i]);

From 9b53e2b64fe9327f55eb12b393a91c666b836dde Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 22:45:48 +0200
Subject: [PATCH 0291/1774] added informative comment for counting semaphore

---
 osal/FreeRTOS/CountingSemaphore.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index adf3f23c9..2b81848a2 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,6 +1,8 @@
 #include <framework/osal/FreeRTOS/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+// Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
+// free FreeRTOSConfig.h file.
 CountingSemaphore::CountingSemaphore(uint8_t count, uint8_t initCount):
 		count(count), initCount(initCount) {
 	handle = xSemaphoreCreateCounting(count, initCount);

From 338651af2f7a67422cda787b56b513f020325df4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 23:07:28 +0200
Subject: [PATCH 0292/1774] binary printer added

---
 globalfunctions/printer.cpp | 15 ++++++++++++++-
 globalfunctions/printer.h   |  4 +++-
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index b71d70b80..a68a91ee2 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -1,5 +1,6 @@
 #include <framework/globalfunctions/printer.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <bitset>
 
 void printer::print(const uint8_t *data, size_t size, OutputType type,
 		bool printInfo, size_t maxCharPerLine) {
@@ -10,9 +11,12 @@ void printer::print(const uint8_t *data, size_t size, OutputType type,
 	if(type == OutputType::HEX) {
 		printer::printHex(data, size, maxCharPerLine);
 	}
-	else {
+	else if (type == OutputType::DEC) {
 		printer::printDec(data, size, maxCharPerLine);
 	}
+	else if(type == OutputType::BIN) {
+	    printer::printBin(data, size);
+	}
 }
 
 void printer::printHex(const uint8_t *data, size_t size,
@@ -46,3 +50,12 @@ void printer::printDec(const uint8_t *data, size_t size,
 	}
 	sif::info << "]" << std::endl;
 }
+
+void printer::printBin(const uint8_t *data, size_t size) {
+    sif::info << "\n" << std::flush;
+    for(size_t i = 0; i < size; i++) {
+        sif::info << "Byte " << i + 1 << ": 0b"<<
+                std::bitset<8>(data[i]) << ",\n" << std::flush;
+    }
+    sif::info << "]" << std::endl;
+}
diff --git a/globalfunctions/printer.h b/globalfunctions/printer.h
index 76d28e5f7..33a382ecc 100644
--- a/globalfunctions/printer.h
+++ b/globalfunctions/printer.h
@@ -7,13 +7,15 @@ namespace printer {
 
 enum class OutputType {
 	DEC,
-	HEX
+	HEX,
+	BIN
 };
 
 void print(const uint8_t* data, size_t size, OutputType type = OutputType::HEX,
 		bool printInfo = true, size_t maxCharPerLine = 12);
 void printHex(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
 void printDec(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printBin(const uint8_t* data, size_t size);
 }
 
 #endif /* FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_ */

From f6b17d6e2ea6156d06214937c70bee305707a836 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 20 May 2020 12:50:56 +0200
Subject: [PATCH 0293/1774] deleted copyctor and copy assignment

---
 osal/FreeRTOS/BinarySemaphore.cpp | 21 ---------------------
 osal/FreeRTOS/BinarySemaphore.h   |  8 ++++----
 2 files changed, 4 insertions(+), 25 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index c4a363b4f..026704d63 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -15,27 +15,6 @@ BinarySemaphore::~BinarySemaphore() {
 	vSemaphoreDelete(handle);
 }
 
-// This copy ctor is important as it prevents the assignment to a ressource
-// (other.handle) variable which is later deleted!
-BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
-    handle = xSemaphoreCreateBinary();
-    if(handle == nullptr) {
-        sif::error << "Binary semaphore creation failure" << std::endl;
-    }
-    xSemaphoreGive(handle);
-}
-
-BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
-    if(this != &s) {
-        handle = xSemaphoreCreateBinary();
-        if(handle == nullptr) {
-            sif::error << "Binary semaphore creation failure" << std::endl;
-        }
-        xSemaphoreGive(handle);
-    }
-    return *this;
-}
-
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 0c9c09926..5f69dc90b 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -39,10 +39,10 @@ public:
 
 	//! @brief Default ctor
 	BinarySemaphore();
-	//! @brief Copy ctor
-	BinarySemaphore(const BinarySemaphore&);
-	//! @brief Copy assignment
-	BinarySemaphore& operator=(const 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

From d2d1ef9a854727a0381ccab719d2a8cba8a4acf0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 22 May 2020 00:58:30 +0200
Subject: [PATCH 0294/1774] better include guards

---
 storagemanager/LocalPool.tpp     |  4 ++--
 storagemanager/PoolManager.h     |  4 ++--
 storagemanager/PoolManager.tpp   |  4 ++--
 storagemanager/StorageAccessor.h | 25 +++++++++++--------------
 4 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 59d06ab80..32724bd8c 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -1,5 +1,5 @@
-#ifndef LOCALPOOL_TPP
-#define LOCALPOOL_TPP
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
+#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
 
 template<uint8_t NUMBER_OF_POOLS>
 inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 87670a828..6e353de22 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,5 +1,5 @@
-#ifndef POOLMANAGER_H_
-#define POOLMANAGER_H_
+#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
 
 #include <framework/storagemanager/LocalPool.h>
 #include <framework/ipc/MutexHelper.h>
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 7025d7959..854e22daa 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -1,5 +1,5 @@
-#ifndef POOLMANAGER_TPP_
-#define POOLMANAGER_TPP_
+#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
+#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 
 template<uint8_t NUMBER_OF_POOLS>
 inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 8949642cd..f6964b934 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,22 +1,19 @@
-/**
- * @brief 	Helper classes to facilitate safe access to storages which is also
- * 			conforming to RAII principles
- * @details	These helper can be used together with the
- * 			StorageManager classes to manage access to a storage.
- * 			It can take care of thread-safety while also providing
- * 			mechanisms to automatically clear storage data.
- */
-#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
-#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
+#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
 
 #include <framework/ipc/MutexHelper.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-#include <memory>
 
 /**
- * @brief   Accessor class which can be returned by pool managers
- *          or passed and set by pool managers to have safe access to the pool
- *          resources.
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details
+ * Accessor class which can be returned by pool manager or passed and set by
+ * pool managers to have safe access to the pool resources.
+ *
+ * These helper can be used together with the StorageManager classes to manage
+ * access to a storage. It can take care of thread-safety while also providing
+ * mechanisms to automatically clear storage data.
  */
 class ConstStorageAccessor {
 	//! StorageManager classes have exclusive access to private variables.

From d4abfacd27b09c17f898e80c62f969610a5d6367 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 22 May 2020 01:15:02 +0200
Subject: [PATCH 0295/1774] found solution for circ dependency

had to put store_address_t in own file though
---
 storagemanager/StorageAccessor.cpp |  1 +
 storagemanager/StorageAccessor.h   |  4 ++-
 storagemanager/StorageManagerIF.h  | 56 ++----------------------------
 storagemanager/storeAddress.h      | 54 ++++++++++++++++++++++++++++
 4 files changed, 61 insertions(+), 54 deletions(-)
 create mode 100644 storagemanager/storeAddress.h

diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index cc292d6cc..c0c8126b7 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,4 +1,5 @@
 #include <framework/storagemanager/StorageAccessor.h>
+#include <framework/storagemanager/StorageManagerIF.h>
 
 ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
 		storeId(storeId) {}
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index f6964b934..57c9369ce 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -2,7 +2,9 @@
 #define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
 
 #include <framework/ipc/MutexHelper.h>
-#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/storagemanager/storeAddress.h>
+
+class StorageManagerIF;
 
 /**
  * @brief 	Helper classes to facilitate safe access to storages which is also
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 559c4b9a8..af5aeb732 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -3,64 +3,14 @@
 
 #include <framework/events/Event.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstddef>
+#include <framework/storagemanager/StorageAccessor.h>
+#include <framework/storagemanager/storeAddress.h>
 #include <utility>
-
-class StorageAccessor;
-class ConstStorageAccessor;
+#include <cstddef>
 
 using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
 using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
 
-/**
- * This union defines the type that identifies where a data packet is
- * stored in the store. It comprises of a raw part to read it as raw value and
- * a structured part to use it in pool-like stores.
- */
-union store_address_t {
-	/**
-	 * Default Constructor, initializing to INVALID_ADDRESS
-	 */
-	store_address_t():raw(0xFFFFFFFF){}
-	/**
-	 * Constructor to create an address object using the raw address
-	 *
-	 * @param rawAddress
-	 */
-	store_address_t(uint32_t rawAddress):raw(rawAddress){}
-
-	/**
-	 * Constructor to create an address object using pool
-	 * and packet indices
-	 *
-	 * @param poolIndex
-	 * @param packetIndex
-	 */
-	store_address_t(uint16_t poolIndex, uint16_t packetIndex):
-		pool_index(poolIndex),packet_index(packetIndex){}
-	/**
-	 * A structure with two elements to access the store address pool-like.
-	 */
-	struct {
-		/**
-		 * The index in which pool the packet lies.
-		 */
-		uint16_t pool_index;
-		/**
-		 * The position in the chosen pool.
-		 */
-		uint16_t packet_index;
-	};
-	/**
-	 * Alternative access to the raw value.
-	 */
-	uint32_t raw;
-
-	bool operator==(const store_address_t& other) const {
-		return raw == other.raw;
-	}
-};
-
 /**
  * @brief	This class provides an interface for intermediate data storage.
  * @details	The Storage manager classes shall be used to store larger chunks of
diff --git a/storagemanager/storeAddress.h b/storagemanager/storeAddress.h
new file mode 100644
index 000000000..5dd785a3e
--- /dev/null
+++ b/storagemanager/storeAddress.h
@@ -0,0 +1,54 @@
+#ifndef FRAMEWORK_STORAGEMANAGER_STOREADDRESS_H_
+#define FRAMEWORK_STORAGEMANAGER_STOREADDRESS_H_
+#include <cstdint>
+
+/**
+ * This union defines the type that identifies where a data packet is
+ * stored in the store. It comprises of a raw part to read it as raw value and
+ * a structured part to use it in pool-like stores.
+ */
+union store_address_t {
+	/**
+	 * Default Constructor, initializing to INVALID_ADDRESS
+	 */
+	store_address_t():raw(0xFFFFFFFF){}
+	/**
+	 * Constructor to create an address object using the raw address
+	 *
+	 * @param rawAddress
+	 */
+	store_address_t(uint32_t rawAddress):raw(rawAddress){}
+
+	/**
+	 * Constructor to create an address object using pool
+	 * and packet indices
+	 *
+	 * @param poolIndex
+	 * @param packetIndex
+	 */
+	store_address_t(uint16_t poolIndex, uint16_t packetIndex):
+		pool_index(poolIndex),packet_index(packetIndex){}
+	/**
+	 * A structure with two elements to access the store address pool-like.
+	 */
+	struct {
+		/**
+		 * The index in which pool the packet lies.
+		 */
+		uint16_t pool_index;
+		/**
+		 * The position in the chosen pool.
+		 */
+		uint16_t packet_index;
+	};
+	/**
+	 * Alternative access to the raw value.
+	 */
+	uint32_t raw;
+
+	bool operator==(const store_address_t& other) const {
+		return raw == other.raw;
+	}
+};
+
+#endif /* FRAMEWORK_STORAGEMANAGER_STOREADDRESS_H_ */

From 2f16b1e7336a1b174bfc0da4ae5437c925c6ac21 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 13:48:43 +0200
Subject: [PATCH 0296/1774] moved some files

---
 datapool/PoolRawAccessHelper.h               | 2 +-
 datapoolglob/DataPoolAdmin.cpp               | 2 +-
 datapoolglob/DataPoolParameterWrapper.cpp    | 2 +-
 {datapool => datapoolglob}/PIDReader.h       | 0
 {datapool => datapoolglob}/PIDReaderList.h   | 8 ++++----
 {datapool => datapoolglob}/PoolRawAccess.cpp | 2 +-
 {datapool => datapoolglob}/PoolRawAccess.h   | 0
 monitoring/MonitorBase.h                     | 2 +-
 power/Fuse.h                                 | 2 +-
 power/PowerSensor.h                          | 2 +-
 10 files changed, 11 insertions(+), 11 deletions(-)
 rename {datapool => datapoolglob}/PIDReader.h (100%)
 rename {datapool => datapoolglob}/PIDReaderList.h (73%)
 rename {datapool => datapoolglob}/PoolRawAccess.cpp (99%)
 rename {datapool => datapoolglob}/PoolRawAccess.h (100%)

diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index f2434241c..52d9ebe5b 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -7,9 +7,9 @@
 #ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
 #define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
 
-#include <framework/datapool/PoolRawAccess.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/PoolRawAccess.h>
 
 /**
  * @brief 	This helper function simplifies accessing data pool entries
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index f32ff567e..05de1eb2a 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,7 +1,7 @@
 #include <framework/datapoolglob/DataPoolAdmin.h>
-#include <framework/datapool/PoolRawAccess.h>
 #include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/GlobalDataPool.h>
+#include <framework/datapoolglob/PoolRawAccess.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/parameters/ParameterMessage.h>
diff --git a/datapoolglob/DataPoolParameterWrapper.cpp b/datapoolglob/DataPoolParameterWrapper.cpp
index d93cd88e5..062cff122 100644
--- a/datapoolglob/DataPoolParameterWrapper.cpp
+++ b/datapoolglob/DataPoolParameterWrapper.cpp
@@ -1,6 +1,6 @@
 #include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/DataPoolParameterWrapper.h>
-#include <framework/datapool/PoolRawAccess.h>
+#include <framework/datapoolglob/PoolRawAccess.h>
 #include <framework/parameters/HasParametersIF.h>
 
 
diff --git a/datapool/PIDReader.h b/datapoolglob/PIDReader.h
similarity index 100%
rename from datapool/PIDReader.h
rename to datapoolglob/PIDReader.h
diff --git a/datapool/PIDReaderList.h b/datapoolglob/PIDReaderList.h
similarity index 73%
rename from datapool/PIDReaderList.h
rename to datapoolglob/PIDReaderList.h
index 07d1b8e6d..0b8385081 100644
--- a/datapool/PIDReaderList.h
+++ b/datapoolglob/PIDReaderList.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_DATAPOOL_PIDREADERLIST_H_
-#define FRAMEWORK_DATAPOOL_PIDREADERLIST_H_
+#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
+#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
 
-#include <framework/datapool/PIDReader.h>
 #include <framework/datapool/PoolVariableIF.h>
+#include <framework/datapoolglob/PIDReader.h>
 template <class T, uint8_t n_var>
 class PIDReaderList {
 private:
@@ -24,4 +24,4 @@ public:
 
 
 
-#endif /* FRAMEWORK_DATAPOOL_PIDREADERLIST_H_ */
+#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
diff --git a/datapool/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
similarity index 99%
rename from datapool/PoolRawAccess.cpp
rename to datapoolglob/PoolRawAccess.cpp
index 778e1b9c2..cc04f9b92 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -1,5 +1,5 @@
 #include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapool/PoolRawAccess.h>
+#include <framework/datapoolglob/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
 
diff --git a/datapool/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
similarity index 100%
rename from datapool/PoolRawAccess.h
rename to datapoolglob/PoolRawAccess.h
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index d66e956d1..f18ca4b5c 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -2,7 +2,7 @@
 #define MONITORBASE_H_
 
 #include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapool/PIDReader.h>
+#include <framework/datapoolglob/PIDReader.h>
 #include <framework/monitoring/LimitViolationReporter.h>
 #include <framework/monitoring/MonitoringIF.h>
 #include <framework/monitoring/MonitoringMessageContent.h>
diff --git a/power/Fuse.h b/power/Fuse.h
index 44f8964f8..0f258b63b 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -3,7 +3,7 @@
 
 #include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/datapool/PIDReader.h>
+#include <framework/datapoolglob/PIDReader.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/monitoring/AbsLimitMonitor.h>
 #include <framework/power/PowerComponentIF.h>
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index f94088a8a..0fb47506c 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -2,8 +2,8 @@
 #define POWERSENSOR_H_
 
 #include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapool/PIDReader.h>
 #include <framework/datapoolglob/GlobalPoolVariable.h>
+#include <framework/datapoolglob/PIDReader.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/monitoring/LimitMonitor.h>
 #include <framework/parameters/ParameterHelper.h>

From 723e715022e6d5ada2dfdee9da5a6f3d7450faa9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 14:01:35 +0200
Subject: [PATCH 0297/1774] consistency fix

---
 storagemanager/LocalPool.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 6892b881b..c155f918b 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -12,7 +12,7 @@
 /**
  * @brief	The LocalPool class provides an intermediate data storage with
  * 			a fixed pool size policy.
- * \details	The class implements the StorageManagerIF interface. While the
+ * @details	The class implements the StorageManagerIF interface. While the
  * 			total number of pools is fixed, the element sizes in one pool and
  * 			the number of pool elements per pool are set on construction.
  * 			The full amount of memory is allocated on construction.

From a37f01cd0ee31c57f8f76f3b299c2f51718e9d85 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 23:11:56 +0200
Subject: [PATCH 0298/1774] improved readability of mode explanations

---
 devicehandlers/DeviceHandlerIF.h | 60 ++++++++++++++++++++++++++------
 1 file changed, 49 insertions(+), 11 deletions(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 34aa41144..59ee1853b 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -28,19 +28,57 @@ public:
 
 	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
-	static const Mode_t MODE_RAW = 3; //!< The device is powered on and ready to perform operations. In this mode, raw commands can be sent. The device handler will send all replies received from the command back to the commanding object.
-	static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
-	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The device handler performs all commands to get the device in a state ready to perform commands. When this is completed, the mode changes to @c MODE_ON.
-	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6; //!< This is a transitional state which can not be commanded. The device handler performs all actions and commands to get the device shut down. When the device is off, the mode changes to @c MODE_OFF.
-	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON; //!< It is possible to set the mode to _MODE_TO_ON to use the to on transition if available.
+	//!< The device is powered on and the device handler periodically sends
+	//! commands. The commands to be sent are selected by the handler
+	//! according to the submode.
+	static const Mode_t MODE_NORMAL = 2;
+	//! The device is powered on and ready to perform operations. In this mode,
+	//! raw commands can be sent. The device handler will send all replies
+	//! received from the command back to the commanding object.
+	static const Mode_t MODE_RAW = 3;
+	//! The device is shut down but the switch could not be turned off, so the
+	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
+	//! can be commanded, which tries to switch off the device again.
+	static const Mode_t MODE_ERROR_ON = 4;
+	//! This is a transitional state which can not be commanded. The device
+	//! handler performs all commands to get the device in a state ready to
+	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
+	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
+	//! This is a transitional state which can not be commanded.
+	//! The device handler performs all actions and commands to get the device
+	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
+	//! It is possible to set the mode to _MODE_TO_ON to use the to on
+	//! transition if available.
+	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
+	//! transition if available.
 	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
+	//! transition if available.
 	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
-	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1; //!< This is a transitional state which can not be commanded. The device is shut down and ready to be switched off. After the command to set the switch off has been sent, the mode changes to @c MODE_WAIT_OFF
-	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2; //!< This is a transitional state which can not be commanded. The device will be switched on in this state. After the command to set the switch on has been sent, the mode changes to @c MODE_WAIT_ON
-	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3; //!< This is a transitional state which can not be commanded. The switch has been commanded off and the handler waits for it to be off. When the switch is off, the mode changes to @c MODE_OFF.
-	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4; //!< This is a transitional state which can not be commanded. The switch has been commanded on and the handler waits for it to be on. When the switch is on, the mode changes to @c MODE_TO_ON.
-	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The switch has been commanded off and is off now. This state is only to do an RMAP cycle once more where the doSendRead() function will set the mode to MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board
+	//! This is a transitional state which can not be commanded.
+	//! The device is shut down and ready to be switched off.
+	//! After the command to set the switch off has been sent,
+	//! the mode changes to @c MODE_WAIT_OFF
+	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
+	//! This is a transitional state which can not be commanded. The device
+	//! will be switched on in this state. After the command to set the switch
+	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
+	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and the handler waits for it to be off.
+	//! When the switch is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
+	//! This is a transitional state which can not be commanded. The switch
+	//! has been commanded on and the handler waits for it to be on.
+	//! When the switch is on, the mode changes to @c MODE_TO_ON.
+	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and is off now. This state is only to do an RMAP
+	//! cycle once more where the doSendRead() function will set the mode to
+	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
+	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
 	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);

From 18d19fbb2c7575cf7b880e0caebf5cbcbc447358 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 23:12:25 +0200
Subject: [PATCH 0299/1774] < removed

---
 devicehandlers/DeviceHandlerIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 59ee1853b..f6b29e255 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -28,7 +28,7 @@ public:
 
 	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	//!< The device is powered on and the device handler periodically sends
+	//! The device is powered on and the device handler periodically sends
 	//! commands. The commands to be sent are selected by the handler
 	//! according to the submode.
 	static const Mode_t MODE_NORMAL = 2;

From eacda67f027dc24a65f60f08b837b2358aa094f5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 23:36:03 +0200
Subject: [PATCH 0300/1774] added some comments for returnvalues

---
 devicehandlers/DeviceHandlerBase.h | 34 ++++++++++++++++--------------
 1 file changed, 18 insertions(+), 16 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 454f0751f..cfa9396a7 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -509,26 +509,28 @@ protected:
 	 */
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
 
-	/**
-	 * These returnvalues can be returned from abstract functions
+	/* These returnvalues can be returned from abstract functions
 	 * to alter the behaviour of DHB.For error values, refer to
-	 * DeviceHandlerIF.h returnvalues.
-	 */
-	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(4);
+	 * DeviceHandlerIF.h returnvalues. */
+	// (Robin): maybe this would be better in DeviceHandlerIF?
+	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(0xA0);
+
 	// Returnvalues for scanForReply()
-	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5); //!< This is used to specify for replies from a device which are not replies to requests
-	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6); //!< Ignore parts of the received packet
-	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(7); //!< Ignore full received packet
+	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB0); //!< This is used to specify for replies from a device which are not replies to requests
+	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB1); //!< Ignore parts of the received packet
+	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB2); //!< Ignore full received packet
 
-//	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
-//	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
-	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(10);
-	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(11);
-	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(12);
+	// Returnvalues for command building
+	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0); //!< Return this if no command sending in required
+	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xC1);
+	// (Robin): Maybe this would be better in DeviceHandlerIF?
+	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
+	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC3);
 
-	//Mode handling error Codes
-	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE2);
+	// (Robin): Maybe this would be better in DeviceHandlerIF?
+	// Mode handling error Codes
+	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xD0);
+	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xD1);
 
 	static const DeviceCommandId_t RAW_COMMAND_ID = -1;
 	static const DeviceCommandId_t NO_COMMAND_ID = -2;

From 243ea9cd8782a4edd74259351b8fb536fdf95bca Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 23:38:51 +0200
Subject: [PATCH 0301/1774] improved dhb IF returnvalues

---
 devicehandlers/DeviceHandlerIF.h | 119 ++++++++++++++++++-------------
 1 file changed, 69 insertions(+), 50 deletions(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 34aa41144..666d9efc3 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -28,19 +28,57 @@ public:
 
 	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
-	static const Mode_t MODE_RAW = 3; //!< The device is powered on and ready to perform operations. In this mode, raw commands can be sent. The device handler will send all replies received from the command back to the commanding object.
-	static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
-	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The device handler performs all commands to get the device in a state ready to perform commands. When this is completed, the mode changes to @c MODE_ON.
-	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6; //!< This is a transitional state which can not be commanded. The device handler performs all actions and commands to get the device shut down. When the device is off, the mode changes to @c MODE_OFF.
-	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON; //!< It is possible to set the mode to _MODE_TO_ON to use the to on transition if available.
+	//! The device is powered on and the device handler periodically sends
+	//! commands. The commands to be sent are selected by the handler
+	//! according to the submode.
+	static const Mode_t MODE_NORMAL = 2;
+	//! The device is powered on and ready to perform operations. In this mode,
+	//! raw commands can be sent. The device handler will send all replies
+	//! received from the command back to the commanding object.
+	static const Mode_t MODE_RAW = 3;
+	//! The device is shut down but the switch could not be turned off, so the
+	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
+	//! can be commanded, which tries to switch off the device again.
+	static const Mode_t MODE_ERROR_ON = 4;
+	//! This is a transitional state which can not be commanded. The device
+	//! handler performs all commands to get the device in a state ready to
+	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
+	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
+	//! This is a transitional state which can not be commanded.
+	//! The device handler performs all actions and commands to get the device
+	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
+	//! It is possible to set the mode to _MODE_TO_ON to use the to on
+	//! transition if available.
+	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
+	//! transition if available.
 	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
+	//! transition if available.
 	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
-	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1; //!< This is a transitional state which can not be commanded. The device is shut down and ready to be switched off. After the command to set the switch off has been sent, the mode changes to @c MODE_WAIT_OFF
-	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2; //!< This is a transitional state which can not be commanded. The device will be switched on in this state. After the command to set the switch on has been sent, the mode changes to @c MODE_WAIT_ON
-	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3; //!< This is a transitional state which can not be commanded. The switch has been commanded off and the handler waits for it to be off. When the switch is off, the mode changes to @c MODE_OFF.
-	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4; //!< This is a transitional state which can not be commanded. The switch has been commanded on and the handler waits for it to be on. When the switch is on, the mode changes to @c MODE_TO_ON.
-	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The switch has been commanded off and is off now. This state is only to do an RMAP cycle once more where the doSendRead() function will set the mode to MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board
+	//! This is a transitional state which can not be commanded.
+	//! The device is shut down and ready to be switched off.
+	//! After the command to set the switch off has been sent,
+	//! the mode changes to @c MODE_WAIT_OFF
+	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
+	//! This is a transitional state which can not be commanded. The device
+	//! will be switched on in this state. After the command to set the switch
+	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
+	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and the handler waits for it to be off.
+	//! When the switch is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
+	//! This is a transitional state which can not be commanded. The switch
+	//! has been commanded on and the handler waits for it to be on.
+	//! When the switch is on, the mode changes to @c MODE_TO_ON.
+	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and is off now. This state is only to do an RMAP
+	//! cycle once more where the doSendRead() function will set the mode to
+	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
+	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
 	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
@@ -58,47 +96,34 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 
 	// Standard codes used when building commands.
-	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xA0); //!< Return this if no command sending in required
-	// Mostly used for internal handling.
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA2); //!< If the command size is 0. Checked in DHB
-	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA3); //!< Used to indicate that this is a command-only command.
-	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA4); //!< Command ID not in commandMap. Checked in DHB
-	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA5); //!< Command was already executed. Checked in DHB
-	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA6);
-	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA7);
-	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA8);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA9);
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xAA);
-	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xAB);
-	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAC);
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If the command size is 0. Checked in DHB
+	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
+	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
+	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
+	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
+	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
+	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
 
 	// Standard codes used in scanForReply
-	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB1); //!< This is used to specify for replies from a device which are not replies to requests
-	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB2);
-	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB3); //!< Ignore parts of the received packet
-	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB4); //!< Ignore full received packet
-	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB5);
-	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB6);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB7);
+	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB0);
+	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB2);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB3);
 
 	// Standard codes used in  interpretDeviceReply
-	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC1); //the device reported, that it did not execute the command
-	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC2);
-	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC3); //the deviceCommandId reported by scanforReply is unknown
-	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC4); //syntax etc is correct but still not ok, eg parameters where none are expected
+	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
+	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
+	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
 
 	// Standard codes used in buildCommandFromCommand
 	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
 	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
 
-	// Standard codes used in getSwitches
-	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xE1); //!< Return in getSwitches() to specify there are no switches
-
-	//	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
-	//	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
-	// where is this used?
-	// static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(11);
-
 	/**
 	 * Communication action that will be executed.
 	 *
@@ -115,16 +140,10 @@ public:
 	/**
 	 * Default Destructor
 	 */
-	virtual ~DeviceHandlerIF() {
-
-	}
+	virtual ~DeviceHandlerIF() {}
 
 	/**
 	 * This MessageQueue is used to command the device handler.
-	 *
-	 * To command a device handler, a DeviceHandlerCommandMessage can be sent to this Queue.
-	 * The handler replies with a DeviceHandlerCommandMessage containing the DeviceHandlerCommand_t reply.
-	 *
 	 * @return the id of the MessageQueue
 	 */
 	virtual MessageQueueId_t getCommandQueue() const = 0;

From 3fd306356a4b2eefeb78bf6f4cf6d197b7c5c7ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 23:43:44 +0200
Subject: [PATCH 0302/1774] fix for dh returnvalues

---
 devicehandlers/DeviceHandlerBase.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index cfa9396a7..74b841118 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -522,15 +522,16 @@ protected:
 
 	// Returnvalues for command building
 	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0); //!< Return this if no command sending in required
-	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xC1);
 	// (Robin): Maybe this would be better in DeviceHandlerIF?
 	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
-	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC3);
+
+	// Returnvalues for getSwitches()
+	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xD0);
 
 	// (Robin): Maybe this would be better in DeviceHandlerIF?
 	// Mode handling error Codes
-	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xD0);
-	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xD1);
+	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE1);
 
 	static const DeviceCommandId_t RAW_COMMAND_ID = -1;
 	static const DeviceCommandId_t NO_COMMAND_ID = -2;

From 242ca355f51008eb9ada619295cf397dbc49ae35 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 26 May 2020 00:01:07 +0200
Subject: [PATCH 0303/1774] removed swappers for arraylist for now

---
 container/ArrayList.h      | 19 -------------------
 container/FixedArrayList.h |  9 +++------
 2 files changed, 3 insertions(+), 25 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index f978c984d..a37a1c424 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -250,25 +250,6 @@ protected:
 	 * true if the array was allocated and needs to be deleted in the destructor.
 	 */
 	bool allocated;
-
-	/**
-	 * Swap the endianness of the Array list (not the length field !)
-	 * Useful if the case the buffer type is larger than uint8_t
-	 * @param list
-	 */
-	void swapArrayListEndianness() {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		count_t i = 0;
-		// uint8_t buffer does not require swapping of entries.
-		if(sizeof(T) == 1) {
-			return;
-		}
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < size)) {
-			T newEntry = EndianSwapper::swap(entries[i]);
-			entries[i] = newEntry;
-			++i;
-		}
-	}
 };
 
 #endif /* ARRAYLIST_H_ */
diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index 5d93db90c..a2d2fa25a 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -20,7 +20,8 @@ public:
 			ArrayList<T, count_t>(data, MAX_SIZE) {
 	}
 
-	// (Robin): We could create a constructor to initialize the fixed array list with data and the known size field
+	// (Robin): We could create a constructor to initialize the fixed array list
+	// with data and the known size field
 	// so it can be used for serialization too (with SerialFixedArrrayListAdapter)
 	// is this feasible?
 	/**
@@ -30,14 +31,10 @@ public:
 	 * @param count
 	 * @param swapArrayListEndianess
 	 */
-	FixedArrayList(T * data_, count_t count,
-			bool swapArrayListEndianess = false):
+	FixedArrayList(T * data_, count_t count):
 		ArrayList<T, count_t>(data, MAX_SIZE) {
 		memcpy(this->data, data_, count * sizeof(T));
 		this->size = count;
-		if(swapArrayListEndianess) {
-			ArrayList<T, count_t>::swapArrayListEndianness();
-		}
 	}
 
 	FixedArrayList(const FixedArrayList& other) :

From 9f2d5b64e009349a03be6990f43b8a3fddc5a02b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 26 May 2020 01:03:26 +0200
Subject: [PATCH 0304/1774] comment improvements

---
 devicehandlers/DeviceHandlerBase.cpp |  2 +-
 devicehandlers/DeviceHandlerBase.h   | 36 ++++++++++++++++++----------
 2 files changed, 25 insertions(+), 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 23ec1f189..6c769cdf0 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -417,7 +417,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);
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 74b841118..8932e109e 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -740,28 +740,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);

From a19fa231f51c6b83c0417afe08e208e2bc8c2563 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 26 May 2020 01:21:48 +0200
Subject: [PATCH 0305/1774] comment improvements

---
 devicehandlers/DeviceHandlerBase.h | 5 +++--
 devicehandlers/DeviceHandlerIF.h   | 2 ++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 8932e109e..832d7e087 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -232,8 +232,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
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 666d9efc3..cb1903444 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -47,6 +47,8 @@ public:
 	//! This is a transitional state which can not be commanded.
 	//! The device handler performs all actions and commands to get the device
 	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
+	//! transition if available.
 	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
 	//! It is possible to set the mode to _MODE_TO_ON to use the to on
 	//! transition if available.

From 1a623a6a527599efc6ee8d4e28e85c405c58cb9a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 26 May 2020 11:05:49 +0200
Subject: [PATCH 0306/1774] added override

---
 devicehandlers/DeviceHandlerBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 832d7e087..244be322f 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -494,7 +494,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
 	 *

From f7dd91891a644c660ff8ae7d6c183e84faf75d9a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 26 May 2020 16:05:03 +0200
Subject: [PATCH 0307/1774] removed comments

---
 devicehandlers/DeviceHandlerBase.h | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 244be322f..1debcdcb8 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -510,26 +510,16 @@ protected:
 	 */
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
 
-	/* These returnvalues can be returned from abstract functions
-	 * to alter the behaviour of DHB.For error values, refer to
-	 * DeviceHandlerIF.h returnvalues. */
-	// (Robin): maybe this would be better in DeviceHandlerIF?
 	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(0xA0);
-
 	// Returnvalues for scanForReply()
 	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB0); //!< This is used to specify for replies from a device which are not replies to requests
 	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB1); //!< Ignore parts of the received packet
 	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB2); //!< Ignore full received packet
-
 	// Returnvalues for command building
 	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0); //!< Return this if no command sending in required
-	// (Robin): Maybe this would be better in DeviceHandlerIF?
 	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
-
 	// Returnvalues for getSwitches()
 	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xD0);
-
-	// (Robin): Maybe this would be better in DeviceHandlerIF?
 	// Mode handling error Codes
 	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE0);
 	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE1);

From be4ac0bc8fa03faee1330a9899cb9051485eebba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 00:28:13 +0200
Subject: [PATCH 0308/1774] added semaph factory to linux

---
 osal/FreeRTOS/BinarySemaphore.cpp |  2 ++
 osal/linux/SemaphoreFactory.cpp   | 36 +++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+)
 create mode 100644 osal/linux/SemaphoreFactory.cpp

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 026704d63..e6c308db5 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -3,6 +3,8 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
+
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
new file mode 100644
index 000000000..7b80176b0
--- /dev/null
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -0,0 +1,36 @@
+#include <framework/tasks/SemaphoreFactory.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
+
+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() {
+	sif::error << "Semaphore not implemented for Linux yet" << std::endl;
+	return nullptr;
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
+		uint8_t initCount) {
+	sif::error << "Counting Semaphore not implemented for "
+			"Linux yet" << std::endl;
+	return nullptr;
+}
+
+void SemaphoreFactory::deleteMutex(SemaphoreIF* semaphore) {
+	delete semaphore;
+}

From f6ae0348cb50dddefa867dc3a0344dac99efef2e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 11:41:36 +0200
Subject: [PATCH 0309/1774] some linux mutex tweaks

---
 osal/linux/Mutex.cpp | 4 +++-
 osal/linux/Mutex.h   | 4 ++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index 36bb3ce43..b47732672 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -25,7 +25,9 @@ Mutex::Mutex() {
 		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
 				<< ", " << " failed with " << strerror(status) << std::endl;
 	}
-	//After a mutex attributes object has been used to initialize one or more mutexes, any function affecting the attributes object (including destruction) shall not affect any previously initialized mutexes.
+	// After a mutex attributes object has been used to initialize one or more
+	// mutexes, any function affecting the attributes object
+	// (including destruction) shall not affect any previously initialized mutexes.
 	status = pthread_mutexattr_destroy(&mutexAttr);
 	if (status != 0) {
 		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index d02d008fe..872ac3ac4 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -2,7 +2,11 @@
 #define OS_RTEMS_MUTEX_H_
 
 #include <framework/ipc/MutexIF.h>
+
+extern "C" {
 #include <pthread.h>
+}
+
 
 class Mutex : public MutexIF {
 public:

From badcacad49e3790df3cda101dc9da973287238de Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 11:48:11 +0200
Subject: [PATCH 0310/1774] added new timeout values

---
 osal/FreeRTOS/BinarySemaphore.cpp  | 2 --
 osal/FreeRTOS/SemaphoreFactory.cpp | 2 ++
 osal/linux/SemaphoreFactory.cpp    | 1 +
 tasks/SemaphoreIF.h                | 4 +++-
 4 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index e6c308db5..026704d63 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -3,8 +3,6 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
-
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 9a3558913..7bd71dd7a 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -4,6 +4,8 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
+const uint32_t SemaphoreIF::MAX_TIMEOUT = portMAX_DELAY;
 
 SemaphoreFactory::SemaphoreFactory() {
 }
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index 7b80176b0..b1100e750 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -2,6 +2,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
+const uint32_t SemaphoreIF::MAX_TIMEOUT = 0xFFFFFFFF;
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index 7dde27f43..b2b113f17 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -20,8 +20,10 @@
 class SemaphoreIF {
 public:
 	virtual~ SemaphoreIF() {};
-	//!< Needs to be defined in implementation.
+	//! Needs to be defined in implementation. No blocking time
 	static const uint32_t NO_TIMEOUT;
+	//! Needs to be defined in implementation. Blocks indefinitely.
+	static const uint32_t MAX_TIMEOUT;
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 	//! Semaphore timeout
 	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);

From 968d7fad815877213c154845bc058140e47ee91b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 17:07:35 +0200
Subject: [PATCH 0311/1774] replaced some timeout values

---
 osal/FreeRTOS/BinarySemaphore.cpp |  9 ++++-----
 osal/FreeRTOS/BinarySemaphore.h   | 20 ++++++--------------
 2 files changed, 10 insertions(+), 19 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 026704d63..98911ad19 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -1,6 +1,5 @@
 #include <framework/osal/FreeRTOS/BinarySemaphore.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
-
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 BinarySemaphore::BinarySemaphore() {
@@ -39,11 +38,11 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
-	TickType_t timeout = BinarySemaphore::NO_BLOCK_TICKS;
-	if(timeoutMs == BinarySemaphore::BLOCK_TIMEOUT) {
-	    timeout = BinarySemaphore::BLOCK_TIMEOUT_TICKS;
+	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
+	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	    timeout = SemaphoreIF::MAX_TIMEOUT;
 	}
-	else if(timeoutMs > BinarySemaphore::NO_BLOCK_TIMEOUT){
+	else if(timeoutMs > BinarySemaphore::NO_TIMEOUT){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 5f69dc90b..7079e91f8 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -3,13 +3,14 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/tasks/SemaphoreIF.h>
+
 extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
 }
 
-// TODO: Counting semaphores and implement the new (better)
-//		 task notifications. However, those use task notifications require
+// TODO: Implement the new (better) task notifications.
+//		 However, those task notifications require
 //		 the task handle. Maybe it would be better to make a separate class
 // 		 and switch between the classes with #ifdefs.
 //		 Task Notifications require FreeRTOS V8.2 something..
@@ -27,15 +28,6 @@ class BinarySemaphore: public SemaphoreIF,
 		public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-
-	//! No block time, poll the semaphore. Can also be used as tick type.
-	//! Can be passed as tick type and ms value.
-	static constexpr uint32_t NO_BLOCK_TIMEOUT = 0;
-	static constexpr TickType_t NO_BLOCK_TICKS = 0;
-	//! No block time, poll the semaphore.
-	//! Can be passed as tick type and ms value.
-	static constexpr TickType_t BLOCK_TIMEOUT_TICKS = portMAX_DELAY;
-	static constexpr uint32_t BLOCK_TIMEOUT = portMAX_DELAY;
 
 	//! @brief Default ctor
 	BinarySemaphore();
@@ -51,7 +43,7 @@ public:
 	virtual ~BinarySemaphore();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	        BinarySemaphore::NO_BLOCK_TIMEOUT) override;
+	        SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() override;
 
@@ -65,7 +57,7 @@ public:
 	 *         -@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	        BinarySemaphore::NO_BLOCK_TIMEOUT);
+	       	   SemaphoreIF::NO_TIMEOUT);
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -74,7 +66,7 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
-	        BinarySemaphore::NO_BLOCK_TICKS);
+	        BinarySemaphore::NO_TIMEOUT);
 
 	/**
 	 * Give back the binary semaphore

From 2d33274c2306fd51b4ea512d5d399502755f20fa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 17:42:18 +0200
Subject: [PATCH 0312/1774] implementing new task notifications

---
 osal/FreeRTOS/BinarySemaphore.cpp | 69 +++++++++++++++++++---
 osal/FreeRTOS/BinarySemaphore.h   | 95 +++++++++++++++++++++++++++----
 2 files changed, 145 insertions(+), 19 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 98911ad19..f7e879830 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -2,6 +2,8 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+#if ( configUSE_OLD_SEMAPHORES == 1 )
+
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
@@ -51,7 +53,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-	    return SEMAPHORE_TIMEOUT;
+	    return SemaphoreIF::SEMAPHORE_TIMEOUT;
 	}
 }
 
@@ -96,14 +98,6 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
-
-void BinarySemaphore::resetSemaphore() {
-	if(handle != nullptr) {
-		vSemaphoreDelete(handle);
-		handle = xSemaphoreCreateBinary();
-		xSemaphoreGive(handle);
-	}
-}
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	return takeBinarySemaphore(timeoutMs);
@@ -135,3 +129,60 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 		return SEMAPHORE_NOT_OWNED;
 	}
 }
+
+
+#else
+
+BinarySemaphore::BinarySemaphore() {
+	handle = TaskManagement::getCurrentTaskHandle();
+}
+
+ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
+	return takeBinarySemaphore(timeoutMs);
+}
+
+ReturnValue_t BinarySemaphore::release() {
+	return giveBinarySemaphore();
+}
+
+ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
+	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	    timeout = SemaphoreIF::MAX_TIMEOUT;
+	}
+	else if(timeoutMs > BinarySemaphore::NO_TIMEOUT){
+	    timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+
+	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeout);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+	    return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
+        TickType_t timeoutTicks) {
+	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
+	if (handle == nullptr) {
+		return SEMAPHORE_NULLPOINTER;
+	}
+	BaseType_t returncode = xTaskNotifyGive(handle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
+
+#endif
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 7079e91f8..4d95fc27c 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -6,7 +6,11 @@
 
 extern "C" {
 #include <freertos/FreeRTOS.h>
+#if ( configUSE_OLD_SEMAPHORES == 1 )
 #include <freertos/semphr.h>
+#else
+#include <freertos/task.h>
+#endif
 }
 
 // TODO: Implement the new (better) task notifications.
@@ -24,11 +28,13 @@ extern "C" {
  * @author 	R. Mueller
  * @ingroup osal
  */
+#if ( configUSE_OLD_SEMAPHORES == 1 )
+
 class BinarySemaphore: public SemaphoreIF,
-		public HasReturnvaluesIF {
+		public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-
+
 	//! @brief Default ctor
 	BinarySemaphore();
 	//! @brief Copy ctor, deleted explicitely.
@@ -46,7 +52,7 @@ public:
 	        SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() override;
-
+
 	/**
 	 * Take the binary semaphore.
 	 * If the semaphore has already been taken, the task will be blocked
@@ -81,11 +87,6 @@ public:
 	 */
 	SemaphoreHandle_t getSemaphore();
 
-	/**
-	 * Reset the semaphore.
-	 */
-	void resetSemaphore();
-
 	 /**
 	 * Wrapper function to give back semaphore from handle
 	 * @param semaphore
@@ -104,9 +105,83 @@ public:
 	 */
 	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 				BaseType_t * higherPriorityTaskWoken);
-
-protected:
+
+protected:
 	SemaphoreHandle_t handle;
 };
 
+
+#else
+
+class BinarySemaphore: public SemaphoreIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! @brief Default ctor
+	BinarySemaphore();
+
+	ReturnValue_t acquire(uint32_t timeoutMs =
+	        SemaphoreIF::NO_TIMEOUT) override;
+	ReturnValue_t release() override;
+	uint8_t getSemaphoreCounter() 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 RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
+	       	   SemaphoreIF::NO_TIMEOUT);
+
+	/**
+	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
+	        BinarySemaphore::NO_TIMEOUT);
+
+	/**
+	 * Give back the binary semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t giveBinarySemaphore();
+
+	/**
+	 * Get Handle 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 giveBinarySemaphore(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
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphoreFromISR(TaskHandle_t taskToNotify,
+				BaseType_t * higherPriorityTaskWoken);
+
+protected:
+	TaskHandle_t handle;
+};
+#endif
+
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */

From 8a1e0dab0370c5b454fcb9e95de0f1349000b380 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 19:03:46 +0200
Subject: [PATCH 0313/1774] continued with task notifications

---
 osal/FreeRTOS/BinarySemaphore.cpp   | 48 ++++++++++++++++++++++++++---
 osal/FreeRTOS/BinarySemaphore.h     |  8 +++--
 osal/FreeRTOS/CountingSemaphore.cpp |  4 +++
 3 files changed, 53 insertions(+), 7 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index f7e879830..150f8c993 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -2,7 +2,7 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-#if ( configUSE_OLD_SEMAPHORES == 1 )
+#if ( configUSE_TASK_NOTIFICATIONS == 0 )
 
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
@@ -174,9 +174,6 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
-	if (handle == nullptr) {
-		return SEMAPHORE_NULLPOINTER;
-	}
 	BaseType_t returncode = xTaskNotifyGive(handle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
@@ -185,4 +182,47 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
 	}
 }
 
+TaskHandle_t BinarySemaphore::getTaskHandle() {
+	return handle;
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounter() {
+	uint32_t notificationValue;
+	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounterFromISR(TaskHandle_t taskHandle) {
+	uint32_t notificationValue;
+	BaseType_t higherPriorityTaskWoken;
+	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
+			&higherPriorityTaskWoken);
+	if(higherPriorityTaskWoken) {
+		TaskManagement::requestContextSwitch(CallContext::isr);
+	}
+	return notificationValue;
+}
+
+
+ReturnValue_t BinarySemaphore::giveBinarySemaphore(TaskHandle_t taskHandle) {
+	BaseType_t returncode = xTaskNotifyGive(taskHandle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
+
+// Be careful with the stack size here. This is called from an ISR!
+ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(
+		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
+	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
+	if(*higherPriorityTaskWoken == pdPASS) {
+		// Request context switch because unblocking the semaphore
+		// caused a high priority task unblock.
+		TaskManagement::requestContextSwitch(CallContext::isr);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 #endif
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 4d95fc27c..2ee102267 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -6,7 +6,7 @@
 
 extern "C" {
 #include <freertos/FreeRTOS.h>
-#if ( configUSE_OLD_SEMAPHORES == 1 )
+#if ( configUSE_TASK_NOTIFICATIONS == 0 )
 #include <freertos/semphr.h>
 #else
 #include <freertos/task.h>
@@ -28,7 +28,7 @@ extern "C" {
  * @author 	R. Mueller
  * @ingroup osal
  */
-#if ( configUSE_OLD_SEMAPHORES == 1 )
+#if ( configUSE_TASK_NOTIFICATIONS == 0 )
 
 class BinarySemaphore: public SemaphoreIF,
 		public HasReturnvaluesIF {
@@ -155,7 +155,7 @@ public:
 	ReturnValue_t giveBinarySemaphore();
 
 	/**
-	 * Get Handle to the semaphore.
+	 * Get handle to the task related to the semaphore.
 	 * @return
 	 */
 	TaskHandle_t getTaskHandle();
@@ -179,6 +179,8 @@ public:
 	static ReturnValue_t giveBinarySemaphoreFromISR(TaskHandle_t taskToNotify,
 				BaseType_t * higherPriorityTaskWoken);
 
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
+
 protected:
 	TaskHandle_t handle;
 };
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index 2b81848a2..e04d3defd 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,6 +1,10 @@
 #include <framework/osal/FreeRTOS/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+extern "C" {
+#include <freertos/semphr.h>
+}
+
 // Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
 // free FreeRTOSConfig.h file.
 CountingSemaphore::CountingSemaphore(uint8_t count, uint8_t initCount):

From b4065c776437b39613542d9beff87ba06e6242ad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 19:46:56 +0200
Subject: [PATCH 0314/1774] seperation of semaph implementations finished

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 95 ++++++++++++++++++++++
 osal/FreeRTOS/BinSemaphUsingTask.h        | 86 ++++++++++++++++++++
 osal/FreeRTOS/BinarySemaphore.cpp         | 99 -----------------------
 osal/FreeRTOS/BinarySemaphore.h           | 93 ++-------------------
 osal/FreeRTOS/CountingSemaphUsingTask.cpp |  8 ++
 osal/FreeRTOS/CountingSemaphUsingTask.h   | 25 ++++++
 osal/FreeRTOS/CountingSemaphore.cpp       |  2 +
 osal/FreeRTOS/SemaphoreFactory.cpp        |  6 +-
 tasks/SemaphoreFactory.h                  | 10 ++-
 9 files changed, 232 insertions(+), 192 deletions(-)
 create mode 100644 osal/FreeRTOS/BinSemaphUsingTask.cpp
 create mode 100644 osal/FreeRTOS/BinSemaphUsingTask.h
 create mode 100644 osal/FreeRTOS/CountingSemaphUsingTask.cpp
 create mode 100644 osal/FreeRTOS/CountingSemaphUsingTask.h

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
new file mode 100644
index 000000000..0d7320545
--- /dev/null
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -0,0 +1,95 @@
+#include <framework/osal/FreeRTOS/BinSemaphUsingTask.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+
+
+BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
+	handle = TaskManagement::getCurrentTaskHandle();
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
+	return takeBinarySemaphore(timeoutMs);
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::release() {
+	return giveBinarySemaphore();
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphore(uint32_t timeoutMs) {
+	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
+	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	    timeout = SemaphoreIF::MAX_TIMEOUT;
+	}
+	else if(timeoutMs > BinarySemaphoreUsingTask::NO_TIMEOUT){
+	    timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+
+	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeout);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+	    return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphoreTickTimeout(
+        TickType_t timeoutTicks) {
+	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore() {
+	BaseType_t returncode = xTaskNotifyGive(handle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
+
+TaskHandle_t BinarySemaphoreUsingTask::getTaskHandle() {
+	return handle;
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() {
+	uint32_t notificationValue;
+	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(TaskHandle_t taskHandle) {
+	uint32_t notificationValue;
+	BaseType_t higherPriorityTaskWoken;
+	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
+			&higherPriorityTaskWoken);
+	if(higherPriorityTaskWoken) {
+		TaskManagement::requestContextSwitch(CallContext::isr);
+	}
+	return notificationValue;
+}
+
+
+ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore(TaskHandle_t taskHandle) {
+	BaseType_t returncode = xTaskNotifyGive(taskHandle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
+
+// Be careful with the stack size here. This is called from an ISR!
+ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphoreFromISR(
+		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
+	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
+	if(*higherPriorityTaskWoken == pdPASS) {
+		// Request context switch because unblocking the semaphore
+		// caused a high priority task unblock.
+		TaskManagement::requestContextSwitch(CallContext::isr);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
new file mode 100644
index 000000000..2736b1db6
--- /dev/null
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -0,0 +1,86 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/tasks/SemaphoreIF.h>
+
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+}
+
+class BinarySemaphoreUsingTask: public SemaphoreIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! @brief Default ctor
+	BinarySemaphoreUsingTask();
+
+	ReturnValue_t acquire(uint32_t timeoutMs =
+	        SemaphoreIF::NO_TIMEOUT) override;
+	ReturnValue_t release() override;
+	uint8_t getSemaphoreCounter() 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 RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
+	       	   SemaphoreIF::NO_TIMEOUT);
+
+	/**
+	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
+	        SemaphoreIF::NO_TIMEOUT);
+
+	/**
+	 * Give back the binary semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t giveBinarySemaphore();
+
+	/**
+	 * 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 giveBinarySemaphore(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
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphoreFromISR(TaskHandle_t taskToNotify,
+				BaseType_t * higherPriorityTaskWoken);
+
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
+
+protected:
+	TaskHandle_t handle;
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 150f8c993..d56be763d 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -2,8 +2,6 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-#if ( configUSE_TASK_NOTIFICATIONS == 0 )
-
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
@@ -129,100 +127,3 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 		return SEMAPHORE_NOT_OWNED;
 	}
 }
-
-
-#else
-
-BinarySemaphore::BinarySemaphore() {
-	handle = TaskManagement::getCurrentTaskHandle();
-}
-
-ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
-	return takeBinarySemaphore(timeoutMs);
-}
-
-ReturnValue_t BinarySemaphore::release() {
-	return giveBinarySemaphore();
-}
-
-ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-	    timeout = SemaphoreIF::MAX_TIMEOUT;
-	}
-	else if(timeoutMs > BinarySemaphore::NO_TIMEOUT){
-	    timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-
-	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeout);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-	    return SemaphoreIF::SEMAPHORE_TIMEOUT;
-	}
-}
-
-ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
-        TickType_t timeoutTicks) {
-	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_TIMEOUT;
-	}
-}
-
-ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
-	BaseType_t returncode = xTaskNotifyGive(handle);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_NOT_OWNED;
-	}
-}
-
-TaskHandle_t BinarySemaphore::getTaskHandle() {
-	return handle;
-}
-
-uint8_t BinarySemaphore::getSemaphoreCounter() {
-	uint32_t notificationValue;
-	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
-	return notificationValue;
-}
-
-uint8_t BinarySemaphore::getSemaphoreCounterFromISR(TaskHandle_t taskHandle) {
-	uint32_t notificationValue;
-	BaseType_t higherPriorityTaskWoken;
-	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
-			&higherPriorityTaskWoken);
-	if(higherPriorityTaskWoken) {
-		TaskManagement::requestContextSwitch(CallContext::isr);
-	}
-	return notificationValue;
-}
-
-
-ReturnValue_t BinarySemaphore::giveBinarySemaphore(TaskHandle_t taskHandle) {
-	BaseType_t returncode = xTaskNotifyGive(taskHandle);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_NOT_OWNED;
-	}
-}
-
-// Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(
-		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
-	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
-	if(*higherPriorityTaskWoken == pdPASS) {
-		// Request context switch because unblocking the semaphore
-		// caused a high priority task unblock.
-		TaskManagement::requestContextSwitch(CallContext::isr);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-#endif
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 2ee102267..e5c0ce4b5 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -6,18 +6,9 @@
 
 extern "C" {
 #include <freertos/FreeRTOS.h>
-#if ( configUSE_TASK_NOTIFICATIONS == 0 )
 #include <freertos/semphr.h>
-#else
-#include <freertos/task.h>
-#endif
 }
 
-// TODO: Implement the new (better) task notifications.
-//		 However, those task notifications require
-//		 the task handle. Maybe it would be better to make a separate class
-// 		 and switch between the classes with #ifdefs.
-//		 Task Notifications require FreeRTOS V8.2 something..
 /**
  * @brief 	OS Tool to achieve synchronization of between tasks or between
  * 			task and ISR. The default semaphore implementation creates a
@@ -25,11 +16,15 @@ extern "C" {
  * @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
  */
-#if ( configUSE_TASK_NOTIFICATIONS == 0 )
-
 class BinarySemaphore: public SemaphoreIF,
 		public HasReturnvaluesIF {
 public:
@@ -110,80 +105,4 @@ protected:
 	SemaphoreHandle_t handle;
 };
 
-
-#else
-
-class BinarySemaphore: public SemaphoreIF,
-		public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-
-	//! @brief Default ctor
-	BinarySemaphore();
-
-	ReturnValue_t acquire(uint32_t timeoutMs =
-	        SemaphoreIF::NO_TIMEOUT) override;
-	ReturnValue_t release() override;
-	uint8_t getSemaphoreCounter() 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 RETURN_FAILED on failure
-	 */
-	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT);
-
-	/**
-	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
-	 * @param timeoutTicks
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
-	        BinarySemaphore::NO_TIMEOUT);
-
-	/**
-	 * Give back the binary semaphore
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t giveBinarySemaphore();
-
-	/**
-	 * 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 giveBinarySemaphore(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
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	static ReturnValue_t giveBinarySemaphoreFromISR(TaskHandle_t taskToNotify,
-				BaseType_t * higherPriorityTaskWoken);
-
-	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
-
-protected:
-	TaskHandle_t handle;
-};
-#endif
-
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
new file mode 100644
index 000000000..6c5d45c7c
--- /dev/null
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -0,0 +1,8 @@
+#include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+
+CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t count,
+		uint8_t initCount):
+		count(count), initCount(initCount) {
+	handle = TaskManagement::getCurrentTaskHandle();
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
new file mode 100644
index 000000000..c4bfb61ab
--- /dev/null
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -0,0 +1,25 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+
+#include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
+#include <framework/tasks/SemaphoreIF.h>
+
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+}
+
+class CountingSemaphoreUsingTask: public SemaphoreIF {
+public:
+	CountingSemaphoreUsingTask(uint8_t count, uint8_t initCount);
+
+	ReturnValue_t acquire(uint32_t timeoutMs);
+	ReturnValue_t release();
+
+private:
+	TaskHandle_t handle;
+	uint8_t count = 0;
+	uint8_t initCount = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index e04d3defd..2f0dfd764 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,5 +1,6 @@
 #include <framework/osal/FreeRTOS/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
 
 extern "C" {
 #include <freertos/semphr.h>
@@ -30,3 +31,4 @@ CountingSemaphore& CountingSemaphore::operator =(
 	}
 	return * this;
 }
+
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 7bd71dd7a..1eee1bacc 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -21,15 +21,15 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 	return SemaphoreFactory::factoryInstance;
 }
 
-SemaphoreIF* SemaphoreFactory::createBinarySemaphore() {
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
 	return new BinarySemaphore();
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
-		uint8_t initCount) {
+		uint8_t initCount, uint32_t argument) {
 	return new CountingSemaphore(count, initCount);
 }
 
-void SemaphoreFactory::deleteMutex(SemaphoreIF* semaphore) {
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
 	delete semaphore;
 }
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index fa95399a1..971e97fa3 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -20,19 +20,23 @@ public:
 	/**
 	 * Create a binary semaphore.
 	 * Creator function for a binary semaphore which may only be acquired once
+	 * @param argument Can be used to pass implementation specific information.
 	 * @return Pointer to newly created semaphore class instance.
 	 */
-	SemaphoreIF* createBinarySemaphore();
+	SemaphoreIF* createBinarySemaphore(uint32_t argument = 0);
 	/**
 	 * Create a counting semaphore.
 	 * Creator functons for a counting semaphore which may be acquired multiple
 	 * times.
 	 * @param count Semaphore can be taken count times.
 	 * @param initCount Initial count value.
+	 * @param argument Can be used to pass implementation specific information.
 	 * @return
 	 */
-	SemaphoreIF* createCountingSemaphore(uint8_t count, uint8_t initCount);
-	void deleteMutex(SemaphoreIF* mutex);
+	SemaphoreIF* createCountingSemaphore(uint8_t count, uint8_t initCount,
+			uint32_t argument = 0);
+
+	void deleteSemaphore(SemaphoreIF* mutex);
 
 private:
 	/**

From eabee85ba9f1dd014abc66d13e212427dc328242 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 19:56:02 +0200
Subject: [PATCH 0315/1774] tweaked factory to have configurability

---
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 13 ++++++++++
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  5 ++--
 osal/FreeRTOS/SemaphoreFactory.cpp        | 30 +++++++++++++++++++++--
 3 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 6c5d45c7c..10365d7e1 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -6,3 +6,16 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t count,
 		count(count), initCount(initCount) {
 	handle = TaskManagement::getCurrentTaskHandle();
 }
+
+ReturnValue_t CountingSemaphoreUsingTask::acquire(
+		uint32_t timeoutMs) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::release() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() {
+	return 0;
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index c4bfb61ab..7fc98e937 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -13,8 +13,9 @@ class CountingSemaphoreUsingTask: public SemaphoreIF {
 public:
 	CountingSemaphoreUsingTask(uint8_t count, uint8_t initCount);
 
-	ReturnValue_t acquire(uint32_t timeoutMs);
-	ReturnValue_t release();
+	ReturnValue_t acquire(uint32_t timeoutMs) override;
+	ReturnValue_t release() override;
+	uint8_t getSemaphoreCounter() override;
 
 private:
 	TaskHandle_t handle;
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 1eee1bacc..6acdc7b73 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -1,5 +1,7 @@
 #include <framework/osal/FreeRTOS/BinarySemaphore.h>
+#include <framework/osal/FreeRTOS/BinSemaphUsingTask.h>
 #include <framework/osal/FreeRTOS/CountingSemaphore.h>
+#include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
 #include <framework/tasks/SemaphoreFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
@@ -7,6 +9,9 @@ SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
 const uint32_t SemaphoreIF::MAX_TIMEOUT = portMAX_DELAY;
 
+static const uint32_t USE_REGULAR_SEMAPHORES = 0;
+static const uint32_t USE_TASK_NOTIFICATIONS = 1;
+
 SemaphoreFactory::SemaphoreFactory() {
 }
 
@@ -22,12 +27,33 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 }
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
-	return new BinarySemaphore();
+	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 count,
 		uint8_t initCount, uint32_t argument) {
-	return new CountingSemaphore(count, initCount);
+	if(argument == USE_REGULAR_SEMAPHORES) {
+		return new CountingSemaphore(count, initCount);
+	}
+	else if(argument == USE_TASK_NOTIFICATIONS) {
+		return new CountingSemaphoreUsingTask(count, initCount);
+	}
+	else {
+		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
+						"binary semaphore" << std::endl;
+		return new CountingSemaphore(count, initCount);
+	}
+
 }
 
 void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {

From 7145982b4ade5f3da12e8dd05161b11e45512998 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 19:59:59 +0200
Subject: [PATCH 0316/1774] improved documentation

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp | 2 +-
 osal/FreeRTOS/BinSemaphUsingTask.h   | 6 ++++++
 tasks/SemaphoreIF.h                  | 3 ++-
 3 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 0d7320545..d6bc02bc0 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -19,7 +19,7 @@ ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphore(uint32_t timeoutMs)
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
 	    timeout = SemaphoreIF::MAX_TIMEOUT;
 	}
-	else if(timeoutMs > BinarySemaphoreUsingTask::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 2736b1db6..8b8a77735 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -9,6 +9,12 @@ extern "C" {
 #include <freertos/task.h>
 }
 
+/**
+ * @brief 	Binary Semaphore implementation using Task Notifications
+ * @details
+ * Additional information: https://www.freertos.org/RTOS-task-notifications.html
+ * and general semaphore documentation.
+ */
 class BinarySemaphoreUsingTask: public SemaphoreIF,
 		public HasReturnvaluesIF {
 public:
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index b2b113f17..fb181ccaa 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -12,7 +12,8 @@
  * A semaphore is a synchronization primitive.
  * See: https://en.wikipedia.org/wiki/Semaphore_(programming)
  * A semaphore can be used to achieve task synchonization and track the
- * availability of resources.
+ * availability of resources by using either the binary or the counting
+ * semaphore types.
  *
  * If mutual exlcusion of a resource is desired, a mutex should be used,
  * which is a special form of a semaphore and has an own interface.

From 88e3dc15b2604de0c337f2bf4911ee5e4780588f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 21:27:31 +0200
Subject: [PATCH 0317/1774] replaced old semaph api

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 16 +++++++++++++---
 osal/FreeRTOS/BinSemaphUsingTask.h        |  3 +++
 osal/FreeRTOS/BinarySemaphore.cpp         | 22 ++++++++--------------
 osal/FreeRTOS/BinarySemaphore.h           | 11 ++++-------
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 15 ++++++++++++---
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  6 +++---
 osal/FreeRTOS/SemaphoreFactory.cpp        |  8 ++++----
 tasks/SemaphoreFactory.h                  |  2 +-
 8 files changed, 48 insertions(+), 35 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index d6bc02bc0..8cdcbc333 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -4,6 +4,8 @@
 
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 	handle = TaskManagement::getCurrentTaskHandle();
+	xTaskNotifyGive(handle);
+	locked = false;
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
@@ -25,6 +27,7 @@ ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphore(uint32_t timeoutMs)
 
 	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeout);
 	if (returncode == pdPASS) {
+		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
@@ -36,6 +39,7 @@ ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphoreTickTimeout(
         TickType_t timeoutTicks) {
 	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
 	if (returncode == pdPASS) {
+		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
 		return SEMAPHORE_TIMEOUT;
@@ -43,11 +47,15 @@ ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphoreTickTimeout(
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore() {
+	if(not locked) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
 	BaseType_t returncode = xTaskNotifyGive(handle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return SEMAPHORE_NOT_OWNED;
+		// This should never happen
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
 
@@ -77,8 +85,10 @@ ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore(TaskHandle_t taskHan
 	BaseType_t returncode = xTaskNotifyGive(taskHandle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_NOT_OWNED;
+	}
+	else {
+		// This should never happen.
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
 
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 8b8a77735..e44b838c1 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -85,6 +85,9 @@ public:
 
 protected:
 	TaskHandle_t handle;
+	// This boolean is required to track whether the semaphore is locked
+	// or unlocked.
+	bool locked;
 };
 
 
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index d56be763d..fa54b71f8 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -7,6 +7,7 @@ BinarySemaphore::BinarySemaphore() {
 	if(handle == nullptr) {
 		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
 	}
+	// Initiated semaphore must be given before it can be taken.
 	xSemaphoreGive(handle);
 }
 
@@ -34,7 +35,7 @@ BinarySemaphore& BinarySemaphore::operator =(
     return *this;
 }
 
-ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -55,7 +56,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	}
 }
 
-ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
+ReturnValue_t BinarySemaphore::acquireWithTickTimeout(
         TickType_t timeoutTicks) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
@@ -69,7 +70,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
 	}
 }
 
-ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
+ReturnValue_t BinarySemaphore::release() {
 	if (handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -96,26 +97,19 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
-
-ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
-	return takeBinarySemaphore(timeoutMs);
-}
-
-ReturnValue_t BinarySemaphore::release() {
-	return giveBinarySemaphore();
-}
 
 uint8_t BinarySemaphore::getSemaphoreCounter() {
 	return uxSemaphoreGetCount(handle);
 }
 
 // Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
-		BaseType_t * higherPriorityTaskWoken) {
+ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(
+		SemaphoreHandle_t semaphore, BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
-	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);
+	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore,
+			higherPriorityTaskWoken);
 	if (returncode == pdPASS) {
 		if(*higherPriorityTaskWoken == pdPASS) {
 			// Request context switch because unblocking the semaphore
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index e5c0ce4b5..0c2fe3bff 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -43,9 +43,6 @@ public:
 	//! @brief Destructor
 	virtual ~BinarySemaphore();
 
-	ReturnValue_t acquire(uint32_t timeoutMs =
-	        SemaphoreIF::NO_TIMEOUT) override;
-	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() override;
 
 	/**
@@ -57,8 +54,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c RETURN_FAILED on failure
 	 */
-	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT);
+	ReturnValue_t acquire(uint32_t timeoutMs =
+	       	   SemaphoreIF::NO_TIMEOUT) override;
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -66,7 +63,7 @@ public:
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
-	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
+	ReturnValue_t  acquireWithTickTimeout(TickType_t timeoutTicks =
 	        BinarySemaphore::NO_TIMEOUT);
 
 	/**
@@ -74,7 +71,7 @@ public:
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
-	ReturnValue_t giveBinarySemaphore();
+	ReturnValue_t release() override;
 
 	/**
 	 * Get Handle to the semaphore.
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 10365d7e1..eecd986b4 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -1,10 +1,19 @@
 #include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t count,
-		uint8_t initCount):
-		count(count), initCount(initCount) {
+CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(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();
+	while(currentCount != initCount) {
+		xTaskNotifyGive(handle);
+		currentCount++;
+	}
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::acquire(
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 7fc98e937..8c881d690 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -11,7 +11,7 @@ extern "C" {
 
 class CountingSemaphoreUsingTask: public SemaphoreIF {
 public:
-	CountingSemaphoreUsingTask(uint8_t count, uint8_t initCount);
+	CountingSemaphoreUsingTask(uint8_t maxCount, uint8_t initCount);
 
 	ReturnValue_t acquire(uint32_t timeoutMs) override;
 	ReturnValue_t release() override;
@@ -19,8 +19,8 @@ public:
 
 private:
 	TaskHandle_t handle;
-	uint8_t count = 0;
-	uint8_t initCount = 0;
+	const uint8_t maxCount;
+	uint8_t currentCount = 0;
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 6acdc7b73..05a898cd1 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -40,18 +40,18 @@ SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
 	}
 }
 
-SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount,
 		uint8_t initCount, uint32_t argument) {
 	if(argument == USE_REGULAR_SEMAPHORES) {
-		return new CountingSemaphore(count, initCount);
+		return new CountingSemaphore(maxCount, initCount);
 	}
 	else if(argument == USE_TASK_NOTIFICATIONS) {
-		return new CountingSemaphoreUsingTask(count, initCount);
+		return new CountingSemaphoreUsingTask(maxCount, initCount);
 	}
 	else {
 		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
 						"binary semaphore" << std::endl;
-		return new CountingSemaphore(count, initCount);
+		return new CountingSemaphore(maxCount, initCount);
 	}
 
 }
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index 971e97fa3..75bbe25dc 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -33,7 +33,7 @@ public:
 	 * @param argument Can be used to pass implementation specific information.
 	 * @return
 	 */
-	SemaphoreIF* createCountingSemaphore(uint8_t count, uint8_t initCount,
+	SemaphoreIF* createCountingSemaphore(uint8_t maxCount, uint8_t initCount,
 			uint32_t argument = 0);
 
 	void deleteSemaphore(SemaphoreIF* mutex);

From c4e60946d3282c497714cb9345918069afb11047 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 21:30:20 +0200
Subject: [PATCH 0318/1774] improved bin semaph implementation

---
 osal/FreeRTOS/BinarySemaphore.cpp | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index fa54b71f8..e6bb8dcab 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -37,7 +37,7 @@ BinarySemaphore& BinarySemaphore::operator =(
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	if(handle == nullptr) {
-		return SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
 	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
@@ -59,14 +59,14 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 ReturnValue_t BinarySemaphore::acquireWithTickTimeout(
         TickType_t timeoutTicks) {
 	if(handle == nullptr) {
-		return SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
 
 	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return SEMAPHORE_TIMEOUT;
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
 	}
 }
 
@@ -82,13 +82,17 @@ ReturnValue_t BinarySemaphore::release() {
 	}
 }
 
+uint8_t BinarySemaphore::getSemaphoreCounter() {
+	return uxSemaphoreGetCount(handle);
+}
+
 SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 	return handle;
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	if (semaphore == nullptr) {
-		return SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
 	BaseType_t returncode = xSemaphoreGive(semaphore);
 	if (returncode == pdPASS) {
@@ -96,17 +100,13 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 	} else {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-}
-
-uint8_t BinarySemaphore::getSemaphoreCounter() {
-	return uxSemaphoreGetCount(handle);
 }
 
 // Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(
 		SemaphoreHandle_t semaphore, BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
-		return SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore,
 			higherPriorityTaskWoken);
@@ -117,7 +117,8 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(
 			TaskManagement::requestContextSwitch(CallContext::isr);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_NOT_OWNED;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
 }

From 95bf5c1071a84696cc0e15abf9a01102764caaca Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 21:33:34 +0200
Subject: [PATCH 0319/1774] improved const correctness

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 2 +-
 osal/FreeRTOS/BinSemaphUsingTask.h        | 2 +-
 osal/FreeRTOS/BinarySemaphore.cpp         | 2 +-
 osal/FreeRTOS/BinarySemaphore.h           | 2 +-
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 5 ++---
 osal/FreeRTOS/CountingSemaphUsingTask.h   | 2 +-
 tasks/SemaphoreIF.h                       | 2 +-
 7 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 8cdcbc333..2a5ca3bd5 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -63,7 +63,7 @@ TaskHandle_t BinarySemaphoreUsingTask::getTaskHandle() {
 	return handle;
 }
 
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() {
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() const {
 	uint32_t notificationValue;
 	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
 	return notificationValue;
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index e44b838c1..b65d4d802 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -26,7 +26,7 @@ public:
 	ReturnValue_t acquire(uint32_t timeoutMs =
 	        SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;
-	uint8_t getSemaphoreCounter() override;
+	uint8_t getSemaphoreCounter() const override;
 
 	/**
 	 * Take the binary semaphore.
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index e6bb8dcab..0d8d415cd 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -82,7 +82,7 @@ ReturnValue_t BinarySemaphore::release() {
 	}
 }
 
-uint8_t BinarySemaphore::getSemaphoreCounter() {
+uint8_t BinarySemaphore::getSemaphoreCounter() const {
 	return uxSemaphoreGetCount(handle);
 }
 
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 0c2fe3bff..b883f8017 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -43,7 +43,7 @@ public:
 	//! @brief Destructor
 	virtual ~BinarySemaphore();
 
-	uint8_t getSemaphoreCounter() override;
+	uint8_t getSemaphoreCounter() const override;
 
 	/**
 	 * Take the binary semaphore.
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index eecd986b4..d08a549ea 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -16,8 +16,7 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t maxCount,
 	}
 }
 
-ReturnValue_t CountingSemaphoreUsingTask::acquire(
-		uint32_t timeoutMs) {
+ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -25,6 +24,6 @@ ReturnValue_t CountingSemaphoreUsingTask::release() {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() {
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
 	return 0;
 }
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 8c881d690..877a975e9 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -15,7 +15,7 @@ public:
 
 	ReturnValue_t acquire(uint32_t timeoutMs) override;
 	ReturnValue_t release() override;
-	uint8_t getSemaphoreCounter() override;
+	uint8_t getSemaphoreCounter() const override;
 
 private:
 	TaskHandle_t handle;
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index fb181ccaa..044e03a8d 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -55,7 +55,7 @@ public:
 	 * is returned if the semaphore is available, and 0 is returned if the
 	 * semaphore is not available.
 	 */
-	virtual uint8_t getSemaphoreCounter() = 0;
+	virtual uint8_t getSemaphoreCounter() const = 0;
 };
 
 #endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */

From 63dbf995925f181f406173ba380d36b8faadb393 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 22:12:52 +0200
Subject: [PATCH 0320/1774] counting semaph implementation finished

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 42 ++++-------
 osal/FreeRTOS/BinSemaphUsingTask.h        | 32 ++-------
 osal/FreeRTOS/BinarySemaphore.cpp         | 24 +++----
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 88 +++++++++++++++++++++--
 osal/FreeRTOS/CountingSemaphUsingTask.h   | 32 ++++++++-
 osal/FreeRTOS/CountingSemaphore.cpp       | 13 ++--
 osal/FreeRTOS/CountingSemaphore.h         |  4 +-
 tasks/SemaphoreFactory.h                  |  6 +-
 8 files changed, 154 insertions(+), 87 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 2a5ca3bd5..9c2afe10c 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -1,7 +1,6 @@
 #include <framework/osal/FreeRTOS/BinSemaphUsingTask.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
-
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 	handle = TaskManagement::getCurrentTaskHandle();
 	xTaskNotifyGive(handle);
@@ -9,44 +8,29 @@ BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	return takeBinarySemaphore(timeoutMs);
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::release() {
-	return giveBinarySemaphore();
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphore(uint32_t timeoutMs) {
 	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-	    timeout = SemaphoreIF::MAX_TIMEOUT;
+		timeout = SemaphoreIF::MAX_TIMEOUT;
 	}
 	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
-	    timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-
-	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeout);
-	if (returncode == pdPASS) {
-		locked = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-	    return SemaphoreIF::SEMAPHORE_TIMEOUT;
+		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
+	return acquireWithTickTimeout(timeout);
 }
 
-ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphoreTickTimeout(
+ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
         TickType_t timeoutTicks) {
 	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
 	if (returncode == pdPASS) {
 		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_TIMEOUT;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
 	}
 }
 
-ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore() {
+ReturnValue_t BinarySemaphoreUsingTask::release() {
 	if(not locked) {
 		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
@@ -69,7 +53,9 @@ uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() const {
 	return notificationValue;
 }
 
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(TaskHandle_t taskHandle) {
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t taskHandle) {
 	uint32_t notificationValue;
 	BaseType_t higherPriorityTaskWoken;
 	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
@@ -80,8 +66,8 @@ uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(TaskHandle_t taskHa
 	return notificationValue;
 }
 
-
-ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore(TaskHandle_t taskHandle) {
+ReturnValue_t BinarySemaphoreUsingTask::release(
+		TaskHandle_t taskHandle) {
 	BaseType_t returncode = xTaskNotifyGive(taskHandle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
@@ -93,7 +79,7 @@ ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore(TaskHandle_t taskHan
 }
 
 // Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphoreFromISR(
+ReturnValue_t BinarySemaphoreUsingTask::releaseFromISR(
 		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
 	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
 	if(*higherPriorityTaskWoken == pdPASS) {
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index b65d4d802..cb6f6287a 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -27,35 +27,17 @@ public:
 	        SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
 
 	/**
-	 * 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 RETURN_FAILED on failure
-	 */
-	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT);
-
-	/**
-	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
+	 * Same as acquire() with timeout in FreeRTOS ticks.
 	 * @param timeoutTicks
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
-	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
+	ReturnValue_t acquireWithTickTimeout(TickType_t timeoutTicks =
 	        SemaphoreIF::NO_TIMEOUT);
 
-	/**
-	 * Give back the binary semaphore
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t giveBinarySemaphore();
-
 	/**
 	 * Get handle to the task related to the semaphore.
 	 * @return
@@ -68,7 +50,7 @@ public:
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
-	static ReturnValue_t giveBinarySemaphore(TaskHandle_t taskToNotify);
+	static ReturnValue_t release(TaskHandle_t taskToNotify);
 
 	/**
 	 * Wrapper function to give back semaphore from handle when called from an ISR
@@ -78,11 +60,9 @@ public:
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
-	static ReturnValue_t giveBinarySemaphoreFromISR(TaskHandle_t taskToNotify,
+	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
 				BaseType_t * higherPriorityTaskWoken);
 
-	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
-
 protected:
 	TaskHandle_t handle;
 	// This boolean is required to track whether the semaphore is locked
@@ -90,6 +70,4 @@ protected:
 	bool locked;
 };
 
-
-
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 0d8d415cd..8891b755b 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -43,21 +43,13 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
 	    timeout = SemaphoreIF::MAX_TIMEOUT;
 	}
-	else if(timeoutMs > BinarySemaphore::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
-
-	BaseType_t returncode = xSemaphoreTake(handle, timeout);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-	    return SemaphoreIF::SEMAPHORE_TIMEOUT;
-	}
+	return acquireWithTickTimeout(timeout);
 }
 
-ReturnValue_t BinarySemaphore::acquireWithTickTimeout(
-        TickType_t timeoutTicks) {
+ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TickType_t timeoutTicks) {
 	if(handle == nullptr) {
 		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
@@ -65,20 +57,22 @@ ReturnValue_t BinarySemaphore::acquireWithTickTimeout(
 	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
+	}
+	else {
 		return SemaphoreIF::SEMAPHORE_TIMEOUT;
 	}
 }
 
 ReturnValue_t BinarySemaphore::release() {
 	if (handle == nullptr) {
-		return SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
 	BaseType_t returncode = xSemaphoreGive(handle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_NOT_OWNED;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
 }
 
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index d08a549ea..9beca310d 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -2,7 +2,7 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t maxCount,
+CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 		uint8_t initCount): maxCount(maxCount) {
 	if(initCount > maxCount) {
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
@@ -17,13 +17,93 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t maxCount,
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	return HasReturnvaluesIF::RETURN_OK;
+	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
+	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+		timeout = SemaphoreIF::MAX_TIMEOUT;
+	}
+	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+		timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+
+	BaseType_t returncode = ulTaskNotifyTake(pdFALSE, timeout);
+	if (returncode == pdPASS) {
+		currentCount--;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
+		TickType_t timeoutTicks) {
+	BaseType_t returncode = ulTaskNotifyTake(pdFALSE, timeoutTicks);
+	if (returncode == pdPASS) {
+		currentCount--;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::release() {
-	return HasReturnvaluesIF::RETURN_OK;
+	if(currentCount == maxCount) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	BaseType_t returncode = xTaskNotifyGive(handle);
+	if (returncode == pdPASS) {
+		currentCount++;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		// This should never happen
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
 }
 
 uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
-	return 0;
+	uint32_t notificationValue;
+	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+TaskHandle_t CountingSemaphoreUsingTask::getTaskHandle() {
+	return handle;
+}
+
+
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t task) {
+	uint32_t notificationValue;
+	BaseType_t higherPriorityTaskWoken = 0;
+	xTaskNotifyAndQueryFromISR(task, 0, eNoAction, &notificationValue,
+			&higherPriorityTaskWoken);
+	if(higherPriorityTaskWoken == pdTRUE) {
+		TaskManagement::requestContextSwitch(CallContext::isr);
+	}
+	return notificationValue;
+}
+
+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;
+	}
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::releaseFromISR(
+		TaskHandle_t taskToNotify, BaseType_t* higherPriorityTaskWoken) {
+	vTaskNotifyGiveFromISR(taskToNotify, higherPriorityTaskWoken);
+	if(*higherPriorityTaskWoken == pdPASS) {
+		// Request context switch because unblocking the semaphore
+		// caused a high priority task unblock.
+		TaskManagement::requestContextSwitch(CallContext::isr);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 877a975e9..ac0425b50 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -11,11 +11,39 @@ extern "C" {
 
 class CountingSemaphoreUsingTask: public SemaphoreIF {
 public:
-	CountingSemaphoreUsingTask(uint8_t maxCount, uint8_t initCount);
+	CountingSemaphoreUsingTask(const uint8_t maxCount, uint8_t initCount);
 
-	ReturnValue_t acquire(uint32_t timeoutMs) override;
+	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t task);
+	/**
+	 * Acquire, using a timeout value in ticks
+	 * @param timeoutTicks
+	 * @return
+	 */
+	ReturnValue_t acquireWithTickTimeout(
+			TickType_t timeoutTicks= SemaphoreIF::NO_TIMEOUT);
+
+	/**
+	 * Get handle to the task related to the semaphore.
+	 * @return
+	 */
+	TaskHandle_t getTaskHandle();
+
+	/**
+	 * Release semaphore of task by supplying task handle
+	 * @param taskToNotify
+	 * @return
+	 */
+	static ReturnValue_t release(TaskHandle_t taskToNotify);
+	/**
+	 * Release seamphore of a task from an ISR.
+	 * @param taskToNotify
+	 * @return
+	 */
+	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
+			BaseType_t* higherPriorityTaskWoken);
 
 private:
 	TaskHandle_t handle;
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index 2f0dfd764..a23f32a03 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -8,16 +8,17 @@ extern "C" {
 
 // Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
 // free FreeRTOSConfig.h file.
-CountingSemaphore::CountingSemaphore(uint8_t count, uint8_t initCount):
-		count(count), initCount(initCount) {
-	handle = xSemaphoreCreateCounting(count, initCount);
+CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
+		maxCount(maxCount), initCount(initCount) {
+	handle = xSemaphoreCreateCounting(maxCount, initCount);
 	if(handle == nullptr) {
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
 	}
 }
 
-CountingSemaphore::CountingSemaphore(CountingSemaphore&& other) {
-	handle = xSemaphoreCreateCounting(other.count, other.initCount);
+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;
 	}
@@ -25,7 +26,7 @@ CountingSemaphore::CountingSemaphore(CountingSemaphore&& other) {
 
 CountingSemaphore& CountingSemaphore::operator =(
 		CountingSemaphore&& other) {
-	handle = xSemaphoreCreateCounting(other.count, other.initCount);
+	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
 	if(handle == nullptr) {
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
 	}
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index a33a0fa5a..77050f900 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -12,7 +12,7 @@
  */
 class CountingSemaphore: public BinarySemaphore {
 public:
-	CountingSemaphore(uint8_t count, uint8_t initCount);
+	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
 	//! @brief Copy ctor, disabled
 	CountingSemaphore(const CountingSemaphore&) = delete;
 	//! @brief Copy assignment, disabled
@@ -22,7 +22,7 @@ public:
 	//! @brief Move assignment
 	CountingSemaphore & operator=(CountingSemaphore &&);
 private:
-	uint8_t count = 0;
+	const uint8_t maxCount;
 	uint8_t initCount = 0;
 };
 
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index 75bbe25dc..3e21be368 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -23,7 +23,7 @@ public:
 	 * @param argument Can be used to pass implementation specific information.
 	 * @return Pointer to newly created semaphore class instance.
 	 */
-	SemaphoreIF* createBinarySemaphore(uint32_t argument = 0);
+	SemaphoreIF* createBinarySemaphore(uint32_t arguments = 0);
 	/**
 	 * Create a counting semaphore.
 	 * Creator functons for a counting semaphore which may be acquired multiple
@@ -33,8 +33,8 @@ public:
 	 * @param argument Can be used to pass implementation specific information.
 	 * @return
 	 */
-	SemaphoreIF* createCountingSemaphore(uint8_t maxCount, uint8_t initCount,
-			uint32_t argument = 0);
+	SemaphoreIF* createCountingSemaphore(const uint8_t maxCount,
+			uint8_t initCount, uint32_t arguments = 0);
 
 	void deleteSemaphore(SemaphoreIF* mutex);
 

From 7ce505fdf9234630298dc6560b625cc44f41770a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 23:29:06 +0200
Subject: [PATCH 0321/1774] some safety updates and fixes

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 10 ++++++
 osal/FreeRTOS/BinSemaphUsingTask.h        |  6 +++-
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 40 ++++++++++++++++-------
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  9 +++++
 4 files changed, 52 insertions(+), 13 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 9c2afe10c..84b0b488e 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -1,12 +1,22 @@
 #include <framework/osal/FreeRTOS/BinSemaphUsingTask.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
+#include <framework/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);
 	locked = false;
 }
 
+BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
+	// Clear notification value on destruction.
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
+}
+
 ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
 	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index cb6f6287a..cad427831 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -10,7 +10,9 @@ extern "C" {
 }
 
 /**
- * @brief 	Binary Semaphore implementation using Task Notifications
+ * @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.
@@ -22,6 +24,8 @@ public:
 
 	//! @brief Default ctor
 	BinarySemaphoreUsingTask();
+	//! @brief Default dtor
+	virtual~ BinarySemaphoreUsingTask();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
 	        SemaphoreIF::NO_TIMEOUT) override;
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 9beca310d..c29f52589 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -9,13 +9,35 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 				"intial cout. Setting initial count to max count." << std::endl;
 		initCount = maxCount;
 	}
+
 	handle = TaskManagement::getCurrentTaskHandle();
+	if(handle == nullptr) {
+		sif::error << "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 << "Semaphore initiated but current notification value"
+				" is not 0. Please ensure the notification value is not used"
+				"for other purposes!" << std::endl;
+	}
+
 	while(currentCount != initCount) {
 		xTaskNotifyGive(handle);
 		currentCount++;
 	}
 }
 
+CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
+	// Clear notification value on destruction.
+	// If this is not desired, don't call the destructor
+	// (or implement a boolea which disables the reset)
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
+}
+
 ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
 	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
@@ -24,22 +46,16 @@ ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
 	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
+	return acquireWithTickTimeout(timeout);
 
-	BaseType_t returncode = ulTaskNotifyTake(pdFALSE, timeout);
-	if (returncode == pdPASS) {
-		currentCount--;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return SemaphoreIF::SEMAPHORE_TIMEOUT;
-	}
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
 		TickType_t timeoutTicks) {
-	BaseType_t returncode = ulTaskNotifyTake(pdFALSE, timeoutTicks);
-	if (returncode == pdPASS) {
-		currentCount--;
+	// Decrement notfication value without resetting it.
+	BaseType_t oldCount = ulTaskNotifyTake(pdFALSE, timeoutTicks);
+	if (getSemaphoreCounter() == oldCount - 1) {
+		currentCount --;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
@@ -63,7 +79,7 @@ ReturnValue_t CountingSemaphoreUsingTask::release() {
 }
 
 uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
-	uint32_t notificationValue;
+	uint32_t notificationValue = 0;
 	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
 	return notificationValue;
 }
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index ac0425b50..2c54b31ba 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -9,9 +9,18 @@ extern "C" {
 #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();
 
 	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;

From 08ffe89682e72c70876d3dbfd0555161e16608e9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 23:41:59 +0200
Subject: [PATCH 0322/1774] doc and api improvements

---
 osal/FreeRTOS/BinarySemaphore.cpp       |  4 +--
 osal/FreeRTOS/BinarySemaphore.h         | 27 ++++++++++---------
 osal/FreeRTOS/CountingSemaphUsingTask.h | 36 ++++++++++++++++++++-----
 osal/FreeRTOS/CountingSemaphore.h       |  4 +++
 4 files changed, 51 insertions(+), 20 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 8891b755b..7d882afff 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -84,7 +84,7 @@ SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 	return handle;
 }
 
-ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+ReturnValue_t BinarySemaphore::release(SemaphoreHandle_t semaphore) {
 	if (semaphore == nullptr) {
 		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
@@ -97,7 +97,7 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 }
 
 // Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(
+ReturnValue_t BinarySemaphore::releaseFromISR(
 		SemaphoreHandle_t semaphore, BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
 		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index b883f8017..f3839151d 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -52,7 +52,7 @@ public:
 	 * for example by an ISR or another task.
 	 * @param timeoutMs
 	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquire(uint32_t timeoutMs =
 	       	   SemaphoreIF::NO_TIMEOUT) override;
@@ -60,16 +60,17 @@ public:
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
 	 * @param timeoutTicks
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t  acquireWithTickTimeout(TickType_t timeoutTicks =
 	        BinarySemaphore::NO_TIMEOUT);
 
 	/**
-	 * Give back the binary semaphore
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
+	 * 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;
 
@@ -82,20 +83,22 @@ public:
 	 /**
 	 * Wrapper function to give back semaphore from handle
 	 * @param semaphore
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
 	 */
-	static ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore);
+	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
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
 	 */
-	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+	static ReturnValue_t releaseFromISR(SemaphoreHandle_t semaphore,
 				BaseType_t * higherPriorityTaskWoken);
 
 protected:
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 2c54b31ba..73d3f987c 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -12,7 +12,7 @@ extern "C" {
 /**
  * @brief 	Couting Semaphore implementation which uses the notification value
  * 			of the task. The notification value should therefore not be used
- * 			for other purposes
+ * 			for other purposes.
  * @details
  *  Additional information: https://www.freertos.org/RTOS-task-notifications.html
  *  and general semaphore documentation.
@@ -22,17 +22,37 @@ 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(uint32_t timeoutMs = SemaphoreIF::NO_TIMEOUT) 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;
 	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t task);
+
 	/**
-	 * Acquire, using a timeout value in ticks
+	 * Acquire with a timeout value in ticks
 	 * @param timeoutTicks
-	 * @return
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquireWithTickTimeout(
-			TickType_t timeoutTicks= SemaphoreIF::NO_TIMEOUT);
+			TickType_t timeoutTicks = SemaphoreIF::NO_TIMEOUT);
 
 	/**
 	 * Get handle to the task related to the semaphore.
@@ -43,13 +63,17 @@ public:
 	/**
 	 * Release semaphore of task by supplying task handle
 	 * @param taskToNotify
-	 * @return
+	 * @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
-	 * @return
+	 * @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);
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index 77050f900..bed3c7260 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -21,6 +21,10 @@ public:
 	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. */
 private:
 	const uint8_t maxCount;
 	uint8_t initCount = 0;

From 60872f936ce2c2566b388e1e40bdb24194178453 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 23:43:40 +0200
Subject: [PATCH 0323/1774] some output improvements

---
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index c29f52589..d34c7d6a8 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -12,19 +12,19 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
-		sif::error << "Could not retrieve task handle. Please ensure the"
-				"constructor was called inside a task." << std::endl;
+		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 << "Semaphore initiated but current notification value"
-				" is not 0. Please ensure the notification value is not used"
-				"for other purposes!" << std::endl;
+		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;
 	}
-
 	while(currentCount != initCount) {
 		xTaskNotifyGive(handle);
 		currentCount++;

From 8676fcd9a929b619b65c1598434c75261fdb74b1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 00:47:54 +0200
Subject: [PATCH 0324/1774] yay, linux bin semaph finished

---
 osal/linux/BinarySemaphore.cpp  | 127 ++++++++++++++++++++++++++++++++
 osal/linux/BinarySemaphore.h    |  68 +++++++++++++++++
 osal/linux/MessageQueue.cpp     |   2 +-
 osal/linux/Mutex.h              |   4 +-
 osal/linux/SemaphoreFactory.cpp |   6 +-
 tasks/SemaphoreFactory.h        |   2 +-
 tasks/SemaphoreIF.h             |   2 +-
 7 files changed, 203 insertions(+), 8 deletions(-)
 create mode 100644 osal/linux/BinarySemaphore.cpp
 create mode 100644 osal/linux/BinarySemaphore.h

diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
new file mode 100644
index 000000000..ed1045e0a
--- /dev/null
+++ b/osal/linux/BinarySemaphore.cpp
@@ -0,0 +1,127 @@
+#include <framework/osal/linux/BinarySemaphore.h>
+#include <framework/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(uint32_t timeoutMs) {
+	int result = 0;
+	if(timeoutMs == SemaphoreIF::NO_TIMEOUT) {
+		result = sem_trywait(&handle);
+	}
+	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	    result = sem_wait(&handle);
+	}
+	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+		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(result) {
+	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"
+				<< std::endl;
+		/* No break */
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t BinarySemaphore::release() {
+	return release(&this->handle);
+}
+
+ReturnValue_t BinarySemaphore::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 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) {
+		sif::debug << "BInarySemaphore::getSemaphoreCounter: Invalid"
+				" Semaphore." << std::endl;
+		return 0;
+	}
+	else {
+		// This should never happen.
+		return 0;
+	}
+}
+
+void BinarySemaphore::initSemaphore() {
+	auto result = sem_init(&handle, true, 1);
+	if(result == -1) {
+		switch(errno) {
+		case(EINVAL):
+						// Value excees SEM_VALUE_MAX
+		case(ENOSYS):
+		// System does not support process-shared semaphores
+		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
+		<< std::endl;
+		}
+	}
+}
diff --git a/osal/linux/BinarySemaphore.h b/osal/linux/BinarySemaphore.h
new file mode 100644
index 000000000..d18b3eaa8
--- /dev/null
+++ b/osal/linux/BinarySemaphore.h
@@ -0,0 +1,68 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/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 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(uint32_t timeoutMs =
+	       	   SemaphoreIF::NO_TIMEOUT) override;
+
+	/**
+	 * 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;
+
+	static ReturnValue_t release(sem_t* handle);
+
+protected:
+	sem_t handle;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 96d9fb4d0..48ba29e80 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -7,7 +7,7 @@
 #include <framework/osal/linux/MessageQueue.h>
 
 
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) :
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		id(0), lastPartner(0), defaultDestination(NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index 872ac3ac4..607337aea 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
+#ifndef OS_LINUX_MUTEX_H_
+#define OS_LINUX_MUTEX_H_
 
 #include <framework/ipc/MutexIF.h>
 
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index b1100e750..db4bebb35 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -20,18 +20,18 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 	return SemaphoreFactory::factoryInstance;
 }
 
-SemaphoreIF* SemaphoreFactory::createBinarySemaphore() {
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
 	sif::error << "Semaphore not implemented for Linux yet" << std::endl;
 	return nullptr;
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
-		uint8_t initCount) {
+		uint8_t initCount, uint32_t arguments) {
 	sif::error << "Counting Semaphore not implemented for "
 			"Linux yet" << std::endl;
 	return nullptr;
 }
 
-void SemaphoreFactory::deleteMutex(SemaphoreIF* semaphore) {
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
 	delete semaphore;
 }
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index 3e21be368..7f8edaf12 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -36,7 +36,7 @@ public:
 	SemaphoreIF* createCountingSemaphore(const uint8_t maxCount,
 			uint8_t initCount, uint32_t arguments = 0);
 
-	void deleteSemaphore(SemaphoreIF* mutex);
+	void deleteSemaphore(SemaphoreIF* semaphore);
 
 private:
 	/**
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index 044e03a8d..a7c5a97b9 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -30,7 +30,7 @@ public:
 	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
 	//! The current semaphore can not be given, because it is not owned
 	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
-	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
+	static constexpr ReturnValue_t SEMAPHORE_INVALID = MAKE_RETURN_CODE(3);
 
 	/**
 	 * Generic call to acquire a semaphore.

From 56498e5bc12076330e8f1b74ce7955b16005d0aa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 00:50:44 +0200
Subject: [PATCH 0325/1774] linux bin semaph unlocked

---
 osal/linux/SemaphoreFactory.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index db4bebb35..8d29ffe39 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,4 +1,5 @@
 #include <framework/tasks/SemaphoreFactory.h>
+#include <framework/osal/linux/BinarySemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
@@ -21,8 +22,7 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 }
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
-	sif::error << "Semaphore not implemented for Linux yet" << std::endl;
-	return nullptr;
+	return new BinarySemaphore();
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,

From 671f298935a640e33274e1a5fd52339e790068b6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 01:41:16 +0200
Subject: [PATCH 0326/1774] implemented counting semaph for linux

---
 osal/FreeRTOS/CountingSemaphore.cpp | 10 ++++++
 osal/FreeRTOS/CountingSemaphore.h   |  1 +
 osal/linux/BinarySemaphore.cpp      | 43 +++++++++++++++++------
 osal/linux/BinarySemaphore.h        | 23 +++++++++---
 osal/linux/CountingSemaphore.cpp    | 54 +++++++++++++++++++++++++++++
 osal/linux/CountingSemaphore.h      | 37 ++++++++++++++++++++
 osal/linux/SemaphoreFactory.cpp     |  7 ++--
 7 files changed, 155 insertions(+), 20 deletions(-)
 create mode 100644 osal/linux/CountingSemaphore.cpp
 create mode 100644 osal/linux/CountingSemaphore.h

diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index a23f32a03..c838f3e2d 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -10,6 +10,12 @@ extern "C" {
 // 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;
@@ -33,3 +39,7 @@ CountingSemaphore& CountingSemaphore::operator =(
 	return * this;
 }
 
+
+uint8_t CountingSemaphore::getMaxCount() const {
+	return maxCount;
+}
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index bed3c7260..dca3ab0ed 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -25,6 +25,7 @@ public:
 	/* 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;
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index ed1045e0a..7c76a5c4f 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -30,7 +30,7 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	if(timeoutMs == SemaphoreIF::NO_TIMEOUT) {
 		result = sem_trywait(&handle);
 	}
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	else if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
 	    result = sem_wait(&handle);
 	}
 	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
@@ -50,7 +50,7 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	switch(result) {
+	switch(errno) {
 	case(EAGAIN):
 		// Operation could not be performed without blocking (for sem_trywait)
 	case(ETIMEDOUT):
@@ -61,8 +61,8 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 		return SemaphoreIF::SEMAPHORE_INVALID;
 	case(EINTR):
 		// Call was interrupted by signal handler
-		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted"
-				<< std::endl;
+		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted."
+				"Code " << strerror(errno) << std::endl;
 		/* No break */
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;
@@ -70,10 +70,15 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 }
 
 ReturnValue_t BinarySemaphore::release() {
-	return release(&this->handle);
+	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;
@@ -102,8 +107,8 @@ uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
 		return value;
 	}
 	else if(result != 0 and errno == EINVAL) {
-		sif::debug << "BInarySemaphore::getSemaphoreCounter: Invalid"
-				" Semaphore." << std::endl;
+		// Could be called from interrupt, use lightweight printf
+		printf("BinarySemaphore::getSemaphoreCounter: Invalid semaphore\n");
 		return 0;
 	}
 	else {
@@ -112,16 +117,32 @@ uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
 	}
 }
 
-void BinarySemaphore::initSemaphore() {
-	auto result = sem_init(&handle, true, 1);
+void BinarySemaphore::initSemaphore(uint8_t initCount) {
+	auto result = sem_init(&handle, true, initCount);
 	if(result == -1) {
 		switch(errno) {
 		case(EINVAL):
-						// Value excees SEM_VALUE_MAX
+			// Value exceeds SEM_VALUE_MAX
 		case(ENOSYS):
 		// System does not support process-shared semaphores
 		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
-		<< std::endl;
+				<< 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;
+}
diff --git a/osal/linux/BinarySemaphore.h b/osal/linux/BinarySemaphore.h
index d18b3eaa8..7836cd413 100644
--- a/osal/linux/BinarySemaphore.h
+++ b/osal/linux/BinarySemaphore.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#ifndef FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/tasks/SemaphoreIF.h>
@@ -35,10 +35,11 @@ public:
 	//! @brief Destructor
 	virtual ~BinarySemaphore();
 
-	void initSemaphore();
+	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
@@ -57,10 +58,22 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
 	 *         	already available.
 	 */
-	ReturnValue_t release() override;
-
+	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;
 };
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
new file mode 100644
index 000000000..dfc4d8013
--- /dev/null
+++ b/osal/linux/CountingSemaphore.cpp
@@ -0,0 +1,54 @@
+#include <framework/osal/linux/CountingSemaphore.h>
+#include <framework/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;
+}
+
diff --git a/osal/linux/CountingSemaphore.h b/osal/linux/CountingSemaphore.h
new file mode 100644
index 000000000..ba6065955
--- /dev/null
+++ b/osal/linux/CountingSemaphore.h
@@ -0,0 +1,37 @@
+#ifndef FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
+#define FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
+#include <framework/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_ */
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index 8d29ffe39..5aec84eae 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,5 +1,6 @@
 #include <framework/tasks/SemaphoreFactory.h>
 #include <framework/osal/linux/BinarySemaphore.h>
+#include <framework/osal/linux/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
@@ -25,11 +26,9 @@ SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
 	return new BinarySemaphore();
 }
 
-SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
 		uint8_t initCount, uint32_t arguments) {
-	sif::error << "Counting Semaphore not implemented for "
-			"Linux yet" << std::endl;
-	return nullptr;
+	return new CountingSemaphore(maxCount, initCount);
 }
 
 void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {

From ccf79ab5b63d5870dfd8aabde90895746f9cdc08 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 01:55:20 +0200
Subject: [PATCH 0327/1774] output correction for linux

---
 osal/linux/PeriodicPosixTask.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index 28a0b9461..f6a74901c 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -57,9 +57,11 @@ void PeriodicPosixTask::taskFunctionality(void){
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
 			if(status==0){
-				sif::error << "ObjectTask: " << name << " Deadline missed." << std::endl;
+				sif::error << "PeriodicPosixTask " << name << ": Deadline "
+						"missed." << std::endl;
 			}else{
-				sif::error << "ObjectTask: X Deadline missed. " << status << std::endl;
+				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
+						status << std::endl;
 			}
 			if (this->deadlineMissedFunc != NULL) {
 				this->deadlineMissedFunc();

From 3d2935ac6917b6d8f20c68011cd77cf9d5890686 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 02:23:14 +0200
Subject: [PATCH 0328/1774] linux time lib improvements

stop watch other function used (more precise for linux)
---
 osal/linux/Clock.cpp      | 17 ++++++++++++++---
 timemanager/Clock.h       | 18 ++++++++++--------
 timemanager/Stopwatch.cpp | 14 +++++---------
 timemanager/Stopwatch.h   |  9 ++-------
 4 files changed, 31 insertions(+), 27 deletions(-)

diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index e24a4fe4b..b3e5c84bf 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,11 +1,13 @@
-#include <sys/time.h>
-#include <time.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/timemanager/Clock.h>
 
-
+extern "C" {
+#include <sys/time.h>
 #include <sys/sysinfo.h>
 #include <linux/sysinfo.h>
+#include <time.h>
 #include <unistd.h>
+}
 
 //#include <fstream>
 uint16_t Clock::leapSeconds = 0;
@@ -65,6 +67,15 @@ ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+timeval Clock::getUptime() {
+	timeval uptime;
+	auto result = getUptime(&uptime);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
+	}
+	return uptime;
+}
+
 ReturnValue_t Clock::getUptime(timeval* uptime) {
 	//TODO This is not posix compatible and delivers only seconds precision
 	struct sysinfo sysInfo;
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 5f18de3ee..fcfacbc09 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -2,11 +2,12 @@
 #define FRAMEWORK_TIMEMANAGER_CLOCK_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <stdint.h>
-#include <sys/time.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/globalfunctions/timevalOperations.h>
 
+#include <cstdint>
+#include <sys/time.h>
+
 typedef uint32_t millis_t;
 typedef float seconds_t;
 
@@ -22,7 +23,7 @@ public:
 	  uint32_t usecond; //!< Microseconds, 0 .. 999999
 	}   TimeOfDay_t;
 
-	/**static Clock* TimeOfDay_t();
+	/**
 	 * This method returns the number of clock ticks per second.
 	 * In RTEMS, this is typically 1000.
 	 * @return	The number of ticks.
@@ -34,22 +35,23 @@ public:
 	 * This system call sets the system time.
 	 * To set the time, it uses a TimeOfDay_t struct.
 	 * @param time The struct with the time settings to set.
-	 * @return	\c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
+	 * 				is returned.
 	 */
 	static ReturnValue_t setClock(const TimeOfDay_t* time);
 	/**
 	 * This system call sets the system time.
 	 * To set the time, it uses a timeval struct.
 	 * @param time The struct with the time settings to set.
-	 * @return	\c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t setClock(const timeval* time);
 	/**
 	 * This system call returns the current system clock in timeval format.
-	 * The timval format has the fields \c tv_sec with seconds and \c tv_usec with
+	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
 	 * microseconds since an OS-defined epoch.
 	 * @param time	A pointer to a timeval struct where the current time is stored.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t getClock_timeval(timeval* time);
 
@@ -57,7 +59,7 @@ public:
 	 * Get the time since boot in a timeval struct
 	 *
 	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
-	 * @return\c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
 	 *
 	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
 	 */
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 1f287fb38..bc8b4149c 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -1,9 +1,3 @@
-/**
- * @file Stopwatch.cpp
- *
- * @date 08.04.2020
- */
-
 #include <framework/timemanager/Stopwatch.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <iomanip>
@@ -12,11 +6,11 @@ Stopwatch::Stopwatch(bool displayOnDestruction,
         StopwatchDisplayMode displayMode): displayOnDestruction(
         displayOnDestruction), displayMode(displayMode) {
     // Measures start time on initialization.
-    startTime = Clock::getUptime();
+    Clock::getClock_timeval(&startTime);
 }
 
 void Stopwatch::start() {
-    startTime = Clock::getUptime();
+    Clock::getClock_timeval(&startTime);
 }
 
 millis_t Stopwatch::stop() {
@@ -57,5 +51,7 @@ StopwatchDisplayMode Stopwatch::getDisplayMode() const {
 }
 
 void Stopwatch::stopInternal() {
-    elapsedTime = Clock::getUptime() - startTime;
+	timeval endTime;
+	Clock::getClock_timeval(&endTime);
+    elapsedTime = endTime - startTime;
 }
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index f48c04eca..c57200b07 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -1,9 +1,3 @@
-/**
- * @file Stopwatch.h
- *
- * @date 08.04.2020
- */
-
 #ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
 #define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
 #include <framework/timemanager/Clock.h>
@@ -14,12 +8,13 @@ enum class StopwatchDisplayMode {
 };
 
 /**
- * @brief Simple Stopwatch implementation to measure elapsed time
+ * @brief 	Simple Stopwatch implementation to measure elapsed time
  * @details
  * This class can be used to measure elapsed times. It also displays elapsed
  * times automatically on destruction if not explicitely deactivated in the
  * constructor. The default time format is the elapsed time in miliseconds
  * as a float.
+ * @author 	R. Mueller
  */
 class Stopwatch {
 public:

From da403c01d0178d814896d4c26561e092c1ac2a6e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 03:03:48 +0200
Subject: [PATCH 0329/1774] retval fix, unittest running again

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 71 ++++++++++-------------
 osal/FreeRTOS/BinSemaphUsingTask.h        |  9 ++-
 osal/FreeRTOS/BinarySemaphore.cpp         | 40 ++++++-------
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 69 +++++++++-------------
 osal/FreeRTOS/CountingSemaphUsingTask.h   | 17 +++++-
 5 files changed, 94 insertions(+), 112 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 84b0b488e..51a3c5636 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -9,7 +9,6 @@ BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 				"constructor was called inside a task." << std::endl;
 	}
 	xTaskNotifyGive(handle);
-	locked = false;
 }
 
 BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
@@ -32,7 +31,6 @@ ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
         TickType_t timeoutTicks) {
 	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
 	if (returncode == pdPASS) {
-		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
@@ -41,43 +39,14 @@ ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::release() {
-	if(not locked) {
-		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
-	}
-	BaseType_t returncode = xTaskNotifyGive(handle);
-	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 {
-	uint32_t notificationValue;
-	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
-	return notificationValue;
-}
-
-
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
-		TaskHandle_t taskHandle) {
-	uint32_t notificationValue;
-	BaseType_t higherPriorityTaskWoken;
-	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
-			&higherPriorityTaskWoken);
-	if(higherPriorityTaskWoken) {
-		TaskManagement::requestContextSwitch(CallContext::isr);
-	}
-	return notificationValue;
+	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;
@@ -88,14 +57,36 @@ ReturnValue_t BinarySemaphoreUsingTask::release(
 	}
 }
 
+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) {
-	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
-	if(*higherPriorityTaskWoken == pdPASS) {
-		// Request context switch because unblocking the semaphore
-		// caused a high priority task unblock.
-		TaskManagement::requestContextSwitch(CallContext::isr);
+	if(getSemaphoreCounterFromISR(taskHandle) == 1) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
+	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t taskHandle) {
+	uint32_t notificationValue;
+	BaseType_t higherPriorityTaskWoken;
+	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
+			&higherPriorityTaskWoken);
+	return notificationValue;
+}
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index cad427831..316208801 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -31,6 +31,7 @@ public:
 	        SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
+	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
 	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
 
 	/**
@@ -59,8 +60,9 @@ public:
 	/**
 	 * 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
+	 * @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
 	 */
@@ -69,9 +71,6 @@ public:
 
 protected:
 	TaskHandle_t handle;
-	// This boolean is required to track whether the semaphore is locked
-	// or unlocked.
-	bool locked;
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 7d882afff..7b695dee1 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -37,7 +37,7 @@ BinarySemaphore& BinarySemaphore::operator =(
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	if(handle == nullptr) {
-		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_INVALID;
 	}
 	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
@@ -51,7 +51,7 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 
 ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TickType_t timeoutTicks) {
 	if(handle == nullptr) {
-		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_INVALID;
 	}
 
 	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
@@ -64,10 +64,14 @@ ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TickType_t timeoutTicks) {
 }
 
 ReturnValue_t BinarySemaphore::release() {
-	if (handle == nullptr) {
-		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
+	return release(handle);
+}
+
+ReturnValue_t BinarySemaphore::release(SemaphoreHandle_t semaphore) {
+	if (semaphore == nullptr) {
+		return SemaphoreIF::SEMAPHORE_INVALID;
 	}
-	BaseType_t returncode = xSemaphoreGive(handle);
+	BaseType_t returncode = xSemaphoreGive(semaphore);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -83,33 +87,23 @@ uint8_t BinarySemaphore::getSemaphoreCounter() const {
 SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 	return handle;
 }
-
-ReturnValue_t BinarySemaphore::release(SemaphoreHandle_t semaphore) {
-	if (semaphore == nullptr) {
-		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
-	}
-	BaseType_t returncode = xSemaphoreGive(semaphore);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
+
 
 // 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_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_INVALID;
 	}
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore,
 			higherPriorityTaskWoken);
+	// This should propably be called at the end of the (calling) ISR
+	//if(*higherPriorityTaskWoken == pdPASS) {
+		// Request context switch because unblocking the semaphore
+		// caused a high priority task unblock.
+		//TaskManagement::requestContextSwitch(CallContext::isr);
+	//}
 	if (returncode == pdPASS) {
-		if(*higherPriorityTaskWoken == pdPASS) {
-			// Request context switch because unblocking the semaphore
-		    // caused a high priority task unblock.
-			TaskManagement::requestContextSwitch(CallContext::isr);
-		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index d34c7d6a8..d0f63f3f9 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -25,16 +25,15 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 				"current notification value is not 0. Please ensure the "
 				"notification value is not used for other purposes!" << std::endl;
 	}
-	while(currentCount != initCount) {
+	for(int i = 0; i < initCount; i++) {
 		xTaskNotifyGive(handle);
-		currentCount++;
 	}
 }
 
 CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
 	// Clear notification value on destruction.
 	// If this is not desired, don't call the destructor
-	// (or implement a boolea which disables the reset)
+	// (or implement a boolean which disables the reset)
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
 }
 
@@ -55,7 +54,6 @@ ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
 	// Decrement notfication value without resetting it.
 	BaseType_t oldCount = ulTaskNotifyTake(pdFALSE, timeoutTicks);
 	if (getSemaphoreCounter() == oldCount - 1) {
-		currentCount --;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
@@ -64,41 +62,10 @@ ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::release() {
-	if(currentCount == maxCount) {
+	if(getSemaphoreCounter() == maxCount) {
 		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
-	BaseType_t returncode = xTaskNotifyGive(handle);
-	if (returncode == pdPASS) {
-		currentCount++;
-		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;
-}
-
-
-uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
-		TaskHandle_t task) {
-	uint32_t notificationValue;
-	BaseType_t higherPriorityTaskWoken = 0;
-	xTaskNotifyAndQueryFromISR(task, 0, eNoAction, &notificationValue,
-			&higherPriorityTaskWoken);
-	if(higherPriorityTaskWoken == pdTRUE) {
-		TaskManagement::requestContextSwitch(CallContext::isr);
-	}
-	return notificationValue;
+	return release(handle);
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::release(
@@ -113,13 +80,31 @@ ReturnValue_t CountingSemaphoreUsingTask::release(
 	}
 }
 
+
+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);
-	if(*higherPriorityTaskWoken == pdPASS) {
-		// Request context switch because unblocking the semaphore
-		// caused a high priority task unblock.
-		TaskManagement::requestContextSwitch(CallContext::isr);
-	}
 	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;
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 73d3f987c..797e864b5 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -43,7 +43,16 @@ public:
 	ReturnValue_t release() override;
 
 	uint8_t getSemaphoreCounter() const override;
-	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t task);
+	/**
+	 * 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
@@ -71,6 +80,9 @@ public:
 	/**
 	 * 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.
@@ -78,10 +90,11 @@ public:
 	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
 			BaseType_t* higherPriorityTaskWoken);
 
+	uint8_t getMaxCount() const;
+
 private:
 	TaskHandle_t handle;
 	const uint8_t maxCount;
-	uint8_t currentCount = 0;
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */

From 78ae109a08ec58c17b1b966944992da0b74da011 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 13:02:13 +0200
Subject: [PATCH 0330/1774] removed context switch request

(shall be done at end of ISR, so must be performed by caller)
---
 osal/FreeRTOS/BinSemaphUsingTask.cpp | 9 ++++-----
 osal/FreeRTOS/BinSemaphUsingTask.h   | 3 ++-
 osal/FreeRTOS/BinarySemaphore.cpp    | 9 ---------
 osal/FreeRTOS/BinarySemaphore.h      | 5 +++--
 osal/FreeRTOS/MessageQueue.cpp       | 2 +-
 osal/FreeRTOS/MessageQueue.h         | 4 ++--
 osal/FreeRTOS/TaskManagement.cpp     | 4 ++--
 osal/FreeRTOS/TaskManagement.h       | 6 +++---
 8 files changed, 17 insertions(+), 25 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 51a3c5636..8f5fd4d8a 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -75,7 +75,7 @@ uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter(
 // 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) == 1) {
+	if(getSemaphoreCounterFromISR(taskHandle, higherPriorityTaskWoken) == 1) {
 		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
 	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
@@ -83,10 +83,9 @@ ReturnValue_t BinarySemaphoreUsingTask::releaseFromISR(
 }
 
 uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
-		TaskHandle_t taskHandle) {
-	uint32_t notificationValue;
-	BaseType_t higherPriorityTaskWoken;
+		TaskHandle_t taskHandle, BaseType_t* higherPriorityTaskWoken) {
+	uint32_t notificationValue = 0;
 	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
-			&higherPriorityTaskWoken);
+			higherPriorityTaskWoken);
 	return notificationValue;
 }
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 316208801..e6cb2a074 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -32,7 +32,8 @@ public:
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
 	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
-	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle,
+			BaseType_t* higherPriorityTaskWoken);
 
 	/**
 	 * Same as acquire() with timeout in FreeRTOS ticks.
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 7b695dee1..b6687bb75 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -36,9 +36,6 @@ BinarySemaphore& BinarySemaphore::operator =(
 }
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
-	if(handle == nullptr) {
-		return SemaphoreIF::SEMAPHORE_INVALID;
-	}
 	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
 	    timeout = SemaphoreIF::MAX_TIMEOUT;
@@ -97,12 +94,6 @@ ReturnValue_t BinarySemaphore::releaseFromISR(
 	}
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore,
 			higherPriorityTaskWoken);
-	// This should propably be called at the end of the (calling) ISR
-	//if(*higherPriorityTaskWoken == pdPASS) {
-		// Request context switch because unblocking the semaphore
-		// caused a high priority task unblock.
-		//TaskManagement::requestContextSwitch(CallContext::isr);
-	//}
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index f3839151d..de6092afd 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -92,8 +92,9 @@ public:
 	/**
 	 * 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
+	 * @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.
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 9e4b581be..b56a62521 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -124,7 +124,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         bool ignoreFault, CallContext callContext) {
     message->setSender(sentFrom);
     BaseType_t result;
-    if(callContext == CallContext::task) {
+    if(callContext == CallContext::TASK) {
         result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
                 static_cast<const void*>(message->getBuffer()), 0);
     }
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 988733f6b..8daab8f66 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -199,7 +199,7 @@ protected:
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false, CallContext callContext = CallContext::task);
+			bool ignoreFault=false, CallContext callContext = CallContext::TASK);
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
@@ -209,7 +209,7 @@ private:
 	MessageQueueId_t defaultDestination = 0;
 	MessageQueueId_t lastPartner = 0;
 	//!< Stores the current system context
-	CallContext callContext =  CallContext::task;
+	CallContext callContext =  CallContext::TASK;
 };
 
 #endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 4529b3710..7871ab2ec 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -5,8 +5,8 @@ void TaskManagement::requestContextSwitchFromTask() {
 }
 
 void TaskManagement::requestContextSwitch(
-		CallContext callContext = CallContext::task) {
-	if(callContext == CallContext::isr) {
+		CallContext callContext = CallContext::TASK) {
+	if(callContext == CallContext::ISR) {
 		// This function depends on the partmacro.h definition for the specific device
 		requestContextSwitchFromISR();
 	} else {
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index b9874db0c..39c24377b 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -21,9 +21,9 @@ extern "C" void requestContextSwitchFromISR();
  * has different functions for handling semaphores and messages from within
  * an ISR and task.
  */
-enum CallContext {
-	task = 0x00,//!< task_context
-	isr = 0xFF  //!< isr_context
+enum class CallContext {
+	TASK = 0x00,//!< task_context
+	ISR = 0xFF  //!< isr_context
 };
 
 

From 5169c09fd8d56eb041011da9062bb325578a313e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 13:07:35 +0200
Subject: [PATCH 0331/1774] improved includes

---
 osal/FreeRTOS/Clock.cpp      | 9 +++++----
 osal/FreeRTOS/Timekeeper.cpp | 9 +--------
 osal/FreeRTOS/Timekeeper.h   | 3 ++-
 3 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index 5e597f258..d1c9f97ba 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -1,13 +1,14 @@
 #include <framework/timemanager/Clock.h>
 #include <framework/globalfunctions/timevalOperations.h>
-#include <stdlib.h>
-#include "Timekeeper.h"
+#include <framework/osal/FreeRTOS/Timekeeper.h>
 
 extern "C" {
-#include <FreeRTOS.h>
-#include <task.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
 }
 
+#include <stdlib.h>
+#include <time.h>
 
 //TODO sanitize input?
 //TODO much of this code can be reused for tick-only systems
diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index 949e1df3c..9fd4af623 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -1,13 +1,6 @@
-/**
- * @file Timekeeper.cpp
- * @date
- */
-
 #include <framework/osal/FreeRTOS/Timekeeper.h>
 
-extern "C" {
-#include <task.h>
-}
+#include "FreeRTOSConfig.h"
 
 Timekeeper * Timekeeper::myinstance = nullptr;
 
diff --git a/osal/FreeRTOS/Timekeeper.h b/osal/FreeRTOS/Timekeeper.h
index 05f0f7011..8709e362c 100644
--- a/osal/FreeRTOS/Timekeeper.h
+++ b/osal/FreeRTOS/Timekeeper.h
@@ -3,7 +3,8 @@
 
 #include <framework/timemanager/Clock.h>
 extern "C" {
-#include <FreeRTOS.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
 }
 
 

From e7ae35c6592fb101ebe2fd44517a8cfc62b1096d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 13:09:47 +0200
Subject: [PATCH 0332/1774] improved structure a bit

---
 osal/FreeRTOS/Timekeeper.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index 9fd4af623..643b27479 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -4,7 +4,9 @@
 
 Timekeeper * Timekeeper::myinstance = nullptr;
 
-Timekeeper::Timekeeper() : offset( { 0, 0 }) {}
+Timekeeper::Timekeeper() : offset( { 0, 0 } ) {}
+
+Timekeeper::~Timekeeper() {}
 
 const timeval& Timekeeper::getOffset() const {
 	return offset;
@@ -21,8 +23,6 @@ void Timekeeper::setOffset(const timeval& offset) {
 	this->offset = offset;
 }
 
-Timekeeper::~Timekeeper() {}
-
 timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
 	timeval uptime;
 	uptime.tv_sec = ticks / configTICK_RATE_HZ;

From d5352a9b87a604cd8535963d2a7fcc8176b2182b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 13:15:37 +0200
Subject: [PATCH 0333/1774] actually extern "C" is not needed

it is included by freeRTOS
---
 osal/FreeRTOS/Clock.cpp    | 6 ++----
 osal/FreeRTOS/Timekeeper.h | 3 +--
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index d1c9f97ba..dce202657 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -2,10 +2,8 @@
 #include <framework/globalfunctions/timevalOperations.h>
 #include <framework/osal/FreeRTOS/Timekeeper.h>
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-}
 
 #include <stdlib.h>
 #include <time.h>
@@ -14,7 +12,7 @@ extern "C" {
 //TODO much of this code can be reused for tick-only systems
 
 uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
+MutexIF* Clock::timeMutex = nullptr;
 
 uint32_t Clock::getTicksPerSecond(void) {
 	return 1000;
@@ -131,7 +129,7 @@ ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
 
 ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
 	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == NULL) {
+	if (timeMutex == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
diff --git a/osal/FreeRTOS/Timekeeper.h b/osal/FreeRTOS/Timekeeper.h
index 8709e362c..7d3ca22b7 100644
--- a/osal/FreeRTOS/Timekeeper.h
+++ b/osal/FreeRTOS/Timekeeper.h
@@ -2,10 +2,9 @@
 #define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
 
 #include <framework/timemanager/Clock.h>
-extern "C" {
+
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-}
 
 
 /**

From 6a3dc94108304d9cf0cdde1cc82ecc6dc62390d8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 13:18:27 +0200
Subject: [PATCH 0334/1774] removed extern "C" for freertos includes

---
 osal/FreeRTOS/BinSemaphUsingTask.h  | 2 --
 osal/FreeRTOS/BinarySemaphore.h     | 2 --
 osal/FreeRTOS/CountingSemaphore.cpp | 2 --
 osal/FreeRTOS/MessageQueue.cpp      | 2 +-
 osal/FreeRTOS/MessageQueue.h        | 7 -------
 osal/FreeRTOS/Mutex.cpp             | 2 +-
 osal/FreeRTOS/Mutex.h               | 3 ---
 7 files changed, 2 insertions(+), 18 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index e6cb2a074..48c1cd12d 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -4,10 +4,8 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/tasks/SemaphoreIF.h>
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-}
 
 /**
  * @brief 	Binary Semaphore implementation using the task notification value.
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index de6092afd..0938dee6f 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -4,10 +4,8 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/tasks/SemaphoreIF.h>
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
-}
 
 /**
  * @brief 	OS Tool to achieve synchronization of between tasks or between
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index c838f3e2d..957f6a319 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -2,9 +2,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
-extern "C" {
 #include <freertos/semphr.h>
-}
 
 // Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
 // free FreeRTOSConfig.h file.
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index b56a62521..0a579296b 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -1,4 +1,4 @@
-#include "MessageQueue.h"
+#include <framework/osal/FreeRTOS/MessageQueue.h>
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 8daab8f66..81b4c186d 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -6,11 +6,8 @@
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/queue.h>
-}
-
 
 // TODO: this class assumes that MessageQueueId_t is the same size as void*
 // (the FreeRTOS handle type), compiler will catch this but it might be nice
@@ -164,11 +161,7 @@ public:
 	MessageQueueId_t getId() const;
 
 	/**
-<<<<<<< HEAD
-	 * \brief	This method is a simple setter for the default destination.
-=======
 	 * @brief	This method is a simple setter for the default destination.
->>>>>>> mueller_BinSempahInterface
 	 */
 	void setDefaultDestination(MessageQueueId_t defaultDestination);
 	/**
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 25513a819..e304d60e9 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -1,4 +1,4 @@
-#include "Mutex.h"
+#include <framework/osal/FreeRTOS/Mutex.h>
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index ef93fd344..e04cd20d2 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -3,11 +3,8 @@
 
 #include <framework/ipc/MutexIF.h>
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
-}
-
 
 /**
  * @brief OS component to implement MUTual EXclusion

From f14bacba32e97c7d74e55405d59b9230ec4e362c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 14:15:45 +0200
Subject: [PATCH 0335/1774] using nullptr now

added new distinction between blocking (MAX_TIMEOUT) and polling
(NO_TIMEOUT)
---
 ipc/MutexIF.h           |  2 +-
 osal/FreeRTOS/Mutex.cpp | 18 +++++++++++-------
 osal/FreeRTOS/Mutex.h   |  2 +-
 3 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index a4aff1cd8..dcb1cf333 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -13,7 +13,7 @@
 class MutexIF {
 public:
 	static const uint32_t NO_TIMEOUT; //!< Needs to be defined in implementation.
-
+	static const uint32_t MAX_TIMEOUT;
 	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
 	/**
 	 * The system lacked the necessary resources (other than memory) to initialize another mutex.
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index e304d60e9..cc2f865ff 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -3,27 +3,31 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 const uint32_t MutexIF::NO_TIMEOUT = 0;
+const uint32_t MutexIF::MAX_TIMEOUT = portMAX_DELAY;
 
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
-	if(handle == NULL) {
-		sif::error << "Mutex creation failure" << std::endl;
+	if(handle == nullptr) {
+		sif::error << "Mutex: Creation failure" << std::endl;
 	}
 }
 
 Mutex::~Mutex() {
-	if (handle != 0) {
+	if (handle != nullptr) {
 		vSemaphoreDelete(handle);
 	}
 
 }
 
 ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	if (handle == 0) {
+	if (handle == nullptr) {
 		return MutexIF::MUTEX_NOT_FOUND;
 	}
-	TickType_t timeout = portMAX_DELAY;
-	if (timeoutMs != NO_TIMEOUT) {
+	TickType_t timeout = MutexIF::NO_TIMEOUT;
+	if(timeoutMs == MutexIF::MAX_TIMEOUT) {
+		timeout = MutexIF::MAX_TIMEOUT;
+	}
+	else if(timeoutMs > MutexIF::NO_TIMEOUT){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
@@ -36,7 +40,7 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 }
 
 ReturnValue_t Mutex::unlockMutex() {
-	if (handle == 0) {
+	if (handle == nullptr) {
 		return MutexIF::MUTEX_NOT_FOUND;
 	}
 	BaseType_t returncode = xSemaphoreGive(handle);
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index e04cd20d2..90e824678 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -18,7 +18,7 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs) override;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::MAX_TIMEOUT) override;
 	ReturnValue_t unlockMutex() override;
 private:
 	SemaphoreHandle_t handle;

From b90492562ac44f576ab7c7519826ae272d5be68e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 16:40:57 +0200
Subject: [PATCH 0336/1774] added author tag back at class definition

---
 storagemanager/LocalPool.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index c155f918b..2d61dea51 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -22,6 +22,7 @@
  * 			0xFFFF-1 bytes.
  * 			It is possible to store empty packets in the pool.
  * 			The local pool is NOT thread-safe.
+ * @author 	Bastian Baetz
  */
 
 template<uint8_t NUMBER_OF_POOLS = 5>

From 5cf9e938cccf450c5a4ad5b7fb74f7cc4b3705ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 16:45:03 +0200
Subject: [PATCH 0337/1774] added include protection

---
 storagemanager/LocalPool.tpp   | 4 ++++
 storagemanager/PoolManager.tpp | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 32724bd8c..dd360a0ab 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -1,6 +1,10 @@
 #ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
 #define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
 
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#error Include LocalPool.h instead of LocalPool.tpp!.
+#endif
+
 template<uint8_t NUMBER_OF_POOLS>
 inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
 		const uint16_t element_sizes[NUMBER_OF_POOLS],
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 854e22daa..bdc73ec28 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -1,6 +1,10 @@
 #ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 #define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 
+#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+#error Include LocalPool.h instead of LocalPool.tpp!.
+#endif
+
 template<uint8_t NUMBER_OF_POOLS>
 inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
 		const uint16_t element_sizes[NUMBER_OF_POOLS],

From 3ef939aca8cff90c0ad51418e859eb69a76a655f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 16:46:26 +0200
Subject: [PATCH 0338/1774] fixed inclue protection

---
 storagemanager/LocalPool.tpp   | 2 +-
 storagemanager/PoolManager.tpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index dd360a0ab..b7fa0da96 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -2,7 +2,7 @@
 #define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
 
 #ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#error Include LocalPool.h instead of LocalPool.tpp!.
+#error Include LocalPool.h instead of LocalPool.tpp!
 #endif
 
 template<uint8_t NUMBER_OF_POOLS>
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index bdc73ec28..97603246e 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -2,7 +2,7 @@
 #define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 
 #ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-#error Include LocalPool.h instead of LocalPool.tpp!.
+#error Include LocalPool.h instead of LocalPool.tpp!
 #endif
 
 template<uint8_t NUMBER_OF_POOLS>

From 6b0558d6c71a5b23b2f678d5b18e170cde60e706 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 16:49:11 +0200
Subject: [PATCH 0339/1774] added author tag back

---
 storagemanager/PoolManager.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 6e353de22..c74e95c0e 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -10,6 +10,7 @@
  * 			a fixed pool size policy for inter-process communication.
  * @details	Uses local pool calls but is thread safe by protecting the call
  * 			with a lock.
+ * @author 	Bastian Baetz
  */
 template <uint8_t NUMBER_OF_POOLS>
 class PoolManager : public LocalPool<NUMBER_OF_POOLS> {

From f13eff79c90a174011c6d3b6c617ce25b575cc76 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 16:51:09 +0200
Subject: [PATCH 0340/1774] another little include guard fix

---
 storagemanager/LocalPool.tpp   | 2 +-
 storagemanager/PoolManager.tpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index b7fa0da96..764bd7be4 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -2,7 +2,7 @@
 #define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
 
 #ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#error Include LocalPool.h instead of LocalPool.tpp!
+#error Include LocalPool.h before LocalPool.tpp!
 #endif
 
 template<uint8_t NUMBER_OF_POOLS>
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 97603246e..29b2b82a6 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -2,7 +2,7 @@
 #define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 
 #ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-#error Include LocalPool.h instead of LocalPool.tpp!
+#error Include PoolManager.h before PoolManager.tpp!
 #endif
 
 template<uint8_t NUMBER_OF_POOLS>

From 4d4ca2f3bd87efaca572378e107f92dda2c57eb2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 17:43:37 +0200
Subject: [PATCH 0341/1774] doc fix for stopwatch

---
 timemanager/Stopwatch.h | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index c57200b07..71580778f 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -13,7 +13,7 @@ enum class StopwatchDisplayMode {
  * This class can be used to measure elapsed times. It also displays elapsed
  * times automatically on destruction if not explicitely deactivated in the
  * constructor. The default time format is the elapsed time in miliseconds
- * as a float.
+ * in seconds as a double.
  * @author 	R. Mueller
  */
 class Stopwatch {
@@ -41,6 +41,10 @@ public:
      * @return elapsed time in milliseconds (rounded)
      */
     millis_t stop();
+    /**
+     * Calculates the elapsed time since start and returns it
+     * @return elapsed time in seconds (double precision)
+     */
     seconds_t stopSeconds();
 
     /**

From 914bf8b9fc1afff3cf98675b4a98707099cb4021 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 17:45:53 +0200
Subject: [PATCH 0342/1774] seconds_t is double now

---
 timemanager/Clock.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index fcfacbc09..19991b817 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -9,7 +9,7 @@
 #include <sys/time.h>
 
 typedef uint32_t millis_t;
-typedef float seconds_t;
+typedef double seconds_t;
 
 class Clock {
 public:

From 7a22d12d0f1328ff55e3e2826e58000e191ef643 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 17:48:24 +0200
Subject: [PATCH 0343/1774] removed extern "C", not needed

---
 osal/linux/Clock.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index b3e5c84bf..630b2cf4c 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,13 +1,11 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/timemanager/Clock.h>
 
-extern "C" {
 #include <sys/time.h>
 #include <sys/sysinfo.h>
 #include <linux/sysinfo.h>
 #include <time.h>
 #include <unistd.h>
-}
 
 //#include <fstream>
 uint16_t Clock::leapSeconds = 0;

From c8a36a79de45c228e7071cc827423e0b4a383998 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 31 May 2020 00:23:38 +0200
Subject: [PATCH 0344/1774] corrected doc for task factory interface

---
 osal/FreeRTOS/FixedTimeslotTask.h | 19 +++++++++-------
 tasks/TaskFactory.h               | 36 ++++++++++++++-----------------
 2 files changed, 27 insertions(+), 28 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 1ab8724f6..fe93dafff 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -10,15 +10,18 @@
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF {
 public:
+
 	/**
-	 * @brief	The standard constructor of the class.
-	 *
-	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
-	 * 			the following variables are passed:
-	 *
-	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
-	 *
-	 * @param	getPst The object id of the completely initialized polling sequence.
+	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
+	 * @param setPriority Number of priorities specified by
+	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
+	 * @param setStack	Stack size in words (not bytes!).
+	 * Lower limit specified by configMINIMAL_STACK_SIZE
+	 * @param overallPeriod		Period in seconds.
+	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
+	 * @return Pointer to the newly created task.
 	 */
 	FixedTimeslotTask(const char *name, TaskPriority setPriority,
 			TaskStackSize setStack, TaskPeriod overallPeriod,
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index f7afa4a22..e1e2f5e2a 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -19,16 +19,14 @@ public:
 	static TaskFactory* instance();
 
 	/**
-	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
-	 * A lot of task parameters are set in "FreeRTOSConfig.h".
-	 * @param name_ Name of the task, lenght limited by configMAX_TASK_NAME_LEN
-	 * @param taskPriority_ Number of priorities specified by
-	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
-	 * @param stackSize_ 	Stack size in words (not bytes!).
-	 * Lower limit specified by configMINIMAL_STACK_SIZE
-	 * @param period_		Period in seconds.
-	 * @param deadLineMissedFunction_ Callback if a deadline was missed.
-	 * @return Pointer to the newly created task.
+	 * Generic interface to create a periodic task
+	 * @param name_ Name of the task
+	 * @param taskPriority_ Priority of the task
+	 * @param stackSize_ Stack size if the task
+	 * @param periodInSeconds_ Period in seconds
+	 * @param deadLineMissedFunction_ This function is called if a deadline was
+	 * missed
+	 * @return Pointer to the created periodic task class
 	 */
 	PeriodicTaskIF* createPeriodicTask(TaskName name_,
 			TaskPriority taskPriority_, TaskStackSize stackSize_,
@@ -36,16 +34,14 @@ public:
 			TaskDeadlineMissedFunction deadLineMissedFunction_);
 
 	/**
-	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
-	 * A lot of task parameters are set in "FreeRTOSConfig.h".
-	 * @param name_ Name of the task, lenght limited by configMAX_TASK_NAME_LEN
-	 * @param taskPriority_ Number of priorities specified by
-	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
-	 * @param stackSize_ 	Stack size in words (not bytes!).
-	 * Lower limit specified by configMINIMAL_STACK_SIZE
-	 * @param period_		Period in seconds.
-	 * @param deadLineMissedFunction_ Callback if a deadline was missed.
-	 * @return Pointer to the newly created task.
+	 * Generic interface to create a fixed timeslot task
+	 * @param name_ Name of the task
+	 * @param taskPriority_ Priority of the task
+	 * @param stackSize_ Stack size if the task
+	 * @param periodInSeconds_ Period in seconds
+	 * @param deadLineMissedFunction_ This function is called if a deadline was
+	 * missed
+	 * @return Pointer to the created periodic task class
 	 */
 	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
 			TaskPriority taskPriority_, TaskStackSize stackSize_,

From 42f0687a6bcf0f1c947ef00dfeea95fa3e060af8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 31 May 2020 23:28:51 +0200
Subject: [PATCH 0345/1774] self deletion nullptr

---
 osal/FreeRTOS/TaskFactory.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 6b18d7a85..663b0531c 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -34,9 +34,9 @@ FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	if (task == NULL) {
+	if (task == nullptr) {
 		//delete self
-		vTaskDelete(NULL);
+		vTaskDelete(nullptr);
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
 		//TODO not implemented

From de6ed5c0859e528b798fdb214cf62b7a3143762e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Jun 2020 15:57:04 +0200
Subject: [PATCH 0346/1774] improved include guard and removed old comment

---
 osal/FreeRTOS/PeriodicTask.h | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 4ece20b33..a449328e3 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -1,5 +1,5 @@
-#ifndef PERIODICTASK_H_
-#define PERIODICTASK_H_
+#ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/tasks/PeriodicTaskIF.h>
@@ -17,8 +17,6 @@ class ExecutableObjectIF;
 /**
  * @brief 	This class represents a specialized task for
  * 			periodic activities of multiple objects.
- * @details
- *
  * @ingroup task_handling
  */
 class PeriodicTask: public PeriodicTaskIF {
@@ -26,24 +24,25 @@ public:
 	/**
 	 * @brief	Standard constructor of the class.
 	 * @details
-	 * The class is initialized without allocated objects. These need to be added
-	 * with #addComponent. In the underlying TaskBase class, a new operating
-	 * system task is created. In addition to the TaskBase parameters,
-	 * the period, the pointer to the aforementioned initialization function and
-	 * an optional "deadline-missed" function pointer is passed.
-	 * @param priority		Sets the priority of a task. Values depend on
-	 * freeRTOS configuration, high number means high priority.
-	 * @param stack_size	The stack size reserved by the operating system for the task.
-	 * @param setPeriod The length of the period with which the task's
+	 * The class is initialized without allocated objects.
+	 * These need to be added with #addComponent.
+	 * @param priority
+	 * Sets the priority of a task. Values depend on freeRTOS configuration,
+	 * high number means high priority.
+	 * @param stack_size
+	 * The stack size reserved by the operating system for the task.
+	 * @param setPeriod
+	 * The length of the period with which the task's
 	 * functionality will be executed. It is expressed in clock ticks.
 	 * @param setDeadlineMissedFunc
-	 * The function pointer to the deadline missed function that shall be assigned.
+	 * 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.
+	 * @brief	Currently, the executed object's lifetime is not coupled with
+	 * 			the task object's lifetime, so the destructor is empty.
 	 */
 	virtual ~PeriodicTask(void);
 

From f0a25b5e2b0e26e549145ff429fc707a5f7c6bb3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Jun 2020 22:10:34 +0200
Subject: [PATCH 0347/1774] new timeout values for MUtexIF and SemaphIF

---
 ipc/MutexIF.h       | 17 +++++++++++++++--
 tasks/SemaphoreIF.h | 19 +++++++++++++++----
 2 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index dcb1cf333..29e59e588 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -12,8 +12,21 @@
  */
 class MutexIF {
 public:
-	static const uint32_t NO_TIMEOUT; //!< Needs to be defined in implementation.
-	static const uint32_t MAX_TIMEOUT;
+	/**
+	 * @brief 	Timeout value used for polling lock attempt.
+	 * @details
+	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
+	 * immediately. Value needs to be defined in implementation.
+	 */
+	static const uint32_t POLLING;
+	/**
+	 * @brief 	Timeout value used for permanent blocking lock attempt.
+	 * @details
+	 * The task will be blocked (indefinitely) until the mutex is unlocked.
+	 * Value needs to be defined in implementation.
+	 */
+	static const uint32_t BLOCKING;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
 	/**
 	 * The system lacked the necessary resources (other than memory) to initialize another mutex.
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index a7c5a97b9..4fc92ebd3 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -21,10 +21,21 @@
 class SemaphoreIF {
 public:
 	virtual~ SemaphoreIF() {};
-	//! Needs to be defined in implementation. No blocking time
-	static const uint32_t NO_TIMEOUT;
-	//! Needs to be defined in implementation. Blocks indefinitely.
-	static const uint32_t MAX_TIMEOUT;
+	/**
+	 * @brief 	Timeout value used for polling lock attempt.
+	 * @details
+	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
+	 * immediately. Value needs to be defined in implementation.
+	 */
+	static const uint32_t POLLING;
+	/**
+	 * @brief 	Timeout value used for permanent blocking lock attempt.
+	 * @details
+	 * The task will be blocked (indefinitely) until the mutex is unlocked.
+	 * Value needs to be defined in implementation.
+	 */
+	static const uint32_t BLOCKING;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 	//! Semaphore timeout
 	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);

From 986dc2047e7ef0f52ebe8bd54fdf7f0fd565a518 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Jun 2020 22:19:48 +0200
Subject: [PATCH 0348/1774] replaced mutexIF and semaphoreIF name for timeouts

---
 datapoolglob/GlobalDataPool.cpp           |  2 +-
 events/EventManager.cpp                   |  2 +-
 health/HealthTable.cpp                    | 12 ++++++------
 internalError/InternalErrorReporter.cpp   | 18 +++++++++---------
 osal/FreeRTOS/BinSemaphUsingTask.cpp      |  8 ++++----
 osal/FreeRTOS/BinSemaphUsingTask.h        |  4 ++--
 osal/FreeRTOS/BinarySemaphore.cpp         |  8 ++++----
 osal/FreeRTOS/BinarySemaphore.h           |  4 ++--
 osal/FreeRTOS/Clock.cpp                   |  4 ++--
 osal/FreeRTOS/CountingSemaphUsingTask.cpp |  8 ++++----
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  4 ++--
 osal/FreeRTOS/Mutex.cpp                   | 12 ++++++------
 osal/FreeRTOS/Mutex.h                     |  2 +-
 osal/FreeRTOS/SemaphoreFactory.cpp        |  4 ++--
 storagemanager/PoolManager.tpp            |  6 +++---
 15 files changed, 49 insertions(+), 49 deletions(-)

diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
index e13765baa..187809048 100644
--- a/datapoolglob/GlobalDataPool.cpp
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -54,7 +54,7 @@ ReturnValue_t GlobalDataPool::freeDataPoolLock() {
 }
 
 ReturnValue_t GlobalDataPool::lockDataPool() {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = mutex->lockMutex(MutexIF::BLOCKING);
 	if ( status != RETURN_OK ) {
 		sif::error << "DataPool::DataPool: lock of mutex failed "
 				"with error code: " << status << std::endl;
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index bff15e3cc..73e77e94a 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -151,7 +151,7 @@ void EventManager::printEvent(EventMessage* message) {
 #endif
 
 void EventManager::lockMutex() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 }
 
 void EventManager::unlockMutex() {
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 94b7cf0bf..5d9f5c61a 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -26,7 +26,7 @@ ReturnValue_t HealthTable::registerObject(object_id_t object,
 
 void HealthTable::setHealth(object_id_t object,
 		HasHealthIF::HealthState newState) {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		iter->second = newState;
@@ -36,7 +36,7 @@ void HealthTable::setHealth(object_id_t object,
 
 HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		state = iter->second;
@@ -46,7 +46,7 @@ HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 }
 
 uint32_t HealthTable::getPrintSize() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	uint32_t size = healthMap.size() * 5 + 2;
 	mutex->unlockMutex();
 	return size;
@@ -54,7 +54,7 @@ uint32_t HealthTable::getPrintSize() {
 
 bool HealthTable::hasHealth(object_id_t object) {
 	bool exits = false;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		exits = true;
@@ -64,7 +64,7 @@ bool HealthTable::hasHealth(object_id_t object) {
 }
 
 void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	size_t size = 0;
 	uint16_t count = healthMap.size();
 	ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
@@ -85,7 +85,7 @@ void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
 ReturnValue_t HealthTable::iterate(
 		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	if (reset) {
 		mapIterator = healthMap.begin();
 	}
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 30a02b442..8944553dd 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -53,7 +53,7 @@ void InternalErrorReporter::lostTm() {
 
 uint32_t InternalErrorReporter::getAndResetQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = queueHits;
 	queueHits = 0;
 	mutex->unlockMutex();
@@ -62,21 +62,21 @@ uint32_t InternalErrorReporter::getAndResetQueueHits() {
 
 uint32_t InternalErrorReporter::getQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = queueHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	queueHits++;
 	mutex->unlockMutex();
 }
 
 uint32_t InternalErrorReporter::getAndResetTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = tmHits;
 	tmHits = 0;
 	mutex->unlockMutex();
@@ -85,14 +85,14 @@ uint32_t InternalErrorReporter::getAndResetTmHits() {
 
 uint32_t InternalErrorReporter::getTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = tmHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	tmHits++;
 	mutex->unlockMutex();
 }
@@ -103,7 +103,7 @@ void InternalErrorReporter::storeFull() {
 
 uint32_t InternalErrorReporter::getAndResetStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = storeHits;
 	storeHits = 0;
 	mutex->unlockMutex();
@@ -112,14 +112,14 @@ uint32_t InternalErrorReporter::getAndResetStoreHits() {
 
 uint32_t InternalErrorReporter::getStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = storeHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	storeHits++;
 	mutex->unlockMutex();
 }
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 8f5fd4d8a..d33518886 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -17,11 +17,11 @@ BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-		timeout = SemaphoreIF::MAX_TIMEOUT;
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+		timeout = SemaphoreIF::BLOCKING;
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 	return acquireWithTickTimeout(timeout);
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 48c1cd12d..43772e5af 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -26,7 +26,7 @@ public:
 	virtual~ BinarySemaphoreUsingTask();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	        SemaphoreIF::NO_TIMEOUT) override;
+	        SemaphoreIF::BLOCKING) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
 	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
@@ -40,7 +40,7 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t acquireWithTickTimeout(TickType_t timeoutTicks =
-	        SemaphoreIF::NO_TIMEOUT);
+	        SemaphoreIF::BLOCKING);
 
 	/**
 	 * Get handle to the task related to the semaphore.
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index b6687bb75..e6d2f92ff 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -36,11 +36,11 @@ BinarySemaphore& BinarySemaphore::operator =(
 }
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-	    timeout = SemaphoreIF::MAX_TIMEOUT;
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+	    timeout = SemaphoreIF::BLOCKING;
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 	return acquireWithTickTimeout(timeout);
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 0938dee6f..2a372cd2b 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -53,7 +53,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT) override;
+			SemaphoreIF::BLOCKING) override;
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -62,7 +62,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t  acquireWithTickTimeout(TickType_t timeoutTicks =
-	        BinarySemaphore::NO_TIMEOUT);
+			SemaphoreIF::BLOCKING);
 
 	/**
 	 * Release the binary semaphore.
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index dce202657..ec07b662e 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -155,7 +155,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -170,7 +170,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if (timeMutex == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index d0f63f3f9..f33c7a0d0 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -38,11 +38,11 @@ CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-		timeout = SemaphoreIF::MAX_TIMEOUT;
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+		timeout = SemaphoreIF::BLOCKING;
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 	return acquireWithTickTimeout(timeout);
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 797e864b5..f1d82c1dd 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -31,7 +31,7 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
-	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::NO_TIMEOUT) override;
+	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::BLOCKING) override;
 
 	/**
 	 * Release a semaphore, increasing the number of available counting
@@ -61,7 +61,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquireWithTickTimeout(
-			TickType_t timeoutTicks = SemaphoreIF::NO_TIMEOUT);
+			TickType_t timeoutTicks = SemaphoreIF::BLOCKING);
 
 	/**
 	 * Get handle to the task related to the semaphore.
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index cc2f865ff..6d90c3f61 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -2,8 +2,8 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t MutexIF::NO_TIMEOUT = 0;
-const uint32_t MutexIF::MAX_TIMEOUT = portMAX_DELAY;
+const uint32_t MutexIF::POLLING = 0;
+const uint32_t MutexIF::BLOCKING = portMAX_DELAY;
 
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
@@ -23,11 +23,11 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 	if (handle == nullptr) {
 		return MutexIF::MUTEX_NOT_FOUND;
 	}
-	TickType_t timeout = MutexIF::NO_TIMEOUT;
-	if(timeoutMs == MutexIF::MAX_TIMEOUT) {
-		timeout = MutexIF::MAX_TIMEOUT;
+	TickType_t timeout = MutexIF::POLLING;
+	if(timeoutMs == MutexIF::BLOCKING) {
+		timeout = MutexIF::BLOCKING;
 	}
-	else if(timeoutMs > MutexIF::NO_TIMEOUT){
+	else if(timeoutMs > MutexIF::POLLING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 90e824678..d6e0aab9e 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -18,7 +18,7 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::MAX_TIMEOUT) override;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
 	ReturnValue_t unlockMutex() override;
 private:
 	SemaphoreHandle_t handle;
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 05a898cd1..caf984f21 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -6,8 +6,8 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
-const uint32_t SemaphoreIF::MAX_TIMEOUT = portMAX_DELAY;
+const uint32_t SemaphoreIF::POLLING= 0;
+const uint32_t SemaphoreIF::BLOCKING = portMAX_DELAY;
 
 static const uint32_t USE_REGULAR_SEMAPHORES = 0;
 static const uint32_t USE_TASK_NOTIFICATIONS = 1;
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 29b2b82a6..9fb11776b 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -21,7 +21,7 @@ inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
 		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
 			address,ignoreFault);
 	return status;
@@ -33,7 +33,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 	// debug << "PoolManager( " << translateObject(getObjectId()) <<
 	//       " )::deleteData from store " << packet_id.pool_index <<
 	//       ". id is "<< packet_id.packet_index << std::endl;
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
 	return status;
 }
@@ -41,7 +41,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 		size_t size, store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
 			size, storeId);
 	return status;

From 54edeacb2d20dcd5a01c0a11e3337b18fb3cf364 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Jun 2020 22:25:28 +0200
Subject: [PATCH 0349/1774] changed names for linux

---
 osal/FreeRTOS/SemaphoreFactory.cpp | 2 +-
 osal/linux/BinarySemaphore.cpp     | 6 +++---
 osal/linux/BinarySemaphore.h       | 2 +-
 osal/linux/Clock.cpp               | 4 ++--
 osal/linux/Mutex.cpp               | 5 +++--
 osal/linux/SemaphoreFactory.cpp    | 4 ++--
 6 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index caf984f21..78427f6cf 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -6,7 +6,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-const uint32_t SemaphoreIF::POLLING= 0;
+const uint32_t SemaphoreIF::POLLING = 0;
 const uint32_t SemaphoreIF::BLOCKING = portMAX_DELAY;
 
 static const uint32_t USE_REGULAR_SEMAPHORES = 0;
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 7c76a5c4f..e2ad9b58a 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -27,13 +27,13 @@ BinarySemaphore& BinarySemaphore::operator =(
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	int result = 0;
-	if(timeoutMs == SemaphoreIF::NO_TIMEOUT) {
+	if(timeoutMs == SemaphoreIF::POLLING) {
 		result = sem_trywait(&handle);
 	}
-	else if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	else if(timeoutMs == SemaphoreIF::BLOCKING) {
 	    result = sem_wait(&handle);
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 		timespec timeOut;
 		clock_gettime(CLOCK_REALTIME, &timeOut);
 		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
diff --git a/osal/linux/BinarySemaphore.h b/osal/linux/BinarySemaphore.h
index 7836cd413..9d4ed1cd4 100644
--- a/osal/linux/BinarySemaphore.h
+++ b/osal/linux/BinarySemaphore.h
@@ -50,7 +50,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT) override;
+	       	   SemaphoreIF::BLOCKING) override;
 
 	/**
 	 * Release the binary semaphore.
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 630b2cf4c..eda5b7af5 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -179,7 +179,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -194,7 +194,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex==NULL){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index b47732672..bdcf34390 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -2,7 +2,8 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/timemanager/Clock.h>
 
-const uint32_t MutexIF::NO_TIMEOUT = 0;
+const uint32_t MutexIF::BLOCKING = 0xffffffff;
+const uint32_t MutexIF::POLLING = 0;
 uint8_t Mutex::count = 0;
 
 
@@ -41,7 +42,7 @@ Mutex::~Mutex() {
 
 ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 	int status = 0;
-	if (timeoutMs != MutexIF::NO_TIMEOUT) {
+	if (timeoutMs != MutexIF::BLOCKING) {
 		timespec timeOut;
 		clock_gettime(CLOCK_REALTIME, &timeOut);
 		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index 5aec84eae..4fbd60d96 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -3,8 +3,8 @@
 #include <framework/osal/linux/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
-const uint32_t SemaphoreIF::MAX_TIMEOUT = 0xFFFFFFFF;
+const uint32_t SemaphoreIF::POLLING = 0;
+const uint32_t SemaphoreIF::BLOCKING = 0xffffffff;
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 

From 6972e72fbf2a1a5f9dd1adae9c8274ecb1119581 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Jun 2020 23:52:31 +0200
Subject: [PATCH 0350/1774] fixed order

---
 ipc/FwMessageTypes.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/ipc/FwMessageTypes.h b/ipc/FwMessageTypes.h
index 07e3d2458..b59319aaf 100644
--- a/ipc/FwMessageTypes.h
+++ b/ipc/FwMessageTypes.h
@@ -14,8 +14,9 @@ enum FW_MESSAGE_TYPE {
 	MONITORING,
 	MEMORY,
 	PARAMETER,
+	FILE_SYSTEM_MESSAGE,
 	FW_MESSAGES_COUNT,
-	FILE_SYSTEM_MESSAGE
+
 };
 }
 

From 5036cdbef3f23cc878c2ce09f66fc648fd34bbe5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Jun 2020 23:54:24 +0200
Subject: [PATCH 0351/1774] queue factory first param uint32_t again

---
 ipc/QueueFactory.h             | 2 +-
 osal/FreeRTOS/QueueFactory.cpp | 2 +-
 osal/linux/QueueFactory.cpp    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index 9a883fd8a..09259ae34 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -18,7 +18,7 @@ public:
 	 */
 	static QueueFactory* instance();
 
-	MessageQueueIF* createMessageQueue(size_t messageDepth = 3,
+	MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
 			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
 
 	void deleteMessageQueue(MessageQueueIF* queue);
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index a4ee5cf37..372d0d413 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -26,7 +26,7 @@ QueueFactory::QueueFactory() {
 QueueFactory::~QueueFactory() {
 }
 
-MessageQueueIF* QueueFactory::createMessageQueue(size_t messageDepth,
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
 		size_t maxMessageSize) {
 	return new MessageQueue(messageDepth, maxMessageSize);
 }
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index 2bacb815f..268d0b995 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -28,7 +28,7 @@ QueueFactory::QueueFactory() {
 QueueFactory::~QueueFactory() {
 }
 
-MessageQueueIF* QueueFactory::createMessageQueue(size_t messageDepth,
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
 		size_t maxMessageSize) {
 	return new MessageQueue(messageDepth, maxMessageSize);
 }

From 3483dff2abf171f85f61e498c6ce3c10131783ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 22:56:03 +0200
Subject: [PATCH 0352/1774] some more interface improvements

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 87 ++++++++++++---------
 serviceinterface/ServiceInterfaceBuffer.h   | 50 ++++++++----
 serviceinterface/ServiceInterfaceStream.cpp | 12 ++-
 serviceinterface/ServiceInterfaceStream.h   | 29 +++++--
 4 files changed, 119 insertions(+), 59 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 2a97ab90b..b0abb9295 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -3,9 +3,42 @@
 #include <cstring>
 
 // to be implemented by bsp
-extern "C" void printChar(const char*);
+extern "C" void printChar(const char*, bool errStream);
+
+#ifndef UT699
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
+        bool errStream, bool addCrToPreamble, uint16_t port):
+		isActive(true), logMessage(setMessage),
+		addCrToPreamble(addCrToPreamble), errStream(errStream) {
+	if(not errStream) {
+		// Set pointers if the stream is buffered.
+		setp( buf, buf + BUF_SIZE );
+	}
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	for(; begin != end; begin++){
+		printChar(begin, false);
+	}
+}
+
+#endif
 
 int ServiceInterfaceBuffer::overflow(int c) {
+	if(errStream) {
+		if (c != Traits::eof()) {
+			printChar(reinterpret_cast<const char*>(&c), true);
+		}
+		return 0;
+	}
 	// Handle output
 	putChars(pbase(), pptr());
 	if (c != Traits::eof()) {
@@ -20,18 +53,13 @@ int ServiceInterfaceBuffer::overflow(int c) {
 }
 
 int ServiceInterfaceBuffer::sync(void) {
+	if(errStream) {
+		return 0;
+	}
+
 	if (this->isActive) {
-		Clock::TimeOfDay_t loggerTime;
-		Clock::getDateAndTime(&loggerTime);
-		std::string preamble;
-		if(addCrToPreamble) {
-			preamble += "\r";
-		}
-		preamble += log_message + ": | " + zero_padded(loggerTime.hour, 2)
-				+ ":" + zero_padded(loggerTime.minute, 2) + ":"
-				+ zero_padded(loggerTime.second, 2) + "."
-				+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
-		// Write log_message and time
+		auto preamble = getPreamble();
+		// Write logMessage and time
 		this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
 		// Handle output
 		this->putChars(pbase(), pptr());
@@ -42,31 +70,20 @@ int ServiceInterfaceBuffer::sync(void) {
 }
 
 
-
-#ifndef UT699
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-        uint16_t port, bool addCrToPreamble) {
-	this->addCrToPreamble = addCrToPreamble;
-	this->log_message = set_message;
-	this->isActive = true;
-	setp( buf, buf + BUF_SIZE );
+std::string ServiceInterfaceBuffer::getPreamble() {
+	Clock::TimeOfDay_t loggerTime;
+	Clock::getDateAndTime(&loggerTime);
+	std::string preamble;
+	if(addCrToPreamble) {
+		preamble += "\r";
+	}
+	preamble += logMessage + ": | " + zero_padded(loggerTime.hour, 2)
+							+ ":" + zero_padded(loggerTime.minute, 2) + ":"
+							+ zero_padded(loggerTime.second, 2) + "."
+							+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
+	return preamble;
 }
 
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	for(; begin != end; begin++){
-		printChar(begin);
-	}
-
-}
-#endif
 
 
 #ifdef UT699
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index a2bc4f4b1..74facafe0 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -3,43 +3,64 @@
 
 #include <iostream>
 #include <sstream>
-#include <cstdio>
 #include <iomanip>
 
 #ifndef UT699
+
+/**
+ * @brief 	This is the underlying stream buffer which implements the
+ * 			streambuf class and overloads the overflow() and sync() methods
+ * @details
+ * This class is used to modify the output of the stream, for example by adding.
+ * It also calls the char printing function which is implemented in the
+ * board supply package (BSP).
+ */
 class ServiceInterfaceBuffer:
-        public std::basic_streambuf<char,std::char_traits<char>> {
+        public std::streambuf {
 	friend class ServiceInterfaceStream;
 public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port,
-			bool addCrToPreamble);
+	ServiceInterfaceBuffer(std::string setMessage, bool errStream,
+			bool addCrToPreamble, uint16_t port);
+
 protected:
 	bool isActive;
-	// This is called when buffer becomes full. If
-	// buffer is not used, then this is called every
-	// time when characters are put to stream.
+	//! This is called when buffer becomes full. If
+	//! buffer is not used, then this is called every
+	//! time when characters are put to stream.
 	int overflow(int c = Traits::eof()) override;
 
-	// This function is called when stream is flushed,
-	// for example when std::endl is put to stream.
+	//! This function is called when stream is flushed,
+	//! for example when std::endl is put to stream.
 	int sync(void) override;
 
 private:
-	// For additional message information
-	std::string log_message;
+	//! For additional message information
+	std::string logMessage;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
-	// This is useful for some terminal programs which do not have
-	// implicit carriage return with newline characters.
+	//! This is useful for some terminal programs which do not have
+	//! implicit carriage return with newline characters.
 	bool addCrToPreamble;
+	//! This specifies to print to stderr and work in unbuffered mode.
+	bool errStream;
 
 	// Work in buffer mode. It is also possible to work without buffer.
 	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
 
-	// In this function, the characters are parsed.
+	//! In this function, the characters are parsed.
 	void putChars(char const* begin, char const* end);
 
+	std::string getPreamble();
+
+	/**
+	 * This helper function returns the zero padded string version of a number.
+	 * The type is deduced automatically.
+	 * @tparam T
+	 * @param num
+	 * @param width
+	 * @return
+	 */
 	template<typename T>
 	std::string zero_padded(const T& num, uint8_t width) {
 	    std::ostringstream string_to_pad;
@@ -52,6 +73,7 @@ private:
 	    return result;
 	}
 };
+
 #endif
 
 
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 40f52f1fe..783715484 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,11 +1,15 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
+		bool errStream, bool addCrToPreamble, uint16_t port) :
+		std::ostream(&buf),
+		buf(setMessage, errStream, addCrToPreamble, port) {
+}
+
 void ServiceInterfaceStream::setActive( bool myActive) {
 	this->buf.isActive = myActive;
 }
 
-ServiceInterfaceStream::ServiceInterfaceStream(std::string set_message,
-		bool addCrToPreamble, uint16_t port) :
-		std::basic_ostream<char, std::char_traits<char>>(&buf),
-		buf(set_message, port, addCrToPreamble) {
+std::string ServiceInterfaceStream::getPreamble() {
+	return buf.getPreamble();
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index a445dcedd..52ac1310c 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -3,11 +3,9 @@
 
 #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
 #include <iostream>
-#include <iosfwd>
-#include <sstream>
 #include <cstdio>
 
-// Unfortunately, there must be a forward declaration of log_fe
+// Unfortunately, there must be a forward declaration of the log front end
 // (MUST be defined in main), to let the system know where to write to.
 namespace sif {
 extern std::ostream debug;
@@ -18,13 +16,32 @@ extern std::ostream error;
 
 
 class ServiceInterfaceStream :
-        public std::basic_ostream<char, std::char_traits<char>> {
+        public std::ostream {
 protected:
     ServiceInterfaceBuffer buf;
 public:
-    ServiceInterfaceStream( std::string set_message,
-    		bool addCrToPreamble = false, uint16_t port = 1234);
+    /**
+     * This constructor is used by specifying the preamble message.
+     * Optionally, the output can be directed to stderr and a CR character
+     * can be prepended to the preamble.
+     * @param set_message
+     * @param errStream
+     * @param addCrToPreamble
+     * @param port
+     */
+    ServiceInterfaceStream(std::string setMessage,
+    		bool errStream = false, bool addCrToPreamble = false,
+			uint16_t port = 1234);
+
+    //! An inactive stream will not print anything.
 	void setActive( bool );
+
+	/**
+	 * This can be used to retrieve the preamble in case it should be printed in
+	 * the unbuffered mode.
+	 * @return Preamle consisting of log message and timestamp.
+	 */
+	std::string getPreamble();
 };
 
 

From 1c0ca4c329c99caa75f438745b53a53f2978cd30 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 23:02:23 +0200
Subject: [PATCH 0353/1774] some changes to take care of activity

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index b0abb9295..93de88b39 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -33,7 +33,7 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 #endif
 
 int ServiceInterfaceBuffer::overflow(int c) {
-	if(errStream) {
+	if(errStream and this->isActive) {
 		if (c != Traits::eof()) {
 			printChar(reinterpret_cast<const char*>(&c), true);
 		}
@@ -53,17 +53,18 @@ int ServiceInterfaceBuffer::overflow(int c) {
 }
 
 int ServiceInterfaceBuffer::sync(void) {
-	if(errStream) {
+	if(not this->isActive or errStream) {
+		if(not errStream) {
+			setp(buf, buf + BUF_SIZE - 1);
+		}
 		return 0;
 	}
 
-	if (this->isActive) {
-		auto preamble = getPreamble();
-		// Write logMessage and time
-		this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
-		// Handle output
-		this->putChars(pbase(), pptr());
-	}
+	auto preamble = getPreamble();
+	// Write logMessage and time
+	this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
+	// Handle output
+	this->putChars(pbase(), pptr());
 	// This tells that buffer is empty again
 	setp(buf, buf + BUF_SIZE - 1);
 	return 0;

From 5b93799ea659b0b93bd769657c0d00c390786e26 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 23:10:04 +0200
Subject: [PATCH 0354/1774] added forward declarations for service interface
 streams

---
 serviceinterface/ServiceInterfaceStream.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 52ac1310c..aecd45c37 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -44,5 +44,13 @@ public:
 	std::string getPreamble();
 };
 
+// Forward declaration of interface streams. These are needed so the public
+// functions can be used by including this header
+namespace sif {
+extern ServiceInterfaceStream debugStream;
+extern ServiceInterfaceStream infoStream;
+extern ServiceInterfaceStream warningStream;
+extern ServiceInterfaceStream errorStream;
+}
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

From 0a512abc3364855116a4756e42aeac33c0aa2fe2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 23:26:27 +0200
Subject: [PATCH 0355/1774] additional clarification comment

---
 serviceinterface/ServiceInterfaceStream.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index aecd45c37..32437d81d 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -7,6 +7,9 @@
 
 // Unfortunately, there must be a forward declaration of the log front end
 // (MUST be defined in main), to let the system know where to write to.
+// The ServiceInterfaceStream instances (declared below and instantiated in main)
+// can be passed to these front ends by passing their underlying buffers
+// with .rdbuf()
 namespace sif {
 extern std::ostream debug;
 extern std::ostream info;

From 5eb3d77bdbb1f4537c95d5c6919a0792b8f274e6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 23:29:00 +0200
Subject: [PATCH 0356/1774] clarfiying comment

---
 serviceinterface/ServiceInterfaceStream.h | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 32437d81d..375a18759 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -5,11 +5,11 @@
 #include <iostream>
 #include <cstdio>
 
-// Unfortunately, there must be a forward declaration of the log front end
-// (MUST be defined in main), to let the system know where to write to.
-// The ServiceInterfaceStream instances (declared below and instantiated in main)
-// can be passed to these front ends by passing their underlying buffers
-// with .rdbuf()
+/* Unfortunately, there must be a forward declaration of the log front end
+ * (MUST be defined in main), to let the system know where to write to.
+ * The ServiceInterfaceStream instances, which are declared below and
+ * can instantaited somewhere else can be passed to these front ends by passing
+ * their underlying buffers with .rdbuf() */
 namespace sif {
 extern std::ostream debug;
 extern std::ostream info;

From 17ed9b77967f6a8ba2deb281a730df3b33fdadb3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 23:38:02 +0200
Subject: [PATCH 0357/1774] OS renamed to OS_FSFW (nameclash with system
 variable)

---
 framework.mk | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/framework.mk b/framework.mk
index cb3e4f229..f2107a4cf 100644
--- a/framework.mk
+++ b/framework.mk
@@ -28,11 +28,11 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/objectmanager/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/*.cpp)
 
 # select the OS
-ifeq ($(OS),rtems)
+ifeq ($(OS_FSFW),rtems)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/rtems/*.cpp)
-else ifeq ($(OS),linux)
+else ifeq ($(OS_FSFW),linux)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/linux/*.cpp)
-else ifeq ($(OS),freeRTOS)
+else ifeq ($(OS_FSFW),freeRTOS)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
 else
 $(error invalid OS specified, valid OS are rtems, linux, freeRTOS)

From 925a54dec965b0c52d312616f9f42902fd5fac2e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 01:06:03 +0200
Subject: [PATCH 0358/1774] more improvements for servicei nterface

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 28 +++++++----
 serviceinterface/ServiceInterfaceBuffer.h   |  5 +-
 serviceinterface/ServiceInterfaceStream.cpp | 22 ++++++++-
 serviceinterface/ServiceInterfaceStream.h   | 51 +++++++++++----------
 4 files changed, 69 insertions(+), 37 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 93de88b39..92f08cae8 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -8,10 +8,11 @@ extern "C" void printChar(const char*, bool errStream);
 #ifndef UT699
 
 ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
-        bool errStream, bool addCrToPreamble, uint16_t port):
+		bool addCrToPreamble, bool buffered , bool errStream, uint16_t port):
 		isActive(true), logMessage(setMessage),
-		addCrToPreamble(addCrToPreamble), errStream(errStream) {
-	if(not errStream) {
+		addCrToPreamble(addCrToPreamble), buffered(buffered),
+		errStream(errStream) {
+	if(buffered) {
 		// Set pointers if the stream is buffered.
 		setp( buf, buf + BUF_SIZE );
 	}
@@ -26,16 +27,27 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 	memcpy(array, begin, length);
 
 	for(; begin != end; begin++){
-		printChar(begin, false);
+		if(errStream) {
+			printChar(begin, true);
+		}
+		else {
+			printChar(begin, false);
+		}
+
 	}
 }
 
 #endif
 
 int ServiceInterfaceBuffer::overflow(int c) {
-	if(errStream and this->isActive) {
+	if(not buffered and this->isActive) {
 		if (c != Traits::eof()) {
-			printChar(reinterpret_cast<const char*>(&c), true);
+			if(errStream) {
+				printChar(reinterpret_cast<const char*>(&c), true);
+			}
+			else {
+				printChar(reinterpret_cast<const char*>(&c), false);
+			}
 		}
 		return 0;
 	}
@@ -53,8 +65,8 @@ int ServiceInterfaceBuffer::overflow(int c) {
 }
 
 int ServiceInterfaceBuffer::sync(void) {
-	if(not this->isActive or errStream) {
-		if(not errStream) {
+	if(not this->isActive) {
+		if(not buffered) {
 			setp(buf, buf + BUF_SIZE - 1);
 		}
 		return 0;
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 74facafe0..e3927007d 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -19,8 +19,8 @@ class ServiceInterfaceBuffer:
         public std::streambuf {
 	friend class ServiceInterfaceStream;
 public:
-	ServiceInterfaceBuffer(std::string setMessage, bool errStream,
-			bool addCrToPreamble, uint16_t port);
+	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
+			bool buffered, bool errStream, uint16_t port);
 
 protected:
 	bool isActive;
@@ -41,6 +41,7 @@ private:
 	//! This is useful for some terminal programs which do not have
 	//! implicit carriage return with newline characters.
 	bool addCrToPreamble;
+	bool buffered;
 	//! This specifies to print to stderr and work in unbuffered mode.
 	bool errStream;
 
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 783715484..bef8136e1 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,9 +1,9 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
-		bool errStream, bool addCrToPreamble, uint16_t port) :
+		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
 		std::ostream(&buf),
-		buf(setMessage, errStream, addCrToPreamble, port) {
+		buf(setMessage, addCrToPreamble, buffered, errStream,  port) {
 }
 
 void ServiceInterfaceStream::setActive( bool myActive) {
@@ -13,3 +13,21 @@ void ServiceInterfaceStream::setActive( bool myActive) {
 std::string ServiceInterfaceStream::getPreamble() {
 	return buf.getPreamble();
 }
+
+void ServiceInterfaceStream::print(std::string error,
+		bool withPreamble, bool withNewline, bool flush) {
+	if(not buffered and withPreamble) {
+		*this << getPreamble() << error;
+	}
+	else {
+		*this << error;
+	}
+
+	if(withNewline) {
+		*this << "\n";
+	}
+	// if mode is non-buffered, no need to flush.
+	if(flush and buffered) {
+		this->flush();
+	}
+}
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 375a18759..9b8b5b6ed 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -5,19 +5,11 @@
 #include <iostream>
 #include <cstdio>
 
-/* Unfortunately, there must be a forward declaration of the log front end
- * (MUST be defined in main), to let the system know where to write to.
- * The ServiceInterfaceStream instances, which are declared below and
- * can instantaited somewhere else can be passed to these front ends by passing
- * their underlying buffers with .rdbuf() */
-namespace sif {
-extern std::ostream debug;
-extern std::ostream info;
-extern std::ostream warning;
-extern std::ostream error;
-}
-
-
+/**
+ * Generic service interface stream which can be used like std::cout or
+ * std::cerr but has additional capability. Add preamble and timestamp
+ * to output. Can be run in buffered or unbuffered mode.
+ */
 class ServiceInterfaceStream :
         public std::ostream {
 protected:
@@ -27,14 +19,14 @@ public:
      * This constructor is used by specifying the preamble message.
      * Optionally, the output can be directed to stderr and a CR character
      * can be prepended to the preamble.
-     * @param set_message
-     * @param errStream
-     * @param addCrToPreamble
-     * @param port
+     * @param setMessage message of preamble.
+     * @param addCrToPreamble Useful for applications like Puttty.
+     * @param buffered specify whether to use buffered mode.
+     * @param errStream specify which output stream to use (stderr or stdout).
      */
     ServiceInterfaceStream(std::string setMessage,
-    		bool errStream = false, bool addCrToPreamble = false,
-			uint16_t port = 1234);
+    		bool addCrToPreamble = false, bool buffered = true,
+			bool errStream = false, uint16_t port = 1234);
 
     //! An inactive stream will not print anything.
 	void setActive( bool );
@@ -45,15 +37,24 @@ public:
 	 * @return Preamle consisting of log message and timestamp.
 	 */
 	std::string getPreamble();
+
+	/**
+	 * This prints an error with a preamble. Useful if using the unbuffered
+	 * mode. Flushes in default mode (prints immediately).
+	 */
+	void print(std::string error, bool withPreamble = true,
+			bool withNewline = true, bool flush = true);
+
+	bool buffered = false;
 };
 
-// Forward declaration of interface streams. These are needed so the public
-// functions can be used by including this header
+// Forward declaration of interface streams. These should be instantiated in
+// main. They can then be used like std::cout or std::cerr.
 namespace sif {
-extern ServiceInterfaceStream debugStream;
-extern ServiceInterfaceStream infoStream;
-extern ServiceInterfaceStream warningStream;
-extern ServiceInterfaceStream errorStream;
+extern ServiceInterfaceStream debug;
+extern ServiceInterfaceStream info;
+extern ServiceInterfaceStream warning;
+extern ServiceInterfaceStream error;
 }
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

From a115bf1186d075ea8c6b98c03ba847f22d41251b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 14:43:33 +0200
Subject: [PATCH 0359/1774] store access improvements

---
 storagemanager/LocalPool.h        | 10 +++++-----
 storagemanager/PoolManager.h      |  3 ++-
 storagemanager/PoolManager.tpp    |  1 -
 storagemanager/StorageManagerIF.h |  3 ++-
 4 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 2d61dea51..bb94a3be2 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -24,7 +24,6 @@
  * 			The local pool is NOT thread-safe.
  * @author 	Bastian Baetz
  */
-
 template<uint8_t NUMBER_OF_POOLS = 5>
 class LocalPool: public SystemObject, public StorageManagerIF {
 public:
@@ -48,9 +47,10 @@ public:
 	 * 						number of elements for each pool is determined.
 	 * 						The position of these values correspond to those in
 	 * 						element_sizes.
-	 * @param registered	Register the pool in object manager or not. Default is false (local pool).
-	 * @param spillsToHigherPools
-	 * 						A variable to determine whether higher n pools are used if the store is full.
+	 * @param registered	Register the pool in object manager or not.
+	 * Default is false (local pool).
+	 * @param spillsToHigherPools A variable to determine whether
+	 * higher n pools are used if the store is full.
 	 */
 	LocalPool(object_id_t setObjectId,
 			const uint16_t element_sizes[NUMBER_OF_POOLS],
@@ -117,7 +117,7 @@ private:
 	/**
 	 * @brief	store represents the actual memory pool.
 	 * @details	It is an array of pointers to memory, which was allocated with
-	 * 			a \c new call on construction.
+	 * 			a @c new call on construction.
 	 */
 	uint8_t* store[NUMBER_OF_POOLS];
 	/**
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index c74e95c0e..7c2e8a719 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -12,7 +12,7 @@
  * 			with a lock.
  * @author 	Bastian Baetz
  */
-template <uint8_t NUMBER_OF_POOLS>
+template <uint8_t NUMBER_OF_POOLS = 5>
 class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
 public:
 	PoolManager(object_id_t setObjectId,
@@ -27,6 +27,7 @@ public:
 	ReturnValue_t deleteData(store_address_t) override;
 	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = nullptr) override;
+
 protected:
 	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
 			bool ignoreFault) override;
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 9fb11776b..a35b810c9 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -48,4 +48,3 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 }
 
 #endif
-
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index d5ac5818e..f8aee8198 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -11,7 +11,6 @@
 using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
 using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
 
-
 /**
  * @brief	This class provides an interface for intermediate data storage.
  * @details	The Storage manager classes shall be used to store larger chunks of
@@ -80,6 +79,7 @@ public:
 	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = nullptr) = 0;
 
+
 	/**
 	 * @brief 	Access the data by supplying a store ID.
 	 * @details
@@ -100,6 +100,7 @@ public:
 	virtual ReturnValue_t getData(store_address_t storeId,
 			ConstStorageAccessor& constAccessor) = 0;
 
+
 	/**
 	 * @brief	getData returns an address to data and the size of the data
 	 * 			for a given packet_id.

From 6ff1cf46c5cda5e6c9ecb85926acc68c8825b1ad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 19:40:43 +0200
Subject: [PATCH 0360/1774] new service interface stream

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 46 ++++++++++++++++-----
 serviceinterface/ServiceInterfaceBuffer.h   | 36 +++-------------
 serviceinterface/ServiceInterfaceStream.cpp | 13 +++---
 serviceinterface/ServiceInterfaceStream.h   | 32 +++++++-------
 4 files changed, 63 insertions(+), 64 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 92f08cae8..f1332637c 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,6 +1,7 @@
 #include <framework/timemanager/Clock.h>
 #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
 #include <cstring>
+#include <inttypes.h>
 
 // to be implemented by bsp
 extern "C" void printChar(const char*, bool errStream);
@@ -16,6 +17,8 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 		// Set pointers if the stream is buffered.
 		setp( buf, buf + BUF_SIZE );
 	}
+	preamble.reserve(96);
+	preamble.resize(96);
 }
 
 void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
@@ -65,16 +68,22 @@ int ServiceInterfaceBuffer::overflow(int c) {
 }
 
 int ServiceInterfaceBuffer::sync(void) {
-	if(not this->isActive) {
+	if(not this->isActive and not buffered) {
 		if(not buffered) {
 			setp(buf, buf + BUF_SIZE - 1);
 		}
 		return 0;
 	}
+	if(not buffered) {
+		return 0;
+	}
 
-	auto preamble = getPreamble();
+	size_t preambleSize  = 0;
+	auto preamble = getPreamble(&preambleSize);
+	uint8_t debugArray[96];
+	memcpy(debugArray, preamble.data(), preambleSize);
 	// Write logMessage and time
-	this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
+	this->putChars(preamble.data(), preamble.data() + preambleSize);
 	// Handle output
 	this->putChars(pbase(), pptr());
 	// This tells that buffer is empty again
@@ -82,18 +91,35 @@ int ServiceInterfaceBuffer::sync(void) {
 	return 0;
 }
 
+bool ServiceInterfaceBuffer::isBuffered() const {
+	return buffered;
+}
 
-std::string ServiceInterfaceBuffer::getPreamble() {
+std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 	Clock::TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
-	std::string preamble;
+	std::string preamble (96, 0);
+	size_t currentSize = 0;
+	char* parsePosition = &preamble[0];
 	if(addCrToPreamble) {
-		preamble += "\r";
+		preamble[0] = '\r';
+		currentSize += 1;
+		parsePosition += 1;
+	}
+	int32_t charCount = sprintf(parsePosition,
+			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
+					this->logMessage.c_str(), loggerTime.hour,
+					loggerTime.minute,
+					loggerTime.second,
+					loggerTime.usecond /1000);
+	if(charCount < 0) {
+		printf("ServiceInterfaceBuffer: Failure parsing preamble");
+		return "";
+	}
+	currentSize += charCount;
+	if(preambleSize != nullptr) {
+		*preambleSize = currentSize;
 	}
-	preamble += logMessage + ": | " + zero_padded(loggerTime.hour, 2)
-							+ ":" + zero_padded(loggerTime.minute, 2) + ":"
-							+ zero_padded(loggerTime.second, 2) + "."
-							+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
 	return preamble;
 }
 
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index e3927007d..00a8e74a3 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <iostream>
 #include <sstream>
 #include <iomanip>
@@ -33,18 +34,20 @@ protected:
 	//! for example when std::endl is put to stream.
 	int sync(void) override;
 
+	bool isBuffered() const;
 private:
 	//! For additional message information
 	std::string logMessage;
+	std::string preamble;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
 	//! This is useful for some terminal programs which do not have
 	//! implicit carriage return with newline characters.
 	bool addCrToPreamble;
-	bool buffered;
+
 	//! This specifies to print to stderr and work in unbuffered mode.
 	bool errStream;
-
+	bool buffered;
 	// Work in buffer mode. It is also possible to work without buffer.
 	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
@@ -52,39 +55,12 @@ private:
 	//! In this function, the characters are parsed.
 	void putChars(char const* begin, char const* end);
 
-	std::string getPreamble();
-
-	/**
-	 * This helper function returns the zero padded string version of a number.
-	 * The type is deduced automatically.
-	 * @tparam T
-	 * @param num
-	 * @param width
-	 * @return
-	 */
-	template<typename T>
-	std::string zero_padded(const T& num, uint8_t width) {
-	    std::ostringstream string_to_pad;
-	    string_to_pad << std::setw(width) << std::setfill('0') << num;
-	    std::string result = string_to_pad.str();
-	    if (result.length() > width)
-	    {
-	        result.erase(0, result.length() - width);
-	    }
-	    return result;
-	}
+	std::string getPreamble(size_t * preambleSize = nullptr);
 };
 
 #endif
 
 
-
-
-
-
-
-
-
 #ifdef UT699
 class ServiceInterfaceBuffer: public std::basic_streambuf<char,
 		std::char_traits<char> > {
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index bef8136e1..76481ed12 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -2,21 +2,20 @@
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
 		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
-		std::ostream(&buf),
-		buf(setMessage, addCrToPreamble, buffered, errStream,  port) {
-}
+		std::ostream(&streambuf),
+		streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
 
 void ServiceInterfaceStream::setActive( bool myActive) {
-	this->buf.isActive = myActive;
+	this->streambuf.isActive = myActive;
 }
 
 std::string ServiceInterfaceStream::getPreamble() {
-	return buf.getPreamble();
+	return streambuf.getPreamble();
 }
 
 void ServiceInterfaceStream::print(std::string error,
 		bool withPreamble, bool withNewline, bool flush) {
-	if(not buffered and withPreamble) {
+	if(not streambuf.isBuffered() and withPreamble) {
 		*this << getPreamble() << error;
 	}
 	else {
@@ -27,7 +26,7 @@ void ServiceInterfaceStream::print(std::string error,
 		*this << "\n";
 	}
 	// if mode is non-buffered, no need to flush.
-	if(flush and buffered) {
+	if(flush and streambuf.isBuffered()) {
 		this->flush();
 	}
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 9b8b5b6ed..9e19c228c 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -10,25 +10,22 @@
  * std::cerr but has additional capability. Add preamble and timestamp
  * to output. Can be run in buffered or unbuffered mode.
  */
-class ServiceInterfaceStream :
-        public std::ostream {
-protected:
-    ServiceInterfaceBuffer buf;
+class ServiceInterfaceStream : public std::ostream {
 public:
-    /**
-     * This constructor is used by specifying the preamble message.
-     * Optionally, the output can be directed to stderr and a CR character
-     * can be prepended to the preamble.
-     * @param setMessage message of preamble.
-     * @param addCrToPreamble Useful for applications like Puttty.
-     * @param buffered specify whether to use buffered mode.
-     * @param errStream specify which output stream to use (stderr or stdout).
-     */
-    ServiceInterfaceStream(std::string setMessage,
-    		bool addCrToPreamble = false, bool buffered = true,
+	/**
+	 * This constructor is used by specifying the preamble message.
+	 * Optionally, the output can be directed to stderr and a CR character
+	 * can be prepended to the preamble.
+	 * @param setMessage message of preamble.
+	 * @param addCrToPreamble Useful for applications like Puttty.
+	 * @param buffered specify whether to use buffered mode.
+	 * @param errStream specify which output stream to use (stderr or stdout).
+	 */
+	ServiceInterfaceStream(std::string setMessage,
+			bool addCrToPreamble = false, bool buffered = true,
 			bool errStream = false, uint16_t port = 1234);
 
-    //! An inactive stream will not print anything.
+	//! An inactive stream will not print anything.
 	void setActive( bool );
 
 	/**
@@ -45,7 +42,8 @@ public:
 	void print(std::string error, bool withPreamble = true,
 			bool withNewline = true, bool flush = true);
 
-	bool buffered = false;
+protected:
+	ServiceInterfaceBuffer streambuf;
 };
 
 // Forward declaration of interface streams. These should be instantiated in

From 4d59ddc3db6d9382e61bc4492e51c63283174489 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 19:50:26 +0200
Subject: [PATCH 0361/1774] some fixes, check for preamble size

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 15 ++++++++-------
 serviceinterface/ServiceInterfaceBuffer.h   |  9 +++++++--
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index f1332637c..5c80862c2 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -17,8 +17,8 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 		// Set pointers if the stream is buffered.
 		setp( buf, buf + BUF_SIZE );
 	}
-	preamble.reserve(96);
-	preamble.resize(96);
+	preamble.reserve(MAX_PREAMBLE_SIZE);
+	preamble.resize(MAX_PREAMBLE_SIZE);
 }
 
 void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
@@ -36,7 +36,6 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 		else {
 			printChar(begin, false);
 		}
-
 	}
 }
 
@@ -80,8 +79,6 @@ int ServiceInterfaceBuffer::sync(void) {
 
 	size_t preambleSize  = 0;
 	auto preamble = getPreamble(&preambleSize);
-	uint8_t debugArray[96];
-	memcpy(debugArray, preamble.data(), preambleSize);
 	// Write logMessage and time
 	this->putChars(preamble.data(), preamble.data() + preambleSize);
 	// Handle output
@@ -98,7 +95,6 @@ bool ServiceInterfaceBuffer::isBuffered() const {
 std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 	Clock::TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
-	std::string preamble (96, 0);
 	size_t currentSize = 0;
 	char* parsePosition = &preamble[0];
 	if(addCrToPreamble) {
@@ -113,7 +109,12 @@ std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 					loggerTime.second,
 					loggerTime.usecond /1000);
 	if(charCount < 0) {
-		printf("ServiceInterfaceBuffer: Failure parsing preamble");
+		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
+		return "";
+	}
+	if(charCount > MAX_PREAMBLE_SIZE) {
+		printf("ServiceInterfaceBuffer: Char count too large for maximum "
+				"preamble size");
 		return "";
 	}
 	currentSize += charCount;
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 00a8e74a3..39ea25c2d 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -20,6 +20,8 @@ class ServiceInterfaceBuffer:
         public std::streambuf {
 	friend class ServiceInterfaceStream;
 public:
+	static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
+
 	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
 			bool buffered, bool errStream, uint16_t port);
 
@@ -41,14 +43,17 @@ private:
 	std::string preamble;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
+
 	//! This is useful for some terminal programs which do not have
 	//! implicit carriage return with newline characters.
 	bool addCrToPreamble;
 
+	//! Specifies whether the stream operates in buffered or unbuffered mode.
+	bool buffered;
 	//! This specifies to print to stderr and work in unbuffered mode.
 	bool errStream;
-	bool buffered;
-	// Work in buffer mode. It is also possible to work without buffer.
+
+	//! Needed for buffered mode.
 	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
 

From 3eca16ff785b928f7015444d987a5dbed0ce99dd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 20:59:52 +0200
Subject: [PATCH 0362/1774] removed exit clause

---
 objectmanager/ObjectManagerIF.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 3575fc162..b523727c0 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -93,7 +93,6 @@ T* ObjectManagerIF::get( object_id_t id ) {
 	if(objectManager == nullptr) {
 		sif::error << "ObjectManagerIF: Global object manager has not "
 				"been initialized yet!" << std::endl;
-		std::exit(0);
 	}
 	SystemObjectIF* temp = this->getSystemObject(id);
 	return dynamic_cast<T*>(temp);

From 71487d60ca524042c95dffdf1582252f028f35e2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 21:01:09 +0200
Subject: [PATCH 0363/1774] onj managerIF update

---
 objectmanager/ObjectManagerIF.h | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index b523727c0..90a1ce3be 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -1,12 +1,5 @@
-/**
- * @file	ObjectManagerIF.h
- * @brief	This file contains the implementation of the ObjectManagerIF interface
- * @date	19.09.2012
- * @author	Bastian Baetz
- */
-
-#ifndef OBJECTMANAGERIF_H_
-#define OBJECTMANAGERIF_H_
+#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
 
 #include <framework/objectmanager/frameworkObjects.h>
 #include <framework/objectmanager/SystemObjectIF.h>
@@ -20,7 +13,8 @@
  * 			inserted, removed and retrieved from the list. On getting the
  * 			object, the call checks if the object implements the requested
  * 			interface.
- * \ingroup system_objects
+ * @author	Bastian Baetz
+ * @ingroup system_objects
  */
 class ObjectManagerIF : public HasReturnvaluesIF {
 public:

From 849053b830d92ccd463779569cb6c450033b47c1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 21:04:24 +0200
Subject: [PATCH 0364/1774] small fix for object manager.cpp

---
 objectmanager/ObjectManager.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 1912715dc..67cf5c1ca 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -23,8 +23,8 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 	} else {
 		sif::error << "ObjectManager::insert: Object id " << std::hex
 		           << (int)id << std::dec << " is already in use!" << std::endl;
-		exit(0); //This is very severe and difficult to handle in other places.
-		return this->INSERTION_FAILED;
+		//This is very severe and difficult to handle in other places.
+		std::exit(INSERTION_FAILED);
 	}
 }
 

From 569724843e7196d5c7ca0b324cd575b6aa9aa9ba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 21:11:49 +0200
Subject: [PATCH 0365/1774] object manager improvements

---
 objectmanager/ObjectManager.cpp | 34 +++++++++++++++------------------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 67cf5c1ca..3e0bfed6f 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -2,21 +2,19 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <cstdlib>
 
-ObjectManager::ObjectManager( void (*setProducer)() ) : produceObjects(setProducer) {
+ObjectManager::ObjectManager( void (*setProducer)() ):
+		produceObjects(setProducer) {
 	//There's nothing special to do in the constructor.
 }
 
 
 ObjectManager::~ObjectManager() {
-	std::map<object_id_t, SystemObjectIF*>::iterator it;
-	for (it = this->objectList.begin(); it != this->objectList.end(); it++) {
-		delete it->second;
-	}
+	// Map is STL object and deletes its own pointers.
 }
 
 ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
-	bool insert_return = this->objectList.insert( std::pair< object_id_t, SystemObjectIF* >( id, object ) ).second;
-	if (insert_return == true) {
+	auto returnPair = objectList.emplace(id, object);
+	if (returnPair.second) {
 	    // sif::debug << "ObjectManager::insert: Object " << std::hex
 	    //            << (int)id << std::dec << " inserted." << std::endl;
 		return this->RETURN_OK;
@@ -44,18 +42,15 @@ ReturnValue_t ObjectManager::remove( object_id_t id ) {
 
 
 SystemObjectIF* ObjectManager::getSystemObject( object_id_t id ) {
-	std::map<object_id_t, SystemObjectIF*>::iterator it = this->objectList.find( id );
-	if (it == this->objectList.end() ) {
-		//Changed for testing different method.
-//		SystemObjectIF* object = this->produceObjects( id );
-//		return object;
-		return NULL;
+	auto listIter = this->objectList.find( id );
+	if (listIter == this->objectList.end() ) {
+		return nullptr;
 	} else {
-		return it->second;
+		return listIter->second;
 	}
 }
 
-ObjectManager::ObjectManager( ) : produceObjects(NULL) {
+ObjectManager::ObjectManager() : produceObjects(nullptr) {
 
 }
 
@@ -63,7 +58,7 @@ void ObjectManager::initialize() {
 	this->produceObjects();
 	ReturnValue_t return_value = RETURN_FAILED;
 	uint32_t error_count = 0;
-	for (std::map<object_id_t, SystemObjectIF*>::iterator it = this->objectList.begin(); it != objectList.end(); it++ ) {
+	for (auto it = this->objectList.begin(); it != objectList.end(); it++ ) {
 		return_value = it->second->initialize();
 		if ( return_value != RETURN_OK ) {
 			object_id_t var = it->first;
@@ -79,10 +74,11 @@ void ObjectManager::initialize() {
 	}
 	//Init was successful. Now check successful interconnections.
 	error_count = 0;
-	for (std::map<object_id_t, SystemObjectIF*>::iterator it = this->objectList.begin(); it != objectList.end(); it++ ) {
-		return_value = it->second->checkObjectConnections();
+	for (auto listIter = this->objectList.begin();
+			listIter != objectList.end(); listIter++ ) {
+		return_value = listIter->second->checkObjectConnections();
 		if ( return_value != RETURN_OK ) {
-			sif::error << "Object " << std::hex <<  (int) it->first
+			sif::error << "Object " << std::hex <<  (int) listIter->first
 			        << " connection check failed with code 0x" << return_value
 			        << std::dec << std::endl;
 			error_count++;

From d423c001156916fe62b3113c539dee9931f359fb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 21:14:35 +0200
Subject: [PATCH 0366/1774] additional nullptr check

---
 objectmanager/ObjectManager.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 3e0bfed6f..a5895098a 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -55,6 +55,11 @@ ObjectManager::ObjectManager() : produceObjects(nullptr) {
 }
 
 void ObjectManager::initialize() {
+	if(produceObjects == nullptr) {
+		sif::error << "ObjectManager: Passed produceObjects functions is"
+				"nullptr!" << std::endl;
+		return;
+	}
 	this->produceObjects();
 	ReturnValue_t return_value = RETURN_FAILED;
 	uint32_t error_count = 0;

From e4944a067c3624a669c4703bfa0d5dce5f1b4119 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 21:24:44 +0200
Subject: [PATCH 0367/1774] change made was wrong (pointers in map are not
 deleted!)

---
 objectmanager/ObjectManager.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index a5895098a..b12c66d9b 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -9,7 +9,9 @@ ObjectManager::ObjectManager( void (*setProducer)() ):
 
 
 ObjectManager::~ObjectManager() {
-	// Map is STL object and deletes its own pointers.
+	for (auto const& iter : objectList) {
+		delete iter.second;
+	}
 }
 
 ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
@@ -99,7 +101,7 @@ void ObjectManager::initialize() {
 void ObjectManager::printList() {
 	std::map<object_id_t, SystemObjectIF*>::iterator it;
 	sif::debug << "ObjectManager: Object List contains:" << std::endl;
-	for (it = this->objectList.begin(); it != this->objectList.end(); it++) {
-		sif::debug << std::hex << it->first << " | " << it->second << std::endl;
+	for (auto const& it : objectList) {
+		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
 	}
 }

From dd193fd64d302e5592dfddc8a4395101d921b61b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 21:27:37 +0200
Subject: [PATCH 0368/1774] obj manager.cpp improvements

---
 objectmanager/ObjectManager.cpp | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index b12c66d9b..2f47950fa 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -65,10 +65,10 @@ void ObjectManager::initialize() {
 	this->produceObjects();
 	ReturnValue_t return_value = RETURN_FAILED;
 	uint32_t error_count = 0;
-	for (auto it = this->objectList.begin(); it != objectList.end(); it++ ) {
-		return_value = it->second->initialize();
+	for (auto const& it : objectList) {
+		return_value = it.second->initialize();
 		if ( return_value != RETURN_OK ) {
-			object_id_t var = it->first;
+			object_id_t var = it.first;
 			sif::error << "Object 0x" << std::hex <<  std::setw(8) <<
 					std::setfill('0')<< var << " failed to initialize " <<
 					"with code 0x" << return_value << std::dec << std::endl;
@@ -81,11 +81,10 @@ void ObjectManager::initialize() {
 	}
 	//Init was successful. Now check successful interconnections.
 	error_count = 0;
-	for (auto listIter = this->objectList.begin();
-			listIter != objectList.end(); listIter++ ) {
-		return_value = listIter->second->checkObjectConnections();
+	for (auto const& it : objectList) {
+		return_value = it.second->checkObjectConnections();
 		if ( return_value != RETURN_OK ) {
-			sif::error << "Object " << std::hex <<  (int) listIter->first
+			sif::error << "Object " << std::hex <<  (int) it.first
 			        << " connection check failed with code 0x" << return_value
 			        << std::dec << std::endl;
 			error_count++;

From 904721cc3638ffac5a1c4758e84395726d2a415b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 13:44:11 +0200
Subject: [PATCH 0369/1774] improved pool entry iF

---
 datapool/PoolEntry.cpp |  38 ++++++++------
 datapool/PoolEntry.h   | 115 ++++++++++++++++++++++++++---------------
 datapool/PoolEntryIF.h |  32 ++++++------
 3 files changed, 110 insertions(+), 75 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index d07c516da..a87a6c4e2 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,30 +1,37 @@
 #include <framework/datapool/PoolEntry.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/globalfunctions/printer.h>
+#include <cstring>
 
 template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t set_length,
-		uint8_t set_valid ) : length(set_length), valid(set_valid) {
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
+		bool setValid ) : length(setLength), valid(setValid) {
 	this->address = new T[this->length];
 	if(initValue.size() == 0) {
-		memset(this->address, 0, this->getByteSize());
+		std::memset(this->address, 0, this->getByteSize());
+	}
+	else if (initValue.size() != setLength){
+		sif::warning << "PoolEntry: setLength is not equal to initializer list"
+				"length! Performing zero initialization with given setLength"
+				<< std::endl;
+		std::memset(this->address, 0, this->getByteSize());
 	}
 	else {
-		memcpy(this->address, initValue.begin(), this->getByteSize());
+		std::copy(initValue.begin(), initValue.end(), this->address);
 	}
 }
 
 template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t set_length, uint8_t set_valid ) :
-		length(set_length), valid(set_valid) {
+PoolEntry<T>::PoolEntry( T* initValue, uint8_t setLength, bool setValid ) :
+		length(setLength), valid(setValid) {
 	this->address = new T[this->length];
-	if (initValue != NULL) {
-		memcpy(this->address, initValue, this->getByteSize() );
+	if (initValue != nullptr) {
+		std::memcpy(this->address, initValue, this->getByteSize() );
 	} else {
-		memset(this->address, 0, this->getByteSize() );
+		std::memset(this->address, 0, this->getByteSize() );
 	}
 }
 
-
 //As the data pool is global, this dtor is only be called on program exit.
 //Warning! Never copy pool entries!
 template <typename T>
@@ -48,21 +55,20 @@ void* PoolEntry<T>::getRawData() {
 }
 
 template <typename T>
-void PoolEntry<T>::setValid( uint8_t isValid ) {
+void PoolEntry<T>::setValid(bool isValid) {
 	this->valid = isValid;
 }
 
 template <typename T>
-uint8_t PoolEntry<T>::getValid() {
+bool PoolEntry<T>::getValid() {
 	return valid;
 }
 
 template <typename T>
 void PoolEntry<T>::print() {
-	for (uint8_t size = 0; size < this->length; size++ ) {
-		sif::debug << "| " << std::hex << (double)this->address[size]
-		           << (this->valid? " (valid) " : " (invalid) ");
-	}
+	 sif::debug << "Pool Entry Validity: " <<
+			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
+	printer::print(reinterpret_cast<uint8_t*>(address), length);
 	sif::debug << std::dec << std::endl;
 }
 
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 4971ee455..1a22bb638 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -1,95 +1,126 @@
-#ifndef POOLENTRY_H_
-#define POOLENTRY_H_
-
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
+#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
 
 #include <framework/datapool/PoolEntryIF.h>
-#include <stddef.h>
-#include <cstring>
+
 #include <initializer_list>
 #include <type_traits>
+#include <cstddef>
+
 /**
  * @brief	This is a small helper class that defines a single data pool entry.
  * @details
  * The helper is used to store all information together with the data as a
- * single data pool entry.The content's type is defined by the template argument.
- * It is prepared for use with plain old data types, but may be extended to
- * complex types if necessary. It can be initialized with a certain value,
- * size and validity flag. It holds a pointer to the real data and offers
- * methods to access this data and to acquire additional information
- * (such as validity and array/byte size). It is NOT intended to be used
- * outside the DataPool class.
- * @author	Bastian Baetz
- * @ingroup data_pool
+ * single data pool entry. The content's type is defined by the template
+ * argument.
  *
+ * It is prepared for use with plain old data types, but may be
+ * extended to complex types if necessary. It can be initialized with a
+ * certain value, size and validity flag.
+ *
+ * It holds a pointer to the real data and offers methods to access this data
+ * and to acquire additional information (such as validity and array/byte size).
+ * It is NOT intended to be used outside DataPool implementations as it performs
+ * dynamic memory allocation.
+ *
+ * @ingroup data_pool
  */
 template <typename T>
 class PoolEntry : public PoolEntryIF {
 public:
 	static_assert(not std::is_same<T, bool>::value,
-			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
-			"Warum? Darum :-)");
+				"Do not use boolean for the PoolEntry type, use uint8_t "
+				"instead! The ECSS standard defines a boolean as a one bit "
+				"field. Therefore it is preferred to store a boolean as an "
+				"uint8_t");
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
 	 * 			potential init values are copied to that space.
-	 * @param initValue	Initializer list with values to initialize with
-	 * @param set_length	Defines the array length of this entry.
-	 * @param set_valid		Sets the initialization flag. It is invalid (0) by default.
+	 * @details
+	 * Not passing any arguments will initialize an non-array pool entry
+	 * (setLength = 1) with an initial invalid state.
+	 * Please note that if an initializer list is passed, the correct
+	 * corresponding length should be passed too, otherwise a zero
+	 * initialization will be performed with the given setLength.
+	 * @param initValue
+	 * Initializer list with values to initialize with, for example {0,0} to
+	 * initialize the two entries to zero.
+	 * @param setLength
+	 * Defines the array length of this entry. Should be equal to the
+	 * intializer list length.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
 	 */
-	PoolEntry( std::initializer_list<T> initValue = {}, uint8_t set_length = 1, uint8_t set_valid = 0 );
+	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
+			bool setValid = false);
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
 	 * 			potential init values are copied to that space.
-	 * @param initValue		A pointer to the single value or array that holds the init value.
-	 * 						With the default value (NULL), the entry is initalized with all 0.
-	 * @param set_length	Defines the array length of this entry.
-	 * @param set_valid		Sets the initialization flag. It is invalid (0) by default.
+	 * @param initValue
+	 * A pointer to the single value or array that holds the init value.
+	 * With the default value (nullptr), the entry is initalized with all 0.
+	 * @param setLength
+	 * Defines the array length of this entry.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
 	 */
-	PoolEntry( T* initValue = NULL, uint8_t set_length = 1, uint8_t set_valid = 0 );
+	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
+
+	//! Explicitely deleted copy ctor, copying is not allowed!
+	PoolEntry(const PoolEntry&) = delete;
+	//! Explicitely deleted copy assignment, copying is not allowed!
+	PoolEntry& operator=(const PoolEntry&) = delete;
 
 	/**
-	 * \brief	The allocated memory for the variable is freed in the destructor.
-	 * \details	As the data pool is global, this dtor is only called on program exit.
-	 * 			PoolEntries shall never be copied, as a copy might delete the variable on the heap.
+	 * @brief	The allocated memory for the variable is freed
+	 * 			in the destructor.
+	 * @details
+	 * As the data pool is global, this dtor is only called on program exit.
+	 * PoolEntries shall never be copied, as a copy might delete the variable
+	 * on the heap.
 	 */
 	~PoolEntry();
+
 	/**
-	 * \brief	This is the address pointing to the allocated memory.
+	 * @brief	This is the address pointing to the allocated memory.
 	 */
 	T* address;
 	/**
-	 * \brief	This attribute stores the length information.
+	 * @brief	This attribute stores the length information.
 	 */
 	uint8_t length;
 	/**
-	 * \brief	Here, the validity information for a variable is stored.
+	 * @brief	Here, the validity information for a variable is stored.
 	 * 			Every entry (single variable or vector) has one valid flag.
 	 */
 	uint8_t valid;
 	/**
-	 * \brief	getSize returns the array size of the entry.
-	 * \details	A single parameter has size 1.
+	 * @brief	getSize returns the array size of the entry.
+	 * @details	A single parameter has size 1.
 	 */
 	uint8_t getSize();
 	/**
-	 * \brief	This operation returns the size in bytes.
-	 * \details	The size is calculated by sizeof(type) * array_size.
+	 * @brief	This operation returns the size in bytes.
+	 * @details	The size is calculated by sizeof(type) * array_size.
 	 */
 	uint16_t getByteSize();
 	/**
-	 * \brief	This operation returns a the address pointer casted to void*.
+	 * @brief	This operation returns a the address pointer casted to void*.
 	 */
 	void* getRawData();
 	/**
-	 * \brief	This method allows to set the valid information of the pool entry.
+	 * @brief	This method allows to set the valid information
+	 * 			of the pool entry.
 	 */
-	void setValid( uint8_t isValid );
+	void setValid( bool isValid );
 	/**
-	 * \brief	This method allows to get the valid information of the pool entry.
+	 * @brief	This method allows to get the valid information
+	 * 			of the pool entry.
 	 */
-	uint8_t getValid();
+	bool getValid();
 	/**
-	 * \brief	This is a debug method that prints all values and the valid information to the screen.
-	 * 			It prints all array entries in a row.
+	 * @brief	This is a debug method that prints all values and the valid
+	 * 			information to the screen. It prints all array entries in a row.
 	 */
 	void print();
 
diff --git a/datapool/PoolEntryIF.h b/datapool/PoolEntryIF.h
index d24d553ae..a075436e2 100644
--- a/datapool/PoolEntryIF.h
+++ b/datapool/PoolEntryIF.h
@@ -1,5 +1,5 @@
-#ifndef POOLENTRYIF_H_
-#define POOLENTRYIF_H_
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
 
 #include <framework/globalfunctions/Type.h>
 #include <cstdint>
@@ -9,55 +9,53 @@
  * 			single data pool entry.
  * @details
  * The interface provides methods to determine the size and the validity
- * information of a value. It also defines a method to receive a pointer to
- * the raw data content. It is mainly used by DataPool itself, but also as a
+ * information of a value. It also defines a method to receive a pointer to the
+ * raw data content. It is mainly used by DataPool itself, but also as a
  * return pointer.
- * @author 	Bastian Baetz
+ *
+ * @author	Bastian Baetz
  * @ingroup data_pool
+ *
  */
 class PoolEntryIF {
 public:
 	/**
 	 * @brief	This is an empty virtual destructor,
-	 * 			as it is proposed for C++ interfaces.
+	 * 			as it is required for C++ interfaces.
 	 */
-	virtual ~PoolEntryIF() {}
-
+	virtual ~PoolEntryIF() {
+	}
 	/**
 	 * @brief	getSize returns the array size of the entry.
 	 * 			A single variable parameter has size 1.
 	 */
 	virtual uint8_t getSize() = 0;
-
 	/**
 	 * @brief	This operation returns the size in bytes, which is calculated by
 	 * 			sizeof(type) * array_size.
 	 */
 	virtual uint16_t getByteSize() = 0;
-
 	/**
 	 * @brief	This operation returns a the address pointer casted to void*.
 	 */
 	virtual void* getRawData() = 0;
-
 	/**
 	 * @brief	This method allows to set the valid information of the pool entry.
 	 */
-	virtual void setValid(uint8_t isValid) = 0;
-
+	virtual void setValid(bool isValid) = 0;
 	/**
 	 * @brief	This method allows to set the valid information of the pool entry.
 	 */
-	virtual uint8_t getValid() = 0;
-
+	virtual bool getValid() = 0;
 	/**
 	 * @brief	This is a debug method that prints all values and the valid
 	 * 			information to the screen. It prints all array entries in a row.
+	 * @details
+	 * Also displays whether the pool entry is valid or invalid.
 	 */
 	virtual void print() = 0;
-
 	/**
-	 * @brief 	Returns the type of the entry.
+	 * Returns the type of the entry.
 	 */
 	virtual Type getType() = 0;
 };

From dd210e99af8ece3866bc898ec3daa631d90b8d9d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 13:45:18 +0200
Subject: [PATCH 0370/1774] additional include which was missing

---
 datapoolglob/PoolRawAccess.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index cc04f9b92..b10ee04c8 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -3,6 +3,8 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
 
+#include <cstring>
+
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
 		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),

From d7036edb94e7d64626e3cacf3d205c2b9db143a9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 15:53:20 +0200
Subject: [PATCH 0371/1774] hotfix

---
 serialize/SerialBufferAdapter.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 3df2abe91..e13e7eb6c 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -82,7 +82,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 			}
 		}
 		//No Else If, go on with buffer
-		if (bufferLength >= *size) {
+		if (bufferLength <= *size) {
 			*size -= bufferLength;
 			memcpy(m_buffer, *buffer, bufferLength);
 			(*buffer) += bufferLength;

From abcd818f2f48f6805ca1bfadf9d9694078e6a963 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 16:44:31 +0200
Subject: [PATCH 0372/1774] printer renamed to arrayprinter

---
 globalfunctions/arrayprinter.cpp | 61 ++++++++++++++++++++++++++++++++
 globalfunctions/arrayprinter.h   | 20 +++++++++++
 2 files changed, 81 insertions(+)
 create mode 100644 globalfunctions/arrayprinter.cpp
 create mode 100644 globalfunctions/arrayprinter.h

diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
new file mode 100644
index 000000000..e8fce56c6
--- /dev/null
+++ b/globalfunctions/arrayprinter.cpp
@@ -0,0 +1,61 @@
+#include <framework/globalfunctions/arrayprinter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <bitset>
+
+void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
+		bool printInfo, size_t maxCharPerLine) {
+	if(printInfo) {
+		sif::info << "Printing data with size " << size << ": ";
+	}
+	sif::info << "[";
+	if(type == OutputType::HEX) {
+		arrayprinter::printHex(data, size, maxCharPerLine);
+	}
+	else if (type == OutputType::DEC) {
+		arrayprinter::printDec(data, size, maxCharPerLine);
+	}
+	else if(type == OutputType::BIN) {
+	    arrayprinter::printBin(data, size);
+	}
+}
+
+void arrayprinter::printHex(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::hex;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << "0x" << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
+		}
+
+	}
+	sif::info << std::dec;
+	sif::info << "]" << std::endl;
+}
+
+void arrayprinter::printDec(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::dec;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
+		}
+	}
+	sif::info << "]" << std::endl;
+}
+
+void arrayprinter::printBin(const uint8_t *data, size_t size) {
+    sif::info << "\n" << std::flush;
+    for(size_t i = 0; i < size; i++) {
+        sif::info << "Byte " << i + 1 << ": 0b"<<
+                std::bitset<8>(data[i]) << ",\n" << std::flush;
+    }
+    sif::info << "]" << std::endl;
+}
diff --git a/globalfunctions/arrayprinter.h b/globalfunctions/arrayprinter.h
new file mode 100644
index 000000000..e57d8e047
--- /dev/null
+++ b/globalfunctions/arrayprinter.h
@@ -0,0 +1,20 @@
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_ARRAYPRINTER_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_ARRAYPRINTER_H_
+#include <cstdint>
+#include <cstddef>
+
+enum class OutputType {
+	DEC,
+	HEX,
+	BIN
+};
+
+namespace arrayprinter {
+void print(const uint8_t* data, size_t size, OutputType type = OutputType::HEX,
+		bool printInfo = true, size_t maxCharPerLine = 12);
+void printHex(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printDec(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printBin(const uint8_t* data, size_t size);
+}
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_ARRAYPRINTER_H_ */

From 4ebd937fe036e5a9427f2bda8683bfca58d5207b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 16:47:46 +0200
Subject: [PATCH 0373/1774] deleted old printer file

---
 datapool/PoolEntry.cpp      |  4 +--
 globalfunctions/printer.cpp | 61 -------------------------------------
 globalfunctions/printer.h   | 21 -------------
 3 files changed, 2 insertions(+), 84 deletions(-)
 delete mode 100644 globalfunctions/printer.cpp
 delete mode 100644 globalfunctions/printer.h

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index a87a6c4e2..d535a72b6 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,6 +1,6 @@
 #include <framework/datapool/PoolEntry.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/globalfunctions/printer.h>
+#include <framework/globalfunctions/arrayprinter.h>
 #include <cstring>
 
 template <typename T>
@@ -68,7 +68,7 @@ template <typename T>
 void PoolEntry<T>::print() {
 	 sif::debug << "Pool Entry Validity: " <<
 			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
-	printer::print(reinterpret_cast<uint8_t*>(address), length);
+	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
 	sif::debug << std::dec << std::endl;
 }
 
diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
deleted file mode 100644
index a68a91ee2..000000000
--- a/globalfunctions/printer.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include <framework/globalfunctions/printer.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <bitset>
-
-void printer::print(const uint8_t *data, size_t size, OutputType type,
-		bool printInfo, size_t maxCharPerLine) {
-	if(printInfo) {
-		sif::info << "Printing data with size " << size << ": ";
-	}
-	sif::info << "[";
-	if(type == OutputType::HEX) {
-		printer::printHex(data, size, maxCharPerLine);
-	}
-	else if (type == OutputType::DEC) {
-		printer::printDec(data, size, maxCharPerLine);
-	}
-	else if(type == OutputType::BIN) {
-	    printer::printBin(data, size);
-	}
-}
-
-void printer::printHex(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-	sif::info << std::hex;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << "0x" << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-			}
-		}
-
-	}
-	sif::info << std::dec;
-	sif::info << "]" << std::endl;
-}
-
-void printer::printDec(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-	sif::info << std::dec;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-			}
-		}
-	}
-	sif::info << "]" << std::endl;
-}
-
-void printer::printBin(const uint8_t *data, size_t size) {
-    sif::info << "\n" << std::flush;
-    for(size_t i = 0; i < size; i++) {
-        sif::info << "Byte " << i + 1 << ": 0b"<<
-                std::bitset<8>(data[i]) << ",\n" << std::flush;
-    }
-    sif::info << "]" << std::endl;
-}
diff --git a/globalfunctions/printer.h b/globalfunctions/printer.h
deleted file mode 100644
index 33a382ecc..000000000
--- a/globalfunctions/printer.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_
-#include <cstdint>
-#include <cstddef>
-
-namespace printer {
-
-enum class OutputType {
-	DEC,
-	HEX,
-	BIN
-};
-
-void print(const uint8_t* data, size_t size, OutputType type = OutputType::HEX,
-		bool printInfo = true, size_t maxCharPerLine = 12);
-void printHex(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
-void printDec(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
-void printBin(const uint8_t* data, size_t size);
-}
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_ */

From dbeb04895b2d86731be07c4f6af7b1f7f09316fc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 17:55:03 +0200
Subject: [PATCH 0374/1774] added hosted OSAL

---
 framework.mk                   |   4 +-
 osal/host/Clock.cpp            | 227 ++++++++++++++++++++++++++++++++
 osal/host/MessageQueue.cpp     | 144 +++++++++++++++++++++
 osal/host/MessageQueue.h       | 230 +++++++++++++++++++++++++++++++++
 osal/host/Mutex.cpp            |  40 ++++++
 osal/host/Mutex.h              |  28 ++++
 osal/host/MutexFactory.cpp     |  28 ++++
 osal/host/PeriodicTask.cpp     | 176 +++++++++++++++++++++++++
 osal/host/PeriodicTask.h       | 122 +++++++++++++++++
 osal/host/QueueFactory.cpp     |  41 ++++++
 osal/host/QueueMapManager.cpp  |  46 +++++++
 osal/host/QueueMapManager.h    |  47 +++++++
 osal/host/SemaphoreFactory.cpp |  40 ++++++
 osal/host/TaskFactory.cpp      |  55 ++++++++
 14 files changed, 1227 insertions(+), 1 deletion(-)
 create mode 100644 osal/host/Clock.cpp
 create mode 100644 osal/host/MessageQueue.cpp
 create mode 100644 osal/host/MessageQueue.h
 create mode 100644 osal/host/Mutex.cpp
 create mode 100644 osal/host/Mutex.h
 create mode 100644 osal/host/MutexFactory.cpp
 create mode 100644 osal/host/PeriodicTask.cpp
 create mode 100644 osal/host/PeriodicTask.h
 create mode 100644 osal/host/QueueFactory.cpp
 create mode 100644 osal/host/QueueMapManager.cpp
 create mode 100644 osal/host/QueueMapManager.h
 create mode 100644 osal/host/SemaphoreFactory.cpp
 create mode 100644 osal/host/TaskFactory.cpp

diff --git a/framework.mk b/framework.mk
index f2107a4cf..2092c2fee 100644
--- a/framework.mk
+++ b/framework.mk
@@ -34,8 +34,10 @@ else ifeq ($(OS_FSFW),linux)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/linux/*.cpp)
 else ifeq ($(OS_FSFW),freeRTOS)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
+else ifeq ($(OS_FSFW),host)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
 else
-$(error invalid OS specified, valid OS are rtems, linux, freeRTOS)
+$(error invalid OS specified, valid OS are rtems, linux, freeRTOS, host)
 endif
 
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/parameters/*.cpp)
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
new file mode 100644
index 000000000..78bbc58a8
--- /dev/null
+++ b/osal/host/Clock.cpp
@@ -0,0 +1,227 @@
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/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::NO_TIMEOUT);
+	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::NO_TIMEOUT);
+	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;
+}
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
new file mode 100644
index 000000000..7d5e4d97a
--- /dev/null
+++ b/osal/host/MessageQueue.cpp
@@ -0,0 +1,144 @@
+#include <framework/osal/host/MessageQueue.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/osal/host/QueueMapManager.h>
+#include <framework/ipc/MutexFactory.h>
+#include <framework/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: Could not be created" << std::endl;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	MutexFactory::instance()->deleteMutex(queueLock);
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessage* 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,
+		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
+			ignoreFault);
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	if(status == HasReturnvaluesIF::RETURN_OK) {
+		*receivedFrom = this->lastPartner;
+	}
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+	if(messageQueue.empty()) {
+		return MessageQueueIF::EMPTY;
+	}
+	// not sure this will work..
+	//*message = std::move(messageQueue.front());
+	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,
+        MessageQueueMessage *message, MessageQueueId_t sentFrom,
+        bool ignoreFault) {
+	if(message->messageSize > MessageQueueMessage::MAX_DATA_SIZE) {
+		// 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, 20);
+		targetQueue->messageQueue.push(*message);
+	}
+	else {
+		return MessageQueueIF::FULL;
+	}
+    message->setSender(sentFrom);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MessageQueue::lockQueue(millis_t lockTimeout) {
+	return queueLock->lockMutex(lockTimeout);
+}
+
+ReturnValue_t MessageQueue::unlockQueue() {
+	return queueLock->unlockMutex();
+}
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
new file mode 100644
index 000000000..a0cce0017
--- /dev/null
+++ b/osal/host/MessageQueue.h
@@ -0,0 +1,230 @@
+#ifndef FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
+#define FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
+
+#include <framework/internalError/InternalErrorReporterIF.h>
+#include <framework/ipc/MessageQueueIF.h>
+#include <framework/ipc/MessageQueueMessage.h>
+#include <framework/ipc/MutexIF.h>
+#include <framework/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,
+			MessageQueueMessage* 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(MessageQueueMessage* 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(MessageQueueMessage* 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,
+			MessageQueueMessage* 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( MessageQueueMessage* 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(MessageQueueMessage* 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(MessageQueueMessage* 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(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,
+			MessageQueueMessage* 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_ */
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
new file mode 100644
index 000000000..0e6e652d7
--- /dev/null
+++ b/osal/host/Mutex.cpp
@@ -0,0 +1,40 @@
+#include <framework/osal/host/Mutex.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+const uint32_t MutexIF::NO_TIMEOUT = 0;
+const uint32_t MutexIF::MAX_TIMEOUT = 0xffffffff;
+
+ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+	if(timeoutMs == MutexIF::MAX_TIMEOUT) {
+		mutex.lock();
+		locked = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else if(timeoutMs == MutexIF::NO_TIMEOUT) {
+		if(mutex.try_lock()) {
+			locked = true;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+	else if(timeoutMs > MutexIF::NO_TIMEOUT){
+		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;
+}
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
new file mode 100644
index 000000000..dce2a9dc3
--- /dev/null
+++ b/osal/host/Mutex.h
@@ -0,0 +1,28 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
+#define FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
+
+#include <framework/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() = default;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::MAX_TIMEOUT) override;
+	ReturnValue_t unlockMutex() override;
+
+	std::timed_mutex* getMutexHandle();
+private:
+	bool locked = false;
+	std::timed_mutex mutex;
+};
+
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/osal/host/MutexFactory.cpp b/osal/host/MutexFactory.cpp
new file mode 100644
index 000000000..25d9fa467
--- /dev/null
+++ b/osal/host/MutexFactory.cpp
@@ -0,0 +1,28 @@
+#include <framework/ipc/MutexFactory.h>
+#include <framework/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;
+}
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
new file mode 100644
index 000000000..57898ac2c
--- /dev/null
+++ b/osal/host/PeriodicTask.cpp
@@ -0,0 +1,176 @@
+#include <framework/ipc/MutexFactory.h>
+#include <framework/osal/host/Mutex.h>
+#include <framework/osal/host/PeriodicTask.h>
+
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/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 delayUntil(&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::delayUntil(std::chrono::milliseconds * previousWakeTimeMs,
+        const std::chrono::milliseconds 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;
+
+}
diff --git a/osal/host/PeriodicTask.h b/osal/host/PeriodicTask.h
new file mode 100644
index 000000000..19c06b52c
--- /dev/null
+++ b/osal/host/PeriodicTask.h
@@ -0,0 +1,122 @@
+#ifndef FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
+#define FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
+
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/tasks/PeriodicTaskIF.h>
+#include <framework/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:
+	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 delayUntil(std::chrono::milliseconds * previousWakeTimeMs,
+	        const std::chrono::milliseconds interval);
+};
+
+#endif /* PERIODICTASK_H_ */
diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
new file mode 100644
index 000000000..691249c3f
--- /dev/null
+++ b/osal/host/QueueFactory.cpp
@@ -0,0 +1,41 @@
+#include <framework/ipc/QueueFactory.h>
+#include <framework/osal/host/MessageQueue.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <cstring>
+
+QueueFactory* QueueFactory::factoryInstance = nullptr;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessage* 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(size_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;
+}
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
new file mode 100644
index 000000000..a57d2c0c0
--- /dev/null
+++ b/osal/host/QueueMapManager.cpp
@@ -0,0 +1,46 @@
+#include <framework/ipc/MutexFactory.h>
+#include <framework/ipc/MutexHelper.h>
+#include <framework/osal/host/QueueMapManager.h>
+
+QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
+
+QueueMapManager::QueueMapManager() {}
+
+QueueMapManager* QueueMapManager::instance() {
+	if (mqManagerInstance == nullptr){
+		mqManagerInstance = new QueueMapManager();
+	}
+	return QueueMapManager::mqManagerInstance;
+}
+
+ReturnValue_t QueueMapManager::addMessageQueue(
+		MessageQueueIF* queueToInsert, MessageQueueId_t* id) {
+	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;
+	}
+	mapLock = MutexFactory::instance()->createMutex();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueIF* QueueMapManager::getMessageQueue(
+		MessageQueueId_t messageQueueId) const {
+	MutexHelper(mapLock, 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;
+	}
+}
+
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
new file mode 100644
index 000000000..34f0fc957
--- /dev/null
+++ b/osal/host/QueueMapManager.h
@@ -0,0 +1,47 @@
+#ifndef FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
+#define FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
+
+#include <framework/ipc/MessageQueueSenderIF.h>
+#include <framework/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();
+	std::atomic<uint32_t> queueCounter = MessageQueueIF::NO_QUEUE + 1;
+	MutexIF* mapLock;
+	QueueMap queueMap;
+	static QueueMapManager* mqManagerInstance;
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_HOST_QUEUEMAP_H_ */
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
new file mode 100644
index 000000000..3719a8833
--- /dev/null
+++ b/osal/host/SemaphoreFactory.cpp
@@ -0,0 +1,40 @@
+#include <framework/tasks/SemaphoreFactory.h>
+#include <framework/osal/linux/BinarySemaphore.h>
+#include <framework/osal/linux/CountingSemaphore.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
+const uint32_t SemaphoreIF::MAX_TIMEOUT = 0xFFFFFFFF;
+
+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) {
+	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) {
+	sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
+				" Returning nullptr!\n" << std::flush;
+	return nullptr;
+}
+
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
+	delete semaphore;
+}
diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
new file mode 100644
index 000000000..a13844c4a
--- /dev/null
+++ b/osal/host/TaskFactory.cpp
@@ -0,0 +1,55 @@
+#include <framework/osal/host/PeriodicTask.h>
+#include <framework/tasks/TaskFactory.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/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_) {
+	// This is going to be interesting. Time now learn the C++ threading library
+	// :-)
+	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
+			deadLineMissedFunction_);
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	// This is going to be interesting. Time now learn the C++ threading library
+	// :-)
+	sif::warning << "TaskFactory::createFixedTimeslotTask: Not implemented "
+			"yet" << std::endl;
+	return nullptr;
+}
+
+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;
+}
+
+

From ef3e5c4582df70896758e775bed5383b7c415689 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 18:20:21 +0200
Subject: [PATCH 0375/1774] very important bugfix for serial buffer adapter

---
 serialize/SerialBufferAdapter.cpp | 39 ++++++++++++-------------------
 serialize/SerialBufferAdapter.h   |  9 +++----
 2 files changed, 20 insertions(+), 28 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index e13e7eb6c..db91a93fd 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -3,22 +3,17 @@
 #include <cstring>
 
 template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer,
+SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
 		count_t bufferLength, bool serializeLength) :
 		serializeLength(serializeLength),
-		constBuffer(static_cast<const uint8_t *>(buffer)), m_buffer(nullptr),
-		bufferLength(bufferLength) {
-
-}
+		constBuffer(buffer), buffer(nullptr),
+		bufferLength(bufferLength) {}
 
 template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer,
+SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
 		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), bufferLength(bufferLength) {
-	uint8_t * member_buffer = static_cast<uint8_t *>(buffer);
-	m_buffer = member_buffer;
-	constBuffer = member_buffer;
-}
+		serializeLength(serializeLength), buffer(buffer), constBuffer(buffer),
+		bufferLength(bufferLength) {}
 
 
 template<typename count_t>
@@ -42,8 +37,8 @@ ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
 		}
 		if (constBuffer != nullptr) {
 			memcpy(*buffer, constBuffer, bufferLength);
-		} else if (m_buffer != nullptr) {
-			memcpy(*buffer, m_buffer, bufferLength);
+		} else if (buffer != nullptr) {
+			memcpy(*buffer, buffer, bufferLength);
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
@@ -66,14 +61,11 @@ template<typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		size_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
-	// (Robin) the one of the buffer? wouldn't that be an issue for serialize
-	// as well? SerialFixedArrayListAdapter implements swapping of buffer
-	// fields (if buffer type is not uint8_t)
 	if (buffer != nullptr) {
 		if(serializeLength) {
 			count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
 					&bufferLength);
-			if(bufferLength + serializedSize >= *size) {
+			if(bufferLength + serializedSize <= *size) {
 				*buffer +=  serializedSize;
 				*size -= serializedSize;
 			}
@@ -84,7 +76,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		//No Else If, go on with buffer
 		if (bufferLength <= *size) {
 			*size -= bufferLength;
-			memcpy(m_buffer, *buffer, bufferLength);
+			memcpy(buffer, *buffer, bufferLength);
 			(*buffer) += bufferLength;
 			return HasReturnvaluesIF::RETURN_OK;
 		}
@@ -99,28 +91,27 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 
 template<typename count_t>
 uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
-	if(m_buffer == nullptr) {
+	if(buffer == nullptr) {
 		sif::error << "Wrong access function for stored type !"
 				 " Use getConstBuffer()" << std::endl;
 		return nullptr;
 	}
-	return m_buffer;
+	return buffer;
 }
 
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
-		sif::error << "Wrong access function for stored type !"
-				 " Use getBuffer()" << std::endl;
+		sif::error << "SerialBufferAdapter: Buffers are unitialized!" << std::endl;
 		return nullptr;
 	}
 	return constBuffer;
 }
 
 template<typename count_t>
-void SerialBufferAdapter<count_t>::setBuffer(void * buffer,
+void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
 		count_t buffer_length) {
-	m_buffer = static_cast<uint8_t *>(buffer);
+	this->buffer = buffer;
 	bufferLength = buffer_length;
 }
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index d414573cb..cb799be5e 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -29,7 +29,7 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter(const void* buffer, count_t bufferLength,
+	SerialBufferAdapter(const uint8_t* buffer, count_t bufferLength,
 			bool serializeLength = false);
 
 	/**
@@ -40,7 +40,8 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength Length field will be serialized with size count_t
 	 */
-	SerialBufferAdapter(void* buffer, count_t bufferLength, bool serializeLength = false);
+	SerialBufferAdapter(uint8_t* buffer, count_t bufferLength,
+			bool serializeLength = false);
 
 	virtual ~SerialBufferAdapter();
 
@@ -66,11 +67,11 @@ public:
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
-	void setBuffer(void* buffer_, count_t bufferLength_);
+	void setBuffer(uint8_t* buffer_, count_t bufferLength_);
 private:
 	bool serializeLength = false;
 	const uint8_t *constBuffer = nullptr;
-	uint8_t *m_buffer = nullptr;
+	uint8_t *buffer = nullptr;
 	count_t bufferLength = 0;
 };
 

From 872c350a9296999af94ad2c275fd2bf34abec1b0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 18:36:22 +0200
Subject: [PATCH 0376/1774] another small bugfix (this-> was missing)

---
 serialize/SerialBufferAdapter.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index db91a93fd..ad4ec358b 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -76,7 +76,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		//No Else If, go on with buffer
 		if (bufferLength <= *size) {
 			*size -= bufferLength;
-			memcpy(buffer, *buffer, bufferLength);
+			memcpy(this->buffer, *buffer, bufferLength);
 			(*buffer) += bufferLength;
 			return HasReturnvaluesIF::RETURN_OK;
 		}

From 8d3ac33b0ef0b22e35dc102f9d715878780d50df Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:18:38 +0200
Subject: [PATCH 0377/1774] reordering init list for compiler

---
 serialize/SerialBufferAdapter.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index ad4ec358b..e409686f4 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -12,7 +12,7 @@ SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
 template<typename count_t>
 SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
 		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), buffer(buffer), constBuffer(buffer),
+		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
 		bufferLength(bufferLength) {}
 
 

From 9fd5ef0194ebad3e2fe1bfc90b705fe7438ac29b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:28:06 +0200
Subject: [PATCH 0378/1774] updated datapool files

---
 datapool/DataSetBase.cpp  | 65 ++++++++++++++++++++++-----------------
 datapool/DataSetBase.h    | 48 ++++++++++++++++++-----------
 datapool/DataSetIF.h      |  8 +++--
 datapool/PoolVariableIF.h | 52 +++++++++++++++++++++++--------
 4 files changed, 112 insertions(+), 61 deletions(-)

diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
index 6ff2fc83f..9104c8e71 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -31,20 +31,14 @@ ReturnValue_t DataSetBase::registerVariable(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t DataSetBase::read() {
+ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	if (state == States::DATA_SET_UNINITIALISED) {
-		lockDataPool();
+		lockDataPool(lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					!= PoolVariableIF::VAR_WRITE
-					&& registeredVariables[count]->getDataPoolId()
-					!= PoolVariableIF::NO_PARAMETER) {
-				ReturnValue_t status = registeredVariables[count]->read();
-				if (status !=  HasReturnvaluesIF::RETURN_OK) {
-					result = INVALID_PARAMETER_DEFINITION;
-					break;
-				}
+			ReturnValue_t result = readVariable(count);
+			if(result != RETURN_OK) {
+				break;
 			}
 		}
 		state = States::DATA_SET_WAS_READ;
@@ -58,47 +52,53 @@ ReturnValue_t DataSetBase::read() {
 	return result;
 }
 
-ReturnValue_t DataSetBase::commit() {
+ReturnValue_t DataSetBase::readVariable(uint16_t count) {
+	ReturnValue_t result = DataSetIF::INVALID_PARAMETER_DEFINITION;
+	// These checks are often performed by the respective
+	// variable implementation too, but I guess a double check does not hurt.
+	if (registeredVariables[count]->getReadWriteMode() !=
+				PoolVariableIF::VAR_WRITE and
+		registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER)
+	{
+		result = registeredVariables[count]->readWithoutLock();
+	}
+	return result;
+}
+
+ReturnValue_t DataSetBase::commit(uint32_t lockTimeout) {
 	if (state == States::DATA_SET_WAS_READ) {
-		handleAlreadyReadDatasetCommit();
+		handleAlreadyReadDatasetCommit(lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-		return handleUnreadDatasetCommit();
+		return handleUnreadDatasetCommit(lockTimeout);
 	}
 }
 
-ReturnValue_t DataSetBase::lockDataPool() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataSetBase::unlockDataPool() {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-void DataSetBase::handleAlreadyReadDatasetCommit() {
-	lockDataPool();
+void DataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
+	lockDataPool(lockTimeout);
 	for (uint16_t count = 0; count < fillCount; count++) {
 		if (registeredVariables[count]->getReadWriteMode()
 				!= PoolVariableIF::VAR_READ
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commit();
+			registeredVariables[count]->commitWithoutLock();
 		}
 	}
 	state = States::DATA_SET_UNINITIALISED;
 	unlockDataPool();
 }
 
-ReturnValue_t DataSetBase::handleUnreadDatasetCommit() {
+ReturnValue_t DataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	lockDataPool();
+	lockDataPool(lockTimeout);
 	for (uint16_t count = 0; count < fillCount; count++) {
 		if (registeredVariables[count]->getReadWriteMode()
 				== PoolVariableIF::VAR_WRITE
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commit();
+			registeredVariables[count]->commitWithoutLock();
 		} else if (registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if (result != COMMITING_WITHOUT_READING) {
@@ -113,6 +113,15 @@ ReturnValue_t DataSetBase::handleUnreadDatasetCommit() {
 	return result;
 }
 
+
+ReturnValue_t DataSetBase::lockDataPool(uint32_t timeoutMs) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataSetBase::unlockDataPool() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
 		const size_t maxSize, bool bigEndian) const {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
index 6b468c118..8bf9a99a3 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -2,6 +2,7 @@
 #define FRAMEWORK_DATAPOOL_DATASETBASE_H_
 #include <framework/datapool/DataSetIF.h>
 #include <framework/datapool/PoolVariableIF.h>
+#include <framework/ipc/MutexIF.h>
 
 /**
  * @brief	The DataSetBase class manages a set of locally checked out variables.
@@ -21,7 +22,8 @@
  * of the set, the DataSet class automatically sets the valid flag in the
  * data pool to invalid (without) changing the variable's value.
  *
- * The base class lockDataPo
+ * The base class lockDataPool und unlockDataPool implementation are empty
+ * and should be implemented to protect the underlying pool type.
  * @author	Bastian Baetz
  * @ingroup data_pool
  */
@@ -49,14 +51,15 @@ public:
 	 *
 	 * The data pool is locked during the whole read operation and
 	 * freed afterwards.The state changes to "was written" after this operation.
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
-	 * 					requested variable is invalid.
-	 * 			- @c SET_WAS_ALREADY_READ if read() is called twice without calling
-	 * 					commit() in between
+	 * @return
+	 * - @c RETURN_OK if all variables were read successfully.
+	 * - @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
+	 * requested variable is invalid.
+	 * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
+	 * commit() in between
 	 */
-	virtual ReturnValue_t read();
-
+	virtual ReturnValue_t read(uint32_t lockTimeout =
+			MutexIF::BLOCKING) override;
 	/**
 	 * @brief	The commit call initializes writing back the registered variables.
 	 * @details
@@ -67,23 +70,30 @@ public:
 	 * The data pool is locked during the whole commit operation and
 	 * freed afterwards. The state changes to "was committed" after this operation.
 	 *
-	 * If the set does contain at least one variable which is not write-only commit()
-	 * can only be called after read(). If the set only contains variables which are
-	 * write only, commit() can be called without a preceding read() call.
+	 * If the set does contain at least one variable which is not write-only
+	 * commit() can only be called after read(). If the set only contains
+	 * variables which are write only, commit() can be called without a
+	 * preceding read() call.
 	 * @return	- @c RETURN_OK if all variables were read successfully.
 	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
 	 * 			  contains non write-only variables
 	 */
-	virtual ReturnValue_t commit();
+	virtual ReturnValue_t commit(uint32_t lockTimeout =
+			MutexIF::BLOCKING) override;
 
-	/* DataSetIF implementation */
+	/**
+	 * Register the passed pool variable instance into the data set.
+	 * @param variable
+	 * @return
+	 */
 	virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override;
 	/**
 	 * Provides the means to lock the underlying data structure to ensure
 	 * thread-safety. Default implementation is empty
 	 * @return Always returns -@c RETURN_OK
 	 */
-	virtual ReturnValue_t lockDataPool() override;
+	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs =
+			MutexIF::BLOCKING) override;
 	/**
 	 * Provides the means to unlock the underlying data structure to ensure
 	 * thread-safety. Default implementation is empty
@@ -98,12 +108,12 @@ public:
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) override;
 
-	//SHOULDDO we could use a linked list of datapool variables
+	// SHOULDDO we could use a linked list of datapool variables
 	//!< This definition sets the maximum number of variables to
 	//! register in one DataSet.
 	static const uint8_t DATA_SET_MAX_SIZE = 63;
-protected:
 
+protected:
 	/**
 	 * @brief	The fill_count attribute ensures that the variables
 	 * 			register in the correct array position and that the maximum
@@ -128,8 +138,10 @@ protected:
 	 */
 	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE] = { };
 
-	void handleAlreadyReadDatasetCommit();
-	ReturnValue_t handleUnreadDatasetCommit();
+private:
+	ReturnValue_t readVariable(uint16_t count);
+	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
+	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
 };
 
 #endif /* FRAMEWORK_DATAPOOL_DATASETBASE_H_ */
diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index d9cc49669..9c5b13c81 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -2,6 +2,7 @@
 #define DATASETIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/timemanager/Clock.h>
 class PoolVariableIF;
 
 /**
@@ -33,20 +34,23 @@ public:
 	 */
 	virtual ~DataSetIF() {}
 
+	virtual ReturnValue_t read(uint32_t lockTimeout) = 0;
+	virtual ReturnValue_t commit(uint32_t lockTimeout) = 0;
 	/**
 	 * @brief	This operation provides a method to register local data pool
 	 * 			variables to register in a data set by passing itself
 	 * 			to this DataSet operation.
 	 */
-	virtual ReturnValue_t registerVariable( PoolVariableIF* variable ) = 0;
+	virtual ReturnValue_t registerVariable(PoolVariableIF* variable) = 0;
 
+private:
 	/**
 	 * @brief 	Most underlying data structures will have a pool like structure
 	 * 			and will require a lock and unlock mechanism to ensure
 	 * 			thread-safety
 	 * @return Lock operation result
 	 */
-	virtual ReturnValue_t lockDataPool() = 0;
+	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs) = 0;
 	/**
 	 * @brief   Unlock call corresponding to the lock call.
 	 * @return Unlock operation result
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 0cbc18c5f..3086bbe8e 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -21,18 +21,10 @@ class PoolVariableIF : public SerializeIF {
 	friend class DataSetBase;
 	friend class GlobDataSet;
 	friend class LocalDataSet;
-protected:
-	/**
-	 * @brief	The commit call shall write back a newly calculated local
-	 * 			value to the data pool.
-	 */
-	virtual ReturnValue_t commit() = 0;
-	/**
-	 * @brief	The read call shall read the value of this parameter from
-	 * 			the data pool and store the content locally.
-	 */
-	virtual ReturnValue_t read() = 0;
 public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
+	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
+
 	static constexpr bool VALID = 1;
 	static constexpr bool INVALID = 0;
 	static constexpr uint32_t NO_PARAMETER = 0;
@@ -61,9 +53,43 @@ public:
 	/**
 	 * @brief	With this call, the valid information of the variable is set.
 	 */
-	// why not just use a boolean here?
-	virtual void setValid(uint8_t validity) = 0;
+	virtual void setValid(bool validity) = 0;
 
+	/**
+	 * @brief	The commit call shall write back a newly calculated local
+	 * 			value to the data pool.
+	 * @details
+	 * It is assumed that these calls are implemented in a thread-safe manner!
+	 */
+	virtual ReturnValue_t commit(uint32_t lockTimeout) = 0;
+	/**
+	 * @brief	The read call shall read the value of this parameter from
+	 * 			the data pool and store the content locally.
+	 * @details
+	 * It is assumbed that these calls are implemented in a thread-safe manner!
+	 */
+	virtual ReturnValue_t read(uint32_t lockTimeout) = 0;
+
+protected:
+
+	/**
+	 * @brief 	Same as commit with the difference that comitting will be
+	 * 			performed without a lock
+	 * @return
+	 * This can be used if the lock protection is handled externally
+	 * to avoid the overhead of locking and unlocking consecutively.
+	 * Declared protected to avoid free public usage.
+	 */
+	virtual ReturnValue_t readWithoutLock() = 0;
+	/**
+	 * @brief 	Same as commit with the difference that comitting will be
+	 * 			performed without a lock
+	 * @return
+	 * This can be used if the lock protection is handled externally
+	 * to avoid the overhead of locking and unlocking consecutively.
+	 * Declared protected to avoid free public usage.
+	 */
+	virtual ReturnValue_t commitWithoutLock() = 0;
 };
 
 using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;

From e04e6a6f1506ca90498803bbce49e854e5ed5d4b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:33:57 +0200
Subject: [PATCH 0379/1774] datapoolglob update

---
 datapoolglob/GlobalDataPool.cpp     | 10 ++---
 datapoolglob/GlobalDataPool.h       |  4 +-
 datapoolglob/GlobalDataSet.cpp      | 14 +++----
 datapoolglob/GlobalDataSet.h        |  7 ++--
 datapoolglob/GlobalPoolVariable.h   | 64 +++++++++++++++++++----------
 datapoolglob/GlobalPoolVariable.tpp | 36 ++++++++++++++--
 datapoolglob/GlobalPoolVector.h     | 40 ++++++++++++++----
 datapoolglob/GlobalPoolVector.tpp   | 36 +++++++++++++++-
 datapoolglob/PIDReader.h            | 24 +++++++++--
 datapoolglob/PoolRawAccess.cpp      | 34 +++++++++++++--
 datapoolglob/PoolRawAccess.h        | 48 +++++++++++++++-------
 11 files changed, 244 insertions(+), 73 deletions(-)

diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
index 187809048..25acaab3f 100644
--- a/datapoolglob/GlobalDataPool.cpp
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -44,18 +44,18 @@ PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
 	}
 }
 
-ReturnValue_t GlobalDataPool::freeDataPoolLock() {
+ReturnValue_t GlobalDataPool::unlockDataPool() {
 	ReturnValue_t status = mutex->unlockMutex();
-	if ( status != RETURN_OK ) {
+	if(status != RETURN_OK) {
 		sif::error << "DataPool::DataPool: unlock of mutex failed with"
 				" error code: " << status << std::endl;
 	}
 	return status;
 }
 
-ReturnValue_t GlobalDataPool::lockDataPool() {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::BLOCKING);
-	if ( status != RETURN_OK ) {
+ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
+	ReturnValue_t status = mutex->lockMutex(timeoutMs);
+	if(status != RETURN_OK) {
 		sif::error << "DataPool::DataPool: lock of mutex failed "
 				"with error code: " << status << std::endl;
 	}
diff --git a/datapoolglob/GlobalDataPool.h b/datapoolglob/GlobalDataPool.h
index 42921a777..b9c1436fb 100644
--- a/datapoolglob/GlobalDataPool.h
+++ b/datapoolglob/GlobalDataPool.h
@@ -95,12 +95,12 @@ public:
 	 * @brief	This is a small helper function to facilitate locking the global data pool.
 	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
 	 */
-	ReturnValue_t lockDataPool();
+	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
 	/**
 	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
 	 * @details	It fetches the pool's mutex id and tries to free the mutex.
 	 */
-	ReturnValue_t freeDataPoolLock();
+	ReturnValue_t unlockDataPool();
 	/**
 	 * @brief	The print call is a simple debug method.
 	 * @details	It prints the current content of the data pool.
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
index 503d068e5..9da8d524e 100644
--- a/datapoolglob/GlobalDataSet.cpp
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -8,22 +8,22 @@ GlobDataSet::GlobDataSet(): DataSetBase() {}
 // (Destructor is already called)
 GlobDataSet::~GlobDataSet() {}
 
-ReturnValue_t GlobDataSet::commit(bool valid) {
+ReturnValue_t GlobDataSet::commit(bool valid, uint32_t lockTimeout) {
 	setEntriesValid(valid);
 	setSetValid(valid);
-	return commit();
+	return commit(lockTimeout);
 }
 
-ReturnValue_t GlobDataSet::commit() {
-	return DataSetBase::commit();
+ReturnValue_t GlobDataSet::commit(uint32_t lockTimeout) {
+	return DataSetBase::commit(lockTimeout);
 }
 
 ReturnValue_t GlobDataSet::unlockDataPool() {
-	return glob::dataPool.freeDataPoolLock();
+	return glob::dataPool.unlockDataPool();
 }
 
-ReturnValue_t GlobDataSet::lockDataPool() {
-	return glob::dataPool.lockDataPool();
+ReturnValue_t GlobDataSet::lockDataPool(uint32_t timeoutMs) {
+	return glob::dataPool.lockDataPool(timeoutMs);
 }
 
 void GlobDataSet::setEntriesValid(bool valid) {
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index c2e0b577d..f0bf7daa8 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -44,8 +44,8 @@ public:
 	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
 	 * 			     contains non write-only variables
 	 */
-	ReturnValue_t commit(bool valid);
-	ReturnValue_t commit() override;
+	ReturnValue_t commit(bool valid, uint32_t lockTimeout = MutexIF::BLOCKING);
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
 
 	/**
 	 * Set all entries
@@ -74,8 +74,7 @@ private:
 	 * @details
 	 * It makes use of the lockDataPool method offered by the DataPool class.
 	 */
-	ReturnValue_t lockDataPool() override;
-
+	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
 	/**
 	 * @brief	This is a small helper function to facilitate
 	 * 			unlocking the global data pool
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index eb44c3072..9e3eea0c9 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -72,7 +72,49 @@ public:
 	 */
 	~GlobPoolVar() {}
 
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout) override;
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * The commit call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout) override;
+
 protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
 	/**
 	 * @brief	To access the correct data pool entry on read and commit calls,
 	 * 			the data pool is stored.
@@ -91,26 +133,6 @@ protected:
 	 */
 	pool_rwm_t readWriteMode;
 
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read() override;
-
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit() override;
-
 	/**
 	 * Empty ctor for List initialization
 	 */
@@ -138,7 +160,7 @@ public:
 
 	uint8_t getValid();
 
-	void setValid(uint8_t valid);
+	void setValid(bool valid) override;
 
 	operator T() {
 		return value;
diff --git a/datapoolglob/GlobalPoolVariable.tpp b/datapoolglob/GlobalPoolVariable.tpp
index d55ea4e02..d61d605d7 100644
--- a/datapoolglob/GlobalPoolVariable.tpp
+++ b/datapoolglob/GlobalPoolVariable.tpp
@@ -12,8 +12,38 @@ inline GlobPoolVar<T>::GlobPoolVar(uint32_t set_id,
 	}
 }
 
+template<typename T>
+inline ReturnValue_t GlobPoolVar<T>::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+template<typename T>
+inline ReturnValue_t GlobPoolVar<T>::commit(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
 template <class T>
-inline ReturnValue_t GlobPoolVar<T>::read() {
+inline ReturnValue_t GlobPoolVar<T>::readWithoutLock() {
 	PoolEntry<T>* read_out = glob::dataPool.getData<T>(dataPoolId, 1);
 	if (read_out != NULL) {
 		valid = read_out->valid;
@@ -29,7 +59,7 @@ inline ReturnValue_t GlobPoolVar<T>::read() {
 }
 
 template <class T>
-inline ReturnValue_t GlobPoolVar<T>::commit() {
+inline ReturnValue_t GlobPoolVar<T>::commitWithoutLock() {
 	PoolEntry<T>* write_back = glob::dataPool.getData<T>(dataPoolId, 1);
 	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
 		write_back->valid = valid;
@@ -80,7 +110,7 @@ inline uint8_t GlobPoolVar<T>::getValid() {
 }
 
 template <class T>
-inline void GlobPoolVar<T>::setValid(uint8_t valid) {
+inline void GlobPoolVar<T>::setValid(bool valid) {
 	this->valid = valid;
 }
 
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 24303457e..930922281 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -102,7 +102,7 @@ public:
 		else
 			return false;
 	}
-	void setValid(uint8_t valid) {this->valid = valid;}
+	void setValid(bool valid) {this->valid = valid;}
 	uint8_t getValid() {return valid;}
 
 	T &operator [](int i) {return value[i];}
@@ -113,7 +113,7 @@ public:
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) override;
-protected:
+
 	/**
 	 * @brief	This is a call to read the array's values
 	 * 			from the global data pool.
@@ -122,19 +122,43 @@ protected:
 	 * data pool id from the global data pool and copies all array values
 	 * and the valid information to its local attributes.
 	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid. The operation does NOT provide
-	 * any mutual exclusive protection by itself.
+	 * variable is set to zero and invalid.
+	 * The read call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t read();
-
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
 	 * It checks type and size, as well as if the variable is writable. If so,
 	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * The commit call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t commit();
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
 private:
 	/**
 	 * @brief	To access the correct data pool entry on read and commit calls,
diff --git a/datapoolglob/GlobalPoolVector.tpp b/datapoolglob/GlobalPoolVector.tpp
index 0b43191bd..5710da574 100644
--- a/datapoolglob/GlobalPoolVector.tpp
+++ b/datapoolglob/GlobalPoolVector.tpp
@@ -12,8 +12,40 @@ inline GlobPoolVector<T, vectorSize>::GlobPoolVector(uint32_t set_id,
 	}
 }
 
+
 template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::read() {
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::commit(
+		uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::readWithoutLock() {
 	PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
 			vectorSize);
 	if (read_out != nullptr) {
@@ -33,7 +65,7 @@ inline ReturnValue_t GlobPoolVector<T, vectorSize>::read() {
 }
 
 template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::commit() {
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::commitWithoutLock() {
 	PoolEntry<T>* writeBack = glob::dataPool.getData<T>(this->dataPoolId,
 			vectorSize);
 	if ((writeBack != nullptr) && (this->readWriteMode != VAR_READ)) {
diff --git a/datapoolglob/PIDReader.h b/datapoolglob/PIDReader.h
index 112066115..359b871f5 100644
--- a/datapoolglob/PIDReader.h
+++ b/datapoolglob/PIDReader.h
@@ -15,7 +15,8 @@ class PIDReader: public PoolVariableIF {
 protected:
 	uint32_t parameterId;
 	uint8_t valid;
-	ReturnValue_t read() {
+
+	ReturnValue_t readWithoutLock() {
 		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
 		PoolEntry<T>* read_out = glob::dataPool.getData<T>(
 				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
@@ -36,9 +37,13 @@ protected:
 	 * Reason is the possibility to access a single DP vector element, but if we commit,
 	 * we set validity of the whole vector.
 	 */
-	ReturnValue_t commit() {
+	ReturnValue_t commit(uint32_t lockTimeout) override {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	ReturnValue_t commitWithoutLock() override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	/**
 	 * Empty ctor for List initialization
 	 */
@@ -71,6 +76,19 @@ public:
 		}
 	}
 
+	ReturnValue_t read(uint32_t lockTimeout) override {
+		ReturnValue_t result = glob::dataPool.lockDataPool();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = readWithoutLock();
+		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "PIDReader::read: Could not unlock data pool!"
+					<< std::endl;
+		}
+		return result;
+	}
 	/**
 	 * Copy ctor to copy classes containing Pool Variables.
 	 */
@@ -113,7 +131,7 @@ public:
 		return valid;
 	}
 
-	void setValid(uint8_t valid) {
+	void setValid(bool valid) {
 		this->valid = valid;
 	}
 
diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index b10ee04c8..39cfd58c7 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -18,7 +18,21 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 
 PoolRawAccess::~PoolRawAccess() {}
 
-ReturnValue_t PoolRawAccess::read() {
+ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::readWithoutLock() {
 	ReturnValue_t result = RETURN_FAILED;
 	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
 	if (readOut != nullptr) {
@@ -75,7 +89,21 @@ void PoolRawAccess::handleReadError(ReturnValue_t result) {
 	memset(value, 0, sizeof(value));
 }
 
-ReturnValue_t PoolRawAccess::commit() {
+ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::commitWithoutLock() {
 	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
 	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
 		write_back->setValid(valid);
@@ -189,7 +217,7 @@ bool PoolRawAccess::isValid() const {
 		return false;
 }
 
-void PoolRawAccess::setValid(uint8_t valid) {
+void PoolRawAccess::setValid(bool valid) {
 	this->valid = valid;
 }
 
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index 452b5397a..60e3c71e3 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -124,7 +124,7 @@ public:
 	 */
 	bool isValid() const;
 
-	void setValid(uint8_t valid);
+	void setValid(bool valid);
 	/**
 	 * Getter for the remaining size.
 	 */
@@ -135,31 +135,49 @@ public:
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
-protected:
 	/**
 	 * @brief	This is a call to read the value from the global data pool.
-	 * @details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself !
-	 * 			If reading from the data pool without information about the type is desired,
-	 * 			initialize the raw pool access by supplying a data set and using the data set
-	 * 			read function, which calls this read function.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The call is protected by a lock of the global data pool.
 	 * @return -@c RETURN_OK Read successfull
 	 * 		   -@c READ_TYPE_TOO_LARGE
 	 * 		   -@c READ_INDEX_TOO_LARGE
 	 * 		   -@c READ_ENTRY_NON_EXISTENT
 	 */
-	ReturnValue_t read();
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
 	/**
 	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The call is protected by a lock of the global data pool.
 	 *
 	 */
-	ReturnValue_t commit();
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
 
 	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
 	void handleReadError(ReturnValue_t result);

From 319fa9ddb6237c58d9fe8b0e5763b0b463ec82a4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:34:34 +0200
Subject: [PATCH 0380/1774] datapoollocal update

---
 datapoollocal/LocalDataSet.cpp      |  69 +++-------
 datapoollocal/LocalDataSet.h        | 141 +++------------------
 datapoollocal/LocalPoolVariable.h   | 143 +++++++++++++++------
 datapoollocal/LocalPoolVariable.tpp |  83 +++++++++---
 datapoollocal/LocalPoolVector.h     | 189 ++++++++++++++++++++++++++++
 datapoollocal/LocalPoolVector.tpp   | 185 +++++++++++++++++++++++++++
 6 files changed, 582 insertions(+), 228 deletions(-)
 create mode 100644 datapoollocal/LocalPoolVector.h
 create mode 100644 datapoollocal/LocalPoolVector.tpp

diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 07f86e18b..988f254a0 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -1,66 +1,35 @@
 #include <framework/datapoollocal/LocalDataSet.h>
+#include <framework/housekeeping/HousekeepingManager.h>
 
-LocalDataSet::LocalDataSet():
-		fill_count(0), state(DATA_SET_UNINITIALISED)
-{
-	for (unsigned count = 0; count < DATA_SET_MAX_SIZE; count++) {
-		registeredVariables[count] = nullptr;
+LocalDataSet::LocalDataSet(HasHkPoolParametersIF *hkOwner): DataSetBase() {
+	if(hkOwner != nullptr) {
+		hkManager = hkOwner->getHkManagerHandle();
+	}
+	else {
+		// config error, error output here.
 	}
 }
 
-// who has the responsibility to lock the mutex? the local pool variable
-// has access to the HK manager and could call its mutex lock function.
-ReturnValue_t LocalDataSet::registerVariable(
-		PoolVariableIF *variable) {
-	return RETURN_OK;
+LocalDataSet::LocalDataSet(object_id_t ownerId): DataSetBase()  {
+	HasHkPoolParametersIF* hkOwner = objectManager->get<HasHkPoolParametersIF>(
+			ownerId);
+	if(hkOwner == nullptr) {
+		// config error, error output here.
+	}
+	hkManager = hkOwner->getHkManagerHandle();
 }
 
 LocalDataSet::~LocalDataSet() {
 }
 
-ReturnValue_t LocalDataSet::read() {
-	return RETURN_OK;
-}
-
-ReturnValue_t LocalDataSet::commit(void) {
-	return RETURN_OK;
-}
-
-ReturnValue_t LocalDataSet::commit(bool valid) {
-	return RETURN_OK;
-}
-
-void LocalDataSet::setSetValid(bool valid) {
-}
-
-void LocalDataSet::setEntriesValid(bool valid) {
-}
-
-ReturnValue_t LocalDataSet::serialize(uint8_t **buffer,
-		size_t *size, const size_t max_size, bool bigEndian) const {
-	return RETURN_OK;
-}
-
-size_t LocalDataSet::getSerializedSize() const {
-	return 0;
-}
-
-ReturnValue_t LocalDataSet::deSerialize(const uint8_t **buffer,
-		size_t *size, bool bigEndian) {
-	return RETURN_OK;
-}
-
-ReturnValue_t LocalDataSet::lockDataPool() {
-	return RETURN_OK;
+ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->lockMutex(timeoutMs);
 }
 
 ReturnValue_t LocalDataSet::unlockDataPool() {
-	return RETURN_OK;
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->unlockMutex();
 }
 
-void LocalDataSet::handleAlreadyReadDatasetCommit() {
-}
 
-ReturnValue_t LocalDataSet::handleUnreadDatasetCommit() {
-	return RETURN_OK;
-}
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 6110175c4..607d10b37 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -1,8 +1,12 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
+#include <framework/datapool/DataSetBase.h>
 #include <framework/datapool/DataSetIF.h>
+#include <framework/housekeeping/HasHkPoolParametersIF.h>
 #include <framework/serialize/SerializeIF.h>
 
+class HousekeepingManager;
+
 /**
  * @brief	The LocalDataSet class manages a set of locally checked out variables
  * 			for local data pools
@@ -24,32 +28,22 @@
  *
  * @ingroup data_pool
  */
-class LocalDataSet:
-		public DataSetIF,
-		public HasReturnvaluesIF,
-		public SerializeIF {
+class LocalDataSet: public DataSetBase {
 public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
-	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION =
-			MAKE_RETURN_CODE( 0x01 );
-	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
-	static constexpr ReturnValue_t COMMITING_WITHOUT_READING =
-			MAKE_RETURN_CODE(0x03);
-
-	static constexpr ReturnValue_t DATA_SET_UNINITIALIZED = MAKE_RETURN_CODE( 0x04 );
-	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE( 0x05 );
-	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE( 0x06 );
 	/**
-	 * @brief	The constructor simply sets the fill_count to zero and sets
+	 * @brief	Constructor for the creator of local pool data.
+	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSet();
+	LocalDataSet(HasHkPoolParametersIF* hkOwner);
 
 	/**
-	 * @brief	This operation is used to register the local variables in the set.
-	 * @details	It stores the pool variable pointer in a variable list.
+	 * @brief	Constructor for users of local pool data. The passed pool
+	 * 			owner should implement the HasHkPoolParametersIF.
+	 * 			The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
 	 */
-	ReturnValue_t registerVariable(PoolVariableIF* variable) override;
+	LocalDataSet(object_id_t ownerId);
 
 	/**
 	 * @brief	The destructor automatically manages writing the valid
@@ -61,127 +55,30 @@ public:
 	 */
 	~LocalDataSet();
 
-	/**
-	 * @brief	The read call initializes reading out all registered variables.
-	 * @details
-	 * It iterates through the list of registered variables and calls all read()
-	 * functions of the registered pool variables (which read out their values
-	 * from the data pool) which are not write-only.
-	 * In case of an error (e.g. a wrong data type, or an invalid data pool id),
-	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
-	 *
-	 * The data pool is locked during the whole read operation and
-	 * freed afterwards.The state changes to "was written" after this operation.
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
-	 * 					requested variable is invalid.
-	 * 			- @c SET_WAS_ALREADY_READ if read() is called twice without
-	 * 				 	calling commit() in between
-	 */
-	ReturnValue_t read();
-
-	/**
-	 * @brief	The commit call initializes writing back the registered variables.
-	 * @details
-	 * It iterates through the list of registered variables and calls the
-	 * commit() method of the remaining registered variables (which write back
-	 * their values to the pool).
-	 *
-	 * The data pool is locked during the whole commit operation and
-	 * freed afterwards. The state changes to "was committed" after this operation.
-	 *
-	 * If the set does contain at least one variable which is not write-only commit()
-	 * can only be called after read(). If the set only contains variables which are
-	 * write only, commit() can be called without a preceding read() call.
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
-	 * 			  contains non write-only variables
-	 */
-	ReturnValue_t commit(void);
-
-	/**
-	 * Variant of method above which sets validity of all elements of the set.
-	 * @param valid Validity information from PoolVariableIF.
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
-	 * 			     contains non write-only variables
-	 */
-	ReturnValue_t commit(bool valid);
-
-	/**
-	 * Set all entries
-	 * @param valid
-	 */
-	void setSetValid(bool valid);
-
-	/**
-	 * Set the valid information of all variables contained in the set which
-	 * are not read-only
-	 *
-	 * @param valid Validity information from PoolVariableIF.
-	 */
-	void setEntriesValid(bool valid);
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
-
-	size_t getSerializedSize() const override;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+protected:
 private:
-	// SHOULDDO we could use a linked list of datapool variables
-	//! This definition sets the maximum number of variables
-	//! to register in one DataSet.
-	static const uint8_t DATA_SET_MAX_SIZE = 63;
-	/**
-	 * @brief	This array represents all pool variables registered in this set.
-	 */
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-	/**
-	 * @brief	The fill_count attribute ensures that the variables register in
-	 * 			the correct array position and that the maximum number of
-	 * 			variables is not exceeded.
-	 */
-	uint16_t fill_count;
-
-	/**
-	 * States of the seet.
-	 */
-	enum States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
-	};
-
-	/**
-	 * @brief	state manages the internal state of the data set,
-	 *          which is important e.g. for the behavior on destruction.
-	 */
-	States state;
-
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
 	 * data set we can use this flag.
 	 */
 	bool valid = false;
+
 	/**
 	 * @brief	This is a small helper function to facilitate locking
-	 * 			the underlying data data pool structure
+	 * 			the global data pool.
 	 * @details
 	 * It makes use of the lockDataPool method offered by the DataPool class.
 	 */
-	ReturnValue_t lockDataPool() override;
-
+	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
 	/**
 	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the underlying data data pool structure
+	 * 			unlocking the global data pool
 	 * @details
 	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
 	 */
 	ReturnValue_t unlockDataPool() override;
 
-	void handleAlreadyReadDatasetCommit();
-	ReturnValue_t handleUnreadDatasetCommit();
+	HousekeepingManager* hkManager;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 39c92f604..cb373a716 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -3,56 +3,63 @@
 
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/datapool/DataSetIF.h>
+#include <framework/housekeeping/HasHkPoolParametersIF.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
 
+#include <framework/serialize/SerializeAdapter.h>
 #include <framework/housekeeping/HousekeepingManager.h>
 
-#include <map>
-/**
- * @brief	This is the access class for non-array local data pool entries.
- *
- * @details
- *
- * 	@tparam	T The template parameter sets the type of the variable.
- * 	Currently, all plain data types are supported, but in principle
- * 	any type is possible.
- *	@ingroup data_pool
- */
-
 /**
  * @brief 	Local Pool Variable class which is used to access the local pools.
- * @details This class is not stored in the map. Instead, it is used to access
- * 			the pool entries by using a pointer to the map storing the pool
- * 			entries. It can also be used to organize these pool entries
- * 			into data sets.
- * @tparam T
+ * @details
+ * This class is not stored in the map. Instead, it is used to access
+ * the pool entries by using a pointer to the map storing the pool
+ * entries. It can also be used to organize these pool entries into data sets.
+ *
+ * @tparam T The template parameter sets the type of the variable. Currently,
+ * all plain data types are supported, but in principle  any type is possible.
+ * @ingroup data_pool
  */
 template<typename T>
 class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
 public:
-	static constexpr lp_id_t INVALID_POOL_ID = 0xFFFFFFFF;
+	//! Default ctor is forbidden.
+	LocalPoolVar() = delete;
 
 	/**
 	 * This constructor is used by the data creators to have pool variable
 	 * instances which can also be stored in datasets.
-	 * @param set_id
-	 * @param setReadWriteMode
-	 * @param localPoolMap
-	 * @param dataSet
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
 	 */
 	LocalPoolVar(lp_id_t poolId, HasHkPoolParametersIF* hkOwner,
-			pool_rwm_t setReadWriteMode, DataSetIF* dataSet = nullptr);
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
 
 	/**
 	 * This constructor is used by data users like controllers to have
 	 * access to the local pool variables of data creators by supplying
 	 * the respective creator object ID.
-	 * @param poolId
-	 * @param poolOwner
-	 * @param setReadWriteMode
-	 * @param dataSet
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
 	 */
 	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
-			pool_rwm_t setReadWriteMode, DataSetIF* dataSet = nullptr);
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
 
 	virtual~ LocalPoolVar() {};
 
@@ -63,33 +70,91 @@ public:
 	 */
 	T value = 0;
 
-	ReturnValue_t commit() override;
-	ReturnValue_t read() override;
 	pool_rwm_t getReadWriteMode() const override;
-	uint32_t getDataPoolId() const override;
+
+	lp_id_t getDataPoolId() const override;
+	void setDataPoolId(lp_id_t poolId);
+
 	bool isValid() const override;
-	void setValid(uint8_t validity) override;
+	void setValid(bool validity) override;
+	uint8_t getValid() const;
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const size_t max_size, bool bigEndian) const override;
+			const size_t max_size, bool bigEndian) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				bool bigEndian) override;
+			bool bigEndian) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the data pool and copies all array values and the valid
+	 * information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 *
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the local valid flag is written back as well.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+	// std::ostream is the type for object std::cout
+//	friend std::ostream& operator<< (std::ostream &out,
+//			const LocalPoolVar &var) {
+//		out << static_cast<int>(value);
+//		return out;
+//	}
+
 private:
-	lp_id_t localPoolId = INVALID_POOL_ID;
+	//! @brief 	Pool ID of pool entry inside the used local pool.
+	lp_id_t localPoolId = PoolVariableIF::NO_PARAMETER;
+	//! @brief 	Read-write mode of the pool variable
 	pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
+	//! @brief 	Specifies whether the entry is valid or invalid.
 	bool valid = false;
 
-	bool objectValid = true;
 	//! Pointer to the class which manages the HK pool.
 	HousekeepingManager* hkManager;
 };
 
 #include <framework/datapoollocal/LocalPoolVariable.tpp>
-template<class T>
-using lp_variable = LocalPoolVar<T>;
 
-using lp_bool_t = LocalPoolVar<bool>;
+template<class T>
+using lp_var_t = LocalPoolVar<T>;
+
+using lp_bool_t = LocalPoolVar<uint8_t>;
 using lp_uint8_t = LocalPoolVar<uint8_t>;
 using lp_uint16_t = LocalPoolVar<uint16_t>;
 using lp_uint32_t = LocalPoolVar<uint32_t>;
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 4bc4c6621..b7a0e837d 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -1,16 +1,24 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
 
-#include <framework/housekeeping/HasHkPoolParametersIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-#include <framework/serialize/SerializeAdapter.h>
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
+#endif
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
 		HasHkPoolParametersIF* hkOwner, pool_rwm_t setReadWriteMode,
 		DataSetIF* dataSet):
 		localPoolId(poolId),readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
+		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
+				"NO_PARAMETER value!" << std::endl;
+	}
+	if(hkOwner == nullptr) {
+		sif::error << "LocalPoolVariable: The supplied pool owner is a nullptr!"
+				<< std::endl;
+		return;
+	}
 	hkManager = hkOwner->getHkManagerHandle();
 	if(dataSet != nullptr) {
 		dataSet->registerVariable(this);
@@ -21,12 +29,15 @@ template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 		pool_rwm_t setReadWriteMode, DataSetIF *dataSet):
 		readWriteMode(readWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
+		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
+				"NO_PARAMETER value!" << std::endl;
+	}
 	HasHkPoolParametersIF* hkOwner =
 			objectManager->get<HasHkPoolParametersIF>(poolOwner);
 	if(hkOwner == nullptr) {
 		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
 				"the correct interface HasHkPoolParametersIF!" << std::endl;
-		objectValid = false;
 		return;
 	}
 	hkManager = hkOwner->getHkManagerHandle();
@@ -36,38 +47,59 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::read() {
+inline ReturnValue_t LocalPoolVar<T>::read(millis_t lockTimeout) {
+	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	return readWithoutLock();
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
-		// TODO: special return value
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::NO_TIMEOUT);
+
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, poolEntry);
-	if(result != RETURN_OK) {
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	if(result != RETURN_OK and poolEntry != nullptr) {
+		sif::error << "PoolVector: Read of local pool variable of object "
+				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
+				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
+				std::dec << " failed.\n" << std::flush;
 		return result;
 	}
 	this->value = *(poolEntry->address);
+	this->valid = poolEntry->valid;
 	return RETURN_OK;
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::commit() {
+inline ReturnValue_t LocalPoolVar<T>::commit(millis_t lockTimeout) {
+	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	return commitWithoutLock();
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 		sif::debug << "LocalPoolVar: Invalid read write "
 				 "mode for commit() call." << std::endl;
-		// TODO: special return value
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::NO_TIMEOUT);
+	// Wait maximum of 50 milliseconds.
+	MutexHelper(hkManager->getMutexHandle(), 50);
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, poolEntry);
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
+		sif::error << "PoolVector: Read of local pool variable of object "
+				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
+				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
+				std::dec << " failed.\n" << std::flush;
 		return result;
 	}
 	*(poolEntry->address) = this->value;
+	poolEntry->valid = this->valid;
 	return RETURN_OK;
 }
 
@@ -81,16 +113,26 @@ inline lp_id_t LocalPoolVar<T>::getDataPoolId() const {
 	return localPoolId;
 }
 
+template<typename T>
+inline void LocalPoolVar<T>::setDataPoolId(lp_id_t poolId) {
+	this->localPoolId = poolId;
+}
+
 template<typename T>
 inline bool LocalPoolVar<T>::isValid() const {
 	return valid;
 }
 
 template<typename T>
-inline void LocalPoolVar<T>::setValid(uint8_t validity) {
+inline void LocalPoolVar<T>::setValid(bool validity) {
 	this->valid = validity;
 }
 
+template<typename T>
+inline uint8_t LocalPoolVar<T>::getValid() const {
+	return valid;
+}
+
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, bool bigEndian) const {
@@ -109,4 +151,11 @@ inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
 	return AutoSerializeAdapter::deSerialize(&value, buffer, size, bigEndian);
 }
 
+//template<typename T>
+//inline friend std::ostream& LocalPoolVar<T>::operator<< (std::ostream &out,
+//		const LocalPoolVar &var) {
+//	out << static_cast<int>(out);
+//}
+
+
 #endif
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
new file mode 100644
index 000000000..02c471137
--- /dev/null
+++ b/datapoollocal/LocalPoolVector.h
@@ -0,0 +1,189 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolEntry.h>
+#include <framework/datapool/PoolVariableIF.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
+public:
+	LocalPoolVector() = delete;
+	/**
+	 * This constructor is used by the data creators to have pool variable
+	 * instances which can also be stored in datasets.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, HasHkPoolParametersIF* hkOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * This constructor is used by data users like controllers to have
+	 * access to the local pool variables of data creators by supplying
+	 * the respective creator object ID.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a local array of this type.
+	 */
+	T value[vectorSize];
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~LocalPoolVector() {};
+	/**
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
+	 */
+	uint8_t getSize() {
+		return vectorSize;
+	}
+
+	uint32_t getDataPoolId() const override;
+	/**
+	 * @brief This operation sets the data pool ID of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	pool_rwm_t getReadWriteMode() const;
+
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+	void setValid(bool valid) override;
+	uint8_t getValid() const;
+
+	T &operator [](int i);
+	const T &operator [](int i) const;
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the data pool and copies all array values and the valid
+	 * information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the local valid flag is written back as well.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t localPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	bool valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+	//! @brief	Pointer to the class which manages the HK pool.
+	HousekeepingManager* hkManager;
+};
+
+#include <framework/datapoollocal/LocalPoolVector.tpp>
+
+template<typename T, uint16_t vectorSize>
+using lp_vec_t = LocalPoolVector<T, vectorSize>;
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
new file mode 100644
index 000000000..78637efff
--- /dev/null
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -0,0 +1,185 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#error Include LocalPoolVector.h before LocalPoolVector.tpp!
+#endif
+
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
+		HasHkPoolParametersIF* hkOwner, pool_rwm_t setReadWriteMode,
+		DataSetIF* dataSet) :
+		localPoolId(poolId), valid(false), readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
+		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
+				"NO_PARAMETER value!" << std::endl;
+	}
+	memset(this->value, 0, vectorSize * sizeof(T));
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
+		object_id_t poolOwner, pool_rwm_t setReadWriteMode, DataSetIF *dataSet):
+		readWriteMode(readWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
+		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
+				"NO_PARAMETER value!" << std::endl;
+	}
+	HasHkPoolParametersIF* hkOwner =
+			objectManager->get<HasHkPoolParametersIF>(poolOwner);
+	if(hkOwner == nullptr) {
+		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
+				"the correct interface HasHkPoolParametersIF!" << std::endl;
+		return;
+	}
+	hkManager = hkOwner->getHkManagerHandle();
+	if(dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
+	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	return readWithoutLock();
+}
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
+	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+		sif::debug << "LocalPoolVar: Invalid read write "
+				"mode for read() call." << std::endl;
+		return PoolVariableIF::INVALID_READ_WRITE_MODE;
+	}
+
+	PoolEntry<T>* poolEntry = nullptr;
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	memset(this->value, 0, vectorSize * sizeof(T));
+
+	if(result != RETURN_OK) {
+		sif::error << "PoolVector: Read of local pool variable of object "
+				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
+				hkManager->getOwner() << "and lp ID 0x" << localPoolId <<
+				std::dec << " failed." << std::endl;
+		return result;
+	}
+	memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
+	this->valid = poolEntry->valid;
+	return RETURN_OK;
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
+		uint32_t lockTimeout) {
+	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	return commitWithoutLock();
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
+	if(readWriteMode == pool_rwm_t::VAR_READ) {
+		sif::debug << "LocalPoolVar: Invalid read write "
+				"mode for commit() call." << std::endl;
+		return PoolVariableIF::INVALID_READ_WRITE_MODE;
+	}
+	// Wait maximum of 50 milliseconds.
+	MutexHelper(hkManager->getMutexHandle(), 50);
+	PoolEntry<T>* poolEntry = nullptr;
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	if(result != RETURN_OK) {
+		sif::error << "PoolVector: Read of local pool variable of object "
+				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
+				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
+				std::dec << " failed.\n" << std::flush;
+		return result;
+	}
+	memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
+	poolEntry->valid = this->valid;
+	return RETURN_OK;
+}
+
+template<typename T, uint16_t vectorSize>
+inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
+	if(i <= vectorSize) {
+		return value[i];
+	}
+	sif::warning << "LocalPoolVector: Invalid index" << std::endl;
+	return 0;
+}
+
+template<typename T, uint16_t vectorSize>
+inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
+	if(i <= vectorSize) {
+		return value[i];
+	}
+	sif::warning << "LocalPoolVector: Invalid index" << std::endl;
+	return 0;
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
+		size_t* size, const size_t max_size, bool bigEndian) const {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t i = 0; i < vectorSize; i++) {
+		result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
+				max_size, bigEndian);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
+	return vectorSize * SerializeAdapter<T>::getSerializedSize(value);
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
+		const uint8_t** buffer, size_t* size, bool bigEndian) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t i = 0; i < vectorSize; i++) {
+		result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
+				bigEndian);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline pool_rwm_t LocalPoolVector<T, vectorSize>::getReadWriteMode() const {
+	return this->readWriteMode;
+}
+
+
+template<typename T, uint16_t vectorSize>
+inline uint32_t LocalPoolVector<T, vectorSize>::getDataPoolId() const {
+	return localPoolId;
+}
+
+template<typename T, uint16_t vectorSize>
+inline void LocalPoolVector<T, vectorSize>::setDataPoolId(uint32_t poolId) {
+	this->localPoolId = poolId;
+}
+
+template<typename T, uint16_t vectorSize>
+inline void LocalPoolVector<T, vectorSize>::setValid(bool valid) {
+	this->valid = valid;
+}
+
+template<typename T, uint16_t vectorSize>
+inline uint8_t LocalPoolVector<T, vectorSize>::getValid() const {
+	return valid;
+}
+
+template<typename T, uint16_t vectorSize>
+inline bool LocalPoolVector<T, vectorSize>::isValid() const {
+	return valid;
+}
+
+#endif

From 9ec2283d1397b5699796517cc47e3f82e327757a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:35:08 +0200
Subject: [PATCH 0381/1774] hk folder update

---
 housekeeping/HasHkPoolParametersIF.h | 23 ++++++++-
 housekeeping/HousekeepingManager.cpp | 46 ++++++++++++++---
 housekeeping/HousekeepingManager.h   | 77 +++++++++++++++++-----------
 housekeeping/HousekeepingMessage.cpp | 12 ++---
 housekeeping/HousekeepingMessage.h   | 15 ++----
 5 files changed, 119 insertions(+), 54 deletions(-)

diff --git a/housekeeping/HasHkPoolParametersIF.h b/housekeeping/HasHkPoolParametersIF.h
index ac248cf35..62715a3d4 100644
--- a/housekeeping/HasHkPoolParametersIF.h
+++ b/housekeeping/HasHkPoolParametersIF.h
@@ -2,9 +2,11 @@
 #define FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
 #include <framework/datapool/PoolEntryIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
+#include <framework/housekeeping/HousekeepingMessage.h>
 #include <map>
 
 class HousekeepingManager;
+class DataSetIF;
 /**
  * @brief	Type definition for local pool entries.
  */
@@ -13,17 +15,34 @@ using LocalDataPoolMap =  std::map<lp_id_t, PoolEntryIF*>;
 using LocalDataPoolMapIter = LocalDataPoolMap::iterator;
 
 /**
- * @brief
+ * @brief 		This interface is implemented by classes which posses a local
+ * 				data pool (not the managing class)
+ * @details
+ * Any class implementing this interface shall also have a HousekeepingManager
+ * member class which handles the retrieval of the local pool data.
+ * This is required because the pool entries are templates, which makes
+ * specifying an interface rather difficult.
+ *
+ * This could be circumvented by using a wrapper/accessor function, but
+ * the LocalPoolVariable classes are templates as well, so this just shifts
+ * the problem somewhere else. Interfaces are nice, but the most
+ * pragmatic solution I found was to offer the client the full interface
+ * of the housekeeping manager.
  */
 class HasHkPoolParametersIF {
 public:
 	virtual~ HasHkPoolParametersIF() {};
 
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING;
+	static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0XA0);
+	static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0xA1);
+
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual ReturnValue_t initializeHousekeepingPoolEntries(
 			LocalDataPoolMap& localDataPoolMap) = 0;
-	virtual float setMinimalHkSamplingFrequency() = 0;
+	//virtual float setMinimalHkSamplingFrequency() = 0;
 	virtual HousekeepingManager* getHkManagerHandle() = 0;
+	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
 };
 
 #endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */
diff --git a/housekeeping/HousekeepingManager.cpp b/housekeeping/HousekeepingManager.cpp
index 05df0ffcf..e8edcc397 100644
--- a/housekeeping/HousekeepingManager.cpp
+++ b/housekeeping/HousekeepingManager.cpp
@@ -1,17 +1,19 @@
+#include <framework/datapoollocal/LocalDataSet.h>
 #include <framework/housekeeping/HousekeepingManager.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 
+#include <array>
+
 HousekeepingManager::HousekeepingManager(HasHkPoolParametersIF* owner) {
-	//todo :: nullptr check owner.
 	if(owner == nullptr) {
 		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
 		std::exit(0);
 	}
 	this->owner = owner;
 	mutex = MutexFactory::instance()->createMutex();
-	owner->setMinimalHkSamplingFrequency();
+	//owner->setMinimalHkSamplingFrequency();
 }
 
 HousekeepingManager::~HousekeepingManager() {}
@@ -24,7 +26,7 @@ ReturnValue_t HousekeepingManager::initializeHousekeepingPoolEntriesOnce() {
 		}
 		return result;
 	}
-	sif::warning << "hk manager says no" << std::endl;
+	sif::warning << "HousekeepingManager: The map" << std::endl;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -33,18 +35,48 @@ ReturnValue_t HousekeepingManager::handleHousekeepingMessage(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t HousekeepingManager::printPoolEntry(
+		lp_id_t localPoolId) {
+	auto poolIter = localDpMap.find(localPoolId);
+	if (poolIter == localDpMap.end()) {
+		sif::debug << "HousekeepingManager::fechPoolEntry:"
+				" Pool entry not found." << std::endl;
+		return HasHkPoolParametersIF::POOL_ENTRY_NOT_FOUND;
+	}
+	poolIter->second->print();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 MutexIF* HousekeepingManager::getMutexHandle() {
 	return mutex;
 }
 
-void HousekeepingManager::setMinimalSamplingFrequency(float frequencySeconds) {
-	this->samplingFrequency = frequencySeconds;
+//void HousekeepingManager::setMinimalSamplingFrequency(float frequencySeconds) {
+//	this->samplingFrequency = frequencySeconds;
+//
+//}
 
-}
+void HousekeepingManager::generateHousekeepingPacket(sid_t sid) {
+	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
+			owner->getDataSetHandle(sid));
+	if(dataSetToSerialize == nullptr) {
+		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+				" Set ID not found" << std::endl;
+		return;
+	}
+	std::array<uint8_t, 256> testBuffer = {};
+	uint8_t* dataPtr = testBuffer.data();
+	size_t size = 0;
+	dataSetToSerialize->serialize(&dataPtr, &size, testBuffer.size(),
+			false);
+	// and now we send it to the TM funnel or somewhere else
 
-void HousekeepingManager::generateHousekeepingPacket(DataSetIF *dataSet) {
 }
 
 void HousekeepingManager::setHkPacketQueue(MessageQueueIF *msgQueue) {
 	this->hkPacketQueue = msgQueue;
 }
+
+const HasHkPoolParametersIF* HousekeepingManager::getOwner() const {
+	return owner;
+}
diff --git a/housekeeping/HousekeepingManager.h b/housekeeping/HousekeepingManager.h
index feec69fc0..43922ae68 100644
--- a/housekeeping/HousekeepingManager.h
+++ b/housekeeping/HousekeepingManager.h
@@ -5,6 +5,7 @@
 #include <framework/housekeeping/HasHkPoolParametersIF.h>
 #include <framework/ipc/MutexIF.h>
 
+#include <framework/housekeeping/HousekeepingMessage.h>
 #include <framework/datapool/PoolEntry.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/MessageQueueIF.h>
@@ -14,47 +15,36 @@
 
 
 class HousekeepingManager {
+	template<typename T>
+	friend class LocalPoolVar;
+	template<typename T, uint16_t vecSize>
+	friend class LocalPoolVector;
+	friend class LocalDataSet;
 public:
 	static constexpr float MINIMAL_SAMPLING_FREQUENCY = 0.2;
 
 	HousekeepingManager(HasHkPoolParametersIF* owner);
 	virtual~ HousekeepingManager();
 
-	MutexIF* getMutexHandle();
 
 	// propably will just call respective local data set functions.
-	void generateHousekeepingPacket(DataSetIF* dataSet);
+	void generateHousekeepingPacket(sid_t sid);
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
-	/**
-	 * Read a variable by supplying its local pool ID and assign the pool
-	 * entry to the supplied PoolEntry pointer. The type of the pool entry
-	 * is deduced automatically. This call is not thread-safe!
-	 * @tparam T Type of the pool entry
-	 * @param localPoolId Pool ID of the variable to read
-	 * @param poolVar [out] Corresponding pool entry will be assigned to the
-	 * 						supplied pointer.
-	 * @return
-	 */
-	template <class T>
-	ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> *poolEntry);
-	void setMinimalSamplingFrequency(float frequencySeconds);
-
 	/**
 	 * This function is used to fill the local data pool map with pool
-	 * entries. The default implementation is empty.
+	 * entries. It should only be called once by the pool owner.
 	 * @param localDataPoolMap
 	 * @return
 	 */
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
 	void setHkPacketQueue(MessageQueueIF* msgQueue);
-private:
-	//! this depends on the PST frequency.. maybe it would be better to just
-	//! set this manually with a global configuration value which is also
-	//! passed to the PST. Or force setting this in device handler.
-	float samplingFrequency = MINIMAL_SAMPLING_FREQUENCY;
+	const HasHkPoolParametersIF* getOwner() const;
 
+	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
+
+private:
 	//! This is the map holding the actual data. Should only be initialized
 	//! once !
 	bool mapInitialized = false;
@@ -72,24 +62,53 @@ private:
 	//! message..)
 	MessageQueueIF* hkReplyQueue = nullptr;
 	//! Used for HK packets, which are generated without requests.
+	//! Maybe this will just be the TM funnel.
 	MessageQueueIF* hkPacketQueue = nullptr;
+
+	/**
+	 * Get the pointer to the mutex. Can be used to lock the data pool
+	 * eternally. Use with care and don't forget to unlock locked mutexes!
+	 * For now, only friend classes can accss this function.
+	 * @return
+	 */
+	MutexIF* getMutexHandle();
+
+	/**
+	 * Read a variable by supplying its local pool ID and assign the pool
+	 * entry to the supplied PoolEntry pointer. The type of the pool entry
+	 * is deduced automatically. This call is not thread-safe!
+	 * For now, only friend classes like LocalPoolVar may access this
+	 * function.
+	 * @tparam T Type of the pool entry
+	 * @param localPoolId Pool ID of the variable to read
+	 * @param poolVar [out] Corresponding pool entry will be assigned to the
+	 * 						supplied pointer.
+	 * @return
+	 */
+	template <class T>
+	ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry);
+	void setMinimalSamplingFrequency(float frequencySeconds);
+
 };
 
 template<class T> inline
 ReturnValue_t HousekeepingManager::fetchPoolEntry(lp_id_t localPoolId,
-		PoolEntry<T> *poolEntry) {
+		PoolEntry<T> **poolEntry) {
 	auto poolIter = localDpMap.find(localPoolId);
 	if (poolIter == localDpMap.end()) {
-		// todo: special returnvalue.
-		return HasReturnvaluesIF::RETURN_FAILED;
+		sif::debug << "HousekeepingManager::fechPoolEntry:"
+				" Pool entry not found." << std::endl;
+		return HasHkPoolParametersIF::POOL_ENTRY_NOT_FOUND;
 	}
 
-	poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
-	if(poolEntry == nullptr) {
-		// todo: special returnvalue.
-		return HasReturnvaluesIF::RETURN_FAILED;
+	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
+	if(*poolEntry == nullptr) {
+		sif::debug << "HousekeepingManager::fetchPoolEntry:"
+				" Pool entry not found." << std::endl;
+		return HasHkPoolParametersIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
 #endif /* FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_ */
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 65d87e9ee..b0109e5df 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,10 +1,10 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 
-void HousekeepingMessage::setAddHkReportStructMessage(CommandMessage *message,
-		set_t setId, store_address_t packet) {
-	message->setCommand(ADD_HK_REPORT_STRUCT);
-	message->setParameter(setId);
-	message->setParameter2(packet.raw);
-}
+//void HousekeepingMessage::setAddHkReportStructMessage(CommandMessage *message,
+//		set_t setId, store_address_t packet) {
+//	message->setCommand(ADD_HK_REPORT_STRUCT);
+//	message->setParameter(setId);
+//	message->setParameter2(packet.raw);
+//}
 
 //void Housekeeping
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 80dc83a6c..e7ba68ba7 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -4,20 +4,15 @@
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <limits>
 
-/**
- * the sid consists of the target object ID and... something else I forgot.
- * Propably a special HK id to distinguish multiple hk pool packages
- * inside a handler or controller
- */
-typedef uint32_t set_t;
-
 union sid_t {
 	static constexpr uint64_t INVALID_ADDRESS = std::numeric_limits<uint64_t>::max();
 	sid_t(): raw(INVALID_ADDRESS) {}
 
 	struct {
 		object_id_t objectId ;
-		set_t hkId;
+		// A generic 32 bit ID to identify unique HK packets for a single object.
+		// For example, the DeviceCommandId_t is used for DeviceHandlers
+		uint32_t ownerSetId;
 	};
 	/**
 	 * Alternative access to the raw value.
@@ -79,8 +74,8 @@ public:
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
-	static void setAddHkReportStructMessage(CommandMessage* message,
-			set_t setId, store_address_t packet);
+//	static void setAddHkReportStructMessage(CommandMessage* message,
+//			DevisetId, store_address_t packet);
 };
 
 

From 7247a1af7efde551f6e7d619e66917d9d4717562 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:36:25 +0200
Subject: [PATCH 0382/1774] new class ids

---
 returnvalues/FwClassIds.h | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 120d8b8c9..870efb461 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -55,12 +55,14 @@ enum {
 	HAS_ACTIONS_IF, //HF
 	DEVICE_COMMUNICATION_IF, //DC
 	BSP, //BSP
-	TIME_STAMPER_IF, //TSI 52
+	TIME_STAMPER_IF, //TSI 53
 	//TODO This will shift all IDs for FLP
-	SGP4PROPAGATOR_CLASS, //SGP4 53
-	MUTEX_IF, //MUX 54
-	MESSAGE_QUEUE_IF,//MQI 55
-	SEMAPHORE_IF, //SPH 56
+	SGP4PROPAGATOR_CLASS, //SGP4 54
+	MUTEX_IF, //MUX 55
+	MESSAGE_QUEUE_IF,//MQI 56
+	SEMAPHORE_IF, //SPH 57
+	HOUSEKEEPING, //HK 58
+	POOL_VARIABLE_IF, //PVA 59
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 0d4d4123ab28a10376c8ba6c6cc7bd3be5c54e74 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:37:46 +0200
Subject: [PATCH 0383/1774] added new message  type (hk)

---
 ipc/FwMessageTypes.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ipc/FwMessageTypes.h b/ipc/FwMessageTypes.h
index b59319aaf..7daf87672 100644
--- a/ipc/FwMessageTypes.h
+++ b/ipc/FwMessageTypes.h
@@ -15,6 +15,7 @@ enum FW_MESSAGE_TYPE {
 	MEMORY,
 	PARAMETER,
 	FILE_SYSTEM_MESSAGE,
+	HOUSEKEEPING,
 	FW_MESSAGES_COUNT,
 
 };

From e9a9a543ce3fbf8a9ff57e337513e050e6004c8e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:38:59 +0200
Subject: [PATCH 0384/1774] fw message count one line further

---
 ipc/FwMessageTypes.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ipc/FwMessageTypes.h b/ipc/FwMessageTypes.h
index 7daf87672..1665747ee 100644
--- a/ipc/FwMessageTypes.h
+++ b/ipc/FwMessageTypes.h
@@ -16,8 +16,8 @@ enum FW_MESSAGE_TYPE {
 	PARAMETER,
 	FILE_SYSTEM_MESSAGE,
 	HOUSEKEEPING,
-	FW_MESSAGES_COUNT,
 
+	FW_MESSAGES_COUNT,
 };
 }
 

From 2b646551e96882aac5c62232b9c88a0271209440 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:40:22 +0200
Subject: [PATCH 0385/1774] mutex helper new output error

---
 ipc/MutexHelper.h | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 671cd5a6a..20760b32f 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -9,8 +9,12 @@ public:
 	MutexHelper(MutexIF* mutex, uint32_t timeoutMs) :
 			internalMutex(mutex) {
 		ReturnValue_t status = mutex->lockMutex(timeoutMs);
-		if(status != HasReturnvaluesIF::RETURN_OK){
-			sif::error << "MutexHelper: Lock of Mutex failed " <<
+		if(status == MutexIF::MUTEX_TIMEOUT) {
+			sif::error << "MutexHelper: Lock of mutex failed with timeout of"
+					<< timeoutMs << " milliseconds!" << std::endl;
+		}
+		else if(status != HasReturnvaluesIF::RETURN_OK){
+			sif::error << "MutexHelper: Lock of Mutex failed with code " <<
 					status << std::endl;
 		}
 	}

From 579115f904e5287ad0bd8d15038b6d707a72523f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 21:36:50 +0200
Subject: [PATCH 0386/1774] adapting host osal

---
 osal/host/Clock.cpp            |  4 ++--
 osal/host/Mutex.cpp            | 10 +++++-----
 osal/host/Mutex.h              |  2 +-
 osal/host/QueueFactory.cpp     |  2 +-
 osal/host/SemaphoreFactory.cpp |  4 ++--
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 78bbc58a8..57f2572b1 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -186,7 +186,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -201,7 +201,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex == nullptr){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index 0e6e652d7..03948c4cf 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -1,22 +1,22 @@
 #include <framework/osal/host/Mutex.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t MutexIF::NO_TIMEOUT = 0;
-const uint32_t MutexIF::MAX_TIMEOUT = 0xffffffff;
+const uint32_t MutexIF::POLLING = 0;
+const uint32_t MutexIF::BLOCKING = 0xffffffff;
 
 ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	if(timeoutMs == MutexIF::MAX_TIMEOUT) {
+	if(timeoutMs == MutexIF::BLOCKING) {
 		mutex.lock();
 		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	else if(timeoutMs == MutexIF::NO_TIMEOUT) {
+	else if(timeoutMs == MutexIF::POLLING) {
 		if(mutex.try_lock()) {
 			locked = true;
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
-	else if(timeoutMs > MutexIF::NO_TIMEOUT){
+	else if(timeoutMs > MutexIF::POLLING){
 		auto chronoMs = std::chrono::milliseconds(timeoutMs);
 		if(mutex.try_lock_for(chronoMs)) {
 			locked = true;
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index dce2a9dc3..d882c457b 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -16,7 +16,7 @@
 class Mutex : public MutexIF {
 public:
 	Mutex() = default;
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::MAX_TIMEOUT) override;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
 	ReturnValue_t unlockMutex() override;
 
 	std::timed_mutex* getMutexHandle();
diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
index 691249c3f..60274c842 100644
--- a/osal/host/QueueFactory.cpp
+++ b/osal/host/QueueFactory.cpp
@@ -27,7 +27,7 @@ QueueFactory::QueueFactory() {
 QueueFactory::~QueueFactory() {
 }
 
-MessageQueueIF* QueueFactory::createMessageQueue(size_t messageDepth,
+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
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index 3719a8833..8712d8662 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -3,8 +3,8 @@
 #include <framework/osal/linux/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
-const uint32_t SemaphoreIF::MAX_TIMEOUT = 0xFFFFFFFF;
+const uint32_t SemaphoreIF::POLLING = 0;
+const uint32_t SemaphoreIF::BLOCKING = 0xFFFFFFFF;
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 

From d74f2c7560452a9b82ddfa4020335b73d971b8a5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 21:40:06 +0200
Subject: [PATCH 0387/1774] housekeeping folder added to .mk file

---
 framework.mk | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/framework.mk b/framework.mk
index 2092c2fee..404055eec 100644
--- a/framework.mk
+++ b/framework.mk
@@ -10,11 +10,11 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoolglob/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/eventmatching/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/fdir/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/framework.mk/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/matching/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/math/*.cpp)

From 87f64d99cd1b7eae59b601140d13a5b92565f384 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 23:18:00 +0200
Subject: [PATCH 0388/1774] implemented fixed timeslot task

---
 osal/host/FixedTimeslotTask.cpp | 191 ++++++++++++++++++++++++++++++++
 osal/host/FixedTimeslotTask.h   | 130 ++++++++++++++++++++++
 osal/host/PeriodicTask.cpp      |   6 +-
 osal/host/PeriodicTask.h        |   5 +-
 osal/host/TaskFactory.cpp       |   6 +-
 5 files changed, 330 insertions(+), 8 deletions(-)
 create mode 100644 osal/host/FixedTimeslotTask.cpp
 create mode 100644 osal/host/FixedTimeslotTask.h

diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
new file mode 100644
index 000000000..48d11843f
--- /dev/null
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -0,0 +1,191 @@
+#include <framework/osal/host/FixedTimeslotTask.h>
+
+#include <framework/ipc/MutexFactory.h>
+#include <framework/osal/host/Mutex.h>
+#include <framework/osal/host/FixedTimeslotTask.h>
+
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/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() {
+    // A local iterator for the Polling Sequence Table is created to
+    // find the start time for the first entry.
+    SlotListIter 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) {
+    if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, 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;
+
+}
+
+
+
+
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
new file mode 100644
index 000000000..bb2f757aa
--- /dev/null
+++ b/osal/host/FixedTimeslotTask.h
@@ -0,0 +1,130 @@
+#ifndef FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
+
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/devicehandlers/FixedSlotSequence.h>
+#include <framework/tasks/FixedTimeslotTaskIF.h>
+#include <framework/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;
+
+    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_ */
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 57898ac2c..1a5024abf 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -105,7 +105,7 @@ void PeriodicTask::taskFunctionality() {
 				it != objectList.end(); ++it) {
 			(*it)->performOperation();
 		}
-		if(not delayUntil(&currentStartTime, periodChrono)) {
+		if(not delayForInterval(&currentStartTime, periodChrono)) {
 			sif::warning << "PeriodicTask: " << taskName <<
 					" missed deadline!\n" << std::flush;
 			if(deadlineMissedFunc != nullptr) {
@@ -129,8 +129,8 @@ uint32_t PeriodicTask::getPeriodMs() const {
 	return period * 1000;
 }
 
-bool PeriodicTask::delayUntil(std::chrono::milliseconds * previousWakeTimeMs,
-        const std::chrono::milliseconds interval) {
+bool PeriodicTask::delayForInterval(chron_ms* previousWakeTimeMs,
+        const chron_ms interval) {
     bool shouldDelay = false;
     //Get current wakeup time
     auto currentStartTime =
diff --git a/osal/host/PeriodicTask.h b/osal/host/PeriodicTask.h
index 19c06b52c..d97bf0890 100644
--- a/osal/host/PeriodicTask.h
+++ b/osal/host/PeriodicTask.h
@@ -64,6 +64,7 @@ public:
 	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;
@@ -115,8 +116,8 @@ protected:
 	 */
 	void taskFunctionality(void);
 
-	bool delayUntil(std::chrono::milliseconds * previousWakeTimeMs,
-	        const std::chrono::milliseconds interval);
+	bool delayForInterval(chron_ms * previousWakeTimeMs,
+	        const chron_ms interval);
 };
 
 #endif /* PERIODICTASK_H_ */
diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
index a13844c4a..9db8ac4d3 100644
--- a/osal/host/TaskFactory.cpp
+++ b/osal/host/TaskFactory.cpp
@@ -1,3 +1,4 @@
+#include <framework/osal/host/FixedTimeslotTask.h>
 #include <framework/osal/host/PeriodicTask.h>
 #include <framework/tasks/TaskFactory.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
@@ -36,9 +37,8 @@ FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
 		TaskDeadlineMissedFunction deadLineMissedFunction_) {
 	// This is going to be interesting. Time now learn the C++ threading library
 	// :-)
-	sif::warning << "TaskFactory::createFixedTimeslotTask: Not implemented "
-			"yet" << std::endl;
-	return nullptr;
+	return new FixedTimeslotTask(name_, taskPriority_, stackSize_,
+	        periodInSeconds_, deadLineMissedFunction_);
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {

From d600d488167c891407e27b3d3f545d02e319fb2e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 01:31:08 +0200
Subject: [PATCH 0389/1774] added the decoupling of DHB from powerSwitcher

+ some first hk maanger changes, might comment them out
---
 devicehandlers/DeviceHandlerBase.cpp          | 232 +++++++++++-------
 devicehandlers/DeviceHandlerBase.h            | 215 ++++++++--------
 .../DeviceHandlerFailureIsolation.cpp         |  34 +--
 .../DeviceHandlerFailureIsolation.h           |   1 +
 4 files changed, 273 insertions(+), 209 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 02c94129b..1e3bb16e8 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -14,7 +14,7 @@
 
 #include <iomanip>
 
-object_id_t DeviceHandlerBase::powerSwitcherId = 0;
+object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
@@ -26,12 +26,13 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
+		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
+		actionHelper(this, nullptr), hkManager(this),
 		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), cookieInfo(),
+		switchOffWasReported(false), cookieInfo(),
 		childTransitionDelay(5000),
 		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
 		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
@@ -52,7 +53,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-	//communicationInterface->close(cookie);
+	delete comCookie;
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
 	}
@@ -129,9 +130,11 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	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 == NULL) {
+			return RETURN_FAILED;
+		}
 	}
 
 	result = healthHelper.initialize();
@@ -162,6 +165,11 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
+	result = hkManager.initializeHousekeepingPoolEntriesOnce();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
 	fillCommandAndReplyMap();
 
 	//Set temperature target state to NON_OP.
@@ -271,7 +279,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);
@@ -341,9 +350,10 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-		uint16_t maxDelayCycles, size_t replyLen, uint8_t 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) {
@@ -354,7 +364,7 @@ ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(DeviceCommandId_t de
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, size_t replyLen, uint8_t periodic) {
+		uint16_t maxDelayCycles, size_t replyLen, bool periodic) {
 	DeviceReplyInfo info;
 	info.maxDelayCycles = maxDelayCycles;
 	info.periodic = periodic;
@@ -369,7 +379,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;
@@ -383,7 +394,7 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
 }
 
 ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
-		uint16_t delayCycles, uint16_t maxDelayCycles, uint8_t periodic) {
+		uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
 	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
 			deviceReplyMap.find(deviceReply);
 	if (iter == deviceReplyMap.end()) {
@@ -576,11 +587,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;
@@ -589,8 +597,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,44 +616,90 @@ void DeviceHandlerBase::doGetRead() {
 
 	if (mode == MODE_RAW) {
 		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 != 0) {
+			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);
+		}
 	}
 }
 
@@ -724,42 +778,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 != 0) {
-			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);
@@ -791,6 +809,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);
@@ -805,9 +826,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) {
@@ -843,6 +862,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;
 
@@ -1286,4 +1308,24 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
 		object_id_t objectId, uint32_t parameter) {}
 
-void DeviceHandlerBase::performOperationHook() {}
+void DeviceHandlerBase::performOperationHook() {
+}
+
+ReturnValue_t DeviceHandlerBase::initializeHousekeepingPoolEntries(
+		LocalDataPoolMap &localDataPoolMap) {
+	return RETURN_OK;
+}
+
+HousekeepingManager* DeviceHandlerBase::getHkManagerHandle() {
+	return &hkManager;
+}
+
+DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
+	auto iter = deviceReplyMap.find(sid.ownerSetId);
+	if(iter != deviceReplyMap.end()) {
+		return iter->second.dataSet;
+	}
+	else {
+		return nullptr;
+	}
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 1debcdcb8..47cf02848 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,5 +1,5 @@
-#ifndef DEVICEHANDLERBASE_H_
-#define DEVICEHANDLERBASE_H_
+#ifndef DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#define DEVICEHANDLERS_DEVICEHANDLERBASE_H_
 
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/tasks/ExecutableObjectIF.h>
@@ -11,12 +11,14 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/power/PowerSwitchIF.h>
 #include <framework/ipc/MessageQueueIF.h>
+#include <framework/housekeeping/HasHkPoolParametersIF.h>
 
 #include <framework/action/ActionHelper.h>
 #include <framework/health/HealthHelper.h>
 #include <framework/parameters/ParameterHelper.h>
 #include <framework/datapool/HkSwitchHelper.h>
 #include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
+#include <framework/housekeeping/HousekeepingManager.h>
 
 #include <map>
 
@@ -46,14 +48,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()
@@ -82,7 +86,8 @@ class DeviceHandlerBase: public DeviceHandlerIF,
 		public HasModesIF,
 		public HasHealthIF,
 		public HasActionsIF,
-		public ReceivesParameterMessagesIF {
+		public ReceivesParameterMessagesIF,
+		public HasHkPoolParametersIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	/**
@@ -150,11 +155,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
@@ -322,12 +325,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.
@@ -382,7 +384,7 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0,
+			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = 0,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
 	/**
@@ -396,7 +398,7 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0);
+			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = 0);
 
 	/**
 	 * @brief 	A simple command to add a command to the commandList.
@@ -422,7 +424,7 @@ protected:
 	 */
 	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
 			uint16_t delayCycles, uint16_t maxDelayCycles,
-			uint8_t periodic = 0);
+			bool periodic = 0);
 
 	/**
 	 * @brief   Can be implemented by child handler to
@@ -471,6 +473,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 initializeHousekeepingPoolEntries(
+				LocalDataPoolMap& localDataPoolMap) override;
+
+	/** Get the HK manager object handle */
+	virtual HousekeepingManager* getHkManagerHandle() override;
+
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
 	 * 			performOperation(). Default implementation is empty.
@@ -528,114 +542,136 @@ 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;
-
 	/**
-	 * 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;
-
 	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 */
+	HousekeepingManager 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.
-		uint8_t 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;
+		//! 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;
+		//! 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;
 
 	/**
@@ -652,15 +688,6 @@ protected:
 	 */
 	uint32_t deviceThermalRequestPoolId;
 
-	/**
-	 * Taking care of the health
-	 */
-	HealthHelper healthHelper;
-
-	ModeHelper modeHelper;
-
-	ParameterHelper parameterHelper;
-
 	/**
 	 * Optional Error code
 	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
@@ -966,24 +993,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:
 
 	/**
@@ -1016,6 +1030,9 @@ private:
 	 */
 	CookieInfo cookieInfo;
 
+	/** the object used to set power switches*/
+	PowerSwitchIF *powerSwitcher = nullptr;
+
 	/**
 	 * Used for timing out mode transitions.
 	 *
@@ -1148,12 +1165,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!!!
@@ -1178,6 +1189,10 @@ private:
 	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
+
+	void parseReply(const uint8_t* receivedData,
+			size_t receivedDataLen);
+	DataSetIF* getDataSetHandle(sid_t sid) override;
 };
 
 #endif /* DEVICEHANDLERBASE_H_ */
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 65c40219a..9bc2cbe8c 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -7,13 +7,15 @@
 
 object_id_t DeviceHandlerFailureIsolation::powerConfirmationId = 0;
 
-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(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() {
@@ -68,9 +70,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(hasPowerConfirmation) {
+			result = sendConfirmationRequest(event, powerConfirmation);
+			if (result == RETURN_OK) {
+				setFdirState(DEVICE_MIGHT_BE_OFF);
+			}
 		}
 		break;
 	case Fuse::FUSE_WENT_OFF:
@@ -142,7 +146,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)) {
@@ -162,10 +167,11 @@ ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
 	}
 	ConfirmsFailuresIF* power = objectManager->get<ConfirmsFailuresIF>(
 			powerConfirmationId);
-	if (power == NULL) {
-		return RETURN_FAILED;
+	if (power != nullptr) {
+		powerConfirmation = power->getEventReceptionQueue();
+		hasPowerConfirmation = true;
 	}
-	powerConfirmation = power->getEventReceptionQueue();
+
 	return RETURN_OK;
 }
 
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.h b/devicehandlers/DeviceHandlerFailureIsolation.h
index 91f6ef64a..379edae31 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.h
+++ b/devicehandlers/DeviceHandlerFailureIsolation.h
@@ -28,6 +28,7 @@ protected:
 		NONE, RECOVERY_ONGOING, DEVICE_MIGHT_BE_OFF, AWAIT_SHUTDOWN
 	};
 	FDIRState fdirState;
+	bool hasPowerConfirmation = false;
 	MessageQueueId_t powerConfirmation;
 	static object_id_t powerConfirmationId;
 	static const uint32_t MAX_REBOOT = 1;

From b4561465ba273718f03b8f32e73eb4d5ffcb7610 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 01:36:07 +0200
Subject: [PATCH 0390/1774] some little form improvements

---
 devicehandlers/DeviceHandlerBase.h   | 4 ++--
 framework.mk                         | 4 ++--
 housekeeping/HasHkPoolParametersIF.h | 1 -
 housekeeping/HousekeepingMessage.h   | 1 +
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 47cf02848..9b2bcdf42 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,5 +1,5 @@
-#ifndef DEVICEHANDLERS_DEVICEHANDLERBASE_H_
-#define DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
 
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/tasks/ExecutableObjectIF.h>
diff --git a/framework.mk b/framework.mk
index 404055eec..c88229814 100644
--- a/framework.mk
+++ b/framework.mk
@@ -1,5 +1,5 @@
-# This file needs FRAMEWORK_PATH and API set correctly
-# Valid API settings: rtems, linux, freeRTOS
+# This file needs FRAMEWORK_PATH and OS_FSFW set correctly by another Makefile.
+# Valid API settings: rtems, linux, freeRTOS, host
 
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/action/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/container/*.cpp)
diff --git a/housekeeping/HasHkPoolParametersIF.h b/housekeeping/HasHkPoolParametersIF.h
index 62715a3d4..9efc6d162 100644
--- a/housekeeping/HasHkPoolParametersIF.h
+++ b/housekeeping/HasHkPoolParametersIF.h
@@ -40,7 +40,6 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual ReturnValue_t initializeHousekeepingPoolEntries(
 			LocalDataPoolMap& localDataPoolMap) = 0;
-	//virtual float setMinimalHkSamplingFrequency() = 0;
 	virtual HousekeepingManager* getHkManagerHandle() = 0;
 	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
 };
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index e7ba68ba7..61e6e199e 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -19,6 +19,7 @@ union sid_t {
 	 */
 	uint64_t raw;
 };
+
 class HousekeepingMessage {
 public:
 	/**

From 8e7593d68a8bf7f909cf87f2daea6625c6ef4010 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 02:10:21 +0200
Subject: [PATCH 0391/1774] removed error handling in separate fnctn

---
 osal/linux/MessageQueue.cpp | 74 ++++++++++++++++++++-----------------
 osal/linux/MessageQueue.h   |  4 ++
 2 files changed, 45 insertions(+), 33 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 48ba29e80..d12fa720e 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,14 +1,14 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/osal/linux/MessageQueue.h>
 #include <fcntl.h>           /* For O_* constants */
 #include <sys/stat.h>        /* For mode constants */
-#include <mqueue.h>
 #include <cstring>
 #include <errno.h>
-#include <framework/osal/linux/MessageQueue.h>
 
 
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
-		id(0), lastPartner(0), defaultDestination(NO_QUEUE) {
+
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize): id(0),
+		lastPartner(0), defaultDestination(NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
 	this->id = 0;
@@ -17,40 +17,17 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 	attributes.mq_maxmsg = messageDepth;
 	attributes.mq_msgsize = maxMessageSize;
 	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
-	//Set the name of the queue
+	//Set the name of the queue. The slash is mandatory!
 	sprintf(name, "/Q%u\n", queueCounter++);
 
-	//Create a nonblocking queue if the name is available (the queue is Read and
-	// writable for the owner as well as the group)
+	// Create a nonblocking queue if the name is available (the queue is read
+	// and writable for the owner as well as the group)
 	mqd_t tempId = mq_open(name, O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
 	S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH, &attributes);
 	if (tempId == -1) {
-		//An error occured during open
-		//We need to distinguish if it is caused by an already created queue
-		if (errno == EEXIST) {
-			//There's another queue with the same name
-			//We unlink the other queue
-			int status = mq_unlink(name);
-			if (status != 0) {
-				sif::error << "mq_unlink Failed with status: " << strerror(errno)
-						   << std::endl;
-			} else {
-				//Successful unlinking, try to open again
-				mqd_t tempId = mq_open(name,
-				O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-				S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, &attributes);
-				if (tempId != -1) {
-					//Successful mq_open
-					this->id = tempId;
-					return;
-				}
-			}
-		}
-		//Failed either the first time or the second time
-		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-				<< name << std::dec << " failed with status: "
-				<< strerror(errno) << std::endl;
-	} else {
+		ReturnValue_t result = handleError(&attributes);
+	}
+	else {
 		//Successful mq_open call
 		this->id = tempId;
 	}
@@ -69,6 +46,37 @@ MessageQueue::~MessageQueue() {
 	}
 }
 
+ReturnValue_t MessageQueue::handleError(mq_attr* attributes) {
+	// An error occured during open
+	// We need to distinguish if it is caused by an already created queue
+	if (errno == EEXIST) {
+		//There's another queue with the same name
+		//We unlink the other queue
+		int status = mq_unlink(name);
+		if (status != 0) {
+			sif::error << "mq_unlink Failed with status: " << strerror(errno)
+					<< std::endl;
+		}
+		else {
+			// Successful unlinking, try to open again
+			mqd_t tempId = mq_open(name,
+					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
+			if (tempId != -1) {
+				//Successful mq_open
+				this->id = tempId;
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+		// Failed either the first time or the second time
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+				<< name << std::dec << " failed with status: "
+				<< strerror(errno) << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+}
+
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), false);
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index fdc8dab19..b44ed5c7b 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -4,6 +4,8 @@
 #include <framework/internalError/InternalErrorReporterIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MessageQueueMessage.h>
+
+#include <mqueue.h>
 /**
  * @brief		This class manages sending and receiving of message queue messages.
  *
@@ -172,6 +174,8 @@ private:
 	char name[5];
 
 	static uint16_t queueCounter;
+
+	ReturnValue_t handleError(mq_attr* attributes);
 };
 
 #endif /* MESSAGEQUEUE_H_ */

From d35524ecbcbcd49d8f95e37180c787f606fad493 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 12:41:17 +0200
Subject: [PATCH 0392/1774] decoupling from raw reciever, linux mq improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 67 +++++++++++++++++-----------
 devicehandlers/DeviceHandlerBase.h   |  2 +-
 health/HealthHelper.cpp              |  1 +
 osal/linux/MessageQueue.cpp          | 62 +++++++++++++++----------
 osal/linux/MessageQueue.h            |  2 +-
 5 files changed, 82 insertions(+), 52 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1e3bb16e8..d738b3f95 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -15,7 +15,7 @@
 #include <iomanip>
 
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
+object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
@@ -36,7 +36,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		childTransitionDelay(5000),
 		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
 		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
+	commandQueue = QueueFactory::instance()->createMessageQueue(1,
 			CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
@@ -121,15 +121,16 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return RETURN_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 == NULL) {
+			return RETURN_FAILED;
+		}
+		defaultRawReceiver = rawReceiver->getDeviceQueue();
 	}
 
-	defaultRawReceiver = rawReceiver->getDeviceQueue();
-
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == NULL) {
@@ -139,6 +140,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	result = healthHelper.initialize();
 	if (result != RETURN_OK) {
+		sif::error << "DeviceHandlerBase::initialize: Health Helper "
+				"initialization failure" << std::endl;
 		return result;
 	}
 
@@ -614,7 +617,7 @@ void DeviceHandlerBase::doGetRead() {
 		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
 	}
 
-	if (mode == MODE_RAW) {
+	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
 		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
 	}
 	else {
@@ -727,7 +730,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 == NULL || len == 0 || sendTo == MessageQueueIF::NO_QUEUE) {
 		return;
 	}
 	store_address_t address;
@@ -1131,35 +1134,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 GlobDataSet 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) {
 		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
 		if (dataSet != NULL) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 9b2bcdf42..3a43fa741 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -577,7 +577,7 @@ protected:
 	 * 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;
 
 	/**
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index b7d54dc18..3a345287e 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -40,6 +40,7 @@ void HealthHelper::setParentQeueue(MessageQueueId_t parentQueue) {
 ReturnValue_t HealthHelper::initialize() {
 	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
 	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
+	// TODO: Better returnvalues
 	if ((healthTable == NULL) || eventSender == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index d12fa720e..08a9ab20b 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -7,7 +7,7 @@
 
 
 
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize): id(0),
+MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize): id(0),
 		lastPartner(0), defaultDestination(NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
@@ -25,7 +25,7 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize): id(0),
 	mqd_t tempId = mq_open(name, O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
 	S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH, &attributes);
 	if (tempId == -1) {
-		ReturnValue_t result = handleError(&attributes);
+		handleError(&attributes);
 	}
 	else {
 		//Successful mq_open call
@@ -47,33 +47,47 @@ MessageQueue::~MessageQueue() {
 }
 
 ReturnValue_t MessageQueue::handleError(mq_attr* attributes) {
-	// An error occured during open
-	// We need to distinguish if it is caused by an already created queue
-	if (errno == EEXIST) {
-		//There's another queue with the same name
-		//We unlink the other queue
-		int status = mq_unlink(name);
-		if (status != 0) {
-			sif::error << "mq_unlink Failed with status: " << strerror(errno)
-					<< std::endl;
-		}
-		else {
-			// Successful unlinking, try to open again
-			mqd_t tempId = mq_open(name,
-					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
-			if (tempId != -1) {
-				//Successful mq_open
-				this->id = tempId;
-				return HasReturnvaluesIF::RETURN_OK;
+	switch(errno) {
+	case(EINVAL): {
+		sif::error << "MessageQueue::MessageQueue: Invalid Name " << std::endl;
+		break;
+	}
+	case(EEXIST): {
+		// An error occured during open
+		// We need to distinguish if it is caused by an already created queue
+		if (errno == EEXIST) {
+			//There's another queue with the same name
+			//We unlink the other queue
+			int status = mq_unlink(name);
+			if (status != 0) {
+				sif::error << "mq_unlink Failed with status: " << strerror(errno)
+											<< std::endl;
+			}
+			else {
+				// Successful unlinking, try to open again
+				mqd_t tempId = mq_open(name,
+						O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+						S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
+				if (tempId != -1) {
+					//Successful mq_open
+					this->id = tempId;
+					return HasReturnvaluesIF::RETURN_OK;
+				}
 			}
 		}
+		break;
+	}
+
+	default:
 		// Failed either the first time or the second time
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-				<< name << std::dec << " failed with status: "
-				<< strerror(errno) << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
+		<< name << std::dec << " failed with status: "
+		<< strerror(errno) << std::endl;
+
 	}
+	return HasReturnvaluesIF::RETURN_FAILED;
+
+
 
 }
 
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index b44ed5c7b..debf9cd15 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -40,7 +40,7 @@ public:
 	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
 	 * 							This should be left default.
 	 */
-	MessageQueue(size_t messageDepth = 3,
+	MessageQueue(uint32_t messageDepth = 3,
 			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
 	/**
 	 * @brief	The destructor deletes the formerly created message queue.

From 5289497ab5769fc61ba1816322c4f86377cfd36f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 12:59:43 +0200
Subject: [PATCH 0393/1774] health helper optional, diagnostic output improved

---
 devicehandlers/DeviceHandlerBase.cpp          | 39 ++++++++++++++-----
 devicehandlers/DeviceHandlerBase.h            |  1 +
 .../DeviceHandlerFailureIsolation.cpp         |  2 +
 fdir/FailureIsolationBase.cpp                 |  4 +-
 objectmanager/ObjectManager.cpp               |  7 ++--
 5 files changed, 39 insertions(+), 14 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d738b3f95..c73cf618d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -139,10 +139,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	}
 
 	result = healthHelper.initialize();
-	if (result != RETURN_OK) {
-		sif::error << "DeviceHandlerBase::initialize: Health Helper "
-				"initialization failure" << std::endl;
-		return result;
+	if (result == RETURN_OK) {
+		healthHelperActive = true;
+	}
+	else {
+		sif::warning << "DeviceHandlerBase::initialize: Health Helper "
+				"initialization failure." << std::endl;
 	}
 
 	result = modeHelper.initialize();
@@ -215,9 +217,11 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	result = healthHelper.handleHealthCommand(&message);
-	if (result == RETURN_OK) {
-		return;
+	if(healthHelperActive) {
+		result = healthHelper.handleHealthCommand(&message);
+		if (result == RETURN_OK) {
+			return;
+		}
 	}
 
 	result = modeHelper.handleModeCommand(&message);
@@ -996,7 +1000,9 @@ void DeviceHandlerBase::getMode(Mode_t* mode, Submode_t* submode) {
 }
 
 void DeviceHandlerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
+	if(healthHelperActive) {
+		healthHelper.setHealth(EXTERNAL_CONTROL);
+	}
 }
 
 void DeviceHandlerBase::announceMode(bool recursive) {
@@ -1016,11 +1022,24 @@ void DeviceHandlerBase::missedReply(DeviceCommandId_t id) {
 }
 
 HasHealthIF::HealthState DeviceHandlerBase::getHealth() {
-	return healthHelper.getHealth();
+	if(healthHelperActive) {
+		return healthHelper.getHealth();
+	}
+	else {
+		sif::warning << "DeviceHandlerBase::getHealth: Health helper not active"
+				<< std::endl;
+		return HasHealthIF::HEALTHY;
+	}
 }
 
 ReturnValue_t DeviceHandlerBase::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
+	if(healthHelperActive) {
+		healthHelper.setHealth(health);
+	}
+	else {
+		sif::warning << "DeviceHandlerBase::getHealth: Health helper not active"
+				<< std::endl;
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3a43fa741..b079e4691 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -601,6 +601,7 @@ protected:
 
 	/** Health helper for HasHealthIF */
 	HealthHelper healthHelper;
+	bool healthHelperActive = false;
 	/** Mode helper for HasModesIF */
 	ModeHelper modeHelper;
 	/** Parameter helper for ReceivesParameterMessagesIF */
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 9bc2cbe8c..1df2afa0e 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -163,6 +163,8 @@ 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>(
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index c65640c27..461144676 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -19,7 +19,9 @@ 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());
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 2f47950fa..fe7adb253 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -69,9 +69,10 @@ void ObjectManager::initialize() {
 		return_value = it.second->initialize();
 		if ( return_value != RETURN_OK ) {
 			object_id_t var = it.first;
-			sif::error << "Object 0x" << std::hex <<  std::setw(8) <<
-					std::setfill('0')<< var << " failed to initialize " <<
-					"with code 0x" << return_value << std::dec << std::endl;
+			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
+					std::setw(8) << std::setfill('0')<< var << " failed to "
+					"initialize with code 0x" << return_value << std::dec <<
+					std::endl;
 			error_count++;
 		}
 	}

From 04236859daecfcde5ed24829623d0a5dbf5da070 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 13:03:37 +0200
Subject: [PATCH 0394/1774] slight improvements to diagnostic ouput

---
 objectmanager/ObjectManager.cpp | 41 ++++++++++++++++-----------------
 1 file changed, 20 insertions(+), 21 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index fe7adb253..606cd369a 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -58,44 +58,43 @@ ObjectManager::ObjectManager() : produceObjects(nullptr) {
 
 void ObjectManager::initialize() {
 	if(produceObjects == nullptr) {
-		sif::error << "ObjectManager: Passed produceObjects functions is"
-				"nullptr!" << std::endl;
+		sif::error << "ObjectManager::initialize: Passed produceObjects "
+				"functions is nullptr!" << std::endl;
 		return;
 	}
 	this->produceObjects();
-	ReturnValue_t return_value = RETURN_FAILED;
-	uint32_t error_count = 0;
+	ReturnValue_t result = RETURN_FAILED;
+	uint32_t errorCount = 0;
 	for (auto const& it : objectList) {
-		return_value = it.second->initialize();
-		if ( return_value != RETURN_OK ) {
+		result = it.second->initialize();
+		if ( result != RETURN_OK ) {
 			object_id_t var = it.first;
 			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
 					std::setw(8) << std::setfill('0')<< var << " failed to "
-					"initialize with code 0x" << return_value << std::dec <<
-					std::endl;
-			error_count++;
+					"initialize with code 0x" << result << std::dec <<
+					std::setfill(' ') << std::endl;
+			errorCount++;
 		}
 	}
-	if (error_count > 0) {
-		sif::error << "ObjectManager::ObjectManager: Counted " << error_count
+	if (errorCount > 0) {
+		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
 		           << " failed initializations." << std::endl;
 	}
 	//Init was successful. Now check successful interconnections.
-	error_count = 0;
+	errorCount = 0;
 	for (auto const& it : objectList) {
-		return_value = it.second->checkObjectConnections();
-		if ( return_value != RETURN_OK ) {
-			sif::error << "Object " << std::hex <<  (int) it.first
-			        << " connection check failed with code 0x" << return_value
-			        << std::dec << std::endl;
-			error_count++;
+		result = it.second->checkObjectConnections();
+		if ( result != RETURN_OK ) {
+			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
+					(int) it.first  << " connection check failed with code 0x"
+					<< result << std::dec << std::endl;
+			errorCount++;
 		}
 	}
-	if (error_count > 0) {
-		sif::error << "ObjectManager::ObjectManager: Counted " << error_count
+	if (errorCount > 0) {
+		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
 		           << " failed connection checks." << std::endl;
 	}
-
 }
 
 void ObjectManager::printList() {

From 95bc5a871b6a3e823cc6ed1c7564e3540456fda0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 13:56:35 +0200
Subject: [PATCH 0395/1774] improved diagnostic messages for linux

---
 devicehandlers/DeviceHandlerBase.cpp |  2 +-
 osal/linux/MessageQueue.cpp          | 32 ++++++++++++++++++++++------
 osal/linux/MessageQueue.h            |  2 +-
 osal/linux/PosixThread.cpp           |  2 +-
 4 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index c73cf618d..965959af6 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -36,7 +36,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		childTransitionDelay(5000),
 		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
 		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(1,
+	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 08a9ab20b..493c2acab 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,12 +1,14 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/linux/MessageQueue.h>
+
+#include <fstream>
+
 #include <fcntl.h>           /* For O_* constants */
 #include <sys/stat.h>        /* For mode constants */
 #include <cstring>
 #include <errno.h>
 
 
-
 MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize): id(0),
 		lastPartner(0), defaultDestination(NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
@@ -22,10 +24,11 @@ MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize): id(0),
 
 	// Create a nonblocking queue if the name is available (the queue is read
 	// and writable for the owner as well as the group)
-	mqd_t tempId = mq_open(name, O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-	S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH, &attributes);
+	int oflag = O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL;
+	mode_t mode = S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH;
+	mqd_t tempId = mq_open(name, oflag, mode, &attributes);
 	if (tempId == -1) {
-		handleError(&attributes);
+		handleError(&attributes, messageDepth);
 	}
 	else {
 		//Successful mq_open call
@@ -46,10 +49,27 @@ MessageQueue::~MessageQueue() {
 	}
 }
 
-ReturnValue_t MessageQueue::handleError(mq_attr* attributes) {
+ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
+		uint32_t messageDepth) {
 	switch(errno) {
 	case(EINVAL): {
-		sif::error << "MessageQueue::MessageQueue: Invalid Name " << std::endl;
+		sif::error << "MessageQueue::MessageQueue: Invalid Name or attributes"
+				" for message size" << std::endl;
+		size_t defaultMqMaxMsg;
+		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
+				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
+			// See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
+			// This happens if the msg_max value is not large enough
+			// It is ignored if the executable is run in privileged mode.
+			// Run the unlockRealtime script or grant the mode manully by using:
+			// sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
+
+			// Permanent solution:
+			// echo msg_max | sudo tee /proc/sys/fs/mqueue/msg_max
+			sif::error << "MessageQueue::MessageQueue: Default MQ size "
+					<< defaultMqMaxMsg << " is too small for requested size "
+					<< messageDepth << std::endl;
+		}
 		break;
 	}
 	case(EEXIST): {
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index debf9cd15..2808d36e1 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -175,7 +175,7 @@ private:
 
 	static uint16_t queueCounter;
 
-	ReturnValue_t handleError(mq_attr* attributes);
+	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
 };
 
 #endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 899700f0d..e8d624ca6 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -138,7 +138,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	void* sp;
 	status = posix_memalign(&sp, sysconf(_SC_PAGESIZE), stackSize);
 	if(status != 0){
-		sif::error << "Posix Thread stack init failed with: " <<
+		sif::error << "PosixThread::createTask: Stack init failed with: " <<
 				strerror(status) << std::endl;
 	}
 

From 788f7a37459dbd445253c4876da62d0a2298c2d6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 13:59:00 +0200
Subject: [PATCH 0396/1774] better name for mq

---
 osal/linux/MessageQueue.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 493c2acab..2456a329a 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -20,7 +20,7 @@ MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize): id(0),
 	attributes.mq_msgsize = maxMessageSize;
 	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
 	//Set the name of the queue. The slash is mandatory!
-	sprintf(name, "/Q%u\n", queueCounter++);
+	sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
 
 	// Create a nonblocking queue if the name is available (the queue is read
 	// and writable for the owner as well as the group)
@@ -53,9 +53,9 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		uint32_t messageDepth) {
 	switch(errno) {
 	case(EINVAL): {
-		sif::error << "MessageQueue::MessageQueue: Invalid Name or attributes"
+		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
 				" for message size" << std::endl;
-		size_t defaultMqMaxMsg;
+		size_t defaultMqMaxMsg = 0;
 		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
 				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
 			// See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html

From 212cd58f9a7a8c7b1ed86b5a4b4f46c09f645022 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 14:45:45 +0200
Subject: [PATCH 0397/1774] issues with fixed timeslo ttask on linux

---
 osal/linux/MessageQueue.cpp |  2 +-
 osal/linux/PosixThread.cpp  | 26 +++++++++++++++++---------
 osal/linux/PosixThread.h    |  2 +-
 osal/linux/TaskFactory.cpp  | 16 ++++++++++++----
 4 files changed, 31 insertions(+), 15 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 2456a329a..86d1e0d99 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -64,7 +64,7 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 			// Run the unlockRealtime script or grant the mode manully by using:
 			// sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
 
-			// Permanent solution:
+			// Permanent solution (EventManager has mq depth of 80):
 			// echo msg_max | sudo tee /proc/sys/fs/mqueue/msg_max
 			sif::error << "MessageQueue::MessageQueue: Default MQ size "
 					<< defaultMqMaxMsg << " is too small for requested size "
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index e8d624ca6..cfc3ed4dd 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -3,6 +3,10 @@
 #include <errno.h>
 #include <framework/osal/linux/PosixThread.h>
 
+PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
+		thread(0),priority(priority_),stackSize(stackSize_) {
+	strcpy(name,name_);
+}
 
 PosixThread::~PosixThread() {
 	//No deletion and no free of Stack Pointer
@@ -113,12 +117,6 @@ uint64_t PosixThread::getCurrentMonotonicTimeMs(){
 	return currentTime_ms;
 }
 
-PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
-		thread(0),priority(priority_),stackSize(stackSize_) {
-	strcpy(name,name_);
-}
-
-
 
 void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	//sif::debug << "PosixThread::createTask" << std::endl;
@@ -135,14 +133,24 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 		sif::error << "Posix Thread attribute init failed with: " <<
 				strerror(status) << std::endl;
 	}
-	void* sp;
-	status = posix_memalign(&sp, sysconf(_SC_PAGESIZE), stackSize);
+	void* stackPointer;
+	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
 	if(status != 0){
 		sif::error << "PosixThread::createTask: Stack init failed with: " <<
 				strerror(status) << std::endl;
+		if(errno == ENOMEM) {
+			double stackMb = (double)((double)stackSize/(double)10e6);
+			sif::error << "PosixThread::createTask: Insufficient memory for"
+					" the requested " << stackMb << " MB" << std::endl;
+		}
+		else if(errno == EINVAL) {
+			sif::error << "PosixThread::createTask: Wrong alignment argument!"
+					<< std::endl;
+		}
+		return;
 	}
 
-	status = pthread_attr_setstack(&attributes, sp, stackSize);
+	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
 	if(status != 0){
 		sif::error << "Posix Thread attribute setStack failed with: " <<
 				strerror(status) << std::endl;
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index d96c4156e..f10352b45 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -68,7 +68,7 @@ protected:
 private:
 	char name[10];
 	int priority;
-	size_t stackSize;
+	size_t stackSize = 0;
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */
diff --git a/osal/linux/TaskFactory.cpp b/osal/linux/TaskFactory.cpp
index 44f46d90b..219630a7e 100644
--- a/osal/linux/TaskFactory.cpp
+++ b/osal/linux/TaskFactory.cpp
@@ -13,12 +13,20 @@ TaskFactory* TaskFactory::instance() {
 	return TaskFactory::factoryInstance;
 }
 
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return static_cast<PeriodicTaskIF*>(new PeriodicPosixTask(name_, taskPriority_,stackSize_,periodInSeconds_ * 1000,deadLineMissedFunction_));
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new PeriodicPosixTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_ * 1000, deadLineMissedFunction_);
 }
 
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return static_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_, taskPriority_,stackSize_,periodInSeconds_*1000));
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new FixedTimeslotTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_*1000);
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {

From ef01b7814064e6847ce8e90ea00e8ea09bb36111 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 15:01:57 +0200
Subject: [PATCH 0398/1774] some issue with stack size ..

---
 osal/linux/PeriodicPosixTask.cpp |  3 ++-
 osal/linux/PosixThread.cpp       |  3 +++
 osal/linux/PosixThread.h         | 19 +++++++++++--------
 3 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index f6a74901c..df5bbf930 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -38,7 +38,8 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
 
 ReturnValue_t PeriodicPosixTask::startTask(void){
 	started = true;
-	createTask(&taskEntryPoint,this);
+	//sif::info << stackSize << std::endl;
+	PosixThread::createTask(&taskEntryPoint,this);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index cfc3ed4dd..5f91858f5 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -128,6 +128,9 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
        default attributes.
 	 */
 	pthread_attr_t attributes;
+	//PeriodicPosixTask* task = reinterpret_cast<PeriodicPosixTask*>(arg_);
+	//sif::info << task->stackSize << std::endl;
+	sif::info << stackSize << std::endl;
 	int status = pthread_attr_init(&attributes);
 	if(status != 0){
 		sif::error << "Posix Thread attribute init failed with: " <<
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index f10352b45..ad403ac4f 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -54,14 +54,17 @@ protected:
 	pthread_t thread;
 
 	/**
-	 * @brief Function that has to be called by derived class because the derived class pointer has to be valid as argument
-	 * @details This function creates a pthread with the given parameters. As the function requires a pointer to the derived object
-	 * 			it has to be called after the this pointer of the derived object is valid. Sets the taskEntryPoint as
-	 * 			function to be called by new a thread.
-	 * @param name_ Name of the task
-	 * @param priority_ Priority of the task according to POSIX
-	 * @param stackSize_ Size of the stack attached to that task
-	 * @param arg_ argument of the taskEntryPoint function, needs to be this pointer of derived class
+	 * @brief 	Function that has to be called by derived class because the
+	 *  		derived class pointer has to be valid as argument
+	 * @details
+	 * This function creates a pthread with the given parameters. As the
+	 * function requires a pointer to the derived object it has to be called
+	 * after the this pointer of the derived object is valid.
+	 * Sets the taskEntryPoint as function to be called by new a thread.
+	 * @param fnc_ Function which will be executed by the thread.
+	 * @param arg_
+	 * argument of the taskEntryPoint function, needs to be this pointer
+	 * of derived class
 	 */
 	void createTask(void* (*fnc_)(void*),void* arg_);
 

From b0634ab0a2f53fc7e1e194391f7ef4da80077931 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 15:26:22 +0200
Subject: [PATCH 0399/1774] fixed bug (critical!)

---
 osal/linux/FixedTimeslotTask.h | 22 +++++++++++++---------
 osal/linux/PosixThread.cpp     | 22 +++++++++++++++-------
 osal/linux/PosixThread.h       |  2 +-
 3 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 6350f3472..6d523ba97 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -8,7 +8,8 @@
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
 public:
-	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_, uint32_t periodMs_);
+	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t periodMs_);
 	virtual ~FixedTimeslotTask();
 
 	virtual ReturnValue_t startTask();
@@ -17,7 +18,9 @@ public:
 
 	virtual uint32_t getPeriodMs() const;
 
-	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+			int8_t executionStep);
+
 	virtual ReturnValue_t checkSequence() const;
 
 	/**
@@ -34,11 +37,10 @@ public:
 protected:
 	/**
 	 * @brief	This function holds the main functionality of the thread.
-	 *
-	 *
-	 * @details	Holding the main functionality of the task, this method is most important.
-	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
-	 * 			to keep the timing of the periods.
+	 * @details
+	 * Holding the main functionality of the task, this method is most important.
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
 	 */
 	virtual void taskFunctionality();
 
@@ -46,8 +48,10 @@ private:
 	/**
 	 * @brief	This is the entry point in a new thread.
 	 *
-	 * @details	This method, that is the entry point in the new thread and calls taskFunctionality of the child class.
-	 * 			Needs a valid pointer to the derived class.
+	 * @details
+	 * This method, that is the entry point in the new thread and calls
+	 * taskFunctionality of the child class. Needs a valid pointer to the
+	 * derived class.
 	 */
 	static void* taskEntryPoint(void* arg);
 	FixedSlotSequence pst;
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 5f91858f5..24545f6f2 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,11 +1,11 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/osal/linux/PosixThread.h>
 #include <cstring>
 #include <errno.h>
-#include <framework/osal/linux/PosixThread.h>
 
 PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
 		thread(0),priority(priority_),stackSize(stackSize_) {
-	strcpy(name,name_);
+	strncpy(name,name_,16);
 }
 
 PosixThread::~PosixThread() {
@@ -128,9 +128,6 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
        default attributes.
 	 */
 	pthread_attr_t attributes;
-	//PeriodicPosixTask* task = reinterpret_cast<PeriodicPosixTask*>(arg_);
-	//sif::info << task->stackSize << std::endl;
-	sif::info << stackSize << std::endl;
 	int status = pthread_attr_init(&attributes);
 	if(status != 0){
 		sif::error << "Posix Thread attribute init failed with: " <<
@@ -142,7 +139,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 		sif::error << "PosixThread::createTask: Stack init failed with: " <<
 				strerror(status) << std::endl;
 		if(errno == ENOMEM) {
-			double stackMb = (double)((double)stackSize/(double)10e6);
+			uint64_t stackMb = stackSize/10e6;
 			sif::error << "PosixThread::createTask: Insufficient memory for"
 					" the requested " << stackMb << " MB" << std::endl;
 		}
@@ -199,8 +196,19 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_setname_np(thread,name);
 	if(status != 0){
-		sif::error << "Posix Thread setname failed with: " <<
+		sif::error << "PosixThread::createTask: setname failed with: " <<
 				strerror(status) << std::endl;
+		if(status == ERANGE) {
+			sif::error << "PosixThread::createTask: Task name length longer"
+					" than 16 chars. Truncating.." << std::endl;
+			name[15] = '\0';
+			status = pthread_setname_np(thread,name);
+			if(status != 0){
+				sif::error << "PosixThread::createTask: Setting name"
+						" did not work.." << std::endl;
+			}
+		}
+
 	}
 
 	status = pthread_attr_destroy(&attributes);
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index ad403ac4f..488e19863 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -69,7 +69,7 @@ protected:
 	void createTask(void* (*fnc_)(void*),void* arg_);
 
 private:
-	char name[10];
+	char name[16];
 	int priority;
 	size_t stackSize = 0;
 };

From dc9ef41bec99951a0012cfa1a6ae17edfbff5bd5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 15:31:45 +0200
Subject: [PATCH 0400/1774] added doc for linux

---
 osal/linux/FixedTimeslotTask.h | 12 ++++++++++++
 osal/linux/PeriodicPosixTask.h | 13 +++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 6d523ba97..d35b9ecb2 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -8,6 +8,18 @@
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
 public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
 	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
 			uint32_t periodMs_);
 	virtual ~FixedTimeslotTask();
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 43647eda1..85de0d597 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -9,9 +9,22 @@
 
 class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
 public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
 	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
 			uint32_t period_, void(*deadlineMissedFunc_)());
 	virtual ~PeriodicPosixTask();
+
 	/**
 	 * @brief	The method to start the task.
 	 * @details	The method starts the task with the respective system call.

From 096fbec156dc27d269154bebd70b61e9d7ed1c70 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 15:40:10 +0200
Subject: [PATCH 0401/1774] cleaned includesu p a bit

---
 osal/linux/FixedTimeslotTask.cpp | 7 ++-----
 osal/linux/FixedTimeslotTask.h   | 3 +++
 osal/linux/PosixThread.h         | 9 ++++-----
 3 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 098753a7a..e5c68f9dd 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -1,10 +1,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <unistd.h>
-#include <limits.h>
-#include <signal.h>
-#include <errno.h>
 #include <framework/osal/linux/FixedTimeslotTask.h>
 
+#include <limits.h>
 
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
@@ -23,7 +20,7 @@ void* FixedTimeslotTask::taskEntryPoint(void* arg) {
 	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
 	//The task's functionality is called.
 	originalTask->taskFunctionality();
-	return NULL;
+	return nullptr;
 }
 
 ReturnValue_t FixedTimeslotTask::startTask() {
diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index d35b9ecb2..916e6d6cc 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -64,6 +64,9 @@ private:
 	 * This method, that is the entry point in the new thread and calls
 	 * taskFunctionality of the child class. Needs a valid pointer to the
 	 * derived class.
+	 *
+	 * The void* returnvalue is not used yet but could be used to return
+	 * arbitrary data.
 	 */
 	static void* taskEntryPoint(void* arg);
 	FixedSlotSequence pst;
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index 488e19863..07233fe54 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -1,12 +1,11 @@
 #ifndef FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
 #define FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
 
-#include <pthread.h>
-#include <sched.h>
-#include <signal.h>
-#include <stdlib.h>
-#include <unistd.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <pthread.h>
+#include <signal.h>
+#include <cstdlib>
+#include <unistd.h>
 
 class PosixThread {
 public:

From b79efa6d6c87cbb9d122b654b706a0279df093a9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 16:25:06 +0200
Subject: [PATCH 0402/1774] variable for name len

---
 osal/linux/PosixThread.cpp | 2 +-
 osal/linux/PosixThread.h   | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 24545f6f2..3845123c1 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -5,7 +5,7 @@
 
 PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
 		thread(0),priority(priority_),stackSize(stackSize_) {
-	strncpy(name,name_,16);
+	strncpy(name, name_, PTHREAD_MAX_NAMELEN);
 }
 
 PosixThread::~PosixThread() {
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index 07233fe54..e9d317289 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -9,6 +9,7 @@
 
 class PosixThread {
 public:
+	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
 	PosixThread(const char* name_, int priority_, size_t stackSize_);
 	virtual ~PosixThread();
 	/**
@@ -54,7 +55,7 @@ protected:
 
 	/**
 	 * @brief 	Function that has to be called by derived class because the
-	 *  		derived class pointer has to be valid as argument
+	 *  		derived class pointer has to be valid as argument.
 	 * @details
 	 * This function creates a pthread with the given parameters. As the
 	 * function requires a pointer to the derived object it has to be called
@@ -68,7 +69,7 @@ protected:
 	void createTask(void* (*fnc_)(void*),void* arg_);
 
 private:
-	char name[16];
+	char name[PTHREAD_MAX_NAMELEN];
 	int priority;
 	size_t stackSize = 0;
 };

From 262d34174ea9a7bd46b7ffd12b70e9e1258fe063 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 18:56:54 +0200
Subject: [PATCH 0403/1774] using strncat now

---
 osal/linux/PosixThread.cpp | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 3845123c1..bc3e62ed7 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -5,7 +5,8 @@
 
 PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
 		thread(0),priority(priority_),stackSize(stackSize_) {
-	strncpy(name, name_, PTHREAD_MAX_NAMELEN);
+    name[0] = '\0';
+    std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
 }
 
 PosixThread::~PosixThread() {
@@ -59,10 +60,6 @@ void PosixThread::resume(){
 	pthread_kill(thread,SIGUSR1);
 }
 
-
-
-
-
 bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
 		const uint64_t delayTime_ms) {
 	uint64_t nextTimeToWake_ms;
@@ -162,7 +159,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 					strerror(status) << std::endl;
 	}
 
-//TODO FIFO -> This needs root privileges for the process
+	// TODO FIFO -> This needs root privileges for the process
 	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
 	if(status != 0){
 		sif::error << "Posix Thread attribute schedule policy failed with: " <<
@@ -208,7 +205,6 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 						" did not work.." << std::endl;
 			}
 		}
-
 	}
 
 	status = pthread_attr_destroy(&attributes);

From d99be255292e7682bac12dea38258c9cc4eed707 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 20:52:28 +0200
Subject: [PATCH 0404/1774] cookie info iter was uninitialized

leads to crash
---
 devicehandlers/DeviceHandlerBase.cpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 965959af6..30ee03949 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -32,19 +32,20 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		deviceThermalRequestPoolId(thermalRequestPoolId),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
-		switchOffWasReported(false), cookieInfo(),
-		childTransitionDelay(5000),
+		switchOffWasReported(false), childTransitionDelay(5000),
 		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
 		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			CommandMessage::MAX_MESSAGE_SIZE);
-	cookieInfo.state = COOKIE_UNUSED;
 	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 "
-				"passing a dummy cookie instead!" << std::endl;
+				<< std::setfill(' ') << "passing a dummy cookie instead!" <<
+				std::endl;
 	}
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
@@ -571,12 +572,12 @@ void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
 
 	size_t requestLen = 0;
-	DeviceReplyIter iter = deviceReplyMap.find(cookieInfo.pendingCommand->first);
-	if(iter != deviceReplyMap.end()) {
-		requestLen = iter->second.replyLen;
-	}
-	else {
-		requestLen = 0;
+	if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
+		DeviceReplyIter iter = deviceReplyMap.find(
+				cookieInfo.pendingCommand->first);
+		if(iter != deviceReplyMap.end()) {
+			requestLen = iter->second.replyLen;
+		}
 	}
 
 	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);

From ea548dea5bbd969ca17cf9cb48a6b5cfad5e8fda Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 21:16:47 +0200
Subject: [PATCH 0405/1774] map lock init

---
 osal/host/QueueMapManager.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index a57d2c0c0..e7c86f306 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -4,7 +4,9 @@
 
 QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
 
-QueueMapManager::QueueMapManager() {}
+QueueMapManager::QueueMapManager() {
+    mapLock = MutexFactory::instance()->createMutex();
+}
 
 QueueMapManager* QueueMapManager::instance() {
 	if (mqManagerInstance == nullptr){

From 8216b26fdee2f5e7dc552b0d037219149abc7edb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 23:15:05 +0200
Subject: [PATCH 0406/1774] datapoollocal updates

---
 datapoollocal/LocalPoolVariable.h   |  8 +++-----
 datapoollocal/LocalPoolVariable.tpp | 12 ++++++------
 datapoollocal/LocalPoolVector.h     |  6 ++++++
 datapoollocal/LocalPoolVector.tpp   | 15 +++++++++++++++
 4 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index cb373a716..b6bfa5b85 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -131,11 +131,9 @@ protected:
 	ReturnValue_t commitWithoutLock() override;
 
 	// std::ostream is the type for object std::cout
-//	friend std::ostream& operator<< (std::ostream &out,
-//			const LocalPoolVar &var) {
-//		out << static_cast<int>(value);
-//		return out;
-//	}
+	template <typename U>
+	friend std::ostream& operator<< (std::ostream &out,
+			const LocalPoolVar<U> &var);
 
 private:
 	//! @brief 	Pool ID of pool entry inside the used local pool.
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index b7a0e837d..663b73f58 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -151,11 +151,11 @@ inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
 	return AutoSerializeAdapter::deSerialize(&value, buffer, size, bigEndian);
 }
 
-//template<typename T>
-//inline friend std::ostream& LocalPoolVar<T>::operator<< (std::ostream &out,
-//		const LocalPoolVar &var) {
-//	out << static_cast<int>(out);
-//}
-
+template<typename T>
+inline std::ostream& operator<< (std::ostream &out,
+		const LocalPoolVar<T> &var) {
+    out << var.value;
+    return out;
+}
 
 #endif
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 02c471137..746151515 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -5,6 +5,7 @@
 #include <framework/datapool/PoolEntry.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/serialize/SerializeAdapter.h>
+#include <framework/housekeeping/HousekeepingManager.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 
@@ -179,6 +180,11 @@ private:
 	ReadWriteMode_t readWriteMode;
 	//! @brief	Pointer to the class which manages the HK pool.
 	HousekeepingManager* hkManager;
+
+	// std::ostream is the type for object std::cout
+	template <typename U, uint16_t otherSize>
+	friend std::ostream& operator<< (std::ostream &out,
+	        const LocalPoolVector<U, otherSize> &var);
 };
 
 #include <framework/datapoollocal/LocalPoolVector.tpp>
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 78637efff..9a00e5dfd 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -15,6 +15,7 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 				"NO_PARAMETER value!" << std::endl;
 	}
 	memset(this->value, 0, vectorSize * sizeof(T));
+	hkManager = hkOwner->getHkManagerHandle();
 	if (dataSet != nullptr) {
 		dataSet->registerVariable(this);
 	}
@@ -182,4 +183,18 @@ inline bool LocalPoolVector<T, vectorSize>::isValid() const {
 	return valid;
 }
 
+template<typename T, uint16_t vectorSize>
+inline std::ostream& operator<< (std::ostream &out,
+        const LocalPoolVector<T, vectorSize> &var) {
+    out << "Vector: [";
+    for(int i = 0;i < vectorSize; i++) {
+        out << var.value[i];
+        if(i < vectorSize - 1) {
+            out << ", ";
+        }
+    }
+    out << "]";
+    return out;
+}
+
 #endif

From 70212d9f4e979b1092e151cc7cb666b085acddad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 23:15:42 +0200
Subject: [PATCH 0407/1774] slight formatting

---
 housekeeping/HasHkPoolParametersIF.h | 1 +
 housekeeping/HousekeepingMessage.h   | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/housekeeping/HasHkPoolParametersIF.h b/housekeeping/HasHkPoolParametersIF.h
index 9efc6d162..62715a3d4 100644
--- a/housekeeping/HasHkPoolParametersIF.h
+++ b/housekeeping/HasHkPoolParametersIF.h
@@ -40,6 +40,7 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual ReturnValue_t initializeHousekeepingPoolEntries(
 			LocalDataPoolMap& localDataPoolMap) = 0;
+	//virtual float setMinimalHkSamplingFrequency() = 0;
 	virtual HousekeepingManager* getHkManagerHandle() = 0;
 	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
 };
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 61e6e199e..e7ba68ba7 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -19,7 +19,6 @@ union sid_t {
 	 */
 	uint64_t raw;
 };
-
 class HousekeepingMessage {
 public:
 	/**

From 9ed92e5e6f24721446613138f81939c763ae4783 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 23:21:51 +0200
Subject: [PATCH 0408/1774] clock typedefs renamed

---
 timemanager/Clock.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 19991b817..121c63df9 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -8,8 +8,9 @@
 #include <cstdint>
 #include <sys/time.h>
 
-typedef uint32_t millis_t;
-typedef double seconds_t;
+//! Don't use these for time points, type is not large enough for UNIX epoch.
+typedef uint32_t dur_millis_t;
+typedef double dur_seconds_t;
 
 class Clock {
 public:

From 3d8993b0c599636fb7549ade76ca08cb47f0b4f2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 23:23:20 +0200
Subject: [PATCH 0409/1774] new typedef names

---
 timemanager/Stopwatch.cpp | 4 ++--
 timemanager/Stopwatch.h   | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index bc8b4149c..52118d580 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -13,12 +13,12 @@ void Stopwatch::start() {
     Clock::getClock_timeval(&startTime);
 }
 
-millis_t Stopwatch::stop() {
+dur_millis_t Stopwatch::stop() {
     stopInternal();
     return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
 }
 
-seconds_t Stopwatch::stopSeconds() {
+dur_seconds_t Stopwatch::stopSeconds() {
     stopInternal();
     return timevalOperations::toDouble(elapsedTime);
 }
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 71580778f..630202cc1 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -40,12 +40,12 @@ public:
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in milliseconds (rounded)
      */
-    millis_t stop();
+    dur_millis_t stop();
     /**
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in seconds (double precision)
      */
-    seconds_t stopSeconds();
+    dur_seconds_t stopSeconds();
 
     /**
      * Displays the elapsed times on the osstream, depending on internal display

From 65999ac6d6c2d8d1cc1b7b30f38366bf67f96054 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 23:30:16 +0200
Subject: [PATCH 0410/1774] pool var no param is one now

---
 datapool/PoolVariableIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 3086bbe8e..6a2900bfb 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -27,7 +27,7 @@ public:
 
 	static constexpr bool VALID = 1;
 	static constexpr bool INVALID = 0;
-	static constexpr uint32_t NO_PARAMETER = 0;
+	static constexpr uint32_t NO_PARAMETER = 0xffffffff;
 
 	enum ReadWriteMode_t {
 		VAR_READ, VAR_WRITE, VAR_READ_WRITE

From c81613690be10ae70c6e18f373a303d77b80052c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 23:41:54 +0200
Subject: [PATCH 0411/1774] no_queue value is 0xffffffff now

---
 ipc/MessageQueueIF.h              |  2 ++
 ipc/MessageQueueSenderIF.h        |  2 +-
 memory/MemoryHelper.cpp           | 26 ++++++++++++--------------
 tcdistribution/PUSDistributor.cpp | 27 ++++++++++++---------------
 4 files changed, 27 insertions(+), 30 deletions(-)

diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index c67f3870a..480019eb6 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -2,6 +2,8 @@
 #define FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
 
 // COULDDO: We could support blocking calls
+// semaphores are being implemented, which makes this idea even more iteresting.
+
 
 /**
  * @defgroup message_queue Message Queue
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 6eb7733d1..ae66cd12d 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -16,7 +16,7 @@ typedef uint32_t MessageQueueId_t;
 
 class MessageQueueSenderIF {
 public:
-	static const MessageQueueId_t NO_QUEUE = 0;
+	static const MessageQueueId_t NO_QUEUE = 0xffffffff;
 
 	virtual ~MessageQueueSenderIF() {}
 
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 2a830c5a5..b078d6ec4 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -33,15 +33,6 @@ ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
 	}
 }
 
-ReturnValue_t MemoryHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore != NULL) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
 void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
 	busy = false;
@@ -185,11 +176,18 @@ void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
 }
 
 ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
-	if(queueToUse_!=NULL){
-		this->queueToUse = queueToUse_;
-	}else{
-		return MessageQueueIF::NO_QUEUE;
+	if(queueToUse_ == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-
+	this->queueToUse = queueToUse_;
 	return initialize();
 }
+
+ReturnValue_t MemoryHelper::initialize() {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore != nullptr) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index f4764c4e6..bcf6d5717 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -4,15 +4,13 @@
 #include <framework/tmtcpacket/pus/TcPacketStored.h>
 #include <framework/tmtcservices/PusVerificationReport.h>
 
-PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId, object_id_t setPacketSource) :
-		TcDistributor(setObjectId), checker(setApid), verifyChannel(), currentPacket(), tcStatus(
-				RETURN_FAILED), packetSource(setPacketSource) {
+PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+		object_id_t setPacketSource) :
+		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
+		currentPacket(), tcStatus(RETURN_FAILED),
+		packetSource(setPacketSource) {}
 
-}
-
-PUSDistributor::~PUSDistributor() {
-
-}
+PUSDistributor::~PUSDistributor() {}
 
 iterator_t PUSDistributor::selectDestination() {
 //	debug << "PUSDistributor::handlePacket received: " << this->current_packet_id.store_index << ", " << this->current_packet_id.packet_index << std::endl;
@@ -45,18 +43,17 @@ iterator_t PUSDistributor::selectDestination() {
 //}
 
 ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
-	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
 	uint16_t serviceId = service->getIdentifier();
 	//info << "Service ID: " << (int)serviceId << std::endl;
 	MessageQueueId_t queue = service->getRequestQueue();
-	errorCode = this->queueMap.insert(
-			std::pair<uint32_t, MessageQueueId_t>(serviceId, queue)).second;
-	if (errorCode == false) {
+	auto returnPair = queueMap.emplace(serviceId, queue);
+	if (not returnPair.second) {
 		//TODO Return Code
-		returnValue = MessageQueueIF::NO_QUEUE;
+		sif::error << "PUSDistributor::registerService: Service ID already"
+				"exists in map." << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	return returnValue;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 MessageQueueId_t PUSDistributor::getRequestQueue() {

From 33cc8591dc2f2ca920dbe86d05e35f8aa40c736c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 01:17:24 +0200
Subject: [PATCH 0412/1774] yaaay, hardcoded values

---
 health/HealthHelper.cpp        |  5 ++--
 health/HealthHelper.h          | 11 ++++----
 memory/MemoryHelper.cpp        |  8 +++---
 memory/MemoryHelper.h          | 10 +++----
 modes/ModeHelper.cpp           | 48 ++++++++++++++++++++++------------
 modes/ModeHelper.h             |  8 ++++--
 parameters/ParameterHelper.cpp |  4 +--
 parameters/ParameterHelper.h   |  9 ++++---
 8 files changed, 61 insertions(+), 42 deletions(-)

diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index 3a345287e..fdfc09673 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -1,9 +1,8 @@
 #include <framework/health/HealthHelper.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
 #include <framework/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() {
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index 24fd0d14a..a17a69f3f 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -1,11 +1,12 @@
-#ifndef HEALTHHELPER_H_
-#define HEALTHHELPER_H_
+#ifndef FRAMEWORK_HEALTH_HEALTHHELPER_H_
+#define FRAMEWORK_HEALTH_HEALTHHELPER_H_
 
 #include <framework/events/EventManagerIF.h>
 #include <framework/events/EventReportingProxyIF.h>
 #include <framework/health/HasHealthIF.h>
 #include <framework/health/HealthMessage.h>
 #include <framework/health/HealthTableIF.h>
+#include <framework/ipc/MessageQueueIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
@@ -39,12 +40,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 +101,7 @@ private:
 	/**
 	 * The Queue of the parent
 	 */
-	MessageQueueId_t parentQueue;
+	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
 
 	/**
 	 * The one using the healthHelper.
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index b078d6ec4..de6092528 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -5,10 +5,10 @@
 #include <framework/serialize/EndianSwapper.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue) :
-		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(NULL), ipcAddress(), lastCommand(
-				CommandMessage::CMD_NONE), lastSender(0), reservedSpaceInIPC(
-				NULL), busy(false) {
+MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
+		MessageQueueIF* useThisQueue):
+		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(nullptr),
+		ipcAddress(), lastCommand(CommandMessage::CMD_NONE), busy(false) {
 }
 
 ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
diff --git a/memory/MemoryHelper.h b/memory/MemoryHelper.h
index 2ff82eb39..da6b9bdb6 100644
--- a/memory/MemoryHelper.h
+++ b/memory/MemoryHelper.h
@@ -1,5 +1,5 @@
-#ifndef MEMORYHELPER_H_
-#define MEMORYHELPER_H_
+#ifndef FRAMEWORK_MEMORY_MEMORYHELPER_H_
+#define FRAMEWORK_MEMORY_MEMORYHELPER_H_
 #include <framework/ipc/CommandMessage.h>
 #include <framework/memory/AcceptsMemoryMessagesIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
@@ -16,11 +16,11 @@ public:
 private:
 	HasMemoryIF* workOnThis;
 	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore;
+	StorageManagerIF* ipcStore = nullptr;
 	store_address_t ipcAddress;
 	Command_t lastCommand;
-	MessageQueueId_t lastSender;
-	uint8_t* reservedSpaceInIPC;
+	MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
+	uint8_t* reservedSpaceInIPC = nullptr;
 	bool busy;
 	void handleMemoryLoad(CommandMessage* message);
 	void handleMemoryCheckOrDump(CommandMessage* message);
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index d9266c354..66726772f 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,13 +1,11 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/modes/ModeHelper.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 ModeHelper::ModeHelper(HasModesIF *owner) :
-		theOneWhoCommandedAMode(0), commandedMode(HasModesIF::MODE_OFF), commandedSubmode(
-				HasModesIF::SUBMODE_NONE), owner(owner), parentQueueId(0), forced(
-				false) {
-}
+		commandedMode(HasModesIF::MODE_OFF),
+		commandedSubmode(HasModesIF::SUBMODE_NONE),
+		owner(owner), forced(false) {}
 
 ModeHelper::~ModeHelper() {
 
@@ -71,27 +69,45 @@ ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
 	return initialize();
 }
 
-void ModeHelper::modeChanged(Mode_t mode, Submode_t submode) {
+void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
 	forced = false;
+	sendModeReplyMessage(ownerMode, ownerSubmode);
+	sendModeInfoMessage(ownerMode, ownerSubmode);
+	theOneWhoCommandedAMode = MessageQueueSenderIF::NO_QUEUE;
+}
+
+void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
 	CommandMessage reply;
-	if (theOneWhoCommandedAMode != MessageQueueSenderIF::NO_QUEUE) {
-		if ((mode != commandedMode) || (submode != commandedSubmode)) {
+	if (theOneWhoCommandedAMode != MessageQueueSenderIF::NO_QUEUE)
+	{
+		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
+		{
 			ModeMessage::setModeMessage(&reply,
-					ModeMessage::REPLY_WRONG_MODE_REPLY, mode, submode);
-		} else {
+					ModeMessage::REPLY_WRONG_MODE_REPLY, ownerMode,
+					ownerSubmode);
+		}
+		else
+		{
 			ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY,
-					mode, submode);
+					ownerMode, ownerSubmode);
 		}
 		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
 				owner->getCommandQueue());
 	}
+}
+
+void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
+	CommandMessage reply;
 	if (theOneWhoCommandedAMode != parentQueueId
-			&& parentQueueId != MessageQueueSenderIF::NO_QUEUE) {
-		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO, mode,
-				submode);
-		MessageQueueSenderIF::sendMessage(parentQueueId, &reply, owner->getCommandQueue());
+			and parentQueueId != MessageQueueSenderIF::NO_QUEUE)
+	{
+		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
+				ownerMode, ownerSubmode);
+		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
+				owner->getCommandQueue());
 	}
-	theOneWhoCommandedAMode = MessageQueueSenderIF::NO_QUEUE;
 }
 
 void ModeHelper::startTimer(uint32_t timeoutMs) {
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index 87f6d4112..b7f5868d2 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -1,6 +1,7 @@
 #ifndef MODEHELPER_H_
 #define MODEHELPER_H_
 
+#include <framework/ipc/MessageQueueIF.h>
 #include <framework/modes/ModeMessage.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/timemanager/Countdown.h>
@@ -9,7 +10,7 @@ class HasModesIF;
 
 class ModeHelper {
 public:
-	MessageQueueId_t theOneWhoCommandedAMode;
+	MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
 	Mode_t commandedMode;
 	Submode_t commandedSubmode;
 
@@ -39,11 +40,14 @@ public:
 	void setForced(bool forced);
 protected:
 	HasModesIF *owner;
-	MessageQueueId_t parentQueueId;
+	MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
 
 	Countdown countdown;
 
 	bool forced;
+private:
+	void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
+	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
 };
 
 #endif /* MODEHELPER_H_ */
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 4ba2a1d99..e0756882b 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -3,9 +3,7 @@
 #include <framework/parameters/ParameterMessage.h>
 
 ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-		owner(owner), ownerQueueId(0), storage(NULL){
-
-}
+		owner(owner) {}
 
 ParameterHelper::~ParameterHelper() {
 }
diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index e2fefdba0..defe2925e 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -1,6 +1,7 @@
-#ifndef PARAMETERHELPER_H_
-#define PARAMETERHELPER_H_
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
+#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
 
+#include <framework/ipc/MessageQueueIF.h>
 #include <framework/parameters/ParameterMessage.h>
 #include <framework/parameters/ReceivesParameterMessagesIF.h>
 
@@ -15,9 +16,9 @@ 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);
 

From 3c80bdfefa8149823ed9fb6273cabaac3d02ccc0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 01:18:19 +0200
Subject: [PATCH 0413/1774] some linebreaks

---
 parameters/ParameterHelper.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index defe2925e..352cf0a9b 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -20,9 +20,11 @@ private:
 
 	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_ */

From d0b218c18e2cdd65405903626566f5c996064876 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 01:40:48 +0200
Subject: [PATCH 0414/1774] renaming for host os

---
 osal/host/MessageQueue.cpp | 2 +-
 osal/host/MessageQueue.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 7d5e4d97a..7e68fd5bf 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -135,7 +135,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MessageQueue::lockQueue(millis_t lockTimeout) {
+ReturnValue_t MessageQueue::lockQueue(dur_millis_t lockTimeout) {
 	return queueLock->lockMutex(lockTimeout);
 }
 
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
index a0cce0017..619b5e91f 100644
--- a/osal/host/MessageQueue.h
+++ b/osal/host/MessageQueue.h
@@ -182,7 +182,7 @@ public:
 
 	bool isDefaultDestinationSet() const override;
 
-	ReturnValue_t lockQueue(millis_t lockTimeout);
+	ReturnValue_t lockQueue(dur_millis_t lockTimeout);
 	ReturnValue_t unlockQueue();
 protected:
 	/**

From fe5b50d8857bb07d7c84d2a89e8cf79d65f6d7a6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 02:22:18 +0200
Subject: [PATCH 0415/1774] improved documentation signigicantly

---
 datapool/PoolVariableIF.h                     | 14 +++---
 .../LocalDataPoolManager.cpp                  | 25 ++++++-----
 .../LocalDataPoolManager.h                    | 45 +++++++++++++------
 datapoollocal/LocalDataSet.cpp                |  6 +--
 datapoollocal/LocalDataSet.h                  |  8 ++--
 datapoollocal/LocalPoolVariable.h             | 34 ++++++++------
 datapoollocal/LocalPoolVariable.tpp           | 10 ++---
 datapoollocal/LocalPoolVector.h               |  6 +--
 datapoollocal/LocalPoolVector.tpp             |  6 +--
 .../OwnsLocalDataPoolIF.h                     | 33 ++++++++------
 devicehandlers/DeviceHandlerBase.cpp          |  4 +-
 devicehandlers/DeviceHandlerBase.h            | 14 +++---
 12 files changed, 118 insertions(+), 87 deletions(-)
 rename housekeeping/HousekeepingManager.cpp => datapoollocal/LocalDataPoolManager.cpp (69%)
 rename housekeeping/HousekeepingManager.h => datapoollocal/LocalDataPoolManager.h (71%)
 rename housekeeping/HasHkPoolParametersIF.h => datapoollocal/OwnsLocalDataPoolIF.h (58%)

diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 6a2900bfb..30b87839b 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -1,12 +1,12 @@
-#ifndef POOLVARIABLEIF_H_
-#define POOLVARIABLEIF_H_
+#ifndef FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
+#define FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serialize/SerializeIF.h>
 
-
 /**
- * @brief	This interface is used to control data pool variable representations.
+ * @brief	This interface is used to control data pool
+ * 			variable representations.
  * @details
  * To securely handle data pool variables, all pool entries are locally
  * managed by data pool variable access classes, which are called pool
@@ -39,7 +39,8 @@ public:
 	 */
 	virtual ~PoolVariableIF() {}
 	/**
-	 * @brief	This method returns if the variable is write-only, read-write or read-only.
+	 * @brief	This method returns if the variable is write-only,
+	 * 			read-write or read-only.
 	 */
 	virtual ReadWriteMode_t getReadWriteMode() const = 0;
 	/**
@@ -47,7 +48,8 @@ public:
 	 */
 	virtual uint32_t getDataPoolId() const = 0;
 	/**
-	 * @brief	With this call, the valid information of the variable is returned.
+	 * @brief	With this call, the valid information of the
+	 * 			variable is returned.
 	 */
 	virtual bool isValid() const = 0;
 	/**
diff --git a/housekeeping/HousekeepingManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
similarity index 69%
rename from housekeeping/HousekeepingManager.cpp
rename to datapoollocal/LocalDataPoolManager.cpp
index e8edcc397..78e57c8c2 100644
--- a/housekeeping/HousekeepingManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,12 +1,12 @@
+#include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
-#include <framework/housekeeping/HousekeepingManager.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 
 #include <array>
 
-HousekeepingManager::HousekeepingManager(HasHkPoolParametersIF* owner) {
+LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner) {
 	if(owner == nullptr) {
 		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
 		std::exit(0);
@@ -16,11 +16,12 @@ HousekeepingManager::HousekeepingManager(HasHkPoolParametersIF* owner) {
 	//owner->setMinimalHkSamplingFrequency();
 }
 
-HousekeepingManager::~HousekeepingManager() {}
+LocalDataPoolManager::~LocalDataPoolManager() {}
 
-ReturnValue_t HousekeepingManager::initializeHousekeepingPoolEntriesOnce() {
+ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	if(not mapInitialized) {
-		ReturnValue_t result = owner->initializeHousekeepingPoolEntries(localDpMap);
+		ReturnValue_t result =
+				owner->initializeHousekeepingPoolEntries(localDpMap);
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			mapInitialized = true;
 		}
@@ -30,24 +31,24 @@ ReturnValue_t HousekeepingManager::initializeHousekeepingPoolEntriesOnce() {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t HousekeepingManager::handleHousekeepingMessage(
+ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		CommandMessage *message) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t HousekeepingManager::printPoolEntry(
+ReturnValue_t LocalDataPoolManager::printPoolEntry(
 		lp_id_t localPoolId) {
 	auto poolIter = localDpMap.find(localPoolId);
 	if (poolIter == localDpMap.end()) {
 		sif::debug << "HousekeepingManager::fechPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return HasHkPoolParametersIF::POOL_ENTRY_NOT_FOUND;
+		return OwnsLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 	poolIter->second->print();
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-MutexIF* HousekeepingManager::getMutexHandle() {
+MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
@@ -56,7 +57,7 @@ MutexIF* HousekeepingManager::getMutexHandle() {
 //
 //}
 
-void HousekeepingManager::generateHousekeepingPacket(sid_t sid) {
+void LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
@@ -73,10 +74,10 @@ void HousekeepingManager::generateHousekeepingPacket(sid_t sid) {
 
 }
 
-void HousekeepingManager::setHkPacketQueue(MessageQueueIF *msgQueue) {
+void LocalDataPoolManager::setHkPacketQueue(MessageQueueIF *msgQueue) {
 	this->hkPacketQueue = msgQueue;
 }
 
-const HasHkPoolParametersIF* HousekeepingManager::getOwner() const {
+const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 	return owner;
 }
diff --git a/housekeeping/HousekeepingManager.h b/datapoollocal/LocalDataPoolManager.h
similarity index 71%
rename from housekeeping/HousekeepingManager.h
rename to datapoollocal/LocalDataPoolManager.h
index 43922ae68..c8a6bf15b 100644
--- a/housekeeping/HousekeepingManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -2,19 +2,35 @@
 #define FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_
 #include <framework/datapool/DataSetIF.h>
 #include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/housekeeping/HasHkPoolParametersIF.h>
 #include <framework/ipc/MutexIF.h>
 
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <framework/datapool/PoolEntry.h>
+#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MutexHelper.h>
 
 #include <map>
 
-
-class HousekeepingManager {
+/**
+ * @brief 	This class is the managing instance for local data pool.
+ * @details
+ * The actual data pool structure is a member of this class. Any class which
+ * has a local data pool shall have this class as a member and implement
+ * the OwnsLocalDataPoolIF.
+ *
+ * Users of the data pool use the helper classes LocalDataSet,
+ * LocalPoolVariable and LocalPoolVector to access pool entries in
+ * a thread-safe and efficient way.
+ *
+ * The local data pools employ a blackboard logic: Only the most recent
+ * value is stored. The helper classes offer a read() and commit() interface
+ * through the PoolVariableIF which is used to read and update values.
+ * Each pool entry has a valid state too.
+ *
+ */
+class LocalDataPoolManager {
 	template<typename T>
 	friend class LocalPoolVar;
 	template<typename T, uint16_t vecSize>
@@ -23,8 +39,8 @@ class HousekeepingManager {
 public:
 	static constexpr float MINIMAL_SAMPLING_FREQUENCY = 0.2;
 
-	HousekeepingManager(HasHkPoolParametersIF* owner);
-	virtual~ HousekeepingManager();
+	LocalDataPoolManager(OwnsLocalDataPoolIF* owner);
+	virtual~ LocalDataPoolManager();
 
 
 	// propably will just call respective local data set functions.
@@ -40,7 +56,7 @@ public:
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
 	void setHkPacketQueue(MessageQueueIF* msgQueue);
-	const HasHkPoolParametersIF* getOwner() const;
+	const OwnsLocalDataPoolIF* getOwner() const;
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
 
@@ -48,14 +64,14 @@ private:
 	//! This is the map holding the actual data. Should only be initialized
 	//! once !
 	bool mapInitialized = false;
-	LocalDataPoolMap localDpMap;
+	LocalDataPool localDpMap;
 
 	//! Every housekeeping data manager has a mutex to protect access
 	//! to it's data pool.
 	MutexIF * mutex = nullptr;
 
 	//! The class which actually owns the manager (and its datapool).
-	HasHkPoolParametersIF* owner = nullptr;
+	OwnsLocalDataPoolIF* owner = nullptr;
 
 	//! Used for replies.
 	//! (maybe we dont need this, the sender can be retrieved from command
@@ -85,27 +101,28 @@ private:
 	 * 						supplied pointer.
 	 * @return
 	 */
-	template <class T>
-	ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry);
-	void setMinimalSamplingFrequency(float frequencySeconds);
+	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
+			PoolEntry<T> **poolEntry);
 
+	void setMinimalSamplingFrequency(float frequencySeconds);
 };
 
+
 template<class T> inline
-ReturnValue_t HousekeepingManager::fetchPoolEntry(lp_id_t localPoolId,
+ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localDpMap.find(localPoolId);
 	if (poolIter == localDpMap.end()) {
 		sif::debug << "HousekeepingManager::fechPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return HasHkPoolParametersIF::POOL_ENTRY_NOT_FOUND;
+		return OwnsLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
 		sif::debug << "HousekeepingManager::fetchPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return HasHkPoolParametersIF::POOL_ENTRY_TYPE_CONFLICT;
+		return OwnsLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 988f254a0..243c9cc1d 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -1,7 +1,7 @@
+#include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
-#include <framework/housekeeping/HousekeepingManager.h>
 
-LocalDataSet::LocalDataSet(HasHkPoolParametersIF *hkOwner): DataSetBase() {
+LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner): DataSetBase() {
 	if(hkOwner != nullptr) {
 		hkManager = hkOwner->getHkManagerHandle();
 	}
@@ -11,7 +11,7 @@ LocalDataSet::LocalDataSet(HasHkPoolParametersIF *hkOwner): DataSetBase() {
 }
 
 LocalDataSet::LocalDataSet(object_id_t ownerId): DataSetBase()  {
-	HasHkPoolParametersIF* hkOwner = objectManager->get<HasHkPoolParametersIF>(
+	OwnsLocalDataPoolIF* hkOwner = objectManager->get<OwnsLocalDataPoolIF>(
 			ownerId);
 	if(hkOwner == nullptr) {
 		// config error, error output here.
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 607d10b37..54da5562c 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -2,10 +2,10 @@
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
 #include <framework/datapool/DataSetBase.h>
 #include <framework/datapool/DataSetIF.h>
-#include <framework/housekeeping/HasHkPoolParametersIF.h>
+#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/serialize/SerializeIF.h>
 
-class HousekeepingManager;
+class LocalDataPoolManager;
 
 /**
  * @brief	The LocalDataSet class manages a set of locally checked out variables
@@ -35,7 +35,7 @@ public:
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSet(HasHkPoolParametersIF* hkOwner);
+	LocalDataSet(OwnsLocalDataPoolIF* hkOwner);
 
 	/**
 	 * @brief	Constructor for users of local pool data. The passed pool
@@ -78,7 +78,7 @@ private:
 	 */
 	ReturnValue_t unlockDataPool() override;
 
-	HousekeepingManager* hkManager;
+	LocalDataPoolManager* hkManager;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index b6bfa5b85..4b6e24aac 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -3,11 +3,11 @@
 
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/datapool/DataSetIF.h>
-#include <framework/housekeeping/HasHkPoolParametersIF.h>
+#include <framework/datapoollocal/LocalDataPoolManager.h>
+#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 
 #include <framework/serialize/SerializeAdapter.h>
-#include <framework/housekeeping/HousekeepingManager.h>
 
 /**
  * @brief 	Local Pool Variable class which is used to access the local pools.
@@ -29,9 +29,12 @@ public:
 	/**
 	 * This constructor is used by the data creators to have pool variable
 	 * instances which can also be stored in datasets.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 *
+	 * It does not fetch the current value from the data pool, which
+	 * has to be done by calling the read() operation.
+	 * Datasets can be used to access multiple local pool entries in an
+	 * efficient way. A pointer to a dataset can be passed to register
+	 * the pool variable in that dataset directly.
 	 * @param poolId ID of the local pool entry.
 	 * @param hkOwner Pointer of the owner. This will generally be the calling
 	 * class itself which passes "this".
@@ -39,7 +42,7 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVar(lp_id_t poolId, HasHkPoolParametersIF* hkOwner,
+	LocalPoolVar(lp_id_t poolId, OwnsLocalDataPoolIF* hkOwner,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
 			DataSetIF* dataSet = nullptr);
 
@@ -47,12 +50,14 @@ public:
 	 * This constructor is used by data users like controllers to have
 	 * access to the local pool variables of data creators by supplying
 	 * the respective creator object ID.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 *
+	 * It does not fetch the current value from the data pool, which
+	 * has to be done by calling the read() operation.
+	 * Datasets can be used to access multiple local pool entries in an
+	 * efficient way. A pointer to a dataset can be passed to register
+	 * the pool variable in that dataset directly.
 	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
+	 * @param hkOwner object ID of the pool owner.
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
@@ -99,7 +104,7 @@ public:
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 *
 	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t read(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
@@ -109,7 +114,8 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
@@ -144,7 +150,7 @@ private:
 	bool valid = false;
 
 	//! Pointer to the class which manages the HK pool.
-	HousekeepingManager* hkManager;
+	LocalDataPoolManager* hkManager;
 };
 
 #include <framework/datapoollocal/LocalPoolVariable.tpp>
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 663b73f58..0140b29d0 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -7,7 +7,7 @@
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
-		HasHkPoolParametersIF* hkOwner, pool_rwm_t setReadWriteMode,
+		OwnsLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
 		DataSetIF* dataSet):
 		localPoolId(poolId),readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
@@ -33,8 +33,8 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
 				"NO_PARAMETER value!" << std::endl;
 	}
-	HasHkPoolParametersIF* hkOwner =
-			objectManager->get<HasHkPoolParametersIF>(poolOwner);
+	OwnsLocalDataPoolIF* hkOwner =
+			objectManager->get<OwnsLocalDataPoolIF>(poolOwner);
 	if(hkOwner == nullptr) {
 		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
 				"the correct interface HasHkPoolParametersIF!" << std::endl;
@@ -47,7 +47,7 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::read(millis_t lockTimeout) {
+inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
 	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
 	return readWithoutLock();
 }
@@ -75,7 +75,7 @@ inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::commit(millis_t lockTimeout) {
+inline ReturnValue_t LocalPoolVar<T>::commit(dur_millis_t lockTimeout) {
 	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
 	return commitWithoutLock();
 }
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 746151515..1c5f1d653 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -4,8 +4,8 @@
 #include <framework/datapool/DataSetIF.h>
 #include <framework/datapool/PoolEntry.h>
 #include <framework/datapool/PoolVariableIF.h>
+#include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/serialize/SerializeAdapter.h>
-#include <framework/housekeeping/HousekeepingManager.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 
@@ -46,7 +46,7 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVector(lp_id_t poolId, HasHkPoolParametersIF* hkOwner,
+	LocalPoolVector(lp_id_t poolId, OwnsLocalDataPoolIF* hkOwner,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
 			DataSetIF* dataSet = nullptr);
 
@@ -179,7 +179,7 @@ private:
 	 */
 	ReadWriteMode_t readWriteMode;
 	//! @brief	Pointer to the class which manages the HK pool.
-	HousekeepingManager* hkManager;
+	LocalDataPoolManager* hkManager;
 
 	// std::ostream is the type for object std::cout
 	template <typename U, uint16_t otherSize>
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 9a00e5dfd..bd35eed3b 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -7,7 +7,7 @@
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		HasHkPoolParametersIF* hkOwner, pool_rwm_t setReadWriteMode,
+		OwnsLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
 		DataSetIF* dataSet) :
 		localPoolId(poolId), valid(false), readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
@@ -29,8 +29,8 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
 				"NO_PARAMETER value!" << std::endl;
 	}
-	HasHkPoolParametersIF* hkOwner =
-			objectManager->get<HasHkPoolParametersIF>(poolOwner);
+	OwnsLocalDataPoolIF* hkOwner =
+			objectManager->get<OwnsLocalDataPoolIF>(poolOwner);
 	if(hkOwner == nullptr) {
 		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
 				"the correct interface HasHkPoolParametersIF!" << std::endl;
diff --git a/housekeeping/HasHkPoolParametersIF.h b/datapoollocal/OwnsLocalDataPoolIF.h
similarity index 58%
rename from housekeeping/HasHkPoolParametersIF.h
rename to datapoollocal/OwnsLocalDataPoolIF.h
index 62715a3d4..cf94f946a 100644
--- a/housekeeping/HasHkPoolParametersIF.h
+++ b/datapoollocal/OwnsLocalDataPoolIF.h
@@ -5,33 +5,40 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <map>
 
-class HousekeepingManager;
+class LocalDataPoolManager;
 class DataSetIF;
 /**
  * @brief	Type definition for local pool entries.
  */
 using lp_id_t = uint32_t;
-using LocalDataPoolMap =  std::map<lp_id_t, PoolEntryIF*>;
-using LocalDataPoolMapIter = LocalDataPoolMap::iterator;
+using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
+using LocalDataPoolMapIter = LocalDataPool::iterator;
 
 /**
  * @brief 		This interface is implemented by classes which posses a local
- * 				data pool (not the managing class)
+ * 				data pool (not the managing class). It defines the relationship
+ * 				between the local data pool owner and the LocalDataPoolManager.
  * @details
- * Any class implementing this interface shall also have a HousekeepingManager
- * member class which handles the retrieval of the local pool data.
+ * Any class implementing this interface shall also have a LocalDataPoolManager
+ * member class which contains the actual pool data structure
+ * and exposes the public interface for it.
  * This is required because the pool entries are templates, which makes
- * specifying an interface rather difficult.
+ * specifying an interface rather difficult. The local data pool can be
+ * accessed by using the LocalPoolVariable, LocalPoolVector or LocalDataSet
+ * classes.
  *
- * This could be circumvented by using a wrapper/accessor function, but
+ * Architectural Note:
+ * This could be circumvented by using a wrapper/accessor function or
+ * implementing the templated function in this interface..
+ * The first solution sounds better than the second but
  * the LocalPoolVariable classes are templates as well, so this just shifts
  * the problem somewhere else. Interfaces are nice, but the most
  * pragmatic solution I found was to offer the client the full interface
- * of the housekeeping manager.
+ * of the LocalDataPoolManager.
  */
-class HasHkPoolParametersIF {
+class OwnsLocalDataPoolIF {
 public:
-	virtual~ HasHkPoolParametersIF() {};
+	virtual~ OwnsLocalDataPoolIF() {};
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING;
 	static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0XA0);
@@ -39,9 +46,9 @@ public:
 
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual ReturnValue_t initializeHousekeepingPoolEntries(
-			LocalDataPoolMap& localDataPoolMap) = 0;
+			LocalDataPool& localDataPoolMap) = 0;
 	//virtual float setMinimalHkSamplingFrequency() = 0;
-	virtual HousekeepingManager* getHkManagerHandle() = 0;
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
 };
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 30ee03949..59bfb6af4 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1347,11 +1347,11 @@ void DeviceHandlerBase::performOperationHook() {
 }
 
 ReturnValue_t DeviceHandlerBase::initializeHousekeepingPoolEntries(
-		LocalDataPoolMap &localDataPoolMap) {
+		LocalDataPool &localDataPoolMap) {
 	return RETURN_OK;
 }
 
-HousekeepingManager* DeviceHandlerBase::getHkManagerHandle() {
+LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
 	return &hkManager;
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index b079e4691..4ee3d652c 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -11,15 +11,13 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/power/PowerSwitchIF.h>
 #include <framework/ipc/MessageQueueIF.h>
-#include <framework/housekeeping/HasHkPoolParametersIF.h>
-
 #include <framework/action/ActionHelper.h>
 #include <framework/health/HealthHelper.h>
 #include <framework/parameters/ParameterHelper.h>
 #include <framework/datapool/HkSwitchHelper.h>
+#include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include <framework/housekeeping/HousekeepingManager.h>
-
+#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <map>
 
 namespace Factory{
@@ -87,7 +85,7 @@ class DeviceHandlerBase: public DeviceHandlerIF,
 		public HasHealthIF,
 		public HasActionsIF,
 		public ReceivesParameterMessagesIF,
-		public HasHkPoolParametersIF {
+		public OwnsLocalDataPoolIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	/**
@@ -480,10 +478,10 @@ protected:
 	 * @return
 	 */
 	virtual ReturnValue_t initializeHousekeepingPoolEntries(
-				LocalDataPoolMap& localDataPoolMap) override;
+				LocalDataPool& localDataPoolMap) override;
 
 	/** Get the HK manager object handle */
-	virtual HousekeepingManager* getHkManagerHandle() override;
+	virtual LocalDataPoolManager* getHkManagerHandle() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
@@ -609,7 +607,7 @@ protected:
 	/** Action helper for HasActionsIF */
 	ActionHelper actionHelper;
 	/** Housekeeping Manager */
-	HousekeepingManager hkManager;
+	LocalDataPoolManager hkManager;
 
 	/**
 	 *  @brief Information about commands

From 73932f0349a958aa15b932f23e56dfa4277a02a8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 13:58:51 +0200
Subject: [PATCH 0416/1774] object maanager tweaks

---
 objectmanager/ObjectManager.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 606cd369a..cfdf65621 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -23,6 +23,7 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 	} else {
 		sif::error << "ObjectManager::insert: Object id " << std::hex
 		           << (int)id << std::dec << " is already in use!" << std::endl;
+		sif::error << "Terminating program." << std::endl;
 		//This is very severe and difficult to handle in other places.
 		std::exit(INSERTION_FAILED);
 	}
@@ -31,8 +32,8 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 ReturnValue_t ObjectManager::remove( object_id_t id ) {
 	if ( this->getSystemObject(id) != NULL ) {
 		this->objectList.erase( id );
-		sif::debug << "ObjectManager::removeObject: Object " << std::hex
-		           << (int)id << std::dec << " removed." << std::endl;
+		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
+		//           << (int)id << std::dec << " removed." << std::endl;
 		return RETURN_OK;
 	} else {
 		sif::error << "ObjectManager::removeObject: Requested object "

From 98e6ca5f78b19e679f5f527db1c3612f8e1f214a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 15:22:32 +0200
Subject: [PATCH 0417/1774] removed locks in lockless functions

---
 datapoollocal/LocalPoolVariable.tpp |  2 --
 datapoollocal/LocalPoolVector.h     | 10 +++++++---
 datapoollocal/LocalPoolVector.tpp   | 16 ++++++++++------
 3 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 0140b29d0..9dcd06992 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -87,8 +87,6 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 				 "mode for commit() call." << std::endl;
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
-	// Wait maximum of 50 milliseconds.
-	MutexHelper(hkManager->getMutexHandle(), 50);
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 1c5f1d653..a8d0a7bb1 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -70,8 +70,9 @@ public:
 
 	/**
 	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
+	 * @details
+	 * The user can work on this attribute just like he would on a local
+	 * array of this type.
 	 */
 	T value[vectorSize];
 	/**
@@ -109,7 +110,7 @@ public:
 	void setValid(bool valid) override;
 	uint8_t getValid() const;
 
-	T &operator [](int i);
+	T& operator [](int i);
 	const T &operator [](int i) const;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
@@ -142,6 +143,7 @@ public:
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
 	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
@@ -185,6 +187,8 @@ private:
 	template <typename U, uint16_t otherSize>
 	friend std::ostream& operator<< (std::ostream &out,
 	        const LocalPoolVector<U, otherSize> &var);
+
+
 };
 
 #include <framework/datapoollocal/LocalPoolVector.tpp>
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index bd35eed3b..a18f83279 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -85,8 +85,6 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 				"mode for commit() call." << std::endl;
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
-	// Wait maximum of 50 milliseconds.
-	MutexHelper(hkManager->getMutexHandle(), 50);
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
@@ -106,8 +104,11 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
 	if(i <= vectorSize) {
 		return value[i];
 	}
-	sif::warning << "LocalPoolVector: Invalid index" << std::endl;
-	return 0;
+	// If this happens, I have to set some value. I consider this
+	// a configuration error, but I wont exit here.
+	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+			" last value!" << std::endl;
+	return value[i];
 }
 
 template<typename T, uint16_t vectorSize>
@@ -115,8 +116,11 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
 	if(i <= vectorSize) {
 		return value[i];
 	}
-	sif::warning << "LocalPoolVector: Invalid index" << std::endl;
-	return 0;
+	// If this happens, I have to set some value. I consider this
+	// a configuration error, but I wont exit here.
+	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+			" last value!" << std::endl;
+	return value[i];
 }
 
 template<typename T, uint16_t vectorSize>

From 3b4413a6ee268d2759a5ef94c1ce8348c7f4d425 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 16:12:23 +0200
Subject: [PATCH 0418/1774] added queue lock for  receiveMessage

---
 osal/host/MessageQueue.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 7e68fd5bf..3e30c8eda 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -61,6 +61,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 	}
 	// not sure this will work..
 	//*message = std::move(messageQueue.front());
+	MutexHelper mutexLock(queueLock, 20);
 	MessageQueueMessage* currentMessage = &messageQueue.front();
 	std::copy(currentMessage->getBuffer(),
 			currentMessage->getBuffer() + messageSize, message->getBuffer());

From 4a90f41122339e106b7ec52f45fcd982dccc5c39 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 18:53:55 +0200
Subject: [PATCH 0419/1774] generate HK packet function continued

---
 datapoollocal/LocalDataPoolManager.cpp | 42 ++++++++++++++-------
 datapoollocal/LocalDataPoolManager.h   | 14 +++++--
 tmtcservices/CommandingServiceBase.cpp | 52 +++++++++++++-------------
 tmtcservices/CommandingServiceBase.h   | 20 +++++-----
 4 files changed, 77 insertions(+), 51 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 78e57c8c2..0a5747dc8 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,6 +1,7 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/objectmanager/frameworkObjects.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 
@@ -13,7 +14,15 @@ LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner) {
 	}
 	this->owner = owner;
 	mutex = MutexFactory::instance()->createMutex();
-	//owner->setMinimalHkSamplingFrequency();
+	if(mutex == nullptr) {
+	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+	            "Could not create mutex." << std::endl;
+	}
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if(ipcStore == nullptr) {
+	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+	            "Could not set IPC store." << std::endl;
+	}
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
@@ -52,32 +61,37 @@ MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
-//void HousekeepingManager::setMinimalSamplingFrequency(float frequencySeconds) {
-//	this->samplingFrequency = frequencySeconds;
-//
-//}
-
-void LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
+ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
 				" Set ID not found" << std::endl;
-		return;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	store_address_t storeId;
+	size_t hkSize = dataSetToSerialize->getSerializedSize();
+	uint8_t* storePtr = nullptr;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId, hkSize,&storePtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+	    sif::warning << "HousekeepingManager::generateHousekeepingPacket: "
+	            "Could not get free element from IPC store." << std::endl;
+	    return result;
 	}
-	std::array<uint8_t, 256> testBuffer = {};
-	uint8_t* dataPtr = testBuffer.data();
 	size_t size = 0;
-	dataSetToSerialize->serialize(&dataPtr, &size, testBuffer.size(),
-			false);
-	// and now we send it to the TM funnel or somewhere else
-
+	dataSetToSerialize->serialize(&storePtr, &size, hkSize, false);
+	// and now we have to set a HK message and send it the queue.
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void LocalDataPoolManager::setHkPacketQueue(MessageQueueIF *msgQueue) {
 	this->hkPacketQueue = msgQueue;
 }
 
+void LocalDataPoolManager::setHkReplyQueue(MessageQueueIF *replyQueue) {
+    this->hkReplyQueue = replyQueue;
+}
+
 const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 	return owner;
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c8a6bf15b..14e7693c8 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -37,14 +37,15 @@ class LocalDataPoolManager {
 	friend class LocalPoolVector;
 	friend class LocalDataSet;
 public:
-	static constexpr float MINIMAL_SAMPLING_FREQUENCY = 0.2;
 
 	LocalDataPoolManager(OwnsLocalDataPoolIF* owner);
 	virtual~ LocalDataPoolManager();
 
+	/* Copying forbidden */
+	LocalDataPoolManager(const LocalDataPoolManager &) = delete;
+	LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 
-	// propably will just call respective local data set functions.
-	void generateHousekeepingPacket(sid_t sid);
+	ReturnValue_t generateHousekeepingPacket(sid_t sid);
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
 	/**
@@ -55,7 +56,12 @@ public:
 	 */
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
+	//! Set the queue for HK packets, which are sent unrequested.
 	void setHkPacketQueue(MessageQueueIF* msgQueue);
+	//! Set the queue for replies. This can be set manually or by the owner
+	//! class if the manager if message are relayed by it.
+	void setHkReplyQueue(MessageQueueIF* replyQueue);
+
 	const OwnsLocalDataPoolIF* getOwner() const;
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
@@ -81,6 +87,8 @@ private:
 	//! Maybe this will just be the TM funnel.
 	MessageQueueIF* hkPacketQueue = nullptr;
 
+	//! Global IPC store is used to store all packets.
+	StorageManagerIF* ipcStore = nullptr;
 	/**
 	 * Get the pointer to the mutex. Can be used to lock the data pool
 	 * eternally. Use with care and don't forget to unlock locked mutexes!
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 5b3977567..adc9400fa 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -218,7 +218,7 @@ void CommandingServiceBase::handleRequestQueue() {
 }
 
 
-void CommandingServiceBase::sendTmPacket(uint8_t subservice,
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
 		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
 		size_t headerSize) {
 	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
@@ -228,36 +228,38 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
 	if (result == HasReturnvaluesIF::RETURN_OK) {
 		this->tmPacketCounter++;
 	}
+	return result;
 }
 
 
-void CommandingServiceBase::sendTmPacket(uint8_t subservice,
-		object_id_t objectId, const uint8_t *data, size_t dataLen) {
-	uint8_t buffer[sizeof(object_id_t)];
-	uint8_t* pBuffer = buffer;
-	size_t size = 0;
-	SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
-			sizeof(object_id_t), true);
-	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-			this->tmPacketCounter, data, dataLen, buffer, size);
-	ReturnValue_t result = tmPacketStored.sendPacket(
-			requestQueue->getDefaultDestination(), requestQueue->getId());
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		this->tmPacketCounter++;
-	}
-
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+        object_id_t objectId, const uint8_t *data, size_t dataLen) {
+    uint8_t buffer[sizeof(object_id_t)];
+    uint8_t* pBuffer = buffer;
+    size_t size = 0;
+    SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
+            sizeof(object_id_t), true);
+    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+            this->tmPacketCounter, data, dataLen, buffer, size);
+    ReturnValue_t result = tmPacketStored.sendPacket(
+            requestQueue->getDefaultDestination(), requestQueue->getId());
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        this->tmPacketCounter++;
+    }
+    return result;
 }
 
 
-void CommandingServiceBase::sendTmPacket(uint8_t subservice,
-		SerializeIF* content, SerializeIF* header) {
-	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-			this->tmPacketCounter, content, header);
-	ReturnValue_t result = tmPacketStored.sendPacket(
-			requestQueue->getDefaultDestination(), requestQueue->getId());
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		this->tmPacketCounter++;
-	}
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+        SerializeIF* content, SerializeIF* header) {
+    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+            this->tmPacketCounter, content, header);
+    ReturnValue_t result = tmPacketStored.sendPacket(
+            requestQueue->getDefaultDestination(), requestQueue->getId());
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        this->tmPacketCounter++;
+    }
+    return result;
 }
 
 
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 259ed1a3b..e79e806de 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -212,36 +212,38 @@ protected:
 	 */
 	PeriodicTaskIF* executingTask;
 
-	// todo: why do these functions not have returnvalues? the caller should be
-	// able to check whether the send operations actually work.
 	/**
-	 * Send TM data from pointer to data. If a header is supplied it is added before data
+	 * @brief   Send TM data from pointer to data.
+	 *          If a header is supplied it is added before data
 	 * @param subservice Number of subservice
 	 * @param data Pointer to the data in the Packet
 	 * @param dataLen Lenght of data in the Packet
 	 * @param headerData HeaderData will be placed before data
 	 * @param headerSize Size of HeaderData
 	 */
-	void sendTmPacket(uint8_t subservice, const uint8_t *data, size_t dataLen,
-			const uint8_t* headerData = nullptr,size_t headerSize = 0);
+	ReturnValue_t sendTmPacket(uint8_t subservice, const uint8_t *data,
+	        size_t dataLen, const uint8_t* headerData = nullptr,
+	        size_t headerSize = 0);
 
 	/**
-	 * To send TM packets of objects that still need to be serialized and consist of an object ID with appended data
+	 * @brief   To send TM packets of objects that still need to be serialized
+	 *          and consist of an object ID with appended data.
 	 * @param subservice Number of subservice
 	 * @param objectId ObjectId is placed before data
 	 * @param data Data to append to the packet
 	 * @param dataLen Length of Data
 	 */
-	void sendTmPacket(uint8_t subservice, object_id_t objectId,
+	ReturnValue_t sendTmPacket(uint8_t subservice, object_id_t objectId,
 			const uint8_t *data, size_t dataLen);
 
 	/**
-	 * To send packets has data which is in form of a SerializeIF or Adapters implementing it
+	 * @brief   To send packets which are contained inside a class implementing
+	 *          SerializeIF.
 	 * @param subservice Number of subservice
 	 * @param content This is a pointer to the serialized packet
 	 * @param header Serialize IF header which will be placed before content
 	 */
-	void sendTmPacket(uint8_t subservice, SerializeIF* content,
+	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
 			SerializeIF* header = nullptr);
 
 	virtual void handleUnrequestedReply(CommandMessage *reply);

From e8bc2cec9f267079f29e78c94d90d4e107e7eba0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 23:26:52 +0200
Subject: [PATCH 0420/1774] small comment in semaph factory

---
 osal/host/SemaphoreFactory.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index 8712d8662..0c077f689 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -23,6 +23,7 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 }
 
 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;
@@ -30,6 +31,7 @@ SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
 
 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;

From 2649fa150706bc93d88137dc1de595d2d17272b2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 23:38:15 +0200
Subject: [PATCH 0421/1774] small small command message tweaks

---
 ipc/CommandMessage.h | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 21c393e59..6190e9038 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,13 +1,5 @@
-/**
- * @file	CommandMessage.h
- * @brief	This file defines the CommandMessage class.
- * @date	20.06.2013
- * @author	baetz
- */
-
-#ifndef COMMANDMESSAGE_H_
-#define COMMANDMESSAGE_H_
-
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGE_H_
 
 #include <framework/ipc/FwMessageTypes.h>
 #include <config/ipc/MissionMessageTypes.h>
@@ -15,10 +7,11 @@
 #include <framework/ipc/MessageQueueMessage.h>
 
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
-typedef ReturnValue_t Command_t;
+typedef uint16_t Command_t;
 
 /**
- * @brief Used to pass command messages between tasks
+ * @brief 	Used to pass command messages between tasks
+ * @author	Bastian Baetz
  */
 class CommandMessage : public MessageQueueMessage {
 public:
@@ -27,9 +20,12 @@ public:
 
 
 	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::COMMAND;
-	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );//!< Used internally, will be ignored
+	//! Used internally, will be ignored
+	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
 	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
+	//! Reply indicating that the current command was rejected,
+	//! par1 should contain the error code
+	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 0xD1 );
 
 	/**
 	 * This is the size of a message as it is seen by the MessageQueue
@@ -40,11 +36,13 @@ public:
 	/**
 	 * Default Constructor, does not initialize anything.
 	 *
-	 * This constructor should be used when receiving a Message, as the content is filled by the MessageQueue.
+	 * This constructor should be used when receiving a Message, as the
+	 * content is filled by the MessageQueue.
 	 */
 	CommandMessage();
 	/**
-	 * This constructor creates a new message with all message content initialized
+	 * This constructor creates a new message with all message content
+	 * initialized
 	 *
 	 * @param command	The DeviceHandlerCommand_t that will be sent
 	 * @param parameter1	The first parameter
@@ -60,7 +58,8 @@ public:
 	}
 
 	/**
-	 * Read the DeviceHandlerCommand_t that is stored in the message, usually used after receiving
+	 * Read the DeviceHandlerCommand_t that is stored in the message,
+	 * usually used after receiving.
 	 *
 	 * @return the Command stored in the Message
 	 */
@@ -126,7 +125,8 @@ public:
 	 * Is needed quite often, so we better code it once only.
 	 */
 	void setToUnknownCommand();
-	void setReplyRejected(ReturnValue_t reason, Command_t initialCommand = CMD_NONE);
+	void setReplyRejected(ReturnValue_t reason,
+			Command_t initialCommand = CMD_NONE);
 	size_t getMinimumMessageSize() const;
 };
 

From 4c41456ddffb6800119c0e6a0d90f4ff03bd4618 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 8 Jun 2020 01:22:21 +0200
Subject: [PATCH 0422/1774] thoughts on message queuee message

new interface. What if there are MQ messages with different sizes?
-> generic interface

furthermore, maybe command message should be refactored to operate
on a mq message instead of implementing it
---
 datapoollocal/LocalDataPoolManager.cpp |  2 +-
 datapoollocal/LocalDataPoolManager.h   |  2 +-
 devicehandlers/DeviceHandlerBase.cpp   | 39 +++++++++++++++++------
 housekeeping/HousekeepingMessage.cpp   |  8 +++++
 housekeeping/HousekeepingMessage.h     | 17 ++++++----
 ipc/CommandMessage.h                   |  3 +-
 ipc/MessageQueueMessage.h              |  4 ++-
 ipc/MessageQueueMessageIF.h            | 44 ++++++++++++++++++++++++++
 8 files changed, 100 insertions(+), 19 deletions(-)
 create mode 100644 ipc/MessageQueueMessageIF.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 0a5747dc8..37dbed368 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -41,7 +41,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-		CommandMessage *message) {
+		MessageQueueMessage *message) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 14e7693c8..1d25fa48c 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -46,7 +46,7 @@ public:
 	LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 
 	ReturnValue_t generateHousekeepingPacket(sid_t sid);
-	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
+	ReturnValue_t handleHousekeepingMessage(MessageQueueMessage* message);
 
 	/**
 	 * This function is used to fill the local data pool map with pool
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 59bfb6af4..94c9dc633 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -8,6 +8,8 @@
 #include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/devicehandlers/DeviceTmReportingWrapper.h>
 #include <framework/globalfunctions/CRC.h>
+#include <framework/housekeeping/HousekeepingMessage.h>
+#include <framework/ipc/MessageQueueMessage.h>
 #include <framework/subsystem/SubsystemBase.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
@@ -36,7 +38,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
 		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	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();
@@ -212,40 +214,59 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	// This is not ideal. What if it is not a command message? (e.g. another
+	// message with 3 parameters). The full buffer is filled anyway
+	// and I could just copy the content into the other message but
+	// all I need are few additional functions the other message type offers.
+	CommandMessage cmdMessage;
+	ReturnValue_t result = commandQueue->receiveMessage(&cmdMessage);
 	if (result != RETURN_OK) {
 		return;
 	}
 
+	// This is really annoying. I can't cast a parent object to a child.
+	// But I want to use another message format..
+//	CommandMessage* cmdMessage = dynamic_cast<CommandMessage*>(msgPtr);
+//	if(cmdMessage == nullptr) {
+//		sif::error << "DeviceHandlerBase::readCommandQueue: Could not cast"
+//				" message to CommandMessage!" << std::endl;
+//		return;
+//	}
+
 	if(healthHelperActive) {
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&cmdMessage);
 		if (result == RETURN_OK) {
 			return;
 		}
 	}
 
-	result = modeHelper.handleModeCommand(&message);
+	result = modeHelper.handleModeCommand(&cmdMessage);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = actionHelper.handleActionMessage(&message);
+	result = actionHelper.handleActionMessage(&cmdMessage);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = parameterHelper.handleParameterMessage(&message);
+	result = parameterHelper.handleParameterMessage(&cmdMessage);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = handleDeviceHandlerMessage(&message);
+//	HousekeepingMessage* hkMessage = dynamic_cast<HousekeepingMessage*>(msgPtr);
+//	result = hkManager.handleHousekeepingMessage(hkMessage);
+//	if (result == RETURN_OK) {
+//		return;
+//	}
+
+	result = handleDeviceHandlerMessage(&cmdMessage);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = letChildHandleMessage(&message);
+	result = letChildHandleMessage(&cmdMessage);
 	if (result == RETURN_OK) {
 		return;
 	}
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index b0109e5df..c94a69d74 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,5 +1,13 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 
+HousekeepingMessage::HousekeepingMessage() {
+
+}
+
+void HousekeepingMessage::setHkReportMessage() {
+}
+
+
 //void HousekeepingMessage::setAddHkReportStructMessage(CommandMessage *message,
 //		set_t setId, store_address_t packet) {
 //	message->setCommand(ADD_HK_REPORT_STRUCT);
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index e7ba68ba7..67edc4edf 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -5,12 +5,14 @@
 #include <limits>
 
 union sid_t {
-	static constexpr uint64_t INVALID_ADDRESS = std::numeric_limits<uint64_t>::max();
+	static constexpr uint64_t INVALID_ADDRESS =
+			std::numeric_limits<uint64_t>::max();
 	sid_t(): raw(INVALID_ADDRESS) {}
 
 	struct {
 		object_id_t objectId ;
-		// A generic 32 bit ID to identify unique HK packets for a single object.
+		// A generic 32 bit ID to identify unique HK packets for a single
+		// object.
 		// For example, the DeviceCommandId_t is used for DeviceHandlers
 		uint32_t ownerSetId;
 	};
@@ -19,15 +21,17 @@ union sid_t {
 	 */
 	uint64_t raw;
 };
-class HousekeepingMessage {
+
+
+class HousekeepingMessage: public MessageQueueMessage {
 public:
 	/**
 	 * No instances of a message shall be created, instead
 	 * a CommandMessage instance is manipulated.
 	 */
-	HousekeepingMessage() = delete;
-	HousekeepingMessage(const HousekeepingMessage&) = delete;
-	HousekeepingMessage operator=(const HousekeepingMessage &) = delete;
+	HousekeepingMessage();
+//	HousekeepingMessage(const HousekeepingMessage&) = delete;
+//	HousekeepingMessage operator=(const HousekeepingMessage &) = delete;
 
 	static constexpr uint8_t MESSAGE_ID = MESSAGE_TYPE::HOUSEKEEPING;
 	static constexpr Command_t ADD_HK_REPORT_STRUCT =
@@ -76,6 +80,7 @@ public:
 
 //	static void setAddHkReportStructMessage(CommandMessage* message,
 //			DevisetId, store_address_t packet);
+	static void setHkReportMessage();
 };
 
 
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 6190e9038..d7b6820d9 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -28,7 +28,8 @@ public:
 	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 0xD1 );
 
 	/**
-	 * This is the size of a message as it is seen by the MessageQueue
+	 * This is the size of a message as it is seen by the MessageQueue.
+	 * 14 of the 24 available MessageQueueMessage bytes are used.
 	 */
 	static const size_t COMMAND_MESSAGE_SIZE = HEADER_SIZE
 			+ sizeof(Command_t) + 2 * sizeof(uint32_t);
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 4d82bd885..93671321a 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -1,6 +1,7 @@
 #ifndef MESSAGEQUEUEMESSAGE_H_
 #define MESSAGEQUEUEMESSAGE_H_
 
+#include <framework/ipc/MessageQueueMessageIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
 #include <stddef.h>
 
@@ -23,7 +24,7 @@
  *	receive messages from other tasks.
  *	@ingroup message_queue
  */
-class MessageQueueMessage {
+class MessageQueueMessage: public MessageQueueMessageIF {
 public:
 	/**
 	 * @brief	The class is initialized empty with this constructor.
@@ -43,6 +44,7 @@ public:
 	 * 				MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
 	 */
 	MessageQueueMessage(uint8_t* data, size_t size);
+
 	/**
 	 * @brief	The size information of each message is stored in this attribute.
 	 * @details
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
new file mode 100644
index 000000000..3bd4a9d61
--- /dev/null
+++ b/ipc/MessageQueueMessageIF.h
@@ -0,0 +1,44 @@
+#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
+#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
+#include <framework/ipc/MessageQueueSenderIF.h>
+#include <cstddef>
+
+class MessageQueueMessageIF {
+public:
+	virtual ~MessageQueueMessageIF() {};
+
+	/**
+	 * @brief	With this method, the whole content and the message
+	 * 			size is set to zero.
+	 */
+	virtual void clear() = 0;
+	/**
+	 * @brief	This is a debug method that prints the content
+	 * 			(till messageSize) to the debug output.
+	 */
+	virtual void print() = 0;
+	virtual const uint8_t* getBuffer() const = 0;
+	/**
+	 * @brief	This method is used to get the complete data of the message.
+	 */
+	virtual uint8_t* getBuffer() = 0;
+	/**
+	 * @brief	This method is used to set the sender's message queue id
+	 * 			information prior to sending the message.
+	 * @param setId	The message queue id that identifies the sending message queue.
+	 */
+	virtual void setSender(MessageQueueId_t setId) = 0;
+	/**
+	 * @brief	This helper function is used by the MessageQueue class to
+	 * 			check the size of an incoming message.
+	 * @details
+	 * The method must be overwritten by child classes if size checks shall
+	 * be more strict.
+	 * @return	The default implementation returns HEADER_SIZE.
+	 */
+	virtual size_t getMinimumMessageSize() = 0;
+};
+
+
+
+#endif /* FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_ */

From 0ea249aac46c7416aa5b908b9c5f844ac8e09388 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 8 Jun 2020 12:25:20 +0200
Subject: [PATCH 0423/1774] messagetype namespace im small letters now

---
 action/ActionMessage.h                |  2 +-
 devicehandlers/DeviceHandlerMessage.h |  2 +-
 health/HealthMessage.h                |  2 +-
 housekeeping/HousekeepingMessage.h    |  2 +-
 ipc/CommandMessage.cpp                | 36 +++++++++++++--------------
 ipc/CommandMessage.h                  |  3 ++-
 ipc/FwMessageTypes.h                  |  4 +--
 ipc/MessageQueueMessageIF.h           | 15 +++++++----
 memory/FileSystemMessage.h            |  2 +-
 memory/MemoryMessage.h                |  2 +-
 modes/ModeMessage.h                   |  2 +-
 monitoring/MonitoringMessage.h        |  2 +-
 parameters/ParameterMessage.h         |  2 +-
 subsystem/modes/ModeSequenceMessage.h |  2 +-
 tmstorage/TmStoreMessage.h            |  2 +-
 15 files changed, 43 insertions(+), 37 deletions(-)

diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index 5d8332cbf..59ad619ef 100644
--- a/action/ActionMessage.h
+++ b/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);
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index c91bb0a4c..2bdf03b22 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/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_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
diff --git a/health/HealthMessage.h b/health/HealthMessage.h
index 7fd009041..13e79b88e 100644
--- a/health/HealthMessage.h
+++ b/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);
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 67edc4edf..3ba6f94d5 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -33,7 +33,7 @@ public:
 //	HousekeepingMessage(const HousekeepingMessage&) = delete;
 //	HousekeepingMessage operator=(const HousekeepingMessage &) = delete;
 
-	static constexpr uint8_t MESSAGE_ID = MESSAGE_TYPE::HOUSEKEEPING;
+	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
 	static constexpr Command_t ADD_HK_REPORT_STRUCT =
 			MAKE_COMMAND_ID(1);
 	static constexpr Command_t ADD_DIAGNOSTICS_REPORT_STRUCT =
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index fa41c6531..544ee43c8 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,9 +1,4 @@
-/**
- * @file	CommandMessage.cpp
- * @brief	This file defines the CommandMessage class.
- * @date	20.06.2013
- * @author	baetz
- */
+#include "MissionMessageTypes.h"
 
 #include <framework/devicehandlers/DeviceHandlerMessage.h>
 #include <framework/health/HealthMessage.h>
@@ -15,7 +10,8 @@
 #include <framework/tmstorage/TmStoreMessage.h>
 #include <framework/parameters/ParameterMessage.h>
 
-namespace MESSAGE_TYPE {
+namespace messagetypes {
+// Implemented in config.
 void clearMissionMessage(CommandMessage* message);
 }
 
@@ -39,6 +35,10 @@ Command_t CommandMessage::getCommand() const {
 	return command;
 }
 
+uint8_t CommandMessage::getMessageType() const {
+	return getCommand() >> 8 & 0xff;
+}
+
 void CommandMessage::setCommand(Command_t command) {
 	memcpy(getData(), &command, sizeof(command));
 }
@@ -66,36 +66,36 @@ void CommandMessage::setParameter2(uint32_t parameter2) {
 }
 
 void CommandMessage::clearCommandMessage() {
-	switch((getCommand()>>8) & 0xff){
-	case  MESSAGE_TYPE::MODE_COMMAND:
+	switch(getMessageType()){
+	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;
 	}
 }
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index d7b6820d9..a5c187f59 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -19,7 +19,7 @@ public:
 	static const ReturnValue_t UNKNOW_COMMAND = MAKE_RETURN_CODE(0x01);
 
 
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::COMMAND;
+	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
 	//! Used internally, will be ignored
 	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
 	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 3 );
@@ -66,6 +66,7 @@ public:
 	 */
 	Command_t getCommand() const;
 
+	uint8_t getMessageType() const;
 	/**
 	 * Set the DeviceHandlerCOmmand_t of the message
 	 *
diff --git a/ipc/FwMessageTypes.h b/ipc/FwMessageTypes.h
index 1665747ee..8b49c1222 100644
--- a/ipc/FwMessageTypes.h
+++ b/ipc/FwMessageTypes.h
@@ -1,9 +1,9 @@
 #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 {
+enum FsfwMessageTypes {
 	COMMAND = 0,
 	MODE_COMMAND,
 	HEALTH_COMMAND,
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 3bd4a9d61..70c87d3cb 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -17,24 +17,29 @@ public:
 	 * 			(till messageSize) to the debug output.
 	 */
 	virtual void print() = 0;
+
+	/**
+	 * @brief	Get read-only pointer to the raw buffer.
+	 * @return
+	 */
 	virtual const uint8_t* getBuffer() const = 0;
+
 	/**
 	 * @brief	This method is used to get the complete data of the message.
 	 */
 	virtual uint8_t* getBuffer() = 0;
+
 	/**
 	 * @brief	This method is used to set the sender's message queue id
 	 * 			information prior to sending the message.
-	 * @param setId	The message queue id that identifies the sending message queue.
+	 * @param setId
+	 * The message queue id that identifies the sending message queue.
 	 */
 	virtual void setSender(MessageQueueId_t setId) = 0;
+
 	/**
 	 * @brief	This helper function is used by the MessageQueue class to
 	 * 			check the size of an incoming message.
-	 * @details
-	 * The method must be overwritten by child classes if size checks shall
-	 * be more strict.
-	 * @return	The default implementation returns HEADER_SIZE.
 	 */
 	virtual size_t getMinimumMessageSize() = 0;
 };
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index b6fd7309e..9f9c1496d 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -16,7 +16,7 @@ class FileSystemMessage {
 private:
 	FileSystemMessage(); //A private ctor inhibits instantiation
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::FILE_SYSTEM_MESSAGE;
+	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
 	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
 	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
 	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
diff --git a/memory/MemoryMessage.h b/memory/MemoryMessage.h
index bcc262e9d..e2c87ca35 100644
--- a/memory/MemoryMessage.h
+++ b/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 );
diff --git a/modes/ModeMessage.h b/modes/ModeMessage.h
index f72fdeec5..675c614b2 100644
--- a/modes/ModeMessage.h
+++ b/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
diff --git a/monitoring/MonitoringMessage.h b/monitoring/MonitoringMessage.h
index d2ff9b4dd..793e1fbf3 100644
--- a/monitoring/MonitoringMessage.h
+++ b/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();
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 0f2866756..432832941 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -9,7 +9,7 @@ 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 );
diff --git a/subsystem/modes/ModeSequenceMessage.h b/subsystem/modes/ModeSequenceMessage.h
index 830cf5329..61d1b6285 100644
--- a/subsystem/modes/ModeSequenceMessage.h
+++ b/subsystem/modes/ModeSequenceMessage.h
@@ -7,7 +7,7 @@
 
 class ModeSequenceMessage {
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::MODE_SEQUENCE;
+	static const uint8_t MESSAGE_ID = messagetypes::MODE_SEQUENCE;
 
 	static const Command_t ADD_SEQUENCE = MAKE_COMMAND_ID(0x01);
 	static const Command_t ADD_TABLE = MAKE_COMMAND_ID(0x02);
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index 0883063ca..bd6b2def9 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -41,7 +41,7 @@ public:
 
 	static store_address_t getStoreId(const CommandMessage* cmd);
 	virtual ~TmStoreMessage();
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::TM_STORE;
+	static const uint8_t MESSAGE_ID = messagetypes::TM_STORE;
 	static const Command_t ENABLE_STORING = MAKE_COMMAND_ID(1);
 	static const Command_t DELETE_STORE_CONTENT = MAKE_COMMAND_ID(2);
 	static const Command_t DOWNLINK_STORE_CONTENT = MAKE_COMMAND_ID(3);

From 07302e0d2aa55dc7a0ed77c595e94f3c4ae9899f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 8 Jun 2020 17:44:54 +0200
Subject: [PATCH 0424/1774] removed include

---
 ipc/CommandMessage.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 544ee43c8..f9e2e010f 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,5 +1,3 @@
-#include "MissionMessageTypes.h"
-
 #include <framework/devicehandlers/DeviceHandlerMessage.h>
 #include <framework/health/HealthMessage.h>
 #include <framework/ipc/CommandMessage.h>

From b1f91439c6325593c59099cbf93d214c27820fc8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 8 Jun 2020 17:50:09 +0200
Subject: [PATCH 0425/1774] deleted copy ctor taskes const ref now

---
 storagemanager/StorageAccessor.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 57c9369ce..069479746 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -84,8 +84,8 @@ public:
 	//! The copy ctor and copy assignemnt should be deleted implicitely
 	//! according to https://foonathan.net/2019/02/special-member-functions/
 	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor& operator= (const ConstStorageAccessor&) = delete;
+	ConstStorageAccessor (const ConstStorageAccessor&) = delete;
 protected:
 	const uint8_t* constDataPointer = nullptr;
 	store_address_t storeId;

From 8ff6506ad90965f6a42d2b03a1fa2b2638f436c9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Jun 2020 02:18:39 +0200
Subject: [PATCH 0426/1774] MessageQueue refactoring complete

---
 action/ActionHelper.cpp                | 17 ++++---
 action/CommandActionHelper.cpp         |  3 +-
 action/SimpleActionHelper.cpp          |  3 +-
 controller/ControllerBase.cpp          | 17 +++----
 datalinklayer/MapPacketExtraction.cpp  |  6 +--
 datapool/HkSwitchHelper.cpp            | 11 ++---
 datapoolglob/DataPoolAdmin.cpp         |  9 ++--
 devicehandlers/AssemblyBase.cpp        |  3 +-
 devicehandlers/DeviceHandlerBase.cpp   | 29 ++++++------
 devicehandlers/HealthDevice.cpp        |  7 +--
 health/HealthHelper.cpp                | 20 +++++----
 ipc/CommandMessage.cpp                 | 62 ++++++++++++++++++++------
 ipc/CommandMessage.h                   | 28 +++++++++---
 ipc/MessageQueueIF.h                   | 16 +++----
 ipc/MessageQueueMessage.cpp            |  2 +-
 ipc/MessageQueueMessage.h              |  2 +-
 ipc/MessageQueueMessageIF.h            | 29 +++++++++---
 ipc/MessageQueueSenderIF.h             | 16 ++-----
 memory/MemoryHelper.cpp                | 15 ++++---
 modes/ModeHelper.cpp                   | 31 +++++++------
 monitoring/LimitViolationReporter.cpp  |  3 +-
 osal/FreeRTOS/MessageQueue.cpp         | 18 ++++----
 osal/FreeRTOS/MessageQueue.h           | 19 ++++----
 osal/FreeRTOS/QueueFactory.cpp         |  2 +-
 parameters/ParameterHelper.cpp         |  9 ++--
 power/Fuse.cpp                         |  3 +-
 power/PowerSensor.cpp                  |  3 +-
 subsystem/Subsystem.cpp                | 14 +++---
 subsystem/SubsystemBase.cpp            | 43 +++++++++---------
 thermal/AbstractTemperatureSensor.cpp  | 11 ++---
 thermal/Heater.cpp                     |  9 ++--
 tmstorage/TmStoreMessage.cpp           |  2 +-
 tmstorage/TmStoreMessage.h             |  2 +-
 tmtcservices/CommandingServiceBase.cpp | 20 +++++----
 34 files changed, 293 insertions(+), 191 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 19a84d82d..0df5f2d4e 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -16,7 +16,7 @@ ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
 				ActionMessage::getStoreId(command));
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return CommandMessage::UNKNOW_COMMAND;
+		return CommandMessage::UNKNOWN_COMMAND;
 	}
 }
 
@@ -33,13 +33,15 @@ ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
 }
 
 void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
 	queueToUse->sendMessage(reportTo, &reply);
 }
 
 void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	ActionMessage::setCompletionReply(&reply, commandId, result);
 	queueToUse->sendMessage(reportTo, &reply);
 }
@@ -54,7 +56,8 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
 		queueToUse->sendMessage(commandedBy, &reply);
 		return;
@@ -62,7 +65,8 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
 	ipcStore->deleteData(dataAddress);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
 		queueToUse->sendMessage(commandedBy, &reply);
 		return;
@@ -71,7 +75,8 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 
 ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 		ActionId_t replyId, SerializeIF* data, bool hideSender) {
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	store_address_t storeAddress;
 	uint8_t *dataPtr;
 	size_t maxSize = data->getSerializedSize();
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index 772954014..c871a2d06 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -53,7 +53,8 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 
 ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
 		ActionId_t actionId, store_address_t storeId) {
-	CommandMessage command;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	ActionMessage::setCommand(&command, actionId, storeId);
 	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index 6861fc28c..f97474b19 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -36,7 +36,8 @@ void SimpleActionHelper::resetHelper() {
 
 void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
 		ActionId_t actionId, store_address_t dataAddress) {
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	if (isExecuting) {
 		ipcStore->deleteData(dataAddress);
 		ActionMessage::setStepReply(&reply, actionId, 0,
diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 7b11bdfa3..ad0a0b978 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -56,26 +56,27 @@ MessageQueueId_t ControllerBase::getCommandQueue() const {
 }
 
 void ControllerBase::handleQueue() {
-	CommandMessage message;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	ReturnValue_t result;
-	for (result = commandQueue->receiveMessage(&message); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&message)) {
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
 
-		result = modeHelper.handleModeCommand(&message);
+		result = modeHelper.handleModeCommand(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
-		result = handleCommandMessage(&message);
+		result = handleCommandMessage(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
-		message.setToUnknownCommand();
-		commandQueue->reply(&message);
+		command.setToUnknownCommand();
+		commandQueue->reply(&command);
 	}
 
 }
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 11b0792a9..4ea45e89c 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -16,9 +16,9 @@
 
 MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
 		object_id_t setPacketDestination) :
-		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0), bufferPosition(
-				packetBuffer), packetDestination(setPacketDestination), packetStore(
-				NULL), tcQueueId(MessageQueueSenderIF::NO_QUEUE) {
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
+		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
+		packetStore(nullptr), tcQueueId(MessageQueueMessageIF::NO_QUEUE) {
 	memset(packetBuffer, 0, sizeof(packetBuffer));
 }
 
diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp
index 844fcd90e..6a9237766 100644
--- a/datapool/HkSwitchHelper.cpp
+++ b/datapool/HkSwitchHelper.cpp
@@ -21,14 +21,15 @@ ReturnValue_t HkSwitchHelper::initialize() {
 }
 
 ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
-	CommandMessage message;
-	while (actionQueue->receiveMessage(&message) == HasReturnvaluesIF::RETURN_OK) {
-		ReturnValue_t result = commandActionHelper.handleReply(&message);
+	MessageQueueMessage message;
+	CommandMessage command(&message);
+	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
+		ReturnValue_t result = commandActionHelper.handleReply(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			continue;
 		}
-		message.setToUnknownCommand();
-		actionQueue->reply(&message);
+		command.setToUnknownCommand();
+		actionQueue->reply(&command);
 	}
 
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 05de1eb2a..6387263f8 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -66,7 +66,8 @@ ReturnValue_t DataPoolAdmin::getParameter(uint8_t domainId,
 }
 
 void DataPoolAdmin::handleCommand() {
-	CommandMessage command;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != RETURN_OK) {
 		return;
@@ -282,7 +283,8 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 
 	ParameterMessage::setParameterDumpReply(&reply, id, address);
 
@@ -294,7 +296,8 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 //identical to ParameterHelper::rejectCommand()
 void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
 		Command_t initialCommand) {
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	reply.setReplyRejected(reason, initialCommand);
 	commandQueue->sendMessage(to, &reply);
 }
diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index bd85d1de5..a5dcad21b 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -148,7 +148,8 @@ void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
 
 void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
 		HealthState health) {
-	CommandMessage command;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
 			health);
 	if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 94c9dc633..11cffc74c 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -218,8 +218,9 @@ void DeviceHandlerBase::readCommandQueue() {
 	// message with 3 parameters). The full buffer is filled anyway
 	// and I could just copy the content into the other message but
 	// all I need are few additional functions the other message type offers.
-	CommandMessage cmdMessage;
-	ReturnValue_t result = commandQueue->receiveMessage(&cmdMessage);
+	MessageQueueMessage message;
+	CommandMessage command(&message);
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != RETURN_OK) {
 		return;
 	}
@@ -234,23 +235,23 @@ void DeviceHandlerBase::readCommandQueue() {
 //	}
 
 	if(healthHelperActive) {
-		result = healthHelper.handleHealthCommand(&cmdMessage);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == RETURN_OK) {
 			return;
 		}
 	}
 
-	result = modeHelper.handleModeCommand(&cmdMessage);
+	result = modeHelper.handleModeCommand(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = actionHelper.handleActionMessage(&cmdMessage);
+	result = actionHelper.handleActionMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = parameterHelper.handleParameterMessage(&cmdMessage);
+	result = parameterHelper.handleParameterMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
@@ -261,17 +262,17 @@ void DeviceHandlerBase::readCommandQueue() {
 //		return;
 //	}
 
-	result = handleDeviceHandlerMessage(&cmdMessage);
+	result = handleDeviceHandlerMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = letChildHandleMessage(&cmdMessage);
+	result = letChildHandleMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	replyReturnvalueToCommand(CommandMessage::UNKNOW_COMMAND);
+	replyReturnvalueToCommand(CommandMessage::UNKNOWN_COMMAND);
 
 }
 
@@ -492,12 +493,13 @@ void DeviceHandlerBase::setMode(Mode_t newMode) {
 
 void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
 		uint32_t parameter) {
+	MessageQueueMessage message;
 	//This is actually the reply protocol for raw and misc DH commands.
 	if (status == RETURN_OK) {
-		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, parameter);
+		CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, parameter);
 		commandQueue->reply(&reply);
 	} else {
-		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, parameter);
+		CommandMessage reply(&message, CommandMessage::REPLY_REJECTED, status, parameter);
 		commandQueue->reply(&reply);
 	}
 }
@@ -767,9 +769,10 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		return;
 	}
 
-	CommandMessage message;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 
-	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&message,
+	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
 			getObjectId(), address, isCommand);
 
 //	this->DeviceHandlerCommand = CommandMessage::CMD_NONE;
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index ea0b99ffa..1c9d18f64 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -13,10 +13,11 @@ HealthDevice::~HealthDevice() {
 }
 
 ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	MessageQueueMessage message;
+	CommandMessage command(&message);
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		healthHelper.handleHealthCommand(&message);
+		healthHelper.handleHealthCommand(&command);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index fdfc09673..b23a8bd28 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -65,29 +65,31 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 	if (parentQueue == 0) {
 		return;
 	}
-	CommandMessage message;
-	HealthMessage::setHealthMessage(&message, HealthMessage::HEALTH_INFO,
+	MessageQueueMessage message;
+	CommandMessage information(&message);
+	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
 			health, oldHealth);
-	if (MessageQueueSenderIF::sendMessage(parentQueue, &message,
+	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() == MessageQueueMessageIF::NO_QUEUE) {
 		return;
 	}
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
 		HealthMessage::setHealthMessage(&reply,
 				HealthMessage::REPLY_HEALTH_SET);
 	} else {
-		reply.setReplyRejected(result, message->getCommand());
+		reply.setReplyRejected(result, command->getCommand());
 	}
-	if (MessageQueueSenderIF::sendMessage(message->getSender(), &reply,
+	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
 			owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
 		sif::debug << "HealthHelper::handleHealthCommand: sending health "
 		        "reply failed." << std::endl;
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index f9e2e010f..cd75aee44 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -14,14 +14,26 @@ void clearMissionMessage(CommandMessage* message);
 }
 
 
-CommandMessage::CommandMessage() {
-	this->messageSize = COMMAND_MESSAGE_SIZE;
+CommandMessage::CommandMessage(MessageQueueMessage* receiverMessage):
+			internalMessage(receiverMessage) {
+	if(receiverMessage == nullptr) {
+		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
+				" as the message queue message, pass the address of an actual"
+				" message!" << std::endl;
+	}
+	internalMessage->messageSize = COMMAND_MESSAGE_SIZE;
 	setCommand(CMD_NONE);
 }
 
-CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
-		uint32_t parameter2) {
-	this->messageSize = COMMAND_MESSAGE_SIZE;
+CommandMessage::CommandMessage(MessageQueueMessage* messageToSet,
+		Command_t command, uint32_t parameter1, uint32_t parameter2):
+				internalMessage(messageToSet) {
+	if(messageToSet == nullptr) {
+		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
+				" as the message queue message, pass the address of an actual"
+				" message!" << std::endl;
+	}
+	internalMessage->messageSize = COMMAND_MESSAGE_SIZE;
 	setCommand(command);
 	setParameter(parameter1);
 	setParameter2(parameter2);
@@ -29,7 +41,7 @@ CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
 
 Command_t CommandMessage::getCommand() const {
 	Command_t command;
-	memcpy(&command, getData(), sizeof(Command_t));
+	memcpy(&command, internalMessage->getData(), sizeof(Command_t));
 	return command;
 }
 
@@ -38,29 +50,35 @@ uint8_t CommandMessage::getMessageType() const {
 }
 
 void CommandMessage::setCommand(Command_t command) {
-	memcpy(getData(), &command, sizeof(command));
+	memcpy(internalMessage->getData(), &command, sizeof(command));
 }
 
 uint32_t CommandMessage::getParameter() const {
 	uint32_t parameter1;
-	memcpy(&parameter1, getData() + sizeof(Command_t), sizeof(parameter1));
+	memcpy(&parameter1, internalMessage->getData() + sizeof(Command_t),
+			sizeof(parameter1));
 	return parameter1;
 }
 
 void CommandMessage::setParameter(uint32_t parameter1) {
-	memcpy(getData() + sizeof(Command_t), &parameter1, sizeof(parameter1));
+	memcpy(internalMessage->getData() + sizeof(Command_t),
+			&parameter1, sizeof(parameter1));
 }
 
 uint32_t CommandMessage::getParameter2() const {
 	uint32_t parameter2;
-	memcpy(&parameter2, getData() + sizeof(Command_t) + sizeof(uint32_t),
-			sizeof(parameter2));
+	memcpy(&parameter2, internalMessage->getData() + sizeof(Command_t)
+			+ sizeof(uint32_t), sizeof(parameter2));
 	return parameter2;
 }
 
 void CommandMessage::setParameter2(uint32_t parameter2) {
-	memcpy(getData() + sizeof(Command_t) + sizeof(uint32_t), &parameter2,
-			sizeof(parameter2));
+	memcpy(internalMessage-> getData() + sizeof(Command_t) + sizeof(uint32_t),
+			&parameter2, sizeof(parameter2));
+}
+
+void CommandMessage::clear() {
+	clearCommandMessage();
 }
 
 void CommandMessage::clearCommandMessage() {
@@ -109,7 +127,7 @@ size_t CommandMessage::getMinimumMessageSize() const {
 void CommandMessage::setToUnknownCommand() {
 	Command_t initialCommand = getCommand();
 	clearCommandMessage();
-	setReplyRejected(UNKNOW_COMMAND, initialCommand);
+	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
 }
 
 void CommandMessage::setReplyRejected(ReturnValue_t reason,
@@ -118,3 +136,19 @@ void CommandMessage::setReplyRejected(ReturnValue_t reason,
 	setParameter(reason);
 	setParameter2(initialCommand);
 }
+
+MessageQueueId_t CommandMessage::getSender() const {
+	return internalMessage->getSender();
+}
+
+uint8_t* CommandMessage::getBuffer() {
+	return internalMessage->getBuffer();
+}
+
+void CommandMessage::setSender(MessageQueueId_t setId) {
+	internalMessage->setSender(setId);
+}
+
+const uint8_t* CommandMessage::getBuffer() const {
+	return internalMessage->getBuffer();
+}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index a5c187f59..f6fd86cba 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -13,10 +13,10 @@ typedef uint16_t Command_t;
  * @brief 	Used to pass command messages between tasks
  * @author	Bastian Baetz
  */
-class CommandMessage : public MessageQueueMessage {
+class CommandMessage: public MessageQueueMessageIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
-	static const ReturnValue_t UNKNOW_COMMAND = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
 
 
 	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
@@ -31,7 +31,7 @@ public:
 	 * This is the size of a message as it is seen by the MessageQueue.
 	 * 14 of the 24 available MessageQueueMessage bytes are used.
 	 */
-	static const size_t COMMAND_MESSAGE_SIZE = HEADER_SIZE
+	static const size_t COMMAND_MESSAGE_SIZE = MessageQueueMessage::HEADER_SIZE
 			+ sizeof(Command_t) + 2 * sizeof(uint32_t);
 
 	/**
@@ -40,7 +40,7 @@ public:
 	 * This constructor should be used when receiving a Message, as the
 	 * content is filled by the MessageQueue.
 	 */
-	CommandMessage();
+	CommandMessage(MessageQueueMessage* receiverMessage);
 	/**
 	 * This constructor creates a new message with all message content
 	 * initialized
@@ -49,7 +49,7 @@ public:
 	 * @param parameter1	The first parameter
 	 * @param parameter2	The second parameter
 	 */
-	CommandMessage(Command_t command,
+	CommandMessage(MessageQueueMessage* messageToSet, Command_t command,
 			uint32_t parameter1, uint32_t parameter2);
 
 	/**
@@ -58,6 +58,8 @@ public:
 	virtual ~CommandMessage() {
 	}
 
+	uint8_t * getBuffer() override;
+	const uint8_t * getBuffer() const override;
 	/**
 	 * Read the DeviceHandlerCommand_t that is stored in the message,
 	 * usually used after receiving.
@@ -66,6 +68,16 @@ public:
 	 */
 	Command_t getCommand() const;
 
+	/**
+	 * @brief	This method is used to set the sender's message queue id
+	 * 			information prior to sending the message.
+	 * @param setId
+	 * The message queue id that identifies the sending message queue.
+	 */
+	void setSender(MessageQueueId_t setId) override;
+
+	MessageQueueId_t getSender() const override;
+
 	uint8_t getMessageType() const;
 	/**
 	 * Set the DeviceHandlerCOmmand_t of the message
@@ -102,6 +114,7 @@ public:
 	 */
 	void setParameter2(uint32_t parameter2);
 
+	void clear() override;
 	/**
 	 * Set the command to CMD_NONE and try to find
 	 * the correct class to handle a more detailed
@@ -129,7 +142,10 @@ public:
 	void setToUnknownCommand();
 	void setReplyRejected(ReturnValue_t reason,
 			Command_t initialCommand = CMD_NONE);
-	size_t getMinimumMessageSize() const;
+	size_t getMinimumMessageSize() const override;
+
+private:
+	MessageQueueMessage* internalMessage;
 };
 
 
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 480019eb6..500f71e2b 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -15,7 +15,7 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 class MessageQueueIF {
 public:
-	static const MessageQueueId_t NO_QUEUE = MessageQueueSenderIF::NO_QUEUE; //!< Ugly hack.
+	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
 	/**
@@ -41,7 +41,7 @@ public:
 	 * @return RETURN_OK if ok
 	 * @return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
 	 */
-	virtual ReturnValue_t reply( MessageQueueMessage* message ) = 0;
+	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) = 0;
 
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
@@ -50,7 +50,7 @@ public:
 	 * @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.
 	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message,
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom) = 0;
 
 	/**
@@ -65,7 +65,7 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::EMPTY if queue is empty
 	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) = 0;
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
@@ -95,7 +95,7 @@ public:
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
 	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault = false ) = 0;
 
 	/**
@@ -107,7 +107,7 @@ public:
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false ) = 0;
+			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
 
 	/**
 	 * @brief	The sendToDefaultFrom method sends a queue message to the default destination.
@@ -118,7 +118,7 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
 			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
 	/**
 	 * @brief	This operation sends a message to the default destination.
@@ -128,7 +128,7 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message )  = 0;
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
 	/**
 	 * \brief	This method is a simple setter for the default destination.
 	 */
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index 544d18e8d..c3e1cb7a8 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -51,7 +51,7 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
 	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
 }
 
-size_t MessageQueueMessage::getMinimumMessageSize() {
+size_t MessageQueueMessage::getMinimumMessageSize() const {
 	return this->HEADER_SIZE;
 }
 
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 93671321a..29d1a869c 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -132,7 +132,7 @@ public:
 	 * @details	The method must be overwritten by child classes if size checks shall be more strict.
 	 * @return	The default implementation returns HEADER_SIZE.
 	 */
-	virtual size_t getMinimumMessageSize();
+	virtual size_t getMinimumMessageSize() const;
 };
 
 #endif /* MESSAGEQUEUEMESSAGE_H_ */
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 70c87d3cb..0a6288b02 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -1,10 +1,23 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
-#include <framework/ipc/MessageQueueSenderIF.h>
 #include <cstddef>
+#include <cstdint>
+
+/*
+ * TODO: Actually, the definition of this ID to be a uint32_t is not  ideal and
+ * breaks layering. However, it is difficult to keep layering, as the ID is
+ * stored in many places and sent around in MessageQueueMessage.
+ * Ideally, one would use the (current) object_id_t only, however, doing a
+ * lookup of queueIDs for every call does not sound ideal.
+ * In a first step, I'll circumvent the issue by not touching it,
+ * maybe in a second step. This also influences Interface design
+ * (getCommandQueue) and some other issues.. */
+typedef uint32_t MessageQueueId_t;
 
 class MessageQueueMessageIF {
 public:
+	static const MessageQueueId_t NO_QUEUE = 0xffffffff;
+
 	virtual ~MessageQueueMessageIF() {};
 
 	/**
@@ -12,11 +25,11 @@ public:
 	 * 			size is set to zero.
 	 */
 	virtual void clear() = 0;
-	/**
-	 * @brief	This is a debug method that prints the content
-	 * 			(till messageSize) to the debug output.
-	 */
-	virtual void print() = 0;
+//	/**
+//	 * @brief	This is a debug method that prints the content
+//	 * 			(till messageSize) to the debug output.
+//	 */
+//	virtual void print() = 0;
 
 	/**
 	 * @brief	Get read-only pointer to the raw buffer.
@@ -37,11 +50,13 @@ public:
 	 */
 	virtual void setSender(MessageQueueId_t setId) = 0;
 
+	virtual MessageQueueId_t getSender() const = 0;
+
 	/**
 	 * @brief	This helper function is used by the MessageQueue class to
 	 * 			check the size of an incoming message.
 	 */
-	virtual size_t getMinimumMessageSize() = 0;
+	virtual size_t getMinimumMessageSize() const = 0;
 };
 
 
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index ae66cd12d..3172454f4 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,22 +1,11 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
 
+#include <framework/ipc/MessageQueueMessageIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
-class MessageQueueMessage;
-
-
-//TODO: Actually, the definition of this ID to be a uint32_t is not ideal and breaks layering.
-//However, it is difficult to keep layering, as the ID is stored in many places and sent around in
-//MessageQueueMessage.
-//Ideally, one would use the (current) object_id_t only, however, doing a lookup of queueIDs for every
-//call does not sound ideal.
-//In a first step, I'll circumvent the issue by not touching it, maybe in a second step.
-//This also influences Interface design (getCommandQueue) and some other issues..
-typedef uint32_t MessageQueueId_t;
 
 class MessageQueueSenderIF {
 public:
-	static const MessageQueueId_t NO_QUEUE = 0xffffffff;
 
 	virtual ~MessageQueueSenderIF() {}
 
@@ -26,7 +15,8 @@ public:
 	 * Must be implemented by a subclass.
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom = MessageQueueSenderIF::NO_QUEUE,
+			MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
 			bool ignoreFault=false);
 private:
 	MessageQueueSenderIF() {}
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index de6092528..2c3846512 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -51,14 +51,16 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 		break;
 	default:
 		ipcStore->deleteData(ipcAddress);
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
 				MemoryMessage::CMD_MEMORY_LOAD);
 		queueToUse->sendMessage(lastSender, &reply);
 		return;
 	}
 	//Only reached on success
-	CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
+	MessageQueueMessage message;
+	CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, 0);
 	queueToUse->sendMessage(lastSender, &reply);
 	ipcStore->deleteData(ipcAddress);
 }
@@ -66,7 +68,8 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 void MemoryHelper::completeDump(ReturnValue_t errorCode,
 		const uint8_t* dataToCopy, const uint32_t size) {
 	busy = false;
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
 	switch (errorCode) {
 	case HasMemoryIF::DO_IT_MYSELF:
@@ -151,7 +154,8 @@ void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
 		completeLoad(returnCode, p_data, size, dataPointer);
 	} else {
 		//At least inform sender.
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
 				MemoryMessage::CMD_MEMORY_LOAD);
 		queueToUse->sendMessage(lastSender, &reply);
@@ -169,7 +173,8 @@ void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
 				reservedSpaceInIPC);
 		completeDump(returnCode, dataPointer, size);
 	} else {
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
 		queueToUse->sendMessage(lastSender, &reply);
 	}
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index 66726772f..b79082afc 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -11,31 +11,32 @@ ModeHelper::~ModeHelper() {
 
 }
 
-ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
-	CommandMessage reply;
+ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	Mode_t mode;
 	Submode_t submode;
-	switch (message->getCommand()) {
+	switch (command->getCommand()) {
 	case ModeMessage::CMD_MODE_COMMAND_FORCED:
 		forced = true;
 		/* NO BREAK falls through*/
 	case ModeMessage::CMD_MODE_COMMAND: {
-		mode = ModeMessage::getMode(message);
-		submode = ModeMessage::getSubmode(message);
+		mode = ModeMessage::getMode(command);
+		submode = ModeMessage::getSubmode(command);
 		uint32_t timeout;
 		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			ModeMessage::cantReachMode(&reply, result);
-			MessageQueueSenderIF::sendMessage(message->getSender(), &reply,
+			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
 					owner->getCommandQueue());
 			break;
 		}
 		//Free to start transition
-		theOneWhoCommandedAMode = message->getSender();
+		theOneWhoCommandedAMode = command->getSender();
 		commandedMode = mode;
 		commandedSubmode = submode;
 
-		if ((parentQueueId != MessageQueueSenderIF::NO_QUEUE)
+		if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
 				&& (theOneWhoCommandedAMode != parentQueueId)) {
 			owner->setToExternalControl();
 		}
@@ -48,7 +49,7 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
 		owner->getMode(&mode, &submode);
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
 				submode);
-		MessageQueueSenderIF::sendMessage(message->getSender(), &reply,
+		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
 				owner->getCommandQueue());
 	}
 		break;
@@ -73,13 +74,14 @@ void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
 	forced = false;
 	sendModeReplyMessage(ownerMode, ownerSubmode);
 	sendModeInfoMessage(ownerMode, ownerSubmode);
-	theOneWhoCommandedAMode = MessageQueueSenderIF::NO_QUEUE;
+	theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
 }
 
 void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 		Submode_t ownerSubmode) {
-	CommandMessage reply;
-	if (theOneWhoCommandedAMode != MessageQueueSenderIF::NO_QUEUE)
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
+	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
 	{
 		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
 		{
@@ -99,9 +101,10 @@ void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 
 void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
 		Submode_t ownerSubmode) {
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	if (theOneWhoCommandedAMode != parentQueueId
-			and parentQueueId != MessageQueueSenderIF::NO_QUEUE)
+			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
 	{
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
 				ownerMode, ownerSubmode);
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 234a0bffb..1378d7549 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -31,7 +31,8 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	CommandMessage report;
+	MessageQueueMessage message;
+	CommandMessage report(&message);
 	MonitoringMessage::setLimitViolationReport(&report, storeId);
 	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
 }
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 0a579296b..8c6ec80b0 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -25,21 +25,21 @@ void MessageQueue::switchSystemContext(CallContext callContext) {
 }
 
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
+		MessageQueueMessageIF* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
 }
 
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 		MessageQueueId_t sentFrom, bool ignoreFault) {
 	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
 }
 
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
-	if (this->lastPartner != 0) {
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+	if (this->lastPartner != MessageQueueMessageIF::NO_QUEUE) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
 		return NO_REPLY_PARTNER;
@@ -47,7 +47,7 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 }
 
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
 			ignoreFault, callContext);
@@ -69,7 +69,7 @@ ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
 	if(status == HasReturnvaluesIF::RETURN_OK) {
@@ -78,7 +78,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 	return status;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
 			message->getBuffer()), 0);
 	if (result == pdPASS){
@@ -120,7 +120,7 @@ bool MessageQueue::isDefaultDestinationSet() const {
 
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessage *message, MessageQueueId_t sentFrom,
+        MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
         bool ignoreFault, CallContext callContext) {
     message->setSender(sentFrom);
     BaseType_t result;
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 81b4c186d..6165c1cf5 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -85,14 +85,14 @@ public:
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false );
+			MessageQueueMessageIF* message, bool ignoreFault = false );
 	/**
 	 * @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( MessageQueueMessage* message );
+	ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
 	/**
 	 * @brief	This operation sends a message to the last communication partner.
 	 * @details	This operation simplifies answering an incoming message by using the stored
@@ -100,7 +100,7 @@ public:
 	 * 			(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( MessageQueueMessage* message );
+	ReturnValue_t reply( MessageQueueMessageIF* message );
 
 	/**
 	 * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
@@ -113,8 +113,9 @@ public:
 	 * 					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, MessageQueueMessage* message,
-			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false );
 
 	/**
 	 * @brief	The sendToDefault method sends a queue message to the default destination.
@@ -123,7 +124,7 @@ public:
 	 * @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( MessageQueueMessage* message,
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
 			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 
 	/**
@@ -133,7 +134,7 @@ public:
 	 * @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(MessageQueueMessage* message,
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom);
 
 	/**
@@ -144,7 +145,7 @@ public:
 	 * 			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(MessageQueueMessage* message);
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
@@ -191,7 +192,7 @@ protected:
 	 * @param context Specify whether call is made from task or from an ISR.
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault=false, CallContext callContext = CallContext::TASK);
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index 372d0d413..beb4969bd 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -7,7 +7,7 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault) {
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
 			sentFrom,ignoreFault);
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index e0756882b..8b91020f9 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -102,7 +102,8 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 
 	ParameterMessage::setParameterDumpReply(&reply, id, address);
 
@@ -123,8 +124,10 @@ ReturnValue_t ParameterHelper::initialize() {
 	}
 }
 
-void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason, Command_t initialCommand) {
-	CommandMessage reply;
+void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+		Command_t initialCommand) {
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	reply.setReplyRejected(reason, initialCommand);
 	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 }
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index eee919841..a80a111fe 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -163,7 +163,8 @@ void Fuse::setAllMonitorsToUnchecked() {
 }
 
 void Fuse::checkCommandQueue() {
-	CommandMessage command;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return;
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 5433acc93..b1aea2700 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -74,7 +74,8 @@ void PowerSensor::setAllMonitorsToUnchecked() {
 }
 
 void PowerSensor::checkCommandQueue() {
-	CommandMessage command;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return;
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 52f2c4741..d774b4d5d 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -309,7 +309,8 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 		break;
 	case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
 		uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		ModeSequenceMessage::setModeSequenceMessage(&reply,
 				ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
 		commandQueue->reply(&reply);
@@ -317,7 +318,8 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 		break;
 	case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
 		uint32_t free = modeTables.maxSize() - modeTables.size();
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		ModeSequenceMessage::setModeSequenceMessage(&reply,
 				ModeSequenceMessage::FREE_TABLE_SLOTS, free);
 		commandQueue->reply(&reply);
@@ -330,11 +332,12 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 }
 
 void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
+	MessageQueueMessage message;
 	if (status == RETURN_OK) {
-		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
+		CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, 0);
 		commandQueue->reply(&reply);
 	} else {
-		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0);
+		CommandMessage reply(&message, CommandMessage::REPLY_REJECTED, status, 0);
 		commandQueue->reply(&reply);
 	}
 }
@@ -617,7 +620,8 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 	for (uint8_t i = 0; i < count; i++) {
 		elements[i]->serialize(&storeBuffer, &size, maxSize, true);
 	}
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
 	if (commandQueue->reply(&reply) != RETURN_OK) {
 		IPCStore->deleteData(address);
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 6df0b64f6..5527f2150 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -9,7 +9,7 @@ SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
 		false), commandsOutstanding(0), commandQueue(NULL), healthHelper(this,
 				setObjectId), modeHelper(this), parentId(parent) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
-			CommandMessage::MAX_MESSAGE_SIZE);
+			MessageQueueMessage::MAX_MESSAGE_SIZE);
 }
 
 SubsystemBase::~SubsystemBase() {
@@ -77,8 +77,8 @@ ReturnValue_t SubsystemBase::checkStateAgainstTable(
 }
 
 void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
-
-	CommandMessage message;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 
 	std::map<object_id_t, ChildInfo>::iterator iter;
 
@@ -100,17 +100,17 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
 
 		if (healthHelper.healthTable->hasHealth(object)) {
 			if (healthHelper.healthTable->isFaulty(object)) {
-				ModeMessage::setModeMessage(&message,
+				ModeMessage::setModeMessage(&command,
 						ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
 						SUBMODE_NONE);
 			} else {
 				if (modeHelper.isForced()) {
-					ModeMessage::setModeMessage(&message,
+					ModeMessage::setModeMessage(&command,
 							ModeMessage::CMD_MODE_COMMAND_FORCED,
 							tableIter.value->getMode(), submodeToCommand);
 				} else {
 					if (healthHelper.healthTable->isCommandable(object)) {
-						ModeMessage::setModeMessage(&message,
+						ModeMessage::setModeMessage(&command,
 								ModeMessage::CMD_MODE_COMMAND,
 								tableIter.value->getMode(), submodeToCommand);
 					} else {
@@ -119,12 +119,12 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
 				}
 			}
 		} else {
-			ModeMessage::setModeMessage(&message, ModeMessage::CMD_MODE_COMMAND,
+			ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
 					tableIter.value->getMode(), submodeToCommand);
 		}
 
-		if ((iter->second.mode == ModeMessage::getMode(&message))
-				&& (iter->second.submode == ModeMessage::getSubmode(&message))
+		if ((iter->second.mode == ModeMessage::getMode(&command))
+				&& (iter->second.submode == ModeMessage::getSubmode(&command))
 				&& !modeHelper.isForced()) {
 			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
 		}
@@ -297,7 +297,8 @@ void SubsystemBase::setToExternalControl() {
 void SubsystemBase::announceMode(bool recursive) {
 	triggerEvent(MODE_INFO, mode, submode);
 	if (recursive) {
-		CommandMessage command;
+		MessageQueueMessage message;
+		CommandMessage command(&message);
 		ModeMessage::setModeMessage(&command,
 				ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
 		commandAllChildren(&command);
@@ -306,31 +307,33 @@ void SubsystemBase::announceMode(bool recursive) {
 
 void SubsystemBase::checkCommandQueue() {
 	ReturnValue_t result;
-	CommandMessage message;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 
-	for (result = commandQueue->receiveMessage(&message); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&message)) {
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
 
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = modeHelper.handleModeCommand(&message);
+		result = modeHelper.handleModeCommand(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = handleModeReply(&message);
+		result = handleModeReply(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = handleCommandMessage(&message);
+		result = handleCommandMessage(&command);
 		if (result != RETURN_OK) {
-			CommandMessage reply;
-			reply.setReplyRejected(CommandMessage::UNKNOW_COMMAND,
-					message.getCommand());
+			MessageQueueMessage message;
+			CommandMessage reply(&message);
+			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
+					command.getCommand());
 			replyToCommand(&reply);
 		}
 	}
diff --git a/thermal/AbstractTemperatureSensor.cpp b/thermal/AbstractTemperatureSensor.cpp
index be143410a..759af87eb 100644
--- a/thermal/AbstractTemperatureSensor.cpp
+++ b/thermal/AbstractTemperatureSensor.cpp
@@ -44,18 +44,19 @@ ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
 }
 
 void AbstractTemperatureSensor::handleCommandQueue() {
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	MessageQueueMessage message;
+	CommandMessage command(&message);
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
-		result = parameterHelper.handleParameterMessage(&message);
+		result = parameterHelper.handleParameterMessage(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
-		message.setToUnknownCommand();
+		command.setToUnknownCommand();
 		commandQueue->reply(&message);
 	}
 }
diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index 29daa15df..6e191fc12 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -279,14 +279,15 @@ ReturnValue_t Heater::initialize() {
 }
 
 void Heater::handleQueue() {
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	MessageQueueMessage message;
+	CommandMessage command(&message);
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
-		parameterHelper.handleParameterMessage(&message);
+		parameterHelper.handleParameterMessage(&command);
 	}
 }
 
diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp
index 4509ba912..669ecc0e7 100644
--- a/tmstorage/TmStoreMessage.cpp
+++ b/tmstorage/TmStoreMessage.cpp
@@ -74,7 +74,7 @@ void TmStoreMessage::clear(CommandMessage* cmd) {
 	case DELETE_STORE_CONTENT_BLOCKS:
 	case DOWNLINK_STORE_CONTENT_BLOCKS:
 	case REPORT_INDEX_REQUEST:
-		cmd->setCommand(UNKNOW_COMMAND);
+		cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
 		cmd->setParameter(0);
 		cmd->setParameter2(0);
 		break;
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index bd6b2def9..93c23e40b 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -5,7 +5,7 @@
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <framework/tmstorage/TmStorePackets.h>
 #include <framework/objectmanager/SystemObjectIF.h>
-class TmStoreMessage: public CommandMessage {
+class TmStoreMessage  {
 public:
 	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
 			bool setEnabled);
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index adc9400fa..a4fc11101 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -77,7 +77,10 @@ ReturnValue_t CommandingServiceBase::initialize() {
 }
 
 void CommandingServiceBase::handleCommandQueue() {
-	CommandMessage reply, nextCommand;
+	MessageQueueMessage replyMessage;
+	CommandMessage reply(&replyMessage);
+	MessageQueueMessage nextCommandMessage;
+	CommandMessage nextCommand(&nextCommandMessage);
 	ReturnValue_t result, sendResult = RETURN_OK;
 	bool isStep = false;
 	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
@@ -268,16 +271,17 @@ void CommandingServiceBase::startExecution(
 		typename FixedMap<MessageQueueId_t,
 				CommandingServiceBase::CommandInfo>::Iterator *iter) {
 	ReturnValue_t result, sendResult = RETURN_OK;
-	CommandMessage message;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	(*iter)->subservice = storedPacket->getSubService();
-	result = prepareCommand(&message, (*iter)->subservice,
+	result = prepareCommand(&command, (*iter)->subservice,
 			storedPacket->getApplicationData(),
 			storedPacket->getApplicationDataSize(), &(*iter)->state,
 			(*iter)->objectId);
 
 	switch (result) {
 	case RETURN_OK:
-		if (message.getCommand() != CommandMessage::CMD_NONE) {
+		if (command.getCommand() != CommandMessage::CMD_NONE) {
 			sendResult = commandQueue->sendMessage((*iter).value->first,
 					&message);
 		}
@@ -286,20 +290,20 @@ void CommandingServiceBase::startExecution(
 			(*iter)->step = 0;
 //			(*iter)->state = 0;
 			(*iter)->subservice = storedPacket->getSubService();
-			(*iter)->command = message.getCommand();
+			(*iter)->command = command.getCommand();
 			(*iter)->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
 			(*iter)->tcInfo.tcPacketId = storedPacket->getPacketId();
 			(*iter)->tcInfo.tcSequenceControl =
 					storedPacket->getPacketSequenceControl();
 			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
 		} else {
-			message.clearCommandMessage();
+			command.clearCommandMessage();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
 		break;
 	case EXECUTION_COMPLETE:
-		if (message.getCommand() != CommandMessage::CMD_NONE) {
+		if (command.getCommand() != CommandMessage::CMD_NONE) {
 			//Fire-and-forget command.
 			sendResult = commandQueue->sendMessage((*iter).value->first,
 					&message);
@@ -310,7 +314,7 @@ void CommandingServiceBase::startExecution(
 			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
 			checkAndExecuteFifo(iter);
 		} else {
-			message.clearCommandMessage();
+			command.clearCommandMessage();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}

From 47aa9ddcc382393279c0a769e51e7d732cf25a35 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Jun 2020 02:46:19 +0200
Subject: [PATCH 0427/1774] doc for mqm improved

---
 ipc/CommandMessage.cpp      |   8 +++
 ipc/CommandMessage.h        |  56 +++++++++++--------
 ipc/MessageQueueMessage.h   | 107 +++++++++++++++++++++---------------
 ipc/MessageQueueMessageIF.h |  28 +++++++---
 4 files changed, 127 insertions(+), 72 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index cd75aee44..44424e023 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -152,3 +152,11 @@ void CommandMessage::setSender(MessageQueueId_t setId) {
 const uint8_t* CommandMessage::getBuffer() const {
 	return internalMessage->getBuffer();
 }
+
+uint8_t* CommandMessage::getData() {
+	return internalMessage->getData();
+}
+
+const uint8_t* CommandMessage::getData() const {
+	return internalMessage->getData();
+}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index f6fd86cba..772bd774d 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,16 +1,25 @@
 #ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
 #define FRAMEWORK_IPC_COMMANDMESSAGE_H_
 
+#include <framework/ipc/MessageQueueMessage.h>
 #include <framework/ipc/FwMessageTypes.h>
 #include <config/ipc/MissionMessageTypes.h>
 
-#include <framework/ipc/MessageQueueMessage.h>
+
 
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef uint16_t Command_t;
 
 /**
- * @brief 	Used to pass command messages between tasks
+ * @brief 	Used to pass command messages between tasks. Primary message type
+ * 			for IPC. Contains sender, 2-byte command field, and 2 4-byte
+ * 			parameters.
+ * @details
+ * It operates on an external memory which is contained inside a
+ * MessageQueueMessage by taking its address.
+ * This allows for a more flexible designs of message implementations.
+ * The pointer can be passed to different message implementations without
+ * the need of unnecessary copying.
  * @author	Bastian Baetz
  */
 class CommandMessage: public MessageQueueMessageIF {
@@ -53,13 +62,10 @@ public:
 			uint32_t parameter1, uint32_t parameter2);
 
 	/**
-	 * Default Destructor
+	 * @brief 	Default Destructor
 	 */
-	virtual ~CommandMessage() {
-	}
+	virtual ~CommandMessage() {}
 
-	uint8_t * getBuffer() override;
-	const uint8_t * getBuffer() const override;
 	/**
 	 * Read the DeviceHandlerCommand_t that is stored in the message,
 	 * usually used after receiving.
@@ -68,53 +74,54 @@ public:
 	 */
 	Command_t getCommand() const;
 
-	/**
-	 * @brief	This method is used to set the sender's message queue id
-	 * 			information prior to sending the message.
-	 * @param setId
-	 * The message queue id that identifies the sending message queue.
+	/*
+	 * MessageQueueMessageIF functions, which generally just call the
+	 * respective functions of the internal message
 	 */
+	uint8_t * getBuffer() override;
+	const uint8_t * getBuffer() const override;
 	void setSender(MessageQueueId_t setId) override;
-
 	MessageQueueId_t getSender() const override;
+	uint8_t * getData() override;
+	const uint8_t* getData() const override;
+	size_t getMinimumMessageSize() const override;
 
+	/**
+	 * Extract message ID, which is the first byte of the command ID.
+	 * @return
+	 */
 	uint8_t getMessageType() const;
 	/**
-	 * Set the DeviceHandlerCOmmand_t of the message
-	 *
+	 * Set the command type of the message
 	 * @param the Command to be sent
 	 */
 	void setCommand(Command_t command);
 
 	/**
 	 * Get the first parameter of the message
-	 *
 	 * @return the first Parameter of the message
 	 */
 	uint32_t getParameter() const;
 
 	/**
 	 * Set the first parameter of the message
-	 *
 	 * @param the first parameter of the message
 	 */
 	void setParameter(uint32_t parameter1);
 
 	/**
 	 * Get the second parameter of the message
-	 *
 	 * @return the second Parameter of the message
 	 */
 	uint32_t getParameter2() const;
 
 	/**
 	 * Set the second parameter of the message
-	 *
 	 * @param the second parameter of the message
 	 */
 	void setParameter2(uint32_t parameter2);
 
-	void clear() override;
+
 	/**
 	 * Set the command to CMD_NONE and try to find
 	 * the correct class to handle a more detailed
@@ -126,6 +133,7 @@ public:
 	 *
 	 */
 	void clearCommandMessage();
+	void clear() override;
 
 	/**
 	 * check if a message was cleared
@@ -134,7 +142,6 @@ public:
 	 */
 	bool isClearedCommandMessage();
 
-
 	/**
 	 * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
 	 * Is needed quite often, so we better code it once only.
@@ -142,9 +149,14 @@ public:
 	void setToUnknownCommand();
 	void setReplyRejected(ReturnValue_t reason,
 			Command_t initialCommand = CMD_NONE);
-	size_t getMinimumMessageSize() const override;
 
 private:
+	/**
+	 * @brief 	Pointer to the message containing the data.
+	 * @details
+	 * The command message does not actually own the memory containing a
+	 * message, it just oprates on it via a pointer to a message queue message.
+	 */
 	MessageQueueMessage* internalMessage;
 };
 
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 29d1a869c..bee39ae62 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -1,5 +1,5 @@
-#ifndef MESSAGEQUEUEMESSAGE_H_
-#define MESSAGEQUEUEMESSAGE_H_
+#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
+#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
 
 #include <framework/ipc/MessageQueueMessageIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
@@ -8,7 +8,6 @@
 /**
  *	@brief		This class is the representation and data organizer
  *				for interprocess messages.
- *
  *	@details
  *	To facilitate and standardize interprocess communication, this class was
  *	created to handle a lightweight "interprocess message protocol".
@@ -28,12 +27,14 @@ class MessageQueueMessage: public MessageQueueMessageIF {
 public:
 	/**
 	 * @brief	The class is initialized empty with this constructor.
-	 * @details	The messageSize attribute is set to the header's size and the
-	 * 			whole content is set to zero.
+	 * @details
+	 * The messageSize attribute is set to the header's size and the whole
+	 * content is set to zero.
 	 */
 	MessageQueueMessage();
 	/**
-	 * @brief	With this constructor the class is initialized with the given content.
+	 * @brief	With this constructor the class is initialized with
+	 * 			the given content.
 	 * @details
 	 * If the passed message size fits into the buffer, the passed data is
 	 * copied to the internal buffer and the messageSize information is set.
@@ -46,7 +47,14 @@ public:
 	MessageQueueMessage(uint8_t* data, size_t size);
 
 	/**
-	 * @brief	The size information of each message is stored in this attribute.
+	 * @brief	As no memory is allocated in this class,
+	 * 		    the destructor is empty.
+	 */
+	virtual ~MessageQueueMessage();
+
+	/**
+	 * @brief	The size information of each message is stored in
+	 *  			this attribute.
 	 * @details
 	 * It is public to simplify usage and to allow for passing the size
 	 * address as a pointer. Care must be taken when inheriting from this class,
@@ -59,19 +67,26 @@ public:
 	 */
 	size_t messageSize;
 	/**
-	 * @brief	This constant defines the maximum size of the data content, excluding the header.
-	 * @details	It may be changed if necessary, but in general should be kept as small as possible.
+	 * @brief	This constant defines the maximum size of the data content,
+	 * 			excluding the header.
+	 * @details
+	 * It may be changed if necessary, but in general should be kept
+	 * as small as possible.
 	 */
 	static const size_t MAX_DATA_SIZE = 24;
 	/**
-	 * @brief	This constants defines the size of the header, which is added to every message.
+	 * @brief	This constants defines the size of the header,
+	 * 			which is added to every message.
 	 */
 	static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);
 	/**
-	 * @brief	This constant defines the maximum total size in bytes of a sent message.
-	 * @details	It is the sum of the maximum data and the header size. Be aware that this constant
-	 * 			is used to define the buffer sizes for every message queue in the system. So, a change
-	 * 			here may have significant impact on the required resources.
+	 * @brief	This constant defines the maximum total size in bytes
+	 * 			of a sent message.
+	 * @details
+	 * It is the sum of the maximum data and the header size. Be aware that
+	 * this constant is used to define the buffer sizes for every message
+	 * queue in the system. So, a change here may have significant impact on
+	 * the required resources.
 	 */
 	static const size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
 	/**
@@ -81,58 +96,64 @@ public:
 	static const size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
 private:
 	/**
-	 * @brief	This is the internal buffer that contains the actual message data.
+	 * @brief	This is the internal buffer that contains the
+	 * 			actual message data.
 	 */
 	uint8_t internalBuffer[MAX_MESSAGE_SIZE];
 public:
 	/**
-	 * @brief	As no memory is allocated in this class, the destructor is empty.
+	 * @brief	This method is used to get the complete data of the message.
 	 */
-	virtual ~MessageQueueMessage();
+	const uint8_t* getBuffer() const override;
 	/**
 	 * @brief	This method is used to get the complete data of the message.
 	 */
-	const uint8_t* getBuffer() const;
-	/**
-	 * @brief	This method is used to get the complete data of the message.
-	 */
-	uint8_t* getBuffer();
+	uint8_t* getBuffer() override;
 	/**
 	 * @brief	This method is used to fetch the data content of the message.
-	 * @details It shall be used by child classes to add data at the right position.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
 	 */
-	const uint8_t* getData() const;
+	const uint8_t* getData() const override;
 	/**
 	 * @brief	This method is used to fetch the data content of the message.
-	 * @details It shall be used by child classes to add data at the right position.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
 	 */
-	uint8_t* getData();
+	uint8_t* getData() override;
 	/**
-	 * @brief	This method is used to extract the sender's message queue id information from a
-	 * 			received message.
+	 * @brief	This method is used to extract the sender's message
+	 * 			queue id information from a received message.
 	 */
-	MessageQueueId_t getSender() const;
+	MessageQueueId_t getSender() const override;
 	/**
-	 * @brief	With this method, the whole content and the message size is set to zero.
+	 * @brief	With this method, the whole content
+	 * 			and the message size is set to zero.
 	 */
-	void clear();
+	void clear() override;
+
 	/**
-	 * @brief	This is a debug method that prints the content (till messageSize) to the debug output.
+	 * @brief	This method is used to set the sender's message queue id
+	 * 			information prior to ing the message.
+	 * @param setId
+	 * The message queue id that identifies the sending message queue.
 	 */
-	void print();
+	void setSender(MessageQueueId_t setId) override;
 	/**
-	 * @brief	This method is used to set the sender's message queue id information prior to
-	 * 			sending the message.
-	 * @param setId	The message queue id that identifies the sending message queue.
-	 */
-	void setSender(MessageQueueId_t setId);
-	/**
-	 * @brief	This helper function is used by the MessageQueue class to check the size of an
-	 * 			incoming message.
-	 * @details	The method must be overwritten by child classes if size checks shall be more strict.
+	 * @brief	This helper function is used by the MessageQueue class to check
+	 * 			the size of an incoming message.
+	 * @details
+	 * The method must be overwritten by child classes if size
+	 * checks shall be more strict.
 	 * @return	The default implementation returns HEADER_SIZE.
 	 */
-	virtual size_t getMinimumMessageSize() const;
+	virtual size_t getMinimumMessageSize() const override;
+
+	/**
+	 * @brief	This is a debug method that prints the content
+	 * 			(till messageSize) to the debug output.
+	 */
+	void print();
 };
 
 #endif /* MESSAGEQUEUEMESSAGE_H_ */
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 0a6288b02..197a26fd7 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -11,7 +11,9 @@
  * lookup of queueIDs for every call does not sound ideal.
  * In a first step, I'll circumvent the issue by not touching it,
  * maybe in a second step. This also influences Interface design
- * (getCommandQueue) and some other issues.. */
+ * (getCommandQueue) and some other issues..
+ */
+
 typedef uint32_t MessageQueueId_t;
 
 class MessageQueueMessageIF {
@@ -25,14 +27,9 @@ public:
 	 * 			size is set to zero.
 	 */
 	virtual void clear() = 0;
-//	/**
-//	 * @brief	This is a debug method that prints the content
-//	 * 			(till messageSize) to the debug output.
-//	 */
-//	virtual void print() = 0;
 
 	/**
-	 * @brief	Get read-only pointer to the raw buffer.
+	 * @brief	Get read-only pointer to the complete data of the message.
 	 * @return
 	 */
 	virtual const uint8_t* getBuffer() const = 0;
@@ -50,8 +47,25 @@ public:
 	 */
 	virtual void setSender(MessageQueueId_t setId) = 0;
 
+	/**
+	 * @brief	This method is used to extract the sender's message queue id
+	 * 			information from a received message.
+	 */
 	virtual MessageQueueId_t getSender() const = 0;
 
+	/**
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
+	 */
+	virtual const uint8_t* getData() const = 0;
+	/**
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
+	 */
+	virtual uint8_t* getData() = 0;
+
 	/**
 	 * @brief	This helper function is used by the MessageQueue class to
 	 * 			check the size of an incoming message.

From 3277d199ac166db242ff1fb7b5edfab6fa2964ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 01:07:50 +0200
Subject: [PATCH 0428/1774] linux mq update

---
 osal/linux/MessageQueue.cpp | 102 +++++++++++++++++++++---------------
 1 file changed, 60 insertions(+), 42 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 86d1e0d99..a9c140c6b 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -56,16 +56,23 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
 				" for message size" << std::endl;
 		size_t defaultMqMaxMsg = 0;
+		// Not POSIX conformant, but should work for all UNIX systems.
+		// Just an additional helpful printout :-)
 		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
 				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
 			// See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
 			// This happens if the msg_max value is not large enough
 			// It is ignored if the executable is run in privileged mode.
-			// Run the unlockRealtime script or grant the mode manully by using:
+			// Run the unlockRealtime script or grant the mode manually by using:
 			// sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
 
-			// Permanent solution (EventManager has mq depth of 80):
-			// echo msg_max | sudo tee /proc/sys/fs/mqueue/msg_max
+			// Persistent solution for session:
+			// echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
+
+			// Permanent solution:
+			// sudo nano /etc/sysctl.conf
+			// Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
+			// Apply changes with: sudo sysctl -p
 			sif::error << "MessageQueue::MessageQueue: Default MQ size "
 					<< defaultMqMaxMsg << " is too small for requested size "
 					<< messageDepth << std::endl;
@@ -75,24 +82,22 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 	case(EEXIST): {
 		// An error occured during open
 		// We need to distinguish if it is caused by an already created queue
-		if (errno == EEXIST) {
-			//There's another queue with the same name
-			//We unlink the other queue
-			int status = mq_unlink(name);
-			if (status != 0) {
-				sif::error << "mq_unlink Failed with status: " << strerror(errno)
-											<< std::endl;
-			}
-			else {
-				// Successful unlinking, try to open again
-				mqd_t tempId = mq_open(name,
-						O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-						S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
-				if (tempId != -1) {
-					//Successful mq_open
-					this->id = tempId;
-					return HasReturnvaluesIF::RETURN_OK;
-				}
+		//There's another queue with the same name
+		//We unlink the other queue
+		int status = mq_unlink(name);
+		if (status != 0) {
+			sif::error << "mq_unlink Failed with status: " << strerror(errno)
+													<< std::endl;
+		}
+		else {
+			// Successful unlinking, try to open again
+			mqd_t tempId = mq_open(name,
+					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
+			if (tempId != -1) {
+				//Successful mq_open
+				this->id = tempId;
+				return HasReturnvaluesIF::RETURN_OK;
 			}
 		}
 		break;
@@ -150,12 +155,13 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 		//Success but no message received
 		return MessageQueueIF::EMPTY;
 	} else {
-		//No message was received. Keep lastPartner anyway, I might send something later.
-		//But still, delete packet content.
+		//No message was received. Keep lastPartner anyway, I might send
+		//something later. But still, delete packet content.
 		memset(message->getData(), 0, message->MAX_DATA_SIZE);
 		switch(errno){
 		case EAGAIN:
-			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages currently on the specified queue.
+			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
+			//currently on the specified queue.
 			return MessageQueueIF::EMPTY;
 		case EBADF:
 			//mqdes doesn't represent a valid queue open for reading.
@@ -165,9 +171,12 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 		case EINVAL:
 			/*
 			 * This value indicates one of the following:
-			 * * The pointer to the buffer for storing the received message, msg_ptr, is NULL.
-			 * * The number of bytes requested, msg_len is less than zero.
-			 * * msg_len is anything other than the mq_msgsize of the specified queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't been set in the queue's mq_flags.
+			 * - The pointer to the buffer for storing the received message,
+			 *   msg_ptr, is NULL.
+			 * - The number of bytes requested, msg_len is less than zero.
+			 * - msg_len is anything other than the mq_msgsize of the specified
+			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
+			 *   been set in the queue's mq_flags.
 			 */
 			sif::error << "MessageQueue::receive: configuration error "
 					   << strerror(errno)  << std::endl;
@@ -175,8 +184,12 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 		case EMSGSIZE:
 			/*
 			 * This value indicates one of the following:
-			 * * the QNX extended option MQ_READBUF_DYNAMIC hasn't been set, and the given msg_len is shorter than the mq_msgsize for the given queue.
-			 * * the extended option MQ_READBUF_DYNAMIC has been set, but the given msg_len is too short for the message that would have been received.
+			 * - the QNX extended option MQ_READBUF_DYNAMIC hasn't been set,
+			 *   and the given msg_len is shorter than the mq_msgsize for
+			 *   the given queue.
+			 * - the extended option MQ_READBUF_DYNAMIC has been set, but the
+			 *   given msg_len is too short for the message that would have
+			 *   been received.
 			 */
 			sif::error << "MessageQueue::receive: configuration error "
 			           << strerror(errno)  << std::endl;
@@ -224,9 +237,10 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		case EINVAL:
 			/*
 			 * This value indicates one of the following:
-			 * * mq_attr is NULL.
-			 * * MQ_MULT_NOTIFY had been set for this queue, and the given mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once MQ_MULT_NOTIFY has been turned on, it may never be turned off.
-			 *
+			 *  - mq_attr is NULL.
+			 *  - MQ_MULT_NOTIFY had been set for this queue, and the given
+			 *    mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once
+			 *    MQ_MULT_NOTIFY has been turned on, it may never be turned off.
 			 */
 		default:
 			return HasReturnvaluesIF::RETURN_FAILED;
@@ -275,7 +289,8 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	//TODO: Check if we're in ISR.
 	if (result != 0) {
 		if(!ignoreFault){
-			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
 						objects::INTERNAL_ERROR_REPORTER);
 			if (internalErrorReporter != NULL) {
 				internalErrorReporter->queueMessageNotSent();
@@ -283,10 +298,13 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		}
 		switch(errno){
 		case EAGAIN:
-			//The O_NONBLOCK flag was set when opening the queue, or the MQ_NONBLOCK flag was set in its attributes, and the specified queue is full.
+			//The O_NONBLOCK flag was set when opening the queue, or the
+			//MQ_NONBLOCK flag was set in its attributes, and the
+			//specified queue is full.
 			return MessageQueueIF::FULL;
 		case EBADF:
-			//mq_des doesn't represent a valid message queue descriptor, or mq_des wasn't opened for writing.
+			//mq_des doesn't represent a valid message queue descriptor,
+			//or mq_des wasn't opened for writing.
 			sif::error << "MessageQueue::sendMessage: Configuration error "
 			           << strerror(errno) << " in mq_send mqSendTo: " << sendTo
 					   << " sent from " << sentFrom << std::endl;
@@ -296,13 +314,13 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		case EINVAL:
 			/*
 			 * This value indicates one of the following:
-			 * * msg_ptr is NULL.
-			 * * msg_len is negative.
-			 * * msg_prio is greater than MQ_PRIO_MAX.
-			 * * msg_prio is less than 0.
-			 * * MQ_PRIO_RESTRICT is set in the mq_attr of mq_des,
-			 *   and msg_prio is greater than the priority of the calling process.
-			 * */
+			 * - msg_ptr is NULL.
+			 * - msg_len is negative.
+			 * - msg_prio is greater than MQ_PRIO_MAX.
+			 * - msg_prio is less than 0.
+			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
+			 *   msg_prio is greater than the priority of the calling process.
+			 */
 			sif::error << "MessageQueue::sendMessage: Configuration error "
 			           << strerror(errno) << " in mq_send" << std::endl;
 			/*NO BREAK*/

From 20e3b3c0e2eeec791f2f7c25e1893808af28c0eb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 01:10:16 +0200
Subject: [PATCH 0429/1774] 0 replaced by MQIF::NO_QUEUE

---
 osal/linux/MessageQueue.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index a9c140c6b..a0749ded3 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -9,8 +9,9 @@
 #include <errno.h>
 
 
-MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize): id(0),
-		lastPartner(0), defaultDestination(NO_QUEUE) {
+MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
+		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
+		defaultDestination(MessageQueueIF::NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
 	this->id = 0;

From 52c887925fe68f0729db72925c24e3b703ca600b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 20:53:28 +0200
Subject: [PATCH 0430/1774] iomanip include

---
 objectmanager/ObjectManager.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index cfdf65621..1c54355a3 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,5 +1,6 @@
 #include <framework/objectmanager/ObjectManager.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <iomanip>
 #include <cstdlib>
 
 ObjectManager::ObjectManager( void (*setProducer)() ):

From 606957dc243f31d18d80f51885f4684fc134186b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 21:26:45 +0200
Subject: [PATCH 0431/1774] PSB update

---
 tmtcservices/PusServiceBase.cpp | 74 +++++++++++++++++++--------------
 tmtcservices/PusServiceBase.h   |  8 ++--
 2 files changed, 48 insertions(+), 34 deletions(-)

diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index c27defe61..f5d1e30bd 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -9,10 +9,11 @@
 object_id_t PusServiceBase::packetSource = 0;
 object_id_t PusServiceBase::packetDestination = 0;
 
-PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid, uint8_t setServiceId) :
-		SystemObject(setObjectId), apid(setApid), serviceId(setServiceId), errorParameter1(
-				0), errorParameter2(0), requestQueue(NULL) {
-	requestQueue = QueueFactory::instance()->createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
+PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid,
+		uint8_t setServiceId) :
+		SystemObject(setObjectId), apid(setApid), serviceId(setServiceId) {
+	requestQueue = QueueFactory::instance()->
+			createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
 }
 
 PusServiceBase::~PusServiceBase() {
@@ -20,51 +21,60 @@ PusServiceBase::~PusServiceBase() {
 }
 
 ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
+	handleRequestQueue();
+	ReturnValue_t result = this->performService();
+	if (result != RETURN_OK) {
+		sif::error << "PusService " << (uint16_t) this->serviceId
+				<< ": performService returned with " << (int16_t) result
+				<< std::endl;
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void PusServiceBase::handleRequestQueue() {
 	TmTcMessage message;
+	ReturnValue_t result = RETURN_FAILED;
 	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
 		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
-		//	debug << "PusServiceBase::performOperation: Receiving from MQ ID: " << std::hex << this->requestQueue.getId()
-		// << std::dec << " returned: " << status << std::endl;
+		//	debug << "PusServiceBase::performOperation: Receiving from MQ ID: "
+		//      << std::hex << this->requestQueue.getId()
+		//      << std::dec << " returned: " << status << std::endl;
 		if (status == RETURN_OK) {
 			this->currentPacket.setStoreAddress(message.getStorageId());
-			//	info << "Service " << (uint16_t) this->serviceId << ": new packet!" << std::endl;
+			//info << "Service " << (uint16_t) this->serviceId <<
+			//     ": new packet!" << std::endl;
 
-			ReturnValue_t return_code = this->handleRequest(currentPacket.getSubService());
+			result = this->handleRequest(currentPacket.getSubService());
 
-			// debug << "Service " << (uint16_t)this->serviceId << ": handleRequest returned: " << (int)return_code << std::endl;
-			if (return_code == RETURN_OK) {
+			// debug << "Service " << (uint16_t)this->serviceId <<
+			//    ": handleRequest returned: " << (int)return_code << std::endl;
+			if (result == RETURN_OK) {
 				this->verifyReporter.sendSuccessReport(
 						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
-			} else {
+			}
+			else {
 				this->verifyReporter.sendFailureReport(
 						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
-						return_code, 0, errorParameter1, errorParameter2);
+						result, 0, errorParameter1, errorParameter2);
 			}
 			this->currentPacket.deletePacket();
 			errorParameter1 = 0;
 			errorParameter2 = 0;
-		} else if (status == MessageQueueIF::EMPTY) {
+		}
+		else if (status == MessageQueueIF::EMPTY) {
 			status = RETURN_OK;
-			// debug << "PusService " << (uint16_t)this->serviceId << ": no new packet." << std::endl;
+			// debug << "PusService " << (uint16_t)this->serviceId <<
+			//      ": no new packet." << std::endl;
 			break;
-		} else {
-
+		}
+		else {
 			sif::error << "PusServiceBase::performOperation: Service "
 					<< (uint16_t) this->serviceId
 					<< ": Error receiving packet. Code: " << std::hex << status
 					<< std::dec << std::endl;
 		}
 	}
-	ReturnValue_t return_code = this->performService();
-	if (return_code == RETURN_OK) {
-		return RETURN_OK;
-	} else {
-
-		sif::error << "PusService " << (uint16_t) this->serviceId
-				<< ": performService returned with " << (int16_t) return_code
-				<< std::endl;
-		return RETURN_FAILED;
-	}
 }
 
 uint16_t PusServiceBase::getIdentifier() {
@@ -80,19 +90,21 @@ ReturnValue_t PusServiceBase::initialize() {
 	if (result != RETURN_OK) {
 		return result;
 	}
-	AcceptsTelemetryIF* dest_service = objectManager->get<AcceptsTelemetryIF>(
+	AcceptsTelemetryIF* destService = objectManager->get<AcceptsTelemetryIF>(
 			packetDestination);
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
-	if ((dest_service != NULL) && (distributor != NULL)) {
+	if ((destService != nullptr) && (distributor != nullptr)) {
 		this->requestQueue->setDefaultDestination(
-				dest_service->getReportReceptionQueue());
+				destService->getReportReceptionQueue());
 		distributor->registerService(this);
 		return RETURN_OK;
-	} else {
+	}
+	else {
 		sif::error << "PusServiceBase::PusServiceBase: Service "
 				<< (uint32_t) this->serviceId << ": Configuration error."
-				<< " Make sure packetSource and packetDestination are defined correctly" << std::endl;
+				<< " Make sure packetSource and packetDestination are defined "
+			       "correctly" << std::endl;
 		return RETURN_FAILED;
 	}
 }
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index dbb1754ce..5f741410a 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -97,16 +97,16 @@ protected:
 	/**
 	 * One of two error parameters for additional error information.
 	 */
-	uint32_t errorParameter1;
+	uint32_t errorParameter1 = 0;
 	/**
 	 * One of two error parameters for additional error information.
 	 */
-	uint32_t errorParameter2;
+	uint32_t errorParameter2 = 0;
 	/**
 	 * This is a complete instance of the Telecommand reception queue of the class.
 	 * It is initialized on construction of the class.
 	 */
-	MessageQueueIF* requestQueue;
+	MessageQueueIF* requestQueue = nullptr;
 	/**
 	 * An instance of the VerificationReporter class, that simplifies sending any kind of
 	 * Verification Message to the TC Verification Service.
@@ -127,6 +127,8 @@ private:
 	 * Remember that one packet must be completely handled in one #handleRequest call.
 	 */
 	static const uint8_t PUS_SERVICE_MAX_RECEPTION = 10;
+
+	void handleRequestQueue();
 };
 
 #endif /* PUSSERVICEBASE_H_ */

From 659594bac71505492c01feff182a2577f79fb1fe Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 21:35:47 +0200
Subject: [PATCH 0432/1774] better include guard and doc form improvement

---
 tmtcservices/PusServiceBase.h | 80 +++++++++++++++++++++--------------
 1 file changed, 48 insertions(+), 32 deletions(-)

diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 5f741410a..39600c413 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -1,5 +1,5 @@
-#ifndef PUSSERVICEBASE_H_
-#define PUSSERVICEBASE_H_
+#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/objectmanager/SystemObject.h>
@@ -9,7 +9,6 @@
 #include <framework/tmtcservices/AcceptsTelecommandsIF.h>
 #include <framework/tmtcservices/VerificationCodes.h>
 #include <framework/tmtcservices/VerificationReporter.h>
-#include <framework/internalError/InternalErrorReporterIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 
 namespace Factory{
@@ -17,18 +16,22 @@ void setStaticFrameworkObjectIds();
 }
 
 /**
- * \defgroup pus_services PUS Service Framework
+ * @defgroup pus_services PUS Service Framework
  * These group contains all implementations of PUS Services in the OBSW.
  * Most of the Services are directly taken from the ECSS PUS Standard.
  */
 
 /**
- * \brief This class is the basis for all PUS Services, which can immediately process Telecommand Packets.
- * It manages Telecommand reception and the generation of Verification Reports. Every class that inherits
- * from this abstract class has to implement handleRequest and performService. Services that are created with this
+ * @brief 	This class is the basis for all PUS Services,
+ * 			which can immediately process Telecommand Packets.
+ * @details
+ * It manages Telecommand reception and the generation of Verification Reports.
+ * Every class that inherits from this abstract class has to implement
+ * handleRequest and performService. Services that are created with this
  * Base class have to handle any kind of request immediately on reception.
- * All PUS Services are System Objects, so an Object ID needs to be specified on construction.
- * \ingroup pus_services
+ * All PUS Services are System Objects, so an Object ID needs to be specified
+ * on construction.
+ * @ingroup pus_services
  */
 class PusServiceBase : public ExecutableObjectIF,
         public AcceptsTelecommandsIF,
@@ -37,49 +40,61 @@ class PusServiceBase : public ExecutableObjectIF,
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	/**
-	 * The constructor for the class.
-	 * The passed values are set, but inter-object initialization is done in the initialize method.
-	 * @param setObjectId		The system object identifier of this Service instance.
-	 * @param set_apid			The APID the Service is instantiated for.
-	 * @param set_service_id	The Service Identifier as specified in ECSS PUS.
+	 * @brief	The passed values are set, but inter-object initialization is
+	 * 			done in the initialize method.
+	 * @param setObjectId
+	 * The system object identifier of this Service instance.
+	 * @param setApid
+	 * The APID the Service is instantiated for.
+	 * @param setServiceId
+	 * The Service Identifier as specified in ECSS PUS.
 	 */
-	PusServiceBase(	object_id_t setObjectId, uint16_t setApid, uint8_t setServiceId);
+	PusServiceBase(	object_id_t setObjectId, uint16_t setApid,
+			uint8_t setServiceId);
 	/**
 	 * The destructor is empty.
 	 */
 	virtual ~PusServiceBase();
 	/**
-	 * @brief The handleRequest method shall handle any kind of Telecommand Request immediately.
+	 * @brief 	The handleRequest method shall handle any kind of Telecommand
+	 * 			Request immediately.
 	 * @details
-	 * Implemetations can take the Telecommand in currentPacket and perform any kind of operation.
-	 * They may send additional "Start Success (1,3)" messages with the verifyReporter, but Completion
-	 * Success or Failure Reports are generated automatically after execution of this method.
+	 * Implemetations can take the Telecommand in currentPacket and perform
+	 * any kind of operation.
+	 * They may send additional "Start Success (1,3)" messages with the
+	 * verifyReporter, but Completion Success or Failure Reports are generated
+	 * automatically after execution of this method.
 	 *
 	 * If a Telecommand can not be executed within one call cycle,
 	 * this Base class is not the right parent.
 	 *
-	 * The child class may add additional error information by setting #errorParameters which are
-	 * attached to the generated verification message.
+	 * The child class may add additional error information by setting
+	 * #errorParameters which aren attached to the generated verification
+	 * message.
 	 *
 	 * Subservice checking should be implemented in this method.
 	 *
-	 * @return	The returned status_code is directly taken as main error code in the Verification Report.
+	 * @return	The returned status_code is directly taken as main error code
+	 * 			in the Verification Report.
 	 * 			On success, RETURN_OK shall be returned.
 	 */
 	virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
 	/**
-	 * In performService, implementations can handle periodic, non-TC-triggered activities.
+	 * In performService, implementations can handle periodic,
+	 * non-TC-triggered activities.
 	 * The performService method is always called.
-	 * @return	A success or failure code that does not trigger any kind of verification message.
+	 * @return	Currently, everything other that RETURN_OK only triggers
+	 * 			diagnostic output.
 	 */
 	virtual ReturnValue_t performService() = 0;
 	/**
 	 * This method implements the typical activity of a simple PUS Service.
-	 * It checks for new requests, and, if found, calls handleRequest, sends completion verification messages and deletes
+	 * It checks for new requests, and, if found, calls handleRequest, sends
+	 * completion verification messages and deletes
 	 * the TC requests afterwards.
 	 * performService is always executed afterwards.
-	 * @return	\c RETURN_OK if the periodic performService was successful.
-	 * 			\c RETURN_FAILED else.
+	 * @return	@c RETURN_OK if the periodic performService was successful.
+	 * 			@c RETURN_FAILED else.
 	 */
 	ReturnValue_t performOperation(uint8_t opCode);
 	virtual uint16_t getIdentifier();
@@ -103,13 +118,13 @@ protected:
 	 */
 	uint32_t errorParameter2 = 0;
 	/**
-	 * This is a complete instance of the Telecommand reception queue of the class.
-	 * It is initialized on construction of the class.
+	 * This is a complete instance of the telecommand reception queue
+	 * of the class. It is initialized on construction of the class.
 	 */
 	MessageQueueIF* requestQueue = nullptr;
 	/**
-	 * An instance of the VerificationReporter class, that simplifies sending any kind of
-	 * Verification Message to the TC Verification Service.
+	 * An instance of the VerificationReporter class, that simplifies
+	 * sending any kind of verification message to the TC Verification Service.
 	 */
 	VerificationReporter verifyReporter;
 	/**
@@ -124,7 +139,8 @@ protected:
 private:
 	/**
 	 * This constant sets the maximum number of packets accepted per call.
-	 * Remember that one packet must be completely handled in one #handleRequest call.
+	 * Remember that one packet must be completely handled in one
+	 * #handleRequest call.
 	 */
 	static const uint8_t PUS_SERVICE_MAX_RECEPTION = 10;
 

From 5007041bc87e39a44284de14f465fa0478cbc2a0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 22:12:29 +0200
Subject: [PATCH 0433/1774] cleaned up includes and improved doc a bit

---
 tmtcservices/CommandingServiceBase.cpp |  27 +++---
 tmtcservices/CommandingServiceBase.h   | 114 ++++++++++++++-----------
 2 files changed, 76 insertions(+), 65 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index adc9400fa..361baf3b6 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -1,22 +1,21 @@
-/*
- * CommandingServiceBase.cpp
- *
- *  Created on: 28.08.2019
- *      Author: gaisser
- */
+#include <framework/tcdistribution/PUSDistributorIF.h>
+#include <framework/tmtcservices/AcceptsTelemetryIF.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
 
 #include <framework/tmtcservices/CommandingServiceBase.h>
+#include <framework/tmtcservices/TmTcMessage.h>
+#include <framework/ipc/QueueFactory.h>
+#include <framework/tmtcpacket/pus/TcPacketStored.h>
+#include <framework/tmtcpacket/pus/TmPacketStored.h>
 
 CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
 		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
-		uint16_t commandTimeout_seconds, object_id_t setPacketSource,
+		uint16_t commandTimeoutSeconds, object_id_t setPacketSource,
 		object_id_t setPacketDestination, size_t queueDepth) :
-		SystemObject(setObjectId), apid(apid), service(service), timeout_seconds(
-				commandTimeout_seconds), tmPacketCounter(0), IPCStore(NULL), TCStore(
-		NULL), commandQueue(NULL), requestQueue(NULL), commandMap(
-				numberOfParallelCommands), failureParameter1(0), failureParameter2(
-				0), packetSource(setPacketSource), packetDestination(
-				setPacketDestination),executingTask(NULL) {
+		SystemObject(setObjectId), apid(apid), service(service),
+		timeoutSeconds(commandTimeoutSeconds),
+		commandMap(numberOfParallelCommands), packetSource(setPacketSource),
+		packetDestination(setPacketDestination) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 }
@@ -369,7 +368,7 @@ void CommandingServiceBase::checkTimeout() {
 	typename FixedMap<MessageQueueId_t,
 			CommandingServiceBase::CommandInfo>::Iterator iter;
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
-		if ((iter->uptimeOfStart + (timeout_seconds * 1000)) < uptime) {
+		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
 					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index e79e806de..37f6891c4 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -1,35 +1,33 @@
-#ifndef COMMANDINGSERVICEBASE_H_
-#define COMMANDINGSERVICEBASE_H_
+#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
 
-#include <framework/container/FixedMap.h>
-#include <framework/container/FIFO.h>
-#include <framework/ipc/CommandMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/objectmanager/SystemObject.h>
-#include <framework/serialize/SerializeAdapter.h>
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/tcdistribution/PUSDistributorIF.h>
-#include <framework/tmtcpacket/pus/TcPacketStored.h>
-#include <framework/tmtcpacket/pus/TmPacketStored.h>
+#include <framework/ipc/MessageQueueIF.h>
 #include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/tmtcservices/AcceptsTelemetryIF.h>
-#include <framework/tmtcservices/TmTcMessage.h>
+
 #include <framework/tmtcservices/VerificationReporter.h>
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/timemanager/Clock.h>
+#include <framework/ipc/CommandMessage.h>
+#include <framework/container/FixedMap.h>
+#include <framework/container/FIFO.h>
+#include <framework/serialize/SerializeIF.h>
+
+class TcPacketStored;
 
 /**
- * \brief This class is the basis for all PUS Services, which have to relay Telecommands to software bus.
+ * @brief 	This class is the basis for all PUS Services, which have to
+ * 			relay Telecommands to software bus.
  *
- * It manages Telecommand reception and the generation of Verification Reports like PUSServiceBase.
- * Every class that inherits from this abstract class has to implement four adaption points:
+ * It manages Telecommand reception and the generation of Verification Reports
+ * similar to PusServiceBase. This class is used if a telecommand can't be
+ * handled immediately and must be relayed to the internal software bus.
  *   - isValidSubservice
  *   - getMessageQueueAndObject
  *   - prepareCommand
  *   - handleReply
- * \ingroup pus_services
+ * @author gaisser
+ * @ingroup pus_services
  */
 class CommandingServiceBase: public SystemObject,
 		public AcceptsTelecommandsIF,
@@ -59,7 +57,7 @@ public:
 	 */
 	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
 			uint8_t service, uint8_t numberOfParallelCommands,
-			uint16_t commandTimeout_seconds, object_id_t setPacketSource,
+			uint16_t commandTimeoutSeconds, object_id_t setPacketSource,
 			object_id_t setPacketDestination, size_t queueDepth = 20);
 	virtual ~CommandingServiceBase();
 
@@ -113,8 +111,9 @@ protected:
 	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
 
 	/**
-	 * Once a TC Request is valid, the existence of the destination and its target interface is checked and retrieved.
-	 * The target message queue ID can then be acquired by using the target interface.
+	 * Once a TC Request is valid, the existence of the destination and its
+	 * target interface is checked and retrieved. The target message queue ID
+	 * can then be acquired by using the target interface.
 	 * @param subservice
 	 * @param tcData Application Data of TC Packet
 	 * @param tcDataLen
@@ -129,10 +128,10 @@ protected:
 			object_id_t *objectId) = 0;
 
 	/**
-	 * After the Message Queue and Object ID are determined,
-	 * the command is prepared by using an implementation specific CommandMessage type
-	 * which is sent to the target object.
-	 * It contains all necessary information for the device to execute telecommands.
+	 * After the Message Queue and Object ID are determined, the command is
+	 * prepared by using an implementation specific CommandMessage type
+	 * which is sent to the target object. It contains all necessary information
+	 * for the device to execute telecommands.
 	 * @param message
 	 * @param subservice
 	 * @param tcData
@@ -146,25 +145,40 @@ protected:
 			uint32_t *state, object_id_t objectId) = 0;
 
 	/**
-	 * This function is responsible for the communication between the Command Service Base
-	 * and the respective PUS Commanding Service once the execution has started.
-	 * The PUS Commanding Service receives replies from the target device and forwards them by calling this function.
-	 * There are different translations of these replies to specify how the Command Service proceeds.
-	 * @param reply[out] Command Message which contains information about the command
-	 * @param previousCommand [out]
-	 * @param state
-	 * @param optionalNextCommand
+	 * This function is implemented by child services to specify how replies
+	 * to a command from another software component are handled
+	 * @param reply
+	 * This is the reply in form of a command message.
+	 * @param previousCommand
+	 * Command_t of related command
+	 * @param state [out/in]
+	 * Additional parameter which can be used to pass state information.
+	 * State of the communication
+	 * @param optionalNextCommand [out]
+	 * An optional next command which can be set in this function
 	 * @param objectId Source object ID
 	 * @param isStep Flag value to mark steps of command execution
-	 * @return - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to generate TC verification success
-	 *         - @c INVALID_REPLY can handle unrequested replies
-	 *         - Anything else triggers a TC verification failure
+	 * @return
+	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
+	 *   generate TC verification success
+	 * - @c INVALID_REPLY calls handleUnrequestedReply
+	 * - Anything else triggers a TC verification failure
 	 */
 	virtual ReturnValue_t handleReply(const CommandMessage *reply,
 			Command_t previousCommand, uint32_t *state,
 			CommandMessage *optionalNextCommand, object_id_t objectId,
 			bool *isStep) = 0;
 
+	/**
+	 * This function can be overidden to handle unrequested reply,
+	 * when the reply sender ID is unknown or is not found is the command map.
+	 * @param reply
+	 */
+	virtual void handleUnrequestedReply(CommandMessage *reply);
+
+	virtual void doPeriodicOperation();
+
+
 	struct CommandInfo {
 		struct tcInfo {
 			uint8_t ackFlags;
@@ -184,33 +198,35 @@ protected:
 
 	const uint8_t service;
 
-	const uint16_t timeout_seconds;
+	const uint16_t timeoutSeconds;
 
-	uint8_t tmPacketCounter;
+	uint8_t tmPacketCounter = 0;
 
-	StorageManagerIF *IPCStore;
+	StorageManagerIF *IPCStore = nullptr;
 
-	StorageManagerIF *TCStore;
+	StorageManagerIF *TCStore = nullptr;
 
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 
-	MessageQueueIF* requestQueue;
+	MessageQueueIF* requestQueue = nullptr;
 
 	VerificationReporter verificationReporter;
 
 	FixedMap<MessageQueueId_t, CommandInfo> commandMap;
 
-	uint32_t failureParameter1; //!< May be set be children to return a more precise failure condition.
-	uint32_t failureParameter2; //!< May be set be children to return a more precise failure condition.
+	/* May be set be children to return a more precise failure condition. */
+	uint32_t failureParameter1 = 0;
+	uint32_t failureParameter2 = 0;
 
 	object_id_t packetSource;
 
 	object_id_t packetDestination;
 
 	/**
-	 * 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;
+	PeriodicTaskIF* executingTask = nullptr;
 
 	/**
 	 * @brief   Send TM data from pointer to data.
@@ -246,10 +262,6 @@ protected:
 	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
 			SerializeIF* header = nullptr);
 
-	virtual void handleUnrequestedReply(CommandMessage *reply);
-
-	virtual void doPeriodicOperation();
-
 	void checkAndExecuteFifo(
 			typename FixedMap<MessageQueueId_t, CommandInfo>::Iterator *iter);
 

From bb9a299e33ce7429314acb58606f964613a31589 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 22:19:40 +0200
Subject: [PATCH 0434/1774] added back removed comments

---
 tmtcservices/CommandingServiceBase.h | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 37f6891c4..f97eabb0e 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -132,11 +132,12 @@ protected:
 	 * prepared by using an implementation specific CommandMessage type
 	 * which is sent to the target object. It contains all necessary information
 	 * for the device to execute telecommands.
-	 * @param message
-	 * @param subservice
-	 * @param tcData
-	 * @param tcDataLen
-	 * @param state
+	 * @param message [out] message which can be set and is sent to the object
+	 * @param subservice Subservice of the current communication
+	 * @param tcData Application data of command
+	 * @param tcDataLen Application data length
+	 * @param state [out/in] Setable state of the communication.
+	 * communication
 	 * @param objectId Target object ID
 	 * @return
 	 */

From 3268806f75a3ea8ceaf7ce933276133d26b05719 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 22:51:54 +0200
Subject: [PATCH 0435/1774] split up huge function to be more readable

---
 tmtcservices/CommandingServiceBase.cpp | 193 ++++++++++++++-----------
 tmtcservices/CommandingServiceBase.h   |   7 +
 2 files changed, 113 insertions(+), 87 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 361baf3b6..4c557f82d 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -56,7 +56,7 @@ ReturnValue_t CommandingServiceBase::initialize() {
 			objectManager->get<AcceptsTelemetryIF>(packetDestination);
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
-	if ((packetForwarding == NULL) && (distributor == NULL)) {
+	if (packetForwarding == nullptr or distributor == nullptr) {
 		return RETURN_FAILED;
 	}
 
@@ -67,7 +67,7 @@ ReturnValue_t CommandingServiceBase::initialize() {
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 
-	if ((IPCStore == NULL) || (TCStore == NULL)) {
+	if (IPCStore == nullptr or TCStore == nullptr) {
 		return RETURN_FAILED;
 	}
 
@@ -76,97 +76,116 @@ ReturnValue_t CommandingServiceBase::initialize() {
 }
 
 void CommandingServiceBase::handleCommandQueue() {
-	CommandMessage reply, nextCommand;
-	ReturnValue_t result, sendResult = RETURN_OK;
-	bool isStep = false;
+	CommandMessage reply;
+	ReturnValue_t result = RETURN_FAILED;
 	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
 			result = commandQueue->receiveMessage(&reply)) {
-		isStep = false;
-		typename FixedMap<MessageQueueId_t,
-				CommandingServiceBase::CommandInfo>::Iterator iter;
-		if (reply.getSender() == MessageQueueIF::NO_QUEUE) {
-			handleUnrequestedReply(&reply);
-			continue;
-		}
-		if ((iter = commandMap.find(reply.getSender())) == commandMap.end()) {
-			handleUnrequestedReply(&reply);
-			continue;
-		}
-		nextCommand.setCommand(CommandMessage::CMD_NONE);
-		result = handleReply(&reply, iter->command, &iter->state, &nextCommand,
-				iter->objectId, &isStep);
-		switch (result) {
-		case EXECUTION_COMPLETE:
-		case RETURN_OK:
-		case NO_STEP_MESSAGE:
-			iter->command = nextCommand.getCommand();
-			if (nextCommand.getCommand() != CommandMessage::CMD_NONE) {
-				sendResult = commandQueue->sendMessage(reply.getSender(),
-						&nextCommand);
-			}
-			if (sendResult == RETURN_OK) {
-				if (isStep) {
-					if (result != NO_STEP_MESSAGE) {
-						verificationReporter.sendSuccessReport(
-								TC_VERIFY::PROGRESS_SUCCESS,
-								iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-								iter->tcInfo.tcSequenceControl, ++iter->step);
-					}
-				} else {
-					verificationReporter.sendSuccessReport(
-							TC_VERIFY::COMPLETION_SUCCESS,
-							iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-							iter->tcInfo.tcSequenceControl, 0);
-					checkAndExecuteFifo(&iter);
-				}
-			} else {
-				if (isStep) {
-					nextCommand.clearCommandMessage();
-					verificationReporter.sendFailureReport(
-							TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-							iter->tcInfo.tcPacketId,
-							iter->tcInfo.tcSequenceControl, sendResult,
-							++iter->step, failureParameter1, failureParameter2);
-				} else {
-					nextCommand.clearCommandMessage();
-					verificationReporter.sendFailureReport(
-							TC_VERIFY::COMPLETION_FAILURE,
-							iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-							iter->tcInfo.tcSequenceControl, sendResult, 0,
-							failureParameter1, failureParameter2);
-				}
-				failureParameter1 = 0;
-				failureParameter2 = 0;
-				checkAndExecuteFifo(&iter);
-			}
-			break;
-		case INVALID_REPLY:
-			//might be just an unrequested reply at a bad moment
-			handleUnrequestedReply(&reply);
-			break;
-		default:
-			if (isStep) {
-				verificationReporter.sendFailureReport(
-						TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-						iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-						result, ++iter->step, failureParameter1,
-						failureParameter2);
-			} else {
-				verificationReporter.sendFailureReport(
-						TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-						iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-						result, 0, failureParameter1, failureParameter2);
-			}
-			failureParameter1 = 0;
-			failureParameter2 = 0;
-			checkAndExecuteFifo(&iter);
-			break;
-		}
-
+		handleCommandMessage(reply);
 	}
 }
 
 
+void CommandingServiceBase::handleCommandMessage(CommandMessage& reply) {
+	bool isStep = false;
+	CommandMessage nextCommand;
+	CommandMapIter iter;
+	if (reply.getSender() == MessageQueueIF::NO_QUEUE) {
+		handleUnrequestedReply(&reply);
+		return;
+	}
+	if ((iter = commandMap.find(reply.getSender())) == commandMap.end()) {
+		handleUnrequestedReply(&reply);
+		return;
+	}
+	nextCommand.setCommand(CommandMessage::CMD_NONE);
+
+	// Implemented by child class, specifies what to do with reply.
+	ReturnValue_t result = handleReply(&reply, iter->command, &iter->state,
+			&nextCommand, iter->objectId, &isStep);
+
+	switch (result) {
+	case EXECUTION_COMPLETE:
+	case RETURN_OK:
+	case NO_STEP_MESSAGE:
+		// handle result of reply handler implemented by developer.
+		handleReplyHandlerResult(result, iter, nextCommand, reply, isStep);
+		break;
+	case INVALID_REPLY:
+		//might be just an unrequested reply at a bad moment
+		handleUnrequestedReply(&reply);
+		break;
+	default:
+		if (isStep) {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, ++iter->step, failureParameter1,
+					failureParameter2);
+		} else {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, 0, failureParameter1, failureParameter2);
+		}
+		failureParameter1 = 0;
+		failureParameter2 = 0;
+		checkAndExecuteFifo(&iter);
+		break;
+	}
+
+}
+
+void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
+		CommandMapIter iter, CommandMessage& nextCommand, CommandMessage& reply,
+		bool& isStep) {
+	iter->command = nextCommand.getCommand();
+
+	// In case a new command is to be sent immediately, this is performed here.
+	// If no new command is sent, only analyse reply result by initializing
+	// sendResult as RETURN_OK
+	ReturnValue_t sendResult = RETURN_OK;
+	if (nextCommand.getCommand() != CommandMessage::CMD_NONE) {
+		sendResult = commandQueue->sendMessage(reply.getSender(),
+				&nextCommand);
+	}
+
+	if (sendResult == RETURN_OK) {
+		if (isStep and result != NO_STEP_MESSAGE) {
+			verificationReporter.sendSuccessReport(
+					TC_VERIFY::PROGRESS_SUCCESS,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, ++iter->step);
+		}
+		else {
+			verificationReporter.sendSuccessReport(
+					TC_VERIFY::COMPLETION_SUCCESS,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, 0);
+			checkAndExecuteFifo(&iter);
+		}
+	}
+	else {
+		if (isStep) {
+			nextCommand.clearCommandMessage();
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult,
+					++iter->step, failureParameter1, failureParameter2);
+		} else {
+			nextCommand.clearCommandMessage();
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult, 0,
+					failureParameter1, failureParameter2);
+		}
+		failureParameter1 = 0;
+		failureParameter2 = 0;
+		checkAndExecuteFifo(&iter);
+	}
+}
+
 void CommandingServiceBase::handleRequestQueue() {
 	TmTcMessage message;
 	ReturnValue_t result;
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index f97eabb0e..9a68a2d3c 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -267,6 +267,9 @@ protected:
 			typename FixedMap<MessageQueueId_t, CommandInfo>::Iterator *iter);
 
 private:
+	using CommandMapIter = FixedMap<MessageQueueId_t,
+			CommandingServiceBase::CommandInfo>::Iterator;
+
 	/**
 	 * This method handles internal execution of a command,
 	 * once it has been started by @sa{startExecution()} in the Request Queue handler.
@@ -298,6 +301,10 @@ private:
 	void startExecution(TcPacketStored *storedPacket,
 			typename FixedMap<MessageQueueId_t, CommandInfo>::Iterator *iter);
 
+	void handleCommandMessage(CommandMessage& reply);
+	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
+			CommandMessage& nextCommand,CommandMessage& reply, bool& isStep);
+
 	void checkTimeout();
 };
 

From a9c7ad84c8b93c39021194e99306e023432b4ee0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Jun 2020 02:03:18 +0200
Subject: [PATCH 0436/1774] added new interface to host and linux osal

---
 ipc/CommandMessage.cpp      |  8 ++++++++
 ipc/CommandMessage.h        |  2 ++
 ipc/MessageQueueMessage.cpp |  8 ++++++++
 ipc/MessageQueueMessage.h   |  4 ++++
 ipc/MessageQueueMessageIF.h | 12 ++++++++++++
 osal/host/MessageQueue.cpp  | 30 ++++++++++++++++++++----------
 osal/host/MessageQueue.h    | 16 ++++++++--------
 osal/host/QueueFactory.cpp  |  2 +-
 osal/linux/MessageQueue.cpp | 25 +++++++++++++------------
 osal/linux/MessageQueue.h   | 21 +++++++++++++--------
 osal/linux/QueueFactory.cpp |  2 +-
 11 files changed, 90 insertions(+), 40 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 44424e023..7d2ecc9bd 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -160,3 +160,11 @@ uint8_t* CommandMessage::getData() {
 const uint8_t* CommandMessage::getData() const {
 	return internalMessage->getData();
 }
+
+size_t CommandMessage::getMessageSize() const {
+	return COMMAND_MESSAGE_SIZE;
+}
+
+size_t CommandMessage::getMaximumMessageSize() const {
+	return MessageQueueMessage::MAX_MESSAGE_SIZE;
+}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 772bd774d..25d608f04 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -85,6 +85,8 @@ public:
 	uint8_t * getData() override;
 	const uint8_t* getData() const override;
 	size_t getMinimumMessageSize() const override;
+	size_t getMessageSize() const override;
+	size_t getMaximumMessageSize() const override;
 
 	/**
 	 * Extract message ID, which is the first byte of the command ID.
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index c3e1cb7a8..8430a8ea3 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -67,3 +67,11 @@ void MessageQueueMessage::print() {
 void MessageQueueMessage::clear() {
 	memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
 }
+
+size_t MessageQueueMessage::getMessageSize() const {
+	return this->messageSize;
+}
+
+size_t MessageQueueMessage::getMaximumMessageSize() const {
+	return this->MAX_MESSAGE_SIZE;
+}
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index bee39ae62..31a43f663 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -149,6 +149,10 @@ public:
 	 */
 	virtual size_t getMinimumMessageSize() const override;
 
+	virtual size_t getMessageSize() const override;
+
+	virtual size_t getMaximumMessageSize() const override;
+
 	/**
 	 * @brief	This is a debug method that prints the content
 	 * 			(till messageSize) to the debug output.
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 197a26fd7..05330ce9e 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -71,6 +71,18 @@ public:
 	 * 			check the size of an incoming message.
 	 */
 	virtual size_t getMinimumMessageSize() const = 0;
+
+	/**
+	 * Get message size of current message implementation.
+	 * @return
+	 */
+	virtual size_t getMessageSize() const = 0;
+
+	/**
+	 * Get maximum allowed size of current message implementation.
+	 * @return
+	 */
+	virtual size_t getMaximumMessageSize() const = 0;
 };
 
 
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 3e30c8eda..7af5fbd90 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -18,20 +18,20 @@ MessageQueue::~MessageQueue() {
 }
 
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
+		MessageQueueMessageIF* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
 }
 
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 		MessageQueueId_t sentFrom, bool ignoreFault) {
 	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
 }
 
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
 	if (this->lastPartner != 0) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
@@ -40,13 +40,13 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 }
 
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
 			ignoreFault);
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
 	if(status == HasReturnvaluesIF::RETURN_OK) {
@@ -55,7 +55,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 	return status;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	if(messageQueue.empty()) {
 		return MessageQueueIF::EMPTY;
 	}
@@ -102,9 +102,9 @@ bool MessageQueue::isDefaultDestinationSet() const {
 
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessage *message, MessageQueueId_t sentFrom,
+        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
         bool ignoreFault) {
-	if(message->messageSize > MessageQueueMessage::MAX_DATA_SIZE) {
+	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.
@@ -127,7 +127,17 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
 		MutexHelper mutexLock(targetQueue->queueLock, 20);
-		targetQueue->messageQueue.push(*message);
+		// 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;
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
index 619b5e91f..7fc77f7aa 100644
--- a/osal/host/MessageQueue.h
+++ b/osal/host/MessageQueue.h
@@ -77,7 +77,7 @@ public:
 	 * is not incremented if queue is full.
 	 */
 	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false) override;
+			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
@@ -85,7 +85,7 @@ public:
 	 * queue id as "sentFrom" information.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	ReturnValue_t sendToDefault(MessageQueueMessage* message) override;
+	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
@@ -93,7 +93,7 @@ public:
 	 * 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(MessageQueueMessage* message) override;
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
 
 	/**
 	 * @brief	With the sendMessage call, a queue message is sent to a
@@ -113,7 +113,7 @@ public:
 	 * is not incremented if queue is full.
 	 */
 	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault = false) override;
 
 	/**
@@ -127,7 +127,7 @@ public:
 	 * sender's queue id into the message. This variable is set to zero by
 	 * default.
 	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
 			MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault = false) override;
 
@@ -140,7 +140,7 @@ public:
 	 * @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(MessageQueueMessage* message,
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom) override;
 
 	/**
@@ -153,7 +153,7 @@ public:
 	 * function returns immediately.
 	 * @param message	A pointer to a message in which the received data is stored.
 	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message) override;
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
@@ -205,7 +205,7 @@ protected:
 	 * @param context Specify whether call is made from task or from an ISR.
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault=false);
 
 	//static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
index 60274c842..225bb8c79 100644
--- a/osal/host/QueueFactory.cpp
+++ b/osal/host/QueueFactory.cpp
@@ -7,7 +7,7 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault) {
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
 			sentFrom,ignoreFault);
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index a0749ded3..605dea2af 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -118,15 +118,15 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 }
 
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
+		MessageQueueMessageIF* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), false);
 }
 
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
 	if (this->lastPartner != 0) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
@@ -134,21 +134,21 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	}
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
 	*receivedFrom = this->lastPartner;
 	return status;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	unsigned int messagePriority = 0;
 	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
-			message->MAX_MESSAGE_SIZE,&messagePriority);
+			message->getMaximumMessageSize(),&messagePriority);
 	if (status > 0) {
 		this->lastPartner = message->getSender();
 		//Check size of incoming message.
-		if (message->messageSize < message->getMinimumMessageSize()) {
+		if (message->getMessageSize() < message->getMinimumMessageSize()) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
@@ -158,7 +158,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 	} else {
 		//No message was received. Keep lastPartner anyway, I might send
 		//something later. But still, delete packet content.
-		memset(message->getData(), 0, message->MAX_DATA_SIZE);
+		memset(message->getData(), 0, message->getMaximumMessageSize());
 		switch(errno){
 		case EAGAIN:
 			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
@@ -259,13 +259,13 @@ void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
 }
 
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
 
 }
 
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 		MessageQueueId_t sentFrom, bool ignoreFault) {
 	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
 }
@@ -281,11 +281,12 @@ bool MessageQueue::isDefaultDestinationSet() const {
 uint16_t MessageQueue::queueCounter = 0;
 
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessage *message, MessageQueueId_t sentFrom,
+		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	message->setSender(sentFrom);
 	int result = mq_send(sendTo,
-			reinterpret_cast<const char*>(message->getBuffer()), message->messageSize,0);
+			reinterpret_cast<const char*>(message->getBuffer()),
+			message->getMessageSize(),0);
 
 	//TODO: Check if we're in ISR.
 	if (result != 0) {
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index 2808d36e1..91066bf76 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -56,14 +56,14 @@ public:
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false );
+			MessageQueueMessageIF* message, bool ignoreFault = false );
 	/**
 	 * @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.
 	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message );
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
 	/**
 	 * @brief	This operation sends a message to the last communication partner.
 	 * @details	This operation simplifies answering an incoming message by using the stored
@@ -71,7 +71,7 @@ public:
 	 * 			(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( MessageQueueMessage* message );
+	ReturnValue_t reply( MessageQueueMessageIF* message );
 
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
@@ -80,7 +80,7 @@ public:
 	 * @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(MessageQueueMessage* message,
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom);
 
 	/**
@@ -91,7 +91,7 @@ public:
 	 * 			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(MessageQueueMessage* message);
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
@@ -114,7 +114,9 @@ public:
 	 * 					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, MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false );
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false );
 	/**
 	 * \brief	The sendToDefault method sends a queue message to the default destination.
 	 * \details	In all other aspects, it works identical to the sendMessage method.
@@ -122,7 +124,8 @@ public:
 	 * \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( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 	/**
 	 * \brief	This method is a simple setter for the default destination.
 	 */
@@ -145,7 +148,9 @@ protected:
 	 * 					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.
 	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,bool ignoreFault=false);
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false);
 private:
 	/**
 	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index 268d0b995..8bd9d52c5 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -9,7 +9,7 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault) {
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
 			sentFrom,ignoreFault);

From 206235ed47e0b086acc06015aeb36484bfeeab76 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Jun 2020 16:03:09 +0200
Subject: [PATCH 0437/1774] dataset base bugfixes

---
 datapool/DataSetBase.cpp | 10 +++++++---
 health/HealthHelper.cpp  |  2 +-
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
index 9104c8e71..60b20f296 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -36,7 +36,7 @@ ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
 	if (state == States::DATA_SET_UNINITIALISED) {
 		lockDataPool(lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
-			ReturnValue_t result = readVariable(count);
+			result = readVariable(count);
 			if(result != RETURN_OK) {
 				break;
 			}
@@ -46,14 +46,15 @@ ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
 	}
 	else {
 		sif::error << "DataSet::read(): "
-				"Call made in wrong position." << std::endl;
+				"Call made in wrong position. Don't forget to commit"
+				" member datasets!" << std::endl;
 		result = SET_WAS_ALREADY_READ;
 	}
 	return result;
 }
 
 ReturnValue_t DataSetBase::readVariable(uint16_t count) {
-	ReturnValue_t result = DataSetIF::INVALID_PARAMETER_DEFINITION;
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	// These checks are often performed by the respective
 	// variable implementation too, but I guess a double check does not hurt.
 	if (registeredVariables[count]->getReadWriteMode() !=
@@ -62,6 +63,9 @@ ReturnValue_t DataSetBase::readVariable(uint16_t count) {
 				!= PoolVariableIF::NO_PARAMETER)
 	{
 		result = registeredVariables[count]->readWithoutLock();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			result = INVALID_PARAMETER_DEFINITION;
+		}
 	}
 	return result;
 }
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index b23a8bd28..df259b529 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -62,7 +62,7 @@ void HealthHelper::setHealth(HasHealthIF::HealthState health) {
 
 void HealthHelper::informParent(HasHealthIF::HealthState health,
 		HasHealthIF::HealthState oldHealth) {
-	if (parentQueue == 0) {
+	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
 		return;
 	}
 	MessageQueueMessage message;

From 6838a9e7687a7232f903b5b39c11fe026bf476ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Jun 2020 16:19:22 +0200
Subject: [PATCH 0438/1774] serial buffer adapter bugfix

---
 serialize/SerialBufferAdapter.cpp | 16 ++++++++--------
 serialize/SerialBufferAdapter.h   |  2 +-
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index e409686f4..d417ba456 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -21,29 +21,29 @@ SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
 template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size, bool bigEndian) const {
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer_,
+		size_t* size_, const size_t max_size, bool bigEndian) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
 				&bufferLength);
 	}
-	if (*size + serializedLength > max_size) {
+	if (*size_ + serializedLength > max_size) {
 		return BUFFER_TOO_SHORT;
 	} else {
 		if (serializeLength) {
-			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
+			AutoSerializeAdapter::serialize(&bufferLength, buffer_, size_,
 					max_size, bigEndian);
 		}
 		if (constBuffer != nullptr) {
-			memcpy(*buffer, constBuffer, bufferLength);
+			memcpy(*buffer_, this->constBuffer, bufferLength);
 		} else if (buffer != nullptr) {
-			memcpy(*buffer, buffer, bufferLength);
+			memcpy(*buffer_, this->buffer, bufferLength);
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
-		*size += bufferLength;
-		(*buffer) += bufferLength;
+		*size_ += bufferLength;
+		(*buffer_) += bufferLength;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 }
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index cb799be5e..026900210 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -45,7 +45,7 @@ public:
 
 	virtual ~SerialBufferAdapter();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer_, size_t* size,
 			const size_t max_size, bool bigEndian) const override;
 
 	virtual size_t getSerializedSize() const;

From f578c3ea29731f29153741b1ee99ae95c02782c6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Jun 2020 16:46:18 +0200
Subject: [PATCH 0439/1774] set buffer: const buffer is set too

---
 serialize/SerialBufferAdapter.cpp | 15 ++++++++++-----
 serialize/SerialBufferAdapter.h   |  2 +-
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index d417ba456..5e834fe26 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -37,9 +37,13 @@ ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer_,
 		}
 		if (constBuffer != nullptr) {
 			memcpy(*buffer_, this->constBuffer, bufferLength);
-		} else if (buffer != nullptr) {
+		}
+		else if (buffer != nullptr) {
+			// This will propably be never reached, constBuffer should always be
+			// set if non-const buffer is set.
 			memcpy(*buffer_, this->buffer, bufferLength);
-		} else {
+		}
+		else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 		*size_ += bufferLength;
@@ -93,7 +97,7 @@ 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;
+				 " Use getConstBuffer()." << std::endl;
 		return nullptr;
 	}
 	return buffer;
@@ -110,9 +114,10 @@ const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 
 template<typename count_t>
 void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
-		count_t buffer_length) {
+		count_t bufferLength) {
 	this->buffer = buffer;
-	bufferLength = buffer_length;
+	this->constBuffer = buffer;
+	this->bufferLength = bufferLength;
 }
 
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 026900210..a30451a1a 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -67,7 +67,7 @@ public:
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
-	void setBuffer(uint8_t* buffer_, count_t bufferLength_);
+	void setBuffer(uint8_t* buffer, count_t bufferLength);
 private:
 	bool serializeLength = false;
 	const uint8_t *constBuffer = nullptr;

From 7b538e9750001a7b91a89fbde5a47f9b619674eb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 12 Jun 2020 20:23:39 +0200
Subject: [PATCH 0440/1774] introduced command message base and

command message IF
---
 housekeeping/HousekeepingMessage.cpp |  17 +---
 housekeeping/HousekeepingMessage.h   |  13 ++-
 ipc/CommandMessage.cpp               | 128 +++++++++------------------
 ipc/CommandMessage.h                 |  79 +++++------------
 ipc/CommandMessageBase.cpp           |  55 ++++++++++++
 ipc/CommandMessageBase.h             |  73 +++++++++++++++
 ipc/CommandMessageIF.h               |  25 ++++++
 ipc/MessageQueueMessage.cpp          |   4 +
 ipc/MessageQueueMessage.h            |   3 +-
 ipc/MessageQueueMessageIF.h          |   4 +-
 10 files changed, 232 insertions(+), 169 deletions(-)
 create mode 100644 ipc/CommandMessageBase.cpp
 create mode 100644 ipc/CommandMessageBase.h
 create mode 100644 ipc/CommandMessageIF.h

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index c94a69d74..d9daf9745 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,18 +1,7 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 
-HousekeepingMessage::HousekeepingMessage() {
+HousekeepingMessage::HousekeepingMessage(MessageQueueMessage *message):
+		CommandMessageBase	(message) {}
 
-}
+HousekeepingMessage::~HousekeepingMessage() {}
 
-void HousekeepingMessage::setHkReportMessage() {
-}
-
-
-//void HousekeepingMessage::setAddHkReportStructMessage(CommandMessage *message,
-//		set_t setId, store_address_t packet) {
-//	message->setCommand(ADD_HK_REPORT_STRUCT);
-//	message->setParameter(setId);
-//	message->setParameter2(packet.raw);
-//}
-
-//void Housekeeping
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 3ba6f94d5..d0cbd0eb5 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,6 +1,8 @@
 #ifndef FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
 #define FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
-#include <framework/ipc/CommandMessage.h>
+#include <framework/ipc/CommandMessageBase.h>
+#include <framework/ipc/FwMessageTypes.h>
+#include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <limits>
 
@@ -23,15 +25,14 @@ union sid_t {
 };
 
 
-class HousekeepingMessage: public MessageQueueMessage {
+class HousekeepingMessage : public CommandMessageBase {
 public:
 	/**
 	 * No instances of a message shall be created, instead
 	 * a CommandMessage instance is manipulated.
 	 */
-	HousekeepingMessage();
-//	HousekeepingMessage(const HousekeepingMessage&) = delete;
-//	HousekeepingMessage operator=(const HousekeepingMessage &) = delete;
+	HousekeepingMessage(MessageQueueMessage* message);
+	virtual ~HousekeepingMessage();
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
 	static constexpr Command_t ADD_HK_REPORT_STRUCT =
@@ -78,8 +79,6 @@ public:
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
-//	static void setAddHkReportStructMessage(CommandMessage* message,
-//			DevisetId, store_address_t packet);
 	static void setHkReportMessage();
 };
 
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 7d2ecc9bd..8f53b77ca 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,6 +1,7 @@
+#include <framework/ipc/CommandMessage.h>
+
 #include <framework/devicehandlers/DeviceHandlerMessage.h>
 #include <framework/health/HealthMessage.h>
-#include <framework/ipc/CommandMessage.h>
 #include <framework/memory/MemoryMessage.h>
 #include <framework/modes/ModeMessage.h>
 #include <framework/monitoring/MonitoringMessage.h>
@@ -8,82 +9,86 @@
 #include <framework/tmstorage/TmStoreMessage.h>
 #include <framework/parameters/ParameterMessage.h>
 
-namespace messagetypes {
-// Implemented in config.
-void clearMissionMessage(CommandMessage* message);
-}
-
-
 CommandMessage::CommandMessage(MessageQueueMessage* receiverMessage):
-			internalMessage(receiverMessage) {
+			CommandMessageBase(receiverMessage) {
 	if(receiverMessage == nullptr) {
 		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
 				" as the message queue message, pass the address of an actual"
 				" message!" << std::endl;
 	}
-	internalMessage->messageSize = COMMAND_MESSAGE_SIZE;
+	internalMessage->setMessageSize(COMMAND_MESSAGE_SIZE);
 	setCommand(CMD_NONE);
 }
 
 CommandMessage::CommandMessage(MessageQueueMessage* messageToSet,
 		Command_t command, uint32_t parameter1, uint32_t parameter2):
-				internalMessage(messageToSet) {
+				CommandMessageBase(messageToSet) {
 	if(messageToSet == nullptr) {
 		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
 				" as the message queue message, pass the address of an actual"
 				" message!" << std::endl;
 	}
-	internalMessage->messageSize = COMMAND_MESSAGE_SIZE;
+	internalMessage->setMessageSize(COMMAND_MESSAGE_SIZE);
 	setCommand(command);
 	setParameter(parameter1);
 	setParameter2(parameter2);
 }
 
-Command_t CommandMessage::getCommand() const {
-	Command_t command;
-	memcpy(&command, internalMessage->getData(), sizeof(Command_t));
-	return command;
-}
-
-uint8_t CommandMessage::getMessageType() const {
-	return getCommand() >> 8 & 0xff;
-}
-
-void CommandMessage::setCommand(Command_t command) {
-	memcpy(internalMessage->getData(), &command, sizeof(command));
-}
-
 uint32_t CommandMessage::getParameter() const {
 	uint32_t parameter1;
-	memcpy(&parameter1, internalMessage->getData() + sizeof(Command_t),
-			sizeof(parameter1));
+	memcpy(&parameter1, CommandMessageBase::getData(), sizeof(parameter1));
 	return parameter1;
 }
 
 void CommandMessage::setParameter(uint32_t parameter1) {
-	memcpy(internalMessage->getData() + sizeof(Command_t),
-			&parameter1, sizeof(parameter1));
+	memcpy(CommandMessageBase::getData(), &parameter1, sizeof(parameter1));
 }
 
 uint32_t CommandMessage::getParameter2() const {
 	uint32_t parameter2;
-	memcpy(&parameter2, internalMessage->getData() + sizeof(Command_t)
-			+ sizeof(uint32_t), sizeof(parameter2));
+	memcpy(&parameter2, CommandMessageBase::getData() + sizeof(uint32_t),
+			sizeof(parameter2));
 	return parameter2;
 }
 
 void CommandMessage::setParameter2(uint32_t parameter2) {
-	memcpy(internalMessage-> getData() + sizeof(Command_t) + sizeof(uint32_t),
-			&parameter2, sizeof(parameter2));
+	memcpy(CommandMessageBase::getData()  + sizeof(uint32_t), &parameter2,
+			sizeof(parameter2));
 }
 
+size_t CommandMessage::getMinimumMessageSize() const {
+	return COMMAND_MESSAGE_SIZE;
+}
+
+size_t CommandMessage::getMaximumMessageSize() const {
+	return MessageQueueMessage::MAX_MESSAGE_SIZE;
+}
+
+bool CommandMessage::isClearedCommandMessage() {
+	return getCommand() == CMD_NONE;
+}
+
+void CommandMessage::setToUnknownCommand() {
+	Command_t initialCommand = getCommand();
+	clearCommandMessage();
+	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
+}
+
+void CommandMessage::setReplyRejected(ReturnValue_t reason,
+		Command_t initialCommand) {
+	setCommand(REPLY_REJECTED);
+	setParameter(reason);
+	setParameter2(initialCommand);
+}
+
+
 void CommandMessage::clear() {
 	clearCommandMessage();
 }
 
 void CommandMessage::clearCommandMessage() {
-	switch(getMessageType()){
-	case messagetypes::MODE_COMMAND:
+	switch(this->getMessageType()){
+	case  messagetypes::MODE_COMMAND:
 		ModeMessage::clear(this);
 		break;
 	case messagetypes::HEALTH_COMMAND:
@@ -115,56 +120,3 @@ void CommandMessage::clearCommandMessage() {
 		break;
 	}
 }
-
-bool CommandMessage::isClearedCommandMessage() {
-	return getCommand() == CMD_NONE;
-}
-
-size_t CommandMessage::getMinimumMessageSize() const {
-	return COMMAND_MESSAGE_SIZE;
-}
-
-void CommandMessage::setToUnknownCommand() {
-	Command_t initialCommand = getCommand();
-	clearCommandMessage();
-	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
-}
-
-void CommandMessage::setReplyRejected(ReturnValue_t reason,
-		Command_t initialCommand) {
-	setCommand(REPLY_REJECTED);
-	setParameter(reason);
-	setParameter2(initialCommand);
-}
-
-MessageQueueId_t CommandMessage::getSender() const {
-	return internalMessage->getSender();
-}
-
-uint8_t* CommandMessage::getBuffer() {
-	return internalMessage->getBuffer();
-}
-
-void CommandMessage::setSender(MessageQueueId_t setId) {
-	internalMessage->setSender(setId);
-}
-
-const uint8_t* CommandMessage::getBuffer() const {
-	return internalMessage->getBuffer();
-}
-
-uint8_t* CommandMessage::getData() {
-	return internalMessage->getData();
-}
-
-const uint8_t* CommandMessage::getData() const {
-	return internalMessage->getData();
-}
-
-size_t CommandMessage::getMessageSize() const {
-	return COMMAND_MESSAGE_SIZE;
-}
-
-size_t CommandMessage::getMaximumMessageSize() const {
-	return MessageQueueMessage::MAX_MESSAGE_SIZE;
-}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 25d608f04..434f8c8ce 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,33 +1,35 @@
 #ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
 #define FRAMEWORK_IPC_COMMANDMESSAGE_H_
 
+#include <framework/ipc/CommandMessageBase.h>
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/ipc/FwMessageTypes.h>
-#include <config/ipc/MissionMessageTypes.h>
 
-
-
-#define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
-typedef uint16_t Command_t;
+namespace messagetypes {
+// Implemented in config.
+void clearMissionMessage(CommandMessageIF* message);
+}
 
 /**
- * @brief 	Used to pass command messages between tasks. Primary message type
- * 			for IPC. Contains sender, 2-byte command field, and 2 4-byte
- * 			parameters.
+ * @brief 	Default command message used to pass command messages between tasks.
+ * 			Primary message type for IPC. Contains sender, 2-byte command ID
+ * 			field, and 2 4-byte parameters.
  * @details
  * It operates on an external memory which is contained inside a
- * MessageQueueMessage by taking its address.
+ * class implementing MessageQueueMessageIF by taking its address.
  * This allows for a more flexible designs of message implementations.
  * The pointer can be passed to different message implementations without
  * the need of unnecessary copying.
+ *
+ * The command message is based of the generic MessageQueueMessage which
+ * currently has an internal message size of 28 bytes.
  * @author	Bastian Baetz
  */
-class CommandMessage: public MessageQueueMessageIF {
+class CommandMessage: public CommandMessageBase {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
 	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
 
-
 	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
 	//! Used internally, will be ignored
 	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
@@ -66,39 +68,11 @@ public:
 	 */
 	virtual ~CommandMessage() {}
 
-	/**
-	 * Read the DeviceHandlerCommand_t that is stored in the message,
-	 * usually used after receiving.
-	 *
-	 * @return the Command stored in the Message
-	 */
-	Command_t getCommand() const;
-
-	/*
-	 * MessageQueueMessageIF functions, which generally just call the
-	 * respective functions of the internal message
-	 */
-	uint8_t * getBuffer() override;
-	const uint8_t * getBuffer() const override;
-	void setSender(MessageQueueId_t setId) override;
-	MessageQueueId_t getSender() const override;
-	uint8_t * getData() override;
-	const uint8_t* getData() const override;
+	/** MessageQueueMessageIF functions used for minimum size check. */
 	size_t getMinimumMessageSize() const override;
-	size_t getMessageSize() const override;
+	/** MessageQueueMessageIF functions used for maximum size check. */
 	size_t getMaximumMessageSize() const override;
 
-	/**
-	 * Extract message ID, which is the first byte of the command ID.
-	 * @return
-	 */
-	uint8_t getMessageType() const;
-	/**
-	 * Set the command type of the message
-	 * @param the Command to be sent
-	 */
-	void setCommand(Command_t command);
-
 	/**
 	 * Get the first parameter of the message
 	 * @return the first Parameter of the message
@@ -123,19 +97,17 @@ public:
 	 */
 	void setParameter2(uint32_t parameter2);
 
+	void clear() override;
 
 	/**
-	 * Set the command to CMD_NONE and try to find
-	 * the correct class to handle a more detailed
-	 * clear.
-	 * Also, calls a mission-specific clearMissionMessage
-	 * function to separate between framework and mission
-	 * messages. Not optimal, may be replaced by totally
-	 * different auto-delete solution (e.g. smart pointers).
+	 * Set the command to CMD_NONE and try to find the correct class to handle
+	 * a more detailed clear.
+	 * Also, calls a mission-specific clearMissionMessage function to separate
+	 * between framework and mission messages. Not optimal, may be replaced by
+	 * totally different auto-delete solution (e.g. smart pointers).
 	 *
 	 */
 	void clearCommandMessage();
-	void clear() override;
 
 	/**
 	 * check if a message was cleared
@@ -151,15 +123,6 @@ public:
 	void setToUnknownCommand();
 	void setReplyRejected(ReturnValue_t reason,
 			Command_t initialCommand = CMD_NONE);
-
-private:
-	/**
-	 * @brief 	Pointer to the message containing the data.
-	 * @details
-	 * The command message does not actually own the memory containing a
-	 * message, it just oprates on it via a pointer to a message queue message.
-	 */
-	MessageQueueMessage* internalMessage;
 };
 
 
diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
new file mode 100644
index 000000000..aa84bd1ef
--- /dev/null
+++ b/ipc/CommandMessageBase.cpp
@@ -0,0 +1,55 @@
+#include <framework/ipc/CommandMessageBase.h>
+#include <cstring>
+
+CommandMessageBase::CommandMessageBase(MessageQueueMessageIF *message):
+		internalMessage(message) {
+}
+
+Command_t CommandMessageBase::getCommand() const {
+	Command_t command;
+	std::memcpy(&command, internalMessage->getData(), sizeof(Command_t));
+	return command;
+}
+
+void CommandMessageBase::setCommand(Command_t command) {
+	std::memcpy(internalMessage->getData(), &command, sizeof(command));
+}
+
+uint8_t CommandMessageBase::getMessageType() const {
+	// first byte of command ID.
+	return getCommand() >> 8 & 0xff;
+}
+
+MessageQueueId_t CommandMessageBase::getSender() const {
+	return internalMessage->getSender();
+}
+
+uint8_t* CommandMessageBase::getBuffer() {
+	return internalMessage->getBuffer();
+}
+
+void CommandMessageBase::setSender(MessageQueueId_t setId) {
+	internalMessage->setSender(setId);
+}
+
+const uint8_t* CommandMessageBase::getBuffer() const {
+	return internalMessage->getBuffer();
+}
+
+// Header includes command ID.
+uint8_t* CommandMessageBase::getData() {
+	return internalMessage->getData() + sizeof(Command_t);
+}
+
+// Header includes command ID.
+const uint8_t* CommandMessageBase::getData() const {
+	return internalMessage->getData() + sizeof(Command_t);
+}
+
+void CommandMessageBase::setMessageSize(size_t messageSize) {
+	internalMessage->setMessageSize(messageSize);
+}
+
+size_t CommandMessageBase::getMessageSize() const {
+	return internalMessage->getMessageSize();
+}
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
new file mode 100644
index 000000000..fa3fd477a
--- /dev/null
+++ b/ipc/CommandMessageBase.h
@@ -0,0 +1,73 @@
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGEBASE_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGEBASE_H_
+#include <framework/ipc/CommandMessageIF.h>
+#include <framework/ipc/MessageQueueMessage.h>
+
+/**
+ * @brief	Base implementation of a generic command message, which has
+ * 			a Command_t ID and message type ID in the header in addition
+ * 			to the sender message queue ID.
+ * @details
+ * This is the base implementation serves as a base for other command messages
+ * and which implements most functions required for MessageQueueMessageIF.
+ * The only functions which have to be supplied by a specific command message
+ * impelementations are the size related functions which are used for
+ * size checks:
+ *
+ *  1. getMinimumMessageSize()
+ *  2. getMaximumMessageSize()
+ *
+ * Don't forget to set the message size of the passed message in the concrete
+ * commandmessage implementation!
+ */
+class CommandMessageBase: public CommandMessageIF {
+public:
+	CommandMessageBase(MessageQueueMessageIF* message);
+
+	/**
+	 * Read the DeviceHandlerCommand_t that is stored in the message,
+	 * usually used after receiving.
+	 *
+	 * @return the Command stored in the Message
+	 */
+	virtual Command_t getCommand() const override;
+	/**
+	 * Set the command type of the message. Default implementation also
+	 * sets the message type, which will be the first byte of the command ID.
+	 * @param the Command to be sent
+	 */
+	virtual void setCommand(Command_t command);
+
+	/**
+	 * Extract message ID, which is the first byte of the command ID for the
+	 * default implementation.
+	 * @return
+	 */
+	virtual uint8_t getMessageType() const override;
+
+	/*
+	 * MessageQueueMessageIF functions, which generally just call the
+	 * respective functions of the internal message queue message.
+	 */
+	virtual uint8_t * getBuffer() override;
+	virtual const uint8_t * getBuffer() const override;
+	virtual void setSender(MessageQueueId_t setId) override;
+	virtual MessageQueueId_t getSender() const override;
+	virtual uint8_t * getData() override;
+	virtual const uint8_t* getData() const override;
+	virtual void setMessageSize(size_t messageSize) override;
+	virtual size_t getMessageSize() const override;
+
+protected:
+	/**
+	 * @brief 	Pointer to the message containing the data.
+	 * @details
+	 * The command message does not actually own the memory containing a
+	 * message, it just oprates on it via a pointer to a message queue message.
+	 */
+	MessageQueueMessageIF* internalMessage;
+};
+
+
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGEBASE_H_ */
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
new file mode 100644
index 000000000..fbc40f88e
--- /dev/null
+++ b/ipc/CommandMessageIF.h
@@ -0,0 +1,25 @@
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
+
+#include <framework/ipc/MessageQueueMessageIF.h>
+
+#define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
+typedef uint16_t Command_t;
+
+class CommandMessageIF: public MessageQueueMessageIF {
+public:
+	virtual ~CommandMessageIF() {};
+
+	/**
+	 * A command message shall have a uint16_t command ID field.
+	 * @return
+	 */
+	virtual Command_t getCommand() const = 0;
+	/**
+	 * A command message shall have a uint8_t message type ID field.
+	 * @return
+	 */
+	virtual uint8_t getMessageType() const = 0;
+};
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index 8430a8ea3..b173f2c41 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -75,3 +75,7 @@ size_t MessageQueueMessage::getMessageSize() const {
 size_t MessageQueueMessage::getMaximumMessageSize() const {
 	return this->MAX_MESSAGE_SIZE;
 }
+
+void MessageQueueMessage::setMessageSize(size_t messageSize) {
+	this->messageSize = messageSize;
+}
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 31a43f663..2eb1f4f56 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -3,7 +3,7 @@
 
 #include <framework/ipc/MessageQueueMessageIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
-#include <stddef.h>
+#include <cstddef>
 
 /**
  *	@brief		This class is the representation and data organizer
@@ -150,6 +150,7 @@ public:
 	virtual size_t getMinimumMessageSize() const override;
 
 	virtual size_t getMessageSize() const override;
+	virtual void setMessageSize(size_t messageSize) override;
 
 	virtual size_t getMaximumMessageSize() const override;
 
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 05330ce9e..f34cab98a 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -24,7 +24,8 @@ public:
 
 	/**
 	 * @brief	With this method, the whole content and the message
-	 * 			size is set to zero.
+	 * 			size is set to zero. Implementations should also take care
+	 * 			to clear data which is stored indirectly (e.g. storage data).
 	 */
 	virtual void clear() = 0;
 
@@ -77,6 +78,7 @@ public:
 	 * @return
 	 */
 	virtual size_t getMessageSize() const = 0;
+	virtual void setMessageSize(size_t messageSize) = 0;
 
 	/**
 	 * Get maximum allowed size of current message implementation.

From 6b67f46c802aa1b421689097d3faf96668073c71 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 13 Jun 2020 17:37:48 +0200
Subject: [PATCH 0441/1774] evil hidden bug found.

CSB uses CommandMessageIF now
---
 datapoollocal/LocalDataPoolManager.cpp |  4 +-
 datapoollocal/LocalDataPoolManager.h   |  2 +-
 devicehandlers/DeviceHandlerBase.cpp   | 28 ++++--------
 devicehandlers/HealthDevice.cpp        |  2 +-
 housekeeping/HousekeepingMessage.cpp   | 45 +++++++++++++++++--
 housekeeping/HousekeepingMessage.h     | 29 +++++++++---
 ipc/CommandMessage.cpp                 | 33 +++++++++++---
 ipc/CommandMessage.h                   | 12 +++--
 ipc/CommandMessageBase.cpp             |  6 ++-
 ipc/CommandMessageBase.h               |  6 ++-
 ipc/CommandMessageIF.h                 | 16 +++++++
 ipc/MessageQueueMessage.h              |  4 +-
 osal/FreeRTOS/MessageQueue.cpp         |  2 +-
 osal/FreeRTOS/MessageQueue.h           | 22 ++++-----
 tmtcservices/CommandingServiceBase.cpp | 62 +++++++++++++++++---------
 tmtcservices/CommandingServiceBase.h   | 23 +++++++---
 tmtcservices/VerificationReporter.cpp  | 10 ++---
 17 files changed, 214 insertions(+), 92 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 37dbed368..58694508f 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -41,8 +41,8 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-		MessageQueueMessage *message) {
-	return HasReturnvaluesIF::RETURN_OK;
+		HousekeepingMessage& message) {
+	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 1d25fa48c..d1a2d410c 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -46,7 +46,7 @@ public:
 	LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 
 	ReturnValue_t generateHousekeepingPacket(sid_t sid);
-	ReturnValue_t handleHousekeepingMessage(MessageQueueMessage* message);
+	ReturnValue_t handleHousekeepingMessage(HousekeepingMessage& message);
 
 	/**
 	 * This function is used to fill the local data pool map with pool
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 11cffc74c..bf6998485 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -225,15 +225,6 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	// This is really annoying. I can't cast a parent object to a child.
-	// But I want to use another message format..
-//	CommandMessage* cmdMessage = dynamic_cast<CommandMessage*>(msgPtr);
-//	if(cmdMessage == nullptr) {
-//		sif::error << "DeviceHandlerBase::readCommandQueue: Could not cast"
-//				" message to CommandMessage!" << std::endl;
-//		return;
-//	}
-
 	if(healthHelperActive) {
 		result = healthHelper.handleHealthCommand(&command);
 		if (result == RETURN_OK) {
@@ -256,11 +247,11 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-//	HousekeepingMessage* hkMessage = dynamic_cast<HousekeepingMessage*>(msgPtr);
-//	result = hkManager.handleHousekeepingMessage(hkMessage);
-//	if (result == RETURN_OK) {
-//		return;
-//	}
+	HousekeepingMessage hkMessage(&message);
+	result = hkManager.handleHousekeepingMessage(hkMessage);
+	if (result == RETURN_OK) {
+		return;
+	}
 
 	result = handleDeviceHandlerMessage(&command);
 	if (result == RETURN_OK) {
@@ -758,7 +749,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 || sendTo == MessageQueueIF::NO_QUEUE) {
+	if (IPCStore == nullptr or len == 0 or sendTo == MessageQueueIF::NO_QUEUE) {
 		return;
 	}
 	store_address_t address;
@@ -775,13 +766,12 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 	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.
 	}
 }
 
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 1c9d18f64..7e3a59bd0 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -5,7 +5,7 @@ HealthDevice::HealthDevice(object_id_t setObjectId,
 		MessageQueueId_t parentQueue) :
 		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
 				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::COMMAND_MESSAGE_SIZE);
+	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
 }
 
 HealthDevice::~HealthDevice() {
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index d9daf9745..6dd1a7116 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,7 +1,46 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
+#include <cstring>
 
-HousekeepingMessage::HousekeepingMessage(MessageQueueMessage *message):
-		CommandMessageBase	(message) {}
+HousekeepingMessage::HousekeepingMessage(MessageQueueMessageIF* message):
+		CommandMessageBase(message) {
+}
 
-HousekeepingMessage::~HousekeepingMessage() {}
+HousekeepingMessage::~HousekeepingMessage() {
+}
 
+void HousekeepingMessage::setHkReportMessage(sid_t sid,
+		store_address_t storeId) {
+	CommandMessageBase::setCommand(HK_REPORT);
+	setSid(sid);
+	setParameter(storeId.raw);
+}
+
+size_t HousekeepingMessage::getMinimumMessageSize() const {
+	return HK_MESSAGE_SIZE;
+}
+
+size_t HousekeepingMessage::getMaximumMessageSize() const {
+	return MessageQueueMessage::MAX_MESSAGE_SIZE;
+}
+
+void HousekeepingMessage::clear() {
+	// clear IPC store where it is needed.
+}
+
+sid_t HousekeepingMessage::getSid() const {
+	sid_t sid;
+	std::memcpy(&sid.raw, CommandMessageBase::getData(), sizeof(sid.raw));
+	return sid;
+}
+
+uint8_t* HousekeepingMessage::getData() {
+	return internalMessage->getBuffer() + sizeof(sid_t);
+}
+
+void HousekeepingMessage::setParameter(uint32_t parameter) {
+	memcpy(getData(), &parameter, sizeof(parameter));
+}
+
+void HousekeepingMessage::setSid(sid_t sid) {
+	std::memcpy(CommandMessageBase::getData(), &sid.raw, sizeof(sid.raw));
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index d0cbd0eb5..4e9d45531 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -13,13 +13,15 @@ union sid_t {
 
 	struct {
 		object_id_t objectId ;
-		// A generic 32 bit ID to identify unique HK packets for a single
-		// object.
-		// For example, the DeviceCommandId_t is used for DeviceHandlers
+		/**
+		 * A generic 32 bit ID to identify unique HK packets for a single
+		 * object. For example, the DeviceCommandId_t is used for
+		 * DeviceHandlers
+		 */
 		uint32_t ownerSetId;
 	};
 	/**
-	 * Alternative access to the raw value.
+	 * Alternative access to the raw value. This is also the size of the type.
 	 */
 	uint64_t raw;
 };
@@ -27,14 +29,18 @@ union sid_t {
 
 class HousekeepingMessage : public CommandMessageBase {
 public:
+
+	static constexpr size_t HK_MESSAGE_SIZE = sizeof(MessageQueueId_t)
+			+ sizeof(Command_t) + sizeof(sid_t) * sizeof(uint32_t);
 	/**
 	 * No instances of a message shall be created, instead
 	 * a CommandMessage instance is manipulated.
 	 */
-	HousekeepingMessage(MessageQueueMessage* message);
+	HousekeepingMessage(MessageQueueMessageIF* message);
 	virtual ~HousekeepingMessage();
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
+
 	static constexpr Command_t ADD_HK_REPORT_STRUCT =
 			MAKE_COMMAND_ID(1);
 	static constexpr Command_t ADD_DIAGNOSTICS_REPORT_STRUCT =
@@ -79,7 +85,18 @@ public:
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
-	static void setHkReportMessage();
+	void setHkReportMessage(sid_t sid, store_address_t storeId);
+
+	void setParameter(uint32_t parameter);
+
+	virtual void clear() override;
+	virtual size_t getMinimumMessageSize() const override;
+	virtual size_t getMaximumMessageSize() const override;
+
+	virtual uint8_t* getData() override;
+private:
+	sid_t getSid() const;
+	void setSid(sid_t sid);
 };
 
 
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 8f53b77ca..9d448aed6 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -9,18 +9,25 @@
 #include <framework/tmstorage/TmStoreMessage.h>
 #include <framework/parameters/ParameterMessage.h>
 
-CommandMessage::CommandMessage(MessageQueueMessage* receiverMessage):
+CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
 			CommandMessageBase(receiverMessage) {
 	if(receiverMessage == nullptr) {
 		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
 				" as the message queue message, pass the address of an actual"
 				" message!" << std::endl;
+		return;
 	}
-	internalMessage->setMessageSize(COMMAND_MESSAGE_SIZE);
-	setCommand(CMD_NONE);
+	if(receiverMessage->getMaximumMessageSize() <
+			MINIMUM_COMMAND_MESSAGE_SIZE) {
+		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
+				" can not hold minimum "<< MINIMUM_COMMAND_MESSAGE_SIZE
+				<< " bytes!" << std::endl;
+		return;
+	}
+	internalMessage->setMessageSize(MINIMUM_COMMAND_MESSAGE_SIZE);
 }
 
-CommandMessage::CommandMessage(MessageQueueMessage* messageToSet,
+CommandMessage::CommandMessage(MessageQueueMessageIF* messageToSet,
 		Command_t command, uint32_t parameter1, uint32_t parameter2):
 				CommandMessageBase(messageToSet) {
 	if(messageToSet == nullptr) {
@@ -28,7 +35,14 @@ CommandMessage::CommandMessage(MessageQueueMessage* messageToSet,
 				" as the message queue message, pass the address of an actual"
 				" message!" << std::endl;
 	}
-	internalMessage->setMessageSize(COMMAND_MESSAGE_SIZE);
+	if(messageToSet->getMaximumMessageSize() <
+			MINIMUM_COMMAND_MESSAGE_SIZE) {
+		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
+				" can not hold minimum "<< MINIMUM_COMMAND_MESSAGE_SIZE
+				<< " bytes!" << std::endl;
+		return;
+	}
+	internalMessage->setMessageSize(MINIMUM_COMMAND_MESSAGE_SIZE);
 	setCommand(command);
 	setParameter(parameter1);
 	setParameter2(parameter2);
@@ -57,7 +71,7 @@ void CommandMessage::setParameter2(uint32_t parameter2) {
 }
 
 size_t CommandMessage::getMinimumMessageSize() const {
-	return COMMAND_MESSAGE_SIZE;
+	return MINIMUM_COMMAND_MESSAGE_SIZE;
 }
 
 size_t CommandMessage::getMaximumMessageSize() const {
@@ -81,6 +95,13 @@ void CommandMessage::setReplyRejected(ReturnValue_t reason,
 	setParameter2(initialCommand);
 }
 
+ReturnValue_t CommandMessage::getRejectedReplyReason(
+		Command_t* initialCommand) const {
+	if(initialCommand != nullptr) {
+		*initialCommand  = getParameter2();
+	}
+	return getParameter();
+}
 
 void CommandMessage::clear() {
 	clearCommandMessage();
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 434f8c8ce..8e1e9c8cd 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -42,8 +42,9 @@ public:
 	 * This is the size of a message as it is seen by the MessageQueue.
 	 * 14 of the 24 available MessageQueueMessage bytes are used.
 	 */
-	static const size_t COMMAND_MESSAGE_SIZE = MessageQueueMessage::HEADER_SIZE
-			+ sizeof(Command_t) + 2 * sizeof(uint32_t);
+	static const size_t MINIMUM_COMMAND_MESSAGE_SIZE =
+			MessageQueueMessage::HEADER_SIZE + sizeof(Command_t) +
+			2 * sizeof(uint32_t);
 
 	/**
 	 * Default Constructor, does not initialize anything.
@@ -51,7 +52,7 @@ public:
 	 * This constructor should be used when receiving a Message, as the
 	 * content is filled by the MessageQueue.
 	 */
-	CommandMessage(MessageQueueMessage* receiverMessage);
+	CommandMessage(MessageQueueMessageIF* receiverMessage);
 	/**
 	 * This constructor creates a new message with all message content
 	 * initialized
@@ -60,7 +61,7 @@ public:
 	 * @param parameter1	The first parameter
 	 * @param parameter2	The second parameter
 	 */
-	CommandMessage(MessageQueueMessage* messageToSet, Command_t command,
+	CommandMessage(MessageQueueMessageIF* messageToSet, Command_t command,
 			uint32_t parameter1, uint32_t parameter2);
 
 	/**
@@ -121,8 +122,11 @@ public:
 	 * Is needed quite often, so we better code it once only.
 	 */
 	void setToUnknownCommand();
+
 	void setReplyRejected(ReturnValue_t reason,
 			Command_t initialCommand = CMD_NONE);
+	ReturnValue_t getRejectedReplyReason(
+			Command_t* initialCommand = nullptr) const;
 };
 
 
diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
index aa84bd1ef..3ffe4daa2 100644
--- a/ipc/CommandMessageBase.cpp
+++ b/ipc/CommandMessageBase.cpp
@@ -12,7 +12,7 @@ Command_t CommandMessageBase::getCommand() const {
 }
 
 void CommandMessageBase::setCommand(Command_t command) {
-	std::memcpy(internalMessage->getData(), &command, sizeof(command));
+	std::memcpy(internalMessage->getData(), &command, sizeof(Command_t));
 }
 
 uint8_t CommandMessageBase::getMessageType() const {
@@ -53,3 +53,7 @@ void CommandMessageBase::setMessageSize(size_t messageSize) {
 size_t CommandMessageBase::getMessageSize() const {
 	return internalMessage->getMessageSize();
 }
+
+MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
+	return internalMessage;
+}
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
index fa3fd477a..b2b7d5f28 100644
--- a/ipc/CommandMessageBase.h
+++ b/ipc/CommandMessageBase.h
@@ -22,6 +22,9 @@
  */
 class CommandMessageBase: public CommandMessageIF {
 public:
+	static constexpr size_t HEADER_SIZE = sizeof(MessageQueueId_t) +
+			sizeof(Command_t);
+
 	CommandMessageBase(MessageQueueMessageIF* message);
 
 	/**
@@ -58,6 +61,7 @@ public:
 	virtual void setMessageSize(size_t messageSize) override;
 	virtual size_t getMessageSize() const override;
 
+	virtual MessageQueueMessageIF* getInternalMessage() const override;
 protected:
 	/**
 	 * @brief 	Pointer to the message containing the data.
@@ -65,7 +69,7 @@ protected:
 	 * The command message does not actually own the memory containing a
 	 * message, it just oprates on it via a pointer to a message queue message.
 	 */
-	MessageQueueMessageIF* internalMessage;
+	MessageQueueMessageIF* internalMessage = nullptr;
 };
 
 
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index fbc40f88e..44853c38b 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -6,6 +6,12 @@
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef uint16_t Command_t;
 
+// TODO: actually, this interface propably does not have to implement
+// MQM IF, because there is a getter function for the internal message..
+// But it is also convenient to have the full access to all MQM IF functions.
+// That way, I can just pass CommandMessages to functions expecting a MQM IF.
+// The command message implementations just forwards the calls. Maybe
+// we should just leave it like that.
 class CommandMessageIF: public MessageQueueMessageIF {
 public:
 	virtual ~CommandMessageIF() {};
@@ -20,6 +26,16 @@ public:
 	 * @return
 	 */
 	virtual uint8_t getMessageType() const = 0;
+
+	/**
+	 * This function is used to get a pointer to the internal message, as
+	 * the command message implementations always operate on the memory
+	 * contained in the message queue message implementation.
+	 * This pointer can be used to set the internal message of different
+	 * command message implementations.
+	 * @return
+	 */
+	virtual MessageQueueMessageIF* getInternalMessage() const = 0;
 };
 
 #endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 2eb1f4f56..8716df54d 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -88,12 +88,12 @@ public:
 	 * queue in the system. So, a change here may have significant impact on
 	 * the required resources.
 	 */
-	static const size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
+	static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
 	/**
 	 * @brief Defines the minimum size of a message where only the
 	 * 		  header is included
 	 */
-	static const size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
+	static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
 private:
 	/**
 	 * @brief	This is the internal buffer that contains the
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 8c6ec80b0..d44b0bc0f 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -101,7 +101,7 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 }
 
 MessageQueueId_t MessageQueue::getId() const {
-	return (MessageQueueId_t) handle;
+	return reinterpret_cast<MessageQueueId_t>(handle);
 }
 
 void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 6165c1cf5..c13a8a200 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -3,7 +3,7 @@
 
 #include <framework/internalError/InternalErrorReporterIF.h>
 #include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
+#include <framework/ipc/MessageQueueMessageIF.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
 #include <freertos/FreeRTOS.h>
@@ -85,14 +85,14 @@ public:
 	 * @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 );
+			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 );
+	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
@@ -100,7 +100,7 @@ public:
 	 * 			(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 );
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
 
 	/**
 	 * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
@@ -113,9 +113,10 @@ public:
 	 * 					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 );
+	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.
@@ -125,7 +126,8 @@ public:
 	 * 					This variable is set to zero by default.
 	 */
 	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
 
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
@@ -135,7 +137,7 @@ public:
 	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
 	 */
 	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom);
+			MessageQueueId_t *receivedFrom) override;
 
 	/**
 	 * @brief	This function reads available messages from the message queue.
@@ -145,7 +147,7 @@ public:
 	 * 			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);
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 72351995d..65053cc88 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -81,40 +81,58 @@ void CommandingServiceBase::handleCommandQueue() {
 	ReturnValue_t result = RETURN_FAILED;
 	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
 			result = commandQueue->receiveMessage(&reply)) {
-		handleCommandMessage(reply);
+		if(reply.getInternalMessage() == nullptr) {
+			// This should never happen unless the passed message maximum size
+			// is too small!
+			sif::error << "CommandingServiceBase::handleCommandMessage: Reply"
+					"does not satisfy minimum requirements for a command "
+					"message!" << std::endl;
+			continue;
+		}
+		handleCommandMessage(&reply);
 	}
 }
 
 
-void CommandingServiceBase::handleCommandMessage(CommandMessage& reply) {
+void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	bool isStep = false;
 	MessageQueueMessage message;
 	CommandMessage nextCommand(&message);
-	CommandMapIter iter;
-	if (reply.getSender() == MessageQueueIF::NO_QUEUE) {
-		handleUnrequestedReply(&reply);
-		return;
-	}
-	if ((iter = commandMap.find(reply.getSender())) == commandMap.end()) {
-		handleUnrequestedReply(&reply);
+	CommandMapIter iter = commandMap.find(reply->getSender());
+
+	// handle unrequested reply first
+	if (reply->getSender() == MessageQueueIF::NO_QUEUE or
+			iter == commandMap.end()) {
+		handleUnrequestedReply(reply);
 		return;
 	}
 	nextCommand.setCommand(CommandMessage::CMD_NONE);
 
+
 	// Implemented by child class, specifies what to do with reply.
-	ReturnValue_t result = handleReply(&reply, iter->command, &iter->state,
+	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
 			&nextCommand, iter->objectId, &isStep);
 
+	/* If the child implementation does not implement special handling for
+	 * rejected replies (RETURN_FAILED is returned), a failure verification
+	 * will be generated with the reason as the return code and the initial
+	 * command as failure parameter 1 */
+	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
+			result == RETURN_FAILED) {
+		result = reply->getRejectedReplyReason(
+				reinterpret_cast<Command_t*>(&failureParameter1));
+	}
+
 	switch (result) {
 	case EXECUTION_COMPLETE:
 	case RETURN_OK:
 	case NO_STEP_MESSAGE:
 		// handle result of reply handler implemented by developer.
-		handleReplyHandlerResult(result, iter, nextCommand, reply, isStep);
+		handleReplyHandlerResult(result, iter, &nextCommand, reply, isStep);
 		break;
 	case INVALID_REPLY:
 		//might be just an unrequested reply at a bad moment
-		handleUnrequestedReply(&reply);
+		handleUnrequestedReply(reply);
 		break;
 	default:
 		if (isStep) {
@@ -138,17 +156,17 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage& reply) {
 }
 
 void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
-		CommandMapIter iter, CommandMessage& nextCommand, CommandMessage& reply,
+		CommandMapIter iter, CommandMessage* nextCommand, CommandMessage* reply,
 		bool& isStep) {
-	iter->command = nextCommand.getCommand();
+	iter->command = nextCommand->getCommand();
 
 	// In case a new command is to be sent immediately, this is performed here.
 	// If no new command is sent, only analyse reply result by initializing
 	// sendResult as RETURN_OK
 	ReturnValue_t sendResult = RETURN_OK;
-	if (nextCommand.getCommand() != CommandMessage::CMD_NONE) {
-		sendResult = commandQueue->sendMessage(reply.getSender(),
-				&nextCommand);
+	if (nextCommand->getCommand() != CommandMessage::CMD_NONE) {
+		sendResult = commandQueue->sendMessage(reply->getSender(),
+				nextCommand);
 	}
 
 	if (sendResult == RETURN_OK) {
@@ -168,14 +186,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 	}
 	else {
 		if (isStep) {
-			nextCommand.clearCommandMessage();
+			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
 					iter->tcInfo.tcPacketId,
 					iter->tcInfo.tcSequenceControl, sendResult,
 					++iter->step, failureParameter1, failureParameter2);
 		} else {
-			nextCommand.clearCommandMessage();
+			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE,
 					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
@@ -366,9 +384,9 @@ void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
 }
 
 
-void CommandingServiceBase::handleUnrequestedReply(
-		CommandMessage* reply) {
-	reply->clearCommandMessage();
+void CommandingServiceBase::handleUnrequestedReply(CommandMessageIF* reply) {
+	CommandMessage commandReply(reply->getInternalMessage());
+	commandReply.clear();
 }
 
 
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 1dcafff82..5adfe4a69 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -147,9 +147,11 @@ protected:
 
 	/**
 	 * This function is implemented by child services to specify how replies
-	 * to a command from another software component are handled
+	 * to a command from another software component are handled.
 	 * @param reply
-	 * This is the reply in form of a command message.
+	 * This is the reply which can be accessed via the command message
+	 * interface. The internal message pointer can be passed to different
+	 * command message implementations (see CommandMessageIF)
 	 * @param previousCommand
 	 * Command_t of related command
 	 * @param state [out/in]
@@ -163,9 +165,12 @@ protected:
 	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
 	 *   generate TC verification success
 	 * - @c INVALID_REPLY calls handleUnrequestedReply
-	 * - Anything else triggers a TC verification failure
+	 * - Anything else triggers a TC verification failure. If RETURN_FAILED
+	 *   is returned and the command ID is CommandMessage::REPLY_REJECTED,
+	 *   a failure verification message with the reason as the error parameter
+	 *   and the initial command as failure parameter 1.
 	 */
-	virtual ReturnValue_t handleReply(const CommandMessage *reply,
+	virtual ReturnValue_t handleReply(const CommandMessageIF *reply,
 			Command_t previousCommand, uint32_t *state,
 			CommandMessage *optionalNextCommand, object_id_t objectId,
 			bool *isStep) = 0;
@@ -173,9 +178,13 @@ protected:
 	/**
 	 * This function can be overidden to handle unrequested reply,
 	 * when the reply sender ID is unknown or is not found is the command map.
+	 * The default implementation will clear the command message and all
+	 * its contents.
 	 * @param reply
+	 * Reply which is non-const so the default implementation can clear the
+	 * message.
 	 */
-	virtual void handleUnrequestedReply(CommandMessage *reply);
+	virtual void handleUnrequestedReply(CommandMessageIF *reply);
 
 	virtual void doPeriodicOperation();
 
@@ -303,9 +312,9 @@ private:
 
 	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
 
-	void handleCommandMessage(CommandMessage& reply);
+	void handleCommandMessage(CommandMessage* reply);
 	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
-			CommandMessage& nextCommand,CommandMessage& reply, bool& isStep);
+			CommandMessage* nextCommand,CommandMessage* reply, bool& isStep);
 
 	void checkTimeout();
 };
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 4484fb9b2..b02479449 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -24,9 +24,8 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 			current_packet->getPacketSequenceControl(), 0, set_step);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue, &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error
-				<< "VerificationReporter::sendSuccessReport: Error writing to queue. Code: "
-				<< (uint16_t) status << std::endl;
+		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
+				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
 	}
 }
 
@@ -40,9 +39,8 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 			tcSequenceControl, 0, set_step);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue, &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error
-				<< "VerificationReporter::sendSuccessReport: Error writing to queue. Code: "
-				<< (uint16_t) status << std::endl;
+		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
+				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
 	}
 }
 

From 8c03f6a823afca715f51d01cbecdbaa5e6ca185e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 13 Jun 2020 21:01:01 +0200
Subject: [PATCH 0442/1774] command message only passed IF now

---
 ipc/CommandMessage.cpp                 | 74 +++-----------------------
 ipc/CommandMessage.h                   | 33 ------------
 ipc/CommandMessageBase.cpp             | 23 ++++++++
 ipc/CommandMessageBase.h               | 21 ++++++--
 ipc/CommandMessageCleaner.cpp          | 45 ++++++++++++++++
 ipc/CommandMessageCleaner.h            | 16 ++++++
 ipc/CommandMessageIF.h                 | 34 ++++++++++++
 memory/MemoryHelper.cpp                |  2 +-
 tmtcservices/CommandingServiceBase.cpp | 16 +++---
 tmtcservices/CommandingServiceBase.h   |  8 +--
 10 files changed, 155 insertions(+), 117 deletions(-)
 create mode 100644 ipc/CommandMessageCleaner.cpp
 create mode 100644 ipc/CommandMessageCleaner.h

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 9d448aed6..392906880 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,13 +1,5 @@
 #include <framework/ipc/CommandMessage.h>
-
-#include <framework/devicehandlers/DeviceHandlerMessage.h>
-#include <framework/health/HealthMessage.h>
-#include <framework/memory/MemoryMessage.h>
-#include <framework/modes/ModeMessage.h>
-#include <framework/monitoring/MonitoringMessage.h>
-#include <framework/subsystem/modes/ModeSequenceMessage.h>
-#include <framework/tmstorage/TmStoreMessage.h>
-#include <framework/parameters/ParameterMessage.h>
+#include <cstring>
 
 CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
 			CommandMessageBase(receiverMessage) {
@@ -50,23 +42,23 @@ CommandMessage::CommandMessage(MessageQueueMessageIF* messageToSet,
 
 uint32_t CommandMessage::getParameter() const {
 	uint32_t parameter1;
-	memcpy(&parameter1, CommandMessageBase::getData(), sizeof(parameter1));
+	std::memcpy(&parameter1, CommandMessageBase::getData(), sizeof(parameter1));
 	return parameter1;
 }
 
 void CommandMessage::setParameter(uint32_t parameter1) {
-	memcpy(CommandMessageBase::getData(), &parameter1, sizeof(parameter1));
+	std::memcpy(CommandMessageBase::getData(), &parameter1, sizeof(parameter1));
 }
 
 uint32_t CommandMessage::getParameter2() const {
 	uint32_t parameter2;
-	memcpy(&parameter2, CommandMessageBase::getData() + sizeof(uint32_t),
+	std::memcpy(&parameter2, CommandMessageBase::getData() + sizeof(uint32_t),
 			sizeof(parameter2));
 	return parameter2;
 }
 
 void CommandMessage::setParameter2(uint32_t parameter2) {
-	memcpy(CommandMessageBase::getData()  + sizeof(uint32_t), &parameter2,
+	std::memcpy(CommandMessageBase::getData()  + sizeof(uint32_t), &parameter2,
 			sizeof(parameter2));
 }
 
@@ -84,60 +76,6 @@ bool CommandMessage::isClearedCommandMessage() {
 
 void CommandMessage::setToUnknownCommand() {
 	Command_t initialCommand = getCommand();
-	clearCommandMessage();
+	this->clear();
 	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
 }
-
-void CommandMessage::setReplyRejected(ReturnValue_t reason,
-		Command_t initialCommand) {
-	setCommand(REPLY_REJECTED);
-	setParameter(reason);
-	setParameter2(initialCommand);
-}
-
-ReturnValue_t CommandMessage::getRejectedReplyReason(
-		Command_t* initialCommand) const {
-	if(initialCommand != nullptr) {
-		*initialCommand  = getParameter2();
-	}
-	return getParameter();
-}
-
-void CommandMessage::clear() {
-	clearCommandMessage();
-}
-
-void CommandMessage::clearCommandMessage() {
-	switch(this->getMessageType()){
-	case  messagetypes::MODE_COMMAND:
-		ModeMessage::clear(this);
-		break;
-	case messagetypes::HEALTH_COMMAND:
-		HealthMessage::clear(this);
-		break;
-	case messagetypes::MODE_SEQUENCE:
-		ModeSequenceMessage::clear(this);
-		break;
-	case messagetypes::ACTION:
-		ActionMessage::clear(this);
-		break;
-	case messagetypes::DEVICE_HANDLER_COMMAND:
-		DeviceHandlerMessage::clear(this);
-		break;
-	case messagetypes::MEMORY:
-		MemoryMessage::clear(this);
-		break;
-	case messagetypes::MONITORING:
-		MonitoringMessage::clear(this);
-		break;
-	case messagetypes::TM_STORE:
-		TmStoreMessage::clear(this);
-		break;
-	case messagetypes::PARAMETER:
-		ParameterMessage::clear(this);
-		break;
-	default:
-		messagetypes::clearMissionMessage(this);
-		break;
-	}
-}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 8e1e9c8cd..72f393573 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -5,11 +5,6 @@
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/ipc/FwMessageTypes.h>
 
-namespace messagetypes {
-// Implemented in config.
-void clearMissionMessage(CommandMessageIF* message);
-}
-
 /**
  * @brief 	Default command message used to pass command messages between tasks.
  * 			Primary message type for IPC. Contains sender, 2-byte command ID
@@ -27,17 +22,6 @@ void clearMissionMessage(CommandMessageIF* message);
  */
 class CommandMessage: public CommandMessageBase {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
-	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
-
-	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
-	//! Used internally, will be ignored
-	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
-	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 3 );
-	//! Reply indicating that the current command was rejected,
-	//! par1 should contain the error code
-	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 0xD1 );
-
 	/**
 	 * This is the size of a message as it is seen by the MessageQueue.
 	 * 14 of the 24 available MessageQueueMessage bytes are used.
@@ -98,18 +82,6 @@ public:
 	 */
 	void setParameter2(uint32_t parameter2);
 
-	void clear() override;
-
-	/**
-	 * Set the command to CMD_NONE and try to find the correct class to handle
-	 * a more detailed clear.
-	 * Also, calls a mission-specific clearMissionMessage function to separate
-	 * between framework and mission messages. Not optimal, may be replaced by
-	 * totally different auto-delete solution (e.g. smart pointers).
-	 *
-	 */
-	void clearCommandMessage();
-
 	/**
 	 * check if a message was cleared
 	 *
@@ -122,11 +94,6 @@ public:
 	 * Is needed quite often, so we better code it once only.
 	 */
 	void setToUnknownCommand();
-
-	void setReplyRejected(ReturnValue_t reason,
-			Command_t initialCommand = CMD_NONE);
-	ReturnValue_t getRejectedReplyReason(
-			Command_t* initialCommand = nullptr) const;
 };
 
 
diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
index 3ffe4daa2..7085ab88d 100644
--- a/ipc/CommandMessageBase.cpp
+++ b/ipc/CommandMessageBase.cpp
@@ -1,4 +1,5 @@
 #include <framework/ipc/CommandMessageBase.h>
+#include <framework/ipc/CommandMessageCleaner.h>
 #include <cstring>
 
 CommandMessageBase::CommandMessageBase(MessageQueueMessageIF *message):
@@ -57,3 +58,25 @@ size_t CommandMessageBase::getMessageSize() const {
 MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
 	return internalMessage;
 }
+
+void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
+		Command_t initialCommand) {
+	std::memcpy(getData(), &reason, sizeof(reason));
+	std::memcpy(getData() + sizeof(reason), &initialCommand,
+			sizeof(initialCommand));
+}
+
+ReturnValue_t CommandMessageBase::getReplyRejectedReason(
+		Command_t *initialCommand) const {
+	ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
+	std::memcpy(&reason, getData(), sizeof(reason));
+	if(initialCommand != nullptr) {
+		std::memcpy(initialCommand, getData() + sizeof(reason),
+				sizeof(Command_t));
+	}
+	return reason;
+}
+
+void CommandMessageBase::clear() {
+	CommandMessageCleaner::clearCommandMessage(this);
+}
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
index b2b7d5f28..d2f24c7e6 100644
--- a/ipc/CommandMessageBase.h
+++ b/ipc/CommandMessageBase.h
@@ -22,9 +22,6 @@
  */
 class CommandMessageBase: public CommandMessageIF {
 public:
-	static constexpr size_t HEADER_SIZE = sizeof(MessageQueueId_t) +
-			sizeof(Command_t);
-
 	CommandMessageBase(MessageQueueMessageIF* message);
 
 	/**
@@ -61,7 +58,25 @@ public:
 	virtual void setMessageSize(size_t messageSize) override;
 	virtual size_t getMessageSize() const override;
 
+	/**
+	 * A command message can be rejected and needs to offer a function
+	 * to set a rejected reply
+	 * @param reason
+	 * @param initialCommand
+	 */
+	void setReplyRejected(ReturnValue_t reason,
+			Command_t initialCommand) override;
+	/**
+	 * Corrensonding getter function.
+	 * @param initialCommand
+	 * @return
+	 */
+	ReturnValue_t getReplyRejectedReason(
+			Command_t* initialCommand = nullptr) const override;
+
 	virtual MessageQueueMessageIF* getInternalMessage() const override;
+
+	virtual void clear() override;
 protected:
 	/**
 	 * @brief 	Pointer to the message containing the data.
diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
new file mode 100644
index 000000000..7153a8e71
--- /dev/null
+++ b/ipc/CommandMessageCleaner.cpp
@@ -0,0 +1,45 @@
+#include <framework/ipc/CommandMessageCleaner.h>
+
+#include <framework/devicehandlers/DeviceHandlerMessage.h>
+#include <framework/health/HealthMessage.h>
+#include <framework/memory/MemoryMessage.h>
+#include <framework/modes/ModeMessage.h>
+#include <framework/monitoring/MonitoringMessage.h>
+#include <framework/subsystem/modes/ModeSequenceMessage.h>
+#include <framework/tmstorage/TmStoreMessage.h>
+#include <framework/parameters/ParameterMessage.h>
+
+void CommandMessageCleaner::clearCommandMessage(CommandMessageIF* message) {
+	switch(message->getMessageType()){
+	case  messagetypes::MODE_COMMAND:
+		ModeMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::HEALTH_COMMAND:
+		HealthMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::MODE_SEQUENCE:
+		ModeSequenceMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::ACTION:
+		ActionMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::DEVICE_HANDLER_COMMAND:
+		DeviceHandlerMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::MEMORY:
+		MemoryMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::MONITORING:
+		MonitoringMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::TM_STORE:
+		TmStoreMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::PARAMETER:
+		ParameterMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	default:
+		messagetypes::clearMissionMessage(message);
+		break;
+	}
+}
diff --git a/ipc/CommandMessageCleaner.h b/ipc/CommandMessageCleaner.h
new file mode 100644
index 000000000..0bd369a2c
--- /dev/null
+++ b/ipc/CommandMessageCleaner.h
@@ -0,0 +1,16 @@
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#include <framework/ipc/CommandMessageIF.h>
+
+namespace messagetypes {
+// Implemented in config.
+void clearMissionMessage(CommandMessageIF* message);
+}
+
+class CommandMessageCleaner {
+public:
+	static void clearCommandMessage(CommandMessageIF* message);
+};
+
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index 44853c38b..fbfbddbb9 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -2,6 +2,9 @@
 #define FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
 
 #include <framework/ipc/MessageQueueMessageIF.h>
+#include <framework/ipc/FwMessageTypes.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
 
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef uint16_t Command_t;
@@ -14,6 +17,20 @@ typedef uint16_t Command_t;
 // we should just leave it like that.
 class CommandMessageIF: public MessageQueueMessageIF {
 public:
+	static constexpr size_t HEADER_SIZE = sizeof(MessageQueueId_t) +
+			sizeof(Command_t);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
+	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
+
+	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
+	//! Used internally, shall be ignored
+	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
+	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
+	//! Reply indicating that the current command was rejected,
+	//! par1 should contain the error code
+	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
+
 	virtual ~CommandMessageIF() {};
 
 	/**
@@ -27,6 +44,22 @@ public:
 	 */
 	virtual uint8_t getMessageType() const = 0;
 
+	/**
+	 * A command message can be rejected and needs to offer a function
+	 * to set a rejected reply
+	 * @param reason
+	 * @param initialCommand
+	 */
+	virtual void setReplyRejected(ReturnValue_t reason,
+			Command_t initialCommand) = 0;
+	/**
+	 * Corrensonding getter function.
+	 * @param initialCommand
+	 * @return
+	 */
+	virtual ReturnValue_t getReplyRejectedReason(
+			Command_t* initialCommand = nullptr) const  = 0;
+
 	/**
 	 * This function is used to get a pointer to the internal message, as
 	 * the command message implementations always operate on the memory
@@ -36,6 +69,7 @@ public:
 	 * @return
 	 */
 	virtual MessageQueueMessageIF* getInternalMessage() const = 0;
+
 };
 
 #endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 2c3846512..fb4d9eb67 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -119,7 +119,7 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
 		break;
 	}
 	if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
-		reply.clearCommandMessage();
+		reply.clear();
 	}
 }
 
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 65053cc88..97856b40a 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -94,7 +94,7 @@ void CommandingServiceBase::handleCommandQueue() {
 }
 
 
-void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
+void CommandingServiceBase::handleCommandMessage(CommandMessageIF* reply) {
 	bool isStep = false;
 	MessageQueueMessage message;
 	CommandMessage nextCommand(&message);
@@ -119,7 +119,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	 * command as failure parameter 1 */
 	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
 			result == RETURN_FAILED) {
-		result = reply->getRejectedReplyReason(
+		result = reply->getReplyRejectedReason(
 				reinterpret_cast<Command_t*>(&failureParameter1));
 	}
 
@@ -156,8 +156,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 }
 
 void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
-		CommandMapIter iter, CommandMessage* nextCommand, CommandMessage* reply,
-		bool& isStep) {
+		CommandMapIter iter, CommandMessageIF* nextCommand,
+		CommandMessageIF* reply, bool& isStep) {
 	iter->command = nextCommand->getCommand();
 
 	// In case a new command is to be sent immediately, this is performed here.
@@ -186,14 +186,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 	}
 	else {
 		if (isStep) {
-			nextCommand->clearCommandMessage();
+			nextCommand->clear();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
 					iter->tcInfo.tcPacketId,
 					iter->tcInfo.tcSequenceControl, sendResult,
 					++iter->step, failureParameter1, failureParameter2);
 		} else {
-			nextCommand->clearCommandMessage();
+			nextCommand->clear();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE,
 					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
@@ -329,7 +329,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 					storedPacket->getPacketSequenceControl();
 			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
 		} else {
-			command.clearCommandMessage();
+			command.clear();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
@@ -346,7 +346,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
 			checkAndExecuteFifo(iter);
 		} else {
-			command.clearCommandMessage();
+			command.clear();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 5adfe4a69..5e2c31713 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -141,7 +141,7 @@ protected:
 	 * @param objectId Target object ID
 	 * @return
 	 */
-	virtual ReturnValue_t prepareCommand(CommandMessage *message,
+	virtual ReturnValue_t prepareCommand(CommandMessageIF *message,
 			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
 			uint32_t *state, object_id_t objectId) = 0;
 
@@ -172,7 +172,7 @@ protected:
 	 */
 	virtual ReturnValue_t handleReply(const CommandMessageIF *reply,
 			Command_t previousCommand, uint32_t *state,
-			CommandMessage *optionalNextCommand, object_id_t objectId,
+			CommandMessageIF *optionalNextCommand, object_id_t objectId,
 			bool *isStep) = 0;
 
 	/**
@@ -312,9 +312,9 @@ private:
 
 	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
 
-	void handleCommandMessage(CommandMessage* reply);
+	void handleCommandMessage(CommandMessageIF* reply);
 	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
-			CommandMessage* nextCommand,CommandMessage* reply, bool& isStep);
+			CommandMessageIF* nextCommand,CommandMessageIF* reply, bool& isStep);
 
 	void checkTimeout();
 };

From 9f69191f234d84e8d73b6ceeeabac3699466aaea Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 14 Jun 2020 17:59:14 +0200
Subject: [PATCH 0443/1774] optimized command messages a bit

---
 ipc/CommandMessage.cpp     |  4 ----
 ipc/CommandMessage.h       |  6 ++----
 ipc/CommandMessageBase.cpp |  8 ++++++++
 ipc/CommandMessageBase.h   | 16 +++++++++++++++-
 4 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 392906880..64d4d41cc 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -66,10 +66,6 @@ size_t CommandMessage::getMinimumMessageSize() const {
 	return MINIMUM_COMMAND_MESSAGE_SIZE;
 }
 
-size_t CommandMessage::getMaximumMessageSize() const {
-	return MessageQueueMessage::MAX_MESSAGE_SIZE;
-}
-
 bool CommandMessage::isClearedCommandMessage() {
 	return getCommand() == CMD_NONE;
 }
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 72f393573..a09494c6c 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -24,11 +24,11 @@ class CommandMessage: public CommandMessageBase {
 public:
 	/**
 	 * This is the size of a message as it is seen by the MessageQueue.
+	 * It can hold the CommandMessage header plus 2 4-byte parameters.
 	 * 14 of the 24 available MessageQueueMessage bytes are used.
 	 */
 	static const size_t MINIMUM_COMMAND_MESSAGE_SIZE =
-			MessageQueueMessage::HEADER_SIZE + sizeof(Command_t) +
-			2 * sizeof(uint32_t);
+			CommandMessageIF::HEADER_SIZE + 2 * sizeof(uint32_t);
 
 	/**
 	 * Default Constructor, does not initialize anything.
@@ -55,8 +55,6 @@ public:
 
 	/** MessageQueueMessageIF functions used for minimum size check. */
 	size_t getMinimumMessageSize() const override;
-	/** MessageQueueMessageIF functions used for maximum size check. */
-	size_t getMaximumMessageSize() const override;
 
 	/**
 	 * Get the first parameter of the message
diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
index 7085ab88d..80f9d3786 100644
--- a/ipc/CommandMessageBase.cpp
+++ b/ipc/CommandMessageBase.cpp
@@ -55,10 +55,18 @@ size_t CommandMessageBase::getMessageSize() const {
 	return internalMessage->getMessageSize();
 }
 
+size_t CommandMessageBase::getMaximumMessageSize() const {
+	return internalMessage->getMaximumMessageSize();
+}
+
 MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
 	return internalMessage;
 }
 
+size_t CommandMessageBase::getMinimumMessageSize() const {
+	return MINIMUM_COMMAND_MESSAGE_BASE_SIZE;
+}
+
 void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
 		Command_t initialCommand) {
 	std::memcpy(getData(), &reason, sizeof(reason));
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
index d2f24c7e6..b237b68f3 100644
--- a/ipc/CommandMessageBase.h
+++ b/ipc/CommandMessageBase.h
@@ -15,13 +15,21 @@
  * size checks:
  *
  *  1. getMinimumMessageSize()
- *  2. getMaximumMessageSize()
  *
+ * The maximum message size generally depends on the buffer size of the passed
+ * internal message.
  * Don't forget to set the message size of the passed message in the concrete
  * commandmessage implementation!
  */
 class CommandMessageBase: public CommandMessageIF {
 public:
+	//! This minimum size is derived from the interface requirement to be able
+	//! to set a rejected reply, which contains a returnvalue and the initial
+	//! command.
+	static constexpr size_t MINIMUM_COMMAND_MESSAGE_BASE_SIZE =
+			CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
+			sizeof(Command_t);
+
 	CommandMessageBase(MessageQueueMessageIF* message);
 
 	/**
@@ -58,6 +66,12 @@ public:
 	virtual void setMessageSize(size_t messageSize) override;
 	virtual size_t getMessageSize() const override;
 
+	//! This depends on the maximum message size of the passed internal message.
+	virtual size_t getMaximumMessageSize() const override;
+
+	//! Return the constant minimum message size.
+	virtual size_t getMinimumMessageSize() const override;
+
 	/**
 	 * A command message can be rejected and needs to offer a function
 	 * to set a rejected reply

From 6ecf1cf534b1eaf45be731263a241b629fa3d937 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 14 Jun 2020 19:03:28 +0200
Subject: [PATCH 0444/1774] hk message continued

---
 housekeeping/HousekeepingMessage.cpp | 57 +++++++++++++++++++++-------
 housekeeping/HousekeepingMessage.h   | 28 ++++++++++----
 2 files changed, 64 insertions(+), 21 deletions(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 6dd1a7116..d47fb92ad 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -3,9 +3,25 @@
 
 HousekeepingMessage::HousekeepingMessage(MessageQueueMessageIF* message):
 		CommandMessageBase(message) {
+	if(message->getMaximumMessageSize() < HK_MESSAGE_SIZE) {
+		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
+				" can not hold minimum "<< HK_MESSAGE_SIZE
+				<< " bytes!" << std::endl;
+		return;
+	}
+	message->setMessageSize(HK_MESSAGE_SIZE);
 }
 
-HousekeepingMessage::~HousekeepingMessage() {
+HousekeepingMessage::~HousekeepingMessage() {}
+
+void HousekeepingMessage::setParameter(uint32_t parameter) {
+	std::memcpy(getData(), &parameter, sizeof(parameter));
+}
+
+uint32_t HousekeepingMessage::getParameter() const {
+	uint32_t parameter;
+	std::memcpy(&parameter, getData(), sizeof(parameter));
+	return parameter;
 }
 
 void HousekeepingMessage::setHkReportMessage(sid_t sid,
@@ -15,32 +31,45 @@ void HousekeepingMessage::setHkReportMessage(sid_t sid,
 	setParameter(storeId.raw);
 }
 
+void HousekeepingMessage::setHkDiagnosticsMessage(sid_t sid,
+		store_address_t storeId) {
+	CommandMessageBase::setCommand(DIAGNOSTICS_REPORT);
+	setSid(sid);
+	setParameter(storeId.raw);
+}
+
 size_t HousekeepingMessage::getMinimumMessageSize() const {
 	return HK_MESSAGE_SIZE;
 }
 
-size_t HousekeepingMessage::getMaximumMessageSize() const {
-	return MessageQueueMessage::MAX_MESSAGE_SIZE;
-}
-
-void HousekeepingMessage::clear() {
-	// clear IPC store where it is needed.
-}
-
 sid_t HousekeepingMessage::getSid() const {
 	sid_t sid;
 	std::memcpy(&sid.raw, CommandMessageBase::getData(), sizeof(sid.raw));
 	return sid;
 }
 
-uint8_t* HousekeepingMessage::getData() {
-	return internalMessage->getBuffer() + sizeof(sid_t);
-}
 
-void HousekeepingMessage::setParameter(uint32_t parameter) {
-	memcpy(getData(), &parameter, sizeof(parameter));
+sid_t HousekeepingMessage::getHkReportMessage(
+		store_address_t *storeIdToSet) const {
+	if(storeIdToSet != nullptr) {
+		*storeIdToSet = getParameter();
+	}
+	return getSid();
 }
 
 void HousekeepingMessage::setSid(sid_t sid) {
 	std::memcpy(CommandMessageBase::getData(), &sid.raw, sizeof(sid.raw));
 }
+
+
+uint8_t* HousekeepingMessage::getData() {
+	return CommandMessageBase::getData() + sizeof(sid_t);
+}
+
+const uint8_t* HousekeepingMessage::getData() const {
+	return CommandMessageBase::getData() + sizeof(sid_t);
+}
+
+void HousekeepingMessage::clear() {
+	// clear IPC store where it is needed.
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 4e9d45531..c5e31fdad 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -27,14 +27,22 @@ union sid_t {
 };
 
 
+/**
+ * @brief	Special command message type for housekeeping messages
+ * @details
+ * This message is slightly larger than regular command messages to accomodate
+ * the uint64_t structure ID (SID).
+ */
 class HousekeepingMessage : public CommandMessageBase {
 public:
 
 	static constexpr size_t HK_MESSAGE_SIZE = sizeof(MessageQueueId_t)
 			+ sizeof(Command_t) + sizeof(sid_t) * sizeof(uint32_t);
+
 	/**
-	 * No instances of a message shall be created, instead
-	 * a CommandMessage instance is manipulated.
+	 * The HK message is initialized with a pointer to a message which holds
+	 * the message data, see CommandMessageIF and getInternalMessage().
+	 * @param message
 	 */
 	HousekeepingMessage(MessageQueueMessageIF* message);
 	virtual ~HousekeepingMessage();
@@ -85,18 +93,24 @@ public:
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
-	void setHkReportMessage(sid_t sid, store_address_t storeId);
 
 	void setParameter(uint32_t parameter);
+	uint32_t getParameter() const;
+
+	void setHkReportMessage(sid_t sid, store_address_t storeId);
+	void setHkDiagnosticsMessage(sid_t sid, store_address_t storeId);
+	//! Get the respective SID and store ID. Command ID can be used beforehand
+	//! to distinguish between diagnostics and regular HK packets
+	sid_t getHkReportMessage(store_address_t * storeIdToSet) const;
 
-	virtual void clear() override;
 	virtual size_t getMinimumMessageSize() const override;
-	virtual size_t getMaximumMessageSize() const override;
-
-	virtual uint8_t* getData() override;
+	virtual void clear() override;
 private:
 	sid_t getSid() const;
 	void setSid(sid_t sid);
+
+	virtual uint8_t* getData() override;
+	virtual const uint8_t* getData() const override;
 };
 
 

From c9d8bd59f0120dca352352dab737d39c43896131 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 15 Jun 2020 11:11:42 +0200
Subject: [PATCH 0445/1774] ctor improved

---
 ipc/CommandMessage.cpp | 19 +++----------------
 1 file changed, 3 insertions(+), 16 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 64d4d41cc..163a6a2d6 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -10,31 +10,18 @@ CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
 		return;
 	}
 	if(receiverMessage->getMaximumMessageSize() <
-			MINIMUM_COMMAND_MESSAGE_SIZE) {
+			getMinimumMessageSize()) {
 		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
 				" can not hold minimum "<< MINIMUM_COMMAND_MESSAGE_SIZE
 				<< " bytes!" << std::endl;
 		return;
 	}
-	internalMessage->setMessageSize(MINIMUM_COMMAND_MESSAGE_SIZE);
+	internalMessage->setMessageSize(getMinimumMessageSize());
 }
 
 CommandMessage::CommandMessage(MessageQueueMessageIF* messageToSet,
 		Command_t command, uint32_t parameter1, uint32_t parameter2):
-				CommandMessageBase(messageToSet) {
-	if(messageToSet == nullptr) {
-		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
-				" as the message queue message, pass the address of an actual"
-				" message!" << std::endl;
-	}
-	if(messageToSet->getMaximumMessageSize() <
-			MINIMUM_COMMAND_MESSAGE_SIZE) {
-		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
-				" can not hold minimum "<< MINIMUM_COMMAND_MESSAGE_SIZE
-				<< " bytes!" << std::endl;
-		return;
-	}
-	internalMessage->setMessageSize(MINIMUM_COMMAND_MESSAGE_SIZE);
+		CommandMessage(messageToSet) {
 	setCommand(command);
 	setParameter(parameter1);
 	setParameter2(parameter2);

From e39d5689e537be8ae3595383005d62e656ad554d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 15 Jun 2020 16:56:22 +0200
Subject: [PATCH 0446/1774] device com IF formattign

---
 devicehandlers/DeviceCommunicationIF.h | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index bb0951164..20565025e 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -1,5 +1,5 @@
-#ifndef DEVICECOMMUNICATIONIF_H_
-#define DEVICECOMMUNICATIONIF_H_
+#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
 
 #include <framework/devicehandlers/CookieIF.h>
 #include <framework/devicehandlers/DeviceHandlerIF.h>
@@ -19,8 +19,8 @@
  * the device handler to allow reuse of these components.
  * @details
  * Documentation: Dissertation Baetz p.138.
- * It works with the assumption that received data
- * is polled by a component. There are four generic steps of device communication:
+ * It works with the assumption that received data  is polled by a component.
+ * There are four generic steps of device communication:
  *
  *   1. Send data to a device
  *   2. Get acknowledgement for sending
@@ -77,8 +77,8 @@ public:
 	 *  - @c RETURN_OK for successfull send
 	 *  - Everything else triggers failure event with returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
-			size_t sendLen) = 0;
+	virtual ReturnValue_t sendMessage(CookieIF *cookie,
+	        const uint8_t * sendData, size_t sendLen) = 0;
 
 	/**
 	 * Called by DHB in the GET_WRITE doGetWrite().
@@ -103,7 +103,8 @@ public:
 	 *         - Everything else triggers failure event with
 	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
+	        size_t requestLen) = 0;
 
 	/**
 	 * Called by DHB in the GET_WRITE doGetRead().
@@ -119,8 +120,8 @@ public:
 	 *         - Everything else triggers failure event with
 	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
-			size_t *size) = 0;
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
+	        uint8_t **buffer, size_t *size) = 0;
 };
 
 #endif /* DEVICECOMMUNICATIONIF_H_ */

From 7871ee7ca810bc49380b3362b3d0c9e1c0e49e0d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 15 Jun 2020 17:39:52 +0200
Subject: [PATCH 0447/1774] mutex helper little formatting correction

---
 ipc/MutexHelper.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 20760b32f..c9579e9b6 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -10,7 +10,7 @@ public:
 			internalMutex(mutex) {
 		ReturnValue_t status = mutex->lockMutex(timeoutMs);
 		if(status == MutexIF::MUTEX_TIMEOUT) {
-			sif::error << "MutexHelper: Lock of mutex failed with timeout of"
+			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
 					<< timeoutMs << " milliseconds!" << std::endl;
 		}
 		else if(status != HasReturnvaluesIF::RETURN_OK){

From 813e82415affa80420751065d83454ae88d47262 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 16 Jun 2020 11:03:24 +0200
Subject: [PATCH 0448/1774] additional doc info

---
 devicehandlers/DeviceCommunicationIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 20565025e..a2662d465 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -72,7 +72,7 @@ public:
 	 * by implementing and calling related drivers or wrapper functions.
 	 * @param cookie
 	 * @param data
-	 * @param len
+	 * @param len If this is 0, nothing shall be sent.
 	 * @return
 	 *  - @c RETURN_OK for successfull send
 	 *  - Everything else triggers failure event with returnvalue as parameter 1

From 38676308e332ead072d35238c95953b7e64abaec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 19:37:55 +0200
Subject: [PATCH 0449/1774] improved array list a bit

---
 container/ArrayList.h | 176 ++++++++++++++++++++----------------------
 1 file changed, 84 insertions(+), 92 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index a37a1c424..8138864b7 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -1,5 +1,5 @@
-#ifndef ARRAYLIST_H_
-#define ARRAYLIST_H_
+#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
+#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serialize/SerializeAdapter.h>
@@ -7,8 +7,9 @@
 
 /**
  * @brief 	A List that stores its values in an array.
- * @details The backend is an array that can be allocated
- * 			by the class itself or supplied via ctor.
+ * @details
+ * The underlying storage is an array that can be allocated by the class
+ * itself or supplied via ctor.
  *
  * @ingroup container
  */
@@ -19,81 +20,13 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
 	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
 
-	/**
-	 * An Iterator to go trough an ArrayList
-	 *
-	 * It stores a pointer to an element and increments the
-	 * pointer when incremented itself.
-	 */
-	class Iterator {
-	public:
-		/**
-		 * Empty ctor, points to NULL
-		 */
-		Iterator() :
-				value(0) {
-
-		}
-
-		/**
-		 * Initializes the Iterator to point to an element
-		 *
-		 * @param initialize
-		 */
-		Iterator(T *initialize) {
-			value = initialize;
-		}
-
-		/**
-		 * The current element the iterator points to
-		 */
-		T *value;
-
-		Iterator& operator++() {
-			value++;
-			return *this;
-		}
-
-		Iterator operator++(int) {
-			Iterator tmp(*this);
-			operator++();
-			return tmp;
-		}
-
-		Iterator& operator--() {
-			value--;
-			return *this;
-		}
-
-		Iterator operator--(int) {
-			Iterator tmp(*this);
-			operator--();
-			return tmp;
-		}
-
-		T operator*() {
-			return *value;
-		}
-
-		T *operator->() {
-			return value;
-		}
-
-		const T *operator->() const{
-			return value;
-		}
-
-		//SHOULDDO this should be implemented as non-member
-		bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const{
-			return (value == other.value);
-		}
-
-		//SHOULDDO this should be implemented as non-member
-		bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
-			return !(*this == other);
-		}
-	}
-	;
+    /**
+     * Copying is forbiden by declaring copy ctor and copy assignment deleted
+     * It is too ambigous in this case.
+     * (Allocate a new backend? Use the same? What to do in an modifying call?)
+     */
+	ArrayList(const ArrayList& other) = delete;
+	const ArrayList& operator=(const ArrayList& other) = delete;
 
 	/**
 	 * Number of Elements stored in this List
@@ -134,6 +67,78 @@ public:
 		}
 	}
 
+    /**
+     * An Iterator to go trough an ArrayList
+     *
+     * It stores a pointer to an element and increments the
+     * pointer when incremented itself.
+     */
+    class Iterator {
+    public:
+        /**
+         * Empty ctor, points to NULL
+         */
+        Iterator(): value(0) {}
+
+        /**
+         * Initializes the Iterator to point to an element
+         *
+         * @param initialize
+         */
+        Iterator(T *initialize) {
+            value = initialize;
+        }
+
+        /**
+         * The current element the iterator points to
+         */
+        T *value;
+
+        Iterator& operator++() {
+            value++;
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
+
+        Iterator& operator--() {
+            value--;
+            return *this;
+        }
+
+        Iterator operator--(int) {
+            Iterator tmp(*this);
+            operator--();
+            return tmp;
+        }
+
+        T operator*() {
+            return *value;
+        }
+
+        T *operator->() {
+            return value;
+        }
+
+        const T *operator->() const{
+            return value;
+        }
+
+        //SHOULDDO this should be implemented as non-member
+        bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const{
+            return (value == other.value);
+        }
+
+        //SHOULDDO this should be implemented as non-member
+        bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
+            return !(*this == other);
+        }
+    };
+
 	/**
 	 * Iterator pointing to the first stored elmement
 	 *
@@ -223,19 +228,6 @@ public:
 		return (maxSize_ - size);
 	}
 
-private:
-	/**
-	 * This is the copy constructor
-	 *
-	 * It is private, as copying is too ambigous in this case. (Allocate a new backend? Use the same?
-	 * What to do in an modifying call?)
-	 *
-	 * @param other
-	 */
-	ArrayList(const ArrayList& other) :
-			size(other.size), entries(other.entries), maxSize_(other.maxSize_),
-			allocated(false) {}
-
 protected:
 	/**
 	 * pointer to the array in which the entries are stored

From f8f10a173033b71d0bb4916cf89243327c0c2921 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 19:41:10 +0200
Subject: [PATCH 0450/1774] slight hybrid iter improvements

---
 container/HybridIterator.h | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index 1c56aa13b..db1ce4bc8 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -8,13 +8,11 @@ template<typename T, typename count_t = uint8_t>
 class HybridIterator: public LinkedElement<T>::Iterator,
 		public ArrayList<T, count_t>::Iterator {
 public:
-	HybridIterator() :
-			value(NULL), linked(NULL), end(NULL) {
-	}
+	HybridIterator() {}
 
 	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
-		LinkedElement<T>::Iterator(*iter), value(
-					iter->value), linked(true), end(NULL) {
+		LinkedElement<T>::Iterator(*iter), value(iter->value),
+		linked(true) {
 
 	}
 
@@ -66,11 +64,11 @@ public:
 		return tmp;
 	}
 
-	bool operator==(HybridIterator other) {
+	bool operator==(const HybridIterator& other) {
 		return value == other.value;
 	}
 
-	bool operator!=(HybridIterator other) {
+	bool operator!=(const HybridIterator& other) {
 		return !(*this == other);
 	}
 
@@ -82,11 +80,11 @@ public:
 		return value;
 	}
 
-	T* value;
+	T* value = nullptr;
 
 private:
-	bool linked;
-	T *end;
+	bool linked = false;
+	T *end = nullptr;
 };
 
 #endif /* HYBRIDITERATOR_H_ */

From b68ad9e4f9182f8e216e69b34d58138e4044494f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 19:50:26 +0200
Subject: [PATCH 0451/1774] new ctor for simple ring buffer which does not

allocate
---
 container/RingBufferBase.h     |  8 +++++---
 container/SimpleRingBuffer.cpp | 12 +++++++++---
 container/SimpleRingBuffer.h   | 30 ++++++++++++++++++++++++------
 3 files changed, 38 insertions(+), 12 deletions(-)

diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 3ef782d87..1beb51c26 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -2,12 +2,14 @@
 #define FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
 
 template<uint8_t N_READ_PTRS = 1>
 class RingBufferBase {
 public:
-	RingBufferBase(uint32_t startAddress, uint32_t size, bool overwriteOld) :
-			start(startAddress), write(startAddress), size(size), overwriteOld(overwriteOld) {
+	RingBufferBase(uint32_t startAddress, const size_t size, bool overwriteOld) :
+			start(startAddress), write(startAddress), size(size),
+			overwriteOld(overwriteOld) {
 		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
 			read[count] = startAddress;
 		}
@@ -83,7 +85,7 @@ protected:
 	const uint32_t start;
 	uint32_t write;
 	uint32_t read[N_READ_PTRS];
-	const uint32_t size;
+	const size_t size;
 	const bool overwriteOld;
 	void incrementWrite(uint32_t amount) {
 		write = ((write + amount - start) % size) + start;
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 63dc3514b..4e50109be 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -1,11 +1,16 @@
 #include <framework/container/SimpleRingBuffer.h>
-#include <string.h>
+#include <cstring>
 
-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;
 }
@@ -66,3 +71,4 @@ ReturnValue_t SimpleRingBuffer::deleteData(uint32_t amount,
 	incrementRead(amount, READ_PTR);
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 4552a1c0a..b5bc2c1c6 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -5,13 +5,29 @@
 #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
+ * @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();
 
 	/**
@@ -30,7 +46,8 @@ public:
 	 * @param trueAmount
 	 * @return
 	 */
-	ReturnValue_t readData(uint8_t* data, uint32_t amount, bool readRemaining = false, uint32_t* trueAmount = NULL);
+	ReturnValue_t readData(uint8_t* data, uint32_t amount,
+	        bool readRemaining = false, uint32_t* trueAmount = nullptr);
 
 	/**
 	 * Delete data starting by incrementing read pointer
@@ -39,11 +56,12 @@ public:
 	 * @param trueAmount
 	 * @return
 	 */
-	ReturnValue_t deleteData(uint32_t amount, bool deleteRemaining = false, uint32_t* trueAmount = NULL);
+	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_ */

From d5ae74f86073c2f9847f4abbd9ed921cdb5ae094 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 20:21:49 +0200
Subject: [PATCH 0452/1774] bugfix hk message size

---
 housekeeping/HousekeepingMessage.cpp | 4 ++--
 housekeeping/HousekeepingMessage.h   | 4 ++--
 ipc/CommandMessage.cpp               | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index d47fb92ad..d7efd7031 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -4,8 +4,8 @@
 HousekeepingMessage::HousekeepingMessage(MessageQueueMessageIF* message):
 		CommandMessageBase(message) {
 	if(message->getMaximumMessageSize() < HK_MESSAGE_SIZE) {
-		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
-				" can not hold minimum "<< HK_MESSAGE_SIZE
+		sif::error << "HousekeepingMessage::HousekeepingMessage: Passed "
+		        "message buffer can not hold minimum " << HK_MESSAGE_SIZE
 				<< " bytes!" << std::endl;
 		return;
 	}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index c5e31fdad..75afc8eae 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -36,8 +36,8 @@ union sid_t {
 class HousekeepingMessage : public CommandMessageBase {
 public:
 
-	static constexpr size_t HK_MESSAGE_SIZE = sizeof(MessageQueueId_t)
-			+ sizeof(Command_t) + sizeof(sid_t) * sizeof(uint32_t);
+	static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
+	        sizeof(sid_t) + sizeof(uint32_t);
 
 	/**
 	 * The HK message is initialized with a pointer to a message which holds
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 163a6a2d6..9a8a82f24 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -12,7 +12,7 @@ CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
 	if(receiverMessage->getMaximumMessageSize() <
 			getMinimumMessageSize()) {
 		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
-				" can not hold minimum "<< MINIMUM_COMMAND_MESSAGE_SIZE
+				" can not hold minimum "<< getMinimumMessageSize()
 				<< " bytes!" << std::endl;
 		return;
 	}

From 259517ac9ba0cc51e61980883467374b3ed849f5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 20:22:09 +0200
Subject: [PATCH 0453/1774] single linked list improvement

---
 container/SinglyLinkedList.h | 46 ++++++++++++++++++------------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 54e7687cd..ed4660865 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -1,8 +1,9 @@
-#ifndef SINGLYLINKEDLIST_H_
-#define SINGLYLINKEDLIST_H_
+#ifndef FRAMEWORK_CONTAINER_SINGLYLINKEDLIST_H_
+#define FRAMEWORK_CONTAINER_SINGLYLINKEDLIST_H_
+
+#include <cstddef>
+#include <cstdint>
 
-#include <stddef.h>
-#include <stdint.h>
 /**
  * @brief	Linked list data structure,
  * 			each entry has a pointer to the next entry (singly)
@@ -47,12 +48,11 @@ public:
 		}
 	};
 
-	LinkedElement(T* setElement, LinkedElement<T>* setNext = NULL) : value(setElement),
-		next(setNext) {
-	}
-	virtual ~LinkedElement(){
+	LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
+	       value(setElement), next(setNext) {}
+
+	virtual ~LinkedElement(){}
 
-	}
 	virtual LinkedElement* getNext() const {
 		return next;
 	}
@@ -69,7 +69,7 @@ public:
 		return this;
 	}
 	LinkedElement* end() {
-		return NULL;
+		return nullptr;
 	}
 private:
 	LinkedElement *next;
@@ -78,21 +78,21 @@ private:
 template<typename T>
 class SinglyLinkedList {
 public:
-	SinglyLinkedList() :
-			start(NULL) {
-	}
+    using ElementIterator = typename LinkedElement<T>::Iterator;
+
+	SinglyLinkedList() {}
+
+	SinglyLinkedList(ElementIterator start) :
+			start(start.value) {}
 
-	SinglyLinkedList(typename LinkedElement<T>::Iterator start) :
-			start(start.value) {
-	}
 	SinglyLinkedList(LinkedElement<T>* startElement) :
-				start(startElement) {
-		}
-	typename LinkedElement<T>::Iterator begin() const {
-		return LinkedElement<T>::Iterator::Iterator(start);
+			start(startElement) {}
+
+	ElementIterator begin() const {
+		return ElementIterator::Iterator(start);
 	}
-	typename LinkedElement<T>::Iterator::Iterator end() const {
-		return LinkedElement<T>::Iterator::Iterator();
+	typename ElementIterator::Iterator end() const {
+		return ElementIterator::Iterator();
 	}
 
 	uint32_t getSize() const {
@@ -108,7 +108,7 @@ public:
 		start = setStart;
 	}
 protected:
-	LinkedElement<T> *start;
+	LinkedElement<T> *start = nullptr;
 };
 
 #endif /* SINGLYLINKEDLIST_H_ */

From bb16fd80b8d60813f0605737e2cdd47d729effbf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 20:37:45 +0200
Subject: [PATCH 0454/1774] singly linked list improvements

---
 container/SinglyLinkedList.h | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index ed4660865..7fffdaac4 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -61,8 +61,8 @@ public:
 		this->next = next;
 	}
 
-	void setEnd() {
-		this->next = nullptr;
+	virtual void setEnd() {
+	    this->next = nullptr;
 	}
 
 	LinkedElement* begin() {
@@ -107,6 +107,11 @@ public:
 	void setStart(LinkedElement<T>* setStart) {
 		start = setStart;
 	}
+
+    void setEnd(LinkedElement<T>* setEnd) {
+        setEnd->setEnd();
+    }
+
 protected:
 	LinkedElement<T> *start = nullptr;
 };

From ed26992d7f1decf404e04d39477836381ec5635b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 20:40:40 +0200
Subject: [PATCH 0455/1774] shoulddo added

---
 container/SinglyLinkedList.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 7fffdaac4..79562cd4a 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -112,6 +112,8 @@ public:
         setEnd->setEnd();
     }
 
+    // SHOULDDO: Insertion operation ?
+
 protected:
 	LinkedElement<T> *start = nullptr;
 };

From 583efec3f8d93efab38c792a9f264f29b0bc01c2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 20:45:44 +0200
Subject: [PATCH 0456/1774] nullptr

---
 container/SinglyLinkedList.h | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 79562cd4a..3c0078fc4 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -15,11 +15,8 @@ public:
 	T *value;
 	class Iterator {
 	public:
-		LinkedElement<T> *value;
-		Iterator() :
-				value(NULL) {
-
-		}
+		LinkedElement<T> *value = nullptr;
+		Iterator() {}
 
 		Iterator(LinkedElement<T> *element) :
 				value(element) {

From 84b8d733c0065280fbb1e39d81bcb8f20fc1ddb7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 03:03:17 +0200
Subject: [PATCH 0457/1774] hk continued

---
 datapool/DataSetBase.h                 |  2 +-
 datapoollocal/LocalDataPoolManager.cpp | 96 +++++++++++++++++++-------
 datapoollocal/LocalDataPoolManager.h   | 42 +++++++----
 datapoollocal/LocalDataSet.cpp         | 68 ++++++++++++++----
 datapoollocal/LocalDataSet.h           | 24 +++++++
 datapoollocal/OwnsLocalDataPoolIF.h    |  4 +-
 housekeeping/HousekeepingMessage.h     |  3 +-
 returnvalues/FwClassIds.h              |  3 +-
 8 files changed, 186 insertions(+), 56 deletions(-)

diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
index 8bf9a99a3..a914ec6b4 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -102,7 +102,7 @@ public:
 	virtual ReturnValue_t unlockDataPool() override;
 
 	/* SerializeIF implementations */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 				const size_t maxSize, bool bigEndian) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 58694508f..a9d131eb7 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,16 +1,17 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/objectmanager/frameworkObjects.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
+#include <framework/ipc/QueueFactory.h>
 
 #include <array>
 
-LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner) {
+LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
+        uint32_t replyQueueDepth, bool appendValidityBuffer):
+        appendValidityBuffer(appendValidityBuffer) {
 	if(owner == nullptr) {
 		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
-		std::exit(0);
+		return;
 	}
 	this->owner = owner;
 	mutex = MutexFactory::instance()->createMutex();
@@ -23,6 +24,8 @@ LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner) {
 	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
 	            "Could not set IPC store." << std::endl;
 	}
+	hkQueue = QueueFactory::instance()->createMessageQueue(replyQueueDepth,
+	        HousekeepingMessage::HK_MESSAGE_SIZE);
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
@@ -36,13 +39,21 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 		}
 		return result;
 	}
-	sif::warning << "HousekeepingManager: The map" << std::endl;
+	sif::warning << "HousekeepingManager: The map should only be initialized "
+	        "once!" << std::endl;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		HousekeepingMessage& message) {
-	return HasReturnvaluesIF::RETURN_FAILED;
+    Command_t command = message.getCommand();
+    switch(command) {
+    case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
+    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
+        return generateHousekeepingPacket(message.getSid());
+    default:
+        return CommandMessageIF::UNKNOWN_COMMAND;
+    }
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
@@ -51,7 +62,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
 	if (poolIter == localDpMap.end()) {
 		sif::debug << "HousekeepingManager::fechPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return OwnsLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
+		return POOL_ENTRY_NOT_FOUND;
 	}
 	poolIter->second->print();
 	return HasReturnvaluesIF::RETURN_OK;
@@ -61,6 +72,15 @@ MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
+void LocalDataPoolManager::setHkPacketDestination(
+        MessageQueueId_t destinationQueueId) {
+    this->currentHkPacketDestination = destinationQueueId;
+}
+
+const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
+    return owner;
+}
+
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
 			owner->getDataSetHandle(sid));
@@ -70,28 +90,56 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	store_address_t storeId;
-	size_t hkSize = dataSetToSerialize->getSerializedSize();
-	uint8_t* storePtr = nullptr;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId, hkSize,&storePtr);
+	ReturnValue_t result = serializeHkPacketIntoStore(&storeId,
+	        dataSetToSerialize);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-	    sif::warning << "HousekeepingManager::generateHousekeepingPacket: "
-	            "Could not get free element from IPC store." << std::endl;
 	    return result;
 	}
-	size_t size = 0;
-	dataSetToSerialize->serialize(&storePtr, &size, hkSize, false);
-	// and now we have to set a HK message and send it the queue.
-	return HasReturnvaluesIF::RETURN_OK;
+
+	// and now we set a HK message and send it the HK packet destination.
+	MessageQueueMessage message;
+	HousekeepingMessage hkMessage(&message);
+	hkMessage.setHkReportMessage(sid, storeId);
+	if(hkQueue == nullptr) {
+	    return QUEUE_NOT_SET;
+	}
+
+	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
+	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
+	}
+	else {
+	    result = hkQueue->sendToDefault(&hkMessage);
+	}
+
+	return result;
 }
 
-void LocalDataPoolManager::setHkPacketQueue(MessageQueueIF *msgQueue) {
-	this->hkPacketQueue = msgQueue;
+ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
+        store_address_t *storeId, LocalDataSet* dataSet) {
+    size_t hkSize = dataSet->getSerializedSize();
+    uint8_t* storePtr = nullptr;
+    ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket: "
+                "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
+    size_t size = 0;
+
+    if(appendValidityBuffer) {
+        result = dataSet->serializeWithValidityBuffer(&storePtr,
+                &size, hkSize, false);
+    }
+    else {
+        result = dataSet->serialize(&storePtr, &size, hkSize, false);
+    }
+
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::serializeHkPacketIntoStore: "
+                "Serialization proccess failed!" << std::endl;
+    }
+    return result;
 }
 
-void LocalDataPoolManager::setHkReplyQueue(MessageQueueIF *replyQueue) {
-    this->hkReplyQueue = replyQueue;
-}
 
-const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
-	return owner;
-}
+
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index d1a2d410c..c649cd684 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -13,6 +13,8 @@
 
 #include <map>
 
+class LocalDataSet;
+
 /**
  * @brief 	This class is the managing instance for local data pool.
  * @details
@@ -37,8 +39,16 @@ class LocalDataPoolManager {
 	friend class LocalPoolVector;
 	friend class LocalDataSet;
 public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-	LocalDataPoolManager(OwnsLocalDataPoolIF* owner);
+    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
+    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
+
+    static constexpr ReturnValue_t QUEUE_NOT_SET = MAKE_RETURN_CODE(0x2);
+    //static constexpr ReturnValue_t SET_NOT_FOUND = MAKE_RETURN_CODE(0x3);
+
+	LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
+	        uint32_t replyQueueDepth = 20, bool appendValidityBuffer = true);
 	virtual~ LocalDataPoolManager();
 
 	/* Copying forbidden */
@@ -57,10 +67,7 @@ public:
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
 	//! Set the queue for HK packets, which are sent unrequested.
-	void setHkPacketQueue(MessageQueueIF* msgQueue);
-	//! Set the queue for replies. This can be set manually or by the owner
-	//! class if the manager if message are relayed by it.
-	void setHkReplyQueue(MessageQueueIF* replyQueue);
+	void setHkPacketDestination(MessageQueueId_t destinationQueueId);
 
 	const OwnsLocalDataPoolIF* getOwner() const;
 
@@ -70,6 +77,10 @@ private:
 	//! This is the map holding the actual data. Should only be initialized
 	//! once !
 	bool mapInitialized = false;
+	//! This specifies whether a validity buffer is appended at the end
+	//! of generated housekeeping packets.
+	bool appendValidityBuffer = true;
+
 	LocalDataPool localDpMap;
 
 	//! Every housekeeping data manager has a mutex to protect access
@@ -79,13 +90,14 @@ private:
 	//! The class which actually owns the manager (and its datapool).
 	OwnsLocalDataPoolIF* owner = nullptr;
 
-	//! Used for replies.
-	//! (maybe we dont need this, the sender can be retrieved from command
-	//! message..)
-	MessageQueueIF* hkReplyQueue = nullptr;
-	//! Used for HK packets, which are generated without requests.
-	//! Maybe this will just be the TM funnel.
-	MessageQueueIF* hkPacketQueue = nullptr;
+	//! Queue used for communication, for example commands.
+	//! Is also used to send messages.
+	MessageQueueIF* hkQueue = nullptr;
+
+	//! HK replies will always be a reply to the commander, but HK packet
+	//! can be sent to another destination by specifying this message queue
+	//! ID, for example to a dedicated housekeeping service implementation.
+	MessageQueueId_t currentHkPacketDestination = MessageQueueIF::NO_QUEUE;
 
 	//! Global IPC store is used to store all packets.
 	StorageManagerIF* ipcStore = nullptr;
@@ -113,6 +125,8 @@ private:
 			PoolEntry<T> **poolEntry);
 
 	void setMinimalSamplingFrequency(float frequencySeconds);
+	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
+	        LocalDataSet* dataSet);
 };
 
 
@@ -123,14 +137,14 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 	if (poolIter == localDpMap.end()) {
 		sif::debug << "HousekeepingManager::fechPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return OwnsLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
+		return POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
 		sif::debug << "HousekeepingManager::fetchPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return OwnsLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
+		return POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 243c9cc1d..bb4aafef2 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -1,22 +1,25 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
 
+#include <cmath>
+#include <cstring>
+
 LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner): DataSetBase() {
-	if(hkOwner != nullptr) {
-		hkManager = hkOwner->getHkManagerHandle();
-	}
-	else {
-		// config error, error output here.
-	}
+    if(hkOwner == nullptr) {
+        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
+                << std::endl;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
 }
 
 LocalDataSet::LocalDataSet(object_id_t ownerId): DataSetBase()  {
-	OwnsLocalDataPoolIF* hkOwner = objectManager->get<OwnsLocalDataPoolIF>(
-			ownerId);
-	if(hkOwner == nullptr) {
-		// config error, error output here.
-	}
-	hkManager = hkOwner->getHkManagerHandle();
+    OwnsLocalDataPoolIF* hkOwner = objectManager->get<OwnsLocalDataPoolIF>(
+            ownerId);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
+                << std::endl;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
 }
 
 LocalDataSet::~LocalDataSet() {
@@ -27,9 +30,50 @@ ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
 	return mutex->lockMutex(timeoutMs);
 }
 
+ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
+        size_t *size, const size_t maxSize, bool bigEndian) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+    uint8_t validityMask[validityMaskSize];
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if(registeredVariables[count]->isValid()) {
+            // set validity buffer here.
+            this->bitSetter(validityMask + validBufferIndex,
+                    validBufferIndexBit, true);
+            if(validBufferIndexBit == 7) {
+                validBufferIndex ++;
+                validBufferIndexBit = 0;
+            }
+            else {
+                validBufferIndexBit ++;
+            }
+        }
+        result = registeredVariables[count]->serialize(buffer, size, maxSize,
+                bigEndian);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    // copy validity buffer to end
+    std::memcpy(*buffer, validityMask, validityMaskSize);
+    *size += validityMaskSize;
+    return result;
+}
+
 ReturnValue_t LocalDataSet::unlockDataPool() {
 	MutexIF* mutex = hkManager->getMutexHandle();
 	return mutex->unlockMutex();
 }
 
+void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position,
+        bool value) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1UL << shiftNumber;
+}
 
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 54da5562c..0c3b3bd8d 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -55,6 +55,20 @@ public:
 	 */
 	~LocalDataSet();
 
+	/**
+	 * Special version of the serilization function which appends a
+	 * validity buffer at the end. Each bit of this validity buffer
+	 * denotes whether the container data set entries are valid from left
+	 * to right, MSB first.
+	 * @param buffer
+	 * @param size
+	 * @param maxSize
+	 * @param bigEndian
+	 * @param withValidityBuffer
+	 * @return
+	 */
+	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
+	        size_t* size, const size_t maxSize, bool bigEndian) const ;
 protected:
 private:
 	/**
@@ -79,6 +93,16 @@ private:
 	ReturnValue_t unlockDataPool() override;
 
 	LocalDataPoolManager* hkManager;
+
+	/**
+	 * Sets the bit at the bit-position of a byte provided by its address
+	 * to the specified value (zero or one).
+	 * @param byte Pointer to byte to bitset.
+	 * @param position MSB first, 0 to 7 possible.
+	 * @param value Value to set.
+	 * @return
+	 */
+	void bitSetter(uint8_t* byte, uint8_t position, bool value) const;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/OwnsLocalDataPoolIF.h b/datapoollocal/OwnsLocalDataPoolIF.h
index cf94f946a..8d657879e 100644
--- a/datapoollocal/OwnsLocalDataPoolIF.h
+++ b/datapoollocal/OwnsLocalDataPoolIF.h
@@ -40,9 +40,7 @@ class OwnsLocalDataPoolIF {
 public:
 	virtual~ OwnsLocalDataPoolIF() {};
 
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING;
-	static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0XA0);
-	static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0xA1);
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual ReturnValue_t initializeHousekeepingPoolEntries(
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 75afc8eae..c6a33c835 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -96,6 +96,7 @@ public:
 
 	void setParameter(uint32_t parameter);
 	uint32_t getParameter() const;
+	sid_t getSid() const;
 
 	void setHkReportMessage(sid_t sid, store_address_t storeId);
 	void setHkDiagnosticsMessage(sid_t sid, store_address_t storeId);
@@ -106,7 +107,7 @@ public:
 	virtual size_t getMinimumMessageSize() const override;
 	virtual void clear() override;
 private:
-	sid_t getSid() const;
+
 	void setSid(sid_t sid);
 
 	virtual uint8_t* getData() override;
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 870efb461..ddee539e3 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -61,8 +61,9 @@ enum {
 	MUTEX_IF, //MUX 55
 	MESSAGE_QUEUE_IF,//MQI 56
 	SEMAPHORE_IF, //SPH 57
-	HOUSEKEEPING, //HK 58
+	LOCAL_POOL_OWNER_IF, //LPIF 58
 	POOL_VARIABLE_IF, //PVA 59
+	HOUSEKEEPING_MANAGER, //HKM 60
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 60ae2d45655330a3d81dd897b8dfb0ff6456dcd4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 14:25:03 +0200
Subject: [PATCH 0458/1774] continued with hk data pool

added deadline missed check for fixed timeslot task,
improved doc for both periodic task and fixed timeslot task
---
 datapool/DataSetBase.cpp               |  4 ++
 datapool/DataSetBase.h                 |  2 +
 datapool/DataSetIF.h                   |  1 +
 datapoollocal/LocalDataPoolManager.cpp | 40 ++++++++++++++++-
 datapoollocal/LocalDataPoolManager.h   |  2 +
 datapoollocal/LocalDataSet.cpp         | 16 +++++++
 datapoollocal/LocalDataSet.h           |  5 ++-
 datapoollocal/OwnsLocalDataPoolIF.h    | 30 +++++++++++--
 devicehandlers/DeviceHandlerBase.cpp   | 17 +++++++-
 devicehandlers/DeviceHandlerBase.h     | 11 ++++-
 events/EventManager.cpp                | 11 +++--
 events/EventManager.h                  |  4 +-
 osal/FreeRTOS/FixedTimeslotTask.cpp    | 60 +++++++++++++++++---------
 osal/FreeRTOS/FixedTimeslotTask.h      | 49 ++++++++++-----------
 osal/FreeRTOS/PeriodicTask.cpp         | 30 +++++++------
 osal/FreeRTOS/PeriodicTask.h           | 49 ++++++++++++---------
 serialize/SerializeAdapter.h           | 15 +++++++
 tasks/ExecutableObjectIF.h             |  6 ++-
 tmtcservices/CommandingServiceBase.cpp |  5 ++-
 tmtcservices/CommandingServiceBase.h   |  4 +-
 20 files changed, 261 insertions(+), 100 deletions(-)

diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
index 60b20f296..b788d05da 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -53,6 +53,10 @@ ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
 	return result;
 }
 
+uint16_t DataSetBase::getFillCount() const {
+    return fillCount;
+}
+
 ReturnValue_t DataSetBase::readVariable(uint16_t count) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	// These checks are often performed by the respective
diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
index a914ec6b4..8f7d892a9 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -101,6 +101,8 @@ public:
 	 */
 	virtual ReturnValue_t unlockDataPool() override;
 
+	virtual uint16_t getFillCount() const;
+
 	/* SerializeIF implementations */
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 				const size_t maxSize, bool bigEndian) const override;
diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index 9c5b13c81..437f324f6 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -43,6 +43,7 @@ public:
 	 */
 	virtual ReturnValue_t registerVariable(PoolVariableIF* variable) = 0;
 
+	virtual uint16_t getFillCount() const = 0;
 private:
 	/**
 	 * @brief 	Most underlying data structures will have a pool like structure
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index a9d131eb7..e0731a96c 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -33,7 +33,7 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	if(not mapInitialized) {
 		ReturnValue_t result =
-				owner->initializeHousekeepingPoolEntries(localDpMap);
+				owner->initializePoolEntries(localDpMap);
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			mapInitialized = true;
 		}
@@ -48,6 +48,14 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		HousekeepingMessage& message) {
     Command_t command = message.getCommand();
     switch(command) {
+    // I think those are the only commands which can be handled here..
+    case(HousekeepingMessage::ADD_HK_REPORT_STRUCT):
+    case(HousekeepingMessage::ADD_DIAGNOSTICS_REPORT_STRUCT):
+        // We should use OwnsLocalPoolDataIF to specify those functions..
+        return HasReturnvaluesIF::RETURN_OK;
+    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
+    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
+        return generateSetStructurePacket(message.getSid());
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
     case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
         return generateHousekeepingPacket(message.getSid());
@@ -114,13 +122,41 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	return result;
 }
 
+ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
+    LocalDataSet* dataSet = dynamic_cast<LocalDataSet*>(
+            owner->getDataSetHandle(sid));
+    if(dataSet == nullptr) {
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+                " Set ID not found" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t);
+    uint8_t* storePtr = nullptr;
+    store_address_t storeId;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            expectedSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+                "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
+    size_t size = 0;
+    result = dataSet->serializeLocalPoolIds(&storePtr, &size,
+            expectedSize, false);
+    if(expectedSize != size) {
+        sif::error << "HousekeepingManager::generateSetStructurePacket: "
+                "Expected size is not equal to serialized size" << std::endl;
+    }
+    return result;
+}
+
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
         store_address_t *storeId, LocalDataSet* dataSet) {
     size_t hkSize = dataSet->getSerializedSize();
     uint8_t* storePtr = nullptr;
     ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket: "
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
                 "Could not get free element from IPC store." << std::endl;
         return result;
     }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c649cd684..b64917241 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -56,6 +56,8 @@ public:
 	LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 
 	ReturnValue_t generateHousekeepingPacket(sid_t sid);
+	ReturnValue_t generateSetStructurePacket(sid_t sid);
+
 	ReturnValue_t handleHousekeepingMessage(HousekeepingMessage& message);
 
 	/**
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index bb4aafef2..27ad4bc2a 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -1,5 +1,6 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
+#include <framework/serialize/SerializeAdapter.h>
 
 #include <cmath>
 #include <cstring>
@@ -67,6 +68,21 @@ ReturnValue_t LocalDataSet::unlockDataPool() {
 	return mutex->unlockMutex();
 }
 
+ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
+        size_t* size, const size_t maxSize, bool bigEndian) const {
+    for (uint16_t count = 0; count < fillCount; count++) {
+        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
+        auto result = AutoSerializeAdapter::serialize(&currentPoolId, buffer,
+                size, maxSize, bigEndian);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
+                    " error!" << std::endl;
+            return result;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position,
         bool value) const {
     if(position > 7) {
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 0c3b3bd8d..48138e631 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -68,7 +68,10 @@ public:
 	 * @return
 	 */
 	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
-	        size_t* size, const size_t maxSize, bool bigEndian) const ;
+	        size_t* size, const size_t maxSize, bool bigEndian) const;
+
+	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
+            size_t* size, const size_t maxSize, bool bigEndian) const;
 protected:
 private:
 	/**
diff --git a/datapoollocal/OwnsLocalDataPoolIF.h b/datapoollocal/OwnsLocalDataPoolIF.h
index 8d657879e..6fc108896 100644
--- a/datapoollocal/OwnsLocalDataPoolIF.h
+++ b/datapoollocal/OwnsLocalDataPoolIF.h
@@ -42,12 +42,36 @@ public:
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 
+	/** Command queue for housekeeping messages. */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ReturnValue_t initializeHousekeepingPoolEntries(
-			LocalDataPool& localDataPoolMap) = 0;
-	//virtual float setMinimalHkSamplingFrequency() = 0;
+
+	/** Is used by pool owner to initialize the pool map once */
+	virtual ReturnValue_t initializePoolEntries(
+	        LocalDataPool& localDataPoolMap) = 0;
+
+	/** Can be used to get a handle to the local data pool manager. */
 	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
 	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
+
+	/* These function can be implemented by pool owner, as they are required
+	 * by the housekeeping message interface */
+	virtual ReturnValue_t addDataSet(sid_t sid) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+	virtual ReturnValue_t removeDataSet(sid_t sid) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
+	        dur_seconds_t newInterval) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
 };
 
 #endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index bf6998485..1ae056a6d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1350,7 +1350,7 @@ void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 }
 
 void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
-			executingTask = task_;
+	executingTask = task_;
 }
 
 // Default implementations empty.
@@ -1360,7 +1360,7 @@ void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
 void DeviceHandlerBase::performOperationHook() {
 }
 
-ReturnValue_t DeviceHandlerBase::initializeHousekeepingPoolEntries(
+ReturnValue_t DeviceHandlerBase::initializePoolEntries(
 		LocalDataPool &localDataPoolMap) {
 	return RETURN_OK;
 }
@@ -1369,6 +1369,19 @@ LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
 	return &hkManager;
 }
 
+ReturnValue_t DeviceHandlerBase::addDataSet(sid_t sid) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DeviceHandlerBase::removeDataSet(sid_t sid) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DeviceHandlerBase::changeCollectionInterval(sid_t sid,
+        dur_seconds_t newInterval) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
 	auto iter = deviceReplyMap.find(sid.ownerSetId);
 	if(iter != deviceReplyMap.end()) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 4ee3d652c..1290742c3 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -477,12 +477,17 @@ protected:
 	 * @param localDataPoolMap
 	 * @return
 	 */
-	virtual ReturnValue_t initializeHousekeepingPoolEntries(
+	virtual ReturnValue_t initializePoolEntries(
 				LocalDataPool& localDataPoolMap) override;
 
 	/** Get the HK manager object handle */
 	virtual LocalDataPoolManager* getHkManagerHandle() override;
 
+	virtual ReturnValue_t addDataSet(sid_t sid) override;
+	virtual ReturnValue_t removeDataSet(sid_t sid) override;
+	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
+	        dur_seconds_t newInterval) override;
+
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
 	 * 			performOperation(). Default implementation is empty.
@@ -703,7 +708,9 @@ 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.
 
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 73e77e94a..539f9e275 100644
--- a/events/EventManager.cpp
+++ b/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);
diff --git a/events/EventManager.h b/events/EventManager.h
index 76dde9f8d..6fac83526 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -36,11 +36,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;
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 18ec1092f..de99413ef 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -1,6 +1,7 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include "FixedTimeslotTask.h"
 
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
 
@@ -18,16 +19,19 @@ FixedTimeslotTask::~FixedTimeslotTask() {
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
 
-	//The argument is re-interpreted as FixedTimeslotTask. The Task object is global, so it is found from any place.
+	// The argument is re-interpreted as FixedTimeslotTask. The Task object is
+    // global, so it is found from any place.
 	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
-	// Task should not start until explicitly requested
-	// in FreeRTOS, tasks start as soon as they are created if the scheduler is running
-	// but not if the scheduler is not running.
-	// to be able to accommodate both cases we check a member which is set in #startTask()
-	// if it is not set and we get here, the scheduler was started before #startTask() was called and we need to suspend
-	// if it is set, the scheduler was not running before #startTask() was called and we can continue
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
 
-	if (!originalTask->started) {
+	if (not originalTask->started) {
 		vTaskSuspend(NULL);
 	}
 
@@ -81,7 +85,8 @@ 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.
+	// A local iterator for the Polling Sequence Table is created to find the
+    // start time for the first entry.
 	SlotListIter slotListIter = pst.current;
 
 	//The start time for the first entry is read.
@@ -101,17 +106,30 @@ void FixedTimeslotTask::taskFunctionality() {
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
 		//The component for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		} else {
-			// we need to wait before executing the current slot
-			//this gives us the time to wait:
-			intervalMs = this->pst.getIntervalToPreviousSlotMs();
-			interval = pdMS_TO_TICKS(intervalMs);
-			vTaskDelayUntil(&xLastWakeTime, interval);
-			//TODO deadline missed check
-		}
+	    this->pst.executeAndAdvance();
+	    if (not pst.slotFollowsImmediately()) {
+	        /* If all operations are finished and the difference of the
+	         * current time minus the last wake time is larger than the
+	         * expected wait period, a deadline was missed. */
+	        if(xTaskGetTickCount() - xLastWakeTime >=
+	                pdMS_TO_TICKS(this->pst.getIntervalToPreviousSlotMs())) {
+#ifdef DEBUG
+	            sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+	                    " missed deadline!\n" << std::flush;
+#endif
+	            if(deadlineMissedFunc != nullptr) {
+	                this->deadlineMissedFunc();
+	            }
+	            // Continue immediately, no need to wait.
+	            break;
+	        }
+
+	        // we need to wait before executing the current slot
+	        //this gives us the time to wait:
+	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
+	        interval = pdMS_TO_TICKS(intervalMs);
+	        vTaskDelayUntil(&xLastWakeTime, interval);
+	    }
 	}
 }
 
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index fe93dafff..39db667cb 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,12 +1,12 @@
-#ifndef POLLINGTASK_H_
-#define POLLINGTASK_H_
+#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 
 #include <framework/devicehandlers/FixedSlotSequence.h>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
-#include <FreeRTOS.h>
-#include "task.h"
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF {
 public:
@@ -29,16 +29,18 @@ public:
 
 	/**
 	 * @brief	The destructor of the class.
-	 *
-	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
-	 * 			the device handlers. This is done by calling the PST's destructor.
+	 * @details
+	 * The destructor frees all heap memory that was allocated on thread
+	 * initialization for the PST and the device handlers. This is done by
+	 * calling the PST's destructor.
 	 */
 	virtual ~FixedTimeslotTask(void);
 
 	ReturnValue_t startTask(void);
 	/**
 	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+	 * It counts missedDeadlines and prints the number of missed deadlines
+	 * every 10th time.
 	 */
 	static void missedDeadlineCounter();
 	/**
@@ -62,30 +64,29 @@ protected:
 	FixedSlotSequence pst;
 
 	/**
-	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
-	 *
-	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
-	 * 			Currently, only one function for missing any deadline is allowed.
-	 * 			If not used, it shall be declared NULL.
+	 * @brief	This attribute holds a function pointer that is executed when
+	 *          a deadline was missed.
+	 * @details
+	 * Another function may be announced to determine the actions to perform
+	 * when a deadline was missed. Currently, only one function for missing
+	 * any deadline is allowed. If not used, it shall be declared NULL.
 	 */
 	void (*deadlineMissedFunc)(void);
 	/**
-	 * @brief	This is the entry point in a new polling thread.
-	 *
-	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
-	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
-	 * 			on success. If operation of the task is ended for some reason,
-	 * 			the destructor is called to free allocated memory.
+	 * @brief	This is the entry point for a new task.
+	 * @details
+	 * This method starts the task by calling taskFunctionality(), as soon as
+	 * all requirements (task scheduler has started and startTask()
+	 * has been called) are met.
 	 */
 	static void taskEntryPoint(void* argument);
 
 	/**
 	 * @brief	This function holds the main functionality of the thread.
-	 *
-	 *
-	 * @details	Holding the main functionality of the task, this method is most important.
-	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
-	 * 			to keep the timing of the periods.
+	 * @details
+	 * Core function holding the main functionality of the task
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
 	 */
 	void taskFunctionality(void);
 };
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index a8e405613..318676393 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -12,8 +12,8 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 	BaseType_t status = xTaskCreate(taskEntryPoint, name,
 			setStack, this, setPriority, &handle);
 	if(status != pdPASS){
-		sif::debug << "PeriodicTask Insufficient heap memory remaining. Status: "
-		           << status << std::endl;
+		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
+		        "Status: " << status << std::endl;
 	}
 
 }
@@ -23,14 +23,17 @@ PeriodicTask::~PeriodicTask(void) {
 }
 
 void PeriodicTask::taskEntryPoint(void* argument) {
-	//The argument is re-interpreted as PeriodicTask. The Task object is global, so it is found from any place.
+	// The argument is re-interpreted as PeriodicTask. The Task object is
+    // global, so it is found from any place.
 	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
-	// Task should not start until explicitly requested
-	// in FreeRTOS, tasks start as soon as they are created if the scheduler is running
-	// but not if the scheduler is not running.
-	// to be able to accommodate both cases we check a member which is set in #startTask()
-	// if it is not set and we get here, the scheduler was started before #startTask() was called and we need to suspend
-	// if it is set, the scheduler was not running before #startTask() was called and we can continue
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
 
 	if (not originalTask->started) {
 		vTaskSuspend(NULL);
@@ -61,9 +64,9 @@ void PeriodicTask::taskFunctionality() {
 	TickType_t xLastWakeTime;
 	const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
 	/* 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 internally within
-	 vTaskDelayUntil(). */
+	 count. Note that this is the only time the variable is written to
+	 explicitly. After this assignment, xLastWakeTime is updated automatically
+	 internally within vTaskDelayUntil(). */
 	xLastWakeTime = xTaskGetTickCount();
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
@@ -76,12 +79,15 @@ void PeriodicTask::taskFunctionality() {
 		 * current time minus the last wake time is larger than the
 		 * wait period, a deadline was missed. */
 		if(xTaskGetTickCount() - xLastWakeTime >= xPeriod) {
+#ifdef DEBUG
 			sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
 					" missed deadline!\n" << std::flush;
+#endif
 			if(deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
 		}
+
 		vTaskDelayUntil(&xLastWakeTime, xPeriod);
 
 	}
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index a449328e3..fd1dd0df4 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -5,10 +5,8 @@
 #include <framework/tasks/PeriodicTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-}
 
 #include <vector>
 
@@ -22,7 +20,8 @@ class ExecutableObjectIF;
 class PeriodicTask: public PeriodicTaskIF {
 public:
 	/**
-	 * @brief	Standard constructor of the class.
+	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
 	 * @details
 	 * The class is initialized without allocated objects.
 	 * These need to be added with #addComponent.
@@ -38,8 +37,9 @@ public:
 	 * The function pointer to the deadline missed function that shall
 	 * be assigned.
 	 */
-	PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack,
-			TaskPeriod setPeriod,void (*setDeadlineMissedFunc)());
+	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.
@@ -58,7 +58,9 @@ public:
 	 * 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 RETURN_OK on success, RETURN_FAILED if the object could not be added.
+	 * @return
+	 * -@c RETURN_OK on success
+	 * -@c RETURN_FAILED if the object could not be added.
 	 */
 	ReturnValue_t addComponent(object_id_t object);
 
@@ -69,40 +71,47 @@ protected:
 	bool started;
 	TaskHandle_t handle;
 
-	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
+	//! Typedef for the List of objects.
+	typedef std::vector<ExecutableObjectIF*> ObjectList;
 	/**
 	 * @brief	This attribute holds a list of objects to be executed.
 	 */
 	ObjectList objectList;
 	/**
 	 * @brief	The period of the task.
-	 * @details	The period determines the frequency of the task's execution. It is expressed in clock ticks.
+	 * @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.
+	 * @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.
+	 * @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.
 	 */
 
 	static 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.
+	 * @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);
 };
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 87e4457ae..62c202043 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -65,6 +65,21 @@
 // No type specification necessary here.
 class AutoSerializeAdapter {
 public:
+    /**
+     * Serialize object into buffer.
+     * @tparam T Type of object.
+     * @param object Object to serialize
+     * @param buffer
+     * Serialize into this buffer, pointer to pointer has to be passed,
+     * *buffer will be incremented automatically.
+     * @param size [out]
+     * Update passed size value, will be incremented by serialized size
+     * @param max_size
+     * Maximum size for range checking
+     * @param bigEndian
+     * Set to true if host-to-network conversion or vice-versa is needed
+     * @return
+     */
 	template<typename T>
 	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
 			size_t* size, const size_t max_size, bool bigEndian) {
diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h
index 5c5955c1c..516b4084b 100644
--- a/tasks/ExecutableObjectIF.h
+++ b/tasks/ExecutableObjectIF.h
@@ -37,8 +37,10 @@ public:
 
 	/**
 	 * @brief Function called during setup assignment of object to task
-	 * @details Has to be called from the function that assigns the object to a task and
-	 * 			enables the object implementation to overwrite this function and get a reference to the executing task
+	 * @details
+	 * Has to be called from the function that assigns the object to a task and
+	 * enables the object implementation to overwrite this function and get
+	 * a reference to the executing task
 	 * @param task_ Pointer to the taskIF of this task
 	 */
 	virtual void setTaskIF(PeriodicTaskIF* task_) {
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 97856b40a..4d29c10e6 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -412,5 +412,6 @@ void CommandingServiceBase::checkTimeout() {
 	}
 }
 
-
-
+void CommandingServiceBase::setTaskIF(PeriodicTaskIF* task_) {
+    executingTask = task_;
+}
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 5e2c31713..05f50709b 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -97,9 +97,7 @@ public:
 	 * Used to setup the reference of the task, that executes this component
 	 * @param task_ Pointer to the taskIF of this task
 	 */
-	virtual void setTaskIF(PeriodicTaskIF* task_){
-		executingTask = task_;
-	};
+	virtual void setTaskIF(PeriodicTaskIF* task_);
 
 protected:
 	/**

From eb4ce980fe93feaba64f01cf13d43d96aaa7d20a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 14:32:04 +0200
Subject: [PATCH 0459/1774] small fixed

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 2 +-
 osal/FreeRTOS/PeriodicTask.h        | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index de99413ef..ea324d35e 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -114,7 +114,7 @@ void FixedTimeslotTask::taskFunctionality() {
 	        if(xTaskGetTickCount() - xLastWakeTime >=
 	                pdMS_TO_TICKS(this->pst.getIntervalToPreviousSlotMs())) {
 #ifdef DEBUG
-	            sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+	            sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
 	                    " missed deadline!\n" << std::flush;
 #endif
 	            if(deadlineMissedFunc != nullptr) {
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index fd1dd0df4..b9930a73b 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -22,6 +22,7 @@ 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.

From 2de811e0afd0ae6a1dc9e4d700bedc693a888691 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 20:14:56 +0200
Subject: [PATCH 0460/1774] moved timeslot files to task folder

implmented setting task IF for regular periodic tasks
---
 osal/FreeRTOS/FixedTimeslotTask.cpp           | 10 +++----
 osal/FreeRTOS/FixedTimeslotTask.h             | 10 +++----
 osal/FreeRTOS/PeriodicTask.cpp                | 14 ++++++----
 osal/FreeRTOS/PeriodicTask.h                  |  9 ++++---
 osal/host/FixedTimeslotTask.h                 |  2 +-
 osal/linux/PeriodicPosixTask.cpp              |  7 ++++-
 osal/linux/PeriodicPosixTask.h                |  3 ++-
 .../FixedSequenceSlot.cpp                     | 15 ++++-------
 {devicehandlers => tasks}/FixedSequenceSlot.h | 25 +++++++-----------
 .../FixedSlotSequence.cpp                     |  2 +-
 {devicehandlers => tasks}/FixedSlotSequence.h |  6 ++---
 tasks/FixedTimeslotTaskIF.h                   | 11 ++++++--
 tasks/PeriodicTaskIF.h                        | 26 ++++++++++++++++---
 13 files changed, 82 insertions(+), 58 deletions(-)
 rename {devicehandlers => tasks}/FixedSequenceSlot.cpp (53%)
 rename {devicehandlers => tasks}/FixedSequenceSlot.h (78%)
 rename {devicehandlers => tasks}/FixedSlotSequence.cpp (98%)
 rename {devicehandlers => tasks}/FixedSlotSequence.h (97%)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index ea324d35e..f3a65fcdd 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -62,11 +62,6 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		if(slotTimeMs == 0) {
-			// FreeRTOS throws a sanity error for zero values, so we set
-			// the time to one millisecond.
-			slotTimeMs = 1;
-		}
 		pst.addSlot(componentId, slotTimeMs, executionStep, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -101,7 +96,9 @@ void FixedTimeslotTask::taskFunctionality() {
 	xLastWakeTime = xTaskGetTickCount();
 
 	// wait for first entry's start time
-	vTaskDelayUntil(&xLastWakeTime, interval);
+	if(interval > 0) {
+	    vTaskDelayUntil(&xLastWakeTime, interval);
+	}
 
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
@@ -137,3 +134,4 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	vTaskDelay(pdMS_TO_TICKS(ms));
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 39db667cb..183fad20c 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 #define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 
-#include <framework/devicehandlers/FixedSlotSequence.h>
+#include <framework/tasks/FixedSlotSequence.h>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
@@ -49,13 +49,13 @@ public:
 	static uint32_t deadlineMissedCount;
 
 	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-			int8_t executionStep);
+			int8_t executionStep) override;
 
-	uint32_t getPeriodMs() const;
+	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t checkSequence() const;
+	ReturnValue_t checkSequence() const override;
 
-	ReturnValue_t sleepFor(uint32_t ms);
+	ReturnValue_t sleepFor(uint32_t ms) override;
 
 protected:
 	bool started;
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 318676393..43928f7c2 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -70,9 +70,8 @@ void PeriodicTask::taskFunctionality() {
 	xLastWakeTime = xTaskGetTickCount();
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
+		for (auto const& object: objectList) {
+			object->performOperation();
 		}
 
 		/* If all operations are finished and the difference of the
@@ -93,12 +92,17 @@ void PeriodicTask::taskFunctionality() {
 	}
 }
 
-ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
+ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
-	if (newObject == NULL) {
+	if (newObject == nullptr) {
+	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+	            "it implement ExecutableObjectIF" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	if(setTaskIF) {
+	    newObject->setTaskIF(this);
+	}
 	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index b9930a73b..a580f519f 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -54,7 +54,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.
@@ -63,11 +63,12 @@ public:
 	 * -@c RETURN_OK on success
 	 * -@c RETURN_FAILED if the object could not be added.
 	 */
-	ReturnValue_t addComponent(object_id_t object);
+	ReturnValue_t addComponent(object_id_t object,
+	        bool setTaskIF = true) override;
 
-	uint32_t getPeriodMs() const;
+	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t sleepFor(uint32_t ms);
+	ReturnValue_t sleepFor(uint32_t ms) override;
 protected:
 	bool started;
 	TaskHandle_t handle;
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index bb2f757aa..b12cc6d3d 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/devicehandlers/FixedSlotSequence.h>
+#include <framework/tasks/FixedSlotSequence.h>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index df5bbf930..ca7011b07 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -24,9 +24,14 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
 ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
-	if (newObject == NULL) {
+	if (newObject == nullptr) {
+	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+	            "it implements ExecutableObjectIF" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	if(setTaskIF) {
+	    newObject->setTaskIF(this);
+	}
 	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 85de0d597..1d62a5659 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -39,7 +39,8 @@ public:
 	 * @param object Id of the object to add.
 	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
 	 */
-	ReturnValue_t addComponent(object_id_t object);
+	ReturnValue_t addComponent(object_id_t object,
+	        bool setTaskIF = true) override;
 
 	uint32_t getPeriodMs() const;
 
diff --git a/devicehandlers/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
similarity index 53%
rename from devicehandlers/FixedSequenceSlot.cpp
rename to tasks/FixedSequenceSlot.cpp
index bb97a8e5c..c46b4fc00 100644
--- a/devicehandlers/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -1,19 +1,14 @@
-/**
- * @file	PollingSlot.cpp
- * @brief	This file defines the PollingSlot class.
- * @date	19.12.2012
- * @author	baetz
- */
-
-#include <framework/devicehandlers/FixedSequenceSlot.h>
 #include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/tasks/FixedSequenceSlot.h>
 #include <cstddef>
 
 FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
 		int8_t setSequenceId, PeriodicTaskIF* executingTask) :
-		handler(NULL), pollingTimeMs(setTime), opcode(setSequenceId) {
+		pollingTimeMs(setTime), opcode(setSequenceId) {
 	handler = objectManager->get<ExecutableObjectIF>(handlerId);
-	handler->setTaskIF(executingTask);
+	if(executingTask != nullptr) {
+	    handler->setTaskIF(executingTask);
+	}
 }
 
 FixedSequenceSlot::~FixedSequenceSlot() {}
diff --git a/devicehandlers/FixedSequenceSlot.h b/tasks/FixedSequenceSlot.h
similarity index 78%
rename from devicehandlers/FixedSequenceSlot.h
rename to tasks/FixedSequenceSlot.h
index 7868cce30..72a35c744 100644
--- a/devicehandlers/FixedSequenceSlot.h
+++ b/tasks/FixedSequenceSlot.h
@@ -1,22 +1,17 @@
-/**
- * @file	FixedSequenceSlot.h
- * @brief	This file defines the PollingSlot class.
- * @date	19.12.2012
- * @author	baetz
- */
-
-#ifndef FIXEDSEQUENCESLOT_H_
-#define FIXEDSEQUENCESLOT_H_
+#ifndef FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
+#define FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/tasks/ExecutableObjectIF.h>
 class PeriodicTaskIF;
 
 /**
- * @brief	This class is the representation of a single polling sequence table entry.
- *
- * @details	The PollingSlot class is the representation of a single polling
- * 			sequence table entry.
+ * @brief	This class is the representation of a single polling sequence
+ *          table entry.
+ * @details
+ * The PollingSlot class is the representation of a single polling
+ * sequence table entry.
+ * @author  baetz
  */
 class FixedSequenceSlot {
 public:
@@ -27,7 +22,7 @@ public:
 	/**
 	 * @brief	Handler identifies which device handler object is executed in this slot.
 	 */
-	ExecutableObjectIF*	handler;
+	ExecutableObjectIF*	handler = nullptr;
 
 	/**
 	 * @brief	This attribute defines when a device handler object is executed.
@@ -43,7 +38,7 @@ public:
 	 * @details	The state of this value decides what communication routine is
 	 * 			called in the PST executable or the device handler object.
 	 */
-	uint8_t			opcode;
+	uint8_t	opcode;
 
 	/**
 	 * @brief 	Operator overload for the comparison operator to
diff --git a/devicehandlers/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
similarity index 98%
rename from devicehandlers/FixedSlotSequence.cpp
rename to tasks/FixedSlotSequence.cpp
index aeb97f3a5..3e542bfce 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -1,5 +1,5 @@
-#include <framework/devicehandlers/FixedSlotSequence.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tasks/FixedSlotSequence.h>
 #include <cstdlib>
 
 FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
diff --git a/devicehandlers/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
similarity index 97%
rename from devicehandlers/FixedSlotSequence.h
rename to tasks/FixedSlotSequence.h
index 145cdbc30..7de1884c4 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -1,8 +1,8 @@
-#ifndef FIXEDSLOTSEQUENCE_H_
-#define FIXEDSLOTSEQUENCE_H_
+#ifndef FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
+#define FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
 
-#include <framework/devicehandlers/FixedSequenceSlot.h>
 #include <framework/objectmanager/SystemObject.h>
+#include <framework/tasks/FixedSequenceSlot.h>
 
 #include <set>
 
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index 7edd67519..023b5ee04 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -12,11 +12,18 @@ class FixedTimeslotTaskIF : public PeriodicTaskIF {
 public:
 	virtual ~FixedTimeslotTaskIF() {}
 
+	/**
+	 * Add an object with a slot time and the execution step to the task.
+	 * The execution step shall be passed to the object.
+	 * @param componentId
+	 * @param slotTimeMs
+	 * @param executionStep
+	 * @return
+	 */
 	virtual ReturnValue_t addSlot(object_id_t componentId,
 			uint32_t slotTimeMs, int8_t executionStep) = 0;
+	/** Check whether the sequence is valid */
 	virtual ReturnValue_t checkSequence() const = 0;
 };
 
-
-
 #endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
diff --git a/tasks/PeriodicTaskIF.h b/tasks/PeriodicTaskIF.h
index 304a7de60..6f4909771 100644
--- a/tasks/PeriodicTaskIF.h
+++ b/tasks/PeriodicTaskIF.h
@@ -1,9 +1,11 @@
-#ifndef PERIODICTASKIF_H_
-#define PERIODICTASKIF_H_
+#ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_
+#define FRAMEWORK_TASK_PERIODICTASKIF_H_
 
 #include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/timemanager/Clock.h>
 #include <cstddef>
 class ExecutableObjectIF;
+
 /**
  * New version of TaskIF
  * Follows RAII principles, i.e. there's no create or delete method.
@@ -17,11 +19,27 @@ public:
 	 */
 	virtual ~PeriodicTaskIF() { }
 	/**
-	 * @brief	With the startTask method, a created task can be started for the first time.
+	 * @brief	With the startTask method, a created task can be started
+	 *          for the first time.
 	 */
 	virtual ReturnValue_t startTask() = 0;
 
-	virtual ReturnValue_t addComponent(object_id_t object) {return HasReturnvaluesIF::RETURN_FAILED;};
+	/**
+	 * Add a component (object) to a periodic task. The pointer to the
+	 * task can be set optionally
+	 * @param object
+	 * Add an object to the task. The most important case is to add an
+	 * executable object with a function which will be called regularly
+	 * (see ExecutableObjectIF)
+	 * @param setTaskIF
+	 * Can be used to specify whether the task object pointer is passed
+	 * to the component.
+	 * @return
+	 */
+	virtual ReturnValue_t addComponent(object_id_t object,
+	        bool setTaskIF = true) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
 
 	virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
 

From 1b0e7c84c7ac2fff9e8b7129110271681c147620 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 20:15:58 +0200
Subject: [PATCH 0461/1774] linux periodic task improvements

---
 osal/linux/PeriodicPosixTask.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index ca7011b07..afdd3a52c 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -1,12 +1,13 @@
 #include <framework/tasks/ExecutableObjectIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <errno.h>
 #include <framework/osal/linux/PeriodicPosixTask.h>
 
+#include <errno.h>
+
 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() {

From 2c04b87418f2552f836775e4c3eaa1b14bcd033c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 20:18:00 +0200
Subject: [PATCH 0462/1774] corrected includes

---
 osal/linux/FixedTimeslotTask.h | 2 +-
 osal/rtems/PollingTask.cpp     | 2 +-
 osal/rtems/PollingTask.h       | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 916e6d6cc..409cd9821 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
 
 #include <framework/tasks/FixedTimeslotTaskIF.h>
-#include <framework/devicehandlers/FixedSlotSequence.h>
+#include <framework/tasks/FixedSlotSequence.h>
 #include <framework/osal/linux/PosixThread.h>
 #include <pthread.h>
 
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index 6b0c0fbd6..a6be7ddf4 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -1,4 +1,4 @@
-#include <framework/devicehandlers/FixedSequenceSlot.h>
+#include <framework/tasks/FixedSequenceSlot.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/osal/rtems/PollingTask.h>
 #include <framework/osal/rtems/RtemsBasic.h>
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 82ec65a2d..5bf8cf57e 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -1,7 +1,7 @@
 #ifndef POLLINGTASK_H_
 #define POLLINGTASK_H_
 
-#include <framework/devicehandlers/FixedSlotSequence.h>
+#include <framework/tasks/FixedSlotSequence.h>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include "TaskBase.h"
 

From 3936fe93609875c7f49332a8a5f24b09d67b7c1c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 20:34:19 +0200
Subject: [PATCH 0463/1774] linux fix

---
 osal/linux/PeriodicPosixTask.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index afdd3a52c..fe8ac19ce 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -22,7 +22,8 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
 	return NULL;
 }
 
-ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
+ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
+		bool setTaskIF) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {

From 95b646046b162d2c47e0a231ae8fad35cc733f21 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 20:43:29 +0200
Subject: [PATCH 0464/1774] debug output working again

---
 events/EventManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 539f9e275..1eb88c324 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -133,7 +133,7 @@ void EventManager::printEvent(EventMessage* message) {
 		break;
 	default:
 		string = translateObject(message->getReporter());
-		sif::error << "EVENT: ";
+		sif::error << "EventManager: ";
 		if (string != 0) {
 			sif::error << string;
 		} else {

From 45a55044ddd3ded4cac2522313f1db53ac62c1d4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 20:47:36 +0200
Subject: [PATCH 0465/1774] using debug stream now

---
 events/EventManager.cpp | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 1eb88c324..30f5ed718 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -133,20 +133,23 @@ void EventManager::printEvent(EventMessage* message) {
 		break;
 	default:
 		string = translateObject(message->getReporter());
-		sif::error << "EventManager: ";
+		sif::debug << "EventManager: ";
 		if (string != 0) {
-			sif::error << string;
-		} else {
-			sif::error << "0x" << std::hex << message->getReporter() << std::dec;
+			sif::debug << string;
 		}
-		sif::error << " reported " << translateEvents(message->getEvent()) << " ("
-				<< std::dec << message->getEventId() << ") " << std::endl;
-
-		sif::error << std::hex << "P1 Hex: 0x" << message->getParameter1() << ", P1 Dec: "
-		        << std::dec << message->getParameter1() << std::endl;
-		sif::error << std::hex << "P2 Hex: 0x" << message->getParameter2() << ", P2 Dec: "
-		        <<  std::dec << message->getParameter2() << std::endl;
+		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;
 	}
 

From 109fdad8b36ca1fe99f0ebad89fb28b04fa7d197 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 15:34:35 +0200
Subject: [PATCH 0466/1774] size check for message queue

---
 osal/FreeRTOS/MessageQueue.cpp | 11 +++++++++--
 osal/FreeRTOS/MessageQueue.h   |  1 +
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index d44b0bc0f..cf6130f83 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -7,7 +7,8 @@
 // As a first step towards this, introduces system context variable which needs
 // to be switched manually
 // Haven't found function to find system context.
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) {
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
+		maxMessageSize(maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
 	if (handle == NULL) {
 		sif::error << "MessageQueue: Creation failed" << std::endl;
@@ -120,10 +121,16 @@ bool MessageQueue::isDefaultDestinationSet() const {
 
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
+        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
         bool ignoreFault, CallContext callContext) {
     message->setSender(sentFrom);
     BaseType_t result;
+    if(message->getMaximumMessageSize() > maxMessageSize) {
+    	sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size"
+    			"too large for queue!" << std::endl;
+    	return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
     if(callContext == CallContext::TASK) {
         result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
                 static_cast<const void*>(message->getBuffer()), 0);
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index c13a8a200..b7e52bb39 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -204,6 +204,7 @@ private:
 	QueueHandle_t handle;
 	MessageQueueId_t defaultDestination = 0;
 	MessageQueueId_t lastPartner = 0;
+	const size_t maxMessageSize;
 	//!< Stores the current system context
 	CallContext callContext =  CallContext::TASK;
 };

From 3b2fa978e1b86ccf1b9c113ab958dcaf81e63b4a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 19:06:10 +0200
Subject: [PATCH 0467/1774] replaced break with continue

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index f3a65fcdd..5d16a4084 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -118,7 +118,7 @@ void FixedTimeslotTask::taskFunctionality() {
 	                this->deadlineMissedFunc();
 	            }
 	            // Continue immediately, no need to wait.
-	            break;
+	            continue;
 	        }
 
 	        // we need to wait before executing the current slot

From 5734a0a0e948df50c57f9d589a2eddac479bb70b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 19:22:52 +0200
Subject: [PATCH 0468/1774] some fixes necessary to perform size check

---
 action/ActionHelper.cpp               |  3 ++-
 datalinklayer/MapPacketExtraction.cpp |  3 ++-
 ipc/MessageQueueSenderIF.h            |  2 +-
 monitoring/LimitViolationReporter.cpp |  3 ++-
 osal/FreeRTOS/MessageQueue.cpp        |  8 ++++----
 osal/FreeRTOS/MessageQueue.h          |  5 +++--
 osal/FreeRTOS/QueueFactory.cpp        |  6 +++---
 tmtcservices/VerificationReporter.cpp | 12 ++++++++----
 8 files changed, 25 insertions(+), 17 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 0df5f2d4e..026df4e13 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -101,7 +101,8 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 
 	//TODO Service Implementation sucks at the moment
 	if (hideSender){
-		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+		result = MessageQueueSenderIF::sendMessage(reportTo, &reply,
+		        MessageQueueMessage::MAX_MESSAGE_SIZE);
 	} else {
 		result = queueToUse->sendMessage(reportTo, &reply);
 	}
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 4ea45e89c..87b465567 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -117,7 +117,8 @@ ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data,
 	ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
 	if (status == RETURN_OK) {
 		TmTcMessage message(store_id);
-		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message);
+		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message,
+		        MessageQueueMessage::MAX_MESSAGE_SIZE);
 	}
 	return status;
 }
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 3172454f4..912f4d7e4 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -15,7 +15,7 @@ public:
 	 * Must be implemented by a subclass.
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message,
+			MessageQueueMessageIF* message, size_t maxMessageSize,
 			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
 			bool ignoreFault=false);
 private:
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 1378d7549..c6e2b5dba 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -34,7 +34,8 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	MessageQueueMessage message;
 	CommandMessage report(&message);
 	MonitoringMessage::setLimitViolationReport(&report, storeId);
-	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
+	return MessageQueueSenderIF::sendMessage(reportQueue, &report,
+	        MessageQueueMessage::MAX_MESSAGE_SIZE);
 }
 
 ReturnValue_t LimitViolationReporter::checkClassLoaded() {
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index cf6130f83..0280869d7 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -50,7 +50,7 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
+	return sendMessageFromMessageQueue(sendTo, message, maxMessageSize, sentFrom,
 			ignoreFault, callContext);
 }
 
@@ -121,11 +121,11 @@ bool MessageQueue::isDefaultDestinationSet() const {
 
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-        bool ignoreFault, CallContext callContext) {
+        MessageQueueMessageIF* message, size_t maxSize,
+        MessageQueueId_t sentFrom, bool ignoreFault, CallContext callContext) {
     message->setSender(sentFrom);
     BaseType_t result;
-    if(message->getMaximumMessageSize() > maxMessageSize) {
+    if(message->getMaximumMessageSize() > maxSize) {
     	sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size"
     			"too large for queue!" << std::endl;
     	return HasReturnvaluesIF::RETURN_FAILED;
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index b7e52bb39..e87e884f6 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -194,8 +194,9 @@ protected:
 	 * @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, CallContext callContext = CallContext::TASK);
+			MessageQueueMessageIF* message, size_t maxSize,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault=false,
+			CallContext callContext = CallContext::TASK);
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index beb4969bd..ec6788909 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -7,9 +7,9 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault) {
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			MessageQueueMessageIF* message, size_t maxSize,
+			MessageQueueId_t sentFrom, bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message, maxSize,
 			sentFrom,ignoreFault);
 }
 
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index b02479449..a54c1f8d4 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -22,7 +22,8 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 			current_packet->getAcknowledgeFlags(),
 			current_packet->getPacketId(),
 			current_packet->getPacketSequenceControl(), 0, set_step);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue, &message);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
@@ -37,7 +38,8 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	}
 	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
 			tcSequenceControl, 0, set_step);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue, &message);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
@@ -55,7 +57,8 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 			current_packet->getPacketId(),
 			current_packet->getPacketSequenceControl(), error_code, step,
 			parameter1, parameter2);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue, &message);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error
 				<< "VerificationReporter::sendFailureReport Error writing to queue. Code: "
@@ -72,7 +75,8 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	}
 	PusVerificationMessage message(report_id, ackFlags, tcPacketId,
 			tcSequenceControl, error_code, step, parameter1, parameter2);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue, &message);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error
 				<< "VerificationReporter::sendFailureReport Error writing to queue. Code: "

From dadc867d9ed44d82782d2f3f66cc0f54b50bfe00 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 20:18:13 +0200
Subject: [PATCH 0469/1774] adapted MessageQueueSenderIF function calls

---
 events/EventManager.cpp             |  3 ++-
 events/EventManagerIF.h             |  3 ++-
 health/HealthHelper.cpp             |  6 ++++--
 modes/ModeHelper.cpp                | 11 +++++++----
 osal/FreeRTOS/FixedTimeslotTask.cpp | 16 +++++++---------
 osal/FreeRTOS/MessageQueue.cpp      | 12 ++++++++++--
 osal/FreeRTOS/QueueFactory.cpp      |  5 +++++
 parameters/ParameterHelper.cpp      |  6 ++++--
 tmtcpacket/pus/TmPacketStored.cpp   |  3 ++-
 9 files changed, 43 insertions(+), 22 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 30f5ed718..a5d145698 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -52,7 +52,8 @@ void EventManager::notifyListeners(EventMessage* message) {
 	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
 		if (iter->second.match(message)) {
 			MessageQueueSenderIF::sendMessage(iter->first, message,
-					message->getSender());
+			        MessageQueueMessage::MAX_MESSAGE_SIZE,
+			        message->getSender());
 		}
 	}
 	unlockMutex();
diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h
index bc0de4329..053e320b0 100644
--- a/events/EventManagerIF.h
+++ b/events/EventManagerIF.h
@@ -44,7 +44,8 @@ public:
 				eventmanagerQueue = eventmanager->getEventReportQueue();
 			}
 		}
-		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
+		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message,
+		        MessageQueueMessage::MAX_MESSAGE_SIZE, sentFrom);
 	}
 
 };
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index df259b529..935bf5e3f 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -70,7 +70,8 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
 			health, oldHealth);
 	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
-			owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+	        MessageQueueMessage::MAX_MESSAGE_SIZE,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
 		sif::debug << "HealthHelper::informParent: sending health reply failed."
 				<< std::endl;
 	}
@@ -90,7 +91,8 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
 		reply.setReplyRejected(result, command->getCommand());
 	}
 	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-			owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+	        MessageQueueMessage::MAX_MESSAGE_SIZE,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
 		sif::debug << "HealthHelper::handleHealthCommand: sending health "
 		        "reply failed." << std::endl;
 
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index b79082afc..f636c0bf3 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -28,7 +28,8 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			ModeMessage::cantReachMode(&reply, result);
 			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-					owner->getCommandQueue());
+			        MessageQueueMessage::MAX_MESSAGE_SIZE,
+			        owner->getCommandQueue());
 			break;
 		}
 		//Free to start transition
@@ -50,7 +51,8 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
 				submode);
 		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-				owner->getCommandQueue());
+		        MessageQueueMessage::MAX_MESSAGE_SIZE,
+		       owner->getCommandQueue());
 	}
 		break;
 	case ModeMessage::CMD_MODE_ANNOUNCE:
@@ -95,7 +97,7 @@ void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 					ownerMode, ownerSubmode);
 		}
 		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
-				owner->getCommandQueue());
+		        MessageQueueMessage::MAX_MESSAGE_SIZE, owner->getCommandQueue());
 	}
 }
 
@@ -109,7 +111,8 @@ void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
 				ownerMode, ownerSubmode);
 		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
-				owner->getCommandQueue());
+		        MessageQueueMessage::MAX_MESSAGE_SIZE,
+		        owner->getCommandQueue());
 	}
 }
 
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 5d16a4084..4d4ec9969 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -105,11 +105,14 @@ void FixedTimeslotTask::taskFunctionality() {
 		//The component for this slot is executed and the next one is chosen.
 	    this->pst.executeAndAdvance();
 	    if (not pst.slotFollowsImmediately()) {
+	        // Get the interval till execution of the next slot.
+	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
+	        interval = pdMS_TO_TICKS(intervalMs);
+
 	        /* If all operations are finished and the difference of the
 	         * current time minus the last wake time is larger than the
 	         * expected wait period, a deadline was missed. */
-	        if(xTaskGetTickCount() - xLastWakeTime >=
-	                pdMS_TO_TICKS(this->pst.getIntervalToPreviousSlotMs())) {
+	        if(xTaskGetTickCount() - xLastWakeTime >= interval) {
 #ifdef DEBUG
 	            sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
 	                    " missed deadline!\n" << std::flush;
@@ -117,14 +120,9 @@ void FixedTimeslotTask::taskFunctionality() {
 	            if(deadlineMissedFunc != nullptr) {
 	                this->deadlineMissedFunc();
 	            }
-	            // Continue immediately, no need to wait.
-	            continue;
 	        }
-
-	        // we need to wait before executing the current slot
-	        //this gives us the time to wait:
-	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
-	        interval = pdMS_TO_TICKS(intervalMs);
+	        // Wait for the interval. This exits immediately if a deadline was
+	        // missed while also updating the last wake time.
 	        vTaskDelayUntil(&xLastWakeTime, interval);
 	    }
 	}
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 0280869d7..c9adf229d 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -80,6 +80,12 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+    if(message->getMaximumMessageSize() < maxMessageSize) {
+        sif::error << "MessageQueue::receiveMessage: Message size "
+                << message->getMaximumMessageSize() <<
+                " too small to receive data!" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
 			message->getBuffer()), 0);
 	if (result == pdPASS){
@@ -126,8 +132,10 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     message->setSender(sentFrom);
     BaseType_t result;
     if(message->getMaximumMessageSize() > maxSize) {
-    	sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size"
-    			"too large for queue!" << std::endl;
+    	sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size "
+    			 << message->getMaximumMessageSize() << " too large for queue"
+    			  " with max. message size " << maxSize << "!"
+    			 << std::endl;
     	return HasReturnvaluesIF::RETURN_FAILED;
     }
 
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index ec6788909..d754b2b9d 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -9,6 +9,11 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message, size_t maxSize,
 			MessageQueueId_t sentFrom, bool ignoreFault) {
+    if(maxSize == 0) {
+        sif::error << "MessageQueueSenderIF::sendMessage: Max Size is 0!"
+                << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message, maxSize,
 			sentFrom,ignoreFault);
 }
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 8b91020f9..68ff5ab05 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -107,7 +107,8 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 
 	ParameterMessage::setParameterDumpReply(&reply, id, address);
 
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+	MessageQueueSenderIF::sendMessage(to, &reply,
+	        MessageQueueMessage::MAX_MESSAGE_SIZE, ownerQueueId);
 
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -129,5 +130,6 @@ void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
 	MessageQueueMessage message;
 	CommandMessage reply(&message);
 	reply.setReplyRejected(reason, initialCommand);
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+	MessageQueueSenderIF::sendMessage(to, &reply,
+	        MessageQueueMessage::MAX_MESSAGE_SIZE, ownerQueueId);
 }
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 42d0d0387..d589db8db 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -117,7 +117,8 @@ ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	TmTcMessage tmMessage(getStoreAddress());
-	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination, &tmMessage, sentFrom);
+	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
+	        &tmMessage, MessageQueueMessage::MAX_MESSAGE_SIZE, sentFrom);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		deletePacket();
 		if (doErrorReporting) {

From 6a7f47e06d95c91f8f9885c38f0716894735a10a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 23:46:44 +0200
Subject: [PATCH 0470/1774] doc fix

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 56 ++++++++++++++++++++---------
 osal/FreeRTOS/FixedTimeslotTask.h   |  6 +++-
 2 files changed, 45 insertions(+), 17 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 4d4ec9969..57c927f98 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -82,7 +82,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.
-	SlotListIter slotListIter = pst.current;
+	auto slotListIter = pst.current;
 
 	//The start time for the first entry is read.
 	uint32_t intervalMs = slotListIter->pollingTimeMs;
@@ -90,9 +90,9 @@ void FixedTimeslotTask::taskFunctionality() {
 
 	TickType_t xLastWakeTime;
 	/* 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 internally within
-	 vTaskDelayUntil(). */
+	 count. Note that this is the only time the variable is written to
+	 explicitly. After this assignment, xLastWakeTime is updated automatically
+	 internally within vTaskDelayUntil(). */
 	xLastWakeTime = xTaskGetTickCount();
 
 	// wait for first entry's start time
@@ -109,18 +109,8 @@ void FixedTimeslotTask::taskFunctionality() {
 	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
 	        interval = pdMS_TO_TICKS(intervalMs);
 
-	        /* If all operations are finished and the difference of the
-	         * current time minus the last wake time is larger than the
-	         * expected wait period, a deadline was missed. */
-	        if(xTaskGetTickCount() - xLastWakeTime >= interval) {
-#ifdef DEBUG
-	            sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
-	                    " missed deadline!\n" << std::flush;
-#endif
-	            if(deadlineMissedFunc != nullptr) {
-	                this->deadlineMissedFunc();
-	            }
-	        }
+	        checkMissedDeadline(xLastWakeTime, interval);
+
 	        // Wait for the interval. This exits immediately if a deadline was
 	        // missed while also updating the last wake time.
 	        vTaskDelayUntil(&xLastWakeTime, interval);
@@ -128,6 +118,40 @@ void FixedTimeslotTask::taskFunctionality() {
 	}
 }
 
+void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Tick count has overflown
+    if(currentTickCount < xLastWakeTime) {
+        // Time to wake has overflown as well. If the tick count
+        // is larger than the time to wake, a deadline was missed.
+        if(timeToWake < xLastWakeTime and
+                currentTickCount > timeToWake) {
+            handleMissedDeadline();
+        }
+    }
+    // No tick count overflow. If the timeToWake has not overflown
+    // and the current tick count is larger than the time to wake,
+    // a deadline was missed.
+    else if(timeToWake > xLastWakeTime and currentTickCount > timeToWake) {
+        handleMissedDeadline();
+    }
+}
+
+void FixedTimeslotTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
+
 ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	vTaskDelay(pdMS_TO_TICKS(ms));
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 183fad20c..32289f4be 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -12,7 +12,7 @@ class FixedTimeslotTask: public FixedTimeslotTaskIF {
 public:
 
 	/**
-	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * Keep in Mind that you need to call before vTaskStartScheduler()!
 	 * A lot of task parameters are set in "FreeRTOSConfig.h".
 	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
 	 * @param setPriority Number of priorities specified by
@@ -89,6 +89,10 @@ protected:
 	 * OS's System Calls to keep the timing of the periods.
 	 */
 	void taskFunctionality(void);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
 };
 
 #endif /* POLLINGTASK_H_ */

From a82dbcbd501a6c035430f8394d5eaebe06480918 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 23:47:18 +0200
Subject: [PATCH 0471/1774] minor doc correction

---
 osal/FreeRTOS/FixedTimeslotTask.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 32289f4be..27d081909 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -12,7 +12,7 @@ class FixedTimeslotTask: public FixedTimeslotTaskIF {
 public:
 
 	/**
-	 * Keep in Mind that you need to call before vTaskStartScheduler()!
+	 * Keep in mind that you need to call before vTaskStartScheduler()!
 	 * A lot of task parameters are set in "FreeRTOSConfig.h".
 	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
 	 * @param setPriority Number of priorities specified by

From 847292ea30e3c71678b0cf994e6436caad71a463 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 01:10:19 +0200
Subject: [PATCH 0472/1774] added overflow checking for periodic task

---
 osal/FreeRTOS/PeriodicTask.cpp | 47 +++++++++++++++++++++++++---------
 osal/FreeRTOS/PeriodicTask.h   |  4 +++
 2 files changed, 39 insertions(+), 12 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 43928f7c2..fa49150ec 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -74,18 +74,7 @@ void PeriodicTask::taskFunctionality() {
 			object->performOperation();
 		}
 
-		/* If all operations are finished and the difference of the
-		 * current time minus the last wake time is larger than the
-		 * wait period, a deadline was missed. */
-		if(xTaskGetTickCount() - xLastWakeTime >= xPeriod) {
-#ifdef DEBUG
-			sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
-					" missed deadline!\n" << std::flush;
-#endif
-			if(deadlineMissedFunc != nullptr) {
-				this->deadlineMissedFunc();
-			}
-		}
+		checkMissedDeadline(xLastWakeTime, xPeriod);
 
 		vTaskDelayUntil(&xLastWakeTime, xPeriod);
 
@@ -110,3 +99,37 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
 uint32_t PeriodicTask::getPeriodMs() const {
 	return period * 1000;
 }
+
+void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Tick count has overflown
+    if(currentTickCount < xLastWakeTime) {
+        // Time to wake has overflown as well. If the tick count
+        // is larger than the time to wake, a deadline was missed.
+        if(timeToWake < xLastWakeTime and
+                currentTickCount > timeToWake) {
+            handleMissedDeadline();
+        }
+    }
+    // No tick count overflow. If the timeToWake has not overflown
+    // and the current tick count is larger than the time to wake,
+    // a deadline was missed.
+    else if(timeToWake > xLastWakeTime and currentTickCount > timeToWake) {
+        handleMissedDeadline();
+    }
+}
+
+void PeriodicTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index a580f519f..09aa6bc7d 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -116,6 +116,10 @@ protected:
 	 * On missing the deadline, the deadlineMissedFunction is executed.
 	 */
 	void taskFunctionality(void);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
 };
 
 #endif /* PERIODICTASK_H_ */

From f7d55a8a37559bf9717b49e414c19db99c5113e9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 01:15:35 +0200
Subject: [PATCH 0473/1774] equal to pull request now

---
 osal/FreeRTOS/PeriodicTask.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index fa49150ec..170eb0a48 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -89,10 +89,11 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
 	            "it implement ExecutableObjectIF" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	if(setTaskIF) {
-	    newObject->setTaskIF(this);
-	}
 	objectList.push_back(newObject);
+
+	if(setTaskIF) {
+	     newObject->setTaskIF(this);
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 

From 64a02c55ba9c0f067e64b460b66750b613a31526 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 01:37:25 +0200
Subject: [PATCH 0474/1774] linux fixed, size checks added

---
 osal/linux/MessageQueue.cpp      | 50 +++++++++++++++++++++++++-------
 osal/linux/MessageQueue.h        |  6 ++--
 osal/linux/PeriodicPosixTask.cpp | 14 +++++----
 osal/linux/PeriodicPosixTask.h   |  6 ++--
 osal/linux/QueueFactory.cpp      |  6 ++--
 5 files changed, 58 insertions(+), 24 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 605dea2af..c4b24a135 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -11,7 +11,8 @@
 
 MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
 		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
-		defaultDestination(MessageQueueIF::NO_QUEUE) {
+		defaultDestination(MessageQueueIF::NO_QUEUE),
+		maxMessageSize(maxMessageSize) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
 	this->id = 0;
@@ -142,6 +143,19 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::receiveMessage: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(message->getMaximumMessageSize() < maxMessageSize) {
+	        sif::error << "MessageQueue::receiveMessage: Message size "
+	                << message->getMaximumMessageSize() <<
+	                " too small to receive data!" << std::endl;
+	        return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	unsigned int messagePriority = 0;
 	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
 			message->getMaximumMessageSize(),&messagePriority);
@@ -258,18 +272,20 @@ void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
 	this->defaultDestination = defaultDestination;
 }
 
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
-
-}
-
 ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 		MessageQueueId_t sentFrom, bool ignoreFault) {
 	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
 }
 
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo,message, maxMessageSize,
+			sentFrom,ignoreFault);
+
+}
+
 MessageQueueId_t MessageQueue::getDefaultDestination() const {
 	return this->defaultDestination;
 }
@@ -281,8 +297,22 @@ bool MessageQueue::isDefaultDestinationSet() const {
 uint16_t MessageQueue::queueCounter = 0;
 
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
+		MessageQueueMessageIF *message, size_t maxSize,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(message->getMaximumMessageSize() > maxSize) {
+		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size "
+				<< message->getMaximumMessageSize() << " too large for queue"
+				" with max. message size " << maxSize << "!"
+				<< std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	message->setSender(sentFrom);
 	int result = mq_send(sendTo,
 			reinterpret_cast<const char*>(message->getBuffer()),
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index 91066bf76..22725d185 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -149,7 +149,8 @@ protected:
 	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			MessageQueueMessageIF* message, size_t maxSize,
+			MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault=false);
 private:
 	/**
@@ -176,9 +177,10 @@ private:
 	/**
 	 * The name of the message queue, stored for unlinking
 	 */
-	char name[5];
+	char name[16];
 
 	static uint16_t queueCounter;
+	const size_t maxMessageSize;
 
 	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
 };
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index fe8ac19ce..db4005b04 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -31,10 +31,11 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
 	            "it implements ExecutableObjectIF" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	objectList.push_back(newObject);
+
 	if(setTaskIF) {
 	    newObject->setTaskIF(this);
 	}
-	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -43,14 +44,14 @@ 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){
+void PeriodicPosixTask::taskFunctionality(void) {
 	if(!started){
 		suspend();
 	}
@@ -64,14 +65,15 @@ void PeriodicPosixTask::taskFunctionality(void){
 		if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
-			if(status==0){
+			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();
 			}
 		}
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 1d62a5659..9b477e36d 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/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(void) override;
 	/**
 	 * Adds an object to the list of objects to be executed.
 	 * The objects are executed in the order added.
@@ -42,9 +42,9 @@ public:
 	ReturnValue_t addComponent(object_id_t object,
 	        bool setTaskIF = true) override;
 
-	uint32_t getPeriodMs() const;
+	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t sleepFor(uint32_t ms);
+	ReturnValue_t sleepFor(uint32_t ms) override;
 
 private:
 	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index 8bd9d52c5..95264a429 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -9,10 +9,10 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault) {
+			MessageQueueMessageIF* message, size_t maxSize,
+			MessageQueueId_t sentFrom, bool ignoreFault) {
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
-			sentFrom,ignoreFault);
+			maxSize, sentFrom,ignoreFault);
 }
 
 QueueFactory* QueueFactory::instance() {

From c0beef44630f991e7307727bbcca6adc81bb48a0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 10:27:44 +0200
Subject: [PATCH 0475/1774] some include guards, todo comments

---
 devicehandlers/DeviceHandlerFailureIsolation.cpp | 2 +-
 devicehandlers/DeviceHandlerFailureIsolation.h   | 1 +
 fdir/ConfirmsFailuresIF.h                        | 1 +
 fdir/FailureIsolationBase.cpp                    | 3 ++-
 health/HealthTable.h                             | 4 ++--
 health/HealthTableIF.h                           | 8 +++++---
 ipc/MessageQueueSenderIF.h                       | 1 -
 returnvalues/HasReturnvaluesIF.h                 | 4 ++--
 8 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 1df2afa0e..46e73cd8c 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -137,7 +137,7 @@ void DeviceHandlerFailureIsolation::decrementFaultCounters() {
 
 void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
 	clearFaultCounters();
-	if (!recoveryCounter.incrementAndCheck()) {
+	if (not recoveryCounter.incrementAndCheck()) {
 		startRecovery(reason);
 	} else {
 		setFaulty(reason);
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.h b/devicehandlers/DeviceHandlerFailureIsolation.h
index 379edae31..4343d88bd 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.h
+++ b/devicehandlers/DeviceHandlerFailureIsolation.h
@@ -31,6 +31,7 @@ protected:
 	bool hasPowerConfirmation = false;
 	MessageQueueId_t powerConfirmation;
 	static object_id_t powerConfirmationId;
+	// TODO: Are those hardcoded value? How can they be changed.
 	static const uint32_t MAX_REBOOT = 1;
 	static const uint32_t REBOOT_TIME_MS = 180000;
 	static const uint32_t MAX_STRANGE_REPLIES = 10;
diff --git a/fdir/ConfirmsFailuresIF.h b/fdir/ConfirmsFailuresIF.h
index 99cd212a8..460749ee5 100644
--- a/fdir/ConfirmsFailuresIF.h
+++ b/fdir/ConfirmsFailuresIF.h
@@ -4,6 +4,7 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
 
+// TODO: Documentation.
 class ConfirmsFailuresIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::HANDLES_FAILURES_IF;
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index 461144676..018fbe6a4 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -9,7 +9,8 @@ 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);
+	eventQueue = QueueFactory::instance()->createMessageQueue(messageDepth,
+			EventMessage::EVENT_MESSAGE_SIZE);
 }
 
 FailureIsolationBase::~FailureIsolationBase() {
diff --git a/health/HealthTable.h b/health/HealthTable.h
index 32a7eee2f..194ad259a 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -1,5 +1,5 @@
-#ifndef HEALTHTABLE_H_
-#define HEALTHTABLE_H_
+#ifndef FRAMEWORK_HEALTH_HEALTHTABLE_H_
+#define FRAMEWORK_HEALTH_HEALTHTABLE_H_
 
 #include <framework/health/HealthTableIF.h>
 #include <framework/objectmanager/SystemObject.h>
diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h
index 6fdfc2c04..c8d2c74a6 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -1,5 +1,5 @@
-#ifndef HEALTHTABLEIF_H_
-#define HEALTHTABLEIF_H_
+#ifndef FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
+#define FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
 
 #include <framework/health/ManagesHealthIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
@@ -8,6 +8,8 @@
 
 
 class HealthTableIF: public ManagesHealthIF {
+	// TODO: This is in the mission folder and not in the framework folder.
+	// delete it?
 	friend class HealthCommandingService;
 public:
 	virtual ~HealthTableIF() {
@@ -23,4 +25,4 @@ protected:
 	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
 };
 
-#endif /* HEALTHTABLEIF_H_ */
+#endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 912f4d7e4..8bc149485 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -12,7 +12,6 @@ public:
 	/**
 	 * Allows sending messages without actually "owing" a message queue.
 	 * Not sure whether this is actually a good idea.
-	 * Must be implemented by a subclass.
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message, size_t maxMessageSize,
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 9bbaf6010..b51dfc828 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -1,5 +1,5 @@
-#ifndef HASRETURNVALUESIF_H_
-#define HASRETURNVALUESIF_H_
+#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
 
 #include <framework/returnvalues/FwClassIds.h>
 #include <config/returnvalues/classIds.h>

From e27310da40a420e78cc894746301d318da632bc9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 10:47:31 +0200
Subject: [PATCH 0476/1774] updates for tmtcbridge

---
 tmtcservices/TmTcBridge.cpp | 17 +++++------------
 tmtcservices/TmTcBridge.h   | 11 ++++++-----
 2 files changed, 11 insertions(+), 17 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index c5eaf78b5..f9a7d3bc5 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -3,6 +3,7 @@
 #include <framework/ipc/QueueFactory.h>
 #include <framework/tmtcservices/AcceptsTelecommandsIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/globalfunctions/arrayprinter.h>
 
 TmTcBridge::TmTcBridge(object_id_t objectId_,
         object_id_t ccsdsPacketDistributor_): SystemObject(objectId_),
@@ -85,7 +86,7 @@ ReturnValue_t TmTcBridge::handleTm() {
 		return RETURN_FAILED;
 	}
 
-	if(tmStored && communicationLinkUp) {
+	if(tmStored and communicationLinkUp) {
 		result = handleStoredTm();
 	}
 	return result;
@@ -141,11 +142,11 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 ReturnValue_t TmTcBridge::handleStoredTm() {
 	uint8_t counter = 0;
 	ReturnValue_t result = RETURN_OK;
-	while(not tmFifo.empty() && counter < sentPacketsPerCycle) {
+	while(not tmFifo.empty() and counter < sentPacketsPerCycle) {
 		//info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
-		const uint8_t* data = NULL;
+		const uint8_t* data = nullptr;
 		size_t size = 0;
 		tmFifo.retrieve(&storeId);
 		result = tmStore->getData(storeId, &data, &size);
@@ -186,14 +187,6 @@ MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
 }
 
 
-
 void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
-	sif::info << "TMTC Bridge: Printing data: [";
-	for(uint32_t i = 0; i < dataLen; i++) {
-		sif::info << std::hex << (int)data[i];
-		if(i < dataLen-1){
-			sif::info << " , ";
-		}
-	}
-	sif::info << " ] " << std::endl;
+	arrayprinter::print(data, dataLen);
 }
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 0a1fcfaba..3e0432d8a 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -43,26 +43,27 @@ public:
 	 */
 	ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
 
-	void registerCommConnect();
-	void registerCommDisconnect();
+	virtual void registerCommConnect();
+	virtual void registerCommDisconnect();
 
 	/**
 	 * Initializes necessary FSFW components for the TMTC Bridge
 	 * @return
 	 */
-	ReturnValue_t initialize() override;
+	virtual ReturnValue_t initialize() override;
 
 	/**
 	 * @brief	Handles TMTC reception
 	 */
-	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 
 	/**
 	 * Return TMTC Reception Queue
 	 * @param virtualChannel
 	 * @return
 	 */
-	MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) override;
+	MessageQueueId_t getReportReceptionQueue(
+			uint8_t virtualChannel = 0) override;
 protected:
 	//! Used to send and receive TMTC messages.
 	//! TmTcMessage is used to transport messages between tasks.

From 45ffb7549aa0654f1423ef5cd8dd0f012ab0537a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 10:58:48 +0200
Subject: [PATCH 0477/1774] storage accessor const in own file now

---
 storagemanager/ConstStorageAccessor.cpp |  93 +++++++++++++++++++
 storagemanager/ConstStorageAccessor.h   | 116 ++++++++++++++++++++++++
 storagemanager/StorageAccessor.cpp      |  98 +-------------------
 storagemanager/StorageAccessor.h        | 109 +---------------------
 4 files changed, 215 insertions(+), 201 deletions(-)
 create mode 100644 storagemanager/ConstStorageAccessor.cpp
 create mode 100644 storagemanager/ConstStorageAccessor.h

diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
new file mode 100644
index 000000000..be3188c1d
--- /dev/null
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -0,0 +1,93 @@
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/storagemanager/ConstStorageAccessor.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
+		storeId(storeId) {}
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		storeId(storeId), store(store) {
+	internalState = AccessState::ASSIGNED;
+}
+
+ConstStorageAccessor::~ConstStorageAccessor() {
+	if(deleteData and store != nullptr) {
+		sif::debug << "deleting store data" << std::endl;
+		store->deleteData(storeId);
+	}
+}
+
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
+ConstStorageAccessor& ConstStorageAccessor::operator=(
+		ConstStorageAccessor&& other) {
+	constDataPointer = other.constDataPointer;
+	storeId = other.storeId;
+	store = other.store;
+	size_ = other.size_;
+	deleteData = other.deleteData;
+	this->store = other.store;
+	// This prevents premature deletion
+	other.store = nullptr;
+	return *this;
+}
+
+const uint8_t* ConstStorageAccessor::data() const {
+	return constDataPointer;
+}
+
+size_t ConstStorageAccessor::size() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return size_;
+}
+
+ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
+		size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(constDataPointer, constDataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ConstStorageAccessor::release() {
+	deleteData = false;
+}
+
+store_address_t ConstStorageAccessor::getId() const {
+	return storeId;
+}
+
+void ConstStorageAccessor::print() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	sif::info << "StorageAccessor: Printing data: [";
+	for(uint16_t iPool = 0; iPool < size_; iPool++) {
+		sif::info << std::hex << (int)constDataPointer[iPool];
+		if(iPool < size_ - 1){
+			sif::info << " , ";
+		}
+	}
+	sif::info << " ] " << std::endl;
+}
+
+void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+	internalState = AccessState::ASSIGNED;
+	this->store = store;
+}
diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
new file mode 100644
index 000000000..cf8ca08fe
--- /dev/null
+++ b/storagemanager/ConstStorageAccessor.h
@@ -0,0 +1,116 @@
+#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+
+#include <framework/storagemanager/storeAddress.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
+
+class StorageManagerIF;
+
+/**
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details
+ * Accessor class which can be returned by pool manager or passed and set by
+ * pool managers to have safe access to the pool resources.
+ *
+ * These helper can be used together with the StorageManager classes to manage
+ * access to a storage. It can take care of thread-safety while also providing
+ * mechanisms to automatically clear storage data.
+ */
+class ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	/**
+	 * @brief	Simple constructor which takes the store ID of the storage
+	 * 			entry to access.
+	 * @param storeId
+	 */
+	ConstStorageAccessor(store_address_t storeId);
+	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
+	/**
+	 * @brief 	The destructor in default configuration takes care of
+	 * 			deleting the accessed pool entry and unlocking the mutex
+	 */
+	virtual ~ConstStorageAccessor();
+
+	/**
+	 * @brief	Returns a pointer to the read-only data
+	 * @return
+	 */
+	const uint8_t* data() const;
+
+	/**
+	 * @brief	Copies the read-only data to the supplied pointer
+	 * @param pointer
+	 */
+	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
+
+	/**
+	 * @brief   Calling this will prevent the Accessor from deleting the data
+	 *          when the destructor is called.
+	 */
+	void release();
+
+	/**
+	 * Get the size of the data
+	 * @return
+	 */
+	size_t size() const;
+
+	/**
+	 * Get the storage ID.
+	 * @return
+	 */
+	store_address_t getId() const;
+
+	void print() const;
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+	ConstStorageAccessor (ConstStorageAccessor&&);
+
+	//! The copy ctor and copy assignemnt should be deleted implicitely
+	//! according to https://foonathan.net/2019/02/special-member-functions/
+	//! but I still deleted them to make it more explicit. (remember rule of 5).
+	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+protected:
+	const uint8_t* constDataPointer = nullptr;
+	store_address_t storeId;
+	size_t size_ = 0;
+	//! Managing pool, has to assign itself.
+	StorageManagerIF* store = nullptr;
+	bool deleteData = true;
+
+	enum class AccessState {
+		UNINIT,
+		ASSIGNED
+	};
+	//! Internal state for safety reasons.
+	AccessState internalState = AccessState::UNINIT;
+	/**
+	 * Used by the pool manager instances to assign themselves to the
+	 * accessor. This is necessary to delete the data when the acessor
+	 * exits the scope ! The internal state will be considered read
+	 * when this function is called, so take care all data is set properly as
+	 * well.
+	 * @param
+	 */
+	void assignStore(StorageManagerIF*);
+};
+
+
+#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index c0c8126b7..b827b9c06 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,96 +1,6 @@
 #include <framework/storagemanager/StorageAccessor.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
-		storeId(storeId) {}
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
-		StorageManagerIF* store):
-		storeId(storeId), store(store) {
-	internalState = AccessState::ASSIGNED;
-}
-
-ConstStorageAccessor::~ConstStorageAccessor() {
-	if(deleteData and store != nullptr) {
-		sif::debug << "deleting store data" << std::endl;
-		store->deleteData(storeId);
-	}
-}
-
-ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
-		constDataPointer(other.constDataPointer), storeId(other.storeId),
-		size_(other.size_), store(other.store), deleteData(other.deleteData),
-		internalState(other.internalState) {
-	// This prevent premature deletion
-	other.store = nullptr;
-}
-
-ConstStorageAccessor& ConstStorageAccessor::operator=(
-		ConstStorageAccessor&& other) {
-	constDataPointer = other.constDataPointer;
-	storeId = other.storeId;
-	store = other.store;
-	size_ = other.size_;
-	deleteData = other.deleteData;
-	this->store = other.store;
-	// This prevents premature deletion
-	other.store = nullptr;
-	return *this;
-}
-
-const uint8_t* ConstStorageAccessor::data() const {
-	return constDataPointer;
-}
-
-size_t ConstStorageAccessor::size() const {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return size_;
-}
-
-ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
-		size_t maxSize) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(constDataPointer, constDataPointer + size_, pointer);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void ConstStorageAccessor::release() {
-	deleteData = false;
-}
-
-store_address_t ConstStorageAccessor::getId() const {
-	return storeId;
-}
-
-void ConstStorageAccessor::print() const {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return;
-	}
-	sif::info << "StorageAccessor: Printing data: [";
-	for(uint16_t iPool = 0; iPool < size_; iPool++) {
-		sif::info << std::hex << (int)constDataPointer[iPool];
-		if(iPool < size_ - 1){
-			sif::info << " , ";
-		}
-	}
-	sif::info << " ] " << std::endl;
-}
-
-void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
-	internalState = AccessState::ASSIGNED;
-	this->store = store;
-}
-
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 StorageAccessor::StorageAccessor(store_address_t storeId):
 		ConstStorageAccessor(storeId) {
@@ -120,7 +30,8 @@ ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		sif::error << "StorageAccessor: Supplied buffer not large "
+				"enough" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(dataPointer, dataPointer + size_, pointer);
@@ -141,7 +52,8 @@ ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(offset + size > size_) {
-		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
+		sif::error << "StorageAccessor: Data too large for pool "
+				"entry!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(data, data + size, dataPointer + offset);
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 069479746..c5e383065 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,117 +1,10 @@
 #ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
 #define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
 
-#include <framework/ipc/MutexHelper.h>
-#include <framework/storagemanager/storeAddress.h>
+#include <framework/storagemanager/ConstStorageAccessor.h>
 
 class StorageManagerIF;
 
-/**
- * @brief 	Helper classes to facilitate safe access to storages which is also
- * 			conforming to RAII principles
- * @details
- * Accessor class which can be returned by pool manager or passed and set by
- * pool managers to have safe access to the pool resources.
- *
- * These helper can be used together with the StorageManager classes to manage
- * access to a storage. It can take care of thread-safety while also providing
- * mechanisms to automatically clear storage data.
- */
-class ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	/**
-	 * @brief	Simple constructor which takes the store ID of the storage
-	 * 			entry to access.
-	 * @param storeId
-	 */
-	ConstStorageAccessor(store_address_t storeId);
-	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
-
-	/**
-	 * @brief 	The destructor in default configuration takes care of
-	 * 			deleting the accessed pool entry and unlocking the mutex
-	 */
-	virtual ~ConstStorageAccessor();
-
-	/**
-	 * @brief	Returns a pointer to the read-only data
-	 * @return
-	 */
-	const uint8_t* data() const;
-
-	/**
-	 * @brief	Copies the read-only data to the supplied pointer
-	 * @param pointer
-	 */
-	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
-
-	/**
-	 * @brief   Calling this will prevent the Accessor from deleting the data
-	 *          when the destructor is called.
-	 */
-	void release();
-
-	/**
-	 * Get the size of the data
-	 * @return
-	 */
-	size_t size() const;
-
-	/**
-	 * Get the storage ID.
-	 * @return
-	 */
-	store_address_t getId() const;
-
-	void print() const;
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor (ConstStorageAccessor&&);
-
-	//! The copy ctor and copy assignemnt should be deleted implicitely
-	//! according to https://foonathan.net/2019/02/special-member-functions/
-	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator= (const ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (const ConstStorageAccessor&) = delete;
-protected:
-	const uint8_t* constDataPointer = nullptr;
-	store_address_t storeId;
-	size_t size_ = 0;
-	//! Managing pool, has to assign itself.
-	StorageManagerIF* store = nullptr;
-	bool deleteData = true;
-
-	enum class AccessState {
-		UNINIT,
-		ASSIGNED
-	};
-	//! Internal state for safety reasons.
-	AccessState internalState = AccessState::UNINIT;
-	/**
-	 * Used by the pool manager instances to assign themselves to the
-	 * accessor. This is necessary to delete the data when the acessor
-	 * exits the scope ! The internal state will be considered read
-	 * when this function is called, so take care all data is set properly as
-	 * well.
-	 * @param
-	 */
-	void assignStore(StorageManagerIF*);
-};
-
-
 /**
  * @brief   Child class for modifyable data. Also has a normal pointer member.
  */

From 446e7d2f82d46ce9690d3f2c4c84b166407a8c2d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 11:00:40 +0200
Subject: [PATCH 0478/1774] const storage accessor improvement

---
 storagemanager/ConstStorageAccessor.cpp | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index be3188c1d..0bfde58c1 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -1,6 +1,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/storagemanager/ConstStorageAccessor.h>
 #include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/globalfunctions/arrayprinter.h>
 
 ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
 		storeId(storeId) {}
@@ -73,18 +74,11 @@ store_address_t ConstStorageAccessor::getId() const {
 }
 
 void ConstStorageAccessor::print() const {
-	if(internalState == AccessState::UNINIT) {
+	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 		return;
 	}
-	sif::info << "StorageAccessor: Printing data: [";
-	for(uint16_t iPool = 0; iPool < size_; iPool++) {
-		sif::info << std::hex << (int)constDataPointer[iPool];
-		if(iPool < size_ - 1){
-			sif::info << " , ";
-		}
-	}
-	sif::info << " ] " << std::endl;
+	arrayprinter::print(constDataPointer, size_);
 }
 
 void ConstStorageAccessor::assignStore(StorageManagerIF* store) {

From 2ecd7c44937180ab0aad13a1185ed9cc54c9eaa4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 11:05:40 +0200
Subject: [PATCH 0479/1774] some minor improvements

---
 storagemanager/LocalPool.h     | 11 +++++++----
 storagemanager/PoolManager.h   |  3 +++
 storagemanager/PoolManager.tpp |  6 +++---
 3 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index bb94a3be2..7e349dcde 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -35,7 +35,7 @@ public:
 	/**
 	 * @brief	This is the default constructor for a pool manager instance.
 	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
-	 * 			allocates memory (with \c new) for store and size_list. These
+	 * 			allocates memory (with @c new) for store and size_list. These
 	 * 			regions are all set to zero on start up.
 	 * @param setObjectId	The object identifier to be set. This allows for
 	 * 						multiple instances of LocalPool in the system.
@@ -87,7 +87,7 @@ public:
 	ReturnValue_t initialize() override;
 protected:
 	/**
-	 * With this helper method, a free element of \c size is reserved.
+	 * With this helper method, a free element of @c size is reserved.
 	 * @param size	The minimum packet size that shall be reserved.
 	 * @param[out] address Storage ID of the reserved data.
 	 * @return	- #RETURN_OK on success,
@@ -100,7 +100,8 @@ protected:
 private:
 	/**
 	 * Indicates that this element is free.
-	 * This value limits the maximum size of a pool. Change to larger data type if increase is required.
+	 * This value limits the maximum size of a pool. Change to larger data type
+	 * if increase is required.
 	 */
 	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
 	/**
@@ -126,7 +127,9 @@ private:
 	 * 			is also dynamically allocated there.
 	 */
 	uint32_t* size_list[NUMBER_OF_POOLS];
-	bool spillsToHigherPools; //!< A variable to determine whether higher n pools are used if the store is full.
+	//! A variable to determine whether higher n pools are used if
+	//! the store is full.
+	bool spillsToHigherPools;
 	/**
 	 * @brief	This method safely stores the given data in the given packet_id.
 	 * @details	It also sets the size in size_list. The method does not perform
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 7c2e8a719..3c1c12176 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -29,6 +29,9 @@ public:
 			store_address_t* storeId = nullptr) override;
 
 protected:
+	//! Default mutex timeout value to prevent permanent blocking.
+	static constexpr uint32_t mutexTimeout = 50;
+
 	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
 			bool ignoreFault) override;
 
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index a35b810c9..4ca22b858 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -21,7 +21,7 @@ inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
 		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
+	MutexHelper mutexHelper(mutex, mutexTimeout);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
 			address,ignoreFault);
 	return status;
@@ -33,7 +33,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 	// debug << "PoolManager( " << translateObject(getObjectId()) <<
 	//       " )::deleteData from store " << packet_id.pool_index <<
 	//       ". id is "<< packet_id.packet_index << std::endl;
-	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
+	MutexHelper mutexHelper(mutex, mutexTimeout);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
 	return status;
 }
@@ -41,7 +41,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 		size_t size, store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
+	MutexHelper mutexHelper(mutex, mutexTimeout);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
 			size, storeId);
 	return status;

From 6f4682e1c8848e8fb578af9329c6f274e84a6f60 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 12:53:30 +0200
Subject: [PATCH 0480/1774] hasactionsIF include guard and doc

---
 action/HasActionsIF.h | 47 ++++++++++++++++++++++++-------------------
 1 file changed, 26 insertions(+), 21 deletions(-)

diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 12ecb89a8..9c2a9c01d 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -1,5 +1,5 @@
-#ifndef HASACTIONSIF_H_
-#define HASACTIONSIF_H_
+#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
+#define FRAMEWORK_ACTION_HASACTIONSIF_H_
 
 #include <framework/action/ActionHelper.h>
 #include <framework/action/ActionMessage.h>
@@ -11,22 +11,26 @@
  * Interface for component which uses actions
  *
  * @details
- * This interface is used to execute actions in the component. Actions, in the sense of this interface, are activities with a well-defined beginning and
- * end in time. They may adjust sub-states of components, but are not supposed to change
- * the main mode of operation, which is handled with the HasModesIF described below.
+ * This interface is used to execute actions in the component. Actions, in the
+ * sense of this interface, are activities with a well-defined beginning and
+ * end in time. They may adjust sub-states of components, but are not supposed
+ * to change the main mode of operation, which is handled with the HasModesIF
+ * described below.
  *
- * The HasActionsIF allows components to define such actions and make them available
- * for other components to use. Implementing the interface is straightforward: There’s a
- * single executeAction call, which provides an identifier for the action to execute, as well
- * as arbitrary parameters for input. Aside from direct, software-based
- * actions, it is used in device handler components as an interface to forward commands to
- * devices.
- * Implementing components of the interface are supposed to check identifier (ID) and
- * parameters and immediately start execution of the action. It is, however, not required to
- * immediately finish execution. Instead, this may be deferred to a later point in time, at
- * which the component needs to inform the caller about finished or failed execution.
+ * The HasActionsIF allows components to define such actions and make them
+ * available for other components to use. Implementing the interface is
+ * straightforward: There’s a single executeAction call, which provides an
+ * identifier for the action to execute, as well as arbitrary parameters for
+ * input.
+ * Aside from direct, software-based actions, it is used in device handler
+ * components as an interface to forward commands to devices.
+ * Implementing components of the interface are supposed to check identifier
+ * (ID) and parameters and immediately start execution of the action.
+ * It is, however, not required to immediately finish execution.
+ * Instead, this may be deferred to a later point in time, at which the
+ * component needs to inform the caller about finished or failed execution.
  *
- * \ingroup interfaces
+ * @ingroup interfaces
  */
 class HasActionsIF {
 public:
@@ -43,13 +47,14 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	/**
 	 * Execute or initialize the execution of a certain function.
-	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to be done.
-	 * When needing more steps, return RETURN_OK and issue steps and completion manually.
+	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to
+	 * be done. When needing more steps, return RETURN_OK and issue steps and
+	 * completion manually.
 	 * One "step failed" or completion report must be issued!
 	 */
-	virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-			const uint8_t* data, size_t size) = 0;
+	virtual ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
 };
 
 
-#endif /* HASACTIONSIF_H_ */
+#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */

From 5f16d30d822a26fd42ddd2cdc4bc5211db695f41 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 13:47:38 +0200
Subject: [PATCH 0481/1774] all ones value for return failed now

---
 returnvalues/HasReturnvaluesIF.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index b51dfc828..6ead6fbbf 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -12,7 +12,8 @@ typedef uint16_t ReturnValue_t;
 class HasReturnvaluesIF {
 public:
 	static const ReturnValue_t RETURN_OK = 0;
-	static const ReturnValue_t RETURN_FAILED = 0xFFFF;
+	//! This will be the alll-ones value irrespective of used unsigned datatype.
+	static const ReturnValue_t RETURN_FAILED = -1;
 	virtual ~HasReturnvaluesIF() {}
 };
 

From 67366c25a0bd0b4e532cb8ee48d3d795215c773b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 13:49:25 +0200
Subject: [PATCH 0482/1774] typo fix

---
 returnvalues/HasReturnvaluesIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 6ead6fbbf..7a861b50d 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -12,7 +12,7 @@ typedef uint16_t ReturnValue_t;
 class HasReturnvaluesIF {
 public:
 	static const ReturnValue_t RETURN_OK = 0;
-	//! This will be the alll-ones value irrespective of used unsigned datatype.
+	//! This will be the all-ones value irrespective of used unsigned datatype.
 	static const ReturnValue_t RETURN_FAILED = -1;
 	virtual ~HasReturnvaluesIF() {}
 };

From 56455a5fa290d69f62ad6a17a2ad66b311401c5e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 14:11:53 +0200
Subject: [PATCH 0483/1774] added static function as alternative to macro

---
 returnvalues/HasReturnvaluesIF.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 7a861b50d..04acd66e9 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -15,6 +15,10 @@ public:
 	//! This will be the all-ones value irrespective of used unsigned datatype.
 	static const ReturnValue_t RETURN_FAILED = -1;
 	virtual ~HasReturnvaluesIF() {}
+
+	static ReturnValue_t makeReturnCode(uint8_t interfaceId, uint8_t number) {
+	    return (interfaceId << 8) + number;
+	}
 };
 
 #endif /* HASRETURNVALUESIF_H_ */

From 905c1a92e38865558e25bebb10a8c7ca380d2ab6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 21:03:22 +0200
Subject: [PATCH 0484/1774] reverted some changes

---
 action/ActionHelper.cpp               |  3 +--
 datalinklayer/MapPacketExtraction.cpp |  3 +--
 events/EventManager.cpp               |  1 -
 events/EventManagerIF.h               |  3 +--
 health/HealthHelper.cpp               |  2 --
 housekeeping/HousekeepingMessage.cpp  | 10 +++++-----
 housekeeping/HousekeepingMessage.h    |  2 +-
 ipc/CommandMessage.cpp                | 22 +++++++++++-----------
 ipc/CommandMessage.h                  |  2 +-
 ipc/CommandMessageBase.cpp            | 16 ++++++----------
 ipc/CommandMessageBase.h              |  7 -------
 ipc/MessageQueueMessage.cpp           | 16 ++++++----------
 ipc/MessageQueueMessage.h             | 12 ------------
 ipc/MessageQueueMessageIF.h           | 14 +-------------
 ipc/MessageQueueSenderIF.h            |  7 +++----
 modes/ModeHelper.cpp                  |  5 +----
 monitoring/LimitViolationReporter.cpp |  3 +--
 osal/FreeRTOS/MessageQueue.cpp        | 19 ++++++-------------
 osal/FreeRTOS/MessageQueue.h          |  5 ++---
 osal/FreeRTOS/QueueFactory.cpp        | 11 +++--------
 parameters/ParameterHelper.cpp        |  6 ++----
 tmtcpacket/pus/TmPacketStored.cpp     |  2 +-
 tmtcservices/VerificationReporter.cpp |  8 ++++----
 23 files changed, 57 insertions(+), 122 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 026df4e13..0df5f2d4e 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -101,8 +101,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 
 	//TODO Service Implementation sucks at the moment
 	if (hideSender){
-		result = MessageQueueSenderIF::sendMessage(reportTo, &reply,
-		        MessageQueueMessage::MAX_MESSAGE_SIZE);
+		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
 	} else {
 		result = queueToUse->sendMessage(reportTo, &reply);
 	}
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 87b465567..4ea45e89c 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -117,8 +117,7 @@ ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data,
 	ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
 	if (status == RETURN_OK) {
 		TmTcMessage message(store_id);
-		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message,
-		        MessageQueueMessage::MAX_MESSAGE_SIZE);
+		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message);
 	}
 	return status;
 }
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index a5d145698..04be6f68f 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -52,7 +52,6 @@ void EventManager::notifyListeners(EventMessage* message) {
 	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
 		if (iter->second.match(message)) {
 			MessageQueueSenderIF::sendMessage(iter->first, message,
-			        MessageQueueMessage::MAX_MESSAGE_SIZE,
 			        message->getSender());
 		}
 	}
diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h
index 053e320b0..bc0de4329 100644
--- a/events/EventManagerIF.h
+++ b/events/EventManagerIF.h
@@ -44,8 +44,7 @@ public:
 				eventmanagerQueue = eventmanager->getEventReportQueue();
 			}
 		}
-		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message,
-		        MessageQueueMessage::MAX_MESSAGE_SIZE, sentFrom);
+		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
 	}
 
 };
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index 935bf5e3f..0b3bffcb1 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -70,7 +70,6 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
 			health, oldHealth);
 	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
-	        MessageQueueMessage::MAX_MESSAGE_SIZE,
 	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
 		sif::debug << "HealthHelper::informParent: sending health reply failed."
 				<< std::endl;
@@ -91,7 +90,6 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
 		reply.setReplyRejected(result, command->getCommand());
 	}
 	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-	        MessageQueueMessage::MAX_MESSAGE_SIZE,
 	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
 		sif::debug << "HealthHelper::handleHealthCommand: sending health "
 		        "reply failed." << std::endl;
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index d7efd7031..f425d16e8 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -3,13 +3,13 @@
 
 HousekeepingMessage::HousekeepingMessage(MessageQueueMessageIF* message):
 		CommandMessageBase(message) {
-	if(message->getMaximumMessageSize() < HK_MESSAGE_SIZE) {
+	if(message->getMessageSize() < HK_MESSAGE_SIZE) {
 		sif::error << "HousekeepingMessage::HousekeepingMessage: Passed "
 		        "message buffer can not hold minimum " << HK_MESSAGE_SIZE
 				<< " bytes!" << std::endl;
 		return;
 	}
-	message->setMessageSize(HK_MESSAGE_SIZE);
+	//message->setMessageSize(HK_MESSAGE_SIZE);
 }
 
 HousekeepingMessage::~HousekeepingMessage() {}
@@ -38,9 +38,9 @@ void HousekeepingMessage::setHkDiagnosticsMessage(sid_t sid,
 	setParameter(storeId.raw);
 }
 
-size_t HousekeepingMessage::getMinimumMessageSize() const {
-	return HK_MESSAGE_SIZE;
-}
+//size_t HousekeepingMessage::getMinimumMessageSize() const {
+//	return HK_MESSAGE_SIZE;
+//}
 
 sid_t HousekeepingMessage::getSid() const {
 	sid_t sid;
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index c6a33c835..f568a418c 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -104,7 +104,7 @@ public:
 	//! to distinguish between diagnostics and regular HK packets
 	sid_t getHkReportMessage(store_address_t * storeIdToSet) const;
 
-	virtual size_t getMinimumMessageSize() const override;
+	//virtual size_t getMinimumMessageSize() const override;
 	virtual void clear() override;
 private:
 
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 9a8a82f24..11355e38d 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -9,14 +9,14 @@ CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
 				" message!" << std::endl;
 		return;
 	}
-	if(receiverMessage->getMaximumMessageSize() <
-			getMinimumMessageSize()) {
-		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
-				" can not hold minimum "<< getMinimumMessageSize()
-				<< " bytes!" << std::endl;
-		return;
-	}
-	internalMessage->setMessageSize(getMinimumMessageSize());
+//	if(receiverMessage->getMessageSize() <
+//			getMinimumMessageSize()) {
+//		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
+//				" can not hold minimum "<< getMinimumMessageSize()
+//				<< " bytes!" << std::endl;
+//		return;
+//	}
+//	internalMessage->setMessageSize(getMinimumMessageSize());
 }
 
 CommandMessage::CommandMessage(MessageQueueMessageIF* messageToSet,
@@ -49,9 +49,9 @@ void CommandMessage::setParameter2(uint32_t parameter2) {
 			sizeof(parameter2));
 }
 
-size_t CommandMessage::getMinimumMessageSize() const {
-	return MINIMUM_COMMAND_MESSAGE_SIZE;
-}
+//size_t CommandMessage::getMinimumMessageSize() const {
+//	return MINIMUM_COMMAND_MESSAGE_SIZE;
+//}
 
 bool CommandMessage::isClearedCommandMessage() {
 	return getCommand() == CMD_NONE;
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index a09494c6c..ae4016b07 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -54,7 +54,7 @@ public:
 	virtual ~CommandMessage() {}
 
 	/** MessageQueueMessageIF functions used for minimum size check. */
-	size_t getMinimumMessageSize() const override;
+	//size_t getMinimumMessageSize() const override;
 
 	/**
 	 * Get the first parameter of the message
diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
index 80f9d3786..ea50f4ead 100644
--- a/ipc/CommandMessageBase.cpp
+++ b/ipc/CommandMessageBase.cpp
@@ -47,25 +47,21 @@ const uint8_t* CommandMessageBase::getData() const {
 	return internalMessage->getData() + sizeof(Command_t);
 }
 
-void CommandMessageBase::setMessageSize(size_t messageSize) {
-	internalMessage->setMessageSize(messageSize);
-}
+//void CommandMessageBase::setMessageSize(size_t messageSize) {
+//	//internalMessage->setMessageSize(messageSize);
+//}
 
 size_t CommandMessageBase::getMessageSize() const {
 	return internalMessage->getMessageSize();
 }
 
-size_t CommandMessageBase::getMaximumMessageSize() const {
-	return internalMessage->getMaximumMessageSize();
-}
-
 MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
 	return internalMessage;
 }
 
-size_t CommandMessageBase::getMinimumMessageSize() const {
-	return MINIMUM_COMMAND_MESSAGE_BASE_SIZE;
-}
+//size_t CommandMessageBase::getMinimumMessageSize() const {
+//	return MINIMUM_COMMAND_MESSAGE_BASE_SIZE;
+//}
 
 void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
 		Command_t initialCommand) {
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
index b237b68f3..1ee1b9702 100644
--- a/ipc/CommandMessageBase.h
+++ b/ipc/CommandMessageBase.h
@@ -63,15 +63,8 @@ public:
 	virtual MessageQueueId_t getSender() const override;
 	virtual uint8_t * getData() override;
 	virtual const uint8_t* getData() const override;
-	virtual void setMessageSize(size_t messageSize) override;
 	virtual size_t getMessageSize() const override;
 
-	//! This depends on the maximum message size of the passed internal message.
-	virtual size_t getMaximumMessageSize() const override;
-
-	//! Return the constant minimum message size.
-	virtual size_t getMinimumMessageSize() const override;
-
 	/**
 	 * A command message can be rejected and needs to offer a function
 	 * to set a rejected reply
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index b173f2c41..f3665074d 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -51,9 +51,9 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
 	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
 }
 
-size_t MessageQueueMessage::getMinimumMessageSize() const {
-	return this->HEADER_SIZE;
-}
+//size_t MessageQueueMessage::getMinimumMessageSize() const {
+//	return this->HEADER_SIZE;
+//}
 
 void MessageQueueMessage::print() {
 	sif::debug << "MessageQueueMessage has size: " << this->messageSize <<
@@ -69,13 +69,9 @@ void MessageQueueMessage::clear() {
 }
 
 size_t MessageQueueMessage::getMessageSize() const {
-	return this->messageSize;
-}
-
-size_t MessageQueueMessage::getMaximumMessageSize() const {
 	return this->MAX_MESSAGE_SIZE;
 }
 
-void MessageQueueMessage::setMessageSize(size_t messageSize) {
-	this->messageSize = messageSize;
-}
+//void MessageQueueMessage::setMessageSize(size_t messageSize) {
+//	this->messageSize = messageSize;
+//}
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 8716df54d..a994c3239 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -139,20 +139,8 @@ public:
 	 * The message queue id that identifies the sending message queue.
 	 */
 	void setSender(MessageQueueId_t setId) override;
-	/**
-	 * @brief	This helper function is used by the MessageQueue class to check
-	 * 			the size of an incoming message.
-	 * @details
-	 * The method must be overwritten by child classes if size
-	 * checks shall be more strict.
-	 * @return	The default implementation returns HEADER_SIZE.
-	 */
-	virtual size_t getMinimumMessageSize() const override;
 
 	virtual size_t getMessageSize() const override;
-	virtual void setMessageSize(size_t messageSize) override;
-
-	virtual size_t getMaximumMessageSize() const override;
 
 	/**
 	 * @brief	This is a debug method that prints the content
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index f34cab98a..19c69bfb6 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -68,23 +68,11 @@ public:
 	virtual uint8_t* getData() = 0;
 
 	/**
-	 * @brief	This helper function is used by the MessageQueue class to
-	 * 			check the size of an incoming message.
-	 */
-	virtual size_t getMinimumMessageSize() const = 0;
-
-	/**
-	 * Get message size of current message implementation.
+	 * Get constant message size of current message implementation.
 	 * @return
 	 */
 	virtual size_t getMessageSize() const = 0;
-	virtual void setMessageSize(size_t messageSize) = 0;
 
-	/**
-	 * Get maximum allowed size of current message implementation.
-	 * @return
-	 */
-	virtual size_t getMaximumMessageSize() const = 0;
 };
 
 
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 8bc149485..e4b9670e7 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -10,17 +10,16 @@ public:
 	virtual ~MessageQueueSenderIF() {}
 
 	/**
-	 * Allows sending messages without actually "owing" a message queue.
+	 * Allows sending messages without actually "owning" a message queue.
 	 * Not sure whether this is actually a good idea.
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, size_t maxMessageSize,
+			MessageQueueMessageIF* message,
 			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
-			bool ignoreFault=false);
+			bool ignoreFault = false);
 private:
 	MessageQueueSenderIF() {}
 };
 
 
-
 #endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index f636c0bf3..59a6d974f 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -28,7 +28,6 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			ModeMessage::cantReachMode(&reply, result);
 			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-			        MessageQueueMessage::MAX_MESSAGE_SIZE,
 			        owner->getCommandQueue());
 			break;
 		}
@@ -51,7 +50,6 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
 				submode);
 		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-		        MessageQueueMessage::MAX_MESSAGE_SIZE,
 		       owner->getCommandQueue());
 	}
 		break;
@@ -97,7 +95,7 @@ void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 					ownerMode, ownerSubmode);
 		}
 		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
-		        MessageQueueMessage::MAX_MESSAGE_SIZE, owner->getCommandQueue());
+		        owner->getCommandQueue());
 	}
 }
 
@@ -111,7 +109,6 @@ void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
 				ownerMode, ownerSubmode);
 		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
-		        MessageQueueMessage::MAX_MESSAGE_SIZE,
 		        owner->getCommandQueue());
 	}
 }
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index c6e2b5dba..1378d7549 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -34,8 +34,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	MessageQueueMessage message;
 	CommandMessage report(&message);
 	MonitoringMessage::setLimitViolationReport(&report, storeId);
-	return MessageQueueSenderIF::sendMessage(reportQueue, &report,
-	        MessageQueueMessage::MAX_MESSAGE_SIZE);
+	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
 }
 
 ReturnValue_t LimitViolationReporter::checkClassLoaded() {
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index c9adf229d..464a4f16b 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -50,8 +50,8 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo, message, maxMessageSize, sentFrom,
-			ignoreFault, callContext);
+	return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault,
+	        callContext);
 }
 
 
@@ -80,9 +80,9 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
-    if(message->getMaximumMessageSize() < maxMessageSize) {
+    if(message->getMessageSize() < maxMessageSize) {
         sif::error << "MessageQueue::receiveMessage: Message size "
-                << message->getMaximumMessageSize() <<
+                << message->getMessageSize() <<
                 " too small to receive data!" << std::endl;
         return HasReturnvaluesIF::RETURN_FAILED;
     }
@@ -127,17 +127,10 @@ bool MessageQueue::isDefaultDestinationSet() const {
 
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessageIF* message, size_t maxSize,
-        MessageQueueId_t sentFrom, bool ignoreFault, CallContext callContext) {
+        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+        bool ignoreFault, CallContext callContext) {
     message->setSender(sentFrom);
     BaseType_t result;
-    if(message->getMaximumMessageSize() > maxSize) {
-    	sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size "
-    			 << message->getMaximumMessageSize() << " too large for queue"
-    			  " with max. message size " << maxSize << "!"
-    			 << std::endl;
-    	return HasReturnvaluesIF::RETURN_FAILED;
-    }
 
     if(callContext == CallContext::TASK) {
         result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index e87e884f6..b7e52bb39 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -194,9 +194,8 @@ protected:
 	 * @param context Specify whether call is made from task or from an ISR.
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, size_t maxSize,
-			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault=false,
-			CallContext callContext = CallContext::TASK);
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false, CallContext callContext = CallContext::TASK);
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index d754b2b9d..beb4969bd 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -7,14 +7,9 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, size_t maxSize,
-			MessageQueueId_t sentFrom, bool ignoreFault) {
-    if(maxSize == 0) {
-        sif::error << "MessageQueueSenderIF::sendMessage: Max Size is 0!"
-                << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message, maxSize,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
 			sentFrom,ignoreFault);
 }
 
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 68ff5ab05..8b91020f9 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -107,8 +107,7 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 
 	ParameterMessage::setParameterDumpReply(&reply, id, address);
 
-	MessageQueueSenderIF::sendMessage(to, &reply,
-	        MessageQueueMessage::MAX_MESSAGE_SIZE, ownerQueueId);
+	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -130,6 +129,5 @@ void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
 	MessageQueueMessage message;
 	CommandMessage reply(&message);
 	reply.setReplyRejected(reason, initialCommand);
-	MessageQueueSenderIF::sendMessage(to, &reply,
-	        MessageQueueMessage::MAX_MESSAGE_SIZE, ownerQueueId);
+	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 }
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index d589db8db..c0ff874b2 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -118,7 +118,7 @@ ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 	}
 	TmTcMessage tmMessage(getStoreAddress());
 	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
-	        &tmMessage, MessageQueueMessage::MAX_MESSAGE_SIZE, sentFrom);
+	        &tmMessage, sentFrom);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		deletePacket();
 		if (doErrorReporting) {
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index a54c1f8d4..bcb4756ce 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -23,7 +23,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 			current_packet->getPacketId(),
 			current_packet->getPacketSequenceControl(), 0, set_step);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
+	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
@@ -39,7 +39,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
 			tcSequenceControl, 0, set_step);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
+	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
@@ -58,7 +58,7 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 			current_packet->getPacketSequenceControl(), error_code, step,
 			parameter1, parameter2);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
+	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error
 				<< "VerificationReporter::sendFailureReport Error writing to queue. Code: "
@@ -76,7 +76,7 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	PusVerificationMessage message(report_id, ackFlags, tcPacketId,
 			tcSequenceControl, error_code, step, parameter1, parameter2);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
+	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error
 				<< "VerificationReporter::sendFailureReport Error writing to queue. Code: "

From 3bf29a7315d926dc1447e954494f393061ee2c8a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 00:24:15 +0200
Subject: [PATCH 0485/1774] removed CommandMessageBase, changed interfaces

---
 action/ActionHelper.cpp                |  15 +--
 action/CommandActionHelper.cpp         |   3 +-
 action/SimpleActionHelper.cpp          |   3 +-
 controller/ControllerBase.cpp          |   3 +-
 datapool/HkSwitchHelper.cpp            |   3 +-
 datapoolglob/DataPoolAdmin.cpp         |   9 +-
 datapoollocal/LocalDataPoolManager.cpp |  33 +++--
 datapoollocal/LocalDataPoolManager.h   |   2 +-
 devicehandlers/AssemblyBase.cpp        |   3 +-
 devicehandlers/DeviceHandlerBase.cpp   |  18 +--
 devicehandlers/HealthDevice.cpp        |   3 +-
 health/HealthHelper.cpp                |   6 +-
 housekeeping/HousekeepingMessage.cpp   |  22 ++--
 housekeeping/HousekeepingMessage.h     |   7 +-
 ipc/CommandMessage.cpp                 |  77 ++++++++----
 ipc/CommandMessage.h                   |  73 ++++++++---
 ipc/CommandMessageBase.cpp             | 168 ++++++++++++-------------
 ipc/CommandMessageBase.h               |  67 +++-------
 ipc/CommandMessageIF.h                 |  34 +++--
 ipc/MessageQueueMessage.cpp            |  41 +++---
 ipc/MessageQueueMessage.h              |  16 ++-
 ipc/MessageQueueMessageIF.h            |  11 +-
 memory/MemoryHelper.cpp                |  15 +--
 modes/ModeHelper.cpp                   |   9 +-
 monitoring/LimitViolationReporter.cpp  |   3 +-
 parameters/ParameterHelper.cpp         |   6 +-
 power/Fuse.cpp                         |   3 +-
 power/PowerSensor.cpp                  |   3 +-
 subsystem/Subsystem.cpp                |  14 +--
 subsystem/SubsystemBase.cpp            |  14 +--
 thermal/AbstractTemperatureSensor.cpp  |   5 +-
 thermal/Heater.cpp                     |   3 +-
 tmtcservices/CommandingServiceBase.cpp |  28 ++---
 tmtcservices/CommandingServiceBase.h   |  10 +-
 34 files changed, 348 insertions(+), 382 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 0df5f2d4e..57b64686f 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -33,15 +33,13 @@ ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
 }
 
 void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
 	queueToUse->sendMessage(reportTo, &reply);
 }
 
 void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	ActionMessage::setCompletionReply(&reply, commandId, result);
 	queueToUse->sendMessage(reportTo, &reply);
 }
@@ -56,8 +54,7 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
 		queueToUse->sendMessage(commandedBy, &reply);
 		return;
@@ -65,8 +62,7 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
 	ipcStore->deleteData(dataAddress);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
 		queueToUse->sendMessage(commandedBy, &reply);
 		return;
@@ -75,8 +71,7 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 
 ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 		ActionId_t replyId, SerializeIF* data, bool hideSender) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	store_address_t storeAddress;
 	uint8_t *dataPtr;
 	size_t maxSize = data->getSerializedSize();
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index c871a2d06..772954014 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -53,8 +53,7 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 
 ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
 		ActionId_t actionId, store_address_t storeId) {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ActionMessage::setCommand(&command, actionId, storeId);
 	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index f97474b19..6861fc28c 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -36,8 +36,7 @@ void SimpleActionHelper::resetHelper() {
 
 void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
 		ActionId_t actionId, store_address_t dataAddress) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	if (isExecuting) {
 		ipcStore->deleteData(dataAddress);
 		ActionMessage::setStepReply(&reply, actionId, 0,
diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index ad0a0b978..674d0fc88 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -56,8 +56,7 @@ MessageQueueId_t ControllerBase::getCommandQueue() const {
 }
 
 void ControllerBase::handleQueue() {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result;
 	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
 			result = commandQueue->receiveMessage(&command)) {
diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp
index 6a9237766..cf5114f75 100644
--- a/datapool/HkSwitchHelper.cpp
+++ b/datapool/HkSwitchHelper.cpp
@@ -21,8 +21,7 @@ ReturnValue_t HkSwitchHelper::initialize() {
 }
 
 ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
 		ReturnValue_t result = commandActionHelper.handleReply(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 6387263f8..05de1eb2a 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -66,8 +66,7 @@ ReturnValue_t DataPoolAdmin::getParameter(uint8_t domainId,
 }
 
 void DataPoolAdmin::handleCommand() {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != RETURN_OK) {
 		return;
@@ -283,8 +282,7 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 
 	ParameterMessage::setParameterDumpReply(&reply, id, address);
 
@@ -296,8 +294,7 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 //identical to ParameterHelper::rejectCommand()
 void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
 		Command_t initialCommand) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	reply.setReplyRejected(reason, initialCommand);
 	commandQueue->sendMessage(to, &reply);
 }
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index e0731a96c..bc57468a0 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -45,8 +45,8 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-		HousekeepingMessage& message) {
-    Command_t command = message.getCommand();
+		CommandMessage* message) {
+    Command_t command = message->getCommand();
     switch(command) {
     // I think those are the only commands which can be handled here..
     case(HousekeepingMessage::ADD_HK_REPORT_STRUCT):
@@ -55,10 +55,10 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
         return HasReturnvaluesIF::RETURN_OK;
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-        return generateSetStructurePacket(message.getSid());
+        //return generateSetStructurePacket(message->getSid());
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
     case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
-        return generateHousekeepingPacket(message.getSid());
+        //return generateHousekeepingPacket(message->getSid());
     default:
         return CommandMessageIF::UNKNOWN_COMMAND;
     }
@@ -105,19 +105,18 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	}
 
 	// and now we set a HK message and send it the HK packet destination.
-	MessageQueueMessage message;
-	HousekeepingMessage hkMessage(&message);
-	hkMessage.setHkReportMessage(sid, storeId);
-	if(hkQueue == nullptr) {
-	    return QUEUE_NOT_SET;
-	}
-
-	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
-	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
-	}
-	else {
-	    result = hkQueue->sendToDefault(&hkMessage);
-	}
+	//HousekeepingMessage hkMessage;
+//	hkMessage.setHkReportMessage(sid, storeId);
+//	if(hkQueue == nullptr) {
+//	    return QUEUE_NOT_SET;
+//	}
+//
+//	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
+//	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
+//	}
+//	else {
+//	    result = hkQueue->sendToDefault(&hkMessage);
+//	}
 
 	return result;
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index b64917241..9d072bf44 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -58,7 +58,7 @@ public:
 	ReturnValue_t generateHousekeepingPacket(sid_t sid);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
-	ReturnValue_t handleHousekeepingMessage(HousekeepingMessage& message);
+	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
 	/**
 	 * This function is used to fill the local data pool map with pool
diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index a5dcad21b..bd85d1de5 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -148,8 +148,7 @@ void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
 
 void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
 		HealthState health) {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
 			health);
 	if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1ae056a6d..0442be89b 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -214,12 +214,7 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	// This is not ideal. What if it is not a command message? (e.g. another
-	// message with 3 parameters). The full buffer is filled anyway
-	// and I could just copy the content into the other message but
-	// all I need are few additional functions the other message type offers.
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != RETURN_OK) {
 		return;
@@ -247,8 +242,7 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	HousekeepingMessage hkMessage(&message);
-	result = hkManager.handleHousekeepingMessage(hkMessage);
+	result = hkManager.handleHousekeepingMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
@@ -484,13 +478,12 @@ void DeviceHandlerBase::setMode(Mode_t newMode) {
 
 void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
 		uint32_t parameter) {
-	MessageQueueMessage message;
 	//This is actually the reply protocol for raw and misc DH commands.
 	if (status == RETURN_OK) {
-		CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, parameter);
+		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, parameter);
 		commandQueue->reply(&reply);
 	} else {
-		CommandMessage reply(&message, CommandMessage::REPLY_REJECTED, status, parameter);
+		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, parameter);
 		commandQueue->reply(&reply);
 	}
 }
@@ -760,8 +753,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		return;
 	}
 
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 
 	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
 			getObjectId(), address, isCommand);
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 7e3a59bd0..0bce34ec7 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -13,8 +13,7 @@ HealthDevice::~HealthDevice() {
 }
 
 ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
 		healthHelper.handleHealthCommand(&command);
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index 0b3bffcb1..e01e6fbb7 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -65,8 +65,7 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
 		return;
 	}
-	MessageQueueMessage message;
-	CommandMessage information(&message);
+	CommandMessage information;
 	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
 			health, oldHealth);
 	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
@@ -81,8 +80,7 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
 	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
 		return;
 	}
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	if (result == HasReturnvaluesIF::RETURN_OK) {
 		HealthMessage::setHealthMessage(&reply,
 				HealthMessage::REPLY_HEALTH_SET);
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index f425d16e8..0d0f98603 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,15 +1,7 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <cstring>
 
-HousekeepingMessage::HousekeepingMessage(MessageQueueMessageIF* message):
-		CommandMessageBase(message) {
-	if(message->getMessageSize() < HK_MESSAGE_SIZE) {
-		sif::error << "HousekeepingMessage::HousekeepingMessage: Passed "
-		        "message buffer can not hold minimum " << HK_MESSAGE_SIZE
-				<< " bytes!" << std::endl;
-		return;
-	}
-	//message->setMessageSize(HK_MESSAGE_SIZE);
+HousekeepingMessage::HousekeepingMessage(): CommandMessage() {
 }
 
 HousekeepingMessage::~HousekeepingMessage() {}
@@ -26,14 +18,14 @@ uint32_t HousekeepingMessage::getParameter() const {
 
 void HousekeepingMessage::setHkReportMessage(sid_t sid,
 		store_address_t storeId) {
-	CommandMessageBase::setCommand(HK_REPORT);
+	CommandMessage::setCommand(HK_REPORT);
 	setSid(sid);
 	setParameter(storeId.raw);
 }
 
 void HousekeepingMessage::setHkDiagnosticsMessage(sid_t sid,
 		store_address_t storeId) {
-	CommandMessageBase::setCommand(DIAGNOSTICS_REPORT);
+	CommandMessage::setCommand(DIAGNOSTICS_REPORT);
 	setSid(sid);
 	setParameter(storeId.raw);
 }
@@ -44,7 +36,7 @@ void HousekeepingMessage::setHkDiagnosticsMessage(sid_t sid,
 
 sid_t HousekeepingMessage::getSid() const {
 	sid_t sid;
-	std::memcpy(&sid.raw, CommandMessageBase::getData(), sizeof(sid.raw));
+	std::memcpy(&sid.raw, CommandMessage::getData(), sizeof(sid.raw));
 	return sid;
 }
 
@@ -58,16 +50,16 @@ sid_t HousekeepingMessage::getHkReportMessage(
 }
 
 void HousekeepingMessage::setSid(sid_t sid) {
-	std::memcpy(CommandMessageBase::getData(), &sid.raw, sizeof(sid.raw));
+	std::memcpy(CommandMessage::getData(), &sid.raw, sizeof(sid.raw));
 }
 
 
 uint8_t* HousekeepingMessage::getData() {
-	return CommandMessageBase::getData() + sizeof(sid_t);
+	return CommandMessage::getData() + sizeof(sid_t);
 }
 
 const uint8_t* HousekeepingMessage::getData() const {
-	return CommandMessageBase::getData() + sizeof(sid_t);
+	return CommandMessage::getData() + sizeof(sid_t);
 }
 
 void HousekeepingMessage::clear() {
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index f568a418c..8958201e8 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
 #define FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
-#include <framework/ipc/CommandMessageBase.h>
+
+#include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/FwMessageTypes.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/storagemanager/StorageManagerIF.h>
@@ -33,7 +34,7 @@ union sid_t {
  * This message is slightly larger than regular command messages to accomodate
  * the uint64_t structure ID (SID).
  */
-class HousekeepingMessage : public CommandMessageBase {
+class HousekeepingMessage : public CommandMessage {
 public:
 
 	static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
@@ -44,7 +45,7 @@ public:
 	 * the message data, see CommandMessageIF and getInternalMessage().
 	 * @param message
 	 */
-	HousekeepingMessage(MessageQueueMessageIF* message);
+	HousekeepingMessage();
 	virtual ~HousekeepingMessage();
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 11355e38d..6aa433df0 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,57 +1,64 @@
 #include <framework/ipc/CommandMessage.h>
+#include <framework/ipc/CommandMessageCleaner.h>
 #include <cstring>
 
-CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
-			CommandMessageBase(receiverMessage) {
-	if(receiverMessage == nullptr) {
-		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
-				" as the message queue message, pass the address of an actual"
-				" message!" << std::endl;
-		return;
-	}
-//	if(receiverMessage->getMessageSize() <
-//			getMinimumMessageSize()) {
-//		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
-//				" can not hold minimum "<< getMinimumMessageSize()
-//				<< " bytes!" << std::endl;
-//		return;
-//	}
-//	internalMessage->setMessageSize(getMinimumMessageSize());
+CommandMessage::CommandMessage() {
+	MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
+    setCommand(CMD_NONE);
 }
 
-CommandMessage::CommandMessage(MessageQueueMessageIF* messageToSet,
-		Command_t command, uint32_t parameter1, uint32_t parameter2):
-		CommandMessage(messageToSet) {
+CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
+        uint32_t parameter2) {
+    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
 	setCommand(command);
 	setParameter(parameter1);
 	setParameter2(parameter2);
 }
 
+Command_t CommandMessage::getCommand() const {
+  Command_t command;
+  std::memcpy(&command, getData(), sizeof(Command_t));
+  return command;
+}
+
+void CommandMessage::setCommand(Command_t command) {
+  std::memcpy(getData(), &command, sizeof(Command_t));
+}
+
+uint8_t CommandMessage::getMessageType() const {
+  // first byte of command ID.
+  return getCommand() >> 8 & 0xff;
+}
+
 uint32_t CommandMessage::getParameter() const {
 	uint32_t parameter1;
-	std::memcpy(&parameter1, CommandMessageBase::getData(), sizeof(parameter1));
+	std::memcpy(&parameter1, MessageQueueMessage::getData(), sizeof(parameter1));
 	return parameter1;
 }
 
 void CommandMessage::setParameter(uint32_t parameter1) {
-	std::memcpy(CommandMessageBase::getData(), &parameter1, sizeof(parameter1));
+	std::memcpy(MessageQueueMessage::getData(), &parameter1, sizeof(parameter1));
 }
 
 uint32_t CommandMessage::getParameter2() const {
 	uint32_t parameter2;
-	std::memcpy(&parameter2, CommandMessageBase::getData() + sizeof(uint32_t),
+	std::memcpy(&parameter2, MessageQueueMessage::getData() + sizeof(uint32_t),
 			sizeof(parameter2));
 	return parameter2;
 }
 
 void CommandMessage::setParameter2(uint32_t parameter2) {
-	std::memcpy(CommandMessageBase::getData()  + sizeof(uint32_t), &parameter2,
+	std::memcpy(MessageQueueMessage::getData()  + sizeof(uint32_t), &parameter2,
 			sizeof(parameter2));
 }
 
-//size_t CommandMessage::getMinimumMessageSize() const {
-//	return MINIMUM_COMMAND_MESSAGE_SIZE;
-//}
+size_t CommandMessage::getMinimumMessageSize() const {
+	return MINIMUM_COMMAND_MESSAGE_SIZE;
+}
+
+void CommandMessage::clear() {
+    CommandMessageCleaner::clearCommandMessage(this);
+}
 
 bool CommandMessage::isClearedCommandMessage() {
 	return getCommand() == CMD_NONE;
@@ -62,3 +69,21 @@ void CommandMessage::setToUnknownCommand() {
 	this->clear();
 	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
 }
+
+void CommandMessage::setReplyRejected(ReturnValue_t reason,
+      Command_t initialCommand) {
+  std::memcpy(getData(), &reason, sizeof(reason));
+  std::memcpy(getData() + sizeof(reason), &initialCommand,
+          sizeof(initialCommand));
+}
+
+ReturnValue_t CommandMessage::getReplyRejectedReason(
+      Command_t *initialCommand) const {
+  ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
+  std::memcpy(&reason, getData(), sizeof(reason));
+  if(initialCommand != nullptr) {
+      std::memcpy(initialCommand, getData() + sizeof(reason),
+              sizeof(Command_t));
+  }
+  return reason;
+}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index ae4016b07..a319a0cf4 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
 #define FRAMEWORK_IPC_COMMANDMESSAGE_H_
 
-#include <framework/ipc/CommandMessageBase.h>
+#include <framework/ipc/CommandMessageIF.h>
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/ipc/FwMessageTypes.h>
 
@@ -20,23 +20,21 @@
  * currently has an internal message size of 28 bytes.
  * @author	Bastian Baetz
  */
-class CommandMessage: public CommandMessageBase {
+class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
 public:
-	/**
-	 * This is the size of a message as it is seen by the MessageQueue.
-	 * It can hold the CommandMessage header plus 2 4-byte parameters.
-	 * 14 of the 24 available MessageQueueMessage bytes are used.
-	 */
-	static const size_t MINIMUM_COMMAND_MESSAGE_SIZE =
-			CommandMessageIF::HEADER_SIZE + 2 * sizeof(uint32_t);
+    /**
+     * Default size can accomodate 2 4-byte parameters.
+     */
+    static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
+            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
 
 	/**
-	 * Default Constructor, does not initialize anything.
-	 *
+	 * @brief   Default Constructor, does not initialize anything.
+	 * @details
 	 * This constructor should be used when receiving a Message, as the
 	 * content is filled by the MessageQueue.
 	 */
-	CommandMessage(MessageQueueMessageIF* receiverMessage);
+	CommandMessage();
 	/**
 	 * This constructor creates a new message with all message content
 	 * initialized
@@ -45,17 +43,13 @@ public:
 	 * @param parameter1	The first parameter
 	 * @param parameter2	The second parameter
 	 */
-	CommandMessage(MessageQueueMessageIF* messageToSet, Command_t command,
-			uint32_t parameter1, uint32_t parameter2);
+	CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
 
 	/**
 	 * @brief 	Default Destructor
 	 */
 	virtual ~CommandMessage() {}
 
-	/** MessageQueueMessageIF functions used for minimum size check. */
-	//size_t getMinimumMessageSize() const override;
-
 	/**
 	 * Get the first parameter of the message
 	 * @return the first Parameter of the message
@@ -91,8 +85,49 @@ public:
 	 * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
 	 * Is needed quite often, so we better code it once only.
 	 */
-	void setToUnknownCommand();
+	void setToUnknownCommand() override;
+
+    /**
+     * A command message can be rejected and needs to offer a function
+     * to set a rejected reply
+     * @param reason
+     * @param initialCommand
+     */
+    void setReplyRejected(ReturnValue_t reason,
+            Command_t initialCommand) override;
+    /**
+     * Corrensonding getter function.
+     * @param initialCommand
+     * @return
+     */
+    ReturnValue_t getReplyRejectedReason(
+            Command_t* initialCommand = nullptr) const override;
+
+    virtual void clear() override;
+
+    /**
+     * Read the DeviceHandlerCommand_t that is stored in the message,
+     * usually used after receiving.
+     *
+     * @return the Command stored in the Message
+     */
+    virtual Command_t getCommand() const override;
+    /**
+     * Set the command type of the message. Default implementation also
+     * sets the message type, which will be the first byte of the command ID.
+     * @param the Command to be sent
+     */
+    virtual void setCommand(Command_t command);
+
+    /**
+     * Extract message ID, which is the first byte of the command ID for the
+     * default implementation.
+     * @return
+     */
+    virtual uint8_t getMessageType() const override;
+
+    /** MessageQueueMessageIF functions used for minimum size check. */
+    size_t getMinimumMessageSize() const override;
 };
 
-
 #endif /* COMMANDMESSAGE_H_ */
diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
index ea50f4ead..745e6c5fc 100644
--- a/ipc/CommandMessageBase.cpp
+++ b/ipc/CommandMessageBase.cpp
@@ -1,86 +1,86 @@
-#include <framework/ipc/CommandMessageBase.h>
-#include <framework/ipc/CommandMessageCleaner.h>
-#include <cstring>
-
-CommandMessageBase::CommandMessageBase(MessageQueueMessageIF *message):
-		internalMessage(message) {
-}
-
-Command_t CommandMessageBase::getCommand() const {
-	Command_t command;
-	std::memcpy(&command, internalMessage->getData(), sizeof(Command_t));
-	return command;
-}
-
-void CommandMessageBase::setCommand(Command_t command) {
-	std::memcpy(internalMessage->getData(), &command, sizeof(Command_t));
-}
-
-uint8_t CommandMessageBase::getMessageType() const {
-	// first byte of command ID.
-	return getCommand() >> 8 & 0xff;
-}
-
-MessageQueueId_t CommandMessageBase::getSender() const {
-	return internalMessage->getSender();
-}
-
-uint8_t* CommandMessageBase::getBuffer() {
-	return internalMessage->getBuffer();
-}
-
-void CommandMessageBase::setSender(MessageQueueId_t setId) {
-	internalMessage->setSender(setId);
-}
-
-const uint8_t* CommandMessageBase::getBuffer() const {
-	return internalMessage->getBuffer();
-}
-
-// Header includes command ID.
-uint8_t* CommandMessageBase::getData() {
-	return internalMessage->getData() + sizeof(Command_t);
-}
-
-// Header includes command ID.
-const uint8_t* CommandMessageBase::getData() const {
-	return internalMessage->getData() + sizeof(Command_t);
-}
-
-//void CommandMessageBase::setMessageSize(size_t messageSize) {
-//	//internalMessage->setMessageSize(messageSize);
+//#include <framework/ipc/CommandMessageBase.h>
+//#include <framework/ipc/CommandMessageCleaner.h>
+//#include <cstring>
+//
+//CommandMessageBase::CommandMessageBase(MessageQueueMessageIF *message):
+//		internalMessage(message) {
 //}
-
-size_t CommandMessageBase::getMessageSize() const {
-	return internalMessage->getMessageSize();
-}
-
-MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
-	return internalMessage;
-}
-
-//size_t CommandMessageBase::getMinimumMessageSize() const {
-//	return MINIMUM_COMMAND_MESSAGE_BASE_SIZE;
+//
+//Command_t CommandMessageBase::getCommand() const {
+//	Command_t command;
+//	std::memcpy(&command, internalMessage->getData(), sizeof(Command_t));
+//	return command;
+//}
+//
+//void CommandMessageBase::setCommand(Command_t command) {
+//	std::memcpy(internalMessage->getData(), &command, sizeof(Command_t));
+//}
+//
+//uint8_t CommandMessageBase::getMessageType() const {
+//	// first byte of command ID.
+//	return getCommand() >> 8 & 0xff;
+//}
+//
+//MessageQueueId_t CommandMessageBase::getSender() const {
+//	return internalMessage->getSender();
+//}
+//
+//uint8_t* CommandMessageBase::getBuffer() {
+//	return internalMessage->getBuffer();
+//}
+//
+//void CommandMessageBase::setSender(MessageQueueId_t setId) {
+//	internalMessage->setSender(setId);
+//}
+//
+//const uint8_t* CommandMessageBase::getBuffer() const {
+//	return internalMessage->getBuffer();
+//}
+//
+//// Header includes command ID.
+//uint8_t* CommandMessageBase::getData() {
+//	return internalMessage->getData() + sizeof(Command_t);
+//}
+//
+//// Header includes command ID.
+//const uint8_t* CommandMessageBase::getData() const {
+//	return internalMessage->getData() + sizeof(Command_t);
+//}
+//
+////void CommandMessageBase::setMessageSize(size_t messageSize) {
+////	//internalMessage->setMessageSize(messageSize);
+////}
+//
+//size_t CommandMessageBase::getMessageSize() const {
+//	return internalMessage->getMessageSize();
+//}
+//
+//MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
+//	return internalMessage;
+//}
+//
+////size_t CommandMessageBase::getMinimumMessageSize() const {
+////	return MINIMUM_COMMAND_MESSAGE_BASE_SIZE;
+////}
+//
+//void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
+//		Command_t initialCommand) {
+//	std::memcpy(getData(), &reason, sizeof(reason));
+//	std::memcpy(getData() + sizeof(reason), &initialCommand,
+//			sizeof(initialCommand));
+//}
+//
+//ReturnValue_t CommandMessageBase::getReplyRejectedReason(
+//		Command_t *initialCommand) const {
+//	ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
+//	std::memcpy(&reason, getData(), sizeof(reason));
+//	if(initialCommand != nullptr) {
+//		std::memcpy(initialCommand, getData() + sizeof(reason),
+//				sizeof(Command_t));
+//	}
+//	return reason;
+//}
+//
+//void CommandMessageBase::clear() {
+//	CommandMessageCleaner::clearCommandMessage(this);
 //}
-
-void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
-		Command_t initialCommand) {
-	std::memcpy(getData(), &reason, sizeof(reason));
-	std::memcpy(getData() + sizeof(reason), &initialCommand,
-			sizeof(initialCommand));
-}
-
-ReturnValue_t CommandMessageBase::getReplyRejectedReason(
-		Command_t *initialCommand) const {
-	ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
-	std::memcpy(&reason, getData(), sizeof(reason));
-	if(initialCommand != nullptr) {
-		std::memcpy(initialCommand, getData() + sizeof(reason),
-				sizeof(Command_t));
-	}
-	return reason;
-}
-
-void CommandMessageBase::clear() {
-	CommandMessageCleaner::clearCommandMessage(this);
-}
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
index 1ee1b9702..59795114f 100644
--- a/ipc/CommandMessageBase.h
+++ b/ipc/CommandMessageBase.h
@@ -23,67 +23,28 @@
  */
 class CommandMessageBase: public CommandMessageIF {
 public:
-	//! This minimum size is derived from the interface requirement to be able
-	//! to set a rejected reply, which contains a returnvalue and the initial
-	//! command.
-	static constexpr size_t MINIMUM_COMMAND_MESSAGE_BASE_SIZE =
-			CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
-			sizeof(Command_t);
+
 
 	CommandMessageBase(MessageQueueMessageIF* message);
 
-	/**
-	 * Read the DeviceHandlerCommand_t that is stored in the message,
-	 * usually used after receiving.
-	 *
-	 * @return the Command stored in the Message
-	 */
-	virtual Command_t getCommand() const override;
-	/**
-	 * Set the command type of the message. Default implementation also
-	 * sets the message type, which will be the first byte of the command ID.
-	 * @param the Command to be sent
-	 */
-	virtual void setCommand(Command_t command);
 
-	/**
-	 * Extract message ID, which is the first byte of the command ID for the
-	 * default implementation.
-	 * @return
-	 */
-	virtual uint8_t getMessageType() const override;
 
-	/*
-	 * MessageQueueMessageIF functions, which generally just call the
-	 * respective functions of the internal message queue message.
-	 */
-	virtual uint8_t * getBuffer() override;
-	virtual const uint8_t * getBuffer() const override;
-	virtual void setSender(MessageQueueId_t setId) override;
-	virtual MessageQueueId_t getSender() const override;
-	virtual uint8_t * getData() override;
-	virtual const uint8_t* getData() const override;
-	virtual size_t getMessageSize() const override;
+//	/*
+//	 * MessageQueueMessageIF functions, which generally just call the
+//	 * respective functions of the internal message queue message.
+//	 */
+//	virtual uint8_t * getBuffer() override;
+//	virtual const uint8_t * getBuffer() const override;
+//	virtual void setSender(MessageQueueId_t setId) override;
+//	virtual MessageQueueId_t getSender() const override;
+//	virtual uint8_t * getData() override;
+//	virtual const uint8_t* getData() const override;
+//	virtual size_t getMessageSize() const override;
 
-	/**
-	 * A command message can be rejected and needs to offer a function
-	 * to set a rejected reply
-	 * @param reason
-	 * @param initialCommand
-	 */
-	void setReplyRejected(ReturnValue_t reason,
-			Command_t initialCommand) override;
-	/**
-	 * Corrensonding getter function.
-	 * @param initialCommand
-	 * @return
-	 */
-	ReturnValue_t getReplyRejectedReason(
-			Command_t* initialCommand = nullptr) const override;
 
-	virtual MessageQueueMessageIF* getInternalMessage() const override;
+	//virtual MessageQueueMessageIF* getInternalMessage() const override;
+
 
-	virtual void clear() override;
 protected:
 	/**
 	 * @brief 	Pointer to the message containing the data.
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index fbfbddbb9..ca050c320 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -5,20 +5,24 @@
 #include <framework/ipc/FwMessageTypes.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
-
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef uint16_t Command_t;
 
-// TODO: actually, this interface propably does not have to implement
-// MQM IF, because there is a getter function for the internal message..
-// But it is also convenient to have the full access to all MQM IF functions.
-// That way, I can just pass CommandMessages to functions expecting a MQM IF.
-// The command message implementations just forwards the calls. Maybe
-// we should just leave it like that.
-class CommandMessageIF: public MessageQueueMessageIF {
+class CommandMessageIF: virtual public MessageQueueMessageIF {
 public:
-	static constexpr size_t HEADER_SIZE = sizeof(MessageQueueId_t) +
+    /**
+     * Header consists of sender ID and command ID.
+     */
+	static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
 			sizeof(Command_t);
+	/**
+	 * This minimum size is derived from the interface requirement to be able
+     * to set a rejected reply, which contains a returnvalue and the initial
+     * command.
+	 */
+	static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
+	        CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
+	        sizeof(Command_t);
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
 	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
@@ -60,15 +64,9 @@ public:
 	virtual ReturnValue_t getReplyRejectedReason(
 			Command_t* initialCommand = nullptr) const  = 0;
 
-	/**
-	 * This function is used to get a pointer to the internal message, as
-	 * the command message implementations always operate on the memory
-	 * contained in the message queue message implementation.
-	 * This pointer can be used to set the internal message of different
-	 * command message implementations.
-	 * @return
-	 */
-	virtual MessageQueueMessageIF* getInternalMessage() const = 0;
+	virtual void setToUnknownCommand() = 0;
+
+	virtual void clear() = 0;
 
 };
 
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index f3665074d..0f4d861bb 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -1,10 +1,10 @@
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-#include <string.h>
+#include <framework/globalfunctions/arrayprinter.h>
+#include <cstring>
 
 MessageQueueMessage::MessageQueueMessage() :
-		messageSize(this->HEADER_SIZE) {
+		messageSize(getMinimumMessageSize()) {
 	memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
 }
 
@@ -51,17 +51,15 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
 	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
 }
 
-//size_t MessageQueueMessage::getMinimumMessageSize() const {
-//	return this->HEADER_SIZE;
-//}
-
-void MessageQueueMessage::print() {
-	sif::debug << "MessageQueueMessage has size: " << this->messageSize <<
-			std::hex << std::endl;
-	for (uint8_t count = 0; count < this->messageSize; count++) {
-		sif::debug << (uint32_t) this->internalBuffer[count] << ":";
+void MessageQueueMessage::print(bool printWholeMessage) {
+	sif::debug << "MessageQueueMessage content: " << std::endl;
+	if(printWholeMessage) {
+	    arrayprinter::print(getData(), getMaximumMessageSize());
 	}
-	sif::debug << std::dec << std::endl;
+	else {
+	    arrayprinter::print(getData(), getMessageSize());
+	}
+
 }
 
 void MessageQueueMessage::clear() {
@@ -69,9 +67,18 @@ void MessageQueueMessage::clear() {
 }
 
 size_t MessageQueueMessage::getMessageSize() const {
-	return this->MAX_MESSAGE_SIZE;
+	return this->messageSize;
+}
+
+void MessageQueueMessage::setMessageSize(size_t messageSize) {
+	this->messageSize = messageSize;
+}
+
+size_t MessageQueueMessage::getMinimumMessageSize() const {
+    return this->MIN_MESSAGE_SIZE;
+}
+
+size_t MessageQueueMessage::getMaximumMessageSize() const {
+    return this->MAX_MESSAGE_SIZE;
 }
 
-//void MessageQueueMessage::setMessageSize(size_t messageSize) {
-//	this->messageSize = messageSize;
-//}
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index a994c3239..c4e82a94c 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -23,7 +23,7 @@
  *	receive messages from other tasks.
  *	@ingroup message_queue
  */
-class MessageQueueMessage: public MessageQueueMessageIF {
+class MessageQueueMessage: virtual public MessageQueueMessageIF {
 public:
 	/**
 	 * @brief	The class is initialized empty with this constructor.
@@ -74,11 +74,7 @@ public:
 	 * as small as possible.
 	 */
 	static const size_t MAX_DATA_SIZE = 24;
-	/**
-	 * @brief	This constants defines the size of the header,
-	 * 			which is added to every message.
-	 */
-	static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);
+
 	/**
 	 * @brief	This constant defines the maximum total size in bytes
 	 * 			of a sent message.
@@ -141,12 +137,14 @@ public:
 	void setSender(MessageQueueId_t setId) override;
 
 	virtual size_t getMessageSize() const override;
+	virtual void setMessageSize(size_t messageSize) override;
+	virtual size_t getMinimumMessageSize() const override;
+	virtual size_t getMaximumMessageSize() const override;
 
 	/**
-	 * @brief	This is a debug method that prints the content
-	 * 			(till messageSize) to the debug output.
+	 * @brief	This is a debug method that prints the content.
 	 */
-	void print();
+	void print(bool printWholeMessage);
 };
 
 #endif /* MESSAGEQUEUEMESSAGE_H_ */
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 19c69bfb6..c6c677c1e 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -18,7 +18,12 @@ typedef uint32_t MessageQueueId_t;
 
 class MessageQueueMessageIF {
 public:
-	static const MessageQueueId_t NO_QUEUE = 0xffffffff;
+	static const MessageQueueId_t NO_QUEUE = -1;
+    /**
+     * @brief   This constants defines the size of the header,
+     *          which is added to every message.
+     */
+    static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);
 
 	virtual ~MessageQueueMessageIF() {};
 
@@ -73,6 +78,10 @@ public:
 	 */
 	virtual size_t getMessageSize() const = 0;
 
+    virtual void setMessageSize(size_t messageSize) = 0;
+    virtual size_t getMinimumMessageSize() const = 0;
+    virtual size_t getMaximumMessageSize() const = 0;
+
 };
 
 
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index fb4d9eb67..ea7ef9e18 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -51,16 +51,14 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 		break;
 	default:
 		ipcStore->deleteData(ipcAddress);
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
 				MemoryMessage::CMD_MEMORY_LOAD);
 		queueToUse->sendMessage(lastSender, &reply);
 		return;
 	}
 	//Only reached on success
-	MessageQueueMessage message;
-	CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, 0);
+	CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
 	queueToUse->sendMessage(lastSender, &reply);
 	ipcStore->deleteData(ipcAddress);
 }
@@ -68,8 +66,7 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 void MemoryHelper::completeDump(ReturnValue_t errorCode,
 		const uint8_t* dataToCopy, const uint32_t size) {
 	busy = false;
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
 	switch (errorCode) {
 	case HasMemoryIF::DO_IT_MYSELF:
@@ -154,8 +151,7 @@ void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
 		completeLoad(returnCode, p_data, size, dataPointer);
 	} else {
 		//At least inform sender.
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
 				MemoryMessage::CMD_MEMORY_LOAD);
 		queueToUse->sendMessage(lastSender, &reply);
@@ -173,8 +169,7 @@ void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
 				reservedSpaceInIPC);
 		completeDump(returnCode, dataPointer, size);
 	} else {
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
 		queueToUse->sendMessage(lastSender, &reply);
 	}
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index 59a6d974f..030f1db3c 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -12,8 +12,7 @@ ModeHelper::~ModeHelper() {
 }
 
 ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	Mode_t mode;
 	Submode_t submode;
 	switch (command->getCommand()) {
@@ -79,8 +78,7 @@ void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
 
 void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 		Submode_t ownerSubmode) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
 	{
 		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
@@ -101,8 +99,7 @@ void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 
 void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
 		Submode_t ownerSubmode) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	if (theOneWhoCommandedAMode != parentQueueId
 			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
 	{
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 1378d7549..234a0bffb 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -31,8 +31,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	MessageQueueMessage message;
-	CommandMessage report(&message);
+	CommandMessage report;
 	MonitoringMessage::setLimitViolationReport(&report, storeId);
 	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
 }
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 8b91020f9..20e7e8ec2 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -102,8 +102,7 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 
 	ParameterMessage::setParameterDumpReply(&reply, id, address);
 
@@ -126,8 +125,7 @@ ReturnValue_t ParameterHelper::initialize() {
 
 void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
 		Command_t initialCommand) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	reply.setReplyRejected(reason, initialCommand);
 	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 }
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index a80a111fe..eee919841 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -163,8 +163,7 @@ void Fuse::setAllMonitorsToUnchecked() {
 }
 
 void Fuse::checkCommandQueue() {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return;
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index b1aea2700..5433acc93 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -74,8 +74,7 @@ void PowerSensor::setAllMonitorsToUnchecked() {
 }
 
 void PowerSensor::checkCommandQueue() {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return;
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index d774b4d5d..52f2c4741 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -309,8 +309,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 		break;
 	case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
 		uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		ModeSequenceMessage::setModeSequenceMessage(&reply,
 				ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
 		commandQueue->reply(&reply);
@@ -318,8 +317,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 		break;
 	case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
 		uint32_t free = modeTables.maxSize() - modeTables.size();
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		ModeSequenceMessage::setModeSequenceMessage(&reply,
 				ModeSequenceMessage::FREE_TABLE_SLOTS, free);
 		commandQueue->reply(&reply);
@@ -332,12 +330,11 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 }
 
 void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
-	MessageQueueMessage message;
 	if (status == RETURN_OK) {
-		CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, 0);
+		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
 		commandQueue->reply(&reply);
 	} else {
-		CommandMessage reply(&message, CommandMessage::REPLY_REJECTED, status, 0);
+		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0);
 		commandQueue->reply(&reply);
 	}
 }
@@ -620,8 +617,7 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 	for (uint8_t i = 0; i < count; i++) {
 		elements[i]->serialize(&storeBuffer, &size, maxSize, true);
 	}
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
 	if (commandQueue->reply(&reply) != RETURN_OK) {
 		IPCStore->deleteData(address);
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 5527f2150..737accefd 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -77,8 +77,7 @@ ReturnValue_t SubsystemBase::checkStateAgainstTable(
 }
 
 void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 
 	std::map<object_id_t, ChildInfo>::iterator iter;
 
@@ -129,7 +128,7 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
 			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
 		}
 		ReturnValue_t result = commandQueue->sendMessage(
-				iter->second.commandQueue, &message);
+				iter->second.commandQueue, &command);
 		if (result == RETURN_OK) {
 			++commandsOutstanding;
 		}
@@ -297,8 +296,7 @@ void SubsystemBase::setToExternalControl() {
 void SubsystemBase::announceMode(bool recursive) {
 	triggerEvent(MODE_INFO, mode, submode);
 	if (recursive) {
-		MessageQueueMessage message;
-		CommandMessage command(&message);
+		CommandMessage command;
 		ModeMessage::setModeMessage(&command,
 				ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
 		commandAllChildren(&command);
@@ -307,8 +305,7 @@ void SubsystemBase::announceMode(bool recursive) {
 
 void SubsystemBase::checkCommandQueue() {
 	ReturnValue_t result;
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 
 	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
 			result = commandQueue->receiveMessage(&command)) {
@@ -330,8 +327,7 @@ void SubsystemBase::checkCommandQueue() {
 
 		result = handleCommandMessage(&command);
 		if (result != RETURN_OK) {
-			MessageQueueMessage message;
-			CommandMessage reply(&message);
+			CommandMessage reply;
 			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
 					command.getCommand());
 			replyToCommand(&reply);
diff --git a/thermal/AbstractTemperatureSensor.cpp b/thermal/AbstractTemperatureSensor.cpp
index 759af87eb..41230f591 100644
--- a/thermal/AbstractTemperatureSensor.cpp
+++ b/thermal/AbstractTemperatureSensor.cpp
@@ -44,8 +44,7 @@ ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
 }
 
 void AbstractTemperatureSensor::handleCommandQueue() {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
 		result = healthHelper.handleHealthCommand(&command);
@@ -57,7 +56,7 @@ void AbstractTemperatureSensor::handleCommandQueue() {
 			return;
 		}
 		command.setToUnknownCommand();
-		commandQueue->reply(&message);
+		commandQueue->reply(&command);
 	}
 }
 
diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index 6e191fc12..b1cf38f2c 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -279,8 +279,7 @@ ReturnValue_t Heater::initialize() {
 }
 
 void Heater::handleQueue() {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
 		result = healthHelper.handleHealthCommand(&command);
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 4d29c10e6..bd6fa5b50 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -76,28 +76,18 @@ ReturnValue_t CommandingServiceBase::initialize() {
 }
 
 void CommandingServiceBase::handleCommandQueue() {
-    MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	ReturnValue_t result = RETURN_FAILED;
 	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
 			result = commandQueue->receiveMessage(&reply)) {
-		if(reply.getInternalMessage() == nullptr) {
-			// This should never happen unless the passed message maximum size
-			// is too small!
-			sif::error << "CommandingServiceBase::handleCommandMessage: Reply"
-					"does not satisfy minimum requirements for a command "
-					"message!" << std::endl;
-			continue;
-		}
 		handleCommandMessage(&reply);
 	}
 }
 
 
-void CommandingServiceBase::handleCommandMessage(CommandMessageIF* reply) {
+void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	bool isStep = false;
-	MessageQueueMessage message;
-	CommandMessage nextCommand(&message);
+	CommandMessage nextCommand;
 	CommandMapIter iter = commandMap.find(reply->getSender());
 
 	// handle unrequested reply first
@@ -303,8 +293,7 @@ ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
 void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
         CommandMapIter iter) {
     ReturnValue_t result = RETURN_OK;
-    MessageQueueMessage message;
-    CommandMessage command(&message);
+    CommandMessage command;
     iter->subservice = storedPacket->getSubService();
     result = prepareCommand(&command, iter->subservice,
             storedPacket->getApplicationData(),
@@ -316,7 +305,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 	case RETURN_OK:
 		if (command.getCommand() != CommandMessage::CMD_NONE) {
 			sendResult = commandQueue->sendMessage(iter.value->first,
-					&message);
+					&command);
 		}
 		if (sendResult == RETURN_OK) {
 			Clock::getUptime(&iter->uptimeOfStart);
@@ -338,7 +327,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 		if (command.getCommand() != CommandMessage::CMD_NONE) {
 			//Fire-and-forget command.
 			sendResult = commandQueue->sendMessage(iter.value->first,
-					&message);
+					&command);
 		}
 		if (sendResult == RETURN_OK) {
 			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
@@ -384,9 +373,8 @@ void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
 }
 
 
-void CommandingServiceBase::handleUnrequestedReply(CommandMessageIF* reply) {
-	CommandMessage commandReply(reply->getInternalMessage());
-	commandReply.clear();
+void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) {
+	reply->clear();
 }
 
 
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 05f50709b..54a0dc7a7 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -139,7 +139,7 @@ protected:
 	 * @param objectId Target object ID
 	 * @return
 	 */
-	virtual ReturnValue_t prepareCommand(CommandMessageIF *message,
+	virtual ReturnValue_t prepareCommand(CommandMessage* message,
 			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
 			uint32_t *state, object_id_t objectId) = 0;
 
@@ -168,9 +168,9 @@ protected:
 	 *   a failure verification message with the reason as the error parameter
 	 *   and the initial command as failure parameter 1.
 	 */
-	virtual ReturnValue_t handleReply(const CommandMessageIF *reply,
+	virtual ReturnValue_t handleReply(const CommandMessage* reply,
 			Command_t previousCommand, uint32_t *state,
-			CommandMessageIF *optionalNextCommand, object_id_t objectId,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
 			bool *isStep) = 0;
 
 	/**
@@ -182,7 +182,7 @@ protected:
 	 * Reply which is non-const so the default implementation can clear the
 	 * message.
 	 */
-	virtual void handleUnrequestedReply(CommandMessageIF *reply);
+	virtual void handleUnrequestedReply(CommandMessage* reply);
 
 	virtual void doPeriodicOperation();
 
@@ -310,7 +310,7 @@ private:
 
 	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
 
-	void handleCommandMessage(CommandMessageIF* reply);
+	void handleCommandMessage(CommandMessage* reply);
 	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
 			CommandMessageIF* nextCommand,CommandMessageIF* reply, bool& isStep);
 

From c7c49b4239fe42f4c4da47eba686c41ff687cf17 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 00:30:32 +0200
Subject: [PATCH 0486/1774] deleted command messge base

---
 ipc/CommandMessageBase.cpp             | 86 --------------------------
 ipc/CommandMessageBase.h               | 60 ------------------
 ipc/CommandMessageIF.h                 |  2 +-
 ipc/MessageQueueMessage.h              |  2 +-
 tmtcservices/CommandingServiceBase.cpp |  4 +-
 tmtcservices/CommandingServiceBase.h   |  2 +-
 6 files changed, 5 insertions(+), 151 deletions(-)
 delete mode 100644 ipc/CommandMessageBase.cpp
 delete mode 100644 ipc/CommandMessageBase.h

diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
deleted file mode 100644
index 745e6c5fc..000000000
--- a/ipc/CommandMessageBase.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-//#include <framework/ipc/CommandMessageBase.h>
-//#include <framework/ipc/CommandMessageCleaner.h>
-//#include <cstring>
-//
-//CommandMessageBase::CommandMessageBase(MessageQueueMessageIF *message):
-//		internalMessage(message) {
-//}
-//
-//Command_t CommandMessageBase::getCommand() const {
-//	Command_t command;
-//	std::memcpy(&command, internalMessage->getData(), sizeof(Command_t));
-//	return command;
-//}
-//
-//void CommandMessageBase::setCommand(Command_t command) {
-//	std::memcpy(internalMessage->getData(), &command, sizeof(Command_t));
-//}
-//
-//uint8_t CommandMessageBase::getMessageType() const {
-//	// first byte of command ID.
-//	return getCommand() >> 8 & 0xff;
-//}
-//
-//MessageQueueId_t CommandMessageBase::getSender() const {
-//	return internalMessage->getSender();
-//}
-//
-//uint8_t* CommandMessageBase::getBuffer() {
-//	return internalMessage->getBuffer();
-//}
-//
-//void CommandMessageBase::setSender(MessageQueueId_t setId) {
-//	internalMessage->setSender(setId);
-//}
-//
-//const uint8_t* CommandMessageBase::getBuffer() const {
-//	return internalMessage->getBuffer();
-//}
-//
-//// Header includes command ID.
-//uint8_t* CommandMessageBase::getData() {
-//	return internalMessage->getData() + sizeof(Command_t);
-//}
-//
-//// Header includes command ID.
-//const uint8_t* CommandMessageBase::getData() const {
-//	return internalMessage->getData() + sizeof(Command_t);
-//}
-//
-////void CommandMessageBase::setMessageSize(size_t messageSize) {
-////	//internalMessage->setMessageSize(messageSize);
-////}
-//
-//size_t CommandMessageBase::getMessageSize() const {
-//	return internalMessage->getMessageSize();
-//}
-//
-//MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
-//	return internalMessage;
-//}
-//
-////size_t CommandMessageBase::getMinimumMessageSize() const {
-////	return MINIMUM_COMMAND_MESSAGE_BASE_SIZE;
-////}
-//
-//void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
-//		Command_t initialCommand) {
-//	std::memcpy(getData(), &reason, sizeof(reason));
-//	std::memcpy(getData() + sizeof(reason), &initialCommand,
-//			sizeof(initialCommand));
-//}
-//
-//ReturnValue_t CommandMessageBase::getReplyRejectedReason(
-//		Command_t *initialCommand) const {
-//	ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
-//	std::memcpy(&reason, getData(), sizeof(reason));
-//	if(initialCommand != nullptr) {
-//		std::memcpy(initialCommand, getData() + sizeof(reason),
-//				sizeof(Command_t));
-//	}
-//	return reason;
-//}
-//
-//void CommandMessageBase::clear() {
-//	CommandMessageCleaner::clearCommandMessage(this);
-//}
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
deleted file mode 100644
index 59795114f..000000000
--- a/ipc/CommandMessageBase.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGEBASE_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGEBASE_H_
-#include <framework/ipc/CommandMessageIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
-
-/**
- * @brief	Base implementation of a generic command message, which has
- * 			a Command_t ID and message type ID in the header in addition
- * 			to the sender message queue ID.
- * @details
- * This is the base implementation serves as a base for other command messages
- * and which implements most functions required for MessageQueueMessageIF.
- * The only functions which have to be supplied by a specific command message
- * impelementations are the size related functions which are used for
- * size checks:
- *
- *  1. getMinimumMessageSize()
- *
- * The maximum message size generally depends on the buffer size of the passed
- * internal message.
- * Don't forget to set the message size of the passed message in the concrete
- * commandmessage implementation!
- */
-class CommandMessageBase: public CommandMessageIF {
-public:
-
-
-	CommandMessageBase(MessageQueueMessageIF* message);
-
-
-
-//	/*
-//	 * MessageQueueMessageIF functions, which generally just call the
-//	 * respective functions of the internal message queue message.
-//	 */
-//	virtual uint8_t * getBuffer() override;
-//	virtual const uint8_t * getBuffer() const override;
-//	virtual void setSender(MessageQueueId_t setId) override;
-//	virtual MessageQueueId_t getSender() const override;
-//	virtual uint8_t * getData() override;
-//	virtual const uint8_t* getData() const override;
-//	virtual size_t getMessageSize() const override;
-
-
-	//virtual MessageQueueMessageIF* getInternalMessage() const override;
-
-
-protected:
-	/**
-	 * @brief 	Pointer to the message containing the data.
-	 * @details
-	 * The command message does not actually own the memory containing a
-	 * message, it just oprates on it via a pointer to a message queue message.
-	 */
-	MessageQueueMessageIF* internalMessage = nullptr;
-};
-
-
-
-#endif /* FRAMEWORK_IPC_COMMANDMESSAGEBASE_H_ */
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index ca050c320..2cb6324eb 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -8,7 +8,7 @@
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef uint16_t Command_t;
 
-class CommandMessageIF: virtual public MessageQueueMessageIF {
+class CommandMessageIF {
 public:
     /**
      * Header consists of sender ID and command ID.
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index c4e82a94c..3d5d4283e 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -23,7 +23,7 @@
  *	receive messages from other tasks.
  *	@ingroup message_queue
  */
-class MessageQueueMessage: virtual public MessageQueueMessageIF {
+class MessageQueueMessage: public MessageQueueMessageIF {
 public:
 	/**
 	 * @brief	The class is initialized empty with this constructor.
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index bd6fa5b50..acf663893 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -146,8 +146,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 }
 
 void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
-		CommandMapIter iter, CommandMessageIF* nextCommand,
-		CommandMessageIF* reply, bool& isStep) {
+		CommandMapIter iter, CommandMessage* nextCommand,
+		CommandMessage* reply, bool& isStep) {
 	iter->command = nextCommand->getCommand();
 
 	// In case a new command is to be sent immediately, this is performed here.
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 54a0dc7a7..8806bd52b 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -312,7 +312,7 @@ private:
 
 	void handleCommandMessage(CommandMessage* reply);
 	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
-			CommandMessageIF* nextCommand,CommandMessageIF* reply, bool& isStep);
+			CommandMessage* nextCommand, CommandMessage* reply, bool& isStep);
 
 	void checkTimeout();
 };

From af24cc7d047cccf09ff5a002a86aa222b18b19ed Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 00:49:13 +0200
Subject: [PATCH 0487/1774] some bugfixes

---
 ipc/CommandMessage.cpp         | 82 +++++++++++++++++++---------------
 ipc/CommandMessage.h           | 30 +++++++------
 ipc/CommandMessageCleaner.cpp  | 20 ++++-----
 ipc/CommandMessageCleaner.h    |  6 +--
 osal/FreeRTOS/MessageQueue.cpp |  6 ---
 5 files changed, 74 insertions(+), 70 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 6aa433df0..2b0c34d5a 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -3,57 +3,57 @@
 #include <cstring>
 
 CommandMessage::CommandMessage() {
-	MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
+    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
     setCommand(CMD_NONE);
 }
 
 CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
         uint32_t parameter2) {
     MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
-	setCommand(command);
-	setParameter(parameter1);
-	setParameter2(parameter2);
+    setCommand(command);
+    setParameter(parameter1);
+    setParameter2(parameter2);
 }
 
 Command_t CommandMessage::getCommand() const {
-  Command_t command;
-  std::memcpy(&command, getData(), sizeof(Command_t));
-  return command;
+    Command_t command;
+    std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
+    return command;
 }
 
 void CommandMessage::setCommand(Command_t command) {
-  std::memcpy(getData(), &command, sizeof(Command_t));
+    std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
 }
 
 uint8_t CommandMessage::getMessageType() const {
-  // first byte of command ID.
-  return getCommand() >> 8 & 0xff;
+    // first byte of command ID.
+    return getCommand() >> 8 & 0xff;
 }
 
 uint32_t CommandMessage::getParameter() const {
-	uint32_t parameter1;
-	std::memcpy(&parameter1, MessageQueueMessage::getData(), sizeof(parameter1));
-	return parameter1;
+    uint32_t parameter1;
+    std::memcpy(&parameter1, this->getData(), sizeof(parameter1));
+    return parameter1;
 }
 
 void CommandMessage::setParameter(uint32_t parameter1) {
-	std::memcpy(MessageQueueMessage::getData(), &parameter1, sizeof(parameter1));
+    std::memcpy(this->getData(), &parameter1, sizeof(parameter1));
 }
 
 uint32_t CommandMessage::getParameter2() const {
-	uint32_t parameter2;
-	std::memcpy(&parameter2, MessageQueueMessage::getData() + sizeof(uint32_t),
-			sizeof(parameter2));
-	return parameter2;
+    uint32_t parameter2;
+    std::memcpy(&parameter2, this->getData() + sizeof(uint32_t),
+            sizeof(parameter2));
+    return parameter2;
 }
 
 void CommandMessage::setParameter2(uint32_t parameter2) {
-	std::memcpy(MessageQueueMessage::getData()  + sizeof(uint32_t), &parameter2,
-			sizeof(parameter2));
+    std::memcpy(this->getData()  + sizeof(uint32_t), &parameter2,
+            sizeof(parameter2));
 }
 
 size_t CommandMessage::getMinimumMessageSize() const {
-	return MINIMUM_COMMAND_MESSAGE_SIZE;
+    return MINIMUM_COMMAND_MESSAGE_SIZE;
 }
 
 void CommandMessage::clear() {
@@ -61,29 +61,37 @@ void CommandMessage::clear() {
 }
 
 bool CommandMessage::isClearedCommandMessage() {
-	return getCommand() == CMD_NONE;
+    return getCommand() == CMD_NONE;
 }
 
 void CommandMessage::setToUnknownCommand() {
-	Command_t initialCommand = getCommand();
-	this->clear();
-	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
+    Command_t initialCommand = getCommand();
+    this->clear();
+    setReplyRejected(UNKNOWN_COMMAND, initialCommand);
 }
 
 void CommandMessage::setReplyRejected(ReturnValue_t reason,
-      Command_t initialCommand) {
-  std::memcpy(getData(), &reason, sizeof(reason));
-  std::memcpy(getData() + sizeof(reason), &initialCommand,
-          sizeof(initialCommand));
+        Command_t initialCommand) {
+    std::memcpy(getData(), &reason, sizeof(reason));
+    std::memcpy(getData() + sizeof(reason), &initialCommand,
+            sizeof(initialCommand));
 }
 
 ReturnValue_t CommandMessage::getReplyRejectedReason(
-      Command_t *initialCommand) const {
-  ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
-  std::memcpy(&reason, getData(), sizeof(reason));
-  if(initialCommand != nullptr) {
-      std::memcpy(initialCommand, getData() + sizeof(reason),
-              sizeof(Command_t));
-  }
-  return reason;
+        Command_t *initialCommand) const {
+    ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
+    std::memcpy(&reason, getData(), sizeof(reason));
+    if(initialCommand != nullptr) {
+        std::memcpy(initialCommand, getData() + sizeof(reason),
+                sizeof(Command_t));
+    }
+    return reason;
+}
+
+uint8_t* CommandMessage::getData() {
+    return MessageQueueMessage::getData() + sizeof(Command_t);
+}
+
+const uint8_t* CommandMessage::getData() const {
+    return MessageQueueMessage::getData() + sizeof(Command_t);
 }
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index a319a0cf4..53df1c08b 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -50,6 +50,22 @@ public:
 	 */
 	virtual ~CommandMessage() {}
 
+    /**
+     * Read the DeviceHandlerCommand_t that is stored in the message,
+     * usually used after receiving.
+     *
+     * @return the Command stored in the Message
+     */
+    virtual Command_t getCommand() const override;
+    /**
+     * Set the command type of the message. Default implementation also
+     * sets the message type, which will be the first byte of the command ID.
+     * @param the Command to be sent
+     */
+    virtual void setCommand(Command_t command);
+
+    virtual uint8_t* getData() override;
+    virtual const uint8_t* getData() const override;
 	/**
 	 * Get the first parameter of the message
 	 * @return the first Parameter of the message
@@ -105,20 +121,6 @@ public:
 
     virtual void clear() override;
 
-    /**
-     * Read the DeviceHandlerCommand_t that is stored in the message,
-     * usually used after receiving.
-     *
-     * @return the Command stored in the Message
-     */
-    virtual Command_t getCommand() const override;
-    /**
-     * Set the command type of the message. Default implementation also
-     * sets the message type, which will be the first byte of the command ID.
-     * @param the Command to be sent
-     */
-    virtual void setCommand(Command_t command);
-
     /**
      * Extract message ID, which is the first byte of the command ID for the
      * default implementation.
diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
index 7153a8e71..23e6e1682 100644
--- a/ipc/CommandMessageCleaner.cpp
+++ b/ipc/CommandMessageCleaner.cpp
@@ -9,34 +9,34 @@
 #include <framework/tmstorage/TmStoreMessage.h>
 #include <framework/parameters/ParameterMessage.h>
 
-void CommandMessageCleaner::clearCommandMessage(CommandMessageIF* message) {
+void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
 	switch(message->getMessageType()){
 	case  messagetypes::MODE_COMMAND:
-		ModeMessage::clear(dynamic_cast<CommandMessage*>(message));
+		ModeMessage::clear(message);
 		break;
 	case messagetypes::HEALTH_COMMAND:
-		HealthMessage::clear(dynamic_cast<CommandMessage*>(message));
+		HealthMessage::clear(message);
 		break;
 	case messagetypes::MODE_SEQUENCE:
-		ModeSequenceMessage::clear(dynamic_cast<CommandMessage*>(message));
+		ModeSequenceMessage::clear(message);
 		break;
 	case messagetypes::ACTION:
-		ActionMessage::clear(dynamic_cast<CommandMessage*>(message));
+		ActionMessage::clear(message);
 		break;
 	case messagetypes::DEVICE_HANDLER_COMMAND:
-		DeviceHandlerMessage::clear(dynamic_cast<CommandMessage*>(message));
+		DeviceHandlerMessage::clear(message);
 		break;
 	case messagetypes::MEMORY:
-		MemoryMessage::clear(dynamic_cast<CommandMessage*>(message));
+		MemoryMessage::clear(message);
 		break;
 	case messagetypes::MONITORING:
-		MonitoringMessage::clear(dynamic_cast<CommandMessage*>(message));
+		MonitoringMessage::clear(message);
 		break;
 	case messagetypes::TM_STORE:
-		TmStoreMessage::clear(dynamic_cast<CommandMessage*>(message));
+		TmStoreMessage::clear(message);
 		break;
 	case messagetypes::PARAMETER:
-		ParameterMessage::clear(dynamic_cast<CommandMessage*>(message));
+		ParameterMessage::clear(message);
 		break;
 	default:
 		messagetypes::clearMissionMessage(message);
diff --git a/ipc/CommandMessageCleaner.h b/ipc/CommandMessageCleaner.h
index 0bd369a2c..48aaa4786 100644
--- a/ipc/CommandMessageCleaner.h
+++ b/ipc/CommandMessageCleaner.h
@@ -1,15 +1,15 @@
 #ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
 #define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
-#include <framework/ipc/CommandMessageIF.h>
+#include <framework/ipc/CommandMessage.h>
 
 namespace messagetypes {
 // Implemented in config.
-void clearMissionMessage(CommandMessageIF* message);
+void clearMissionMessage(CommandMessage* message);
 }
 
 class CommandMessageCleaner {
 public:
-	static void clearCommandMessage(CommandMessageIF* message);
+	static void clearCommandMessage(CommandMessage* message);
 };
 
 
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 464a4f16b..8eb669ed8 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -80,12 +80,6 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
-    if(message->getMessageSize() < maxMessageSize) {
-        sif::error << "MessageQueue::receiveMessage: Message size "
-                << message->getMessageSize() <<
-                " too small to receive data!" << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
 	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
 			message->getBuffer()), 0);
 	if (result == pdPASS){

From 16cbbb2693a18cc588661270c482325d4257e95f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 01:11:48 +0200
Subject: [PATCH 0488/1774] linux fixes

---
 osal/linux/MessageQueue.cpp | 15 +++------------
 osal/linux/MessageQueue.h   |  3 +--
 osal/linux/QueueFactory.cpp |  6 +++---
 3 files changed, 7 insertions(+), 17 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index c4b24a135..b11b9b6f1 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -281,8 +281,7 @@ ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message, maxMessageSize,
-			sentFrom,ignoreFault);
+	return sendMessageFromMessageQueue(sendTo,message, sentFrom,ignoreFault);
 
 }
 
@@ -297,22 +296,14 @@ bool MessageQueue::isDefaultDestinationSet() const {
 uint16_t MessageQueue::queueCounter = 0;
 
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessageIF *message, size_t maxSize,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
+		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
 	if(message == nullptr) {
 		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
 				"nullptr!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	if(message->getMaximumMessageSize() > maxSize) {
-		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size "
-				<< message->getMaximumMessageSize() << " too large for queue"
-				" with max. message size " << maxSize << "!"
-				<< std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
 	message->setSender(sentFrom);
 	int result = mq_send(sendTo,
 			reinterpret_cast<const char*>(message->getBuffer()),
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index 22725d185..8e3a5191d 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -149,8 +149,7 @@ protected:
 	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, size_t maxSize,
-			MessageQueueId_t sentFrom = NO_QUEUE,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault=false);
 private:
 	/**
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index 95264a429..8bd9d52c5 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -9,10 +9,10 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, size_t maxSize,
-			MessageQueueId_t sentFrom, bool ignoreFault) {
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
-			maxSize, sentFrom,ignoreFault);
+			sentFrom,ignoreFault);
 }
 
 QueueFactory* QueueFactory::instance() {

From 7f3607c3d998fb4473fd7b35b3ddf9ebff7b1dbb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 02:00:26 +0200
Subject: [PATCH 0489/1774] hk service fixed

---
 housekeeping/HousekeepingMessage.cpp | 66 ++++++++++------------------
 housekeeping/HousekeepingMessage.h   | 27 +++++-------
 ipc/CommandMessage.cpp               | 12 +++++
 ipc/CommandMessage.h                 | 14 ++----
 4 files changed, 50 insertions(+), 69 deletions(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 0d0f98603..64b07c17b 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,67 +1,47 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <cstring>
 
-HousekeepingMessage::HousekeepingMessage(): CommandMessage() {
-}
-
 HousekeepingMessage::~HousekeepingMessage() {}
 
-void HousekeepingMessage::setParameter(uint32_t parameter) {
-	std::memcpy(getData(), &parameter, sizeof(parameter));
-}
-
-uint32_t HousekeepingMessage::getParameter() const {
-	uint32_t parameter;
-	std::memcpy(&parameter, getData(), sizeof(parameter));
-	return parameter;
-}
-
-void HousekeepingMessage::setHkReportMessage(sid_t sid,
+void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
 		store_address_t storeId) {
-	CommandMessage::setCommand(HK_REPORT);
-	setSid(sid);
-	setParameter(storeId.raw);
+	message->setCommand(HK_REPORT);
+	message->setMessageSize(HK_MESSAGE_SIZE);
+	setSid(message, sid);
+	message->setParameter(storeId.raw);
 }
 
-void HousekeepingMessage::setHkDiagnosticsMessage(sid_t sid,
-		store_address_t storeId) {
-	CommandMessage::setCommand(DIAGNOSTICS_REPORT);
-	setSid(sid);
-	setParameter(storeId.raw);
+void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
+		sid_t sid, store_address_t storeId) {
+	message->setCommand(DIAGNOSTICS_REPORT);
+	setSid(message, sid);
+	setParameter(message, storeId.raw);
 }
-
-//size_t HousekeepingMessage::getMinimumMessageSize() const {
-//	return HK_MESSAGE_SIZE;
-//}
-
-sid_t HousekeepingMessage::getSid() const {
+sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 	sid_t sid;
-	std::memcpy(&sid.raw, CommandMessage::getData(), sizeof(sid.raw));
+	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
 	return sid;
 }
 
 
-sid_t HousekeepingMessage::getHkReportMessage(
-		store_address_t *storeIdToSet) const {
+sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
+		store_address_t *storeIdToSet) {
 	if(storeIdToSet != nullptr) {
-		*storeIdToSet = getParameter();
+		*storeIdToSet = getParameter(message);
 	}
-	return getSid();
+	return getSid(message);
 }
 
-void HousekeepingMessage::setSid(sid_t sid) {
-	std::memcpy(CommandMessage::getData(), &sid.raw, sizeof(sid.raw));
+void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
+	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
 }
 
 
-uint8_t* HousekeepingMessage::getData() {
-	return CommandMessage::getData() + sizeof(sid_t);
+void HousekeepingMessage::setParameter(CommandMessage *message,
+		uint32_t parameter) {
+	message->setParameter3(parameter);
 }
 
-const uint8_t* HousekeepingMessage::getData() const {
-	return CommandMessage::getData() + sizeof(sid_t);
-}
-
-void HousekeepingMessage::clear() {
-	// clear IPC store where it is needed.
+uint32_t HousekeepingMessage::getParameter(const CommandMessage *message) {
+	return message->getParameter3();
 }
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 8958201e8..e2a698057 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -34,7 +34,7 @@ union sid_t {
  * This message is slightly larger than regular command messages to accomodate
  * the uint64_t structure ID (SID).
  */
-class HousekeepingMessage : public CommandMessage {
+class HousekeepingMessage {
 public:
 
 	static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
@@ -45,7 +45,7 @@ public:
 	 * the message data, see CommandMessageIF and getInternalMessage().
 	 * @param message
 	 */
-	HousekeepingMessage();
+	HousekeepingMessage() = delete;
 	virtual ~HousekeepingMessage();
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
@@ -94,25 +94,22 @@ public:
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
+	static sid_t getSid(const CommandMessage* message);
 
-	void setParameter(uint32_t parameter);
-	uint32_t getParameter() const;
-	sid_t getSid() const;
+	static void setHkReportMessage(CommandMessage* message, sid_t sid,
+			store_address_t storeId);
+	static void setHkDiagnosticsMessage(CommandMessage* message, sid_t sid,
+			store_address_t storeId);
 
-	void setHkReportMessage(sid_t sid, store_address_t storeId);
-	void setHkDiagnosticsMessage(sid_t sid, store_address_t storeId);
 	//! Get the respective SID and store ID. Command ID can be used beforehand
 	//! to distinguish between diagnostics and regular HK packets
-	sid_t getHkReportMessage(store_address_t * storeIdToSet) const;
+	static sid_t getHkReportMessage(const CommandMessage* message,
+			store_address_t * storeIdToSet);
 
-	//virtual size_t getMinimumMessageSize() const override;
-	virtual void clear() override;
 private:
-
-	void setSid(sid_t sid);
-
-	virtual uint8_t* getData() override;
-	virtual const uint8_t* getData() const override;
+	static void setSid(CommandMessage* message, sid_t sid);
+	static void setParameter(CommandMessage* message, uint32_t parameter);
+	static uint32_t getParameter(const CommandMessage* message);
 };
 
 
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 2b0c34d5a..e1d4dfae1 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -52,6 +52,18 @@ void CommandMessage::setParameter2(uint32_t parameter2) {
             sizeof(parameter2));
 }
 
+uint32_t CommandMessage::getParameter3() const {
+    uint32_t parameter3;
+    std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
+            sizeof(parameter3));
+    return parameter3;
+}
+
+void CommandMessage::setParameter3(uint32_t parameter3) {
+    std::memcpy(this->getData()  + 2 * sizeof(uint32_t), &parameter3,
+            sizeof(parameter3));
+}
+
 size_t CommandMessage::getMinimumMessageSize() const {
     return MINIMUM_COMMAND_MESSAGE_SIZE;
 }
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 53df1c08b..021fa49ab 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -66,29 +66,21 @@ public:
 
     virtual uint8_t* getData() override;
     virtual const uint8_t* getData() const override;
+
 	/**
 	 * Get the first parameter of the message
 	 * @return the first Parameter of the message
 	 */
 	uint32_t getParameter() const;
-
 	/**
 	 * Set the first parameter of the message
 	 * @param the first parameter of the message
 	 */
 	void setParameter(uint32_t parameter1);
-
-	/**
-	 * Get the second parameter of the message
-	 * @return the second Parameter of the message
-	 */
 	uint32_t getParameter2() const;
-
-	/**
-	 * Set the second parameter of the message
-	 * @param the second parameter of the message
-	 */
 	void setParameter2(uint32_t parameter2);
+	uint32_t getParameter3() const;
+	void setParameter3(uint32_t parameter3);
 
 	/**
 	 * check if a message was cleared

From 6f2bb4125d7e4cd9baaf812c3dcd118883f65e71 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 02:02:57 +0200
Subject: [PATCH 0490/1774] bugfix

---
 housekeeping/HousekeepingMessage.cpp | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 64b07c17b..2335f03dd 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -8,21 +8,16 @@ void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
 	message->setCommand(HK_REPORT);
 	message->setMessageSize(HK_MESSAGE_SIZE);
 	setSid(message, sid);
-	message->setParameter(storeId.raw);
+	setParameter(message, storeId.raw);
 }
 
 void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
 		sid_t sid, store_address_t storeId) {
 	message->setCommand(DIAGNOSTICS_REPORT);
+	message->setMessageSize(HK_MESSAGE_SIZE);
 	setSid(message, sid);
 	setParameter(message, storeId.raw);
 }
-sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
-	sid_t sid;
-	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
-	return sid;
-}
-
 
 sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
 		store_address_t *storeIdToSet) {
@@ -32,6 +27,12 @@ sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
 	return getSid(message);
 }
 
+sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
+	sid_t sid;
+	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
+	return sid;
+}
+
 void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
 	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
 }

From 8d633bf1278e473a23ab67ee86458771a5c45bc2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 11:40:48 +0200
Subject: [PATCH 0491/1774] took over changed for singly linked list

---
 container/SinglyLinkedList.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 3c0078fc4..a78a14670 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -88,14 +88,15 @@ public:
 	ElementIterator begin() const {
 		return ElementIterator::Iterator(start);
 	}
-	typename ElementIterator::Iterator end() const {
+
+	ElementIterator end() const {
 		return ElementIterator::Iterator();
 	}
 
-	uint32_t getSize() const {
-		uint32_t size = 0;
+	size_t getSize() const {
+		size_t size = 0;
 		LinkedElement<T> *element = start;
-		while (element != NULL) {
+		while (element != nullptr) {
 			size++;
 			element = element->getNext();
 		}

From 0c32a964529105b611b600938c84df647f8fa0cf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 11:54:41 +0200
Subject: [PATCH 0492/1774] some more singly linked list improvements

---
 container/SinglyLinkedList.h | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index a78a14670..85a92e6a1 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -16,8 +16,13 @@ public:
 	class Iterator {
 	public:
 		LinkedElement<T> *value = nullptr;
+		//! Creates an uninitialized iterator which points to nullptr.
 		Iterator() {}
 
+		/**
+		 * Initialize iterator at specified linked element.
+		 * @param element
+		 */
 		Iterator(LinkedElement<T> *element) :
 				value(element) {
 		}
@@ -72,6 +77,11 @@ private:
 	LinkedElement *next;
 };
 
+/**
+ * @brief 	SinglyLinkedList data structure which keeps a pointer to its
+ * 			first element to perform all operations.
+ * @tparam T
+ */
 template<typename T>
 class SinglyLinkedList {
 public:
@@ -90,7 +100,11 @@ public:
 	}
 
 	ElementIterator end() const {
-		return ElementIterator::Iterator();
+		LinkedElement<T> *element = start;
+		while (element != nullptr) {
+			element = element->getNext();
+		}
+		return ElementIterator::Iterator(element);
 	}
 
 	size_t getSize() const {

From 08f25370f3505ebf39f26166b2bf5a4000c28461 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 12:03:52 +0200
Subject: [PATCH 0493/1774] moved typedefs into namespace

---
 tasks/FixedSlotSequence.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 7de1884c4..61883658a 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -6,9 +6,6 @@
 
 #include <set>
 
-using SlotList = std::multiset<FixedSequenceSlot>;
-using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
-
 /**
  * @brief	This class is the representation of a Polling Sequence Table in software.
  * @details
@@ -27,6 +24,8 @@ using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
  */
 class FixedSlotSequence {
 public:
+	using SlotList = std::multiset<FixedSequenceSlot>;
+	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
 
 	/**
 	 * @brief	The constructor of the FixedSlotSequence object.

From ba5b8bd682e1e3e36612a9c8974a4b27c8bf1151 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 26 Jun 2020 13:28:58 +0200
Subject: [PATCH 0494/1774] hybrid iter update

---
 container/HybridIterator.h | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index db1ce4bc8..f2fd6b288 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -1,5 +1,5 @@
-#ifndef HYBRIDITERATOR_H_
-#define HYBRIDITERATOR_H_
+#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
 
 #include <framework/container/ArrayList.h>
 #include <framework/container/SinglyLinkedList.h>
@@ -17,23 +17,23 @@ public:
 	}
 
 	HybridIterator(LinkedElement<T> *start) :
-		LinkedElement<T>::Iterator(start), value(
-					start->value), linked(true), end(NULL) {
+		LinkedElement<T>::Iterator(start), value(start->value),
+		linked(true) {
 
 	}
 
 	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
 			typename ArrayList<T, count_t>::Iterator end) :
-			ArrayList<T, count_t>::Iterator(start), value(start.value), linked(
-					false), end(end.value) {
+			ArrayList<T, count_t>::Iterator(start), value(start.value),
+			linked(false), end(end.value) {
 		if (value == this->end) {
 			value = NULL;
 		}
 	}
 
 	HybridIterator(T *firstElement, T *lastElement) :
-			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement), linked(
-					false), end(++lastElement) {
+			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
+			linked(false), end(++lastElement) {
 		if (value == end) {
 			value = NULL;
 		}
@@ -42,17 +42,17 @@ public:
 	HybridIterator& operator++() {
 		if (linked) {
 			LinkedElement<T>::Iterator::operator++();
-			if (LinkedElement<T>::Iterator::value != NULL) {
+			if (LinkedElement<T>::Iterator::value != nullptr) {
 				value = LinkedElement<T>::Iterator::value->value;
 			} else {
-				value = NULL;
+				value = nullptr;
 			}
 		} else {
 			ArrayList<T, count_t>::Iterator::operator++();
 			value = ArrayList<T, count_t>::Iterator::value;
 
 			if (value == end) {
-				value = NULL;
+				value = nullptr;
 			}
 		}
 		return *this;
@@ -64,11 +64,11 @@ public:
 		return tmp;
 	}
 
-	bool operator==(const HybridIterator& other) {
+	bool operator==(const HybridIterator& other) const {
 		return value == other.value;
 	}
 
-	bool operator!=(const HybridIterator& other) {
+	bool operator!=(const HybridIterator& other) const {
 		return !(*this == other);
 	}
 
@@ -87,4 +87,4 @@ private:
 	T *end = nullptr;
 };
 
-#endif /* HYBRIDITERATOR_H_ */
+#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */

From b81b458ba6cc5c6819b9dae6045e25469a1d43cc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 15:44:18 +0200
Subject: [PATCH 0495/1774] exec task if new init function, some corrections

---
 ipc/CommandMessage.cpp                 |  5 ++---
 osal/host/FixedTimeslotTask.cpp        |  2 +-
 osal/host/QueueMapManager.h            |  2 +-
 tasks/ExecutableObjectIF.h             | 13 +++++++++++--
 tasks/FixedSequenceSlot.cpp            |  1 +
 tmtcservices/CommandingServiceBase.cpp |  4 ++--
 6 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index e1d4dfae1..0aeaa79af 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -84,9 +84,8 @@ void CommandMessage::setToUnknownCommand() {
 
 void CommandMessage::setReplyRejected(ReturnValue_t reason,
         Command_t initialCommand) {
-    std::memcpy(getData(), &reason, sizeof(reason));
-    std::memcpy(getData() + sizeof(reason), &initialCommand,
-            sizeof(initialCommand));
+    setParameter(reason);
+    setParameter2(initialCommand);
 }
 
 ReturnValue_t CommandMessage::getReplyRejectedReason(
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 48d11843f..dac399f6b 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -92,7 +92,7 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 void FixedTimeslotTask::taskFunctionality() {
     // A local iterator for the Polling Sequence Table is created to
     // find the start time for the first entry.
-    SlotListIter slotListIter = pollingSeqTable.current;
+    FixedSlotSequence::SlotListIter slotListIter = pollingSeqTable.current;
     // Get start time for first entry.
     chron_ms interval(slotListIter->pollingTimeMs);
     auto currentStartTime {
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
index 34f0fc957..499b1622a 100644
--- a/osal/host/QueueMapManager.h
+++ b/osal/host/QueueMapManager.h
@@ -36,7 +36,7 @@ public:
 private:
 	//! External instantiation is forbidden.
 	QueueMapManager();
-	std::atomic<uint32_t> queueCounter = MessageQueueIF::NO_QUEUE + 1;
+	std::atomic<uint32_t> queueCounter = 1;
 	MutexIF* mapLock;
 	QueueMap queueMap;
 	static QueueMapManager* mqManagerInstance;
diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h
index 516b4084b..f66b53dab 100644
--- a/tasks/ExecutableObjectIF.h
+++ b/tasks/ExecutableObjectIF.h
@@ -43,9 +43,18 @@ public:
 	 * a reference to the executing task
 	 * @param task_ Pointer to the taskIF of this task
 	 */
-	virtual void setTaskIF(PeriodicTaskIF* task_) {
+	virtual void setTaskIF(PeriodicTaskIF* task_) {};
 
-	}
+	/**
+	 * This function will be called after the object was assigned to a specific
+	 * task.
+	 *
+	 * Example: Can be used to get task execution frequency.
+	 * The task is created after initialize() and the object ctors have been
+	 * called so the execution frequency can't be cached in initialize()
+	 * @return
+	 */
+	//virtual ReturnValue_t initializeAfterTaskCreation() = 0;
 };
 
 #endif /* EXECUTABLEOBJECTIF_H_ */
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index c46b4fc00..430ce0199 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -9,6 +9,7 @@ FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
 	if(executingTask != nullptr) {
 	    handler->setTaskIF(executingTask);
 	}
+	//handler->initializeAfterTaskCreation();
 }
 
 FixedSequenceSlot::~FixedSequenceSlot() {}
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index acf663893..5a48bd63a 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -109,8 +109,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	 * command as failure parameter 1 */
 	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
 			result == RETURN_FAILED) {
-		result = reply->getReplyRejectedReason(
-				reinterpret_cast<Command_t*>(&failureParameter1));
+		result = reply->getReplyRejectedReason();
+		failureParameter1 = iter->command;
 	}
 
 	switch (result) {

From d5d968a39365b2b0c285d8f283a054050e94be3b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 15:46:16 +0200
Subject: [PATCH 0496/1774] some more correctioons

---
 datapoollocal/LocalDataPoolManager.cpp | 24 ++++++++++++------------
 ipc/CommandMessage.cpp                 |  6 ++----
 2 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index bc57468a0..55d36a9a9 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -105,18 +105,18 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	}
 
 	// and now we set a HK message and send it the HK packet destination.
-	//HousekeepingMessage hkMessage;
-//	hkMessage.setHkReportMessage(sid, storeId);
-//	if(hkQueue == nullptr) {
-//	    return QUEUE_NOT_SET;
-//	}
-//
-//	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
-//	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
-//	}
-//	else {
-//	    result = hkQueue->sendToDefault(&hkMessage);
-//	}
+	CommandMessage hkMessage;
+	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+	if(hkQueue == nullptr) {
+	    return QUEUE_NOT_SET;
+	}
+
+	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
+	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
+	}
+	else {
+	    result = hkQueue->sendToDefault(&hkMessage);
+	}
 
 	return result;
 }
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 0aeaa79af..1470fe85f 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -90,11 +90,9 @@ void CommandMessage::setReplyRejected(ReturnValue_t reason,
 
 ReturnValue_t CommandMessage::getReplyRejectedReason(
         Command_t *initialCommand) const {
-    ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
-    std::memcpy(&reason, getData(), sizeof(reason));
+    ReturnValue_t reason = getParameter();
     if(initialCommand != nullptr) {
-        std::memcpy(initialCommand, getData() + sizeof(reason),
-                sizeof(Command_t));
+        *initialCommand = getParameter2();
     }
     return reason;
 }

From 003e70bf4785a8b9e57a8f8ab5f67ae0b0dfade3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 15:55:20 +0200
Subject: [PATCH 0497/1774] new initializeAfterTaskCreation()

---
 osal/FreeRTOS/PeriodicTask.cpp   |  3 ++-
 osal/linux/PeriodicPosixTask.cpp |  4 +++-
 osal/rtems/MultiObjectTask.cpp   |  3 ++-
 tasks/ExecutableObjectIF.h       | 25 +++++++++----------------
 tasks/FixedSequenceSlot.cpp      |  2 +-
 5 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 170eb0a48..2ebfebf40 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -94,7 +94,8 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
 	if(setTaskIF) {
 	     newObject->setTaskIF(this);
 	}
-	return HasReturnvaluesIF::RETURN_OK;
+	ReturnValue_t result = newObject->initializeAfterTaskCreation();
+	return result;
 }
 
 uint32_t PeriodicTask::getPeriodMs() const {
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index db4005b04..b811274b6 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -36,7 +36,9 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
 	if(setTaskIF) {
 	    newObject->setTaskIF(this);
 	}
-	return HasReturnvaluesIF::RETURN_OK;
+
+	ReturnValue_t result = newObject->initializeAfterTaskCreation();
+	return result;
 }
 
 ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index bb8c2c817..6b9c8c8ea 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -78,7 +78,8 @@ ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
-	return HasReturnvaluesIF::RETURN_OK;
+	ReturnValue_t result = newObject->initializeAfterTaskCreation();
+	return result;
 }
 
 uint32_t MultiObjectTask::getPeriodMs() const {
diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h
index f66b53dab..d716cdfbb 100644
--- a/tasks/ExecutableObjectIF.h
+++ b/tasks/ExecutableObjectIF.h
@@ -1,15 +1,5 @@
-/**
- * @file	ExecutableObjectIF.h
- *
- * @brief	This file contains the definition for the ExecutableObjectIF interface.
- *
- * @author	Bastian Baetz
- *
- * @date	12.03.2012
- */
-
-#ifndef EXECUTABLEOBJECTIF_H_
-#define EXECUTABLEOBJECTIF_H_
+#ifndef FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
+#define FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
 
 class PeriodicTaskIF;
 
@@ -20,6 +10,7 @@ class PeriodicTaskIF;
  * @brief	The interface provides a method to execute objects within a task.
  * @details	The performOperation method, that is required by the interface is
  * 			executed cyclically within a task context.
+ * @author  Bastian Baetz
  */
 class ExecutableObjectIF {
 public:
@@ -46,15 +37,17 @@ public:
 	virtual void setTaskIF(PeriodicTaskIF* task_) {};
 
 	/**
-	 * This function will be called after the object was assigned to a specific
-	 * task.
+	 * This function should be called after the object was assigned to a
+	 * specific task.
 	 *
 	 * Example: Can be used to get task execution frequency.
 	 * The task is created after initialize() and the object ctors have been
 	 * called so the execution frequency can't be cached in initialize()
 	 * @return
 	 */
-	//virtual ReturnValue_t initializeAfterTaskCreation() = 0;
+	virtual ReturnValue_t initializeAfterTaskCreation() {
+	    return HasReturnvaluesIF::RETURN_OK;
+	}
 };
 
-#endif /* EXECUTABLEOBJECTIF_H_ */
+#endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index 430ce0199..4331aadab 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -9,7 +9,7 @@ FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
 	if(executingTask != nullptr) {
 	    handler->setTaskIF(executingTask);
 	}
-	//handler->initializeAfterTaskCreation();
+	handler->initializeAfterTaskCreation();
 }
 
 FixedSequenceSlot::~FixedSequenceSlot() {}

From ae6314d8cd43a0ad8f0c1a7b9bd567be378203d3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 16:06:53 +0200
Subject: [PATCH 0498/1774] added task handle member

---
 tmtcservices/PusServiceBase.cpp | 11 +++++++++++
 tmtcservices/PusServiceBase.h   | 17 +++++++++++++----
 2 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index f5d1e30bd..82e5ff5cc 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -32,6 +32,10 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
 	return RETURN_OK;
 }
 
+void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle) {
+    this->taskHandle = taskHandle;
+}
+
 void PusServiceBase::handleRequestQueue() {
 	TmTcMessage message;
 	ReturnValue_t result = RETURN_FAILED;
@@ -108,3 +112,10 @@ ReturnValue_t PusServiceBase::initialize() {
 		return RETURN_FAILED;
 	}
 }
+
+ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
+    // If task parameters, for example task frequency are required, this
+    // function should be overriden and the system object task IF can
+    // be used to get those parameters.
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 39600c413..6d3d9bac6 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -96,11 +96,20 @@ public:
 	 * @return	@c RETURN_OK if the periodic performService was successful.
 	 * 			@c RETURN_FAILED else.
 	 */
-	ReturnValue_t performOperation(uint8_t opCode);
-	virtual uint16_t getIdentifier();
-	MessageQueueId_t getRequestQueue();
-	virtual ReturnValue_t initialize();
+	ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual uint16_t getIdentifier() override;
+	MessageQueueId_t getRequestQueue() override;
+	virtual ReturnValue_t initialize() override;
+
+	virtual void setTaskIF(PeriodicTaskIF* taskHandle) override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
 protected:
+	/**
+	 * @brief   Handle to the underlying task
+	 * @details
+	 * Will be set by setTaskIF(), which is called on task creation.
+	 */
+	PeriodicTaskIF* taskHandle = nullptr;
 	/**
 	 * The APID of this instance of the Service.
 	 */

From 044aa259e6298bf8accff8c8ab53cd373ed186bc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 16:37:55 +0200
Subject: [PATCH 0499/1774] dhb cached pst interval now

---
 devicehandlers/DeviceHandlerBase.cpp |  9 +++++++++
 devicehandlers/DeviceHandlerBase.h   | 11 +++++++++--
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 0442be89b..3994dc125 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1374,6 +1374,15 @@ ReturnValue_t DeviceHandlerBase::changeCollectionInterval(sid_t sid,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
+    // In this function, the task handle should be valid in any case.
+    // We still check to be 1000 % sure :-)
+    if(executingTask != nullptr) {
+        pstIntervalMs = executingTask->getPeriodMs();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
 	auto iter = deviceReplyMap.find(sid.ownerSetId);
 	if(iter != deviceReplyMap.end()) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 1290742c3..b2b4798d6 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -11,6 +11,8 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/power/PowerSwitchIF.h>
 #include <framework/ipc/MessageQueueIF.h>
+#include <framework/tasks/PeriodicTaskIF.h>
+
 #include <framework/action/ActionHelper.h>
 #include <framework/health/HealthHelper.h>
 #include <framework/parameters/ParameterHelper.h>
@@ -18,6 +20,7 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
 #include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
+
 #include <map>
 
 namespace Factory{
@@ -563,6 +566,8 @@ protected:
 
 	/** This is the counter value from performOperation(). */
 	uint8_t pstStep = 0;
+	uint32_t pstIntervalMs = 0;
+
 	/**
 	 * Wiretapping flag:
 	 *
@@ -1196,9 +1201,11 @@ private:
 
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
-	void parseReply(const uint8_t* receivedData,
-			size_t receivedDataLen);
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
 	DataSetIF* getDataSetHandle(sid_t sid) override;
+
+	void parseReply(const uint8_t* receivedData,
+	            size_t receivedDataLen);
 };
 
 #endif /* DEVICEHANDLERBASE_H_ */

From 691be0dcd4f6c8586b4a29b866bc7d9808d345c5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 16:39:55 +0200
Subject: [PATCH 0500/1774] dhb doc improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 3994dc125..cebe89531 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1375,8 +1375,8 @@ ReturnValue_t DeviceHandlerBase::changeCollectionInterval(sid_t sid,
 }
 
 ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
-    // In this function, the task handle should be valid in any case.
-    // We still check to be 1000 % sure :-)
+    // 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();
     }

From 48df3cbe8382423b671d7b5d651e3b623f4e2d90 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 16:43:02 +0200
Subject: [PATCH 0501/1774] csb comment improved

---
 tmtcservices/CommandingServiceBase.h | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 8806bd52b..37fa0a040 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -276,7 +276,6 @@ protected:
 	void checkAndExecuteFifo(CommandMapIter iter);
 
 private:
-
 	/**
 	 * This method handles internal execution of a command,
 	 * once it has been started by @sa{startExecution()} in the request
@@ -296,10 +295,13 @@ private:
 	void handleCommandQueue();
 
 	/**
+	 * @brief       Handler function for request queue
+	 * @details
 	 * Sequence of request queue handling:
 	 * isValidSubservice -> getMessageQueueAndObject -> startExecution
-	 * Generates Start Success Reports TM[1,3] in subfunction @sa{startExecution()}
-	 * or Start Failure Report TM[1,4] by using the TC Verification Service
+	 * Generates a Start Success Reports TM[1,3] in subfunction
+	 * @sa{startExecution()} or  a Start Failure Report TM[1,4] by using the
+	 * TC Verification Service.
 	 */
 	void handleRequestQueue();
 

From e2a36efce3d210c85c1ba924cd627a43b1cac922 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 16:47:58 +0200
Subject: [PATCH 0502/1774] csb changes taken over

---
 tmtcservices/CommandingServiceBase.cpp | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 5a48bd63a..f8af15af6 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -57,7 +57,9 @@ ReturnValue_t CommandingServiceBase::initialize() {
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
 	if (packetForwarding == nullptr or distributor == nullptr) {
-		return RETURN_FAILED;
+	    sif::error << "CommandingServiceBase::intialize: Packet source or "
+	            "packet destination invalid!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	distributor->registerService(this);
@@ -68,7 +70,9 @@ ReturnValue_t CommandingServiceBase::initialize() {
 	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 
 	if (IPCStore == nullptr or TCStore == nullptr) {
-		return RETURN_FAILED;
+	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
+	                    "not initialized yet!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	return RETURN_OK;
@@ -109,8 +113,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	 * command as failure parameter 1 */
 	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
 			result == RETURN_FAILED) {
-		result = reply->getReplyRejectedReason();
-		failureParameter1 = iter->command;
+	    result = reply->getReplyRejectedReason();
+	    failureParameter1 = iter->command;
 	}
 
 	switch (result) {
@@ -176,14 +180,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 	}
 	else {
 		if (isStep) {
-			nextCommand->clear();
+			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
 					iter->tcInfo.tcPacketId,
 					iter->tcInfo.tcSequenceControl, sendResult,
 					++iter->step, failureParameter1, failureParameter2);
 		} else {
-			nextCommand->clear();
+			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE,
 					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
@@ -318,7 +322,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 					storedPacket->getPacketSequenceControl();
 			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
 		} else {
-			command.clear();
+			command.clearCommandMessage();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
@@ -335,7 +339,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
 			checkAndExecuteFifo(iter);
 		} else {
-			command.clear();
+			command.clearCommandMessage();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
@@ -374,7 +378,7 @@ void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
 
 
 void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) {
-	reply->clear();
+	reply->clearCommandMessage();
 }
 
 

From 85cc936d5da669f8f74ea02c87a8204f4a6235c4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 16:50:45 +0200
Subject: [PATCH 0503/1774] added back clear CommandMessage function

---
 ipc/CommandMessage.cpp | 4 ++++
 ipc/CommandMessage.h   | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 1470fe85f..8c296abdd 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -68,6 +68,10 @@ size_t CommandMessage::getMinimumMessageSize() const {
     return MINIMUM_COMMAND_MESSAGE_SIZE;
 }
 
+void CommandMessage::clearCommandMessage() {
+    clear();
+}
+
 void CommandMessage::clear() {
     CommandMessageCleaner::clearCommandMessage(this);
 }
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 021fa49ab..d843e4c54 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -111,7 +111,9 @@ public:
     ReturnValue_t getReplyRejectedReason(
             Command_t* initialCommand = nullptr) const override;
 
+
     virtual void clear() override;
+    void clearCommandMessage();
 
     /**
      * Extract message ID, which is the first byte of the command ID for the

From 3a850018550b319476a4ec8b68bd75b035909df2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 30 Jun 2020 00:48:48 +0200
Subject: [PATCH 0504/1774] bit setter correction

---
 datapoollocal/LocalDataSet.cpp |  7 +++----
 datapoollocal/LocalDataSet.h   | 10 +++-------
 2 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 27ad4bc2a..3fc8592e9 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -42,7 +42,7 @@ ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
         if(registeredVariables[count]->isValid()) {
             // set validity buffer here.
             this->bitSetter(validityMask + validBufferIndex,
-                    validBufferIndexBit, true);
+                    validBufferIndexBit);
             if(validBufferIndexBit == 7) {
                 validBufferIndex ++;
                 validBufferIndexBit = 0;
@@ -83,13 +83,12 @@ ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position,
-        bool value) const {
+void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
         sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
         return;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1UL << shiftNumber;
+    *byte |= 1 << shiftNumber;
 }
 
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 48138e631..aea699d85 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -98,14 +98,10 @@ private:
 	LocalDataPoolManager* hkManager;
 
 	/**
-	 * Sets the bit at the bit-position of a byte provided by its address
-	 * to the specified value (zero or one).
-	 * @param byte Pointer to byte to bitset.
-	 * @param position MSB first, 0 to 7 possible.
-	 * @param value Value to set.
-	 * @return
+	 * Set n-th bit of a byte, with n being the position from 0
+	 * (most significant bit) to 7 (least significant bit)
 	 */
-	void bitSetter(uint8_t* byte, uint8_t position, bool value) const;
+	void bitSetter(uint8_t* byte, uint8_t position) const;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */

From 2de972bb8a9a35b81824f5c6bc5d00802c32dadd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 30 Jun 2020 15:51:19 +0200
Subject: [PATCH 0505/1774] const store accessor copy ctor fixx

---
 storagemanager/ConstStorageAccessor.h | 6 +++---
 storagemanager/StorageAccessor.h      | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index cf8ca08fe..020030a9e 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -80,13 +80,13 @@ public:
 	 * @return
 	 */
 	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor (ConstStorageAccessor&&);
+	ConstStorageAccessor(ConstStorageAccessor&&);
 
 	//! The copy ctor and copy assignemnt should be deleted implicitely
 	//! according to https://foonathan.net/2019/02/special-member-functions/
 	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
+	ConstStorageAccessor(const ConstStorageAccessor&) = delete;
 protected:
 	const uint8_t* constDataPointer = nullptr;
 	store_address_t storeId;
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index c5e383065..475b2f4fa 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -26,7 +26,7 @@ public:
 	 * @return
 	 */
 	StorageAccessor& operator= (StorageAccessor&&);
-	StorageAccessor (StorageAccessor&&);
+	StorageAccessor(StorageAccessor&&);
 
 	ReturnValue_t write(uint8_t *data, size_t size,
 		uint16_t offset = 0);

From 1820b5f95c4e3d03c06cd7c0ee9b2fa6639adac9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 30 Jun 2020 16:02:07 +0200
Subject: [PATCH 0506/1774] hotfix for copy ctor

---
 storagemanager/ConstStorageAccessor.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index cf8ca08fe..020030a9e 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -80,13 +80,13 @@ public:
 	 * @return
 	 */
 	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor (ConstStorageAccessor&&);
+	ConstStorageAccessor(ConstStorageAccessor&&);
 
 	//! The copy ctor and copy assignemnt should be deleted implicitely
 	//! according to https://foonathan.net/2019/02/special-member-functions/
 	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
+	ConstStorageAccessor(const ConstStorageAccessor&) = delete;
 protected:
 	const uint8_t* constDataPointer = nullptr;
 	store_address_t storeId;

From 837fecf8599a54102c59ea549ac56a876ff5c32b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 30 Jun 2020 21:22:26 +0200
Subject: [PATCH 0507/1774] added hk receiver obj id to dhb ctor

---
 datapoollocal/LocalDataPoolManager.cpp    | 66 +++++++++++++-----
 datapoollocal/LocalDataPoolManager.h      | 84 +++++++++++++++--------
 devicehandlers/AcceptsDeviceResponsesIF.h | 17 ++---
 devicehandlers/ChildHandlerBase.cpp       |  7 +-
 devicehandlers/ChildHandlerBase.h         |  6 +-
 devicehandlers/DeviceHandlerBase.cpp      | 34 +++++----
 devicehandlers/DeviceHandlerBase.h        | 23 ++++---
 housekeeping/AcceptsHkPacketsIF.h         | 11 +++
 tmtcservices/CommandingServiceBase.h      |  2 +-
 9 files changed, 169 insertions(+), 81 deletions(-)
 create mode 100644 housekeeping/AcceptsHkPacketsIF.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 55d36a9a9..bb06206e3 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,5 +1,6 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
+#include <framework/housekeeping/AcceptsHkPacketsIF.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 #include <framework/ipc/QueueFactory.h>
@@ -7,7 +8,7 @@
 #include <array>
 
 LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
-        uint32_t replyQueueDepth, bool appendValidityBuffer):
+        MessageQueueIF* queueToUse, bool appendValidityBuffer):
         appendValidityBuffer(appendValidityBuffer) {
 	if(owner == nullptr) {
 		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
@@ -24,16 +25,44 @@ LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
 	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
 	            "Could not set IPC store." << std::endl;
 	}
-	hkQueue = QueueFactory::instance()->createMessageQueue(replyQueueDepth,
-	        HousekeepingMessage::HK_MESSAGE_SIZE);
+	hkQueue = queueToUse;
+}
+
+ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
+        object_id_t hkDestination) {
+    if(queueToUse == nullptr) {
+        sif::error << "LocalDataPoolManager::initialize: Supplied queue "
+                "invalid!" << std::endl;
+    }
+    hkQueue = queueToUse;
+
+    if(hkDestination == objects::NO_OBJECT) {
+        return initializeHousekeepingPoolEntriesOnce();
+    }
+
+    AcceptsHkPacketsIF* hkReceiver =
+            objectManager->get<AcceptsHkPacketsIF>(hkDestination);
+    if(hkReceiver != nullptr) {
+        setHkPacketDestination(hkReceiver->getHkQueue());
+    }
+    else {
+        sif::warning << "LocalDataPoolManager::initialize: Could not retrieve"
+                " queue ID from HK destination object ID. Make sure it exists"
+                " and the object impements AcceptsHkPacketsIF!" << std::endl;
+    }
+    return initializeHousekeepingPoolEntriesOnce();
+}
+
+void LocalDataPoolManager::setHkPacketDestination(
+        MessageQueueId_t hkDestination) {
+    this->hkDestination = hkDestination;
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	if(not mapInitialized) {
-		ReturnValue_t result =
-				owner->initializePoolEntries(localDpMap);
+		ReturnValue_t result = owner->initializePoolEntries(localDpMap);
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			mapInitialized = true;
 		}
@@ -80,16 +109,12 @@ MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
-void LocalDataPoolManager::setHkPacketDestination(
-        MessageQueueId_t destinationQueueId) {
-    this->currentHkPacketDestination = destinationQueueId;
-}
-
 const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
     return owner;
 }
 
-ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
+ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
+        MessageQueueId_t sendTo) {
 	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
@@ -108,14 +133,21 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	CommandMessage hkMessage;
 	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
 	if(hkQueue == nullptr) {
-	    return QUEUE_NOT_SET;
+	    return QUEUE_OR_DESTINATION_NOT_SET;
 	}
 
-	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
-	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
+	if(sendTo != MessageQueueIF::NO_QUEUE) {
+	    result = hkQueue->sendMessage(sendTo, &hkMessage);
 	}
 	else {
-	    result = hkQueue->sendToDefault(&hkMessage);
+	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
+	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
+	                " Destination is not set properly!" << std::endl;
+	        return QUEUE_OR_DESTINATION_NOT_SET;
+	    }
+	    else {
+	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
+	    }
 	}
 
 	return result;
@@ -149,6 +181,9 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
     return result;
 }
 
+void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
+}
+
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
         store_address_t *storeId, LocalDataSet* dataSet) {
     size_t hkSize = dataSet->getSerializedSize();
@@ -177,4 +212,3 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
 }
 
 
-
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 9d072bf44..3841b99ce 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -44,18 +44,45 @@ public:
     static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
     static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
 
-    static constexpr ReturnValue_t QUEUE_NOT_SET = MAKE_RETURN_CODE(0x2);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
     //static constexpr ReturnValue_t SET_NOT_FOUND = MAKE_RETURN_CODE(0x3);
 
-	LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
-	        uint32_t replyQueueDepth = 20, bool appendValidityBuffer = true);
+    /**
+     * This constructor is used by a class which wants to implement
+     * a personal local data pool. The queueToUse can be supplied if it
+     * is already known.
+     *
+     * initialize() has to be called in any case before using the object!
+     * @param owner
+     * @param queueToUse
+     * @param appendValidityBuffer
+     */
+	LocalDataPoolManager(OwnsLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+	        bool appendValidityBuffer = true);
+	/**
+	 * Initializes the map by calling the map initialization function of the
+	 * owner abd assigns the queue to use.
+	 * @param queueToUse
+	 * @return
+	 */
+	ReturnValue_t initialize(MessageQueueIF* queueToUse,
+	        object_id_t hkDestination);
+	/**
+	 * This function is used to set the default HK packet destination.
+	 * This destination will usually only be set once.
+	 * @param hkDestination
+	 */
+	void setHkPacketDestination(MessageQueueId_t hkDestination);
+
 	virtual~ LocalDataPoolManager();
 
-	/* Copying forbidden */
-	LocalDataPoolManager(const LocalDataPoolManager &) = delete;
-	LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
-
-	ReturnValue_t generateHousekeepingPacket(sid_t sid);
+	/**
+	 * Generate a housekeeping packet with a given SID.
+	 * @param sid
+	 * @return
+	 */
+	ReturnValue_t generateHousekeepingPacket(sid_t sid, MessageQueueId_t sendTo
+	        = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
@@ -68,40 +95,43 @@ public:
 	 */
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
-	//! Set the queue for HK packets, which are sent unrequested.
-	void setHkPacketDestination(MessageQueueId_t destinationQueueId);
-
 	const OwnsLocalDataPoolIF* getOwner() const;
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
 
+    /* Copying forbidden */
+    LocalDataPoolManager(const LocalDataPoolManager &) = delete;
+    LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 private:
-	//! This is the map holding the actual data. Should only be initialized
-	//! once !
+	/** This is the map holding the actual data. Should only be initialized
+	 * once ! */
 	bool mapInitialized = false;
-	//! This specifies whether a validity buffer is appended at the end
-	//! of generated housekeeping packets.
+	/** This specifies whether a validity buffer is appended at the end
+	 * of generated housekeeping packets. */
 	bool appendValidityBuffer = true;
 
 	LocalDataPool localDpMap;
 
-	//! Every housekeeping data manager has a mutex to protect access
-	//! to it's data pool.
+	/** Every housekeeping data manager has a mutex to protect access
+	 * to it's data pool. */
 	MutexIF * mutex = nullptr;
-
-	//! The class which actually owns the manager (and its datapool).
+	/** The class which actually owns the manager (and its datapool). */
 	OwnsLocalDataPoolIF* owner = nullptr;
-
-	//! Queue used for communication, for example commands.
-	//! Is also used to send messages.
+	/**
+	 * @brief Queue used for communication, for example commands.
+	 * Is also used to send messages. Can be set either in the constructor
+     * or in the initialize() function.
+	 */
 	MessageQueueIF* hkQueue = nullptr;
 
-	//! HK replies will always be a reply to the commander, but HK packet
-	//! can be sent to another destination by specifying this message queue
-	//! ID, for example to a dedicated housekeeping service implementation.
-	MessageQueueId_t currentHkPacketDestination = MessageQueueIF::NO_QUEUE;
+	/**
+	 * HK replies will always be a reply to the commander, but HK packet
+	 * can be sent to another destination by specifying this message queue
+	 * ID, for example to a dedicated housekeeping service implementation.
+	 */
+	MessageQueueId_t hkDestination = MessageQueueIF::NO_QUEUE;
 
-	//! Global IPC store is used to store all packets.
+	/** Global IPC store is used to store all packets. */
 	StorageManagerIF* ipcStore = nullptr;
 	/**
 	 * Get the pointer to the mutex. Can be used to lock the data pool
diff --git a/devicehandlers/AcceptsDeviceResponsesIF.h b/devicehandlers/AcceptsDeviceResponsesIF.h
index c811158f6..fcf5237d2 100644
--- a/devicehandlers/AcceptsDeviceResponsesIF.h
+++ b/devicehandlers/AcceptsDeviceResponsesIF.h
@@ -1,15 +1,12 @@
-/**
- * @file	AcceptsDeviceResponsesIF.h
- * @brief	This file defines the AcceptsDeviceResponsesIF class.
- * @date	15.05.2013
- * @author	baetz
- */
-
-#ifndef ACCEPTSDEVICERESPONSESIF_H_
-#define ACCEPTSDEVICERESPONSESIF_H_
+#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
 
 #include <framework/ipc/MessageQueueSenderIF.h>
 
+/**
+ * This interface is used by the device handler to send a device response
+ * to the queue ID, which is returned in the implemented abstract method.
+ */
 class AcceptsDeviceResponsesIF {
 public:
 	/**
@@ -19,4 +16,4 @@ public:
 	virtual MessageQueueId_t getDeviceQueue() = 0;
 };
 
-#endif /* ACCEPTSDEVICERESPONSESIF_H_ */
+#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index c34846769..3e5bcc608 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -5,10 +5,11 @@
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * cookie,
 		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		uint32_t parent, FailureIsolationBase* customFdir, size_t cmdQueueSize) :
+		object_id_t hkDestination, uint32_t thermalStatePoolId,
+		uint32_t thermalRequestPoolId, uint32_t parent,
+		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
 		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
-			setDeviceSwitch,  thermalStatePoolId,
+		    hkDestination, setDeviceSwitch,  thermalStatePoolId,
 			thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir),
 			cmdQueueSize),
 		parentId(parent), childHandlerFdir(setObjectId) {
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 493b22ee2..100216314 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -8,9 +8,9 @@ class ChildHandlerBase: public DeviceHandlerBase {
 public:
 	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
 			CookieIF * cookie, uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-			uint32_t parent, FailureIsolationBase* customFdir = nullptr,
-			size_t cmdQueueSize = 20);
+			object_id_t hkDestination, uint32_t thermalStatePoolId,
+			uint32_t thermalRequestPoolId, uint32_t parent,
+			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
 
 	virtual ReturnValue_t initialize();
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index cebe89531..867bf415e 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -22,21 +22,21 @@ object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
 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) :
+		uint8_t setDeviceSwitch, object_id_t hkDestination,
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		actionHelper(this, nullptr), hkManager(this),
+		actionHelper(this, nullptr), hkManager(this, nullptr),
 		deviceThermalStatePoolId(thermalStatePoolId),
 		deviceThermalRequestPoolId(thermalRequestPoolId),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
-		switchOffWasReported(false), childTransitionDelay(5000),
-		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
-		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
+		switchOffWasReported(false), hkDestination(hkDestination),
+		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			MessageQueueMessage::MAX_MESSAGE_SIZE);
 	insertInCommandMap(RAW_COMMAND_ID);
@@ -173,7 +173,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-	result = hkManager.initializeHousekeepingPoolEntriesOnce();
+	result = hkManager.initialize(commandQueue, hkDestination);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -315,6 +315,12 @@ void DeviceHandlerBase::doStateMachine() {
 	case _MODE_WAIT_OFF: {
 		uint32_t currentUptime;
 		Clock::getUptime(&currentUptime);
+
+		if(powerSwitcher == nullptr) {
+		    setMode(MODE_OFF);
+		    return;
+		}
+
 		if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
 			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
 					0);
@@ -696,19 +702,23 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 
 	if (info->delayCycles != 0) {
 
-		if (info->periodic != 0) {
+		if (info->periodic != false) {
 			info->delayCycles = info->maxDelayCycles;
-		} else {
+		}
+		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 {
+	}
+	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.
@@ -719,7 +729,7 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 }
 
 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) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index b2b4798d6..3fdab9ed4 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -107,6 +107,7 @@ public:
 	 */
 	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
 			CookieIF * comCookie, uint8_t setDeviceSwitch,
+			object_id_t hkDestination = objects::NO_OBJECT,
 			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = nullptr,
@@ -652,11 +653,13 @@ protected:
 		size_t replyLen = 0; //!< Expected size of the reply.
 		//! if this is !=0, the delayCycles will not be reset to 0 but to
 		//! maxDelayCycles
-		bool periodic;
+		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;
+		DataSetIF* dataSet = nullptr;
+		float collectionInterval = 0.0;
+		uint32_t intervalCounter = 0;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -1035,18 +1038,19 @@ 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*/
+	/** the object used to set power switches */
 	PowerSwitchIF *powerSwitcher = nullptr;
 
+	/** Cached for initialize() */
+	object_id_t hkDestination = objects::NO_OBJECT;
+
 	/**
-	 * Used for timing out mode transitions.
-	 *
+	 * @brief   Used for timing out mode transitions.
 	 * Set when setMode() is called.
 	 */
 	uint32_t timeoutStart = 0;
@@ -1057,11 +1061,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]
 	 */
diff --git a/housekeeping/AcceptsHkPacketsIF.h b/housekeeping/AcceptsHkPacketsIF.h
new file mode 100644
index 000000000..f44e1d950
--- /dev/null
+++ b/housekeeping/AcceptsHkPacketsIF.h
@@ -0,0 +1,11 @@
+#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#include <framework/ipc/MessageQueueMessageIF.h>
+
+class AcceptsHkPacketsIF {
+public:
+    virtual~ AcceptsHkPacketsIF() {};
+    virtual MessageQueueId_t getHkQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 37fa0a040..700503c69 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -89,7 +89,7 @@ public:
 	 */
 	virtual MessageQueueId_t getCommandQueue();
 
-	virtual ReturnValue_t initialize();
+	virtual ReturnValue_t initialize() override;
 
 	/**
 	 * Implementation of ExecutableObjectIF function

From d7bff31a4cfd5e720847a0c9525a4099b97560ac Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Jul 2020 14:17:55 +0200
Subject: [PATCH 0508/1774] compiling again

---
 datapool/DataSetBase.cpp                |   8 +-
 datapool/DataSetBase.h                  |   5 +-
 datapool/PoolRawAccessHelper.cpp        |  20 ++--
 datapool/PoolRawAccessHelper.h          |   6 +-
 datapoolglob/GlobalPoolVariable.h       |  14 +--
 datapoolglob/GlobalPoolVector.h         |   4 +-
 datapoolglob/GlobalPoolVector.tpp       |  16 ++--
 datapoolglob/PIDReader.h                |   6 +-
 datapoolglob/PoolRawAccess.cpp          |  70 +++++++-------
 datapoolglob/PoolRawAccess.h            |  14 +--
 datapoollocal/LocalDataPoolManager.cpp  |   7 +-
 datapoollocal/LocalDataSet.cpp          |  12 ++-
 datapoollocal/LocalDataSet.h            |   6 +-
 datapoollocal/LocalPoolVariable.h       |   6 +-
 datapoollocal/LocalPoolVariable.tpp     |  12 +--
 datapoollocal/LocalPoolVector.h         |   5 +-
 datapoollocal/LocalPoolVector.tpp       |  16 ++--
 health/HealthTableIF.h                  |   2 +-
 power/PowerComponent.h                  |   9 --
 serialize/SerialBufferAdapter.cpp       |   8 +-
 serialize/SerialFixedArrayListAdapter.h |  35 +++----
 serialize/SerializeAdapter.h            |   3 +-
 serialize/SerializeAdapterInternal.h    | 118 ------------------------
 tmtcpacket/pus/TmPacketStored.cpp       |   2 +-
 24 files changed, 144 insertions(+), 260 deletions(-)
 delete mode 100644 serialize/SerializeAdapterInternal.h

diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
index b788d05da..55801eb12 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -131,11 +131,11 @@ ReturnValue_t DataSetBase::unlockDataPool() {
 }
 
 ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
-		const size_t maxSize, bool bigEndian) const {
+		const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t count = 0; count < fillCount; count++) {
 		result = registeredVariables[count]->serialize(buffer, size, maxSize,
-				bigEndian);
+		        streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
@@ -144,11 +144,11 @@ ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
 }
 
 ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
+        SerializeIF::Endianness streamEndianness) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t count = 0; count < fillCount; count++) {
 		result = registeredVariables[count]->deSerialize(buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
index 8f7d892a9..8eae6a095 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -105,10 +105,11 @@ public:
 
 	/* SerializeIF implementations */
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const size_t maxSize, bool bigEndian) const override;
+				const size_t maxSize,
+				SerializeIF::Endianness streamEndianness) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+	        SerializeIF::Endianness streamEndianness) override;
 
 	// SHOULDDO we could use a linked list of datapool variables
 	//!< This definition sets the maximum number of variables to
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 6e289303d..2324a56cd 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -24,8 +24,9 @@ PoolRawAccessHelper::~PoolRawAccessHelper() {
 }
 
 ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
-		const size_t max_size, bool bigEndian) {
-	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
+		const size_t max_size, SerializeIF::Endianness streamEndianness) {
+	SerializationArgs serializationArgs = {buffer, size, max_size,
+	        streamEndianness};
 	ReturnValue_t result = RETURN_OK;
 	size_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
@@ -44,9 +45,10 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 }
 
 ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
-		size_t * size, const size_t max_size, bool bigEndian) {
+		size_t * size, const size_t max_size,
+		SerializeIF::Endianness streamEndianness) {
 	ReturnValue_t result = RETURN_OK;
-	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
+	SerializationArgs argStruct = {buffer, size, max_size, streamEndianness};
 	size_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
 	uint8_t validityMask[validityMaskSize];
@@ -76,8 +78,8 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
 		bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
 	// Deserialize current pool ID from pool ID buffer
-	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
-			&poolIdBuffer,remainingParameters, false);
+	ReturnValue_t result = SerializeAdapter::deSerialize(&currentPoolId,
+			&poolIdBuffer,remainingParameters, SerializeIF::Endianness::MACHINE);
 	if(result != RETURN_OK) {
 		sif::debug << std::hex << "PoolRawAccessHelper: Error deSeralizing "
 				"pool IDs" << std::dec << std::endl;
@@ -109,8 +111,8 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 
 		GlobDataSet currentDataSet;
 		//debug << "Current array position: " << (int)arrayPosition << std::endl;
-		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,
-				&currentDataSet,PoolVariableIF::VAR_READ);
+		PoolRawAccess currentPoolRawAccess(currentPoolId, arrayPosition,
+				&currentDataSet, PoolVariableIF::VAR_READ);
 
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
@@ -137,7 +139,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 		}
 
 		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
-				argStruct.max_size, argStruct.bigEndian);
+				argStruct.max_size, argStruct.streamEndianness);
 		if (result != RETURN_OK) {
 			sif::debug << "Pool Raw Access Helper: Error serializing pool data with "
 					 "ID 0x" << std::hex << currentPoolId << " into send buffer "
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 52d9ebe5b..0d8f8d6d0 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -43,7 +43,7 @@ public:
 	 * 			@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t serialize(uint8_t ** buffer, size_t * size,
-			const size_t max_size, bool bigEndian);
+			const size_t max_size, SerializeIF::Endianness streamEndianness);
 
 	/**
 	 * Serializes data pool entries into provided buffer with the validity mask buffer
@@ -56,7 +56,7 @@ public:
 	 * 			@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, size_t * size,
-			const size_t max_size, bool bigEndian);
+			const size_t max_size, SerializeIF::Endianness streamEndianness);
 
 
 private:
@@ -71,7 +71,7 @@ private:
 		uint8_t ** buffer;
 		size_t * size;
 		const size_t max_size;
-		bool bigEndian;
+		SerializeIF::Endianness streamEndianness;
 	};
 	/**
 	 * Helper function to serialize single pool entries
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index 9e3eea0c9..b4aa6c4c1 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -181,18 +181,20 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override {
-		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
-				bigEndian);
+			const size_t max_size,
+			SerializeIF::Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, max_size,
+				streamEndianness);
 	}
 
 	virtual size_t getSerializedSize() const {
-		return SerializeAdapter<T>::getSerializedSize(&value);
+		return SerializeAdapter::getSerializedSize(&value);
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
-		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
+	        SerializeIF::Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+		        streamEndianness);
 	}
 };
 
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 930922281..0e03f77db 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -109,10 +109,10 @@ public:
 	const T &operator [](int i) const {return value[i];}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
+			size_t max_size, Endianness streamEndianness) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+	        Endianness streamEndianness) override;
 
 	/**
 	 * @brief	This is a call to read the array's values
diff --git a/datapoolglob/GlobalPoolVector.tpp b/datapoolglob/GlobalPoolVector.tpp
index 5710da574..ccf33138d 100644
--- a/datapoolglob/GlobalPoolVector.tpp
+++ b/datapoolglob/GlobalPoolVector.tpp
@@ -79,12 +79,13 @@ inline ReturnValue_t GlobPoolVector<T, vectorSize>::commitWithoutLock() {
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size, bool bigEndian) const {
+		size_t* size, size_t max_size,
+		SerializeIF::Endianness streamEndianness) const {
 	uint16_t i;
 	ReturnValue_t result;
 	for (i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
-				max_size, bigEndian);
+		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
+				max_size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
@@ -94,17 +95,18 @@ inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
 
 template<typename T, uint16_t vectorSize>
 inline size_t GlobPoolVector<T, vectorSize>::getSerializedSize() const {
-	return vectorSize * SerializeAdapter<T>::getSerializedSize(value);
+	return vectorSize * SerializeAdapter::getSerializedSize(value);
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t GlobPoolVector<T, vectorSize>::deSerialize(
-		const uint8_t** buffer, size_t* size, bool bigEndian) {
+		const uint8_t** buffer, size_t* size,
+		SerializeIF::Endianness streamEndianness) {
 	uint16_t i;
 	ReturnValue_t result;
 	for (i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
-				bigEndian);
+		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+		        streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
diff --git a/datapoolglob/PIDReader.h b/datapoolglob/PIDReader.h
index 1b337f288..a11160402 100644
--- a/datapoolglob/PIDReader.h
+++ b/datapoolglob/PIDReader.h
@@ -16,9 +16,9 @@ protected:
 	uint32_t parameterId;
 	uint8_t valid;
 	ReturnValue_t readWithoutLock() {
-		uint8_t arrayIndex = DataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T> *read_out = ::dataPool.getData<T>(
-				DataPool::PIDToDataPoolId(parameterId), arrayIndex);
+		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
+		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
+				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
 		if (read_out != NULL) {
 			valid = read_out->valid;
 			value = read_out->address[arrayIndex];
diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index 39cfd58c7..bec54ab37 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -145,27 +145,29 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 
 
 ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
-	if (typeSize + *size <= max_size) {
-		if (bigEndian) {
+        size_t maxSize, Endianness streamEndianness) const {
+    //TODO integer overflow
+    if (typeSize + *size <= maxSize) {
+#warning use endian swapper
+        if (1) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for (uint8_t count = 0; count < typeSize; count++) {
-				(*buffer)[count] = value[typeSize - count - 1];
-			}
+            for (uint8_t count = 0; count < typeSize; count++) {
+                (*buffer)[count] = value[typeSize - count - 1];
+            }
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(*buffer, value, typeSize);
+            memcpy(*buffer, value, typeSize);
 #endif
-		} else {
-			memcpy(*buffer, value, typeSize);
-		}
-		*size += typeSize;
-		(*buffer) += typeSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SerializeIF::BUFFER_TOO_SHORT;
-	}
+        } else {
+            memcpy(*buffer, value, typeSize);
+        }
+        *size += typeSize;
+        (*buffer) += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return SerializeIF::BUFFER_TOO_SHORT;
+    }
 }
 
 
@@ -231,28 +233,26 @@ size_t PoolRawAccess::getSerializedSize() const {
 }
 
 ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
-	// TODO: Needs to be tested!!!
-	if (*size >= typeSize) {
-		*size -= typeSize;
-		if (bigEndian) {
+        Endianness streamEndianness) {
+
+    if (*size >= typeSize) {
+        *size -= typeSize;
+        if (1) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for (uint8_t count = 0; count < typeSize; count++) {
-				value[count] = (*buffer)[typeSize - count - 1];
-			}
+            for (uint8_t count = 0; count < typeSize; count++) {
+                value[count] = (*buffer)[typeSize - count - 1];
+            }
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(value, *buffer, typeSize);
+            memcpy(value, *buffer, typeSize);
 #endif
-		}
-		else {
-			memcpy(value, *buffer, typeSize);
-		}
-		*buffer += typeSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return SerializeIF::STREAM_TOO_SHORT;
-	}
+        } else {
+            memcpy(value, *buffer, typeSize);
+        }
+        *buffer += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return SerializeIF::STREAM_TOO_SHORT;
+    }
 }
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index 60e3c71e3..ea07356e0 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -69,8 +69,13 @@ public:
 	 * @return - @c RETURN_OK if serialization was successfull
 	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
 	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+	        size_t maxSize, Endianness streamEndianness) const override;
+
+    size_t getSerializedSize() const override;
+
+    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+            Endianness streamEndianness) override;
 
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
@@ -130,11 +135,6 @@ public:
 	 */
 	uint16_t getSizeTillEnd() const;
 
-	size_t getSerializedSize() const;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
-
 	/**
 	 * @brief	This is a call to read the value from the global data pool.
 	 * @details
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index bb06206e3..781161384 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -173,7 +173,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
     }
     size_t size = 0;
     result = dataSet->serializeLocalPoolIds(&storePtr, &size,
-            expectedSize, false);
+            expectedSize, SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
         sif::error << "HousekeepingManager::generateSetStructurePacket: "
                 "Expected size is not equal to serialized size" << std::endl;
@@ -198,10 +198,11 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
 
     if(appendValidityBuffer) {
         result = dataSet->serializeWithValidityBuffer(&storePtr,
-                &size, hkSize, false);
+                &size, hkSize, SerializeIF::Endianness::MACHINE);
     }
     else {
-        result = dataSet->serialize(&storePtr, &size, hkSize, false);
+        result = dataSet->serialize(&storePtr, &size, hkSize,
+                SerializeIF::Endianness::MACHINE);
     }
 
     if(result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 3fc8592e9..72d79103a 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -32,7 +32,8 @@ ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
 }
 
 ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
-        size_t *size, const size_t maxSize, bool bigEndian) const {
+        size_t *size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
     uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
     uint8_t validityMask[validityMaskSize];
@@ -52,7 +53,7 @@ ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
             }
         }
         result = registeredVariables[count]->serialize(buffer, size, maxSize,
-                bigEndian);
+                streamEndianness);
         if (result != HasReturnvaluesIF::RETURN_OK) {
             return result;
         }
@@ -69,11 +70,12 @@ ReturnValue_t LocalDataSet::unlockDataPool() {
 }
 
 ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, const size_t maxSize, bool bigEndian) const {
+        size_t* size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
     for (uint16_t count = 0; count < fillCount; count++) {
         lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-        auto result = AutoSerializeAdapter::serialize(&currentPoolId, buffer,
-                size, maxSize, bigEndian);
+        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
+                size, maxSize, streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
                     " error!" << std::endl;
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index aea699d85..e997b7295 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -68,10 +68,12 @@ public:
 	 * @return
 	 */
 	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
-	        size_t* size, const size_t maxSize, bool bigEndian) const;
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
 
 	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
-            size_t* size, const size_t maxSize, bool bigEndian) const;
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
 protected:
 private:
 	/**
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 4b6e24aac..98782b8d2 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -84,11 +84,11 @@ public:
 	void setValid(bool validity) override;
 	uint8_t getValid() const;
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+	        SerializeIF::Endianness streamEndianness) override;
 
 	/**
 	 * @brief	This is a call to read the array's values
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 9dcd06992..7f9fbf137 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -133,20 +133,20 @@ inline uint8_t LocalPoolVar<T>::getValid() const {
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
-	return AutoSerializeAdapter::serialize(&value,
-			buffer, size ,max_size, bigEndian);
+		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
+	return SerializeAdapter::serialize(&value,
+			buffer, size ,max_size, streamEndianness);
 }
 
 template<typename T>
 inline size_t LocalPoolVar<T>::getSerializedSize() const {
-	return AutoSerializeAdapter::getSerializedSize(&value);
+	return SerializeAdapter::getSerializedSize(&value);
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
-		size_t* size, bool bigEndian) {
-	return AutoSerializeAdapter::deSerialize(&value, buffer, size, bigEndian);
+		size_t* size, SerializeIF::Endianness streamEndianness) {
+	return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
 template<typename T>
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index a8d0a7bb1..f65328949 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -114,10 +114,11 @@ public:
 	const T &operator [](int i) const;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
+			const size_t maxSize,
+			SerializeIF::Endianness streamEndiannes) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+	        SerializeIF::Endianness streamEndianness) override;
 
 	/**
 	 * @brief	This is a call to read the array's values
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index a18f83279..872c49ec9 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -125,11 +125,12 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size, bool bigEndian) const {
+		size_t* size, size_t maxSize,
+		SerializeIF::Endianness streamEndianness) const {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
-				max_size, bigEndian);
+		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
+				maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			break;
 		}
@@ -139,16 +140,17 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
 
 template<typename T, uint16_t vectorSize>
 inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
-	return vectorSize * SerializeAdapter<T>::getSerializedSize(value);
+	return vectorSize * SerializeAdapter::getSerializedSize(value);
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
-		const uint8_t** buffer, size_t* size, bool bigEndian) {
+		const uint8_t** buffer, size_t* size,
+		SerializeIF::Endianness streamEndianness) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
-				bigEndian);
+		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			break;
 		}
diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h
index c8d2c74a6..e4606286f 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -19,7 +19,7 @@ public:
 			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
 
 	virtual uint32_t getPrintSize() = 0;
-	virtual void printAll(uint8_t *pointer, uint32_t maxSize) = 0;
+	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
 
 protected:
 	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 1c550776d..61ab3674e 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -20,21 +20,12 @@ public:
 	float getMax();
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-<<<<<<< HEAD
-			const size_t max_size, bool bigEndian) const;
-
-	size_t getSerializedSize() const;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
-=======
 			size_t maxSize, Endianness streamEndianness) const override;
 
 	size_t getSerializedSize() const override;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			Endianness streamEndianness) override;
->>>>>>> upstream/mohr_serialize
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 69f40a349..1224bba1b 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -36,18 +36,18 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
 					maxSize, streamEndianness);
 		}
 		if (constBuffer != nullptr) {
-			memcpy(*buffer_, this->constBuffer, bufferLength);
+			memcpy(*buffer, this->constBuffer, bufferLength);
 		}
 		else if (buffer != nullptr) {
 			// This will propably be never reached, constBuffer should always be
 			// set if non-const buffer is set.
-			memcpy(*buffer_, this->buffer, bufferLength);
+			memcpy(*buffer, this->buffer, bufferLength);
 		}
 		else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
-		*size_ += bufferLength;
-		(*buffer_) += bufferLength;
+		*size += bufferLength;
+		(*buffer) += bufferLength;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 }
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 6ad154a80..196af67c9 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -39,30 +39,25 @@ public:
 	 */
 	template<typename... Args>
 	SerialFixedArrayListAdapter(Args... args) :
-	FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...)
-	{}
+	        FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(
+	        std::forward<Args>(args)...){}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const  override {
-		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
-				buffer, size, max_size, bigEndian);
-	}
+    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);
+    }
 
-	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<BUFFER_TYPE, count_t>::getSerializedSize(this);
+    }
 
-	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<BUFFER_TYPE, count_t>::deSerialize(this,
+                buffer, size, streamEndianness);
+    }
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, streamEndianness);
-	}
 };
 
-
-
 #endif /* SERIALFIXEDARRAYLISTADAPTER_H_ */
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index f80428618..2be39d5cb 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -2,8 +2,9 @@
 #define SERIALIZEADAPTER_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/serialize/EndianSwapper.h>
+#include <framework/container/IsDerivedFrom.h>
 #include <framework/serialize/SerializeIF.h>
-#include <framework/serialize/SerializeAdapterInternal.h>
 #include <type_traits>
 
  /**
diff --git a/serialize/SerializeAdapterInternal.h b/serialize/SerializeAdapterInternal.h
deleted file mode 100644
index c57af0c95..000000000
--- a/serialize/SerializeAdapterInternal.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/**
- * @file 	SerializeAdapterInternal.h
- *
- * @date	13.04.2020
- * @author	R. Mueller
- */
-
-#ifndef FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
-#define FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/container/IsDerivedFrom.h>
-#include <framework/serialize/EndianSwapper.h>
-
-/**
- * This template specialization will be chosen for fundamental types or
- * anything else not implementing SerializeIF, based on partial
- * template specialization.
- * @tparam T
- * @tparam
- */
-template<typename T, int>
-class SerializeAdapter_ {
-public:
-	/**
-	 *
-	 * @param object
-	 * @param buffer
-	 * @param size
-	 * @param max_size
-	 * @param bigEndian
-	 * @return
-	 */
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			size_t* size, const size_t max_size, bool bigEndian) {
-	    // function eventuelly serializes structs here.
-	    // does this work on every architecture?
-	    // static_assert(std::is_fundamental<T>::value);
-		size_t ignoredSize = 0;
-		if (size == nullptr) {
-			size = &ignoredSize;
-		}
-		if (sizeof(T) + *size <= max_size) {
-			T tmp;
-			if (bigEndian) {
-				tmp = EndianSwapper::swap<T>(*object);
-			} else {
-				tmp = *object;
-			}
-			memcpy(*buffer, &tmp, sizeof(T));
-			*size += sizeof(T);
-			(*buffer) += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::BUFFER_TOO_SHORT;
-		}
-	}
-
-	/**
-	 * Deserialize buffer into object
-	 * @param object [out] Object to be deserialized with buffer data
-	 * @param buffer contains the data. Non-Const pointer to non-const
-	 * 				 pointer to const data.
-	 * @param size Size to deSerialize. wil be decremented by sizeof(T)
-	 * @param bigEndian Specify endianness
-	 * @return
-	 */
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
-		T tmp;
-		if (*size >= sizeof(T)) {
-			*size -= sizeof(T);
-			memcpy(&tmp, *buffer, sizeof(T));
-			if (bigEndian) {
-				*object = EndianSwapper::swap<T>(tmp);
-			} else {
-				*object = tmp;
-			}
-			*buffer += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::STREAM_TOO_SHORT;
-		}
-	}
-
-	size_t getSerializedSize(const T * object) {
-		return sizeof(T);
-	}
-};
-
-/**
- * This template specialization will be chosen for class derived from
- * SerializeIF, based on partial template specialization.
- * @tparam T
- * @tparam
- */
-template<typename T>
-class SerializeAdapter_<T, true> {
-public:
-	ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		size_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		return object->serialize(buffer, size, max_size, bigEndian);
-	}
-
-	size_t getSerializedSize(const T* object) const {
-		return object->getSerializedSize();
-	}
-
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
-		return object->deSerialize(buffer, size, bigEndian);
-	}
-};
-
-#endif /* FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_ */
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 14cf6a03c..d6a4a69fb 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -84,7 +84,7 @@ void TmPacketStored::deletePacket() {
 void TmPacketStored::setStoreAddress(store_address_t setAddress) {
 	storeAddress = setAddress;
 	const uint8_t *temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	if (!checkAndSetStore()) {
 		return;
 	}

From 47b8ed2321c1a71743cb50fa555cbb3f6b2a3a62 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Jul 2020 14:34:16 +0200
Subject: [PATCH 0509/1774] split up long debug message

---
 datapoollocal/LocalDataPoolManager.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 781161384..9c70c74fb 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -47,8 +47,9 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
     }
     else {
         sif::warning << "LocalDataPoolManager::initialize: Could not retrieve"
-                " queue ID from HK destination object ID. Make sure it exists"
-                " and the object impements AcceptsHkPacketsIF!" << std::endl;
+                " queue ID from HK destination object ID. " << std::flush;
+        sif::warning << "Make sure it exists and the object impements "
+                "AcceptsHkPacketsIF!" << std::endl;
     }
     return initializeHousekeepingPoolEntriesOnce();
 }

From 3e069c34aa6a076f0394ab6bdf3c66f14294ba53 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 2 Jul 2020 16:29:29 +0200
Subject: [PATCH 0510/1774] datasetbase stays same f or now

---
 datapool/{StaticDataSetBase.cpp => DataSetBase.cpp} | 2 +-
 datapool/{StaticDataSetBase.h => DataSetBase.h}     | 6 +++---
 datapoolglob/GlobalDataSet.h                        | 2 +-
 datapoollocal/LocalDataSet.h                        | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)
 rename datapool/{StaticDataSetBase.cpp => DataSetBase.cpp} (98%)
 rename datapool/{StaticDataSetBase.h => DataSetBase.h} (97%)

diff --git a/datapool/StaticDataSetBase.cpp b/datapool/DataSetBase.cpp
similarity index 98%
rename from datapool/StaticDataSetBase.cpp
rename to datapool/DataSetBase.cpp
index 3815534e1..b788d05da 100644
--- a/datapool/StaticDataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -1,4 +1,4 @@
-#include <framework/datapool/StaticDataSetBase.h>
+#include <framework/datapool/DataSetBase.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 DataSetBase::DataSetBase() {
diff --git a/datapool/StaticDataSetBase.h b/datapool/DataSetBase.h
similarity index 97%
rename from datapool/StaticDataSetBase.h
rename to datapool/DataSetBase.h
index 708849ced..8f7d892a9 100644
--- a/datapool/StaticDataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DATAPOOL_STATICDATASETBASE_H_
-#define FRAMEWORK_DATAPOOL_STATICDATASETBASE_H_
+#ifndef FRAMEWORK_DATAPOOL_DATASETBASE_H_
+#define FRAMEWORK_DATAPOOL_DATASETBASE_H_
 #include <framework/datapool/DataSetIF.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/ipc/MutexIF.h>
@@ -146,4 +146,4 @@ private:
 	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
 };
 
-#endif /* FRAMEWORK_DATAPOOL_STATICDATASETBASE_H_ */
+#endif /* FRAMEWORK_DATAPOOL_DATASETBASE_H_ */
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index dec66dbc1..f0bf7daa8 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -1,7 +1,7 @@
 #ifndef DATASET_H_
 #define DATASET_H_
 
-#include <framework/datapool/StaticDataSetBase.h>
+#include <framework/datapool/DataSetBase.h>
 
 /**
  * @brief	The DataSet class manages a set of locally checked out variables
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 52a227e5a..aea699d85 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
+#include <framework/datapool/DataSetBase.h>
 #include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/StaticDataSetBase.h>
 #include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/serialize/SerializeIF.h>
 

From 099e6281ecdaccf39127da33e7b86b6eaa3f2335 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 2 Jul 2020 16:54:53 +0200
Subject: [PATCH 0511/1774] DataSetBase not bound to max size anymore

---
 datapool/DataSetBase.cpp             |  9 ++++++---
 datapool/DataSetBase.h               | 13 ++++++-------
 datapoolglob/GlobalDataSet.cpp       |  4 +++-
 datapoolglob/GlobalDataSet.h         |  6 ++++++
 datapoollocal/LocalDataSet.cpp       | 14 ++++++++++++--
 datapoollocal/LocalDataSet.h         | 10 ++++++++--
 datapoollocal/StaticLocalDataSet.cpp |  6 ++++++
 datapoollocal/StaticLocalDataSet.h   | 11 +++++++++++
 8 files changed, 58 insertions(+), 15 deletions(-)
 create mode 100644 datapoollocal/StaticLocalDataSet.cpp
 create mode 100644 datapoollocal/StaticLocalDataSet.h

diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
index b788d05da..3d38e1435 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -1,8 +1,11 @@
 #include <framework/datapool/DataSetBase.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-DataSetBase::DataSetBase() {
-	for (uint8_t count = 0; count < DATA_SET_MAX_SIZE; count++) {
+DataSetBase::DataSetBase(PoolVariableIF** registeredVariablesArray,
+        const size_t maxFillCount):
+        registeredVariables(registeredVariablesArray),
+        maxFillCount(maxFillCount) {
+	for (uint8_t count = 0; count < maxFillCount; count++) {
 		registeredVariables[count] = nullptr;
 	}
 }
@@ -21,7 +24,7 @@ ReturnValue_t DataSetBase::registerVariable(
 				"Pool variable is nullptr." << std::endl;
 		return DataSetIF::POOL_VAR_NULL;
 	}
-	if (fillCount >= DATA_SET_MAX_SIZE) {
+	if (fillCount >= maxFillCount) {
 		sif::error << "DataSet::registerVariable: "
 				"DataSet is full." << std::endl;
 		return DataSetIF::DATA_SET_FULL;
diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
index 8f7d892a9..12ae2b532 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -37,7 +37,8 @@ public:
 	 * 			supply a pointer to this dataset to PoolVariable
 	 * 			initializations to register pool variables.
 	 */
-	DataSetBase();
+	DataSetBase(PoolVariableIF** registeredVariablesArray,
+	        const size_t maxFillCount);
 	virtual~ DataSetBase();
 
 	/**
@@ -110,11 +111,6 @@ public:
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) override;
 
-	// SHOULDDO we could use a linked list of datapool variables
-	//!< This definition sets the maximum number of variables to
-	//! register in one DataSet.
-	static const uint8_t DATA_SET_MAX_SIZE = 63;
-
 protected:
 	/**
 	 * @brief	The fill_count attribute ensures that the variables
@@ -137,8 +133,11 @@ protected:
 
 	/**
 	 * @brief	This array represents all pool variables registered in this set.
+	 * Child classes can use a static or dynamic container to create
+	 * an array of registered variables and assign the first entry here.
 	 */
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE] = { };
+	PoolVariableIF** registeredVariables = nullptr;
+	const size_t maxFillCount = 0;
 
 private:
 	ReturnValue_t readVariable(uint16_t count);
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
index 9da8d524e..883f61577 100644
--- a/datapoolglob/GlobalDataSet.cpp
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -2,7 +2,9 @@
 #include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-GlobDataSet::GlobDataSet(): DataSetBase() {}
+GlobDataSet::GlobDataSet(): DataSetBase(
+        reinterpret_cast<PoolVariableIF**>(&registeredVariables),
+        DATA_SET_MAX_SIZE) {}
 
 // Don't do anything with your variables, they are dead already!
 // (Destructor is already called)
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index f0bf7daa8..519b08c09 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -61,6 +61,10 @@ public:
 	 */
 	void setEntriesValid(bool valid);
 
+	//!< This definition sets the maximum number of variables to
+	//! register in one DataSet.
+	static const uint8_t DATA_SET_MAX_SIZE = 63;
+
 private:
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
@@ -85,6 +89,8 @@ private:
 
 	void handleAlreadyReadDatasetCommit();
 	ReturnValue_t handleUnreadDatasetCommit();
+
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
 };
 
 #endif /* DATASET_H_ */
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 3fc8592e9..c5142bfc2 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -5,20 +5,30 @@
 #include <cmath>
 #include <cstring>
 
-LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner): DataSetBase() {
+LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner,
+        const size_t maxNumberOfVariables):
+        DataSetBase(poolVarList.data(), maxNumberOfVariables) {
+    poolVarList.reserve(maxNumberOfVariables);
+    poolVarList.resize(maxNumberOfVariables);
     if(hkOwner == nullptr) {
         sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
                 << std::endl;
+        return;
     }
     hkManager = hkOwner->getHkManagerHandle();
 }
 
-LocalDataSet::LocalDataSet(object_id_t ownerId): DataSetBase()  {
+LocalDataSet::LocalDataSet(object_id_t ownerId,
+        const size_t maxNumberOfVariables):
+        DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
+    poolVarList.reserve(maxNumberOfVariables);
+    poolVarList.resize(maxNumberOfVariables);
     OwnsLocalDataPoolIF* hkOwner = objectManager->get<OwnsLocalDataPoolIF>(
             ownerId);
     if(hkOwner == nullptr) {
         sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
                 << std::endl;
+        return;
     }
     hkManager = hkOwner->getHkManagerHandle();
 }
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index aea699d85..1a8941301 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -5,6 +5,8 @@
 #include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/serialize/SerializeIF.h>
 
+#include <vector>
+
 class LocalDataPoolManager;
 
 /**
@@ -35,7 +37,8 @@ public:
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSet(OwnsLocalDataPoolIF* hkOwner);
+	LocalDataSet(OwnsLocalDataPoolIF *hkOwner,
+	        const size_t maxNumberOfVariables);
 
 	/**
 	 * @brief	Constructor for users of local pool data. The passed pool
@@ -43,7 +46,8 @@ public:
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSet(object_id_t ownerId);
+	LocalDataSet(object_id_t ownerId,
+	        const size_t maxNumberOfVariables);
 
 	/**
 	 * @brief	The destructor automatically manages writing the valid
@@ -102,6 +106,8 @@ private:
 	 * (most significant bit) to 7 (least significant bit)
 	 */
 	void bitSetter(uint8_t* byte, uint8_t position) const;
+
+	std::vector<PoolVariableIF*> poolVarList;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/StaticLocalDataSet.cpp b/datapoollocal/StaticLocalDataSet.cpp
new file mode 100644
index 000000000..15d4251a4
--- /dev/null
+++ b/datapoollocal/StaticLocalDataSet.cpp
@@ -0,0 +1,6 @@
+#include <framework/datapoollocal/StaticLocalDataSet.h>
+
+
+
+
+
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
new file mode 100644
index 000000000..15a79aaef
--- /dev/null
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -0,0 +1,11 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#include <framework/datapool/DataSetBase.h>
+
+
+class StaticLocalDataSet: public DataSetBase {
+
+};
+
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */

From 72768a68152b3fb6778e7c90aead2b6f46d596ab Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 4 Jul 2020 00:51:49 +0200
Subject: [PATCH 0512/1774] started unix udp bridge

---
 osal/linux/TmTcUnixUdpBridge.cpp | 37 ++++++++++++++++++++++++++++++++
 osal/linux/TmTcUnixUdpBridge.h   | 28 ++++++++++++++++++++++++
 tmtcservices/TmTcBridge.cpp      |  6 +++---
 tmtcservices/TmTcBridge.h        |  2 +-
 4 files changed, 69 insertions(+), 4 deletions(-)
 create mode 100644 osal/linux/TmTcUnixUdpBridge.cpp
 create mode 100644 osal/linux/TmTcUnixUdpBridge.h

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
new file mode 100644
index 000000000..02c173122
--- /dev/null
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -0,0 +1,37 @@
+#include <framework/osal/linux/TmTcUnixUdpBridge.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
+		object_id_t ccsdsPacketDistributor):
+		TmTcBridge(objectId, ccsdsPacketDistributor) {
+	serverSocket = socket(AF_INET, SOCK_DGRAM, 0);
+	if(socket < 0) {
+		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
+				" UDP socket!" << std::endl;
+		// check errno here.
+		return;
+	}
+
+	serverAddress.sin_family = AF_INET;
+	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+	serverAddress.sin_port = htons(UDP_SERVER_PORT);
+	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
+			sizeof(serverSocketOptions));
+
+	int result = bind(serverSocket,
+			reinterpret_cast<struct sockaddr*>(&serverAddress),
+			sizeof(serverAddress));
+	if(result== -1) {
+		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
+				"local port " << UDP_SERVER_PORT << " to server socket!"
+				<< std::endl;
+		// check errno here.
+		return;
+	}
+
+
+
+}
+
+TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
+}
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
new file mode 100644
index 000000000..b84d9fe17
--- /dev/null
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -0,0 +1,28 @@
+#ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
+#define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
+
+#include <framework/tmtcservices/TmTcBridge.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+
+class TmTcUnixUdpBridge: public TmTcBridge {
+public:
+	static constexpr int UDP_SERVER_PORT = 7;
+	static constexpr int UDP_CLIENT_PORT = 2008;
+
+	TmTcUnixUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor);
+	virtual~ TmTcUnixUdpBridge();
+
+protected:
+
+private:
+	int serverSocket = 0;
+	const int serverSocketOptions = 0;
+	struct sockaddr_in clientAddress;
+	struct sockaddr_in serverAddress;
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index f9a7d3bc5..092884bbe 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -5,9 +5,9 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/globalfunctions/arrayprinter.h>
 
-TmTcBridge::TmTcBridge(object_id_t objectId_,
-        object_id_t ccsdsPacketDistributor_): SystemObject(objectId_),
-        ccsdsPacketDistributor(ccsdsPacketDistributor_)
+TmTcBridge::TmTcBridge(object_id_t objectId,
+        object_id_t ccsdsPacketDistributor): SystemObject(objectId),
+        ccsdsPacketDistributor(ccsdsPacketDistributor)
 {
     TmTcReceptionQueue = QueueFactory::instance()->
             createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 3e0432d8a..b50e9e1bc 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -22,7 +22,7 @@ public:
 	static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
 	static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
 
-	TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_);
+	TmTcBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor);
 	virtual ~TmTcBridge();
 
 	/**

From e0a3257f8b945da09aba28e784ebc2756e72f984 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 4 Jul 2020 23:20:29 +0200
Subject: [PATCH 0513/1774] even better output for unset max msg size

---
 osal/linux/MessageQueue.cpp | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index b11b9b6f1..3d5d7a5ae 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -62,22 +62,27 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		// Just an additional helpful printout :-)
 		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
 				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
-			// See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
-			// This happens if the msg_max value is not large enough
-			// It is ignored if the executable is run in privileged mode.
-			// Run the unlockRealtime script or grant the mode manually by using:
-			// sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
+			/*
+			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
+			This happens if the msg_max value is not large enough
+			It is ignored if the executable is run in privileged mode.
+		    Run the unlockRealtime script or grant the mode manually by using:
+			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
 
-			// Persistent solution for session:
-			// echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
+			Persistent solution for session:
+			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
 
-			// Permanent solution:
-			// sudo nano /etc/sysctl.conf
-			// Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
-			// Apply changes with: sudo sysctl -p
+			Permanent solution:
+			sudo nano /etc/sysctl.conf
+			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
+			Apply changes with: sudo sysctl -p
+			*/
 			sif::error << "MessageQueue::MessageQueue: Default MQ size "
 					<< defaultMqMaxMsg << " is too small for requested size "
 					<< messageDepth << std::endl;
+			sif::error << "This error can be fixed by setting the maximum "
+					"allowed message size higher!" << std::endl;
+
 		}
 		break;
 	}

From 571da391087a8c03220989ed61b1333543aef4ee Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 4 Jul 2020 23:52:44 +0200
Subject: [PATCH 0514/1774] continued new bridge

---
 osal/linux/TmTcUnixUdpBridge.cpp | 29 ++++++++++++++++++++++++++---
 osal/linux/TmTcUnixUdpBridge.h   | 12 ++++++++----
 2 files changed, 34 insertions(+), 7 deletions(-)

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 02c173122..c2c0c3531 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -2,8 +2,19 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
-		object_id_t ccsdsPacketDistributor):
+		object_id_t ccsdsPacketDistributor, uint16_t serverPort,
+		uint16_t clientPort):
 		TmTcBridge(objectId, ccsdsPacketDistributor) {
+	uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
+	if(serverPort != 0xFFFF) {
+		setServerPort = serverPort;
+	}
+
+	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
+	if(clientPort != 0xFFFF) {
+		setClientPort = clientPort;
+	}
+
 	serverSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	if(socket < 0) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
@@ -14,7 +25,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 
 	serverAddress.sin_family = AF_INET;
 	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-	serverAddress.sin_port = htons(UDP_SERVER_PORT);
+	serverAddress.sin_port = htons(setServerPort);
 	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
 			sizeof(serverSocketOptions));
 
@@ -23,7 +34,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 			sizeof(serverAddress));
 	if(result== -1) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
-				"local port " << UDP_SERVER_PORT << " to server socket!"
+				"local port " << setServerPort << " to server socket!"
 				<< std::endl;
 		// check errno here.
 		return;
@@ -35,3 +46,15 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 
 TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 }
+
+ReturnValue_t TmTcUnixUdpBridge::handleTc() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmTcUnixUdpBridge::receiveTc(uint8_t **recvBuffer, size_t *size) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index b84d9fe17..ab2e2d674 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -8,14 +8,18 @@
 
 class TmTcUnixUdpBridge: public TmTcBridge {
 public:
-	static constexpr int UDP_SERVER_PORT = 7;
-	static constexpr int UDP_CLIENT_PORT = 2008;
+	static constexpr int DEFAULT_UDP_SERVER_PORT = 7;
+	static constexpr int DEFAULT_UDP_CLIENT_PORT = 2008;
 
-	TmTcUnixUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor);
+	TmTcUnixUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor,
+			 uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
 	virtual~ TmTcUnixUdpBridge();
 
 protected:
-
+	virtual ReturnValue_t handleTc() override;
+	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer,
+			size_t * size) override;
+	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
 private:
 	int serverSocket = 0;
 	const int serverSocketOptions = 0;

From 5cee12684142153d01f31627b0bd9b17bcee31d2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 00:06:30 +0200
Subject: [PATCH 0515/1774] formatting

---
 osal/linux/TmTcUnixUdpBridge.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index c2c0c3531..045e475ac 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -32,7 +32,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	int result = bind(serverSocket,
 			reinterpret_cast<struct sockaddr*>(&serverAddress),
 			sizeof(serverAddress));
-	if(result== -1) {
+	if(result == -1) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
 				"local port " << setServerPort << " to server socket!"
 				<< std::endl;

From c160000027bbe6311fd9c0d318c62a51179129ac Mon Sep 17 00:00:00 2001
From: Ulrich Mohr <mohr@irs.uni-stuttgart.de>
Date: Fri, 3 Jul 2020 12:44:08 +0200
Subject: [PATCH 0516/1774] Corrected filename of EndianConverter.h

---
 memory/MemoryHelper.cpp                          | 2 +-
 serialize/{EndianSwapper.h => EndianConverter.h} | 0
 serialize/SerializeAdapter.h                     | 3 +--
 3 files changed, 2 insertions(+), 3 deletions(-)
 rename serialize/{EndianSwapper.h => EndianConverter.h} (100%)

diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 7c8f76107..b07f450c4 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -2,7 +2,7 @@
 #include <framework/memory/MemoryHelper.h>
 #include <framework/memory/MemoryMessage.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serialize/EndianSwapper.h>
+#include <framework/serialize/EndianConverter.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
diff --git a/serialize/EndianSwapper.h b/serialize/EndianConverter.h
similarity index 100%
rename from serialize/EndianSwapper.h
rename to serialize/EndianConverter.h
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 2be39d5cb..bb364eae5 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -2,8 +2,7 @@
 #define SERIALIZEADAPTER_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/EndianSwapper.h>
-#include <framework/container/IsDerivedFrom.h>
+#include <framework/serialize/EndianConverter.h>
 #include <framework/serialize/SerializeIF.h>
 #include <type_traits>
 

From 24240b6c7d73d124af1caae18ead919ccde203c8 Mon Sep 17 00:00:00 2001
From: Ulrich Mohr <mohr@irs.uni-stuttgart.de>
Date: Fri, 3 Jul 2020 15:46:00 +0200
Subject: [PATCH 0517/1774] Documented EndianConverter and changed length to
 size_t

---
 serialize/EndianConverter.h | 59 ++++++++++++++++++++++++++++++-------
 1 file changed, 48 insertions(+), 11 deletions(-)

diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index 4ab28ecf9..81117a5e7 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -5,15 +5,41 @@
 #include <cstring>
 #include <iostream>
 
+/**
+ * Helper class to convert variables or bitstreams between machine
+ * endian and either big or little endian.
+ * Machine endian is the endianness used by the machine running the
+ * program and is one of big or little endian. As this is portable
+ * code, it is not known at coding time which it is. At compile time
+ * it is however, which is why this is implemented using compiler
+ * macros and translates to a copy operation at runtime.
+ *
+ * This changes the layout of multi-byte variables in the machine's
+ * memory. In most cases, you should not need to use this class.
+ * Probably what you are looking for is the SerializeAdapter.
+ * If you still decide you need this class, please read and understand
+ * the code first.
+ *
+ * The order of the individual bytes of the multi-byte variable is
+ * reversed, the byte at the highest address is moved to the lowest
+ * address and vice versa, same for the bytes in between.
+ *
+ * Note that the conversion is also its inversion, that is converting
+ * from machine to a specified endianness is the same operation as
+ * converting from specified to machine (I looked it up, mathematicians
+ * would call it an involution):
+ *
+ * X == convertBigEndian(convertBigEndian(X))
+ *
+ * Thus, there is only one function supplied to do the conversion.
+ */
 class EndianConverter {
 private:
 	EndianConverter() {};
 public:
 	/**
-	 * Swap the endianness of a variable with arbitrary type
-	 * @tparam T Type of variable
-	 * @param in variable
-	 * @return Variable with swapped endianness
+	 * Convert a typed variable between big endian and machine endian.
+	 * Intended for plain old datatypes.
 	 */
 	template<typename T>
 	static T convertBigEndian(T in) {
@@ -23,7 +49,7 @@ public:
 		T tmp;
 		uint8_t *pointerOut = (uint8_t*) &tmp;
 		uint8_t *pointerIn = (uint8_t*) &in;
-		for (uint8_t count = 0; count < sizeof(T); count++) {
+		for (size_t count = 0; count < sizeof(T); count++) {
 			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
 		}
 		return tmp;
@@ -34,12 +60,16 @@ public:
 #endif
 	}
 
+	/**
+	 * convert a bytestream representing a single variable between big endian
+	 * and machine endian.
+	 */
 	static void convertBigEndian(uint8_t *out, const uint8_t *in,
-			uint32_t size) {
+			size_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		for (uint8_t count = 0; count < size; count++) {
+		for (size_t count = 0; count < size; count++) {
 			out[size - count - 1] = in[count];
 		}
 		return;
@@ -49,7 +79,10 @@ public:
 #endif
 	}
 
-
+	/**
+	 * Convert a typed variable between little endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
 	template<typename T>
 	static T convertLittleEndian(T in) {
 #ifndef BYTE_ORDER_SYSTEM
@@ -58,7 +91,7 @@ public:
 			T tmp;
 			uint8_t *pointerOut = (uint8_t *) &tmp;
 			uint8_t *pointerIn = (uint8_t *) &in;
-			for (uint8_t count = 0; count < sizeof(T); count++) {
+			for (size_t count = 0; count < sizeof(T); count++) {
 				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
 			}
 			return tmp;
@@ -68,12 +101,16 @@ public:
 	#error Unknown Byte Order
 	#endif
 	}
+	/**
+	 * convert a bytestream representing a single variable between little endian
+	 * and machine endian.
+	 */
 	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
-			uint32_t size) {
+			size_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 	#error BYTE_ORDER_SYSTEM not defined
 	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			for (uint8_t count = 0; count < size; count++) {
+			for (size_t count = 0; count < size; count++) {
 				out[size - count - 1] = in[count];
 			}
 			return;

From 1a177d2efa05f62c86fe33352cf3608d1b96340b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 00:28:06 +0200
Subject: [PATCH 0518/1774] integrated pool raw access serialize changes

---
 datapoolglob/PoolRawAccess.cpp | 84 +++++++++++++---------------------
 datapoolglob/PoolRawAccess.h   |  6 +--
 2 files changed, 34 insertions(+), 56 deletions(-)

diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index bec54ab37..cd4138d3d 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -1,7 +1,7 @@
 #include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/datapoolglob/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/Endiness.h>
+#include <framework/serialize/EndianConverter.h>
 
 #include <cstring>
 
@@ -130,15 +130,7 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 		return DATA_POOL_ACCESS_FAILED;
 	if (typeSize > max_size)
 		return INCORRECT_SIZE;
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-	for (uint8_t count = 0; count < typeSize; count++) {
-		buffer[count] = data_ptr[typeSize - count - 1];
-	}
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-	memcpy(buffer, data_ptr, typeSize);
-#endif
+	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
 	*writtenBytes = typeSize;
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -146,21 +138,18 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 
 ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
         size_t maxSize, Endianness streamEndianness) const {
-    //TODO integer overflow
     if (typeSize + *size <= maxSize) {
-#warning use endian swapper
-        if (1) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-            for (uint8_t count = 0; count < typeSize; count++) {
-                (*buffer)[count] = value[typeSize - count - 1];
-            }
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-            memcpy(*buffer, value, typeSize);
-#endif
-        } else {
+    	switch(streamEndianness) {
+    	case(Endianness::BIG):
+    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::MACHINE):
+    	default:
             memcpy(*buffer, value, typeSize);
+            break;
         }
         *size += typeSize;
         (*buffer) += typeSize;
@@ -175,11 +164,11 @@ Type PoolRawAccess::getType() {
 	return type;
 }
 
-uint8_t PoolRawAccess::getSizeOfType() {
+size_t PoolRawAccess::getSizeOfType() {
 	return typeSize;
 }
 
-uint8_t PoolRawAccess::getArraySize(){
+size_t PoolRawAccess::getArraySize(){
 	return arraySize;
 }
 
@@ -191,22 +180,14 @@ PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
 	return readWriteMode;
 }
 
-ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t* buffer,
-		uint32_t setSize) {
+ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
+		size_t setSize) {
 	if (typeSize == setSize) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		for (uint8_t count = 0; count < typeSize; count++) {
-			value[count] = buffer[typeSize - count - 1];
-		}
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		memcpy(value, buffer, typeSize);
-#endif
+		EndianConverter::convertBigEndian(value, buffer, typeSize);
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: Internal"
-				<< (uint32_t) typeSize << ", Requested: " << setSize
+		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
+				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
 				<< std::endl;
 		return INCORRECT_SIZE;
 	}
@@ -232,27 +213,24 @@ size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
 }
 
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
         Endianness streamEndianness) {
 
     if (*size >= typeSize) {
-        *size -= typeSize;
-        if (1) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-            for (uint8_t count = 0; count < typeSize; count++) {
-                value[count] = (*buffer)[typeSize - count - 1];
-            }
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-            memcpy(value, *buffer, typeSize);
-#endif
-        } else {
+        switch(streamEndianness) {
+        case(Endianness::BIG):
+			EndianConverter::convertBigEndian(value, *buffer, typeSize);
+		    break;
+        case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
+		   	break;
+        case(Endianness::MACHINE):
+        default:
             memcpy(value, *buffer, typeSize);
+            break;
         }
+    	*size -= typeSize;
         *buffer += typeSize;
         return HasReturnvaluesIF::RETURN_OK;
-    } else {
-        return SerializeIF::STREAM_TOO_SHORT;
     }
 }
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index ea07356e0..2ef1d6535 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -85,7 +85,7 @@ public:
 	 * 			- @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			uint32_t setSize);
+			size_t setSize);
 	/**
 	 *  @brief This operation returns the type of the entry currently stored.
 	 */
@@ -93,12 +93,12 @@ public:
 	/**
 	 *  @brief This operation returns the size of the entry currently stored.
 	 */
-	uint8_t getSizeOfType();
+	size_t getSizeOfType();
 	/**
 	 *
 	 * @return the size of the datapool array
 	 */
-	uint8_t getArraySize();
+	size_t getArraySize();
 	/**
 	 * @brief	This operation returns the data pool id of the variable.
 	 */

From b86e5664c470bf1b1c9615abb8557d51d3f86eb8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 00:33:03 +0200
Subject: [PATCH 0519/1774] include which was missing, pool raw access size_t
 replacements

---
 datapoolglob/PoolRawAccess.cpp | 5 ++++-
 datapoolglob/PoolRawAccess.h   | 8 ++++----
 serialize/SerializeAdapter.h   | 1 +
 3 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index cd4138d3d..4355cd0f7 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -204,7 +204,7 @@ void PoolRawAccess::setValid(bool valid) {
 	this->valid = valid;
 }
 
-uint16_t PoolRawAccess::getSizeTillEnd() const {
+size_t PoolRawAccess::getSizeTillEnd() const {
 	return sizeTillEnd;
 }
 
@@ -233,4 +233,7 @@ ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
         *buffer += typeSize;
         return HasReturnvaluesIF::RETURN_OK;
     }
+    else {
+    	return SerializeIF::STREAM_TOO_SHORT;
+    }
 }
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index 2ef1d6535..f58efdd09 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -133,7 +133,7 @@ public:
 	/**
 	 * Getter for the remaining size.
 	 */
-	uint16_t getSizeTillEnd() const;
+	size_t getSizeTillEnd() const;
 
 	/**
 	 * @brief	This is a call to read the value from the global data pool.
@@ -202,15 +202,15 @@ private:
 	/**
 	 * @brief	This value contains the size of the data pool entry type in bytes.
 	 */
-	uint8_t typeSize;
+	size_t typeSize;
 	/**
 	 * The size of the DP array (single values return 1)
 	 */
-	uint8_t arraySize;
+	size_t arraySize;
 	/**
 	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
 	 */
-	uint16_t sizeTillEnd;
+	size_t sizeTillEnd;
 	/**
 	 * @brief	The information whether the class is read-write or read-only is stored here.
 	 */
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index bb364eae5..4534ffb80 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -1,6 +1,7 @@
 #ifndef SERIALIZEADAPTER_H_
 #define SERIALIZEADAPTER_H_
 
+#include <framework/container/IsDerivedFrom.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serialize/EndianConverter.h>
 #include <framework/serialize/SerializeIF.h>

From 9dcf0c711854aff22789f0bdcb5375bde51e74bd Mon Sep 17 00:00:00 2001
From: Ulrich Mohr <mohr@irs.uni-stuttgart.de>
Date: Fri, 3 Jul 2020 15:50:29 +0200
Subject: [PATCH 0520/1774] size_t for DataPoolAdmin

---
 datapoolglob/DataPoolAdmin.cpp | 8 ++++----
 datapoolglob/DataPoolAdmin.h   | 6 +++---
 datapoolglob/PoolRawAccess.cpp | 2 +-
 datapoolglob/PoolRawAccess.h   | 4 ++--
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index edbac6eb4..4d0e5530f 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -26,7 +26,7 @@ MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
 }
 
 ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
 	if (actionId != SET_VALIDITY) {
 		return INVALID_ACTION_ID;
 	}
@@ -91,7 +91,7 @@ void DataPoolAdmin::handleCommand() {
 }
 
 ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
-		const uint8_t* data, uint32_t size, uint8_t** dataPointer) {
+		const uint8_t* data, size_t size, uint8_t** dataPointer) {
 	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
 	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
 	GlobDataSet testSet;
@@ -129,7 +129,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 	return ACTIVITY_COMPLETED;
 }
 
-ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
+ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
 		uint8_t** dataPointer, uint8_t* copyHere) {
 	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
 	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
@@ -151,7 +151,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
 				PoolVariableIF::VAR_READ);
 		status = rawSet.read();
 		if (status == RETURN_OK) {
-			uint32_t temp = 0;
+			size_t temp = 0;
 			status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
 			if (status != RETURN_OK) {
 				return RETURN_FAILED;
diff --git a/datapoolglob/DataPoolAdmin.h b/datapoolglob/DataPoolAdmin.h
index 5f995893b..653fdd8e2 100644
--- a/datapoolglob/DataPoolAdmin.h
+++ b/datapoolglob/DataPoolAdmin.h
@@ -30,12 +30,12 @@ public:
 	MessageQueueId_t getCommandQueue() const;
 
 	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
-			uint32_t size, uint8_t** dataPointer);
-	ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size,
+			size_t size, uint8_t** dataPointer);
+	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
 			uint8_t** dataPointer, uint8_t* copyHere);
 
 	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
 
 	//not implemented as ParameterHelper is no used
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index 4355cd0f7..783418cc9 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -121,7 +121,7 @@ uint8_t* PoolRawAccess::getEntry() {
 }
 
 ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		uint32_t* writtenBytes, uint32_t max_size) {
+		size_t* writtenBytes, size_t max_size) {
 	uint8_t* data_ptr = getEntry();
 	// debug << "PoolRawAccess::getEntry: Array position: " <<
 	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index f58efdd09..22dc312d7 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -57,8 +57,8 @@ public:
 	 * @return	- @c RETURN_OK if entry could be acquired
 	 * 			- @c RETURN_FAILED else.
 	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
-			uint32_t max_size);
+	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
+			size_t maxSize);
 
 	/**
 	 * @brief 	Serialize raw pool entry into provided buffer directly

From fcf3f04377910154f4a8302481b5f0cbec5273fe Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 01:25:49 +0200
Subject: [PATCH 0521/1774] diag output for inits improved

---
 devicehandlers/DeviceHandlerBase.cpp | 8 ++++++--
 fdir/FailureIsolationBase.cpp        | 6 ++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 867bf415e..fcb61acea 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -128,8 +128,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		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();
 	}
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index 018fbe6a4..a2fc9ea18 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -35,8 +35,10 @@ ReturnValue_t FailureIsolationBase::initialize() {
 			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) {

From 9e2fa165506192b18ca2ea4fa2540c7918c9e480 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 15:31:02 +0200
Subject: [PATCH 0522/1774] mq stack error improved

---
 osal/linux/MessageQueue.cpp      |  2 +-
 osal/linux/PosixThread.cpp       |  6 ++++--
 osal/linux/TmTcUnixUdpBridge.cpp | 21 ++++++++++++++++++---
 osal/linux/TmTcUnixUdpBridge.h   |  2 ++
 4 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 3d5d7a5ae..ce1da17c0 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -47,7 +47,7 @@ MessageQueue::~MessageQueue() {
 	status = mq_unlink(name);
 	if(status != 0){
 		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
-				   << strerror(errno) <<std::endl;
+				   << strerror(errno) << std::endl;
 	}
 }
 
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index bc3e62ed7..d84c8d9d8 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -149,8 +149,10 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
 	if(status != 0){
-		sif::error << "Posix Thread attribute setStack failed with: " <<
-				strerror(status) << std::endl;
+		sif::error << "PosixThread::createTask: pthread_attr_setstack "
+				" failed with: " << strerror(status) <<  std::endl;
+		sif::error << "Make sure the specified stack size is valid and is "
+				"larger than the minimum allowed stack size." << std::endl;
 	}
 
 	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 045e475ac..3beef3d45 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,5 +1,6 @@
 #include <framework/osal/linux/TmTcUnixUdpBridge.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <errno.h>
 
 TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		object_id_t ccsdsPacketDistributor, uint16_t serverPort,
@@ -20,6 +21,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
 				" UDP socket!" << std::endl;
 		// check errno here.
+		handleSocketError();
 		return;
 	}
 
@@ -39,9 +41,6 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		// check errno here.
 		return;
 	}
-
-
-
 }
 
 TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
@@ -58,3 +57,19 @@ ReturnValue_t TmTcUnixUdpBridge::receiveTc(uint8_t **recvBuffer, size_t *size) {
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
+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::TmTcUnixBridge: Socket creation failed"
+				<< " with " << strerror(errno) << std::endl;
+	}
+}
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index ab2e2d674..ccab1b1f6 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -25,6 +25,8 @@ private:
 	const int serverSocketOptions = 0;
 	struct sockaddr_in clientAddress;
 	struct sockaddr_in serverAddress;
+
+	void handleSocketError();
 };
 
 

From 26ab1983dcad5ae88addd3aa9b947db9ee6edfc6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 18:22:39 +0200
Subject: [PATCH 0523/1774] new ports

---
 osal/linux/TmTcUnixUdpBridge.cpp | 43 ++++++++++++++++++++++++++++++++
 osal/linux/TmTcUnixUdpBridge.h   |  7 ++++--
 2 files changed, 48 insertions(+), 2 deletions(-)

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 3beef3d45..60f4214ef 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -39,6 +39,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 				"local port " << setServerPort << " to server socket!"
 				<< std::endl;
 		// check errno here.
+		handleBindError();
 		return;
 	}
 }
@@ -59,6 +60,7 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 }
 
 void TmTcUnixUdpBridge::handleSocketError() {
+
 	// See: https://man7.org/linux/man-pages/man2/socket.2.html
 	switch(errno) {
 	case(EACCES):
@@ -71,5 +73,46 @@ void TmTcUnixUdpBridge::handleSocketError() {
 	case(EPROTONOSUPPORT):
 		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
+		break;
+	default:
+		sif::error << "TmTcUnixBridge::TmTcUnixBridge: 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::TmTcUnixBridge: 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::TmTcUnixBridge: Socket creation failed"
+					<< " with " << strerror(errno) << std::endl;
+		break;
+	default:
+		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
+						<< std::endl;
+		break;
+	}
+
+}
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index ccab1b1f6..7c55ea827 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -8,8 +8,10 @@
 
 class TmTcUnixUdpBridge: public TmTcBridge {
 public:
-	static constexpr int DEFAULT_UDP_SERVER_PORT = 7;
-	static constexpr int DEFAULT_UDP_CLIENT_PORT = 2008;
+	// The ports chosen here should not be used by any other process.
+	// List of used ports on Linux: /etc/services
+	static constexpr int DEFAULT_UDP_SERVER_PORT = 7301;
+	static constexpr int DEFAULT_UDP_CLIENT_PORT = 7302;
 
 	TmTcUnixUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor,
 			 uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
@@ -27,6 +29,7 @@ private:
 	struct sockaddr_in serverAddress;
 
 	void handleSocketError();
+	void handleBindError();
 };
 
 

From 724fee09ff30d8c1e435870a93cd4800e6ac0c86 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 18:58:16 +0200
Subject: [PATCH 0524/1774] new task for tc unix polling

---
 osal/linux/TcUnixUdpPollingTask.cpp |  8 ++++++++
 osal/linux/TcUnixUdpPollingTask.h   | 28 ++++++++++++++++++++++++++++
 osal/linux/TmTcUnixUdpBridge.cpp    | 23 ++++++++++++++---------
 osal/linux/TmTcUnixUdpBridge.h      |  1 -
 4 files changed, 50 insertions(+), 10 deletions(-)
 create mode 100644 osal/linux/TcUnixUdpPollingTask.cpp
 create mode 100644 osal/linux/TcUnixUdpPollingTask.h

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
new file mode 100644
index 000000000..0703904cd
--- /dev/null
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -0,0 +1,8 @@
+#include <framework/osal/linux/TcSocketPollingTask.h>
+
+TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
+		object_id_t tmtcUnixUdpBridge): SystemObject(objectId) {
+}
+
+TcSocketPollingTask::~TcSocketPollingTask() {
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
new file mode 100644
index 000000000..ffed08a73
--- /dev/null
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -0,0 +1,28 @@
+#ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+#define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+#include <framework/objectmanager/SystemObject.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+
+/**
+ * @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 TcSocketPollingTask: public SystemObject,
+		public ExecutableObjectIF {
+public:
+	TcSocketPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge);
+	virtual~ TcSocketPollingTask();
+
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual ReturnValue_t initialize() override;
+private:
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 60f4214ef..ff8b6588a 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -47,15 +47,15 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 }
 
-ReturnValue_t TmTcUnixUdpBridge::handleTc() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TmTcUnixUdpBridge::receiveTc(uint8_t **recvBuffer, size_t *size) {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+	int flags = 0;
+	ssize_t result = send(serverSocket, data, dataLen, flags);
+	if(result < 0) {
+		//handle error
+		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed "
+				"with error " << strerror(errno) << std::endl;
+	}
+
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -114,5 +114,10 @@ void TmTcUnixUdpBridge::handleBindError() {
 						<< std::endl;
 		break;
 	}
-
+}
+
+
+ReturnValue_t TmTcUnixUdpBridge::receiveTc(uint8_t **recvBuffer, size_t *size) {
+	// TC reception handled by separate polling task because it is blocking.
+	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index 7c55ea827..a969083d5 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -18,7 +18,6 @@ public:
 	virtual~ TmTcUnixUdpBridge();
 
 protected:
-	virtual ReturnValue_t handleTc() override;
 	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer,
 			size_t * size) override;
 	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;

From 327b1e9d2f242c49c331533a6d8c34407bf0060f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 19:11:21 +0200
Subject: [PATCH 0525/1774] file renamed

---
 osal/linux/TcUnixUdpPollingTask.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 0703904cd..c470d96f7 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,4 +1,4 @@
-#include <framework/osal/linux/TcSocketPollingTask.h>
+#include <framework/osal/linux/TcUnixUdpPollingTask.h>
 
 TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge): SystemObject(objectId) {

From 2395e487aee6c5cc6701a4e0a50de2ea676e4f0c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 20:42:05 +0200
Subject: [PATCH 0526/1774] udp polling taks init

---
 osal/linux/TcUnixUdpPollingTask.cpp | 8 ++++++++
 osal/linux/TcUnixUdpPollingTask.h   | 4 ++++
 2 files changed, 12 insertions(+)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index c470d96f7..21ad1d9a6 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -6,3 +6,11 @@ TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
 
 TcSocketPollingTask::~TcSocketPollingTask() {
 }
+
+ReturnValue_t TcSocketPollingTask::performOperation(uint8_t opCode) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TcSocketPollingTask::initialize() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index ffed08a73..eda7fe5df 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -2,6 +2,7 @@
 #define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/tasks/ExecutableObjectIF.h>
+#include <sys/socket.h>
 
 /**
  * @brief 	This class can be used to implement the polling of a Unix socket,
@@ -14,6 +15,7 @@
  */
 class TcSocketPollingTask: public SystemObject,
 		public ExecutableObjectIF {
+	friend class TmTcUnixUdpBridge;
 public:
 	TcSocketPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge);
 	virtual~ TcSocketPollingTask();
@@ -21,6 +23,8 @@ public:
 	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 	virtual ReturnValue_t initialize() override;
 private:
+	//! Sender Address is cached here.
+	const struct sockaddr senderAddress;
 };
 
 

From ebec074655d40dd60c4553c8b94ce3018d6f7358 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 23:53:13 +0200
Subject: [PATCH 0527/1774] Split up FIFO into StaticFIFO and normale FIFO

---
 container/FIFO.h                      | 88 +++++----------------------
 container/FIFOBase.h                  | 59 ++++++++++++++++++
 container/FIFOBase.tpp                | 76 +++++++++++++++++++++++
 container/StaticFIFO.h                | 23 +++++++
 globalfunctions/timevalOperations.cpp |  7 +++
 globalfunctions/timevalOperations.h   |  1 +
 osal/linux/TcUnixUdpPollingTask.cpp   | 66 +++++++++++++++++++-
 osal/linux/TcUnixUdpPollingTask.h     | 30 +++++++--
 osal/linux/TmTcUnixUdpBridge.cpp      | 19 +++++-
 osal/linux/TmTcUnixUdpBridge.h        | 16 ++++-
 tmtcservices/CommandingServiceBase.h  |  4 +-
 tmtcservices/TmTcBridge.h             |  4 +-
 12 files changed, 309 insertions(+), 84 deletions(-)
 create mode 100644 container/FIFOBase.h
 create mode 100644 container/FIFOBase.tpp
 create mode 100644 container/StaticFIFO.h

diff --git a/container/FIFO.h b/container/FIFO.h
index f70c78b0d..217ddbcaa 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -1,82 +1,26 @@
-#ifndef FIFO_H_
-#define FIFO_H_
+#ifndef FRAMEWORK_CONTAINER_FIFO_H_
+#define FRAMEWORK_CONTAINER_FIFO_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/container/FIFOBase.h>
+#include <vector>
 
 /**
- * @brief Simple First-In-First-Out data structure
+ * @brief 	Simple First-In-First-Out data structure. The maximum size
+ * 			can be set in the constructor. 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>
+class FIFO: public FIFOBase<T> {
 public:
-	FIFO() :
-			readIndex(0), writeIndex(0), currentSize(0) {
-	}
+	FIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity) {
+		values.reserve(maxCapacity);
+		values.resize(maxCapacity);
+	};
 
-	bool empty() {
-		return (currentSize == 0);
-	}
-
-	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::vector<T> values;
 };
 
-#endif /* FIFO_H_ */
+#endif /* FRAMEWORK_CONTAINER_FIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
new file mode 100644
index 000000000..c6a74d2f0
--- /dev/null
+++ b/container/FIFOBase.h
@@ -0,0 +1,59 @@
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
+#define FRAMEWORK_CONTAINER_FIFOBASE_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
+
+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, no input arguments required. */
+	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();
+
+private:
+	T* values;
+	size_t maxCapacity;
+
+	size_t readIndex = 0;
+	size_t writeIndex = 0;
+	size_t currentSize = 0;
+
+	size_t next(size_t current);
+};
+
+#include <framework/container/FIFOBase.tpp>
+
+#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
new file mode 100644
index 000000000..011ce6de7
--- /dev/null
+++ b/container/FIFOBase.tpp
@@ -0,0 +1,76 @@
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_TPP_
+#define FRAMEWORK_CONTAINER_FIFOBASE_TPP_
+
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
+#error Include FIFOBase.h before FIFOBase.tpp!
+#endif
+
+template<typename T>
+inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
+		values(values), maxCapacity(maxCapacity) {};
+
+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;
+}
+
+#endif
diff --git a/container/StaticFIFO.h b/container/StaticFIFO.h
new file mode 100644
index 000000000..651c4989b
--- /dev/null
+++ b/container/StaticFIFO.h
@@ -0,0 +1,23 @@
+#ifndef FRAMEWORK_CONTAINER_STATICFIFO_H_
+#define FRAMEWORK_CONTAINER_STATICFIFO_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/container/FIFOBase.h>
+
+/**
+ * @brief 	Simple First-In-First-Out data structure with size fixed at
+ * 			compile time. The public interface of FIFOBase exposes
+ * 			the user interface for the FIFO.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+template<typename T, size_t capacity>
+class StaticFIFO: public FIFOBase<T> {
+public:
+	StaticFIFO(): FIFOBase<T>(values.data(), capacity) {};
+
+private:
+	std::array<T, capacity> values;
+};
+
+#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/globalfunctions/timevalOperations.cpp b/globalfunctions/timevalOperations.cpp
index 253b6eb77..1da45d7b1 100644
--- a/globalfunctions/timevalOperations.cpp
+++ b/globalfunctions/timevalOperations.cpp
@@ -90,3 +90,10 @@ 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;
+}
diff --git a/globalfunctions/timevalOperations.h b/globalfunctions/timevalOperations.h
index a553e60a5..3977d5d96 100644
--- a/globalfunctions/timevalOperations.h
+++ b/globalfunctions/timevalOperations.h
@@ -41,6 +41,7 @@ namespace timevalOperations {
  * @return seconds
  */
 double toDouble(const timeval timeval);
+timeval toTimeval(const double seconds);
 }
 
 #endif /* TIMEVALOPERATIONS_H_ */
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 21ad1d9a6..79dbdce26 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,16 +1,80 @@
 #include <framework/osal/linux/TcUnixUdpPollingTask.h>
 
 TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
-		object_id_t tmtcUnixUdpBridge): SystemObject(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);
+	}
+
+	// Set receive timeout.
+	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+			&receptionTimeout, sizeof(receptionTimeout));
+	if(result == -1) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting receive"
+				"timeout failed with " << strerror(errno) << std::endl;
+		return;
+	}
 }
 
 TcSocketPollingTask::~TcSocketPollingTask() {
 }
 
 ReturnValue_t TcSocketPollingTask::performOperation(uint8_t opCode) {
+	// Poll for new data permanently. The call will block until the specified
+	// length of bytes has been received or a timeout occured.
+	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: recvfrom "
+					"failed with " << strerror(errno) << std::endl;
+			continue;
+		}
+		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
+				<< " bytes received" << std::endl;
+
+		ReturnValue_t result = handleSuccessfullTcRead();
+		tmtcBridge->checkAndSetClientAddress(senderAddress);
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t TcSocketPollingTask::initialize() {
+	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 TcSocketPollingTask::handleSuccessfullTcRead() {
+
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index eda7fe5df..09ee6c997 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -1,8 +1,11 @@
 #ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
 #define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
 #include <framework/objectmanager/SystemObject.h>
+#include <framework/osal/linux/TmTcUnixUdpBridge.h>
 #include <framework/tasks/ExecutableObjectIF.h>
+
 #include <sys/socket.h>
+#include <vector>
 
 /**
  * @brief 	This class can be used to implement the polling of a Unix socket,
@@ -17,15 +20,34 @@ class TcSocketPollingTask: public SystemObject,
 		public ExecutableObjectIF {
 	friend class TmTcUnixUdpBridge;
 public:
-	TcSocketPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge);
+	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};
+
+	TcSocketPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+			size_t frameSize = 0, double timeoutSeconds = -1);
 	virtual~ TcSocketPollingTask();
 
 	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 	virtual ReturnValue_t initialize() override;
+
 private:
-	//! Sender Address is cached here.
-	const struct sockaddr senderAddress;
-};
+	//! TMTC bridge is cached.
+	object_id_t tmtcBridgeId = objects::NO_OBJECT;
+	TmTcUnixUdpBridge* tmtcBridge = nullptr;
+	//! 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();
 
 
 
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index ff8b6588a..710761b44 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,11 +1,14 @@
 #include <framework/osal/linux/TmTcUnixUdpBridge.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <errno.h>
+#include <framework/ipc/MutexHelper.h>
 
 TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		object_id_t ccsdsPacketDistributor, uint16_t serverPort,
 		uint16_t clientPort):
 		TmTcBridge(objectId, ccsdsPacketDistributor) {
+	mutex = MutexFactory::instance()->createMutex();
+
 	uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
 	if(serverPort != 0xFFFF) {
 		setServerPort = serverPort;
@@ -16,6 +19,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		setClientPort = clientPort;
 	}
 
+	// Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
 	serverSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	if(socket < 0) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
@@ -26,14 +30,16 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	}
 
 	serverAddress.sin_family = AF_INET;
+	// Accept packets from any interface.
 	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
 	serverAddress.sin_port = htons(setServerPort);
 	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
 			sizeof(serverSocketOptions));
 
+	serverSocketLen = sizeof(serverAddress);
 	int result = bind(serverSocket,
 			reinterpret_cast<struct sockaddr*>(&serverAddress),
-			sizeof(serverAddress));
+			serverSocketLen);
 	if(result == -1) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
 				"local port " << setServerPort << " to server socket!"
@@ -81,6 +87,17 @@ void TmTcUnixUdpBridge::handleSocketError() {
 	}
 }
 
+void TmTcUnixUdpBridge::setTimeout(float timeoutSeconds) {
+}
+
+void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+	MutexHelper lock(mutex, 10);
+	// 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;
+	}
+}
+
 void TmTcUnixUdpBridge::handleBindError() {
 	// See: https://man7.org/linux/man-pages/man2/bind.2.html
 	switch(errno) {
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index a969083d5..15d256cd4 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -7,16 +7,20 @@
 #include <netinet/udp.h>
 
 class TmTcUnixUdpBridge: public TmTcBridge {
+	friend class TcSocketPollingTask;
 public:
 	// The ports chosen here should not be used by any other process.
 	// List of used ports on Linux: /etc/services
-	static constexpr int DEFAULT_UDP_SERVER_PORT = 7301;
-	static constexpr int DEFAULT_UDP_CLIENT_PORT = 7302;
+	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 ccsdsPacketDistributor,
 			 uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
 	virtual~ TmTcUnixUdpBridge();
 
+	void setTimeout(float timeoutSeconds);
+	void checkAndSetClientAddress(sockaddr_in clientAddress);
+
 protected:
 	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer,
 			size_t * size) override;
@@ -24,8 +28,16 @@ protected:
 private:
 	int serverSocket = 0;
 	const int serverSocketOptions = 0;
+
 	struct sockaddr_in clientAddress;
+	socklen_t clientSocketLen = 0;
+
 	struct sockaddr_in serverAddress;
+	socklen_t serverSocketLen = 0;
+
+	//! Access to the client address is mutex protected as it is set
+	//! by another task.
+	MutexIF* mutex;
 
 	void handleSocketError();
 	void handleBindError();
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 700503c69..169eebe19 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -10,7 +10,7 @@
 #include <framework/tmtcservices/VerificationReporter.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/container/FixedMap.h>
-#include <framework/container/FIFO.h>
+#include <framework/container/StaticFIFO.h>
 #include <framework/serialize/SerializeIF.h>
 
 class TcPacketStored;
@@ -199,7 +199,7 @@ protected:
 		uint32_t state;
 		Command_t command;
 		object_id_t objectId;
-		FIFO<store_address_t, 3> fifo;
+		StaticFIFO<store_address_t, 3> fifo;
 	};
 
 	using CommandMapIter = FixedMap<MessageQueueId_t,
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index b50e9e1bc..a24aa805d 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -8,7 +8,7 @@
 #include <framework/objectmanager/SystemObject.h>
 
 #include <framework/tmtcservices/TmTcMessage.h>
-#include <framework/container/FIFO.h>
+#include <framework/container/StaticFIFO.h>
 
 class TmTcBridge : public AcceptsTelemetryIF,
 		public ExecutableObjectIF,
@@ -143,7 +143,7 @@ protected:
 	 * This fifo can be used to store downlink data
 	 * which can not be sent at the moment.
 	 */
-	FIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
+	StaticFIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
     uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
     uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };

From 2158208a2fbbd98c1fa5ced154866803f80d04f1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 00:33:55 +0200
Subject: [PATCH 0528/1774] new pus parser

---
 osal/linux/TcUnixUdpPollingTask.cpp |  1 -
 osal/linux/TcUnixUdpPollingTask.h   |  2 +-
 tmtcservices/PusParser.cpp          | 10 ++++++
 tmtcservices/PusParser.h            | 51 +++++++++++++++++++++++++++++
 4 files changed, 62 insertions(+), 2 deletions(-)
 create mode 100644 tmtcservices/PusParser.cpp
 create mode 100644 tmtcservices/PusParser.h

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 79dbdce26..f237a0f26 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -75,6 +75,5 @@ ReturnValue_t TcSocketPollingTask::initialize() {
 }
 
 ReturnValue_t TcSocketPollingTask::handleSuccessfullTcRead() {
-
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index 09ee6c997..a6b0e9d47 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -49,6 +49,6 @@ private:
 
 	ReturnValue_t handleSuccessfullTcRead();
 
-
+};
 
 #endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
new file mode 100644
index 000000000..76934e338
--- /dev/null
+++ b/tmtcservices/PusParser.cpp
@@ -0,0 +1,10 @@
+#include <framework/tmtcservices/PusParser.h>
+
+PusParser::PusParser(uint16_t maxExpectedPusPackets,
+		bool storeSplitPackets): indexSizePairFIFO(maxExpectedPusPackets) {
+}
+
+ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
+		size_t frameSize) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
new file mode 100644
index 000000000..8fbf9652a
--- /dev/null
+++ b/tmtcservices/PusParser.h
@@ -0,0 +1,51 @@
+#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
+#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
+
+#include <framework/container/FIFO.h>
+
+#include <utility>
+#include <cstdint>
+
+/**
+ * @brief	This small helper class scans a given buffer for PUS packets.
+ * 			Can be used if PUS packets are serialized in a tightly packed frame.
+ * @details
+ * The parser uses the payload length field of PUS packets to find
+ * the respective PUS packet sizes.
+ *
+ * The parser parses a buffer by taking a pointer and the maximum size to scan.
+ * If PUS packets are found, they are stored in a FIFO which stores pairs
+ * consisting of the index in the buffer and the respective packet sizes.
+ *
+ * If the parser detects split packets (which means that the size of the
+ * next packet is larger than the remaining size to scan), it can either
+ * store that split packet or throw away the packet.
+ */
+class PusParser {
+public:
+	/**
+	 * Parser constructor.
+	 * @param maxExpectedPusPackets
+	 * Maximum expected number of PUS packets. A good estimate is to divide
+	 * the frame size by the minimum size of a PUS packet (12 bytes)
+	 * @param storeSplitPackets
+	 * Specifies whether split packets are also stored inside the FIFO,
+	 * with the size being the remaining frame size.
+	 */
+	PusParser(uint16_t maxExpectedPusPackets, bool storeSplitPackets);
+
+	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
+private:
+	//! The first entry is the index inside the buffer while the second index
+	//! is the size of the PUS packet starting at that index.
+	using indexSizePair = std::pair<size_t, size_t>;
+	//! A FIFO is used to store information about multiple PUS packets
+	//! inside the receive buffer. The maximum number of entries is defined
+	//! by the first constructor argument.
+	FIFO<indexSizePair> indexSizePairFIFO;
+
+	bool storeSplitPackets = false;
+};
+
+
+#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */

From bb5de8f11041014ad9f6c33c98fc6d6e0822afc3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 13:41:07 +0200
Subject: [PATCH 0529/1774] merged new changes

---
 container/FIFO.h       | 11 +++++++++--
 container/FIFOBase.h   |  8 ++++++--
 container/StaticFIFO.h | 11 +++++++++--
 3 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/container/FIFO.h b/container/FIFO.h
index 217ddbcaa..7251321f5 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -4,10 +4,15 @@
 #include <framework/container/FIFOBase.h>
 #include <vector>
 
+namespace fsfw {
+
 /**
  * @brief 	Simple First-In-First-Out data structure. The maximum size
- * 			can be set in the constructor. THe public interface of
- * 			FIFOBase exposes the user interface for the FIFO.
+ * 			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
  */
@@ -23,4 +28,6 @@ private:
 	std::vector<T> values;
 };
 
+}
+
 #endif /* FRAMEWORK_CONTAINER_FIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index c6a74d2f0..ac5c6e2cb 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -4,6 +4,8 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
 
+namespace fsfw {
+
 template <typename T>
 class FIFOBase {
 public:
@@ -11,8 +13,8 @@ public:
 	static const ReturnValue_t FULL = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(2);
 
-
-	/** Default ctor, no input arguments required. */
+	/** Default ctor, takes pointer to first entry of underlying container
+	 *  and maximum capacity */
 	FIFOBase(T* values, const size_t maxCapacity);
 
 	/**
@@ -56,4 +58,6 @@ private:
 
 #include <framework/container/FIFOBase.tpp>
 
+}
+
 #endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
diff --git a/container/StaticFIFO.h b/container/StaticFIFO.h
index 651c4989b..f31282004 100644
--- a/container/StaticFIFO.h
+++ b/container/StaticFIFO.h
@@ -3,11 +3,16 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/container/FIFOBase.h>
+#include <array>
+
+namespace fsfw {
 
 /**
  * @brief 	Simple First-In-First-Out data structure with size fixed at
- * 			compile time. The public interface of FIFOBase exposes
- * 			the user interface for the FIFO.
+ * 			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
  */
@@ -20,4 +25,6 @@ private:
 	std::array<T, capacity> values;
 };
 
+}
+
 #endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */

From b61e1df8bcd2177f06cbdb28e7c4352cee75422c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 13:43:41 +0200
Subject: [PATCH 0530/1774] fifo in namespace now

---
 tmtcservices/CommandingServiceBase.h | 2 +-
 tmtcservices/PusParser.h             | 2 +-
 tmtcservices/TmTcBridge.h            | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 169eebe19..72fe13f2f 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -199,7 +199,7 @@ protected:
 		uint32_t state;
 		Command_t command;
 		object_id_t objectId;
-		StaticFIFO<store_address_t, 3> fifo;
+		fsfw::StaticFIFO<store_address_t, 3> fifo;
 	};
 
 	using CommandMapIter = FixedMap<MessageQueueId_t,
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
index 8fbf9652a..ef1770796 100644
--- a/tmtcservices/PusParser.h
+++ b/tmtcservices/PusParser.h
@@ -42,7 +42,7 @@ private:
 	//! A FIFO is used to store information about multiple PUS packets
 	//! inside the receive buffer. The maximum number of entries is defined
 	//! by the first constructor argument.
-	FIFO<indexSizePair> indexSizePairFIFO;
+	fsfw::FIFO<indexSizePair> indexSizePairFIFO;
 
 	bool storeSplitPackets = false;
 };
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index a24aa805d..23f7dcfa4 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -143,7 +143,7 @@ protected:
 	 * This fifo can be used to store downlink data
 	 * which can not be sent at the moment.
 	 */
-	StaticFIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
+	fsfw::StaticFIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
     uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
     uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };

From 78283ddbeecefb733fe68408befb3337ad869173 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 14:09:33 +0200
Subject: [PATCH 0531/1774] queue map manager: not using std::atomic anymore

---
 osal/host/QueueMapManager.cpp | 5 ++++-
 osal/host/QueueMapManager.h   | 2 +-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index e7c86f306..89b9a948f 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -17,6 +17,10 @@ QueueMapManager* QueueMapManager::instance() {
 
 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) {
@@ -28,7 +32,6 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 	if (id != nullptr) {
 		*id = currentId;
 	}
-	mapLock = MutexFactory::instance()->createMutex();
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
index 499b1622a..a2a1b6581 100644
--- a/osal/host/QueueMapManager.h
+++ b/osal/host/QueueMapManager.h
@@ -36,7 +36,7 @@ public:
 private:
 	//! External instantiation is forbidden.
 	QueueMapManager();
-	std::atomic<uint32_t> queueCounter = 1;
+	uint32_t queueCounter = 1;
 	MutexIF* mapLock;
 	QueueMap queueMap;
 	static QueueMapManager* mqManagerInstance;

From f442a5889ec4bb213f35668a9320dd4cfedeee94 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 16:34:11 +0200
Subject: [PATCH 0532/1774] pus parser continued

---
 returnvalues/FwClassIds.h  |  1 +
 tmtcservices/PusParser.cpp | 33 +++++++++++++++++++++++++++++++++
 tmtcservices/PusParser.h   | 11 +++++++++++
 3 files changed, 45 insertions(+)

diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index ddee539e3..abee534a1 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -64,6 +64,7 @@ enum {
 	LOCAL_POOL_OWNER_IF, //LPIF 58
 	POOL_VARIABLE_IF, //PVA 59
 	HOUSEKEEPING_MANAGER, //HKM 60
+	PUS_PARSER, //PUSP 61
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index 76934e338..5f326b447 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -1,4 +1,5 @@
 #include <framework/tmtcservices/PusParser.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 PusParser::PusParser(uint16_t maxExpectedPusPackets,
 		bool storeSplitPackets): indexSizePairFIFO(maxExpectedPusPackets) {
@@ -6,5 +7,37 @@ PusParser::PusParser(uint16_t maxExpectedPusPackets,
 
 ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 		size_t frameSize) {
+	if(frame == nullptr) {
+		sif::error << "PusParser::parsePusPackets: Frame pointers in invalid!"
+				<< std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	// Size of a pus packet is the value in the packet length field plus 7.
+	uint16_t packetSize = (frame[4] << 8 | frame[5]) + 7;
+	if(packetSize > 0) {
+		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return NO_PACKET_FOUND;
+	}
+
+	if(frameSize > packetSize) {
+		return readMultiplePackets(frameSize);
+
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
+//ReturnValue_t PusParser::readMultiplePackets(size_t frameSize) {
+//	size_t endOfBuffer = frameSize - 1;
+//	size_t endIndex = firstPacketSize;
+//	size_t startIndex = 0;
+//	while (endIndex < endOfBuffer) {
+//		ReturnValue_t result = readNextPacket(&startIndex, &endIndex);
+//		if(result != RETURN_OK) {
+//			return;
+//		}
+//	}
+//}
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
index ef1770796..cdc887edf 100644
--- a/tmtcservices/PusParser.h
+++ b/tmtcservices/PusParser.h
@@ -23,6 +23,9 @@
  */
 class PusParser {
 public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
+	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
+
 	/**
 	 * Parser constructor.
 	 * @param maxExpectedPusPackets
@@ -34,6 +37,12 @@ public:
 	 */
 	PusParser(uint16_t maxExpectedPusPackets, bool storeSplitPackets);
 
+	/**
+	 * Parse a given frame for PUS packets
+	 * @param frame
+	 * @param frameSize
+	 * @return -@c NO_PACKET_FOUND if no packet was found.
+	 */
 	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
 private:
 	//! The first entry is the index inside the buffer while the second index
@@ -45,6 +54,8 @@ private:
 	fsfw::FIFO<indexSizePair> indexSizePairFIFO;
 
 	bool storeSplitPackets = false;
+
+	ReturnValue_t readMultiplePackets(size_t frameSize);
 };
 
 

From 8ba75fc3c2fad46fc0e37fe17a627a99cfa3f09a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 19:36:21 +0200
Subject: [PATCH 0533/1774] pus parser implemented

---
 tmtcservices/PusParser.cpp | 113 ++++++++++++++++++++++++++++++-------
 tmtcservices/PusParser.h   |  32 +++++++++--
 2 files changed, 120 insertions(+), 25 deletions(-)

diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index 5f326b447..21d44efaa 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -13,31 +13,106 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	// Size of a pus packet is the value in the packet length field plus 7.
-	uint16_t packetSize = (frame[4] << 8 | frame[5]) + 7;
-	if(packetSize > 0) {
-		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
-		return HasReturnvaluesIF::RETURN_OK;
+	if(indexSizePairFIFO.full()) {
+		sif::error << "PusParser::parsePusPackets: FIFO is full!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	else {
+
+
+	size_t lengthField = frame[4] << 8 | frame[5];
+
+	if(lengthField == 0) {
 		return NO_PACKET_FOUND;
 	}
 
-	if(frameSize > packetSize) {
-		return readMultiplePackets(frameSize);
+	size_t packetSize = lengthField + 7;
+	if(lengthField > 0) {
+		// Size of a pus packet is the value in the packet length field plus 7.
+		if(packetSize > frameSize)
+		{
+			if(storeSplitPackets)
+			{
+				indexSizePairFIFO.insert(indexSizePair(0, frameSize));
+			}
+			else
+			{
+				sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
+						"larger than remaining frame," << std::endl;
+				sif::debug << "Throwing away packet. Detected packet size: "
+						<< packetSize << std::endl;
+			}
+			return SPLIT_PACKET;
+		}
+		else
+		{
+			indexSizePairFIFO.insert(indexSizePair(0, packetSize));
+			if(packetSize == frameSize) {
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+	}
 
+	// packet size is smaller than frame size, parse for more packets.
+	return readMultiplePackets(frame, frameSize, packetSize);
+}
+
+ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
+		size_t frameSize, size_t startIndex) {
+	while (startIndex < frameSize) {
+		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-//ReturnValue_t PusParser::readMultiplePackets(size_t frameSize) {
-//	size_t endOfBuffer = frameSize - 1;
-//	size_t endIndex = firstPacketSize;
-//	size_t startIndex = 0;
-//	while (endIndex < endOfBuffer) {
-//		ReturnValue_t result = readNextPacket(&startIndex, &endIndex);
-//		if(result != RETURN_OK) {
-//			return;
-//		}
-//	}
-//}
+fsfw::FIFO<PusParser::indexSizePair>* PusParser::fifo(){
+	return &indexSizePairFIFO;
+}
+
+PusParser::indexSizePair PusParser::getNextFifoPair() {
+	indexSizePair nextIndexSizePair;
+	indexSizePairFIFO.retrieve(&nextIndexSizePair);
+	return nextIndexSizePair;
+}
+
+ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
+		size_t frameSize, size_t& currentIndex) {
+	// sif::debug << startIndex << std::endl;
+	uint16_t lengthField = frame[currentIndex + 4] << 8 |
+			frame[currentIndex + 5];
+	if(lengthField == 0) {
+		// It is assumed that no packet follows.
+		currentIndex = frameSize;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	size_t nextPacketSize = lengthField + 7;
+	size_t remainingSize = frameSize - currentIndex;
+	if(nextPacketSize > remainingSize)
+	{
+		if(storeSplitPackets)
+		{
+			indexSizePairFIFO.insert(indexSizePair(currentIndex, remainingSize));
+		}
+		else
+		{
+			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
+					"larger than remaining frame," << std::endl;
+			sif::debug << "Throwing away packet. Detected packet size: "
+					<< nextPacketSize << std::endl;
+		}
+		return SPLIT_PACKET;
+	}
+
+	ReturnValue_t result = indexSizePairFIFO.insert(indexSizePair(currentIndex,
+			nextPacketSize));
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		// FIFO full.
+		sif::debug << "PusParser: Issue inserting into start index size "
+		        "FIFO, it is full!" << std::endl;
+	}
+	currentIndex += nextPacketSize;
+
+	return result;
+}
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
index cdc887edf..82aff57e1 100644
--- a/tmtcservices/PusParser.h
+++ b/tmtcservices/PusParser.h
@@ -23,9 +23,13 @@
  */
 class PusParser {
 public:
+	//! The first entry is the index inside the buffer while the second index
+	//! is the size of the PUS packet starting at that index.
+	using indexSizePair = std::pair<size_t, size_t>;
+
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
 	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
-
+	static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);
 	/**
 	 * Parser constructor.
 	 * @param maxExpectedPusPackets
@@ -44,10 +48,24 @@ public:
 	 * @return -@c NO_PACKET_FOUND if no packet was found.
 	 */
 	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
+
+	/**
+	 * Accessor function to get a reference to the internal FIFO which
+	 * stores pairs of indexi and packet sizes. This FIFO is filled
+	 * by the parsePusPackets() function.
+	 * @return
+	 */
+	fsfw::FIFO<indexSizePair>* fifo();
+
+	/**
+	 * Retrieve the next index and packet size pair from the FIFO.
+	 * This also removed it from the FIFO. Please note that if the FIFO
+	 * is empty, an empty pair will be returned.
+	 * @return
+	 */
+	indexSizePair getNextFifoPair();
 private:
-	//! The first entry is the index inside the buffer while the second index
-	//! is the size of the PUS packet starting at that index.
-	using indexSizePair = std::pair<size_t, size_t>;
+
 	//! A FIFO is used to store information about multiple PUS packets
 	//! inside the receive buffer. The maximum number of entries is defined
 	//! by the first constructor argument.
@@ -55,8 +73,10 @@ private:
 
 	bool storeSplitPackets = false;
 
-	ReturnValue_t readMultiplePackets(size_t frameSize);
+	ReturnValue_t readMultiplePackets(const uint8_t *frame, size_t frameSize,
+			size_t startIndex);
+	ReturnValue_t readNextPacket(const uint8_t *frame,
+			size_t frameSize, size_t& startIndex);
 };
 
-
 #endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */

From fd1e612ea5d931d20177405a827c34bf52ee7c54 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 20:17:05 +0200
Subject: [PATCH 0534/1774] pus parser fixes

---
 tmtcservices/PusParser.cpp | 40 +++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index 21d44efaa..b43b0519f 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -18,7 +18,6 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-
 	size_t lengthField = frame[4] << 8 | frame[5];
 
 	if(lengthField == 0) {
@@ -26,32 +25,32 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 	}
 
 	size_t packetSize = lengthField + 7;
-	if(lengthField > 0) {
-		// Size of a pus packet is the value in the packet length field plus 7.
-		if(packetSize > frameSize)
+	// Size of a pus packet is the value in the packet length field plus 7.
+	if(packetSize > frameSize)
+	{
+		if(storeSplitPackets)
 		{
-			if(storeSplitPackets)
-			{
-				indexSizePairFIFO.insert(indexSizePair(0, frameSize));
-			}
-			else
-			{
-				sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
-						"larger than remaining frame," << std::endl;
-				sif::debug << "Throwing away packet. Detected packet size: "
-						<< packetSize << std::endl;
-			}
-			return SPLIT_PACKET;
+			indexSizePairFIFO.insert(indexSizePair(0, frameSize));
 		}
 		else
 		{
-			indexSizePairFIFO.insert(indexSizePair(0, packetSize));
-			if(packetSize == frameSize) {
-				return HasReturnvaluesIF::RETURN_OK;
-			}
+			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
+					"larger than remaining frame," << std::endl;
+			sif::debug << "Throwing away packet. Detected packet size: "
+					<< packetSize << std::endl;
+		}
+		return SPLIT_PACKET;
+	}
+	else
+	{
+		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
+		if(packetSize == frameSize) {
+			sif::info << "test2" << std::endl;
+			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
 
+
 	// packet size is smaller than frame size, parse for more packets.
 	return readMultiplePackets(frame, frameSize, packetSize);
 }
@@ -59,6 +58,7 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
 		size_t frameSize, size_t startIndex) {
 	while (startIndex < frameSize) {
+		sif::info << "test" << std::endl;
 		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			return result;

From cb691db807d562c8f84178d48650464c4cb58ecc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 23:07:38 +0200
Subject: [PATCH 0535/1774] fifo tweaks, pus parser fixes

---
 container/FIFO.h           | 6 ++----
 container/FIFOBase.h       | 4 +++-
 container/FIFOBase.tpp     | 5 +++++
 tmtcservices/PusParser.cpp | 3 ---
 4 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/container/FIFO.h b/container/FIFO.h
index 7251321f5..19daaf1be 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -19,10 +19,8 @@ namespace fsfw {
 template<typename T>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity) {
-		values.reserve(maxCapacity);
-		values.resize(maxCapacity);
-	};
+	FIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
+			values(maxCapacity) {};
 
 private:
 	std::vector<T> values;
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index ac5c6e2cb..6ed7d924b 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -45,9 +45,11 @@ public:
 	bool full();
 	size_t size();
 
+	size_t getMaxCapacity() const;
+
 private:
 	T* values;
-	size_t maxCapacity;
+	size_t maxCapacity = 0;
 
 	size_t readIndex = 0;
 	size_t writeIndex = 0;
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index 011ce6de7..48a060ff3 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -73,4 +73,9 @@ inline size_t FIFOBase<T>::next(size_t current) {
 	return current;
 }
 
+template<typename T>
+inline size_t FIFOBase<T>::getMaxCapacity() const {
+	return maxCapacity;
+}
+
 #endif
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index b43b0519f..175c28934 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -45,12 +45,10 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 	{
 		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
 		if(packetSize == frameSize) {
-			sif::info << "test2" << std::endl;
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
 
-
 	// packet size is smaller than frame size, parse for more packets.
 	return readMultiplePackets(frame, frameSize, packetSize);
 }
@@ -58,7 +56,6 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
 		size_t frameSize, size_t startIndex) {
 	while (startIndex < frameSize) {
-		sif::info << "test" << std::endl;
 		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			return result;

From 4f1f610ae03bd4f0fecc9e19ecafa5803ee8a231 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 16:36:41 +0200
Subject: [PATCH 0536/1774] doc and improvements for DLE encoder

---
 globalfunctions/DleEncoder.cpp | 39 +++++++++++----------
 globalfunctions/DleEncoder.h   | 64 +++++++++++++++++++++++++++++-----
 returnvalues/FwClassIds.h      |  3 +-
 3 files changed, 78 insertions(+), 28 deletions(-)

diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index a68f15249..ee934785b 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -1,18 +1,16 @@
 #include <framework/globalfunctions/DleEncoder.h>
 
-DleEncoder::DleEncoder() {
-}
+DleEncoder::DleEncoder() {}
 
-DleEncoder::~DleEncoder() {
-}
+DleEncoder::~DleEncoder() {}
 
 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;
+		return DECODING_ERROR;
 	}
 	++encodedIndex;
 	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
@@ -20,14 +18,18 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 			&& (sourceStream[encodedIndex] != STX)) {
 		if (sourceStream[encodedIndex] == DLE) {
 			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) {
 				destStream[decodedIndex] = nextByte;
 			} else {
+			    // The next byte is a STX, DTX or 0x0D character which
+			    // was escaped by a DLE character
 				if ((nextByte == 0x42) || (nextByte == 0x43)
 						|| (nextByte == 0x4D)) {
 					destStream[decodedIndex] = nextByte - 0x40;
 				} else {
-					return RETURN_FAILED;
+				    return DECODING_ERROR;
 				}
 			}
 			++encodedIndex;
@@ -38,7 +40,7 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 		++decodedIndex;
 	}
 	if (sourceStream[encodedIndex] != ETX) {
-		return RETURN_FAILED;
+		return DECODING_ERROR;
 	} else {
 		*readLen = ++encodedIndex;
 		*decodedLen = decodedIndex;
@@ -47,12 +49,12 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 }
 
 ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
-		uint32_t sourceLen, uint8_t* destStream, uint32_t maxDestLen,
-		uint32_t* encodedLen, bool addStxEtx) {
+		size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
+		size_t* encodedLen, bool addStxEtx) {
 	if (maxDestLen < 2) {
-		return RETURN_FAILED;
+		return STREAM_TOO_SHORT;
 	}
-	uint32_t encodedIndex = 0, sourceIndex = 0;
+	size_t encodedIndex = 0, sourceIndex = 0;
 	uint8_t nextByte;
 	if (addStxEtx) {
 		destStream[0] = STX;
@@ -62,15 +64,16 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 		nextByte = sourceStream[sourceIndex];
 		if ((nextByte == STX) || (nextByte == ETX) || (nextByte == 0x0D)) {
 			if (encodedIndex + 1 >= maxDestLen) {
-				return RETURN_FAILED;
+				return STREAM_TOO_SHORT;
 			} else {
 				destStream[encodedIndex] = DLE;
 				++encodedIndex;
+				// Escaped byte will be actual byte + 0x40.
 				destStream[encodedIndex] = nextByte + 0x40;
 			}
 		} else if (nextByte == DLE) {
 			if (encodedIndex + 1 >= maxDestLen) {
-				return RETURN_FAILED;
+			    return STREAM_TOO_SHORT;
 			} else {
 				destStream[encodedIndex] = DLE;
 				++encodedIndex;
@@ -90,6 +93,6 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 		*encodedLen = encodedIndex;
 		return RETURN_OK;
 	} else {
-		return RETURN_FAILED;
+		return STREAM_TOO_SHORT;
 	}
 }
diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index fc1556007..0f4a4c8fa 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -1,25 +1,71 @@
-#ifndef DLEENCODER_H_
-#define DLEENCODER_H_
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
 
 #include <framework/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 startr of the stream and an ETX marker at the end of
+ * the stream. Any STX, ETX and DLE occurences in the source stream are escaped
+ * by a DLE character.
+ */
 class DleEncoder: public HasReturnvaluesIF {
 private:
 	DleEncoder();
 	virtual ~DleEncoder();
 
 public:
+	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 const uint8_t STX = 0x02;
+	//! End Of Text character. Last character in encoded stream
 	static const uint8_t ETX = 0x03;
+	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
+	//! in the source stream.
 	static const uint8_t DLE = 0x10;
 
-	static ReturnValue_t decode(const uint8_t *sourceStream,
-			uint32_t sourceStreamLen, uint32_t *readLen, uint8_t *destStream,
-			uint32_t maxDestStreamlen, uint32_t *decodedLen);
+    /**
+     * 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.
+     * @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);
 
-	static ReturnValue_t encode(const uint8_t *sourceStream, uint32_t sourceLen,
-			uint8_t *destStream, uint32_t maxDestLen, uint32_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,
+			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+			size_t maxDestStreamlen, size_t *decodedLen);
 };
 
-#endif /* DLEENCODER_H_ */
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index abee534a1..7e4d89530 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -64,7 +64,8 @@ enum {
 	LOCAL_POOL_OWNER_IF, //LPIF 58
 	POOL_VARIABLE_IF, //PVA 59
 	HOUSEKEEPING_MANAGER, //HKM 60
-	PUS_PARSER, //PUSP 61
+	DLE_ENCODER, //DLEE 61
+	PUS_PARSER, //PUSP 62
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 359163886ba2d926cefe8f57b6691818a1e70b8e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 17:06:30 +0200
Subject: [PATCH 0537/1774] pus srv5 and 1 moved to framework

---
 framework.mk                            |   2 +-
 pus/Service1TelecommandVerification.cpp | 100 ++++++++++++++
 pus/Service1TelecommandVerification.h   |  94 ++++++++++++++
 pus/Service5EventReporting.cpp          |  92 +++++++++++++
 pus/Service5EventReporting.h            |  86 ++++++++++++
 pus/servicepackets/Service1Packets.h    | 166 ++++++++++++++++++++++++
 pus/servicepackets/Service5Packets.h    |  83 ++++++++++++
 7 files changed, 622 insertions(+), 1 deletion(-)
 create mode 100644 pus/Service1TelecommandVerification.cpp
 create mode 100644 pus/Service1TelecommandVerification.h
 create mode 100644 pus/Service5EventReporting.cpp
 create mode 100644 pus/Service5EventReporting.h
 create mode 100644 pus/servicepackets/Service1Packets.h
 create mode 100644 pus/servicepackets/Service5Packets.h

diff --git a/framework.mk b/framework.mk
index c88229814..bfbd4b1f7 100644
--- a/framework.mk
+++ b/framework.mk
@@ -58,4 +58,4 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/test/*.cpp)
\ No newline at end of file
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)
\ No newline at end of file
diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
new file mode 100644
index 000000000..4ce2ce54c
--- /dev/null
+++ b/pus/Service1TelecommandVerification.cpp
@@ -0,0 +1,100 @@
+#include <framework/pus/Service1TelecommandVerification.h>
+#include <framework/pus/servicepackets/Service1Packets.h>
+
+#include <framework/ipc/QueueFactory.h>
+#include <framework/tmtcservices/PusVerificationReport.h>
+#include <framework/tmtcpacket/pus/TmPacketStored.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tmtcservices/AcceptsTelemetryIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+
+Service1TelecommandVerification::Service1TelecommandVerification(
+        object_id_t objectId, uint16_t apid, uint8_t serviceId,
+        object_id_t targetDestination):
+        SystemObject(objectId), apid(apid), serviceId(serviceId),
+        targetDestination(targetDestination) {
+	tmQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Service1TelecommandVerification::~Service1TelecommandVerification() {}
+
+MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
+	return tmQueue->getId();
+}
+
+
+ReturnValue_t Service1TelecommandVerification::performOperation(
+		uint8_t operationCode){
+	PusVerificationMessage message;
+	ReturnValue_t status = tmQueue->receiveMessage(&message);
+	while(status == HasReturnvaluesIF::RETURN_OK) {
+		status = sendVerificationReport(&message);
+		if(status != HasReturnvaluesIF::RETURN_OK) {
+			return status;
+		}
+		status = tmQueue->receiveMessage(&message);
+	}
+	if (status == MessageQueueIF::EMPTY) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return status;
+	}
+}
+
+
+ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
+		PusVerificationMessage* message) {
+	ReturnValue_t result;
+	if(message->getReportId() % 2 == 0) {
+		result = generateFailureReport(message);
+	} else {
+		result = generateSuccessReport(message);
+	}
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Service1TelecommandVerification::initialize: "
+		        "Sending verification packet failed !" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t Service1TelecommandVerification::generateFailureReport(
+        PusVerificationMessage *message) {
+	FailureReport report(
+			message->getReportId(), message->getTcPacketId(),
+			message->getTcSequenceControl(), message->getStep(),
+			message->getErrorCode(), message->getParameter1(),
+			message->getParameter2());
+	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	        packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
+			tmQueue->getId());
+	return result;
+}
+
+ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
+        PusVerificationMessage *message) {
+	SuccessReport report(message->getReportId(),message->getTcPacketId(),
+			message->getTcSequenceControl(),message->getStep());
+	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	        packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
+			tmQueue->getId());
+	return result;
+}
+
+
+ReturnValue_t Service1TelecommandVerification::initialize() {
+	// Get target object for TC verification messages
+	AcceptsTelemetryIF* funnel = objectManager->
+			get<AcceptsTelemetryIF>(targetDestination);
+	if(funnel == nullptr){
+	    sif::error << "Service1TelecommandVerification::initialize: Specified"
+	            " TM funnel invalid. Make sure it is set up and implements"
+	            " AcceptsTelemetryIF." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
+	return SystemObject::initialize();
+}
diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h
new file mode 100644
index 000000000..1d4b67196
--- /dev/null
+++ b/pus/Service1TelecommandVerification.h
@@ -0,0 +1,94 @@
+#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+
+#include <framework/objectmanager/SystemObject.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+#include <framework/tmtcservices/AcceptsVerifyMessageIF.h>
+#include <framework/tmtcservices/PusVerificationReport.h>
+#include <framework/ipc/MessageQueueIF.h>
+
+/**
+ * @brief Verify TC acceptance, start, progress and execution.
+ *
+ * Full Documentation: ECSS-E70-41A p.51
+ *
+ * The telecommand verification service provides the capability for
+ * explicit verification of each distinct stage of execution of a telecommand
+ * packet, from on-board acceptance through to completion of execution.
+ *
+ * Minimum capabilities of this service:
+ *
+ *  - TM[1,1]: Telecommand Acceptance Report - Success.
+ *  - TM[1,2]: Telecommand Acceptance Report - Failure.
+ *
+ * Additional capabilities of this service:
+ *
+ *  - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4).
+ *  - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3).
+ *  - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6).
+ *  - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5).
+ *  - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8).
+ *  - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7).
+ *
+ * This Service is not inherited from PUSServiceBase unlike other PUS Services
+ * because all services implementing PUSServiceBase use this service to
+ * generate verification reports.
+ * @ingroup pus_services
+ */
+class Service1TelecommandVerification: public AcceptsVerifyMessageIF,
+		public SystemObject,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
+
+	Service1TelecommandVerification(object_id_t objectId,
+	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
+	virtual ~Service1TelecommandVerification();
+
+	/**
+	 *
+	 * @return ID of Verification Queue
+	 */
+	virtual MessageQueueId_t getVerificationQueue();
+
+	/**
+	 * Performs the service periodically as specified in init_mission().
+	 * Triggers the handlePacket function to send TC verification messages
+	 * @param operationCode
+	 * @return
+	 */
+	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+	/**
+	 * Initializes the destination for TC verification messages and initializes
+	 * Service 1 as a system object
+	 * @return
+	 */
+	ReturnValue_t initialize() override;
+private:
+	uint16_t apid = 0;
+	uint8_t serviceId = 0;
+
+	object_id_t targetDestination = objects::NO_OBJECT;
+
+	ReturnValue_t sendVerificationReport(PusVerificationMessage* message);
+	ReturnValue_t generateFailureReport(PusVerificationMessage* message);
+	ReturnValue_t generateSuccessReport(PusVerificationMessage* message);
+
+	uint16_t packetSubCounter = 0;
+
+	MessageQueueIF* tmQueue = nullptr;
+
+	enum class Subservice: uint8_t {
+		VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM]
+		VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM]
+		VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM]
+		VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM]
+		VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM]
+		VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM]
+	};
+};
+
+#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
new file mode 100644
index 000000000..fe55059c2
--- /dev/null
+++ b/pus/Service5EventReporting.cpp
@@ -0,0 +1,92 @@
+#include <framework/pus/Service5EventReporting.h>
+#include <framework/pus/servicepackets/Service5Packets.h>
+
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/events/EventManagerIF.h>
+#include <framework/ipc/QueueFactory.h>
+#include <framework/tmtcpacket/pus/TmPacketStored.h>
+
+
+Service5EventReporting::Service5EventReporting(object_id_t objectId,
+            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
+		PusServiceBase(objectId, apid, serviceId),
+		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
+	eventQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Service5EventReporting::~Service5EventReporting(){}
+
+ReturnValue_t Service5EventReporting::performService() {
+	EventMessage message;
+	ReturnValue_t status = RETURN_OK;
+	for(uint8_t counter = 0;
+	        counter < maxNumberReportsPerCycle;
+	        counter++)
+	{
+	    // Receive messages even if reporting is disabled for now.
+	    status = eventQueue->receiveMessage(&message);
+	    if(status == MessageQueueIF::EMPTY) {
+	        return HasReturnvaluesIF::RETURN_OK;
+	    }
+
+	    if(enableEventReport) {
+	       status = generateEventReport(message);
+	       if(status != HasReturnvaluesIF::RETURN_OK) {
+	           return status;
+	       }
+	    }
+	}
+	sif::debug <<  "Service5EventReporting::generateEventReport:"
+	        " Too many events" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service5EventReporting::generateEventReport(
+		EventMessage message)
+{
+	EventReport report(message.getEventId(),message.getReporter(),
+			message.getParameter1(),message.getParameter2());
+	TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
+			message.getSeverity(), packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(
+	        requestQueue->getDefaultDestination(),requestQueue->getId());
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "Service5EventReporting::generateEventReport:"
+		        " Could not send TM packet" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
+	switch(subservice)
+	{
+	case Subservice::ENABLE: {
+		enableEventReport = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case Subservice::DISABLE: {
+		enableEventReport = false;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+
+// In addition to the default PUSServiceBase initialization, this service needs
+// to be registered to the event manager to listen for events.
+ReturnValue_t Service5EventReporting::initialize() {
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+				objects::EVENT_MANAGER);
+	if (manager == NULL) {
+			return RETURN_FAILED;
+	}
+	// register Service 5 as listener for events
+	ReturnValue_t result =  manager->registerListener(eventQueue->getId(),true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+	     return result;
+	}
+	return PusServiceBase::initialize();
+}
diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h
new file mode 100644
index 000000000..79b7c5e7b
--- /dev/null
+++ b/pus/Service5EventReporting.h
@@ -0,0 +1,86 @@
+#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+
+#include <framework/tmtcservices/PusServiceBase.h>
+#include <framework/events/EventMessage.h>
+
+/**
+ * @brief Report on-board events like information or errors
+ * @details
+ * Full Documentation: ECSS-E70-41A p.79
+ * Implements the PusServiceBase template class.
+ * Documentation: Dissertation Baetz p.135,136
+ *
+ * This service provides for the reporting to the service user of information of
+ * operational significance.
+ *   1. reporting of failures or anomalies detected on-board;
+ *   2. reporting of autonomous on-board actions;
+ *   3. reporting of normal progress of operations and activities, e.g.
+ *   detection of events which are not anomalous (such as payload events),
+ *   reaching of predefined steps in an operation. Some reports can combine
+ *   more than one of these events.
+ *
+ * Minimum capabilities of this service:
+ *
+ * - TM[5,1]: Normal/Progress Report
+ * - TM[5,2]: Error/Anomaly Report - Low Severity
+ * - TM[5,3]: Error/Anomaly Report - Medium Severity
+ * - TM[5,4]: Error/Anomaly Report - High Severity
+ *
+ * Events can be translated by using translator files located in
+ * /config/objects/ and /config/events/. Description to events can be added by
+ * adding a comment behind the event definition with [//!<] as leading string
+ *
+ * Additional capabilities of this service:
+ *
+ *  - TC[5,5]: Enable Event Report Generation (Req. 6)
+ *  - TC[5,6]: Disable Event Report Generation (Req. 5)
+ * @author 	R. Mueller
+ * @ingroup pus_services
+ */
+class Service5EventReporting: public PusServiceBase {
+public:
+
+	Service5EventReporting(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
+	virtual ~Service5EventReporting();
+
+	/***
+	* Check for events and generate event reports if required.
+	* @return
+	*/
+	ReturnValue_t performService() override;
+
+	/***
+	 * Turn event generation on or off.
+	 * @return
+	 */
+	ReturnValue_t handleRequest(uint8_t subservice) override;
+
+	/**
+	 * The default PusServiceBase initialize has been overridden but is still
+	 * executed. Registers this service as a listener for events at the
+	 * EventManager.
+	 * @return
+	 */
+	ReturnValue_t initialize() override;
+
+	enum Subservice: uint8_t {
+		NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report
+		ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity
+		ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity
+		ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity
+		ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation
+		DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation
+	};
+
+private:
+	uint16_t packetSubCounter = 0;
+	MessageQueueIF* eventQueue = nullptr;
+	bool enableEventReport = true;
+	const uint8_t maxNumberReportsPerCycle;
+
+	ReturnValue_t generateEventReport(EventMessage message);
+};
+
+#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
new file mode 100644
index 000000000..b01942c6e
--- /dev/null
+++ b/pus/servicepackets/Service1Packets.h
@@ -0,0 +1,166 @@
+/**
+ * @defgroup spacepackets PUS Packet Definitions
+ *  This group contains all implemented TM or TM packages that are sent to
+ *  or sent by the OBC.They are exported later to display
+ *  packet structures in Mission Information Base (MIB).
+ */
+
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/tmtcservices/VerificationCodes.h>
+
+/**
+ * @brief 	FailureReport class to serialize a failure report
+ * @brief 	Subservice 1, 3, 5, 7
+ * @ingroup spacepackets
+ */
+class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
+public:
+	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
+			uint16_t packetSequenceControl_, uint8_t stepNumber_,
+			ReturnValue_t errorCode_, uint32_t errorParameter1_,
+			uint32_t errorParameter2_) :
+			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
+			stepNumber(stepNumber_), errorCode(errorCode_),
+			errorParameter1(errorParameter1_), errorParameter2(errorParameter2_),
+			failureSubtype(failureSubtype_) {}
+
+	/**
+	 * This function is called by the FSFW when calling the tm packet send
+	 * function and supplying the SerializeIF* as parameter
+	 * @param buffer Object content is serialized into the buffer
+	 * @param size
+	 * @param max_size
+	 * @param bigEndian
+	 * @return
+	 */
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	        size_t maxSize, SerializeIF::Endianness streamEndianness
+	        ) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
+			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
+			        maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		result = SerializeAdapter::serialize(&errorCode, buffer, size,
+		        maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&errorParameter1, buffer, size,
+		        maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		result = SerializeAdapter::serialize(&errorParameter2, buffer, size,
+		        maxSize, streamEndianness);
+		return result;
+	}
+
+
+	virtual size_t getSerializedSize() const {
+		size_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&packetId);
+		size += sizeof(packetSequenceControl);
+		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
+			size += SerializeAdapter::getSerializedSize(&stepNumber);
+		}
+		size += SerializeAdapter::getSerializedSize(&errorCode);
+		size += SerializeAdapter::getSerializedSize(&errorParameter1);
+		size += SerializeAdapter::getSerializedSize(&errorParameter2);
+		return size;
+	}
+
+	/**
+	 * Deserialization is not allowed for a report.
+	 * @param buffer
+	 * @param size
+	 * @param bigEndian
+	 * @return
+	 */
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
+	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
+	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
+	ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file
+	uint32_t errorParameter1;
+	uint32_t errorParameter2;
+	const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE]
+};
+
+/**
+ * @brief       Subservices 2, 4, 6, 8
+ * @ingroup     spacepackets
+ */
+class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
+public:
+	SuccessReport(uint8_t subtype_, uint16_t packetId_,
+			uint16_t packetSequenceControl_,uint8_t stepNumber_) :
+			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
+			stepNumber(stepNumber_), subtype(subtype_) {}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, SerializeIF::Endianness streamEndianness
+			) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
+			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
+					maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		size_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&packetId);
+		size += sizeof(packetSequenceControl);
+		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
+			size += SerializeAdapter::getSerializedSize(&stepNumber);
+		}
+		return size;
+
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
+	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
+	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
+	const uint8_t subtype; //!< [EXPORT] : [IGNORE]
+};
+
+#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */
diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h
new file mode 100644
index 000000000..f8f730c38
--- /dev/null
+++ b/pus/servicepackets/Service5Packets.h
@@ -0,0 +1,83 @@
+/**
+ * \file Service5Packets.h
+ *
+ * Structure of Event Report.
+ * It consists of:
+ * 		1. Report ID(RID). This is the Event ID in the FSFW
+ *		2. Object ID of the reporter (e.g. subsystem)
+ *		2. Parameter 1
+ *		3. Parameter 2
+ *
+ * Created on: 21.05.2019
+ * Author: R. Mueller, J. Meier
+ */
+
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/tmtcservices/VerificationCodes.h>
+
+
+/**
+ * \brief Subservice 1, 2, 3, 4
+ * \ingroup spacepackets
+ */
+class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
+public:
+
+	EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
+			uint32_t parameter2_):
+			reportId(reportId_),objectId(objectId_), parameter1(parameter1_),
+			parameter2(parameter2_) {}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override
+	{
+		ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&objectId, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&parameter1, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&parameter2, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		uint32_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&reportId);
+		size += SerializeAdapter::getSerializedSize(&objectId);
+		size += SerializeAdapter::getSerializedSize(&parameter1);
+		size += SerializeAdapter::getSerializedSize(&parameter2);
+		return size;
+
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	EventId_t reportId;
+	object_id_t objectId;
+	uint32_t parameter1;
+	uint32_t parameter2;
+};
+
+
+#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */

From 7698f3f13e4ff5886c6c56145e56111a49a6ff4f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 17:18:33 +0200
Subject: [PATCH 0538/1774] moved srv2 to framework

---
 pus/Service2DeviceAccess.cpp         | 178 +++++++++++++++++++++++++++
 pus/Service2DeviceAccess.h           |  96 +++++++++++++++
 pus/servicepackets/Service2Packets.h |  76 ++++++++++++
 pus/servicepackets/Service5Packets.h |  25 ++--
 4 files changed, 359 insertions(+), 16 deletions(-)
 create mode 100644 pus/Service2DeviceAccess.cpp
 create mode 100644 pus/Service2DeviceAccess.h
 create mode 100644 pus/servicepackets/Service2Packets.h

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
new file mode 100644
index 000000000..5c6ad5068
--- /dev/null
+++ b/pus/Service2DeviceAccess.cpp
@@ -0,0 +1,178 @@
+#include <framework/pus/Service2DeviceAccess.h>
+#include <framework/pus/servicepackets/Service2Packets.h>
+
+#include <framework/devicehandlers/DeviceHandlerIF.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/devicehandlers/DeviceHandlerMessage.h>
+#include <framework/serialize/EndianConverter.h>
+#include <framework/action/ActionMessage.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId, object_id_t tcSource,
+        object_id_t tmDestination):
+        CommandingServiceBase(objectId, apid, serviceId,
+	        NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS,
+	        tcSource, tmDestination) {}
+
+Service2DeviceAccess::~Service2DeviceAccess() {}
+
+ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
+	switch(static_cast<Subservice>(subservice)){
+	case Subservice::RAW_COMMANDING:
+	case Subservice::TOGGLE_WIRETAPPING:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		sif::error << "Invalid Subservice" << std::endl;
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
+		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+		MessageQueueId_t* id, object_id_t* objectId) {
+	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = checkInterfaceAndAcquireMessageQueue(id,objectId);
+	return result;
+
+}
+
+ReturnValue_t Service2DeviceAccess::checkAndAcquireTargetID(
+		object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) {
+	if(SerializeAdapter::deSerialize(objectIdToSet, &tcData,
+	        &tcDataLen, SerializeIF::Endianness::BIG) != RETURN_OK) {
+		sif::error << "Service 2: Target ID not found. ID: " <<
+				std::hex << objectIdToSet ;
+		return CommandingServiceBase::INVALID_TC;
+	}
+	else {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
+ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t * messageQueueToSet, object_id_t *objectId) {
+	DeviceHandlerIF* possibleTarget =
+			objectManager->get<DeviceHandlerIF>(*objectId);
+	if(possibleTarget == nullptr) {
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+	*messageQueueToSet = possibleTarget->getCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
+		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+		uint32_t* state, object_id_t objectId) {
+	switch(static_cast<Subservice>(subservice)){
+	case Subservice::RAW_COMMANDING: {
+		return prepareRawCommand(dynamic_cast<CommandMessage*>(message),
+				tcData, tcDataLen);
+	}
+	break;
+	case Subservice::TOGGLE_WIRETAPPING: {
+		return prepareWiretappingCommand(dynamic_cast<CommandMessage*>(message),
+				tcData, tcDataLen);
+	}
+	break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Service2DeviceAccess::prepareRawCommand(
+        CommandMessage* messageToSet, const uint8_t *tcData,size_t tcDataLen) {
+	RawCommand RawCommand(tcData,tcDataLen);
+	// store command into the Inter Process Communication Store
+	store_address_t storeAddress;
+	ReturnValue_t result = IPCStore->addData(&storeAddress,
+	        RawCommand.getCommand(), RawCommand.getCommandSize());
+	DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet,
+	        storeAddress);
+	return result;
+}
+
+ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand(
+		CommandMessage *messageToSet, const uint8_t *tcData,
+		size_t tcDataLen) {
+	if(tcDataLen != WiretappingToggle::WIRETAPPING_COMMAND_SIZE) {
+		return CommandingServiceBase::INVALID_TC;
+	}
+	WiretappingToggle command;
+	ReturnValue_t result = command.deSerialize(&tcData, &tcDataLen,
+	        SerializeIF::Endianness::BIG);
+	DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(messageToSet,
+			command.getWiretappingMode());
+	return result;
+}
+
+ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply,
+		Command_t previousCommand, uint32_t* state,
+		CommandMessage* optionalNextCommand, object_id_t objectId,
+		bool* isStep) {
+	switch(reply->getCommand()) {
+	case CommandMessage::REPLY_COMMAND_OK:
+		return HasReturnvaluesIF::RETURN_OK;
+	case CommandMessage::REPLY_REJECTED:
+		return reply->getReplyRejectedReason();
+	default:
+		return CommandingServiceBase::INVALID_REPLY;
+	}
+}
+
+// All device handlers set service 2 as default raw receiver for wiretapping
+// so we have to handle those unrequested messages.
+void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
+	switch(reply->getCommand()) {
+	case DeviceHandlerMessage::REPLY_RAW_COMMAND:
+		sendWiretappingTm(reply,
+				static_cast<uint8_t>(Subservice::WIRETAPPING_RAW_TC));
+		break;
+	case DeviceHandlerMessage::REPLY_RAW_REPLY:
+		sendWiretappingTm(reply,
+				static_cast<uint8_t>(Subservice::RAW_REPLY));
+		break;
+	default:
+		sif::error << "Unknown message in Service2DeviceAccess::"
+				"handleUnrequestedReply with command ID " <<
+				reply->getCommand() << std::endl;
+		break;
+	}
+	//Must be reached by all cases to clear message
+	reply->clear();
+}
+
+void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
+		uint8_t subservice) {
+	// Raw Wiretapping
+	// Get Address of Data from Message
+	store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply);
+	const uint8_t* data = nullptr;
+	size_t size = 0;
+	ReturnValue_t result = IPCStore->getData(storeAddress,&data,&size);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
+		        "handleUnrequestedReply with failure ID "<< result
+		        << std::endl;
+		return;
+	}
+
+	// Init our dummy packet and correct endianness of object ID before
+	// sending it back.
+	WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply),
+	        data);
+	TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId);
+	sendTmPacket(subservice,TmPacket.data,size,reinterpret_cast<uint8_t*>(
+			&TmPacket.objectId),sizeof(TmPacket.objectId));
+}
+
+MessageQueueId_t Service2DeviceAccess::getDeviceQueue() {
+	return commandQueue->getId();
+}
+
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
new file mode 100644
index 000000000..ecab61019
--- /dev/null
+++ b/pus/Service2DeviceAccess.h
@@ -0,0 +1,96 @@
+#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
+#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
+
+#include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
+#include <framework/tmtcservices/CommandingServiceBase.h>
+
+/**
+ * @brief   Raw Commanding and Wiretapping of devices.
+ * @details
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This service provides the capability to communicate with devices in their
+ * native protocols with raw commands through the DeviceHandlerIF.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * This service is very closely tied to the Commanding Service Base
+ * template class. There is constant interaction between this Service Base und
+ * a Subclass like this service
+ * There are 4 adaption points for component implementation through the
+ * Commanding Service Base.
+ *
+ * This service employs custom subservices exclusively.  This includes a
+ * wiretapping subservice to monitor all traffic between target devices and
+ * this service.
+ *
+ *   - TC[2,128]: Raw Commanding
+ *   - TC[2,129]: Toggle Wiretapping
+ *   - TM[2,130]: Wiretapping Packet TM
+ *   - TM[2,131]: Wiretapping Packet TC
+ * @ingroup pus_services
+ */
+class Service2DeviceAccess : public CommandingServiceBase,
+		public AcceptsDeviceResponsesIF
+{
+public:
+	Service2DeviceAccess(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId, object_id_t tcSource,
+	        object_id_t tmDestination);
+	virtual ~Service2DeviceAccess();
+
+	static constexpr uint8_t NUM_OF_PARALLEL_COMMANDS = 4;
+	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+protected:
+	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+	        const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message, uint8_t subservice,
+	        const uint8_t *tcData, size_t tcDataLen, uint32_t *state,
+	        object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+				Command_t previousCommand, uint32_t *state,
+				CommandMessage* optionalNextCommand, object_id_t objectId,
+				bool *isStep) override;
+
+	/**
+	 * @brief 	Generates TM packets containing either the TC wiretapping
+	 * 			packets or the TM wiretapping packets.
+	 * Note that for service 2, all telemetry will be treated as an
+	 * unrequested reply regardless of wiretapping mode.
+	 * @param reply
+	 */
+	void handleUnrequestedReply(CommandMessage* reply) override;
+
+	MessageQueueId_t getDeviceQueue() override;
+private:
+	/**
+	 * Generates TM packets for Wiretapping Service
+	 * @param reply
+	 * @param subservice
+	 */
+	void sendWiretappingTm(CommandMessage* reply,uint8_t subservice);
+
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+	        const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
+
+	ReturnValue_t prepareRawCommand(CommandMessage* messageToSet,
+	        const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t prepareWiretappingCommand(CommandMessage* messageToSet,
+	        const uint8_t* tcData, size_t tcDataLen);
+
+	enum class Subservice {
+		RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol
+		TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
+		RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
+		WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
+	};
+};
+
+
+#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */
diff --git a/pus/servicepackets/Service2Packets.h b/pus/servicepackets/Service2Packets.h
new file mode 100644
index 000000000..f292611e7
--- /dev/null
+++ b/pus/servicepackets/Service2Packets.h
@@ -0,0 +1,76 @@
+#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+
+#include <framework/action/ActionMessage.h>
+#include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+/**
+ * @brief Subservice 128
+ * @ingroup spacepackets
+ */
+class RawCommand { //!< [EXPORT] : [SUBSERVICE] 128
+public:
+	RawCommand(const uint8_t* buffer, size_t size) {
+		// Deserialize Adapter to get correct endianness
+		SerializeAdapter::deSerialize(&objectId, &buffer, &size,
+		        SerializeIF::Endianness::BIG);
+		commandBuffer = buffer;
+		// size is decremented by AutoSerializeAdapter,
+		// remaining size is data size
+		dataSize = size;
+	}
+	object_id_t getObjectId() const {
+		return objectId;
+	}
+
+	const uint8_t*  getCommand() {
+		return commandBuffer;
+	}
+
+	size_t getCommandSize() const {
+		return dataSize;
+	}
+private:
+	object_id_t objectId = 0;
+	const uint8_t* commandBuffer = nullptr; //!< [EXPORT] : [MAXSIZE] 256 Bytes
+	size_t dataSize = 0; //!< [EXPORT] : [IGNORE]
+};
+
+
+/**
+ * @brief Subservice 129: Command packet to set wiretapping mode
+ * @ingroup spacepackets
+ */
+class WiretappingToggle: public SerialLinkedListAdapter<SerializeIF>{ //!< [EXPORT] : [SUBSERVICE] 129
+public:
+	static const size_t WIRETAPPING_COMMAND_SIZE = 5;
+	WiretappingToggle(){
+		setStart(&objectId);
+		objectId.setNext(&wiretappingMode);
+	}
+
+	uint8_t getWiretappingMode() const {
+		return wiretappingMode.entry;
+	}
+private:
+	SerializeElement<object_id_t> objectId;
+	SerializeElement<uint8_t> wiretappingMode; //!< [EXPORT] : [INPUT] Mode 0: OFF, Mode 1: RAW
+};
+
+
+/**
+ * @brief Subservices 130 and 131: TM packets
+ * @ingroup spacepackets
+ */
+class WiretappingPacket { //!< [EXPORT] : [SUBSERVICE] 130, 131
+public:
+	object_id_t objectId; //!< [EXPORT] : [COMMENT] Object ID of source object
+	const uint8_t* data; //!< [EXPORT] : [MAXSIZE] Raw Command Max. Size
+	WiretappingPacket(object_id_t objectId, const uint8_t* buffer):
+	    objectId(objectId), data(buffer) {
+	}
+};
+
+#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h
index f8f730c38..14219c936 100644
--- a/pus/servicepackets/Service5Packets.h
+++ b/pus/servicepackets/Service5Packets.h
@@ -1,17 +1,3 @@
-/**
- * \file Service5Packets.h
- *
- * Structure of Event Report.
- * It consists of:
- * 		1. Report ID(RID). This is the Event ID in the FSFW
- *		2. Object ID of the reporter (e.g. subsystem)
- *		2. Parameter 1
- *		3. Parameter 2
- *
- * Created on: 21.05.2019
- * Author: R. Mueller, J. Meier
- */
-
 #ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
 #define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
 
@@ -20,8 +6,15 @@
 
 
 /**
- * \brief Subservice 1, 2, 3, 4
- * \ingroup spacepackets
+ * @brief Subservice 1, 2, 3, 4
+ * Structure of Event Report.
+ * It consists of:
+ *      1. Report ID(RID). This is the Event ID in the FSFW
+ *      2. Object ID of the reporter (e.g. subsystem)
+ *      2. Parameter 1
+ *      3. Parameter 2
+ *
+ * @ingroup spacepackets
  */
 class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
 public:

From 684b56ac883b0ee0528edc55b492977518611430 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 17:21:47 +0200
Subject: [PATCH 0539/1774] srv2 tweak: CSB params now configurable

---
 pus/Service2DeviceAccess.cpp |  5 +++--
 pus/Service2DeviceAccess.h   | 15 +++++++--------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 5c6ad5068..d1f8faf3b 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -12,9 +12,10 @@
 
 Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
         uint16_t apid, uint8_t serviceId, object_id_t tcSource,
-        object_id_t tmDestination):
+        object_id_t tmDestination, uint8_t numberOfParallelCommands,
+        uint16_t commandTimeoutSeconds):
         CommandingServiceBase(objectId, apid, serviceId,
-	        NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS,
+	        numberOfParallelCommands, commandTimeoutSeconds,
 	        tcSource, tmDestination) {}
 
 Service2DeviceAccess::~Service2DeviceAccess() {}
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index ecab61019..20fc30b92 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -14,12 +14,12 @@
  * This service provides the capability to communicate with devices in their
  * native protocols with raw commands through the DeviceHandlerIF.
  *
- * This is a gateway service. It relays device commands using the software bus.
- * This service is very closely tied to the Commanding Service Base
- * template class. There is constant interaction between this Service Base und
- * a Subclass like this service
+ * This is a gateway service. It relays device commands to the software bus.
+ * This service is very closely tied to the CommandingServiceBase
+ * template class.
+ *
  * There are 4 adaption points for component implementation through the
- * Commanding Service Base.
+ * CommandingServiceBase.
  *
  * This service employs custom subservices exclusively.  This includes a
  * wiretapping subservice to monitor all traffic between target devices and
@@ -37,11 +37,10 @@ class Service2DeviceAccess : public CommandingServiceBase,
 public:
 	Service2DeviceAccess(object_id_t objectId, uint16_t apid,
 	        uint8_t serviceId, object_id_t tcSource,
-	        object_id_t tmDestination);
+	        object_id_t tmDestination, uint8_t numberOfParallelCommands = 4,
+	        uint16_t commandTimeoutSeconds = 60);
 	virtual ~Service2DeviceAccess();
 
-	static constexpr uint8_t NUM_OF_PARALLEL_COMMANDS = 4;
-	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
 protected:
 	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
 	ReturnValue_t isValidSubservice(uint8_t subservice) override;

From 06d389ed1e6157f1fe736c5dacf121eec247ea14 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 17:25:52 +0200
Subject: [PATCH 0540/1774] increased srv2 readability

---
 pus/Service2DeviceAccess.cpp | 24 ++++++------------------
 pus/Service2DeviceAccess.h   |  2 --
 2 files changed, 6 insertions(+), 20 deletions(-)

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index d1f8faf3b..ee48b46dd 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -34,29 +34,17 @@ ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
 ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
 		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
 		MessageQueueId_t* id, object_id_t* objectId) {
-	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData,
+                &tcDataLen, SerializeIF::Endianness::BIG);
 
-	result = checkInterfaceAndAcquireMessageQueue(id,objectId);
+	ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
 	return result;
 
 }
 
-ReturnValue_t Service2DeviceAccess::checkAndAcquireTargetID(
-		object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) {
-	if(SerializeAdapter::deSerialize(objectIdToSet, &tcData,
-	        &tcDataLen, SerializeIF::Endianness::BIG) != RETURN_OK) {
-		sif::error << "Service 2: Target ID not found. ID: " <<
-				std::hex << objectIdToSet ;
-		return CommandingServiceBase::INVALID_TC;
-	}
-	else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
-
 ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
 		MessageQueueId_t * messageQueueToSet, object_id_t *objectId) {
 	DeviceHandlerIF* possibleTarget =
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index 20fc30b92..4dab0fa0a 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -73,8 +73,6 @@ private:
 	 */
 	void sendWiretappingTm(CommandMessage* reply,uint8_t subservice);
 
-	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
-	        const uint8_t* tcData, size_t tcDataLen);
 	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
 	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
 

From dd48f7ccadc824b275ea3bf2af0da1c9820ad61b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 17:28:00 +0200
Subject: [PATCH 0541/1774] some form improvements

---
 pus/Service2DeviceAccess.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index ee48b46dd..391c11164 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -144,7 +144,7 @@ void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
 	store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply);
 	const uint8_t* data = nullptr;
 	size_t size = 0;
-	ReturnValue_t result = IPCStore->getData(storeAddress,&data,&size);
+	ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
 	if(result != HasReturnvaluesIF::RETURN_OK){
 		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
 		        "handleUnrequestedReply with failure ID "<< result
@@ -157,8 +157,8 @@ void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
 	WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply),
 	        data);
 	TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId);
-	sendTmPacket(subservice,TmPacket.data,size,reinterpret_cast<uint8_t*>(
-			&TmPacket.objectId),sizeof(TmPacket.objectId));
+	sendTmPacket(subservice, TmPacket.data,size, reinterpret_cast<uint8_t*>(
+			&TmPacket.objectId), sizeof(TmPacket.objectId));
 }
 
 MessageQueueId_t Service2DeviceAccess::getDeviceQueue() {

From 399fc0e287048b1fb8e1343185d637c78a791a80 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 17:42:37 +0200
Subject: [PATCH 0542/1774] fifo replacements

---
 container/DynamicFIFO.h              | 27 +++++++++++++++++++++++++
 container/FIFO.h                     | 23 +++++++++------------
 container/FIFOBase.h                 |  4 ----
 container/SimpleRingBuffer.cpp       |  6 +++---
 container/SimpleRingBuffer.h         |  2 +-
 container/StaticFIFO.h               | 30 ----------------------------
 tmtcservices/CommandingServiceBase.h |  4 ++--
 tmtcservices/PusParser.cpp           |  2 +-
 tmtcservices/PusParser.h             |  7 +++----
 tmtcservices/TmTcBridge.h            |  4 ++--
 10 files changed, 48 insertions(+), 61 deletions(-)
 create mode 100644 container/DynamicFIFO.h
 delete mode 100644 container/StaticFIFO.h

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
new file mode 100644
index 000000000..3a5242c7e
--- /dev/null
+++ b/container/DynamicFIFO.h
@@ -0,0 +1,27 @@
+#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+
+#include <framework/container/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>(values.data(), maxCapacity),
+			values(maxCapacity) {};
+
+private:
+	std::vector<T> values;
+};
+
+#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index 19daaf1be..ecb218fda 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -1,31 +1,26 @@
 #ifndef FRAMEWORK_CONTAINER_FIFO_H_
 #define FRAMEWORK_CONTAINER_FIFO_H_
 
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/container/FIFOBase.h>
-#include <vector>
-
-namespace fsfw {
+#include <array>
 
 /**
- * @brief 	Simple First-In-First-Out data structure. The maximum size
- * 			can be set in the constructor.
+ * @brief 	Simple First-In-First-Out data structure with size fixed at
+ * 			compile time
  * @details
- * The maximum capacity can be determined at run-time, so this container
- * performs dynamic memory allocation!
+ * 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>
+template<typename T, size_t capacity>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
-			values(maxCapacity) {};
+	FIFO(): FIFOBase<T>(values.data(), capacity) {};
 
 private:
-	std::vector<T> values;
+	std::array<T, capacity> values;
 };
 
-}
-
-#endif /* FRAMEWORK_CONTAINER_FIFO_H_ */
+#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index 6ed7d924b..8bdb333f8 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -4,8 +4,6 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
 
-namespace fsfw {
-
 template <typename T>
 class FIFOBase {
 public:
@@ -60,6 +58,4 @@ private:
 
 #include <framework/container/FIFOBase.tpp>
 
-}
-
 #endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 4e50109be..731c9dc92 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -17,7 +17,7 @@ SimpleRingBuffer::~SimpleRingBuffer() {
 
 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);
@@ -43,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) {
@@ -65,7 +65,7 @@ ReturnValue_t SimpleRingBuffer::deleteData(uint32_t amount,
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
-	if (trueAmount != NULL) {
+	if (trueAmount != nullptr) {
 		*trueAmount = amount;
 	}
 	incrementRead(amount, READ_PTR);
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index b5bc2c1c6..30dd184cd 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
 
 #include <framework/container/RingBufferBase.h>
-#include <stddef.h>
+#include <cstddef>
 
 /**
  * @brief 	Circular buffer implementation, useful for buffering
diff --git a/container/StaticFIFO.h b/container/StaticFIFO.h
deleted file mode 100644
index f31282004..000000000
--- a/container/StaticFIFO.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef FRAMEWORK_CONTAINER_STATICFIFO_H_
-#define FRAMEWORK_CONTAINER_STATICFIFO_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/container/FIFOBase.h>
-#include <array>
-
-namespace fsfw {
-
-/**
- * @brief 	Simple First-In-First-Out data structure with size fixed at
- * 			compile time
- * @details
- * Performs no dynamic memory allocation.
- * The public interface of FIFOBase exposes the user interface for the FIFO.
- * @tparam T Entry Type
- * @tparam capacity Maximum capacity
- */
-template<typename T, size_t capacity>
-class StaticFIFO: public FIFOBase<T> {
-public:
-	StaticFIFO(): FIFOBase<T>(values.data(), capacity) {};
-
-private:
-	std::array<T, capacity> values;
-};
-
-}
-
-#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 72fe13f2f..700503c69 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -10,7 +10,7 @@
 #include <framework/tmtcservices/VerificationReporter.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/container/FixedMap.h>
-#include <framework/container/StaticFIFO.h>
+#include <framework/container/FIFO.h>
 #include <framework/serialize/SerializeIF.h>
 
 class TcPacketStored;
@@ -199,7 +199,7 @@ protected:
 		uint32_t state;
 		Command_t command;
 		object_id_t objectId;
-		fsfw::StaticFIFO<store_address_t, 3> fifo;
+		FIFO<store_address_t, 3> fifo;
 	};
 
 	using CommandMapIter = FixedMap<MessageQueueId_t,
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index 175c28934..4198e36ea 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -64,7 +64,7 @@ ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-fsfw::FIFO<PusParser::indexSizePair>* PusParser::fifo(){
+DynamicFIFO<PusParser::indexSizePair>* PusParser::fifo(){
 	return &indexSizePairFIFO;
 }
 
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
index 82aff57e1..88570bb29 100644
--- a/tmtcservices/PusParser.h
+++ b/tmtcservices/PusParser.h
@@ -1,8 +1,7 @@
 #ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
 #define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
 
-#include <framework/container/FIFO.h>
-
+#include <framework/container/DynamicFIFO.h>
 #include <utility>
 #include <cstdint>
 
@@ -55,7 +54,7 @@ public:
 	 * by the parsePusPackets() function.
 	 * @return
 	 */
-	fsfw::FIFO<indexSizePair>* fifo();
+	DynamicFIFO<indexSizePair>* fifo();
 
 	/**
 	 * Retrieve the next index and packet size pair from the FIFO.
@@ -69,7 +68,7 @@ private:
 	//! A FIFO is used to store information about multiple PUS packets
 	//! inside the receive buffer. The maximum number of entries is defined
 	//! by the first constructor argument.
-	fsfw::FIFO<indexSizePair> indexSizePairFIFO;
+	DynamicFIFO<indexSizePair> indexSizePairFIFO;
 
 	bool storeSplitPackets = false;
 
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 23f7dcfa4..5b933c793 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 #define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 
+#include <framework/container/FIFO.h>
 #include <framework/tmtcservices/AcceptsTelemetryIF.h>
 #include <framework/tasks/ExecutableObjectIF.h>
 #include <framework/ipc/MessageQueueIF.h>
@@ -8,7 +9,6 @@
 #include <framework/objectmanager/SystemObject.h>
 
 #include <framework/tmtcservices/TmTcMessage.h>
-#include <framework/container/StaticFIFO.h>
 
 class TmTcBridge : public AcceptsTelemetryIF,
 		public ExecutableObjectIF,
@@ -143,7 +143,7 @@ protected:
 	 * This fifo can be used to store downlink data
 	 * which can not be sent at the moment.
 	 */
-	fsfw::StaticFIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
+	FIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
     uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
     uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };

From 2efcda735f84166665c2c1b42dc604048a7bbb34 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 02:20:38 +0200
Subject: [PATCH 0543/1774] message arriving.

big clean up in tcdistribution folder
---
 osal/linux/TcUnixUdpPollingTask.cpp |  73 +++++++++++-----
 osal/linux/TcUnixUdpPollingTask.h   |  13 ++-
 osal/linux/TmTcUnixUdpBridge.cpp    |  15 ++--
 osal/linux/TmTcUnixUdpBridge.h      |   2 +-
 tcdistribution/CCSDSDistributor.cpp |  39 +++++----
 tcdistribution/CCSDSDistributor.h   |  87 ++++++++++---------
 tcdistribution/PUSDistributor.cpp   |   4 +-
 tcdistribution/PUSDistributor.h     |  52 +++++++-----
 tcdistribution/TcDistributor.cpp    |   5 +-
 tcdistribution/TcDistributor.h      | 124 ++++++++++++++--------------
 tmtcservices/PusServiceBase.cpp     |  11 ++-
 tmtcservices/TmTcBridge.h           |   2 +-
 12 files changed, 253 insertions(+), 174 deletions(-)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index f237a0f26..83f7a3da1 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,6 +1,7 @@
 #include <framework/osal/linux/TcUnixUdpPollingTask.h>
+#include <framework/globalfunctions/arrayprinter.h>
 
-TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
+TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,
 		double timeoutSeconds): SystemObject(objectId),
 		tmtcBridgeId(tmtcUnixUdpBridge) {
@@ -23,23 +24,13 @@ TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
 	else {
 		receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
 	}
-
-	// Set receive timeout.
-	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
-			&receptionTimeout, sizeof(receptionTimeout));
-	if(result == -1) {
-		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting receive"
-				"timeout failed with " << strerror(errno) << std::endl;
-		return;
-	}
 }
 
-TcSocketPollingTask::~TcSocketPollingTask() {
+TcUnixUdpPollingTask::~TcUnixUdpPollingTask() {
 }
 
-ReturnValue_t TcSocketPollingTask::performOperation(uint8_t opCode) {
-	// Poll for new data permanently. The call will block until the specified
-	// length of bytes has been received or a timeout occured.
+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;
@@ -48,21 +39,34 @@ ReturnValue_t TcSocketPollingTask::performOperation(uint8_t opCode) {
 				receptionBuffer.data(), frameSize, receptionFlags,
 				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
 		if(bytesReceived < 0) {
-			//handle error
+			// handle error
 			sif::error << "TcSocketPollingTask::performOperation: recvfrom "
 					"failed with " << strerror(errno) << std::endl;
+			if(errno == EAGAIN or errno == EWOULDBLOCK) {
+				sif::info << "timeout" << std::endl;
+			}
 			continue;
 		}
 		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
 				<< " bytes received" << std::endl;
 
-		ReturnValue_t result = handleSuccessfullTcRead();
+		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
+		if(result != HasReturnvaluesIF::RETURN_FAILED) {
+
+		}
 		tmtcBridge->checkAndSetClientAddress(senderAddress);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t TcSocketPollingTask::initialize() {
+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"
@@ -70,10 +74,41 @@ ReturnValue_t TcSocketPollingTask::initialize() {
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
+	targetTcDestination = tmtcBridge->getReportReceptionQueue();
+
 	serverUdpSocket = tmtcBridge->serverSocket;
+
+	// Set receive timeout.
+//	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+//			&receptionTimeout, sizeof(receptionTimeout));
+//	if(result == -1) {
+//		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+//				"receive timeout failed with " << strerror(errno) << std::endl;
+//		return ObjectManagerIF::CHILD_INIT_FAILED;
+//	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t TcSocketPollingTask::handleSuccessfullTcRead() {
-	return HasReturnvaluesIF::RETURN_OK;
+ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
+	store_address_t storeId = 0;
+	ReturnValue_t result = tcStore->addData(&storeId,
+			receptionBuffer.data(), bytesRead);
+	// arrayprinter::print(receptionBuffer.data(), bytesRead);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+				"storage failed" << std::endl;
+		sif::debug << "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;
 }
+
+
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index a6b0e9d47..3503d5056 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -1,5 +1,6 @@
 #ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
 #define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/osal/linux/TmTcUnixUdpBridge.h>
 #include <framework/tasks/ExecutableObjectIF.h>
@@ -16,7 +17,7 @@
  * This class caches the IP address of the sender. It is assumed there
  * is only one sender for now.
  */
-class TcSocketPollingTask: public SystemObject,
+class TcUnixUdpPollingTask: public SystemObject,
 		public ExecutableObjectIF {
 	friend class TmTcUnixUdpBridge;
 public:
@@ -24,17 +25,21 @@ public:
 	//! 0.5  default milliseconds timeout for now.
 	static constexpr timeval DEFAULT_TIMEOUT = {.tv_sec = 0, .tv_usec = 500};
 
-	TcSocketPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+	TcUnixUdpPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
 			size_t frameSize = 0, double timeoutSeconds = -1);
-	virtual~ TcSocketPollingTask();
+	virtual~ TcUnixUdpPollingTask();
 
 	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 	virtual ReturnValue_t initialize() 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;
 
@@ -47,7 +52,7 @@ private:
 	size_t frameSize = 0;
 	timeval receptionTimeout;
 
-	ReturnValue_t handleSuccessfullTcRead();
+	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
 
 };
 
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 710761b44..a337b8ae2 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -101,7 +101,7 @@ void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
 void TmTcUnixUdpBridge::handleBindError() {
 	// See: https://man7.org/linux/man-pages/man2/bind.2.html
 	switch(errno) {
-	case(EACCES):
+	case(EACCES): {
 		/*
 		 Ephermeral ports can be shown with following command:
 		 sysctl -A | grep ip_local_port_range
@@ -110,7 +110,8 @@ void TmTcUnixUdpBridge::handleBindError() {
 				"Ports 1-1024 are reserved on UNIX systems and require root "
 				"rights while ephermeral ports should not be used as well."
 				<< std::endl;
-		break;
+	}
+	break;
 	case(EADDRINUSE):
 	case(EBADF):
 	case(EINVAL):
@@ -122,15 +123,17 @@ void TmTcUnixUdpBridge::handleBindError() {
 	case(ENOENT):
 	case(ENOMEM):
 	case(ENOTDIR):
-	case(EROFS):
+	case(EROFS): {
 		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
-					<< " with " << strerror(errno) << std::endl;
+				<< " with " << strerror(errno) << std::endl;
 		break;
-	default:
+	}
+	default: {
 		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
-						<< std::endl;
+				<< std::endl;
 		break;
 	}
+	}
 }
 
 
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index 15d256cd4..2fb606b0e 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -7,7 +7,7 @@
 #include <netinet/udp.h>
 
 class TmTcUnixUdpBridge: public TmTcBridge {
-	friend class TcSocketPollingTask;
+	friend class TcUnixUdpPollingTask;
 public:
 	// The ports chosen here should not be used by any other process.
 	// List of used ports on Linux: /etc/services
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index 878b8f7d5..199e2ed15 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -2,30 +2,37 @@
 #include <framework/tcdistribution/CCSDSDistributor.h>
 #include <framework/tmtcpacket/SpacePacketBase.h>
 
-CCSDSDistributor::CCSDSDistributor( uint16_t setDefaultApid, object_id_t setObjectId ) :
-		TcDistributor( setObjectId ), default_apid( setDefaultApid ), tcStore(NULL) {
+CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
+		object_id_t setObjectId):
+		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
 }
 
-CCSDSDistributor::~CCSDSDistributor() {
+CCSDSDistributor::~CCSDSDistributor() {}
 
-}
-
-iterator_t CCSDSDistributor::selectDestination() {
-//	debug << "CCSDSDistributor::selectDestination received: " << this->currentMessage.getStorageId().pool_index << ", " << this->currentMessage.getStorageId().packet_index << std::endl;
-	const uint8_t* p_packet = NULL;
+TcDistributor::TcMessageQueueMapIter CCSDSDistributor::selectDestination() {
+//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
+//			this->currentMessage.getStorageId().pool_index << ", " <<
+//			this->currentMessage.getStorageId().packet_index << std::endl;
+	const uint8_t* packet = nullptr;
 	size_t size = 0;
-	//TODO check returncode?
-	this->tcStore->getData( this->currentMessage.getStorageId(), &p_packet, &size );
-	SpacePacketBase current_packet( p_packet );
-//	info << "CCSDSDistributor::selectDestination has packet with APID " << std::hex << current_packet.getAPID() << std::dec << std::endl;
-	iterator_t position = this->queueMap.find( current_packet.getAPID() );
+	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
+			&packet, &size );
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
+				"store failed!" << std::endl;
+	}
+	SpacePacketBase currentPacket(packet);
+
+//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
+//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
+	TcMessageQueueMapIter position = this->queueMap.find(currentPacket.getAPID());
 	if ( position != this->queueMap.end() ) {
 		return position;
 	} else {
-		//The APID was not found. Forward packet to main SW-APID anyway to create acceptance failure report.
-		return this->queueMap.find( this->default_apid );
+		//The APID was not found. Forward packet to main SW-APID anyway to
+		// create acceptance failure report.
+		return this->queueMap.find( this->defaultApid );
 	}
-
 }
 
 MessageQueueId_t CCSDSDistributor::getRequestQueue() {
diff --git a/tcdistribution/CCSDSDistributor.h b/tcdistribution/CCSDSDistributor.h
index 9dce34f2b..22025f760 100644
--- a/tcdistribution/CCSDSDistributor.h
+++ b/tcdistribution/CCSDSDistributor.h
@@ -1,58 +1,69 @@
-#ifndef CCSDSDISTRIBUTOR_H_
-#define CCSDSDISTRIBUTOR_H_
+#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <framework/tcdistribution/CCSDSDistributorIF.h>
 #include <framework/tcdistribution/TcDistributor.h>
 #include <framework/tmtcservices/AcceptsTelecommandsIF.h>
+
 /**
- * An instantiation of the CCSDSDistributorIF.
- * It receives Space Packets, and selects a destination depending on the APID of the telecommands.
+ * @brief 	An instantiation of the CCSDSDistributorIF.
+ * @details
+ * It receives Space Packets, and selects a destination depending on the
+ * APID of the telecommands.
  * The Secondary Header (with Service/Subservice) is ignored.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
-class CCSDSDistributor : public TcDistributor, public CCSDSDistributorIF, public AcceptsTelecommandsIF {
-protected:
-	/**
-	 * This implementation checks if an Application with fitting APID has registered and forwards the
-	 * packet to the according message queue.
-	 * If the packet is not found, it returns the queue to \c default_apid, where a Acceptance Failure
-	 * message should be generated.
-	 * @return Iterator to map entry of found APID or iterator to default APID.
-	 */
-	iterator_t selectDestination();
-	/**
-	 * The default APID, where packets with unknown APID are sent to.
-	 */
-	uint16_t default_apid;
-	/**
-	 * A reference to the TC storage must be maintained, as this class handles pure Space Packets and there
-	 * exists no SpacePacketStored class.
-	 */
-	StorageManagerIF* tcStore;
-	/**
-	 * The callback here handles the generation of acceptance success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+class CCSDSDistributor : public TcDistributor,
+		public CCSDSDistributorIF,
+		public AcceptsTelecommandsIF {
 public:
 	/**
-	 * The constructor sets the default APID and calls the TcDistributor ctor with a certain object id.
-	 * \c tcStore is set in the \c initialize method.
-	 * @param set_default_apid The default APID, where packets with unknown destination are sent to.
+	 * @brief	The constructor sets the default APID and calls the
+	 * 			TcDistributor ctor with a certain object id.
+	 * @details
+	 * @c tcStore is set in the @c initialize method.
+	 * @param set_default_apid The default APID, where packets with unknown
+	 * destination are sent to.
 	 */
 	CCSDSDistributor( uint16_t setDefaultApid, object_id_t setObjectId );
 	/**
 	 * The destructor is empty.
 	 */
 	~CCSDSDistributor();
-	MessageQueueId_t getRequestQueue();
-	ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id );
-	ReturnValue_t registerApplication( AcceptsTelecommandsIF* application );
+
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t registerApplication( uint16_t apid,
+			MessageQueueId_t id) override;
+	ReturnValue_t registerApplication(
+			AcceptsTelecommandsIF* application) override;
 	uint16_t getIdentifier();
-	ReturnValue_t initialize();
+	ReturnValue_t initialize() override;
+
+protected:
+	/**
+	 * This implementation checks if an application with fitting APID has
+	 * registered and forwards the packet to the according message queue.
+	 * If the packet is not found, it returns the queue to @c defaultApid,
+	 * where a Acceptance Failure message should be generated.
+	 * @return Iterator to map entry of found APID or iterator to default APID.
+	 */
+	TcMessageQueueMapIter selectDestination();
+	/**
+	 * The default APID, where packets with unknown APID are sent to.
+	 */
+	uint16_t defaultApid;
+	/**
+	 * A reference to the TC storage must be maintained, as this class handles
+	 * pure Space Packets and there exists no SpacePacketStored class.
+	 */
+	StorageManagerIF* tcStore = nullptr;
+	/**
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
 };
 
-
-
-#endif /* CCSDSDISTRIBUTOR_H_ */
+#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index bcf6d5717..f13b5f8de 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -12,9 +12,9 @@ PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
 
 PUSDistributor::~PUSDistributor() {}
 
-iterator_t PUSDistributor::selectDestination() {
+TcDistributor::TcMessageQueueMapIter PUSDistributor::selectDestination() {
 //	debug << "PUSDistributor::handlePacket received: " << this->current_packet_id.store_index << ", " << this->current_packet_id.packet_index << std::endl;
-	iterator_t queueMapIt = this->queueMap.end();
+	TcMessageQueueMapIter queueMapIt = this->queueMap.end();
 	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
 	if (currentPacket.getWholeData() != NULL) {
 		tcStatus = checker.checkPacket(&currentPacket);
diff --git a/tcdistribution/PUSDistributor.h b/tcdistribution/PUSDistributor.h
index 8d7746626..3d6717bd4 100644
--- a/tcdistribution/PUSDistributor.h
+++ b/tcdistribution/PUSDistributor.h
@@ -1,5 +1,5 @@
-#ifndef PUSDISTRIBUTOR_H_
-#define PUSDISTRIBUTOR_H_
+#ifndef FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/tcdistribution/PUSDistributorIF.h>
@@ -9,37 +9,42 @@
 #include <framework/tmtcservices/VerificationReporter.h>
 
 /**
- * This class accepts PUS Telecommands and forwards them to Application services.
- * In addition, the class performs a formal packet check and sends acceptance success
- * or failure messages.
- * \ingroup tc_distribution
+ * This class accepts PUS Telecommands and forwards them to Application
+ * services. In addition, the class performs a formal packet check and
+ * sends acceptance success or failure messages.
+ * @ingroup tc_distribution
  */
 class PUSDistributor: public TcDistributor,
 		public PUSDistributorIF,
 		public AcceptsTelecommandsIF {
 public:
 	/**
-	 * The ctor passes \c set_apid to the checker class and calls the TcDistribution ctor with a certain object id.
+	 * The ctor passes @c set_apid to the checker class and calls the
+	 * TcDistribution ctor with a certain object id.
 	 * @param setApid The APID of this receiving Application.
 	 * @param setObjectId Object ID of the distributor itself
-	 * @param setPacketSource Object ID of the source of TC packets. Must implement CCSDSDistributorIF.
+	 * @param setPacketSource Object ID of the source of TC packets.
+	 * Must implement CCSDSDistributorIF.
 	 */
-	PUSDistributor(uint16_t setApid, object_id_t setObjectId, object_id_t setPacketSource);
+	PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+			object_id_t setPacketSource);
 	/**
 	 * The destructor is empty.
 	 */
 	virtual ~PUSDistributor();
-	ReturnValue_t registerService(AcceptsTelecommandsIF* service);
-	MessageQueueId_t getRequestQueue();
-	uint16_t getIdentifier();
-	ReturnValue_t initialize();
+	ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t initialize() override;
+	uint16_t getIdentifier() override;
+
 protected:
 	/**
 	 * This attribute contains the class, that performs a formal packet check.
 	 */
 	TcPacketCheck checker;
 	/**
-	 * With this class, verification messages are sent to the TC Verification service.
+	 * With this class, verification messages are sent to the
+	 * TC Verification service.
 	 */
 	VerificationReporter verifyChannel;
 	/**
@@ -47,21 +52,26 @@ protected:
 	 */
 	TcPacketStored currentPacket;
 	/**
-	 * With this variable, the current check status is stored to generate acceptance messages later.
+	 * With this variable, the current check status is stored to generate
+	 * acceptance messages later.
 	 */
 	ReturnValue_t tcStatus;
 
 	const object_id_t packetSource;
 	/**
-	 * This method reads the packet service, checks if such a service is registered and forwards the packet to the destination.
-	 * It also initiates the formal packet check and sending of verification messages.
-	 * @return Iterator to map entry of found service id or iterator to \c map.end().
+	 * This method reads the packet service, checks if such a service is
+	 * registered and forwards the packet to the destination.
+	 * It also initiates the formal packet check and sending of verification
+	 * messages.
+	 * @return Iterator to map entry of found service id
+	 * or iterator to @c map.end().
 	 */
-	iterator_t selectDestination();
+	TcMessageQueueMapIter selectDestination();
 	/**
-	 * The callback here handles the generation of acceptance success/failure messages.
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
 	 */
 	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
 };
 
-#endif /* PUSDISTRIBUTOR_H_ */
+#endif /* FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index 579214593..7bebbb9c7 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -15,7 +15,6 @@ TcDistributor::~TcDistributor() {
 
 ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
 	ReturnValue_t status = RETURN_OK;
-//	debug << "TcDistributor: performing Operation." << std::endl;
 	for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
 			status = tcQueue->receiveMessage(&currentMessage)) {
 		status = handlePacket();
@@ -29,7 +28,7 @@ ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
 
 ReturnValue_t TcDistributor::handlePacket() {
 
-	iterator_t queueMapIt = this->selectDestination();
+	TcMessageQueueMapIter queueMapIt = this->selectDestination();
 	ReturnValue_t returnValue = RETURN_FAILED;
 	if (queueMapIt != this->queueMap.end()) {
 		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
@@ -41,7 +40,7 @@ ReturnValue_t TcDistributor::handlePacket() {
 void TcDistributor::print() {
 	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
 			<< std::endl;
-	for (iterator_t it = this->queueMap.begin(); it != this->queueMap.end();
+	for (TcMessageQueueMapIter it = this->queueMap.begin(); it != this->queueMap.end();
 			it++) {
 		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
 				<< std::endl;
diff --git a/tcdistribution/TcDistributor.h b/tcdistribution/TcDistributor.h
index b80f08e68..5c958de08 100644
--- a/tcdistribution/TcDistributor.h
+++ b/tcdistribution/TcDistributor.h
@@ -1,5 +1,6 @@
-#ifndef TCDISTRIBUTOR_H_
-#define TCDISTRIBUTOR_H_
+#ifndef FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+#define FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
@@ -9,16 +10,12 @@
 #include <framework/ipc/MessageQueueIF.h>
 #include <map>
 
-
 /**
- * \defgroup tc_distribution Telecommand Distribution
- * All classes associated with Routing and Distribution of Telecommands belong to this group.
+ * @defgroup tc_distribution Telecommand Distribution
+ * All classes associated with Routing and Distribution of Telecommands
+ * belong to this group.
  */
 
-/**
- * This typedef simplifies writing down the \c map iterator.
- */
-typedef std::map<uint32_t, MessageQueueId_t>::iterator iterator_t;
 
 /**
  * This is the base class to implement distributors for Space Packets.
@@ -28,59 +25,15 @@ typedef std::map<uint32_t, MessageQueueId_t>::iterator iterator_t;
  * message queue ids to some identifier. The process of unpacking the
  * destination information from the packet is handled by the child class
  * implementations.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
-class TcDistributor : public SystemObject, public ExecutableObjectIF, public HasReturnvaluesIF {
-private:
-	/**
-	 * This constant sets the maximum number of packets distributed per call.
-	 */
-	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
-protected:
-	/**
-	 * This is the receiving queue for incoming Telecommands.
-	 * The child classes must make its queue id public.
-	 */
-	MessageQueueIF* tcQueue;
-	/**
-	 * The last received incoming packet information is stored in this
-	 * member.
-	 * As different child classes unpack the incoming packet differently
-	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
-	 * is not tried to unpack the packet information within this class.
-	 */
-	TmTcMessage currentMessage;
-	/**
-	 * The map that links certain packet information to a destination.
-	 * The packet information may be the APID of the packet or the service
-	 * identifier. Filling of the map is under control of the different child
-	 * classes.
-	 */
-	std::map<uint32_t, MessageQueueId_t> queueMap;
-	/**
-	 * This method shall unpack the routing information from the incoming
-	 * packet and select the map entry which represents the packet's target.
-	 * @return	An iterator to the map element to forward to or queuMap.end().
-	 */
-	virtual iterator_t selectDestination() = 0;
-	/**
-	 * The handlePacket method calls the child class's selectDestination method
-	 * and forwards the packet to its destination, if found.
-	 * @return The message queue return value or \c RETURN_FAILED, in case no
-	 * 		destination was found.
-	 */
-	ReturnValue_t handlePacket();
-	/**
-	 * This method gives the child class a chance to perform some kind of operation
-	 * after the parent tried to forward the message.
-	 * A typically application would be sending success/failure messages.
-	 * The default implementation just returns \c RETURN_OK.
-	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
-	 * @return	- \c RETURN_OK on success
-	 * 			- \c RETURN_FAILED on failure
-	 */
-	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+class TcDistributor : public SystemObject,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
 public:
+	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
+	using TcMessageQueueMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
 	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
 	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
@@ -110,6 +63,57 @@ public:
 	 * queueMap.
 	 */
 	void print();
+
+protected:
+	/**
+	 * This is the receiving queue for incoming Telecommands.
+	 * The child classes must make its queue id public.
+	 */
+	MessageQueueIF* tcQueue;
+	/**
+	 * The last received incoming packet information is stored in this
+	 * member.
+	 * As different child classes unpack the incoming packet differently
+	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
+	 * is not tried to unpack the packet information within this class.
+	 */
+	TmTcMessage currentMessage;
+	/**
+	 * The map that links certain packet information to a destination.
+	 * The packet information may be the APID of the packet or the service
+	 * identifier. Filling of the map is under control of the different child
+	 * classes.
+	 */
+	TcMessageQueueMap queueMap;
+	/**
+	 * This method shall unpack the routing information from the incoming
+	 * packet and select the map entry which represents the packet's target.
+	 * @return	An iterator to the map element to forward to or queuMap.end().
+	 */
+	virtual TcMessageQueueMapIter selectDestination() = 0;
+	/**
+	 * The handlePacket method calls the child class's selectDestination method
+	 * and forwards the packet to its destination, if found.
+	 * @return The message queue return value or \c RETURN_FAILED, in case no
+	 * 		destination was found.
+	 */
+	ReturnValue_t handlePacket();
+	/**
+	 * This method gives the child class a chance to perform some kind of operation
+	 * after the parent tried to forward the message.
+	 * A typically application would be sending success/failure messages.
+	 * The default implementation just returns \c RETURN_OK.
+	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
+	 * @return	- \c RETURN_OK on success
+	 * 			- \c RETURN_FAILED on failure
+	 */
+	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+
+private:
+	/**
+	 * This constant sets the maximum number of packets distributed per call.
+	 */
+	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
 };
 
 
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index 82e5ff5cc..cb1e633f6 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -41,9 +41,14 @@ void PusServiceBase::handleRequestQueue() {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
 		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
-		//	debug << "PusServiceBase::performOperation: Receiving from MQ ID: "
-		//      << std::hex << this->requestQueue.getId()
-		//      << std::dec << " returned: " << status << std::endl;
+//		if(status != MessageQueueIF::EMPTY) {
+//			sif::debug << "PusServiceBase::performOperation: Receiving from "
+//					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
+//					<< std::setfill('0') << this->requestQueue->getId()
+//					<< std::dec << " returned: " << status << std::setfill(' ')
+//					<<  std::endl;
+//		}
+
 		if (status == RETURN_OK) {
 			this->currentPacket.setStoreAddress(message.getStorageId());
 			//info << "Service " << (uint16_t) this->serviceId <<
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 5b933c793..a009c9622 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -62,7 +62,7 @@ public:
 	 * @param virtualChannel
 	 * @return
 	 */
-	MessageQueueId_t getReportReceptionQueue(
+	virtual MessageQueueId_t getReportReceptionQueue(
 			uint8_t virtualChannel = 0) override;
 protected:
 	//! Used to send and receive TMTC messages.

From 264914e86a1b9a2854dbc8d83ed96445a1255482 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 03:18:09 +0200
Subject: [PATCH 0544/1774] tmtcbridge tweaks.

UDP bridge now working :-D
---
 osal/linux/MessageQueue.cpp          |  8 ++--
 osal/linux/PeriodicPosixTask.cpp     |  8 ++--
 osal/linux/TcUnixUdpPollingTask.cpp  | 69 ++++++++++++++++------------
 osal/linux/TcUnixUdpPollingTask.h    |  8 ++++
 osal/linux/TmTcUnixUdpBridge.cpp     | 43 +++++++----------
 osal/linux/TmTcUnixUdpBridge.h       |  7 +--
 tcdistribution/CCSDSDistributor.cpp  |  4 +-
 tcdistribution/CCSDSDistributor.h    |  8 ++--
 tcdistribution/PUSDistributor.cpp    |  4 +-
 tcdistribution/PUSDistributor.h      |  2 +-
 tcdistribution/TcDistributor.cpp     |  4 +-
 tcdistribution/TcDistributor.h       |  4 +-
 tmtcservices/AcceptsTelecommandsIF.h | 10 ++--
 tmtcservices/TmTcBridge.cpp          | 26 +++++++----
 tmtcservices/TmTcBridge.h            | 34 ++++++--------
 15 files changed, 121 insertions(+), 118 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index ce1da17c0..153f43d3b 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -155,10 +155,10 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	}
 
 	if(message->getMaximumMessageSize() < maxMessageSize) {
-	        sif::error << "MessageQueue::receiveMessage: Message size "
-	                << message->getMaximumMessageSize() <<
-	                " too small to receive data!" << std::endl;
-	        return HasReturnvaluesIF::RETURN_FAILED;
+		sif::error << "MessageQueue::receiveMessage: Message size "
+				<< message->getMaximumMessageSize()
+				<< " too small to receive data!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
 	unsigned int messagePriority = 0;
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index b811274b6..4b0c77fc8 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -68,12 +68,12 @@ void PeriodicPosixTask::taskFunctionality(void) {
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
 			if(status == 0){
-				sif::error << "PeriodicPosixTask " << name << ": Deadline "
-						"missed." << std::endl;
+				//sif::error << "PeriodicPosixTask " << name << ": Deadline "
+				//		"missed." << std::endl;
 			}
 			else {
-				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
-						status << std::endl;
+				//sif::error << "PeriodicPosixTask X: Deadline missed. " <<
+				//		status << std::endl;
 			}
 			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 83f7a3da1..97fbd044e 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -26,8 +26,7 @@ TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
 	}
 }
 
-TcUnixUdpPollingTask::~TcUnixUdpPollingTask() {
-}
+TcUnixUdpPollingTask::~TcUnixUdpPollingTask() {}
 
 ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 	// Poll for new UDP datagrams in permanent loop.
@@ -59,6 +58,30 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
+	store_address_t storeId = 0;
+	ReturnValue_t result = tcStore->addData(&storeId,
+			receptionBuffer.data(), bytesRead);
+	// arrayprinter::print(receptionBuffer.data(), bytesRead);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+				"storage failed" << std::endl;
+		sif::debug << "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) {
@@ -74,41 +97,27 @@ ReturnValue_t TcUnixUdpPollingTask::initialize() {
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
-	targetTcDestination = tmtcBridge->getReportReceptionQueue();
-
 	serverUdpSocket = tmtcBridge->serverSocket;
 
-	// Set receive timeout.
-//	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
-//			&receptionTimeout, sizeof(receptionTimeout));
-//	if(result == -1) {
-//		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
-//				"receive timeout failed with " << strerror(errno) << std::endl;
-//		return ObjectManagerIF::CHILD_INIT_FAILED;
-//	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
-	store_address_t storeId = 0;
-	ReturnValue_t result = tcStore->addData(&storeId,
-			receptionBuffer.data(), bytesRead);
-	// arrayprinter::print(receptionBuffer.data(), bytesRead);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
-				"storage failed" << std::endl;
-		sif::debug << "Packet size: " << bytesRead << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+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;
+}
 
-	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);
+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;
 	}
-	return result;
 }
 
 
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index 3503d5056..86591e8d0 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -29,8 +29,16 @@ public:
 			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;
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index a337b8ae2..4dc61c50a 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,8 +1,9 @@
 #include <framework/osal/linux/TmTcUnixUdpBridge.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <errno.h>
 #include <framework/ipc/MutexHelper.h>
 
+#include <errno.h>
+
 TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		object_id_t ccsdsPacketDistributor, uint16_t serverPort,
 		uint16_t clientPort):
@@ -14,17 +15,16 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		setServerPort = serverPort;
 	}
 
-	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
-	if(clientPort != 0xFFFF) {
-		setClientPort = clientPort;
-	}
+//	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
 	serverSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	if(socket < 0) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
 				" UDP socket!" << std::endl;
-		// check errno here.
 		handleSocketError();
 		return;
 	}
@@ -44,7 +44,6 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
 				"local port " << setServerPort << " to server socket!"
 				<< std::endl;
-		// check errno here.
 		handleBindError();
 		return;
 	}
@@ -57,14 +56,21 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	int flags = 0;
 	ssize_t result = send(serverSocket, data, dataLen, flags);
 	if(result < 0) {
-		//handle error
+		// todo: handle errors
 		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed "
 				"with error " << strerror(errno) << std::endl;
 	}
-
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+	MutexHelper lock(mutex, 10);
+	// 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;
+	}
+}
+
 void TmTcUnixUdpBridge::handleSocketError() {
 
 	// See: https://man7.org/linux/man-pages/man2/socket.2.html
@@ -87,17 +93,6 @@ void TmTcUnixUdpBridge::handleSocketError() {
 	}
 }
 
-void TmTcUnixUdpBridge::setTimeout(float timeoutSeconds) {
-}
-
-void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
-	MutexHelper lock(mutex, 10);
-	// 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;
-	}
-}
-
 void TmTcUnixUdpBridge::handleBindError() {
 	// See: https://man7.org/linux/man-pages/man2/bind.2.html
 	switch(errno) {
@@ -128,16 +123,10 @@ void TmTcUnixUdpBridge::handleBindError() {
 				<< " with " << strerror(errno) << std::endl;
 		break;
 	}
-	default: {
+	default:
 		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
 				<< std::endl;
 		break;
 	}
-	}
 }
 
-
-ReturnValue_t TmTcUnixUdpBridge::receiveTc(uint8_t **recvBuffer, size_t *size) {
-	// TC reception handled by separate polling task because it is blocking.
-	return HasReturnvaluesIF::RETURN_OK;
-}
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index 2fb606b0e..538664d83 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
 #define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
 
+#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
 #include <framework/tmtcservices/TmTcBridge.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
@@ -18,13 +19,11 @@ public:
 			 uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
 	virtual~ TmTcUnixUdpBridge();
 
-	void setTimeout(float timeoutSeconds);
 	void checkAndSetClientAddress(sockaddr_in clientAddress);
 
 protected:
-	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer,
-			size_t * size) override;
 	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
+
 private:
 	int serverSocket = 0;
 	const int serverSocketOptions = 0;
@@ -43,6 +42,4 @@ private:
 	void handleBindError();
 };
 
-
-
 #endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index 199e2ed15..24c937302 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -9,7 +9,7 @@ CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
 
 CCSDSDistributor::~CCSDSDistributor() {}
 
-TcDistributor::TcMessageQueueMapIter CCSDSDistributor::selectDestination() {
+TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
 //	sif::debug << "CCSDSDistributor::selectDestination received: " <<
 //			this->currentMessage.getStorageId().pool_index << ", " <<
 //			this->currentMessage.getStorageId().packet_index << std::endl;
@@ -25,7 +25,7 @@ TcDistributor::TcMessageQueueMapIter CCSDSDistributor::selectDestination() {
 
 //	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
 //			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
-	TcMessageQueueMapIter position = this->queueMap.find(currentPacket.getAPID());
+	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
 	if ( position != this->queueMap.end() ) {
 		return position;
 	} else {
diff --git a/tcdistribution/CCSDSDistributor.h b/tcdistribution/CCSDSDistributor.h
index 22025f760..60877753e 100644
--- a/tcdistribution/CCSDSDistributor.h
+++ b/tcdistribution/CCSDSDistributor.h
@@ -24,14 +24,14 @@ public:
 	 * 			TcDistributor ctor with a certain object id.
 	 * @details
 	 * @c tcStore is set in the @c initialize method.
-	 * @param set_default_apid The default APID, where packets with unknown
+	 * @param setDefaultApid The default APID, where packets with unknown
 	 * destination are sent to.
 	 */
-	CCSDSDistributor( uint16_t setDefaultApid, object_id_t setObjectId );
+	CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
 	/**
 	 * The destructor is empty.
 	 */
-	~CCSDSDistributor();
+	virtual ~CCSDSDistributor();
 
 	MessageQueueId_t getRequestQueue() override;
 	ReturnValue_t registerApplication( uint16_t apid,
@@ -49,7 +49,7 @@ protected:
 	 * where a Acceptance Failure message should be generated.
 	 * @return Iterator to map entry of found APID or iterator to default APID.
 	 */
-	TcMessageQueueMapIter selectDestination();
+	TcMqMapIter selectDestination() override;
 	/**
 	 * The default APID, where packets with unknown APID are sent to.
 	 */
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index f13b5f8de..d6e20acf5 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -12,9 +12,9 @@ PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
 
 PUSDistributor::~PUSDistributor() {}
 
-TcDistributor::TcMessageQueueMapIter PUSDistributor::selectDestination() {
+TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
 //	debug << "PUSDistributor::handlePacket received: " << this->current_packet_id.store_index << ", " << this->current_packet_id.packet_index << std::endl;
-	TcMessageQueueMapIter queueMapIt = this->queueMap.end();
+	TcMqMapIter queueMapIt = this->queueMap.end();
 	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
 	if (currentPacket.getWholeData() != NULL) {
 		tcStatus = checker.checkPacket(&currentPacket);
diff --git a/tcdistribution/PUSDistributor.h b/tcdistribution/PUSDistributor.h
index 3d6717bd4..4a22f9367 100644
--- a/tcdistribution/PUSDistributor.h
+++ b/tcdistribution/PUSDistributor.h
@@ -66,7 +66,7 @@ protected:
 	 * @return Iterator to map entry of found service id
 	 * or iterator to @c map.end().
 	 */
-	TcMessageQueueMapIter selectDestination();
+	TcMqMapIter selectDestination() override;
 	/**
 	 * The callback here handles the generation of acceptance
 	 * success/failure messages.
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index 7bebbb9c7..0190cc970 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -28,7 +28,7 @@ ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
 
 ReturnValue_t TcDistributor::handlePacket() {
 
-	TcMessageQueueMapIter queueMapIt = this->selectDestination();
+	TcMqMapIter queueMapIt = this->selectDestination();
 	ReturnValue_t returnValue = RETURN_FAILED;
 	if (queueMapIt != this->queueMap.end()) {
 		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
@@ -40,7 +40,7 @@ ReturnValue_t TcDistributor::handlePacket() {
 void TcDistributor::print() {
 	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
 			<< std::endl;
-	for (TcMessageQueueMapIter it = this->queueMap.begin(); it != this->queueMap.end();
+	for (TcMqMapIter it = this->queueMap.begin(); it != this->queueMap.end();
 			it++) {
 		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
 				<< std::endl;
diff --git a/tcdistribution/TcDistributor.h b/tcdistribution/TcDistributor.h
index 5c958de08..73425302f 100644
--- a/tcdistribution/TcDistributor.h
+++ b/tcdistribution/TcDistributor.h
@@ -32,7 +32,7 @@ class TcDistributor : public SystemObject,
 		public HasReturnvaluesIF {
 public:
 	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
-	using TcMessageQueueMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
+	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
 	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
@@ -90,7 +90,7 @@ protected:
 	 * packet and select the map entry which represents the packet's target.
 	 * @return	An iterator to the map element to forward to or queuMap.end().
 	 */
-	virtual TcMessageQueueMapIter selectDestination() = 0;
+	virtual TcMqMapIter selectDestination() = 0;
 	/**
 	 * The handlePacket method calls the child class's selectDestination method
 	 * and forwards the packet to its destination, if found.
diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h
index 0952d3a60..2878dd5d1 100644
--- a/tmtcservices/AcceptsTelecommandsIF.h
+++ b/tmtcservices/AcceptsTelecommandsIF.h
@@ -1,5 +1,5 @@
-#ifndef ACCEPTSTELECOMMANDSIF_H_
-#define ACCEPTSTELECOMMANDSIF_H_
+#ifndef FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
+#define FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
 
 #include <framework/ipc/MessageQueueSenderIF.h>
 
@@ -26,9 +26,9 @@ public:
 	/**
 	 * @brief	Getter for the service id.
 	 * @details	Any receiving service (at least any PUS service) shall have a
-	 * 			service id. If the receiver can handle Telecommands, but for
+	 * 			service ID. If the receiver can handle Telecommands, but for
 	 * 			some reason has no service id, it shall return 0.
-	 * @return	The service id or 0.
+	 * @return	The service ID or 0.
 	 */
 	virtual uint16_t getIdentifier() = 0;
 	/**
@@ -40,4 +40,4 @@ public:
 };
 
 
-#endif /* ACCEPTSTELECOMMANDSIF_H_ */
+#endif /* FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 092884bbe..9c3e5b94d 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -9,7 +9,7 @@ TmTcBridge::TmTcBridge(object_id_t objectId,
         object_id_t ccsdsPacketDistributor): SystemObject(objectId),
         ccsdsPacketDistributor(ccsdsPacketDistributor)
 {
-    TmTcReceptionQueue = QueueFactory::instance()->
+    tmTcReceptionQueue = QueueFactory::instance()->
             createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
 }
 
@@ -55,7 +55,8 @@ ReturnValue_t TmTcBridge::initialize() {
 	if (tcDistributor == NULL) {
 		return RETURN_FAILED;
 	}
-	TmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
+
+	tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
 	return RETURN_OK;
 }
 
@@ -73,10 +74,7 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 }
 
 ReturnValue_t TmTcBridge::handleTc() {
-	uint8_t * recvBuffer = nullptr;
-	size_t recvLen = 0;
-	ReturnValue_t result = receiveTc(&recvBuffer, &recvLen);
-	return result;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t TmTcBridge::handleTm() {
@@ -97,8 +95,8 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 	TmTcMessage message;
 	const uint8_t* data = nullptr;
 	size_t size = 0;
-	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
-		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
+	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
+		 result == RETURN_OK; result = tmTcReceptionQueue->receiveMessage(&message))
 	{
 		if(communicationLinkUp == false) {
 			result = storeDownlinkData(&message);
@@ -183,10 +181,20 @@ void TmTcBridge::registerCommDisconnect() {
 }
 
 MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
-	return TmTcReceptionQueue->getId();
+	return tmTcReceptionQueue->getId();
 }
 
 
 void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
 	arrayprinter::print(data, dataLen);
 }
+
+uint16_t TmTcBridge::getIdentifier() {
+	// This is no PUS service, so we just return 0
+	return 0;
+}
+
+MessageQueueId_t TmTcBridge::getRequestQueue() {
+	// Default implementation: Relay TC messages to TC distributor directly.
+	return tmTcReceptionQueue->getDefaultDestination();
+}
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index a009c9622..3fcbf84c2 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,16 +1,18 @@
 #ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 #define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 
-#include <framework/container/FIFO.h>
+#include <framework/objectmanager/SystemObject.h>
 #include <framework/tmtcservices/AcceptsTelemetryIF.h>
 #include <framework/tasks/ExecutableObjectIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
+#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
 
+#include <framework/container/FIFO.h>
 #include <framework/tmtcservices/TmTcMessage.h>
 
 class TmTcBridge : public AcceptsTelemetryIF,
+		public AcceptsTelecommandsIF,
 		public ExecutableObjectIF,
 		public HasReturnvaluesIF,
 		public SystemObject {
@@ -57,17 +59,19 @@ public:
 	 */
 	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 
-	/**
-	 * Return TMTC Reception Queue
-	 * @param virtualChannel
-	 * @return
-	 */
+
+	/** AcceptsTelemetryIF override */
 	virtual MessageQueueId_t getReportReceptionQueue(
 			uint8_t virtualChannel = 0) override;
+
+	/** AcceptsTelecommandsIF override */
+	virtual uint16_t getIdentifier() override;
+	virtual MessageQueueId_t getRequestQueue() override;
+
 protected:
 	//! Used to send and receive TMTC messages.
 	//! TmTcMessage is used to transport messages between tasks.
-	MessageQueueIF* TmTcReceptionQueue = nullptr;
+	MessageQueueIF* tmTcReceptionQueue = nullptr;
 	StorageManagerIF* tcStore = nullptr;
 	StorageManagerIF* tmStore = nullptr;
 	object_id_t ccsdsPacketDistributor = 0;
@@ -79,23 +83,11 @@ protected:
 	 * @brief 	Handle TC reception
 	 * @details
 	 * Default implementation provided, but is empty.
-	 * Child handler should override this in most cases orsend TC to the
-	 * TC distributor directly with the address of the reception queue by
-	 * calling getReportRecptionQueue()
+	 * In most cases, TC reception will be handled in a separate task anyway.
 	 * @return
 	 */
 	virtual ReturnValue_t handleTc();
 
-	/**
-	 * Implemented by child class. Perform receiving of Telecommand,
-	 * for example by implementing specific drivers or wrappers,
-	 * e.g. UART Communication or an ethernet stack
-	 * @param recvBuffer [out] Received data
-	 * @param size [out] Size of received data
-	 * @return
-	 */
-	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer, size_t * size) = 0;
-
 	/**
 	 * Handle Telemetry. Default implementation provided.
 	 * Calls sendTm()

From 94f9b1e1ef0ecdbd0f92751284f74dc02310b7c2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 12:41:15 +0200
Subject: [PATCH 0545/1774] dle encoder doc finished and hopefully correct

---
 globalfunctions/DleEncoder.cpp | 128 +++++++++++++++++++--------------
 globalfunctions/DleEncoder.h   |  21 ++++--
 2 files changed, 89 insertions(+), 60 deletions(-)

diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index ee934785b..d727d665a 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -4,50 +4,6 @@ DleEncoder::DleEncoder() {}
 
 DleEncoder::~DleEncoder() {}
 
-ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
-		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 DECODING_ERROR;
-	}
-	++encodedIndex;
-	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
-			&& (sourceStream[encodedIndex] != ETX)
-			&& (sourceStream[encodedIndex] != STX)) {
-		if (sourceStream[encodedIndex] == DLE) {
-			nextByte = sourceStream[encodedIndex + 1];
-			// 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) {
-				destStream[decodedIndex] = nextByte;
-			} else {
-			    // The next byte is a STX, DTX or 0x0D character which
-			    // was escaped by a DLE character
-				if ((nextByte == 0x42) || (nextByte == 0x43)
-						|| (nextByte == 0x4D)) {
-					destStream[decodedIndex] = nextByte - 0x40;
-				} else {
-				    return DECODING_ERROR;
-				}
-			}
-			++encodedIndex;
-		} else {
-			destStream[decodedIndex] = sourceStream[encodedIndex];
-		}
-		++encodedIndex;
-		++decodedIndex;
-	}
-	if (sourceStream[encodedIndex] != ETX) {
-		return DECODING_ERROR;
-	} else {
-		*readLen = ++encodedIndex;
-		*decodedLen = decodedIndex;
-		return RETURN_OK;
-	}
-}
-
 ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 		size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
 		size_t* encodedLen, bool addStxEtx) {
@@ -60,39 +16,105 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 		destStream[0] = STX;
 		++encodedIndex;
 	}
-	while ((encodedIndex < maxDestLen) && (sourceIndex < sourceLen)) {
+
+	while (encodedIndex < maxDestLen and sourceIndex < sourceLen) {
 		nextByte = sourceStream[sourceIndex];
-		if ((nextByte == STX) || (nextByte == ETX) || (nextByte == 0x0D)) {
+		// STX, ETX and CR characters in the stream need to be escaped with DLE
+		if (nextByte == STX or nextByte == ETX or nextByte == CARRIAGE_RETURN) {
 			if (encodedIndex + 1 >= maxDestLen) {
 				return STREAM_TOO_SHORT;
-			} else {
+			}
+			else {
 				destStream[encodedIndex] = DLE;
 				++encodedIndex;
-				// Escaped byte will be actual byte + 0x40.
+				/* 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;
 			}
-		} else if (nextByte == DLE) {
+		}
+		// DLE characters are simply escaped with DLE.
+		else if (nextByte == DLE) {
 			if (encodedIndex + 1 >= maxDestLen) {
 			    return STREAM_TOO_SHORT;
-			} else {
+			}
+			else {
 				destStream[encodedIndex] = DLE;
 				++encodedIndex;
 				destStream[encodedIndex] = DLE;
 			}
-		} else {
+		}
+		else {
 			destStream[encodedIndex] = nextByte;
 		}
 		++encodedIndex;
 		++sourceIndex;
 	}
-	if ((sourceIndex == sourceLen) && (encodedIndex < maxDestLen)) {
+
+	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
 		if (addStxEtx) {
 			destStream[encodedIndex] = ETX;
 			++encodedIndex;
 		}
 		*encodedLen = encodedIndex;
 		return RETURN_OK;
-	} else {
+	}
+	else {
 		return STREAM_TOO_SHORT;
 	}
 }
+
+ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
+		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 DECODING_ERROR;
+	}
+	++encodedIndex;
+
+	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
+			&& (sourceStream[encodedIndex] != ETX)
+			&& (sourceStream[encodedIndex] != STX)) {
+		if (sourceStream[encodedIndex] == DLE) {
+			nextByte = sourceStream[encodedIndex + 1];
+			// 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) {
+				destStream[decodedIndex] = nextByte;
+			}
+			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 preven 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 DECODING_ERROR;
+				}
+			}
+			++encodedIndex;
+		}
+		else {
+			destStream[decodedIndex] = sourceStream[encodedIndex];
+		}
+		++encodedIndex;
+		++decodedIndex;
+	}
+
+	if (sourceStream[encodedIndex] != ETX) {
+		return DECODING_ERROR;
+	}
+	else {
+		*readLen = ++encodedIndex;
+		*decodedLen = decodedIndex;
+		return RETURN_OK;
+	}
+}
+
diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index 0f4a4c8fa..36cb1d3f3 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -14,9 +14,15 @@
  * 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 startr of the stream and an ETX marker at the end of
- * the stream. Any STX, ETX and DLE occurences in the source stream are escaped
- * by a DLE character.
+ * 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 occurences 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 enoded 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:
@@ -29,12 +35,13 @@ public:
 	static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
 
 	//! Start Of Text character. First character is encoded stream
-	static const uint8_t STX = 0x02;
+	static constexpr uint8_t STX = 0x02;
 	//! End Of Text character. Last character in encoded stream
-	static const uint8_t ETX = 0x03;
+	static constexpr uint8_t ETX = 0x03;
 	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
 	//! in the source stream.
-	static const uint8_t DLE = 0x10;
+	static constexpr uint8_t DLE = 0x10;
+	static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
 
     /**
      * Encodes the give data stream by preceding it with the STX marker
@@ -54,7 +61,7 @@ public:
             bool addStxEtx = true);
 
     /**
-     * Converts an encoded stream back
+     * Converts an encoded stream back.
      * @param sourceStream
      * @param sourceStreamLen
      * @param readLen

From 01b10803766e61833eaa9762327a48e0fff76c29 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 12:53:46 +0200
Subject: [PATCH 0546/1774] readability increase

---
 globalfunctions/DleEncoder.cpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index d727d665a..c8f788722 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -17,7 +17,8 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 		++encodedIndex;
 	}
 
-	while (encodedIndex < maxDestLen and sourceIndex < sourceLen) {
+	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 or nextByte == ETX or nextByte == CARRIAGE_RETURN) {
@@ -80,7 +81,8 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 
 	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
 			&& (sourceStream[encodedIndex] != ETX)
-			&& (sourceStream[encodedIndex] != STX)) {
+			&& (sourceStream[encodedIndex] != STX))
+	{
 		if (sourceStream[encodedIndex] == DLE) {
 			nextByte = sourceStream[encodedIndex + 1];
 			// The next byte is a DLE character that was escaped by another
@@ -95,7 +97,8 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 				 * in the stream at all, so we convert it back. */
 				if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
 					destStream[decodedIndex] = nextByte - 0x40;
-				} else {
+				}
+				else {
 				    return DECODING_ERROR;
 				}
 			}
@@ -104,6 +107,7 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 		else {
 			destStream[decodedIndex] = sourceStream[encodedIndex];
 		}
+
 		++encodedIndex;
 		++decodedIndex;
 	}

From b56aa94f99730cee982eebc09dd8fa88a3fbc077 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 12:54:40 +0200
Subject: [PATCH 0547/1774] additional doc

---
 globalfunctions/DleEncoder.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index 36cb1d3f3..29851dfe3 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -46,7 +46,8 @@ public:
     /**
      * 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.
+     * the stream are escaped by DLE characters and also replaced by adding
+     * 0x40 (which is reverted in the decoing process).
      * @param sourceStream
      * @param sourceLen
      * @param destStream

From 5ec78b065c4ca0ba486b9837c0e4c0eba40d5b15 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 13:29:57 +0200
Subject: [PATCH 0548/1774] error handling for invalid dest queues improved

---
 ipc/MessageQueueIF.h                  | 14 +++----
 objectmanager/frameworkObjects.h      |  4 ++
 osal/linux/MessageQueue.cpp           | 13 ++++---
 tmtcservices/VerificationReporter.cpp | 56 +++++++++++++++------------
 tmtcservices/VerificationReporter.h   | 39 ++++++++++++++-----
 5 files changed, 78 insertions(+), 48 deletions(-)

diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 500f71e2b..c05754425 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -18,18 +18,14 @@ public:
 	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
-	/**
-	 * No new messages on the queue
-	 */
+	//! No new messages on the queue
 	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(1);
-	/**
-	 * No space left for more messages
-	 */
+	//! No space left for more messages
 	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
-	/**
-	 * Returned if a reply method was called without partner
-	 */
+	//! Returned if a reply method was called without partner
 	static const ReturnValue_t NO_REPLY_PARTNER = MAKE_RETURN_CODE(3);
+	//! Returned if the target destination is invalid.
+	static constexpr ReturnValue_t DESTINVATION_INVALID = MAKE_RETURN_CODE(4);
 
 	virtual ~MessageQueueIF() {}
 	/**
diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index c3deafc43..46d5feea2 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -3,6 +3,9 @@
 
 namespace objects {
 enum framework_objects {
+	// Default verification reporter.
+	PUS_SERVICE_1 = 0x53000000,
+
 	//Generic IDs for IPC, modes, health, events
 	HEALTH_TABLE = 0x53010000,
 //	MODE_STORE = 0x53010100,
@@ -12,6 +15,7 @@ enum framework_objects {
 	//IDs for PUS Packet Communication
 	TC_STORE = 0x534f0100,
 	TM_STORE = 0x534f0200,
+
 	NO_OBJECT = 0xFFFFFFFF
 };
 }
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 153f43d3b..236e61b6a 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -330,13 +330,16 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			//MQ_NONBLOCK flag was set in its attributes, and the
 			//specified queue is full.
 			return MessageQueueIF::FULL;
-		case EBADF:
+		case EBADF: {
 			//mq_des doesn't represent a valid message queue descriptor,
 			//or mq_des wasn't opened for writing.
-			sif::error << "MessageQueue::sendMessage: Configuration error "
-			           << strerror(errno) << " in mq_send mqSendTo: " << sendTo
-					   << " sent from " << sentFrom << std::endl;
-			/*NO BREAK*/
+			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
+					<< " destination invalid."  << std::endl;
+			sif::error << strerror(errno) << " in "
+					<<"mq_send to: " << sendTo << " sent from "
+					<< sentFrom << std::endl;
+			return DESTINVATION_INVALID;
+		}
 		case EINTR:
 			//The call was interrupted by a signal.
 		case EINVAL:
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index bcb4756ce..40f7e57f4 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -1,17 +1,18 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcservices/AcceptsVerifyMessageIF.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
 #include <framework/tmtcservices/VerificationReporter.h>
 
-object_id_t VerificationReporter::messageReceiver = 0;
+#include <framework/ipc/MessageQueueIF.h>
+#include <framework/tmtcservices/AcceptsVerifyMessageIF.h>
+#include <framework/tmtcservices/PusVerificationReport.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/objectmanager/frameworkObjects.h>
+
+object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1;
 
 VerificationReporter::VerificationReporter() :
-		acknowledgeQueue() {
+		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {
 }
 
-VerificationReporter::~VerificationReporter() {
-	//Default, empty
-}
+VerificationReporter::~VerificationReporter() {}
 
 void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 		TcPacketBase* current_packet, uint8_t set_step) {
@@ -23,10 +24,11 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 			current_packet->getPacketId(),
 			current_packet->getPacketSequenceControl(), 0, set_step);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message);
+			&message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
-				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
 	}
 }
 
@@ -39,10 +41,11 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
 			tcSequenceControl, 0, set_step);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message);
+			&message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
-				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
 	}
 }
 
@@ -60,9 +63,9 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error
-				<< "VerificationReporter::sendFailureReport Error writing to queue. Code: "
-				<< (uint16_t) status << std::endl;
+		sif::error << "VerificationReporter::sendFailureReport Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
 	}
 }
 
@@ -78,20 +81,25 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error
-				<< "VerificationReporter::sendFailureReport Error writing to queue. Code: "
-				<< (uint16_t) status << std::endl;
+		sif::error << "VerificationReporter::sendFailureReport Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
 	}
 }
 
 void VerificationReporter::initialize() {
+	if(messageReceiver == objects::NO_OBJECT) {
+		sif::warning << "VerificationReporter::initialize: Verification message"
+				" receiver object ID not set yet in Factory!" << std::endl;
+		return;
+	}
 	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
 			messageReceiver);
-	if (temp != NULL) {
-		this->acknowledgeQueue = temp->getVerificationQueue();
-	} else {
-		sif::error
-				<< "VerificationReporter::VerificationReporter: Configuration error."
-				<< std::endl;
+	if (temp == nullptr) {
+		sif::error << "VerificationReporter::initialize: Message "
+				<< "receiver invalid. Make sure it is set up properly and "
+				<<"implementsAcceptsVerifyMessageIF" << std::endl;
+
 	}
+	this->acknowledgeQueue = temp->getVerificationQueue();
 }
diff --git a/tmtcservices/VerificationReporter.h b/tmtcservices/VerificationReporter.h
index 370c44c8c..f13998d9a 100644
--- a/tmtcservices/VerificationReporter.h
+++ b/tmtcservices/VerificationReporter.h
@@ -1,5 +1,5 @@
-#ifndef VERIFICATIONREPORTER_H_
-#define VERIFICATIONREPORTER_H_
+#ifndef FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
+#define FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/tmtcservices/PusVerificationReport.h>
@@ -8,24 +8,43 @@ namespace Factory{
 void setStaticFrameworkObjectIds();
 }
 
+/**
+ * @brief 	This helper object is used to forward verification messages
+ * 			which are generated by the Flight Software Framework.
+ * @details
+ * The messages can be relayed to an arbitrary object, for example a dedicated
+ * Verification Reporter. The destination is set by setting the static framework
+ * Id VerificationReporter::messageReceiver. The default verification reporter
+ * will be the PUS service 1, which sends verification messages according
+ * to the PUS standard.
+ *
+ */
 class VerificationReporter {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	VerificationReporter();
 	virtual ~VerificationReporter();
-	void sendSuccessReport( uint8_t set_report_id, TcPacketBase* current_packet, uint8_t set_step = 0 );
-	void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl, uint8_t set_step = 0);
-	void sendFailureReport( uint8_t report_id, TcPacketBase* current_packet, ReturnValue_t error_code = 0,
-			uint8_t step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
+
+	void sendSuccessReport( uint8_t set_report_id, TcPacketBase* current_packet,
+			uint8_t set_step = 0 );
+	void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags,
+			uint16_t tcPacketId, uint16_t tcSequenceControl,
+			uint8_t set_step = 0);
+
+	void sendFailureReport( uint8_t report_id, TcPacketBase* current_packet,
+			ReturnValue_t error_code = 0,
+			uint8_t step = 0, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0 );
 	void sendFailureReport(uint8_t report_id,
-			uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl, ReturnValue_t error_code = 0, uint8_t step = 0,
+			uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+			ReturnValue_t error_code = 0, uint8_t step = 0,
 			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+
 	void initialize();
+
 private:
 	static object_id_t messageReceiver;
 	MessageQueueId_t acknowledgeQueue;
-
-
 };
 
-#endif /* VERIFICATIONREPORTER_H_ */
+#endif /* FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_ */

From 236ad1b85b600acecc741127faa19c72925542fc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 15:06:46 +0200
Subject: [PATCH 0549/1774] a lot of debug output added

---
 osal/linux/TcUnixUdpPollingTask.cpp   |  1 +
 osal/linux/TmTcUnixUdpBridge.cpp      | 54 ++++++++++++++++++++-------
 osal/linux/TmTcUnixUdpBridge.h        | 11 ++++--
 tmtcservices/PusServiceBase.cpp       | 20 +++++-----
 tmtcservices/TmTcBridge.cpp           | 32 ++++++++++------
 tmtcservices/TmTcBridge.h             | 17 ++++++---
 tmtcservices/VerificationReporter.cpp |  8 ++--
 7 files changed, 93 insertions(+), 50 deletions(-)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 97fbd044e..122301da4 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -53,6 +53,7 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 		if(result != HasReturnvaluesIF::RETURN_FAILED) {
 
 		}
+		tmtcBridge->registerCommConnect();
 		tmtcBridge->checkAndSetClientAddress(senderAddress);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 4dc61c50a..40e965615 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -3,11 +3,12 @@
 #include <framework/ipc/MutexHelper.h>
 
 #include <errno.h>
+#include <arpa/inet.h>
 
 TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
-		object_id_t ccsdsPacketDistributor, uint16_t serverPort,
-		uint16_t clientPort):
-		TmTcBridge(objectId, ccsdsPacketDistributor) {
+		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;
@@ -15,13 +16,14 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		setServerPort = serverPort;
 	}
 
-//	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
-//	if(clientPort != 0xFFFF) {
-//		setClientPort = clientPort;
-//	}
+	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
-	serverSocket = socket(AF_INET, SOCK_DGRAM, 0);
+	//clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
+	serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 	if(socket < 0) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
 				" UDP socket!" << std::endl;
@@ -36,10 +38,14 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
 			sizeof(serverSocketOptions));
 
-	serverSocketLen = sizeof(serverAddress);
+	clientAddress.sin_family = AF_INET;
+	clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+	clientAddress.sin_port = htons(setClientPort);
+
+	serverAddressLen = sizeof(serverAddress);
 	int result = bind(serverSocket,
 			reinterpret_cast<struct sockaddr*>(&serverAddress),
-			serverSocketLen);
+			serverAddressLen);
 	if(result == -1) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
 				"local port " << setServerPort << " to server socket!"
@@ -54,20 +60,35 @@ TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	int flags = 0;
-	ssize_t result = send(serverSocket, data, dataLen, flags);
-	if(result < 0) {
+	sif::debug << "Client Port: "<<ntohs(clientAddress.sin_port) << std::endl;
+	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
+			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
+	if(bytesSent < 0) {
 		// todo: handle errors
-		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed "
-				"with error " << strerror(errno) << std::endl;
+		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
+				<< std::endl;
+		sif::error << "Error: " << strerror(errno) << 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, 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) {
+		sif::info << "setting new address" << std::endl;
 		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
+		clientAddressLen = sizeof(clientAddress);
 	}
 }
 
@@ -130,3 +151,8 @@ void TmTcUnixUdpBridge::handleBindError() {
 	}
 }
 
+void TmTcUnixUdpBridge::handleSendError() {
+
+
+}
+
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index 538664d83..dbddc6c32 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -15,8 +15,9 @@ public:
 	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 ccsdsPacketDistributor,
-			 uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
+	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);
@@ -26,13 +27,14 @@ protected:
 
 private:
 	int serverSocket = 0;
+
 	const int serverSocketOptions = 0;
 
 	struct sockaddr_in clientAddress;
-	socklen_t clientSocketLen = 0;
+	socklen_t clientAddressLen = 0;
 
 	struct sockaddr_in serverAddress;
-	socklen_t serverSocketLen = 0;
+	socklen_t serverAddressLen = 0;
 
 	//! Access to the client address is mutex protected as it is set
 	//! by another task.
@@ -40,6 +42,7 @@ private:
 
 	void handleSocketError();
 	void handleBindError();
+	void handleSendError();
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index cb1e633f6..4385609bb 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -103,19 +103,17 @@ ReturnValue_t PusServiceBase::initialize() {
 			packetDestination);
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
-	if ((destService != nullptr) && (distributor != nullptr)) {
-		this->requestQueue->setDefaultDestination(
-				destService->getReportReceptionQueue());
-		distributor->registerService(this);
-		return RETURN_OK;
-	}
-	else {
+	if (destService == nullptr or distributor == nullptr) {
 		sif::error << "PusServiceBase::PusServiceBase: Service "
-				<< (uint32_t) this->serviceId << ": Configuration error."
-				<< " Make sure packetSource and packetDestination are defined "
-			       "correctly" << std::endl;
-		return RETURN_FAILED;
+				<< this->serviceId << ": Configuration error. Make sure "
+				<<	"packetSource and packetDestination are defined correctly"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
+	this->requestQueue->setDefaultDestination(
+			destService->getReportReceptionQueue());
+	distributor->registerService(this);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 9c3e5b94d..8c44f7de0 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -5,9 +5,11 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/globalfunctions/arrayprinter.h>
 
-TmTcBridge::TmTcBridge(object_id_t objectId,
-        object_id_t ccsdsPacketDistributor): SystemObject(objectId),
-        ccsdsPacketDistributor(ccsdsPacketDistributor)
+TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
+		object_id_t tmStoreId, object_id_t tcStoreId):
+		SystemObject(objectId),tmStoreId(tmStoreId), tcStoreId(tcStoreId),
+		tcDestination(tcDestination)
+
 {
     tmTcReceptionQueue = QueueFactory::instance()->
             createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
@@ -42,18 +44,24 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
 }
 
 ReturnValue_t TmTcBridge::initialize() {
-	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-	if (tcStore == NULL) {
-		return RETURN_FAILED;
+	tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
+	if (tcStore == nullptr) {
+		sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
+				"it is created and set up properly." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
-	tmStore = objectManager->get<StorageManagerIF>(objects::TM_STORE);
-	if (tmStore == NULL) {
-		return RETURN_FAILED;
+	tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
+	if (tmStore == nullptr) {
+		sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
+				"it is created and set up properly." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 	AcceptsTelecommandsIF* tcDistributor =
-			objectManager->get<AcceptsTelecommandsIF>(ccsdsPacketDistributor);
-	if (tcDistributor == NULL) {
-		return RETURN_FAILED;
+			objectManager->get<AcceptsTelecommandsIF>(tcDestination);
+	if (tcDistributor == nullptr) {
+		sif::error << "TmTcBridge::initialize: TC Distributor invalid"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 3fcbf84c2..3e3d1b714 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -24,7 +24,8 @@ public:
 	static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
 	static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
 
-	TmTcBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor);
+	TmTcBridge(object_id_t objectId, object_id_t tcDestination,
+			object_id_t tmStoreId, object_id_t tcStoreId);
 	virtual ~TmTcBridge();
 
 	/**
@@ -69,14 +70,20 @@ public:
 	virtual MessageQueueId_t getRequestQueue() override;
 
 protected:
+	//! Cached for initialize function.
+	object_id_t tmStoreId = objects::NO_OBJECT;
+	object_id_t tcStoreId = objects::NO_OBJECT;
+	object_id_t tcDestination = objects::NO_OBJECT;
+
 	//! Used to send and receive TMTC messages.
 	//! TmTcMessage is used to transport messages between tasks.
 	MessageQueueIF* tmTcReceptionQueue = nullptr;
-	StorageManagerIF* tcStore = nullptr;
+
 	StorageManagerIF* tmStore = nullptr;
-	object_id_t ccsdsPacketDistributor = 0;
-	//! Used to specify whether communication link is up
-	bool communicationLinkUp = false;
+	StorageManagerIF* tcStore = nullptr;
+
+	//! Used to specify whether communication link is up by default.
+	bool communicationLinkUp = true;
 	bool tmStored = false;
 
 	/**
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 40f7e57f4..79e650f1b 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -16,7 +16,7 @@ VerificationReporter::~VerificationReporter() {}
 
 void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 		TcPacketBase* current_packet, uint8_t set_step) {
-	if (this->acknowledgeQueue == 0) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
 		this->initialize();
 	}
 	PusVerificationMessage message(set_report_id,
@@ -35,7 +35,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
 		uint8_t set_step) {
-	if (this->acknowledgeQueue == 0) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE)  {
 		this->initialize();
 	}
 	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
@@ -52,7 +52,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 void VerificationReporter::sendFailureReport(uint8_t report_id,
 		TcPacketBase* current_packet, ReturnValue_t error_code, uint8_t step,
 		uint32_t parameter1, uint32_t parameter2) {
-	if (this->acknowledgeQueue == 0) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
 		this->initialize();
 	}
 	PusVerificationMessage message(report_id,
@@ -73,7 +73,7 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
 		ReturnValue_t error_code, uint8_t step, uint32_t parameter1,
 		uint32_t parameter2) {
-	if (this->acknowledgeQueue == 0) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
 		this->initialize();
 	}
 	PusVerificationMessage message(report_id, ackFlags, tcPacketId,

From 8046d005a46e734aa2112cbd6f617920da2ec753 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 18:18:54 +0200
Subject: [PATCH 0550/1774] CSB static framework id setting

---
 osal/linux/FixedTimeslotTask.cpp       |  2 +-
 osal/linux/TcUnixUdpPollingTask.cpp    | 35 +++++++++++++------
 osal/linux/TcUnixUdpPollingTask.h      |  2 +-
 osal/linux/TmTcUnixUdpBridge.cpp       | 48 ++++++++++++++++----------
 pus/Service2DeviceAccess.cpp           |  3 +-
 tcdistribution/PUSDistributor.cpp      |  8 ++---
 tmtcservices/CommandingServiceBase.cpp | 18 +++++++---
 tmtcservices/CommandingServiceBase.h   | 28 ++++++++++++---
 tmtcservices/PusServiceBase.cpp        |  5 ++-
 9 files changed, 99 insertions(+), 50 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index e5c68f9dd..9d7d08f68 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -45,7 +45,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 	}
 
 	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
+			" not found, not adding it to pst" << std::dec << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 122301da4..8cf7b2859 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -39,15 +39,14 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
 		if(bytesReceived < 0) {
 			// handle error
-			sif::error << "TcSocketPollingTask::performOperation: recvfrom "
-					"failed with " << strerror(errno) << std::endl;
-			if(errno == EAGAIN or errno == EWOULDBLOCK) {
-				sif::info << "timeout" << std::endl;
-			}
+			sif::error << "TcSocketPollingTask::performOperation: Reception"
+					"error." << std::endl;
+			handleReadError();
+
 			continue;
 		}
-		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
-				<< " bytes received" << std::endl;
+//		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
+//				<< " bytes received" << std::endl;
 
 		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
 		if(result != HasReturnvaluesIF::RETURN_FAILED) {
@@ -61,14 +60,14 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 
 
 ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
-	store_address_t storeId = 0;
+	store_address_t storeId;
 	ReturnValue_t result = tcStore->addData(&storeId,
 			receptionBuffer.data(), bytesRead);
 	// arrayprinter::print(receptionBuffer.data(), bytesRead);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
 				"storage failed" << std::endl;
-		sif::debug << "Packet size: " << bytesRead << std::endl;
+		sif::error << "Packet size: " << bytesRead << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -121,4 +120,18 @@ void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
 	}
 }
 
-
+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;
+	}
+	}
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index 86591e8d0..d8de14584 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -61,7 +61,7 @@ private:
 	timeval receptionTimeout;
 
 	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
-
+	void handleReadError();
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 40e965615..92fbbdfa9 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -32,17 +32,20 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	}
 
 	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);
 
-	serverAddressLen = sizeof(serverAddress);
 	int result = bind(serverSocket,
 			reinterpret_cast<struct sockaddr*>(&serverAddress),
 			serverAddressLen);
@@ -60,33 +63,38 @@ TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	int flags = 0;
-	sif::debug << "Client Port: "<<ntohs(clientAddress.sin_port) << std::endl;
+
+	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) {
-		// todo: handle errors
 		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
 				<< std::endl;
-		sif::error << "Error: " << strerror(errno) << std::endl;
 		handleSendError();
 	}
-	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
-			" sent." << std::endl;
+//	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+//			" sent." << std::endl;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
 	MutexHelper lock(mutex, 10);
 
-	char ipAddress [15];
-	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
-			&newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+//	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;
 
-	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) {
-		sif::info << "setting new address" << std::endl;
 		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
 		clientAddressLen = sizeof(clientAddress);
 	}
@@ -104,11 +112,11 @@ void TmTcUnixUdpBridge::handleSocketError() {
 	case(ENOBUFS):
 	case(ENOMEM):
 	case(EPROTONOSUPPORT):
-		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
+		sif::error << "TmTcUnixBridge::handleSocketError: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
 		break;
 	default:
-		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
+		sif::error << "TmTcUnixBridge::handleSocketError: Unknown error"
 				<< std::endl;
 		break;
 	}
@@ -122,7 +130,7 @@ void TmTcUnixUdpBridge::handleBindError() {
 		 Ephermeral ports can be shown with following command:
 		 sysctl -A | grep ip_local_port_range
 		 */
-		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Port access issue."
+		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;
@@ -140,19 +148,21 @@ void TmTcUnixUdpBridge::handleBindError() {
 	case(ENOMEM):
 	case(ENOTDIR):
 	case(EROFS): {
-		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
+		sif::error << "TmTcUnixBridge::handleBindError: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
 		break;
 	}
 	default:
-		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
+		sif::error << "TmTcUnixBridge::handleBindError: Unknown error"
 				<< std::endl;
 		break;
 	}
 }
 
 void TmTcUnixUdpBridge::handleSendError() {
-
-
+	switch(errno) {
+	default:
+		sif::error << "Error: " << strerror(errno) << std::endl;
+	}
 }
 
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 391c11164..4648aa9c0 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -15,8 +15,7 @@ Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
         object_id_t tmDestination, uint8_t numberOfParallelCommands,
         uint16_t commandTimeoutSeconds):
         CommandingServiceBase(objectId, apid, serviceId,
-	        numberOfParallelCommands, commandTimeoutSeconds,
-	        tcSource, tmDestination) {}
+	        numberOfParallelCommands, commandTimeoutSeconds) {}
 
 Service2DeviceAccess::~Service2DeviceAccess() {}
 
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index d6e20acf5..969380d6f 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -13,12 +13,12 @@ PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
 PUSDistributor::~PUSDistributor() {}
 
 TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
-//	debug << "PUSDistributor::handlePacket received: " << this->current_packet_id.store_index << ", " << this->current_packet_id.packet_index << std::endl;
 	TcMqMapIter queueMapIt = this->queueMap.end();
 	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
 	if (currentPacket.getWholeData() != NULL) {
 		tcStatus = checker.checkPacket(&currentPacket);
-//		info << "PUSDistributor::handlePacket: packetCheck returned with " << (int)tc_status << std::endl;
+//		sif::debug << "PUSDistributor::handlePacket: packetCheck returned with "
+//				<< (int)tcStatus << std::endl;
 		uint32_t queue_id = currentPacket.getService();
 		queueMapIt = this->queueMap.find(queue_id);
 	} else {
@@ -29,8 +29,8 @@ TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
 	}
 
 	if (tcStatus != RETURN_OK) {
-		sif::debug << "PUSDistributor::handlePacket: error with " << (int) tcStatus
-				<< ", 0x"<< std::hex << (int) tcStatus << std::endl;
+		sif::debug << "PUSDistributor::handlePacket: Error with " << tcStatus
+				<< ", 0x"<< std::hex << tcStatus << std::dec << std::endl;
 		return this->queueMap.end();
 	} else {
 		return queueMapIt;
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 0c5f5eab1..63a3d9435 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -8,18 +8,28 @@
 #include <framework/tmtcpacket/pus/TcPacketStored.h>
 #include <framework/tmtcpacket/pus/TmPacketStored.h>
 
+object_id_t CommandingServiceBase::packetSource = objects::NO_OBJECT;
+object_id_t CommandingServiceBase::packetDestination = objects::NO_OBJECT;
+
 CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
 		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
-		uint16_t commandTimeoutSeconds, object_id_t setPacketSource,
-		object_id_t setPacketDestination, size_t queueDepth) :
+		uint16_t commandTimeoutSeconds, size_t queueDepth) :
 		SystemObject(setObjectId), apid(apid), service(service),
 		timeoutSeconds(commandTimeoutSeconds),
-		commandMap(numberOfParallelCommands), packetSource(setPacketSource),
-		packetDestination(setPacketDestination) {
+		commandMap(numberOfParallelCommands) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 }
 
+void CommandingServiceBase::setPacketSource(object_id_t packetSource) {
+	this->packetSource = packetSource;
+}
+
+void CommandingServiceBase::setPacketDestination(
+		object_id_t packetDestination) {
+	this->packetDestination = packetDestination;
+}
+
 
 CommandingServiceBase::~CommandingServiceBase() {
 	QueueFactory::instance()->deleteMessageQueue(commandQueue);
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 700503c69..e9b5f0471 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -15,6 +15,10 @@
 
 class TcPacketStored;
 
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
 /**
  * @brief 	This class is the basis for all PUS Services, which have to
  * 			relay Telecommands to software bus.
@@ -33,6 +37,7 @@ class CommandingServiceBase: public SystemObject,
 		public AcceptsTelecommandsIF,
 		public ExecutableObjectIF,
 		public HasReturnvaluesIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
 	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
@@ -57,10 +62,24 @@ public:
 	 */
 	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
 			uint8_t service, uint8_t numberOfParallelCommands,
-			uint16_t commandTimeoutSeconds, object_id_t setPacketSource,
-			object_id_t setPacketDestination, size_t queueDepth = 20);
+			uint16_t commandTimeoutSeconds, size_t queueDepth = 20);
 	virtual ~CommandingServiceBase();
 
+	/**
+	 * This setter can be used to set the packet source individually instead
+	 * of using the default static framework ID set in the factory.
+	 * This should be called at object initialization and not during run-time!
+	 * @param packetSource
+	 */
+	void setPacketSource(object_id_t packetSource);
+	/**
+	 * This setter can be used to set the packet destination individually
+	 * instead of using the default static framework ID set in the factory.
+	 * This should be called at object initialization and not during run-time!
+	 * @param packetDestination
+	 */
+	void setPacketDestination(object_id_t packetDestination);
+
 	/***
 	 * This is the periodically called function.
 	 * Handle request queue for external commands.
@@ -229,9 +248,8 @@ protected:
 	uint32_t failureParameter1 = 0;
 	uint32_t failureParameter2 = 0;
 
-	object_id_t packetSource;
-
-	object_id_t packetDestination;
+	static object_id_t packetSource;
+	static object_id_t packetDestination;
 
 	/**
 	 * Pointer to the task which executes this component,
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index 4385609bb..877eff3e6 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -79,9 +79,8 @@ void PusServiceBase::handleRequestQueue() {
 		}
 		else {
 			sif::error << "PusServiceBase::performOperation: Service "
-					<< (uint16_t) this->serviceId
-					<< ": Error receiving packet. Code: " << std::hex << status
-					<< std::dec << std::endl;
+					<< this->serviceId << ": Error receiving packet. Code: "
+					<< std::hex << status << std::dec << std::endl;
 		}
 	}
 }

From dc27cc9aff73e6c17eb36281d056bd7c217ba6b6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 18:37:26 +0200
Subject: [PATCH 0551/1774] srv8 added to framework

---
 pus/Service2DeviceAccess.cpp         |   7 +-
 pus/Service2DeviceAccess.h           |   3 +-
 pus/Service8FunctionManagement.cpp   | 129 +++++++++++++++++++++++++
 pus/Service8FunctionManagement.h     |  64 +++++++++++++
 pus/servicepackets/Service8Packets.h | 136 +++++++++++++++++++++++++++
 5 files changed, 334 insertions(+), 5 deletions(-)
 create mode 100644 pus/Service8FunctionManagement.cpp
 create mode 100644 pus/Service8FunctionManagement.h
 create mode 100644 pus/servicepackets/Service8Packets.h

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 4648aa9c0..1d5f21eba 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -11,14 +11,14 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId, object_id_t tcSource,
-        object_id_t tmDestination, uint8_t numberOfParallelCommands,
+        uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands,
         uint16_t commandTimeoutSeconds):
         CommandingServiceBase(objectId, apid, serviceId,
 	        numberOfParallelCommands, commandTimeoutSeconds) {}
 
 Service2DeviceAccess::~Service2DeviceAccess() {}
 
+
 ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
 	switch(static_cast<Subservice>(subservice)){
 	case Subservice::RAW_COMMANDING:
@@ -41,7 +41,6 @@ ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
 
 	ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
 	return result;
-
 }
 
 ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
@@ -55,6 +54,7 @@ ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
 ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
 		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
 		uint32_t* state, object_id_t objectId) {
@@ -100,6 +100,7 @@ ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand(
 	return result;
 }
 
+
 ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply,
 		Command_t previousCommand, uint32_t* state,
 		CommandMessage* optionalNextCommand, object_id_t objectId,
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index 4dab0fa0a..1a0bede0a 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -36,8 +36,7 @@ class Service2DeviceAccess : public CommandingServiceBase,
 {
 public:
 	Service2DeviceAccess(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, object_id_t tcSource,
-	        object_id_t tmDestination, uint8_t numberOfParallelCommands = 4,
+	        uint8_t serviceId, uint8_t numberOfParallelCommands = 4,
 	        uint16_t commandTimeoutSeconds = 60);
 	virtual ~Service2DeviceAccess();
 
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
new file mode 100644
index 000000000..47afeae6e
--- /dev/null
+++ b/pus/Service8FunctionManagement.cpp
@@ -0,0 +1,129 @@
+#include <framework/pus/Service8FunctionManagement.h>
+#include <framework/pus/servicepackets/Service8Packets.h>
+
+#include <framework/action/ActionMessage.h>
+#include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/action/HasActionsIF.h>
+#include <framework/devicehandlers/DeviceHandlerIF.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
+		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
+		uint16_t commandTimeoutSeconds):
+		CommandingServiceBase(object_id, apid, serviceId, numParallelCommands,
+		commandTimeoutSeconds) {}
+
+Service8FunctionManagement::~Service8FunctionManagement() {}
+
+
+ReturnValue_t Service8FunctionManagement::isValidSubservice(
+		uint8_t subservice) {
+	switch(static_cast<Subservice>(subservice)) {
+	case Subservice::DIRECT_COMMANDING:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject(
+		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+		MessageQueueId_t* id, object_id_t* objectId) {
+	if(tcDataLen < sizeof(object_id_t)) {
+		return CommandingServiceBase::INVALID_TC;
+	}
+	SerializeAdapter::deSerialize(objectId, &tcData,
+			&tcDataLen, SerializeIF::Endianness::BIG);
+
+	return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+	// check HasActionIF property of target
+	HasActionsIF* possibleTarget = objectManager->get<HasActionsIF>(*objectId);
+	if(possibleTarget == nullptr){
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+	*messageQueueToSet = possibleTarget->getCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service8FunctionManagement::prepareCommand(
+		CommandMessage* message, uint8_t subservice, const uint8_t* tcData,
+		size_t tcDataLen, uint32_t* state, object_id_t objectId) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	if(subservice == static_cast<uint8_t>(Subservice::DIRECT_COMMANDING)) {
+		result = prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
+				tcData, tcDataLen);
+	}
+	return result;
+}
+
+ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
+		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
+	// Create direct command instance by extracting data from Telecommand
+	DirectCommand command(tcData,tcDataLen);
+
+	// store additional parameters into the Inter Process Communication Store
+	store_address_t parameterAddress;
+	ReturnValue_t result = IPCStore->addData(&parameterAddress,
+			command.getParameters(),command.getParametersSize());
+
+	// setCommand expects a Command Message, an Action ID and a store adress
+	// pointing to additional parameters
+	ActionMessage::setCommand(message,command.getActionId(),parameterAddress);
+	return result;
+}
+
+
+ReturnValue_t Service8FunctionManagement::handleReply(
+		const CommandMessage* reply, Command_t previousCommand,
+		uint32_t* state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool* isStep) {
+	Command_t replyId = reply->getCommand();
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	ActionId_t actionId = ActionMessage::getActionId(reply);
+	ReturnValue_t returnCode = ActionMessage::getReturnCode(reply);
+
+	switch(replyId)  {
+	case ActionMessage::COMPLETION_SUCCESS: {
+		DirectReply completionReply(objectId, actionId,returnCode);
+		result = CommandingServiceBase::EXECUTION_COMPLETE;
+		break;
+	}
+	case ActionMessage::STEP_SUCCESS: {
+		*isStep = true;
+		result = HasReturnvaluesIF::RETURN_OK;
+		break;
+	}
+	case ActionMessage::DATA_REPLY: {
+		store_address_t storeId = ActionMessage::getStoreId(reply);
+		size_t size = 0;
+		const uint8_t * buffer = nullptr;
+		result = IPCStore->getData(storeId, &buffer, &size);
+		if(result != RETURN_OK) {
+			sif::error << "Service 8: Could not retrieve data for data reply";
+			return result;
+		}
+		DataReply dataReply(objectId,actionId,buffer,size);
+		sendTmPacket(static_cast<uint8_t>(
+				Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
+		result = IPCStore ->deleteData(storeId);
+		break;
+	}
+	case ActionMessage::STEP_FAILED:
+		*isStep = true;
+		/*No break, falls through*/
+	case ActionMessage::COMPLETION_FAILED:
+		result = ActionMessage::getReturnCode(reply);
+		break;
+	default:
+		result = INVALID_REPLY;
+	}
+	return result;
+}
+
+
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
new file mode 100644
index 000000000..e06c554c4
--- /dev/null
+++ b/pus/Service8FunctionManagement.h
@@ -0,0 +1,64 @@
+#ifndef MISSION_SERVICE8FUNCTIONMANAGEMENT_H_
+#define MISSION_SERVICE8FUNCTIONMANAGEMENT_H_
+
+#include <framework/tmtcservices/CommandingServiceBase.h>
+
+/**
+ * @brief Functional commanding.
+ * Full Documentation: ECSS-E-ST-70-41C p.64, p. 451
+ * Dissertation Baetz p. 115, 116, 165-167
+ *
+ * This service provides the capability to perform functions of an
+ * application process and provides high-level commanding as opposed to the
+ * Raw Access provided by Service 2. Examples for these functions can include
+ * control and operation of payload or the AOCS subsystem.
+ * This service will be the primary means to control the spacecraft as it is
+ * considered safer than the Raw Access provided
+ * by Service 2 and is generally sufficient for most tasks.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * This service is very closely tied to the Commanding Service Base template
+ * class. There is constant interaction between this Service Base und a
+ * subclass like this service.
+ *
+ * Service Capability:
+ * 	 - TC[8,128]: Direct Commanding
+ *   - TM[8,130]: Direct Commanding Data Reply
+ *
+ * @ingroup pus_services
+ */
+class Service8FunctionManagement : public CommandingServiceBase
+{
+public:
+	Service8FunctionManagement(object_id_t objectId, uint16_t apid,
+			uint8_t serviceId, uint8_t numParallelCommands = 4,
+			uint16_t commandTimeoutSeconds = 60);
+	virtual ~Service8FunctionManagement();
+
+protected:
+	/* CSB abstract functions implementation . See CSB documentation. */
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message,
+				uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+				uint32_t *state, object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+				Command_t previousCommand, uint32_t *state,
+				CommandMessage* optionalNextCommand, object_id_t objectId,
+				bool *isStep) override;
+
+private:
+	enum class Subservice {
+		DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding
+		DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply
+	};
+
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
+	ReturnValue_t prepareDirectCommand(CommandMessage* message,
+			const uint8_t* tcData, size_t tcDataLen);
+};
+
+#endif /* MISSION_DEVICE2DEVICECOMMANDING_H_ */
diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
new file mode 100644
index 000000000..5ef912806
--- /dev/null
+++ b/pus/servicepackets/Service8Packets.h
@@ -0,0 +1,136 @@
+/**
+ * \file Service8Packets.h
+ *
+ * \brief Structure of a Direct Command.
+ * Normal reply (subservice 130) consists of
+ *   1. Target object ID
+ *   2. Action ID (taget device has specified functions with action IDs)
+ *   3. Return Code
+ *   4. Optional step number for step replies
+ *
+ * Data reply (subservice 132) consists of
+ *   1. Target Object ID
+ *   2. Action ID
+ *   3. Data
+ *
+ *  \date 01.07.2019
+ *  \author R. Mueller
+ */
+
+#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+
+#include <framework/action/ActionMessage.h>
+#include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/serialize/SerialBufferAdapter.h>
+#include <framework/serialize/SerializeElement.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/serialize/SerialFixedArrayListAdapter.h>
+
+
+/**
+ * \brief Subservice 128
+ * \ingroup spacepackets
+ */
+class DirectCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
+public:
+	//typedef uint16_t typeOfMaxData;
+	//static const typeOfMaxData MAX_DATA = 256;
+	DirectCommand(const uint8_t* dataBuffer_, uint32_t size_) {
+		size_t size = sizeof(objectId);
+		SerializeAdapter::deSerialize(&objectId,&dataBuffer_,&size,
+		        SerializeIF::Endianness::BIG);
+		size = sizeof(actionId);
+		SerializeAdapter::deSerialize(&actionId,&dataBuffer_,&size,
+		        SerializeIF::Endianness::BIG);
+		parameterBuffer = dataBuffer_;
+		parametersSize = size_ - sizeof(objectId) - sizeof(actionId);
+	}
+	ActionId_t getActionId() const {
+		return actionId;
+	}
+
+	object_id_t getObjectId() const {
+		return objectId;
+	}
+
+	const uint8_t*  getParameters() {
+		return parameterBuffer;
+	}
+
+	uint32_t getParametersSize() const {
+		return parametersSize;
+	}
+
+private:
+	DirectCommand(const DirectCommand &command);
+	object_id_t objectId;
+	ActionId_t actionId;
+	uint32_t parametersSize; //!< [EXPORT] : [IGNORE]
+	const uint8_t * parameterBuffer; //!< [EXPORT] : [MAXSIZE] 65535 Bytes
+
+};
+
+
+/**
+ * \brief Subservice 130
+ * \ingroup spacepackets
+ */
+class DataReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 130
+public:
+	typedef uint16_t typeOfMaxDataSize;
+	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
+	DataReply(object_id_t objectId_, ActionId_t actionId_,
+		const uint8_t * replyDataBuffer_ = NULL, uint16_t replyDataSize_ = 0):
+		objectId(objectId_), actionId(actionId_), replyData(replyDataBuffer_,replyDataSize_){
+		setLinks();
+	}
+
+private:
+	DataReply(const DataReply &reply);
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&actionId);
+		actionId.setNext(&replyData);
+	}
+	SerializeElement<object_id_t> objectId;
+	SerializeElement<ActionId_t> actionId;
+	SerializeElement<SerialBufferAdapter<uint16_t>> replyData;
+};
+
+
+/**
+ * \brief Subservice 132
+ * \ingroup spacepackets
+ */
+class DirectReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 132
+public:
+	typedef uint16_t typeOfMaxDataSize;
+	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
+
+	DirectReply(object_id_t objectId_, ActionId_t actionId_, ReturnValue_t returnCode_,
+			bool isStep_ = false, uint8_t step_ = 0):
+			isStep(isStep_), objectId(objectId_), actionId(actionId_),
+			returnCode(returnCode_),step(step_)  {
+		setLinks();
+	}
+private:
+
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&actionId);
+		actionId.setNext(&returnCode);
+		if(isStep) {
+			returnCode.setNext(&step);
+		}
+	}
+	bool isDataReply; //!< [EXPORT] : [IGNORE]
+	bool isStep; //!< [EXPORT] : [IGNORE]
+	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [IGNORE]
+	SerializeElement<ActionId_t> actionId; //!< [EXPORT] : [IGNORE]
+	SerializeElement<ReturnValue_t> returnCode; //!< [EXPORT] : [IGNORE]
+	SerializeElement<uint8_t> step; //!< [EXPORT] : [OPTIONAL] [IGNORE]
+
+};
+
+#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */

From 64c290ffe44ce6a4352152bcb1a04ff643bfd395 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 18:38:58 +0200
Subject: [PATCH 0552/1774] include guard fix

---
 pus/Service8FunctionManagement.cpp | 2 +-
 pus/Service8FunctionManagement.h   | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 47afeae6e..243384645 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -67,7 +67,7 @@ ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
 	// Create direct command instance by extracting data from Telecommand
 	DirectCommand command(tcData,tcDataLen);
 
-	// store additional parameters into the Inter Process Communication Store
+	// store additional parameters into the IPC Store
 	store_address_t parameterAddress;
 	ReturnValue_t result = IPCStore->addData(&parameterAddress,
 			command.getParameters(),command.getParametersSize());
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index e06c554c4..54c98b97c 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -1,5 +1,5 @@
-#ifndef MISSION_SERVICE8FUNCTIONMANAGEMENT_H_
-#define MISSION_SERVICE8FUNCTIONMANAGEMENT_H_
+#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
+#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 
 #include <framework/tmtcservices/CommandingServiceBase.h>
 
@@ -61,4 +61,4 @@ private:
 			const uint8_t* tcData, size_t tcDataLen);
 };
 
-#endif /* MISSION_DEVICE2DEVICECOMMANDING_H_ */
+#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */

From ac9e6e1337acc8a5f68811be1f5da30c69a3e52e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 00:59:10 +0200
Subject: [PATCH 0553/1774] continued with local data pool manager

---
 datapoolglob/GlobalDataSet.h                  |  6 +-
 ...LocalDataPoolIF.h => HasLocalDataPoolIF.h} |  4 +-
 datapoollocal/LocalDataPoolManager.cpp        | 14 +--
 datapoollocal/LocalDataPoolManager.h          | 95 ++++++++++++++-----
 datapoollocal/LocalDataSet.cpp                |  4 +-
 datapoollocal/LocalDataSet.h                  |  4 +-
 datapoollocal/LocalPoolVariable.h             |  4 +-
 datapoollocal/LocalPoolVariable.tpp           |  6 +-
 datapoollocal/LocalPoolVector.h               |  2 +-
 datapoollocal/LocalPoolVector.tpp             |  6 +-
 devicehandlers/DeviceHandlerBase.h            |  5 +-
 11 files changed, 97 insertions(+), 53 deletions(-)
 rename datapoollocal/{OwnsLocalDataPoolIF.h => HasLocalDataPoolIF.h} (97%)

diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index 519b08c09..d237cc1b4 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -1,5 +1,5 @@
-#ifndef DATASET_H_
-#define DATASET_H_
+#ifndef FRAMEWORK_DATAPOOLGLOB_DATASET_H_
+#define FRAMEWORK_DATAPOOLGLOB_DATASET_H_
 
 #include <framework/datapool/DataSetBase.h>
 
@@ -93,4 +93,4 @@ private:
 	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
 };
 
-#endif /* DATASET_H_ */
+#endif /* FRAMEWORK_DATAPOOLGLOB_DATASET_H_ */
diff --git a/datapoollocal/OwnsLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
similarity index 97%
rename from datapoollocal/OwnsLocalDataPoolIF.h
rename to datapoollocal/HasLocalDataPoolIF.h
index 6fc108896..0095f8944 100644
--- a/datapoollocal/OwnsLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -36,9 +36,9 @@ using LocalDataPoolMapIter = LocalDataPool::iterator;
  * pragmatic solution I found was to offer the client the full interface
  * of the LocalDataPoolManager.
  */
-class OwnsLocalDataPoolIF {
+class HasLocalDataPoolIF {
 public:
-	virtual~ OwnsLocalDataPoolIF() {};
+	virtual~ HasLocalDataPoolIF() {};
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 9c70c74fb..02016abf0 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -7,7 +7,7 @@
 
 #include <array>
 
-LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
+LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
         appendValidityBuffer(appendValidityBuffer) {
 	if(owner == nullptr) {
@@ -63,7 +63,7 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	if(not mapInitialized) {
-		ReturnValue_t result = owner->initializePoolEntries(localDpMap);
+		ReturnValue_t result = owner->initializePoolEntries(localPoolMap);
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			mapInitialized = true;
 		}
@@ -96,8 +96,8 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
 		lp_id_t localPoolId) {
-	auto poolIter = localDpMap.find(localPoolId);
-	if (poolIter == localDpMap.end()) {
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
 		sif::debug << "HousekeepingManager::fechPoolEntry:"
 				" Pool entry not found." << std::endl;
 		return POOL_ENTRY_NOT_FOUND;
@@ -110,7 +110,7 @@ MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
-const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
+const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
     return owner;
 }
 
@@ -213,4 +213,6 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
     return result;
 }
 
-
+ReturnValue_t LocalDataPoolManager::performHkOperation() {
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 3841b99ce..847c309c7 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,12 +1,13 @@
-#ifndef FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_
-#define FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+
 #include <framework/datapool/DataSetIF.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/ipc/MutexIF.h>
 
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <framework/datapool/PoolEntry.h>
-#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
+#include <framework/datapoollocal/HasLocalDataPoolIF.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MutexHelper.h>
@@ -20,7 +21,7 @@ class LocalDataSet;
  * @details
  * The actual data pool structure is a member of this class. Any class which
  * has a local data pool shall have this class as a member and implement
- * the OwnsLocalDataPoolIF.
+ * the HasLocalDataPoolIF.
  *
  * Users of the data pool use the helper classes LocalDataSet,
  * LocalPoolVariable and LocalPoolVector to access pool entries in
@@ -57,16 +58,24 @@ public:
      * @param queueToUse
      * @param appendValidityBuffer
      */
-	LocalDataPoolManager(OwnsLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+	LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
 	        bool appendValidityBuffer = true);
+	virtual~ LocalDataPoolManager();
+
 	/**
 	 * Initializes the map by calling the map initialization function of the
-	 * owner abd assigns the queue to use.
+	 * owner and assigns the queue to use.
 	 * @param queueToUse
 	 * @return
 	 */
 	ReturnValue_t initialize(MessageQueueIF* queueToUse,
 	        object_id_t hkDestination);
+	/**
+	 * This should be called in the periodic handler of the owner.
+	 * It performs all the periodic functionalities of the data pool manager.
+	 * @return
+	 */
+	ReturnValue_t performHkOperation();
 	/**
 	 * This function is used to set the default HK packet destination.
 	 * This destination will usually only be set once.
@@ -74,8 +83,6 @@ public:
 	 */
 	void setHkPacketDestination(MessageQueueId_t hkDestination);
 
-	virtual~ LocalDataPoolManager();
-
 	/**
 	 * Generate a housekeeping packet with a given SID.
 	 * @param sid
@@ -95,28 +102,64 @@ public:
 	 */
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
-	const OwnsLocalDataPoolIF* getOwner() const;
+	const HasLocalDataPoolIF* getOwner() const;
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
 
+    /**
+     * Different types of housekeeping reporting are possible.
+     *  1. PERIODIC: HK packets are generated in fixed intervals
+     *  2. UPDATED: HK packets are generated if a value was updated
+     *  3. REQUESTED: HK packets are only generated if explicitely requested
+     */
+    enum class ReportingType: uint8_t {
+        PERIODIC,
+        ON_UPDATE,
+        REQUESTED
+    };
+
     /* Copying forbidden */
     LocalDataPoolManager(const LocalDataPoolManager &) = delete;
     LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
+
 private:
-	/** This is the map holding the actual data. Should only be initialized
-	 * once ! */
-	bool mapInitialized = false;
-	/** This specifies whether a validity buffer is appended at the end
-	 * of generated housekeeping packets. */
-	bool appendValidityBuffer = true;
+    LocalDataPool localPoolMap;
+    /** Every housekeeping data manager has a mutex to protect access
+     * to it's data pool. */
+    MutexIF* mutex = nullptr;
+    /** The class which actually owns the manager (and its datapool). */
+    HasLocalDataPoolIF* owner = nullptr;
 
-	LocalDataPool localDpMap;
+    /**
+     * The data pool manager will keep an internal map of HK receivers.
+     */
+    struct HkReceiver {
+        LocalDataSet* dataSet = nullptr;
+        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
+        ReportingType reportingType = ReportingType::PERIODIC;
+        bool reportingStatus = true;
+        /** Different members of this union will be used depending on reporting
+         * type */
+        union hkParameter {
+            /** This parameter will be used for the PERIODIC type */
+            dur_seconds_t collectionInterval = 0;
+            /** This parameter will be used for the ON_UPDATE type */
+            bool hkDataChanged;
+        };
+    };
+
+    /** Using a multimap as the same object might request multiple datasets */
+    using HkReceiversMap = std::multimap<object_id_t, struct HkReceiver>;
+
+    HkReceiversMap hkReceiversMap;
+
+    /** This is the map holding the actual data. Should only be initialized
+     * once ! */
+    bool mapInitialized = false;
+    /** This specifies whether a validity buffer is appended at the end
+     * of generated housekeeping packets. */
+    bool appendValidityBuffer = true;
 
-	/** Every housekeeping data manager has a mutex to protect access
-	 * to it's data pool. */
-	MutexIF * mutex = nullptr;
-	/** The class which actually owns the manager (and its datapool). */
-	OwnsLocalDataPoolIF* owner = nullptr;
 	/**
 	 * @brief Queue used for communication, for example commands.
 	 * Is also used to send messages. Can be set either in the constructor
@@ -165,10 +208,10 @@ private:
 template<class T> inline
 ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
-	auto poolIter = localDpMap.find(localPoolId);
-	if (poolIter == localDpMap.end()) {
-		sif::debug << "HousekeepingManager::fechPoolEntry:"
-				" Pool entry not found." << std::endl;
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
+		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
+		        "not found." << std::endl;
 		return POOL_ENTRY_NOT_FOUND;
 	}
 
@@ -182,4 +225,4 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 }
 
 
-#endif /* FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_ */
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 272a1b6f5..2a42cd387 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -5,7 +5,7 @@
 #include <cmath>
 #include <cstring>
 
-LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner,
+LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
         const size_t maxNumberOfVariables):
         DataSetBase(poolVarList.data(), maxNumberOfVariables) {
     poolVarList.reserve(maxNumberOfVariables);
@@ -23,7 +23,7 @@ LocalDataSet::LocalDataSet(object_id_t ownerId,
         DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
     poolVarList.reserve(maxNumberOfVariables);
     poolVarList.resize(maxNumberOfVariables);
-    OwnsLocalDataPoolIF* hkOwner = objectManager->get<OwnsLocalDataPoolIF>(
+    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             ownerId);
     if(hkOwner == nullptr) {
         sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 20c647ca1..2c70de826 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
 #include <framework/datapool/DataSetBase.h>
 #include <framework/datapool/DataSetIF.h>
-#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
+#include <framework/datapoollocal/HasLocalDataPoolIF.h>
 #include <framework/serialize/SerializeIF.h>
 
 #include <vector>
@@ -37,7 +37,7 @@ public:
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSet(OwnsLocalDataPoolIF *hkOwner,
+	LocalDataSet(HasLocalDataPoolIF *hkOwner,
 	        const size_t maxNumberOfVariables);
 
 	/**
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 98782b8d2..73d691d7e 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -3,8 +3,8 @@
 
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/datapool/DataSetIF.h>
+#include <framework/datapoollocal/HasLocalDataPoolIF.h>
 #include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 
 #include <framework/serialize/SerializeAdapter.h>
@@ -42,7 +42,7 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVar(lp_id_t poolId, OwnsLocalDataPoolIF* hkOwner,
+	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
 			DataSetIF* dataSet = nullptr);
 
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 7f9fbf137..0b96bb4fd 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -7,7 +7,7 @@
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
-		OwnsLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
+		HasLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
 		DataSetIF* dataSet):
 		localPoolId(poolId),readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
@@ -33,8 +33,8 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
 				"NO_PARAMETER value!" << std::endl;
 	}
-	OwnsLocalDataPoolIF* hkOwner =
-			objectManager->get<OwnsLocalDataPoolIF>(poolOwner);
+	HasLocalDataPoolIF* hkOwner =
+			objectManager->get<HasLocalDataPoolIF>(poolOwner);
 	if(hkOwner == nullptr) {
 		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
 				"the correct interface HasHkPoolParametersIF!" << std::endl;
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index f65328949..3083646f3 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -46,7 +46,7 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVector(lp_id_t poolId, OwnsLocalDataPoolIF* hkOwner,
+	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
 			DataSetIF* dataSet = nullptr);
 
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 872c49ec9..b7f2fe192 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -7,7 +7,7 @@
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		OwnsLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
+		HasLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
 		DataSetIF* dataSet) :
 		localPoolId(poolId), valid(false), readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
@@ -29,8 +29,8 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
 				"NO_PARAMETER value!" << std::endl;
 	}
-	OwnsLocalDataPoolIF* hkOwner =
-			objectManager->get<OwnsLocalDataPoolIF>(poolOwner);
+	HasLocalDataPoolIF* hkOwner =
+			objectManager->get<HasLocalDataPoolIF>(poolOwner);
 	if(hkOwner == nullptr) {
 		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
 				"the correct interface HasHkPoolParametersIF!" << std::endl;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3fdab9ed4..ce7f7b9f2 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -17,10 +17,9 @@
 #include <framework/health/HealthHelper.h>
 #include <framework/parameters/ParameterHelper.h>
 #include <framework/datapool/HkSwitchHelper.h>
+#include <framework/datapoollocal/HasLocalDataPoolIF.h>
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
-
 #include <map>
 
 namespace Factory{
@@ -88,7 +87,7 @@ class DeviceHandlerBase: public DeviceHandlerIF,
 		public HasHealthIF,
 		public HasActionsIF,
 		public ReceivesParameterMessagesIF,
-		public OwnsLocalDataPoolIF {
+		public HasLocalDataPoolIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	/**

From 6f50356964da86b311b9e96b08d33de6c2b76233 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 14:26:15 +0200
Subject: [PATCH 0554/1774] new shared ring buffer

---
 container/RingBufferBase.h           | 73 ++++++++++++++++------------
 container/SharedRingBuffer.cpp       | 32 ++++++++++++
 container/SharedRingBuffer.h         | 42 ++++++++++++++++
 container/SimpleRingBuffer.cpp       | 27 ++++++----
 container/SimpleRingBuffer.h         | 44 ++++++++++++-----
 devicehandlers/ChildHandlerBase.cpp  | 16 +++---
 devicehandlers/ChildHandlerBase.h    |  4 +-
 devicehandlers/DeviceHandlerBase.cpp | 38 ++++++++++-----
 devicehandlers/DeviceHandlerBase.h   | 19 ++++----
 globalfunctions/DleEncoder.cpp       |  3 +-
 timemanager/Clock.h                  |  4 +-
 11 files changed, 216 insertions(+), 86 deletions(-)
 create mode 100644 container/SharedRingBuffer.cpp
 create mode 100644 container/SharedRingBuffer.h

diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 1beb51c26..86896b9ec 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -7,29 +7,23 @@
 template<uint8_t N_READ_PTRS = 1>
 class RingBufferBase {
 public:
-	RingBufferBase(uint32_t startAddress, const size_t size, bool overwriteOld) :
+	RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
 			start(startAddress), write(startAddress), size(size),
 			overwriteOld(overwriteOld) {
 		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
 			read[count] = startAddress;
 		}
 	}
-	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
-		if (availableReadData(n) >= amount) {
-			incrementRead(amount, n);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
+
+	virtual ~RingBufferBase() {}
+
+	bool isFull(uint8_t n = 0) {
+		return (availableWriteSpace(n) == 0);
 	}
-	ReturnValue_t writeData(uint32_t amount) {
-		if (availableWriteSpace() >= amount || overwriteOld) {
-			incrementWrite(amount);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
+	bool isEmpty(uint8_t n = 0) {
+		return (availableReadData(n) == 0);
 	}
+
 	uint32_t availableReadData(uint8_t n = 0) const {
 		return ((write + size) - read[n]) % size;
 	}
@@ -37,54 +31,55 @@ public:
 		//One less to avoid ambiguous full/empty problem.
 		return (((read[n] + size) - write - 1) % size);
 	}
-	bool isFull(uint8_t n = 0) {
-		return (availableWriteSpace(n) == 0);
-	}
-	bool isEmpty(uint8_t n = 0) {
-		return (availableReadData(n) == 0);
-	}
-	virtual ~RingBufferBase() {
 
-	}
 	uint32_t getRead(uint8_t n = 0) const {
 		return read[n];
 	}
+
 	void setRead(uint32_t read, uint8_t n = 0) {
 		if (read >= start && read < (start+size)) {
 			this->read[n] = read;
 		}
 	}
+
 	uint32_t getWrite() const {
 		return write;
 	}
+
 	void setWrite(uint32_t write) {
 		this->write = write;
 	}
+
 	void clear() {
 		write = start;
 		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
 			read[count] = start;
 		}
 	}
-	uint32_t writeTillWrap() {
+
+	size_t writeTillWrap() {
 		return (start + size) - write;
 	}
-	uint32_t readTillWrap(uint8_t n = 0) {
+
+	size_t readTillWrap(uint8_t n = 0) {
 		return (start + size) - read[n];
 	}
-	uint32_t getStart() const {
+
+	size_t getStart() const {
 		return start;
 	}
+
 	bool overwritesOld() const {
 		return overwriteOld;
 	}
-	uint32_t maxSize() const {
+
+	size_t maxSize() const {
 		return size - 1;
 	}
 protected:
-	const uint32_t start;
-	uint32_t write;
-	uint32_t read[N_READ_PTRS];
+	const size_t start;
+	size_t write;
+	size_t read[N_READ_PTRS];
 	const size_t size;
 	const bool overwriteOld;
 	void incrementWrite(uint32_t amount) {
@@ -93,6 +88,24 @@ protected:
 	void incrementRead(uint32_t amount, uint8_t n = 0) {
 		read[n] = ((read[n] + amount - start) % size) + start;
 	}
+
+	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
+		if (availableReadData(n) >= amount) {
+			incrementRead(amount, n);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+
+	ReturnValue_t writeData(uint32_t amount) {
+		if (availableWriteSpace() >= amount or overwriteOld) {
+			incrementWrite(amount);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
 };
 
 #endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
new file mode 100644
index 000000000..36315753f
--- /dev/null
+++ b/container/SharedRingBuffer.cpp
@@ -0,0 +1,32 @@
+#include <framework/container/SharedRingBuffer.h>
+#include <framework/ipc/MutexFactory.h>
+#include <framework/ipc/MutexHelper.h>
+
+SharedRingBuffer::SharedRingBuffer(const size_t size, bool overwriteOld):
+		SimpleRingBuffer(size, overwriteOld) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+SharedRingBuffer::SharedRingBuffer(uint8_t *buffer, const size_t size,
+		bool overwriteOld): SimpleRingBuffer(buffer, size, overwriteOld) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedRingBuffer::writeDataProtected(const uint8_t *data,
+		size_t amount, dur_millis_t timeout) {
+	MutexHelper(mutex, timeout);
+	return writeData(data,amount);
+}
+
+ReturnValue_t SharedRingBuffer::readDataProtected(uint8_t *data, size_t amount,
+		dur_millis_t timeout, bool incrementReadPtr, bool readRemaining,
+		size_t *trueAmount) {
+	MutexHelper(mutex, timeout);
+	return readData(data,amount, incrementReadPtr, readRemaining, trueAmount);
+}
+
+ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
+		bool deleteRemaining, size_t *trueAmount, dur_millis_t timeout) {
+	MutexHelper(mutex, timeout);
+	return deleteData(amount, deleteRemaining, trueAmount);
+}
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
new file mode 100644
index 000000000..411866195
--- /dev/null
+++ b/container/SharedRingBuffer.h
@@ -0,0 +1,42 @@
+#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#include <framework/container/SimpleRingBuffer.h>
+#include <framework/ipc/MutexIF.h>
+#include <framework/timemanager/Clock.h>
+
+class SharedRingBuffer: public SimpleRingBuffer {
+public:
+	/**
+	 * This constructor allocates a new internal buffer with the supplied size.
+	 * @param size
+	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+	 * will be overwritten.
+	 */
+	SharedRingBuffer(const size_t size, bool overwriteOld);
+
+	/**
+	 * This constructor takes an external buffer with the specified size.
+	 * @param buffer
+	 * @param size
+	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+	 * will be overwritten.
+	 */
+	SharedRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld);
+
+	ReturnValue_t writeDataProtected(const uint8_t* data, size_t amount,
+			dur_millis_t timeout = 10);
+	ReturnValue_t readDataProtected(uint8_t *data, size_t amount,
+			dur_millis_t timeout = 10, bool incrementReadPtr = false,
+			bool readRemaining = false, size_t *trueAmount = nullptr);
+	ReturnValue_t deleteDataProtected(size_t amount,
+			bool deleteRemaining = false, size_t* trueAmount = nullptr,
+			dur_millis_t timeout = 10);
+private:
+	MutexIF* mutex = nullptr;
+};
+
+
+
+#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 731c9dc92..69d94143e 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -16,12 +16,14 @@ SimpleRingBuffer::~SimpleRingBuffer() {
 }
 
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
-		uint32_t amount) {
+		size_t amount) {
 	if (availableWriteSpace() >= amount or overwriteOld) {
-		uint32_t amountTillWrap = writeTillWrap();
+		size_t amountTillWrap = writeTillWrap();
 		if (amountTillWrap >= amount) {
+			// remaining size in buffer is sufficient to fit full amount.
 			memcpy(&buffer[write], data, amount);
-		} else {
+		}
+		else {
 			memcpy(&buffer[write], data, amountTillWrap);
 			memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
 		}
@@ -32,12 +34,13 @@ ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
 	}
 }
 
-ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, uint32_t amount,
-		bool readRemaining, uint32_t* trueAmount) {
-	uint32_t availableData = availableReadData(READ_PTR);
-	uint32_t amountTillWrap = readTillWrap(READ_PTR);
+ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
+		bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
+	size_t availableData = availableReadData(READ_PTR);
+	size_t amountTillWrap = readTillWrap(READ_PTR);
 	if (availableData < amount) {
 		if (readRemaining) {
+			// more data available than amount specified.
 			amount = availableData;
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
@@ -52,12 +55,16 @@ ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, uint32_t amount,
 		memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
 		memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
 	}
+
+	if(incrementReadPtr) {
+		deleteData(amount, readRemaining);
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t SimpleRingBuffer::deleteData(uint32_t amount,
-		bool deleteRemaining, uint32_t* trueAmount) {
-	uint32_t availableData = availableReadData(READ_PTR);
+ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
+		bool deleteRemaining, size_t* trueAmount) {
+	size_t availableData = availableReadData(READ_PTR);
 	if (availableData < amount) {
 		if (deleteRemaining) {
 			amount = availableData;
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 30dd184cd..cf78814f7 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -18,6 +18,8 @@ public:
      * This constructor allocates a new internal buffer with the supplied size.
      * @param size
      * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
      */
 	SimpleRingBuffer(const size_t size, bool overwriteOld);
 	/**
@@ -25,41 +27,59 @@ public:
 	 * @param buffer
 	 * @param size
 	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
 	 */
 	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld);
 
 	virtual ~SimpleRingBuffer();
 
 	/**
-	 * Write to circular buffer and increment write pointer by amount
+	 * Write to circular buffer and increment write pointer by amount.
 	 * @param data
 	 * @param amount
-	 * @return
+	 * @return -@c RETURN_OK if write operation was successfull
+	 * -@c RETURN_FAILED if
 	 */
-	ReturnValue_t writeData(const uint8_t* data, uint32_t amount);
+	ReturnValue_t writeData(const uint8_t* data, size_t amount);
 
 	/**
-	 * Read from circular buffer at read pointer
+	 * Read from circular buffer at read pointer.
 	 * @param data
 	 * @param amount
+	 * @param incrementReadPtr
+	 * If this is set to true, the read pointer will be incremented.
+	 * If readRemaining is set to true, the read pointer will be incremented
+	 * accordingly.
 	 * @param readRemaining
-	 * @param trueAmount
+	 * If this is set to true, the data will be read even if the amount
+	 * specified exceeds the read data available.
+	 * @param trueAmount [out]
+	 * If readRemaining was set to true, the true amount read will be assigned
+	 * to the passed value.
 	 * @return
+	 * - @c RETURN_OK if data was read successfully
+	 * - @c RETURN_FAILED if not enough data was available and readRemaining
+	 *      was set to false.
 	 */
-	ReturnValue_t readData(uint8_t* data, uint32_t amount,
-	        bool readRemaining = false, uint32_t* trueAmount = nullptr);
+	ReturnValue_t readData(uint8_t* data, size_t amount,
+			bool incrementReadPtr = false, bool readRemaining = false,
+			size_t* trueAmount = nullptr);
 
 	/**
-	 * Delete data starting by incrementing read pointer
+	 * Delete data by incrementing read pointer.
 	 * @param amount
 	 * @param deleteRemaining
-	 * @param trueAmount
+	 * If the amount specified is larger than the remaing size to read and this
+	 * is set to true, the remaining amount will be deleted as well
+	 * @param trueAmount [out]
+	 * If deleteRemaining was set to true, the amount deleted will be assigned
+	 * to the passed value.
 	 * @return
 	 */
-	ReturnValue_t deleteData(uint32_t amount, bool deleteRemaining = false,
-	        uint32_t* trueAmount = nullptr);
+	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
+	        size_t* trueAmount = nullptr);
 private:
-//	static const uint8_t TEMP_READ_PTR = 1;
 	static const uint8_t READ_PTR = 0;
 	uint8_t* buffer = nullptr;
 };
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 3e5bcc608..9e5019b4d 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -4,15 +4,19 @@
 
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * cookie,
-		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-		object_id_t hkDestination, uint32_t thermalStatePoolId,
-		uint32_t thermalRequestPoolId, uint32_t parent,
+		uint8_t setDeviceSwitch, object_id_t hkDestination,
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		object_id_t parent,
 		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
 		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
-		    hkDestination, setDeviceSwitch,  thermalStatePoolId,
-			thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir),
+			(customFdir == nullptr? &childHandlerFdir : customFdir),
 			cmdQueueSize),
 		parentId(parent), childHandlerFdir(setObjectId) {
+	this->setDeviceSwitch(setDeviceSwitch);
+	this->setHkDestination(hkDestination);
+	this->setThermalStateRequestPoolIds(thermalStatePoolId,
+			thermalRequestPoolId);
+
 }
 
 ChildHandlerBase::~ChildHandlerBase() {
@@ -26,7 +30,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;
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 100216314..5c216e86f 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -7,9 +7,9 @@
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
 	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * cookie, uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
+			CookieIF * cookie, uint8_t setDeviceSwitch,
 			object_id_t hkDestination, uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId, uint32_t parent,
+			uint32_t thermalRequestPoolId, object_id_t parent = objects::NO_OBJECT,
 			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index fcb61acea..08d921302 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -18,43 +18,55 @@
 
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
+object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * comCookie,
-		uint8_t setDeviceSwitch, object_id_t hkDestination,
-		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),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
 		actionHelper(this, nullptr), hkManager(this, nullptr),
-		deviceThermalStatePoolId(thermalStatePoolId),
-		deviceThermalRequestPoolId(thermalRequestPoolId),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
 		switchOffWasReported(false), hkDestination(hkDestination),
 		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
+		transitionSourceSubMode(SUBMODE_NONE) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			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::setHkDestination(object_id_t hkDestination) {
+	this->hkDestination = hkDestination;
+}
+
+void DeviceHandlerBase::setThermalStateRequestPoolIds(
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId) {
+	this->deviceThermalRequestPoolId = thermalStatePoolId;
+	this->deviceThermalRequestPoolId = thermalRequestPoolId;
+}
+
+
+void DeviceHandlerBase::setDeviceSwitch(uint8_t deviceSwitch) {
+	this->deviceSwitch = deviceSwitch;
+}
+
 DeviceHandlerBase::~DeviceHandlerBase() {
 	delete comCookie;
 	if (defaultFDIRUsed) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3fdab9ed4..2adaa80ec 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -106,13 +106,14 @@ public:
 	 * @param cmdQueueSize
 	 */
 	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * comCookie, uint8_t setDeviceSwitch,
-			object_id_t hkDestination = objects::NO_OBJECT,
-			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 setDeviceSwitch(uint8_t deviceSwitch);
+	void setHkDestination(object_id_t hkDestination);
+	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
+			uint32_t thermalRequestPoolId);
+
 	/**
 	 * @brief 	This function is the device handler base core component and is
 	 * 			called periodically.
@@ -691,14 +692,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;
+	uint32_t deviceThermalRequestPoolId = PoolVariableIF::NO_PARAMETER;
 
 	/**
 	 * Optional Error code
@@ -724,7 +725,7 @@ protected:
 
 	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
 	 *
@@ -1082,7 +1083,7 @@ private:
 	 *
 	 * for devices using two switches override getSwitches()
 	 */
-	const uint8_t deviceSwitch;
+	uint8_t deviceSwitch;
 
 	/**
 	 * read the command queue
diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index c8f788722..f4bd765da 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -81,8 +81,7 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 
 	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
 			&& (sourceStream[encodedIndex] != ETX)
-			&& (sourceStream[encodedIndex] != STX))
-	{
+			&& (sourceStream[encodedIndex] != STX)) {
 		if (sourceStream[encodedIndex] == DLE) {
 			nextByte = sourceStream[encodedIndex + 1];
 			// The next byte is a DLE character that was escaped by another
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 121c63df9..65e152bfc 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -9,8 +9,8 @@
 #include <sys/time.h>
 
 //! Don't use these for time points, type is not large enough for UNIX epoch.
-typedef uint32_t dur_millis_t;
-typedef double dur_seconds_t;
+using dur_millis_t = uint32_t;
+using dur_seconds_t = double;
 
 class Clock {
 public:

From ecd740a1015f47d60ec73b48d54f632dc6aa38bd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 15:47:50 +0200
Subject: [PATCH 0555/1774] ring buffer base calls made protected

---
 container/RingBufferBase.h     | 48 ++++++++++++++++++----------------
 container/SharedRingBuffer.cpp | 36 ++++++++++++++++---------
 container/SharedRingBuffer.h   | 28 ++++++++++++++------
 3 files changed, 68 insertions(+), 44 deletions(-)

diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 86896b9ec..f42a42886 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -24,30 +24,20 @@ public:
 		return (availableReadData(n) == 0);
 	}
 
-	uint32_t availableReadData(uint8_t n = 0) const {
+	size_t availableReadData(uint8_t n = 0) const {
 		return ((write + size) - read[n]) % size;
 	}
-	uint32_t availableWriteSpace(uint8_t n = 0) const  {
+	size_t availableWriteSpace(uint8_t n = 0) const  {
 		//One less to avoid ambiguous full/empty problem.
 		return (((read[n] + size) - write - 1) % size);
 	}
 
-	uint32_t getRead(uint8_t n = 0) const {
-		return read[n];
+	bool overwritesOld() const {
+		return overwriteOld;
 	}
 
-	void setRead(uint32_t read, uint8_t n = 0) {
-		if (read >= start && read < (start+size)) {
-			this->read[n] = read;
-		}
-	}
-
-	uint32_t getWrite() const {
-		return write;
-	}
-
-	void setWrite(uint32_t write) {
-		this->write = write;
+	size_t maxSize() const {
+		return size - 1;
 	}
 
 	void clear() {
@@ -69,13 +59,6 @@ public:
 		return start;
 	}
 
-	bool overwritesOld() const {
-		return overwriteOld;
-	}
-
-	size_t maxSize() const {
-		return size - 1;
-	}
 protected:
 	const size_t start;
 	size_t write;
@@ -106,6 +89,25 @@ protected:
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
+
+
+	size_t getRead(uint8_t n = 0) const {
+		return read[n];
+	}
+
+	void setRead(uint32_t read, uint8_t n = 0) {
+		if (read >= start && read < (start+size)) {
+			this->read[n] = read;
+		}
+	}
+
+	uint32_t getWrite() const {
+		return write;
+	}
+
+	void setWrite(uint32_t write) {
+		this->write = write;
+	}
 };
 
 #endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 36315753f..64cbc6691 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -2,31 +2,41 @@
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 
-SharedRingBuffer::SharedRingBuffer(const size_t size, bool overwriteOld):
-		SimpleRingBuffer(size, overwriteOld) {
+SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
+		bool overwriteOld, dur_millis_t mutexTimeout):
+		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld),
+		mutexTimeout(mutexTimeout) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
-SharedRingBuffer::SharedRingBuffer(uint8_t *buffer, const size_t size,
-		bool overwriteOld): SimpleRingBuffer(buffer, size, overwriteOld) {
+SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
+		const size_t size, bool overwriteOld, dur_millis_t mutexTimeout):
+		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld),
+		mutexTimeout(mutexTimeout) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
 ReturnValue_t SharedRingBuffer::writeDataProtected(const uint8_t *data,
-		size_t amount, dur_millis_t timeout) {
-	MutexHelper(mutex, timeout);
-	return writeData(data,amount);
+		size_t amount) {
+	MutexHelper(mutex, mutexTimeout);
+	return SimpleRingBuffer::writeData(data,amount);
 }
 
 ReturnValue_t SharedRingBuffer::readDataProtected(uint8_t *data, size_t amount,
-		dur_millis_t timeout, bool incrementReadPtr, bool readRemaining,
+		bool incrementReadPtr, bool readRemaining,
 		size_t *trueAmount) {
-	MutexHelper(mutex, timeout);
-	return readData(data,amount, incrementReadPtr, readRemaining, trueAmount);
+	MutexHelper(mutex, mutexTimeout);
+	return SimpleRingBuffer::readData(data,amount, incrementReadPtr,
+			readRemaining, trueAmount);
 }
 
 ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
-		bool deleteRemaining, size_t *trueAmount, dur_millis_t timeout) {
-	MutexHelper(mutex, timeout);
-	return deleteData(amount, deleteRemaining, trueAmount);
+		bool deleteRemaining, size_t *trueAmount) {
+	MutexHelper(mutex, mutexTimeout);
+	return SimpleRingBuffer::deleteData(amount, deleteRemaining, trueAmount);
+}
+
+size_t SharedRingBuffer::getAvailableReadDataProtected(uint8_t n) const {
+	MutexHelper(mutex, mutexTimeout);
+	return ((write + size) - read[n]) % size;
 }
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 411866195..e045b72ad 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -2,9 +2,11 @@
 #define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
 #include <framework/container/SimpleRingBuffer.h>
 #include <framework/ipc/MutexIF.h>
+#include <framework/objectmanager/SystemObject.h>
 #include <framework/timemanager/Clock.h>
 
-class SharedRingBuffer: public SimpleRingBuffer {
+class SharedRingBuffer: public SystemObject,
+		public SimpleRingBuffer {
 public:
 	/**
 	 * This constructor allocates a new internal buffer with the supplied size.
@@ -13,7 +15,8 @@ public:
 	 * If the ring buffer is overflowing at a write operartion, the oldest data
 	 * will be overwritten.
 	 */
-	SharedRingBuffer(const size_t size, bool overwriteOld);
+	SharedRingBuffer(object_id_t objectId, const size_t size,
+			bool overwriteOld, dur_millis_t mutexTimeout = 10);
 
 	/**
 	 * This constructor takes an external buffer with the specified size.
@@ -23,17 +26,26 @@ public:
 	 * If the ring buffer is overflowing at a write operartion, the oldest data
 	 * will be overwritten.
 	 */
-	SharedRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld);
+	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
+			bool overwriteOld, dur_millis_t mutexTimeout = 10);
 
-	ReturnValue_t writeDataProtected(const uint8_t* data, size_t amount,
-			dur_millis_t timeout = 10);
+	void setMutexTimeout(dur_millis_t newTimeout);
+
+	/** Performs mutex protected SimpleRingBuffer::writeData call */
+	ReturnValue_t writeDataProtected(const uint8_t* data, size_t amount);
+
+	/** Performs mutex protected SimpleRingBuffer::readData call */
 	ReturnValue_t readDataProtected(uint8_t *data, size_t amount,
-			dur_millis_t timeout = 10, bool incrementReadPtr = false,
+			bool incrementReadPtr = false,
 			bool readRemaining = false, size_t *trueAmount = nullptr);
+
+	/** Performs mutex protected SimpleRingBuffer::deleteData call */
 	ReturnValue_t deleteDataProtected(size_t amount,
-			bool deleteRemaining = false, size_t* trueAmount = nullptr,
-			dur_millis_t timeout = 10);
+			bool deleteRemaining = false, size_t* trueAmount = nullptr);
+
+	size_t getAvailableReadDataProtected (uint8_t n = 0) const;
 private:
+	dur_millis_t mutexTimeout;
 	MutexIF* mutex = nullptr;
 };
 

From 32ef807341f2b868af94a11507db532990a4c771 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 15:49:52 +0200
Subject: [PATCH 0556/1774] newline

---
 container/SharedRingBuffer.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index e045b72ad..f7d3bc3cc 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -1,5 +1,6 @@
 #ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
 #define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+
 #include <framework/container/SimpleRingBuffer.h>
 #include <framework/ipc/MutexIF.h>
 #include <framework/objectmanager/SystemObject.h>

From 5a351474d2de7e2b38c2ccf232f1a9ba6241bf10 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 16:31:33 +0200
Subject: [PATCH 0557/1774] DHB ctor simplified

---
 datapoollocal/LocalDataPoolManager.h |  1 +
 devicehandlers/DeviceHandlerBase.cpp | 12 ++++++++----
 devicehandlers/DeviceHandlerBase.h   |  1 +
 fdir/FailureIsolationBase.cpp        | 11 ++++++++---
 fdir/FailureIsolationBase.h          |  7 +++++--
 tcdistribution/PUSDistributor.cpp    |  2 +-
 6 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 3841b99ce..d5cfb1a3a 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -67,6 +67,7 @@ public:
 	 */
 	ReturnValue_t initialize(MessageQueueIF* queueToUse,
 	        object_id_t hkDestination);
+
 	/**
 	 * This function is used to set the default HK packet destination.
 	 * This destination will usually only be set once.
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 08d921302..48d366b60 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -19,11 +19,11 @@
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::defaultHkDestination = objects::NO_OBJECT;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * comCookie,
-		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),
@@ -31,8 +31,8 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		actionHelper(this, nullptr), hkManager(this, nullptr),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
-		switchOffWasReported(false), hkDestination(hkDestination),
-		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		switchOffWasReported(false), childTransitionDelay(5000),
+		transitionSourceMode(_MODE_POWER_DOWN),
 		transitionSourceSubMode(SUBMODE_NONE) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			MessageQueueMessage::MAX_MESSAGE_SIZE);
@@ -189,6 +189,10 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
+	if(hkDestination == objects::NO_OBJECT) {
+		hkDestination = defaultHkDestination;
+	}
+
 	result = hkManager.initialize(commandQueue, hkDestination);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 2adaa80ec..523496566 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1048,6 +1048,7 @@ private:
 	PowerSwitchIF *powerSwitcher = nullptr;
 
 	/** Cached for initialize() */
+	static object_id_t defaultHkDestination;
 	object_id_t hkDestination = objects::NO_OBJECT;
 
 	/**
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index a2fc9ea18..8bc88002a 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -29,7 +29,7 @@ ReturnValue_t FailureIsolationBase::initialize() {
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if (ownerId != 0) {
+	if (faultTreeParent != objects::NO_OBJECT) {
 		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
@@ -41,10 +41,15 @@ ReturnValue_t FailureIsolationBase::initialize() {
 			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());
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index 894f63562..dea149bd3 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -17,8 +17,11 @@ 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();
 
@@ -26,7 +29,7 @@ public:
 	 * 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:
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 969380d6f..5eb50103a 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -50,7 +50,7 @@ ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
 	if (not returnPair.second) {
 		//TODO Return Code
 		sif::error << "PUSDistributor::registerService: Service ID already"
-				"exists in map." << std::endl;
+				" exists in map." << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	return HasReturnvaluesIF::RETURN_OK;

From a5d3d9ea8030d5f14a7c584641b68a5bf4f21d58 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 16:46:57 +0200
Subject: [PATCH 0558/1774] improved init function

---
 devicehandlers/DeviceHandlerBase.cpp | 38 ++++++++++++++++++----------
 1 file changed, 24 insertions(+), 14 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 48d366b60..b47c58fc5 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -122,8 +122,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);
@@ -132,8 +136,10 @@ 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;
 	}
 
 	if(rawDataReceiverId != objects::NO_OBJECT) {
@@ -152,8 +158,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
-		if (powerSwitcher == NULL) {
-			return RETURN_FAILED;
+		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;
 		}
 	}
 
@@ -189,14 +199,14 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-	if(hkDestination == objects::NO_OBJECT) {
-		hkDestination = defaultHkDestination;
-	}
-
-	result = hkManager.initialize(commandQueue, hkDestination);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+//	if(hkDestination == objects::NO_OBJECT) {
+//		hkDestination = defaultHkDestination;
+//	}
+//
+//	result = hkManager.initialize(commandQueue, hkDestination);
+//	if (result != HasReturnvaluesIF::RETURN_OK) {
+//		return result;
+//	}
 
 	fillCommandAndReplyMap();
 

From da30680d04bffca3ebd17a446fc7cad765a6770f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 16:54:18 +0200
Subject: [PATCH 0559/1774] readability improvement

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index b47c58fc5..4358503ed 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -228,7 +228,7 @@ void DeviceHandlerBase::decrementDeviceReplyMap() {
 		if (iter->second.delayCycles != 0) {
 			iter->second.delayCycles--;
 			if (iter->second.delayCycles == 0) {
-				if (iter->second.periodic != 0) {
+				if (iter->second.periodic) {
 					iter->second.delayCycles = iter->second.maxDelayCycles;
 				}
 				replyToReply(iter, TIMEOUT);

From ceb61979048feb501a31530ac363aaf53c6b5e43 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 17:01:12 +0200
Subject: [PATCH 0560/1774] some minor improvements

---
 devicehandlers/DeviceHandlerBase.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index b60acd524..3c5edf55e 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -386,7 +386,7 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = 0,
+			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
 	/**
@@ -400,7 +400,7 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = 0);
+			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false);
 
 	/**
 	 * @brief 	A simple command to add a command to the commandList.
@@ -426,7 +426,7 @@ protected:
 	 */
 	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
 			uint16_t delayCycles, uint16_t maxDelayCycles,
-			bool periodic = 0);
+			bool periodic = false);
 
 	/**
 	 * @brief   Can be implemented by child handler to
@@ -1214,5 +1214,5 @@ private:
 	            size_t receivedDataLen);
 };
 
-#endif /* DEVICEHANDLERBASE_H_ */
+#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
 

From ad049cc634b1c0aa9b0505bc4de42cb6a89a6679 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 19:41:52 +0200
Subject: [PATCH 0561/1774] tmtc bridge formatting improvements

---
 tmtcservices/TmTcBridge.cpp | 27 +++++++++++++++------------
 tmtcservices/TmTcBridge.h   | 11 +++++++----
 2 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 8c44f7de0..b55803cbc 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -24,8 +24,9 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 		return RETURN_OK;
 	}
 	else {
-	    sif::warning << "TmTcBridge: Number of packets sent per cycle "
-	               "exceeds limits. Keeping default value." << std::endl;
+	    sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of "
+	             << "packets sent per cycle exceeds limits. "
+	             << "Keeping default value." << std::endl;
 		return RETURN_FAILED;
 	}
 }
@@ -37,8 +38,9 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
         return RETURN_OK;
     }
     else {
-        sif::warning << "TmTcBridge: Number of packets stored "
-                   "exceeds limits. Keeping default value." << std::endl;
+        sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of "
+                << "packets stored exceeds limits. "
+                << "Keeping default value." << std::endl;
         return RETURN_FAILED;
     }
 }
@@ -72,11 +74,13 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 	ReturnValue_t result;
 	result = handleTc();
 	if(result != RETURN_OK) {
-		sif::error << "TMTC Bridge: Error handling TCs" << std::endl;
+		sif::debug << "TmTcBridge::performOperation: "
+		        << "Error handling TCs" << std::endl;
 	}
 	result = handleTm();
 	if (result != RETURN_OK) {
-		sif::error << "TMTC Bridge: Error handling TMs" << std::endl;
+	    sif::debug << "TmTcBridge::performOperation: "
+	                    << "Error handling TMs" << std::endl;
 	}
 	return result;
 }
@@ -88,7 +92,7 @@ ReturnValue_t TmTcBridge::handleTc() {
 ReturnValue_t TmTcBridge::handleTm() {
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
-		sif::error << "TMTC Bridge: Reading TM Queue failed" << std::endl;
+		sif::warning << "TmTcBridge: Reading TM Queue failed" << std::endl;
 		return RETURN_FAILED;
 	}
 
@@ -118,7 +122,7 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 
 		result = sendTm(data, size);
 		if (result != RETURN_OK) {
-			sif::error << "TMTC Bridge: Could not send TM packet"<< std::endl;
+			sif::warning << "TmTcBridge: Could not send TM packet" << std::endl;
 			tmStore->deleteData(message.getStorageId());
 			return result;
 
@@ -129,13 +133,12 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 }
 
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
-	//debug << "TMTC Bridge: Comm Link down. "
-	//		 "Saving packet ID to be sent later\r\n" << std::flush;
 	store_address_t storeId = 0;
 
 	if(tmFifo.full()) {
-		sif::error << "TMTC Bridge: TM downlink max. number of stored packet IDs "
-				 "reached! Overwriting old data" << std::endl;
+		sif::error << "TmTcBridge::storeDownlinkData: TM downlink max. number "
+		        << "of stored packet IDs reached! "
+		        << "Overwriting old data" << std::endl;
 		tmFifo.retrieve(&storeId);
 		tmStore->deleteData(storeId);
 	}
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 3e3d1b714..993cd5b99 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -76,13 +76,14 @@ protected:
 	object_id_t tcDestination = objects::NO_OBJECT;
 
 	//! Used to send and receive TMTC messages.
-	//! TmTcMessage is used to transport messages between tasks.
+	//! The TmTcMessage class is used to transport messages between tasks.
 	MessageQueueIF* tmTcReceptionQueue = nullptr;
 
 	StorageManagerIF* tmStore = nullptr;
 	StorageManagerIF* tcStore = nullptr;
 
-	//! Used to specify whether communication link is up by default.
+	//! Used to specify whether communication link is up. Will be true
+	//! by default, so telemetry will be handled immediately.
 	bool communicationLinkUp = true;
 	bool tmStored = false;
 
@@ -103,7 +104,8 @@ protected:
 	virtual ReturnValue_t handleTm();
 
 	/**
-	 * Read the TM Queue and send TM if necessary. Default implementation provided
+	 * Read the TM Queue and send TM if necessary.
+	 * Default implementation provided
 	 * @return
 	 */
 	virtual ReturnValue_t handleTmQueue();
@@ -116,7 +118,8 @@ protected:
 
 	/**
 	 * Implemented by child class. Perform sending of Telemetry by implementing
-	 * communication drivers or wrappers, e.g. UART communication or lwIP stack.
+	 * communication drivers or wrappers, e.g. serial communication or a socket
+	 * call.
 	 * @param data
 	 * @param dataLen
 	 * @return

From 57418eb877888bed655eb8f3fee2d58b6f4cbe82 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 20:04:49 +0200
Subject: [PATCH 0562/1774] distrinction between default settings

and individual settings for service
---
 devicehandlers/DeviceHandlerBase.h     |  1 +
 tmtcservices/CommandingServiceBase.cpp | 12 ++++++++++--
 tmtcservices/CommandingServiceBase.h   |  6 ++++--
 3 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3c5edf55e..61fb701d5 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1048,6 +1048,7 @@ private:
 
 	/** Cached for initialize() */
 	static object_id_t defaultHkDestination;
+	/** HK destination can also be set individually */
 	object_id_t hkDestination = objects::NO_OBJECT;
 
 	/**
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 63a3d9435..4c9b5375c 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -8,8 +8,8 @@
 #include <framework/tmtcpacket/pus/TcPacketStored.h>
 #include <framework/tmtcpacket/pus/TmPacketStored.h>
 
-object_id_t CommandingServiceBase::packetSource = objects::NO_OBJECT;
-object_id_t CommandingServiceBase::packetDestination = objects::NO_OBJECT;
+object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
 
 CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
 		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
@@ -62,10 +62,18 @@ ReturnValue_t CommandingServiceBase::initialize() {
 		return result;
 	}
 
+	if(packetDestination == objects::NO_OBJECT) {
+	    packetDestination = defaultPacketDestination;
+	}
 	AcceptsTelemetryIF* packetForwarding =
 			objectManager->get<AcceptsTelemetryIF>(packetDestination);
+
+	if(packetSource == objects::NO_OBJECT) {
+	    packetSource = defaultPacketSource;
+	}
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
+
 	if (packetForwarding == nullptr or distributor == nullptr) {
 	    sif::error << "CommandingServiceBase::intialize: Packet source or "
 	            "packet destination invalid!" << std::endl;
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index e9b5f0471..ec38bdee4 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -248,8 +248,10 @@ protected:
 	uint32_t failureParameter1 = 0;
 	uint32_t failureParameter2 = 0;
 
-	static object_id_t packetSource;
-	static object_id_t packetDestination;
+	static object_id_t defaultPacketSource;
+	object_id_t packetSource = objects::NO_OBJECT;
+	static object_id_t defaultPacketDestination;
+	object_id_t packetDestination = objects::NO_OBJECT;
 
 	/**
 	 * Pointer to the task which executes this component,

From cdd877032fe211cd6e9e56940352f608b7e90efb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 23:20:48 +0200
Subject: [PATCH 0563/1774] doc for system object IF improved

---
 objectmanager/SystemObjectIF.h | 56 ++++++++++++++++------------------
 1 file changed, 27 insertions(+), 29 deletions(-)

diff --git a/objectmanager/SystemObjectIF.h b/objectmanager/SystemObjectIF.h
index 7540f80fb..b75905094 100644
--- a/objectmanager/SystemObjectIF.h
+++ b/objectmanager/SystemObjectIF.h
@@ -1,26 +1,19 @@
-/**
- * @file	SystemObjectIF.h
- * @brief	This file contains the definition of the SystemObjectIF interface.
- * @date	18.09.2012
- * @author	Bastian Baetz
- */
-
-#ifndef SYSTEMOBJECTIF_H_
-#define SYSTEMOBJECTIF_H_
+#ifndef FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+#define FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
 
 #include <framework/events/EventReportingProxyIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <stdint.h>
+#include <cstdint>
 /**
- * \defgroup system_objects Software System Object Management
- * The classes to create System Objects and classes to manage these are contained in this group.
- * System Objects are software elements that can be controlled externally. They all have a unique
- * object identifier.
+ * @defgroup system_objects Software System Object Management
+ * The classes to create System Objects and classes to manage these are
+ * contained in this group. System Objects are software elements that can be
+ * controlled externally. They all have a unique object identifier.
  */
 
 /**
  * This is the typedef for object identifiers.
- * \ingroup system_objects
+ * @ingroup system_objects
  */
 typedef uint32_t object_id_t;
 
@@ -29,7 +22,8 @@ typedef uint32_t object_id_t;
  * list.
  * It does not provide any method definitions, still it is required to
  * perform a type check with dynamic_cast.
- * \ingroup system_objects
+ * @author  Bastian Baetz
+ * @ingroup system_objects
  */
 class SystemObjectIF : public EventReportingProxyIF {
 public:
@@ -41,24 +35,28 @@ public:
 	/**
 	 * The empty virtual destructor as required for C++ interfaces.
 	 */
-	virtual ~SystemObjectIF() {
-	}
+	virtual ~SystemObjectIF() {}
 	/**
-	 * Initializes all inter-object dependencies.
-	 * This is necessary to avoid circular dependencies of not-fully
-	 * initialized objects on start up.
-	 * @return	- \c RETURN_OK in case the initialization was successful
-	 * 			- \c RETURN_FAILED otherwise
+	 * @brief   Initializes the object.
+	 * There are initialization steps which can also be done in the constructor.
+	 * However, there is no clean way to get a returnvalue from a constructor.
+	 * Furthermore some components require other system object to be created
+	 * which might not have been built yet.
+	 * Therefore, a two-step initialization resolves this problem and prevents
+	 * circular dependencies of not-fully initialized objects on start up.
+	 * @return	- @c RETURN_OK in case the initialization was successful
+	 * 			- @c RETURN_FAILED otherwise
 	 */
 	virtual ReturnValue_t initialize() = 0;
 	/**
-	 * Checks, if all object-object interconnections are satisfying for operation.
-	 * Some objects need certain other objects (or a certain number), to be registered as children.
-	 * These checks can be done in this method.
-	 * @return	- \c RETURN_OK in case the check was successful
-	 * 			- \c any other code otherwise
+	 * @brief   Checks if all object-object interconnections are satisfying
+	 *          for operation.
+	 * Some objects need certain other objects (or a certain number), to be
+	 * registered as children. These checks can be done in this method.
+	 * @return	- @c RETURN_OK in case the check was successful
+	 * 			- @c any other code otherwise
 	 */
 	virtual ReturnValue_t checkObjectConnections() = 0;
 };
 
-#endif /* SYSTEMOBJECTIF_H_ */
+#endif /* FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */

From 1fde3c2c992f3fd96cd0098bfb23c5ab6fa51589 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 00:19:25 +0200
Subject: [PATCH 0564/1774] added srv200, CSB doc

---
 pus/CService200ModeCommanding.cpp      | 133 +++++++++++++++++++++++++
 pus/CService200ModeCommanding.h        |  85 ++++++++++++++++
 pus/servicepackets/Service200Packets.h |  56 +++++++++++
 tmtcpacket/pus/TmPacketStored.cpp      |   1 +
 tmtcservices/CommandingServiceBase.h   |  23 +++--
 5 files changed, 290 insertions(+), 8 deletions(-)
 create mode 100644 pus/CService200ModeCommanding.cpp
 create mode 100644 pus/CService200ModeCommanding.h
 create mode 100644 pus/servicepackets/Service200Packets.h

diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
new file mode 100644
index 000000000..753ec38b6
--- /dev/null
+++ b/pus/CService200ModeCommanding.cpp
@@ -0,0 +1,133 @@
+#include <framework/pus/CService200ModeCommanding.h>
+#include <framework/pus/servicepackets/Service200Packets.h>
+
+#include <framework/modes/HasModesIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/modes/ModeMessage.h>
+
+CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId):
+        CommandingServiceBase(objectId, apid, serviceId,
+	    NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {}
+
+CService200ModeCommanding::~CService200ModeCommanding() {}
+
+ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
+	switch(subservice) {
+	case(Subservice::COMMAND_MODE_COMMAND):
+	case(Subservice::COMMAND_MODE_READ):
+	case(Subservice::COMMAND_MODE_ANNCOUNCE):
+		return RETURN_OK;
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+
+ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject(
+		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+		MessageQueueId_t *id, object_id_t *objectId)
+{
+	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = checkInterfaceAndAcquireMessageQueue(id,objectId);
+	return result;
+}
+
+ReturnValue_t CService200ModeCommanding::checkAndAcquireTargetID(
+		object_id_t* objectIdToSet, const uint8_t* tcData, uint32_t tcDataLen) {
+	size_t size = tcDataLen;
+	if (SerializeAdapter::deSerialize(objectIdToSet, &tcData, &size,
+	        SerializeIF::Endianness::BIG)
+			!= HasReturnvaluesIF::RETURN_OK)
+		return CommandingServiceBase::INVALID_TC;
+	else
+		return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t* MessageQueueToSet, object_id_t* objectId) {
+	HasModesIF * possibleTarget = objectManager->get<HasModesIF>(*objectId);
+	if(possibleTarget!=NULL){
+		*MessageQueueToSet = possibleTarget->getCommandQueue();
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+}
+
+
+ReturnValue_t CService200ModeCommanding::prepareCommand(
+		CommandMessage* message,uint8_t subservice, const uint8_t *tcData,
+		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
+	ModePacket modeCommandPacket;
+	ReturnValue_t result = modeCommandPacket.deSerialize(&tcData,
+			&tcDataLen, SerializeIF::Endianness::BIG);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	else {
+		ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
+				ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
+				modeCommandPacket.getSubmode());
+		return result;
+	}
+}
+
+
+ReturnValue_t CService200ModeCommanding::handleReply(
+		const CommandMessage* reply, Command_t previousCommand,
+		uint32_t *state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool *isStep) {
+	Command_t replyId = reply->getCommand();
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	switch(replyId) {
+	case(ModeMessage::REPLY_MODE_REPLY): {
+		result = prepareModeReply(reply, objectId);
+		break;
+	}
+	case(ModeMessage::REPLY_WRONG_MODE_REPLY): {
+		result = prepareWrongModeReply(reply, objectId);
+		break;
+	}
+	case(ModeMessage::REPLY_CANT_REACH_MODE): {
+		result = prepareCantReachModeReply(reply, objectId);
+		break;
+	}
+	case(ModeMessage::REPLY_MODE_INFO):
+		result = INVALID_REPLY;
+		break;
+	default:
+		result = RETURN_FAILED;
+	}
+	return result;
+}
+
+ReturnValue_t CService200ModeCommanding::prepareModeReply(
+		const CommandMessage *reply, object_id_t objectId) {
+	ModePacket modeReplyPacket(objectId,
+			ModeMessage::getMode(reply),
+			ModeMessage::getSubmode(reply));
+	return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket);
+}
+
+ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(
+		const CommandMessage *reply, object_id_t objectId) {
+	ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply),
+			ModeMessage::getSubmode(reply));
+	return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
+}
+
+ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
+		const CommandMessage *reply, object_id_t objectId) {
+	CantReachModePacket cantReachModePacket(objectId,
+	        ModeMessage::getCantReachModeReason(reply));
+	return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
+	        &cantReachModePacket);
+}
+
+
+
diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h
new file mode 100644
index 000000000..ede61a84e
--- /dev/null
+++ b/pus/CService200ModeCommanding.h
@@ -0,0 +1,85 @@
+#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
+#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
+
+#include <framework/tmtcservices/CommandingServiceBase.h>
+
+/**
+ * @brief Custom PUS service to set mode of all objects implementing HasModesIF
+ *
+ * Examples: Device Handlers, Assemblies or Subsystems.
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * @ingroup pus_services
+ */
+class CService200ModeCommanding: public CommandingServiceBase {
+public:
+	static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
+	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+
+	CService200ModeCommanding(object_id_t objectId,
+	        uint16_t apid, uint8_t serviceId);
+	virtual~ CService200ModeCommanding();
+
+protected:
+	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) override;
+
+private:
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+			const uint8_t* tcData, uint32_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
+
+	ReturnValue_t prepareModeReply(const CommandMessage *reply,
+			object_id_t objectId);
+	ReturnValue_t prepareWrongModeReply(const CommandMessage *reply,
+			object_id_t objectId);
+	ReturnValue_t prepareCantReachModeReply(const CommandMessage *reply,
+			object_id_t objectId);
+
+	enum Subservice { //!< [EXPORT] : [COMMENT] Mode Commanding Subservices
+		//!< [EXPORT] : [COMMAND] Command assembly, subsystem or device mode
+		COMMAND_MODE_COMMAND = 1,
+		//!< [EXPORT] : [COMMAND] Command to set the specified Mode,
+		//! regardless of external control flag
+		COMMAND_MODE_COMMAND_FORCED = 2,
+		//!< [EXPORT] : [COMMAND] Read the current mode and
+		//! reply with a REPLY_MODE_REPLY
+		COMMAND_MODE_READ = 3,
+		//!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event.
+		//! This command does NOT have a reply
+		COMMAND_MODE_ANNCOUNCE = 4,
+		//!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this
+		//! command to every child. This command does NOT have a reply.
+		COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5,
+		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
+		REPLY_MODE_REPLY = 6,
+		//!< [EXPORT] : [REPLY] Reply in case a mode command can't be executed.
+		REPLY_CANT_REACH_MODE = 7,
+		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND, indicating that a
+		//! mode was commanded and a transition started but was aborted,
+		//! the parameters contain the mode that was reached
+		REPLY_WRONG_MODE_REPLY = 8
+	};
+
+	enum modeParameters {
+		MODE_OFF = 0,
+		MODE_ON = 1,
+		MODE_NORMAL = 2,
+		MODE_RAW = 3
+	};
+};
+
+#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */
diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h
new file mode 100644
index 000000000..fb153e21a
--- /dev/null
+++ b/pus/servicepackets/Service200Packets.h
@@ -0,0 +1,56 @@
+#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/modes/ModeMessage.h>
+#include <framework/serialize/SerializeIF.h>
+
+/**
+ * @brief Subservice 1, 2, 3, 4, 5
+ * @ingroup spacepackets
+ */
+class ModePacket : public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6
+public:
+	ModePacket() {
+		setLinks();
+	}
+
+	ModePacket(object_id_t objectId, Mode_t mode, Submode_t submode) :
+	        objectId(objectId), mode(mode), submode(submode) {
+		setLinks();
+	}
+
+	Mode_t getMode() {
+		return mode.entry;
+	}
+
+	Submode_t getSubmode() {
+		return submode.entry;
+	}
+
+private:
+	// Forbid copying because of next pointer to member
+	ModePacket(const ModePacket &command);
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&mode);
+		mode.setNext(&submode);
+	}
+	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Target or source object
+	SerializeElement<Mode_t> mode; //!< [EXPORT] : [COMMENT] 0: MODE_OFF, 1: MODE_ON, 2: MODE_NORMAL, 3: MODE_RAW
+	SerializeElement<Submode_t> submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible
+};
+
+class CantReachModePacket: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 7
+public:
+    CantReachModePacket(object_id_t objectId, ReturnValue_t reason):
+            objectId(objectId), reason(reason) {
+        setStart(&this->objectId);
+        this->objectId.setNext(&this->reason);
+    }
+
+    SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Reply source object
+	SerializeElement<ReturnValue_t> reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached
+};
+
+#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index d6a4a69fb..6eb852f05 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -34,6 +34,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
 }
 
+// todo: Endianness flags as optional parameter?
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
 		SerializeIF *header) :
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index ec38bdee4..1bd18571e 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -114,16 +114,17 @@ public:
 	 * Implementation of ExecutableObjectIF function
 	 *
 	 * Used to setup the reference of the task, that executes this component
-	 * @param task_ Pointer to the taskIF of this task
+	 * @param task Pointer to the taskIF of this task
 	 */
-	virtual void setTaskIF(PeriodicTaskIF* task_);
+	virtual void setTaskIF(PeriodicTaskIF* task);
 
 protected:
 	/**
 	 * Check the target subservice
 	 * @param subservice[in]
-	 * @return -@c RETURN_OK on success
-     *         -@c INVALID_SUBSERVICE if service is not known
+	 * @return
+	 * -@c RETURN_OK Subservice valid, continue message handling
+     * -@c INVALID_SUBSERVICE if service is not known, rejects packet.
 	 */
 	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
 
@@ -136,9 +137,10 @@ protected:
 	 * @param tcDataLen
 	 * @param id MessageQueue ID is stored here
 	 * @param objectId Object ID is extracted and stored here
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED
-	 *         - @c CSB or implementation specific return codes
+	 * @return
+	 * - @c RETURN_OK Cotinue message handling
+	 * - @c RETURN_FAILED Reject the packet and generates a start failure
+	 *      verification
 	 */
 	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
 			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
@@ -157,6 +159,11 @@ protected:
 	 * communication
 	 * @param objectId Target object ID
 	 * @return
+	 * - @c RETURN_OK to generate a verification start message
+	 * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
+	 *      verification message.
+	 * - @c Anything else rejects the packets and generates a start failure
+	 *      verification.
 	 */
 	virtual ReturnValue_t prepareCommand(CommandMessage* message,
 			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
@@ -181,7 +188,7 @@ protected:
 	 * @return
 	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
 	 *   generate TC verification success
-	 * - @c INVALID_REPLY calls handleUnrequestedReply
+	 * - @c INVALID_REPLY Calls handleUnrequestedReply
 	 * - Anything else triggers a TC verification failure. If RETURN_FAILED
 	 *   is returned and the command ID is CommandMessage::REPLY_REJECTED,
 	 *   a failure verification message with the reason as the error parameter

From 7a4cc1a6b692b39c596bb88e67051af69b97f928 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 01:22:23 +0200
Subject: [PATCH 0565/1774] hk manager initialized now

---
 devicehandlers/DeviceHandlerBase.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4358503ed..c696e4e3e 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -199,14 +199,14 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-//	if(hkDestination == objects::NO_OBJECT) {
-//		hkDestination = defaultHkDestination;
-//	}
-//
-//	result = hkManager.initialize(commandQueue, hkDestination);
-//	if (result != HasReturnvaluesIF::RETURN_OK) {
-//		return result;
-//	}
+	if(hkDestination == objects::NO_OBJECT) {
+		hkDestination = defaultHkDestination;
+	}
+
+	result = hkManager.initialize(commandQueue, hkDestination);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
 
 	fillCommandAndReplyMap();
 

From f3739fd213acd0849399fa4b755ffa7a126da6ab Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 02:44:58 +0200
Subject: [PATCH 0566/1774] bugfix failure isolation base

---
 fdir/FailureIsolationBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index 8bc88002a..083f5af08 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -29,7 +29,7 @@ ReturnValue_t FailureIsolationBase::initialize() {
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if (faultTreeParent != objects::NO_OBJECT) {
+	if (ownerId != objects::NO_OBJECT) {
 		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;

From 3551a767a71635c47af18df4b5afbc393416838e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 03:06:18 +0200
Subject: [PATCH 0567/1774] removed old code

---
 devicehandlers/DeviceHandlerBase.cpp | 17 +----------------
 1 file changed, 1 insertion(+), 16 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index c696e4e3e..06fb84cc8 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -348,7 +348,7 @@ void DeviceHandlerBase::doStateMachine() {
 
 		if(powerSwitcher == nullptr) {
 		    setMode(MODE_OFF);
-		    return;
+		    break;
 		}
 
 		if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
@@ -832,21 +832,6 @@ MessageQueueId_t DeviceHandlerBase::getCommandQueue() const {
 	return commandQueue->getId();
 }
 
-//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,

From bdc6e881986e9048eac100561ac0e0159b1b0eca Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 03:09:32 +0200
Subject: [PATCH 0568/1774] reordered includes

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 06fb84cc8..af98ba44f 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,10 +1,10 @@
-#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/devicehandlers/DeviceHandlerBase.h>
 #include <framework/objectmanager/ObjectManager.h>
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
 
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/devicehandlers/DeviceTmReportingWrapper.h>
 #include <framework/globalfunctions/CRC.h>

From 9cbc1a18b8c305c095f1c70ada691541e1df6bd1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 03:16:08 +0200
Subject: [PATCH 0569/1774] csrv200 improvements

---
 pus/CService200ModeCommanding.cpp | 56 ++++++++++++-------------------
 storagemanager/StorageAccessor.h  |  5 +++
 2 files changed, 26 insertions(+), 35 deletions(-)

diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index 753ec38b6..fd6da67e9 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -27,36 +27,26 @@ ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
 
 ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject(
 		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-		MessageQueueId_t *id, object_id_t *objectId)
-{
-	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = checkInterfaceAndAcquireMessageQueue(id,objectId);
-	return result;
-}
+		MessageQueueId_t *id, object_id_t *objectId) {
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG);
 
-ReturnValue_t CService200ModeCommanding::checkAndAcquireTargetID(
-		object_id_t* objectIdToSet, const uint8_t* tcData, uint32_t tcDataLen) {
-	size_t size = tcDataLen;
-	if (SerializeAdapter::deSerialize(objectIdToSet, &tcData, &size,
-	        SerializeIF::Endianness::BIG)
-			!= HasReturnvaluesIF::RETURN_OK)
-		return CommandingServiceBase::INVALID_TC;
-	else
-		return HasReturnvaluesIF::RETURN_OK;
+	return checkInterfaceAndAcquireMessageQueue(id,objectId);
 }
 
 ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
-		MessageQueueId_t* MessageQueueToSet, object_id_t* objectId) {
-	HasModesIF * possibleTarget = objectManager->get<HasModesIF>(*objectId);
-	if(possibleTarget!=NULL){
-		*MessageQueueToSet = possibleTarget->getCommandQueue();
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return CommandingServiceBase::INVALID_OBJECT;
-	}
+        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+    HasModesIF * destination = objectManager->get<HasModesIF>(*objectId);
+    if(destination == nullptr) {
+        return CommandingServiceBase::INVALID_OBJECT;
+
+    }
+
+    *messageQueueToSet = destination->getCommandQueue();
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 
@@ -69,12 +59,11 @@ ReturnValue_t CService200ModeCommanding::prepareCommand(
 	if (result != RETURN_OK) {
 		return result;
 	}
-	else {
-		ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
-				ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
-				modeCommandPacket.getSubmode());
-		return result;
-	}
+
+	ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
+	        ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
+	        modeCommandPacket.getSubmode());
+	return result;
 }
 
 
@@ -128,6 +117,3 @@ ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
 	return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
 	        &cantReachModePacket);
 }
-
-
-
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index c5e383065..4b3f1ea99 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -25,8 +25,13 @@ public:
 	 * @param
 	 * @return
 	 */
+<<<<<<< Updated upstream
 	StorageAccessor& operator= (StorageAccessor&&);
 	StorageAccessor (StorageAccessor&&);
+=======
+	StorageAccessor& operator=(StorageAccessor&&);
+	StorageAccessor(StorageAccessor&&);
+>>>>>>> Stashed changes
 
 	ReturnValue_t write(uint8_t *data, size_t size,
 		uint16_t offset = 0);

From be8913efeaada850906e19f2d40b6e503b7ec270 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 03:30:52 +0200
Subject: [PATCH 0570/1774] srv8 improvements

---
 pus/Service5EventReporting.cpp     |  3 +--
 pus/Service8FunctionManagement.cpp | 42 +++++++++++++++++-------------
 pus/Service8FunctionManagement.h   |  3 +++
 storagemanager/StorageAccessor.h   | 12 +++------
 4 files changed, 32 insertions(+), 28 deletions(-)

diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index fe55059c2..1dfbe2293 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -59,8 +59,7 @@ ReturnValue_t Service5EventReporting::generateEventReport(
 }
 
 ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
-	switch(subservice)
-	{
+	switch(subservice) {
 	case Subservice::ENABLE: {
 		enableEventReport = true;
 		return HasReturnvaluesIF::RETURN_OK;
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 243384645..812398b94 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -1,7 +1,6 @@
 #include <framework/pus/Service8FunctionManagement.h>
 #include <framework/pus/servicepackets/Service8Packets.h>
 
-#include <framework/action/ActionMessage.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/action/HasActionsIF.h>
 #include <framework/devicehandlers/DeviceHandlerIF.h>
@@ -54,12 +53,8 @@ ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue(
 ReturnValue_t Service8FunctionManagement::prepareCommand(
 		CommandMessage* message, uint8_t subservice, const uint8_t* tcData,
 		size_t tcDataLen, uint32_t* state, object_id_t objectId) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	if(subservice == static_cast<uint8_t>(Subservice::DIRECT_COMMANDING)) {
-		result = prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
+	return prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
 				tcData, tcDataLen);
-	}
-	return result;
 }
 
 ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
@@ -100,18 +95,7 @@ ReturnValue_t Service8FunctionManagement::handleReply(
 		break;
 	}
 	case ActionMessage::DATA_REPLY: {
-		store_address_t storeId = ActionMessage::getStoreId(reply);
-		size_t size = 0;
-		const uint8_t * buffer = nullptr;
-		result = IPCStore->getData(storeId, &buffer, &size);
-		if(result != RETURN_OK) {
-			sif::error << "Service 8: Could not retrieve data for data reply";
-			return result;
-		}
-		DataReply dataReply(objectId,actionId,buffer,size);
-		sendTmPacket(static_cast<uint8_t>(
-				Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
-		result = IPCStore ->deleteData(storeId);
+	    result = handleDataReply(reply, objectId, actionId);
 		break;
 	}
 	case ActionMessage::STEP_FAILED:
@@ -126,4 +110,26 @@ ReturnValue_t Service8FunctionManagement::handleReply(
 	return result;
 }
 
+ReturnValue_t Service8FunctionManagement::handleDataReply(
+        const CommandMessage* reply, object_id_t objectId,
+        ActionId_t actionId) {
+    store_address_t storeId = ActionMessage::getStoreId(reply);
+    size_t size = 0;
+    const uint8_t * buffer = nullptr;
+    ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
+    if(result != RETURN_OK) {
+        sif::error << "Service 8: Could not retrieve data for data reply"
+                << std::endl;
+        return result;
+    }
+    DataReply dataReply(objectId, actionId, buffer, size);
+    result = sendTmPacket(static_cast<uint8_t>(
+            Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
 
+    auto deletionResult = IPCStore->deleteData(storeId);
+    if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "Service8FunctionManagement::handleReply: Deletion"
+                << " of data in pool failed." << std::endl;
+    }
+    return result;
+}
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index 54c98b97c..e2c7a84f6 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 #define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 
+#include <framework/action/ActionMessage.h>
 #include <framework/tmtcservices/CommandingServiceBase.h>
 
 /**
@@ -59,6 +60,8 @@ private:
 	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
 	ReturnValue_t prepareDirectCommand(CommandMessage* message,
 			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t handleDataReply(const CommandMessage* reply,
+	        object_id_t objectId, ActionId_t actionId);
 };
 
 #endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 4b3f1ea99..d75e06ac8 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -17,21 +17,17 @@ class StorageAccessor: public ConstStorageAccessor {
 public:
 	StorageAccessor(store_address_t storeId);
 	StorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
 	/**
 	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * 			 move-constructors-and-move-assignment-operators-cpp.md
+	 * 			a returnvalue. They prevent resource being freed prematurely.
+	 * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * 		move-constructors-and-move-assignment-operators-cpp.md
 	 * @param
 	 * @return
 	 */
-<<<<<<< Updated upstream
-	StorageAccessor& operator= (StorageAccessor&&);
-	StorageAccessor (StorageAccessor&&);
-=======
 	StorageAccessor& operator=(StorageAccessor&&);
 	StorageAccessor(StorageAccessor&&);
->>>>>>> Stashed changes
 
 	ReturnValue_t write(uint8_t *data, size_t size,
 		uint16_t offset = 0);

From a7d68f8c52886f39d116a9ad0553f26463c753b8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 13:31:45 +0200
Subject: [PATCH 0571/1774] deleted copy ctor

---
 pus/servicepackets/Service200Packets.h | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h
index fb153e21a..1b5bf236f 100644
--- a/pus/servicepackets/Service200Packets.h
+++ b/pus/servicepackets/Service200Packets.h
@@ -11,6 +11,7 @@
  */
 class ModePacket : public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6
 public:
+
 	ModePacket() {
 		setLinks();
 	}
@@ -28,9 +29,11 @@ public:
 		return submode.entry;
 	}
 
+	// Forbid copying, pointers are used.
+	ModePacket(const ModePacket&) = delete;
+	ModePacket& operator=(const ModePacket&) = delete;
 private:
-	// Forbid copying because of next pointer to member
-	ModePacket(const ModePacket &command);
+
 	void setLinks() {
 		setStart(&objectId);
 		objectId.setNext(&mode);
@@ -41,6 +44,10 @@ private:
 	SerializeElement<Submode_t> submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible
 };
 
+/**
+ * @brief Subservice 7
+ * @ingroup spacepackets
+ */
 class CantReachModePacket: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 7
 public:
     CantReachModePacket(object_id_t objectId, ReturnValue_t reason):

From e29226c9bba6587460d5db87e3ad3b3d7eab2357 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 14:28:36 +0200
Subject: [PATCH 0572/1774] srv8 improved

---
 pus/Service8FunctionManagement.cpp   |  9 +++++-
 pus/servicepackets/Service8Packets.h | 41 ++++++++++++++--------------
 2 files changed, 29 insertions(+), 21 deletions(-)

diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 812398b94..50102b04c 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -59,8 +59,15 @@ ReturnValue_t Service8FunctionManagement::prepareCommand(
 
 ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
 		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
+    if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
+        sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
+                << " TC size smaller thant minimum size of direct command."
+                << std::endl;
+        return CommandingServiceBase::INVALID_TC;
+    }
+
 	// Create direct command instance by extracting data from Telecommand
-	DirectCommand command(tcData,tcDataLen);
+	DirectCommand command(tcData, tcDataLen);
 
 	// store additional parameters into the IPC Store
 	store_address_t parameterAddress;
diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
index 5ef912806..86681c142 100644
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@@ -8,10 +8,7 @@
  *   3. Return Code
  *   4. Optional step number for step replies
  *
- * Data reply (subservice 132) consists of
- *   1. Target Object ID
- *   2. Action ID
- *   3. Data
+
  *
  *  \date 01.07.2019
  *  \author R. Mueller
@@ -29,23 +26,21 @@
 
 
 /**
- * \brief Subservice 128
- * \ingroup spacepackets
+ * @brief Subservice 128
+ * @ingroup spacepackets
  */
 class DirectCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
 public:
-	//typedef uint16_t typeOfMaxData;
-	//static const typeOfMaxData MAX_DATA = 256;
-	DirectCommand(const uint8_t* dataBuffer_, uint32_t size_) {
-		size_t size = sizeof(objectId);
-		SerializeAdapter::deSerialize(&objectId,&dataBuffer_,&size,
+
+	DirectCommand(const uint8_t* tcData, size_t size) {
+		SerializeAdapter::deSerialize(&objectId, &tcData, &size,
 		        SerializeIF::Endianness::BIG);
-		size = sizeof(actionId);
-		SerializeAdapter::deSerialize(&actionId,&dataBuffer_,&size,
+		SerializeAdapter::deSerialize(&actionId, &tcData, &size,
 		        SerializeIF::Endianness::BIG);
-		parameterBuffer = dataBuffer_;
-		parametersSize = size_ - sizeof(objectId) - sizeof(actionId);
+		parameterBuffer = tcData;
+		parametersSize = size;
 	}
+
 	ActionId_t getActionId() const {
 		return actionId;
 	}
@@ -73,8 +68,12 @@ private:
 
 
 /**
- * \brief Subservice 130
- * \ingroup spacepackets
+ * @brief Subservice 130
+ * Data reply (subservice 130) consists of
+ *   1. Target Object ID
+ *   2. Action ID
+ *   3. Data
+ * @ingroup spacepackets
  */
 class DataReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 130
 public:
@@ -100,8 +99,10 @@ private:
 
 
 /**
- * \brief Subservice 132
- * \ingroup spacepackets
+ * @brief Subservice 132
+ * @details
+ * Not used yet. Telecommand Verification takes care of this.
+ * @ingroup spacepackets
  */
 class DirectReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 132
 public:
@@ -124,7 +125,7 @@ private:
 			returnCode.setNext(&step);
 		}
 	}
-	bool isDataReply; //!< [EXPORT] : [IGNORE]
+
 	bool isStep; //!< [EXPORT] : [IGNORE]
 	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [IGNORE]
 	SerializeElement<ActionId_t> actionId; //!< [EXPORT] : [IGNORE]

From 36a7f2f9ee86b00370bee48721f470d9392bf93c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 14:32:25 +0200
Subject: [PATCH 0573/1774] removed file header comment

---
 pus/servicepackets/Service8Packets.h | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
index 86681c142..8ea0d1086 100644
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@@ -1,19 +1,3 @@
-/**
- * \file Service8Packets.h
- *
- * \brief Structure of a Direct Command.
- * Normal reply (subservice 130) consists of
- *   1. Target object ID
- *   2. Action ID (taget device has specified functions with action IDs)
- *   3. Return Code
- *   4. Optional step number for step replies
- *
-
- *
- *  \date 01.07.2019
- *  \author R. Mueller
- */
-
 #ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 #define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 

From 31450362106ebec643d99dd60d963e822516b0a5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 19:34:18 +0200
Subject: [PATCH 0574/1774] getter functions for task handle

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 3 +++
 osal/FreeRTOS/FixedTimeslotTask.h   | 2 ++
 osal/FreeRTOS/PeriodicTask.cpp      | 4 ++++
 osal/FreeRTOS/PeriodicTask.h        | 2 ++
 osal/FreeRTOS/TaskManagement.cpp    | 5 +++--
 osal/FreeRTOS/TaskManagement.h      | 3 ++-
 6 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 57c927f98..3bd2aafb7 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -157,3 +157,6 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+TaskHandle_t FixedTimeslotTask::getTaskHandle() const {
+    return handle;
+}
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 27d081909..985b4f90f 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -57,6 +57,8 @@ public:
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
 
+	TaskHandle_t getTaskHandle() const;
+
 protected:
 	bool started;
 	TaskHandle_t handle;
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 2ebfebf40..6d013a5b7 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -126,6 +126,10 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
     }
 }
 
+TaskHandle_t PeriodicTask::getTaskHandle() const {
+    return handle;
+}
+
 void PeriodicTask::handleMissedDeadline() {
 #ifdef DEBUG
     sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 09aa6bc7d..679686f64 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -69,6 +69,8 @@ public:
 	uint32_t getPeriodMs() const override;
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
+
+	TaskHandle_t getTaskHandle() const;
 protected:
 	bool started;
 	TaskHandle_t handle;
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 7871ab2ec..9a1e44472 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -18,6 +18,7 @@ TaskHandle_t TaskManagement::getCurrentTaskHandle() {
 	return xTaskGetCurrentTaskHandle();
 }
 
-configSTACK_DEPTH_TYPE TaskManagement::getTaskStackHighWatermark() {
-	return uxTaskGetStackHighWaterMark(TaskManagement::getCurrentTaskHandle());
+configSTACK_DEPTH_TYPE TaskManagement::getTaskStackHighWatermark(
+        TaskHandle_t task) {
+	return uxTaskGetStackHighWaterMark(task);
 }
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 39c24377b..cbde510cd 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -57,7 +57,8 @@ public:
 	 * @return Smallest value of stack remaining since the task was started in
 	 * 		   words.
 	 */
-	static configSTACK_DEPTH_TYPE getTaskStackHighWatermark();
+	static configSTACK_DEPTH_TYPE getTaskStackHighWatermark(
+	        TaskHandle_t task = nullptr);
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */

From 444ee80f356a8e6b8e639c1cb847da320a21713b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 20:31:10 +0200
Subject: [PATCH 0575/1774] removed unnecessary case and added more size checks

---
 pus/Service2DeviceAccess.cpp |  6 ++----
 tmtcservices/PusParser.cpp   | 29 ++++++++++++++---------------
 2 files changed, 16 insertions(+), 19 deletions(-)

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 1d5f21eba..84d6693d3 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -60,13 +60,11 @@ ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
 		uint32_t* state, object_id_t objectId) {
 	switch(static_cast<Subservice>(subservice)){
 	case Subservice::RAW_COMMANDING: {
-		return prepareRawCommand(dynamic_cast<CommandMessage*>(message),
-				tcData, tcDataLen);
+		return prepareRawCommand(message, tcData, tcDataLen);
 	}
 	break;
 	case Subservice::TOGGLE_WIRETAPPING: {
-		return prepareWiretappingCommand(dynamic_cast<CommandMessage*>(message),
-				tcData, tcDataLen);
+		return prepareWiretappingCommand(message, tcData, tcDataLen);
 	}
 	break;
 	default:
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index 4198e36ea..3dd34a84b 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -7,9 +7,8 @@ PusParser::PusParser(uint16_t maxExpectedPusPackets,
 
 ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 		size_t frameSize) {
-	if(frame == nullptr) {
-		sif::error << "PusParser::parsePusPackets: Frame pointers in invalid!"
-				<< std::endl;
+	if(frame == nullptr or frameSize < 5) {
+		sif::error << "PusParser::parsePusPackets: Frame invalid!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -25,15 +24,13 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 	}
 
 	size_t packetSize = lengthField + 7;
+	// sif::debug << frameSize << std::endl;
 	// Size of a pus packet is the value in the packet length field plus 7.
-	if(packetSize > frameSize)
-	{
-		if(storeSplitPackets)
-		{
+	if(packetSize > frameSize) {
+		if(storeSplitPackets) {
 			indexSizePairFIFO.insert(indexSizePair(0, frameSize));
 		}
-		else
-		{
+		else {
 			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
 					"larger than remaining frame," << std::endl;
 			sif::debug << "Throwing away packet. Detected packet size: "
@@ -41,8 +38,7 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 		}
 		return SPLIT_PACKET;
 	}
-	else
-	{
+	else {
 		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
 		if(packetSize == frameSize) {
 			return HasReturnvaluesIF::RETURN_OK;
@@ -77,6 +73,11 @@ PusParser::indexSizePair PusParser::getNextFifoPair() {
 ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
 		size_t frameSize, size_t& currentIndex) {
 	// sif::debug << startIndex << std::endl;
+    if(currentIndex + 5 > frameSize) {
+        currentIndex = frameSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
 	uint16_t lengthField = frame[currentIndex + 4] << 8 |
 			frame[currentIndex + 5];
 	if(lengthField == 0) {
@@ -88,12 +89,10 @@ ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
 	size_t remainingSize = frameSize - currentIndex;
 	if(nextPacketSize > remainingSize)
 	{
-		if(storeSplitPackets)
-		{
+		if(storeSplitPackets) {
 			indexSizePairFIFO.insert(indexSizePair(currentIndex, remainingSize));
 		}
-		else
-		{
+		else {
 			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
 					"larger than remaining frame," << std::endl;
 			sif::debug << "Throwing away packet. Detected packet size: "

From 6a6395313f8dce6ec9693acddb6b93d3cda9549a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 11 Jul 2020 01:06:01 +0200
Subject: [PATCH 0576/1774] added copy ctor and assignment for FIFObase

---
 container/DynamicFIFO.h |  2 +-
 container/FIFOBase.h    | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 3a5242c7e..fca4c8e81 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -18,7 +18,7 @@ template<typename T>
 class DynamicFIFO: public FIFOBase<T> {
 public:
 	DynamicFIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
-			values(maxCapacity) {};
+			values(maxCapacity)  {};
 
 private:
 	std::vector<T> values;
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index 8bdb333f8..082c596aa 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -3,6 +3,7 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
+#include <cstring>
 
 template <typename T>
 class FIFOBase {
@@ -43,6 +44,23 @@ public:
 	bool full();
 	size_t size();
 
+	FIFOBase(const FIFOBase& other): readIndex(other.readIndex),
+			writeIndex(other.writeIndex), currentSize(other.currentSize),
+			maxCapacity(other.maxCapacity) {
+		std::memcpy(values, other.values, sizeof(T) * currentSize);
+	}
+
+	FIFOBase& operator=(const FIFOBase& other) {
+		if(&other == this)
+			return *this;
+		maxCapacity = other.maxCapacity;
+		readIndex = other.readIndex;
+		writeIndex = other.writeIndex;
+		currentSize = other.currentSize;
+		std::memcpy(values, other.values, sizeof(T) * currentSize);
+		return *this;
+	}
+
 	size_t getMaxCapacity() const;
 
 private:

From 35d4267b400a950847447d2adc24e53096e4ef86 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 11 Jul 2020 02:36:04 +0200
Subject: [PATCH 0577/1774] dynamic fifo bug fixed

---
 container/DynamicFIFO.h  | 21 ++++++++++++++++++---
 container/FIFO.h         | 12 ++++++++++--
 container/FIFOBase.h     | 22 ++++------------------
 container/FIFOBase.tpp   |  8 +++++++-
 tmtcservices/PusParser.h |  9 +++++----
 5 files changed, 44 insertions(+), 28 deletions(-)

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index fca4c8e81..59adfb3ad 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -17,11 +17,26 @@
 template<typename T>
 class DynamicFIFO: public FIFOBase<T> {
 public:
-	DynamicFIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
-			values(maxCapacity)  {};
+	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->setData(fifoVector.data());
+	};
+
+	/**
+	 * @brief	Custom copy constructor which prevents setting the
+	 * 	        underlying pointer wrong.
+	 */
+	DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
+			fifoVector(other.maxCapacity) {
+		this->setData(fifoVector.data());
+	}
+
 
 private:
-	std::vector<T> values;
+	std::vector<T> fifoVector;
 };
 
 #endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index ecb218fda..2e332dc2e 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -17,10 +17,18 @@
 template<typename T, size_t capacity>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(): FIFOBase<T>(values.data(), capacity) {};
+	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
+
+	/**
+	 * @brief 	Custom copy constructor to set pointer correctly.
+	 * @param other
+	 */
+	FIFO(const FIFO& other): FIFOBase<T>(other) {
+		this->setData(fifoArray.data());
+	}
 
 private:
-	std::array<T, capacity> values;
+	std::array<T, capacity> fifoArray;
 };
 
 #endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index 082c596aa..7f8bde962 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -44,29 +44,15 @@ public:
 	bool full();
 	size_t size();
 
-	FIFOBase(const FIFOBase& other): readIndex(other.readIndex),
-			writeIndex(other.writeIndex), currentSize(other.currentSize),
-			maxCapacity(other.maxCapacity) {
-		std::memcpy(values, other.values, sizeof(T) * currentSize);
-	}
-
-	FIFOBase& operator=(const FIFOBase& other) {
-		if(&other == this)
-			return *this;
-		maxCapacity = other.maxCapacity;
-		readIndex = other.readIndex;
-		writeIndex = other.writeIndex;
-		currentSize = other.currentSize;
-		std::memcpy(values, other.values, sizeof(T) * currentSize);
-		return *this;
-	}
 
 	size_t getMaxCapacity() const;
 
-private:
-	T* values;
+protected:
+	void setData(T* data);
 	size_t maxCapacity = 0;
 
+	T* values;
+
 	size_t readIndex = 0;
 	size_t writeIndex = 0;
 	size_t currentSize = 0;
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index 48a060ff3..c73e9d590 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -7,7 +7,7 @@
 
 template<typename T>
 inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
-		values(values), maxCapacity(maxCapacity) {};
+		maxCapacity(maxCapacity), values(values){};
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::insert(T value) {
@@ -78,4 +78,10 @@ inline size_t FIFOBase<T>::getMaxCapacity() const {
 	return maxCapacity;
 }
 
+
+template<typename T>
+inline void FIFOBase<T>::setData(T *data) {
+	this->values = data;
+}
+
 #endif
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
index 88570bb29..d59673f68 100644
--- a/tmtcservices/PusParser.h
+++ b/tmtcservices/PusParser.h
@@ -63,11 +63,12 @@ public:
 	 * @return
 	 */
 	indexSizePair getNextFifoPair();
-private:
 
-	//! A FIFO is used to store information about multiple PUS packets
-	//! inside the receive buffer. The maximum number of entries is defined
-	//! by the first constructor argument.
+private:
+	/** A FIFO is used to store information about multiple PUS packets
+	 * inside the receive buffer. The maximum number of entries is defined
+	 * by the first constructor argument.
+	 */
 	DynamicFIFO<indexSizePair> indexSizePairFIFO;
 
 	bool storeSplitPackets = false;

From 69946d5276549dce7624540df1de75c94ffc5004 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 11 Jul 2020 11:52:01 +0200
Subject: [PATCH 0578/1774] FIFO hotfix

---
 container/DynamicFIFO.h | 21 ++++++++++++++++++---
 container/FIFO.h        | 12 ++++++++++--
 container/FIFOBase.h    |  8 ++++++--
 container/FIFOBase.tpp  |  8 +++++++-
 4 files changed, 41 insertions(+), 8 deletions(-)

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 3a5242c7e..59adfb3ad 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -17,11 +17,26 @@
 template<typename T>
 class DynamicFIFO: public FIFOBase<T> {
 public:
-	DynamicFIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
-			values(maxCapacity) {};
+	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->setData(fifoVector.data());
+	};
+
+	/**
+	 * @brief	Custom copy constructor which prevents setting the
+	 * 	        underlying pointer wrong.
+	 */
+	DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
+			fifoVector(other.maxCapacity) {
+		this->setData(fifoVector.data());
+	}
+
 
 private:
-	std::vector<T> values;
+	std::vector<T> fifoVector;
 };
 
 #endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index ecb218fda..2e332dc2e 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -17,10 +17,18 @@
 template<typename T, size_t capacity>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(): FIFOBase<T>(values.data(), capacity) {};
+	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
+
+	/**
+	 * @brief 	Custom copy constructor to set pointer correctly.
+	 * @param other
+	 */
+	FIFO(const FIFO& other): FIFOBase<T>(other) {
+		this->setData(fifoArray.data());
+	}
 
 private:
-	std::array<T, capacity> values;
+	std::array<T, capacity> fifoArray;
 };
 
 #endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index 8bdb333f8..7f8bde962 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -3,6 +3,7 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
+#include <cstring>
 
 template <typename T>
 class FIFOBase {
@@ -43,12 +44,15 @@ public:
 	bool full();
 	size_t size();
 
+
 	size_t getMaxCapacity() const;
 
-private:
-	T* values;
+protected:
+	void setData(T* data);
 	size_t maxCapacity = 0;
 
+	T* values;
+
 	size_t readIndex = 0;
 	size_t writeIndex = 0;
 	size_t currentSize = 0;
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index 48a060ff3..c73e9d590 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -7,7 +7,7 @@
 
 template<typename T>
 inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
-		values(values), maxCapacity(maxCapacity) {};
+		maxCapacity(maxCapacity), values(values){};
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::insert(T value) {
@@ -78,4 +78,10 @@ inline size_t FIFOBase<T>::getMaxCapacity() const {
 	return maxCapacity;
 }
 
+
+template<typename T>
+inline void FIFOBase<T>::setData(T *data) {
+	this->values = data;
+}
+
 #endif

From e4f795d209f36bbfaa39a1d03e46c759d4a86acd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 11 Jul 2020 13:38:14 +0200
Subject: [PATCH 0579/1774] stack high watermark in bytes now

---
 osal/FreeRTOS/TaskManagement.cpp | 4 ++--
 osal/FreeRTOS/TaskManagement.h   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 9a1e44472..704f9d34e 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -18,7 +18,7 @@ TaskHandle_t TaskManagement::getCurrentTaskHandle() {
 	return xTaskGetCurrentTaskHandle();
 }
 
-configSTACK_DEPTH_TYPE TaskManagement::getTaskStackHighWatermark(
+size_t TaskManagement::getTaskStackHighWatermark(
         TaskHandle_t task) {
-	return uxTaskGetStackHighWaterMark(task);
+	return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
 }
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index cbde510cd..ea3633596 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -57,7 +57,7 @@ public:
 	 * @return Smallest value of stack remaining since the task was started in
 	 * 		   words.
 	 */
-	static configSTACK_DEPTH_TYPE getTaskStackHighWatermark(
+	static size_t getTaskStackHighWatermark(
 	        TaskHandle_t task = nullptr);
 };
 

From 799846d89fecc4c17dc6305d17b903217b0687ba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 11 Jul 2020 14:29:30 +0200
Subject: [PATCH 0580/1774] little formatting changes

---
 action/HasActionsIF.h |  2 +-
 events/Event.h        | 11 ++++++-----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 9c2a9c01d..008d9eaf8 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -35,7 +35,7 @@
 class HasActionsIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
-	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);//!<
+	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
 	static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
 	static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
diff --git a/events/Event.h b/events/Event.h
index 96800f34c..0a1cfcf2a 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -1,10 +1,10 @@
-#ifndef EVENTOBJECT_EVENT_H_
-#define EVENTOBJECT_EVENT_H_
+#ifndef FRAMEWORK_EVENTS_EVENT_H_
+#define FRAMEWORK_EVENTS_EVENT_H_
 
-#include <stdint.h>
+#include <cstdint>
 #include <framework/events/fwSubsystemIdRanges.h>
 //could be move to more suitable location
-#include <config/tmtc/subsystemIdRanges.h>
+#include <subsystemIdRanges.h>
 
 typedef uint16_t EventId_t;
 typedef uint8_t EventSeverity_t;
@@ -21,6 +21,7 @@ EventSeverity_t getSeverity(Event event);
 Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
 
 }
+
 namespace SEVERITY {
 	static const EventSeverity_t INFO = 1;
 	static const EventSeverity_t LOW = 2;
@@ -41,4 +42,4 @@ namespace SEVERITY {
 //	static const EventSeverity_t HIGH = 4;
 //};
 
-#endif /* EVENTOBJECT_EVENT_H_ */
+#endif /* FRAMEWORK_EVENTS_EVENT_H_ */

From 7d794c76235c8247602b6327034f604d962b71c5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 11 Jul 2020 18:24:09 +0200
Subject: [PATCH 0581/1774] task management functions have freertos syntax now

---
 osal/FreeRTOS/TaskManagement.cpp | 6 +++---
 osal/FreeRTOS/TaskManagement.h   | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 704f9d34e..ff552adbb 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,6 +1,6 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
-void TaskManagement::requestContextSwitchFromTask() {
+void TaskManagement::vRequestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
 
@@ -8,9 +8,9 @@ void TaskManagement::requestContextSwitch(
 		CallContext callContext = CallContext::TASK) {
 	if(callContext == CallContext::ISR) {
 		// This function depends on the partmacro.h definition for the specific device
-		requestContextSwitchFromISR();
+		vRequestContextSwitchFromISR();
 	} else {
-		requestContextSwitchFromTask();
+		vRequestContextSwitchFromTask();
 	}
 }
 
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index ea3633596..0ae8a6e9f 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -13,7 +13,7 @@ extern "C" {
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
  */
-extern "C" void requestContextSwitchFromISR();
+extern "C" void vRequestContextSwitchFromISR();
 
 /*!
  * Used by functions to tell if they are being called from
@@ -41,7 +41,7 @@ public:
 	 * If task preemption in FreeRTOS is disabled, a context switch
 	 * can be requested manually by calling this function.
 	 */
-	static void requestContextSwitchFromTask(void);
+	static void vRequestContextSwitchFromTask(void);
 
 	/**
 	 * @return The current task handle

From 99aef0cf287fcdf23f9336927c171762e8bf4f7c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 12 Jul 2020 01:16:32 +0200
Subject: [PATCH 0582/1774] C++ linkage for yield from ISR function

---
 osal/FreeRTOS/TaskManagement.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 0ae8a6e9f..62c68331a 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -13,7 +13,7 @@ extern "C" {
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
  */
-extern "C" void vRequestContextSwitchFromISR();
+extern void vRequestContextSwitchFromISR();
 
 /*!
  * Used by functions to tell if they are being called from

From b4f292f3d7fc4f606bf1b6d48618bd0cf1878e26 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 12 Jul 2020 18:01:09 +0200
Subject: [PATCH 0583/1774] new generic freertos task interface

---
 osal/FreeRTOS/FixedTimeslotTask.cpp |  2 +-
 osal/FreeRTOS/FixedTimeslotTask.h   |  5 +++--
 osal/FreeRTOS/FreeRTOSTaskIF.h      | 13 +++++++++++++
 osal/FreeRTOS/PeriodicTask.cpp      |  2 +-
 osal/FreeRTOS/PeriodicTask.h        |  6 ++++--
 returnvalues/HasReturnvaluesIF.h    | 10 +++++++++-
 6 files changed, 31 insertions(+), 7 deletions(-)
 create mode 100644 osal/FreeRTOS/FreeRTOSTaskIF.h

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 3bd2aafb7..630952d29 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -157,6 +157,6 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-TaskHandle_t FixedTimeslotTask::getTaskHandle() const {
+TaskHandle_t FixedTimeslotTask::getTaskHandle() {
     return handle;
 }
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 985b4f90f..b63cb7750 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 #define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 
+#include <framework/osal/FreeRTOS/FreeRTOSTaskIF.h>
 #include <framework/tasks/FixedSlotSequence.h>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include <framework/tasks/Typedef.h>
@@ -8,7 +9,7 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
-class FixedTimeslotTask: public FixedTimeslotTaskIF {
+class FixedTimeslotTask: public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
 public:
 
 	/**
@@ -57,7 +58,7 @@ public:
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
 
-	TaskHandle_t getTaskHandle() const;
+	TaskHandle_t getTaskHandle() override;
 
 protected:
 	bool started;
diff --git a/osal/FreeRTOS/FreeRTOSTaskIF.h b/osal/FreeRTOS/FreeRTOSTaskIF.h
new file mode 100644
index 000000000..06fda2828
--- /dev/null
+++ b/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_ */
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 6d013a5b7..f960d8bbc 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -126,7 +126,7 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
     }
 }
 
-TaskHandle_t PeriodicTask::getTaskHandle() const {
+TaskHandle_t PeriodicTask::getTaskHandle() {
     return handle;
 }
 
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 679686f64..ca2c53240 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -1,10 +1,12 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
 #define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
 
+#include <framework/osal/FreeRTOS/FreeRTOSTaskIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/tasks/PeriodicTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
+
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
@@ -17,7 +19,7 @@ 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()!
@@ -70,7 +72,7 @@ public:
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
 
-	TaskHandle_t getTaskHandle() const;
+	TaskHandle_t getTaskHandle() override;
 protected:
 	bool started;
 	TaskHandle_t handle;
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index d231f4ee9..9b9086d99 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -15,7 +15,15 @@ public:
 	static const ReturnValue_t RETURN_FAILED = 1;
 	virtual ~HasReturnvaluesIF() {}
 
-	static ReturnValue_t makeReturnCode(uint8_t interfaceId, uint8_t number) {
+	/**
+	 * It is discouraged to use the input parameters 0,0 and 0,1 as this
+	 * will generate the RETURN_OK and RETURN_FAILED returnvalues.
+	 * @param interfaceId
+	 * @param number
+	 * @return
+	 */
+	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
+			uint8_t number) {
 	    return (interfaceId << 8) + number;
 	}
 };

From 6d99ab3df3e105901cf6af955a034968b7f8364d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Jul 2020 19:37:33 +0200
Subject: [PATCH 0584/1774] ncreased readability of DHB function

---
 devicehandlers/DeviceHandlerBase.cpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index af98ba44f..cc97cd420 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1264,18 +1264,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;
 	}

From 15052cb33304f18d3e5ce95a4b547a2ff0826c99 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Jul 2020 19:54:38 +0200
Subject: [PATCH 0585/1774] singly linked list update

---
 container/SinglyLinkedList.h | 61 ++++++++++++++++++++++++------------
 1 file changed, 41 insertions(+), 20 deletions(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 85a92e6a1..7d5fc4a9d 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -16,13 +16,8 @@ public:
 	class Iterator {
 	public:
 		LinkedElement<T> *value = nullptr;
-		//! Creates an uninitialized iterator which points to nullptr.
 		Iterator() {}
 
-		/**
-		 * Initialize iterator at specified linked element.
-		 * @param element
-		 */
 		Iterator(LinkedElement<T> *element) :
 				value(element) {
 		}
@@ -77,11 +72,6 @@ private:
 	LinkedElement *next;
 };
 
-/**
- * @brief 	SinglyLinkedList data structure which keeps a pointer to its
- * 			first element to perform all operations.
- * @tparam T
- */
 template<typename T>
 class SinglyLinkedList {
 public:
@@ -99,12 +89,21 @@ public:
 		return ElementIterator::Iterator(start);
 	}
 
+	/** Returns iterator to nulltr */
 	ElementIterator end() const {
-		LinkedElement<T> *element = start;
-		while (element != nullptr) {
-			element = element->getNext();
-		}
-		return ElementIterator::Iterator(element);
+		return ElementIterator::Iterator();
+	}
+
+	/**
+	 * Returns last element in singly linked list.
+	 * @return
+	 */
+	ElementIterator back() const {
+	    LinkedElement<T> *element = start;
+	    while (element != nullptr) {
+	        element = element->getNext();
+	    }
+	    return ElementIterator::Iterator(element);
 	}
 
 	size_t getSize() const {
@@ -116,15 +115,37 @@ public:
 		}
 		return size;
 	}
-	void setStart(LinkedElement<T>* setStart) {
-		start = setStart;
+	void setStart(LinkedElement<T>* firstElement) {
+		start = firstElement;
 	}
 
-    void setEnd(LinkedElement<T>* setEnd) {
-        setEnd->setEnd();
+	void setNext(LinkedElement<T>* currentElement,
+	        LinkedElement<T>* nextElement) {
+	    currentElement->setNext(nextElement);
+	}
+
+    void setLast(LinkedElement<T>* lastElement) {
+        lastElement->setEnd();
     }
 
-    // SHOULDDO: Insertion operation ?
+    void insertElement(LinkedElement<T>* element, size_t position) {
+        LinkedElement<T> *currentElement = start;
+        for(size_t count = 0; count < position; count++) {
+            if(currentElement == nullptr) {
+                return;
+            }
+            currentElement = currentElement->getNext();
+        }
+        LinkedElement<T>* elementAfterCurrent = currentElement->next;
+        currentElement->setNext(element);
+        if(elementAfterCurrent != nullptr) {
+            element->setNext(elementAfterCurrent);
+        }
+    }
+
+    void insertBack(LinkedElement<T>* lastElement) {
+        back().value->setNext(lastElement);
+    }
 
 protected:
 	LinkedElement<T> *start = nullptr;

From e7b6999c5ea11e776848cb63a11f1e9673af0efa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Jul 2020 22:13:19 +0200
Subject: [PATCH 0586/1774] added back inttypes.h for cleaner code

---
 timemanager/CCSDSTime.cpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 47cab911d..71b2539df 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -205,9 +205,10 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	uint8_t hour;
 	uint8_t minute;
 	float second;
-	//try Code A (yyyy-mm-dd)
-	int count = sscanf((char *) from, "%4hi-%2hhi-%2hiT%2hhi:%2hhi:%fZ", &year,
-				&month, &day, &hour, &minute, &second);
+    //try Code A (yyyy-mm-dd)
+    int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16
+            "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year, &month, &day,
+            &hour, &minute, &second);
 	if (count == 6) {
 		to->year = year;
 		to->month = month;
@@ -219,9 +220,9 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		return RETURN_OK;
 	}
 
-	//try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4hi-%3hiT%2hhi:%2hhi:%fZ", &year, &day,
-			&hour, &minute, &second);
+    //try Code B (yyyy-ddd)
+    count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu8
+            ":%2" SCNu8 ":%fZ", &year, &day, &hour, &minute, &second);
 	if (count == 5) {
 		uint8_t tempDay;
 		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,

From e204bd77c6cf4ac9a4229ed434674a43d72a94c3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Jul 2020 02:21:11 +0200
Subject: [PATCH 0587/1774] created tpp file for fixed ordered multimap

---
 container/FixedOrderedMultimap.h   | 242 ++++++++++++++---------------
 container/FixedOrderedMultimap.tpp |  83 ++++++++++
 2 files changed, 199 insertions(+), 126 deletions(-)
 create mode 100644 container/FixedOrderedMultimap.tpp

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 3dd20a749..9a04becf2 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -4,8 +4,18 @@
 #include <framework/container/ArrayList.h>
 #include <cstring>
 #include <set>
+
 /**
- * \ingroup container
+ * @brief   Map implementation which allows entries with identical keys
+ * @details
+ * Performs no dynamic memory allocation except on initialization.
+ * Uses an ArrayList as the underlying container and thus has a linear
+ * complexity O(n). As long as the number of entries remains low, this
+ * should not be an issue.
+ * The number of insertion and deletion operation should be minimized
+ * as those incur exensive memory move operations (the underlying container
+ * is not node based).
+ * @ingroup container
  */
 template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
 class FixedOrderedMultimap {
@@ -15,11 +25,113 @@ public:
 	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
 	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
 
+	/**
+	 * Initializes the ordered multimap with a fixed maximum size.
+	 * @param maxSize
+	 */
+    FixedOrderedMultimap(size_t maxSize);
+
+    virtual ~FixedOrderedMultimap() {}
+
+    class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
+    public:
+        /** Returns an iterator to nullptr */
+        Iterator();
+        /** Initializes iterator to given entry */
+        Iterator(std::pair<key_t, T> *pair);
+        /** Dereference operator can be used to get value */
+        T operator*();
+        /** Arrow operator can be used to get pointer to value */
+        T *operator->();
+    };
+
+    /** Iterator to start of map */
+    Iterator begin() const;
+    /** Iterator to end of map */
+    Iterator end() const;
+    /** Current (variable) size of the map */
+    size_t size() const;
+
+    /**
+     * Insert a key/value pair inside the map. An iterator to the stored
+     * value might be returned optionally.
+     * @param key
+     * @param value
+     * @param storedValue
+     * @return
+     */
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
+    /**
+     * Insert a given std::pair<key, value>
+     * @param pair
+     * @return
+     */
+    ReturnValue_t insert(std::pair<key_t, T> pair);
+    /**
+     * Checks existence of key in map.
+     * @param key
+     * @return
+     * - @c KEY_DOES_NOT_EXIST if key does not exists.
+     * - @c RETURN_OK otherwise.
+     */
+    ReturnValue_t exists(key_t key) const;
+
+    ReturnValue_t erase(Iterator *iter) {
+        uint32_t i;
+        if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+            return KEY_DOES_NOT_EXIST;
+        }
+        removeFromPosition(i);
+        if (*iter != begin()) {
+            (*iter)--;
+        } else {
+            *iter = begin();
+        }
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    ReturnValue_t erase(key_t key) {
+        uint32_t i;
+        if ((i = findFirstIndex(key)) >= _size) {
+            return KEY_DOES_NOT_EXIST;
+        }
+        do {
+            removeFromPosition(i);
+            i = findFirstIndex(key, i);
+        } while (i < _size);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    Iterator find(key_t key) const {
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return end();
+        }
+        return Iterator(&theMap[findFirstIndex(key)]);
+    }
+
+    ReturnValue_t find(key_t key, T **value) const {
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        *value = &theMap[findFirstIndex(key)].second;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    void clear() {
+        _size = 0;
+    }
+
+    size_t maxSize() const {
+        return theMap.maxSize();
+    }
+
 private:
 	typedef KEY_COMPARE compare;
 	compare myComp;
 	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
+	size_t _size;
 
 	uint32_t findFirstIndex(key_t key, uint32_t startAt = 0) const {
 		if (startAt >= _size) {
@@ -52,130 +164,8 @@ private:
 				(_size - position - 1) * sizeof(std::pair<key_t,T>));
 		--_size;
 	}
-public:
-	FixedOrderedMultimap(uint32_t maxSize) :
-			theMap(maxSize), _size(0) {
-	}
-	virtual ~FixedOrderedMultimap() {
-	}
-
-	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-	public:
-		Iterator() :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
-		}
-
-		Iterator(std::pair<key_t, T> *pair) :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
-		}
-
-		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 {
-		return Iterator(&theMap[0]);
-	}
-
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
-
-	uint32_t size() const {
-		return _size;
-	}
-
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
-		if (_size == theMap.maxSize()) {
-			return MAP_FULL;
-		}
-		uint32_t position = findNicePlace(key);
-		memmove(&theMap[position + 1], &theMap[position],
-				(_size - position) * sizeof(std::pair<key_t,T>));
-		theMap[position].first = key;
-		theMap[position].second = value;
-		++_size;
-		if (storedValue != NULL) {
-			*storedValue = Iterator(&theMap[position]);
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.fist, pair.second);
-	}
-
-	ReturnValue_t exists(key_t key) const {
-		ReturnValue_t result = KEY_DOES_NOT_EXIST;
-		if (findFirstIndex(key) < _size) {
-			result = HasReturnvaluesIF::RETURN_OK;
-		}
-		return result;
-	}
-
-	ReturnValue_t erase(Iterator *iter) {
-		uint32_t i;
-		if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		removeFromPosition(i);
-		if (*iter != begin()) {
-			(*iter)--;
-		} else {
-			*iter = begin();
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t erase(key_t key) {
-		uint32_t i;
-		if ((i = findFirstIndex(key)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		do {
-			removeFromPosition(i);
-			i = findFirstIndex(key, i);
-		} while (i < _size);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	//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) {
-			return end();
-		}
-		return Iterator(&theMap[findFirstIndex(key)]);
-	}
-
-	ReturnValue_t find(key_t key, T **value) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		*value = &theMap[findFirstIndex(key)].second;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	void clear() {
-		_size = 0;
-	}
-
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
-
 };
 
+#include <framework/container/FixedOrderedMultimap.tpp>
+
 #endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
new file mode 100644
index 000000000..74edbf9ae
--- /dev/null
+++ b/container/FixedOrderedMultimap.tpp
@@ -0,0 +1,83 @@
+#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
+#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator():
+        ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(){}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator(
+        std::pair<key_t, T> *pair):
+        ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair){}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline T FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::operator*() {
+    return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
+FixedOrderedMultimap<key_t, T, KEY_COMPARE>::begin() const {
+    return Iterator(&theMap[0]);
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
+FixedOrderedMultimap<key_t, T, KEY_COMPARE>::end() const {
+    return Iterator(&theMap[_size]);
+}
+
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::size() const {
+    return _size;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline T* FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::operator->() {
+    return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::FixedOrderedMultimap(
+        size_t maxSize): theMap(maxSize), _size(0) {}
+
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(
+        key_t key, T value, Iterator *storedValue) {
+    if (_size == theMap.maxSize()) {
+        return MAP_FULL;
+    }
+    uint32_t position = findNicePlace(key);
+    // Compiler might emitt warning because std::pair is not a POD type (yet..)
+    // See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm#std::pair-example
+    // Should still work without issues.
+    std::memmove(&theMap[position + 1], &theMap[position],
+            (_size - position) * sizeof(std::pair<key_t,T>));
+    theMap[position].first = key;
+    theMap[position].second = value;
+    ++_size;
+    if (storedValue != nullptr) {
+        *storedValue = Iterator(&theMap[position]);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(
+        std::pair<key_t, T> pair) {
+    return insert(pair.fist, pair.second);
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(
+        key_t key) const {
+    ReturnValue_t result = KEY_DOES_NOT_EXIST;
+    if (findFirstIndex(key) < _size) {
+        result = HasReturnvaluesIF::RETURN_OK;
+    }
+    return result;
+}
+
+#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */

From e5ab7ada682fb80db4daa3ba7b4f5f20b364fedd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Jul 2020 15:45:03 +0200
Subject: [PATCH 0588/1774] added new interfaces for datasets

---
 datapool/DataSetIF.h                          |  22 +---
 .../{DataSetBase.cpp => PoolDataSetBase.cpp}  |  34 ++---
 datapool/{DataSetBase.h => PoolDataSetBase.h} |  15 ++-
 datapool/PoolDataSetIF.h                      |  28 ++++
 datapool/PoolVariableIF.h                     |   4 +-
 datapool/SharedDataSetIF.h                    |  15 +++
 datapoolglob/GlobalDataSet.cpp                |   8 +-
 datapoolglob/GlobalDataSet.h                  |   6 +-
 datapoollocal/LocalDataPoolManager.cpp        |   8 +-
 datapoollocal/LocalDataPoolManager.h          |   8 +-
 datapoollocal/LocalDataSet.cpp                | 113 +---------------
 datapoollocal/LocalDataSet.h                  | 112 ++--------------
 datapoollocal/LocalDataSetBase.cpp            | 107 ++++++++++++++++
 datapoollocal/LocalPoolDataSetBase.h          | 121 ++++++++++++++++++
 datapoollocal/SharedLocalDataSet.cpp          |  16 +++
 datapoollocal/SharedLocalDataSet.h            |  25 ++++
 datapoollocal/StaticLocalDataSet.cpp          |   6 -
 datapoollocal/StaticLocalDataSet.h            |  22 +++-
 18 files changed, 396 insertions(+), 274 deletions(-)
 rename datapool/{DataSetBase.cpp => PoolDataSetBase.cpp} (80%)
 rename datapool/{DataSetBase.h => PoolDataSetBase.h} (93%)
 create mode 100644 datapool/PoolDataSetIF.h
 create mode 100644 datapool/SharedDataSetIF.h
 create mode 100644 datapoollocal/LocalDataSetBase.cpp
 create mode 100644 datapoollocal/LocalPoolDataSetBase.h
 create mode 100644 datapoollocal/SharedLocalDataSet.cpp
 create mode 100644 datapoollocal/SharedLocalDataSet.h
 delete mode 100644 datapoollocal/StaticLocalDataSet.cpp

diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index 437f324f6..bcc1cd21d 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -1,5 +1,5 @@
-#ifndef DATASETIF_H_
-#define DATASETIF_H_
+#ifndef FRAMEWORK_DATAPOOL_DATASETIF_H_
+#define FRAMEWORK_DATAPOOL_DATASETIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/timemanager/Clock.h>
@@ -34,8 +34,7 @@ public:
 	 */
 	virtual ~DataSetIF() {}
 
-	virtual ReturnValue_t read(uint32_t lockTimeout) = 0;
-	virtual ReturnValue_t commit(uint32_t lockTimeout) = 0;
+
 	/**
 	 * @brief	This operation provides a method to register local data pool
 	 * 			variables to register in a data set by passing itself
@@ -44,19 +43,6 @@ public:
 	virtual ReturnValue_t registerVariable(PoolVariableIF* variable) = 0;
 
 	virtual uint16_t getFillCount() const = 0;
-private:
-	/**
-	 * @brief 	Most underlying data structures will have a pool like structure
-	 * 			and will require a lock and unlock mechanism to ensure
-	 * 			thread-safety
-	 * @return Lock operation result
-	 */
-	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs) = 0;
-	/**
-	 * @brief   Unlock call corresponding to the lock call.
-	 * @return Unlock operation result
-	 */
-	virtual ReturnValue_t unlockDataPool() = 0;
 };
 
-#endif /* DATASETIF_H_ */
+#endif /* FRAMEWORK_DATAPOOL_DATASETIF_H_ */
diff --git a/datapool/DataSetBase.cpp b/datapool/PoolDataSetBase.cpp
similarity index 80%
rename from datapool/DataSetBase.cpp
rename to datapool/PoolDataSetBase.cpp
index cb7a78993..63820732a 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -1,7 +1,7 @@
-#include <framework/datapool/DataSetBase.h>
+#include <framework/datapool/PoolDataSetBase.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-DataSetBase::DataSetBase(PoolVariableIF** registeredVariablesArray,
+PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
         const size_t maxFillCount):
         registeredVariables(registeredVariablesArray),
         maxFillCount(maxFillCount) {
@@ -10,9 +10,9 @@ DataSetBase::DataSetBase(PoolVariableIF** registeredVariablesArray,
 	}
 }
 
-DataSetBase::~DataSetBase() {}
+PoolDataSetBase::~PoolDataSetBase() {}
 
-ReturnValue_t DataSetBase::registerVariable(
+ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
 	if (state != States::DATA_SET_UNINITIALISED) {
 		sif::error << "DataSet::registerVariable: "
@@ -34,7 +34,7 @@ ReturnValue_t DataSetBase::registerVariable(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	if (state == States::DATA_SET_UNINITIALISED) {
 		lockDataPool(lockTimeout);
@@ -56,11 +56,11 @@ ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
 	return result;
 }
 
-uint16_t DataSetBase::getFillCount() const {
+uint16_t PoolDataSetBase::getFillCount() const {
     return fillCount;
 }
 
-ReturnValue_t DataSetBase::readVariable(uint16_t count) {
+ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	// These checks are often performed by the respective
 	// variable implementation too, but I guess a double check does not hurt.
@@ -77,7 +77,7 @@ ReturnValue_t DataSetBase::readVariable(uint16_t count) {
 	return result;
 }
 
-ReturnValue_t DataSetBase::commit(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
 	if (state == States::DATA_SET_WAS_READ) {
 		handleAlreadyReadDatasetCommit(lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
@@ -87,7 +87,7 @@ ReturnValue_t DataSetBase::commit(uint32_t lockTimeout) {
 	}
 }
 
-void DataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
+void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 	lockDataPool(lockTimeout);
 	for (uint16_t count = 0; count < fillCount; count++) {
 		if (registeredVariables[count]->getReadWriteMode()
@@ -101,7 +101,7 @@ void DataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 	unlockDataPool();
 }
 
-ReturnValue_t DataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	lockDataPool(lockTimeout);
 	for (uint16_t count = 0; count < fillCount; count++) {
@@ -125,15 +125,15 @@ ReturnValue_t DataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 }
 
 
-ReturnValue_t DataSetBase::lockDataPool(uint32_t timeoutMs) {
+ReturnValue_t PoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t DataSetBase::unlockDataPool() {
+ReturnValue_t PoolDataSetBase::unlockDataPool() {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
+ReturnValue_t PoolDataSetBase::serialize(uint8_t** buffer, size_t* size,
 		const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t count = 0; count < fillCount; count++) {
@@ -146,7 +146,7 @@ ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
 	return result;
 }
 
-ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
+ReturnValue_t PoolDataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
         SerializeIF::Endianness streamEndianness) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t count = 0; count < fillCount; count++) {
@@ -159,10 +159,14 @@ ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
 	return result;
 }
 
-size_t DataSetBase::getSerializedSize() const {
+size_t PoolDataSetBase::getSerializedSize() const {
 	uint32_t size = 0;
 	for (uint16_t count = 0; count < fillCount; count++) {
 		size += registeredVariables[count]->getSerializedSize();
 	}
 	return size;
 }
+
+void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
+    this->registeredVariables = variablesContainer;
+}
diff --git a/datapool/DataSetBase.h b/datapool/PoolDataSetBase.h
similarity index 93%
rename from datapool/DataSetBase.h
rename to datapool/PoolDataSetBase.h
index cc16aa9e5..112808dd0 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -1,6 +1,7 @@
-#ifndef FRAMEWORK_DATAPOOL_DATASETBASE_H_
-#define FRAMEWORK_DATAPOOL_DATASETBASE_H_
+#ifndef FRAMEWORK_DATAPOOL_POOLPOOLDATASETBASE_H_
+#define FRAMEWORK_DATAPOOL_POOLPOOLDATASETBASE_H_
 #include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolDataSetIF.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/ipc/MutexIF.h>
 
@@ -27,7 +28,7 @@
  * @author	Bastian Baetz
  * @ingroup data_pool
  */
-class DataSetBase: public DataSetIF,
+class PoolDataSetBase: public PoolDataSetIF,
 		public SerializeIF,
 		public HasReturnvaluesIF {
 public:
@@ -37,9 +38,9 @@ public:
 	 * 			supply a pointer to this dataset to PoolVariable
 	 * 			initializations to register pool variables.
 	 */
-	DataSetBase(PoolVariableIF** registeredVariablesArray,
+	PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
 	        const size_t maxFillCount);
-	virtual~ DataSetBase();
+	virtual~ PoolDataSetBase();
 
 	/**
 	 * @brief	The read call initializes reading out all registered variables.
@@ -140,10 +141,12 @@ protected:
 	PoolVariableIF** registeredVariables = nullptr;
 	const size_t maxFillCount = 0;
 
+	void setContainer(PoolVariableIF** variablesContainer);
+
 private:
 	ReturnValue_t readVariable(uint16_t count);
 	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
 	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
 };
 
-#endif /* FRAMEWORK_DATAPOOL_DATASETBASE_H_ */
+#endif /* FRAMEWORK_DATAPOOL_POOLPOOLDATASETBASE_H_ */
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
new file mode 100644
index 000000000..a33d4bd06
--- /dev/null
+++ b/datapool/PoolDataSetIF.h
@@ -0,0 +1,28 @@
+#ifndef FRAMEWORK_DATAPOOL_POOLDATASETIF_H_
+#define FRAMEWORK_DATAPOOL_POOLDATASETIF_H_
+#include <framework/datapool/DataSetIF.h>
+
+class PoolDataSetIF: public DataSetIF {
+public:
+    virtual~ PoolDataSetIF() {};
+
+    virtual ReturnValue_t read(dur_millis_t lockTimeout) = 0;
+    virtual ReturnValue_t commit(dur_millis_t lockTimeout) = 0;
+
+    /**
+     * @brief   Most underlying data structures will have a pool like structure
+     *          and will require a lock and unlock mechanism to ensure
+     *          thread-safety
+     * @return Lock operation result
+     */
+    virtual ReturnValue_t lockDataPool(dur_millis_t timeoutMs) = 0;
+    /**
+     * @brief   Unlock call corresponding to the lock call.
+     * @return Unlock operation result
+     */
+    virtual ReturnValue_t unlockDataPool() = 0;
+
+    virtual bool isValid() const = 0;
+};
+
+#endif /* FRAMEWORK_DATAPOOL_POOLDATASETIF_H_ */
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 30b87839b..6b0dd7fb2 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -18,9 +18,9 @@
  * @ingroup data_pool
  */
 class PoolVariableIF : public SerializeIF {
-	friend class DataSetBase;
+	friend class PoolDataSetBase;
 	friend class GlobDataSet;
-	friend class LocalDataSet;
+	friend class LocalDataSetBase;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
 	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
diff --git a/datapool/SharedDataSetIF.h b/datapool/SharedDataSetIF.h
new file mode 100644
index 000000000..3d9cc302e
--- /dev/null
+++ b/datapool/SharedDataSetIF.h
@@ -0,0 +1,15 @@
+#ifndef FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_
+#define FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolDataSetIF.h>
+
+class SharedDataSetIF: public PoolDataSetIF {
+public:
+    virtual ~SharedDataSetIF() {};
+
+private:
+    virtual ReturnValue_t lockDataset(dur_millis_t mutexTimeout) = 0;
+    virtual ReturnValue_t unlockDataset() = 0;
+};
+
+#endif /* FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_ */
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
index 883f61577..3e6e3e529 100644
--- a/datapoolglob/GlobalDataSet.cpp
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -2,7 +2,7 @@
 #include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-GlobDataSet::GlobDataSet(): DataSetBase(
+GlobDataSet::GlobDataSet(): PoolDataSetBase(
         reinterpret_cast<PoolVariableIF**>(&registeredVariables),
         DATA_SET_MAX_SIZE) {}
 
@@ -17,7 +17,11 @@ ReturnValue_t GlobDataSet::commit(bool valid, uint32_t lockTimeout) {
 }
 
 ReturnValue_t GlobDataSet::commit(uint32_t lockTimeout) {
-	return DataSetBase::commit(lockTimeout);
+	return PoolDataSetBase::commit(lockTimeout);
+}
+
+bool GlobDataSet::isValid() const {
+    return this->valid;
 }
 
 ReturnValue_t GlobDataSet::unlockDataPool() {
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index d237cc1b4..3ebe72358 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_DATAPOOLGLOB_DATASET_H_
 #define FRAMEWORK_DATAPOOLGLOB_DATASET_H_
 
-#include <framework/datapool/DataSetBase.h>
+#include <framework/datapool/PoolDataSetBase.h>
 
 /**
  * @brief	The DataSet class manages a set of locally checked out variables
@@ -17,7 +17,7 @@
  * @author	Bastian Baetz
  * @ingroup data_pool
  */
-class GlobDataSet: public DataSetBase {
+class GlobDataSet: public PoolDataSetBase {
 public:
 
 	/**
@@ -53,6 +53,8 @@ public:
 	 */
 	void setSetValid(bool valid);
 
+	bool isValid() const override;
+
 	/**
 	 * Set the valid information of all variables contained in the set which
 	 * are not read-only
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 02016abf0..afce330fe 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,5 +1,5 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/datapoollocal/LocalDataSet.h>
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
 #include <framework/housekeeping/AcceptsHkPacketsIF.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
@@ -116,7 +116,7 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t sendTo) {
-	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
+	LocalDataSetBase* dataSetToSerialize = dynamic_cast<LocalDataSetBase*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
@@ -155,7 +155,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
-    LocalDataSet* dataSet = dynamic_cast<LocalDataSet*>(
+    LocalDataSetBase* dataSet = dynamic_cast<LocalDataSetBase*>(
             owner->getDataSetHandle(sid));
     if(dataSet == nullptr) {
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
@@ -186,7 +186,7 @@ void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-        store_address_t *storeId, LocalDataSet* dataSet) {
+        store_address_t *storeId, LocalDataSetBase* dataSet) {
     size_t hkSize = dataSet->getSerializedSize();
     uint8_t* storePtr = nullptr;
     ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index df7b9ff43..5a840303f 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -14,7 +14,7 @@
 
 #include <map>
 
-class LocalDataSet;
+class LocalDataSetBase;
 
 /**
  * @brief 	This class is the managing instance for local data pool.
@@ -38,7 +38,7 @@ class LocalDataPoolManager {
 	friend class LocalPoolVar;
 	template<typename T, uint16_t vecSize>
 	friend class LocalPoolVector;
-	friend class LocalDataSet;
+	friend class LocalDataSetBase;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
@@ -135,7 +135,7 @@ private:
      * The data pool manager will keep an internal map of HK receivers.
      */
     struct HkReceiver {
-        LocalDataSet* dataSet = nullptr;
+        LocalDataSetBase* dataSet = nullptr;
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         ReportingType reportingType = ReportingType::PERIODIC;
         bool reportingStatus = true;
@@ -202,7 +202,7 @@ private:
 
 	void setMinimalSamplingFrequency(float frequencySeconds);
 	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
-	        LocalDataSet* dataSet);
+	        LocalDataSetBase* dataSet);
 };
 
 
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 2a42cd387..b6508ada0 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -1,106 +1,7 @@
-#include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/datapoollocal/LocalDataSet.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-#include <cmath>
-#include <cstring>
-
-LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
-        const size_t maxNumberOfVariables):
-        DataSetBase(poolVarList.data(), maxNumberOfVariables) {
-    poolVarList.reserve(maxNumberOfVariables);
-    poolVarList.resize(maxNumberOfVariables);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-}
-
-LocalDataSet::LocalDataSet(object_id_t ownerId,
-        const size_t maxNumberOfVariables):
-        DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
-    poolVarList.reserve(maxNumberOfVariables);
-    poolVarList.resize(maxNumberOfVariables);
-    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
-            ownerId);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-}
-
-LocalDataSet::~LocalDataSet() {
-}
-
-ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(timeoutMs);
-}
-
-ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
-        size_t *size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-    uint8_t validityMask[validityMaskSize];
-    uint8_t validBufferIndex = 0;
-    uint8_t validBufferIndexBit = 0;
-    for (uint16_t count = 0; count < fillCount; count++) {
-        if(registeredVariables[count]->isValid()) {
-            // set validity buffer here.
-            this->bitSetter(validityMask + validBufferIndex,
-                    validBufferIndexBit);
-            if(validBufferIndexBit == 7) {
-                validBufferIndex ++;
-                validBufferIndexBit = 0;
-            }
-            else {
-                validBufferIndexBit ++;
-            }
-        }
-        result = registeredVariables[count]->serialize(buffer, size, maxSize,
-                streamEndianness);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-    }
-    // copy validity buffer to end
-    std::memcpy(*buffer, validityMask, validityMaskSize);
-    *size += validityMaskSize;
-    return result;
-}
-
-ReturnValue_t LocalDataSet::unlockDataPool() {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->unlockMutex();
-}
-
-ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    for (uint16_t count = 0; count < fillCount; count++) {
-        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
-                size, maxSize, streamEndianness);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
-                    " error!" << std::endl;
-            return result;
-        }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position) const {
-    if(position > 7) {
-        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
-}
-
+#include <framework/datapoollocal/LocalDataSet.h>
+
+LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner, const size_t maxSize):
+        LocalDataSetBase(hkOwner, nullptr, maxSize), poolVarList(maxSize) {
+    this->setContainer(poolVarList.data());
+}
+
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 2c70de826..c26d540c8 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -1,115 +1,19 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
-#include <framework/datapool/DataSetBase.h>
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapoollocal/HasLocalDataPoolIF.h>
-#include <framework/serialize/SerializeIF.h>
-
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
 #include <vector>
 
-class LocalDataPoolManager;
-
-/**
- * @brief	The LocalDataSet class manages a set of locally checked out variables
- * 			for local data pools
- * @details
- * This class manages a list, where a set of local variables (or pool variables)
- * are registered. They are checked-out (i.e. their values are looked
- * up and copied) with the read call. After the user finishes working with the
- * pool variables, he can write back all variable values to the pool with
- * the commit call. The data set manages locking and freeing the local data pools,
- * to ensure thread-safety.
- *
- * An internal state manages usage of this class. Variables may only be
- * registered before the read call is made, and the commit call only
- * after the read call.
- *
- * If pool variables are writable and not committed until destruction
- * of the set, the DataSet class automatically sets the valid flag in the
- * data pool to invalid (without) changing the variable's value.
- *
- * @ingroup data_pool
- */
-class LocalDataSet: public DataSetBase {
+class LocalDataSet: public LocalDataSetBase {
 public:
-	/**
-	 * @brief	Constructor for the creator of local pool data.
-	 * 			The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
-	 */
-	LocalDataSet(HasLocalDataPoolIF *hkOwner,
-	        const size_t maxNumberOfVariables);
+    LocalDataSet(HasLocalDataPoolIF* hkOwner, const size_t maxSize);
 
-	/**
-	 * @brief	Constructor for users of local pool data. The passed pool
-	 * 			owner should implement the HasHkPoolParametersIF.
-	 * 			The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
-	 */
-	LocalDataSet(object_id_t ownerId,
-	        const size_t maxNumberOfVariables);
+    virtual~ LocalDataSet() {};
 
-	/**
-	 * @brief	The destructor automatically manages writing the valid
-	 * 			information of variables.
-	 * @details
-	 * In case the data set was read out, but not committed(indicated by state),
-	 * the destructor parses all variables that are still registered to the set.
-	 * For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~LocalDataSet();
-
-	/**
-	 * Special version of the serilization function which appends a
-	 * validity buffer at the end. Each bit of this validity buffer
-	 * denotes whether the container data set entries are valid from left
-	 * to right, MSB first.
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param bigEndian
-	 * @param withValidityBuffer
-	 * @return
-	 */
-	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
-	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const;
-
-	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
-	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const;
-protected:
+    //! Copying forbidden for now.
+    LocalDataSet(const LocalDataSet&) = delete;
+    LocalDataSet& operator=(const LocalDataSet&) = delete;
 private:
-	/**
-	 * If the valid state of a dataset is always relevant to the whole
-	 * data set we can use this flag.
-	 */
-	bool valid = false;
-
-	/**
-	 * @brief	This is a small helper function to facilitate locking
-	 * 			the global data pool.
-	 * @details
-	 * It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
-	/**
-	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the global data pool
-	 * @details
-	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	ReturnValue_t unlockDataPool() override;
-
-	LocalDataPoolManager* hkManager;
-
-	/**
-	 * Set n-th bit of a byte, with n being the position from 0
-	 * (most significant bit) to 7 (least significant bit)
-	 */
-	void bitSetter(uint8_t* byte, uint8_t position) const;
-
-	std::vector<PoolVariableIF*> poolVarList;
+    std::vector<PoolVariableIF*> poolVarList;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/LocalDataSetBase.cpp b/datapoollocal/LocalDataSetBase.cpp
new file mode 100644
index 000000000..f490ff675
--- /dev/null
+++ b/datapoollocal/LocalDataSetBase.cpp
@@ -0,0 +1,107 @@
+#include <framework/datapoollocal/LocalDataPoolManager.h>
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
+#include <framework/serialize/SerializeAdapter.h>
+
+#include <cmath>
+#include <cstring>
+
+LocalDataSetBase::LocalDataSetBase(HasLocalDataPoolIF *hkOwner,
+        PoolVariableIF** registeredVariablesArray,
+        const size_t maxNumberOfVariables):
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+    if(hkOwner == nullptr) {
+        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
+                << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+}
+
+LocalDataSetBase::LocalDataSetBase(object_id_t ownerId,
+        PoolVariableIF** registeredVariablesArray,
+        const size_t maxNumberOfVariables):
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
+    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+            ownerId);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
+                << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+}
+
+LocalDataSetBase::~LocalDataSetBase() {
+}
+
+ReturnValue_t LocalDataSetBase::lockDataPool(uint32_t timeoutMs) {
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->lockMutex(timeoutMs);
+}
+
+ReturnValue_t LocalDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
+        size_t *size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+    uint8_t validityMask[validityMaskSize];
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if(registeredVariables[count]->isValid()) {
+            // set validity buffer here.
+            this->bitSetter(validityMask + validBufferIndex,
+                    validBufferIndexBit);
+            if(validBufferIndexBit == 7) {
+                validBufferIndex ++;
+                validBufferIndexBit = 0;
+            }
+            else {
+                validBufferIndexBit ++;
+            }
+        }
+        result = registeredVariables[count]->serialize(buffer, size, maxSize,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    // copy validity buffer to end
+    std::memcpy(*buffer, validityMask, validityMaskSize);
+    *size += validityMaskSize;
+    return result;
+}
+
+ReturnValue_t LocalDataSetBase::unlockDataPool() {
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->unlockMutex();
+}
+
+ReturnValue_t LocalDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
+        size_t* size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    for (uint16_t count = 0; count < fillCount; count++) {
+        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
+        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
+                size, maxSize, streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
+                    " error!" << std::endl;
+            return result;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void LocalDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1 << shiftNumber;
+}
+
+bool LocalDataSetBase::isValid() const {
+    return this->valid;
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
new file mode 100644
index 000000000..5ef8f3d41
--- /dev/null
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -0,0 +1,121 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolDataSetBase.h>
+#include <framework/datapoollocal/HasLocalDataPoolIF.h>
+#include <framework/serialize/SerializeIF.h>
+
+#include <vector>
+
+class LocalDataPoolManager;
+
+/**
+ * @brief	The LocalDataSet class manages a set of locally checked out
+ *          variables for local data pools
+ * @details
+ * This class manages a list, where a set of local variables (or pool variables)
+ * are registered. They are checked-out (i.e. their values are looked
+ * up and copied) with the read call. After the user finishes working with the
+ * pool variables, he can write back all variable values to the pool with
+ * the commit call. The data set manages locking and freeing the local data pools,
+ * to ensure thread-safety.
+ *
+ * An internal state manages usage of this class. Variables may only be
+ * registered before the read call is made, and the commit call only
+ * after the read call.
+ *
+ * If pool variables are writable and not committed until destruction
+ * of the set, the DataSet class automatically sets the valid flag in the
+ * data pool to invalid (without) changing the variable's value.
+ *
+ * @ingroup data_pool
+ */
+class LocalDataSetBase: public PoolDataSetBase {
+public:
+	/**
+	 * @brief	Constructor for the creator of local pool data.
+	 * 			The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
+	 */
+	LocalDataSetBase(HasLocalDataPoolIF *hkOwner,
+	        PoolVariableIF** registeredVariablesArray,
+	        const size_t maxNumberOfVariables);
+
+	/**
+	 * @brief	Constructor for users of local pool data. The passed pool
+	 * 			owner should implement the HasHkPoolParametersIF.
+	 * 			The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
+	 */
+	LocalDataSetBase(object_id_t ownerId,
+	        PoolVariableIF** registeredVariablesArray,
+	        const size_t maxNumberOfVariables);
+
+	/**
+	 * @brief	The destructor automatically manages writing the valid
+	 * 			information of variables.
+	 * @details
+	 * In case the data set was read out, but not committed(indicated by state),
+	 * the destructor parses all variables that are still registered to the set.
+	 * For each, the valid flag in the data pool is set to "invalid".
+	 */
+	~LocalDataSetBase();
+
+	/**
+	 * Special version of the serilization function which appends a
+	 * validity buffer at the end. Each bit of this validity buffer
+	 * denotes whether the container data set entries are valid from left
+	 * to right, MSB first.
+	 * @param buffer
+	 * @param size
+	 * @param maxSize
+	 * @param bigEndian
+	 * @param withValidityBuffer
+	 * @return
+	 */
+	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
+
+	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
+
+	bool isValid() const override;
+
+protected:
+	/**
+	 * If the valid state of a dataset is always relevant to the whole
+	 * data set we can use this flag.
+	 */
+	bool valid = false;
+
+	/**
+	 * @brief	This is a small helper function to facilitate locking
+	 * 			the global data pool.
+	 * @details
+	 * It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
+	/**
+	 * @brief	This is a small helper function to facilitate
+	 * 			unlocking the global data pool
+	 * @details
+	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	ReturnValue_t unlockDataPool() override;
+
+	LocalDataPoolManager* hkManager;
+
+	/**
+	 * Set n-th bit of a byte, with n being the position from 0
+	 * (most significant bit) to 7 (least significant bit)
+	 */
+	void bitSetter(uint8_t* byte, uint8_t position) const;
+
+private:
+
+
+};
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ */
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
new file mode 100644
index 000000000..6f355a8a2
--- /dev/null
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -0,0 +1,16 @@
+#include <framework/datapoollocal/SharedLocalDataSet.h>
+
+SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, object_id_t owner,
+        const size_t maxSize): SystemObject(objectId),
+        LocalDataSetBase(owner, nullptr, maxSize) {
+    this->setContainer(poolVarVector.data());
+    datasetLock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
+    return datasetLock->lockMutex(mutexTimeout);
+}
+
+ReturnValue_t SharedLocalDataSet::unlockDataset() {
+    return datasetLock->unlockMutex();
+}
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
new file mode 100644
index 000000000..8fe613bac
--- /dev/null
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -0,0 +1,25 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+#define FRAMEWORK_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+#include <framework/datapool/SharedDataSetIF.h>
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
+#include <framework/objectmanager/SystemObject.h>
+#include <vector>
+
+class SharedLocalDataSet: public SystemObject,
+        public LocalDataSetBase,
+        public SharedDataSetIF {
+public:
+    SharedLocalDataSet(object_id_t objectId, object_id_t owner,
+            const size_t maxSize);
+    ReturnValue_t lockDataset(dur_millis_t mutexTimeout) override;
+    ReturnValue_t unlockDataset() override;
+private:
+
+
+    MutexIF* datasetLock = nullptr;
+    std::vector<PoolVariableIF*> poolVarVector;
+};
+
+
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_ */
diff --git a/datapoollocal/StaticLocalDataSet.cpp b/datapoollocal/StaticLocalDataSet.cpp
deleted file mode 100644
index 15d4251a4..000000000
--- a/datapoollocal/StaticLocalDataSet.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <framework/datapoollocal/StaticLocalDataSet.h>
-
-
-
-
-
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index 15a79aaef..f31018af3 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -1,11 +1,23 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
 #define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#include <framework/datapool/DataSetBase.h>
-
-
-class StaticLocalDataSet: public DataSetBase {
+#include <framework/datapool/PoolDataSetBase.h>
+#include <array>
 
+/**
+ * @brief   This local dataset type is created on the stack.
+ * @details
+ * Size of data set specified as a constructor argument. It is recommended
+ * to use the default LocalDataSet of the dataset is constructed on the heap
+ * and the SharedLocalDataSet if it created on the heap and used by multiple
+ * other software objects.
+ * @tparam capacity
+ */
+template <uint8_t capacity>
+class StaticLocalDataSet: public PoolDataSetBase {
+    StaticLocalDataSet():  PoolDataSetBase(poolVarList.data(), capacity) {}
+    virtual~ StaticLocalDataSet();
+private:
+    std::array<PoolVariableIF*, capacity> poolVarList;
 };
 
-
 #endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */

From a0b8f8855ced699701290f643c1fab8658bd323b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Jul 2020 11:45:23 +0200
Subject: [PATCH 0589/1774] cotinued distir datapool

---
 datapoollocal/HasLocalDataPoolIF.h   |  1 +
 datapoollocal/LocalDataPoolManager.h | 26 +++++++++++++++++++++++---
 datapoollocal/LocalDataSet.cpp       |  4 ++++
 datapoollocal/LocalDataSet.h         |  2 +-
 datapoollocal/LocalPoolDataSetBase.h |  2 ++
 datapoollocal/LocalPoolVariable.tpp  |  2 +-
 datapoollocal/SharedLocalDataSet.h   |  8 +++++++-
 datapoollocal/StaticLocalDataSet.h   | 13 +++++++++----
 8 files changed, 48 insertions(+), 10 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 0095f8944..7727c3b48 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -41,6 +41,7 @@ public:
 	virtual~ HasLocalDataPoolIF() {};
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
+	static constexpr lp_id_t NO_POOL_ID = 0xffffffff;
 
 	/** Command queue for housekeeping messages. */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 5a840303f..9c413aa4b 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -109,13 +109,32 @@ public:
 
     /**
      * Different types of housekeeping reporting are possible.
-     *  1. PERIODIC: HK packets are generated in fixed intervals
-     *  2. UPDATED: HK packets are generated if a value was updated
-     *  3. REQUESTED: HK packets are only generated if explicitely requested
+     *  1. PERIODIC: HK packets are generated in fixed intervals and sent to
+     *     destination. Fromat will be raw.
+     *  2. UPDATED: Notification will be sent out if HK data has changed.
+     *     Question: Send Raw data directly or just the message?
+     *  3. REQUESTED: HK packets are only generated if explicitely requested.
+     *     Propably not necessary, just use multiple local data sets or
+     *     shared datasets.
+     *
+     *  TODO: This is a big architecture question. Use raw data or shared
+     *  datasets? dumb thing about shared datasets: It propably would be better
+     *  if each task who uses the data has their own copy of the pool
+     *  variables. Then the LPIDs should be hardcoded in the dataset implementations
+     *  so the users don't have to worry about it anymore.
+     *
+     *  Notifications should also be possible for single variables instead of
+     *  full dataset updates.
      */
     enum class ReportingType: uint8_t {
+        // Periodic generation of HK packets.
         PERIODIC,
+        // Notification will be sent out as message.
+        // Data is accessed via shared data set or multiple local data sets.
         ON_UPDATE,
+        // actually, requested is propably unnecessary. If another component
+        // needs data on request, they can just use  the new SharedDataSet
+        // which is thread-safe to also have full access to the interface..
         REQUESTED
     };
 
@@ -136,6 +155,7 @@ private:
      */
     struct HkReceiver {
         LocalDataSetBase* dataSet = nullptr;
+        lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         ReportingType reportingType = ReportingType::PERIODIC;
         bool reportingStatus = true;
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index b6508ada0..74b1376ef 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -5,3 +5,7 @@ LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner, const size_t maxSize):
     this->setContainer(poolVarList.data());
 }
 
+LocalDataSet::LocalDataSet(object_id_t owner, const size_t maxSize):
+        LocalDataSetBase(owner, nullptr, maxSize), poolVarList(maxSize) {
+    this->setContainer(poolVarList.data());
+}
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index c26d540c8..e6bd20127 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -6,7 +6,7 @@
 class LocalDataSet: public LocalDataSetBase {
 public:
     LocalDataSet(HasLocalDataPoolIF* hkOwner, const size_t maxSize);
-
+    LocalDataSet(object_id_t owner, const size_t maxSize);
     virtual~ LocalDataSet() {};
 
     //! Copying forbidden for now.
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 5ef8f3d41..f7a2cae4a 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -46,6 +46,8 @@ public:
 	 * 			owner should implement the HasHkPoolParametersIF.
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
+	 * @details
+	 *
 	 */
 	LocalDataSetBase(object_id_t ownerId,
 	        PoolVariableIF** registeredVariablesArray,
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 0b96bb4fd..59bf78d0d 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -28,7 +28,7 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 		pool_rwm_t setReadWriteMode, DataSetIF *dataSet):
-		readWriteMode(readWriteMode) {
+		readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
 				"NO_PARAMETER value!" << std::endl;
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index 8fe613bac..acb0cd268 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -5,6 +5,13 @@
 #include <framework/objectmanager/SystemObject.h>
 #include <vector>
 
+/**
+ * Baseline question: If this dataset is shared, is there once instance
+ * shared among many objects or multiple instances? Maybe be flexible
+ * and provide both ways? Sharing one instance requires a mutex lock.
+ * If there are multiple instances, it is not shared anymore, to be fair..
+ * Then a regular local data set is sufficient.
+ */
 class SharedLocalDataSet: public SystemObject,
         public LocalDataSetBase,
         public SharedDataSetIF {
@@ -15,7 +22,6 @@ public:
     ReturnValue_t unlockDataset() override;
 private:
 
-
     MutexIF* datasetLock = nullptr;
     std::vector<PoolVariableIF*> poolVarVector;
 };
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index f31018af3..fbe1545f9 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
 #define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
 #include <framework/datapool/PoolDataSetBase.h>
+#include <framework/objectmanager/SystemObjectIF.h>
 #include <array>
 
 /**
@@ -12,12 +13,16 @@
  * other software objects.
  * @tparam capacity
  */
-template <uint8_t capacity>
-class StaticLocalDataSet: public PoolDataSetBase {
-    StaticLocalDataSet():  PoolDataSetBase(poolVarList.data(), capacity) {}
+template <uint8_t NUM_VARIABLES>
+class StaticLocalDataSet: public LocalDataSetBase {
+public:
+    StaticLocalDataSet(object_id_t owner):
+        LocalDataSetBase(owner, poolVarList.data(), NUM_VARIABLES) {
+    }
+
     virtual~ StaticLocalDataSet();
 private:
-    std::array<PoolVariableIF*, capacity> poolVarList;
+    std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */

From 47b3a428c68ff74a6019eb2c36c9fb253cc427fd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Jul 2020 12:33:03 +0200
Subject: [PATCH 0590/1774] removed device switch, not necessary anymore

---
 devicehandlers/ChildHandlerBase.cpp  | 5 ++---
 devicehandlers/ChildHandlerBase.h    | 6 +++---
 devicehandlers/DeviceHandlerBase.cpp | 4 ----
 devicehandlers/DeviceHandlerBase.h   | 8 --------
 4 files changed, 5 insertions(+), 18 deletions(-)

diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 9e5019b4d..bdc5fa653 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -4,15 +4,14 @@
 
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * cookie,
-		uint8_t setDeviceSwitch, object_id_t hkDestination,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		object_id_t hkDestination, 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->setDeviceSwitch(setDeviceSwitch);
 	this->setHkDestination(hkDestination);
 	this->setThermalStateRequestPoolIds(thermalStatePoolId,
 			thermalRequestPoolId);
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 5c216e86f..c8ac9541e 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -7,9 +7,9 @@
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
 	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * cookie, uint8_t setDeviceSwitch,
-			object_id_t hkDestination, uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId, object_id_t parent = objects::NO_OBJECT,
+			CookieIF * cookie, object_id_t hkDestination,
+			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+			object_id_t parent = objects::NO_OBJECT,
 			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index cc97cd420..c13611b33 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -63,10 +63,6 @@ void DeviceHandlerBase::setThermalStateRequestPoolIds(
 }
 
 
-void DeviceHandlerBase::setDeviceSwitch(uint8_t deviceSwitch) {
-	this->deviceSwitch = deviceSwitch;
-}
-
 DeviceHandlerBase::~DeviceHandlerBase() {
 	delete comCookie;
 	if (defaultFDIRUsed) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 61fb701d5..034653dcb 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -108,7 +108,6 @@ public:
 			CookieIF * comCookie, FailureIsolationBase* fdirInstance = nullptr,
 			size_t cmdQueueSize = 20);
 
-	void setDeviceSwitch(uint8_t deviceSwitch);
 	void setHkDestination(object_id_t hkDestination);
 	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
 			uint32_t thermalRequestPoolId);
@@ -1079,13 +1078,6 @@ private:
 	 */
 	Submode_t transitionSourceSubMode;
 
-	/**
-	 * the switch of the device
-	 *
-	 * for devices using two switches override getSwitches()
-	 */
-	uint8_t deviceSwitch;
-
 	/**
 	 * read the command queue
 	 */

From aaafed7b28bc7110321f0a092a81beb8002990bb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Jul 2020 12:38:21 +0200
Subject: [PATCH 0591/1774] health table init now mandatory, better

diagnostic output for uninit health table or invalid health helper owner
---
 devicehandlers/DeviceHandlerBase.cpp | 39 +++++++---------------------
 devicehandlers/DeviceHandlerBase.h   |  1 -
 health/HealthHelper.cpp              | 15 ++++++++---
 3 files changed, 21 insertions(+), 34 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index c13611b33..b4ad0fdac 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -164,12 +164,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	}
 
 	result = healthHelper.initialize();
-	if (result == RETURN_OK) {
-		healthHelperActive = true;
-	}
-	else {
-		sif::warning << "DeviceHandlerBase::initialize: Health Helper "
-				"initialization failure." << std::endl;
+	if (result != RETURN_OK) {
+	    return result;
 	}
 
 	result = modeHelper.initialize();
@@ -246,11 +242,9 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	if(healthHelperActive) {
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == RETURN_OK) {
-			return;
-		}
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == RETURN_OK) {
+	    return;
 	}
 
 	result = modeHelper.handleModeCommand(&command);
@@ -1028,9 +1022,7 @@ void DeviceHandlerBase::getMode(Mode_t* mode, Submode_t* submode) {
 }
 
 void DeviceHandlerBase::setToExternalControl() {
-	if(healthHelperActive) {
-		healthHelper.setHealth(EXTERNAL_CONTROL);
-	}
+	healthHelper.setHealth(EXTERNAL_CONTROL);
 }
 
 void DeviceHandlerBase::announceMode(bool recursive) {
@@ -1050,25 +1042,12 @@ void DeviceHandlerBase::missedReply(DeviceCommandId_t id) {
 }
 
 HasHealthIF::HealthState DeviceHandlerBase::getHealth() {
-	if(healthHelperActive) {
-		return healthHelper.getHealth();
-	}
-	else {
-		sif::warning << "DeviceHandlerBase::getHealth: Health helper not active"
-				<< std::endl;
-		return HasHealthIF::HEALTHY;
-	}
+	return healthHelper.getHealth();
 }
 
 ReturnValue_t DeviceHandlerBase::setHealth(HealthState health) {
-	if(healthHelperActive) {
-		healthHelper.setHealth(health);
-	}
-	else {
-		sif::warning << "DeviceHandlerBase::getHealth: Health helper not active"
-				<< std::endl;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    healthHelper.setHealth(health);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void DeviceHandlerBase::checkSwitchState() {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 034653dcb..a29063683 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -609,7 +609,6 @@ protected:
 
 	/** Health helper for HasHealthIF */
 	HealthHelper healthHelper;
-	bool healthHelperActive = false;
 	/** Mode helper for HasModesIF */
 	ModeHelper modeHelper;
 	/** Parameter helper for ReceivesParameterMessagesIF */
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index e01e6fbb7..a39305a3e 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -39,10 +39,19 @@ void HealthHelper::setParentQeueue(MessageQueueId_t parentQueue) {
 ReturnValue_t HealthHelper::initialize() {
 	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
 	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
-	// TODO: Better returnvalues
-	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) {

From b4d6d970bc9890c24b4abb3c671dad2104aac383 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Jul 2020 12:41:05 +0200
Subject: [PATCH 0592/1774] removed HK manager virtual functions

---
 devicehandlers/DeviceHandlerBase.cpp | 12 ------------
 devicehandlers/DeviceHandlerBase.h   |  5 -----
 2 files changed, 17 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index b4ad0fdac..282f20b2c 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1366,18 +1366,6 @@ LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
 	return &hkManager;
 }
 
-ReturnValue_t DeviceHandlerBase::addDataSet(sid_t sid) {
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DeviceHandlerBase::removeDataSet(sid_t sid) {
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DeviceHandlerBase::changeCollectionInterval(sid_t sid,
-        dur_seconds_t newInterval) {
-    return HasReturnvaluesIF::RETURN_OK;
-}
 
 ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
     // In this function, the task handle should be valid if the task
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index a29063683..ddbf60410 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -486,11 +486,6 @@ protected:
 	/** Get the HK manager object handle */
 	virtual LocalDataPoolManager* getHkManagerHandle() override;
 
-	virtual ReturnValue_t addDataSet(sid_t sid) override;
-	virtual ReturnValue_t removeDataSet(sid_t sid) override;
-	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
-	        dur_seconds_t newInterval) override;
-
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
 	 * 			performOperation(). Default implementation is empty.

From e179288c00ffedf8e160b399db15a0ec26395ea2 Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Thu, 25 Jun 2020 18:09:32 +0200
Subject: [PATCH 0593/1774] Fixed spelling mistake in HealthHelper

---
 devicehandlers/ChildHandlerBase.cpp  | 2 +-
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 devicehandlers/HealthDevice.cpp      | 2 +-
 health/HealthHelper.cpp              | 4 ++--
 health/HealthHelper.h                | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index bdc5fa653..2e4428e5f 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -39,7 +39,7 @@ ReturnValue_t ChildHandlerBase::initialize() {
 		parent->registerChild(getObjectId());
 	}
 
-	healthHelper.setParentQeueue(parentQueue);
+	healthHelper.setParentQueue(parentQueue);
 
 	modeHelper.setParentQueue(parentQueue);
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 282f20b2c..9f4c7baf2 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1134,7 +1134,7 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 
 void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
 	modeHelper.setParentQueue(parentQueueId);
-	healthHelper.setParentQeueue(parentQueueId);
+	healthHelper.setParentQueue(parentQueueId);
 }
 
 bool DeviceHandlerBase::isAwaitingReply() {
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 0bce34ec7..8367a6bc9 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -38,7 +38,7 @@ MessageQueueId_t HealthDevice::getCommandQueue() const {
 }
 
 void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
-	healthHelper.setParentQeueue(parentQueue);
+	healthHelper.setParentQueue(parentQueue);
 }
 
 bool HealthDevice::hasHealthChanged() {
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index a39305a3e..ba8504c22 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -28,11 +28,11 @@ HasHealthIF::HealthState HealthHelper::getHealth() {
 }
 
 ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
-	setParentQeueue(parentQueue);
+	setParentQueue(parentQueue);
 	return initialize();
 }
 
-void HealthHelper::setParentQeueue(MessageQueueId_t parentQueue) {
+void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
 	this->parentQueue = parentQueue;
 }
 
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index a17a69f3f..e112ad2c7 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -79,7 +79,7 @@ public:
 	/**
 	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
 	 */
-	void setParentQeueue(MessageQueueId_t parentQueue);
+	void setParentQueue(MessageQueueId_t parentQueue);
 
 	/**
 	 *

From 6425c0dd4c43ba0fa0711d5d894ae76a1858782f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 26 Jul 2020 03:12:04 +0200
Subject: [PATCH 0594/1774] better init error output

---
 osal/FreeRTOS/Mutex.cpp | 2 +-
 osal/FreeRTOS/Mutex.h   | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 6d90c3f61..8a5c444dd 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -8,7 +8,7 @@ const uint32_t MutexIF::BLOCKING = portMAX_DELAY;
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
 	if(handle == nullptr) {
-		sif::error << "Mutex: Creation failure" << std::endl;
+		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
 	}
 }
 
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index d6e0aab9e..37f1791c4 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -20,6 +20,7 @@ public:
 	~Mutex();
 	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
 	ReturnValue_t unlockMutex() override;
+
 private:
 	SemaphoreHandle_t handle;
 };

From afc16ef2d72dd6662ecb19c4a08a9aedc2119aab Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Jul 2020 12:49:18 +0200
Subject: [PATCH 0595/1774] new servicei nterface buffer /stream

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 12 ++++++------
 serviceinterface/ServiceInterfaceBuffer.h   |  2 +-
 serviceinterface/ServiceInterfaceStream.cpp |  2 +-
 serviceinterface/ServiceInterfaceStream.h   |  2 +-
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 5c80862c2..8c510eac4 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -78,9 +78,9 @@ int ServiceInterfaceBuffer::sync(void) {
 	}
 
 	size_t preambleSize  = 0;
-	auto preamble = getPreamble(&preambleSize);
+	std::string* preamble = getPreamble(&preambleSize);
 	// Write logMessage and time
-	this->putChars(preamble.data(), preamble.data() + preambleSize);
+	this->putChars(preamble->data(), preamble->data() + preambleSize);
 	// Handle output
 	this->putChars(pbase(), pptr());
 	// This tells that buffer is empty again
@@ -92,7 +92,7 @@ bool ServiceInterfaceBuffer::isBuffered() const {
 	return buffered;
 }
 
-std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
+std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 	Clock::TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
 	size_t currentSize = 0;
@@ -110,18 +110,18 @@ std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 					loggerTime.usecond /1000);
 	if(charCount < 0) {
 		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
-		return "";
+		return &preamble;
 	}
 	if(charCount > MAX_PREAMBLE_SIZE) {
 		printf("ServiceInterfaceBuffer: Char count too large for maximum "
 				"preamble size");
-		return "";
+		return &preamble;
 	}
 	currentSize += charCount;
 	if(preambleSize != nullptr) {
 		*preambleSize = currentSize;
 	}
-	return preamble;
+	return &preamble;
 }
 
 
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 39ea25c2d..7a2ce2ee7 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -60,7 +60,7 @@ private:
 	//! In this function, the characters are parsed.
 	void putChars(char const* begin, char const* end);
 
-	std::string getPreamble(size_t * preambleSize = nullptr);
+	std::string* getPreamble(size_t * preambleSize = nullptr);
 };
 
 #endif
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 76481ed12..31bc7c730 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -9,7 +9,7 @@ void ServiceInterfaceStream::setActive( bool myActive) {
 	this->streambuf.isActive = myActive;
 }
 
-std::string ServiceInterfaceStream::getPreamble() {
+std::string* ServiceInterfaceStream::getPreamble() {
 	return streambuf.getPreamble();
 }
 
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 9e19c228c..dc111459a 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -33,7 +33,7 @@ public:
 	 * the unbuffered mode.
 	 * @return Preamle consisting of log message and timestamp.
 	 */
-	std::string getPreamble();
+	std::string* getPreamble();
 
 	/**
 	 * This prints an error with a preamble. Useful if using the unbuffered

From 69f9ff02f047917c2c6a622bcb6fc6244d60564f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Jul 2020 17:00:51 +0200
Subject: [PATCH 0596/1774] better returnvalue for failed  comIF init

---
 devicehandlers/DeviceHandlerBase.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 9f4c7baf2..1e7ebf04d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -128,7 +128,9 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
-		return result;
+	    sif::error << "DeviceHandlerBase::initialize: Initializing "
+	            "communication interface failed!" << std::endl;
+	    return result;
 	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);

From 9acf82cf510be6dfd0f7e94601cdf4795213e5f4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Jul 2020 18:12:10 +0200
Subject: [PATCH 0597/1774] doc improved

---
 devicehandlers/DeviceHandlerBase.h | 2 ++
 devicehandlers/DeviceHandlerIF.h   | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index ddbf60410..632db5e09 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -379,6 +379,8 @@ protected:
 	 * @param deviceCommand	Identifier of the command to add.
 	 * @param maxDelayCycles The maximum number of delay cycles the command
 	 * waits until it times out.
+	 * @param replyLen Will be supplied to the requestReceiveMessage call of
+	 * the communication interface.
 	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
 	 * by the device repeatedly without request) or not. Default is aperiodic (0)
 	 * @return	- @c RETURN_OK when the command was successfully inserted,
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index cb1903444..593020808 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -98,7 +98,7 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 
 	// Standard codes used when building commands.
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If the command size is 0. Checked in DHB
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
 	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
 	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
 	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);

From 9fa9421ba58d4c6793aa19886ce6ee17e7f85d71 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Jul 2020 20:57:05 +0200
Subject: [PATCH 0598/1774] important bugfix

---
 fdir/FailureIsolationBase.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index 083f5af08..4df56dcdb 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -104,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;

From c64aa9f7f55e4afbc5f21cf149bfc71a889a06e5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Jul 2020 21:00:11 +0200
Subject: [PATCH 0599/1774] another important bugfix

---
 fdir/FailureIsolationBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index dea149bd3..6010baca8 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -45,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:

From 276c3b172e18df8b7f457e23fb43c22e9c332553 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 29 Jul 2020 15:32:36 +0200
Subject: [PATCH 0600/1774] better diagnostic warning for DHB

---
 devicehandlers/DeviceHandlerBase.cpp | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1e7ebf04d..a4346afbe 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -680,16 +680,24 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		switch (result) {
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
+			if(foundLen == 0) {
+			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+			            " Packet parsing will be stuck." << std::endl;
+			}
 			break;
 		case APERIODIC_REPLY: {
 			result = interpretDeviceReply(foundId, receivedData);
 			if (result != RETURN_OK) {
-				replyRawReplyIfnotWiretapped(receivedData, foundLen);
-				triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
-						foundId);
+			    replyRawReplyIfnotWiretapped(receivedData, foundLen);
+			    triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
+			            foundId);
 			}
+			if(foundLen == 0) {
+			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+			            " Packet parsing will be stuck." << std::endl;
+			}
+			break;
 		}
-		break;
 		case IGNORE_REPLY_DATA:
 			break;
 		case IGNORE_FULL_PACKET:

From 18899a4c828262258699d9c80beab12cd251b506 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 29 Jul 2020 20:07:24 +0200
Subject: [PATCH 0601/1774] hotfix for deadline checking

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 19 +++++++++----------
 osal/FreeRTOS/PeriodicTask.cpp      | 19 +++++++++----------
 2 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 630952d29..1dc45b1d2 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -125,19 +125,18 @@ void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
      * it. */
     TickType_t currentTickCount = xTaskGetTickCount();
     TickType_t timeToWake = xLastWakeTime + interval;
-    // Tick count has overflown
-    if(currentTickCount < xLastWakeTime) {
-        // Time to wake has overflown as well. If the tick count
-        // is larger than the time to wake, a deadline was missed.
-        if(timeToWake < xLastWakeTime and
-                currentTickCount > timeToWake) {
+    // Time to wake has not overflown.
+    if(timeToWake > xLastWakeTime) {
+        /* If the current time has overflown exclusively or the current
+         * tick count is simply larger than the time to wake, a deadline was
+         * missed */
+        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
             handleMissedDeadline();
         }
     }
-    // No tick count overflow. If the timeToWake has not overflown
-    // and the current tick count is larger than the time to wake,
-    // a deadline was missed.
-    else if(timeToWake > xLastWakeTime and currentTickCount > timeToWake) {
+    /* Time to wake has overflown. A deadline was missed if the current time
+     * is larger than the time to wake */
+    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
         handleMissedDeadline();
     }
 }
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index f960d8bbc..817cb06fb 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -109,19 +109,18 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
      * it. */
     TickType_t currentTickCount = xTaskGetTickCount();
     TickType_t timeToWake = xLastWakeTime + interval;
-    // Tick count has overflown
-    if(currentTickCount < xLastWakeTime) {
-        // Time to wake has overflown as well. If the tick count
-        // is larger than the time to wake, a deadline was missed.
-        if(timeToWake < xLastWakeTime and
-                currentTickCount > timeToWake) {
+    // Time to wake has not overflown.
+    if(timeToWake > xLastWakeTime) {
+        /* If the current time has overflown exclusively or the current
+         * tick count is simply larger than the time to wake, a deadline was
+         * missed */
+        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
             handleMissedDeadline();
         }
     }
-    // No tick count overflow. If the timeToWake has not overflown
-    // and the current tick count is larger than the time to wake,
-    // a deadline was missed.
-    else if(timeToWake > xLastWakeTime and currentTickCount > timeToWake) {
+    /* Time to wake has overflown. A deadline was missed if the current time
+     * is larger than the time to wake */
+    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
         handleMissedDeadline();
     }
 }

From 58a4f4f8a1d9608b671cd6fab087afea5d086dc1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 1 Aug 2020 16:39:17 +0200
Subject: [PATCH 0602/1774] command message bugfix, CSB improvement

parameter helper diagnostic message
---
 ipc/CommandMessage.cpp                 | 1 +
 parameters/ParameterHelper.cpp         | 7 ++++---
 parameters/ParameterHelper.h           | 6 ++++++
 tmtcservices/CommandingServiceBase.cpp | 8 ++++----
 4 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 8c296abdd..cc1185c7d 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -88,6 +88,7 @@ void CommandMessage::setToUnknownCommand() {
 
 void CommandMessage::setReplyRejected(ReturnValue_t reason,
         Command_t initialCommand) {
+	setCommand(REPLY_REJECTED);
     setParameter(reason);
     setParameter2(initialCommand);
 }
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index e40ed6756..53f1229ff 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -26,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(
@@ -34,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;
 		}
 
diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index 352cf0a9b..538aaac6f 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -5,6 +5,12 @@
 #include <framework/parameters/ParameterMessage.h>
 #include <framework/parameters/ReceivesParameterMessagesIF.h>
 
+/**
+ * @brief	Helper class to handle parameter messages
+ * @details
+ * This class simplfiies handling of parameter messages, which are sent
+ * to a class which implements ReceivesParameterMessagesIF.
+ */
 class ParameterHelper {
 public:
 	ParameterHelper(ReceivesParameterMessagesIF *owner);
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 4c9b5375c..80a280937 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -126,11 +126,11 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 			&nextCommand, iter->objectId, &isStep);
 
 	/* If the child implementation does not implement special handling for
-	 * rejected replies (RETURN_FAILED is returned), a failure verification
-	 * will be generated with the reason as the return code and the initial
-	 * command as failure parameter 1 */
+	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
+	 * failure verification will be generated with the reason as the
+	 * return code and the initial command as failure parameter 1 */
 	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
-			result == RETURN_FAILED) {
+			(result == RETURN_FAILED or result == INVALID_REPLY)) {
 	    result = reply->getReplyRejectedReason();
 	    failureParameter1 = iter->command;
 	}

From 66eac57e3bb77c73a4030d1320a64b42e5841641 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 1 Aug 2020 16:54:54 +0200
Subject: [PATCH 0603/1774] csb update

---
 tmtcservices/CommandingServiceBase.cpp |  6 +++---
 tmtcservices/CommandingServiceBase.h   | 17 ++++++++---------
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 80a280937..330fd00f6 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -129,7 +129,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
 	 * failure verification will be generated with the reason as the
 	 * return code and the initial command as failure parameter 1 */
-	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
+	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
 			(result == RETURN_FAILED or result == INVALID_REPLY)) {
 	    result = reply->getReplyRejectedReason();
 	    failureParameter1 = iter->command;
@@ -230,8 +230,8 @@ void CommandingServiceBase::handleRequestQueue() {
 		address = message.getStorageId();
 		packet.setStoreAddress(address);
 
-		if (packet.getSubService() == 0
-				or isValidSubservice(packet.getSubService()) != RETURN_OK) {
+		if ((packet.getSubService() == 0)
+				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
 			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
 			continue;
 		}
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 1bd18571e..b3a15985e 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -87,7 +87,7 @@ public:
 	 * @param opCode is unused here at the moment
 	 * @return RETURN_OK
 	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode);
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
 	virtual uint16_t getIdentifier();
 
@@ -116,7 +116,7 @@ public:
 	 * Used to setup the reference of the task, that executes this component
 	 * @param task Pointer to the taskIF of this task
 	 */
-	virtual void setTaskIF(PeriodicTaskIF* task);
+	virtual void setTaskIF(PeriodicTaskIF* task) override;
 
 protected:
 	/**
@@ -173,9 +173,7 @@ protected:
 	 * This function is implemented by child services to specify how replies
 	 * to a command from another software component are handled.
 	 * @param reply
-	 * This is the reply which can be accessed via the command message
-	 * interface. The internal message pointer can be passed to different
-	 * command message implementations (see CommandMessageIF)
+	 * This is the reply in form of a generic read-only command message.
 	 * @param previousCommand
 	 * Command_t of related command
 	 * @param state [out/in]
@@ -189,10 +187,11 @@ protected:
 	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
 	 *   generate TC verification success
 	 * - @c INVALID_REPLY Calls handleUnrequestedReply
-	 * - Anything else triggers a TC verification failure. If RETURN_FAILED
-	 *   is returned and the command ID is CommandMessage::REPLY_REJECTED,
-	 *   a failure verification message with the reason as the error parameter
-	 *   and the initial command as failure parameter 1.
+	 * - Anything else triggers a TC verification failure. If RETURN_FAILED or
+	 * 	 INVALID_REPLY is returned and the command ID is
+	 * 	 CommandMessage::REPLY_REJECTED, a failure verification message with
+	 * 	 the reason as the error parameter and the initial command as
+	 * 	 failure parameter 1 is generated.
 	 */
 	virtual ReturnValue_t handleReply(const CommandMessage* reply,
 			Command_t previousCommand, uint32_t *state,

From ebf5d41a7880f4c866fa1eb29113ecc960bd0efc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 1 Aug 2020 19:03:03 +0200
Subject: [PATCH 0604/1774] parameters IF doc and improvement

---
 parameters/HasParametersIF.h    | 19 +++++--
 parameters/ParameterWrapper.cpp | 24 ++++-----
 parameters/ParameterWrapper.h   | 91 +++++++++++++++++++++------------
 3 files changed, 84 insertions(+), 50 deletions(-)

diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index fbb694454..02f363184 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -5,8 +5,23 @@
 #include <framework/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
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 7daf738c2..521a6644c 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -1,20 +1,19 @@
 #include <framework/parameters/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() {
@@ -266,15 +265,14 @@ 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);
+			uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
+			std::memcpy(typedData +  offset, from->readonlyData,
+					typeSize * from->columns);
 		}
 	}
 
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index a00c997cc..eec101f27 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -1,5 +1,5 @@
-#ifndef PARAMETERWRAPPER_H_
-#define PARAMETERWRAPPER_H_
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
+#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serialize/SerializeAdapter.h>
@@ -7,6 +7,10 @@
 #include <stddef.h>
 #include <framework/globalfunctions/Type.h>
 
+/**
+ * @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);
 };
 
+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 /* PARAMETERWRAPPER_H_ */

From f240827bbdd9ad7542e21ca5810235e6acb20c96 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 00:59:19 +0200
Subject: [PATCH 0605/1774] added getFreeElement

---
 container/SimpleRingBuffer.h | 33 ++++++++++++++++++++++++++++-----
 1 file changed, 28 insertions(+), 5 deletions(-)

diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index cf78814f7..9a5488153 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -16,12 +16,17 @@ class SimpleRingBuffer: public RingBufferBase<> {
 public:
     /**
      * This constructor allocates a new internal buffer with the supplied size.
+     *
      * @param size
-     * @param overwriteOld
-     * If the ring buffer is overflowing at a write operartion, the oldest data
-     * will be overwritten.
+     * @param overwriteOld If the ring buffer is overflowing at a write
+     * operation, the oldest data will be overwritten.
+     * @param maxExcessBytes These additional bytes will be allocated in addtion
+     * to the specified size to accomodate contiguous write operations
+     * with getFreeElement.
+     *
      */
-	SimpleRingBuffer(const size_t size, bool overwriteOld);
+	SimpleRingBuffer(const size_t size, bool overwriteOld,
+	        size_t maxExcessBytes = 0);
 	/**
 	 * This constructor takes an external buffer with the specified size.
 	 * @param buffer
@@ -29,8 +34,13 @@ public:
 	 * @param overwriteOld
 	 * If the ring buffer is overflowing at a write operartion, the oldest data
      * will be overwritten.
+	 * @param maxExcessBytes
+	 * If the buffer can accomodate additional bytes for contigous write
+	 * operations with getFreeElement, this is the maximum allowed additional
+	 * size
 	 */
-	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld);
+	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
+	        size_t maxExcessBytes = 0);
 
 	virtual ~SimpleRingBuffer();
 
@@ -43,6 +53,17 @@ public:
 	 */
 	ReturnValue_t writeData(const uint8_t* data, size_t amount);
 
+	/**
+	 * Returns a pointer to a free element. If the remaining buffer is
+	 * not large enough, the data will be written past the actual size
+	 * and the amount of excess bytes will be cached.
+	 * @param writePointer Pointer to a pointer which can be used to write
+	 * contiguous blocks into the ring buffer
+	 * @param amount
+	 * @return
+	 */
+	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
+
 	/**
 	 * Read from circular buffer at read pointer.
 	 * @param data
@@ -82,6 +103,8 @@ public:
 private:
 	static const uint8_t READ_PTR = 0;
 	uint8_t* buffer = nullptr;
+	const size_t maxExcessBytes;
+	size_t excessBytes = 0;
 };
 
 #endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */

From 0ead44bea976bba70676fc40ed9716f2ae6b84d8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 01:07:59 +0200
Subject: [PATCH 0606/1774] getFreeElement implemented

---
 container/SimpleRingBuffer.cpp | 44 ++++++++++++++++++++++++++++++----
 container/SimpleRingBuffer.h   |  8 +++++++
 2 files changed, 47 insertions(+), 5 deletions(-)

diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 69d94143e..3cc1ffdf9 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -1,20 +1,43 @@
 #include <framework/container/SimpleRingBuffer.h>
 #include <cstring>
 
-SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld) :
-		RingBufferBase<>(0, size, overwriteOld) {
-	buffer = new uint8_t[size];
+SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
+        size_t maxExcessBytes) :
+		RingBufferBase<>(0, size, overwriteOld),
+		maxExcessBytes(maxExcessBytes) {
+	buffer = new uint8_t[size + maxExcessBytes];
 }
 
 SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
-        bool overwriteOld):
-        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {}
+        bool overwriteOld, size_t maxExcessBytes):
+        RingBufferBase<>(0, size, overwriteOld), buffer(buffer),
+        maxExcessBytes(maxExcessBytes) {}
 
 
 SimpleRingBuffer::~SimpleRingBuffer() {
 	delete[] buffer;
 }
 
+
+ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
+        size_t amount) {
+    if (availableWriteSpace() >= amount or overwriteOld) {
+        size_t amountTillWrap = writeTillWrap();
+        if (amountTillWrap < amount) {
+            if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
+                return HasReturnvaluesIF::RETURN_FAILED;
+            }
+            excessBytes += amount - amountTillWrap;
+        }
+        *writePointer = &buffer[write];
+        incrementWrite(amount);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+}
+
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
 		size_t amount) {
 	if (availableWriteSpace() >= amount or overwriteOld) {
@@ -62,6 +85,17 @@ ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+size_t SimpleRingBuffer::getExcessBytes() const {
+    return excessBytes;
+}
+
+void SimpleRingBuffer::moveExcessBytesToStart() {
+    if(excessBytes > 0) {
+        std::memcpy(buffer, &buffer[size], excessBytes);
+        excessBytes = 0;
+    }
+}
+
 ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
 		bool deleteRemaining, size_t* trueAmount) {
 	size_t availableData = availableReadData(READ_PTR);
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 9a5488153..4bb3a4e8b 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -64,6 +64,14 @@ public:
 	 */
 	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
 
+	size_t getExcessBytes() const;
+	/**
+	 * Helper functions which moves any excess bytes to the start
+	 * of the ring buffer.
+	 * @return
+	 */
+	void moveExcessBytesToStart();
+
 	/**
 	 * Read from circular buffer at read pointer.
 	 * @param data

From 4e9e465360b2b4757699e79b265c12358ac5e8db Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 02:00:00 +0200
Subject: [PATCH 0607/1774] shared ring buffer continued

---
 container/SimpleRingBuffer.cpp | 20 ++++++++++++++++----
 container/SimpleRingBuffer.h   |  2 +-
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 3cc1ffdf9..cad1a48e9 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -2,16 +2,28 @@
 #include <cstring>
 
 SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
-        size_t maxExcessBytes) :
+		size_t maxExcessBytes) :
 		RingBufferBase<>(0, size, overwriteOld),
 		maxExcessBytes(maxExcessBytes) {
+	if(maxExcessBytes > size) {
+		this->maxExcessBytes = size;
+	}
+	else {
+		this->maxExcessBytes = maxExcessBytes;
+	}
 	buffer = new uint8_t[size + maxExcessBytes];
 }
 
 SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
-        bool overwriteOld, size_t maxExcessBytes):
-        RingBufferBase<>(0, size, overwriteOld), buffer(buffer),
-        maxExcessBytes(maxExcessBytes) {}
+		bool overwriteOld, size_t maxExcessBytes):
+        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
+	if(maxExcessBytes > size) {
+		this->maxExcessBytes = size;
+	}
+	else {
+		this->maxExcessBytes = maxExcessBytes;
+	}
+}
 
 
 SimpleRingBuffer::~SimpleRingBuffer() {
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 4bb3a4e8b..2627541f1 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -111,7 +111,7 @@ public:
 private:
 	static const uint8_t READ_PTR = 0;
 	uint8_t* buffer = nullptr;
-	const size_t maxExcessBytes;
+	size_t maxExcessBytes;
 	size_t excessBytes = 0;
 };
 

From 6b475792a4a7c57a5006a010c554dda8b31d41b7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 02:25:10 +0200
Subject: [PATCH 0608/1774] shared ring buffer continued

---
 container/SharedRingBuffer.cpp | 19 +++++++++++++------
 container/SharedRingBuffer.h   |  9 +++++++--
 2 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 64cbc6691..86277a80e 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -3,19 +3,26 @@
 #include <framework/ipc/MutexHelper.h>
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		bool overwriteOld, dur_millis_t mutexTimeout):
-		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld),
-		mutexTimeout(mutexTimeout) {
+		bool overwriteOld, size_t maxExcessBytes, dur_millis_t mutexTimeout):
+		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
+		maxExcessBytes), mutexTimeout(mutexTimeout) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
-		const size_t size, bool overwriteOld, dur_millis_t mutexTimeout):
-		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld),
-		mutexTimeout(mutexTimeout) {
+		const size_t size, bool overwriteOld, size_t maxExcessBytes,
+		dur_millis_t mutexTimeout):
+		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
+		maxExcessBytes), mutexTimeout(mutexTimeout) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
+ReturnValue_t SharedRingBuffer::getFreeElementProtected(uint8_t** writePtr,
+		size_t amount) {
+	MutexHelper(mutex, mutexTimeout);
+	return SimpleRingBuffer::getFreeElement(writePtr,amount);
+}
+
 ReturnValue_t SharedRingBuffer::writeDataProtected(const uint8_t *data,
 		size_t amount) {
 	MutexHelper(mutex, mutexTimeout);
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index f7d3bc3cc..7fed7b221 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -17,7 +17,8 @@ public:
 	 * will be overwritten.
 	 */
 	SharedRingBuffer(object_id_t objectId, const size_t size,
-			bool overwriteOld, dur_millis_t mutexTimeout = 10);
+			bool overwriteOld, size_t maxExcessBytes,
+			dur_millis_t mutexTimeout = 10);
 
 	/**
 	 * This constructor takes an external buffer with the specified size.
@@ -28,10 +29,14 @@ public:
 	 * will be overwritten.
 	 */
 	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
-			bool overwriteOld, dur_millis_t mutexTimeout = 10);
+			bool overwriteOld, size_t maxExcessBytes,
+			dur_millis_t mutexTimeout = 10);
 
 	void setMutexTimeout(dur_millis_t newTimeout);
 
+	/** Performs mutex protected SimpleRingBuffer::getFreeElement call */
+	ReturnValue_t getFreeElementProtected(uint8_t** writePtr, size_t amount);
+
 	/** Performs mutex protected SimpleRingBuffer::writeData call */
 	ReturnValue_t writeDataProtected(const uint8_t* data, size_t amount);
 

From 4dcfa5125edf80f2bc6bde7861e1da394b4d7a4e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 11:47:47 +0200
Subject: [PATCH 0609/1774] added additional calls

---
 container/SharedRingBuffer.cpp | 10 ++++++++++
 container/SharedRingBuffer.h   |  8 ++++++++
 container/SimpleRingBuffer.cpp |  2 +-
 container/SimpleRingBuffer.h   |  4 ++--
 4 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 86277a80e..2fde2851b 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -43,6 +43,16 @@ ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
 	return SimpleRingBuffer::deleteData(amount, deleteRemaining, trueAmount);
 }
 
+size_t SharedRingBuffer::getExcessBytes() const {
+	MutexHelper(mutex, mutexTimeout);
+	return SimpleRingBuffer::getExcessBytes();
+}
+
+void SharedRingBuffer::moveExcessBytesToStart() {
+	MutexHelper(mutex, mutexTimeout);
+	return SimpleRingBuffer::moveExcessBytesToStart();
+}
+
 size_t SharedRingBuffer::getAvailableReadDataProtected(uint8_t n) const {
 	MutexHelper(mutex, mutexTimeout);
 	return ((write + size) - read[n]) % size;
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 7fed7b221..8d68b9678 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -34,6 +34,14 @@ public:
 
 	void setMutexTimeout(dur_millis_t newTimeout);
 
+	virtual size_t getExcessBytes() const override;
+	/**
+	 * Helper functions which moves any excess bytes to the start
+	 * of the ring buffer.
+	 * @return
+	 */
+	virtual void moveExcessBytesToStart() override;
+
 	/** Performs mutex protected SimpleRingBuffer::getFreeElement call */
 	ReturnValue_t getFreeElementProtected(uint8_t** writePtr, size_t amount);
 
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index cad1a48e9..368808133 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -39,7 +39,7 @@ ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
             if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
                 return HasReturnvaluesIF::RETURN_FAILED;
             }
-            excessBytes += amount - amountTillWrap;
+            excessBytes = amount - amountTillWrap;
         }
         *writePointer = &buffer[write];
         incrementWrite(amount);
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 2627541f1..0784e4152 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -64,13 +64,13 @@ public:
 	 */
 	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
 
-	size_t getExcessBytes() const;
+	virtual size_t getExcessBytes() const;
 	/**
 	 * Helper functions which moves any excess bytes to the start
 	 * of the ring buffer.
 	 * @return
 	 */
-	void moveExcessBytesToStart();
+	virtual void moveExcessBytesToStart();
 
 	/**
 	 * Read from circular buffer at read pointer.

From 2177877625aa1543c585504505b55b49fd1c2904 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 15:16:09 +0200
Subject: [PATCH 0610/1774] updated framework subsystem ID ranges

---
 events/fwSubsystemIdRanges.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/events/fwSubsystemIdRanges.h b/events/fwSubsystemIdRanges.h
index 4c261e57a..a05652c22 100644
--- a/events/fwSubsystemIdRanges.h
+++ b/events/fwSubsystemIdRanges.h
@@ -18,6 +18,8 @@ enum {
 	SYSTEM_MANAGER = 74,
 	SYSTEM_MANAGER_1 = 75,
 	SYSTEM_1 = 79,
+	PUS_SERVICE_1 = 80,
+	FW_SUBSYSTEM_ID_RANGE
 };
 }
 

From 4d3f0875c18a69147c18f99d401175e5b64c361f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 15:23:37 +0200
Subject: [PATCH 0611/1774] periodic task if adapted

---
 osal/FreeRTOS/PeriodicTask.cpp   |  7 ++-----
 osal/FreeRTOS/PeriodicTask.h     |  3 +--
 osal/linux/PeriodicPosixTask.cpp | 11 +++--------
 osal/linux/PeriodicPosixTask.h   |  3 +--
 tasks/PeriodicTaskIF.h           |  3 +--
 5 files changed, 8 insertions(+), 19 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 817cb06fb..cc29edae5 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -90,12 +90,9 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
+	newObject->setTaskIF(this);
 
-	if(setTaskIF) {
-	     newObject->setTaskIF(this);
-	}
-	ReturnValue_t result = newObject->initializeAfterTaskCreation();
-	return result;
+	return newObject->initializeAfterTaskCreation();
 }
 
 uint32_t PeriodicTask::getPeriodMs() const {
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index ca2c53240..2be2521ca 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -65,8 +65,7 @@ public:
 	 * -@c RETURN_OK on success
 	 * -@c RETURN_FAILED if the object could not be added.
 	 */
-	ReturnValue_t addComponent(object_id_t object,
-	        bool setTaskIF = true) override;
+	ReturnValue_t addComponent(object_id_t object) override;
 
 	uint32_t getPeriodMs() const override;
 
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index 4b0c77fc8..cd487531d 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -22,8 +22,7 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
 	return NULL;
 }
 
-ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
-		bool setTaskIF) {
+ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
@@ -32,13 +31,9 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
+	newObject->setTaskIF(this);
 
-	if(setTaskIF) {
-	    newObject->setTaskIF(this);
-	}
-
-	ReturnValue_t result = newObject->initializeAfterTaskCreation();
-	return result;
+	return newObject->initializeAfterTaskCreation();
 }
 
 ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 9b477e36d..0b2d51cdd 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -39,8 +39,7 @@ public:
 	 * @param object Id of the object to add.
 	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
 	 */
-	ReturnValue_t addComponent(object_id_t object,
-	        bool setTaskIF = true) override;
+	ReturnValue_t addComponent(object_id_t object) override;
 
 	uint32_t getPeriodMs() const override;
 
diff --git a/tasks/PeriodicTaskIF.h b/tasks/PeriodicTaskIF.h
index 6f4909771..f54d61557 100644
--- a/tasks/PeriodicTaskIF.h
+++ b/tasks/PeriodicTaskIF.h
@@ -36,8 +36,7 @@ public:
 	 * to the component.
 	 * @return
 	 */
-	virtual ReturnValue_t addComponent(object_id_t object,
-	        bool setTaskIF = true) {
+	virtual ReturnValue_t addComponent(object_id_t object) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
 

From 3f87537c6106feb54ab0151247be0ad300a88580 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 15:25:24 +0200
Subject: [PATCH 0612/1774] minor corrections

---
 osal/FreeRTOS/PeriodicTask.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index cc29edae5..f2dcd093f 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -81,7 +81,7 @@ void PeriodicTask::taskFunctionality() {
 	}
 }
 
-ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
+ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {

From c4ffb1acd5bff2a8214ddb9f4336d081b3f84636 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 18:12:15 +0200
Subject: [PATCH 0613/1774] subservice number correction

---
 pus/servicepackets/Service1Packets.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index b01942c6e..4a2c7cbc6 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -16,7 +16,7 @@
  * @brief 	Subservice 1, 3, 5, 7
  * @ingroup spacepackets
  */
-class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
+class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
 public:
 	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
 			uint16_t packetSequenceControl_, uint8_t stepNumber_,
@@ -111,7 +111,7 @@ private:
  * @brief       Subservices 2, 4, 6, 8
  * @ingroup     spacepackets
  */
-class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
+class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
 public:
 	SuccessReport(uint8_t subtype_, uint16_t packetId_,
 			uint16_t packetSequenceControl_,uint8_t stepNumber_) :

From 66039bd3feb553e913fe8440a48e09c1b8843166 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 18:14:39 +0200
Subject: [PATCH 0614/1774] move group def down

---
 pus/servicepackets/Service1Packets.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index 4a2c7cbc6..4ba493d08 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -1,3 +1,9 @@
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/tmtcservices/VerificationCodes.h>
+
 /**
  * @defgroup spacepackets PUS Packet Definitions
  *  This group contains all implemented TM or TM packages that are sent to
@@ -5,12 +11,6 @@
  *  packet structures in Mission Information Base (MIB).
  */
 
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-
 /**
  * @brief 	FailureReport class to serialize a failure report
  * @brief 	Subservice 1, 3, 5, 7

From 1a118fe215350eb321184bae30777278095cb1c7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 19:21:47 +0200
Subject: [PATCH 0615/1774] added documentation to assembly base

---
 devicehandlers/AssemblyBase.cpp |  5 +-
 devicehandlers/AssemblyBase.h   | 85 ++++++++++++++++++++++-----------
 subsystem/SubsystemBase.cpp     | 10 ++--
 3 files changed, 65 insertions(+), 35 deletions(-)

diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index bd85d1de5..f56573278 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -165,9 +165,8 @@ ReturnValue_t AssemblyBase::checkChildrenState() {
 }
 
 ReturnValue_t AssemblyBase::checkChildrenStateOff() {
-	for (std::map<object_id_t, ChildInfo>::iterator iter = childrenMap.begin();
-			iter != childrenMap.end(); iter++) {
-		if (checkChildOff(iter->first) != RETURN_OK) {
+	for (const auto& childIter: childrenMap) {
+		if (checkChildOff(childIter.first) != RETURN_OK) {
 			return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
 		}
 	}
diff --git a/devicehandlers/AssemblyBase.h b/devicehandlers/AssemblyBase.h
index ee1210324..d0dc868c9 100644
--- a/devicehandlers/AssemblyBase.h
+++ b/devicehandlers/AssemblyBase.h
@@ -1,10 +1,30 @@
-#ifndef ASSEMBLYBASE_H_
-#define ASSEMBLYBASE_H_
+#ifndef FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
+#define FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
 
 #include <framework/container/FixedArrayList.h>
 #include <framework/devicehandlers/DeviceHandlerBase.h>
 #include <framework/subsystem/SubsystemBase.h>
 
+/**
+ * @brief   Base class to implement reconfiguration and failure handling for
+ *          redundant devices by monitoring their modes health states.
+ * @details
+ * Documentation: Dissertation Baetz p.156, 157.
+ *
+ * This class reduces the complexity of controller components which would
+ * otherwise be needed for the handling of redundant devices.
+ *
+ * The template class monitors mode and health state of its children
+ * and checks availability of devices on every detected change.
+ * AssemblyBase does not implement any redundancy logic by itself, but provides
+ * adaptation points for implementations to do so. Since most monitoring
+ * activities rely on mode and health state only and are therefore
+ * generic, it is sufficient for subclasses to provide:
+ *
+ * 1. check logic when active-> checkChildrenStateOn
+ * 2. transition logic to change the mode -> commandChildren
+ *
+ */
 class AssemblyBase: public SubsystemBase {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ASSEMBLY_BASE;
@@ -16,10 +36,41 @@ public:
 	static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE =
 			MAKE_RETURN_CODE(0xa1);
 
-	AssemblyBase(object_id_t objectId, object_id_t parentId, uint16_t commandQueueDepth = 8);
+	AssemblyBase(object_id_t objectId, object_id_t parentId,
+	        uint16_t commandQueueDepth = 8);
 	virtual ~AssemblyBase();
 
 protected:
+
+    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
+    // (or return internalState directly?)
+    /**
+     * Command children to reach [mode,submode] combination
+     * Can be done by setting #commandsOutstanding correctly,
+     * or using executeTable()
+     * @param mode
+     * @param submode
+     * @return
+     *    - @c RETURN_OK if ok
+     *    - @c NEED_SECOND_STEP if children need to be commanded again
+     */
+    virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
+
+    /**
+     * Check whether desired assembly mode was achieved by checking the modes
+     * or/and health states of child device handlers.
+     * The assembly template class will also call this function if a health
+     * or mode change of a child device handler was detected.
+     * @param wantedMode
+     * @param wantedSubmode
+     * @return
+     */
+    virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
+            Submode_t wantedSubmode) = 0;
+
+    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+            Submode_t submode) = 0;
+
 	enum InternalState {
 		STATE_NONE,
 		STATE_OVERWRITE_HEALTH,
@@ -36,6 +87,7 @@ protected:
 		RECOVERY_WAIT
 	} recoveryState; //!< Indicates if one of the children requested a recovery.
 	ChildrenMap::iterator recoveringDevice;
+
 	/**
 	 * the mode the current transition is trying to achieve.
 	 * Can be different from the modehelper.commandedMode!
@@ -61,8 +113,8 @@ protected:
 	bool handleChildrenChanged();
 
 	/**
-	 * This method is called if the children changed its mode in a way that the current
-	 * mode can't be kept.
+	 * This method is called if the children changed its mode in a way that
+	 * the current mode can't be kept.
 	 * Default behavior is to go to MODE_OFF.
 	 * @param result The failure code which was returned by checkChildrenState.
 	 */
@@ -75,9 +127,6 @@ protected:
 	ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
 			uint32_t *msToReachTheMode);
 
-	virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
-			Submode_t submode) = 0;
-
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 
 	virtual void doStartTransition(Mode_t mode, Submode_t submode);
@@ -90,24 +139,6 @@ protected:
 
 	void sendHealthCommand(MessageQueueId_t sendTo, HealthState health);
 
-	//SHOULDDO: Change that OVERWRITE_HEALTH may be returned (or return internalState directly?)
-	/**
-	 * command children to reach mode,submode
-	 *
-	 * set #commandsOutstanding correctly, or use executeTable()
-	 *
-	 * @param mode
-	 * @param submode
-	 * @return
-	 *    - @c RETURN_OK if ok
-	 *    - @c NEED_SECOND_STEP if children need to be commanded again
-	 */
-	virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
-
-	//SHOULDDO: Remove wantedMode, wantedSubmode, as targetMode/submode is available?
-	virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
-			Submode_t wantedSubmode) = 0;
-
 	virtual ReturnValue_t checkChildrenStateOff();
 
 	ReturnValue_t checkChildrenState();
@@ -129,4 +160,4 @@ protected:
 
 };
 
-#endif /* ASSEMBLYBASE_H_ */
+#endif /* FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 737accefd..51c35f1f2 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -5,9 +5,9 @@
 
 SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
 		Mode_t initialMode, uint16_t commandQueueDepth) :
-		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE), childrenChangedMode(
-		false), commandsOutstanding(0), commandQueue(NULL), healthHelper(this,
-				setObjectId), modeHelper(this), parentId(parent) {
+		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
+		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
+		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
 			MessageQueueMessage::MAX_MESSAGE_SIZE);
 }
@@ -23,8 +23,8 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
 	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
 	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
 	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
-	if (child == NULL) {
-		if (healthChild == NULL) {
+	if (child == nullptr) {
+		if (healthChild == nullptr) {
 			return CHILD_DOESNT_HAVE_MODES;
 		} else {
 			info.commandQueue = healthChild->getCommandQueue();

From bfecbfbd80a9f64f84b55246b742c07bf1beccf9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 20:36:37 +0200
Subject: [PATCH 0616/1774] implemented new mutex interface

---
 datapoolglob/GlobalDataPool.cpp |  3 ++-
 datapoollocal/LocalDataSet.cpp  |  2 +-
 ipc/MutexHelper.h               |  3 ++-
 ipc/MutexIF.h                   | 37 ++++++++++++++++++---------------
 osal/FreeRTOS/Mutex.cpp         | 15 +++++++------
 osal/FreeRTOS/Mutex.h           |  3 ++-
 osal/linux/Mutex.cpp            | 12 ++++++++---
 osal/linux/Mutex.h              |  2 +-
 subsystem/SubsystemBase.cpp     |  5 +++--
 9 files changed, 47 insertions(+), 35 deletions(-)

diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
index 25acaab3f..9dedb4b8a 100644
--- a/datapoolglob/GlobalDataPool.cpp
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -54,7 +54,8 @@ ReturnValue_t GlobalDataPool::unlockDataPool() {
 }
 
 ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
-	ReturnValue_t status = mutex->lockMutex(timeoutMs);
+	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
+	        timeoutMs);
 	if(status != RETURN_OK) {
 		sif::error << "DataPool::DataPool: lock of mutex failed "
 				"with error code: " << status << std::endl;
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 2a42cd387..8725f6972 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -38,7 +38,7 @@ LocalDataSet::~LocalDataSet() {
 
 ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
 	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(timeoutMs);
+	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
 }
 
 ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index c9579e9b6..fc6e38bfe 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -8,7 +8,8 @@ class MutexHelper {
 public:
 	MutexHelper(MutexIF* mutex, uint32_t timeoutMs) :
 			internalMutex(mutex) {
-		ReturnValue_t status = mutex->lockMutex(timeoutMs);
+		ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
+		        timeoutMs);
 		if(status == MutexIF::MUTEX_TIMEOUT) {
 			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
 					<< timeoutMs << " milliseconds!" << std::endl;
diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 29e59e588..b174fe0da 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -12,20 +12,25 @@
  */
 class MutexIF {
 public:
-	/**
-	 * @brief 	Timeout value used for polling lock attempt.
-	 * @details
-	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
-	 * immediately. Value needs to be defined in implementation.
-	 */
-	static const uint32_t POLLING;
-	/**
-	 * @brief 	Timeout value used for permanent blocking lock attempt.
-	 * @details
-	 * The task will be blocked (indefinitely) until the mutex is unlocked.
-	 * Value needs to be defined in implementation.
-	 */
-	static const uint32_t BLOCKING;
+    /**
+     * Different types of timeout for the mutex lock.
+     */
+    enum TimeoutType {
+        POLLING, //!< If mutex is not available, return immediately
+        WAITING, //!< Wait a specified time for the mutex to become available
+        BLOCKING //!< Block indefinitely until the mutex becomes available.
+    };
+
+    /**
+     * Lock the mutex.
+     * @param timeoutType
+     * @param timeoutMs
+     * This value will only be used for TimeoutType::WAIT
+     * @return
+     */
+    virtual ReturnValue_t lockMutex(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
+    virtual ReturnValue_t unlockMutex() = 0;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
 	/**
@@ -77,9 +82,7 @@ public:
 	 */
 	static const ReturnValue_t MUTEX_DESTROYED_WHILE_WAITING = MAKE_RETURN_CODE(12);
 
-	virtual ~MutexIF() {}
-	virtual ReturnValue_t lockMutex(uint32_t timeoutMs) = 0;
-	virtual ReturnValue_t unlockMutex() = 0;
+    virtual ~MutexIF() {}
 };
 
 
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 8a5c444dd..764b0ae09 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -2,9 +2,6 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t MutexIF::POLLING = 0;
-const uint32_t MutexIF::BLOCKING = portMAX_DELAY;
-
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
 	if(handle == nullptr) {
@@ -19,15 +16,17 @@ Mutex::~Mutex() {
 
 }
 
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
 	if (handle == nullptr) {
 		return MutexIF::MUTEX_NOT_FOUND;
 	}
-	TickType_t timeout = MutexIF::POLLING;
-	if(timeoutMs == MutexIF::BLOCKING) {
-		timeout = MutexIF::BLOCKING;
+	// If the timeout type is BLOCKING, this will be the correct value.
+	uint32_t timeout = portMAX_DELAY;
+	if(timeoutType == TimeoutType::POLLING) {
+		timeout = 0;
 	}
-	else if(timeoutMs > MutexIF::POLLING){
+	else if(timeoutType == TimeoutType::WAITING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 37f1791c4..2a4fae26d 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -18,7 +18,8 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
+	ReturnValue_t lockMutex(TimeoutType timeoutType,
+	        uint32_t timeoutMs) override;
 	ReturnValue_t unlockMutex() override;
 
 private:
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index bdcf34390..c99fe531d 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -40,9 +40,13 @@ Mutex::~Mutex() {
 	pthread_mutex_destroy(&mutex);
 }
 
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
 	int status = 0;
-	if (timeoutMs != MutexIF::BLOCKING) {
+
+	if(timeoutType == TimeoutType::POLLING) {
+	    status = pthread_mutex_trylock(&mutex);
+	}
+	else if (timeoutType == TimeoutType::WAITING) {
 		timespec timeOut;
 		clock_gettime(CLOCK_REALTIME, &timeOut);
 		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
@@ -50,9 +54,11 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 		timeOut.tv_sec = nseconds / 1000000000;
 		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
 		status = pthread_mutex_timedlock(&mutex, &timeOut);
-	} else {
+	}
+	else if(timeoutType == TimeoutType::BLOCKING) {
 		status = pthread_mutex_lock(&mutex);
 	}
+
 	switch (status) {
 	case EINVAL:
 		//The mutex was created with the protocol attribute having the value PTHREAD_PRIO_PROTECT and the calling thread's priority is higher than the mutex's current priority ceiling.
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index 607337aea..26420c2eb 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -12,7 +12,7 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	virtual ~Mutex();
-	virtual ReturnValue_t lockMutex(uint32_t timeoutMs);
+	virtual ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs);
 	virtual ReturnValue_t unlockMutex();
 private:
 	pthread_mutex_t mutex;
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 51c35f1f2..71fa81b75 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -76,14 +76,15 @@ ReturnValue_t SubsystemBase::checkStateAgainstTable(
 	return RETURN_OK;
 }
 
-void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
+void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
+        Submode_t targetSubmode) {
 	CommandMessage command;
 
 	std::map<object_id_t, ChildInfo>::iterator iter;
 
 	commandsOutstanding = 0;
 
-	for (; tableIter.value != NULL; ++tableIter) {
+	for (; tableIter.value != nullptr; ++tableIter) {
 		object_id_t object = tableIter.value->getObject();
 		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
 			//illegal table entry, should only happen due to misconfigured mode table

From 37f2539d894b8f1e9b85fd29005032c9bd4ba12a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 20:44:40 +0200
Subject: [PATCH 0617/1774] empty line removed

---
 ipc/MutexIF.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index b174fe0da..0d0cb444e 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -5,7 +5,6 @@
 
 /**
  * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
- *
  * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
  * @ingroup osal
  * @ingroup interface

From e3d094b2dec8ddc838a0f70218b0200b8c1b1ce4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 22:02:23 +0200
Subject: [PATCH 0618/1774] linux: removed old static timeout values

---
 osal/linux/Mutex.cpp | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index c99fe531d..03789e625 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -2,8 +2,6 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/timemanager/Clock.h>
 
-const uint32_t MutexIF::BLOCKING = 0xffffffff;
-const uint32_t MutexIF::POLLING = 0;
 uint8_t Mutex::count = 0;
 
 
@@ -61,22 +59,28 @@ ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
 
 	switch (status) {
 	case EINVAL:
-		//The mutex was created with the protocol attribute having the value PTHREAD_PRIO_PROTECT and the calling thread's priority is higher than the mutex's current priority ceiling.
+		// The mutex was created with the protocol attribute having the value
+		// PTHREAD_PRIO_PROTECT and the calling thread's priority is higher
+		// than the mutex's current priority ceiling.
 		return WRONG_ATTRIBUTE_SETTING;
-		//The process or thread would have blocked, and the abs_timeout parameter specified a nanoseconds field value less than zero or greater than or equal to 1000 million.
-		//The value specified by mutex does not refer to an initialized mutex object.
+		// The process or thread would have blocked, and the abs_timeout
+		// parameter specified a nanoseconds field value less than zero or
+		// greater than or equal to 1000 million.
+		// The value specified by mutex does not refer to an initialized mutex object.
 		//return MUTEX_NOT_FOUND;
 	case EBUSY:
-		//The mutex could not be acquired because it was already locked.
+		// The mutex could not be acquired because it was already locked.
 		return MUTEX_ALREADY_LOCKED;
 	case ETIMEDOUT:
-		//The mutex could not be locked before the specified timeout expired.
+		// The mutex could not be locked before the specified timeout expired.
 		return MUTEX_TIMEOUT;
 	case EAGAIN:
-		//The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded.
+		// The mutex could not be acquired because the maximum number of
+		// recursive locks for mutex has been exceeded.
 		return MUTEX_MAX_LOCKS;
 	case EDEADLK:
-		//A deadlock condition was detected or the current thread already owns the mutex.
+		// A deadlock condition was detected or the current thread
+		// already owns the mutex.
 		return CURR_THREAD_ALREADY_OWNS_MUTEX;
 	case 0:
 		//Success

From 44b70b45e216600bf5cfdca4899166f6bad0fd41 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 22:06:20 +0200
Subject: [PATCH 0619/1774] little doc correction

---
 ipc/MutexIF.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 0d0cb444e..b0096a343 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -21,10 +21,10 @@ public:
     };
 
     /**
-     * Lock the mutex.
+     * Lock the mutex. The timeout value will only be used for
+     * TimeoutType::WAITING
      * @param timeoutType
      * @param timeoutMs
-     * This value will only be used for TimeoutType::WAIT
      * @return
      */
     virtual ReturnValue_t lockMutex(TimeoutType timeoutType =

From 458e849f7d86ca95b0a3ae675d4d00895e26ede8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 22:11:13 +0200
Subject: [PATCH 0620/1774] adapting mutex helper to new interface

---
 ipc/MutexHelper.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index fc6e38bfe..a89497370 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -6,9 +6,10 @@
 
 class MutexHelper {
 public:
-	MutexHelper(MutexIF* mutex, uint32_t timeoutMs) :
+	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs) :
 			internalMutex(mutex) {
-		ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
+		ReturnValue_t status = mutex->lockMutex(timeoutType,
 		        timeoutMs);
 		if(status == MutexIF::MUTEX_TIMEOUT) {
 			sif::error << "MutexHelper: Lock of mutex failed with timeout of "

From 979fea3400668661d817621766c64af1a62ed379 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 22:15:03 +0200
Subject: [PATCH 0621/1774] mutex helper api change

---
 container/SharedRingBuffer.cpp      | 14 +++++++-------
 datapoollocal/LocalPoolVariable.tpp |  6 ++++--
 datapoollocal/LocalPoolVector.tpp   |  6 ++++--
 ipc/MutexHelper.h                   |  2 +-
 osal/linux/TmTcUnixUdpBridge.cpp    |  2 +-
 storagemanager/PoolManager.tpp      |  9 ++++++---
 6 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 2fde2851b..a8b06b013 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -19,41 +19,41 @@ SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
 
 ReturnValue_t SharedRingBuffer::getFreeElementProtected(uint8_t** writePtr,
 		size_t amount) {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return SimpleRingBuffer::getFreeElement(writePtr,amount);
 }
 
 ReturnValue_t SharedRingBuffer::writeDataProtected(const uint8_t *data,
 		size_t amount) {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return SimpleRingBuffer::writeData(data,amount);
 }
 
 ReturnValue_t SharedRingBuffer::readDataProtected(uint8_t *data, size_t amount,
 		bool incrementReadPtr, bool readRemaining,
 		size_t *trueAmount) {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return SimpleRingBuffer::readData(data,amount, incrementReadPtr,
 			readRemaining, trueAmount);
 }
 
 ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
 		bool deleteRemaining, size_t *trueAmount) {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return SimpleRingBuffer::deleteData(amount, deleteRemaining, trueAmount);
 }
 
 size_t SharedRingBuffer::getExcessBytes() const {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return SimpleRingBuffer::getExcessBytes();
 }
 
 void SharedRingBuffer::moveExcessBytesToStart() {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return SimpleRingBuffer::moveExcessBytesToStart();
 }
 
 size_t SharedRingBuffer::getAvailableReadDataProtected(uint8_t n) const {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return ((write + size) - read[n]) % size;
 }
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 0b96bb4fd..b4e09f2d3 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -48,7 +48,8 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
+			lockTimeout);
 	return readWithoutLock();
 }
 
@@ -76,7 +77,8 @@ inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::commit(dur_millis_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
+			lockTimeout);
 	return commitWithoutLock();
 }
 
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index b7f2fe192..7c3d2c1ee 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -44,7 +44,8 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
+			lockTimeout);
 	return readWithoutLock();
 }
 template<typename T, uint16_t vectorSize>
@@ -74,7 +75,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 		uint32_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
+			lockTimeout);
 	return commitWithoutLock();
 }
 
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index a89497370..52ce51e3a 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -7,7 +7,7 @@
 class MutexHelper {
 public:
 	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs) :
+			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
 			internalMutex(mutex) {
 		ReturnValue_t status = mutex->lockMutex(timeoutType,
 		        timeoutMs);
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 92fbbdfa9..2cdb93f36 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -85,7 +85,7 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 }
 
 void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
-	MutexHelper lock(mutex, 10);
+	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //	char ipAddress [15];
 //	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 4ca22b858..0656e9675 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -21,7 +21,8 @@ inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
 		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex, mutexTimeout);
+	MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+			mutexTimeout);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
 			address,ignoreFault);
 	return status;
@@ -33,7 +34,8 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 	// debug << "PoolManager( " << translateObject(getObjectId()) <<
 	//       " )::deleteData from store " << packet_id.pool_index <<
 	//       ". id is "<< packet_id.packet_index << std::endl;
-	MutexHelper mutexHelper(mutex, mutexTimeout);
+	MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+				mutexTimeout);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
 	return status;
 }
@@ -41,7 +43,8 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 		size_t size, store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex, mutexTimeout);
+	MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+				mutexTimeout);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
 			size, storeId);
 	return status;

From a6a1e656071342e70d2408a51289ccfe42de78e4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 12:17:27 +0200
Subject: [PATCH 0622/1774] local data set fix

---
 datapoollocal/LocalDataSet.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 2af01d043..d91c93e93 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -7,7 +7,7 @@
 
 LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
         const size_t maxNumberOfVariables):
-        DataSetBase(poolVarList.data(), maxNumberOfVariables) {
+        LocalDataSetBase(hkOwner,poolVarList.data(), maxNumberOfVariables) {
     poolVarList.reserve(maxNumberOfVariables);
     poolVarList.resize(maxNumberOfVariables);
     if(hkOwner == nullptr) {
@@ -20,7 +20,7 @@ LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
 
 LocalDataSet::LocalDataSet(object_id_t ownerId,
         const size_t maxNumberOfVariables):
-        DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
+        LocalDataSetBase(ownerId, poolVarList.data(), maxNumberOfVariables)  {
     poolVarList.reserve(maxNumberOfVariables);
     poolVarList.resize(maxNumberOfVariables);
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(

From af11c8fcf96c242447baeffbbb9731c9807a6f8e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 12:38:39 +0200
Subject: [PATCH 0623/1774] freeRTOS corrections

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 5 +++--
 osal/FreeRTOS/FixedTimeslotTask.h   | 2 +-
 osal/FreeRTOS/PeriodicTask.cpp      | 7 ++++---
 osal/FreeRTOS/PeriodicTask.h        | 4 ++--
 osal/FreeRTOS/TaskFactory.cpp       | 8 ++++----
 tasks/Typedef.h                     | 1 -
 6 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 1dc45b1d2..2a7bff9cf 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/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;
 }
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index b63cb7750..369507731 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -24,7 +24,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)());
 
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index f2dcd093f..c316d4fc5 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/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;
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 2be2521ca..8030baadc 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -40,9 +40,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.
diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 663b0531c..68866f393 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -18,8 +18,8 @@ PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
 		TaskPriority taskPriority_, TaskStackSize stackSize_,
 		TaskPeriod period_,
 		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return (PeriodicTaskIF*) (new PeriodicTask(name_, taskPriority_, stackSize_,
-			period_, deadLineMissedFunction_));
+	return dynamic_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_,
+			stackSize_, period_, deadLineMissedFunction_));
 }
 
 /**
@@ -29,8 +29,8 @@ FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
 		TaskPriority taskPriority_, TaskStackSize stackSize_,
 		TaskPeriod period_,
 		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return (FixedTimeslotTaskIF*) (new FixedTimeslotTask(name_, taskPriority_,
-			stackSize_, period_, deadLineMissedFunction_));
+	return dynamic_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_,
+			taskPriority_,stackSize_, period_, deadLineMissedFunction_));
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
diff --git a/tasks/Typedef.h b/tasks/Typedef.h
index b393ee1e1..07d96b00d 100644
--- a/tasks/Typedef.h
+++ b/tasks/Typedef.h
@@ -1,7 +1,6 @@
 #ifndef FRAMEWORK_TASKS_TYPEDEF_H_
 #define FRAMEWORK_TASKS_TYPEDEF_H_
 
-//TODO more generic?
 typedef const char* TaskName;
 typedef uint8_t TaskPriority;
 typedef size_t TaskStackSize;

From f766398b20a1c148f63d10eaea70aad46bf2f3a2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 12:49:20 +0200
Subject: [PATCH 0624/1774] some bugfixes

---
 datapoollocal/LocalDataSet.cpp                | 70 +------------------
 datapoollocal/LocalDataSet.h                  |  2 +-
 ...taSetBase.cpp => LocalPoolDataSetBase.cpp} |  2 +-
 datapoollocal/SharedLocalDataSet.cpp          |  2 +-
 datapoollocal/StaticLocalDataSet.h            |  4 +-
 5 files changed, 6 insertions(+), 74 deletions(-)
 rename datapoollocal/{LocalDataSetBase.cpp => LocalPoolDataSetBase.cpp} (98%)

diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index d91c93e93..84ed2ae2b 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -33,73 +33,5 @@ LocalDataSet::LocalDataSet(object_id_t ownerId,
     hkManager = hkOwner->getHkManagerHandle();
 }
 
-LocalDataSet::~LocalDataSet() {
-}
+LocalDataSet::~LocalDataSet() {}
 
-ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
-}
-
-ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
-        size_t *size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-    uint8_t validityMask[validityMaskSize];
-    uint8_t validBufferIndex = 0;
-    uint8_t validBufferIndexBit = 0;
-    for (uint16_t count = 0; count < fillCount; count++) {
-        if(registeredVariables[count]->isValid()) {
-            // set validity buffer here.
-            this->bitSetter(validityMask + validBufferIndex,
-                    validBufferIndexBit);
-            if(validBufferIndexBit == 7) {
-                validBufferIndex ++;
-                validBufferIndexBit = 0;
-            }
-            else {
-                validBufferIndexBit ++;
-            }
-        }
-        result = registeredVariables[count]->serialize(buffer, size, maxSize,
-                streamEndianness);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-    }
-    // copy validity buffer to end
-    std::memcpy(*buffer, validityMask, validityMaskSize);
-    *size += validityMaskSize;
-    return result;
-}
-
-ReturnValue_t LocalDataSet::unlockDataPool() {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->unlockMutex();
-}
-
-ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    for (uint16_t count = 0; count < fillCount; count++) {
-        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
-                size, maxSize, streamEndianness);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
-                    " error!" << std::endl;
-            return result;
-        }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position) const {
-    if(position > 7) {
-        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
-}
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index e6bd20127..820818d78 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -7,7 +7,7 @@ class LocalDataSet: public LocalDataSetBase {
 public:
     LocalDataSet(HasLocalDataPoolIF* hkOwner, const size_t maxSize);
     LocalDataSet(object_id_t owner, const size_t maxSize);
-    virtual~ LocalDataSet() {};
+    virtual~ LocalDataSet();
 
     //! Copying forbidden for now.
     LocalDataSet(const LocalDataSet&) = delete;
diff --git a/datapoollocal/LocalDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
similarity index 98%
rename from datapoollocal/LocalDataSetBase.cpp
rename to datapoollocal/LocalPoolDataSetBase.cpp
index f490ff675..7c2c06326 100644
--- a/datapoollocal/LocalDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -36,7 +36,7 @@ LocalDataSetBase::~LocalDataSetBase() {
 
 ReturnValue_t LocalDataSetBase::lockDataPool(uint32_t timeoutMs) {
 	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(timeoutMs);
+	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
 }
 
 ReturnValue_t LocalDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
index 6f355a8a2..c2b1d21be 100644
--- a/datapoollocal/SharedLocalDataSet.cpp
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -8,7 +8,7 @@ SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, object_id_t owner,
 }
 
 ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
-    return datasetLock->lockMutex(mutexTimeout);
+    return datasetLock->lockMutex(MutexIF::TimeoutType::WAITING, mutexTimeout);
 }
 
 ReturnValue_t SharedLocalDataSet::unlockDataset() {
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index fbe1545f9..b381ed41a 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -1,6 +1,6 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
 #define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#include <framework/datapool/PoolDataSetBase.h>
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <array>
 
@@ -20,7 +20,7 @@ public:
         LocalDataSetBase(owner, poolVarList.data(), NUM_VARIABLES) {
     }
 
-    virtual~ StaticLocalDataSet();
+    virtual~ StaticLocalDataSet() {};
 private:
     std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList;
 };

From fba8775f49347da75646b0c70e4adbea94cbd1b3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 12:51:31 +0200
Subject: [PATCH 0625/1774] some renaming

---
 datapool/PoolVariableIF.h              |  2 +-
 datapoollocal/LocalDataPoolManager.cpp |  6 +++---
 datapoollocal/LocalDataPoolManager.h   |  8 ++++----
 datapoollocal/LocalDataSet.cpp         |  4 ++--
 datapoollocal/LocalDataSet.h           |  2 +-
 datapoollocal/LocalPoolDataSetBase.cpp | 18 +++++++++---------
 datapoollocal/LocalPoolDataSetBase.h   |  8 ++++----
 datapoollocal/SharedLocalDataSet.cpp   |  2 +-
 datapoollocal/SharedLocalDataSet.h     |  2 +-
 datapoollocal/StaticLocalDataSet.h     |  5 ++---
 10 files changed, 28 insertions(+), 29 deletions(-)

diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 6b0dd7fb2..3c4b33e67 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -20,7 +20,7 @@
 class PoolVariableIF : public SerializeIF {
 	friend class PoolDataSetBase;
 	friend class GlobDataSet;
-	friend class LocalDataSetBase;
+	friend class LocalPoolDataSetBase;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
 	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index afce330fe..ec4134929 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -116,7 +116,7 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t sendTo) {
-	LocalDataSetBase* dataSetToSerialize = dynamic_cast<LocalDataSetBase*>(
+	LocalPoolDataSetBase* dataSetToSerialize = dynamic_cast<LocalPoolDataSetBase*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
@@ -155,7 +155,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
-    LocalDataSetBase* dataSet = dynamic_cast<LocalDataSetBase*>(
+    LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
             owner->getDataSetHandle(sid));
     if(dataSet == nullptr) {
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
@@ -186,7 +186,7 @@ void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-        store_address_t *storeId, LocalDataSetBase* dataSet) {
+        store_address_t *storeId, LocalPoolDataSetBase* dataSet) {
     size_t hkSize = dataSet->getSerializedSize();
     uint8_t* storePtr = nullptr;
     ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 9c413aa4b..6912f0bc4 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -14,7 +14,7 @@
 
 #include <map>
 
-class LocalDataSetBase;
+class LocalPoolDataSetBase;
 
 /**
  * @brief 	This class is the managing instance for local data pool.
@@ -38,7 +38,7 @@ class LocalDataPoolManager {
 	friend class LocalPoolVar;
 	template<typename T, uint16_t vecSize>
 	friend class LocalPoolVector;
-	friend class LocalDataSetBase;
+	friend class LocalPoolDataSetBase;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
@@ -154,7 +154,7 @@ private:
      * The data pool manager will keep an internal map of HK receivers.
      */
     struct HkReceiver {
-        LocalDataSetBase* dataSet = nullptr;
+        LocalPoolDataSetBase* dataSet = nullptr;
         lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         ReportingType reportingType = ReportingType::PERIODIC;
@@ -222,7 +222,7 @@ private:
 
 	void setMinimalSamplingFrequency(float frequencySeconds);
 	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
-	        LocalDataSetBase* dataSet);
+	        LocalPoolDataSetBase* dataSet);
 };
 
 
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 84ed2ae2b..d28d089f8 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -7,7 +7,7 @@
 
 LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
         const size_t maxNumberOfVariables):
-        LocalDataSetBase(hkOwner,poolVarList.data(), maxNumberOfVariables) {
+        LocalPoolDataSetBase(hkOwner,poolVarList.data(), maxNumberOfVariables) {
     poolVarList.reserve(maxNumberOfVariables);
     poolVarList.resize(maxNumberOfVariables);
     if(hkOwner == nullptr) {
@@ -20,7 +20,7 @@ LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
 
 LocalDataSet::LocalDataSet(object_id_t ownerId,
         const size_t maxNumberOfVariables):
-        LocalDataSetBase(ownerId, poolVarList.data(), maxNumberOfVariables)  {
+        LocalPoolDataSetBase(ownerId, poolVarList.data(), maxNumberOfVariables)  {
     poolVarList.reserve(maxNumberOfVariables);
     poolVarList.resize(maxNumberOfVariables);
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 820818d78..c3ae7eaae 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -3,7 +3,7 @@
 #include <framework/datapoollocal/LocalPoolDataSetBase.h>
 #include <vector>
 
-class LocalDataSet: public LocalDataSetBase {
+class LocalDataSet: public LocalPoolDataSetBase {
 public:
     LocalDataSet(HasLocalDataPoolIF* hkOwner, const size_t maxSize);
     LocalDataSet(object_id_t owner, const size_t maxSize);
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 7c2c06326..f5273cfef 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -5,7 +5,7 @@
 #include <cmath>
 #include <cstring>
 
-LocalDataSetBase::LocalDataSetBase(HasLocalDataPoolIF *hkOwner,
+LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
@@ -17,7 +17,7 @@ LocalDataSetBase::LocalDataSetBase(HasLocalDataPoolIF *hkOwner,
     hkManager = hkOwner->getHkManagerHandle();
 }
 
-LocalDataSetBase::LocalDataSetBase(object_id_t ownerId,
+LocalPoolDataSetBase::LocalPoolDataSetBase(object_id_t ownerId,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
@@ -31,15 +31,15 @@ LocalDataSetBase::LocalDataSetBase(object_id_t ownerId,
     hkManager = hkOwner->getHkManagerHandle();
 }
 
-LocalDataSetBase::~LocalDataSetBase() {
+LocalPoolDataSetBase::~LocalPoolDataSetBase() {
 }
 
-ReturnValue_t LocalDataSetBase::lockDataPool(uint32_t timeoutMs) {
+ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
 	MutexIF* mutex = hkManager->getMutexHandle();
 	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
 }
 
-ReturnValue_t LocalDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
+ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
         size_t *size, size_t maxSize,
         SerializeIF::Endianness streamEndianness) const {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
@@ -72,12 +72,12 @@ ReturnValue_t LocalDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
     return result;
 }
 
-ReturnValue_t LocalDataSetBase::unlockDataPool() {
+ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
 	MutexIF* mutex = hkManager->getMutexHandle();
 	return mutex->unlockMutex();
 }
 
-ReturnValue_t LocalDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
+ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
         size_t* size, size_t maxSize,
         SerializeIF::Endianness streamEndianness) const {
     for (uint16_t count = 0; count < fillCount; count++) {
@@ -93,7 +93,7 @@ ReturnValue_t LocalDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void LocalDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
+void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
         sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
         return;
@@ -102,6 +102,6 @@ void LocalDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     *byte |= 1 << shiftNumber;
 }
 
-bool LocalDataSetBase::isValid() const {
+bool LocalPoolDataSetBase::isValid() const {
     return this->valid;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index f7a2cae4a..1034fc29d 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -30,14 +30,14 @@ class LocalDataPoolManager;
  *
  * @ingroup data_pool
  */
-class LocalDataSetBase: public PoolDataSetBase {
+class LocalPoolDataSetBase: public PoolDataSetBase {
 public:
 	/**
 	 * @brief	Constructor for the creator of local pool data.
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSetBase(HasLocalDataPoolIF *hkOwner,
+	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 	        PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
@@ -49,7 +49,7 @@ public:
 	 * @details
 	 *
 	 */
-	LocalDataSetBase(object_id_t ownerId,
+	LocalPoolDataSetBase(object_id_t ownerId,
 	        PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
@@ -61,7 +61,7 @@ public:
 	 * the destructor parses all variables that are still registered to the set.
 	 * For each, the valid flag in the data pool is set to "invalid".
 	 */
-	~LocalDataSetBase();
+	~LocalPoolDataSetBase();
 
 	/**
 	 * Special version of the serilization function which appends a
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
index c2b1d21be..8582d8951 100644
--- a/datapoollocal/SharedLocalDataSet.cpp
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -2,7 +2,7 @@
 
 SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, object_id_t owner,
         const size_t maxSize): SystemObject(objectId),
-        LocalDataSetBase(owner, nullptr, maxSize) {
+        LocalPoolDataSetBase(owner, nullptr, maxSize) {
     this->setContainer(poolVarVector.data());
     datasetLock = MutexFactory::instance()->createMutex();
 }
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index acb0cd268..3fbb9ea10 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -13,7 +13,7 @@
  * Then a regular local data set is sufficient.
  */
 class SharedLocalDataSet: public SystemObject,
-        public LocalDataSetBase,
+        public LocalPoolDataSetBase,
         public SharedDataSetIF {
 public:
     SharedLocalDataSet(object_id_t objectId, object_id_t owner,
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index b381ed41a..7b6c47b61 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -14,13 +14,12 @@
  * @tparam capacity
  */
 template <uint8_t NUM_VARIABLES>
-class StaticLocalDataSet: public LocalDataSetBase {
+class StaticLocalDataSet: public LocalPoolDataSetBase {
 public:
     StaticLocalDataSet(object_id_t owner):
-        LocalDataSetBase(owner, poolVarList.data(), NUM_VARIABLES) {
+        LocalPoolDataSetBase(owner, poolVarList.data(), NUM_VARIABLES) {
     }
 
-    virtual~ StaticLocalDataSet() {};
 private:
     std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList;
 };

From 5c85d03c39af4e9ec31a03e238dd1994b02ea68a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 13:04:31 +0200
Subject: [PATCH 0626/1774] additional check for freeRTOS

---
 osal/FreeRTOS/MessageQueue.cpp | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 8eb669ed8..e9f3871e2 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -123,11 +123,20 @@ bool MessageQueue::isDefaultDestinationSet() const {
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
         bool ignoreFault, CallContext callContext) {
+	BaseType_t result = pdFALSE;
+	QueueHandle_t destination = nullptr;
+
+	if(sendTo == MessageQueueIF::NO_QUEUE) {
+		return MessageQueueIF::DESTINVATION_INVALID;
+	}
+	else  {
+		destination = reinterpret_cast<QueueHandle_t>(sendTo);
+	}
     message->setSender(sentFrom);
-    BaseType_t result;
+
 
     if(callContext == CallContext::TASK) {
-        result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
+        result = xQueueSendToBack(destination,
                 static_cast<const void*>(message->getBuffer()), 0);
     }
     else {

From 121e94a3854049c4a4075327034f8d492b1b3bb8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 13:20:02 +0200
Subject: [PATCH 0627/1774] local pool var update

---
 datapoollocal/LocalPoolVariable.h   | 3 +++
 datapoollocal/LocalPoolVariable.tpp | 7 +++++++
 2 files changed, 10 insertions(+)

diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 73d691d7e..93ac14b0d 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -116,6 +116,8 @@ public:
 	 */
 	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
 
+
+	LocalPoolVar<T> &operator=(T newValue);
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
@@ -170,4 +172,5 @@ using lp_int64_t = LocalPoolVar<int64_t>;
 using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
+
 #endif
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index a16e11190..6e6f27aaa 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -103,6 +103,13 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 	return RETURN_OK;
 }
 
+template<typename T>
+inline LocalPoolVar<T> & LocalPoolVar<T>::operator =(T newValue) {
+    value = newValue;
+    return *this;
+}
+
+
 template<typename T>
 inline pool_rwm_t LocalPoolVar<T>::getReadWriteMode() const {
 	return readWriteMode;

From 03cd5780f9b6f915566c07b07482a1b86b103eed Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 13:29:38 +0200
Subject: [PATCH 0628/1774] null initializations in header

---
 fdir/FailureIsolationBase.cpp | 4 ++--
 fdir/FailureIsolationBase.h   | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index 4df56dcdb..ad4493ff2 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -7,8 +7,8 @@
 
 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) {
+		ownerId(owner), faultTreeParent(parent),
+		parameterDomainBase(parameterDomainBase) {
 	eventQueue = QueueFactory::instance()->createMessageQueue(messageDepth,
 			EventMessage::EVENT_MESSAGE_SIZE);
 }
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index 6010baca8..c0fe6041e 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -33,9 +33,9 @@ public:
 	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);

From e7d28d630cfe41ed859f516084b661df3b37a565 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 19:43:28 +0200
Subject: [PATCH 0629/1774] continued with implementation

---
 datapoollocal/HasLocalDataPoolIF.h     |  9 ++++
 datapoollocal/LocalDataPoolManager.cpp | 70 +++++++++++++++++++++++++-
 datapoollocal/LocalDataPoolManager.h   | 44 ++++++++++++----
 devicehandlers/DeviceHandlerBase.cpp   |  9 ++++
 devicehandlers/DeviceHandlerBase.h     |  8 ++-
 objectmanager/SystemObject.h           |  4 +-
 6 files changed, 129 insertions(+), 15 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 7727c3b48..1a026dd30 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -43,6 +43,8 @@ public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 	static constexpr lp_id_t NO_POOL_ID = 0xffffffff;
 
+	virtual object_id_t getObjectId() const = 0;
+
 	/** Command queue for housekeeping messages. */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
@@ -53,6 +55,13 @@ public:
 	/** Can be used to get a handle to the local data pool manager. */
 	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 
+	/**
+	 * Returns the minimum sampling frequency, which will usually be the
+	 * period the pool owner performs its periodic operation-
+	 * @return
+	 */
+	virtual dur_millis_t getPeriodicOperationFrequency() const = 0;
+
 	/**
 	 * This function is used by the pool manager to get a valid dataset
      * from a SID
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index ec4134929..b852143e4 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -6,6 +6,7 @@
 #include <framework/ipc/QueueFactory.h>
 
 #include <array>
+#include <cmath>
 
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
@@ -25,11 +26,12 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
 	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
 	            "Could not set IPC store." << std::endl;
 	}
+
 	hkQueue = queueToUse;
 }
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
-        object_id_t hkDestination) {
+        object_id_t hkDestination, uint8_t nonDiagInvlFactor) {
     if(queueToUse == nullptr) {
         sif::error << "LocalDataPoolManager::initialize: Supplied queue "
                 "invalid!" << std::endl;
@@ -51,6 +53,10 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
         sif::warning << "Make sure it exists and the object impements "
                 "AcceptsHkPacketsIF!" << std::endl;
     }
+
+    setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
+    diagnosticMinimumInterval = owner->getPeriodicOperationFrequency();
+    regularMinimumInterval = diagnosticMinimumInterval * nonDiagnosticIntervalFactor;
     return initializeHousekeepingPoolEntriesOnce();
 }
 
@@ -182,7 +188,9 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
     return result;
 }
 
-void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
+void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
+        uint8_t nonDiagInvlFactor) {
+    this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
@@ -214,5 +222,63 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
+    for(auto& hkReceiversIter: hkReceiversMap) {
+        HkReceiver* receiver = &hkReceiversIter.second;
+        switch(receiver->reportingType) {
+        case(ReportingType::PERIODIC): {
+            performPeriodicHkGeneration(receiver);
+            break;
+        }
+        case(ReportingType::ON_UPDATE): {
+            // check whether data has changed and send messages in case it has.
+            break;
+        }
+        default:
+            // This should never happen.
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
     return HasReturnvaluesIF::RETURN_OK;
 }
+
+void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
+    if(receiver->reportingEnabled) {
+        if(receiver->intervalCounter >= intervalSecondsToInterval(
+                receiver->isDiagnostics,
+                receiver->hkParameter.collectionInterval)) {
+            ReturnValue_t result = generateHousekeepingPacket(
+                    receiver->dataSetSid, receiver->destinationQueue);
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                // configuration error
+                sif::debug << "LocalDataPoolManager::performHkOperation:"
+                        << "0x" << std::setfill('0') << std::setw(8)
+                << owner->getObjectId() << " Error generating "
+                << "HK packet" << std::setfill(' ') << std::endl;
+            }
+            receiver->intervalCounter = 1;
+        }
+        else if(receiver->reportingEnabled){
+            receiver->intervalCounter++;
+        }
+    }
+}
+
+uint32_t LocalDataPoolManager::intervalSecondsToInterval(bool isDiagnostics,
+        float collectionIntervalSeconds) {
+    if(isDiagnostics) {
+        return  std::ceil(collectionIntervalSeconds/diagnosticMinimumInterval);
+    }
+    else {
+        return std::ceil(collectionIntervalSeconds/regularMinimumInterval);
+    }
+}
+
+float LocalDataPoolManager::intervalToIntervalSeconds(bool isDiagnostics,
+        uint32_t collectionInterval) {
+    if(isDiagnostics) {
+        return  static_cast<float>(collectionInterval * diagnosticMinimumInterval);
+    }
+    else {
+        return static_cast<float>(collectionInterval * regularMinimumInterval);
+    }
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 6912f0bc4..bcfee3f44 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -66,10 +66,22 @@ public:
 	 * Initializes the map by calling the map initialization function of the
 	 * owner and assigns the queue to use.
 	 * @param queueToUse
+	 * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
 	 * @return
 	 */
 	ReturnValue_t initialize(MessageQueueIF* queueToUse,
-	        object_id_t hkDestination);
+	        object_id_t hkDestination, uint8_t nonDiagInvlFactor = 5);
+
+	/**
+	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
+	 * than diagnostic packets.
+	 * A factor can be specified to determine the minimum sampling frequency
+	 * for non-diagnostic packets. The minimum sampling frequency of the
+	 * diagnostics packets,which is usually jusst the period of the
+	 * performOperation calls, is multiplied with that factor.
+	 * @param factor
+	 */
+	void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
 
 	/**
 	 * This should be called in the periodic handler of the owner.
@@ -144,29 +156,36 @@ public:
 
 private:
     LocalDataPool localPoolMap;
-    /** Every housekeeping data manager has a mutex to protect access
-     * to it's data pool. */
+    //! Every housekeeping data manager has a mutex to protect access
+    //! to it's data pool.
     MutexIF* mutex = nullptr;
     /** The class which actually owns the manager (and its datapool). */
     HasLocalDataPoolIF* owner = nullptr;
 
-    /**
-     * The data pool manager will keep an internal map of HK receivers.
-     */
+    uint8_t nonDiagnosticIntervalFactor = 0;
+    dur_millis_t regularMinimumInterval = 0;
+    dur_millis_t diagnosticMinimumInterval = 0;
+
+    /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
-        LocalPoolDataSetBase* dataSet = nullptr;
+        sid_t dataSetSid;
+        //LocalPoolDataSetBase* dataSet = nullptr;
         lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         ReportingType reportingType = ReportingType::PERIODIC;
-        bool reportingStatus = true;
+        bool reportingEnabled = true;
         /** Different members of this union will be used depending on reporting
          * type */
-        union hkParameter {
+        union HkParameter {
             /** This parameter will be used for the PERIODIC type */
             dur_seconds_t collectionInterval = 0;
             /** This parameter will be used for the ON_UPDATE type */
             bool hkDataChanged;
         };
+        HkParameter hkParameter;
+        bool isDiagnostics;
+        //! General purpose counter which is used for periodic generation.
+        uint32_t intervalCounter;
     };
 
     /** Using a multimap as the same object might request multiple datasets */
@@ -223,6 +242,13 @@ private:
 	void setMinimalSamplingFrequency(float frequencySeconds);
 	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
 	        LocalPoolDataSetBase* dataSet);
+
+	uint32_t intervalSecondsToInterval(bool isDiagnostics,
+	        float collectionIntervalSeconds);
+	float intervalToIntervalSeconds(bool isDiagnostics,
+	        uint32_t collectionInterval);
+
+	void performPeriodicHkGeneration(HkReceiver* hkReceiver);
 };
 
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index a4346afbe..cbbecb705 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -82,6 +82,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		decrementDeviceReplyMap();
 		fdirInstance->checkForFailures();
 		hkSwitcher.performOperation();
+		hkManager.performHkOperation();
 		performOperationHook();
 	}
 	if (mode == MODE_OFF) {
@@ -1395,3 +1396,11 @@ DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
 		return nullptr;
 	}
 }
+
+object_id_t DeviceHandlerBase::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
+    return pstIntervalMs;
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 632db5e09..302829ea9 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -493,7 +493,11 @@ protected:
 	 * 			performOperation(). Default implementation is empty.
 	 */
 	virtual void performOperationHook();
+
 public:
+	/** Explicit interface implementation of getObjectId */
+	virtual object_id_t getObjectId() const override;
+
 	/**
 	 * @param parentQueueId
 	 */
@@ -653,8 +657,6 @@ protected:
 		//! respective device reply. Will point to a dataset held by
 		//! the child handler (if one is specified)
 		DataSetIF* dataSet = nullptr;
-		float collectionInterval = 0.0;
-		uint32_t intervalCounter = 0;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -1201,6 +1203,8 @@ private:
 
 	void parseReply(const uint8_t* receivedData,
 	            size_t receivedDataLen);
+
+    virtual dur_millis_t getPeriodicOperationFrequency() const override;
 };
 
 #endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
diff --git a/objectmanager/SystemObject.h b/objectmanager/SystemObject.h
index 6a1b35b6f..47e53a7fd 100644
--- a/objectmanager/SystemObject.h
+++ b/objectmanager/SystemObject.h
@@ -51,8 +51,8 @@ public:
 	 * @brief	On destruction, the object removes itself from the list.
 	 */
 	virtual ~SystemObject();
-	object_id_t getObjectId() const;
-	virtual ReturnValue_t initialize();
+	object_id_t getObjectId() const override;
+	virtual ReturnValue_t initialize() override;
 	virtual ReturnValue_t checkObjectConnections();
 
 	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;

From b828d7c6d7b8267e9867369a557d6e0b9c4d8452 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 19:56:42 +0200
Subject: [PATCH 0630/1774] continued with local datapool manager

---
 datapoollocal/LocalDataPoolManager.cpp | 46 ++++++++++++++++----------
 datapoollocal/LocalDataPoolManager.h   | 29 ++++++++--------
 2 files changed, 42 insertions(+), 33 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index b852143e4..b7b203b88 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -129,6 +129,12 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 				" Set ID not found" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+
+	// do we generate hk packets for invalid datasets?
+//	if(not dataSetToSerialize->isValid()) {
+//	    return HasReturnvaluesIF::RETURN_OK;
+//	}
+
 	store_address_t storeId;
 	ReturnValue_t result = serializeHkPacketIntoStore(&storeId,
 	        dataSetToSerialize);
@@ -224,8 +230,16 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
     for(auto& hkReceiversIter: hkReceiversMap) {
         HkReceiver* receiver = &hkReceiversIter.second;
+        if(not receiver->reportingEnabled) {
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+
         switch(receiver->reportingType) {
         case(ReportingType::PERIODIC): {
+            if(receiver->dataId.dataSetSid == sid_t::INVALID_ADDRESS) {
+                // Periodic packets shall only be generated from datasets.
+                continue;
+            }
             performPeriodicHkGeneration(receiver);
             break;
         }
@@ -242,24 +256,22 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
 }
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
-    if(receiver->reportingEnabled) {
-        if(receiver->intervalCounter >= intervalSecondsToInterval(
-                receiver->isDiagnostics,
-                receiver->hkParameter.collectionInterval)) {
-            ReturnValue_t result = generateHousekeepingPacket(
-                    receiver->dataSetSid, receiver->destinationQueue);
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                // configuration error
-                sif::debug << "LocalDataPoolManager::performHkOperation:"
-                        << "0x" << std::setfill('0') << std::setw(8)
-                << owner->getObjectId() << " Error generating "
-                << "HK packet" << std::setfill(' ') << std::endl;
-            }
-            receiver->intervalCounter = 1;
-        }
-        else if(receiver->reportingEnabled){
-            receiver->intervalCounter++;
+    if(receiver->intervalCounter >= intervalSecondsToInterval(
+            receiver->isDiagnostics,
+            receiver->hkParameter.collectionInterval)) {
+        ReturnValue_t result = generateHousekeepingPacket(
+                receiver->dataId.dataSetSid, receiver->destinationQueue);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            // configuration error
+            sif::debug << "LocalDataPoolManager::performHkOperation:"
+                    << "0x" << std::setfill('0') << std::setw(8)
+            << owner->getObjectId() << " Error generating "
+            << "HK packet" << std::setfill(' ') << std::endl;
         }
+        receiver->intervalCounter = 1;
+    }
+    else {
+        receiver->intervalCounter++;
     }
 }
 
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index bcfee3f44..d9e84f4ee 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -31,7 +31,7 @@ class LocalPoolDataSetBase;
  * value is stored. The helper classes offer a read() and commit() interface
  * through the PoolVariableIF which is used to read and update values.
  * Each pool entry has a valid state too.
- *
+ * @author R. Mueller
  */
 class LocalDataPoolManager {
 	template<typename T>
@@ -129,12 +129,6 @@ public:
      *     Propably not necessary, just use multiple local data sets or
      *     shared datasets.
      *
-     *  TODO: This is a big architecture question. Use raw data or shared
-     *  datasets? dumb thing about shared datasets: It propably would be better
-     *  if each task who uses the data has their own copy of the pool
-     *  variables. Then the LPIDs should be hardcoded in the dataset implementations
-     *  so the users don't have to worry about it anymore.
-     *
      *  Notifications should also be possible for single variables instead of
      *  full dataset updates.
      */
@@ -144,10 +138,6 @@ public:
         // Notification will be sent out as message.
         // Data is accessed via shared data set or multiple local data sets.
         ON_UPDATE,
-        // actually, requested is propably unnecessary. If another component
-        // needs data on request, they can just use  the new SharedDataSet
-        // which is thread-safe to also have full access to the interface..
-        REQUESTED
     };
 
     /* Copying forbidden */
@@ -168,14 +158,21 @@ private:
 
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
-        sid_t dataSetSid;
-        //LocalPoolDataSetBase* dataSet = nullptr;
-        lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
+        /** Different member of this union will be used depending on the
+        type of data the receiver is interested in (full datasets or
+        single data variables. */
+        union DataId {
+            /** Will be initialized to INVALID_ADDRESS */
+            sid_t dataSetSid;
+            lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
+        };
+        DataId dataId;
+
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         ReportingType reportingType = ReportingType::PERIODIC;
         bool reportingEnabled = true;
         /** Different members of this union will be used depending on reporting
-         * type */
+        type */
         union HkParameter {
             /** This parameter will be used for the PERIODIC type */
             dur_seconds_t collectionInterval = 0;
@@ -184,7 +181,7 @@ private:
         };
         HkParameter hkParameter;
         bool isDiagnostics;
-        //! General purpose counter which is used for periodic generation.
+        /** General purpose counter which is used for periodic generation. */
         uint32_t intervalCounter;
     };
 

From b092850dfcb0a37f3d9fd8b67933b8201d8d622b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 21:32:15 +0200
Subject: [PATCH 0631/1774] internal housekeeping packet finished

---
 datapoollocal/LocalDataPoolManager.cpp    |  2 +-
 datapoollocal/LocalPoolDataSetBase.cpp    | 79 +++++++++++++++++++++++
 datapoollocal/LocalPoolDataSetBase.h      | 16 ++++-
 housekeeping/HousekeepingMessage.h        |  4 ++
 housekeeping/InternalHousekeepingPacket.h | 73 +++++++++++++++++++++
 5 files changed, 171 insertions(+), 3 deletions(-)
 create mode 100644 housekeeping/InternalHousekeepingPacket.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index b7b203b88..7c41ff2a4 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -236,7 +236,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
 
         switch(receiver->reportingType) {
         case(ReportingType::PERIODIC): {
-            if(receiver->dataId.dataSetSid == sid_t::INVALID_ADDRESS) {
+            if(receiver->dataId.dataSetSid.notSet()) {
                 // Periodic packets shall only be generated from datasets.
                 continue;
             }
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index f5273cfef..d24ffd185 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -72,6 +72,36 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
     return result;
 }
 
+ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
+        const uint8_t **buffer, size_t *size,
+        SerializeIF::Endianness streamEndianness) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        result = registeredVariables[count]->deSerialize(buffer, size,
+                        streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    // could be made more efficient but make it work first
+    for (uint16_t count = 0; count < fillCount; count++) {
+        // set validity buffer here.
+        bool nextVarValid = this->bitGetter(*buffer +
+                validBufferIndex, validBufferIndexBit);
+        registeredVariables[count]->setValid(nextVarValid);
+
+        if(validBufferIndexBit == 7) {
+            validBufferIndex ++;
+            validBufferIndexBit = 0;
+        }
+        else {
+            validBufferIndexBit ++;
+        }
+    }
+    return result;
+}
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
 	MutexIF* mutex = hkManager->getMutexHandle();
 	return mutex->unlockMutex();
@@ -102,6 +132,55 @@ void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     *byte |= 1 << shiftNumber;
 }
 
+size_t LocalPoolDataSetBase::getSerializedSize() const {
+    if(withValidityBuffer) {
+        uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+        return validityMaskSize + PoolDataSetBase::getSerializedSize();
+    }
+    else {
+        return PoolDataSetBase::getSerializedSize();
+    }
+}
+
+void LocalPoolDataSetBase::setValidityBufferGeneration(
+        bool withValidityBuffer) {
+    this->withValidityBuffer = withValidityBuffer;
+}
+
+ReturnValue_t LocalPoolDataSetBase::deSerialize(const uint8_t **buffer,
+        size_t *size, SerializeIF::Endianness streamEndianness) {
+    if(withValidityBuffer) {
+        return this->deSerializeWithValidityBuffer(buffer, size,
+                streamEndianness);
+    }
+    else {
+        return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
+    }
+}
+
+ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
+        size_t maxSize, SerializeIF::Endianness streamEndianness) const {
+    if(withValidityBuffer) {
+        return this->serializeWithValidityBuffer(buffer, size,
+                maxSize, streamEndianness);
+    }
+    else {
+        return PoolDataSetBase::serialize(buffer, size, maxSize,
+                streamEndianness);
+    }
+}
+
+bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte, uint8_t position) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+        return false;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    return *byte & (1 << shiftNumber);
+}
+
 bool LocalPoolDataSetBase::isValid() const {
     return this->valid;
 }
+
+
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 1034fc29d..e9baeea35 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -30,6 +30,7 @@ class LocalDataPoolManager;
  *
  * @ingroup data_pool
  */
+// todo: make withValidityBuffer a member
 class LocalPoolDataSetBase: public PoolDataSetBase {
 public:
 	/**
@@ -63,6 +64,14 @@ public:
 	 */
 	~LocalPoolDataSetBase();
 
+	void setValidityBufferGeneration(bool withValidityBuffer);
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+	            SerializeIF::Endianness streamEndianness) const override;
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
+	        SerializeIF::Endianness streamEndianness) override;
+	size_t getSerializedSize() const override;
+
 	/**
 	 * Special version of the serilization function which appends a
 	 * validity buffer at the end. Each bit of this validity buffer
@@ -78,7 +87,8 @@ public:
 	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
 	        size_t* size, size_t maxSize,
 	        SerializeIF::Endianness streamEndianness) const;
-
+	ReturnValue_t deSerializeWithValidityBuffer(const uint8_t** buffer,
+	        size_t *size, SerializeIF::Endianness streamEndianness);
 	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
 	        size_t* size, size_t maxSize,
 	        SerializeIF::Endianness streamEndianness) const;
@@ -92,6 +102,8 @@ protected:
 	 */
 	bool valid = false;
 
+	bool withValidityBuffer = true;
+
 	/**
 	 * @brief	This is a small helper function to facilitate locking
 	 * 			the global data pool.
@@ -114,7 +126,7 @@ protected:
 	 * (most significant bit) to 7 (least significant bit)
 	 */
 	void bitSetter(uint8_t* byte, uint8_t position) const;
-
+	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 private:
 
 
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index e2a698057..db6d3ab86 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -25,6 +25,10 @@ union sid_t {
 	 * Alternative access to the raw value. This is also the size of the type.
 	 */
 	uint64_t raw;
+
+	bool notSet() const {
+	    return raw == INVALID_ADDRESS;
+	}
 };
 
 
diff --git a/housekeeping/InternalHousekeepingPacket.h b/housekeeping/InternalHousekeepingPacket.h
new file mode 100644
index 000000000..2a9a55644
--- /dev/null
+++ b/housekeeping/InternalHousekeepingPacket.h
@@ -0,0 +1,73 @@
+#ifndef FRAMEWORK_HOUSEKEEPING_INTERNALHOUSEKEEPINGPACKET_H_
+#define FRAMEWORK_HOUSEKEEPING_INTERNALHOUSEKEEPINGPACKET_H_
+
+#include <framework/serialize/SerialBufferAdapter.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
+
+/**
+ * @brief   This helper class will be used to serialize and deserialize
+ *          internal housekeeping packets into the store.
+ */
+class InternalHousekeepingPacket: public SerializeIF {
+public:
+    /**
+     * @param timeStamp
+     * @param timeStampSize
+     * @param hkData
+     * @param hkDataSize
+     */
+    InternalHousekeepingPacket(uint8_t* timeStamp, size_t timeStampSize,
+            LocalPoolDataSetBase* dataSetPtr):
+            timeStamp(timeStamp), timeStampSize(timeStampSize),
+            dataSetPtr(dataSetPtr) {};
+
+    virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+            size_t maxSize, Endianness streamEndianness) const {
+        if(timeStamp != nullptr) {
+            // Endianness will always be MACHINE, so we can simply use memcpy
+            // here.
+            std::memcpy(*buffer, timeStamp, timeStampSize);
+            *size += timeStampSize;
+            *buffer += timeStampSize;
+        }
+        if(dataSetPtr == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+
+        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
+    }
+
+    virtual size_t getSerializedSize() const {
+        if(dataSetPtr == nullptr) {
+            return 0;
+        }
+        return timeStampSize + dataSetPtr->getSerializedSize();
+    }
+
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            SerializeIF::Endianness streamEndianness) override {
+        if(timeStamp != nullptr) {
+            // Endianness will always be MACHINE, so we can simply use memcpy
+            // here.
+            std::memcpy(timeStamp, *buffer, timeStampSize);
+            *size += timeStampSize;
+            *buffer += timeStampSize;
+        }
+
+        if(dataSetPtr == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        return dataSetPtr->deSerialize(buffer, size, streamEndianness);
+    }
+
+private:
+   uint8_t* timeStamp;
+   size_t timeStampSize;
+
+   LocalPoolDataSetBase* dataSetPtr = nullptr;
+};
+
+
+
+#endif /* FRAMEWORK_HOUSEKEEPING_INTERNALHOUSEKEEPINGPACKET_H_ */

From 6484c1a27697f1b3a8326dbae0d3fa5eb4be7b4f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 23:45:18 +0200
Subject: [PATCH 0632/1774] shared ring buffer simplified

---
 container/SharedRingBuffer.cpp | 46 +++++++---------------------------
 container/SharedRingBuffer.h   | 43 +++++++++++++++----------------
 2 files changed, 29 insertions(+), 60 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index a8b06b013..afcd89c7e 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -5,7 +5,7 @@
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
 		bool overwriteOld, size_t maxExcessBytes, dur_millis_t mutexTimeout):
 		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
-		maxExcessBytes), mutexTimeout(mutexTimeout) {
+		maxExcessBytes) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
@@ -13,47 +13,19 @@ SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
 		const size_t size, bool overwriteOld, size_t maxExcessBytes,
 		dur_millis_t mutexTimeout):
 		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
-		maxExcessBytes), mutexTimeout(mutexTimeout) {
+		maxExcessBytes) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
-ReturnValue_t SharedRingBuffer::getFreeElementProtected(uint8_t** writePtr,
-		size_t amount) {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return SimpleRingBuffer::getFreeElement(writePtr,amount);
+ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
+        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
+    return mutex->lockMutex(timeoutType, timeout);
 }
 
-ReturnValue_t SharedRingBuffer::writeDataProtected(const uint8_t *data,
-		size_t amount) {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return SimpleRingBuffer::writeData(data,amount);
+ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
+    return mutex->unlockMutex();
 }
 
-ReturnValue_t SharedRingBuffer::readDataProtected(uint8_t *data, size_t amount,
-		bool incrementReadPtr, bool readRemaining,
-		size_t *trueAmount) {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return SimpleRingBuffer::readData(data,amount, incrementReadPtr,
-			readRemaining, trueAmount);
-}
-
-ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
-		bool deleteRemaining, size_t *trueAmount) {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return SimpleRingBuffer::deleteData(amount, deleteRemaining, trueAmount);
-}
-
-size_t SharedRingBuffer::getExcessBytes() const {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return SimpleRingBuffer::getExcessBytes();
-}
-
-void SharedRingBuffer::moveExcessBytesToStart() {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return SimpleRingBuffer::moveExcessBytesToStart();
-}
-
-size_t SharedRingBuffer::getAvailableReadDataProtected(uint8_t n) const {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return ((write + size) - read[n]) % size;
+MutexIF* SharedRingBuffer::getMutexHandle() const {
+    return mutex;
 }
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 8d68b9678..69a3d7249 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -6,6 +6,13 @@
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/timemanager/Clock.h>
 
+/**
+ * @brief   Ring buffer which can be shared among multiple objects
+ * @details
+ * This class offers a mutex to perform thread-safe operation on the ring
+ * buffer. It is still up to the developer to actually perform the lock
+ * and unlock operations.
+ */
 class SharedRingBuffer: public SystemObject,
 		public SimpleRingBuffer {
 public:
@@ -32,34 +39,24 @@ public:
 			bool overwriteOld, size_t maxExcessBytes,
 			dur_millis_t mutexTimeout = 10);
 
-	void setMutexTimeout(dur_millis_t newTimeout);
-
-	virtual size_t getExcessBytes() const override;
 	/**
-	 * Helper functions which moves any excess bytes to the start
-	 * of the ring buffer.
+	 * Unless a read-only constant value is read, all operations on the
+	 * shared ring buffer should be protected by calling this function.
+	 * @param timeoutType
+	 * @param timeout
 	 * @return
 	 */
-	virtual void moveExcessBytesToStart() override;
+	virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
+	        dur_millis_t timeout);
+	/**
+	 * Any locked mutex also has to be unlocked, otherwise, access to the
+	 * shared ring buffer will be blocked.
+	 * @return
+	 */
+	virtual ReturnValue_t unlockRingBufferMutex();
 
-	/** Performs mutex protected SimpleRingBuffer::getFreeElement call */
-	ReturnValue_t getFreeElementProtected(uint8_t** writePtr, size_t amount);
-
-	/** Performs mutex protected SimpleRingBuffer::writeData call */
-	ReturnValue_t writeDataProtected(const uint8_t* data, size_t amount);
-
-	/** Performs mutex protected SimpleRingBuffer::readData call */
-	ReturnValue_t readDataProtected(uint8_t *data, size_t amount,
-			bool incrementReadPtr = false,
-			bool readRemaining = false, size_t *trueAmount = nullptr);
-
-	/** Performs mutex protected SimpleRingBuffer::deleteData call */
-	ReturnValue_t deleteDataProtected(size_t amount,
-			bool deleteRemaining = false, size_t* trueAmount = nullptr);
-
-	size_t getAvailableReadDataProtected (uint8_t n = 0) const;
+	MutexIF* getMutexHandle() const;
 private:
-	dur_millis_t mutexTimeout;
 	MutexIF* mutex = nullptr;
 };
 

From f9ce1d9eb9f5fcf85a339fc28b3b5806cb1c644c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 23:46:21 +0200
Subject: [PATCH 0633/1774] more simplifications for shared ring buffer

---
 container/SharedRingBuffer.cpp | 5 ++---
 container/SharedRingBuffer.h   | 6 ++----
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index afcd89c7e..001a21ed5 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -3,15 +3,14 @@
 #include <framework/ipc/MutexHelper.h>
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes, dur_millis_t mutexTimeout):
+		bool overwriteOld, size_t maxExcessBytes):
 		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
 		maxExcessBytes) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
-		const size_t size, bool overwriteOld, size_t maxExcessBytes,
-		dur_millis_t mutexTimeout):
+		const size_t size, bool overwriteOld, size_t maxExcessBytes):
 		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
 		maxExcessBytes) {
 	mutex = MutexFactory::instance()->createMutex();
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 69a3d7249..102cc6be8 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -24,8 +24,7 @@ public:
 	 * will be overwritten.
 	 */
 	SharedRingBuffer(object_id_t objectId, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes,
-			dur_millis_t mutexTimeout = 10);
+			bool overwriteOld, size_t maxExcessBytes);
 
 	/**
 	 * This constructor takes an external buffer with the specified size.
@@ -36,8 +35,7 @@ public:
 	 * will be overwritten.
 	 */
 	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes,
-			dur_millis_t mutexTimeout = 10);
+			bool overwriteOld, size_t maxExcessBytes);
 
 	/**
 	 * Unless a read-only constant value is read, all operations on the

From 5d09ae322176247536667994806ca8aa6bb3b1e5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 23:47:44 +0200
Subject: [PATCH 0634/1774] additional comment

---
 container/SharedRingBuffer.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 102cc6be8..0b5be0521 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -53,6 +53,11 @@ public:
 	 */
 	virtual ReturnValue_t unlockRingBufferMutex();
 
+	/**
+	 * The mutex handle can be accessed directly, for example to perform
+	 * the lock with the #MutexHelper for a RAII compliant lock operation.
+	 * @return
+	 */
 	MutexIF* getMutexHandle() const;
 private:
 	MutexIF* mutex = nullptr;

From 9e7d92b387249a6156a889e277cefc80fd53d667 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 9 Aug 2020 19:46:37 +0200
Subject: [PATCH 0635/1774] some renaming , hk packets finished

---
 housekeeping/HousekeepingPacketDownlink.h     | 75 +++++++++++++++++++
 ...ingPacket.h => HousekeepingPacketUpdate.h} | 10 +--
 2 files changed, 80 insertions(+), 5 deletions(-)
 create mode 100644 housekeeping/HousekeepingPacketDownlink.h
 rename housekeeping/{InternalHousekeepingPacket.h => HousekeepingPacketUpdate.h} (86%)

diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
new file mode 100644
index 000000000..d386bfdf3
--- /dev/null
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -0,0 +1,75 @@
+#ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+#define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
+#include <framework/housekeeping/HousekeepingMessage.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+
+/**
+ * @brief   This class will be used to serialize general housekeeping packets
+ *          which are destined to be downlinked into the store.
+ * @details
+ * The housekeeping packets are stored into the IPC store and forwarded
+ * to the designated housekeeping handler.
+ */
+class HousekeepingPacketDownlink: public SerialLinkedListAdapter<SerializeIF> {
+public:
+    HousekeepingPacketDownlink(sid_t sid, float collectionInterval, uint8_t
+            numberOfParameters, LocalPoolDataSetBase* dataSetPtr):
+            sourceId(sid.objectId), setId(sid.ownerSetId),
+            collectionInterval(collectionInterval),
+            numberOfParameters(numberOfParameters), dataSetPtr(dataSetPtr),
+            hkData(dataSetPtr) {
+        setLinks();
+    }
+
+//    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+//                size_t maxSize, Endianness streamEndianness) const override {
+//        ReturnValue_t result = SerialLinkedListAdapter::serialize(buffer, size,
+//                maxSize, streamEndianness);
+//        if(result != HasReturnvaluesIF::RETURN_OK) {
+//            return result;
+//        }
+//        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
+//   }
+//
+//   virtual size_t getSerializedSize() const override {
+//
+//   }
+
+   virtual ReturnValue_t moveToOtherStore(StorageManagerIF* formerStore,
+           store_address_t storeId, StorageManagerIF* otherStore,
+           store_address_t* newStoreId, uint8_t** buffer, size_t size) {
+       const uint8_t* dataPtr = nullptr;
+       size_t hkDataSize = 0;
+       ReturnValue_t result = formerStore->getData(storeId, &dataPtr, &hkDataSize);
+       if(result != HasReturnvaluesIF::RETURN_OK) {
+           return result;
+       }
+
+       otherStore->addData(newStoreId, dataPtrgetSerializedSize(),
+               buffer);
+       std::memcpy
+
+   }
+
+private:
+    void setLinks() {
+        setStart(&sourceId);
+        sourceId.setNext(&setId);
+        setId.setNext(&collectionInterval);
+        collectionInterval.setNext(&numberOfParameters);
+        numberOfParameters.setNext(&hkData);
+    }
+
+    SerializeElement<object_id_t> sourceId;
+    SerializeElement<uint32_t> setId;
+    SerializeElement<float> collectionInterval;
+    SerializeElement<uint8_t> numberOfParameters;
+    LinkedElement<SerializeIF> hkData;
+    LocalPoolDataSetBase* dataSetPtr;
+};
+
+
+
+#endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_ */
diff --git a/housekeeping/InternalHousekeepingPacket.h b/housekeeping/HousekeepingPacketUpdate.h
similarity index 86%
rename from housekeeping/InternalHousekeepingPacket.h
rename to housekeeping/HousekeepingPacketUpdate.h
index 2a9a55644..bfdcde992 100644
--- a/housekeeping/InternalHousekeepingPacket.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_HOUSEKEEPING_INTERNALHOUSEKEEPINGPACKET_H_
-#define FRAMEWORK_HOUSEKEEPING_INTERNALHOUSEKEEPINGPACKET_H_
+#ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
+#define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
 
 #include <framework/serialize/SerialBufferAdapter.h>
 #include <framework/serialize/SerialLinkedListAdapter.h>
@@ -9,7 +9,7 @@
  * @brief   This helper class will be used to serialize and deserialize
  *          internal housekeeping packets into the store.
  */
-class InternalHousekeepingPacket: public SerializeIF {
+class HousekeepingPacketUpdate: public SerializeIF {
 public:
     /**
      * @param timeStamp
@@ -17,7 +17,7 @@ public:
      * @param hkData
      * @param hkDataSize
      */
-    InternalHousekeepingPacket(uint8_t* timeStamp, size_t timeStampSize,
+    HousekeepingPacketUpdate(uint8_t* timeStamp, size_t timeStampSize,
             LocalPoolDataSetBase* dataSetPtr):
             timeStamp(timeStamp), timeStampSize(timeStampSize),
             dataSetPtr(dataSetPtr) {};
@@ -70,4 +70,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_HOUSEKEEPING_INTERNALHOUSEKEEPINGPACKET_H_ */
+#endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_ */

From 87eb31b65aa7c68c4b3ad40cfac7353349b7b968 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 9 Aug 2020 20:06:29 +0200
Subject: [PATCH 0636/1774] local data pool manager uses new packet now

---
 datapoollocal/LocalDataPoolManager.cpp    | 51 +++++++---------
 datapoollocal/LocalDataPoolManager.h      | 10 ++--
 housekeeping/HousekeepingPacketDownlink.h | 72 ++++++++++++-----------
 housekeeping/HousekeepingPacketUpdate.h   | 10 ++--
 4 files changed, 71 insertions(+), 72 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 7c41ff2a4..3c5f0c1bd 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,6 +1,7 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalPoolDataSetBase.h>
 #include <framework/housekeeping/AcceptsHkPacketsIF.h>
+#include <framework/housekeeping/HousekeepingPacketDownlink.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 #include <framework/ipc/QueueFactory.h>
@@ -121,7 +122,7 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        MessageQueueId_t sendTo) {
+        float collectionInterval, MessageQueueId_t sendTo) {
 	LocalPoolDataSetBase* dataSetToSerialize = dynamic_cast<LocalPoolDataSetBase*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
@@ -136,8 +137,9 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 //	}
 
 	store_address_t storeId;
-	ReturnValue_t result = serializeHkPacketIntoStore(&storeId,
-	        dataSetToSerialize);
+	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
+	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
+	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 	    return result;
 	}
@@ -166,6 +168,22 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	return result;
 }
 
+ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
+        HousekeepingPacketDownlink& hkPacket,
+        store_address_t *storeId) {
+    uint8_t* dataPtr = nullptr;
+    size_t serializedSize = hkPacket.getSerializedSize();
+    const size_t maxSize = serializedSize;
+    ReturnValue_t  result = ipcStore->getFreeElement(storeId,
+            serializedSize, &dataPtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    return hkPacket.serialize(&dataPtr, &serializedSize, maxSize,
+            SerializeIF::Endianness::MACHINE);
+}
+
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
     LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
             owner->getDataSetHandle(sid));
@@ -199,33 +217,6 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
     this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
 }
 
-ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-        store_address_t *storeId, LocalPoolDataSetBase* dataSet) {
-    size_t hkSize = dataSet->getSerializedSize();
-    uint8_t* storePtr = nullptr;
-    ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                "Could not get free element from IPC store." << std::endl;
-        return result;
-    }
-    size_t size = 0;
-
-    if(appendValidityBuffer) {
-        result = dataSet->serializeWithValidityBuffer(&storePtr,
-                &size, hkSize, SerializeIF::Endianness::MACHINE);
-    }
-    else {
-        result = dataSet->serialize(&storePtr, &size, hkSize,
-                SerializeIF::Endianness::MACHINE);
-    }
-
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::serializeHkPacketIntoStore: "
-                "Serialization proccess failed!" << std::endl;
-    }
-    return result;
-}
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
     for(auto& hkReceiversIter: hkReceiversMap) {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index d9e84f4ee..d0d3d8055 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -8,6 +8,7 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <framework/datapool/PoolEntry.h>
 #include <framework/datapoollocal/HasLocalDataPoolIF.h>
+#include <framework/housekeeping/HousekeepingPacketDownlink.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MutexHelper.h>
@@ -101,8 +102,8 @@ public:
 	 * @param sid
 	 * @return
 	 */
-	ReturnValue_t generateHousekeepingPacket(sid_t sid, MessageQueueId_t sendTo
-	        = MessageQueueIF::NO_QUEUE);
+	ReturnValue_t generateHousekeepingPacket(sid_t sid, float collectionInterval,
+	        MessageQueueId_t sendTo = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
@@ -237,8 +238,9 @@ private:
 			PoolEntry<T> **poolEntry);
 
 	void setMinimalSamplingFrequency(float frequencySeconds);
-	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
-	        LocalPoolDataSetBase* dataSet);
+	ReturnValue_t serializeHkPacketIntoStore(
+	        HousekeepingPacketDownlink& hkPacket,
+	        store_address_t *storeId);
 
 	uint32_t intervalSecondsToInterval(bool isDiagnostics,
 	        float collectionIntervalSeconds);
diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
index d386bfdf3..feb49c590 100644
--- a/housekeeping/HousekeepingPacketDownlink.h
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -1,5 +1,6 @@
 #ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
 #define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+
 #include <framework/datapoollocal/LocalPoolDataSetBase.h>
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <framework/serialize/SerialLinkedListAdapter.h>
@@ -18,40 +19,32 @@ public:
             numberOfParameters, LocalPoolDataSetBase* dataSetPtr):
             sourceId(sid.objectId), setId(sid.ownerSetId),
             collectionInterval(collectionInterval),
-            numberOfParameters(numberOfParameters), dataSetPtr(dataSetPtr),
-            hkData(dataSetPtr) {
+            numberOfParameters(numberOfParameters), hkData(dataSetPtr) {
         setLinks();
     }
 
-//    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-//                size_t maxSize, Endianness streamEndianness) const override {
-//        ReturnValue_t result = SerialLinkedListAdapter::serialize(buffer, size,
-//                maxSize, streamEndianness);
-//        if(result != HasReturnvaluesIF::RETURN_OK) {
-//            return result;
-//        }
-//        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
-//   }
-//
-//   virtual size_t getSerializedSize() const override {
-//
-//   }
+    /**
+     * Helper functions which can be used to move HK data from the IPC store
+     * to the telemetry store.
+     * @param formerStore
+     * @param storeId
+     * @param newStore
+     * @param newStoreId [out]
+     * @return
+     */
+    virtual ReturnValue_t moveToOtherStore(StorageManagerIF* formerStore,
+            store_address_t storeId, StorageManagerIF* newStore,
+            store_address_t* newStoreId) {
+        const uint8_t* dataPtr = nullptr;
+        size_t hkDataSize = 0;
+        ReturnValue_t result = formerStore->getData(storeId, &dataPtr,
+                &hkDataSize);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
 
-   virtual ReturnValue_t moveToOtherStore(StorageManagerIF* formerStore,
-           store_address_t storeId, StorageManagerIF* otherStore,
-           store_address_t* newStoreId, uint8_t** buffer, size_t size) {
-       const uint8_t* dataPtr = nullptr;
-       size_t hkDataSize = 0;
-       ReturnValue_t result = formerStore->getData(storeId, &dataPtr, &hkDataSize);
-       if(result != HasReturnvaluesIF::RETURN_OK) {
-           return result;
-       }
-
-       otherStore->addData(newStoreId, dataPtrgetSerializedSize(),
-               buffer);
-       std::memcpy
-
-   }
+        return newStore->addData(newStoreId, dataPtr, hkDataSize);
+    }
 
 private:
     void setLinks() {
@@ -67,9 +60,22 @@ private:
     SerializeElement<float> collectionInterval;
     SerializeElement<uint8_t> numberOfParameters;
     LinkedElement<SerializeIF> hkData;
-    LocalPoolDataSetBase* dataSetPtr;
 };
 
-
-
 #endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_ */
+
+
+
+//    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+//                size_t maxSize, Endianness streamEndianness) const override {
+//        ReturnValue_t result = SerialLinkedListAdapter::serialize(buffer, size,
+//                maxSize, streamEndianness);
+//        if(result != HasReturnvaluesIF::RETURN_OK) {
+//            return result;
+//        }
+//        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
+//   }
+//
+//   virtual size_t getSerializedSize() const override {
+//
+//   }
diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index bfdcde992..e7b644f58 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -7,7 +7,7 @@
 
 /**
  * @brief   This helper class will be used to serialize and deserialize
- *          internal housekeeping packets into the store.
+ *          update housekeeping packets into the store.
  */
 class HousekeepingPacketUpdate: public SerializeIF {
 public:
@@ -25,8 +25,8 @@ public:
     virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
             size_t maxSize, Endianness streamEndianness) const {
         if(timeStamp != nullptr) {
-            // Endianness will always be MACHINE, so we can simply use memcpy
-            // here.
+            /* Endianness will always be MACHINE, so we can simply use memcpy
+            here. */
             std::memcpy(*buffer, timeStamp, timeStampSize);
             *size += timeStampSize;
             *buffer += timeStampSize;
@@ -48,8 +48,8 @@ public:
     virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
             SerializeIF::Endianness streamEndianness) override {
         if(timeStamp != nullptr) {
-            // Endianness will always be MACHINE, so we can simply use memcpy
-            // here.
+            /* Endianness will always be MACHINE, so we can simply use memcpy
+            here. */
             std::memcpy(timeStamp, *buffer, timeStampSize);
             *size += timeStampSize;
             *buffer += timeStampSize;

From f39b8bdb419bd2832d8b1e6b44b13ece12ceb0b8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 10 Aug 2020 18:33:28 +0200
Subject: [PATCH 0637/1774] several simplifications

---
 datapoollocal/LocalDataPoolManager.cpp |  9 ++-------
 datapoollocal/LocalDataPoolManager.h   |  2 +-
 housekeeping/HousekeepingMessage.cpp   | 15 +++------------
 housekeeping/HousekeepingMessage.h     |  2 --
 osal/FreeRTOS/MessageQueue.cpp         |  1 +
 5 files changed, 7 insertions(+), 22 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 3c5f0c1bd..5373edb44 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -131,11 +131,6 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	// do we generate hk packets for invalid datasets?
-//	if(not dataSetToSerialize->isValid()) {
-//	    return HasReturnvaluesIF::RETURN_OK;
-//	}
-
 	store_address_t storeId;
 	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
 	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
@@ -249,7 +244,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
     if(receiver->intervalCounter >= intervalSecondsToInterval(
             receiver->isDiagnostics,
-            receiver->hkParameter.collectionInterval)) {
+            receiver->hkParameter.collectionIntervalSeconds)) {
         ReturnValue_t result = generateHousekeepingPacket(
                 receiver->dataId.dataSetSid, receiver->destinationQueue);
         if(result != HasReturnvaluesIF::RETURN_OK) {
@@ -279,7 +274,7 @@ uint32_t LocalDataPoolManager::intervalSecondsToInterval(bool isDiagnostics,
 float LocalDataPoolManager::intervalToIntervalSeconds(bool isDiagnostics,
         uint32_t collectionInterval) {
     if(isDiagnostics) {
-        return  static_cast<float>(collectionInterval * diagnosticMinimumInterval);
+        return static_cast<float>(collectionInterval * diagnosticMinimumInterval);
     }
     else {
         return static_cast<float>(collectionInterval * regularMinimumInterval);
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index d0d3d8055..068d2703e 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -176,7 +176,7 @@ private:
         type */
         union HkParameter {
             /** This parameter will be used for the PERIODIC type */
-            dur_seconds_t collectionInterval = 0;
+            float collectionIntervalSeconds = 0;
             /** This parameter will be used for the ON_UPDATE type */
             bool hkDataChanged;
         };
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 2335f03dd..2b1da8514 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -8,7 +8,7 @@ void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
 	message->setCommand(HK_REPORT);
 	message->setMessageSize(HK_MESSAGE_SIZE);
 	setSid(message, sid);
-	setParameter(message, storeId.raw);
+	message->setParameter3(storeId.raw);
 }
 
 void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
@@ -16,13 +16,13 @@ void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
 	message->setCommand(DIAGNOSTICS_REPORT);
 	message->setMessageSize(HK_MESSAGE_SIZE);
 	setSid(message, sid);
-	setParameter(message, storeId.raw);
+	message->setParameter3(storeId.raw);
 }
 
 sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
 		store_address_t *storeIdToSet) {
 	if(storeIdToSet != nullptr) {
-		*storeIdToSet = getParameter(message);
+	    *storeIdToSet = message->getParameter3();
 	}
 	return getSid(message);
 }
@@ -37,12 +37,3 @@ void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
 	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
 }
 
-
-void HousekeepingMessage::setParameter(CommandMessage *message,
-		uint32_t parameter) {
-	message->setParameter3(parameter);
-}
-
-uint32_t HousekeepingMessage::getParameter(const CommandMessage *message) {
-	return message->getParameter3();
-}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index db6d3ab86..f62beafae 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -112,8 +112,6 @@ public:
 
 private:
 	static void setSid(CommandMessage* message, sid_t sid);
-	static void setParameter(CommandMessage* message, uint32_t parameter);
-	static uint32_t getParameter(const CommandMessage* message);
 };
 
 
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index e9f3871e2..398d1300c 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -132,6 +132,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	else  {
 		destination = reinterpret_cast<QueueHandle_t>(sendTo);
 	}
+
     message->setSender(sentFrom);
 
 

From fbecda75492905c8c8301b774d66ee777e791037 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 18 Aug 2020 13:09:15 +0200
Subject: [PATCH 0638/1774] include replacements

---
 action/ActionHelper.cpp                       |  220 +-
 action/ActionHelper.h                         |  186 +-
 action/ActionMessage.cpp                      |  158 +-
 action/ActionMessage.h                        |   64 +-
 action/CommandActionHelper.cpp                |  254 +-
 action/CommandActionHelper.h                  |   72 +-
 action/CommandsActionsIF.h                    |   68 +-
 action/HasActionsIF.h                         |  120 +-
 action/SimpleActionHelper.cpp                 |  148 +-
 action/SimpleActionHelper.h                   |   48 +-
 container/ArrayList.h                         |  494 +--
 container/DynamicFIFO.h                       |   84 +-
 container/FIFO.h                              |   68 +-
 container/FIFOBase.h                          |  130 +-
 container/FixedArrayList.h                    |  114 +-
 container/FixedMap.h                          |  450 +--
 container/FixedOrderedMultimap.h              |  362 +--
 container/HybridIterator.h                    |  180 +-
 container/IndexedRingMemoryArray.h            | 1442 ++++-----
 container/PlacementFactory.h                  |   70 +-
 container/RingBufferBase.h                    |  226 +-
 container/SharedRingBuffer.cpp                |   60 +-
 container/SharedRingBuffer.h                  |  136 +-
 container/SimpleRingBuffer.cpp                |  254 +-
 container/SimpleRingBuffer.h                  |  238 +-
 controller/ControllerBase.cpp                 |  274 +-
 controller/ControllerBase.h                   |  158 +-
 coordinates/CoordinateTransformations.cpp     |  454 +--
 coordinates/CoordinateTransformations.h       |   68 +-
 coordinates/Jgm3Model.h                       |  360 +--
 coordinates/Sgp4Propagator.cpp                |  456 +--
 coordinates/Sgp4Propagator.h                  |   88 +-
 datalinklayer/BCFrame.h                       |  124 +-
 datalinklayer/CCSDSReturnValuesIF.h           |  112 +-
 datalinklayer/Clcw.cpp                        |  126 +-
 datalinklayer/Clcw.h                          |  132 +-
 datalinklayer/DataLinkLayer.cpp               |  278 +-
 datalinklayer/DataLinkLayer.h                 |  224 +-
 datalinklayer/Farm1StateIF.h                  |  108 +-
 datalinklayer/Farm1StateLockout.cpp           |   70 +-
 datalinklayer/Farm1StateLockout.h             |  118 +-
 datalinklayer/Farm1StateOpen.cpp              |   98 +-
 datalinklayer/Farm1StateOpen.h                |  124 +-
 datalinklayer/Farm1StateWait.cpp              |   86 +-
 datalinklayer/Farm1StateWait.h                |  116 +-
 datalinklayer/MapPacketExtraction.cpp         |  308 +-
 datalinklayer/MapPacketExtraction.h           |  156 +-
 datalinklayer/MapPacketExtractionIF.h         |   94 +-
 datalinklayer/TcTransferFrame.cpp             |  204 +-
 datalinklayer/TcTransferFrameLocal.cpp        |   98 +-
 datalinklayer/TcTransferFrameLocal.h          |   98 +-
 datalinklayer/VirtualChannelReception.cpp     |  242 +-
 datalinklayer/VirtualChannelReception.h       |  228 +-
 datalinklayer/VirtualChannelReceptionIF.h     |  114 +-
 datapool/ControllerSet.cpp                    |   28 +-
 datapool/ControllerSet.h                      |   30 +-
 datapool/DataSetBase.cpp                      |  336 +-
 datapool/DataSetBase.h                        |  298 +-
 datapool/DataSetIF.h                          |  124 +-
 datapool/HkSwitchHelper.cpp                   |  150 +-
 datapool/HkSwitchHelper.h                     |   92 +-
 datapool/PoolEntry.cpp                        |  174 +-
 datapool/PoolEntry.h                          |  260 +-
 datapool/PoolEntryIF.h                        |  126 +-
 datapool/PoolRawAccessHelper.cpp              |    8 +-
 datapool/PoolRawAccessHelper.h                |    6 +-
 datapool/PoolVarList.h                        |   56 +-
 datapool/PoolVariableIF.h                     |  198 +-
 datapoolglob/DataPoolAdmin.cpp                |  600 ++--
 datapoolglob/DataPoolAdmin.h                  |  118 +-
 datapoolglob/DataPoolParameterWrapper.cpp     |  358 +--
 datapoolglob/DataPoolParameterWrapper.h       |   76 +-
 datapoolglob/GlobalDataPool.cpp               |  266 +-
 datapoolglob/GlobalDataPool.h                 |  298 +-
 datapoolglob/GlobalDataSet.cpp                |   88 +-
 datapoolglob/GlobalDataSet.h                  |  192 +-
 datapoolglob/GlobalPoolVariable.h             |  426 +--
 datapoolglob/GlobalPoolVector.h               |  370 +--
 datapoolglob/PIDReader.h                      |  328 +-
 datapoolglob/PIDReaderList.h                  |   54 +-
 datapoolglob/PoolRawAccess.cpp                |  478 +--
 datapoolglob/PoolRawAccess.h                  |  440 +--
 datapoollocal/HasLocalDataPoolIF.h            |  154 +-
 datapoollocal/LocalDataPoolManager.cpp        |  436 +--
 datapoollocal/LocalDataPoolManager.h          |  458 +--
 datapoollocal/LocalDataSet.cpp                |  212 +-
 datapoollocal/LocalDataSet.h                  |  230 +-
 datapoollocal/LocalPoolVariable.h             |  346 +-
 datapoollocal/LocalPoolVector.h               |  400 +--
 datapoollocal/StaticLocalDataSet.cpp          |   12 +-
 datapoollocal/StaticLocalDataSet.h            |   22 +-
 devicehandlers/AcceptsDeviceResponsesIF.h     |   38 +-
 devicehandlers/AssemblyBase.cpp               |  546 ++--
 devicehandlers/AssemblyBase.h                 |  326 +-
 devicehandlers/ChildHandlerBase.cpp           |   94 +-
 devicehandlers/ChildHandlerBase.h             |   48 +-
 devicehandlers/ChildHandlerFDIR.cpp           |   20 +-
 devicehandlers/ChildHandlerFDIR.h             |   40 +-
 devicehandlers/CommunicationMessage.cpp       |    4 +-
 devicehandlers/CommunicationMessage.h         |    8 +-
 devicehandlers/DeviceCommunicationIF.h        |  254 +-
 devicehandlers/DeviceHandlerBase.cpp          | 2794 ++++++++---------
 devicehandlers/DeviceHandlerBase.h            | 2414 +++++++-------
 .../DeviceHandlerFailureIsolation.cpp         |  502 +--
 .../DeviceHandlerFailureIsolation.h           |  108 +-
 devicehandlers/DeviceHandlerIF.h              |  310 +-
 devicehandlers/DeviceHandlerMessage.cpp       |  202 +-
 devicehandlers/DeviceHandlerMessage.h         |  182 +-
 devicehandlers/DeviceTmReportingWrapper.cpp   |   92 +-
 devicehandlers/DeviceTmReportingWrapper.h     |   54 +-
 devicehandlers/HealthDevice.cpp               |  118 +-
 devicehandlers/HealthDevice.h                 |   80 +-
 events/Event.cpp                              |   28 +-
 events/Event.h                                |   90 +-
 events/EventManager.cpp                       |  330 +-
 events/EventManager.h                         |  122 +-
 events/EventManagerIF.h                       |  104 +-
 events/EventMessage.cpp                       |  228 +-
 events/EventMessage.h                         |  104 +-
 events/EventReportingProxyIF.h                |   38 +-
 events/eventmatching/EventIdRangeMatcher.cpp  |   24 +-
 events/eventmatching/EventIdRangeMatcher.h    |   26 +-
 events/eventmatching/EventMatchTree.cpp       |  298 +-
 events/eventmatching/EventMatchTree.h         |   72 +-
 events/eventmatching/EventRangeMatcherBase.h  |   58 +-
 events/eventmatching/ReporterRangeMatcher.cpp |   26 +-
 events/eventmatching/ReporterRangeMatcher.h   |   26 +-
 events/eventmatching/SeverityRangeMatcher.cpp |   28 +-
 events/eventmatching/SeverityRangeMatcher.h   |   26 +-
 events/eventmatching/eventmatching.h          |   20 +-
 fdir/ConfirmsFailuresIF.h                     |   40 +-
 fdir/EventCorrelation.cpp                     |   88 +-
 fdir/EventCorrelation.h                       |   46 +-
 fdir/FailureIsolationBase.cpp                 |  328 +-
 fdir/FailureIsolationBase.h                   |  112 +-
 fdir/FaultCounter.cpp                         |  172 +-
 fdir/FaultCounter.h                           |   76 +-
 globalfunctions/AsciiConverter.cpp            |  460 +--
 globalfunctions/AsciiConverter.h              |   78 +-
 globalfunctions/CRC.cpp                       |  278 +-
 globalfunctions/DleEncoder.cpp                |  246 +-
 globalfunctions/DleEncoder.h                  |  158 +-
 globalfunctions/Type.cpp                      |  362 +--
 globalfunctions/Type.h                        |  188 +-
 globalfunctions/arrayprinter.cpp              |  122 +-
 globalfunctions/matching/BinaryMatcher.h      |   82 +-
 globalfunctions/matching/DecimalMatcher.h     |  100 +-
 globalfunctions/matching/MatchTree.h          |  432 +--
 globalfunctions/matching/RangeMatcher.h       |  140 +-
 .../matching/SerializeableMatcherIF.h         |   26 +-
 globalfunctions/math/QuaternionOperations.cpp |  312 +-
 globalfunctions/timevalOperations.cpp         |  198 +-
 health/HasHealthIF.h                          |  100 +-
 health/HealthHelper.cpp                       |  210 +-
 health/HealthHelper.h                         |  242 +-
 health/HealthMessage.cpp                      |   56 +-
 health/HealthMessage.h                        |   60 +-
 health/HealthTable.cpp                        |  200 +-
 health/HealthTable.h                          |   70 +-
 health/HealthTableIF.h                        |   56 +-
 health/ManagesHealthIF.h                      |  104 +-
 housekeeping/AcceptsHkPacketsIF.h             |   22 +-
 housekeeping/HousekeepingMessage.cpp          |   96 +-
 housekeeping/HousekeepingMessage.h            |  232 +-
 internalError/InternalErrorReporter.cpp       |  250 +-
 internalError/InternalErrorReporter.h         |  100 +-
 ipc/CommandMessage.cpp                        |  222 +-
 ipc/CommandMessage.h                          |  258 +-
 ipc/CommandMessageCleaner.cpp                 |   90 +-
 ipc/CommandMessageCleaner.h                   |   32 +-
 ipc/CommandMessageIF.h                        |  146 +-
 ipc/MessageQueueIF.h                          |  284 +-
 ipc/MessageQueueMessage.cpp                   |  168 +-
 ipc/MessageQueueMessage.h                     |  300 +-
 ipc/MessageQueueSenderIF.h                    |   50 +-
 ipc/MutexFactory.h                            |   68 +-
 ipc/MutexHelper.h                             |   60 +-
 ipc/MutexIF.h                                 |  178 +-
 ipc/QueueFactory.h                            |   66 +-
 memory/AcceptsMemoryMessagesIF.h              |   42 +-
 memory/FileSystemMessage.cpp                  |   56 +-
 memory/FileSystemMessage.h                    |   60 +-
 memory/HasFileSystemIF.h                      |   72 +-
 memory/HasMemoryIF.h                          |   94 +-
 memory/MemoryHelper.cpp                       |  386 +--
 memory/MemoryHelper.h                         |   74 +-
 memory/MemoryMessage.cpp                      |  224 +-
 memory/MemoryMessage.h                        |   78 +-
 memory/MemoryProxyIF.h                        |   44 +-
 modes/HasModesIF.h                            |  114 +-
 modes/ModeHelper.cpp                          |  270 +-
 modes/ModeHelper.h                            |  106 +-
 modes/ModeMessage.cpp                         |   62 +-
 modes/ModeMessage.h                           |   80 +-
 monitoring/AbsLimitMonitor.h                  |  146 +-
 monitoring/HasMonitorsIF.h                    |   60 +-
 monitoring/LimitMonitor.h                     |  190 +-
 monitoring/LimitViolationReporter.cpp         |  120 +-
 monitoring/LimitViolationReporter.h           |   62 +-
 monitoring/MonitorBase.h                      |  124 +-
 monitoring/MonitorReporter.h                  |  356 +--
 monitoring/MonitoringIF.h                     |  134 +-
 monitoring/MonitoringMessage.cpp              |   76 +-
 monitoring/MonitoringMessage.h                |   42 +-
 monitoring/MonitoringMessageContent.h         |  154 +-
 monitoring/ReceivesMonitoringReportsIF.h      |   30 +-
 monitoring/TriplexMonitor.h                   |  310 +-
 monitoring/TwoValueLimitMonitor.h             |   88 +-
 objectmanager/ObjectManager.cpp               |  216 +-
 objectmanager/ObjectManager.h                 |  134 +-
 objectmanager/ObjectManagerIF.h               |  190 +-
 objectmanager/SystemObject.cpp                |   74 +-
 objectmanager/SystemObject.h                  |  122 +-
 objectmanager/SystemObjectIF.h                |  124 +-
 osal/FreeRTOS/BinSemaphUsingTask.cpp          |  182 +-
 osal/FreeRTOS/BinSemaphUsingTask.h            |  150 +-
 osal/FreeRTOS/BinarySemaphore.cpp             |   14 +-
 osal/FreeRTOS/BinarySemaphore.h               |    4 +-
 osal/FreeRTOS/Clock.cpp                       |  392 +--
 osal/FreeRTOS/CountingSemaphUsingTask.cpp     |  220 +-
 osal/FreeRTOS/CountingSemaphUsingTask.h       |  200 +-
 osal/FreeRTOS/CountingSemaphore.cpp           |   86 +-
 osal/FreeRTOS/CountingSemaphore.h             |   68 +-
 osal/FreeRTOS/FixedTimeslotTask.cpp           |  324 +-
 osal/FreeRTOS/FixedTimeslotTask.h             |  202 +-
 osal/FreeRTOS/MessageQueue.cpp                |  310 +-
 osal/FreeRTOS/MessageQueue.h                  |  424 +--
 osal/FreeRTOS/Mutex.cpp                       |  102 +-
 osal/FreeRTOS/Mutex.h                         |   58 +-
 osal/FreeRTOS/MutexFactory.cpp                |   56 +-
 osal/FreeRTOS/PeriodicTask.cpp                |  276 +-
 osal/FreeRTOS/PeriodicTask.h                  |  256 +-
 osal/FreeRTOS/QueueFactory.cpp                |   72 +-
 osal/FreeRTOS/SemaphoreFactory.cpp            |  122 +-
 osal/FreeRTOS/TaskFactory.cpp                 |  106 +-
 osal/FreeRTOS/TaskManagement.cpp              |   12 +-
 osal/FreeRTOS/TaskManagement.h                |   20 +-
 osal/FreeRTOS/Timekeeper.cpp                  |   82 +-
 osal/FreeRTOS/Timekeeper.h                    |   80 +-
 osal/InternalErrorCodes.h                     |   78 +-
 osal/host/Clock.cpp                           |  454 +--
 osal/host/FixedTimeslotTask.cpp               |  382 +--
 osal/host/FixedTimeslotTask.h                 |  260 +-
 osal/host/MessageQueue.cpp                    |  310 +-
 osal/host/MessageQueue.h                      |  460 +--
 osal/host/Mutex.cpp                           |   80 +-
 osal/host/Mutex.h                             |   56 +-
 osal/host/MutexFactory.cpp                    |   56 +-
 osal/host/PeriodicTask.cpp                    |  352 +--
 osal/host/PeriodicTask.h                      |  246 +-
 osal/host/QueueFactory.cpp                    |   82 +-
 osal/host/QueueMapManager.cpp                 |  102 +-
 osal/host/QueueMapManager.h                   |   94 +-
 osal/host/SemaphoreFactory.cpp                |   84 +-
 osal/host/TaskFactory.cpp                     |  110 +-
 osal/linux/BinarySemaphore.cpp                |    4 +-
 osal/linux/BinarySemaphore.h                  |    4 +-
 osal/linux/Clock.cpp                          |  440 +--
 osal/linux/CountingSemaphore.cpp              |  108 +-
 osal/linux/CountingSemaphore.h                |   74 +-
 osal/linux/FixedTimeslotTask.cpp              |  182 +-
 osal/linux/FixedTimeslotTask.h                |  154 +-
 osal/linux/InternalErrorCodes.cpp             |   28 +-
 osal/linux/MessageQueue.cpp                   |  738 ++---
 osal/linux/MessageQueue.h                     |  374 +--
 osal/linux/Mutex.cpp                          |  222 +-
 osal/linux/Mutex.h                            |   44 +-
 osal/linux/MutexFactory.cpp                   |   46 +-
 osal/linux/PeriodicPosixTask.cpp              |  164 +-
 osal/linux/PeriodicPosixTask.h                |  180 +-
 osal/linux/PosixThread.cpp                    |  434 +--
 osal/linux/PosixThread.h                      |  154 +-
 osal/linux/QueueFactory.cpp                   |   76 +-
 osal/linux/SemaphoreFactory.cpp               |   72 +-
 osal/linux/TaskFactory.cpp                    |   84 +-
 osal/linux/TcUnixUdpPollingTask.cpp           |  274 +-
 osal/linux/TcUnixUdpPollingTask.h             |  134 +-
 osal/linux/Timer.cpp                          |   84 +-
 osal/linux/TmTcUnixUdpBridge.cpp              |  336 +-
 osal/linux/TmTcUnixUdpBridge.h                |   96 +-
 osal/rtems/Clock.cpp                          |  396 +--
 osal/rtems/CpuUsage.cpp                       |  366 +--
 osal/rtems/CpuUsage.h                         |  106 +-
 osal/rtems/InternalErrorCodes.cpp             |  120 +-
 osal/rtems/Interrupt.h                        |  100 +-
 osal/rtems/MessageQueue.cpp                   |  294 +-
 osal/rtems/MessageQueue.h                     |  362 +--
 osal/rtems/MultiObjectTask.cpp                |  174 +-
 osal/rtems/MultiObjectTask.h                  |  226 +-
 osal/rtems/Mutex.cpp                          |  130 +-
 osal/rtems/Mutex.h                            |   36 +-
 osal/rtems/MutexFactory.cpp                   |   48 +-
 osal/rtems/PollingTask.cpp                    |  244 +-
 osal/rtems/PollingTask.h                      |  170 +-
 osal/rtems/QueueFactory.cpp                   |  118 +-
 osal/rtems/RtemsBasic.h                       |   50 +-
 osal/rtems/TaskBase.cpp                       |  164 +-
 osal/rtems/TaskBase.h                         |   94 +-
 osal/rtems/TaskFactory.cpp                    |   82 +-
 parameters/HasParametersIF.h                  |  134 +-
 parameters/ParameterHelper.cpp                |  264 +-
 parameters/ParameterHelper.h                  |   72 +-
 parameters/ParameterMessage.cpp               |   96 +-
 parameters/ParameterMessage.h                 |   58 +-
 parameters/ParameterWrapper.cpp               |  560 ++--
 parameters/ParameterWrapper.h                 |  324 +-
 parameters/ReceivesParameterMessagesIF.h      |   38 +-
 power/Fuse.cpp                                |  520 +--
 power/Fuse.h                                  |  212 +-
 power/PowerComponent.cpp                      |  172 +-
 power/PowerComponent.h                        |   96 +-
 power/PowerComponentIF.h                      |   48 +-
 power/PowerSensor.cpp                         |  256 +-
 power/PowerSensor.h                           |  142 +-
 power/PowerSwitchIF.h                         |  160 +-
 power/PowerSwitcher.cpp                       |  254 +-
 power/PowerSwitcher.h                         |   90 +-
 pus/CService200ModeCommanding.cpp             |   12 +-
 pus/CService200ModeCommanding.h               |    2 +-
 pus/Service1TelecommandVerification.cpp       |  200 +-
 pus/Service1TelecommandVerification.h         |  188 +-
 pus/Service2DeviceAccess.cpp                  |   20 +-
 pus/Service2DeviceAccess.h                    |    6 +-
 pus/Service5EventReporting.cpp                |  182 +-
 pus/Service5EventReporting.h                  |  172 +-
 pus/Service8FunctionManagement.cpp            |   14 +-
 pus/Service8FunctionManagement.h              |    4 +-
 pus/servicepackets/Service1Packets.h          |  332 +-
 pus/servicepackets/Service200Packets.h        |    6 +-
 pus/servicepackets/Service2Packets.h          |    8 +-
 pus/servicepackets/Service5Packets.h          |  152 +-
 pus/servicepackets/Service8Packets.h          |   12 +-
 returnvalues/HasReturnvaluesIF.h              |   62 +-
 rmap/RMAP.cpp                                 |  178 +-
 rmap/RMAP.h                                   |  454 +--
 rmap/RMAPChannelIF.h                          |  232 +-
 rmap/RMAPCookie.cpp                           |  248 +-
 rmap/RMAPCookie.h                             |  118 +-
 rmap/RmapDeviceCommunicationIF.cpp            |   94 +-
 rmap/RmapDeviceCommunicationIF.h              |  178 +-
 serialize/EndianConverter.h                   |  248 +-
 serialize/SerialArrayListAdapter.h            |  182 +-
 serialize/SerialBufferAdapter.cpp             |  256 +-
 serialize/SerialBufferAdapter.h               |  156 +-
 serialize/SerialFixedArrayListAdapter.h       |  126 +-
 serialize/SerialLinkedListAdapter.h           |  266 +-
 serialize/SerializeAdapter.h                  |  350 +--
 serialize/SerializeElement.h                  |  120 +-
 serialize/SerializeIF.h                       |  116 +-
 serviceinterface/ServiceInterfaceBuffer.cpp   |  434 +--
 serviceinterface/ServiceInterfaceBuffer.h     |  290 +-
 serviceinterface/ServiceInterfaceStream.cpp   |   64 +-
 serviceinterface/ServiceInterfaceStream.h     |  116 +-
 storagemanager/ConstStorageAccessor.cpp       |  174 +-
 storagemanager/ConstStorageAccessor.h         |  232 +-
 storagemanager/LocalPool.h                    |  378 +--
 storagemanager/PoolManager.h                  |   98 +-
 storagemanager/StorageAccessor.cpp            |  134 +-
 storagemanager/StorageAccessor.h              |   90 +-
 storagemanager/StorageManagerIF.h             |  334 +-
 subsystem/Subsystem.cpp                       | 1324 ++++----
 subsystem/Subsystem.h                         |  328 +-
 subsystem/SubsystemBase.cpp                   |  712 ++---
 subsystem/SubsystemBase.h                     |  258 +-
 subsystem/modes/HasModeSequenceIF.h           |   40 +-
 subsystem/modes/ModeDefinitions.h             |  304 +-
 subsystem/modes/ModeSequenceMessage.cpp       |  178 +-
 subsystem/modes/ModeSequenceMessage.h         |   96 +-
 subsystem/modes/ModeStore.cpp                 |  252 +-
 subsystem/modes/ModeStore.h                   |   90 +-
 subsystem/modes/ModeStoreIF.h                 |   74 +-
 tasks/ExecutableObjectIF.h                    |  106 +-
 tasks/FixedSequenceSlot.cpp                   |   32 +-
 tasks/FixedSequenceSlot.h                     |  110 +-
 tasks/FixedSlotSequence.cpp                   |  248 +-
 tasks/FixedSlotSequence.h                     |  308 +-
 tasks/FixedTimeslotTaskIF.h                   |   58 +-
 tasks/PeriodicTaskIF.h                        |   98 +-
 tasks/SemaphoreFactory.h                      |   98 +-
 tasks/SemaphoreIF.h                           |  144 +-
 tasks/TaskFactory.h                           |  146 +-
 tcdistribution/CCSDSDistributor.cpp           |  164 +-
 tcdistribution/CCSDSDistributor.h             |  138 +-
 tcdistribution/CCSDSDistributorIF.h           |   80 +-
 tcdistribution/PUSDistributor.cpp             |  184 +-
 tcdistribution/PUSDistributor.h               |  154 +-
 tcdistribution/PUSDistributorIF.h             |   52 +-
 tcdistribution/TcDistributor.cpp              |  108 +-
 tcdistribution/TcDistributor.h                |  240 +-
 tcdistribution/TcPacketCheck.cpp              |   74 +-
 tcdistribution/TcPacketCheck.h                |  118 +-
 thermal/AbstractTemperatureSensor.cpp         |  140 +-
 thermal/AbstractTemperatureSensor.h           |  128 +-
 thermal/AcceptsThermalMessagesIF.h            |    2 +-
 thermal/CoreComponent.h                       |  192 +-
 thermal/Heater.cpp                            |  700 ++---
 thermal/Heater.h                              |  180 +-
 thermal/RedundantHeater.h                     |  100 +-
 thermal/TemperatureSensor.h                   |  444 +--
 thermal/ThermalComponentIF.h                  |  228 +-
 thermal/ThermalModule.cpp                     |  576 ++--
 thermal/ThermalModule.h                       |  190 +-
 thermal/ThermalMonitor.cpp                    |  136 +-
 thermal/ThermalMonitor.h                      |   52 +-
 timemanager/CCSDSTime.cpp                     | 1204 +++----
 timemanager/CCSDSTime.h                       |  466 +--
 timemanager/Clock.h                           |  310 +-
 timemanager/Countdown.cpp                     |   90 +-
 timemanager/Countdown.h                       |   62 +-
 timemanager/ReceivesTimeInfoIF.h              |   64 +-
 timemanager/Stopwatch.cpp                     |    4 +-
 timemanager/Stopwatch.h                       |    2 +-
 timemanager/TimeMessage.cpp                   |   74 +-
 timemanager/TimeMessage.h                     |  112 +-
 timemanager/TimeStamperIF.h                   |   48 +-
 tmstorage/TmStoreBackendIF.h                  |  190 +-
 tmstorage/TmStoreFrontendIF.h                 |  126 +-
 tmstorage/TmStoreMessage.cpp                  |  330 +-
 tmstorage/TmStoreMessage.h                    |  126 +-
 tmstorage/TmStorePackets.h                    |  600 ++--
 tmtcpacket/SpacePacket.cpp                    |   54 +-
 tmtcpacket/SpacePacket.h                      |  140 +-
 tmtcpacket/SpacePacketBase.cpp                |  208 +-
 tmtcpacket/SpacePacketBase.h                  |  354 +--
 tmtcpacket/packetmatcher/ApidMatcher.h        |   80 +-
 tmtcpacket/packetmatcher/PacketMatchTree.cpp  |  390 +--
 tmtcpacket/packetmatcher/PacketMatchTree.h    |   72 +-
 tmtcpacket/packetmatcher/ServiceMatcher.h     |   78 +-
 tmtcpacket/packetmatcher/SubserviceMatcher.h  |   80 +-
 tmtcpacket/pus/PacketTimestampInterpreterIF.h |   32 +-
 tmtcpacket/pus/TcPacketBase.cpp               |  186 +-
 tmtcpacket/pus/TcPacketBase.h                 |  408 +--
 tmtcpacket/pus/TcPacketStored.cpp             |  236 +-
 tmtcpacket/pus/TcPacketStored.h               |  220 +-
 tmtcpacket/pus/TmPacketBase.cpp               |  238 +-
 tmtcpacket/pus/TmPacketBase.h                 |  372 +--
 tmtcpacket/pus/TmPacketMinimal.cpp            |   90 +-
 tmtcpacket/pus/TmPacketMinimal.h              |  168 +-
 tmtcpacket/pus/TmPacketStored.cpp             |  290 +-
 tmtcpacket/pus/TmPacketStored.h               |  192 +-
 tmtcservices/AcceptsTelecommandsIF.h          |   86 +-
 tmtcservices/AcceptsTelemetryIF.h             |   52 +-
 tmtcservices/AcceptsVerifyMessageIF.h         |   30 +-
 tmtcservices/CommandingServiceBase.cpp        |  854 ++---
 tmtcservices/CommandingServiceBase.h          |  696 ++--
 tmtcservices/PusParser.cpp                    |  228 +-
 tmtcservices/PusParser.h                      |  164 +-
 tmtcservices/PusServiceBase.cpp               |  246 +-
 tmtcservices/PusServiceBase.h                 |  318 +-
 tmtcservices/PusVerificationReport.cpp        |  326 +-
 tmtcservices/PusVerificationReport.h          |  154 +-
 tmtcservices/SourceSequenceCounter.h          |   60 +-
 tmtcservices/TmTcBridge.cpp                   |   18 +-
 tmtcservices/TmTcBridge.h                     |   16 +-
 tmtcservices/TmTcMessage.cpp                  |   58 +-
 tmtcservices/TmTcMessage.h                    |  100 +-
 tmtcservices/VerificationReporter.cpp         |  210 +-
 tmtcservices/VerificationReporter.h           |  100 +-
 458 files changed, 43655 insertions(+), 43655 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index dc6bd4982..a367af161 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -1,110 +1,110 @@
-#include <framework/action/ActionHelper.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
-}
-
-ActionHelper::~ActionHelper() {
-}
-
-ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
-	if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
-		ActionId_t currentAction = ActionMessage::getActionId(command);
-		prepareExecution(command->getSender(), currentAction,
-				ActionMessage::getStoreId(command));
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return CommandMessage::UNKNOWN_COMMAND;
-	}
-}
-
-ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(queueToUse_ != nullptr) {
-		setQueueToUse(queueToUse_);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
-	queueToUse->sendMessage(reportTo, &reply);
-}
-
-void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setCompletionReply(&reply, commandId, result);
-	queueToUse->sendMessage(reportTo, &reply);
-}
-
-void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
-	queueToUse = queue;
-}
-
-void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-		store_address_t dataAddress) {
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-}
-
-ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
-		ActionId_t replyId, SerializeIF* data, bool hideSender) {
-	CommandMessage reply;
-	store_address_t storeAddress;
-	uint8_t *dataPtr;
-	size_t maxSize = data->getSerializedSize();
-	if (maxSize == 0) {
-		//No error, there's simply nothing to report.
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
-			&dataPtr);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeAddress);
-		return result;
-	}
-	//We don't need to report the objectId, as we receive REQUESTED data before the completion success message.
-	//True aperiodic replies need to be reported with another dedicated message.
-	ActionMessage::setDataReply(&reply, replyId, storeAddress);
-
-	//TODO Service Implementation sucks at the moment
-	if (hideSender){
-		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
-	} else {
-		result = queueToUse->sendMessage(reportTo, &reply);
-	}
-	if ( result != HasReturnvaluesIF::RETURN_OK){
-		ipcStore->deleteData(storeAddress);
-	}
-	return result;
-}
-
-void ActionHelper::resetHelper() {
-}
+#include "../action/ActionHelper.h"
+#include "../action/HasActionsIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
+		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
+}
+
+ActionHelper::~ActionHelper() {
+}
+
+ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
+	if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
+		ActionId_t currentAction = ActionMessage::getActionId(command);
+		prepareExecution(command->getSender(), currentAction,
+				ActionMessage::getStoreId(command));
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return CommandMessage::UNKNOWN_COMMAND;
+	}
+}
+
+ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(queueToUse_ != nullptr) {
+		setQueueToUse(queueToUse_);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+	CommandMessage reply;
+	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
+	queueToUse->sendMessage(reportTo, &reply);
+}
+
+void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+	CommandMessage reply;
+	ActionMessage::setCompletionReply(&reply, commandId, result);
+	queueToUse->sendMessage(reportTo, &reply);
+}
+
+void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
+	queueToUse = queue;
+}
+
+void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
+		store_address_t dataAddress) {
+	const uint8_t* dataPtr = NULL;
+	size_t size = 0;
+	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		CommandMessage reply;
+		ActionMessage::setStepReply(&reply, actionId, 0, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+		return;
+	}
+	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+	ipcStore->deleteData(dataAddress);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		CommandMessage reply;
+		ActionMessage::setStepReply(&reply, actionId, 0, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+		return;
+	}
+}
+
+ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
+		ActionId_t replyId, SerializeIF* data, bool hideSender) {
+	CommandMessage reply;
+	store_address_t storeAddress;
+	uint8_t *dataPtr;
+	size_t maxSize = data->getSerializedSize();
+	if (maxSize == 0) {
+		//No error, there's simply nothing to report.
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	size_t size = 0;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
+			&dataPtr);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		ipcStore->deleteData(storeAddress);
+		return result;
+	}
+	//We don't need to report the objectId, as we receive REQUESTED data before the completion success message.
+	//True aperiodic replies need to be reported with another dedicated message.
+	ActionMessage::setDataReply(&reply, replyId, storeAddress);
+
+	//TODO Service Implementation sucks at the moment
+	if (hideSender){
+		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+	} else {
+		result = queueToUse->sendMessage(reportTo, &reply);
+	}
+	if ( result != HasReturnvaluesIF::RETURN_OK){
+		ipcStore->deleteData(storeAddress);
+	}
+	return result;
+}
+
+void ActionHelper::resetHelper() {
+}
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index 3d8351d66..f528b0312 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -1,93 +1,93 @@
-#ifndef ACTIONHELPER_H_
-#define ACTIONHELPER_H_
-
-#include <framework/action/ActionMessage.h>
-#include <framework/serialize/SerializeIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-/**
- * \brief Action Helper is a helper class which handles action messages
- *
- * Components which use the HasActionIF this helper can be used to handle the action messages.
- * It does handle step messages as well as other answers to action calls. It uses the executeAction function
- * of its owner as callback. The call of the initialize function is mandatory and it needs a valid messageQueueIF pointer!
- */
-class HasActionsIF;
-
-class ActionHelper {
-public:
-	/**
-	 * Constructor of the action helper
-	 * @param setOwner Pointer to the owner of the interface
-	 * @param useThisQueue messageQueue to be used, can be set during initialize function as well.
-	 */
-	ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-
-	virtual ~ActionHelper();
-	/**
-	 * Function to be called from the owner with a new command message
-	 *
-	 * If the message is a valid action message the helper will use the executeAction function from HasActionsIF.
-	 * If the message is invalid or the callback fails a message reply will be send to the sender of the message automatically.
-	 *
-	 * @param command Pointer to a command message received by the owner
-	 * @return HasReturnvaluesIF::RETURN_OK if the message is a action message, CommandMessage::UNKNOW_COMMAND if this message ID is unkown
-	 */
-	ReturnValue_t handleActionMessage(CommandMessage* command);
-	/**
-	 * Helper initialize function. Must be called before use of any other helper function
-	 * @param queueToUse_ Pointer to the messageQueue to be used
-	 * @return Returns RETURN_OK if successful
-	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
-	/**
-	 * Function to be called from the owner to send a step message. Success or failure will be determined by the result value.
-	 *
-	 * @param step Number of steps already done
-	 * @param reportTo The messageQueueId to report the step message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner to send a action completion message
-	 *
-	 * @param reportTo MessageQueueId_t to report the action completion message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner if an action does report data
-	 *
-	 * @param reportTo MessageQueueId_t to report the action completion message to
-	 * @param replyId ID of the executed command
-	 * @param data Pointer to the data
-	 * @return Returns RETURN_OK if successful, otherwise failure code
-	 */
-	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data, bool hideSender = false);
-	/**
-	 * Function to setup the MessageQueueIF* of the helper. Can be used to set the messageQueueIF* if
-	 * message queue is unavailable at construction and initialize but must be setup before first call of other functions.
-	 * @param queue Queue to be used by the helper
-	 */
-	void setQueueToUse(MessageQueueIF *queue);
-protected:
-	static const uint8_t STEP_OFFSET = 1;//!< Increase of value of this per step
-	HasActionsIF* owner;//!< Pointer to the owner
-	MessageQueueIF* queueToUse;//!< Queue to be used as response sender, has to be set with
-	StorageManagerIF* ipcStore;//!< Pointer to an IPC Store, initialized during construction or initialize(MessageQueueIF* queueToUse_) or with setQueueToUse(MessageQueueIF *queue)
-	/**
-	 *Internal function called by handleActionMessage(CommandMessage* command)
-	 *
-	 * @param commandedBy MessageQueueID of Commander
-	 * @param actionId ID of action to be done
-	 * @param dataAddress Address of additional data in IPC Store
-	 */
-	virtual void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
-	/**
-	 *
-	 */
-	virtual void resetHelper();
-};
-
-#endif /* ACTIONHELPER_H_ */
+#ifndef ACTIONHELPER_H_
+#define ACTIONHELPER_H_
+
+#include "../action/ActionMessage.h"
+#include "../serialize/SerializeIF.h"
+#include "../ipc/MessageQueueIF.h"
+/**
+ * \brief Action Helper is a helper class which handles action messages
+ *
+ * Components which use the HasActionIF this helper can be used to handle the action messages.
+ * It does handle step messages as well as other answers to action calls. It uses the executeAction function
+ * of its owner as callback. The call of the initialize function is mandatory and it needs a valid messageQueueIF pointer!
+ */
+class HasActionsIF;
+
+class ActionHelper {
+public:
+	/**
+	 * Constructor of the action helper
+	 * @param setOwner Pointer to the owner of the interface
+	 * @param useThisQueue messageQueue to be used, can be set during initialize function as well.
+	 */
+	ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+
+	virtual ~ActionHelper();
+	/**
+	 * Function to be called from the owner with a new command message
+	 *
+	 * If the message is a valid action message the helper will use the executeAction function from HasActionsIF.
+	 * If the message is invalid or the callback fails a message reply will be send to the sender of the message automatically.
+	 *
+	 * @param command Pointer to a command message received by the owner
+	 * @return HasReturnvaluesIF::RETURN_OK if the message is a action message, CommandMessage::UNKNOW_COMMAND if this message ID is unkown
+	 */
+	ReturnValue_t handleActionMessage(CommandMessage* command);
+	/**
+	 * Helper initialize function. Must be called before use of any other helper function
+	 * @param queueToUse_ Pointer to the messageQueue to be used
+	 * @return Returns RETURN_OK if successful
+	 */
+	ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
+	/**
+	 * Function to be called from the owner to send a step message. Success or failure will be determined by the result value.
+	 *
+	 * @param step Number of steps already done
+	 * @param reportTo The messageQueueId to report the step message to
+	 * @param commandId ID of the executed command
+	 * @param result Result of the execution
+	 */
+	void step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	/**
+	 * Function to be called by the owner to send a action completion message
+	 *
+	 * @param reportTo MessageQueueId_t to report the action completion message to
+	 * @param commandId ID of the executed command
+	 * @param result Result of the execution
+	 */
+	void finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	/**
+	 * Function to be called by the owner if an action does report data
+	 *
+	 * @param reportTo MessageQueueId_t to report the action completion message to
+	 * @param replyId ID of the executed command
+	 * @param data Pointer to the data
+	 * @return Returns RETURN_OK if successful, otherwise failure code
+	 */
+	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data, bool hideSender = false);
+	/**
+	 * Function to setup the MessageQueueIF* of the helper. Can be used to set the messageQueueIF* if
+	 * message queue is unavailable at construction and initialize but must be setup before first call of other functions.
+	 * @param queue Queue to be used by the helper
+	 */
+	void setQueueToUse(MessageQueueIF *queue);
+protected:
+	static const uint8_t STEP_OFFSET = 1;//!< Increase of value of this per step
+	HasActionsIF* owner;//!< Pointer to the owner
+	MessageQueueIF* queueToUse;//!< Queue to be used as response sender, has to be set with
+	StorageManagerIF* ipcStore;//!< Pointer to an IPC Store, initialized during construction or initialize(MessageQueueIF* queueToUse_) or with setQueueToUse(MessageQueueIF *queue)
+	/**
+	 *Internal function called by handleActionMessage(CommandMessage* command)
+	 *
+	 * @param commandedBy MessageQueueID of Commander
+	 * @param actionId ID of action to be done
+	 * @param dataAddress Address of additional data in IPC Store
+	 */
+	virtual void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
+	/**
+	 *
+	 */
+	virtual void resetHelper();
+};
+
+#endif /* ACTIONHELPER_H_ */
diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index 96ff59b66..5743cc740 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -1,79 +1,79 @@
-#include <framework/action/ActionMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-
-ActionMessage::ActionMessage() {
-}
-
-ActionMessage::~ActionMessage() {
-}
-
-void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
-		store_address_t parameters) {
-	message->setCommand(EXECUTE_ACTION);
-	message->setParameter(fid);
-	message->setParameter2(parameters.raw);
-}
-
-ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
-	return ActionId_t(message->getParameter());
-}
-
-store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-void ActionMessage::setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
-		ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		message->setCommand(STEP_SUCCESS);
-	} else {
-		message->setCommand(STEP_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2((step << 16) + result);
-}
-
-uint8_t ActionMessage::getStep(const CommandMessage* message) {
-	return uint8_t((message->getParameter2() >> 16) & 0xFF);
-}
-
-ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
-	return message->getParameter2() & 0xFFFF;
-}
-
-void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
-		store_address_t data) {
-	message->setCommand(DATA_REPLY);
-	message->setParameter(actionId);
-	message->setParameter2(data.raw);
-}
-
-void ActionMessage::setCompletionReply(CommandMessage* message,
-		ActionId_t fid, ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		message->setCommand(COMPLETION_SUCCESS);
-	} else {
-		message->setCommand(COMPLETION_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2(result);
-}
-
-void ActionMessage::clear(CommandMessage* message) {
-	switch(message->getCommand()) {
-	case EXECUTE_ACTION:
-	case DATA_REPLY: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-}
+#include "../action/ActionMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+ActionMessage::ActionMessage() {
+}
+
+ActionMessage::~ActionMessage() {
+}
+
+void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
+		store_address_t parameters) {
+	message->setCommand(EXECUTE_ACTION);
+	message->setParameter(fid);
+	message->setParameter2(parameters.raw);
+}
+
+ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
+	return ActionId_t(message->getParameter());
+}
+
+store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+void ActionMessage::setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
+		ReturnValue_t result) {
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		message->setCommand(STEP_SUCCESS);
+	} else {
+		message->setCommand(STEP_FAILED);
+	}
+	message->setParameter(fid);
+	message->setParameter2((step << 16) + result);
+}
+
+uint8_t ActionMessage::getStep(const CommandMessage* message) {
+	return uint8_t((message->getParameter2() >> 16) & 0xFF);
+}
+
+ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
+	return message->getParameter2() & 0xFFFF;
+}
+
+void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
+		store_address_t data) {
+	message->setCommand(DATA_REPLY);
+	message->setParameter(actionId);
+	message->setParameter2(data.raw);
+}
+
+void ActionMessage::setCompletionReply(CommandMessage* message,
+		ActionId_t fid, ReturnValue_t result) {
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		message->setCommand(COMPLETION_SUCCESS);
+	} else {
+		message->setCommand(COMPLETION_FAILED);
+	}
+	message->setParameter(fid);
+	message->setParameter2(result);
+}
+
+void ActionMessage::clear(CommandMessage* message) {
+	switch(message->getCommand()) {
+	case EXECUTE_ACTION:
+	case DATA_REPLY: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(message));
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index 59ad619ef..aae44e162 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -1,32 +1,32 @@
-#ifndef ACTIONMESSAGE_H_
-#define ACTIONMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-typedef uint32_t ActionId_t;
-
-class ActionMessage {
-private:
-	ActionMessage();
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::ACTION;
-	static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
-	static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
-	static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
-	static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
-	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
-	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
-	virtual ~ActionMessage();
-	static void setCommand(CommandMessage* message, ActionId_t fid, store_address_t parameters);
-	static ActionId_t getActionId(const CommandMessage* message );
-	static store_address_t getStoreId(const CommandMessage* message );
-	static void setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static uint8_t getStep(const CommandMessage* message );
-	static ReturnValue_t getReturnCode(const CommandMessage* message );
-	static void setDataReply(CommandMessage* message, ActionId_t actionId, store_address_t data);
-	static void setCompletionReply(CommandMessage* message, ActionId_t fid, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static void clear(CommandMessage* message);
-};
-
-#endif /* ACTIONMESSAGE_H_ */
+#ifndef ACTIONMESSAGE_H_
+#define ACTIONMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+typedef uint32_t ActionId_t;
+
+class ActionMessage {
+private:
+	ActionMessage();
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::ACTION;
+	static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
+	static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
+	static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
+	static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
+	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
+	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
+	virtual ~ActionMessage();
+	static void setCommand(CommandMessage* message, ActionId_t fid, store_address_t parameters);
+	static ActionId_t getActionId(const CommandMessage* message );
+	static store_address_t getStoreId(const CommandMessage* message );
+	static void setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	static uint8_t getStep(const CommandMessage* message );
+	static ReturnValue_t getReturnCode(const CommandMessage* message );
+	static void setDataReply(CommandMessage* message, ActionId_t actionId, store_address_t data);
+	static void setCompletionReply(CommandMessage* message, ActionId_t fid, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	static void clear(CommandMessage* message);
+};
+
+#endif /* ACTIONMESSAGE_H_ */
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index 70ffbbdeb..d8d506aa8 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -1,127 +1,127 @@
-#include <framework/action/ActionMessage.h>
-#include <framework/action/CommandActionHelper.h>
-#include <framework/action/CommandsActionsIF.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
-		owner(setOwner), queueToUse(NULL), ipcStore(
-		NULL), commandCount(0), lastTarget(0) {
-}
-
-CommandActionHelper::~CommandActionHelper() {
-}
-
-ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, SerializeIF *data) {
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	uint8_t *storePointer;
-	size_t maxSize = data->getSerializedSize();
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
-			&storePointer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	size_t size = 0;
-	result = data->serialize(&storePointer, &size, maxSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
-}
-
-ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, const uint8_t *data, uint32_t size) {
-//	if (commandCount != 0) {
-//		return CommandsFunctionsIF::ALREADY_COMMANDING;
-//	}
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	ReturnValue_t result = ipcStore->addData(&storeId, data, size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
-}
-
-ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
-		ActionId_t actionId, store_address_t storeId) {
-	CommandMessage command;
-	ActionMessage::setCommand(&command, actionId, storeId);
-	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeId);
-	}
-	lastTarget = queueId;
-	commandCount++;
-	return result;
-}
-
-ReturnValue_t CommandActionHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	queueToUse = owner->getCommandQueuePtr();
-	if (queueToUse == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
-	if (reply->getSender() != lastTarget) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	switch (reply->getCommand()) {
-	case ActionMessage::COMPLETION_SUCCESS:
-		commandCount--;
-		owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::COMPLETION_FAILED:
-		commandCount--;
-		owner->completionFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_SUCCESS:
-		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_FAILED:
-		commandCount--;
-		owner->stepFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::DATA_REPLY:
-		extractDataForOwner(ActionMessage::getActionId(reply),
-				ActionMessage::getStoreId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t CommandActionHelper::getCommandCount() const {
-	return commandCount;
-}
-
-void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-	const uint8_t * data = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	owner->dataReceived(actionId, data, size);
-	ipcStore->deleteData(storeId);
-}
+#include "../action/ActionMessage.h"
+#include "../action/CommandActionHelper.h"
+#include "../action/CommandsActionsIF.h"
+#include "../action/HasActionsIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
+		owner(setOwner), queueToUse(NULL), ipcStore(
+		NULL), commandCount(0), lastTarget(0) {
+}
+
+CommandActionHelper::~CommandActionHelper() {
+}
+
+ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
+		ActionId_t actionId, SerializeIF *data) {
+	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+	if (receiver == NULL) {
+		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+	}
+	store_address_t storeId;
+	uint8_t *storePointer;
+	size_t maxSize = data->getSerializedSize();
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
+			&storePointer);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	size_t size = 0;
+	result = data->serialize(&storePointer, &size, maxSize,
+			SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+}
+
+ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
+		ActionId_t actionId, const uint8_t *data, uint32_t size) {
+//	if (commandCount != 0) {
+//		return CommandsFunctionsIF::ALREADY_COMMANDING;
+//	}
+	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+	if (receiver == NULL) {
+		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+	}
+	store_address_t storeId;
+	ReturnValue_t result = ipcStore->addData(&storeId, data, size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+}
+
+ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
+		ActionId_t actionId, store_address_t storeId) {
+	CommandMessage command;
+	ActionMessage::setCommand(&command, actionId, storeId);
+	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		ipcStore->deleteData(storeId);
+	}
+	lastTarget = queueId;
+	commandCount++;
+	return result;
+}
+
+ReturnValue_t CommandActionHelper::initialize() {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	queueToUse = owner->getCommandQueuePtr();
+	if (queueToUse == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
+	if (reply->getSender() != lastTarget) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	switch (reply->getCommand()) {
+	case ActionMessage::COMPLETION_SUCCESS:
+		commandCount--;
+		owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	case ActionMessage::COMPLETION_FAILED:
+		commandCount--;
+		owner->completionFailedReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getReturnCode(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	case ActionMessage::STEP_SUCCESS:
+		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getStep(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	case ActionMessage::STEP_FAILED:
+		commandCount--;
+		owner->stepFailedReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getStep(reply),
+				ActionMessage::getReturnCode(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	case ActionMessage::DATA_REPLY:
+		extractDataForOwner(ActionMessage::getActionId(reply),
+				ActionMessage::getStoreId(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t CommandActionHelper::getCommandCount() const {
+	return commandCount;
+}
+
+void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
+	const uint8_t * data = NULL;
+	size_t size = 0;
+	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	owner->dataReceived(actionId, data, size);
+	ipcStore->deleteData(storeId);
+}
diff --git a/action/CommandActionHelper.h b/action/CommandActionHelper.h
index 24d0380c6..edbcaaddd 100644
--- a/action/CommandActionHelper.h
+++ b/action/CommandActionHelper.h
@@ -1,36 +1,36 @@
-#ifndef COMMANDACTIONHELPER_H_
-#define COMMANDACTIONHELPER_H_
-
-#include <framework/action/ActionMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-class CommandsActionsIF;
-
-class CommandActionHelper {
-	friend class CommandsActionsIF;
-public:
-	CommandActionHelper(CommandsActionsIF* owner);
-	virtual ~CommandActionHelper();
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, const uint8_t* data, uint32_t size);
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, SerializeIF* data);
-	ReturnValue_t initialize();
-	ReturnValue_t handleReply(CommandMessage* reply);
-	uint8_t getCommandCount() const;
-private:
-	CommandsActionsIF* owner;
-	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore;
-	uint8_t commandCount;
-	MessageQueueId_t lastTarget;
-	void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
-	ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
-			store_address_t storeId);
-};
-
-#endif /* COMMANDACTIONHELPER_H_ */
+#ifndef COMMANDACTIONHELPER_H_
+#define COMMANDACTIONHELPER_H_
+
+#include "../action/ActionMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class CommandsActionsIF;
+
+class CommandActionHelper {
+	friend class CommandsActionsIF;
+public:
+	CommandActionHelper(CommandsActionsIF* owner);
+	virtual ~CommandActionHelper();
+	ReturnValue_t commandAction(object_id_t commandTo,
+			ActionId_t actionId, const uint8_t* data, uint32_t size);
+	ReturnValue_t commandAction(object_id_t commandTo,
+			ActionId_t actionId, SerializeIF* data);
+	ReturnValue_t initialize();
+	ReturnValue_t handleReply(CommandMessage* reply);
+	uint8_t getCommandCount() const;
+private:
+	CommandsActionsIF* owner;
+	MessageQueueIF* queueToUse;
+	StorageManagerIF* ipcStore;
+	uint8_t commandCount;
+	MessageQueueId_t lastTarget;
+	void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
+	ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
+			store_address_t storeId);
+};
+
+#endif /* COMMANDACTIONHELPER_H_ */
diff --git a/action/CommandsActionsIF.h b/action/CommandsActionsIF.h
index db76fb505..bead31406 100644
--- a/action/CommandsActionsIF.h
+++ b/action/CommandsActionsIF.h
@@ -1,34 +1,34 @@
-#ifndef COMMANDSACTIONSIF_H_
-#define COMMANDSACTIONSIF_H_
-
-#include <framework/action/CommandActionHelper.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-/**
- * Interface to separate commanding actions of other objects.
- * In next iteration, IF should be shortened to three calls:
- * - dataReceived(data)
- * - successReceived(id, step)
- * - failureReceived(id, step, cause)
- * or even
- * - replyReceived(id, step, cause) (if cause == OK, it's a success).
- */
-class CommandsActionsIF {
-	friend class CommandActionHelper;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
-	static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
-	virtual ~CommandsActionsIF() {}
-	virtual MessageQueueIF* getCommandQueuePtr() = 0;
-protected:
-	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
-	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) = 0;
-	virtual void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) = 0;
-	virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
-	virtual void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) = 0;
-};
-
-
-#endif /* COMMANDSACTIONSIF_H_ */
+#ifndef COMMANDSACTIONSIF_H_
+#define COMMANDSACTIONSIF_H_
+
+#include "../action/CommandActionHelper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+/**
+ * Interface to separate commanding actions of other objects.
+ * In next iteration, IF should be shortened to three calls:
+ * - dataReceived(data)
+ * - successReceived(id, step)
+ * - failureReceived(id, step, cause)
+ * or even
+ * - replyReceived(id, step, cause) (if cause == OK, it's a success).
+ */
+class CommandsActionsIF {
+	friend class CommandActionHelper;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
+	static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
+	virtual ~CommandsActionsIF() {}
+	virtual MessageQueueIF* getCommandQueuePtr() = 0;
+protected:
+	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
+	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) = 0;
+	virtual void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) = 0;
+	virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
+	virtual void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) = 0;
+};
+
+
+#endif /* COMMANDSACTIONSIF_H_ */
diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 008d9eaf8..283664a3a 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -1,60 +1,60 @@
-#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
-#define FRAMEWORK_ACTION_HASACTIONSIF_H_
-
-#include <framework/action/ActionHelper.h>
-#include <framework/action/ActionMessage.h>
-#include <framework/action/SimpleActionHelper.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-/**
- * @brief
- * Interface for component which uses actions
- *
- * @details
- * This interface is used to execute actions in the component. Actions, in the
- * sense of this interface, are activities with a well-defined beginning and
- * end in time. They may adjust sub-states of components, but are not supposed
- * to change the main mode of operation, which is handled with the HasModesIF
- * described below.
- *
- * The HasActionsIF allows components to define such actions and make them
- * available for other components to use. Implementing the interface is
- * straightforward: There’s a single executeAction call, which provides an
- * identifier for the action to execute, as well as arbitrary parameters for
- * input.
- * Aside from direct, software-based actions, it is used in device handler
- * components as an interface to forward commands to devices.
- * Implementing components of the interface are supposed to check identifier
- * (ID) and parameters and immediately start execution of the action.
- * It is, however, not required to immediately finish execution.
- * Instead, this may be deferred to a later point in time, at which the
- * component needs to inform the caller about finished or failed execution.
- *
- * @ingroup interfaces
- */
-class HasActionsIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
-	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
-	virtual ~HasActionsIF() { }
-	/**
-	 * Function to get the MessageQueueId_t of the implementing object
-	 * @return MessageQueueId_t of the object
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	/**
-	 * Execute or initialize the execution of a certain function.
-	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to
-	 * be done. When needing more steps, return RETURN_OK and issue steps and
-	 * completion manually.
-	 * One "step failed" or completion report must be issued!
-	 */
-	virtual ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
-};
-
-
-#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */
+#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
+#define FRAMEWORK_ACTION_HASACTIONSIF_H_
+
+#include "../action/ActionHelper.h"
+#include "../action/ActionMessage.h"
+#include "../action/SimpleActionHelper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+/**
+ * @brief
+ * Interface for component which uses actions
+ *
+ * @details
+ * This interface is used to execute actions in the component. Actions, in the
+ * sense of this interface, are activities with a well-defined beginning and
+ * end in time. They may adjust sub-states of components, but are not supposed
+ * to change the main mode of operation, which is handled with the HasModesIF
+ * described below.
+ *
+ * The HasActionsIF allows components to define such actions and make them
+ * available for other components to use. Implementing the interface is
+ * straightforward: There’s a single executeAction call, which provides an
+ * identifier for the action to execute, as well as arbitrary parameters for
+ * input.
+ * Aside from direct, software-based actions, it is used in device handler
+ * components as an interface to forward commands to devices.
+ * Implementing components of the interface are supposed to check identifier
+ * (ID) and parameters and immediately start execution of the action.
+ * It is, however, not required to immediately finish execution.
+ * Instead, this may be deferred to a later point in time, at which the
+ * component needs to inform the caller about finished or failed execution.
+ *
+ * @ingroup interfaces
+ */
+class HasActionsIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
+	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
+	virtual ~HasActionsIF() { }
+	/**
+	 * Function to get the MessageQueueId_t of the implementing object
+	 * @return MessageQueueId_t of the object
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	/**
+	 * Execute or initialize the execution of a certain function.
+	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to
+	 * be done. When needing more steps, return RETURN_OK and issue steps and
+	 * completion manually.
+	 * One "step failed" or completion report must be issued!
+	 */
+	virtual ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
+};
+
+
+#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index 6861fc28c..83ce3c854 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -1,74 +1,74 @@
-#include <framework/action/HasActionsIF.h>
-#include <framework/action/SimpleActionHelper.h>
-SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
-		MessageQueueIF* useThisQueue) :
-		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
-				0), lastAction(0), stepCount(0) {
-}
-
-SimpleActionHelper::~SimpleActionHelper() {
-}
-
-void SimpleActionHelper::step(ReturnValue_t result) {
-	//STEP_OFFESET is subtracted to compensate for adding offset in base method, which is not necessary here.
-	ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
-			result);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		resetHelper();
-	}
-}
-
-void SimpleActionHelper::finish(ReturnValue_t result) {
-	ActionHelper::finish(lastCommander, lastAction, result);
-	resetHelper();
-}
-
-ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
-	return ActionHelper::reportData(lastCommander, lastAction, data);
-}
-
-void SimpleActionHelper::resetHelper() {
-	stepCount = 0;
-	isExecuting = false;
-	lastAction = 0;
-	lastCommander = 0;
-}
-
-void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
-		ActionId_t actionId, store_address_t dataAddress) {
-	CommandMessage reply;
-	if (isExecuting) {
-		ipcStore->deleteData(dataAddress);
-		ActionMessage::setStepReply(&reply, actionId, 0,
-				HasActionsIF::IS_BUSY);
-		queueToUse->sendMessage(commandedBy, &reply);
-	}
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	lastCommander = commandedBy;
-	lastAction = actionId;
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	switch (result) {
-	case HasReturnvaluesIF::RETURN_OK:
-		isExecuting = true;
-		stepCount++;
-		break;
-	case HasActionsIF::EXECUTION_FINISHED:
-		ActionMessage::setCompletionReply(&reply, actionId,
-				HasReturnvaluesIF::RETURN_OK);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	default:
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	}
-
-}
+#include "../action/HasActionsIF.h"
+#include "../action/SimpleActionHelper.h"
+SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
+		MessageQueueIF* useThisQueue) :
+		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
+				0), lastAction(0), stepCount(0) {
+}
+
+SimpleActionHelper::~SimpleActionHelper() {
+}
+
+void SimpleActionHelper::step(ReturnValue_t result) {
+	//STEP_OFFESET is subtracted to compensate for adding offset in base method, which is not necessary here.
+	ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
+			result);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		resetHelper();
+	}
+}
+
+void SimpleActionHelper::finish(ReturnValue_t result) {
+	ActionHelper::finish(lastCommander, lastAction, result);
+	resetHelper();
+}
+
+ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
+	return ActionHelper::reportData(lastCommander, lastAction, data);
+}
+
+void SimpleActionHelper::resetHelper() {
+	stepCount = 0;
+	isExecuting = false;
+	lastAction = 0;
+	lastCommander = 0;
+}
+
+void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
+		ActionId_t actionId, store_address_t dataAddress) {
+	CommandMessage reply;
+	if (isExecuting) {
+		ipcStore->deleteData(dataAddress);
+		ActionMessage::setStepReply(&reply, actionId, 0,
+				HasActionsIF::IS_BUSY);
+		queueToUse->sendMessage(commandedBy, &reply);
+	}
+	const uint8_t* dataPtr = NULL;
+	size_t size = 0;
+	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		ActionMessage::setStepReply(&reply, actionId, 0, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+		return;
+	}
+	lastCommander = commandedBy;
+	lastAction = actionId;
+	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+	ipcStore->deleteData(dataAddress);
+	switch (result) {
+	case HasReturnvaluesIF::RETURN_OK:
+		isExecuting = true;
+		stepCount++;
+		break;
+	case HasActionsIF::EXECUTION_FINISHED:
+		ActionMessage::setCompletionReply(&reply, actionId,
+				HasReturnvaluesIF::RETURN_OK);
+		queueToUse->sendMessage(commandedBy, &reply);
+		break;
+	default:
+		ActionMessage::setStepReply(&reply, actionId, 0, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+		break;
+	}
+
+}
diff --git a/action/SimpleActionHelper.h b/action/SimpleActionHelper.h
index 71e73c5ad..05025f827 100644
--- a/action/SimpleActionHelper.h
+++ b/action/SimpleActionHelper.h
@@ -1,24 +1,24 @@
-#ifndef SIMPLEACTIONHELPER_H_
-#define SIMPLEACTIONHELPER_H_
-
-#include <framework/action/ActionHelper.h>
-
-class SimpleActionHelper: public ActionHelper {
-public:
-	SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-	virtual ~SimpleActionHelper();
-	void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	ReturnValue_t reportData(SerializeIF* data);
-
-protected:
-	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
-	virtual  void resetHelper();
-private:
-	bool isExecuting;
-	MessageQueueId_t lastCommander;
-	ActionId_t lastAction;
-	uint8_t stepCount;
-};
-
-#endif /* SIMPLEACTIONHELPER_H_ */
+#ifndef SIMPLEACTIONHELPER_H_
+#define SIMPLEACTIONHELPER_H_
+
+#include "../action/ActionHelper.h"
+
+class SimpleActionHelper: public ActionHelper {
+public:
+	SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+	virtual ~SimpleActionHelper();
+	void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	ReturnValue_t reportData(SerializeIF* data);
+
+protected:
+	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
+	virtual  void resetHelper();
+private:
+	bool isExecuting;
+	MessageQueueId_t lastCommander;
+	ActionId_t lastAction;
+	uint8_t stepCount;
+};
+
+#endif /* SIMPLEACTIONHELPER_H_ */
diff --git a/container/ArrayList.h b/container/ArrayList.h
index 8138864b7..436dc7161 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -1,247 +1,247 @@
-#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
-#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serialize/SerializeIF.h>
-
-/**
- * @brief 	A List that stores its values in an array.
- * @details
- * The underlying storage is an array that can be allocated by the class
- * itself or supplied via ctor.
- *
- * @ingroup container
- */
-template<typename T, typename count_t = uint8_t>
-class ArrayList {
-	template<typename U, typename count> friend class SerialArrayListAdapter;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
-
-    /**
-     * Copying is forbiden by declaring copy ctor and copy assignment deleted
-     * It is too ambigous in this case.
-     * (Allocate a new backend? Use the same? What to do in an modifying call?)
-     */
-	ArrayList(const ArrayList& other) = delete;
-	const ArrayList& operator=(const ArrayList& other) = delete;
-
-	/**
-	 * Number of Elements stored in this List
-	 */
-	count_t size;
-
-	/**
-	 * This is the allocating constructor;
-	 *
-	 * It allocates an array of the specified size.
-	 *
-	 * @param maxSize
-	 */
-	ArrayList(count_t maxSize) :
-			size(0), maxSize_(maxSize), allocated(true) {
-		entries = new T[maxSize];
-	}
-
-	/**
-	 * This is the non-allocating constructor
-	 *
-	 * It expects a pointer to an array of a certain size and initializes itself to it.
-	 *
-	 * @param storage the array to use as backend
-	 * @param maxSize size of storage
-	 * @param size size of data already present in storage
-	 */
-	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
-			size(size), entries(storage), maxSize_(maxSize), allocated(false) {
-	}
-
-	/**
-	 * Destructor, if the allocating constructor was used, it deletes the array.
-	 */
-	virtual ~ArrayList() {
-		if (allocated) {
-			delete[] entries;
-		}
-	}
-
-    /**
-     * An Iterator to go trough an ArrayList
-     *
-     * It stores a pointer to an element and increments the
-     * pointer when incremented itself.
-     */
-    class Iterator {
-    public:
-        /**
-         * Empty ctor, points to NULL
-         */
-        Iterator(): value(0) {}
-
-        /**
-         * Initializes the Iterator to point to an element
-         *
-         * @param initialize
-         */
-        Iterator(T *initialize) {
-            value = initialize;
-        }
-
-        /**
-         * The current element the iterator points to
-         */
-        T *value;
-
-        Iterator& operator++() {
-            value++;
-            return *this;
-        }
-
-        Iterator operator++(int) {
-            Iterator tmp(*this);
-            operator++();
-            return tmp;
-        }
-
-        Iterator& operator--() {
-            value--;
-            return *this;
-        }
-
-        Iterator operator--(int) {
-            Iterator tmp(*this);
-            operator--();
-            return tmp;
-        }
-
-        T operator*() {
-            return *value;
-        }
-
-        T *operator->() {
-            return value;
-        }
-
-        const T *operator->() const{
-            return value;
-        }
-
-        //SHOULDDO this should be implemented as non-member
-        bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const{
-            return (value == other.value);
-        }
-
-        //SHOULDDO this should be implemented as non-member
-        bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
-            return !(*this == other);
-        }
-    };
-
-	/**
-	 * Iterator pointing to the first stored elmement
-	 *
-	 * @return Iterator to the first element
-	 */
-	Iterator begin() const {
-		return Iterator(&entries[0]);
-	}
-
-	/**
-	 * returns an Iterator pointing to the element after the last stored entry
-	 *
-	 * @return Iterator to the element after the last entry
-	 */
-	Iterator end() const {
-		return Iterator(&entries[size]);
-	}
-
-	T & operator[](count_t i) const {
-		return entries[i];
-	}
-
-	/**
-	 * The first element
-	 *
-	 * @return pointer to the first stored element
-	 */
-	T *front() {
-		return entries;
-	}
-
-	/**
-	 * The last element
-	 *
-	 * does not return a valid pointer if called on an empty list.
-	 *
-	 * @return pointer to the last stored element
-	 */
-	T *back() {
-		return &entries[size - 1];
-		//Alternative solution
-		//return const_cast<T*>(static_cast<const T*>(*this).back());
-	}
-
-	const T* back() const{
-		return &entries[size-1];
-	}
-
-	/**
-	 * The maximum number of elements this List can contain
-	 *
-	 * @return maximum number of elements
-	 */
-	uint32_t maxSize() const {
-		return this->maxSize_;
-	}
-
-	/**
-	 * Insert a new element into the list.
-	 *
-	 * The new element is inserted after the last stored element.
-	 *
-	 * @param entry
-	 * @return
-	 *          -@c FULL if the List is full
-	 *          -@c RETURN_OK else
-	 */
-	ReturnValue_t insert(T entry) {
-		if (size >= maxSize_) {
-			return FULL;
-		}
-		entries[size] = entry;
-		++size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	/**
-	 * clear the List
-	 *
-	 * This does not actually clear all entries, it only sets the size to 0.
-	 */
-	void clear() {
-		size = 0;
-	}
-
-	count_t remaining() {
-		return (maxSize_ - size);
-	}
-
-protected:
-	/**
-	 * pointer to the array in which the entries are stored
-	 */
-	T *entries;
-	/**
-	 * remembering the maximum size
-	 */
-	uint32_t maxSize_;
-
-	/**
-	 * true if the array was allocated and needs to be deleted in the destructor.
-	 */
-	bool allocated;
-};
-
-#endif /* ARRAYLIST_H_ */
+#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
+#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeIF.h"
+
+/**
+ * @brief 	A List that stores its values in an array.
+ * @details
+ * The underlying storage is an array that can be allocated by the class
+ * itself or supplied via ctor.
+ *
+ * @ingroup container
+ */
+template<typename T, typename count_t = uint8_t>
+class ArrayList {
+	template<typename U, typename count> friend class SerialArrayListAdapter;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
+
+    /**
+     * Copying is forbiden by declaring copy ctor and copy assignment deleted
+     * It is too ambigous in this case.
+     * (Allocate a new backend? Use the same? What to do in an modifying call?)
+     */
+	ArrayList(const ArrayList& other) = delete;
+	const ArrayList& operator=(const ArrayList& other) = delete;
+
+	/**
+	 * Number of Elements stored in this List
+	 */
+	count_t size;
+
+	/**
+	 * This is the allocating constructor;
+	 *
+	 * It allocates an array of the specified size.
+	 *
+	 * @param maxSize
+	 */
+	ArrayList(count_t maxSize) :
+			size(0), maxSize_(maxSize), allocated(true) {
+		entries = new T[maxSize];
+	}
+
+	/**
+	 * This is the non-allocating constructor
+	 *
+	 * It expects a pointer to an array of a certain size and initializes itself to it.
+	 *
+	 * @param storage the array to use as backend
+	 * @param maxSize size of storage
+	 * @param size size of data already present in storage
+	 */
+	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
+			size(size), entries(storage), maxSize_(maxSize), allocated(false) {
+	}
+
+	/**
+	 * Destructor, if the allocating constructor was used, it deletes the array.
+	 */
+	virtual ~ArrayList() {
+		if (allocated) {
+			delete[] entries;
+		}
+	}
+
+    /**
+     * An Iterator to go trough an ArrayList
+     *
+     * It stores a pointer to an element and increments the
+     * pointer when incremented itself.
+     */
+    class Iterator {
+    public:
+        /**
+         * Empty ctor, points to NULL
+         */
+        Iterator(): value(0) {}
+
+        /**
+         * Initializes the Iterator to point to an element
+         *
+         * @param initialize
+         */
+        Iterator(T *initialize) {
+            value = initialize;
+        }
+
+        /**
+         * The current element the iterator points to
+         */
+        T *value;
+
+        Iterator& operator++() {
+            value++;
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
+
+        Iterator& operator--() {
+            value--;
+            return *this;
+        }
+
+        Iterator operator--(int) {
+            Iterator tmp(*this);
+            operator--();
+            return tmp;
+        }
+
+        T operator*() {
+            return *value;
+        }
+
+        T *operator->() {
+            return value;
+        }
+
+        const T *operator->() const{
+            return value;
+        }
+
+        //SHOULDDO this should be implemented as non-member
+        bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const{
+            return (value == other.value);
+        }
+
+        //SHOULDDO this should be implemented as non-member
+        bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
+            return !(*this == other);
+        }
+    };
+
+	/**
+	 * Iterator pointing to the first stored elmement
+	 *
+	 * @return Iterator to the first element
+	 */
+	Iterator begin() const {
+		return Iterator(&entries[0]);
+	}
+
+	/**
+	 * returns an Iterator pointing to the element after the last stored entry
+	 *
+	 * @return Iterator to the element after the last entry
+	 */
+	Iterator end() const {
+		return Iterator(&entries[size]);
+	}
+
+	T & operator[](count_t i) const {
+		return entries[i];
+	}
+
+	/**
+	 * The first element
+	 *
+	 * @return pointer to the first stored element
+	 */
+	T *front() {
+		return entries;
+	}
+
+	/**
+	 * The last element
+	 *
+	 * does not return a valid pointer if called on an empty list.
+	 *
+	 * @return pointer to the last stored element
+	 */
+	T *back() {
+		return &entries[size - 1];
+		//Alternative solution
+		//return const_cast<T*>(static_cast<const T*>(*this).back());
+	}
+
+	const T* back() const{
+		return &entries[size-1];
+	}
+
+	/**
+	 * The maximum number of elements this List can contain
+	 *
+	 * @return maximum number of elements
+	 */
+	uint32_t maxSize() const {
+		return this->maxSize_;
+	}
+
+	/**
+	 * Insert a new element into the list.
+	 *
+	 * The new element is inserted after the last stored element.
+	 *
+	 * @param entry
+	 * @return
+	 *          -@c FULL if the List is full
+	 *          -@c RETURN_OK else
+	 */
+	ReturnValue_t insert(T entry) {
+		if (size >= maxSize_) {
+			return FULL;
+		}
+		entries[size] = entry;
+		++size;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	/**
+	 * clear the List
+	 *
+	 * This does not actually clear all entries, it only sets the size to 0.
+	 */
+	void clear() {
+		size = 0;
+	}
+
+	count_t remaining() {
+		return (maxSize_ - size);
+	}
+
+protected:
+	/**
+	 * pointer to the array in which the entries are stored
+	 */
+	T *entries;
+	/**
+	 * remembering the maximum size
+	 */
+	uint32_t maxSize_;
+
+	/**
+	 * true if the array was allocated and needs to be deleted in the destructor.
+	 */
+	bool allocated;
+};
+
+#endif /* ARRAYLIST_H_ */
diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 59adfb3ad..b63cee657 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -1,42 +1,42 @@
-#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
-#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
-
-#include <framework/container/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->setData(fifoVector.data());
-	};
-
-	/**
-	 * @brief	Custom copy constructor which prevents setting the
-	 * 	        underlying pointer wrong.
-	 */
-	DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
-			fifoVector(other.maxCapacity) {
-		this->setData(fifoVector.data());
-	}
-
-
-private:
-	std::vector<T> fifoVector;
-};
-
-#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
+#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+
+#include "../container/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->setData(fifoVector.data());
+	};
+
+	/**
+	 * @brief	Custom copy constructor which prevents setting the
+	 * 	        underlying pointer wrong.
+	 */
+	DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
+			fifoVector(other.maxCapacity) {
+		this->setData(fifoVector.data());
+	}
+
+
+private:
+	std::vector<T> fifoVector;
+};
+
+#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index 2e332dc2e..a870e773e 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -1,34 +1,34 @@
-#ifndef FRAMEWORK_CONTAINER_FIFO_H_
-#define FRAMEWORK_CONTAINER_FIFO_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/container/FIFOBase.h>
-#include <array>
-
-/**
- * @brief 	Simple First-In-First-Out data structure with size fixed at
- * 			compile time
- * @details
- * Performs no dynamic memory allocation.
- * The public interface of FIFOBase exposes the user interface for the FIFO.
- * @tparam T Entry Type
- * @tparam capacity Maximum capacity
- */
-template<typename T, size_t capacity>
-class FIFO: public FIFOBase<T> {
-public:
-	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
-
-	/**
-	 * @brief 	Custom copy constructor to set pointer correctly.
-	 * @param other
-	 */
-	FIFO(const FIFO& other): FIFOBase<T>(other) {
-		this->setData(fifoArray.data());
-	}
-
-private:
-	std::array<T, capacity> fifoArray;
-};
-
-#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
+#ifndef FRAMEWORK_CONTAINER_FIFO_H_
+#define FRAMEWORK_CONTAINER_FIFO_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../container/FIFOBase.h"
+#include <array>
+
+/**
+ * @brief 	Simple First-In-First-Out data structure with size fixed at
+ * 			compile time
+ * @details
+ * Performs no dynamic memory allocation.
+ * The public interface of FIFOBase exposes the user interface for the FIFO.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+template<typename T, size_t capacity>
+class FIFO: public FIFOBase<T> {
+public:
+	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
+
+	/**
+	 * @brief 	Custom copy constructor to set pointer correctly.
+	 * @param other
+	 */
+	FIFO(const FIFO& other): FIFOBase<T>(other) {
+		this->setData(fifoArray.data());
+	}
+
+private:
+	std::array<T, capacity> fifoArray;
+};
+
+#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index 7f8bde962..ddccbdd42 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -1,65 +1,65 @@
-#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
-#define FRAMEWORK_CONTAINER_FIFOBASE_H_
-
-#include <framework/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 setData(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 <framework/container/FIFOBase.tpp>
-
-#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
+#define FRAMEWORK_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 setData(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 "../container/FIFOBase.tpp"
+
+#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index a2d2fa25a..70a1d5e2b 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -1,57 +1,57 @@
-#ifndef FIXEDARRAYLIST_H_
-#define FIXEDARRAYLIST_H_
-
-#include <framework/container/ArrayList.h>
-
-/**
- * @brief 	Array List with a fixed maximum size
- * @ingroup container
- */
-template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
-class FixedArrayList: public ArrayList<T, count_t> {
-private:
-	T data[MAX_SIZE];
-public:
-	/**
-	 * (Robin) Maybe we should also implement move assignment and move ctor.
-	 * Or at least delete them.
-	 */
-	FixedArrayList() :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-	}
-
-	// (Robin): We could create a constructor to initialize the fixed array list
-	// with data and the known size field
-	// so it can be used for serialization too (with SerialFixedArrrayListAdapter)
-	// is this feasible?
-	/**
-	 * Initialize a fixed array list with data and number of data fields.
-	 * Endianness of entries can be swapped optionally.
-	 * @param data_
-	 * @param count
-	 * @param swapArrayListEndianess
-	 */
-	FixedArrayList(T * data_, count_t count):
-		ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, data_, count * sizeof(T));
-		this->size = count;
-	}
-
-	FixedArrayList(const FixedArrayList& other) :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-	}
-
-	FixedArrayList& operator=(FixedArrayList other) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		return *this;
-	}
-
-	virtual ~FixedArrayList() {
-	}
-
-};
-
-#endif /* FIXEDARRAYLIST_H_ */
+#ifndef FIXEDARRAYLIST_H_
+#define FIXEDARRAYLIST_H_
+
+#include "../container/ArrayList.h"
+
+/**
+ * @brief 	Array List with a fixed maximum size
+ * @ingroup container
+ */
+template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
+class FixedArrayList: public ArrayList<T, count_t> {
+private:
+	T data[MAX_SIZE];
+public:
+	/**
+	 * (Robin) Maybe we should also implement move assignment and move ctor.
+	 * Or at least delete them.
+	 */
+	FixedArrayList() :
+			ArrayList<T, count_t>(data, MAX_SIZE) {
+	}
+
+	// (Robin): We could create a constructor to initialize the fixed array list
+	// with data and the known size field
+	// so it can be used for serialization too (with SerialFixedArrrayListAdapter)
+	// is this feasible?
+	/**
+	 * Initialize a fixed array list with data and number of data fields.
+	 * Endianness of entries can be swapped optionally.
+	 * @param data_
+	 * @param count
+	 * @param swapArrayListEndianess
+	 */
+	FixedArrayList(T * data_, count_t count):
+		ArrayList<T, count_t>(data, MAX_SIZE) {
+		memcpy(this->data, data_, count * sizeof(T));
+		this->size = count;
+	}
+
+	FixedArrayList(const FixedArrayList& other) :
+			ArrayList<T, count_t>(data, MAX_SIZE) {
+		memcpy(this->data, other.data, sizeof(this->data));
+		this->entries = data;
+	}
+
+	FixedArrayList& operator=(FixedArrayList other) {
+		memcpy(this->data, other.data, sizeof(this->data));
+		this->entries = data;
+		return *this;
+	}
+
+	virtual ~FixedArrayList() {
+	}
+
+};
+
+#endif /* FIXEDARRAYLIST_H_ */
diff --git a/container/FixedMap.h b/container/FixedMap.h
index 7ef4d7aef..a3afc0238 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -1,225 +1,225 @@
-#ifndef FIXEDMAP_H_
-#define FIXEDMAP_H_
-
-#include <framework/container/ArrayList.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <utility>
-
-/**
- * @brief 	Map implementation for maps with a pre-defined size.
- * @details Can be initialized with desired maximum size.
- * 	        Iterator is used to access <key,value> pair and
- * 	        iterate through map entries. Complexity O(n).
- * @ingroup container
- */
-template<typename key_t, typename T>
-class FixedMap: public SerializeIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
-
-private:
-	static const key_t EMPTY_SLOT = -1;
-	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
-
-	uint32_t findIndex(key_t key) const {
-		if (_size == 0) {
-			return 1;
-		}
-		uint32_t i = 0;
-		for (i = 0; i < _size; ++i) {
-			if (theMap[i].first == key) {
-				return i;
-			}
-		}
-		return i;
-	}
-public:
-	FixedMap(uint32_t maxSize) :
-			theMap(maxSize), _size(0) {
-	}
-
-	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-	public:
-		Iterator() :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
-		}
-
-		Iterator(std::pair<key_t, T> *pair) :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
-		}
-
-		T operator*() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		// -> operator overloaded, can be used to access value
-		T *operator->() {
-			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		// Can be used to access the key of the iterator
-		key_t first() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->first;
-		}
-
-		// Alternative to access value, similar to std::map implementation
-		T second() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-	};
-
-
-
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
-
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
-
-	uint32_t size() const {
-		return _size;
-	}
-
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
-		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
-			return FixedMap::KEY_ALREADY_EXISTS;
-		}
-		if (_size == theMap.maxSize()) {
-			return FixedMap::MAP_FULL;
-		}
-		theMap[_size].first = key;
-		theMap[_size].second = value;
-		if (storedValue != NULL) {
-			*storedValue = Iterator(&theMap[_size]);
-		}
-		++_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.first, pair.second);
-	}
-
-	ReturnValue_t exists(key_t key) const {
-		ReturnValue_t result = KEY_DOES_NOT_EXIST;
-		if (findIndex(key) < _size) {
-			result = HasReturnvaluesIF::RETURN_OK;
-		}
-		return result;
-	}
-
-	ReturnValue_t erase(Iterator *iter) {
-		uint32_t i;
-		if ((i = findIndex((*iter).value->first)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		--((*iter).value);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t erase(key_t key) {
-		uint32_t i;
-		if ((i = findIndex(key)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	T *findValue(key_t key) const {
-		return &theMap[findIndex(key)].second;
-	}
-
-	Iterator find(key_t key) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findIndex(key)]);
-	}
-
-	ReturnValue_t find(key_t key, T **value) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		*value = &theMap[findIndex(key)].second;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	void clear() {
-		_size = 0;
-	}
-
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
-
-
-	bool full() {
-		if(_size == theMap.maxSize()) {
-			return true;
-		}
-		else {
-			return false;
-		}
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
-				buffer, size, maxSize, streamEndianness);
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
-					size, maxSize, streamEndianness);
-			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const {
-		uint32_t printSize = sizeof(_size);
-		uint32_t i = 0;
-
-		for (i = 0; i < _size; ++i) {
-			printSize += SerializeAdapter::getSerializedSize(
-					&theMap[i].first);
-			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
-		}
-
-		return printSize;
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
-				buffer, size, streamEndianness);
-		if (this->_size > theMap.maxSize()) {
-			return SerializeIF::TOO_MANY_ELEMENTS;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
-					size, streamEndianness);
-			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-};
-
-#endif /* FIXEDMAP_H_ */
+#ifndef FIXEDMAP_H_
+#define FIXEDMAP_H_
+
+#include "../container/ArrayList.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <utility>
+
+/**
+ * @brief 	Map implementation for maps with a pre-defined size.
+ * @details Can be initialized with desired maximum size.
+ * 	        Iterator is used to access <key,value> pair and
+ * 	        iterate through map entries. Complexity O(n).
+ * @ingroup container
+ */
+template<typename key_t, typename T>
+class FixedMap: public SerializeIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
+	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+
+private:
+	static const key_t EMPTY_SLOT = -1;
+	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
+	uint32_t _size;
+
+	uint32_t findIndex(key_t key) const {
+		if (_size == 0) {
+			return 1;
+		}
+		uint32_t i = 0;
+		for (i = 0; i < _size; ++i) {
+			if (theMap[i].first == key) {
+				return i;
+			}
+		}
+		return i;
+	}
+public:
+	FixedMap(uint32_t maxSize) :
+			theMap(maxSize), _size(0) {
+	}
+
+	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
+	public:
+		Iterator() :
+				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
+		}
+
+		Iterator(std::pair<key_t, T> *pair) :
+				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
+		}
+
+		T operator*() {
+			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
+
+		// -> operator overloaded, can be used to access value
+		T *operator->() {
+			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
+
+		// Can be used to access the key of the iterator
+		key_t first() {
+			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->first;
+		}
+
+		// Alternative to access value, similar to std::map implementation
+		T second() {
+			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
+	};
+
+
+
+	Iterator begin() const {
+		return Iterator(&theMap[0]);
+	}
+
+	Iterator end() const {
+		return Iterator(&theMap[_size]);
+	}
+
+	uint32_t size() const {
+		return _size;
+	}
+
+	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
+		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
+			return FixedMap::KEY_ALREADY_EXISTS;
+		}
+		if (_size == theMap.maxSize()) {
+			return FixedMap::MAP_FULL;
+		}
+		theMap[_size].first = key;
+		theMap[_size].second = value;
+		if (storedValue != NULL) {
+			*storedValue = Iterator(&theMap[_size]);
+		}
+		++_size;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t insert(std::pair<key_t, T> pair) {
+		return insert(pair.first, pair.second);
+	}
+
+	ReturnValue_t exists(key_t key) const {
+		ReturnValue_t result = KEY_DOES_NOT_EXIST;
+		if (findIndex(key) < _size) {
+			result = HasReturnvaluesIF::RETURN_OK;
+		}
+		return result;
+	}
+
+	ReturnValue_t erase(Iterator *iter) {
+		uint32_t i;
+		if ((i = findIndex((*iter).value->first)) >= _size) {
+			return KEY_DOES_NOT_EXIST;
+		}
+		theMap[i] = theMap[_size - 1];
+		--_size;
+		--((*iter).value);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t erase(key_t key) {
+		uint32_t i;
+		if ((i = findIndex(key)) >= _size) {
+			return KEY_DOES_NOT_EXIST;
+		}
+		theMap[i] = theMap[_size - 1];
+		--_size;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	T *findValue(key_t key) const {
+		return &theMap[findIndex(key)].second;
+	}
+
+	Iterator find(key_t key) const {
+		ReturnValue_t result = exists(key);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return end();
+		}
+		return Iterator(&theMap[findIndex(key)]);
+	}
+
+	ReturnValue_t find(key_t key, T **value) const {
+		ReturnValue_t result = exists(key);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		*value = &theMap[findIndex(key)].second;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	void clear() {
+		_size = 0;
+	}
+
+	uint32_t maxSize() const {
+		return theMap.maxSize();
+	}
+
+
+	bool full() {
+		if(_size == theMap.maxSize()) {
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
+				buffer, size, maxSize, streamEndianness);
+		uint32_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
+					size, maxSize, streamEndianness);
+			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
+					maxSize, streamEndianness);
+			++i;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const {
+		uint32_t printSize = sizeof(_size);
+		uint32_t i = 0;
+
+		for (i = 0; i < _size; ++i) {
+			printSize += SerializeAdapter::getSerializedSize(
+					&theMap[i].first);
+			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
+		}
+
+		return printSize;
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
+				buffer, size, streamEndianness);
+		if (this->_size > theMap.maxSize()) {
+			return SerializeIF::TOO_MANY_ELEMENTS;
+		}
+		uint32_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
+					size, streamEndianness);
+			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
+					streamEndianness);
+			++i;
+		}
+		return result;
+	}
+
+};
+
+#endif /* FIXEDMAP_H_ */
diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 3dd20a749..5bc007efc 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -1,181 +1,181 @@
-#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
-#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
-
-#include <framework/container/ArrayList.h>
-#include <cstring>
-#include <set>
-/**
- * \ingroup container
- */
-template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
-class FixedOrderedMultimap {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
-
-private:
-	typedef KEY_COMPARE compare;
-	compare myComp;
-	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
-
-	uint32_t findFirstIndex(key_t key, uint32_t startAt = 0) const {
-		if (startAt >= _size) {
-			return startAt + 1;
-		}
-		uint32_t i = startAt;
-		for (i = startAt; i < _size; ++i) {
-			if (theMap[i].first == key) {
-				return i;
-			}
-		}
-		return i;
-	}
-
-	uint32_t findNicePlace(key_t key) const {
-		uint32_t i = 0;
-		for (i = 0; i < _size; ++i) {
-			if (myComp(key, theMap[i].first)) {
-				return i;
-			}
-		}
-		return i;
-	}
-
-	void removeFromPosition(uint32_t position) {
-		if (_size <= position) {
-			return;
-		}
-		memmove(&theMap[position], &theMap[position + 1],
-				(_size - position - 1) * sizeof(std::pair<key_t,T>));
-		--_size;
-	}
-public:
-	FixedOrderedMultimap(uint32_t maxSize) :
-			theMap(maxSize), _size(0) {
-	}
-	virtual ~FixedOrderedMultimap() {
-	}
-
-	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-	public:
-		Iterator() :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
-		}
-
-		Iterator(std::pair<key_t, T> *pair) :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
-		}
-
-		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 {
-		return Iterator(&theMap[0]);
-	}
-
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
-
-	uint32_t size() const {
-		return _size;
-	}
-
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
-		if (_size == theMap.maxSize()) {
-			return MAP_FULL;
-		}
-		uint32_t position = findNicePlace(key);
-		memmove(&theMap[position + 1], &theMap[position],
-				(_size - position) * sizeof(std::pair<key_t,T>));
-		theMap[position].first = key;
-		theMap[position].second = value;
-		++_size;
-		if (storedValue != NULL) {
-			*storedValue = Iterator(&theMap[position]);
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.fist, pair.second);
-	}
-
-	ReturnValue_t exists(key_t key) const {
-		ReturnValue_t result = KEY_DOES_NOT_EXIST;
-		if (findFirstIndex(key) < _size) {
-			result = HasReturnvaluesIF::RETURN_OK;
-		}
-		return result;
-	}
-
-	ReturnValue_t erase(Iterator *iter) {
-		uint32_t i;
-		if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		removeFromPosition(i);
-		if (*iter != begin()) {
-			(*iter)--;
-		} else {
-			*iter = begin();
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t erase(key_t key) {
-		uint32_t i;
-		if ((i = findFirstIndex(key)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		do {
-			removeFromPosition(i);
-			i = findFirstIndex(key, i);
-		} while (i < _size);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	//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) {
-			return end();
-		}
-		return Iterator(&theMap[findFirstIndex(key)]);
-	}
-
-	ReturnValue_t find(key_t key, T **value) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		*value = &theMap[findFirstIndex(key)].second;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	void clear() {
-		_size = 0;
-	}
-
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
-
-};
-
-#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
+#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+
+#include "../container/ArrayList.h"
+#include <cstring>
+#include <set>
+/**
+ * \ingroup container
+ */
+template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
+class FixedOrderedMultimap {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
+	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+
+private:
+	typedef KEY_COMPARE compare;
+	compare myComp;
+	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
+	uint32_t _size;
+
+	uint32_t findFirstIndex(key_t key, uint32_t startAt = 0) const {
+		if (startAt >= _size) {
+			return startAt + 1;
+		}
+		uint32_t i = startAt;
+		for (i = startAt; i < _size; ++i) {
+			if (theMap[i].first == key) {
+				return i;
+			}
+		}
+		return i;
+	}
+
+	uint32_t findNicePlace(key_t key) const {
+		uint32_t i = 0;
+		for (i = 0; i < _size; ++i) {
+			if (myComp(key, theMap[i].first)) {
+				return i;
+			}
+		}
+		return i;
+	}
+
+	void removeFromPosition(uint32_t position) {
+		if (_size <= position) {
+			return;
+		}
+		memmove(&theMap[position], &theMap[position + 1],
+				(_size - position - 1) * sizeof(std::pair<key_t,T>));
+		--_size;
+	}
+public:
+	FixedOrderedMultimap(uint32_t maxSize) :
+			theMap(maxSize), _size(0) {
+	}
+	virtual ~FixedOrderedMultimap() {
+	}
+
+	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
+	public:
+		Iterator() :
+				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
+		}
+
+		Iterator(std::pair<key_t, T> *pair) :
+				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
+		}
+
+		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 {
+		return Iterator(&theMap[0]);
+	}
+
+	Iterator end() const {
+		return Iterator(&theMap[_size]);
+	}
+
+	uint32_t size() const {
+		return _size;
+	}
+
+	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
+		if (_size == theMap.maxSize()) {
+			return MAP_FULL;
+		}
+		uint32_t position = findNicePlace(key);
+		memmove(&theMap[position + 1], &theMap[position],
+				(_size - position) * sizeof(std::pair<key_t,T>));
+		theMap[position].first = key;
+		theMap[position].second = value;
+		++_size;
+		if (storedValue != NULL) {
+			*storedValue = Iterator(&theMap[position]);
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t insert(std::pair<key_t, T> pair) {
+		return insert(pair.fist, pair.second);
+	}
+
+	ReturnValue_t exists(key_t key) const {
+		ReturnValue_t result = KEY_DOES_NOT_EXIST;
+		if (findFirstIndex(key) < _size) {
+			result = HasReturnvaluesIF::RETURN_OK;
+		}
+		return result;
+	}
+
+	ReturnValue_t erase(Iterator *iter) {
+		uint32_t i;
+		if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+			return KEY_DOES_NOT_EXIST;
+		}
+		removeFromPosition(i);
+		if (*iter != begin()) {
+			(*iter)--;
+		} else {
+			*iter = begin();
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t erase(key_t key) {
+		uint32_t i;
+		if ((i = findFirstIndex(key)) >= _size) {
+			return KEY_DOES_NOT_EXIST;
+		}
+		do {
+			removeFromPosition(i);
+			i = findFirstIndex(key, i);
+		} while (i < _size);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	//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) {
+			return end();
+		}
+		return Iterator(&theMap[findFirstIndex(key)]);
+	}
+
+	ReturnValue_t find(key_t key, T **value) const {
+		ReturnValue_t result = exists(key);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		*value = &theMap[findFirstIndex(key)].second;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	void clear() {
+		_size = 0;
+	}
+
+	uint32_t maxSize() const {
+		return theMap.maxSize();
+	}
+
+};
+
+#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index f2fd6b288..118813266 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -1,90 +1,90 @@
-#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
-#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
-
-#include <framework/container/ArrayList.h>
-#include <framework/container/SinglyLinkedList.h>
-
-template<typename T, typename count_t = uint8_t>
-class HybridIterator: public LinkedElement<T>::Iterator,
-		public ArrayList<T, count_t>::Iterator {
-public:
-	HybridIterator() {}
-
-	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
-		LinkedElement<T>::Iterator(*iter), value(iter->value),
-		linked(true) {
-
-	}
-
-	HybridIterator(LinkedElement<T> *start) :
-		LinkedElement<T>::Iterator(start), value(start->value),
-		linked(true) {
-
-	}
-
-	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
-			typename ArrayList<T, count_t>::Iterator end) :
-			ArrayList<T, count_t>::Iterator(start), value(start.value),
-			linked(false), end(end.value) {
-		if (value == this->end) {
-			value = NULL;
-		}
-	}
-
-	HybridIterator(T *firstElement, T *lastElement) :
-			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
-			linked(false), end(++lastElement) {
-		if (value == end) {
-			value = NULL;
-		}
-	}
-
-	HybridIterator& operator++() {
-		if (linked) {
-			LinkedElement<T>::Iterator::operator++();
-			if (LinkedElement<T>::Iterator::value != nullptr) {
-				value = LinkedElement<T>::Iterator::value->value;
-			} else {
-				value = nullptr;
-			}
-		} else {
-			ArrayList<T, count_t>::Iterator::operator++();
-			value = ArrayList<T, count_t>::Iterator::value;
-
-			if (value == end) {
-				value = nullptr;
-			}
-		}
-		return *this;
-	}
-
-	HybridIterator operator++(int) {
-		HybridIterator tmp(*this);
-		operator++();
-		return tmp;
-	}
-
-	bool operator==(const HybridIterator& other) const {
-		return value == other.value;
-	}
-
-	bool operator!=(const HybridIterator& other) const {
-		return !(*this == other);
-	}
-
-	T operator*() {
-		return *value;
-	}
-
-	T *operator->() {
-		return value;
-	}
-
-	T* value = nullptr;
-
-private:
-	bool linked = false;
-	T *end = nullptr;
-};
-
-#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
+#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+
+#include "../container/ArrayList.h"
+#include "../container/SinglyLinkedList.h"
+
+template<typename T, typename count_t = uint8_t>
+class HybridIterator: public LinkedElement<T>::Iterator,
+		public ArrayList<T, count_t>::Iterator {
+public:
+	HybridIterator() {}
+
+	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
+		LinkedElement<T>::Iterator(*iter), value(iter->value),
+		linked(true) {
+
+	}
+
+	HybridIterator(LinkedElement<T> *start) :
+		LinkedElement<T>::Iterator(start), value(start->value),
+		linked(true) {
+
+	}
+
+	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
+			typename ArrayList<T, count_t>::Iterator end) :
+			ArrayList<T, count_t>::Iterator(start), value(start.value),
+			linked(false), end(end.value) {
+		if (value == this->end) {
+			value = NULL;
+		}
+	}
+
+	HybridIterator(T *firstElement, T *lastElement) :
+			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
+			linked(false), end(++lastElement) {
+		if (value == end) {
+			value = NULL;
+		}
+	}
+
+	HybridIterator& operator++() {
+		if (linked) {
+			LinkedElement<T>::Iterator::operator++();
+			if (LinkedElement<T>::Iterator::value != nullptr) {
+				value = LinkedElement<T>::Iterator::value->value;
+			} else {
+				value = nullptr;
+			}
+		} else {
+			ArrayList<T, count_t>::Iterator::operator++();
+			value = ArrayList<T, count_t>::Iterator::value;
+
+			if (value == end) {
+				value = nullptr;
+			}
+		}
+		return *this;
+	}
+
+	HybridIterator operator++(int) {
+		HybridIterator tmp(*this);
+		operator++();
+		return tmp;
+	}
+
+	bool operator==(const HybridIterator& other) const {
+		return value == other.value;
+	}
+
+	bool operator!=(const HybridIterator& other) const {
+		return !(*this == other);
+	}
+
+	T operator*() {
+		return *value;
+	}
+
+	T *operator->() {
+		return value;
+	}
+
+	T* value = nullptr;
+
+private:
+	bool linked = false;
+	T *end = nullptr;
+};
+
+#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index d433df626..282916e19 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -1,721 +1,721 @@
-#ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
-#define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
-
-#include <framework/container/ArrayList.h>
-#include <framework/globalfunctions/CRC.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerialArrayListAdapter.h>
-#include <cmath>
-
-/**
- * Index is the Type used for the list of indices.
- *
- * @tparam T Type which destribes the index. Needs to be a child of SerializeIF
- * 			 to be able to make it persistent
- */
-template<typename T>
-class Index: public SerializeIF{
-	/**
-	 *
-	 */
-	static_assert(std::is_base_of<SerializeIF,T>::value,
-			"Wrong Type for Index, Type must implement SerializeIF");
-public:
-	Index():blockStartAddress(0),size(0),storedPackets(0){}
-
-	Index(uint32_t startAddress):blockStartAddress(startAddress),
-			size(0),storedPackets(0) {
-	}
-
-	void setBlockStartAddress(uint32_t newAddress) {
-		this->blockStartAddress = newAddress;
-	}
-
-	uint32_t getBlockStartAddress() const {
-		return blockStartAddress;
-	}
-
-	const T* getIndexType() const {
-		return &indexType;
-	}
-
-	T* modifyIndexType() {
-		return &indexType;
-	}
-	/**
-	 * Updates the index Type. Uses = operator
-	 * @param indexType Type to copy from
-	 */
-	void setIndexType(T* indexType) {
-		this->indexType = *indexType;
-	}
-
-	uint32_t getSize() const {
-		return size;
-	}
-
-	void setSize(uint32_t size) {
-		this->size = size;
-	}
-
-	void addSize(uint32_t size){
-		this->size += size;
-	}
-
-	void setStoredPackets(uint32_t newStoredPackets){
-		this->storedPackets = newStoredPackets;
-	}
-
-	void addStoredPackets(uint32_t packets){
-		this->storedPackets += packets;
-	}
-
-	uint32_t getStoredPackets() const{
-		return this->storedPackets;
-	}
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		return result;
-	}
-
-	size_t getSerializedSize() const {
-		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
-		size += indexType.getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
-		return size;
-	}
-
-
-	bool operator==(const Index<T>& other){
-		return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
-	}
-
-private:
-	uint32_t blockStartAddress;
-	uint32_t size;
-	uint32_t storedPackets;
-	T indexType;
-};
-
-
-/**
- * @brief Indexed Ring Memory Array is a class for a ring memory with indices.
- * @details
- * It assumes that the newest data comes in last
- * It uses the currentWriteBlock as pointer to the current writing position
- * The currentReadBlock must be set manually
- * @tparam T
- */
-template<typename T>
-class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
-	/**
-	 *
-	 */
-public:
-	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
-			SerializeIF* additionalInfo, bool overwriteOld):
-			ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),
-			indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),
-			lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld)
-	{
-		//Calculate the maximum number of indices needed for this blocksize
-		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
-
-		//Calculate the Size needeed for the index itself
-		size_t serializedSize = 0;
-		if(additionalInfo!=NULL) {
-			serializedSize += additionalInfo->getSerializedSize();
-		}
-
-		//Size of current iterator type
-		Index<T> tempIndex;
-		serializedSize += tempIndex.getSerializedSize();
-
-		//Add Size of Array
-		serializedSize += sizeof(uint32_t); //size of array
-		serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
-		serializedSize += sizeof(uint16_t); //size of crc
-
-		//Calculate new size after index
-		if(serializedSize > totalSize){
-			error << "IndexedRingMemory: Store is too small for index" << std::endl;
-		}
-		uint32_t useableSize = totalSize - serializedSize;
-
-		//Update the totalSize for calculations
-		totalSize = useableSize;
-
-		//True StartAddress
-		uint32_t trueStartAddress = indexAddress + serializedSize;
-
-		//Calculate True number of Blocks and reset size of true Number of Blocks
-		uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
-
-		//allocate memory now
-		this->entries = new Index<T>[trueNumberOfBlocks];
-		this->size = trueNumberOfBlocks;
-		this->maxSize_ = trueNumberOfBlocks;
-		this->allocated = true;
-
-		//Check trueNumberOfBlocks
-		if(trueNumberOfBlocks<1) {
-			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
-		}
-
-		//Fill address into index
-		uint32_t address = trueStartAddress;
-		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
-			it->setBlockStartAddress(address);
-			it->setSize(0);
-			it->setStoredPackets(0);
-			address += bytesPerBlock;
-		}
-
-		//Initialize iterators
-		currentWriteBlock = this->begin();
-		currentReadBlock = this->begin();
-		lastBlockToRead = this->begin();
-
-		//Check last blockSize
-		uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
-		if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
-			//remove the last Block so the second last block has more size
-			this->size -= 1;
-			debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
-		}
-	}
-
-	/**
-	 * Resets the whole index, the iterators and executes the given reset function on every index type
-	 * @param typeResetFnc static reset function which accepts a pointer to the index Type
-	 */
-	void reset(void (*typeResetFnc)(T*)){
-		currentReadBlock = this->begin();
-		currentWriteBlock = this->begin();
-		lastBlockToRead = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = 0;
-		lastBlockToReadSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
-			it->setSize(0);
-			it->setStoredPackets(0);
-			(*typeResetFnc)(it->modifyIndexType());
-		}
-	}
-
-	void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
-		it->setSize(0);
-		it->setStoredPackets(0);
-		(*typeResetFnc)(it->modifyIndexType());
-	}
-
-	/**
-	 * Reading
-	 * @param it
-	 */
-	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
-		currentReadBlock = it;
-		currentReadBlockSizeCached = it->getSize();
-	}
-
-	void resetRead(){
-		currentReadBlock = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = this->begin()->getSize();
-		lastBlockToRead = currentWriteBlock;
-		lastBlockToReadSize = currentWriteBlock->getSize();
-	}
-
-	/**
-	 * Sets the last block to read to this iterator.
-	 * Can be used to dump until block x
-	 * @param it The iterator for the last read block
-	 */
-	void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
-		lastBlockToRead = it;
-		lastBlockToReadSize = it->getSize();
-	}
-
-	/**
-	 * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
-	 * Can be the currentWriteBlock as well
-	 */
-	void readOldest(){
-		resetRead();
-		currentReadBlock = getNextNonEmptyBlock();
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-
-	}
-
-	/**
-	 * Sets the current read iterator to the next Block and resets the current read size
-	 * The current size of the block will be cached to avoid race condition between write and read
-	 * If the end of the ring is reached the read pointer will be set to the begin
-	 */
-	void readNext(){
-		currentReadSize = 0;
-		if((this->size != 0) && (currentReadBlock.value ==this->back())){
-			currentReadBlock = this->begin();
-		}else{
-			currentReadBlock++;
-		}
-
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-	}
-
-	/**
-	 * Returns the address which is currently read from
-	 * @return Address to read from
-	 */
-	uint32_t getCurrentReadAddress() const {
-		return getAddressOfCurrentReadBlock() + currentReadSize;
-	}
-
-	/**
-	 * Adds readSize to the current size and checks if the read has no more data
-	 * left and advances the read block.
-	 * @param readSize The size that was read
-	 * @return Returns true if the read can go on
-	 */
-	bool addReadSize(uint32_t readSize) {
-		if(currentReadBlock == lastBlockToRead) {
-			//The current read block is the last to read
-			if((currentReadSize+readSize)<lastBlockToReadSize) {
-				//the block has more data -> return true
-				currentReadSize += readSize;
-				return true;
-			}
-			else {
-				//Reached end of read -> return false
-				currentReadSize = lastBlockToReadSize;
-				return false;
-			}
-		}
-		else {
-			//We are not in the last Block
-			if((currentReadSize + readSize)<currentReadBlockSizeCached) {
-				//The current Block has more data
-				currentReadSize += readSize;
-				return true;
-			}
-			// TODO: Maybe some logic blocks should be extracted
-			else {
-				//The current block is written completely
-				readNext();
-				if(currentReadBlockSizeCached==0) {
-					//Next block is empty
-					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
-					//Search if any block between this and the last block is not empty
-					for(;it!=lastBlockToRead;++it){
-						if(it == this->end()){
-							//This is the end, next block is the begin
-							it = this->begin();
-							if(it == lastBlockToRead){
-								//Break if the begin is the lastBlockToRead
-								break;
-							}
-						}
-						if(it->getSize()!=0){
-							//This is a non empty block. Go on reading with this block
-							currentReadBlock = it;
-							currentReadBlockSizeCached = it->getSize();
-							return true;
-						}
-					}
-					//reached lastBlockToRead and every block was empty, check if the last block is also empty
-					if(lastBlockToReadSize!=0){
-						//go on with last Block
-						currentReadBlock = lastBlockToRead;
-						currentReadBlockSizeCached = lastBlockToReadSize;
-						return true;
-					}
-					//There is no non empty block left
-					return false;
-				}
-				//Size is larger than 0
-				return true;
-			}
-		}
-	}
-	uint32_t getRemainigSizeOfCurrentReadBlock() const{
-		if(currentReadBlock == lastBlockToRead){
-			return (lastBlockToReadSize - currentReadSize);
-		}else{
-			return (currentReadBlockSizeCached - currentReadSize);
-		}
-	}
-
-	uint32_t getAddressOfCurrentReadBlock() const {
-		return currentReadBlock->getBlockStartAddress();
-	}
-
-	/**
-	 * Gets the next non empty Block after the current write block,
-	 * @return Returns the iterator to the block. If there is non, the current write block is returned
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
-		for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
-				if(it == this->end()){
-					it = this->begin();
-					if(it == currentWriteBlock){
-						break;
-					}
-				}
-				if(it->getSize()!=0){
-					return it;
-				}
-		}
-		return currentWriteBlock;
-	}
-
-	/**
-	 * Returns a copy of the oldest Index type
-	 * @return Type of Index
-	 */
-	T* getOldest(){
-		return (getNextNonEmptyBlock()->modifyIndexType());
-	}
-
-
-	/*
-	 * Writing
-	 */
-	uint32_t getAddressOfCurrentWriteBlock() const{
-		return currentWriteBlock->getBlockStartAddress();
-	}
-
-	uint32_t getSizeOfCurrentWriteBlock() const{
-		return currentWriteBlock->getSize();
-	}
-
-	uint32_t getCurrentWriteAddress() const{
-		return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
-	}
-
-	void clearCurrentWriteBlock(){
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-	}
-
-	void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
-		currentWriteBlock->addSize(size);
-		currentWriteBlock->addStoredPackets(storedPackets);
-	}
-
-	T* modifyCurrentWriteBlockIndexType(){
-		return currentWriteBlock->modifyIndexType();
-	}
-
-	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
-		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
-		it->addSize(size);
-		it->addStoredPackets(storedPackets);
-	}
-
-	/**
-	 * Checks if the block has enough space for sizeToWrite
-	 * @param sizeToWrite The data to be written in the Block
-	 * @return Returns true if size to write is smaller the remaining size of the block
-	 */
-	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
-		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
-		uint32_t addressOfNextBlock = next->getBlockStartAddress();
-		uint32_t availableSize =
-				( ( addressOfNextBlock + totalSize ) -
-				(getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock()))
-				% totalSize;
-		return (sizeToWrite < availableSize);
-	}
-
-	/**
-	 * Checks if the store is full if overwrite old is false
-	 * @return Returns true if it is writeable and false if not
-	 */
-	bool isNextBlockWritable(){
-		//First check if this is the end of the list
-		typename IndexedRingMemoryArray<T>::Iterator next;
-		next = getNextWrite();
-		if((next->getSize()!=0) && (!overwriteOld)){
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * Updates current write Block Index Type
-	 * @param infoOfNewBlock
-	 */
-	void updateCurrentBlock(T* infoOfNewBlock){
-		currentWriteBlock->setIndexType(infoOfNewBlock);
-	}
-
-
-	/**
-	 * Succeed to next block, returns FAILED if overwrite is false and the store is full
-	 * @return
-	 */
-	ReturnValue_t writeNext(){
-		//Check Next Block
-		if(!isNextBlockWritable()){
-			//The Index is full and does not overwrite old
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		//Next block can be written, update Metadata
-		currentWriteBlock = getNextWrite();
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	/**
-	 * Serializes the Index and calculates the CRC.
-	 * Parameters according to HasSerializeIF
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param streamEndianness
-	 * @return
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const{
-		uint8_t* crcBuffer = *buffer;
-		uint32_t oldSize = *size;
-		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
-		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
-
-
-	/**
-	 * Get the serialized Size of the index
-	 * @return The serialized size of the index
-	 */
-	size_t getSerializedSize() const {
-
-		size_t size = 0;
-		if(additionalInfo!=NULL){
-			size += additionalInfo->getSerializedSize();
-		}
-		size += currentWriteBlock->getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += (this->entries[0].getSerializedSize()) * this->size;
-		uint16_t crc = 0;
-		size += SerializeAdapter::getSerializedSize(&crc);
-		return size;
-	}
-	/**
-	 * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
-	 * CRC Has to be checked before!
-	 * @param buffer
-	 * @param size
-	 * @param streamEndianness
-	 * @return
-	 */
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-
-		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		uint32_t tempSize = 0;
-		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		if(this->size != tempSize){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::deSerialize(
-					&this->entries[i], buffer, size,
-					streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			if(*(cmp.value) == *(it.value)){
-				currentWriteBlock = it;
-				return HasReturnvaluesIF::RETURN_OK;
-			}
-		}
-		//Reached if current write block iterator is not found
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint32_t getIndexAddress() const {
-		return indexAddress;
-	}
-
-
-	/*
-	 * Statistics
-	 */
-	uint32_t getStoredPackets() const {
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getStoredPackets();
-		}
-		return size;
-	}
-
-	uint32_t getTotalSize() const {
-		return totalSize;
-	}
-
-	uint32_t getCurrentSize() const{
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getSize();
-		}
-		return size;
-	}
-
-	bool isEmpty() const{
-		return getCurrentSize()==0;
-	}
-
-	double getPercentageFilled() const{
-		uint32_t filledSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			filledSize += it->getSize();
-		}
-
-		return (double)filledSize/(double)this->totalSize;
-	}
-
-	typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
-		return currentWriteBlock;
-	}
-	/**
-	 * Get the next block of the currentWriteBlock.
-	 * Returns the first one if currentWriteBlock is the last one
-	 * @return Iterator pointing to the next block after currentWriteBlock
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
-		typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
-		if((this->size != 0) && (currentWriteBlock.value == this->back())){
-			next = this->begin();
-		}else{
-			++next;
-		}
-		return next;
-	}
-	/**
-	 * Get the block in front of the Iterator
-	 * Returns the last block if it is the first block
-	 * @param it iterator which you want the previous block from
-	 * @return pointing to the block before it
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
-		if(this->begin() == it){
-			typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
-			return next;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator next(it);
-		--next;
-		return next;
-	}
-private:
-	//The total size used by the blocks (without index)
-	uint32_t totalSize;
-
-	//The address of the index
-	const uint32_t indexAddress;
-
-	//The iterators for writing and reading
-	typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
-	typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
-
-	//How much of the current read block is read already
-	uint32_t currentReadSize;
-
-	//Cached Size of current read block
-	uint32_t currentReadBlockSizeCached;
-
-	//Last block of current write (should be write block)
-	typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
-	//current size of last Block to read
-	uint32_t lastBlockToReadSize;
-
-	//Additional Info to be serialized with the index
-	SerializeIF* additionalInfo;
-
-	//Does it overwrite old blocks?
-	const bool overwriteOld;
-
-};
-
-#endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */
+#ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
+#define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
+
+#include "../container/ArrayList.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include <cmath>
+
+/**
+ * Index is the Type used for the list of indices.
+ *
+ * @tparam T Type which destribes the index. Needs to be a child of SerializeIF
+ * 			 to be able to make it persistent
+ */
+template<typename T>
+class Index: public SerializeIF{
+	/**
+	 *
+	 */
+	static_assert(std::is_base_of<SerializeIF,T>::value,
+			"Wrong Type for Index, Type must implement SerializeIF");
+public:
+	Index():blockStartAddress(0),size(0),storedPackets(0){}
+
+	Index(uint32_t startAddress):blockStartAddress(startAddress),
+			size(0),storedPackets(0) {
+	}
+
+	void setBlockStartAddress(uint32_t newAddress) {
+		this->blockStartAddress = newAddress;
+	}
+
+	uint32_t getBlockStartAddress() const {
+		return blockStartAddress;
+	}
+
+	const T* getIndexType() const {
+		return &indexType;
+	}
+
+	T* modifyIndexType() {
+		return &indexType;
+	}
+	/**
+	 * Updates the index Type. Uses = operator
+	 * @param indexType Type to copy from
+	 */
+	void setIndexType(T* indexType) {
+		this->indexType = *indexType;
+	}
+
+	uint32_t getSize() const {
+		return size;
+	}
+
+	void setSize(uint32_t size) {
+		this->size = size;
+	}
+
+	void addSize(uint32_t size){
+		this->size += size;
+	}
+
+	void setStoredPackets(uint32_t newStoredPackets){
+		this->storedPackets = newStoredPackets;
+	}
+
+	void addStoredPackets(uint32_t packets){
+		this->storedPackets += packets;
+	}
+
+	uint32_t getStoredPackets() const{
+		return this->storedPackets;
+	}
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
+		return result;
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness){
+		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = indexType.deSerialize(buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		return result;
+	}
+
+	size_t getSerializedSize() const {
+		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
+		size += indexType.getSerializedSize();
+		size += SerializeAdapter::getSerializedSize(&this->size);
+		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
+		return size;
+	}
+
+
+	bool operator==(const Index<T>& other){
+		return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
+	}
+
+private:
+	uint32_t blockStartAddress;
+	uint32_t size;
+	uint32_t storedPackets;
+	T indexType;
+};
+
+
+/**
+ * @brief Indexed Ring Memory Array is a class for a ring memory with indices.
+ * @details
+ * It assumes that the newest data comes in last
+ * It uses the currentWriteBlock as pointer to the current writing position
+ * The currentReadBlock must be set manually
+ * @tparam T
+ */
+template<typename T>
+class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
+	/**
+	 *
+	 */
+public:
+	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
+			SerializeIF* additionalInfo, bool overwriteOld):
+			ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),
+			indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),
+			lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld)
+	{
+		//Calculate the maximum number of indices needed for this blocksize
+		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
+
+		//Calculate the Size needeed for the index itself
+		size_t serializedSize = 0;
+		if(additionalInfo!=NULL) {
+			serializedSize += additionalInfo->getSerializedSize();
+		}
+
+		//Size of current iterator type
+		Index<T> tempIndex;
+		serializedSize += tempIndex.getSerializedSize();
+
+		//Add Size of Array
+		serializedSize += sizeof(uint32_t); //size of array
+		serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
+		serializedSize += sizeof(uint16_t); //size of crc
+
+		//Calculate new size after index
+		if(serializedSize > totalSize){
+			error << "IndexedRingMemory: Store is too small for index" << std::endl;
+		}
+		uint32_t useableSize = totalSize - serializedSize;
+
+		//Update the totalSize for calculations
+		totalSize = useableSize;
+
+		//True StartAddress
+		uint32_t trueStartAddress = indexAddress + serializedSize;
+
+		//Calculate True number of Blocks and reset size of true Number of Blocks
+		uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
+
+		//allocate memory now
+		this->entries = new Index<T>[trueNumberOfBlocks];
+		this->size = trueNumberOfBlocks;
+		this->maxSize_ = trueNumberOfBlocks;
+		this->allocated = true;
+
+		//Check trueNumberOfBlocks
+		if(trueNumberOfBlocks<1) {
+			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
+		}
+
+		//Fill address into index
+		uint32_t address = trueStartAddress;
+		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
+			it->setBlockStartAddress(address);
+			it->setSize(0);
+			it->setStoredPackets(0);
+			address += bytesPerBlock;
+		}
+
+		//Initialize iterators
+		currentWriteBlock = this->begin();
+		currentReadBlock = this->begin();
+		lastBlockToRead = this->begin();
+
+		//Check last blockSize
+		uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
+		if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
+			//remove the last Block so the second last block has more size
+			this->size -= 1;
+			debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
+		}
+	}
+
+	/**
+	 * Resets the whole index, the iterators and executes the given reset function on every index type
+	 * @param typeResetFnc static reset function which accepts a pointer to the index Type
+	 */
+	void reset(void (*typeResetFnc)(T*)){
+		currentReadBlock = this->begin();
+		currentWriteBlock = this->begin();
+		lastBlockToRead = this->begin();
+		currentReadSize = 0;
+		currentReadBlockSizeCached = 0;
+		lastBlockToReadSize = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
+			it->setSize(0);
+			it->setStoredPackets(0);
+			(*typeResetFnc)(it->modifyIndexType());
+		}
+	}
+
+	void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
+		it->setSize(0);
+		it->setStoredPackets(0);
+		(*typeResetFnc)(it->modifyIndexType());
+	}
+
+	/**
+	 * Reading
+	 * @param it
+	 */
+	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
+		currentReadBlock = it;
+		currentReadBlockSizeCached = it->getSize();
+	}
+
+	void resetRead(){
+		currentReadBlock = this->begin();
+		currentReadSize = 0;
+		currentReadBlockSizeCached = this->begin()->getSize();
+		lastBlockToRead = currentWriteBlock;
+		lastBlockToReadSize = currentWriteBlock->getSize();
+	}
+
+	/**
+	 * Sets the last block to read to this iterator.
+	 * Can be used to dump until block x
+	 * @param it The iterator for the last read block
+	 */
+	void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
+		lastBlockToRead = it;
+		lastBlockToReadSize = it->getSize();
+	}
+
+	/**
+	 * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
+	 * Can be the currentWriteBlock as well
+	 */
+	void readOldest(){
+		resetRead();
+		currentReadBlock = getNextNonEmptyBlock();
+		currentReadBlockSizeCached = currentReadBlock->getSize();
+
+	}
+
+	/**
+	 * Sets the current read iterator to the next Block and resets the current read size
+	 * The current size of the block will be cached to avoid race condition between write and read
+	 * If the end of the ring is reached the read pointer will be set to the begin
+	 */
+	void readNext(){
+		currentReadSize = 0;
+		if((this->size != 0) && (currentReadBlock.value ==this->back())){
+			currentReadBlock = this->begin();
+		}else{
+			currentReadBlock++;
+		}
+
+		currentReadBlockSizeCached = currentReadBlock->getSize();
+	}
+
+	/**
+	 * Returns the address which is currently read from
+	 * @return Address to read from
+	 */
+	uint32_t getCurrentReadAddress() const {
+		return getAddressOfCurrentReadBlock() + currentReadSize;
+	}
+
+	/**
+	 * Adds readSize to the current size and checks if the read has no more data
+	 * left and advances the read block.
+	 * @param readSize The size that was read
+	 * @return Returns true if the read can go on
+	 */
+	bool addReadSize(uint32_t readSize) {
+		if(currentReadBlock == lastBlockToRead) {
+			//The current read block is the last to read
+			if((currentReadSize+readSize)<lastBlockToReadSize) {
+				//the block has more data -> return true
+				currentReadSize += readSize;
+				return true;
+			}
+			else {
+				//Reached end of read -> return false
+				currentReadSize = lastBlockToReadSize;
+				return false;
+			}
+		}
+		else {
+			//We are not in the last Block
+			if((currentReadSize + readSize)<currentReadBlockSizeCached) {
+				//The current Block has more data
+				currentReadSize += readSize;
+				return true;
+			}
+			// TODO: Maybe some logic blocks should be extracted
+			else {
+				//The current block is written completely
+				readNext();
+				if(currentReadBlockSizeCached==0) {
+					//Next block is empty
+					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
+					//Search if any block between this and the last block is not empty
+					for(;it!=lastBlockToRead;++it){
+						if(it == this->end()){
+							//This is the end, next block is the begin
+							it = this->begin();
+							if(it == lastBlockToRead){
+								//Break if the begin is the lastBlockToRead
+								break;
+							}
+						}
+						if(it->getSize()!=0){
+							//This is a non empty block. Go on reading with this block
+							currentReadBlock = it;
+							currentReadBlockSizeCached = it->getSize();
+							return true;
+						}
+					}
+					//reached lastBlockToRead and every block was empty, check if the last block is also empty
+					if(lastBlockToReadSize!=0){
+						//go on with last Block
+						currentReadBlock = lastBlockToRead;
+						currentReadBlockSizeCached = lastBlockToReadSize;
+						return true;
+					}
+					//There is no non empty block left
+					return false;
+				}
+				//Size is larger than 0
+				return true;
+			}
+		}
+	}
+	uint32_t getRemainigSizeOfCurrentReadBlock() const{
+		if(currentReadBlock == lastBlockToRead){
+			return (lastBlockToReadSize - currentReadSize);
+		}else{
+			return (currentReadBlockSizeCached - currentReadSize);
+		}
+	}
+
+	uint32_t getAddressOfCurrentReadBlock() const {
+		return currentReadBlock->getBlockStartAddress();
+	}
+
+	/**
+	 * Gets the next non empty Block after the current write block,
+	 * @return Returns the iterator to the block. If there is non, the current write block is returned
+	 */
+	typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
+		for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
+				if(it == this->end()){
+					it = this->begin();
+					if(it == currentWriteBlock){
+						break;
+					}
+				}
+				if(it->getSize()!=0){
+					return it;
+				}
+		}
+		return currentWriteBlock;
+	}
+
+	/**
+	 * Returns a copy of the oldest Index type
+	 * @return Type of Index
+	 */
+	T* getOldest(){
+		return (getNextNonEmptyBlock()->modifyIndexType());
+	}
+
+
+	/*
+	 * Writing
+	 */
+	uint32_t getAddressOfCurrentWriteBlock() const{
+		return currentWriteBlock->getBlockStartAddress();
+	}
+
+	uint32_t getSizeOfCurrentWriteBlock() const{
+		return currentWriteBlock->getSize();
+	}
+
+	uint32_t getCurrentWriteAddress() const{
+		return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
+	}
+
+	void clearCurrentWriteBlock(){
+		currentWriteBlock->setSize(0);
+		currentWriteBlock->setStoredPackets(0);
+	}
+
+	void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
+		currentWriteBlock->addSize(size);
+		currentWriteBlock->addStoredPackets(storedPackets);
+	}
+
+	T* modifyCurrentWriteBlockIndexType(){
+		return currentWriteBlock->modifyIndexType();
+	}
+
+	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
+		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
+		it->addSize(size);
+		it->addStoredPackets(storedPackets);
+	}
+
+	/**
+	 * Checks if the block has enough space for sizeToWrite
+	 * @param sizeToWrite The data to be written in the Block
+	 * @return Returns true if size to write is smaller the remaining size of the block
+	 */
+	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
+		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
+		uint32_t addressOfNextBlock = next->getBlockStartAddress();
+		uint32_t availableSize =
+				( ( addressOfNextBlock + totalSize ) -
+				(getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock()))
+				% totalSize;
+		return (sizeToWrite < availableSize);
+	}
+
+	/**
+	 * Checks if the store is full if overwrite old is false
+	 * @return Returns true if it is writeable and false if not
+	 */
+	bool isNextBlockWritable(){
+		//First check if this is the end of the list
+		typename IndexedRingMemoryArray<T>::Iterator next;
+		next = getNextWrite();
+		if((next->getSize()!=0) && (!overwriteOld)){
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Updates current write Block Index Type
+	 * @param infoOfNewBlock
+	 */
+	void updateCurrentBlock(T* infoOfNewBlock){
+		currentWriteBlock->setIndexType(infoOfNewBlock);
+	}
+
+
+	/**
+	 * Succeed to next block, returns FAILED if overwrite is false and the store is full
+	 * @return
+	 */
+	ReturnValue_t writeNext(){
+		//Check Next Block
+		if(!isNextBlockWritable()){
+			//The Index is full and does not overwrite old
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		//Next block can be written, update Metadata
+		currentWriteBlock = getNextWrite();
+		currentWriteBlock->setSize(0);
+		currentWriteBlock->setStoredPackets(0);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	/**
+	 * Serializes the Index and calculates the CRC.
+	 * Parameters according to HasSerializeIF
+	 * @param buffer
+	 * @param size
+	 * @param maxSize
+	 * @param streamEndianness
+	 * @return
+	 */
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const{
+		uint8_t* crcBuffer = *buffer;
+		uint32_t oldSize = *size;
+		if(additionalInfo!=NULL){
+			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
+		}
+		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+
+		uint32_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
+					maxSize, streamEndianness);
+			++i;
+		}
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
+		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
+		return result;
+	}
+
+
+	/**
+	 * Get the serialized Size of the index
+	 * @return The serialized size of the index
+	 */
+	size_t getSerializedSize() const {
+
+		size_t size = 0;
+		if(additionalInfo!=NULL){
+			size += additionalInfo->getSerializedSize();
+		}
+		size += currentWriteBlock->getSerializedSize();
+		size += SerializeAdapter::getSerializedSize(&this->size);
+		size += (this->entries[0].getSerializedSize()) * this->size;
+		uint16_t crc = 0;
+		size += SerializeAdapter::getSerializedSize(&crc);
+		return size;
+	}
+	/**
+	 * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
+	 * CRC Has to be checked before!
+	 * @param buffer
+	 * @param size
+	 * @param streamEndianness
+	 * @return
+	 */
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness){
+
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		if(additionalInfo!=NULL){
+			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
+		}
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+
+		Index<T> tempIndex;
+		result = tempIndex.deSerialize(buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		uint32_t tempSize = 0;
+		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		if(this->size != tempSize){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		uint32_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+			result = SerializeAdapter::deSerialize(
+					&this->entries[i], buffer, size,
+					streamEndianness);
+			++i;
+		}
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			if(*(cmp.value) == *(it.value)){
+				currentWriteBlock = it;
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+		//Reached if current write block iterator is not found
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint32_t getIndexAddress() const {
+		return indexAddress;
+	}
+
+
+	/*
+	 * Statistics
+	 */
+	uint32_t getStoredPackets() const {
+		uint32_t size = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			size += it->getStoredPackets();
+		}
+		return size;
+	}
+
+	uint32_t getTotalSize() const {
+		return totalSize;
+	}
+
+	uint32_t getCurrentSize() const{
+		uint32_t size = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			size += it->getSize();
+		}
+		return size;
+	}
+
+	bool isEmpty() const{
+		return getCurrentSize()==0;
+	}
+
+	double getPercentageFilled() const{
+		uint32_t filledSize = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			filledSize += it->getSize();
+		}
+
+		return (double)filledSize/(double)this->totalSize;
+	}
+
+	typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
+		return currentWriteBlock;
+	}
+	/**
+	 * Get the next block of the currentWriteBlock.
+	 * Returns the first one if currentWriteBlock is the last one
+	 * @return Iterator pointing to the next block after currentWriteBlock
+	 */
+	typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
+		typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
+		if((this->size != 0) && (currentWriteBlock.value == this->back())){
+			next = this->begin();
+		}else{
+			++next;
+		}
+		return next;
+	}
+	/**
+	 * Get the block in front of the Iterator
+	 * Returns the last block if it is the first block
+	 * @param it iterator which you want the previous block from
+	 * @return pointing to the block before it
+	 */
+	typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
+		if(this->begin() == it){
+			typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
+			return next;
+		}
+		typename IndexedRingMemoryArray<T>::Iterator next(it);
+		--next;
+		return next;
+	}
+private:
+	//The total size used by the blocks (without index)
+	uint32_t totalSize;
+
+	//The address of the index
+	const uint32_t indexAddress;
+
+	//The iterators for writing and reading
+	typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
+	typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
+
+	//How much of the current read block is read already
+	uint32_t currentReadSize;
+
+	//Cached Size of current read block
+	uint32_t currentReadBlockSizeCached;
+
+	//Last block of current write (should be write block)
+	typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
+	//current size of last Block to read
+	uint32_t lastBlockToReadSize;
+
+	//Additional Info to be serialized with the index
+	SerializeIF* additionalInfo;
+
+	//Does it overwrite old blocks?
+	const bool overwriteOld;
+
+};
+
+#endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */
diff --git a/container/PlacementFactory.h b/container/PlacementFactory.h
index daf4ee20c..4a1b7df27 100644
--- a/container/PlacementFactory.h
+++ b/container/PlacementFactory.h
@@ -1,35 +1,35 @@
-#ifndef FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
-#define FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
-
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <utility>
-
-class PlacementFactory {
-public:
-	PlacementFactory(StorageManagerIF* backend) :
-			dataBackend(backend) {
-	}
-	template<typename T, typename ... Args>
-	T* generate(Args&&... args) {
-		store_address_t tempId;
-		uint8_t* pData = NULL;
-		ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
-				&pData);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return NULL;
-		}
-		T* temp = new (pData) T(std::forward<Args>(args)...);
-		return temp;
-	}
-	template<typename T>
-	ReturnValue_t destroy(T* thisElement) {
-		//Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
-		thisElement->~T();
-		uint8_t* pointer = (uint8_t*) (thisElement);
-		return dataBackend->deleteData(pointer, sizeof(T));
-	}
-private:
-	StorageManagerIF* dataBackend;
-};
-
-#endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */
+#ifndef FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
+#define FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
+
+#include "../storagemanager/StorageManagerIF.h"
+#include <utility>
+
+class PlacementFactory {
+public:
+	PlacementFactory(StorageManagerIF* backend) :
+			dataBackend(backend) {
+	}
+	template<typename T, typename ... Args>
+	T* generate(Args&&... args) {
+		store_address_t tempId;
+		uint8_t* pData = NULL;
+		ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
+				&pData);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return NULL;
+		}
+		T* temp = new (pData) T(std::forward<Args>(args)...);
+		return temp;
+	}
+	template<typename T>
+	ReturnValue_t destroy(T* thisElement) {
+		//Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
+		thisElement->~T();
+		uint8_t* pointer = (uint8_t*) (thisElement);
+		return dataBackend->deleteData(pointer, sizeof(T));
+	}
+private:
+	StorageManagerIF* dataBackend;
+};
+
+#endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */
diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index f42a42886..b6ac20c10 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -1,113 +1,113 @@
-#ifndef FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
-#define FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstddef>
-
-template<uint8_t N_READ_PTRS = 1>
-class RingBufferBase {
-public:
-	RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
-			start(startAddress), write(startAddress), size(size),
-			overwriteOld(overwriteOld) {
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = startAddress;
-		}
-	}
-
-	virtual ~RingBufferBase() {}
-
-	bool isFull(uint8_t n = 0) {
-		return (availableWriteSpace(n) == 0);
-	}
-	bool isEmpty(uint8_t n = 0) {
-		return (availableReadData(n) == 0);
-	}
-
-	size_t availableReadData(uint8_t n = 0) const {
-		return ((write + size) - read[n]) % size;
-	}
-	size_t availableWriteSpace(uint8_t n = 0) const  {
-		//One less to avoid ambiguous full/empty problem.
-		return (((read[n] + size) - write - 1) % size);
-	}
-
-	bool overwritesOld() const {
-		return overwriteOld;
-	}
-
-	size_t maxSize() const {
-		return size - 1;
-	}
-
-	void clear() {
-		write = start;
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = start;
-		}
-	}
-
-	size_t writeTillWrap() {
-		return (start + size) - write;
-	}
-
-	size_t readTillWrap(uint8_t n = 0) {
-		return (start + size) - read[n];
-	}
-
-	size_t getStart() const {
-		return start;
-	}
-
-protected:
-	const size_t start;
-	size_t write;
-	size_t read[N_READ_PTRS];
-	const size_t size;
-	const bool overwriteOld;
-	void incrementWrite(uint32_t amount) {
-		write = ((write + amount - start) % size) + start;
-	}
-	void incrementRead(uint32_t amount, uint8_t n = 0) {
-		read[n] = ((read[n] + amount - start) % size) + start;
-	}
-
-	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
-		if (availableReadData(n) >= amount) {
-			incrementRead(amount, n);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-
-	ReturnValue_t writeData(uint32_t amount) {
-		if (availableWriteSpace() >= amount or overwriteOld) {
-			incrementWrite(amount);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-
-
-	size_t getRead(uint8_t n = 0) const {
-		return read[n];
-	}
-
-	void setRead(uint32_t read, uint8_t n = 0) {
-		if (read >= start && read < (start+size)) {
-			this->read[n] = read;
-		}
-	}
-
-	uint32_t getWrite() const {
-		return write;
-	}
-
-	void setWrite(uint32_t write) {
-		this->write = write;
-	}
-};
-
-#endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
+#ifndef FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
+#define FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+template<uint8_t N_READ_PTRS = 1>
+class RingBufferBase {
+public:
+	RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
+			start(startAddress), write(startAddress), size(size),
+			overwriteOld(overwriteOld) {
+		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+			read[count] = startAddress;
+		}
+	}
+
+	virtual ~RingBufferBase() {}
+
+	bool isFull(uint8_t n = 0) {
+		return (availableWriteSpace(n) == 0);
+	}
+	bool isEmpty(uint8_t n = 0) {
+		return (availableReadData(n) == 0);
+	}
+
+	size_t availableReadData(uint8_t n = 0) const {
+		return ((write + size) - read[n]) % size;
+	}
+	size_t availableWriteSpace(uint8_t n = 0) const  {
+		//One less to avoid ambiguous full/empty problem.
+		return (((read[n] + size) - write - 1) % size);
+	}
+
+	bool overwritesOld() const {
+		return overwriteOld;
+	}
+
+	size_t maxSize() const {
+		return size - 1;
+	}
+
+	void clear() {
+		write = start;
+		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+			read[count] = start;
+		}
+	}
+
+	size_t writeTillWrap() {
+		return (start + size) - write;
+	}
+
+	size_t readTillWrap(uint8_t n = 0) {
+		return (start + size) - read[n];
+	}
+
+	size_t getStart() const {
+		return start;
+	}
+
+protected:
+	const size_t start;
+	size_t write;
+	size_t read[N_READ_PTRS];
+	const size_t size;
+	const bool overwriteOld;
+	void incrementWrite(uint32_t amount) {
+		write = ((write + amount - start) % size) + start;
+	}
+	void incrementRead(uint32_t amount, uint8_t n = 0) {
+		read[n] = ((read[n] + amount - start) % size) + start;
+	}
+
+	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
+		if (availableReadData(n) >= amount) {
+			incrementRead(amount, n);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+
+	ReturnValue_t writeData(uint32_t amount) {
+		if (availableWriteSpace() >= amount or overwriteOld) {
+			incrementWrite(amount);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+
+
+	size_t getRead(uint8_t n = 0) const {
+		return read[n];
+	}
+
+	void setRead(uint32_t read, uint8_t n = 0) {
+		if (read >= start && read < (start+size)) {
+			this->read[n] = read;
+		}
+	}
+
+	uint32_t getWrite() const {
+		return write;
+	}
+
+	void setWrite(uint32_t write) {
+		this->write = write;
+	}
+};
+
+#endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 001a21ed5..c41e8d30d 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -1,30 +1,30 @@
-#include <framework/container/SharedRingBuffer.h>
-#include <framework/ipc/MutexFactory.h>
-#include <framework/ipc/MutexHelper.h>
-
-SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
-		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
-		const size_t size, bool overwriteOld, size_t maxExcessBytes):
-		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
-        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
-    return mutex->lockMutex(timeoutType, timeout);
-}
-
-ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
-    return mutex->unlockMutex();
-}
-
-MutexIF* SharedRingBuffer::getMutexHandle() const {
-    return mutex;
-}
+#include "../container/SharedRingBuffer.h"
+#include "../ipc/MutexFactory.h"
+#include "../ipc/MutexHelper.h"
+
+SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
+		bool overwriteOld, size_t maxExcessBytes):
+		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
+		maxExcessBytes) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
+		const size_t size, bool overwriteOld, size_t maxExcessBytes):
+		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
+		maxExcessBytes) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
+        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
+    return mutex->lockMutex(timeoutType, timeout);
+}
+
+ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
+    return mutex->unlockMutex();
+}
+
+MutexIF* SharedRingBuffer::getMutexHandle() const {
+    return mutex;
+}
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 0b5be0521..c6d958cc2 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -1,68 +1,68 @@
-#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
-
-#include <framework/container/SimpleRingBuffer.h>
-#include <framework/ipc/MutexIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/timemanager/Clock.h>
-
-/**
- * @brief   Ring buffer which can be shared among multiple objects
- * @details
- * This class offers a mutex to perform thread-safe operation on the ring
- * buffer. It is still up to the developer to actually perform the lock
- * and unlock operations.
- */
-class SharedRingBuffer: public SystemObject,
-		public SimpleRingBuffer {
-public:
-	/**
-	 * This constructor allocates a new internal buffer with the supplied size.
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes);
-
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes);
-
-	/**
-	 * Unless a read-only constant value is read, all operations on the
-	 * shared ring buffer should be protected by calling this function.
-	 * @param timeoutType
-	 * @param timeout
-	 * @return
-	 */
-	virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
-	        dur_millis_t timeout);
-	/**
-	 * Any locked mutex also has to be unlocked, otherwise, access to the
-	 * shared ring buffer will be blocked.
-	 * @return
-	 */
-	virtual ReturnValue_t unlockRingBufferMutex();
-
-	/**
-	 * The mutex handle can be accessed directly, for example to perform
-	 * the lock with the #MutexHelper for a RAII compliant lock operation.
-	 * @return
-	 */
-	MutexIF* getMutexHandle() const;
-private:
-	MutexIF* mutex = nullptr;
-};
-
-
-
-#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
+#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+
+#include "../container/SimpleRingBuffer.h"
+#include "../ipc/MutexIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../timemanager/Clock.h"
+
+/**
+ * @brief   Ring buffer which can be shared among multiple objects
+ * @details
+ * This class offers a mutex to perform thread-safe operation on the ring
+ * buffer. It is still up to the developer to actually perform the lock
+ * and unlock operations.
+ */
+class SharedRingBuffer: public SystemObject,
+		public SimpleRingBuffer {
+public:
+	/**
+	 * This constructor allocates a new internal buffer with the supplied size.
+	 * @param size
+	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+	 * will be overwritten.
+	 */
+	SharedRingBuffer(object_id_t objectId, const size_t size,
+			bool overwriteOld, size_t maxExcessBytes);
+
+	/**
+	 * This constructor takes an external buffer with the specified size.
+	 * @param buffer
+	 * @param size
+	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+	 * will be overwritten.
+	 */
+	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
+			bool overwriteOld, size_t maxExcessBytes);
+
+	/**
+	 * Unless a read-only constant value is read, all operations on the
+	 * shared ring buffer should be protected by calling this function.
+	 * @param timeoutType
+	 * @param timeout
+	 * @return
+	 */
+	virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
+	        dur_millis_t timeout);
+	/**
+	 * Any locked mutex also has to be unlocked, otherwise, access to the
+	 * shared ring buffer will be blocked.
+	 * @return
+	 */
+	virtual ReturnValue_t unlockRingBufferMutex();
+
+	/**
+	 * The mutex handle can be accessed directly, for example to perform
+	 * the lock with the #MutexHelper for a RAII compliant lock operation.
+	 * @return
+	 */
+	MutexIF* getMutexHandle() const;
+private:
+	MutexIF* mutex = nullptr;
+};
+
+
+
+#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 368808133..8d817bb0b 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -1,127 +1,127 @@
-#include <framework/container/SimpleRingBuffer.h>
-#include <cstring>
-
-SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
-		size_t maxExcessBytes) :
-		RingBufferBase<>(0, size, overwriteOld),
-		maxExcessBytes(maxExcessBytes) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
-	buffer = new uint8_t[size + maxExcessBytes];
-}
-
-SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
-        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
-}
-
-
-SimpleRingBuffer::~SimpleRingBuffer() {
-	delete[] buffer;
-}
-
-
-ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
-        size_t amount) {
-    if (availableWriteSpace() >= amount or overwriteOld) {
-        size_t amountTillWrap = writeTillWrap();
-        if (amountTillWrap < amount) {
-            if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
-                return HasReturnvaluesIF::RETURN_FAILED;
-            }
-            excessBytes = amount - amountTillWrap;
-        }
-        *writePointer = &buffer[write];
-        incrementWrite(amount);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-}
-
-ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
-		size_t amount) {
-	if (availableWriteSpace() >= amount or overwriteOld) {
-		size_t amountTillWrap = writeTillWrap();
-		if (amountTillWrap >= amount) {
-			// remaining size in buffer is sufficient to fit full amount.
-			memcpy(&buffer[write], data, amount);
-		}
-		else {
-			memcpy(&buffer[write], data, amountTillWrap);
-			memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
-		}
-		incrementWrite(amount);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
-		bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
-	size_t availableData = availableReadData(READ_PTR);
-	size_t amountTillWrap = readTillWrap(READ_PTR);
-	if (availableData < amount) {
-		if (readRemaining) {
-			// more data available than amount specified.
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	if (amountTillWrap >= amount) {
-		memcpy(data, &buffer[read[READ_PTR]], amount);
-	} else {
-		memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
-		memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
-	}
-
-	if(incrementReadPtr) {
-		deleteData(amount, readRemaining);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-size_t SimpleRingBuffer::getExcessBytes() const {
-    return excessBytes;
-}
-
-void SimpleRingBuffer::moveExcessBytesToStart() {
-    if(excessBytes > 0) {
-        std::memcpy(buffer, &buffer[size], excessBytes);
-        excessBytes = 0;
-    }
-}
-
-ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
-		bool deleteRemaining, size_t* trueAmount) {
-	size_t availableData = availableReadData(READ_PTR);
-	if (availableData < amount) {
-		if (deleteRemaining) {
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	incrementRead(amount, READ_PTR);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
+#include "../container/SimpleRingBuffer.h"
+#include <cstring>
+
+SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
+		size_t maxExcessBytes) :
+		RingBufferBase<>(0, size, overwriteOld),
+		maxExcessBytes(maxExcessBytes) {
+	if(maxExcessBytes > size) {
+		this->maxExcessBytes = size;
+	}
+	else {
+		this->maxExcessBytes = maxExcessBytes;
+	}
+	buffer = new uint8_t[size + maxExcessBytes];
+}
+
+SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
+		bool overwriteOld, size_t maxExcessBytes):
+        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
+	if(maxExcessBytes > size) {
+		this->maxExcessBytes = size;
+	}
+	else {
+		this->maxExcessBytes = maxExcessBytes;
+	}
+}
+
+
+SimpleRingBuffer::~SimpleRingBuffer() {
+	delete[] buffer;
+}
+
+
+ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
+        size_t amount) {
+    if (availableWriteSpace() >= amount or overwriteOld) {
+        size_t amountTillWrap = writeTillWrap();
+        if (amountTillWrap < amount) {
+            if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
+                return HasReturnvaluesIF::RETURN_FAILED;
+            }
+            excessBytes = amount - amountTillWrap;
+        }
+        *writePointer = &buffer[write];
+        incrementWrite(amount);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+}
+
+ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
+		size_t amount) {
+	if (availableWriteSpace() >= amount or overwriteOld) {
+		size_t amountTillWrap = writeTillWrap();
+		if (amountTillWrap >= amount) {
+			// remaining size in buffer is sufficient to fit full amount.
+			memcpy(&buffer[write], data, amount);
+		}
+		else {
+			memcpy(&buffer[write], data, amountTillWrap);
+			memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
+		}
+		incrementWrite(amount);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
+		bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
+	size_t availableData = availableReadData(READ_PTR);
+	size_t amountTillWrap = readTillWrap(READ_PTR);
+	if (availableData < amount) {
+		if (readRemaining) {
+			// more data available than amount specified.
+			amount = availableData;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	if (trueAmount != nullptr) {
+		*trueAmount = amount;
+	}
+	if (amountTillWrap >= amount) {
+		memcpy(data, &buffer[read[READ_PTR]], amount);
+	} else {
+		memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
+		memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
+	}
+
+	if(incrementReadPtr) {
+		deleteData(amount, readRemaining);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+size_t SimpleRingBuffer::getExcessBytes() const {
+    return excessBytes;
+}
+
+void SimpleRingBuffer::moveExcessBytesToStart() {
+    if(excessBytes > 0) {
+        std::memcpy(buffer, &buffer[size], excessBytes);
+        excessBytes = 0;
+    }
+}
+
+ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
+		bool deleteRemaining, size_t* trueAmount) {
+	size_t availableData = availableReadData(READ_PTR);
+	if (availableData < amount) {
+		if (deleteRemaining) {
+			amount = availableData;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	if (trueAmount != nullptr) {
+		*trueAmount = amount;
+	}
+	incrementRead(amount, READ_PTR);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 0784e4152..a2cb96ab0 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -1,119 +1,119 @@
-#ifndef FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
-
-#include <framework/container/RingBufferBase.h>
-#include <cstddef>
-
-/**
- * @brief 	Circular buffer implementation, useful for buffering
- *          into data streams.
- * @details
- * Note that the deleteData() has to be called to increment the read pointer.
- * This class allocated dynamically, so
- * @ingroup containers
- */
-class SimpleRingBuffer: public RingBufferBase<> {
-public:
-    /**
-     * This constructor allocates a new internal buffer with the supplied size.
-     *
-     * @param size
-     * @param overwriteOld If the ring buffer is overflowing at a write
-     * operation, the oldest data will be overwritten.
-     * @param maxExcessBytes These additional bytes will be allocated in addtion
-     * to the specified size to accomodate contiguous write operations
-     * with getFreeElement.
-     *
-     */
-	SimpleRingBuffer(const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-     * will be overwritten.
-	 * @param maxExcessBytes
-	 * If the buffer can accomodate additional bytes for contigous write
-	 * operations with getFreeElement, this is the maximum allowed additional
-	 * size
-	 */
-	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
-
-	virtual ~SimpleRingBuffer();
-
-	/**
-	 * Write to circular buffer and increment write pointer by amount.
-	 * @param data
-	 * @param amount
-	 * @return -@c RETURN_OK if write operation was successfull
-	 * -@c RETURN_FAILED if
-	 */
-	ReturnValue_t writeData(const uint8_t* data, size_t amount);
-
-	/**
-	 * Returns a pointer to a free element. If the remaining buffer is
-	 * not large enough, the data will be written past the actual size
-	 * and the amount of excess bytes will be cached.
-	 * @param writePointer Pointer to a pointer which can be used to write
-	 * contiguous blocks into the ring buffer
-	 * @param amount
-	 * @return
-	 */
-	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
-
-	virtual size_t getExcessBytes() const;
-	/**
-	 * Helper functions which moves any excess bytes to the start
-	 * of the ring buffer.
-	 * @return
-	 */
-	virtual void moveExcessBytesToStart();
-
-	/**
-	 * Read from circular buffer at read pointer.
-	 * @param data
-	 * @param amount
-	 * @param incrementReadPtr
-	 * If this is set to true, the read pointer will be incremented.
-	 * If readRemaining is set to true, the read pointer will be incremented
-	 * accordingly.
-	 * @param readRemaining
-	 * If this is set to true, the data will be read even if the amount
-	 * specified exceeds the read data available.
-	 * @param trueAmount [out]
-	 * If readRemaining was set to true, the true amount read will be assigned
-	 * to the passed value.
-	 * @return
-	 * - @c RETURN_OK if data was read successfully
-	 * - @c RETURN_FAILED if not enough data was available and readRemaining
-	 *      was set to false.
-	 */
-	ReturnValue_t readData(uint8_t* data, size_t amount,
-			bool incrementReadPtr = false, bool readRemaining = false,
-			size_t* trueAmount = nullptr);
-
-	/**
-	 * Delete data by incrementing read pointer.
-	 * @param amount
-	 * @param deleteRemaining
-	 * If the amount specified is larger than the remaing size to read and this
-	 * is set to true, the remaining amount will be deleted as well
-	 * @param trueAmount [out]
-	 * If deleteRemaining was set to true, the amount deleted will be assigned
-	 * to the passed value.
-	 * @return
-	 */
-	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
-	        size_t* trueAmount = nullptr);
-private:
-	static const uint8_t READ_PTR = 0;
-	uint8_t* buffer = nullptr;
-	size_t maxExcessBytes;
-	size_t excessBytes = 0;
-};
-
-#endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */
-
+#ifndef FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
+#define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
+
+#include "../container/RingBufferBase.h"
+#include <cstddef>
+
+/**
+ * @brief 	Circular buffer implementation, useful for buffering
+ *          into data streams.
+ * @details
+ * Note that the deleteData() has to be called to increment the read pointer.
+ * This class allocated dynamically, so
+ * @ingroup containers
+ */
+class SimpleRingBuffer: public RingBufferBase<> {
+public:
+    /**
+     * This constructor allocates a new internal buffer with the supplied size.
+     *
+     * @param size
+     * @param overwriteOld If the ring buffer is overflowing at a write
+     * operation, the oldest data will be overwritten.
+     * @param maxExcessBytes These additional bytes will be allocated in addtion
+     * to the specified size to accomodate contiguous write operations
+     * with getFreeElement.
+     *
+     */
+	SimpleRingBuffer(const size_t size, bool overwriteOld,
+	        size_t maxExcessBytes = 0);
+	/**
+	 * This constructor takes an external buffer with the specified size.
+	 * @param buffer
+	 * @param size
+	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+	 * @param maxExcessBytes
+	 * If the buffer can accomodate additional bytes for contigous write
+	 * operations with getFreeElement, this is the maximum allowed additional
+	 * size
+	 */
+	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
+	        size_t maxExcessBytes = 0);
+
+	virtual ~SimpleRingBuffer();
+
+	/**
+	 * Write to circular buffer and increment write pointer by amount.
+	 * @param data
+	 * @param amount
+	 * @return -@c RETURN_OK if write operation was successfull
+	 * -@c RETURN_FAILED if
+	 */
+	ReturnValue_t writeData(const uint8_t* data, size_t amount);
+
+	/**
+	 * Returns a pointer to a free element. If the remaining buffer is
+	 * not large enough, the data will be written past the actual size
+	 * and the amount of excess bytes will be cached.
+	 * @param writePointer Pointer to a pointer which can be used to write
+	 * contiguous blocks into the ring buffer
+	 * @param amount
+	 * @return
+	 */
+	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
+
+	virtual size_t getExcessBytes() const;
+	/**
+	 * Helper functions which moves any excess bytes to the start
+	 * of the ring buffer.
+	 * @return
+	 */
+	virtual void moveExcessBytesToStart();
+
+	/**
+	 * Read from circular buffer at read pointer.
+	 * @param data
+	 * @param amount
+	 * @param incrementReadPtr
+	 * If this is set to true, the read pointer will be incremented.
+	 * If readRemaining is set to true, the read pointer will be incremented
+	 * accordingly.
+	 * @param readRemaining
+	 * If this is set to true, the data will be read even if the amount
+	 * specified exceeds the read data available.
+	 * @param trueAmount [out]
+	 * If readRemaining was set to true, the true amount read will be assigned
+	 * to the passed value.
+	 * @return
+	 * - @c RETURN_OK if data was read successfully
+	 * - @c RETURN_FAILED if not enough data was available and readRemaining
+	 *      was set to false.
+	 */
+	ReturnValue_t readData(uint8_t* data, size_t amount,
+			bool incrementReadPtr = false, bool readRemaining = false,
+			size_t* trueAmount = nullptr);
+
+	/**
+	 * Delete data by incrementing read pointer.
+	 * @param amount
+	 * @param deleteRemaining
+	 * If the amount specified is larger than the remaing size to read and this
+	 * is set to true, the remaining amount will be deleted as well
+	 * @param trueAmount [out]
+	 * If deleteRemaining was set to true, the amount deleted will be assigned
+	 * to the passed value.
+	 * @return
+	 */
+	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
+	        size_t* trueAmount = nullptr);
+private:
+	static const uint8_t READ_PTR = 0;
+	uint8_t* buffer = nullptr;
+	size_t maxExcessBytes;
+	size_t excessBytes = 0;
+};
+
+#endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */
+
diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 674d0fc88..4ce854dc1 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -1,137 +1,137 @@
-#include <framework/subsystem/SubsystemBase.h>
-#include <framework/controller/ControllerBase.h>
-#include <framework/subsystem/SubsystemBase.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/action/HasActionsIF.h>
-
-ControllerBase::ControllerBase(uint32_t setObjectId, uint32_t parentId,
-		size_t commandQueueDepth) :
-		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF), submode(
-				SUBMODE_NONE), commandQueue(NULL), modeHelper(
-				this), healthHelper(this, setObjectId),hkSwitcher(this),executingTask(NULL) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
-
-}
-
-ControllerBase::~ControllerBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t ControllerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	MessageQueueId_t parentQueue = 0;
-	if (parentId != 0) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
-
-		parent->registerChild(getObjectId());
-	}
-
-	result = healthHelper.initialize(parentQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	result = modeHelper.initialize(parentQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	result = hkSwitcher.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	return RETURN_OK;
-}
-
-MessageQueueId_t ControllerBase::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void ControllerBase::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result;
-	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
-
-		result = modeHelper.handleModeCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-		result = handleCommandMessage(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
-
-}
-
-void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
-	changeHK(this->mode, this->submode, false);
-	triggerEvent(CHANGING_MODE, mode, submode);
-	this->mode = mode;
-	this->submode = submode;
-	modeHelper.modeChanged(mode, submode);
-	modeChanged(mode, submode);
-	announceMode(false);
-	changeHK(this->mode, this->submode, true);
-}
-
-void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
-}
-
-void ControllerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
-}
-
-void ControllerBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
-}
-
-ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
-	handleQueue();
-	hkSwitcher.performOperation();
-	performControlOperation();
-	return RETURN_OK;
-}
-
-void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
-	return;
-}
-
-ReturnValue_t ControllerBase::setHealth(HealthState health) {
-	switch (health) {
-	case HEALTHY:
-	case EXTERNAL_CONTROL:
-		healthHelper.setHealth(health);
-		return RETURN_OK;
-	default:
-		return INVALID_HEALTH_STATE;
-	}
-}
-
-HasHealthIF::HealthState ControllerBase::getHealth() {
-	return healthHelper.getHealth();
-}
-void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
-			executingTask = task_;
-}
-
-void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
-}
+#include "../subsystem/SubsystemBase.h"
+#include "../controller/ControllerBase.h"
+#include "../subsystem/SubsystemBase.h"
+#include "../ipc/QueueFactory.h"
+#include "../action/HasActionsIF.h"
+
+ControllerBase::ControllerBase(uint32_t setObjectId, uint32_t parentId,
+		size_t commandQueueDepth) :
+		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF), submode(
+				SUBMODE_NONE), commandQueue(NULL), modeHelper(
+				this), healthHelper(this, setObjectId),hkSwitcher(this),executingTask(NULL) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
+
+}
+
+ControllerBase::~ControllerBase() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t ControllerBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	MessageQueueId_t parentQueue = 0;
+	if (parentId != 0) {
+		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		if (parent == NULL) {
+			return RETURN_FAILED;
+		}
+		parentQueue = parent->getCommandQueue();
+
+		parent->registerChild(getObjectId());
+	}
+
+	result = healthHelper.initialize(parentQueue);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	result = modeHelper.initialize(parentQueue);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	result = hkSwitcher.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	return RETURN_OK;
+}
+
+MessageQueueId_t ControllerBase::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void ControllerBase::handleQueue() {
+	CommandMessage command;
+	ReturnValue_t result;
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
+
+		result = modeHelper.handleModeCommand(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+		result = handleCommandMessage(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+		command.setToUnknownCommand();
+		commandQueue->reply(&command);
+	}
+
+}
+
+void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
+	changeHK(this->mode, this->submode, false);
+	triggerEvent(CHANGING_MODE, mode, submode);
+	this->mode = mode;
+	this->submode = submode;
+	modeHelper.modeChanged(mode, submode);
+	modeChanged(mode, submode);
+	announceMode(false);
+	changeHK(this->mode, this->submode, true);
+}
+
+void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
+	*mode = this->mode;
+	*submode = this->submode;
+}
+
+void ControllerBase::setToExternalControl() {
+	healthHelper.setHealth(EXTERNAL_CONTROL);
+}
+
+void ControllerBase::announceMode(bool recursive) {
+	triggerEvent(MODE_INFO, mode, submode);
+}
+
+ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
+	handleQueue();
+	hkSwitcher.performOperation();
+	performControlOperation();
+	return RETURN_OK;
+}
+
+void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
+	return;
+}
+
+ReturnValue_t ControllerBase::setHealth(HealthState health) {
+	switch (health) {
+	case HEALTHY:
+	case EXTERNAL_CONTROL:
+		healthHelper.setHealth(health);
+		return RETURN_OK;
+	default:
+		return INVALID_HEALTH_STATE;
+	}
+}
+
+HasHealthIF::HealthState ControllerBase::getHealth() {
+	return healthHelper.getHealth();
+}
+void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
+			executingTask = task_;
+}
+
+void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
+}
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 804bc7c25..d98a66652 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -1,79 +1,79 @@
-#ifndef CONTROLLERBASE_H_
-#define CONTROLLERBASE_H_
-
-#include <framework/health/HasHealthIF.h>
-#include <framework/health/HealthHelper.h>
-#include <framework/modes/HasModesIF.h>
-#include <framework/modes/ModeHelper.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/datapool/HkSwitchHelper.h>
-
-
-class ControllerBase: public HasModesIF,
-		public HasHealthIF,
-		public ExecutableObjectIF,
-		public SystemObject,
-		public HasReturnvaluesIF {
-public:
-
-	static const Mode_t MODE_NORMAL = 2;
-
-	ControllerBase(uint32_t setObjectId, uint32_t parentId,
-			size_t commandQueueDepth = 3);
-	virtual ~ControllerBase();
-
-	ReturnValue_t initialize();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	virtual ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual ReturnValue_t setHealth(HealthState health);
-
-	virtual HasHealthIF::HealthState getHealth();
-
-	/**
-	 * Implementation of ExecutableObjectIF function
-	 *
-	 * Used to setup the reference of the task, that executes this component
-	 * @param task_ Pointer to the taskIF of this task
-	 */
-	virtual  void setTaskIF(PeriodicTaskIF* task_);
-
-
-protected:
-	const uint32_t parentId;
-
-	Mode_t mode;
-
-	Submode_t submode;
-
-	MessageQueueIF* commandQueue;
-
-	ModeHelper modeHelper;
-
-	HealthHelper healthHelper;
-
-	HkSwitchHelper hkSwitcher;
-
-	/**
-	 * Pointer to the task which executes this component, is invalid before setTaskIF was called.
-	 */
-	PeriodicTaskIF* executingTask;
-
-	void handleQueue();
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
-	virtual void performControlOperation() = 0;
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode) = 0;
-	virtual void modeChanged(Mode_t mode, Submode_t submode);
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-	virtual void setToExternalControl();
-	virtual void announceMode(bool recursive);
-	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
-};
-
-#endif /* CONTROLLERBASE_H_ */
+#ifndef CONTROLLERBASE_H_
+#define CONTROLLERBASE_H_
+
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../modes/HasModesIF.h"
+#include "../modes/ModeHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../datapool/HkSwitchHelper.h"
+
+
+class ControllerBase: public HasModesIF,
+		public HasHealthIF,
+		public ExecutableObjectIF,
+		public SystemObject,
+		public HasReturnvaluesIF {
+public:
+
+	static const Mode_t MODE_NORMAL = 2;
+
+	ControllerBase(uint32_t setObjectId, uint32_t parentId,
+			size_t commandQueueDepth = 3);
+	virtual ~ControllerBase();
+
+	ReturnValue_t initialize();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	virtual ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual ReturnValue_t setHealth(HealthState health);
+
+	virtual HasHealthIF::HealthState getHealth();
+
+	/**
+	 * Implementation of ExecutableObjectIF function
+	 *
+	 * Used to setup the reference of the task, that executes this component
+	 * @param task_ Pointer to the taskIF of this task
+	 */
+	virtual  void setTaskIF(PeriodicTaskIF* task_);
+
+
+protected:
+	const uint32_t parentId;
+
+	Mode_t mode;
+
+	Submode_t submode;
+
+	MessageQueueIF* commandQueue;
+
+	ModeHelper modeHelper;
+
+	HealthHelper healthHelper;
+
+	HkSwitchHelper hkSwitcher;
+
+	/**
+	 * Pointer to the task which executes this component, is invalid before setTaskIF was called.
+	 */
+	PeriodicTaskIF* executingTask;
+
+	void handleQueue();
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+	virtual void performControlOperation() = 0;
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode) = 0;
+	virtual void modeChanged(Mode_t mode, Submode_t submode);
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+	virtual void getMode(Mode_t *mode, Submode_t *submode);
+	virtual void setToExternalControl();
+	virtual void announceMode(bool recursive);
+	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
+};
+
+#endif /* CONTROLLERBASE_H_ */
diff --git a/coordinates/CoordinateTransformations.cpp b/coordinates/CoordinateTransformations.cpp
index b57519a38..df9b3caca 100644
--- a/coordinates/CoordinateTransformations.cpp
+++ b/coordinates/CoordinateTransformations.cpp
@@ -1,227 +1,227 @@
-#include <framework/coordinates/CoordinateTransformations.h>
-#include <framework/globalfunctions/constants.h>
-#include <framework/globalfunctions/math/MatrixOperations.h>
-#include <framework/globalfunctions/math/VectorOperations.h>
-#include <stddef.h>
-#include <cmath>
-
-
-void CoordinateTransformations::positionEcfToEci(const double* ecfPosition,
-		double* eciPosition, timeval *timeUTC) {
-	ecfToEci(ecfPosition, eciPosition, NULL, timeUTC);
-
-}
-
-void CoordinateTransformations::velocityEcfToEci(const double* ecfVelocity,
-		const double* ecfPosition, double* eciVelocity, timeval *timeUTC) {
-	ecfToEci(ecfVelocity, eciVelocity, ecfPosition, timeUTC);
-}
-
-void CoordinateTransformations::positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC){
-	eciToEcf(eciCoordinates,ecfCoordinates,NULL,timeUTC);
-};
-
-void CoordinateTransformations::velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC){
-	eciToEcf(eciVelocity,ecfVelocity,eciPosition,timeUTC);
-}
-
-double CoordinateTransformations::getEarthRotationAngle(timeval timeUTC) {
-
-	double jD2000UTC;
-	Clock::convertTimevalToJD2000(timeUTC, &jD2000UTC);
-
-	double TTt2000 = getJuleanCenturiesTT(timeUTC);
-
-	double theta = 2 * Math::PI
-			* (0.779057273264 + 1.00273781191135448 * jD2000UTC);
-
-	//Correct theta according to IAU 2000 precession-nutation model
-	theta = theta + 7.03270725817493E-008 + 0.0223603701 * TTt2000
-			+ 6.77128219501896E-006 * TTt2000 * TTt2000
-			+ 4.5300990362875E-010 * TTt2000 * TTt2000 * TTt2000
-			+ 9.12419347848147E-011 * TTt2000 * TTt2000 * TTt2000 * TTt2000;
-	return theta;
-}
-
-void CoordinateTransformations::getEarthRotationMatrix(timeval timeUTC,
-		double matrix[][3]) {
-	double theta = getEarthRotationAngle(timeUTC);
-
-	matrix[0][0] = cos(theta);
-	matrix[0][1] = sin(theta);
-	matrix[0][2] = 0;
-	matrix[1][0] = -sin(theta);
-	matrix[1][1] = cos(theta);
-	matrix[1][2] = 0;
-	matrix[2][0] = 0;
-	matrix[2][1] = 0;
-	matrix[2][2] = 1;
-}
-
-void CoordinateTransformations::ecfToEci(const double* ecfCoordinates,
-		double* eciCoordinates,
-		const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin) {
-
-	timeval timeUTC;
-	if (timeUTCin != NULL) {
-		timeUTC = *timeUTCin;
-	} else {
-		Clock::getClock_timeval(&timeUTC);
-	}
-
-	double Tfi[3][3];
-	double Tif[3][3];
-	getTransMatrixECITOECF(timeUTC,Tfi);
-
-	MatrixOperations<double>::transpose(Tfi[0], Tif[0], 3);
-
-	MatrixOperations<double>::multiply(Tif[0], ecfCoordinates, eciCoordinates,
-			3, 3, 1);
-
-
-
-
-	if (ecfPositionIfCoordinatesAreVelocity != NULL) {
-
-		double Tdotfi[3][3];
-		double Tdotif[3][3];
-		double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
-				{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
-
-		MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
-				3);
-
-		MatrixOperations<double>::transpose(Tdotfi[0], Tdotif[0], 3);
-
-		double velocityCorrection[3];
-
-		MatrixOperations<double>::multiply(Tdotif[0],
-				ecfPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
-				1);
-
-		VectorOperations<double>::add(velocityCorrection, eciCoordinates,
-				eciCoordinates, 3);
-	}
-}
-
-double CoordinateTransformations::getJuleanCenturiesTT(timeval timeUTC) {
-	timeval timeTT;
-	Clock::convertUTCToTT(timeUTC, &timeTT);
-	double jD2000TT;
-	Clock::convertTimevalToJD2000(timeTT, &jD2000TT);
-
-	return jD2000TT / 36525.;
-}
-
-void CoordinateTransformations::eciToEcf(const double* eciCoordinates,
-		double* ecfCoordinates,
-		const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin){
-	timeval timeUTC;
-	if (timeUTCin != NULL) {
-		timeUTC = *timeUTCin;
-	}else{
-		Clock::getClock_timeval(&timeUTC);
-	}
-
-	double Tfi[3][3];
-
-	getTransMatrixECITOECF(timeUTC,Tfi);
-
-	MatrixOperations<double>::multiply(Tfi[0],eciCoordinates,ecfCoordinates,3,3,1);
-
-	if (eciPositionIfCoordinatesAreVelocity != NULL) {
-
-			double Tdotfi[3][3];
-			double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
-					{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
-
-			MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
-					3);
-
-			double velocityCorrection[3];
-
-			MatrixOperations<double>::multiply(Tdotfi[0],
-					eciPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
-					1);
-
-			VectorOperations<double>::add(ecfCoordinates, velocityCorrection,
-					ecfCoordinates, 3);
-		}
-};
-
-void CoordinateTransformations::getTransMatrixECITOECF(timeval timeUTC,double Tfi[3][3]){
-	double TTt2000 = getJuleanCenturiesTT(timeUTC);
-
-		//////////////////////////////////////////////////////////
-		// Calculate Precession Matrix
-
-		double zeta = 0.0111808609 * TTt2000
-				+ 1.46355554053347E-006 * TTt2000 * TTt2000
-				+ 8.72567663260943E-008 * TTt2000 * TTt2000 * TTt2000;
-		double theta_p = 0.0097171735 * TTt2000
-				- 2.06845757045384E-006 * TTt2000 * TTt2000
-				- 2.02812107218552E-007 * TTt2000 * TTt2000 * TTt2000;
-		double z = zeta + 3.8436028638364E-006 * TTt2000 * TTt2000
-				+ 0.000000001 * TTt2000 * TTt2000 * TTt2000;
-
-		double mPrecession[3][3];
-
-		mPrecession[0][0] = -sin(z) * sin(zeta) + cos(z) * cos(theta_p) * cos(zeta);
-		mPrecession[1][0] = cos(z) * sin(zeta) + sin(z) * cos(theta_p) * cos(zeta);
-		mPrecession[2][0] = sin(theta_p) * cos(zeta);
-
-		mPrecession[0][1] = -sin(z) * cos(zeta) - cos(z) * cos(theta_p) * sin(zeta);
-		mPrecession[1][1] = cos(z) * cos(zeta) - sin(z) * cos(theta_p) * sin(zeta);
-		mPrecession[2][1] = -sin(theta_p) * sin(zeta);
-
-		mPrecession[0][2] = -cos(z) * sin(theta_p);
-		mPrecession[1][2] = -sin(z) * sin(theta_p);
-		mPrecession[2][2] = cos(theta_p);
-
-		//////////////////////////////////////////////////////////
-		// Calculate Nutation Matrix
-
-		double omega_moon = 2.1824386244 - 33.7570459338 * TTt2000
-				+ 3.61428599267159E-005 * TTt2000 * TTt2000
-				+ 3.87850944887629E-008 * TTt2000 * TTt2000 * TTt2000;
-
-		double deltaPsi = -0.000083388 * sin(omega_moon);
-		double deltaEpsilon = 4.46174030725106E-005 * cos(omega_moon);
-
-		double epsilon = 0.4090928042 - 0.0002269655 * TTt2000
-				- 2.86040071854626E-009 * TTt2000 * TTt2000
-				+ 8.78967203851589E-009 * TTt2000 * TTt2000 * TTt2000;
-
-
-		double mNutation[3][3];
-
-		mNutation[0][0] = cos(deltaPsi);
-		mNutation[1][0] = cos(epsilon + deltaEpsilon) * sin(deltaPsi);
-		mNutation[2][0] = sin(epsilon + deltaEpsilon) * sin(deltaPsi);
-
-		mNutation[0][1] = -cos(epsilon) * sin(deltaPsi);
-		mNutation[1][1] = cos(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
-				+ sin(epsilon) * sin(epsilon + deltaEpsilon);
-		mNutation[2][1] = cos(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
-				- sin(epsilon) * cos(epsilon + deltaEpsilon);
-
-		mNutation[0][2] = -sin(epsilon) * sin(deltaPsi);
-		mNutation[1][2] = sin(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
-				- cos(epsilon) * sin(epsilon + deltaEpsilon);
-		mNutation[2][2] = sin(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
-				+ cos(epsilon) * cos(epsilon + deltaEpsilon);
-
-		//////////////////////////////////////////////////////////
-		// Calculate Earth rotation matrix
-		//calculate theta
-
-		double mTheta[3][3];
-		double Ttemp[3][3];
-		getEarthRotationMatrix(timeUTC, mTheta);
-
-		//polar motion is neglected
-		MatrixOperations<double>::multiply(mNutation[0], mPrecession[0], Ttemp[0],
-				3, 3, 3);
-
-		MatrixOperations<double>::multiply(mTheta[0], Ttemp[0], Tfi[0], 3, 3, 3);
-};
+#include "../coordinates/CoordinateTransformations.h"
+#include "../globalfunctions/constants.h"
+#include "../globalfunctions/math/MatrixOperations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include <stddef.h>
+#include <cmath>
+
+
+void CoordinateTransformations::positionEcfToEci(const double* ecfPosition,
+		double* eciPosition, timeval *timeUTC) {
+	ecfToEci(ecfPosition, eciPosition, NULL, timeUTC);
+
+}
+
+void CoordinateTransformations::velocityEcfToEci(const double* ecfVelocity,
+		const double* ecfPosition, double* eciVelocity, timeval *timeUTC) {
+	ecfToEci(ecfVelocity, eciVelocity, ecfPosition, timeUTC);
+}
+
+void CoordinateTransformations::positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC){
+	eciToEcf(eciCoordinates,ecfCoordinates,NULL,timeUTC);
+};
+
+void CoordinateTransformations::velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC){
+	eciToEcf(eciVelocity,ecfVelocity,eciPosition,timeUTC);
+}
+
+double CoordinateTransformations::getEarthRotationAngle(timeval timeUTC) {
+
+	double jD2000UTC;
+	Clock::convertTimevalToJD2000(timeUTC, &jD2000UTC);
+
+	double TTt2000 = getJuleanCenturiesTT(timeUTC);
+
+	double theta = 2 * Math::PI
+			* (0.779057273264 + 1.00273781191135448 * jD2000UTC);
+
+	//Correct theta according to IAU 2000 precession-nutation model
+	theta = theta + 7.03270725817493E-008 + 0.0223603701 * TTt2000
+			+ 6.77128219501896E-006 * TTt2000 * TTt2000
+			+ 4.5300990362875E-010 * TTt2000 * TTt2000 * TTt2000
+			+ 9.12419347848147E-011 * TTt2000 * TTt2000 * TTt2000 * TTt2000;
+	return theta;
+}
+
+void CoordinateTransformations::getEarthRotationMatrix(timeval timeUTC,
+		double matrix[][3]) {
+	double theta = getEarthRotationAngle(timeUTC);
+
+	matrix[0][0] = cos(theta);
+	matrix[0][1] = sin(theta);
+	matrix[0][2] = 0;
+	matrix[1][0] = -sin(theta);
+	matrix[1][1] = cos(theta);
+	matrix[1][2] = 0;
+	matrix[2][0] = 0;
+	matrix[2][1] = 0;
+	matrix[2][2] = 1;
+}
+
+void CoordinateTransformations::ecfToEci(const double* ecfCoordinates,
+		double* eciCoordinates,
+		const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin) {
+
+	timeval timeUTC;
+	if (timeUTCin != NULL) {
+		timeUTC = *timeUTCin;
+	} else {
+		Clock::getClock_timeval(&timeUTC);
+	}
+
+	double Tfi[3][3];
+	double Tif[3][3];
+	getTransMatrixECITOECF(timeUTC,Tfi);
+
+	MatrixOperations<double>::transpose(Tfi[0], Tif[0], 3);
+
+	MatrixOperations<double>::multiply(Tif[0], ecfCoordinates, eciCoordinates,
+			3, 3, 1);
+
+
+
+
+	if (ecfPositionIfCoordinatesAreVelocity != NULL) {
+
+		double Tdotfi[3][3];
+		double Tdotif[3][3];
+		double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
+				{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
+
+		MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
+				3);
+
+		MatrixOperations<double>::transpose(Tdotfi[0], Tdotif[0], 3);
+
+		double velocityCorrection[3];
+
+		MatrixOperations<double>::multiply(Tdotif[0],
+				ecfPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
+				1);
+
+		VectorOperations<double>::add(velocityCorrection, eciCoordinates,
+				eciCoordinates, 3);
+	}
+}
+
+double CoordinateTransformations::getJuleanCenturiesTT(timeval timeUTC) {
+	timeval timeTT;
+	Clock::convertUTCToTT(timeUTC, &timeTT);
+	double jD2000TT;
+	Clock::convertTimevalToJD2000(timeTT, &jD2000TT);
+
+	return jD2000TT / 36525.;
+}
+
+void CoordinateTransformations::eciToEcf(const double* eciCoordinates,
+		double* ecfCoordinates,
+		const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin){
+	timeval timeUTC;
+	if (timeUTCin != NULL) {
+		timeUTC = *timeUTCin;
+	}else{
+		Clock::getClock_timeval(&timeUTC);
+	}
+
+	double Tfi[3][3];
+
+	getTransMatrixECITOECF(timeUTC,Tfi);
+
+	MatrixOperations<double>::multiply(Tfi[0],eciCoordinates,ecfCoordinates,3,3,1);
+
+	if (eciPositionIfCoordinatesAreVelocity != NULL) {
+
+			double Tdotfi[3][3];
+			double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
+					{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
+
+			MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
+					3);
+
+			double velocityCorrection[3];
+
+			MatrixOperations<double>::multiply(Tdotfi[0],
+					eciPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
+					1);
+
+			VectorOperations<double>::add(ecfCoordinates, velocityCorrection,
+					ecfCoordinates, 3);
+		}
+};
+
+void CoordinateTransformations::getTransMatrixECITOECF(timeval timeUTC,double Tfi[3][3]){
+	double TTt2000 = getJuleanCenturiesTT(timeUTC);
+
+		//////////////////////////////////////////////////////////
+		// Calculate Precession Matrix
+
+		double zeta = 0.0111808609 * TTt2000
+				+ 1.46355554053347E-006 * TTt2000 * TTt2000
+				+ 8.72567663260943E-008 * TTt2000 * TTt2000 * TTt2000;
+		double theta_p = 0.0097171735 * TTt2000
+				- 2.06845757045384E-006 * TTt2000 * TTt2000
+				- 2.02812107218552E-007 * TTt2000 * TTt2000 * TTt2000;
+		double z = zeta + 3.8436028638364E-006 * TTt2000 * TTt2000
+				+ 0.000000001 * TTt2000 * TTt2000 * TTt2000;
+
+		double mPrecession[3][3];
+
+		mPrecession[0][0] = -sin(z) * sin(zeta) + cos(z) * cos(theta_p) * cos(zeta);
+		mPrecession[1][0] = cos(z) * sin(zeta) + sin(z) * cos(theta_p) * cos(zeta);
+		mPrecession[2][0] = sin(theta_p) * cos(zeta);
+
+		mPrecession[0][1] = -sin(z) * cos(zeta) - cos(z) * cos(theta_p) * sin(zeta);
+		mPrecession[1][1] = cos(z) * cos(zeta) - sin(z) * cos(theta_p) * sin(zeta);
+		mPrecession[2][1] = -sin(theta_p) * sin(zeta);
+
+		mPrecession[0][2] = -cos(z) * sin(theta_p);
+		mPrecession[1][2] = -sin(z) * sin(theta_p);
+		mPrecession[2][2] = cos(theta_p);
+
+		//////////////////////////////////////////////////////////
+		// Calculate Nutation Matrix
+
+		double omega_moon = 2.1824386244 - 33.7570459338 * TTt2000
+				+ 3.61428599267159E-005 * TTt2000 * TTt2000
+				+ 3.87850944887629E-008 * TTt2000 * TTt2000 * TTt2000;
+
+		double deltaPsi = -0.000083388 * sin(omega_moon);
+		double deltaEpsilon = 4.46174030725106E-005 * cos(omega_moon);
+
+		double epsilon = 0.4090928042 - 0.0002269655 * TTt2000
+				- 2.86040071854626E-009 * TTt2000 * TTt2000
+				+ 8.78967203851589E-009 * TTt2000 * TTt2000 * TTt2000;
+
+
+		double mNutation[3][3];
+
+		mNutation[0][0] = cos(deltaPsi);
+		mNutation[1][0] = cos(epsilon + deltaEpsilon) * sin(deltaPsi);
+		mNutation[2][0] = sin(epsilon + deltaEpsilon) * sin(deltaPsi);
+
+		mNutation[0][1] = -cos(epsilon) * sin(deltaPsi);
+		mNutation[1][1] = cos(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
+				+ sin(epsilon) * sin(epsilon + deltaEpsilon);
+		mNutation[2][1] = cos(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
+				- sin(epsilon) * cos(epsilon + deltaEpsilon);
+
+		mNutation[0][2] = -sin(epsilon) * sin(deltaPsi);
+		mNutation[1][2] = sin(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
+				- cos(epsilon) * sin(epsilon + deltaEpsilon);
+		mNutation[2][2] = sin(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
+				+ cos(epsilon) * cos(epsilon + deltaEpsilon);
+
+		//////////////////////////////////////////////////////////
+		// Calculate Earth rotation matrix
+		//calculate theta
+
+		double mTheta[3][3];
+		double Ttemp[3][3];
+		getEarthRotationMatrix(timeUTC, mTheta);
+
+		//polar motion is neglected
+		MatrixOperations<double>::multiply(mNutation[0], mPrecession[0], Ttemp[0],
+				3, 3, 3);
+
+		MatrixOperations<double>::multiply(mTheta[0], Ttemp[0], Tfi[0], 3, 3, 3);
+};
diff --git a/coordinates/CoordinateTransformations.h b/coordinates/CoordinateTransformations.h
index b072271fc..0bfb203dd 100644
--- a/coordinates/CoordinateTransformations.h
+++ b/coordinates/CoordinateTransformations.h
@@ -1,34 +1,34 @@
-#ifndef COORDINATETRANSFORMATIONS_H_
-#define COORDINATETRANSFORMATIONS_H_
-
-#include <framework/timemanager/Clock.h>
-#include <cstring>
-
-class CoordinateTransformations {
-public:
-	static void positionEcfToEci(const double* ecfCoordinates, double* eciCoordinates, timeval *timeUTC = NULL);
-
-	static void velocityEcfToEci(const double* ecfVelocity,
-			const double* ecfPosition,
-			double* eciVelocity, timeval *timeUTC = NULL);
-
-	static void positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC = NULL);
-	static void velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC = NULL);
-
-	static double getEarthRotationAngle(timeval timeUTC);
-
-	static void getEarthRotationMatrix(timeval timeUTC, double matrix[][3]);
-private:
-	CoordinateTransformations();
-	static void ecfToEci(const double* ecfCoordinates, double* eciCoordinates,
-			const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin);
-	static void eciToEcf(const double* eciCoordinates,
-				double* ecfCoordinates,
-				const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin);
-
-	static double getJuleanCenturiesTT(timeval timeUTC);
-	static void getTransMatrixECITOECF(timeval time,double Tfi[3][3]);
-
-};
-
-#endif /* COORDINATETRANSFORMATIONS_H_ */
+#ifndef COORDINATETRANSFORMATIONS_H_
+#define COORDINATETRANSFORMATIONS_H_
+
+#include "../timemanager/Clock.h"
+#include <cstring>
+
+class CoordinateTransformations {
+public:
+	static void positionEcfToEci(const double* ecfCoordinates, double* eciCoordinates, timeval *timeUTC = NULL);
+
+	static void velocityEcfToEci(const double* ecfVelocity,
+			const double* ecfPosition,
+			double* eciVelocity, timeval *timeUTC = NULL);
+
+	static void positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC = NULL);
+	static void velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC = NULL);
+
+	static double getEarthRotationAngle(timeval timeUTC);
+
+	static void getEarthRotationMatrix(timeval timeUTC, double matrix[][3]);
+private:
+	CoordinateTransformations();
+	static void ecfToEci(const double* ecfCoordinates, double* eciCoordinates,
+			const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin);
+	static void eciToEcf(const double* eciCoordinates,
+				double* ecfCoordinates,
+				const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin);
+
+	static double getJuleanCenturiesTT(timeval timeUTC);
+	static void getTransMatrixECITOECF(timeval time,double Tfi[3][3]);
+
+};
+
+#endif /* COORDINATETRANSFORMATIONS_H_ */
diff --git a/coordinates/Jgm3Model.h b/coordinates/Jgm3Model.h
index 8f0598f84..fd74741dd 100644
--- a/coordinates/Jgm3Model.h
+++ b/coordinates/Jgm3Model.h
@@ -1,180 +1,180 @@
-#ifndef FRAMEWORK_COORDINATES_JGM3MODEL_H_
-#define FRAMEWORK_COORDINATES_JGM3MODEL_H_
-
-#include <stdint.h>
-#include <framework/coordinates/CoordinateTransformations.h>
-#include <framework/globalfunctions/math/VectorOperations.h>
-#include <framework/globalfunctions/timevalOperations.h>
-#include <framework/globalfunctions/constants.h>
-#include <memory.h>
-
-
-template<uint8_t DEGREE,uint8_t ORDER>
-class Jgm3Model {
-public:
-	static const uint32_t factorialLookupTable[DEGREE+3]; //This table is used instead of factorial calculation, must be increased if order or degree is higher
-
-	Jgm3Model() {
-		y0[0] = 0;
-		y0[1] = 0;
-		y0[2] = 0;
-		y0[3] = 0;
-		y0[4] = 0;
-		y0[5] = 0;
-
-		lastExecutionTime.tv_sec = 0;
-		lastExecutionTime.tv_usec = 0;
-	}
-	virtual ~Jgm3Model(){};
-
-	//double acsNavOrbit(double posECF[3],double velECF[3],timeval gpsTime);
-
-	double y0[6]; //position and velocity at beginning of RK step in EC
-	timeval lastExecutionTime; //Time of last execution
-
-
-	void accelDegOrd(const double pos[3],const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1],double* accel){
-		//Get radius of this position
-		double r = VectorOperations<double>::norm(pos,3);
-
-
-
-		//Initialize the V and W matrix
-		double V[DEGREE+2][ORDER+2] = {{0}};
-		double W[DEGREE+2][ORDER+2] = {{0}};
-
-		for(uint8_t m=0;m<(ORDER+2);m++){
-			for(uint8_t n=m;n<(DEGREE+2);n++){
-				if((n==0) && (m==0)){
-					//Montenbruck "Satellite Orbits Eq.3.31"
-					V[0][0] = Earth::MEAN_RADIUS / r;
-					W[0][0] = 0;
-				}else{
-					if(n==m){
-						//Montenbruck "Satellite Orbits Eq.3.29"
-						V[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1] - pos[1]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1]);
-						W[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1] + pos[1]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1]);
-					}else{
-						//Montenbruck "Satellite Orbits Eq.3.30"
-						V[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*V[n-1][m];
-						W[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*W[n-1][m];
-						if(n!=(m+1)){
-							V[n][m] = V[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * V[n-2][m]);
-							W[n][m] = W[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * W[n-2][m]);
-						}//End of if(n!=(m+1))
-					}//End of if(n==m){
-				}//End of if(n==0 and m==0)
-			}//End of for(uint8_t n=0;n<(DEGREE+1);n++)
-		}//End of for(uint8_t m=0;m<(ORDER+1);m++)
-
-
-		//overwrite accel if not properly initialized
-		accel[0] = 0;
-		accel[1] = 0;
-		accel[2] = 0;
-
-		for(uint8_t m=0;m<(ORDER+1);m++){
-			for(uint8_t n=m;n<(DEGREE+1);n++){
-				//Use table lookup to get factorial
-				double partAccel[3] = {0};
-				double factor = Earth::STANDARD_GRAVITATIONAL_PARAMETER/pow(Earth::MEAN_RADIUS,2);
-				if(m==0){
-					//Montenbruck "Satellite Orbits Eq.3.33"
-					partAccel[0] = factor * (-C[n][0]*V[n+1][1]);
-					partAccel[1] = factor * (-C[n][0]*W[n+1][1]);
-				}else{
-					double factMN = static_cast<double>(factorialLookupTable[n-m+2]) / static_cast<double>(factorialLookupTable[n-m]);
-					partAccel[0] = factor * 0.5 * ((-C[n][m]*V[n+1][m+1]-S[n][m]*W[n+1][m+1])+factMN*(C[n][m]*V[n+1][m-1]+S[n][m]*W[n+1][m-1]));
-					partAccel[1] = factor * 0.5 * ((-C[n][m]*W[n+1][m+1]+S[n][m]*V[n+1][m+1])+factMN*(-C[n][m]*W[n+1][m-1]+S[n][m]*V[n+1][m-1]));
-				}
-
-				partAccel[2] = factor * ((n-m+1)*(-C[n][m]*V[n+1][m]-S[n][m]*W[n+1][m]));
-
-
-				accel[0] += partAccel[0];
-				accel[1] += partAccel[1];
-				accel[2] += partAccel[2];
-			}//End of for(uint8_t n=0;n<DEGREE;n++)
-		}//End of uint8_t m=0;m<ORDER;m++
-	}
-
-	void initializeNavOrbit(const double position[3],const double velocity[3], timeval timeUTC){
-		CoordinateTransformations::positionEcfToEci(position,&y0[0],&timeUTC);
-		CoordinateTransformations::velocityEcfToEci(velocity,position,&y0[3],&timeUTC);
-		lastExecutionTime = timeUTC;
-	}
-
-
-	void acsNavOrbit(timeval timeUTC, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1], double outputPos[3],double outputVel[3]){
-
-		//RK4 Integration for this timestamp
-		double deltaT = timevalOperations::toDouble(timeUTC-lastExecutionTime);
-
-		double y0dot[6] = {0,0,0,0,0,0};
-		double yA[6] = {0,0,0,0,0,0};
-		double yAdot[6] = {0,0,0,0,0,0};
-		double yB[6] = {0,0,0,0,0,0};
-		double yBdot[6] = {0,0,0,0,0,0};
-		double yC[6] = {0,0,0,0,0,0};
-		double yCdot[6] = {0,0,0,0,0,0};
-
-		//Step One
-		rungeKuttaStep(y0,y0dot,lastExecutionTime,S,C);
-
-		//Step Two
-		VectorOperations<double>::mulScalar(y0dot,deltaT/2,yA,6);
-		VectorOperations<double>::add(y0,yA,yA,6);
-		rungeKuttaStep(yA,yAdot,lastExecutionTime,S,C);
-
-		//Step Three
-		VectorOperations<double>::mulScalar(yAdot,deltaT/2,yB,6);
-		VectorOperations<double>::add(y0,yB,yB,6);
-		rungeKuttaStep(yB,yBdot,lastExecutionTime,S,C);
-
-		//Step Four
-		VectorOperations<double>::mulScalar(yBdot,deltaT,yC,6);
-		VectorOperations<double>::add(y0,yC,yC,6);
-		rungeKuttaStep(yC,yCdot,lastExecutionTime,S,C);
-
-		//Calc new State
-		VectorOperations<double>::mulScalar(yAdot,2,yAdot,6);
-		VectorOperations<double>::mulScalar(yBdot,2,yBdot,6);
-		VectorOperations<double>::add(y0dot,yAdot,y0dot,6);
-		VectorOperations<double>::add(y0dot,yBdot,y0dot,6);
-		VectorOperations<double>::add(y0dot,yCdot,y0dot,6);
-		VectorOperations<double>::mulScalar(y0dot,1./6.*deltaT,y0dot,6);
-		VectorOperations<double>::add(y0,y0dot,y0,6);
-
-		CoordinateTransformations::positionEciToEcf(&y0[0],outputPos,&timeUTC);
-		CoordinateTransformations::velocityEciToEcf(&y0[3],&y0[0],outputVel,&timeUTC);
-
-		lastExecutionTime = timeUTC;
-
-
-	}
-
-
-	void rungeKuttaStep(const double* yIn,double* yOut,timeval time, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1]){
-		double rECF[3] = {0,0,0};
-		double rDotECF[3] = {0,0,0};
-		double accelECF[3] = {0,0,0};
-		double accelECI[3] = {0,0,0};
-
-
-		CoordinateTransformations::positionEciToEcf(&yIn[0],rECF,&time);
-		CoordinateTransformations::velocityEciToEcf(&yIn[3],&yIn[0],rDotECF,&time);
-		accelDegOrd(rECF,S,C,accelECF);
-		//This is not correct, as the acceleration would have derived terms but we don't know the velocity and position at that time
-		//Tests showed that a wrong velocity does make the equation worse than neglecting it
-		CoordinateTransformations::positionEcfToEci(accelECF,accelECI,&time);
-		memcpy(&yOut[0],&yIn[3],sizeof(yOut[0])*3);
-		memcpy(&yOut[3],accelECI,sizeof(yOut[0])*3);
-	}
-};
-
-
-
-
-
-
-#endif /* FRAMEWORK_COORDINATES_JGM3MODEL_H_ */
+#ifndef FRAMEWORK_COORDINATES_JGM3MODEL_H_
+#define FRAMEWORK_COORDINATES_JGM3MODEL_H_
+
+#include <stdint.h>
+#include "../coordinates/CoordinateTransformations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include "../globalfunctions/timevalOperations.h"
+#include "../globalfunctions/constants.h"
+#include <memory.h>
+
+
+template<uint8_t DEGREE,uint8_t ORDER>
+class Jgm3Model {
+public:
+	static const uint32_t factorialLookupTable[DEGREE+3]; //This table is used instead of factorial calculation, must be increased if order or degree is higher
+
+	Jgm3Model() {
+		y0[0] = 0;
+		y0[1] = 0;
+		y0[2] = 0;
+		y0[3] = 0;
+		y0[4] = 0;
+		y0[5] = 0;
+
+		lastExecutionTime.tv_sec = 0;
+		lastExecutionTime.tv_usec = 0;
+	}
+	virtual ~Jgm3Model(){};
+
+	//double acsNavOrbit(double posECF[3],double velECF[3],timeval gpsTime);
+
+	double y0[6]; //position and velocity at beginning of RK step in EC
+	timeval lastExecutionTime; //Time of last execution
+
+
+	void accelDegOrd(const double pos[3],const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1],double* accel){
+		//Get radius of this position
+		double r = VectorOperations<double>::norm(pos,3);
+
+
+
+		//Initialize the V and W matrix
+		double V[DEGREE+2][ORDER+2] = {{0}};
+		double W[DEGREE+2][ORDER+2] = {{0}};
+
+		for(uint8_t m=0;m<(ORDER+2);m++){
+			for(uint8_t n=m;n<(DEGREE+2);n++){
+				if((n==0) && (m==0)){
+					//Montenbruck "Satellite Orbits Eq.3.31"
+					V[0][0] = Earth::MEAN_RADIUS / r;
+					W[0][0] = 0;
+				}else{
+					if(n==m){
+						//Montenbruck "Satellite Orbits Eq.3.29"
+						V[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1] - pos[1]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1]);
+						W[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1] + pos[1]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1]);
+					}else{
+						//Montenbruck "Satellite Orbits Eq.3.30"
+						V[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*V[n-1][m];
+						W[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*W[n-1][m];
+						if(n!=(m+1)){
+							V[n][m] = V[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * V[n-2][m]);
+							W[n][m] = W[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * W[n-2][m]);
+						}//End of if(n!=(m+1))
+					}//End of if(n==m){
+				}//End of if(n==0 and m==0)
+			}//End of for(uint8_t n=0;n<(DEGREE+1);n++)
+		}//End of for(uint8_t m=0;m<(ORDER+1);m++)
+
+
+		//overwrite accel if not properly initialized
+		accel[0] = 0;
+		accel[1] = 0;
+		accel[2] = 0;
+
+		for(uint8_t m=0;m<(ORDER+1);m++){
+			for(uint8_t n=m;n<(DEGREE+1);n++){
+				//Use table lookup to get factorial
+				double partAccel[3] = {0};
+				double factor = Earth::STANDARD_GRAVITATIONAL_PARAMETER/pow(Earth::MEAN_RADIUS,2);
+				if(m==0){
+					//Montenbruck "Satellite Orbits Eq.3.33"
+					partAccel[0] = factor * (-C[n][0]*V[n+1][1]);
+					partAccel[1] = factor * (-C[n][0]*W[n+1][1]);
+				}else{
+					double factMN = static_cast<double>(factorialLookupTable[n-m+2]) / static_cast<double>(factorialLookupTable[n-m]);
+					partAccel[0] = factor * 0.5 * ((-C[n][m]*V[n+1][m+1]-S[n][m]*W[n+1][m+1])+factMN*(C[n][m]*V[n+1][m-1]+S[n][m]*W[n+1][m-1]));
+					partAccel[1] = factor * 0.5 * ((-C[n][m]*W[n+1][m+1]+S[n][m]*V[n+1][m+1])+factMN*(-C[n][m]*W[n+1][m-1]+S[n][m]*V[n+1][m-1]));
+				}
+
+				partAccel[2] = factor * ((n-m+1)*(-C[n][m]*V[n+1][m]-S[n][m]*W[n+1][m]));
+
+
+				accel[0] += partAccel[0];
+				accel[1] += partAccel[1];
+				accel[2] += partAccel[2];
+			}//End of for(uint8_t n=0;n<DEGREE;n++)
+		}//End of uint8_t m=0;m<ORDER;m++
+	}
+
+	void initializeNavOrbit(const double position[3],const double velocity[3], timeval timeUTC){
+		CoordinateTransformations::positionEcfToEci(position,&y0[0],&timeUTC);
+		CoordinateTransformations::velocityEcfToEci(velocity,position,&y0[3],&timeUTC);
+		lastExecutionTime = timeUTC;
+	}
+
+
+	void acsNavOrbit(timeval timeUTC, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1], double outputPos[3],double outputVel[3]){
+
+		//RK4 Integration for this timestamp
+		double deltaT = timevalOperations::toDouble(timeUTC-lastExecutionTime);
+
+		double y0dot[6] = {0,0,0,0,0,0};
+		double yA[6] = {0,0,0,0,0,0};
+		double yAdot[6] = {0,0,0,0,0,0};
+		double yB[6] = {0,0,0,0,0,0};
+		double yBdot[6] = {0,0,0,0,0,0};
+		double yC[6] = {0,0,0,0,0,0};
+		double yCdot[6] = {0,0,0,0,0,0};
+
+		//Step One
+		rungeKuttaStep(y0,y0dot,lastExecutionTime,S,C);
+
+		//Step Two
+		VectorOperations<double>::mulScalar(y0dot,deltaT/2,yA,6);
+		VectorOperations<double>::add(y0,yA,yA,6);
+		rungeKuttaStep(yA,yAdot,lastExecutionTime,S,C);
+
+		//Step Three
+		VectorOperations<double>::mulScalar(yAdot,deltaT/2,yB,6);
+		VectorOperations<double>::add(y0,yB,yB,6);
+		rungeKuttaStep(yB,yBdot,lastExecutionTime,S,C);
+
+		//Step Four
+		VectorOperations<double>::mulScalar(yBdot,deltaT,yC,6);
+		VectorOperations<double>::add(y0,yC,yC,6);
+		rungeKuttaStep(yC,yCdot,lastExecutionTime,S,C);
+
+		//Calc new State
+		VectorOperations<double>::mulScalar(yAdot,2,yAdot,6);
+		VectorOperations<double>::mulScalar(yBdot,2,yBdot,6);
+		VectorOperations<double>::add(y0dot,yAdot,y0dot,6);
+		VectorOperations<double>::add(y0dot,yBdot,y0dot,6);
+		VectorOperations<double>::add(y0dot,yCdot,y0dot,6);
+		VectorOperations<double>::mulScalar(y0dot,1./6.*deltaT,y0dot,6);
+		VectorOperations<double>::add(y0,y0dot,y0,6);
+
+		CoordinateTransformations::positionEciToEcf(&y0[0],outputPos,&timeUTC);
+		CoordinateTransformations::velocityEciToEcf(&y0[3],&y0[0],outputVel,&timeUTC);
+
+		lastExecutionTime = timeUTC;
+
+
+	}
+
+
+	void rungeKuttaStep(const double* yIn,double* yOut,timeval time, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1]){
+		double rECF[3] = {0,0,0};
+		double rDotECF[3] = {0,0,0};
+		double accelECF[3] = {0,0,0};
+		double accelECI[3] = {0,0,0};
+
+
+		CoordinateTransformations::positionEciToEcf(&yIn[0],rECF,&time);
+		CoordinateTransformations::velocityEciToEcf(&yIn[3],&yIn[0],rDotECF,&time);
+		accelDegOrd(rECF,S,C,accelECF);
+		//This is not correct, as the acceleration would have derived terms but we don't know the velocity and position at that time
+		//Tests showed that a wrong velocity does make the equation worse than neglecting it
+		CoordinateTransformations::positionEcfToEci(accelECF,accelECI,&time);
+		memcpy(&yOut[0],&yIn[3],sizeof(yOut[0])*3);
+		memcpy(&yOut[3],accelECI,sizeof(yOut[0])*3);
+	}
+};
+
+
+
+
+
+
+#endif /* FRAMEWORK_COORDINATES_JGM3MODEL_H_ */
diff --git a/coordinates/Sgp4Propagator.cpp b/coordinates/Sgp4Propagator.cpp
index 0eb20f08a..84a527997 100644
--- a/coordinates/Sgp4Propagator.cpp
+++ b/coordinates/Sgp4Propagator.cpp
@@ -1,228 +1,228 @@
-#include <framework/coordinates/CoordinateTransformations.h>
-#include <framework/coordinates/Sgp4Propagator.h>
-#include <framework/globalfunctions/constants.h>
-#include <framework/globalfunctions/math/MatrixOperations.h>
-#include <framework/globalfunctions/math/VectorOperations.h>
-#include <framework/globalfunctions/timevalOperations.h>
-#include <cstring>
-Sgp4Propagator::Sgp4Propagator() :
-		initialized(false), epoch({0, 0}), whichconst(wgs84) {
-
-}
-
-Sgp4Propagator::~Sgp4Propagator() {
-
-}
-
-void jday(int year, int mon, int day, int hr, int minute, double sec,
-		double& jd) {
-	jd = 367.0 * year - floor((7 * (year + floor((mon + 9) / 12.0))) * 0.25)
-			+ floor(275 * mon / 9.0) + day + 1721013.5
-			+ ((sec / 60.0 + minute) / 60.0 + hr) / 24.0;  // ut in days
-			// - 0.5*sgn(100.0*year + mon - 190002.5) + 0.5;
-}
-
-void days2mdhms(int year, double days, int& mon, int& day, int& hr, int& minute,
-		double& sec) {
-	int i, inttemp, dayofyr;
-	double temp;
-	int lmonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-
-	dayofyr = (int) floor(days);
-	/* ----------------- find month and day of month ---------------- */
-	if ((year % 4) == 0)
-		lmonth[1] = 29;
-
-	i = 1;
-	inttemp = 0;
-	while ((dayofyr > inttemp + lmonth[i - 1]) && (i < 12)) {
-		inttemp = inttemp + lmonth[i - 1];
-		i++;
-	}
-	mon = i;
-	day = dayofyr - inttemp;
-
-	/* ----------------- find hours minutes and seconds ------------- */
-	temp = (days - dayofyr) * 24.0;
-	hr = (int) floor(temp);
-	temp = (temp - hr) * 60.0;
-	minute = (int) floor(temp);
-	sec = (temp - minute) * 60.0;
-}
-
-ReturnValue_t Sgp4Propagator::initialize(const uint8_t* line1,
-		const uint8_t* line2) {
-
-	char longstr1[130];
-	char longstr2[130];
-
-	//need some space for decimal points
-	memcpy(longstr1, line1, 69);
-	memcpy(longstr2, line2, 69);
-
-	const double deg2rad = Math::PI / 180.0;    //   0.0174532925199433
-	const double xpdotp = 1440.0 / (2.0 * Math::PI); // 229.1831180523293
-
-	double sec, mu, radiusearthkm, tumin, xke, j2, j3, j4, j3oj2;
-	int cardnumb, numb, j;
-	long revnum = 0, elnum = 0;
-	char classification, intldesg[11];
-	int year = 0;
-	int mon, day, hr, minute, nexp, ibexp;
-
-	getgravconst(whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2);
-
-	satrec.error = 0;
-
-	// set the implied decimal points since doing a formated read
-	// fixes for bad input data values (missing, ...)
-	for (j = 10; j <= 15; j++)
-		if (longstr1[j] == ' ')
-			longstr1[j] = '_';
-
-	if (longstr1[44] != ' ')
-		longstr1[43] = longstr1[44];
-	longstr1[44] = '.';
-	if (longstr1[7] == ' ')
-		longstr1[7] = 'U';
-	if (longstr1[9] == ' ')
-		longstr1[9] = '.';
-	for (j = 45; j <= 49; j++)
-		if (longstr1[j] == ' ')
-			longstr1[j] = '0';
-	if (longstr1[51] == ' ')
-		longstr1[51] = '0';
-	if (longstr1[53] != ' ')
-		longstr1[52] = longstr1[53];
-	longstr1[53] = '.';
-	longstr2[25] = '.';
-	for (j = 26; j <= 32; j++)
-		if (longstr2[j] == ' ')
-			longstr2[j] = '0';
-	if (longstr1[62] == ' ')
-		longstr1[62] = '0';
-	if (longstr1[68] == ' ')
-		longstr1[68] = '0';
-
-	sscanf(longstr1,
-			"%2d %5ld %1c %10s %2d %12lf %11lf %7lf %2d %7lf %2d %2d %6ld ",
-			&cardnumb, &satrec.satnum, &classification, intldesg,
-			&satrec.epochyr, &satrec.epochdays, &satrec.ndot, &satrec.nddot,
-			&nexp, &satrec.bstar, &ibexp, &numb, &elnum);
-
-	if (longstr2[52] == ' ') {
-		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %10lf %6ld \n",
-				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
-				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
-	} else {
-		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %11lf %6ld \n",
-				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
-				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
-	}
-
-	// ---- find no, ndot, nddot ----
-	satrec.no = satrec.no / xpdotp; //* rad/min
-	satrec.nddot = satrec.nddot * pow(10.0, nexp);
-	satrec.bstar = satrec.bstar * pow(10.0, ibexp);
-
-	// ---- convert to sgp4 units ----
-	satrec.a = pow(satrec.no * tumin, (-2.0 / 3.0));
-	satrec.ndot = satrec.ndot / (xpdotp * 1440.0);  //* ? * minperday
-	satrec.nddot = satrec.nddot / (xpdotp * 1440.0 * 1440);
-
-	// ---- find standard orbital elements ----
-	satrec.inclo = satrec.inclo * deg2rad;
-	satrec.nodeo = satrec.nodeo * deg2rad;
-	satrec.argpo = satrec.argpo * deg2rad;
-	satrec.mo = satrec.mo * deg2rad;
-
-	satrec.alta = satrec.a * (1.0 + satrec.ecco) - 1.0;
-	satrec.altp = satrec.a * (1.0 - satrec.ecco) - 1.0;
-
-	// ----------------------------------------------------------------
-	// find sgp4epoch time of element set
-	// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
-	// and minutes from the epoch (time)
-	// ----------------------------------------------------------------
-
-	// ---------------- temp fix for years from 1957-2056 -------------------
-	// --------- correct fix will occur when year is 4-digit in tle ---------
-	if (satrec.epochyr < 57) {
-		year = satrec.epochyr + 2000;
-	} else {
-		year = satrec.epochyr + 1900;
-	}
-
-	days2mdhms(year, satrec.epochdays, mon, day, hr, minute, sec);
-	jday(year, mon, day, hr, minute, sec, satrec.jdsatepoch);
-
-	double unixSeconds = (satrec.jdsatepoch - 2451544.5) * 24 * 3600
-			+ 946684800;
-
-	epoch.tv_sec = unixSeconds;
-	double subseconds = unixSeconds - epoch.tv_sec;
-	epoch.tv_usec = subseconds * 1000000;
-
-	// ---------------- initialize the orbit at sgp4epoch -------------------
-	uint8_t result = sgp4init(whichconst, satrec.satnum,
-			satrec.jdsatepoch - 2433281.5, satrec.bstar, satrec.ecco,
-			satrec.argpo, satrec.inclo, satrec.mo, satrec.no, satrec.nodeo,
-			satrec);
-
-	if (result != 00) {
-		return MAKE_RETURN_CODE(result);
-	} else {
-		initialized = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-}
-
-ReturnValue_t Sgp4Propagator::propagate(double* position, double* velocity,
-		timeval time, uint8_t gpsUtcOffset) {
-
-	if (!initialized) {
-		return TLE_NOT_INITIALIZED;
-	}
-
-	//Time since epoch in minutes
-	timeval timeSinceEpoch = time - epoch;
-	double minutesSinceEpoch = timeSinceEpoch.tv_sec / 60.
-			+ timeSinceEpoch.tv_usec / 60000000.;
-
-	double yearsSinceEpoch = minutesSinceEpoch / 60 / 24 / 365;
-
-	if ((yearsSinceEpoch > 1) || (yearsSinceEpoch < -1)) {
-		return TLE_TOO_OLD;
-	}
-
-	double positionTEME[3];
-	double velocityTEME[3];
-
-	uint8_t result = sgp4(whichconst, satrec, minutesSinceEpoch, positionTEME,
-			velocityTEME);
-
-	VectorOperations<double>::mulScalar(positionTEME, 1000, positionTEME, 3);
-	VectorOperations<double>::mulScalar(velocityTEME, 1000, velocityTEME, 3);
-
-	//Transform to ECF
-	double earthRotationMatrix[3][3];
-	CoordinateTransformations::getEarthRotationMatrix(time,
-			earthRotationMatrix);
-
-	MatrixOperations<double>::multiply(earthRotationMatrix[0], positionTEME,
-			position, 3, 3, 1);
-	MatrixOperations<double>::multiply(earthRotationMatrix[0], velocityTEME,
-			velocity, 3, 3, 1);
-
-	double omegaEarth[3] = { 0, 0, Earth::OMEGA };
-	double velocityCorrection[3];
-	VectorOperations<double>::cross(omegaEarth, position, velocityCorrection);
-	VectorOperations<double>::subtract(velocity, velocityCorrection, velocity);
-
-	if (result != 0) {
-		return MAKE_RETURN_CODE(result || 0xB0);
-	} else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
+#include "../coordinates/CoordinateTransformations.h"
+#include "../coordinates/Sgp4Propagator.h"
+#include "../globalfunctions/constants.h"
+#include "../globalfunctions/math/MatrixOperations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include "../globalfunctions/timevalOperations.h"
+#include <cstring>
+Sgp4Propagator::Sgp4Propagator() :
+		initialized(false), epoch({0, 0}), whichconst(wgs84) {
+
+}
+
+Sgp4Propagator::~Sgp4Propagator() {
+
+}
+
+void jday(int year, int mon, int day, int hr, int minute, double sec,
+		double& jd) {
+	jd = 367.0 * year - floor((7 * (year + floor((mon + 9) / 12.0))) * 0.25)
+			+ floor(275 * mon / 9.0) + day + 1721013.5
+			+ ((sec / 60.0 + minute) / 60.0 + hr) / 24.0;  // ut in days
+			// - 0.5*sgn(100.0*year + mon - 190002.5) + 0.5;
+}
+
+void days2mdhms(int year, double days, int& mon, int& day, int& hr, int& minute,
+		double& sec) {
+	int i, inttemp, dayofyr;
+	double temp;
+	int lmonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+	dayofyr = (int) floor(days);
+	/* ----------------- find month and day of month ---------------- */
+	if ((year % 4) == 0)
+		lmonth[1] = 29;
+
+	i = 1;
+	inttemp = 0;
+	while ((dayofyr > inttemp + lmonth[i - 1]) && (i < 12)) {
+		inttemp = inttemp + lmonth[i - 1];
+		i++;
+	}
+	mon = i;
+	day = dayofyr - inttemp;
+
+	/* ----------------- find hours minutes and seconds ------------- */
+	temp = (days - dayofyr) * 24.0;
+	hr = (int) floor(temp);
+	temp = (temp - hr) * 60.0;
+	minute = (int) floor(temp);
+	sec = (temp - minute) * 60.0;
+}
+
+ReturnValue_t Sgp4Propagator::initialize(const uint8_t* line1,
+		const uint8_t* line2) {
+
+	char longstr1[130];
+	char longstr2[130];
+
+	//need some space for decimal points
+	memcpy(longstr1, line1, 69);
+	memcpy(longstr2, line2, 69);
+
+	const double deg2rad = Math::PI / 180.0;    //   0.0174532925199433
+	const double xpdotp = 1440.0 / (2.0 * Math::PI); // 229.1831180523293
+
+	double sec, mu, radiusearthkm, tumin, xke, j2, j3, j4, j3oj2;
+	int cardnumb, numb, j;
+	long revnum = 0, elnum = 0;
+	char classification, intldesg[11];
+	int year = 0;
+	int mon, day, hr, minute, nexp, ibexp;
+
+	getgravconst(whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2);
+
+	satrec.error = 0;
+
+	// set the implied decimal points since doing a formated read
+	// fixes for bad input data values (missing, ...)
+	for (j = 10; j <= 15; j++)
+		if (longstr1[j] == ' ')
+			longstr1[j] = '_';
+
+	if (longstr1[44] != ' ')
+		longstr1[43] = longstr1[44];
+	longstr1[44] = '.';
+	if (longstr1[7] == ' ')
+		longstr1[7] = 'U';
+	if (longstr1[9] == ' ')
+		longstr1[9] = '.';
+	for (j = 45; j <= 49; j++)
+		if (longstr1[j] == ' ')
+			longstr1[j] = '0';
+	if (longstr1[51] == ' ')
+		longstr1[51] = '0';
+	if (longstr1[53] != ' ')
+		longstr1[52] = longstr1[53];
+	longstr1[53] = '.';
+	longstr2[25] = '.';
+	for (j = 26; j <= 32; j++)
+		if (longstr2[j] == ' ')
+			longstr2[j] = '0';
+	if (longstr1[62] == ' ')
+		longstr1[62] = '0';
+	if (longstr1[68] == ' ')
+		longstr1[68] = '0';
+
+	sscanf(longstr1,
+			"%2d %5ld %1c %10s %2d %12lf %11lf %7lf %2d %7lf %2d %2d %6ld ",
+			&cardnumb, &satrec.satnum, &classification, intldesg,
+			&satrec.epochyr, &satrec.epochdays, &satrec.ndot, &satrec.nddot,
+			&nexp, &satrec.bstar, &ibexp, &numb, &elnum);
+
+	if (longstr2[52] == ' ') {
+		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %10lf %6ld \n",
+				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
+				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
+	} else {
+		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %11lf %6ld \n",
+				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
+				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
+	}
+
+	// ---- find no, ndot, nddot ----
+	satrec.no = satrec.no / xpdotp; //* rad/min
+	satrec.nddot = satrec.nddot * pow(10.0, nexp);
+	satrec.bstar = satrec.bstar * pow(10.0, ibexp);
+
+	// ---- convert to sgp4 units ----
+	satrec.a = pow(satrec.no * tumin, (-2.0 / 3.0));
+	satrec.ndot = satrec.ndot / (xpdotp * 1440.0);  //* ? * minperday
+	satrec.nddot = satrec.nddot / (xpdotp * 1440.0 * 1440);
+
+	// ---- find standard orbital elements ----
+	satrec.inclo = satrec.inclo * deg2rad;
+	satrec.nodeo = satrec.nodeo * deg2rad;
+	satrec.argpo = satrec.argpo * deg2rad;
+	satrec.mo = satrec.mo * deg2rad;
+
+	satrec.alta = satrec.a * (1.0 + satrec.ecco) - 1.0;
+	satrec.altp = satrec.a * (1.0 - satrec.ecco) - 1.0;
+
+	// ----------------------------------------------------------------
+	// find sgp4epoch time of element set
+	// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
+	// and minutes from the epoch (time)
+	// ----------------------------------------------------------------
+
+	// ---------------- temp fix for years from 1957-2056 -------------------
+	// --------- correct fix will occur when year is 4-digit in tle ---------
+	if (satrec.epochyr < 57) {
+		year = satrec.epochyr + 2000;
+	} else {
+		year = satrec.epochyr + 1900;
+	}
+
+	days2mdhms(year, satrec.epochdays, mon, day, hr, minute, sec);
+	jday(year, mon, day, hr, minute, sec, satrec.jdsatepoch);
+
+	double unixSeconds = (satrec.jdsatepoch - 2451544.5) * 24 * 3600
+			+ 946684800;
+
+	epoch.tv_sec = unixSeconds;
+	double subseconds = unixSeconds - epoch.tv_sec;
+	epoch.tv_usec = subseconds * 1000000;
+
+	// ---------------- initialize the orbit at sgp4epoch -------------------
+	uint8_t result = sgp4init(whichconst, satrec.satnum,
+			satrec.jdsatepoch - 2433281.5, satrec.bstar, satrec.ecco,
+			satrec.argpo, satrec.inclo, satrec.mo, satrec.no, satrec.nodeo,
+			satrec);
+
+	if (result != 00) {
+		return MAKE_RETURN_CODE(result);
+	} else {
+		initialized = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+}
+
+ReturnValue_t Sgp4Propagator::propagate(double* position, double* velocity,
+		timeval time, uint8_t gpsUtcOffset) {
+
+	if (!initialized) {
+		return TLE_NOT_INITIALIZED;
+	}
+
+	//Time since epoch in minutes
+	timeval timeSinceEpoch = time - epoch;
+	double minutesSinceEpoch = timeSinceEpoch.tv_sec / 60.
+			+ timeSinceEpoch.tv_usec / 60000000.;
+
+	double yearsSinceEpoch = minutesSinceEpoch / 60 / 24 / 365;
+
+	if ((yearsSinceEpoch > 1) || (yearsSinceEpoch < -1)) {
+		return TLE_TOO_OLD;
+	}
+
+	double positionTEME[3];
+	double velocityTEME[3];
+
+	uint8_t result = sgp4(whichconst, satrec, minutesSinceEpoch, positionTEME,
+			velocityTEME);
+
+	VectorOperations<double>::mulScalar(positionTEME, 1000, positionTEME, 3);
+	VectorOperations<double>::mulScalar(velocityTEME, 1000, velocityTEME, 3);
+
+	//Transform to ECF
+	double earthRotationMatrix[3][3];
+	CoordinateTransformations::getEarthRotationMatrix(time,
+			earthRotationMatrix);
+
+	MatrixOperations<double>::multiply(earthRotationMatrix[0], positionTEME,
+			position, 3, 3, 1);
+	MatrixOperations<double>::multiply(earthRotationMatrix[0], velocityTEME,
+			velocity, 3, 3, 1);
+
+	double omegaEarth[3] = { 0, 0, Earth::OMEGA };
+	double velocityCorrection[3];
+	VectorOperations<double>::cross(omegaEarth, position, velocityCorrection);
+	VectorOperations<double>::subtract(velocity, velocityCorrection, velocity);
+
+	if (result != 0) {
+		return MAKE_RETURN_CODE(result || 0xB0);
+	} else {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
diff --git a/coordinates/Sgp4Propagator.h b/coordinates/Sgp4Propagator.h
index 957397620..f041ec075 100644
--- a/coordinates/Sgp4Propagator.h
+++ b/coordinates/Sgp4Propagator.h
@@ -1,44 +1,44 @@
-#ifndef SGP4PROPAGATOR_H_
-#define SGP4PROPAGATOR_H_
-
-#include <sys/time.h>
-#include "../contrib/sgp4/sgp4unit.h"
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-class Sgp4Propagator {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SGP4PROPAGATOR_CLASS;
-	static const ReturnValue_t INVALID_ECCENTRICITY = MAKE_RETURN_CODE(0xA1);
-	static const ReturnValue_t INVALID_MEAN_MOTION = MAKE_RETURN_CODE(0xA2);
-	static const ReturnValue_t INVALID_PERTURBATION_ELEMENTS = MAKE_RETURN_CODE(0xA3);
-	static const ReturnValue_t INVALID_SEMI_LATUS_RECTUM = MAKE_RETURN_CODE(0xA4);
-	static const ReturnValue_t INVALID_EPOCH_ELEMENTS = MAKE_RETURN_CODE(0xA5);
-	static const ReturnValue_t SATELLITE_HAS_DECAYED = MAKE_RETURN_CODE(0xA6);
-	static const ReturnValue_t TLE_TOO_OLD = MAKE_RETURN_CODE(0xB1);
-	static const ReturnValue_t TLE_NOT_INITIALIZED = MAKE_RETURN_CODE(0xB2);
-
-
-
-	Sgp4Propagator();
-	virtual ~Sgp4Propagator();
-
-	ReturnValue_t initialize(const uint8_t *line1, const uint8_t *line2);
-
-	/**
-	 *
-	 * @param[out] position in ECF
-	 * @param[out] velocity in ECF
-	 * @param time to which to propagate
-	 * @return
-	 */
-	ReturnValue_t propagate(double *position, double *velocity, timeval time, uint8_t gpsUtcOffset);
-
-private:
-	bool initialized;
-	timeval epoch;
-	elsetrec satrec;
-	gravconsttype whichconst;
-
-};
-
-#endif /* SGP4PROPAGATOR_H_ */
+#ifndef SGP4PROPAGATOR_H_
+#define SGP4PROPAGATOR_H_
+
+#include <sys/time.h>
+#include "../contrib/sgp4/sgp4unit.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class Sgp4Propagator {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SGP4PROPAGATOR_CLASS;
+	static const ReturnValue_t INVALID_ECCENTRICITY = MAKE_RETURN_CODE(0xA1);
+	static const ReturnValue_t INVALID_MEAN_MOTION = MAKE_RETURN_CODE(0xA2);
+	static const ReturnValue_t INVALID_PERTURBATION_ELEMENTS = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t INVALID_SEMI_LATUS_RECTUM = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t INVALID_EPOCH_ELEMENTS = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t SATELLITE_HAS_DECAYED = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t TLE_TOO_OLD = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t TLE_NOT_INITIALIZED = MAKE_RETURN_CODE(0xB2);
+
+
+
+	Sgp4Propagator();
+	virtual ~Sgp4Propagator();
+
+	ReturnValue_t initialize(const uint8_t *line1, const uint8_t *line2);
+
+	/**
+	 *
+	 * @param[out] position in ECF
+	 * @param[out] velocity in ECF
+	 * @param time to which to propagate
+	 * @return
+	 */
+	ReturnValue_t propagate(double *position, double *velocity, timeval time, uint8_t gpsUtcOffset);
+
+private:
+	bool initialized;
+	timeval epoch;
+	elsetrec satrec;
+	gravconsttype whichconst;
+
+};
+
+#endif /* SGP4PROPAGATOR_H_ */
diff --git a/datalinklayer/BCFrame.h b/datalinklayer/BCFrame.h
index bcdf53008..785cbb755 100644
--- a/datalinklayer/BCFrame.h
+++ b/datalinklayer/BCFrame.h
@@ -1,62 +1,62 @@
-/**
- * @file	BCFrame.h
- * @brief	This file defines the BCFrame class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef BCFRAME_H_
-#define BCFRAME_H_
-
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
-
-/**
- * Small helper class to identify a BcFrame.
- * @ingroup ccsds_handling
- */
-class BcFrame: public CCSDSReturnValuesIF {
-private:
-	static const uint8_t UNLOCK_COMMAND = 0b00000000;//! Identifier for a certain BC Command.
-	static const uint8_t SET_V_R_1 = 0b10000010;//! Identifier for a certain BC Command.
-	static const uint8_t SET_V_R_2 = 0b00000000;//! Identifier for a certain BC Command.
-
-public:
-	uint8_t byte1;	//!< First content byte
-	uint8_t byte2;	//!< Second content byte
-	uint8_t vR;	//!< vR byte
-	/**
-	 * Simple default constructor.
-	 */
-	BcFrame() :
-			byte1(0), byte2(0), vR(0) {
-	}
-	/**
-	 * Main and only useful method of the class.
-	 * With the buffer and size information passed, the class passes the content
-	 * and checks if it is one of the two valid BC Command Frames.
-	 * @param inBuffer	Content of the frame to check,
-	 * @param inSize	Size of the data to check.
-	 * @return 	- #BC_ILLEGAL_COMMAND if it is no command.
-	 * 			- #BC_IS_UNLOCK_COMMAND if it is an unlock command.
-	 * 			- #BC_IS_SET_VR_COMMAND if it is such.
-	 */
-	ReturnValue_t initialize(const uint8_t* inBuffer, uint16_t inSize) {
-		ReturnValue_t returnValue = BC_ILLEGAL_COMMAND;
-		if (inSize == 1) {
-			byte1 = inBuffer[0];
-			if (byte1 == UNLOCK_COMMAND) {
-				returnValue = BC_IS_UNLOCK_COMMAND;
-			}
-		} else if (inSize == 3) {
-			byte1 = inBuffer[0];
-			byte2 = inBuffer[1];
-			vR = inBuffer[2];
-			if (byte1 == SET_V_R_1 && byte2 == SET_V_R_2) {
-				returnValue = BC_IS_SET_VR_COMMAND;
-			}
-		}
-		return returnValue;
-	}
-};
-
-#endif /* BCFRAME_H_ */
+/**
+ * @file	BCFrame.h
+ * @brief	This file defines the BCFrame class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef BCFRAME_H_
+#define BCFRAME_H_
+
+#include "../datalinklayer/CCSDSReturnValuesIF.h"
+
+/**
+ * Small helper class to identify a BcFrame.
+ * @ingroup ccsds_handling
+ */
+class BcFrame: public CCSDSReturnValuesIF {
+private:
+	static const uint8_t UNLOCK_COMMAND = 0b00000000;//! Identifier for a certain BC Command.
+	static const uint8_t SET_V_R_1 = 0b10000010;//! Identifier for a certain BC Command.
+	static const uint8_t SET_V_R_2 = 0b00000000;//! Identifier for a certain BC Command.
+
+public:
+	uint8_t byte1;	//!< First content byte
+	uint8_t byte2;	//!< Second content byte
+	uint8_t vR;	//!< vR byte
+	/**
+	 * Simple default constructor.
+	 */
+	BcFrame() :
+			byte1(0), byte2(0), vR(0) {
+	}
+	/**
+	 * Main and only useful method of the class.
+	 * With the buffer and size information passed, the class passes the content
+	 * and checks if it is one of the two valid BC Command Frames.
+	 * @param inBuffer	Content of the frame to check,
+	 * @param inSize	Size of the data to check.
+	 * @return 	- #BC_ILLEGAL_COMMAND if it is no command.
+	 * 			- #BC_IS_UNLOCK_COMMAND if it is an unlock command.
+	 * 			- #BC_IS_SET_VR_COMMAND if it is such.
+	 */
+	ReturnValue_t initialize(const uint8_t* inBuffer, uint16_t inSize) {
+		ReturnValue_t returnValue = BC_ILLEGAL_COMMAND;
+		if (inSize == 1) {
+			byte1 = inBuffer[0];
+			if (byte1 == UNLOCK_COMMAND) {
+				returnValue = BC_IS_UNLOCK_COMMAND;
+			}
+		} else if (inSize == 3) {
+			byte1 = inBuffer[0];
+			byte2 = inBuffer[1];
+			vR = inBuffer[2];
+			if (byte1 == SET_V_R_1 && byte2 == SET_V_R_2) {
+				returnValue = BC_IS_SET_VR_COMMAND;
+			}
+		}
+		return returnValue;
+	}
+};
+
+#endif /* BCFRAME_H_ */
diff --git a/datalinklayer/CCSDSReturnValuesIF.h b/datalinklayer/CCSDSReturnValuesIF.h
index 4d4f4bde9..054be9e78 100644
--- a/datalinklayer/CCSDSReturnValuesIF.h
+++ b/datalinklayer/CCSDSReturnValuesIF.h
@@ -1,56 +1,56 @@
-/**
- * @file	CCSDSReturnValuesIF.h
- * @brief	This file defines the CCSDSReturnValuesIF class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef CCSDSRETURNVALUESIF_H_
-#define CCSDSRETURNVALUESIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-/**
- * This is a helper class to collect special return values that come up during CCSDS Handling.
- * @ingroup ccsds_handling
- */
-class CCSDSReturnValuesIF: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER_IF;	//!< Basic ID of the interface.
-
-	static const ReturnValue_t BC_IS_SET_VR_COMMAND = MAKE_RETURN_CODE( 0x01 );	//!< A value to describe a BC frame.
-	static const ReturnValue_t BC_IS_UNLOCK_COMMAND = MAKE_RETURN_CODE( 0x02 );	//!< A value to describe a BC frame.
-	static const ReturnValue_t BC_ILLEGAL_COMMAND = MAKE_RETURN_CODE( 0xB0 );//!< A value to describe an illegal BC frame.
-	static const ReturnValue_t BOARD_READING_NOT_FINISHED = MAKE_RETURN_CODE( 0xB1 );	//! The CCSDS Board is not yet finished reading, it requires another cycle.
-
-	static const ReturnValue_t NS_POSITIVE_W = MAKE_RETURN_CODE( 0xF0 );//!< NS is in the positive window
-	static const ReturnValue_t NS_NEGATIVE_W = MAKE_RETURN_CODE( 0xF1 );//!< NS is in the negative window
-	static const ReturnValue_t NS_LOCKOUT = MAKE_RETURN_CODE( 0xF2 );	//!< NS is in lockout state
-	static const ReturnValue_t FARM_IN_LOCKOUT = MAKE_RETURN_CODE( 0xF3 );//!< FARM-1 is currently in lockout state
-	static const ReturnValue_t FARM_IN_WAIT = MAKE_RETURN_CODE( 0xF4 );	//!< FARM-1 is currently in wait state
-
-	static const ReturnValue_t WRONG_SYMBOL = MAKE_RETURN_CODE( 0xE0 );	//!< An error code in the FrameFinder.
-	static const ReturnValue_t DOUBLE_START = MAKE_RETURN_CODE( 0xE1 );	//!< An error code in the FrameFinder.
-	static const ReturnValue_t START_SYMBOL_MISSED = MAKE_RETURN_CODE( 0xE2 );//!< An error code in the FrameFinder.
-	static const ReturnValue_t END_WITHOUT_START = MAKE_RETURN_CODE( 0xE3 );//!< An error code in the FrameFinder.
-	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE( 0xE4 );//!< An error code for a frame.
-	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE( 0xE5 );//!< An error code for a frame.
-	static const ReturnValue_t WRONG_TF_VERSION = MAKE_RETURN_CODE( 0xE6 );	//!< An error code for a frame.
-	static const ReturnValue_t WRONG_SPACECRAFT_ID = MAKE_RETURN_CODE( 0xE7 );//!< An error code for a frame.
-	static const ReturnValue_t NO_VALID_FRAME_TYPE = MAKE_RETURN_CODE( 0xE8 );//!< An error code for a frame.
-	static const ReturnValue_t CRC_FAILED = MAKE_RETURN_CODE( 0xE9 );//!< An error code for a frame.
-	static const ReturnValue_t VC_NOT_FOUND = MAKE_RETURN_CODE( 0xEA );	//!< An error code for a frame.
-	static const ReturnValue_t FORWARDING_FAILED = MAKE_RETURN_CODE( 0xEB );//!< An error code for a frame.
-	static const ReturnValue_t CONTENT_TOO_LARGE = MAKE_RETURN_CODE( 0xEC );//!< An error code for a frame.
-	static const ReturnValue_t RESIDUAL_DATA = MAKE_RETURN_CODE( 0xED );//!< An error code for a frame.
-	static const ReturnValue_t DATA_CORRUPTED = MAKE_RETURN_CODE( 0xEE );//!< An error code for a frame.
-	static const ReturnValue_t ILLEGAL_SEGMENTATION_FLAG = MAKE_RETURN_CODE( 0xEF );//!< An error code for a frame.
-	static const ReturnValue_t ILLEGAL_FLAG_COMBINATION = MAKE_RETURN_CODE( 0xD0 );	//!< An error code for a frame.
-	static const ReturnValue_t SHORTER_THAN_HEADER = MAKE_RETURN_CODE( 0xD1 );	//!< An error code for a frame.
-	static const ReturnValue_t TOO_SHORT_BLOCKED_PACKET = MAKE_RETURN_CODE( 0xD2 );	//!< An error code for a frame.
-	static const ReturnValue_t TOO_SHORT_MAP_EXTRACTION = MAKE_RETURN_CODE( 0xD3 );	//!< An error code for a frame.
-
-	virtual ~CCSDSReturnValuesIF() {
-	} //!< Empty virtual destructor
-};
-
-#endif /* CCSDSRETURNVALUESIF_H_ */
+/**
+ * @file	CCSDSReturnValuesIF.h
+ * @brief	This file defines the CCSDSReturnValuesIF class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef CCSDSRETURNVALUESIF_H_
+#define CCSDSRETURNVALUESIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ * This is a helper class to collect special return values that come up during CCSDS Handling.
+ * @ingroup ccsds_handling
+ */
+class CCSDSReturnValuesIF: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER_IF;	//!< Basic ID of the interface.
+
+	static const ReturnValue_t BC_IS_SET_VR_COMMAND = MAKE_RETURN_CODE( 0x01 );	//!< A value to describe a BC frame.
+	static const ReturnValue_t BC_IS_UNLOCK_COMMAND = MAKE_RETURN_CODE( 0x02 );	//!< A value to describe a BC frame.
+	static const ReturnValue_t BC_ILLEGAL_COMMAND = MAKE_RETURN_CODE( 0xB0 );//!< A value to describe an illegal BC frame.
+	static const ReturnValue_t BOARD_READING_NOT_FINISHED = MAKE_RETURN_CODE( 0xB1 );	//! The CCSDS Board is not yet finished reading, it requires another cycle.
+
+	static const ReturnValue_t NS_POSITIVE_W = MAKE_RETURN_CODE( 0xF0 );//!< NS is in the positive window
+	static const ReturnValue_t NS_NEGATIVE_W = MAKE_RETURN_CODE( 0xF1 );//!< NS is in the negative window
+	static const ReturnValue_t NS_LOCKOUT = MAKE_RETURN_CODE( 0xF2 );	//!< NS is in lockout state
+	static const ReturnValue_t FARM_IN_LOCKOUT = MAKE_RETURN_CODE( 0xF3 );//!< FARM-1 is currently in lockout state
+	static const ReturnValue_t FARM_IN_WAIT = MAKE_RETURN_CODE( 0xF4 );	//!< FARM-1 is currently in wait state
+
+	static const ReturnValue_t WRONG_SYMBOL = MAKE_RETURN_CODE( 0xE0 );	//!< An error code in the FrameFinder.
+	static const ReturnValue_t DOUBLE_START = MAKE_RETURN_CODE( 0xE1 );	//!< An error code in the FrameFinder.
+	static const ReturnValue_t START_SYMBOL_MISSED = MAKE_RETURN_CODE( 0xE2 );//!< An error code in the FrameFinder.
+	static const ReturnValue_t END_WITHOUT_START = MAKE_RETURN_CODE( 0xE3 );//!< An error code in the FrameFinder.
+	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE( 0xE4 );//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE( 0xE5 );//!< An error code for a frame.
+	static const ReturnValue_t WRONG_TF_VERSION = MAKE_RETURN_CODE( 0xE6 );	//!< An error code for a frame.
+	static const ReturnValue_t WRONG_SPACECRAFT_ID = MAKE_RETURN_CODE( 0xE7 );//!< An error code for a frame.
+	static const ReturnValue_t NO_VALID_FRAME_TYPE = MAKE_RETURN_CODE( 0xE8 );//!< An error code for a frame.
+	static const ReturnValue_t CRC_FAILED = MAKE_RETURN_CODE( 0xE9 );//!< An error code for a frame.
+	static const ReturnValue_t VC_NOT_FOUND = MAKE_RETURN_CODE( 0xEA );	//!< An error code for a frame.
+	static const ReturnValue_t FORWARDING_FAILED = MAKE_RETURN_CODE( 0xEB );//!< An error code for a frame.
+	static const ReturnValue_t CONTENT_TOO_LARGE = MAKE_RETURN_CODE( 0xEC );//!< An error code for a frame.
+	static const ReturnValue_t RESIDUAL_DATA = MAKE_RETURN_CODE( 0xED );//!< An error code for a frame.
+	static const ReturnValue_t DATA_CORRUPTED = MAKE_RETURN_CODE( 0xEE );//!< An error code for a frame.
+	static const ReturnValue_t ILLEGAL_SEGMENTATION_FLAG = MAKE_RETURN_CODE( 0xEF );//!< An error code for a frame.
+	static const ReturnValue_t ILLEGAL_FLAG_COMBINATION = MAKE_RETURN_CODE( 0xD0 );	//!< An error code for a frame.
+	static const ReturnValue_t SHORTER_THAN_HEADER = MAKE_RETURN_CODE( 0xD1 );	//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT_BLOCKED_PACKET = MAKE_RETURN_CODE( 0xD2 );	//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT_MAP_EXTRACTION = MAKE_RETURN_CODE( 0xD3 );	//!< An error code for a frame.
+
+	virtual ~CCSDSReturnValuesIF() {
+	} //!< Empty virtual destructor
+};
+
+#endif /* CCSDSRETURNVALUESIF_H_ */
diff --git a/datalinklayer/Clcw.cpp b/datalinklayer/Clcw.cpp
index ee497e206..53424e8a1 100644
--- a/datalinklayer/Clcw.cpp
+++ b/datalinklayer/Clcw.cpp
@@ -1,63 +1,63 @@
-/**
- * @file	Clcw.cpp
- * @brief	This file defines the Clcw class.
- * @date	17.04.2013
- * @author	baetz
- */
-
-
-
-#include <framework/datalinklayer/Clcw.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-Clcw::Clcw() {
-	content.raw = 0;
-	content.status = STATUS_FIELD_DEFAULT;
-}
-
-Clcw::~Clcw() {
-}
-
-void Clcw::setVirtualChannel(uint8_t setChannel) {
-	content.virtualChannelIdSpare = ((setChannel & 0x3F) << 2);
-}
-
-void Clcw::setLockoutFlag(bool lockout) {
-	content.flags = (content.flags & LOCKOUT_FLAG_MASK) | (lockout << LOCKOUT_FLAG_POSITION);
-}
-
-void Clcw::setWaitFlag(bool waitFlag) {
-	content.flags = (content.flags & WAIT_FLAG_MASK) | (waitFlag << WAIT_FLAG_POSITION);
-}
-
-void Clcw::setRetransmitFlag(bool retransmitFlag) {
-	content.flags = (content.flags & RETRANSMIT_FLAG_MASK) | (retransmitFlag << RETRANSMIT_FLAG_POSITION);
-}
-
-void Clcw::setFarmBCount(uint8_t count) {
-	content.flags = (content.flags & FARM_B_COUNT_MASK) | ((count & 0x03) << 1);
-}
-
-void Clcw::setReceiverFrameSequenceNumber(uint8_t vR) {
-	content.vRValue = vR;
-}
-
-uint32_t Clcw::getAsWhole() {
-	return content.raw;
-}
-
-void Clcw::setRFAvailable(bool rfAvailable) {
-	content.flags = (content.flags & NO_RF_AVIALABLE_MASK) | (!rfAvailable << NO_RF_AVIALABLE_POSITION);
-}
-
-void Clcw::setBitLock(bool bitLock) {
-	content.flags = (content.flags & NO_BIT_LOCK_MASK) | (!bitLock << NO_BIT_LOCK_POSITION);
-}
-
-void Clcw::print() {
-	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
-}
-
-void Clcw::setWhole(uint32_t rawClcw) {
-	content.raw = rawClcw;
-}
+/**
+ * @file	Clcw.cpp
+ * @brief	This file defines the Clcw class.
+ * @date	17.04.2013
+ * @author	baetz
+ */
+
+
+
+#include "../datalinklayer/Clcw.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+Clcw::Clcw() {
+	content.raw = 0;
+	content.status = STATUS_FIELD_DEFAULT;
+}
+
+Clcw::~Clcw() {
+}
+
+void Clcw::setVirtualChannel(uint8_t setChannel) {
+	content.virtualChannelIdSpare = ((setChannel & 0x3F) << 2);
+}
+
+void Clcw::setLockoutFlag(bool lockout) {
+	content.flags = (content.flags & LOCKOUT_FLAG_MASK) | (lockout << LOCKOUT_FLAG_POSITION);
+}
+
+void Clcw::setWaitFlag(bool waitFlag) {
+	content.flags = (content.flags & WAIT_FLAG_MASK) | (waitFlag << WAIT_FLAG_POSITION);
+}
+
+void Clcw::setRetransmitFlag(bool retransmitFlag) {
+	content.flags = (content.flags & RETRANSMIT_FLAG_MASK) | (retransmitFlag << RETRANSMIT_FLAG_POSITION);
+}
+
+void Clcw::setFarmBCount(uint8_t count) {
+	content.flags = (content.flags & FARM_B_COUNT_MASK) | ((count & 0x03) << 1);
+}
+
+void Clcw::setReceiverFrameSequenceNumber(uint8_t vR) {
+	content.vRValue = vR;
+}
+
+uint32_t Clcw::getAsWhole() {
+	return content.raw;
+}
+
+void Clcw::setRFAvailable(bool rfAvailable) {
+	content.flags = (content.flags & NO_RF_AVIALABLE_MASK) | (!rfAvailable << NO_RF_AVIALABLE_POSITION);
+}
+
+void Clcw::setBitLock(bool bitLock) {
+	content.flags = (content.flags & NO_BIT_LOCK_MASK) | (!bitLock << NO_BIT_LOCK_POSITION);
+}
+
+void Clcw::print() {
+	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
+}
+
+void Clcw::setWhole(uint32_t rawClcw) {
+	content.raw = rawClcw;
+}
diff --git a/datalinklayer/Clcw.h b/datalinklayer/Clcw.h
index f19f37b66..72ccd77ac 100644
--- a/datalinklayer/Clcw.h
+++ b/datalinklayer/Clcw.h
@@ -1,66 +1,66 @@
-/**
- * @file	Clcw.h
- * @brief	This file defines the Clcw class.
- * @date	17.04.2013
- * @author	baetz
- */
-
-#ifndef CLCW_H_
-#define CLCW_H_
-
-#include <framework/datalinklayer/ClcwIF.h>
-/**
- * Small helper method to handle the Clcw values.
- * It has a content struct that manages the register and can be set externally.
- * @ingroup ccsds_handling
- */
-class Clcw : public ClcwIF {
-private:
-	static const uint8_t STATUS_FIELD_DEFAULT = 0b00000001; //!< Default for the status field.
-	static const uint8_t NO_RF_AVIALABLE_POSITION = 7;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t NO_BIT_LOCK_POSITION = 6;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t LOCKOUT_FLAG_POSITION = 5;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t WAIT_FLAG_POSITION = 4;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t RETRANSMIT_FLAG_POSITION = 3;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t NO_RF_AVIALABLE_MASK = 0xFF xor (1 << NO_RF_AVIALABLE_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t NO_BIT_LOCK_MASK = 0xFF xor (1 << NO_BIT_LOCK_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t LOCKOUT_FLAG_MASK = 0xFF xor (1 << LOCKOUT_FLAG_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t WAIT_FLAG_MASK = 0xFF xor (1 << WAIT_FLAG_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t RETRANSMIT_FLAG_MASK = 0xFF xor (1 << RETRANSMIT_FLAG_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t FARM_B_COUNT_MASK = 0b11111001;	//!< Mask for a counter in the register.
-	/**
-	 * This is the data structure of the CLCW register.
-	 */
-	union clcwContent {
-		uint32_t raw;
-		struct {
-			uint8_t status;
-			uint8_t virtualChannelIdSpare;
-			uint8_t flags;
-			uint8_t vRValue;
-		};
-	};
-	clcwContent content;	//!< Represents the content of the register.
-public:
-	/**
-	 * The constructor sets everything to default values.
-	 */
-	Clcw();
-	/**
-	 * Nothing happens in the destructor.
-	 */
-	~Clcw();
-	void setVirtualChannel( uint8_t setChannel );
-	void setLockoutFlag( bool lockout );
-	void setWaitFlag( bool waitFlag );
-	void setRetransmitFlag( bool retransmitFlag );
-	void setFarmBCount( uint8_t count );
-	void setReceiverFrameSequenceNumber( uint8_t vR );
-	void setRFAvailable( bool rfAvailable );
-	void setBitLock( bool bitLock );
-	uint32_t getAsWhole();
-	void setWhole( uint32_t rawClcw );
-	void print();
-};
-
-#endif /* CLCW_H_ */
+/**
+ * @file	Clcw.h
+ * @brief	This file defines the Clcw class.
+ * @date	17.04.2013
+ * @author	baetz
+ */
+
+#ifndef CLCW_H_
+#define CLCW_H_
+
+#include "../datalinklayer/ClcwIF.h"
+/**
+ * Small helper method to handle the Clcw values.
+ * It has a content struct that manages the register and can be set externally.
+ * @ingroup ccsds_handling
+ */
+class Clcw : public ClcwIF {
+private:
+	static const uint8_t STATUS_FIELD_DEFAULT = 0b00000001; //!< Default for the status field.
+	static const uint8_t NO_RF_AVIALABLE_POSITION = 7;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t NO_BIT_LOCK_POSITION = 6;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t LOCKOUT_FLAG_POSITION = 5;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t WAIT_FLAG_POSITION = 4;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t RETRANSMIT_FLAG_POSITION = 3;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t NO_RF_AVIALABLE_MASK = 0xFF xor (1 << NO_RF_AVIALABLE_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t NO_BIT_LOCK_MASK = 0xFF xor (1 << NO_BIT_LOCK_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t LOCKOUT_FLAG_MASK = 0xFF xor (1 << LOCKOUT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t WAIT_FLAG_MASK = 0xFF xor (1 << WAIT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t RETRANSMIT_FLAG_MASK = 0xFF xor (1 << RETRANSMIT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t FARM_B_COUNT_MASK = 0b11111001;	//!< Mask for a counter in the register.
+	/**
+	 * This is the data structure of the CLCW register.
+	 */
+	union clcwContent {
+		uint32_t raw;
+		struct {
+			uint8_t status;
+			uint8_t virtualChannelIdSpare;
+			uint8_t flags;
+			uint8_t vRValue;
+		};
+	};
+	clcwContent content;	//!< Represents the content of the register.
+public:
+	/**
+	 * The constructor sets everything to default values.
+	 */
+	Clcw();
+	/**
+	 * Nothing happens in the destructor.
+	 */
+	~Clcw();
+	void setVirtualChannel( uint8_t setChannel );
+	void setLockoutFlag( bool lockout );
+	void setWaitFlag( bool waitFlag );
+	void setRetransmitFlag( bool retransmitFlag );
+	void setFarmBCount( uint8_t count );
+	void setReceiverFrameSequenceNumber( uint8_t vR );
+	void setRFAvailable( bool rfAvailable );
+	void setBitLock( bool bitLock );
+	uint32_t getAsWhole();
+	void setWhole( uint32_t rawClcw );
+	void print();
+};
+
+#endif /* CLCW_H_ */
diff --git a/datalinklayer/DataLinkLayer.cpp b/datalinklayer/DataLinkLayer.cpp
index 4ca7f2705..83fe1e612 100644
--- a/datalinklayer/DataLinkLayer.cpp
+++ b/datalinklayer/DataLinkLayer.cpp
@@ -1,139 +1,139 @@
-#include <framework/datalinklayer/DataLinkLayer.h>
-#include <framework/globalfunctions/CRC.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-DataLinkLayer::DataLinkLayer(uint8_t* set_frame_buffer, ClcwIF* setClcw,
-		uint8_t set_start_sequence_length, uint16_t set_scid) :
-		spacecraftId(set_scid), frameBuffer(set_frame_buffer), clcw(setClcw), receivedDataLength(0), currentFrame(
-				NULL), startSequenceLength(set_start_sequence_length) {
-	//Nothing to do except from setting the values above.
-}
-
-DataLinkLayer::~DataLinkLayer() {
-
-}
-
-ReturnValue_t DataLinkLayer::frameDelimitingAndFillRemoval() {
-	if ((receivedDataLength - startSequenceLength) < FRAME_PRIMARY_HEADER_LENGTH) {
-		return SHORTER_THAN_HEADER;
-	}
-	//Removing start sequence.
-	//SHOULDDO: Not implemented here.
-	while ( *frameBuffer == START_SEQUENCE_PATTERN ) {
-		frameBuffer++;
-	}
-	TcTransferFrame frame_candidate(frameBuffer);
-	this->currentFrame = frame_candidate; //should work with shallow copy.
-
-	return RETURN_OK;
-}
-
-ReturnValue_t DataLinkLayer::frameValidationCheck() {
-	//Check TF_version number
-	if (this->currentFrame.getVersionNumber() != FRAME_VERSION_NUMBER_DEFAULT) {
-		return WRONG_TF_VERSION;
-	}
-	//Check SpaceCraft ID
-	if (this->currentFrame.getSpacecraftId() != this->spacecraftId) {
-		return WRONG_SPACECRAFT_ID;
-	}
-	//Check other header limitations:
-	if (!this->currentFrame.bypassFlagSet() && this->currentFrame.controlCommandFlagSet()) {
-		return NO_VALID_FRAME_TYPE;
-	}
-	//- Spares are zero
-	if (!this->currentFrame.spareIsZero()) {
-		return NO_VALID_FRAME_TYPE;
-	}
-	//Compare detected frame length with the one in the header
-	uint16_t length = currentFrame.getFullSize();
-	if (length > receivedDataLength) {
-		//Frame is too long or just right
-//		error << "frameValidationCheck: Too short.";
-//		currentFrame.print();
-		return TOO_SHORT;
-	}
-	if (USE_CRC) {
-		return this->frameCheckCRC();
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t DataLinkLayer::frameCheckCRC() {
-	uint16_t checkValue = CRC::crc16ccitt(this->currentFrame.getFullFrame(),
-			this->currentFrame.getFullSize());
-	if (checkValue == 0) {
-		return RETURN_OK;
-	} else {
-		return CRC_FAILED;
-	}
-
-}
-
-ReturnValue_t DataLinkLayer::allFramesReception() {
-	ReturnValue_t status = this->frameDelimitingAndFillRemoval();
-	if (status != RETURN_OK) {
-		return status;
-	}
-	return this->frameValidationCheck();
-}
-
-ReturnValue_t DataLinkLayer::masterChannelDemultiplexing() {
-	//Nothing to do at present. Ideally, there would be a map of MCID's identifying which MC to use.
-	return virtualChannelDemultiplexing();
-}
-
-ReturnValue_t DataLinkLayer::virtualChannelDemultiplexing() {
-	uint8_t vcId = currentFrame.getVirtualChannelId();
-	virtualChannelIterator iter = virtualChannels.find(vcId);
-	if (iter == virtualChannels.end()) {
-		//Do not report because passive board will get this error all the time.
-		return RETURN_OK;
-	} else {
-		return (iter->second)->frameAcceptanceAndReportingMechanism(&currentFrame, clcw);
-	}
-}
-
-ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
-	receivedDataLength = length;
-	ReturnValue_t status = allFramesReception();
-	if (status != RETURN_OK) {
-		sif::error << "DataLinkLayer::processFrame: frame reception failed. "
-		         "Error code: " << std::hex << status << std::dec << std::endl;
-//		currentFrame.print();
-		return status;
-	} else {
-		return masterChannelDemultiplexing();
-	}
-}
-
-ReturnValue_t DataLinkLayer::addVirtualChannel(uint8_t virtualChannelId,
-		VirtualChannelReceptionIF* object) {
-	std::pair<virtualChannelIterator, bool> returnValue = virtualChannels.insert(
-			std::pair<uint8_t, VirtualChannelReceptionIF*>(virtualChannelId, object));
-	if (returnValue.second == true) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t DataLinkLayer::initialize() {
-	ReturnValue_t returnValue = RETURN_FAILED;
-	//Set Virtual Channel ID to first virtual channel instance in this DataLinkLayer instance to avoid faulty information (e.g. 0) in the VCID.
-	if ( virtualChannels.begin() != virtualChannels.end() ) {
-		clcw->setVirtualChannel( virtualChannels.begin()->second->getChannelId() );
-	} else {
-		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
-		return RETURN_FAILED;
-	}
-
-	for (virtualChannelIterator iterator = virtualChannels.begin();
-			iterator != virtualChannels.end(); iterator++) {
-		returnValue = iterator->second->initialize();
-		if (returnValue != RETURN_OK)
-			break;
-	}
-	return returnValue;
-
-}
+#include "../datalinklayer/DataLinkLayer.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+DataLinkLayer::DataLinkLayer(uint8_t* set_frame_buffer, ClcwIF* setClcw,
+		uint8_t set_start_sequence_length, uint16_t set_scid) :
+		spacecraftId(set_scid), frameBuffer(set_frame_buffer), clcw(setClcw), receivedDataLength(0), currentFrame(
+				NULL), startSequenceLength(set_start_sequence_length) {
+	//Nothing to do except from setting the values above.
+}
+
+DataLinkLayer::~DataLinkLayer() {
+
+}
+
+ReturnValue_t DataLinkLayer::frameDelimitingAndFillRemoval() {
+	if ((receivedDataLength - startSequenceLength) < FRAME_PRIMARY_HEADER_LENGTH) {
+		return SHORTER_THAN_HEADER;
+	}
+	//Removing start sequence.
+	//SHOULDDO: Not implemented here.
+	while ( *frameBuffer == START_SEQUENCE_PATTERN ) {
+		frameBuffer++;
+	}
+	TcTransferFrame frame_candidate(frameBuffer);
+	this->currentFrame = frame_candidate; //should work with shallow copy.
+
+	return RETURN_OK;
+}
+
+ReturnValue_t DataLinkLayer::frameValidationCheck() {
+	//Check TF_version number
+	if (this->currentFrame.getVersionNumber() != FRAME_VERSION_NUMBER_DEFAULT) {
+		return WRONG_TF_VERSION;
+	}
+	//Check SpaceCraft ID
+	if (this->currentFrame.getSpacecraftId() != this->spacecraftId) {
+		return WRONG_SPACECRAFT_ID;
+	}
+	//Check other header limitations:
+	if (!this->currentFrame.bypassFlagSet() && this->currentFrame.controlCommandFlagSet()) {
+		return NO_VALID_FRAME_TYPE;
+	}
+	//- Spares are zero
+	if (!this->currentFrame.spareIsZero()) {
+		return NO_VALID_FRAME_TYPE;
+	}
+	//Compare detected frame length with the one in the header
+	uint16_t length = currentFrame.getFullSize();
+	if (length > receivedDataLength) {
+		//Frame is too long or just right
+//		error << "frameValidationCheck: Too short.";
+//		currentFrame.print();
+		return TOO_SHORT;
+	}
+	if (USE_CRC) {
+		return this->frameCheckCRC();
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t DataLinkLayer::frameCheckCRC() {
+	uint16_t checkValue = CRC::crc16ccitt(this->currentFrame.getFullFrame(),
+			this->currentFrame.getFullSize());
+	if (checkValue == 0) {
+		return RETURN_OK;
+	} else {
+		return CRC_FAILED;
+	}
+
+}
+
+ReturnValue_t DataLinkLayer::allFramesReception() {
+	ReturnValue_t status = this->frameDelimitingAndFillRemoval();
+	if (status != RETURN_OK) {
+		return status;
+	}
+	return this->frameValidationCheck();
+}
+
+ReturnValue_t DataLinkLayer::masterChannelDemultiplexing() {
+	//Nothing to do at present. Ideally, there would be a map of MCID's identifying which MC to use.
+	return virtualChannelDemultiplexing();
+}
+
+ReturnValue_t DataLinkLayer::virtualChannelDemultiplexing() {
+	uint8_t vcId = currentFrame.getVirtualChannelId();
+	virtualChannelIterator iter = virtualChannels.find(vcId);
+	if (iter == virtualChannels.end()) {
+		//Do not report because passive board will get this error all the time.
+		return RETURN_OK;
+	} else {
+		return (iter->second)->frameAcceptanceAndReportingMechanism(&currentFrame, clcw);
+	}
+}
+
+ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
+	receivedDataLength = length;
+	ReturnValue_t status = allFramesReception();
+	if (status != RETURN_OK) {
+		sif::error << "DataLinkLayer::processFrame: frame reception failed. "
+		         "Error code: " << std::hex << status << std::dec << std::endl;
+//		currentFrame.print();
+		return status;
+	} else {
+		return masterChannelDemultiplexing();
+	}
+}
+
+ReturnValue_t DataLinkLayer::addVirtualChannel(uint8_t virtualChannelId,
+		VirtualChannelReceptionIF* object) {
+	std::pair<virtualChannelIterator, bool> returnValue = virtualChannels.insert(
+			std::pair<uint8_t, VirtualChannelReceptionIF*>(virtualChannelId, object));
+	if (returnValue.second == true) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t DataLinkLayer::initialize() {
+	ReturnValue_t returnValue = RETURN_FAILED;
+	//Set Virtual Channel ID to first virtual channel instance in this DataLinkLayer instance to avoid faulty information (e.g. 0) in the VCID.
+	if ( virtualChannels.begin() != virtualChannels.end() ) {
+		clcw->setVirtualChannel( virtualChannels.begin()->second->getChannelId() );
+	} else {
+		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
+		return RETURN_FAILED;
+	}
+
+	for (virtualChannelIterator iterator = virtualChannels.begin();
+			iterator != virtualChannels.end(); iterator++) {
+		returnValue = iterator->second->initialize();
+		if (returnValue != RETURN_OK)
+			break;
+	}
+	return returnValue;
+
+}
diff --git a/datalinklayer/DataLinkLayer.h b/datalinklayer/DataLinkLayer.h
index 8a3bb8e5a..cf5cf42e5 100644
--- a/datalinklayer/DataLinkLayer.h
+++ b/datalinklayer/DataLinkLayer.h
@@ -1,112 +1,112 @@
-#ifndef DATALINKLAYER_H_
-#define DATALINKLAYER_H_
-
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/datalinklayer/VirtualChannelReceptionIF.h>
-#include <framework/events/Event.h>
-#include <map>
-
-
-class VirtualChannelReception;
-/**
- * A complete representation of the CCSDS Data Link Layer.
- * The operations of this layer are defined in the CCSDS TC Space Data Link Protocol
- * document. It is configured to handle a VC Demultiplexing function. All reception
- * steps are performed.
- */
-class DataLinkLayer : public CCSDSReturnValuesIF {
-public:
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_1;
-	static const Event RF_AVAILABLE = MAKE_EVENT(0, SEVERITY::INFO); //!< A RF available signal was detected. P1: raw RFA state, P2: 0
-	static const Event RF_LOST = MAKE_EVENT(1, SEVERITY::INFO); //!< A previously found RF available signal was lost. P1: raw RFA state, P2: 0
-	static const Event BIT_LOCK = MAKE_EVENT(2, SEVERITY::INFO); //!< A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0
-	static const Event BIT_LOCK_LOST = MAKE_EVENT(3, SEVERITY::INFO); //!< A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
-//	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, SEVERITY::INFO); //!< The CCSDS Board detected that either bit lock or RF available or both are lost. No parameters.
-	static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< The CCSDS Board could not interpret a TC
-	/**
-	 * The Constructor sets the passed parameters and nothing else.
-	 * @param set_frame_buffer The buffer in which incoming frame candidates are stored.
-	 * @param setClcw	The CLCW class to work on when returning CLCW information.
-	 * @param set_start_sequence_length	Length of the Start sequence in front of every TC Transfer Frame.
-	 * @param set_scid	The SCID to operate on.
-	 */
-	DataLinkLayer( uint8_t* set_frame_buffer, ClcwIF* setClcw, uint8_t set_start_sequence_length, uint16_t set_scid );
-	/**
-	 * Empty virtual destructor.
-	 */
-	~DataLinkLayer();
-	/**
-	 * This method tries to process a frame that is placed in #frameBuffer.
-	 * The procedures described in the Standard are performed.
-	 * @param length	Length of the incoming frame candidate.
-	 * @return	@c RETURN_OK on successful handling, otherwise the return codes of the higher methods.
-	 */
-	ReturnValue_t processFrame( uint16_t length );
-	/**
-	 * Configuration method to add a new TC Virtual Channel.
-	 * Shall only be called during initialization. As soon as the method was called, the layer can
-	 * handle Frames directed to this VC.
-	 * @param virtualChannelId	Id of the VC. Shall be smaller than 64.
-	 * @param object	Reference to the object that handles the Frame.
-	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t addVirtualChannel( uint8_t virtualChannelId, VirtualChannelReceptionIF* object );
-	/**
-	 * The initialization method calls the @c initialize routine of all virtual channels.
-	 * @return The return code of the first failed VC initialization or @c RETURN_OK.
-	 */
-	ReturnValue_t initialize();
-private:
-	typedef std::map<uint8_t, VirtualChannelReceptionIF*>::iterator virtualChannelIterator; //!< Typedef to simplify handling the #virtualChannels map.
-	static const uint8_t FRAME_VERSION_NUMBER_DEFAULT = 0x00;	//!< Constant for the default value of Frame Version Numbers.
-	static const uint8_t FRAME_PRIMARY_HEADER_LENGTH = 5;	//!< Length of the frame's primary header.
-	static const uint8_t START_SEQUENCE_PATTERN = 0x00; //!< The start sequence pattern which might be with the frame.
-	static const bool USE_CRC = true;	//!< A global, so called "Managed Parameter" that identifies if incoming frames have CRC's or not.
-	uint16_t spacecraftId;	//!< The Space Craft Identifier (SCID) configured.
-	uint8_t* frameBuffer;	//!< A pointer to point to the current incoming frame.
-	ClcwIF* clcw;	//!< Pointer to store the CLCW to work on.
-	uint16_t receivedDataLength;	//!< Stores the length of the currently processed frame.
-	TcTransferFrame currentFrame;	//!< Stores a more convenient access to the current frame.
-	uint8_t startSequenceLength;	//!< Configured length of the start sequence. Maybe this must be done more variable.
-	std::map<uint8_t, VirtualChannelReceptionIF*> virtualChannels;	//!< Map of all virtual channels assigned.
-	/**
-	 * Method that performs all possible frame validity checks (as specified).
-	 * @return	Various error codes or @c RETURN_OK on success.
-	 */
-	ReturnValue_t frameValidationCheck();
-	/**
-	 * First method to call.
-	 * Removes start sequence bytes and checks if the complete frame was received.
-	 * SHOULDDO: Maybe handling the start sequence must be done more variable.
-	 * @return @c RETURN_OK or @c TOO_SHORT.
-	 */
-	ReturnValue_t frameDelimitingAndFillRemoval();
-	/**
-	 * Small helper method to check the CRC of the Frame.
-	 * @return @c RETURN_OK or @c CRC_FAILED.
-	 */
-	ReturnValue_t frameCheckCRC();
-	/**
-	 * Method that groups the reception process of all Frames.
-	 * Calls #frameDelimitingAndFillRemoval and #frameValidationCheck.
-	 * @return The return codes of the sub calls.
-	 */
-	ReturnValue_t allFramesReception();
-	/**
-	 * Dummy method for master channel demultiplexing.
-	 * As there's only one Master Channel here, the method calls #virtualChannelDemultiplexing.
-	 * @return	The return codes of #virtualChannelDemultiplexing.
-	 */
-	ReturnValue_t masterChannelDemultiplexing();
-	/**
-	 * Method to demultiplex the Frames to Virtual Channels (VC's).
-	 * Looks up the requested VC in #virtualChannels and forwards the Frame to its
-	 * #frameAcceptanceAndReportingMechanism method, if found.
-	 * @return The higher method codes or @c VC_NOT_FOUND.
-	 */
-	ReturnValue_t virtualChannelDemultiplexing();
-};
-
-#endif /* DATALINKLAYER_H_ */
+#ifndef DATALINKLAYER_H_
+#define DATALINKLAYER_H_
+
+#include "../datalinklayer/CCSDSReturnValuesIF.h"
+#include "../datalinklayer/ClcwIF.h"
+#include "../datalinklayer/TcTransferFrame.h"
+#include "../datalinklayer/VirtualChannelReceptionIF.h"
+#include "../events/Event.h"
+#include <map>
+
+
+class VirtualChannelReception;
+/**
+ * A complete representation of the CCSDS Data Link Layer.
+ * The operations of this layer are defined in the CCSDS TC Space Data Link Protocol
+ * document. It is configured to handle a VC Demultiplexing function. All reception
+ * steps are performed.
+ */
+class DataLinkLayer : public CCSDSReturnValuesIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_1;
+	static const Event RF_AVAILABLE = MAKE_EVENT(0, SEVERITY::INFO); //!< A RF available signal was detected. P1: raw RFA state, P2: 0
+	static const Event RF_LOST = MAKE_EVENT(1, SEVERITY::INFO); //!< A previously found RF available signal was lost. P1: raw RFA state, P2: 0
+	static const Event BIT_LOCK = MAKE_EVENT(2, SEVERITY::INFO); //!< A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0
+	static const Event BIT_LOCK_LOST = MAKE_EVENT(3, SEVERITY::INFO); //!< A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
+//	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, SEVERITY::INFO); //!< The CCSDS Board detected that either bit lock or RF available or both are lost. No parameters.
+	static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< The CCSDS Board could not interpret a TC
+	/**
+	 * The Constructor sets the passed parameters and nothing else.
+	 * @param set_frame_buffer The buffer in which incoming frame candidates are stored.
+	 * @param setClcw	The CLCW class to work on when returning CLCW information.
+	 * @param set_start_sequence_length	Length of the Start sequence in front of every TC Transfer Frame.
+	 * @param set_scid	The SCID to operate on.
+	 */
+	DataLinkLayer( uint8_t* set_frame_buffer, ClcwIF* setClcw, uint8_t set_start_sequence_length, uint16_t set_scid );
+	/**
+	 * Empty virtual destructor.
+	 */
+	~DataLinkLayer();
+	/**
+	 * This method tries to process a frame that is placed in #frameBuffer.
+	 * The procedures described in the Standard are performed.
+	 * @param length	Length of the incoming frame candidate.
+	 * @return	@c RETURN_OK on successful handling, otherwise the return codes of the higher methods.
+	 */
+	ReturnValue_t processFrame( uint16_t length );
+	/**
+	 * Configuration method to add a new TC Virtual Channel.
+	 * Shall only be called during initialization. As soon as the method was called, the layer can
+	 * handle Frames directed to this VC.
+	 * @param virtualChannelId	Id of the VC. Shall be smaller than 64.
+	 * @param object	Reference to the object that handles the Frame.
+	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t addVirtualChannel( uint8_t virtualChannelId, VirtualChannelReceptionIF* object );
+	/**
+	 * The initialization method calls the @c initialize routine of all virtual channels.
+	 * @return The return code of the first failed VC initialization or @c RETURN_OK.
+	 */
+	ReturnValue_t initialize();
+private:
+	typedef std::map<uint8_t, VirtualChannelReceptionIF*>::iterator virtualChannelIterator; //!< Typedef to simplify handling the #virtualChannels map.
+	static const uint8_t FRAME_VERSION_NUMBER_DEFAULT = 0x00;	//!< Constant for the default value of Frame Version Numbers.
+	static const uint8_t FRAME_PRIMARY_HEADER_LENGTH = 5;	//!< Length of the frame's primary header.
+	static const uint8_t START_SEQUENCE_PATTERN = 0x00; //!< The start sequence pattern which might be with the frame.
+	static const bool USE_CRC = true;	//!< A global, so called "Managed Parameter" that identifies if incoming frames have CRC's or not.
+	uint16_t spacecraftId;	//!< The Space Craft Identifier (SCID) configured.
+	uint8_t* frameBuffer;	//!< A pointer to point to the current incoming frame.
+	ClcwIF* clcw;	//!< Pointer to store the CLCW to work on.
+	uint16_t receivedDataLength;	//!< Stores the length of the currently processed frame.
+	TcTransferFrame currentFrame;	//!< Stores a more convenient access to the current frame.
+	uint8_t startSequenceLength;	//!< Configured length of the start sequence. Maybe this must be done more variable.
+	std::map<uint8_t, VirtualChannelReceptionIF*> virtualChannels;	//!< Map of all virtual channels assigned.
+	/**
+	 * Method that performs all possible frame validity checks (as specified).
+	 * @return	Various error codes or @c RETURN_OK on success.
+	 */
+	ReturnValue_t frameValidationCheck();
+	/**
+	 * First method to call.
+	 * Removes start sequence bytes and checks if the complete frame was received.
+	 * SHOULDDO: Maybe handling the start sequence must be done more variable.
+	 * @return @c RETURN_OK or @c TOO_SHORT.
+	 */
+	ReturnValue_t frameDelimitingAndFillRemoval();
+	/**
+	 * Small helper method to check the CRC of the Frame.
+	 * @return @c RETURN_OK or @c CRC_FAILED.
+	 */
+	ReturnValue_t frameCheckCRC();
+	/**
+	 * Method that groups the reception process of all Frames.
+	 * Calls #frameDelimitingAndFillRemoval and #frameValidationCheck.
+	 * @return The return codes of the sub calls.
+	 */
+	ReturnValue_t allFramesReception();
+	/**
+	 * Dummy method for master channel demultiplexing.
+	 * As there's only one Master Channel here, the method calls #virtualChannelDemultiplexing.
+	 * @return	The return codes of #virtualChannelDemultiplexing.
+	 */
+	ReturnValue_t masterChannelDemultiplexing();
+	/**
+	 * Method to demultiplex the Frames to Virtual Channels (VC's).
+	 * Looks up the requested VC in #virtualChannels and forwards the Frame to its
+	 * #frameAcceptanceAndReportingMechanism method, if found.
+	 * @return The higher method codes or @c VC_NOT_FOUND.
+	 */
+	ReturnValue_t virtualChannelDemultiplexing();
+};
+
+#endif /* DATALINKLAYER_H_ */
diff --git a/datalinklayer/Farm1StateIF.h b/datalinklayer/Farm1StateIF.h
index 25836e6a4..ef02d891e 100644
--- a/datalinklayer/Farm1StateIF.h
+++ b/datalinklayer/Farm1StateIF.h
@@ -1,54 +1,54 @@
-/**
- * @file	Farm1StateIF.h
- * @brief	This file defines the Farm1StateIF class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATEIF_H_
-#define FARM1STATEIF_H_
-
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
-class VirtualChannelReception;
-class TcTransferFrame;
-class ClcwIF;
-
-/**
- * This is the interface for states of the FARM-1 state machine.
- * Classes implementing this interface can be used as FARM-1 states. This is a simple implementation
- * of the state pattern.
- */
-class Farm1StateIF : public CCSDSReturnValuesIF {
-public:
-	/**
-	 * A method that shall handle an incoming frame as AD Frame.
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
-	 * 			Otherwise, an appropriate return value or error code shall be generated.
-	 */
-	virtual ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
-	/**
-	 * This method shall handle frames that have been successfully identified as BC Unlock frames.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
-	 * 			Otherwise, an appropriate return value or error code shall be generated.
-	 */
-	virtual ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw ) = 0;
-	/**
-	 * This method shall handle frames that have been successfully identified as BC Set VR frames.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
-	 * 			Otherwise, an appropriate return value or error code shall be generated.
-	 */
-	virtual ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) = 0;
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~Farm1StateIF() {
-
-	}
-};
-
-#endif /* FARM1STATEIF_H_ */
+/**
+ * @file	Farm1StateIF.h
+ * @brief	This file defines the Farm1StateIF class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEIF_H_
+#define FARM1STATEIF_H_
+
+#include "../datalinklayer/CCSDSReturnValuesIF.h"
+class VirtualChannelReception;
+class TcTransferFrame;
+class ClcwIF;
+
+/**
+ * This is the interface for states of the FARM-1 state machine.
+ * Classes implementing this interface can be used as FARM-1 states. This is a simple implementation
+ * of the state pattern.
+ */
+class Farm1StateIF : public CCSDSReturnValuesIF {
+public:
+	/**
+	 * A method that shall handle an incoming frame as AD Frame.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
+	/**
+	 * This method shall handle frames that have been successfully identified as BC Unlock frames.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw ) = 0;
+	/**
+	 * This method shall handle frames that have been successfully identified as BC Set VR frames.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) = 0;
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~Farm1StateIF() {
+
+	}
+};
+
+#endif /* FARM1STATEIF_H_ */
diff --git a/datalinklayer/Farm1StateLockout.cpp b/datalinklayer/Farm1StateLockout.cpp
index 45ae47f9b..f8dca9fdc 100644
--- a/datalinklayer/Farm1StateLockout.cpp
+++ b/datalinklayer/Farm1StateLockout.cpp
@@ -1,35 +1,35 @@
-/**
- * @file	Farm1StateLockout.cpp
- * @brief	This file defines the Farm1StateLockout class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-
-
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/Farm1StateLockout.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/datalinklayer/VirtualChannelReception.h>
-Farm1StateLockout::Farm1StateLockout(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
-}
-
-ReturnValue_t Farm1StateLockout::handleADFrame(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-	return FARM_IN_LOCKOUT;
-}
-
-ReturnValue_t Farm1StateLockout::handleBCUnlockCommand(ClcwIF* clcw) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	clcw->setLockoutFlag( false );
-	clcw->setWaitFlag( false );
-	myVC->currentState = &(myVC->openState);
-	return BC_IS_UNLOCK_COMMAND;
-}
-
-ReturnValue_t Farm1StateLockout::handleBCSetVrCommand(ClcwIF* clcw,
-		uint8_t vr) {
-	myVC->farmBCounter++;
-	return BC_IS_SET_VR_COMMAND;
-}
+/**
+ * @file	Farm1StateLockout.cpp
+ * @brief	This file defines the Farm1StateLockout class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+
+
+#include "../datalinklayer/ClcwIF.h"
+#include "../datalinklayer/Farm1StateLockout.h"
+#include "../datalinklayer/TcTransferFrame.h"
+#include "../datalinklayer/VirtualChannelReception.h"
+Farm1StateLockout::Farm1StateLockout(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
+}
+
+ReturnValue_t Farm1StateLockout::handleADFrame(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+	return FARM_IN_LOCKOUT;
+}
+
+ReturnValue_t Farm1StateLockout::handleBCUnlockCommand(ClcwIF* clcw) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	clcw->setLockoutFlag( false );
+	clcw->setWaitFlag( false );
+	myVC->currentState = &(myVC->openState);
+	return BC_IS_UNLOCK_COMMAND;
+}
+
+ReturnValue_t Farm1StateLockout::handleBCSetVrCommand(ClcwIF* clcw,
+		uint8_t vr) {
+	myVC->farmBCounter++;
+	return BC_IS_SET_VR_COMMAND;
+}
diff --git a/datalinklayer/Farm1StateLockout.h b/datalinklayer/Farm1StateLockout.h
index aac8ed74c..9e3713ccd 100644
--- a/datalinklayer/Farm1StateLockout.h
+++ b/datalinklayer/Farm1StateLockout.h
@@ -1,59 +1,59 @@
-/**
- * @file	Farm1StateLockout.h
- * @brief	This file defines the Farm1StateLockout class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATELOCKOUT_H_
-#define FARM1STATELOCKOUT_H_
-
-#include <framework/datalinklayer/Farm1StateIF.h>
-
-/**
- * This class represents the FARM-1 "Lockout" State.
- * The Lockout state is reached if the received Transfer Frame Sequence Number is completely wrong
- * (i.e. within the Lockout Window). No AD Frames are forwarded. To leave the State, a BC Unlock
- * command is required.
- */
-class Farm1StateLockout : public Farm1StateIF {
-private:
-	/**
-	 * This is a reference to the "owner" class the State works on.
-	 */
-	VirtualChannelReception* myVC;
-public:
-	/**
-	 * The default constructor if the State.
-	 * Sets the "owner" of the State.
-	 * @param setMyVC	The "owner" class.
-	 */
-	Farm1StateLockout( VirtualChannelReception* setMyVC );
-	/**
-	 * All AD Frames are rejected with FARM_IN_LOCKOUT
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return FARM_IN_LOCKOUT
-	 */
-	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State changes to Farm1StateOpen.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * The V(r) value is not set in Lockout State, even though the Command itself is accepted.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
-};
-
-
-#endif /* FARM1STATELOCKOUT_H_ */
+/**
+ * @file	Farm1StateLockout.h
+ * @brief	This file defines the Farm1StateLockout class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATELOCKOUT_H_
+#define FARM1STATELOCKOUT_H_
+
+#include "../datalinklayer/Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Lockout" State.
+ * The Lockout state is reached if the received Transfer Frame Sequence Number is completely wrong
+ * (i.e. within the Lockout Window). No AD Frames are forwarded. To leave the State, a BC Unlock
+ * command is required.
+ */
+class Farm1StateLockout : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateLockout( VirtualChannelReception* setMyVC );
+	/**
+	 * All AD Frames are rejected with FARM_IN_LOCKOUT
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return FARM_IN_LOCKOUT
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State changes to Farm1StateOpen.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * The V(r) value is not set in Lockout State, even though the Command itself is accepted.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATELOCKOUT_H_ */
diff --git a/datalinklayer/Farm1StateOpen.cpp b/datalinklayer/Farm1StateOpen.cpp
index b06cff48d..b7837013c 100644
--- a/datalinklayer/Farm1StateOpen.cpp
+++ b/datalinklayer/Farm1StateOpen.cpp
@@ -1,49 +1,49 @@
-/**
- * @file	Farm1StateOpen.cpp
- * @brief	This file defines the Farm1StateOpen class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-
-
-
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/Farm1StateOpen.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/datalinklayer/VirtualChannelReception.h>
-
-Farm1StateOpen::Farm1StateOpen(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
-}
-
-ReturnValue_t Farm1StateOpen::handleADFrame(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-	int8_t diff = frame->getSequenceNumber() - myVC->vR;
-	if (diff == 0 ) {
-		myVC->vR++;
-		clcw->setRetransmitFlag(false);
-		return RETURN_OK;
-	} else if (diff < myVC->positiveWindow && diff > 0 ) {
-		clcw->setRetransmitFlag(true);
-		return NS_POSITIVE_W;
-	} else if (diff < 0 && diff >= -myVC->negativeWindow) {
-		return NS_NEGATIVE_W;
-	} else {
-		clcw->setLockoutFlag(true);
-		myVC->currentState = &(myVC->lockoutState);
-		return NS_LOCKOUT;
-	}
-}
-
-ReturnValue_t Farm1StateOpen::handleBCUnlockCommand( ClcwIF* clcw ) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	return BC_IS_UNLOCK_COMMAND;
-}
-
-ReturnValue_t Farm1StateOpen::handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	myVC->vR = vr;
-	return BC_IS_SET_VR_COMMAND;
-}
+/**
+ * @file	Farm1StateOpen.cpp
+ * @brief	This file defines the Farm1StateOpen class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+
+
+
+#include "../datalinklayer/ClcwIF.h"
+#include "../datalinklayer/Farm1StateOpen.h"
+#include "../datalinklayer/TcTransferFrame.h"
+#include "../datalinklayer/VirtualChannelReception.h"
+
+Farm1StateOpen::Farm1StateOpen(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
+}
+
+ReturnValue_t Farm1StateOpen::handleADFrame(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+	int8_t diff = frame->getSequenceNumber() - myVC->vR;
+	if (diff == 0 ) {
+		myVC->vR++;
+		clcw->setRetransmitFlag(false);
+		return RETURN_OK;
+	} else if (diff < myVC->positiveWindow && diff > 0 ) {
+		clcw->setRetransmitFlag(true);
+		return NS_POSITIVE_W;
+	} else if (diff < 0 && diff >= -myVC->negativeWindow) {
+		return NS_NEGATIVE_W;
+	} else {
+		clcw->setLockoutFlag(true);
+		myVC->currentState = &(myVC->lockoutState);
+		return NS_LOCKOUT;
+	}
+}
+
+ReturnValue_t Farm1StateOpen::handleBCUnlockCommand( ClcwIF* clcw ) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	return BC_IS_UNLOCK_COMMAND;
+}
+
+ReturnValue_t Farm1StateOpen::handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	myVC->vR = vr;
+	return BC_IS_SET_VR_COMMAND;
+}
diff --git a/datalinklayer/Farm1StateOpen.h b/datalinklayer/Farm1StateOpen.h
index 09caacbbb..ebc3b333a 100644
--- a/datalinklayer/Farm1StateOpen.h
+++ b/datalinklayer/Farm1StateOpen.h
@@ -1,62 +1,62 @@
-/**
- * @file	Farm1StateOpen.h
- * @brief	This file defines the Farm1StateOpen class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATEOPEN_H_
-#define FARM1STATEOPEN_H_
-
-#include <framework/datalinklayer/Farm1StateIF.h>
-
-/**
- * This class represents the FARM-1 "Open" State.
- * The Open state is the state of normal operation. It handles all types of frames,
- * including AD Frames. If a wrong Frame Sequence Number is detected in an AD Frame, the
- * State reacts as specified.
- */
-class Farm1StateOpen : public Farm1StateIF {
-private:
-	/**
-	 * This is a reference to the "owner" class the State works on.
-	 */
-	VirtualChannelReception* myVC;
-public:
-	/**
-	 * The default constructor if the State.
-	 * Sets the "owner" of the State.
-	 * @param setMyVC	The "owner" class.
-	 */
-	Farm1StateOpen( VirtualChannelReception* setMyVC );
-	/**
-	 * Method to check the validity of AD Frames.
-	 * It checks the Frame Sequence Number and reacts as specified in the standard. The state may
-	 * change to Farm1StateLockout.
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return If the Sequence Number is ok, it returns #RETURN_OK. Otherwise either #NS_POSITIVE_W,
-	 * 			#NS_NEGATIVE_W or NS_LOCKOUT is returned.
-	 */
-	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State does not change.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State does not change.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
-};
-
-
-#endif /* FARM1STATEOPEN_H_ */
+/**
+ * @file	Farm1StateOpen.h
+ * @brief	This file defines the Farm1StateOpen class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEOPEN_H_
+#define FARM1STATEOPEN_H_
+
+#include "../datalinklayer/Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Open" State.
+ * The Open state is the state of normal operation. It handles all types of frames,
+ * including AD Frames. If a wrong Frame Sequence Number is detected in an AD Frame, the
+ * State reacts as specified.
+ */
+class Farm1StateOpen : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateOpen( VirtualChannelReception* setMyVC );
+	/**
+	 * Method to check the validity of AD Frames.
+	 * It checks the Frame Sequence Number and reacts as specified in the standard. The state may
+	 * change to Farm1StateLockout.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return If the Sequence Number is ok, it returns #RETURN_OK. Otherwise either #NS_POSITIVE_W,
+	 * 			#NS_NEGATIVE_W or NS_LOCKOUT is returned.
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State does not change.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State does not change.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATEOPEN_H_ */
diff --git a/datalinklayer/Farm1StateWait.cpp b/datalinklayer/Farm1StateWait.cpp
index 1c72e68f8..c3cc85de7 100644
--- a/datalinklayer/Farm1StateWait.cpp
+++ b/datalinklayer/Farm1StateWait.cpp
@@ -1,43 +1,43 @@
-/**
- * @file	Farm1StateWait.cpp
- * @brief	This file defines the Farm1StateWait class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/Farm1StateWait.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/datalinklayer/VirtualChannelReception.h>
-
-Farm1StateWait::Farm1StateWait(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
-}
-
-ReturnValue_t Farm1StateWait::handleADFrame(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-
-	int8_t diff = frame->getSequenceNumber() - myVC->vR;
-	if ( diff < -myVC->negativeWindow || diff >= myVC->positiveWindow ) {
-		clcw->setLockoutFlag(true);
-		myVC->currentState = &(myVC->lockoutState);
-	}
-	return FARM_IN_WAIT;
-}
-
-ReturnValue_t Farm1StateWait::handleBCUnlockCommand(ClcwIF* clcw) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	clcw->setWaitFlag( false );
-	myVC->currentState = &(myVC->openState);
-	return BC_IS_UNLOCK_COMMAND;
-}
-
-ReturnValue_t Farm1StateWait::handleBCSetVrCommand(ClcwIF* clcw, uint8_t vr) {
-	myVC->farmBCounter++;
-	clcw->setWaitFlag( false );
-	clcw->setRetransmitFlag(false);
-	myVC->vR = vr;
-	myVC->currentState = &(myVC->openState);
-	return BC_IS_SET_VR_COMMAND;
-}
+/**
+ * @file	Farm1StateWait.cpp
+ * @brief	This file defines the Farm1StateWait class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+
+#include "../datalinklayer/ClcwIF.h"
+#include "../datalinklayer/Farm1StateWait.h"
+#include "../datalinklayer/TcTransferFrame.h"
+#include "../datalinklayer/VirtualChannelReception.h"
+
+Farm1StateWait::Farm1StateWait(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
+}
+
+ReturnValue_t Farm1StateWait::handleADFrame(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+
+	int8_t diff = frame->getSequenceNumber() - myVC->vR;
+	if ( diff < -myVC->negativeWindow || diff >= myVC->positiveWindow ) {
+		clcw->setLockoutFlag(true);
+		myVC->currentState = &(myVC->lockoutState);
+	}
+	return FARM_IN_WAIT;
+}
+
+ReturnValue_t Farm1StateWait::handleBCUnlockCommand(ClcwIF* clcw) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	clcw->setWaitFlag( false );
+	myVC->currentState = &(myVC->openState);
+	return BC_IS_UNLOCK_COMMAND;
+}
+
+ReturnValue_t Farm1StateWait::handleBCSetVrCommand(ClcwIF* clcw, uint8_t vr) {
+	myVC->farmBCounter++;
+	clcw->setWaitFlag( false );
+	clcw->setRetransmitFlag(false);
+	myVC->vR = vr;
+	myVC->currentState = &(myVC->openState);
+	return BC_IS_SET_VR_COMMAND;
+}
diff --git a/datalinklayer/Farm1StateWait.h b/datalinklayer/Farm1StateWait.h
index f12017912..aa4566642 100644
--- a/datalinklayer/Farm1StateWait.h
+++ b/datalinklayer/Farm1StateWait.h
@@ -1,58 +1,58 @@
-/**
- * @file	Farm1StateWait.h
- * @brief	This file defines the Farm1StateWait class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATEWAIT_H_
-#define FARM1STATEWAIT_H_
-
-#include <framework/datalinklayer/Farm1StateIF.h>
-
-/**
- * This class represents the FARM-1 "Wait" State.
- * The Wait state is reached if higher level procedures inform the FARM-1 Machine to wait
- * for a certain period. Currently, it is not in use.
- */
-class Farm1StateWait : public Farm1StateIF {
-private:
-	/**
-	 * This is a reference to the "owner" class the State works on.
-	 */
-	VirtualChannelReception* myVC;
-public:
-	/**
-	 * The default constructor if the State.
-	 * Sets the "owner" of the State.
-	 * @param setMyVC	The "owner" class.
-	 */
-	Farm1StateWait( VirtualChannelReception* setMyVC );
-	/**
-	 * AD Frames are always discarded.
-	 * If the frame number is in the lockout window, the state changes to Farm1StateLockout.
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	Always returns FARM_IN_WAIT.
-	 */
-	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State changes to Farm1StateOpen.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
-};
-
-
-#endif /* FARM1STATEWAIT_H_ */
+/**
+ * @file	Farm1StateWait.h
+ * @brief	This file defines the Farm1StateWait class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEWAIT_H_
+#define FARM1STATEWAIT_H_
+
+#include "../datalinklayer/Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Wait" State.
+ * The Wait state is reached if higher level procedures inform the FARM-1 Machine to wait
+ * for a certain period. Currently, it is not in use.
+ */
+class Farm1StateWait : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateWait( VirtualChannelReception* setMyVC );
+	/**
+	 * AD Frames are always discarded.
+	 * If the frame number is in the lockout window, the state changes to Farm1StateLockout.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	Always returns FARM_IN_WAIT.
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State changes to Farm1StateOpen.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATEWAIT_H_ */
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 4ea45e89c..a14bcefeb 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -1,154 +1,154 @@
-/**
- * @file	MapPacketExtraction.cpp
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
-#include <framework/datalinklayer/MapPacketExtraction.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tmtcpacket/SpacePacketBase.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <string.h>
-
-MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
-		object_id_t setPacketDestination) :
-		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
-		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
-		packetStore(nullptr), tcQueueId(MessageQueueMessageIF::NO_QUEUE) {
-	memset(packetBuffer, 0, sizeof(packetBuffer));
-}
-
-ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
-	uint8_t segmentationFlag = frame->getSequenceFlags();
-	ReturnValue_t status = TOO_SHORT_MAP_EXTRACTION;
-	switch (segmentationFlag) {
-	case NO_SEGMENTATION:
-		status = unpackBlockingPackets(frame);
-		break;
-	case FIRST_PORTION:
-		packetLength = frame->getDataLength();
-		if (packetLength <= MAX_PACKET_SIZE) {
-			memcpy(packetBuffer, frame->getDataField(), packetLength);
-			bufferPosition = &packetBuffer[packetLength];
-			status = RETURN_OK;
-		} else {
-			sif::error
-					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
-					<< packetLength << std::endl;
-			clearBuffers();
-			status = CONTENT_TOO_LARGE;
-		}
-		break;
-	case CONTINUING_PORTION:
-	case LAST_PORTION:
-		if (lastSegmentationFlag == FIRST_PORTION
-				|| lastSegmentationFlag == CONTINUING_PORTION) {
-			packetLength += frame->getDataLength();
-			if (packetLength <= MAX_PACKET_SIZE) {
-				memcpy(bufferPosition, frame->getDataField(),
-						frame->getDataLength());
-				bufferPosition = &packetBuffer[packetLength];
-				if (segmentationFlag == LAST_PORTION) {
-					status = sendCompletePacket(packetBuffer, packetLength);
-					clearBuffers();
-				}
-				status = RETURN_OK;
-			} else {
-				sif::error
-						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
-						<< packetLength << std::endl;
-				clearBuffers();
-				status = CONTENT_TOO_LARGE;
-			}
-		} else {
-			sif::error
-					<< "MapPacketExtraction::extractPackets. Illegal segment! Last flag: "
-					<< (int) lastSegmentationFlag << std::endl;
-			clearBuffers();
-			status = ILLEGAL_SEGMENTATION_FLAG;
-		}
-		break;
-	default:
-		sif::error
-				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
-				<< (int) segmentationFlag << std::endl;
-		clearBuffers();
-		status = DATA_CORRUPTED;
-		break;
-	}
-	lastSegmentationFlag = segmentationFlag;
-	return status;
-}
-
-ReturnValue_t MapPacketExtraction::unpackBlockingPackets(
-		TcTransferFrame* frame) {
-	ReturnValue_t status = TOO_SHORT_BLOCKED_PACKET;
-	uint32_t totalLength = frame->getDataLength();
-	if (totalLength > MAX_PACKET_SIZE)
-		return CONTENT_TOO_LARGE;
-	uint8_t* position = frame->getDataField();
-	while ((totalLength > SpacePacketBase::MINIMUM_SIZE)) {
-		SpacePacketBase packet(position);
-		uint32_t packetSize = packet.getFullSize();
-		if (packetSize <= totalLength) {
-			status = sendCompletePacket(packet.getWholeData(),
-					packet.getFullSize());
-			totalLength -= packet.getFullSize();
-			position += packet.getFullSize();
-			status = RETURN_OK;
-		} else {
-			status = DATA_CORRUPTED;
-			totalLength = 0;
-		}
-	}
-	if (totalLength > 0) {
-		status = RESIDUAL_DATA;
-	}
-	return status;
-}
-
-ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data,
-		uint32_t size) {
-	store_address_t store_id;
-	ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
-	if (status == RETURN_OK) {
-		TmTcMessage message(store_id);
-		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message);
-	}
-	return status;
-}
-
-void MapPacketExtraction::clearBuffers() {
-	memset(packetBuffer, 0, sizeof(packetBuffer));
-	bufferPosition = packetBuffer;
-	packetLength = 0;
-	lastSegmentationFlag = NO_SEGMENTATION;
-}
-
-ReturnValue_t MapPacketExtraction::initialize() {
-	packetStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-	AcceptsTelecommandsIF* distributor = objectManager->get<
-			AcceptsTelecommandsIF>(packetDestination);
-	if ((packetStore != NULL) && (distributor != NULL)) {
-		tcQueueId = distributor->getRequestQueue();
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-void MapPacketExtraction::printPacketBuffer(void) {
-	sif::debug << "DLL: packet_buffer contains: " << std::endl;
-	for (uint32_t i = 0; i < this->packetLength; ++i) {
-		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
-				<< (uint16_t) this->packetBuffer[i] << std::endl;
-	}
-}
-
-uint8_t MapPacketExtraction::getMapId() const {
-	return mapId;
-}
+/**
+ * @file	MapPacketExtraction.cpp
+ * @brief	This file defines the MapPacketExtraction class.
+ * @date	26.03.2013
+ * @author	baetz
+ */
+
+#include "../datalinklayer/MapPacketExtraction.h"
+#include "../ipc/QueueFactory.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tmtcpacket/SpacePacketBase.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include <string.h>
+
+MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
+		object_id_t setPacketDestination) :
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
+		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
+		packetStore(nullptr), tcQueueId(MessageQueueMessageIF::NO_QUEUE) {
+	memset(packetBuffer, 0, sizeof(packetBuffer));
+}
+
+ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
+	uint8_t segmentationFlag = frame->getSequenceFlags();
+	ReturnValue_t status = TOO_SHORT_MAP_EXTRACTION;
+	switch (segmentationFlag) {
+	case NO_SEGMENTATION:
+		status = unpackBlockingPackets(frame);
+		break;
+	case FIRST_PORTION:
+		packetLength = frame->getDataLength();
+		if (packetLength <= MAX_PACKET_SIZE) {
+			memcpy(packetBuffer, frame->getDataField(), packetLength);
+			bufferPosition = &packetBuffer[packetLength];
+			status = RETURN_OK;
+		} else {
+			sif::error
+					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
+					<< packetLength << std::endl;
+			clearBuffers();
+			status = CONTENT_TOO_LARGE;
+		}
+		break;
+	case CONTINUING_PORTION:
+	case LAST_PORTION:
+		if (lastSegmentationFlag == FIRST_PORTION
+				|| lastSegmentationFlag == CONTINUING_PORTION) {
+			packetLength += frame->getDataLength();
+			if (packetLength <= MAX_PACKET_SIZE) {
+				memcpy(bufferPosition, frame->getDataField(),
+						frame->getDataLength());
+				bufferPosition = &packetBuffer[packetLength];
+				if (segmentationFlag == LAST_PORTION) {
+					status = sendCompletePacket(packetBuffer, packetLength);
+					clearBuffers();
+				}
+				status = RETURN_OK;
+			} else {
+				sif::error
+						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
+						<< packetLength << std::endl;
+				clearBuffers();
+				status = CONTENT_TOO_LARGE;
+			}
+		} else {
+			sif::error
+					<< "MapPacketExtraction::extractPackets. Illegal segment! Last flag: "
+					<< (int) lastSegmentationFlag << std::endl;
+			clearBuffers();
+			status = ILLEGAL_SEGMENTATION_FLAG;
+		}
+		break;
+	default:
+		sif::error
+				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
+				<< (int) segmentationFlag << std::endl;
+		clearBuffers();
+		status = DATA_CORRUPTED;
+		break;
+	}
+	lastSegmentationFlag = segmentationFlag;
+	return status;
+}
+
+ReturnValue_t MapPacketExtraction::unpackBlockingPackets(
+		TcTransferFrame* frame) {
+	ReturnValue_t status = TOO_SHORT_BLOCKED_PACKET;
+	uint32_t totalLength = frame->getDataLength();
+	if (totalLength > MAX_PACKET_SIZE)
+		return CONTENT_TOO_LARGE;
+	uint8_t* position = frame->getDataField();
+	while ((totalLength > SpacePacketBase::MINIMUM_SIZE)) {
+		SpacePacketBase packet(position);
+		uint32_t packetSize = packet.getFullSize();
+		if (packetSize <= totalLength) {
+			status = sendCompletePacket(packet.getWholeData(),
+					packet.getFullSize());
+			totalLength -= packet.getFullSize();
+			position += packet.getFullSize();
+			status = RETURN_OK;
+		} else {
+			status = DATA_CORRUPTED;
+			totalLength = 0;
+		}
+	}
+	if (totalLength > 0) {
+		status = RESIDUAL_DATA;
+	}
+	return status;
+}
+
+ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data,
+		uint32_t size) {
+	store_address_t store_id;
+	ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
+	if (status == RETURN_OK) {
+		TmTcMessage message(store_id);
+		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message);
+	}
+	return status;
+}
+
+void MapPacketExtraction::clearBuffers() {
+	memset(packetBuffer, 0, sizeof(packetBuffer));
+	bufferPosition = packetBuffer;
+	packetLength = 0;
+	lastSegmentationFlag = NO_SEGMENTATION;
+}
+
+ReturnValue_t MapPacketExtraction::initialize() {
+	packetStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	AcceptsTelecommandsIF* distributor = objectManager->get<
+			AcceptsTelecommandsIF>(packetDestination);
+	if ((packetStore != NULL) && (distributor != NULL)) {
+		tcQueueId = distributor->getRequestQueue();
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+void MapPacketExtraction::printPacketBuffer(void) {
+	sif::debug << "DLL: packet_buffer contains: " << std::endl;
+	for (uint32_t i = 0; i < this->packetLength; ++i) {
+		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
+				<< (uint16_t) this->packetBuffer[i] << std::endl;
+	}
+}
+
+uint8_t MapPacketExtraction::getMapId() const {
+	return mapId;
+}
diff --git a/datalinklayer/MapPacketExtraction.h b/datalinklayer/MapPacketExtraction.h
index 5a32366c4..cb09c27f0 100644
--- a/datalinklayer/MapPacketExtraction.h
+++ b/datalinklayer/MapPacketExtraction.h
@@ -1,78 +1,78 @@
-/**
- * @file	MapPacketExtraction.h
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
-#ifndef MAPPACKETEXTRACTION_H_
-#define MAPPACKETEXTRACTION_H_
-
-#include <framework/datalinklayer/MapPacketExtractionIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class StorageManagerIF;
-
-/**
- * Implementation of a MAP Packet Extraction class.
- * The class implements the full MAP Packet Extraction functionality as described in the CCSDS
- * TC Space Data Link Protocol. It internally stores incomplete segmented packets until they are
- * fully received. All found packets are forwarded to a single distribution entity.
- */
-class MapPacketExtraction: public MapPacketExtractionIF {
-private:
-	static const uint32_t MAX_PACKET_SIZE = 4096;
-	uint8_t lastSegmentationFlag;	//!< The segmentation flag of the last received frame.
-	uint8_t mapId;	//!< MAP ID of this MAP Channel.
-	uint32_t packetLength;	//!< Complete length of the current Space Packet.
-	uint8_t* bufferPosition;	//!< Position to write to in the internal Packet buffer.
-	uint8_t packetBuffer[MAX_PACKET_SIZE];	//!< The internal Space Packet Buffer.
-	object_id_t packetDestination;
-	StorageManagerIF* packetStore;	//!< Pointer to the store where full TC packets are stored.
-	MessageQueueId_t tcQueueId;		//!< QueueId to send found packets to the distributor.
-	/**
-	 * Debug method to print the packet Buffer's content.
-	 */
-	void printPacketBuffer();
-	/**
-	 * Method that is called if the segmentation flag is @c NO_SEGMENTATION.
-	 * The method extracts one or more packets within the frame and forwards them to the OBSW.
-	 * @param frame	The TC Transfer Frame to work on.
-	 * @return	@c RETURN_OK if all Packets were extracted. If something is entirely wrong,
-	 * 	 @c DATA_CORRUPTED is returned, if some bytes are left over @c RESIDUAL_DATA.
-	 */
-	ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame);
-	/**
-	 * Helper method to forward a complete packet to the OBSW.
-	 * @param data	Pointer to the data, either directly from the frame or from the packetBuffer.
-	 * @param size	Complete total size of the packet.
-	 * @return	Return Code of the Packet Store or the Message Queue.
-	 */
-	ReturnValue_t sendCompletePacket( uint8_t* data, uint32_t size );
-	/**
-	 * Helper method to reset the internal buffer.
-	 */
-	void clearBuffers();
-public:
-	/**
-	 * Default constructor.
-	 * Members are set to default values.
-	 * @param setMapId	The MAP ID of the instance.
-	 */
-	MapPacketExtraction( uint8_t setMapId, object_id_t setPacketDestination );
-	ReturnValue_t extractPackets(TcTransferFrame* frame);
-	/**
-	 * The #packetStore and the default destination of #tcQueue are initialized here.
-	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t initialize();
-	/**
-	 * Getter.
-	 * @return The MAP ID of this instance.
-	 */
-	uint8_t getMapId() const;
-};
-
-#endif /* MAPPACKETEXTRACTION_H_ */
+/**
+ * @file	MapPacketExtraction.h
+ * @brief	This file defines the MapPacketExtraction class.
+ * @date	26.03.2013
+ * @author	baetz
+ */
+
+#ifndef MAPPACKETEXTRACTION_H_
+#define MAPPACKETEXTRACTION_H_
+
+#include "../datalinklayer/MapPacketExtractionIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class StorageManagerIF;
+
+/**
+ * Implementation of a MAP Packet Extraction class.
+ * The class implements the full MAP Packet Extraction functionality as described in the CCSDS
+ * TC Space Data Link Protocol. It internally stores incomplete segmented packets until they are
+ * fully received. All found packets are forwarded to a single distribution entity.
+ */
+class MapPacketExtraction: public MapPacketExtractionIF {
+private:
+	static const uint32_t MAX_PACKET_SIZE = 4096;
+	uint8_t lastSegmentationFlag;	//!< The segmentation flag of the last received frame.
+	uint8_t mapId;	//!< MAP ID of this MAP Channel.
+	uint32_t packetLength;	//!< Complete length of the current Space Packet.
+	uint8_t* bufferPosition;	//!< Position to write to in the internal Packet buffer.
+	uint8_t packetBuffer[MAX_PACKET_SIZE];	//!< The internal Space Packet Buffer.
+	object_id_t packetDestination;
+	StorageManagerIF* packetStore;	//!< Pointer to the store where full TC packets are stored.
+	MessageQueueId_t tcQueueId;		//!< QueueId to send found packets to the distributor.
+	/**
+	 * Debug method to print the packet Buffer's content.
+	 */
+	void printPacketBuffer();
+	/**
+	 * Method that is called if the segmentation flag is @c NO_SEGMENTATION.
+	 * The method extracts one or more packets within the frame and forwards them to the OBSW.
+	 * @param frame	The TC Transfer Frame to work on.
+	 * @return	@c RETURN_OK if all Packets were extracted. If something is entirely wrong,
+	 * 	 @c DATA_CORRUPTED is returned, if some bytes are left over @c RESIDUAL_DATA.
+	 */
+	ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame);
+	/**
+	 * Helper method to forward a complete packet to the OBSW.
+	 * @param data	Pointer to the data, either directly from the frame or from the packetBuffer.
+	 * @param size	Complete total size of the packet.
+	 * @return	Return Code of the Packet Store or the Message Queue.
+	 */
+	ReturnValue_t sendCompletePacket( uint8_t* data, uint32_t size );
+	/**
+	 * Helper method to reset the internal buffer.
+	 */
+	void clearBuffers();
+public:
+	/**
+	 * Default constructor.
+	 * Members are set to default values.
+	 * @param setMapId	The MAP ID of the instance.
+	 */
+	MapPacketExtraction( uint8_t setMapId, object_id_t setPacketDestination );
+	ReturnValue_t extractPackets(TcTransferFrame* frame);
+	/**
+	 * The #packetStore and the default destination of #tcQueue are initialized here.
+	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t initialize();
+	/**
+	 * Getter.
+	 * @return The MAP ID of this instance.
+	 */
+	uint8_t getMapId() const;
+};
+
+#endif /* MAPPACKETEXTRACTION_H_ */
diff --git a/datalinklayer/MapPacketExtractionIF.h b/datalinklayer/MapPacketExtractionIF.h
index 802a893d0..d66831dee 100644
--- a/datalinklayer/MapPacketExtractionIF.h
+++ b/datalinklayer/MapPacketExtractionIF.h
@@ -1,47 +1,47 @@
-/**
- * @file	MapPacketExtractionIF.h
- * @brief	This file defines the MapPacketExtractionIF class.
- * @date	25.03.2013
- * @author	baetz
- */
-
-#ifndef MAPPACKETEXTRACTIONIF_H_
-#define MAPPACKETEXTRACTIONIF_H_
-
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-
-/**
- * This is the interface for MAP Packet Extraction classes.
- * All classes implementing this interface shall be able to extract blocked or segmented Space
- * Packets on a certain MAP channel. This is done in accordance with the CCSDS TC Space Data Link
- * Protocol.
- */
-class MapPacketExtractionIF : public CCSDSReturnValuesIF {
-protected:
-	static const uint8_t FIRST_PORTION = 0b01;		//!< Identification of the first part of a segmented Packet.
-	static const uint8_t CONTINUING_PORTION = 0b00;	//!< Identification of a continuing part of segmented Packets.
-	static const uint8_t LAST_PORTION = 0b10;		//!< The last portion of a segmented Packet.
-	static const uint8_t NO_SEGMENTATION = 0b11;	//!< A Frame without segmentation but maybe with blocking.
-public:
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~MapPacketExtractionIF() {
-	}
-	/**
-	 * Method to call to handle a single Transfer Frame.
-	 * The method tries to extract Packets from the frame as stated in the Standard.
-	 * @param frame
-	 * @return
-	 */
-	virtual ReturnValue_t extractPackets( TcTransferFrame* frame ) = 0;
-	/**
-	 * Any post-instantiation initialization shall be done in this method.
-	 * @return
-	 */
-	virtual ReturnValue_t initialize() = 0;
-};
-
-
-#endif /* MAPPACKETEXTRACTIONIF_H_ */
+/**
+ * @file	MapPacketExtractionIF.h
+ * @brief	This file defines the MapPacketExtractionIF class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef MAPPACKETEXTRACTIONIF_H_
+#define MAPPACKETEXTRACTIONIF_H_
+
+#include "../datalinklayer/CCSDSReturnValuesIF.h"
+#include "../datalinklayer/TcTransferFrame.h"
+
+/**
+ * This is the interface for MAP Packet Extraction classes.
+ * All classes implementing this interface shall be able to extract blocked or segmented Space
+ * Packets on a certain MAP channel. This is done in accordance with the CCSDS TC Space Data Link
+ * Protocol.
+ */
+class MapPacketExtractionIF : public CCSDSReturnValuesIF {
+protected:
+	static const uint8_t FIRST_PORTION = 0b01;		//!< Identification of the first part of a segmented Packet.
+	static const uint8_t CONTINUING_PORTION = 0b00;	//!< Identification of a continuing part of segmented Packets.
+	static const uint8_t LAST_PORTION = 0b10;		//!< The last portion of a segmented Packet.
+	static const uint8_t NO_SEGMENTATION = 0b11;	//!< A Frame without segmentation but maybe with blocking.
+public:
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~MapPacketExtractionIF() {
+	}
+	/**
+	 * Method to call to handle a single Transfer Frame.
+	 * The method tries to extract Packets from the frame as stated in the Standard.
+	 * @param frame
+	 * @return
+	 */
+	virtual ReturnValue_t extractPackets( TcTransferFrame* frame ) = 0;
+	/**
+	 * Any post-instantiation initialization shall be done in this method.
+	 * @return
+	 */
+	virtual ReturnValue_t initialize() = 0;
+};
+
+
+#endif /* MAPPACKETEXTRACTIONIF_H_ */
diff --git a/datalinklayer/TcTransferFrame.cpp b/datalinklayer/TcTransferFrame.cpp
index 30398e9bf..8a3e1d76d 100644
--- a/datalinklayer/TcTransferFrame.cpp
+++ b/datalinklayer/TcTransferFrame.cpp
@@ -1,102 +1,102 @@
-/**
- * @file	TcTransferFrame.cpp
- * @brief	This file defines the TcTransferFrame class.
- * @date	27.04.2013
- * @author	baetz
- */
-
-
-
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-TcTransferFrame::TcTransferFrame() {
-	 frame = NULL;
-}
-
-TcTransferFrame::TcTransferFrame(uint8_t* setData) {
-	 this->frame = (tc_transfer_frame*)setData;
-}
-
-uint8_t TcTransferFrame::getVersionNumber() {
-	 return (this->frame->header.flagsAndScid & 0b11000000) >> 6;
-}
-
-bool TcTransferFrame::bypassFlagSet() {
-	 return (this->frame->header.flagsAndScid & 0b00100000) != 0;
-}
-
-bool TcTransferFrame::controlCommandFlagSet() {
-	 return (this->frame->header.flagsAndScid & 0b00010000) != 0;
-}
-
-bool TcTransferFrame::spareIsZero() {
-	 return ( (this->frame->header.flagsAndScid & 0b00001100) == 0 );
-}
-
-uint16_t TcTransferFrame::getSpacecraftId() {
-	 return ( (this->frame->header.flagsAndScid & 0b00000011) << 8 ) + this->frame->header.spacecraftId_l;
-}
-
-uint8_t TcTransferFrame::getVirtualChannelId() {
-	 return (this->frame->header.vcidAndLength_h & 0b11111100) >> 2;
-}
-
-uint16_t TcTransferFrame::getFrameLength() {
-	 return  ( (this->frame->header.vcidAndLength_h & 0b00000011) << 8 ) + this->frame->header.length_l;
-}
-
-uint16_t TcTransferFrame::getDataLength() {
-	 return  this->getFrameLength() - this->getHeaderSize() -1 - FRAME_CRC_SIZE + 1; // -1 for the segment header.
-}
-
-uint8_t TcTransferFrame::getSequenceNumber() {
-	 return this->frame->header.sequenceNumber;
-}
-
-uint8_t TcTransferFrame::getSequenceFlags() {
-	 return (this->frame->dataField & 0b11000000)>>6;
-}
-
-uint8_t TcTransferFrame::getMAPId() {
-	 return this->frame->dataField & 0b00111111;
-}
-
-uint8_t* TcTransferFrame::getDataField() {
-	return &(this->frame->dataField) + 1;
-}
-
-uint8_t* TcTransferFrame::getFullFrame() {
-	return (uint8_t*)this->frame;
-}
-
-uint16_t TcTransferFrame::getFullSize() {
-	return this->getFrameLength() + 1;
-}
-
-uint16_t TcTransferFrame::getHeaderSize() {
-	 return sizeof(frame->header);
-}
-
-uint16_t TcTransferFrame::getFullDataLength() {
-	return this->getFrameLength() - this->getHeaderSize() - FRAME_CRC_SIZE + 1;
-}
-
-uint8_t* TcTransferFrame::getFullDataField() {
-	return &frame->dataField;
-}
-
-void TcTransferFrame::print() {
-	sif::debug << "Raw Frame: " << std::hex << std::endl;
-	for (uint16_t count = 0; count < this->getFullSize(); count++ ) {
-		sif::debug << (uint16_t)this->getFullFrame()[count] << " ";
-	}
-	sif::debug << std::dec << std::endl;
-//	debug << "Frame Header:" << std::endl;
-//	debug << "Version Number: " << std::hex << (uint16_t)this->current_frame.getVersionNumber() << std::endl;
-//	debug << "Bypass Flag set?| Ctrl Cmd Flag set?: " << (uint16_t)this->current_frame.bypassFlagSet() << " | " << (uint16_t)this->current_frame.controlCommandFlagSet()  << std::endl;
-//	debug << "SCID : " << this->current_frame.getSpacecraftId() << std::endl;
-//	debug << "VCID : " << (uint16_t)this->current_frame.getVirtualChannelId() << std::endl;
-//	debug << "Frame length: " << std::dec << this->current_frame.getFrameLength() << std::endl;
-//	debug << "Sequence Number: " << (uint16_t)this->current_frame.getSequenceNumber() << std::endl;
-}
+/**
+ * @file	TcTransferFrame.cpp
+ * @brief	This file defines the TcTransferFrame class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+
+
+#include "../datalinklayer/TcTransferFrame.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+TcTransferFrame::TcTransferFrame() {
+	 frame = NULL;
+}
+
+TcTransferFrame::TcTransferFrame(uint8_t* setData) {
+	 this->frame = (tc_transfer_frame*)setData;
+}
+
+uint8_t TcTransferFrame::getVersionNumber() {
+	 return (this->frame->header.flagsAndScid & 0b11000000) >> 6;
+}
+
+bool TcTransferFrame::bypassFlagSet() {
+	 return (this->frame->header.flagsAndScid & 0b00100000) != 0;
+}
+
+bool TcTransferFrame::controlCommandFlagSet() {
+	 return (this->frame->header.flagsAndScid & 0b00010000) != 0;
+}
+
+bool TcTransferFrame::spareIsZero() {
+	 return ( (this->frame->header.flagsAndScid & 0b00001100) == 0 );
+}
+
+uint16_t TcTransferFrame::getSpacecraftId() {
+	 return ( (this->frame->header.flagsAndScid & 0b00000011) << 8 ) + this->frame->header.spacecraftId_l;
+}
+
+uint8_t TcTransferFrame::getVirtualChannelId() {
+	 return (this->frame->header.vcidAndLength_h & 0b11111100) >> 2;
+}
+
+uint16_t TcTransferFrame::getFrameLength() {
+	 return  ( (this->frame->header.vcidAndLength_h & 0b00000011) << 8 ) + this->frame->header.length_l;
+}
+
+uint16_t TcTransferFrame::getDataLength() {
+	 return  this->getFrameLength() - this->getHeaderSize() -1 - FRAME_CRC_SIZE + 1; // -1 for the segment header.
+}
+
+uint8_t TcTransferFrame::getSequenceNumber() {
+	 return this->frame->header.sequenceNumber;
+}
+
+uint8_t TcTransferFrame::getSequenceFlags() {
+	 return (this->frame->dataField & 0b11000000)>>6;
+}
+
+uint8_t TcTransferFrame::getMAPId() {
+	 return this->frame->dataField & 0b00111111;
+}
+
+uint8_t* TcTransferFrame::getDataField() {
+	return &(this->frame->dataField) + 1;
+}
+
+uint8_t* TcTransferFrame::getFullFrame() {
+	return (uint8_t*)this->frame;
+}
+
+uint16_t TcTransferFrame::getFullSize() {
+	return this->getFrameLength() + 1;
+}
+
+uint16_t TcTransferFrame::getHeaderSize() {
+	 return sizeof(frame->header);
+}
+
+uint16_t TcTransferFrame::getFullDataLength() {
+	return this->getFrameLength() - this->getHeaderSize() - FRAME_CRC_SIZE + 1;
+}
+
+uint8_t* TcTransferFrame::getFullDataField() {
+	return &frame->dataField;
+}
+
+void TcTransferFrame::print() {
+	sif::debug << "Raw Frame: " << std::hex << std::endl;
+	for (uint16_t count = 0; count < this->getFullSize(); count++ ) {
+		sif::debug << (uint16_t)this->getFullFrame()[count] << " ";
+	}
+	sif::debug << std::dec << std::endl;
+//	debug << "Frame Header:" << std::endl;
+//	debug << "Version Number: " << std::hex << (uint16_t)this->current_frame.getVersionNumber() << std::endl;
+//	debug << "Bypass Flag set?| Ctrl Cmd Flag set?: " << (uint16_t)this->current_frame.bypassFlagSet() << " | " << (uint16_t)this->current_frame.controlCommandFlagSet()  << std::endl;
+//	debug << "SCID : " << this->current_frame.getSpacecraftId() << std::endl;
+//	debug << "VCID : " << (uint16_t)this->current_frame.getVirtualChannelId() << std::endl;
+//	debug << "Frame length: " << std::dec << this->current_frame.getFrameLength() << std::endl;
+//	debug << "Sequence Number: " << (uint16_t)this->current_frame.getSequenceNumber() << std::endl;
+}
diff --git a/datalinklayer/TcTransferFrameLocal.cpp b/datalinklayer/TcTransferFrameLocal.cpp
index 79e141674..0bffa586a 100644
--- a/datalinklayer/TcTransferFrameLocal.cpp
+++ b/datalinklayer/TcTransferFrameLocal.cpp
@@ -1,49 +1,49 @@
-/**
- * @file	TcTransferFrameLocal.cpp
- * @brief	This file defines the TcTransferFrameLocal class.
- * @date	27.04.2013
- * @author	baetz
- */
-
-#include <framework/datalinklayer/TcTransferFrameLocal.h>
-#include <framework/globalfunctions/CRC.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <string.h>
-
-TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid,
-		uint8_t vcId, uint8_t sequenceNumber, uint8_t setSegmentHeader, uint8_t* data, uint16_t dataSize, uint16_t forceCrc) {
-	this->frame = (tc_transfer_frame*)&localData;
-	frame->header.flagsAndScid = (bypass << 5) + (controlCommand << 4) + ((scid & 0x0300) >> 8);
-	frame->header.spacecraftId_l = (scid & 0x00FF);
-	frame->header.vcidAndLength_h = (vcId & 0b00111111) << 2;
-	frame->header.length_l = sizeof(TcTransferFramePrimaryHeader) -1;
-	frame->header.sequenceNumber = sequenceNumber;
-	frame->dataField = setSegmentHeader;
-	if (data != NULL) {
-		if (bypass && controlCommand) {
-			memcpy(&(frame->dataField), data, dataSize);
-			uint16_t totalSize = sizeof(TcTransferFramePrimaryHeader) + dataSize + FRAME_CRC_SIZE -1;
-			frame->header.vcidAndLength_h |= (totalSize & 0x0300) >> 8;
-			frame->header.length_l = (totalSize & 0x00FF);
-			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
-			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
-			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
-		} else if (dataSize <= 1016) {
-			memcpy(&(frame->dataField) +1, data, dataSize);
-			uint16_t dataCrcSize = sizeof(TcTransferFramePrimaryHeader) + 1 + dataSize + FRAME_CRC_SIZE -1;
-			frame->header.vcidAndLength_h |= (dataCrcSize & 0x0300) >> 8;
-			frame->header.length_l = (dataCrcSize & 0x00FF);
-			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
-			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
-			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
-		} else {
-			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
-		}
-	} else {
-		//No data in frame
-	}
-	if (forceCrc != 0 ) {
-		localData.data[getFullSize()-2] = (forceCrc & 0xFF00) >> 8;
-		localData.data[getFullSize()-1] = (forceCrc & 0x00FF);
-	}
-}
+/**
+ * @file	TcTransferFrameLocal.cpp
+ * @brief	This file defines the TcTransferFrameLocal class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+#include "../datalinklayer/TcTransferFrameLocal.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <string.h>
+
+TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid,
+		uint8_t vcId, uint8_t sequenceNumber, uint8_t setSegmentHeader, uint8_t* data, uint16_t dataSize, uint16_t forceCrc) {
+	this->frame = (tc_transfer_frame*)&localData;
+	frame->header.flagsAndScid = (bypass << 5) + (controlCommand << 4) + ((scid & 0x0300) >> 8);
+	frame->header.spacecraftId_l = (scid & 0x00FF);
+	frame->header.vcidAndLength_h = (vcId & 0b00111111) << 2;
+	frame->header.length_l = sizeof(TcTransferFramePrimaryHeader) -1;
+	frame->header.sequenceNumber = sequenceNumber;
+	frame->dataField = setSegmentHeader;
+	if (data != NULL) {
+		if (bypass && controlCommand) {
+			memcpy(&(frame->dataField), data, dataSize);
+			uint16_t totalSize = sizeof(TcTransferFramePrimaryHeader) + dataSize + FRAME_CRC_SIZE -1;
+			frame->header.vcidAndLength_h |= (totalSize & 0x0300) >> 8;
+			frame->header.length_l = (totalSize & 0x00FF);
+			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
+			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
+			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
+		} else if (dataSize <= 1016) {
+			memcpy(&(frame->dataField) +1, data, dataSize);
+			uint16_t dataCrcSize = sizeof(TcTransferFramePrimaryHeader) + 1 + dataSize + FRAME_CRC_SIZE -1;
+			frame->header.vcidAndLength_h |= (dataCrcSize & 0x0300) >> 8;
+			frame->header.length_l = (dataCrcSize & 0x00FF);
+			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
+			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
+			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
+		} else {
+			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
+		}
+	} else {
+		//No data in frame
+	}
+	if (forceCrc != 0 ) {
+		localData.data[getFullSize()-2] = (forceCrc & 0xFF00) >> 8;
+		localData.data[getFullSize()-1] = (forceCrc & 0x00FF);
+	}
+}
diff --git a/datalinklayer/TcTransferFrameLocal.h b/datalinklayer/TcTransferFrameLocal.h
index f20f12ec2..d98350fe1 100644
--- a/datalinklayer/TcTransferFrameLocal.h
+++ b/datalinklayer/TcTransferFrameLocal.h
@@ -1,49 +1,49 @@
-/**
- * @file	TcTransferFrameLocal.h
- * @brief	This file defines the TcTransferFrameLocal class.
- * @date	27.04.2013
- * @author	baetz
- */
-
-#ifndef TCTRANSFERFRAMELOCAL_H_
-#define TCTRANSFERFRAMELOCAL_H_
-
-#include <framework/datalinklayer/TcTransferFrame.h>
-
-/**
- * This is a helper class to locally create TC Transfer Frames.
- * This is mainly required for testing purposes and therefore not very sophisticated.
- * @ingroup ccsds_handling
- */
-class TcTransferFrameLocal : public TcTransferFrame {
-private:
-	/**
-	 * A stuct to locally store the complete data.
-	 */
-	struct frameData {
-		TcTransferFramePrimaryHeader header;	//!< The primary header.
-		uint8_t data[1019];	//!< The data field.
-	};
-public:
-	frameData localData; //!< The local data in the Frame.
-	/**
-	 * The default Constructor.
-	 * All parameters in the Header are passed.
-	 * If a BC Frame is detected no segment header is created.
-	 * Otherwise (AD and BD), the Segment Header is set.
-	 * @param bypass			The bypass flag.
-	 * @param controlCommand	The Control Command flag.
-	 * @param scid				The SCID.
-	 * @param vcId				The VCID.
-	 * @param sequenceNumber	The Frame Sequence Number N(s)
-	 * @param setSegmentHeader	A value for the Segment Header.
-	 * @param data				Data to put into the Frame Data Field.
-	 * @param dataSize			Size of the Data.
-	 * @param forceCrc			if != 0, the value is used as CRC.
-	 */
-	TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid, uint8_t vcId, uint8_t sequenceNumber,
-			uint8_t setSegmentHeader = 0xC0, uint8_t* data = NULL, uint16_t dataSize = 0, uint16_t forceCrc = 0);
-};
-
-
-#endif /* TCTRANSFERFRAMELOCAL_H_ */
+/**
+ * @file	TcTransferFrameLocal.h
+ * @brief	This file defines the TcTransferFrameLocal class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+#ifndef TCTRANSFERFRAMELOCAL_H_
+#define TCTRANSFERFRAMELOCAL_H_
+
+#include "../datalinklayer/TcTransferFrame.h"
+
+/**
+ * This is a helper class to locally create TC Transfer Frames.
+ * This is mainly required for testing purposes and therefore not very sophisticated.
+ * @ingroup ccsds_handling
+ */
+class TcTransferFrameLocal : public TcTransferFrame {
+private:
+	/**
+	 * A stuct to locally store the complete data.
+	 */
+	struct frameData {
+		TcTransferFramePrimaryHeader header;	//!< The primary header.
+		uint8_t data[1019];	//!< The data field.
+	};
+public:
+	frameData localData; //!< The local data in the Frame.
+	/**
+	 * The default Constructor.
+	 * All parameters in the Header are passed.
+	 * If a BC Frame is detected no segment header is created.
+	 * Otherwise (AD and BD), the Segment Header is set.
+	 * @param bypass			The bypass flag.
+	 * @param controlCommand	The Control Command flag.
+	 * @param scid				The SCID.
+	 * @param vcId				The VCID.
+	 * @param sequenceNumber	The Frame Sequence Number N(s)
+	 * @param setSegmentHeader	A value for the Segment Header.
+	 * @param data				Data to put into the Frame Data Field.
+	 * @param dataSize			Size of the Data.
+	 * @param forceCrc			if != 0, the value is used as CRC.
+	 */
+	TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid, uint8_t vcId, uint8_t sequenceNumber,
+			uint8_t setSegmentHeader = 0xC0, uint8_t* data = NULL, uint16_t dataSize = 0, uint16_t forceCrc = 0);
+};
+
+
+#endif /* TCTRANSFERFRAMELOCAL_H_ */
diff --git a/datalinklayer/VirtualChannelReception.cpp b/datalinklayer/VirtualChannelReception.cpp
index 373f6c62d..55169c42f 100644
--- a/datalinklayer/VirtualChannelReception.cpp
+++ b/datalinklayer/VirtualChannelReception.cpp
@@ -1,121 +1,121 @@
-/**
- * @file	VirtualChannelReception.cpp
- * @brief	This file defines the VirtualChannelReception class.
- * @date	26.03.2013
- * @author	baetz
- */
-
-#include <framework/datalinklayer/BCFrame.h>
-#include <framework/datalinklayer/VirtualChannelReception.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-VirtualChannelReception::VirtualChannelReception(uint8_t setChannelId,
-		uint8_t setSlidingWindowWidth) :
-		channelId(setChannelId), slidingWindowWidth(setSlidingWindowWidth), positiveWindow(
-				setSlidingWindowWidth / 2), negativeWindow(setSlidingWindowWidth / 2), currentState(
-				&openState), openState(this), waitState(this), lockoutState(this), vR(0), farmBCounter(
-				0) {
-	internalClcw.setVirtualChannel(channelId);
-}
-
-ReturnValue_t VirtualChannelReception::mapDemultiplexing(TcTransferFrame* frame) {
-	uint8_t mapId = frame->getMAPId();
-	mapChannelIterator iter = mapChannels.find(mapId);
-	if (iter == mapChannels.end()) {
-//		error << "VirtualChannelReception::mapDemultiplexing on VC " << std::hex << (int) channelId
-//				<< ": MapChannel " << (int) mapId << std::dec << " not found." << std::endl;
-		return VC_NOT_FOUND;
-	} else {
-		return (iter->second)->extractPackets(frame);
-	}
-}
-
-ReturnValue_t VirtualChannelReception::doFARM(TcTransferFrame* frame, ClcwIF* clcw) {
-	uint8_t bypass = frame->bypassFlagSet();
-	uint8_t controlCommand = frame->controlCommandFlagSet();
-	uint8_t typeValue = (bypass << 1) + controlCommand;
-	switch (typeValue) {
-	case AD_FRAME:
-		return currentState->handleADFrame(frame, clcw);
-	case BD_FRAME:
-		return handleBDFrame(frame, clcw);
-	case BC_FRAME:
-		return handleBCFrame(frame, clcw);
-	default:
-		return ILLEGAL_FLAG_COMBINATION;
-	}
-}
-
-ReturnValue_t VirtualChannelReception::frameAcceptanceAndReportingMechanism(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-	ReturnValue_t result = RETURN_OK;
-	result = doFARM(frame, &internalClcw);
-	internalClcw.setReceiverFrameSequenceNumber(vR);
-	internalClcw.setFarmBCount(farmBCounter);
-	clcw->setWhole(internalClcw.getAsWhole());
-	switch (result) {
-	case RETURN_OK:
-		return mapDemultiplexing(frame);
-	case BC_IS_SET_VR_COMMAND:
-	case BC_IS_UNLOCK_COMMAND:
-		//Need to catch these codes to avoid error reporting later.
-		return RETURN_OK;
-	default:
-		break;
-	}
-	return result;
-}
-
-ReturnValue_t VirtualChannelReception::addMapChannel(uint8_t mapId, MapPacketExtractionIF* object) {
-	std::pair<mapChannelIterator, bool> returnValue = mapChannels.insert(
-			std::pair<uint8_t, MapPacketExtractionIF*>(mapId, object));
-	if (returnValue.second == true) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t VirtualChannelReception::handleBDFrame(TcTransferFrame* frame, ClcwIF* clcw) {
-	farmBCounter++;
-	return RETURN_OK;
-}
-
-ReturnValue_t VirtualChannelReception::handleBCFrame(TcTransferFrame* frame, ClcwIF* clcw) {
-	BcFrame content;
-	ReturnValue_t returnValue = content.initialize(frame->getFullDataField(),
-			frame->getFullDataLength());
-	if (returnValue == BC_IS_UNLOCK_COMMAND) {
-		returnValue = currentState->handleBCUnlockCommand(clcw);
-	} else if (returnValue == BC_IS_SET_VR_COMMAND) {
-		returnValue = currentState->handleBCSetVrCommand(clcw, content.vR);
-	} else {
-		//Do nothing
-	}
-	return returnValue;
-}
-
-uint8_t VirtualChannelReception::getChannelId() const {
-	return channelId;
-}
-
-ReturnValue_t VirtualChannelReception::initialize() {
-	ReturnValue_t returnValue = RETURN_FAILED;
-	if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
-		sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
-				<< (int) slidingWindowWidth << std::endl;
-		return RETURN_FAILED;
-	}
-	for (mapChannelIterator iterator = mapChannels.begin(); iterator != mapChannels.end();
-			iterator++) {
-		returnValue = iterator->second->initialize();
-		if (returnValue != RETURN_OK)
-			break;
-	}
-	return returnValue;
-}
-
-void VirtualChannelReception::setToWaitState() {
-	internalClcw.setWaitFlag(true);
-	this->currentState = &waitState;
-}
+/**
+ * @file	VirtualChannelReception.cpp
+ * @brief	This file defines the VirtualChannelReception class.
+ * @date	26.03.2013
+ * @author	baetz
+ */
+
+#include "../datalinklayer/BCFrame.h"
+#include "../datalinklayer/VirtualChannelReception.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+VirtualChannelReception::VirtualChannelReception(uint8_t setChannelId,
+		uint8_t setSlidingWindowWidth) :
+		channelId(setChannelId), slidingWindowWidth(setSlidingWindowWidth), positiveWindow(
+				setSlidingWindowWidth / 2), negativeWindow(setSlidingWindowWidth / 2), currentState(
+				&openState), openState(this), waitState(this), lockoutState(this), vR(0), farmBCounter(
+				0) {
+	internalClcw.setVirtualChannel(channelId);
+}
+
+ReturnValue_t VirtualChannelReception::mapDemultiplexing(TcTransferFrame* frame) {
+	uint8_t mapId = frame->getMAPId();
+	mapChannelIterator iter = mapChannels.find(mapId);
+	if (iter == mapChannels.end()) {
+//		error << "VirtualChannelReception::mapDemultiplexing on VC " << std::hex << (int) channelId
+//				<< ": MapChannel " << (int) mapId << std::dec << " not found." << std::endl;
+		return VC_NOT_FOUND;
+	} else {
+		return (iter->second)->extractPackets(frame);
+	}
+}
+
+ReturnValue_t VirtualChannelReception::doFARM(TcTransferFrame* frame, ClcwIF* clcw) {
+	uint8_t bypass = frame->bypassFlagSet();
+	uint8_t controlCommand = frame->controlCommandFlagSet();
+	uint8_t typeValue = (bypass << 1) + controlCommand;
+	switch (typeValue) {
+	case AD_FRAME:
+		return currentState->handleADFrame(frame, clcw);
+	case BD_FRAME:
+		return handleBDFrame(frame, clcw);
+	case BC_FRAME:
+		return handleBCFrame(frame, clcw);
+	default:
+		return ILLEGAL_FLAG_COMBINATION;
+	}
+}
+
+ReturnValue_t VirtualChannelReception::frameAcceptanceAndReportingMechanism(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+	ReturnValue_t result = RETURN_OK;
+	result = doFARM(frame, &internalClcw);
+	internalClcw.setReceiverFrameSequenceNumber(vR);
+	internalClcw.setFarmBCount(farmBCounter);
+	clcw->setWhole(internalClcw.getAsWhole());
+	switch (result) {
+	case RETURN_OK:
+		return mapDemultiplexing(frame);
+	case BC_IS_SET_VR_COMMAND:
+	case BC_IS_UNLOCK_COMMAND:
+		//Need to catch these codes to avoid error reporting later.
+		return RETURN_OK;
+	default:
+		break;
+	}
+	return result;
+}
+
+ReturnValue_t VirtualChannelReception::addMapChannel(uint8_t mapId, MapPacketExtractionIF* object) {
+	std::pair<mapChannelIterator, bool> returnValue = mapChannels.insert(
+			std::pair<uint8_t, MapPacketExtractionIF*>(mapId, object));
+	if (returnValue.second == true) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t VirtualChannelReception::handleBDFrame(TcTransferFrame* frame, ClcwIF* clcw) {
+	farmBCounter++;
+	return RETURN_OK;
+}
+
+ReturnValue_t VirtualChannelReception::handleBCFrame(TcTransferFrame* frame, ClcwIF* clcw) {
+	BcFrame content;
+	ReturnValue_t returnValue = content.initialize(frame->getFullDataField(),
+			frame->getFullDataLength());
+	if (returnValue == BC_IS_UNLOCK_COMMAND) {
+		returnValue = currentState->handleBCUnlockCommand(clcw);
+	} else if (returnValue == BC_IS_SET_VR_COMMAND) {
+		returnValue = currentState->handleBCSetVrCommand(clcw, content.vR);
+	} else {
+		//Do nothing
+	}
+	return returnValue;
+}
+
+uint8_t VirtualChannelReception::getChannelId() const {
+	return channelId;
+}
+
+ReturnValue_t VirtualChannelReception::initialize() {
+	ReturnValue_t returnValue = RETURN_FAILED;
+	if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
+		sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
+				<< (int) slidingWindowWidth << std::endl;
+		return RETURN_FAILED;
+	}
+	for (mapChannelIterator iterator = mapChannels.begin(); iterator != mapChannels.end();
+			iterator++) {
+		returnValue = iterator->second->initialize();
+		if (returnValue != RETURN_OK)
+			break;
+	}
+	return returnValue;
+}
+
+void VirtualChannelReception::setToWaitState() {
+	internalClcw.setWaitFlag(true);
+	this->currentState = &waitState;
+}
diff --git a/datalinklayer/VirtualChannelReception.h b/datalinklayer/VirtualChannelReception.h
index f364c6e5d..f7111e42a 100644
--- a/datalinklayer/VirtualChannelReception.h
+++ b/datalinklayer/VirtualChannelReception.h
@@ -1,114 +1,114 @@
-/**
- * @file	VirtualChannelReception.h
- * @brief	This file defines the VirtualChannelReception class.
- * @date	25.03.2013
- * @author	baetz
- */
-
-#ifndef VIRTUALCHANNELRECEPTION_H_
-#define VIRTUALCHANNELRECEPTION_H_
-
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
-#include <framework/datalinklayer/Clcw.h>
-#include <framework/datalinklayer/Farm1StateIF.h>
-#include <framework/datalinklayer/Farm1StateLockout.h>
-#include <framework/datalinklayer/Farm1StateOpen.h>
-#include <framework/datalinklayer/Farm1StateWait.h>
-#include <framework/datalinklayer/MapPacketExtractionIF.h>
-#include <framework/datalinklayer/VirtualChannelReceptionIF.h>
-#include <map>
-/**
- * Implementation of a TC Virtual Channel.
- * This is a full implementation of a virtual channel as specified in the CCSDS TC Space Data Link
- * Protocol. It is designed to operate within an instance of the @c DataLinkLayer class.
- * Features:
- *  - any (6bit) Virtual Channel ID is assignable.
- *  - Supports an arbitrary number of MAP Channels (with a map).
- *  - Has a complete FARM-1 Machine built-in.
- *
- * The FARM-1 state machine uses the State Pattern.
- */
-class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSReturnValuesIF {
-	friend class Farm1StateOpen;
-	friend class Farm1StateWait;
-	friend class Farm1StateLockout;
-private:
-	uint8_t channelId;	//!< Stores the VCID that was assigned on construction.
-	uint8_t slidingWindowWidth;	//!< A constant to set the FARM-1 sliding window width.
-	uint8_t positiveWindow;	//!< The positive window for the FARM-1 machine.
-	uint8_t negativeWindow; //!< The negative window for the FARM-1 machine.
-protected:
-	Farm1StateIF* currentState;	//!< The current state. To change, one of the other states must be assigned to this pointer.
-	Farm1StateOpen openState;	//!< Instance of the FARM-1 State "Open".
-	Farm1StateWait waitState;	//!< Instance of the FARM-1 State "Wait".
-	Farm1StateLockout lockoutState;	//!< Instance of the FARM-1 State "Lockout".
-	Clcw internalClcw;	//!< A CLCW class to internally set the values before writing them back to the TTC System.
-	uint8_t vR;	//!< The Receiver Frame Sequence Number V(R) as it shall be maintained for every Virtual Channel.
-	uint8_t farmBCounter;	//!< The FARM-B COunter as it shall be maintained for every Virtual Channel.
-	typedef std::map<uint8_t, MapPacketExtractionIF*>::iterator mapChannelIterator;	//!< Typedef to simplify handling of the mapChannels map.
-	std::map<uint8_t, MapPacketExtractionIF*> mapChannels;	//!< A map that maintains all map Channels. Channels must be configured on initialization. MAy be omitted in a simplified version.
-	/**
-	 * This method handles demultiplexing to different map channels.
-	 * It parses the entries of #mapChannels and forwards the Frame to a found MAP Channel.
-	 * @param frame	The frame to forward.
-	 * @return	#VC_NOT_FOUND or the return value of the map channel extraction.
-	 */
-	ReturnValue_t mapDemultiplexing( TcTransferFrame* frame );
-	/**
-	 * A sub-method that actually does the FARM-1 handling for different Frame types.
-	 * @param frame	The Tc Transfer Frame to handle.
-	 * @param clcw	Any changes on the CLCW shall be done with this method.
-	 * @return	The return code of higher methods or @c ILLEGAL_FLAG_COMBINATION.
-	 */
-	ReturnValue_t doFARM(TcTransferFrame* frame, ClcwIF* clcw);
-	/**
-	 * Handles incoming BD Frames.
-	 * Handling these Frames is independent of the State, so no subcall to #currentState is
-	 * required.
-	 * @param frame	The Tc Transfer Frame to handle.
-	 * @param clcw	Any changes on the CLCW shall be done with this method.
-	 * @return Always returns @c RETURN_OK.
-	 */
-	ReturnValue_t handleBDFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * Handles incoming BC Frames.
-	 * The type of the BC Frame is detected and checked first, then methods of #currentState are called.
-	 * @param frame	The Tc Transfer Frame to handle.
-	 * @param clcw	Any changes on the CLCW shall be done with this method.
-	 * @return The failure code of BC Frame interpretation or the return code of higher methods.
-	 */
-	ReturnValue_t handleBCFrame( TcTransferFrame* frame, ClcwIF* clcw );
-public:
-	/**
-	 * Default constructor.
-	 * Only sets the channelId of the channel. Setting the Sliding Window width is possible as well.
-	 * @param setChannelId	Virtual Channel Identifier (VCID) of the channel.
-	 */
-	VirtualChannelReception( uint8_t setChannelId, uint8_t setSlidingWindowWidth );
-	ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * Helper method to simplify adding a mapChannel during construction.
-	 * @param mapId	The mapId of the object to add.
-	 * @param object	Pointer to the MapPacketExtraction object itself.
-	 * @return	@c RETURN_OK if the channel was successfully inserted, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t addMapChannel( uint8_t mapId, MapPacketExtractionIF* object );
-	/**
-	 * The initialization routine checks the set #slidingWindowWidth and initializes all MAP
-	 * channels.
-	 * @return	@c RETURN_OK on successful initialization, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t initialize();
-	/**
-	 * Getter for the VCID.
-	 * @return	The #channelId.
-	 */
-	uint8_t getChannelId() const;
-	/**
-	 * Small method to set the state to Farm1StateWait.
-	 */
-	void setToWaitState();
-};
-
-
-#endif /* VIRTUALCHANNELRECEPTION_H_ */
+/**
+ * @file	VirtualChannelReception.h
+ * @brief	This file defines the VirtualChannelReception class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef VIRTUALCHANNELRECEPTION_H_
+#define VIRTUALCHANNELRECEPTION_H_
+
+#include "../datalinklayer/CCSDSReturnValuesIF.h"
+#include "../datalinklayer/Clcw.h"
+#include "../datalinklayer/Farm1StateIF.h"
+#include "../datalinklayer/Farm1StateLockout.h"
+#include "../datalinklayer/Farm1StateOpen.h"
+#include "../datalinklayer/Farm1StateWait.h"
+#include "../datalinklayer/MapPacketExtractionIF.h"
+#include "../datalinklayer/VirtualChannelReceptionIF.h"
+#include <map>
+/**
+ * Implementation of a TC Virtual Channel.
+ * This is a full implementation of a virtual channel as specified in the CCSDS TC Space Data Link
+ * Protocol. It is designed to operate within an instance of the @c DataLinkLayer class.
+ * Features:
+ *  - any (6bit) Virtual Channel ID is assignable.
+ *  - Supports an arbitrary number of MAP Channels (with a map).
+ *  - Has a complete FARM-1 Machine built-in.
+ *
+ * The FARM-1 state machine uses the State Pattern.
+ */
+class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSReturnValuesIF {
+	friend class Farm1StateOpen;
+	friend class Farm1StateWait;
+	friend class Farm1StateLockout;
+private:
+	uint8_t channelId;	//!< Stores the VCID that was assigned on construction.
+	uint8_t slidingWindowWidth;	//!< A constant to set the FARM-1 sliding window width.
+	uint8_t positiveWindow;	//!< The positive window for the FARM-1 machine.
+	uint8_t negativeWindow; //!< The negative window for the FARM-1 machine.
+protected:
+	Farm1StateIF* currentState;	//!< The current state. To change, one of the other states must be assigned to this pointer.
+	Farm1StateOpen openState;	//!< Instance of the FARM-1 State "Open".
+	Farm1StateWait waitState;	//!< Instance of the FARM-1 State "Wait".
+	Farm1StateLockout lockoutState;	//!< Instance of the FARM-1 State "Lockout".
+	Clcw internalClcw;	//!< A CLCW class to internally set the values before writing them back to the TTC System.
+	uint8_t vR;	//!< The Receiver Frame Sequence Number V(R) as it shall be maintained for every Virtual Channel.
+	uint8_t farmBCounter;	//!< The FARM-B COunter as it shall be maintained for every Virtual Channel.
+	typedef std::map<uint8_t, MapPacketExtractionIF*>::iterator mapChannelIterator;	//!< Typedef to simplify handling of the mapChannels map.
+	std::map<uint8_t, MapPacketExtractionIF*> mapChannels;	//!< A map that maintains all map Channels. Channels must be configured on initialization. MAy be omitted in a simplified version.
+	/**
+	 * This method handles demultiplexing to different map channels.
+	 * It parses the entries of #mapChannels and forwards the Frame to a found MAP Channel.
+	 * @param frame	The frame to forward.
+	 * @return	#VC_NOT_FOUND or the return value of the map channel extraction.
+	 */
+	ReturnValue_t mapDemultiplexing( TcTransferFrame* frame );
+	/**
+	 * A sub-method that actually does the FARM-1 handling for different Frame types.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return	The return code of higher methods or @c ILLEGAL_FLAG_COMBINATION.
+	 */
+	ReturnValue_t doFARM(TcTransferFrame* frame, ClcwIF* clcw);
+	/**
+	 * Handles incoming BD Frames.
+	 * Handling these Frames is independent of the State, so no subcall to #currentState is
+	 * required.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return Always returns @c RETURN_OK.
+	 */
+	ReturnValue_t handleBDFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * Handles incoming BC Frames.
+	 * The type of the BC Frame is detected and checked first, then methods of #currentState are called.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return The failure code of BC Frame interpretation or the return code of higher methods.
+	 */
+	ReturnValue_t handleBCFrame( TcTransferFrame* frame, ClcwIF* clcw );
+public:
+	/**
+	 * Default constructor.
+	 * Only sets the channelId of the channel. Setting the Sliding Window width is possible as well.
+	 * @param setChannelId	Virtual Channel Identifier (VCID) of the channel.
+	 */
+	VirtualChannelReception( uint8_t setChannelId, uint8_t setSlidingWindowWidth );
+	ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * Helper method to simplify adding a mapChannel during construction.
+	 * @param mapId	The mapId of the object to add.
+	 * @param object	Pointer to the MapPacketExtraction object itself.
+	 * @return	@c RETURN_OK if the channel was successfully inserted, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t addMapChannel( uint8_t mapId, MapPacketExtractionIF* object );
+	/**
+	 * The initialization routine checks the set #slidingWindowWidth and initializes all MAP
+	 * channels.
+	 * @return	@c RETURN_OK on successful initialization, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t initialize();
+	/**
+	 * Getter for the VCID.
+	 * @return	The #channelId.
+	 */
+	uint8_t getChannelId() const;
+	/**
+	 * Small method to set the state to Farm1StateWait.
+	 */
+	void setToWaitState();
+};
+
+
+#endif /* VIRTUALCHANNELRECEPTION_H_ */
diff --git a/datalinklayer/VirtualChannelReceptionIF.h b/datalinklayer/VirtualChannelReceptionIF.h
index 98a9b72c8..da5440814 100644
--- a/datalinklayer/VirtualChannelReceptionIF.h
+++ b/datalinklayer/VirtualChannelReceptionIF.h
@@ -1,57 +1,57 @@
-/**
- * @file	VirtualChannelReceptionIF.h
- * @brief	This file defines the VirtualChannelReceptionIF class.
- * @date	25.03.2013
- * @author	baetz
- */
-
-#ifndef VIRTUALCHANNELRECEPTIONIF_H_
-#define VIRTUALCHANNELRECEPTIONIF_H_
-
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-/**
- * This is the interface for Virtual Channel reception classes.
- * It represents a single TC Virtual Channel that operates on one IO
- */
-class VirtualChannelReceptionIF {
-public:
-	/**
-	 * Enum including all valid types of frames.
-	 * The type is made up by two flags, so 0b1111 is definitely illegal.
-	 */
-	enum frameType  {
-		AD_FRAME = 0b00,
-		BC_FRAME = 0b11,
-		BD_FRAME = 0b10,
-		ILLEGAL_FRAME = 0b1111
-	};
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~VirtualChannelReceptionIF() {
-	}
-	/**
-	 * This method shall accept frames and do all FARM-1 stuff.
-	 * Handling the Frame includes forwarding to higher-level procedures.
-	 * @param frame	The Tc Transfer Frame that was received and checked.
-	 * @param clcw	Any changes to the CLCW value are forwarded by using this parameter.
-	 * @return The return Value shall indicate successful processing with @c RETURN_OK.
-	 */
-	virtual ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
-	/**
-	 * If any other System Objects are required for operation they shall be initialized here.
-	 * @return	@c RETURN_OK for successful initialization.
-	 */
-	virtual ReturnValue_t initialize() = 0;
-	/**
-	 * Getter for the VCID.
-	 * @return	The #channelId.
-	 */
-	virtual uint8_t getChannelId() const = 0;
-};
-
-
-#endif /* VIRTUALCHANNELRECEPTIONIF_H_ */
+/**
+ * @file	VirtualChannelReceptionIF.h
+ * @brief	This file defines the VirtualChannelReceptionIF class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef VIRTUALCHANNELRECEPTIONIF_H_
+#define VIRTUALCHANNELRECEPTIONIF_H_
+
+#include "../datalinklayer/ClcwIF.h"
+#include "../datalinklayer/TcTransferFrame.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * This is the interface for Virtual Channel reception classes.
+ * It represents a single TC Virtual Channel that operates on one IO
+ */
+class VirtualChannelReceptionIF {
+public:
+	/**
+	 * Enum including all valid types of frames.
+	 * The type is made up by two flags, so 0b1111 is definitely illegal.
+	 */
+	enum frameType  {
+		AD_FRAME = 0b00,
+		BC_FRAME = 0b11,
+		BD_FRAME = 0b10,
+		ILLEGAL_FRAME = 0b1111
+	};
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~VirtualChannelReceptionIF() {
+	}
+	/**
+	 * This method shall accept frames and do all FARM-1 stuff.
+	 * Handling the Frame includes forwarding to higher-level procedures.
+	 * @param frame	The Tc Transfer Frame that was received and checked.
+	 * @param clcw	Any changes to the CLCW value are forwarded by using this parameter.
+	 * @return The return Value shall indicate successful processing with @c RETURN_OK.
+	 */
+	virtual ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
+	/**
+	 * If any other System Objects are required for operation they shall be initialized here.
+	 * @return	@c RETURN_OK for successful initialization.
+	 */
+	virtual ReturnValue_t initialize() = 0;
+	/**
+	 * Getter for the VCID.
+	 * @return	The #channelId.
+	 */
+	virtual uint8_t getChannelId() const = 0;
+};
+
+
+#endif /* VIRTUALCHANNELRECEPTIONIF_H_ */
diff --git a/datapool/ControllerSet.cpp b/datapool/ControllerSet.cpp
index eb4f6d0fd..f83b38d58 100644
--- a/datapool/ControllerSet.cpp
+++ b/datapool/ControllerSet.cpp
@@ -1,14 +1,14 @@
-#include <framework/datapool/ControllerSet.h>
-
-ControllerSet::ControllerSet() {
-
-}
-
-ControllerSet::~ControllerSet() {
-}
-
-void ControllerSet::setInvalid() {
-	read();
-	setToDefault();
-	commit(PoolVariableIF::INVALID);
-}
+#include "../datapool/ControllerSet.h"
+
+ControllerSet::ControllerSet() {
+
+}
+
+ControllerSet::~ControllerSet() {
+}
+
+void ControllerSet::setInvalid() {
+	read();
+	setToDefault();
+	commit(PoolVariableIF::INVALID);
+}
diff --git a/datapool/ControllerSet.h b/datapool/ControllerSet.h
index 7625c3d1b..da6a9bf4b 100644
--- a/datapool/ControllerSet.h
+++ b/datapool/ControllerSet.h
@@ -1,15 +1,15 @@
-#ifndef CONTROLLERSET_H_
-#define CONTROLLERSET_H_
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-
-class ControllerSet :public GlobDataSet {
-public:
-	ControllerSet();
-	virtual ~ControllerSet();
-
-	virtual void setToDefault() = 0;
-	void setInvalid();
-};
-
-#endif /* CONTROLLERSET_H_ */
+#ifndef CONTROLLERSET_H_
+#define CONTROLLERSET_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+
+class ControllerSet :public GlobDataSet {
+public:
+	ControllerSet();
+	virtual ~ControllerSet();
+
+	virtual void setToDefault() = 0;
+	void setInvalid();
+};
+
+#endif /* CONTROLLERSET_H_ */
diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
index cb7a78993..b7dd2cee9 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -1,168 +1,168 @@
-#include <framework/datapool/DataSetBase.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-DataSetBase::DataSetBase(PoolVariableIF** registeredVariablesArray,
-        const size_t maxFillCount):
-        registeredVariables(registeredVariablesArray),
-        maxFillCount(maxFillCount) {
-	for (uint8_t count = 0; count < maxFillCount; count++) {
-		registeredVariables[count] = nullptr;
-	}
-}
-
-DataSetBase::~DataSetBase() {}
-
-ReturnValue_t DataSetBase::registerVariable(
-		PoolVariableIF *variable) {
-	if (state != States::DATA_SET_UNINITIALISED) {
-		sif::error << "DataSet::registerVariable: "
-				"Call made in wrong position." << std::endl;
-		return DataSetIF::DATA_SET_UNINITIALISED;
-	}
-	if (variable == nullptr) {
-		sif::error << "DataSet::registerVariable: "
-				"Pool variable is nullptr." << std::endl;
-		return DataSetIF::POOL_VAR_NULL;
-	}
-	if (fillCount >= maxFillCount) {
-		sif::error << "DataSet::registerVariable: "
-				"DataSet is full." << std::endl;
-		return DataSetIF::DATA_SET_FULL;
-	}
-	registeredVariables[fillCount] = variable;
-	fillCount++;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	if (state == States::DATA_SET_UNINITIALISED) {
-		lockDataPool(lockTimeout);
-		for (uint16_t count = 0; count < fillCount; count++) {
-			result = readVariable(count);
-			if(result != RETURN_OK) {
-				break;
-			}
-		}
-		state = States::DATA_SET_WAS_READ;
-		unlockDataPool();
-	}
-	else {
-		sif::error << "DataSet::read(): "
-				"Call made in wrong position. Don't forget to commit"
-				" member datasets!" << std::endl;
-		result = SET_WAS_ALREADY_READ;
-	}
-	return result;
-}
-
-uint16_t DataSetBase::getFillCount() const {
-    return fillCount;
-}
-
-ReturnValue_t DataSetBase::readVariable(uint16_t count) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	// These checks are often performed by the respective
-	// variable implementation too, but I guess a double check does not hurt.
-	if (registeredVariables[count]->getReadWriteMode() !=
-				PoolVariableIF::VAR_WRITE and
-		registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER)
-	{
-		result = registeredVariables[count]->readWithoutLock();
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			result = INVALID_PARAMETER_DEFINITION;
-		}
-	}
-	return result;
-}
-
-ReturnValue_t DataSetBase::commit(uint32_t lockTimeout) {
-	if (state == States::DATA_SET_WAS_READ) {
-		handleAlreadyReadDatasetCommit(lockTimeout);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return handleUnreadDatasetCommit(lockTimeout);
-	}
-}
-
-void DataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
-	lockDataPool(lockTimeout);
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ
-				&& registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commitWithoutLock();
-		}
-	}
-	state = States::DATA_SET_UNINITIALISED;
-	unlockDataPool();
-}
-
-ReturnValue_t DataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	lockDataPool(lockTimeout);
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				== PoolVariableIF::VAR_WRITE
-				&& registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commitWithoutLock();
-		} else if (registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			if (result != COMMITING_WITHOUT_READING) {
-				sif::error << "DataSet::commit(): commit-without-read call made "
-						"with non write-only variable." << std::endl;
-				result = COMMITING_WITHOUT_READING;
-			}
-		}
-	}
-	state = States::DATA_SET_UNINITIALISED;
-	unlockDataPool();
-	return result;
-}
-
-
-ReturnValue_t DataSetBase::lockDataPool(uint32_t timeoutMs) {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataSetBase::unlockDataPool() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
-		const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		result = registeredVariables[count]->serialize(buffer, size, maxSize,
-		        streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
-        SerializeIF::Endianness streamEndianness) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		result = registeredVariables[count]->deSerialize(buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-size_t DataSetBase::getSerializedSize() const {
-	uint32_t size = 0;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		size += registeredVariables[count]->getSerializedSize();
-	}
-	return size;
-}
+#include "../datapool/DataSetBase.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+DataSetBase::DataSetBase(PoolVariableIF** registeredVariablesArray,
+        const size_t maxFillCount):
+        registeredVariables(registeredVariablesArray),
+        maxFillCount(maxFillCount) {
+	for (uint8_t count = 0; count < maxFillCount; count++) {
+		registeredVariables[count] = nullptr;
+	}
+}
+
+DataSetBase::~DataSetBase() {}
+
+ReturnValue_t DataSetBase::registerVariable(
+		PoolVariableIF *variable) {
+	if (state != States::DATA_SET_UNINITIALISED) {
+		sif::error << "DataSet::registerVariable: "
+				"Call made in wrong position." << std::endl;
+		return DataSetIF::DATA_SET_UNINITIALISED;
+	}
+	if (variable == nullptr) {
+		sif::error << "DataSet::registerVariable: "
+				"Pool variable is nullptr." << std::endl;
+		return DataSetIF::POOL_VAR_NULL;
+	}
+	if (fillCount >= maxFillCount) {
+		sif::error << "DataSet::registerVariable: "
+				"DataSet is full." << std::endl;
+		return DataSetIF::DATA_SET_FULL;
+	}
+	registeredVariables[fillCount] = variable;
+	fillCount++;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	if (state == States::DATA_SET_UNINITIALISED) {
+		lockDataPool(lockTimeout);
+		for (uint16_t count = 0; count < fillCount; count++) {
+			result = readVariable(count);
+			if(result != RETURN_OK) {
+				break;
+			}
+		}
+		state = States::DATA_SET_WAS_READ;
+		unlockDataPool();
+	}
+	else {
+		sif::error << "DataSet::read(): "
+				"Call made in wrong position. Don't forget to commit"
+				" member datasets!" << std::endl;
+		result = SET_WAS_ALREADY_READ;
+	}
+	return result;
+}
+
+uint16_t DataSetBase::getFillCount() const {
+    return fillCount;
+}
+
+ReturnValue_t DataSetBase::readVariable(uint16_t count) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	// These checks are often performed by the respective
+	// variable implementation too, but I guess a double check does not hurt.
+	if (registeredVariables[count]->getReadWriteMode() !=
+				PoolVariableIF::VAR_WRITE and
+		registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER)
+	{
+		result = registeredVariables[count]->readWithoutLock();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			result = INVALID_PARAMETER_DEFINITION;
+		}
+	}
+	return result;
+}
+
+ReturnValue_t DataSetBase::commit(uint32_t lockTimeout) {
+	if (state == States::DATA_SET_WAS_READ) {
+		handleAlreadyReadDatasetCommit(lockTimeout);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return handleUnreadDatasetCommit(lockTimeout);
+	}
+}
+
+void DataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
+	lockDataPool(lockTimeout);
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				!= PoolVariableIF::VAR_READ
+				&& registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			registeredVariables[count]->commitWithoutLock();
+		}
+	}
+	state = States::DATA_SET_UNINITIALISED;
+	unlockDataPool();
+}
+
+ReturnValue_t DataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	lockDataPool(lockTimeout);
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				== PoolVariableIF::VAR_WRITE
+				&& registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			registeredVariables[count]->commitWithoutLock();
+		} else if (registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			if (result != COMMITING_WITHOUT_READING) {
+				sif::error << "DataSet::commit(): commit-without-read call made "
+						"with non write-only variable." << std::endl;
+				result = COMMITING_WITHOUT_READING;
+			}
+		}
+	}
+	state = States::DATA_SET_UNINITIALISED;
+	unlockDataPool();
+	return result;
+}
+
+
+ReturnValue_t DataSetBase::lockDataPool(uint32_t timeoutMs) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataSetBase::unlockDataPool() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
+		const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		result = registeredVariables[count]->serialize(buffer, size, maxSize,
+		        streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
+        SerializeIF::Endianness streamEndianness) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		result = registeredVariables[count]->deSerialize(buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+size_t DataSetBase::getSerializedSize() const {
+	uint32_t size = 0;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		size += registeredVariables[count]->getSerializedSize();
+	}
+	return size;
+}
diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
index cc16aa9e5..ed7eaa281 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -1,149 +1,149 @@
-#ifndef FRAMEWORK_DATAPOOL_DATASETBASE_H_
-#define FRAMEWORK_DATAPOOL_DATASETBASE_H_
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/ipc/MutexIF.h>
-
-/**
- * @brief	The DataSetBase class manages a set of locally checked out variables.
- * @details
- * This class manages a list, where a set of local variables (or pool variables)
- * are registered. They are checked-out (i.e. their values are looked
- * up and copied) with the read call. After the user finishes working with the
- * pool variables, he can write back all variable values to the pool with
- * the commit call. The data set manages locking and freeing the data pool,
- * to ensure that all values are read and written back at once.
- *
- * An internal state manages usage of this class. Variables may only be
- * registered before the read call is made, and the commit call only
- * after the read call.
- *
- * If pool variables are writable and not committed until destruction
- * of the set, the DataSet class automatically sets the valid flag in the
- * data pool to invalid (without) changing the variable's value.
- *
- * The base class lockDataPool und unlockDataPool implementation are empty
- * and should be implemented to protect the underlying pool type.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class DataSetBase: public DataSetIF,
-		public SerializeIF,
-		public HasReturnvaluesIF {
-public:
-
-	/**
-	 * @brief	Creates an empty dataset. Use registerVariable or
-	 * 			supply a pointer to this dataset to PoolVariable
-	 * 			initializations to register pool variables.
-	 */
-	DataSetBase(PoolVariableIF** registeredVariablesArray,
-	        const size_t maxFillCount);
-	virtual~ DataSetBase();
-
-	/**
-	 * @brief	The read call initializes reading out all registered variables.
-	 * @details
-	 * It iterates through the list of registered variables and calls all read()
-	 * functions of the registered pool variables (which read out their values
-	 * from the data pool) which are not write-only.
-	 * In case of an error (e.g. a wrong data type, or an invalid data pool id),
-	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
-	 *
-	 * The data pool is locked during the whole read operation and
-	 * freed afterwards.The state changes to "was written" after this operation.
-	 * @return
-	 * - @c RETURN_OK if all variables were read successfully.
-	 * - @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
-	 * requested variable is invalid.
-	 * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
-	 * commit() in between
-	 */
-	virtual ReturnValue_t read(uint32_t lockTimeout =
-			MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call initializes writing back the registered variables.
-	 * @details
-	 * It iterates through the list of registered variables and calls the
-	 * commit() method of the remaining registered variables (which write back
-	 * their values to the pool).
-	 *
-	 * The data pool is locked during the whole commit operation and
-	 * freed afterwards. The state changes to "was committed" after this operation.
-	 *
-	 * If the set does contain at least one variable which is not write-only
-	 * commit() can only be called after read(). If the set only contains
-	 * variables which are write only, commit() can be called without a
-	 * preceding read() call.
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
-	 * 			  contains non write-only variables
-	 */
-	virtual ReturnValue_t commit(uint32_t lockTimeout =
-			MutexIF::BLOCKING) override;
-
-	/**
-	 * Register the passed pool variable instance into the data set.
-	 * @param variable
-	 * @return
-	 */
-	virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override;
-	/**
-	 * Provides the means to lock the underlying data structure to ensure
-	 * thread-safety. Default implementation is empty
-	 * @return Always returns -@c RETURN_OK
-	 */
-	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs =
-			MutexIF::BLOCKING) override;
-	/**
-	 * Provides the means to unlock the underlying data structure to ensure
-	 * thread-safety. Default implementation is empty
-	 * @return Always returns -@c RETURN_OK
-	 */
-	virtual ReturnValue_t unlockDataPool() override;
-
-	virtual uint16_t getFillCount() const;
-
-	/* SerializeIF implementations */
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const size_t maxSize,
-				SerializeIF::Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override;
-
-protected:
-	/**
-	 * @brief	The fill_count attribute ensures that the variables
-	 * 			register in the correct array position and that the maximum
-	 * 			number of variables is not exceeded.
-	 */
-	uint16_t fillCount = 0;
-	/**
-	 * States of the seet.
-	 */
-	enum class States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
-	};
-	/**
-	 * @brief	state manages the internal state of the data set,
-	 *          which is important e.g. for the behavior on destruction.
-	 */
-	States state = States::DATA_SET_UNINITIALISED;
-
-	/**
-	 * @brief	This array represents all pool variables registered in this set.
-	 * Child classes can use a static or dynamic container to create
-	 * an array of registered variables and assign the first entry here.
-	 */
-	PoolVariableIF** registeredVariables = nullptr;
-	const size_t maxFillCount = 0;
-
-private:
-	ReturnValue_t readVariable(uint16_t count);
-	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
-	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
-};
-
-#endif /* FRAMEWORK_DATAPOOL_DATASETBASE_H_ */
+#ifndef FRAMEWORK_DATAPOOL_DATASETBASE_H_
+#define FRAMEWORK_DATAPOOL_DATASETBASE_H_
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../ipc/MutexIF.h"
+
+/**
+ * @brief	The DataSetBase class manages a set of locally checked out variables.
+ * @details
+ * This class manages a list, where a set of local variables (or pool variables)
+ * are registered. They are checked-out (i.e. their values are looked
+ * up and copied) with the read call. After the user finishes working with the
+ * pool variables, he can write back all variable values to the pool with
+ * the commit call. The data set manages locking and freeing the data pool,
+ * to ensure that all values are read and written back at once.
+ *
+ * An internal state manages usage of this class. Variables may only be
+ * registered before the read call is made, and the commit call only
+ * after the read call.
+ *
+ * If pool variables are writable and not committed until destruction
+ * of the set, the DataSet class automatically sets the valid flag in the
+ * data pool to invalid (without) changing the variable's value.
+ *
+ * The base class lockDataPool und unlockDataPool implementation are empty
+ * and should be implemented to protect the underlying pool type.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class DataSetBase: public DataSetIF,
+		public SerializeIF,
+		public HasReturnvaluesIF {
+public:
+
+	/**
+	 * @brief	Creates an empty dataset. Use registerVariable or
+	 * 			supply a pointer to this dataset to PoolVariable
+	 * 			initializations to register pool variables.
+	 */
+	DataSetBase(PoolVariableIF** registeredVariablesArray,
+	        const size_t maxFillCount);
+	virtual~ DataSetBase();
+
+	/**
+	 * @brief	The read call initializes reading out all registered variables.
+	 * @details
+	 * It iterates through the list of registered variables and calls all read()
+	 * functions of the registered pool variables (which read out their values
+	 * from the data pool) which are not write-only.
+	 * In case of an error (e.g. a wrong data type, or an invalid data pool id),
+	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
+	 *
+	 * The data pool is locked during the whole read operation and
+	 * freed afterwards.The state changes to "was written" after this operation.
+	 * @return
+	 * - @c RETURN_OK if all variables were read successfully.
+	 * - @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
+	 * requested variable is invalid.
+	 * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
+	 * commit() in between
+	 */
+	virtual ReturnValue_t read(uint32_t lockTimeout =
+			MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call initializes writing back the registered variables.
+	 * @details
+	 * It iterates through the list of registered variables and calls the
+	 * commit() method of the remaining registered variables (which write back
+	 * their values to the pool).
+	 *
+	 * The data pool is locked during the whole commit operation and
+	 * freed afterwards. The state changes to "was committed" after this operation.
+	 *
+	 * If the set does contain at least one variable which is not write-only
+	 * commit() can only be called after read(). If the set only contains
+	 * variables which are write only, commit() can be called without a
+	 * preceding read() call.
+	 * @return	- @c RETURN_OK if all variables were read successfully.
+	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
+	 * 			  contains non write-only variables
+	 */
+	virtual ReturnValue_t commit(uint32_t lockTimeout =
+			MutexIF::BLOCKING) override;
+
+	/**
+	 * Register the passed pool variable instance into the data set.
+	 * @param variable
+	 * @return
+	 */
+	virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override;
+	/**
+	 * Provides the means to lock the underlying data structure to ensure
+	 * thread-safety. Default implementation is empty
+	 * @return Always returns -@c RETURN_OK
+	 */
+	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs =
+			MutexIF::BLOCKING) override;
+	/**
+	 * Provides the means to unlock the underlying data structure to ensure
+	 * thread-safety. Default implementation is empty
+	 * @return Always returns -@c RETURN_OK
+	 */
+	virtual ReturnValue_t unlockDataPool() override;
+
+	virtual uint16_t getFillCount() const;
+
+	/* SerializeIF implementations */
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				const size_t maxSize,
+				SerializeIF::Endianness streamEndianness) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override;
+
+protected:
+	/**
+	 * @brief	The fill_count attribute ensures that the variables
+	 * 			register in the correct array position and that the maximum
+	 * 			number of variables is not exceeded.
+	 */
+	uint16_t fillCount = 0;
+	/**
+	 * States of the seet.
+	 */
+	enum class States {
+		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
+		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
+	};
+	/**
+	 * @brief	state manages the internal state of the data set,
+	 *          which is important e.g. for the behavior on destruction.
+	 */
+	States state = States::DATA_SET_UNINITIALISED;
+
+	/**
+	 * @brief	This array represents all pool variables registered in this set.
+	 * Child classes can use a static or dynamic container to create
+	 * an array of registered variables and assign the first entry here.
+	 */
+	PoolVariableIF** registeredVariables = nullptr;
+	const size_t maxFillCount = 0;
+
+private:
+	ReturnValue_t readVariable(uint16_t count);
+	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
+	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
+};
+
+#endif /* FRAMEWORK_DATAPOOL_DATASETBASE_H_ */
diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index 437f324f6..88e82e503 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -1,62 +1,62 @@
-#ifndef DATASETIF_H_
-#define DATASETIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/timemanager/Clock.h>
-class PoolVariableIF;
-
-/**
- * @brief	This class defines a small interface to register on a DataSet.
- *
- * @details
- * Currently, the only purpose of this interface is to provide a
- * method for locally checked-out variables to register on a data set.
- * Still, it may become useful for other purposes as well.
- * @author 	Bastian Baetz
- * @ingroup data_pool
- */
-class DataSetIF {
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
-	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION =
-			MAKE_RETURN_CODE( 0x01 );
-	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
-	static constexpr ReturnValue_t COMMITING_WITHOUT_READING =
-			MAKE_RETURN_CODE(0x03);
-
-	static constexpr ReturnValue_t DATA_SET_UNINITIALISED = MAKE_RETURN_CODE( 0x04 );
-	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE( 0x05 );
-	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE( 0x06 );
-
-	/**
-	 * @brief	This is an empty virtual destructor,
-	 * 			as it is proposed for C++ interfaces.
-	 */
-	virtual ~DataSetIF() {}
-
-	virtual ReturnValue_t read(uint32_t lockTimeout) = 0;
-	virtual ReturnValue_t commit(uint32_t lockTimeout) = 0;
-	/**
-	 * @brief	This operation provides a method to register local data pool
-	 * 			variables to register in a data set by passing itself
-	 * 			to this DataSet operation.
-	 */
-	virtual ReturnValue_t registerVariable(PoolVariableIF* variable) = 0;
-
-	virtual uint16_t getFillCount() const = 0;
-private:
-	/**
-	 * @brief 	Most underlying data structures will have a pool like structure
-	 * 			and will require a lock and unlock mechanism to ensure
-	 * 			thread-safety
-	 * @return Lock operation result
-	 */
-	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs) = 0;
-	/**
-	 * @brief   Unlock call corresponding to the lock call.
-	 * @return Unlock operation result
-	 */
-	virtual ReturnValue_t unlockDataPool() = 0;
-};
-
-#endif /* DATASETIF_H_ */
+#ifndef DATASETIF_H_
+#define DATASETIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Clock.h"
+class PoolVariableIF;
+
+/**
+ * @brief	This class defines a small interface to register on a DataSet.
+ *
+ * @details
+ * Currently, the only purpose of this interface is to provide a
+ * method for locally checked-out variables to register on a data set.
+ * Still, it may become useful for other purposes as well.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
+ */
+class DataSetIF {
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
+	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION =
+			MAKE_RETURN_CODE( 0x01 );
+	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
+	static constexpr ReturnValue_t COMMITING_WITHOUT_READING =
+			MAKE_RETURN_CODE(0x03);
+
+	static constexpr ReturnValue_t DATA_SET_UNINITIALISED = MAKE_RETURN_CODE( 0x04 );
+	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE( 0x05 );
+	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE( 0x06 );
+
+	/**
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is proposed for C++ interfaces.
+	 */
+	virtual ~DataSetIF() {}
+
+	virtual ReturnValue_t read(uint32_t lockTimeout) = 0;
+	virtual ReturnValue_t commit(uint32_t lockTimeout) = 0;
+	/**
+	 * @brief	This operation provides a method to register local data pool
+	 * 			variables to register in a data set by passing itself
+	 * 			to this DataSet operation.
+	 */
+	virtual ReturnValue_t registerVariable(PoolVariableIF* variable) = 0;
+
+	virtual uint16_t getFillCount() const = 0;
+private:
+	/**
+	 * @brief 	Most underlying data structures will have a pool like structure
+	 * 			and will require a lock and unlock mechanism to ensure
+	 * 			thread-safety
+	 * @return Lock operation result
+	 */
+	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs) = 0;
+	/**
+	 * @brief   Unlock call corresponding to the lock call.
+	 * @return Unlock operation result
+	 */
+	virtual ReturnValue_t unlockDataPool() = 0;
+};
+
+#endif /* DATASETIF_H_ */
diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp
index cf5114f75..5a59f94c4 100644
--- a/datapool/HkSwitchHelper.cpp
+++ b/datapool/HkSwitchHelper.cpp
@@ -1,75 +1,75 @@
-#include <framework/datapool/HkSwitchHelper.h>
-#include <framework/ipc/QueueFactory.h>
-
-HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
-		commandActionHelper(this), eventProxy(eventProxy) {
-	actionQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-HkSwitchHelper::~HkSwitchHelper() {
-	// TODO Auto-generated destructor stub
-}
-
-ReturnValue_t HkSwitchHelper::initialize() {
-	ReturnValue_t result = commandActionHelper.initialize();
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	return result;
-}
-
-ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
-	CommandMessage command;
-	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
-		ReturnValue_t result = commandActionHelper.handleReply(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			continue;
-		}
-		command.setToUnknownCommand();
-		actionQueue->reply(&command);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HkSwitchHelper::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {
-}
-
-void HkSwitchHelper::stepFailedReceived(ActionId_t actionId, uint8_t step,
-		ReturnValue_t returnCode) {
-	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
-}
-
-void HkSwitchHelper::dataReceived(ActionId_t actionId, const uint8_t* data,
-		uint32_t size) {
-}
-
-void HkSwitchHelper::completionSuccessfulReceived(ActionId_t actionId) {
-}
-
-void HkSwitchHelper::completionFailedReceived(ActionId_t actionId,
-		ReturnValue_t returnCode) {
-	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
-}
-
-ReturnValue_t HkSwitchHelper::switchHK(SerializeIF* sids, bool enable) {
-//	ActionId_t action = HKService::DISABLE_HK;
-//	if (enable) {
-//		action = HKService::ENABLE_HK;
-//	}
-//
-//	ReturnValue_t result = commandActionHelper.commandAction(
-//			objects::PUS_HK_SERVICE, action, sids);
-//
-//	if (result != HasReturnvaluesIF::RETURN_OK) {
-//		eventProxy->forwardEvent(SWITCHING_TM_FAILED, result);
-//	}
-//	return result;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueIF* HkSwitchHelper::getCommandQueuePtr() {
-	return actionQueue;
-}
+#include "../datapool/HkSwitchHelper.h"
+#include "../ipc/QueueFactory.h"
+
+HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
+		commandActionHelper(this), eventProxy(eventProxy) {
+	actionQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+HkSwitchHelper::~HkSwitchHelper() {
+	// TODO Auto-generated destructor stub
+}
+
+ReturnValue_t HkSwitchHelper::initialize() {
+	ReturnValue_t result = commandActionHelper.initialize();
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return result;
+}
+
+ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
+	CommandMessage command;
+	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
+		ReturnValue_t result = commandActionHelper.handleReply(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			continue;
+		}
+		command.setToUnknownCommand();
+		actionQueue->reply(&command);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void HkSwitchHelper::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {
+}
+
+void HkSwitchHelper::stepFailedReceived(ActionId_t actionId, uint8_t step,
+		ReturnValue_t returnCode) {
+	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
+}
+
+void HkSwitchHelper::dataReceived(ActionId_t actionId, const uint8_t* data,
+		uint32_t size) {
+}
+
+void HkSwitchHelper::completionSuccessfulReceived(ActionId_t actionId) {
+}
+
+void HkSwitchHelper::completionFailedReceived(ActionId_t actionId,
+		ReturnValue_t returnCode) {
+	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
+}
+
+ReturnValue_t HkSwitchHelper::switchHK(SerializeIF* sids, bool enable) {
+//	ActionId_t action = HKService::DISABLE_HK;
+//	if (enable) {
+//		action = HKService::ENABLE_HK;
+//	}
+//
+//	ReturnValue_t result = commandActionHelper.commandAction(
+//			objects::PUS_HK_SERVICE, action, sids);
+//
+//	if (result != HasReturnvaluesIF::RETURN_OK) {
+//		eventProxy->forwardEvent(SWITCHING_TM_FAILED, result);
+//	}
+//	return result;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueIF* HkSwitchHelper::getCommandQueuePtr() {
+	return actionQueue;
+}
diff --git a/datapool/HkSwitchHelper.h b/datapool/HkSwitchHelper.h
index 1a3b62758..de34ab233 100644
--- a/datapool/HkSwitchHelper.h
+++ b/datapool/HkSwitchHelper.h
@@ -1,46 +1,46 @@
-#ifndef FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
-#define FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
-
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/action/CommandsActionsIF.h>
-#include <framework/events/EventReportingProxyIF.h>
-
-//TODO this class violations separation between mission and framework
-//but it is only a transitional solution until the Datapool is
-//implemented decentrally
-
-class HkSwitchHelper: public ExecutableObjectIF, public CommandsActionsIF {
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HK;
-	static const Event SWITCHING_TM_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Commanding the HK Service failed, p1: error code, p2 action: 0 disable / 1 enable
-
-	HkSwitchHelper(EventReportingProxyIF *eventProxy);
-	virtual ~HkSwitchHelper();
-
-	ReturnValue_t initialize();
-
-	virtual ReturnValue_t  performOperation(uint8_t operationCode = 0);
-
-	ReturnValue_t switchHK(SerializeIF *sids, bool enable);
-
-	virtual void setTaskIF(PeriodicTaskIF* task_){};
-
-protected:
-	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step);
-	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
-			ReturnValue_t returnCode);
-	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
-			uint32_t size);
-	virtual void completionSuccessfulReceived(ActionId_t actionId);
-	virtual void completionFailedReceived(ActionId_t actionId,
-			ReturnValue_t returnCode);
-	virtual MessageQueueIF* getCommandQueuePtr();
-
-private:
-	CommandActionHelper commandActionHelper;
-	MessageQueueIF* actionQueue;
-	EventReportingProxyIF *eventProxy;
-};
-
-#endif /* FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ */
+#ifndef FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
+#define FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
+
+#include "../tasks/ExecutableObjectIF.h"
+#include "../action/CommandsActionsIF.h"
+#include "../events/EventReportingProxyIF.h"
+
+//TODO this class violations separation between mission and framework
+//but it is only a transitional solution until the Datapool is
+//implemented decentrally
+
+class HkSwitchHelper: public ExecutableObjectIF, public CommandsActionsIF {
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HK;
+	static const Event SWITCHING_TM_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Commanding the HK Service failed, p1: error code, p2 action: 0 disable / 1 enable
+
+	HkSwitchHelper(EventReportingProxyIF *eventProxy);
+	virtual ~HkSwitchHelper();
+
+	ReturnValue_t initialize();
+
+	virtual ReturnValue_t  performOperation(uint8_t operationCode = 0);
+
+	ReturnValue_t switchHK(SerializeIF *sids, bool enable);
+
+	virtual void setTaskIF(PeriodicTaskIF* task_){};
+
+protected:
+	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step);
+	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
+			ReturnValue_t returnCode);
+	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
+			uint32_t size);
+	virtual void completionSuccessfulReceived(ActionId_t actionId);
+	virtual void completionFailedReceived(ActionId_t actionId,
+			ReturnValue_t returnCode);
+	virtual MessageQueueIF* getCommandQueuePtr();
+
+private:
+	CommandActionHelper commandActionHelper;
+	MessageQueueIF* actionQueue;
+	EventReportingProxyIF *eventProxy;
+};
+
+#endif /* FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ */
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index d535a72b6..a21d521f5 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,87 +1,87 @@
-#include <framework/datapool/PoolEntry.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/globalfunctions/arrayprinter.h>
-#include <cstring>
-
-template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
-		bool setValid ) : length(setLength), valid(setValid) {
-	this->address = new T[this->length];
-	if(initValue.size() == 0) {
-		std::memset(this->address, 0, this->getByteSize());
-	}
-	else if (initValue.size() != setLength){
-		sif::warning << "PoolEntry: setLength is not equal to initializer list"
-				"length! Performing zero initialization with given setLength"
-				<< std::endl;
-		std::memset(this->address, 0, this->getByteSize());
-	}
-	else {
-		std::copy(initValue.begin(), initValue.end(), this->address);
-	}
-}
-
-template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t setLength, bool setValid ) :
-		length(setLength), valid(setValid) {
-	this->address = new T[this->length];
-	if (initValue != nullptr) {
-		std::memcpy(this->address, initValue, this->getByteSize() );
-	} else {
-		std::memset(this->address, 0, this->getByteSize() );
-	}
-}
-
-//As the data pool is global, this dtor is only be called on program exit.
-//Warning! Never copy pool entries!
-template <typename T>
-PoolEntry<T>::~PoolEntry() {
-	delete[] this->address;
-}
-
-template <typename T>
-uint16_t PoolEntry<T>::getByteSize() {
-	return ( sizeof(T) * this->length );
-}
-
-template <typename T>
-uint8_t PoolEntry<T>::getSize() {
-	return this->length;
-}
-
-template <typename T>
-void* PoolEntry<T>::getRawData() {
-	return this->address;
-}
-
-template <typename T>
-void PoolEntry<T>::setValid(bool isValid) {
-	this->valid = isValid;
-}
-
-template <typename T>
-bool PoolEntry<T>::getValid() {
-	return valid;
-}
-
-template <typename T>
-void PoolEntry<T>::print() {
-	 sif::debug << "Pool Entry Validity: " <<
-			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
-	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
-	sif::debug << std::dec << std::endl;
-}
-
-template<typename T>
-Type PoolEntry<T>::getType() {
-	return PodTypeConversion<T>::type;
-}
-
-template class PoolEntry<uint8_t>;
-template class PoolEntry<uint16_t>;
-template class PoolEntry<uint32_t>;
-template class PoolEntry<int8_t>;
-template class PoolEntry<int16_t>;
-template class PoolEntry<int32_t>;
-template class PoolEntry<float>;
-template class PoolEntry<double>;
+#include "../datapool/PoolEntry.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../globalfunctions/arrayprinter.h"
+#include <cstring>
+
+template <typename T>
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
+		bool setValid ) : length(setLength), valid(setValid) {
+	this->address = new T[this->length];
+	if(initValue.size() == 0) {
+		std::memset(this->address, 0, this->getByteSize());
+	}
+	else if (initValue.size() != setLength){
+		sif::warning << "PoolEntry: setLength is not equal to initializer list"
+				"length! Performing zero initialization with given setLength"
+				<< std::endl;
+		std::memset(this->address, 0, this->getByteSize());
+	}
+	else {
+		std::copy(initValue.begin(), initValue.end(), this->address);
+	}
+}
+
+template <typename T>
+PoolEntry<T>::PoolEntry( T* initValue, uint8_t setLength, bool setValid ) :
+		length(setLength), valid(setValid) {
+	this->address = new T[this->length];
+	if (initValue != nullptr) {
+		std::memcpy(this->address, initValue, this->getByteSize() );
+	} else {
+		std::memset(this->address, 0, this->getByteSize() );
+	}
+}
+
+//As the data pool is global, this dtor is only be called on program exit.
+//Warning! Never copy pool entries!
+template <typename T>
+PoolEntry<T>::~PoolEntry() {
+	delete[] this->address;
+}
+
+template <typename T>
+uint16_t PoolEntry<T>::getByteSize() {
+	return ( sizeof(T) * this->length );
+}
+
+template <typename T>
+uint8_t PoolEntry<T>::getSize() {
+	return this->length;
+}
+
+template <typename T>
+void* PoolEntry<T>::getRawData() {
+	return this->address;
+}
+
+template <typename T>
+void PoolEntry<T>::setValid(bool isValid) {
+	this->valid = isValid;
+}
+
+template <typename T>
+bool PoolEntry<T>::getValid() {
+	return valid;
+}
+
+template <typename T>
+void PoolEntry<T>::print() {
+	 sif::debug << "Pool Entry Validity: " <<
+			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
+	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
+	sif::debug << std::dec << std::endl;
+}
+
+template<typename T>
+Type PoolEntry<T>::getType() {
+	return PodTypeConversion<T>::type;
+}
+
+template class PoolEntry<uint8_t>;
+template class PoolEntry<uint16_t>;
+template class PoolEntry<uint32_t>;
+template class PoolEntry<int8_t>;
+template class PoolEntry<int16_t>;
+template class PoolEntry<int32_t>;
+template class PoolEntry<float>;
+template class PoolEntry<double>;
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 1a22bb638..67891af88 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -1,130 +1,130 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
-
-#include <framework/datapool/PoolEntryIF.h>
-
-#include <initializer_list>
-#include <type_traits>
-#include <cstddef>
-
-/**
- * @brief	This is a small helper class that defines a single data pool entry.
- * @details
- * The helper is used to store all information together with the data as a
- * single data pool entry. The content's type is defined by the template
- * argument.
- *
- * It is prepared for use with plain old data types, but may be
- * extended to complex types if necessary. It can be initialized with a
- * certain value, size and validity flag.
- *
- * It holds a pointer to the real data and offers methods to access this data
- * and to acquire additional information (such as validity and array/byte size).
- * It is NOT intended to be used outside DataPool implementations as it performs
- * dynamic memory allocation.
- *
- * @ingroup data_pool
- */
-template <typename T>
-class PoolEntry : public PoolEntryIF {
-public:
-	static_assert(not std::is_same<T, bool>::value,
-				"Do not use boolean for the PoolEntry type, use uint8_t "
-				"instead! The ECSS standard defines a boolean as a one bit "
-				"field. Therefore it is preferred to store a boolean as an "
-				"uint8_t");
-	/**
-	 * @brief	In the classe's constructor, space is allocated on the heap and
-	 * 			potential init values are copied to that space.
-	 * @details
-	 * Not passing any arguments will initialize an non-array pool entry
-	 * (setLength = 1) with an initial invalid state.
-	 * Please note that if an initializer list is passed, the correct
-	 * corresponding length should be passed too, otherwise a zero
-	 * initialization will be performed with the given setLength.
-	 * @param initValue
-	 * Initializer list with values to initialize with, for example {0,0} to
-	 * initialize the two entries to zero.
-	 * @param setLength
-	 * Defines the array length of this entry. Should be equal to the
-	 * intializer list length.
-	 * @param setValid
-	 * Sets the initialization flag. It is invalid by default.
-	 */
-	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
-			bool setValid = false);
-	/**
-	 * @brief	In the classe's constructor, space is allocated on the heap and
-	 * 			potential init values are copied to that space.
-	 * @param initValue
-	 * A pointer to the single value or array that holds the init value.
-	 * With the default value (nullptr), the entry is initalized with all 0.
-	 * @param setLength
-	 * Defines the array length of this entry.
-	 * @param setValid
-	 * Sets the initialization flag. It is invalid by default.
-	 */
-	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
-
-	//! Explicitely deleted copy ctor, copying is not allowed!
-	PoolEntry(const PoolEntry&) = delete;
-	//! Explicitely deleted copy assignment, copying is not allowed!
-	PoolEntry& operator=(const PoolEntry&) = delete;
-
-	/**
-	 * @brief	The allocated memory for the variable is freed
-	 * 			in the destructor.
-	 * @details
-	 * As the data pool is global, this dtor is only called on program exit.
-	 * PoolEntries shall never be copied, as a copy might delete the variable
-	 * on the heap.
-	 */
-	~PoolEntry();
-
-	/**
-	 * @brief	This is the address pointing to the allocated memory.
-	 */
-	T* address;
-	/**
-	 * @brief	This attribute stores the length information.
-	 */
-	uint8_t length;
-	/**
-	 * @brief	Here, the validity information for a variable is stored.
-	 * 			Every entry (single variable or vector) has one valid flag.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	getSize returns the array size of the entry.
-	 * @details	A single parameter has size 1.
-	 */
-	uint8_t getSize();
-	/**
-	 * @brief	This operation returns the size in bytes.
-	 * @details	The size is calculated by sizeof(type) * array_size.
-	 */
-	uint16_t getByteSize();
-	/**
-	 * @brief	This operation returns a the address pointer casted to void*.
-	 */
-	void* getRawData();
-	/**
-	 * @brief	This method allows to set the valid information
-	 * 			of the pool entry.
-	 */
-	void setValid( bool isValid );
-	/**
-	 * @brief	This method allows to get the valid information
-	 * 			of the pool entry.
-	 */
-	bool getValid();
-	/**
-	 * @brief	This is a debug method that prints all values and the valid
-	 * 			information to the screen. It prints all array entries in a row.
-	 */
-	void print();
-
-	Type getType();
-};
-
-#endif /* POOLENTRY_H_ */
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
+#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
+
+#include "../datapool/PoolEntryIF.h"
+
+#include <initializer_list>
+#include <type_traits>
+#include <cstddef>
+
+/**
+ * @brief	This is a small helper class that defines a single data pool entry.
+ * @details
+ * The helper is used to store all information together with the data as a
+ * single data pool entry. The content's type is defined by the template
+ * argument.
+ *
+ * It is prepared for use with plain old data types, but may be
+ * extended to complex types if necessary. It can be initialized with a
+ * certain value, size and validity flag.
+ *
+ * It holds a pointer to the real data and offers methods to access this data
+ * and to acquire additional information (such as validity and array/byte size).
+ * It is NOT intended to be used outside DataPool implementations as it performs
+ * dynamic memory allocation.
+ *
+ * @ingroup data_pool
+ */
+template <typename T>
+class PoolEntry : public PoolEntryIF {
+public:
+	static_assert(not std::is_same<T, bool>::value,
+				"Do not use boolean for the PoolEntry type, use uint8_t "
+				"instead! The ECSS standard defines a boolean as a one bit "
+				"field. Therefore it is preferred to store a boolean as an "
+				"uint8_t");
+	/**
+	 * @brief	In the classe's constructor, space is allocated on the heap and
+	 * 			potential init values are copied to that space.
+	 * @details
+	 * Not passing any arguments will initialize an non-array pool entry
+	 * (setLength = 1) with an initial invalid state.
+	 * Please note that if an initializer list is passed, the correct
+	 * corresponding length should be passed too, otherwise a zero
+	 * initialization will be performed with the given setLength.
+	 * @param initValue
+	 * Initializer list with values to initialize with, for example {0,0} to
+	 * initialize the two entries to zero.
+	 * @param setLength
+	 * Defines the array length of this entry. Should be equal to the
+	 * intializer list length.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
+	 */
+	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
+			bool setValid = false);
+	/**
+	 * @brief	In the classe's constructor, space is allocated on the heap and
+	 * 			potential init values are copied to that space.
+	 * @param initValue
+	 * A pointer to the single value or array that holds the init value.
+	 * With the default value (nullptr), the entry is initalized with all 0.
+	 * @param setLength
+	 * Defines the array length of this entry.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
+	 */
+	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
+
+	//! Explicitely deleted copy ctor, copying is not allowed!
+	PoolEntry(const PoolEntry&) = delete;
+	//! Explicitely deleted copy assignment, copying is not allowed!
+	PoolEntry& operator=(const PoolEntry&) = delete;
+
+	/**
+	 * @brief	The allocated memory for the variable is freed
+	 * 			in the destructor.
+	 * @details
+	 * As the data pool is global, this dtor is only called on program exit.
+	 * PoolEntries shall never be copied, as a copy might delete the variable
+	 * on the heap.
+	 */
+	~PoolEntry();
+
+	/**
+	 * @brief	This is the address pointing to the allocated memory.
+	 */
+	T* address;
+	/**
+	 * @brief	This attribute stores the length information.
+	 */
+	uint8_t length;
+	/**
+	 * @brief	Here, the validity information for a variable is stored.
+	 * 			Every entry (single variable or vector) has one valid flag.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	getSize returns the array size of the entry.
+	 * @details	A single parameter has size 1.
+	 */
+	uint8_t getSize();
+	/**
+	 * @brief	This operation returns the size in bytes.
+	 * @details	The size is calculated by sizeof(type) * array_size.
+	 */
+	uint16_t getByteSize();
+	/**
+	 * @brief	This operation returns a the address pointer casted to void*.
+	 */
+	void* getRawData();
+	/**
+	 * @brief	This method allows to set the valid information
+	 * 			of the pool entry.
+	 */
+	void setValid( bool isValid );
+	/**
+	 * @brief	This method allows to get the valid information
+	 * 			of the pool entry.
+	 */
+	bool getValid();
+	/**
+	 * @brief	This is a debug method that prints all values and the valid
+	 * 			information to the screen. It prints all array entries in a row.
+	 */
+	void print();
+
+	Type getType();
+};
+
+#endif /* POOLENTRY_H_ */
diff --git a/datapool/PoolEntryIF.h b/datapool/PoolEntryIF.h
index a075436e2..a9fb44ef3 100644
--- a/datapool/PoolEntryIF.h
+++ b/datapool/PoolEntryIF.h
@@ -1,63 +1,63 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-
-#include <framework/globalfunctions/Type.h>
-#include <cstdint>
-
-/**
- * @brief	This interface defines the access possibilities to a
- * 			single data pool entry.
- * @details
- * The interface provides methods to determine the size and the validity
- * information of a value. It also defines a method to receive a pointer to the
- * raw data content. It is mainly used by DataPool itself, but also as a
- * return pointer.
- *
- * @author	Bastian Baetz
- * @ingroup data_pool
- *
- */
-class PoolEntryIF {
-public:
-	/**
-	 * @brief	This is an empty virtual destructor,
-	 * 			as it is required for C++ interfaces.
-	 */
-	virtual ~PoolEntryIF() {
-	}
-	/**
-	 * @brief	getSize returns the array size of the entry.
-	 * 			A single variable parameter has size 1.
-	 */
-	virtual uint8_t getSize() = 0;
-	/**
-	 * @brief	This operation returns the size in bytes, which is calculated by
-	 * 			sizeof(type) * array_size.
-	 */
-	virtual uint16_t getByteSize() = 0;
-	/**
-	 * @brief	This operation returns a the address pointer casted to void*.
-	 */
-	virtual void* getRawData() = 0;
-	/**
-	 * @brief	This method allows to set the valid information of the pool entry.
-	 */
-	virtual void setValid(bool isValid) = 0;
-	/**
-	 * @brief	This method allows to set the valid information of the pool entry.
-	 */
-	virtual bool getValid() = 0;
-	/**
-	 * @brief	This is a debug method that prints all values and the valid
-	 * 			information to the screen. It prints all array entries in a row.
-	 * @details
-	 * Also displays whether the pool entry is valid or invalid.
-	 */
-	virtual void print() = 0;
-	/**
-	 * Returns the type of the entry.
-	 */
-	virtual Type getType() = 0;
-};
-
-#endif /* POOLENTRYIF_H_ */
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+
+#include "../globalfunctions/Type.h"
+#include <cstdint>
+
+/**
+ * @brief	This interface defines the access possibilities to a
+ * 			single data pool entry.
+ * @details
+ * The interface provides methods to determine the size and the validity
+ * information of a value. It also defines a method to receive a pointer to the
+ * raw data content. It is mainly used by DataPool itself, but also as a
+ * return pointer.
+ *
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ *
+ */
+class PoolEntryIF {
+public:
+	/**
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is required for C++ interfaces.
+	 */
+	virtual ~PoolEntryIF() {
+	}
+	/**
+	 * @brief	getSize returns the array size of the entry.
+	 * 			A single variable parameter has size 1.
+	 */
+	virtual uint8_t getSize() = 0;
+	/**
+	 * @brief	This operation returns the size in bytes, which is calculated by
+	 * 			sizeof(type) * array_size.
+	 */
+	virtual uint16_t getByteSize() = 0;
+	/**
+	 * @brief	This operation returns a the address pointer casted to void*.
+	 */
+	virtual void* getRawData() = 0;
+	/**
+	 * @brief	This method allows to set the valid information of the pool entry.
+	 */
+	virtual void setValid(bool isValid) = 0;
+	/**
+	 * @brief	This method allows to set the valid information of the pool entry.
+	 */
+	virtual bool getValid() = 0;
+	/**
+	 * @brief	This is a debug method that prints all values and the valid
+	 * 			information to the screen. It prints all array entries in a row.
+	 * @details
+	 * Also displays whether the pool entry is valid or invalid.
+	 */
+	virtual void print() = 0;
+	/**
+	 * Returns the type of the entry.
+	 */
+	virtual Type getType() = 0;
+};
+
+#endif /* POOLENTRYIF_H_ */
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 2324a56cd..272bb5023 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -5,10 +5,10 @@
  * @author R. Mueller
  */
 
-#include <framework/datapool/PoolRawAccessHelper.h>
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../datapool/PoolRawAccessHelper.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 
 #include <cmath>
 #include <cstring>
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 0d8f8d6d0..a09f7a2f7 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -7,9 +7,9 @@
 #ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
 #define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/PoolRawAccess.h>
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/PoolRawAccess.h"
 
 /**
  * @brief 	This helper function simplifies accessing data pool entries
diff --git a/datapool/PoolVarList.h b/datapool/PoolVarList.h
index 9d6bc461a..10c0e074a 100644
--- a/datapool/PoolVarList.h
+++ b/datapool/PoolVarList.h
@@ -1,28 +1,28 @@
-#ifndef POOLVARLIST_H_
-#define POOLVARLIST_H_
-
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-template <class T, uint8_t n_var>
-class PoolVarList {
-private:
-	GlobPoolVar<T> variables[n_var];
-public:
-	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
-		//I really should have a look at the new init list c++ syntax.
-		if (dataSet == NULL) {
-			return;
-		}
-		for (uint8_t count = 0; count < n_var; count++) {
-			variables[count].dataPoolId = set_id[count];
-			variables[count].readWriteMode = setReadWriteMode;
-			dataSet->registerVariable(&variables[count]);
-		}
-	}
-
-	GlobPoolVar<T> &operator [](int i) { return variables[i]; }
-};
-
-
-
-#endif /* POOLVARLIST_H_ */
+#ifndef POOLVARLIST_H_
+#define POOLVARLIST_H_
+
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+template <class T, uint8_t n_var>
+class PoolVarList {
+private:
+	GlobPoolVar<T> variables[n_var];
+public:
+	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
+		//I really should have a look at the new init list c++ syntax.
+		if (dataSet == NULL) {
+			return;
+		}
+		for (uint8_t count = 0; count < n_var; count++) {
+			variables[count].dataPoolId = set_id[count];
+			variables[count].readWriteMode = setReadWriteMode;
+			dataSet->registerVariable(&variables[count]);
+		}
+	}
+
+	GlobPoolVar<T> &operator [](int i) { return variables[i]; }
+};
+
+
+
+#endif /* POOLVARLIST_H_ */
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 30b87839b..fc59ccd92 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -1,99 +1,99 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
-#define FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeIF.h>
-
-/**
- * @brief	This interface is used to control data pool
- * 			variable representations.
- * @details
- * To securely handle data pool variables, all pool entries are locally
- * managed by data pool variable access classes, which are called pool
- * variables. To ensure a common state of a set of variables needed in a
- * function, these local pool variables again are managed by other classes,
- * like the DataSet classes. This interface provides unified access to
- * local pool variables for such manager classes.
- * @author 	Bastian Baetz
- * @ingroup data_pool
- */
-class PoolVariableIF : public SerializeIF {
-	friend class DataSetBase;
-	friend class GlobDataSet;
-	friend class LocalDataSet;
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
-	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
-
-	static constexpr bool VALID = 1;
-	static constexpr bool INVALID = 0;
-	static constexpr uint32_t NO_PARAMETER = 0xffffffff;
-
-	enum ReadWriteMode_t {
-		VAR_READ, VAR_WRITE, VAR_READ_WRITE
-	};
-
-	/**
-	 * @brief	This is an empty virtual destructor,
-	 * 			as it is proposed for C++ interfaces.
-	 */
-	virtual ~PoolVariableIF() {}
-	/**
-	 * @brief	This method returns if the variable is write-only,
-	 * 			read-write or read-only.
-	 */
-	virtual ReadWriteMode_t getReadWriteMode() const = 0;
-	/**
-	 * @brief	This operation shall return the data pool id of the variable.
-	 */
-	virtual uint32_t getDataPoolId() const = 0;
-	/**
-	 * @brief	With this call, the valid information of the
-	 * 			variable is returned.
-	 */
-	virtual bool isValid() const = 0;
-	/**
-	 * @brief	With this call, the valid information of the variable is set.
-	 */
-	virtual void setValid(bool validity) = 0;
-
-	/**
-	 * @brief	The commit call shall write back a newly calculated local
-	 * 			value to the data pool.
-	 * @details
-	 * It is assumed that these calls are implemented in a thread-safe manner!
-	 */
-	virtual ReturnValue_t commit(uint32_t lockTimeout) = 0;
-	/**
-	 * @brief	The read call shall read the value of this parameter from
-	 * 			the data pool and store the content locally.
-	 * @details
-	 * It is assumbed that these calls are implemented in a thread-safe manner!
-	 */
-	virtual ReturnValue_t read(uint32_t lockTimeout) = 0;
-
-protected:
-
-	/**
-	 * @brief 	Same as commit with the difference that comitting will be
-	 * 			performed without a lock
-	 * @return
-	 * This can be used if the lock protection is handled externally
-	 * to avoid the overhead of locking and unlocking consecutively.
-	 * Declared protected to avoid free public usage.
-	 */
-	virtual ReturnValue_t readWithoutLock() = 0;
-	/**
-	 * @brief 	Same as commit with the difference that comitting will be
-	 * 			performed without a lock
-	 * @return
-	 * This can be used if the lock protection is handled externally
-	 * to avoid the overhead of locking and unlocking consecutively.
-	 * Declared protected to avoid free public usage.
-	 */
-	virtual ReturnValue_t commitWithoutLock() = 0;
-};
-
-using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
-
-#endif /* POOLVARIABLEIF_H_ */
+#ifndef FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
+#define FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+
+/**
+ * @brief	This interface is used to control data pool
+ * 			variable representations.
+ * @details
+ * To securely handle data pool variables, all pool entries are locally
+ * managed by data pool variable access classes, which are called pool
+ * variables. To ensure a common state of a set of variables needed in a
+ * function, these local pool variables again are managed by other classes,
+ * like the DataSet classes. This interface provides unified access to
+ * local pool variables for such manager classes.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
+ */
+class PoolVariableIF : public SerializeIF {
+	friend class DataSetBase;
+	friend class GlobDataSet;
+	friend class LocalDataSet;
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
+	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
+
+	static constexpr bool VALID = 1;
+	static constexpr bool INVALID = 0;
+	static constexpr uint32_t NO_PARAMETER = 0xffffffff;
+
+	enum ReadWriteMode_t {
+		VAR_READ, VAR_WRITE, VAR_READ_WRITE
+	};
+
+	/**
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is proposed for C++ interfaces.
+	 */
+	virtual ~PoolVariableIF() {}
+	/**
+	 * @brief	This method returns if the variable is write-only,
+	 * 			read-write or read-only.
+	 */
+	virtual ReadWriteMode_t getReadWriteMode() const = 0;
+	/**
+	 * @brief	This operation shall return the data pool id of the variable.
+	 */
+	virtual uint32_t getDataPoolId() const = 0;
+	/**
+	 * @brief	With this call, the valid information of the
+	 * 			variable is returned.
+	 */
+	virtual bool isValid() const = 0;
+	/**
+	 * @brief	With this call, the valid information of the variable is set.
+	 */
+	virtual void setValid(bool validity) = 0;
+
+	/**
+	 * @brief	The commit call shall write back a newly calculated local
+	 * 			value to the data pool.
+	 * @details
+	 * It is assumed that these calls are implemented in a thread-safe manner!
+	 */
+	virtual ReturnValue_t commit(uint32_t lockTimeout) = 0;
+	/**
+	 * @brief	The read call shall read the value of this parameter from
+	 * 			the data pool and store the content locally.
+	 * @details
+	 * It is assumbed that these calls are implemented in a thread-safe manner!
+	 */
+	virtual ReturnValue_t read(uint32_t lockTimeout) = 0;
+
+protected:
+
+	/**
+	 * @brief 	Same as commit with the difference that comitting will be
+	 * 			performed without a lock
+	 * @return
+	 * This can be used if the lock protection is handled externally
+	 * to avoid the overhead of locking and unlocking consecutively.
+	 * Declared protected to avoid free public usage.
+	 */
+	virtual ReturnValue_t readWithoutLock() = 0;
+	/**
+	 * @brief 	Same as commit with the difference that comitting will be
+	 * 			performed without a lock
+	 * @return
+	 * This can be used if the lock protection is handled externally
+	 * to avoid the overhead of locking and unlocking consecutively.
+	 * Declared protected to avoid free public usage.
+	 */
+	virtual ReturnValue_t commitWithoutLock() = 0;
+};
+
+using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
+
+#endif /* POOLVARIABLEIF_H_ */
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 4d0e5530f..669bcc00c 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,300 +1,300 @@
-#include <framework/datapoolglob/DataPoolAdmin.h>
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapoolglob/PoolRawAccess.h>
-#include <framework/ipc/CommandMessage.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/parameters/ParameterMessage.h>
-
-DataPoolAdmin::DataPoolAdmin(object_id_t objectId) :
-		SystemObject(objectId), storage(NULL), commandQueue(NULL), memoryHelper(
-				this, NULL), actionHelper(this, NULL) {
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-DataPoolAdmin::~DataPoolAdmin() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t DataPoolAdmin::performOperation(uint8_t opCode) {
-	handleCommand();
-	return RETURN_OK;
-}
-
-MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
-	if (actionId != SET_VALIDITY) {
-		return INVALID_ACTION_ID;
-	}
-
-	if (size != 5) {
-		return INVALID_PARAMETERS;
-	}
-
-	uint32_t address = (data[0] << 24) | (data[1] << 16) | (data[2] << 8)
-			| data[3];
-
-	uint8_t valid = data[4];
-
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-
-	GlobDataSet mySet;
-	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
-	ReturnValue_t status = mySet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	if (valid != 0) {
-		variable.setValid(PoolVariableIF::VALID);
-	} else {
-		variable.setValid(PoolVariableIF::INVALID);
-	}
-
-	mySet.commit();
-
-	return EXECUTION_FINISHED;
-}
-
-ReturnValue_t DataPoolAdmin::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-void DataPoolAdmin::handleCommand() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != RETURN_OK) {
-		return;
-	}
-
-	result = actionHelper.handleActionMessage(&command);
-
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-
-	result = handleParameterCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-
-	result = memoryHelper.handleMemoryCommand(&command);
-	if (result != RETURN_OK) {
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
-}
-
-ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
-		const uint8_t* data, size_t size, uint8_t** dataPointer) {
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
-	GlobDataSet testSet;
-	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
-			PoolVariableIF::VAR_READ);
-	ReturnValue_t status = testSet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	uint8_t typeSize = varToGetSize.getSizeOfType();
-
-	if (size % typeSize != 0) {
-		return INVALID_SIZE;
-	}
-
-	if (size > varToGetSize.getSizeTillEnd()) {
-		return INVALID_SIZE;
-	}
-	const uint8_t* readPosition = data;
-
-	for (; size > 0; size -= typeSize) {
-		GlobDataSet rawSet;
-		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
-				PoolVariableIF::VAR_READ_WRITE);
-		status = rawSet.read();
-		if (status == RETURN_OK) {
-			status = variable.setEntryFromBigEndian(readPosition, typeSize);
-			if (status == RETURN_OK) {
-				status = rawSet.commit();
-			}
-		}
-		arrayIndex += 1;
-		readPosition += typeSize;
-	}
-	return ACTIVITY_COMPLETED;
-}
-
-ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
-		uint8_t** dataPointer, uint8_t* copyHere) {
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
-	GlobDataSet testSet;
-	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
-			PoolVariableIF::VAR_READ);
-	ReturnValue_t status = testSet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	uint8_t typeSize = varToGetSize.getSizeOfType();
-	if (size > varToGetSize.getSizeTillEnd()) {
-		return INVALID_SIZE;
-	}
-	uint8_t* ptrToCopy = copyHere;
-	for (; size > 0; size -= typeSize) {
-		GlobDataSet rawSet;
-		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
-				PoolVariableIF::VAR_READ);
-		status = rawSet.read();
-		if (status == RETURN_OK) {
-			size_t temp = 0;
-			status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
-			if (status != RETURN_OK) {
-				return RETURN_FAILED;
-			}
-		} else {
-			//Error reading parameter.
-		}
-		arrayIndex += 1;
-		ptrToCopy += typeSize;
-	}
-	return ACTIVITY_COMPLETED;
-}
-
-ReturnValue_t DataPoolAdmin::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = memoryHelper.initialize(commandQueue);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (storage == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	result = actionHelper.initialize(commandQueue);
-
-	return result;
-}
-
-//mostly identical to ParameterHelper::handleParameterMessage()
-ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch (command->getCommand()) {
-	case ParameterMessage::CMD_PARAMETER_DUMP: {
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(command));
-
-		DataPoolParameterWrapper wrapper;
-		result = wrapper.set(domain, parameterId);
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(command->getSender(),
-					ParameterMessage::getParameterId(command), &wrapper);
-		}
-	}
-		break;
-	case ParameterMessage::CMD_PARAMETER_LOAD: {
-
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(command));
-		uint8_t index = HasParametersIF::getIndex(
-				ParameterMessage::getParameterId(command));
-
-		const uint8_t *storedStream;
-		size_t storedStreamSize;
-		result = storage->getData(ParameterMessage::getStoreId(command),
-				&storedStream, &storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-
-		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(storedStream, storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(command));
-			break;
-		}
-
-		DataPoolParameterWrapper poolWrapper;
-		result = poolWrapper.set(domain, parameterId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(command));
-			break;
-		}
-
-		result = poolWrapper.copyFrom(&streamWrapper, index);
-
-		storage->deleteData(ParameterMessage::getStoreId(command));
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(command->getSender(),
-					ParameterMessage::getParameterId(command), &poolWrapper);
-		}
-	}
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		rejectCommand(command->getSender(), result, command->getCommand());
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-//identical to ParameterHelper::sendParameter()
-ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
-		const DataPoolParameterWrapper* wrapper) {
-	size_t serializedSize = wrapper->getSerializedSize();
-
-	uint8_t *storeElement;
-	store_address_t address;
-
-	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
-			&storeElement);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	size_t storeElementSize = 0;
-
-	result = wrapper->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		storage->deleteData(address);
-		return result;
-	}
-
-	CommandMessage reply;
-
-	ParameterMessage::setParameterDumpReply(&reply, id, address);
-
-	commandQueue->sendMessage(to, &reply);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//identical to ParameterHelper::rejectCommand()
-void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-		Command_t initialCommand) {
-	CommandMessage reply;
-	reply.setReplyRejected(reason, initialCommand);
-	commandQueue->sendMessage(to, &reply);
-}
+#include "../datapoolglob/DataPoolAdmin.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../ipc/CommandMessage.h"
+#include "../ipc/QueueFactory.h"
+#include "../parameters/ParameterMessage.h"
+
+DataPoolAdmin::DataPoolAdmin(object_id_t objectId) :
+		SystemObject(objectId), storage(NULL), commandQueue(NULL), memoryHelper(
+				this, NULL), actionHelper(this, NULL) {
+	commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+DataPoolAdmin::~DataPoolAdmin() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t DataPoolAdmin::performOperation(uint8_t opCode) {
+	handleCommand();
+	return RETURN_OK;
+}
+
+MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
+	if (actionId != SET_VALIDITY) {
+		return INVALID_ACTION_ID;
+	}
+
+	if (size != 5) {
+		return INVALID_PARAMETERS;
+	}
+
+	uint32_t address = (data[0] << 24) | (data[1] << 16) | (data[2] << 8)
+			| data[3];
+
+	uint8_t valid = data[4];
+
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+
+	GlobDataSet mySet;
+	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
+	ReturnValue_t status = mySet.read();
+	if (status != RETURN_OK) {
+		return INVALID_ADDRESS;
+	}
+	if (valid != 0) {
+		variable.setValid(PoolVariableIF::VALID);
+	} else {
+		variable.setValid(PoolVariableIF::INVALID);
+	}
+
+	mySet.commit();
+
+	return EXECUTION_FINISHED;
+}
+
+ReturnValue_t DataPoolAdmin::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+void DataPoolAdmin::handleCommand() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != RETURN_OK) {
+		return;
+	}
+
+	result = actionHelper.handleActionMessage(&command);
+
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+
+	result = handleParameterCommand(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+
+	result = memoryHelper.handleMemoryCommand(&command);
+	if (result != RETURN_OK) {
+		command.setToUnknownCommand();
+		commandQueue->reply(&command);
+	}
+}
+
+ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
+		const uint8_t* data, size_t size, uint8_t** dataPointer) {
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
+	GlobDataSet testSet;
+	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
+			PoolVariableIF::VAR_READ);
+	ReturnValue_t status = testSet.read();
+	if (status != RETURN_OK) {
+		return INVALID_ADDRESS;
+	}
+	uint8_t typeSize = varToGetSize.getSizeOfType();
+
+	if (size % typeSize != 0) {
+		return INVALID_SIZE;
+	}
+
+	if (size > varToGetSize.getSizeTillEnd()) {
+		return INVALID_SIZE;
+	}
+	const uint8_t* readPosition = data;
+
+	for (; size > 0; size -= typeSize) {
+		GlobDataSet rawSet;
+		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
+				PoolVariableIF::VAR_READ_WRITE);
+		status = rawSet.read();
+		if (status == RETURN_OK) {
+			status = variable.setEntryFromBigEndian(readPosition, typeSize);
+			if (status == RETURN_OK) {
+				status = rawSet.commit();
+			}
+		}
+		arrayIndex += 1;
+		readPosition += typeSize;
+	}
+	return ACTIVITY_COMPLETED;
+}
+
+ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
+		uint8_t** dataPointer, uint8_t* copyHere) {
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
+	GlobDataSet testSet;
+	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
+			PoolVariableIF::VAR_READ);
+	ReturnValue_t status = testSet.read();
+	if (status != RETURN_OK) {
+		return INVALID_ADDRESS;
+	}
+	uint8_t typeSize = varToGetSize.getSizeOfType();
+	if (size > varToGetSize.getSizeTillEnd()) {
+		return INVALID_SIZE;
+	}
+	uint8_t* ptrToCopy = copyHere;
+	for (; size > 0; size -= typeSize) {
+		GlobDataSet rawSet;
+		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
+				PoolVariableIF::VAR_READ);
+		status = rawSet.read();
+		if (status == RETURN_OK) {
+			size_t temp = 0;
+			status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
+			if (status != RETURN_OK) {
+				return RETURN_FAILED;
+			}
+		} else {
+			//Error reading parameter.
+		}
+		arrayIndex += 1;
+		ptrToCopy += typeSize;
+	}
+	return ACTIVITY_COMPLETED;
+}
+
+ReturnValue_t DataPoolAdmin::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = memoryHelper.initialize(commandQueue);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (storage == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	result = actionHelper.initialize(commandQueue);
+
+	return result;
+}
+
+//mostly identical to ParameterHelper::handleParameterMessage()
+ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	switch (command->getCommand()) {
+	case ParameterMessage::CMD_PARAMETER_DUMP: {
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(command));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(command));
+
+		DataPoolParameterWrapper wrapper;
+		result = wrapper.set(domain, parameterId);
+
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(command->getSender(),
+					ParameterMessage::getParameterId(command), &wrapper);
+		}
+	}
+		break;
+	case ParameterMessage::CMD_PARAMETER_LOAD: {
+
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(command));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(command));
+		uint8_t index = HasParametersIF::getIndex(
+				ParameterMessage::getParameterId(command));
+
+		const uint8_t *storedStream;
+		size_t storedStreamSize;
+		result = storage->getData(ParameterMessage::getStoreId(command),
+				&storedStream, &storedStreamSize);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+
+		ParameterWrapper streamWrapper;
+		result = streamWrapper.set(storedStream, storedStreamSize);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(command));
+			break;
+		}
+
+		DataPoolParameterWrapper poolWrapper;
+		result = poolWrapper.set(domain, parameterId);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(command));
+			break;
+		}
+
+		result = poolWrapper.copyFrom(&streamWrapper, index);
+
+		storage->deleteData(ParameterMessage::getStoreId(command));
+
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(command->getSender(),
+					ParameterMessage::getParameterId(command), &poolWrapper);
+		}
+	}
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		rejectCommand(command->getSender(), result, command->getCommand());
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+//identical to ParameterHelper::sendParameter()
+ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
+		const DataPoolParameterWrapper* wrapper) {
+	size_t serializedSize = wrapper->getSerializedSize();
+
+	uint8_t *storeElement;
+	store_address_t address;
+
+	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
+			&storeElement);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	size_t storeElementSize = 0;
+
+	result = wrapper->serialize(&storeElement, &storeElementSize,
+			serializedSize, SerializeIF::Endianness::BIG);
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		storage->deleteData(address);
+		return result;
+	}
+
+	CommandMessage reply;
+
+	ParameterMessage::setParameterDumpReply(&reply, id, address);
+
+	commandQueue->sendMessage(to, &reply);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+//identical to ParameterHelper::rejectCommand()
+void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+		Command_t initialCommand) {
+	CommandMessage reply;
+	reply.setReplyRejected(reason, initialCommand);
+	commandQueue->sendMessage(to, &reply);
+}
diff --git a/datapoolglob/DataPoolAdmin.h b/datapoolglob/DataPoolAdmin.h
index 653fdd8e2..3d5d4d0c0 100644
--- a/datapoolglob/DataPoolAdmin.h
+++ b/datapoolglob/DataPoolAdmin.h
@@ -1,59 +1,59 @@
-#ifndef DATAPOOLADMIN_H_
-#define DATAPOOLADMIN_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/parameters/ReceivesParameterMessagesIF.h>
-
-#include <framework/memory/MemoryHelper.h>
-#include <framework/action/SimpleActionHelper.h>
-#include <framework/datapoolglob/DataPoolParameterWrapper.h>
-
-class DataPoolAdmin: public HasActionsIF,
-		public ExecutableObjectIF,
-		public AcceptsMemoryMessagesIF,
-		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF,
-		public SystemObject {
-public:
-	static const ActionId_t SET_VALIDITY = 1;
-
-	DataPoolAdmin(object_id_t objectId);
-
-	~DataPoolAdmin();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
-			size_t size, uint8_t** dataPointer);
-	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
-			uint8_t** dataPointer, uint8_t* copyHere);
-
-	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
-
-	//not implemented as ParameterHelper is no used
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-	ReturnValue_t initialize();
-private:
-	StorageManagerIF *storage;
-	MessageQueueIF* commandQueue;
-	MemoryHelper memoryHelper;
-	SimpleActionHelper actionHelper;
-	void handleCommand();
-	ReturnValue_t handleParameterCommand(CommandMessage *command);
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
-			const DataPoolParameterWrapper* wrapper);
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-			Command_t initialCommand);
-};
-
-#endif /* DATAPOOLADMIN_H_ */
+#ifndef DATAPOOLADMIN_H_
+#define DATAPOOLADMIN_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../action/HasActionsIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../parameters/ReceivesParameterMessagesIF.h"
+
+#include "../memory/MemoryHelper.h"
+#include "../action/SimpleActionHelper.h"
+#include "../datapoolglob/DataPoolParameterWrapper.h"
+
+class DataPoolAdmin: public HasActionsIF,
+		public ExecutableObjectIF,
+		public AcceptsMemoryMessagesIF,
+		public HasReturnvaluesIF,
+		public ReceivesParameterMessagesIF,
+		public SystemObject {
+public:
+	static const ActionId_t SET_VALIDITY = 1;
+
+	DataPoolAdmin(object_id_t objectId);
+
+	~DataPoolAdmin();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
+			size_t size, uint8_t** dataPointer);
+	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
+			uint8_t** dataPointer, uint8_t* copyHere);
+
+	ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
+
+	//not implemented as ParameterHelper is no used
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+	ReturnValue_t initialize();
+private:
+	StorageManagerIF *storage;
+	MessageQueueIF* commandQueue;
+	MemoryHelper memoryHelper;
+	SimpleActionHelper actionHelper;
+	void handleCommand();
+	ReturnValue_t handleParameterCommand(CommandMessage *command);
+	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
+			const DataPoolParameterWrapper* wrapper);
+	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+			Command_t initialCommand);
+};
+
+#endif /* DATAPOOLADMIN_H_ */
diff --git a/datapoolglob/DataPoolParameterWrapper.cpp b/datapoolglob/DataPoolParameterWrapper.cpp
index a292016ea..597cc86b7 100644
--- a/datapoolglob/DataPoolParameterWrapper.cpp
+++ b/datapoolglob/DataPoolParameterWrapper.cpp
@@ -1,179 +1,179 @@
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/DataPoolParameterWrapper.h>
-#include <framework/datapoolglob/PoolRawAccess.h>
-#include <framework/parameters/HasParametersIF.h>
-
-
-DataPoolParameterWrapper::DataPoolParameterWrapper() :
-		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
-				PoolVariableIF::NO_PARAMETER) {
-
-}
-
-DataPoolParameterWrapper::~DataPoolParameterWrapper() {
-
-}
-
-ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
-		uint16_t parameterId) {
-	poolId = (domainId << 16) + parameterId;
-
-	GlobDataSet mySet;
-	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
-	ReturnValue_t status = mySet.read();
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		//should only fail for invalid pool id
-		return HasParametersIF::INVALID_MATRIX_ID;
-	}
-
-	type = raw.getType();
-	rows = raw.getArraySize();
-	columns = 1;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result;
-
-	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&columns, buffer, size,
-			maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	for (uint8_t index = 0; index < rows; index++){
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
-		mySet.read();
-		result = raw.serialize(buffer,size,maxSize,streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//same as ParameterWrapper
-size_t DataPoolParameterWrapper::getSerializedSize() const {
-	size_t serializedSize = 0;
-	serializedSize += type.getSerializedSize();
-	serializedSize += sizeof(rows);
-	serializedSize += sizeof(columns);
-	serializedSize += rows * columns * type.getSize();
-
-	return serializedSize;
-}
-
-ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-template<typename T>
-ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
-		uint8_t startingColumn, const void* from, uint8_t fromRows) {
-	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t *) from;
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-
-	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
-
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
-				PoolVariableIF::VAR_READ_WRITE);
-		mySet.read();
-
-		result = raw.setEntryFromBigEndian(fromAsStream, sizeof(T));
-
-		fromAsStream += sizeof(T);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		mySet.commit();
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::copyFrom(const ParameterWrapper* from,
-		uint16_t startWritingAtIndex) {
-	if (poolId == PoolVariableIF::NO_PARAMETER) {
-		return ParameterWrapper::NOT_SET;
-	}
-
-	if (type != from->type) {
-		return ParameterWrapper::DATATYPE_MISSMATCH;
-	}
-
-	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
-
-	if ((from->rows > (rows - startingRow))
-			|| (from->columns > (columns - startingColumn))) {
-		return ParameterWrapper::TOO_BIG;
-	}
-
-	ReturnValue_t result;
-	//copy data
-	if (from->pointsToStream) {
-		switch (type) {
-		case Type::UINT8_T:
-			result = deSerializeData<uint8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT8_T:
-			result = deSerializeData<int8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT16_T:
-			result = deSerializeData<uint16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT16_T:
-			result = deSerializeData<int16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT32_T:
-			result = deSerializeData<uint32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT32_T:
-			result = deSerializeData<int32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::FLOAT:
-			result = deSerializeData<float>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::DOUBLE:
-			result = deSerializeData<double>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		default:
-			result = ParameterWrapper::UNKNOW_DATATYPE;
-			break;
-		}
-	} else {
-		//not supported
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	return result;
-}
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/DataPoolParameterWrapper.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../parameters/HasParametersIF.h"
+
+
+DataPoolParameterWrapper::DataPoolParameterWrapper() :
+		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
+				PoolVariableIF::NO_PARAMETER) {
+
+}
+
+DataPoolParameterWrapper::~DataPoolParameterWrapper() {
+
+}
+
+ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
+		uint16_t parameterId) {
+	poolId = (domainId << 16) + parameterId;
+
+	GlobDataSet mySet;
+	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
+	ReturnValue_t status = mySet.read();
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		//should only fail for invalid pool id
+		return HasParametersIF::INVALID_MATRIX_ID;
+	}
+
+	type = raw.getType();
+	rows = raw.getArraySize();
+	columns = 1;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result;
+
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&columns, buffer, size,
+			maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	for (uint8_t index = 0; index < rows; index++){
+		GlobDataSet mySet;
+		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
+		mySet.read();
+		result = raw.serialize(buffer,size,maxSize,streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+//same as ParameterWrapper
+size_t DataPoolParameterWrapper::getSerializedSize() const {
+	size_t serializedSize = 0;
+	serializedSize += type.getSerializedSize();
+	serializedSize += sizeof(rows);
+	serializedSize += sizeof(columns);
+	serializedSize += rows * columns * type.getSize();
+
+	return serializedSize;
+}
+
+ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+template<typename T>
+ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
+		uint8_t startingColumn, const void* from, uint8_t fromRows) {
+	//treat from as a continuous Stream as we copy all of it
+	const uint8_t *fromAsStream = (const uint8_t *) from;
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+
+	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
+
+		GlobDataSet mySet;
+		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
+				PoolVariableIF::VAR_READ_WRITE);
+		mySet.read();
+
+		result = raw.setEntryFromBigEndian(fromAsStream, sizeof(T));
+
+		fromAsStream += sizeof(T);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		mySet.commit();
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataPoolParameterWrapper::copyFrom(const ParameterWrapper* from,
+		uint16_t startWritingAtIndex) {
+	if (poolId == PoolVariableIF::NO_PARAMETER) {
+		return ParameterWrapper::NOT_SET;
+	}
+
+	if (type != from->type) {
+		return ParameterWrapper::DATATYPE_MISSMATCH;
+	}
+
+	//check if from fits into this
+	uint8_t startingRow = startWritingAtIndex / columns;
+	uint8_t startingColumn = startWritingAtIndex % columns;
+
+	if ((from->rows > (rows - startingRow))
+			|| (from->columns > (columns - startingColumn))) {
+		return ParameterWrapper::TOO_BIG;
+	}
+
+	ReturnValue_t result;
+	//copy data
+	if (from->pointsToStream) {
+		switch (type) {
+		case Type::UINT8_T:
+			result = deSerializeData<uint8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::INT8_T:
+			result = deSerializeData<int8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::UINT16_T:
+			result = deSerializeData<uint16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::INT16_T:
+			result = deSerializeData<int16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::UINT32_T:
+			result = deSerializeData<uint32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::INT32_T:
+			result = deSerializeData<int32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::FLOAT:
+			result = deSerializeData<float>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::DOUBLE:
+			result = deSerializeData<double>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		default:
+			result = ParameterWrapper::UNKNOW_DATATYPE;
+			break;
+		}
+	} else {
+		//not supported
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	return result;
+}
diff --git a/datapoolglob/DataPoolParameterWrapper.h b/datapoolglob/DataPoolParameterWrapper.h
index a3dbdc04d..0c5c65ea5 100644
--- a/datapoolglob/DataPoolParameterWrapper.h
+++ b/datapoolglob/DataPoolParameterWrapper.h
@@ -1,38 +1,38 @@
-#ifndef DATAPOOLPARAMETERWRAPPER_H_
-#define DATAPOOLPARAMETERWRAPPER_H_
-
-#include <framework/globalfunctions/Type.h>
-#include <framework/parameters/ParameterWrapper.h>
-
-class DataPoolParameterWrapper: public SerializeIF {
-public:
-	DataPoolParameterWrapper();
-	virtual ~DataPoolParameterWrapper();
-
-	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
-
-	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;
-
-	ReturnValue_t copyFrom(const ParameterWrapper *from,
-			uint16_t startWritingAtIndex);
-
-private:
-	Type type;
-	uint8_t rows;
-	uint8_t columns;
-
-	uint32_t poolId;
-
-	template<typename T>
-	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
-			const void *from, uint8_t fromRows);
-
-};
-
-#endif /* DATAPOOLPARAMETERWRAPPER_H_ */
+#ifndef DATAPOOLPARAMETERWRAPPER_H_
+#define DATAPOOLPARAMETERWRAPPER_H_
+
+#include "../globalfunctions/Type.h"
+#include "../parameters/ParameterWrapper.h"
+
+class DataPoolParameterWrapper: public SerializeIF {
+public:
+	DataPoolParameterWrapper();
+	virtual ~DataPoolParameterWrapper();
+
+	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
+
+	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;
+
+	ReturnValue_t copyFrom(const ParameterWrapper *from,
+			uint16_t startWritingAtIndex);
+
+private:
+	Type type;
+	uint8_t rows;
+	uint8_t columns;
+
+	uint32_t poolId;
+
+	template<typename T>
+	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
+			const void *from, uint8_t fromRows);
+
+};
+
+#endif /* DATAPOOLPARAMETERWRAPPER_H_ */
diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
index 9dedb4b8a..aa6831f87 100644
--- a/datapoolglob/GlobalDataPool.cpp
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -1,133 +1,133 @@
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/ipc/MutexFactory.h>
-
-GlobalDataPool::GlobalDataPool(
-		void(*initFunction)(GlobPoolMap* pool_map)) {
-	mutex = MutexFactory::instance()->createMutex();
-	if (initFunction != NULL ) {
-		initFunction( &this->globDataPool );
-	}
-}
-
-GlobalDataPool::~GlobalDataPool() {
-	MutexFactory::instance()->deleteMutex(mutex);
-	for(GlobPoolMapIter it = this->globDataPool.begin();
-	    it != this->globDataPool.end(); ++it )
-	{
-		delete it->second;
-	}
-}
-
-// The function checks PID, type and array length before returning a copy of
-// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
-template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
-		uint8_t sizeOrPosition ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
-		if (entry != nullptr ) {
-			if ( sizeOrPosition <= entry->length ) {
-				return entry;
-			}
-		}
-	}
-	return nullptr;
-}
-
-PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		return it->second;
-	} else {
-		return nullptr;
-	}
-}
-
-ReturnValue_t GlobalDataPool::unlockDataPool() {
-	ReturnValue_t status = mutex->unlockMutex();
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: unlock of mutex failed with"
-				" error code: " << status << std::endl;
-	}
-	return status;
-}
-
-ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
-	        timeoutMs);
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: lock of mutex failed "
-				"with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-void GlobalDataPool::print() {
-	sif::debug << "DataPool contains: " << std::endl;
-	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
-	dataPoolIt = this->globDataPool.begin();
-	while( dataPoolIt != this->globDataPool.end() ) {
-		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
-		dataPoolIt->second->print();
-		dataPoolIt++;
-	}
-}
-
-uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
-	return (parameter_id >> 8) & 0x00FFFFFF;
-}
-
-uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
-	return (parameter_id & 0x000000FF);
-}
-
-uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
-	return (poolId << 8) + index;
-}
-
-
-//SHOULDDO: Do we need a mutex lock here... I don't think so,
-//as we only check static const values of elements in a list that do not change.
-//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
-ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
-	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
-	if ( it != this->globDataPool.end() ) {
-		*type = it->second->getType();
-		return RETURN_OK;
-	} else {
-		*type = Type::UNKNOWN_TYPE;
-		return RETURN_FAILED;
-	}
-}
-
-bool GlobalDataPool::exists(uint32_t parameterId) {
-	uint32_t poolId = PIDToDataPoolId(parameterId);
-	uint32_t index = PIDToArrayIndex(parameterId);
-	GlobPoolMapIter it = this->globDataPool.find( poolId );
-	if (it != globDataPool.end()) {
-		if (it->second->getSize() >= index) {
-			return true;
-		}
-	}
-	return false;
-}
-
-template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
-		uint32_t data_pool_id, uint8_t size);
-template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<float>* GlobalDataPool::getData<float>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<double>* GlobalDataPool::getData<double>(
-		uint32_t data_pool_id, uint8_t size);
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../ipc/MutexFactory.h"
+
+GlobalDataPool::GlobalDataPool(
+		void(*initFunction)(GlobPoolMap* pool_map)) {
+	mutex = MutexFactory::instance()->createMutex();
+	if (initFunction != NULL ) {
+		initFunction( &this->globDataPool );
+	}
+}
+
+GlobalDataPool::~GlobalDataPool() {
+	MutexFactory::instance()->deleteMutex(mutex);
+	for(GlobPoolMapIter it = this->globDataPool.begin();
+	    it != this->globDataPool.end(); ++it )
+	{
+		delete it->second;
+	}
+}
+
+// The function checks PID, type and array length before returning a copy of
+// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
+template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
+		uint8_t sizeOrPosition ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
+		if (entry != nullptr ) {
+			if ( sizeOrPosition <= entry->length ) {
+				return entry;
+			}
+		}
+	}
+	return nullptr;
+}
+
+PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		return it->second;
+	} else {
+		return nullptr;
+	}
+}
+
+ReturnValue_t GlobalDataPool::unlockDataPool() {
+	ReturnValue_t status = mutex->unlockMutex();
+	if(status != RETURN_OK) {
+		sif::error << "DataPool::DataPool: unlock of mutex failed with"
+				" error code: " << status << std::endl;
+	}
+	return status;
+}
+
+ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
+	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
+	        timeoutMs);
+	if(status != RETURN_OK) {
+		sif::error << "DataPool::DataPool: lock of mutex failed "
+				"with error code: " << status << std::endl;
+	}
+	return status;
+}
+
+void GlobalDataPool::print() {
+	sif::debug << "DataPool contains: " << std::endl;
+	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
+	dataPoolIt = this->globDataPool.begin();
+	while( dataPoolIt != this->globDataPool.end() ) {
+		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
+		dataPoolIt->second->print();
+		dataPoolIt++;
+	}
+}
+
+uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
+	return (parameter_id >> 8) & 0x00FFFFFF;
+}
+
+uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
+	return (parameter_id & 0x000000FF);
+}
+
+uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
+	return (poolId << 8) + index;
+}
+
+
+//SHOULDDO: Do we need a mutex lock here... I don't think so,
+//as we only check static const values of elements in a list that do not change.
+//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
+ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
+	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
+	if ( it != this->globDataPool.end() ) {
+		*type = it->second->getType();
+		return RETURN_OK;
+	} else {
+		*type = Type::UNKNOWN_TYPE;
+		return RETURN_FAILED;
+	}
+}
+
+bool GlobalDataPool::exists(uint32_t parameterId) {
+	uint32_t poolId = PIDToDataPoolId(parameterId);
+	uint32_t index = PIDToArrayIndex(parameterId);
+	GlobPoolMapIter it = this->globDataPool.find( poolId );
+	if (it != globDataPool.end()) {
+		if (it->second->getSize() >= index) {
+			return true;
+		}
+	}
+	return false;
+}
+
+template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
+		uint32_t data_pool_id, uint8_t size);
+template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<float>* GlobalDataPool::getData<float>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<double>* GlobalDataPool::getData<double>(
+		uint32_t data_pool_id, uint8_t size);
diff --git a/datapoolglob/GlobalDataPool.h b/datapoolglob/GlobalDataPool.h
index b9c1436fb..37a4057bd 100644
--- a/datapoolglob/GlobalDataPool.h
+++ b/datapoolglob/GlobalDataPool.h
@@ -1,149 +1,149 @@
-#ifndef GLOBALDATAPOOL_H_
-#define GLOBALDATAPOOL_H_
-
-#include <framework/datapool/PoolEntry.h>
-#include <framework/globalfunctions/Type.h>
-#include <framework/ipc/MutexIF.h>
-#include <map>
-
-/**
- * @defgroup data_pool Global data pool
- * This is the group, where all classes associated with global
- * data pool handling belong to.
- * This includes classes to access Data Pool variables.
- */
-
-/**
- * Typedefs for the global pool representations
- */
-using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
-using GlobPoolMapIter = GlobPoolMap::iterator;
-
-/**
- * @brief		This class represents the OBSW global data-pool.
- *
- * @details
- * All variables are registered and space is allocated in an initialization
- * function, which is passed do the constructor. Space for the variables is
- * allocated on the heap (with a new call).
- *
- * The data is found by a data pool id, which uniquely represents a variable.
- * Data pool variables should be used with a blackboard logic in mind,
- * which means read data is valid (if flagged so),
- * but not necessarily up-to-date.
- *
- * Variables are either single values or arrays.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class GlobalDataPool : public HasReturnvaluesIF {
-private:
-	/**
-	 * @brief	This is the actual data pool itself.
-	 * @details	It is represented by a map with the data pool id as index
-	 * 			and a pointer to a single PoolEntry as value.
-	 */
-	GlobPoolMap globDataPool;
-
-	/**
-	 * @brief	The mutex is created in the constructor and makes
-	 * 			access mutual exclusive.
-	 * @details	Locking and unlocking the pool is only done by the DataSet class.
-	 */
-	MutexIF*	mutex;
-public:
-	/**
-	 * @brief	In the classes constructor,
-	 * 			the passed initialization function is called.
-	 * @details
-	 * To enable filling the pool, a pointer to the map is passed,
-	 * allowing direct access to the pool's content.
-	 * On runtime, adding or removing variables is forbidden.
-	 */
-	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
-
-	/**
-	 * 	@brief	The destructor iterates through the data_pool map and
-	 * 			calls all entries destructors to clean up the heap.
-	 */
-	~GlobalDataPool();
-
-	/**
-	 * @brief	This is the default call to access the pool.
-	 * @details
-	 * A pointer to the PoolEntry object is returned.
-	 * The call checks data pool id, type and array size.
-	 * Returns NULL in case of failure.
-	 * @param data_pool_id	The data pool id to search.
-	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
-	 * or the position the user wants to read.
-	 * 			If smaller than the entry size, everything's ok.
-	 */
-	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
-			uint8_t sizeOrPosition );
-
-	/**
-	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
-	 * 			(i.e. in Housekeeping Telemetry).
-	 * @details	It returns a basic interface and does NOT perform
-	 * 			a size check. The caller has to assure he does not copy too much data.
-	 * 			Returns NULL in case the entry is not found.
-	 * @param data_pool_id	The data pool id to search.
-	 */
-	PoolEntryIF* getRawData( uint32_t data_pool_id );
-	/**
-	 * @brief	This is a small helper function to facilitate locking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
-	/**
-	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to free the mutex.
-	 */
-	ReturnValue_t unlockDataPool();
-	/**
-	 * @brief	The print call is a simple debug method.
-	 * @details	It prints the current content of the data pool.
-	 *  		It iterates through the data_pool map and calls each entry's print() method.
-	 */
-	void print();
-	/**
-	 * Extracts the data pool id from a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The data pool id as used within the OBSW.
-	 */
-	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
-	/**
-	 * Extracts an array index out of a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The index of the corresponding data pool entry.
-	 */
-	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
-	/**
-	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
-	 */
-	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
-
-	/**
-	 * Method to return the type of a pool variable.
-	 * @param parameter_id A parameterID (not pool id) of a DP member.
-	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
-	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
-	 */
-	ReturnValue_t getType( uint32_t parameter_id, Type* type );
-
-	/**
-	 * Method to check if a PID exists. Does not lock, as there's no
-	 * possibility to alter the list that is checked during run-time.
-	 * @param parameterId The PID (not pool id!) of a parameter.
-	 * @return	true if exists, false else.
-	 */
-	bool exists(uint32_t parameterId);
-};
-
-//We assume someone globally instantiates a DataPool.
-namespace glob {
-extern GlobalDataPool dataPool;
-}
-
-#endif /* DATAPOOL_H_ */
+#ifndef GLOBALDATAPOOL_H_
+#define GLOBALDATAPOOL_H_
+
+#include "../datapool/PoolEntry.h"
+#include "../globalfunctions/Type.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+/**
+ * @defgroup data_pool Global data pool
+ * This is the group, where all classes associated with global
+ * data pool handling belong to.
+ * This includes classes to access Data Pool variables.
+ */
+
+/**
+ * Typedefs for the global pool representations
+ */
+using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
+using GlobPoolMapIter = GlobPoolMap::iterator;
+
+/**
+ * @brief		This class represents the OBSW global data-pool.
+ *
+ * @details
+ * All variables are registered and space is allocated in an initialization
+ * function, which is passed do the constructor. Space for the variables is
+ * allocated on the heap (with a new call).
+ *
+ * The data is found by a data pool id, which uniquely represents a variable.
+ * Data pool variables should be used with a blackboard logic in mind,
+ * which means read data is valid (if flagged so),
+ * but not necessarily up-to-date.
+ *
+ * Variables are either single values or arrays.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class GlobalDataPool : public HasReturnvaluesIF {
+private:
+	/**
+	 * @brief	This is the actual data pool itself.
+	 * @details	It is represented by a map with the data pool id as index
+	 * 			and a pointer to a single PoolEntry as value.
+	 */
+	GlobPoolMap globDataPool;
+
+	/**
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking the pool is only done by the DataSet class.
+	 */
+	MutexIF*	mutex;
+public:
+	/**
+	 * @brief	In the classes constructor,
+	 * 			the passed initialization function is called.
+	 * @details
+	 * To enable filling the pool, a pointer to the map is passed,
+	 * allowing direct access to the pool's content.
+	 * On runtime, adding or removing variables is forbidden.
+	 */
+	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
+
+	/**
+	 * 	@brief	The destructor iterates through the data_pool map and
+	 * 			calls all entries destructors to clean up the heap.
+	 */
+	~GlobalDataPool();
+
+	/**
+	 * @brief	This is the default call to access the pool.
+	 * @details
+	 * A pointer to the PoolEntry object is returned.
+	 * The call checks data pool id, type and array size.
+	 * Returns NULL in case of failure.
+	 * @param data_pool_id	The data pool id to search.
+	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
+	 * or the position the user wants to read.
+	 * 			If smaller than the entry size, everything's ok.
+	 */
+	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
+			uint8_t sizeOrPosition );
+
+	/**
+	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
+	 * 			(i.e. in Housekeeping Telemetry).
+	 * @details	It returns a basic interface and does NOT perform
+	 * 			a size check. The caller has to assure he does not copy too much data.
+	 * 			Returns NULL in case the entry is not found.
+	 * @param data_pool_id	The data pool id to search.
+	 */
+	PoolEntryIF* getRawData( uint32_t data_pool_id );
+	/**
+	 * @brief	This is a small helper function to facilitate locking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
+	/**
+	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to free the mutex.
+	 */
+	ReturnValue_t unlockDataPool();
+	/**
+	 * @brief	The print call is a simple debug method.
+	 * @details	It prints the current content of the data pool.
+	 *  		It iterates through the data_pool map and calls each entry's print() method.
+	 */
+	void print();
+	/**
+	 * Extracts the data pool id from a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The data pool id as used within the OBSW.
+	 */
+	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
+	/**
+	 * Extracts an array index out of a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The index of the corresponding data pool entry.
+	 */
+	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
+	/**
+	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
+	 */
+	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
+
+	/**
+	 * Method to return the type of a pool variable.
+	 * @param parameter_id A parameterID (not pool id) of a DP member.
+	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
+	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
+	 */
+	ReturnValue_t getType( uint32_t parameter_id, Type* type );
+
+	/**
+	 * Method to check if a PID exists. Does not lock, as there's no
+	 * possibility to alter the list that is checked during run-time.
+	 * @param parameterId The PID (not pool id!) of a parameter.
+	 * @return	true if exists, false else.
+	 */
+	bool exists(uint32_t parameterId);
+};
+
+//We assume someone globally instantiates a DataPool.
+namespace glob {
+extern GlobalDataPool dataPool;
+}
+
+#endif /* DATAPOOL_H_ */
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
index 883f61577..00124fb01 100644
--- a/datapoolglob/GlobalDataSet.cpp
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -1,44 +1,44 @@
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-GlobDataSet::GlobDataSet(): DataSetBase(
-        reinterpret_cast<PoolVariableIF**>(&registeredVariables),
-        DATA_SET_MAX_SIZE) {}
-
-// Don't do anything with your variables, they are dead already!
-// (Destructor is already called)
-GlobDataSet::~GlobDataSet() {}
-
-ReturnValue_t GlobDataSet::commit(bool valid, uint32_t lockTimeout) {
-	setEntriesValid(valid);
-	setSetValid(valid);
-	return commit(lockTimeout);
-}
-
-ReturnValue_t GlobDataSet::commit(uint32_t lockTimeout) {
-	return DataSetBase::commit(lockTimeout);
-}
-
-ReturnValue_t GlobDataSet::unlockDataPool() {
-	return glob::dataPool.unlockDataPool();
-}
-
-ReturnValue_t GlobDataSet::lockDataPool(uint32_t timeoutMs) {
-	return glob::dataPool.lockDataPool(timeoutMs);
-}
-
-void GlobDataSet::setEntriesValid(bool valid) {
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ) {
-			registeredVariables[count]->setValid(valid);
-		}
-	}
-}
-
-void GlobDataSet::setSetValid(bool valid) {
-	this->valid = valid;
-}
-
-
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+GlobDataSet::GlobDataSet(): DataSetBase(
+        reinterpret_cast<PoolVariableIF**>(&registeredVariables),
+        DATA_SET_MAX_SIZE) {}
+
+// Don't do anything with your variables, they are dead already!
+// (Destructor is already called)
+GlobDataSet::~GlobDataSet() {}
+
+ReturnValue_t GlobDataSet::commit(bool valid, uint32_t lockTimeout) {
+	setEntriesValid(valid);
+	setSetValid(valid);
+	return commit(lockTimeout);
+}
+
+ReturnValue_t GlobDataSet::commit(uint32_t lockTimeout) {
+	return DataSetBase::commit(lockTimeout);
+}
+
+ReturnValue_t GlobDataSet::unlockDataPool() {
+	return glob::dataPool.unlockDataPool();
+}
+
+ReturnValue_t GlobDataSet::lockDataPool(uint32_t timeoutMs) {
+	return glob::dataPool.lockDataPool(timeoutMs);
+}
+
+void GlobDataSet::setEntriesValid(bool valid) {
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				!= PoolVariableIF::VAR_READ) {
+			registeredVariables[count]->setValid(valid);
+		}
+	}
+}
+
+void GlobDataSet::setSetValid(bool valid) {
+	this->valid = valid;
+}
+
+
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index d237cc1b4..019595ce2 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -1,96 +1,96 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_DATASET_H_
-#define FRAMEWORK_DATAPOOLGLOB_DATASET_H_
-
-#include <framework/datapool/DataSetBase.h>
-
-/**
- * @brief	The DataSet class manages a set of locally checked out variables
- * 			for the global data pool.
- * @details
- * This class uses the read-commit() semantic provided by the DataSetBase class.
- * It extends the base class by using the global data pool,
- * having a valid state and implementing lock und unlock calls for the global
- * datapool.
- *
- * For more information on how this class works, see the DataSetBase
- * documentation.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class GlobDataSet: public DataSetBase {
-public:
-
-	/**
-	 * @brief	Creates an empty GlobDataSet. Use registerVariable or
-	 * 			supply a pointer to this dataset to PoolVariable
-	 * 			initializations to register pool variables.
-	 */
-	GlobDataSet();
-
-	/**
-	 * @brief	The destructor automatically manages writing the valid
-	 * 			information of variables.
-	 * @details
-	 * In case the data set was read out, but not committed(indicated by state),
-	 * the destructor parses all variables that are still registered to the set.
-	 * For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~GlobDataSet();
-
-	/**
-	 * Variant of method above which sets validity of all elements of the set.
-	 * @param valid Validity information from PoolVariableIF.
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
-	 * 			     contains non write-only variables
-	 */
-	ReturnValue_t commit(bool valid, uint32_t lockTimeout = MutexIF::BLOCKING);
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-	/**
-	 * Set all entries
-	 * @param valid
-	 */
-	void setSetValid(bool valid);
-
-	/**
-	 * Set the valid information of all variables contained in the set which
-	 * are not read-only
-	 *
-	 * @param valid Validity information from PoolVariableIF.
-	 */
-	void setEntriesValid(bool valid);
-
-	//!< This definition sets the maximum number of variables to
-	//! register in one DataSet.
-	static const uint8_t DATA_SET_MAX_SIZE = 63;
-
-private:
-	/**
-	 * If the valid state of a dataset is always relevant to the whole
-	 * data set we can use this flag.
-	 */
-	bool valid = false;
-
-	/**
-	 * @brief	This is a small helper function to facilitate locking
-	 * 			the global data pool.
-	 * @details
-	 * It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
-	/**
-	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the global data pool
-	 * @details
-	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	ReturnValue_t unlockDataPool() override;
-
-	void handleAlreadyReadDatasetCommit();
-	ReturnValue_t handleUnreadDatasetCommit();
-
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-};
-
-#endif /* FRAMEWORK_DATAPOOLGLOB_DATASET_H_ */
+#ifndef FRAMEWORK_DATAPOOLGLOB_DATASET_H_
+#define FRAMEWORK_DATAPOOLGLOB_DATASET_H_
+
+#include "../datapool/DataSetBase.h"
+
+/**
+ * @brief	The DataSet class manages a set of locally checked out variables
+ * 			for the global data pool.
+ * @details
+ * This class uses the read-commit() semantic provided by the DataSetBase class.
+ * It extends the base class by using the global data pool,
+ * having a valid state and implementing lock und unlock calls for the global
+ * datapool.
+ *
+ * For more information on how this class works, see the DataSetBase
+ * documentation.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class GlobDataSet: public DataSetBase {
+public:
+
+	/**
+	 * @brief	Creates an empty GlobDataSet. Use registerVariable or
+	 * 			supply a pointer to this dataset to PoolVariable
+	 * 			initializations to register pool variables.
+	 */
+	GlobDataSet();
+
+	/**
+	 * @brief	The destructor automatically manages writing the valid
+	 * 			information of variables.
+	 * @details
+	 * In case the data set was read out, but not committed(indicated by state),
+	 * the destructor parses all variables that are still registered to the set.
+	 * For each, the valid flag in the data pool is set to "invalid".
+	 */
+	~GlobDataSet();
+
+	/**
+	 * Variant of method above which sets validity of all elements of the set.
+	 * @param valid Validity information from PoolVariableIF.
+	 * @return	- @c RETURN_OK if all variables were read successfully.
+	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
+	 * 			     contains non write-only variables
+	 */
+	ReturnValue_t commit(bool valid, uint32_t lockTimeout = MutexIF::BLOCKING);
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+	/**
+	 * Set all entries
+	 * @param valid
+	 */
+	void setSetValid(bool valid);
+
+	/**
+	 * Set the valid information of all variables contained in the set which
+	 * are not read-only
+	 *
+	 * @param valid Validity information from PoolVariableIF.
+	 */
+	void setEntriesValid(bool valid);
+
+	//!< This definition sets the maximum number of variables to
+	//! register in one DataSet.
+	static const uint8_t DATA_SET_MAX_SIZE = 63;
+
+private:
+	/**
+	 * If the valid state of a dataset is always relevant to the whole
+	 * data set we can use this flag.
+	 */
+	bool valid = false;
+
+	/**
+	 * @brief	This is a small helper function to facilitate locking
+	 * 			the global data pool.
+	 * @details
+	 * It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
+	/**
+	 * @brief	This is a small helper function to facilitate
+	 * 			unlocking the global data pool
+	 * @details
+	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	ReturnValue_t unlockDataPool() override;
+
+	void handleAlreadyReadDatasetCommit();
+	ReturnValue_t handleUnreadDatasetCommit();
+
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
+};
+
+#endif /* FRAMEWORK_DATAPOOLGLOB_DATASET_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index b4aa6c4c1..f5fc49f8b 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -1,213 +1,213 @@
-#ifndef GLOBALPOOLVARIABLE_H_
-#define GLOBALPOOLVARIABLE_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-template<typename T, uint8_t n_var> class PoolVarList;
-
-
-/**
- * @brief	This is the access class for non-array data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly
- * on the data pool entries, but on local copies. This class provides simple
- * type-safe access to single data pool entries (i.e. entries with length = 1).
- * The class can be instantiated as read-write and read only.
- * It provides a commit-and-roll-back semantic, which means that the
- * variable's value in the data pool is not changed until the
- * commit call is executed.
- * 	@tparam	T The template parameter sets the type of the variable.
- * 	Currently, all plain data types are supported, but in principle
- * 	any type is possible.
- *	@ingroup data_pool
- */
-template<typename T>
-class GlobPoolVar: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PoolVarList;
-	static_assert(not std::is_same<T, bool>::value,
-			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
-			"There is no boolean type in CCSDS.");
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if nullptr is not passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but
-	 * sets the value attribute to default (0).
-	 * The value is fetched within the read() operation.
-	 * @param set_id	This is the id in the global data pool
-	 * 					this instance of the access class corresponds to.
-	 * @param dataSet	The data set in which the variable shall register
-	 * 					itself. If NULL, the variable is not registered.
-	 * @param setWritable If this flag is set to true, changes in the value
-	 * 			attribute can be written back to the data pool, otherwise not.
-	 */
-	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value = 0;
-
-	/**
-	 * @brief 	Copy ctor to copy classes containing Pool Variables.
-	 * 			(Robin): This only copies member variables, which is done
-	 * 			by the default copy ctor. maybe we can ommit this ctor?
-	 */
-	GlobPoolVar(const GlobPoolVar& rhs);
-
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVar() {}
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * The commit call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool is stored.
-	 */
-	uint32_t dataPoolId;
-
-	/**
-	 * @brief	The valid information as it was stored in the data pool is
-	 * 			copied to this attribute.
-	 */
-	uint8_t valid;
-
-	/**
-	 * @brief	The information whether the class is read-write or read-only
-	 * 			is stored here.
-	 */
-	pool_rwm_t readWriteMode;
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	GlobPoolVar();
-public:
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const override;
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const override;
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-
-	uint8_t getValid();
-
-	void setValid(bool valid) override;
-
-	operator T() {
-		return value;
-	}
-
-	operator T() const {
-		return value;
-	}
-
-	GlobPoolVar<T> &operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
-		value = newPoolVariable.value;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size,
-			SerializeIF::Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, max_size,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-		        streamEndianness);
-	}
-};
-
-#include <framework/datapoolglob/GlobalPoolVariable.tpp>
-
-typedef GlobPoolVar<uint8_t> gp_bool_t;
-typedef GlobPoolVar<uint8_t> gp_uint8_t;
-typedef GlobPoolVar<uint16_t> gp_uint16_t;
-typedef GlobPoolVar<uint32_t> gp_uint32_t;
-typedef GlobPoolVar<int8_t> gp_int8_t;
-typedef GlobPoolVar<int16_t> gp_int16_t;
-typedef GlobPoolVar<int32_t> gp_int32_t;
-typedef GlobPoolVar<float> gp_float_t;
-typedef GlobPoolVar<double> gp_double_t;
-
-#endif /* POOLVARIABLE_H_ */
+#ifndef GLOBALPOOLVARIABLE_H_
+#define GLOBALPOOLVARIABLE_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+template<typename T, uint8_t n_var> class PoolVarList;
+
+
+/**
+ * @brief	This is the access class for non-array data pool entries.
+ *
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly
+ * on the data pool entries, but on local copies. This class provides simple
+ * type-safe access to single data pool entries (i.e. entries with length = 1).
+ * The class can be instantiated as read-write and read only.
+ * It provides a commit-and-roll-back semantic, which means that the
+ * variable's value in the data pool is not changed until the
+ * commit call is executed.
+ * 	@tparam	T The template parameter sets the type of the variable.
+ * 	Currently, all plain data types are supported, but in principle
+ * 	any type is possible.
+ *	@ingroup data_pool
+ */
+template<typename T>
+class GlobPoolVar: public PoolVariableIF {
+	template<typename U, uint8_t n_var> friend class PoolVarList;
+	static_assert(not std::is_same<T, bool>::value,
+			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
+			"There is no boolean type in CCSDS.");
+public:
+	/**
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if nullptr is not passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but
+	 * sets the value attribute to default (0).
+	 * The value is fetched within the read() operation.
+	 * @param set_id	This is the id in the global data pool
+	 * 					this instance of the access class corresponds to.
+	 * @param dataSet	The data set in which the variable shall register
+	 * 					itself. If NULL, the variable is not registered.
+	 * @param setWritable If this flag is set to true, changes in the value
+	 * 			attribute can be written back to the data pool, otherwise not.
+	 */
+	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
+			ReadWriteMode_t setReadWriteMode);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a simple local variable.
+	 */
+	T value = 0;
+
+	/**
+	 * @brief 	Copy ctor to copy classes containing Pool Variables.
+	 * 			(Robin): This only copies member variables, which is done
+	 * 			by the default copy ctor. maybe we can ommit this ctor?
+	 */
+	GlobPoolVar(const GlobPoolVar& rhs);
+
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVar() {}
+
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout) override;
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * The commit call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool is stored.
+	 */
+	uint32_t dataPoolId;
+
+	/**
+	 * @brief	The valid information as it was stored in the data pool is
+	 * 			copied to this attribute.
+	 */
+	uint8_t valid;
+
+	/**
+	 * @brief	The information whether the class is read-write or read-only
+	 * 			is stored here.
+	 */
+	pool_rwm_t readWriteMode;
+
+	/**
+	 * Empty ctor for List initialization
+	 */
+	GlobPoolVar();
+public:
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const override;
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const override;
+	/**
+	 * This operation sets the data pool id of the variable.
+	 * The method is necessary to set id's of data pool member variables with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+
+	uint8_t getValid();
+
+	void setValid(bool valid) override;
+
+	operator T() {
+		return value;
+	}
+
+	operator T() const {
+		return value;
+	}
+
+	GlobPoolVar<T> &operator=(T newValue) {
+		value = newValue;
+		return *this;
+	}
+
+	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
+		value = newPoolVariable.value;
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size,
+			SerializeIF::Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, max_size,
+				streamEndianness);
+	}
+
+	virtual size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+		        streamEndianness);
+	}
+};
+
+#include "../datapoolglob/GlobalPoolVariable.tpp"
+
+typedef GlobPoolVar<uint8_t> gp_bool_t;
+typedef GlobPoolVar<uint8_t> gp_uint8_t;
+typedef GlobPoolVar<uint16_t> gp_uint16_t;
+typedef GlobPoolVar<uint32_t> gp_uint32_t;
+typedef GlobPoolVar<int8_t> gp_int8_t;
+typedef GlobPoolVar<int16_t> gp_int16_t;
+typedef GlobPoolVar<int32_t> gp_int32_t;
+typedef GlobPoolVar<float> gp_float_t;
+typedef GlobPoolVar<double> gp_double_t;
+
+#endif /* POOLVARIABLE_H_ */
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 0e03f77db..eb40d1f18 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -1,185 +1,185 @@
-#ifndef GLOBALPOOLVECTOR_H_
-#define GLOBALPOOLVECTOR_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-/**
- * @brief	This is the access class for array-type data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly on the
- * data pool entries, but on local copies. This class provides simple type-
- * and length-safe access to vector-style data pool entries (i.e. entries with
- * length > 1). The class can be instantiated as read-write and read only.
- *
- * It provides a commit-and-roll-back semantic, which means that no array
- * entry in the data pool is changed until the commit call is executed.
- * There are two template parameters:
- * @tparam	T
- * This template parameter specifies the data type of an array entry. Currently,
- * all plain data types are supported, but in principle any type is possible.
- * @tparam  vector_size
- * This template parameter specifies the vector size of this entry. Using a
- * template parameter for this is not perfect, but avoids
- * dynamic memory allocation.
- * @ingroup data_pool
- */
-template<typename T, uint16_t vectorSize>
-class GlobPoolVector: public PoolVariableIF {
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if no nullptr is passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but sets the
-	 * value attribute to default (0). The value is fetched within the
-	 * read() operation.
-	 * @param set_id
-	 * This is the id in the global data pool this instance of the access
-	 * class corresponds to.
-	 * @param dataSet
-	 * The data set in which the variable shall register itself. If nullptr,
-	 * the variable is not registered.
-	 * @param setWritable
-	 * If this flag is set to true, changes in the value attribute can be
-	 * written back to the data pool, otherwise not.
-	 */
-	GlobPoolVector(uint32_t set_id, DataSetIF* set,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * @brief This operation sets the data pool id of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid != INVALID)
-			return true;
-		else
-			return false;
-	}
-	void setValid(bool valid) {this->valid = valid;}
-	uint8_t getValid() {return valid;}
-
-	T &operator [](int i) {return value[i];}
-	const T &operator [](int i) const {return value[i];}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t max_size, Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) override;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies all array values
-	 * and the valid information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The commit call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#include <framework/datapoolglob/GlobalPoolVector.tpp>
-
-template<typename T, uint16_t vectorSize>
-using gp_vec_t = GlobPoolVector<T, vectorSize>;
-
-#endif /* POOLVECTOR_H_ */
+#ifndef GLOBALPOOLVECTOR_H_
+#define GLOBALPOOLVECTOR_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ *
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class GlobPoolVector: public PoolVariableIF {
+public:
+	/**
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if no nullptr is passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but sets the
+	 * value attribute to default (0). The value is fetched within the
+	 * read() operation.
+	 * @param set_id
+	 * This is the id in the global data pool this instance of the access
+	 * class corresponds to.
+	 * @param dataSet
+	 * The data set in which the variable shall register itself. If nullptr,
+	 * the variable is not registered.
+	 * @param setWritable
+	 * If this flag is set to true, changes in the value attribute can be
+	 * written back to the data pool, otherwise not.
+	 */
+	GlobPoolVector(uint32_t set_id, DataSetIF* set,
+			ReadWriteMode_t setReadWriteMode);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a local array of this type.
+	 */
+	T value[vectorSize];
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVector() {};
+	/**
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
+	 */
+	uint8_t getSize() {
+		return vectorSize;
+	}
+	/**
+	 * @brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const {
+		return dataPoolId;
+	}
+	/**
+	 * @brief This operation sets the data pool id of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId) {
+		dataPoolId = poolId;
+	}
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const {
+		return readWriteMode;
+	}
+
+
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const {
+		if (valid != INVALID)
+			return true;
+		else
+			return false;
+	}
+	void setValid(bool valid) {this->valid = valid;}
+	uint8_t getValid() {return valid;}
+
+	T &operator [](int i) {return value[i];}
+	const T &operator [](int i) const {return value[i];}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t max_size, Endianness streamEndianness) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies all array values
+	 * and the valid information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The commit call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+};
+
+#include "../datapoolglob/GlobalPoolVector.tpp"
+
+template<typename T, uint16_t vectorSize>
+using gp_vec_t = GlobPoolVector<T, vectorSize>;
+
+#endif /* POOLVECTOR_H_ */
diff --git a/datapoolglob/PIDReader.h b/datapoolglob/PIDReader.h
index a11160402..7d12a0fd6 100644
--- a/datapoolglob/PIDReader.h
+++ b/datapoolglob/PIDReader.h
@@ -1,164 +1,164 @@
-#ifndef PIDREADER_H_
-#define PIDREADER_H_
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-template<typename U, uint8_t n_var> class PIDReaderList;
-
-template<typename T>
-class PIDReader: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PIDReaderList;
-protected:
-	uint32_t parameterId;
-	uint8_t valid;
-	ReturnValue_t readWithoutLock() {
-		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
-				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
-		if (read_out != NULL) {
-			valid = read_out->valid;
-			value = read_out->address[arrayIndex];
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			value = 0;
-			valid = false;
-			sif::error << "PIDReader: read of PID 0x" << std::hex << parameterId
-					<< std::dec << " failed." << std::endl;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * Never commit, is read-only.
-	 * Reason is the possibility to access a single DP vector element, but if we commit,
-	 * we set validity of the whole vector.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t commitWithoutLock() override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	PIDReader() :
-			parameterId(PoolVariableIF::NO_PARAMETER), valid(
-					PoolVariableIF::INVALID), value(0) {
-
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 */
-	T value;
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
-	 */
-	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
-			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
-					0) {
-		if (dataSet != NULL) {
-			dataSet->registerVariable(this);
-		}
-	}
-
-	ReturnValue_t read(uint32_t lockTimeout) override {
-		ReturnValue_t result = glob::dataPool.lockDataPool();
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = readWithoutLock();
-		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "PIDReader::read: Could not unlock data pool!"
-					<< std::endl;
-		}
-		return result;
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-	PIDReader(const PIDReader &rhs) :
-			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
-	}
-
-	/**
-	 * \brief	The classes destructor is empty.
-	 */
-	~PIDReader() {
-
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return GlobalDataPool::PIDToDataPoolId(parameterId);
-	}
-	uint32_t getParameterId() const {
-		return parameterId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return VAR_READ;
-	}
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid)
-			return true;
-		else
-			return false;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	void setValid(bool valid) {
-		this->valid = valid;
-	}
-
-	operator T() {
-		return value;
-	}
-
-	PIDReader<T>& operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-				streamEndianness);
-	}
-};
-
-#endif /* PIDREADER_H_ */
+#ifndef PIDREADER_H_
+#define PIDREADER_H_
+#include "../datapool/DataSetIF.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+template<typename U, uint8_t n_var> class PIDReaderList;
+
+template<typename T>
+class PIDReader: public PoolVariableIF {
+	template<typename U, uint8_t n_var> friend class PIDReaderList;
+protected:
+	uint32_t parameterId;
+	uint8_t valid;
+	ReturnValue_t readWithoutLock() {
+		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
+		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
+				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
+		if (read_out != NULL) {
+			valid = read_out->valid;
+			value = read_out->address[arrayIndex];
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			value = 0;
+			valid = false;
+			sif::error << "PIDReader: read of PID 0x" << std::hex << parameterId
+					<< std::dec << " failed." << std::endl;
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	/**
+	 * Never commit, is read-only.
+	 * Reason is the possibility to access a single DP vector element, but if we commit,
+	 * we set validity of the whole vector.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t commitWithoutLock() override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	/**
+	 * Empty ctor for List initialization
+	 */
+	PIDReader() :
+			parameterId(PoolVariableIF::NO_PARAMETER), valid(
+					PoolVariableIF::INVALID), value(0) {
+
+	}
+public:
+	/**
+	 * \brief	This is the local copy of the data pool entry.
+	 */
+	T value;
+	/**
+	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
+	 * 			passed).
+	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
+	 * 			attribute to default (0). The value is fetched within the read() operation.
+	 * \param set_id	This is the id in the global data pool this instance of the access class
+	 * 					corresponds to.
+	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
+	 * 					the variable is not registered.
+	 * \param setWritable If this flag is set to true, changes in the value attribute can be
+	 * 					written back to the data pool, otherwise not.
+	 */
+	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
+			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
+					0) {
+		if (dataSet != NULL) {
+			dataSet->registerVariable(this);
+		}
+	}
+
+	ReturnValue_t read(uint32_t lockTimeout) override {
+		ReturnValue_t result = glob::dataPool.lockDataPool();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = readWithoutLock();
+		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "PIDReader::read: Could not unlock data pool!"
+					<< std::endl;
+		}
+		return result;
+	}
+	/**
+	 * Copy ctor to copy classes containing Pool Variables.
+	 */
+	PIDReader(const PIDReader &rhs) :
+			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
+	}
+
+	/**
+	 * \brief	The classes destructor is empty.
+	 */
+	~PIDReader() {
+
+	}
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const {
+		return GlobalDataPool::PIDToDataPoolId(parameterId);
+	}
+	uint32_t getParameterId() const {
+		return parameterId;
+	}
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const {
+		return VAR_READ;
+	}
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const {
+		if (valid)
+			return true;
+		else
+			return false;
+	}
+
+	uint8_t getValid() {
+		return valid;
+	}
+
+	void setValid(bool valid) {
+		this->valid = valid;
+	}
+
+	operator T() {
+		return value;
+	}
+
+	PIDReader<T>& operator=(T newValue) {
+		value = newValue;
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	virtual size_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+				streamEndianness);
+	}
+};
+
+#endif /* PIDREADER_H_ */
diff --git a/datapoolglob/PIDReaderList.h b/datapoolglob/PIDReaderList.h
index 0b8385081..b167feaa0 100644
--- a/datapoolglob/PIDReaderList.h
+++ b/datapoolglob/PIDReaderList.h
@@ -1,27 +1,27 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapoolglob/PIDReader.h>
-template <class T, uint8_t n_var>
-class PIDReaderList {
-private:
-	PIDReader<T> variables[n_var];
-public:
-	PIDReaderList( const uint32_t setPid[n_var], DataSetIF* dataSet) {
-		//I really should have a look at the new init list c++ syntax.
-		if (dataSet == NULL) {
-			return;
-		}
-		for (uint8_t count = 0; count < n_var; count++) {
-			variables[count].parameterId = setPid[count];
-			dataSet->registerVariable(&variables[count]);
-		}
-	}
-
-	PIDReader<T> &operator [](int i) { return variables[i]; }
-};
-
-
-
-#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
+#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
+#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
+
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoolglob/PIDReader.h"
+template <class T, uint8_t n_var>
+class PIDReaderList {
+private:
+	PIDReader<T> variables[n_var];
+public:
+	PIDReaderList( const uint32_t setPid[n_var], DataSetIF* dataSet) {
+		//I really should have a look at the new init list c++ syntax.
+		if (dataSet == NULL) {
+			return;
+		}
+		for (uint8_t count = 0; count < n_var; count++) {
+			variables[count].parameterId = setPid[count];
+			dataSet->registerVariable(&variables[count]);
+		}
+	}
+
+	PIDReader<T> &operator [](int i) { return variables[i]; }
+};
+
+
+
+#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index 783418cc9..09093cd6e 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -1,239 +1,239 @@
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapoolglob/PoolRawAccess.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/serialize/EndianConverter.h>
-
-#include <cstring>
-
-PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
-		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
-		readWriteMode(setReadWriteMode) {
-	memset(value, 0, sizeof(value));
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
-
-PoolRawAccess::~PoolRawAccess() {}
-
-ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::readWithoutLock() {
-	ReturnValue_t result = RETURN_FAILED;
-	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
-	if (readOut != nullptr) {
-		result = handleReadOut(readOut);
-		if(result == RETURN_OK) {
-			return result;
-		}
-	} else {
-		result = READ_ENTRY_NON_EXISTENT;
-	}
-	handleReadError(result);
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
-	ReturnValue_t result = RETURN_FAILED;
-	valid = readOut->getValid();
-	if (readOut->getSize() > arrayEntry) {
-		arraySize = readOut->getSize();
-		typeSize = readOut->getByteSize() / readOut->getSize();
-		type = readOut->getType();
-		if (typeSize <= sizeof(value)) {
-			uint16_t arrayPosition = arrayEntry * typeSize;
-			sizeTillEnd = readOut->getByteSize() - arrayPosition;
-			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
-			memcpy(value, ptr, typeSize);
-			return RETURN_OK;
-		} else {
-			result = READ_TYPE_TOO_LARGE;
-		}
-	} else {
-		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
-		result = READ_INDEX_TOO_LARGE;
-	}
-	return result;
-}
-
-void PoolRawAccess::handleReadError(ReturnValue_t result) {
-	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed, ";
-	if(result == READ_TYPE_TOO_LARGE) {
-		sif::error << "type too large." << std::endl;
-	}
-	else if(result == READ_INDEX_TOO_LARGE) {
-		sif::error << "index too large." << std::endl;
-	}
-	else if(result == READ_ENTRY_NON_EXISTENT) {
-		sif::error << "entry does not exist." << std::endl;
-	}
-
-	valid = INVALID;
-	typeSize = 0;
-	sizeTillEnd = 0;
-	memset(value, 0, sizeof(value));
-}
-
-ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::commitWithoutLock() {
-	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
-	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-		write_back->setValid(valid);
-		uint8_t array_position = arrayEntry * typeSize;
-		uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position];
-		memcpy(ptr, value, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t* PoolRawAccess::getEntry() {
-	return value;
-}
-
-ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		size_t* writtenBytes, size_t max_size) {
-	uint8_t* data_ptr = getEntry();
-	// debug << "PoolRawAccess::getEntry: Array position: " <<
-	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
-	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
-	if (typeSize == 0)
-		return DATA_POOL_ACCESS_FAILED;
-	if (typeSize > max_size)
-		return INCORRECT_SIZE;
-	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
-	*writtenBytes = typeSize;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-        size_t maxSize, Endianness streamEndianness) const {
-    if (typeSize + *size <= maxSize) {
-    	switch(streamEndianness) {
-    	case(Endianness::BIG):
-    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::MACHINE):
-    	default:
-            memcpy(*buffer, value, typeSize);
-            break;
-        }
-        *size += typeSize;
-        (*buffer) += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    } else {
-        return SerializeIF::BUFFER_TOO_SHORT;
-    }
-}
-
-
-Type PoolRawAccess::getType() {
-	return type;
-}
-
-size_t PoolRawAccess::getSizeOfType() {
-	return typeSize;
-}
-
-size_t PoolRawAccess::getArraySize(){
-	return arraySize;
-}
-
-uint32_t PoolRawAccess::getDataPoolId() const {
-	return dataPoolId;
-}
-
-PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
-	return readWriteMode;
-}
-
-ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
-		size_t setSize) {
-	if (typeSize == setSize) {
-		EndianConverter::convertBigEndian(value, buffer, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
-				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
-				<< std::endl;
-		return INCORRECT_SIZE;
-	}
-}
-
-bool PoolRawAccess::isValid() const {
-	if (valid != INVALID)
-		return true;
-	else
-		return false;
-}
-
-void PoolRawAccess::setValid(bool valid) {
-	this->valid = valid;
-}
-
-size_t PoolRawAccess::getSizeTillEnd() const {
-	return sizeTillEnd;
-}
-
-
-size_t PoolRawAccess::getSerializedSize() const {
-	return typeSize;
-}
-
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
-        Endianness streamEndianness) {
-
-    if (*size >= typeSize) {
-        switch(streamEndianness) {
-        case(Endianness::BIG):
-			EndianConverter::convertBigEndian(value, *buffer, typeSize);
-		    break;
-        case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
-		   	break;
-        case(Endianness::MACHINE):
-        default:
-            memcpy(value, *buffer, typeSize);
-            break;
-        }
-    	*size -= typeSize;
-        *buffer += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-    	return SerializeIF::STREAM_TOO_SHORT;
-    }
-}
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serialize/EndianConverter.h"
+
+#include <cstring>
+
+PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
+		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
+		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
+		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
+		readWriteMode(setReadWriteMode) {
+	memset(value, 0, sizeof(value));
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+PoolRawAccess::~PoolRawAccess() {}
+
+ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::readWithoutLock() {
+	ReturnValue_t result = RETURN_FAILED;
+	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
+	if (readOut != nullptr) {
+		result = handleReadOut(readOut);
+		if(result == RETURN_OK) {
+			return result;
+		}
+	} else {
+		result = READ_ENTRY_NON_EXISTENT;
+	}
+	handleReadError(result);
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
+	ReturnValue_t result = RETURN_FAILED;
+	valid = readOut->getValid();
+	if (readOut->getSize() > arrayEntry) {
+		arraySize = readOut->getSize();
+		typeSize = readOut->getByteSize() / readOut->getSize();
+		type = readOut->getType();
+		if (typeSize <= sizeof(value)) {
+			uint16_t arrayPosition = arrayEntry * typeSize;
+			sizeTillEnd = readOut->getByteSize() - arrayPosition;
+			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
+			memcpy(value, ptr, typeSize);
+			return RETURN_OK;
+		} else {
+			result = READ_TYPE_TOO_LARGE;
+		}
+	} else {
+		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
+		result = READ_INDEX_TOO_LARGE;
+	}
+	return result;
+}
+
+void PoolRawAccess::handleReadError(ReturnValue_t result) {
+	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
+			<< std::dec << " failed, ";
+	if(result == READ_TYPE_TOO_LARGE) {
+		sif::error << "type too large." << std::endl;
+	}
+	else if(result == READ_INDEX_TOO_LARGE) {
+		sif::error << "index too large." << std::endl;
+	}
+	else if(result == READ_ENTRY_NON_EXISTENT) {
+		sif::error << "entry does not exist." << std::endl;
+	}
+
+	valid = INVALID;
+	typeSize = 0;
+	sizeTillEnd = 0;
+	memset(value, 0, sizeof(value));
+}
+
+ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::commitWithoutLock() {
+	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
+	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
+		write_back->setValid(valid);
+		uint8_t array_position = arrayEntry * typeSize;
+		uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position];
+		memcpy(ptr, value, typeSize);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t* PoolRawAccess::getEntry() {
+	return value;
+}
+
+ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
+		size_t* writtenBytes, size_t max_size) {
+	uint8_t* data_ptr = getEntry();
+	// debug << "PoolRawAccess::getEntry: Array position: " <<
+	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
+	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
+	if (typeSize == 0)
+		return DATA_POOL_ACCESS_FAILED;
+	if (typeSize > max_size)
+		return INCORRECT_SIZE;
+	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
+	*writtenBytes = typeSize;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+        size_t maxSize, Endianness streamEndianness) const {
+    if (typeSize + *size <= maxSize) {
+    	switch(streamEndianness) {
+    	case(Endianness::BIG):
+    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::MACHINE):
+    	default:
+            memcpy(*buffer, value, typeSize);
+            break;
+        }
+        *size += typeSize;
+        (*buffer) += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return SerializeIF::BUFFER_TOO_SHORT;
+    }
+}
+
+
+Type PoolRawAccess::getType() {
+	return type;
+}
+
+size_t PoolRawAccess::getSizeOfType() {
+	return typeSize;
+}
+
+size_t PoolRawAccess::getArraySize(){
+	return arraySize;
+}
+
+uint32_t PoolRawAccess::getDataPoolId() const {
+	return dataPoolId;
+}
+
+PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
+	return readWriteMode;
+}
+
+ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
+		size_t setSize) {
+	if (typeSize == setSize) {
+		EndianConverter::convertBigEndian(value, buffer, typeSize);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
+				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
+				<< std::endl;
+		return INCORRECT_SIZE;
+	}
+}
+
+bool PoolRawAccess::isValid() const {
+	if (valid != INVALID)
+		return true;
+	else
+		return false;
+}
+
+void PoolRawAccess::setValid(bool valid) {
+	this->valid = valid;
+}
+
+size_t PoolRawAccess::getSizeTillEnd() const {
+	return sizeTillEnd;
+}
+
+
+size_t PoolRawAccess::getSerializedSize() const {
+	return typeSize;
+}
+
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
+        Endianness streamEndianness) {
+
+    if (*size >= typeSize) {
+        switch(streamEndianness) {
+        case(Endianness::BIG):
+			EndianConverter::convertBigEndian(value, *buffer, typeSize);
+		    break;
+        case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
+		   	break;
+        case(Endianness::MACHINE):
+        default:
+            memcpy(value, *buffer, typeSize);
+            break;
+        }
+    	*size -= typeSize;
+        *buffer += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+    	return SerializeIF::STREAM_TOO_SHORT;
+    }
+}
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index 22dc312d7..a1bed466d 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -1,220 +1,220 @@
-#ifndef POOLRAWACCESS_H_
-#define POOLRAWACCESS_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolEntryIF.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/globalfunctions/Type.h>
-
-/**
- * @brief This class allows accessing Data Pool variables as raw bytes.
- * @details
- * This is necessary to have an access method for HK data, as the PID's alone
- * do not provide type information. Please note that the the raw pool access
- * read() and commit() calls are not thread-safe.
- *
- * Please supply a data set and use the data set read(), commit() calls for
- * thread-safe data pool access.
- * @ingroup data_pool
- */
-class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
-public:
-	/**
-	 * This constructor is used to access a data pool entry with a
-	 * given ID if the target type is not known. A DataSet object is supplied
-	 * and the data pool entry with the given ID is registered to that data set.
-	 * Please note that a pool raw access buffer only has a buffer
-	 * with a size of double. As such, for vector entries which have
-	 * @param data_pool_id Target data pool entry ID
-	 * @param arrayEntry
-	 * @param data_set Dataset to register data pool entry to
-	 * @param setReadWriteMode
-	 * @param registerVectors If set to true, the constructor checks if
-	 *                        there are multiple vector entries to registers
-	 *                        and registers all of them recursively into the data_set
-	 *
-	 */
-	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
-			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-					PoolVariableIF::VAR_READ);
-
-	/**
-	 * @brief	This operation returns a pointer to the entry fetched.
-	 * @details	Return pointer to the buffer containing the raw data
-	 *          Size and number of data can be retrieved by other means.
-	 */
-	uint8_t* getEntry();
-	/**
-	 * @brief 	This operation returns the fetched entry from the data pool and
-	 * 			flips the bytes, if necessary.
-	 * @details	It makes use of the getEntry call of this function, but additionally flips the
-	 * 			bytes to big endian, which is the default for external communication (as House-
-	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given max_size.
-	 * @param buffer	A pointer to a buffer to write to
-	 * @param writtenBytes	The number of bytes written is returned with this value.
-	 * @param max_size	The maximum size that the function may write to buffer.
-	 * @return	- @c RETURN_OK if entry could be acquired
-	 * 			- @c RETURN_FAILED else.
-	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
-			size_t maxSize);
-
-	/**
-	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @param buffer Provided buffer. Raw pool data will be copied here
-	 * @param size [out] Increment provided size value by serialized size
-	 * @param max_size Maximum allowed serialization size
-	 * @param bigEndian Specify endianess
-	 * @return - @c RETURN_OK if serialization was successfull
-	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
-	 */
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-	        size_t maxSize, Endianness streamEndianness) const override;
-
-    size_t getSerializedSize() const override;
-
-    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-            Endianness streamEndianness) override;
-
-	/**
-	 * With this method, the content can be set from a big endian buffer safely.
-	 * @param buffer	Pointer to the data to set
-	 * @param size		Size of the data to write. Must fit this->size.
-	 * @return	- @c RETURN_OK on success
-	 * 			- @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			size_t setSize);
-	/**
-	 *  @brief This operation returns the type of the entry currently stored.
-	 */
-	Type getType();
-	/**
-	 *  @brief This operation returns the size of the entry currently stored.
-	 */
-	size_t getSizeOfType();
-	/**
-	 *
-	 * @return the size of the datapool array
-	 */
-	size_t getArraySize();
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
-	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
-	uint8_t value[RAW_MAX_SIZE];
-
-
-	/**
-	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolRawAccess();
-
-	/**
-	 * This method returns if the variable is read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const;
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const;
-
-	void setValid(bool valid);
-	/**
-	 * Getter for the remaining size.
-	 */
-	size_t getSizeTillEnd() const;
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The call is protected by a lock of the global data pool.
-	 * @return -@c RETURN_OK Read successfull
-	 * 		   -@c READ_TYPE_TOO_LARGE
-	 * 		   -@c READ_INDEX_TOO_LARGE
-	 * 		   -@c READ_ENTRY_NON_EXISTENT
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The call is protected by a lock of the global data pool.
-	 *
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
-	void handleReadError(ReturnValue_t result);
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The array entry that is fetched from the data pool.
-	 */
-	uint8_t arrayEntry;
-	/**
-	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	This value contains the type of the data pool entry.
-	 */
-	Type type;
-	/**
-	 * @brief	This value contains the size of the data pool entry type in bytes.
-	 */
-	size_t typeSize;
-	/**
-	 * The size of the DP array (single values return 1)
-	 */
-	size_t arraySize;
-	/**
-	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
-	 */
-	size_t sizeTillEnd;
-	/**
-	 * @brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#endif /* POOLRAWACCESS_H_ */
+#ifndef POOLRAWACCESS_H_
+#define POOLRAWACCESS_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntryIF.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../globalfunctions/Type.h"
+
+/**
+ * @brief This class allows accessing Data Pool variables as raw bytes.
+ * @details
+ * This is necessary to have an access method for HK data, as the PID's alone
+ * do not provide type information. Please note that the the raw pool access
+ * read() and commit() calls are not thread-safe.
+ *
+ * Please supply a data set and use the data set read(), commit() calls for
+ * thread-safe data pool access.
+ * @ingroup data_pool
+ */
+class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
+public:
+	/**
+	 * This constructor is used to access a data pool entry with a
+	 * given ID if the target type is not known. A DataSet object is supplied
+	 * and the data pool entry with the given ID is registered to that data set.
+	 * Please note that a pool raw access buffer only has a buffer
+	 * with a size of double. As such, for vector entries which have
+	 * @param data_pool_id Target data pool entry ID
+	 * @param arrayEntry
+	 * @param data_set Dataset to register data pool entry to
+	 * @param setReadWriteMode
+	 * @param registerVectors If set to true, the constructor checks if
+	 *                        there are multiple vector entries to registers
+	 *                        and registers all of them recursively into the data_set
+	 *
+	 */
+	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
+			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
+					PoolVariableIF::VAR_READ);
+
+	/**
+	 * @brief	This operation returns a pointer to the entry fetched.
+	 * @details	Return pointer to the buffer containing the raw data
+	 *          Size and number of data can be retrieved by other means.
+	 */
+	uint8_t* getEntry();
+	/**
+	 * @brief 	This operation returns the fetched entry from the data pool and
+	 * 			flips the bytes, if necessary.
+	 * @details	It makes use of the getEntry call of this function, but additionally flips the
+	 * 			bytes to big endian, which is the default for external communication (as House-
+	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
+	 * 			buffer, if it fits in the given max_size.
+	 * @param buffer	A pointer to a buffer to write to
+	 * @param writtenBytes	The number of bytes written is returned with this value.
+	 * @param max_size	The maximum size that the function may write to buffer.
+	 * @return	- @c RETURN_OK if entry could be acquired
+	 * 			- @c RETURN_FAILED else.
+	 */
+	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
+			size_t maxSize);
+
+	/**
+	 * @brief 	Serialize raw pool entry into provided buffer directly
+	 * @param buffer Provided buffer. Raw pool data will be copied here
+	 * @param size [out] Increment provided size value by serialized size
+	 * @param max_size Maximum allowed serialization size
+	 * @param bigEndian Specify endianess
+	 * @return - @c RETURN_OK if serialization was successfull
+	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
+	 */
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+	        size_t maxSize, Endianness streamEndianness) const override;
+
+    size_t getSerializedSize() const override;
+
+    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+            Endianness streamEndianness) override;
+
+	/**
+	 * With this method, the content can be set from a big endian buffer safely.
+	 * @param buffer	Pointer to the data to set
+	 * @param size		Size of the data to write. Must fit this->size.
+	 * @return	- @c RETURN_OK on success
+	 * 			- @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
+			size_t setSize);
+	/**
+	 *  @brief This operation returns the type of the entry currently stored.
+	 */
+	Type getType();
+	/**
+	 *  @brief This operation returns the size of the entry currently stored.
+	 */
+	size_t getSizeOfType();
+	/**
+	 *
+	 * @return the size of the datapool array
+	 */
+	size_t getArraySize();
+	/**
+	 * @brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
+	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
+	static const uint8_t RAW_MAX_SIZE = sizeof(double);
+	uint8_t value[RAW_MAX_SIZE];
+
+
+	/**
+	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~PoolRawAccess();
+
+	/**
+	 * This method returns if the variable is read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const;
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const;
+
+	void setValid(bool valid);
+	/**
+	 * Getter for the remaining size.
+	 */
+	size_t getSizeTillEnd() const;
+
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The call is protected by a lock of the global data pool.
+	 * @return -@c RETURN_OK Read successfull
+	 * 		   -@c READ_TYPE_TOO_LARGE
+	 * 		   -@c READ_INDEX_TOO_LARGE
+	 * 		   -@c READ_ENTRY_NON_EXISTENT
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The call is protected by a lock of the global data pool.
+	 *
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
+	void handleReadError(ReturnValue_t result);
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * 			is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * @brief	The array entry that is fetched from the data pool.
+	 */
+	uint8_t arrayEntry;
+	/**
+	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	This value contains the type of the data pool entry.
+	 */
+	Type type;
+	/**
+	 * @brief	This value contains the size of the data pool entry type in bytes.
+	 */
+	size_t typeSize;
+	/**
+	 * The size of the DP array (single values return 1)
+	 */
+	size_t arraySize;
+	/**
+	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
+	 */
+	size_t sizeTillEnd;
+	/**
+	 * @brief	The information whether the class is read-write or read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+};
+
+#endif /* POOLRAWACCESS_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 0095f8944..8703233c3 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
-#define FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
-#include <framework/datapool/PoolEntryIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-#include <framework/housekeeping/HousekeepingMessage.h>
-#include <map>
-
-class LocalDataPoolManager;
-class DataSetIF;
-/**
- * @brief	Type definition for local pool entries.
- */
-using lp_id_t = uint32_t;
-using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
-using LocalDataPoolMapIter = LocalDataPool::iterator;
-
-/**
- * @brief 		This interface is implemented by classes which posses a local
- * 				data pool (not the managing class). It defines the relationship
- * 				between the local data pool owner and the LocalDataPoolManager.
- * @details
- * Any class implementing this interface shall also have a LocalDataPoolManager
- * member class which contains the actual pool data structure
- * and exposes the public interface for it.
- * This is required because the pool entries are templates, which makes
- * specifying an interface rather difficult. The local data pool can be
- * accessed by using the LocalPoolVariable, LocalPoolVector or LocalDataSet
- * classes.
- *
- * Architectural Note:
- * This could be circumvented by using a wrapper/accessor function or
- * implementing the templated function in this interface..
- * The first solution sounds better than the second but
- * the LocalPoolVariable classes are templates as well, so this just shifts
- * the problem somewhere else. Interfaces are nice, but the most
- * pragmatic solution I found was to offer the client the full interface
- * of the LocalDataPoolManager.
- */
-class HasLocalDataPoolIF {
-public:
-	virtual~ HasLocalDataPoolIF() {};
-
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
-
-	/** Command queue for housekeeping messages. */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-
-	/** Is used by pool owner to initialize the pool map once */
-	virtual ReturnValue_t initializePoolEntries(
-	        LocalDataPool& localDataPoolMap) = 0;
-
-	/** Can be used to get a handle to the local data pool manager. */
-	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
-
-	/**
-	 * This function is used by the pool manager to get a valid dataset
-     * from a SID
-	 * @param sid Corresponding structure ID
-	 * @return
-	 */
-	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
-
-	/* These function can be implemented by pool owner, as they are required
-	 * by the housekeeping message interface */
-	virtual ReturnValue_t addDataSet(sid_t sid) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-	virtual ReturnValue_t removeDataSet(sid_t sid) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
-	        dur_seconds_t newInterval) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-};
-
-#endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */
+#ifndef FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
+#define FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
+#include "../datapool/PoolEntryIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include "../housekeeping/HousekeepingMessage.h"
+#include <map>
+
+class LocalDataPoolManager;
+class DataSetIF;
+/**
+ * @brief	Type definition for local pool entries.
+ */
+using lp_id_t = uint32_t;
+using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
+using LocalDataPoolMapIter = LocalDataPool::iterator;
+
+/**
+ * @brief 		This interface is implemented by classes which posses a local
+ * 				data pool (not the managing class). It defines the relationship
+ * 				between the local data pool owner and the LocalDataPoolManager.
+ * @details
+ * Any class implementing this interface shall also have a LocalDataPoolManager
+ * member class which contains the actual pool data structure
+ * and exposes the public interface for it.
+ * This is required because the pool entries are templates, which makes
+ * specifying an interface rather difficult. The local data pool can be
+ * accessed by using the LocalPoolVariable, LocalPoolVector or LocalDataSet
+ * classes.
+ *
+ * Architectural Note:
+ * This could be circumvented by using a wrapper/accessor function or
+ * implementing the templated function in this interface..
+ * The first solution sounds better than the second but
+ * the LocalPoolVariable classes are templates as well, so this just shifts
+ * the problem somewhere else. Interfaces are nice, but the most
+ * pragmatic solution I found was to offer the client the full interface
+ * of the LocalDataPoolManager.
+ */
+class HasLocalDataPoolIF {
+public:
+	virtual~ HasLocalDataPoolIF() {};
+
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
+
+	/** Command queue for housekeeping messages. */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+	/** Is used by pool owner to initialize the pool map once */
+	virtual ReturnValue_t initializePoolEntries(
+	        LocalDataPool& localDataPoolMap) = 0;
+
+	/** Can be used to get a handle to the local data pool manager. */
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
+	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
+
+	/* These function can be implemented by pool owner, as they are required
+	 * by the housekeeping message interface */
+	virtual ReturnValue_t addDataSet(sid_t sid) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+	virtual ReturnValue_t removeDataSet(sid_t sid) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
+	        dur_seconds_t newInterval) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+};
+
+#endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 02016abf0..434dd6ae6 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,218 +1,218 @@
-#include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/datapoollocal/LocalDataSet.h>
-#include <framework/housekeeping/AcceptsHkPacketsIF.h>
-#include <framework/ipc/MutexFactory.h>
-#include <framework/ipc/MutexHelper.h>
-#include <framework/ipc/QueueFactory.h>
-
-#include <array>
-
-LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
-        MessageQueueIF* queueToUse, bool appendValidityBuffer):
-        appendValidityBuffer(appendValidityBuffer) {
-	if(owner == nullptr) {
-		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
-		return;
-	}
-	this->owner = owner;
-	mutex = MutexFactory::instance()->createMutex();
-	if(mutex == nullptr) {
-	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-	            "Could not create mutex." << std::endl;
-	}
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if(ipcStore == nullptr) {
-	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-	            "Could not set IPC store." << std::endl;
-	}
-	hkQueue = queueToUse;
-}
-
-ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
-        object_id_t hkDestination) {
-    if(queueToUse == nullptr) {
-        sif::error << "LocalDataPoolManager::initialize: Supplied queue "
-                "invalid!" << std::endl;
-    }
-    hkQueue = queueToUse;
-
-    if(hkDestination == objects::NO_OBJECT) {
-        return initializeHousekeepingPoolEntriesOnce();
-    }
-
-    AcceptsHkPacketsIF* hkReceiver =
-            objectManager->get<AcceptsHkPacketsIF>(hkDestination);
-    if(hkReceiver != nullptr) {
-        setHkPacketDestination(hkReceiver->getHkQueue());
-    }
-    else {
-        sif::warning << "LocalDataPoolManager::initialize: Could not retrieve"
-                " queue ID from HK destination object ID. " << std::flush;
-        sif::warning << "Make sure it exists and the object impements "
-                "AcceptsHkPacketsIF!" << std::endl;
-    }
-    return initializeHousekeepingPoolEntriesOnce();
-}
-
-void LocalDataPoolManager::setHkPacketDestination(
-        MessageQueueId_t hkDestination) {
-    this->hkDestination = hkDestination;
-}
-
-LocalDataPoolManager::~LocalDataPoolManager() {}
-
-ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
-	if(not mapInitialized) {
-		ReturnValue_t result = owner->initializePoolEntries(localPoolMap);
-		if(result == HasReturnvaluesIF::RETURN_OK) {
-			mapInitialized = true;
-		}
-		return result;
-	}
-	sif::warning << "HousekeepingManager: The map should only be initialized "
-	        "once!" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-		CommandMessage* message) {
-    Command_t command = message->getCommand();
-    switch(command) {
-    // I think those are the only commands which can be handled here..
-    case(HousekeepingMessage::ADD_HK_REPORT_STRUCT):
-    case(HousekeepingMessage::ADD_DIAGNOSTICS_REPORT_STRUCT):
-        // We should use OwnsLocalPoolDataIF to specify those functions..
-        return HasReturnvaluesIF::RETURN_OK;
-    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
-    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-        //return generateSetStructurePacket(message->getSid());
-    case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
-    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
-        //return generateHousekeepingPacket(message->getSid());
-    default:
-        return CommandMessageIF::UNKNOWN_COMMAND;
-    }
-}
-
-ReturnValue_t LocalDataPoolManager::printPoolEntry(
-		lp_id_t localPoolId) {
-	auto poolIter = localPoolMap.find(localPoolId);
-	if (poolIter == localPoolMap.end()) {
-		sif::debug << "HousekeepingManager::fechPoolEntry:"
-				" Pool entry not found." << std::endl;
-		return POOL_ENTRY_NOT_FOUND;
-	}
-	poolIter->second->print();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MutexIF* LocalDataPoolManager::getMutexHandle() {
-	return mutex;
-}
-
-const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
-    return owner;
-}
-
-ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        MessageQueueId_t sendTo) {
-	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
-			owner->getDataSetHandle(sid));
-	if(dataSetToSerialize == nullptr) {
-		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				" Set ID not found" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	store_address_t storeId;
-	ReturnValue_t result = serializeHkPacketIntoStore(&storeId,
-	        dataSetToSerialize);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-	    return result;
-	}
-
-	// and now we set a HK message and send it the HK packet destination.
-	CommandMessage hkMessage;
-	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
-	if(hkQueue == nullptr) {
-	    return QUEUE_OR_DESTINATION_NOT_SET;
-	}
-
-	if(sendTo != MessageQueueIF::NO_QUEUE) {
-	    result = hkQueue->sendMessage(sendTo, &hkMessage);
-	}
-	else {
-	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
-	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
-	                " Destination is not set properly!" << std::endl;
-	        return QUEUE_OR_DESTINATION_NOT_SET;
-	    }
-	    else {
-	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
-	    }
-	}
-
-	return result;
-}
-
-ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
-    LocalDataSet* dataSet = dynamic_cast<LocalDataSet*>(
-            owner->getDataSetHandle(sid));
-    if(dataSet == nullptr) {
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                " Set ID not found" << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t);
-    uint8_t* storePtr = nullptr;
-    store_address_t storeId;
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            expectedSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                "Could not get free element from IPC store." << std::endl;
-        return result;
-    }
-    size_t size = 0;
-    result = dataSet->serializeLocalPoolIds(&storePtr, &size,
-            expectedSize, SerializeIF::Endianness::BIG);
-    if(expectedSize != size) {
-        sif::error << "HousekeepingManager::generateSetStructurePacket: "
-                "Expected size is not equal to serialized size" << std::endl;
-    }
-    return result;
-}
-
-void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
-}
-
-ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-        store_address_t *storeId, LocalDataSet* dataSet) {
-    size_t hkSize = dataSet->getSerializedSize();
-    uint8_t* storePtr = nullptr;
-    ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                "Could not get free element from IPC store." << std::endl;
-        return result;
-    }
-    size_t size = 0;
-
-    if(appendValidityBuffer) {
-        result = dataSet->serializeWithValidityBuffer(&storePtr,
-                &size, hkSize, SerializeIF::Endianness::MACHINE);
-    }
-    else {
-        result = dataSet->serialize(&storePtr, &size, hkSize,
-                SerializeIF::Endianness::MACHINE);
-    }
-
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::serializeHkPacketIntoStore: "
-                "Serialization proccess failed!" << std::endl;
-    }
-    return result;
-}
-
-ReturnValue_t LocalDataPoolManager::performHkOperation() {
-    return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../datapoollocal/LocalDataSet.h"
+#include "../housekeeping/AcceptsHkPacketsIF.h"
+#include "../ipc/MutexFactory.h"
+#include "../ipc/MutexHelper.h"
+#include "../ipc/QueueFactory.h"
+
+#include <array>
+
+LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
+        MessageQueueIF* queueToUse, bool appendValidityBuffer):
+        appendValidityBuffer(appendValidityBuffer) {
+	if(owner == nullptr) {
+		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
+		return;
+	}
+	this->owner = owner;
+	mutex = MutexFactory::instance()->createMutex();
+	if(mutex == nullptr) {
+	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+	            "Could not create mutex." << std::endl;
+	}
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if(ipcStore == nullptr) {
+	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+	            "Could not set IPC store." << std::endl;
+	}
+	hkQueue = queueToUse;
+}
+
+ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
+        object_id_t hkDestination) {
+    if(queueToUse == nullptr) {
+        sif::error << "LocalDataPoolManager::initialize: Supplied queue "
+                "invalid!" << std::endl;
+    }
+    hkQueue = queueToUse;
+
+    if(hkDestination == objects::NO_OBJECT) {
+        return initializeHousekeepingPoolEntriesOnce();
+    }
+
+    AcceptsHkPacketsIF* hkReceiver =
+            objectManager->get<AcceptsHkPacketsIF>(hkDestination);
+    if(hkReceiver != nullptr) {
+        setHkPacketDestination(hkReceiver->getHkQueue());
+    }
+    else {
+        sif::warning << "LocalDataPoolManager::initialize: Could not retrieve"
+                " queue ID from HK destination object ID. " << std::flush;
+        sif::warning << "Make sure it exists and the object impements "
+                "AcceptsHkPacketsIF!" << std::endl;
+    }
+    return initializeHousekeepingPoolEntriesOnce();
+}
+
+void LocalDataPoolManager::setHkPacketDestination(
+        MessageQueueId_t hkDestination) {
+    this->hkDestination = hkDestination;
+}
+
+LocalDataPoolManager::~LocalDataPoolManager() {}
+
+ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
+	if(not mapInitialized) {
+		ReturnValue_t result = owner->initializePoolEntries(localPoolMap);
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			mapInitialized = true;
+		}
+		return result;
+	}
+	sif::warning << "HousekeepingManager: The map should only be initialized "
+	        "once!" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
+		CommandMessage* message) {
+    Command_t command = message->getCommand();
+    switch(command) {
+    // I think those are the only commands which can be handled here..
+    case(HousekeepingMessage::ADD_HK_REPORT_STRUCT):
+    case(HousekeepingMessage::ADD_DIAGNOSTICS_REPORT_STRUCT):
+        // We should use OwnsLocalPoolDataIF to specify those functions..
+        return HasReturnvaluesIF::RETURN_OK;
+    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
+    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
+        //return generateSetStructurePacket(message->getSid());
+    case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
+    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
+        //return generateHousekeepingPacket(message->getSid());
+    default:
+        return CommandMessageIF::UNKNOWN_COMMAND;
+    }
+}
+
+ReturnValue_t LocalDataPoolManager::printPoolEntry(
+		lp_id_t localPoolId) {
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
+		sif::debug << "HousekeepingManager::fechPoolEntry:"
+				" Pool entry not found." << std::endl;
+		return POOL_ENTRY_NOT_FOUND;
+	}
+	poolIter->second->print();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MutexIF* LocalDataPoolManager::getMutexHandle() {
+	return mutex;
+}
+
+const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
+    return owner;
+}
+
+ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
+        MessageQueueId_t sendTo) {
+	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
+			owner->getDataSetHandle(sid));
+	if(dataSetToSerialize == nullptr) {
+		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+				" Set ID not found" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	store_address_t storeId;
+	ReturnValue_t result = serializeHkPacketIntoStore(&storeId,
+	        dataSetToSerialize);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+	    return result;
+	}
+
+	// and now we set a HK message and send it the HK packet destination.
+	CommandMessage hkMessage;
+	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+	if(hkQueue == nullptr) {
+	    return QUEUE_OR_DESTINATION_NOT_SET;
+	}
+
+	if(sendTo != MessageQueueIF::NO_QUEUE) {
+	    result = hkQueue->sendMessage(sendTo, &hkMessage);
+	}
+	else {
+	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
+	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
+	                " Destination is not set properly!" << std::endl;
+	        return QUEUE_OR_DESTINATION_NOT_SET;
+	    }
+	    else {
+	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
+	    }
+	}
+
+	return result;
+}
+
+ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
+    LocalDataSet* dataSet = dynamic_cast<LocalDataSet*>(
+            owner->getDataSetHandle(sid));
+    if(dataSet == nullptr) {
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+                " Set ID not found" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t);
+    uint8_t* storePtr = nullptr;
+    store_address_t storeId;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            expectedSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+                "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
+    size_t size = 0;
+    result = dataSet->serializeLocalPoolIds(&storePtr, &size,
+            expectedSize, SerializeIF::Endianness::BIG);
+    if(expectedSize != size) {
+        sif::error << "HousekeepingManager::generateSetStructurePacket: "
+                "Expected size is not equal to serialized size" << std::endl;
+    }
+    return result;
+}
+
+void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
+}
+
+ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
+        store_address_t *storeId, LocalDataSet* dataSet) {
+    size_t hkSize = dataSet->getSerializedSize();
+    uint8_t* storePtr = nullptr;
+    ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+                "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
+    size_t size = 0;
+
+    if(appendValidityBuffer) {
+        result = dataSet->serializeWithValidityBuffer(&storePtr,
+                &size, hkSize, SerializeIF::Endianness::MACHINE);
+    }
+    else {
+        result = dataSet->serialize(&storePtr, &size, hkSize,
+                SerializeIF::Endianness::MACHINE);
+    }
+
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::serializeHkPacketIntoStore: "
+                "Serialization proccess failed!" << std::endl;
+    }
+    return result;
+}
+
+ReturnValue_t LocalDataPoolManager::performHkOperation() {
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index df7b9ff43..c5f8761fc 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,229 +1,229 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/ipc/MutexIF.h>
-
-#include <framework/housekeeping/HousekeepingMessage.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/datapoollocal/HasLocalDataPoolIF.h>
-#include <framework/ipc/CommandMessage.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MutexHelper.h>
-
-#include <map>
-
-class LocalDataSet;
-
-/**
- * @brief 	This class is the managing instance for local data pool.
- * @details
- * The actual data pool structure is a member of this class. Any class which
- * has a local data pool shall have this class as a member and implement
- * the HasLocalDataPoolIF.
- *
- * Users of the data pool use the helper classes LocalDataSet,
- * LocalPoolVariable and LocalPoolVector to access pool entries in
- * a thread-safe and efficient way.
- *
- * The local data pools employ a blackboard logic: Only the most recent
- * value is stored. The helper classes offer a read() and commit() interface
- * through the PoolVariableIF which is used to read and update values.
- * Each pool entry has a valid state too.
- *
- */
-class LocalDataPoolManager {
-	template<typename T>
-	friend class LocalPoolVar;
-	template<typename T, uint16_t vecSize>
-	friend class LocalPoolVector;
-	friend class LocalDataSet;
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
-
-    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
-    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
-
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
-    //static constexpr ReturnValue_t SET_NOT_FOUND = MAKE_RETURN_CODE(0x3);
-
-    /**
-     * This constructor is used by a class which wants to implement
-     * a personal local data pool. The queueToUse can be supplied if it
-     * is already known.
-     *
-     * initialize() has to be called in any case before using the object!
-     * @param owner
-     * @param queueToUse
-     * @param appendValidityBuffer
-     */
-	LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
-	        bool appendValidityBuffer = true);
-	virtual~ LocalDataPoolManager();
-
-	/**
-	 * Initializes the map by calling the map initialization function of the
-	 * owner and assigns the queue to use.
-	 * @param queueToUse
-	 * @return
-	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse,
-	        object_id_t hkDestination);
-
-	/**
-	 * This should be called in the periodic handler of the owner.
-	 * It performs all the periodic functionalities of the data pool manager.
-	 * @return
-	 */
-	ReturnValue_t performHkOperation();
-	/**
-	 * This function is used to set the default HK packet destination.
-	 * This destination will usually only be set once.
-	 * @param hkDestination
-	 */
-	void setHkPacketDestination(MessageQueueId_t hkDestination);
-
-	/**
-	 * Generate a housekeeping packet with a given SID.
-	 * @param sid
-	 * @return
-	 */
-	ReturnValue_t generateHousekeepingPacket(sid_t sid, MessageQueueId_t sendTo
-	        = MessageQueueIF::NO_QUEUE);
-	ReturnValue_t generateSetStructurePacket(sid_t sid);
-
-	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
-
-	/**
-	 * This function is used to fill the local data pool map with pool
-	 * entries. It should only be called once by the pool owner.
-	 * @param localDataPoolMap
-	 * @return
-	 */
-	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
-
-	const HasLocalDataPoolIF* getOwner() const;
-
-	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
-
-    /**
-     * Different types of housekeeping reporting are possible.
-     *  1. PERIODIC: HK packets are generated in fixed intervals
-     *  2. UPDATED: HK packets are generated if a value was updated
-     *  3. REQUESTED: HK packets are only generated if explicitely requested
-     */
-    enum class ReportingType: uint8_t {
-        PERIODIC,
-        ON_UPDATE,
-        REQUESTED
-    };
-
-    /* Copying forbidden */
-    LocalDataPoolManager(const LocalDataPoolManager &) = delete;
-    LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
-
-private:
-    LocalDataPool localPoolMap;
-    /** Every housekeeping data manager has a mutex to protect access
-     * to it's data pool. */
-    MutexIF* mutex = nullptr;
-    /** The class which actually owns the manager (and its datapool). */
-    HasLocalDataPoolIF* owner = nullptr;
-
-    /**
-     * The data pool manager will keep an internal map of HK receivers.
-     */
-    struct HkReceiver {
-        LocalDataSet* dataSet = nullptr;
-        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
-        ReportingType reportingType = ReportingType::PERIODIC;
-        bool reportingStatus = true;
-        /** Different members of this union will be used depending on reporting
-         * type */
-        union hkParameter {
-            /** This parameter will be used for the PERIODIC type */
-            dur_seconds_t collectionInterval = 0;
-            /** This parameter will be used for the ON_UPDATE type */
-            bool hkDataChanged;
-        };
-    };
-
-    /** Using a multimap as the same object might request multiple datasets */
-    using HkReceiversMap = std::multimap<object_id_t, struct HkReceiver>;
-
-    HkReceiversMap hkReceiversMap;
-
-    /** This is the map holding the actual data. Should only be initialized
-     * once ! */
-    bool mapInitialized = false;
-    /** This specifies whether a validity buffer is appended at the end
-     * of generated housekeeping packets. */
-    bool appendValidityBuffer = true;
-
-	/**
-	 * @brief Queue used for communication, for example commands.
-	 * Is also used to send messages. Can be set either in the constructor
-     * or in the initialize() function.
-	 */
-	MessageQueueIF* hkQueue = nullptr;
-
-	/**
-	 * HK replies will always be a reply to the commander, but HK packet
-	 * can be sent to another destination by specifying this message queue
-	 * ID, for example to a dedicated housekeeping service implementation.
-	 */
-	MessageQueueId_t hkDestination = MessageQueueIF::NO_QUEUE;
-
-	/** Global IPC store is used to store all packets. */
-	StorageManagerIF* ipcStore = nullptr;
-	/**
-	 * Get the pointer to the mutex. Can be used to lock the data pool
-	 * eternally. Use with care and don't forget to unlock locked mutexes!
-	 * For now, only friend classes can accss this function.
-	 * @return
-	 */
-	MutexIF* getMutexHandle();
-
-	/**
-	 * Read a variable by supplying its local pool ID and assign the pool
-	 * entry to the supplied PoolEntry pointer. The type of the pool entry
-	 * is deduced automatically. This call is not thread-safe!
-	 * For now, only friend classes like LocalPoolVar may access this
-	 * function.
-	 * @tparam T Type of the pool entry
-	 * @param localPoolId Pool ID of the variable to read
-	 * @param poolVar [out] Corresponding pool entry will be assigned to the
-	 * 						supplied pointer.
-	 * @return
-	 */
-	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
-			PoolEntry<T> **poolEntry);
-
-	void setMinimalSamplingFrequency(float frequencySeconds);
-	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
-	        LocalDataSet* dataSet);
-};
-
-
-template<class T> inline
-ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
-		PoolEntry<T> **poolEntry) {
-	auto poolIter = localPoolMap.find(localPoolId);
-	if (poolIter == localPoolMap.end()) {
-		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
-		        "not found." << std::endl;
-		return POOL_ENTRY_NOT_FOUND;
-	}
-
-	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
-	if(*poolEntry == nullptr) {
-		sif::debug << "HousekeepingManager::fetchPoolEntry:"
-				" Pool entry not found." << std::endl;
-		return POOL_ENTRY_TYPE_CONFLICT;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../ipc/MutexIF.h"
+
+#include "../housekeeping/HousekeepingMessage.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../ipc/CommandMessage.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../ipc/MutexHelper.h"
+
+#include <map>
+
+class LocalDataSet;
+
+/**
+ * @brief 	This class is the managing instance for local data pool.
+ * @details
+ * The actual data pool structure is a member of this class. Any class which
+ * has a local data pool shall have this class as a member and implement
+ * the HasLocalDataPoolIF.
+ *
+ * Users of the data pool use the helper classes LocalDataSet,
+ * LocalPoolVariable and LocalPoolVector to access pool entries in
+ * a thread-safe and efficient way.
+ *
+ * The local data pools employ a blackboard logic: Only the most recent
+ * value is stored. The helper classes offer a read() and commit() interface
+ * through the PoolVariableIF which is used to read and update values.
+ * Each pool entry has a valid state too.
+ *
+ */
+class LocalDataPoolManager {
+	template<typename T>
+	friend class LocalPoolVar;
+	template<typename T, uint16_t vecSize>
+	friend class LocalPoolVector;
+	friend class LocalDataSet;
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
+
+    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
+    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
+
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
+    //static constexpr ReturnValue_t SET_NOT_FOUND = MAKE_RETURN_CODE(0x3);
+
+    /**
+     * This constructor is used by a class which wants to implement
+     * a personal local data pool. The queueToUse can be supplied if it
+     * is already known.
+     *
+     * initialize() has to be called in any case before using the object!
+     * @param owner
+     * @param queueToUse
+     * @param appendValidityBuffer
+     */
+	LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+	        bool appendValidityBuffer = true);
+	virtual~ LocalDataPoolManager();
+
+	/**
+	 * Initializes the map by calling the map initialization function of the
+	 * owner and assigns the queue to use.
+	 * @param queueToUse
+	 * @return
+	 */
+	ReturnValue_t initialize(MessageQueueIF* queueToUse,
+	        object_id_t hkDestination);
+
+	/**
+	 * This should be called in the periodic handler of the owner.
+	 * It performs all the periodic functionalities of the data pool manager.
+	 * @return
+	 */
+	ReturnValue_t performHkOperation();
+	/**
+	 * This function is used to set the default HK packet destination.
+	 * This destination will usually only be set once.
+	 * @param hkDestination
+	 */
+	void setHkPacketDestination(MessageQueueId_t hkDestination);
+
+	/**
+	 * Generate a housekeeping packet with a given SID.
+	 * @param sid
+	 * @return
+	 */
+	ReturnValue_t generateHousekeepingPacket(sid_t sid, MessageQueueId_t sendTo
+	        = MessageQueueIF::NO_QUEUE);
+	ReturnValue_t generateSetStructurePacket(sid_t sid);
+
+	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
+
+	/**
+	 * This function is used to fill the local data pool map with pool
+	 * entries. It should only be called once by the pool owner.
+	 * @param localDataPoolMap
+	 * @return
+	 */
+	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
+
+	const HasLocalDataPoolIF* getOwner() const;
+
+	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
+
+    /**
+     * Different types of housekeeping reporting are possible.
+     *  1. PERIODIC: HK packets are generated in fixed intervals
+     *  2. UPDATED: HK packets are generated if a value was updated
+     *  3. REQUESTED: HK packets are only generated if explicitely requested
+     */
+    enum class ReportingType: uint8_t {
+        PERIODIC,
+        ON_UPDATE,
+        REQUESTED
+    };
+
+    /* Copying forbidden */
+    LocalDataPoolManager(const LocalDataPoolManager &) = delete;
+    LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
+
+private:
+    LocalDataPool localPoolMap;
+    /** Every housekeeping data manager has a mutex to protect access
+     * to it's data pool. */
+    MutexIF* mutex = nullptr;
+    /** The class which actually owns the manager (and its datapool). */
+    HasLocalDataPoolIF* owner = nullptr;
+
+    /**
+     * The data pool manager will keep an internal map of HK receivers.
+     */
+    struct HkReceiver {
+        LocalDataSet* dataSet = nullptr;
+        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
+        ReportingType reportingType = ReportingType::PERIODIC;
+        bool reportingStatus = true;
+        /** Different members of this union will be used depending on reporting
+         * type */
+        union hkParameter {
+            /** This parameter will be used for the PERIODIC type */
+            dur_seconds_t collectionInterval = 0;
+            /** This parameter will be used for the ON_UPDATE type */
+            bool hkDataChanged;
+        };
+    };
+
+    /** Using a multimap as the same object might request multiple datasets */
+    using HkReceiversMap = std::multimap<object_id_t, struct HkReceiver>;
+
+    HkReceiversMap hkReceiversMap;
+
+    /** This is the map holding the actual data. Should only be initialized
+     * once ! */
+    bool mapInitialized = false;
+    /** This specifies whether a validity buffer is appended at the end
+     * of generated housekeeping packets. */
+    bool appendValidityBuffer = true;
+
+	/**
+	 * @brief Queue used for communication, for example commands.
+	 * Is also used to send messages. Can be set either in the constructor
+     * or in the initialize() function.
+	 */
+	MessageQueueIF* hkQueue = nullptr;
+
+	/**
+	 * HK replies will always be a reply to the commander, but HK packet
+	 * can be sent to another destination by specifying this message queue
+	 * ID, for example to a dedicated housekeeping service implementation.
+	 */
+	MessageQueueId_t hkDestination = MessageQueueIF::NO_QUEUE;
+
+	/** Global IPC store is used to store all packets. */
+	StorageManagerIF* ipcStore = nullptr;
+	/**
+	 * Get the pointer to the mutex. Can be used to lock the data pool
+	 * eternally. Use with care and don't forget to unlock locked mutexes!
+	 * For now, only friend classes can accss this function.
+	 * @return
+	 */
+	MutexIF* getMutexHandle();
+
+	/**
+	 * Read a variable by supplying its local pool ID and assign the pool
+	 * entry to the supplied PoolEntry pointer. The type of the pool entry
+	 * is deduced automatically. This call is not thread-safe!
+	 * For now, only friend classes like LocalPoolVar may access this
+	 * function.
+	 * @tparam T Type of the pool entry
+	 * @param localPoolId Pool ID of the variable to read
+	 * @param poolVar [out] Corresponding pool entry will be assigned to the
+	 * 						supplied pointer.
+	 * @return
+	 */
+	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
+			PoolEntry<T> **poolEntry);
+
+	void setMinimalSamplingFrequency(float frequencySeconds);
+	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
+	        LocalDataSet* dataSet);
+};
+
+
+template<class T> inline
+ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
+		PoolEntry<T> **poolEntry) {
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
+		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
+		        "not found." << std::endl;
+		return POOL_ENTRY_NOT_FOUND;
+	}
+
+	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
+	if(*poolEntry == nullptr) {
+		sif::debug << "HousekeepingManager::fetchPoolEntry:"
+				" Pool entry not found." << std::endl;
+		return POOL_ENTRY_TYPE_CONFLICT;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 8725f6972..163482e3d 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -1,106 +1,106 @@
-#include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/datapoollocal/LocalDataSet.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-#include <cmath>
-#include <cstring>
-
-LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
-        const size_t maxNumberOfVariables):
-        DataSetBase(poolVarList.data(), maxNumberOfVariables) {
-    poolVarList.reserve(maxNumberOfVariables);
-    poolVarList.resize(maxNumberOfVariables);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-}
-
-LocalDataSet::LocalDataSet(object_id_t ownerId,
-        const size_t maxNumberOfVariables):
-        DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
-    poolVarList.reserve(maxNumberOfVariables);
-    poolVarList.resize(maxNumberOfVariables);
-    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
-            ownerId);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-}
-
-LocalDataSet::~LocalDataSet() {
-}
-
-ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
-}
-
-ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
-        size_t *size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-    uint8_t validityMask[validityMaskSize];
-    uint8_t validBufferIndex = 0;
-    uint8_t validBufferIndexBit = 0;
-    for (uint16_t count = 0; count < fillCount; count++) {
-        if(registeredVariables[count]->isValid()) {
-            // set validity buffer here.
-            this->bitSetter(validityMask + validBufferIndex,
-                    validBufferIndexBit);
-            if(validBufferIndexBit == 7) {
-                validBufferIndex ++;
-                validBufferIndexBit = 0;
-            }
-            else {
-                validBufferIndexBit ++;
-            }
-        }
-        result = registeredVariables[count]->serialize(buffer, size, maxSize,
-                streamEndianness);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-    }
-    // copy validity buffer to end
-    std::memcpy(*buffer, validityMask, validityMaskSize);
-    *size += validityMaskSize;
-    return result;
-}
-
-ReturnValue_t LocalDataSet::unlockDataPool() {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->unlockMutex();
-}
-
-ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    for (uint16_t count = 0; count < fillCount; count++) {
-        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
-                size, maxSize, streamEndianness);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
-                    " error!" << std::endl;
-            return result;
-        }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position) const {
-    if(position > 7) {
-        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
-}
-
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../datapoollocal/LocalDataSet.h"
+#include "../serialize/SerializeAdapter.h"
+
+#include <cmath>
+#include <cstring>
+
+LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
+        const size_t maxNumberOfVariables):
+        DataSetBase(poolVarList.data(), maxNumberOfVariables) {
+    poolVarList.reserve(maxNumberOfVariables);
+    poolVarList.resize(maxNumberOfVariables);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
+                << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+}
+
+LocalDataSet::LocalDataSet(object_id_t ownerId,
+        const size_t maxNumberOfVariables):
+        DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
+    poolVarList.reserve(maxNumberOfVariables);
+    poolVarList.resize(maxNumberOfVariables);
+    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+            ownerId);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
+                << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+}
+
+LocalDataSet::~LocalDataSet() {
+}
+
+ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+}
+
+ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
+        size_t *size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+    uint8_t validityMask[validityMaskSize];
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if(registeredVariables[count]->isValid()) {
+            // set validity buffer here.
+            this->bitSetter(validityMask + validBufferIndex,
+                    validBufferIndexBit);
+            if(validBufferIndexBit == 7) {
+                validBufferIndex ++;
+                validBufferIndexBit = 0;
+            }
+            else {
+                validBufferIndexBit ++;
+            }
+        }
+        result = registeredVariables[count]->serialize(buffer, size, maxSize,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    // copy validity buffer to end
+    std::memcpy(*buffer, validityMask, validityMaskSize);
+    *size += validityMaskSize;
+    return result;
+}
+
+ReturnValue_t LocalDataSet::unlockDataPool() {
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->unlockMutex();
+}
+
+ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
+        size_t* size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    for (uint16_t count = 0; count < fillCount; count++) {
+        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
+        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
+                size, maxSize, streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
+                    " error!" << std::endl;
+            return result;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1 << shiftNumber;
+}
+
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 2c70de826..75111d936 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -1,115 +1,115 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
-#include <framework/datapool/DataSetBase.h>
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapoollocal/HasLocalDataPoolIF.h>
-#include <framework/serialize/SerializeIF.h>
-
-#include <vector>
-
-class LocalDataPoolManager;
-
-/**
- * @brief	The LocalDataSet class manages a set of locally checked out variables
- * 			for local data pools
- * @details
- * This class manages a list, where a set of local variables (or pool variables)
- * are registered. They are checked-out (i.e. their values are looked
- * up and copied) with the read call. After the user finishes working with the
- * pool variables, he can write back all variable values to the pool with
- * the commit call. The data set manages locking and freeing the local data pools,
- * to ensure thread-safety.
- *
- * An internal state manages usage of this class. Variables may only be
- * registered before the read call is made, and the commit call only
- * after the read call.
- *
- * If pool variables are writable and not committed until destruction
- * of the set, the DataSet class automatically sets the valid flag in the
- * data pool to invalid (without) changing the variable's value.
- *
- * @ingroup data_pool
- */
-class LocalDataSet: public DataSetBase {
-public:
-	/**
-	 * @brief	Constructor for the creator of local pool data.
-	 * 			The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
-	 */
-	LocalDataSet(HasLocalDataPoolIF *hkOwner,
-	        const size_t maxNumberOfVariables);
-
-	/**
-	 * @brief	Constructor for users of local pool data. The passed pool
-	 * 			owner should implement the HasHkPoolParametersIF.
-	 * 			The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
-	 */
-	LocalDataSet(object_id_t ownerId,
-	        const size_t maxNumberOfVariables);
-
-	/**
-	 * @brief	The destructor automatically manages writing the valid
-	 * 			information of variables.
-	 * @details
-	 * In case the data set was read out, but not committed(indicated by state),
-	 * the destructor parses all variables that are still registered to the set.
-	 * For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~LocalDataSet();
-
-	/**
-	 * Special version of the serilization function which appends a
-	 * validity buffer at the end. Each bit of this validity buffer
-	 * denotes whether the container data set entries are valid from left
-	 * to right, MSB first.
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param bigEndian
-	 * @param withValidityBuffer
-	 * @return
-	 */
-	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
-	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const;
-
-	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
-	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const;
-protected:
-private:
-	/**
-	 * If the valid state of a dataset is always relevant to the whole
-	 * data set we can use this flag.
-	 */
-	bool valid = false;
-
-	/**
-	 * @brief	This is a small helper function to facilitate locking
-	 * 			the global data pool.
-	 * @details
-	 * It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
-	/**
-	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the global data pool
-	 * @details
-	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	ReturnValue_t unlockDataPool() override;
-
-	LocalDataPoolManager* hkManager;
-
-	/**
-	 * Set n-th bit of a byte, with n being the position from 0
-	 * (most significant bit) to 7 (least significant bit)
-	 */
-	void bitSetter(uint8_t* byte, uint8_t position) const;
-
-	std::vector<PoolVariableIF*> poolVarList;
-};
-
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
+#include "../datapool/DataSetBase.h"
+#include "../datapool/DataSetIF.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../serialize/SerializeIF.h"
+
+#include <vector>
+
+class LocalDataPoolManager;
+
+/**
+ * @brief	The LocalDataSet class manages a set of locally checked out variables
+ * 			for local data pools
+ * @details
+ * This class manages a list, where a set of local variables (or pool variables)
+ * are registered. They are checked-out (i.e. their values are looked
+ * up and copied) with the read call. After the user finishes working with the
+ * pool variables, he can write back all variable values to the pool with
+ * the commit call. The data set manages locking and freeing the local data pools,
+ * to ensure thread-safety.
+ *
+ * An internal state manages usage of this class. Variables may only be
+ * registered before the read call is made, and the commit call only
+ * after the read call.
+ *
+ * If pool variables are writable and not committed until destruction
+ * of the set, the DataSet class automatically sets the valid flag in the
+ * data pool to invalid (without) changing the variable's value.
+ *
+ * @ingroup data_pool
+ */
+class LocalDataSet: public DataSetBase {
+public:
+	/**
+	 * @brief	Constructor for the creator of local pool data.
+	 * 			The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
+	 */
+	LocalDataSet(HasLocalDataPoolIF *hkOwner,
+	        const size_t maxNumberOfVariables);
+
+	/**
+	 * @brief	Constructor for users of local pool data. The passed pool
+	 * 			owner should implement the HasHkPoolParametersIF.
+	 * 			The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
+	 */
+	LocalDataSet(object_id_t ownerId,
+	        const size_t maxNumberOfVariables);
+
+	/**
+	 * @brief	The destructor automatically manages writing the valid
+	 * 			information of variables.
+	 * @details
+	 * In case the data set was read out, but not committed(indicated by state),
+	 * the destructor parses all variables that are still registered to the set.
+	 * For each, the valid flag in the data pool is set to "invalid".
+	 */
+	~LocalDataSet();
+
+	/**
+	 * Special version of the serilization function which appends a
+	 * validity buffer at the end. Each bit of this validity buffer
+	 * denotes whether the container data set entries are valid from left
+	 * to right, MSB first.
+	 * @param buffer
+	 * @param size
+	 * @param maxSize
+	 * @param bigEndian
+	 * @param withValidityBuffer
+	 * @return
+	 */
+	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
+
+	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
+protected:
+private:
+	/**
+	 * If the valid state of a dataset is always relevant to the whole
+	 * data set we can use this flag.
+	 */
+	bool valid = false;
+
+	/**
+	 * @brief	This is a small helper function to facilitate locking
+	 * 			the global data pool.
+	 * @details
+	 * It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
+	/**
+	 * @brief	This is a small helper function to facilitate
+	 * 			unlocking the global data pool
+	 * @details
+	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	ReturnValue_t unlockDataPool() override;
+
+	LocalDataPoolManager* hkManager;
+
+	/**
+	 * Set n-th bit of a byte, with n being the position from 0
+	 * (most significant bit) to 7 (least significant bit)
+	 */
+	void bitSetter(uint8_t* byte, uint8_t position) const;
+
+	std::vector<PoolVariableIF*> poolVarList;
+};
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 73d691d7e..efebdaefd 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,173 +1,173 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
-
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapoollocal/HasLocalDataPoolIF.h>
-#include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-#include <framework/serialize/SerializeAdapter.h>
-
-/**
- * @brief 	Local Pool Variable class which is used to access the local pools.
- * @details
- * This class is not stored in the map. Instead, it is used to access
- * the pool entries by using a pointer to the map storing the pool
- * entries. It can also be used to organize these pool entries into data sets.
- *
- * @tparam T The template parameter sets the type of the variable. Currently,
- * all plain data types are supported, but in principle  any type is possible.
- * @ingroup data_pool
- */
-template<typename T>
-class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
-public:
-	//! Default ctor is forbidden.
-	LocalPoolVar() = delete;
-
-	/**
-	 * This constructor is used by the data creators to have pool variable
-	 * instances which can also be stored in datasets.
-	 *
-	 * It does not fetch the current value from the data pool, which
-	 * has to be done by calling the read() operation.
-	 * Datasets can be used to access multiple local pool entries in an
-	 * efficient way. A pointer to a dataset can be passed to register
-	 * the pool variable in that dataset directly.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
-
-	/**
-	 * This constructor is used by data users like controllers to have
-	 * access to the local pool variables of data creators by supplying
-	 * the respective creator object ID.
-	 *
-	 * It does not fetch the current value from the data pool, which
-	 * has to be done by calling the read() operation.
-	 * Datasets can be used to access multiple local pool entries in an
-	 * efficient way. A pointer to a dataset can be passed to register
-	 * the pool variable in that dataset directly.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner object ID of the pool owner.
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
-
-	virtual~ LocalPoolVar() {};
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value = 0;
-
-	pool_rwm_t getReadWriteMode() const override;
-
-	lp_id_t getDataPoolId() const override;
-	void setDataPoolId(lp_id_t poolId);
-
-	bool isValid() const override;
-	void setValid(bool validity) override;
-	uint8_t getValid() const;
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the data pool and copies all array values and the valid
-	 * information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 *
-	 */
-	ReturnValue_t read(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the local valid flag is written back as well.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-	// std::ostream is the type for object std::cout
-	template <typename U>
-	friend std::ostream& operator<< (std::ostream &out,
-			const LocalPoolVar<U> &var);
-
-private:
-	//! @brief 	Pool ID of pool entry inside the used local pool.
-	lp_id_t localPoolId = PoolVariableIF::NO_PARAMETER;
-	//! @brief 	Read-write mode of the pool variable
-	pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
-	//! @brief 	Specifies whether the entry is valid or invalid.
-	bool valid = false;
-
-	//! Pointer to the class which manages the HK pool.
-	LocalDataPoolManager* hkManager;
-};
-
-#include <framework/datapoollocal/LocalPoolVariable.tpp>
-
-template<class T>
-using lp_var_t = LocalPoolVar<T>;
-
-using lp_bool_t = LocalPoolVar<uint8_t>;
-using lp_uint8_t = LocalPoolVar<uint8_t>;
-using lp_uint16_t = LocalPoolVar<uint16_t>;
-using lp_uint32_t = LocalPoolVar<uint32_t>;
-using lp_uint64_t = LocalPoolVar<uint64_t>;
-using lp_int8_t = LocalPoolVar<int8_t>;
-using lp_int16_t = LocalPoolVar<int16_t>;
-using lp_int32_t = LocalPoolVar<int32_t>;
-using lp_int64_t = LocalPoolVar<int64_t>;
-using lp_float_t = LocalPoolVar<float>;
-using lp_double_t = LocalPoolVar<double>;
-
-#endif
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+
+#include "../datapool/PoolVariableIF.h"
+#include "../datapool/DataSetIF.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+#include "../serialize/SerializeAdapter.h"
+
+/**
+ * @brief 	Local Pool Variable class which is used to access the local pools.
+ * @details
+ * This class is not stored in the map. Instead, it is used to access
+ * the pool entries by using a pointer to the map storing the pool
+ * entries. It can also be used to organize these pool entries into data sets.
+ *
+ * @tparam T The template parameter sets the type of the variable. Currently,
+ * all plain data types are supported, but in principle  any type is possible.
+ * @ingroup data_pool
+ */
+template<typename T>
+class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
+public:
+	//! Default ctor is forbidden.
+	LocalPoolVar() = delete;
+
+	/**
+	 * This constructor is used by the data creators to have pool variable
+	 * instances which can also be stored in datasets.
+	 *
+	 * It does not fetch the current value from the data pool, which
+	 * has to be done by calling the read() operation.
+	 * Datasets can be used to access multiple local pool entries in an
+	 * efficient way. A pointer to a dataset can be passed to register
+	 * the pool variable in that dataset directly.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * This constructor is used by data users like controllers to have
+	 * access to the local pool variables of data creators by supplying
+	 * the respective creator object ID.
+	 *
+	 * It does not fetch the current value from the data pool, which
+	 * has to be done by calling the read() operation.
+	 * Datasets can be used to access multiple local pool entries in an
+	 * efficient way. A pointer to a dataset can be passed to register
+	 * the pool variable in that dataset directly.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner object ID of the pool owner.
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	virtual~ LocalPoolVar() {};
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a simple local variable.
+	 */
+	T value = 0;
+
+	pool_rwm_t getReadWriteMode() const override;
+
+	lp_id_t getDataPoolId() const override;
+	void setDataPoolId(lp_id_t poolId);
+
+	bool isValid() const override;
+	void setValid(bool validity) override;
+	uint8_t getValid() const;
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the data pool and copies all array values and the valid
+	 * information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 *
+	 */
+	ReturnValue_t read(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the local valid flag is written back as well.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+	// std::ostream is the type for object std::cout
+	template <typename U>
+	friend std::ostream& operator<< (std::ostream &out,
+			const LocalPoolVar<U> &var);
+
+private:
+	//! @brief 	Pool ID of pool entry inside the used local pool.
+	lp_id_t localPoolId = PoolVariableIF::NO_PARAMETER;
+	//! @brief 	Read-write mode of the pool variable
+	pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
+	//! @brief 	Specifies whether the entry is valid or invalid.
+	bool valid = false;
+
+	//! Pointer to the class which manages the HK pool.
+	LocalDataPoolManager* hkManager;
+};
+
+#include "../datapoollocal/LocalPoolVariable.tpp"
+
+template<class T>
+using lp_var_t = LocalPoolVar<T>;
+
+using lp_bool_t = LocalPoolVar<uint8_t>;
+using lp_uint8_t = LocalPoolVar<uint8_t>;
+using lp_uint16_t = LocalPoolVar<uint16_t>;
+using lp_uint32_t = LocalPoolVar<uint32_t>;
+using lp_uint64_t = LocalPoolVar<uint64_t>;
+using lp_int8_t = LocalPoolVar<int8_t>;
+using lp_int16_t = LocalPoolVar<int16_t>;
+using lp_int32_t = LocalPoolVar<int32_t>;
+using lp_int64_t = LocalPoolVar<int64_t>;
+using lp_float_t = LocalPoolVar<float>;
+using lp_double_t = LocalPoolVar<double>;
+
+#endif
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 3083646f3..8c3c50dbc 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,200 +1,200 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-
-/**
- * @brief	This is the access class for array-type data pool entries.
- * @details
- * To ensure safe usage of the data pool, operation is not done directly on the
- * data pool entries, but on local copies. This class provides simple type-
- * and length-safe access to vector-style data pool entries (i.e. entries with
- * length > 1). The class can be instantiated as read-write and read only.
- *
- * It provides a commit-and-roll-back semantic, which means that no array
- * entry in the data pool is changed until the commit call is executed.
- * There are two template parameters:
- * @tparam	T
- * This template parameter specifies the data type of an array entry. Currently,
- * all plain data types are supported, but in principle any type is possible.
- * @tparam  vector_size
- * This template parameter specifies the vector size of this entry. Using a
- * template parameter for this is not perfect, but avoids
- * dynamic memory allocation.
- * @ingroup data_pool
- */
-template<typename T, uint16_t vectorSize>
-class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
-public:
-	LocalPoolVector() = delete;
-	/**
-	 * This constructor is used by the data creators to have pool variable
-	 * instances which can also be stored in datasets.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
-
-	/**
-	 * This constructor is used by data users like controllers to have
-	 * access to the local pool variables of data creators by supplying
-	 * the respective creator object ID.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details
-	 * The user can work on this attribute just like he would on a local
-	 * array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~LocalPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
-
-	uint32_t getDataPoolId() const override;
-	/**
-	 * @brief This operation sets the data pool ID of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	pool_rwm_t getReadWriteMode() const;
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-	void setValid(bool valid) override;
-	uint8_t getValid() const;
-
-	T& operator [](int i);
-	const T &operator [](int i) const;
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t maxSize,
-			SerializeIF::Endianness streamEndiannes) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the data pool and copies all array values and the valid
-	 * information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the local valid flag is written back as well.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t localPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	bool valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	//! @brief	Pointer to the class which manages the HK pool.
-	LocalDataPoolManager* hkManager;
-
-	// std::ostream is the type for object std::cout
-	template <typename U, uint16_t otherSize>
-	friend std::ostream& operator<< (std::ostream &out,
-	        const LocalPoolVector<U, otherSize> &var);
-
-
-};
-
-#include <framework/datapoollocal/LocalPoolVector.tpp>
-
-template<typename T, uint16_t vectorSize>
-using lp_vec_t = LocalPoolVector<T, vectorSize>;
-
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
+public:
+	LocalPoolVector() = delete;
+	/**
+	 * This constructor is used by the data creators to have pool variable
+	 * instances which can also be stored in datasets.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * This constructor is used by data users like controllers to have
+	 * access to the local pool variables of data creators by supplying
+	 * the respective creator object ID.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details
+	 * The user can work on this attribute just like he would on a local
+	 * array of this type.
+	 */
+	T value[vectorSize];
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~LocalPoolVector() {};
+	/**
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
+	 */
+	uint8_t getSize() {
+		return vectorSize;
+	}
+
+	uint32_t getDataPoolId() const override;
+	/**
+	 * @brief This operation sets the data pool ID of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	pool_rwm_t getReadWriteMode() const;
+
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+	void setValid(bool valid) override;
+	uint8_t getValid() const;
+
+	T& operator [](int i);
+	const T &operator [](int i) const;
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t maxSize,
+			SerializeIF::Endianness streamEndiannes) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the data pool and copies all array values and the valid
+	 * information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the local valid flag is written back as well.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t localPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	bool valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+	//! @brief	Pointer to the class which manages the HK pool.
+	LocalDataPoolManager* hkManager;
+
+	// std::ostream is the type for object std::cout
+	template <typename U, uint16_t otherSize>
+	friend std::ostream& operator<< (std::ostream &out,
+	        const LocalPoolVector<U, otherSize> &var);
+
+
+};
+
+#include "../datapoollocal/LocalPoolVector.tpp"
+
+template<typename T, uint16_t vectorSize>
+using lp_vec_t = LocalPoolVector<T, vectorSize>;
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
diff --git a/datapoollocal/StaticLocalDataSet.cpp b/datapoollocal/StaticLocalDataSet.cpp
index 15d4251a4..c845a0d1c 100644
--- a/datapoollocal/StaticLocalDataSet.cpp
+++ b/datapoollocal/StaticLocalDataSet.cpp
@@ -1,6 +1,6 @@
-#include <framework/datapoollocal/StaticLocalDataSet.h>
-
-
-
-
-
+#include "../datapoollocal/StaticLocalDataSet.h"
+
+
+
+
+
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index 15a79aaef..add9c48cf 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -1,11 +1,11 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#include <framework/datapool/DataSetBase.h>
-
-
-class StaticLocalDataSet: public DataSetBase {
-
-};
-
-
-#endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */
+#ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#include "../datapool/DataSetBase.h"
+
+
+class StaticLocalDataSet: public DataSetBase {
+
+};
+
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */
diff --git a/devicehandlers/AcceptsDeviceResponsesIF.h b/devicehandlers/AcceptsDeviceResponsesIF.h
index fcf5237d2..d7e117149 100644
--- a/devicehandlers/AcceptsDeviceResponsesIF.h
+++ b/devicehandlers/AcceptsDeviceResponsesIF.h
@@ -1,19 +1,19 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
-#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
-
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-/**
- * This interface is used by the device handler to send a device response
- * to the queue ID, which is returned in the implemented abstract method.
- */
-class AcceptsDeviceResponsesIF {
-public:
-	/**
-	 * Default empty virtual destructor.
-	 */
-	virtual ~AcceptsDeviceResponsesIF() {}
-	virtual MessageQueueId_t getDeviceQueue() = 0;
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * This interface is used by the device handler to send a device response
+ * to the queue ID, which is returned in the implemented abstract method.
+ */
+class AcceptsDeviceResponsesIF {
+public:
+	/**
+	 * Default empty virtual destructor.
+	 */
+	virtual ~AcceptsDeviceResponsesIF() {}
+	virtual MessageQueueId_t getDeviceQueue() = 0;
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index f56573278..c98a9f678 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -1,273 +1,273 @@
-#include <framework/devicehandlers/AssemblyBase.h>
-
-AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
-		uint16_t commandQueueDepth) :
-		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
-		internalState(STATE_NONE), recoveryState(RECOVERY_IDLE),
-		recoveringDevice(childrenMap.end()), targetMode(MODE_OFF),
-		targetSubmode(SUBMODE_NONE) {
-	recoveryOffTimer.setTimeout(POWER_OFF_TIME_MS);
-}
-
-AssemblyBase::~AssemblyBase() {
-}
-
-ReturnValue_t AssemblyBase::handleCommandMessage(CommandMessage* message) {
-	return handleHealthReply(message);
-}
-
-void AssemblyBase::performChildOperation() {
-	if (isInTransition()) {
-		handleChildrenTransition();
-	} else {
-		handleChildrenChanged();
-	}
-}
-
-void AssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
-	doStartTransition(mode, submode);
-	if (modeHelper.isForced()) {
-		triggerEvent(FORCING_MODE, mode, submode);
-	} else {
-		triggerEvent(CHANGING_MODE, mode, submode);
-	}
-}
-
-void AssemblyBase::doStartTransition(Mode_t mode, Submode_t submode) {
-	targetMode = mode;
-	targetSubmode = submode;
-	internalState = STATE_SINGLE_STEP;
-	ReturnValue_t result = commandChildren(mode, submode);
-	if (result == NEED_SECOND_STEP) {
-		internalState = STATE_NEED_SECOND_STEP;
-	}
-}
-
-bool AssemblyBase::isInTransition() {
-	return (internalState != STATE_NONE) || (recoveryState != RECOVERY_IDLE);
-}
-
-bool AssemblyBase::handleChildrenChanged() {
-	if (childrenChangedMode) {
-		ReturnValue_t result = checkChildrenState();
-		if (result != RETURN_OK) {
-			handleChildrenLostMode(result);
-		}
-		return true;
-	} else {
-		return handleChildrenChangedHealth();
-	}
-}
-
-void AssemblyBase::handleChildrenLostMode(ReturnValue_t result) {
-	triggerEvent(CANT_KEEP_MODE, mode, submode);
-	startTransition(MODE_OFF, SUBMODE_NONE);
-}
-
-bool AssemblyBase::handleChildrenChangedHealth() {
-	auto iter = childrenMap.begin();
-	for (; iter != childrenMap.end(); iter++) {
-		if (iter->second.healthChanged) {
-			iter->second.healthChanged = false;
-			break;
-		}
-	}
-	if (iter == childrenMap.end()) {
-		return false;
-	}
-	HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
-	if (healthState == HasHealthIF::NEEDS_RECOVERY) {
-		triggerEvent(TRYING_RECOVERY);
-		recoveryState = RECOVERY_STARTED;
-		recoveringDevice = iter;
-		doStartTransition(targetMode, targetSubmode);
-	} else {
-		triggerEvent(CHILD_CHANGED_HEALTH);
-		doStartTransition(mode, submode);
-	}
-	if (modeHelper.isForced()) {
-		triggerEvent(FORCING_MODE, targetMode, targetSubmode);
-	}
-	return true;
-}
-
-void AssemblyBase::handleChildrenTransition() {
-	if (commandsOutstanding <= 0) {
-		switch (internalState) {
-		case STATE_NEED_SECOND_STEP:
-			internalState = STATE_SECOND_STEP;
-			commandChildren(targetMode, targetSubmode);
-			return;
-		case STATE_OVERWRITE_HEALTH: {
-			internalState = STATE_SINGLE_STEP;
-			ReturnValue_t result = commandChildren(mode, submode);
-			if (result == NEED_SECOND_STEP) {
-				internalState = STATE_NEED_SECOND_STEP;
-			}
-			return;
-		}
-		case STATE_NONE:
-			//Valid state, used in recovery.
-		case STATE_SINGLE_STEP:
-		case STATE_SECOND_STEP:
-			if (checkAndHandleRecovery()) {
-				return;
-			}
-			break;
-		}
-		ReturnValue_t result = checkChildrenState();
-		if (result == RETURN_OK) {
-			handleModeReached();
-		} else {
-			handleModeTransitionFailed(result);
-		}
-	}
-}
-
-void AssemblyBase::handleModeReached() {
-	internalState = STATE_NONE;
-	setMode(targetMode, targetSubmode);
-}
-
-void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
-//always accept transition to OFF, there is nothing we can do except sending an info event
-//In theory this should never happen, but we would risk an infinite loop otherwise
-	if (targetMode == MODE_OFF) {
-		triggerEvent(CHILD_PROBLEMS, result);
-		internalState = STATE_NONE;
-		setMode(targetMode, targetSubmode);
-	} else {
-		if (handleChildrenChangedHealth()) {
-			//If any health change is pending, handle that first.
-			return;
-		}
-		triggerEvent(MODE_TRANSITION_FAILED, result);
-		startTransition(MODE_OFF, SUBMODE_NONE);
-	}
-}
-
-void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
-		HealthState health) {
-	CommandMessage command;
-	HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
-			health);
-	if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
-		commandsOutstanding++;
-	}
-}
-
-ReturnValue_t AssemblyBase::checkChildrenState() {
-	if (targetMode == MODE_OFF) {
-		return checkChildrenStateOff();
-	} else {
-		return checkChildrenStateOn(targetMode, targetSubmode);
-	}
-}
-
-ReturnValue_t AssemblyBase::checkChildrenStateOff() {
-	for (const auto& childIter: childrenMap) {
-		if (checkChildOff(childIter.first) != RETURN_OK) {
-			return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t AssemblyBase::checkChildOff(uint32_t objectId) {
-	ChildInfo childInfo = childrenMap.find(objectId)->second;
-	if (healthHelper.healthTable->isCommandable(objectId)) {
-		if (childInfo.submode != SUBMODE_NONE) {
-			return RETURN_FAILED;
-		} else {
-			if ((childInfo.mode != MODE_OFF)
-					&& (childInfo.mode != DeviceHandlerIF::MODE_ERROR_ON)) {
-				return RETURN_FAILED;
-			}
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t AssemblyBase::checkModeCommand(Mode_t mode, Submode_t submode,
-		uint32_t* msToReachTheMode) {
-
-//always accept transition to OFF
-	if (mode == MODE_OFF) {
-		if (submode != SUBMODE_NONE) {
-			return INVALID_SUBMODE;
-		}
-		return RETURN_OK;
-	}
-
-	if ((mode != MODE_ON) && (mode != DeviceHandlerIF::MODE_NORMAL)) {
-		return INVALID_MODE;
-	}
-
-	if (internalState != STATE_NONE) {
-		return IN_TRANSITION;
-	}
-
-	return isModeCombinationValid(mode, submode);
-}
-
-ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
-	if (message->getCommand() == HealthMessage::HEALTH_INFO) {
-		HealthState health = HealthMessage::getHealth(message);
-		if (health != EXTERNAL_CONTROL) {
-			updateChildChangedHealth(message->getSender(), true);
-		}
-		return RETURN_OK;
-	}
-	if (message->getCommand() == HealthMessage::REPLY_HEALTH_SET
-			|| (message->getCommand() == CommandMessage::REPLY_REJECTED
-					&& message->getParameter2() == HealthMessage::HEALTH_SET)) {
-		if (isInTransition()) {
-			commandsOutstanding--;
-		}
-		return RETURN_OK;
-	}
-	return RETURN_FAILED;
-}
-
-bool AssemblyBase::checkAndHandleRecovery() {
-	switch (recoveryState) {
-	case RECOVERY_STARTED:
-		recoveryState = RECOVERY_WAIT;
-		recoveryOffTimer.resetTimer();
-		return true;
-	case RECOVERY_WAIT:
-		if (recoveryOffTimer.isBusy()) {
-			return true;
-		}
-		triggerEvent(RECOVERY_STEP, 0);
-		sendHealthCommand(recoveringDevice->second.commandQueue, HEALTHY);
-		internalState = STATE_NONE;
-		recoveryState = RECOVERY_ONGOING;
-		//Don't check state!
-		return true;
-	case RECOVERY_ONGOING:
-		triggerEvent(RECOVERY_STEP, 1);
-		recoveryState = RECOVERY_ONGOING_2;
-		recoveringDevice->second.healthChanged = false;
-		//Device should be healthy again, so restart a transition.
-		//Might be including second step, but that's already handled.
-		doStartTransition(targetMode, targetSubmode);
-		return true;
-	case RECOVERY_ONGOING_2:
-		triggerEvent(RECOVERY_DONE);
-		//Now we're through, but not sure if it was successful.
-		recoveryState = RECOVERY_IDLE;
-		return false;
-	case RECOVERY_IDLE:
-	default:
-		return false;
-	}
-}
-
-void AssemblyBase::overwriteDeviceHealth(object_id_t objectId,
-		HasHealthIF::HealthState oldHealth) {
-	triggerEvent(OVERWRITING_HEALTH, objectId, oldHealth);
-	internalState = STATE_OVERWRITE_HEALTH;
-	modeHelper.setForced(true);
-	sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
-}
+#include "../devicehandlers/AssemblyBase.h"
+
+AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
+		uint16_t commandQueueDepth) :
+		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
+		internalState(STATE_NONE), recoveryState(RECOVERY_IDLE),
+		recoveringDevice(childrenMap.end()), targetMode(MODE_OFF),
+		targetSubmode(SUBMODE_NONE) {
+	recoveryOffTimer.setTimeout(POWER_OFF_TIME_MS);
+}
+
+AssemblyBase::~AssemblyBase() {
+}
+
+ReturnValue_t AssemblyBase::handleCommandMessage(CommandMessage* message) {
+	return handleHealthReply(message);
+}
+
+void AssemblyBase::performChildOperation() {
+	if (isInTransition()) {
+		handleChildrenTransition();
+	} else {
+		handleChildrenChanged();
+	}
+}
+
+void AssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
+	doStartTransition(mode, submode);
+	if (modeHelper.isForced()) {
+		triggerEvent(FORCING_MODE, mode, submode);
+	} else {
+		triggerEvent(CHANGING_MODE, mode, submode);
+	}
+}
+
+void AssemblyBase::doStartTransition(Mode_t mode, Submode_t submode) {
+	targetMode = mode;
+	targetSubmode = submode;
+	internalState = STATE_SINGLE_STEP;
+	ReturnValue_t result = commandChildren(mode, submode);
+	if (result == NEED_SECOND_STEP) {
+		internalState = STATE_NEED_SECOND_STEP;
+	}
+}
+
+bool AssemblyBase::isInTransition() {
+	return (internalState != STATE_NONE) || (recoveryState != RECOVERY_IDLE);
+}
+
+bool AssemblyBase::handleChildrenChanged() {
+	if (childrenChangedMode) {
+		ReturnValue_t result = checkChildrenState();
+		if (result != RETURN_OK) {
+			handleChildrenLostMode(result);
+		}
+		return true;
+	} else {
+		return handleChildrenChangedHealth();
+	}
+}
+
+void AssemblyBase::handleChildrenLostMode(ReturnValue_t result) {
+	triggerEvent(CANT_KEEP_MODE, mode, submode);
+	startTransition(MODE_OFF, SUBMODE_NONE);
+}
+
+bool AssemblyBase::handleChildrenChangedHealth() {
+	auto iter = childrenMap.begin();
+	for (; iter != childrenMap.end(); iter++) {
+		if (iter->second.healthChanged) {
+			iter->second.healthChanged = false;
+			break;
+		}
+	}
+	if (iter == childrenMap.end()) {
+		return false;
+	}
+	HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
+	if (healthState == HasHealthIF::NEEDS_RECOVERY) {
+		triggerEvent(TRYING_RECOVERY);
+		recoveryState = RECOVERY_STARTED;
+		recoveringDevice = iter;
+		doStartTransition(targetMode, targetSubmode);
+	} else {
+		triggerEvent(CHILD_CHANGED_HEALTH);
+		doStartTransition(mode, submode);
+	}
+	if (modeHelper.isForced()) {
+		triggerEvent(FORCING_MODE, targetMode, targetSubmode);
+	}
+	return true;
+}
+
+void AssemblyBase::handleChildrenTransition() {
+	if (commandsOutstanding <= 0) {
+		switch (internalState) {
+		case STATE_NEED_SECOND_STEP:
+			internalState = STATE_SECOND_STEP;
+			commandChildren(targetMode, targetSubmode);
+			return;
+		case STATE_OVERWRITE_HEALTH: {
+			internalState = STATE_SINGLE_STEP;
+			ReturnValue_t result = commandChildren(mode, submode);
+			if (result == NEED_SECOND_STEP) {
+				internalState = STATE_NEED_SECOND_STEP;
+			}
+			return;
+		}
+		case STATE_NONE:
+			//Valid state, used in recovery.
+		case STATE_SINGLE_STEP:
+		case STATE_SECOND_STEP:
+			if (checkAndHandleRecovery()) {
+				return;
+			}
+			break;
+		}
+		ReturnValue_t result = checkChildrenState();
+		if (result == RETURN_OK) {
+			handleModeReached();
+		} else {
+			handleModeTransitionFailed(result);
+		}
+	}
+}
+
+void AssemblyBase::handleModeReached() {
+	internalState = STATE_NONE;
+	setMode(targetMode, targetSubmode);
+}
+
+void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
+//always accept transition to OFF, there is nothing we can do except sending an info event
+//In theory this should never happen, but we would risk an infinite loop otherwise
+	if (targetMode == MODE_OFF) {
+		triggerEvent(CHILD_PROBLEMS, result);
+		internalState = STATE_NONE;
+		setMode(targetMode, targetSubmode);
+	} else {
+		if (handleChildrenChangedHealth()) {
+			//If any health change is pending, handle that first.
+			return;
+		}
+		triggerEvent(MODE_TRANSITION_FAILED, result);
+		startTransition(MODE_OFF, SUBMODE_NONE);
+	}
+}
+
+void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
+		HealthState health) {
+	CommandMessage command;
+	HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
+			health);
+	if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
+		commandsOutstanding++;
+	}
+}
+
+ReturnValue_t AssemblyBase::checkChildrenState() {
+	if (targetMode == MODE_OFF) {
+		return checkChildrenStateOff();
+	} else {
+		return checkChildrenStateOn(targetMode, targetSubmode);
+	}
+}
+
+ReturnValue_t AssemblyBase::checkChildrenStateOff() {
+	for (const auto& childIter: childrenMap) {
+		if (checkChildOff(childIter.first) != RETURN_OK) {
+			return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t AssemblyBase::checkChildOff(uint32_t objectId) {
+	ChildInfo childInfo = childrenMap.find(objectId)->second;
+	if (healthHelper.healthTable->isCommandable(objectId)) {
+		if (childInfo.submode != SUBMODE_NONE) {
+			return RETURN_FAILED;
+		} else {
+			if ((childInfo.mode != MODE_OFF)
+					&& (childInfo.mode != DeviceHandlerIF::MODE_ERROR_ON)) {
+				return RETURN_FAILED;
+			}
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t AssemblyBase::checkModeCommand(Mode_t mode, Submode_t submode,
+		uint32_t* msToReachTheMode) {
+
+//always accept transition to OFF
+	if (mode == MODE_OFF) {
+		if (submode != SUBMODE_NONE) {
+			return INVALID_SUBMODE;
+		}
+		return RETURN_OK;
+	}
+
+	if ((mode != MODE_ON) && (mode != DeviceHandlerIF::MODE_NORMAL)) {
+		return INVALID_MODE;
+	}
+
+	if (internalState != STATE_NONE) {
+		return IN_TRANSITION;
+	}
+
+	return isModeCombinationValid(mode, submode);
+}
+
+ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
+	if (message->getCommand() == HealthMessage::HEALTH_INFO) {
+		HealthState health = HealthMessage::getHealth(message);
+		if (health != EXTERNAL_CONTROL) {
+			updateChildChangedHealth(message->getSender(), true);
+		}
+		return RETURN_OK;
+	}
+	if (message->getCommand() == HealthMessage::REPLY_HEALTH_SET
+			|| (message->getCommand() == CommandMessage::REPLY_REJECTED
+					&& message->getParameter2() == HealthMessage::HEALTH_SET)) {
+		if (isInTransition()) {
+			commandsOutstanding--;
+		}
+		return RETURN_OK;
+	}
+	return RETURN_FAILED;
+}
+
+bool AssemblyBase::checkAndHandleRecovery() {
+	switch (recoveryState) {
+	case RECOVERY_STARTED:
+		recoveryState = RECOVERY_WAIT;
+		recoveryOffTimer.resetTimer();
+		return true;
+	case RECOVERY_WAIT:
+		if (recoveryOffTimer.isBusy()) {
+			return true;
+		}
+		triggerEvent(RECOVERY_STEP, 0);
+		sendHealthCommand(recoveringDevice->second.commandQueue, HEALTHY);
+		internalState = STATE_NONE;
+		recoveryState = RECOVERY_ONGOING;
+		//Don't check state!
+		return true;
+	case RECOVERY_ONGOING:
+		triggerEvent(RECOVERY_STEP, 1);
+		recoveryState = RECOVERY_ONGOING_2;
+		recoveringDevice->second.healthChanged = false;
+		//Device should be healthy again, so restart a transition.
+		//Might be including second step, but that's already handled.
+		doStartTransition(targetMode, targetSubmode);
+		return true;
+	case RECOVERY_ONGOING_2:
+		triggerEvent(RECOVERY_DONE);
+		//Now we're through, but not sure if it was successful.
+		recoveryState = RECOVERY_IDLE;
+		return false;
+	case RECOVERY_IDLE:
+	default:
+		return false;
+	}
+}
+
+void AssemblyBase::overwriteDeviceHealth(object_id_t objectId,
+		HasHealthIF::HealthState oldHealth) {
+	triggerEvent(OVERWRITING_HEALTH, objectId, oldHealth);
+	internalState = STATE_OVERWRITE_HEALTH;
+	modeHelper.setForced(true);
+	sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
+}
diff --git a/devicehandlers/AssemblyBase.h b/devicehandlers/AssemblyBase.h
index d0dc868c9..7c66b21d9 100644
--- a/devicehandlers/AssemblyBase.h
+++ b/devicehandlers/AssemblyBase.h
@@ -1,163 +1,163 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
-#define FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
-
-#include <framework/container/FixedArrayList.h>
-#include <framework/devicehandlers/DeviceHandlerBase.h>
-#include <framework/subsystem/SubsystemBase.h>
-
-/**
- * @brief   Base class to implement reconfiguration and failure handling for
- *          redundant devices by monitoring their modes health states.
- * @details
- * Documentation: Dissertation Baetz p.156, 157.
- *
- * This class reduces the complexity of controller components which would
- * otherwise be needed for the handling of redundant devices.
- *
- * The template class monitors mode and health state of its children
- * and checks availability of devices on every detected change.
- * AssemblyBase does not implement any redundancy logic by itself, but provides
- * adaptation points for implementations to do so. Since most monitoring
- * activities rely on mode and health state only and are therefore
- * generic, it is sufficient for subclasses to provide:
- *
- * 1. check logic when active-> checkChildrenStateOn
- * 2. transition logic to change the mode -> commandChildren
- *
- */
-class AssemblyBase: public SubsystemBase {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ASSEMBLY_BASE;
-	static const ReturnValue_t NEED_SECOND_STEP = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t NEED_TO_RECONFIGURE = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t MODE_FALLBACK = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t CHILD_NOT_COMMANDABLE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t NEED_TO_CHANGE_HEALTH = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE =
-			MAKE_RETURN_CODE(0xa1);
-
-	AssemblyBase(object_id_t objectId, object_id_t parentId,
-	        uint16_t commandQueueDepth = 8);
-	virtual ~AssemblyBase();
-
-protected:
-
-    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
-    // (or return internalState directly?)
-    /**
-     * Command children to reach [mode,submode] combination
-     * Can be done by setting #commandsOutstanding correctly,
-     * or using executeTable()
-     * @param mode
-     * @param submode
-     * @return
-     *    - @c RETURN_OK if ok
-     *    - @c NEED_SECOND_STEP if children need to be commanded again
-     */
-    virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
-
-    /**
-     * Check whether desired assembly mode was achieved by checking the modes
-     * or/and health states of child device handlers.
-     * The assembly template class will also call this function if a health
-     * or mode change of a child device handler was detected.
-     * @param wantedMode
-     * @param wantedSubmode
-     * @return
-     */
-    virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
-            Submode_t wantedSubmode) = 0;
-
-    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
-            Submode_t submode) = 0;
-
-	enum InternalState {
-		STATE_NONE,
-		STATE_OVERWRITE_HEALTH,
-		STATE_NEED_SECOND_STEP,
-		STATE_SINGLE_STEP,
-		STATE_SECOND_STEP,
-	} internalState;
-
-	enum RecoveryState {
-		RECOVERY_IDLE,
-		RECOVERY_STARTED,
-		RECOVERY_ONGOING,
-		RECOVERY_ONGOING_2,
-		RECOVERY_WAIT
-	} recoveryState; //!< Indicates if one of the children requested a recovery.
-	ChildrenMap::iterator recoveringDevice;
-
-	/**
-	 * the mode the current transition is trying to achieve.
-	 * Can be different from the modehelper.commandedMode!
-	 */
-	Mode_t targetMode;
-
-	/**
-	 * the submode the current transition is trying to achieve.
-	 * Can be different from the modehelper.commandedSubmode!
-	 */
-	Submode_t targetSubmode;
-
-	Countdown recoveryOffTimer;
-
-	static const uint32_t POWER_OFF_TIME_MS = 1000;
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
-
-	virtual ReturnValue_t handleHealthReply(CommandMessage *message);
-
-	virtual void performChildOperation();
-
-	bool handleChildrenChanged();
-
-	/**
-	 * This method is called if the children changed its mode in a way that
-	 * the current mode can't be kept.
-	 * Default behavior is to go to MODE_OFF.
-	 * @param result The failure code which was returned by checkChildrenState.
-	 */
-	virtual void handleChildrenLostMode(ReturnValue_t result);
-
-	bool handleChildrenChangedHealth();
-
-	virtual void handleChildrenTransition();
-
-	ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode);
-
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-
-	virtual void doStartTransition(Mode_t mode, Submode_t submode);
-
-	virtual bool isInTransition();
-
-	virtual void handleModeReached();
-
-	virtual void handleModeTransitionFailed(ReturnValue_t result);
-
-	void sendHealthCommand(MessageQueueId_t sendTo, HealthState health);
-
-	virtual ReturnValue_t checkChildrenStateOff();
-
-	ReturnValue_t checkChildrenState();
-
-	virtual ReturnValue_t checkChildOff(uint32_t objectId);
-
-	/**
-	 * Manages recovery of a device
-	 * @return true if recovery is still ongoing, false else.
-	 */
-	bool checkAndHandleRecovery();
-
-	/**
-	 * Helper method to overwrite health state of one of the children.
-	 * Also sets state to STATE_OVERWRITE_HEATH.
-	 * @param objectId Must be a registered child.
-	 */
-	void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
-
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
+#define FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
+
+#include "../container/FixedArrayList.h"
+#include "../devicehandlers/DeviceHandlerBase.h"
+#include "../subsystem/SubsystemBase.h"
+
+/**
+ * @brief   Base class to implement reconfiguration and failure handling for
+ *          redundant devices by monitoring their modes health states.
+ * @details
+ * Documentation: Dissertation Baetz p.156, 157.
+ *
+ * This class reduces the complexity of controller components which would
+ * otherwise be needed for the handling of redundant devices.
+ *
+ * The template class monitors mode and health state of its children
+ * and checks availability of devices on every detected change.
+ * AssemblyBase does not implement any redundancy logic by itself, but provides
+ * adaptation points for implementations to do so. Since most monitoring
+ * activities rely on mode and health state only and are therefore
+ * generic, it is sufficient for subclasses to provide:
+ *
+ * 1. check logic when active-> checkChildrenStateOn
+ * 2. transition logic to change the mode -> commandChildren
+ *
+ */
+class AssemblyBase: public SubsystemBase {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ASSEMBLY_BASE;
+	static const ReturnValue_t NEED_SECOND_STEP = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t NEED_TO_RECONFIGURE = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t MODE_FALLBACK = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t CHILD_NOT_COMMANDABLE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t NEED_TO_CHANGE_HEALTH = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE =
+			MAKE_RETURN_CODE(0xa1);
+
+	AssemblyBase(object_id_t objectId, object_id_t parentId,
+	        uint16_t commandQueueDepth = 8);
+	virtual ~AssemblyBase();
+
+protected:
+
+    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
+    // (or return internalState directly?)
+    /**
+     * Command children to reach [mode,submode] combination
+     * Can be done by setting #commandsOutstanding correctly,
+     * or using executeTable()
+     * @param mode
+     * @param submode
+     * @return
+     *    - @c RETURN_OK if ok
+     *    - @c NEED_SECOND_STEP if children need to be commanded again
+     */
+    virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
+
+    /**
+     * Check whether desired assembly mode was achieved by checking the modes
+     * or/and health states of child device handlers.
+     * The assembly template class will also call this function if a health
+     * or mode change of a child device handler was detected.
+     * @param wantedMode
+     * @param wantedSubmode
+     * @return
+     */
+    virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
+            Submode_t wantedSubmode) = 0;
+
+    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+            Submode_t submode) = 0;
+
+	enum InternalState {
+		STATE_NONE,
+		STATE_OVERWRITE_HEALTH,
+		STATE_NEED_SECOND_STEP,
+		STATE_SINGLE_STEP,
+		STATE_SECOND_STEP,
+	} internalState;
+
+	enum RecoveryState {
+		RECOVERY_IDLE,
+		RECOVERY_STARTED,
+		RECOVERY_ONGOING,
+		RECOVERY_ONGOING_2,
+		RECOVERY_WAIT
+	} recoveryState; //!< Indicates if one of the children requested a recovery.
+	ChildrenMap::iterator recoveringDevice;
+
+	/**
+	 * the mode the current transition is trying to achieve.
+	 * Can be different from the modehelper.commandedMode!
+	 */
+	Mode_t targetMode;
+
+	/**
+	 * the submode the current transition is trying to achieve.
+	 * Can be different from the modehelper.commandedSubmode!
+	 */
+	Submode_t targetSubmode;
+
+	Countdown recoveryOffTimer;
+
+	static const uint32_t POWER_OFF_TIME_MS = 1000;
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
+
+	virtual ReturnValue_t handleHealthReply(CommandMessage *message);
+
+	virtual void performChildOperation();
+
+	bool handleChildrenChanged();
+
+	/**
+	 * This method is called if the children changed its mode in a way that
+	 * the current mode can't be kept.
+	 * Default behavior is to go to MODE_OFF.
+	 * @param result The failure code which was returned by checkChildrenState.
+	 */
+	virtual void handleChildrenLostMode(ReturnValue_t result);
+
+	bool handleChildrenChangedHealth();
+
+	virtual void handleChildrenTransition();
+
+	ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode);
+
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+
+	virtual void doStartTransition(Mode_t mode, Submode_t submode);
+
+	virtual bool isInTransition();
+
+	virtual void handleModeReached();
+
+	virtual void handleModeTransitionFailed(ReturnValue_t result);
+
+	void sendHealthCommand(MessageQueueId_t sendTo, HealthState health);
+
+	virtual ReturnValue_t checkChildrenStateOff();
+
+	ReturnValue_t checkChildrenState();
+
+	virtual ReturnValue_t checkChildOff(uint32_t objectId);
+
+	/**
+	 * Manages recovery of a device
+	 * @return true if recovery is still ongoing, false else.
+	 */
+	bool checkAndHandleRecovery();
+
+	/**
+	 * Helper method to overwrite health state of one of the children.
+	 * Also sets state to STATE_OVERWRITE_HEATH.
+	 * @param objectId Must be a registered child.
+	 */
+	void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
+
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 2e4428e5f..acc1b5a04 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -1,47 +1,47 @@
-#include <framework/subsystem/SubsystemBase.h>
-#include <framework/devicehandlers/ChildHandlerBase.h>
-#include <framework/subsystem/SubsystemBase.h>
-
-ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
-		object_id_t deviceCommunication, CookieIF * cookie,
-		object_id_t hkDestination, uint32_t thermalStatePoolId,
-		uint32_t thermalRequestPoolId,
-		object_id_t parent,
-		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
-		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
-			(customFdir == nullptr? &childHandlerFdir : customFdir),
-			cmdQueueSize),
-		parentId(parent), childHandlerFdir(setObjectId) {
-	this->setHkDestination(hkDestination);
-	this->setThermalStateRequestPoolIds(thermalStatePoolId,
-			thermalRequestPoolId);
-
-}
-
-ChildHandlerBase::~ChildHandlerBase() {
-}
-
-ReturnValue_t ChildHandlerBase::initialize() {
-	ReturnValue_t result = DeviceHandlerBase::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	MessageQueueId_t parentQueue = 0;
-
-	if (parentId != objects::NO_OBJECT) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
-
-		parent->registerChild(getObjectId());
-	}
-
-	healthHelper.setParentQueue(parentQueue);
-
-	modeHelper.setParentQueue(parentQueue);
-
-	return RETURN_OK;
-}
+#include "../subsystem/SubsystemBase.h"
+#include "../devicehandlers/ChildHandlerBase.h"
+#include "../subsystem/SubsystemBase.h"
+
+ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
+		object_id_t deviceCommunication, CookieIF * cookie,
+		object_id_t hkDestination, uint32_t thermalStatePoolId,
+		uint32_t thermalRequestPoolId,
+		object_id_t parent,
+		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
+		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
+			(customFdir == nullptr? &childHandlerFdir : customFdir),
+			cmdQueueSize),
+		parentId(parent), childHandlerFdir(setObjectId) {
+	this->setHkDestination(hkDestination);
+	this->setThermalStateRequestPoolIds(thermalStatePoolId,
+			thermalRequestPoolId);
+
+}
+
+ChildHandlerBase::~ChildHandlerBase() {
+}
+
+ReturnValue_t ChildHandlerBase::initialize() {
+	ReturnValue_t result = DeviceHandlerBase::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	MessageQueueId_t parentQueue = 0;
+
+	if (parentId != objects::NO_OBJECT) {
+		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		if (parent == NULL) {
+			return RETURN_FAILED;
+		}
+		parentQueue = parent->getCommandQueue();
+
+		parent->registerChild(getObjectId());
+	}
+
+	healthHelper.setParentQueue(parentQueue);
+
+	modeHelper.setParentQueue(parentQueue);
+
+	return RETURN_OK;
+}
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index c8ac9541e..625955f0f 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -1,24 +1,24 @@
-#ifndef PAYLOADHANDLERBASE_H_
-#define PAYLOADHANDLERBASE_H_
-
-#include <framework/devicehandlers/ChildHandlerFDIR.h>
-#include <framework/devicehandlers/DeviceHandlerBase.h>
-
-class ChildHandlerBase: public DeviceHandlerBase {
-public:
-	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * cookie, object_id_t hkDestination,
-			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-			object_id_t parent = objects::NO_OBJECT,
-			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
-	virtual ~ChildHandlerBase();
-
-	virtual ReturnValue_t initialize();
-
-protected:
-	const uint32_t parentId;
-	ChildHandlerFDIR childHandlerFdir;
-
-};
-
-#endif /* PAYLOADHANDLERBASE_H_ */
+#ifndef PAYLOADHANDLERBASE_H_
+#define PAYLOADHANDLERBASE_H_
+
+#include "../devicehandlers/ChildHandlerFDIR.h"
+#include "../devicehandlers/DeviceHandlerBase.h"
+
+class ChildHandlerBase: public DeviceHandlerBase {
+public:
+	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+			CookieIF * cookie, object_id_t hkDestination,
+			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+			object_id_t parent = objects::NO_OBJECT,
+			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
+	virtual ~ChildHandlerBase();
+
+	virtual ReturnValue_t initialize();
+
+protected:
+	const uint32_t parentId;
+	ChildHandlerFDIR childHandlerFdir;
+
+};
+
+#endif /* PAYLOADHANDLERBASE_H_ */
diff --git a/devicehandlers/ChildHandlerFDIR.cpp b/devicehandlers/ChildHandlerFDIR.cpp
index 1bba47fec..bab5a7e52 100644
--- a/devicehandlers/ChildHandlerFDIR.cpp
+++ b/devicehandlers/ChildHandlerFDIR.cpp
@@ -1,10 +1,10 @@
-#include <framework/devicehandlers/ChildHandlerFDIR.h>
-
-ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent, uint32_t recoveryCount) :
-		DeviceHandlerFailureIsolation(owner, faultTreeParent) {
-	recoveryCounter.setFailureThreshold(recoveryCount);
-}
-
-ChildHandlerFDIR::~ChildHandlerFDIR() {
-}
-
+#include "../devicehandlers/ChildHandlerFDIR.h"
+
+ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent, uint32_t recoveryCount) :
+		DeviceHandlerFailureIsolation(owner, faultTreeParent) {
+	recoveryCounter.setFailureThreshold(recoveryCount);
+}
+
+ChildHandlerFDIR::~ChildHandlerFDIR() {
+}
+
diff --git a/devicehandlers/ChildHandlerFDIR.h b/devicehandlers/ChildHandlerFDIR.h
index 7df9d238f..83f79a636 100644
--- a/devicehandlers/ChildHandlerFDIR.h
+++ b/devicehandlers/ChildHandlerFDIR.h
@@ -1,20 +1,20 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
-#define FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
-
-#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-
-/**
- * Very simple extension to normal FDIR.
- * Does not have a default fault tree parent and
- * allows to make the recovery count settable to 0.
- */
-class ChildHandlerFDIR: public DeviceHandlerFailureIsolation {
-public:
-	ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent =
-			NO_FAULT_TREE_PARENT, uint32_t recoveryCount = 0);
-	virtual ~ChildHandlerFDIR();
-protected:
-	static const object_id_t NO_FAULT_TREE_PARENT = 0;
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+#define FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+
+/**
+ * Very simple extension to normal FDIR.
+ * Does not have a default fault tree parent and
+ * allows to make the recovery count settable to 0.
+ */
+class ChildHandlerFDIR: public DeviceHandlerFailureIsolation {
+public:
+	ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent =
+			NO_FAULT_TREE_PARENT, uint32_t recoveryCount = 0);
+	virtual ~ChildHandlerFDIR();
+protected:
+	static const object_id_t NO_FAULT_TREE_PARENT = 0;
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_ */
diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index a80e7de18..aacf55803 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -4,8 +4,8 @@
  * @date 28.02.2020
  */
 
-#include <framework/devicehandlers/CommunicationMessage.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../devicehandlers/CommunicationMessage.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 #include <cstring>
 
 CommunicationMessage::CommunicationMessage(): uninitialized(true) {
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
index 952663197..a31e270c3 100644
--- a/devicehandlers/CommunicationMessage.h
+++ b/devicehandlers/CommunicationMessage.h
@@ -6,11 +6,11 @@
 
 #ifndef FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
 #define FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
-#include <framework/devicehandlers/CommunicationMessage.h>
+#include "../devicehandlers/CommunicationMessage.h"
 
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/devicehandlers/DeviceHandlerBase.h>
+#include "../ipc/MessageQueueMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../devicehandlers/DeviceHandlerBase.h"
 
 /**
  * @brief Message type to send larger messages
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index a2662d465..cbff54115 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -1,127 +1,127 @@
-#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
-#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
-
-#include <framework/devicehandlers/CookieIF.h>
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-/**
- * @defgroup interfaces Interfaces
- * @brief Interfaces for flight software objects
- */
-
-/**
- * @defgroup comm Communication
- * @brief Communication software components.
- */
-
-/**
- * @brief This is an interface to decouple device communication from
- * the device handler to allow reuse of these components.
- * @details
- * Documentation: Dissertation Baetz p.138.
- * It works with the assumption that received data  is polled by a component.
- * There are four generic steps of device communication:
- *
- *   1. Send data to a device
- *   2. Get acknowledgement for sending
- *   3. Request reading data from a device
- *   4. Read received data
- *
- *  To identify different connection over a single interface can return
- *  so-called cookies to components.
- *  The CommunicationMessage message type can be used to extend the
- *  functionality of the ComIF if a separate polling task is required.
- *  @ingroup interfaces
- *  @ingroup comm
- */
-class DeviceCommunicationIF: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
-
-	//! This is returned in readReceivedMessage() if no reply was reived.
-	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0x01);
-
-	//! General protocol error. Define more concrete errors in child handler
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
-	//! If cookie is a null pointer
-	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x04);
-	// is this needed if there is no open/close call?
-	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
-
-	virtual ~DeviceCommunicationIF() {}
-
-	/**
-	 * @brief Device specific initialization, using the cookie.
-	 * @details
-	 * The cookie is already prepared in the factory. If the communication
-	 * interface needs to be set up in some way and requires cookie information,
-	 * this can be performed in this function, which is called on device handler
-	 * initialization.
-	 * @param cookie
-	 * @return
-	 *  - @c RETURN_OK if initialization was successfull
-	 *  - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendWrite().
-	 * This function is used to send data to the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param data
-	 * @param len If this is 0, nothing shall be sent.
-	 * @return
-	 *  - @c RETURN_OK for successfull send
-	 *  - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t sendMessage(CookieIF *cookie,
-	        const uint8_t * sendData, size_t sendLen) = 0;
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetWrite().
-	 * Get send confirmation that the data in sendMessage() was sent successfully.
-	 * @param cookie
-	 * @return - @c RETURN_OK if data was sent successfull
-	 * 		   - Everything else triggers falure event with
-	 * 		     returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * It is assumed that it is always possible to request a reply
-	 * from a device. If a requestLen of 0 is supplied, no reply was enabled
-	 * and communication specific action should be taken (e.g. read nothing
-	 * or read everything).
-	 *
-	 * @param cookie
-	 * @param requestLen Size of data to read
-	 * @return - @c RETURN_OK to confirm the request for data has been sent.
-	 *         - Everything else triggers failure event with
-	 *           returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-	        size_t requestLen) = 0;
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetRead().
-	 * This function is used to receive data from the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param buffer [out] Set reply here (by using *buffer = ...)
-	 * @param size [out] size pointer to set (by using *size = ...).
-	 * 	           Set to 0 if no reply was received
-	 * @return - @c RETURN_OK for successfull receive
-	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
-	 * 		   	   0 has the same effect
-	 *         - Everything else triggers failure event with
-	 *           returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
-	        uint8_t **buffer, size_t *size) = 0;
-};
-
-#endif /* DEVICECOMMUNICATIONIF_H_ */
+#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+
+#include "../devicehandlers/CookieIF.h"
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ * @defgroup interfaces Interfaces
+ * @brief Interfaces for flight software objects
+ */
+
+/**
+ * @defgroup comm Communication
+ * @brief Communication software components.
+ */
+
+/**
+ * @brief This is an interface to decouple device communication from
+ * the device handler to allow reuse of these components.
+ * @details
+ * Documentation: Dissertation Baetz p.138.
+ * It works with the assumption that received data  is polled by a component.
+ * There are four generic steps of device communication:
+ *
+ *   1. Send data to a device
+ *   2. Get acknowledgement for sending
+ *   3. Request reading data from a device
+ *   4. Read received data
+ *
+ *  To identify different connection over a single interface can return
+ *  so-called cookies to components.
+ *  The CommunicationMessage message type can be used to extend the
+ *  functionality of the ComIF if a separate polling task is required.
+ *  @ingroup interfaces
+ *  @ingroup comm
+ */
+class DeviceCommunicationIF: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
+
+	//! This is returned in readReceivedMessage() if no reply was reived.
+	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0x01);
+
+	//! General protocol error. Define more concrete errors in child handler
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
+	//! If cookie is a null pointer
+	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x04);
+	// is this needed if there is no open/close call?
+	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
+
+	virtual ~DeviceCommunicationIF() {}
+
+	/**
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return
+	 *  - @c RETURN_OK if initialization was successfull
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len If this is 0, nothing shall be sent.
+	 * @return
+	 *  - @c RETURN_OK for successfull send
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t sendMessage(CookieIF *cookie,
+	        const uint8_t * sendData, size_t sendLen) = 0;
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return - @c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with
+	 * 		     returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device. If a requestLen of 0 is supplied, no reply was enabled
+	 * and communication specific action should be taken (e.g. read nothing
+	 * or read everything).
+	 *
+	 * @param cookie
+	 * @param requestLen Size of data to read
+	 * @return - @c RETURN_OK to confirm the request for data has been sent.
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
+	        size_t requestLen) = 0;
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param buffer [out] Set reply here (by using *buffer = ...)
+	 * @param size [out] size pointer to set (by using *size = ...).
+	 * 	           Set to 0 if no reply was received
+	 * @return - @c RETURN_OK for successfull receive
+	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
+	 * 		   	   0 has the same effect
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
+	        uint8_t **buffer, size_t *size) = 0;
+};
+
+#endif /* DEVICECOMMUNICATIONIF_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index a4346afbe..06b26595e 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,1397 +1,1397 @@
-#include <framework/devicehandlers/DeviceHandlerBase.h>
-#include <framework/objectmanager/ObjectManager.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/thermal/ThermalComponentIF.h>
-#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
-#include <framework/globalfunctions/CRC.h>
-#include <framework/housekeeping/HousekeepingMessage.h>
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/subsystem/SubsystemBase.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-#include <iomanip>
-
-object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::defaultHkDestination = objects::NO_OBJECT;
-
-DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
-		object_id_t deviceCommunication, CookieIF * comCookie,
-		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
-		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
-		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
-		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		actionHelper(this, nullptr), hkManager(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,
-			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;
-	}
-	if (this->fdirInstance == nullptr) {
-		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
-				defaultFdirParentId);
-	}
-}
-
-void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
-	this->hkDestination = hkDestination;
-}
-
-void DeviceHandlerBase::setThermalStateRequestPoolIds(
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId) {
-	this->deviceThermalRequestPoolId = thermalStatePoolId;
-	this->deviceThermalRequestPoolId = thermalRequestPoolId;
-}
-
-
-DeviceHandlerBase::~DeviceHandlerBase() {
-	delete comCookie;
-	if (defaultFDIRUsed) {
-		delete fdirInstance;
-	}
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
-	this->pstStep = counter;
-
-	if (getComAction() == SEND_WRITE) {
-		cookieInfo.state = COOKIE_UNUSED;
-		readCommandQueue();
-		doStateMachine();
-		checkSwitchState();
-		decrementDeviceReplyMap();
-		fdirInstance->checkForFailures();
-		hkSwitcher.performOperation();
-		performOperationHook();
-	}
-	if (mode == MODE_OFF) {
-		return RETURN_OK;
-	}
-	switch (getComAction()) {
-	case SEND_WRITE:
-		if ((cookieInfo.state == COOKIE_UNUSED)) {
-			buildInternalCommand();
-		}
-		doSendWrite();
-		break;
-	case GET_WRITE:
-		doGetWrite();
-		break;
-	case SEND_READ:
-		doSendRead();
-		break;
-	case GET_READ:
-		doGetRead();
-		cookieInfo.state = COOKIE_UNUSED;
-		break;
-	default:
-		break;
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t DeviceHandlerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	communicationInterface = objectManager->get<DeviceCommunicationIF>(
-			deviceCommunicationId);
-	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);
-	if (result != RETURN_OK) {
-	    sif::error << "DeviceHandlerBase::initialize: Initializing "
-	            "communication interface failed!" << std::endl;
-	    return result;
-	}
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (IPCStore == nullptr) {
-		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
-				"factory." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	if(rawDataReceiverId != objects::NO_OBJECT) {
-		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
-				AcceptsDeviceResponsesIF>(rawDataReceiverId);
-
-		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();
-	}
-
-	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;
-	}
-
-	result = modeHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = actionHelper.initialize(commandQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = fdirInstance->initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = hkSwitcher.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	if(hkDestination == objects::NO_OBJECT) {
-		hkDestination = defaultHkDestination;
-	}
-
-	result = hkManager.initialize(commandQueue, hkDestination);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	fillCommandAndReplyMap();
-
-	//Set temperature target state to NON_OP.
-	GlobDataSet mySet;
-	gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-			PoolVariableIF::VAR_WRITE);
-	mySet.read();
-	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-	mySet.commit(PoolVariableIF::VALID);
-
-	return RETURN_OK;
-
-}
-
-void DeviceHandlerBase::decrementDeviceReplyMap() {
-	for (std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
-			deviceReplyMap.begin(); iter != deviceReplyMap.end(); iter++) {
-		if (iter->second.delayCycles != 0) {
-			iter->second.delayCycles--;
-			if (iter->second.delayCycles == 0) {
-				if (iter->second.periodic) {
-					iter->second.delayCycles = iter->second.maxDelayCycles;
-				}
-				replyToReply(iter, TIMEOUT);
-				missedReply(iter->first);
-			}
-		}
-	}
-}
-
-void DeviceHandlerBase::readCommandQueue() {
-
-	if (dontCheckQueue()) {
-		return;
-	}
-
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != RETURN_OK) {
-		return;
-	}
-
-	result = healthHelper.handleHealthCommand(&command);
-	if (result == RETURN_OK) {
-	    return;
-	}
-
-	result = modeHelper.handleModeCommand(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	result = actionHelper.handleActionMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	result = parameterHelper.handleParameterMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	result = hkManager.handleHousekeepingMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	result = handleDeviceHandlerMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	result = letChildHandleMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	replyReturnvalueToCommand(CommandMessage::UNKNOWN_COMMAND);
-
-}
-
-void DeviceHandlerBase::doStateMachine() {
-	switch (mode) {
-	case _MODE_START_UP:
-	case _MODE_SHUT_DOWN:
-	case _MODE_TO_NORMAL:
-	case _MODE_TO_ON:
-	case _MODE_TO_RAW: {
-		Mode_t currentMode = mode;
-		callChildStatemachine();
-		//Only do timeout if child did not change anything
-		if (mode != currentMode) {
-			break;
-		}
-		uint32_t currentUptime;
-		Clock::getUptime(&currentUptime);
-		if (currentUptime - timeoutStart >= childTransitionDelay) {
-			triggerEvent(MODE_TRANSITION_FAILED, childTransitionFailure, 0);
-			setMode(transitionSourceMode, transitionSourceSubMode);
-			break;
-		}
-	}
-		break;
-	case _MODE_POWER_DOWN:
-		commandSwitch(PowerSwitchIF::SWITCH_OFF);
-		setMode(_MODE_WAIT_OFF);
-		break;
-	case _MODE_POWER_ON:
-		commandSwitch(PowerSwitchIF::SWITCH_ON);
-		setMode(_MODE_WAIT_ON);
-		break;
-	case _MODE_WAIT_ON: {
-		uint32_t currentUptime;
-		Clock::getUptime(&currentUptime);
-		if (powerSwitcher != nullptr and currentUptime - timeoutStart >=
-				powerSwitcher->getSwitchDelayMs()) {
-			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
-					0);
-			setMode(_MODE_POWER_DOWN);
-			callChildStatemachine();
-			break;
-		}
-		ReturnValue_t switchState = getStateOfSwitches();
-		if ((switchState == PowerSwitchIF::SWITCH_ON)
-				|| (switchState == NO_SWITCH)) {
-			//NOTE: TransitionSourceMode and -SubMode are set by handleCommandedModeTransition
-			childTransitionFailure = CHILD_TIMEOUT;
-			setMode(_MODE_START_UP);
-			callChildStatemachine();
-		}
-	}
-		break;
-	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);
-			setMode(MODE_ERROR_ON);
-			break;
-		}
-		ReturnValue_t switchState = getStateOfSwitches();
-		if ((switchState == PowerSwitchIF::SWITCH_OFF)
-				|| (switchState == NO_SWITCH)) {
-			setMode(_MODE_SWITCH_IS_OFF);
-		}
-	}
-		break;
-	case MODE_OFF:
-		doOffActivity();
-		break;
-	case MODE_ON:
-		doOnActivity();
-		break;
-	case MODE_RAW:
-	case MODE_NORMAL:
-	case MODE_ERROR_ON:
-		break;
-	case _MODE_SWITCH_IS_OFF:
-		setMode(MODE_OFF, SUBMODE_NONE);
-		break;
-	default:
-		triggerEvent(OBJECT_IN_INVALID_MODE, mode, submode);
-		setMode(_MODE_POWER_DOWN, 0);
-		break;
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
-		Submode_t submode) {
-	switch (mode) {
-	case MODE_OFF:
-	case MODE_ON:
-	case MODE_NORMAL:
-	case MODE_RAW:
-		if (submode == SUBMODE_NONE) {
-			return RETURN_OK;
-		} else {
-			return INVALID_SUBMODE;
-		}
-	default:
-		return HasModesIF::INVALID_MODE;
-	}
-}
-
-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) {
-		return insertInReplyMap(replyId, maxDelayCycles, replyLen, periodic);
-	} else {
-		return insertInReplyMap(deviceCommand, maxDelayCycles, replyLen, periodic);
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, size_t replyLen, bool periodic) {
-	DeviceReplyInfo info;
-	info.maxDelayCycles = maxDelayCycles;
-	info.periodic = periodic;
-	info.delayCycles = 0;
-	info.replyLen = replyLen;
-	info.command = deviceCommandMap.end();
-	auto resultPair = deviceReplyMap.emplace(replyId, info);
-	if (resultPair.second) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::insertInCommandMap(
-		DeviceCommandId_t deviceCommand) {
-	DeviceCommandInfo info;
-	info.expectedReplies = 0;
-	info.isExecuting = false;
-	info.sendReplyTo = NO_COMMANDER;
-	auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
-	if (resultPair.second) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
-		uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
-	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
-			deviceReplyMap.find(deviceReply);
-	if (iter == deviceReplyMap.end()) {
-		triggerEvent(INVALID_DEVICE_COMMAND, deviceReply);
-		return RETURN_FAILED;
-	} else {
-		DeviceReplyInfo *info = &(iter->second);
-		if (maxDelayCycles != 0) {
-			info->maxDelayCycles = maxDelayCycles;
-		}
-		info->delayCycles = delayCycles;
-		info->periodic = periodic;
-		return RETURN_OK;
-	}
-}
-
-void DeviceHandlerBase::callChildStatemachine() {
-	if (mode == _MODE_START_UP) {
-		doStartUp();
-	} else if (mode == _MODE_SHUT_DOWN) {
-		doShutDown();
-	} else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
-		doTransition(transitionSourceMode, transitionSourceSubMode);
-	}
-}
-
-void DeviceHandlerBase::setTransition(Mode_t modeTo, Submode_t submodeTo) {
-	triggerEvent(CHANGING_MODE, modeTo, submodeTo);
-	childTransitionDelay = getTransitionDelayMs(mode, modeTo);
-	transitionSourceMode = mode;
-	transitionSourceSubMode = submode;
-	childTransitionFailure = CHILD_TIMEOUT;
-
-	// transitionTargetMode is set by setMode
-	setMode((modeTo | TRANSITION_MODE_CHILD_ACTION_MASK), submodeTo);
-}
-
-void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
-	changeHK(mode, submode, false);
-	submode = newSubmode;
-	mode = newMode;
-	modeChanged();
-	setNormalDatapoolEntriesInvalid();
-	if (!isTransitionalMode()) {
-		modeHelper.modeChanged(newMode, newSubmode);
-		announceMode(false);
-	}
-	Clock::getUptime(&timeoutStart);
-
-	if (mode == MODE_OFF) {
-		GlobDataSet mySet;
-		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-				PoolVariableIF::VAR_READ_WRITE);
-		mySet.read();
-		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-			thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-		}
-		mySet.commit(PoolVariableIF::VALID);
-	}
-	changeHK(mode, submode, true);
-}
-
-void DeviceHandlerBase::setMode(Mode_t newMode) {
-	setMode(newMode, submode);
-}
-
-void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
-		uint32_t parameter) {
-	//This is actually the reply protocol for raw and misc DH commands.
-	if (status == RETURN_OK) {
-		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, parameter);
-		commandQueue->reply(&reply);
-	} else {
-		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, parameter);
-		commandQueue->reply(&reply);
-	}
-}
-
-void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
-		uint32_t parameter) {
-//Check if we reply to a raw command.
-	if (cookieInfo.pendingCommand->first == RAW_COMMAND_ID) {
-		if (status == NO_REPLY_EXPECTED) {
-			status = RETURN_OK;
-		}
-		replyReturnvalueToCommand(status, parameter);
-		//Always delete data from a raw command.
-		IPCStore->deleteData(storedRawData);
-		return;
-	}
-//Check if we were externally commanded.
-	if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
-		MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
-		if (status == NO_REPLY_EXPECTED) {
-			actionHelper.finish(queueId, cookieInfo.pendingCommand->first,
-					RETURN_OK);
-		} else {
-			actionHelper.step(1, queueId, cookieInfo.pendingCommand->first,
-					status);
-		}
-	}
-}
-
-void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
-		ReturnValue_t status) {
-//No need to check if iter exists, as this is checked by callers. If someone else uses the method, add check.
-	if (iter->second.command == deviceCommandMap.end()) {
-		//Is most likely periodic reply. Silent return.
-		return;
-	}
-//Check if more replies are expected. If so, do nothing.
-	DeviceCommandInfo* info = &(iter->second.command->second);
-	if (--info->expectedReplies == 0) {
-		//Check if it was transition or internal command. Don't send any replies in that case.
-		if (info->sendReplyTo != NO_COMMANDER) {
-			actionHelper.finish(info->sendReplyTo, iter->first, status);
-		}
-		info->isExecuting = false;
-	}
-}
-
-void DeviceHandlerBase::doSendWrite() {
-	if (cookieInfo.state == COOKIE_WRITE_READY) {
-
-		ReturnValue_t result = communicationInterface->sendMessage(comCookie,
-				rawPacket, rawPacketLen);
-
-		if (result == RETURN_OK) {
-			cookieInfo.state = COOKIE_WRITE_SENT;
-		} else {
-			//always generate a failure event, so that FDIR knows what's up
-			triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
-					cookieInfo.pendingCommand->first);
-			replyToCommand(result);
-			cookieInfo.state = COOKIE_UNUSED;
-			cookieInfo.pendingCommand->second.isExecuting = false;
-		}
-	}
-}
-
-void DeviceHandlerBase::doGetWrite() {
-	if (cookieInfo.state != COOKIE_WRITE_SENT) {
-		return;
-	}
-	cookieInfo.state = COOKIE_UNUSED;
-	ReturnValue_t result = communicationInterface->getSendSuccess(comCookie);
-	if (result == RETURN_OK) {
-		if (wiretappingMode == RAW) {
-			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
-		}
-
-		//We need to distinguish here, because a raw command never expects a reply.
-		//(Could be done in eRIRM, but then child implementations need to be careful.
-		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
-	} else {
-		//always generate a failure event, so that FDIR knows what's up
-		triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
-				cookieInfo.pendingCommand->first);
-	}
-	if (result != RETURN_OK) {
-		cookieInfo.pendingCommand->second.isExecuting = false;
-	}
-	replyToCommand(result);
-}
-
-void DeviceHandlerBase::doSendRead() {
-	ReturnValue_t result;
-
-	size_t requestLen = 0;
-	if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
-		DeviceReplyIter iter = deviceReplyMap.find(
-				cookieInfo.pendingCommand->first);
-		if(iter != deviceReplyMap.end()) {
-			requestLen = iter->second.replyLen;
-		}
-	}
-
-	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
-
-	if (result == RETURN_OK) {
-		cookieInfo.state = COOKIE_READ_SENT;
-	} else {
-		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
-		//We can't inform anyone, because we don't know which command was sent last.
-		//So, we need to wait for a timeout.
-		//but I think we can allow to ignore one missedReply.
-		ignoreMissedRepliesCount++;
-		cookieInfo.state = COOKIE_UNUSED;
-	}
-}
-
-void DeviceHandlerBase::doGetRead() {
-	size_t receivedDataLen = 0;
-	uint8_t *receivedData = nullptr;
-
-	if (cookieInfo.state != COOKIE_READ_SENT) {
-		cookieInfo.state = COOKIE_UNUSED;
-		return;
-	}
-
-	cookieInfo.state = COOKIE_UNUSED;
-
-	ReturnValue_t result = communicationInterface->readReceivedMessage(
-			comCookie, &receivedData, &receivedDataLen);
-
-	if (result != RETURN_OK) {
-		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
-		//I think we can allow to ignore one missedReply.
-		ignoreMissedRepliesCount++;
-		return;
-	}
-
-	if (receivedDataLen == 0 or result == DeviceCommunicationIF::NO_REPLY_RECEIVED)
-		return;
-
-	if (wiretappingMode == RAW) {
-		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
-	}
-
-	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
-		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
-	}
-	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);
-			if(foundLen == 0) {
-			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
-			            " Packet parsing will be stuck." << std::endl;
-			}
-			break;
-		case APERIODIC_REPLY: {
-			result = interpretDeviceReply(foundId, receivedData);
-			if (result != RETURN_OK) {
-			    replyRawReplyIfnotWiretapped(receivedData, foundLen);
-			    triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
-			            foundId);
-			}
-			if(foundLen == 0) {
-			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
-			            " Packet parsing will be stuck." << std::endl;
-			}
-			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) {
-	size_t lenTmp;
-
-	if (IPCStore == nullptr) {
-		*data = nullptr;
-		*len = 0;
-		return RETURN_FAILED;
-	}
-	ReturnValue_t result = IPCStore->modifyData(storageAddress, data, &lenTmp);
-	if (result == RETURN_OK) {
-		*len = lenTmp;
-		return RETURN_OK;
-	} else {
-		triggerEvent(StorageManagerIF::GET_DATA_FAILED, result,
-				storageAddress.raw);
-		*data = nullptr;
-		*len = 0;
-		return result;
-	}
-}
-
-void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
-		MessageQueueId_t sendTo, bool isCommand) {
-	if (IPCStore == nullptr or len == 0 or sendTo == MessageQueueIF::NO_QUEUE) {
-		return;
-	}
-	store_address_t address;
-	ReturnValue_t result = IPCStore->addData(&address, data, len);
-
-	if (result != RETURN_OK) {
-		triggerEvent(StorageManagerIF::STORE_DATA_FAILED, result);
-		return;
-	}
-
-	CommandMessage command;
-
-	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
-			getObjectId(), address, isCommand);
-
-	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.
-	}
-}
-
-//Default child implementations
-DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
-	switch (pstStep) {
-	case 0:
-		return SEND_WRITE;
-		break;
-	case 1:
-		return GET_WRITE;
-		break;
-	case 2:
-		return SEND_READ;
-		break;
-	case 3:
-		return GET_READ;
-		break;
-	default:
-		break;
-	}
-	return NOTHING;
-}
-
-MessageQueueId_t DeviceHandlerBase::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
-	storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
-	ReturnValue_t result = getStorageData(storedRawData, &rawPacket,
-			&rawPacketLen);
-	if (result != RETURN_OK) {
-		replyReturnvalueToCommand(result, RAW_COMMAND_ID);
-		storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
-	} else {
-		cookieInfo.pendingCommand = deviceCommandMap.find(
-				(DeviceCommandId_t) RAW_COMMAND_ID);
-		cookieInfo.pendingCommand->second.isExecuting = true;
-		cookieInfo.state = COOKIE_WRITE_READY;
-	}
-}
-
-void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
-	if(powerSwitcher == nullptr) {
-		return;
-	}
-	const uint8_t *switches;
-	uint8_t numberOfSwitches = 0;
-	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
-	if (result == RETURN_OK) {
-		while (numberOfSwitches > 0) {
-			powerSwitcher->sendSwitchCommand(switches[numberOfSwitches - 1],
-					onOff);
-			numberOfSwitches--;
-		}
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::getSwitches(const uint8_t **switches,
-		uint8_t *numberOfSwitches) {
-	return DeviceHandlerBase::NO_SWITCH;
-}
-
-void DeviceHandlerBase::modeChanged(void) {
-}
-
-ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
-		DeviceCommandMap::iterator command, uint8_t expectedReplies,
-		bool useAlternativeId, DeviceCommandId_t alternativeReply) {
-	DeviceReplyMap::iterator iter;
-	if (useAlternativeId) {
-		iter = deviceReplyMap.find(alternativeReply);
-	} else {
-		iter = deviceReplyMap.find(command->first);
-	}
-	if (iter != deviceReplyMap.end()) {
-		DeviceReplyInfo *info = &(iter->second);
-		info->delayCycles = info->maxDelayCycles;
-		info->command = command;
-		command->second.expectedReplies = expectedReplies;
-		return RETURN_OK;
-	} else {
-		return NO_REPLY_EXPECTED;
-	}
-}
-
-void DeviceHandlerBase::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
-	setMode(getBaseMode(mode));
-}
-
-uint32_t DeviceHandlerBase::getTransitionDelayMs(Mode_t modeFrom,
-		Mode_t modeTo) {
-	return 0;
-}
-
-ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
-	if(powerSwitcher == nullptr) {
-		return NO_SWITCH;
-	}
-	uint8_t numberOfSwitches = 0;
-	const uint8_t *switches;
-
-	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
-	if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
-		while (numberOfSwitches > 0) {
-			if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1])
-					== PowerSwitchIF::SWITCH_OFF) {
-				return PowerSwitchIF::SWITCH_OFF;
-			}
-			numberOfSwitches--;
-		}
-		return PowerSwitchIF::SWITCH_ON;
-	}
-
-	return NO_SWITCH;
-}
-
-Mode_t DeviceHandlerBase::getBaseMode(Mode_t transitionMode) {
-//only child action special modes are handled, as a child should never see any base action modes
-	if (transitionMode == _MODE_START_UP) {
-		return _MODE_TO_ON;
-	}
-	if (transitionMode == _MODE_SHUT_DOWN) {
-		return _MODE_POWER_DOWN;
-	}
-	return transitionMode
-			& ~(TRANSITION_MODE_BASE_ACTION_MASK
-					| TRANSITION_MODE_CHILD_ACTION_MASK);
-}
-
-//SHOULDDO: Allow transition from OFF to NORMAL to reduce complexity in assemblies. And, by the way, throw away DHB and write a new one:
-// - Include power and thermal completely, but more modular :-)
-// - Don't use modes for state transitions, reduce FSM (Finte State Machine) complexity.
-// - Modularization?
-ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
-		Submode_t commandedSubmode, uint32_t* msToReachTheMode) {
-	if (isTransitionalMode()) {
-		return IN_TRANSITION;
-	}
-	if ((mode == MODE_ERROR_ON) && (commandedMode != MODE_OFF)) {
-		return TRANS_NOT_ALLOWED;
-	}
-	if ((commandedMode == MODE_NORMAL) && (mode == MODE_OFF)) {
-		return TRANS_NOT_ALLOWED;
-	}
-
-	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
-			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)) {
-		GlobDataSet mySet;
-		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
-				PoolVariableIF::VAR_READ);
-		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-				PoolVariableIF::VAR_READ);
-		mySet.read();
-		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-			if (!ThermalComponentIF::isOperational(thermalState)) {
-				triggerEvent(ThermalComponentIF::TEMP_NOT_IN_OP_RANGE,
-						thermalState);
-				return NON_OP_TEMPERATURE;
-			}
-		}
-	}
-
-	return isModeCombinationValid(commandedMode, commandedSubmode);
-}
-
-void DeviceHandlerBase::startTransition(Mode_t commandedMode,
-		Submode_t commandedSubmode) {
-	switch (commandedMode) {
-	case MODE_ON:
-		if (mode == MODE_OFF) {
-			transitionSourceMode = _MODE_POWER_DOWN;
-			transitionSourceSubMode = SUBMODE_NONE;
-			setMode(_MODE_POWER_ON, commandedSubmode);
-			//already set the delay for the child transition so we don't need to call it twice
-			childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
-					MODE_ON);
-			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-			GlobDataSet mySet;
-			gp_int8_t thermalRequest(deviceThermalRequestPoolId,
-					&mySet, PoolVariableIF::VAR_READ_WRITE);
-			mySet.read();
-			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-				thermalRequest = ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
-				mySet.commit(PoolVariableIF::VALID);
-			}
-		} else {
-			setTransition(MODE_ON, commandedSubmode);
-		}
-		break;
-	case MODE_OFF:
-		if (mode == MODE_OFF) {
-			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-			setMode(_MODE_POWER_DOWN, commandedSubmode);
-		} else {
-			//already set the delay for the child transition so we don't need to call it twice
-			childTransitionDelay = getTransitionDelayMs(mode, _MODE_POWER_DOWN);
-			transitionSourceMode = _MODE_POWER_DOWN;
-			transitionSourceSubMode = commandedSubmode;
-			childTransitionFailure = CHILD_TIMEOUT;
-			setMode(_MODE_SHUT_DOWN, commandedSubmode);
-			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-		}
-		break;
-	case MODE_RAW:
-		if (mode != MODE_OFF) {
-			setTransition(MODE_RAW, commandedSubmode);
-		} else {
-			setMode(MODE_RAW, commandedSubmode);
-		}
-		break;
-	case MODE_NORMAL:
-		if (mode != MODE_OFF) {
-			setTransition(MODE_NORMAL, commandedSubmode);
-		} else {
-			replyReturnvalueToCommand(HasModesIF::TRANS_NOT_ALLOWED);
-		}
-		break;
-	}
-}
-
-void DeviceHandlerBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
-}
-
-void DeviceHandlerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
-}
-
-void DeviceHandlerBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
-}
-
-bool DeviceHandlerBase::dontCheckQueue() {
-	return false;
-}
-
-void DeviceHandlerBase::missedReply(DeviceCommandId_t id) {
-	if (ignoreMissedRepliesCount > 0) {
-		ignoreMissedRepliesCount--;
-	} else {
-		triggerEvent(DEVICE_MISSED_REPLY, id);
-	}
-}
-
-HasHealthIF::HealthState DeviceHandlerBase::getHealth() {
-	return healthHelper.getHealth();
-}
-
-ReturnValue_t DeviceHandlerBase::setHealth(HealthState health) {
-    healthHelper.setHealth(health);
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void DeviceHandlerBase::checkSwitchState() {
-	if ((mode == MODE_ON || mode == MODE_NORMAL)) {
-		//We only check in ON and NORMAL, ignore RAW and ERROR_ON.
-		ReturnValue_t result = getStateOfSwitches();
-		if (result == PowerSwitchIF::SWITCH_OFF && !switchOffWasReported) {
-			triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
-			switchOffWasReported = true;
-		}
-	} else {
-		switchOffWasReported = false;
-	}
-}
-
-void DeviceHandlerBase::doOnActivity() {
-}
-
-ReturnValue_t DeviceHandlerBase::acceptExternalDeviceCommands() {
-	if ((mode != MODE_ON) && (mode != MODE_NORMAL)) {
-		return WRONG_MODE_FOR_COMMAND;
-	}
-	return RETURN_OK;
-}
-
-void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
-		size_t len) {
-	if ((wiretappingMode == RAW)
-			&& (defaultRawReceiver == requestedRawTraffic)) {
-		//The raw packet was already sent by the wiretapping service
-	} else {
-		replyRawData(data, len, defaultRawReceiver);
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
-		CommandMessage * message) {
-	switch (message->getCommand()) {
-	case DeviceHandlerMessage::CMD_WIRETAPPING:
-		switch (DeviceHandlerMessage::getWiretappingMode(message)) {
-		case RAW:
-			wiretappingMode = RAW;
-			requestedRawTraffic = commandQueue->getLastPartner();
-			break;
-		case TM:
-			wiretappingMode = TM;
-			requestedRawTraffic = commandQueue->getLastPartner();
-			break;
-		case OFF:
-			wiretappingMode = OFF;
-			break;
-		default:
-			replyReturnvalueToCommand(INVALID_COMMAND_PARAMETER);
-			wiretappingMode = OFF;
-			return RETURN_OK;
-		}
-		replyReturnvalueToCommand(RETURN_OK);
-		return RETURN_OK;
-//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
-//		if (mode != MODE_OFF) {
-//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-//		} else {
-//			result = switchCookieChannel(
-//					DeviceHandlerMessage::getIoBoardObjectId(message));
-//			if (result == RETURN_OK) {
-//				replyReturnvalueToCommand(RETURN_OK);
-//			} else {
-//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
-//			}
-//		}
-//		return RETURN_OK;
-	case DeviceHandlerMessage::CMD_RAW:
-		if ((mode != MODE_RAW)) {
-			DeviceHandlerMessage::clear(message);
-			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-		} else {
-			buildRawDeviceCommand(message);
-		}
-		return RETURN_OK;
-	default:
-		return RETURN_FAILED;
-	}
-}
-
-void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
-	modeHelper.setParentQueue(parentQueueId);
-	healthHelper.setParentQueue(parentQueueId);
-}
-
-bool DeviceHandlerBase::isAwaitingReply() {
-	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter;
-	for (iter = deviceReplyMap.begin(); iter != deviceReplyMap.end(); ++iter) {
-		if (iter->second.delayCycles != 0) {
-			return true;
-		}
-	}
-	return false;
-}
-
-ReturnValue_t DeviceHandlerBase::letChildHandleMessage(
-		CommandMessage * message) {
-	return RETURN_FAILED;
-}
-
-void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
-		DeviceCommandId_t replyId, bool neverInDataPool, bool forceDirectTm) {
-	DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
-	if (iter == deviceReplyMap.end()) {
-		triggerEvent(DEVICE_UNKNOWN_REPLY, replyId);
-		return;
-	}
-	DeviceTmReportingWrapper wrapper(getObjectId(), replyId, data);
-	//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 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);
-		}
-	}
-	//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) {
-		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
-		if (dataSet != NULL) {
-			dataSet->commit(PoolVariableIF::VALID);
-		}
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
-	ReturnValue_t result = acceptExternalDeviceCommands();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
-	if (iter == deviceCommandMap.end()) {
-		result = COMMAND_NOT_SUPPORTED;
-	} else if (iter->second.isExecuting) {
-		result = COMMAND_ALREADY_SENT;
-	} else {
-		result = buildCommandFromCommand(actionId, data, size);
-	}
-	if (result == RETURN_OK) {
-		iter->second.sendReplyTo = commandedBy;
-		iter->second.isExecuting = true;
-		cookieInfo.pendingCommand = iter;
-		cookieInfo.state = COOKIE_WRITE_READY;
-	}
-	return result;
-}
-
-void DeviceHandlerBase::buildInternalCommand(void) {
-//Neither Raw nor Direct could build a command
-	ReturnValue_t result = NOTHING_TO_SEND;
-	DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
-	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;
-			result = NOTHING_TO_SEND; //no need to report this
-		}
-	}
-	else if (mode == MODE_RAW) {
-		result = buildChildRawCommand();
-		deviceCommandId = RAW_COMMAND_ID;
-	}
-	else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
-		result = buildTransitionDeviceCommand(&deviceCommandId);
-	}
-	else {
-		return;
-	}
-
-	if (result == NOTHING_TO_SEND) {
-		return;
-	}
-	if (result == RETURN_OK) {
-		DeviceCommandMap::iterator iter = deviceCommandMap.find(
-				deviceCommandId);
-		if (iter == deviceCommandMap.end()) {
-			result = COMMAND_NOT_SUPPORTED;
-		} else if (iter->second.isExecuting) {
-			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Command "
-					<< deviceCommandId << " isExecuting" << std::endl; //so we can track misconfigurations
-			return; //this is an internal command, no need to report a failure here, missed reply will track if a reply is too late, otherwise, it's ok
-		} else {
-			iter->second.sendReplyTo = NO_COMMANDER;
-			iter->second.isExecuting = true;
-			cookieInfo.pendingCommand = iter;
-			cookieInfo.state = COOKIE_WRITE_READY;
-		}
-	}
-	if (result != RETURN_OK) {
-		triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::buildChildRawCommand() {
-	return NOTHING_TO_SEND;
-}
-
-uint8_t DeviceHandlerBase::getReplyDelayCycles(
-		DeviceCommandId_t deviceCommand) {
-	DeviceReplyMap::iterator iter = deviceReplyMap.find(deviceCommand);
-	if (iter == deviceReplyMap.end()) {
-		return 0;
-	}
-	return iter->second.delayCycles;
-}
-
-Mode_t DeviceHandlerBase::getTransitionSourceMode() const {
-	return transitionSourceMode;
-}
-
-Submode_t DeviceHandlerBase::getTransitionSourceSubMode() const {
-	return transitionSourceSubMode;
-}
-
-void DeviceHandlerBase::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	fdirInstance->triggerEvent(event, parameter1, parameter2);
-}
-
-void DeviceHandlerBase::forwardEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) const {
-	fdirInstance->triggerEvent(event, parameter1, parameter2);
-}
-
-void DeviceHandlerBase::doOffActivity() {
-}
-
-ReturnValue_t DeviceHandlerBase::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = fdirInstance->getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	return INVALID_DOMAIN_ID;
-
-}
-
-bool DeviceHandlerBase::isTransitionalMode() {
-	return ((mode
-			& (TRANSITION_MODE_BASE_ACTION_MASK
-					| TRANSITION_MODE_CHILD_ACTION_MASK)) != 0);
-}
-
-bool DeviceHandlerBase::commandIsExecuting(DeviceCommandId_t commandId) {
-	auto iter = deviceCommandMap.find(commandId);
-	if (iter != deviceCommandMap.end()) {
-		return iter->second.isExecuting;
-	} else {
-		return false;
-	}
-
-}
-
-void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
-}
-
-void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
-	executingTask = task_;
-}
-
-// Default implementations empty.
-void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
-		object_id_t objectId, uint32_t parameter) {}
-
-void DeviceHandlerBase::performOperationHook() {
-}
-
-ReturnValue_t DeviceHandlerBase::initializePoolEntries(
-		LocalDataPool &localDataPoolMap) {
-	return RETURN_OK;
-}
-
-LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
-	return &hkManager;
-}
-
-
-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;
-}
-
-DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
-	auto iter = deviceReplyMap.find(sid.ownerSetId);
-	if(iter != deviceReplyMap.end()) {
-		return iter->second.dataSet;
-	}
-	else {
-		return nullptr;
-	}
-}
+#include "../devicehandlers/DeviceHandlerBase.h"
+#include "../objectmanager/ObjectManager.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../thermal/ThermalComponentIF.h"
+#include "../devicehandlers/AcceptsDeviceResponsesIF.h"
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../devicehandlers/DeviceTmReportingWrapper.h"
+#include "../globalfunctions/CRC.h"
+#include "../housekeeping/HousekeepingMessage.h"
+#include "../ipc/MessageQueueMessage.h"
+#include "../subsystem/SubsystemBase.h"
+#include "../ipc/QueueFactory.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+#include <iomanip>
+
+object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::defaultHkDestination = objects::NO_OBJECT;
+
+DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
+		object_id_t deviceCommunication, CookieIF * comCookie,
+		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
+		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
+		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
+		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
+		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
+		actionHelper(this, nullptr), hkManager(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,
+			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;
+	}
+	if (this->fdirInstance == nullptr) {
+		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
+				defaultFdirParentId);
+	}
+}
+
+void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
+	this->hkDestination = hkDestination;
+}
+
+void DeviceHandlerBase::setThermalStateRequestPoolIds(
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId) {
+	this->deviceThermalRequestPoolId = thermalStatePoolId;
+	this->deviceThermalRequestPoolId = thermalRequestPoolId;
+}
+
+
+DeviceHandlerBase::~DeviceHandlerBase() {
+	delete comCookie;
+	if (defaultFDIRUsed) {
+		delete fdirInstance;
+	}
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
+	this->pstStep = counter;
+
+	if (getComAction() == SEND_WRITE) {
+		cookieInfo.state = COOKIE_UNUSED;
+		readCommandQueue();
+		doStateMachine();
+		checkSwitchState();
+		decrementDeviceReplyMap();
+		fdirInstance->checkForFailures();
+		hkSwitcher.performOperation();
+		performOperationHook();
+	}
+	if (mode == MODE_OFF) {
+		return RETURN_OK;
+	}
+	switch (getComAction()) {
+	case SEND_WRITE:
+		if ((cookieInfo.state == COOKIE_UNUSED)) {
+			buildInternalCommand();
+		}
+		doSendWrite();
+		break;
+	case GET_WRITE:
+		doGetWrite();
+		break;
+	case SEND_READ:
+		doSendRead();
+		break;
+	case GET_READ:
+		doGetRead();
+		cookieInfo.state = COOKIE_UNUSED;
+		break;
+	default:
+		break;
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t DeviceHandlerBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	communicationInterface = objectManager->get<DeviceCommunicationIF>(
+			deviceCommunicationId);
+	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);
+	if (result != RETURN_OK) {
+	    sif::error << "DeviceHandlerBase::initialize: Initializing "
+	            "communication interface failed!" << std::endl;
+	    return result;
+	}
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (IPCStore == nullptr) {
+		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
+				"factory." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	if(rawDataReceiverId != objects::NO_OBJECT) {
+		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
+				AcceptsDeviceResponsesIF>(rawDataReceiverId);
+
+		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();
+	}
+
+	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;
+	}
+
+	result = modeHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = actionHelper.initialize(commandQueue);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = fdirInstance->initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = hkSwitcher.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	if(hkDestination == objects::NO_OBJECT) {
+		hkDestination = defaultHkDestination;
+	}
+
+	result = hkManager.initialize(commandQueue, hkDestination);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	fillCommandAndReplyMap();
+
+	//Set temperature target state to NON_OP.
+	GlobDataSet mySet;
+	gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+			PoolVariableIF::VAR_WRITE);
+	mySet.read();
+	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+	mySet.commit(PoolVariableIF::VALID);
+
+	return RETURN_OK;
+
+}
+
+void DeviceHandlerBase::decrementDeviceReplyMap() {
+	for (std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
+			deviceReplyMap.begin(); iter != deviceReplyMap.end(); iter++) {
+		if (iter->second.delayCycles != 0) {
+			iter->second.delayCycles--;
+			if (iter->second.delayCycles == 0) {
+				if (iter->second.periodic) {
+					iter->second.delayCycles = iter->second.maxDelayCycles;
+				}
+				replyToReply(iter, TIMEOUT);
+				missedReply(iter->first);
+			}
+		}
+	}
+}
+
+void DeviceHandlerBase::readCommandQueue() {
+
+	if (dontCheckQueue()) {
+		return;
+	}
+
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != RETURN_OK) {
+		return;
+	}
+
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == RETURN_OK) {
+	    return;
+	}
+
+	result = modeHelper.handleModeCommand(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
+
+	result = actionHelper.handleActionMessage(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
+
+	result = parameterHelper.handleParameterMessage(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
+
+	result = hkManager.handleHousekeepingMessage(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
+
+	result = handleDeviceHandlerMessage(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
+
+	result = letChildHandleMessage(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
+
+	replyReturnvalueToCommand(CommandMessage::UNKNOWN_COMMAND);
+
+}
+
+void DeviceHandlerBase::doStateMachine() {
+	switch (mode) {
+	case _MODE_START_UP:
+	case _MODE_SHUT_DOWN:
+	case _MODE_TO_NORMAL:
+	case _MODE_TO_ON:
+	case _MODE_TO_RAW: {
+		Mode_t currentMode = mode;
+		callChildStatemachine();
+		//Only do timeout if child did not change anything
+		if (mode != currentMode) {
+			break;
+		}
+		uint32_t currentUptime;
+		Clock::getUptime(&currentUptime);
+		if (currentUptime - timeoutStart >= childTransitionDelay) {
+			triggerEvent(MODE_TRANSITION_FAILED, childTransitionFailure, 0);
+			setMode(transitionSourceMode, transitionSourceSubMode);
+			break;
+		}
+	}
+		break;
+	case _MODE_POWER_DOWN:
+		commandSwitch(PowerSwitchIF::SWITCH_OFF);
+		setMode(_MODE_WAIT_OFF);
+		break;
+	case _MODE_POWER_ON:
+		commandSwitch(PowerSwitchIF::SWITCH_ON);
+		setMode(_MODE_WAIT_ON);
+		break;
+	case _MODE_WAIT_ON: {
+		uint32_t currentUptime;
+		Clock::getUptime(&currentUptime);
+		if (powerSwitcher != nullptr and currentUptime - timeoutStart >=
+				powerSwitcher->getSwitchDelayMs()) {
+			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
+					0);
+			setMode(_MODE_POWER_DOWN);
+			callChildStatemachine();
+			break;
+		}
+		ReturnValue_t switchState = getStateOfSwitches();
+		if ((switchState == PowerSwitchIF::SWITCH_ON)
+				|| (switchState == NO_SWITCH)) {
+			//NOTE: TransitionSourceMode and -SubMode are set by handleCommandedModeTransition
+			childTransitionFailure = CHILD_TIMEOUT;
+			setMode(_MODE_START_UP);
+			callChildStatemachine();
+		}
+	}
+		break;
+	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);
+			setMode(MODE_ERROR_ON);
+			break;
+		}
+		ReturnValue_t switchState = getStateOfSwitches();
+		if ((switchState == PowerSwitchIF::SWITCH_OFF)
+				|| (switchState == NO_SWITCH)) {
+			setMode(_MODE_SWITCH_IS_OFF);
+		}
+	}
+		break;
+	case MODE_OFF:
+		doOffActivity();
+		break;
+	case MODE_ON:
+		doOnActivity();
+		break;
+	case MODE_RAW:
+	case MODE_NORMAL:
+	case MODE_ERROR_ON:
+		break;
+	case _MODE_SWITCH_IS_OFF:
+		setMode(MODE_OFF, SUBMODE_NONE);
+		break;
+	default:
+		triggerEvent(OBJECT_IN_INVALID_MODE, mode, submode);
+		setMode(_MODE_POWER_DOWN, 0);
+		break;
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
+		Submode_t submode) {
+	switch (mode) {
+	case MODE_OFF:
+	case MODE_ON:
+	case MODE_NORMAL:
+	case MODE_RAW:
+		if (submode == SUBMODE_NONE) {
+			return RETURN_OK;
+		} else {
+			return INVALID_SUBMODE;
+		}
+	default:
+		return HasModesIF::INVALID_MODE;
+	}
+}
+
+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) {
+		return insertInReplyMap(replyId, maxDelayCycles, replyLen, periodic);
+	} else {
+		return insertInReplyMap(deviceCommand, maxDelayCycles, replyLen, periodic);
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
+		uint16_t maxDelayCycles, size_t replyLen, bool periodic) {
+	DeviceReplyInfo info;
+	info.maxDelayCycles = maxDelayCycles;
+	info.periodic = periodic;
+	info.delayCycles = 0;
+	info.replyLen = replyLen;
+	info.command = deviceCommandMap.end();
+	auto resultPair = deviceReplyMap.emplace(replyId, info);
+	if (resultPair.second) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::insertInCommandMap(
+		DeviceCommandId_t deviceCommand) {
+	DeviceCommandInfo info;
+	info.expectedReplies = 0;
+	info.isExecuting = false;
+	info.sendReplyTo = NO_COMMANDER;
+	auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
+	if (resultPair.second) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
+		uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
+	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
+			deviceReplyMap.find(deviceReply);
+	if (iter == deviceReplyMap.end()) {
+		triggerEvent(INVALID_DEVICE_COMMAND, deviceReply);
+		return RETURN_FAILED;
+	} else {
+		DeviceReplyInfo *info = &(iter->second);
+		if (maxDelayCycles != 0) {
+			info->maxDelayCycles = maxDelayCycles;
+		}
+		info->delayCycles = delayCycles;
+		info->periodic = periodic;
+		return RETURN_OK;
+	}
+}
+
+void DeviceHandlerBase::callChildStatemachine() {
+	if (mode == _MODE_START_UP) {
+		doStartUp();
+	} else if (mode == _MODE_SHUT_DOWN) {
+		doShutDown();
+	} else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
+		doTransition(transitionSourceMode, transitionSourceSubMode);
+	}
+}
+
+void DeviceHandlerBase::setTransition(Mode_t modeTo, Submode_t submodeTo) {
+	triggerEvent(CHANGING_MODE, modeTo, submodeTo);
+	childTransitionDelay = getTransitionDelayMs(mode, modeTo);
+	transitionSourceMode = mode;
+	transitionSourceSubMode = submode;
+	childTransitionFailure = CHILD_TIMEOUT;
+
+	// transitionTargetMode is set by setMode
+	setMode((modeTo | TRANSITION_MODE_CHILD_ACTION_MASK), submodeTo);
+}
+
+void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
+	changeHK(mode, submode, false);
+	submode = newSubmode;
+	mode = newMode;
+	modeChanged();
+	setNormalDatapoolEntriesInvalid();
+	if (!isTransitionalMode()) {
+		modeHelper.modeChanged(newMode, newSubmode);
+		announceMode(false);
+	}
+	Clock::getUptime(&timeoutStart);
+
+	if (mode == MODE_OFF) {
+		GlobDataSet mySet;
+		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+				PoolVariableIF::VAR_READ_WRITE);
+		mySet.read();
+		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
+			thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+		}
+		mySet.commit(PoolVariableIF::VALID);
+	}
+	changeHK(mode, submode, true);
+}
+
+void DeviceHandlerBase::setMode(Mode_t newMode) {
+	setMode(newMode, submode);
+}
+
+void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
+		uint32_t parameter) {
+	//This is actually the reply protocol for raw and misc DH commands.
+	if (status == RETURN_OK) {
+		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, parameter);
+		commandQueue->reply(&reply);
+	} else {
+		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, parameter);
+		commandQueue->reply(&reply);
+	}
+}
+
+void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
+		uint32_t parameter) {
+//Check if we reply to a raw command.
+	if (cookieInfo.pendingCommand->first == RAW_COMMAND_ID) {
+		if (status == NO_REPLY_EXPECTED) {
+			status = RETURN_OK;
+		}
+		replyReturnvalueToCommand(status, parameter);
+		//Always delete data from a raw command.
+		IPCStore->deleteData(storedRawData);
+		return;
+	}
+//Check if we were externally commanded.
+	if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
+		MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
+		if (status == NO_REPLY_EXPECTED) {
+			actionHelper.finish(queueId, cookieInfo.pendingCommand->first,
+					RETURN_OK);
+		} else {
+			actionHelper.step(1, queueId, cookieInfo.pendingCommand->first,
+					status);
+		}
+	}
+}
+
+void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
+		ReturnValue_t status) {
+//No need to check if iter exists, as this is checked by callers. If someone else uses the method, add check.
+	if (iter->second.command == deviceCommandMap.end()) {
+		//Is most likely periodic reply. Silent return.
+		return;
+	}
+//Check if more replies are expected. If so, do nothing.
+	DeviceCommandInfo* info = &(iter->second.command->second);
+	if (--info->expectedReplies == 0) {
+		//Check if it was transition or internal command. Don't send any replies in that case.
+		if (info->sendReplyTo != NO_COMMANDER) {
+			actionHelper.finish(info->sendReplyTo, iter->first, status);
+		}
+		info->isExecuting = false;
+	}
+}
+
+void DeviceHandlerBase::doSendWrite() {
+	if (cookieInfo.state == COOKIE_WRITE_READY) {
+
+		ReturnValue_t result = communicationInterface->sendMessage(comCookie,
+				rawPacket, rawPacketLen);
+
+		if (result == RETURN_OK) {
+			cookieInfo.state = COOKIE_WRITE_SENT;
+		} else {
+			//always generate a failure event, so that FDIR knows what's up
+			triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
+					cookieInfo.pendingCommand->first);
+			replyToCommand(result);
+			cookieInfo.state = COOKIE_UNUSED;
+			cookieInfo.pendingCommand->second.isExecuting = false;
+		}
+	}
+}
+
+void DeviceHandlerBase::doGetWrite() {
+	if (cookieInfo.state != COOKIE_WRITE_SENT) {
+		return;
+	}
+	cookieInfo.state = COOKIE_UNUSED;
+	ReturnValue_t result = communicationInterface->getSendSuccess(comCookie);
+	if (result == RETURN_OK) {
+		if (wiretappingMode == RAW) {
+			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
+		}
+
+		//We need to distinguish here, because a raw command never expects a reply.
+		//(Could be done in eRIRM, but then child implementations need to be careful.
+		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
+	} else {
+		//always generate a failure event, so that FDIR knows what's up
+		triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
+				cookieInfo.pendingCommand->first);
+	}
+	if (result != RETURN_OK) {
+		cookieInfo.pendingCommand->second.isExecuting = false;
+	}
+	replyToCommand(result);
+}
+
+void DeviceHandlerBase::doSendRead() {
+	ReturnValue_t result;
+
+	size_t requestLen = 0;
+	if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
+		DeviceReplyIter iter = deviceReplyMap.find(
+				cookieInfo.pendingCommand->first);
+		if(iter != deviceReplyMap.end()) {
+			requestLen = iter->second.replyLen;
+		}
+	}
+
+	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
+
+	if (result == RETURN_OK) {
+		cookieInfo.state = COOKIE_READ_SENT;
+	} else {
+		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
+		//We can't inform anyone, because we don't know which command was sent last.
+		//So, we need to wait for a timeout.
+		//but I think we can allow to ignore one missedReply.
+		ignoreMissedRepliesCount++;
+		cookieInfo.state = COOKIE_UNUSED;
+	}
+}
+
+void DeviceHandlerBase::doGetRead() {
+	size_t receivedDataLen = 0;
+	uint8_t *receivedData = nullptr;
+
+	if (cookieInfo.state != COOKIE_READ_SENT) {
+		cookieInfo.state = COOKIE_UNUSED;
+		return;
+	}
+
+	cookieInfo.state = COOKIE_UNUSED;
+
+	ReturnValue_t result = communicationInterface->readReceivedMessage(
+			comCookie, &receivedData, &receivedDataLen);
+
+	if (result != RETURN_OK) {
+		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
+		//I think we can allow to ignore one missedReply.
+		ignoreMissedRepliesCount++;
+		return;
+	}
+
+	if (receivedDataLen == 0 or result == DeviceCommunicationIF::NO_REPLY_RECEIVED)
+		return;
+
+	if (wiretappingMode == RAW) {
+		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
+	}
+
+	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
+		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
+	}
+	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);
+			if(foundLen == 0) {
+			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+			            " Packet parsing will be stuck." << std::endl;
+			}
+			break;
+		case APERIODIC_REPLY: {
+			result = interpretDeviceReply(foundId, receivedData);
+			if (result != RETURN_OK) {
+			    replyRawReplyIfnotWiretapped(receivedData, foundLen);
+			    triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
+			            foundId);
+			}
+			if(foundLen == 0) {
+			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+			            " Packet parsing will be stuck." << std::endl;
+			}
+			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) {
+	size_t lenTmp;
+
+	if (IPCStore == nullptr) {
+		*data = nullptr;
+		*len = 0;
+		return RETURN_FAILED;
+	}
+	ReturnValue_t result = IPCStore->modifyData(storageAddress, data, &lenTmp);
+	if (result == RETURN_OK) {
+		*len = lenTmp;
+		return RETURN_OK;
+	} else {
+		triggerEvent(StorageManagerIF::GET_DATA_FAILED, result,
+				storageAddress.raw);
+		*data = nullptr;
+		*len = 0;
+		return result;
+	}
+}
+
+void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
+		MessageQueueId_t sendTo, bool isCommand) {
+	if (IPCStore == nullptr or len == 0 or sendTo == MessageQueueIF::NO_QUEUE) {
+		return;
+	}
+	store_address_t address;
+	ReturnValue_t result = IPCStore->addData(&address, data, len);
+
+	if (result != RETURN_OK) {
+		triggerEvent(StorageManagerIF::STORE_DATA_FAILED, result);
+		return;
+	}
+
+	CommandMessage command;
+
+	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
+			getObjectId(), address, isCommand);
+
+	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.
+	}
+}
+
+//Default child implementations
+DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
+	switch (pstStep) {
+	case 0:
+		return SEND_WRITE;
+		break;
+	case 1:
+		return GET_WRITE;
+		break;
+	case 2:
+		return SEND_READ;
+		break;
+	case 3:
+		return GET_READ;
+		break;
+	default:
+		break;
+	}
+	return NOTHING;
+}
+
+MessageQueueId_t DeviceHandlerBase::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
+	storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
+	ReturnValue_t result = getStorageData(storedRawData, &rawPacket,
+			&rawPacketLen);
+	if (result != RETURN_OK) {
+		replyReturnvalueToCommand(result, RAW_COMMAND_ID);
+		storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
+	} else {
+		cookieInfo.pendingCommand = deviceCommandMap.find(
+				(DeviceCommandId_t) RAW_COMMAND_ID);
+		cookieInfo.pendingCommand->second.isExecuting = true;
+		cookieInfo.state = COOKIE_WRITE_READY;
+	}
+}
+
+void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
+	if(powerSwitcher == nullptr) {
+		return;
+	}
+	const uint8_t *switches;
+	uint8_t numberOfSwitches = 0;
+	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
+	if (result == RETURN_OK) {
+		while (numberOfSwitches > 0) {
+			powerSwitcher->sendSwitchCommand(switches[numberOfSwitches - 1],
+					onOff);
+			numberOfSwitches--;
+		}
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::getSwitches(const uint8_t **switches,
+		uint8_t *numberOfSwitches) {
+	return DeviceHandlerBase::NO_SWITCH;
+}
+
+void DeviceHandlerBase::modeChanged(void) {
+}
+
+ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
+		DeviceCommandMap::iterator command, uint8_t expectedReplies,
+		bool useAlternativeId, DeviceCommandId_t alternativeReply) {
+	DeviceReplyMap::iterator iter;
+	if (useAlternativeId) {
+		iter = deviceReplyMap.find(alternativeReply);
+	} else {
+		iter = deviceReplyMap.find(command->first);
+	}
+	if (iter != deviceReplyMap.end()) {
+		DeviceReplyInfo *info = &(iter->second);
+		info->delayCycles = info->maxDelayCycles;
+		info->command = command;
+		command->second.expectedReplies = expectedReplies;
+		return RETURN_OK;
+	} else {
+		return NO_REPLY_EXPECTED;
+	}
+}
+
+void DeviceHandlerBase::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
+	setMode(getBaseMode(mode));
+}
+
+uint32_t DeviceHandlerBase::getTransitionDelayMs(Mode_t modeFrom,
+		Mode_t modeTo) {
+	return 0;
+}
+
+ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
+	if(powerSwitcher == nullptr) {
+		return NO_SWITCH;
+	}
+	uint8_t numberOfSwitches = 0;
+	const uint8_t *switches;
+
+	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
+	if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
+		while (numberOfSwitches > 0) {
+			if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1])
+					== PowerSwitchIF::SWITCH_OFF) {
+				return PowerSwitchIF::SWITCH_OFF;
+			}
+			numberOfSwitches--;
+		}
+		return PowerSwitchIF::SWITCH_ON;
+	}
+
+	return NO_SWITCH;
+}
+
+Mode_t DeviceHandlerBase::getBaseMode(Mode_t transitionMode) {
+//only child action special modes are handled, as a child should never see any base action modes
+	if (transitionMode == _MODE_START_UP) {
+		return _MODE_TO_ON;
+	}
+	if (transitionMode == _MODE_SHUT_DOWN) {
+		return _MODE_POWER_DOWN;
+	}
+	return transitionMode
+			& ~(TRANSITION_MODE_BASE_ACTION_MASK
+					| TRANSITION_MODE_CHILD_ACTION_MASK);
+}
+
+//SHOULDDO: Allow transition from OFF to NORMAL to reduce complexity in assemblies. And, by the way, throw away DHB and write a new one:
+// - Include power and thermal completely, but more modular :-)
+// - Don't use modes for state transitions, reduce FSM (Finte State Machine) complexity.
+// - Modularization?
+ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
+		Submode_t commandedSubmode, uint32_t* msToReachTheMode) {
+	if (isTransitionalMode()) {
+		return IN_TRANSITION;
+	}
+	if ((mode == MODE_ERROR_ON) && (commandedMode != MODE_OFF)) {
+		return TRANS_NOT_ALLOWED;
+	}
+	if ((commandedMode == MODE_NORMAL) && (mode == MODE_OFF)) {
+		return TRANS_NOT_ALLOWED;
+	}
+
+	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
+			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)) {
+		GlobDataSet mySet;
+		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
+				PoolVariableIF::VAR_READ);
+		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+				PoolVariableIF::VAR_READ);
+		mySet.read();
+		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
+			if (!ThermalComponentIF::isOperational(thermalState)) {
+				triggerEvent(ThermalComponentIF::TEMP_NOT_IN_OP_RANGE,
+						thermalState);
+				return NON_OP_TEMPERATURE;
+			}
+		}
+	}
+
+	return isModeCombinationValid(commandedMode, commandedSubmode);
+}
+
+void DeviceHandlerBase::startTransition(Mode_t commandedMode,
+		Submode_t commandedSubmode) {
+	switch (commandedMode) {
+	case MODE_ON:
+		if (mode == MODE_OFF) {
+			transitionSourceMode = _MODE_POWER_DOWN;
+			transitionSourceSubMode = SUBMODE_NONE;
+			setMode(_MODE_POWER_ON, commandedSubmode);
+			//already set the delay for the child transition so we don't need to call it twice
+			childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
+					MODE_ON);
+			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
+			GlobDataSet mySet;
+			gp_int8_t thermalRequest(deviceThermalRequestPoolId,
+					&mySet, PoolVariableIF::VAR_READ_WRITE);
+			mySet.read();
+			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
+				thermalRequest = ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
+				mySet.commit(PoolVariableIF::VALID);
+			}
+		} else {
+			setTransition(MODE_ON, commandedSubmode);
+		}
+		break;
+	case MODE_OFF:
+		if (mode == MODE_OFF) {
+			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
+			setMode(_MODE_POWER_DOWN, commandedSubmode);
+		} else {
+			//already set the delay for the child transition so we don't need to call it twice
+			childTransitionDelay = getTransitionDelayMs(mode, _MODE_POWER_DOWN);
+			transitionSourceMode = _MODE_POWER_DOWN;
+			transitionSourceSubMode = commandedSubmode;
+			childTransitionFailure = CHILD_TIMEOUT;
+			setMode(_MODE_SHUT_DOWN, commandedSubmode);
+			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
+		}
+		break;
+	case MODE_RAW:
+		if (mode != MODE_OFF) {
+			setTransition(MODE_RAW, commandedSubmode);
+		} else {
+			setMode(MODE_RAW, commandedSubmode);
+		}
+		break;
+	case MODE_NORMAL:
+		if (mode != MODE_OFF) {
+			setTransition(MODE_NORMAL, commandedSubmode);
+		} else {
+			replyReturnvalueToCommand(HasModesIF::TRANS_NOT_ALLOWED);
+		}
+		break;
+	}
+}
+
+void DeviceHandlerBase::getMode(Mode_t* mode, Submode_t* submode) {
+	*mode = this->mode;
+	*submode = this->submode;
+}
+
+void DeviceHandlerBase::setToExternalControl() {
+	healthHelper.setHealth(EXTERNAL_CONTROL);
+}
+
+void DeviceHandlerBase::announceMode(bool recursive) {
+	triggerEvent(MODE_INFO, mode, submode);
+}
+
+bool DeviceHandlerBase::dontCheckQueue() {
+	return false;
+}
+
+void DeviceHandlerBase::missedReply(DeviceCommandId_t id) {
+	if (ignoreMissedRepliesCount > 0) {
+		ignoreMissedRepliesCount--;
+	} else {
+		triggerEvent(DEVICE_MISSED_REPLY, id);
+	}
+}
+
+HasHealthIF::HealthState DeviceHandlerBase::getHealth() {
+	return healthHelper.getHealth();
+}
+
+ReturnValue_t DeviceHandlerBase::setHealth(HealthState health) {
+    healthHelper.setHealth(health);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void DeviceHandlerBase::checkSwitchState() {
+	if ((mode == MODE_ON || mode == MODE_NORMAL)) {
+		//We only check in ON and NORMAL, ignore RAW and ERROR_ON.
+		ReturnValue_t result = getStateOfSwitches();
+		if (result == PowerSwitchIF::SWITCH_OFF && !switchOffWasReported) {
+			triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
+			switchOffWasReported = true;
+		}
+	} else {
+		switchOffWasReported = false;
+	}
+}
+
+void DeviceHandlerBase::doOnActivity() {
+}
+
+ReturnValue_t DeviceHandlerBase::acceptExternalDeviceCommands() {
+	if ((mode != MODE_ON) && (mode != MODE_NORMAL)) {
+		return WRONG_MODE_FOR_COMMAND;
+	}
+	return RETURN_OK;
+}
+
+void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
+		size_t len) {
+	if ((wiretappingMode == RAW)
+			&& (defaultRawReceiver == requestedRawTraffic)) {
+		//The raw packet was already sent by the wiretapping service
+	} else {
+		replyRawData(data, len, defaultRawReceiver);
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
+		CommandMessage * message) {
+	switch (message->getCommand()) {
+	case DeviceHandlerMessage::CMD_WIRETAPPING:
+		switch (DeviceHandlerMessage::getWiretappingMode(message)) {
+		case RAW:
+			wiretappingMode = RAW;
+			requestedRawTraffic = commandQueue->getLastPartner();
+			break;
+		case TM:
+			wiretappingMode = TM;
+			requestedRawTraffic = commandQueue->getLastPartner();
+			break;
+		case OFF:
+			wiretappingMode = OFF;
+			break;
+		default:
+			replyReturnvalueToCommand(INVALID_COMMAND_PARAMETER);
+			wiretappingMode = OFF;
+			return RETURN_OK;
+		}
+		replyReturnvalueToCommand(RETURN_OK);
+		return RETURN_OK;
+//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
+//		if (mode != MODE_OFF) {
+//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
+//		} else {
+//			result = switchCookieChannel(
+//					DeviceHandlerMessage::getIoBoardObjectId(message));
+//			if (result == RETURN_OK) {
+//				replyReturnvalueToCommand(RETURN_OK);
+//			} else {
+//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
+//			}
+//		}
+//		return RETURN_OK;
+	case DeviceHandlerMessage::CMD_RAW:
+		if ((mode != MODE_RAW)) {
+			DeviceHandlerMessage::clear(message);
+			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
+		} else {
+			buildRawDeviceCommand(message);
+		}
+		return RETURN_OK;
+	default:
+		return RETURN_FAILED;
+	}
+}
+
+void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
+	modeHelper.setParentQueue(parentQueueId);
+	healthHelper.setParentQueue(parentQueueId);
+}
+
+bool DeviceHandlerBase::isAwaitingReply() {
+	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter;
+	for (iter = deviceReplyMap.begin(); iter != deviceReplyMap.end(); ++iter) {
+		if (iter->second.delayCycles != 0) {
+			return true;
+		}
+	}
+	return false;
+}
+
+ReturnValue_t DeviceHandlerBase::letChildHandleMessage(
+		CommandMessage * message) {
+	return RETURN_FAILED;
+}
+
+void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
+		DeviceCommandId_t replyId, bool neverInDataPool, bool forceDirectTm) {
+	DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
+	if (iter == deviceReplyMap.end()) {
+		triggerEvent(DEVICE_UNKNOWN_REPLY, replyId);
+		return;
+	}
+	DeviceTmReportingWrapper wrapper(getObjectId(), replyId, data);
+	//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 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);
+		}
+	}
+	//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) {
+		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
+		if (dataSet != NULL) {
+			dataSet->commit(PoolVariableIF::VALID);
+		}
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
+	ReturnValue_t result = acceptExternalDeviceCommands();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
+	if (iter == deviceCommandMap.end()) {
+		result = COMMAND_NOT_SUPPORTED;
+	} else if (iter->second.isExecuting) {
+		result = COMMAND_ALREADY_SENT;
+	} else {
+		result = buildCommandFromCommand(actionId, data, size);
+	}
+	if (result == RETURN_OK) {
+		iter->second.sendReplyTo = commandedBy;
+		iter->second.isExecuting = true;
+		cookieInfo.pendingCommand = iter;
+		cookieInfo.state = COOKIE_WRITE_READY;
+	}
+	return result;
+}
+
+void DeviceHandlerBase::buildInternalCommand(void) {
+//Neither Raw nor Direct could build a command
+	ReturnValue_t result = NOTHING_TO_SEND;
+	DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
+	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;
+			result = NOTHING_TO_SEND; //no need to report this
+		}
+	}
+	else if (mode == MODE_RAW) {
+		result = buildChildRawCommand();
+		deviceCommandId = RAW_COMMAND_ID;
+	}
+	else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
+		result = buildTransitionDeviceCommand(&deviceCommandId);
+	}
+	else {
+		return;
+	}
+
+	if (result == NOTHING_TO_SEND) {
+		return;
+	}
+	if (result == RETURN_OK) {
+		DeviceCommandMap::iterator iter = deviceCommandMap.find(
+				deviceCommandId);
+		if (iter == deviceCommandMap.end()) {
+			result = COMMAND_NOT_SUPPORTED;
+		} else if (iter->second.isExecuting) {
+			sif::debug << std::hex << getObjectId()
+					<< ": DHB::buildInternalCommand: Command "
+					<< deviceCommandId << " isExecuting" << std::endl; //so we can track misconfigurations
+			return; //this is an internal command, no need to report a failure here, missed reply will track if a reply is too late, otherwise, it's ok
+		} else {
+			iter->second.sendReplyTo = NO_COMMANDER;
+			iter->second.isExecuting = true;
+			cookieInfo.pendingCommand = iter;
+			cookieInfo.state = COOKIE_WRITE_READY;
+		}
+	}
+	if (result != RETURN_OK) {
+		triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::buildChildRawCommand() {
+	return NOTHING_TO_SEND;
+}
+
+uint8_t DeviceHandlerBase::getReplyDelayCycles(
+		DeviceCommandId_t deviceCommand) {
+	DeviceReplyMap::iterator iter = deviceReplyMap.find(deviceCommand);
+	if (iter == deviceReplyMap.end()) {
+		return 0;
+	}
+	return iter->second.delayCycles;
+}
+
+Mode_t DeviceHandlerBase::getTransitionSourceMode() const {
+	return transitionSourceMode;
+}
+
+Submode_t DeviceHandlerBase::getTransitionSourceSubMode() const {
+	return transitionSourceSubMode;
+}
+
+void DeviceHandlerBase::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	fdirInstance->triggerEvent(event, parameter1, parameter2);
+}
+
+void DeviceHandlerBase::forwardEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) const {
+	fdirInstance->triggerEvent(event, parameter1, parameter2);
+}
+
+void DeviceHandlerBase::doOffActivity() {
+}
+
+ReturnValue_t DeviceHandlerBase::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	ReturnValue_t result = fdirInstance->getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	return INVALID_DOMAIN_ID;
+
+}
+
+bool DeviceHandlerBase::isTransitionalMode() {
+	return ((mode
+			& (TRANSITION_MODE_BASE_ACTION_MASK
+					| TRANSITION_MODE_CHILD_ACTION_MASK)) != 0);
+}
+
+bool DeviceHandlerBase::commandIsExecuting(DeviceCommandId_t commandId) {
+	auto iter = deviceCommandMap.find(commandId);
+	if (iter != deviceCommandMap.end()) {
+		return iter->second.isExecuting;
+	} else {
+		return false;
+	}
+
+}
+
+void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
+}
+
+void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
+	executingTask = task_;
+}
+
+// Default implementations empty.
+void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
+		object_id_t objectId, uint32_t parameter) {}
+
+void DeviceHandlerBase::performOperationHook() {
+}
+
+ReturnValue_t DeviceHandlerBase::initializePoolEntries(
+		LocalDataPool &localDataPoolMap) {
+	return RETURN_OK;
+}
+
+LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
+	return &hkManager;
+}
+
+
+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;
+}
+
+DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
+	auto iter = deviceReplyMap.find(sid.ownerSetId);
+	if(iter != deviceReplyMap.end()) {
+		return iter->second.dataSet;
+	}
+	else {
+		return nullptr;
+	}
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 632db5e09..7add48e46 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,1207 +1,1207 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
-#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/devicehandlers/DeviceCommunicationIF.h>
-#include <framework/modes/HasModesIF.h>
-#include <framework/power/PowerSwitchIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
-
-#include <framework/action/ActionHelper.h>
-#include <framework/health/HealthHelper.h>
-#include <framework/parameters/ParameterHelper.h>
-#include <framework/datapool/HkSwitchHelper.h>
-#include <framework/datapoollocal/HasLocalDataPoolIF.h>
-#include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include <map>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-class StorageManagerIF;
-
-/**
- * @defgroup devices Devices
- * Contains all devices and the DeviceHandlerBase class.
- */
-
-/**
- * @brief This is the abstract base class for device handlers.
- * @details
- * Documentation: Dissertation Baetz p.138,139, p.141-149
- *
- * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink,
- * communication with physical devices, using the @link DeviceCommunicationIF @endlink,
- * and communication with commanding objects.
- * It inherits SystemObject and thus can be created by the ObjectManagerIF.
- *
- * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
- * For each step an RMAP action is selected and executed.
- * 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.
- * 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).
- * The following abstract methods must be implemented by a device handler:
- *  1. doStartUp()
- *  2. doShutDown()
- *  3. buildTransitionDeviceCommand()
- *  4. buildNormalDeviceCommand()
- *  5. buildCommandFromCommand()
- *  6. fillCommandAndReplyMap()
- *  7. scanForReply()
- *  8. interpretDeviceReply()
- *
- * Other important virtual methods with a default implementation
- * are the getTransitionDelayMs() function and the getSwitches() function.
- * Please ensure that getSwitches() returns DeviceHandlerIF::NO_SWITCHES if
- * power switches are not implemented yet. Otherwise, the device handler will
- * not transition to MODE_ON, even if setMode(MODE_ON) is called.
- * If a transition to MODE_ON is desired without commanding, override the
- * intialize() function and call setMode(_MODE_START_UP) before calling
- * DeviceHandlerBase::initialize().
- *
- * @ingroup devices
- */
-class DeviceHandlerBase: public DeviceHandlerIF,
-		public HasReturnvaluesIF,
-		public ExecutableObjectIF,
-		public SystemObject,
-		public HasModesIF,
-		public HasHealthIF,
-		public HasActionsIF,
-		public ReceivesParameterMessagesIF,
-		public HasLocalDataPoolIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	/**
-	 * The constructor passes the objectId to the SystemObject().
-	 *
-	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
-	 * @param setDeviceSwitch the switch the device is connected to,
-	 * for devices using two switches, overwrite getSwitches()
-	 * @param deviceCommuncation Communcation Interface object which is used
-	 * to implement communication functions
-	 * @param thermalStatePoolId
-	 * @param thermalRequestPoolId
-	 * @param fdirInstance
-	 * @param cmdQueueSize
-	 */
-	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * comCookie, FailureIsolationBase* fdirInstance = nullptr,
-			size_t cmdQueueSize = 20);
-
-	void setHkDestination(object_id_t hkDestination);
-	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId);
-
-	/**
-	 * @brief 	This function is the device handler base core component and is
-	 * 			called periodically.
-	 * @details
-	 * General sequence, showing where abstract virtual functions are called:
-	 * If the State is SEND_WRITE:
-	 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
-	 *   2. Handles Device State Modes by calling doStateMachine().
-	 *      This function calls callChildStatemachine() which calls the
-	 *      abstract functions doStartUp() and doShutDown()
-	 *   3. Check switch states by calling checkSwitchStates()
-	 *   4. Decrements counter for timeout of replies by calling
-	 *      decrementDeviceReplyMap()
-	 *   5. Performs FDIR check for failures
-	 *   6. Calls hkSwitcher.performOperation()
-	 *   7. If the device mode is MODE_OFF, return RETURN_OK.
-     *      Otherwise, perform the Action property and performs depending
-     *      on value specified by input value counter (incremented in PST).
-     *      The child class tells base class what to do by setting this value.
-	 *     - SEND_WRITE: Send data or commands to device by calling
-	 *       doSendWrite() which calls sendMessage function
-	 *       of #communicationInterface
-	 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
-	 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite()
-	 *       which calls getSendSuccess of #communicationInterface.
-	 *       Calls abstract functions scanForReply() and interpretDeviceReply().
-	 *     - SEND_READ: Request reading data from device by calling doSendRead()
-	 *       which calls requestReceiveMessage of #communcationInterface
-	 *     - GET_READ: Access requested reading data by calling doGetRead()
-	 *       which calls readReceivedMessage of #communicationInterface
-	 * @param counter Specifies which Action to perform
-	 * @return RETURN_OK for successful execution
-	 */
-	virtual ReturnValue_t performOperation(uint8_t counter);
-
-	/**
-	 * @brief  Initializes the device handler
-	 * @details
-	 * Initialize Device Handler as system object and
-	 * initializes all important helper classes.
-	 * Calls fillCommandAndReplyMap().
-	 * @return
-	 */
-	virtual ReturnValue_t initialize();
-	/** Destructor. */
-	virtual ~DeviceHandlerBase();
-
-protected:
-	/**
-	 * @brief 	This is used to let the child class handle the transition from
-	 * 			mode @c _MODE_START_UP to @c MODE_ON
-	 * @details
-	 * It is only called when the device handler is in mode @c _MODE_START_UP.
-	 * That means, the device switch(es) are already set to on.
-	 * Device handler commands are read and can be handled by the child class.
-	 * If the child class handles a command, it should also send
-	 * an reply accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE,
-	 * the base class handles rejecting the command and sends a reply.
-	 * The replies for mode transitions are handled by the base class.
-	 *
-	 *  - If the device is started and ready for operation, the mode should be
-	 *    set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
-	 *    use the to on transition if available.
-	 *  - If the power-up fails, the mode should be set to _MODE_POWER_DOWN
-	 *    which will lead to the device being powered off.
-	 *  - If the device does not change the mode, the mode will be changed
-	 *    to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay())
-	 *    has passed.
-	 *
-	 * #transitionFailure can be set to a failure code indicating the reason
-	 * for a failed transition
-	 */
-	virtual void doStartUp() = 0;
-
-	/**
-	 * @brief 	This is used to let the child class handle the transition
-	 * 			from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
-	 * @details
-	 * It is only called when the device handler is in mode @c _MODE_SHUT_DOWN.
-	 * Device handler commands are read and can be handled by the child class.
-	 * If the child class handles a command, it should also send an reply
-	 * accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not
-	 * @c CMD_NONE, the base class handles rejecting the command and sends a
-	 * reply. The replies for mode transitions are handled by the base class.
-	 *
-	 *  - If the device ready to be switched off,
-	 *    the mode should be set to _MODE_POWER_DOWN.
-	 *  - If the device should not be switched off, the mode can be changed to
-	 *     _MODE_TO_ON (or MODE_ON if no transition is needed).
-	 *  - If the device does not change the mode, the mode will be changed to
-	 *    _MODE_POWER_DOWN, when the timeout (from getTransitionDelay())
-	 *    has passed.
-	 *
-	 * #transitionFailure can be set to a failure code indicating the reason
-	 * for a failed transition
-	 */
-	virtual void doShutDown() = 0;
-
-	/**
-	 * Build the device command to send for normal mode.
-	 *
-	 * This is only called in @c MODE_NORMAL. If multiple submodes for
-	 * @c MODE_NORMAL are supported, different commands can built,
-	 * depending on the submode.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the
-	 * packet to be sent. If variable command frequence is required, a counter
-	 * can be used and the frequency in the reply map has to be set manually
-	 * by calling updateReplyMap().
-	 *
-	 * @param[out] id the device command id that has been built
-	 * @return
-	 *    - @c RETURN_OK to send command after setting #rawPacket and #rawPacketLen.
-	 *    - @c NOTHING_TO_SEND when no command is to be sent.
-	 *    - Anything else triggers an even with the returnvalue as a parameter.
-	 */
-	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
-
-	/**
-	 * 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_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
-	 * and filling them in doStartUp(), doShutDown() and doTransition() so no
-	 * modes have to be checked here.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 *
-	 * @param[out] id the device command id built
-	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - @c NOTHING_TO_SEND when no command is to be sent
-	 *    - Anything else triggers an even with the returnvalue as a parameter
-	 */
-	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
-
-	/**
-	 * @brief Build a device command packet from data supplied by a direct command.
-	 *
-	 * @details
-	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
-	 * The existence of the command in the command map and the command size check
-	 * against 0 are done by the base class.
-	 *
-	 * @param deviceCommand the command to build, already checked against deviceCommandMap
-	 * @param commandData pointer to the data from the direct command
-	 * @param commandDataLen length of commandData
-	 * @return
-	 *     - @c RETURN_OK to send command after #rawPacket and #rawPacketLen have been set.
-	 *     - Anything else triggers an event with the returnvalue as a parameter
-	 */
-	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-			const uint8_t * commandData, size_t commandDataLen) = 0;
-
-	/**
-	 * @brief Scans a buffer for a valid reply.
-	 * @details
-	 * This is used by the base class to check the data received for valid packets.
-	 * It only checks if a valid packet starts at @c start.
-	 * It also only checks the structural validy of the packet,
-	 * e.g. checksums lengths and protocol data. No information check is done,
-	 * e.g. range checks etc.
-	 *
-	 * Errors should be reported directly, the base class does NOT report any
-	 * errors based on the return value of this function.
-	 *
-	 * @param start start of remaining buffer to be scanned
-	 * @param len length of remaining buffer to be scanned
-	 * @param[out] foundId the id of the data found in the buffer.
-	 * @param[out] foundLen length of the data found. Is to be set in function,
-	 *                       buffer is scanned at previous position + foundLen.
-	 * @return
-	 *  - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *  - @c RETURN_FAILED no reply could be found starting at @c start,
-	 *    implies @c foundLen is not valid, base class will call scanForReply()
-	 *    again with ++start
-	 *  - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
-	 *    e.g. checksum error, implies @c foundLen is valid, can be used to
-	 *    skip some bytes
-	 *  - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
-	 *  - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of
-	 *    the packet
-	 *  - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
-	 *  - @c APERIODIC_REPLY if a valid reply is received that has not been
-	 *    requested by a command, but should be handled anyway
-	 *    (@see also fillCommandAndCookieMap() )
-	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
-			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
-
-	/**
-	 * @brief Interpret a reply from the device.
-	 * @details
-	 * This is called after scanForReply() found a valid packet, it can be
-	 * assumed that the length and structure is valid.
-	 * This routine extracts the data from the packet into a DataSet and then
-	 * calls handleDeviceTM(), which either sends a TM packet or stores the
-	 * data in the DataPool depending on whether it was an external command.
-	 * No packet length is given, as it should be defined implicitly by the id.
-	 *
-	 * @param id the id found by scanForReply()
-	 * @param packet
-	 * @return
-	 *     - @c RETURN_OK when the reply was interpreted.
-	 *     - @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 and #DeviceReplyMap
-	 *	 	  called by the initialize() of the base class
-	 * @details
-	 * This is used to let the base class know which replies are expected.
-	 * There are different scenarios regarding this:
-	 *
-	 *  - "Normal" commands. These are commands, that trigger a direct reply
-	 *    from the device. In this case, the id of the command should be added
-	 *    to the command map with a commandData_t where maxDelayCycles is set
-	 *    to the maximum expected number of PST cycles the reply will take.
-	 *    Then, scanForReply returns the id of the command and the base class
-	 *    can handle time-out and missing replies.
-	 *
-	 *  - Periodic, unrequested replies. These are replies that, once enabled,
-	 *    are sent by the device on its own in a defined interval.
-	 *    In this case, the id of the reply or a placeholder id should be added
-	 *    to the deviceCommandMap with a commandData_t where maxDelayCycles is
-	 *    set to the maximum expected number of PST cycles between two replies
-	 *    (also a tolerance should be added, as an FDIR message will be
-	 *    generated if it is missed).
-	 *
-	 *    (Robin) This part confuses me. "must do as soon as" implies that
-	 *    the developer must do something somewhere else in the code. Is
-	 *    that really the case? If I understood correctly, DHB performs
-	 *    almost everything (e.g. in erirm function) as long as the commands
-	 *    are inserted correctly.
-	 *
-	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must
-	 *    be set to true, DeviceCommandInfo.delayCycles to
-	 *    DeviceCommandInfo.maxDelayCycles.
-	 *    From then on, the base class handles the reception.
-	 *    Then, scanForReply returns the id of the reply or the placeholder id
-	 *    and the base class will take care of checking that all replies are
-	 *    received and the interval is correct.
-	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set
-	 *    to 0, DeviceCommandInfo.delayCycles to 0;
-	 *
-	 *  - Aperiodic, unrequested replies. These are replies that are sent
-	 *    by the device without any preceding command and not in a defined
-	 *    interval. These are not entered in the deviceCommandMap but
-	 *    handled by returning @c APERIODIC_REPLY in scanForReply().
-	 */
-	virtual void fillCommandAndReplyMap() = 0;
-
-	/**
-	 * This is a helper method to facilitate inserting entries in the command map.
-	 * @param deviceCommand	Identifier of the command to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the command
-	 * waits until it times out.
-	 * @param replyLen Will be supplied to the requestReceiveMessage call of
-	 * the communication interface.
-	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
-	 * by the device repeatedly without request) or not. Default is aperiodic (0)
-	 * @return	- @c RETURN_OK when the command was successfully inserted,
-	 *          - @c RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false,
-			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
-
-	/**
-	 * @brief 	This is a helper method to insert replies in the reply map.
-	 * @param deviceCommand	Identifier of the reply to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
-	 * until it times out.
-	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
-	 * by the device repeatedly without request) or not. Default is aperiodic (0)
-	 * @return	- @c RETURN_OK when the command was successfully inserted,
-	 *          - @c RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false);
-
-	/**
-	 * @brief 	A simple command to add a command to the commandList.
-	 * @param deviceCommand The command to add
-	 * @return - @c RETURN_OK when the command was successfully inserted,
-	 *         - @c RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
-	/**
-	 * @brief 	This is a helper method to facilitate updating entries
-	 *        	in the reply map.
-	 * @param deviceCommand	Identifier of the reply to update.
-	 * @param delayCycles The current number of delay cycles to wait.
-	 * As stated in #fillCommandAndCookieMap, to disable periodic commands,
-	 * this is set to zero.
-	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
-	 * until it times out. By passing 0 the entry remains untouched.
-	 * @param periodic Indicates if the command is periodic (i.e. it is sent
-	 * by the device repeatedly without request) or not.Default is aperiodic (0).
-	 * Warning: The setting always overrides the value that was entered in the map.
-	 * @return - @c RETURN_OK when the command was successfully inserted,
-	 *         - @c RETURN_FAILED else.
-	 */
-	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
-			uint16_t delayCycles, uint16_t maxDelayCycles,
-			bool periodic = false);
-
-	/**
-	 * @brief   Can be implemented by child handler to
-	 *          perform debugging
-	 * @details Example: Calling this in performOperation
-	 *          to track values like mode.
-	 * @param positionTracker Provide the child handler a way to know
-	 * where the debugInterface was called
-	 * @param objectId Provide the child handler object Id to
-	 * specify actions for spefic devices
-	 * @param parameter Supply a parameter of interest
-	 * Please delete all debugInterface calls in DHB after debugging is finished !
-	 */
-	virtual void debugInterface(uint8_t positionTracker = 0,
-			object_id_t objectId = 0, uint32_t parameter = 0);
-
-	/**
-	 * Get the time needed to transit from modeFrom to modeTo.
-	 *
-	 * Used for the following transitions:
-	 * modeFrom -> modeTo:
-	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches,
-	 * the base class got you covered)
-	 *
-	 * The default implementation returns 0 !
-	 * @param modeFrom
-	 * @param modeTo
-	 * @return time in ms
-	 */
-	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo);
-
-	/**
-	 * Return the switches connected to the device.
-	 *
-	 * The default implementation returns one switch set in the ctor.
-	 *
-	 * @param[out] switches pointer to an array of switches
-	 * @param[out] numberOfSwitches length of returned array
-	 * @return
-	 *      - @c RETURN_OK if the parameters were set
-	 *      - @c RETURN_FAILED if no switches exist
-	 */
-	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.
-	 */
-	virtual void performOperationHook();
-public:
-	/**
-	 * @param parentQueueId
-	 */
-	virtual void setParentQueue(MessageQueueId_t parentQueueId);
-
-	/** @brief 	Implementation required for HasActionIF */
-	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data,
-			size_t size) override;
-
-	Mode_t getTransitionSourceMode() const;
-	Submode_t getTransitionSourceSubMode() const;
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-	HealthState getHealth();
-	ReturnValue_t setHealth(HealthState health);
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) override;
-	/**
-	 * Implementation of ExecutableObjectIF function
-	 *
-	 * Used to setup the reference of the task, that executes this component
-	 * @param task_ Pointer to the taskIF of this task
-	 */
-	virtual  void setTaskIF(PeriodicTaskIF* task_);
-	virtual MessageQueueId_t getCommandQueue(void) const;
-
-protected:
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
-
-	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(0xA0);
-	// Returnvalues for scanForReply()
-	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB0); //!< This is used to specify for replies from a device which are not replies to requests
-	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB1); //!< Ignore parts of the received packet
-	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB2); //!< Ignore full received packet
-	// Returnvalues for command building
-	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0); //!< Return this if no command sending in required
-	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
-	// Returnvalues for getSwitches()
-	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xD0);
-	// Mode handling error Codes
-	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE1);
-
-	static const DeviceCommandId_t RAW_COMMAND_ID = -1;
-	static const DeviceCommandId_t NO_COMMAND_ID = -2;
-	static const MessageQueueId_t NO_COMMANDER = 0;
-
-	/** Pointer to the raw packet that will be sent.*/
-	uint8_t *rawPacket = nullptr;
-	/** 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(). */
-	uint8_t pstStep = 0;
-	uint32_t pstIntervalMs = 0;
-
-	/**
-	 * Wiretapping flag:
-	 *
-	 * 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;
-	/**
-	 * @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 erroneous replies
-	 */
-	MessageQueueId_t defaultRawReceiver = MessageQueueIF::NO_QUEUE;
-	store_address_t storedRawData;
-
-	/**
-	 * @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;
-
-	/**
-	 * Pointer to the IPCStore.
-	 * This caches the pointer received from the objectManager in the constructor.
-	 */
-	StorageManagerIF *IPCStore = nullptr;
-	/** The comIF object ID is cached for the intialize() function */
-	object_id_t deviceCommunicationId;
-	/** Communication object used for device communication */
-	DeviceCommunicationIF * communicationInterface = nullptr;
-	/** 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 {
-		//! 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.
-	 */
-	struct DeviceReplyInfo {
-		//! 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.
-		//! 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;
-		float collectionInterval = 0.0;
-		uint32_t intervalCounter = 0;
-		//! The command that expects this reply.
-		DeviceCommandMap::iterator command;
-	};
-
-	using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
-	using DeviceReplyIter = DeviceReplyMap::iterator;
-	/**
-	 * 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;
-
-	/**
-	 * this is the datapool variable with the thermal state of the device
-	 *
-	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
-	 */
-	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 = PoolVariableIF::NO_PARAMETER;
-
-	/**
-	 * Optional Error code
-	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
-	 */
-	ReturnValue_t childTransitionFailure;
-
-	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
-
-	FailureIsolationBase* fdirInstance; //!< Pointer to the used FDIR instance. If not provided by child, default class is instantiated.
-
-	HkSwitchHelper hkSwitcher;
-
-	bool defaultFDIRUsed; //!< To correctly delete the default instance.
-
-	bool switchOffWasReported; //!< Indicates if SWITCH_WENT_OFF was already thrown.
-
-	//! 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.
-	/**
-	 * Helper function to report a missed reply
-	 *
-	 * Can be overwritten by children to act on missed replies or to fake reporting Id.
-	 *
-	 * @param id of the missed reply
-	 */
-	virtual void missedReply(DeviceCommandId_t id);
-
-	/**
-	 * Send a reply to a received device handler command.
-	 *
-	 * This also resets #DeviceHandlerCommand to 0.
-	 *
-	 * @param reply the reply type
-	 * @param parameter parameter for the reply
-	 */
-	void replyReturnvalueToCommand(ReturnValue_t status,
-			uint32_t parameter = 0);
-
-	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
-
-	/**
-	 * Set the device handler mode
-	 *
-	 * Sets #timeoutStart with every call.
-	 *
-	 * Sets #transitionTargetMode if necessary so transitional states can be
-	 * entered from everywhere without breaking the state machine
-	 * (which relies on a correct #transitionTargetMode).
-	 *
-	 * The submode is left unchanged.
-	 *
-	 *
-	 * @param newMode
-	 */
-	void setMode(Mode_t newMode);
-
-	/**
-	 * @overload
-	 * @param submode
-	 */
-	void setMode(Mode_t newMode, Submode_t submode);
-
-	/**
-	 * 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
-	 * [_MODE_TO_ON, _MODE_TO_NORMAL, _MODE_TO_RAW]
-	 *
-	 * 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 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.
-	 *
-	 * 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 directly.
-	 *
-	 * #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 subModeFrom the subMode of modeFrom
-	 */
-	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
-
-	/**
-	 * Is the combination of mode and submode valid?
-	 *
-	 * @param mode
-	 * @param submode
-	 * @return
-	 *    - @c RETURN_OK if valid
-	 *    - @c RETURN_FAILED if invalid
-	 */
-	virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
-			Submode_t submode);
-
-	/**
-	 * Get the Rmap action for the current step.
-	 *
-	 * The step number can be read from #pstStep.
-	 *
-	 * @return The Rmap action to execute in this step
-	 */
-
-	virtual CommunicationAction_t getComAction();
-
-	/**
-	 * Build the device command to send for raw mode.
-	 *
-	 * This is only called in @c MODE_RAW. It is for the rare case that in raw mode packets
-	 * are to be sent by the handler itself. It is NOT needed for the raw commanding service.
-	 * Its only current use is in the STR handler which gets its raw packets from a different
-	 * source.
-	 * Also it can be used for transitional commands, to get the device ready for @c MODE_RAW
-	 *
-	 * As it is almost never used, there is a default implementation returning @c NOTHING_TO_SEND.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 *
-	 * @param[out] id the device command id built
-	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c NOTHING_TO_SEND when no command is to be sent
-	 */
-	virtual ReturnValue_t buildChildRawCommand();
-
-	/**
-	 * Returns the delay cycle count of a reply.
-	 * A count != 0 indicates that the command is already executed.
-	 * @param deviceCommand	The command to look for
-	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
-	 */
-	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
-
-	/**
-	 * Construct a command reply containing a raw reply.
-	 *
-	 * It gets space in the #IPCStore, copies data there, then sends a raw reply
-	 * containing the store address.
-	 *
-	 * This method is virtual, as the STR has a different channel to send raw replies
-	 * and overwrites it accordingly.
-	 *
-	 * @param data data to send
-	 * @param len length of @c data
-	 * @param sendTo the messageQueueId of the one to send to
-	 * @param isCommand marks the raw data as a command, the message then will be of type raw_command
-	 */
-	virtual void replyRawData(const uint8_t *data, size_t len,
-			MessageQueueId_t sendTo, bool isCommand = false);
-
-	/**
-	 * Calls replyRawData() with #defaultRawReceiver, but checks if wiretapping is active and if so,
-	 * does not send the Data as the wiretapping will have sent it already
-	 */
-	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
-
-	/**
-	 * notify child about mode change
-	 */
-	virtual void modeChanged(void);
-
-	/**
-	 * Enable the reply checking for a command
-	 *
-	 * Is only called, if the command was sent (ie the getWriteReply was successful).
-	 * Must ensure that all replies are activated and correctly linked to the command that initiated it.
-	 * The default implementation looks for a reply with the same id as the command id in the replyMap or
-	 * uses the alternativeReplyId if flagged so.
-	 * When found, copies maxDelayCycles to delayCycles in the reply information and sets the command to
-	 * expect one reply.
-	 *
-	 * Can be overwritten by the child, if a command activates multiple replies
-	 * or replyId differs from commandId.
-	 * Notes for child implementations:
-	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
-	 * 	- A failure code may be returned if something went fundamentally wrong.
-	 *
-	 * @param deviceCommand
-	 * @return 	- RETURN_OK if a reply was activated.
-	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an
-	 * 			  error case as many commands do not expect a reply.
-	 */
-	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
-			uint8_t expectedReplies = 1, bool useAlternateId = false,
-			DeviceCommandId_t alternateReplyID = 0);
-
-	/**
-	 * get the state of the PCDU switches in the datapool
-	 *
-	 * @return
-	 *     - @c PowerSwitchIF::SWITCH_ON if all switches specified by #switches are on
-	 *     - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by #switches are off
-	 *     - @c PowerSwitchIF::RETURN_FAILED if an error occured
-	 */
-	ReturnValue_t getStateOfSwitches(void);
-
-	/**
-	 * set all datapool variables that are update periodically in normal mode invalid
-	 *
-	 * Child classes should provide an implementation which sets all those variables invalid
-	 * which are set periodically during any normal mode.
-	 */
-	virtual void setNormalDatapoolEntriesInvalid() = 0;
-
-	/**
-	 * build a list of sids and pass it to the #hkSwitcher
-	 */
-	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
-
-	/**
-	 * Children can overwrite this function to suppress checking of the command Queue
-	 *
-	 * This can be used when the child does not want to receive a command in a certain
-	 * situation. Care must be taken that checking is not permanentely disabled as this
-	 * would render the handler unusable.
-	 *
-	 * @return whether checking the queue should NOT be done
-	 */
-	virtual bool dontCheckQueue();
-
-	Mode_t getBaseMode(Mode_t transitionMode);
-
-	bool isAwaitingReply();
-
-	void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t commandId,
-			bool neverInDataPool = false, bool forceDirectTm = false);
-
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode);
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-	virtual void setToExternalControl();
-	virtual void announceMode(bool recursive);
-
-	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
-
-	/**
-	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper" faster about executed events.
-	 * This is a bit sneaky, but improves responsiveness of the device FDIR.
-	 * @param event	The event to be thrown
-	 * @param parameter1	Optional parameter 1
-	 * @param parameter2	Optional parameter 2
-	 */
-	void triggerEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);
-	/**
-	 * Same as triggerEvent, but for forwarding if object is used as proxy.
-	 */
-	virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0) const;
-	/**
-	 * Checks state of switches in conjunction with mode and triggers an event if they don't fit.
-	 */
-	virtual void checkSwitchState();
-
-	/**
-	 * Reserved for the rare case where a device needs to perform additional operation cyclically in OFF mode.
-	 */
-	virtual void doOffActivity();
-
-	/**
-	 * Reserved for the rare case where a device needs to perform additional operation cyclically in ON mode.
-	 */
-	virtual void doOnActivity();
-
-	/**
-	 * Checks if current mode is transitional mode.
-	 * @return true if mode is transitional, false else.
-	 */
-	bool isTransitionalMode();
-
-	/**
-	 * Checks if current handler state allows reception of external device commands.
-	 * Default implementation allows commands only in plain MODE_ON and MODE_NORMAL.
-	 * @return RETURN_OK if commands are accepted, anything else otherwise.
-	 */
-	virtual ReturnValue_t acceptExternalDeviceCommands();
-
-	bool commandIsExecuting(DeviceCommandId_t commandId);
-
-	/**
-	 * set all switches returned by getSwitches()
-	 *
-	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
-	 */
-	void commandSwitch(ReturnValue_t onOff);
-private:
-
-	/**
-	 * State a cookie is in.
-	 *
-	 * Used to keep track of the state of the RMAP communication.
-	 */
-	enum CookieState_t {
-		COOKIE_UNUSED,    //!< The Cookie is unused
-		COOKIE_WRITE_READY, //!< There's data available to send.
-		COOKIE_READ_SENT, //!< A sendRead command was sent with this cookie
-		COOKIE_WRITE_SENT //!< A sendWrite command was sent with this cookie
-	};
-	/**
-	 * Information about a cookie.
-	 *
-	 * This is stored in a map for each cookie, to not only track the state, but also information
-	 * about  the sent command. Tracking this information is needed as
-	 * the state of a commandId (waiting for reply) is done when a RMAP write reply is received.
-	 */
-	struct CookieInfo {
-		CookieState_t state;
-		DeviceCommandMap::iterator pendingCommand;
-	};
-
-	/**
-	 * @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;
-
-	/** Cached for initialize() */
-	static object_id_t defaultHkDestination;
-	/** HK destination can also be set individually */
-	object_id_t hkDestination = objects::NO_OBJECT;
-
-	/**
-	 * @brief   Used for timing out mode transitions.
-	 * Set when setMode() is called.
-	 */
-	uint32_t timeoutStart = 0;
-
-	/**
-	 * Delay for the current mode transition, used for time out
-	 */
-	uint32_t childTransitionDelay;
-
-	/**
-	 * @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)
-	 *
-	 * is element of [MODE_ON, MODE_NORMAL, MODE_RAW]
-	 */
-	Mode_t transitionSourceMode;
-
-	/**
-	 * the submode of the source mode during a transition
-	 */
-	Submode_t transitionSourceSubMode;
-
-	/**
-	 * read the command queue
-	 */
-	void readCommandQueue(void);
-
-	/**
-	 * Handle the device handler mode.
-	 *
-	 * - checks whether commands are valid for the current mode, rejects them accordingly
-	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
-	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
-	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
-	 */
-	void doStateMachine(void);
-
-	void buildRawDeviceCommand(CommandMessage* message);
-	void buildInternalCommand(void);
-
-//	/**
-//	 * Send a reply with the current mode and submode.
-//	 */
-//	void announceMode(void);
-
-	/**
-	 * Decrement the counter for the timout of replies.
-	 *
-	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
-	 * but not received).
-	 */
-	void decrementDeviceReplyMap(void);
-
-	/**
-	 * Convenience function to handle a reply.
-	 *
-	 * Called after scanForReply() has found a packet. Checks if the found id is in the #deviceCommandMap, if so,
-	 * calls interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) for further action.
-	 *
-	 * It also resets the timeout counter for the command id.
-	 *
-	 * @param data the found packet
-	 * @param id the found id
-	 * @foundLen the length of the packet
-	 */
-	void handleReply(const uint8_t *data, DeviceCommandId_t id, uint32_t foundLen);
-
-	void replyToReply(DeviceReplyMap::iterator iter, ReturnValue_t status);
-	/**
-	 * Build and send a command to the device.
-	 *
-	 * This routine checks whether a raw or direct command has been received, checks the content of the received command and
-	 * calls buildCommandFromCommand() for direct commands or sets #rawpacket to the received raw packet.
-	 * If no external command is received or the received command is invalid and the current mode is @c MODE_NORMAL or a transitional mode,
-	 * it asks the child class to build a command (via getNormalDeviceCommand() or getTransitionalDeviceCommand() and buildCommand()) and
-	 * sends the command via RMAP.
-	 */
-	void doSendWrite(void);
-
-	/**
-	 * Check if the RMAP sendWrite action was successful.
-	 *
-	 * Depending on the result, the following is done
-	 * - if the device command was external commanded, a reply is sent indicating the result
-	 * - if the action was successful, the reply timout counter is initialized
-	 */
-	void doGetWrite(void);
-
-	/**
-	 * Send a RMAP getRead command.
-	 *
-	 * The size of the getRead command is #maxDeviceReplyLen.
-	 * This is always executed, independently from the current mode.
-	 */
-	void doSendRead(void);
-
-	/**
-	 * Check the getRead reply and the contained data.
-	 *
-	 * If data was received scanForReply() and, if successful, handleReply() are called.
-	 * If the current mode is @c MODE_RAW, the received packet is sent to the commanding object
-	 * via commandQueue.
-	 */
-	void doGetRead(void);
-
-	/**
-	 * Retrive data from the #IPCStore.
-	 *
-	 * @param storageAddress
-	 * @param[out] data
-	 * @param[out] len
-	 * @return
-	 *   - @c RETURN_OK @c data is valid
-	 *   - @c RETURN_FAILED IPCStore is NULL
-	 *   - the return value from the IPCStore if it was not @c RETURN_OK
-	 */
-	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
-			uint32_t *len);
-
-
-	/**
-	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
-	 */
-	void setTransition(Mode_t modeTo, Submode_t submodeTo);
-
-	/**
-	 * calls the right child function for the transitional submodes
-	 */
-	void callChildStatemachine();
-
-	/**
-	 * Switches the channel of the cookie used for the communication
-	 *
-	 *
-	 * @param newChannel the object Id of the channel to switch to
-	 * @return
-	 *     - @c RETURN_OK when cookie was changed
-	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
-	 *     - @c returnvalues of RMAPChannelIF::isActive()
-	 */
-	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
-
-	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
-
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
-	DataSetIF* getDataSetHandle(sid_t sid) override;
-
-	void parseReply(const uint8_t* receivedData,
-	            size_t receivedDataLen);
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
-
+#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../action/HasActionsIF.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../devicehandlers/DeviceCommunicationIF.h"
+#include "../modes/HasModesIF.h"
+#include "../power/PowerSwitchIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../tasks/PeriodicTaskIF.h"
+
+#include "../action/ActionHelper.h"
+#include "../health/HealthHelper.h"
+#include "../parameters/ParameterHelper.h"
+#include "../datapool/HkSwitchHelper.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+#include <map>
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+class StorageManagerIF;
+
+/**
+ * @defgroup devices Devices
+ * Contains all devices and the DeviceHandlerBase class.
+ */
+
+/**
+ * @brief This is the abstract base class for device handlers.
+ * @details
+ * Documentation: Dissertation Baetz p.138,139, p.141-149
+ *
+ * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink,
+ * communication with physical devices, using the @link DeviceCommunicationIF @endlink,
+ * and communication with commanding objects.
+ * It inherits SystemObject and thus can be created by the ObjectManagerIF.
+ *
+ * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
+ * For each step an RMAP action is selected and executed.
+ * 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.
+ * 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).
+ * The following abstract methods must be implemented by a device handler:
+ *  1. doStartUp()
+ *  2. doShutDown()
+ *  3. buildTransitionDeviceCommand()
+ *  4. buildNormalDeviceCommand()
+ *  5. buildCommandFromCommand()
+ *  6. fillCommandAndReplyMap()
+ *  7. scanForReply()
+ *  8. interpretDeviceReply()
+ *
+ * Other important virtual methods with a default implementation
+ * are the getTransitionDelayMs() function and the getSwitches() function.
+ * Please ensure that getSwitches() returns DeviceHandlerIF::NO_SWITCHES if
+ * power switches are not implemented yet. Otherwise, the device handler will
+ * not transition to MODE_ON, even if setMode(MODE_ON) is called.
+ * If a transition to MODE_ON is desired without commanding, override the
+ * intialize() function and call setMode(_MODE_START_UP) before calling
+ * DeviceHandlerBase::initialize().
+ *
+ * @ingroup devices
+ */
+class DeviceHandlerBase: public DeviceHandlerIF,
+		public HasReturnvaluesIF,
+		public ExecutableObjectIF,
+		public SystemObject,
+		public HasModesIF,
+		public HasHealthIF,
+		public HasActionsIF,
+		public ReceivesParameterMessagesIF,
+		public HasLocalDataPoolIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	/**
+	 * The constructor passes the objectId to the SystemObject().
+	 *
+	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
+	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
+	 * @param setDeviceSwitch the switch the device is connected to,
+	 * for devices using two switches, overwrite getSwitches()
+	 * @param deviceCommuncation Communcation Interface object which is used
+	 * to implement communication functions
+	 * @param thermalStatePoolId
+	 * @param thermalRequestPoolId
+	 * @param fdirInstance
+	 * @param cmdQueueSize
+	 */
+	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+			CookieIF * comCookie, FailureIsolationBase* fdirInstance = nullptr,
+			size_t cmdQueueSize = 20);
+
+	void setHkDestination(object_id_t hkDestination);
+	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
+			uint32_t thermalRequestPoolId);
+
+	/**
+	 * @brief 	This function is the device handler base core component and is
+	 * 			called periodically.
+	 * @details
+	 * General sequence, showing where abstract virtual functions are called:
+	 * If the State is SEND_WRITE:
+	 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
+	 *   2. Handles Device State Modes by calling doStateMachine().
+	 *      This function calls callChildStatemachine() which calls the
+	 *      abstract functions doStartUp() and doShutDown()
+	 *   3. Check switch states by calling checkSwitchStates()
+	 *   4. Decrements counter for timeout of replies by calling
+	 *      decrementDeviceReplyMap()
+	 *   5. Performs FDIR check for failures
+	 *   6. Calls hkSwitcher.performOperation()
+	 *   7. If the device mode is MODE_OFF, return RETURN_OK.
+     *      Otherwise, perform the Action property and performs depending
+     *      on value specified by input value counter (incremented in PST).
+     *      The child class tells base class what to do by setting this value.
+	 *     - SEND_WRITE: Send data or commands to device by calling
+	 *       doSendWrite() which calls sendMessage function
+	 *       of #communicationInterface
+	 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
+	 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite()
+	 *       which calls getSendSuccess of #communicationInterface.
+	 *       Calls abstract functions scanForReply() and interpretDeviceReply().
+	 *     - SEND_READ: Request reading data from device by calling doSendRead()
+	 *       which calls requestReceiveMessage of #communcationInterface
+	 *     - GET_READ: Access requested reading data by calling doGetRead()
+	 *       which calls readReceivedMessage of #communicationInterface
+	 * @param counter Specifies which Action to perform
+	 * @return RETURN_OK for successful execution
+	 */
+	virtual ReturnValue_t performOperation(uint8_t counter);
+
+	/**
+	 * @brief  Initializes the device handler
+	 * @details
+	 * Initialize Device Handler as system object and
+	 * initializes all important helper classes.
+	 * Calls fillCommandAndReplyMap().
+	 * @return
+	 */
+	virtual ReturnValue_t initialize();
+	/** Destructor. */
+	virtual ~DeviceHandlerBase();
+
+protected:
+	/**
+	 * @brief 	This is used to let the child class handle the transition from
+	 * 			mode @c _MODE_START_UP to @c MODE_ON
+	 * @details
+	 * It is only called when the device handler is in mode @c _MODE_START_UP.
+	 * That means, the device switch(es) are already set to on.
+	 * Device handler commands are read and can be handled by the child class.
+	 * If the child class handles a command, it should also send
+	 * an reply accordingly.
+	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE,
+	 * the base class handles rejecting the command and sends a reply.
+	 * The replies for mode transitions are handled by the base class.
+	 *
+	 *  - If the device is started and ready for operation, the mode should be
+	 *    set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
+	 *    use the to on transition if available.
+	 *  - If the power-up fails, the mode should be set to _MODE_POWER_DOWN
+	 *    which will lead to the device being powered off.
+	 *  - If the device does not change the mode, the mode will be changed
+	 *    to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay())
+	 *    has passed.
+	 *
+	 * #transitionFailure can be set to a failure code indicating the reason
+	 * for a failed transition
+	 */
+	virtual void doStartUp() = 0;
+
+	/**
+	 * @brief 	This is used to let the child class handle the transition
+	 * 			from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
+	 * @details
+	 * It is only called when the device handler is in mode @c _MODE_SHUT_DOWN.
+	 * Device handler commands are read and can be handled by the child class.
+	 * If the child class handles a command, it should also send an reply
+	 * accordingly.
+	 * If an Command is not handled (ie #DeviceHandlerCommand is not
+	 * @c CMD_NONE, the base class handles rejecting the command and sends a
+	 * reply. The replies for mode transitions are handled by the base class.
+	 *
+	 *  - If the device ready to be switched off,
+	 *    the mode should be set to _MODE_POWER_DOWN.
+	 *  - If the device should not be switched off, the mode can be changed to
+	 *     _MODE_TO_ON (or MODE_ON if no transition is needed).
+	 *  - If the device does not change the mode, the mode will be changed to
+	 *    _MODE_POWER_DOWN, when the timeout (from getTransitionDelay())
+	 *    has passed.
+	 *
+	 * #transitionFailure can be set to a failure code indicating the reason
+	 * for a failed transition
+	 */
+	virtual void doShutDown() = 0;
+
+	/**
+	 * Build the device command to send for normal mode.
+	 *
+	 * This is only called in @c MODE_NORMAL. If multiple submodes for
+	 * @c MODE_NORMAL are supported, different commands can built,
+	 * depending on the submode.
+	 *
+	 * #rawPacket and #rawPacketLen must be set by this method to the
+	 * packet to be sent. If variable command frequence is required, a counter
+	 * can be used and the frequency in the reply map has to be set manually
+	 * by calling updateReplyMap().
+	 *
+	 * @param[out] id the device command id that has been built
+	 * @return
+	 *    - @c RETURN_OK to send command after setting #rawPacket and #rawPacketLen.
+	 *    - @c NOTHING_TO_SEND when no command is to be sent.
+	 *    - Anything else triggers an even with the returnvalue as a parameter.
+	 */
+	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
+
+	/**
+	 * 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_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
+	 * and filling them in doStartUp(), doShutDown() and doTransition() so no
+	 * modes have to be checked here.
+	 *
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 *
+	 * @param[out] id the device command id built
+	 * @return
+	 *    - @c RETURN_OK when a command is to be sent
+	 *    - @c NOTHING_TO_SEND when no command is to be sent
+	 *    - Anything else triggers an even with the returnvalue as a parameter
+	 */
+	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
+
+	/**
+	 * @brief Build a device command packet from data supplied by a direct command.
+	 *
+	 * @details
+	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
+	 * The existence of the command in the command map and the command size check
+	 * against 0 are done by the base class.
+	 *
+	 * @param deviceCommand the command to build, already checked against deviceCommandMap
+	 * @param commandData pointer to the data from the direct command
+	 * @param commandDataLen length of commandData
+	 * @return
+	 *     - @c RETURN_OK to send command after #rawPacket and #rawPacketLen have been set.
+	 *     - Anything else triggers an event with the returnvalue as a parameter
+	 */
+	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+			const uint8_t * commandData, size_t commandDataLen) = 0;
+
+	/**
+	 * @brief Scans a buffer for a valid reply.
+	 * @details
+	 * This is used by the base class to check the data received for valid packets.
+	 * It only checks if a valid packet starts at @c start.
+	 * It also only checks the structural validy of the packet,
+	 * e.g. checksums lengths and protocol data. No information check is done,
+	 * e.g. range checks etc.
+	 *
+	 * Errors should be reported directly, the base class does NOT report any
+	 * errors based on the return value of this function.
+	 *
+	 * @param start start of remaining buffer to be scanned
+	 * @param len length of remaining buffer to be scanned
+	 * @param[out] foundId the id of the data found in the buffer.
+	 * @param[out] foundLen length of the data found. Is to be set in function,
+	 *                       buffer is scanned at previous position + foundLen.
+	 * @return
+	 *  - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
+	 *  - @c RETURN_FAILED no reply could be found starting at @c start,
+	 *    implies @c foundLen is not valid, base class will call scanForReply()
+	 *    again with ++start
+	 *  - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
+	 *    e.g. checksum error, implies @c foundLen is valid, can be used to
+	 *    skip some bytes
+	 *  - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
+	 *  - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of
+	 *    the packet
+	 *  - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
+	 *  - @c APERIODIC_REPLY if a valid reply is received that has not been
+	 *    requested by a command, but should be handled anyway
+	 *    (@see also fillCommandAndCookieMap() )
+	 */
+	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
+
+	/**
+	 * @brief Interpret a reply from the device.
+	 * @details
+	 * This is called after scanForReply() found a valid packet, it can be
+	 * assumed that the length and structure is valid.
+	 * This routine extracts the data from the packet into a DataSet and then
+	 * calls handleDeviceTM(), which either sends a TM packet or stores the
+	 * data in the DataPool depending on whether it was an external command.
+	 * No packet length is given, as it should be defined implicitly by the id.
+	 *
+	 * @param id the id found by scanForReply()
+	 * @param packet
+	 * @return
+	 *     - @c RETURN_OK when the reply was interpreted.
+	 *     - @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 and #DeviceReplyMap
+	 *	 	  called by the initialize() of the base class
+	 * @details
+	 * This is used to let the base class know which replies are expected.
+	 * There are different scenarios regarding this:
+	 *
+	 *  - "Normal" commands. These are commands, that trigger a direct reply
+	 *    from the device. In this case, the id of the command should be added
+	 *    to the command map with a commandData_t where maxDelayCycles is set
+	 *    to the maximum expected number of PST cycles the reply will take.
+	 *    Then, scanForReply returns the id of the command and the base class
+	 *    can handle time-out and missing replies.
+	 *
+	 *  - Periodic, unrequested replies. These are replies that, once enabled,
+	 *    are sent by the device on its own in a defined interval.
+	 *    In this case, the id of the reply or a placeholder id should be added
+	 *    to the deviceCommandMap with a commandData_t where maxDelayCycles is
+	 *    set to the maximum expected number of PST cycles between two replies
+	 *    (also a tolerance should be added, as an FDIR message will be
+	 *    generated if it is missed).
+	 *
+	 *    (Robin) This part confuses me. "must do as soon as" implies that
+	 *    the developer must do something somewhere else in the code. Is
+	 *    that really the case? If I understood correctly, DHB performs
+	 *    almost everything (e.g. in erirm function) as long as the commands
+	 *    are inserted correctly.
+	 *
+	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must
+	 *    be set to true, DeviceCommandInfo.delayCycles to
+	 *    DeviceCommandInfo.maxDelayCycles.
+	 *    From then on, the base class handles the reception.
+	 *    Then, scanForReply returns the id of the reply or the placeholder id
+	 *    and the base class will take care of checking that all replies are
+	 *    received and the interval is correct.
+	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set
+	 *    to 0, DeviceCommandInfo.delayCycles to 0;
+	 *
+	 *  - Aperiodic, unrequested replies. These are replies that are sent
+	 *    by the device without any preceding command and not in a defined
+	 *    interval. These are not entered in the deviceCommandMap but
+	 *    handled by returning @c APERIODIC_REPLY in scanForReply().
+	 */
+	virtual void fillCommandAndReplyMap() = 0;
+
+	/**
+	 * This is a helper method to facilitate inserting entries in the command map.
+	 * @param deviceCommand	Identifier of the command to add.
+	 * @param maxDelayCycles The maximum number of delay cycles the command
+	 * waits until it times out.
+	 * @param replyLen Will be supplied to the requestReceiveMessage call of
+	 * the communication interface.
+	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not. Default is aperiodic (0)
+	 * @return	- @c RETURN_OK when the command was successfully inserted,
+	 *          - @c RETURN_FAILED else.
+	 */
+	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
+			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false,
+			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
+
+	/**
+	 * @brief 	This is a helper method to insert replies in the reply map.
+	 * @param deviceCommand	Identifier of the reply to add.
+	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
+	 * until it times out.
+	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not. Default is aperiodic (0)
+	 * @return	- @c RETURN_OK when the command was successfully inserted,
+	 *          - @c RETURN_FAILED else.
+	 */
+	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
+			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false);
+
+	/**
+	 * @brief 	A simple command to add a command to the commandList.
+	 * @param deviceCommand The command to add
+	 * @return - @c RETURN_OK when the command was successfully inserted,
+	 *         - @c RETURN_FAILED else.
+	 */
+	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
+	/**
+	 * @brief 	This is a helper method to facilitate updating entries
+	 *        	in the reply map.
+	 * @param deviceCommand	Identifier of the reply to update.
+	 * @param delayCycles The current number of delay cycles to wait.
+	 * As stated in #fillCommandAndCookieMap, to disable periodic commands,
+	 * this is set to zero.
+	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
+	 * until it times out. By passing 0 the entry remains untouched.
+	 * @param periodic Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not.Default is aperiodic (0).
+	 * Warning: The setting always overrides the value that was entered in the map.
+	 * @return - @c RETURN_OK when the command was successfully inserted,
+	 *         - @c RETURN_FAILED else.
+	 */
+	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
+			uint16_t delayCycles, uint16_t maxDelayCycles,
+			bool periodic = false);
+
+	/**
+	 * @brief   Can be implemented by child handler to
+	 *          perform debugging
+	 * @details Example: Calling this in performOperation
+	 *          to track values like mode.
+	 * @param positionTracker Provide the child handler a way to know
+	 * where the debugInterface was called
+	 * @param objectId Provide the child handler object Id to
+	 * specify actions for spefic devices
+	 * @param parameter Supply a parameter of interest
+	 * Please delete all debugInterface calls in DHB after debugging is finished !
+	 */
+	virtual void debugInterface(uint8_t positionTracker = 0,
+			object_id_t objectId = 0, uint32_t parameter = 0);
+
+	/**
+	 * Get the time needed to transit from modeFrom to modeTo.
+	 *
+	 * Used for the following transitions:
+	 * modeFrom -> modeTo:
+	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches,
+	 * the base class got you covered)
+	 *
+	 * The default implementation returns 0 !
+	 * @param modeFrom
+	 * @param modeTo
+	 * @return time in ms
+	 */
+	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo);
+
+	/**
+	 * Return the switches connected to the device.
+	 *
+	 * The default implementation returns one switch set in the ctor.
+	 *
+	 * @param[out] switches pointer to an array of switches
+	 * @param[out] numberOfSwitches length of returned array
+	 * @return
+	 *      - @c RETURN_OK if the parameters were set
+	 *      - @c RETURN_FAILED if no switches exist
+	 */
+	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.
+	 */
+	virtual void performOperationHook();
+public:
+	/**
+	 * @param parentQueueId
+	 */
+	virtual void setParentQueue(MessageQueueId_t parentQueueId);
+
+	/** @brief 	Implementation required for HasActionIF */
+	ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data,
+			size_t size) override;
+
+	Mode_t getTransitionSourceMode() const;
+	Submode_t getTransitionSourceSubMode() const;
+	virtual void getMode(Mode_t *mode, Submode_t *submode);
+	HealthState getHealth();
+	ReturnValue_t setHealth(HealthState health);
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) override;
+	/**
+	 * Implementation of ExecutableObjectIF function
+	 *
+	 * Used to setup the reference of the task, that executes this component
+	 * @param task_ Pointer to the taskIF of this task
+	 */
+	virtual  void setTaskIF(PeriodicTaskIF* task_);
+	virtual MessageQueueId_t getCommandQueue(void) const;
+
+protected:
+	/**
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
+	 */
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
+
+	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(0xA0);
+	// Returnvalues for scanForReply()
+	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB0); //!< This is used to specify for replies from a device which are not replies to requests
+	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB1); //!< Ignore parts of the received packet
+	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB2); //!< Ignore full received packet
+	// Returnvalues for command building
+	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0); //!< Return this if no command sending in required
+	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
+	// Returnvalues for getSwitches()
+	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xD0);
+	// Mode handling error Codes
+	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE1);
+
+	static const DeviceCommandId_t RAW_COMMAND_ID = -1;
+	static const DeviceCommandId_t NO_COMMAND_ID = -2;
+	static const MessageQueueId_t NO_COMMANDER = 0;
+
+	/** Pointer to the raw packet that will be sent.*/
+	uint8_t *rawPacket = nullptr;
+	/** 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(). */
+	uint8_t pstStep = 0;
+	uint32_t pstIntervalMs = 0;
+
+	/**
+	 * Wiretapping flag:
+	 *
+	 * 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;
+	/**
+	 * @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 erroneous replies
+	 */
+	MessageQueueId_t defaultRawReceiver = MessageQueueIF::NO_QUEUE;
+	store_address_t storedRawData;
+
+	/**
+	 * @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;
+
+	/**
+	 * Pointer to the IPCStore.
+	 * This caches the pointer received from the objectManager in the constructor.
+	 */
+	StorageManagerIF *IPCStore = nullptr;
+	/** The comIF object ID is cached for the intialize() function */
+	object_id_t deviceCommunicationId;
+	/** Communication object used for device communication */
+	DeviceCommunicationIF * communicationInterface = nullptr;
+	/** 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 {
+		//! 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.
+	 */
+	struct DeviceReplyInfo {
+		//! 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.
+		//! 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;
+		float collectionInterval = 0.0;
+		uint32_t intervalCounter = 0;
+		//! The command that expects this reply.
+		DeviceCommandMap::iterator command;
+	};
+
+	using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
+	using DeviceReplyIter = DeviceReplyMap::iterator;
+	/**
+	 * 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;
+
+	/**
+	 * this is the datapool variable with the thermal state of the device
+	 *
+	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
+	 */
+	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 = PoolVariableIF::NO_PARAMETER;
+
+	/**
+	 * Optional Error code
+	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
+	 */
+	ReturnValue_t childTransitionFailure;
+
+	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
+
+	FailureIsolationBase* fdirInstance; //!< Pointer to the used FDIR instance. If not provided by child, default class is instantiated.
+
+	HkSwitchHelper hkSwitcher;
+
+	bool defaultFDIRUsed; //!< To correctly delete the default instance.
+
+	bool switchOffWasReported; //!< Indicates if SWITCH_WENT_OFF was already thrown.
+
+	//! 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.
+	/**
+	 * Helper function to report a missed reply
+	 *
+	 * Can be overwritten by children to act on missed replies or to fake reporting Id.
+	 *
+	 * @param id of the missed reply
+	 */
+	virtual void missedReply(DeviceCommandId_t id);
+
+	/**
+	 * Send a reply to a received device handler command.
+	 *
+	 * This also resets #DeviceHandlerCommand to 0.
+	 *
+	 * @param reply the reply type
+	 * @param parameter parameter for the reply
+	 */
+	void replyReturnvalueToCommand(ReturnValue_t status,
+			uint32_t parameter = 0);
+
+	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
+
+	/**
+	 * Set the device handler mode
+	 *
+	 * Sets #timeoutStart with every call.
+	 *
+	 * Sets #transitionTargetMode if necessary so transitional states can be
+	 * entered from everywhere without breaking the state machine
+	 * (which relies on a correct #transitionTargetMode).
+	 *
+	 * The submode is left unchanged.
+	 *
+	 *
+	 * @param newMode
+	 */
+	void setMode(Mode_t newMode);
+
+	/**
+	 * @overload
+	 * @param submode
+	 */
+	void setMode(Mode_t newMode, Submode_t submode);
+
+	/**
+	 * 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
+	 * [_MODE_TO_ON, _MODE_TO_NORMAL, _MODE_TO_RAW]
+	 *
+	 * 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 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.
+	 *
+	 * 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 directly.
+	 *
+	 * #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 subModeFrom the subMode of modeFrom
+	 */
+	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
+
+	/**
+	 * Is the combination of mode and submode valid?
+	 *
+	 * @param mode
+	 * @param submode
+	 * @return
+	 *    - @c RETURN_OK if valid
+	 *    - @c RETURN_FAILED if invalid
+	 */
+	virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+			Submode_t submode);
+
+	/**
+	 * Get the Rmap action for the current step.
+	 *
+	 * The step number can be read from #pstStep.
+	 *
+	 * @return The Rmap action to execute in this step
+	 */
+
+	virtual CommunicationAction_t getComAction();
+
+	/**
+	 * Build the device command to send for raw mode.
+	 *
+	 * This is only called in @c MODE_RAW. It is for the rare case that in raw mode packets
+	 * are to be sent by the handler itself. It is NOT needed for the raw commanding service.
+	 * Its only current use is in the STR handler which gets its raw packets from a different
+	 * source.
+	 * Also it can be used for transitional commands, to get the device ready for @c MODE_RAW
+	 *
+	 * As it is almost never used, there is a default implementation returning @c NOTHING_TO_SEND.
+	 *
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 *
+	 * @param[out] id the device command id built
+	 * @return
+	 *    - @c RETURN_OK when a command is to be sent
+	 *    - not @c NOTHING_TO_SEND when no command is to be sent
+	 */
+	virtual ReturnValue_t buildChildRawCommand();
+
+	/**
+	 * Returns the delay cycle count of a reply.
+	 * A count != 0 indicates that the command is already executed.
+	 * @param deviceCommand	The command to look for
+	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
+	 */
+	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
+
+	/**
+	 * Construct a command reply containing a raw reply.
+	 *
+	 * It gets space in the #IPCStore, copies data there, then sends a raw reply
+	 * containing the store address.
+	 *
+	 * This method is virtual, as the STR has a different channel to send raw replies
+	 * and overwrites it accordingly.
+	 *
+	 * @param data data to send
+	 * @param len length of @c data
+	 * @param sendTo the messageQueueId of the one to send to
+	 * @param isCommand marks the raw data as a command, the message then will be of type raw_command
+	 */
+	virtual void replyRawData(const uint8_t *data, size_t len,
+			MessageQueueId_t sendTo, bool isCommand = false);
+
+	/**
+	 * Calls replyRawData() with #defaultRawReceiver, but checks if wiretapping is active and if so,
+	 * does not send the Data as the wiretapping will have sent it already
+	 */
+	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
+
+	/**
+	 * notify child about mode change
+	 */
+	virtual void modeChanged(void);
+
+	/**
+	 * Enable the reply checking for a command
+	 *
+	 * Is only called, if the command was sent (ie the getWriteReply was successful).
+	 * Must ensure that all replies are activated and correctly linked to the command that initiated it.
+	 * The default implementation looks for a reply with the same id as the command id in the replyMap or
+	 * uses the alternativeReplyId if flagged so.
+	 * When found, copies maxDelayCycles to delayCycles in the reply information and sets the command to
+	 * expect one reply.
+	 *
+	 * Can be overwritten by the child, if a command activates multiple replies
+	 * or replyId differs from commandId.
+	 * Notes for child implementations:
+	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
+	 * 	- A failure code may be returned if something went fundamentally wrong.
+	 *
+	 * @param deviceCommand
+	 * @return 	- RETURN_OK if a reply was activated.
+	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an
+	 * 			  error case as many commands do not expect a reply.
+	 */
+	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
+			uint8_t expectedReplies = 1, bool useAlternateId = false,
+			DeviceCommandId_t alternateReplyID = 0);
+
+	/**
+	 * get the state of the PCDU switches in the datapool
+	 *
+	 * @return
+	 *     - @c PowerSwitchIF::SWITCH_ON if all switches specified by #switches are on
+	 *     - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by #switches are off
+	 *     - @c PowerSwitchIF::RETURN_FAILED if an error occured
+	 */
+	ReturnValue_t getStateOfSwitches(void);
+
+	/**
+	 * set all datapool variables that are update periodically in normal mode invalid
+	 *
+	 * Child classes should provide an implementation which sets all those variables invalid
+	 * which are set periodically during any normal mode.
+	 */
+	virtual void setNormalDatapoolEntriesInvalid() = 0;
+
+	/**
+	 * build a list of sids and pass it to the #hkSwitcher
+	 */
+	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
+
+	/**
+	 * Children can overwrite this function to suppress checking of the command Queue
+	 *
+	 * This can be used when the child does not want to receive a command in a certain
+	 * situation. Care must be taken that checking is not permanentely disabled as this
+	 * would render the handler unusable.
+	 *
+	 * @return whether checking the queue should NOT be done
+	 */
+	virtual bool dontCheckQueue();
+
+	Mode_t getBaseMode(Mode_t transitionMode);
+
+	bool isAwaitingReply();
+
+	void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t commandId,
+			bool neverInDataPool = false, bool forceDirectTm = false);
+
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode);
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+	virtual void setToExternalControl();
+	virtual void announceMode(bool recursive);
+
+	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
+
+	/**
+	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper" faster about executed events.
+	 * This is a bit sneaky, but improves responsiveness of the device FDIR.
+	 * @param event	The event to be thrown
+	 * @param parameter1	Optional parameter 1
+	 * @param parameter2	Optional parameter 2
+	 */
+	void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
+	/**
+	 * Same as triggerEvent, but for forwarding if object is used as proxy.
+	 */
+	virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0) const;
+	/**
+	 * Checks state of switches in conjunction with mode and triggers an event if they don't fit.
+	 */
+	virtual void checkSwitchState();
+
+	/**
+	 * Reserved for the rare case where a device needs to perform additional operation cyclically in OFF mode.
+	 */
+	virtual void doOffActivity();
+
+	/**
+	 * Reserved for the rare case where a device needs to perform additional operation cyclically in ON mode.
+	 */
+	virtual void doOnActivity();
+
+	/**
+	 * Checks if current mode is transitional mode.
+	 * @return true if mode is transitional, false else.
+	 */
+	bool isTransitionalMode();
+
+	/**
+	 * Checks if current handler state allows reception of external device commands.
+	 * Default implementation allows commands only in plain MODE_ON and MODE_NORMAL.
+	 * @return RETURN_OK if commands are accepted, anything else otherwise.
+	 */
+	virtual ReturnValue_t acceptExternalDeviceCommands();
+
+	bool commandIsExecuting(DeviceCommandId_t commandId);
+
+	/**
+	 * set all switches returned by getSwitches()
+	 *
+	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
+	 */
+	void commandSwitch(ReturnValue_t onOff);
+private:
+
+	/**
+	 * State a cookie is in.
+	 *
+	 * Used to keep track of the state of the RMAP communication.
+	 */
+	enum CookieState_t {
+		COOKIE_UNUSED,    //!< The Cookie is unused
+		COOKIE_WRITE_READY, //!< There's data available to send.
+		COOKIE_READ_SENT, //!< A sendRead command was sent with this cookie
+		COOKIE_WRITE_SENT //!< A sendWrite command was sent with this cookie
+	};
+	/**
+	 * Information about a cookie.
+	 *
+	 * This is stored in a map for each cookie, to not only track the state, but also information
+	 * about  the sent command. Tracking this information is needed as
+	 * the state of a commandId (waiting for reply) is done when a RMAP write reply is received.
+	 */
+	struct CookieInfo {
+		CookieState_t state;
+		DeviceCommandMap::iterator pendingCommand;
+	};
+
+	/**
+	 * @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;
+
+	/** Cached for initialize() */
+	static object_id_t defaultHkDestination;
+	/** HK destination can also be set individually */
+	object_id_t hkDestination = objects::NO_OBJECT;
+
+	/**
+	 * @brief   Used for timing out mode transitions.
+	 * Set when setMode() is called.
+	 */
+	uint32_t timeoutStart = 0;
+
+	/**
+	 * Delay for the current mode transition, used for time out
+	 */
+	uint32_t childTransitionDelay;
+
+	/**
+	 * @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)
+	 *
+	 * is element of [MODE_ON, MODE_NORMAL, MODE_RAW]
+	 */
+	Mode_t transitionSourceMode;
+
+	/**
+	 * the submode of the source mode during a transition
+	 */
+	Submode_t transitionSourceSubMode;
+
+	/**
+	 * read the command queue
+	 */
+	void readCommandQueue(void);
+
+	/**
+	 * Handle the device handler mode.
+	 *
+	 * - checks whether commands are valid for the current mode, rejects them accordingly
+	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
+	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
+	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
+	 */
+	void doStateMachine(void);
+
+	void buildRawDeviceCommand(CommandMessage* message);
+	void buildInternalCommand(void);
+
+//	/**
+//	 * Send a reply with the current mode and submode.
+//	 */
+//	void announceMode(void);
+
+	/**
+	 * Decrement the counter for the timout of replies.
+	 *
+	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
+	 * but not received).
+	 */
+	void decrementDeviceReplyMap(void);
+
+	/**
+	 * Convenience function to handle a reply.
+	 *
+	 * Called after scanForReply() has found a packet. Checks if the found id is in the #deviceCommandMap, if so,
+	 * calls interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) for further action.
+	 *
+	 * It also resets the timeout counter for the command id.
+	 *
+	 * @param data the found packet
+	 * @param id the found id
+	 * @foundLen the length of the packet
+	 */
+	void handleReply(const uint8_t *data, DeviceCommandId_t id, uint32_t foundLen);
+
+	void replyToReply(DeviceReplyMap::iterator iter, ReturnValue_t status);
+	/**
+	 * Build and send a command to the device.
+	 *
+	 * This routine checks whether a raw or direct command has been received, checks the content of the received command and
+	 * calls buildCommandFromCommand() for direct commands or sets #rawpacket to the received raw packet.
+	 * If no external command is received or the received command is invalid and the current mode is @c MODE_NORMAL or a transitional mode,
+	 * it asks the child class to build a command (via getNormalDeviceCommand() or getTransitionalDeviceCommand() and buildCommand()) and
+	 * sends the command via RMAP.
+	 */
+	void doSendWrite(void);
+
+	/**
+	 * Check if the RMAP sendWrite action was successful.
+	 *
+	 * Depending on the result, the following is done
+	 * - if the device command was external commanded, a reply is sent indicating the result
+	 * - if the action was successful, the reply timout counter is initialized
+	 */
+	void doGetWrite(void);
+
+	/**
+	 * Send a RMAP getRead command.
+	 *
+	 * The size of the getRead command is #maxDeviceReplyLen.
+	 * This is always executed, independently from the current mode.
+	 */
+	void doSendRead(void);
+
+	/**
+	 * Check the getRead reply and the contained data.
+	 *
+	 * If data was received scanForReply() and, if successful, handleReply() are called.
+	 * If the current mode is @c MODE_RAW, the received packet is sent to the commanding object
+	 * via commandQueue.
+	 */
+	void doGetRead(void);
+
+	/**
+	 * Retrive data from the #IPCStore.
+	 *
+	 * @param storageAddress
+	 * @param[out] data
+	 * @param[out] len
+	 * @return
+	 *   - @c RETURN_OK @c data is valid
+	 *   - @c RETURN_FAILED IPCStore is NULL
+	 *   - the return value from the IPCStore if it was not @c RETURN_OK
+	 */
+	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
+			uint32_t *len);
+
+
+	/**
+	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
+	 */
+	void setTransition(Mode_t modeTo, Submode_t submodeTo);
+
+	/**
+	 * calls the right child function for the transitional submodes
+	 */
+	void callChildStatemachine();
+
+	/**
+	 * Switches the channel of the cookie used for the communication
+	 *
+	 *
+	 * @param newChannel the object Id of the channel to switch to
+	 * @return
+	 *     - @c RETURN_OK when cookie was changed
+	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
+	 *     - @c returnvalues of RMAPChannelIF::isActive()
+	 */
+	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
+
+	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
+
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+	DataSetIF* getDataSetHandle(sid_t sid) override;
+
+	void parseReply(const uint8_t* receivedData,
+	            size_t receivedDataLen);
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
+
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 46e73cd8c..54788600a 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -1,251 +1,251 @@
-#include <framework/devicehandlers/DeviceHandlerBase.h>
-#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include <framework/health/HealthTableIF.h>
-#include <framework/power/Fuse.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/thermal/ThermalComponentIF.h>
-
-object_id_t DeviceHandlerFailureIsolation::powerConfirmationId = 0;
-
-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() {
-}
-
-ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event) {
-	if(isFdirInActionOrAreWeFaulty(event)) {
-		return RETURN_OK;
-	}
-	ReturnValue_t result = RETURN_FAILED;
-	switch (event->getEvent()) {
-	case HasModesIF::MODE_TRANSITION_FAILED:
-	case HasModesIF::OBJECT_IN_INVALID_MODE:
-		//We'll try a recovery as long as defined in MAX_REBOOT.
-		//Might cause some AssemblyBase cycles, so keep number low.
-		handleRecovery(event->getEvent());
-		break;
-	case DeviceHandlerIF::DEVICE_INTERPRETING_REPLY_FAILED:
-	case DeviceHandlerIF::DEVICE_READING_REPLY_FAILED:
-	case DeviceHandlerIF::DEVICE_UNREQUESTED_REPLY:
-	case DeviceHandlerIF::DEVICE_UNKNOWN_REPLY: //Some DH's generate generic reply-ids.
-	case DeviceHandlerIF::DEVICE_BUILDING_COMMAND_FAILED:
-		//These faults all mean that there were stupid replies from a device.
-		if (strangeReplyCount.incrementAndCheck()) {
-			handleRecovery(event->getEvent());
-		}
-		break;
-	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
-	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
-		//The two above should never be confirmed.
-	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
-		result = sendConfirmationRequest(event);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-		//else
-		if (missedReplyCount.incrementAndCheck()) {
-			handleRecovery(event->getEvent());
-		}
-		break;
-	case StorageManagerIF::GET_DATA_FAILED:
-	case StorageManagerIF::STORE_DATA_FAILED:
-		//Rather strange bugs, occur in RAW mode only. Ignore.
-		break;
-	case DeviceHandlerIF::INVALID_DEVICE_COMMAND:
-		//Ignore, is bad configuration. We can't do anything in flight.
-		break;
-	case HasHealthIF::HEALTH_INFO:
-	case HasModesIF::MODE_INFO:
-	case HasModesIF::CHANGING_MODE:
-		//Do nothing, but mark as handled.
-		break;
-		//****Power*****
-	case PowerSwitchIF::SWITCH_WENT_OFF:
-		if(hasPowerConfirmation) {
-			result = sendConfirmationRequest(event, powerConfirmation);
-			if (result == RETURN_OK) {
-				setFdirState(DEVICE_MIGHT_BE_OFF);
-			}
-		}
-		break;
-	case Fuse::FUSE_WENT_OFF:
-		//Not so good, because PCDU reacted.
-	case Fuse::POWER_ABOVE_HIGH_LIMIT:
-		//Better, because software detected over-current.
-		setFaulty(event->getEvent());
-		break;
-	case Fuse::POWER_BELOW_LOW_LIMIT:
-		//Device might got stuck during boot, retry.
-		handleRecovery(event->getEvent());
-		break;
-		//****Thermal*****
-	case ThermalComponentIF::COMPONENT_TEMP_LOW:
-	case ThermalComponentIF::COMPONENT_TEMP_HIGH:
-	case ThermalComponentIF::COMPONENT_TEMP_OOL_LOW:
-	case ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH:
-		//Well, the device is not really faulty, but it is required to stay off as long as possible.
-		setFaulty(event->getEvent());
-		break;
-	case ThermalComponentIF::TEMP_NOT_IN_OP_RANGE:
-		//Ignore, is information only.
-		break;
-		//*******Default monitoring variables. Are currently not used.*****
-//	case DeviceHandlerIF::MONITORING_LIMIT_EXCEEDED:
-//		setFaulty(event->getEvent());
-//		break;
-//	case DeviceHandlerIF::MONITORING_AMBIGUOUS:
-//		break;
-	default:
-		//We don't know the event, someone else should handle it.
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void DeviceHandlerFailureIsolation::eventConfirmed(EventMessage* event) {
-	switch (event->getEvent()) {
-	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
-	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
-	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
-		if (missedReplyCount.incrementAndCheck()) {
-			handleRecovery(event->getEvent());
-		}
-		break;
-	case PowerSwitchIF::SWITCH_WENT_OFF:
-		//This means the switch went off only for one device.
-		handleRecovery(event->getEvent());
-		break;
-	default:
-		break;
-	}
-}
-
-void DeviceHandlerFailureIsolation::decrementFaultCounters() {
-	strangeReplyCount.checkForDecrement();
-	missedReplyCount.checkForDecrement();
-	recoveryCounter.checkForDecrement();
-}
-
-void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
-	clearFaultCounters();
-	if (not recoveryCounter.incrementAndCheck()) {
-		startRecovery(reason);
-	} else {
-		setFaulty(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?
-	//Same issue in TxFailureIsolation!
-//	if ((event->getEvent() == PowerSwitchIF::SWITCH_WENT_OFF)
-//			&& (fdirState != RECOVERY_ONGOING)) {
-//		setFdirState(NONE);
-//	}
-}
-
-void DeviceHandlerFailureIsolation::clearFaultCounters() {
-	strangeReplyCount.clear();
-	missedReplyCount.clear();
-}
-
-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 != nullptr) {
-		powerConfirmation = power->getEventReceptionQueue();
-		hasPowerConfirmation = true;
-	}
-
-	return RETURN_OK;
-}
-
-void DeviceHandlerFailureIsolation::setFdirState(FDIRState state) {
-	FailureIsolationBase::throwFdirEvent(FDIR_CHANGED_STATE, state, fdirState);
-	fdirState = state;
-}
-
-void DeviceHandlerFailureIsolation::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	//Do not throw error events if fdirState != none.
-	//This will still forward MODE and HEALTH INFO events in any case.
-	if (fdirState == NONE || EVENT::getSeverity(event) == SEVERITY::INFO) {
-		FailureIsolationBase::triggerEvent(event, parameter1, parameter2);
-	}
-}
-
-bool DeviceHandlerFailureIsolation::isFdirActionInProgress() {
-	return (fdirState != NONE);
-}
-
-void DeviceHandlerFailureIsolation::startRecovery(Event reason) {
-	throwFdirEvent(FDIR_STARTS_RECOVERY, EVENT::getEventId(reason));
-	setOwnerHealth(HasHealthIF::NEEDS_RECOVERY);
-	setFdirState(RECOVERY_ONGOING);
-}
-
-ReturnValue_t DeviceHandlerFailureIsolation::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = strangeReplyCount.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = missedReplyCount.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = recoveryCounter.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	return INVALID_DOMAIN_ID;
-}
-
-void DeviceHandlerFailureIsolation::setFaulty(Event reason) {
-	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, EVENT::getEventId(reason));
-	setOwnerHealth(HasHealthIF::FAULTY);
-	setFdirState(AWAIT_SHUTDOWN);
-}
-
-bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
-		EventMessage* event) {
-	if (fdirState != NONE) {
-		//Only wait for those events, ignore all others.
-		if (event->getParameter1() == HasHealthIF::HEALTHY
-				&& event->getEvent() == HasHealthIF::HEALTH_INFO) {
-			setFdirState(NONE);
-		}
-		if (event->getEvent() == HasModesIF::MODE_INFO
-				&& fdirState != RECOVERY_ONGOING) {
-			setFdirState(NONE);
-		}
-		return true;
-	}
-	if (owner->getHealth() == HasHealthIF::FAULTY
-			|| owner->getHealth() == HasHealthIF::PERMANENT_FAULTY) {
-		//Ignore all events in case device is already faulty.
-		return true;
-	}
-	return false;
-}
+#include "../devicehandlers/DeviceHandlerBase.h"
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+#include "../health/HealthTableIF.h"
+#include "../power/Fuse.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../thermal/ThermalComponentIF.h"
+
+object_id_t DeviceHandlerFailureIsolation::powerConfirmationId = 0;
+
+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() {
+}
+
+ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event) {
+	if(isFdirInActionOrAreWeFaulty(event)) {
+		return RETURN_OK;
+	}
+	ReturnValue_t result = RETURN_FAILED;
+	switch (event->getEvent()) {
+	case HasModesIF::MODE_TRANSITION_FAILED:
+	case HasModesIF::OBJECT_IN_INVALID_MODE:
+		//We'll try a recovery as long as defined in MAX_REBOOT.
+		//Might cause some AssemblyBase cycles, so keep number low.
+		handleRecovery(event->getEvent());
+		break;
+	case DeviceHandlerIF::DEVICE_INTERPRETING_REPLY_FAILED:
+	case DeviceHandlerIF::DEVICE_READING_REPLY_FAILED:
+	case DeviceHandlerIF::DEVICE_UNREQUESTED_REPLY:
+	case DeviceHandlerIF::DEVICE_UNKNOWN_REPLY: //Some DH's generate generic reply-ids.
+	case DeviceHandlerIF::DEVICE_BUILDING_COMMAND_FAILED:
+		//These faults all mean that there were stupid replies from a device.
+		if (strangeReplyCount.incrementAndCheck()) {
+			handleRecovery(event->getEvent());
+		}
+		break;
+	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
+	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
+		//The two above should never be confirmed.
+	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
+		result = sendConfirmationRequest(event);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+		//else
+		if (missedReplyCount.incrementAndCheck()) {
+			handleRecovery(event->getEvent());
+		}
+		break;
+	case StorageManagerIF::GET_DATA_FAILED:
+	case StorageManagerIF::STORE_DATA_FAILED:
+		//Rather strange bugs, occur in RAW mode only. Ignore.
+		break;
+	case DeviceHandlerIF::INVALID_DEVICE_COMMAND:
+		//Ignore, is bad configuration. We can't do anything in flight.
+		break;
+	case HasHealthIF::HEALTH_INFO:
+	case HasModesIF::MODE_INFO:
+	case HasModesIF::CHANGING_MODE:
+		//Do nothing, but mark as handled.
+		break;
+		//****Power*****
+	case PowerSwitchIF::SWITCH_WENT_OFF:
+		if(hasPowerConfirmation) {
+			result = sendConfirmationRequest(event, powerConfirmation);
+			if (result == RETURN_OK) {
+				setFdirState(DEVICE_MIGHT_BE_OFF);
+			}
+		}
+		break;
+	case Fuse::FUSE_WENT_OFF:
+		//Not so good, because PCDU reacted.
+	case Fuse::POWER_ABOVE_HIGH_LIMIT:
+		//Better, because software detected over-current.
+		setFaulty(event->getEvent());
+		break;
+	case Fuse::POWER_BELOW_LOW_LIMIT:
+		//Device might got stuck during boot, retry.
+		handleRecovery(event->getEvent());
+		break;
+		//****Thermal*****
+	case ThermalComponentIF::COMPONENT_TEMP_LOW:
+	case ThermalComponentIF::COMPONENT_TEMP_HIGH:
+	case ThermalComponentIF::COMPONENT_TEMP_OOL_LOW:
+	case ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH:
+		//Well, the device is not really faulty, but it is required to stay off as long as possible.
+		setFaulty(event->getEvent());
+		break;
+	case ThermalComponentIF::TEMP_NOT_IN_OP_RANGE:
+		//Ignore, is information only.
+		break;
+		//*******Default monitoring variables. Are currently not used.*****
+//	case DeviceHandlerIF::MONITORING_LIMIT_EXCEEDED:
+//		setFaulty(event->getEvent());
+//		break;
+//	case DeviceHandlerIF::MONITORING_AMBIGUOUS:
+//		break;
+	default:
+		//We don't know the event, someone else should handle it.
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void DeviceHandlerFailureIsolation::eventConfirmed(EventMessage* event) {
+	switch (event->getEvent()) {
+	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
+	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
+	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
+		if (missedReplyCount.incrementAndCheck()) {
+			handleRecovery(event->getEvent());
+		}
+		break;
+	case PowerSwitchIF::SWITCH_WENT_OFF:
+		//This means the switch went off only for one device.
+		handleRecovery(event->getEvent());
+		break;
+	default:
+		break;
+	}
+}
+
+void DeviceHandlerFailureIsolation::decrementFaultCounters() {
+	strangeReplyCount.checkForDecrement();
+	missedReplyCount.checkForDecrement();
+	recoveryCounter.checkForDecrement();
+}
+
+void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
+	clearFaultCounters();
+	if (not recoveryCounter.incrementAndCheck()) {
+		startRecovery(reason);
+	} else {
+		setFaulty(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?
+	//Same issue in TxFailureIsolation!
+//	if ((event->getEvent() == PowerSwitchIF::SWITCH_WENT_OFF)
+//			&& (fdirState != RECOVERY_ONGOING)) {
+//		setFdirState(NONE);
+//	}
+}
+
+void DeviceHandlerFailureIsolation::clearFaultCounters() {
+	strangeReplyCount.clear();
+	missedReplyCount.clear();
+}
+
+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 != nullptr) {
+		powerConfirmation = power->getEventReceptionQueue();
+		hasPowerConfirmation = true;
+	}
+
+	return RETURN_OK;
+}
+
+void DeviceHandlerFailureIsolation::setFdirState(FDIRState state) {
+	FailureIsolationBase::throwFdirEvent(FDIR_CHANGED_STATE, state, fdirState);
+	fdirState = state;
+}
+
+void DeviceHandlerFailureIsolation::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	//Do not throw error events if fdirState != none.
+	//This will still forward MODE and HEALTH INFO events in any case.
+	if (fdirState == NONE || EVENT::getSeverity(event) == SEVERITY::INFO) {
+		FailureIsolationBase::triggerEvent(event, parameter1, parameter2);
+	}
+}
+
+bool DeviceHandlerFailureIsolation::isFdirActionInProgress() {
+	return (fdirState != NONE);
+}
+
+void DeviceHandlerFailureIsolation::startRecovery(Event reason) {
+	throwFdirEvent(FDIR_STARTS_RECOVERY, EVENT::getEventId(reason));
+	setOwnerHealth(HasHealthIF::NEEDS_RECOVERY);
+	setFdirState(RECOVERY_ONGOING);
+}
+
+ReturnValue_t DeviceHandlerFailureIsolation::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	ReturnValue_t result = strangeReplyCount.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = missedReplyCount.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = recoveryCounter.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	return INVALID_DOMAIN_ID;
+}
+
+void DeviceHandlerFailureIsolation::setFaulty(Event reason) {
+	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, EVENT::getEventId(reason));
+	setOwnerHealth(HasHealthIF::FAULTY);
+	setFdirState(AWAIT_SHUTDOWN);
+}
+
+bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
+		EventMessage* event) {
+	if (fdirState != NONE) {
+		//Only wait for those events, ignore all others.
+		if (event->getParameter1() == HasHealthIF::HEALTHY
+				&& event->getEvent() == HasHealthIF::HEALTH_INFO) {
+			setFdirState(NONE);
+		}
+		if (event->getEvent() == HasModesIF::MODE_INFO
+				&& fdirState != RECOVERY_ONGOING) {
+			setFdirState(NONE);
+		}
+		return true;
+	}
+	if (owner->getHealth() == HasHealthIF::FAULTY
+			|| owner->getHealth() == HasHealthIF::PERMANENT_FAULTY) {
+		//Ignore all events in case device is already faulty.
+		return true;
+	}
+	return false;
+}
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.h b/devicehandlers/DeviceHandlerFailureIsolation.h
index 4343d88bd..25247a8d0 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.h
+++ b/devicehandlers/DeviceHandlerFailureIsolation.h
@@ -1,54 +1,54 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
-#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
-
-#include <framework/fdir/FaultCounter.h>
-#include <framework/fdir/FailureIsolationBase.h>
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-
-class DeviceHandlerFailureIsolation: public FailureIsolationBase {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-	friend class Heater;
-public:
-	DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent);
-	~DeviceHandlerFailureIsolation();
-	ReturnValue_t initialize();
-	void triggerEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);bool isFdirActionInProgress();
-	virtual ReturnValue_t getParameter(uint8_t domainId, 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;
-	bool hasPowerConfirmation = false;
-	MessageQueueId_t powerConfirmation;
-	static object_id_t powerConfirmationId;
-	// TODO: Are those hardcoded value? How can they be changed.
-	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;
-	virtual ReturnValue_t eventReceived(EventMessage* event);
-	virtual void eventConfirmed(EventMessage* event);
-	void wasParentsFault(EventMessage* event);
-	void decrementFaultCounters();
-	void handleRecovery(Event reason);
-	virtual void clearFaultCounters();
-	void setFdirState(FDIRState state);
-	void startRecovery(Event reason);
-	void setFaulty(Event reason);
-
-	bool isFdirInActionOrAreWeFaulty(EventMessage* event);
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+
+#include "../fdir/FaultCounter.h"
+#include "../fdir/FailureIsolationBase.h"
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+
+class DeviceHandlerFailureIsolation: public FailureIsolationBase {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+	friend class Heater;
+public:
+	DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent);
+	~DeviceHandlerFailureIsolation();
+	ReturnValue_t initialize();
+	void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);bool isFdirActionInProgress();
+	virtual ReturnValue_t getParameter(uint8_t domainId, 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;
+	bool hasPowerConfirmation = false;
+	MessageQueueId_t powerConfirmation;
+	static object_id_t powerConfirmationId;
+	// TODO: Are those hardcoded value? How can they be changed.
+	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;
+	virtual ReturnValue_t eventReceived(EventMessage* event);
+	virtual void eventConfirmed(EventMessage* event);
+	void wasParentsFault(EventMessage* event);
+	void decrementFaultCounters();
+	void handleRecovery(Event reason);
+	virtual void clearFaultCounters();
+	void setFdirState(FDIRState state);
+	void startRecovery(Event reason);
+	void setFaulty(Event reason);
+
+	bool isFdirInActionOrAreWeFaulty(EventMessage* event);
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 593020808..67ab37f71 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,155 +1,155 @@
-#ifndef DEVICEHANDLERIF_H_
-#define DEVICEHANDLERIF_H_
-
-#include <framework/action/HasActionsIF.h>
-#include <framework/devicehandlers/DeviceHandlerMessage.h>
-#include <framework/events/Event.h>
-#include <framework/modes/HasModesIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-/**
- * @brief 	This is the Interface used to communicate with a device handler.
- * @details Includes all expected return values, events and modes.
- *
- */
-class DeviceHandlerIF {
-public:
-
-	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
-	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
-
-	/**
-	 * @brief This is the mode the <strong>device handler</strong> is in.
-	 *
-	 * @details The mode of the device handler must not be confused with the mode the device is in.
-	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
-	 * MODE_ON and MODE_OFF are included in hasModesIF.h
-	 */
-
-	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	//! The device is powered on and the device handler periodically sends
-	//! commands. The commands to be sent are selected by the handler
-	//! according to the submode.
-	static const Mode_t MODE_NORMAL = 2;
-	//! The device is powered on and ready to perform operations. In this mode,
-	//! raw commands can be sent. The device handler will send all replies
-	//! received from the command back to the commanding object.
-	static const Mode_t MODE_RAW = 3;
-	//! The device is shut down but the switch could not be turned off, so the
-	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
-	//! can be commanded, which tries to switch off the device again.
-	static const Mode_t MODE_ERROR_ON = 4;
-	//! This is a transitional state which can not be commanded. The device
-	//! handler performs all commands to get the device in a state ready to
-	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
-	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
-	//! This is a transitional state which can not be commanded.
-	//! The device handler performs all actions and commands to get the device
-	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
-	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
-	//! transition if available.
-	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
-	//! It is possible to set the mode to _MODE_TO_ON to use the to on
-	//! transition if available.
-	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
-	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
-	//! transition if available.
-	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
-	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
-	//! transition if available.
-	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
-	//! This is a transitional state which can not be commanded.
-	//! The device is shut down and ready to be switched off.
-	//! After the command to set the switch off has been sent,
-	//! the mode changes to @c MODE_WAIT_OFF
-	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
-	//! This is a transitional state which can not be commanded. The device
-	//! will be switched on in this state. After the command to set the switch
-	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
-	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
-	//! This is a transitional state which can not be commanded. The switch has
-	//! been commanded off and the handler waits for it to be off.
-	//! When the switch is off, the mode changes to @c MODE_OFF.
-	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
-	//! This is a transitional state which can not be commanded. The switch
-	//! has been commanded on and the handler waits for it to be on.
-	//! When the switch is on, the mode changes to @c MODE_TO_ON.
-	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
-	//! This is a transitional state which can not be commanded. The switch has
-	//! been commanded off and is off now. This state is only to do an RMAP
-	//! cycle once more where the doSendRead() function will set the mode to
-	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
-	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
-	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
-	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
-	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
-	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
-	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
-	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
-
-	// Standard codes used when building commands.
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
-	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
-	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
-	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
-	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA4);
-	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
-	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
-	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
-	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
-
-	// Standard codes used in scanForReply
-	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB0);
-	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB1);
-	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB2);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB3);
-
-	// Standard codes used in  interpretDeviceReply
-	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
-	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
-	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
-	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
-
-	// Standard codes used in buildCommandFromCommand
-	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
-	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
-
-	/**
-	 * Communication action that will be executed.
-	 *
-	 * This is used by the child class to tell the base class what to do.
-	 */
-	enum CommunicationAction_t: uint8_t {
-		SEND_WRITE,//!< Send write
-		GET_WRITE, //!< Get write
-		SEND_READ, //!< Send read
-		GET_READ,  //!< Get read
-		NOTHING    //!< Do nothing.
-	};
-
-	/**
-	 * Default Destructor
-	 */
-	virtual ~DeviceHandlerIF() {}
-
-	/**
-	 * This MessageQueue is used to command the device handler.
-	 * @return the id of the MessageQueue
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-
-};
-
-#endif /* DEVICEHANDLERIF_H_ */
+#ifndef DEVICEHANDLERIF_H_
+#define DEVICEHANDLERIF_H_
+
+#include "../action/HasActionsIF.h"
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../events/Event.h"
+#include "../modes/HasModesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * @brief 	This is the Interface used to communicate with a device handler.
+ * @details Includes all expected return values, events and modes.
+ *
+ */
+class DeviceHandlerIF {
+public:
+
+	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
+	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
+
+	/**
+	 * @brief This is the mode the <strong>device handler</strong> is in.
+	 *
+	 * @details The mode of the device handler must not be confused with the mode the device is in.
+	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
+	 * MODE_ON and MODE_OFF are included in hasModesIF.h
+	 */
+
+	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	//! The device is powered on and the device handler periodically sends
+	//! commands. The commands to be sent are selected by the handler
+	//! according to the submode.
+	static const Mode_t MODE_NORMAL = 2;
+	//! The device is powered on and ready to perform operations. In this mode,
+	//! raw commands can be sent. The device handler will send all replies
+	//! received from the command back to the commanding object.
+	static const Mode_t MODE_RAW = 3;
+	//! The device is shut down but the switch could not be turned off, so the
+	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
+	//! can be commanded, which tries to switch off the device again.
+	static const Mode_t MODE_ERROR_ON = 4;
+	//! This is a transitional state which can not be commanded. The device
+	//! handler performs all commands to get the device in a state ready to
+	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
+	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
+	//! This is a transitional state which can not be commanded.
+	//! The device handler performs all actions and commands to get the device
+	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
+	//! transition if available.
+	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
+	//! It is possible to set the mode to _MODE_TO_ON to use the to on
+	//! transition if available.
+	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
+	//! transition if available.
+	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
+	//! transition if available.
+	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
+	//! This is a transitional state which can not be commanded.
+	//! The device is shut down and ready to be switched off.
+	//! After the command to set the switch off has been sent,
+	//! the mode changes to @c MODE_WAIT_OFF
+	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
+	//! This is a transitional state which can not be commanded. The device
+	//! will be switched on in this state. After the command to set the switch
+	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
+	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and the handler waits for it to be off.
+	//! When the switch is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
+	//! This is a transitional state which can not be commanded. The switch
+	//! has been commanded on and the handler waits for it to be on.
+	//! When the switch is on, the mode changes to @c MODE_TO_ON.
+	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and is off now. This state is only to do an RMAP
+	//! cycle once more where the doSendRead() function will set the mode to
+	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
+	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
+	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
+	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
+	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
+	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
+	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
+	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
+
+	// Standard codes used when building commands.
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
+	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
+	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
+	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
+	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
+	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
+	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
+
+	// Standard codes used in scanForReply
+	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB0);
+	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB2);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB3);
+
+	// Standard codes used in  interpretDeviceReply
+	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
+	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
+	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
+
+	// Standard codes used in buildCommandFromCommand
+	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
+	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
+
+	/**
+	 * Communication action that will be executed.
+	 *
+	 * This is used by the child class to tell the base class what to do.
+	 */
+	enum CommunicationAction_t: uint8_t {
+		SEND_WRITE,//!< Send write
+		GET_WRITE, //!< Get write
+		SEND_READ, //!< Send read
+		GET_READ,  //!< Get read
+		NOTHING    //!< Do nothing.
+	};
+
+	/**
+	 * Default Destructor
+	 */
+	virtual ~DeviceHandlerIF() {}
+
+	/**
+	 * This MessageQueue is used to command the device handler.
+	 * @return the id of the MessageQueue
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+};
+
+#endif /* DEVICEHANDLERIF_H_ */
diff --git a/devicehandlers/DeviceHandlerMessage.cpp b/devicehandlers/DeviceHandlerMessage.cpp
index 97abcac52..95e5ae0c0 100644
--- a/devicehandlers/DeviceHandlerMessage.cpp
+++ b/devicehandlers/DeviceHandlerMessage.cpp
@@ -1,101 +1,101 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/devicehandlers/DeviceHandlerMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-DeviceHandlerMessage::DeviceHandlerMessage() {
-}
-
-store_address_t DeviceHandlerMessage::getStoreAddress(
-		const CommandMessage* message) {
-	return store_address_t(message->getParameter2());
-}
-
-uint32_t DeviceHandlerMessage::getDeviceCommandId(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-object_id_t DeviceHandlerMessage::getIoBoardObjectId(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-uint8_t DeviceHandlerMessage::getWiretappingMode(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
-//		CommandMessage* message, DeviceCommandId_t deviceCommand,
-//		store_address_t commandParametersStoreId) {
-//	message->setCommand(CMD_DIRECT);
-//	message->setParameter(deviceCommand);
-//	message->setParameter2(commandParametersStoreId.raw);
-//}
-
-void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
-		CommandMessage* message, store_address_t rawPacketStoreId) {
-	message->setCommand(CMD_RAW);
-	message->setParameter2(rawPacketStoreId.raw);
-}
-
-void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
-		CommandMessage* message, uint8_t wiretappingMode) {
-	message->setCommand(CMD_WIRETAPPING);
-	message->setParameter(wiretappingMode);
-}
-
-void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
-		CommandMessage* message, uint32_t ioBoardIdentifier) {
-	message->setCommand(CMD_SWITCH_ADDRESS);
-	message->setParameter(ioBoardIdentifier);
-}
-
-object_id_t DeviceHandlerMessage::getDeviceObjectId(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-void DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(
-		CommandMessage* message, object_id_t deviceObjectid,
-		store_address_t rawPacketStoreId, bool isCommand) {
-	if (isCommand) {
-		message->setCommand(REPLY_RAW_COMMAND);
-	} else {
-		message->setCommand(REPLY_RAW_REPLY);
-	}
-	message->setParameter(deviceObjectid);
-	message->setParameter2(rawPacketStoreId.raw);
-}
-
-void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
-		CommandMessage* message, object_id_t deviceObjectid,
-		store_address_t commandParametersStoreId) {
-	message->setCommand(REPLY_DIRECT_COMMAND_DATA);
-	message->setParameter(deviceObjectid);
-	message->setParameter2(commandParametersStoreId.raw);
-}
-
-void DeviceHandlerMessage::clear(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case CMD_RAW:
-//	case CMD_DIRECT:
-	case REPLY_RAW_COMMAND:
-	case REPLY_RAW_REPLY:
-	case REPLY_DIRECT_COMMAND_DATA: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreAddress(message));
-		}
-	}
-		/* NO BREAK falls through*/
-	case CMD_SWITCH_ADDRESS:
-	case CMD_WIRETAPPING:
-		message->setCommand(CommandMessage::CMD_NONE);
-		message->setParameter(0);
-		message->setParameter2(0);
-		break;
-	}
-
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+DeviceHandlerMessage::DeviceHandlerMessage() {
+}
+
+store_address_t DeviceHandlerMessage::getStoreAddress(
+		const CommandMessage* message) {
+	return store_address_t(message->getParameter2());
+}
+
+uint32_t DeviceHandlerMessage::getDeviceCommandId(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+object_id_t DeviceHandlerMessage::getIoBoardObjectId(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+uint8_t DeviceHandlerMessage::getWiretappingMode(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
+//		CommandMessage* message, DeviceCommandId_t deviceCommand,
+//		store_address_t commandParametersStoreId) {
+//	message->setCommand(CMD_DIRECT);
+//	message->setParameter(deviceCommand);
+//	message->setParameter2(commandParametersStoreId.raw);
+//}
+
+void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
+		CommandMessage* message, store_address_t rawPacketStoreId) {
+	message->setCommand(CMD_RAW);
+	message->setParameter2(rawPacketStoreId.raw);
+}
+
+void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
+		CommandMessage* message, uint8_t wiretappingMode) {
+	message->setCommand(CMD_WIRETAPPING);
+	message->setParameter(wiretappingMode);
+}
+
+void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
+		CommandMessage* message, uint32_t ioBoardIdentifier) {
+	message->setCommand(CMD_SWITCH_ADDRESS);
+	message->setParameter(ioBoardIdentifier);
+}
+
+object_id_t DeviceHandlerMessage::getDeviceObjectId(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+void DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(
+		CommandMessage* message, object_id_t deviceObjectid,
+		store_address_t rawPacketStoreId, bool isCommand) {
+	if (isCommand) {
+		message->setCommand(REPLY_RAW_COMMAND);
+	} else {
+		message->setCommand(REPLY_RAW_REPLY);
+	}
+	message->setParameter(deviceObjectid);
+	message->setParameter2(rawPacketStoreId.raw);
+}
+
+void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
+		CommandMessage* message, object_id_t deviceObjectid,
+		store_address_t commandParametersStoreId) {
+	message->setCommand(REPLY_DIRECT_COMMAND_DATA);
+	message->setParameter(deviceObjectid);
+	message->setParameter2(commandParametersStoreId.raw);
+}
+
+void DeviceHandlerMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_RAW:
+//	case CMD_DIRECT:
+	case REPLY_RAW_COMMAND:
+	case REPLY_RAW_REPLY:
+	case REPLY_DIRECT_COMMAND_DATA: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreAddress(message));
+		}
+	}
+		/* NO BREAK falls through*/
+	case CMD_SWITCH_ADDRESS:
+	case CMD_WIRETAPPING:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+	}
+
+}
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index 2bdf03b22..6b54392be 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -1,91 +1,91 @@
-#ifndef DEVICEHANDLERMESSAGE_H_
-#define DEVICEHANDLERMESSAGE_H_
-
-#include <framework/action/ActionMessage.h>
-#include <framework/ipc/CommandMessage.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
-
-/**
- * This is used to uniquely identify commands that are sent to a device
- *
- * The values are defined in the device-specific implementations
- */
-typedef uint32_t DeviceCommandId_t;
-
-/**
- * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
- */
-class DeviceHandlerMessage {
-private:
-	DeviceHandlerMessage();
-public:
-
-	/**
-	 * These are the commands that can be sent to a DeviceHandlerBase
-	 */
-	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_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
-	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
-
-	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
-	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
-	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
-
-	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
-
-	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
-	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
-	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
-	 */
-	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
-	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
-	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
-	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
-
-	/**
-	 * Default Destructor
-	 */
-	virtual ~DeviceHandlerMessage() {
-	}
-
-	static store_address_t getStoreAddress(const CommandMessage* message);
-	static uint32_t getDeviceCommandId(const CommandMessage* message);
-	static object_id_t getDeviceObjectId(const CommandMessage *message);
-	static object_id_t getIoBoardObjectId(const CommandMessage* message);
-	static uint8_t getWiretappingMode(const CommandMessage* message);
-
-//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
-//			DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-
-	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
-			object_id_t deviceObjectid,
-			store_address_t commandParametersStoreId);
-
-	static void setDeviceHandlerRawCommandMessage(CommandMessage* message,
-			store_address_t rawPacketStoreId);
-
-	static void setDeviceHandlerRawReplyMessage(CommandMessage* message,
-			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
-			bool isCommand);
-
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, store_address_t rawPacketStoreId);
-	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
-			uint8_t wiretappingMode);
-	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
-			object_id_t ioBoardIdentifier);
-
-	static void clear(CommandMessage* message);
-};
-
-#endif /* DEVICEHANDLERMESSAGE_H_ */
+#ifndef DEVICEHANDLERMESSAGE_H_
+#define DEVICEHANDLERMESSAGE_H_
+
+#include "../action/ActionMessage.h"
+#include "../ipc/CommandMessage.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
+
+/**
+ * This is used to uniquely identify commands that are sent to a device
+ *
+ * The values are defined in the device-specific implementations
+ */
+typedef uint32_t DeviceCommandId_t;
+
+/**
+ * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
+ */
+class DeviceHandlerMessage {
+private:
+	DeviceHandlerMessage();
+public:
+
+	/**
+	 * These are the commands that can be sent to a DeviceHandlerBase
+	 */
+	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_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
+
+	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
+	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
+	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
+
+	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
+	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
+	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
+
+	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
+	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
+	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
+	 */
+	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
+	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
+	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
+	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
+
+	/**
+	 * Default Destructor
+	 */
+	virtual ~DeviceHandlerMessage() {
+	}
+
+	static store_address_t getStoreAddress(const CommandMessage* message);
+	static uint32_t getDeviceCommandId(const CommandMessage* message);
+	static object_id_t getDeviceObjectId(const CommandMessage *message);
+	static object_id_t getIoBoardObjectId(const CommandMessage* message);
+	static uint8_t getWiretappingMode(const CommandMessage* message);
+
+//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
+//			DeviceCommandId_t deviceCommand,
+//			store_address_t commandParametersStoreId);
+
+	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
+			object_id_t deviceObjectid,
+			store_address_t commandParametersStoreId);
+
+	static void setDeviceHandlerRawCommandMessage(CommandMessage* message,
+			store_address_t rawPacketStoreId);
+
+	static void setDeviceHandlerRawReplyMessage(CommandMessage* message,
+			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
+			bool isCommand);
+
+//	static void setDeviceHandlerMessage(CommandMessage* message,
+//			Command_t command, DeviceCommandId_t deviceCommand,
+//			store_address_t commandParametersStoreId);
+//	static void setDeviceHandlerMessage(CommandMessage* message,
+//			Command_t command, store_address_t rawPacketStoreId);
+	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
+			uint8_t wiretappingMode);
+	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
+			object_id_t ioBoardIdentifier);
+
+	static void clear(CommandMessage* message);
+};
+
+#endif /* DEVICEHANDLERMESSAGE_H_ */
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index ce5eb1094..f19b02e9b 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -1,46 +1,46 @@
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId,
-		ActionId_t actionId, SerializeIF* data) :
-		objectId(objectId), actionId(actionId), data(data) {
-}
-
-DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
-
-}
-
-ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
-			buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&actionId, buffer,
-			size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return data->serialize(buffer, size, maxSize, streamEndianness);
-}
-
-size_t DeviceTmReportingWrapper::getSerializedSize() const {
-	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
-}
-
-ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
-			buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::deSerialize(&actionId, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return data->deSerialize(buffer, size, streamEndianness);
-}
+#include "../serialize/SerializeAdapter.h"
+#include "../devicehandlers/DeviceTmReportingWrapper.h"
+#include "../serialize/SerializeAdapter.h"
+
+DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId,
+		ActionId_t actionId, SerializeIF* data) :
+		objectId(objectId), actionId(actionId), data(data) {
+}
+
+DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
+
+}
+
+ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
+			buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&actionId, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return data->serialize(buffer, size, maxSize, streamEndianness);
+}
+
+size_t DeviceTmReportingWrapper::getSerializedSize() const {
+	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
+}
+
+ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
+			buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&actionId, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return data->deSerialize(buffer, size, streamEndianness);
+}
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index 4432b7f15..ecf7089a8 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -1,27 +1,27 @@
-#ifndef DEVICETMREPORTINGWRAPPER_H_
-#define DEVICETMREPORTINGWRAPPER_H_
-
-#include <framework/action/HasActionsIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/serialize/SerializeIF.h>
-
-class DeviceTmReportingWrapper: public SerializeIF {
-public:
-	DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId,
-			SerializeIF *data);
-	virtual ~DeviceTmReportingWrapper();
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-private:
-	object_id_t objectId;
-	ActionId_t actionId;
-	SerializeIF *data;
-};
-
-#endif /* DEVICETMREPORTINGWRAPPER_H_ */
+#ifndef DEVICETMREPORTINGWRAPPER_H_
+#define DEVICETMREPORTINGWRAPPER_H_
+
+#include "../action/HasActionsIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../serialize/SerializeIF.h"
+
+class DeviceTmReportingWrapper: public SerializeIF {
+public:
+	DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId,
+			SerializeIF *data);
+	virtual ~DeviceTmReportingWrapper();
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+private:
+	object_id_t objectId;
+	ActionId_t actionId;
+	SerializeIF *data;
+};
+
+#endif /* DEVICETMREPORTINGWRAPPER_H_ */
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 8367a6bc9..de7e4d8ca 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -1,59 +1,59 @@
-#include <framework/devicehandlers/HealthDevice.h>
-#include <framework/ipc/QueueFactory.h>
-
-HealthDevice::HealthDevice(object_id_t setObjectId,
-		MessageQueueId_t parentQueue) :
-		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
-				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
-}
-
-HealthDevice::~HealthDevice() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		healthHelper.handleHealthCommand(&command);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t HealthDevice::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (parentQueue != 0) {
-		return healthHelper.initialize(parentQueue);
-	} else {
-		return healthHelper.initialize();
-	}
-}
-
-MessageQueueId_t HealthDevice::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
-	healthHelper.setParentQueue(parentQueue);
-}
-
-bool HealthDevice::hasHealthChanged() {
-	bool changed;
-	HealthState currentHealth = healthHelper.getHealth();
-	changed = currentHealth != lastHealth;
-	lastHealth = currentHealth;
-	return changed;
-}
-
-ReturnValue_t HealthDevice::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-HasHealthIF::HealthState HealthDevice::getHealth() {
-	return healthHelper.getHealth();
-}
+#include "../devicehandlers/HealthDevice.h"
+#include "../ipc/QueueFactory.h"
+
+HealthDevice::HealthDevice(object_id_t setObjectId,
+		MessageQueueId_t parentQueue) :
+		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
+				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
+}
+
+HealthDevice::~HealthDevice() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		healthHelper.handleHealthCommand(&command);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t HealthDevice::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (parentQueue != 0) {
+		return healthHelper.initialize(parentQueue);
+	} else {
+		return healthHelper.initialize();
+	}
+}
+
+MessageQueueId_t HealthDevice::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
+	healthHelper.setParentQueue(parentQueue);
+}
+
+bool HealthDevice::hasHealthChanged() {
+	bool changed;
+	HealthState currentHealth = healthHelper.getHealth();
+	changed = currentHealth != lastHealth;
+	lastHealth = currentHealth;
+	return changed;
+}
+
+ReturnValue_t HealthDevice::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState HealthDevice::getHealth() {
+	return healthHelper.getHealth();
+}
diff --git a/devicehandlers/HealthDevice.h b/devicehandlers/HealthDevice.h
index ffb9e5bd6..fb38584ea 100644
--- a/devicehandlers/HealthDevice.h
+++ b/devicehandlers/HealthDevice.h
@@ -1,40 +1,40 @@
-#ifndef HEALTHDEVICE_H_
-#define HEALTHDEVICE_H_
-
-#include <framework/health/HasHealthIF.h>
-#include <framework/health/HealthHelper.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-class HealthDevice: public SystemObject,
-		public ExecutableObjectIF,
-		public HasHealthIF {
-public:
-	HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue);
-	virtual ~HealthDevice();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	ReturnValue_t initialize();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	void setParentQueue(MessageQueueId_t parentQueue);
-
-	bool hasHealthChanged();
-
-	virtual ReturnValue_t setHealth(HealthState health);
-
-	virtual HealthState getHealth();
-
-protected:
-	HealthState lastHealth;
-
-	MessageQueueId_t parentQueue;
-	MessageQueueIF* commandQueue;
-public:
-	HealthHelper healthHelper;
-};
-
-#endif /* HEALTHDEVICE_H_ */
+#ifndef HEALTHDEVICE_H_
+#define HEALTHDEVICE_H_
+
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class HealthDevice: public SystemObject,
+		public ExecutableObjectIF,
+		public HasHealthIF {
+public:
+	HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue);
+	virtual ~HealthDevice();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	ReturnValue_t initialize();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	void setParentQueue(MessageQueueId_t parentQueue);
+
+	bool hasHealthChanged();
+
+	virtual ReturnValue_t setHealth(HealthState health);
+
+	virtual HealthState getHealth();
+
+protected:
+	HealthState lastHealth;
+
+	MessageQueueId_t parentQueue;
+	MessageQueueIF* commandQueue;
+public:
+	HealthHelper healthHelper;
+};
+
+#endif /* HEALTHDEVICE_H_ */
diff --git a/events/Event.cpp b/events/Event.cpp
index 9ea9f552b..a94ae6db3 100644
--- a/events/Event.cpp
+++ b/events/Event.cpp
@@ -1,14 +1,14 @@
-#include <framework/events/Event.h>
-namespace EVENT {
-EventId_t getEventId(Event event) {
-	return (event & 0xFFFF);
-}
-
-EventSeverity_t getSeverity(Event event) {
-	return ((event >> 16) & 0xFF);
-}
-
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity) {
-	return (eventSeverity << 16) + (eventId & 0xFFFF);
-}
-}
+#include "../events/Event.h"
+namespace EVENT {
+EventId_t getEventId(Event event) {
+	return (event & 0xFFFF);
+}
+
+EventSeverity_t getSeverity(Event event) {
+	return ((event >> 16) & 0xFF);
+}
+
+Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity) {
+	return (eventSeverity << 16) + (eventId & 0xFFFF);
+}
+}
diff --git a/events/Event.h b/events/Event.h
index 0a1cfcf2a..f613e701d 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -1,45 +1,45 @@
-#ifndef FRAMEWORK_EVENTS_EVENT_H_
-#define FRAMEWORK_EVENTS_EVENT_H_
-
-#include <cstdint>
-#include <framework/events/fwSubsystemIdRanges.h>
-//could be move to more suitable location
-#include <subsystemIdRanges.h>
-
-typedef uint16_t EventId_t;
-typedef uint8_t EventSeverity_t;
-
-#define MAKE_EVENT(id, severity) (((severity)<<16)+(SUBSYSTEM_ID*100)+(id))
-
-typedef uint32_t Event;
-
-namespace EVENT {
-EventId_t getEventId(Event event);
-
-EventSeverity_t getSeverity(Event event);
-
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
-
-}
-
-namespace SEVERITY {
-	static const EventSeverity_t INFO = 1;
-	static const EventSeverity_t LOW = 2;
-	static const EventSeverity_t MEDIUM = 3;
-	static const EventSeverity_t HIGH = 4;
-}
-
-//Unfortunately, this does not work nicely because of the inability to define static classes in headers.
-//struct Event {
-//	Event(uint8_t domain, uint8_t counter, EventSeverity_t severity) :
-//			id(domain*100+counter), severity(severity) {
-//	}
-//	EventId_t id;
-//	EventSeverity_t severity;
-//	static const EventSeverity_t INFO = 1;
-//	static const EventSeverity_t LOW = 2;
-//	static const EventSeverity_t MEDIUM = 3;
-//	static const EventSeverity_t HIGH = 4;
-//};
-
-#endif /* FRAMEWORK_EVENTS_EVENT_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENT_H_
+#define FRAMEWORK_EVENTS_EVENT_H_
+
+#include <cstdint>
+#include "../events/fwSubsystemIdRanges.h"
+//could be move to more suitable location
+#include <subsystemIdRanges.h>
+
+typedef uint16_t EventId_t;
+typedef uint8_t EventSeverity_t;
+
+#define MAKE_EVENT(id, severity) (((severity)<<16)+(SUBSYSTEM_ID*100)+(id))
+
+typedef uint32_t Event;
+
+namespace EVENT {
+EventId_t getEventId(Event event);
+
+EventSeverity_t getSeverity(Event event);
+
+Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
+
+}
+
+namespace SEVERITY {
+	static const EventSeverity_t INFO = 1;
+	static const EventSeverity_t LOW = 2;
+	static const EventSeverity_t MEDIUM = 3;
+	static const EventSeverity_t HIGH = 4;
+}
+
+//Unfortunately, this does not work nicely because of the inability to define static classes in headers.
+//struct Event {
+//	Event(uint8_t domain, uint8_t counter, EventSeverity_t severity) :
+//			id(domain*100+counter), severity(severity) {
+//	}
+//	EventId_t id;
+//	EventSeverity_t severity;
+//	static const EventSeverity_t INFO = 1;
+//	static const EventSeverity_t LOW = 2;
+//	static const EventSeverity_t MEDIUM = 3;
+//	static const EventSeverity_t HIGH = 4;
+//};
+
+#endif /* FRAMEWORK_EVENTS_EVENT_H_ */
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 04be6f68f..5848dd744 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,165 +1,165 @@
-#include <framework/events/EventManager.h>
-#include <framework/events/EventMessage.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/ipc/MutexFactory.h>
-
-
-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.
-// 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),
-		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
-	mutex = MutexFactory::instance()->createMutex();
-	eventReportQueue = QueueFactory::instance()->createMessageQueue(
-			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
-}
-
-EventManager::~EventManager() {
-	QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-MessageQueueId_t EventManager::getEventReportQueue() {
-	return eventReportQueue->getId();
-}
-
-ReturnValue_t EventManager::performOperation(uint8_t opCode) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	while (result == HasReturnvaluesIF::RETURN_OK) {
-		EventMessage message;
-		result = eventReportQueue->receiveMessage(&message);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-#ifdef DEBUG
-			printEvent(&message);
-#endif
-			notifyListeners(&message);
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void EventManager::notifyListeners(EventMessage* message) {
-	lockMutex();
-	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
-		if (iter->second.match(message)) {
-			MessageQueueSenderIF::sendMessage(iter->first, message,
-			        message->getSender());
-		}
-	}
-	unlockMutex();
-}
-
-ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
-bool forwardAllButSelected) {
-	auto result = listenerList.insert(
-			std::pair<MessageQueueId_t, EventMatchTree>(listener,
-					EventMatchTree(&factoryBackend, forwardAllButSelected)));
-	if (!result.second) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener,
-		EventId_t event) {
-	return subscribeToEventRange(listener, event);
-}
-
-ReturnValue_t EventManager::subscribeToAllEventsFrom(MessageQueueId_t listener,
-		object_id_t object) {
-	return subscribeToEventRange(listener, 0, 0, true, object);
-}
-
-ReturnValue_t EventManager::subscribeToEventRange(MessageQueueId_t listener,
-		EventId_t idFrom, EventId_t idTo, bool idInverted,
-		object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	auto iter = listenerList.find(listener);
-	if (iter == listenerList.end()) {
-		return LISTENER_NOT_FOUND;
-	}
-	lockMutex();
-	ReturnValue_t result = iter->second.addMatch(idFrom, idTo, idInverted,
-			reporterFrom, reporterTo, reporterInverted);
-	unlockMutex();
-	return result;
-}
-
-ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
-		EventId_t idFrom, EventId_t idTo, bool idInverted,
-		object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	auto iter = listenerList.find(listener);
-	if (iter == listenerList.end()) {
-		return LISTENER_NOT_FOUND;
-	}
-	lockMutex();
-	ReturnValue_t result = iter->second.removeMatch(idFrom, idTo, idInverted,
-			reporterFrom, reporterTo, reporterInverted);
-	unlockMutex();
-	return result;
-}
-
-#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:
-		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
-
-void EventManager::lockMutex() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-}
-
-void EventManager::unlockMutex() {
-	mutex->unlockMutex();
-}
+#include "../events/EventManager.h"
+#include "../events/EventMessage.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../ipc/QueueFactory.h"
+#include "../ipc/MutexFactory.h"
+
+
+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.
+// 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),
+		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
+	mutex = MutexFactory::instance()->createMutex();
+	eventReportQueue = QueueFactory::instance()->createMessageQueue(
+			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
+}
+
+EventManager::~EventManager() {
+	QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+MessageQueueId_t EventManager::getEventReportQueue() {
+	return eventReportQueue->getId();
+}
+
+ReturnValue_t EventManager::performOperation(uint8_t opCode) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	while (result == HasReturnvaluesIF::RETURN_OK) {
+		EventMessage message;
+		result = eventReportQueue->receiveMessage(&message);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+#ifdef DEBUG
+			printEvent(&message);
+#endif
+			notifyListeners(&message);
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void EventManager::notifyListeners(EventMessage* message) {
+	lockMutex();
+	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
+		if (iter->second.match(message)) {
+			MessageQueueSenderIF::sendMessage(iter->first, message,
+			        message->getSender());
+		}
+	}
+	unlockMutex();
+}
+
+ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
+bool forwardAllButSelected) {
+	auto result = listenerList.insert(
+			std::pair<MessageQueueId_t, EventMatchTree>(listener,
+					EventMatchTree(&factoryBackend, forwardAllButSelected)));
+	if (!result.second) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener,
+		EventId_t event) {
+	return subscribeToEventRange(listener, event);
+}
+
+ReturnValue_t EventManager::subscribeToAllEventsFrom(MessageQueueId_t listener,
+		object_id_t object) {
+	return subscribeToEventRange(listener, 0, 0, true, object);
+}
+
+ReturnValue_t EventManager::subscribeToEventRange(MessageQueueId_t listener,
+		EventId_t idFrom, EventId_t idTo, bool idInverted,
+		object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+	auto iter = listenerList.find(listener);
+	if (iter == listenerList.end()) {
+		return LISTENER_NOT_FOUND;
+	}
+	lockMutex();
+	ReturnValue_t result = iter->second.addMatch(idFrom, idTo, idInverted,
+			reporterFrom, reporterTo, reporterInverted);
+	unlockMutex();
+	return result;
+}
+
+ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
+		EventId_t idFrom, EventId_t idTo, bool idInverted,
+		object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+	auto iter = listenerList.find(listener);
+	if (iter == listenerList.end()) {
+		return LISTENER_NOT_FOUND;
+	}
+	lockMutex();
+	ReturnValue_t result = iter->second.removeMatch(idFrom, idTo, idInverted,
+			reporterFrom, reporterTo, reporterInverted);
+	unlockMutex();
+	return result;
+}
+
+#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:
+		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
+
+void EventManager::lockMutex() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+}
+
+void EventManager::unlockMutex() {
+	mutex->unlockMutex();
+}
diff --git a/events/EventManager.h b/events/EventManager.h
index 6fac83526..5323edd8b 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -1,61 +1,61 @@
-#ifndef EVENTMANAGER_H_
-#define EVENTMANAGER_H_
-
-#include <framework/events/eventmatching/EventMatchTree.h>
-#include <framework/events/EventManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/storagemanager/LocalPool.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MutexIF.h>
-#include <map>
-
-class EventManager: public EventManagerIF,
-		public ExecutableObjectIF,
-		public SystemObject {
-public:
-	static const uint16_t MAX_EVENTS_PER_CYCLE = 80;
-
-	EventManager(object_id_t setObjectId);
-	virtual ~EventManager();
-
-	MessageQueueId_t getEventReportQueue();
-
-	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
-	ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
-	ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
-			object_id_t object);
-	ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	ReturnValue_t performOperation(uint8_t opCode);
-protected:
-
-	MessageQueueIF* eventReportQueue = nullptr;
-
-	std::map<MessageQueueId_t, EventMatchTree> listenerList;
-
-	MutexIF* mutex = nullptr;
-
-	static const uint8_t N_POOLS = 3;
-	LocalPool<N_POOLS> factoryBackend;
-	static const uint16_t POOL_SIZES[N_POOLS];
-	static const uint16_t N_ELEMENTS[N_POOLS];
-
-	void notifyListeners(EventMessage *message);
-
-#ifdef DEBUG
-	void printEvent(EventMessage *message);
-#endif
-
-	void lockMutex();
-
-	void unlockMutex();
-};
-
-#endif /* EVENTMANAGER_H_ */
+#ifndef EVENTMANAGER_H_
+#define EVENTMANAGER_H_
+
+#include "../events/eventmatching/EventMatchTree.h"
+#include "../events/EventManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../storagemanager/LocalPool.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+class EventManager: public EventManagerIF,
+		public ExecutableObjectIF,
+		public SystemObject {
+public:
+	static const uint16_t MAX_EVENTS_PER_CYCLE = 80;
+
+	EventManager(object_id_t setObjectId);
+	virtual ~EventManager();
+
+	MessageQueueId_t getEventReportQueue();
+
+	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
+	ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
+	ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
+			object_id_t object);
+	ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t performOperation(uint8_t opCode);
+protected:
+
+	MessageQueueIF* eventReportQueue = nullptr;
+
+	std::map<MessageQueueId_t, EventMatchTree> listenerList;
+
+	MutexIF* mutex = nullptr;
+
+	static const uint8_t N_POOLS = 3;
+	LocalPool<N_POOLS> factoryBackend;
+	static const uint16_t POOL_SIZES[N_POOLS];
+	static const uint16_t N_ELEMENTS[N_POOLS];
+
+	void notifyListeners(EventMessage *message);
+
+#ifdef DEBUG
+	void printEvent(EventMessage *message);
+#endif
+
+	void lockMutex();
+
+	void unlockMutex();
+};
+
+#endif /* EVENTMANAGER_H_ */
diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h
index bc0de4329..bb36f0a31 100644
--- a/events/EventManagerIF.h
+++ b/events/EventManagerIF.h
@@ -1,52 +1,52 @@
-#ifndef EVENTMANAGERIF_H_
-#define EVENTMANAGERIF_H_
-
-#include <framework/events/eventmatching/eventmatching.h>
-#include <framework/events/EventMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class EventManagerIF {
-public:
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::EVENT_MANAGER_IF;
-	static const ReturnValue_t LISTENER_NOT_FOUND = MAKE_RETURN_CODE(1);
-	virtual ~EventManagerIF() {
-	}
-
-	virtual MessageQueueId_t getEventReportQueue() = 0;
-
-	virtual ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false) = 0;
-	virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener,
-			EventId_t event) = 0;
-	virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
-			object_id_t object) = 0;
-	virtual ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false) = 0;
-	virtual ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false) = 0;
-
-	static void triggerEvent(object_id_t reportingObject, Event event,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0, MessageQueueId_t sentFrom = 0) {
-		EventMessage message(event, reportingObject, parameter1, parameter2);
-		triggerEvent(&message, sentFrom);
-	}
-	static void triggerEvent(EventMessage* message, MessageQueueId_t sentFrom = 0) {
-		static MessageQueueId_t eventmanagerQueue = 0;
-		if (eventmanagerQueue == 0) {
-			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
-					objects::EVENT_MANAGER);
-			if (eventmanager != NULL) {
-				eventmanagerQueue = eventmanager->getEventReportQueue();
-			}
-		}
-		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
-	}
-
-};
-
-#endif /* EVENTMANAGERIF_H_ */
+#ifndef EVENTMANAGERIF_H_
+#define EVENTMANAGERIF_H_
+
+#include "../events/eventmatching/eventmatching.h"
+#include "../events/EventMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class EventManagerIF {
+public:
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::EVENT_MANAGER_IF;
+	static const ReturnValue_t LISTENER_NOT_FOUND = MAKE_RETURN_CODE(1);
+	virtual ~EventManagerIF() {
+	}
+
+	virtual MessageQueueId_t getEventReportQueue() = 0;
+
+	virtual ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false) = 0;
+	virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener,
+			EventId_t event) = 0;
+	virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
+			object_id_t object) = 0;
+	virtual ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false) = 0;
+	virtual ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false) = 0;
+
+	static void triggerEvent(object_id_t reportingObject, Event event,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0, MessageQueueId_t sentFrom = 0) {
+		EventMessage message(event, reportingObject, parameter1, parameter2);
+		triggerEvent(&message, sentFrom);
+	}
+	static void triggerEvent(EventMessage* message, MessageQueueId_t sentFrom = 0) {
+		static MessageQueueId_t eventmanagerQueue = 0;
+		if (eventmanagerQueue == 0) {
+			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
+					objects::EVENT_MANAGER);
+			if (eventmanager != NULL) {
+				eventmanagerQueue = eventmanager->getEventReportQueue();
+			}
+		}
+		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
+	}
+
+};
+
+#endif /* EVENTMANAGERIF_H_ */
diff --git a/events/EventMessage.cpp b/events/EventMessage.cpp
index f06f68c3b..28538f7f8 100644
--- a/events/EventMessage.cpp
+++ b/events/EventMessage.cpp
@@ -1,114 +1,114 @@
-#include <framework/events/EventMessage.h>
-#include <cstring>
-
-EventMessage::EventMessage() {
-	messageSize = EVENT_MESSAGE_SIZE;
-	clearEventMessage();
-}
-
-EventMessage::EventMessage(Event event, object_id_t reporter,
-		uint32_t parameter1, uint32_t parameter2) {
-	messageSize = EVENT_MESSAGE_SIZE;
-	setMessageId(EVENT_MESSAGE);
-	setEvent(event);
-	setReporter(reporter);
-	setParameter1(parameter1);
-	setParameter2(parameter2);
-}
-
-EventMessage::~EventMessage() {
-}
-
-Event EventMessage::getEvent() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return (event & 0xFFFFFF);
-}
-
-void EventMessage::setEvent(Event event) {
-	Event tempEvent;
-	memcpy(&tempEvent, getData(), sizeof(Event));
-	tempEvent = (tempEvent & 0xFF000000) + (event & 0xFFFFFF);
-	memcpy(getData(), &tempEvent, sizeof(Event));
-}
-
-uint8_t EventMessage::getMessageId() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return (event & 0xFF000000) >> 24;
-}
-
-void EventMessage::setMessageId(uint8_t id) {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	event = (event & 0x00FFFFFF) + (id << 24);
-	memcpy(getData(), &event, sizeof(Event));
-}
-
-EventSeverity_t EventMessage::getSeverity() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getSeverity(event);
-}
-
-void EventMessage::setSeverity(EventSeverity_t severity) {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	event = (event & 0xFF00FFFF) + (severity << 16);
-	memcpy(getData(), &event, sizeof(Event));
-}
-
-EventId_t EventMessage::getEventId() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getEventId(event);
-}
-
-void EventMessage::setEventId(EventId_t eventId) {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	event = (event & 0xFFFF0000) + eventId;
-	memcpy(getData(), &event, sizeof(Event));
-}
-
-object_id_t EventMessage::getReporter() {
-	object_id_t parameter;
-	memcpy(&parameter, getData() + sizeof(Event), sizeof(object_id_t));
-	return parameter;
-}
-
-void EventMessage::setReporter(object_id_t reporter) {
-	memcpy(getData() + sizeof(Event), &reporter, sizeof(object_id_t));
-}
-
-uint32_t EventMessage::getParameter1() {
-	uint32_t parameter;
-	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t), 4);
-	return parameter;
-}
-
-void EventMessage::setParameter1(uint32_t parameter) {
-	memcpy(getData() + sizeof(Event) + sizeof(object_id_t), &parameter, 4);
-}
-
-uint32_t EventMessage::getParameter2() {
-	uint32_t parameter;
-	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t) + 4, 4);
-	return parameter;
-}
-
-void EventMessage::setParameter2(uint32_t parameter) {
-	memcpy(getData() + sizeof(Event) + sizeof(object_id_t) + 4, &parameter, 4);
-}
-
-void EventMessage::clearEventMessage() {
-	setEvent(INVALID_EVENT);
-}
-
-bool EventMessage::isClearedEventMessage() {
-	return getEvent() == INVALID_EVENT;
-}
-
-size_t EventMessage::getMinimumMessageSize() {
-	return EVENT_MESSAGE_SIZE;
-}
+#include "../events/EventMessage.h"
+#include <cstring>
+
+EventMessage::EventMessage() {
+	messageSize = EVENT_MESSAGE_SIZE;
+	clearEventMessage();
+}
+
+EventMessage::EventMessage(Event event, object_id_t reporter,
+		uint32_t parameter1, uint32_t parameter2) {
+	messageSize = EVENT_MESSAGE_SIZE;
+	setMessageId(EVENT_MESSAGE);
+	setEvent(event);
+	setReporter(reporter);
+	setParameter1(parameter1);
+	setParameter2(parameter2);
+}
+
+EventMessage::~EventMessage() {
+}
+
+Event EventMessage::getEvent() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return (event & 0xFFFFFF);
+}
+
+void EventMessage::setEvent(Event event) {
+	Event tempEvent;
+	memcpy(&tempEvent, getData(), sizeof(Event));
+	tempEvent = (tempEvent & 0xFF000000) + (event & 0xFFFFFF);
+	memcpy(getData(), &tempEvent, sizeof(Event));
+}
+
+uint8_t EventMessage::getMessageId() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return (event & 0xFF000000) >> 24;
+}
+
+void EventMessage::setMessageId(uint8_t id) {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	event = (event & 0x00FFFFFF) + (id << 24);
+	memcpy(getData(), &event, sizeof(Event));
+}
+
+EventSeverity_t EventMessage::getSeverity() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return EVENT::getSeverity(event);
+}
+
+void EventMessage::setSeverity(EventSeverity_t severity) {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	event = (event & 0xFF00FFFF) + (severity << 16);
+	memcpy(getData(), &event, sizeof(Event));
+}
+
+EventId_t EventMessage::getEventId() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return EVENT::getEventId(event);
+}
+
+void EventMessage::setEventId(EventId_t eventId) {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	event = (event & 0xFFFF0000) + eventId;
+	memcpy(getData(), &event, sizeof(Event));
+}
+
+object_id_t EventMessage::getReporter() {
+	object_id_t parameter;
+	memcpy(&parameter, getData() + sizeof(Event), sizeof(object_id_t));
+	return parameter;
+}
+
+void EventMessage::setReporter(object_id_t reporter) {
+	memcpy(getData() + sizeof(Event), &reporter, sizeof(object_id_t));
+}
+
+uint32_t EventMessage::getParameter1() {
+	uint32_t parameter;
+	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t), 4);
+	return parameter;
+}
+
+void EventMessage::setParameter1(uint32_t parameter) {
+	memcpy(getData() + sizeof(Event) + sizeof(object_id_t), &parameter, 4);
+}
+
+uint32_t EventMessage::getParameter2() {
+	uint32_t parameter;
+	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t) + 4, 4);
+	return parameter;
+}
+
+void EventMessage::setParameter2(uint32_t parameter) {
+	memcpy(getData() + sizeof(Event) + sizeof(object_id_t) + 4, &parameter, 4);
+}
+
+void EventMessage::clearEventMessage() {
+	setEvent(INVALID_EVENT);
+}
+
+bool EventMessage::isClearedEventMessage() {
+	return getEvent() == INVALID_EVENT;
+}
+
+size_t EventMessage::getMinimumMessageSize() {
+	return EVENT_MESSAGE_SIZE;
+}
diff --git a/events/EventMessage.h b/events/EventMessage.h
index 9cbe33363..8769333b0 100644
--- a/events/EventMessage.h
+++ b/events/EventMessage.h
@@ -1,52 +1,52 @@
-#ifndef EVENTMESSAGE_H_
-#define EVENTMESSAGE_H_
-
-#include <framework/events/Event.h>
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-/**
- * Passing on events through IPC.
- * Event Id, severity and message type retrieval is a bit difficult.
- */
-class EventMessage: public MessageQueueMessage {
-public:
-	static const uint8_t EVENT_MESSAGE = 0; //!< Normal event
-	static const uint8_t CONFIRMATION_REQUEST = 1; //!< Request to parent if event is caused by child or not.
-	static const uint8_t YOUR_FAULT = 2; //!< The fault was caused by child, parent believes it's ok.
-	static const uint8_t MY_FAULT = 3; //!< The fault was caused by the parent, child is ok.
-	//Add other messageIDs here if necessary.
-	static const uint8_t EVENT_MESSAGE_SIZE = HEADER_SIZE + sizeof(Event)
-			+ 3 * sizeof(uint32_t);
-
-	EventMessage();
-//	EventMessage(EventId_t event, EventSeverity_t severity,
-//			object_id_t reporter, uint32_t parameter1, uint32_t parameter2 = 0);
-	EventMessage(Event event, object_id_t reporter, uint32_t parameter1,
-			uint32_t parameter2 = 0);
-	virtual ~EventMessage();
-	Event getEvent();
-	void setEvent(Event event);
-	uint8_t getMessageId();
-	void setMessageId(uint8_t id);
-	EventSeverity_t getSeverity();
-	void setSeverity(EventSeverity_t severity);
-	EventId_t getEventId();
-	void setEventId(EventId_t event);
-	object_id_t getReporter();
-	void setReporter(object_id_t reporter);
-	uint32_t getParameter1();
-	void setParameter1(uint32_t parameter);
-	uint32_t getParameter2();
-	void setParameter2(uint32_t parameter);
-
-	void clearEventMessage();
-	bool isClearedEventMessage();
-
-protected:
-	static const Event INVALID_EVENT = 0;
-	virtual size_t getMinimumMessageSize();
-
-};
-
-#endif /* EVENTMESSAGE_H_ */
+#ifndef EVENTMESSAGE_H_
+#define EVENTMESSAGE_H_
+
+#include "../events/Event.h"
+#include "../ipc/MessageQueueMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+/**
+ * Passing on events through IPC.
+ * Event Id, severity and message type retrieval is a bit difficult.
+ */
+class EventMessage: public MessageQueueMessage {
+public:
+	static const uint8_t EVENT_MESSAGE = 0; //!< Normal event
+	static const uint8_t CONFIRMATION_REQUEST = 1; //!< Request to parent if event is caused by child or not.
+	static const uint8_t YOUR_FAULT = 2; //!< The fault was caused by child, parent believes it's ok.
+	static const uint8_t MY_FAULT = 3; //!< The fault was caused by the parent, child is ok.
+	//Add other messageIDs here if necessary.
+	static const uint8_t EVENT_MESSAGE_SIZE = HEADER_SIZE + sizeof(Event)
+			+ 3 * sizeof(uint32_t);
+
+	EventMessage();
+//	EventMessage(EventId_t event, EventSeverity_t severity,
+//			object_id_t reporter, uint32_t parameter1, uint32_t parameter2 = 0);
+	EventMessage(Event event, object_id_t reporter, uint32_t parameter1,
+			uint32_t parameter2 = 0);
+	virtual ~EventMessage();
+	Event getEvent();
+	void setEvent(Event event);
+	uint8_t getMessageId();
+	void setMessageId(uint8_t id);
+	EventSeverity_t getSeverity();
+	void setSeverity(EventSeverity_t severity);
+	EventId_t getEventId();
+	void setEventId(EventId_t event);
+	object_id_t getReporter();
+	void setReporter(object_id_t reporter);
+	uint32_t getParameter1();
+	void setParameter1(uint32_t parameter);
+	uint32_t getParameter2();
+	void setParameter2(uint32_t parameter);
+
+	void clearEventMessage();
+	bool isClearedEventMessage();
+
+protected:
+	static const Event INVALID_EVENT = 0;
+	virtual size_t getMinimumMessageSize();
+
+};
+
+#endif /* EVENTMESSAGE_H_ */
diff --git a/events/EventReportingProxyIF.h b/events/EventReportingProxyIF.h
index 8aca4e26a..1b8064bd1 100644
--- a/events/EventReportingProxyIF.h
+++ b/events/EventReportingProxyIF.h
@@ -1,19 +1,19 @@
-#ifndef FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
-#define FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
-
-#include <framework/events/Event.h>
-
-
-class EventReportingProxyIF {
-public:
-	virtual ~EventReportingProxyIF() {
-	}
-
-	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const = 0;
-
-};
-
-
-
-
-#endif /* FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
+#define FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
+
+#include "../events/Event.h"
+
+
+class EventReportingProxyIF {
+public:
+	virtual ~EventReportingProxyIF() {
+	}
+
+	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const = 0;
+
+};
+
+
+
+
+#endif /* FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_ */
diff --git a/events/eventmatching/EventIdRangeMatcher.cpp b/events/eventmatching/EventIdRangeMatcher.cpp
index ac9156fd5..40220e4b4 100644
--- a/events/eventmatching/EventIdRangeMatcher.cpp
+++ b/events/eventmatching/EventIdRangeMatcher.cpp
@@ -1,12 +1,12 @@
-#include <framework/events/eventmatching/EventIdRangeMatcher.h>
-
-EventIdRangeMatcher::EventIdRangeMatcher(EventId_t lower, EventId_t upper,
-		bool inverted) : EventRangeMatcherBase<EventId_t>(lower, upper, inverted) {
-}
-
-EventIdRangeMatcher::~EventIdRangeMatcher() {
-}
-
-bool EventIdRangeMatcher::match(EventMessage* message) {
-	return rangeMatcher.match(message->getEventId());
-}
+#include "../../events/eventmatching/EventIdRangeMatcher.h"
+
+EventIdRangeMatcher::EventIdRangeMatcher(EventId_t lower, EventId_t upper,
+		bool inverted) : EventRangeMatcherBase<EventId_t>(lower, upper, inverted) {
+}
+
+EventIdRangeMatcher::~EventIdRangeMatcher() {
+}
+
+bool EventIdRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getEventId());
+}
diff --git a/events/eventmatching/EventIdRangeMatcher.h b/events/eventmatching/EventIdRangeMatcher.h
index 57b77cb10..ffc2ce80b 100644
--- a/events/eventmatching/EventIdRangeMatcher.h
+++ b/events/eventmatching/EventIdRangeMatcher.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
-
-#include <framework/events/eventmatching/EventRangeMatcherBase.h>
-
-class EventIdRangeMatcher: public EventRangeMatcherBase<EventId_t> {
-public:
-	EventIdRangeMatcher(EventId_t lower, EventId_t upper, bool inverted);
-	~EventIdRangeMatcher();
-	bool match(EventMessage* message);
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
+
+#include "../../events/eventmatching/EventRangeMatcherBase.h"
+
+class EventIdRangeMatcher: public EventRangeMatcherBase<EventId_t> {
+public:
+	EventIdRangeMatcher(EventId_t lower, EventId_t upper, bool inverted);
+	~EventIdRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_ */
diff --git a/events/eventmatching/EventMatchTree.cpp b/events/eventmatching/EventMatchTree.cpp
index e1925b8f0..fef1b83ea 100644
--- a/events/eventmatching/EventMatchTree.cpp
+++ b/events/eventmatching/EventMatchTree.cpp
@@ -1,149 +1,149 @@
-#include <framework/events/eventmatching/EventIdRangeMatcher.h>
-#include <framework/events/eventmatching/EventMatchTree.h>
-#include <framework/events/eventmatching/ReporterRangeMatcher.h>
-#include <framework/events/eventmatching/SeverityRangeMatcher.h>
-
-EventMatchTree::EventMatchTree(StorageManagerIF* storageBackend,
-		bool invertedMatch) :
-		MatchTree<EventMessage*>(end(), 1), factory(storageBackend), invertedMatch(
-				invertedMatch) {
-}
-
-EventMatchTree::~EventMatchTree() {
-}
-
-bool EventMatchTree::match(EventMessage* number) {
-	if (invertedMatch) {
-		return !MatchTree<EventMessage*>::match(number);
-	} else {
-		return MatchTree<EventMessage*>::match(number);
-	}
-}
-
-ReturnValue_t EventMatchTree::addMatch(EventId_t idFrom, EventId_t idTo,
-		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	if (idFrom == 0) {
-		//Assuming all events shall be forwarded.
-		idTo = 0;
-		idInverted = true;
-	}
-	if (idTo == 0) {
-		idTo = idFrom;
-	}
-	iterator lastTest;
-	ReturnValue_t result = findOrInsertRangeMatcher<EventId_t,
-			EventIdRangeMatcher>(begin(), idFrom, idTo, idInverted, &lastTest);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (reporterFrom == 0) {
-		//No need to add another AND branch
-		return RETURN_OK;
-	}
-	if (reporterTo == 0) {
-		reporterTo = reporterFrom;
-	}
-	return findOrInsertRangeMatcher<object_id_t, ReporterRangeMatcher>(
-			lastTest.left(), reporterFrom, reporterTo, reporterInverted,
-			&lastTest);
-}
-
-ReturnValue_t EventMatchTree::removeMatch(EventId_t idFrom, EventId_t idTo,
-		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-
-	iterator foundElement;
-
-	if (idFrom == 0) {
-		//Assuming a "forward all events" request.
-		idTo = 0;
-		idInverted = true;
-	}
-	if (idTo == 0) {
-		idTo = idFrom;
-	}
-	foundElement = findRangeMatcher<EventId_t, EventIdRangeMatcher>(begin(),
-			idFrom, idTo, idInverted);
-	if (foundElement == end()) {
-		return NO_MATCH; //Can't tell if too detailed or just not found.
-	}
-	if (reporterFrom == 0) {
-		if (foundElement.left() == end()) {
-			return removeElementAndReconnectChildren(foundElement);
-		} else {
-			return TOO_GENERAL_REQUEST;
-		}
-	}
-	if (reporterTo == 0) {
-		reporterTo = reporterFrom;
-	}
-	foundElement = findRangeMatcher<object_id_t, ReporterRangeMatcher>(
-			foundElement.left(), reporterFrom, reporterTo, reporterInverted);
-	if (foundElement == end()) {
-		return NO_MATCH;
-	} else {
-		return removeElementAndReconnectChildren(foundElement);
-	}
-}
-
-template<typename VALUE_T, typename INSERTION_T>
-inline ReturnValue_t EventMatchTree::findOrInsertRangeMatcher(iterator start,
-		VALUE_T idFrom, VALUE_T idTo, bool inverted, iterator* lastTest) {
-	bool attachToBranch = AND;
-	iterator iter = start;
-	while (iter != end()) {
-		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
-		attachToBranch = OR;
-		*lastTest = iter;
-		if ((matcher->rangeMatcher.lowerBound == idFrom)
-				&& (matcher->rangeMatcher.upperBound == idTo)
-				&& (matcher->rangeMatcher.inverted == inverted)) {
-			return RETURN_OK;
-		} else {
-			iter = iter.right();
-		}
-	}
-	//Only reached if nothing was found.
-	SerializeableMatcherIF<EventMessage*>* newContent = factory.generate<
-			INSERTION_T>(idFrom, idTo, inverted);
-	if (newContent == NULL) {
-		return FULL;
-	}
-	Node* newNode = factory.generate<Node>(newContent);
-	if (newNode == NULL) {
-		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
-		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
-		return FULL;
-	}
-	*lastTest = insert(attachToBranch, *lastTest, newNode);
-	if (*lastTest == end()) {
-		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-template<typename VALUE_T, typename INSERTION_T>
-EventMatchTree::iterator EventMatchTree::findRangeMatcher(iterator start,
-		VALUE_T idFrom, VALUE_T idTo, bool inverted) {
-	iterator iter = start;
-	while (iter != end()) {
-		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
-		if ((matcher->rangeMatcher.lowerBound == idFrom)
-				&& (matcher->rangeMatcher.upperBound == idTo)
-				&& (matcher->rangeMatcher.inverted == inverted)) {
-			break;
-		} else {
-			iter = iter.right(); //next OR element
-		}
-	}
-	return iter;
-}
-
-ReturnValue_t EventMatchTree::cleanUpElement(iterator position) {
-	factory.destroy(position.element->value);
-	//If deletion fails, delete element anyway, nothing we can do.
-	//SHOULDO: Throw event, or write debug output.
-	return factory.destroy(position.element);
-}
+#include "../../events/eventmatching/EventIdRangeMatcher.h"
+#include "../../events/eventmatching/EventMatchTree.h"
+#include "../../events/eventmatching/ReporterRangeMatcher.h"
+#include "../../events/eventmatching/SeverityRangeMatcher.h"
+
+EventMatchTree::EventMatchTree(StorageManagerIF* storageBackend,
+		bool invertedMatch) :
+		MatchTree<EventMessage*>(end(), 1), factory(storageBackend), invertedMatch(
+				invertedMatch) {
+}
+
+EventMatchTree::~EventMatchTree() {
+}
+
+bool EventMatchTree::match(EventMessage* number) {
+	if (invertedMatch) {
+		return !MatchTree<EventMessage*>::match(number);
+	} else {
+		return MatchTree<EventMessage*>::match(number);
+	}
+}
+
+ReturnValue_t EventMatchTree::addMatch(EventId_t idFrom, EventId_t idTo,
+		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+	if (idFrom == 0) {
+		//Assuming all events shall be forwarded.
+		idTo = 0;
+		idInverted = true;
+	}
+	if (idTo == 0) {
+		idTo = idFrom;
+	}
+	iterator lastTest;
+	ReturnValue_t result = findOrInsertRangeMatcher<EventId_t,
+			EventIdRangeMatcher>(begin(), idFrom, idTo, idInverted, &lastTest);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (reporterFrom == 0) {
+		//No need to add another AND branch
+		return RETURN_OK;
+	}
+	if (reporterTo == 0) {
+		reporterTo = reporterFrom;
+	}
+	return findOrInsertRangeMatcher<object_id_t, ReporterRangeMatcher>(
+			lastTest.left(), reporterFrom, reporterTo, reporterInverted,
+			&lastTest);
+}
+
+ReturnValue_t EventMatchTree::removeMatch(EventId_t idFrom, EventId_t idTo,
+		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+
+	iterator foundElement;
+
+	if (idFrom == 0) {
+		//Assuming a "forward all events" request.
+		idTo = 0;
+		idInverted = true;
+	}
+	if (idTo == 0) {
+		idTo = idFrom;
+	}
+	foundElement = findRangeMatcher<EventId_t, EventIdRangeMatcher>(begin(),
+			idFrom, idTo, idInverted);
+	if (foundElement == end()) {
+		return NO_MATCH; //Can't tell if too detailed or just not found.
+	}
+	if (reporterFrom == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	if (reporterTo == 0) {
+		reporterTo = reporterFrom;
+	}
+	foundElement = findRangeMatcher<object_id_t, ReporterRangeMatcher>(
+			foundElement.left(), reporterFrom, reporterTo, reporterInverted);
+	if (foundElement == end()) {
+		return NO_MATCH;
+	} else {
+		return removeElementAndReconnectChildren(foundElement);
+	}
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+inline ReturnValue_t EventMatchTree::findOrInsertRangeMatcher(iterator start,
+		VALUE_T idFrom, VALUE_T idTo, bool inverted, iterator* lastTest) {
+	bool attachToBranch = AND;
+	iterator iter = start;
+	while (iter != end()) {
+		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
+		attachToBranch = OR;
+		*lastTest = iter;
+		if ((matcher->rangeMatcher.lowerBound == idFrom)
+				&& (matcher->rangeMatcher.upperBound == idTo)
+				&& (matcher->rangeMatcher.inverted == inverted)) {
+			return RETURN_OK;
+		} else {
+			iter = iter.right();
+		}
+	}
+	//Only reached if nothing was found.
+	SerializeableMatcherIF<EventMessage*>* newContent = factory.generate<
+			INSERTION_T>(idFrom, idTo, inverted);
+	if (newContent == NULL) {
+		return FULL;
+	}
+	Node* newNode = factory.generate<Node>(newContent);
+	if (newNode == NULL) {
+		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
+		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
+		return FULL;
+	}
+	*lastTest = insert(attachToBranch, *lastTest, newNode);
+	if (*lastTest == end()) {
+		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+EventMatchTree::iterator EventMatchTree::findRangeMatcher(iterator start,
+		VALUE_T idFrom, VALUE_T idTo, bool inverted) {
+	iterator iter = start;
+	while (iter != end()) {
+		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
+		if ((matcher->rangeMatcher.lowerBound == idFrom)
+				&& (matcher->rangeMatcher.upperBound == idTo)
+				&& (matcher->rangeMatcher.inverted == inverted)) {
+			break;
+		} else {
+			iter = iter.right(); //next OR element
+		}
+	}
+	return iter;
+}
+
+ReturnValue_t EventMatchTree::cleanUpElement(iterator position) {
+	factory.destroy(position.element->value);
+	//If deletion fails, delete element anyway, nothing we can do.
+	//SHOULDO: Throw event, or write debug output.
+	return factory.destroy(position.element);
+}
diff --git a/events/eventmatching/EventMatchTree.h b/events/eventmatching/EventMatchTree.h
index bd81e3bed..ba02217ac 100644
--- a/events/eventmatching/EventMatchTree.h
+++ b/events/eventmatching/EventMatchTree.h
@@ -1,36 +1,36 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
-
-#include <framework/container/PlacementFactory.h>
-#include <framework/events/EventMessage.h>
-#include <framework/globalfunctions/matching/MatchTree.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-class StorageManagerIF;
-
-class EventMatchTree: public MatchTree<EventMessage*>, public HasReturnvaluesIF {
-public:
-	EventMatchTree(StorageManagerIF* storageBackend, bool invertedMatch);
-	virtual ~EventMatchTree();
-	ReturnValue_t addMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	ReturnValue_t removeMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	bool match(EventMessage* number);
-protected:
-	ReturnValue_t cleanUpElement(iterator position);
-private:
-	PlacementFactory factory;
-	bool invertedMatch;
-	template<typename VALUE_T, typename INSERTION_T>
-	ReturnValue_t findOrInsertRangeMatcher(iterator start, VALUE_T idFrom,
-			VALUE_T idTo, bool inverted, iterator* lastTest);
-
-	template<typename VALUE_T, typename INSERTION_T>
-	iterator findRangeMatcher(iterator start, VALUE_T idFrom, VALUE_T idTo,
-			bool inverted);
-
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
+
+#include "../../container/PlacementFactory.h"
+#include "../../events/EventMessage.h"
+#include "../../globalfunctions/matching/MatchTree.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+class StorageManagerIF;
+
+class EventMatchTree: public MatchTree<EventMessage*>, public HasReturnvaluesIF {
+public:
+	EventMatchTree(StorageManagerIF* storageBackend, bool invertedMatch);
+	virtual ~EventMatchTree();
+	ReturnValue_t addMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t removeMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	bool match(EventMessage* number);
+protected:
+	ReturnValue_t cleanUpElement(iterator position);
+private:
+	PlacementFactory factory;
+	bool invertedMatch;
+	template<typename VALUE_T, typename INSERTION_T>
+	ReturnValue_t findOrInsertRangeMatcher(iterator start, VALUE_T idFrom,
+			VALUE_T idTo, bool inverted, iterator* lastTest);
+
+	template<typename VALUE_T, typename INSERTION_T>
+	iterator findRangeMatcher(iterator start, VALUE_T idFrom, VALUE_T idTo,
+			bool inverted);
+
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_ */
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index 587669ba5..ab42800a9 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -1,29 +1,29 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
-
-#include <framework/events/EventMessage.h>
-#include <framework/globalfunctions/matching/RangeMatcher.h>
-#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
-
-template <typename T>
-class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
-	friend class EventMatchTree;
-public:
-	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
-	virtual ~EventRangeMatcherBase() { }
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return rangeMatcher.getSerializedSize();
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
-	}
-protected:
-	RangeMatcher<T> rangeMatcher;
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
+
+#include "../../events/EventMessage.h"
+#include "../../globalfunctions/matching/RangeMatcher.h"
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+
+template <typename T>
+class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
+	friend class EventMatchTree;
+public:
+	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
+	virtual ~EventRangeMatcherBase() { }
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return rangeMatcher.getSerializedSize();
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
+	}
+protected:
+	RangeMatcher<T> rangeMatcher;
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_ */
diff --git a/events/eventmatching/ReporterRangeMatcher.cpp b/events/eventmatching/ReporterRangeMatcher.cpp
index 76b8e7886..6751b5e0c 100644
--- a/events/eventmatching/ReporterRangeMatcher.cpp
+++ b/events/eventmatching/ReporterRangeMatcher.cpp
@@ -1,13 +1,13 @@
-#include <framework/events/eventmatching/ReporterRangeMatcher.h>
-
-ReporterRangeMatcher::ReporterRangeMatcher(object_id_t lower, object_id_t upper,
-		bool inverted) : EventRangeMatcherBase<object_id_t>(lower, upper, inverted) {
-}
-
-ReporterRangeMatcher::~ReporterRangeMatcher() {
-	
-}
-
-bool ReporterRangeMatcher::match(EventMessage* message) {
-	return rangeMatcher.match(message->getReporter());
-}
+#include "../../events/eventmatching/ReporterRangeMatcher.h"
+
+ReporterRangeMatcher::ReporterRangeMatcher(object_id_t lower, object_id_t upper,
+		bool inverted) : EventRangeMatcherBase<object_id_t>(lower, upper, inverted) {
+}
+
+ReporterRangeMatcher::~ReporterRangeMatcher() {
+	
+}
+
+bool ReporterRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getReporter());
+}
diff --git a/events/eventmatching/ReporterRangeMatcher.h b/events/eventmatching/ReporterRangeMatcher.h
index 65be2365e..ee23d0768 100644
--- a/events/eventmatching/ReporterRangeMatcher.h
+++ b/events/eventmatching/ReporterRangeMatcher.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
-
-#include <framework/events/eventmatching/EventRangeMatcherBase.h>
-
-class ReporterRangeMatcher: public EventRangeMatcherBase<object_id_t> {
-public:
-	ReporterRangeMatcher(object_id_t lower, object_id_t upper, bool inverted);
-	~ReporterRangeMatcher();
-	bool match(EventMessage* message);
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
+
+#include "../../events/eventmatching/EventRangeMatcherBase.h"
+
+class ReporterRangeMatcher: public EventRangeMatcherBase<object_id_t> {
+public:
+	ReporterRangeMatcher(object_id_t lower, object_id_t upper, bool inverted);
+	~ReporterRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_ */
diff --git a/events/eventmatching/SeverityRangeMatcher.cpp b/events/eventmatching/SeverityRangeMatcher.cpp
index 98f8d7e16..41eb90207 100644
--- a/events/eventmatching/SeverityRangeMatcher.cpp
+++ b/events/eventmatching/SeverityRangeMatcher.cpp
@@ -1,14 +1,14 @@
-#include <framework/events/eventmatching/SeverityRangeMatcher.h>
-#include <framework/events/EventMessage.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-SeverityRangeMatcher::SeverityRangeMatcher(EventSeverity_t from,
-		EventSeverity_t till, bool inverted) : EventRangeMatcherBase<EventSeverity_t>(from, till, inverted) {
-}
-
-SeverityRangeMatcher::~SeverityRangeMatcher() {
-}
-
-bool SeverityRangeMatcher::match(EventMessage* message) {
-	return rangeMatcher.match(message->getSeverity());
-}
+#include "../../events/eventmatching/SeverityRangeMatcher.h"
+#include "../../events/EventMessage.h"
+#include "../../serialize/SerializeAdapter.h"
+
+SeverityRangeMatcher::SeverityRangeMatcher(EventSeverity_t from,
+		EventSeverity_t till, bool inverted) : EventRangeMatcherBase<EventSeverity_t>(from, till, inverted) {
+}
+
+SeverityRangeMatcher::~SeverityRangeMatcher() {
+}
+
+bool SeverityRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getSeverity());
+}
diff --git a/events/eventmatching/SeverityRangeMatcher.h b/events/eventmatching/SeverityRangeMatcher.h
index ffacff818..b3c3fbc81 100644
--- a/events/eventmatching/SeverityRangeMatcher.h
+++ b/events/eventmatching/SeverityRangeMatcher.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
-
-#include <framework/events/eventmatching/EventRangeMatcherBase.h>
-
-class SeverityRangeMatcher: public EventRangeMatcherBase<EventSeverity_t> {
-public:
-	SeverityRangeMatcher(EventSeverity_t from, EventSeverity_t till, bool inverted);
-	~SeverityRangeMatcher();
-	bool match(EventMessage* message);
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
+
+#include "../../events/eventmatching/EventRangeMatcherBase.h"
+
+class SeverityRangeMatcher: public EventRangeMatcherBase<EventSeverity_t> {
+public:
+	SeverityRangeMatcher(EventSeverity_t from, EventSeverity_t till, bool inverted);
+	~SeverityRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_ */
diff --git a/events/eventmatching/eventmatching.h b/events/eventmatching/eventmatching.h
index 435c7457f..85b852a5b 100644
--- a/events/eventmatching/eventmatching.h
+++ b/events/eventmatching/eventmatching.h
@@ -1,10 +1,10 @@
-#ifndef EVENTMATCHING_H_
-#define EVENTMATCHING_H_
-
-#include <framework/events/eventmatching/EventIdRangeMatcher.h>
-#include <framework/events/eventmatching/EventMatchTree.h>
-#include <framework/events/eventmatching/ReporterRangeMatcher.h>
-#include <framework/events/eventmatching/SeverityRangeMatcher.h>
-
-
-#endif /* EVENTMATCHING_H_ */
+#ifndef EVENTMATCHING_H_
+#define EVENTMATCHING_H_
+
+#include "../../events/eventmatching/EventIdRangeMatcher.h"
+#include "../../events/eventmatching/EventMatchTree.h"
+#include "../../events/eventmatching/ReporterRangeMatcher.h"
+#include "../../events/eventmatching/SeverityRangeMatcher.h"
+
+
+#endif /* EVENTMATCHING_H_ */
diff --git a/fdir/ConfirmsFailuresIF.h b/fdir/ConfirmsFailuresIF.h
index 460749ee5..1896d24ae 100644
--- a/fdir/ConfirmsFailuresIF.h
+++ b/fdir/ConfirmsFailuresIF.h
@@ -1,20 +1,20 @@
-#ifndef FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
-#define FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-// TODO: Documentation.
-class ConfirmsFailuresIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HANDLES_FAILURES_IF;
-	static const ReturnValue_t YOUR_FAULT = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t MY_FAULT = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t CONFIRM_LATER = MAKE_RETURN_CODE(2);
-	virtual ~ConfirmsFailuresIF() {}
-	virtual MessageQueueId_t getEventReceptionQueue() = 0;
-};
-
-
-
-#endif /* FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_ */
+#ifndef FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
+#define FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+// TODO: Documentation.
+class ConfirmsFailuresIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HANDLES_FAILURES_IF;
+	static const ReturnValue_t YOUR_FAULT = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t MY_FAULT = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t CONFIRM_LATER = MAKE_RETURN_CODE(2);
+	virtual ~ConfirmsFailuresIF() {}
+	virtual MessageQueueId_t getEventReceptionQueue() = 0;
+};
+
+
+
+#endif /* FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_ */
diff --git a/fdir/EventCorrelation.cpp b/fdir/EventCorrelation.cpp
index 32aa3cd3b..dea6a5699 100644
--- a/fdir/EventCorrelation.cpp
+++ b/fdir/EventCorrelation.cpp
@@ -1,44 +1,44 @@
-#include <framework/fdir/EventCorrelation.h>
-
-EventCorrelation::EventCorrelation(uint32_t timeout) :
-		eventPending(false) {
-	correlationTimer.setTimeout(timeout);
-}
-
-EventCorrelation::~EventCorrelation() {
-}
-
-EventCorrelation::State EventCorrelation::doesEventCorrelate() {
-	if (correlationTimer.isBusy()) {
-		eventPending = false;
-		return CORRELATED;
-	} else {
-		if (eventPending) {
-			return ALREADY_STARTED;
-		} else {
-			eventPending = true;
-			correlationTimer.resetTimer();
-			return CORRELATION_STARTED;
-		}
-	}
-}
-
-bool EventCorrelation::isEventPending() {
-	if (eventPending) {
-		eventPending = false;
-		return true;
-	} else {
-		correlationTimer.resetTimer();
-		return false;
-	}
-}
-
-bool EventCorrelation::hasPendingEventTimedOut() {
-	if (correlationTimer.hasTimedOut()) {
-		bool temp = eventPending;
-		eventPending = false;
-		return temp;
-	} else {
-		return false;
-	}
-}
+#include "../fdir/EventCorrelation.h"
+
+EventCorrelation::EventCorrelation(uint32_t timeout) :
+		eventPending(false) {
+	correlationTimer.setTimeout(timeout);
+}
+
+EventCorrelation::~EventCorrelation() {
+}
+
+EventCorrelation::State EventCorrelation::doesEventCorrelate() {
+	if (correlationTimer.isBusy()) {
+		eventPending = false;
+		return CORRELATED;
+	} else {
+		if (eventPending) {
+			return ALREADY_STARTED;
+		} else {
+			eventPending = true;
+			correlationTimer.resetTimer();
+			return CORRELATION_STARTED;
+		}
+	}
+}
+
+bool EventCorrelation::isEventPending() {
+	if (eventPending) {
+		eventPending = false;
+		return true;
+	} else {
+		correlationTimer.resetTimer();
+		return false;
+	}
+}
+
+bool EventCorrelation::hasPendingEventTimedOut() {
+	if (correlationTimer.hasTimedOut()) {
+		bool temp = eventPending;
+		eventPending = false;
+		return temp;
+	} else {
+		return false;
+	}
+}
diff --git a/fdir/EventCorrelation.h b/fdir/EventCorrelation.h
index 0cad6265d..bbfe92c17 100644
--- a/fdir/EventCorrelation.h
+++ b/fdir/EventCorrelation.h
@@ -1,23 +1,23 @@
-#ifndef FRAMEWORK_FDIR_EVENTCORRELATION_H_
-#define FRAMEWORK_FDIR_EVENTCORRELATION_H_
-
-#include <framework/timemanager/Countdown.h>
-
-class EventCorrelation {
-public:
-	enum State {
-		CORRELATION_STARTED,
-		CORRELATED,
-		ALREADY_STARTED
-	};
-	EventCorrelation(uint32_t timeout);
-	~EventCorrelation();
-	EventCorrelation::State doesEventCorrelate();
-	bool isEventPending();
-	bool hasPendingEventTimedOut();
-	Countdown correlationTimer;
-private:
-	bool eventPending;
-};
-
-#endif /* FRAMEWORK_FDIR_EVENTCORRELATION_H_ */
+#ifndef FRAMEWORK_FDIR_EVENTCORRELATION_H_
+#define FRAMEWORK_FDIR_EVENTCORRELATION_H_
+
+#include "../timemanager/Countdown.h"
+
+class EventCorrelation {
+public:
+	enum State {
+		CORRELATION_STARTED,
+		CORRELATED,
+		ALREADY_STARTED
+	};
+	EventCorrelation(uint32_t timeout);
+	~EventCorrelation();
+	EventCorrelation::State doesEventCorrelate();
+	bool isEventPending();
+	bool hasPendingEventTimedOut();
+	Countdown correlationTimer;
+private:
+	bool eventPending;
+};
+
+#endif /* FRAMEWORK_FDIR_EVENTCORRELATION_H_ */
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index ad4493ff2..b9994dc3e 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -1,164 +1,164 @@
-#include <framework/events/EventManagerIF.h>
-#include <framework/fdir/FailureIsolationBase.h>
-#include <framework/health/HasHealthIF.h>
-#include <framework/health/HealthMessage.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-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() {
-	QueueFactory::instance()->deleteMessageQueue(eventQueue);
-}
-
-ReturnValue_t FailureIsolationBase::initialize() {
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-			objects::EVENT_MANAGER);
-	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 != objects::NO_OBJECT) {
-		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		owner = objectManager->get<HasHealthIF>(ownerId);
-		if (owner == nullptr) {
-			sif::error << "FailureIsolationBase::intialize: Owner object "
-					"invalid. Make sure it implements HasHealthIF" << std::endl;
-			return ObjectManagerIF::CHILD_INIT_FAILED;
-		}
-	}
-	if (faultTreeParent != objects::NO_OBJECT) {
-		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
-				faultTreeParent);
-		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());
-	}
-	return RETURN_OK;
-}
-
-void FailureIsolationBase::checkForFailures() {
-	EventMessage event;
-	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
-			result == RETURN_OK; result = eventQueue->receiveMessage(&event)) {
-		if (event.getSender() == eventQueue->getId()) {
-			//We already got this event, because we sent it.
-			continue;
-		}
-		switch (event.getMessageId()) {
-		case EventMessage::EVENT_MESSAGE:
-			if (isFdirDisabledForSeverity(event.getSeverity())) {
-				//We do not handle events when disabled.
-				continue;
-			}
-			eventReceived(&event);
-			break;
-		case EventMessage::CONFIRMATION_REQUEST:
-			doConfirmFault(&event);
-			break;
-		case EventMessage::YOUR_FAULT:
-			eventConfirmed(&event);
-			break;
-		case EventMessage::MY_FAULT:
-			wasParentsFault(&event);
-			break;
-		default:
-			break;
-		}
-	}
-	decrementFaultCounters();
-}
-
-void FailureIsolationBase::setOwnerHealth(HasHealthIF::HealthState health) {
-	if (owner != NULL) {
-		owner->setHealth(health);
-	}
-	//else: owner has no health.
-
-}
-
-MessageQueueId_t FailureIsolationBase::getEventReceptionQueue() {
-	return eventQueue->getId();
-}
-
-ReturnValue_t FailureIsolationBase::sendConfirmationRequest(EventMessage* event,
-		MessageQueueId_t destination) {
-	event->setMessageId(EventMessage::CONFIRMATION_REQUEST);
-	if (destination != MessageQueueIF::NO_QUEUE) {
-		return eventQueue->sendMessage(destination, event);
-	} else if (faultTreeParent != objects::NO_OBJECT) {
-		return eventQueue->sendToDefault(event);
-	}
-	return RETURN_FAILED;
-}
-
-void FailureIsolationBase::eventConfirmed(EventMessage* event) {
-}
-
-void FailureIsolationBase::wasParentsFault(EventMessage* event) {
-}
-
-void FailureIsolationBase::doConfirmFault(EventMessage* event) {
-	ReturnValue_t result = confirmFault(event);
-	if (result == YOUR_FAULT) {
-		event->setMessageId(EventMessage::YOUR_FAULT);
-		eventQueue->reply(event);
-	} else if (result == MY_FAULT) {
-		event->setMessageId(EventMessage::MY_FAULT);
-		eventQueue->reply(event);
-	} else {
-
-	}
-}
-
-ReturnValue_t FailureIsolationBase::confirmFault(EventMessage* event) {
-	return YOUR_FAULT;
-}
-
-void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	//With this mechanism, all events are disabled for a certain device.
-	//That's not so good for visibility.
-	if (isFdirDisabledForSeverity(EVENT::getSeverity(event))) {
-		return;
-	}
-	EventMessage message(event, ownerId, parameter1, parameter2);
-	EventManagerIF::triggerEvent(&message, eventQueue->getId());
-	eventReceived(&message);
-}
-
-bool FailureIsolationBase::isFdirDisabledForSeverity(EventSeverity_t severity) {
-	if ((owner != NULL) && (severity != SEVERITY::INFO)) {
-		if (owner->getHealth() == HasHealthIF::EXTERNAL_CONTROL) {
-			//External control disables handling of fault messages.
-			return true;
-		}
-	}
-	return false;
-}
-
-void FailureIsolationBase::throwFdirEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	EventMessage message(event, ownerId, parameter1, parameter2);
-	EventManagerIF::triggerEvent(&message, eventQueue->getId());
-}
+#include "../events/EventManagerIF.h"
+#include "../fdir/FailureIsolationBase.h"
+#include "../health/HasHealthIF.h"
+#include "../health/HealthMessage.h"
+#include "../ipc/QueueFactory.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+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() {
+	QueueFactory::instance()->deleteMessageQueue(eventQueue);
+}
+
+ReturnValue_t FailureIsolationBase::initialize() {
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+			objects::EVENT_MANAGER);
+	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 != objects::NO_OBJECT) {
+		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		owner = objectManager->get<HasHealthIF>(ownerId);
+		if (owner == nullptr) {
+			sif::error << "FailureIsolationBase::intialize: Owner object "
+					"invalid. Make sure it implements HasHealthIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
+		}
+	}
+	if (faultTreeParent != objects::NO_OBJECT) {
+		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
+				faultTreeParent);
+		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());
+	}
+	return RETURN_OK;
+}
+
+void FailureIsolationBase::checkForFailures() {
+	EventMessage event;
+	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
+			result == RETURN_OK; result = eventQueue->receiveMessage(&event)) {
+		if (event.getSender() == eventQueue->getId()) {
+			//We already got this event, because we sent it.
+			continue;
+		}
+		switch (event.getMessageId()) {
+		case EventMessage::EVENT_MESSAGE:
+			if (isFdirDisabledForSeverity(event.getSeverity())) {
+				//We do not handle events when disabled.
+				continue;
+			}
+			eventReceived(&event);
+			break;
+		case EventMessage::CONFIRMATION_REQUEST:
+			doConfirmFault(&event);
+			break;
+		case EventMessage::YOUR_FAULT:
+			eventConfirmed(&event);
+			break;
+		case EventMessage::MY_FAULT:
+			wasParentsFault(&event);
+			break;
+		default:
+			break;
+		}
+	}
+	decrementFaultCounters();
+}
+
+void FailureIsolationBase::setOwnerHealth(HasHealthIF::HealthState health) {
+	if (owner != NULL) {
+		owner->setHealth(health);
+	}
+	//else: owner has no health.
+
+}
+
+MessageQueueId_t FailureIsolationBase::getEventReceptionQueue() {
+	return eventQueue->getId();
+}
+
+ReturnValue_t FailureIsolationBase::sendConfirmationRequest(EventMessage* event,
+		MessageQueueId_t destination) {
+	event->setMessageId(EventMessage::CONFIRMATION_REQUEST);
+	if (destination != MessageQueueIF::NO_QUEUE) {
+		return eventQueue->sendMessage(destination, event);
+	} else if (faultTreeParent != objects::NO_OBJECT) {
+		return eventQueue->sendToDefault(event);
+	}
+	return RETURN_FAILED;
+}
+
+void FailureIsolationBase::eventConfirmed(EventMessage* event) {
+}
+
+void FailureIsolationBase::wasParentsFault(EventMessage* event) {
+}
+
+void FailureIsolationBase::doConfirmFault(EventMessage* event) {
+	ReturnValue_t result = confirmFault(event);
+	if (result == YOUR_FAULT) {
+		event->setMessageId(EventMessage::YOUR_FAULT);
+		eventQueue->reply(event);
+	} else if (result == MY_FAULT) {
+		event->setMessageId(EventMessage::MY_FAULT);
+		eventQueue->reply(event);
+	} else {
+
+	}
+}
+
+ReturnValue_t FailureIsolationBase::confirmFault(EventMessage* event) {
+	return YOUR_FAULT;
+}
+
+void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	//With this mechanism, all events are disabled for a certain device.
+	//That's not so good for visibility.
+	if (isFdirDisabledForSeverity(EVENT::getSeverity(event))) {
+		return;
+	}
+	EventMessage message(event, ownerId, parameter1, parameter2);
+	EventManagerIF::triggerEvent(&message, eventQueue->getId());
+	eventReceived(&message);
+}
+
+bool FailureIsolationBase::isFdirDisabledForSeverity(EventSeverity_t severity) {
+	if ((owner != NULL) && (severity != SEVERITY::INFO)) {
+		if (owner->getHealth() == HasHealthIF::EXTERNAL_CONTROL) {
+			//External control disables handling of fault messages.
+			return true;
+		}
+	}
+	return false;
+}
+
+void FailureIsolationBase::throwFdirEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	EventMessage message(event, ownerId, parameter1, parameter2);
+	EventManagerIF::triggerEvent(&message, eventQueue->getId());
+}
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index c0fe6041e..b2735e6d1 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -1,56 +1,56 @@
-#ifndef FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
-#define FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
-
-#include <framework/events/EventMessage.h>
-#include <framework/fdir/ConfirmsFailuresIF.h>
-#include <framework/fdir/FaultCounter.h>
-#include <framework/health/HealthMessage.h>
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-class FailureIsolationBase: public HasReturnvaluesIF,
-		public ConfirmsFailuresIF,
-		public HasParametersIF {
-public:
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
-	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 = 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() override;
-	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);
-protected:
-	MessageQueueIF* eventQueue = nullptr;
-	object_id_t ownerId;
-	HasHealthIF* owner = nullptr;
-	object_id_t faultTreeParent;
-	uint8_t parameterDomainBase;
-	void setOwnerHealth(HasHealthIF::HealthState health);
-	virtual ReturnValue_t eventReceived(EventMessage* event) = 0;
-	virtual void eventConfirmed(EventMessage* event);
-	virtual void wasParentsFault(EventMessage* event);
-	virtual ReturnValue_t confirmFault(EventMessage* event);
-	virtual void decrementFaultCounters() = 0;
-	ReturnValue_t sendConfirmationRequest(EventMessage* event,
-			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
-	void throwFdirEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);
-private:
-	void doConfirmFault(EventMessage* event);bool isFdirDisabledForSeverity(
-			EventSeverity_t severity);
-};
-
-#endif /* FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_ */
+#ifndef FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
+#define FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
+
+#include "../events/EventMessage.h"
+#include "../fdir/ConfirmsFailuresIF.h"
+#include "../fdir/FaultCounter.h"
+#include "../health/HealthMessage.h"
+#include "../parameters/HasParametersIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class FailureIsolationBase: public HasReturnvaluesIF,
+		public ConfirmsFailuresIF,
+		public HasParametersIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
+	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 = 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() override;
+	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
+protected:
+	MessageQueueIF* eventQueue = nullptr;
+	object_id_t ownerId;
+	HasHealthIF* owner = nullptr;
+	object_id_t faultTreeParent;
+	uint8_t parameterDomainBase;
+	void setOwnerHealth(HasHealthIF::HealthState health);
+	virtual ReturnValue_t eventReceived(EventMessage* event) = 0;
+	virtual void eventConfirmed(EventMessage* event);
+	virtual void wasParentsFault(EventMessage* event);
+	virtual ReturnValue_t confirmFault(EventMessage* event);
+	virtual void decrementFaultCounters() = 0;
+	ReturnValue_t sendConfirmationRequest(EventMessage* event,
+			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
+	void throwFdirEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
+private:
+	void doConfirmFault(EventMessage* event);bool isFdirDisabledForSeverity(
+			EventSeverity_t severity);
+};
+
+#endif /* FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_ */
diff --git a/fdir/FaultCounter.cpp b/fdir/FaultCounter.cpp
index 3dc899c26..674d278a9 100644
--- a/fdir/FaultCounter.cpp
+++ b/fdir/FaultCounter.cpp
@@ -1,86 +1,86 @@
-#include <framework/fdir/FaultCounter.h>
-
-FaultCounter::FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
-		uint8_t setParameterDomain) :
-		parameterDomain(setParameterDomain), timer(), faultCount(0), failureThreshold(
-				failureThreshold) {
-	timer.setTimeout(decrementAfterMs);
-}
-
-FaultCounter::~FaultCounter() {
-}
-
-void FaultCounter::increment(uint32_t amount) {
-	if (faultCount == 0) {
-		timer.resetTimer();
-	}
-	faultCount += amount;
-}
-
-bool FaultCounter::checkForDecrement() {
-	if (timer.hasTimedOut()) {
-		timer.resetTimer();
-		if (faultCount > 0) {
-			faultCount--;
-			return true;
-		}
-	}
-	return false;
-}
-
-bool FaultCounter::incrementAndCheck(uint32_t amount) {
-	increment(amount);
-	return aboveThreshold();
-}
-
-bool FaultCounter::aboveThreshold() {
-	if (faultCount > failureThreshold) {
-		faultCount = 0;
-		return true;
-	} else {
-		return false;
-	}
-}
-
-void FaultCounter::clear() {
-	faultCount = 0;
-}
-
-void FaultCounter::setFailureThreshold(uint32_t failureThreshold) {
-	this->failureThreshold = failureThreshold;
-}
-
-void FaultCounter::setFaultDecrementTimeMs(uint32_t timeMs) {
-	timer.setTimeout(timeMs);
-}
-
-FaultCounter::FaultCounter() :
-		parameterDomain(0), timer(), faultCount(0), failureThreshold(0) {
-}
-
-ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	if (domainId != parameterDomain) {
-		return INVALID_DOMAIN_ID;
-	}
-
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set(failureThreshold);
-		break;
-	case 1:
-		parameterWrapper->set(faultCount);
-		break;
-	case 2:
-		parameterWrapper->set(timer.timeout);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void FaultCounter::setParameterDomain(uint8_t domain) {
-	parameterDomain = domain;
-}
+#include "../fdir/FaultCounter.h"
+
+FaultCounter::FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
+		uint8_t setParameterDomain) :
+		parameterDomain(setParameterDomain), timer(), faultCount(0), failureThreshold(
+				failureThreshold) {
+	timer.setTimeout(decrementAfterMs);
+}
+
+FaultCounter::~FaultCounter() {
+}
+
+void FaultCounter::increment(uint32_t amount) {
+	if (faultCount == 0) {
+		timer.resetTimer();
+	}
+	faultCount += amount;
+}
+
+bool FaultCounter::checkForDecrement() {
+	if (timer.hasTimedOut()) {
+		timer.resetTimer();
+		if (faultCount > 0) {
+			faultCount--;
+			return true;
+		}
+	}
+	return false;
+}
+
+bool FaultCounter::incrementAndCheck(uint32_t amount) {
+	increment(amount);
+	return aboveThreshold();
+}
+
+bool FaultCounter::aboveThreshold() {
+	if (faultCount > failureThreshold) {
+		faultCount = 0;
+		return true;
+	} else {
+		return false;
+	}
+}
+
+void FaultCounter::clear() {
+	faultCount = 0;
+}
+
+void FaultCounter::setFailureThreshold(uint32_t failureThreshold) {
+	this->failureThreshold = failureThreshold;
+}
+
+void FaultCounter::setFaultDecrementTimeMs(uint32_t timeMs) {
+	timer.setTimeout(timeMs);
+}
+
+FaultCounter::FaultCounter() :
+		parameterDomain(0), timer(), faultCount(0), failureThreshold(0) {
+}
+
+ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	if (domainId != parameterDomain) {
+		return INVALID_DOMAIN_ID;
+	}
+
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set(failureThreshold);
+		break;
+	case 1:
+		parameterWrapper->set(faultCount);
+		break;
+	case 2:
+		parameterWrapper->set(timer.timeout);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FaultCounter::setParameterDomain(uint8_t domain) {
+	parameterDomain = domain;
+}
diff --git a/fdir/FaultCounter.h b/fdir/FaultCounter.h
index ac23853cb..17e2a3dfe 100644
--- a/fdir/FaultCounter.h
+++ b/fdir/FaultCounter.h
@@ -1,38 +1,38 @@
-#ifndef FRAMEWORK_FDIR_FAULTCOUNTER_H_
-#define FRAMEWORK_FDIR_FAULTCOUNTER_H_
-
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/timemanager/Countdown.h>
-
-class FaultCounter: public HasParametersIF {
-public:
-	FaultCounter();
-	FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
-			uint8_t setParameterDomain = 0);
-	virtual ~FaultCounter();
-
-	bool incrementAndCheck(uint32_t amount = 1);
-
-	void increment(uint32_t amount = 1);
-
-	bool checkForDecrement();
-
-	bool aboveThreshold();
-
-	void clear();
-	void setFailureThreshold(uint32_t failureThreshold);
-	void setFaultDecrementTimeMs(uint32_t timeMs);
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-	void setParameterDomain(uint8_t domain);
-private:
-	uint8_t parameterDomain;
-	Countdown timer;
-	uint32_t faultCount;
-	uint32_t failureThreshold;
-};
-
-#endif /* FRAMEWORK_FDIR_FAULTCOUNTER_H_ */
+#ifndef FRAMEWORK_FDIR_FAULTCOUNTER_H_
+#define FRAMEWORK_FDIR_FAULTCOUNTER_H_
+
+#include "../parameters/HasParametersIF.h"
+#include "../timemanager/Countdown.h"
+
+class FaultCounter: public HasParametersIF {
+public:
+	FaultCounter();
+	FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
+			uint8_t setParameterDomain = 0);
+	virtual ~FaultCounter();
+
+	bool incrementAndCheck(uint32_t amount = 1);
+
+	void increment(uint32_t amount = 1);
+
+	bool checkForDecrement();
+
+	bool aboveThreshold();
+
+	void clear();
+	void setFailureThreshold(uint32_t failureThreshold);
+	void setFaultDecrementTimeMs(uint32_t timeMs);
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+	void setParameterDomain(uint8_t domain);
+private:
+	uint8_t parameterDomain;
+	Countdown timer;
+	uint32_t faultCount;
+	uint32_t failureThreshold;
+};
+
+#endif /* FRAMEWORK_FDIR_FAULTCOUNTER_H_ */
diff --git a/globalfunctions/AsciiConverter.cpp b/globalfunctions/AsciiConverter.cpp
index 1459a2410..f54af6a88 100644
--- a/globalfunctions/AsciiConverter.cpp
+++ b/globalfunctions/AsciiConverter.cpp
@@ -1,230 +1,230 @@
-#include <framework/globalfunctions/AsciiConverter.h>
-#include <limits>
-#include <cmath>
-
-template<typename T>
-ReturnValue_t AsciiConverter::scanAsciiDecimalNumber(const uint8_t** dataPtr,
-		uint8_t len, T* value) {
-	if (len > std::numeric_limits<T>().digits10) {
-		return TOO_LONG_FOR_TARGET_TYPE;
-	}
-
-	double temp;
-
-	ReturnValue_t result = scanAsciiDecimalNumber_(dataPtr, len, &temp);
-
-	*value = temp;
-
-	return result;
-}
-
-ReturnValue_t AsciiConverter::scanAsciiHexByte(const uint8_t** dataPtr,
-		uint8_t* value) {
-	int8_t tmp;
-
-	tmp = convertHexChar(*dataPtr);
-	(*dataPtr)++;
-	if (tmp == -1) {
-		return INVALID_CHARACTERS;
-	}
-	if (tmp == -2) {
-		tmp = 0;
-	}
-
-	*value = tmp << 4;
-
-	tmp = convertHexChar(*dataPtr);
-	(*dataPtr)++;
-	if (tmp == -1) {
-		return INVALID_CHARACTERS;
-	}
-	if (tmp != -2) {
-		*value += tmp;
-	} else {
-		*value = *value >> 4;
-	}
-
-	return RETURN_OK;
-}
-
-ReturnValue_t AsciiConverter::scanAsciiDecimalNumber_(uint8_t const ** dataPtr,
-		uint8_t len, double* value) {
-
-	uint8_t const *ptr = *dataPtr;
-	int8_t sign = 1;
-	float decimal = 0;
-	bool abort = false;
-
-	*value = 0;
-
-	//ignore leading space
-	ptr = clearSpace(ptr, len);
-
-	while ((ptr - *dataPtr < len) && !abort) {
-		switch (*ptr) {
-		case '+':
-			sign = 1;
-			break;
-		case '-':
-			sign = -1;
-			break;
-		case '.':
-			decimal = 1;
-			break;
-		case ' ':
-		case 0x0d:
-		case 0x0a:
-			//ignore trailing space
-			ptr = clearSpace(ptr, len - (ptr - *dataPtr)) - 1; //before aborting the loop, ptr will be incremented
-			abort = true;
-			break;
-		default:
-			if ((*ptr < 0x30) || (*ptr > 0x39)) {
-				return INVALID_CHARACTERS;
-			}
-			*value = *value * 10 + (*ptr - 0x30);
-			if (decimal > 0) {
-				decimal *= 10;
-			}
-			break;
-		}
-		ptr++;
-	}
-
-	if (decimal == 0) {
-		decimal = 1;
-	}
-
-	*value = *value / (decimal) * sign;
-
-	*dataPtr = ptr;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t AsciiConverter::printFloat(uint8_t* buffer, uint32_t bufferLength,
-		float value, uint8_t decimalPlaces, uint32_t *printedSize) {
-	*printedSize = 0;
-	uint32_t streamposition = 0, integerSize;
-	bool negative = (value < 0);
-	int32_t digits = bufferLength - decimalPlaces - 1;
-	if (digits <= 0) {
-		return BUFFER_TOO_SMALL;
-	}
-	if (negative) {
-		digits -= 1;
-		buffer[streamposition++] = '-';
-		value = -value;
-	}
-	float maximumNumber = pow(10, digits);
-	if (value >= maximumNumber) {
-		return BUFFER_TOO_SMALL;
-	}
-	//print the numbers before the decimal point;
-	ReturnValue_t result = printInteger(buffer + streamposition,
-			bufferLength - streamposition - decimalPlaces - 1, value,
-			&integerSize);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	streamposition += integerSize;
-	//The decimal Point
-	buffer[streamposition++] = '.';
-
-	//Print the decimals
-	uint32_t integerValue = value;
-	value -= integerValue;
-	value = value * pow(10, decimalPlaces);
-	result = printInteger(buffer + streamposition, decimalPlaces, round(value),
-			&integerSize, true);
-	*printedSize = integerSize + streamposition;
-	return result;
-}
-
-ReturnValue_t AsciiConverter::printInteger(uint8_t* buffer,
-		uint32_t bufferLength, uint32_t value, uint32_t *printedSize,
-		bool leadingZeros) {
-	*printedSize = 0;
-	if (bufferLength == 0) {
-		return BUFFER_TOO_SMALL;
-	}
-	uint32_t maximumNumber = -1;
-	if (bufferLength < 10) {
-		maximumNumber = pow(10, bufferLength);
-		if (value >= maximumNumber) {
-			return BUFFER_TOO_SMALL;
-		}
-		maximumNumber /= 10;
-	} else {
-		if (!(value <= maximumNumber)) {
-			return BUFFER_TOO_SMALL;
-		}
-		maximumNumber = 1000000000;
-	}
-	if (!leadingZeros && (value == 0)) {
-		buffer[(*printedSize)++] = '0';
-		return RETURN_OK;
-	}
-	while (maximumNumber >= 1) {
-		uint8_t number = value / maximumNumber;
-		value = value - (number * maximumNumber);
-		if (!leadingZeros && number == 0) {
-			maximumNumber /= 10;
-		} else {
-			leadingZeros = true;
-			buffer[(*printedSize)++] = '0' + number;
-			maximumNumber /= 10;
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t AsciiConverter::printSignedInteger(uint8_t* buffer,
-		uint32_t bufferLength, int32_t value, uint32_t *printedSize) {
-	bool negative = false;
-	if ((bufferLength > 0) && (value < 0)) {
-		*buffer++ = '-';
-		bufferLength--;
-		value = -value;
-		negative = true;
-	}
-	ReturnValue_t result = printInteger(buffer, bufferLength, value,
-			printedSize);
-	if (negative) {
-		(*printedSize)++;
-	}
-	return result;
-}
-
-int8_t AsciiConverter::convertHexChar(const uint8_t* character) {
-	if ((*character > 0x60) && (*character < 0x67)) {
-		return *character - 0x61 + 10;
-	} else if ((*character > 0x40) && (*character < 0x47)) {
-		return *character - 0x41 + 10;
-	} else if ((*character > 0x2F) && (*character < 0x3A)) {
-		return *character - 0x30;
-	} else if (*character == ' ') {
-		return -2;
-	}
-	return -1;
-}
-
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<float>(
-		const uint8_t** dataPtr, uint8_t len, float* value);
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint8_t>(
-		const uint8_t** dataPtr, uint8_t len, uint8_t* value);
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint16_t>(
-		const uint8_t** dataPtr, uint8_t len, uint16_t* value);
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<double>(
-		const uint8_t** dataPtr, uint8_t len, double* value);
-
-const uint8_t* AsciiConverter::clearSpace(const uint8_t* data, uint8_t len) {
-	while (len > 0) {
-		if ((*data != ' ') && (*data != 0x0a) && (*data != 0x0d)) {
-			return data;
-		}
-		data++;
-		len--;
-	}
-	return data;
-}
+#include "../globalfunctions/AsciiConverter.h"
+#include <limits>
+#include <cmath>
+
+template<typename T>
+ReturnValue_t AsciiConverter::scanAsciiDecimalNumber(const uint8_t** dataPtr,
+		uint8_t len, T* value) {
+	if (len > std::numeric_limits<T>().digits10) {
+		return TOO_LONG_FOR_TARGET_TYPE;
+	}
+
+	double temp;
+
+	ReturnValue_t result = scanAsciiDecimalNumber_(dataPtr, len, &temp);
+
+	*value = temp;
+
+	return result;
+}
+
+ReturnValue_t AsciiConverter::scanAsciiHexByte(const uint8_t** dataPtr,
+		uint8_t* value) {
+	int8_t tmp;
+
+	tmp = convertHexChar(*dataPtr);
+	(*dataPtr)++;
+	if (tmp == -1) {
+		return INVALID_CHARACTERS;
+	}
+	if (tmp == -2) {
+		tmp = 0;
+	}
+
+	*value = tmp << 4;
+
+	tmp = convertHexChar(*dataPtr);
+	(*dataPtr)++;
+	if (tmp == -1) {
+		return INVALID_CHARACTERS;
+	}
+	if (tmp != -2) {
+		*value += tmp;
+	} else {
+		*value = *value >> 4;
+	}
+
+	return RETURN_OK;
+}
+
+ReturnValue_t AsciiConverter::scanAsciiDecimalNumber_(uint8_t const ** dataPtr,
+		uint8_t len, double* value) {
+
+	uint8_t const *ptr = *dataPtr;
+	int8_t sign = 1;
+	float decimal = 0;
+	bool abort = false;
+
+	*value = 0;
+
+	//ignore leading space
+	ptr = clearSpace(ptr, len);
+
+	while ((ptr - *dataPtr < len) && !abort) {
+		switch (*ptr) {
+		case '+':
+			sign = 1;
+			break;
+		case '-':
+			sign = -1;
+			break;
+		case '.':
+			decimal = 1;
+			break;
+		case ' ':
+		case 0x0d:
+		case 0x0a:
+			//ignore trailing space
+			ptr = clearSpace(ptr, len - (ptr - *dataPtr)) - 1; //before aborting the loop, ptr will be incremented
+			abort = true;
+			break;
+		default:
+			if ((*ptr < 0x30) || (*ptr > 0x39)) {
+				return INVALID_CHARACTERS;
+			}
+			*value = *value * 10 + (*ptr - 0x30);
+			if (decimal > 0) {
+				decimal *= 10;
+			}
+			break;
+		}
+		ptr++;
+	}
+
+	if (decimal == 0) {
+		decimal = 1;
+	}
+
+	*value = *value / (decimal) * sign;
+
+	*dataPtr = ptr;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t AsciiConverter::printFloat(uint8_t* buffer, uint32_t bufferLength,
+		float value, uint8_t decimalPlaces, uint32_t *printedSize) {
+	*printedSize = 0;
+	uint32_t streamposition = 0, integerSize;
+	bool negative = (value < 0);
+	int32_t digits = bufferLength - decimalPlaces - 1;
+	if (digits <= 0) {
+		return BUFFER_TOO_SMALL;
+	}
+	if (negative) {
+		digits -= 1;
+		buffer[streamposition++] = '-';
+		value = -value;
+	}
+	float maximumNumber = pow(10, digits);
+	if (value >= maximumNumber) {
+		return BUFFER_TOO_SMALL;
+	}
+	//print the numbers before the decimal point;
+	ReturnValue_t result = printInteger(buffer + streamposition,
+			bufferLength - streamposition - decimalPlaces - 1, value,
+			&integerSize);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	streamposition += integerSize;
+	//The decimal Point
+	buffer[streamposition++] = '.';
+
+	//Print the decimals
+	uint32_t integerValue = value;
+	value -= integerValue;
+	value = value * pow(10, decimalPlaces);
+	result = printInteger(buffer + streamposition, decimalPlaces, round(value),
+			&integerSize, true);
+	*printedSize = integerSize + streamposition;
+	return result;
+}
+
+ReturnValue_t AsciiConverter::printInteger(uint8_t* buffer,
+		uint32_t bufferLength, uint32_t value, uint32_t *printedSize,
+		bool leadingZeros) {
+	*printedSize = 0;
+	if (bufferLength == 0) {
+		return BUFFER_TOO_SMALL;
+	}
+	uint32_t maximumNumber = -1;
+	if (bufferLength < 10) {
+		maximumNumber = pow(10, bufferLength);
+		if (value >= maximumNumber) {
+			return BUFFER_TOO_SMALL;
+		}
+		maximumNumber /= 10;
+	} else {
+		if (!(value <= maximumNumber)) {
+			return BUFFER_TOO_SMALL;
+		}
+		maximumNumber = 1000000000;
+	}
+	if (!leadingZeros && (value == 0)) {
+		buffer[(*printedSize)++] = '0';
+		return RETURN_OK;
+	}
+	while (maximumNumber >= 1) {
+		uint8_t number = value / maximumNumber;
+		value = value - (number * maximumNumber);
+		if (!leadingZeros && number == 0) {
+			maximumNumber /= 10;
+		} else {
+			leadingZeros = true;
+			buffer[(*printedSize)++] = '0' + number;
+			maximumNumber /= 10;
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t AsciiConverter::printSignedInteger(uint8_t* buffer,
+		uint32_t bufferLength, int32_t value, uint32_t *printedSize) {
+	bool negative = false;
+	if ((bufferLength > 0) && (value < 0)) {
+		*buffer++ = '-';
+		bufferLength--;
+		value = -value;
+		negative = true;
+	}
+	ReturnValue_t result = printInteger(buffer, bufferLength, value,
+			printedSize);
+	if (negative) {
+		(*printedSize)++;
+	}
+	return result;
+}
+
+int8_t AsciiConverter::convertHexChar(const uint8_t* character) {
+	if ((*character > 0x60) && (*character < 0x67)) {
+		return *character - 0x61 + 10;
+	} else if ((*character > 0x40) && (*character < 0x47)) {
+		return *character - 0x41 + 10;
+	} else if ((*character > 0x2F) && (*character < 0x3A)) {
+		return *character - 0x30;
+	} else if (*character == ' ') {
+		return -2;
+	}
+	return -1;
+}
+
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<float>(
+		const uint8_t** dataPtr, uint8_t len, float* value);
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint8_t>(
+		const uint8_t** dataPtr, uint8_t len, uint8_t* value);
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint16_t>(
+		const uint8_t** dataPtr, uint8_t len, uint16_t* value);
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<double>(
+		const uint8_t** dataPtr, uint8_t len, double* value);
+
+const uint8_t* AsciiConverter::clearSpace(const uint8_t* data, uint8_t len) {
+	while (len > 0) {
+		if ((*data != ' ') && (*data != 0x0a) && (*data != 0x0d)) {
+			return data;
+		}
+		data++;
+		len--;
+	}
+	return data;
+}
diff --git a/globalfunctions/AsciiConverter.h b/globalfunctions/AsciiConverter.h
index acd406dab..27bed4e75 100644
--- a/globalfunctions/AsciiConverter.h
+++ b/globalfunctions/AsciiConverter.h
@@ -1,39 +1,39 @@
-#ifndef ASCIICONVERTER_H_
-#define ASCIICONVERTER_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-class AsciiConverter: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ASCII_CONVERTER;
-	static const ReturnValue_t TOO_LONG_FOR_TARGET_TYPE = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_CHARACTERS = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t BUFFER_TOO_SMALL = MAKE_RETURN_CODE(0x3);
-
-	template<typename T>
-	static ReturnValue_t scanAsciiDecimalNumber(const uint8_t **dataPtr,
-			uint8_t len, T *value);
-
-	static ReturnValue_t scanAsciiHexByte(const uint8_t **dataPtr,
-			uint8_t *value);
-
-	static ReturnValue_t printFloat(uint8_t *buffer, uint32_t bufferLength,
-			float value, uint8_t decimalPlaces, uint32_t *printedSize);
-
-	static ReturnValue_t printInteger(uint8_t *buffer, uint32_t bufferLength,
-			uint32_t value, uint32_t *printedSize, bool leadingZeros = false);
-
-	static ReturnValue_t printSignedInteger(uint8_t *buffer,
-			uint32_t bufferLength, int32_t value, uint32_t *printedSize);
-
-private:
-	AsciiConverter();
-	static ReturnValue_t scanAsciiDecimalNumber_(const uint8_t **dataPtr,
-			uint8_t len, double *value);
-
-	static int8_t convertHexChar(const uint8_t *character);
-
-	static const uint8_t *clearSpace(const uint8_t *data, uint8_t len);
-};
-
-#endif /* ASCIICONVERTER_H_ */
+#ifndef ASCIICONVERTER_H_
+#define ASCIICONVERTER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class AsciiConverter: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ASCII_CONVERTER;
+	static const ReturnValue_t TOO_LONG_FOR_TARGET_TYPE = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID_CHARACTERS = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t BUFFER_TOO_SMALL = MAKE_RETURN_CODE(0x3);
+
+	template<typename T>
+	static ReturnValue_t scanAsciiDecimalNumber(const uint8_t **dataPtr,
+			uint8_t len, T *value);
+
+	static ReturnValue_t scanAsciiHexByte(const uint8_t **dataPtr,
+			uint8_t *value);
+
+	static ReturnValue_t printFloat(uint8_t *buffer, uint32_t bufferLength,
+			float value, uint8_t decimalPlaces, uint32_t *printedSize);
+
+	static ReturnValue_t printInteger(uint8_t *buffer, uint32_t bufferLength,
+			uint32_t value, uint32_t *printedSize, bool leadingZeros = false);
+
+	static ReturnValue_t printSignedInteger(uint8_t *buffer,
+			uint32_t bufferLength, int32_t value, uint32_t *printedSize);
+
+private:
+	AsciiConverter();
+	static ReturnValue_t scanAsciiDecimalNumber_(const uint8_t **dataPtr,
+			uint8_t len, double *value);
+
+	static int8_t convertHexChar(const uint8_t *character);
+
+	static const uint8_t *clearSpace(const uint8_t *data, uint8_t len);
+};
+
+#endif /* ASCIICONVERTER_H_ */
diff --git a/globalfunctions/CRC.cpp b/globalfunctions/CRC.cpp
index ecd0b6756..6156b558f 100644
--- a/globalfunctions/CRC.cpp
+++ b/globalfunctions/CRC.cpp
@@ -1,139 +1,139 @@
-#include <framework/globalfunctions/CRC.h>
-#include <math.h>
-
-const uint16_t CRC::crc16ccitt_table[256] = {
-    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
-    0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
-    0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
-    0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
-    0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
-    0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
-    0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
-    0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
-    0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
-    0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
-    0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
-    0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
-    0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
-    0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
-    0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
-    0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
-    0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
-    0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
-    0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
-    0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
-    0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
-    0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
-    0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
-    0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
-    0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
-    0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
-    0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
-    0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
-    0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
-    0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
-    0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
-    0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
-};
-
-
-// CRC implementation
-uint16_t CRC::crc16ccitt(uint8_t const input[], uint32_t length, uint16_t startingCrc)
-{
-	uint8_t *data = (uint8_t *)input;
-	unsigned int tbl_idx;
-
-    while (length--) {
-        tbl_idx = ((startingCrc >> 8) ^ *data) & 0xff;
-        startingCrc = (crc16ccitt_table[tbl_idx] ^ (startingCrc << 8)) & 0xffff;
-
-        data++;
-    }
-    return startingCrc & 0xffff;
-
-    //The part below is not used!
-//	bool temr[16];
-//	bool xor_out[16];
-//	bool r[16];
-//	bool d[8];
-//	uint16_t crc_value = 0;
-//
-//
-//	for (int i=0; i<16 ;i++) {
-//		temr[i] = false;
-//		xor_out[i] = false;
-//	}
-//
-//
-//	for (int i=0; i<16 ;i++)
-//			r[i] = true;    // initialize with 0xFFFF
-//
-//
-//
-//	for (int j=0; j<length ;j++)
-//	{
-//
-//	for (int i=0; i<8 ;i++)
-//		if ((input[j] & 1<<i) == 1<<i)
-//			d[7-i]=true;			// reverse   input data
-//		else
-//			d[7-i]=false;			// reverse input data
-//
-//
-//
-//		  temr[0] = d[4] ^ d[0];
-//		  temr[1] = d[5] ^ d[1];
-//		  temr[2] = d[6] ^ d[2];
-//		  temr[3] = d[7] ^ d[3];
-//		  temr[4] = r[12] ^ r[8];
-//		  temr[5] = r[13] ^ r[9];
-//		  temr[6] = r[14] ^ r[10];
-//		  temr[7] = r[15] ^ r[11];
-//		  temr[8] = d[4] ^ r[12];
-//		  temr[9] = d[5] ^ r[13];
-//		  temr[10] = d[6] ^ r[14];
-//		  temr[11] = d[7] ^ r[15];
-//		  temr[12] = temr[0] ^ temr[4];
-//		  temr[13] = temr[1] ^ temr[5];
-//		  temr[14] = temr[2] ^ temr[6];
-//		  temr[15] = temr[3] ^ temr[7];
-//
-//
-//		  xor_out[0] = temr[12];
-//		  xor_out[1] = temr[13];
-//		  xor_out[2] = temr[14];
-//		  xor_out[3] = temr[15];
-//		  xor_out[4] = temr[8];
-//		  xor_out[5] = temr[9] ^ temr[12];
-//		  xor_out[6] = temr[10] ^ temr[13];
-//		  xor_out[7] = temr[11] ^ temr[14];
-//		  xor_out[8] = temr[15] ^ r[0];
-//		  xor_out[9] = temr[8] ^ r[1];
-//		  xor_out[10] = temr[9] ^ r[2];
-//		  xor_out[11] = temr[10] ^ r[3];
-//		  xor_out[12] = temr[11] ^ temr[12] ^ r[4];
-//		  xor_out[13] = temr[13] ^ r[5];
-//		  xor_out[14] = temr[14] ^ r[6];
-//		  xor_out[15] = temr[15] ^ r[7];
-//
-//	 for (int i=0; i<16 ;i++)
-//	 {
-//		  r[i]= xor_out[i] ;
-//	 }
-//
-//	}
-//
-//
-//
-//	for (int i=0; i<16 ;i++)
-//	{
-//		 if  (xor_out[i] == true)
-//			 crc_value = crc_value + pow(2,(15 -i));   // reverse CrC result before Final XOR
-//	}
-//
-//	crc_value = 0;// for debug mode
-//	return (crc_value);
-
-}   /* Calculate_CRC() */
-
-
+#include "../globalfunctions/CRC.h"
+#include <math.h>
+
+const uint16_t CRC::crc16ccitt_table[256] = {
+    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
+    0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
+    0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
+    0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
+    0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
+    0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
+    0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
+    0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
+    0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
+    0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
+    0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
+    0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
+    0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
+    0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
+    0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
+    0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
+    0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
+    0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
+    0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
+    0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
+    0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
+    0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+    0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
+    0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
+    0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
+    0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
+    0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
+    0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
+    0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
+    0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
+    0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
+    0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
+};
+
+
+// CRC implementation
+uint16_t CRC::crc16ccitt(uint8_t const input[], uint32_t length, uint16_t startingCrc)
+{
+	uint8_t *data = (uint8_t *)input;
+	unsigned int tbl_idx;
+
+    while (length--) {
+        tbl_idx = ((startingCrc >> 8) ^ *data) & 0xff;
+        startingCrc = (crc16ccitt_table[tbl_idx] ^ (startingCrc << 8)) & 0xffff;
+
+        data++;
+    }
+    return startingCrc & 0xffff;
+
+    //The part below is not used!
+//	bool temr[16];
+//	bool xor_out[16];
+//	bool r[16];
+//	bool d[8];
+//	uint16_t crc_value = 0;
+//
+//
+//	for (int i=0; i<16 ;i++) {
+//		temr[i] = false;
+//		xor_out[i] = false;
+//	}
+//
+//
+//	for (int i=0; i<16 ;i++)
+//			r[i] = true;    // initialize with 0xFFFF
+//
+//
+//
+//	for (int j=0; j<length ;j++)
+//	{
+//
+//	for (int i=0; i<8 ;i++)
+//		if ((input[j] & 1<<i) == 1<<i)
+//			d[7-i]=true;			// reverse   input data
+//		else
+//			d[7-i]=false;			// reverse input data
+//
+//
+//
+//		  temr[0] = d[4] ^ d[0];
+//		  temr[1] = d[5] ^ d[1];
+//		  temr[2] = d[6] ^ d[2];
+//		  temr[3] = d[7] ^ d[3];
+//		  temr[4] = r[12] ^ r[8];
+//		  temr[5] = r[13] ^ r[9];
+//		  temr[6] = r[14] ^ r[10];
+//		  temr[7] = r[15] ^ r[11];
+//		  temr[8] = d[4] ^ r[12];
+//		  temr[9] = d[5] ^ r[13];
+//		  temr[10] = d[6] ^ r[14];
+//		  temr[11] = d[7] ^ r[15];
+//		  temr[12] = temr[0] ^ temr[4];
+//		  temr[13] = temr[1] ^ temr[5];
+//		  temr[14] = temr[2] ^ temr[6];
+//		  temr[15] = temr[3] ^ temr[7];
+//
+//
+//		  xor_out[0] = temr[12];
+//		  xor_out[1] = temr[13];
+//		  xor_out[2] = temr[14];
+//		  xor_out[3] = temr[15];
+//		  xor_out[4] = temr[8];
+//		  xor_out[5] = temr[9] ^ temr[12];
+//		  xor_out[6] = temr[10] ^ temr[13];
+//		  xor_out[7] = temr[11] ^ temr[14];
+//		  xor_out[8] = temr[15] ^ r[0];
+//		  xor_out[9] = temr[8] ^ r[1];
+//		  xor_out[10] = temr[9] ^ r[2];
+//		  xor_out[11] = temr[10] ^ r[3];
+//		  xor_out[12] = temr[11] ^ temr[12] ^ r[4];
+//		  xor_out[13] = temr[13] ^ r[5];
+//		  xor_out[14] = temr[14] ^ r[6];
+//		  xor_out[15] = temr[15] ^ r[7];
+//
+//	 for (int i=0; i<16 ;i++)
+//	 {
+//		  r[i]= xor_out[i] ;
+//	 }
+//
+//	}
+//
+//
+//
+//	for (int i=0; i<16 ;i++)
+//	{
+//		 if  (xor_out[i] == true)
+//			 crc_value = crc_value + pow(2,(15 -i));   // reverse CrC result before Final XOR
+//	}
+//
+//	crc_value = 0;// for debug mode
+//	return (crc_value);
+
+}   /* Calculate_CRC() */
+
+
diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index f4bd765da..8d74130f6 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -1,123 +1,123 @@
-#include <framework/globalfunctions/DleEncoder.h>
-
-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;
-		++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 or nextByte == ETX or nextByte == CARRIAGE_RETURN) {
-			if (encodedIndex + 1 >= maxDestLen) {
-				return STREAM_TOO_SHORT;
-			}
-			else {
-				destStream[encodedIndex] = DLE;
-				++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) {
-			if (encodedIndex + 1 >= maxDestLen) {
-			    return STREAM_TOO_SHORT;
-			}
-			else {
-				destStream[encodedIndex] = DLE;
-				++encodedIndex;
-				destStream[encodedIndex] = DLE;
-			}
-		}
-		else {
-			destStream[encodedIndex] = nextByte;
-		}
-		++encodedIndex;
-		++sourceIndex;
-	}
-
-	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
-		if (addStxEtx) {
-			destStream[encodedIndex] = ETX;
-			++encodedIndex;
-		}
-		*encodedLen = encodedIndex;
-		return RETURN_OK;
-	}
-	else {
-		return STREAM_TOO_SHORT;
-	}
-}
-
-ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
-		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 DECODING_ERROR;
-	}
-	++encodedIndex;
-
-	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
-			&& (sourceStream[encodedIndex] != ETX)
-			&& (sourceStream[encodedIndex] != STX)) {
-		if (sourceStream[encodedIndex] == DLE) {
-			nextByte = sourceStream[encodedIndex + 1];
-			// 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) {
-				destStream[decodedIndex] = nextByte;
-			}
-			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 preven 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 DECODING_ERROR;
-				}
-			}
-			++encodedIndex;
-		}
-		else {
-			destStream[decodedIndex] = sourceStream[encodedIndex];
-		}
-
-		++encodedIndex;
-		++decodedIndex;
-	}
-
-	if (sourceStream[encodedIndex] != ETX) {
-		return DECODING_ERROR;
-	}
-	else {
-		*readLen = ++encodedIndex;
-		*decodedLen = decodedIndex;
-		return RETURN_OK;
-	}
-}
-
+#include "../globalfunctions/DleEncoder.h"
+
+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;
+		++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 or nextByte == ETX or nextByte == CARRIAGE_RETURN) {
+			if (encodedIndex + 1 >= maxDestLen) {
+				return STREAM_TOO_SHORT;
+			}
+			else {
+				destStream[encodedIndex] = DLE;
+				++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) {
+			if (encodedIndex + 1 >= maxDestLen) {
+			    return STREAM_TOO_SHORT;
+			}
+			else {
+				destStream[encodedIndex] = DLE;
+				++encodedIndex;
+				destStream[encodedIndex] = DLE;
+			}
+		}
+		else {
+			destStream[encodedIndex] = nextByte;
+		}
+		++encodedIndex;
+		++sourceIndex;
+	}
+
+	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
+		if (addStxEtx) {
+			destStream[encodedIndex] = ETX;
+			++encodedIndex;
+		}
+		*encodedLen = encodedIndex;
+		return RETURN_OK;
+	}
+	else {
+		return STREAM_TOO_SHORT;
+	}
+}
+
+ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
+		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 DECODING_ERROR;
+	}
+	++encodedIndex;
+
+	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
+			&& (sourceStream[encodedIndex] != ETX)
+			&& (sourceStream[encodedIndex] != STX)) {
+		if (sourceStream[encodedIndex] == DLE) {
+			nextByte = sourceStream[encodedIndex + 1];
+			// 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) {
+				destStream[decodedIndex] = nextByte;
+			}
+			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 preven 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 DECODING_ERROR;
+				}
+			}
+			++encodedIndex;
+		}
+		else {
+			destStream[decodedIndex] = sourceStream[encodedIndex];
+		}
+
+		++encodedIndex;
+		++decodedIndex;
+	}
+
+	if (sourceStream[encodedIndex] != ETX) {
+		return DECODING_ERROR;
+	}
+	else {
+		*readLen = ++encodedIndex;
+		*decodedLen = decodedIndex;
+		return RETURN_OK;
+	}
+}
+
diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index 29851dfe3..da3bbaaf1 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -1,79 +1,79 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
-
-#include <framework/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 occurences 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 enoded 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 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 = 0x02;
-	//! End Of Text character. Last character in encoded stream
-	static constexpr uint8_t ETX = 0x03;
-	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
-	//! in the source stream.
-	static constexpr uint8_t DLE = 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 decoing 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,
-			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
-			size_t maxDestStreamlen, size_t *decodedLen);
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_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 occurences 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 enoded 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 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 = 0x02;
+	//! End Of Text character. Last character in encoded stream
+	static constexpr uint8_t ETX = 0x03;
+	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
+	//! in the source stream.
+	static constexpr uint8_t DLE = 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 decoing 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,
+			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+			size_t maxDestStreamlen, size_t *decodedLen);
+};
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index 2101074ee..9589bed3d 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -1,181 +1,181 @@
-#include <framework/globalfunctions/Type.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-Type::Type() :
-		actualType(UNKNOWN_TYPE) {
-}
-
-Type::Type(ActualType_t actualType) :
-		actualType(actualType) {
-}
-
-Type::Type(const Type& type) :
-		actualType(type.actualType) {
-}
-
-Type& Type::operator =(Type rhs) {
-	this->actualType = rhs.actualType;
-	return *this;
-}
-
-Type& Type::operator =(ActualType_t actualType) {
-	this->actualType = actualType;
-	return *this;
-}
-
-Type::operator Type::ActualType_t() const {
-	return actualType;
-}
-
-bool Type::operator ==(const Type& rhs) {
-	return this->actualType == rhs.actualType;
-}
-
-bool Type::operator !=(const Type& rhs) {
-	return !operator==(rhs);
-}
-
-uint8_t Type::getSize() const {
-	switch (actualType) {
-	case UINT8_T:
-		return sizeof(uint8_t);
-	case INT8_T:
-		return sizeof(int8_t);
-	case UINT16_T:
-		return sizeof(uint16_t);
-	case INT16_T:
-		return sizeof(int16_t);
-	case UINT32_T:
-		return sizeof(uint32_t);
-	case INT32_T:
-		return sizeof(int32_t);
-	case FLOAT:
-		return sizeof(float);
-	case DOUBLE:
-		return sizeof(double);
-	default:
-		return 0;
-	}
-}
-
-ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	uint8_t ptc;
-	uint8_t pfc;
-	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
-			streamEndianness);
-
-	return result;
-
-}
-
-size_t Type::getSerializedSize() const {
-	uint8_t dontcare = 0;
-	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
-}
-
-ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
-		Endianness streamEndianness) {
-	uint8_t ptc;
-	uint8_t pfc;
-	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	actualType = getActualType(ptc, pfc);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Type::getPtcPfc(uint8_t* ptc, uint8_t* pfc) const {
-	switch (actualType) {
-	case UINT8_T:
-		*ptc = 3;
-		*pfc = 4;
-		break;
-	case INT8_T:
-		*ptc = 4;
-		*pfc = 4;
-		break;
-	case UINT16_T:
-		*ptc = 3;
-		*pfc = 12;
-		break;
-	case INT16_T:
-		*ptc = 4;
-		*pfc = 12;
-		break;
-	case UINT32_T:
-		*ptc = 3;
-		*pfc = 14;
-		break;
-	case INT32_T:
-		*ptc = 4;
-		*pfc = 14;
-		break;
-	case FLOAT:
-		*ptc = 5;
-		*pfc = 1;
-		break;
-	case DOUBLE:
-		*ptc = 5;
-		*pfc = 2;
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-Type::ActualType_t Type::getActualType(uint8_t ptc, uint8_t pfc) {
-	switch (ptc) {
-	case 3:
-		switch (pfc) {
-		case 4:
-			return UINT8_T;
-		case 12:
-			return UINT16_T;
-		case 14:
-			return UINT32_T;
-		}
-		break;
-	case 4:
-		switch (pfc) {
-		case 4:
-			return INT8_T;
-		case 12:
-			return INT16_T;
-		case 14:
-			return INT32_T;
-		}
-		break;
-	case 5:
-		switch (pfc) {
-		case 1:
-			return FLOAT;
-		case 2:
-			return DOUBLE;
-		}
-		break;
-	}
-	return UNKNOWN_TYPE;
-}
+#include "../globalfunctions/Type.h"
+#include "../serialize/SerializeAdapter.h"
+
+Type::Type() :
+		actualType(UNKNOWN_TYPE) {
+}
+
+Type::Type(ActualType_t actualType) :
+		actualType(actualType) {
+}
+
+Type::Type(const Type& type) :
+		actualType(type.actualType) {
+}
+
+Type& Type::operator =(Type rhs) {
+	this->actualType = rhs.actualType;
+	return *this;
+}
+
+Type& Type::operator =(ActualType_t actualType) {
+	this->actualType = actualType;
+	return *this;
+}
+
+Type::operator Type::ActualType_t() const {
+	return actualType;
+}
+
+bool Type::operator ==(const Type& rhs) {
+	return this->actualType == rhs.actualType;
+}
+
+bool Type::operator !=(const Type& rhs) {
+	return !operator==(rhs);
+}
+
+uint8_t Type::getSize() const {
+	switch (actualType) {
+	case UINT8_T:
+		return sizeof(uint8_t);
+	case INT8_T:
+		return sizeof(int8_t);
+	case UINT16_T:
+		return sizeof(uint16_t);
+	case INT16_T:
+		return sizeof(int16_t);
+	case UINT32_T:
+		return sizeof(uint32_t);
+	case INT32_T:
+		return sizeof(int32_t);
+	case FLOAT:
+		return sizeof(float);
+	case DOUBLE:
+		return sizeof(double);
+	default:
+		return 0;
+	}
+}
+
+ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	uint8_t ptc;
+	uint8_t pfc;
+	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
+			streamEndianness);
+
+	return result;
+
+}
+
+size_t Type::getSerializedSize() const {
+	uint8_t dontcare = 0;
+	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
+}
+
+ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
+	uint8_t ptc;
+	uint8_t pfc;
+	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	actualType = getActualType(ptc, pfc);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Type::getPtcPfc(uint8_t* ptc, uint8_t* pfc) const {
+	switch (actualType) {
+	case UINT8_T:
+		*ptc = 3;
+		*pfc = 4;
+		break;
+	case INT8_T:
+		*ptc = 4;
+		*pfc = 4;
+		break;
+	case UINT16_T:
+		*ptc = 3;
+		*pfc = 12;
+		break;
+	case INT16_T:
+		*ptc = 4;
+		*pfc = 12;
+		break;
+	case UINT32_T:
+		*ptc = 3;
+		*pfc = 14;
+		break;
+	case INT32_T:
+		*ptc = 4;
+		*pfc = 14;
+		break;
+	case FLOAT:
+		*ptc = 5;
+		*pfc = 1;
+		break;
+	case DOUBLE:
+		*ptc = 5;
+		*pfc = 2;
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+Type::ActualType_t Type::getActualType(uint8_t ptc, uint8_t pfc) {
+	switch (ptc) {
+	case 3:
+		switch (pfc) {
+		case 4:
+			return UINT8_T;
+		case 12:
+			return UINT16_T;
+		case 14:
+			return UINT32_T;
+		}
+		break;
+	case 4:
+		switch (pfc) {
+		case 4:
+			return INT8_T;
+		case 12:
+			return INT16_T;
+		case 14:
+			return INT32_T;
+		}
+		break;
+	case 5:
+		switch (pfc) {
+		case 1:
+			return FLOAT;
+		case 2:
+			return DOUBLE;
+		}
+		break;
+	}
+	return UNKNOWN_TYPE;
+}
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index b083a7018..c10511f89 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -1,94 +1,94 @@
-#ifndef TYPE_H_
-#define TYPE_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeIF.h>
-
-/**
- * @brief 	Type definition for CCSDS or ECSS.
- */
-class Type: public SerializeIF {
-public:
-	enum ActualType_t {
-		UINT8_T,
-		INT8_T,
-		UINT16_T,
-		INT16_T,
-		UINT32_T,
-		INT32_T,
-		FLOAT,
-		DOUBLE,
-		UNKNOWN_TYPE
-	};
-
-	Type();
-
-	Type(ActualType_t actualType);
-
-	Type(const Type &type);
-
-	Type& operator=(Type rhs);
-
-	Type& operator=(ActualType_t actualType);
-
-	operator ActualType_t() const;
-
-	bool operator==(const Type &rhs);
-	bool operator!=(const Type &rhs);
-
-	uint8_t getSize() const;
-
-	ReturnValue_t getPtcPfc(uint8_t *ptc, uint8_t *pfc) const;
-
-	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
-
-	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:
-	ActualType_t actualType;
-};
-
-template<typename T>
-struct PodTypeConversion {
-	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
-};
-template<>
-struct PodTypeConversion<uint8_t> {
-	static const Type::ActualType_t type = Type::UINT8_T;
-};
-template<>
-struct PodTypeConversion<uint16_t> {
-	static const Type::ActualType_t type = Type::UINT16_T;
-};
-template<>
-struct PodTypeConversion<uint32_t> {
-	static const Type::ActualType_t type = Type::UINT32_T;
-};
-template<>
-struct PodTypeConversion<int8_t> {
-	static const Type::ActualType_t type = Type::INT8_T;
-};
-template<>
-struct PodTypeConversion<int16_t> {
-	static const Type::ActualType_t type = Type::INT16_T;
-};
-template<>
-struct PodTypeConversion<int32_t> {
-	static const Type::ActualType_t type = Type::INT32_T;
-};
-template<>
-struct PodTypeConversion<float> {
-	static const Type::ActualType_t type = Type::FLOAT;
-};
-template<>
-struct PodTypeConversion<double> {
-	static const Type::ActualType_t type = Type::DOUBLE;
-};
-
-#endif /* TYPE_H_ */
+#ifndef TYPE_H_
+#define TYPE_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+
+/**
+ * @brief 	Type definition for CCSDS or ECSS.
+ */
+class Type: public SerializeIF {
+public:
+	enum ActualType_t {
+		UINT8_T,
+		INT8_T,
+		UINT16_T,
+		INT16_T,
+		UINT32_T,
+		INT32_T,
+		FLOAT,
+		DOUBLE,
+		UNKNOWN_TYPE
+	};
+
+	Type();
+
+	Type(ActualType_t actualType);
+
+	Type(const Type &type);
+
+	Type& operator=(Type rhs);
+
+	Type& operator=(ActualType_t actualType);
+
+	operator ActualType_t() const;
+
+	bool operator==(const Type &rhs);
+	bool operator!=(const Type &rhs);
+
+	uint8_t getSize() const;
+
+	ReturnValue_t getPtcPfc(uint8_t *ptc, uint8_t *pfc) const;
+
+	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
+
+	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:
+	ActualType_t actualType;
+};
+
+template<typename T>
+struct PodTypeConversion {
+	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
+};
+template<>
+struct PodTypeConversion<uint8_t> {
+	static const Type::ActualType_t type = Type::UINT8_T;
+};
+template<>
+struct PodTypeConversion<uint16_t> {
+	static const Type::ActualType_t type = Type::UINT16_T;
+};
+template<>
+struct PodTypeConversion<uint32_t> {
+	static const Type::ActualType_t type = Type::UINT32_T;
+};
+template<>
+struct PodTypeConversion<int8_t> {
+	static const Type::ActualType_t type = Type::INT8_T;
+};
+template<>
+struct PodTypeConversion<int16_t> {
+	static const Type::ActualType_t type = Type::INT16_T;
+};
+template<>
+struct PodTypeConversion<int32_t> {
+	static const Type::ActualType_t type = Type::INT32_T;
+};
+template<>
+struct PodTypeConversion<float> {
+	static const Type::ActualType_t type = Type::FLOAT;
+};
+template<>
+struct PodTypeConversion<double> {
+	static const Type::ActualType_t type = Type::DOUBLE;
+};
+
+#endif /* TYPE_H_ */
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index e8fce56c6..3f02c882e 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -1,61 +1,61 @@
-#include <framework/globalfunctions/arrayprinter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <bitset>
-
-void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
-		bool printInfo, size_t maxCharPerLine) {
-	if(printInfo) {
-		sif::info << "Printing data with size " << size << ": ";
-	}
-	sif::info << "[";
-	if(type == OutputType::HEX) {
-		arrayprinter::printHex(data, size, maxCharPerLine);
-	}
-	else if (type == OutputType::DEC) {
-		arrayprinter::printDec(data, size, maxCharPerLine);
-	}
-	else if(type == OutputType::BIN) {
-	    arrayprinter::printBin(data, size);
-	}
-}
-
-void arrayprinter::printHex(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-	sif::info << std::hex;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << "0x" << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-			}
-		}
-
-	}
-	sif::info << std::dec;
-	sif::info << "]" << std::endl;
-}
-
-void arrayprinter::printDec(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-	sif::info << std::dec;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-			}
-		}
-	}
-	sif::info << "]" << std::endl;
-}
-
-void arrayprinter::printBin(const uint8_t *data, size_t size) {
-    sif::info << "\n" << std::flush;
-    for(size_t i = 0; i < size; i++) {
-        sif::info << "Byte " << i + 1 << ": 0b"<<
-                std::bitset<8>(data[i]) << ",\n" << std::flush;
-    }
-    sif::info << "]" << std::endl;
-}
+#include "../globalfunctions/arrayprinter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <bitset>
+
+void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
+		bool printInfo, size_t maxCharPerLine) {
+	if(printInfo) {
+		sif::info << "Printing data with size " << size << ": ";
+	}
+	sif::info << "[";
+	if(type == OutputType::HEX) {
+		arrayprinter::printHex(data, size, maxCharPerLine);
+	}
+	else if (type == OutputType::DEC) {
+		arrayprinter::printDec(data, size, maxCharPerLine);
+	}
+	else if(type == OutputType::BIN) {
+	    arrayprinter::printBin(data, size);
+	}
+}
+
+void arrayprinter::printHex(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::hex;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << "0x" << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
+		}
+
+	}
+	sif::info << std::dec;
+	sif::info << "]" << std::endl;
+}
+
+void arrayprinter::printDec(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::dec;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
+		}
+	}
+	sif::info << "]" << std::endl;
+}
+
+void arrayprinter::printBin(const uint8_t *data, size_t size) {
+    sif::info << "\n" << std::flush;
+    for(size_t i = 0; i < size; i++) {
+        sif::info << "Byte " << i + 1 << ": 0b"<<
+                std::bitset<8>(data[i]) << ",\n" << std::flush;
+    }
+    sif::info << "]" << std::endl;
+}
diff --git a/globalfunctions/matching/BinaryMatcher.h b/globalfunctions/matching/BinaryMatcher.h
index df7325cff..60e055a11 100644
--- a/globalfunctions/matching/BinaryMatcher.h
+++ b/globalfunctions/matching/BinaryMatcher.h
@@ -1,41 +1,41 @@
-#ifndef BINARYMATCHER_H_
-#define BINARYMATCHER_H_
-
-#include <framework/globalfunctions/matching/MatcherIF.h>
-
-template<typename T>
-class BinaryMatcher: public MatcherIF<T> {
-public:
-	bool inverted;
-	T mask, matchField;
-
-	BinaryMatcher() :
-			inverted(false), mask(0), matchField(0) {
-	}
-
-	BinaryMatcher(T mask, T match, bool inverted = false) :
-			inverted(inverted), mask(mask), matchField(match) {
-	}
-
-	bool match(T input) {
-		if (inverted) {
-			return ~doMatch(input, mask, matchField);
-		} else {
-			return doMatch(input, mask, matchField);
-		}
-	}
-
-protected:
-
-	bool doMatch(T input, T mask, T match) {
-		match = match & mask;
-		input = input & mask;
-		if (input == match) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-};
-
-#endif /* BINARYMATCHER_H_ */
+#ifndef BINARYMATCHER_H_
+#define BINARYMATCHER_H_
+
+#include "../../globalfunctions/matching/MatcherIF.h"
+
+template<typename T>
+class BinaryMatcher: public MatcherIF<T> {
+public:
+	bool inverted;
+	T mask, matchField;
+
+	BinaryMatcher() :
+			inverted(false), mask(0), matchField(0) {
+	}
+
+	BinaryMatcher(T mask, T match, bool inverted = false) :
+			inverted(inverted), mask(mask), matchField(match) {
+	}
+
+	bool match(T input) {
+		if (inverted) {
+			return ~doMatch(input, mask, matchField);
+		} else {
+			return doMatch(input, mask, matchField);
+		}
+	}
+
+protected:
+
+	bool doMatch(T input, T mask, T match) {
+		match = match & mask;
+		input = input & mask;
+		if (input == match) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+};
+
+#endif /* BINARYMATCHER_H_ */
diff --git a/globalfunctions/matching/DecimalMatcher.h b/globalfunctions/matching/DecimalMatcher.h
index f4722e6bd..24f399eff 100644
--- a/globalfunctions/matching/DecimalMatcher.h
+++ b/globalfunctions/matching/DecimalMatcher.h
@@ -1,50 +1,50 @@
-#ifndef DECIMALMATCHER_H_
-#define DECIMALMATCHER_H_
-
-#include <framework/globalfunctions/matching/MatcherIF.h>
-
-template<typename T>
-class DecimalMatcher: public MatcherIF<T> {
-public:
-	bool inverted;
-	T mask, matchField;
-
-	DecimalMatcher() :
-			inverted(false), mask(0), matchField(0) {
-	}
-
-	DecimalMatcher(T mask, T match, bool inverted = false) :
-			inverted(inverted), mask(mask), matchField(match) {
-	}
-
-	bool match(T input) {
-		if (inverted) {
-			return ~doMatch(input, mask, matchField);
-		} else {
-			return doMatch(input, mask, matchField);
-		}
-	}
-
-protected:
-	bool doMatch(T input, T mask, T match) {
-		T decimal = 1, remainderMask, remainderMatch, remainderInput;
-
-		while (mask != 0) {
-			remainderMask = mask % (decimal * 10);
-			remainderMatch = match % (decimal * 10);
-			remainderInput = input % (decimal * 10);
-			if (remainderMask != 0) {
-				if (remainderMatch != remainderInput) {
-					return false;
-				}
-			}
-			mask -= remainderMask;
-			match -= remainderMatch;
-			input -= remainderInput;
-			decimal *= 10;
-		}
-		return true;
-	}
-};
-
-#endif /* DECIMALMATCHER_H_ */
+#ifndef DECIMALMATCHER_H_
+#define DECIMALMATCHER_H_
+
+#include "../../globalfunctions/matching/MatcherIF.h"
+
+template<typename T>
+class DecimalMatcher: public MatcherIF<T> {
+public:
+	bool inverted;
+	T mask, matchField;
+
+	DecimalMatcher() :
+			inverted(false), mask(0), matchField(0) {
+	}
+
+	DecimalMatcher(T mask, T match, bool inverted = false) :
+			inverted(inverted), mask(mask), matchField(match) {
+	}
+
+	bool match(T input) {
+		if (inverted) {
+			return ~doMatch(input, mask, matchField);
+		} else {
+			return doMatch(input, mask, matchField);
+		}
+	}
+
+protected:
+	bool doMatch(T input, T mask, T match) {
+		T decimal = 1, remainderMask, remainderMatch, remainderInput;
+
+		while (mask != 0) {
+			remainderMask = mask % (decimal * 10);
+			remainderMatch = match % (decimal * 10);
+			remainderInput = input % (decimal * 10);
+			if (remainderMask != 0) {
+				if (remainderMatch != remainderInput) {
+					return false;
+				}
+			}
+			mask -= remainderMask;
+			match -= remainderMatch;
+			input -= remainderInput;
+			decimal *= 10;
+		}
+		return true;
+	}
+};
+
+#endif /* DECIMALMATCHER_H_ */
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index b54f5492d..2d380bbb0 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -1,216 +1,216 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
-
-#include <framework/container/BinaryTree.h>
-#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-template<typename T>
-class MatchTree: public SerializeableMatcherIF<T>, public BinaryTree<
-		SerializeableMatcherIF<T>> {
-public:
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::MATCH_TREE_CLASS;
-	static const ReturnValue_t TOO_DETAILED_REQUEST = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t TOO_GENERAL_REQUEST = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t NO_MATCH = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t NEW_NODE_CREATED = MAKE_RETURN_CODE(5);
-
-	typedef typename BinaryTree<SerializeableMatcherIF<T>>::iterator iterator;
-	typedef BinaryNode<SerializeableMatcherIF<T>> Node;
-	static const bool AND = true; //LEFT
-	static const bool OR = false; //RIGHT
-	MatchTree(BinaryNode<SerializeableMatcherIF<T>>* root,
-			uint8_t maxDepth = -1) :
-			BinaryTree<SerializeableMatcherIF<T>>(root), maxDepth(maxDepth) {
-	}
-	MatchTree(iterator root, uint8_t maxDepth = -1) :
-			BinaryTree<SerializeableMatcherIF<T>>(root.element), maxDepth(
-					maxDepth) {
-	}
-	MatchTree() :
-			BinaryTree<SerializeableMatcherIF<T>>(), maxDepth(-1) {
-	}
-	virtual ~MatchTree() {
-	}
-	virtual bool match(T number) {
-		return matchesTree(number);
-	}
-	bool matchesTree(T number) {
-		iterator iter = this->begin();
-		if (iter == this->end()) {
-			return false;
-		}
-		return matchSubtree(iter, number);
-	}
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
-		iterator iter = this->begin();
-		uint8_t count = this->countRight(iter);
-		ReturnValue_t result = SerializeAdapter::serialize(&count,
-				buffer, size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (iter == this->end()) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-		result = iter->serialize(buffer, size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (maxDepth > 0) {
-			MatchTree<T> temp(iter.left(), maxDepth - 1);
-			result = temp.serialize(buffer, size, maxSize, streamEndianness);
-		}
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		iter = iter.right();
-		while (iter != this->end()) {
-			result = iter->serialize(buffer, size, maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-			if (maxDepth > 0) {
-				MatchTree<T> temp(iter.left(), maxDepth - 1);
-				result = temp.serialize(buffer, size, maxSize, streamEndianness);
-			}
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-			iter = iter.right();
-		}
-		return result;
-	}
-
-	size_t getSerializedSize() const override {
-		//Analogous to serialize!
-		uint32_t size = 1; //One for count
-		iterator iter = this->begin();
-		if (iter == this->end()) {
-			return size;
-		}
-		//Count object itself
-		size += iter->getSerializedSize();
-		//Handle everything below on AND side
-		if (maxDepth > 0) {
-			MatchTree<T> temp(iter.left(), maxDepth - 1);
-			size += temp.getSerializedSize();
-		}
-		//Handle everything on OR side
-		iter = iter.right();
-		//Iterate over every object on the OR branch
-		while (iter != this->end()) {
-			size += iter->getSerializedSize();
-			if (maxDepth > 0) {
-				//If we are allowed to go deeper, handle AND elements.
-				MatchTree<T> temp(iter.left(), maxDepth - 1);
-				size += temp.getSerializedSize();
-			}
-			iter = iter.right();
-		}
-		return size;
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-protected:
-
-	bool isOnAndBranch(iterator position) {
-		if ((position == this->end()) || (position.up() == this->end())) {
-			return false;
-		}
-		if (position.up().left() == position) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	//SHOULDDO: What to do if insertion/deletion fails. Throw event?
-	ReturnValue_t removeElementAndAllChildren(iterator position) {
-		auto children = this->erase(position);
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if (children.first != this->end()) {
-			result = removeElementAndAllChildren(children.first);
-		}
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (children.second != this->end()) {
-			result = removeElementAndAllChildren(children.second);
-		}
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		//Delete element itself.
-		return cleanUpElement(position);
-	}
-
-	ReturnValue_t removeElementAndReconnectChildren(iterator position) {
-		if (position == this->end()) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-		//Delete everything from the AND branch.
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if (position.left() != this->end()) {
-			result = removeElementAndAllChildren(position.left());
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-
-		if (position.right() != this->end()) {
-			//There's something at the OR branch, reconnect to parent.
-			if (isOnAndBranch(position)) {
-				//Either one hierarchy up AND branch...
-				this->insert(AND, position.up(), position.right().element);
-			} else {
-				//or on another OR'ed element (or install new root node).
-				this->insert(OR, position.up(), position.right().element);
-			}
-		} else {
-			if (isOnAndBranch(position)) {
-				//Recursively delete parent node as well, because it is not expected to be there anymore.
-				return removeElementAndReconnectChildren(position.up());
-			} else {
-				//simply delete self.
-				this->erase(position);
-			}
-
-		}
-		//Delete element itself.
-		return cleanUpElement(position);
-	}
-
-	virtual ReturnValue_t cleanUpElement(iterator position) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	bool matchSubtree(iterator iter, T number) {
-		bool isMatch = iter->match(number);
-		if (isMatch) {
-			if (iter.left() == this->end()) {
-				return true;
-			}
-			isMatch = matchSubtree(iter.left(), number);
-			if (isMatch) {
-				return true;
-			}
-		}
-		if (iter.right() == this->end()) {
-			return false;
-		}
-		return matchSubtree(iter.right(), number);
-	}
-private:
-	uint8_t maxDepth;
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_ */
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
+
+#include "../../container/BinaryTree.h"
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+
+template<typename T>
+class MatchTree: public SerializeableMatcherIF<T>, public BinaryTree<
+		SerializeableMatcherIF<T>> {
+public:
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::MATCH_TREE_CLASS;
+	static const ReturnValue_t TOO_DETAILED_REQUEST = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t TOO_GENERAL_REQUEST = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t NO_MATCH = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t NEW_NODE_CREATED = MAKE_RETURN_CODE(5);
+
+	typedef typename BinaryTree<SerializeableMatcherIF<T>>::iterator iterator;
+	typedef BinaryNode<SerializeableMatcherIF<T>> Node;
+	static const bool AND = true; //LEFT
+	static const bool OR = false; //RIGHT
+	MatchTree(BinaryNode<SerializeableMatcherIF<T>>* root,
+			uint8_t maxDepth = -1) :
+			BinaryTree<SerializeableMatcherIF<T>>(root), maxDepth(maxDepth) {
+	}
+	MatchTree(iterator root, uint8_t maxDepth = -1) :
+			BinaryTree<SerializeableMatcherIF<T>>(root.element), maxDepth(
+					maxDepth) {
+	}
+	MatchTree() :
+			BinaryTree<SerializeableMatcherIF<T>>(), maxDepth(-1) {
+	}
+	virtual ~MatchTree() {
+	}
+	virtual bool match(T number) {
+		return matchesTree(number);
+	}
+	bool matchesTree(T number) {
+		iterator iter = this->begin();
+		if (iter == this->end()) {
+			return false;
+		}
+		return matchSubtree(iter, number);
+	}
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
+		iterator iter = this->begin();
+		uint8_t count = this->countRight(iter);
+		ReturnValue_t result = SerializeAdapter::serialize(&count,
+				buffer, size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (iter == this->end()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+		result = iter->serialize(buffer, size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (maxDepth > 0) {
+			MatchTree<T> temp(iter.left(), maxDepth - 1);
+			result = temp.serialize(buffer, size, maxSize, streamEndianness);
+		}
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		iter = iter.right();
+		while (iter != this->end()) {
+			result = iter->serialize(buffer, size, maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+			if (maxDepth > 0) {
+				MatchTree<T> temp(iter.left(), maxDepth - 1);
+				result = temp.serialize(buffer, size, maxSize, streamEndianness);
+			}
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+			iter = iter.right();
+		}
+		return result;
+	}
+
+	size_t getSerializedSize() const override {
+		//Analogous to serialize!
+		uint32_t size = 1; //One for count
+		iterator iter = this->begin();
+		if (iter == this->end()) {
+			return size;
+		}
+		//Count object itself
+		size += iter->getSerializedSize();
+		//Handle everything below on AND side
+		if (maxDepth > 0) {
+			MatchTree<T> temp(iter.left(), maxDepth - 1);
+			size += temp.getSerializedSize();
+		}
+		//Handle everything on OR side
+		iter = iter.right();
+		//Iterate over every object on the OR branch
+		while (iter != this->end()) {
+			size += iter->getSerializedSize();
+			if (maxDepth > 0) {
+				//If we are allowed to go deeper, handle AND elements.
+				MatchTree<T> temp(iter.left(), maxDepth - 1);
+				size += temp.getSerializedSize();
+			}
+			iter = iter.right();
+		}
+		return size;
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+protected:
+
+	bool isOnAndBranch(iterator position) {
+		if ((position == this->end()) || (position.up() == this->end())) {
+			return false;
+		}
+		if (position.up().left() == position) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	//SHOULDDO: What to do if insertion/deletion fails. Throw event?
+	ReturnValue_t removeElementAndAllChildren(iterator position) {
+		auto children = this->erase(position);
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		if (children.first != this->end()) {
+			result = removeElementAndAllChildren(children.first);
+		}
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (children.second != this->end()) {
+			result = removeElementAndAllChildren(children.second);
+		}
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		//Delete element itself.
+		return cleanUpElement(position);
+	}
+
+	ReturnValue_t removeElementAndReconnectChildren(iterator position) {
+		if (position == this->end()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+		//Delete everything from the AND branch.
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		if (position.left() != this->end()) {
+			result = removeElementAndAllChildren(position.left());
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+
+		if (position.right() != this->end()) {
+			//There's something at the OR branch, reconnect to parent.
+			if (isOnAndBranch(position)) {
+				//Either one hierarchy up AND branch...
+				this->insert(AND, position.up(), position.right().element);
+			} else {
+				//or on another OR'ed element (or install new root node).
+				this->insert(OR, position.up(), position.right().element);
+			}
+		} else {
+			if (isOnAndBranch(position)) {
+				//Recursively delete parent node as well, because it is not expected to be there anymore.
+				return removeElementAndReconnectChildren(position.up());
+			} else {
+				//simply delete self.
+				this->erase(position);
+			}
+
+		}
+		//Delete element itself.
+		return cleanUpElement(position);
+	}
+
+	virtual ReturnValue_t cleanUpElement(iterator position) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	bool matchSubtree(iterator iter, T number) {
+		bool isMatch = iter->match(number);
+		if (isMatch) {
+			if (iter.left() == this->end()) {
+				return true;
+			}
+			isMatch = matchSubtree(iter.left(), number);
+			if (isMatch) {
+				return true;
+			}
+		}
+		if (iter.right() == this->end()) {
+			return false;
+		}
+		return matchSubtree(iter.right(), number);
+	}
+private:
+	uint8_t maxDepth;
+};
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_ */
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index 6fee1f522..ac67e8b83 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -1,70 +1,70 @@
-#ifndef RANGEMATCHER_H_
-#define RANGEMATCHER_H_
-
-#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-template<typename T>
-class RangeMatcher: public SerializeableMatcherIF<T> {
-public:
-	bool inverted;
-	T lowerBound;
-	T upperBound;
-
-	RangeMatcher() :
-			inverted(true), lowerBound(1), upperBound(0) {
-	}
-	RangeMatcher(T lowerBound, T upperBound, bool inverted = false) :
-			inverted(inverted), lowerBound(lowerBound), upperBound(upperBound) {
-	}
-
-	bool match(T input) {
-		if (inverted) {
-			return !doMatch(input);
-		} else {
-			return doMatch(input);
-		}
-	}
-
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&upperBound, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	size_t getSerializedSize() const override {
-		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
-	}
-
-	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			SerializeIF::Endianness streamEndianness) override {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
-				buffer, size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::deSerialize(&inverted, buffer, size,
-				streamEndianness);
-	}
-protected:
-	bool doMatch(T input) {
-		return (input >= lowerBound) && (input <= upperBound);
-	}
-};
-
-#endif /* RANGEMATCHER_H_ */
+#ifndef RANGEMATCHER_H_
+#define RANGEMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+
+template<typename T>
+class RangeMatcher: public SerializeableMatcherIF<T> {
+public:
+	bool inverted;
+	T lowerBound;
+	T upperBound;
+
+	RangeMatcher() :
+			inverted(true), lowerBound(1), upperBound(0) {
+	}
+	RangeMatcher(T lowerBound, T upperBound, bool inverted = false) :
+			inverted(inverted), lowerBound(lowerBound), upperBound(upperBound) {
+	}
+
+	bool match(T input) {
+		if (inverted) {
+			return !doMatch(input);
+		} else {
+			return doMatch(input);
+		}
+	}
+
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&upperBound, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	size_t getSerializedSize() const override {
+		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
+	}
+
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
+				buffer, size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::deSerialize(&inverted, buffer, size,
+				streamEndianness);
+	}
+protected:
+	bool doMatch(T input) {
+		return (input >= lowerBound) && (input <= upperBound);
+	}
+};
+
+#endif /* RANGEMATCHER_H_ */
diff --git a/globalfunctions/matching/SerializeableMatcherIF.h b/globalfunctions/matching/SerializeableMatcherIF.h
index 7b00a1b3b..0d2873ef2 100644
--- a/globalfunctions/matching/SerializeableMatcherIF.h
+++ b/globalfunctions/matching/SerializeableMatcherIF.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
-
-#include <framework/globalfunctions/matching/MatcherIF.h>
-#include <framework/serialize/SerializeIF.h>
-
-template<typename T>
-class SerializeableMatcherIF : public MatcherIF<T>, public SerializeIF {
-public:
-	virtual ~SerializeableMatcherIF() {}
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_ */
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
+
+#include "../../globalfunctions/matching/MatcherIF.h"
+#include "../../serialize/SerializeIF.h"
+
+template<typename T>
+class SerializeableMatcherIF : public MatcherIF<T>, public SerializeIF {
+public:
+	virtual ~SerializeableMatcherIF() {}
+};
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_ */
diff --git a/globalfunctions/math/QuaternionOperations.cpp b/globalfunctions/math/QuaternionOperations.cpp
index f8c751493..448d30f10 100644
--- a/globalfunctions/math/QuaternionOperations.cpp
+++ b/globalfunctions/math/QuaternionOperations.cpp
@@ -1,156 +1,156 @@
-#include "QuaternionOperations.h"
-#include <framework/globalfunctions/math/VectorOperations.h>
-
-#include <cmath>
-#include <cstring>
-#include <stdint.h>
-
-QuaternionOperations::~QuaternionOperations() {
-}
-
-void QuaternionOperations::multiply(const double* q1, const double* q2,
-		double* q) {
-	double out[4];
-
-	out[0] = q1[3] * q2[0] + q1[2] * q2[1] - q1[1] * q2[2] + q1[0] * q2[3];
-	out[1] = -q1[2] * q2[0] + q1[3] * q2[1] + q1[0] * q2[2] + q1[1] * q2[3];
-	out[2] = q1[1] * q2[0] - q1[0] * q2[1] + q1[3] * q2[2] + q1[2] * q2[3];
-	out[3] = -q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2] + q1[3] * q2[3];
-
-	memcpy(q, out, 4 * sizeof(*q));
-}
-
-void QuaternionOperations::toDcm(const double* quaternion, double dcm[][3]) {
-	dcm[0][0] = 2
-			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[0][1] = 2
-			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
-	dcm[0][2] = 2
-			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
-
-	dcm[1][0] = 2
-			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
-	dcm[1][1] = 2
-			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[1][2] = 2
-			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
-
-	dcm[2][0] = 2
-			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
-	dcm[2][1] = 2
-			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
-	dcm[2][2] = 2
-			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
-			- 1;
-}
-
-void QuaternionOperations::inverse(const double* quaternion,
-		double* inverseQuaternion) {
-	memcpy(inverseQuaternion, quaternion, 4 * sizeof(*quaternion));
-	VectorOperations<double>::mulScalar(inverseQuaternion, -1,
-			inverseQuaternion, 3);
-}
-
-QuaternionOperations::QuaternionOperations() {
-
-}
-
-void QuaternionOperations::normalize(const double* quaternion,
-		double* unitQuaternion) {
-	VectorOperations<double>::normalize(quaternion, unitQuaternion, 4);
-}
-
-float QuaternionOperations::norm(const double* quaternion) {
-	return VectorOperations<double>::norm(quaternion, 4);
-}
-
-void QuaternionOperations::fromDcm(const double dcm[][3], double* quaternion,
-		uint8_t *index) {
-
-	double a[4];
-
-	a[0] = 1 + dcm[0][0] - dcm[1][1] - dcm[2][2];
-	a[1] = 1 - dcm[0][0] + dcm[1][1] - dcm[2][2];
-	a[2] = 1 - dcm[0][0] - dcm[1][1] + dcm[2][2];
-	a[3] = 1 + dcm[0][0] + dcm[1][1] + dcm[2][2];
-
-	uint8_t maxAIndex = 0;
-
-	VectorOperations<double>::maxValue(a, 4, &maxAIndex);
-
-	if (index != 0) {
-		*index = maxAIndex;
-	}
-
-	switch (maxAIndex) {
-	case 0:
-		quaternion[0] = 0.5 * sqrt(a[0]);
-		quaternion[1] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[0]));
-		quaternion[2] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[0]));
-		quaternion[3] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[0]));
-		break;
-	case 1:
-		quaternion[0] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[1]));
-		quaternion[1] = 0.5 * sqrt(a[1]);
-		quaternion[2] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[1]));
-		quaternion[3] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[1]));
-		break;
-	case 2:
-		quaternion[0] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[2]));
-		quaternion[1] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[2]));
-		quaternion[2] = 0.5 * sqrt(a[2]);
-		quaternion[3] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[2]));
-		break;
-	case 3:
-		quaternion[0] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[3]));
-		quaternion[1] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[3]));
-		quaternion[2] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[3]));
-		quaternion[3] = 0.5 * sqrt(a[3]);
-		break;
-	}
-
-}
-
-void QuaternionOperations::toDcm(const double* quaternion, float dcm[][3]) {
-	dcm[0][0] = 2
-			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[0][1] = 2
-			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
-	dcm[0][2] = 2
-			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
-
-	dcm[1][0] = 2
-			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
-	dcm[1][1] = 2
-			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[1][2] = 2
-			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
-
-	dcm[2][0] = 2
-			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
-	dcm[2][1] = 2
-			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
-	dcm[2][2] = 2
-			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
-			- 1;
-}
-
-void QuaternionOperations::normalize(double* quaternion) {
-	normalize(quaternion, quaternion);
-}
-
-double QuaternionOperations::getAngle(const double* quaternion, bool abs) {
-	if (quaternion[3] >= 0) {
-		return 2 * acos(quaternion[3]);
-	} else {
-		if (abs) {
-			return 2 * acos(-quaternion[3]);
-		} else {
-			return -2 * acos(-quaternion[3]);
-		}
-	}
-}
+#include "QuaternionOperations.h"
+#include "../../globalfunctions/math/VectorOperations.h"
+
+#include <cmath>
+#include <cstring>
+#include <stdint.h>
+
+QuaternionOperations::~QuaternionOperations() {
+}
+
+void QuaternionOperations::multiply(const double* q1, const double* q2,
+		double* q) {
+	double out[4];
+
+	out[0] = q1[3] * q2[0] + q1[2] * q2[1] - q1[1] * q2[2] + q1[0] * q2[3];
+	out[1] = -q1[2] * q2[0] + q1[3] * q2[1] + q1[0] * q2[2] + q1[1] * q2[3];
+	out[2] = q1[1] * q2[0] - q1[0] * q2[1] + q1[3] * q2[2] + q1[2] * q2[3];
+	out[3] = -q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2] + q1[3] * q2[3];
+
+	memcpy(q, out, 4 * sizeof(*q));
+}
+
+void QuaternionOperations::toDcm(const double* quaternion, double dcm[][3]) {
+	dcm[0][0] = 2
+			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[0][1] = 2
+			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
+	dcm[0][2] = 2
+			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
+
+	dcm[1][0] = 2
+			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
+	dcm[1][1] = 2
+			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[1][2] = 2
+			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
+
+	dcm[2][0] = 2
+			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
+	dcm[2][1] = 2
+			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
+	dcm[2][2] = 2
+			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
+			- 1;
+}
+
+void QuaternionOperations::inverse(const double* quaternion,
+		double* inverseQuaternion) {
+	memcpy(inverseQuaternion, quaternion, 4 * sizeof(*quaternion));
+	VectorOperations<double>::mulScalar(inverseQuaternion, -1,
+			inverseQuaternion, 3);
+}
+
+QuaternionOperations::QuaternionOperations() {
+
+}
+
+void QuaternionOperations::normalize(const double* quaternion,
+		double* unitQuaternion) {
+	VectorOperations<double>::normalize(quaternion, unitQuaternion, 4);
+}
+
+float QuaternionOperations::norm(const double* quaternion) {
+	return VectorOperations<double>::norm(quaternion, 4);
+}
+
+void QuaternionOperations::fromDcm(const double dcm[][3], double* quaternion,
+		uint8_t *index) {
+
+	double a[4];
+
+	a[0] = 1 + dcm[0][0] - dcm[1][1] - dcm[2][2];
+	a[1] = 1 - dcm[0][0] + dcm[1][1] - dcm[2][2];
+	a[2] = 1 - dcm[0][0] - dcm[1][1] + dcm[2][2];
+	a[3] = 1 + dcm[0][0] + dcm[1][1] + dcm[2][2];
+
+	uint8_t maxAIndex = 0;
+
+	VectorOperations<double>::maxValue(a, 4, &maxAIndex);
+
+	if (index != 0) {
+		*index = maxAIndex;
+	}
+
+	switch (maxAIndex) {
+	case 0:
+		quaternion[0] = 0.5 * sqrt(a[0]);
+		quaternion[1] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[0]));
+		quaternion[2] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[0]));
+		quaternion[3] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[0]));
+		break;
+	case 1:
+		quaternion[0] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[1]));
+		quaternion[1] = 0.5 * sqrt(a[1]);
+		quaternion[2] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[1]));
+		quaternion[3] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[1]));
+		break;
+	case 2:
+		quaternion[0] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[2]));
+		quaternion[1] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[2]));
+		quaternion[2] = 0.5 * sqrt(a[2]);
+		quaternion[3] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[2]));
+		break;
+	case 3:
+		quaternion[0] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[3]));
+		quaternion[1] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[3]));
+		quaternion[2] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[3]));
+		quaternion[3] = 0.5 * sqrt(a[3]);
+		break;
+	}
+
+}
+
+void QuaternionOperations::toDcm(const double* quaternion, float dcm[][3]) {
+	dcm[0][0] = 2
+			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[0][1] = 2
+			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
+	dcm[0][2] = 2
+			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
+
+	dcm[1][0] = 2
+			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
+	dcm[1][1] = 2
+			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[1][2] = 2
+			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
+
+	dcm[2][0] = 2
+			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
+	dcm[2][1] = 2
+			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
+	dcm[2][2] = 2
+			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
+			- 1;
+}
+
+void QuaternionOperations::normalize(double* quaternion) {
+	normalize(quaternion, quaternion);
+}
+
+double QuaternionOperations::getAngle(const double* quaternion, bool abs) {
+	if (quaternion[3] >= 0) {
+		return 2 * acos(quaternion[3]);
+	} else {
+		if (abs) {
+			return 2 * acos(-quaternion[3]);
+		} else {
+			return -2 * acos(-quaternion[3]);
+		}
+	}
+}
diff --git a/globalfunctions/timevalOperations.cpp b/globalfunctions/timevalOperations.cpp
index 1da45d7b1..aa921511a 100644
--- a/globalfunctions/timevalOperations.cpp
+++ b/globalfunctions/timevalOperations.cpp
@@ -1,99 +1,99 @@
-#include <framework/globalfunctions/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;
-}
+#include "../globalfunctions/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;
+}
diff --git a/health/HasHealthIF.h b/health/HasHealthIF.h
index dd27fe39f..9ef8c1e99 100644
--- a/health/HasHealthIF.h
+++ b/health/HasHealthIF.h
@@ -1,50 +1,50 @@
-#ifndef HASHEALTHIF_H_
-#define HASHEALTHIF_H_
-
-#include <framework/events/Event.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class HasHealthIF {
-public:
-
-	typedef enum {
-		HEALTHY = 1, FAULTY = 0, EXTERNAL_CONTROL = 2, NEEDS_RECOVERY = 3, PERMANENT_FAULTY = 4
-	} HealthState;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
-	static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
-	static const Event HEALTH_INFO = MAKE_EVENT(6, SEVERITY::INFO);
-	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, SEVERITY::INFO);
-	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, SEVERITY::LOW);
-	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, SEVERITY::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
-	static const Event TRYING_RECOVERY = MAKE_EVENT(10, SEVERITY::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
-	static const Event RECOVERY_STEP = MAKE_EVENT(11, SEVERITY::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
-	static const Event RECOVERY_DONE = MAKE_EVENT(12, SEVERITY::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
-
-	virtual ~HasHealthIF() {
-	}
-
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-
-	/**
-	 * set the Health State
-	 *
-	 * The parent will be informed, if the Health changes
-	 *
-	 * @param health
-	 */
-	virtual ReturnValue_t setHealth(HealthState health) = 0;
-
-	/**
-	 * get Health State
-	 *
-	 * @return Health State of the object
-	 */
-	virtual HasHealthIF::HealthState getHealth() = 0;
-};
-
-#endif /* HASHEALTHIF_H_ */
+#ifndef HASHEALTHIF_H_
+#define HASHEALTHIF_H_
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class HasHealthIF {
+public:
+
+	typedef enum {
+		HEALTHY = 1, FAULTY = 0, EXTERNAL_CONTROL = 2, NEEDS_RECOVERY = 3, PERMANENT_FAULTY = 4
+	} HealthState;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
+	static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
+	static const Event HEALTH_INFO = MAKE_EVENT(6, SEVERITY::INFO);
+	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, SEVERITY::INFO);
+	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, SEVERITY::LOW);
+	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, SEVERITY::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
+	static const Event TRYING_RECOVERY = MAKE_EVENT(10, SEVERITY::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
+	static const Event RECOVERY_STEP = MAKE_EVENT(11, SEVERITY::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
+	static const Event RECOVERY_DONE = MAKE_EVENT(12, SEVERITY::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
+
+	virtual ~HasHealthIF() {
+	}
+
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+	/**
+	 * set the Health State
+	 *
+	 * The parent will be informed, if the Health changes
+	 *
+	 * @param health
+	 */
+	virtual ReturnValue_t setHealth(HealthState health) = 0;
+
+	/**
+	 * get Health State
+	 *
+	 * @return Health State of the object
+	 */
+	virtual HasHealthIF::HealthState getHealth() = 0;
+};
+
+#endif /* HASHEALTHIF_H_ */
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index ba8504c22..800d6e367 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -1,105 +1,105 @@
-#include <framework/health/HealthHelper.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
-		objectId(objectId), owner(owner) {
-}
-
-HealthHelper::~HealthHelper() {
-}
-
-ReturnValue_t HealthHelper::handleHealthCommand(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case HealthMessage::HEALTH_SET:
-		handleSetHealthCommand(message);
-		return HasReturnvaluesIF::RETURN_OK;
-	case HealthMessage::HEALTH_ANNOUNCE: {
-		eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, getHealth(),
-				getHealth());
-	}
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-HasHealthIF::HealthState HealthHelper::getHealth() {
-	return healthTable->getHealth(objectId);
-}
-
-ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
-	setParentQueue(parentQueue);
-	return initialize();
-}
-
-void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
-	this->parentQueue = parentQueue;
-}
-
-ReturnValue_t HealthHelper::initialize() {
-	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
-	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
-
-	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) {
-		return result;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HealthHelper::setHealth(HasHealthIF::HealthState health) {
-	HasHealthIF::HealthState oldHealth = getHealth();
-	eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, health, oldHealth);
-	if (health != oldHealth) {
-		healthTable->setHealth(objectId, health);
-		informParent(health, oldHealth);
-	}
-}
-
-void HealthHelper::informParent(HasHealthIF::HealthState health,
-		HasHealthIF::HealthState oldHealth) {
-	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
-		return;
-	}
-	CommandMessage information;
-	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
-			health, oldHealth);
-	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
-	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "HealthHelper::informParent: sending health reply failed."
-				<< std::endl;
-	}
-}
-
-void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
-	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
-	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
-		return;
-	}
-	CommandMessage reply;
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		HealthMessage::setHealthMessage(&reply,
-				HealthMessage::REPLY_HEALTH_SET);
-	} else {
-		reply.setReplyRejected(result, command->getCommand());
-	}
-	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "HealthHelper::handleHealthCommand: sending health "
-		        "reply failed." << std::endl;
-
-	}
-}
+#include "../health/HealthHelper.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
+		objectId(objectId), owner(owner) {
+}
+
+HealthHelper::~HealthHelper() {
+}
+
+ReturnValue_t HealthHelper::handleHealthCommand(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case HealthMessage::HEALTH_SET:
+		handleSetHealthCommand(message);
+		return HasReturnvaluesIF::RETURN_OK;
+	case HealthMessage::HEALTH_ANNOUNCE: {
+		eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, getHealth(),
+				getHealth());
+	}
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+HasHealthIF::HealthState HealthHelper::getHealth() {
+	return healthTable->getHealth(objectId);
+}
+
+ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
+	setParentQueue(parentQueue);
+	return initialize();
+}
+
+void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
+	this->parentQueue = parentQueue;
+}
+
+ReturnValue_t HealthHelper::initialize() {
+	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
+	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
+
+	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) {
+		return result;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void HealthHelper::setHealth(HasHealthIF::HealthState health) {
+	HasHealthIF::HealthState oldHealth = getHealth();
+	eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, health, oldHealth);
+	if (health != oldHealth) {
+		healthTable->setHealth(objectId, health);
+		informParent(health, oldHealth);
+	}
+}
+
+void HealthHelper::informParent(HasHealthIF::HealthState health,
+		HasHealthIF::HealthState oldHealth) {
+	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
+		return;
+	}
+	CommandMessage information;
+	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
+			health, oldHealth);
+	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "HealthHelper::informParent: sending health reply failed."
+				<< std::endl;
+	}
+}
+
+void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
+	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
+	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
+		return;
+	}
+	CommandMessage reply;
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		HealthMessage::setHealthMessage(&reply,
+				HealthMessage::REPLY_HEALTH_SET);
+	} else {
+		reply.setReplyRejected(result, command->getCommand());
+	}
+	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "HealthHelper::handleHealthCommand: sending health "
+		        "reply failed." << std::endl;
+
+	}
+}
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index e112ad2c7..99bb501fb 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -1,121 +1,121 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHHELPER_H_
-#define FRAMEWORK_HEALTH_HEALTHHELPER_H_
-
-#include <framework/events/EventManagerIF.h>
-#include <framework/events/EventReportingProxyIF.h>
-#include <framework/health/HasHealthIF.h>
-#include <framework/health/HealthMessage.h>
-#include <framework/health/HealthTableIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-/**
- * Helper class for Objects that implement HasHealthIF
- *
- * It takes care of registering with the Health Table as well as handling health commands
- * (including replying to the sender) and updating the Health Table.
- *
- * If a parent is set in the ctor, the parent will be informed with a @c HEALTH_INFO message
- * about changes in the health state. Note that a @c HEALTH_INFO is only generated if the Health
- * changes, not for all @c HEALTH_SET commands received.
- *
- * It does NOT handle @c HEALTH_INFO messages
- */
-class HealthHelper {
-public:
-
-	/**
-	 * ctor
-	 *
-	 * @param owner
-	 * @param objectId the object Id to use when communication with the HealthTable
-	 */
-	HealthHelper(HasHealthIF* owner, object_id_t objectId);
-
-	virtual ~HealthHelper();
-
-	/**
-	 * Pointer to the Health Table
-	 *
-	 * only valid after initialize() has been called
-	 */
-	HealthTableIF *healthTable = nullptr;
-
-	/**
-	 * Proxy to forward events.
-	 */
-	EventReportingProxyIF* eventSender = nullptr;
-
-	/**
-	 * Try to handle the message.
-	 *
-	 * This function handles @c HEALTH_SET and @c HEALTH_READ commands.
-	 * it updates the Health Table and generates a reply to the sender.
-	 *
-	 * @param message
-	 * @return
-	 * 			-@c RETURN_OK if the message was handled
-	 * 			-@c RETURN_FAILED if the message could not be handled (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
-	 */
-	ReturnValue_t handleHealthCommand(CommandMessage *message);
-
-	/**
-	 * set the Health State
-	 *
-	 * The parent will be informed, if the Health changes
-	 *
-	 * @param health
-	 */
-	void setHealth(HasHealthIF::HealthState health);
-
-	/**
-	 * get Health State
-	 *
-	 * @return Health State of the object
-	 */
-	HasHealthIF::HealthState getHealth();
-
-	/**
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
-	 */
-	void setParentQueue(MessageQueueId_t parentQueue);
-
-	/**
-	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
-	 * @return
-	 * 			-@c RETURN_OK if the Health Table was found and the object could be registered
-	 * 			-@c RETURN_FAILED else
-	 */
-	ReturnValue_t initialize(MessageQueueId_t parentQueue );
-
-	ReturnValue_t initialize();
-
-private:
-	/**
-	 * the object id to use when communicating with the Health Table
-	 */
-	object_id_t objectId;
-
-	/**
-	 * The Queue of the parent
-	 */
-	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
-
-	/**
-	 * The one using the healthHelper.
-	 */
-	HasHealthIF* owner;
-
-	/**
-	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message will be sent to this queue
-	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
-	 * @param oldHealth information of the previous health state.
-	 */
-	void informParent(HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth);
-
-	void handleSetHealthCommand(CommandMessage *message);
-};
-
-#endif /* HEALTHHELPER_H_ */
+#ifndef FRAMEWORK_HEALTH_HEALTHHELPER_H_
+#define FRAMEWORK_HEALTH_HEALTHHELPER_H_
+
+#include "../events/EventManagerIF.h"
+#include "../events/EventReportingProxyIF.h"
+#include "../health/HasHealthIF.h"
+#include "../health/HealthMessage.h"
+#include "../health/HealthTableIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * Helper class for Objects that implement HasHealthIF
+ *
+ * It takes care of registering with the Health Table as well as handling health commands
+ * (including replying to the sender) and updating the Health Table.
+ *
+ * If a parent is set in the ctor, the parent will be informed with a @c HEALTH_INFO message
+ * about changes in the health state. Note that a @c HEALTH_INFO is only generated if the Health
+ * changes, not for all @c HEALTH_SET commands received.
+ *
+ * It does NOT handle @c HEALTH_INFO messages
+ */
+class HealthHelper {
+public:
+
+	/**
+	 * ctor
+	 *
+	 * @param owner
+	 * @param objectId the object Id to use when communication with the HealthTable
+	 */
+	HealthHelper(HasHealthIF* owner, object_id_t objectId);
+
+	virtual ~HealthHelper();
+
+	/**
+	 * Pointer to the Health Table
+	 *
+	 * only valid after initialize() has been called
+	 */
+	HealthTableIF *healthTable = nullptr;
+
+	/**
+	 * Proxy to forward events.
+	 */
+	EventReportingProxyIF* eventSender = nullptr;
+
+	/**
+	 * Try to handle the message.
+	 *
+	 * This function handles @c HEALTH_SET and @c HEALTH_READ commands.
+	 * it updates the Health Table and generates a reply to the sender.
+	 *
+	 * @param message
+	 * @return
+	 * 			-@c RETURN_OK if the message was handled
+	 * 			-@c RETURN_FAILED if the message could not be handled (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
+	 */
+	ReturnValue_t handleHealthCommand(CommandMessage *message);
+
+	/**
+	 * set the Health State
+	 *
+	 * The parent will be informed, if the Health changes
+	 *
+	 * @param health
+	 */
+	void setHealth(HasHealthIF::HealthState health);
+
+	/**
+	 * get Health State
+	 *
+	 * @return Health State of the object
+	 */
+	HasHealthIF::HealthState getHealth();
+
+	/**
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 */
+	void setParentQueue(MessageQueueId_t parentQueue);
+
+	/**
+	 *
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @return
+	 * 			-@c RETURN_OK if the Health Table was found and the object could be registered
+	 * 			-@c RETURN_FAILED else
+	 */
+	ReturnValue_t initialize(MessageQueueId_t parentQueue );
+
+	ReturnValue_t initialize();
+
+private:
+	/**
+	 * the object id to use when communicating with the Health Table
+	 */
+	object_id_t objectId;
+
+	/**
+	 * The Queue of the parent
+	 */
+	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
+
+	/**
+	 * The one using the healthHelper.
+	 */
+	HasHealthIF* owner;
+
+	/**
+	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message will be sent to this queue
+	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
+	 * @param oldHealth information of the previous health state.
+	 */
+	void informParent(HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth);
+
+	void handleSetHealthCommand(CommandMessage *message);
+};
+
+#endif /* HEALTHHELPER_H_ */
diff --git a/health/HealthMessage.cpp b/health/HealthMessage.cpp
index 768dea469..c5f5b733d 100644
--- a/health/HealthMessage.cpp
+++ b/health/HealthMessage.cpp
@@ -1,28 +1,28 @@
-#include <framework/health/HealthMessage.h>
-
-void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
-		HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth) {
-	message->setCommand(command);
-	message->setParameter(health);
-	message->setParameter2(oldHealth);
-}
-
-void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command) {
-	message->setCommand(command);
-}
-
-HasHealthIF::HealthState HealthMessage::getHealth(const CommandMessage* message) {
-	return (HasHealthIF::HealthState) message->getParameter();
-}
-
-void HealthMessage::clear(CommandMessage* message) {
-	message->setCommand(CommandMessage::CMD_NONE);
-}
-
-HealthMessage::HealthMessage() {
-}
-
-HasHealthIF::HealthState HealthMessage::getOldHealth(
-		const CommandMessage* message) {
-	return (HasHealthIF::HealthState) message->getParameter2();
-}
+#include "../health/HealthMessage.h"
+
+void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
+		HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth) {
+	message->setCommand(command);
+	message->setParameter(health);
+	message->setParameter2(oldHealth);
+}
+
+void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command) {
+	message->setCommand(command);
+}
+
+HasHealthIF::HealthState HealthMessage::getHealth(const CommandMessage* message) {
+	return (HasHealthIF::HealthState) message->getParameter();
+}
+
+void HealthMessage::clear(CommandMessage* message) {
+	message->setCommand(CommandMessage::CMD_NONE);
+}
+
+HealthMessage::HealthMessage() {
+}
+
+HasHealthIF::HealthState HealthMessage::getOldHealth(
+		const CommandMessage* message) {
+	return (HasHealthIF::HealthState) message->getParameter2();
+}
diff --git a/health/HealthMessage.h b/health/HealthMessage.h
index 13e79b88e..d16c65db1 100644
--- a/health/HealthMessage.h
+++ b/health/HealthMessage.h
@@ -1,30 +1,30 @@
-#ifndef HEALTHMESSAGE_H_
-#define HEALTHMESSAGE_H_
-
-#include <framework/health/HasHealthIF.h>
-#include <framework/ipc/CommandMessage.h>
-
-class HealthMessage {
-public:
-	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);
-	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
-
-	static void setHealthMessage(CommandMessage *message, Command_t command,
-			HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
-
-	static void setHealthMessage(CommandMessage *message, Command_t command);
-
-	static HasHealthIF::HealthState getHealth(const CommandMessage *message);
-
-	static HasHealthIF::HealthState getOldHealth(const CommandMessage *message);
-
-	static void clear(CommandMessage *message);
-
-private:
-	HealthMessage();
-};
-
-#endif /* HEALTHMESSAGE_H_ */
+#ifndef HEALTHMESSAGE_H_
+#define HEALTHMESSAGE_H_
+
+#include "../health/HasHealthIF.h"
+#include "../ipc/CommandMessage.h"
+
+class HealthMessage {
+public:
+	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);
+	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
+
+	static void setHealthMessage(CommandMessage *message, Command_t command,
+			HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
+
+	static void setHealthMessage(CommandMessage *message, Command_t command);
+
+	static HasHealthIF::HealthState getHealth(const CommandMessage *message);
+
+	static HasHealthIF::HealthState getOldHealth(const CommandMessage *message);
+
+	static void clear(CommandMessage *message);
+
+private:
+	HealthMessage();
+};
+
+#endif /* HEALTHMESSAGE_H_ */
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index e11dcd97f..88db89b19 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -1,100 +1,100 @@
-#include <framework/health/HealthTable.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/ipc/MutexFactory.h>
-
-HealthTable::HealthTable(object_id_t objectid) :
-		SystemObject(objectid) {
-	mutex = MutexFactory::instance()->createMutex();;
-
-	mapIterator = healthMap.begin();
-}
-
-HealthTable::~HealthTable() {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-ReturnValue_t HealthTable::registerObject(object_id_t object,
-		HasHealthIF::HealthState initilialState) {
-	if (healthMap.count(object) != 0) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	healthMap.insert(
-			std::pair<object_id_t, HasHealthIF::HealthState>(object,
-					initilialState));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HealthTable::setHealth(object_id_t object,
-		HasHealthIF::HealthState newState) {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	HealthMap::iterator iter = healthMap.find(object);
-	if (iter != healthMap.end()) {
-		iter->second = newState;
-	}
-	mutex->unlockMutex();
-}
-
-HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
-	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	HealthMap::iterator iter = healthMap.find(object);
-	if (iter != healthMap.end()) {
-		state = iter->second;
-	}
-	mutex->unlockMutex();
-	return state;
-}
-
-uint32_t HealthTable::getPrintSize() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	uint32_t size = healthMap.size() * 5 + 2;
-	mutex->unlockMutex();
-	return size;
-}
-
-bool HealthTable::hasHealth(object_id_t object) {
-	bool exits = false;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	HealthMap::iterator iter = healthMap.find(object);
-	if (iter != healthMap.end()) {
-		exits = true;
-	}
-	mutex->unlockMutex();
-	return exits;
-}
-
-void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	size_t size = 0;
-	uint16_t count = healthMap.size();
-	ReturnValue_t result = SerializeAdapter::serialize(&count,
-			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-	HealthMap::iterator iter;
-	for (iter = healthMap.begin();
-			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
-			++iter) {
-		result = SerializeAdapter::serialize(&iter->first,
-				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-		uint8_t health = iter->second;
-		result = SerializeAdapter::serialize(&health, &pointer, &size,
-				maxSize, SerializeIF::Endianness::BIG);
-	}
-	mutex->unlockMutex();
-}
-
-ReturnValue_t HealthTable::iterate(
-		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	if (reset) {
-		mapIterator = healthMap.begin();
-	}
-	if (mapIterator == healthMap.end()) {
-		result = HasReturnvaluesIF::RETURN_FAILED;
-	}
-	*value = *mapIterator;
-	mapIterator++;
-	mutex->unlockMutex();
-
-	return result;
-}
+#include "../health/HealthTable.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../ipc/MutexFactory.h"
+
+HealthTable::HealthTable(object_id_t objectid) :
+		SystemObject(objectid) {
+	mutex = MutexFactory::instance()->createMutex();;
+
+	mapIterator = healthMap.begin();
+}
+
+HealthTable::~HealthTable() {
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+ReturnValue_t HealthTable::registerObject(object_id_t object,
+		HasHealthIF::HealthState initilialState) {
+	if (healthMap.count(object) != 0) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	healthMap.insert(
+			std::pair<object_id_t, HasHealthIF::HealthState>(object,
+					initilialState));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void HealthTable::setHealth(object_id_t object,
+		HasHealthIF::HealthState newState) {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	HealthMap::iterator iter = healthMap.find(object);
+	if (iter != healthMap.end()) {
+		iter->second = newState;
+	}
+	mutex->unlockMutex();
+}
+
+HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
+	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	HealthMap::iterator iter = healthMap.find(object);
+	if (iter != healthMap.end()) {
+		state = iter->second;
+	}
+	mutex->unlockMutex();
+	return state;
+}
+
+uint32_t HealthTable::getPrintSize() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	uint32_t size = healthMap.size() * 5 + 2;
+	mutex->unlockMutex();
+	return size;
+}
+
+bool HealthTable::hasHealth(object_id_t object) {
+	bool exits = false;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	HealthMap::iterator iter = healthMap.find(object);
+	if (iter != healthMap.end()) {
+		exits = true;
+	}
+	mutex->unlockMutex();
+	return exits;
+}
+
+void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	size_t size = 0;
+	uint16_t count = healthMap.size();
+	ReturnValue_t result = SerializeAdapter::serialize(&count,
+			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
+	HealthMap::iterator iter;
+	for (iter = healthMap.begin();
+			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
+			++iter) {
+		result = SerializeAdapter::serialize(&iter->first,
+				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
+		uint8_t health = iter->second;
+		result = SerializeAdapter::serialize(&health, &pointer, &size,
+				maxSize, SerializeIF::Endianness::BIG);
+	}
+	mutex->unlockMutex();
+}
+
+ReturnValue_t HealthTable::iterate(
+		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	if (reset) {
+		mapIterator = healthMap.begin();
+	}
+	if (mapIterator == healthMap.end()) {
+		result = HasReturnvaluesIF::RETURN_FAILED;
+	}
+	*value = *mapIterator;
+	mapIterator++;
+	mutex->unlockMutex();
+
+	return result;
+}
diff --git a/health/HealthTable.h b/health/HealthTable.h
index 6f1ac8296..5ed450412 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -1,35 +1,35 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHTABLE_H_
-#define FRAMEWORK_HEALTH_HEALTHTABLE_H_
-
-#include <framework/health/HealthTableIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/ipc/MutexIF.h>
-#include <map>
-
-typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
-
-class HealthTable: public HealthTableIF, public SystemObject {
-public:
-	HealthTable(object_id_t objectid);
-	virtual ~HealthTable();
-
-	virtual ReturnValue_t registerObject(object_id_t object,
-			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY);
-
-	virtual bool hasHealth(object_id_t object);
-	virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState);
-	virtual HasHealthIF::HealthState getHealth(object_id_t);
-
-	virtual uint32_t getPrintSize();
-	virtual void printAll(uint8_t *pointer, size_t maxSize);
-
-protected:
-	MutexIF* mutex;
-	HealthMap healthMap;
-
-	HealthMap::iterator mapIterator;
-
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false);
-};
-
-#endif /* HEALTHTABLE_H_ */
+#ifndef FRAMEWORK_HEALTH_HEALTHTABLE_H_
+#define FRAMEWORK_HEALTH_HEALTHTABLE_H_
+
+#include "../health/HealthTableIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
+
+class HealthTable: public HealthTableIF, public SystemObject {
+public:
+	HealthTable(object_id_t objectid);
+	virtual ~HealthTable();
+
+	virtual ReturnValue_t registerObject(object_id_t object,
+			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY);
+
+	virtual bool hasHealth(object_id_t object);
+	virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState);
+	virtual HasHealthIF::HealthState getHealth(object_id_t);
+
+	virtual uint32_t getPrintSize();
+	virtual void printAll(uint8_t *pointer, size_t maxSize);
+
+protected:
+	MutexIF* mutex;
+	HealthMap healthMap;
+
+	HealthMap::iterator mapIterator;
+
+	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false);
+};
+
+#endif /* HEALTHTABLE_H_ */
diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h
index e4606286f..bc4a8cfba 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -1,28 +1,28 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
-#define FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
-
-#include <framework/health/ManagesHealthIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <map>
-
-
-class HealthTableIF: public ManagesHealthIF {
-	// TODO: This is in the mission folder and not in the framework folder.
-	// delete it?
-	friend class HealthCommandingService;
-public:
-	virtual ~HealthTableIF() {
-	}
-
-	virtual ReturnValue_t registerObject(object_id_t object,
-			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
-
-	virtual uint32_t getPrintSize() = 0;
-	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
-
-protected:
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
-};
-
-#endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */
+#ifndef FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
+#define FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
+
+#include "../health/ManagesHealthIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <map>
+
+
+class HealthTableIF: public ManagesHealthIF {
+	// TODO: This is in the mission folder and not in the framework folder.
+	// delete it?
+	friend class HealthCommandingService;
+public:
+	virtual ~HealthTableIF() {
+	}
+
+	virtual ReturnValue_t registerObject(object_id_t object,
+			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
+
+	virtual uint32_t getPrintSize() = 0;
+	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
+
+protected:
+	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
+};
+
+#endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */
diff --git a/health/ManagesHealthIF.h b/health/ManagesHealthIF.h
index ff0c53860..57996dda0 100644
--- a/health/ManagesHealthIF.h
+++ b/health/ManagesHealthIF.h
@@ -1,52 +1,52 @@
-#ifndef FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
-#define FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
-
-#include <framework/health/HasHealthIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-class ManagesHealthIF {
-public:
-	virtual ~ManagesHealthIF() {
-	}
-	virtual bool hasHealth(object_id_t object) = 0;
-	virtual void setHealth(object_id_t object,
-			HasHealthIF::HealthState newState) = 0;
-	virtual HasHealthIF::HealthState getHealth(object_id_t) = 0;
-
-	virtual bool isHealthy(object_id_t object) {
-		return (getHealth(object) == HasHealthIF::HEALTHY);
-	}
-
-	virtual bool isHealthy(HasHealthIF::HealthState health) {
-		return (health == HasHealthIF::HEALTHY);
-	}
-
-	virtual bool isFaulty(object_id_t object) {
-		HasHealthIF::HealthState health = getHealth(object);
-		return isFaulty(health);
-	}
-
-	virtual bool isPermanentFaulty(object_id_t object) {
-		HasHealthIF::HealthState health = getHealth(object);
-		return isPermanentFaulty(health);
-	}
-
-	virtual bool isPermanentFaulty(HasHealthIF::HealthState health) {
-		return (health == HasHealthIF::PERMANENT_FAULTY);
-	}
-
-	static bool isFaulty(HasHealthIF::HealthState health) {
-		return ((health == HasHealthIF::FAULTY)
-				|| (health == HasHealthIF::PERMANENT_FAULTY)
-				|| (health == HasHealthIF::NEEDS_RECOVERY));
-	}
-
-	virtual bool isCommandable(object_id_t object) {
-		return (getHealth(object) != HasHealthIF::EXTERNAL_CONTROL);
-	}
-
-	virtual bool isCommandable(HasHealthIF::HealthState health) {
-		return (health != HasHealthIF::EXTERNAL_CONTROL);
-	}
-};
-
-#endif /* FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ */
+#ifndef FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
+#define FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
+
+#include "../health/HasHealthIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+class ManagesHealthIF {
+public:
+	virtual ~ManagesHealthIF() {
+	}
+	virtual bool hasHealth(object_id_t object) = 0;
+	virtual void setHealth(object_id_t object,
+			HasHealthIF::HealthState newState) = 0;
+	virtual HasHealthIF::HealthState getHealth(object_id_t) = 0;
+
+	virtual bool isHealthy(object_id_t object) {
+		return (getHealth(object) == HasHealthIF::HEALTHY);
+	}
+
+	virtual bool isHealthy(HasHealthIF::HealthState health) {
+		return (health == HasHealthIF::HEALTHY);
+	}
+
+	virtual bool isFaulty(object_id_t object) {
+		HasHealthIF::HealthState health = getHealth(object);
+		return isFaulty(health);
+	}
+
+	virtual bool isPermanentFaulty(object_id_t object) {
+		HasHealthIF::HealthState health = getHealth(object);
+		return isPermanentFaulty(health);
+	}
+
+	virtual bool isPermanentFaulty(HasHealthIF::HealthState health) {
+		return (health == HasHealthIF::PERMANENT_FAULTY);
+	}
+
+	static bool isFaulty(HasHealthIF::HealthState health) {
+		return ((health == HasHealthIF::FAULTY)
+				|| (health == HasHealthIF::PERMANENT_FAULTY)
+				|| (health == HasHealthIF::NEEDS_RECOVERY));
+	}
+
+	virtual bool isCommandable(object_id_t object) {
+		return (getHealth(object) != HasHealthIF::EXTERNAL_CONTROL);
+	}
+
+	virtual bool isCommandable(HasHealthIF::HealthState health) {
+		return (health != HasHealthIF::EXTERNAL_CONTROL);
+	}
+};
+
+#endif /* FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ */
diff --git a/housekeeping/AcceptsHkPacketsIF.h b/housekeeping/AcceptsHkPacketsIF.h
index f44e1d950..879aaf8e4 100644
--- a/housekeeping/AcceptsHkPacketsIF.h
+++ b/housekeeping/AcceptsHkPacketsIF.h
@@ -1,11 +1,11 @@
-#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
-#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
-#include <framework/ipc/MessageQueueMessageIF.h>
-
-class AcceptsHkPacketsIF {
-public:
-    virtual~ AcceptsHkPacketsIF() {};
-    virtual MessageQueueId_t getHkQueue() const = 0;
-};
-
-#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */
+#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#include "../ipc/MessageQueueMessageIF.h"
+
+class AcceptsHkPacketsIF {
+public:
+    virtual~ AcceptsHkPacketsIF() {};
+    virtual MessageQueueId_t getHkQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 2335f03dd..6777c4715 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,48 +1,48 @@
-#include <framework/housekeeping/HousekeepingMessage.h>
-#include <cstring>
-
-HousekeepingMessage::~HousekeepingMessage() {}
-
-void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
-		store_address_t storeId) {
-	message->setCommand(HK_REPORT);
-	message->setMessageSize(HK_MESSAGE_SIZE);
-	setSid(message, sid);
-	setParameter(message, storeId.raw);
-}
-
-void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
-		sid_t sid, store_address_t storeId) {
-	message->setCommand(DIAGNOSTICS_REPORT);
-	message->setMessageSize(HK_MESSAGE_SIZE);
-	setSid(message, sid);
-	setParameter(message, storeId.raw);
-}
-
-sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
-		store_address_t *storeIdToSet) {
-	if(storeIdToSet != nullptr) {
-		*storeIdToSet = getParameter(message);
-	}
-	return getSid(message);
-}
-
-sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
-	sid_t sid;
-	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
-	return sid;
-}
-
-void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
-	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
-}
-
-
-void HousekeepingMessage::setParameter(CommandMessage *message,
-		uint32_t parameter) {
-	message->setParameter3(parameter);
-}
-
-uint32_t HousekeepingMessage::getParameter(const CommandMessage *message) {
-	return message->getParameter3();
-}
+#include "../housekeeping/HousekeepingMessage.h"
+#include <cstring>
+
+HousekeepingMessage::~HousekeepingMessage() {}
+
+void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
+		store_address_t storeId) {
+	message->setCommand(HK_REPORT);
+	message->setMessageSize(HK_MESSAGE_SIZE);
+	setSid(message, sid);
+	setParameter(message, storeId.raw);
+}
+
+void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
+		sid_t sid, store_address_t storeId) {
+	message->setCommand(DIAGNOSTICS_REPORT);
+	message->setMessageSize(HK_MESSAGE_SIZE);
+	setSid(message, sid);
+	setParameter(message, storeId.raw);
+}
+
+sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
+		store_address_t *storeIdToSet) {
+	if(storeIdToSet != nullptr) {
+		*storeIdToSet = getParameter(message);
+	}
+	return getSid(message);
+}
+
+sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
+	sid_t sid;
+	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
+	return sid;
+}
+
+void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
+	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
+}
+
+
+void HousekeepingMessage::setParameter(CommandMessage *message,
+		uint32_t parameter) {
+	message->setParameter3(parameter);
+}
+
+uint32_t HousekeepingMessage::getParameter(const CommandMessage *message) {
+	return message->getParameter3();
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index e2a698057..0f50c2a41 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,116 +1,116 @@
-#ifndef FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
-#define FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/ipc/FwMessageTypes.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <limits>
-
-union sid_t {
-	static constexpr uint64_t INVALID_ADDRESS =
-			std::numeric_limits<uint64_t>::max();
-	sid_t(): raw(INVALID_ADDRESS) {}
-
-	struct {
-		object_id_t objectId ;
-		/**
-		 * A generic 32 bit ID to identify unique HK packets for a single
-		 * object. For example, the DeviceCommandId_t is used for
-		 * DeviceHandlers
-		 */
-		uint32_t ownerSetId;
-	};
-	/**
-	 * Alternative access to the raw value. This is also the size of the type.
-	 */
-	uint64_t raw;
-};
-
-
-/**
- * @brief	Special command message type for housekeeping messages
- * @details
- * This message is slightly larger than regular command messages to accomodate
- * the uint64_t structure ID (SID).
- */
-class HousekeepingMessage {
-public:
-
-	static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
-	        sizeof(sid_t) + sizeof(uint32_t);
-
-	/**
-	 * The HK message is initialized with a pointer to a message which holds
-	 * the message data, see CommandMessageIF and getInternalMessage().
-	 * @param message
-	 */
-	HousekeepingMessage() = delete;
-	virtual ~HousekeepingMessage();
-
-	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
-
-	static constexpr Command_t ADD_HK_REPORT_STRUCT =
-			MAKE_COMMAND_ID(1);
-	static constexpr Command_t ADD_DIAGNOSTICS_REPORT_STRUCT =
-			MAKE_COMMAND_ID(2);
-
-	static constexpr Command_t DELETE_HK_REPORT_STRUCT = MAKE_COMMAND_ID(3);
-	static constexpr Command_t DELETE_DIAGNOSTICS_REPORT_STRUCT =
-			MAKE_COMMAND_ID(4);
-
-	static constexpr Command_t ENABLE_PERIODIC_HK_GENERATION =
-			MAKE_COMMAND_ID(5);
-	static constexpr Command_t DISABLE_PERIODIC_HK_REPORT_GENERATION =
-			MAKE_COMMAND_ID(6);
-
-	static constexpr Command_t ENABLE_PERIODIC_DIAGNOSTICS_GENERATION =
-			MAKE_COMMAND_ID(7);
-	static constexpr Command_t DISABLE_PERIODIC_DIAGNOSTICS_GENERATION =
-			MAKE_COMMAND_ID(8);
-
-	static constexpr Command_t REPORT_HK_REPORT_STRUCTURES = MAKE_COMMAND_ID(9);
-	static constexpr Command_t REPORT_DIAGNOSTICS_REPORT_STRUCTURES =
-			MAKE_COMMAND_ID(11);
-
-	static constexpr Command_t HK_DEFINITIONS_REPORT = MAKE_COMMAND_ID(10);
-	static constexpr Command_t DIAGNOSTICS_DEFINITION_REPORT = MAKE_COMMAND_ID(12);
-
-	static constexpr Command_t HK_REPORT = MAKE_COMMAND_ID(25);
-	static constexpr Command_t DIAGNOSTICS_REPORT = MAKE_COMMAND_ID(26);
-
-	static constexpr Command_t GENERATE_ONE_PARAMETER_REPORT  =
-			MAKE_COMMAND_ID(27);
-	static constexpr Command_t GENERATE_ONE_DIAGNOSTICS_REPORT =
-			MAKE_COMMAND_ID(28);
-
-	static constexpr Command_t APPEND_PARAMETERS_TO_PARAMETER_REPORT_STRUCTURE =
-			MAKE_COMMAND_ID(29);
-	static constexpr Command_t APPEND_PARAMETERS_TO_DIAGNOSTICS_REPORT_STRUCTURE =
-			MAKE_COMMAND_ID(30);
-
-	static constexpr Command_t MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL =
-			MAKE_COMMAND_ID(31);
-	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
-			MAKE_COMMAND_ID(32);
-
-	static sid_t getSid(const CommandMessage* message);
-
-	static void setHkReportMessage(CommandMessage* message, sid_t sid,
-			store_address_t storeId);
-	static void setHkDiagnosticsMessage(CommandMessage* message, sid_t sid,
-			store_address_t storeId);
-
-	//! Get the respective SID and store ID. Command ID can be used beforehand
-	//! to distinguish between diagnostics and regular HK packets
-	static sid_t getHkReportMessage(const CommandMessage* message,
-			store_address_t * storeIdToSet);
-
-private:
-	static void setSid(CommandMessage* message, sid_t sid);
-	static void setParameter(CommandMessage* message, uint32_t parameter);
-	static uint32_t getParameter(const CommandMessage* message);
-};
-
-
-#endif /* FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_ */
+#ifndef FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
+#define FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../ipc/FwMessageTypes.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include <limits>
+
+union sid_t {
+	static constexpr uint64_t INVALID_ADDRESS =
+			std::numeric_limits<uint64_t>::max();
+	sid_t(): raw(INVALID_ADDRESS) {}
+
+	struct {
+		object_id_t objectId ;
+		/**
+		 * A generic 32 bit ID to identify unique HK packets for a single
+		 * object. For example, the DeviceCommandId_t is used for
+		 * DeviceHandlers
+		 */
+		uint32_t ownerSetId;
+	};
+	/**
+	 * Alternative access to the raw value. This is also the size of the type.
+	 */
+	uint64_t raw;
+};
+
+
+/**
+ * @brief	Special command message type for housekeeping messages
+ * @details
+ * This message is slightly larger than regular command messages to accomodate
+ * the uint64_t structure ID (SID).
+ */
+class HousekeepingMessage {
+public:
+
+	static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
+	        sizeof(sid_t) + sizeof(uint32_t);
+
+	/**
+	 * The HK message is initialized with a pointer to a message which holds
+	 * the message data, see CommandMessageIF and getInternalMessage().
+	 * @param message
+	 */
+	HousekeepingMessage() = delete;
+	virtual ~HousekeepingMessage();
+
+	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
+
+	static constexpr Command_t ADD_HK_REPORT_STRUCT =
+			MAKE_COMMAND_ID(1);
+	static constexpr Command_t ADD_DIAGNOSTICS_REPORT_STRUCT =
+			MAKE_COMMAND_ID(2);
+
+	static constexpr Command_t DELETE_HK_REPORT_STRUCT = MAKE_COMMAND_ID(3);
+	static constexpr Command_t DELETE_DIAGNOSTICS_REPORT_STRUCT =
+			MAKE_COMMAND_ID(4);
+
+	static constexpr Command_t ENABLE_PERIODIC_HK_GENERATION =
+			MAKE_COMMAND_ID(5);
+	static constexpr Command_t DISABLE_PERIODIC_HK_REPORT_GENERATION =
+			MAKE_COMMAND_ID(6);
+
+	static constexpr Command_t ENABLE_PERIODIC_DIAGNOSTICS_GENERATION =
+			MAKE_COMMAND_ID(7);
+	static constexpr Command_t DISABLE_PERIODIC_DIAGNOSTICS_GENERATION =
+			MAKE_COMMAND_ID(8);
+
+	static constexpr Command_t REPORT_HK_REPORT_STRUCTURES = MAKE_COMMAND_ID(9);
+	static constexpr Command_t REPORT_DIAGNOSTICS_REPORT_STRUCTURES =
+			MAKE_COMMAND_ID(11);
+
+	static constexpr Command_t HK_DEFINITIONS_REPORT = MAKE_COMMAND_ID(10);
+	static constexpr Command_t DIAGNOSTICS_DEFINITION_REPORT = MAKE_COMMAND_ID(12);
+
+	static constexpr Command_t HK_REPORT = MAKE_COMMAND_ID(25);
+	static constexpr Command_t DIAGNOSTICS_REPORT = MAKE_COMMAND_ID(26);
+
+	static constexpr Command_t GENERATE_ONE_PARAMETER_REPORT  =
+			MAKE_COMMAND_ID(27);
+	static constexpr Command_t GENERATE_ONE_DIAGNOSTICS_REPORT =
+			MAKE_COMMAND_ID(28);
+
+	static constexpr Command_t APPEND_PARAMETERS_TO_PARAMETER_REPORT_STRUCTURE =
+			MAKE_COMMAND_ID(29);
+	static constexpr Command_t APPEND_PARAMETERS_TO_DIAGNOSTICS_REPORT_STRUCTURE =
+			MAKE_COMMAND_ID(30);
+
+	static constexpr Command_t MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL =
+			MAKE_COMMAND_ID(31);
+	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
+			MAKE_COMMAND_ID(32);
+
+	static sid_t getSid(const CommandMessage* message);
+
+	static void setHkReportMessage(CommandMessage* message, sid_t sid,
+			store_address_t storeId);
+	static void setHkDiagnosticsMessage(CommandMessage* message, sid_t sid,
+			store_address_t storeId);
+
+	//! Get the respective SID and store ID. Command ID can be used beforehand
+	//! to distinguish between diagnostics and regular HK packets
+	static sid_t getHkReportMessage(const CommandMessage* message,
+			store_address_t * storeIdToSet);
+
+private:
+	static void setSid(CommandMessage* message, sid_t sid);
+	static void setParameter(CommandMessage* message, uint32_t parameter);
+	static uint32_t getParameter(const CommandMessage* message);
+};
+
+
+#endif /* FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_ */
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 8944553dd..ed064da65 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,125 +1,125 @@
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include "InternalErrorReporter.h"
-
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/ipc/MutexFactory.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
-		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
-		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
-		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
-		storeHits(0) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-InternalErrorReporter::~InternalErrorReporter() {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
-
-	GlobDataSet mySet;
-	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-
-	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
-
-	uint32_t newQueueHits = getAndResetQueueHits();
-	uint32_t newTmHits = getAndResetTmHits();
-	uint32_t newStoreHits = getAndResetStoreHits();
-
-	queueHitsInPool.value += newQueueHits;
-	tmHitsInPool.value += newTmHits;
-	storeHitsInPool.value += newStoreHits;
-
-	mySet.commit(PoolVariableIF::VALID);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void InternalErrorReporter::queueMessageNotSent() {
-	incrementQueueHits();
-}
-
-void InternalErrorReporter::lostTm() {
-	incrementTmHits();
-}
-
-uint32_t InternalErrorReporter::getAndResetQueueHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = queueHits;
-	queueHits = 0;
-	mutex->unlockMutex();
-	return value;
-}
-
-uint32_t InternalErrorReporter::getQueueHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = queueHits;
-	mutex->unlockMutex();
-	return value;
-}
-
-void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	queueHits++;
-	mutex->unlockMutex();
-}
-
-uint32_t InternalErrorReporter::getAndResetTmHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = tmHits;
-	tmHits = 0;
-	mutex->unlockMutex();
-	return value;
-}
-
-uint32_t InternalErrorReporter::getTmHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = tmHits;
-	mutex->unlockMutex();
-	return value;
-}
-
-void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	tmHits++;
-	mutex->unlockMutex();
-}
-
-void InternalErrorReporter::storeFull() {
-	incrementStoreHits();
-}
-
-uint32_t InternalErrorReporter::getAndResetStoreHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = storeHits;
-	storeHits = 0;
-	mutex->unlockMutex();
-	return value;
-}
-
-uint32_t InternalErrorReporter::getStoreHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = storeHits;
-	mutex->unlockMutex();
-	return value;
-}
-
-void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	storeHits++;
-	mutex->unlockMutex();
-}
+#include "../datapoolglob/GlobalDataSet.h"
+#include "InternalErrorReporter.h"
+
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../ipc/MutexFactory.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
+		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
+		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
+		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
+		storeHits(0) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+InternalErrorReporter::~InternalErrorReporter() {
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
+
+	GlobDataSet mySet;
+	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
+			PoolVariableIF::VAR_READ_WRITE);
+	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
+			PoolVariableIF::VAR_READ_WRITE);
+
+	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
+			PoolVariableIF::VAR_READ_WRITE);
+	mySet.read();
+
+	uint32_t newQueueHits = getAndResetQueueHits();
+	uint32_t newTmHits = getAndResetTmHits();
+	uint32_t newStoreHits = getAndResetStoreHits();
+
+	queueHitsInPool.value += newQueueHits;
+	tmHitsInPool.value += newTmHits;
+	storeHitsInPool.value += newStoreHits;
+
+	mySet.commit(PoolVariableIF::VALID);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void InternalErrorReporter::queueMessageNotSent() {
+	incrementQueueHits();
+}
+
+void InternalErrorReporter::lostTm() {
+	incrementTmHits();
+}
+
+uint32_t InternalErrorReporter::getAndResetQueueHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = queueHits;
+	queueHits = 0;
+	mutex->unlockMutex();
+	return value;
+}
+
+uint32_t InternalErrorReporter::getQueueHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = queueHits;
+	mutex->unlockMutex();
+	return value;
+}
+
+void InternalErrorReporter::incrementQueueHits() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	queueHits++;
+	mutex->unlockMutex();
+}
+
+uint32_t InternalErrorReporter::getAndResetTmHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = tmHits;
+	tmHits = 0;
+	mutex->unlockMutex();
+	return value;
+}
+
+uint32_t InternalErrorReporter::getTmHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = tmHits;
+	mutex->unlockMutex();
+	return value;
+}
+
+void InternalErrorReporter::incrementTmHits() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	tmHits++;
+	mutex->unlockMutex();
+}
+
+void InternalErrorReporter::storeFull() {
+	incrementStoreHits();
+}
+
+uint32_t InternalErrorReporter::getAndResetStoreHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = storeHits;
+	storeHits = 0;
+	mutex->unlockMutex();
+	return value;
+}
+
+uint32_t InternalErrorReporter::getStoreHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = storeHits;
+	mutex->unlockMutex();
+	return value;
+}
+
+void InternalErrorReporter::incrementStoreHits() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	storeHits++;
+	mutex->unlockMutex();
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 7c1df6a7b..1fe7426db 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -1,50 +1,50 @@
-#ifndef INTERNALERRORREPORTER_H_
-#define INTERNALERRORREPORTER_H_
-
-#include "InternalErrorReporterIF.h"
-
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/ipc/MutexIF.h>
-
-class InternalErrorReporter: public SystemObject,
-		public ExecutableObjectIF,
-		public InternalErrorReporterIF {
-public:
-	InternalErrorReporter(object_id_t setObjectId, uint32_t queuePoolId,
-			uint32_t tmPoolId, uint32_t storePoolId);
-	virtual ~InternalErrorReporter();
-
-	virtual ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual void queueMessageNotSent();
-
-	virtual void lostTm();
-
-	virtual void storeFull();
-protected:
-	MutexIF* mutex;
-
-	uint32_t queuePoolId;
-	uint32_t tmPoolId;
-	uint32_t storePoolId;
-
-	uint32_t queueHits;
-	uint32_t tmHits;
-	uint32_t storeHits;
-
-	uint32_t getAndResetQueueHits();
-	uint32_t getQueueHits();
-	void incrementQueueHits();
-
-	uint32_t getAndResetTmHits();
-	uint32_t getTmHits();
-	void incrementTmHits();
-
-	uint32_t getAndResetStoreHits();
-	uint32_t getStoreHits();
-	void incrementStoreHits();
-
-};
-
-#endif /* INTERNALERRORREPORTER_H_ */
+#ifndef INTERNALERRORREPORTER_H_
+#define INTERNALERRORREPORTER_H_
+
+#include "InternalErrorReporterIF.h"
+
+#include "../tasks/ExecutableObjectIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../ipc/MutexIF.h"
+
+class InternalErrorReporter: public SystemObject,
+		public ExecutableObjectIF,
+		public InternalErrorReporterIF {
+public:
+	InternalErrorReporter(object_id_t setObjectId, uint32_t queuePoolId,
+			uint32_t tmPoolId, uint32_t storePoolId);
+	virtual ~InternalErrorReporter();
+
+	virtual ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual void queueMessageNotSent();
+
+	virtual void lostTm();
+
+	virtual void storeFull();
+protected:
+	MutexIF* mutex;
+
+	uint32_t queuePoolId;
+	uint32_t tmPoolId;
+	uint32_t storePoolId;
+
+	uint32_t queueHits;
+	uint32_t tmHits;
+	uint32_t storeHits;
+
+	uint32_t getAndResetQueueHits();
+	uint32_t getQueueHits();
+	void incrementQueueHits();
+
+	uint32_t getAndResetTmHits();
+	uint32_t getTmHits();
+	void incrementTmHits();
+
+	uint32_t getAndResetStoreHits();
+	uint32_t getStoreHits();
+	void incrementStoreHits();
+
+};
+
+#endif /* INTERNALERRORREPORTER_H_ */
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index cc1185c7d..6934e6ce8 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,111 +1,111 @@
-#include <framework/ipc/CommandMessage.h>
-#include <framework/ipc/CommandMessageCleaner.h>
-#include <cstring>
-
-CommandMessage::CommandMessage() {
-    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
-    setCommand(CMD_NONE);
-}
-
-CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
-        uint32_t parameter2) {
-    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
-    setCommand(command);
-    setParameter(parameter1);
-    setParameter2(parameter2);
-}
-
-Command_t CommandMessage::getCommand() const {
-    Command_t command;
-    std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
-    return command;
-}
-
-void CommandMessage::setCommand(Command_t command) {
-    std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
-}
-
-uint8_t CommandMessage::getMessageType() const {
-    // first byte of command ID.
-    return getCommand() >> 8 & 0xff;
-}
-
-uint32_t CommandMessage::getParameter() const {
-    uint32_t parameter1;
-    std::memcpy(&parameter1, this->getData(), sizeof(parameter1));
-    return parameter1;
-}
-
-void CommandMessage::setParameter(uint32_t parameter1) {
-    std::memcpy(this->getData(), &parameter1, sizeof(parameter1));
-}
-
-uint32_t CommandMessage::getParameter2() const {
-    uint32_t parameter2;
-    std::memcpy(&parameter2, this->getData() + sizeof(uint32_t),
-            sizeof(parameter2));
-    return parameter2;
-}
-
-void CommandMessage::setParameter2(uint32_t parameter2) {
-    std::memcpy(this->getData()  + sizeof(uint32_t), &parameter2,
-            sizeof(parameter2));
-}
-
-uint32_t CommandMessage::getParameter3() const {
-    uint32_t parameter3;
-    std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
-            sizeof(parameter3));
-    return parameter3;
-}
-
-void CommandMessage::setParameter3(uint32_t parameter3) {
-    std::memcpy(this->getData()  + 2 * sizeof(uint32_t), &parameter3,
-            sizeof(parameter3));
-}
-
-size_t CommandMessage::getMinimumMessageSize() const {
-    return MINIMUM_COMMAND_MESSAGE_SIZE;
-}
-
-void CommandMessage::clearCommandMessage() {
-    clear();
-}
-
-void CommandMessage::clear() {
-    CommandMessageCleaner::clearCommandMessage(this);
-}
-
-bool CommandMessage::isClearedCommandMessage() {
-    return getCommand() == CMD_NONE;
-}
-
-void CommandMessage::setToUnknownCommand() {
-    Command_t initialCommand = getCommand();
-    this->clear();
-    setReplyRejected(UNKNOWN_COMMAND, initialCommand);
-}
-
-void CommandMessage::setReplyRejected(ReturnValue_t reason,
-        Command_t initialCommand) {
-	setCommand(REPLY_REJECTED);
-    setParameter(reason);
-    setParameter2(initialCommand);
-}
-
-ReturnValue_t CommandMessage::getReplyRejectedReason(
-        Command_t *initialCommand) const {
-    ReturnValue_t reason = getParameter();
-    if(initialCommand != nullptr) {
-        *initialCommand = getParameter2();
-    }
-    return reason;
-}
-
-uint8_t* CommandMessage::getData() {
-    return MessageQueueMessage::getData() + sizeof(Command_t);
-}
-
-const uint8_t* CommandMessage::getData() const {
-    return MessageQueueMessage::getData() + sizeof(Command_t);
-}
+#include "../ipc/CommandMessage.h"
+#include "../ipc/CommandMessageCleaner.h"
+#include <cstring>
+
+CommandMessage::CommandMessage() {
+    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
+    setCommand(CMD_NONE);
+}
+
+CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
+        uint32_t parameter2) {
+    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
+    setCommand(command);
+    setParameter(parameter1);
+    setParameter2(parameter2);
+}
+
+Command_t CommandMessage::getCommand() const {
+    Command_t command;
+    std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
+    return command;
+}
+
+void CommandMessage::setCommand(Command_t command) {
+    std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
+}
+
+uint8_t CommandMessage::getMessageType() const {
+    // first byte of command ID.
+    return getCommand() >> 8 & 0xff;
+}
+
+uint32_t CommandMessage::getParameter() const {
+    uint32_t parameter1;
+    std::memcpy(&parameter1, this->getData(), sizeof(parameter1));
+    return parameter1;
+}
+
+void CommandMessage::setParameter(uint32_t parameter1) {
+    std::memcpy(this->getData(), &parameter1, sizeof(parameter1));
+}
+
+uint32_t CommandMessage::getParameter2() const {
+    uint32_t parameter2;
+    std::memcpy(&parameter2, this->getData() + sizeof(uint32_t),
+            sizeof(parameter2));
+    return parameter2;
+}
+
+void CommandMessage::setParameter2(uint32_t parameter2) {
+    std::memcpy(this->getData()  + sizeof(uint32_t), &parameter2,
+            sizeof(parameter2));
+}
+
+uint32_t CommandMessage::getParameter3() const {
+    uint32_t parameter3;
+    std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
+            sizeof(parameter3));
+    return parameter3;
+}
+
+void CommandMessage::setParameter3(uint32_t parameter3) {
+    std::memcpy(this->getData()  + 2 * sizeof(uint32_t), &parameter3,
+            sizeof(parameter3));
+}
+
+size_t CommandMessage::getMinimumMessageSize() const {
+    return MINIMUM_COMMAND_MESSAGE_SIZE;
+}
+
+void CommandMessage::clearCommandMessage() {
+    clear();
+}
+
+void CommandMessage::clear() {
+    CommandMessageCleaner::clearCommandMessage(this);
+}
+
+bool CommandMessage::isClearedCommandMessage() {
+    return getCommand() == CMD_NONE;
+}
+
+void CommandMessage::setToUnknownCommand() {
+    Command_t initialCommand = getCommand();
+    this->clear();
+    setReplyRejected(UNKNOWN_COMMAND, initialCommand);
+}
+
+void CommandMessage::setReplyRejected(ReturnValue_t reason,
+        Command_t initialCommand) {
+	setCommand(REPLY_REJECTED);
+    setParameter(reason);
+    setParameter2(initialCommand);
+}
+
+ReturnValue_t CommandMessage::getReplyRejectedReason(
+        Command_t *initialCommand) const {
+    ReturnValue_t reason = getParameter();
+    if(initialCommand != nullptr) {
+        *initialCommand = getParameter2();
+    }
+    return reason;
+}
+
+uint8_t* CommandMessage::getData() {
+    return MessageQueueMessage::getData() + sizeof(Command_t);
+}
+
+const uint8_t* CommandMessage::getData() const {
+    return MessageQueueMessage::getData() + sizeof(Command_t);
+}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index d843e4c54..73b73dc91 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,129 +1,129 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGE_H_
-
-#include <framework/ipc/CommandMessageIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/ipc/FwMessageTypes.h>
-
-/**
- * @brief 	Default command message used to pass command messages between tasks.
- * 			Primary message type for IPC. Contains sender, 2-byte command ID
- * 			field, and 2 4-byte parameters.
- * @details
- * It operates on an external memory which is contained inside a
- * class implementing MessageQueueMessageIF by taking its address.
- * This allows for a more flexible designs of message implementations.
- * The pointer can be passed to different message implementations without
- * the need of unnecessary copying.
- *
- * The command message is based of the generic MessageQueueMessage which
- * currently has an internal message size of 28 bytes.
- * @author	Bastian Baetz
- */
-class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
-public:
-    /**
-     * Default size can accomodate 2 4-byte parameters.
-     */
-    static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
-            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
-
-	/**
-	 * @brief   Default Constructor, does not initialize anything.
-	 * @details
-	 * This constructor should be used when receiving a Message, as the
-	 * content is filled by the MessageQueue.
-	 */
-	CommandMessage();
-	/**
-	 * This constructor creates a new message with all message content
-	 * initialized
-	 *
-	 * @param command	The DeviceHandlerCommand_t that will be sent
-	 * @param parameter1	The first parameter
-	 * @param parameter2	The second parameter
-	 */
-	CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
-
-	/**
-	 * @brief 	Default Destructor
-	 */
-	virtual ~CommandMessage() {}
-
-    /**
-     * Read the DeviceHandlerCommand_t that is stored in the message,
-     * usually used after receiving.
-     *
-     * @return the Command stored in the Message
-     */
-    virtual Command_t getCommand() const override;
-    /**
-     * Set the command type of the message. Default implementation also
-     * sets the message type, which will be the first byte of the command ID.
-     * @param the Command to be sent
-     */
-    virtual void setCommand(Command_t command);
-
-    virtual uint8_t* getData() override;
-    virtual const uint8_t* getData() const override;
-
-	/**
-	 * Get the first parameter of the message
-	 * @return the first Parameter of the message
-	 */
-	uint32_t getParameter() const;
-	/**
-	 * Set the first parameter of the message
-	 * @param the first parameter of the message
-	 */
-	void setParameter(uint32_t parameter1);
-	uint32_t getParameter2() const;
-	void setParameter2(uint32_t parameter2);
-	uint32_t getParameter3() const;
-	void setParameter3(uint32_t parameter3);
-
-	/**
-	 * check if a message was cleared
-	 *
-	 * @return if the command is CMD_NONE
-	 */
-	bool isClearedCommandMessage();
-
-	/**
-	 * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
-	 * Is needed quite often, so we better code it once only.
-	 */
-	void setToUnknownCommand() override;
-
-    /**
-     * A command message can be rejected and needs to offer a function
-     * to set a rejected reply
-     * @param reason
-     * @param initialCommand
-     */
-    void setReplyRejected(ReturnValue_t reason,
-            Command_t initialCommand) override;
-    /**
-     * Corrensonding getter function.
-     * @param initialCommand
-     * @return
-     */
-    ReturnValue_t getReplyRejectedReason(
-            Command_t* initialCommand = nullptr) const override;
-
-
-    virtual void clear() override;
-    void clearCommandMessage();
-
-    /**
-     * Extract message ID, which is the first byte of the command ID for the
-     * default implementation.
-     * @return
-     */
-    virtual uint8_t getMessageType() const override;
-
-    /** MessageQueueMessageIF functions used for minimum size check. */
-    size_t getMinimumMessageSize() const override;
-};
-
-#endif /* COMMANDMESSAGE_H_ */
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGE_H_
+
+#include "../ipc/CommandMessageIF.h"
+#include "../ipc/MessageQueueMessage.h"
+#include "../ipc/FwMessageTypes.h"
+
+/**
+ * @brief 	Default command message used to pass command messages between tasks.
+ * 			Primary message type for IPC. Contains sender, 2-byte command ID
+ * 			field, and 2 4-byte parameters.
+ * @details
+ * It operates on an external memory which is contained inside a
+ * class implementing MessageQueueMessageIF by taking its address.
+ * This allows for a more flexible designs of message implementations.
+ * The pointer can be passed to different message implementations without
+ * the need of unnecessary copying.
+ *
+ * The command message is based of the generic MessageQueueMessage which
+ * currently has an internal message size of 28 bytes.
+ * @author	Bastian Baetz
+ */
+class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
+public:
+    /**
+     * Default size can accomodate 2 4-byte parameters.
+     */
+    static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
+            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
+
+	/**
+	 * @brief   Default Constructor, does not initialize anything.
+	 * @details
+	 * This constructor should be used when receiving a Message, as the
+	 * content is filled by the MessageQueue.
+	 */
+	CommandMessage();
+	/**
+	 * This constructor creates a new message with all message content
+	 * initialized
+	 *
+	 * @param command	The DeviceHandlerCommand_t that will be sent
+	 * @param parameter1	The first parameter
+	 * @param parameter2	The second parameter
+	 */
+	CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
+
+	/**
+	 * @brief 	Default Destructor
+	 */
+	virtual ~CommandMessage() {}
+
+    /**
+     * Read the DeviceHandlerCommand_t that is stored in the message,
+     * usually used after receiving.
+     *
+     * @return the Command stored in the Message
+     */
+    virtual Command_t getCommand() const override;
+    /**
+     * Set the command type of the message. Default implementation also
+     * sets the message type, which will be the first byte of the command ID.
+     * @param the Command to be sent
+     */
+    virtual void setCommand(Command_t command);
+
+    virtual uint8_t* getData() override;
+    virtual const uint8_t* getData() const override;
+
+	/**
+	 * Get the first parameter of the message
+	 * @return the first Parameter of the message
+	 */
+	uint32_t getParameter() const;
+	/**
+	 * Set the first parameter of the message
+	 * @param the first parameter of the message
+	 */
+	void setParameter(uint32_t parameter1);
+	uint32_t getParameter2() const;
+	void setParameter2(uint32_t parameter2);
+	uint32_t getParameter3() const;
+	void setParameter3(uint32_t parameter3);
+
+	/**
+	 * check if a message was cleared
+	 *
+	 * @return if the command is CMD_NONE
+	 */
+	bool isClearedCommandMessage();
+
+	/**
+	 * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
+	 * Is needed quite often, so we better code it once only.
+	 */
+	void setToUnknownCommand() override;
+
+    /**
+     * A command message can be rejected and needs to offer a function
+     * to set a rejected reply
+     * @param reason
+     * @param initialCommand
+     */
+    void setReplyRejected(ReturnValue_t reason,
+            Command_t initialCommand) override;
+    /**
+     * Corrensonding getter function.
+     * @param initialCommand
+     * @return
+     */
+    ReturnValue_t getReplyRejectedReason(
+            Command_t* initialCommand = nullptr) const override;
+
+
+    virtual void clear() override;
+    void clearCommandMessage();
+
+    /**
+     * Extract message ID, which is the first byte of the command ID for the
+     * default implementation.
+     * @return
+     */
+    virtual uint8_t getMessageType() const override;
+
+    /** MessageQueueMessageIF functions used for minimum size check. */
+    size_t getMinimumMessageSize() const override;
+};
+
+#endif /* COMMANDMESSAGE_H_ */
diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
index 23e6e1682..a4dec78df 100644
--- a/ipc/CommandMessageCleaner.cpp
+++ b/ipc/CommandMessageCleaner.cpp
@@ -1,45 +1,45 @@
-#include <framework/ipc/CommandMessageCleaner.h>
-
-#include <framework/devicehandlers/DeviceHandlerMessage.h>
-#include <framework/health/HealthMessage.h>
-#include <framework/memory/MemoryMessage.h>
-#include <framework/modes/ModeMessage.h>
-#include <framework/monitoring/MonitoringMessage.h>
-#include <framework/subsystem/modes/ModeSequenceMessage.h>
-#include <framework/tmstorage/TmStoreMessage.h>
-#include <framework/parameters/ParameterMessage.h>
-
-void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
-	switch(message->getMessageType()){
-	case  messagetypes::MODE_COMMAND:
-		ModeMessage::clear(message);
-		break;
-	case messagetypes::HEALTH_COMMAND:
-		HealthMessage::clear(message);
-		break;
-	case messagetypes::MODE_SEQUENCE:
-		ModeSequenceMessage::clear(message);
-		break;
-	case messagetypes::ACTION:
-		ActionMessage::clear(message);
-		break;
-	case messagetypes::DEVICE_HANDLER_COMMAND:
-		DeviceHandlerMessage::clear(message);
-		break;
-	case messagetypes::MEMORY:
-		MemoryMessage::clear(message);
-		break;
-	case messagetypes::MONITORING:
-		MonitoringMessage::clear(message);
-		break;
-	case messagetypes::TM_STORE:
-		TmStoreMessage::clear(message);
-		break;
-	case messagetypes::PARAMETER:
-		ParameterMessage::clear(message);
-		break;
-	default:
-		messagetypes::clearMissionMessage(message);
-		break;
-	}
-}
+#include "../ipc/CommandMessageCleaner.h"
+
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../health/HealthMessage.h"
+#include "../memory/MemoryMessage.h"
+#include "../modes/ModeMessage.h"
+#include "../monitoring/MonitoringMessage.h"
+#include "../subsystem/modes/ModeSequenceMessage.h"
+#include "../tmstorage/TmStoreMessage.h"
+#include "../parameters/ParameterMessage.h"
+
+void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
+	switch(message->getMessageType()){
+	case  messagetypes::MODE_COMMAND:
+		ModeMessage::clear(message);
+		break;
+	case messagetypes::HEALTH_COMMAND:
+		HealthMessage::clear(message);
+		break;
+	case messagetypes::MODE_SEQUENCE:
+		ModeSequenceMessage::clear(message);
+		break;
+	case messagetypes::ACTION:
+		ActionMessage::clear(message);
+		break;
+	case messagetypes::DEVICE_HANDLER_COMMAND:
+		DeviceHandlerMessage::clear(message);
+		break;
+	case messagetypes::MEMORY:
+		MemoryMessage::clear(message);
+		break;
+	case messagetypes::MONITORING:
+		MonitoringMessage::clear(message);
+		break;
+	case messagetypes::TM_STORE:
+		TmStoreMessage::clear(message);
+		break;
+	case messagetypes::PARAMETER:
+		ParameterMessage::clear(message);
+		break;
+	default:
+		messagetypes::clearMissionMessage(message);
+		break;
+	}
+}
diff --git a/ipc/CommandMessageCleaner.h b/ipc/CommandMessageCleaner.h
index 48aaa4786..f17bf282b 100644
--- a/ipc/CommandMessageCleaner.h
+++ b/ipc/CommandMessageCleaner.h
@@ -1,16 +1,16 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
-#include <framework/ipc/CommandMessage.h>
-
-namespace messagetypes {
-// Implemented in config.
-void clearMissionMessage(CommandMessage* message);
-}
-
-class CommandMessageCleaner {
-public:
-	static void clearCommandMessage(CommandMessage* message);
-};
-
-
-#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#include "../ipc/CommandMessage.h"
+
+namespace messagetypes {
+// Implemented in config.
+void clearMissionMessage(CommandMessage* message);
+}
+
+class CommandMessageCleaner {
+public:
+	static void clearCommandMessage(CommandMessage* message);
+};
+
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index 2cb6324eb..e5f962aec 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -1,73 +1,73 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
-
-#include <framework/ipc/MessageQueueMessageIF.h>
-#include <framework/ipc/FwMessageTypes.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-#define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
-typedef uint16_t Command_t;
-
-class CommandMessageIF {
-public:
-    /**
-     * Header consists of sender ID and command ID.
-     */
-	static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
-			sizeof(Command_t);
-	/**
-	 * This minimum size is derived from the interface requirement to be able
-     * to set a rejected reply, which contains a returnvalue and the initial
-     * command.
-	 */
-	static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
-	        CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
-	        sizeof(Command_t);
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
-	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
-
-	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
-	//! Used internally, shall be ignored
-	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
-	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
-	//! Reply indicating that the current command was rejected,
-	//! par1 should contain the error code
-	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
-
-	virtual ~CommandMessageIF() {};
-
-	/**
-	 * A command message shall have a uint16_t command ID field.
-	 * @return
-	 */
-	virtual Command_t getCommand() const = 0;
-	/**
-	 * A command message shall have a uint8_t message type ID field.
-	 * @return
-	 */
-	virtual uint8_t getMessageType() const = 0;
-
-	/**
-	 * A command message can be rejected and needs to offer a function
-	 * to set a rejected reply
-	 * @param reason
-	 * @param initialCommand
-	 */
-	virtual void setReplyRejected(ReturnValue_t reason,
-			Command_t initialCommand) = 0;
-	/**
-	 * Corrensonding getter function.
-	 * @param initialCommand
-	 * @return
-	 */
-	virtual ReturnValue_t getReplyRejectedReason(
-			Command_t* initialCommand = nullptr) const  = 0;
-
-	virtual void setToUnknownCommand() = 0;
-
-	virtual void clear() = 0;
-
-};
-
-#endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
+
+#include "../ipc/MessageQueueMessageIF.h"
+#include "../ipc/FwMessageTypes.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+#define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
+typedef uint16_t Command_t;
+
+class CommandMessageIF {
+public:
+    /**
+     * Header consists of sender ID and command ID.
+     */
+	static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
+			sizeof(Command_t);
+	/**
+	 * This minimum size is derived from the interface requirement to be able
+     * to set a rejected reply, which contains a returnvalue and the initial
+     * command.
+	 */
+	static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
+	        CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
+	        sizeof(Command_t);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
+	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
+
+	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
+	//! Used internally, shall be ignored
+	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
+	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
+	//! Reply indicating that the current command was rejected,
+	//! par1 should contain the error code
+	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
+
+	virtual ~CommandMessageIF() {};
+
+	/**
+	 * A command message shall have a uint16_t command ID field.
+	 * @return
+	 */
+	virtual Command_t getCommand() const = 0;
+	/**
+	 * A command message shall have a uint8_t message type ID field.
+	 * @return
+	 */
+	virtual uint8_t getMessageType() const = 0;
+
+	/**
+	 * A command message can be rejected and needs to offer a function
+	 * to set a rejected reply
+	 * @param reason
+	 * @param initialCommand
+	 */
+	virtual void setReplyRejected(ReturnValue_t reason,
+			Command_t initialCommand) = 0;
+	/**
+	 * Corrensonding getter function.
+	 * @param initialCommand
+	 * @return
+	 */
+	virtual ReturnValue_t getReplyRejectedReason(
+			Command_t* initialCommand = nullptr) const  = 0;
+
+	virtual void setToUnknownCommand() = 0;
+
+	virtual void clear() = 0;
+
+};
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index c05754425..6ae852eae 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -1,142 +1,142 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
-
-// COULDDO: We could support blocking calls
-// semaphores are being implemented, which makes this idea even more iteresting.
-
-
-/**
- * @defgroup message_queue Message Queue
- * @brief Message Queue related software components
- */
-
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-class MessageQueueIF {
-public:
-	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
-	//! No new messages on the queue
-	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(1);
-	//! No space left for more messages
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
-	//! Returned if a reply method was called without partner
-	static const ReturnValue_t NO_REPLY_PARTNER = MAKE_RETURN_CODE(3);
-	//! Returned if the target destination is invalid.
-	static constexpr ReturnValue_t DESTINVATION_INVALID = MAKE_RETURN_CODE(4);
-
-	virtual ~MessageQueueIF() {}
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter 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.
-	 * @return RETURN_OK if ok
-	 * @return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
-	 */
-	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) = 0;
-
-	/**
-	 * @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.
-	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) = 0;
-
-	/**
-	 * @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 theblastPartner 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.
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::EMPTY if queue is empty
-	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
-	/**
-	 * Deletes all pending messages in the queue.
-	 * @param count The number of flushed messages.
-	 * @return RETURN_OK on success.
-	 */
-	virtual ReturnValue_t flush(uint32_t* count) = 0;
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	virtual MessageQueueId_t getLastPartner() const = 0;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	virtual MessageQueueId_t getId() const = 0;
-
-	/**
-	 * @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 (if implemented).
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::FULL if queue is full
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false ) = 0;
-
-	/**
-	 * @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.
-	 */
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
-
-	/**
-	 * @brief	The sendToDefaultFrom 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.
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::FULL if queue is full
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-	 * 			Implementation class and adds its queue id as "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::FULL if queue is full
-	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
-	/**
-	 * \brief	This method is a simple setter for the default destination.
-	 */
-	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) = 0;
-	/**
-	 * \brief	This method is a simple getter for the default destination.
-	 */
-	virtual MessageQueueId_t getDefaultDestination() const = 0;
-
-	virtual bool isDefaultDestinationSet() const = 0;
-};
-
-
-
-#endif /* FRAMEWORK_IPC_MESSAGEQUEUEIF_H_ */
+#ifndef FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
+#define FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
+
+// COULDDO: We could support blocking calls
+// semaphores are being implemented, which makes this idea even more iteresting.
+
+
+/**
+ * @defgroup message_queue Message Queue
+ * @brief Message Queue related software components
+ */
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+class MessageQueueIF {
+public:
+	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
+	//! No new messages on the queue
+	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(1);
+	//! No space left for more messages
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
+	//! Returned if a reply method was called without partner
+	static const ReturnValue_t NO_REPLY_PARTNER = MAKE_RETURN_CODE(3);
+	//! Returned if the target destination is invalid.
+	static constexpr ReturnValue_t DESTINVATION_INVALID = MAKE_RETURN_CODE(4);
+
+	virtual ~MessageQueueIF() {}
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using the stored
+	 * 			lastParnter 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.
+	 * @return RETURN_OK if ok
+	 * @return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
+	 */
+	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) = 0;
+
+	/**
+	 * @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.
+	 */
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) = 0;
+
+	/**
+	 * @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 theblastPartner 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.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::EMPTY if queue is empty
+	 */
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	virtual ReturnValue_t flush(uint32_t* count) = 0;
+	/**
+	 * @brief	This method returns the message queue id of the last communication partner.
+	 */
+	virtual MessageQueueId_t getLastPartner() const = 0;
+	/**
+	 * @brief	This method returns the message queue id of this class's message queue.
+	 */
+	virtual MessageQueueId_t getId() const = 0;
+
+	/**
+	 * @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 (if implemented).
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) = 0;
+
+	/**
+	 * @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.
+	 */
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
+
+	/**
+	 * @brief	The sendToDefaultFrom 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.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
+	 * 			Implementation class and adds its queue id as "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
+	/**
+	 * \brief	This method is a simple setter for the default destination.
+	 */
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) = 0;
+	/**
+	 * \brief	This method is a simple getter for the default destination.
+	 */
+	virtual MessageQueueId_t getDefaultDestination() const = 0;
+
+	virtual bool isDefaultDestinationSet() const = 0;
+};
+
+
+
+#endif /* FRAMEWORK_IPC_MESSAGEQUEUEIF_H_ */
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index 0f4d861bb..d00321297 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -1,84 +1,84 @@
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/globalfunctions/arrayprinter.h>
-#include <cstring>
-
-MessageQueueMessage::MessageQueueMessage() :
-		messageSize(getMinimumMessageSize()) {
-	memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
-}
-
-MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
-		messageSize(this->HEADER_SIZE + size) {
-	if (size <= this->MAX_DATA_SIZE) {
-		memcpy(this->getData(), data, size);
-		this->messageSize = this->HEADER_SIZE + size;
-	}
-	else {
-		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
-				"allowed size! Setting content to 0" << std::endl;
-		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
-		this->messageSize = this->HEADER_SIZE;
-	}
-}
-
-MessageQueueMessage::~MessageQueueMessage() {
-}
-
-const uint8_t* MessageQueueMessage::getBuffer() const {
-	return this->internalBuffer;
-}
-
-uint8_t* MessageQueueMessage::getBuffer() {
-	return this->internalBuffer;
-}
-
-const uint8_t* MessageQueueMessage::getData() const {
-	return this->internalBuffer + this->HEADER_SIZE;
-}
-
-uint8_t* MessageQueueMessage::getData() {
-	return this->internalBuffer + this->HEADER_SIZE;
-}
-
-MessageQueueId_t MessageQueueMessage::getSender() const {
-	MessageQueueId_t temp_id;
-	memcpy(&temp_id, this->internalBuffer, sizeof(MessageQueueId_t));
-	return temp_id;
-}
-
-void MessageQueueMessage::setSender(MessageQueueId_t setId) {
-	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
-}
-
-void MessageQueueMessage::print(bool printWholeMessage) {
-	sif::debug << "MessageQueueMessage content: " << std::endl;
-	if(printWholeMessage) {
-	    arrayprinter::print(getData(), getMaximumMessageSize());
-	}
-	else {
-	    arrayprinter::print(getData(), getMessageSize());
-	}
-
-}
-
-void MessageQueueMessage::clear() {
-	memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
-}
-
-size_t MessageQueueMessage::getMessageSize() const {
-	return this->messageSize;
-}
-
-void MessageQueueMessage::setMessageSize(size_t messageSize) {
-	this->messageSize = messageSize;
-}
-
-size_t MessageQueueMessage::getMinimumMessageSize() const {
-    return this->MIN_MESSAGE_SIZE;
-}
-
-size_t MessageQueueMessage::getMaximumMessageSize() const {
-    return this->MAX_MESSAGE_SIZE;
-}
-
+#include "../ipc/MessageQueueMessage.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../globalfunctions/arrayprinter.h"
+#include <cstring>
+
+MessageQueueMessage::MessageQueueMessage() :
+		messageSize(getMinimumMessageSize()) {
+	memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
+}
+
+MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
+		messageSize(this->HEADER_SIZE + size) {
+	if (size <= this->MAX_DATA_SIZE) {
+		memcpy(this->getData(), data, size);
+		this->messageSize = this->HEADER_SIZE + size;
+	}
+	else {
+		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
+				"allowed size! Setting content to 0" << std::endl;
+		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
+		this->messageSize = this->HEADER_SIZE;
+	}
+}
+
+MessageQueueMessage::~MessageQueueMessage() {
+}
+
+const uint8_t* MessageQueueMessage::getBuffer() const {
+	return this->internalBuffer;
+}
+
+uint8_t* MessageQueueMessage::getBuffer() {
+	return this->internalBuffer;
+}
+
+const uint8_t* MessageQueueMessage::getData() const {
+	return this->internalBuffer + this->HEADER_SIZE;
+}
+
+uint8_t* MessageQueueMessage::getData() {
+	return this->internalBuffer + this->HEADER_SIZE;
+}
+
+MessageQueueId_t MessageQueueMessage::getSender() const {
+	MessageQueueId_t temp_id;
+	memcpy(&temp_id, this->internalBuffer, sizeof(MessageQueueId_t));
+	return temp_id;
+}
+
+void MessageQueueMessage::setSender(MessageQueueId_t setId) {
+	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
+}
+
+void MessageQueueMessage::print(bool printWholeMessage) {
+	sif::debug << "MessageQueueMessage content: " << std::endl;
+	if(printWholeMessage) {
+	    arrayprinter::print(getData(), getMaximumMessageSize());
+	}
+	else {
+	    arrayprinter::print(getData(), getMessageSize());
+	}
+
+}
+
+void MessageQueueMessage::clear() {
+	memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
+}
+
+size_t MessageQueueMessage::getMessageSize() const {
+	return this->messageSize;
+}
+
+void MessageQueueMessage::setMessageSize(size_t messageSize) {
+	this->messageSize = messageSize;
+}
+
+size_t MessageQueueMessage::getMinimumMessageSize() const {
+    return this->MIN_MESSAGE_SIZE;
+}
+
+size_t MessageQueueMessage::getMaximumMessageSize() const {
+    return this->MAX_MESSAGE_SIZE;
+}
+
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 3d5d4283e..cf06fde62 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -1,150 +1,150 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
-
-#include <framework/ipc/MessageQueueMessageIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-#include <cstddef>
-
-/**
- *	@brief		This class is the representation and data organizer
- *				for interprocess messages.
- *	@details
- *	To facilitate and standardize interprocess communication, this class was
- *	created to handle a lightweight "interprocess message protocol".
- *
- *	It adds a header with the sender's queue id to every sent message and
- *	defines the maximum total message size. Specialized messages, such as
- *	device commanding messages, can be created by inheriting from this class
- *	and filling the buffer provided by getData with additional content.
- *
- *	If larger amounts of data must be sent between processes, the data shall
- *	be stored in the IPC Store object and only the storage id is passed in a
- *	queue message.The class is used both to generate and send messages and to
- *	receive messages from other tasks.
- *	@ingroup message_queue
- */
-class MessageQueueMessage: public MessageQueueMessageIF {
-public:
-	/**
-	 * @brief	The class is initialized empty with this constructor.
-	 * @details
-	 * The messageSize attribute is set to the header's size and the whole
-	 * content is set to zero.
-	 */
-	MessageQueueMessage();
-	/**
-	 * @brief	With this constructor the class is initialized with
-	 * 			the given content.
-	 * @details
-	 * If the passed message size fits into the buffer, the passed data is
-	 * copied to the internal buffer and the messageSize information is set.
-	 * Otherwise, messageSize is set to the header's size and the whole
-	 * content is set to zero.
-	 * @param data	The data to be put in the message.
-	 * @param size	Size of the data to be copied. Must be smaller than
-	 * 				MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
-	 */
-	MessageQueueMessage(uint8_t* data, size_t size);
-
-	/**
-	 * @brief	As no memory is allocated in this class,
-	 * 		    the destructor is empty.
-	 */
-	virtual ~MessageQueueMessage();
-
-	/**
-	 * @brief	The size information of each message is stored in
-	 *  			this attribute.
-	 * @details
-	 * It is public to simplify usage and to allow for passing the size
-	 * address as a pointer. Care must be taken when inheriting from this class,
-	 * as every child class is responsible for managing the size information by
-	 * itself. When using the class to receive a message, the size information
-	 * is updated automatically.
-	 *
-	 * Please note that the minimum size is limited by the size of the header
-	 * while the maximum size is limited by the maximum allowed message size.
-	 */
-	size_t messageSize;
-	/**
-	 * @brief	This constant defines the maximum size of the data content,
-	 * 			excluding the header.
-	 * @details
-	 * It may be changed if necessary, but in general should be kept
-	 * as small as possible.
-	 */
-	static const size_t MAX_DATA_SIZE = 24;
-
-	/**
-	 * @brief	This constant defines the maximum total size in bytes
-	 * 			of a sent message.
-	 * @details
-	 * It is the sum of the maximum data and the header size. Be aware that
-	 * this constant is used to define the buffer sizes for every message
-	 * queue in the system. So, a change here may have significant impact on
-	 * the required resources.
-	 */
-	static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
-	/**
-	 * @brief Defines the minimum size of a message where only the
-	 * 		  header is included
-	 */
-	static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
-private:
-	/**
-	 * @brief	This is the internal buffer that contains the
-	 * 			actual message data.
-	 */
-	uint8_t internalBuffer[MAX_MESSAGE_SIZE];
-public:
-	/**
-	 * @brief	This method is used to get the complete data of the message.
-	 */
-	const uint8_t* getBuffer() const override;
-	/**
-	 * @brief	This method is used to get the complete data of the message.
-	 */
-	uint8_t* getBuffer() override;
-	/**
-	 * @brief	This method is used to fetch the data content of the message.
-	 * @details
-	 * It shall be used by child classes to add data at the right position.
-	 */
-	const uint8_t* getData() const override;
-	/**
-	 * @brief	This method is used to fetch the data content of the message.
-	 * @details
-	 * It shall be used by child classes to add data at the right position.
-	 */
-	uint8_t* getData() override;
-	/**
-	 * @brief	This method is used to extract the sender's message
-	 * 			queue id information from a received message.
-	 */
-	MessageQueueId_t getSender() const override;
-	/**
-	 * @brief	With this method, the whole content
-	 * 			and the message size is set to zero.
-	 */
-	void clear() override;
-
-	/**
-	 * @brief	This method is used to set the sender's message queue id
-	 * 			information prior to ing the message.
-	 * @param setId
-	 * The message queue id that identifies the sending message queue.
-	 */
-	void setSender(MessageQueueId_t setId) override;
-
-	virtual size_t getMessageSize() const override;
-	virtual void setMessageSize(size_t messageSize) override;
-	virtual size_t getMinimumMessageSize() const override;
-	virtual size_t getMaximumMessageSize() const override;
-
-	/**
-	 * @brief	This is a debug method that prints the content.
-	 */
-	void print(bool printWholeMessage);
-};
-
-#endif /* MESSAGEQUEUEMESSAGE_H_ */
+#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
+#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
+
+#include "../ipc/MessageQueueMessageIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include <cstddef>
+
+/**
+ *	@brief		This class is the representation and data organizer
+ *				for interprocess messages.
+ *	@details
+ *	To facilitate and standardize interprocess communication, this class was
+ *	created to handle a lightweight "interprocess message protocol".
+ *
+ *	It adds a header with the sender's queue id to every sent message and
+ *	defines the maximum total message size. Specialized messages, such as
+ *	device commanding messages, can be created by inheriting from this class
+ *	and filling the buffer provided by getData with additional content.
+ *
+ *	If larger amounts of data must be sent between processes, the data shall
+ *	be stored in the IPC Store object and only the storage id is passed in a
+ *	queue message.The class is used both to generate and send messages and to
+ *	receive messages from other tasks.
+ *	@ingroup message_queue
+ */
+class MessageQueueMessage: public MessageQueueMessageIF {
+public:
+	/**
+	 * @brief	The class is initialized empty with this constructor.
+	 * @details
+	 * The messageSize attribute is set to the header's size and the whole
+	 * content is set to zero.
+	 */
+	MessageQueueMessage();
+	/**
+	 * @brief	With this constructor the class is initialized with
+	 * 			the given content.
+	 * @details
+	 * If the passed message size fits into the buffer, the passed data is
+	 * copied to the internal buffer and the messageSize information is set.
+	 * Otherwise, messageSize is set to the header's size and the whole
+	 * content is set to zero.
+	 * @param data	The data to be put in the message.
+	 * @param size	Size of the data to be copied. Must be smaller than
+	 * 				MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
+	 */
+	MessageQueueMessage(uint8_t* data, size_t size);
+
+	/**
+	 * @brief	As no memory is allocated in this class,
+	 * 		    the destructor is empty.
+	 */
+	virtual ~MessageQueueMessage();
+
+	/**
+	 * @brief	The size information of each message is stored in
+	 *  			this attribute.
+	 * @details
+	 * It is public to simplify usage and to allow for passing the size
+	 * address as a pointer. Care must be taken when inheriting from this class,
+	 * as every child class is responsible for managing the size information by
+	 * itself. When using the class to receive a message, the size information
+	 * is updated automatically.
+	 *
+	 * Please note that the minimum size is limited by the size of the header
+	 * while the maximum size is limited by the maximum allowed message size.
+	 */
+	size_t messageSize;
+	/**
+	 * @brief	This constant defines the maximum size of the data content,
+	 * 			excluding the header.
+	 * @details
+	 * It may be changed if necessary, but in general should be kept
+	 * as small as possible.
+	 */
+	static const size_t MAX_DATA_SIZE = 24;
+
+	/**
+	 * @brief	This constant defines the maximum total size in bytes
+	 * 			of a sent message.
+	 * @details
+	 * It is the sum of the maximum data and the header size. Be aware that
+	 * this constant is used to define the buffer sizes for every message
+	 * queue in the system. So, a change here may have significant impact on
+	 * the required resources.
+	 */
+	static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
+	/**
+	 * @brief Defines the minimum size of a message where only the
+	 * 		  header is included
+	 */
+	static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
+private:
+	/**
+	 * @brief	This is the internal buffer that contains the
+	 * 			actual message data.
+	 */
+	uint8_t internalBuffer[MAX_MESSAGE_SIZE];
+public:
+	/**
+	 * @brief	This method is used to get the complete data of the message.
+	 */
+	const uint8_t* getBuffer() const override;
+	/**
+	 * @brief	This method is used to get the complete data of the message.
+	 */
+	uint8_t* getBuffer() override;
+	/**
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
+	 */
+	const uint8_t* getData() const override;
+	/**
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
+	 */
+	uint8_t* getData() override;
+	/**
+	 * @brief	This method is used to extract the sender's message
+	 * 			queue id information from a received message.
+	 */
+	MessageQueueId_t getSender() const override;
+	/**
+	 * @brief	With this method, the whole content
+	 * 			and the message size is set to zero.
+	 */
+	void clear() override;
+
+	/**
+	 * @brief	This method is used to set the sender's message queue id
+	 * 			information prior to ing the message.
+	 * @param setId
+	 * The message queue id that identifies the sending message queue.
+	 */
+	void setSender(MessageQueueId_t setId) override;
+
+	virtual size_t getMessageSize() const override;
+	virtual void setMessageSize(size_t messageSize) override;
+	virtual size_t getMinimumMessageSize() const override;
+	virtual size_t getMaximumMessageSize() const override;
+
+	/**
+	 * @brief	This is a debug method that prints the content.
+	 */
+	void print(bool printWholeMessage);
+};
+
+#endif /* MESSAGEQUEUEMESSAGE_H_ */
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index e4b9670e7..806231578 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,25 +1,25 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
-
-#include <framework/ipc/MessageQueueMessageIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-class MessageQueueSenderIF {
-public:
-
-	virtual ~MessageQueueSenderIF() {}
-
-	/**
-	 * Allows sending messages without actually "owning" a message queue.
-	 * Not sure whether this is actually a good idea.
-	 */
-	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
-			bool ignoreFault = false);
-private:
-	MessageQueueSenderIF() {}
-};
-
-
-#endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */
+#ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
+#define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
+
+#include "../ipc/MessageQueueMessageIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+class MessageQueueSenderIF {
+public:
+
+	virtual ~MessageQueueSenderIF() {}
+
+	/**
+	 * Allows sending messages without actually "owning" a message queue.
+	 * Not sure whether this is actually a good idea.
+	 */
+	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
+			bool ignoreFault = false);
+private:
+	MessageQueueSenderIF() {}
+};
+
+
+#endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */
diff --git a/ipc/MutexFactory.h b/ipc/MutexFactory.h
index b2e58b6e7..91e909073 100644
--- a/ipc/MutexFactory.h
+++ b/ipc/MutexFactory.h
@@ -1,34 +1,34 @@
-#ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
-#define FRAMEWORK_IPC_MUTEXFACTORY_H_
-
-#include <framework/ipc/MutexIF.h>
-/**
- * Creates Mutex.
- * This class is a "singleton" interface, i.e. it provides an
- * interface, but also is the base class for a singleton.
- */
-class MutexFactory {
-public:
-	virtual ~MutexFactory();
-	/**
-	 * Returns the single instance of MutexFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static MutexFactory* instance();
-
-	MutexIF* createMutex();
-
-	void deleteMutex(MutexIF* mutex);
-
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	MutexFactory();
-	static MutexFactory* factoryInstance;
-};
-
-
-
-#endif /* FRAMEWORK_IPC_MUTEXFACTORY_H_ */
+#ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
+#define FRAMEWORK_IPC_MUTEXFACTORY_H_
+
+#include "../ipc/MutexIF.h"
+/**
+ * Creates Mutex.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class MutexFactory {
+public:
+	virtual ~MutexFactory();
+	/**
+	 * Returns the single instance of MutexFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static MutexFactory* instance();
+
+	MutexIF* createMutex();
+
+	void deleteMutex(MutexIF* mutex);
+
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	MutexFactory();
+	static MutexFactory* factoryInstance;
+};
+
+
+
+#endif /* FRAMEWORK_IPC_MUTEXFACTORY_H_ */
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 52ce51e3a..31d8d9ecb 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -1,30 +1,30 @@
-#ifndef FRAMEWORK_IPC_MUTEXHELPER_H_
-#define FRAMEWORK_IPC_MUTEXHELPER_H_
-
-#include <framework/ipc/MutexFactory.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-class MutexHelper {
-public:
-	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
-			internalMutex(mutex) {
-		ReturnValue_t status = mutex->lockMutex(timeoutType,
-		        timeoutMs);
-		if(status == MutexIF::MUTEX_TIMEOUT) {
-			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
-					<< timeoutMs << " milliseconds!" << std::endl;
-		}
-		else if(status != HasReturnvaluesIF::RETURN_OK){
-			sif::error << "MutexHelper: Lock of Mutex failed with code " <<
-					status << std::endl;
-		}
-	}
-
-	~MutexHelper() {
-		internalMutex->unlockMutex();
-	}
-private:
-	MutexIF* internalMutex;
-};
-#endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */
+#ifndef FRAMEWORK_IPC_MUTEXHELPER_H_
+#define FRAMEWORK_IPC_MUTEXHELPER_H_
+
+#include "../ipc/MutexFactory.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+class MutexHelper {
+public:
+	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
+			internalMutex(mutex) {
+		ReturnValue_t status = mutex->lockMutex(timeoutType,
+		        timeoutMs);
+		if(status == MutexIF::MUTEX_TIMEOUT) {
+			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
+					<< timeoutMs << " milliseconds!" << std::endl;
+		}
+		else if(status != HasReturnvaluesIF::RETURN_OK){
+			sif::error << "MutexHelper: Lock of Mutex failed with code " <<
+					status << std::endl;
+		}
+	}
+
+	~MutexHelper() {
+		internalMutex->unlockMutex();
+	}
+private:
+	MutexIF* internalMutex;
+};
+#endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */
diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index b0096a343..7bca4c9de 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -1,89 +1,89 @@
-#ifndef FRAMEWORK_IPC_MUTEXIF_H_
-#define FRAMEWORK_IPC_MUTEXIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-/**
- * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
- * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
- * @ingroup osal
- * @ingroup interface
- */
-class MutexIF {
-public:
-    /**
-     * Different types of timeout for the mutex lock.
-     */
-    enum TimeoutType {
-        POLLING, //!< If mutex is not available, return immediately
-        WAITING, //!< Wait a specified time for the mutex to become available
-        BLOCKING //!< Block indefinitely until the mutex becomes available.
-    };
-
-    /**
-     * Lock the mutex. The timeout value will only be used for
-     * TimeoutType::WAITING
-     * @param timeoutType
-     * @param timeoutMs
-     * @return
-     */
-    virtual ReturnValue_t lockMutex(TimeoutType timeoutType =
-            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
-    virtual ReturnValue_t unlockMutex() = 0;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
-	/**
-	 * The system lacked the necessary resources (other than memory) to initialize another mutex.
-	 */
-	static const ReturnValue_t NOT_ENOUGH_RESOURCES = MAKE_RETURN_CODE(1);
-	/**
-	 * Insufficient memory to create or init Mutex
-	 */
-	static const ReturnValue_t INSUFFICIENT_MEMORY = MAKE_RETURN_CODE(2);
-	/**
-	 * Caller does not have enough or right privilege
-	 */
-	static const ReturnValue_t NO_PRIVILEGE =  MAKE_RETURN_CODE(3);
-	/**
-	 * Wrong Attribute Setting
-	 */
-	static const ReturnValue_t WRONG_ATTRIBUTE_SETTING = MAKE_RETURN_CODE(4);
-	/**
-	 * The mutex is already locked
-	 */
-	static const ReturnValue_t MUTEX_ALREADY_LOCKED = MAKE_RETURN_CODE(5);
-	/**
-	 * Mutex object not found
-	 */
-	static const ReturnValue_t MUTEX_NOT_FOUND = MAKE_RETURN_CODE(6);
-	/**
-	 * Mutex could not be locked because max amount of recursive locks
-	 */
-	static const ReturnValue_t MUTEX_MAX_LOCKS = MAKE_RETURN_CODE(7);
-	/**
-	 * The current thread already owns this mutex
-	 */
-	static const ReturnValue_t CURR_THREAD_ALREADY_OWNS_MUTEX = MAKE_RETURN_CODE(8);
-	/**
-	 * Current thread does not own this mutex
-	 */
-	static const ReturnValue_t CURR_THREAD_DOES_NOT_OWN_MUTEX = MAKE_RETURN_CODE(9);
-	/**
-	 * The Mutex could not be blocked before timeout
-	 */
-	static const ReturnValue_t MUTEX_TIMEOUT = MAKE_RETURN_CODE(10);
-	/**
-	 * Invalid Mutex ID
-	 */
-	static const ReturnValue_t MUTEX_INVALID_ID = MAKE_RETURN_CODE(11);
-	/**
-	 * Mutex destroyed while waiting
-	 */
-	static const ReturnValue_t MUTEX_DESTROYED_WHILE_WAITING = MAKE_RETURN_CODE(12);
-
-    virtual ~MutexIF() {}
-};
-
-
-
-#endif /* FRAMEWORK_IPC_MUTEXIF_H_ */
+#ifndef FRAMEWORK_IPC_MUTEXIF_H_
+#define FRAMEWORK_IPC_MUTEXIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
+ * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
+ * @ingroup osal
+ * @ingroup interface
+ */
+class MutexIF {
+public:
+    /**
+     * Different types of timeout for the mutex lock.
+     */
+    enum TimeoutType {
+        POLLING, //!< If mutex is not available, return immediately
+        WAITING, //!< Wait a specified time for the mutex to become available
+        BLOCKING //!< Block indefinitely until the mutex becomes available.
+    };
+
+    /**
+     * Lock the mutex. The timeout value will only be used for
+     * TimeoutType::WAITING
+     * @param timeoutType
+     * @param timeoutMs
+     * @return
+     */
+    virtual ReturnValue_t lockMutex(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
+    virtual ReturnValue_t unlockMutex() = 0;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
+	/**
+	 * The system lacked the necessary resources (other than memory) to initialize another mutex.
+	 */
+	static const ReturnValue_t NOT_ENOUGH_RESOURCES = MAKE_RETURN_CODE(1);
+	/**
+	 * Insufficient memory to create or init Mutex
+	 */
+	static const ReturnValue_t INSUFFICIENT_MEMORY = MAKE_RETURN_CODE(2);
+	/**
+	 * Caller does not have enough or right privilege
+	 */
+	static const ReturnValue_t NO_PRIVILEGE =  MAKE_RETURN_CODE(3);
+	/**
+	 * Wrong Attribute Setting
+	 */
+	static const ReturnValue_t WRONG_ATTRIBUTE_SETTING = MAKE_RETURN_CODE(4);
+	/**
+	 * The mutex is already locked
+	 */
+	static const ReturnValue_t MUTEX_ALREADY_LOCKED = MAKE_RETURN_CODE(5);
+	/**
+	 * Mutex object not found
+	 */
+	static const ReturnValue_t MUTEX_NOT_FOUND = MAKE_RETURN_CODE(6);
+	/**
+	 * Mutex could not be locked because max amount of recursive locks
+	 */
+	static const ReturnValue_t MUTEX_MAX_LOCKS = MAKE_RETURN_CODE(7);
+	/**
+	 * The current thread already owns this mutex
+	 */
+	static const ReturnValue_t CURR_THREAD_ALREADY_OWNS_MUTEX = MAKE_RETURN_CODE(8);
+	/**
+	 * Current thread does not own this mutex
+	 */
+	static const ReturnValue_t CURR_THREAD_DOES_NOT_OWN_MUTEX = MAKE_RETURN_CODE(9);
+	/**
+	 * The Mutex could not be blocked before timeout
+	 */
+	static const ReturnValue_t MUTEX_TIMEOUT = MAKE_RETURN_CODE(10);
+	/**
+	 * Invalid Mutex ID
+	 */
+	static const ReturnValue_t MUTEX_INVALID_ID = MAKE_RETURN_CODE(11);
+	/**
+	 * Mutex destroyed while waiting
+	 */
+	static const ReturnValue_t MUTEX_DESTROYED_WHILE_WAITING = MAKE_RETURN_CODE(12);
+
+    virtual ~MutexIF() {}
+};
+
+
+
+#endif /* FRAMEWORK_IPC_MUTEXIF_H_ */
diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index 09259ae34..8141a3cf2 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -1,33 +1,33 @@
-#ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
-#define FRAMEWORK_IPC_QUEUEFACTORY_H_
-
-#include <framework/ipc/MessageQueueIF.h>
-#include <cstdint>
-/**
- * Creates message queues.
- * This class is a "singleton" interface, i.e. it provides an
- * interface, but also is the base class for a singleton.
- */
-class QueueFactory {
-public:
-	virtual ~QueueFactory();
-	/**
-	 * Returns the single instance of QueueFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static QueueFactory* instance();
-
-	MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
-			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
-
-	void deleteMessageQueue(MessageQueueIF* queue);
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	QueueFactory();
-	static QueueFactory* factoryInstance;
-};
-
-#endif /* FRAMEWORK_IPC_QUEUEFACTORY_H_ */
+#ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
+#define FRAMEWORK_IPC_QUEUEFACTORY_H_
+
+#include "../ipc/MessageQueueIF.h"
+#include <cstdint>
+/**
+ * Creates message queues.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class QueueFactory {
+public:
+	virtual ~QueueFactory();
+	/**
+	 * Returns the single instance of QueueFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static QueueFactory* instance();
+
+	MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
+
+	void deleteMessageQueue(MessageQueueIF* queue);
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	QueueFactory();
+	static QueueFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_IPC_QUEUEFACTORY_H_ */
diff --git a/memory/AcceptsMemoryMessagesIF.h b/memory/AcceptsMemoryMessagesIF.h
index 2b37f1af2..044f22360 100644
--- a/memory/AcceptsMemoryMessagesIF.h
+++ b/memory/AcceptsMemoryMessagesIF.h
@@ -1,21 +1,21 @@
-/**
- * @file	AcceptsMemoryMessagesIF.h
- * @brief	This file defines the AcceptsMemoryMessagesIF class.
- * @date	11.07.2013
- * @author	baetz
- */
-
-#ifndef ACCEPTSMEMORYMESSAGESIF_H_
-#define ACCEPTSMEMORYMESSAGESIF_H_
-
-#include <framework/memory/HasMemoryIF.h>
-#include <framework/memory/MemoryMessage.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class AcceptsMemoryMessagesIF : public HasMemoryIF {
-public:
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-};
-
-
-#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */
+/**
+ * @file	AcceptsMemoryMessagesIF.h
+ * @brief	This file defines the AcceptsMemoryMessagesIF class.
+ * @date	11.07.2013
+ * @author	baetz
+ */
+
+#ifndef ACCEPTSMEMORYMESSAGESIF_H_
+#define ACCEPTSMEMORYMESSAGESIF_H_
+
+#include "../memory/HasMemoryIF.h"
+#include "../memory/MemoryMessage.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class AcceptsMemoryMessagesIF : public HasMemoryIF {
+public:
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+};
+
+
+#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */
diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index efbc80097..a1c3955f5 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -1,28 +1,28 @@
-/*
- * FileSystemMessage.cpp
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#include "FileSystemMessage.h"
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-ReturnValue_t FileSystemMessage::setWriteToFileCommand(CommandMessage* message,
-		MessageQueueId_t replyQueueId, store_address_t storageID) {
-	message->setCommand(WRITE_TO_FILE);
-	message->setParameter(replyQueueId);
-	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-store_address_t FileSystemMessage::getStoreID(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-MessageQueueId_t FileSystemMessage::getReplyQueueId(const CommandMessage* message){
-	return message->getParameter();
-}
-
+/*
+ * FileSystemMessage.cpp
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#include "FileSystemMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+ReturnValue_t FileSystemMessage::setWriteToFileCommand(CommandMessage* message,
+		MessageQueueId_t replyQueueId, store_address_t storageID) {
+	message->setCommand(WRITE_TO_FILE);
+	message->setParameter(replyQueueId);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+store_address_t FileSystemMessage::getStoreID(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+MessageQueueId_t FileSystemMessage::getReplyQueueId(const CommandMessage* message){
+	return message->getParameter();
+}
+
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index 9f9c1496d..9ef9a2f49 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -1,30 +1,30 @@
-/*
- * FileSystemMessage.h
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
-#define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
-
-class FileSystemMessage {
-private:
-	FileSystemMessage(); //A private ctor inhibits instantiation
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
-	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
-	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
-	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
-
-	static ReturnValue_t setWriteToFileCommand(CommandMessage* message, MessageQueueId_t replyToQueue, store_address_t storageID );
-	static store_address_t getStoreID( const CommandMessage* message );
-	static MessageQueueId_t getReplyQueueId(const CommandMessage* message);
-
-};
-
-#endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */
+/*
+ * FileSystemMessage.h
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
+#define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+
+class FileSystemMessage {
+private:
+	FileSystemMessage(); //A private ctor inhibits instantiation
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
+	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
+	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
+	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
+
+	static ReturnValue_t setWriteToFileCommand(CommandMessage* message, MessageQueueId_t replyToQueue, store_address_t storageID );
+	static store_address_t getStoreID( const CommandMessage* message );
+	static MessageQueueId_t getReplyQueueId(const CommandMessage* message);
+
+};
+
+#endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */
diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 8b66f88b7..49a2ae54b 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -1,36 +1,36 @@
-/*
- * HasFileSystemIF.h
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#ifndef FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
-#define FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-class HasFileSystemIF {
-public:
-
-	virtual ~HasFileSystemIF() {}
-	/**
-	 * Function to get the MessageQueueId_t of the implementing object
-	 * @return MessageQueueId_t of the object
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	/**
-	 * Function to write to a file
-	 * @param dirname Directory of the file
-	 * @param filename The filename of the file
-	 * @param data The data to write to the file
-	 * @param size The size of the data to write
-	 * @param packetNumber Counts the number of packets. For large files the write procedure must be split in multiple calls to writeToFile
-	 */
-	virtual ReturnValue_t writeToFile(const char* dirname, char* filename, const uint8_t* data, uint32_t size, uint16_t packetNumber) = 0;
-	virtual ReturnValue_t createFile(const char* dirname, const char* filename, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t deleteFile(const char* dirname, const char* filename) = 0;
-};
-
-
-#endif /* FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_ */
+/*
+ * HasFileSystemIF.h
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#ifndef FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+#define FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class HasFileSystemIF {
+public:
+
+	virtual ~HasFileSystemIF() {}
+	/**
+	 * Function to get the MessageQueueId_t of the implementing object
+	 * @return MessageQueueId_t of the object
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	/**
+	 * Function to write to a file
+	 * @param dirname Directory of the file
+	 * @param filename The filename of the file
+	 * @param data The data to write to the file
+	 * @param size The size of the data to write
+	 * @param packetNumber Counts the number of packets. For large files the write procedure must be split in multiple calls to writeToFile
+	 */
+	virtual ReturnValue_t writeToFile(const char* dirname, char* filename, const uint8_t* data, uint32_t size, uint16_t packetNumber) = 0;
+	virtual ReturnValue_t createFile(const char* dirname, const char* filename, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t deleteFile(const char* dirname, const char* filename) = 0;
+};
+
+
+#endif /* FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_ */
diff --git a/memory/HasMemoryIF.h b/memory/HasMemoryIF.h
index cd6e66654..788a86b6d 100644
--- a/memory/HasMemoryIF.h
+++ b/memory/HasMemoryIF.h
@@ -1,47 +1,47 @@
-#ifndef HASMEMORYIF_H_
-#define HASMEMORYIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-class HasMemoryIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MEMORY_IF;
-	static const ReturnValue_t DO_IT_MYSELF = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t POINTS_TO_VARIABLE = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t POINTS_TO_MEMORY =  MAKE_RETURN_CODE(3);
-	static const ReturnValue_t ACTIVITY_COMPLETED  =  MAKE_RETURN_CODE(4);
-	static const ReturnValue_t POINTS_TO_VECTOR_UINT8 = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t POINTS_TO_VECTOR_UINT16 = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t POINTS_TO_VECTOR_UINT32 = MAKE_RETURN_CODE(7);
-	static const ReturnValue_t POINTS_TO_VECTOR_FLOAT = MAKE_RETURN_CODE(8);
-	static const ReturnValue_t DUMP_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA0);
-	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t INVALID_CONTENT = MAKE_RETURN_CODE(0xE2);
-	static const ReturnValue_t UNALIGNED_ACCESS = MAKE_RETURN_CODE(0xE3);
-	static const ReturnValue_t WRITE_PROTECTED = MAKE_RETURN_CODE(0xE4);
-//	static const ReturnValue_t TARGET_BUSY = MAKE_RETURN_CODE(0xE5);
-	virtual ~HasMemoryIF() {}
-	virtual ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data, uint32_t size, uint8_t** dataPointer) = 0;
-	virtual ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size, uint8_t** dataPointer, uint8_t* dumpTarget ) = 0;
-	/**
-	 * Sets the address of the memory, if possible.
-	 * startAddress is a proposal for an address, or the base address if multiple addresses are set.
-	 */
-	virtual ReturnValue_t setAddress( uint32_t* startAddress ) { return HasReturnvaluesIF::RETURN_FAILED; }
-	static bool memAccessWasSuccessful(ReturnValue_t result) {
-		switch (result) {
-		case DO_IT_MYSELF:
-		case POINTS_TO_MEMORY:
-		case POINTS_TO_VARIABLE:
-		case HasReturnvaluesIF::RETURN_OK:
-		case ACTIVITY_COMPLETED:
-			return true;
-		default:
-			return false;
-		}
-	}
-};
-
-
-#endif /* HASMEMORYIF_H_ */
+#ifndef HASMEMORYIF_H_
+#define HASMEMORYIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class HasMemoryIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MEMORY_IF;
+	static const ReturnValue_t DO_IT_MYSELF = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t POINTS_TO_VARIABLE = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t POINTS_TO_MEMORY =  MAKE_RETURN_CODE(3);
+	static const ReturnValue_t ACTIVITY_COMPLETED  =  MAKE_RETURN_CODE(4);
+	static const ReturnValue_t POINTS_TO_VECTOR_UINT8 = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t POINTS_TO_VECTOR_UINT16 = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t POINTS_TO_VECTOR_UINT32 = MAKE_RETURN_CODE(7);
+	static const ReturnValue_t POINTS_TO_VECTOR_FLOAT = MAKE_RETURN_CODE(8);
+	static const ReturnValue_t DUMP_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA0);
+	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
+	static const ReturnValue_t INVALID_CONTENT = MAKE_RETURN_CODE(0xE2);
+	static const ReturnValue_t UNALIGNED_ACCESS = MAKE_RETURN_CODE(0xE3);
+	static const ReturnValue_t WRITE_PROTECTED = MAKE_RETURN_CODE(0xE4);
+//	static const ReturnValue_t TARGET_BUSY = MAKE_RETURN_CODE(0xE5);
+	virtual ~HasMemoryIF() {}
+	virtual ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data, uint32_t size, uint8_t** dataPointer) = 0;
+	virtual ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size, uint8_t** dataPointer, uint8_t* dumpTarget ) = 0;
+	/**
+	 * Sets the address of the memory, if possible.
+	 * startAddress is a proposal for an address, or the base address if multiple addresses are set.
+	 */
+	virtual ReturnValue_t setAddress( uint32_t* startAddress ) { return HasReturnvaluesIF::RETURN_FAILED; }
+	static bool memAccessWasSuccessful(ReturnValue_t result) {
+		switch (result) {
+		case DO_IT_MYSELF:
+		case POINTS_TO_MEMORY:
+		case POINTS_TO_VARIABLE:
+		case HasReturnvaluesIF::RETURN_OK:
+		case ACTIVITY_COMPLETED:
+			return true;
+		default:
+			return false;
+		}
+	}
+};
+
+
+#endif /* HASMEMORYIF_H_ */
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index b07f450c4..c74b7d9f9 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -1,193 +1,193 @@
-#include <framework/globalfunctions/CRC.h>
-#include <framework/memory/MemoryHelper.h>
-#include <framework/memory/MemoryMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serialize/EndianConverter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
-		MessageQueueIF* useThisQueue):
-		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(nullptr),
-		ipcAddress(), lastCommand(CommandMessage::CMD_NONE), busy(false) {
-}
-
-ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
-	lastSender = message->getSender();
-	lastCommand = message->getCommand();
-	if (busy) {
-		sif::debug << "MemHelper: Busy!" << std::endl;
-	}
-	switch (lastCommand) {
-	case MemoryMessage::CMD_MEMORY_DUMP:
-		handleMemoryCheckOrDump(message);
-		return RETURN_OK;
-	case MemoryMessage::CMD_MEMORY_LOAD:
-		handleMemoryLoad(message);
-		return RETURN_OK;
-	case MemoryMessage::CMD_MEMORY_CHECK:
-		handleMemoryCheckOrDump(message);
-		return RETURN_OK;
-	default:
-		lastCommand = CommandMessage::CMD_NONE;
-		return UNKNOWN_CMD;
-	}
-}
-
-void MemoryHelper::completeLoad(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
-	busy = false;
-	switch (errorCode) {
-	case HasMemoryIF::DO_IT_MYSELF:
-		busy = true;
-		return;
-	case HasMemoryIF::POINTS_TO_MEMORY:
-		memcpy(copyHere, dataToCopy, size);
-		break;
-	case HasMemoryIF::POINTS_TO_VARIABLE:
-		EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
-		break;
-	case HasMemoryIF::ACTIVITY_COMPLETED:
-	case RETURN_OK:
-		break;
-	default:
-		ipcStore->deleteData(ipcAddress);
-		CommandMessage reply;
-		MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
-				MemoryMessage::CMD_MEMORY_LOAD);
-		queueToUse->sendMessage(lastSender, &reply);
-		return;
-	}
-	//Only reached on success
-	CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
-	queueToUse->sendMessage(lastSender, &reply);
-	ipcStore->deleteData(ipcAddress);
-}
-
-void MemoryHelper::completeDump(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size) {
-	busy = false;
-	CommandMessage reply;
-	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
-	switch (errorCode) {
-	case HasMemoryIF::DO_IT_MYSELF:
-		busy = true;
-		return;
-	case HasReturnvaluesIF::RETURN_OK:
-	case HasMemoryIF::POINTS_TO_MEMORY:
-	case HasMemoryIF::POINTS_TO_VARIABLE:
-		//"data" must be valid pointer!
-		if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
-			EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
-		} else {
-			memcpy(reservedSpaceInIPC, dataToCopy, size);
-		}
-		/* NO BREAK falls through*/
-	case HasMemoryIF::ACTIVITY_COMPLETED:
-		switch (lastCommand) {
-		case MemoryMessage::CMD_MEMORY_DUMP: {
-			MemoryMessage::setMemoryDumpReply(&reply, ipcAddress);
-			break;
-		}
-		case MemoryMessage::CMD_MEMORY_CHECK: {
-			uint16_t crc = CRC::crc16ccitt(reservedSpaceInIPC, size);
-			//Delete data immediately, was temporary.
-			ipcStore->deleteData(ipcAddress);
-			MemoryMessage::setMemoryCheckReply(&reply, crc);
-			break;
-		}
-		default:
-			//This should never happen!
-			//Is it ok to send message? Otherwise: return;
-			ipcStore->deleteData(ipcAddress);
-			reply.setParameter(STATE_MISMATCH);
-			break;
-		}
-		break;
-	case HasMemoryIF::DUMP_NOT_SUPPORTED:
-		if (lastCommand == MemoryMessage::CMD_MEMORY_CHECK){
-			MemoryMessage::setMemoryCheckReply(&reply, 0);
-			MemoryMessage::setCrcReturnValue(&reply,HasMemoryIF::DUMP_NOT_SUPPORTED);
-		}
-		ipcStore->deleteData(ipcAddress);
-		break;
-	default:
-		//Reply is already set to REJECTED.
-		ipcStore->deleteData(ipcAddress);
-		break;
-	}
-	if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
-		reply.clear();
-	}
-}
-
-void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
-		uint32_t totalSize, uint8_t datatypeSize) {
-	if (totalSize % datatypeSize != 0){
-		return;
-	}
-
-	while (totalSize > 0){
-		EndianConverter::convertBigEndian(out,in,datatypeSize);
-		out += datatypeSize;
-		in += datatypeSize;
-		totalSize -= datatypeSize;
-	}
-}
-
-MemoryHelper::~MemoryHelper() {
-	//Nothing to destroy
-}
-
-void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
-	uint32_t address = MemoryMessage::getAddress(message);
-	ipcAddress = MemoryMessage::getStoreID(message);
-	const uint8_t* p_data = NULL;
-	uint8_t* dataPointer = NULL;
-	size_t size = 0;
-	ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
-	if (returnCode == RETURN_OK) {
-		returnCode = workOnThis->handleMemoryLoad(address, p_data, size,
-				&dataPointer);
-		completeLoad(returnCode, p_data, size, dataPointer);
-	} else {
-		//At least inform sender.
-		CommandMessage reply;
-		MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
-				MemoryMessage::CMD_MEMORY_LOAD);
-		queueToUse->sendMessage(lastSender, &reply);
-	}
-}
-
-void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
-	uint32_t address = MemoryMessage::getAddress(message);
-	uint32_t size = MemoryMessage::getLength(message);
-	uint8_t* dataPointer = NULL;
-	ReturnValue_t returnCode = ipcStore->getFreeElement(&ipcAddress, size,
-			&reservedSpaceInIPC);
-	if (returnCode == RETURN_OK) {
-		returnCode = workOnThis->handleMemoryDump(address, size, &dataPointer,
-				reservedSpaceInIPC);
-		completeDump(returnCode, dataPointer, size);
-	} else {
-		CommandMessage reply;
-		MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
-		queueToUse->sendMessage(lastSender, &reply);
-	}
-}
-
-ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
-	if(queueToUse_ == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	this->queueToUse = queueToUse_;
-	return initialize();
-}
-
-ReturnValue_t MemoryHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore != nullptr) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
+#include "../globalfunctions/CRC.h"
+#include "../memory/MemoryHelper.h"
+#include "../memory/MemoryMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/EndianConverter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
+		MessageQueueIF* useThisQueue):
+		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(nullptr),
+		ipcAddress(), lastCommand(CommandMessage::CMD_NONE), busy(false) {
+}
+
+ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
+	lastSender = message->getSender();
+	lastCommand = message->getCommand();
+	if (busy) {
+		sif::debug << "MemHelper: Busy!" << std::endl;
+	}
+	switch (lastCommand) {
+	case MemoryMessage::CMD_MEMORY_DUMP:
+		handleMemoryCheckOrDump(message);
+		return RETURN_OK;
+	case MemoryMessage::CMD_MEMORY_LOAD:
+		handleMemoryLoad(message);
+		return RETURN_OK;
+	case MemoryMessage::CMD_MEMORY_CHECK:
+		handleMemoryCheckOrDump(message);
+		return RETURN_OK;
+	default:
+		lastCommand = CommandMessage::CMD_NONE;
+		return UNKNOWN_CMD;
+	}
+}
+
+void MemoryHelper::completeLoad(ReturnValue_t errorCode,
+		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
+	busy = false;
+	switch (errorCode) {
+	case HasMemoryIF::DO_IT_MYSELF:
+		busy = true;
+		return;
+	case HasMemoryIF::POINTS_TO_MEMORY:
+		memcpy(copyHere, dataToCopy, size);
+		break;
+	case HasMemoryIF::POINTS_TO_VARIABLE:
+		EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
+		break;
+	case HasMemoryIF::ACTIVITY_COMPLETED:
+	case RETURN_OK:
+		break;
+	default:
+		ipcStore->deleteData(ipcAddress);
+		CommandMessage reply;
+		MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
+				MemoryMessage::CMD_MEMORY_LOAD);
+		queueToUse->sendMessage(lastSender, &reply);
+		return;
+	}
+	//Only reached on success
+	CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
+	queueToUse->sendMessage(lastSender, &reply);
+	ipcStore->deleteData(ipcAddress);
+}
+
+void MemoryHelper::completeDump(ReturnValue_t errorCode,
+		const uint8_t* dataToCopy, const uint32_t size) {
+	busy = false;
+	CommandMessage reply;
+	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
+	switch (errorCode) {
+	case HasMemoryIF::DO_IT_MYSELF:
+		busy = true;
+		return;
+	case HasReturnvaluesIF::RETURN_OK:
+	case HasMemoryIF::POINTS_TO_MEMORY:
+	case HasMemoryIF::POINTS_TO_VARIABLE:
+		//"data" must be valid pointer!
+		if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
+			EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
+		} else {
+			memcpy(reservedSpaceInIPC, dataToCopy, size);
+		}
+		/* NO BREAK falls through*/
+	case HasMemoryIF::ACTIVITY_COMPLETED:
+		switch (lastCommand) {
+		case MemoryMessage::CMD_MEMORY_DUMP: {
+			MemoryMessage::setMemoryDumpReply(&reply, ipcAddress);
+			break;
+		}
+		case MemoryMessage::CMD_MEMORY_CHECK: {
+			uint16_t crc = CRC::crc16ccitt(reservedSpaceInIPC, size);
+			//Delete data immediately, was temporary.
+			ipcStore->deleteData(ipcAddress);
+			MemoryMessage::setMemoryCheckReply(&reply, crc);
+			break;
+		}
+		default:
+			//This should never happen!
+			//Is it ok to send message? Otherwise: return;
+			ipcStore->deleteData(ipcAddress);
+			reply.setParameter(STATE_MISMATCH);
+			break;
+		}
+		break;
+	case HasMemoryIF::DUMP_NOT_SUPPORTED:
+		if (lastCommand == MemoryMessage::CMD_MEMORY_CHECK){
+			MemoryMessage::setMemoryCheckReply(&reply, 0);
+			MemoryMessage::setCrcReturnValue(&reply,HasMemoryIF::DUMP_NOT_SUPPORTED);
+		}
+		ipcStore->deleteData(ipcAddress);
+		break;
+	default:
+		//Reply is already set to REJECTED.
+		ipcStore->deleteData(ipcAddress);
+		break;
+	}
+	if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
+		reply.clear();
+	}
+}
+
+void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
+		uint32_t totalSize, uint8_t datatypeSize) {
+	if (totalSize % datatypeSize != 0){
+		return;
+	}
+
+	while (totalSize > 0){
+		EndianConverter::convertBigEndian(out,in,datatypeSize);
+		out += datatypeSize;
+		in += datatypeSize;
+		totalSize -= datatypeSize;
+	}
+}
+
+MemoryHelper::~MemoryHelper() {
+	//Nothing to destroy
+}
+
+void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
+	uint32_t address = MemoryMessage::getAddress(message);
+	ipcAddress = MemoryMessage::getStoreID(message);
+	const uint8_t* p_data = NULL;
+	uint8_t* dataPointer = NULL;
+	size_t size = 0;
+	ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
+	if (returnCode == RETURN_OK) {
+		returnCode = workOnThis->handleMemoryLoad(address, p_data, size,
+				&dataPointer);
+		completeLoad(returnCode, p_data, size, dataPointer);
+	} else {
+		//At least inform sender.
+		CommandMessage reply;
+		MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
+				MemoryMessage::CMD_MEMORY_LOAD);
+		queueToUse->sendMessage(lastSender, &reply);
+	}
+}
+
+void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
+	uint32_t address = MemoryMessage::getAddress(message);
+	uint32_t size = MemoryMessage::getLength(message);
+	uint8_t* dataPointer = NULL;
+	ReturnValue_t returnCode = ipcStore->getFreeElement(&ipcAddress, size,
+			&reservedSpaceInIPC);
+	if (returnCode == RETURN_OK) {
+		returnCode = workOnThis->handleMemoryDump(address, size, &dataPointer,
+				reservedSpaceInIPC);
+		completeDump(returnCode, dataPointer, size);
+	} else {
+		CommandMessage reply;
+		MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
+		queueToUse->sendMessage(lastSender, &reply);
+	}
+}
+
+ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
+	if(queueToUse_ == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	this->queueToUse = queueToUse_;
+	return initialize();
+}
+
+ReturnValue_t MemoryHelper::initialize() {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore != nullptr) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
diff --git a/memory/MemoryHelper.h b/memory/MemoryHelper.h
index da6b9bdb6..90dbafb49 100644
--- a/memory/MemoryHelper.h
+++ b/memory/MemoryHelper.h
@@ -1,37 +1,37 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYHELPER_H_
-#define FRAMEWORK_MEMORY_MEMORYHELPER_H_
-#include <framework/ipc/CommandMessage.h>
-#include <framework/memory/AcceptsMemoryMessagesIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-class MemoryHelper : public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER;
-	static const ReturnValue_t UNKNOWN_CMD = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2);
-	static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3);
-private:
-	HasMemoryIF* workOnThis;
-	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore = nullptr;
-	store_address_t ipcAddress;
-	Command_t lastCommand;
-	MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
-	uint8_t* reservedSpaceInIPC = nullptr;
-	bool busy;
-	void handleMemoryLoad(CommandMessage* message);
-	void handleMemoryCheckOrDump(CommandMessage* message);
-	ReturnValue_t initialize();
-public:
-	ReturnValue_t handleMemoryCommand(CommandMessage* message);
-	void completeLoad( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0, uint8_t* copyHere = NULL );
-	void completeDump(  ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0);
-	void swapMatrixCopy( uint8_t *out, const uint8_t *in, uint32_t totalSize, uint8_t datatypeSize);
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
-	MemoryHelper( HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue );
-	~MemoryHelper();
-};
-#endif /* MEMORYHELPER_H_ */
+#ifndef FRAMEWORK_MEMORY_MEMORYHELPER_H_
+#define FRAMEWORK_MEMORY_MEMORYHELPER_H_
+#include "../ipc/CommandMessage.h"
+#include "../memory/AcceptsMemoryMessagesIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class MemoryHelper : public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER;
+	static const ReturnValue_t UNKNOWN_CMD = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
+	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2);
+	static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3);
+private:
+	HasMemoryIF* workOnThis;
+	MessageQueueIF* queueToUse;
+	StorageManagerIF* ipcStore = nullptr;
+	store_address_t ipcAddress;
+	Command_t lastCommand;
+	MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
+	uint8_t* reservedSpaceInIPC = nullptr;
+	bool busy;
+	void handleMemoryLoad(CommandMessage* message);
+	void handleMemoryCheckOrDump(CommandMessage* message);
+	ReturnValue_t initialize();
+public:
+	ReturnValue_t handleMemoryCommand(CommandMessage* message);
+	void completeLoad( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0, uint8_t* copyHere = NULL );
+	void completeDump(  ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0);
+	void swapMatrixCopy( uint8_t *out, const uint8_t *in, uint32_t totalSize, uint8_t datatypeSize);
+	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
+	MemoryHelper( HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue );
+	~MemoryHelper();
+};
+#endif /* MEMORYHELPER_H_ */
diff --git a/memory/MemoryMessage.cpp b/memory/MemoryMessage.cpp
index f978ed4ec..16a60502c 100644
--- a/memory/MemoryMessage.cpp
+++ b/memory/MemoryMessage.cpp
@@ -1,112 +1,112 @@
-#include <framework/memory/MemoryMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-MemoryMessage::MemoryMessage() {
-}
-
-uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-store_address_t MemoryMessage::getStoreID(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-uint32_t MemoryMessage::getLength(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
-		uint32_t address, uint32_t length) {
-	message->setCommand(CMD_MEMORY_DUMP);
-	message->setParameter( address );
-	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_address_t storageID) {
-	message->setCommand(REPLY_MEMORY_DUMP);
-	message->setParameter2( storageID.raw );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
-		uint32_t address, store_address_t storageID) {
-	message->setCommand(CMD_MEMORY_LOAD);
-	message->setParameter( address );
-	message->setParameter2( storageID.raw );
-}
-
-ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-void MemoryMessage::clear(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case CMD_MEMORY_LOAD:
-	case REPLY_MEMORY_DUMP: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreID(message));
-		}
-	}
-	/* NO BREAK falls through*/
-	case CMD_MEMORY_DUMP:
-	case CMD_MEMORY_CHECK:
-	case REPLY_MEMORY_CHECK:
-	case END_OF_MEMORY_COPY:
-		message->setCommand(CommandMessage::CMD_NONE);
-		message->setParameter(0);
-		message->setParameter2(0);
-		break;
-		}
-}
-
-ReturnValue_t MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
-		uint32_t address, uint32_t length) {
-	message->setCommand(CMD_MEMORY_CHECK);
-	message->setParameter( address );
-	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message,
-		uint16_t crc) {
-	message->setCommand(REPLY_MEMORY_CHECK);
-	message->setParameter( crc );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void MemoryMessage::setCrcReturnValue(CommandMessage* message, ReturnValue_t returnValue){
-	message->setParameter(returnValue<<16);
-};
-
-uint16_t MemoryMessage::getCrc(const CommandMessage* message) {
-	return (uint16_t)(message->getParameter());
-}
-
-ReturnValue_t MemoryMessage::getCrcReturnValue(const CommandMessage* message){
-	return (message->getParameter()>>16);
-}
-
-Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
-		ReturnValue_t errorCode, Command_t initialCommand) {
-	message->setCommand(REPLY_MEMORY_FAILED);
-	message->setParameter(errorCode);
-	message->setParameter2(initialCommand);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
-	message->setCommand(END_OF_MEMORY_COPY);
-	message->setParameter(0);
-	message->setParameter2(0);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
+#include "../memory/MemoryMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+MemoryMessage::MemoryMessage() {
+}
+
+uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+store_address_t MemoryMessage::getStoreID(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+uint32_t MemoryMessage::getLength(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
+		uint32_t address, uint32_t length) {
+	message->setCommand(CMD_MEMORY_DUMP);
+	message->setParameter( address );
+	message->setParameter2( length );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_address_t storageID) {
+	message->setCommand(REPLY_MEMORY_DUMP);
+	message->setParameter2( storageID.raw );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
+		uint32_t address, store_address_t storageID) {
+	message->setCommand(CMD_MEMORY_LOAD);
+	message->setParameter( address );
+	message->setParameter2( storageID.raw );
+}
+
+ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+void MemoryMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_MEMORY_LOAD:
+	case REPLY_MEMORY_DUMP: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreID(message));
+		}
+	}
+	/* NO BREAK falls through*/
+	case CMD_MEMORY_DUMP:
+	case CMD_MEMORY_CHECK:
+	case REPLY_MEMORY_CHECK:
+	case END_OF_MEMORY_COPY:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+		}
+}
+
+ReturnValue_t MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
+		uint32_t address, uint32_t length) {
+	message->setCommand(CMD_MEMORY_CHECK);
+	message->setParameter( address );
+	message->setParameter2( length );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message,
+		uint16_t crc) {
+	message->setCommand(REPLY_MEMORY_CHECK);
+	message->setParameter( crc );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void MemoryMessage::setCrcReturnValue(CommandMessage* message, ReturnValue_t returnValue){
+	message->setParameter(returnValue<<16);
+};
+
+uint16_t MemoryMessage::getCrc(const CommandMessage* message) {
+	return (uint16_t)(message->getParameter());
+}
+
+ReturnValue_t MemoryMessage::getCrcReturnValue(const CommandMessage* message){
+	return (message->getParameter()>>16);
+}
+
+Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
+		ReturnValue_t errorCode, Command_t initialCommand) {
+	message->setCommand(REPLY_MEMORY_FAILED);
+	message->setParameter(errorCode);
+	message->setParameter2(initialCommand);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
+	message->setCommand(END_OF_MEMORY_COPY);
+	message->setParameter(0);
+	message->setParameter2(0);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
diff --git a/memory/MemoryMessage.h b/memory/MemoryMessage.h
index e2c87ca35..af936c1fb 100644
--- a/memory/MemoryMessage.h
+++ b/memory/MemoryMessage.h
@@ -1,39 +1,39 @@
-#ifndef MEMORYMESSAGE_H_
-#define MEMORYMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-
-
-class MemoryMessage {
-private:
-	MemoryMessage(); //A private ctor inhibits instantiation
-public:
-	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 );
-	static const Command_t REPLY_MEMORY_DUMP = MAKE_COMMAND_ID( 0x10 );
-	static const Command_t REPLY_MEMORY_CHECK = MAKE_COMMAND_ID( 0x30 );
-	static const Command_t REPLY_MEMORY_FAILED = MAKE_COMMAND_ID( 0xE0 );
-	static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
-
-	static uint32_t getAddress( const CommandMessage* message );
-	static store_address_t getStoreID( const CommandMessage* message );
-	static uint32_t getLength( const CommandMessage* message );
-	static ReturnValue_t getErrorCode( const CommandMessage* message );
-	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
-	static void setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
-	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
-	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
-	static ReturnValue_t setMemoryCopyEnd( CommandMessage* message);
-	static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue);
-	static uint16_t getCrc( const CommandMessage* message );
-	static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
-	static Command_t getInitialCommand( const CommandMessage* message );
-	static void clear(CommandMessage* message);
-};
-
-#endif /* MEMORYMESSAGE_H_ */
+#ifndef MEMORYMESSAGE_H_
+#define MEMORYMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+
+class MemoryMessage {
+private:
+	MemoryMessage(); //A private ctor inhibits instantiation
+public:
+	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 );
+	static const Command_t REPLY_MEMORY_DUMP = MAKE_COMMAND_ID( 0x10 );
+	static const Command_t REPLY_MEMORY_CHECK = MAKE_COMMAND_ID( 0x30 );
+	static const Command_t REPLY_MEMORY_FAILED = MAKE_COMMAND_ID( 0xE0 );
+	static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
+
+	static uint32_t getAddress( const CommandMessage* message );
+	static store_address_t getStoreID( const CommandMessage* message );
+	static uint32_t getLength( const CommandMessage* message );
+	static ReturnValue_t getErrorCode( const CommandMessage* message );
+	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
+	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
+	static void setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
+	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
+	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
+	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
+	static ReturnValue_t setMemoryCopyEnd( CommandMessage* message);
+	static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue);
+	static uint16_t getCrc( const CommandMessage* message );
+	static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
+	static Command_t getInitialCommand( const CommandMessage* message );
+	static void clear(CommandMessage* message);
+};
+
+#endif /* MEMORYMESSAGE_H_ */
diff --git a/memory/MemoryProxyIF.h b/memory/MemoryProxyIF.h
index d325ba4eb..a30165c39 100644
--- a/memory/MemoryProxyIF.h
+++ b/memory/MemoryProxyIF.h
@@ -1,22 +1,22 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-
-#include <framework/memory/AcceptsMemoryMessagesIF.h>
-
-/**
- * This was a nice idea to transparently forward incoming messages to another object.
- * But it doesn't work like that.
- */
-class MemoryProxyIF : public AcceptsMemoryMessagesIF {
-public:
-	virtual MessageQueueId_t getProxyQueue() const = 0;
-	MessageQueueId_t getCommandQueue() const {
-		return getProxyQueue();
-	}
-	virtual ~MemoryProxyIF() {}
-
-};
-
-
-
-#endif /* FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ */
+#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
+#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
+
+#include "../memory/AcceptsMemoryMessagesIF.h"
+
+/**
+ * This was a nice idea to transparently forward incoming messages to another object.
+ * But it doesn't work like that.
+ */
+class MemoryProxyIF : public AcceptsMemoryMessagesIF {
+public:
+	virtual MessageQueueId_t getProxyQueue() const = 0;
+	MessageQueueId_t getCommandQueue() const {
+		return getProxyQueue();
+	}
+	virtual ~MemoryProxyIF() {}
+
+};
+
+
+
+#endif /* FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ */
diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h
index 263b0a87f..eade3613e 100644
--- a/modes/HasModesIF.h
+++ b/modes/HasModesIF.h
@@ -1,57 +1,57 @@
-/**
- * @file	HasModesIF.h
- * @brief	This file defines the HasModesIF class.
- * @date	20.06.2013
- * @author	baetz
- */
-
-#ifndef HASMODESIF_H_
-#define HASMODESIF_H_
-
-#include <framework/events/Event.h>
-#include <framework/modes/ModeHelper.h>
-#include <framework/modes/ModeMessage.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <stdint.h>
-
-
-class HasModesIF {
-	friend class ModeHelper;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MODES_IF;
-	static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t TRANS_NOT_ALLOWED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t IN_TRANSITION = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-	static const Event CHANGING_MODE = MAKE_EVENT(0, SEVERITY::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
-	static const Event MODE_INFO = MAKE_EVENT(1, SEVERITY::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
-	static const Event FALLBACK_FAILED = MAKE_EVENT(2, SEVERITY::HIGH);
-	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, SEVERITY::HIGH);
-	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, SEVERITY::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
-	static const Event FORCING_MODE = MAKE_EVENT(6, SEVERITY::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
-	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, SEVERITY::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
-
-	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	static const Submode_t SUBMODE_NONE = 0; //!< To avoid checks against magic number "0".
-	virtual ~HasModesIF() {
-	}
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
-protected:
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	virtual void startTransition(Mode_t mode, Submode_t submode) {
-	}
-	virtual void setToExternalControl() {
-	}
-	virtual void announceMode(bool recursive) {
-	}
-};
-
-#endif /* HASMODESIF_H_ */
+/**
+ * @file	HasModesIF.h
+ * @brief	This file defines the HasModesIF class.
+ * @date	20.06.2013
+ * @author	baetz
+ */
+
+#ifndef HASMODESIF_H_
+#define HASMODESIF_H_
+
+#include "../events/Event.h"
+#include "../modes/ModeHelper.h"
+#include "../modes/ModeMessage.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <stdint.h>
+
+
+class HasModesIF {
+	friend class ModeHelper;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MODES_IF;
+	static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t TRANS_NOT_ALLOWED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t IN_TRANSITION = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
+	static const Event CHANGING_MODE = MAKE_EVENT(0, SEVERITY::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
+	static const Event MODE_INFO = MAKE_EVENT(1, SEVERITY::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
+	static const Event FALLBACK_FAILED = MAKE_EVENT(2, SEVERITY::HIGH);
+	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, SEVERITY::HIGH);
+	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, SEVERITY::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
+	static const Event FORCING_MODE = MAKE_EVENT(6, SEVERITY::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
+	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, SEVERITY::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
+
+	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	static const Submode_t SUBMODE_NONE = 0; //!< To avoid checks against magic number "0".
+	virtual ~HasModesIF() {
+	}
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
+protected:
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	virtual void startTransition(Mode_t mode, Submode_t submode) {
+	}
+	virtual void setToExternalControl() {
+	}
+	virtual void announceMode(bool recursive) {
+	}
+};
+
+#endif /* HASMODESIF_H_ */
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index 030f1db3c..d6cbf2c9f 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,135 +1,135 @@
-#include <framework/modes/HasModesIF.h>
-#include <framework/modes/ModeHelper.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-ModeHelper::ModeHelper(HasModesIF *owner) :
-		commandedMode(HasModesIF::MODE_OFF),
-		commandedSubmode(HasModesIF::SUBMODE_NONE),
-		owner(owner), forced(false) {}
-
-ModeHelper::~ModeHelper() {
-
-}
-
-ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
-	CommandMessage reply;
-	Mode_t mode;
-	Submode_t submode;
-	switch (command->getCommand()) {
-	case ModeMessage::CMD_MODE_COMMAND_FORCED:
-		forced = true;
-		/* NO BREAK falls through*/
-	case ModeMessage::CMD_MODE_COMMAND: {
-		mode = ModeMessage::getMode(command);
-		submode = ModeMessage::getSubmode(command);
-		uint32_t timeout;
-		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			ModeMessage::cantReachMode(&reply, result);
-			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-			        owner->getCommandQueue());
-			break;
-		}
-		//Free to start transition
-		theOneWhoCommandedAMode = command->getSender();
-		commandedMode = mode;
-		commandedSubmode = submode;
-
-		if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
-				&& (theOneWhoCommandedAMode != parentQueueId)) {
-			owner->setToExternalControl();
-		}
-
-		countdown.setTimeout(timeout);
-		owner->startTransition(mode, submode);
-	}
-		break;
-	case ModeMessage::CMD_MODE_READ: {
-		owner->getMode(&mode, &submode);
-		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
-				submode);
-		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-		       owner->getCommandQueue());
-	}
-		break;
-	case ModeMessage::CMD_MODE_ANNOUNCE:
-		owner->announceMode(false);
-		break;
-	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
-		owner->announceMode(true);
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
-	setParentQueue(parentQueueId);
-	return initialize();
-}
-
-void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
-	forced = false;
-	sendModeReplyMessage(ownerMode, ownerSubmode);
-	sendModeInfoMessage(ownerMode, ownerSubmode);
-	theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
-}
-
-void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
-		Submode_t ownerSubmode) {
-	CommandMessage reply;
-	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
-	{
-		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
-		{
-			ModeMessage::setModeMessage(&reply,
-					ModeMessage::REPLY_WRONG_MODE_REPLY, ownerMode,
-					ownerSubmode);
-		}
-		else
-		{
-			ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY,
-					ownerMode, ownerSubmode);
-		}
-		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
-		        owner->getCommandQueue());
-	}
-}
-
-void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
-		Submode_t ownerSubmode) {
-	CommandMessage reply;
-	if (theOneWhoCommandedAMode != parentQueueId
-			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
-	{
-		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
-				ownerMode, ownerSubmode);
-		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
-		        owner->getCommandQueue());
-	}
-}
-
-void ModeHelper::startTimer(uint32_t timeoutMs) {
-	countdown.setTimeout(timeoutMs);
-}
-
-void ModeHelper::setParentQueue(MessageQueueId_t parentQueueId) {
-	this->parentQueueId = parentQueueId;
-}
-
-ReturnValue_t ModeHelper::initialize(void) {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-bool ModeHelper::isTimedOut() {
-	return countdown.hasTimedOut();
-}
-
-bool ModeHelper::isForced() {
-	return forced;
-}
-
-void ModeHelper::setForced(bool forced) {
-	this->forced = forced;
-}
+#include "../modes/HasModesIF.h"
+#include "../modes/ModeHelper.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+ModeHelper::ModeHelper(HasModesIF *owner) :
+		commandedMode(HasModesIF::MODE_OFF),
+		commandedSubmode(HasModesIF::SUBMODE_NONE),
+		owner(owner), forced(false) {}
+
+ModeHelper::~ModeHelper() {
+
+}
+
+ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
+	CommandMessage reply;
+	Mode_t mode;
+	Submode_t submode;
+	switch (command->getCommand()) {
+	case ModeMessage::CMD_MODE_COMMAND_FORCED:
+		forced = true;
+		/* NO BREAK falls through*/
+	case ModeMessage::CMD_MODE_COMMAND: {
+		mode = ModeMessage::getMode(command);
+		submode = ModeMessage::getSubmode(command);
+		uint32_t timeout;
+		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			ModeMessage::cantReachMode(&reply, result);
+			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+			        owner->getCommandQueue());
+			break;
+		}
+		//Free to start transition
+		theOneWhoCommandedAMode = command->getSender();
+		commandedMode = mode;
+		commandedSubmode = submode;
+
+		if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
+				&& (theOneWhoCommandedAMode != parentQueueId)) {
+			owner->setToExternalControl();
+		}
+
+		countdown.setTimeout(timeout);
+		owner->startTransition(mode, submode);
+	}
+		break;
+	case ModeMessage::CMD_MODE_READ: {
+		owner->getMode(&mode, &submode);
+		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
+				submode);
+		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+		       owner->getCommandQueue());
+	}
+		break;
+	case ModeMessage::CMD_MODE_ANNOUNCE:
+		owner->announceMode(false);
+		break;
+	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
+		owner->announceMode(true);
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
+	setParentQueue(parentQueueId);
+	return initialize();
+}
+
+void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
+	forced = false;
+	sendModeReplyMessage(ownerMode, ownerSubmode);
+	sendModeInfoMessage(ownerMode, ownerSubmode);
+	theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
+}
+
+void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
+	CommandMessage reply;
+	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
+	{
+		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
+		{
+			ModeMessage::setModeMessage(&reply,
+					ModeMessage::REPLY_WRONG_MODE_REPLY, ownerMode,
+					ownerSubmode);
+		}
+		else
+		{
+			ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY,
+					ownerMode, ownerSubmode);
+		}
+		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
+		        owner->getCommandQueue());
+	}
+}
+
+void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
+	CommandMessage reply;
+	if (theOneWhoCommandedAMode != parentQueueId
+			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
+	{
+		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
+				ownerMode, ownerSubmode);
+		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
+		        owner->getCommandQueue());
+	}
+}
+
+void ModeHelper::startTimer(uint32_t timeoutMs) {
+	countdown.setTimeout(timeoutMs);
+}
+
+void ModeHelper::setParentQueue(MessageQueueId_t parentQueueId) {
+	this->parentQueueId = parentQueueId;
+}
+
+ReturnValue_t ModeHelper::initialize(void) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+bool ModeHelper::isTimedOut() {
+	return countdown.hasTimedOut();
+}
+
+bool ModeHelper::isForced() {
+	return forced;
+}
+
+void ModeHelper::setForced(bool forced) {
+	this->forced = forced;
+}
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index b7f5868d2..1e51bce5e 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -1,53 +1,53 @@
-#ifndef MODEHELPER_H_
-#define MODEHELPER_H_
-
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/modes/ModeMessage.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/timemanager/Countdown.h>
-
-class HasModesIF;
-
-class ModeHelper {
-public:
-	MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
-	Mode_t commandedMode;
-	Submode_t commandedSubmode;
-
-	ModeHelper(HasModesIF *owner);
-	virtual ~ModeHelper();
-
-	ReturnValue_t handleModeCommand(CommandMessage *message);
-
-	/**
-	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
-	 */
-	void setParentQueue(MessageQueueId_t parentQueueId);
-
-	ReturnValue_t initialize(MessageQueueId_t parentQueueId);
-
-	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
-
-	void modeChanged(Mode_t mode, Submode_t submode);
-
-	void startTimer(uint32_t timeoutMs);
-
-	bool isTimedOut();
-
-	bool isForced();
-
-	void setForced(bool forced);
-protected:
-	HasModesIF *owner;
-	MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
-
-	Countdown countdown;
-
-	bool forced;
-private:
-	void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
-	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
-};
-
-#endif /* MODEHELPER_H_ */
+#ifndef MODEHELPER_H_
+#define MODEHELPER_H_
+
+#include "../ipc/MessageQueueIF.h"
+#include "../modes/ModeMessage.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Countdown.h"
+
+class HasModesIF;
+
+class ModeHelper {
+public:
+	MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
+	Mode_t commandedMode;
+	Submode_t commandedSubmode;
+
+	ModeHelper(HasModesIF *owner);
+	virtual ~ModeHelper();
+
+	ReturnValue_t handleModeCommand(CommandMessage *message);
+
+	/**
+	 *
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 */
+	void setParentQueue(MessageQueueId_t parentQueueId);
+
+	ReturnValue_t initialize(MessageQueueId_t parentQueueId);
+
+	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
+
+	void modeChanged(Mode_t mode, Submode_t submode);
+
+	void startTimer(uint32_t timeoutMs);
+
+	bool isTimedOut();
+
+	bool isForced();
+
+	void setForced(bool forced);
+protected:
+	HasModesIF *owner;
+	MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
+
+	Countdown countdown;
+
+	bool forced;
+private:
+	void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
+	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
+};
+
+#endif /* MODEHELPER_H_ */
diff --git a/modes/ModeMessage.cpp b/modes/ModeMessage.cpp
index 1d3baad54..de3fc69c9 100644
--- a/modes/ModeMessage.cpp
+++ b/modes/ModeMessage.cpp
@@ -1,31 +1,31 @@
-#include <framework/modes/ModeMessage.h>
-
-Mode_t ModeMessage::getMode(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-Submode_t ModeMessage::getSubmode(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t command,
-		Mode_t mode, Submode_t submode) {
-	message->setCommand( command );
-	message->setParameter( mode );
-	message->setParameter2( submode );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-void ModeMessage::clear(CommandMessage* message) {
-	message->setCommand(CommandMessage::CMD_NONE);
-}
-
-void ModeMessage::cantReachMode(CommandMessage* message, ReturnValue_t reason) {
-	message->setCommand(REPLY_CANT_REACH_MODE);
-	message->setParameter(reason);
-	message->setParameter2(0);
-}
+#include "../modes/ModeMessage.h"
+
+Mode_t ModeMessage::getMode(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+Submode_t ModeMessage::getSubmode(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t command,
+		Mode_t mode, Submode_t submode) {
+	message->setCommand( command );
+	message->setParameter( mode );
+	message->setParameter2( submode );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+void ModeMessage::clear(CommandMessage* message) {
+	message->setCommand(CommandMessage::CMD_NONE);
+}
+
+void ModeMessage::cantReachMode(CommandMessage* message, ReturnValue_t reason) {
+	message->setCommand(REPLY_CANT_REACH_MODE);
+	message->setParameter(reason);
+	message->setParameter2(0);
+}
diff --git a/modes/ModeMessage.h b/modes/ModeMessage.h
index 675c614b2..63624b1df 100644
--- a/modes/ModeMessage.h
+++ b/modes/ModeMessage.h
@@ -1,40 +1,40 @@
-/**
- * @file	ModeMessage.h
- * @brief	This file defines the ModeMessage class.
- * @date	17.07.2013
- * @author	baetz
- */
-
-#ifndef MODEMESSAGE_H_
-#define MODEMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-
-typedef uint32_t Mode_t;
-typedef uint8_t Submode_t;
-
-class ModeMessage {
-private:
-	ModeMessage();
-public:
-	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
-	static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);	//!> Unrequested info about the current mode (used for composites to inform their container of a changed mode)
-	static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04); //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
-	static const Command_t REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);//!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded and a transition started but was aborted; the parameters contain the mode that was reached
-	static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);//!> Command to read the current mode and reply with a REPLY_MODE_REPLY
-	static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);//!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
-	static const Command_t CMD_MODE_ANNOUNCE_RECURSIVELY = MAKE_COMMAND_ID(0x08);//!> Command to trigger an ModeInfo Event and to send this command to every child. This command does NOT have a reply.
-
-	static Mode_t getMode(const CommandMessage* message);
-	static Submode_t getSubmode(const CommandMessage* message);
-	static ReturnValue_t setModeMessage(CommandMessage* message,
-			Command_t command, Mode_t mode, Submode_t submode);
-	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
-	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
-	static void clear(CommandMessage* message);
-};
-
-#endif /* MODEMESSAGE_H_ */
+/**
+ * @file	ModeMessage.h
+ * @brief	This file defines the ModeMessage class.
+ * @date	17.07.2013
+ * @author	baetz
+ */
+
+#ifndef MODEMESSAGE_H_
+#define MODEMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+
+typedef uint32_t Mode_t;
+typedef uint8_t Submode_t;
+
+class ModeMessage {
+private:
+	ModeMessage();
+public:
+	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
+	static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);	//!> Unrequested info about the current mode (used for composites to inform their container of a changed mode)
+	static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04); //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
+	static const Command_t REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);//!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded and a transition started but was aborted; the parameters contain the mode that was reached
+	static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);//!> Command to read the current mode and reply with a REPLY_MODE_REPLY
+	static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);//!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
+	static const Command_t CMD_MODE_ANNOUNCE_RECURSIVELY = MAKE_COMMAND_ID(0x08);//!> Command to trigger an ModeInfo Event and to send this command to every child. This command does NOT have a reply.
+
+	static Mode_t getMode(const CommandMessage* message);
+	static Submode_t getSubmode(const CommandMessage* message);
+	static ReturnValue_t setModeMessage(CommandMessage* message,
+			Command_t command, Mode_t mode, Submode_t submode);
+	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
+	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
+	static void clear(CommandMessage* message);
+};
+
+#endif /* MODEMESSAGE_H_ */
diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index 3525ba2c7..6b546bd02 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -1,73 +1,73 @@
-#ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
-
-#include <framework/monitoring/MonitorBase.h>
-#include <cmath>
-
-template<typename T>
-class AbsLimitMonitor: public MonitorBase<T> {
-public:
-	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
-			uint16_t confirmationLimit, T limit, Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE, bool aboveIsViolation = true) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), limit(limit), violationEvent(violationEvent), aboveIsViolation(aboveIsViolation) {
-	}
-	virtual ~AbsLimitMonitor() {
-	}
-	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
-		*crossedLimit = limit;
-		if (aboveIsViolation) {
-			if ((std::abs(sample) > limit)) {
-				return MonitoringIF::OUT_OF_RANGE;
-			}
-		} else {
-			if ((std::abs(sample) < limit)) {
-				return MonitoringIF::OUT_OF_RANGE;
-			}
-		}
-		return HasReturnvaluesIF::RETURN_OK; //We're not out of range.
-	}
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
-				parameterId, parameterWrapper, newValues, startAtIndex);
-		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
-			return result;
-		}
-		switch (parameterId) {
-		case 10:
-			parameterWrapper->set(this->limit);
-			break;
-		default:
-			return this->INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	bool isOutOfLimits() {
-		if (this->oldState == MonitoringIF::OUT_OF_RANGE) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	void setLimit(T value) {
-		limit = value;
-	}
-protected:
-	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
-		switch (state) {
-		case MonitoringIF::OUT_OF_RANGE:
-			EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->parameterId);
-			break;
-		default:
-			break;
-		}
-	}
-	T limit;
-	const Event violationEvent;
-	const bool aboveIsViolation;
-};
-
-#endif /* FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
+#define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
+
+#include "../monitoring/MonitorBase.h"
+#include <cmath>
+
+template<typename T>
+class AbsLimitMonitor: public MonitorBase<T> {
+public:
+	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
+			uint16_t confirmationLimit, T limit, Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE, bool aboveIsViolation = true) :
+			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), limit(limit), violationEvent(violationEvent), aboveIsViolation(aboveIsViolation) {
+	}
+	virtual ~AbsLimitMonitor() {
+	}
+	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
+		*crossedLimit = limit;
+		if (aboveIsViolation) {
+			if ((std::abs(sample) > limit)) {
+				return MonitoringIF::OUT_OF_RANGE;
+			}
+		} else {
+			if ((std::abs(sample) < limit)) {
+				return MonitoringIF::OUT_OF_RANGE;
+			}
+		}
+		return HasReturnvaluesIF::RETURN_OK; //We're not out of range.
+	}
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
+				parameterId, parameterWrapper, newValues, startAtIndex);
+		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
+		if (result != this->INVALID_MATRIX_ID) {
+			return result;
+		}
+		switch (parameterId) {
+		case 10:
+			parameterWrapper->set(this->limit);
+			break;
+		default:
+			return this->INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	bool isOutOfLimits() {
+		if (this->oldState == MonitoringIF::OUT_OF_RANGE) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	void setLimit(T value) {
+		limit = value;
+	}
+protected:
+	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+		switch (state) {
+		case MonitoringIF::OUT_OF_RANGE:
+			EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->parameterId);
+			break;
+		default:
+			break;
+		}
+	}
+	T limit;
+	const Event violationEvent;
+	const bool aboveIsViolation;
+};
+
+#endif /* FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ */
diff --git a/monitoring/HasMonitorsIF.h b/monitoring/HasMonitorsIF.h
index 6f1dc1b3e..be561efd8 100644
--- a/monitoring/HasMonitorsIF.h
+++ b/monitoring/HasMonitorsIF.h
@@ -1,30 +1,30 @@
-/**
- * @file	HasMonitorsIF.h
- * @brief	This file defines the HasMonitorsIF class.
- * @date	28.07.2014
- * @author	baetz
- */
-#ifndef HASMONITORSIF_H_
-#define HASMONITORSIF_H_
-
-#include <framework/events/EventReportingProxyIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class HasMonitorsIF {
-public:
-	static const uint8_t MAX_N_PARAMETER = 10;
-//	static const uint8_t MAX_N_LIMIT_ID = 10;
-	virtual ReturnValue_t setCheckingOfParameters(uint8_t checkingStrategy,
-			bool forOnePid = false, uint32_t parameterId = 0) = 0;
-	virtual ReturnValue_t modifyParameterMonitor(uint8_t limitType,
-			uint32_t parameterId, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t modifyObjectMonitor(uint32_t objectId,
-			const uint8_t* data, const uint32_t size) = 0;
-	virtual void setAllMonitorsToUnchecked() = 0;
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ~HasMonitorsIF() {
-	}
-};
-
-#endif /* HASMONITORSIF_H_ */
+/**
+ * @file	HasMonitorsIF.h
+ * @brief	This file defines the HasMonitorsIF class.
+ * @date	28.07.2014
+ * @author	baetz
+ */
+#ifndef HASMONITORSIF_H_
+#define HASMONITORSIF_H_
+
+#include "../events/EventReportingProxyIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class HasMonitorsIF {
+public:
+	static const uint8_t MAX_N_PARAMETER = 10;
+//	static const uint8_t MAX_N_LIMIT_ID = 10;
+	virtual ReturnValue_t setCheckingOfParameters(uint8_t checkingStrategy,
+			bool forOnePid = false, uint32_t parameterId = 0) = 0;
+	virtual ReturnValue_t modifyParameterMonitor(uint8_t limitType,
+			uint32_t parameterId, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t modifyObjectMonitor(uint32_t objectId,
+			const uint8_t* data, const uint32_t size) = 0;
+	virtual void setAllMonitorsToUnchecked() = 0;
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ~HasMonitorsIF() {
+	}
+};
+
+#endif /* HASMONITORSIF_H_ */
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index c24629a35..465d72e83 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -1,95 +1,95 @@
-#ifndef FRAMEWORK_MONITORING_LIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_LIMITMONITOR_H_
-
-#include <framework/monitoring/MonitorBase.h>
-
-/**
- * Variant of a limit checking class.
- * Newer version as compared to LimitCheckMonitor.
- * Functionality is more or less the same, but does not use
- * heavy weight MonitoringIF.
- */
-template<typename T>
-class LimitMonitor: public MonitorBase<T> {
-public:
-	LimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
-			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
-			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
-			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit),
-			lowerLimit(lowerLimit), upperLimit(upperLimit), belowLowEvent(belowLowEvent),
-			aboveHighEvent(aboveHighEvent) {
-	}
-
-	virtual ~LimitMonitor() {}
-
-	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
-		*crossedLimit = 0.0;
-		if (sample > upperLimit) {
-			*crossedLimit = upperLimit;
-			return MonitoringIF::ABOVE_HIGH_LIMIT;
-		} else if (sample < lowerLimit) {
-			*crossedLimit = lowerLimit;
-			return MonitoringIF::BELOW_LOW_LIMIT;
-		} else {
-			return HasReturnvaluesIF::RETURN_OK; //Within limits.
-		}
-	}
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
-				parameterId, parameterWrapper, newValues, startAtIndex);
-		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
-			return result;
-		}
-		switch (parameterId) {
-		case 10:
-			parameterWrapper->set(this->lowerLimit);
-			break;
-		case 11:
-			parameterWrapper->set(this->upperLimit);
-			break;
-		default:
-			return this->INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	bool isOutOfLimits() {
-		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT || this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	T getLowerLimit() const {
-		return lowerLimit;
-	}
-
-	T getUpperLimit() const {
-		return upperLimit;
-	}
-
-protected:
-	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
-		switch (state) {
-		case MonitoringIF::BELOW_LOW_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent, this->parameterId);
-			break;
-		case MonitoringIF::ABOVE_HIGH_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent, this->parameterId);
-			break;
-		default:
-			break;
-		}
-	}
-	T lowerLimit;
-	T upperLimit;
-	const Event belowLowEvent;
-	const Event aboveHighEvent;
-};
-
-#endif /* FRAMEWORK_MONITORING_LIMITMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_LIMITMONITOR_H_
+#define FRAMEWORK_MONITORING_LIMITMONITOR_H_
+
+#include "../monitoring/MonitorBase.h"
+
+/**
+ * Variant of a limit checking class.
+ * Newer version as compared to LimitCheckMonitor.
+ * Functionality is more or less the same, but does not use
+ * heavy weight MonitoringIF.
+ */
+template<typename T>
+class LimitMonitor: public MonitorBase<T> {
+public:
+	LimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
+			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
+			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
+			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
+			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit),
+			lowerLimit(lowerLimit), upperLimit(upperLimit), belowLowEvent(belowLowEvent),
+			aboveHighEvent(aboveHighEvent) {
+	}
+
+	virtual ~LimitMonitor() {}
+
+	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
+		*crossedLimit = 0.0;
+		if (sample > upperLimit) {
+			*crossedLimit = upperLimit;
+			return MonitoringIF::ABOVE_HIGH_LIMIT;
+		} else if (sample < lowerLimit) {
+			*crossedLimit = lowerLimit;
+			return MonitoringIF::BELOW_LOW_LIMIT;
+		} else {
+			return HasReturnvaluesIF::RETURN_OK; //Within limits.
+		}
+	}
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
+				parameterId, parameterWrapper, newValues, startAtIndex);
+		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
+		if (result != this->INVALID_MATRIX_ID) {
+			return result;
+		}
+		switch (parameterId) {
+		case 10:
+			parameterWrapper->set(this->lowerLimit);
+			break;
+		case 11:
+			parameterWrapper->set(this->upperLimit);
+			break;
+		default:
+			return this->INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	bool isOutOfLimits() {
+		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT || this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	T getLowerLimit() const {
+		return lowerLimit;
+	}
+
+	T getUpperLimit() const {
+		return upperLimit;
+	}
+
+protected:
+	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+		switch (state) {
+		case MonitoringIF::BELOW_LOW_LIMIT:
+			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent, this->parameterId);
+			break;
+		case MonitoringIF::ABOVE_HIGH_LIMIT:
+			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent, this->parameterId);
+			break;
+		default:
+			break;
+		}
+	}
+	T lowerLimit;
+	T upperLimit;
+	const Event belowLowEvent;
+	const Event aboveHighEvent;
+};
+
+#endif /* FRAMEWORK_MONITORING_LIMITMONITOR_H_ */
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 489a8f9e9..7869dc2ba 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -1,60 +1,60 @@
-/**
- * @file	LimitViolationReporter.cpp
- * @brief	This file defines the LimitViolationReporter class.
- * @date	17.07.2014
- * @author	baetz
- */
-#include <framework/monitoring/LimitViolationReporter.h>
-#include <framework/monitoring/MonitoringIF.h>
-#include <framework/monitoring/ReceivesMonitoringReportsIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF* data) {
-	ReturnValue_t result = checkClassLoaded();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	store_address_t storeId;
-	uint8_t* dataTarget = NULL;
-	size_t maxSize = data->getSerializedSize();
-	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
-		return MonitoringIF::INVALID_SIZE;
-	}
-	result = ipcStore->getFreeElement(&storeId, maxSize,
-			&dataTarget);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	size_t size = 0;
-	result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	CommandMessage report;
-	MonitoringMessage::setLimitViolationReport(&report, storeId);
-	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
-}
-
-ReturnValue_t LimitViolationReporter::checkClassLoaded() {
-	if (reportQueue == 0) {
-		ReceivesMonitoringReportsIF* receiver = objectManager->get<
-				ReceivesMonitoringReportsIF>(reportingTarget);
-		if (receiver == NULL) {
-			return ObjectManagerIF::NOT_FOUND;
-		}
-		reportQueue = receiver->getCommandQueue();
-	}
-	if (ipcStore == NULL) {
-		ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//Lazy initialization.
-MessageQueueId_t LimitViolationReporter::reportQueue = 0;
-StorageManagerIF* LimitViolationReporter::ipcStore = NULL;
-object_id_t LimitViolationReporter::reportingTarget = 0;
+/**
+ * @file	LimitViolationReporter.cpp
+ * @brief	This file defines the LimitViolationReporter class.
+ * @date	17.07.2014
+ * @author	baetz
+ */
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/ReceivesMonitoringReportsIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerializeAdapter.h"
+
+ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF* data) {
+	ReturnValue_t result = checkClassLoaded();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	store_address_t storeId;
+	uint8_t* dataTarget = NULL;
+	size_t maxSize = data->getSerializedSize();
+	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
+		return MonitoringIF::INVALID_SIZE;
+	}
+	result = ipcStore->getFreeElement(&storeId, maxSize,
+			&dataTarget);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	size_t size = 0;
+	result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	CommandMessage report;
+	MonitoringMessage::setLimitViolationReport(&report, storeId);
+	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
+}
+
+ReturnValue_t LimitViolationReporter::checkClassLoaded() {
+	if (reportQueue == 0) {
+		ReceivesMonitoringReportsIF* receiver = objectManager->get<
+				ReceivesMonitoringReportsIF>(reportingTarget);
+		if (receiver == NULL) {
+			return ObjectManagerIF::NOT_FOUND;
+		}
+		reportQueue = receiver->getCommandQueue();
+	}
+	if (ipcStore == NULL) {
+		ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+//Lazy initialization.
+MessageQueueId_t LimitViolationReporter::reportQueue = 0;
+StorageManagerIF* LimitViolationReporter::ipcStore = NULL;
+object_id_t LimitViolationReporter::reportingTarget = 0;
diff --git a/monitoring/LimitViolationReporter.h b/monitoring/LimitViolationReporter.h
index 3a9d04ddc..53d67b9d4 100644
--- a/monitoring/LimitViolationReporter.h
+++ b/monitoring/LimitViolationReporter.h
@@ -1,31 +1,31 @@
-/**
- * @file	LimitViolationReporter.h
- * @brief	This file defines the LimitViolationReporter class.
- * @date	17.07.2014
- * @author	baetz
- */
-#ifndef LIMITVIOLATIONREPORTER_H_
-#define LIMITVIOLATIONREPORTER_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-class LimitViolationReporter {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	static ReturnValue_t sendLimitViolationReport(const SerializeIF* data);
-private:
-	static object_id_t reportingTarget;
-	static MessageQueueId_t reportQueue;
-	static StorageManagerIF* ipcStore;
-	static ReturnValue_t checkClassLoaded();
-	LimitViolationReporter();
-};
-
-#endif /* LIMITVIOLATIONREPORTER_H_ */
+/**
+ * @file	LimitViolationReporter.h
+ * @brief	This file defines the LimitViolationReporter class.
+ * @date	17.07.2014
+ * @author	baetz
+ */
+#ifndef LIMITVIOLATIONREPORTER_H_
+#define LIMITVIOLATIONREPORTER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+class LimitViolationReporter {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	static ReturnValue_t sendLimitViolationReport(const SerializeIF* data);
+private:
+	static object_id_t reportingTarget;
+	static MessageQueueId_t reportQueue;
+	static StorageManagerIF* ipcStore;
+	static ReturnValue_t checkClassLoaded();
+	LimitViolationReporter();
+};
+
+#endif /* LIMITVIOLATIONREPORTER_H_ */
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index f18ca4b5c..45fe22ec0 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,62 +1,62 @@
-#ifndef MONITORBASE_H_
-#define MONITORBASE_H_
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/PIDReader.h>
-#include <framework/monitoring/LimitViolationReporter.h>
-#include <framework/monitoring/MonitoringIF.h>
-#include <framework/monitoring/MonitoringMessageContent.h>
-#include <framework/monitoring/MonitorReporter.h>
-
-/**
- * Base class for monitoring of parameters.
- * Can be used anywhere, specializations need to implement checkSample and should override sendTransitionEvent.
- * Manages state handling, enabling and disabling of events/reports and forwarding of transition
- * reports via MonitorReporter. In addition, it provides default implementations for fetching the parameter sample from
- * the data pool and a simple confirmation counter.
- */
-template<typename T>
-class MonitorBase: public MonitorReporter<T> {
-public:
-	MonitorBase(object_id_t reporterId, uint8_t monitorId,
-			uint32_t parameterId, uint16_t confirmationLimit) :
-			MonitorReporter<T>(reporterId, monitorId, parameterId, confirmationLimit) {
-	}
-	virtual ~MonitorBase() {
-	}
-	virtual ReturnValue_t check() {
-		//1. Fetch sample of type T, return validity.
-		T sample = 0;
-		ReturnValue_t validity = fetchSample(&sample);
-
-		//2. If returning from fetch != OK, parameter is invalid. Report (if oldState is != invalidity).
-		if (validity != HasReturnvaluesIF::RETURN_OK) {
-			this->monitorStateIs(validity, sample, 0);
-			//3. Otherwise, check sample.
-		} else {
-			this->oldState = doCheck(sample);
-		}
-		return this->oldState;
-	}
-	virtual ReturnValue_t doCheck(T sample) {
-		T crossedLimit = 0.0;
-		ReturnValue_t currentState = checkSample(sample, &crossedLimit);
-		return this->monitorStateIs(currentState,sample, crossedLimit);
-	}
-	//Abstract or default.
-	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
-
-protected:
-	virtual ReturnValue_t fetchSample(T* sample) {
-		GlobDataSet mySet;
-		PIDReader<T> parameter(this->parameterId, &mySet);
-		mySet.read();
-		if (!parameter.isValid()) {
-			return MonitoringIF::INVALID;
-		}
-		*sample = parameter.value;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-#endif /* MONITORBASE_H_ */
+#ifndef MONITORBASE_H_
+#define MONITORBASE_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../monitoring/MonitorReporter.h"
+
+/**
+ * Base class for monitoring of parameters.
+ * Can be used anywhere, specializations need to implement checkSample and should override sendTransitionEvent.
+ * Manages state handling, enabling and disabling of events/reports and forwarding of transition
+ * reports via MonitorReporter. In addition, it provides default implementations for fetching the parameter sample from
+ * the data pool and a simple confirmation counter.
+ */
+template<typename T>
+class MonitorBase: public MonitorReporter<T> {
+public:
+	MonitorBase(object_id_t reporterId, uint8_t monitorId,
+			uint32_t parameterId, uint16_t confirmationLimit) :
+			MonitorReporter<T>(reporterId, monitorId, parameterId, confirmationLimit) {
+	}
+	virtual ~MonitorBase() {
+	}
+	virtual ReturnValue_t check() {
+		//1. Fetch sample of type T, return validity.
+		T sample = 0;
+		ReturnValue_t validity = fetchSample(&sample);
+
+		//2. If returning from fetch != OK, parameter is invalid. Report (if oldState is != invalidity).
+		if (validity != HasReturnvaluesIF::RETURN_OK) {
+			this->monitorStateIs(validity, sample, 0);
+			//3. Otherwise, check sample.
+		} else {
+			this->oldState = doCheck(sample);
+		}
+		return this->oldState;
+	}
+	virtual ReturnValue_t doCheck(T sample) {
+		T crossedLimit = 0.0;
+		ReturnValue_t currentState = checkSample(sample, &crossedLimit);
+		return this->monitorStateIs(currentState,sample, crossedLimit);
+	}
+	//Abstract or default.
+	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
+
+protected:
+	virtual ReturnValue_t fetchSample(T* sample) {
+		GlobDataSet mySet;
+		PIDReader<T> parameter(this->parameterId, &mySet);
+		mySet.read();
+		if (!parameter.isValid()) {
+			return MonitoringIF::INVALID;
+		}
+		*sample = parameter.value;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+#endif /* MONITORBASE_H_ */
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 6274313f6..69bb00eaa 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -1,178 +1,178 @@
-#ifndef FRAMEWORK_MONITORING_MONITORREPORTER_H_
-#define FRAMEWORK_MONITORING_MONITORREPORTER_H_
-
-#include <framework/events/EventManagerIF.h>
-#include <framework/monitoring/LimitViolationReporter.h>
-#include <framework/monitoring/MonitoringIF.h>
-#include <framework/monitoring/MonitoringMessageContent.h>
-#include <framework/parameters/HasParametersIF.h>
-
-template<typename T>
-class MonitorReporter: public HasParametersIF {
-public:
-
-	static const uint8_t ENABLED = 1;
-	static const uint8_t DISABLED = 0;
-
-	MonitorReporter(object_id_t reportingId, uint8_t monitorId, uint32_t parameterId, uint16_t confirmationLimit) :
-			monitorId(monitorId), parameterId(parameterId), reportingId(
-					reportingId), oldState(MonitoringIF::UNCHECKED), reportingEnabled(
-			ENABLED), eventEnabled(ENABLED), currentCounter(0), confirmationLimit(
-					confirmationLimit) {
-	}
-
-	virtual ~MonitorReporter() {
-	}
-
-	ReturnValue_t monitorStateIs(ReturnValue_t state, T parameterValue = 0,
-			T crossedLimit = 0) {
-		if (state != oldState) {
-			if (isConfirmed(state)) {
-				if (eventEnabled == ENABLED) {
-					sendTransitionEvent(parameterValue, state);
-				}
-				if (reportingEnabled == ENABLED) {
-					sendTransitionReport(parameterValue, crossedLimit, state);
-				}
-				oldState = state;
-			} else {
-				//This is to ensure confirmation works.
-				//Needs to be reset to be able to confirm against oldState again next time.
-				return oldState;
-			}
-		} else {
-			resetConfirmation();
-		}
-		return state;
-	}
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		if (domainId != monitorId) {
-			return INVALID_DOMAIN_ID;
-		}
-		switch (parameterId) {
-		case 0:
-			parameterWrapper->set(this->confirmationLimit);
-			break;
-		case 1:
-			parameterWrapper->set(this->reportingEnabled);
-			break;
-		case 2:
-			parameterWrapper->set(this->eventEnabled);
-			break;
-		default:
-			return INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t setToUnchecked() {
-		return setToState(MonitoringIF::UNCHECKED);
-	}
-	virtual ReturnValue_t setToInvalid() {
-		return setToState(MonitoringIF::INVALID);
-	}
-	object_id_t getReporterId() const {
-		return reportingId;
-	}
-
-	void setEventEnabled(uint8_t eventEnabled) {
-		this->eventEnabled = eventEnabled;
-	}
-
-	void setReportingEnabled(uint8_t reportingEnabled) {
-		this->reportingEnabled = reportingEnabled;
-	}
-
-	bool isEventEnabled() const {
-		return (eventEnabled == ENABLED);
-	}
-
-protected:
-	const uint8_t monitorId;
-	const uint32_t parameterId;
-	object_id_t reportingId;
-	ReturnValue_t oldState;
-
-	uint8_t reportingEnabled;
-
-	uint8_t eventEnabled;
-
-	uint16_t currentCounter;
-	uint16_t confirmationLimit;
-
-	bool isConfirmed(ReturnValue_t state) {
-		//Confirm INVALID and UNCHECKED immediately.
-		if (state == MonitoringIF::INVALID
-				|| state == MonitoringIF::UNCHECKED) {
-			currentCounter = 0;
-			return true;
-		}
-		return doesChildConfirm(state);
-	}
-
-	/**
-	 * This is the most simple form of confirmation.
-	 * A counter counts any violation and compares the number to maxCounter.
-	 * @param state The state, indicating the type of violation. Not used here.
-	 * @return true if counter > maxCounter, else false.
-	 */
-	virtual bool doesChildConfirm(ReturnValue_t state) {
-		currentCounter += 1;
-		if (currentCounter > confirmationLimit) {
-			currentCounter = 0;
-			return true;
-		} else {
-			return false;
-		}
-	}
-	/**
-	 * This method needs to reset the confirmation in case a valid sample was found.
-	 * Here, simply resets the current counter.
-	 */
-	virtual void resetConfirmation() {
-		currentCounter = 0;
-	}
-	/**
-	 * Default version of sending transitional events.
-	 * Should be overridden from specialized monitors.
-	 * @param currentValue The current value which was monitored.
-	 * @param state The state the monitor changed to.
-	 */
-	virtual void sendTransitionEvent(T currentValue, ReturnValue_t state) {
-		switch(state) {
-		case MonitoringIF::UNCHECKED:
-		case MonitoringIF::UNSELECTED:
-		case MonitoringIF::INVALID:
-		case HasReturnvaluesIF::RETURN_OK:
-			break;
-		default:
-			EventManagerIF::triggerEvent(reportingId, MonitoringIF::MONITOR_CHANGED_STATE, state);
-			break;
-		}
-	}
-	/**
-	 * Default implementation for sending transition report.
-	 * May be overridden, but is seldom necessary.
-	 * @param parameterValue Current value of the parameter
-	 * @param crossedLimit The limit crossed (if applicable).
-	 * @param state Current state the monitor is in.
-	 */
-	virtual void sendTransitionReport(T parameterValue, T crossedLimit, ReturnValue_t state) {
-		MonitoringReportContent<T> report(parameterId,
-				parameterValue, crossedLimit, oldState, state);
-		LimitViolationReporter::sendLimitViolationReport(&report);
-	}
-	ReturnValue_t setToState(ReturnValue_t state) {
-		if (oldState != state && reportingEnabled) {
-			MonitoringReportContent<T> report(parameterId, 0, 0, oldState,
-					state);
-			LimitViolationReporter::sendLimitViolationReport(&report);
-			oldState = state;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-#endif /* FRAMEWORK_MONITORING_MONITORREPORTER_H_ */
+#ifndef FRAMEWORK_MONITORING_MONITORREPORTER_H_
+#define FRAMEWORK_MONITORING_MONITORREPORTER_H_
+
+#include "../events/EventManagerIF.h"
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../parameters/HasParametersIF.h"
+
+template<typename T>
+class MonitorReporter: public HasParametersIF {
+public:
+
+	static const uint8_t ENABLED = 1;
+	static const uint8_t DISABLED = 0;
+
+	MonitorReporter(object_id_t reportingId, uint8_t monitorId, uint32_t parameterId, uint16_t confirmationLimit) :
+			monitorId(monitorId), parameterId(parameterId), reportingId(
+					reportingId), oldState(MonitoringIF::UNCHECKED), reportingEnabled(
+			ENABLED), eventEnabled(ENABLED), currentCounter(0), confirmationLimit(
+					confirmationLimit) {
+	}
+
+	virtual ~MonitorReporter() {
+	}
+
+	ReturnValue_t monitorStateIs(ReturnValue_t state, T parameterValue = 0,
+			T crossedLimit = 0) {
+		if (state != oldState) {
+			if (isConfirmed(state)) {
+				if (eventEnabled == ENABLED) {
+					sendTransitionEvent(parameterValue, state);
+				}
+				if (reportingEnabled == ENABLED) {
+					sendTransitionReport(parameterValue, crossedLimit, state);
+				}
+				oldState = state;
+			} else {
+				//This is to ensure confirmation works.
+				//Needs to be reset to be able to confirm against oldState again next time.
+				return oldState;
+			}
+		} else {
+			resetConfirmation();
+		}
+		return state;
+	}
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		if (domainId != monitorId) {
+			return INVALID_DOMAIN_ID;
+		}
+		switch (parameterId) {
+		case 0:
+			parameterWrapper->set(this->confirmationLimit);
+			break;
+		case 1:
+			parameterWrapper->set(this->reportingEnabled);
+			break;
+		case 2:
+			parameterWrapper->set(this->eventEnabled);
+			break;
+		default:
+			return INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t setToUnchecked() {
+		return setToState(MonitoringIF::UNCHECKED);
+	}
+	virtual ReturnValue_t setToInvalid() {
+		return setToState(MonitoringIF::INVALID);
+	}
+	object_id_t getReporterId() const {
+		return reportingId;
+	}
+
+	void setEventEnabled(uint8_t eventEnabled) {
+		this->eventEnabled = eventEnabled;
+	}
+
+	void setReportingEnabled(uint8_t reportingEnabled) {
+		this->reportingEnabled = reportingEnabled;
+	}
+
+	bool isEventEnabled() const {
+		return (eventEnabled == ENABLED);
+	}
+
+protected:
+	const uint8_t monitorId;
+	const uint32_t parameterId;
+	object_id_t reportingId;
+	ReturnValue_t oldState;
+
+	uint8_t reportingEnabled;
+
+	uint8_t eventEnabled;
+
+	uint16_t currentCounter;
+	uint16_t confirmationLimit;
+
+	bool isConfirmed(ReturnValue_t state) {
+		//Confirm INVALID and UNCHECKED immediately.
+		if (state == MonitoringIF::INVALID
+				|| state == MonitoringIF::UNCHECKED) {
+			currentCounter = 0;
+			return true;
+		}
+		return doesChildConfirm(state);
+	}
+
+	/**
+	 * This is the most simple form of confirmation.
+	 * A counter counts any violation and compares the number to maxCounter.
+	 * @param state The state, indicating the type of violation. Not used here.
+	 * @return true if counter > maxCounter, else false.
+	 */
+	virtual bool doesChildConfirm(ReturnValue_t state) {
+		currentCounter += 1;
+		if (currentCounter > confirmationLimit) {
+			currentCounter = 0;
+			return true;
+		} else {
+			return false;
+		}
+	}
+	/**
+	 * This method needs to reset the confirmation in case a valid sample was found.
+	 * Here, simply resets the current counter.
+	 */
+	virtual void resetConfirmation() {
+		currentCounter = 0;
+	}
+	/**
+	 * Default version of sending transitional events.
+	 * Should be overridden from specialized monitors.
+	 * @param currentValue The current value which was monitored.
+	 * @param state The state the monitor changed to.
+	 */
+	virtual void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+		switch(state) {
+		case MonitoringIF::UNCHECKED:
+		case MonitoringIF::UNSELECTED:
+		case MonitoringIF::INVALID:
+		case HasReturnvaluesIF::RETURN_OK:
+			break;
+		default:
+			EventManagerIF::triggerEvent(reportingId, MonitoringIF::MONITOR_CHANGED_STATE, state);
+			break;
+		}
+	}
+	/**
+	 * Default implementation for sending transition report.
+	 * May be overridden, but is seldom necessary.
+	 * @param parameterValue Current value of the parameter
+	 * @param crossedLimit The limit crossed (if applicable).
+	 * @param state Current state the monitor is in.
+	 */
+	virtual void sendTransitionReport(T parameterValue, T crossedLimit, ReturnValue_t state) {
+		MonitoringReportContent<T> report(parameterId,
+				parameterValue, crossedLimit, oldState, state);
+		LimitViolationReporter::sendLimitViolationReport(&report);
+	}
+	ReturnValue_t setToState(ReturnValue_t state) {
+		if (oldState != state && reportingEnabled) {
+			MonitoringReportContent<T> report(parameterId, 0, 0, oldState,
+					state);
+			LimitViolationReporter::sendLimitViolationReport(&report);
+			oldState = state;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+#endif /* FRAMEWORK_MONITORING_MONITORREPORTER_H_ */
diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h
index d2d62f351..a4c0666cb 100644
--- a/monitoring/MonitoringIF.h
+++ b/monitoring/MonitoringIF.h
@@ -1,67 +1,67 @@
-#ifndef MONITORINGIF_H_
-#define MONITORINGIF_H_
-
-#include <framework/memory/HasMemoryIF.h>
-#include <framework/monitoring/MonitoringMessage.h>
-#include <framework/serialize/SerializeIF.h>
-
-class MonitoringIF : public SerializeIF {
-public:
-	static const uint8_t VIOLATION_REPORT_MAX_SIZE = 32;
-	static const uint8_t LIMIT_TYPE_NO_TYPE = 0xFF;
-	static const uint8_t LIMIT_TYPE_LIMIT_CHECK = 0;
-	static const uint8_t LIMIT_TYPE_DELTA_CHECK = 1;
-	static const uint8_t LIMIT_TYPE_ABSOLUTE_CHECK = 2;
-	static const uint8_t LIMIT_TYPE_OBJECT = 128;
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_2;
-	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, SEVERITY::LOW);
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::LIMITS_IF;
-	static const ReturnValue_t UNCHECKED = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t UNSELECTED = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t BELOW_LOW_LIMIT = MAKE_RETURN_CODE(4);
-//	static const ReturnValue_t CHECKING_STATUS_BELOW_LOW_THRESHOLD = MAKE_RETURN_CODE(4);
-//	static const ReturnValue_t CHECKING_STATUS_ABOVE_HIGH_THRESHOLD = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t ABOVE_HIGH_LIMIT = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t UNEXPECTED_VALUE = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t OUT_OF_RANGE = MAKE_RETURN_CODE(7);
-
-
-	static const ReturnValue_t FIRST_SAMPLE = MAKE_RETURN_CODE(0xA0);
-	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t WRONG_TYPE = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t WRONG_PID = MAKE_RETURN_CODE(0xE2);
-	static const ReturnValue_t WRONG_LIMIT_ID = MAKE_RETURN_CODE(0xE3);
-	static const ReturnValue_t MONITOR_NOT_FOUND = MAKE_RETURN_CODE(0xEE);
-
-	static const uint8_t REPORT_NONE = 0;
-	static const uint8_t REPORT_EVENTS_ONLY = 1;
-	static const uint8_t REPORT_REPORTS_ONLY = 2;
-	static const uint8_t REPORT_ALL = 3;
-
-//	static const ReturnValue_t STILL_IN_LOW_WARNING = MAKE_RETURN_CODE(0x11);
-//	static const ReturnValue_t STILL_IN_LOW_LIMIT = MAKE_RETURN_CODE(0x12);
-//	static const ReturnValue_t STILL_IN_HIGH_WARNING = MAKE_RETURN_CODE(0x13);
-//	static const ReturnValue_t STILL_IN_HIGH_LIMIT = MAKE_RETURN_CODE(0x14);
-//	static const ReturnValue_t VARIABLE_IS_INVALID = MAKE_RETURN_CODE(0xE0);
-//	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE1);
-//	static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xE2);
-	virtual ReturnValue_t check() = 0;
-	virtual ReturnValue_t setLimits( uint8_t type, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t setChecking(uint8_t strategy) = 0;
-	virtual ReturnValue_t setToUnchecked() = 0;
-	virtual uint8_t getLimitType() const = 0;
-	virtual uint32_t getLimitId() const = 0;
-//	virtual ReturnValue_t setEventReporting(bool active) = 0;
-	virtual ~MonitoringIF() {
-	}
-};
-
-
-
-#endif /* MONITORINGIF_H_ */
+#ifndef MONITORINGIF_H_
+#define MONITORINGIF_H_
+
+#include "../memory/HasMemoryIF.h"
+#include "../monitoring/MonitoringMessage.h"
+#include "../serialize/SerializeIF.h"
+
+class MonitoringIF : public SerializeIF {
+public:
+	static const uint8_t VIOLATION_REPORT_MAX_SIZE = 32;
+	static const uint8_t LIMIT_TYPE_NO_TYPE = 0xFF;
+	static const uint8_t LIMIT_TYPE_LIMIT_CHECK = 0;
+	static const uint8_t LIMIT_TYPE_DELTA_CHECK = 1;
+	static const uint8_t LIMIT_TYPE_ABSOLUTE_CHECK = 2;
+	static const uint8_t LIMIT_TYPE_OBJECT = 128;
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_2;
+	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, SEVERITY::LOW);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::LIMITS_IF;
+	static const ReturnValue_t UNCHECKED = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t UNSELECTED = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BELOW_LOW_LIMIT = MAKE_RETURN_CODE(4);
+//	static const ReturnValue_t CHECKING_STATUS_BELOW_LOW_THRESHOLD = MAKE_RETURN_CODE(4);
+//	static const ReturnValue_t CHECKING_STATUS_ABOVE_HIGH_THRESHOLD = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t ABOVE_HIGH_LIMIT = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t UNEXPECTED_VALUE = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t OUT_OF_RANGE = MAKE_RETURN_CODE(7);
+
+
+	static const ReturnValue_t FIRST_SAMPLE = MAKE_RETURN_CODE(0xA0);
+	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t WRONG_TYPE = MAKE_RETURN_CODE(0xE1);
+	static const ReturnValue_t WRONG_PID = MAKE_RETURN_CODE(0xE2);
+	static const ReturnValue_t WRONG_LIMIT_ID = MAKE_RETURN_CODE(0xE3);
+	static const ReturnValue_t MONITOR_NOT_FOUND = MAKE_RETURN_CODE(0xEE);
+
+	static const uint8_t REPORT_NONE = 0;
+	static const uint8_t REPORT_EVENTS_ONLY = 1;
+	static const uint8_t REPORT_REPORTS_ONLY = 2;
+	static const uint8_t REPORT_ALL = 3;
+
+//	static const ReturnValue_t STILL_IN_LOW_WARNING = MAKE_RETURN_CODE(0x11);
+//	static const ReturnValue_t STILL_IN_LOW_LIMIT = MAKE_RETURN_CODE(0x12);
+//	static const ReturnValue_t STILL_IN_HIGH_WARNING = MAKE_RETURN_CODE(0x13);
+//	static const ReturnValue_t STILL_IN_HIGH_LIMIT = MAKE_RETURN_CODE(0x14);
+//	static const ReturnValue_t VARIABLE_IS_INVALID = MAKE_RETURN_CODE(0xE0);
+//	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE1);
+//	static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xE2);
+	virtual ReturnValue_t check() = 0;
+	virtual ReturnValue_t setLimits( uint8_t type, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t setChecking(uint8_t strategy) = 0;
+	virtual ReturnValue_t setToUnchecked() = 0;
+	virtual uint8_t getLimitType() const = 0;
+	virtual uint32_t getLimitId() const = 0;
+//	virtual ReturnValue_t setEventReporting(bool active) = 0;
+	virtual ~MonitoringIF() {
+	}
+};
+
+
+
+#endif /* MONITORINGIF_H_ */
diff --git a/monitoring/MonitoringMessage.cpp b/monitoring/MonitoringMessage.cpp
index 77919bfe8..9edf16d5b 100644
--- a/monitoring/MonitoringMessage.cpp
+++ b/monitoring/MonitoringMessage.cpp
@@ -1,38 +1,38 @@
-#include <framework/monitoring/MonitoringMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-MonitoringMessage::~MonitoringMessage() {
-}
-
-void MonitoringMessage::setLimitViolationReport(CommandMessage* message,
-		store_address_t storeId) {
-	setTypicalMessage(message, LIMIT_VIOLATION_REPORT, storeId);
-}
-
-void MonitoringMessage::setTypicalMessage(CommandMessage* message,
-		Command_t type, store_address_t storeId) {
-	message->setCommand(type);
-	message->setParameter2(storeId.raw);
-}
-
-store_address_t MonitoringMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-void MonitoringMessage::clear(CommandMessage* message) {
-	message->setCommand(CommandMessage::CMD_NONE);
-	switch (message->getCommand()) {
-	case MonitoringMessage::LIMIT_VIOLATION_REPORT: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-}
+#include "../monitoring/MonitoringMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+MonitoringMessage::~MonitoringMessage() {
+}
+
+void MonitoringMessage::setLimitViolationReport(CommandMessage* message,
+		store_address_t storeId) {
+	setTypicalMessage(message, LIMIT_VIOLATION_REPORT, storeId);
+}
+
+void MonitoringMessage::setTypicalMessage(CommandMessage* message,
+		Command_t type, store_address_t storeId) {
+	message->setCommand(type);
+	message->setParameter2(storeId.raw);
+}
+
+store_address_t MonitoringMessage::getStoreId(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+void MonitoringMessage::clear(CommandMessage* message) {
+	message->setCommand(CommandMessage::CMD_NONE);
+	switch (message->getCommand()) {
+	case MonitoringMessage::LIMIT_VIOLATION_REPORT: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(message));
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
diff --git a/monitoring/MonitoringMessage.h b/monitoring/MonitoringMessage.h
index 793e1fbf3..55d3ea5c2 100644
--- a/monitoring/MonitoringMessage.h
+++ b/monitoring/MonitoringMessage.h
@@ -1,21 +1,21 @@
-#ifndef MONITORINGMESSAGE_H_
-#define MONITORINGMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-
-class MonitoringMessage: public CommandMessage {
-public:
-	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();
-	static void setLimitViolationReport(CommandMessage* message, store_address_t storeId);
-	static void clear(CommandMessage* message);
-	static store_address_t getStoreId(const CommandMessage* message);
-	static void setTypicalMessage(CommandMessage* message, Command_t type, store_address_t storeId);
-
-};
-
-
-#endif /* MONITORINGMESSAGE_H_ */
+#ifndef MONITORINGMESSAGE_H_
+#define MONITORINGMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+class MonitoringMessage: public CommandMessage {
+public:
+	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();
+	static void setLimitViolationReport(CommandMessage* message, store_address_t storeId);
+	static void clear(CommandMessage* message);
+	static store_address_t getStoreId(const CommandMessage* message);
+	static void setTypicalMessage(CommandMessage* message, Command_t type, store_address_t storeId);
+
+};
+
+
+#endif /* MONITORINGMESSAGE_H_ */
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index 7e1aca626..a0934c14c 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -1,77 +1,77 @@
-#ifndef MONITORINGMESSAGECONTENT_H_
-#define MONITORINGMESSAGECONTENT_H_
-
-#include <framework/monitoring/HasMonitorsIF.h>
-#include <framework/monitoring/MonitoringIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serialize/SerialBufferAdapter.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/timemanager/TimeStamperIF.h>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-//PID(uint32_t), TYPE, LIMIT_ID, value,limitValue, previous, later, timestamp
-template<typename T>
-class MonitoringReportContent: public SerialLinkedListAdapter<SerializeIF> {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	SerializeElement<uint8_t> monitorId;
-	SerializeElement<uint32_t> parameterId;
-	SerializeElement<T> parameterValue;
-	SerializeElement<T> limitValue;
-	SerializeElement<ReturnValue_t> oldState;
-	SerializeElement<ReturnValue_t> newState;
-	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
-	SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
-	TimeStamperIF* timeStamper;
-	MonitoringReportContent() :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					0), parameterValue(0), limitValue(0), oldState(0), newState(
-					0), rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
-					sizeof(rawTimestamp)), timeStamper(NULL) {
-		setAllNext();
-	}
-	MonitoringReportContent(uint32_t setPID, T value, T limitValue,
-			ReturnValue_t oldState, ReturnValue_t newState) :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					setPID), parameterValue(value), limitValue(limitValue), oldState(
-					oldState), newState(newState), timestampSerializer(rawTimestamp,
-							sizeof(rawTimestamp)), timeStamper(NULL) {
-		setAllNext();
-		if (checkAndSetStamper()) {
-			timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
-		}
-	}
-private:
-
-	static object_id_t timeStamperId;
-	void setAllNext() {
-		parameterId.setNext(&parameterValue);
-		parameterValue.setNext(&limitValue);
-		limitValue.setNext(&oldState);
-		oldState.setNext(&newState);
-		newState.setNext(&timestampSerializer);
-	}
-	bool checkAndSetStamper() {
-		if (timeStamper == NULL) {
-			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
-			if ( timeStamper == NULL ) {
-				sif::error << "MonitoringReportContent::checkAndSetStamper: "
-				        "Stamper not found!" << std::endl;
-				return false;
-			}
-		}
-		return true;
-	}
-};
-template<typename T>
-object_id_t MonitoringReportContent<T>::timeStamperId = 0;
-
-#endif /* MONITORINGMESSAGECONTENT_H_ */
+#ifndef MONITORINGMESSAGECONTENT_H_
+#define MONITORINGMESSAGECONTENT_H_
+
+#include "../monitoring/HasMonitorsIF.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../timemanager/TimeStamperIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+//PID(uint32_t), TYPE, LIMIT_ID, value,limitValue, previous, later, timestamp
+template<typename T>
+class MonitoringReportContent: public SerialLinkedListAdapter<SerializeIF> {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	SerializeElement<uint8_t> monitorId;
+	SerializeElement<uint32_t> parameterId;
+	SerializeElement<T> parameterValue;
+	SerializeElement<T> limitValue;
+	SerializeElement<ReturnValue_t> oldState;
+	SerializeElement<ReturnValue_t> newState;
+	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+	SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
+	TimeStamperIF* timeStamper;
+	MonitoringReportContent() :
+			SerialLinkedListAdapter<SerializeIF>(
+					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
+					0), parameterValue(0), limitValue(0), oldState(0), newState(
+					0), rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
+					sizeof(rawTimestamp)), timeStamper(NULL) {
+		setAllNext();
+	}
+	MonitoringReportContent(uint32_t setPID, T value, T limitValue,
+			ReturnValue_t oldState, ReturnValue_t newState) :
+			SerialLinkedListAdapter<SerializeIF>(
+					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
+					setPID), parameterValue(value), limitValue(limitValue), oldState(
+					oldState), newState(newState), timestampSerializer(rawTimestamp,
+							sizeof(rawTimestamp)), timeStamper(NULL) {
+		setAllNext();
+		if (checkAndSetStamper()) {
+			timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
+		}
+	}
+private:
+
+	static object_id_t timeStamperId;
+	void setAllNext() {
+		parameterId.setNext(&parameterValue);
+		parameterValue.setNext(&limitValue);
+		limitValue.setNext(&oldState);
+		oldState.setNext(&newState);
+		newState.setNext(&timestampSerializer);
+	}
+	bool checkAndSetStamper() {
+		if (timeStamper == NULL) {
+			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
+			if ( timeStamper == NULL ) {
+				sif::error << "MonitoringReportContent::checkAndSetStamper: "
+				        "Stamper not found!" << std::endl;
+				return false;
+			}
+		}
+		return true;
+	}
+};
+template<typename T>
+object_id_t MonitoringReportContent<T>::timeStamperId = 0;
+
+#endif /* MONITORINGMESSAGECONTENT_H_ */
diff --git a/monitoring/ReceivesMonitoringReportsIF.h b/monitoring/ReceivesMonitoringReportsIF.h
index 42c365c16..16595f33c 100644
--- a/monitoring/ReceivesMonitoringReportsIF.h
+++ b/monitoring/ReceivesMonitoringReportsIF.h
@@ -1,15 +1,15 @@
-#ifndef RECEIVESMONITORINGREPORTSIF_H_
-#define RECEIVESMONITORINGREPORTSIF_H_
-
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class ReceivesMonitoringReportsIF {
-public:
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ~ReceivesMonitoringReportsIF() {
-	}
-};
-
-
-
-#endif /* RECEIVESMONITORINGREPORTSIF_H_ */
+#ifndef RECEIVESMONITORINGREPORTSIF_H_
+#define RECEIVESMONITORINGREPORTSIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+class ReceivesMonitoringReportsIF {
+public:
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ~ReceivesMonitoringReportsIF() {
+	}
+};
+
+
+
+#endif /* RECEIVESMONITORINGREPORTSIF_H_ */
diff --git a/monitoring/TriplexMonitor.h b/monitoring/TriplexMonitor.h
index 9a2e69c3b..6f190361d 100644
--- a/monitoring/TriplexMonitor.h
+++ b/monitoring/TriplexMonitor.h
@@ -1,155 +1,155 @@
-#ifndef FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
-#define FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
-
-#include <framework/datapool/DataSet.h>
-#include <framework/datapool/PIDReaderList.h>
-#include <framework/health/HealthTableIF.h>
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-
-//SHOULDDO: This is by far not perfect. Could be merged with new Monitor classes. But still, it's over-engineering.
-template<typename T>
-class TriplexMonitor : public HasParametersIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TRIPLE_REDUNDACY_CHECK;
-	static const ReturnValue_t NOT_ENOUGH_SENSORS = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LOWEST_VALUE_OOL = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t HIGHEST_VALUE_OOL = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t BOTH_VALUES_OOL = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t DUPLEX_OOL = MAKE_RETURN_CODE(5);
-
-	static const uint8_t THREE = 3;
-
-	TriplexMonitor(const uint32_t parameterIds[3], uint8_t domainId, const T initialLimit,
-			Event eventTripleCheck, Event eventDualCheck) :
-			values(parameterIds, &dataSet), limit(initialLimit), eventTripleCheck(
-					eventTripleCheck), eventDualCheck(eventDualCheck), healthTable(
-					NULL), domainId(domainId) {
-
-	}
-	virtual ~TriplexMonitor() {
-	}
-	ReturnValue_t check() {
-		dataSet.read();
-		//check health and validity
-		uint8_t availableIndex[2] = { 0, 0 };
-		bool first = true;
-		uint8_t nAvailable = 0;
-		for (uint8_t count = 0; count < THREE; count++) {
-			if (values[count].isValid() && checkObjectHealthState(count)) {
-				if (first) {
-					availableIndex[0] = count;
-					first = false;
-				} else {
-					//Might be filled twice, but then it's not needed anyway.
-					availableIndex[1] = count;
-				}
-				nAvailable++;
-			}
-		}
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-		switch (nAvailable) {
-		case 3:
-			result = doTriplexMonitoring();
-			break;
-		case 2:
-			result = doDuplexMonitoring(availableIndex);
-			break;
-		default:
-			result = NOT_ENOUGH_SENSORS;
-			break;
-		}
-		dataSet.commit();
-		return result;
-	}
-	ReturnValue_t initialize() {
-		healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
-		if (healthTable == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		if (domainId != this->domainId) {
-			return INVALID_DOMAIN_ID;
-		}
-		switch (parameterId) {
-		case 0:
-			parameterWrapper->set(limit);
-			break;
-		default:
-			return INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-protected:
-	DataSet dataSet;
-	PIDReaderList<T, THREE> values;
-	T limit;
-	Event eventTripleCheck;
-	Event eventDualCheck;
-	HealthTableIF* healthTable;
-	uint8_t domainId;
-	ReturnValue_t doTriplexMonitoring() {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		//Find middle value, by ordering indices
-		uint8_t index[3] = { 0, 1, 2 };
-		if (values[index[0]].value > values[index[1]].value) {
-			std::swap(index[0], index[1]);
-		}
-		if (values[index[0]].value > values[index[2]].value) {
-			std::swap(index[0], index[2]);
-		}
-		if (values[index[1]].value > values[index[2]].value) {
-			std::swap(index[1], index[2]);
-		}
-		//Test if smallest value is out-of-limit.
-		if (values[index[0]] < (values[index[1]] - limit)) {
-			EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
-					eventTripleCheck, LOWEST_VALUE_OOL, 0);
-			result = LOWEST_VALUE_OOL;
-		}
-		//Test if largest value is out-of-limit.
-		if (values[index[2]] > (values[index[1]] + limit)) {
-			EventManagerIF::triggerEvent(getRefereneceObject(index[2]),
-					eventTripleCheck, HIGHEST_VALUE_OOL, 0);
-			if (result == HasReturnvaluesIF::RETURN_OK) {
-				result = HIGHEST_VALUE_OOL;
-			} else {
-				result = BOTH_VALUES_OOL;
-			}
-		}
-		return result;
-	}
-
-	ReturnValue_t doDuplexMonitoring(uint8_t index[2]) {
-		T mean = (values[index[0]] + values[index[1]]) / 2;
-		if (values[index[0]] > values[index[1]]) {
-			if (values[index[0]] > (mean + limit)) {
-				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
-						eventDualCheck, 0, 0);
-				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
-						eventDualCheck, 0, 0);
-				return DUPLEX_OOL;
-			}
-		} else {
-			if (values[index[1]] > (mean + limit)) {
-				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
-						eventDualCheck, 0, 0);
-				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
-						eventDualCheck, 0, 0);
-				return DUPLEX_OOL;
-			}
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual bool checkObjectHealthState(uint8_t valueIndex) = 0;
-	virtual object_id_t getRefereneceObject(uint8_t valueIndex) = 0;
-};
-
-#endif /* FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
+#define FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
+
+#include "../datapool/DataSet.h"
+#include "../datapool/PIDReaderList.h"
+#include "../health/HealthTableIF.h"
+#include "../parameters/HasParametersIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+
+//SHOULDDO: This is by far not perfect. Could be merged with new Monitor classes. But still, it's over-engineering.
+template<typename T>
+class TriplexMonitor : public HasParametersIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TRIPLE_REDUNDACY_CHECK;
+	static const ReturnValue_t NOT_ENOUGH_SENSORS = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LOWEST_VALUE_OOL = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t HIGHEST_VALUE_OOL = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BOTH_VALUES_OOL = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t DUPLEX_OOL = MAKE_RETURN_CODE(5);
+
+	static const uint8_t THREE = 3;
+
+	TriplexMonitor(const uint32_t parameterIds[3], uint8_t domainId, const T initialLimit,
+			Event eventTripleCheck, Event eventDualCheck) :
+			values(parameterIds, &dataSet), limit(initialLimit), eventTripleCheck(
+					eventTripleCheck), eventDualCheck(eventDualCheck), healthTable(
+					NULL), domainId(domainId) {
+
+	}
+	virtual ~TriplexMonitor() {
+	}
+	ReturnValue_t check() {
+		dataSet.read();
+		//check health and validity
+		uint8_t availableIndex[2] = { 0, 0 };
+		bool first = true;
+		uint8_t nAvailable = 0;
+		for (uint8_t count = 0; count < THREE; count++) {
+			if (values[count].isValid() && checkObjectHealthState(count)) {
+				if (first) {
+					availableIndex[0] = count;
+					first = false;
+				} else {
+					//Might be filled twice, but then it's not needed anyway.
+					availableIndex[1] = count;
+				}
+				nAvailable++;
+			}
+		}
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+		switch (nAvailable) {
+		case 3:
+			result = doTriplexMonitoring();
+			break;
+		case 2:
+			result = doDuplexMonitoring(availableIndex);
+			break;
+		default:
+			result = NOT_ENOUGH_SENSORS;
+			break;
+		}
+		dataSet.commit();
+		return result;
+	}
+	ReturnValue_t initialize() {
+		healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
+		if (healthTable == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+				ParameterWrapper *parameterWrapper,
+				const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		if (domainId != this->domainId) {
+			return INVALID_DOMAIN_ID;
+		}
+		switch (parameterId) {
+		case 0:
+			parameterWrapper->set(limit);
+			break;
+		default:
+			return INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+protected:
+	DataSet dataSet;
+	PIDReaderList<T, THREE> values;
+	T limit;
+	Event eventTripleCheck;
+	Event eventDualCheck;
+	HealthTableIF* healthTable;
+	uint8_t domainId;
+	ReturnValue_t doTriplexMonitoring() {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		//Find middle value, by ordering indices
+		uint8_t index[3] = { 0, 1, 2 };
+		if (values[index[0]].value > values[index[1]].value) {
+			std::swap(index[0], index[1]);
+		}
+		if (values[index[0]].value > values[index[2]].value) {
+			std::swap(index[0], index[2]);
+		}
+		if (values[index[1]].value > values[index[2]].value) {
+			std::swap(index[1], index[2]);
+		}
+		//Test if smallest value is out-of-limit.
+		if (values[index[0]] < (values[index[1]] - limit)) {
+			EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
+					eventTripleCheck, LOWEST_VALUE_OOL, 0);
+			result = LOWEST_VALUE_OOL;
+		}
+		//Test if largest value is out-of-limit.
+		if (values[index[2]] > (values[index[1]] + limit)) {
+			EventManagerIF::triggerEvent(getRefereneceObject(index[2]),
+					eventTripleCheck, HIGHEST_VALUE_OOL, 0);
+			if (result == HasReturnvaluesIF::RETURN_OK) {
+				result = HIGHEST_VALUE_OOL;
+			} else {
+				result = BOTH_VALUES_OOL;
+			}
+		}
+		return result;
+	}
+
+	ReturnValue_t doDuplexMonitoring(uint8_t index[2]) {
+		T mean = (values[index[0]] + values[index[1]]) / 2;
+		if (values[index[0]] > values[index[1]]) {
+			if (values[index[0]] > (mean + limit)) {
+				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
+						eventDualCheck, 0, 0);
+				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
+						eventDualCheck, 0, 0);
+				return DUPLEX_OOL;
+			}
+		} else {
+			if (values[index[1]] > (mean + limit)) {
+				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
+						eventDualCheck, 0, 0);
+				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
+						eventDualCheck, 0, 0);
+				return DUPLEX_OOL;
+			}
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual bool checkObjectHealthState(uint8_t valueIndex) = 0;
+	virtual object_id_t getRefereneceObject(uint8_t valueIndex) = 0;
+};
+
+#endif /* FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_ */
diff --git a/monitoring/TwoValueLimitMonitor.h b/monitoring/TwoValueLimitMonitor.h
index c17ad4337..ac0ef1ee3 100644
--- a/monitoring/TwoValueLimitMonitor.h
+++ b/monitoring/TwoValueLimitMonitor.h
@@ -1,44 +1,44 @@
-#ifndef FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
-
-#include <framework/monitoring/LimitMonitor.h>
-
-template<typename T>
-class TwoValueLimitMonitor: public LimitMonitor<T> {
-public:
-	TwoValueLimitMonitor(object_id_t reporterId, uint8_t monitorId,
-			uint32_t lowParameterId, uint32_t highParameterId,
-			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
-			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
-			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			LimitMonitor<T>(reporterId, monitorId, lowParameterId,
-					confirmationLimit, lowerLimit, upperLimit, belowLowEvent,
-					aboveHighEvent), highValueParameterId(highParameterId) {
-	}
-	virtual ~TwoValueLimitMonitor() {
-	}
-	ReturnValue_t doCheck(T lowSample, T highSample) {
-		T crossedLimit;
-		ReturnValue_t currentState = this->checkSample(lowSample, &crossedLimit);
-		if (currentState != HasReturnvaluesIF::RETURN_OK) {
-			return this->monitorStateIs(currentState, lowSample, crossedLimit);
-		}
-		currentState = this->checkSample(highSample, &crossedLimit);
-		return this->monitorStateIs(currentState, highSample, crossedLimit);
-	}
-protected:
-	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
-			ReturnValue_t state) {
-		uint32_t usedParameterId = this->parameterId;
-		if (state == MonitoringIF::ABOVE_HIGH_LIMIT) {
-			usedParameterId = this->highValueParameterId;
-		}
-		MonitoringReportContent<T> report(usedParameterId, parameterValue,
-				crossedLimit, this->oldState, state);
-		LimitViolationReporter::sendLimitViolationReport(&report);
-	}
-private:
-	const uint32_t highValueParameterId;
-};
-
-#endif /* FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
+#define FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
+
+#include "../monitoring/LimitMonitor.h"
+
+template<typename T>
+class TwoValueLimitMonitor: public LimitMonitor<T> {
+public:
+	TwoValueLimitMonitor(object_id_t reporterId, uint8_t monitorId,
+			uint32_t lowParameterId, uint32_t highParameterId,
+			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
+			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
+			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
+			LimitMonitor<T>(reporterId, monitorId, lowParameterId,
+					confirmationLimit, lowerLimit, upperLimit, belowLowEvent,
+					aboveHighEvent), highValueParameterId(highParameterId) {
+	}
+	virtual ~TwoValueLimitMonitor() {
+	}
+	ReturnValue_t doCheck(T lowSample, T highSample) {
+		T crossedLimit;
+		ReturnValue_t currentState = this->checkSample(lowSample, &crossedLimit);
+		if (currentState != HasReturnvaluesIF::RETURN_OK) {
+			return this->monitorStateIs(currentState, lowSample, crossedLimit);
+		}
+		currentState = this->checkSample(highSample, &crossedLimit);
+		return this->monitorStateIs(currentState, highSample, crossedLimit);
+	}
+protected:
+	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
+			ReturnValue_t state) {
+		uint32_t usedParameterId = this->parameterId;
+		if (state == MonitoringIF::ABOVE_HIGH_LIMIT) {
+			usedParameterId = this->highValueParameterId;
+		}
+		MonitoringReportContent<T> report(usedParameterId, parameterValue,
+				crossedLimit, this->oldState, state);
+		LimitViolationReporter::sendLimitViolationReport(&report);
+	}
+private:
+	const uint32_t highValueParameterId;
+};
+
+#endif /* FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_ */
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 1c54355a3..13d67559e 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,108 +1,108 @@
-#include <framework/objectmanager/ObjectManager.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <iomanip>
-#include <cstdlib>
-
-ObjectManager::ObjectManager( void (*setProducer)() ):
-		produceObjects(setProducer) {
-	//There's nothing special to do in the constructor.
-}
-
-
-ObjectManager::~ObjectManager() {
-	for (auto const& iter : objectList) {
-		delete iter.second;
-	}
-}
-
-ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
-	auto returnPair = objectList.emplace(id, object);
-	if (returnPair.second) {
-	    // sif::debug << "ObjectManager::insert: Object " << std::hex
-	    //            << (int)id << std::dec << " inserted." << std::endl;
-		return this->RETURN_OK;
-	} else {
-		sif::error << "ObjectManager::insert: Object id " << std::hex
-		           << (int)id << std::dec << " is already in use!" << std::endl;
-		sif::error << "Terminating program." << std::endl;
-		//This is very severe and difficult to handle in other places.
-		std::exit(INSERTION_FAILED);
-	}
-}
-
-ReturnValue_t ObjectManager::remove( object_id_t id ) {
-	if ( this->getSystemObject(id) != NULL ) {
-		this->objectList.erase( id );
-		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
-		//           << (int)id << std::dec << " removed." << std::endl;
-		return RETURN_OK;
-	} else {
-		sif::error << "ObjectManager::removeObject: Requested object "
-		        << std::hex << (int)id << std::dec << " not found." << std::endl;
-		return NOT_FOUND;
-	}
-}
-
-
-
-SystemObjectIF* ObjectManager::getSystemObject( object_id_t id ) {
-	auto listIter = this->objectList.find( id );
-	if (listIter == this->objectList.end() ) {
-		return nullptr;
-	} else {
-		return listIter->second;
-	}
-}
-
-ObjectManager::ObjectManager() : produceObjects(nullptr) {
-
-}
-
-void ObjectManager::initialize() {
-	if(produceObjects == nullptr) {
-		sif::error << "ObjectManager::initialize: Passed produceObjects "
-				"functions is nullptr!" << std::endl;
-		return;
-	}
-	this->produceObjects();
-	ReturnValue_t result = RETURN_FAILED;
-	uint32_t errorCount = 0;
-	for (auto const& it : objectList) {
-		result = it.second->initialize();
-		if ( result != RETURN_OK ) {
-			object_id_t var = it.first;
-			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
-					std::setw(8) << std::setfill('0')<< var << " failed to "
-					"initialize with code 0x" << result << std::dec <<
-					std::setfill(' ') << std::endl;
-			errorCount++;
-		}
-	}
-	if (errorCount > 0) {
-		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
-		           << " failed initializations." << std::endl;
-	}
-	//Init was successful. Now check successful interconnections.
-	errorCount = 0;
-	for (auto const& it : objectList) {
-		result = it.second->checkObjectConnections();
-		if ( result != RETURN_OK ) {
-			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
-					(int) it.first  << " connection check failed with code 0x"
-					<< result << std::dec << std::endl;
-			errorCount++;
-		}
-	}
-	if (errorCount > 0) {
-		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
-		           << " failed connection checks." << std::endl;
-	}
-}
-
-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;
-	}
-}
+#include "../objectmanager/ObjectManager.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <iomanip>
+#include <cstdlib>
+
+ObjectManager::ObjectManager( void (*setProducer)() ):
+		produceObjects(setProducer) {
+	//There's nothing special to do in the constructor.
+}
+
+
+ObjectManager::~ObjectManager() {
+	for (auto const& iter : objectList) {
+		delete iter.second;
+	}
+}
+
+ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
+	auto returnPair = objectList.emplace(id, object);
+	if (returnPair.second) {
+	    // sif::debug << "ObjectManager::insert: Object " << std::hex
+	    //            << (int)id << std::dec << " inserted." << std::endl;
+		return this->RETURN_OK;
+	} else {
+		sif::error << "ObjectManager::insert: Object id " << std::hex
+		           << (int)id << std::dec << " is already in use!" << std::endl;
+		sif::error << "Terminating program." << std::endl;
+		//This is very severe and difficult to handle in other places.
+		std::exit(INSERTION_FAILED);
+	}
+}
+
+ReturnValue_t ObjectManager::remove( object_id_t id ) {
+	if ( this->getSystemObject(id) != NULL ) {
+		this->objectList.erase( id );
+		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
+		//           << (int)id << std::dec << " removed." << std::endl;
+		return RETURN_OK;
+	} else {
+		sif::error << "ObjectManager::removeObject: Requested object "
+		        << std::hex << (int)id << std::dec << " not found." << std::endl;
+		return NOT_FOUND;
+	}
+}
+
+
+
+SystemObjectIF* ObjectManager::getSystemObject( object_id_t id ) {
+	auto listIter = this->objectList.find( id );
+	if (listIter == this->objectList.end() ) {
+		return nullptr;
+	} else {
+		return listIter->second;
+	}
+}
+
+ObjectManager::ObjectManager() : produceObjects(nullptr) {
+
+}
+
+void ObjectManager::initialize() {
+	if(produceObjects == nullptr) {
+		sif::error << "ObjectManager::initialize: Passed produceObjects "
+				"functions is nullptr!" << std::endl;
+		return;
+	}
+	this->produceObjects();
+	ReturnValue_t result = RETURN_FAILED;
+	uint32_t errorCount = 0;
+	for (auto const& it : objectList) {
+		result = it.second->initialize();
+		if ( result != RETURN_OK ) {
+			object_id_t var = it.first;
+			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
+					std::setw(8) << std::setfill('0')<< var << " failed to "
+					"initialize with code 0x" << result << std::dec <<
+					std::setfill(' ') << std::endl;
+			errorCount++;
+		}
+	}
+	if (errorCount > 0) {
+		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
+		           << " failed initializations." << std::endl;
+	}
+	//Init was successful. Now check successful interconnections.
+	errorCount = 0;
+	for (auto const& it : objectList) {
+		result = it.second->checkObjectConnections();
+		if ( result != RETURN_OK ) {
+			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
+					(int) it.first  << " connection check failed with code 0x"
+					<< result << std::dec << std::endl;
+			errorCount++;
+		}
+	}
+	if (errorCount > 0) {
+		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
+		           << " failed connection checks." << std::endl;
+	}
+}
+
+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;
+	}
+}
diff --git a/objectmanager/ObjectManager.h b/objectmanager/ObjectManager.h
index 634510713..0bc525bed 100644
--- a/objectmanager/ObjectManager.h
+++ b/objectmanager/ObjectManager.h
@@ -1,67 +1,67 @@
-/**
- * @file	ObjectManager.h
- * @brief	This file contains the implementation of the ObjectManager class
- * @date	18.09.2012
- * @author	Bastian Baetz
- */
-
-#ifndef OBJECTMANAGER_H_
-#define OBJECTMANAGER_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <map>
-
-/**
- * @brief	This class implements a global object manager.
- * @details	This manager handles a list of available objects with system-wide
- * 			relevance, such as device handlers, and TM/TC services. Objects can
- * 			be inserted, removed and retrieved from the list. In addition, the
- * 			class holds a so-called factory, that creates and inserts new
- * 			objects if they are not already in the list. This feature automates
- * 			most of the system initialization.
- * 			As the system is static after initialization, no new objects are
- * 			created or inserted into the list after startup.
- * \ingroup system_objects
- */
-class ObjectManager : public ObjectManagerIF {
-private:
-	//comparison?
-	/**
-	 * \brief	This is the map of all initialized objects in the manager.
-	 * \details	Objects in the List must inherit the SystemObjectIF.
-	 */
-	std::map<object_id_t, SystemObjectIF*> objectList;
-protected:
-	SystemObjectIF* getSystemObject( object_id_t id );
-	/**
-	 * @brief	This attribute is initialized with the factory function
-	 * 			that creates new objects.
-	 * @details	The function is called if an object was requested with
-	 * 			getSystemObject, but not found in objectList.
-	 * @param 	The id of the object to be created.
-	 * @return	Returns a pointer to the newly created object or NULL.
-	 */
-	void (*produceObjects)();
-public:
-	/**
-	 * @brief	Apart from setting the producer function, nothing special
-	 * 			happens in the constructor.
-	 * @param setProducer	A pointer to a factory function.
-	 */
-	ObjectManager( void (*produce)() );
-	ObjectManager();
-	/**
-	 *	@brief	In the class's destructor, all objects in the list are deleted.
-	 */
-	//SHOULDDO: If, for some reason, deleting an ObjectManager instance is required, check if this works.
-	virtual ~ObjectManager( void );
-	ReturnValue_t insert( object_id_t id, SystemObjectIF* object );
-	ReturnValue_t remove( object_id_t id );
-	void initialize();
-	void printList();
-};
-
-
-
-#endif /* OBJECTMANAGER_H_ */
+/**
+ * @file	ObjectManager.h
+ * @brief	This file contains the implementation of the ObjectManager class
+ * @date	18.09.2012
+ * @author	Bastian Baetz
+ */
+
+#ifndef OBJECTMANAGER_H_
+#define OBJECTMANAGER_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include <map>
+
+/**
+ * @brief	This class implements a global object manager.
+ * @details	This manager handles a list of available objects with system-wide
+ * 			relevance, such as device handlers, and TM/TC services. Objects can
+ * 			be inserted, removed and retrieved from the list. In addition, the
+ * 			class holds a so-called factory, that creates and inserts new
+ * 			objects if they are not already in the list. This feature automates
+ * 			most of the system initialization.
+ * 			As the system is static after initialization, no new objects are
+ * 			created or inserted into the list after startup.
+ * \ingroup system_objects
+ */
+class ObjectManager : public ObjectManagerIF {
+private:
+	//comparison?
+	/**
+	 * \brief	This is the map of all initialized objects in the manager.
+	 * \details	Objects in the List must inherit the SystemObjectIF.
+	 */
+	std::map<object_id_t, SystemObjectIF*> objectList;
+protected:
+	SystemObjectIF* getSystemObject( object_id_t id );
+	/**
+	 * @brief	This attribute is initialized with the factory function
+	 * 			that creates new objects.
+	 * @details	The function is called if an object was requested with
+	 * 			getSystemObject, but not found in objectList.
+	 * @param 	The id of the object to be created.
+	 * @return	Returns a pointer to the newly created object or NULL.
+	 */
+	void (*produceObjects)();
+public:
+	/**
+	 * @brief	Apart from setting the producer function, nothing special
+	 * 			happens in the constructor.
+	 * @param setProducer	A pointer to a factory function.
+	 */
+	ObjectManager( void (*produce)() );
+	ObjectManager();
+	/**
+	 *	@brief	In the class's destructor, all objects in the list are deleted.
+	 */
+	//SHOULDDO: If, for some reason, deleting an ObjectManager instance is required, check if this works.
+	virtual ~ObjectManager( void );
+	ReturnValue_t insert( object_id_t id, SystemObjectIF* object );
+	ReturnValue_t remove( object_id_t id );
+	void initialize();
+	void printList();
+};
+
+
+
+#endif /* OBJECTMANAGER_H_ */
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 90a1ce3be..5dfe8e4eb 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -1,95 +1,95 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
-#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
-
-#include <framework/objectmanager/frameworkObjects.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-/**
- * @brief	This class provides an interface to the global object manager.
- * @details	This manager handles a list of available objects with system-wide
- * 			relevance, such as device handlers, and TM/TC services. They can be
- * 			inserted, removed and retrieved from the list. On getting the
- * 			object, the call checks if the object implements the requested
- * 			interface.
- * @author	Bastian Baetz
- * @ingroup system_objects
- */
-class ObjectManagerIF : public HasReturnvaluesIF {
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
-	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
-	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
-	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
-	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
-
-protected:
-	/**
-	 * @brief	This method is used to hide the template-based get call from
-	 * 			a specific implementation.
-	 * @details	So, an implementation only has to implement this call.
-	 * @param id	The object id of the requested object.
-	 * @return	The method returns a pointer to an object implementing (at
-	 * 			least) the SystemObjectIF, or NULL.
-	 */
-	virtual  SystemObjectIF* getSystemObject( object_id_t id ) = 0;
-public:
-	/**
-	 * @brief	This is the empty virtual destructor as requested by C++ interfaces.
-	 */
-	virtual ~ObjectManagerIF( void ) {};
-	/**
-	 * @brief	With this call, new objects are inserted to the list.
-	 * @details	The implementation shall return an error code in case the
-	 * 			object can't be added (e.g. the id is already in use).
-	 * @param id		The new id to be added to the list.
-	 * @param object	A pointer to the object to be added.
-	 * @return	@li INSERTION_FAILED in case the object could not be inserted.
-	 * 			@li RETURN_OK in case the object was successfully inserted
-	 */
-	virtual ReturnValue_t insert( object_id_t id, SystemObjectIF* object ) = 0;
-	/**
-	 * @brief	With the get call, interfaces of an object can be retrieved in
-	 * 			a type-safe manner.
-	 * @details With the template-based call, the object list is searched with the
-	 * 			getSystemObject method and afterwards it is checked, if the object
-	 * 			implements the requested interface (with a dynamic_cast).
-	 * @param id	The object id of the requested object.
-	 * @return	The method returns a pointer to an object implementing the
-	 * 			requested interface, or NULL.
-	 */
-	template <typename T> T* get( object_id_t id );
-	/**
-	 * @brief	With this call, an object is removed from the list.
-	 * @param id	The object id of the object to be removed.
-	 * @return	\li NOT_FOUND in case the object was not found
-	 * 			\li RETURN_OK in case the object was successfully removed
-	 */
-	virtual ReturnValue_t remove( object_id_t id ) = 0;
-	virtual void initialize() = 0;
-	/**
-	 * @brief	This is a debug function, that prints the current content of the
-	 * 			object list.
-	 */
-	virtual void printList() = 0;
-};
-
-
-/**
- * @brief	This is the forward declaration of the global objectManager instance.
- */
-extern ObjectManagerIF *objectManager;
-
-/*Documentation can be found in the class method declaration above.*/
-template <typename T>
-T* ObjectManagerIF::get( object_id_t id ) {
-	if(objectManager == nullptr) {
-		sif::error << "ObjectManagerIF: Global object manager has not "
-				"been initialized yet!" << std::endl;
-	}
-	SystemObjectIF* temp = this->getSystemObject(id);
-	return dynamic_cast<T*>(temp);
-}
-
-#endif /* OBJECTMANAGERIF_H_ */
+#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+
+#include "../objectmanager/frameworkObjects.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+/**
+ * @brief	This class provides an interface to the global object manager.
+ * @details	This manager handles a list of available objects with system-wide
+ * 			relevance, such as device handlers, and TM/TC services. They can be
+ * 			inserted, removed and retrieved from the list. On getting the
+ * 			object, the call checks if the object implements the requested
+ * 			interface.
+ * @author	Bastian Baetz
+ * @ingroup system_objects
+ */
+class ObjectManagerIF : public HasReturnvaluesIF {
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
+	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
+	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
+
+protected:
+	/**
+	 * @brief	This method is used to hide the template-based get call from
+	 * 			a specific implementation.
+	 * @details	So, an implementation only has to implement this call.
+	 * @param id	The object id of the requested object.
+	 * @return	The method returns a pointer to an object implementing (at
+	 * 			least) the SystemObjectIF, or NULL.
+	 */
+	virtual  SystemObjectIF* getSystemObject( object_id_t id ) = 0;
+public:
+	/**
+	 * @brief	This is the empty virtual destructor as requested by C++ interfaces.
+	 */
+	virtual ~ObjectManagerIF( void ) {};
+	/**
+	 * @brief	With this call, new objects are inserted to the list.
+	 * @details	The implementation shall return an error code in case the
+	 * 			object can't be added (e.g. the id is already in use).
+	 * @param id		The new id to be added to the list.
+	 * @param object	A pointer to the object to be added.
+	 * @return	@li INSERTION_FAILED in case the object could not be inserted.
+	 * 			@li RETURN_OK in case the object was successfully inserted
+	 */
+	virtual ReturnValue_t insert( object_id_t id, SystemObjectIF* object ) = 0;
+	/**
+	 * @brief	With the get call, interfaces of an object can be retrieved in
+	 * 			a type-safe manner.
+	 * @details With the template-based call, the object list is searched with the
+	 * 			getSystemObject method and afterwards it is checked, if the object
+	 * 			implements the requested interface (with a dynamic_cast).
+	 * @param id	The object id of the requested object.
+	 * @return	The method returns a pointer to an object implementing the
+	 * 			requested interface, or NULL.
+	 */
+	template <typename T> T* get( object_id_t id );
+	/**
+	 * @brief	With this call, an object is removed from the list.
+	 * @param id	The object id of the object to be removed.
+	 * @return	\li NOT_FOUND in case the object was not found
+	 * 			\li RETURN_OK in case the object was successfully removed
+	 */
+	virtual ReturnValue_t remove( object_id_t id ) = 0;
+	virtual void initialize() = 0;
+	/**
+	 * @brief	This is a debug function, that prints the current content of the
+	 * 			object list.
+	 */
+	virtual void printList() = 0;
+};
+
+
+/**
+ * @brief	This is the forward declaration of the global objectManager instance.
+ */
+extern ObjectManagerIF *objectManager;
+
+/*Documentation can be found in the class method declaration above.*/
+template <typename T>
+T* ObjectManagerIF::get( object_id_t id ) {
+	if(objectManager == nullptr) {
+		sif::error << "ObjectManagerIF: Global object manager has not "
+				"been initialized yet!" << std::endl;
+	}
+	SystemObjectIF* temp = this->getSystemObject(id);
+	return dynamic_cast<T*>(temp);
+}
+
+#endif /* OBJECTMANAGERIF_H_ */
diff --git a/objectmanager/SystemObject.cpp b/objectmanager/SystemObject.cpp
index 85daaa358..e3eb22eed 100644
--- a/objectmanager/SystemObject.cpp
+++ b/objectmanager/SystemObject.cpp
@@ -1,37 +1,37 @@
-#include <framework/events/EventManagerIF.h>
-#include <framework/objectmanager/ObjectManager.h>
-#include <framework/objectmanager/SystemObject.h>
-
-SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
-		objectId(setObjectId), registered(doRegister) {
-	if (registered) {
-		objectManager->insert(objectId, this);
-	}
-}
-
-SystemObject::~SystemObject() {
-	if (registered) {
-		objectManager->remove(objectId);
-	}
-}
-
-object_id_t SystemObject::getObjectId() const {
-	return objectId;
-}
-
-void SystemObject::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
-}
-
-ReturnValue_t SystemObject::initialize() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t SystemObject::checkObjectConnections() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void SystemObject::forwardEvent(Event event, uint32_t parameter1, uint32_t parameter2) const {
-	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
-}
+#include "../events/EventManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
+#include "../objectmanager/SystemObject.h"
+
+SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
+		objectId(setObjectId), registered(doRegister) {
+	if (registered) {
+		objectManager->insert(objectId, this);
+	}
+}
+
+SystemObject::~SystemObject() {
+	if (registered) {
+		objectManager->remove(objectId);
+	}
+}
+
+object_id_t SystemObject::getObjectId() const {
+	return objectId;
+}
+
+void SystemObject::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
+}
+
+ReturnValue_t SystemObject::initialize() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SystemObject::checkObjectConnections() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void SystemObject::forwardEvent(Event event, uint32_t parameter1, uint32_t parameter2) const {
+	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
+}
diff --git a/objectmanager/SystemObject.h b/objectmanager/SystemObject.h
index 6a1b35b6f..fa97aab46 100644
--- a/objectmanager/SystemObject.h
+++ b/objectmanager/SystemObject.h
@@ -1,61 +1,61 @@
-/**
- * @file	SystemObject.h
- * @brief	This file contains the definition of the SystemObject class.
- * @date	07.11.2012
- * @author	Ulrich Mohr
- */
-
-#ifndef SYSTEMOBJECT_H_
-#define SYSTEMOBJECT_H_
-
-#include <framework/events/Event.h>
-#include <framework/events/EventReportingProxyIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/timemanager/Clock.h>
-
-/**
- * @brief	This class automates insertion into the ObjectManager and
- * 			management of the object id.
- * @details	This class is more a base class, which shall be inherited by any
- * 			class that is announced to ObjectManager. It automatically includes
- * 			itself (and therefore the inheriting class) in the object manager's
- * 			list.
- * \ingroup system_objects
- */
-class SystemObject: public SystemObjectIF {
-private:
-	/**
-	 * @brief	This is the id the class instant got assigned.
-	 */
-	const object_id_t objectId;
-	const bool registered;
-public:
-
-	/**
-	 * Helper function to send Event Messages to the Event Manager
-	 * @param event
-	 * @param parameter1
-	 * @param parameter2
-	 */
-	virtual void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-
-	/**
-	 * @brief	The class's constructor.
-	 * @details	In the constructor, the object id is set and the class is
-	 * 			inserted in the object manager.
-	 * @param setObjectId	The id the object shall have.
-	 * @param doRegister	Determines if the object is registered in the global object manager.
-	 */
-	SystemObject(object_id_t setObjectId, bool doRegister = true);
-	/**
-	 * @brief	On destruction, the object removes itself from the list.
-	 */
-	virtual ~SystemObject();
-	object_id_t getObjectId() const;
-	virtual ReturnValue_t initialize();
-	virtual ReturnValue_t checkObjectConnections();
-
-	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;
-};
-
-#endif /* SYSTEMOBJECT_H_ */
+/**
+ * @file	SystemObject.h
+ * @brief	This file contains the definition of the SystemObject class.
+ * @date	07.11.2012
+ * @author	Ulrich Mohr
+ */
+
+#ifndef SYSTEMOBJECT_H_
+#define SYSTEMOBJECT_H_
+
+#include "../events/Event.h"
+#include "../events/EventReportingProxyIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../timemanager/Clock.h"
+
+/**
+ * @brief	This class automates insertion into the ObjectManager and
+ * 			management of the object id.
+ * @details	This class is more a base class, which shall be inherited by any
+ * 			class that is announced to ObjectManager. It automatically includes
+ * 			itself (and therefore the inheriting class) in the object manager's
+ * 			list.
+ * \ingroup system_objects
+ */
+class SystemObject: public SystemObjectIF {
+private:
+	/**
+	 * @brief	This is the id the class instant got assigned.
+	 */
+	const object_id_t objectId;
+	const bool registered;
+public:
+
+	/**
+	 * Helper function to send Event Messages to the Event Manager
+	 * @param event
+	 * @param parameter1
+	 * @param parameter2
+	 */
+	virtual void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+
+	/**
+	 * @brief	The class's constructor.
+	 * @details	In the constructor, the object id is set and the class is
+	 * 			inserted in the object manager.
+	 * @param setObjectId	The id the object shall have.
+	 * @param doRegister	Determines if the object is registered in the global object manager.
+	 */
+	SystemObject(object_id_t setObjectId, bool doRegister = true);
+	/**
+	 * @brief	On destruction, the object removes itself from the list.
+	 */
+	virtual ~SystemObject();
+	object_id_t getObjectId() const;
+	virtual ReturnValue_t initialize();
+	virtual ReturnValue_t checkObjectConnections();
+
+	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;
+};
+
+#endif /* SYSTEMOBJECT_H_ */
diff --git a/objectmanager/SystemObjectIF.h b/objectmanager/SystemObjectIF.h
index b75905094..54a2e8668 100644
--- a/objectmanager/SystemObjectIF.h
+++ b/objectmanager/SystemObjectIF.h
@@ -1,62 +1,62 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
-#define FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
-
-#include <framework/events/EventReportingProxyIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstdint>
-/**
- * @defgroup system_objects Software System Object Management
- * The classes to create System Objects and classes to manage these are
- * contained in this group. System Objects are software elements that can be
- * controlled externally. They all have a unique object identifier.
- */
-
-/**
- * This is the typedef for object identifiers.
- * @ingroup system_objects
- */
-typedef uint32_t object_id_t;
-
-/**
- * This interface allows a class to be included in the object manager
- * list.
- * It does not provide any method definitions, still it is required to
- * perform a type check with dynamic_cast.
- * @author  Bastian Baetz
- * @ingroup system_objects
- */
-class SystemObjectIF : public EventReportingProxyIF {
-public:
-	/**
-	 * This is a simple getter to return the object identifier.
-	 * @return	Returns the object id of this object.
-	 */
-	virtual object_id_t getObjectId() const = 0;
-	/**
-	 * The empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~SystemObjectIF() {}
-	/**
-	 * @brief   Initializes the object.
-	 * There are initialization steps which can also be done in the constructor.
-	 * However, there is no clean way to get a returnvalue from a constructor.
-	 * Furthermore some components require other system object to be created
-	 * which might not have been built yet.
-	 * Therefore, a two-step initialization resolves this problem and prevents
-	 * circular dependencies of not-fully initialized objects on start up.
-	 * @return	- @c RETURN_OK in case the initialization was successful
-	 * 			- @c RETURN_FAILED otherwise
-	 */
-	virtual ReturnValue_t initialize() = 0;
-	/**
-	 * @brief   Checks if all object-object interconnections are satisfying
-	 *          for operation.
-	 * Some objects need certain other objects (or a certain number), to be
-	 * registered as children. These checks can be done in this method.
-	 * @return	- @c RETURN_OK in case the check was successful
-	 * 			- @c any other code otherwise
-	 */
-	virtual ReturnValue_t checkObjectConnections() = 0;
-};
-
-#endif /* FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */
+#ifndef FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+#define FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+
+#include "../events/EventReportingProxyIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstdint>
+/**
+ * @defgroup system_objects Software System Object Management
+ * The classes to create System Objects and classes to manage these are
+ * contained in this group. System Objects are software elements that can be
+ * controlled externally. They all have a unique object identifier.
+ */
+
+/**
+ * This is the typedef for object identifiers.
+ * @ingroup system_objects
+ */
+typedef uint32_t object_id_t;
+
+/**
+ * This interface allows a class to be included in the object manager
+ * list.
+ * It does not provide any method definitions, still it is required to
+ * perform a type check with dynamic_cast.
+ * @author  Bastian Baetz
+ * @ingroup system_objects
+ */
+class SystemObjectIF : public EventReportingProxyIF {
+public:
+	/**
+	 * This is a simple getter to return the object identifier.
+	 * @return	Returns the object id of this object.
+	 */
+	virtual object_id_t getObjectId() const = 0;
+	/**
+	 * The empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~SystemObjectIF() {}
+	/**
+	 * @brief   Initializes the object.
+	 * There are initialization steps which can also be done in the constructor.
+	 * However, there is no clean way to get a returnvalue from a constructor.
+	 * Furthermore some components require other system object to be created
+	 * which might not have been built yet.
+	 * Therefore, a two-step initialization resolves this problem and prevents
+	 * circular dependencies of not-fully initialized objects on start up.
+	 * @return	- @c RETURN_OK in case the initialization was successful
+	 * 			- @c RETURN_FAILED otherwise
+	 */
+	virtual ReturnValue_t initialize() = 0;
+	/**
+	 * @brief   Checks if all object-object interconnections are satisfying
+	 *          for operation.
+	 * Some objects need certain other objects (or a certain number), to be
+	 * registered as children. These checks can be done in this method.
+	 * @return	- @c RETURN_OK in case the check was successful
+	 * 			- @c any other code otherwise
+	 */
+	virtual ReturnValue_t checkObjectConnections() = 0;
+};
+
+#endif /* FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index d33518886..71c0aba9b 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -1,91 +1,91 @@
-#include <framework/osal/FreeRTOS/BinSemaphUsingTask.h>
-#include <framework/osal/FreeRTOS/TaskManagement.h>
-#include <framework/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(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::BLOCKING) {
-		timeout = SemaphoreIF::BLOCKING;
-	}
-	else if(timeoutMs > SemaphoreIF::POLLING){
-		timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-	return acquireWithTickTimeout(timeout);
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
-        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;
-}
+#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(uint32_t timeoutMs) {
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+		timeout = SemaphoreIF::BLOCKING;
+	}
+	else if(timeoutMs > SemaphoreIF::POLLING){
+		timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+	return acquireWithTickTimeout(timeout);
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
+        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;
+}
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 43772e5af..e69899700 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -1,75 +1,75 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/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(uint32_t timeoutMs =
-	        SemaphoreIF::BLOCKING) 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(TickType_t timeoutTicks =
-	        SemaphoreIF::BLOCKING);
-
-	/**
-	 * 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_ */
+#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(uint32_t timeoutMs =
+	        SemaphoreIF::BLOCKING) 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(TickType_t timeoutTicks =
+	        SemaphoreIF::BLOCKING);
+
+	/**
+	 * 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_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index e6d2f92ff..8e15b7a55 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -1,11 +1,11 @@
-#include <framework/osal/FreeRTOS/BinarySemaphore.h>
-#include <framework/osal/FreeRTOS/TaskManagement.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#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;
+	if(handle == nullptr) {
+		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
 	}
 	// Initiated semaphore must be given before it can be taken.
 	xSemaphoreGive(handle);
@@ -84,7 +84,7 @@ uint8_t BinarySemaphore::getSemaphoreCounter() const {
 SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 	return handle;
 }
-
+
 
 // Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphore::releaseFromISR(
@@ -100,4 +100,4 @@ ReturnValue_t BinarySemaphore::releaseFromISR(
 	else {
 		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
-}
+}
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 2a372cd2b..4cf270de7 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -1,8 +1,8 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 #define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/SemaphoreIF.h>
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/SemaphoreIF.h"
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index ec07b662e..48d7bc078 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -1,196 +1,196 @@
-#include <framework/timemanager/Clock.h>
-#include <framework/globalfunctions/timevalOperations.h>
-#include <framework/osal/FreeRTOS/Timekeeper.h>
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-#include <stdlib.h>
-#include <time.h>
-
-//TODO sanitize input?
-//TODO much of this code can be reused for tick-only systems
-
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = nullptr;
-
-uint32_t Clock::getTicksPerSecond(void) {
-	return 1000;
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-
-	timeval time_timeval;
-
-	ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
-
-	return setClock(&time_timeval);
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	timeval uptime = getUptime();
-
-	timeval offset = *time - uptime;
-
-	Timekeeper::instance()->setOffset(offset);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	timeval uptime = getUptime();
-
-	timeval offset = Timekeeper::instance()->getOffset();
-
-	*time = offset + uptime;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	*uptime = getUptime();
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-timeval Clock::getUptime() {
-	TickType_t ticksSinceStart = xTaskGetTickCount();
-	return Timekeeper::ticksToTimeval(ticksSinceStart);
-}
-
-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::getClock_usecs(uint64_t* time) {
-	timeval time_timeval;
-	ReturnValue_t result = getClock_timeval(&time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	*time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	timeval time_timeval;
-	ReturnValue_t result = getClock_timeval(&time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	struct tm time_tm;
-
-	gmtime_r(&time_timeval.tv_sec,&time_tm);
-
-	time->year = time_tm.tm_year + 1900;
-	time->month = time_tm.tm_mon + 1;
-	time->day = time_tm.tm_mday;
-
-	time->hour = time_tm.tm_hour;
-	time->minute = time_tm.tm_min;
-	time->second = time_tm.tm_sec;
-
-	time->usecond = time_timeval.tv_usec;
-
-
-	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;
-}
-
-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 == nullptr) {
-		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 == NULL) {
-		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 == NULL) {
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../timemanager/Clock.h"
+#include "../../globalfunctions/timevalOperations.h"
+#include "../../osal/FreeRTOS/Timekeeper.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+#include <stdlib.h>
+#include <time.h>
+
+//TODO sanitize input?
+//TODO much of this code can be reused for tick-only systems
+
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = nullptr;
+
+uint32_t Clock::getTicksPerSecond(void) {
+	return 1000;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+
+	timeval time_timeval;
+
+	ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
+	if (result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+
+	return setClock(&time_timeval);
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	timeval uptime = getUptime();
+
+	timeval offset = *time - uptime;
+
+	Timekeeper::instance()->setOffset(offset);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+	timeval uptime = getUptime();
+
+	timeval offset = Timekeeper::instance()->getOffset();
+
+	*time = offset + uptime;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	*uptime = getUptime();
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+timeval Clock::getUptime() {
+	TickType_t ticksSinceStart = xTaskGetTickCount();
+	return Timekeeper::ticksToTimeval(ticksSinceStart);
+}
+
+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::getClock_usecs(uint64_t* time) {
+	timeval time_timeval;
+	ReturnValue_t result = getClock_timeval(&time_timeval);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	*time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	timeval time_timeval;
+	ReturnValue_t result = getClock_timeval(&time_timeval);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	struct tm time_tm;
+
+	gmtime_r(&time_timeval.tv_sec,&time_tm);
+
+	time->year = time_tm.tm_year + 1900;
+	time->month = time_tm.tm_mon + 1;
+	time->day = time_tm.tm_mday;
+
+	time->hour = time_tm.tm_hour;
+	time->minute = time_tm.tm_min;
+	time->second = time_tm.tm_sec;
+
+	time->usecond = time_timeval.tv_usec;
+
+
+	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;
+}
+
+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 == nullptr) {
+		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 == NULL) {
+		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 == NULL) {
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index f33c7a0d0..333865c89 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -1,110 +1,110 @@
-#include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
-#include <framework/osal/FreeRTOS/TaskManagement.h>
-#include <framework/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(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::BLOCKING) {
-		timeout = SemaphoreIF::BLOCKING;
-	}
-	else if(timeoutMs > SemaphoreIF::POLLING){
-		timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-	return acquireWithTickTimeout(timeout);
-
-}
-
-ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
-		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;
-}
+#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(uint32_t timeoutMs) {
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+		timeout = SemaphoreIF::BLOCKING;
+	}
+	else if(timeoutMs > SemaphoreIF::POLLING){
+		timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+	return acquireWithTickTimeout(timeout);
+
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
+		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;
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index f1d82c1dd..801e34309 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -1,100 +1,100 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
-
-#include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
-#include <framework/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(uint32_t timeoutMs = SemaphoreIF::BLOCKING) 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(
-			TickType_t timeoutTicks = SemaphoreIF::BLOCKING);
-
-	/**
-	 * 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_ */
+#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(uint32_t timeoutMs = SemaphoreIF::BLOCKING) 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(
+			TickType_t timeoutTicks = SemaphoreIF::BLOCKING);
+
+	/**
+	 * 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_ */
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index 957f6a319..0b218e544 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,43 +1,43 @@
-#include <framework/osal/FreeRTOS/CountingSemaphore.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/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;
-}
+#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;
+}
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index dca3ab0ed..9432ed81e 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -1,34 +1,34 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
-#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
-#include <framework/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_ */
+#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_ */
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 2a7bff9cf..769f31e1b 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -1,162 +1,162 @@
-#include "FixedTimeslotTask.h"
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
-
-FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
-		TaskStackSize setStack, TaskPeriod overallPeriod,
-		void (*setDeadlineMissedFunc)()) :
-		started(false), handle(NULL), pst(overallPeriod * 1000) {
-	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;
-}
-
-FixedTimeslotTask::~FixedTimeslotTask() {
-}
-
-void FixedTimeslotTask::taskEntryPoint(void* argument) {
-
-	// The argument is re-interpreted as FixedTimeslotTask. The Task object is
-    // global, so it is found from any place.
-	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
-	/* Task should not start until explicitly requested,
-	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
-	 * is running but not if the scheduler is not running.
-	 * To be able to accommodate both cases we check a member which is set in
-	 * #startTask(). If it is not set and we get here, the scheduler was started
-	 * before #startTask() was called and we need to suspend if it is set,
-	 * the scheduler was not running before #startTask() was called and we
-	 * can continue */
-
-	if (not originalTask->started) {
-		vTaskSuspend(NULL);
-	}
-
-	originalTask->taskFunctionality();
-	sif::debug << "Polling task " << originalTask->handle
-			<< " returned from taskFunctionality." << std::endl;
-}
-
-void FixedTimeslotTask::missedDeadlineCounter() {
-	FixedTimeslotTask::deadlineMissedCount++;
-	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
-				<< " deadlines." << std::endl;
-	}
-}
-
-ReturnValue_t FixedTimeslotTask::startTask() {
-	started = true;
-
-	// We must not call resume if scheduler is not started yet
-	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
-		vTaskResume(handle);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t FixedTimeslotTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
-	return pst.checkSequence();
-}
-
-void FixedTimeslotTask::taskFunctionality() {
-	// A local iterator for the Polling Sequence Table is created to find the
-    // start time for the first entry.
-	auto slotListIter = pst.current;
-
-	//The start time for the first entry is read.
-	uint32_t intervalMs = slotListIter->pollingTimeMs;
-	TickType_t interval = pdMS_TO_TICKS(intervalMs);
-
-	TickType_t xLastWakeTime;
-	/* 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
-	 internally within vTaskDelayUntil(). */
-	xLastWakeTime = xTaskGetTickCount();
-
-	// wait for first entry's start time
-	if(interval > 0) {
-	    vTaskDelayUntil(&xLastWakeTime, interval);
-	}
-
-	/* Enter the loop that defines the task behavior. */
-	for (;;) {
-		//The component for this slot is executed and the next one is chosen.
-	    this->pst.executeAndAdvance();
-	    if (not pst.slotFollowsImmediately()) {
-	        // Get the interval till execution of the next slot.
-	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
-	        interval = pdMS_TO_TICKS(intervalMs);
-
-	        checkMissedDeadline(xLastWakeTime, interval);
-
-	        // Wait for the interval. This exits immediately if a deadline was
-	        // missed while also updating the last wake time.
-	        vTaskDelayUntil(&xLastWakeTime, interval);
-	    }
-	}
-}
-
-void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-}
-
-void FixedTimeslotTask::handleMissedDeadline() {
-#ifdef DEBUG
-    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
-            " missed deadline!\n" << std::flush;
-#endif
-    if(deadlineMissedFunc != nullptr) {
-        this->deadlineMissedFunc();
-    }
-}
-
-ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
-	vTaskDelay(pdMS_TO_TICKS(ms));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-TaskHandle_t FixedTimeslotTask::getTaskHandle() {
-    return handle;
-}
+#include "FixedTimeslotTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
+
+FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
+		TaskStackSize setStack, TaskPeriod overallPeriod,
+		void (*setDeadlineMissedFunc)()) :
+		started(false), handle(NULL), pst(overallPeriod * 1000) {
+	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;
+}
+
+FixedTimeslotTask::~FixedTimeslotTask() {
+}
+
+void FixedTimeslotTask::taskEntryPoint(void* argument) {
+
+	// The argument is re-interpreted as FixedTimeslotTask. The Task object is
+    // global, so it is found from any place.
+	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
+
+	if (not originalTask->started) {
+		vTaskSuspend(NULL);
+	}
+
+	originalTask->taskFunctionality();
+	sif::debug << "Polling task " << originalTask->handle
+			<< " returned from taskFunctionality." << std::endl;
+}
+
+void FixedTimeslotTask::missedDeadlineCounter() {
+	FixedTimeslotTask::deadlineMissedCount++;
+	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
+				<< " deadlines." << std::endl;
+	}
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+	started = true;
+
+	// We must not call resume if scheduler is not started yet
+	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
+		vTaskResume(handle);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+		uint32_t slotTimeMs, int8_t executionStep) {
+	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+	return pst.getLengthMs();
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+	return pst.checkSequence();
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+	// A local iterator for the Polling Sequence Table is created to find the
+    // start time for the first entry.
+	auto slotListIter = pst.current;
+
+	//The start time for the first entry is read.
+	uint32_t intervalMs = slotListIter->pollingTimeMs;
+	TickType_t interval = pdMS_TO_TICKS(intervalMs);
+
+	TickType_t xLastWakeTime;
+	/* 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
+	 internally within vTaskDelayUntil(). */
+	xLastWakeTime = xTaskGetTickCount();
+
+	// wait for first entry's start time
+	if(interval > 0) {
+	    vTaskDelayUntil(&xLastWakeTime, interval);
+	}
+
+	/* Enter the loop that defines the task behavior. */
+	for (;;) {
+		//The component for this slot is executed and the next one is chosen.
+	    this->pst.executeAndAdvance();
+	    if (not pst.slotFollowsImmediately()) {
+	        // Get the interval till execution of the next slot.
+	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
+	        interval = pdMS_TO_TICKS(intervalMs);
+
+	        checkMissedDeadline(xLastWakeTime, interval);
+
+	        // Wait for the interval. This exits immediately if a deadline was
+	        // missed while also updating the last wake time.
+	        vTaskDelayUntil(&xLastWakeTime, interval);
+	    }
+	}
+}
+
+void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Time to wake has not overflown.
+    if(timeToWake > xLastWakeTime) {
+        /* If the current time has overflown exclusively or the current
+         * tick count is simply larger than the time to wake, a deadline was
+         * missed */
+        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
+            handleMissedDeadline();
+        }
+    }
+    /* Time to wake has overflown. A deadline was missed if the current time
+     * is larger than the time to wake */
+    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
+        handleMissedDeadline();
+    }
+}
+
+void FixedTimeslotTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
+	vTaskDelay(pdMS_TO_TICKS(ms));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+TaskHandle_t FixedTimeslotTask::getTaskHandle() {
+    return handle;
+}
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 369507731..42af14b84 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,101 +1,101 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
-
-#include <framework/osal/FreeRTOS/FreeRTOSTaskIF.h>
-#include <framework/tasks/FixedSlotSequence.h>
-#include <framework/tasks/FixedTimeslotTaskIF.h>
-#include <framework/tasks/Typedef.h>
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-class FixedTimeslotTask: public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
-public:
-
-	/**
-	 * Keep in mind that you need to call before vTaskStartScheduler()!
-	 * A lot of task parameters are set in "FreeRTOSConfig.h".
-	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
-	 * @param setPriority Number of priorities specified by
-	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
-	 * @param setStack	Stack size in words (not bytes!).
-	 * Lower limit specified by configMINIMAL_STACK_SIZE
-	 * @param overallPeriod		Period in seconds.
-	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
-	 * @return Pointer to the newly created task.
-	 */
-	FixedTimeslotTask(TaskName name, TaskPriority setPriority,
-			TaskStackSize setStack, TaskPeriod overallPeriod,
-			void (*setDeadlineMissedFunc)());
-
-	/**
-	 * @brief	The destructor of the class.
-	 * @details
-	 * The destructor frees all heap memory that was allocated on thread
-	 * initialization for the PST and the device handlers. This is done by
-	 * calling the PST's destructor.
-	 */
-	virtual ~FixedTimeslotTask(void);
-
-	ReturnValue_t startTask(void);
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines
-	 * every 10th time.
-	 */
-	static void missedDeadlineCounter();
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-			int8_t executionStep) override;
-
-	uint32_t getPeriodMs() const override;
-
-	ReturnValue_t checkSequence() const override;
-
-	ReturnValue_t sleepFor(uint32_t ms) override;
-
-	TaskHandle_t getTaskHandle() override;
-
-protected:
-	bool started;
-	TaskHandle_t handle;
-
-	FixedSlotSequence pst;
-
-	/**
-	 * @brief	This attribute holds a function pointer that is executed when
-	 *          a deadline was missed.
-	 * @details
-	 * Another function may be announced to determine the actions to perform
-	 * when a deadline was missed. Currently, only one function for missing
-	 * any deadline is allowed. If not used, it shall be declared NULL.
-	 */
-	void (*deadlineMissedFunc)(void);
-	/**
-	 * @brief	This is the entry point for a new task.
-	 * @details
-	 * This method starts the task by calling taskFunctionality(), as soon as
-	 * all requirements (task scheduler has started and startTask()
-	 * has been called) are met.
-	 */
-	static void taskEntryPoint(void* argument);
-
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 * @details
-	 * Core function holding the main functionality of the task
-	 * It links the functionalities provided by FixedSlotSequence with the
-	 * OS's System Calls to keep the timing of the periods.
-	 */
-	void taskFunctionality(void);
-
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
-	void handleMissedDeadline();
-};
-
-#endif /* POLLINGTASK_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+
+#include "../../osal/FreeRTOS/FreeRTOSTaskIF.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+class FixedTimeslotTask: public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
+public:
+
+	/**
+	 * Keep in mind that you need to call before vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
+	 * @param setPriority Number of priorities specified by
+	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
+	 * @param setStack	Stack size in words (not bytes!).
+	 * Lower limit specified by configMINIMAL_STACK_SIZE
+	 * @param overallPeriod		Period in seconds.
+	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
+	 * @return Pointer to the newly created task.
+	 */
+	FixedTimeslotTask(TaskName name, TaskPriority setPriority,
+			TaskStackSize setStack, TaskPeriod overallPeriod,
+			void (*setDeadlineMissedFunc)());
+
+	/**
+	 * @brief	The destructor of the class.
+	 * @details
+	 * The destructor frees all heap memory that was allocated on thread
+	 * initialization for the PST and the device handlers. This is done by
+	 * calling the PST's destructor.
+	 */
+	virtual ~FixedTimeslotTask(void);
+
+	ReturnValue_t startTask(void);
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines
+	 * every 10th time.
+	 */
+	static void missedDeadlineCounter();
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+			int8_t executionStep) override;
+
+	uint32_t getPeriodMs() const override;
+
+	ReturnValue_t checkSequence() const override;
+
+	ReturnValue_t sleepFor(uint32_t ms) override;
+
+	TaskHandle_t getTaskHandle() override;
+
+protected:
+	bool started;
+	TaskHandle_t handle;
+
+	FixedSlotSequence pst;
+
+	/**
+	 * @brief	This attribute holds a function pointer that is executed when
+	 *          a deadline was missed.
+	 * @details
+	 * Another function may be announced to determine the actions to perform
+	 * when a deadline was missed. Currently, only one function for missing
+	 * any deadline is allowed. If not used, it shall be declared NULL.
+	 */
+	void (*deadlineMissedFunc)(void);
+	/**
+	 * @brief	This is the entry point for a new task.
+	 * @details
+	 * This method starts the task by calling taskFunctionality(), as soon as
+	 * all requirements (task scheduler has started and startTask()
+	 * has been called) are met.
+	 */
+	static void taskEntryPoint(void* argument);
+
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 * @details
+	 * Core function holding the main functionality of the task
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
+	 */
+	void taskFunctionality(void);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
+};
+
+#endif /* POLLINGTASK_H_ */
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index e9f3871e2..3b335ffc7 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -1,155 +1,155 @@
-#include <framework/osal/FreeRTOS/MessageQueue.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-// TODO I guess we should have a way of checking if we are in an ISR and then
-// use the "fromISR" versions of all calls
-// As a first step towards this, introduces system context variable which needs
-// to be switched manually
-// Haven't found function to find system context.
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
-		maxMessageSize(maxMessageSize) {
-	handle = xQueueCreate(messageDepth, maxMessageSize);
-	if (handle == NULL) {
-		sif::error << "MessageQueue: Creation failed" << std::endl;
-	}
-}
-
-MessageQueue::~MessageQueue() {
-	if (handle != NULL) {
-		vQueueDelete(handle);
-	}
-}
-
-void MessageQueue::switchSystemContext(CallContext callContext) {
-	this->callContext = callContext;
-}
-
-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 != MessageQueueMessageIF::NO_QUEUE) {
-		return sendMessageFrom(this->lastPartner, message, this->getId());
-	} else {
-		return NO_REPLY_PARTNER;
-	}
-}
-
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault,
-	        callContext);
-}
-
-
-ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
-	if (result != pdPASS) {
-		if (not ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter =
-					objectManager->get<InternalErrorReporterIF>(
-					objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != nullptr) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		return MessageQueueIF::FULL;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-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) {
-	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
-			message->getBuffer()), 0);
-	if (result == pdPASS){
-		this->lastPartner = message->getSender();
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return MessageQueueIF::EMPTY;
-	}
-}
-
-MessageQueueId_t MessageQueue::getLastPartner() const {
-	return lastPartner;
-}
-
-ReturnValue_t MessageQueue::flush(uint32_t* count) {
-	//TODO FreeRTOS does not support flushing partially
-	//Is always successful
-	xQueueReset(handle);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t MessageQueue::getId() const {
-	return reinterpret_cast<MessageQueueId_t>(handle);
-}
-
-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, CallContext callContext) {
-	BaseType_t result = pdFALSE;
-	QueueHandle_t destination = nullptr;
-
-	if(sendTo == MessageQueueIF::NO_QUEUE) {
-		return MessageQueueIF::DESTINVATION_INVALID;
-	}
-	else  {
-		destination = reinterpret_cast<QueueHandle_t>(sendTo);
-	}
-    message->setSender(sentFrom);
-
-
-    if(callContext == CallContext::TASK) {
-        result = xQueueSendToBack(destination,
-                static_cast<const void*>(message->getBuffer()), 0);
-    }
-    else {
-        /* If the call context is from an interrupt,
-         * request a context switch if a higher priority task
-         * was blocked by the interrupt. */
-        BaseType_t xHigherPriorityTaskWoken = pdFALSE;
-        result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
-                static_cast<const void*>(message->getBuffer()),
-                &xHigherPriorityTaskWoken);
-        if(xHigherPriorityTaskWoken == pdTRUE) {
-            TaskManagement::requestContextSwitch(callContext);
-        }
-    }
-    return handleSendResult(result, ignoreFault);
-}
+#include "../../osal/FreeRTOS/MessageQueue.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+// TODO I guess we should have a way of checking if we are in an ISR and then
+// use the "fromISR" versions of all calls
+// As a first step towards this, introduces system context variable which needs
+// to be switched manually
+// Haven't found function to find system context.
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
+		maxMessageSize(maxMessageSize) {
+	handle = xQueueCreate(messageDepth, maxMessageSize);
+	if (handle == NULL) {
+		sif::error << "MessageQueue: Creation failed" << std::endl;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	if (handle != NULL) {
+		vQueueDelete(handle);
+	}
+}
+
+void MessageQueue::switchSystemContext(CallContext callContext) {
+	this->callContext = callContext;
+}
+
+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 != MessageQueueMessageIF::NO_QUEUE) {
+		return sendMessageFrom(this->lastPartner, message, this->getId());
+	} else {
+		return NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault,
+	        callContext);
+}
+
+
+ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
+	if (result != pdPASS) {
+		if (not ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != nullptr) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		return MessageQueueIF::FULL;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+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) {
+	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
+			message->getBuffer()), 0);
+	if (result == pdPASS){
+		this->lastPartner = message->getSender();
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return MessageQueueIF::EMPTY;
+	}
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	//TODO FreeRTOS does not support flushing partially
+	//Is always successful
+	xQueueReset(handle);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return reinterpret_cast<MessageQueueId_t>(handle);
+}
+
+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, CallContext callContext) {
+	BaseType_t result = pdFALSE;
+	QueueHandle_t destination = nullptr;
+
+	if(sendTo == MessageQueueIF::NO_QUEUE) {
+		return MessageQueueIF::DESTINVATION_INVALID;
+	}
+	else  {
+		destination = reinterpret_cast<QueueHandle_t>(sendTo);
+	}
+    message->setSender(sentFrom);
+
+
+    if(callContext == CallContext::TASK) {
+        result = xQueueSendToBack(destination,
+                static_cast<const void*>(message->getBuffer()), 0);
+    }
+    else {
+        /* If the call context is from an interrupt,
+         * request a context switch if a higher priority task
+         * was blocked by the interrupt. */
+        BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+        result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
+                static_cast<const void*>(message->getBuffer()),
+                &xHigherPriorityTaskWoken);
+        if(xHigherPriorityTaskWoken == pdTRUE) {
+            TaskManagement::requestContextSwitch(callContext);
+        }
+    }
+    return handleSendResult(result, ignoreFault);
+}
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index b7e52bb39..48a5ab6a6 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -1,212 +1,212 @@
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
-
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MessageQueueMessageIF.h>
-#include <framework/osal/FreeRTOS/TaskManagement.h>
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/queue.h>
-
-// TODO: this class assumes that MessageQueueId_t is the same size as void*
-// (the FreeRTOS handle type), compiler will catch this but it might be nice
-// to have something checking or even an always working solution
-// https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
-
-/**
- * @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 i 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();
-
-	/**
-	 * This function is used to switch the call context. This has to be called
-	 * if a message is sent or received from an ISR!
-	 * @param callContext
-	 */
-	void switchSystemContext(CallContext callContext);
-
-	/**
-	 * @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
-	 * 			lastParnter 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);
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	MessageQueueId_t getId() const;
-
-	/**
-	 * @brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * @brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
-
-	bool isDefaultDestinationSet() const;
-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, CallContext callContext = CallContext::TASK);
-
-	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
-
-private:
-	bool defaultDestinationSet = false;
-	QueueHandle_t handle;
-	MessageQueueId_t defaultDestination = 0;
-	MessageQueueId_t lastPartner = 0;
-	const size_t maxMessageSize;
-	//!< Stores the current system context
-	CallContext callContext =  CallContext::TASK;
-};
-
-#endif /* MESSAGEQUEUE_H_ */
+#ifndef MESSAGEQUEUE_H_
+#define MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessageIF.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+
+// TODO: this class assumes that MessageQueueId_t is the same size as void*
+// (the FreeRTOS handle type), compiler will catch this but it might be nice
+// to have something checking or even an always working solution
+// https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
+
+/**
+ * @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 i 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();
+
+	/**
+	 * This function is used to switch the call context. This has to be called
+	 * if a message is sent or received from an ISR!
+	 * @param callContext
+	 */
+	void switchSystemContext(CallContext callContext);
+
+	/**
+	 * @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
+	 * 			lastParnter 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);
+	/**
+	 * @brief	This method returns the message queue id of the last communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const;
+	/**
+	 * @brief	This method returns the message queue id of this class's message queue.
+	 */
+	MessageQueueId_t getId() const;
+
+	/**
+	 * @brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination);
+	/**
+	 * @brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const;
+
+	bool isDefaultDestinationSet() const;
+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, CallContext callContext = CallContext::TASK);
+
+	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
+private:
+	bool defaultDestinationSet = false;
+	QueueHandle_t handle;
+	MessageQueueId_t defaultDestination = 0;
+	MessageQueueId_t lastPartner = 0;
+	const size_t maxMessageSize;
+	//!< Stores the current system context
+	CallContext callContext =  CallContext::TASK;
+};
+
+#endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 764b0ae09..8d2e43b87 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -1,51 +1,51 @@
-#include <framework/osal/FreeRTOS/Mutex.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-Mutex::Mutex() {
-	handle = xSemaphoreCreateMutex();
-	if(handle == nullptr) {
-		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
-	}
-}
-
-Mutex::~Mutex() {
-	if (handle != nullptr) {
-		vSemaphoreDelete(handle);
-	}
-
-}
-
-ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType,
-        uint32_t timeoutMs) {
-	if (handle == nullptr) {
-		return MutexIF::MUTEX_NOT_FOUND;
-	}
-	// If the timeout type is BLOCKING, this will be the correct value.
-	uint32_t timeout = portMAX_DELAY;
-	if(timeoutType == TimeoutType::POLLING) {
-		timeout = 0;
-	}
-	else if(timeoutType == TimeoutType::WAITING){
-		timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-
-	BaseType_t returncode = xSemaphoreTake(handle, timeout);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return MutexIF::MUTEX_TIMEOUT;
-	}
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	if (handle == nullptr) {
-		return MutexIF::MUTEX_NOT_FOUND;
-	}
-	BaseType_t returncode = xSemaphoreGive(handle);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	}
-}
+#include "../../osal/FreeRTOS/Mutex.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+Mutex::Mutex() {
+	handle = xSemaphoreCreateMutex();
+	if(handle == nullptr) {
+		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
+	}
+}
+
+Mutex::~Mutex() {
+	if (handle != nullptr) {
+		vSemaphoreDelete(handle);
+	}
+
+}
+
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+	if (handle == nullptr) {
+		return MutexIF::MUTEX_NOT_FOUND;
+	}
+	// If the timeout type is BLOCKING, this will be the correct value.
+	uint32_t timeout = portMAX_DELAY;
+	if(timeoutType == TimeoutType::POLLING) {
+		timeout = 0;
+	}
+	else if(timeoutType == TimeoutType::WAITING){
+		timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+
+	BaseType_t returncode = xSemaphoreTake(handle, timeout);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return MutexIF::MUTEX_TIMEOUT;
+	}
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	if (handle == nullptr) {
+		return MutexIF::MUTEX_NOT_FOUND;
+	}
+	BaseType_t returncode = xSemaphoreGive(handle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	}
+}
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 2a4fae26d..5cbc6a72e 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -1,29 +1,29 @@
-#ifndef FRAMEWORK_FREERTOS_MUTEX_H_
-#define FRAMEWORK_FREERTOS_MUTEX_H_
-
-#include <framework/ipc/MutexIF.h>
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/semphr.h>
-
-/**
- * @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();
-	~Mutex();
-	ReturnValue_t lockMutex(TimeoutType timeoutType,
-	        uint32_t timeoutMs) override;
-	ReturnValue_t unlockMutex() override;
-
-private:
-	SemaphoreHandle_t handle;
-};
-
-#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
+#ifndef FRAMEWORK_FREERTOS_MUTEX_H_
+#define FRAMEWORK_FREERTOS_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+
+/**
+ * @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();
+	~Mutex();
+	ReturnValue_t lockMutex(TimeoutType timeoutType,
+	        uint32_t timeoutMs) override;
+	ReturnValue_t unlockMutex() override;
+
+private:
+	SemaphoreHandle_t handle;
+};
+
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/osal/FreeRTOS/MutexFactory.cpp b/osal/FreeRTOS/MutexFactory.cpp
index a1cca54be..9dcd85363 100644
--- a/osal/FreeRTOS/MutexFactory.cpp
+++ b/osal/FreeRTOS/MutexFactory.cpp
@@ -1,28 +1,28 @@
-#include <framework/ipc/MutexFactory.h>
-#include <framework/osal/FreeRTOS/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;
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/FreeRTOS/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;
+}
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index c316d4fc5..662ece3b2 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -1,138 +1,138 @@
-#include "PeriodicTask.h"
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-
-PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
-		TaskStackSize setStack, TaskPeriod setPeriod,
-		TaskDeadlineMissedFunction deadlineMissedFunc) :
-		started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
-		deadlineMissedFunc)
-{
-	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
-	BaseType_t status = xTaskCreate(taskEntryPoint, name,
-			stackSize, this, setPriority, &handle);
-	if(status != pdPASS){
-		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
-		        "Status: " << status << std::endl;
-	}
-
-}
-
-PeriodicTask::~PeriodicTask(void) {
-	//Do not delete objects, we were responsible for ptrs only.
-}
-
-void PeriodicTask::taskEntryPoint(void* argument) {
-	// The argument is re-interpreted as PeriodicTask. The Task object is
-    // global, so it is found from any place.
-	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
-	/* Task should not start until explicitly requested,
-	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
-	 * is running but not if the scheduler is not running.
-	 * To be able to accommodate both cases we check a member which is set in
-	 * #startTask(). If it is not set and we get here, the scheduler was started
-	 * before #startTask() was called and we need to suspend if it is set,
-	 * the scheduler was not running before #startTask() was called and we
-	 * can continue */
-
-	if (not originalTask->started) {
-		vTaskSuspend(NULL);
-	}
-
-	originalTask->taskFunctionality();
-	sif::debug << "Polling task " << originalTask->handle
-			<< " returned from taskFunctionality." << std::endl;
-}
-
-ReturnValue_t PeriodicTask::startTask() {
-	started = true;
-
-	// We must not call resume if scheduler is not started yet
-	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
-		vTaskResume(handle);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
-	vTaskDelay(pdMS_TO_TICKS(ms));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void PeriodicTask::taskFunctionality() {
-	TickType_t xLastWakeTime;
-	const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
-	/* 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
-	 internally within vTaskDelayUntil(). */
-	xLastWakeTime = xTaskGetTickCount();
-	/* Enter the loop that defines the task behavior. */
-	for (;;) {
-		for (auto const& object: objectList) {
-			object->performOperation();
-		}
-
-		checkMissedDeadline(xLastWakeTime, xPeriod);
-
-		vTaskDelayUntil(&xLastWakeTime, xPeriod);
-
-	}
-}
-
-ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == nullptr) {
-	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
-	            "it implement ExecutableObjectIF" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	newObject->setTaskIF(this);
-
-	return newObject->initializeAfterTaskCreation();
-}
-
-uint32_t PeriodicTask::getPeriodMs() const {
-	return period * 1000;
-}
-
-void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-}
-
-TaskHandle_t PeriodicTask::getTaskHandle() {
-    return handle;
-}
-
-void PeriodicTask::handleMissedDeadline() {
-#ifdef DEBUG
-    sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
-            " missed deadline!\n" << std::flush;
-#endif
-    if(deadlineMissedFunc != nullptr) {
-        this->deadlineMissedFunc();
-    }
-}
+#include "PeriodicTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
+		TaskStackSize setStack, TaskPeriod setPeriod,
+		TaskDeadlineMissedFunction deadlineMissedFunc) :
+		started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
+		deadlineMissedFunc)
+{
+	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
+	BaseType_t status = xTaskCreate(taskEntryPoint, name,
+			stackSize, this, setPriority, &handle);
+	if(status != pdPASS){
+		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
+		        "Status: " << status << std::endl;
+	}
+
+}
+
+PeriodicTask::~PeriodicTask(void) {
+	//Do not delete objects, we were responsible for ptrs only.
+}
+
+void PeriodicTask::taskEntryPoint(void* argument) {
+	// The argument is re-interpreted as PeriodicTask. The Task object is
+    // global, so it is found from any place.
+	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
+
+	if (not originalTask->started) {
+		vTaskSuspend(NULL);
+	}
+
+	originalTask->taskFunctionality();
+	sif::debug << "Polling task " << originalTask->handle
+			<< " returned from taskFunctionality." << std::endl;
+}
+
+ReturnValue_t PeriodicTask::startTask() {
+	started = true;
+
+	// We must not call resume if scheduler is not started yet
+	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
+		vTaskResume(handle);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
+	vTaskDelay(pdMS_TO_TICKS(ms));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PeriodicTask::taskFunctionality() {
+	TickType_t xLastWakeTime;
+	const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
+	/* 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
+	 internally within vTaskDelayUntil(). */
+	xLastWakeTime = xTaskGetTickCount();
+	/* Enter the loop that defines the task behavior. */
+	for (;;) {
+		for (auto const& object: objectList) {
+			object->performOperation();
+		}
+
+		checkMissedDeadline(xLastWakeTime, xPeriod);
+
+		vTaskDelayUntil(&xLastWakeTime, xPeriod);
+
+	}
+}
+
+ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == nullptr) {
+	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+	            "it implement ExecutableObjectIF" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	newObject->setTaskIF(this);
+
+	return newObject->initializeAfterTaskCreation();
+}
+
+uint32_t PeriodicTask::getPeriodMs() const {
+	return period * 1000;
+}
+
+void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Time to wake has not overflown.
+    if(timeToWake > xLastWakeTime) {
+        /* If the current time has overflown exclusively or the current
+         * tick count is simply larger than the time to wake, a deadline was
+         * missed */
+        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
+            handleMissedDeadline();
+        }
+    }
+    /* Time to wake has overflown. A deadline was missed if the current time
+     * is larger than the time to wake */
+    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
+        handleMissedDeadline();
+    }
+}
+
+TaskHandle_t PeriodicTask::getTaskHandle() {
+    return handle;
+}
+
+void PeriodicTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 8030baadc..1cdc3df70 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -1,128 +1,128 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
-
-#include <framework/osal/FreeRTOS/FreeRTOSTaskIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
-#include <framework/tasks/Typedef.h>
-
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-#include <vector>
-
-class ExecutableObjectIF;
-
-/**
- * @brief 	This class represents a specialized task for
- * 			periodic activities of multiple objects.
- * @ingroup task_handling
- */
-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.
-	 * @param priority
-	 * Sets the priority of a task. Values depend on freeRTOS configuration,
-	 * high number means high priority.
-	 * @param stack_size
-	 * The stack size reserved by the operating system for the task.
-	 * @param setPeriod
-	 * The length of the period with which the task's
-	 * functionality will be executed. It is expressed in clock ticks.
-	 * @param setDeadlineMissedFunc
-	 * The function pointer to the deadline missed function that shall
-	 * be assigned.
-	 */
-	PeriodicTask(TaskName name, TaskPriority setPriority,
-	        TaskStackSize setStack, TaskPeriod setPeriod,
-	        TaskDeadlineMissedFunction deadlineMissedFunc);
-	/**
-	 * @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() override;
-	/**
-	 * 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) override;
-
-	uint32_t getPeriodMs() const override;
-
-	ReturnValue_t sleepFor(uint32_t ms) override;
-
-	TaskHandle_t getTaskHandle() override;
-protected:
-	bool started;
-	TaskHandle_t handle;
-
-	//! Typedef for the List of objects.
-	typedef std::vector<ExecutableObjectIF*> ObjectList;
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-	/**
-	 * @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.
-	 */
-
-	static 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);
-
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
-	void handleMissedDeadline();
-};
-
-#endif /* PERIODICTASK_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
+
+#include "../../osal/FreeRTOS/FreeRTOSTaskIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+#include <vector>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief 	This class represents a specialized task for
+ * 			periodic activities of multiple objects.
+ * @ingroup task_handling
+ */
+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.
+	 * @param priority
+	 * Sets the priority of a task. Values depend on freeRTOS configuration,
+	 * high number means high priority.
+	 * @param stack_size
+	 * The stack size reserved by the operating system for the task.
+	 * @param setPeriod
+	 * The length of the period with which the task's
+	 * functionality will be executed. It is expressed in clock ticks.
+	 * @param setDeadlineMissedFunc
+	 * The function pointer to the deadline missed function that shall
+	 * be assigned.
+	 */
+	PeriodicTask(TaskName name, TaskPriority setPriority,
+	        TaskStackSize setStack, TaskPeriod setPeriod,
+	        TaskDeadlineMissedFunction deadlineMissedFunc);
+	/**
+	 * @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() override;
+	/**
+	 * 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) override;
+
+	uint32_t getPeriodMs() const override;
+
+	ReturnValue_t sleepFor(uint32_t ms) override;
+
+	TaskHandle_t getTaskHandle() override;
+protected:
+	bool started;
+	TaskHandle_t handle;
+
+	//! Typedef for the List of objects.
+	typedef std::vector<ExecutableObjectIF*> ObjectList;
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+	/**
+	 * @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.
+	 */
+
+	static 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);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
+};
+
+#endif /* PERIODICTASK_H_ */
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index beb4969bd..050917335 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -1,36 +1,36 @@
-#include <framework/ipc/QueueFactory.h>
-
-#include <framework/osal/FreeRTOS/MessageQueue.h>
-
-
-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);
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == nullptr) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+
+#include "../../osal/FreeRTOS/MessageQueue.h"
+
+
+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);
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == nullptr) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 78427f6cf..453f22269 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -1,61 +1,61 @@
-#include <framework/osal/FreeRTOS/BinarySemaphore.h>
-#include <framework/osal/FreeRTOS/BinSemaphUsingTask.h>
-#include <framework/osal/FreeRTOS/CountingSemaphore.h>
-#include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
-#include <framework/tasks/SemaphoreFactory.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = portMAX_DELAY;
-
-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;
-}
+#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;
+const uint32_t SemaphoreIF::POLLING = 0;
+const uint32_t SemaphoreIF::BLOCKING = portMAX_DELAY;
+
+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;
+}
diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 68866f393..b68b05b3e 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -1,53 +1,53 @@
-#include <framework/tasks/TaskFactory.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-#include "PeriodicTask.h"
-#include "FixedTimeslotTask.h"
-
-
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
-		TaskPriority taskPriority_, TaskStackSize stackSize_,
-		TaskPeriod period_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return dynamic_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_,
-			stackSize_, period_, deadLineMissedFunction_));
-}
-
-/**
- * Keep in Mind that you need to call before this vTaskStartScheduler()!
- */
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-		TaskPriority taskPriority_, TaskStackSize stackSize_,
-		TaskPeriod period_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return dynamic_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_,
-			taskPriority_,stackSize_, period_, deadLineMissedFunction_));
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	if (task == nullptr) {
-		//delete self
-		vTaskDelete(nullptr);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		//TODO not implemented
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
-	vTaskDelay(pdMS_TO_TICKS(delayMs));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-TaskFactory::TaskFactory() {
-}
+#include "../../tasks/TaskFactory.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+#include "PeriodicTask.h"
+#include "FixedTimeslotTask.h"
+
+
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_, TaskStackSize stackSize_,
+		TaskPeriod period_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return dynamic_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_,
+			stackSize_, period_, deadLineMissedFunction_));
+}
+
+/**
+ * Keep in Mind that you need to call before this vTaskStartScheduler()!
+ */
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_, TaskStackSize stackSize_,
+		TaskPeriod period_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return dynamic_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_,
+			taskPriority_,stackSize_, period_, deadLineMissedFunction_));
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	if (task == nullptr) {
+		//delete self
+		vTaskDelete(nullptr);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		//TODO not implemented
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
+	vTaskDelay(pdMS_TO_TICKS(delayMs));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+TaskFactory::TaskFactory() {
+}
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index ff552adbb..16682d361 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,11 +1,11 @@
-#include <framework/osal/FreeRTOS/TaskManagement.h>
-
+#include "../../osal/FreeRTOS/TaskManagement.h"
+
 void TaskManagement::vRequestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
-
+
 void TaskManagement::requestContextSwitch(
-		CallContext callContext = CallContext::TASK) {
+		CallContext callContext = CallContext::TASK) {
 	if(callContext == CallContext::ISR) {
 		// This function depends on the partmacro.h definition for the specific device
 		vRequestContextSwitchFromISR();
@@ -13,7 +13,7 @@ void TaskManagement::requestContextSwitch(
 		vRequestContextSwitchFromTask();
 	}
 }
-
+
 TaskHandle_t TaskManagement::getCurrentTaskHandle() {
 	return xTaskGetCurrentTaskHandle();
 }
@@ -21,4 +21,4 @@ TaskHandle_t TaskManagement::getCurrentTaskHandle() {
 size_t TaskManagement::getTaskStackHighWatermark(
         TaskHandle_t task) {
 	return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
-}
+}
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 62c68331a..43003d763 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -1,14 +1,14 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 #define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.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.
@@ -17,9 +17,9 @@ 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
+ * 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.
+ * an ISR and task.
  */
 enum class CallContext {
 	TASK = 0x00,//!< task_context
@@ -29,19 +29,19 @@ enum class CallContext {
 
 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.
+	 * 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);
+	 */
+	static void vRequestContextSwitchFromTask(void);
 
 	/**
 	 * @return The current task handle
@@ -56,9 +56,9 @@ public:
 	 * 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);
+	        TaskHandle_t task = nullptr);
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */
diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index 643b27479..f7a3c8f85 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -1,41 +1,41 @@
-#include <framework/osal/FreeRTOS/Timekeeper.h>
-
-#include "FreeRTOSConfig.h"
-
-Timekeeper * Timekeeper::myinstance = nullptr;
-
-Timekeeper::Timekeeper() : offset( { 0, 0 } ) {}
-
-Timekeeper::~Timekeeper() {}
-
-const timeval& Timekeeper::getOffset() const {
-	return offset;
-}
-
-Timekeeper* Timekeeper::instance() {
-	if (myinstance == nullptr) {
-		myinstance = new Timekeeper();
-	}
-	return myinstance;
-}
-
-void Timekeeper::setOffset(const timeval& offset) {
-	this->offset = offset;
-}
-
-timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
-	timeval uptime;
-	uptime.tv_sec = ticks / configTICK_RATE_HZ;
-
-	//TODO explain, think about overflow
-	uint32_t subsecondTicks = ticks % configTICK_RATE_HZ;
-	uint64_t usecondTicks = subsecondTicks * 1000000;
-
-	uptime.tv_usec = usecondTicks / configTICK_RATE_HZ;
-
-	return uptime;
-}
-
-TickType_t Timekeeper::getTicks() {
-    return xTaskGetTickCount();
-}
+#include "../../osal/FreeRTOS/Timekeeper.h"
+
+#include "FreeRTOSConfig.h"
+
+Timekeeper * Timekeeper::myinstance = nullptr;
+
+Timekeeper::Timekeeper() : offset( { 0, 0 } ) {}
+
+Timekeeper::~Timekeeper() {}
+
+const timeval& Timekeeper::getOffset() const {
+	return offset;
+}
+
+Timekeeper* Timekeeper::instance() {
+	if (myinstance == nullptr) {
+		myinstance = new Timekeeper();
+	}
+	return myinstance;
+}
+
+void Timekeeper::setOffset(const timeval& offset) {
+	this->offset = offset;
+}
+
+timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
+	timeval uptime;
+	uptime.tv_sec = ticks / configTICK_RATE_HZ;
+
+	//TODO explain, think about overflow
+	uint32_t subsecondTicks = ticks % configTICK_RATE_HZ;
+	uint64_t usecondTicks = subsecondTicks * 1000000;
+
+	uptime.tv_usec = usecondTicks / configTICK_RATE_HZ;
+
+	return uptime;
+}
+
+TickType_t Timekeeper::getTicks() {
+    return xTaskGetTickCount();
+}
diff --git a/osal/FreeRTOS/Timekeeper.h b/osal/FreeRTOS/Timekeeper.h
index 7d3ca22b7..fc1664e20 100644
--- a/osal/FreeRTOS/Timekeeper.h
+++ b/osal/FreeRTOS/Timekeeper.h
@@ -1,40 +1,40 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
-#define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
-
-#include <framework/timemanager/Clock.h>
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-
-/**
- * A Class to basically store the time difference between uptime and UTC
- * so the "time-agnostic" FreeRTOS can keep an UTC Time
- *
- * Implemented as Singleton, so the FSFW Clock Implementation (see Clock.cpp)
- * can use it without having a member.
- */
-
-class Timekeeper {
-private:
-	Timekeeper();
-
-	timeval offset;
-
-	static Timekeeper * myinstance;
-public:
-	static Timekeeper * instance();
-	virtual ~Timekeeper();
-
-	static timeval ticksToTimeval(TickType_t ticks);
-    /**
-     * Get elapsed time in system ticks.
-     * @return
-     */
-    static TickType_t getTicks();
-
-	const timeval& getOffset() const;
-	void setOffset(const timeval& offset);
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
+#define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
+
+#include "../../timemanager/Clock.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+
+/**
+ * A Class to basically store the time difference between uptime and UTC
+ * so the "time-agnostic" FreeRTOS can keep an UTC Time
+ *
+ * Implemented as Singleton, so the FSFW Clock Implementation (see Clock.cpp)
+ * can use it without having a member.
+ */
+
+class Timekeeper {
+private:
+	Timekeeper();
+
+	timeval offset;
+
+	static Timekeeper * myinstance;
+public:
+	static Timekeeper * instance();
+	virtual ~Timekeeper();
+
+	static timeval ticksToTimeval(TickType_t ticks);
+    /**
+     * Get elapsed time in system ticks.
+     * @return
+     */
+    static TickType_t getTicks();
+
+	const timeval& getOffset() const;
+	void setOffset(const timeval& offset);
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ */
diff --git a/osal/InternalErrorCodes.h b/osal/InternalErrorCodes.h
index 5419fd94d..d89eb230f 100644
--- a/osal/InternalErrorCodes.h
+++ b/osal/InternalErrorCodes.h
@@ -1,39 +1,39 @@
-#ifndef INTERNALERRORCODES_H_
-#define INTERNALERRORCODES_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-class InternalErrorCodes {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::INTERNAL_ERROR_CODES;
-
-static const ReturnValue_t NO_CONFIGURATION_TABLE = MAKE_RETURN_CODE(0x01 );
-static const ReturnValue_t NO_CPU_TABLE = MAKE_RETURN_CODE(0x02 );
-static const ReturnValue_t INVALID_WORKSPACE_ADDRESS = MAKE_RETURN_CODE(0x03 );
-static const ReturnValue_t TOO_LITTLE_WORKSPACE = MAKE_RETURN_CODE(0x04 );
-static const ReturnValue_t WORKSPACE_ALLOCATION = MAKE_RETURN_CODE(0x05 );
-static const ReturnValue_t INTERRUPT_STACK_TOO_SMALL = MAKE_RETURN_CODE(0x06 );
-static const ReturnValue_t THREAD_EXITTED = MAKE_RETURN_CODE(0x07 );
-static const ReturnValue_t INCONSISTENT_MP_INFORMATION = MAKE_RETURN_CODE(0x08 );
-static const ReturnValue_t INVALID_NODE = MAKE_RETURN_CODE(0x09 );
-static const ReturnValue_t NO_MPCI = MAKE_RETURN_CODE(0x0a );
-static const ReturnValue_t BAD_PACKET = MAKE_RETURN_CODE(0x0b );
-static const ReturnValue_t OUT_OF_PACKETS = MAKE_RETURN_CODE(0x0c );
-static const ReturnValue_t OUT_OF_GLOBAL_OBJECTS = MAKE_RETURN_CODE(0x0d );
-static const ReturnValue_t OUT_OF_PROXIES = MAKE_RETURN_CODE(0x0e );
-static const ReturnValue_t INVALID_GLOBAL_ID = MAKE_RETURN_CODE(0x0f );
-static const ReturnValue_t BAD_STACK_HOOK = MAKE_RETURN_CODE(0x10 );
-static const ReturnValue_t BAD_ATTRIBUTES = MAKE_RETURN_CODE(0x11 );
-static const ReturnValue_t IMPLEMENTATION_KEY_CREATE_INCONSISTENCY = MAKE_RETURN_CODE(0x12 );
-static const ReturnValue_t IMPLEMENTATION_BLOCKING_OPERATION_CANCEL = MAKE_RETURN_CODE(0x13 );
-static const ReturnValue_t MUTEX_OBTAIN_FROM_BAD_STATE = MAKE_RETURN_CODE(0x14 );
-static const ReturnValue_t UNLIMITED_AND_MAXIMUM_IS_0 = MAKE_RETURN_CODE(0x15 );
-
-	virtual ~InternalErrorCodes();
-
-	static ReturnValue_t translate(uint8_t code);
-private:
-	InternalErrorCodes();
-};
-
-#endif /* INTERNALERRORCODES_H_ */
+#ifndef INTERNALERRORCODES_H_
+#define INTERNALERRORCODES_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class InternalErrorCodes {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::INTERNAL_ERROR_CODES;
+
+static const ReturnValue_t NO_CONFIGURATION_TABLE = MAKE_RETURN_CODE(0x01 );
+static const ReturnValue_t NO_CPU_TABLE = MAKE_RETURN_CODE(0x02 );
+static const ReturnValue_t INVALID_WORKSPACE_ADDRESS = MAKE_RETURN_CODE(0x03 );
+static const ReturnValue_t TOO_LITTLE_WORKSPACE = MAKE_RETURN_CODE(0x04 );
+static const ReturnValue_t WORKSPACE_ALLOCATION = MAKE_RETURN_CODE(0x05 );
+static const ReturnValue_t INTERRUPT_STACK_TOO_SMALL = MAKE_RETURN_CODE(0x06 );
+static const ReturnValue_t THREAD_EXITTED = MAKE_RETURN_CODE(0x07 );
+static const ReturnValue_t INCONSISTENT_MP_INFORMATION = MAKE_RETURN_CODE(0x08 );
+static const ReturnValue_t INVALID_NODE = MAKE_RETURN_CODE(0x09 );
+static const ReturnValue_t NO_MPCI = MAKE_RETURN_CODE(0x0a );
+static const ReturnValue_t BAD_PACKET = MAKE_RETURN_CODE(0x0b );
+static const ReturnValue_t OUT_OF_PACKETS = MAKE_RETURN_CODE(0x0c );
+static const ReturnValue_t OUT_OF_GLOBAL_OBJECTS = MAKE_RETURN_CODE(0x0d );
+static const ReturnValue_t OUT_OF_PROXIES = MAKE_RETURN_CODE(0x0e );
+static const ReturnValue_t INVALID_GLOBAL_ID = MAKE_RETURN_CODE(0x0f );
+static const ReturnValue_t BAD_STACK_HOOK = MAKE_RETURN_CODE(0x10 );
+static const ReturnValue_t BAD_ATTRIBUTES = MAKE_RETURN_CODE(0x11 );
+static const ReturnValue_t IMPLEMENTATION_KEY_CREATE_INCONSISTENCY = MAKE_RETURN_CODE(0x12 );
+static const ReturnValue_t IMPLEMENTATION_BLOCKING_OPERATION_CANCEL = MAKE_RETURN_CODE(0x13 );
+static const ReturnValue_t MUTEX_OBTAIN_FROM_BAD_STATE = MAKE_RETURN_CODE(0x14 );
+static const ReturnValue_t UNLIMITED_AND_MAXIMUM_IS_0 = MAKE_RETURN_CODE(0x15 );
+
+	virtual ~InternalErrorCodes();
+
+	static ReturnValue_t translate(uint8_t code);
+private:
+	InternalErrorCodes();
+};
+
+#endif /* INTERNALERRORCODES_H_ */
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 57f2572b1..52d0d5f0e 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -1,227 +1,227 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/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;
-}
+#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;
+}
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index dac399f6b..1999c9e62 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -1,191 +1,191 @@
-#include <framework/osal/host/FixedTimeslotTask.h>
-
-#include <framework/ipc/MutexFactory.h>
-#include <framework/osal/host/Mutex.h>
-#include <framework/osal/host/FixedTimeslotTask.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/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() {
-    // A local iterator for the Polling Sequence Table is created to
-    // find the start time for the first entry.
-    FixedSlotSequence::SlotListIter 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) {
-    if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, 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;
-
-}
-
-
-
-
+#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() {
+    // A local iterator for the Polling Sequence Table is created to
+    // find the start time for the first entry.
+    FixedSlotSequence::SlotListIter 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) {
+    if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, 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;
+
+}
+
+
+
+
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index b12cc6d3d..bbee94a63 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -1,130 +1,130 @@
-#ifndef FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/FixedSlotSequence.h>
-#include <framework/tasks/FixedTimeslotTaskIF.h>
-#include <framework/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;
-
-    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_ */
+#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;
+
+    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_ */
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 7af5fbd90..6fd428494 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -1,155 +1,155 @@
-#include <framework/osal/host/MessageQueue.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/host/QueueMapManager.h>
-#include <framework/ipc/MutexFactory.h>
-#include <framework/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: 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, 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, 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(dur_millis_t lockTimeout) {
-	return queueLock->lockMutex(lockTimeout);
-}
-
-ReturnValue_t MessageQueue::unlockQueue() {
-	return queueLock->unlockMutex();
-}
+#include "../../osal/host/MessageQueue.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/host/QueueMapManager.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: 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, 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, 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(dur_millis_t lockTimeout) {
+	return queueLock->lockMutex(lockTimeout);
+}
+
+ReturnValue_t MessageQueue::unlockQueue() {
+	return queueLock->unlockMutex();
+}
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
index 7fc77f7aa..d2da24022 100644
--- a/osal/host/MessageQueue.h
+++ b/osal/host/MessageQueue.h
@@ -1,230 +1,230 @@
-#ifndef FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
-#define FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
-
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/ipc/MutexIF.h>
-#include <framework/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(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_ */
+#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(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_ */
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index 03948c4cf..28768507c 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -1,40 +1,40 @@
-#include <framework/osal/host/Mutex.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-const uint32_t MutexIF::POLLING = 0;
-const uint32_t MutexIF::BLOCKING = 0xffffffff;
-
-ReturnValue_t Mutex::lockMutex(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;
-}
+#include "../../osal/host/Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t MutexIF::POLLING = 0;
+const uint32_t MutexIF::BLOCKING = 0xffffffff;
+
+ReturnValue_t Mutex::lockMutex(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;
+}
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index d882c457b..4d49bac7e 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -1,28 +1,28 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
-#define FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
-
-#include <framework/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() = default;
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
-	ReturnValue_t unlockMutex() override;
-
-	std::timed_mutex* getMutexHandle();
-private:
-	bool locked = false;
-	std::timed_mutex mutex;
-};
-
-#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
+#define FRAMEWORK_OSAL_FREERTOS_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() = default;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
+	ReturnValue_t unlockMutex() override;
+
+	std::timed_mutex* getMutexHandle();
+private:
+	bool locked = false;
+	std::timed_mutex mutex;
+};
+
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/osal/host/MutexFactory.cpp b/osal/host/MutexFactory.cpp
index 25d9fa467..284ce59f7 100644
--- a/osal/host/MutexFactory.cpp
+++ b/osal/host/MutexFactory.cpp
@@ -1,28 +1,28 @@
-#include <framework/ipc/MutexFactory.h>
-#include <framework/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;
-}
+#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;
+}
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 1a5024abf..c4cf9f569 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -1,176 +1,176 @@
-#include <framework/ipc/MutexFactory.h>
-#include <framework/osal/host/Mutex.h>
-#include <framework/osal/host/PeriodicTask.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/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;
-
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/host/Mutex.h"
+#include "../../osal/host/PeriodicTask.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;
+
+}
diff --git a/osal/host/PeriodicTask.h b/osal/host/PeriodicTask.h
index d97bf0890..7eb768cb6 100644
--- a/osal/host/PeriodicTask.h
+++ b/osal/host/PeriodicTask.h
@@ -1,123 +1,123 @@
-#ifndef FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
-#define FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
-#include <framework/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_ */
+#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_ */
diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
index 225bb8c79..052671caf 100644
--- a/osal/host/QueueFactory.cpp
+++ b/osal/host/QueueFactory.cpp
@@ -1,41 +1,41 @@
-#include <framework/ipc/QueueFactory.h>
-#include <framework/osal/host/MessageQueue.h>
-#include <framework/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;
-}
+#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;
+}
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 89b9a948f..35db204e8 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -1,51 +1,51 @@
-#include <framework/ipc/MutexFactory.h>
-#include <framework/ipc/MutexHelper.h>
-#include <framework/osal/host/QueueMapManager.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, 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;
-	}
-}
-
+#include "../../ipc/MutexFactory.h"
+#include "../../ipc/MutexHelper.h"
+#include "../../osal/host/QueueMapManager.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, 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;
+	}
+}
+
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
index a2a1b6581..acf203898 100644
--- a/osal/host/QueueMapManager.h
+++ b/osal/host/QueueMapManager.h
@@ -1,47 +1,47 @@
-#ifndef FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
-#define FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
-
-#include <framework/ipc/MessageQueueSenderIF.h>
-#include <framework/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 /* FRAMEWORK_OSAL_HOST_QUEUEMAP_H_ */
+#ifndef FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
+#define FRAMEWORK_OSAL_HOST_QUEUEMAP_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 /* FRAMEWORK_OSAL_HOST_QUEUEMAP_H_ */
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index 0c077f689..580404288 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -1,42 +1,42 @@
-#include <framework/tasks/SemaphoreFactory.h>
-#include <framework/osal/linux/BinarySemaphore.h>
-#include <framework/osal/linux/CountingSemaphore.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = 0xFFFFFFFF;
-
-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;
-}
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../osal/linux/BinarySemaphore.h"
+#include "../../osal/linux/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t SemaphoreIF::POLLING = 0;
+const uint32_t SemaphoreIF::BLOCKING = 0xFFFFFFFF;
+
+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;
+}
diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
index 9db8ac4d3..3f527130e 100644
--- a/osal/host/TaskFactory.cpp
+++ b/osal/host/TaskFactory.cpp
@@ -1,55 +1,55 @@
-#include <framework/osal/host/FixedTimeslotTask.h>
-#include <framework/osal/host/PeriodicTask.h>
-#include <framework/tasks/TaskFactory.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/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_) {
-	// This is going to be interesting. Time now learn the C++ threading library
-	// :-)
-	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
-			deadLineMissedFunction_);
-}
-
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	// This is going to be interesting. Time now learn the C++ threading library
-	// :-)
-	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;
-}
-
-
+#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_) {
+	// This is going to be interesting. Time now learn the C++ threading library
+	// :-)
+	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
+			deadLineMissedFunction_);
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	// This is going to be interesting. Time now learn the C++ threading library
+	// :-)
+	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;
+}
+
+
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index e2ad9b58a..37947b268 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -1,5 +1,5 @@
-#include <framework/osal/linux/BinarySemaphore.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../../osal/linux/BinarySemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
 
 extern "C" {
 #include <errno.h>
diff --git a/osal/linux/BinarySemaphore.h b/osal/linux/BinarySemaphore.h
index 9d4ed1cd4..9ac9ba7f9 100644
--- a/osal/linux/BinarySemaphore.h
+++ b/osal/linux/BinarySemaphore.h
@@ -1,8 +1,8 @@
 #ifndef FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
 #define FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/SemaphoreIF.h>
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/SemaphoreIF.h"
 
 extern "C" {
 #include <semaphore.h>
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index eda5b7af5..370c77f7f 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,220 +1,220 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/timemanager/Clock.h>
-
-#include <sys/time.h>
-#include <sys/sysinfo.h>
-#include <linux/sysinfo.h>
-#include <time.h>
-#include <unistd.h>
-
-//#include <fstream>
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
-uint32_t Clock::getTicksPerSecond(void){
-	uint32_t ticks = sysconf(_SC_CLK_TCK);
-	return ticks;
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-	timespec timeUnix;
-	timeval timeTimeval;
-	convertTimeOfDayToTimeval(time,&timeTimeval);
-	timeUnix.tv_sec = timeTimeval.tv_sec;
-	timeUnix.tv_nsec = (__syscall_slong_t) timeTimeval.tv_usec * 1000;
-
-	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
-	if(status!=0){
-		//TODO errno
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	timespec timeUnix;
-	timeUnix.tv_sec = time->tv_sec;
-	timeUnix.tv_nsec = (__syscall_slong_t) time->tv_usec * 1000;
-	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
-	if(status!=0){
-		//TODO errno
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	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;
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval timeVal;
-	ReturnValue_t result = getClock_timeval(&timeVal);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
-	*time = (uint64_t)timeVal.tv_sec*1e6 + timeVal.tv_usec;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-timeval Clock::getUptime() {
-	timeval uptime;
-	auto result = getUptime(&uptime);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
-	}
-	return uptime;
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	//TODO This is not posix compatible and delivers only seconds precision
-	struct sysinfo sysInfo;
-	int result = sysinfo(&sysInfo);
-	if(result != 0){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	uptime->tv_sec = sysInfo.uptime;
-	uptime->tv_usec = 0;
-
-
-	//Linux specific file read but more precise
-//	double uptimeSeconds;
-//	if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
-//		uptime->tv_sec = uptimeSeconds;
-//		uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
-//	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	timeval uptime;
-	ReturnValue_t result = getUptime(&uptime);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
-	*uptimeMs = uptime.tv_sec * 1e3 + uptime.tv_usec / 1e3;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	timespec timeUnix;
-	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
-	if(status != 0){
-		//TODO errno
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	struct tm* timeInfo;
-	timeInfo = gmtime(&timeUnix.tv_sec);
-	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;
-	time->usecond = timeUnix.tv_nsec / 1000.0;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-
-	tm fromTm;
-	//Note: Fails for years before AD
-	fromTm.tm_year = from->year - 1900;
-	fromTm.tm_mon = from->month - 1;
-	fromTm.tm_mday = from->day;
-	fromTm.tm_hour = from->hour;
-	fromTm.tm_min = from->minute;
-	fromTm.tm_sec = from->second;
-
-	to->tv_sec = mktime(&fromTm);
-	to->tv_usec = from->usecond;
-	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==NULL){
-		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==NULL){
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Clock.h"
+
+#include <sys/time.h>
+#include <sys/sysinfo.h>
+#include <linux/sysinfo.h>
+#include <time.h>
+#include <unistd.h>
+
+//#include <fstream>
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
+uint32_t Clock::getTicksPerSecond(void){
+	uint32_t ticks = sysconf(_SC_CLK_TCK);
+	return ticks;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+	timespec timeUnix;
+	timeval timeTimeval;
+	convertTimeOfDayToTimeval(time,&timeTimeval);
+	timeUnix.tv_sec = timeTimeval.tv_sec;
+	timeUnix.tv_nsec = (__syscall_slong_t) timeTimeval.tv_usec * 1000;
+
+	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		//TODO errno
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	timespec timeUnix;
+	timeUnix.tv_sec = time->tv_sec;
+	timeUnix.tv_nsec = (__syscall_slong_t) time->tv_usec * 1000;
+	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		//TODO errno
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+	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;
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	timeval timeVal;
+	ReturnValue_t result = getClock_timeval(&timeVal);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+	*time = (uint64_t)timeVal.tv_sec*1e6 + timeVal.tv_usec;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+timeval Clock::getUptime() {
+	timeval uptime;
+	auto result = getUptime(&uptime);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
+	}
+	return uptime;
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	//TODO This is not posix compatible and delivers only seconds precision
+	struct sysinfo sysInfo;
+	int result = sysinfo(&sysInfo);
+	if(result != 0){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	uptime->tv_sec = sysInfo.uptime;
+	uptime->tv_usec = 0;
+
+
+	//Linux specific file read but more precise
+//	double uptimeSeconds;
+//	if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
+//		uptime->tv_sec = uptimeSeconds;
+//		uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
+//	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	timeval uptime;
+	ReturnValue_t result = getUptime(&uptime);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+	*uptimeMs = uptime.tv_sec * 1e3 + uptime.tv_usec / 1e3;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	timespec timeUnix;
+	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
+	if(status != 0){
+		//TODO errno
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	struct tm* timeInfo;
+	timeInfo = gmtime(&timeUnix.tv_sec);
+	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;
+	time->usecond = timeUnix.tv_nsec / 1000.0;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+
+	tm fromTm;
+	//Note: Fails for years before AD
+	fromTm.tm_year = from->year - 1900;
+	fromTm.tm_mon = from->month - 1;
+	fromTm.tm_mday = from->day;
+	fromTm.tm_hour = from->hour;
+	fromTm.tm_min = from->minute;
+	fromTm.tm_sec = from->second;
+
+	to->tv_sec = mktime(&fromTm);
+	to->tv_usec = from->usecond;
+	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==NULL){
+		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==NULL){
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
index dfc4d8013..ef32539b3 100644
--- a/osal/linux/CountingSemaphore.cpp
+++ b/osal/linux/CountingSemaphore.cpp
@@ -1,54 +1,54 @@
-#include <framework/osal/linux/CountingSemaphore.h>
-#include <framework/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;
-}
-
+#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;
+}
+
diff --git a/osal/linux/CountingSemaphore.h b/osal/linux/CountingSemaphore.h
index ba6065955..afe21a614 100644
--- a/osal/linux/CountingSemaphore.h
+++ b/osal/linux/CountingSemaphore.h
@@ -1,37 +1,37 @@
-#ifndef FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
-#define FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
-#include <framework/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_ */
+#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_ */
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 9d7d08f68..60ce9a63c 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -1,91 +1,91 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/linux/FixedTimeslotTask.h>
-
-#include <limits.h>
-
-uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
-
-FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_,
-		size_t stackSize_, uint32_t periodMs_):
-		PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
-}
-
-FixedTimeslotTask::~FixedTimeslotTask() {
-
-}
-
-void* FixedTimeslotTask::taskEntryPoint(void* arg) {
-	//The argument is re-interpreted as PollingTask.
-	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-	return nullptr;
-}
-
-ReturnValue_t FixedTimeslotTask::startTask() {
-	started = true;
-	createTask(&taskEntryPoint,this);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
-	return PosixThread::sleep((uint64_t)ms*1000000);
-}
-
-uint32_t FixedTimeslotTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::dec << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
-	return pst.checkSequence();
-}
-
-void FixedTimeslotTask::taskFunctionality() {
-	//Like FreeRTOS pthreads are running as soon as they are created
-	if (!started) {
-		suspend();
-	}
-	//The start time for the first entry is read.
-	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
-	uint64_t interval = pst.getIntervalToNextSlotMs();
-
-
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		} else {
-			//The interval for the next polling slot is selected.
-			interval = this->pst.getIntervalToPreviousSlotMs();
-			//The period is checked and restarted with the new interval.
-			//If the deadline was missed, the deadlineMissedFunc is called.
-			if(!PosixThread::delayUntil(&lastWakeTime,interval)) {
-				//No time left on timer -> we missed the deadline
-				missedDeadlineCounter();
-			}
-		}
-		//The device handler for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-	}
-}
-
-void FixedTimeslotTask::missedDeadlineCounter() {
-	FixedTimeslotTask::deadlineMissedCount++;
-	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
-				   << " deadlines." << std::endl;
-	}
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/FixedTimeslotTask.h"
+
+#include <limits.h>
+
+uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
+
+FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_,
+		size_t stackSize_, uint32_t periodMs_):
+		PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
+}
+
+FixedTimeslotTask::~FixedTimeslotTask() {
+
+}
+
+void* FixedTimeslotTask::taskEntryPoint(void* arg) {
+	//The argument is re-interpreted as PollingTask.
+	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
+	//The task's functionality is called.
+	originalTask->taskFunctionality();
+	return nullptr;
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+	started = true;
+	createTask(&taskEntryPoint,this);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
+	return PosixThread::sleep((uint64_t)ms*1000000);
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+	return pst.getLengthMs();
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+		uint32_t slotTimeMs, int8_t executionStep) {
+	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::dec << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+	return pst.checkSequence();
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+	//Like FreeRTOS pthreads are running as soon as they are created
+	if (!started) {
+		suspend();
+	}
+	//The start time for the first entry is read.
+	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
+	uint64_t interval = pst.getIntervalToNextSlotMs();
+
+
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		if (pst.slotFollowsImmediately()) {
+			//Do nothing
+		} else {
+			//The interval for the next polling slot is selected.
+			interval = this->pst.getIntervalToPreviousSlotMs();
+			//The period is checked and restarted with the new interval.
+			//If the deadline was missed, the deadlineMissedFunc is called.
+			if(!PosixThread::delayUntil(&lastWakeTime,interval)) {
+				//No time left on timer -> we missed the deadline
+				missedDeadlineCounter();
+			}
+		}
+		//The device handler for this slot is executed and the next one is chosen.
+		this->pst.executeAndAdvance();
+	}
+}
+
+void FixedTimeslotTask::missedDeadlineCounter() {
+	FixedTimeslotTask::deadlineMissedCount++;
+	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
+				   << " deadlines." << std::endl;
+	}
+}
diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 409cd9821..83bf203e0 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
-
-#include <framework/tasks/FixedTimeslotTaskIF.h>
-#include <framework/tasks/FixedSlotSequence.h>
-#include <framework/osal/linux/PosixThread.h>
-#include <pthread.h>
-
-class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
-public:
-	/**
-	 * Create a generic periodic task.
-	 * @param name_
-	 * Name, maximum allowed size of linux is 16 chars, everything else will
-	 * be truncated.
-	 * @param priority_
-	 * Real-time priority, ranges from 1 to 99 for Linux.
-	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
-	 * @param stackSize_
-	 * @param period_
-	 * @param deadlineMissedFunc_
-	 */
-	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
-			uint32_t periodMs_);
-	virtual ~FixedTimeslotTask();
-
-	virtual ReturnValue_t startTask();
-
-	virtual ReturnValue_t sleepFor(uint32_t ms);
-
-	virtual uint32_t getPeriodMs() const;
-
-	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-			int8_t executionStep);
-
-	virtual ReturnValue_t checkSequence() const;
-
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-	 */
-	static void missedDeadlineCounter();
-
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-protected:
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 * @details
-	 * Holding the main functionality of the task, this method is most important.
-	 * It links the functionalities provided by FixedSlotSequence with the
-	 * OS's System Calls to keep the timing of the periods.
-	 */
-	virtual void taskFunctionality();
-
-private:
-	/**
-	 * @brief	This is the entry point in a new thread.
-	 *
-	 * @details
-	 * This method, that is the entry point in the new thread and calls
-	 * taskFunctionality of the child class. Needs a valid pointer to the
-	 * derived class.
-	 *
-	 * The void* returnvalue is not used yet but could be used to return
-	 * arbitrary data.
-	 */
-	static void* taskEntryPoint(void* arg);
-	FixedSlotSequence pst;
-
-	bool started;
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
+
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../osal/linux/PosixThread.h"
+#include <pthread.h>
+
+class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
+public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
+	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t periodMs_);
+	virtual ~FixedTimeslotTask();
+
+	virtual ReturnValue_t startTask();
+
+	virtual ReturnValue_t sleepFor(uint32_t ms);
+
+	virtual uint32_t getPeriodMs() const;
+
+	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+			int8_t executionStep);
+
+	virtual ReturnValue_t checkSequence() const;
+
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+	 */
+	static void missedDeadlineCounter();
+
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+protected:
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 * @details
+	 * Holding the main functionality of the task, this method is most important.
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
+	 */
+	virtual void taskFunctionality();
+
+private:
+	/**
+	 * @brief	This is the entry point in a new thread.
+	 *
+	 * @details
+	 * This method, that is the entry point in the new thread and calls
+	 * taskFunctionality of the child class. Needs a valid pointer to the
+	 * derived class.
+	 *
+	 * The void* returnvalue is not used yet but could be used to return
+	 * arbitrary data.
+	 */
+	static void* taskEntryPoint(void* arg);
+	FixedSlotSequence pst;
+
+	bool started;
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */
diff --git a/osal/linux/InternalErrorCodes.cpp b/osal/linux/InternalErrorCodes.cpp
index 7f83663b1..724cb4bc6 100644
--- a/osal/linux/InternalErrorCodes.cpp
+++ b/osal/linux/InternalErrorCodes.cpp
@@ -1,14 +1,14 @@
-#include <framework/osal/InternalErrorCodes.h>
-
-ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
-	//TODO This class can be removed
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-InternalErrorCodes::InternalErrorCodes() {
-}
-
-InternalErrorCodes::~InternalErrorCodes() {
-	
-}
-
+#include "../../osal/InternalErrorCodes.h"
+
+ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
+	//TODO This class can be removed
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+InternalErrorCodes::InternalErrorCodes() {
+}
+
+InternalErrorCodes::~InternalErrorCodes() {
+	
+}
+
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 236e61b6a..97c895520 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,369 +1,369 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/linux/MessageQueue.h>
-
-#include <fstream>
-
-#include <fcntl.h>           /* For O_* constants */
-#include <sys/stat.h>        /* For mode constants */
-#include <cstring>
-#include <errno.h>
-
-
-MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
-		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
-		defaultDestination(MessageQueueIF::NO_QUEUE),
-		maxMessageSize(maxMessageSize) {
-	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
-	mq_attr attributes;
-	this->id = 0;
-	//Set attributes
-	attributes.mq_curmsgs = 0;
-	attributes.mq_maxmsg = messageDepth;
-	attributes.mq_msgsize = maxMessageSize;
-	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
-	//Set the name of the queue. The slash is mandatory!
-	sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
-
-	// Create a nonblocking queue if the name is available (the queue is read
-	// and writable for the owner as well as the group)
-	int oflag = O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL;
-	mode_t mode = S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH;
-	mqd_t tempId = mq_open(name, oflag, mode, &attributes);
-	if (tempId == -1) {
-		handleError(&attributes, messageDepth);
-	}
-	else {
-		//Successful mq_open call
-		this->id = tempId;
-	}
-}
-
-MessageQueue::~MessageQueue() {
-	int status = mq_close(this->id);
-	if(status != 0){
-		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
-				   << strerror(errno) <<std::endl;
-	}
-	status = mq_unlink(name);
-	if(status != 0){
-		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
-				   << strerror(errno) << std::endl;
-	}
-}
-
-ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
-		uint32_t messageDepth) {
-	switch(errno) {
-	case(EINVAL): {
-		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
-				" for message size" << std::endl;
-		size_t defaultMqMaxMsg = 0;
-		// Not POSIX conformant, but should work for all UNIX systems.
-		// Just an additional helpful printout :-)
-		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
-				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
-			/*
-			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
-			This happens if the msg_max value is not large enough
-			It is ignored if the executable is run in privileged mode.
-		    Run the unlockRealtime script or grant the mode manually by using:
-			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
-
-			Persistent solution for session:
-			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
-
-			Permanent solution:
-			sudo nano /etc/sysctl.conf
-			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
-			Apply changes with: sudo sysctl -p
-			*/
-			sif::error << "MessageQueue::MessageQueue: Default MQ size "
-					<< defaultMqMaxMsg << " is too small for requested size "
-					<< messageDepth << std::endl;
-			sif::error << "This error can be fixed by setting the maximum "
-					"allowed message size higher!" << std::endl;
-
-		}
-		break;
-	}
-	case(EEXIST): {
-		// An error occured during open
-		// We need to distinguish if it is caused by an already created queue
-		//There's another queue with the same name
-		//We unlink the other queue
-		int status = mq_unlink(name);
-		if (status != 0) {
-			sif::error << "mq_unlink Failed with status: " << strerror(errno)
-													<< std::endl;
-		}
-		else {
-			// Successful unlinking, try to open again
-			mqd_t tempId = mq_open(name,
-					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
-			if (tempId != -1) {
-				//Successful mq_open
-				this->id = tempId;
-				return HasReturnvaluesIF::RETURN_OK;
-			}
-		}
-		break;
-	}
-
-	default:
-		// Failed either the first time or the second time
-		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-		<< name << std::dec << " failed with status: "
-		<< strerror(errno) << std::endl;
-
-	}
-	return HasReturnvaluesIF::RETURN_FAILED;
-
-
-
-}
-
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, bool ignoreFault) {
-	return sendMessageFrom(sendTo, message, this->getId(), false);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
-	return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != 0) {
-		return sendMessageFrom(this->lastPartner, message, this->getId());
-	} else {
-		return NO_REPLY_PARTNER;
-	}
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
-		MessageQueueId_t* receivedFrom) {
-	ReturnValue_t status = this->receiveMessage(message);
-	*receivedFrom = this->lastPartner;
-	return status;
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
-	if(message == nullptr) {
-		sif::error << "MessageQueue::receiveMessage: Message is "
-				"nullptr!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(message->getMaximumMessageSize() < maxMessageSize) {
-		sif::error << "MessageQueue::receiveMessage: Message size "
-				<< message->getMaximumMessageSize()
-				<< " too small to receive data!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	unsigned int messagePriority = 0;
-	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
-			message->getMaximumMessageSize(),&messagePriority);
-	if (status > 0) {
-		this->lastPartner = message->getSender();
-		//Check size of incoming message.
-		if (message->getMessageSize() < message->getMinimumMessageSize()) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}else if(status==0){
-		//Success but no message received
-		return MessageQueueIF::EMPTY;
-	} else {
-		//No message was received. Keep lastPartner anyway, I might send
-		//something later. But still, delete packet content.
-		memset(message->getData(), 0, message->getMaximumMessageSize());
-		switch(errno){
-		case EAGAIN:
-			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
-			//currently on the specified queue.
-			return MessageQueueIF::EMPTY;
-		case EBADF:
-			//mqdes doesn't represent a valid queue open for reading.
-			sif::error << "MessageQueue::receive: configuration error "
-			           << strerror(errno)  << std::endl;
-			/*NO BREAK*/
-		case EINVAL:
-			/*
-			 * This value indicates one of the following:
-			 * - The pointer to the buffer for storing the received message,
-			 *   msg_ptr, is NULL.
-			 * - The number of bytes requested, msg_len is less than zero.
-			 * - msg_len is anything other than the mq_msgsize of the specified
-			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
-			 *   been set in the queue's mq_flags.
-			 */
-			sif::error << "MessageQueue::receive: configuration error "
-					   << strerror(errno)  << std::endl;
-			/*NO BREAK*/
-		case EMSGSIZE:
-			/*
-			 * This value indicates one of the following:
-			 * - the QNX extended option MQ_READBUF_DYNAMIC hasn't been set,
-			 *   and the given msg_len is shorter than the mq_msgsize for
-			 *   the given queue.
-			 * - the extended option MQ_READBUF_DYNAMIC has been set, but the
-			 *   given msg_len is too short for the message that would have
-			 *   been received.
-			 */
-			sif::error << "MessageQueue::receive: configuration error "
-			           << strerror(errno)  << std::endl;
-			/*NO BREAK*/
-		case EINTR:
-			//The operation was interrupted by a signal.
-		default:
-
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-
-	}
-}
-
-MessageQueueId_t MessageQueue::getLastPartner() const {
-	return this->lastPartner;
-}
-
-ReturnValue_t MessageQueue::flush(uint32_t* count) {
-	mq_attr attrib;
-	int status = mq_getattr(id,&attrib);
-	if(status != 0){
-		switch(errno){
-		case EBADF:
-			//mqdes doesn't represent a valid message queue.
-			sif::error << "MessageQueue::flush configuration error, "
-					"called flush with an invalid queue ID" << std::endl;
-			/*NO BREAK*/
-		case EINVAL:
-			//mq_attr is NULL
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	*count = attrib.mq_curmsgs;
-	attrib.mq_curmsgs = 0;
-	status = mq_setattr(id,&attrib,NULL);
-	if(status != 0){
-		switch(errno){
-		case EBADF:
-			//mqdes doesn't represent a valid message queue.
-			sif::error << "MessageQueue::flush configuration error, "
-					"called flush with an invalid queue ID" << std::endl;
-			/*NO BREAK*/
-		case EINVAL:
-			/*
-			 * This value indicates one of the following:
-			 *  - mq_attr is NULL.
-			 *  - MQ_MULT_NOTIFY had been set for this queue, and the given
-			 *    mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once
-			 *    MQ_MULT_NOTIFY has been turned on, it may never be turned off.
-			 */
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t MessageQueue::getId() const {
-	return this->id;
-}
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-	this->defaultDestination = defaultDestination;
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
-}
-
-
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message, sentFrom,ignoreFault);
-
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const {
-	return this->defaultDestination;
-}
-
-bool MessageQueue::isDefaultDestinationSet() const {
-	return (defaultDestination != NO_QUEUE);
-}
-
-uint16_t MessageQueue::queueCounter = 0;
-
-ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	if(message == nullptr) {
-		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
-				"nullptr!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	message->setSender(sentFrom);
-	int result = mq_send(sendTo,
-			reinterpret_cast<const char*>(message->getBuffer()),
-			message->getMessageSize(),0);
-
-	//TODO: Check if we're in ISR.
-	if (result != 0) {
-		if(!ignoreFault){
-			InternalErrorReporterIF* internalErrorReporter =
-					objectManager->get<InternalErrorReporterIF>(
-						objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != NULL) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		switch(errno){
-		case EAGAIN:
-			//The O_NONBLOCK flag was set when opening the queue, or the
-			//MQ_NONBLOCK flag was set in its attributes, and the
-			//specified queue is full.
-			return MessageQueueIF::FULL;
-		case EBADF: {
-			//mq_des doesn't represent a valid message queue descriptor,
-			//or mq_des wasn't opened for writing.
-			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
-					<< " destination invalid."  << std::endl;
-			sif::error << strerror(errno) << " in "
-					<<"mq_send to: " << sendTo << " sent from "
-					<< sentFrom << std::endl;
-			return DESTINVATION_INVALID;
-		}
-		case EINTR:
-			//The call was interrupted by a signal.
-		case EINVAL:
-			/*
-			 * This value indicates one of the following:
-			 * - msg_ptr is NULL.
-			 * - msg_len is negative.
-			 * - msg_prio is greater than MQ_PRIO_MAX.
-			 * - msg_prio is less than 0.
-			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
-			 *   msg_prio is greater than the priority of the calling process.
-			 */
-			sif::error << "MessageQueue::sendMessage: Configuration error "
-			           << strerror(errno) << " in mq_send" << std::endl;
-			/*NO BREAK*/
-		case EMSGSIZE:
-			// The msg_len is greater than the msgsize associated with
-			//the specified queue.
-			sif::error << "MessageQueue::sendMessage: Size error [" <<
-					strerror(errno) << "] in mq_send" << std::endl;
-			/*NO BREAK*/
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/MessageQueue.h"
+
+#include <fstream>
+
+#include <fcntl.h>           /* For O_* constants */
+#include <sys/stat.h>        /* For mode constants */
+#include <cstring>
+#include <errno.h>
+
+
+MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
+		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
+		defaultDestination(MessageQueueIF::NO_QUEUE),
+		maxMessageSize(maxMessageSize) {
+	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
+	mq_attr attributes;
+	this->id = 0;
+	//Set attributes
+	attributes.mq_curmsgs = 0;
+	attributes.mq_maxmsg = messageDepth;
+	attributes.mq_msgsize = maxMessageSize;
+	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
+	//Set the name of the queue. The slash is mandatory!
+	sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
+
+	// Create a nonblocking queue if the name is available (the queue is read
+	// and writable for the owner as well as the group)
+	int oflag = O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL;
+	mode_t mode = S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH;
+	mqd_t tempId = mq_open(name, oflag, mode, &attributes);
+	if (tempId == -1) {
+		handleError(&attributes, messageDepth);
+	}
+	else {
+		//Successful mq_open call
+		this->id = tempId;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	int status = mq_close(this->id);
+	if(status != 0){
+		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
+				   << strerror(errno) <<std::endl;
+	}
+	status = mq_unlink(name);
+	if(status != 0){
+		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
+				   << strerror(errno) << std::endl;
+	}
+}
+
+ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
+		uint32_t messageDepth) {
+	switch(errno) {
+	case(EINVAL): {
+		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
+				" for message size" << std::endl;
+		size_t defaultMqMaxMsg = 0;
+		// Not POSIX conformant, but should work for all UNIX systems.
+		// Just an additional helpful printout :-)
+		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
+				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
+			/*
+			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
+			This happens if the msg_max value is not large enough
+			It is ignored if the executable is run in privileged mode.
+		    Run the unlockRealtime script or grant the mode manually by using:
+			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
+
+			Persistent solution for session:
+			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
+
+			Permanent solution:
+			sudo nano /etc/sysctl.conf
+			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
+			Apply changes with: sudo sysctl -p
+			*/
+			sif::error << "MessageQueue::MessageQueue: Default MQ size "
+					<< defaultMqMaxMsg << " is too small for requested size "
+					<< messageDepth << std::endl;
+			sif::error << "This error can be fixed by setting the maximum "
+					"allowed message size higher!" << std::endl;
+
+		}
+		break;
+	}
+	case(EEXIST): {
+		// An error occured during open
+		// We need to distinguish if it is caused by an already created queue
+		//There's another queue with the same name
+		//We unlink the other queue
+		int status = mq_unlink(name);
+		if (status != 0) {
+			sif::error << "mq_unlink Failed with status: " << strerror(errno)
+													<< std::endl;
+		}
+		else {
+			// Successful unlinking, try to open again
+			mqd_t tempId = mq_open(name,
+					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
+			if (tempId != -1) {
+				//Successful mq_open
+				this->id = tempId;
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+		break;
+	}
+
+	default:
+		// Failed either the first time or the second time
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+		<< name << std::dec << " failed with status: "
+		<< strerror(errno) << std::endl;
+
+	}
+	return HasReturnvaluesIF::RETURN_FAILED;
+
+
+
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), false);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+	if (this->lastPartner != 0) {
+		return sendMessageFrom(this->lastPartner, message, this->getId());
+	} else {
+		return NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	*receivedFrom = this->lastPartner;
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::receiveMessage: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(message->getMaximumMessageSize() < maxMessageSize) {
+		sif::error << "MessageQueue::receiveMessage: Message size "
+				<< message->getMaximumMessageSize()
+				<< " too small to receive data!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	unsigned int messagePriority = 0;
+	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
+			message->getMaximumMessageSize(),&messagePriority);
+	if (status > 0) {
+		this->lastPartner = message->getSender();
+		//Check size of incoming message.
+		if (message->getMessageSize() < message->getMinimumMessageSize()) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}else if(status==0){
+		//Success but no message received
+		return MessageQueueIF::EMPTY;
+	} else {
+		//No message was received. Keep lastPartner anyway, I might send
+		//something later. But still, delete packet content.
+		memset(message->getData(), 0, message->getMaximumMessageSize());
+		switch(errno){
+		case EAGAIN:
+			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
+			//currently on the specified queue.
+			return MessageQueueIF::EMPTY;
+		case EBADF:
+			//mqdes doesn't represent a valid queue open for reading.
+			sif::error << "MessageQueue::receive: configuration error "
+			           << strerror(errno)  << std::endl;
+			/*NO BREAK*/
+		case EINVAL:
+			/*
+			 * This value indicates one of the following:
+			 * - The pointer to the buffer for storing the received message,
+			 *   msg_ptr, is NULL.
+			 * - The number of bytes requested, msg_len is less than zero.
+			 * - msg_len is anything other than the mq_msgsize of the specified
+			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
+			 *   been set in the queue's mq_flags.
+			 */
+			sif::error << "MessageQueue::receive: configuration error "
+					   << strerror(errno)  << std::endl;
+			/*NO BREAK*/
+		case EMSGSIZE:
+			/*
+			 * This value indicates one of the following:
+			 * - the QNX extended option MQ_READBUF_DYNAMIC hasn't been set,
+			 *   and the given msg_len is shorter than the mq_msgsize for
+			 *   the given queue.
+			 * - the extended option MQ_READBUF_DYNAMIC has been set, but the
+			 *   given msg_len is too short for the message that would have
+			 *   been received.
+			 */
+			sif::error << "MessageQueue::receive: configuration error "
+			           << strerror(errno)  << std::endl;
+			/*NO BREAK*/
+		case EINTR:
+			//The operation was interrupted by a signal.
+		default:
+
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+	}
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return this->lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	mq_attr attrib;
+	int status = mq_getattr(id,&attrib);
+	if(status != 0){
+		switch(errno){
+		case EBADF:
+			//mqdes doesn't represent a valid message queue.
+			sif::error << "MessageQueue::flush configuration error, "
+					"called flush with an invalid queue ID" << std::endl;
+			/*NO BREAK*/
+		case EINVAL:
+			//mq_attr is NULL
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	*count = attrib.mq_curmsgs;
+	attrib.mq_curmsgs = 0;
+	status = mq_setattr(id,&attrib,NULL);
+	if(status != 0){
+		switch(errno){
+		case EBADF:
+			//mqdes doesn't represent a valid message queue.
+			sif::error << "MessageQueue::flush configuration error, "
+					"called flush with an invalid queue ID" << std::endl;
+			/*NO BREAK*/
+		case EINVAL:
+			/*
+			 * This value indicates one of the following:
+			 *  - mq_attr is NULL.
+			 *  - MQ_MULT_NOTIFY had been set for this queue, and the given
+			 *    mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once
+			 *    MQ_MULT_NOTIFY has been turned on, it may never be turned off.
+			 */
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return this->id;
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	this->defaultDestination = defaultDestination;
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
+}
+
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo,message, sentFrom,ignoreFault);
+
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return this->defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return (defaultDestination != NO_QUEUE);
+}
+
+uint16_t MessageQueue::queueCounter = 0;
+
+ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	message->setSender(sentFrom);
+	int result = mq_send(sendTo,
+			reinterpret_cast<const char*>(message->getBuffer()),
+			message->getMessageSize(),0);
+
+	//TODO: Check if we're in ISR.
+	if (result != 0) {
+		if(!ignoreFault){
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
+						objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != NULL) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		switch(errno){
+		case EAGAIN:
+			//The O_NONBLOCK flag was set when opening the queue, or the
+			//MQ_NONBLOCK flag was set in its attributes, and the
+			//specified queue is full.
+			return MessageQueueIF::FULL;
+		case EBADF: {
+			//mq_des doesn't represent a valid message queue descriptor,
+			//or mq_des wasn't opened for writing.
+			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
+					<< " destination invalid."  << std::endl;
+			sif::error << strerror(errno) << " in "
+					<<"mq_send to: " << sendTo << " sent from "
+					<< sentFrom << std::endl;
+			return DESTINVATION_INVALID;
+		}
+		case EINTR:
+			//The call was interrupted by a signal.
+		case EINVAL:
+			/*
+			 * This value indicates one of the following:
+			 * - msg_ptr is NULL.
+			 * - msg_len is negative.
+			 * - msg_prio is greater than MQ_PRIO_MAX.
+			 * - msg_prio is less than 0.
+			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
+			 *   msg_prio is greater than the priority of the calling process.
+			 */
+			sif::error << "MessageQueue::sendMessage: Configuration error "
+			           << strerror(errno) << " in mq_send" << std::endl;
+			/*NO BREAK*/
+		case EMSGSIZE:
+			// The msg_len is greater than the msgsize associated with
+			//the specified queue.
+			sif::error << "MessageQueue::sendMessage: Size error [" <<
+					strerror(errno) << "] in mq_send" << std::endl;
+			/*NO BREAK*/
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index 8e3a5191d..35d16e254 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -1,187 +1,187 @@
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
-
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
-
-#include <mqueue.h>
-/**
- * @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".
- *
- * The creation of message queues, as well as sending and receiving messages,
- * makes use of the operating system calls provided.
- *	@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 i 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(uint32_t messageDepth = 3,
-			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
-	/**
-	 * @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.
-	 */
-	virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false );
-	/**
-	 * @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.
-	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter 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 );
-
-	/**
-	 * @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);
-
-	/**
-	 * @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);
-	/**
-	 * 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);
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	MessageQueueId_t getId() const;
-	/**
-	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * \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,
-			bool ignoreFault = false );
-	/**
-	 * \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 );
-	/**
-	 * \brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * \brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
-
-	bool isDefaultDestinationSet() const;
-protected:
-	/**
-	 * 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.
-	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false);
-private:
-	/**
-	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
-	 * 			If initialization fails, the queue id is set to zero.
-	 */
-	MessageQueueId_t id;
-	/**
-	 * @brief	In this attribute, the queue id of the last communication partner is stored
-	 * 			to allow for replying.
-	 */
-	MessageQueueId_t lastPartner;
-	/**
-	 * @brief	The message queue's name -a user specific information for the operating system-  is
-	 * 			generated automatically with the help of this static counter.
-	 */
-	/**
-	 * \brief	This attribute stores a default destination to send messages to.
-	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
-	 * 			be set in the constructor or by a setter call to setDefaultDestination.
-	 */
-	MessageQueueId_t defaultDestination;
-
-	/**
-	 * The name of the message queue, stored for unlinking
-	 */
-	char name[16];
-
-	static uint16_t queueCounter;
-	const size_t maxMessageSize;
-
-	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
-};
-
-#endif /* MESSAGEQUEUE_H_ */
+#ifndef MESSAGEQUEUE_H_
+#define MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessage.h"
+
+#include <mqueue.h>
+/**
+ * @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".
+ *
+ * The creation of message queues, as well as sending and receiving messages,
+ * makes use of the operating system calls provided.
+ *	@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 i 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(uint32_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	/**
+	 * @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.
+	 */
+	virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false );
+	/**
+	 * @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.
+	 */
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using the stored
+	 * 			lastParnter 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 );
+
+	/**
+	 * @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);
+
+	/**
+	 * @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);
+	/**
+	 * 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);
+	/**
+	 * @brief	This method returns the message queue id of the last communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const;
+	/**
+	 * @brief	This method returns the message queue id of this class's message queue.
+	 */
+	MessageQueueId_t getId() const;
+	/**
+	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * \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,
+			bool ignoreFault = false );
+	/**
+	 * \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 );
+	/**
+	 * \brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination);
+	/**
+	 * \brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const;
+
+	bool isDefaultDestinationSet() const;
+protected:
+	/**
+	 * 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.
+	 */
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false);
+private:
+	/**
+	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the queue id is set to zero.
+	 */
+	MessageQueueId_t id;
+	/**
+	 * @brief	In this attribute, the queue id of the last communication partner is stored
+	 * 			to allow for replying.
+	 */
+	MessageQueueId_t lastPartner;
+	/**
+	 * @brief	The message queue's name -a user specific information for the operating system-  is
+	 * 			generated automatically with the help of this static counter.
+	 */
+	/**
+	 * \brief	This attribute stores a default destination to send messages to.
+	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
+	 * 			be set in the constructor or by a setter call to setDefaultDestination.
+	 */
+	MessageQueueId_t defaultDestination;
+
+	/**
+	 * The name of the message queue, stored for unlinking
+	 */
+	char name[16];
+
+	static uint16_t queueCounter;
+	const size_t maxMessageSize;
+
+	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
+};
+
+#endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index 03789e625..20be8aee4 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -1,111 +1,111 @@
-#include <framework/osal/linux/Mutex.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/timemanager/Clock.h>
-
-uint8_t Mutex::count = 0;
-
-
-#include <cstring>
-#include <errno.h>
-
-Mutex::Mutex() {
-	pthread_mutexattr_t mutexAttr;
-	int status = pthread_mutexattr_init(&mutexAttr);
-	if (status != 0) {
-		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
-	}
-	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
-	if (status != 0) {
-		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
-				<< std::endl;
-	}
-	status = pthread_mutex_init(&mutex, &mutexAttr);
-	if (status != 0) {
-		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
-				<< ", " << " failed with " << strerror(status) << std::endl;
-	}
-	// After a mutex attributes object has been used to initialize one or more
-	// mutexes, any function affecting the attributes object
-	// (including destruction) shall not affect any previously initialized mutexes.
-	status = pthread_mutexattr_destroy(&mutexAttr);
-	if (status != 0) {
-		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
-	}
-}
-
-Mutex::~Mutex() {
-	//No Status check yet
-	pthread_mutex_destroy(&mutex);
-}
-
-ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
-	int status = 0;
-
-	if(timeoutType == TimeoutType::POLLING) {
-	    status = pthread_mutex_trylock(&mutex);
-	}
-	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;
-		status = pthread_mutex_timedlock(&mutex, &timeOut);
-	}
-	else if(timeoutType == TimeoutType::BLOCKING) {
-		status = pthread_mutex_lock(&mutex);
-	}
-
-	switch (status) {
-	case EINVAL:
-		// The mutex was created with the protocol attribute having the value
-		// PTHREAD_PRIO_PROTECT and the calling thread's priority is higher
-		// than the mutex's current priority ceiling.
-		return WRONG_ATTRIBUTE_SETTING;
-		// The process or thread would have blocked, and the abs_timeout
-		// parameter specified a nanoseconds field value less than zero or
-		// greater than or equal to 1000 million.
-		// The value specified by mutex does not refer to an initialized mutex object.
-		//return MUTEX_NOT_FOUND;
-	case EBUSY:
-		// The mutex could not be acquired because it was already locked.
-		return MUTEX_ALREADY_LOCKED;
-	case ETIMEDOUT:
-		// The mutex could not be locked before the specified timeout expired.
-		return MUTEX_TIMEOUT;
-	case EAGAIN:
-		// The mutex could not be acquired because the maximum number of
-		// recursive locks for mutex has been exceeded.
-		return MUTEX_MAX_LOCKS;
-	case EDEADLK:
-		// A deadlock condition was detected or the current thread
-		// already owns the mutex.
-		return CURR_THREAD_ALREADY_OWNS_MUTEX;
-	case 0:
-		//Success
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	};
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	int status = pthread_mutex_unlock(&mutex);
-	switch (status) {
-	case EINVAL:
-		//The value specified by mutex does not refer to an initialized mutex object.
-		return MUTEX_NOT_FOUND;
-	case EAGAIN:
-		//The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded.
-		return MUTEX_MAX_LOCKS;
-	case EPERM:
-		//The current thread does not own the mutex.
-		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	case 0:
-		//Success
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	};
-}
+#include "../../osal/linux/Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Clock.h"
+
+uint8_t Mutex::count = 0;
+
+
+#include <cstring>
+#include <errno.h>
+
+Mutex::Mutex() {
+	pthread_mutexattr_t mutexAttr;
+	int status = pthread_mutexattr_init(&mutexAttr);
+	if (status != 0) {
+		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
+	}
+	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
+	if (status != 0) {
+		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
+				<< std::endl;
+	}
+	status = pthread_mutex_init(&mutex, &mutexAttr);
+	if (status != 0) {
+		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
+				<< ", " << " failed with " << strerror(status) << std::endl;
+	}
+	// After a mutex attributes object has been used to initialize one or more
+	// mutexes, any function affecting the attributes object
+	// (including destruction) shall not affect any previously initialized mutexes.
+	status = pthread_mutexattr_destroy(&mutexAttr);
+	if (status != 0) {
+		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
+	}
+}
+
+Mutex::~Mutex() {
+	//No Status check yet
+	pthread_mutex_destroy(&mutex);
+}
+
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
+	int status = 0;
+
+	if(timeoutType == TimeoutType::POLLING) {
+	    status = pthread_mutex_trylock(&mutex);
+	}
+	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;
+		status = pthread_mutex_timedlock(&mutex, &timeOut);
+	}
+	else if(timeoutType == TimeoutType::BLOCKING) {
+		status = pthread_mutex_lock(&mutex);
+	}
+
+	switch (status) {
+	case EINVAL:
+		// The mutex was created with the protocol attribute having the value
+		// PTHREAD_PRIO_PROTECT and the calling thread's priority is higher
+		// than the mutex's current priority ceiling.
+		return WRONG_ATTRIBUTE_SETTING;
+		// The process or thread would have blocked, and the abs_timeout
+		// parameter specified a nanoseconds field value less than zero or
+		// greater than or equal to 1000 million.
+		// The value specified by mutex does not refer to an initialized mutex object.
+		//return MUTEX_NOT_FOUND;
+	case EBUSY:
+		// The mutex could not be acquired because it was already locked.
+		return MUTEX_ALREADY_LOCKED;
+	case ETIMEDOUT:
+		// The mutex could not be locked before the specified timeout expired.
+		return MUTEX_TIMEOUT;
+	case EAGAIN:
+		// The mutex could not be acquired because the maximum number of
+		// recursive locks for mutex has been exceeded.
+		return MUTEX_MAX_LOCKS;
+	case EDEADLK:
+		// A deadlock condition was detected or the current thread
+		// already owns the mutex.
+		return CURR_THREAD_ALREADY_OWNS_MUTEX;
+	case 0:
+		//Success
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	};
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	int status = pthread_mutex_unlock(&mutex);
+	switch (status) {
+	case EINVAL:
+		//The value specified by mutex does not refer to an initialized mutex object.
+		return MUTEX_NOT_FOUND;
+	case EAGAIN:
+		//The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded.
+		return MUTEX_MAX_LOCKS;
+	case EPERM:
+		//The current thread does not own the mutex.
+		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	case 0:
+		//Success
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	};
+}
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index 26420c2eb..77a11fe4a 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -1,22 +1,22 @@
-#ifndef OS_LINUX_MUTEX_H_
-#define OS_LINUX_MUTEX_H_
-
-#include <framework/ipc/MutexIF.h>
-
-extern "C" {
-#include <pthread.h>
-}
-
-
-class Mutex : public MutexIF {
-public:
-	Mutex();
-	virtual ~Mutex();
-	virtual ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs);
-	virtual ReturnValue_t unlockMutex();
-private:
-	pthread_mutex_t mutex;
-	static uint8_t count;
-};
-
-#endif /* OS_RTEMS_MUTEX_H_ */
+#ifndef OS_LINUX_MUTEX_H_
+#define OS_LINUX_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+
+extern "C" {
+#include <pthread.h>
+}
+
+
+class Mutex : public MutexIF {
+public:
+	Mutex();
+	virtual ~Mutex();
+	virtual ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs);
+	virtual ReturnValue_t unlockMutex();
+private:
+	pthread_mutex_t mutex;
+	static uint8_t count;
+};
+
+#endif /* OS_RTEMS_MUTEX_H_ */
diff --git a/osal/linux/MutexFactory.cpp b/osal/linux/MutexFactory.cpp
index d769cc334..70dc3c710 100644
--- a/osal/linux/MutexFactory.cpp
+++ b/osal/linux/MutexFactory.cpp
@@ -1,23 +1,23 @@
-#include <framework/ipc/MutexFactory.h>
-#include <framework/osal/linux/Mutex.h>
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-
-MutexFactory::MutexFactory() {
-}
-
-MutexFactory::~MutexFactory() {
-}
-
-MutexFactory* MutexFactory::instance() {
-	return MutexFactory::factoryInstance;
-}
-
-MutexIF* MutexFactory::createMutex() {
-	return new Mutex();
-}
-
-void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/linux/Mutex.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index cd487531d..9b6148c5e 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -1,82 +1,82 @@
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/linux/PeriodicPosixTask.h>
-
-#include <errno.h>
-
-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_) {
-}
-
-PeriodicPosixTask::~PeriodicPosixTask() {
-	//Not Implemented
-}
-
-void* PeriodicPosixTask::taskEntryPoint(void* arg) {
-	//The argument is re-interpreted as PollingTask.
-	PeriodicPosixTask *originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-	return NULL;
-}
-
-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);
-	newObject->setTaskIF(this);
-
-	return newObject->initializeAfterTaskCreation();
-}
-
-ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
-	return PosixThread::sleep((uint64_t)ms*1000000);
-}
-
-
-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){
-		suspend();
-	}
-	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();
-		}
-		if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
-			char name[20] = {0};
-			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
-			if(status == 0){
-				//sif::error << "PeriodicPosixTask " << name << ": Deadline "
-				//		"missed." << std::endl;
-			}
-			else {
-				//sif::error << "PeriodicPosixTask X: Deadline missed. " <<
-				//		status << std::endl;
-			}
-			if (this->deadlineMissedFunc != nullptr) {
-				this->deadlineMissedFunc();
-			}
-		}
-	}
-}
-
-uint32_t PeriodicPosixTask::getPeriodMs() const {
-	return periodMs;
-}
+#include "../../tasks/ExecutableObjectIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/PeriodicPosixTask.h"
+
+#include <errno.h>
+
+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_) {
+}
+
+PeriodicPosixTask::~PeriodicPosixTask() {
+	//Not Implemented
+}
+
+void* PeriodicPosixTask::taskEntryPoint(void* arg) {
+	//The argument is re-interpreted as PollingTask.
+	PeriodicPosixTask *originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
+	//The task's functionality is called.
+	originalTask->taskFunctionality();
+	return NULL;
+}
+
+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);
+	newObject->setTaskIF(this);
+
+	return newObject->initializeAfterTaskCreation();
+}
+
+ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
+	return PosixThread::sleep((uint64_t)ms*1000000);
+}
+
+
+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){
+		suspend();
+	}
+	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();
+		}
+		if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
+			char name[20] = {0};
+			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
+			if(status == 0){
+				//sif::error << "PeriodicPosixTask " << name << ": Deadline "
+				//		"missed." << std::endl;
+			}
+			else {
+				//sif::error << "PeriodicPosixTask X: Deadline missed. " <<
+				//		status << std::endl;
+			}
+			if (this->deadlineMissedFunc != nullptr) {
+				this->deadlineMissedFunc();
+			}
+		}
+	}
+}
+
+uint32_t PeriodicPosixTask::getPeriodMs() const {
+	return periodMs;
+}
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 0b2d51cdd..59302e433 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -1,90 +1,90 @@
-#ifndef FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
-#define FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
-
-#include <framework/tasks/PeriodicTaskIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/osal/linux/PosixThread.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <vector>
-
-class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
-public:
-	/**
-	 * Create a generic periodic task.
-	 * @param name_
-	 * Name, maximum allowed size of linux is 16 chars, everything else will
-	 * be truncated.
-	 * @param priority_
-	 * Real-time priority, ranges from 1 to 99 for Linux.
-	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
-	 * @param stackSize_
-	 * @param period_
-	 * @param deadlineMissedFunc_
-	 */
-	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
-			uint32_t period_, void(*deadlineMissedFunc_)());
-	virtual ~PeriodicPosixTask();
-
-	/**
-	 * @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) override;
-	/**
-	 * 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 RETURN_OK on success, RETURN_FAILED if the object could not be added.
-	 */
-	ReturnValue_t addComponent(object_id_t object) override;
-
-	uint32_t getPeriodMs() const override;
-
-	ReturnValue_t sleepFor(uint32_t ms) override;
-
-private:
-	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-
-	/**
-	 * @brief Flag to indicate that the task was started and is allowed to run
-	 */
-	bool started;
-
-
-	/**
-	 * @brief Period of the task in milliseconds
-	 */
-	uint32_t periodMs;
-	/**
-	 * @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 indefinitely. Within the loop, all performOperation methods of the added
-	 * 			objects are called. Afterwards the task will be blocked until the next period.
-	 * 			On missing the deadline, the deadlineMissedFunction is executed.
-	 */
-	virtual void taskFunctionality(void);
-	/**
-	 * @brief	This is the entry point in a new thread.
-	 *
-	 * @details	This method, that is the entry point in the new thread and calls taskFunctionality of the child class.
-	 * 			Needs a valid pointer to the derived class.
-	 */
-	static void* taskEntryPoint(void* arg);
-	/**
-	 * @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)();
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
+#define FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
+
+#include "../../tasks/PeriodicTaskIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../osal/linux/PosixThread.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include <vector>
+
+class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
+public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
+	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t period_, void(*deadlineMissedFunc_)());
+	virtual ~PeriodicPosixTask();
+
+	/**
+	 * @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) override;
+	/**
+	 * 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 RETURN_OK on success, RETURN_FAILED if the object could not be added.
+	 */
+	ReturnValue_t addComponent(object_id_t object) override;
+
+	uint32_t getPeriodMs() const override;
+
+	ReturnValue_t sleepFor(uint32_t ms) override;
+
+private:
+	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+
+	/**
+	 * @brief Flag to indicate that the task was started and is allowed to run
+	 */
+	bool started;
+
+
+	/**
+	 * @brief Period of the task in milliseconds
+	 */
+	uint32_t periodMs;
+	/**
+	 * @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 indefinitely. Within the loop, all performOperation methods of the added
+	 * 			objects are called. Afterwards the task will be blocked until the next period.
+	 * 			On missing the deadline, the deadlineMissedFunction is executed.
+	 */
+	virtual void taskFunctionality(void);
+	/**
+	 * @brief	This is the entry point in a new thread.
+	 *
+	 * @details	This method, that is the entry point in the new thread and calls taskFunctionality of the child class.
+	 * 			Needs a valid pointer to the derived class.
+	 */
+	static void* taskEntryPoint(void* arg);
+	/**
+	 * @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)();
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_ */
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index d84c8d9d8..70c63c4a8 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,217 +1,217 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/linux/PosixThread.h>
-#include <cstring>
-#include <errno.h>
-
-PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
-		thread(0),priority(priority_),stackSize(stackSize_) {
-    name[0] = '\0';
-    std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
-}
-
-PosixThread::~PosixThread() {
-	//No deletion and no free of Stack Pointer
-}
-
-ReturnValue_t PosixThread::sleep(uint64_t ns) {
-	//TODO sleep might be better with timer instead of sleep()
-	timespec time;
-	time.tv_sec = ns/1000000000;
-	time.tv_nsec = ns - time.tv_sec*1e9;
-
-	//Remaining Time is not set here
-	int status = nanosleep(&time,NULL);
-	if(status != 0){
-		switch(errno){
-		case EINTR:
-			//The nanosleep() function was interrupted by a signal.
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case EINVAL:
-			//The rqtp argument specified a nanosecond value less than zero or
-			// greater than or equal to 1000 million.
-			return HasReturnvaluesIF::RETURN_FAILED;
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void PosixThread::suspend() {
-	//Wait for SIGUSR1
-	int caughtSig = 0;
-	sigset_t waitSignal;
-	sigemptyset(&waitSignal);
-	sigaddset(&waitSignal, SIGUSR1);
-	sigwait(&waitSignal, &caughtSig);
-	if (caughtSig != SIGUSR1) {
-		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
-				caughtSig << std::endl;
-	}
-}
-
-void PosixThread::resume(){
-	/* Signal the thread to start. Makes sense to call kill to start or? ;)
-	 *
-	*	According to Posix raise(signal) will call pthread_kill(pthread_self(), sig),
-	*	but as the call must be done from the thread itsself this is not possible here
-	*/
-	pthread_kill(thread,SIGUSR1);
-}
-
-bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
-		const uint64_t delayTime_ms) {
-	uint64_t nextTimeToWake_ms;
-	bool shouldDelay = false;
-	//Get current Time
-	const uint64_t currentTime_ms = getCurrentMonotonicTimeMs();
-	/* Generate the tick time at which the task wants to wake. */
-	nextTimeToWake_ms = (*prevoiusWakeTime_ms) + delayTime_ms;
-
-	if (currentTime_ms < *prevoiusWakeTime_ms) {
-		/* 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 < *prevoiusWakeTime_ms)
-				&& (nextTimeToWake_ms > currentTime_ms)) {
-			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 < *prevoiusWakeTime_ms)
-				|| (nextTimeToWake_ms > currentTime_ms)) {
-			shouldDelay = true;
-		}
-	}
-
-	/* Update the wake time ready for the next call. */
-
-	(*prevoiusWakeTime_ms) =  nextTimeToWake_ms;
-
-	if (shouldDelay) {
-		uint64_t sleepTime = nextTimeToWake_ms - currentTime_ms;
-		PosixThread::sleep(sleepTime * 1000000ull);
-		return true;
-	}
-	//We are shifting the time in case the deadline was missed like rtems
-	(*prevoiusWakeTime_ms) = currentTime_ms;
-	return false;
-
-}
-
-
-uint64_t PosixThread::getCurrentMonotonicTimeMs(){
-	timespec timeNow;
-	clock_gettime(CLOCK_MONOTONIC_RAW, &timeNow);
-	uint64_t currentTime_ms = (uint64_t) timeNow.tv_sec * 1000
-				+ timeNow.tv_nsec / 1000000;
-
-	return currentTime_ms;
-}
-
-
-void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
-	//sif::debug << "PosixThread::createTask" << std::endl;
-	/*
-	 * The attr argument points to a pthread_attr_t structure whose contents
-       are used at thread creation time to determine attributes for the new
-       thread; this structure is initialized using pthread_attr_init(3) and
-       related functions.  If attr is NULL, then the thread is created with
-       default attributes.
-	 */
-	pthread_attr_t attributes;
-	int status = pthread_attr_init(&attributes);
-	if(status != 0){
-		sif::error << "Posix Thread attribute init failed with: " <<
-				strerror(status) << std::endl;
-	}
-	void* stackPointer;
-	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
-	if(status != 0){
-		sif::error << "PosixThread::createTask: Stack init failed with: " <<
-				strerror(status) << std::endl;
-		if(errno == ENOMEM) {
-			uint64_t stackMb = stackSize/10e6;
-			sif::error << "PosixThread::createTask: Insufficient memory for"
-					" the requested " << stackMb << " MB" << std::endl;
-		}
-		else if(errno == EINVAL) {
-			sif::error << "PosixThread::createTask: Wrong alignment argument!"
-					<< std::endl;
-		}
-		return;
-	}
-
-	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
-	if(status != 0){
-		sif::error << "PosixThread::createTask: pthread_attr_setstack "
-				" failed with: " << strerror(status) <<  std::endl;
-		sif::error << "Make sure the specified stack size is valid and is "
-				"larger than the minimum allowed stack size." << std::endl;
-	}
-
-	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
-	if(status != 0){
-			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
-					strerror(status) << std::endl;
-	}
-
-	// TODO FIFO -> This needs root privileges for the process
-	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
-	if(status != 0){
-		sif::error << "Posix Thread attribute schedule policy failed with: " <<
-				strerror(status) << std::endl;
-	}
-
-	sched_param scheduleParams;
-	scheduleParams.__sched_priority = priority;
-	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
-	if(status != 0){
-		sif::error << "Posix Thread attribute schedule params failed with: " <<
-				strerror(status) << std::endl;
-	}
-
-	//Set Signal Mask for suspend until startTask is called
-	sigset_t waitSignal;
-	sigemptyset(&waitSignal);
-	sigaddset(&waitSignal, SIGUSR1);
-	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
-	if(status != 0){
-		sif::error << "Posix Thread sigmask failed failed with: " <<
-				strerror(status) << " errno: " << strerror(errno) << std::endl;
-	}
-
-
-	status = pthread_create(&thread,&attributes,fnc_,arg_);
-	if(status != 0){
-		sif::error << "Posix Thread create failed with: " <<
-				strerror(status) << std::endl;
-	}
-
-	status = pthread_setname_np(thread,name);
-	if(status != 0){
-		sif::error << "PosixThread::createTask: setname failed with: " <<
-				strerror(status) << std::endl;
-		if(status == ERANGE) {
-			sif::error << "PosixThread::createTask: Task name length longer"
-					" than 16 chars. Truncating.." << std::endl;
-			name[15] = '\0';
-			status = pthread_setname_np(thread,name);
-			if(status != 0){
-				sif::error << "PosixThread::createTask: Setting name"
-						" did not work.." << std::endl;
-			}
-		}
-	}
-
-	status = pthread_attr_destroy(&attributes);
-	if(status!=0){
-		sif::error << "Posix Thread attribute destroy failed with: " <<
-				strerror(status) << std::endl;
-	}
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/PosixThread.h"
+#include <cstring>
+#include <errno.h>
+
+PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
+		thread(0),priority(priority_),stackSize(stackSize_) {
+    name[0] = '\0';
+    std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
+}
+
+PosixThread::~PosixThread() {
+	//No deletion and no free of Stack Pointer
+}
+
+ReturnValue_t PosixThread::sleep(uint64_t ns) {
+	//TODO sleep might be better with timer instead of sleep()
+	timespec time;
+	time.tv_sec = ns/1000000000;
+	time.tv_nsec = ns - time.tv_sec*1e9;
+
+	//Remaining Time is not set here
+	int status = nanosleep(&time,NULL);
+	if(status != 0){
+		switch(errno){
+		case EINTR:
+			//The nanosleep() function was interrupted by a signal.
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case EINVAL:
+			//The rqtp argument specified a nanosecond value less than zero or
+			// greater than or equal to 1000 million.
+			return HasReturnvaluesIF::RETURN_FAILED;
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PosixThread::suspend() {
+	//Wait for SIGUSR1
+	int caughtSig = 0;
+	sigset_t waitSignal;
+	sigemptyset(&waitSignal);
+	sigaddset(&waitSignal, SIGUSR1);
+	sigwait(&waitSignal, &caughtSig);
+	if (caughtSig != SIGUSR1) {
+		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
+				caughtSig << std::endl;
+	}
+}
+
+void PosixThread::resume(){
+	/* Signal the thread to start. Makes sense to call kill to start or? ;)
+	 *
+	*	According to Posix raise(signal) will call pthread_kill(pthread_self(), sig),
+	*	but as the call must be done from the thread itsself this is not possible here
+	*/
+	pthread_kill(thread,SIGUSR1);
+}
+
+bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
+		const uint64_t delayTime_ms) {
+	uint64_t nextTimeToWake_ms;
+	bool shouldDelay = false;
+	//Get current Time
+	const uint64_t currentTime_ms = getCurrentMonotonicTimeMs();
+	/* Generate the tick time at which the task wants to wake. */
+	nextTimeToWake_ms = (*prevoiusWakeTime_ms) + delayTime_ms;
+
+	if (currentTime_ms < *prevoiusWakeTime_ms) {
+		/* 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 < *prevoiusWakeTime_ms)
+				&& (nextTimeToWake_ms > currentTime_ms)) {
+			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 < *prevoiusWakeTime_ms)
+				|| (nextTimeToWake_ms > currentTime_ms)) {
+			shouldDelay = true;
+		}
+	}
+
+	/* Update the wake time ready for the next call. */
+
+	(*prevoiusWakeTime_ms) =  nextTimeToWake_ms;
+
+	if (shouldDelay) {
+		uint64_t sleepTime = nextTimeToWake_ms - currentTime_ms;
+		PosixThread::sleep(sleepTime * 1000000ull);
+		return true;
+	}
+	//We are shifting the time in case the deadline was missed like rtems
+	(*prevoiusWakeTime_ms) = currentTime_ms;
+	return false;
+
+}
+
+
+uint64_t PosixThread::getCurrentMonotonicTimeMs(){
+	timespec timeNow;
+	clock_gettime(CLOCK_MONOTONIC_RAW, &timeNow);
+	uint64_t currentTime_ms = (uint64_t) timeNow.tv_sec * 1000
+				+ timeNow.tv_nsec / 1000000;
+
+	return currentTime_ms;
+}
+
+
+void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
+	//sif::debug << "PosixThread::createTask" << std::endl;
+	/*
+	 * The attr argument points to a pthread_attr_t structure whose contents
+       are used at thread creation time to determine attributes for the new
+       thread; this structure is initialized using pthread_attr_init(3) and
+       related functions.  If attr is NULL, then the thread is created with
+       default attributes.
+	 */
+	pthread_attr_t attributes;
+	int status = pthread_attr_init(&attributes);
+	if(status != 0){
+		sif::error << "Posix Thread attribute init failed with: " <<
+				strerror(status) << std::endl;
+	}
+	void* stackPointer;
+	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
+	if(status != 0){
+		sif::error << "PosixThread::createTask: Stack init failed with: " <<
+				strerror(status) << std::endl;
+		if(errno == ENOMEM) {
+			uint64_t stackMb = stackSize/10e6;
+			sif::error << "PosixThread::createTask: Insufficient memory for"
+					" the requested " << stackMb << " MB" << std::endl;
+		}
+		else if(errno == EINVAL) {
+			sif::error << "PosixThread::createTask: Wrong alignment argument!"
+					<< std::endl;
+		}
+		return;
+	}
+
+	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
+	if(status != 0){
+		sif::error << "PosixThread::createTask: pthread_attr_setstack "
+				" failed with: " << strerror(status) <<  std::endl;
+		sif::error << "Make sure the specified stack size is valid and is "
+				"larger than the minimum allowed stack size." << std::endl;
+	}
+
+	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
+	if(status != 0){
+			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
+					strerror(status) << std::endl;
+	}
+
+	// TODO FIFO -> This needs root privileges for the process
+	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
+	if(status != 0){
+		sif::error << "Posix Thread attribute schedule policy failed with: " <<
+				strerror(status) << std::endl;
+	}
+
+	sched_param scheduleParams;
+	scheduleParams.__sched_priority = priority;
+	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
+	if(status != 0){
+		sif::error << "Posix Thread attribute schedule params failed with: " <<
+				strerror(status) << std::endl;
+	}
+
+	//Set Signal Mask for suspend until startTask is called
+	sigset_t waitSignal;
+	sigemptyset(&waitSignal);
+	sigaddset(&waitSignal, SIGUSR1);
+	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
+	if(status != 0){
+		sif::error << "Posix Thread sigmask failed failed with: " <<
+				strerror(status) << " errno: " << strerror(errno) << std::endl;
+	}
+
+
+	status = pthread_create(&thread,&attributes,fnc_,arg_);
+	if(status != 0){
+		sif::error << "Posix Thread create failed with: " <<
+				strerror(status) << std::endl;
+	}
+
+	status = pthread_setname_np(thread,name);
+	if(status != 0){
+		sif::error << "PosixThread::createTask: setname failed with: " <<
+				strerror(status) << std::endl;
+		if(status == ERANGE) {
+			sif::error << "PosixThread::createTask: Task name length longer"
+					" than 16 chars. Truncating.." << std::endl;
+			name[15] = '\0';
+			status = pthread_setname_np(thread,name);
+			if(status != 0){
+				sif::error << "PosixThread::createTask: Setting name"
+						" did not work.." << std::endl;
+			}
+		}
+	}
+
+	status = pthread_attr_destroy(&attributes);
+	if(status!=0){
+		sif::error << "Posix Thread attribute destroy failed with: " <<
+				strerror(status) << std::endl;
+	}
+}
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index e9d317289..9d6097f74 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
-#define FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <pthread.h>
-#include <signal.h>
-#include <cstdlib>
-#include <unistd.h>
-
-class PosixThread {
-public:
-	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
-	PosixThread(const char* name_, int priority_, size_t stackSize_);
-	virtual ~PosixThread();
-	/**
-	 * Set the Thread to sleep state
-	 * @param ns Nanosecond sleep time
-	 * @return Returns Failed if sleep fails
-	 */
-	static ReturnValue_t sleep(uint64_t ns);
-	/**
-	 * @brief Function to suspend the task until SIGUSR1 was received
-	 *
-	 *  @details Will be called in the beginning to suspend execution until startTask() is called explicitly.
-	 */
-	void suspend();
-
-	/**
-	 * @brief Function to allow a other thread to start the thread again from suspend state
-	 *
-	 * @details Restarts the Thread after suspend call
-	 */
-	void resume();
-
-
-	/**
-	 * Delay function similar to FreeRtos delayUntil function
-	 *
-	 * @param prevoiusWakeTime_ms Needs the previous wake time and returns the next wakeup time
-	 * @param delayTime_ms Time period to delay
-	 *
-	 * @return False If deadline was missed; True if task was delayed
-	 */
-	static bool delayUntil(uint64_t* const prevoiusWakeTime_ms, const uint64_t delayTime_ms);
-
-	/**
-	 * Returns the current time in milliseconds from CLOCK_MONOTONIC
-	 *
-	 * @return current time in milliseconds from CLOCK_MONOTONIC
-	 */
-	static uint64_t getCurrentMonotonicTimeMs();
-
-protected:
-	pthread_t thread;
-
-	/**
-	 * @brief 	Function that has to be called by derived class because the
-	 *  		derived class pointer has to be valid as argument.
-	 * @details
-	 * This function creates a pthread with the given parameters. As the
-	 * function requires a pointer to the derived object it has to be called
-	 * after the this pointer of the derived object is valid.
-	 * Sets the taskEntryPoint as function to be called by new a thread.
-	 * @param fnc_ Function which will be executed by the thread.
-	 * @param arg_
-	 * argument of the taskEntryPoint function, needs to be this pointer
-	 * of derived class
-	 */
-	void createTask(void* (*fnc_)(void*),void* arg_);
-
-private:
-	char name[PTHREAD_MAX_NAMELEN];
-	int priority;
-	size_t stackSize = 0;
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
+#define FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <pthread.h>
+#include <signal.h>
+#include <cstdlib>
+#include <unistd.h>
+
+class PosixThread {
+public:
+	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
+	PosixThread(const char* name_, int priority_, size_t stackSize_);
+	virtual ~PosixThread();
+	/**
+	 * Set the Thread to sleep state
+	 * @param ns Nanosecond sleep time
+	 * @return Returns Failed if sleep fails
+	 */
+	static ReturnValue_t sleep(uint64_t ns);
+	/**
+	 * @brief Function to suspend the task until SIGUSR1 was received
+	 *
+	 *  @details Will be called in the beginning to suspend execution until startTask() is called explicitly.
+	 */
+	void suspend();
+
+	/**
+	 * @brief Function to allow a other thread to start the thread again from suspend state
+	 *
+	 * @details Restarts the Thread after suspend call
+	 */
+	void resume();
+
+
+	/**
+	 * Delay function similar to FreeRtos delayUntil function
+	 *
+	 * @param prevoiusWakeTime_ms Needs the previous wake time and returns the next wakeup time
+	 * @param delayTime_ms Time period to delay
+	 *
+	 * @return False If deadline was missed; True if task was delayed
+	 */
+	static bool delayUntil(uint64_t* const prevoiusWakeTime_ms, const uint64_t delayTime_ms);
+
+	/**
+	 * Returns the current time in milliseconds from CLOCK_MONOTONIC
+	 *
+	 * @return current time in milliseconds from CLOCK_MONOTONIC
+	 */
+	static uint64_t getCurrentMonotonicTimeMs();
+
+protected:
+	pthread_t thread;
+
+	/**
+	 * @brief 	Function that has to be called by derived class because the
+	 *  		derived class pointer has to be valid as argument.
+	 * @details
+	 * This function creates a pthread with the given parameters. As the
+	 * function requires a pointer to the derived object it has to be called
+	 * after the this pointer of the derived object is valid.
+	 * Sets the taskEntryPoint as function to be called by new a thread.
+	 * @param fnc_ Function which will be executed by the thread.
+	 * @param arg_
+	 * argument of the taskEntryPoint function, needs to be this pointer
+	 * of derived class
+	 */
+	void createTask(void* (*fnc_)(void*),void* arg_);
+
+private:
+	char name[PTHREAD_MAX_NAMELEN];
+	int priority;
+	size_t stackSize = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index 8bd9d52c5..d1332504e 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -1,38 +1,38 @@
-#include <framework/ipc/QueueFactory.h>
-#include <mqueue.h>
-#include <errno.h>
-#include <framework/osal/linux/MessageQueue.h>
-#include <framework/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);
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == nullptr) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+#include <mqueue.h>
+#include <errno.h>
+#include "../../osal/linux/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);
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == nullptr) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index 4fbd60d96..43b1978df 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,36 +1,36 @@
-#include <framework/tasks/SemaphoreFactory.h>
-#include <framework/osal/linux/BinarySemaphore.h>
-#include <framework/osal/linux/CountingSemaphore.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = 0xffffffff;
-
-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;
-}
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../osal/linux/BinarySemaphore.h"
+#include "../../osal/linux/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t SemaphoreIF::POLLING = 0;
+const uint32_t SemaphoreIF::BLOCKING = 0xffffffff;
+
+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;
+}
diff --git a/osal/linux/TaskFactory.cpp b/osal/linux/TaskFactory.cpp
index 219630a7e..1cd0b2b10 100644
--- a/osal/linux/TaskFactory.cpp
+++ b/osal/linux/TaskFactory.cpp
@@ -1,42 +1,42 @@
-#include <framework/osal/linux/FixedTimeslotTask.h>
-#include <framework/osal/linux/PeriodicPosixTask.h>
-#include <framework/tasks/TaskFactory.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return new PeriodicPosixTask(name_, taskPriority_,stackSize_,
-			periodInSeconds_ * 1000, deadLineMissedFunction_);
-}
-
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return new FixedTimeslotTask(name_, taskPriority_,stackSize_,
-			periodInSeconds_*1000);
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	//TODO not implemented
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
-	return PosixThread::sleep(delayMs*1000000ull);
-}
-
-TaskFactory::TaskFactory() {
-}
+#include "../../osal/linux/FixedTimeslotTask.h"
+#include "../../osal/linux/PeriodicPosixTask.h"
+#include "../../tasks/TaskFactory.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new PeriodicPosixTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_ * 1000, deadLineMissedFunction_);
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new FixedTimeslotTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_*1000);
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	//TODO not implemented
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
+	return PosixThread::sleep(delayMs*1000000ull);
+}
+
+TaskFactory::TaskFactory() {
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 8cf7b2859..04c1d2555 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,137 +1,137 @@
-#include <framework/osal/linux/TcUnixUdpPollingTask.h>
-#include <framework/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;
-	}
-}
-
-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;
-	}
-	}
-}
+#include "../../osal/linux/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;
+	}
+}
+
+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;
+	}
+	}
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index d8de14584..9d678a81c 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -1,67 +1,67 @@
-#ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
-#define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/osal/linux/TmTcUnixUdpBridge.h>
-#include <framework/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_ */
+#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_ */
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index 5e27c328e..e45395219 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -1,42 +1,42 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <errno.h>
-#include <framework/osal/linux/Timer.h>
-
-Timer::Timer() {
-	sigevent sigEvent;
-	sigEvent.sigev_notify = SIGEV_NONE;
-	sigEvent.sigev_signo = 0;
-	sigEvent.sigev_value.sival_ptr = &timerId;
-	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
-	if(status!=0){
-		sif::error << "Timer creation failed with: " << status <<
-				" errno: " << errno << std::endl;
-	}
-}
-
-Timer::~Timer() {
-	timer_delete(timerId);
-}
-
-int Timer::setTimer(uint32_t intervalMs) {
-	itimerspec timer;
-	timer.it_value.tv_sec = intervalMs / 1000;
-	timer.it_value.tv_nsec = (intervalMs * 1000000) % (1000000000);
-	timer.it_interval.tv_sec = 0;
-	timer.it_interval.tv_nsec = 0;
-	return timer_settime(timerId, 0, &timer, NULL);
-}
-
-
-int Timer::getTimer(uint32_t* remainingTimeMs){
-	itimerspec timer;
-	timer.it_value.tv_sec = 0;
-	timer.it_value.tv_nsec = 0;
-	timer.it_interval.tv_sec = 0;
-	timer.it_interval.tv_nsec = 0;
-	int status = timer_gettime(timerId, &timer);
-
-	*remainingTimeMs = timer.it_value.tv_sec * 1000 + timer.it_value.tv_nsec / 1000000;
-
-	return status;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <errno.h>
+#include "../../osal/linux/Timer.h"
+
+Timer::Timer() {
+	sigevent sigEvent;
+	sigEvent.sigev_notify = SIGEV_NONE;
+	sigEvent.sigev_signo = 0;
+	sigEvent.sigev_value.sival_ptr = &timerId;
+	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
+	if(status!=0){
+		sif::error << "Timer creation failed with: " << status <<
+				" errno: " << errno << std::endl;
+	}
+}
+
+Timer::~Timer() {
+	timer_delete(timerId);
+}
+
+int Timer::setTimer(uint32_t intervalMs) {
+	itimerspec timer;
+	timer.it_value.tv_sec = intervalMs / 1000;
+	timer.it_value.tv_nsec = (intervalMs * 1000000) % (1000000000);
+	timer.it_interval.tv_sec = 0;
+	timer.it_interval.tv_nsec = 0;
+	return timer_settime(timerId, 0, &timer, NULL);
+}
+
+
+int Timer::getTimer(uint32_t* remainingTimeMs){
+	itimerspec timer;
+	timer.it_value.tv_sec = 0;
+	timer.it_value.tv_nsec = 0;
+	timer.it_interval.tv_sec = 0;
+	timer.it_interval.tv_nsec = 0;
+	int status = timer_gettime(timerId, &timer);
+
+	*remainingTimeMs = timer.it_value.tv_sec * 1000 + timer.it_value.tv_nsec / 1000000;
+
+	return status;
+}
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 2cdb93f36..57722b3f6 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,168 +1,168 @@
-#include <framework/osal/linux/TmTcUnixUdpBridge.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/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(socket < 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 << "Error: " << strerror(errno) << std::endl;
-	}
-}
-
+#include "../../osal/linux/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(socket < 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 << "Error: " << strerror(errno) << std::endl;
+	}
+}
+
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index dbddc6c32..e4aa8b1a0 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -1,48 +1,48 @@
-#ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
-#define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
-
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/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_ */
+#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_ */
diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index 98198dd31..826d0b141 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -1,198 +1,198 @@
-#include <framework/timemanager/Clock.h>
-#include "RtemsBasic.h"
-#include <rtems/score/todimpl.h>
-
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
-uint32_t Clock::getTicksPerSecond(void){
-	rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-	return static_cast<uint32_t>(ticks_per_second);
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-	rtems_time_of_day timeRtems;
-	timeRtems.year = time->year;
-	timeRtems.month = time->month;
-	timeRtems.day = time->day;
-	timeRtems.hour = time->hour;
-	timeRtems.minute  = time->minute;
-	timeRtems.second = time->second;
-	timeRtems.ticks = time->usecond * getTicksPerSecond() / 1e6;
-	rtems_status_code status = rtems_clock_set(&timeRtems);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_INVALID_ADDRESS:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_CLOCK:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	//TODO This routine uses _TOD_Set which is not
-	timespec newTime;
-	newTime.tv_sec = time->tv_sec;
-	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
-	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
-	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
-	//TODO Second parameter is ISR_lock_Context
-	_TOD_Set(&newTime,NULL);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	//Callable from ISR
-	rtems_status_code status = rtems_clock_get_tod_timeval(time);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_DEFINED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	//According to docs.rtems.org for rtems 5 this method is more accurate than rtems_clock_get_ticks_since_boot
-	timespec time;
-	rtems_status_code status = rtems_clock_get_uptime(&time);
-	uptime->tv_sec = time.tv_sec;
-	time.tv_nsec = time.tv_nsec / 1000;
-	uptime->tv_usec = time.tv_nsec;
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	//This counter overflows after 50 days
-	*uptimeMs = rtems_clock_get_ticks_since_boot();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval temp_time;
-	rtems_status_code returnValue = rtems_clock_get_tod_timeval(&temp_time);
-	*time = ((uint64_t) temp_time.tv_sec * 1000000) + temp_time.tv_usec;
-	switch(returnValue){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
-	rtems_status_code status = rtems_clock_get_tod(timeRtems);
-	switch (status) {
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_DEFINED:
-		//system date and time is not set
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		//time_buffer is NULL
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-	//Fails in 2038..
-	rtems_time_of_day timeRtems;
-	timeRtems.year = from->year;
-	timeRtems.month = from->month;
-	timeRtems.day = from->day;
-	timeRtems.hour = from->hour;
-	timeRtems.minute  = from->minute;
-	timeRtems.second = from->second;
-	timeRtems.ticks = from->usecond * getTicksPerSecond() / 1e6;
-	to->tv_sec = _TOD_To_seconds(&timeRtems);
-	to->tv_usec = from->usecond;
-	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::NO_TIMEOUT);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	leapSeconds = leapSeconds_;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if(timeMutex==NULL){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	*leapSeconds_ = leapSeconds;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex==NULL){
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../timemanager/Clock.h"
+#include "RtemsBasic.h"
+#include <rtems/score/todimpl.h>
+
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
+uint32_t Clock::getTicksPerSecond(void){
+	rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+	return static_cast<uint32_t>(ticks_per_second);
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+	rtems_time_of_day timeRtems;
+	timeRtems.year = time->year;
+	timeRtems.month = time->month;
+	timeRtems.day = time->day;
+	timeRtems.hour = time->hour;
+	timeRtems.minute  = time->minute;
+	timeRtems.second = time->second;
+	timeRtems.ticks = time->usecond * getTicksPerSecond() / 1e6;
+	rtems_status_code status = rtems_clock_set(&timeRtems);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_INVALID_ADDRESS:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_CLOCK:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	//TODO This routine uses _TOD_Set which is not
+	timespec newTime;
+	newTime.tv_sec = time->tv_sec;
+	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
+	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
+	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
+	//TODO Second parameter is ISR_lock_Context
+	_TOD_Set(&newTime,NULL);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+	//Callable from ISR
+	rtems_status_code status = rtems_clock_get_tod_timeval(time);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_NOT_DEFINED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	//According to docs.rtems.org for rtems 5 this method is more accurate than rtems_clock_get_ticks_since_boot
+	timespec time;
+	rtems_status_code status = rtems_clock_get_uptime(&time);
+	uptime->tv_sec = time.tv_sec;
+	time.tv_nsec = time.tv_nsec / 1000;
+	uptime->tv_usec = time.tv_nsec;
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	//This counter overflows after 50 days
+	*uptimeMs = rtems_clock_get_ticks_since_boot();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	timeval temp_time;
+	rtems_status_code returnValue = rtems_clock_get_tod_timeval(&temp_time);
+	*time = ((uint64_t) temp_time.tv_sec * 1000000) + temp_time.tv_usec;
+	switch(returnValue){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
+	rtems_status_code status = rtems_clock_get_tod(timeRtems);
+	switch (status) {
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_NOT_DEFINED:
+		//system date and time is not set
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		//time_buffer is NULL
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+	//Fails in 2038..
+	rtems_time_of_day timeRtems;
+	timeRtems.year = from->year;
+	timeRtems.month = from->month;
+	timeRtems.day = from->day;
+	timeRtems.hour = from->hour;
+	timeRtems.minute  = from->minute;
+	timeRtems.second = from->second;
+	timeRtems.ticks = from->usecond * getTicksPerSecond() / 1e6;
+	to->tv_sec = _TOD_To_seconds(&timeRtems);
+	to->tv_usec = from->usecond;
+	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::NO_TIMEOUT);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	leapSeconds = leapSeconds_;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+	if(timeMutex==NULL){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	*leapSeconds_ = leapSeconds;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::checkOrCreateClockMutex(){
+	if(timeMutex==NULL){
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index 61b66c3d0..c5fac6535 100644
--- a/osal/rtems/CpuUsage.cpp
+++ b/osal/rtems/CpuUsage.cpp
@@ -1,183 +1,183 @@
-#include "CpuUsage.h"
-#include <framework/serialize/SerialArrayListAdapter.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <string.h>
-
-extern "C" {
-#include <rtems/cpuuse.h>
-}
-
-int handlePrint(void * token, const char *format, ...) {
-	CpuUsage *cpuUsage = (CpuUsage *) token;
-
-	if (cpuUsage->counter == 0) {
-		//header
-		cpuUsage->counter++;
-		return 0;
-	}
-
-	if (cpuUsage->counter % 2 == 1) {
-		{
-			//we can not tell when the last call is so we assume it be every uneven time
-			va_list vl;
-			va_start(vl, format);
-			float timeSinceLastReset = va_arg(vl,uint32_t);
-			uint32_t timeSinceLastResetDecimals = va_arg(vl,uint32_t);
-
-			timeSinceLastReset = timeSinceLastReset
-					+ (timeSinceLastResetDecimals / 1000.);
-
-			cpuUsage->timeSinceLastReset = timeSinceLastReset;
-
-			va_end(vl);
-		}
-		//task name and id
-		va_list vl;
-		va_start(vl, format);
-
-		cpuUsage->cachedValue.id = va_arg(vl,uint32_t);
-		const char *name = va_arg(vl,const char *);
-		memcpy(cpuUsage->cachedValue.name, name,
-				CpuUsage::ThreadData::MAX_LENGTH_OF_THREAD_NAME);
-
-		va_end(vl);
-
-	} else {
-		//statistics
-		va_list vl;
-		va_start(vl, format);
-		float run = va_arg(vl,uint32_t);
-		uint32_t runDecimals = va_arg(vl,uint32_t);
-		float percent = va_arg(vl,uint32_t);
-		uint32_t percent_decimals = va_arg(vl,uint32_t);
-
-		run = run + (runDecimals / 1000.);
-		percent = percent + (percent_decimals / 1000.);
-
-		cpuUsage->cachedValue.percentUsage = percent;
-		cpuUsage->cachedValue.timeRunning = run;
-
-		cpuUsage->threadData.insert(cpuUsage->cachedValue);
-
-		va_end(vl);
-	}
-	cpuUsage->counter++;
-
-	return 0;
-}
-
-CpuUsage::CpuUsage() :
-		counter(0), timeSinceLastReset(0) {
-
-}
-
-CpuUsage::~CpuUsage() {
-
-}
-
-void CpuUsage::resetCpuUsage() {
-	rtems_cpu_usage_reset();
-}
-
-void CpuUsage::read() {
-	//rtems_cpu_usage_report_with_plugin(this, &handlePrint);
-}
-
-void CpuUsage::clear() {
-	counter = 0;
-	timeSinceLastReset = 0;
-	threadData.clear();
-}
-
-ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(
-			&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
-			size, maxSize, streamEndianness);
-}
-
-uint32_t CpuUsage::getSerializedSize() const {
-	uint32_t size = 0;
-
-	size += sizeof(timeSinceLastReset);
-	size += SerialArrayListAdapter<ThreadData>::getSerializedSize(&threadData);
-
-	return size;
-}
-
-ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
-		Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(
-			&timeSinceLastReset, buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
-			size, streamEndianness);
-}
-
-ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
-			size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
-		return BUFFER_TOO_SHORT;
-	}
-	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
-	*size += MAX_LENGTH_OF_THREAD_NAME;
-	*buffer += MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter::serialize(&timeRunning,
-			buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&percentUsage,
-			buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t CpuUsage::ThreadData::getSerializedSize() const {
-	uint32_t size = 0;
-
-	size += sizeof(id);
-	size += MAX_LENGTH_OF_THREAD_NAME;
-	size += sizeof(timeRunning);
-	size += sizeof(percentUsage);
-
-	return size;
-}
-
-ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
-		int32_t* size, Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if ((*size = *size - MAX_LENGTH_OF_THREAD_NAME) < 0) {
-		return STREAM_TOO_SHORT;
-	}
-	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
-	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter::deSerialize(&timeRunning,
-			buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::deSerialize(&percentUsage,
-			buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "CpuUsage.h"
+#include "../../serialize/SerialArrayListAdapter.h"
+#include "../../serialize/SerializeAdapter.h"
+#include <string.h>
+
+extern "C" {
+#include <rtems/cpuuse.h>
+}
+
+int handlePrint(void * token, const char *format, ...) {
+	CpuUsage *cpuUsage = (CpuUsage *) token;
+
+	if (cpuUsage->counter == 0) {
+		//header
+		cpuUsage->counter++;
+		return 0;
+	}
+
+	if (cpuUsage->counter % 2 == 1) {
+		{
+			//we can not tell when the last call is so we assume it be every uneven time
+			va_list vl;
+			va_start(vl, format);
+			float timeSinceLastReset = va_arg(vl,uint32_t);
+			uint32_t timeSinceLastResetDecimals = va_arg(vl,uint32_t);
+
+			timeSinceLastReset = timeSinceLastReset
+					+ (timeSinceLastResetDecimals / 1000.);
+
+			cpuUsage->timeSinceLastReset = timeSinceLastReset;
+
+			va_end(vl);
+		}
+		//task name and id
+		va_list vl;
+		va_start(vl, format);
+
+		cpuUsage->cachedValue.id = va_arg(vl,uint32_t);
+		const char *name = va_arg(vl,const char *);
+		memcpy(cpuUsage->cachedValue.name, name,
+				CpuUsage::ThreadData::MAX_LENGTH_OF_THREAD_NAME);
+
+		va_end(vl);
+
+	} else {
+		//statistics
+		va_list vl;
+		va_start(vl, format);
+		float run = va_arg(vl,uint32_t);
+		uint32_t runDecimals = va_arg(vl,uint32_t);
+		float percent = va_arg(vl,uint32_t);
+		uint32_t percent_decimals = va_arg(vl,uint32_t);
+
+		run = run + (runDecimals / 1000.);
+		percent = percent + (percent_decimals / 1000.);
+
+		cpuUsage->cachedValue.percentUsage = percent;
+		cpuUsage->cachedValue.timeRunning = run;
+
+		cpuUsage->threadData.insert(cpuUsage->cachedValue);
+
+		va_end(vl);
+	}
+	cpuUsage->counter++;
+
+	return 0;
+}
+
+CpuUsage::CpuUsage() :
+		counter(0), timeSinceLastReset(0) {
+
+}
+
+CpuUsage::~CpuUsage() {
+
+}
+
+void CpuUsage::resetCpuUsage() {
+	rtems_cpu_usage_reset();
+}
+
+void CpuUsage::read() {
+	//rtems_cpu_usage_report_with_plugin(this, &handlePrint);
+}
+
+void CpuUsage::clear() {
+	counter = 0;
+	timeSinceLastReset = 0;
+	threadData.clear();
+}
+
+ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(
+			&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
+			size, maxSize, streamEndianness);
+}
+
+uint32_t CpuUsage::getSerializedSize() const {
+	uint32_t size = 0;
+
+	size += sizeof(timeSinceLastReset);
+	size += SerialArrayListAdapter<ThreadData>::getSerializedSize(&threadData);
+
+	return size;
+}
+
+ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(
+			&timeSinceLastReset, buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
+			size, streamEndianness);
+}
+
+ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
+		return BUFFER_TOO_SHORT;
+	}
+	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
+	*size += MAX_LENGTH_OF_THREAD_NAME;
+	*buffer += MAX_LENGTH_OF_THREAD_NAME;
+	result = SerializeAdapter::serialize(&timeRunning,
+			buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&percentUsage,
+			buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t CpuUsage::ThreadData::getSerializedSize() const {
+	uint32_t size = 0;
+
+	size += sizeof(id);
+	size += MAX_LENGTH_OF_THREAD_NAME;
+	size += sizeof(timeRunning);
+	size += sizeof(percentUsage);
+
+	return size;
+}
+
+ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
+		int32_t* size, Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if ((*size = *size - MAX_LENGTH_OF_THREAD_NAME) < 0) {
+		return STREAM_TOO_SHORT;
+	}
+	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
+	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
+	result = SerializeAdapter::deSerialize(&timeRunning,
+			buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&percentUsage,
+			buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/rtems/CpuUsage.h b/osal/rtems/CpuUsage.h
index eb03c5e33..24cbb919b 100644
--- a/osal/rtems/CpuUsage.h
+++ b/osal/rtems/CpuUsage.h
@@ -1,53 +1,53 @@
-#ifndef CPUUSAGE_H_
-#define CPUUSAGE_H_
-
-#include <framework/container/FixedArrayList.h>
-#include <framework/serialize/SerializeIF.h>
-#include <stdarg.h>
-
-class CpuUsage : public SerializeIF {
-public:
-	static const uint8_t MAXIMUM_NUMBER_OF_THREADS = 30;
-
-	class ThreadData: public SerializeIF {
-	public:
-		static const uint8_t MAX_LENGTH_OF_THREAD_NAME = 4;
-
-		uint32_t id;
-		char name[MAX_LENGTH_OF_THREAD_NAME];
-		float timeRunning;
-		float percentUsage;
-
-		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;
-	};
-
-	CpuUsage();
-	virtual ~CpuUsage();
-
-	uint8_t counter;
-	float timeSinceLastReset;
-	FixedArrayList<ThreadData, MAXIMUM_NUMBER_OF_THREADS> threadData;
-	ThreadData cachedValue;
-
-	static void resetCpuUsage();
-
-	void read();
-
-	void clear();
-
-	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;
-};
-
-#endif /* CPUUSAGE_H_ */
+#ifndef CPUUSAGE_H_
+#define CPUUSAGE_H_
+
+#include "../../container/FixedArrayList.h"
+#include "../../serialize/SerializeIF.h"
+#include <stdarg.h>
+
+class CpuUsage : public SerializeIF {
+public:
+	static const uint8_t MAXIMUM_NUMBER_OF_THREADS = 30;
+
+	class ThreadData: public SerializeIF {
+	public:
+		static const uint8_t MAX_LENGTH_OF_THREAD_NAME = 4;
+
+		uint32_t id;
+		char name[MAX_LENGTH_OF_THREAD_NAME];
+		float timeRunning;
+		float percentUsage;
+
+		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;
+	};
+
+	CpuUsage();
+	virtual ~CpuUsage();
+
+	uint8_t counter;
+	float timeSinceLastReset;
+	FixedArrayList<ThreadData, MAXIMUM_NUMBER_OF_THREADS> threadData;
+	ThreadData cachedValue;
+
+	static void resetCpuUsage();
+
+	void read();
+
+	void clear();
+
+	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;
+};
+
+#endif /* CPUUSAGE_H_ */
diff --git a/osal/rtems/InternalErrorCodes.cpp b/osal/rtems/InternalErrorCodes.cpp
index dbe3172e8..3542ecced 100644
--- a/osal/rtems/InternalErrorCodes.cpp
+++ b/osal/rtems/InternalErrorCodes.cpp
@@ -1,60 +1,60 @@
-#include <framework/osal/InternalErrorCodes.h>
-#include <rtems/score/interr.h>
-
-ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
-	switch (code) {
-	//TODO It looks like RTEMS-5 does not provide the same error codes
-//	case INTERNAL_ERROR_NO_CONFIGURATION_TABLE:
-//		return NO_CONFIGURATION_TABLE;
-//	case INTERNAL_ERROR_NO_CPU_TABLE:
-//		return NO_CPU_TABLE;
-//	case INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS:
-//		return INVALID_WORKSPACE_ADDRESS;
-	case INTERNAL_ERROR_TOO_LITTLE_WORKSPACE:
-		return TOO_LITTLE_WORKSPACE;
-	case INTERNAL_ERROR_WORKSPACE_ALLOCATION:
-		return WORKSPACE_ALLOCATION;
-//	case INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL:
-//		return INTERRUPT_STACK_TOO_SMALL;
-	case INTERNAL_ERROR_THREAD_EXITTED:
-		return THREAD_EXITTED;
-	case INTERNAL_ERROR_INCONSISTENT_MP_INFORMATION:
-		return INCONSISTENT_MP_INFORMATION;
-	case INTERNAL_ERROR_INVALID_NODE:
-		return INVALID_NODE;
-	case INTERNAL_ERROR_NO_MPCI:
-		return NO_MPCI;
-	case INTERNAL_ERROR_BAD_PACKET:
-		return BAD_PACKET;
-	case INTERNAL_ERROR_OUT_OF_PACKETS:
-		return OUT_OF_PACKETS;
-	case INTERNAL_ERROR_OUT_OF_GLOBAL_OBJECTS:
-		return OUT_OF_GLOBAL_OBJECTS;
-	case INTERNAL_ERROR_OUT_OF_PROXIES:
-		return OUT_OF_PROXIES;
-	case INTERNAL_ERROR_INVALID_GLOBAL_ID:
-		return INVALID_GLOBAL_ID;
-	case INTERNAL_ERROR_BAD_STACK_HOOK:
-		return BAD_STACK_HOOK;
-//	case INTERNAL_ERROR_BAD_ATTRIBUTES:
-//		return BAD_ATTRIBUTES;
-//	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:
-//		return IMPLEMENTATION_KEY_CREATE_INCONSISTENCY;
-//	case INTERNAL_ERROR_IMPLEMENTATION_BLOCKING_OPERATION_CANCEL:
-//		return IMPLEMENTATION_BLOCKING_OPERATION_CANCEL;
-//	case INTERNAL_ERROR_MUTEX_OBTAIN_FROM_BAD_STATE:
-//		return MUTEX_OBTAIN_FROM_BAD_STATE;
-//	case INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0:
-//		return UNLIMITED_AND_MAXIMUM_IS_0;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-InternalErrorCodes::InternalErrorCodes() {
-}
-
-InternalErrorCodes::~InternalErrorCodes() {
-	
-}
-
+#include "../../osal/InternalErrorCodes.h"
+#include <rtems/score/interr.h>
+
+ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
+	switch (code) {
+	//TODO It looks like RTEMS-5 does not provide the same error codes
+//	case INTERNAL_ERROR_NO_CONFIGURATION_TABLE:
+//		return NO_CONFIGURATION_TABLE;
+//	case INTERNAL_ERROR_NO_CPU_TABLE:
+//		return NO_CPU_TABLE;
+//	case INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS:
+//		return INVALID_WORKSPACE_ADDRESS;
+	case INTERNAL_ERROR_TOO_LITTLE_WORKSPACE:
+		return TOO_LITTLE_WORKSPACE;
+	case INTERNAL_ERROR_WORKSPACE_ALLOCATION:
+		return WORKSPACE_ALLOCATION;
+//	case INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL:
+//		return INTERRUPT_STACK_TOO_SMALL;
+	case INTERNAL_ERROR_THREAD_EXITTED:
+		return THREAD_EXITTED;
+	case INTERNAL_ERROR_INCONSISTENT_MP_INFORMATION:
+		return INCONSISTENT_MP_INFORMATION;
+	case INTERNAL_ERROR_INVALID_NODE:
+		return INVALID_NODE;
+	case INTERNAL_ERROR_NO_MPCI:
+		return NO_MPCI;
+	case INTERNAL_ERROR_BAD_PACKET:
+		return BAD_PACKET;
+	case INTERNAL_ERROR_OUT_OF_PACKETS:
+		return OUT_OF_PACKETS;
+	case INTERNAL_ERROR_OUT_OF_GLOBAL_OBJECTS:
+		return OUT_OF_GLOBAL_OBJECTS;
+	case INTERNAL_ERROR_OUT_OF_PROXIES:
+		return OUT_OF_PROXIES;
+	case INTERNAL_ERROR_INVALID_GLOBAL_ID:
+		return INVALID_GLOBAL_ID;
+	case INTERNAL_ERROR_BAD_STACK_HOOK:
+		return BAD_STACK_HOOK;
+//	case INTERNAL_ERROR_BAD_ATTRIBUTES:
+//		return BAD_ATTRIBUTES;
+//	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:
+//		return IMPLEMENTATION_KEY_CREATE_INCONSISTENCY;
+//	case INTERNAL_ERROR_IMPLEMENTATION_BLOCKING_OPERATION_CANCEL:
+//		return IMPLEMENTATION_BLOCKING_OPERATION_CANCEL;
+//	case INTERNAL_ERROR_MUTEX_OBTAIN_FROM_BAD_STATE:
+//		return MUTEX_OBTAIN_FROM_BAD_STATE;
+//	case INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0:
+//		return UNLIMITED_AND_MAXIMUM_IS_0;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+InternalErrorCodes::InternalErrorCodes() {
+}
+
+InternalErrorCodes::~InternalErrorCodes() {
+	
+}
+
diff --git a/osal/rtems/Interrupt.h b/osal/rtems/Interrupt.h
index c4c21911d..076a6704f 100644
--- a/osal/rtems/Interrupt.h
+++ b/osal/rtems/Interrupt.h
@@ -1,50 +1,50 @@
-#ifndef OS_RTEMS_INTERRUPT_H_
-#define OS_RTEMS_INTERRUPT_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstring>
-#include <rtems.h>
-
-typedef rtems_isr_entry IsrHandler_t;
-typedef rtems_isr IsrReturn_t;
-typedef rtems_vector_number InterruptNumber_t;
-
-class Interrupt {
-public:
-	virtual ~Interrupt(){};
-
-	/**
-	 * Establishes a new interrupt service routine.
-	 * @param handler	The service routine to establish
-	 * @param interrupt	The interrupt (NOT trap type) the routine shall react to.
-	 * @return	RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setInterruptServiceRoutine(IsrHandler_t handler,
-			InterruptNumber_t interrupt, IsrHandler_t *oldHandler = NULL);
-	static ReturnValue_t enableInterrupt(InterruptNumber_t interruptNumber);
-	static ReturnValue_t disableInterrupt(InterruptNumber_t interruptNumber);
-	/**
-	 * Enables the interrupt given.
-	 * The function tests, if the InterruptMask register was written successfully.
-	 * @param interrupt The interrupt to enable.
-	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
-	 */
-	static ReturnValue_t enableGpioInterrupt(InterruptNumber_t interrupt);
-	/**
-	 * Disables the interrupt given.
-	 * @param interrupt The interrupt to disable.
-	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
-	 */
-	static ReturnValue_t disableGpioInterrupt(InterruptNumber_t interrupt);
-
-
-	/**
-	 * Checks if the current executing context is an ISR.
-	 * @return true if handling an interrupt, false else.
-	 */
-	static bool isInterruptInProgress();
-
-};
-
-
-#endif /* OS_RTEMS_INTERRUPT_H_ */
+#ifndef OS_RTEMS_INTERRUPT_H_
+#define OS_RTEMS_INTERRUPT_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <cstring>
+#include <rtems.h>
+
+typedef rtems_isr_entry IsrHandler_t;
+typedef rtems_isr IsrReturn_t;
+typedef rtems_vector_number InterruptNumber_t;
+
+class Interrupt {
+public:
+	virtual ~Interrupt(){};
+
+	/**
+	 * Establishes a new interrupt service routine.
+	 * @param handler	The service routine to establish
+	 * @param interrupt	The interrupt (NOT trap type) the routine shall react to.
+	 * @return	RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setInterruptServiceRoutine(IsrHandler_t handler,
+			InterruptNumber_t interrupt, IsrHandler_t *oldHandler = NULL);
+	static ReturnValue_t enableInterrupt(InterruptNumber_t interruptNumber);
+	static ReturnValue_t disableInterrupt(InterruptNumber_t interruptNumber);
+	/**
+	 * Enables the interrupt given.
+	 * The function tests, if the InterruptMask register was written successfully.
+	 * @param interrupt The interrupt to enable.
+	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
+	 */
+	static ReturnValue_t enableGpioInterrupt(InterruptNumber_t interrupt);
+	/**
+	 * Disables the interrupt given.
+	 * @param interrupt The interrupt to disable.
+	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
+	 */
+	static ReturnValue_t disableGpioInterrupt(InterruptNumber_t interrupt);
+
+
+	/**
+	 * Checks if the current executing context is an ISR.
+	 * @return true if handling an interrupt, false else.
+	 */
+	static bool isInterruptInProgress();
+
+};
+
+
+#endif /* OS_RTEMS_INTERRUPT_H_ */
diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index de148fdc6..e0752409c 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -1,147 +1,147 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include "MessageQueue.h"
-#include "RtemsBasic.h"
-#include <cstring>
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(NULL) {
-	rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
-	rtems_status_code status = rtems_message_queue_create(name, message_depth,
-			max_message_size, 0, &(this->id));
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-				<< name << std::dec << " failed with status:"
-				<< (uint32_t) status << std::endl;
-		this->id = 0;
-	}
-}
-
-MessageQueue::~MessageQueue() {
-	rtems_message_queue_delete(id);
-}
-
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
-	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
-	return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
-	if (this->lastPartner != 0) {
-		return sendMessage(this->lastPartner, message, this->getId());
-	} else {
-		return NO_REPLY_PARTNER;
-	}
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
-		MessageQueueId_t* receivedFrom) {
-	ReturnValue_t status = this->receiveMessage(message);
-	*receivedFrom = this->lastPartner;
-	return status;
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
-	rtems_status_code status = rtems_message_queue_receive(id,
-			message->getBuffer(), &(message->messageSize),
-			RTEMS_NO_WAIT, 1);
-	if (status == RTEMS_SUCCESSFUL) {
-		this->lastPartner = message->getSender();
-		//Check size of incoming message.
-		if (message->messageSize < message->getMinimumMessageSize()) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	} else {
-		//No message was received. Keep lastPartner anyway, I might send something later.
-		//But still, delete packet content.
-		memset(message->getData(), 0, message->MAX_DATA_SIZE);
-	}
-	return convertReturnCode(status);
-}
-
-MessageQueueId_t MessageQueue::getLastPartner() const {
-	return this->lastPartner;
-}
-
-ReturnValue_t MessageQueue::flush(uint32_t* count) {
-	rtems_status_code status = rtems_message_queue_flush(id, count);
-	return convertReturnCode(status);
-}
-
-MessageQueueId_t MessageQueue::getId() const {
-	return this->id;
-}
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-	this->defaultDestination = defaultDestination;
-}
-
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-
-	message->setSender(sentFrom);
-	rtems_status_code result = rtems_message_queue_send(sendTo,
-			message->getBuffer(), message->messageSize);
-
-	//TODO: Check if we're in ISR.
-	if (result != RTEMS_SUCCESSFUL && !ignoreFault) {
-		if (internalErrorReporter == NULL) {
-			internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-					objects::INTERNAL_ERROR_REPORTER);
-		}
-		if (internalErrorReporter != NULL) {
-			internalErrorReporter->queueMessageNotSent();
-		}
-	}
-
-	ReturnValue_t returnCode = convertReturnCode(result);
-	if(result == MessageQueueIF::EMPTY){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	return returnCode;
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const {
-	return this->defaultDestination;
-}
-
-bool MessageQueue::isDefaultDestinationSet() const {
-	return (defaultDestination != NO_QUEUE);
-}
-
-ReturnValue_t MessageQueue::convertReturnCode(rtems_status_code inValue){
-		switch(inValue){
-		case RTEMS_SUCCESSFUL:
-			return HasReturnvaluesIF::RETURN_OK;
-		case  RTEMS_INVALID_ID:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_TIMEOUT:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_OBJECT_WAS_DELETED:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_INVALID_ADDRESS:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_INVALID_SIZE:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_TOO_MANY:
-			return MessageQueueIF::FULL;
-		case RTEMS_UNSATISFIED:
-			return MessageQueueIF::EMPTY;
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-
-}
-
-
-
-uint16_t MessageQueue::queueCounter = 0;
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "MessageQueue.h"
+#include "RtemsBasic.h"
+#include <cstring>
+MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
+		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(NULL) {
+	rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
+	rtems_status_code status = rtems_message_queue_create(name, message_depth,
+			max_message_size, 0, &(this->id));
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+				<< name << std::dec << " failed with status:"
+				<< (uint32_t) status << std::endl;
+		this->id = 0;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	rtems_message_queue_delete(id);
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+	if (this->lastPartner != 0) {
+		return sendMessage(this->lastPartner, message, this->getId());
+	} else {
+		return NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	*receivedFrom = this->lastPartner;
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+	rtems_status_code status = rtems_message_queue_receive(id,
+			message->getBuffer(), &(message->messageSize),
+			RTEMS_NO_WAIT, 1);
+	if (status == RTEMS_SUCCESSFUL) {
+		this->lastPartner = message->getSender();
+		//Check size of incoming message.
+		if (message->messageSize < message->getMinimumMessageSize()) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	} else {
+		//No message was received. Keep lastPartner anyway, I might send something later.
+		//But still, delete packet content.
+		memset(message->getData(), 0, message->MAX_DATA_SIZE);
+	}
+	return convertReturnCode(status);
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return this->lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	rtems_status_code status = rtems_message_queue_flush(id, count);
+	return convertReturnCode(status);
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return this->id;
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	this->defaultDestination = defaultDestination;
+}
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+
+	message->setSender(sentFrom);
+	rtems_status_code result = rtems_message_queue_send(sendTo,
+			message->getBuffer(), message->messageSize);
+
+	//TODO: Check if we're in ISR.
+	if (result != RTEMS_SUCCESSFUL && !ignoreFault) {
+		if (internalErrorReporter == NULL) {
+			internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+		}
+		if (internalErrorReporter != NULL) {
+			internalErrorReporter->queueMessageNotSent();
+		}
+	}
+
+	ReturnValue_t returnCode = convertReturnCode(result);
+	if(result == MessageQueueIF::EMPTY){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	return returnCode;
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return this->defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return (defaultDestination != NO_QUEUE);
+}
+
+ReturnValue_t MessageQueue::convertReturnCode(rtems_status_code inValue){
+		switch(inValue){
+		case RTEMS_SUCCESSFUL:
+			return HasReturnvaluesIF::RETURN_OK;
+		case  RTEMS_INVALID_ID:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_TIMEOUT:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_OBJECT_WAS_DELETED:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_INVALID_ADDRESS:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_INVALID_SIZE:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_TOO_MANY:
+			return MessageQueueIF::FULL;
+		case RTEMS_UNSATISFIED:
+			return MessageQueueIF::EMPTY;
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+}
+
+
+
+uint16_t MessageQueue::queueCounter = 0;
diff --git a/osal/rtems/MessageQueue.h b/osal/rtems/MessageQueue.h
index 9bdce7cad..2d1bd8db8 100644
--- a/osal/rtems/MessageQueue.h
+++ b/osal/rtems/MessageQueue.h
@@ -1,181 +1,181 @@
-/**
- *	@file	MessageQueue.h
- *
- *  @date	10/02/2012
- *	@author	Bastian Baetz
- *
- *	@brief	This file contains the definition of the MessageQueue class.
- */
-
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
-
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
-#include "RtemsBasic.h"
-
-/**
- *	@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.
- *	\ingroup message_queue
- */
-class MessageQueue : public MessageQueueIF {
-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 i 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 message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
-	/**
-	 * @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,
-			MessageQueueMessage* message, bool ignoreFault = false );
-	/**
-	 * @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( MessageQueueMessage* message );
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter 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( MessageQueueMessage* message );
-
-	/**
-	 * @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(MessageQueueMessage* message,
-			MessageQueueId_t *receivedFrom);
-
-	/**
-	 * @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(MessageQueueMessage* message);
-	/**
-	 * 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);
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	MessageQueueId_t getId() const;
-	/**
-	 * \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, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \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( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * \brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
-
-	bool isDefaultDestinationSet() const;
-private:
-	/**
-	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
-	 * 			If initialization fails, the queue id is set to zero.
-	 */
-	MessageQueueId_t id;
-	/**
-	 * @brief	In this attribute, the queue id of the last communication partner is stored
-	 * 			to allow for replying.
-	 */
-	MessageQueueId_t lastPartner;
-	/**
-	 * @brief	The message queue's name -a user specific information for the operating system-  is
-	 * 			generated automatically with the help of this static counter.
-	 */
-	/**
-	 * \brief	This attribute stores a default destination to send messages to.
-	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
-	 * 			be set in the constructor or by a setter call to setDefaultDestination.
-	 */
-	MessageQueueId_t defaultDestination;
-
-	/**
-	 * \brief	This attribute stores a reference to the internal error reporter for reporting full queues.
-	 * \details	In the event of a full destination queue, the reporter will be notified. The reference is set
-	 * 			by lazy loading
-	 */
-	InternalErrorReporterIF *internalErrorReporter;
-
-	static uint16_t queueCounter;
-	/**
-	 * A method to convert an OS-specific return code to the frameworks return value concept.
-	 * @param inValue The return code coming from the OS.
-	 * @return The converted return value.
-	 */
-	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
-};
-
-#endif /* MESSAGEQUEUE_H_ */
+/**
+ *	@file	MessageQueue.h
+ *
+ *  @date	10/02/2012
+ *	@author	Bastian Baetz
+ *
+ *	@brief	This file contains the definition of the MessageQueue class.
+ */
+
+#ifndef MESSAGEQUEUE_H_
+#define MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessage.h"
+#include "RtemsBasic.h"
+
+/**
+ *	@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.
+ *	\ingroup message_queue
+ */
+class MessageQueue : public MessageQueueIF {
+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 i 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 message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	/**
+	 * @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,
+			MessageQueueMessage* message, bool ignoreFault = false );
+	/**
+	 * @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( MessageQueueMessage* message );
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using the stored
+	 * 			lastParnter 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( MessageQueueMessage* message );
+
+	/**
+	 * @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(MessageQueueMessage* message,
+			MessageQueueId_t *receivedFrom);
+
+	/**
+	 * @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(MessageQueueMessage* message);
+	/**
+	 * 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);
+	/**
+	 * @brief	This method returns the message queue id of the last communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const;
+	/**
+	 * @brief	This method returns the message queue id of this class's message queue.
+	 */
+	MessageQueueId_t getId() const;
+	/**
+	 * \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, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	/**
+	 * \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( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	/**
+	 * \brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination);
+	/**
+	 * \brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const;
+
+	bool isDefaultDestinationSet() const;
+private:
+	/**
+	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the queue id is set to zero.
+	 */
+	MessageQueueId_t id;
+	/**
+	 * @brief	In this attribute, the queue id of the last communication partner is stored
+	 * 			to allow for replying.
+	 */
+	MessageQueueId_t lastPartner;
+	/**
+	 * @brief	The message queue's name -a user specific information for the operating system-  is
+	 * 			generated automatically with the help of this static counter.
+	 */
+	/**
+	 * \brief	This attribute stores a default destination to send messages to.
+	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
+	 * 			be set in the constructor or by a setter call to setDefaultDestination.
+	 */
+	MessageQueueId_t defaultDestination;
+
+	/**
+	 * \brief	This attribute stores a reference to the internal error reporter for reporting full queues.
+	 * \details	In the event of a full destination queue, the reporter will be notified. The reference is set
+	 * 			by lazy loading
+	 */
+	InternalErrorReporterIF *internalErrorReporter;
+
+	static uint16_t queueCounter;
+	/**
+	 * A method to convert an OS-specific return code to the frameworks return value concept.
+	 * @param inValue The return code coming from the OS.
+	 * @return The converted return value.
+	 */
+	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
+};
+
+#endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index 6b9c8c8ea..8cec10f7e 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -1,87 +1,87 @@
-/**
- * @file	MultiObjectTask.cpp
- * @brief	This file defines the MultiObjectTask class.
- * @date	30.01.2014
- * @author	baetz
- */
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include "MultiObjectTask.h"
-
-MultiObjectTask::MultiObjectTask(const char *name, rtems_task_priority setPriority,
-		size_t setStack, rtems_interval setPeriod, void (*setDeadlineMissedFunc)()) :
-		TaskBase(setPriority, setStack, name), periodTicks(
-				RtemsBasic::convertMsToTicks(setPeriod)), periodId(0), deadlineMissedFunc(
-				setDeadlineMissedFunc) {
-}
-
-MultiObjectTask::~MultiObjectTask(void) {
-	//Do not delete objects, we were responsible for ptrs only.
-	rtems_rate_monotonic_delete(periodId);
-}
-rtems_task MultiObjectTask::taskEntryPoint(rtems_task_argument argument) {
-	//The argument is re-interpreted as MultiObjectTask. The Task object is global, so it is found from any place.
-	MultiObjectTask *originalTask(reinterpret_cast<MultiObjectTask*>(argument));
-	originalTask->taskFunctionality();
-}
-
-ReturnValue_t MultiObjectTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
-			rtems_task_argument((void *) this));
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "ObjectTask::startTask for " << std::hex << this->getId()
-				<< std::dec << " failed." << std::endl;
-	}
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ask started successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-/*		RTEMS_INVALID_ADDRESS - invalid task entry point
-		RTEMS_INVALID_ID - invalid task id
-		RTEMS_INCORRECT_STATE - task not in the dormant state
-		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t MultiObjectTask::sleepFor(uint32_t ms) {
-	return TaskBase::sleepFor(ms);
-}
-
-void MultiObjectTask::taskFunctionality() {
-	TaskBase::setAndStartPeriod(periodTicks,&periodId);
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
-		}
-		rtems_status_code status = TaskBase::restartPeriod(periodTicks,periodId);
-		if (status == RTEMS_TIMEOUT) {
-			char nameSpace[8] = { 0 };
-			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
-					nameSpace);
-			error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
-			if (this->deadlineMissedFunc != NULL) {
-				this->deadlineMissedFunc();
-			}
-		}
-	}
-}
-
-ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	ReturnValue_t result = newObject->initializeAfterTaskCreation();
-	return result;
-}
-
-uint32_t MultiObjectTask::getPeriodMs() const {
-	return RtemsBasic::convertTicksToMs(periodTicks);
-}
+/**
+ * @file	MultiObjectTask.cpp
+ * @brief	This file defines the MultiObjectTask class.
+ * @date	30.01.2014
+ * @author	baetz
+ */
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include "MultiObjectTask.h"
+
+MultiObjectTask::MultiObjectTask(const char *name, rtems_task_priority setPriority,
+		size_t setStack, rtems_interval setPeriod, void (*setDeadlineMissedFunc)()) :
+		TaskBase(setPriority, setStack, name), periodTicks(
+				RtemsBasic::convertMsToTicks(setPeriod)), periodId(0), deadlineMissedFunc(
+				setDeadlineMissedFunc) {
+}
+
+MultiObjectTask::~MultiObjectTask(void) {
+	//Do not delete objects, we were responsible for ptrs only.
+	rtems_rate_monotonic_delete(periodId);
+}
+rtems_task MultiObjectTask::taskEntryPoint(rtems_task_argument argument) {
+	//The argument is re-interpreted as MultiObjectTask. The Task object is global, so it is found from any place.
+	MultiObjectTask *originalTask(reinterpret_cast<MultiObjectTask*>(argument));
+	originalTask->taskFunctionality();
+}
+
+ReturnValue_t MultiObjectTask::startTask() {
+	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
+			rtems_task_argument((void *) this));
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "ObjectTask::startTask for " << std::hex << this->getId()
+				<< std::dec << " failed." << std::endl;
+	}
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//ask started successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+/*		RTEMS_INVALID_ADDRESS - invalid task entry point
+		RTEMS_INVALID_ID - invalid task id
+		RTEMS_INCORRECT_STATE - task not in the dormant state
+		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t MultiObjectTask::sleepFor(uint32_t ms) {
+	return TaskBase::sleepFor(ms);
+}
+
+void MultiObjectTask::taskFunctionality() {
+	TaskBase::setAndStartPeriod(periodTicks,&periodId);
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		for (ObjectList::iterator it = objectList.begin();
+				it != objectList.end(); ++it) {
+			(*it)->performOperation();
+		}
+		rtems_status_code status = TaskBase::restartPeriod(periodTicks,periodId);
+		if (status == RTEMS_TIMEOUT) {
+			char nameSpace[8] = { 0 };
+			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
+					nameSpace);
+			error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
+			if (this->deadlineMissedFunc != NULL) {
+				this->deadlineMissedFunc();
+			}
+		}
+	}
+}
+
+ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	ReturnValue_t result = newObject->initializeAfterTaskCreation();
+	return result;
+}
+
+uint32_t MultiObjectTask::getPeriodMs() const {
+	return RtemsBasic::convertTicksToMs(periodTicks);
+}
diff --git a/osal/rtems/MultiObjectTask.h b/osal/rtems/MultiObjectTask.h
index 64b09c52a..b3ff66c2e 100644
--- a/osal/rtems/MultiObjectTask.h
+++ b/osal/rtems/MultiObjectTask.h
@@ -1,113 +1,113 @@
-/**
- * @file	MultiObjectTask.h
- * @brief	This file defines the MultiObjectTask class.
- * @date	30.01.2014
- * @author	baetz
- */
-#ifndef MULTIOBJECTTASK_H_
-#define MULTIOBJECTTASK_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
-
-#include "TaskBase.h"
-#include <vector>
-
-class ExecutableObjectIF;
-
-/**
- * @brief This class represents a specialized task for periodic activities of multiple objects.
- *
- * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
- * 			multiple objects that implement the ExecutableObjectIF interface. The objects must be
- * 			added prior to starting the task.
- *
- * @ingroup task_handling
- */
-class MultiObjectTask: public TaskBase, public PeriodicTaskIF {
-public:
-	/**
-	 * @brief	Standard constructor of the class.
-	 * @details	The class is initialized without allocated objects. These need to be added
-	 * 			with #addObject.
-	 * 			In the underlying TaskBase class, a new operating system task is created.
-	 * 			In addition to the TaskBase parameters, the period, the pointer to the
-	 * 			aforementioned initialization function and an optional "deadline-missed"
-	 * 			function pointer is passed.
-	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
-	 * @param stack_size	The stack size reserved by the operating system for the task.
-	 * @param setPeriod 	The length of the period with which the task's functionality will be
-	 * 						executed. It is expressed in clock ticks.
-	 * @param setDeadlineMissedFunc	The function pointer to the deadline missed function
-	 * 								that shall be assigned.
-	 */
-	MultiObjectTask(const char *name, rtems_task_priority setPriority, size_t setStack, rtems_interval 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 ~MultiObjectTask(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 RETURN_OK on success, 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:
-	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-	/**
-	 * @brief	The period of the task.
-	 * @details	The period determines the frequency of the task's execution. It is expressed in clock ticks.
-	 */
-	rtems_interval periodTicks;
-	/**
-	 * @brief id of the associated OS period
-	 */
-	rtems_id periodId;
-	/**
-	 * @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.
-	 */
-	static rtems_task taskEntryPoint(rtems_task_argument 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);
-};
-
-#endif /* MULTIOBJECTTASK_H_ */
+/**
+ * @file	MultiObjectTask.h
+ * @brief	This file defines the MultiObjectTask class.
+ * @date	30.01.2014
+ * @author	baetz
+ */
+#ifndef MULTIOBJECTTASK_H_
+#define MULTIOBJECTTASK_H_
+
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+
+#include "TaskBase.h"
+#include <vector>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief This class represents a specialized task for periodic activities of multiple objects.
+ *
+ * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
+ * 			multiple objects that implement the ExecutableObjectIF interface. The objects must be
+ * 			added prior to starting the task.
+ *
+ * @ingroup task_handling
+ */
+class MultiObjectTask: public TaskBase, public PeriodicTaskIF {
+public:
+	/**
+	 * @brief	Standard constructor of the class.
+	 * @details	The class is initialized without allocated objects. These need to be added
+	 * 			with #addObject.
+	 * 			In the underlying TaskBase class, a new operating system task is created.
+	 * 			In addition to the TaskBase parameters, the period, the pointer to the
+	 * 			aforementioned initialization function and an optional "deadline-missed"
+	 * 			function pointer is passed.
+	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
+	 * @param stack_size	The stack size reserved by the operating system for the task.
+	 * @param setPeriod 	The length of the period with which the task's functionality will be
+	 * 						executed. It is expressed in clock ticks.
+	 * @param setDeadlineMissedFunc	The function pointer to the deadline missed function
+	 * 								that shall be assigned.
+	 */
+	MultiObjectTask(const char *name, rtems_task_priority setPriority, size_t setStack, rtems_interval 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 ~MultiObjectTask(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 RETURN_OK on success, 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:
+	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+	/**
+	 * @brief	The period of the task.
+	 * @details	The period determines the frequency of the task's execution. It is expressed in clock ticks.
+	 */
+	rtems_interval periodTicks;
+	/**
+	 * @brief id of the associated OS period
+	 */
+	rtems_id periodId;
+	/**
+	 * @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.
+	 */
+	static rtems_task taskEntryPoint(rtems_task_argument 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);
+};
+
+#endif /* MULTIOBJECTTASK_H_ */
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index d094e1dce..7ead88518 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -1,65 +1,65 @@
-#include "Mutex.h"
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-const uint32_t MutexIF::NO_TIMEOUT = RTEMS_NO_TIMEOUT;
-uint8_t Mutex::count = 0;
-
-Mutex::Mutex() :
-		mutexId(0) {
-	rtems_name mutexName = ('M' << 24) + ('T' << 16) + ('X' << 8) + count++;
-	rtems_status_code status = rtems_semaphore_create(mutexName, 1,
-	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
-			&mutexId);
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
-				<< " failed with " << status << std::endl;
-	}
-}
-
-Mutex::~Mutex() {
-	rtems_status_code status = rtems_semaphore_delete(mutexId);
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "Mutex: deletion for id " << mutexId
-				<< " failed with " << status << std::endl;
-	}
-}
-
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	rtems_status_code status = rtems_semaphore_obtain(mutexId, RTEMS_WAIT, timeoutMs);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//semaphore obtained successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_UNSATISFIED:
-		//semaphore not available
-		return MUTEX_NOT_FOUND;
-	case RTEMS_TIMEOUT:
-		//timed out waiting for semaphore
-		return MUTEX_TIMEOUT;
-	case RTEMS_OBJECT_WAS_DELETED:
-		//semaphore deleted while waiting
-		return MUTEX_DESTROYED_WHILE_WAITING;
-	case RTEMS_INVALID_ID:
-		//invalid semaphore id
-		return MUTEX_INVALID_ID;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	rtems_status_code status = rtems_semaphore_release(mutexId);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//semaphore obtained successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_OWNER_OF_RESOURCE:
-		//semaphore not available
-		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	case RTEMS_INVALID_ID:
-		//invalid semaphore id
-		return MUTEX_INVALID_ID;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
+#include "Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t MutexIF::NO_TIMEOUT = RTEMS_NO_TIMEOUT;
+uint8_t Mutex::count = 0;
+
+Mutex::Mutex() :
+		mutexId(0) {
+	rtems_name mutexName = ('M' << 24) + ('T' << 16) + ('X' << 8) + count++;
+	rtems_status_code status = rtems_semaphore_create(mutexName, 1,
+	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
+			&mutexId);
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
+				<< " failed with " << status << std::endl;
+	}
+}
+
+Mutex::~Mutex() {
+	rtems_status_code status = rtems_semaphore_delete(mutexId);
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "Mutex: deletion for id " << mutexId
+				<< " failed with " << status << std::endl;
+	}
+}
+
+ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+	rtems_status_code status = rtems_semaphore_obtain(mutexId, RTEMS_WAIT, timeoutMs);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//semaphore obtained successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_UNSATISFIED:
+		//semaphore not available
+		return MUTEX_NOT_FOUND;
+	case RTEMS_TIMEOUT:
+		//timed out waiting for semaphore
+		return MUTEX_TIMEOUT;
+	case RTEMS_OBJECT_WAS_DELETED:
+		//semaphore deleted while waiting
+		return MUTEX_DESTROYED_WHILE_WAITING;
+	case RTEMS_INVALID_ID:
+		//invalid semaphore id
+		return MUTEX_INVALID_ID;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	rtems_status_code status = rtems_semaphore_release(mutexId);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//semaphore obtained successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_NOT_OWNER_OF_RESOURCE:
+		//semaphore not available
+		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	case RTEMS_INVALID_ID:
+		//invalid semaphore id
+		return MUTEX_INVALID_ID;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
diff --git a/osal/rtems/Mutex.h b/osal/rtems/Mutex.h
index 19b34e7f2..fd76b86a3 100644
--- a/osal/rtems/Mutex.h
+++ b/osal/rtems/Mutex.h
@@ -1,18 +1,18 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
-
-#include <framework/ipc/MutexIF.h>
-#include "RtemsBasic.h"
-
-class Mutex : public MutexIF {
-public:
-	Mutex();
-	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs);
-	ReturnValue_t unlockMutex();
-private:
-	rtems_id mutexId;
-	static uint8_t count;
-};
-
-#endif /* OS_RTEMS_MUTEX_H_ */
+#ifndef OS_RTEMS_MUTEX_H_
+#define OS_RTEMS_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+#include "RtemsBasic.h"
+
+class Mutex : public MutexIF {
+public:
+	Mutex();
+	~Mutex();
+	ReturnValue_t lockMutex(uint32_t timeoutMs);
+	ReturnValue_t unlockMutex();
+private:
+	rtems_id mutexId;
+	static uint8_t count;
+};
+
+#endif /* OS_RTEMS_MUTEX_H_ */
diff --git a/osal/rtems/MutexFactory.cpp b/osal/rtems/MutexFactory.cpp
index d7bd16bca..3ffab927c 100644
--- a/osal/rtems/MutexFactory.cpp
+++ b/osal/rtems/MutexFactory.cpp
@@ -1,24 +1,24 @@
-#include <framework/ipc/MutexFactory.h>
-#include "Mutex.h"
-#include "RtemsBasic.h"
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-
-MutexFactory::MutexFactory() {
-}
-
-MutexFactory::~MutexFactory() {
-}
-
-MutexFactory* MutexFactory::instance() {
-	return MutexFactory::factoryInstance;
-}
-
-MutexIF* MutexFactory::createMutex() {
-	return new Mutex();
-}
-
-void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
-}
+#include "../../ipc/MutexFactory.h"
+#include "Mutex.h"
+#include "RtemsBasic.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index a6be7ddf4..527df367d 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -1,122 +1,122 @@
-#include <framework/tasks/FixedSequenceSlot.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/osal/rtems/PollingTask.h>
-#include <framework/osal/rtems/RtemsBasic.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <rtems/bspIo.h>
-#include <rtems/rtems/ratemon.h>
-#include <rtems/rtems/status.h>
-#include <rtems/rtems/tasks.h>
-#include <rtems/rtems/types.h>
-#include <stddef.h>
-#include <sys/_stdint.h>
-#include <iostream>
-#include <list>
-
-uint32_t PollingTask::deadlineMissedCount = 0;
-
-PollingTask::PollingTask(const char *name, rtems_task_priority setPriority,
-		size_t setStack, uint32_t setOverallPeriod,
-		void (*setDeadlineMissedFunc)()) :
-		TaskBase(setPriority, setStack, name), periodId(0), pst(
-				setOverallPeriod) {
-	// All additional attributes are applied to the object.
-	this->deadlineMissedFunc = setDeadlineMissedFunc;
-}
-
-PollingTask::~PollingTask() {
-}
-
-rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
-
-	//The argument is re-interpreted as PollingTask.
-	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-	debug << "Polling task " << originalTask->getId()
-			<< " returned from taskFunctionality." << std::endl;
-}
-
-void PollingTask::missedDeadlineCounter() {
-	PollingTask::deadlineMissedCount++;
-	if (PollingTask::deadlineMissedCount % 10 == 0) {
-		error << "PST missed " << PollingTask::deadlineMissedCount
-				<< " deadlines." << std::endl;
-	}
-}
-
-ReturnValue_t PollingTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
-			rtems_task_argument((void *) this));
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "PollingTask::startTask for " << std::hex << this->getId()
-				<< std::dec << " failed." << std::endl;
-	}
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ask started successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-/*		RTEMS_INVALID_ADDRESS - invalid task entry point
-		RTEMS_INVALID_ID - invalid task id
-		RTEMS_INCORRECT_STATE - task not in the dormant state
-		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t PollingTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t PollingTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t PollingTask::checkSequence() const {
-	return pst.checkSequence();
-}
-
-#include <rtems/io.h>
-
-void PollingTask::taskFunctionality() {
-	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
-	std::list<FixedSequenceSlot*>::iterator it = pst.current;
-
-	//The start time for the first entry is read.
-	rtems_interval interval = RtemsBasic::convertMsToTicks(
-			(*it)->pollingTimeMs);
-	TaskBase::setAndStartPeriod(interval,&periodId);
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		} else {
-			//The interval for the next polling slot is selected.
-			interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
-			//The period is checked and restarted with the new interval.
-			//If the deadline was missed, the deadlineMissedFunc is called.
-			rtems_status_code status = TaskBase::restartPeriod(interval,periodId);
-			if (status == RTEMS_TIMEOUT) {
-				if (this->deadlineMissedFunc != NULL) {
-					this->deadlineMissedFunc();
-				}
-			}
-		}
-		//The device handler for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-	}
-}
-
-ReturnValue_t PollingTask::sleepFor(uint32_t ms){
-	return TaskBase::sleepFor(ms);
-};
+#include "../../tasks/FixedSequenceSlot.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../osal/rtems/PollingTask.h"
+#include "../../osal/rtems/RtemsBasic.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <rtems/bspIo.h>
+#include <rtems/rtems/ratemon.h>
+#include <rtems/rtems/status.h>
+#include <rtems/rtems/tasks.h>
+#include <rtems/rtems/types.h>
+#include <stddef.h>
+#include <sys/_stdint.h>
+#include <iostream>
+#include <list>
+
+uint32_t PollingTask::deadlineMissedCount = 0;
+
+PollingTask::PollingTask(const char *name, rtems_task_priority setPriority,
+		size_t setStack, uint32_t setOverallPeriod,
+		void (*setDeadlineMissedFunc)()) :
+		TaskBase(setPriority, setStack, name), periodId(0), pst(
+				setOverallPeriod) {
+	// All additional attributes are applied to the object.
+	this->deadlineMissedFunc = setDeadlineMissedFunc;
+}
+
+PollingTask::~PollingTask() {
+}
+
+rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
+
+	//The argument is re-interpreted as PollingTask.
+	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
+	//The task's functionality is called.
+	originalTask->taskFunctionality();
+	debug << "Polling task " << originalTask->getId()
+			<< " returned from taskFunctionality." << std::endl;
+}
+
+void PollingTask::missedDeadlineCounter() {
+	PollingTask::deadlineMissedCount++;
+	if (PollingTask::deadlineMissedCount % 10 == 0) {
+		error << "PST missed " << PollingTask::deadlineMissedCount
+				<< " deadlines." << std::endl;
+	}
+}
+
+ReturnValue_t PollingTask::startTask() {
+	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
+			rtems_task_argument((void *) this));
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "PollingTask::startTask for " << std::hex << this->getId()
+				<< std::dec << " failed." << std::endl;
+	}
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//ask started successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+/*		RTEMS_INVALID_ADDRESS - invalid task entry point
+		RTEMS_INVALID_ID - invalid task id
+		RTEMS_INCORRECT_STATE - task not in the dormant state
+		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t PollingTask::addSlot(object_id_t componentId,
+		uint32_t slotTimeMs, int8_t executionStep) {
+	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t PollingTask::getPeriodMs() const {
+	return pst.getLengthMs();
+}
+
+ReturnValue_t PollingTask::checkSequence() const {
+	return pst.checkSequence();
+}
+
+#include <rtems/io.h>
+
+void PollingTask::taskFunctionality() {
+	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
+	std::list<FixedSequenceSlot*>::iterator it = pst.current;
+
+	//The start time for the first entry is read.
+	rtems_interval interval = RtemsBasic::convertMsToTicks(
+			(*it)->pollingTimeMs);
+	TaskBase::setAndStartPeriod(interval,&periodId);
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		if (pst.slotFollowsImmediately()) {
+			//Do nothing
+		} else {
+			//The interval for the next polling slot is selected.
+			interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
+			//The period is checked and restarted with the new interval.
+			//If the deadline was missed, the deadlineMissedFunc is called.
+			rtems_status_code status = TaskBase::restartPeriod(interval,periodId);
+			if (status == RTEMS_TIMEOUT) {
+				if (this->deadlineMissedFunc != NULL) {
+					this->deadlineMissedFunc();
+				}
+			}
+		}
+		//The device handler for this slot is executed and the next one is chosen.
+		this->pst.executeAndAdvance();
+	}
+}
+
+ReturnValue_t PollingTask::sleepFor(uint32_t ms){
+	return TaskBase::sleepFor(ms);
+};
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 5bf8cf57e..759ed43d7 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -1,85 +1,85 @@
-#ifndef POLLINGTASK_H_
-#define POLLINGTASK_H_
-
-#include <framework/tasks/FixedSlotSequence.h>
-#include <framework/tasks/FixedTimeslotTaskIF.h>
-#include "TaskBase.h"
-
-class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
-	public:
-	/**
-	 * @brief	The standard constructor of the class.
-	 *
-	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
-	 * 			the following variables are passed:
-	 *
-	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
-	 *
-	 * @param	getPst The object id of the completely initialized polling sequence.
-	 */
-	PollingTask( const char *name, rtems_task_priority setPriority, size_t setStackSize, uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
-
-	/**
-	 * @brief	The destructor of the class.
-	 *
-	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
-	 * 			the device handlers. This is done by calling the PST's destructor.
-	 */
-	virtual ~PollingTask( void );
-
-	ReturnValue_t startTask( void );
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-	 */
-	static void missedDeadlineCounter();
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
-
-	uint32_t getPeriodMs() const;
-
-	ReturnValue_t checkSequence() const;
-
-	ReturnValue_t sleepFor(uint32_t ms);
-protected:
-	/**
-	* @brief id of the associated OS period
-	*/
-	rtems_id periodId;
-
-	FixedSlotSequence pst;
-
-	/**
-	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
-	 *
-	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
-	 * 			Currently, only one function for missing any deadline is allowed.
-	 * 			If not used, it shall be declared NULL.
-	 */
-	void ( *deadlineMissedFunc )( void );
-	/**
-	 * @brief	This is the entry point in a new polling thread.
-	 *
-	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
-	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
-	 * 			on success. If operation of the task is ended for some reason,
-	 * 			the destructor is called to free allocated memory.
-	 */
-	static rtems_task taskEntryPoint( rtems_task_argument argument );
-
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 *
-	 *
-	 * @details	Holding the main functionality of the task, this method is most important.
-	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
-	 * 			to keep the timing of the periods.
-	 */
-	void taskFunctionality( void );
-};
-
-#endif /* POLLINGTASK_H_ */
+#ifndef POLLINGTASK_H_
+#define POLLINGTASK_H_
+
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "TaskBase.h"
+
+class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
+	public:
+	/**
+	 * @brief	The standard constructor of the class.
+	 *
+	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
+	 * 			the following variables are passed:
+	 *
+	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
+	 *
+	 * @param	getPst The object id of the completely initialized polling sequence.
+	 */
+	PollingTask( const char *name, rtems_task_priority setPriority, size_t setStackSize, uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
+
+	/**
+	 * @brief	The destructor of the class.
+	 *
+	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
+	 * 			the device handlers. This is done by calling the PST's destructor.
+	 */
+	virtual ~PollingTask( void );
+
+	ReturnValue_t startTask( void );
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+	 */
+	static void missedDeadlineCounter();
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+
+	uint32_t getPeriodMs() const;
+
+	ReturnValue_t checkSequence() const;
+
+	ReturnValue_t sleepFor(uint32_t ms);
+protected:
+	/**
+	* @brief id of the associated OS period
+	*/
+	rtems_id periodId;
+
+	FixedSlotSequence pst;
+
+	/**
+	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
+	 *
+	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
+	 * 			Currently, only one function for missing any deadline is allowed.
+	 * 			If not used, it shall be declared NULL.
+	 */
+	void ( *deadlineMissedFunc )( void );
+	/**
+	 * @brief	This is the entry point in a new polling thread.
+	 *
+	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
+	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
+	 * 			on success. If operation of the task is ended for some reason,
+	 * 			the destructor is called to free allocated memory.
+	 */
+	static rtems_task taskEntryPoint( rtems_task_argument argument );
+
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 *
+	 *
+	 * @details	Holding the main functionality of the task, this method is most important.
+	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
+	 * 			to keep the timing of the periods.
+	 */
+	void taskFunctionality( void );
+};
+
+#endif /* POLLINGTASK_H_ */
diff --git a/osal/rtems/QueueFactory.cpp b/osal/rtems/QueueFactory.cpp
index 8cc9905cb..a492d4004 100644
--- a/osal/rtems/QueueFactory.cpp
+++ b/osal/rtems/QueueFactory.cpp
@@ -1,59 +1,59 @@
-#include <framework/ipc/QueueFactory.h>
-#include "MessageQueue.h"
-#include "RtemsBasic.h"
-
-QueueFactory* QueueFactory::factoryInstance = NULL;
-
-
-ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
-	//TODO add ignoreFault functionality
-	message->setSender(sentFrom);
-	rtems_status_code result = rtems_message_queue_send(sendTo, message->getBuffer(),
-			message->messageSize);
-	switch(result){
-	case RTEMS_SUCCESSFUL:
-			//message sent successfully
-			return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_INVALID_ID:
-			//invalid queue id
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_SIZE:
-		// invalid message size
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		//buffer is NULL
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_UNSATISFIED:
-		//out of message buffers
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_TOO_MANY:
-		//queue's limit has been reached
-		return MessageQueueIF::FULL;
-
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == NULL) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+#include "MessageQueue.h"
+#include "RtemsBasic.h"
+
+QueueFactory* QueueFactory::factoryInstance = NULL;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
+	//TODO add ignoreFault functionality
+	message->setSender(sentFrom);
+	rtems_status_code result = rtems_message_queue_send(sendTo, message->getBuffer(),
+			message->messageSize);
+	switch(result){
+	case RTEMS_SUCCESSFUL:
+			//message sent successfully
+			return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_INVALID_ID:
+			//invalid queue id
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_SIZE:
+		// invalid message size
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		//buffer is NULL
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_UNSATISFIED:
+		//out of message buffers
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_TOO_MANY:
+		//queue's limit has been reached
+		return MessageQueueIF::FULL;
+
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == NULL) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/rtems/RtemsBasic.h b/osal/rtems/RtemsBasic.h
index f7ab86144..b9aa33e88 100644
--- a/osal/rtems/RtemsBasic.h
+++ b/osal/rtems/RtemsBasic.h
@@ -1,25 +1,25 @@
-#ifndef OS_RTEMS_RTEMSBASIC_H_
-#define OS_RTEMS_RTEMSBASIC_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <rtems.h>
-#include <rtems/libio.h>
-#include <rtems/error.h>
-#include <rtems/stackchk.h>
-#include <stddef.h>
-
-
-class RtemsBasic {
-public:
-	static rtems_interval convertMsToTicks(uint32_t msIn) {
-		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-		return (ticks_per_second * msIn) / 1000;
-	}
-
-	static rtems_interval convertTicksToMs(rtems_interval ticksIn) {
-		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-		return (ticksIn * 1000) / ticks_per_second;
-	}
-};
-
-#endif /* OS_RTEMS_RTEMSBASIC_H_ */
+#ifndef OS_RTEMS_RTEMSBASIC_H_
+#define OS_RTEMS_RTEMSBASIC_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <rtems.h>
+#include <rtems/libio.h>
+#include <rtems/error.h>
+#include <rtems/stackchk.h>
+#include <stddef.h>
+
+
+class RtemsBasic {
+public:
+	static rtems_interval convertMsToTicks(uint32_t msIn) {
+		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+		return (ticks_per_second * msIn) / 1000;
+	}
+
+	static rtems_interval convertTicksToMs(rtems_interval ticksIn) {
+		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+		return (ticksIn * 1000) / ticks_per_second;
+	}
+};
+
+#endif /* OS_RTEMS_RTEMSBASIC_H_ */
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index ad795645a..b95ab51f8 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -1,82 +1,82 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include "TaskBase.h"
-
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE=RTEMS_MINIMUM_STACK_SIZE;
-
-TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
-		const char *name) {
-	rtems_name osalName = 0;
-	for (uint8_t i = 0; i < 4; i++) {
-		if (name[i] == 0) {
-			break;
-		}
-		osalName += name[i] << (8 * (3 - i));
-	}
-	//The task is created with the operating system's system call.
-	rtems_status_code status = RTEMS_UNSATISFIED;
-	if (set_priority >= 0 && set_priority <= 99) {
-		 status = rtems_task_create(osalName,
-				(0xFF - 2 * set_priority), stack_size,
-				RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
-				RTEMS_FLOATING_POINT, &id);
-	}
-	ReturnValue_t result = convertReturnCode(status);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		error << "TaskBase::TaskBase: createTask with name " << std::hex
-				<< osalName << std::dec << " failed with return code "
-				<< (uint32_t) status << std::endl;
-		this->id = 0;
-	}
-}
-
-TaskBase::~TaskBase() {
-	rtems_task_delete(id);
-}
-
-rtems_id TaskBase::getId() {
-	return this->id;
-}
-
-ReturnValue_t TaskBase::sleepFor(uint32_t ms) {
-	rtems_status_code status = rtems_task_wake_after(RtemsBasic::convertMsToTicks(ms));
-	return convertReturnCode(status);
-}
-
-
-ReturnValue_t TaskBase::convertReturnCode(rtems_status_code inValue) {
-	switch (inValue) {
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_MP_NOT_CONFIGURED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_NAME:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_TOO_MANY:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_UNSATISFIED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_PRIORITY:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-}
-
-
-ReturnValue_t TaskBase::setAndStartPeriod(rtems_interval period, rtems_id *periodId) {
-	rtems_name periodName = (('P' << 24) + ('e' << 16) + ('r' << 8) + 'd');
-	rtems_status_code status = rtems_rate_monotonic_create(periodName, periodId);
-	if (status == RTEMS_SUCCESSFUL) {
-		status = restartPeriod(period,*periodId);
-	}
-	return convertReturnCode(status);
-}
-
-rtems_status_code TaskBase::restartPeriod(rtems_interval period, rtems_id periodId){
-	//This is necessary to avoid a call with period = 0, which does not start the period.
-	rtems_status_code status = rtems_rate_monotonic_period(periodId, period + 1);
-	return status;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "TaskBase.h"
+
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE=RTEMS_MINIMUM_STACK_SIZE;
+
+TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
+		const char *name) {
+	rtems_name osalName = 0;
+	for (uint8_t i = 0; i < 4; i++) {
+		if (name[i] == 0) {
+			break;
+		}
+		osalName += name[i] << (8 * (3 - i));
+	}
+	//The task is created with the operating system's system call.
+	rtems_status_code status = RTEMS_UNSATISFIED;
+	if (set_priority >= 0 && set_priority <= 99) {
+		 status = rtems_task_create(osalName,
+				(0xFF - 2 * set_priority), stack_size,
+				RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
+				RTEMS_FLOATING_POINT, &id);
+	}
+	ReturnValue_t result = convertReturnCode(status);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		error << "TaskBase::TaskBase: createTask with name " << std::hex
+				<< osalName << std::dec << " failed with return code "
+				<< (uint32_t) status << std::endl;
+		this->id = 0;
+	}
+}
+
+TaskBase::~TaskBase() {
+	rtems_task_delete(id);
+}
+
+rtems_id TaskBase::getId() {
+	return this->id;
+}
+
+ReturnValue_t TaskBase::sleepFor(uint32_t ms) {
+	rtems_status_code status = rtems_task_wake_after(RtemsBasic::convertMsToTicks(ms));
+	return convertReturnCode(status);
+}
+
+
+ReturnValue_t TaskBase::convertReturnCode(rtems_status_code inValue) {
+	switch (inValue) {
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_MP_NOT_CONFIGURED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_NAME:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_TOO_MANY:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_UNSATISFIED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_PRIORITY:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+}
+
+
+ReturnValue_t TaskBase::setAndStartPeriod(rtems_interval period, rtems_id *periodId) {
+	rtems_name periodName = (('P' << 24) + ('e' << 16) + ('r' << 8) + 'd');
+	rtems_status_code status = rtems_rate_monotonic_create(periodName, periodId);
+	if (status == RTEMS_SUCCESSFUL) {
+		status = restartPeriod(period,*periodId);
+	}
+	return convertReturnCode(status);
+}
+
+rtems_status_code TaskBase::restartPeriod(rtems_interval period, rtems_id periodId){
+	//This is necessary to avoid a call with period = 0, which does not start the period.
+	rtems_status_code status = rtems_rate_monotonic_period(periodId, period + 1);
+	return status;
+}
diff --git a/osal/rtems/TaskBase.h b/osal/rtems/TaskBase.h
index b9c1192aa..3010a9728 100644
--- a/osal/rtems/TaskBase.h
+++ b/osal/rtems/TaskBase.h
@@ -1,47 +1,47 @@
-#ifndef TASKBASE_H_
-#define TASKBASE_H_
-
-#include "RtemsBasic.h"
-#include <framework/tasks/PeriodicTaskIF.h>
-
-/**
- * @brief	This is the basic task handling class for rtems.
- *
- * @details Task creation base class for rtems.
- */
-class TaskBase {
-protected:
-	/**
-	 * @brief	The class stores the task id it got assigned from the operating system in this attribute.
-	 * 			If initialization fails, the id is set to zero.
-	 */
-	rtems_id id;
-public:
-	/**
-	 * @brief	The constructor creates and initializes a task.
-	 * @details	This is accomplished by using the operating system call to create a task. The name is
-	 * 			created automatically with the help od taskCounter. Priority and stack size are
-	 * 			adjustable, all other attributes are set with default values.
-	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
-	 * @param stack_size	The stack size reserved by the operating system for the task.
-	 * @param nam			The name of the Task, as a null-terminated String. Currently max 4 chars supported (excluding Null-terminator), rest will be truncated
-	 */
-	TaskBase( rtems_task_priority priority, size_t stack_size, const char  *name);
-	/**
-	 * @brief	In the destructor, the created task is deleted.
-	 */
-	virtual ~TaskBase();
-	/**
-	 * @brief	This method returns the task id of this class.
-	 */
-	rtems_id getId();
-
-	ReturnValue_t sleepFor(uint32_t ms);
-	static ReturnValue_t setAndStartPeriod(rtems_interval period, rtems_id *periodId);
-	static rtems_status_code restartPeriod(rtems_interval period, rtems_id periodId);
-private:
-	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
-};
-
-
-#endif /* TASKBASE_H_ */
+#ifndef TASKBASE_H_
+#define TASKBASE_H_
+
+#include "RtemsBasic.h"
+#include "../../tasks/PeriodicTaskIF.h"
+
+/**
+ * @brief	This is the basic task handling class for rtems.
+ *
+ * @details Task creation base class for rtems.
+ */
+class TaskBase {
+protected:
+	/**
+	 * @brief	The class stores the task id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the id is set to zero.
+	 */
+	rtems_id id;
+public:
+	/**
+	 * @brief	The constructor creates and initializes a task.
+	 * @details	This is accomplished by using the operating system call to create a task. The name is
+	 * 			created automatically with the help od taskCounter. Priority and stack size are
+	 * 			adjustable, all other attributes are set with default values.
+	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
+	 * @param stack_size	The stack size reserved by the operating system for the task.
+	 * @param nam			The name of the Task, as a null-terminated String. Currently max 4 chars supported (excluding Null-terminator), rest will be truncated
+	 */
+	TaskBase( rtems_task_priority priority, size_t stack_size, const char  *name);
+	/**
+	 * @brief	In the destructor, the created task is deleted.
+	 */
+	virtual ~TaskBase();
+	/**
+	 * @brief	This method returns the task id of this class.
+	 */
+	rtems_id getId();
+
+	ReturnValue_t sleepFor(uint32_t ms);
+	static ReturnValue_t setAndStartPeriod(rtems_interval period, rtems_id *periodId);
+	static rtems_status_code restartPeriod(rtems_interval period, rtems_id periodId);
+private:
+	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
+};
+
+
+#endif /* TASKBASE_H_ */
diff --git a/osal/rtems/TaskFactory.cpp b/osal/rtems/TaskFactory.cpp
index 2bee19c76..f79571f07 100644
--- a/osal/rtems/TaskFactory.cpp
+++ b/osal/rtems/TaskFactory.cpp
@@ -1,41 +1,41 @@
-#include <framework/tasks/TaskFactory.h>
-#include "MultiObjectTask.h"
-#include "PollingTask.h"
-#include "InitTask.h"
-#include "RtemsBasic.h"
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
-
-	return static_cast<PeriodicTaskIF*>(new MultiObjectTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
-}
-
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
-	return static_cast<FixedTimeslotTaskIF*>(new PollingTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	//TODO not implemented
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
-	rtems_task_wake_after(RtemsBasic::convertMsToTicks(delayMs));
-	//Only return value is "RTEMS_SUCCESSFUL - always successful" so it has been neglected
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-TaskFactory::TaskFactory() {
-}
+#include "../../tasks/TaskFactory.h"
+#include "MultiObjectTask.h"
+#include "PollingTask.h"
+#include "InitTask.h"
+#include "RtemsBasic.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
+
+	return static_cast<PeriodicTaskIF*>(new MultiObjectTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
+	return static_cast<FixedTimeslotTaskIF*>(new PollingTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	//TODO not implemented
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
+	rtems_task_wake_after(RtemsBasic::convertMsToTicks(delayMs));
+	//Only return value is "RTEMS_SUCCESSFUL - always successful" so it has been neglected
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+TaskFactory::TaskFactory() {
+}
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 02f363184..14446e3c1 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -1,67 +1,67 @@
-#ifndef HASPARAMETERSIF_H_
-#define HASPARAMETERSIF_H_
-
-#include <framework/parameters/ParameterWrapper.h>
-#include <framework/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;
-	static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
-
-	static uint8_t getDomain(ParameterId_t id) {
-		return id >> 24;
-	}
-
-	static uint16_t getMatrixId(ParameterId_t id) {
-		return id >> 8;
-	}
-
-	static uint8_t getIndex(ParameterId_t id) {
-		return id;
-	}
-
-	static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
-			uint8_t index) {
-		return (domainId << 24) + (parameterId << 8) + index;
-	}
-
-	virtual ~HasParametersIF() {}
-
-	/**
-	 * Always set parameter before checking newValues!
-	 *
-	 * @param domainId
-	 * @param parameterId
-	 * @param parameterWrapper
-	 * @param newValues
-	 * @param startAtIndex
-	 * @return
-	 */
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
-};
-
-#endif /* HASPARAMETERSIF_H_ */
+#ifndef HASPARAMETERSIF_H_
+#define HASPARAMETERSIF_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;
+	static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
+
+	static uint8_t getDomain(ParameterId_t id) {
+		return id >> 24;
+	}
+
+	static uint16_t getMatrixId(ParameterId_t id) {
+		return id >> 8;
+	}
+
+	static uint8_t getIndex(ParameterId_t id) {
+		return id;
+	}
+
+	static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
+			uint8_t index) {
+		return (domainId << 24) + (parameterId << 8) + index;
+	}
+
+	virtual ~HasParametersIF() {}
+
+	/**
+	 * Always set parameter before checking newValues!
+	 *
+	 * @param domainId
+	 * @param parameterId
+	 * @param parameterWrapper
+	 * @param newValues
+	 * @param startAtIndex
+	 * @return
+	 */
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
+};
+
+#endif /* HASPARAMETERSIF_H_ */
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 53f1229ff..55633566f 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -1,132 +1,132 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/parameters/ParameterHelper.h>
-#include <framework/parameters/ParameterMessage.h>
-
-ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-		owner(owner) {}
-
-ParameterHelper::~ParameterHelper() {
-}
-
-ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch (message->getCommand()) {
-	case ParameterMessage::CMD_PARAMETER_DUMP: {
-		ParameterWrapper description;
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(message));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(message));
-		result = owner->getParameter(domain, parameterId,
-				&description, &description, 0);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &description);
-		}
-	}
-		break;
-	case ParameterMessage::CMD_PARAMETER_LOAD: {
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(message));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(message));
-		uint8_t index = HasParametersIF::getIndex(
-				ParameterMessage::getParameterId(message));
-
-		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;
-		}
-
-		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(storedStream, storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
-		}
-
-		ParameterWrapper ownerWrapper;
-		result = owner->getParameter(domain, parameterId, &ownerWrapper,
-				&streamWrapper, index);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
-		}
-
-		result = ownerWrapper.copyFrom(&streamWrapper, index);
-
-		storage->deleteData(ParameterMessage::getStoreId(message));
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &ownerWrapper);
-		}
-	}
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		rejectCommand(message->getSender(), result, message->getCommand());
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
-		const ParameterWrapper* description) {
-	size_t serializedSize = description->getSerializedSize();
-
-	uint8_t *storeElement;
-	store_address_t address;
-
-	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
-			&storeElement);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	size_t storeElementSize = 0;
-
-	result = description->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		storage->deleteData(address);
-		return result;
-	}
-
-	CommandMessage reply;
-
-	ParameterMessage::setParameterDumpReply(&reply, id, address);
-
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ParameterHelper::initialize() {
-	ownerQueueId = owner->getCommandQueue();
-
-
-	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (storage == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	} else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
-
-void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-		Command_t initialCommand) {
-	CommandMessage reply;
-	reply.setReplyRejected(reason, initialCommand);
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../parameters/ParameterHelper.h"
+#include "../parameters/ParameterMessage.h"
+
+ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
+		owner(owner) {}
+
+ParameterHelper::~ParameterHelper() {
+}
+
+ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	switch (message->getCommand()) {
+	case ParameterMessage::CMD_PARAMETER_DUMP: {
+		ParameterWrapper description;
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(message));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(message));
+		result = owner->getParameter(domain, parameterId,
+				&description, &description, 0);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(message->getSender(),
+					ParameterMessage::getParameterId(message), &description);
+		}
+	}
+		break;
+	case ParameterMessage::CMD_PARAMETER_LOAD: {
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(message));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(message));
+		uint8_t index = HasParametersIF::getIndex(
+				ParameterMessage::getParameterId(message));
+
+		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;
+		}
+
+		ParameterWrapper streamWrapper;
+		result = streamWrapper.set(storedStream, storedStreamSize);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(message));
+			break;
+		}
+
+		ParameterWrapper ownerWrapper;
+		result = owner->getParameter(domain, parameterId, &ownerWrapper,
+				&streamWrapper, index);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(message));
+			break;
+		}
+
+		result = ownerWrapper.copyFrom(&streamWrapper, index);
+
+		storage->deleteData(ParameterMessage::getStoreId(message));
+
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(message->getSender(),
+					ParameterMessage::getParameterId(message), &ownerWrapper);
+		}
+	}
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		rejectCommand(message->getSender(), result, message->getCommand());
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
+		const ParameterWrapper* description) {
+	size_t serializedSize = description->getSerializedSize();
+
+	uint8_t *storeElement;
+	store_address_t address;
+
+	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
+			&storeElement);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	size_t storeElementSize = 0;
+
+	result = description->serialize(&storeElement, &storeElementSize,
+			serializedSize, SerializeIF::Endianness::BIG);
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		storage->deleteData(address);
+		return result;
+	}
+
+	CommandMessage reply;
+
+	ParameterMessage::setParameterDumpReply(&reply, id, address);
+
+	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterHelper::initialize() {
+	ownerQueueId = owner->getCommandQueue();
+
+
+	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (storage == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	} else {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
+void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+		Command_t initialCommand) {
+	CommandMessage reply;
+	reply.setReplyRejected(reason, initialCommand);
+	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+}
diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index 538aaac6f..668bb081c 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -1,36 +1,36 @@
-#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
-#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
-
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/parameters/ParameterMessage.h>
-#include <framework/parameters/ReceivesParameterMessagesIF.h>
-
-/**
- * @brief	Helper class to handle parameter messages
- * @details
- * This class simplfiies handling of parameter messages, which are sent
- * to a class which implements ReceivesParameterMessagesIF.
- */
-class ParameterHelper {
-public:
-	ParameterHelper(ReceivesParameterMessagesIF *owner);
-	virtual ~ParameterHelper();
-
-	ReturnValue_t handleParameterMessage(CommandMessage *message);
-
-	ReturnValue_t initialize();
-private:
-	ReceivesParameterMessagesIF *owner;
-
-	MessageQueueId_t ownerQueueId = MessageQueueIF::NO_QUEUE;
-
-	StorageManagerIF *storage = nullptr;
-
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
-			const ParameterWrapper *description);
-
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-			Command_t initialCommand);
-};
-
-#endif /* PARAMETERHELPER_H_ */
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
+#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
+
+#include "../ipc/MessageQueueIF.h"
+#include "../parameters/ParameterMessage.h"
+#include "../parameters/ReceivesParameterMessagesIF.h"
+
+/**
+ * @brief	Helper class to handle parameter messages
+ * @details
+ * This class simplfiies handling of parameter messages, which are sent
+ * to a class which implements ReceivesParameterMessagesIF.
+ */
+class ParameterHelper {
+public:
+	ParameterHelper(ReceivesParameterMessagesIF *owner);
+	virtual ~ParameterHelper();
+
+	ReturnValue_t handleParameterMessage(CommandMessage *message);
+
+	ReturnValue_t initialize();
+private:
+	ReceivesParameterMessagesIF *owner;
+
+	MessageQueueId_t ownerQueueId = MessageQueueIF::NO_QUEUE;
+
+	StorageManagerIF *storage = nullptr;
+
+	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
+			const ParameterWrapper *description);
+
+	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+			Command_t initialCommand);
+};
+
+#endif /* PARAMETERHELPER_H_ */
diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp
index 1c7d6911d..0cc4dd90a 100644
--- a/parameters/ParameterMessage.cpp
+++ b/parameters/ParameterMessage.cpp
@@ -1,48 +1,48 @@
-#include <framework/parameters/ParameterMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-store_address_t ParameterMessage::getStoreId(const CommandMessage* message) {
-	store_address_t address;
-	address.raw = message->getParameter2();
-	return address;
-}
-
-void ParameterMessage::setParameterDumpCommand(CommandMessage* message,
-		ParameterId_t id) {
-	message->setCommand(CMD_PARAMETER_DUMP);
-	message->setParameter(id);
-}
-
-void ParameterMessage::setParameterDumpReply(CommandMessage* message,
-		ParameterId_t id, store_address_t storageID) {
-	message->setCommand(REPLY_PARAMETER_DUMP);
-	message->setParameter(id);
-	message->setParameter2(storageID.raw);
-}
-
-void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
-		ParameterId_t id, store_address_t storageID) {
-	message->setCommand(CMD_PARAMETER_LOAD);
-	message->setParameter(id);
-	message->setParameter2(storageID.raw);
-}
-
-void ParameterMessage::clear(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case CMD_PARAMETER_LOAD:
-	case REPLY_PARAMETER_DUMP: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-}
+#include "../parameters/ParameterMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+store_address_t ParameterMessage::getStoreId(const CommandMessage* message) {
+	store_address_t address;
+	address.raw = message->getParameter2();
+	return address;
+}
+
+void ParameterMessage::setParameterDumpCommand(CommandMessage* message,
+		ParameterId_t id) {
+	message->setCommand(CMD_PARAMETER_DUMP);
+	message->setParameter(id);
+}
+
+void ParameterMessage::setParameterDumpReply(CommandMessage* message,
+		ParameterId_t id, store_address_t storageID) {
+	message->setCommand(REPLY_PARAMETER_DUMP);
+	message->setParameter(id);
+	message->setParameter2(storageID.raw);
+}
+
+void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
+		ParameterId_t id, store_address_t storageID) {
+	message->setCommand(CMD_PARAMETER_LOAD);
+	message->setParameter(id);
+	message->setParameter2(storageID.raw);
+}
+
+void ParameterMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_PARAMETER_LOAD:
+	case REPLY_PARAMETER_DUMP: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(message));
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 432832941..51321f2b7 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -1,29 +1,29 @@
-#ifndef PARAMETERMESSAGE_H_
-#define PARAMETERMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-
-class ParameterMessage {
-private:
-	ParameterMessage();
-public:
-	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 );
-
-	static ParameterId_t getParameterId(const CommandMessage* message);
-	static store_address_t getStoreId(const CommandMessage* message);
-	static void setParameterDumpCommand(CommandMessage* message,
-			ParameterId_t id);
-	static void setParameterDumpReply(CommandMessage* message,
-			ParameterId_t id,  store_address_t storageID);
-	static void setParameterLoadCommand(CommandMessage* message,
-			ParameterId_t id, store_address_t storageID);
-	static void clear(CommandMessage* message);
-
-};
-
-#endif /* PARAMETERMESSAGE_H_ */
+#ifndef PARAMETERMESSAGE_H_
+#define PARAMETERMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../parameters/HasParametersIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+class ParameterMessage {
+private:
+	ParameterMessage();
+public:
+	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 );
+
+	static ParameterId_t getParameterId(const CommandMessage* message);
+	static store_address_t getStoreId(const CommandMessage* message);
+	static void setParameterDumpCommand(CommandMessage* message,
+			ParameterId_t id);
+	static void setParameterDumpReply(CommandMessage* message,
+			ParameterId_t id,  store_address_t storageID);
+	static void setParameterLoadCommand(CommandMessage* message,
+			ParameterId_t id, store_address_t storageID);
+	static void clear(CommandMessage* message);
+
+};
+
+#endif /* PARAMETERMESSAGE_H_ */
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 521a6644c..8e6dd86c0 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -1,280 +1,280 @@
-#include <framework/parameters/ParameterWrapper.h>
-
-ParameterWrapper::ParameterWrapper() :
-		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) {
-}
-
-ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-		const void *data) :
-		pointsToStream(false), type(type), rows(rows), columns(columns),
-		data(nullptr), readonlyData(data) {
-}
-
-ParameterWrapper::~ParameterWrapper() {
-}
-
-ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result;
-
-	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	//serialize uses readonlyData, as it is always valid
-	if (readonlyData == NULL) {
-		return NOT_SET;
-	}
-	switch (type) {
-	case Type::UINT8_T:
-		result = serializeData<uint8_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::INT8_T:
-		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
-		break;
-	case Type::UINT16_T:
-		result = serializeData<uint16_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::INT16_T:
-		result = serializeData<int16_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::UINT32_T:
-		result = serializeData<uint32_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::INT32_T:
-		result = serializeData<int32_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::FLOAT:
-		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
-		break;
-	case Type::DOUBLE:
-		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
-		break;
-	default:
-		result = UNKNOW_DATATYPE;
-		break;
-	}
-	return result;
-}
-
-size_t ParameterWrapper::getSerializedSize() const {
-	uint32_t serializedSize = 0;
-	serializedSize += type.getSerializedSize();
-	serializedSize += sizeof(rows);
-	serializedSize += sizeof(columns);
-	serializedSize += rows * columns * type.getSize();
-
-	return serializedSize;
-}
-
-template<typename T>
-ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
-		size_t maxSize, Endianness streamEndianness) const {
-	const T *element = (const T*) readonlyData;
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	uint16_t dataSize = columns * rows;
-	while (dataSize != 0) {
-		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		element++;
-		dataSize--;
-	}
-	return result;
-}
-
-template<typename T>
-ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
-		uint8_t startingColumn, const void *from, uint8_t fromRows,
-		uint8_t fromColumns) {
-
-	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t*) from;
-	size_t streamSize = fromRows * fromColumns * sizeof(T);
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-
-	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
-
-		//get the start element of this row in data
-		T *dataWithDataType = ((T*) data)
-				+ (((startingRow + fromRow) * columns) + startingColumn);
-
-		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
-			result = SerializeAdapter::deSerialize(
-					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
-					SerializeIF::Endianness::BIG);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-	}
-
-	return result;
-
-}
-
-
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
-		size_t *size, Endianness streamEndianness) {
-	return deSerialize(buffer, size, streamEndianness, 0);
-}
-
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
-		size_t *size, Endianness streamEndianness,
-		uint16_t startWritingAtIndex) {
-	ParameterWrapper streamDescription;
-
-	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	return copyFrom(&streamDescription, startWritingAtIndex);
-}
-
-ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
-		const uint8_t **remainingStream, size_t *remainingSize) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
-			&streamSize, SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	size_t dataSize = type.getSize() * rows * columns;
-
-	if (streamSize < dataSize) {
-		return SerializeIF::STREAM_TOO_SHORT;
-	}
-
-	data = nullptr;
-	readonlyData = stream;
-	pointsToStream = true;
-
-	stream += dataSize;
-	if (remainingStream !=  nullptr) {
-		*remainingStream = stream;
-	}
-	streamSize -= dataSize;
-	if (remainingSize != nullptr) {
-		*remainingSize = streamSize;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
-		uint16_t startWritingAtIndex) {
-	if (data == NULL) {
-		return READONLY;
-	}
-
-	if (from->readonlyData == NULL) {
-		return SOURCE_NOT_SET;
-	}
-
-	if (type != from->type) {
-		return DATATYPE_MISSMATCH;
-	}
-
-	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
-
-	if ((from->rows > (rows - startingRow))
-			|| (from->columns > (columns - startingColumn))) {
-		return TOO_BIG;
-	}
-
-	uint8_t typeSize = type.getSize();
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	//copy data
-	if (from->pointsToStream) {
-		switch (type) {
-		case Type::UINT8_T:
-			result = deSerializeData<uint8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::INT8_T:
-			result = deSerializeData<int8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::UINT16_T:
-			result = deSerializeData<uint16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::INT16_T:
-			result = deSerializeData<int16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::UINT32_T:
-			result = deSerializeData<uint32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::INT32_T:
-			result = deSerializeData<int32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::FLOAT:
-			result = deSerializeData<float>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::DOUBLE:
-			result = deSerializeData<double>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		default:
-			result = UNKNOW_DATATYPE;
-			break;
-		}
-	}
-	else {
-		//need a type to do arithmetic
-		uint8_t* typedData = static_cast<uint8_t*>(data);
-		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
-			uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
-			std::memcpy(typedData +  offset, from->readonlyData,
-					typeSize * from->columns);
-		}
-	}
-
-	return result;
-}
+#include "../parameters/ParameterWrapper.h"
+
+ParameterWrapper::ParameterWrapper() :
+		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) {
+}
+
+ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+		const void *data) :
+		pointsToStream(false), type(type), rows(rows), columns(columns),
+		data(nullptr), readonlyData(data) {
+}
+
+ParameterWrapper::~ParameterWrapper() {
+}
+
+ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result;
+
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	//serialize uses readonlyData, as it is always valid
+	if (readonlyData == NULL) {
+		return NOT_SET;
+	}
+	switch (type) {
+	case Type::UINT8_T:
+		result = serializeData<uint8_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT8_T:
+		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
+		break;
+	case Type::UINT16_T:
+		result = serializeData<uint16_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT16_T:
+		result = serializeData<int16_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::UINT32_T:
+		result = serializeData<uint32_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT32_T:
+		result = serializeData<int32_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::FLOAT:
+		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
+		break;
+	case Type::DOUBLE:
+		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
+		break;
+	default:
+		result = UNKNOW_DATATYPE;
+		break;
+	}
+	return result;
+}
+
+size_t ParameterWrapper::getSerializedSize() const {
+	uint32_t serializedSize = 0;
+	serializedSize += type.getSerializedSize();
+	serializedSize += sizeof(rows);
+	serializedSize += sizeof(columns);
+	serializedSize += rows * columns * type.getSize();
+
+	return serializedSize;
+}
+
+template<typename T>
+ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
+	const T *element = (const T*) readonlyData;
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	uint16_t dataSize = columns * rows;
+	while (dataSize != 0) {
+		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		element++;
+		dataSize--;
+	}
+	return result;
+}
+
+template<typename T>
+ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
+		uint8_t startingColumn, const void *from, uint8_t fromRows,
+		uint8_t fromColumns) {
+
+	//treat from as a continuous Stream as we copy all of it
+	const uint8_t *fromAsStream = (const uint8_t*) from;
+	size_t streamSize = fromRows * fromColumns * sizeof(T);
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+
+	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
+
+		//get the start element of this row in data
+		T *dataWithDataType = ((T*) data)
+				+ (((startingRow + fromRow) * columns) + startingColumn);
+
+		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
+			result = SerializeAdapter::deSerialize(
+					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
+					SerializeIF::Endianness::BIG);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+	}
+
+	return result;
+
+}
+
+
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness) {
+	return deSerialize(buffer, size, streamEndianness, 0);
+}
+
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness,
+		uint16_t startWritingAtIndex) {
+	ParameterWrapper streamDescription;
+
+	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return copyFrom(&streamDescription, startWritingAtIndex);
+}
+
+ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
+		const uint8_t **remainingStream, size_t *remainingSize) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
+			&streamSize, SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	size_t dataSize = type.getSize() * rows * columns;
+
+	if (streamSize < dataSize) {
+		return SerializeIF::STREAM_TOO_SHORT;
+	}
+
+	data = nullptr;
+	readonlyData = stream;
+	pointsToStream = true;
+
+	stream += dataSize;
+	if (remainingStream !=  nullptr) {
+		*remainingStream = stream;
+	}
+	streamSize -= dataSize;
+	if (remainingSize != nullptr) {
+		*remainingSize = streamSize;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
+		uint16_t startWritingAtIndex) {
+	if (data == NULL) {
+		return READONLY;
+	}
+
+	if (from->readonlyData == NULL) {
+		return SOURCE_NOT_SET;
+	}
+
+	if (type != from->type) {
+		return DATATYPE_MISSMATCH;
+	}
+
+	//check if from fits into this
+	uint8_t startingRow = startWritingAtIndex / columns;
+	uint8_t startingColumn = startWritingAtIndex % columns;
+
+	if ((from->rows > (rows - startingRow))
+			|| (from->columns > (columns - startingColumn))) {
+		return TOO_BIG;
+	}
+
+	uint8_t typeSize = type.getSize();
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	//copy data
+	if (from->pointsToStream) {
+		switch (type) {
+		case Type::UINT8_T:
+			result = deSerializeData<uint8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT8_T:
+			result = deSerializeData<int8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::UINT16_T:
+			result = deSerializeData<uint16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT16_T:
+			result = deSerializeData<int16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::UINT32_T:
+			result = deSerializeData<uint32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT32_T:
+			result = deSerializeData<int32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::FLOAT:
+			result = deSerializeData<float>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::DOUBLE:
+			result = deSerializeData<double>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		default:
+			result = UNKNOW_DATATYPE;
+			break;
+		}
+	}
+	else {
+		//need a type to do arithmetic
+		uint8_t* typedData = static_cast<uint8_t*>(data);
+		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
+			uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
+			std::memcpy(typedData +  offset, from->readonlyData,
+					typeSize * from->columns);
+		}
+	}
+
+	return result;
+}
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index eec101f27..1f38f6915 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -1,162 +1,162 @@
-#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
-#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serialize/SerializeIF.h>
-#include <stddef.h>
-#include <framework/globalfunctions/Type.h>
-
-/**
- * @brief
- * @details
- */
-class ParameterWrapper: public SerializeIF {
-	friend class DataPoolParameterWrapper;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::PARAMETER_WRAPPER;
-	static const ReturnValue_t UNKNOW_DATATYPE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
-	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
-
-	ParameterWrapper();
-	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
-	ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-			const void *data);
-	virtual ~ParameterWrapper();
-
-	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;
-
-	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;
-
-	template<typename T>
-	void set(T *data, uint8_t rows, uint8_t columns) {
-		this->data = data;
-		this->readonlyData = data;
-		this->type = PodTypeConversion<T>::type;
-		this->rows = rows;
-		this->columns = columns;
-		this->pointsToStream = false;
-	}
-
-	template<typename T>
-	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
-		this->data = NULL;
-		this->readonlyData = readonlyData;
-		this->type = PodTypeConversion<T>::type;
-		this->rows = rows;
-		this->columns = columns;
-		this->pointsToStream = false;
-	}
-
-	template<typename T>
-	void set(T& member) {
-		this->set(&member, 1, 1);
-	}
-
-	template<typename T>
-	void set(const T& readonlyMember) {
-		this->set(&readonlyMember, 1, 1);
-	}
-
-	template<typename T>
-	void setVector(T& member) {
-		this->set(member, sizeof(member)/sizeof(member[0]), 1);
-	}
-
-	template<typename T>
-	void setVector(const T& member) {
-		this->set(member, 1, sizeof(member)/sizeof(member[0]));
-	}
-	template<typename T>
-	void setMatrix(T& member) {
-		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
-	}
-
-	template<typename T>
-	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 = nullptr,
-			size_t *remainingSize = nullptr);
-
-	ReturnValue_t copyFrom(const ParameterWrapper *from,
-			uint16_t startWritingAtIndex);
-
-private:
-	bool pointsToStream = false;
-
-	Type type;
-	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,
-			size_t maxSize, Endianness streamEndianness) const;
-
-	template<typename T>
-	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
-			const void *from, uint8_t fromRows, uint8_t fromColumns);
-};
-
-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 /* PARAMETERWRAPPER_H_ */
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
+#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeIF.h"
+#include <stddef.h>
+#include "../globalfunctions/Type.h"
+
+/**
+ * @brief
+ * @details
+ */
+class ParameterWrapper: public SerializeIF {
+	friend class DataPoolParameterWrapper;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::PARAMETER_WRAPPER;
+	static const ReturnValue_t UNKNOW_DATATYPE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
+	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
+
+	ParameterWrapper();
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+			const void *data);
+	virtual ~ParameterWrapper();
+
+	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;
+
+	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;
+
+	template<typename T>
+	void set(T *data, uint8_t rows, uint8_t columns) {
+		this->data = data;
+		this->readonlyData = data;
+		this->type = PodTypeConversion<T>::type;
+		this->rows = rows;
+		this->columns = columns;
+		this->pointsToStream = false;
+	}
+
+	template<typename T>
+	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
+		this->data = NULL;
+		this->readonlyData = readonlyData;
+		this->type = PodTypeConversion<T>::type;
+		this->rows = rows;
+		this->columns = columns;
+		this->pointsToStream = false;
+	}
+
+	template<typename T>
+	void set(T& member) {
+		this->set(&member, 1, 1);
+	}
+
+	template<typename T>
+	void set(const T& readonlyMember) {
+		this->set(&readonlyMember, 1, 1);
+	}
+
+	template<typename T>
+	void setVector(T& member) {
+		this->set(member, sizeof(member)/sizeof(member[0]), 1);
+	}
+
+	template<typename T>
+	void setVector(const T& member) {
+		this->set(member, 1, sizeof(member)/sizeof(member[0]));
+	}
+	template<typename T>
+	void setMatrix(T& member) {
+		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+	}
+
+	template<typename T>
+	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 = nullptr,
+			size_t *remainingSize = nullptr);
+
+	ReturnValue_t copyFrom(const ParameterWrapper *from,
+			uint16_t startWritingAtIndex);
+
+private:
+	bool pointsToStream = false;
+
+	Type type;
+	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,
+			size_t maxSize, Endianness streamEndianness) const;
+
+	template<typename T>
+	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
+			const void *from, uint8_t fromRows, uint8_t fromColumns);
+};
+
+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 /* PARAMETERWRAPPER_H_ */
diff --git a/parameters/ReceivesParameterMessagesIF.h b/parameters/ReceivesParameterMessagesIF.h
index 9bcd226dd..9a280b4f1 100644
--- a/parameters/ReceivesParameterMessagesIF.h
+++ b/parameters/ReceivesParameterMessagesIF.h
@@ -1,19 +1,19 @@
-#ifndef RECEIVESPARAMETERMESSAGESIF_H_
-#define RECEIVESPARAMETERMESSAGESIF_H_
-
-
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class ReceivesParameterMessagesIF : public HasParametersIF {
-public:
-
-	static const uint8_t DOMAIN_ID_BASE = 0;
-	virtual ~ReceivesParameterMessagesIF() {
-	}
-
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-};
-
-
-#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
+#ifndef RECEIVESPARAMETERMESSAGESIF_H_
+#define RECEIVESPARAMETERMESSAGESIF_H_
+
+
+#include "../parameters/HasParametersIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class ReceivesParameterMessagesIF : public HasParametersIF {
+public:
+
+	static const uint8_t DOMAIN_ID_BASE = 0;
+	virtual ~ReceivesParameterMessagesIF() {
+	}
+
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+};
+
+
+#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index b18b5b1ad..59d60491c 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -1,260 +1,260 @@
-#include <framework/monitoring/LimitViolationReporter.h>
-#include <framework/monitoring/MonitoringMessageContent.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/power/Fuse.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
-#include <framework/ipc/QueueFactory.h>
-
-object_id_t Fuse::powerSwitchId = 0;
-
-Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
-		float maxCurrent, uint16_t confirmationCount) :
-		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
-		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
-				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
-				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
-				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
-				ids.pidCurrent, &set), state(ids.pidState, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
-				NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Fuse::~Fuse() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-void Fuse::addDevice(PowerComponentIF* switchSet) {
-	devices.push_back(switchSet);
-}
-
-ReturnValue_t Fuse::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = parameterHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = healthHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	powerIF = objectManager->get<PowerSwitchIF>(powerSwitchId);
-	if (powerIF == NULL) {
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void Fuse::calculatePowerLimits(float* low, float* high) {
-	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
-			iter++) {
-		if (areSwitchesOfComponentOn(iter)) {
-			*low += (*iter)->getMin();
-			*high += (*iter)->getMax();
-		}
-	}
-}
-
-ReturnValue_t Fuse::check() {
-	set.read();
-	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
-		setAllMonitorsToUnchecked();
-		set.commit(PoolVariableIF::INVALID);
-		return RETURN_OK;
-	}
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	checkFuseState();
-	calculateFusePower();
-	//Check if power is valid and if fuse state is off or invalid.
-	if (!power.isValid() || (state == 0) || !state.isValid()) {
-		result = powerMonitor.setToInvalid();
-	} else {
-		float lowLimit = 0.0;
-		float highLimit = RESIDUAL_POWER;
-		calculatePowerLimits(&lowLimit, &highLimit);
-		result = powerMonitor.checkPower(power, lowLimit, highLimit);
-		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
-			reportEvents(POWER_BELOW_LOW_LIMIT);
-		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
-			reportEvents(POWER_ABOVE_HIGH_LIMIT);
-		}
-	}
-	set.commit();
-	return result;
-}
-
-ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = RETURN_FAILED;
-	for (DeviceList::const_iterator iter = devices.begin();
-			iter != devices.end(); iter++) {
-		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return RETURN_OK;
-}
-
-size_t Fuse::getSerializedSize() const {
-	uint32_t size = 0;
-	for (DeviceList::const_iterator iter = devices.begin();
-			iter != devices.end(); iter++) {
-		size += (*iter)->getSerializedSize();
-	}
-	return size;
-}
-
-ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
-        Endianness streamEndianness) {
-	ReturnValue_t result = RETURN_FAILED;
-	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
-			iter++) {
-		result = (*iter)->deSerialize(buffer, size, streamEndianness);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return RETURN_OK;
-}
-
-uint8_t Fuse::getFuseId() const {
-	return fuseId;
-}
-
-void Fuse::calculateFusePower() {
-	ReturnValue_t result1 = currentLimit.check();
-	if (result1 != HasReturnvaluesIF::RETURN_OK || !(voltage.isValid())) {
-		power.setValid(PoolVariableIF::INVALID);
-		return;
-	}
-	//Calculate fuse power.
-	power = current * voltage;
-	power.setValid(PoolVariableIF::VALID);
-}
-
-ReturnValue_t Fuse::performOperation(uint8_t opCode) {
-	checkCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Fuse::reportEvents(Event event) {
-	if (!powerMonitor.isEventEnabled()) {
-		return;
-	}
-	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
-			iter++) {
-		if (areSwitchesOfComponentOn(iter)) {
-			EventManagerIF::triggerEvent((*iter)->getDeviceObjectId(), event);
-		}
-	}
-}
-
-MessageQueueId_t Fuse::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void Fuse::setAllMonitorsToUnchecked() {
-	currentLimit.setToUnchecked();
-	powerMonitor.setToUnchecked();
-}
-
-void Fuse::checkCommandQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = healthHelper.handleHealthCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = parameterHelper.handleParameterMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	command.setToUnknownCommand();
-	commandQueue->reply(&command);
-}
-
-void Fuse::checkFuseState() {
-	if (!state.isValid()) {
-		oldFuseState = 0;
-		return;
-	}
-	if (state == 0) {
-		if (oldFuseState != 0) {
-			reportEvents(FUSE_WENT_OFF);
-		}
-	}
-	oldFuseState = state;
-}
-
-float Fuse::getPower() {
-	if (power.isValid()) {
-		return power;
-	} else {
-		return 0.0;
-	}
-}
-
-void Fuse::setDataPoolEntriesInvalid() {
-	set.read();
-	set.commit(PoolVariableIF::INVALID);
-}
-
-ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = powerMonitor.getParameter(domainId, parameterId, parameterWrapper,
-			newValues, startAtIndex);
-	return result;
-}
-
-bool Fuse::areSwitchesOfComponentOn(DeviceList::iterator iter) {
-	if (powerIF->getSwitchState((*iter)->getSwitchId1())
-			!= PowerSwitchIF::SWITCH_ON) {
-		return false;
-	}
-	if ((*iter)->hasTwoSwitches()) {
-		if ((powerIF->getSwitchState((*iter)->getSwitchId2())
-				!= PowerSwitchIF::SWITCH_ON)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool Fuse::isPowerValid() {
-	return power.isValid();
-}
-
-ReturnValue_t Fuse::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return RETURN_OK;
-}
-
-HasHealthIF::HealthState Fuse::getHealth() {
-	return healthHelper.getHealth();
-}
-
-ReturnValue_t Fuse::PowerMonitor::checkPower(float sample, float lowerLimit,
-		float upperLimit) {
-	if (sample > upperLimit) {
-		return this->monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
-				upperLimit);
-	} else if (sample < lowerLimit) {
-		return this->monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
-				lowerLimit);
-	} else {
-		return this->monitorStateIs(RETURN_OK, sample, 0.0); //Within limits.
-	}
-}
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../power/Fuse.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../ipc/QueueFactory.h"
+
+object_id_t Fuse::powerSwitchId = 0;
+
+Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
+		float maxCurrent, uint16_t confirmationCount) :
+		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
+		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
+				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
+				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
+				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
+				ids.pidCurrent, &set), state(ids.pidState, &set), power(
+				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
+				NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
+	commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Fuse::~Fuse() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+void Fuse::addDevice(PowerComponentIF* switchSet) {
+	devices.push_back(switchSet);
+}
+
+ReturnValue_t Fuse::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	powerIF = objectManager->get<PowerSwitchIF>(powerSwitchId);
+	if (powerIF == NULL) {
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void Fuse::calculatePowerLimits(float* low, float* high) {
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		if (areSwitchesOfComponentOn(iter)) {
+			*low += (*iter)->getMin();
+			*high += (*iter)->getMax();
+		}
+	}
+}
+
+ReturnValue_t Fuse::check() {
+	set.read();
+	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
+		setAllMonitorsToUnchecked();
+		set.commit(PoolVariableIF::INVALID);
+		return RETURN_OK;
+	}
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	checkFuseState();
+	calculateFusePower();
+	//Check if power is valid and if fuse state is off or invalid.
+	if (!power.isValid() || (state == 0) || !state.isValid()) {
+		result = powerMonitor.setToInvalid();
+	} else {
+		float lowLimit = 0.0;
+		float highLimit = RESIDUAL_POWER;
+		calculatePowerLimits(&lowLimit, &highLimit);
+		result = powerMonitor.checkPower(power, lowLimit, highLimit);
+		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
+			reportEvents(POWER_BELOW_LOW_LIMIT);
+		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
+			reportEvents(POWER_ABOVE_HIGH_LIMIT);
+		}
+	}
+	set.commit();
+	return result;
+}
+
+ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = RETURN_FAILED;
+	for (DeviceList::const_iterator iter = devices.begin();
+			iter != devices.end(); iter++) {
+		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return RETURN_OK;
+}
+
+size_t Fuse::getSerializedSize() const {
+	uint32_t size = 0;
+	for (DeviceList::const_iterator iter = devices.begin();
+			iter != devices.end(); iter++) {
+		size += (*iter)->getSerializedSize();
+	}
+	return size;
+}
+
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
+        Endianness streamEndianness) {
+	ReturnValue_t result = RETURN_FAILED;
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		result = (*iter)->deSerialize(buffer, size, streamEndianness);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return RETURN_OK;
+}
+
+uint8_t Fuse::getFuseId() const {
+	return fuseId;
+}
+
+void Fuse::calculateFusePower() {
+	ReturnValue_t result1 = currentLimit.check();
+	if (result1 != HasReturnvaluesIF::RETURN_OK || !(voltage.isValid())) {
+		power.setValid(PoolVariableIF::INVALID);
+		return;
+	}
+	//Calculate fuse power.
+	power = current * voltage;
+	power.setValid(PoolVariableIF::VALID);
+}
+
+ReturnValue_t Fuse::performOperation(uint8_t opCode) {
+	checkCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Fuse::reportEvents(Event event) {
+	if (!powerMonitor.isEventEnabled()) {
+		return;
+	}
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		if (areSwitchesOfComponentOn(iter)) {
+			EventManagerIF::triggerEvent((*iter)->getDeviceObjectId(), event);
+		}
+	}
+}
+
+MessageQueueId_t Fuse::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void Fuse::setAllMonitorsToUnchecked() {
+	currentLimit.setToUnchecked();
+	powerMonitor.setToUnchecked();
+}
+
+void Fuse::checkCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = parameterHelper.handleParameterMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	command.setToUnknownCommand();
+	commandQueue->reply(&command);
+}
+
+void Fuse::checkFuseState() {
+	if (!state.isValid()) {
+		oldFuseState = 0;
+		return;
+	}
+	if (state == 0) {
+		if (oldFuseState != 0) {
+			reportEvents(FUSE_WENT_OFF);
+		}
+	}
+	oldFuseState = state;
+}
+
+float Fuse::getPower() {
+	if (power.isValid()) {
+		return power;
+	} else {
+		return 0.0;
+	}
+}
+
+void Fuse::setDataPoolEntriesInvalid() {
+	set.read();
+	set.commit(PoolVariableIF::INVALID);
+}
+
+ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = powerMonitor.getParameter(domainId, parameterId, parameterWrapper,
+			newValues, startAtIndex);
+	return result;
+}
+
+bool Fuse::areSwitchesOfComponentOn(DeviceList::iterator iter) {
+	if (powerIF->getSwitchState((*iter)->getSwitchId1())
+			!= PowerSwitchIF::SWITCH_ON) {
+		return false;
+	}
+	if ((*iter)->hasTwoSwitches()) {
+		if ((powerIF->getSwitchState((*iter)->getSwitchId2())
+				!= PowerSwitchIF::SWITCH_ON)) {
+			return false;
+		}
+	}
+	return true;
+}
+
+bool Fuse::isPowerValid() {
+	return power.isValid();
+}
+
+ReturnValue_t Fuse::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return RETURN_OK;
+}
+
+HasHealthIF::HealthState Fuse::getHealth() {
+	return healthHelper.getHealth();
+}
+
+ReturnValue_t Fuse::PowerMonitor::checkPower(float sample, float lowerLimit,
+		float upperLimit) {
+	if (sample > upperLimit) {
+		return this->monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
+				upperLimit);
+	} else if (sample < lowerLimit) {
+		return this->monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
+				lowerLimit);
+	} else {
+		return this->monitorStateIs(RETURN_OK, sample, 0.0); //Within limits.
+	}
+}
diff --git a/power/Fuse.h b/power/Fuse.h
index 1608023cd..e6d6929c7 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -1,106 +1,106 @@
-#ifndef FUSE_H_
-#define FUSE_H_
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/datapoolglob/PIDReader.h>
-#include <framework/devicehandlers/HealthDevice.h>
-#include <framework/monitoring/AbsLimitMonitor.h>
-#include <framework/power/PowerComponentIF.h>
-#include <framework/power/PowerSwitchIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/parameters/ParameterHelper.h>
-#include <list>
-
-namespace Factory {
-void setStaticFrameworkObjectIds();
-}
-
-class Fuse: public SystemObject,
-		public HasHealthIF,
-		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF,
-		public SerializeIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-private:
-	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
-public:
-	struct VariableIds {
-		uint32_t pidVoltage;
-		uint32_t pidCurrent;
-		uint32_t pidState;
-		uint32_t poolIdPower;
-	};
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
-	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
-	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
-	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
-	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
-
-	typedef std::list<PowerComponentIF*> DeviceList;
-	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
-			float maxCurrent, uint16_t confirmationCount = 2);
-	virtual ~Fuse();
-	void addDevice(PowerComponentIF *set);
-	float getPower();
-
-	bool isPowerValid();
-
-	ReturnValue_t check();
-	uint8_t getFuseId() const;
-	ReturnValue_t initialize();
-	DeviceList devices;
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override;
-	size_t getSerializedSize() const override;
-	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			SerializeIF::Endianness streamEndianness) override;
-	void setAllMonitorsToUnchecked();
-	ReturnValue_t performOperation(uint8_t opCode);
-	MessageQueueId_t getCommandQueue() const;
-	void setDataPoolEntriesInvalid();
-	ReturnValue_t setHealth(HealthState health);
-	HasHealthIF::HealthState getHealth();
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-private:
-	uint8_t oldFuseState;
-	uint8_t fuseId;
-	PowerSwitchIF *powerIF; //could be static in our case.
-	AbsLimitMonitor<float> currentLimit;
-	class PowerMonitor: public MonitorReporter<float> {
-	public:
-		template<typename ... Args>
-		PowerMonitor(Args ... args) :
-				MonitorReporter<float>(std::forward<Args>(args)...) {
-		}
-		ReturnValue_t checkPower(float sample, float lowerLimit,
-				float upperLimit);
-		void sendTransitionEvent(float currentValue, ReturnValue_t state) {
-		}
-
-	};
-	PowerMonitor powerMonitor;
-	GlobDataSet set;
-	PIDReader<float> voltage;
-	PIDReader<float> current;
-	PIDReader<uint8_t> state;
-	gp_float_t power;
-	MessageQueueIF* commandQueue;
-	ParameterHelper parameterHelper;
-	HealthHelper healthHelper;
-	static object_id_t powerSwitchId;
-	void calculatePowerLimits(float *low, float *high);
-	void calculateFusePower();
-	void checkFuseState();
-	void reportEvents(Event event);
-	void checkCommandQueue();
-
-	bool areSwitchesOfComponentOn(DeviceList::iterator iter);
-};
-
-#endif /* FUSE_H_ */
+#ifndef FUSE_H_
+#define FUSE_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../monitoring/AbsLimitMonitor.h"
+#include "../power/PowerComponentIF.h"
+#include "../power/PowerSwitchIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../parameters/ParameterHelper.h"
+#include <list>
+
+namespace Factory {
+void setStaticFrameworkObjectIds();
+}
+
+class Fuse: public SystemObject,
+		public HasHealthIF,
+		public HasReturnvaluesIF,
+		public ReceivesParameterMessagesIF,
+		public SerializeIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+private:
+	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
+public:
+	struct VariableIds {
+		uint32_t pidVoltage;
+		uint32_t pidCurrent;
+		uint32_t pidState;
+		uint32_t poolIdPower;
+	};
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
+	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
+	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
+	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
+	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
+
+	typedef std::list<PowerComponentIF*> DeviceList;
+	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
+			float maxCurrent, uint16_t confirmationCount = 2);
+	virtual ~Fuse();
+	void addDevice(PowerComponentIF *set);
+	float getPower();
+
+	bool isPowerValid();
+
+	ReturnValue_t check();
+	uint8_t getFuseId() const;
+	ReturnValue_t initialize();
+	DeviceList devices;
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override;
+	size_t getSerializedSize() const override;
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override;
+	void setAllMonitorsToUnchecked();
+	ReturnValue_t performOperation(uint8_t opCode);
+	MessageQueueId_t getCommandQueue() const;
+	void setDataPoolEntriesInvalid();
+	ReturnValue_t setHealth(HealthState health);
+	HasHealthIF::HealthState getHealth();
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+private:
+	uint8_t oldFuseState;
+	uint8_t fuseId;
+	PowerSwitchIF *powerIF; //could be static in our case.
+	AbsLimitMonitor<float> currentLimit;
+	class PowerMonitor: public MonitorReporter<float> {
+	public:
+		template<typename ... Args>
+		PowerMonitor(Args ... args) :
+				MonitorReporter<float>(std::forward<Args>(args)...) {
+		}
+		ReturnValue_t checkPower(float sample, float lowerLimit,
+				float upperLimit);
+		void sendTransitionEvent(float currentValue, ReturnValue_t state) {
+		}
+
+	};
+	PowerMonitor powerMonitor;
+	GlobDataSet set;
+	PIDReader<float> voltage;
+	PIDReader<float> current;
+	PIDReader<uint8_t> state;
+	gp_float_t power;
+	MessageQueueIF* commandQueue;
+	ParameterHelper parameterHelper;
+	HealthHelper healthHelper;
+	static object_id_t powerSwitchId;
+	void calculatePowerLimits(float *low, float *high);
+	void calculateFusePower();
+	void checkFuseState();
+	void reportEvents(Event event);
+	void checkCommandQueue();
+
+	bool areSwitchesOfComponentOn(DeviceList::iterator iter);
+};
+
+#endif /* FUSE_H_ */
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index d1acffebd..ef852e64c 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -1,86 +1,86 @@
-/**
- * @file	PowerComponent.cpp
- * @brief	This file defines the PowerComponent class.
- * @date	28.08.2014
- * @author	baetz
- */
-
-#include <framework/power/PowerComponent.h>
-
-PowerComponent::PowerComponent() :
-		deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
-		false), min(0.0), max(0.0), moduleId(0) {
-}
-PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
-		uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
-		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2), doIHaveTwoSwitches(
-				twoSwitches), min(min), max(max), moduleId(moduleId) {
-}
-
-ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
-			size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
-			streamEndianness);
-}
-
-size_t PowerComponent::getSerializedSize() const {
-	return sizeof(min) + sizeof(max);
-}
-
-object_id_t PowerComponent::getDeviceObjectId() {
-	return deviceObjectId;
-}
-
-uint8_t PowerComponent::getSwitchId1() {
-	return switchId1;
-}
-
-uint8_t PowerComponent::getSwitchId2() {
-	return switchId2;
-}
-
-bool PowerComponent::hasTwoSwitches() {
-	return doIHaveTwoSwitches;
-}
-
-float PowerComponent::getMin() {
-	return min;
-}
-
-float PowerComponent::getMax() {
-	return max;
-}
-
-ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
-        Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
-}
-
-ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	if (domainId != moduleId) {
-		return INVALID_DOMAIN_ID;
-	}
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set<>(min);
-		break;
-	case 1:
-		parameterWrapper->set<>(max);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+/**
+ * @file	PowerComponent.cpp
+ * @brief	This file defines the PowerComponent class.
+ * @date	28.08.2014
+ * @author	baetz
+ */
+
+#include "../power/PowerComponent.h"
+
+PowerComponent::PowerComponent() :
+		deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
+		false), min(0.0), max(0.0), moduleId(0) {
+}
+PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
+		uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
+		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2), doIHaveTwoSwitches(
+				twoSwitches), min(min), max(max), moduleId(moduleId) {
+}
+
+ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
+			streamEndianness);
+}
+
+size_t PowerComponent::getSerializedSize() const {
+	return sizeof(min) + sizeof(max);
+}
+
+object_id_t PowerComponent::getDeviceObjectId() {
+	return deviceObjectId;
+}
+
+uint8_t PowerComponent::getSwitchId1() {
+	return switchId1;
+}
+
+uint8_t PowerComponent::getSwitchId2() {
+	return switchId2;
+}
+
+bool PowerComponent::hasTwoSwitches() {
+	return doIHaveTwoSwitches;
+}
+
+float PowerComponent::getMin() {
+	return min;
+}
+
+float PowerComponent::getMax() {
+	return max;
+}
+
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
+        Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
+}
+
+ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	if (domainId != moduleId) {
+		return INVALID_DOMAIN_ID;
+	}
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set<>(min);
+		break;
+	case 1:
+		parameterWrapper->set<>(max);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 61ab3674e..2e11fa82e 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -1,48 +1,48 @@
-#ifndef POWERCOMPONENT_H_
-#define POWERCOMPONENT_H_
-
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/power/PowerComponentIF.h>
-
-class PowerComponent: public PowerComponentIF {
-public:
-	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
-			bool twoSwitches = false, uint8_t switchId2 = 0xFF);
-
-	virtual object_id_t getDeviceObjectId();
-
-	virtual uint8_t getSwitchId1();
-	virtual uint8_t getSwitchId2();
-
-	bool hasTwoSwitches();
-
-	float getMin();
-	float getMax();
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	size_t getSerializedSize() const override;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex);
-private:
-	const object_id_t deviceObjectId;
-	const uint8_t switchId1;
-	const uint8_t switchId2;
-
-	const bool doIHaveTwoSwitches;
-
-	float min;
-	float max;
-
-	uint8_t moduleId;
-
-	PowerComponent();
-};
-
-#endif /* POWERCOMPONENT_H_ */
+#ifndef POWERCOMPONENT_H_
+#define POWERCOMPONENT_H_
+
+#include "../objectmanager/SystemObjectIF.h"
+#include "../power/PowerComponentIF.h"
+
+class PowerComponent: public PowerComponentIF {
+public:
+	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
+			bool twoSwitches = false, uint8_t switchId2 = 0xFF);
+
+	virtual object_id_t getDeviceObjectId();
+
+	virtual uint8_t getSwitchId1();
+	virtual uint8_t getSwitchId2();
+
+	bool hasTwoSwitches();
+
+	float getMin();
+	float getMax();
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	size_t getSerializedSize() const override;
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+				ParameterWrapper *parameterWrapper,
+				const ParameterWrapper *newValues, uint16_t startAtIndex);
+private:
+	const object_id_t deviceObjectId;
+	const uint8_t switchId1;
+	const uint8_t switchId2;
+
+	const bool doIHaveTwoSwitches;
+
+	float min;
+	float max;
+
+	uint8_t moduleId;
+
+	PowerComponent();
+};
+
+#endif /* POWERCOMPONENT_H_ */
diff --git a/power/PowerComponentIF.h b/power/PowerComponentIF.h
index f2aa70aec..eeaa39fb5 100644
--- a/power/PowerComponentIF.h
+++ b/power/PowerComponentIF.h
@@ -1,24 +1,24 @@
-#ifndef POWERCOMPONENTIF_H_
-#define POWERCOMPONENTIF_H_
-
-#include <framework/serialize/SerializeIF.h>
-#include <framework/parameters/HasParametersIF.h>
-
-class PowerComponentIF : public SerializeIF, public HasParametersIF {
-public:
-	virtual ~PowerComponentIF() {
-
-	}
-
-	virtual object_id_t getDeviceObjectId()=0;
-
-	virtual uint8_t getSwitchId1()=0;
-	virtual uint8_t getSwitchId2()=0;
-	virtual bool hasTwoSwitches()=0;
-
-	virtual float getMin() = 0;
-	virtual float getMax() = 0;
-
-};
-
-#endif /* POWERCOMPONENTIF_H_ */
+#ifndef POWERCOMPONENTIF_H_
+#define POWERCOMPONENTIF_H_
+
+#include "../serialize/SerializeIF.h"
+#include "../parameters/HasParametersIF.h"
+
+class PowerComponentIF : public SerializeIF, public HasParametersIF {
+public:
+	virtual ~PowerComponentIF() {
+
+	}
+
+	virtual object_id_t getDeviceObjectId()=0;
+
+	virtual uint8_t getSwitchId1()=0;
+	virtual uint8_t getSwitchId2()=0;
+	virtual bool hasTwoSwitches()=0;
+
+	virtual float getMin() = 0;
+	virtual float getMax() = 0;
+
+};
+
+#endif /* POWERCOMPONENTIF_H_ */
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 5433acc93..51300db73 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -1,128 +1,128 @@
-#include <framework/power/PowerSensor.h>
-#include <framework/ipc/QueueFactory.h>
-
-PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
-		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
-		SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
-				ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
-				setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
-				limits.currentMin, limits.currentMax, events.currentLow,
-				events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
-				ids.pidVoltage, confirmationCount, limits.voltageMin,
-				limits.voltageMax, events.voltageLow, events.voltageHigh) {
-		commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-PowerSensor::~PowerSensor() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t PowerSensor::calculatePower() {
-	set.read();
-	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
-	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
-	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
-			&& current.isValid()) {
-		result1 = voltageLimit.doCheck(voltage);
-		result2 = currentLimit.doCheck(current);
-	} else {
-		voltageLimit.setToInvalid();
-		currentLimit.setToInvalid();
-		result1 = OBJECT_NOT_HEALTHY;
-	}
-	if (result1 != HasReturnvaluesIF::RETURN_OK
-			|| result2 != HasReturnvaluesIF::RETURN_OK) {
-		result1 = MonitoringIF::INVALID;
-		power.setValid(PoolVariableIF::INVALID);
-	} else {
-		power.setValid(PoolVariableIF::VALID);
-		power = current * voltage;
-	}
-	set.commit();
-	return result1;
-}
-
-ReturnValue_t PowerSensor::performOperation(uint8_t opCode) {
-	checkCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t PowerSensor::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t PowerSensor::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return result;
-}
-
-void PowerSensor::setAllMonitorsToUnchecked() {
-	currentLimit.setToUnchecked();
-	voltageLimit.setToUnchecked();
-}
-
-void PowerSensor::checkCommandQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = healthHelper.handleHealthCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = parameterHelper.handleParameterMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	command.setToUnknownCommand();
-	commandQueue->reply(&command);
-}
-
-void PowerSensor::setDataPoolEntriesInvalid() {
-	set.read();
-	set.commit(PoolVariableIF::INVALID);
-}
-
-float PowerSensor::getPower() {
-	if (power.isValid()) {
-		return power.value;
-	} else {
-		return 0.0;
-	}
-
-}
-
-ReturnValue_t PowerSensor::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-HasHealthIF::HealthState PowerSensor::getHealth() {
-	return healthHelper.getHealth();
-}
-
-ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = voltageLimit.getParameter(domainId, parameterId, parameterWrapper,
-			newValues, startAtIndex);
-	return result;
-}
+#include "../power/PowerSensor.h"
+#include "../ipc/QueueFactory.h"
+
+PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
+		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
+		SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
+				ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
+				ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
+				setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
+				limits.currentMin, limits.currentMax, events.currentLow,
+				events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
+				ids.pidVoltage, confirmationCount, limits.voltageMin,
+				limits.voltageMax, events.voltageLow, events.voltageHigh) {
+		commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+PowerSensor::~PowerSensor() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t PowerSensor::calculatePower() {
+	set.read();
+	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
+	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
+	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
+			&& current.isValid()) {
+		result1 = voltageLimit.doCheck(voltage);
+		result2 = currentLimit.doCheck(current);
+	} else {
+		voltageLimit.setToInvalid();
+		currentLimit.setToInvalid();
+		result1 = OBJECT_NOT_HEALTHY;
+	}
+	if (result1 != HasReturnvaluesIF::RETURN_OK
+			|| result2 != HasReturnvaluesIF::RETURN_OK) {
+		result1 = MonitoringIF::INVALID;
+		power.setValid(PoolVariableIF::INVALID);
+	} else {
+		power.setValid(PoolVariableIF::VALID);
+		power = current * voltage;
+	}
+	set.commit();
+	return result1;
+}
+
+ReturnValue_t PowerSensor::performOperation(uint8_t opCode) {
+	checkCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t PowerSensor::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t PowerSensor::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return result;
+}
+
+void PowerSensor::setAllMonitorsToUnchecked() {
+	currentLimit.setToUnchecked();
+	voltageLimit.setToUnchecked();
+}
+
+void PowerSensor::checkCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = parameterHelper.handleParameterMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	command.setToUnknownCommand();
+	commandQueue->reply(&command);
+}
+
+void PowerSensor::setDataPoolEntriesInvalid() {
+	set.read();
+	set.commit(PoolVariableIF::INVALID);
+}
+
+float PowerSensor::getPower() {
+	if (power.isValid()) {
+		return power.value;
+	} else {
+		return 0.0;
+	}
+
+}
+
+ReturnValue_t PowerSensor::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState PowerSensor::getHealth() {
+	return healthHelper.getHealth();
+}
+
+ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = voltageLimit.getParameter(domainId, parameterId, parameterWrapper,
+			newValues, startAtIndex);
+	return result;
+}
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index 0fb47506c..dc859ab35 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -1,71 +1,71 @@
-#ifndef POWERSENSOR_H_
-#define POWERSENSOR_H_
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/datapoolglob/PIDReader.h>
-#include <framework/devicehandlers/HealthDevice.h>
-#include <framework/monitoring/LimitMonitor.h>
-#include <framework/parameters/ParameterHelper.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-class PowerController;
-
-class PowerSensor: public SystemObject,
-		public ReceivesParameterMessagesIF,
-		public HasHealthIF {
-	friend class PowerController;
-public:
-	struct VariableIds {
-		uint32_t pidCurrent;
-		uint32_t pidVoltage;
-		uint32_t poolIdPower;
-	};
-	struct DefaultLimits {
-		float currentMin;
-		float currentMax;
-		float voltageMin;
-		float voltageMax;
-	};
-	struct SensorEvents {
-		Event currentLow;
-		Event currentHigh;
-		Event voltageLow;
-		Event voltageHigh;
-	};
-	PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
-			SensorEvents events, uint16_t confirmationCount = 0);
-	virtual ~PowerSensor();
-	ReturnValue_t calculatePower();
-	ReturnValue_t performOperation(uint8_t opCode);
-	void setAllMonitorsToUnchecked();
-	MessageQueueId_t getCommandQueue() const;
-	ReturnValue_t initialize();
-	void setDataPoolEntriesInvalid();
-	float getPower();
-	ReturnValue_t setHealth(HealthState health);
-	HasHealthIF::HealthState getHealth();
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-private:
-	MessageQueueIF* commandQueue;
-	ParameterHelper parameterHelper;
-	HealthHelper healthHelper;
-	GlobDataSet set;
-	//Variables in
-	PIDReader<float> current;
-	PIDReader<float> voltage;
-	//Variables out
-	gp_float_t power;
-
-	static const uint8_t MODULE_ID_CURRENT = 1;
-	static const uint8_t MODULE_ID_VOLTAGE = 2;
-	void checkCommandQueue();
-protected:
-	LimitMonitor<float> currentLimit;
-	LimitMonitor<float> voltageLimit;
-};
-
-#endif /* POWERSENSOR_H_ */
+#ifndef POWERSENSOR_H_
+#define POWERSENSOR_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../monitoring/LimitMonitor.h"
+#include "../parameters/ParameterHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../ipc/MessageQueueIF.h"
+
+class PowerController;
+
+class PowerSensor: public SystemObject,
+		public ReceivesParameterMessagesIF,
+		public HasHealthIF {
+	friend class PowerController;
+public:
+	struct VariableIds {
+		uint32_t pidCurrent;
+		uint32_t pidVoltage;
+		uint32_t poolIdPower;
+	};
+	struct DefaultLimits {
+		float currentMin;
+		float currentMax;
+		float voltageMin;
+		float voltageMax;
+	};
+	struct SensorEvents {
+		Event currentLow;
+		Event currentHigh;
+		Event voltageLow;
+		Event voltageHigh;
+	};
+	PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
+			SensorEvents events, uint16_t confirmationCount = 0);
+	virtual ~PowerSensor();
+	ReturnValue_t calculatePower();
+	ReturnValue_t performOperation(uint8_t opCode);
+	void setAllMonitorsToUnchecked();
+	MessageQueueId_t getCommandQueue() const;
+	ReturnValue_t initialize();
+	void setDataPoolEntriesInvalid();
+	float getPower();
+	ReturnValue_t setHealth(HealthState health);
+	HasHealthIF::HealthState getHealth();
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+private:
+	MessageQueueIF* commandQueue;
+	ParameterHelper parameterHelper;
+	HealthHelper healthHelper;
+	GlobDataSet set;
+	//Variables in
+	PIDReader<float> current;
+	PIDReader<float> voltage;
+	//Variables out
+	gp_float_t power;
+
+	static const uint8_t MODULE_ID_CURRENT = 1;
+	static const uint8_t MODULE_ID_VOLTAGE = 2;
+	void checkCommandQueue();
+protected:
+	LimitMonitor<float> currentLimit;
+	LimitMonitor<float> voltageLimit;
+};
+
+#endif /* POWERSENSOR_H_ */
diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h
index f25589c4d..817c4ce1d 100644
--- a/power/PowerSwitchIF.h
+++ b/power/PowerSwitchIF.h
@@ -1,80 +1,80 @@
-/**
- * @file	PowerSwitchIF.h
- * @brief	This file defines the PowerSwitchIF class.
- * @date	20.03.2013
- * @author	baetz
- */
-
-#ifndef POWERSWITCHIF_H_
-#define POWERSWITCHIF_H_
-
-#include <framework/events/Event.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-/**
- *
- * @brief   This interface defines a connection to a device that is capable of turning on and off
- *          switches of devices identified by a switch ID.
- * @details The virtual functions of this interface do not allow to make any assignments
- *          because they can be called asynchronosuly (const ending).
- *
- * @ingroup interfaces
- */
-class PowerSwitchIF : public HasReturnvaluesIF {
-public:
-	/**
-	 * Empty dtor.
-	 */
-	virtual ~PowerSwitchIF() {
-
-	}
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCH_IF;
-	static const ReturnValue_t SWITCH_ON = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t SWITCH_OFF = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
-	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
-	/**
-	 * send a direct command to the Power Unit to enable/disable the specified switch.
-	 *
-	 * @param switchNr
-	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
-	 */
-	virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const = 0;
-	/**
-	 * Sends a command to the Power Unit to enable a certain fuse.
-	 */
-	virtual void sendFuseOnCommand(uint8_t fuseNr) const = 0;
-
-	/**
-	 * get the state of the Switches.
-	 * @param switchNr
-	 * @return
-	 *     - @c SWITCH_ON if the specified switch is on.
-	 *     - @c SWITCH_OFF if the specified switch is off.
-	 *     - @c RETURN_FAILED if an error occured
-	 */
-	virtual ReturnValue_t getSwitchState( uint8_t switchNr ) const = 0;
-	/**
-	 * get state of a fuse.
-	 * @param fuseNr
-	 * @return
-	 *     - @c FUSE_ON if the specified fuse is on.
-	 *     - @c FUSE_OFF if the specified fuse is off.
-	 *     - @c RETURN_FAILED if an error occured
-	 */
-	virtual ReturnValue_t getFuseState( uint8_t fuseNr ) const = 0;
-	/**
-	 * The maximum delay that it will take to change a switch
-	 *
-	 * This may take into account the time to send a command, wait for it to be executed and see the switch changed.
-	 */
-	virtual uint32_t getSwitchDelayMs(void) const = 0;
-};
-
-
-#endif /* POWERSWITCHIF_H_ */
+/**
+ * @file	PowerSwitchIF.h
+ * @brief	This file defines the PowerSwitchIF class.
+ * @date	20.03.2013
+ * @author	baetz
+ */
+
+#ifndef POWERSWITCHIF_H_
+#define POWERSWITCHIF_H_
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ *
+ * @brief   This interface defines a connection to a device that is capable of turning on and off
+ *          switches of devices identified by a switch ID.
+ * @details The virtual functions of this interface do not allow to make any assignments
+ *          because they can be called asynchronosuly (const ending).
+ *
+ * @ingroup interfaces
+ */
+class PowerSwitchIF : public HasReturnvaluesIF {
+public:
+	/**
+	 * Empty dtor.
+	 */
+	virtual ~PowerSwitchIF() {
+
+	}
+	/**
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
+	 */
+	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCH_IF;
+	static const ReturnValue_t SWITCH_ON = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t SWITCH_OFF = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
+	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
+	/**
+	 * send a direct command to the Power Unit to enable/disable the specified switch.
+	 *
+	 * @param switchNr
+	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
+	 */
+	virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const = 0;
+	/**
+	 * Sends a command to the Power Unit to enable a certain fuse.
+	 */
+	virtual void sendFuseOnCommand(uint8_t fuseNr) const = 0;
+
+	/**
+	 * get the state of the Switches.
+	 * @param switchNr
+	 * @return
+	 *     - @c SWITCH_ON if the specified switch is on.
+	 *     - @c SWITCH_OFF if the specified switch is off.
+	 *     - @c RETURN_FAILED if an error occured
+	 */
+	virtual ReturnValue_t getSwitchState( uint8_t switchNr ) const = 0;
+	/**
+	 * get state of a fuse.
+	 * @param fuseNr
+	 * @return
+	 *     - @c FUSE_ON if the specified fuse is on.
+	 *     - @c FUSE_OFF if the specified fuse is off.
+	 *     - @c RETURN_FAILED if an error occured
+	 */
+	virtual ReturnValue_t getFuseState( uint8_t fuseNr ) const = 0;
+	/**
+	 * The maximum delay that it will take to change a switch
+	 *
+	 * This may take into account the time to send a command, wait for it to be executed and see the switch changed.
+	 */
+	virtual uint32_t getSwitchDelayMs(void) const = 0;
+};
+
+
+#endif /* POWERSWITCHIF_H_ */
diff --git a/power/PowerSwitcher.cpp b/power/PowerSwitcher.cpp
index 6b06bf735..73d9f89bc 100644
--- a/power/PowerSwitcher.cpp
+++ b/power/PowerSwitcher.cpp
@@ -1,127 +1,127 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/power/PowerSwitcher.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
-		PowerSwitcher::State_t setStartState) :
-		state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
-}
-
-ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
-	power = objectManager->get<PowerSwitchIF>(powerSwitchId);
-	if (power == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PowerSwitcher::getStateOfSwitches() {
-	SwitchReturn_t result = howManySwitches();
-	switch (result) {
-	case ONE_SWITCH:
-		return power->getSwitchState(firstSwitch);
-	case TWO_SWITCHES:
-		if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
-			return PowerSwitchIF::SWITCH_ON;
-		} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
-			return PowerSwitchIF::SWITCH_OFF;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
-	SwitchReturn_t result = howManySwitches();
-	switch (result) {
-	case TWO_SWITCHES:
-		power->sendSwitchCommand(secondSwitch, onOff);
-		/* NO BREAK falls through*/
-	case ONE_SWITCH:
-		power->sendSwitchCommand(firstSwitch, onOff);
-		break;
-	}
-	return;
-
-}
-
-void PowerSwitcher::turnOn() {
-	commandSwitches(PowerSwitchIF::SWITCH_ON);
-	state = WAIT_ON;
-}
-
-void PowerSwitcher::turnOff() {
-	commandSwitches(PowerSwitchIF::SWITCH_OFF);
-	state = WAIT_OFF;
-}
-
-PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
-	if (secondSwitch == NO_SWITCH) {
-		return ONE_SWITCH;
-	} else {
-		return TWO_SWITCHES;
-	}
-}
-
-void PowerSwitcher::doStateMachine() {
-	switch (state) {
-	case SWITCH_IS_OFF:
-	case SWITCH_IS_ON:
-		//Do nothing.
-		break;
-	case WAIT_OFF:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
-			state = SWITCH_IS_OFF;
-		}
-		break;
-	case WAIT_ON:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
-			state = SWITCH_IS_ON;
-		}
-		break;
-	default:
-		//Should never happen.
-		break;
-	}
-}
-
-ReturnValue_t PowerSwitcher::checkSwitchState() {
-	switch (state) {
-	case WAIT_OFF:
-	case WAIT_ON:
-		return IN_POWER_TRANSITION;
-	case SWITCH_IS_OFF:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
-			return RETURN_OK;
-		} else {
-			return SWITCH_STATE_MISMATCH;
-		}
-	case SWITCH_IS_ON:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
-			return RETURN_OK;
-		} else {
-			return SWITCH_STATE_MISMATCH;
-		}
-	}
-	return RETURN_FAILED;
-}
-
-PowerSwitcher::State_t PowerSwitcher::getState() {
-	return state;
-}
-
-uint32_t PowerSwitcher::getSwitchDelay() {
-	return power->getSwitchDelayMs();
-}
-
-uint8_t PowerSwitcher::getFirstSwitch() const {
-	return firstSwitch;
-}
-
-uint8_t PowerSwitcher::getSecondSwitch() const {
-	return secondSwitch;
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../power/PowerSwitcher.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
+		PowerSwitcher::State_t setStartState) :
+		state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
+}
+
+ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
+	power = objectManager->get<PowerSwitchIF>(powerSwitchId);
+	if (power == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PowerSwitcher::getStateOfSwitches() {
+	SwitchReturn_t result = howManySwitches();
+	switch (result) {
+	case ONE_SWITCH:
+		return power->getSwitchState(firstSwitch);
+	case TWO_SWITCHES:
+		if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
+				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
+			return PowerSwitchIF::SWITCH_ON;
+		} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
+				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
+			return PowerSwitchIF::SWITCH_OFF;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
+	SwitchReturn_t result = howManySwitches();
+	switch (result) {
+	case TWO_SWITCHES:
+		power->sendSwitchCommand(secondSwitch, onOff);
+		/* NO BREAK falls through*/
+	case ONE_SWITCH:
+		power->sendSwitchCommand(firstSwitch, onOff);
+		break;
+	}
+	return;
+
+}
+
+void PowerSwitcher::turnOn() {
+	commandSwitches(PowerSwitchIF::SWITCH_ON);
+	state = WAIT_ON;
+}
+
+void PowerSwitcher::turnOff() {
+	commandSwitches(PowerSwitchIF::SWITCH_OFF);
+	state = WAIT_OFF;
+}
+
+PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
+	if (secondSwitch == NO_SWITCH) {
+		return ONE_SWITCH;
+	} else {
+		return TWO_SWITCHES;
+	}
+}
+
+void PowerSwitcher::doStateMachine() {
+	switch (state) {
+	case SWITCH_IS_OFF:
+	case SWITCH_IS_ON:
+		//Do nothing.
+		break;
+	case WAIT_OFF:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
+			state = SWITCH_IS_OFF;
+		}
+		break;
+	case WAIT_ON:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
+			state = SWITCH_IS_ON;
+		}
+		break;
+	default:
+		//Should never happen.
+		break;
+	}
+}
+
+ReturnValue_t PowerSwitcher::checkSwitchState() {
+	switch (state) {
+	case WAIT_OFF:
+	case WAIT_ON:
+		return IN_POWER_TRANSITION;
+	case SWITCH_IS_OFF:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
+			return RETURN_OK;
+		} else {
+			return SWITCH_STATE_MISMATCH;
+		}
+	case SWITCH_IS_ON:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
+			return RETURN_OK;
+		} else {
+			return SWITCH_STATE_MISMATCH;
+		}
+	}
+	return RETURN_FAILED;
+}
+
+PowerSwitcher::State_t PowerSwitcher::getState() {
+	return state;
+}
+
+uint32_t PowerSwitcher::getSwitchDelay() {
+	return power->getSwitchDelayMs();
+}
+
+uint8_t PowerSwitcher::getFirstSwitch() const {
+	return firstSwitch;
+}
+
+uint8_t PowerSwitcher::getSecondSwitch() const {
+	return secondSwitch;
+}
diff --git a/power/PowerSwitcher.h b/power/PowerSwitcher.h
index 5b2789e96..39f44f505 100644
--- a/power/PowerSwitcher.h
+++ b/power/PowerSwitcher.h
@@ -1,45 +1,45 @@
-#ifndef POWERSWITCHER_H_
-#define POWERSWITCHER_H_
-#include <framework/power/PowerSwitchIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/timemanager/Countdown.h>
-
-class PowerSwitcher : public HasReturnvaluesIF {
-public:
-	enum State_t {
-		WAIT_OFF,
-		WAIT_ON,
-		SWITCH_IS_OFF,
-		SWITCH_IS_ON,
-	};
-	State_t state;
-	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
-	static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
-	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
-	ReturnValue_t initialize(object_id_t powerSwitchId);
-	void turnOn();
-	void turnOff();
-	void doStateMachine();
-	State_t getState();
-	ReturnValue_t checkSwitchState();
-	uint32_t getSwitchDelay();
-	uint8_t getFirstSwitch() const;
-	uint8_t getSecondSwitch() const;
-private:
-	uint8_t firstSwitch;
-	uint8_t secondSwitch;
-	PowerSwitchIF* power;
-	static const uint8_t NO_SWITCH = 0xFF;
-	enum SwitchReturn_t {
-		ONE_SWITCH = 1,
-		TWO_SWITCHES = 2
-	};
-	ReturnValue_t getStateOfSwitches();
-	void commandSwitches( ReturnValue_t onOff );
-	SwitchReturn_t howManySwitches();
-};
-
-
-
-#endif /* POWERSWITCHER_H_ */
+#ifndef POWERSWITCHER_H_
+#define POWERSWITCHER_H_
+#include "../power/PowerSwitchIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Countdown.h"
+
+class PowerSwitcher : public HasReturnvaluesIF {
+public:
+	enum State_t {
+		WAIT_OFF,
+		WAIT_ON,
+		SWITCH_IS_OFF,
+		SWITCH_IS_ON,
+	};
+	State_t state;
+	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
+	static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
+	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
+	ReturnValue_t initialize(object_id_t powerSwitchId);
+	void turnOn();
+	void turnOff();
+	void doStateMachine();
+	State_t getState();
+	ReturnValue_t checkSwitchState();
+	uint32_t getSwitchDelay();
+	uint8_t getFirstSwitch() const;
+	uint8_t getSecondSwitch() const;
+private:
+	uint8_t firstSwitch;
+	uint8_t secondSwitch;
+	PowerSwitchIF* power;
+	static const uint8_t NO_SWITCH = 0xFF;
+	enum SwitchReturn_t {
+		ONE_SWITCH = 1,
+		TWO_SWITCHES = 2
+	};
+	ReturnValue_t getStateOfSwitches();
+	void commandSwitches( ReturnValue_t onOff );
+	SwitchReturn_t howManySwitches();
+};
+
+
+
+#endif /* POWERSWITCHER_H_ */
diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index fd6da67e9..8a51469fb 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -1,10 +1,10 @@
-#include <framework/pus/CService200ModeCommanding.h>
-#include <framework/pus/servicepackets/Service200Packets.h>
+#include "../pus/CService200ModeCommanding.h"
+#include "../pus/servicepackets/Service200Packets.h"
 
-#include <framework/modes/HasModesIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/modes/ModeMessage.h>
+#include "../modes/HasModesIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../modes/ModeMessage.h"
 
 CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
         uint16_t apid, uint8_t serviceId):
diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h
index ede61a84e..dfb4dfa60 100644
--- a/pus/CService200ModeCommanding.h
+++ b/pus/CService200ModeCommanding.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
 #define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
 
-#include <framework/tmtcservices/CommandingServiceBase.h>
+#include "../tmtcservices/CommandingServiceBase.h"
 
 /**
  * @brief Custom PUS service to set mode of all objects implementing HasModesIF
diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index 4ce2ce54c..f6cbf6bf7 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -1,100 +1,100 @@
-#include <framework/pus/Service1TelecommandVerification.h>
-#include <framework/pus/servicepackets/Service1Packets.h>
-
-#include <framework/ipc/QueueFactory.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-#include <framework/tmtcpacket/pus/TmPacketStored.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcservices/AcceptsTelemetryIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-
-Service1TelecommandVerification::Service1TelecommandVerification(
-        object_id_t objectId, uint16_t apid, uint8_t serviceId,
-        object_id_t targetDestination):
-        SystemObject(objectId), apid(apid), serviceId(serviceId),
-        targetDestination(targetDestination) {
-	tmQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Service1TelecommandVerification::~Service1TelecommandVerification() {}
-
-MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
-	return tmQueue->getId();
-}
-
-
-ReturnValue_t Service1TelecommandVerification::performOperation(
-		uint8_t operationCode){
-	PusVerificationMessage message;
-	ReturnValue_t status = tmQueue->receiveMessage(&message);
-	while(status == HasReturnvaluesIF::RETURN_OK) {
-		status = sendVerificationReport(&message);
-		if(status != HasReturnvaluesIF::RETURN_OK) {
-			return status;
-		}
-		status = tmQueue->receiveMessage(&message);
-	}
-	if (status == MessageQueueIF::EMPTY) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return status;
-	}
-}
-
-
-ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
-		PusVerificationMessage* message) {
-	ReturnValue_t result;
-	if(message->getReportId() % 2 == 0) {
-		result = generateFailureReport(message);
-	} else {
-		result = generateSuccessReport(message);
-	}
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Service1TelecommandVerification::initialize: "
-		        "Sending verification packet failed !" << std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t Service1TelecommandVerification::generateFailureReport(
-        PusVerificationMessage *message) {
-	FailureReport report(
-			message->getReportId(), message->getTcPacketId(),
-			message->getTcSequenceControl(), message->getStep(),
-			message->getErrorCode(), message->getParameter1(),
-			message->getParameter2());
-	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
-	        packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
-			tmQueue->getId());
-	return result;
-}
-
-ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
-        PusVerificationMessage *message) {
-	SuccessReport report(message->getReportId(),message->getTcPacketId(),
-			message->getTcSequenceControl(),message->getStep());
-	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
-	        packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
-			tmQueue->getId());
-	return result;
-}
-
-
-ReturnValue_t Service1TelecommandVerification::initialize() {
-	// Get target object for TC verification messages
-	AcceptsTelemetryIF* funnel = objectManager->
-			get<AcceptsTelemetryIF>(targetDestination);
-	if(funnel == nullptr){
-	    sif::error << "Service1TelecommandVerification::initialize: Specified"
-	            " TM funnel invalid. Make sure it is set up and implements"
-	            " AcceptsTelemetryIF." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
-	return SystemObject::initialize();
-}
+#include "../pus/Service1TelecommandVerification.h"
+#include "../pus/servicepackets/Service1Packets.h"
+
+#include "../ipc/QueueFactory.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+
+Service1TelecommandVerification::Service1TelecommandVerification(
+        object_id_t objectId, uint16_t apid, uint8_t serviceId,
+        object_id_t targetDestination):
+        SystemObject(objectId), apid(apid), serviceId(serviceId),
+        targetDestination(targetDestination) {
+	tmQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Service1TelecommandVerification::~Service1TelecommandVerification() {}
+
+MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
+	return tmQueue->getId();
+}
+
+
+ReturnValue_t Service1TelecommandVerification::performOperation(
+		uint8_t operationCode){
+	PusVerificationMessage message;
+	ReturnValue_t status = tmQueue->receiveMessage(&message);
+	while(status == HasReturnvaluesIF::RETURN_OK) {
+		status = sendVerificationReport(&message);
+		if(status != HasReturnvaluesIF::RETURN_OK) {
+			return status;
+		}
+		status = tmQueue->receiveMessage(&message);
+	}
+	if (status == MessageQueueIF::EMPTY) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return status;
+	}
+}
+
+
+ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
+		PusVerificationMessage* message) {
+	ReturnValue_t result;
+	if(message->getReportId() % 2 == 0) {
+		result = generateFailureReport(message);
+	} else {
+		result = generateSuccessReport(message);
+	}
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Service1TelecommandVerification::initialize: "
+		        "Sending verification packet failed !" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t Service1TelecommandVerification::generateFailureReport(
+        PusVerificationMessage *message) {
+	FailureReport report(
+			message->getReportId(), message->getTcPacketId(),
+			message->getTcSequenceControl(), message->getStep(),
+			message->getErrorCode(), message->getParameter1(),
+			message->getParameter2());
+	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	        packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
+			tmQueue->getId());
+	return result;
+}
+
+ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
+        PusVerificationMessage *message) {
+	SuccessReport report(message->getReportId(),message->getTcPacketId(),
+			message->getTcSequenceControl(),message->getStep());
+	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	        packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
+			tmQueue->getId());
+	return result;
+}
+
+
+ReturnValue_t Service1TelecommandVerification::initialize() {
+	// Get target object for TC verification messages
+	AcceptsTelemetryIF* funnel = objectManager->
+			get<AcceptsTelemetryIF>(targetDestination);
+	if(funnel == nullptr){
+	    sif::error << "Service1TelecommandVerification::initialize: Specified"
+	            " TM funnel invalid. Make sure it is set up and implements"
+	            " AcceptsTelemetryIF." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
+	return SystemObject::initialize();
+}
diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h
index 1d4b67196..91275cfb0 100644
--- a/pus/Service1TelecommandVerification.h
+++ b/pus/Service1TelecommandVerification.h
@@ -1,94 +1,94 @@
-#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/tmtcservices/AcceptsVerifyMessageIF.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-/**
- * @brief Verify TC acceptance, start, progress and execution.
- *
- * Full Documentation: ECSS-E70-41A p.51
- *
- * The telecommand verification service provides the capability for
- * explicit verification of each distinct stage of execution of a telecommand
- * packet, from on-board acceptance through to completion of execution.
- *
- * Minimum capabilities of this service:
- *
- *  - TM[1,1]: Telecommand Acceptance Report - Success.
- *  - TM[1,2]: Telecommand Acceptance Report - Failure.
- *
- * Additional capabilities of this service:
- *
- *  - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4).
- *  - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3).
- *  - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6).
- *  - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5).
- *  - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8).
- *  - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7).
- *
- * This Service is not inherited from PUSServiceBase unlike other PUS Services
- * because all services implementing PUSServiceBase use this service to
- * generate verification reports.
- * @ingroup pus_services
- */
-class Service1TelecommandVerification: public AcceptsVerifyMessageIF,
-		public SystemObject,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-public:
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
-
-	Service1TelecommandVerification(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
-	virtual ~Service1TelecommandVerification();
-
-	/**
-	 *
-	 * @return ID of Verification Queue
-	 */
-	virtual MessageQueueId_t getVerificationQueue();
-
-	/**
-	 * Performs the service periodically as specified in init_mission().
-	 * Triggers the handlePacket function to send TC verification messages
-	 * @param operationCode
-	 * @return
-	 */
-	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
-
-	/**
-	 * Initializes the destination for TC verification messages and initializes
-	 * Service 1 as a system object
-	 * @return
-	 */
-	ReturnValue_t initialize() override;
-private:
-	uint16_t apid = 0;
-	uint8_t serviceId = 0;
-
-	object_id_t targetDestination = objects::NO_OBJECT;
-
-	ReturnValue_t sendVerificationReport(PusVerificationMessage* message);
-	ReturnValue_t generateFailureReport(PusVerificationMessage* message);
-	ReturnValue_t generateSuccessReport(PusVerificationMessage* message);
-
-	uint16_t packetSubCounter = 0;
-
-	MessageQueueIF* tmQueue = nullptr;
-
-	enum class Subservice: uint8_t {
-		VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM]
-		VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM]
-		VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM]
-		VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM]
-		VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM]
-		VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM]
-	};
-};
-
-#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
+#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcservices/AcceptsVerifyMessageIF.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../ipc/MessageQueueIF.h"
+
+/**
+ * @brief Verify TC acceptance, start, progress and execution.
+ *
+ * Full Documentation: ECSS-E70-41A p.51
+ *
+ * The telecommand verification service provides the capability for
+ * explicit verification of each distinct stage of execution of a telecommand
+ * packet, from on-board acceptance through to completion of execution.
+ *
+ * Minimum capabilities of this service:
+ *
+ *  - TM[1,1]: Telecommand Acceptance Report - Success.
+ *  - TM[1,2]: Telecommand Acceptance Report - Failure.
+ *
+ * Additional capabilities of this service:
+ *
+ *  - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4).
+ *  - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3).
+ *  - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6).
+ *  - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5).
+ *  - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8).
+ *  - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7).
+ *
+ * This Service is not inherited from PUSServiceBase unlike other PUS Services
+ * because all services implementing PUSServiceBase use this service to
+ * generate verification reports.
+ * @ingroup pus_services
+ */
+class Service1TelecommandVerification: public AcceptsVerifyMessageIF,
+		public SystemObject,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
+
+	Service1TelecommandVerification(object_id_t objectId,
+	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
+	virtual ~Service1TelecommandVerification();
+
+	/**
+	 *
+	 * @return ID of Verification Queue
+	 */
+	virtual MessageQueueId_t getVerificationQueue();
+
+	/**
+	 * Performs the service periodically as specified in init_mission().
+	 * Triggers the handlePacket function to send TC verification messages
+	 * @param operationCode
+	 * @return
+	 */
+	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+	/**
+	 * Initializes the destination for TC verification messages and initializes
+	 * Service 1 as a system object
+	 * @return
+	 */
+	ReturnValue_t initialize() override;
+private:
+	uint16_t apid = 0;
+	uint8_t serviceId = 0;
+
+	object_id_t targetDestination = objects::NO_OBJECT;
+
+	ReturnValue_t sendVerificationReport(PusVerificationMessage* message);
+	ReturnValue_t generateFailureReport(PusVerificationMessage* message);
+	ReturnValue_t generateSuccessReport(PusVerificationMessage* message);
+
+	uint16_t packetSubCounter = 0;
+
+	MessageQueueIF* tmQueue = nullptr;
+
+	enum class Subservice: uint8_t {
+		VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM]
+		VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM]
+		VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM]
+		VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM]
+		VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM]
+		VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM]
+	};
+};
+
+#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 84d6693d3..26639de61 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -1,14 +1,14 @@
-#include <framework/pus/Service2DeviceAccess.h>
-#include <framework/pus/servicepackets/Service2Packets.h>
+#include "../pus/Service2DeviceAccess.h"
+#include "../pus/servicepackets/Service2Packets.h"
 
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/devicehandlers/DeviceHandlerMessage.h>
-#include <framework/serialize/EndianConverter.h>
-#include <framework/action/ActionMessage.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../serialize/EndianConverter.h"
+#include "../action/ActionMessage.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 
 Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
         uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands,
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index 1a0bede0a..3fb9e8301 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -1,9 +1,9 @@
 #ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
 #define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
 
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
-#include <framework/tmtcservices/CommandingServiceBase.h>
+#include "../objectmanager/SystemObjectIF.h"
+#include "../devicehandlers/AcceptsDeviceResponsesIF.h"
+#include "../tmtcservices/CommandingServiceBase.h"
 
 /**
  * @brief   Raw Commanding and Wiretapping of devices.
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index 1dfbe2293..5343b3184 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -1,91 +1,91 @@
-#include <framework/pus/Service5EventReporting.h>
-#include <framework/pus/servicepackets/Service5Packets.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/events/EventManagerIF.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/tmtcpacket/pus/TmPacketStored.h>
-
-
-Service5EventReporting::Service5EventReporting(object_id_t objectId,
-            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
-		PusServiceBase(objectId, apid, serviceId),
-		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Service5EventReporting::~Service5EventReporting(){}
-
-ReturnValue_t Service5EventReporting::performService() {
-	EventMessage message;
-	ReturnValue_t status = RETURN_OK;
-	for(uint8_t counter = 0;
-	        counter < maxNumberReportsPerCycle;
-	        counter++)
-	{
-	    // Receive messages even if reporting is disabled for now.
-	    status = eventQueue->receiveMessage(&message);
-	    if(status == MessageQueueIF::EMPTY) {
-	        return HasReturnvaluesIF::RETURN_OK;
-	    }
-
-	    if(enableEventReport) {
-	       status = generateEventReport(message);
-	       if(status != HasReturnvaluesIF::RETURN_OK) {
-	           return status;
-	       }
-	    }
-	}
-	sif::debug <<  "Service5EventReporting::generateEventReport:"
-	        " Too many events" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Service5EventReporting::generateEventReport(
-		EventMessage message)
-{
-	EventReport report(message.getEventId(),message.getReporter(),
-			message.getParameter1(),message.getParameter2());
-	TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
-			message.getSeverity(), packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(
-	        requestQueue->getDefaultDestination(),requestQueue->getId());
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "Service5EventReporting::generateEventReport:"
-		        " Could not send TM packet" << std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
-	switch(subservice) {
-	case Subservice::ENABLE: {
-		enableEventReport = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	case Subservice::DISABLE: {
-		enableEventReport = false;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	default:
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-
-// In addition to the default PUSServiceBase initialization, this service needs
-// to be registered to the event manager to listen for events.
-ReturnValue_t Service5EventReporting::initialize() {
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-				objects::EVENT_MANAGER);
-	if (manager == NULL) {
-			return RETURN_FAILED;
-	}
-	// register Service 5 as listener for events
-	ReturnValue_t result =  manager->registerListener(eventQueue->getId(),true);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-	     return result;
-	}
-	return PusServiceBase::initialize();
-}
+#include "../pus/Service5EventReporting.h"
+#include "../pus/servicepackets/Service5Packets.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../events/EventManagerIF.h"
+#include "../ipc/QueueFactory.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+
+
+Service5EventReporting::Service5EventReporting(object_id_t objectId,
+            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
+		PusServiceBase(objectId, apid, serviceId),
+		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
+	eventQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Service5EventReporting::~Service5EventReporting(){}
+
+ReturnValue_t Service5EventReporting::performService() {
+	EventMessage message;
+	ReturnValue_t status = RETURN_OK;
+	for(uint8_t counter = 0;
+	        counter < maxNumberReportsPerCycle;
+	        counter++)
+	{
+	    // Receive messages even if reporting is disabled for now.
+	    status = eventQueue->receiveMessage(&message);
+	    if(status == MessageQueueIF::EMPTY) {
+	        return HasReturnvaluesIF::RETURN_OK;
+	    }
+
+	    if(enableEventReport) {
+	       status = generateEventReport(message);
+	       if(status != HasReturnvaluesIF::RETURN_OK) {
+	           return status;
+	       }
+	    }
+	}
+	sif::debug <<  "Service5EventReporting::generateEventReport:"
+	        " Too many events" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service5EventReporting::generateEventReport(
+		EventMessage message)
+{
+	EventReport report(message.getEventId(),message.getReporter(),
+			message.getParameter1(),message.getParameter2());
+	TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
+			message.getSeverity(), packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(
+	        requestQueue->getDefaultDestination(),requestQueue->getId());
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "Service5EventReporting::generateEventReport:"
+		        " Could not send TM packet" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
+	switch(subservice) {
+	case Subservice::ENABLE: {
+		enableEventReport = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case Subservice::DISABLE: {
+		enableEventReport = false;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+
+// In addition to the default PUSServiceBase initialization, this service needs
+// to be registered to the event manager to listen for events.
+ReturnValue_t Service5EventReporting::initialize() {
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+				objects::EVENT_MANAGER);
+	if (manager == NULL) {
+			return RETURN_FAILED;
+	}
+	// register Service 5 as listener for events
+	ReturnValue_t result =  manager->registerListener(eventQueue->getId(),true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+	     return result;
+	}
+	return PusServiceBase::initialize();
+}
diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h
index 79b7c5e7b..3f0c8cdf4 100644
--- a/pus/Service5EventReporting.h
+++ b/pus/Service5EventReporting.h
@@ -1,86 +1,86 @@
-#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-
-#include <framework/tmtcservices/PusServiceBase.h>
-#include <framework/events/EventMessage.h>
-
-/**
- * @brief Report on-board events like information or errors
- * @details
- * Full Documentation: ECSS-E70-41A p.79
- * Implements the PusServiceBase template class.
- * Documentation: Dissertation Baetz p.135,136
- *
- * This service provides for the reporting to the service user of information of
- * operational significance.
- *   1. reporting of failures or anomalies detected on-board;
- *   2. reporting of autonomous on-board actions;
- *   3. reporting of normal progress of operations and activities, e.g.
- *   detection of events which are not anomalous (such as payload events),
- *   reaching of predefined steps in an operation. Some reports can combine
- *   more than one of these events.
- *
- * Minimum capabilities of this service:
- *
- * - TM[5,1]: Normal/Progress Report
- * - TM[5,2]: Error/Anomaly Report - Low Severity
- * - TM[5,3]: Error/Anomaly Report - Medium Severity
- * - TM[5,4]: Error/Anomaly Report - High Severity
- *
- * Events can be translated by using translator files located in
- * /config/objects/ and /config/events/. Description to events can be added by
- * adding a comment behind the event definition with [//!<] as leading string
- *
- * Additional capabilities of this service:
- *
- *  - TC[5,5]: Enable Event Report Generation (Req. 6)
- *  - TC[5,6]: Disable Event Report Generation (Req. 5)
- * @author 	R. Mueller
- * @ingroup pus_services
- */
-class Service5EventReporting: public PusServiceBase {
-public:
-
-	Service5EventReporting(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
-	virtual ~Service5EventReporting();
-
-	/***
-	* Check for events and generate event reports if required.
-	* @return
-	*/
-	ReturnValue_t performService() override;
-
-	/***
-	 * Turn event generation on or off.
-	 * @return
-	 */
-	ReturnValue_t handleRequest(uint8_t subservice) override;
-
-	/**
-	 * The default PusServiceBase initialize has been overridden but is still
-	 * executed. Registers this service as a listener for events at the
-	 * EventManager.
-	 * @return
-	 */
-	ReturnValue_t initialize() override;
-
-	enum Subservice: uint8_t {
-		NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report
-		ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity
-		ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity
-		ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity
-		ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation
-		DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation
-	};
-
-private:
-	uint16_t packetSubCounter = 0;
-	MessageQueueIF* eventQueue = nullptr;
-	bool enableEventReport = true;
-	const uint8_t maxNumberReportsPerCycle;
-
-	ReturnValue_t generateEventReport(EventMessage message);
-};
-
-#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
+#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+
+#include "../tmtcservices/PusServiceBase.h"
+#include "../events/EventMessage.h"
+
+/**
+ * @brief Report on-board events like information or errors
+ * @details
+ * Full Documentation: ECSS-E70-41A p.79
+ * Implements the PusServiceBase template class.
+ * Documentation: Dissertation Baetz p.135,136
+ *
+ * This service provides for the reporting to the service user of information of
+ * operational significance.
+ *   1. reporting of failures or anomalies detected on-board;
+ *   2. reporting of autonomous on-board actions;
+ *   3. reporting of normal progress of operations and activities, e.g.
+ *   detection of events which are not anomalous (such as payload events),
+ *   reaching of predefined steps in an operation. Some reports can combine
+ *   more than one of these events.
+ *
+ * Minimum capabilities of this service:
+ *
+ * - TM[5,1]: Normal/Progress Report
+ * - TM[5,2]: Error/Anomaly Report - Low Severity
+ * - TM[5,3]: Error/Anomaly Report - Medium Severity
+ * - TM[5,4]: Error/Anomaly Report - High Severity
+ *
+ * Events can be translated by using translator files located in
+ * /config/objects/ and /config/events/. Description to events can be added by
+ * adding a comment behind the event definition with [//!<] as leading string
+ *
+ * Additional capabilities of this service:
+ *
+ *  - TC[5,5]: Enable Event Report Generation (Req. 6)
+ *  - TC[5,6]: Disable Event Report Generation (Req. 5)
+ * @author 	R. Mueller
+ * @ingroup pus_services
+ */
+class Service5EventReporting: public PusServiceBase {
+public:
+
+	Service5EventReporting(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
+	virtual ~Service5EventReporting();
+
+	/***
+	* Check for events and generate event reports if required.
+	* @return
+	*/
+	ReturnValue_t performService() override;
+
+	/***
+	 * Turn event generation on or off.
+	 * @return
+	 */
+	ReturnValue_t handleRequest(uint8_t subservice) override;
+
+	/**
+	 * The default PusServiceBase initialize has been overridden but is still
+	 * executed. Registers this service as a listener for events at the
+	 * EventManager.
+	 * @return
+	 */
+	ReturnValue_t initialize() override;
+
+	enum Subservice: uint8_t {
+		NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report
+		ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity
+		ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity
+		ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity
+		ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation
+		DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation
+	};
+
+private:
+	uint16_t packetSubCounter = 0;
+	MessageQueueIF* eventQueue = nullptr;
+	bool enableEventReport = true;
+	const uint8_t maxNumberReportsPerCycle;
+
+	ReturnValue_t generateEventReport(EventMessage message);
+};
+
+#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 50102b04c..7174566af 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -1,11 +1,11 @@
-#include <framework/pus/Service8FunctionManagement.h>
-#include <framework/pus/servicepackets/Service8Packets.h>
+#include "../pus/Service8FunctionManagement.h"
+#include "../pus/servicepackets/Service8Packets.h"
 
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../objectmanager/SystemObjectIF.h"
+#include "../action/HasActionsIF.h"
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 
 Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
 		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index e2c7a84f6..165235332 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -1,8 +1,8 @@
 #ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 #define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 
-#include <framework/action/ActionMessage.h>
-#include <framework/tmtcservices/CommandingServiceBase.h>
+#include "../action/ActionMessage.h"
+#include "../tmtcservices/CommandingServiceBase.h"
 
 /**
  * @brief Functional commanding.
diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index 4ba493d08..f4acbb615 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -1,166 +1,166 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-
-/**
- * @defgroup spacepackets PUS Packet Definitions
- *  This group contains all implemented TM or TM packages that are sent to
- *  or sent by the OBC.They are exported later to display
- *  packet structures in Mission Information Base (MIB).
- */
-
-/**
- * @brief 	FailureReport class to serialize a failure report
- * @brief 	Subservice 1, 3, 5, 7
- * @ingroup spacepackets
- */
-class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
-public:
-	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
-			uint16_t packetSequenceControl_, uint8_t stepNumber_,
-			ReturnValue_t errorCode_, uint32_t errorParameter1_,
-			uint32_t errorParameter2_) :
-			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
-			stepNumber(stepNumber_), errorCode(errorCode_),
-			errorParameter1(errorParameter1_), errorParameter2(errorParameter2_),
-			failureSubtype(failureSubtype_) {}
-
-	/**
-	 * This function is called by the FSFW when calling the tm packet send
-	 * function and supplying the SerializeIF* as parameter
-	 * @param buffer Object content is serialized into the buffer
-	 * @param size
-	 * @param max_size
-	 * @param bigEndian
-	 * @return
-	 */
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-	        size_t maxSize, SerializeIF::Endianness streamEndianness
-	        ) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
-			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
-			        maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		result = SerializeAdapter::serialize(&errorCode, buffer, size,
-		        maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&errorParameter1, buffer, size,
-		        maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		result = SerializeAdapter::serialize(&errorParameter2, buffer, size,
-		        maxSize, streamEndianness);
-		return result;
-	}
-
-
-	virtual size_t getSerializedSize() const {
-		size_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&packetId);
-		size += sizeof(packetSequenceControl);
-		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
-			size += SerializeAdapter::getSerializedSize(&stepNumber);
-		}
-		size += SerializeAdapter::getSerializedSize(&errorCode);
-		size += SerializeAdapter::getSerializedSize(&errorParameter1);
-		size += SerializeAdapter::getSerializedSize(&errorParameter2);
-		return size;
-	}
-
-	/**
-	 * Deserialization is not allowed for a report.
-	 * @param buffer
-	 * @param size
-	 * @param bigEndian
-	 * @return
-	 */
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
-	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
-	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
-	ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file
-	uint32_t errorParameter1;
-	uint32_t errorParameter2;
-	const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE]
-};
-
-/**
- * @brief       Subservices 2, 4, 6, 8
- * @ingroup     spacepackets
- */
-class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
-public:
-	SuccessReport(uint8_t subtype_, uint16_t packetId_,
-			uint16_t packetSequenceControl_,uint8_t stepNumber_) :
-			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
-			stepNumber(stepNumber_), subtype(subtype_) {}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, SerializeIF::Endianness streamEndianness
-			) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
-			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
-					maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		size_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&packetId);
-		size += sizeof(packetSequenceControl);
-		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
-			size += SerializeAdapter::getSerializedSize(&stepNumber);
-		}
-		return size;
-
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
-	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
-	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
-	const uint8_t subtype; //!< [EXPORT] : [IGNORE]
-};
-
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcservices/VerificationCodes.h"
+
+/**
+ * @defgroup spacepackets PUS Packet Definitions
+ *  This group contains all implemented TM or TM packages that are sent to
+ *  or sent by the OBC.They are exported later to display
+ *  packet structures in Mission Information Base (MIB).
+ */
+
+/**
+ * @brief 	FailureReport class to serialize a failure report
+ * @brief 	Subservice 1, 3, 5, 7
+ * @ingroup spacepackets
+ */
+class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
+public:
+	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
+			uint16_t packetSequenceControl_, uint8_t stepNumber_,
+			ReturnValue_t errorCode_, uint32_t errorParameter1_,
+			uint32_t errorParameter2_) :
+			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
+			stepNumber(stepNumber_), errorCode(errorCode_),
+			errorParameter1(errorParameter1_), errorParameter2(errorParameter2_),
+			failureSubtype(failureSubtype_) {}
+
+	/**
+	 * This function is called by the FSFW when calling the tm packet send
+	 * function and supplying the SerializeIF* as parameter
+	 * @param buffer Object content is serialized into the buffer
+	 * @param size
+	 * @param max_size
+	 * @param bigEndian
+	 * @return
+	 */
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	        size_t maxSize, SerializeIF::Endianness streamEndianness
+	        ) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
+			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
+			        maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		result = SerializeAdapter::serialize(&errorCode, buffer, size,
+		        maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&errorParameter1, buffer, size,
+		        maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		result = SerializeAdapter::serialize(&errorParameter2, buffer, size,
+		        maxSize, streamEndianness);
+		return result;
+	}
+
+
+	virtual size_t getSerializedSize() const {
+		size_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&packetId);
+		size += sizeof(packetSequenceControl);
+		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
+			size += SerializeAdapter::getSerializedSize(&stepNumber);
+		}
+		size += SerializeAdapter::getSerializedSize(&errorCode);
+		size += SerializeAdapter::getSerializedSize(&errorParameter1);
+		size += SerializeAdapter::getSerializedSize(&errorParameter2);
+		return size;
+	}
+
+	/**
+	 * Deserialization is not allowed for a report.
+	 * @param buffer
+	 * @param size
+	 * @param bigEndian
+	 * @return
+	 */
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
+	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
+	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
+	ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file
+	uint32_t errorParameter1;
+	uint32_t errorParameter2;
+	const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE]
+};
+
+/**
+ * @brief       Subservices 2, 4, 6, 8
+ * @ingroup     spacepackets
+ */
+class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
+public:
+	SuccessReport(uint8_t subtype_, uint16_t packetId_,
+			uint16_t packetSequenceControl_,uint8_t stepNumber_) :
+			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
+			stepNumber(stepNumber_), subtype(subtype_) {}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, SerializeIF::Endianness streamEndianness
+			) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
+			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
+					maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		size_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&packetId);
+		size += sizeof(packetSequenceControl);
+		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
+			size += SerializeAdapter::getSerializedSize(&stepNumber);
+		}
+		return size;
+
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
+	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
+	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
+	const uint8_t subtype; //!< [EXPORT] : [IGNORE]
+};
+
+#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */
diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h
index 1b5bf236f..6a700b50a 100644
--- a/pus/servicepackets/Service200Packets.h
+++ b/pus/servicepackets/Service200Packets.h
@@ -1,9 +1,9 @@
 #ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
 #define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
 
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/modes/ModeMessage.h>
-#include <framework/serialize/SerializeIF.h>
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../modes/ModeMessage.h"
+#include "../../serialize/SerializeIF.h"
 
 /**
  * @brief Subservice 1, 2, 3, 4, 5
diff --git a/pus/servicepackets/Service2Packets.h b/pus/servicepackets/Service2Packets.h
index f292611e7..a0b1305d7 100644
--- a/pus/servicepackets/Service2Packets.h
+++ b/pus/servicepackets/Service2Packets.h
@@ -1,10 +1,10 @@
 #ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
 #define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
 
-#include <framework/action/ActionMessage.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../../action/ActionMessage.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
 
 /**
  * @brief Subservice 128
diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h
index 14219c936..0b52be3c9 100644
--- a/pus/servicepackets/Service5Packets.h
+++ b/pus/servicepackets/Service5Packets.h
@@ -1,76 +1,76 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-
-
-/**
- * @brief Subservice 1, 2, 3, 4
- * Structure of Event Report.
- * It consists of:
- *      1. Report ID(RID). This is the Event ID in the FSFW
- *      2. Object ID of the reporter (e.g. subsystem)
- *      2. Parameter 1
- *      3. Parameter 2
- *
- * @ingroup spacepackets
- */
-class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
-public:
-
-	EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
-			uint32_t parameter2_):
-			reportId(reportId_),objectId(objectId_), parameter1(parameter1_),
-			parameter2(parameter2_) {}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override
-	{
-		ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&objectId, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&parameter1, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&parameter2, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		uint32_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&reportId);
-		size += SerializeAdapter::getSerializedSize(&objectId);
-		size += SerializeAdapter::getSerializedSize(&parameter1);
-		size += SerializeAdapter::getSerializedSize(&parameter2);
-		return size;
-
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	EventId_t reportId;
-	object_id_t objectId;
-	uint32_t parameter1;
-	uint32_t parameter2;
-};
-
-
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcservices/VerificationCodes.h"
+
+
+/**
+ * @brief Subservice 1, 2, 3, 4
+ * Structure of Event Report.
+ * It consists of:
+ *      1. Report ID(RID). This is the Event ID in the FSFW
+ *      2. Object ID of the reporter (e.g. subsystem)
+ *      2. Parameter 1
+ *      3. Parameter 2
+ *
+ * @ingroup spacepackets
+ */
+class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
+public:
+
+	EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
+			uint32_t parameter2_):
+			reportId(reportId_),objectId(objectId_), parameter1(parameter1_),
+			parameter2(parameter2_) {}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override
+	{
+		ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&objectId, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&parameter1, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&parameter2, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		uint32_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&reportId);
+		size += SerializeAdapter::getSerializedSize(&objectId);
+		size += SerializeAdapter::getSerializedSize(&parameter1);
+		size += SerializeAdapter::getSerializedSize(&parameter2);
+		return size;
+
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	EventId_t reportId;
+	object_id_t objectId;
+	uint32_t parameter1;
+	uint32_t parameter2;
+};
+
+
+#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
index 8ea0d1086..d16309ec8 100644
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@@ -1,12 +1,12 @@
 #ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 #define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 
-#include <framework/action/ActionMessage.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/serialize/SerialBufferAdapter.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
+#include "../../action/ActionMessage.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../serialize/SerialBufferAdapter.h"
+#include "../../serialize/SerializeElement.h"
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serialize/SerialFixedArrayListAdapter.h"
 
 
 /**
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 9b9086d99..893ad1db9 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -1,31 +1,31 @@
-#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
-#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
-
-#include <framework/returnvalues/FwClassIds.h>
-#include <config/returnvalues/classIds.h>
-#include <cstdint>
-
-#define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
-typedef uint16_t ReturnValue_t;
-
-
-class HasReturnvaluesIF {
-public:
-	static const ReturnValue_t RETURN_OK = 0;
-	static const ReturnValue_t RETURN_FAILED = 1;
-	virtual ~HasReturnvaluesIF() {}
-
-	/**
-	 * It is discouraged to use the input parameters 0,0 and 0,1 as this
-	 * will generate the RETURN_OK and RETURN_FAILED returnvalues.
-	 * @param interfaceId
-	 * @param number
-	 * @return
-	 */
-	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
-			uint8_t number) {
-	    return (interfaceId << 8) + number;
-	}
-};
-
-#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
+#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+
+#include "../returnvalues/FwClassIds.h"
+#include <config/returnvalues/classIds.h>
+#include <cstdint>
+
+#define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
+typedef uint16_t ReturnValue_t;
+
+
+class HasReturnvaluesIF {
+public:
+	static const ReturnValue_t RETURN_OK = 0;
+	static const ReturnValue_t RETURN_FAILED = 1;
+	virtual ~HasReturnvaluesIF() {}
+
+	/**
+	 * It is discouraged to use the input parameters 0,0 and 0,1 as this
+	 * will generate the RETURN_OK and RETURN_FAILED returnvalues.
+	 * @param interfaceId
+	 * @param number
+	 * @return
+	 */
+	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
+			uint8_t number) {
+	    return (interfaceId << 8) + number;
+	}
+};
+
+#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
diff --git a/rmap/RMAP.cpp b/rmap/RMAP.cpp
index 927fe746f..8bc91bb5e 100644
--- a/rmap/RMAP.cpp
+++ b/rmap/RMAP.cpp
@@ -1,89 +1,89 @@
-#include <framework/devicehandlers/DeviceCommunicationIF.h>
-#include <framework/rmap/rmapStructs.h>
-#include <framework/rmap/RMAP.h>
-#include <framework/rmap/RMAPChannelIF.h>
-#include <stddef.h>
-
-ReturnValue_t RMAP::reset(RMAPCookie* cookie) {
-	return cookie->getChannel()->reset();
-}
-
-RMAP::RMAP(){
-
-}
-
-ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
-		size_t length) {
-	uint8_t instruction;
-
-	if ((buffer == NULL) && (length != 0)) {
-		return DeviceCommunicationIF::NULLPOINTER;
-	}
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	instruction = RMAPIds::RMAP_COMMAND_WRITE | cookie->getCommandMask();
-	return cookie->getChannel()->sendCommand(cookie, instruction, buffer,
-			length);
-
-}
-
-ReturnValue_t RMAP::getWriteReply(RMAPCookie *cookie) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
-		return cookie->getChannel()->getReply(cookie, NULL, NULL);
-	} else {
-		return REPLY_MISSMATCH;
-	}
-}
-
-ReturnValue_t RMAP::writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
-		uint32_t length, uint32_t timeout_us) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	return cookie->getChannel()->sendCommandBlocking(cookie, buffer, length,
-			NULL, NULL, timeout_us);
-
-}
-ReturnValue_t RMAP::sendReadCommand(RMAPCookie *cookie, uint32_t expLength) {
-	uint8_t command;
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	command =  RMAPIds::RMAP_COMMAND_READ
-			| (cookie->getCommandMask() & ~(1 <<  RMAPIds::RMAP_COMMAND_BIT_VERIFY));
-
-	return cookie->getChannel()->sendCommand(cookie, command, NULL, expLength);
-
-}
-
-ReturnValue_t RMAP::getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-		size_t *size) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	if (buffer == NULL || size == NULL) {
-		return DeviceCommunicationIF::NULLPOINTER;
-	}
-	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
-		return REPLY_MISSMATCH;
-	} else {
-		return cookie->getChannel()->getReply(cookie, buffer, size);
-	}
-
-}
-
-ReturnValue_t RMAP::readBlocking(RMAPCookie *cookie, uint32_t expLength,
-		uint8_t** buffer, uint32_t *size, uint32_t timeout_us) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	if (buffer == NULL || size == NULL) {
-		return DeviceCommunicationIF::NULLPOINTER;
-	}
-	return cookie->getChannel()->sendCommandBlocking(cookie, NULL, expLength,
-			buffer, size, timeout_us);
-}
+#include "../devicehandlers/DeviceCommunicationIF.h"
+#include "../rmap/rmapStructs.h"
+#include "../rmap/RMAP.h"
+#include "../rmap/RMAPChannelIF.h"
+#include <stddef.h>
+
+ReturnValue_t RMAP::reset(RMAPCookie* cookie) {
+	return cookie->getChannel()->reset();
+}
+
+RMAP::RMAP(){
+
+}
+
+ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+		size_t length) {
+	uint8_t instruction;
+
+	if ((buffer == NULL) && (length != 0)) {
+		return DeviceCommunicationIF::NULLPOINTER;
+	}
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	instruction = RMAPIds::RMAP_COMMAND_WRITE | cookie->getCommandMask();
+	return cookie->getChannel()->sendCommand(cookie, instruction, buffer,
+			length);
+
+}
+
+ReturnValue_t RMAP::getWriteReply(RMAPCookie *cookie) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
+		return cookie->getChannel()->getReply(cookie, NULL, NULL);
+	} else {
+		return REPLY_MISSMATCH;
+	}
+}
+
+ReturnValue_t RMAP::writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
+		uint32_t length, uint32_t timeout_us) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	return cookie->getChannel()->sendCommandBlocking(cookie, buffer, length,
+			NULL, NULL, timeout_us);
+
+}
+ReturnValue_t RMAP::sendReadCommand(RMAPCookie *cookie, uint32_t expLength) {
+	uint8_t command;
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	command =  RMAPIds::RMAP_COMMAND_READ
+			| (cookie->getCommandMask() & ~(1 <<  RMAPIds::RMAP_COMMAND_BIT_VERIFY));
+
+	return cookie->getChannel()->sendCommand(cookie, command, NULL, expLength);
+
+}
+
+ReturnValue_t RMAP::getReadReply(RMAPCookie *cookie, uint8_t **buffer,
+		size_t *size) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	if (buffer == NULL || size == NULL) {
+		return DeviceCommunicationIF::NULLPOINTER;
+	}
+	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
+		return REPLY_MISSMATCH;
+	} else {
+		return cookie->getChannel()->getReply(cookie, buffer, size);
+	}
+
+}
+
+ReturnValue_t RMAP::readBlocking(RMAPCookie *cookie, uint32_t expLength,
+		uint8_t** buffer, uint32_t *size, uint32_t timeout_us) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	if (buffer == NULL || size == NULL) {
+		return DeviceCommunicationIF::NULLPOINTER;
+	}
+	return cookie->getChannel()->sendCommandBlocking(cookie, NULL, expLength,
+			buffer, size, timeout_us);
+}
diff --git a/rmap/RMAP.h b/rmap/RMAP.h
index 91aa123e2..9ab6b87db 100644
--- a/rmap/RMAP.h
+++ b/rmap/RMAP.h
@@ -1,227 +1,227 @@
-#ifndef RMAPpp_H_
-#define RMAPpp_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/rmap/RMAPCookie.h>
-
-//SHOULDTODO: clean up includes for RMAP, should be enough to include RMAP.h but right now it's quite chaotic...
-
-/**
- * API for a Cookie/Channel based RMAP implementation.
- *
- * The API offers the four basic RMAP actions: sending a Read or Write command and getting the reply to each.
- * As RMAP is an asynchronous protocol, these are implemented as four seperate calls. There are blocking
- * calls which combine a send and get call using a timeout, but these are "real" blocking, looping in between
- * the calls.
- *
- * Cookies are used to contain Information between a send[Read,Write]Command and a get[Read,Write]Reply call,
- * one can think of them like *nix file descriptors. A cookie is valid from a sendX call until the related getX
- * call. That means if a cookie is used in a getX call, the reply to the sendX call the cookie was used with
- * previously is returned.
- * Depending on the underlying RMAPChannel implementation, a cookie can also be valid for more than one getX
- * call, but this should not be assumed generally.
- * A cookie encapsulates information like the RMAP Channel to use, as well as the RMAP Address
- * and a Command Mask used for specifying which RMAP capabilities are used.
- * Cookies are created without interaction with this API, there is no open() call. The RMAP implementation
- * will initialize all fields which are not set by the cookie's constructor.
- *
- * The RMAP implementation relies on Channels. A channel is used to construct the RMAP Headers and handle the
- * protocol. It is access via the RMAPChannelIF. Thus it is possible to use different Implementations which only
- * need to implement the RMAPChannelIF. A channel is also responsible for accessing the lower layers, for example
- * a SPaceWire transport layer.
- *
- * There is one RMAP Channel per physical device. The cookie-channel as well as the device-channel assignment
- * can be changed at runtime to allow for example redundancy switching. This API is static as the information which
- * channel to use is contained within the cookie.
- */
-class RMAP: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::RMAP_CHANNEL;
-
-	//static const ReturnValue_t COMMAND_OK = MAKE_RETURN_CODE(0x00);
-	static const ReturnValue_t COMMAND_NO_DESCRIPTORS_AVAILABLE =
-			MAKE_RETURN_CODE(0xE1); //no descriptors available for sending command; command was not sent
-	static const ReturnValue_t COMMAND_BUFFER_FULL = MAKE_RETURN_CODE(0xE2); //no receiver buffer available for expected len; command was not sent
-	static const ReturnValue_t COMMAND_CHANNEL_OUT_OF_RANGE = MAKE_RETURN_CODE(
-			0xE3); //The cookie points to an invalid channel; command was not sent
-//Replaced by DeviceCommunicationIF::TOO_MUCH_DATA	static const ReturnValue_t COMMAND_TOO_BIG = MAKE_RETURN_CODE(0xE4); //the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command)
-	//command was not sent
-//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t COMMAND_NULLPOINTER = MAKE_RETURN_CODE(0xE5); //datalen was != 0 but data was == NULL in write command, or nullpointer in read command
-	static const ReturnValue_t COMMAND_CHANNEL_DEACTIVATED = MAKE_RETURN_CODE(
-			0xE6);	//the channel has no port set
-	static const ReturnValue_t COMMAND_PORT_OUT_OF_RANGE = MAKE_RETURN_CODE(
-			0xE7);	//The specified port is not valid
-	static const ReturnValue_t COMMAND_PORT_IN_USE = MAKE_RETURN_CODE(0xE8);//The specified port is already in use
-	static const ReturnValue_t COMMAND_NO_CHANNEL = MAKE_RETURN_CODE(0xE9);//The cookie to work with has no channel assigned.
-	static const ReturnValue_t NO_HW_CRC = MAKE_RETURN_CODE(0xEA);//The SpW port does not support HW CRC generation, which is unsupported
-	//return values for both get_write_reply and get_read_reply
-	static const ReturnValue_t REPLY_NO_REPLY = MAKE_RETURN_CODE(0xD0);	//no reply was received
-	static const ReturnValue_t REPLY_NOT_SENT = MAKE_RETURN_CODE(0xD1);	//command was not sent, implies no reply
-	static const ReturnValue_t REPLY_NOT_YET_SENT = MAKE_RETURN_CODE(0xD2);	//command is still waiting to be sent
-	static const ReturnValue_t REPLY_MISSMATCH = MAKE_RETURN_CODE(0xD3);//a read command was issued, but get_write_rply called, or other way round
-	static const ReturnValue_t REPLY_TIMEOUT = MAKE_RETURN_CODE(0xD4);//timeout
-//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t REPLY_NULLPOINTER = MAKE_RETURN_CODE(0xD5);//one of the arguments in a read reply was NULL
-	//return values for get_reply
-	static const ReturnValue_t REPLY_INTERFACE_BUSY = MAKE_RETURN_CODE(
-			0xC0);//Interface is busy (transmission buffer still being processed)
-	static const ReturnValue_t REPLY_TRANSMISSION_ERROR =
-			MAKE_RETURN_CODE(0xC1);	//Interface encountered errors during last operation, data could not be processed. (transmission error)
-	static const ReturnValue_t REPLY_INVALID_DATA = MAKE_RETURN_CODE(
-			0xC2);	//Invalid data (amount / value)
-	static const ReturnValue_t REPLY_NOT_SUPPORTED = MAKE_RETURN_CODE(
-			0xC3);
-
-	//return values for reset
-	static const ReturnValue_t LINK_DOWN = MAKE_RETURN_CODE(0xF0);//The spw link is down
-	//Other SpW codes:
-	static const ReturnValue_t SPW_CREDIT = MAKE_RETURN_CODE(0xF1);
-	static const ReturnValue_t SPW_ESCAPE = MAKE_RETURN_CODE(0xF2);
-	static const ReturnValue_t SPW_DISCONNECT = MAKE_RETURN_CODE(0xF3);
-	static const ReturnValue_t SPW_PARITY = MAKE_RETURN_CODE(0xF4);
-	static const ReturnValue_t SPW_WRITE_SYNC = MAKE_RETURN_CODE(0xF5);
-	static const ReturnValue_t SPW_INVALID_ADDRESS = MAKE_RETURN_CODE(0xF6);
-	static const ReturnValue_t SPW_EARLY_EOP = MAKE_RETURN_CODE(0xF7);
-	static const ReturnValue_t SPW_DMA = MAKE_RETURN_CODE(0xF8);
-	static const ReturnValue_t SPW_LINK_ERROR = MAKE_RETURN_CODE(0xF9);
-
-
-	//RMAP standard replies
-	static const ReturnValue_t REPLY_OK = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t REPLY_GENERAL_ERROR_CODE = MAKE_RETURN_CODE(1);// The detected error does not fit into the other
-	// error cases or the node does not support
-	// further distinction between the errors
-	static const ReturnValue_t REPLY_UNUSED_PACKET_TYPE_OR_COMMAND_CODE =
-			MAKE_RETURN_CODE(2);	// The Header CRC was decoded correctly but
-	// the packet type is reserved or the command
-	// is not used by the RMAP protocol.
-	static const ReturnValue_t REPLY_INVALID_KEY = MAKE_RETURN_CODE(3);	// The Header CRC was decoded correctly but
-	// the device key did not match that expected
-	// by the target user application
-	static const ReturnValue_t REPLY_INVALID_DATA_CRC = MAKE_RETURN_CODE(4);// Error in the CRC of the data field
-	static const ReturnValue_t REPLY_EARLY_EOP = MAKE_RETURN_CODE(5);// EOP marker detected before the end of the data
-	static const ReturnValue_t REPLY_TOO_MUCH_DATA = MAKE_RETURN_CODE(6);// More than the expected amount of data in a
-	// command has been received
-	static const ReturnValue_t REPLY_EEP = MAKE_RETURN_CODE(7);	// EEP marker detected immediately after the
-	// header CRC or during the transfer of data
-	// and Data CRC or immediately thereafter.
-	// Indicates that there was a communication
-	// failure of some sort on the network
-	static const ReturnValue_t REPLY_RESERVED = MAKE_RETURN_CODE(8);// Reserved
-	static const ReturnValue_t REPLY_VERIFY_BUFFER_OVERRUN = MAKE_RETURN_CODE(
-			9);	// The verify before write bit of the command
-	// was set so that the data field was buffered in
-	// order to verify the Data CRC before
-	// transferring the data to target memory. The
-	// data field was longer than able to fit inside
-	// the verify buffer resulting in a buffer overrun
-	// Note that the command is not executed in
-	// this case
-	static const ReturnValue_t REPLY_COMMAND_NOT_IMPLEMENTED_OR_NOT_AUTHORISED =
-			MAKE_RETURN_CODE(10);// The target user application did not authorise
-	// the requested operation. This may be because
-	// the command requested has not been
-	// implemented
-	static const ReturnValue_t REPLY_RMW_DATA_LENGTH_ERROR = MAKE_RETURN_CODE(
-			11);	// The amount of data in a RMW command is
-	// invalid (0x01	 0x03	 0x05	 0x07 or  greater
-	// than 0x08)
-	static const ReturnValue_t REPLY_INVALID_TARGET_LOGICAL_ADDRESS =
-			MAKE_RETURN_CODE(12);	// The Header CRC was decoded correctly but
-	// the Target Logical Address was not the value
-	// expected by the target
-
-	/**
-	 * Resets the underlying channel.
-	 *
-	 * @param cookie The cookie which points to the channel to reset
-	 * @return
-	 */
-	static ReturnValue_t reset(RMAPCookie *cookie);
-
-	/**
-	 * send an RMAP write command
-	 *
-	 * datalen is only 24bit wide, rest will be ignored
-	 * IMPORTANT: the data buffer must be datalen+1 large, as the driver might
-	 * write a CRC sum at data[datalen]
-	 * if you want to send an empty packet, just do datalen = 0 and data = NULL
-	 *
-	 * @param cookie The cookie to write to
-	 * @param buffer the data to write
-	 * @param length length of data
-	 * @return
-	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command
-	 *      - return codes of RMAPChannelIF::sendCommand()
-	 */
-	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
-			size_t length);
-
-	/**
-	 * get the reply to a write command
-	 *
-	 * @param cookie the cookie the command was sent with
-	 * @return
-	 *      - @c REPLY_MISSMATCH			a read command was issued, but getWriteReply called
-	 *      - return codes of RMAPChannelIF::getReply()
-	 */
-	static ReturnValue_t getWriteReply(RMAPCookie *cookie);
-
-	/**
-	 * @see sendWriteCommand()
-	 * @see getWriteReply()
-	 *
-	 * @param timeout_us the time after the function returns, if no reply was received
-	 *
-	 * @return
-	 *       - All of sendWriteCommand()
-	 *       - All of getWriteReply()
-	 *       - @c REPLY_TIMEOUT				timeout
-	 */
-	static ReturnValue_t writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
-			uint32_t length, uint32_t timeout_us);
-
-	/**
-	 * send an RMAP read command
-	 *
-	 * @param cookie to cookie to read from
-	 * @param expLength the expected maximum length of the reply
-	 * @return
-	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command, or nullpointer in read command
-	 *      - return codes of RMAPChannelIF::sendCommand()
-	 */
-	static ReturnValue_t sendReadCommand(RMAPCookie *cookie,
-			uint32_t expLength);
-
-	/**
-	 * get a reply to an RMAP read command
-	 *
-	 * @param cookie the cookie that was read from
-	 * @param[out] buffer the location of the data
-	 * @param[out] size size of the data
-	 * @return
-	 *      - @c COMMAND_NULLPOINTER		buffer or size was NULL
-	 *      - @c REPLY_MISSMATCH			a write command was issued, but getReadReply called
-	 *      - return codes of RMAPChannelIF::getReply()
-	 */
-	static ReturnValue_t getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-			size_t *size);
-
-	/**
-	 * @see sendReadCommand()
-	 * @see getReadReply()
-	 *
-	 * @param timeout_us the time after the function returns, if no reply was received
-	 *
-	 * @return
-	 *       - All of sendReadCommand()
-	 *       - All of getReadReply()
-	 *       - @c REPLY_TIMEOUT				timeout
-	 */
-	static ReturnValue_t readBlocking(RMAPCookie *cookie, uint32_t expLength,
-			uint8_t** buffer, uint32_t *size, uint32_t timeout_us);
-
-protected:
-	RMAP();
-};
-
-#endif /* RMAPpp_H_ */
+#ifndef RMAPpp_H_
+#define RMAPpp_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../rmap/RMAPCookie.h"
+
+//SHOULDTODO: clean up includes for RMAP, should be enough to include RMAP.h but right now it's quite chaotic...
+
+/**
+ * API for a Cookie/Channel based RMAP implementation.
+ *
+ * The API offers the four basic RMAP actions: sending a Read or Write command and getting the reply to each.
+ * As RMAP is an asynchronous protocol, these are implemented as four seperate calls. There are blocking
+ * calls which combine a send and get call using a timeout, but these are "real" blocking, looping in between
+ * the calls.
+ *
+ * Cookies are used to contain Information between a send[Read,Write]Command and a get[Read,Write]Reply call,
+ * one can think of them like *nix file descriptors. A cookie is valid from a sendX call until the related getX
+ * call. That means if a cookie is used in a getX call, the reply to the sendX call the cookie was used with
+ * previously is returned.
+ * Depending on the underlying RMAPChannel implementation, a cookie can also be valid for more than one getX
+ * call, but this should not be assumed generally.
+ * A cookie encapsulates information like the RMAP Channel to use, as well as the RMAP Address
+ * and a Command Mask used for specifying which RMAP capabilities are used.
+ * Cookies are created without interaction with this API, there is no open() call. The RMAP implementation
+ * will initialize all fields which are not set by the cookie's constructor.
+ *
+ * The RMAP implementation relies on Channels. A channel is used to construct the RMAP Headers and handle the
+ * protocol. It is access via the RMAPChannelIF. Thus it is possible to use different Implementations which only
+ * need to implement the RMAPChannelIF. A channel is also responsible for accessing the lower layers, for example
+ * a SPaceWire transport layer.
+ *
+ * There is one RMAP Channel per physical device. The cookie-channel as well as the device-channel assignment
+ * can be changed at runtime to allow for example redundancy switching. This API is static as the information which
+ * channel to use is contained within the cookie.
+ */
+class RMAP: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::RMAP_CHANNEL;
+
+	//static const ReturnValue_t COMMAND_OK = MAKE_RETURN_CODE(0x00);
+	static const ReturnValue_t COMMAND_NO_DESCRIPTORS_AVAILABLE =
+			MAKE_RETURN_CODE(0xE1); //no descriptors available for sending command; command was not sent
+	static const ReturnValue_t COMMAND_BUFFER_FULL = MAKE_RETURN_CODE(0xE2); //no receiver buffer available for expected len; command was not sent
+	static const ReturnValue_t COMMAND_CHANNEL_OUT_OF_RANGE = MAKE_RETURN_CODE(
+			0xE3); //The cookie points to an invalid channel; command was not sent
+//Replaced by DeviceCommunicationIF::TOO_MUCH_DATA	static const ReturnValue_t COMMAND_TOO_BIG = MAKE_RETURN_CODE(0xE4); //the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command)
+	//command was not sent
+//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t COMMAND_NULLPOINTER = MAKE_RETURN_CODE(0xE5); //datalen was != 0 but data was == NULL in write command, or nullpointer in read command
+	static const ReturnValue_t COMMAND_CHANNEL_DEACTIVATED = MAKE_RETURN_CODE(
+			0xE6);	//the channel has no port set
+	static const ReturnValue_t COMMAND_PORT_OUT_OF_RANGE = MAKE_RETURN_CODE(
+			0xE7);	//The specified port is not valid
+	static const ReturnValue_t COMMAND_PORT_IN_USE = MAKE_RETURN_CODE(0xE8);//The specified port is already in use
+	static const ReturnValue_t COMMAND_NO_CHANNEL = MAKE_RETURN_CODE(0xE9);//The cookie to work with has no channel assigned.
+	static const ReturnValue_t NO_HW_CRC = MAKE_RETURN_CODE(0xEA);//The SpW port does not support HW CRC generation, which is unsupported
+	//return values for both get_write_reply and get_read_reply
+	static const ReturnValue_t REPLY_NO_REPLY = MAKE_RETURN_CODE(0xD0);	//no reply was received
+	static const ReturnValue_t REPLY_NOT_SENT = MAKE_RETURN_CODE(0xD1);	//command was not sent, implies no reply
+	static const ReturnValue_t REPLY_NOT_YET_SENT = MAKE_RETURN_CODE(0xD2);	//command is still waiting to be sent
+	static const ReturnValue_t REPLY_MISSMATCH = MAKE_RETURN_CODE(0xD3);//a read command was issued, but get_write_rply called, or other way round
+	static const ReturnValue_t REPLY_TIMEOUT = MAKE_RETURN_CODE(0xD4);//timeout
+//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t REPLY_NULLPOINTER = MAKE_RETURN_CODE(0xD5);//one of the arguments in a read reply was NULL
+	//return values for get_reply
+	static const ReturnValue_t REPLY_INTERFACE_BUSY = MAKE_RETURN_CODE(
+			0xC0);//Interface is busy (transmission buffer still being processed)
+	static const ReturnValue_t REPLY_TRANSMISSION_ERROR =
+			MAKE_RETURN_CODE(0xC1);	//Interface encountered errors during last operation, data could not be processed. (transmission error)
+	static const ReturnValue_t REPLY_INVALID_DATA = MAKE_RETURN_CODE(
+			0xC2);	//Invalid data (amount / value)
+	static const ReturnValue_t REPLY_NOT_SUPPORTED = MAKE_RETURN_CODE(
+			0xC3);
+
+	//return values for reset
+	static const ReturnValue_t LINK_DOWN = MAKE_RETURN_CODE(0xF0);//The spw link is down
+	//Other SpW codes:
+	static const ReturnValue_t SPW_CREDIT = MAKE_RETURN_CODE(0xF1);
+	static const ReturnValue_t SPW_ESCAPE = MAKE_RETURN_CODE(0xF2);
+	static const ReturnValue_t SPW_DISCONNECT = MAKE_RETURN_CODE(0xF3);
+	static const ReturnValue_t SPW_PARITY = MAKE_RETURN_CODE(0xF4);
+	static const ReturnValue_t SPW_WRITE_SYNC = MAKE_RETURN_CODE(0xF5);
+	static const ReturnValue_t SPW_INVALID_ADDRESS = MAKE_RETURN_CODE(0xF6);
+	static const ReturnValue_t SPW_EARLY_EOP = MAKE_RETURN_CODE(0xF7);
+	static const ReturnValue_t SPW_DMA = MAKE_RETURN_CODE(0xF8);
+	static const ReturnValue_t SPW_LINK_ERROR = MAKE_RETURN_CODE(0xF9);
+
+
+	//RMAP standard replies
+	static const ReturnValue_t REPLY_OK = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t REPLY_GENERAL_ERROR_CODE = MAKE_RETURN_CODE(1);// The detected error does not fit into the other
+	// error cases or the node does not support
+	// further distinction between the errors
+	static const ReturnValue_t REPLY_UNUSED_PACKET_TYPE_OR_COMMAND_CODE =
+			MAKE_RETURN_CODE(2);	// The Header CRC was decoded correctly but
+	// the packet type is reserved or the command
+	// is not used by the RMAP protocol.
+	static const ReturnValue_t REPLY_INVALID_KEY = MAKE_RETURN_CODE(3);	// The Header CRC was decoded correctly but
+	// the device key did not match that expected
+	// by the target user application
+	static const ReturnValue_t REPLY_INVALID_DATA_CRC = MAKE_RETURN_CODE(4);// Error in the CRC of the data field
+	static const ReturnValue_t REPLY_EARLY_EOP = MAKE_RETURN_CODE(5);// EOP marker detected before the end of the data
+	static const ReturnValue_t REPLY_TOO_MUCH_DATA = MAKE_RETURN_CODE(6);// More than the expected amount of data in a
+	// command has been received
+	static const ReturnValue_t REPLY_EEP = MAKE_RETURN_CODE(7);	// EEP marker detected immediately after the
+	// header CRC or during the transfer of data
+	// and Data CRC or immediately thereafter.
+	// Indicates that there was a communication
+	// failure of some sort on the network
+	static const ReturnValue_t REPLY_RESERVED = MAKE_RETURN_CODE(8);// Reserved
+	static const ReturnValue_t REPLY_VERIFY_BUFFER_OVERRUN = MAKE_RETURN_CODE(
+			9);	// The verify before write bit of the command
+	// was set so that the data field was buffered in
+	// order to verify the Data CRC before
+	// transferring the data to target memory. The
+	// data field was longer than able to fit inside
+	// the verify buffer resulting in a buffer overrun
+	// Note that the command is not executed in
+	// this case
+	static const ReturnValue_t REPLY_COMMAND_NOT_IMPLEMENTED_OR_NOT_AUTHORISED =
+			MAKE_RETURN_CODE(10);// The target user application did not authorise
+	// the requested operation. This may be because
+	// the command requested has not been
+	// implemented
+	static const ReturnValue_t REPLY_RMW_DATA_LENGTH_ERROR = MAKE_RETURN_CODE(
+			11);	// The amount of data in a RMW command is
+	// invalid (0x01	 0x03	 0x05	 0x07 or  greater
+	// than 0x08)
+	static const ReturnValue_t REPLY_INVALID_TARGET_LOGICAL_ADDRESS =
+			MAKE_RETURN_CODE(12);	// The Header CRC was decoded correctly but
+	// the Target Logical Address was not the value
+	// expected by the target
+
+	/**
+	 * Resets the underlying channel.
+	 *
+	 * @param cookie The cookie which points to the channel to reset
+	 * @return
+	 */
+	static ReturnValue_t reset(RMAPCookie *cookie);
+
+	/**
+	 * send an RMAP write command
+	 *
+	 * datalen is only 24bit wide, rest will be ignored
+	 * IMPORTANT: the data buffer must be datalen+1 large, as the driver might
+	 * write a CRC sum at data[datalen]
+	 * if you want to send an empty packet, just do datalen = 0 and data = NULL
+	 *
+	 * @param cookie The cookie to write to
+	 * @param buffer the data to write
+	 * @param length length of data
+	 * @return
+	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command
+	 *      - return codes of RMAPChannelIF::sendCommand()
+	 */
+	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+			size_t length);
+
+	/**
+	 * get the reply to a write command
+	 *
+	 * @param cookie the cookie the command was sent with
+	 * @return
+	 *      - @c REPLY_MISSMATCH			a read command was issued, but getWriteReply called
+	 *      - return codes of RMAPChannelIF::getReply()
+	 */
+	static ReturnValue_t getWriteReply(RMAPCookie *cookie);
+
+	/**
+	 * @see sendWriteCommand()
+	 * @see getWriteReply()
+	 *
+	 * @param timeout_us the time after the function returns, if no reply was received
+	 *
+	 * @return
+	 *       - All of sendWriteCommand()
+	 *       - All of getWriteReply()
+	 *       - @c REPLY_TIMEOUT				timeout
+	 */
+	static ReturnValue_t writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
+			uint32_t length, uint32_t timeout_us);
+
+	/**
+	 * send an RMAP read command
+	 *
+	 * @param cookie to cookie to read from
+	 * @param expLength the expected maximum length of the reply
+	 * @return
+	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command, or nullpointer in read command
+	 *      - return codes of RMAPChannelIF::sendCommand()
+	 */
+	static ReturnValue_t sendReadCommand(RMAPCookie *cookie,
+			uint32_t expLength);
+
+	/**
+	 * get a reply to an RMAP read command
+	 *
+	 * @param cookie the cookie that was read from
+	 * @param[out] buffer the location of the data
+	 * @param[out] size size of the data
+	 * @return
+	 *      - @c COMMAND_NULLPOINTER		buffer or size was NULL
+	 *      - @c REPLY_MISSMATCH			a write command was issued, but getReadReply called
+	 *      - return codes of RMAPChannelIF::getReply()
+	 */
+	static ReturnValue_t getReadReply(RMAPCookie *cookie, uint8_t **buffer,
+			size_t *size);
+
+	/**
+	 * @see sendReadCommand()
+	 * @see getReadReply()
+	 *
+	 * @param timeout_us the time after the function returns, if no reply was received
+	 *
+	 * @return
+	 *       - All of sendReadCommand()
+	 *       - All of getReadReply()
+	 *       - @c REPLY_TIMEOUT				timeout
+	 */
+	static ReturnValue_t readBlocking(RMAPCookie *cookie, uint32_t expLength,
+			uint8_t** buffer, uint32_t *size, uint32_t timeout_us);
+
+protected:
+	RMAP();
+};
+
+#endif /* RMAPpp_H_ */
diff --git a/rmap/RMAPChannelIF.h b/rmap/RMAPChannelIF.h
index 34623bb35..037d6d27f 100644
--- a/rmap/RMAPChannelIF.h
+++ b/rmap/RMAPChannelIF.h
@@ -1,116 +1,116 @@
-#ifndef RMAPCHANNELIF_H_
-#define RMAPCHANNELIF_H_
-
-#include <framework/rmap/RMAPCookie.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstddef>
-
-class RMAPChannelIF {
-public:
-	virtual ~RMAPChannelIF(){};
-	/**
-	 * Reset an RMAP channel
-	 *
-	 * Clears the receive buffer (all received messages are deleted) and resets the descriptor table.
-	 * Also checks for errors in the descriptors and submits them to FDIR (aka stdout)
-	 *
-	 * @param channel to reset
-	 *
-	 * @return
-	 *      - @c LINK_DOWN	when the link is down and all replies were missed
-	 *      - @c COMMAND_CHANNEL_DEACTIVATED if the channel's port is NULL
-	 *      - @c RETURN_OK else
-	 */
-	virtual ReturnValue_t reset()=0;
-
-	/**
-	 * Check if a channel is active (ie has a port)
-	 *
-	 * @param channel_nr
-	 * @return
-	 *      - @c COMMAND_OK if channel is active
-	 *      - @c COMMAND_CHANNEL_DEACTIVATED if channel is deactivated
-	 */
-	virtual ReturnValue_t isActive()=0;
-
-	/**
-	 * Assign a SpaceWire port to the Channel
-	 *
-	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
-	 * @param dest_addr	the destination address used by all packets sent from this channel
-	 * @param src_addr the source address used by all packets sent from this channel and used when checking incoming packets
-	 * @return
-	 *      - @c COMMAND_OK if port was changed
-	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
-	 */
-	virtual ReturnValue_t setPort(int8_t port, uint8_t dest_addr,
-			uint8_t src_addr)=0;
-
-	/**
-	 * Assign a SpaceWire port to the Channel
-	 *
-	 * same as setPort(int8_t port, uint8_t dest_addr, uint8_t src_addr), only the addresses are left unchanged
-	 *
-	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
-	 * @return
-	 *      - @c COMMAND_OK if port was changed
-	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
-	 */
-	virtual ReturnValue_t setPort(int8_t port)=0;
-
-	/**
-	 * Send an RMAP command
-	 *
-	 * @param cookie the cookie used with this call
-	 * @param instruction the instruction byte that will be sent (this defines if it is a read or write command)
-	 * @param data data to be sent
-	 * @param datalen length of data
-	 * @return
-	 *      - @c RETURN_OK
-	 *      - @c COMMAND_NO_DESCRIPTORS_AVAILABLE 	no descriptors available for sending command; command was not sent
-	 *      - @c COMMAND_BUFFER_FULL				no receiver buffer available for expected len; command was not sent
-	 *      - @c COMMAND_TOO_BIG					the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command) command was not sent
-	 *      - @c COMMAND_CHANNEL_DEACTIVATED		the channel has no port set
-	 *      - @c NOT_SUPPORTED						if you dont feel like implementing something...
-	 */
-	virtual ReturnValue_t sendCommand(RMAPCookie *cookie, uint8_t instruction,
-			const uint8_t *data, size_t datalen)=0;
-
-	/**
-	 * get the reply to an rmap command
-	 *
-	 * @param cookie the cookie the command was sent with
-	 * @param databuffer a pointer to a pointer the location of the reply will be written to
-	 * @param len a pointer to the variable the length of the reply will be written to
-	 * @return
-	 *      - @c REPLY_NO_REPLY				no reply was received
-	 *      - @c REPLY_NOT_SENT				command was not sent, implies no reply
-	 *      - @c REPLY_NOT_YET_SENT			command is still waiting to be sent
-	 *      - @c WRITE_REPLY_INTERFACE_BUSY			Interface is busy (transmission buffer still being processed)
-	 *      - @c WRITE_REPLY_TRANSMISSION_ERROR		Interface encountered errors during last operation, data could not be processed. (transmission error)
-	 *      - @c WRITE_REPLY_INVALID_DATA			Invalid data (amount / value)
-	 *      - @c WRITE_REPLY_NOT_SUPPORTED
-	 *      - all RMAP standard replies
-	 */
-	virtual ReturnValue_t getReply(RMAPCookie *cookie, uint8_t **databuffer,
-			size_t *len)=0;
-
-	/**
-	 *
-	 * @param cookie
-	 * @param data
-	 * @param datalen
-	 * @param databuffer
-	 * @param len
-	 * @param timeout_us
-	 * @return
-	 *       - all replies of sendCommand() and getReply()
-	 *       - @c REPLY_TIMEOUT				timeout
-	 */
-	virtual ReturnValue_t sendCommandBlocking(RMAPCookie *cookie, uint8_t *data,
-			uint32_t datalen, uint8_t **databuffer, uint32_t *len,
-			uint32_t timeout_us)=0;
-
-};
-
-#endif /* RMAPCHANNELIF_H_ */
+#ifndef RMAPCHANNELIF_H_
+#define RMAPCHANNELIF_H_
+
+#include "../rmap/RMAPCookie.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+class RMAPChannelIF {
+public:
+	virtual ~RMAPChannelIF(){};
+	/**
+	 * Reset an RMAP channel
+	 *
+	 * Clears the receive buffer (all received messages are deleted) and resets the descriptor table.
+	 * Also checks for errors in the descriptors and submits them to FDIR (aka stdout)
+	 *
+	 * @param channel to reset
+	 *
+	 * @return
+	 *      - @c LINK_DOWN	when the link is down and all replies were missed
+	 *      - @c COMMAND_CHANNEL_DEACTIVATED if the channel's port is NULL
+	 *      - @c RETURN_OK else
+	 */
+	virtual ReturnValue_t reset()=0;
+
+	/**
+	 * Check if a channel is active (ie has a port)
+	 *
+	 * @param channel_nr
+	 * @return
+	 *      - @c COMMAND_OK if channel is active
+	 *      - @c COMMAND_CHANNEL_DEACTIVATED if channel is deactivated
+	 */
+	virtual ReturnValue_t isActive()=0;
+
+	/**
+	 * Assign a SpaceWire port to the Channel
+	 *
+	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
+	 * @param dest_addr	the destination address used by all packets sent from this channel
+	 * @param src_addr the source address used by all packets sent from this channel and used when checking incoming packets
+	 * @return
+	 *      - @c COMMAND_OK if port was changed
+	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
+	 */
+	virtual ReturnValue_t setPort(int8_t port, uint8_t dest_addr,
+			uint8_t src_addr)=0;
+
+	/**
+	 * Assign a SpaceWire port to the Channel
+	 *
+	 * same as setPort(int8_t port, uint8_t dest_addr, uint8_t src_addr), only the addresses are left unchanged
+	 *
+	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
+	 * @return
+	 *      - @c COMMAND_OK if port was changed
+	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
+	 */
+	virtual ReturnValue_t setPort(int8_t port)=0;
+
+	/**
+	 * Send an RMAP command
+	 *
+	 * @param cookie the cookie used with this call
+	 * @param instruction the instruction byte that will be sent (this defines if it is a read or write command)
+	 * @param data data to be sent
+	 * @param datalen length of data
+	 * @return
+	 *      - @c RETURN_OK
+	 *      - @c COMMAND_NO_DESCRIPTORS_AVAILABLE 	no descriptors available for sending command; command was not sent
+	 *      - @c COMMAND_BUFFER_FULL				no receiver buffer available for expected len; command was not sent
+	 *      - @c COMMAND_TOO_BIG					the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command) command was not sent
+	 *      - @c COMMAND_CHANNEL_DEACTIVATED		the channel has no port set
+	 *      - @c NOT_SUPPORTED						if you dont feel like implementing something...
+	 */
+	virtual ReturnValue_t sendCommand(RMAPCookie *cookie, uint8_t instruction,
+			const uint8_t *data, size_t datalen)=0;
+
+	/**
+	 * get the reply to an rmap command
+	 *
+	 * @param cookie the cookie the command was sent with
+	 * @param databuffer a pointer to a pointer the location of the reply will be written to
+	 * @param len a pointer to the variable the length of the reply will be written to
+	 * @return
+	 *      - @c REPLY_NO_REPLY				no reply was received
+	 *      - @c REPLY_NOT_SENT				command was not sent, implies no reply
+	 *      - @c REPLY_NOT_YET_SENT			command is still waiting to be sent
+	 *      - @c WRITE_REPLY_INTERFACE_BUSY			Interface is busy (transmission buffer still being processed)
+	 *      - @c WRITE_REPLY_TRANSMISSION_ERROR		Interface encountered errors during last operation, data could not be processed. (transmission error)
+	 *      - @c WRITE_REPLY_INVALID_DATA			Invalid data (amount / value)
+	 *      - @c WRITE_REPLY_NOT_SUPPORTED
+	 *      - all RMAP standard replies
+	 */
+	virtual ReturnValue_t getReply(RMAPCookie *cookie, uint8_t **databuffer,
+			size_t *len)=0;
+
+	/**
+	 *
+	 * @param cookie
+	 * @param data
+	 * @param datalen
+	 * @param databuffer
+	 * @param len
+	 * @param timeout_us
+	 * @return
+	 *       - all replies of sendCommand() and getReply()
+	 *       - @c REPLY_TIMEOUT				timeout
+	 */
+	virtual ReturnValue_t sendCommandBlocking(RMAPCookie *cookie, uint8_t *data,
+			uint32_t datalen, uint8_t **databuffer, uint32_t *len,
+			uint32_t timeout_us)=0;
+
+};
+
+#endif /* RMAPCHANNELIF_H_ */
diff --git a/rmap/RMAPCookie.cpp b/rmap/RMAPCookie.cpp
index 223b5165d..74101ffa5 100644
--- a/rmap/RMAPCookie.cpp
+++ b/rmap/RMAPCookie.cpp
@@ -1,124 +1,124 @@
-#include <framework/rmap/RMAPChannelIF.h>
-#include <framework/rmap/RMAPCookie.h>
-#include <stddef.h>
-
-
-RMAPCookie::RMAPCookie() {
-	this->header.dest_address = 0;
-	this->header.protocol = 0x01;
-	this->header.instruction = 0;
-	this->header.dest_key = 0;
-	this->header.source_address = 0;
-	this->header.tid_h = 0;
-	this->header.tid_l = 0;
-	this->header.extended_address = 0;
-	this->header.address_hh = 0;
-	this->header.address_h = 0;
-	this->header.address_l = 0;
-	this->header.address_ll = 0;
-	this->header.datalen_h = 0;
-	this->header.datalen_m = 0;
-	this->header.datalen_l = 0;
-	this->header.header_crc = 0;
-	this->channel = NULL;
-	this->command_mask = 0;
-
-	this->dataCRC = 0;
-
-	this->maxReplyLen = 0;
-}
-
-
-
-RMAPCookie::RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-		RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen) {
-	this->header.dest_address = 0;
-	this->header.protocol = 0x01;
-	this->header.instruction = 0;
-	this->header.dest_key = 0;
-	this->header.source_address = 0;
-	this->header.tid_h = 0;
-	this->header.tid_l = 0;
-	this->header.extended_address = set_extended_address;
-	setAddress(set_address);
-	this->header.datalen_h = 0;
-	this->header.datalen_m = 0;
-	this->header.datalen_l = 0;
-	this->header.header_crc = 0;
-	this->channel = set_channel;
-	this->command_mask = set_command_mask;
-	this->dataCRC = 0;
-
-	this->maxReplyLen = maxReplyLen;
-}
-
-
-void RMAPCookie::setAddress(uint32_t address) {
-	this->header.address_hh = (address & 0xFF000000) >> 24;
-	this->header.address_h = (address & 0x00FF0000) >> 16;
-	this->header.address_l = (address & 0x0000FF00) >> 8;
-	this->header.address_ll = address & 0x000000FF;
-}
-
-void RMAPCookie::setExtendedAddress(uint8_t extendedAddress) {
-	this->header.extended_address = extendedAddress;
-}
-
-void RMAPCookie::setChannel(RMAPChannelIF *channel) {
-	this->channel = channel;
-}
-
-void RMAPCookie::setCommandMask(uint8_t commandMask) {
-	this->command_mask = commandMask;
-}
-
-uint32_t RMAPCookie::getAddress() {
-	return (header.address_hh << 24) + (header.address_h << 16)
-			+ (header.address_l << 8) + (header.address_ll);
-}
-
-uint8_t RMAPCookie::getExtendedAddress() {
-	return header.extended_address;
-}
-
-RMAPChannelIF *RMAPCookie::getChannel() {
-	return channel;
-}
-
-uint8_t RMAPCookie::getCommandMask() {
-	return command_mask;
-}
-
-RMAPCookie::~RMAPCookie() {
-
-}
-
-size_t RMAPCookie::getMaxReplyLen() const {
-	return maxReplyLen;
-}
-
-void RMAPCookie::setMaxReplyLen(size_t maxReplyLen) {
-	this->maxReplyLen = maxReplyLen;
-}
-
-RMAPStructs::rmap_cmd_header* RMAPCookie::getHeader(){
-	return &this->header;
-}
-
-uint16_t RMAPCookie::getTransactionIdentifier() const {
-	return static_cast<uint16_t>((header.tid_h << 8) | (header.tid_l));
-}
-
-void RMAPCookie::setTransactionIdentifier(uint16_t id_) {
-	header.tid_l  = id_ & 0xFF;
-	header.tid_h = (id_ >> 8 ) & 0xFF;
-}
-
-uint32_t RMAPCookie::getDataLength() const {
-	return static_cast<uint32_t>(header.datalen_h << 16 | header.datalen_m << 8 | header.datalen_l);
-}
-void RMAPCookie::setDataLength(uint32_t length_) {
-	header.datalen_l = length_ & 0xff;
-	header.datalen_m = (length_ >> 8) & 0xff;
-	header.datalen_h = (length_ >> 16) & 0xff;
-}
+#include "../rmap/RMAPChannelIF.h"
+#include "../rmap/RMAPCookie.h"
+#include <stddef.h>
+
+
+RMAPCookie::RMAPCookie() {
+	this->header.dest_address = 0;
+	this->header.protocol = 0x01;
+	this->header.instruction = 0;
+	this->header.dest_key = 0;
+	this->header.source_address = 0;
+	this->header.tid_h = 0;
+	this->header.tid_l = 0;
+	this->header.extended_address = 0;
+	this->header.address_hh = 0;
+	this->header.address_h = 0;
+	this->header.address_l = 0;
+	this->header.address_ll = 0;
+	this->header.datalen_h = 0;
+	this->header.datalen_m = 0;
+	this->header.datalen_l = 0;
+	this->header.header_crc = 0;
+	this->channel = NULL;
+	this->command_mask = 0;
+
+	this->dataCRC = 0;
+
+	this->maxReplyLen = 0;
+}
+
+
+
+RMAPCookie::RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
+		RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen) {
+	this->header.dest_address = 0;
+	this->header.protocol = 0x01;
+	this->header.instruction = 0;
+	this->header.dest_key = 0;
+	this->header.source_address = 0;
+	this->header.tid_h = 0;
+	this->header.tid_l = 0;
+	this->header.extended_address = set_extended_address;
+	setAddress(set_address);
+	this->header.datalen_h = 0;
+	this->header.datalen_m = 0;
+	this->header.datalen_l = 0;
+	this->header.header_crc = 0;
+	this->channel = set_channel;
+	this->command_mask = set_command_mask;
+	this->dataCRC = 0;
+
+	this->maxReplyLen = maxReplyLen;
+}
+
+
+void RMAPCookie::setAddress(uint32_t address) {
+	this->header.address_hh = (address & 0xFF000000) >> 24;
+	this->header.address_h = (address & 0x00FF0000) >> 16;
+	this->header.address_l = (address & 0x0000FF00) >> 8;
+	this->header.address_ll = address & 0x000000FF;
+}
+
+void RMAPCookie::setExtendedAddress(uint8_t extendedAddress) {
+	this->header.extended_address = extendedAddress;
+}
+
+void RMAPCookie::setChannel(RMAPChannelIF *channel) {
+	this->channel = channel;
+}
+
+void RMAPCookie::setCommandMask(uint8_t commandMask) {
+	this->command_mask = commandMask;
+}
+
+uint32_t RMAPCookie::getAddress() {
+	return (header.address_hh << 24) + (header.address_h << 16)
+			+ (header.address_l << 8) + (header.address_ll);
+}
+
+uint8_t RMAPCookie::getExtendedAddress() {
+	return header.extended_address;
+}
+
+RMAPChannelIF *RMAPCookie::getChannel() {
+	return channel;
+}
+
+uint8_t RMAPCookie::getCommandMask() {
+	return command_mask;
+}
+
+RMAPCookie::~RMAPCookie() {
+
+}
+
+size_t RMAPCookie::getMaxReplyLen() const {
+	return maxReplyLen;
+}
+
+void RMAPCookie::setMaxReplyLen(size_t maxReplyLen) {
+	this->maxReplyLen = maxReplyLen;
+}
+
+RMAPStructs::rmap_cmd_header* RMAPCookie::getHeader(){
+	return &this->header;
+}
+
+uint16_t RMAPCookie::getTransactionIdentifier() const {
+	return static_cast<uint16_t>((header.tid_h << 8) | (header.tid_l));
+}
+
+void RMAPCookie::setTransactionIdentifier(uint16_t id_) {
+	header.tid_l  = id_ & 0xFF;
+	header.tid_h = (id_ >> 8 ) & 0xFF;
+}
+
+uint32_t RMAPCookie::getDataLength() const {
+	return static_cast<uint32_t>(header.datalen_h << 16 | header.datalen_m << 8 | header.datalen_l);
+}
+void RMAPCookie::setDataLength(uint32_t length_) {
+	header.datalen_l = length_ & 0xff;
+	header.datalen_m = (length_ >> 8) & 0xff;
+	header.datalen_h = (length_ >> 16) & 0xff;
+}
diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h
index 99ebd6a20..0da03e308 100644
--- a/rmap/RMAPCookie.h
+++ b/rmap/RMAPCookie.h
@@ -1,59 +1,59 @@
-#ifndef RMAPCOOKIE_H_
-#define RMAPCOOKIE_H_
-
-#include <framework/devicehandlers/CookieIF.h>
-#include <framework/rmap/rmapStructs.h>
-#include <cstddef>
-
-class RMAPChannelIF;
-
-class RMAPCookie : public CookieIF {
-public:
-	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
-	RMAPCookie();
-
-	RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-			RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen = 0);
-	virtual ~RMAPCookie();
-
-
-	void setAddress(uint32_t address);
-	uint32_t getAddress();
-
-	void setExtendedAddress(uint8_t);
-	uint8_t getExtendedAddress();
-
-	void setChannel(RMAPChannelIF *channel);
-	RMAPChannelIF *getChannel();
-
-	void setCommandMask(uint8_t commandMask);
-	uint8_t getCommandMask();
-
-	size_t getMaxReplyLen() const;
-	void setMaxReplyLen(size_t maxReplyLen);
-
-	uint16_t getTransactionIdentifier() const;
-	void setTransactionIdentifier(uint16_t id_);
-
-	RMAPStructs::rmap_cmd_header* getHeader();
-
-	uint32_t getDataLength() const;
-	void setDataLength(uint32_t lenght_);
-
-	uint8_t getDataCrc() const {
-		return dataCRC;
-	}
-
-	void setDataCrc(uint8_t dataCrc) {
-		dataCRC = dataCrc;
-	}
-
-protected:
-	RMAPStructs::rmap_cmd_header header;
-	RMAPChannelIF *channel;
-	uint8_t command_mask;
-	uint32_t maxReplyLen;
-	uint8_t dataCRC;
-};
-
-#endif /* RMAPCOOKIE_H_ */
+#ifndef RMAPCOOKIE_H_
+#define RMAPCOOKIE_H_
+
+#include "../devicehandlers/CookieIF.h"
+#include "../rmap/rmapStructs.h"
+#include <cstddef>
+
+class RMAPChannelIF;
+
+class RMAPCookie : public CookieIF {
+public:
+	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
+	RMAPCookie();
+
+	RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
+			RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen = 0);
+	virtual ~RMAPCookie();
+
+
+	void setAddress(uint32_t address);
+	uint32_t getAddress();
+
+	void setExtendedAddress(uint8_t);
+	uint8_t getExtendedAddress();
+
+	void setChannel(RMAPChannelIF *channel);
+	RMAPChannelIF *getChannel();
+
+	void setCommandMask(uint8_t commandMask);
+	uint8_t getCommandMask();
+
+	size_t getMaxReplyLen() const;
+	void setMaxReplyLen(size_t maxReplyLen);
+
+	uint16_t getTransactionIdentifier() const;
+	void setTransactionIdentifier(uint16_t id_);
+
+	RMAPStructs::rmap_cmd_header* getHeader();
+
+	uint32_t getDataLength() const;
+	void setDataLength(uint32_t lenght_);
+
+	uint8_t getDataCrc() const {
+		return dataCRC;
+	}
+
+	void setDataCrc(uint8_t dataCrc) {
+		dataCRC = dataCrc;
+	}
+
+protected:
+	RMAPStructs::rmap_cmd_header header;
+	RMAPChannelIF *channel;
+	uint8_t command_mask;
+	uint32_t maxReplyLen;
+	uint8_t dataCRC;
+};
+
+#endif /* RMAPCOOKIE_H_ */
diff --git a/rmap/RmapDeviceCommunicationIF.cpp b/rmap/RmapDeviceCommunicationIF.cpp
index 6dc91339f..36247ce6f 100644
--- a/rmap/RmapDeviceCommunicationIF.cpp
+++ b/rmap/RmapDeviceCommunicationIF.cpp
@@ -1,47 +1,47 @@
-#include <framework/rmap/RmapDeviceCommunicationIF.h>
-#include <framework/rmap/RMAP.h>
-
-//TODO Cast here are all potential bugs
-RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF *cookie,
-		const uint8_t * sendData, size_t sendLen) {
-	return RMAP::sendWriteCommand((RMAPCookie *) cookie, sendData, sendLen);
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
-	return RMAP::getWriteReply((RMAPCookie *) cookie);
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::requestReceiveMessage(
-		CookieIF *cookie, size_t requestLen) {
-	return RMAP::sendReadCommand((RMAPCookie *) cookie,
-				((RMAPCookie *) cookie)->getMaxReplyLen());
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
-		uint8_t** buffer, size_t * size) {
-	return RMAP::getReadReply((RMAPCookie *) cookie, buffer, size);
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::setAddress(CookieIF* cookie,
-		uint32_t address) {
-
-	((RMAPCookie *) cookie)->setAddress(address);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t RmapDeviceCommunicationIF::getAddress(CookieIF* cookie) {
-	return ((RMAPCookie *) cookie)->getAddress();
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::setParameter(CookieIF* cookie,
-		uint32_t parameter) {
-	//TODO Empty?
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t RmapDeviceCommunicationIF::getParameter(CookieIF* cookie) {
-	return 0;
-}
+#include "../rmap/RmapDeviceCommunicationIF.h"
+#include "../rmap/RMAP.h"
+
+//TODO Cast here are all potential bugs
+RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF *cookie,
+		const uint8_t * sendData, size_t sendLen) {
+	return RMAP::sendWriteCommand((RMAPCookie *) cookie, sendData, sendLen);
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
+	return RMAP::getWriteReply((RMAPCookie *) cookie);
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::requestReceiveMessage(
+		CookieIF *cookie, size_t requestLen) {
+	return RMAP::sendReadCommand((RMAPCookie *) cookie,
+				((RMAPCookie *) cookie)->getMaxReplyLen());
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
+		uint8_t** buffer, size_t * size) {
+	return RMAP::getReadReply((RMAPCookie *) cookie, buffer, size);
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::setAddress(CookieIF* cookie,
+		uint32_t address) {
+
+	((RMAPCookie *) cookie)->setAddress(address);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t RmapDeviceCommunicationIF::getAddress(CookieIF* cookie) {
+	return ((RMAPCookie *) cookie)->getAddress();
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::setParameter(CookieIF* cookie,
+		uint32_t parameter) {
+	//TODO Empty?
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t RmapDeviceCommunicationIF::getParameter(CookieIF* cookie) {
+	return 0;
+}
diff --git a/rmap/RmapDeviceCommunicationIF.h b/rmap/RmapDeviceCommunicationIF.h
index 12bac57ae..b05641935 100644
--- a/rmap/RmapDeviceCommunicationIF.h
+++ b/rmap/RmapDeviceCommunicationIF.h
@@ -1,89 +1,89 @@
-#ifndef MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
-#define MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
-
-#include <framework/devicehandlers/DeviceCommunicationIF.h>
-
-/**
- * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls.
- *          It expects RMAPCookies or a derived class of RMAPCookies
- *
- * @details	The open, close and reOpen calls are mission specific
- * 			The open call might return any child of RMAPCookies
- *
- * \ingroup rmap
- */
-class RmapDeviceCommunicationIF: public DeviceCommunicationIF {
-
-public:
-	virtual ~RmapDeviceCommunicationIF();
-
-	/**
-	 * @brief Device specific initialization, using the cookie.
-	 * @details
-	 * The cookie is already prepared in the factory. If the communication
-	 * interface needs to be set up in some way and requires cookie information,
-	 * this can be performed in this function, which is called on device handler
-	 * initialization.
-	 * @param cookie
-	 * @return -@c RETURN_OK if initialization was successfull
-	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendWrite().
-	 * This function is used to send data to the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param data
-	 * @param len
-	 * @return -@c RETURN_OK for successfull send
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
-			size_t sendLen);
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetWrite().
-	 * Get send confirmation that the data in sendMessage() was sent successfully.
-	 * @param cookie
-	 * @return -@c RETURN_OK if data was sent successfull
-	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * It is assumed that it is always possible to request a reply
-	 * from a device.
-	 *
-	 * @param cookie
-	 * @return -@c RETURN_OK to confirm the request for data has been sent.
-	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
-	 *         	   will not be called in the respective communication cycle.
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen);
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetRead().
-	 * This function is used to receive data from the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param data
-	 * @param len
-	 * @return @c RETURN_OK for successfull receive
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
-			size_t *size);
-
-	ReturnValue_t setAddress(CookieIF* cookie,
-			uint32_t address);
-	uint32_t getAddress(CookieIF* cookie);
-	ReturnValue_t setParameter(CookieIF* cookie,
-			uint32_t parameter);
-	uint32_t getParameter(CookieIF* cookie);
-};
-
-#endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
+#ifndef MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+#define MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+
+#include "../devicehandlers/DeviceCommunicationIF.h"
+
+/**
+ * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls.
+ *          It expects RMAPCookies or a derived class of RMAPCookies
+ *
+ * @details	The open, close and reOpen calls are mission specific
+ * 			The open call might return any child of RMAPCookies
+ *
+ * \ingroup rmap
+ */
+class RmapDeviceCommunicationIF: public DeviceCommunicationIF {
+
+public:
+	virtual ~RmapDeviceCommunicationIF();
+
+	/**
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return -@c RETURN_OK if initialization was successfull
+	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return -@c RETURN_OK for successfull send
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
+			size_t sendLen);
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return -@c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device.
+	 *
+	 * @param cookie
+	 * @return -@c RETURN_OK to confirm the request for data has been sent.
+	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
+	 *         	   will not be called in the respective communication cycle.
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen);
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return @c RETURN_OK for successfull receive
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+			size_t *size);
+
+	ReturnValue_t setAddress(CookieIF* cookie,
+			uint32_t address);
+	uint32_t getAddress(CookieIF* cookie);
+	ReturnValue_t setParameter(CookieIF* cookie,
+			uint32_t parameter);
+	uint32_t getParameter(CookieIF* cookie);
+};
+
+#endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index 81117a5e7..fae10bcaf 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -1,124 +1,124 @@
-#ifndef ENDIANSWAPPER_H_
-#define ENDIANSWAPPER_H_
-
-#include <framework/osal/Endiness.h>
-#include <cstring>
-#include <iostream>
-
-/**
- * Helper class to convert variables or bitstreams between machine
- * endian and either big or little endian.
- * Machine endian is the endianness used by the machine running the
- * program and is one of big or little endian. As this is portable
- * code, it is not known at coding time which it is. At compile time
- * it is however, which is why this is implemented using compiler
- * macros and translates to a copy operation at runtime.
- *
- * This changes the layout of multi-byte variables in the machine's
- * memory. In most cases, you should not need to use this class.
- * Probably what you are looking for is the SerializeAdapter.
- * If you still decide you need this class, please read and understand
- * the code first.
- *
- * The order of the individual bytes of the multi-byte variable is
- * reversed, the byte at the highest address is moved to the lowest
- * address and vice versa, same for the bytes in between.
- *
- * Note that the conversion is also its inversion, that is converting
- * from machine to a specified endianness is the same operation as
- * converting from specified to machine (I looked it up, mathematicians
- * would call it an involution):
- *
- * X == convertBigEndian(convertBigEndian(X))
- *
- * Thus, there is only one function supplied to do the conversion.
- */
-class EndianConverter {
-private:
-	EndianConverter() {};
-public:
-	/**
-	 * Convert a typed variable between big endian and machine endian.
-	 * Intended for plain old datatypes.
-	 */
-	template<typename T>
-	static T convertBigEndian(T in) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		T tmp;
-		uint8_t *pointerOut = (uint8_t*) &tmp;
-		uint8_t *pointerIn = (uint8_t*) &in;
-		for (size_t count = 0; count < sizeof(T); count++) {
-			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
-		}
-		return tmp;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		return in;
-#else
-#error Unknown Byte Order
-#endif
-	}
-
-	/**
-	 * convert a bytestream representing a single variable between big endian
-	 * and machine endian.
-	 */
-	static void convertBigEndian(uint8_t *out, const uint8_t *in,
-			size_t size) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		for (size_t count = 0; count < size; count++) {
-			out[size - count - 1] = in[count];
-		}
-		return;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		memcpy(out, in, size);
-		return;
-#endif
-	}
-
-	/**
-	 * Convert a typed variable between little endian and machine endian.
-	 * Intended for plain old datatypes.
-	 */
-	template<typename T>
-	static T convertLittleEndian(T in) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			T tmp;
-			uint8_t *pointerOut = (uint8_t *) &tmp;
-			uint8_t *pointerIn = (uint8_t *) &in;
-			for (size_t count = 0; count < sizeof(T); count++) {
-				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
-			}
-			return tmp;
-	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		return in;
-#else
-	#error Unknown Byte Order
-	#endif
-	}
-	/**
-	 * convert a bytestream representing a single variable between little endian
-	 * and machine endian.
-	 */
-	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
-			size_t size) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			for (size_t count = 0; count < size; count++) {
-				out[size - count - 1] = in[count];
-			}
-			return;
-	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		memcpy(out, in, size);
-		return;
-#endif
-	}
-};
-
-#endif /* ENDIANSWAPPER_H_ */
+#ifndef ENDIANSWAPPER_H_
+#define ENDIANSWAPPER_H_
+
+#include "../osal/Endiness.h"
+#include <cstring>
+#include <iostream>
+
+/**
+ * Helper class to convert variables or bitstreams between machine
+ * endian and either big or little endian.
+ * Machine endian is the endianness used by the machine running the
+ * program and is one of big or little endian. As this is portable
+ * code, it is not known at coding time which it is. At compile time
+ * it is however, which is why this is implemented using compiler
+ * macros and translates to a copy operation at runtime.
+ *
+ * This changes the layout of multi-byte variables in the machine's
+ * memory. In most cases, you should not need to use this class.
+ * Probably what you are looking for is the SerializeAdapter.
+ * If you still decide you need this class, please read and understand
+ * the code first.
+ *
+ * The order of the individual bytes of the multi-byte variable is
+ * reversed, the byte at the highest address is moved to the lowest
+ * address and vice versa, same for the bytes in between.
+ *
+ * Note that the conversion is also its inversion, that is converting
+ * from machine to a specified endianness is the same operation as
+ * converting from specified to machine (I looked it up, mathematicians
+ * would call it an involution):
+ *
+ * X == convertBigEndian(convertBigEndian(X))
+ *
+ * Thus, there is only one function supplied to do the conversion.
+ */
+class EndianConverter {
+private:
+	EndianConverter() {};
+public:
+	/**
+	 * Convert a typed variable between big endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertBigEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		T tmp;
+		uint8_t *pointerOut = (uint8_t*) &tmp;
+		uint8_t *pointerIn = (uint8_t*) &in;
+		for (size_t count = 0; count < sizeof(T); count++) {
+			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+		}
+		return tmp;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		return in;
+#else
+#error Unknown Byte Order
+#endif
+	}
+
+	/**
+	 * convert a bytestream representing a single variable between big endian
+	 * and machine endian.
+	 */
+	static void convertBigEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		for (size_t count = 0; count < size; count++) {
+			out[size - count - 1] = in[count];
+		}
+		return;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+
+	/**
+	 * Convert a typed variable between little endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertLittleEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			T tmp;
+			uint8_t *pointerOut = (uint8_t *) &tmp;
+			uint8_t *pointerIn = (uint8_t *) &in;
+			for (size_t count = 0; count < sizeof(T); count++) {
+				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+			}
+			return tmp;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		return in;
+#else
+	#error Unknown Byte Order
+	#endif
+	}
+	/**
+	 * convert a bytestream representing a single variable between little endian
+	 * and machine endian.
+	 */
+	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			for (size_t count = 0; count < size; count++) {
+				out[size - count - 1] = in[count];
+			}
+			return;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+};
+
+#endif /* ENDIANSWAPPER_H_ */
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 17a4558f0..19190abd6 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -1,91 +1,91 @@
-/**
- * @file	SerialArrayListAdapter.h
- * @brief	This file defines the SerialArrayListAdapter class.
- * @date	22.07.2014
- * @author	baetz
- */
-#ifndef SERIALARRAYLISTADAPTER_H_
-#define SERIALARRAYLISTADAPTER_H_
-
-#include <framework/container/ArrayList.h>
-#include <framework/serialize/SerializeIF.h>
-#include <utility>
-
-/**
- * Also serializes length field !
- * @ingroup serialize
- */
-template<typename T, typename count_t = uint8_t>
-class SerialArrayListAdapter : public SerializeIF {
-public:
-	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
-	}
-
-	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, 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);
-			++i;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const {
-		return getSerializedSize(adaptee);
-	}
-
-	static uint32_t getSerializedSize(const ArrayList<T, count_t>* list) {
-		uint32_t printSize = sizeof(count_t);
-		count_t i = 0;
-
-		for (i = 0; i < list->size; ++i) {
-			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
-		}
-
-		return printSize;
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return deSerialize(adaptee, buffer, size, streamEndianness);
-	}
-
-	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		count_t tempSize = 0;
-		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
-				buffer, size, streamEndianness);
-		if (tempSize > list->maxSize()) {
-			return SerializeIF::TOO_MANY_ELEMENTS;
-		}
-		list->size = tempSize;
-		count_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter::deSerialize(
-					&list->front()[i], buffer, size,
-					streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-
-	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
-		list->swapArrayListEndianness();
-	}
-private:
-	ArrayList<T, count_t> *adaptee;
-};
-
-
-
-#endif /* SERIALARRAYLISTADAPTER_H_ */
+/**
+ * @file	SerialArrayListAdapter.h
+ * @brief	This file defines the SerialArrayListAdapter class.
+ * @date	22.07.2014
+ * @author	baetz
+ */
+#ifndef SERIALARRAYLISTADAPTER_H_
+#define SERIALARRAYLISTADAPTER_H_
+
+#include "../container/ArrayList.h"
+#include "../serialize/SerializeIF.h"
+#include <utility>
+
+/**
+ * Also serializes length field !
+ * @ingroup serialize
+ */
+template<typename T, typename count_t = uint8_t>
+class SerialArrayListAdapter : public SerializeIF {
+public:
+	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
+	}
+
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, 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);
+			++i;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const {
+		return getSerializedSize(adaptee);
+	}
+
+	static uint32_t getSerializedSize(const ArrayList<T, count_t>* list) {
+		uint32_t printSize = sizeof(count_t);
+		count_t i = 0;
+
+		for (i = 0; i < list->size; ++i) {
+			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
+		}
+
+		return printSize;
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return deSerialize(adaptee, buffer, size, streamEndianness);
+	}
+
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		count_t tempSize = 0;
+		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
+				buffer, size, streamEndianness);
+		if (tempSize > list->maxSize()) {
+			return SerializeIF::TOO_MANY_ELEMENTS;
+		}
+		list->size = tempSize;
+		count_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
+			result = SerializeAdapter::deSerialize(
+					&list->front()[i], buffer, size,
+					streamEndianness);
+			++i;
+		}
+		return result;
+	}
+
+
+	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
+		list->swapArrayListEndianness();
+	}
+private:
+	ArrayList<T, count_t> *adaptee;
+};
+
+
+
+#endif /* SERIALARRAYLISTADAPTER_H_ */
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 1224bba1b..b1e0856aa 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,128 +1,128 @@
-#include <framework/serialize/SerialBufferAdapter.h>
-#include <framework/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 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 (constBuffer != nullptr) {
-			memcpy(*buffer, this->constBuffer, bufferLength);
-		}
-		else if (buffer != nullptr) {
-			// This will propably be never reached, constBuffer should always be
-			// set if non-const buffer is set.
-			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(bufferLength + serializedSize <= *size) {
-				*buffer +=  serializedSize;
-				*size -= serializedSize;
-			}
-			else {
-				return STREAM_TOO_SHORT;
-			}
-		}
-		//No Else If, go on with buffer
-		if (bufferLength <= *size) {
-			*size -= bufferLength;
-			memcpy(this->buffer, *buffer, bufferLength);
-			(*buffer) += bufferLength;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-		else {
-			return STREAM_TOO_SHORT;
-		}
-	}
-	else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-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: 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>;
-
+#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 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 (constBuffer != nullptr) {
+			memcpy(*buffer, this->constBuffer, bufferLength);
+		}
+		else if (buffer != nullptr) {
+			// This will propably be never reached, constBuffer should always be
+			// set if non-const buffer is set.
+			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(bufferLength + serializedSize <= *size) {
+				*buffer +=  serializedSize;
+				*size -= serializedSize;
+			}
+			else {
+				return STREAM_TOO_SHORT;
+			}
+		}
+		//No Else If, go on with buffer
+		if (bufferLength <= *size) {
+			*size -= bufferLength;
+			memcpy(this->buffer, *buffer, bufferLength);
+			(*buffer) += bufferLength;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+		else {
+			return STREAM_TOO_SHORT;
+		}
+	}
+	else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+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: 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>;
+
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 2c47e0f19..c3dfcd8fb 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -1,78 +1,78 @@
-#ifndef SERIALBUFFERADAPTER_H_
-#define SERIALBUFFERADAPTER_H_
-
-#include <framework/serialize/SerializeIF.h>
-#include <framework/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_ */
+#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_ */
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 196af67c9..7968b4204 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -1,63 +1,63 @@
-#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
-#define SERIALFIXEDARRAYLISTADAPTER_H_
-
-#include <framework/container/FixedArrayList.h>
-#include <framework/serialize/SerialArrayListAdapter.h>
-
-/**
- * @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.
- *
- *  - Buffers with a size header inside that class can be declared with
- *    @code
- *    SerialFixedArrayListAdapter<BUFFER_TYPE,
- *          MAX_SIZE, count_t> mySerialFixedArrayList(...).
- *    @endcode
- *
- *  - MAX_SIZE: specifies the maximum allowed number of elements
- *    in FixedArrayList.
- *  - BUFFER_TYPE: specifies the data type of the buffer
- *  - count_t: specifies the type/size of the length field
- *    which defaults to one byte.
- *
- * @ingroup serialize
- */
-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<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_ */
+#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
+#define SERIALFIXEDARRAYLISTADAPTER_H_
+
+#include "../container/FixedArrayList.h"
+#include "../serialize/SerialArrayListAdapter.h"
+
+/**
+ * @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.
+ *
+ *  - Buffers with a size header inside that class can be declared with
+ *    @code
+ *    SerialFixedArrayListAdapter<BUFFER_TYPE,
+ *          MAX_SIZE, count_t> mySerialFixedArrayList(...).
+ *    @endcode
+ *
+ *  - MAX_SIZE: specifies the maximum allowed number of elements
+ *    in FixedArrayList.
+ *  - BUFFER_TYPE: specifies the data type of the buffer
+ *  - count_t: specifies the type/size of the length field
+ *    which defaults to one byte.
+ *
+ * @ingroup serialize
+ */
+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<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_ */
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index c822bd1b3..a46520285 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -1,133 +1,133 @@
-/**
- * @file	SerialLinkedListAdapter.h
- * @brief	This file defines the SerialLinkedListAdapter class.
- * @date	22.07.2014
- * @author	baetz
- */
-#ifndef SERIALLINKEDLISTADAPTER_H_
-#define SERIALLINKEDLISTADAPTER_H_
-
-#include <framework/container/SinglyLinkedList.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerializeIF.h>
-//This is where we need the SerializeAdapter!
-
- /**
- * @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 with a known size
- *   - 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.
- *
- * @ingroup serialize
- */
-template<typename T, typename count_t = uint8_t>
-class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
-public:
-	/**
-	 * 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;
-
-	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) {
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override {
-		if (printCount) {
-			count_t mySize = SinglyLinkedList<T>::getSize();
-			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
-					buffer, size, maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	static ReturnValue_t serialize(const LinkedElement<T>* element,
-			uint8_t** buffer, size_t* size, size_t maxSize,
-			Endianness streamEndianness) {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			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()
-					+ sizeof(count_t);
-		} else {
-			return getSerializedSize(SinglyLinkedList<T>::start);
-		}
-	}
-
-	static size_t getSerializedSize(const LinkedElement<T> *element) {
-		size_t size = 0;
-		while (element != NULL) {
-			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);
-	}
-
-	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)) {
-			result = element->value->deSerialize(buffer, size, streamEndianness);
-			element = element->getNext();
-		}
-		return result;
-	}
-
-	bool printCount;
-};
-
-#endif /* SERIALLINKEDLISTADAPTER_H_ */
+/**
+ * @file	SerialLinkedListAdapter.h
+ * @brief	This file defines the SerialLinkedListAdapter class.
+ * @date	22.07.2014
+ * @author	baetz
+ */
+#ifndef SERIALLINKEDLISTADAPTER_H_
+#define SERIALLINKEDLISTADAPTER_H_
+
+#include "../container/SinglyLinkedList.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerializeIF.h"
+//This is where we need the SerializeAdapter!
+
+ /**
+ * @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 with a known size
+ *   - 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.
+ *
+ * @ingroup serialize
+ */
+template<typename T, typename count_t = uint8_t>
+class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
+public:
+	/**
+	 * 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;
+
+	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) {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		if (printCount) {
+			count_t mySize = SinglyLinkedList<T>::getSize();
+			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
+					buffer, size, maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	static ReturnValue_t serialize(const LinkedElement<T>* element,
+			uint8_t** buffer, size_t* size, size_t maxSize,
+			Endianness streamEndianness) {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
+			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()
+					+ sizeof(count_t);
+		} else {
+			return getSerializedSize(SinglyLinkedList<T>::start);
+		}
+	}
+
+	static size_t getSerializedSize(const LinkedElement<T> *element) {
+		size_t size = 0;
+		while (element != NULL) {
+			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);
+	}
+
+	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)) {
+			result = element->value->deSerialize(buffer, size, streamEndianness);
+			element = element->getNext();
+		}
+		return result;
+	}
+
+	bool printCount;
+};
+
+#endif /* SERIALLINKEDLISTADAPTER_H_ */
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 4534ffb80..bcddb71a0 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -1,175 +1,175 @@
-#ifndef SERIALIZEADAPTER_H_
-#define SERIALIZEADAPTER_H_
-
-#include <framework/container/IsDerivedFrom.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/EndianConverter.h>
-#include <framework/serialize/SerializeIF.h>
-#include <type_traits>
-
- /**
- * @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
- *
- * A report class is converted into a TM buffer. The report class implements a
- * serialize functions and calls the AutoSerializeAdapter::serialize function
- * repeatedly on all object data fields. The getSerializedSize function is
- * implemented by calling the AutoSerializeAdapter::getSerializedSize function
- * repeatedly on all data fields.
- *
- * The AutoSerializeAdapter functions can also be used as an alternative to
- * memcpy to retrieve data out of a buffer directly into a class variable
- * with data type T while being able to specify endianness. The boolean
- * bigEndian specifies whether an endian swap is performed on the data before
- * serialization or deserialization.
- *
- * There are three ways to retrieve data out of a buffer to be used in the FSFW
- * to use regular aligned (big endian) data. Examples:
- *
- *   1. Use the AutoSerializeAdapter::deSerialize function
- *		The pointer *buffer will be incremented automatically by the typeSize
- *		 of the object, so this function can be called on &buffer repeatedly
- *		without adjusting pointer position. Set bigEndian parameter to true
- *		to perform endian swapping, if necessary
- *		@code
- *   	uint16_t data;
- *   	int32_t dataLen = sizeof(data);
- *   	ReturnValue_t result =
- *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
- *   	@endcode
- *
- *   2. Perform a bitshift operation. Watch for for endianness:
- *		@code
- *   	uint16_t data;
- *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
- *   	data = EndianSwapper::swap(data); //optional, or swap order above
- *   	@endcode
- *
- *   3. memcpy or std::copy can also be used, but watch out if system
- *   	endianness is different from required data endianness.
- *   	Perform endian-swapping if necessary.
- *		@code
- *   	uint16_t data;
- *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
- *   	data = EndianSwapper::swap(data); //optional
- *   	@endcode
- *
- * When serializing for downlink, the packets are generally serialized assuming
- * big endian data format like seen in TmPacketStored.cpp for example.
- *
- * @ingroup serialize
- */
-
-class SerializeAdapter {
-public:
-	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;
-		return adapter.serialize(object, buffer, size, maxSize,
-				streamEndianness);
-	}
-	template<typename T>
-	static uint32_t getSerializedSize(const T *object) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.getSerializedSize(object);
-	}
-	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;
-		return adapter.deSerialize(object, buffer, size, streamEndianness);
-	}
-private:
-	template<typename T, int>
-	class InternalSerializeAdapter {
-	public:
-		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
-				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
-			size_t ignoredSize = 0;
-			if (size == NULL) {
-				size = &ignoredSize;
-			}
-			//TODO check integer overflow of *size
-			if (sizeof(T) + *size <= max_size) {
-				T tmp;
-				switch (streamEndianness) {
-				case SerializeIF::Endianness::BIG:
-					tmp = EndianConverter::convertBigEndian<T>(*object);
-					break;
-				case SerializeIF::Endianness::LITTLE:
-					tmp = EndianConverter::convertLittleEndian<T>(*object);
-					break;
-				default:
-				case SerializeIF::Endianness::MACHINE:
-					tmp = *object;
-					break;
-				}
-				memcpy(*buffer, &tmp, sizeof(T));
-				*size += sizeof(T);
-				(*buffer) += sizeof(T);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				return SerializeIF::BUFFER_TOO_SHORT;
-			}
-		}
-
-		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-				size_t *size, SerializeIF::Endianness streamEndianness) {
-			T tmp;
-			if (*size >= sizeof(T)) {
-				*size -= sizeof(T);
-				memcpy(&tmp, *buffer, sizeof(T));
-				switch (streamEndianness) {
-				case SerializeIF::Endianness::BIG:
-					*object = EndianConverter::convertBigEndian<T>(tmp);
-					break;
-				case SerializeIF::Endianness::LITTLE:
-					*object = EndianConverter::convertLittleEndian<T>(tmp);
-					break;
-				default:
-				case SerializeIF::Endianness::MACHINE:
-					*object = tmp;
-					break;
-				}
-
-				*buffer += sizeof(T);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				return SerializeIF::STREAM_TOO_SHORT;
-			}
-		}
-
-		uint32_t getSerializedSize(const T *object) {
-			return sizeof(T);
-		}
-
-	};
-
-	template<typename T>
-	class InternalSerializeAdapter<T, 1> {
-	public:
-		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) {
-				size = &ignoredSize;
-			}
-			return object->serialize(buffer, size, max_size, streamEndianness);
-		}
-		uint32_t getSerializedSize(const T *object) const {
-			return object->getSerializedSize();
-		}
-
-		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-				size_t *size, SerializeIF::Endianness streamEndianness) {
-			return object->deSerialize(buffer, size, streamEndianness);
-		}
-	};
-};
-
-#endif /* SERIALIZEADAPTER_H_ */
+#ifndef SERIALIZEADAPTER_H_
+#define SERIALIZEADAPTER_H_
+
+#include "../container/IsDerivedFrom.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/EndianConverter.h"
+#include "../serialize/SerializeIF.h"
+#include <type_traits>
+
+ /**
+ * @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
+ *
+ * A report class is converted into a TM buffer. The report class implements a
+ * serialize functions and calls the AutoSerializeAdapter::serialize function
+ * repeatedly on all object data fields. The getSerializedSize function is
+ * implemented by calling the AutoSerializeAdapter::getSerializedSize function
+ * repeatedly on all data fields.
+ *
+ * The AutoSerializeAdapter functions can also be used as an alternative to
+ * memcpy to retrieve data out of a buffer directly into a class variable
+ * with data type T while being able to specify endianness. The boolean
+ * bigEndian specifies whether an endian swap is performed on the data before
+ * serialization or deserialization.
+ *
+ * There are three ways to retrieve data out of a buffer to be used in the FSFW
+ * to use regular aligned (big endian) data. Examples:
+ *
+ *   1. Use the AutoSerializeAdapter::deSerialize function
+ *		The pointer *buffer will be incremented automatically by the typeSize
+ *		 of the object, so this function can be called on &buffer repeatedly
+ *		without adjusting pointer position. Set bigEndian parameter to true
+ *		to perform endian swapping, if necessary
+ *		@code
+ *   	uint16_t data;
+ *   	int32_t dataLen = sizeof(data);
+ *   	ReturnValue_t result =
+ *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
+ *   	@endcode
+ *
+ *   2. Perform a bitshift operation. Watch for for endianness:
+ *		@code
+ *   	uint16_t data;
+ *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
+ *   	data = EndianSwapper::swap(data); //optional, or swap order above
+ *   	@endcode
+ *
+ *   3. memcpy or std::copy can also be used, but watch out if system
+ *   	endianness is different from required data endianness.
+ *   	Perform endian-swapping if necessary.
+ *		@code
+ *   	uint16_t data;
+ *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
+ *   	data = EndianSwapper::swap(data); //optional
+ *   	@endcode
+ *
+ * When serializing for downlink, the packets are generally serialized assuming
+ * big endian data format like seen in TmPacketStored.cpp for example.
+ *
+ * @ingroup serialize
+ */
+
+class SerializeAdapter {
+public:
+	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;
+		return adapter.serialize(object, buffer, size, maxSize,
+				streamEndianness);
+	}
+	template<typename T>
+	static uint32_t getSerializedSize(const T *object) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.getSerializedSize(object);
+	}
+	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;
+		return adapter.deSerialize(object, buffer, size, streamEndianness);
+	}
+private:
+	template<typename T, int>
+	class InternalSerializeAdapter {
+	public:
+		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
+			size_t ignoredSize = 0;
+			if (size == NULL) {
+				size = &ignoredSize;
+			}
+			//TODO check integer overflow of *size
+			if (sizeof(T) + *size <= max_size) {
+				T tmp;
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					tmp = EndianConverter::convertBigEndian<T>(*object);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					tmp = EndianConverter::convertLittleEndian<T>(*object);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					tmp = *object;
+					break;
+				}
+				memcpy(*buffer, &tmp, sizeof(T));
+				*size += sizeof(T);
+				(*buffer) += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::BUFFER_TOO_SHORT;
+			}
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			T tmp;
+			if (*size >= sizeof(T)) {
+				*size -= sizeof(T);
+				memcpy(&tmp, *buffer, sizeof(T));
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					*object = EndianConverter::convertBigEndian<T>(tmp);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					*object = EndianConverter::convertLittleEndian<T>(tmp);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					*object = tmp;
+					break;
+				}
+
+				*buffer += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::STREAM_TOO_SHORT;
+			}
+		}
+
+		uint32_t getSerializedSize(const T *object) {
+			return sizeof(T);
+		}
+
+	};
+
+	template<typename T>
+	class InternalSerializeAdapter<T, 1> {
+	public:
+		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) {
+				size = &ignoredSize;
+			}
+			return object->serialize(buffer, size, max_size, streamEndianness);
+		}
+		uint32_t getSerializedSize(const T *object) const {
+			return object->getSerializedSize();
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			return object->deSerialize(buffer, size, streamEndianness);
+		}
+	};
+};
+
+#endif /* SERIALIZEADAPTER_H_ */
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 5ad0e4b25..e33192ca7 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -1,60 +1,60 @@
-#ifndef SERIALIZEELEMENT_H_
-#define SERIALIZEELEMENT_H_
-
-#include <framework/container/SinglyLinkedList.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <utility>
-
-/**
- * @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().
- * Serilization and Deserialization is then performed automatically in
- * specified sequence order.
- * @ingroup serialize
- */
-template<typename T>
-class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
-public:
-	template<typename ... Args>
-	SerializeElement(Args ... args) :
-			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
-
-	}
-	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,
-				streamEndianness);
-	}
-
-	size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&entry);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&entry, buffer, size,
-				streamEndianness);
-	}
-
-	operator T() {
-		return entry;
-	}
-
-	SerializeElement<T>& operator=(T newValue) {
-		entry = newValue;
-		return *this;
-	}
-	T* operator->() {
-		return &entry;
-	}
-};
-
-#endif /* SERIALIZEELEMENT_H_ */
+#ifndef SERIALIZEELEMENT_H_
+#define SERIALIZEELEMENT_H_
+
+#include "../container/SinglyLinkedList.h"
+#include "../serialize/SerializeAdapter.h"
+#include <utility>
+
+/**
+ * @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().
+ * Serilization and Deserialization is then performed automatically in
+ * specified sequence order.
+ * @ingroup serialize
+ */
+template<typename T>
+class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
+public:
+	template<typename ... Args>
+	SerializeElement(Args ... args) :
+			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
+
+	}
+	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,
+				streamEndianness);
+	}
+
+	size_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&entry);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&entry, buffer, size,
+				streamEndianness);
+	}
+
+	operator T() {
+		return entry;
+	}
+
+	SerializeElement<T>& operator=(T newValue) {
+		entry = newValue;
+		return *this;
+	}
+	T* operator->() {
+		return &entry;
+	}
+};
+
+#endif /* SERIALIZEELEMENT_H_ */
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 14eef927e..8dc4894a0 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -1,58 +1,58 @@
-#ifndef SERIALIZEIF_H_
-#define SERIALIZEIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstddef>
-
-/**
- * @defgroup serialize Serialization
- * Contains serialisation services.
- */
-
-/**
- * @brief An interface for alle classes which require
- *        translation of objects data into data streams and vice-versa.
- * @details
- * If the target architecture is little endian (e.g. ARM), any data types
- * created might  have the wrong endianess if they are to be used for the FSFW.
- * Depending on the system architecture, endian correctness must be assured,
- * This is important for incoming and outgoing data. The internal handling
- * of data should be performed in the native system endianness.
- * There are three ways to copy data (with different options to ensure
- * endian correctness):
- *
- *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
- *      the endian flag)
- *   2. Perform a bitshift operation (with correct order)
- *   3. @c memcpy (with @c EndianSwapper if necessary)
- *
- * When serializing for downlink, the packets are generally serialized
- * assuming big endian data format like seen in TmPacketStored.cpp for example.
- *
- * @ingroup serialize
- */
-class SerializeIF {
-public:
-	enum class Endianness : uint8_t {
-		BIG, LITTLE, MACHINE
-	};
-
-	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);
-
-	virtual ~SerializeIF() {
-	}
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const = 0;
-
-	virtual size_t getSerializedSize() const = 0;
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) = 0;
-
-};
-
-#endif /* SERIALIZEIF_H_ */
+#ifndef SERIALIZEIF_H_
+#define SERIALIZEIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+/**
+ * @defgroup serialize Serialization
+ * Contains serialisation services.
+ */
+
+/**
+ * @brief An interface for alle classes which require
+ *        translation of objects data into data streams and vice-versa.
+ * @details
+ * If the target architecture is little endian (e.g. ARM), any data types
+ * created might  have the wrong endianess if they are to be used for the FSFW.
+ * Depending on the system architecture, endian correctness must be assured,
+ * This is important for incoming and outgoing data. The internal handling
+ * of data should be performed in the native system endianness.
+ * There are three ways to copy data (with different options to ensure
+ * endian correctness):
+ *
+ *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
+ *      the endian flag)
+ *   2. Perform a bitshift operation (with correct order)
+ *   3. @c memcpy (with @c EndianSwapper if necessary)
+ *
+ * When serializing for downlink, the packets are generally serialized
+ * assuming big endian data format like seen in TmPacketStored.cpp for example.
+ *
+ * @ingroup serialize
+ */
+class SerializeIF {
+public:
+	enum class Endianness : uint8_t {
+		BIG, LITTLE, MACHINE
+	};
+
+	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);
+
+	virtual ~SerializeIF() {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const = 0;
+
+	virtual size_t getSerializedSize() const = 0;
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) = 0;
+
+};
+
+#endif /* SERIALIZEIF_H_ */
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 8c510eac4..e7b2a43ed 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,217 +1,217 @@
-#include <framework/timemanager/Clock.h>
-#include <framework/serviceinterface/ServiceInterfaceBuffer.h>
-#include <cstring>
-#include <inttypes.h>
-
-// to be implemented by bsp
-extern "C" void printChar(const char*, bool errStream);
-
-#ifndef UT699
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
-		bool addCrToPreamble, bool buffered , bool errStream, uint16_t port):
-		isActive(true), logMessage(setMessage),
-		addCrToPreamble(addCrToPreamble), buffered(buffered),
-		errStream(errStream) {
-	if(buffered) {
-		// Set pointers if the stream is buffered.
-		setp( buf, buf + BUF_SIZE );
-	}
-	preamble.reserve(MAX_PREAMBLE_SIZE);
-	preamble.resize(MAX_PREAMBLE_SIZE);
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	for(; begin != end; begin++){
-		if(errStream) {
-			printChar(begin, true);
-		}
-		else {
-			printChar(begin, false);
-		}
-	}
-}
-
-#endif
-
-int ServiceInterfaceBuffer::overflow(int c) {
-	if(not buffered and this->isActive) {
-		if (c != Traits::eof()) {
-			if(errStream) {
-				printChar(reinterpret_cast<const char*>(&c), true);
-			}
-			else {
-				printChar(reinterpret_cast<const char*>(&c), false);
-			}
-		}
-		return 0;
-	}
-	// Handle output
-	putChars(pbase(), pptr());
-	if (c != Traits::eof()) {
-		char c2 = c;
-		// Handle the one character that didn't fit to buffer
-		putChars(&c2, &c2 + 1);
-	}
-	// This tells that buffer is empty again
-	setp(buf, buf + BUF_SIZE - 1);
-	// I'm not sure about this return value!
-	return 0;
-}
-
-int ServiceInterfaceBuffer::sync(void) {
-	if(not this->isActive and not buffered) {
-		if(not buffered) {
-			setp(buf, buf + BUF_SIZE - 1);
-		}
-		return 0;
-	}
-	if(not buffered) {
-		return 0;
-	}
-
-	size_t preambleSize  = 0;
-	std::string* preamble = getPreamble(&preambleSize);
-	// Write logMessage and time
-	this->putChars(preamble->data(), preamble->data() + preambleSize);
-	// Handle output
-	this->putChars(pbase(), pptr());
-	// This tells that buffer is empty again
-	setp(buf, buf + BUF_SIZE - 1);
-	return 0;
-}
-
-bool ServiceInterfaceBuffer::isBuffered() const {
-	return buffered;
-}
-
-std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
-	Clock::TimeOfDay_t loggerTime;
-	Clock::getDateAndTime(&loggerTime);
-	size_t currentSize = 0;
-	char* parsePosition = &preamble[0];
-	if(addCrToPreamble) {
-		preamble[0] = '\r';
-		currentSize += 1;
-		parsePosition += 1;
-	}
-	int32_t charCount = sprintf(parsePosition,
-			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
-					this->logMessage.c_str(), loggerTime.hour,
-					loggerTime.minute,
-					loggerTime.second,
-					loggerTime.usecond /1000);
-	if(charCount < 0) {
-		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
-		return &preamble;
-	}
-	if(charCount > MAX_PREAMBLE_SIZE) {
-		printf("ServiceInterfaceBuffer: Char count too large for maximum "
-				"preamble size");
-		return &preamble;
-	}
-	currentSize += charCount;
-	if(preambleSize != nullptr) {
-		*preambleSize = currentSize;
-	}
-	return &preamble;
-}
-
-
-
-#ifdef UT699
-#include <framework/osal/rtems/Interrupt.h>
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-		uint16_t port) {
-	this->log_message = set_message;
-	this->isActive = true;
-	setp( buf, buf + BUF_SIZE );
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	if (!Interrupt::isInterruptInProgress()) {
-		std::cout << array;
-	} else {
-		//Uncomment the following line if you need ISR debug output.
-//		printk(array);
-	}
-}
-#endif //UT699
-
-#ifdef ML505
-#include <bsp_flp/network/networkconfig.h>
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-		uint16_t port) :
-		isActive(true), log_message(set_message), udpSocket(0), remoteAddressLength(
-				sizeof(remoteAddress)) {
-	setp(buf, buf + BUF_SIZE);
-	memset((uint8_t*) &remoteAddress, 0, sizeof(remoteAddress));
-	remoteAddress.sin_family = AF_INET;
-	remoteAddress.sin_port = htons(port);
-	remoteAddress.sin_addr.s_addr = htonl(inet_addr("192.168.250.100"));
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	if (udpSocket <= 0) {
-		initSocket();
-	}
-
-	if (udpSocket > 0) {
-		sendto(udpSocket, array, length, 0, (sockaddr*) &remoteAddress,
-				sizeof(remoteAddress));
-	}
-
-}
-
-void ServiceInterfaceBuffer::initSocket() {
-	sockaddr_in address;
-	memset((uint8_t*) &address, 0, sizeof(address));
-	address.sin_family = AF_INET;
-	address.sin_port = htons(0);
-	address.sin_addr.s_addr = htonl(INADDR_ANY);
-
-	udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
-	if (socket < 0) {
-		printf("Error opening socket!\n");
-		return;
-	}
-	timeval timeout = { 0, 20 };
-	if (setsockopt(udpSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout,
-			sizeof(timeout)) < 0) {
-		printf("Error setting SO_RCVTIMEO socket options!\n");
-		return;
-	}
-	if (setsockopt(udpSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout,
-			sizeof(timeout)) < 0) {
-		printf("Error setting SO_SNDTIMEO socket options!\n");
-		return;
-	}
-	if (bind(udpSocket, (sockaddr *) &address, sizeof(address)) < 0) {
-		printf("Error binding socket!\n");
-	}
-}
-
-#endif //ML505
+#include "../timemanager/Clock.h"
+#include "../serviceinterface/ServiceInterfaceBuffer.h"
+#include <cstring>
+#include <inttypes.h>
+
+// to be implemented by bsp
+extern "C" void printChar(const char*, bool errStream);
+
+#ifndef UT699
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
+		bool addCrToPreamble, bool buffered , bool errStream, uint16_t port):
+		isActive(true), logMessage(setMessage),
+		addCrToPreamble(addCrToPreamble), buffered(buffered),
+		errStream(errStream) {
+	if(buffered) {
+		// Set pointers if the stream is buffered.
+		setp( buf, buf + BUF_SIZE );
+	}
+	preamble.reserve(MAX_PREAMBLE_SIZE);
+	preamble.resize(MAX_PREAMBLE_SIZE);
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	for(; begin != end; begin++){
+		if(errStream) {
+			printChar(begin, true);
+		}
+		else {
+			printChar(begin, false);
+		}
+	}
+}
+
+#endif
+
+int ServiceInterfaceBuffer::overflow(int c) {
+	if(not buffered and this->isActive) {
+		if (c != Traits::eof()) {
+			if(errStream) {
+				printChar(reinterpret_cast<const char*>(&c), true);
+			}
+			else {
+				printChar(reinterpret_cast<const char*>(&c), false);
+			}
+		}
+		return 0;
+	}
+	// Handle output
+	putChars(pbase(), pptr());
+	if (c != Traits::eof()) {
+		char c2 = c;
+		// Handle the one character that didn't fit to buffer
+		putChars(&c2, &c2 + 1);
+	}
+	// This tells that buffer is empty again
+	setp(buf, buf + BUF_SIZE - 1);
+	// I'm not sure about this return value!
+	return 0;
+}
+
+int ServiceInterfaceBuffer::sync(void) {
+	if(not this->isActive and not buffered) {
+		if(not buffered) {
+			setp(buf, buf + BUF_SIZE - 1);
+		}
+		return 0;
+	}
+	if(not buffered) {
+		return 0;
+	}
+
+	size_t preambleSize  = 0;
+	std::string* preamble = getPreamble(&preambleSize);
+	// Write logMessage and time
+	this->putChars(preamble->data(), preamble->data() + preambleSize);
+	// Handle output
+	this->putChars(pbase(), pptr());
+	// This tells that buffer is empty again
+	setp(buf, buf + BUF_SIZE - 1);
+	return 0;
+}
+
+bool ServiceInterfaceBuffer::isBuffered() const {
+	return buffered;
+}
+
+std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
+	Clock::TimeOfDay_t loggerTime;
+	Clock::getDateAndTime(&loggerTime);
+	size_t currentSize = 0;
+	char* parsePosition = &preamble[0];
+	if(addCrToPreamble) {
+		preamble[0] = '\r';
+		currentSize += 1;
+		parsePosition += 1;
+	}
+	int32_t charCount = sprintf(parsePosition,
+			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
+					this->logMessage.c_str(), loggerTime.hour,
+					loggerTime.minute,
+					loggerTime.second,
+					loggerTime.usecond /1000);
+	if(charCount < 0) {
+		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
+		return &preamble;
+	}
+	if(charCount > MAX_PREAMBLE_SIZE) {
+		printf("ServiceInterfaceBuffer: Char count too large for maximum "
+				"preamble size");
+		return &preamble;
+	}
+	currentSize += charCount;
+	if(preambleSize != nullptr) {
+		*preambleSize = currentSize;
+	}
+	return &preamble;
+}
+
+
+
+#ifdef UT699
+#include "../osal/rtems/Interrupt.h"
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+		uint16_t port) {
+	this->log_message = set_message;
+	this->isActive = true;
+	setp( buf, buf + BUF_SIZE );
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	if (!Interrupt::isInterruptInProgress()) {
+		std::cout << array;
+	} else {
+		//Uncomment the following line if you need ISR debug output.
+//		printk(array);
+	}
+}
+#endif //UT699
+
+#ifdef ML505
+#include <bsp_flp/network/networkconfig.h>
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+		uint16_t port) :
+		isActive(true), log_message(set_message), udpSocket(0), remoteAddressLength(
+				sizeof(remoteAddress)) {
+	setp(buf, buf + BUF_SIZE);
+	memset((uint8_t*) &remoteAddress, 0, sizeof(remoteAddress));
+	remoteAddress.sin_family = AF_INET;
+	remoteAddress.sin_port = htons(port);
+	remoteAddress.sin_addr.s_addr = htonl(inet_addr("192.168.250.100"));
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	if (udpSocket <= 0) {
+		initSocket();
+	}
+
+	if (udpSocket > 0) {
+		sendto(udpSocket, array, length, 0, (sockaddr*) &remoteAddress,
+				sizeof(remoteAddress));
+	}
+
+}
+
+void ServiceInterfaceBuffer::initSocket() {
+	sockaddr_in address;
+	memset((uint8_t*) &address, 0, sizeof(address));
+	address.sin_family = AF_INET;
+	address.sin_port = htons(0);
+	address.sin_addr.s_addr = htonl(INADDR_ANY);
+
+	udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
+	if (socket < 0) {
+		printf("Error opening socket!\n");
+		return;
+	}
+	timeval timeout = { 0, 20 };
+	if (setsockopt(udpSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout,
+			sizeof(timeout)) < 0) {
+		printf("Error setting SO_RCVTIMEO socket options!\n");
+		return;
+	}
+	if (setsockopt(udpSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout,
+			sizeof(timeout)) < 0) {
+		printf("Error setting SO_SNDTIMEO socket options!\n");
+		return;
+	}
+	if (bind(udpSocket, (sockaddr *) &address, sizeof(address)) < 0) {
+		printf("Error binding socket!\n");
+	}
+}
+
+#endif //ML505
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 7a2ce2ee7..a5c135b66 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -1,145 +1,145 @@
-#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
-#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <iostream>
-#include <sstream>
-#include <iomanip>
-
-#ifndef UT699
-
-/**
- * @brief 	This is the underlying stream buffer which implements the
- * 			streambuf class and overloads the overflow() and sync() methods
- * @details
- * This class is used to modify the output of the stream, for example by adding.
- * It also calls the char printing function which is implemented in the
- * board supply package (BSP).
- */
-class ServiceInterfaceBuffer:
-        public std::streambuf {
-	friend class ServiceInterfaceStream;
-public:
-	static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
-
-	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
-			bool buffered, bool errStream, uint16_t port);
-
-protected:
-	bool isActive;
-	//! This is called when buffer becomes full. If
-	//! buffer is not used, then this is called every
-	//! time when characters are put to stream.
-	int overflow(int c = Traits::eof()) override;
-
-	//! This function is called when stream is flushed,
-	//! for example when std::endl is put to stream.
-	int sync(void) override;
-
-	bool isBuffered() const;
-private:
-	//! For additional message information
-	std::string logMessage;
-	std::string preamble;
-	// For EOF detection
-	typedef std::char_traits<char> Traits;
-
-	//! This is useful for some terminal programs which do not have
-	//! implicit carriage return with newline characters.
-	bool addCrToPreamble;
-
-	//! Specifies whether the stream operates in buffered or unbuffered mode.
-	bool buffered;
-	//! This specifies to print to stderr and work in unbuffered mode.
-	bool errStream;
-
-	//! Needed for buffered mode.
-	static size_t const BUF_SIZE = 128;
-	char buf[BUF_SIZE];
-
-	//! In this function, the characters are parsed.
-	void putChars(char const* begin, char const* end);
-
-	std::string* getPreamble(size_t * preambleSize = nullptr);
-};
-
-#endif
-
-
-#ifdef UT699
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
-	friend class ServiceInterfaceStream;
-public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
-protected:
-	bool isActive;
-	// This is called when buffer becomes full. If
-	// buffer is not used, then this is called every
-	// time when characters are put to stream.
-	virtual int overflow(int c = Traits::eof());
-
-	// This function is called when stream is flushed,
-	// for example when std::endl is put to stream.
-	virtual int sync(void);
-
-private:
-	// For additional message information
-	std::string log_message;
-	// For EOF detection
-	typedef std::char_traits<char> Traits;
-
-	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 128;
-	char buf[BUF_SIZE];
-
-	// In this function, the characters are parsed.
-	void putChars(char const* begin, char const* end);
-};
-#endif //UT699
-
-#ifdef ML505
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <netinet/udp.h>
-
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
-	friend class ServiceInterfaceStream;
-public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
-protected:
-	bool isActive;
-	// This is called when buffer becomes full. If
-	// buffer is not used, then this is called every
-	// time when characters are put to stream.
-	virtual int overflow(int c = Traits::eof());
-
-	// This function is called when stream is flushed,
-	// for example when std::endl is put to stream.
-	virtual int sync(void);
-
-private:
-	// For additional message information
-	std::string log_message;
-	// For EOF detection
-	typedef std::char_traits<char> Traits;
-
-	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 128;
-	char buf[BUF_SIZE];
-
-	// In this function, the characters are parsed.
-	void putChars(char const* begin, char const* end);
-
-	int udpSocket;
-	sockaddr_in remoteAddress;
-	socklen_t remoteAddressLength;
-	void initSocket();
-};
-#endif //ML505
-
-
-#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+
+#ifndef UT699
+
+/**
+ * @brief 	This is the underlying stream buffer which implements the
+ * 			streambuf class and overloads the overflow() and sync() methods
+ * @details
+ * This class is used to modify the output of the stream, for example by adding.
+ * It also calls the char printing function which is implemented in the
+ * board supply package (BSP).
+ */
+class ServiceInterfaceBuffer:
+        public std::streambuf {
+	friend class ServiceInterfaceStream;
+public:
+	static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
+
+	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
+			bool buffered, bool errStream, uint16_t port);
+
+protected:
+	bool isActive;
+	//! This is called when buffer becomes full. If
+	//! buffer is not used, then this is called every
+	//! time when characters are put to stream.
+	int overflow(int c = Traits::eof()) override;
+
+	//! This function is called when stream is flushed,
+	//! for example when std::endl is put to stream.
+	int sync(void) override;
+
+	bool isBuffered() const;
+private:
+	//! For additional message information
+	std::string logMessage;
+	std::string preamble;
+	// For EOF detection
+	typedef std::char_traits<char> Traits;
+
+	//! This is useful for some terminal programs which do not have
+	//! implicit carriage return with newline characters.
+	bool addCrToPreamble;
+
+	//! Specifies whether the stream operates in buffered or unbuffered mode.
+	bool buffered;
+	//! This specifies to print to stderr and work in unbuffered mode.
+	bool errStream;
+
+	//! Needed for buffered mode.
+	static size_t const BUF_SIZE = 128;
+	char buf[BUF_SIZE];
+
+	//! In this function, the characters are parsed.
+	void putChars(char const* begin, char const* end);
+
+	std::string* getPreamble(size_t * preambleSize = nullptr);
+};
+
+#endif
+
+
+#ifdef UT699
+class ServiceInterfaceBuffer: public std::basic_streambuf<char,
+		std::char_traits<char> > {
+	friend class ServiceInterfaceStream;
+public:
+	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+protected:
+	bool isActive;
+	// This is called when buffer becomes full. If
+	// buffer is not used, then this is called every
+	// time when characters are put to stream.
+	virtual int overflow(int c = Traits::eof());
+
+	// This function is called when stream is flushed,
+	// for example when std::endl is put to stream.
+	virtual int sync(void);
+
+private:
+	// For additional message information
+	std::string log_message;
+	// For EOF detection
+	typedef std::char_traits<char> Traits;
+
+	// Work in buffer mode. It is also possible to work without buffer.
+	static size_t const BUF_SIZE = 128;
+	char buf[BUF_SIZE];
+
+	// In this function, the characters are parsed.
+	void putChars(char const* begin, char const* end);
+};
+#endif //UT699
+
+#ifdef ML505
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+
+class ServiceInterfaceBuffer: public std::basic_streambuf<char,
+		std::char_traits<char> > {
+	friend class ServiceInterfaceStream;
+public:
+	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+protected:
+	bool isActive;
+	// This is called when buffer becomes full. If
+	// buffer is not used, then this is called every
+	// time when characters are put to stream.
+	virtual int overflow(int c = Traits::eof());
+
+	// This function is called when stream is flushed,
+	// for example when std::endl is put to stream.
+	virtual int sync(void);
+
+private:
+	// For additional message information
+	std::string log_message;
+	// For EOF detection
+	typedef std::char_traits<char> Traits;
+
+	// Work in buffer mode. It is also possible to work without buffer.
+	static size_t const BUF_SIZE = 128;
+	char buf[BUF_SIZE];
+
+	// In this function, the characters are parsed.
+	void putChars(char const* begin, char const* end);
+
+	int udpSocket;
+	sockaddr_in remoteAddress;
+	socklen_t remoteAddressLength;
+	void initSocket();
+};
+#endif //ML505
+
+
+#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 31bc7c730..7c6676ddd 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,32 +1,32 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
-		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
-		std::ostream(&streambuf),
-		streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
-
-void ServiceInterfaceStream::setActive( bool myActive) {
-	this->streambuf.isActive = myActive;
-}
-
-std::string* ServiceInterfaceStream::getPreamble() {
-	return streambuf.getPreamble();
-}
-
-void ServiceInterfaceStream::print(std::string error,
-		bool withPreamble, bool withNewline, bool flush) {
-	if(not streambuf.isBuffered() and withPreamble) {
-		*this << getPreamble() << error;
-	}
-	else {
-		*this << error;
-	}
-
-	if(withNewline) {
-		*this << "\n";
-	}
-	// if mode is non-buffered, no need to flush.
-	if(flush and streambuf.isBuffered()) {
-		this->flush();
-	}
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
+		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
+		std::ostream(&streambuf),
+		streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
+
+void ServiceInterfaceStream::setActive( bool myActive) {
+	this->streambuf.isActive = myActive;
+}
+
+std::string* ServiceInterfaceStream::getPreamble() {
+	return streambuf.getPreamble();
+}
+
+void ServiceInterfaceStream::print(std::string error,
+		bool withPreamble, bool withNewline, bool flush) {
+	if(not streambuf.isBuffered() and withPreamble) {
+		*this << getPreamble() << error;
+	}
+	else {
+		*this << error;
+	}
+
+	if(withNewline) {
+		*this << "\n";
+	}
+	// if mode is non-buffered, no need to flush.
+	if(flush and streambuf.isBuffered()) {
+		this->flush();
+	}
+}
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index dc111459a..b1786a380 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -1,58 +1,58 @@
-#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
-#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
-
-#include <framework/serviceinterface/ServiceInterfaceBuffer.h>
-#include <iostream>
-#include <cstdio>
-
-/**
- * Generic service interface stream which can be used like std::cout or
- * std::cerr but has additional capability. Add preamble and timestamp
- * to output. Can be run in buffered or unbuffered mode.
- */
-class ServiceInterfaceStream : public std::ostream {
-public:
-	/**
-	 * This constructor is used by specifying the preamble message.
-	 * Optionally, the output can be directed to stderr and a CR character
-	 * can be prepended to the preamble.
-	 * @param setMessage message of preamble.
-	 * @param addCrToPreamble Useful for applications like Puttty.
-	 * @param buffered specify whether to use buffered mode.
-	 * @param errStream specify which output stream to use (stderr or stdout).
-	 */
-	ServiceInterfaceStream(std::string setMessage,
-			bool addCrToPreamble = false, bool buffered = true,
-			bool errStream = false, uint16_t port = 1234);
-
-	//! An inactive stream will not print anything.
-	void setActive( bool );
-
-	/**
-	 * This can be used to retrieve the preamble in case it should be printed in
-	 * the unbuffered mode.
-	 * @return Preamle consisting of log message and timestamp.
-	 */
-	std::string* getPreamble();
-
-	/**
-	 * This prints an error with a preamble. Useful if using the unbuffered
-	 * mode. Flushes in default mode (prints immediately).
-	 */
-	void print(std::string error, bool withPreamble = true,
-			bool withNewline = true, bool flush = true);
-
-protected:
-	ServiceInterfaceBuffer streambuf;
-};
-
-// Forward declaration of interface streams. These should be instantiated in
-// main. They can then be used like std::cout or std::cerr.
-namespace sif {
-extern ServiceInterfaceStream debug;
-extern ServiceInterfaceStream info;
-extern ServiceInterfaceStream warning;
-extern ServiceInterfaceStream error;
-}
-
-#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+
+#include "../serviceinterface/ServiceInterfaceBuffer.h"
+#include <iostream>
+#include <cstdio>
+
+/**
+ * Generic service interface stream which can be used like std::cout or
+ * std::cerr but has additional capability. Add preamble and timestamp
+ * to output. Can be run in buffered or unbuffered mode.
+ */
+class ServiceInterfaceStream : public std::ostream {
+public:
+	/**
+	 * This constructor is used by specifying the preamble message.
+	 * Optionally, the output can be directed to stderr and a CR character
+	 * can be prepended to the preamble.
+	 * @param setMessage message of preamble.
+	 * @param addCrToPreamble Useful for applications like Puttty.
+	 * @param buffered specify whether to use buffered mode.
+	 * @param errStream specify which output stream to use (stderr or stdout).
+	 */
+	ServiceInterfaceStream(std::string setMessage,
+			bool addCrToPreamble = false, bool buffered = true,
+			bool errStream = false, uint16_t port = 1234);
+
+	//! An inactive stream will not print anything.
+	void setActive( bool );
+
+	/**
+	 * This can be used to retrieve the preamble in case it should be printed in
+	 * the unbuffered mode.
+	 * @return Preamle consisting of log message and timestamp.
+	 */
+	std::string* getPreamble();
+
+	/**
+	 * This prints an error with a preamble. Useful if using the unbuffered
+	 * mode. Flushes in default mode (prints immediately).
+	 */
+	void print(std::string error, bool withPreamble = true,
+			bool withNewline = true, bool flush = true);
+
+protected:
+	ServiceInterfaceBuffer streambuf;
+};
+
+// Forward declaration of interface streams. These should be instantiated in
+// main. They can then be used like std::cout or std::cerr.
+namespace sif {
+extern ServiceInterfaceStream debug;
+extern ServiceInterfaceStream info;
+extern ServiceInterfaceStream warning;
+extern ServiceInterfaceStream error;
+}
+
+#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */
diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 0bfde58c1..ea9f2e444 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -1,87 +1,87 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/storagemanager/ConstStorageAccessor.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/globalfunctions/arrayprinter.h>
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
-		storeId(storeId) {}
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
-		StorageManagerIF* store):
-		storeId(storeId), store(store) {
-	internalState = AccessState::ASSIGNED;
-}
-
-ConstStorageAccessor::~ConstStorageAccessor() {
-	if(deleteData and store != nullptr) {
-		sif::debug << "deleting store data" << std::endl;
-		store->deleteData(storeId);
-	}
-}
-
-ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
-		constDataPointer(other.constDataPointer), storeId(other.storeId),
-		size_(other.size_), store(other.store), deleteData(other.deleteData),
-		internalState(other.internalState) {
-	// This prevent premature deletion
-	other.store = nullptr;
-}
-
-ConstStorageAccessor& ConstStorageAccessor::operator=(
-		ConstStorageAccessor&& other) {
-	constDataPointer = other.constDataPointer;
-	storeId = other.storeId;
-	store = other.store;
-	size_ = other.size_;
-	deleteData = other.deleteData;
-	this->store = other.store;
-	// This prevents premature deletion
-	other.store = nullptr;
-	return *this;
-}
-
-const uint8_t* ConstStorageAccessor::data() const {
-	return constDataPointer;
-}
-
-size_t ConstStorageAccessor::size() const {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return size_;
-}
-
-ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
-		size_t maxSize) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(constDataPointer, constDataPointer + size_, pointer);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void ConstStorageAccessor::release() {
-	deleteData = false;
-}
-
-store_address_t ConstStorageAccessor::getId() const {
-	return storeId;
-}
-
-void ConstStorageAccessor::print() const {
-	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return;
-	}
-	arrayprinter::print(constDataPointer, size_);
-}
-
-void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
-	internalState = AccessState::ASSIGNED;
-	this->store = store;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/ConstStorageAccessor.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../globalfunctions/arrayprinter.h"
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
+		storeId(storeId) {}
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		storeId(storeId), store(store) {
+	internalState = AccessState::ASSIGNED;
+}
+
+ConstStorageAccessor::~ConstStorageAccessor() {
+	if(deleteData and store != nullptr) {
+		sif::debug << "deleting store data" << std::endl;
+		store->deleteData(storeId);
+	}
+}
+
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
+ConstStorageAccessor& ConstStorageAccessor::operator=(
+		ConstStorageAccessor&& other) {
+	constDataPointer = other.constDataPointer;
+	storeId = other.storeId;
+	store = other.store;
+	size_ = other.size_;
+	deleteData = other.deleteData;
+	this->store = other.store;
+	// This prevents premature deletion
+	other.store = nullptr;
+	return *this;
+}
+
+const uint8_t* ConstStorageAccessor::data() const {
+	return constDataPointer;
+}
+
+size_t ConstStorageAccessor::size() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return size_;
+}
+
+ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
+		size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(constDataPointer, constDataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ConstStorageAccessor::release() {
+	deleteData = false;
+}
+
+store_address_t ConstStorageAccessor::getId() const {
+	return storeId;
+}
+
+void ConstStorageAccessor::print() const {
+	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	arrayprinter::print(constDataPointer, size_);
+}
+
+void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+	internalState = AccessState::ASSIGNED;
+	this->store = store;
+}
diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index 020030a9e..ec2da8cef 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -1,116 +1,116 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
-
-#include <framework/storagemanager/storeAddress.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstddef>
-
-class StorageManagerIF;
-
-/**
- * @brief 	Helper classes to facilitate safe access to storages which is also
- * 			conforming to RAII principles
- * @details
- * Accessor class which can be returned by pool manager or passed and set by
- * pool managers to have safe access to the pool resources.
- *
- * These helper can be used together with the StorageManager classes to manage
- * access to a storage. It can take care of thread-safety while also providing
- * mechanisms to automatically clear storage data.
- */
-class ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	/**
-	 * @brief	Simple constructor which takes the store ID of the storage
-	 * 			entry to access.
-	 * @param storeId
-	 */
-	ConstStorageAccessor(store_address_t storeId);
-	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
-
-	/**
-	 * @brief 	The destructor in default configuration takes care of
-	 * 			deleting the accessed pool entry and unlocking the mutex
-	 */
-	virtual ~ConstStorageAccessor();
-
-	/**
-	 * @brief	Returns a pointer to the read-only data
-	 * @return
-	 */
-	const uint8_t* data() const;
-
-	/**
-	 * @brief	Copies the read-only data to the supplied pointer
-	 * @param pointer
-	 */
-	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
-
-	/**
-	 * @brief   Calling this will prevent the Accessor from deleting the data
-	 *          when the destructor is called.
-	 */
-	void release();
-
-	/**
-	 * Get the size of the data
-	 * @return
-	 */
-	size_t size() const;
-
-	/**
-	 * Get the storage ID.
-	 * @return
-	 */
-	store_address_t getId() const;
-
-	void print() const;
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor(ConstStorageAccessor&&);
-
-	//! The copy ctor and copy assignemnt should be deleted implicitely
-	//! according to https://foonathan.net/2019/02/special-member-functions/
-	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
-	ConstStorageAccessor(const ConstStorageAccessor&) = delete;
-protected:
-	const uint8_t* constDataPointer = nullptr;
-	store_address_t storeId;
-	size_t size_ = 0;
-	//! Managing pool, has to assign itself.
-	StorageManagerIF* store = nullptr;
-	bool deleteData = true;
-
-	enum class AccessState {
-		UNINIT,
-		ASSIGNED
-	};
-	//! Internal state for safety reasons.
-	AccessState internalState = AccessState::UNINIT;
-	/**
-	 * Used by the pool manager instances to assign themselves to the
-	 * accessor. This is necessary to delete the data when the acessor
-	 * exits the scope ! The internal state will be considered read
-	 * when this function is called, so take care all data is set properly as
-	 * well.
-	 * @param
-	 */
-	void assignStore(StorageManagerIF*);
-};
-
-
-#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+
+#include "../storagemanager/storeAddress.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+class StorageManagerIF;
+
+/**
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details
+ * Accessor class which can be returned by pool manager or passed and set by
+ * pool managers to have safe access to the pool resources.
+ *
+ * These helper can be used together with the StorageManager classes to manage
+ * access to a storage. It can take care of thread-safety while also providing
+ * mechanisms to automatically clear storage data.
+ */
+class ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	/**
+	 * @brief	Simple constructor which takes the store ID of the storage
+	 * 			entry to access.
+	 * @param storeId
+	 */
+	ConstStorageAccessor(store_address_t storeId);
+	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
+	/**
+	 * @brief 	The destructor in default configuration takes care of
+	 * 			deleting the accessed pool entry and unlocking the mutex
+	 */
+	virtual ~ConstStorageAccessor();
+
+	/**
+	 * @brief	Returns a pointer to the read-only data
+	 * @return
+	 */
+	const uint8_t* data() const;
+
+	/**
+	 * @brief	Copies the read-only data to the supplied pointer
+	 * @param pointer
+	 */
+	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
+
+	/**
+	 * @brief   Calling this will prevent the Accessor from deleting the data
+	 *          when the destructor is called.
+	 */
+	void release();
+
+	/**
+	 * Get the size of the data
+	 * @return
+	 */
+	size_t size() const;
+
+	/**
+	 * Get the storage ID.
+	 * @return
+	 */
+	store_address_t getId() const;
+
+	void print() const;
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+	ConstStorageAccessor(ConstStorageAccessor&&);
+
+	//! The copy ctor and copy assignemnt should be deleted implicitely
+	//! according to https://foonathan.net/2019/02/special-member-functions/
+	//! but I still deleted them to make it more explicit. (remember rule of 5).
+	ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
+	ConstStorageAccessor(const ConstStorageAccessor&) = delete;
+protected:
+	const uint8_t* constDataPointer = nullptr;
+	store_address_t storeId;
+	size_t size_ = 0;
+	//! Managing pool, has to assign itself.
+	StorageManagerIF* store = nullptr;
+	bool deleteData = true;
+
+	enum class AccessState {
+		UNINIT,
+		ASSIGNED
+	};
+	//! Internal state for safety reasons.
+	AccessState internalState = AccessState::UNINIT;
+	/**
+	 * Used by the pool manager instances to assign themselves to the
+	 * accessor. This is necessary to delete the data when the acessor
+	 * exits the scope ! The internal state will be considered read
+	 * when this function is called, so take care all data is set properly as
+	 * well.
+	 * @param
+	 */
+	void assignStore(StorageManagerIF*);
+};
+
+
+#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 7e349dcde..5ead79812 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -1,189 +1,189 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/storagemanager/StorageAccessor.h>
-#include <cstring>
-
-/**
- * @brief	The LocalPool class provides an intermediate data storage with
- * 			a fixed pool size policy.
- * @details	The class implements the StorageManagerIF interface. While the
- * 			total number of pools is fixed, the element sizes in one pool and
- * 			the number of pool elements per pool are set on construction.
- * 			The full amount of memory is allocated on construction.
- * 			The overhead is 4 byte per pool element to store the size
- * 			information of each stored element.
- * 			To maintain an "empty" information, the pool size is limited to
- * 			0xFFFF-1 bytes.
- * 			It is possible to store empty packets in the pool.
- * 			The local pool is NOT thread-safe.
- * @author 	Bastian Baetz
- */
-template<uint8_t NUMBER_OF_POOLS = 5>
-class LocalPool: public SystemObject, public StorageManagerIF {
-public:
-	/**
-	 * @brief	This definition generally sets the number of different sized pools.
-	 * @details This must be less than the maximum number of pools (currently 0xff).
-	 */
-	//	static const uint32_t NUMBER_OF_POOLS;
-	/**
-	 * @brief	This is the default constructor for a pool manager instance.
-	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
-	 * 			allocates memory (with @c new) for store and size_list. These
-	 * 			regions are all set to zero on start up.
-	 * @param setObjectId	The object identifier to be set. This allows for
-	 * 						multiple instances of LocalPool in the system.
-	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
-	 * 						of a single element in each pool is determined.
-	 * 						<b>The sizes must be provided in ascending order.
-	 * 						</b>
-	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
-	 * 						number of elements for each pool is determined.
-	 * 						The position of these values correspond to those in
-	 * 						element_sizes.
-	 * @param registered	Register the pool in object manager or not.
-	 * Default is false (local pool).
-	 * @param spillsToHigherPools A variable to determine whether
-	 * higher n pools are used if the store is full.
-	 */
-	LocalPool(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS],
-			bool registered = false,
-			bool spillsToHigherPools = false);
-	/**
-	 * @brief	In the LocalPool's destructor all allocated memory is freed.
-	 */
-	virtual ~LocalPool(void);
-
-	/**
-	 * Documentation: See StorageManagerIF.h
-	 */
-	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
-			size_t size, bool ignoreFault = false) override;
-	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
-			uint8_t** p_data, bool ignoreFault = false) override;
-
-	ConstAccessorPair getData(store_address_t packet_id) override;
-	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
-	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
-			size_t * size) override;
-
-	AccessorPair modifyData(store_address_t packet_id) override;
-	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
-	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			size_t * size) override;
-
-	virtual ReturnValue_t deleteData(store_address_t) override;
-	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
-			store_address_t* storeId = NULL) override;
-	void clearStore() override;
-	ReturnValue_t initialize() override;
-protected:
-	/**
-	 * With this helper method, a free element of @c size is reserved.
-	 * @param size	The minimum packet size that shall be reserved.
-	 * @param[out] address Storage ID of the reserved data.
-	 * @return	- #RETURN_OK on success,
-	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
-	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size,
-			store_address_t* address, bool ignoreFault);
-
-	InternalErrorReporterIF *internalErrorReporter;
-private:
-	/**
-	 * Indicates that this element is free.
-	 * This value limits the maximum size of a pool. Change to larger data type
-	 * if increase is required.
-	 */
-	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
-	/**
-	 * @brief	In this array, the element sizes of each pool is stored.
-	 * @details	The sizes are maintained for internal pool management. The sizes
-	 * 			must be set in ascending order on construction.
-	 */
-	uint32_t element_sizes[NUMBER_OF_POOLS];
-	/**
-	 * @brief	n_elements stores the number of elements per pool.
-	 * @details	These numbers are maintained for internal pool management.
-	 */
-	uint16_t n_elements[NUMBER_OF_POOLS];
-	/**
-	 * @brief	store represents the actual memory pool.
-	 * @details	It is an array of pointers to memory, which was allocated with
-	 * 			a @c new call on construction.
-	 */
-	uint8_t* store[NUMBER_OF_POOLS];
-	/**
-	 * @brief	The size_list attribute stores the size values of every pool element.
-	 * @details	As the number of elements is determined on construction, the size list
-	 * 			is also dynamically allocated there.
-	 */
-	uint32_t* size_list[NUMBER_OF_POOLS];
-	//! A variable to determine whether higher n pools are used if
-	//! the store is full.
-	bool spillsToHigherPools;
-	/**
-	 * @brief	This method safely stores the given data in the given packet_id.
-	 * @details	It also sets the size in size_list. The method does not perform
-	 * 			any range checks, these are done in advance.
-	 * @param packet_id	The storage identifier in which the data shall be stored.
-	 * @param data		The data to be stored.
-	 * @param size		The size of the data to be stored.
-	 */
-	void write(store_address_t packet_id, const uint8_t* data, size_t size);
-	/**
-	 * @brief	A helper method to read the element size of a certain pool.
-	 * @param pool_index	The pool in which to look.
-	 * @return	Returns the size of an element or 0.
-	 */
-	uint32_t getPageSize(uint16_t pool_index);
-	/**
-	 * @brief	This helper method looks up a fitting pool for a given size.
-	 * @details	The pools are looked up in ascending order, so the first that
-	 * 			fits is used.
-	 * @param packet_size	The size of the data to be stored.
-	 * @return	Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
-	 */
-	/**
-	 * @brief	This helper method looks up a fitting pool for a given size.
-	 * @details	The pools are looked up in ascending order, so the first that
-	 * 			fits is used.
-	 * @param packet_size		The size of the data to be stored.
-	 * @param[out] poolIndex	The fitting pool index found.
-	 * @return	- #RETURN_OK on success,
-	 * 			- #DATA_TOO_LARGE otherwise.
-	 */
-	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
-			uint16_t startAtIndex = 0);
-	/**
-	 * @brief	This helper method calculates the true array position in store
-	 * 			of a given packet id.
-	 * @details	The method does not perform any range checks, these are done in
-	 * 			advance.
-	 * @param packet_id	The packet id to look up.
-	 * @return	Returns the position of the data in store.
-	 */
-	uint32_t getRawPosition(store_address_t packet_id);
-	/**
-	 * @brief	This is a helper method to find an empty element in a given pool.
-	 * @details	The method searches size_list for the first empty element, so
-	 * 			duration grows with the fill level of the pool.
-	 * @param pool_index	The pool in which the search is performed.
-	 * @param[out] element	The first found element in the pool.
-	 * @return	- #RETURN_OK on success,
-	 * 			- #DATA_STORAGE_FULL if the store is full
-	 */
-	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
-};
-
-#include <framework/storagemanager/LocalPool.tpp>
-
-#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../internalError/InternalErrorReporterIF.h"
+#include "../storagemanager/StorageAccessor.h"
+#include <cstring>
+
+/**
+ * @brief	The LocalPool class provides an intermediate data storage with
+ * 			a fixed pool size policy.
+ * @details	The class implements the StorageManagerIF interface. While the
+ * 			total number of pools is fixed, the element sizes in one pool and
+ * 			the number of pool elements per pool are set on construction.
+ * 			The full amount of memory is allocated on construction.
+ * 			The overhead is 4 byte per pool element to store the size
+ * 			information of each stored element.
+ * 			To maintain an "empty" information, the pool size is limited to
+ * 			0xFFFF-1 bytes.
+ * 			It is possible to store empty packets in the pool.
+ * 			The local pool is NOT thread-safe.
+ * @author 	Bastian Baetz
+ */
+template<uint8_t NUMBER_OF_POOLS = 5>
+class LocalPool: public SystemObject, public StorageManagerIF {
+public:
+	/**
+	 * @brief	This definition generally sets the number of different sized pools.
+	 * @details This must be less than the maximum number of pools (currently 0xff).
+	 */
+	//	static const uint32_t NUMBER_OF_POOLS;
+	/**
+	 * @brief	This is the default constructor for a pool manager instance.
+	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
+	 * 			allocates memory (with @c new) for store and size_list. These
+	 * 			regions are all set to zero on start up.
+	 * @param setObjectId	The object identifier to be set. This allows for
+	 * 						multiple instances of LocalPool in the system.
+	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
+	 * 						of a single element in each pool is determined.
+	 * 						<b>The sizes must be provided in ascending order.
+	 * 						</b>
+	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
+	 * 						number of elements for each pool is determined.
+	 * 						The position of these values correspond to those in
+	 * 						element_sizes.
+	 * @param registered	Register the pool in object manager or not.
+	 * Default is false (local pool).
+	 * @param spillsToHigherPools A variable to determine whether
+	 * higher n pools are used if the store is full.
+	 */
+	LocalPool(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS],
+			bool registered = false,
+			bool spillsToHigherPools = false);
+	/**
+	 * @brief	In the LocalPool's destructor all allocated memory is freed.
+	 */
+	virtual ~LocalPool(void);
+
+	/**
+	 * Documentation: See StorageManagerIF.h
+	 */
+	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
+			size_t size, bool ignoreFault = false) override;
+	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
+			uint8_t** p_data, bool ignoreFault = false) override;
+
+	ConstAccessorPair getData(store_address_t packet_id) override;
+	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
+	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
+			size_t * size) override;
+
+	AccessorPair modifyData(store_address_t packet_id) override;
+	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
+	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
+			size_t * size) override;
+
+	virtual ReturnValue_t deleteData(store_address_t) override;
+	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
+			store_address_t* storeId = NULL) override;
+	void clearStore() override;
+	ReturnValue_t initialize() override;
+protected:
+	/**
+	 * With this helper method, a free element of @c size is reserved.
+	 * @param size	The minimum packet size that shall be reserved.
+	 * @param[out] address Storage ID of the reserved data.
+	 * @return	- #RETURN_OK on success,
+	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
+	 */
+	virtual ReturnValue_t reserveSpace(const uint32_t size,
+			store_address_t* address, bool ignoreFault);
+
+	InternalErrorReporterIF *internalErrorReporter;
+private:
+	/**
+	 * Indicates that this element is free.
+	 * This value limits the maximum size of a pool. Change to larger data type
+	 * if increase is required.
+	 */
+	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
+	/**
+	 * @brief	In this array, the element sizes of each pool is stored.
+	 * @details	The sizes are maintained for internal pool management. The sizes
+	 * 			must be set in ascending order on construction.
+	 */
+	uint32_t element_sizes[NUMBER_OF_POOLS];
+	/**
+	 * @brief	n_elements stores the number of elements per pool.
+	 * @details	These numbers are maintained for internal pool management.
+	 */
+	uint16_t n_elements[NUMBER_OF_POOLS];
+	/**
+	 * @brief	store represents the actual memory pool.
+	 * @details	It is an array of pointers to memory, which was allocated with
+	 * 			a @c new call on construction.
+	 */
+	uint8_t* store[NUMBER_OF_POOLS];
+	/**
+	 * @brief	The size_list attribute stores the size values of every pool element.
+	 * @details	As the number of elements is determined on construction, the size list
+	 * 			is also dynamically allocated there.
+	 */
+	uint32_t* size_list[NUMBER_OF_POOLS];
+	//! A variable to determine whether higher n pools are used if
+	//! the store is full.
+	bool spillsToHigherPools;
+	/**
+	 * @brief	This method safely stores the given data in the given packet_id.
+	 * @details	It also sets the size in size_list. The method does not perform
+	 * 			any range checks, these are done in advance.
+	 * @param packet_id	The storage identifier in which the data shall be stored.
+	 * @param data		The data to be stored.
+	 * @param size		The size of the data to be stored.
+	 */
+	void write(store_address_t packet_id, const uint8_t* data, size_t size);
+	/**
+	 * @brief	A helper method to read the element size of a certain pool.
+	 * @param pool_index	The pool in which to look.
+	 * @return	Returns the size of an element or 0.
+	 */
+	uint32_t getPageSize(uint16_t pool_index);
+	/**
+	 * @brief	This helper method looks up a fitting pool for a given size.
+	 * @details	The pools are looked up in ascending order, so the first that
+	 * 			fits is used.
+	 * @param packet_size	The size of the data to be stored.
+	 * @return	Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
+	 */
+	/**
+	 * @brief	This helper method looks up a fitting pool for a given size.
+	 * @details	The pools are looked up in ascending order, so the first that
+	 * 			fits is used.
+	 * @param packet_size		The size of the data to be stored.
+	 * @param[out] poolIndex	The fitting pool index found.
+	 * @return	- #RETURN_OK on success,
+	 * 			- #DATA_TOO_LARGE otherwise.
+	 */
+	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
+			uint16_t startAtIndex = 0);
+	/**
+	 * @brief	This helper method calculates the true array position in store
+	 * 			of a given packet id.
+	 * @details	The method does not perform any range checks, these are done in
+	 * 			advance.
+	 * @param packet_id	The packet id to look up.
+	 * @return	Returns the position of the data in store.
+	 */
+	uint32_t getRawPosition(store_address_t packet_id);
+	/**
+	 * @brief	This is a helper method to find an empty element in a given pool.
+	 * @details	The method searches size_list for the first empty element, so
+	 * 			duration grows with the fill level of the pool.
+	 * @param pool_index	The pool in which the search is performed.
+	 * @param[out] element	The first found element in the pool.
+	 * @return	- #RETURN_OK on success,
+	 * 			- #DATA_STORAGE_FULL if the store is full
+	 */
+	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
+};
+
+#include "../storagemanager/LocalPool.tpp"
+
+#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 3c1c12176..2dc3266ac 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,49 +1,49 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-
-#include <framework/storagemanager/LocalPool.h>
-#include <framework/ipc/MutexHelper.h>
-#include <framework/storagemanager/StorageAccessor.h>
-
-/**
- * @brief	The PoolManager class provides an intermediate data storage with
- * 			a fixed pool size policy for inter-process communication.
- * @details	Uses local pool calls but is thread safe by protecting the call
- * 			with a lock.
- * @author 	Bastian Baetz
- */
-template <uint8_t NUMBER_OF_POOLS = 5>
-class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
-public:
-	PoolManager(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS]);
-
-	//! @brief	In the PoolManager's destructor all allocated memory is freed.
-	virtual ~PoolManager();
-
-	//! @brief LocalPool overrides for thread-safety. Decorator function which
-	//! 	   wraps LocalPool calls with a mutex protection.
-	ReturnValue_t deleteData(store_address_t) override;
-	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
-			store_address_t* storeId = nullptr) override;
-
-protected:
-	//! Default mutex timeout value to prevent permanent blocking.
-	static constexpr uint32_t mutexTimeout = 50;
-
-	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
-			bool ignoreFault) override;
-
-	/**
-	 * @brief	The mutex is created in the constructor and makes
-	 * 			access mutual exclusive.
-	 * @details	Locking and unlocking is done during searching for free slots
-	 * 			and deleting existing slots.
-	 */
-	MutexIF* mutex;
-};
-
-#include "PoolManager.tpp"
-
-#endif /* POOLMANAGER_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+
+#include "../storagemanager/LocalPool.h"
+#include "../ipc/MutexHelper.h"
+#include "../storagemanager/StorageAccessor.h"
+
+/**
+ * @brief	The PoolManager class provides an intermediate data storage with
+ * 			a fixed pool size policy for inter-process communication.
+ * @details	Uses local pool calls but is thread safe by protecting the call
+ * 			with a lock.
+ * @author 	Bastian Baetz
+ */
+template <uint8_t NUMBER_OF_POOLS = 5>
+class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
+public:
+	PoolManager(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS]);
+
+	//! @brief	In the PoolManager's destructor all allocated memory is freed.
+	virtual ~PoolManager();
+
+	//! @brief LocalPool overrides for thread-safety. Decorator function which
+	//! 	   wraps LocalPool calls with a mutex protection.
+	ReturnValue_t deleteData(store_address_t) override;
+	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = nullptr) override;
+
+protected:
+	//! Default mutex timeout value to prevent permanent blocking.
+	static constexpr uint32_t mutexTimeout = 50;
+
+	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
+			bool ignoreFault) override;
+
+	/**
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking is done during searching for free slots
+	 * 			and deleting existing slots.
+	 */
+	MutexIF* mutex;
+};
+
+#include "PoolManager.tpp"
+
+#endif /* POOLMANAGER_H_ */
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index b827b9c06..d4d2a54d8 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,67 +1,67 @@
-#include <framework/storagemanager/StorageAccessor.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-StorageAccessor::StorageAccessor(store_address_t storeId):
-		ConstStorageAccessor(storeId) {
-}
-
-StorageAccessor::StorageAccessor(store_address_t storeId,
-		StorageManagerIF* store):
-		ConstStorageAccessor(storeId, store) {
-}
-
-StorageAccessor& StorageAccessor::operator =(
-		StorageAccessor&& other) {
-	// Call the parent move assignment and also assign own member.
-	dataPointer = other.dataPointer;
-	StorageAccessor::operator=(std::move(other));
-	return * this;
-}
-
-// Call the parent move ctor and also transfer own member.
-StorageAccessor::StorageAccessor(StorageAccessor&& other):
-		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
-}
-
-ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large "
-				"enough" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(dataPointer, dataPointer + size_, pointer);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint8_t* StorageAccessor::data() {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return dataPointer;
-}
-
-ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
-		uint16_t offset) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(offset + size > size_) {
-		sif::error << "StorageAccessor: Data too large for pool "
-				"entry!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(data, data + size, dataPointer + offset);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void StorageAccessor::assignConstPointer() {
-	constDataPointer = dataPointer;
-}
-
-
+#include "../storagemanager/StorageAccessor.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+StorageAccessor::StorageAccessor(store_address_t storeId):
+		ConstStorageAccessor(storeId) {
+}
+
+StorageAccessor::StorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		ConstStorageAccessor(storeId, store) {
+}
+
+StorageAccessor& StorageAccessor::operator =(
+		StorageAccessor&& other) {
+	// Call the parent move assignment and also assign own member.
+	dataPointer = other.dataPointer;
+	StorageAccessor::operator=(std::move(other));
+	return * this;
+}
+
+// Call the parent move ctor and also transfer own member.
+StorageAccessor::StorageAccessor(StorageAccessor&& other):
+		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+}
+
+ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large "
+				"enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(dataPointer, dataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t* StorageAccessor::data() {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return dataPointer;
+}
+
+ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
+		uint16_t offset) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(offset + size > size_) {
+		sif::error << "StorageAccessor: Data too large for pool "
+				"entry!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(data, data + size, dataPointer + offset);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void StorageAccessor::assignConstPointer() {
+	constDataPointer = dataPointer;
+}
+
+
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index d75e06ac8..1ca5f7ddc 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,45 +1,45 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
-
-#include <framework/storagemanager/ConstStorageAccessor.h>
-
-class StorageManagerIF;
-
-/**
- * @brief   Child class for modifyable data. Also has a normal pointer member.
- */
-class StorageAccessor: public ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	StorageAccessor(store_address_t storeId);
-	StorageAccessor(store_address_t storeId, StorageManagerIF* store);
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being freed prematurely.
-	 * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * 		move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	StorageAccessor& operator=(StorageAccessor&&);
-	StorageAccessor(StorageAccessor&&);
-
-	ReturnValue_t write(uint8_t *data, size_t size,
-		uint16_t offset = 0);
-	uint8_t* data();
-	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
-
-private:
-	//! Non-const pointer for modifyable data.
-	uint8_t* dataPointer = nullptr;
-	//! For modifyable data, the const pointer is assigned to the normal
-	//! pointer by the pool manager so both access functions can be used safely
-	void assignConstPointer();
-};
-
-#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+
+#include "../storagemanager/ConstStorageAccessor.h"
+
+class StorageManagerIF;
+
+/**
+ * @brief   Child class for modifyable data. Also has a normal pointer member.
+ */
+class StorageAccessor: public ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	StorageAccessor(store_address_t storeId);
+	StorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being freed prematurely.
+	 * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * 		move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	StorageAccessor& operator=(StorageAccessor&&);
+	StorageAccessor(StorageAccessor&&);
+
+	ReturnValue_t write(uint8_t *data, size_t size,
+		uint16_t offset = 0);
+	uint8_t* data();
+	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
+
+private:
+	//! Non-const pointer for modifyable data.
+	uint8_t* dataPointer = nullptr;
+	//! For modifyable data, the const pointer is assigned to the normal
+	//! pointer by the pool manager so both access functions can be used safely
+	void assignConstPointer();
+};
+
+#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index f8aee8198..85341f2e8 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -1,167 +1,167 @@
-#ifndef STORAGEMANAGERIF_H_H
-#define STORAGEMANAGERIF_H_H
-
-#include <framework/events/Event.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/storagemanager/StorageAccessor.h>
-#include <framework/storagemanager/storeAddress.h>
-#include <utility>
-#include <cstddef>
-
-using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
-using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
-
-/**
- * @brief	This class provides an interface for intermediate data storage.
- * @details	The Storage manager classes shall be used to store larger chunks of
- * 			data in RAM for exchange between tasks. This interface expects the
- * 			data to be stored in one consecutive block of memory, so tasks can
- * 			write directly to the destination pointer.
- * 			For interprocess communication, the stores must be locked during
- * 			insertion and deletion. If the receiving storage identifier is
- * 			passed token-like between tasks, a lock during read and write
- * 			operations is not necessary.
- * @author	Bastian Baetz
- * @date	18.09.2012
- */
-class StorageManagerIF : public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
-	static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
-	static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
-	static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
-	static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
-	static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
-	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-
-	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
-	/**
-	 * @brief This is the empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~StorageManagerIF() {
-	}
-	;
-	/**
-	 * @brief	With addData, a free storage position is allocated and data
-	 * 			stored there.
-	 * @details	During the allocation, the StorageManager is blocked.
-	 * @param storageId A pointer to the storageId to retrieve.
-	 * @param data	The data to be stored in the StorageManager.
-	 * @param size	The amount of data to be stored.
-	 * @return	Returns @li RETURN_OK if data was added.
-	 * 					@li	RETURN_FAILED if data could not be added.
-	 * 						storageId is unchanged then.
-	 */
-	virtual ReturnValue_t addData(store_address_t* storageId,
-			const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
-	/**
-	 * @brief	With deleteData, the storageManager frees the memory region
-	 * 			identified by packet_id.
-	 * @param packet_id	The identifier of the memory region to be freed.
-	 * @return	@li RETURN_OK on success.
-	 * 			@li	RETURN_FAILED if deletion did not work
-	 * 				(e.g. an illegal packet_id was passed).
-	 */
-	virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
-	/**
-	 * @brief	Another deleteData which uses the pointer and size of the
-	 * 			stored data to delete the content.
-	 * @param buffer	Pointer to the data.
-	 * @param size		Size of data to be stored.
-	 * @param storeId	Store id of the deleted element (optional)
-	 * @return	@li RETURN_OK on success.
-	 * 			@li	failure code if deletion did not work
-	 */
-	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
-			store_address_t* storeId = nullptr) = 0;
-
-
-	/**
-	 * @brief 	Access the data by supplying a store ID.
-	 * @details
-	 * A pair consisting of the retrieval result and an instance of a
-	 * ConstStorageAccessor class is returned
-	 * @param storeId
-	 * @return Pair of return value and a ConstStorageAccessor instance
-	 */
-	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
-
-	/**
-	 * @brief 	Access the data by supplying a store ID and a helper
-	 * 			instance
-	 * @param storeId
-	 * @param constAccessor Wrapper function to access store data.
-	 * @return
-	 */
-	virtual ReturnValue_t getData(store_address_t storeId,
-			ConstStorageAccessor& constAccessor) = 0;
-
-
-	/**
-	 * @brief	getData returns an address to data and the size of the data
-	 * 			for a given packet_id.
-	 * @param packet_id		The id of the data to be returned
-	 * @param packet_ptr	The passed pointer address is set to the the memory
-	 * 						position
-	 * @param size			The exact size of the stored data is returned here.
-	 * @return	@li RETURN_OK on success.
-	 * 			@li	RETURN_FAILED if fetching data did not work
-	 * 				(e.g. an illegal packet_id was passed).
-	 */
-	virtual ReturnValue_t getData(store_address_t packet_id,
-			const uint8_t** packet_ptr, size_t* size) = 0;
-
-
-	/**
-	 * Modify data by supplying a store ID
-	 * @param storeId
-	 * @return Pair of return value and StorageAccessor helper
-	 */
-	virtual AccessorPair modifyData(store_address_t storeId) = 0;
-
-	/**
-	 * Modify data by supplying a store ID and a StorageAccessor helper instance.
-	 * @param storeId
-	 * @param accessor Helper class to access the modifiable data.
-	 * @return
-	 */
-	virtual ReturnValue_t modifyData(store_address_t storeId,
-				StorageAccessor& accessor) = 0;
-
-	/**
-	 * Get pointer and size of modifiable data by supplying the storeId
-	 * @param packet_id
-	 * @param packet_ptr [out] Pointer to pointer of data to set
-	 * @param size [out] Pointer to size to set
-	 * @return
-	 */
-	virtual ReturnValue_t modifyData(store_address_t packet_id,
-			uint8_t** packet_ptr, size_t* size) = 0;
-	/**
-	 * This method reserves an element of \c size.
-	 *
-	 * It returns the packet id of this element as well as a direct pointer to the
-	 * data of the element. It must be assured that exactly \c size data is
-	 * written to p_data!
-	 * @param storageId A pointer to the storageId to retrieve.
-	 * @param size		The size of the space to be reserved.
-	 * @param p_data	A pointer to the element data is returned here.
-	 * @return	Returns @li RETURN_OK if data was added.
-	 * 					@li	RETURN_FAILED if data could not be added.
-	 * 						storageId is unchanged then.
-	 */
-	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
-			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
-
-	/**
-	 * Clears the whole store.
-	 * Use with care!
-	 */
-	virtual void clearStore() = 0;
-};
-
-#endif /* STORAGEMANAGERIF_H_ */
+#ifndef STORAGEMANAGERIF_H_H
+#define STORAGEMANAGERIF_H_H
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageAccessor.h"
+#include "../storagemanager/storeAddress.h"
+#include <utility>
+#include <cstddef>
+
+using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
+using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
+
+/**
+ * @brief	This class provides an interface for intermediate data storage.
+ * @details	The Storage manager classes shall be used to store larger chunks of
+ * 			data in RAM for exchange between tasks. This interface expects the
+ * 			data to be stored in one consecutive block of memory, so tasks can
+ * 			write directly to the destination pointer.
+ * 			For interprocess communication, the stores must be locked during
+ * 			insertion and deletion. If the receiving storage identifier is
+ * 			passed token-like between tasks, a lock during read and write
+ * 			operations is not necessary.
+ * @author	Bastian Baetz
+ * @date	18.09.2012
+ */
+class StorageManagerIF : public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
+	static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
+	static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
+	static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
+	static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
+	static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
+	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+
+	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
+	/**
+	 * @brief This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~StorageManagerIF() {
+	}
+	;
+	/**
+	 * @brief	With addData, a free storage position is allocated and data
+	 * 			stored there.
+	 * @details	During the allocation, the StorageManager is blocked.
+	 * @param storageId A pointer to the storageId to retrieve.
+	 * @param data	The data to be stored in the StorageManager.
+	 * @param size	The amount of data to be stored.
+	 * @return	Returns @li RETURN_OK if data was added.
+	 * 					@li	RETURN_FAILED if data could not be added.
+	 * 						storageId is unchanged then.
+	 */
+	virtual ReturnValue_t addData(store_address_t* storageId,
+			const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
+	/**
+	 * @brief	With deleteData, the storageManager frees the memory region
+	 * 			identified by packet_id.
+	 * @param packet_id	The identifier of the memory region to be freed.
+	 * @return	@li RETURN_OK on success.
+	 * 			@li	RETURN_FAILED if deletion did not work
+	 * 				(e.g. an illegal packet_id was passed).
+	 */
+	virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
+	/**
+	 * @brief	Another deleteData which uses the pointer and size of the
+	 * 			stored data to delete the content.
+	 * @param buffer	Pointer to the data.
+	 * @param size		Size of data to be stored.
+	 * @param storeId	Store id of the deleted element (optional)
+	 * @return	@li RETURN_OK on success.
+	 * 			@li	failure code if deletion did not work
+	 */
+	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = nullptr) = 0;
+
+
+	/**
+	 * @brief 	Access the data by supplying a store ID.
+	 * @details
+	 * A pair consisting of the retrieval result and an instance of a
+	 * ConstStorageAccessor class is returned
+	 * @param storeId
+	 * @return Pair of return value and a ConstStorageAccessor instance
+	 */
+	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
+
+	/**
+	 * @brief 	Access the data by supplying a store ID and a helper
+	 * 			instance
+	 * @param storeId
+	 * @param constAccessor Wrapper function to access store data.
+	 * @return
+	 */
+	virtual ReturnValue_t getData(store_address_t storeId,
+			ConstStorageAccessor& constAccessor) = 0;
+
+
+	/**
+	 * @brief	getData returns an address to data and the size of the data
+	 * 			for a given packet_id.
+	 * @param packet_id		The id of the data to be returned
+	 * @param packet_ptr	The passed pointer address is set to the the memory
+	 * 						position
+	 * @param size			The exact size of the stored data is returned here.
+	 * @return	@li RETURN_OK on success.
+	 * 			@li	RETURN_FAILED if fetching data did not work
+	 * 				(e.g. an illegal packet_id was passed).
+	 */
+	virtual ReturnValue_t getData(store_address_t packet_id,
+			const uint8_t** packet_ptr, size_t* size) = 0;
+
+
+	/**
+	 * Modify data by supplying a store ID
+	 * @param storeId
+	 * @return Pair of return value and StorageAccessor helper
+	 */
+	virtual AccessorPair modifyData(store_address_t storeId) = 0;
+
+	/**
+	 * Modify data by supplying a store ID and a StorageAccessor helper instance.
+	 * @param storeId
+	 * @param accessor Helper class to access the modifiable data.
+	 * @return
+	 */
+	virtual ReturnValue_t modifyData(store_address_t storeId,
+				StorageAccessor& accessor) = 0;
+
+	/**
+	 * Get pointer and size of modifiable data by supplying the storeId
+	 * @param packet_id
+	 * @param packet_ptr [out] Pointer to pointer of data to set
+	 * @param size [out] Pointer to size to set
+	 * @return
+	 */
+	virtual ReturnValue_t modifyData(store_address_t packet_id,
+			uint8_t** packet_ptr, size_t* size) = 0;
+	/**
+	 * This method reserves an element of \c size.
+	 *
+	 * It returns the packet id of this element as well as a direct pointer to the
+	 * data of the element. It must be assured that exactly \c size data is
+	 * written to p_data!
+	 * @param storageId A pointer to the storageId to retrieve.
+	 * @param size		The size of the space to be reserved.
+	 * @param p_data	A pointer to the element data is returned here.
+	 * @return	Returns @li RETURN_OK if data was added.
+	 * 					@li	RETURN_FAILED if data could not be added.
+	 * 						storageId is unchanged then.
+	 */
+	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
+			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+
+	/**
+	 * Clears the whole store.
+	 * Use with care!
+	 */
+	virtual void clearStore() = 0;
+};
+
+#endif /* STORAGEMANAGERIF_H_ */
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index fcf2e1891..a4869eba4 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -1,662 +1,662 @@
-#include <framework/health/HealthMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serialize/SerialArrayListAdapter.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/subsystem/Subsystem.h>
-#include <string>
-
-Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
-		uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) :
-		SubsystemBase(setObjectId, parent, 0), isInTransition(false), childrenChangedHealth(
-				false), uptimeStartTable(0), currentTargetTable(), targetMode(
-				0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables(
-				maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore(
-		NULL)
-#ifdef USE_MODESTORE
-,modeStore(NULL)
-#endif
-{
-
-}
-
-Subsystem::~Subsystem() {
-	//Auto-generated destructor stub
-}
-
-ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
-		Mode_t fallbackSequence) {
-
-	//only check for existence, checking the fallback would lead to a (possibly infinite) recursion.
-	//the fallback sequence will be checked when it is needed.
-	if (!existsModeSequence(fallbackSequence)) {
-		return FALLBACK_SEQUENCE_DOES_NOT_EXIST;
-	}
-
-	if (iter.value == NULL) {
-		return NO_TARGET_TABLE;
-	}
-
-	for (; iter.value != NULL; ++iter) {
-		if (!existsModeTable(iter->getTableId())) {
-			return TABLE_DOES_NOT_EXIST;
-		} else {
-			ReturnValue_t result = checkTable(getTable(iter->getTableId()));
-			if (result != RETURN_OK) {
-				return result;
-			}
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t Subsystem::checkSequence(Mode_t sequence) {
-	if (!existsModeSequence(sequence)) {
-		return SEQUENCE_DOES_NOT_EXIST;
-	}
-	HybridIterator<ModeListEntry> iter = getSequence(sequence);
-	return checkSequence(iter, getFallbackSequence(sequence));
-}
-
-bool Subsystem::existsModeSequence(Mode_t id) {
-	return modeSequences.exists(id) == RETURN_OK;
-}
-
-bool Subsystem::existsModeTable(Mode_t id) {
-	return modeTables.exists(id) == RETURN_OK;
-}
-
-HybridIterator<ModeListEntry> Subsystem::getCurrentTable() {
-	return getTable(currentSequenceIterator->getTableId());
-}
-
-void Subsystem::performChildOperation() {
-	if (isInTransition) {
-		if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
-			if (currentSequenceIterator.value == NULL) { //we're through with this sequence
-				if (checkStateAgainstTable(currentTargetTable, targetSubmode)
-						== RETURN_OK) {
-					setMode(targetMode, targetSubmode);
-					isInTransition = false;
-					return;
-				} else {
-					transitionFailed(TARGET_TABLE_NOT_REACHED,
-							getSequence(targetMode)->getTableId());
-					return;
-				}
-			}
-			if (currentSequenceIterator->checkSuccess()) {
-				if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
-						!= RETURN_OK) {
-					transitionFailed(TABLE_CHECK_FAILED,
-							currentSequenceIterator->getTableId());
-					return;
-				}
-			}
-			if (currentSequenceIterator->getWaitSeconds() != 0) {
-				if (uptimeStartTable == 0) {
-					Clock::getUptime(&uptimeStartTable);
-					return;
-				} else {
-					uint32_t uptimeNow;
-					Clock::getUptime(&uptimeNow);
-					if ((uptimeNow - uptimeStartTable)
-							< (currentSequenceIterator->getWaitSeconds() * 1000)) {
-						return;
-					}
-				}
-			}
-			uptimeStartTable = 0;
-			//next Table, but only if there is one
-			if ((++currentSequenceIterator).value != NULL) { //we're through with this sequence
-				executeTable(getCurrentTable(), targetSubmode);
-			}
-		}
-	} else {
-		if (childrenChangedHealth) {
-			triggerEvent(CHILD_CHANGED_HEALTH, 0, 0);
-			childrenChangedHealth = false;
-			startTransition(mode, submode);
-		} else if (childrenChangedMode) {
-			if (checkStateAgainstTable(currentTargetTable, submode)
-					!= RETURN_OK) {
-				triggerEvent(CANT_KEEP_MODE, mode, submode);
-				cantKeepMode();
-			}
-		}
-	}
-}
-
-HybridIterator<ModeListEntry> Subsystem::getSequence(Mode_t id) {
-	SequenceInfo *sequenceInfo = modeSequences.findValue(id);
-	if (sequenceInfo->entries.islinked) {
-		return HybridIterator<ModeListEntry>(
-				sequenceInfo->entries.firstLinkedElement);
-	} else {
-		return HybridIterator<ModeListEntry>(
-				sequenceInfo->entries.array->front(),
-				sequenceInfo->entries.array->back());
-	}
-}
-
-HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
-	EntryPointer *entry = modeTables.findValue(id);
-	if (entry->islinked) {
-		return HybridIterator<ModeListEntry>(entry->firstLinkedElement);
-	} else {
-		return HybridIterator<ModeListEntry>(entry->array->front(),
-				entry->array->back());
-	}
-}
-
-ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
-	ReturnValue_t result;
-	switch (message->getCommand()) {
-	case HealthMessage::HEALTH_INFO: {
-		HealthState health = HealthMessage::getHealth(message);
-		if (health != EXTERNAL_CONTROL) {
-			//Ignore external control, as it has an effect only if the mode changes,
-			//which is communicated with an additional mode info event.
-			childrenChangedHealth = true;
-		}
-	}
-		break;
-	case ModeSequenceMessage::ADD_SEQUENCE: {
-		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
-		const uint8_t *pointer;
-		size_t sizeRead;
-		result = IPCStore->getData(
-				ModeSequenceMessage::getStoreAddress(message), &pointer,
-				&sizeRead);
-		if (result == RETURN_OK) {
-			Mode_t fallbackId;
-			size_t size = sizeRead;
-			result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
-					SerializeIF::Endianness::BIG);
-			if (result == RETURN_OK) {
-				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
-						&sequence, &pointer, &size,
-						SerializeIF::Endianness::BIG);
-				if (result == RETURN_OK) {
-					result = addSequence(&sequence,
-							ModeSequenceMessage::getSequenceId(message),
-							fallbackId);
-				}
-			}
-			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
-		}
-		replyToCommand(result, 0);
-	}
-		break;
-	case ModeSequenceMessage::ADD_TABLE: {
-		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
-		const uint8_t *pointer;
-		size_t sizeRead;
-		result = IPCStore->getData(
-				ModeSequenceMessage::getStoreAddress(message), &pointer,
-				&sizeRead);
-		if (result == RETURN_OK) {
-			size_t size = sizeRead;
-			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
-					&pointer, &size, SerializeIF::Endianness::BIG);
-			if (result == RETURN_OK) {
-				result = addTable(&table,
-						ModeSequenceMessage::getSequenceId(message));
-			}
-			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
-		}
-		replyToCommand(result, 0);
-
-	}
-		break;
-	case ModeSequenceMessage::DELETE_SEQUENCE:
-		if (isInTransition) {
-			replyToCommand(IN_TRANSITION, 0);
-			break;
-		}
-		result = deleteSequence(ModeSequenceMessage::getSequenceId(message));
-		replyToCommand(result, 0);
-		break;
-	case ModeSequenceMessage::DELETE_TABLE:
-		if (isInTransition) {
-			replyToCommand(IN_TRANSITION, 0);
-			break;
-		}
-		result = deleteTable(ModeSequenceMessage::getTableId(message));
-		replyToCommand(result, 0);
-		break;
-	case ModeSequenceMessage::LIST_SEQUENCES: {
-		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> sequences;
-		FixedMap<Mode_t, SequenceInfo>::Iterator iter;
-		for (iter = modeSequences.begin(); iter != modeSequences.end();
-				++iter) {
-			sequences.insert(iter.value->first);
-		}
-		SerializeIF *pointer = &sequences;
-		sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE_LIST,
-				&pointer, 1);
-	}
-		break;
-	case ModeSequenceMessage::LIST_TABLES: {
-		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> tables;
-		FixedMap<Mode_t, EntryPointer>::Iterator iter;
-		for (iter = modeTables.begin(); iter != modeTables.end(); ++iter) {
-			tables.insert(iter.value->first);
-		}
-		SerializeIF *pointer = &tables;
-		sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE_LIST,
-				&pointer, 1);
-	}
-		break;
-	case ModeSequenceMessage::READ_SEQUENCE: {
-		ReturnValue_t result;
-		Mode_t sequence = ModeSequenceMessage::getSequenceId(message);
-		SequenceInfo *sequenceInfo = NULL;
-		result = modeSequences.find(sequence, &sequenceInfo);
-		if (result != RETURN_OK) {
-			replyToCommand(result, 0);
-		}
-
-		SerializeIF *elements[3];
-		SerializeElement<Mode_t> sequenceId(sequence);
-		SerializeElement<Mode_t> fallbackSequenceId(
-				getFallbackSequence(sequence));
-
-		elements[0] = &sequenceId;
-		elements[1] = &fallbackSequenceId;
-
-		if (sequenceInfo->entries.islinked) {
-			SerialLinkedListAdapter<ModeListEntry> list(
-					sequenceInfo->entries.firstLinkedElement, true);
-			elements[2] = &list;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
-					elements, 3);
-		} else {
-			SerialArrayListAdapter<ModeListEntry> serializableArray(
-					sequenceInfo->entries.array);
-
-			elements[2] = &serializableArray;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
-					elements, 3);
-		}
-	}
-		break;
-	case ModeSequenceMessage::READ_TABLE: {
-		ReturnValue_t result;
-		Mode_t table = ModeSequenceMessage::getSequenceId(message);
-		EntryPointer *entry = NULL;
-		result = modeTables.find(table, &entry);
-		if (result != RETURN_OK) {
-			replyToCommand(result, 0);
-		}
-
-		SerializeIF *elements[2];
-		SerializeElement<Mode_t> tableId(table);
-
-		elements[0] = &tableId;
-
-		if (entry->islinked) {
-			SerialLinkedListAdapter<ModeListEntry> list(
-					entry->firstLinkedElement, true);
-			elements[1] = &list;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
-					elements, 2);
-		} else {
-			SerialArrayListAdapter<ModeListEntry> serializableArray(
-					entry->array);
-			elements[1] = &serializableArray;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
-					elements, 2);
-		}
-	}
-		break;
-	case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
-		uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
-		CommandMessage reply;
-		ModeSequenceMessage::setModeSequenceMessage(&reply,
-				ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
-		commandQueue->reply(&reply);
-	}
-		break;
-	case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
-		uint32_t free = modeTables.maxSize() - modeTables.size();
-		CommandMessage reply;
-		ModeSequenceMessage::setModeSequenceMessage(&reply,
-				ModeSequenceMessage::FREE_TABLE_SLOTS, free);
-		commandQueue->reply(&reply);
-	}
-		break;
-	default:
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
-	if (status == RETURN_OK) {
-		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
-		commandQueue->reply(&reply);
-	} else {
-		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0);
-		commandQueue->reply(&reply);
-	}
-}
-
-ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
-		Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
-
-	ReturnValue_t result;
-
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
-	//Sequences added before are checked by initialize()
-	if (!preInit) {
-		result = checkSequence(
-				HybridIterator<ModeListEntry>(sequence->front(),
-						sequence->back()), fallbackSequence);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-
-	SequenceInfo info;
-
-	info.fallbackSequence = fallbackSequence;
-
-	info.entries.islinked = inStore;
-	info.entries.array = sequence;
-
-	result = modeSequences.insert(id, info);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	if (inStore) {
-#ifdef USE_MODESTORE
-		result = modeStore->storeArray(sequence,
-				&(modeSequences.find(id)->entries.firstLinkedElement));
-		if (result != RETURN_OK) {
-			modeSequences.erase(id);
-		}
-#else
-		modeSequences.erase(id);
-		return RETURN_FAILED;
-#endif
-	}
-
-	return result;
-
-}
-
-ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
-		bool inStore, bool preInit) {
-
-	ReturnValue_t result;
-
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
-	//Tables added before are checked by initialize()
-	if (!preInit) {
-		result = checkTable(
-				HybridIterator<ModeListEntry>(table->front(), table->back()));
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-
-	EntryPointer pointer;
-
-	pointer.islinked = inStore;
-	pointer.array = table;
-
-	result = modeTables.insert(id, pointer);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	if (inStore) {
-#ifdef USE_MODESTORE
-		result = modeStore->storeArray(table,
-				&(modeTables.find(id)->firstLinkedElement));
-		if (result != RETURN_OK) {
-			modeTables.erase(id);
-		}
-#else
-		modeTables.erase(id);
-		return RETURN_FAILED;
-#endif
-	}
-	return result;
-}
-
-ReturnValue_t Subsystem::deleteSequence(Mode_t id) {
-
-	if (isFallbackSequence(id)) {
-		return IS_FALLBACK_SEQUENCE;
-	}
-
-	SequenceInfo *sequenceInfo;
-	ReturnValue_t result;
-	result = modeSequences.find(id, &sequenceInfo);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (!sequenceInfo->entries.islinked) {
-		return ACCESS_DENIED;
-	}
-
-#ifdef USE_MODESTORE
-	modeStore->deleteList(sequenceInfo->entries.firstLinkedElement);
-#endif
-	modeSequences.erase(id);
-	return RETURN_OK;
-}
-
-ReturnValue_t Subsystem::deleteTable(Mode_t id) {
-
-	if (isTableUsed(id)) {
-		return TABLE_IN_USE;
-	}
-
-	EntryPointer *pointer;
-	ReturnValue_t result;
-	result = modeTables.find(id, &pointer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (!pointer->islinked) {
-		return ACCESS_DENIED;
-	}
-
-#ifdef USE_MODESTORE
-	modeStore->deleteList(pointer->firstLinkedElement);
-#endif
-	modeSequences.erase(id);
-	return RETURN_OK;
-}
-
-ReturnValue_t Subsystem::initialize() {
-	ReturnValue_t result = SubsystemBase::initialize();
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (IPCStore == NULL) {
-		return RETURN_FAILED;
-	}
-
-#ifdef USE_MODESTORE
-	modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
-
-	if (modeStore == NULL) {
-		return RETURN_FAILED;
-	}
-#endif
-
-	if ((modeSequences.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)
-			|| (modeTables.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)) {
-		return TABLE_OR_SEQUENCE_LENGTH_INVALID;
-	}
-
-	mode = initialMode;
-
-	return RETURN_OK;
-}
-
-MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
-	return SubsystemBase::getCommandQueue();
-}
-
-ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
-		uint32_t *msToReachTheMode) {
-	//Need to accept all submodes to be able to inherit submodes
-//	if (submode != SUBMODE_NONE) {
-//		return INVALID_SUBMODE;
-//	}
-
-	if (isInTransition && (mode != getFallbackSequence(targetMode))) {
-		return HasModesIF::IN_TRANSITION;
-	} else {
-		return checkSequence(mode);
-	}
-}
-
-void Subsystem::startTransition(Mode_t sequence, Submode_t submode) {
-	if (modeHelper.isForced()) {
-		triggerEvent(FORCING_MODE, sequence, submode);
-	} else {
-		triggerEvent(CHANGING_MODE, sequence, submode);
-	}
-	targetMode = sequence;
-	targetSubmode = submode;
-	isInTransition = true;
-	commandsOutstanding = 0;
-	currentSequenceIterator = getSequence(sequence);
-
-	currentTargetTable = getTable(currentSequenceIterator->getTableId());
-
-	++currentSequenceIterator;
-
-	if (currentSequenceIterator.value != NULL) {
-		executeTable(getCurrentTable(), targetSubmode);
-	}
-}
-
-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 -1;
-}
-
-bool Subsystem::isFallbackSequence(Mode_t SequenceId) {
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
-			iter != modeSequences.end(); iter++) {
-		if (iter->fallbackSequence == SequenceId) {
-			return true;
-		}
-	}
-	return false;
-}
-
-bool Subsystem::isTableUsed(Mode_t tableId) {
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator sequence =
-			modeSequences.begin(); sequence != modeSequences.end();
-			sequence++) {
-		HybridIterator<ModeListEntry> sequenceIterator = getSequence(
-				sequence.value->first);
-		while (sequenceIterator.value != NULL) {
-			if (sequenceIterator->getTableId() == tableId) {
-				return true;
-			}
-			++sequenceIterator;
-		}
-	}
-	return false;
-}
-
-void Subsystem::transitionFailed(ReturnValue_t failureCode,
-		uint32_t parameter) {
-	triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter);
-	if (mode == targetMode) {
-		//already tried going back to the current mode
-		//go into fallback mode, also set current mode to fallback mode, so we come here at the next fail
-		modeHelper.setForced(true);
-		ReturnValue_t result;
-		if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
-			triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
-			isInTransition = false; //keep still and allow arbitrary mode commands to recover
-			return;
-		}
-		mode = getFallbackSequence(mode);
-		startTransition(mode, submode);
-	} else {
-		//try to go back to the current mode
-		startTransition(mode, submode);
-	}
-}
-
-void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
-		SerializeIF **elements, uint8_t count) {
-	ReturnValue_t result;
-	size_t maxSize = 0;
-	for (uint8_t i = 0; i < count; i++) {
-		maxSize += elements[i]->getSerializedSize();
-	}
-	uint8_t *storeBuffer;
-	store_address_t address;
-	size_t size = 0;
-
-	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		replyToCommand(result, 0);
-		return;
-	}
-	for (uint8_t i = 0; i < count; i++) {
-		elements[i]->serialize(&storeBuffer, &size, maxSize,
-				SerializeIF::Endianness::BIG);
-	}
-	CommandMessage reply;
-	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
-	if (commandQueue->reply(&reply) != RETURN_OK) {
-		IPCStore->deleteData(address);
-	}
-}
-
-ReturnValue_t Subsystem::checkObjectConnections() {
-	ReturnValue_t result = RETURN_OK;
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
-			iter != modeSequences.end(); iter++) {
-		result = checkSequence(iter.value->first);
-		if (result != RETURN_OK) {
-			return result;
-		}
-
-	}
-	return RETURN_OK;
-}
-
-void Subsystem::setInitialMode(Mode_t mode) {
-	initialMode = mode;
-}
-
-void Subsystem::cantKeepMode() {
-	ReturnValue_t result;
-	if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
-		triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
-		return;
-	}
-
-	modeHelper.setForced(true);
-
-	//already set the mode, so that we do not try to go back in our old mode when the transition fails
-	mode = getFallbackSequence(mode);
-	//SHOULDDO: We should store submodes for fallback sequence as well, otherwise we should get rid of submodes completely.
-	startTransition(mode, SUBMODE_NONE);
-}
+#include "../health/HealthMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../subsystem/Subsystem.h"
+#include <string>
+
+Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
+		uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) :
+		SubsystemBase(setObjectId, parent, 0), isInTransition(false), childrenChangedHealth(
+				false), uptimeStartTable(0), currentTargetTable(), targetMode(
+				0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables(
+				maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore(
+		NULL)
+#ifdef USE_MODESTORE
+,modeStore(NULL)
+#endif
+{
+
+}
+
+Subsystem::~Subsystem() {
+	//Auto-generated destructor stub
+}
+
+ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
+		Mode_t fallbackSequence) {
+
+	//only check for existence, checking the fallback would lead to a (possibly infinite) recursion.
+	//the fallback sequence will be checked when it is needed.
+	if (!existsModeSequence(fallbackSequence)) {
+		return FALLBACK_SEQUENCE_DOES_NOT_EXIST;
+	}
+
+	if (iter.value == NULL) {
+		return NO_TARGET_TABLE;
+	}
+
+	for (; iter.value != NULL; ++iter) {
+		if (!existsModeTable(iter->getTableId())) {
+			return TABLE_DOES_NOT_EXIST;
+		} else {
+			ReturnValue_t result = checkTable(getTable(iter->getTableId()));
+			if (result != RETURN_OK) {
+				return result;
+			}
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t Subsystem::checkSequence(Mode_t sequence) {
+	if (!existsModeSequence(sequence)) {
+		return SEQUENCE_DOES_NOT_EXIST;
+	}
+	HybridIterator<ModeListEntry> iter = getSequence(sequence);
+	return checkSequence(iter, getFallbackSequence(sequence));
+}
+
+bool Subsystem::existsModeSequence(Mode_t id) {
+	return modeSequences.exists(id) == RETURN_OK;
+}
+
+bool Subsystem::existsModeTable(Mode_t id) {
+	return modeTables.exists(id) == RETURN_OK;
+}
+
+HybridIterator<ModeListEntry> Subsystem::getCurrentTable() {
+	return getTable(currentSequenceIterator->getTableId());
+}
+
+void Subsystem::performChildOperation() {
+	if (isInTransition) {
+		if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
+			if (currentSequenceIterator.value == NULL) { //we're through with this sequence
+				if (checkStateAgainstTable(currentTargetTable, targetSubmode)
+						== RETURN_OK) {
+					setMode(targetMode, targetSubmode);
+					isInTransition = false;
+					return;
+				} else {
+					transitionFailed(TARGET_TABLE_NOT_REACHED,
+							getSequence(targetMode)->getTableId());
+					return;
+				}
+			}
+			if (currentSequenceIterator->checkSuccess()) {
+				if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
+						!= RETURN_OK) {
+					transitionFailed(TABLE_CHECK_FAILED,
+							currentSequenceIterator->getTableId());
+					return;
+				}
+			}
+			if (currentSequenceIterator->getWaitSeconds() != 0) {
+				if (uptimeStartTable == 0) {
+					Clock::getUptime(&uptimeStartTable);
+					return;
+				} else {
+					uint32_t uptimeNow;
+					Clock::getUptime(&uptimeNow);
+					if ((uptimeNow - uptimeStartTable)
+							< (currentSequenceIterator->getWaitSeconds() * 1000)) {
+						return;
+					}
+				}
+			}
+			uptimeStartTable = 0;
+			//next Table, but only if there is one
+			if ((++currentSequenceIterator).value != NULL) { //we're through with this sequence
+				executeTable(getCurrentTable(), targetSubmode);
+			}
+		}
+	} else {
+		if (childrenChangedHealth) {
+			triggerEvent(CHILD_CHANGED_HEALTH, 0, 0);
+			childrenChangedHealth = false;
+			startTransition(mode, submode);
+		} else if (childrenChangedMode) {
+			if (checkStateAgainstTable(currentTargetTable, submode)
+					!= RETURN_OK) {
+				triggerEvent(CANT_KEEP_MODE, mode, submode);
+				cantKeepMode();
+			}
+		}
+	}
+}
+
+HybridIterator<ModeListEntry> Subsystem::getSequence(Mode_t id) {
+	SequenceInfo *sequenceInfo = modeSequences.findValue(id);
+	if (sequenceInfo->entries.islinked) {
+		return HybridIterator<ModeListEntry>(
+				sequenceInfo->entries.firstLinkedElement);
+	} else {
+		return HybridIterator<ModeListEntry>(
+				sequenceInfo->entries.array->front(),
+				sequenceInfo->entries.array->back());
+	}
+}
+
+HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
+	EntryPointer *entry = modeTables.findValue(id);
+	if (entry->islinked) {
+		return HybridIterator<ModeListEntry>(entry->firstLinkedElement);
+	} else {
+		return HybridIterator<ModeListEntry>(entry->array->front(),
+				entry->array->back());
+	}
+}
+
+ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
+	ReturnValue_t result;
+	switch (message->getCommand()) {
+	case HealthMessage::HEALTH_INFO: {
+		HealthState health = HealthMessage::getHealth(message);
+		if (health != EXTERNAL_CONTROL) {
+			//Ignore external control, as it has an effect only if the mode changes,
+			//which is communicated with an additional mode info event.
+			childrenChangedHealth = true;
+		}
+	}
+		break;
+	case ModeSequenceMessage::ADD_SEQUENCE: {
+		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
+		const uint8_t *pointer;
+		size_t sizeRead;
+		result = IPCStore->getData(
+				ModeSequenceMessage::getStoreAddress(message), &pointer,
+				&sizeRead);
+		if (result == RETURN_OK) {
+			Mode_t fallbackId;
+			size_t size = sizeRead;
+			result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
+					SerializeIF::Endianness::BIG);
+			if (result == RETURN_OK) {
+				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
+						&sequence, &pointer, &size,
+						SerializeIF::Endianness::BIG);
+				if (result == RETURN_OK) {
+					result = addSequence(&sequence,
+							ModeSequenceMessage::getSequenceId(message),
+							fallbackId);
+				}
+			}
+			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+		replyToCommand(result, 0);
+	}
+		break;
+	case ModeSequenceMessage::ADD_TABLE: {
+		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
+		const uint8_t *pointer;
+		size_t sizeRead;
+		result = IPCStore->getData(
+				ModeSequenceMessage::getStoreAddress(message), &pointer,
+				&sizeRead);
+		if (result == RETURN_OK) {
+			size_t size = sizeRead;
+			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
+					&pointer, &size, SerializeIF::Endianness::BIG);
+			if (result == RETURN_OK) {
+				result = addTable(&table,
+						ModeSequenceMessage::getSequenceId(message));
+			}
+			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+		replyToCommand(result, 0);
+
+	}
+		break;
+	case ModeSequenceMessage::DELETE_SEQUENCE:
+		if (isInTransition) {
+			replyToCommand(IN_TRANSITION, 0);
+			break;
+		}
+		result = deleteSequence(ModeSequenceMessage::getSequenceId(message));
+		replyToCommand(result, 0);
+		break;
+	case ModeSequenceMessage::DELETE_TABLE:
+		if (isInTransition) {
+			replyToCommand(IN_TRANSITION, 0);
+			break;
+		}
+		result = deleteTable(ModeSequenceMessage::getTableId(message));
+		replyToCommand(result, 0);
+		break;
+	case ModeSequenceMessage::LIST_SEQUENCES: {
+		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> sequences;
+		FixedMap<Mode_t, SequenceInfo>::Iterator iter;
+		for (iter = modeSequences.begin(); iter != modeSequences.end();
+				++iter) {
+			sequences.insert(iter.value->first);
+		}
+		SerializeIF *pointer = &sequences;
+		sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE_LIST,
+				&pointer, 1);
+	}
+		break;
+	case ModeSequenceMessage::LIST_TABLES: {
+		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> tables;
+		FixedMap<Mode_t, EntryPointer>::Iterator iter;
+		for (iter = modeTables.begin(); iter != modeTables.end(); ++iter) {
+			tables.insert(iter.value->first);
+		}
+		SerializeIF *pointer = &tables;
+		sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE_LIST,
+				&pointer, 1);
+	}
+		break;
+	case ModeSequenceMessage::READ_SEQUENCE: {
+		ReturnValue_t result;
+		Mode_t sequence = ModeSequenceMessage::getSequenceId(message);
+		SequenceInfo *sequenceInfo = NULL;
+		result = modeSequences.find(sequence, &sequenceInfo);
+		if (result != RETURN_OK) {
+			replyToCommand(result, 0);
+		}
+
+		SerializeIF *elements[3];
+		SerializeElement<Mode_t> sequenceId(sequence);
+		SerializeElement<Mode_t> fallbackSequenceId(
+				getFallbackSequence(sequence));
+
+		elements[0] = &sequenceId;
+		elements[1] = &fallbackSequenceId;
+
+		if (sequenceInfo->entries.islinked) {
+			SerialLinkedListAdapter<ModeListEntry> list(
+					sequenceInfo->entries.firstLinkedElement, true);
+			elements[2] = &list;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
+					elements, 3);
+		} else {
+			SerialArrayListAdapter<ModeListEntry> serializableArray(
+					sequenceInfo->entries.array);
+
+			elements[2] = &serializableArray;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
+					elements, 3);
+		}
+	}
+		break;
+	case ModeSequenceMessage::READ_TABLE: {
+		ReturnValue_t result;
+		Mode_t table = ModeSequenceMessage::getSequenceId(message);
+		EntryPointer *entry = NULL;
+		result = modeTables.find(table, &entry);
+		if (result != RETURN_OK) {
+			replyToCommand(result, 0);
+		}
+
+		SerializeIF *elements[2];
+		SerializeElement<Mode_t> tableId(table);
+
+		elements[0] = &tableId;
+
+		if (entry->islinked) {
+			SerialLinkedListAdapter<ModeListEntry> list(
+					entry->firstLinkedElement, true);
+			elements[1] = &list;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
+					elements, 2);
+		} else {
+			SerialArrayListAdapter<ModeListEntry> serializableArray(
+					entry->array);
+			elements[1] = &serializableArray;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
+					elements, 2);
+		}
+	}
+		break;
+	case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
+		uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
+		CommandMessage reply;
+		ModeSequenceMessage::setModeSequenceMessage(&reply,
+				ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
+		commandQueue->reply(&reply);
+	}
+		break;
+	case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
+		uint32_t free = modeTables.maxSize() - modeTables.size();
+		CommandMessage reply;
+		ModeSequenceMessage::setModeSequenceMessage(&reply,
+				ModeSequenceMessage::FREE_TABLE_SLOTS, free);
+		commandQueue->reply(&reply);
+	}
+		break;
+	default:
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
+	if (status == RETURN_OK) {
+		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
+		commandQueue->reply(&reply);
+	} else {
+		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0);
+		commandQueue->reply(&reply);
+	}
+}
+
+ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
+		Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
+
+	ReturnValue_t result;
+
+	//Before initialize() is called, tables must not be checked as the children are not added yet.
+	//Sequences added before are checked by initialize()
+	if (!preInit) {
+		result = checkSequence(
+				HybridIterator<ModeListEntry>(sequence->front(),
+						sequence->back()), fallbackSequence);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+
+	SequenceInfo info;
+
+	info.fallbackSequence = fallbackSequence;
+
+	info.entries.islinked = inStore;
+	info.entries.array = sequence;
+
+	result = modeSequences.insert(id, info);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	if (inStore) {
+#ifdef USE_MODESTORE
+		result = modeStore->storeArray(sequence,
+				&(modeSequences.find(id)->entries.firstLinkedElement));
+		if (result != RETURN_OK) {
+			modeSequences.erase(id);
+		}
+#else
+		modeSequences.erase(id);
+		return RETURN_FAILED;
+#endif
+	}
+
+	return result;
+
+}
+
+ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
+		bool inStore, bool preInit) {
+
+	ReturnValue_t result;
+
+	//Before initialize() is called, tables must not be checked as the children are not added yet.
+	//Tables added before are checked by initialize()
+	if (!preInit) {
+		result = checkTable(
+				HybridIterator<ModeListEntry>(table->front(), table->back()));
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+
+	EntryPointer pointer;
+
+	pointer.islinked = inStore;
+	pointer.array = table;
+
+	result = modeTables.insert(id, pointer);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	if (inStore) {
+#ifdef USE_MODESTORE
+		result = modeStore->storeArray(table,
+				&(modeTables.find(id)->firstLinkedElement));
+		if (result != RETURN_OK) {
+			modeTables.erase(id);
+		}
+#else
+		modeTables.erase(id);
+		return RETURN_FAILED;
+#endif
+	}
+	return result;
+}
+
+ReturnValue_t Subsystem::deleteSequence(Mode_t id) {
+
+	if (isFallbackSequence(id)) {
+		return IS_FALLBACK_SEQUENCE;
+	}
+
+	SequenceInfo *sequenceInfo;
+	ReturnValue_t result;
+	result = modeSequences.find(id, &sequenceInfo);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (!sequenceInfo->entries.islinked) {
+		return ACCESS_DENIED;
+	}
+
+#ifdef USE_MODESTORE
+	modeStore->deleteList(sequenceInfo->entries.firstLinkedElement);
+#endif
+	modeSequences.erase(id);
+	return RETURN_OK;
+}
+
+ReturnValue_t Subsystem::deleteTable(Mode_t id) {
+
+	if (isTableUsed(id)) {
+		return TABLE_IN_USE;
+	}
+
+	EntryPointer *pointer;
+	ReturnValue_t result;
+	result = modeTables.find(id, &pointer);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (!pointer->islinked) {
+		return ACCESS_DENIED;
+	}
+
+#ifdef USE_MODESTORE
+	modeStore->deleteList(pointer->firstLinkedElement);
+#endif
+	modeSequences.erase(id);
+	return RETURN_OK;
+}
+
+ReturnValue_t Subsystem::initialize() {
+	ReturnValue_t result = SubsystemBase::initialize();
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (IPCStore == NULL) {
+		return RETURN_FAILED;
+	}
+
+#ifdef USE_MODESTORE
+	modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
+
+	if (modeStore == NULL) {
+		return RETURN_FAILED;
+	}
+#endif
+
+	if ((modeSequences.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)
+			|| (modeTables.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)) {
+		return TABLE_OR_SEQUENCE_LENGTH_INVALID;
+	}
+
+	mode = initialMode;
+
+	return RETURN_OK;
+}
+
+MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
+	return SubsystemBase::getCommandQueue();
+}
+
+ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
+		uint32_t *msToReachTheMode) {
+	//Need to accept all submodes to be able to inherit submodes
+//	if (submode != SUBMODE_NONE) {
+//		return INVALID_SUBMODE;
+//	}
+
+	if (isInTransition && (mode != getFallbackSequence(targetMode))) {
+		return HasModesIF::IN_TRANSITION;
+	} else {
+		return checkSequence(mode);
+	}
+}
+
+void Subsystem::startTransition(Mode_t sequence, Submode_t submode) {
+	if (modeHelper.isForced()) {
+		triggerEvent(FORCING_MODE, sequence, submode);
+	} else {
+		triggerEvent(CHANGING_MODE, sequence, submode);
+	}
+	targetMode = sequence;
+	targetSubmode = submode;
+	isInTransition = true;
+	commandsOutstanding = 0;
+	currentSequenceIterator = getSequence(sequence);
+
+	currentTargetTable = getTable(currentSequenceIterator->getTableId());
+
+	++currentSequenceIterator;
+
+	if (currentSequenceIterator.value != NULL) {
+		executeTable(getCurrentTable(), targetSubmode);
+	}
+}
+
+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 -1;
+}
+
+bool Subsystem::isFallbackSequence(Mode_t SequenceId) {
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
+			iter != modeSequences.end(); iter++) {
+		if (iter->fallbackSequence == SequenceId) {
+			return true;
+		}
+	}
+	return false;
+}
+
+bool Subsystem::isTableUsed(Mode_t tableId) {
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator sequence =
+			modeSequences.begin(); sequence != modeSequences.end();
+			sequence++) {
+		HybridIterator<ModeListEntry> sequenceIterator = getSequence(
+				sequence.value->first);
+		while (sequenceIterator.value != NULL) {
+			if (sequenceIterator->getTableId() == tableId) {
+				return true;
+			}
+			++sequenceIterator;
+		}
+	}
+	return false;
+}
+
+void Subsystem::transitionFailed(ReturnValue_t failureCode,
+		uint32_t parameter) {
+	triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter);
+	if (mode == targetMode) {
+		//already tried going back to the current mode
+		//go into fallback mode, also set current mode to fallback mode, so we come here at the next fail
+		modeHelper.setForced(true);
+		ReturnValue_t result;
+		if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
+			triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
+			isInTransition = false; //keep still and allow arbitrary mode commands to recover
+			return;
+		}
+		mode = getFallbackSequence(mode);
+		startTransition(mode, submode);
+	} else {
+		//try to go back to the current mode
+		startTransition(mode, submode);
+	}
+}
+
+void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
+		SerializeIF **elements, uint8_t count) {
+	ReturnValue_t result;
+	size_t maxSize = 0;
+	for (uint8_t i = 0; i < count; i++) {
+		maxSize += elements[i]->getSerializedSize();
+	}
+	uint8_t *storeBuffer;
+	store_address_t address;
+	size_t size = 0;
+
+	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		replyToCommand(result, 0);
+		return;
+	}
+	for (uint8_t i = 0; i < count; i++) {
+		elements[i]->serialize(&storeBuffer, &size, maxSize,
+				SerializeIF::Endianness::BIG);
+	}
+	CommandMessage reply;
+	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
+	if (commandQueue->reply(&reply) != RETURN_OK) {
+		IPCStore->deleteData(address);
+	}
+}
+
+ReturnValue_t Subsystem::checkObjectConnections() {
+	ReturnValue_t result = RETURN_OK;
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
+			iter != modeSequences.end(); iter++) {
+		result = checkSequence(iter.value->first);
+		if (result != RETURN_OK) {
+			return result;
+		}
+
+	}
+	return RETURN_OK;
+}
+
+void Subsystem::setInitialMode(Mode_t mode) {
+	initialMode = mode;
+}
+
+void Subsystem::cantKeepMode() {
+	ReturnValue_t result;
+	if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
+		triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
+		return;
+	}
+
+	modeHelper.setForced(true);
+
+	//already set the mode, so that we do not try to go back in our old mode when the transition fails
+	mode = getFallbackSequence(mode);
+	//SHOULDDO: We should store submodes for fallback sequence as well, otherwise we should get rid of submodes completely.
+	startTransition(mode, SUBMODE_NONE);
+}
diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index ca1020b94..b296a2e88 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -1,164 +1,164 @@
-#ifndef SUBSYSTEM_H_
-#define SUBSYSTEM_H_
-
-#include <framework/container/FixedArrayList.h>
-#include <framework/container/FixedMap.h>
-#include <framework/container/HybridIterator.h>
-#include <framework/container/SinglyLinkedList.h>
-#include <framework/serialize/SerialArrayListAdapter.h>
-#include <framework/subsystem/modes/ModeDefinitions.h>
-#include <framework/subsystem/SubsystemBase.h>
-
-class Subsystem: public SubsystemBase, public HasModeSequenceIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM;
-	static const ReturnValue_t SEQUENCE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t TABLE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t TABLE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t TABLE_OR_SEQUENCE_LENGTH_INVALID = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t SEQUENCE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
-			MAKE_RETURN_CODE(0x06);
-	static const ReturnValue_t FALLBACK_SEQUENCE_DOES_NOT_EXIST =
-			MAKE_RETURN_CODE(0x07);
-	static const ReturnValue_t NO_TARGET_TABLE = MAKE_RETURN_CODE(0x08);
-	static const ReturnValue_t SEQUENCE_OR_TABLE_TOO_LONG = MAKE_RETURN_CODE(0x09);
-	static const ReturnValue_t IS_FALLBACK_SEQUENCE = MAKE_RETURN_CODE(0x0B);
-	static const ReturnValue_t ACCESS_DENIED = MAKE_RETURN_CODE(0x0C);
-	static const ReturnValue_t TABLE_IN_USE = MAKE_RETURN_CODE(0x0E);
-
-	static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1);
-	static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2);
-
-
-
-	Subsystem(object_id_t setObjectId, object_id_t parent,
-			uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
-	virtual ~Subsystem();
-
-	ReturnValue_t addSequence(ArrayList<ModeListEntry>* sequence, Mode_t id,
-			Mode_t fallbackSequence, bool inStore = true, bool preInit = true);
-
-	ReturnValue_t addTable(ArrayList<ModeListEntry> *table, Mode_t id,
-			bool inStore = true, bool preInit = true);
-
-	void setInitialMode(Mode_t mode);
-
-	virtual ReturnValue_t initialize();
-
-	virtual ReturnValue_t checkObjectConnections();
-
-	virtual MessageQueueId_t getSequenceCommandQueue() const;
-
-	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
-	 * @param sequence
-	 * @return
-	 */
-	ReturnValue_t checkSequence(Mode_t sequence);
-
-	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
-	 * @param iter
-	 * @return
-	 */
-	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter, Mode_t fallbackSequence);
-protected:
-
-	struct EntryPointer {
-		bool islinked;
-		union {
-			ModeListEntry *firstLinkedElement;
-			ArrayList<ModeListEntry> *array;
-		};
-	};
-
-	struct SequenceInfo {
-		Mode_t fallbackSequence;
-		EntryPointer entries;
-	};
-
-	static const uint8_t MAX_NUMBER_OF_TABLES_OR_SEQUENCES = 70;
-
-	static const uint8_t MAX_LENGTH_OF_TABLE_OR_SEQUENCE = 20;
-
-	bool isInTransition;
-
-	bool childrenChangedHealth;
-
-	uint32_t uptimeStartTable;
-
-	HybridIterator<ModeListEntry> currentTargetTable;
-
-	Mode_t targetMode;
-
-	Submode_t targetSubmode;
-
-	Mode_t initialMode;
-
-	HybridIterator<ModeListEntry> currentSequenceIterator;
-
-	FixedMap<Mode_t, EntryPointer> modeTables;
-
-	FixedMap<Mode_t, SequenceInfo> modeSequences;
-
-	StorageManagerIF *IPCStore;
-
-#ifdef USE_MODESTORE
-	ModeStoreIF *modeStore;
-#endif
-
-	bool existsModeSequence(Mode_t id);
-
-	HybridIterator<ModeListEntry> getSequence(Mode_t id);
-
-	bool existsModeTable(Mode_t id);
-
-	HybridIterator<ModeListEntry> getTable(Mode_t id);
-
-	HybridIterator<ModeListEntry> getCurrentTable();
-
-//	void startSequence(Mode_t sequence);
-
-	/**
-	 * DO NOT USE ON NON EXISTING SEQUENCE
-	 *
-	 * @param a sequence
-	 * @return the fallback sequence's Id
-	 */
-	Mode_t getFallbackSequence(Mode_t sequence);
-
-	void replyToCommand(ReturnValue_t status, uint32_t parameter);
-
-	ReturnValue_t deleteSequence(Mode_t id);
-
-	ReturnValue_t deleteTable(Mode_t id);
-
-	virtual void performChildOperation();
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
-
-	bool isFallbackSequence(Mode_t SequenceId);
-
-	bool isTableUsed(Mode_t tableId);
-
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode);
-
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-
-	void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);
-
-	void transitionFailed(ReturnValue_t failureCode, uint32_t parameter);
-
-	void cantKeepMode();
-
-};
-
-#endif /* SUBSYSTEM_H_ */
+#ifndef SUBSYSTEM_H_
+#define SUBSYSTEM_H_
+
+#include "../container/FixedArrayList.h"
+#include "../container/FixedMap.h"
+#include "../container/HybridIterator.h"
+#include "../container/SinglyLinkedList.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include "../subsystem/modes/ModeDefinitions.h"
+#include "../subsystem/SubsystemBase.h"
+
+class Subsystem: public SubsystemBase, public HasModeSequenceIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM;
+	static const ReturnValue_t SEQUENCE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t TABLE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t TABLE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t TABLE_OR_SEQUENCE_LENGTH_INVALID = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t SEQUENCE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
+			MAKE_RETURN_CODE(0x06);
+	static const ReturnValue_t FALLBACK_SEQUENCE_DOES_NOT_EXIST =
+			MAKE_RETURN_CODE(0x07);
+	static const ReturnValue_t NO_TARGET_TABLE = MAKE_RETURN_CODE(0x08);
+	static const ReturnValue_t SEQUENCE_OR_TABLE_TOO_LONG = MAKE_RETURN_CODE(0x09);
+	static const ReturnValue_t IS_FALLBACK_SEQUENCE = MAKE_RETURN_CODE(0x0B);
+	static const ReturnValue_t ACCESS_DENIED = MAKE_RETURN_CODE(0x0C);
+	static const ReturnValue_t TABLE_IN_USE = MAKE_RETURN_CODE(0x0E);
+
+	static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1);
+	static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2);
+
+
+
+	Subsystem(object_id_t setObjectId, object_id_t parent,
+			uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
+	virtual ~Subsystem();
+
+	ReturnValue_t addSequence(ArrayList<ModeListEntry>* sequence, Mode_t id,
+			Mode_t fallbackSequence, bool inStore = true, bool preInit = true);
+
+	ReturnValue_t addTable(ArrayList<ModeListEntry> *table, Mode_t id,
+			bool inStore = true, bool preInit = true);
+
+	void setInitialMode(Mode_t mode);
+
+	virtual ReturnValue_t initialize();
+
+	virtual ReturnValue_t checkObjectConnections();
+
+	virtual MessageQueueId_t getSequenceCommandQueue() const;
+
+	/**
+	 *
+	 *
+	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
+	 *
+	 * @param sequence
+	 * @return
+	 */
+	ReturnValue_t checkSequence(Mode_t sequence);
+
+	/**
+	 *
+	 *
+	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
+	 *
+	 * @param iter
+	 * @return
+	 */
+	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter, Mode_t fallbackSequence);
+protected:
+
+	struct EntryPointer {
+		bool islinked;
+		union {
+			ModeListEntry *firstLinkedElement;
+			ArrayList<ModeListEntry> *array;
+		};
+	};
+
+	struct SequenceInfo {
+		Mode_t fallbackSequence;
+		EntryPointer entries;
+	};
+
+	static const uint8_t MAX_NUMBER_OF_TABLES_OR_SEQUENCES = 70;
+
+	static const uint8_t MAX_LENGTH_OF_TABLE_OR_SEQUENCE = 20;
+
+	bool isInTransition;
+
+	bool childrenChangedHealth;
+
+	uint32_t uptimeStartTable;
+
+	HybridIterator<ModeListEntry> currentTargetTable;
+
+	Mode_t targetMode;
+
+	Submode_t targetSubmode;
+
+	Mode_t initialMode;
+
+	HybridIterator<ModeListEntry> currentSequenceIterator;
+
+	FixedMap<Mode_t, EntryPointer> modeTables;
+
+	FixedMap<Mode_t, SequenceInfo> modeSequences;
+
+	StorageManagerIF *IPCStore;
+
+#ifdef USE_MODESTORE
+	ModeStoreIF *modeStore;
+#endif
+
+	bool existsModeSequence(Mode_t id);
+
+	HybridIterator<ModeListEntry> getSequence(Mode_t id);
+
+	bool existsModeTable(Mode_t id);
+
+	HybridIterator<ModeListEntry> getTable(Mode_t id);
+
+	HybridIterator<ModeListEntry> getCurrentTable();
+
+//	void startSequence(Mode_t sequence);
+
+	/**
+	 * DO NOT USE ON NON EXISTING SEQUENCE
+	 *
+	 * @param a sequence
+	 * @return the fallback sequence's Id
+	 */
+	Mode_t getFallbackSequence(Mode_t sequence);
+
+	void replyToCommand(ReturnValue_t status, uint32_t parameter);
+
+	ReturnValue_t deleteSequence(Mode_t id);
+
+	ReturnValue_t deleteTable(Mode_t id);
+
+	virtual void performChildOperation();
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
+
+	bool isFallbackSequence(Mode_t SequenceId);
+
+	bool isTableUsed(Mode_t tableId);
+
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode);
+
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+
+	void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);
+
+	void transitionFailed(ReturnValue_t failureCode, uint32_t parameter);
+
+	void cantKeepMode();
+
+};
+
+#endif /* SUBSYSTEM_H_ */
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 71fa81b75..2bd6c1ad3 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -1,356 +1,356 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/subsystem/SubsystemBase.h>
-#include <framework/ipc/QueueFactory.h>
-
-SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
-		Mode_t initialMode, uint16_t commandQueueDepth) :
-		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
-		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
-		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
-			MessageQueueMessage::MAX_MESSAGE_SIZE);
-}
-
-SubsystemBase::~SubsystemBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-
-}
-
-ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
-	ChildInfo info;
-
-	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
-	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
-	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
-	if (child == nullptr) {
-		if (healthChild == nullptr) {
-			return CHILD_DOESNT_HAVE_MODES;
-		} else {
-			info.commandQueue = healthChild->getCommandQueue();
-			info.mode = MODE_OFF;
-		}
-	} else {
-		info.commandQueue = child->getCommandQueue();
-		info.mode = -1;	//intentional to force an initial command during system startup
-	}
-
-	info.submode = SUBMODE_NONE;
-	info.healthChanged = false;
-
-	std::pair<std::map<object_id_t, ChildInfo>::iterator, bool> returnValue =
-			childrenMap.insert(
-					std::pair<object_id_t, ChildInfo>(objectId, info));
-	if (!(returnValue.second)) {
-		return COULD_NOT_INSERT_CHILD;
-	} else {
-		return RETURN_OK;
-	}
-}
-
-ReturnValue_t SubsystemBase::checkStateAgainstTable(
-		HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
-
-	std::map<object_id_t, ChildInfo>::iterator childIter;
-
-	for (; tableIter.value != NULL; ++tableIter) {
-		object_id_t object = tableIter.value->getObject();
-
-		if ((childIter = childrenMap.find(object)) == childrenMap.end()) {
-			return RETURN_FAILED;
-		}
-
-		if (childIter->second.mode != tableIter.value->getMode()) {
-			return RETURN_FAILED;
-		}
-
-		Submode_t submodeToCheckAgainst = tableIter.value->getSubmode();
-		if (tableIter.value->inheritSubmode()) {
-			submodeToCheckAgainst = targetSubmode;
-		}
-
-		if (childIter->second.submode != submodeToCheckAgainst) {
-			return RETURN_FAILED;
-		}
-	}
-	return RETURN_OK;
-}
-
-void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
-        Submode_t targetSubmode) {
-	CommandMessage command;
-
-	std::map<object_id_t, ChildInfo>::iterator iter;
-
-	commandsOutstanding = 0;
-
-	for (; tableIter.value != nullptr; ++tableIter) {
-		object_id_t object = tableIter.value->getObject();
-		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
-			//illegal table entry, should only happen due to misconfigured mode table
-			sif::debug << std::hex << getObjectId() << ": invalid mode table entry"
-					<< std::endl;
-			continue;
-		}
-
-		Submode_t submodeToCommand = tableIter.value->getSubmode();
-		if (tableIter.value->inheritSubmode()) {
-			submodeToCommand = targetSubmode;
-		}
-
-		if (healthHelper.healthTable->hasHealth(object)) {
-			if (healthHelper.healthTable->isFaulty(object)) {
-				ModeMessage::setModeMessage(&command,
-						ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
-						SUBMODE_NONE);
-			} else {
-				if (modeHelper.isForced()) {
-					ModeMessage::setModeMessage(&command,
-							ModeMessage::CMD_MODE_COMMAND_FORCED,
-							tableIter.value->getMode(), submodeToCommand);
-				} else {
-					if (healthHelper.healthTable->isCommandable(object)) {
-						ModeMessage::setModeMessage(&command,
-								ModeMessage::CMD_MODE_COMMAND,
-								tableIter.value->getMode(), submodeToCommand);
-					} else {
-						continue;
-					}
-				}
-			}
-		} else {
-			ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
-					tableIter.value->getMode(), submodeToCommand);
-		}
-
-		if ((iter->second.mode == ModeMessage::getMode(&command))
-				&& (iter->second.submode == ModeMessage::getSubmode(&command))
-				&& !modeHelper.isForced()) {
-			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
-		}
-		ReturnValue_t result = commandQueue->sendMessage(
-				iter->second.commandQueue, &command);
-		if (result == RETURN_OK) {
-			++commandsOutstanding;
-		}
-	}
-
-}
-
-ReturnValue_t SubsystemBase::updateChildMode(MessageQueueId_t queue,
-		Mode_t mode, Submode_t submode) {
-	std::map<object_id_t, ChildInfo>::iterator iter;
-
-	for (iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
-		if (iter->second.commandQueue == queue) {
-			iter->second.mode = mode;
-			iter->second.submode = submode;
-			return RETURN_OK;
-		}
-	}
-	return CHILD_NOT_FOUND;
-}
-
-ReturnValue_t SubsystemBase::updateChildChangedHealth(MessageQueueId_t queue,
-bool changedHealth) {
-	for (auto iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
-		if (iter->second.commandQueue == queue) {
-			iter->second.healthChanged = changedHealth;
-			return RETURN_OK;
-		}
-	}
-	return CHILD_NOT_FOUND;
-}
-
-MessageQueueId_t SubsystemBase::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t SubsystemBase::initialize() {
-	MessageQueueId_t parentQueue = 0;
-	ReturnValue_t result = SystemObject::initialize();
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	if (parentId != 0) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
-
-		parent->registerChild(getObjectId());
-	}
-
-	result = healthHelper.initialize(parentQueue);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	result = modeHelper.initialize(parentQueue);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	return RETURN_OK;
-}
-
-ReturnValue_t SubsystemBase::performOperation(uint8_t opCode) {
-
-	childrenChangedMode = false;
-
-	checkCommandQueue();
-
-	performChildOperation();
-
-	return RETURN_OK;
-}
-
-ReturnValue_t SubsystemBase::handleModeReply(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case ModeMessage::REPLY_MODE_INFO:
-		updateChildMode(message->getSender(), ModeMessage::getMode(message),
-				ModeMessage::getSubmode(message));
-		childrenChangedMode = true;
-		return RETURN_OK;
-	case ModeMessage::REPLY_MODE_REPLY:
-	case ModeMessage::REPLY_WRONG_MODE_REPLY:
-		updateChildMode(message->getSender(), ModeMessage::getMode(message),
-				ModeMessage::getSubmode(message));
-		childrenChangedMode = true;
-		commandsOutstanding--;
-		return RETURN_OK;
-	case ModeMessage::REPLY_CANT_REACH_MODE:
-		commandsOutstanding--;
-		{
-			for (auto iter = childrenMap.begin(); iter != childrenMap.end();
-					iter++) {
-				if (iter->second.commandQueue == message->getSender()) {
-					triggerEvent(MODE_CMD_REJECTED, iter->first,
-							message->getParameter());
-				}
-			}
-		}
-		return RETURN_OK;
-//	case ModeMessage::CMD_MODE_COMMAND:
-//		handleCommandedMode(message);
-//		return RETURN_OK;
-//	case ModeMessage::CMD_MODE_ANNOUNCE:
-//		triggerEvent(MODE_INFO, mode, submode);
-//		return RETURN_OK;
-//	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
-//		triggerEvent(MODE_INFO, mode, submode);
-//		commandAllChildren(message);
-//		return RETURN_OK;
-	default:
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t SubsystemBase::checkTable(
-		HybridIterator<ModeListEntry> tableIter) {
-	for (; tableIter.value != NULL; ++tableIter) {
-		if (childrenMap.find(tableIter.value->getObject())
-				== childrenMap.end()) {
-			return TABLE_CONTAINS_INVALID_OBJECT_ID;
-		}
-	}
-	return RETURN_OK;
-}
-
-void SubsystemBase::replyToCommand(CommandMessage* message) {
-	commandQueue->reply(message);
-}
-
-void SubsystemBase::setMode(Mode_t newMode, Submode_t newSubmode) {
-	modeHelper.modeChanged(newMode, newSubmode);
-	mode = newMode;
-	submode = newSubmode;
-	modeChanged();
-	announceMode(false);
-}
-
-void SubsystemBase::setMode(Mode_t newMode) {
-	setMode(newMode, submode);
-}
-
-void SubsystemBase::commandAllChildren(CommandMessage* message) {
-	std::map<object_id_t, ChildInfo>::iterator iter;
-	for (iter = childrenMap.begin(); iter != childrenMap.end(); ++iter) {
-		commandQueue->sendMessage(iter->second.commandQueue, message);
-	}
-}
-
-void SubsystemBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
-}
-
-void SubsystemBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
-}
-
-void SubsystemBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
-	if (recursive) {
-		CommandMessage command;
-		ModeMessage::setModeMessage(&command,
-				ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
-		commandAllChildren(&command);
-	}
-}
-
-void SubsystemBase::checkCommandQueue() {
-	ReturnValue_t result;
-	CommandMessage command;
-
-	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
-
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = modeHelper.handleModeCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = handleModeReply(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = handleCommandMessage(&command);
-		if (result != RETURN_OK) {
-			CommandMessage reply;
-			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
-					command.getCommand());
-			replyToCommand(&reply);
-		}
-	}
-}
-
-ReturnValue_t SubsystemBase::setHealth(HealthState health) {
-	switch (health) {
-	case HEALTHY:
-	case EXTERNAL_CONTROL:
-		healthHelper.setHealth(health);
-		return RETURN_OK;
-	default:
-		return INVALID_HEALTH_STATE;
-	}
-}
-
-HasHealthIF::HealthState SubsystemBase::getHealth() {
-	return healthHelper.getHealth();
-}
-
-void SubsystemBase::modeChanged() {
-}
-
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../subsystem/SubsystemBase.h"
+#include "../ipc/QueueFactory.h"
+
+SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
+		Mode_t initialMode, uint16_t commandQueueDepth) :
+		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
+		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
+		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
+			MessageQueueMessage::MAX_MESSAGE_SIZE);
+}
+
+SubsystemBase::~SubsystemBase() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+
+}
+
+ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
+	ChildInfo info;
+
+	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
+	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
+	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
+	if (child == nullptr) {
+		if (healthChild == nullptr) {
+			return CHILD_DOESNT_HAVE_MODES;
+		} else {
+			info.commandQueue = healthChild->getCommandQueue();
+			info.mode = MODE_OFF;
+		}
+	} else {
+		info.commandQueue = child->getCommandQueue();
+		info.mode = -1;	//intentional to force an initial command during system startup
+	}
+
+	info.submode = SUBMODE_NONE;
+	info.healthChanged = false;
+
+	std::pair<std::map<object_id_t, ChildInfo>::iterator, bool> returnValue =
+			childrenMap.insert(
+					std::pair<object_id_t, ChildInfo>(objectId, info));
+	if (!(returnValue.second)) {
+		return COULD_NOT_INSERT_CHILD;
+	} else {
+		return RETURN_OK;
+	}
+}
+
+ReturnValue_t SubsystemBase::checkStateAgainstTable(
+		HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
+
+	std::map<object_id_t, ChildInfo>::iterator childIter;
+
+	for (; tableIter.value != NULL; ++tableIter) {
+		object_id_t object = tableIter.value->getObject();
+
+		if ((childIter = childrenMap.find(object)) == childrenMap.end()) {
+			return RETURN_FAILED;
+		}
+
+		if (childIter->second.mode != tableIter.value->getMode()) {
+			return RETURN_FAILED;
+		}
+
+		Submode_t submodeToCheckAgainst = tableIter.value->getSubmode();
+		if (tableIter.value->inheritSubmode()) {
+			submodeToCheckAgainst = targetSubmode;
+		}
+
+		if (childIter->second.submode != submodeToCheckAgainst) {
+			return RETURN_FAILED;
+		}
+	}
+	return RETURN_OK;
+}
+
+void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
+        Submode_t targetSubmode) {
+	CommandMessage command;
+
+	std::map<object_id_t, ChildInfo>::iterator iter;
+
+	commandsOutstanding = 0;
+
+	for (; tableIter.value != nullptr; ++tableIter) {
+		object_id_t object = tableIter.value->getObject();
+		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
+			//illegal table entry, should only happen due to misconfigured mode table
+			sif::debug << std::hex << getObjectId() << ": invalid mode table entry"
+					<< std::endl;
+			continue;
+		}
+
+		Submode_t submodeToCommand = tableIter.value->getSubmode();
+		if (tableIter.value->inheritSubmode()) {
+			submodeToCommand = targetSubmode;
+		}
+
+		if (healthHelper.healthTable->hasHealth(object)) {
+			if (healthHelper.healthTable->isFaulty(object)) {
+				ModeMessage::setModeMessage(&command,
+						ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
+						SUBMODE_NONE);
+			} else {
+				if (modeHelper.isForced()) {
+					ModeMessage::setModeMessage(&command,
+							ModeMessage::CMD_MODE_COMMAND_FORCED,
+							tableIter.value->getMode(), submodeToCommand);
+				} else {
+					if (healthHelper.healthTable->isCommandable(object)) {
+						ModeMessage::setModeMessage(&command,
+								ModeMessage::CMD_MODE_COMMAND,
+								tableIter.value->getMode(), submodeToCommand);
+					} else {
+						continue;
+					}
+				}
+			}
+		} else {
+			ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
+					tableIter.value->getMode(), submodeToCommand);
+		}
+
+		if ((iter->second.mode == ModeMessage::getMode(&command))
+				&& (iter->second.submode == ModeMessage::getSubmode(&command))
+				&& !modeHelper.isForced()) {
+			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
+		}
+		ReturnValue_t result = commandQueue->sendMessage(
+				iter->second.commandQueue, &command);
+		if (result == RETURN_OK) {
+			++commandsOutstanding;
+		}
+	}
+
+}
+
+ReturnValue_t SubsystemBase::updateChildMode(MessageQueueId_t queue,
+		Mode_t mode, Submode_t submode) {
+	std::map<object_id_t, ChildInfo>::iterator iter;
+
+	for (iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
+		if (iter->second.commandQueue == queue) {
+			iter->second.mode = mode;
+			iter->second.submode = submode;
+			return RETURN_OK;
+		}
+	}
+	return CHILD_NOT_FOUND;
+}
+
+ReturnValue_t SubsystemBase::updateChildChangedHealth(MessageQueueId_t queue,
+bool changedHealth) {
+	for (auto iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
+		if (iter->second.commandQueue == queue) {
+			iter->second.healthChanged = changedHealth;
+			return RETURN_OK;
+		}
+	}
+	return CHILD_NOT_FOUND;
+}
+
+MessageQueueId_t SubsystemBase::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t SubsystemBase::initialize() {
+	MessageQueueId_t parentQueue = 0;
+	ReturnValue_t result = SystemObject::initialize();
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	if (parentId != 0) {
+		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		if (parent == NULL) {
+			return RETURN_FAILED;
+		}
+		parentQueue = parent->getCommandQueue();
+
+		parent->registerChild(getObjectId());
+	}
+
+	result = healthHelper.initialize(parentQueue);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	result = modeHelper.initialize(parentQueue);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	return RETURN_OK;
+}
+
+ReturnValue_t SubsystemBase::performOperation(uint8_t opCode) {
+
+	childrenChangedMode = false;
+
+	checkCommandQueue();
+
+	performChildOperation();
+
+	return RETURN_OK;
+}
+
+ReturnValue_t SubsystemBase::handleModeReply(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case ModeMessage::REPLY_MODE_INFO:
+		updateChildMode(message->getSender(), ModeMessage::getMode(message),
+				ModeMessage::getSubmode(message));
+		childrenChangedMode = true;
+		return RETURN_OK;
+	case ModeMessage::REPLY_MODE_REPLY:
+	case ModeMessage::REPLY_WRONG_MODE_REPLY:
+		updateChildMode(message->getSender(), ModeMessage::getMode(message),
+				ModeMessage::getSubmode(message));
+		childrenChangedMode = true;
+		commandsOutstanding--;
+		return RETURN_OK;
+	case ModeMessage::REPLY_CANT_REACH_MODE:
+		commandsOutstanding--;
+		{
+			for (auto iter = childrenMap.begin(); iter != childrenMap.end();
+					iter++) {
+				if (iter->second.commandQueue == message->getSender()) {
+					triggerEvent(MODE_CMD_REJECTED, iter->first,
+							message->getParameter());
+				}
+			}
+		}
+		return RETURN_OK;
+//	case ModeMessage::CMD_MODE_COMMAND:
+//		handleCommandedMode(message);
+//		return RETURN_OK;
+//	case ModeMessage::CMD_MODE_ANNOUNCE:
+//		triggerEvent(MODE_INFO, mode, submode);
+//		return RETURN_OK;
+//	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
+//		triggerEvent(MODE_INFO, mode, submode);
+//		commandAllChildren(message);
+//		return RETURN_OK;
+	default:
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t SubsystemBase::checkTable(
+		HybridIterator<ModeListEntry> tableIter) {
+	for (; tableIter.value != NULL; ++tableIter) {
+		if (childrenMap.find(tableIter.value->getObject())
+				== childrenMap.end()) {
+			return TABLE_CONTAINS_INVALID_OBJECT_ID;
+		}
+	}
+	return RETURN_OK;
+}
+
+void SubsystemBase::replyToCommand(CommandMessage* message) {
+	commandQueue->reply(message);
+}
+
+void SubsystemBase::setMode(Mode_t newMode, Submode_t newSubmode) {
+	modeHelper.modeChanged(newMode, newSubmode);
+	mode = newMode;
+	submode = newSubmode;
+	modeChanged();
+	announceMode(false);
+}
+
+void SubsystemBase::setMode(Mode_t newMode) {
+	setMode(newMode, submode);
+}
+
+void SubsystemBase::commandAllChildren(CommandMessage* message) {
+	std::map<object_id_t, ChildInfo>::iterator iter;
+	for (iter = childrenMap.begin(); iter != childrenMap.end(); ++iter) {
+		commandQueue->sendMessage(iter->second.commandQueue, message);
+	}
+}
+
+void SubsystemBase::getMode(Mode_t* mode, Submode_t* submode) {
+	*mode = this->mode;
+	*submode = this->submode;
+}
+
+void SubsystemBase::setToExternalControl() {
+	healthHelper.setHealth(EXTERNAL_CONTROL);
+}
+
+void SubsystemBase::announceMode(bool recursive) {
+	triggerEvent(MODE_INFO, mode, submode);
+	if (recursive) {
+		CommandMessage command;
+		ModeMessage::setModeMessage(&command,
+				ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
+		commandAllChildren(&command);
+	}
+}
+
+void SubsystemBase::checkCommandQueue() {
+	ReturnValue_t result;
+	CommandMessage command;
+
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
+
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = modeHelper.handleModeCommand(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = handleModeReply(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = handleCommandMessage(&command);
+		if (result != RETURN_OK) {
+			CommandMessage reply;
+			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
+					command.getCommand());
+			replyToCommand(&reply);
+		}
+	}
+}
+
+ReturnValue_t SubsystemBase::setHealth(HealthState health) {
+	switch (health) {
+	case HEALTHY:
+	case EXTERNAL_CONTROL:
+		healthHelper.setHealth(health);
+		return RETURN_OK;
+	default:
+		return INVALID_HEALTH_STATE;
+	}
+}
+
+HasHealthIF::HealthState SubsystemBase::getHealth() {
+	return healthHelper.getHealth();
+}
+
+void SubsystemBase::modeChanged() {
+}
+
diff --git a/subsystem/SubsystemBase.h b/subsystem/SubsystemBase.h
index 1a050a9aa..c0abbe400 100644
--- a/subsystem/SubsystemBase.h
+++ b/subsystem/SubsystemBase.h
@@ -1,129 +1,129 @@
-#ifndef SUBSYSTEMBASE_H_
-#define SUBSYSTEMBASE_H_
-
-#include <framework/container/HybridIterator.h>
-#include <framework/health/HasHealthIF.h>
-#include <framework/health/HealthHelper.h>
-#include <framework/modes/HasModesIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/subsystem/modes/HasModeSequenceIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <map>
-
-/**
- * @defgroup subsystems Subsystem Objects
- * Contains all Subsystem and Assemblies
- */
-class SubsystemBase: public SystemObject,
-		public HasModesIF,
-		public HasHealthIF,
-		public HasReturnvaluesIF,
-		public ExecutableObjectIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM_BASE;
-	static const ReturnValue_t CHILD_NOT_FOUND = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t CHILD_INFO_UPDATED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t CHILD_DOESNT_HAVE_MODES = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t COULD_NOT_INSERT_CHILD = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
-			MAKE_RETURN_CODE(0x05);
-
-	SubsystemBase(object_id_t setObjectId, object_id_t parent,
-			Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
-	virtual ~SubsystemBase();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t registerChild(object_id_t objectId);
-
-	virtual ReturnValue_t initialize();
-
-	virtual ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual ReturnValue_t setHealth(HealthState health);
-
-	virtual HasHealthIF::HealthState getHealth();
-
-protected:
-	struct ChildInfo {
-		MessageQueueId_t commandQueue;
-		Mode_t mode;
-		Submode_t submode;bool healthChanged;
-	};
-
-	Mode_t mode;
-
-	Submode_t submode;
-
-	bool childrenChangedMode;
-
-	/**
-	 * Always check this against <=0, so you are robust against too many replies
-	 */
-	int32_t commandsOutstanding;
-
-	MessageQueueIF* commandQueue;
-
-	HealthHelper healthHelper;
-
-	ModeHelper modeHelper;
-
-	const object_id_t parentId;
-
-	typedef std::map<object_id_t, ChildInfo> ChildrenMap;
-	ChildrenMap childrenMap;
-
-	void checkCommandQueue();
-
-	/**
-	 * We need to know the target Submode, as children are able to inherit the submode
-	 */
-	ReturnValue_t checkStateAgainstTable(
-			HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode);
-
-	/**
-	 * We need to know the target Submode, as children are able to inherit the submode
-	 * Still, we have a default for all child implementations which do not use submode inheritance
-	 */
-	void executeTable(HybridIterator<ModeListEntry> tableIter,
-			Submode_t targetSubmode = SUBMODE_NONE);
-
-	ReturnValue_t updateChildMode(MessageQueueId_t queue, Mode_t mode,
-			Submode_t submode);
-
-	ReturnValue_t updateChildChangedHealth(MessageQueueId_t queue,
-			bool changedHealth = true);
-
-	virtual ReturnValue_t handleModeReply(CommandMessage *message);
-
-	void commandAllChildren(CommandMessage *message);
-
-	ReturnValue_t checkTable(HybridIterator<ModeListEntry> tableIter);
-
-	void replyToCommand(CommandMessage *message);
-
-	void setMode(Mode_t newMode, Submode_t newSubmode);
-
-	void setMode(Mode_t newMode);
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
-
-	virtual void performChildOperation() = 0;
-
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode) = 0;
-
-	virtual void startTransition(Mode_t mode, Submode_t submode) = 0;
-
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-
-	virtual void setToExternalControl();
-
-	virtual void announceMode(bool recursive);
-
-	virtual void modeChanged();
-};
-
-#endif /* SUBSYSTEMBASE_H_ */
+#ifndef SUBSYSTEMBASE_H_
+#define SUBSYSTEMBASE_H_
+
+#include "../container/HybridIterator.h"
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../modes/HasModesIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../subsystem/modes/HasModeSequenceIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include <map>
+
+/**
+ * @defgroup subsystems Subsystem Objects
+ * Contains all Subsystem and Assemblies
+ */
+class SubsystemBase: public SystemObject,
+		public HasModesIF,
+		public HasHealthIF,
+		public HasReturnvaluesIF,
+		public ExecutableObjectIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM_BASE;
+	static const ReturnValue_t CHILD_NOT_FOUND = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t CHILD_INFO_UPDATED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t CHILD_DOESNT_HAVE_MODES = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t COULD_NOT_INSERT_CHILD = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
+			MAKE_RETURN_CODE(0x05);
+
+	SubsystemBase(object_id_t setObjectId, object_id_t parent,
+			Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
+	virtual ~SubsystemBase();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t registerChild(object_id_t objectId);
+
+	virtual ReturnValue_t initialize();
+
+	virtual ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual ReturnValue_t setHealth(HealthState health);
+
+	virtual HasHealthIF::HealthState getHealth();
+
+protected:
+	struct ChildInfo {
+		MessageQueueId_t commandQueue;
+		Mode_t mode;
+		Submode_t submode;bool healthChanged;
+	};
+
+	Mode_t mode;
+
+	Submode_t submode;
+
+	bool childrenChangedMode;
+
+	/**
+	 * Always check this against <=0, so you are robust against too many replies
+	 */
+	int32_t commandsOutstanding;
+
+	MessageQueueIF* commandQueue;
+
+	HealthHelper healthHelper;
+
+	ModeHelper modeHelper;
+
+	const object_id_t parentId;
+
+	typedef std::map<object_id_t, ChildInfo> ChildrenMap;
+	ChildrenMap childrenMap;
+
+	void checkCommandQueue();
+
+	/**
+	 * We need to know the target Submode, as children are able to inherit the submode
+	 */
+	ReturnValue_t checkStateAgainstTable(
+			HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode);
+
+	/**
+	 * We need to know the target Submode, as children are able to inherit the submode
+	 * Still, we have a default for all child implementations which do not use submode inheritance
+	 */
+	void executeTable(HybridIterator<ModeListEntry> tableIter,
+			Submode_t targetSubmode = SUBMODE_NONE);
+
+	ReturnValue_t updateChildMode(MessageQueueId_t queue, Mode_t mode,
+			Submode_t submode);
+
+	ReturnValue_t updateChildChangedHealth(MessageQueueId_t queue,
+			bool changedHealth = true);
+
+	virtual ReturnValue_t handleModeReply(CommandMessage *message);
+
+	void commandAllChildren(CommandMessage *message);
+
+	ReturnValue_t checkTable(HybridIterator<ModeListEntry> tableIter);
+
+	void replyToCommand(CommandMessage *message);
+
+	void setMode(Mode_t newMode, Submode_t newSubmode);
+
+	void setMode(Mode_t newMode);
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+	virtual void performChildOperation() = 0;
+
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode) = 0;
+
+	virtual void startTransition(Mode_t mode, Submode_t submode) = 0;
+
+	virtual void getMode(Mode_t *mode, Submode_t *submode);
+
+	virtual void setToExternalControl();
+
+	virtual void announceMode(bool recursive);
+
+	virtual void modeChanged();
+};
+
+#endif /* SUBSYSTEMBASE_H_ */
diff --git a/subsystem/modes/HasModeSequenceIF.h b/subsystem/modes/HasModeSequenceIF.h
index e03de4102..90007d800 100644
--- a/subsystem/modes/HasModeSequenceIF.h
+++ b/subsystem/modes/HasModeSequenceIF.h
@@ -1,20 +1,20 @@
-#ifndef HASMODESEQUENCEIF_H_
-#define HASMODESEQUENCEIF_H_
-
-#include <framework/subsystem/modes/ModeDefinitions.h>
-#include <framework/subsystem/modes/ModeSequenceMessage.h>
-#include <framework/subsystem/modes/ModeStoreIF.h>
-
-
-class HasModeSequenceIF {
-public:
-	virtual ~HasModeSequenceIF() {
-
-	}
-
-	virtual MessageQueueId_t getSequenceCommandQueue() const = 0;
-
-};
-
-
-#endif /* HASMODESEQUENCEIF_H_ */
+#ifndef HASMODESEQUENCEIF_H_
+#define HASMODESEQUENCEIF_H_
+
+#include "../../subsystem/modes/ModeDefinitions.h"
+#include "../../subsystem/modes/ModeSequenceMessage.h"
+#include "../../subsystem/modes/ModeStoreIF.h"
+
+
+class HasModeSequenceIF {
+public:
+	virtual ~HasModeSequenceIF() {
+
+	}
+
+	virtual MessageQueueId_t getSequenceCommandQueue() const = 0;
+
+};
+
+
+#endif /* HASMODESEQUENCEIF_H_ */
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 153710afb..0514b3571 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -1,152 +1,152 @@
-#ifndef MODEDEFINITIONS_H_
-#define MODEDEFINITIONS_H_
-
-#include <framework/modes/HasModesIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/serialize/SerializeIF.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
-public:
-	ModeListEntry() :
-			LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0), value4(
-					0) {
-
-	}
-
-	uint32_t value1;
-	uint32_t value2;
-	uint8_t value3;
-	uint8_t value4;
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-
-		ReturnValue_t result;
-
-		result = SerializeAdapter::serialize(&value1, buffer, size,
-				maxSize, streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&value2, buffer, size,
-				maxSize, streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&value3, buffer, size,
-				maxSize, streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		result = SerializeAdapter::serialize(&value4, buffer, size,
-				maxSize, streamEndianness);
-
-		return result;
-
-	}
-
-	virtual size_t getSerializedSize() const {
-		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	Endianness streamEndianness) {
-		ReturnValue_t result;
-
-		result = SerializeAdapter::deSerialize(&value1, buffer, size,
-				streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&value2, buffer, size,
-				streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&value3, buffer, size,
-				streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&value4, buffer, size,
-				streamEndianness);
-
-		return result;
-	}
-
-	//for Sequences
-	Mode_t getTableId() const {
-		return value1;
-	}
-
-	void setTableId(Mode_t tableId) {
-		this->value1 = tableId;
-	}
-
-	uint8_t getWaitSeconds() const {
-		return value2;
-	}
-
-	void setWaitSeconds(uint8_t waitSeconds) {
-		this->value2 = waitSeconds;
-	}
-
-	bool checkSuccess() const {
-		return value3 == 1;
-	}
-
-	void setCheckSuccess(bool checkSuccess) {
-		this->value3 = checkSuccess;
-	}
-
-	//for Tables
-	object_id_t getObject() const {
-		return value1;
-	}
-
-	void setObject(object_id_t object) {
-		this->value1 = object;
-	}
-
-	Mode_t getMode() const {
-		return value2;
-	}
-
-	void setMode(Mode_t mode) {
-		this->value2 = mode;
-	}
-
-	Submode_t getSubmode() const {
-		return value3;
-	}
-
-	void setSubmode(Submode_t submode) {
-		this->value3 = submode;
-	}
-
-	bool inheritSubmode() const {
-		return value4 == 1;
-	}
-
-	void setInheritSubmode(bool inherit){
-		if (inherit){
-			value4 = 1;
-		} else {
-			value4 = 0;
-		}
-	}
-
-	bool operator==(ModeListEntry other) {
-		return ((value1 == other.value1) && (value2 == other.value2)
-				&& (value3 == other.value3));
-	}
-};
-
-#endif //MODEDEFINITIONS_H_
+#ifndef MODEDEFINITIONS_H_
+#define MODEDEFINITIONS_H_
+
+#include "../../modes/HasModesIF.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../serialize/SerializeIF.h"
+#include "../../serialize/SerialLinkedListAdapter.h"
+class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
+public:
+	ModeListEntry() :
+			LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0), value4(
+					0) {
+
+	}
+
+	uint32_t value1;
+	uint32_t value2;
+	uint8_t value3;
+	uint8_t value4;
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+
+		ReturnValue_t result;
+
+		result = SerializeAdapter::serialize(&value1, buffer, size,
+				maxSize, streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&value2, buffer, size,
+				maxSize, streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&value3, buffer, size,
+				maxSize, streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		result = SerializeAdapter::serialize(&value4, buffer, size,
+				maxSize, streamEndianness);
+
+		return result;
+
+	}
+
+	virtual size_t getSerializedSize() const {
+		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	Endianness streamEndianness) {
+		ReturnValue_t result;
+
+		result = SerializeAdapter::deSerialize(&value1, buffer, size,
+				streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&value2, buffer, size,
+				streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&value3, buffer, size,
+				streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&value4, buffer, size,
+				streamEndianness);
+
+		return result;
+	}
+
+	//for Sequences
+	Mode_t getTableId() const {
+		return value1;
+	}
+
+	void setTableId(Mode_t tableId) {
+		this->value1 = tableId;
+	}
+
+	uint8_t getWaitSeconds() const {
+		return value2;
+	}
+
+	void setWaitSeconds(uint8_t waitSeconds) {
+		this->value2 = waitSeconds;
+	}
+
+	bool checkSuccess() const {
+		return value3 == 1;
+	}
+
+	void setCheckSuccess(bool checkSuccess) {
+		this->value3 = checkSuccess;
+	}
+
+	//for Tables
+	object_id_t getObject() const {
+		return value1;
+	}
+
+	void setObject(object_id_t object) {
+		this->value1 = object;
+	}
+
+	Mode_t getMode() const {
+		return value2;
+	}
+
+	void setMode(Mode_t mode) {
+		this->value2 = mode;
+	}
+
+	Submode_t getSubmode() const {
+		return value3;
+	}
+
+	void setSubmode(Submode_t submode) {
+		this->value3 = submode;
+	}
+
+	bool inheritSubmode() const {
+		return value4 == 1;
+	}
+
+	void setInheritSubmode(bool inherit){
+		if (inherit){
+			value4 = 1;
+		} else {
+			value4 = 0;
+		}
+	}
+
+	bool operator==(ModeListEntry other) {
+		return ((value1 == other.value1) && (value2 == other.value2)
+				&& (value3 == other.value3));
+	}
+};
+
+#endif //MODEDEFINITIONS_H_
diff --git a/subsystem/modes/ModeSequenceMessage.cpp b/subsystem/modes/ModeSequenceMessage.cpp
index 31661739e..3eb4ebe83 100644
--- a/subsystem/modes/ModeSequenceMessage.cpp
+++ b/subsystem/modes/ModeSequenceMessage.cpp
@@ -1,89 +1,89 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/subsystem/modes/ModeSequenceMessage.h>
-
-void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-		Command_t command, Mode_t sequence, store_address_t storeAddress) {
-	message->setCommand(command);
-	message->setParameter(storeAddress.raw);
-	message->setParameter2(sequence);
-}
-
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table, store_address_t storeAddress) {
-//	message->setCommand(command);
-//	message->setParameter(storeAddress.raw);
-//	message->setParameter2(table);
-//}
-
-void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-		Command_t command, Mode_t sequence) {
-	message->setCommand(command);
-	message->setParameter2(sequence);
-}
-
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table) {
-//	message->setCommand(command);
-//	message->setParameter2(table);
-//}
-
-void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-		Command_t command, store_address_t storeAddress) {
-	message->setCommand(command);
-	message->setParameter(storeAddress.raw);
-}
-
-store_address_t ModeSequenceMessage::getStoreAddress(
-		const CommandMessage* message) {
-	store_address_t address;
-	address.raw = message->getParameter();
-	return address;
-}
-
-Mode_t ModeSequenceMessage::getSequenceId(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-Mode_t ModeSequenceMessage::getTableId(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-
-uint32_t ModeSequenceMessage::getNumber(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-void ModeSequenceMessage::clear(CommandMessage *message) {
-	switch (message->getCommand()) {
-	case ADD_SEQUENCE:
-	case ADD_TABLE:
-	case SEQUENCE_LIST:
-	case TABLE_LIST:
-	case TABLE:
-	case SEQUENCE:{
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore != NULL){
-			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
-		}
-	}
-	/* NO BREAK falls through*/
-	case DELETE_SEQUENCE:
-	case DELETE_TABLE:
-	case READ_SEQUENCE:
-	case READ_TABLE:
-	case LIST_SEQUENCES:
-	case LIST_TABLES:
-	case READ_FREE_SEQUENCE_SLOTS:
-	case FREE_SEQUENCE_SLOTS:
-	case READ_FREE_TABLE_SLOTS:
-	case FREE_TABLE_SLOTS:
-	default:
-		message->setCommand(CommandMessage::CMD_NONE);
-		message->setParameter(0);
-		message->setParameter2(0);
-		break;
-	}
-}
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../subsystem/modes/ModeSequenceMessage.h"
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, Mode_t sequence, store_address_t storeAddress) {
+	message->setCommand(command);
+	message->setParameter(storeAddress.raw);
+	message->setParameter2(sequence);
+}
+
+//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+//		Command_t command, ModeTableId_t table, store_address_t storeAddress) {
+//	message->setCommand(command);
+//	message->setParameter(storeAddress.raw);
+//	message->setParameter2(table);
+//}
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, Mode_t sequence) {
+	message->setCommand(command);
+	message->setParameter2(sequence);
+}
+
+//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+//		Command_t command, ModeTableId_t table) {
+//	message->setCommand(command);
+//	message->setParameter2(table);
+//}
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, store_address_t storeAddress) {
+	message->setCommand(command);
+	message->setParameter(storeAddress.raw);
+}
+
+store_address_t ModeSequenceMessage::getStoreAddress(
+		const CommandMessage* message) {
+	store_address_t address;
+	address.raw = message->getParameter();
+	return address;
+}
+
+Mode_t ModeSequenceMessage::getSequenceId(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+Mode_t ModeSequenceMessage::getTableId(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+
+uint32_t ModeSequenceMessage::getNumber(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+void ModeSequenceMessage::clear(CommandMessage *message) {
+	switch (message->getCommand()) {
+	case ADD_SEQUENCE:
+	case ADD_TABLE:
+	case SEQUENCE_LIST:
+	case TABLE_LIST:
+	case TABLE:
+	case SEQUENCE:{
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore != NULL){
+			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+	}
+	/* NO BREAK falls through*/
+	case DELETE_SEQUENCE:
+	case DELETE_TABLE:
+	case READ_SEQUENCE:
+	case READ_TABLE:
+	case LIST_SEQUENCES:
+	case LIST_TABLES:
+	case READ_FREE_SEQUENCE_SLOTS:
+	case FREE_SEQUENCE_SLOTS:
+	case READ_FREE_TABLE_SLOTS:
+	case FREE_TABLE_SLOTS:
+	default:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+	}
+}
diff --git a/subsystem/modes/ModeSequenceMessage.h b/subsystem/modes/ModeSequenceMessage.h
index 61d1b6285..fcb5b2e7f 100644
--- a/subsystem/modes/ModeSequenceMessage.h
+++ b/subsystem/modes/ModeSequenceMessage.h
@@ -1,48 +1,48 @@
-#ifndef MODESEQUENCEMESSAGE_H_
-#define MODESEQUENCEMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/subsystem/modes/ModeDefinitions.h>
-
-class ModeSequenceMessage {
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::MODE_SEQUENCE;
-
-	static const Command_t ADD_SEQUENCE = MAKE_COMMAND_ID(0x01);
-	static const Command_t ADD_TABLE = MAKE_COMMAND_ID(0x02);
-	static const Command_t DELETE_SEQUENCE = MAKE_COMMAND_ID(0x03);
-	static const Command_t DELETE_TABLE = MAKE_COMMAND_ID(0x04);
-	static const Command_t READ_SEQUENCE = MAKE_COMMAND_ID(0x05);
-	static const Command_t READ_TABLE = MAKE_COMMAND_ID(0x06);
-	static const Command_t LIST_SEQUENCES = MAKE_COMMAND_ID(0x07);
-	static const Command_t LIST_TABLES = MAKE_COMMAND_ID(0x08);
-	static const Command_t SEQUENCE_LIST = MAKE_COMMAND_ID(0x09);
-	static const Command_t TABLE_LIST = MAKE_COMMAND_ID(0x0A);
-	static const Command_t TABLE = MAKE_COMMAND_ID(0x0B);
-	static const Command_t SEQUENCE = MAKE_COMMAND_ID(0x0C);
-	static const Command_t READ_FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0D);
-	static const Command_t FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0E);
-	static const Command_t READ_FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x0F);
-	static const Command_t FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x10);
-
-	static void setModeSequenceMessage(CommandMessage *message,
-			Command_t command, Mode_t sequenceOrTable,
-			store_address_t storeAddress);
-	static void setModeSequenceMessage(CommandMessage *message,
-			Command_t command, Mode_t sequenceOrTable);
-	static void setModeSequenceMessage(CommandMessage *message,
-			Command_t command, store_address_t storeAddress);
-
-	static store_address_t getStoreAddress(const CommandMessage *message);
-	static Mode_t getSequenceId(const CommandMessage *message);
-	static Mode_t getTableId(const CommandMessage *message);
-	static uint32_t getNumber(const CommandMessage *message);
-
-	static void clear(CommandMessage *message);
-
-private:
-	ModeSequenceMessage();
-};
-
-#endif /* MODESEQUENCEMESSAGE_H_ */
+#ifndef MODESEQUENCEMESSAGE_H_
+#define MODESEQUENCEMESSAGE_H_
+
+#include "../../ipc/CommandMessage.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../subsystem/modes/ModeDefinitions.h"
+
+class ModeSequenceMessage {
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::MODE_SEQUENCE;
+
+	static const Command_t ADD_SEQUENCE = MAKE_COMMAND_ID(0x01);
+	static const Command_t ADD_TABLE = MAKE_COMMAND_ID(0x02);
+	static const Command_t DELETE_SEQUENCE = MAKE_COMMAND_ID(0x03);
+	static const Command_t DELETE_TABLE = MAKE_COMMAND_ID(0x04);
+	static const Command_t READ_SEQUENCE = MAKE_COMMAND_ID(0x05);
+	static const Command_t READ_TABLE = MAKE_COMMAND_ID(0x06);
+	static const Command_t LIST_SEQUENCES = MAKE_COMMAND_ID(0x07);
+	static const Command_t LIST_TABLES = MAKE_COMMAND_ID(0x08);
+	static const Command_t SEQUENCE_LIST = MAKE_COMMAND_ID(0x09);
+	static const Command_t TABLE_LIST = MAKE_COMMAND_ID(0x0A);
+	static const Command_t TABLE = MAKE_COMMAND_ID(0x0B);
+	static const Command_t SEQUENCE = MAKE_COMMAND_ID(0x0C);
+	static const Command_t READ_FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0D);
+	static const Command_t FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0E);
+	static const Command_t READ_FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x0F);
+	static const Command_t FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x10);
+
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, Mode_t sequenceOrTable,
+			store_address_t storeAddress);
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, Mode_t sequenceOrTable);
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, store_address_t storeAddress);
+
+	static store_address_t getStoreAddress(const CommandMessage *message);
+	static Mode_t getSequenceId(const CommandMessage *message);
+	static Mode_t getTableId(const CommandMessage *message);
+	static uint32_t getNumber(const CommandMessage *message);
+
+	static void clear(CommandMessage *message);
+
+private:
+	ModeSequenceMessage();
+};
+
+#endif /* MODESEQUENCEMESSAGE_H_ */
diff --git a/subsystem/modes/ModeStore.cpp b/subsystem/modes/ModeStore.cpp
index 2aa02087e..409a5f0fd 100644
--- a/subsystem/modes/ModeStore.cpp
+++ b/subsystem/modes/ModeStore.cpp
@@ -1,126 +1,126 @@
-#include <framework/subsystem/modes/ModeStore.h>
-
-#ifdef USE_MODESTORE
-
-ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
-		SystemObject(objectId), store(slots), emptySlot(store.front()) {
-	mutex = MutexFactory::instance()->createMutex();;
-	OSAL::createMutex(objectId + 1, mutex);
-	clear();
-}
-
-ModeStore::~ModeStore() {
-	delete mutex;
-}
-
-uint32_t ModeStore::getFreeSlots() {
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	uint32_t count = 0;
-	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
-	for (iter = store.begin(); iter != store.end(); ++iter) {
-		if (iter->getNext() == emptySlot) {
-			++count;
-		}
-	}
-	OSAL::unlockMutex(mutex);
-	return count;
-}
-
-ReturnValue_t ModeStore::storeArray(ArrayList<ModeListEntry>* sequence,
-		ModeListEntry** storedFirstEntry) {
-	if (sequence->size == 0) {
-		return CANT_STORE_EMPTY;
-	}
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	*storedFirstEntry = findEmptySlotNoLock(store.front());
-
-	ModeListEntry* pointer =
-			*storedFirstEntry;
-	pointer->setNext(pointer);
-
-	ArrayList<ModeListEntry>::Iterator iter;
-	for (iter = sequence->begin(); iter != sequence->end(); ++iter) {
-		//SHOULDDO: I need to check this in detail. What is the idea? Why does it not work?
-		pointer = pointer->getNext()->value;
-		if (pointer == NULL) {
-			deleteListNoLock(*storedFirstEntry);
-			OSAL::unlockMutex(mutex);
-			return TOO_MANY_ELEMENTS;
-		}
-		pointer->value->value1 = iter->value1;
-		pointer->value->value2 = iter->value2;
-		pointer->value->value3 = iter->value3;
-		pointer->setNext(findEmptySlotNoLock(pointer + 1));
-	}
-	pointer->setNext(NULL);
-	OSAL::unlockMutex(mutex);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeStore::deleteList(ModeListEntry* sequence) {
-	ReturnValue_t result = isValidEntry(sequence);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-		deleteListNoLock(sequence);
-		OSAL::unlockMutex(mutex);
-		return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeStore::readList(ModeListEntry* sequence,
-		ArrayList<ModeListEntry>* into) {
-	ReturnValue_t result = isValidEntry(sequence);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	result = into->insert(*sequence->value);
-	while ((result == HasReturnvaluesIF::RETURN_OK) && (sequence->getNext() != NULL)) {
-		result = into->insert(*sequence->value);
-		sequence = sequence->getNext()->value;
-	}
-	OSAL::unlockMutex(mutex);
-	return result;
-}
-
-void ModeStore::clear() {
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	store.size = store.maxSize();
-	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
-	for (iter = store.begin(); iter != store.end(); ++iter) {
-		iter->setNext(emptySlot);
-	}
-	OSAL::unlockMutex(mutex);
-}
-
-ModeListEntry* ModeStore::findEmptySlotNoLock(ModeListEntry* startFrom) {
-	ArrayList<ModeListEntry, uint32_t>::Iterator iter(
-			startFrom);
-	for (; iter != store.end(); ++iter) {
-		if (iter.value->getNext() == emptySlot) {
-			OSAL::unlockMutex(mutex);
-			return iter.value;
-		}
-	}
-	return NULL;
-}
-
-void ModeStore::deleteListNoLock(ModeListEntry* sequence) {
-	ModeListEntry* next = sequence;
-	while (next != NULL) {
-		next = sequence->getNext()->value;
-		sequence->setNext(emptySlot);
-		sequence = next;
-	}
-}
-
-ReturnValue_t ModeStore::isValidEntry(ModeListEntry* sequence) {
-	if ((sequence < store.front()) || (sequence > store.back())
-			|| sequence->getNext() == emptySlot) {
-		return INVALID_ENTRY;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-#endif
+#include "../../subsystem/modes/ModeStore.h"
+
+#ifdef USE_MODESTORE
+
+ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
+		SystemObject(objectId), store(slots), emptySlot(store.front()) {
+	mutex = MutexFactory::instance()->createMutex();;
+	OSAL::createMutex(objectId + 1, mutex);
+	clear();
+}
+
+ModeStore::~ModeStore() {
+	delete mutex;
+}
+
+uint32_t ModeStore::getFreeSlots() {
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	uint32_t count = 0;
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
+	for (iter = store.begin(); iter != store.end(); ++iter) {
+		if (iter->getNext() == emptySlot) {
+			++count;
+		}
+	}
+	OSAL::unlockMutex(mutex);
+	return count;
+}
+
+ReturnValue_t ModeStore::storeArray(ArrayList<ModeListEntry>* sequence,
+		ModeListEntry** storedFirstEntry) {
+	if (sequence->size == 0) {
+		return CANT_STORE_EMPTY;
+	}
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	*storedFirstEntry = findEmptySlotNoLock(store.front());
+
+	ModeListEntry* pointer =
+			*storedFirstEntry;
+	pointer->setNext(pointer);
+
+	ArrayList<ModeListEntry>::Iterator iter;
+	for (iter = sequence->begin(); iter != sequence->end(); ++iter) {
+		//SHOULDDO: I need to check this in detail. What is the idea? Why does it not work?
+		pointer = pointer->getNext()->value;
+		if (pointer == NULL) {
+			deleteListNoLock(*storedFirstEntry);
+			OSAL::unlockMutex(mutex);
+			return TOO_MANY_ELEMENTS;
+		}
+		pointer->value->value1 = iter->value1;
+		pointer->value->value2 = iter->value2;
+		pointer->value->value3 = iter->value3;
+		pointer->setNext(findEmptySlotNoLock(pointer + 1));
+	}
+	pointer->setNext(NULL);
+	OSAL::unlockMutex(mutex);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeStore::deleteList(ModeListEntry* sequence) {
+	ReturnValue_t result = isValidEntry(sequence);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+		deleteListNoLock(sequence);
+		OSAL::unlockMutex(mutex);
+		return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeStore::readList(ModeListEntry* sequence,
+		ArrayList<ModeListEntry>* into) {
+	ReturnValue_t result = isValidEntry(sequence);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	result = into->insert(*sequence->value);
+	while ((result == HasReturnvaluesIF::RETURN_OK) && (sequence->getNext() != NULL)) {
+		result = into->insert(*sequence->value);
+		sequence = sequence->getNext()->value;
+	}
+	OSAL::unlockMutex(mutex);
+	return result;
+}
+
+void ModeStore::clear() {
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	store.size = store.maxSize();
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
+	for (iter = store.begin(); iter != store.end(); ++iter) {
+		iter->setNext(emptySlot);
+	}
+	OSAL::unlockMutex(mutex);
+}
+
+ModeListEntry* ModeStore::findEmptySlotNoLock(ModeListEntry* startFrom) {
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter(
+			startFrom);
+	for (; iter != store.end(); ++iter) {
+		if (iter.value->getNext() == emptySlot) {
+			OSAL::unlockMutex(mutex);
+			return iter.value;
+		}
+	}
+	return NULL;
+}
+
+void ModeStore::deleteListNoLock(ModeListEntry* sequence) {
+	ModeListEntry* next = sequence;
+	while (next != NULL) {
+		next = sequence->getNext()->value;
+		sequence->setNext(emptySlot);
+		sequence = next;
+	}
+}
+
+ReturnValue_t ModeStore::isValidEntry(ModeListEntry* sequence) {
+	if ((sequence < store.front()) || (sequence > store.back())
+			|| sequence->getNext() == emptySlot) {
+		return INVALID_ENTRY;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+#endif
diff --git a/subsystem/modes/ModeStore.h b/subsystem/modes/ModeStore.h
index cbc45b5af..cb3404430 100644
--- a/subsystem/modes/ModeStore.h
+++ b/subsystem/modes/ModeStore.h
@@ -1,45 +1,45 @@
-#ifndef MODESTORE_H_
-#define MODESTORE_H_
-
-#ifdef USE_MODESTORE
-
-#include <framework/container/ArrayList.h>
-#include <framework/container/SinglyLinkedList.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/subsystem/modes/ModeStoreIF.h>
-
-class ModeStore: public ModeStoreIF, public SystemObject {
-public:
-	ModeStore(object_id_t objectId, uint32_t slots);
-	virtual ~ModeStore();
-
-	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
-			ModeListEntry **storedFirstEntry);
-
-	virtual ReturnValue_t deleteList(
-			ModeListEntry *sequence);
-
-	virtual ReturnValue_t readList(
-			ModeListEntry *sequence,
-			ArrayList<ModeListEntry> *into);
-
-	virtual uint32_t getFreeSlots();
-
-private:
-	MutexId_t* mutex;
-	ArrayList<ModeListEntry, uint32_t> store;
-	ModeListEntry *emptySlot;
-
-	void clear();
-	ModeListEntry* findEmptySlotNoLock(
-			ModeListEntry* startFrom);
-	void deleteListNoLock(
-			ModeListEntry *sequence);
-
-	ReturnValue_t isValidEntry(ModeListEntry *sequence);
-};
-
-#endif
-
-#endif /* MODESTORE_H_ */
-
+#ifndef MODESTORE_H_
+#define MODESTORE_H_
+
+#ifdef USE_MODESTORE
+
+#include "../../container/ArrayList.h"
+#include "../../container/SinglyLinkedList.h"
+#include "../../objectmanager/SystemObject.h"
+#include "../../subsystem/modes/ModeStoreIF.h"
+
+class ModeStore: public ModeStoreIF, public SystemObject {
+public:
+	ModeStore(object_id_t objectId, uint32_t slots);
+	virtual ~ModeStore();
+
+	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
+			ModeListEntry **storedFirstEntry);
+
+	virtual ReturnValue_t deleteList(
+			ModeListEntry *sequence);
+
+	virtual ReturnValue_t readList(
+			ModeListEntry *sequence,
+			ArrayList<ModeListEntry> *into);
+
+	virtual uint32_t getFreeSlots();
+
+private:
+	MutexId_t* mutex;
+	ArrayList<ModeListEntry, uint32_t> store;
+	ModeListEntry *emptySlot;
+
+	void clear();
+	ModeListEntry* findEmptySlotNoLock(
+			ModeListEntry* startFrom);
+	void deleteListNoLock(
+			ModeListEntry *sequence);
+
+	ReturnValue_t isValidEntry(ModeListEntry *sequence);
+};
+
+#endif
+
+#endif /* MODESTORE_H_ */
+
diff --git a/subsystem/modes/ModeStoreIF.h b/subsystem/modes/ModeStoreIF.h
index 7be7a5a7d..b9f2df70b 100644
--- a/subsystem/modes/ModeStoreIF.h
+++ b/subsystem/modes/ModeStoreIF.h
@@ -1,37 +1,37 @@
-#ifndef MODESTOREIF_H_
-#define MODESTOREIF_H_
-
-#ifdef USE_MODESTORE
-
-#include <framework/container/ArrayList.h>
-#include <framework/container/SinglyLinkedList.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/subsystem/modes/ModeDefinitions.h>
-
-class ModeStoreIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::MODE_STORE_IF;
-	static const ReturnValue_t INVALID_ENTRY = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t CANT_STORE_EMPTY = MAKE_RETURN_CODE(0x04);
-
-	virtual ~ModeStoreIF() {
-
-	}
-
-	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
-			ModeListEntry **storedFirstEntry) = 0;
-
-	virtual ReturnValue_t deleteList(
-			ModeListEntry *sequence) = 0;
-
-	virtual ReturnValue_t readList(
-			ModeListEntry *sequence,
-			ArrayList<ModeListEntry> *into) = 0;
-
-	virtual uint32_t getFreeSlots() = 0;
-};
-
-#endif
-
-#endif /* MODESTOREIF_H_ */
+#ifndef MODESTOREIF_H_
+#define MODESTOREIF_H_
+
+#ifdef USE_MODESTORE
+
+#include "../../container/ArrayList.h"
+#include "../../container/SinglyLinkedList.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../subsystem/modes/ModeDefinitions.h"
+
+class ModeStoreIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::MODE_STORE_IF;
+	static const ReturnValue_t INVALID_ENTRY = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t CANT_STORE_EMPTY = MAKE_RETURN_CODE(0x04);
+
+	virtual ~ModeStoreIF() {
+
+	}
+
+	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
+			ModeListEntry **storedFirstEntry) = 0;
+
+	virtual ReturnValue_t deleteList(
+			ModeListEntry *sequence) = 0;
+
+	virtual ReturnValue_t readList(
+			ModeListEntry *sequence,
+			ArrayList<ModeListEntry> *into) = 0;
+
+	virtual uint32_t getFreeSlots() = 0;
+};
+
+#endif
+
+#endif /* MODESTOREIF_H_ */
diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h
index d716cdfbb..902b2e3c9 100644
--- a/tasks/ExecutableObjectIF.h
+++ b/tasks/ExecutableObjectIF.h
@@ -1,53 +1,53 @@
-#ifndef FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
-#define FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
-
-class PeriodicTaskIF;
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-#include <cstring>
-/**
- * @brief	The interface provides a method to execute objects within a task.
- * @details	The performOperation method, that is required by the interface is
- * 			executed cyclically within a task context.
- * @author  Bastian Baetz
- */
-class ExecutableObjectIF {
-public:
-	/**
-	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~ExecutableObjectIF() { }
-	/**
-	 * @brief	The performOperation method is executed in a task.
-	 * @details	There are no restrictions for calls within this method, so any
-	 * 			other member of the class can be used.
-	 * @return	Currently, the return value is ignored.
-	 */
-	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) = 0;
-
-	/**
-	 * @brief Function called during setup assignment of object to task
-	 * @details
-	 * Has to be called from the function that assigns the object to a task and
-	 * enables the object implementation to overwrite this function and get
-	 * a reference to the executing task
-	 * @param task_ Pointer to the taskIF of this task
-	 */
-	virtual void setTaskIF(PeriodicTaskIF* task_) {};
-
-	/**
-	 * This function should be called after the object was assigned to a
-	 * specific task.
-	 *
-	 * Example: Can be used to get task execution frequency.
-	 * The task is created after initialize() and the object ctors have been
-	 * called so the execution frequency can't be cached in initialize()
-	 * @return
-	 */
-	virtual ReturnValue_t initializeAfterTaskCreation() {
-	    return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-#endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */
+#ifndef FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
+#define FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
+
+class PeriodicTaskIF;
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+#include <cstring>
+/**
+ * @brief	The interface provides a method to execute objects within a task.
+ * @details	The performOperation method, that is required by the interface is
+ * 			executed cyclically within a task context.
+ * @author  Bastian Baetz
+ */
+class ExecutableObjectIF {
+public:
+	/**
+	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~ExecutableObjectIF() { }
+	/**
+	 * @brief	The performOperation method is executed in a task.
+	 * @details	There are no restrictions for calls within this method, so any
+	 * 			other member of the class can be used.
+	 * @return	Currently, the return value is ignored.
+	 */
+	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) = 0;
+
+	/**
+	 * @brief Function called during setup assignment of object to task
+	 * @details
+	 * Has to be called from the function that assigns the object to a task and
+	 * enables the object implementation to overwrite this function and get
+	 * a reference to the executing task
+	 * @param task_ Pointer to the taskIF of this task
+	 */
+	virtual void setTaskIF(PeriodicTaskIF* task_) {};
+
+	/**
+	 * This function should be called after the object was assigned to a
+	 * specific task.
+	 *
+	 * Example: Can be used to get task execution frequency.
+	 * The task is created after initialize() and the object ctors have been
+	 * called so the execution frequency can't be cached in initialize()
+	 * @return
+	 */
+	virtual ReturnValue_t initializeAfterTaskCreation() {
+	    return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+#endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index 4331aadab..cccc6371f 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -1,16 +1,16 @@
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/tasks/FixedSequenceSlot.h>
-#include <cstddef>
-
-FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
-		int8_t setSequenceId, PeriodicTaskIF* executingTask) :
-		pollingTimeMs(setTime), opcode(setSequenceId) {
-	handler = objectManager->get<ExecutableObjectIF>(handlerId);
-	if(executingTask != nullptr) {
-	    handler->setTaskIF(executingTask);
-	}
-	handler->initializeAfterTaskCreation();
-}
-
-FixedSequenceSlot::~FixedSequenceSlot() {}
-
+#include "../objectmanager/SystemObjectIF.h"
+#include "../tasks/FixedSequenceSlot.h"
+#include <cstddef>
+
+FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
+		int8_t setSequenceId, PeriodicTaskIF* executingTask) :
+		pollingTimeMs(setTime), opcode(setSequenceId) {
+	handler = objectManager->get<ExecutableObjectIF>(handlerId);
+	if(executingTask != nullptr) {
+	    handler->setTaskIF(executingTask);
+	}
+	handler->initializeAfterTaskCreation();
+}
+
+FixedSequenceSlot::~FixedSequenceSlot() {}
+
diff --git a/tasks/FixedSequenceSlot.h b/tasks/FixedSequenceSlot.h
index 72a35c744..e33134de9 100644
--- a/tasks/FixedSequenceSlot.h
+++ b/tasks/FixedSequenceSlot.h
@@ -1,55 +1,55 @@
-#ifndef FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
-#define FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-class PeriodicTaskIF;
-
-/**
- * @brief	This class is the representation of a single polling sequence
- *          table entry.
- * @details
- * The PollingSlot class is the representation of a single polling
- * sequence table entry.
- * @author  baetz
- */
-class FixedSequenceSlot {
-public:
-	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
-			int8_t setSequenceId, PeriodicTaskIF* executingTask );
-	virtual ~FixedSequenceSlot();
-
-	/**
-	 * @brief	Handler identifies which device handler object is executed in this slot.
-	 */
-	ExecutableObjectIF*	handler = nullptr;
-
-	/**
-	 * @brief	This attribute defines when a device handler object is executed.
-	 *
-	 * @details	The pollingTime attribute identifies the time the handler is executed in ms.
-	 * 			It must be smaller than the period length of the polling sequence.
-	 */
-	uint32_t	pollingTimeMs;
-
-	/**
-	 * @brief	This value defines the type of device communication.
-	 *
-	 * @details	The state of this value decides what communication routine is
-	 * 			called in the PST executable or the device handler object.
-	 */
-	uint8_t	opcode;
-
-	/**
-	 * @brief 	Operator overload for the comparison operator to
-	 * 			allow sorting by polling time.
-	 * @param fixedSequenceSlot
-	 * @return
-	 */
-	bool operator <(const FixedSequenceSlot & fixedSequenceSlot) const {
-		return pollingTimeMs < fixedSequenceSlot.pollingTimeMs;
-	}
-};
-
-
-#endif /* FIXEDSEQUENCESLOT_H_ */
+#ifndef FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
+#define FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+class PeriodicTaskIF;
+
+/**
+ * @brief	This class is the representation of a single polling sequence
+ *          table entry.
+ * @details
+ * The PollingSlot class is the representation of a single polling
+ * sequence table entry.
+ * @author  baetz
+ */
+class FixedSequenceSlot {
+public:
+	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
+			int8_t setSequenceId, PeriodicTaskIF* executingTask );
+	virtual ~FixedSequenceSlot();
+
+	/**
+	 * @brief	Handler identifies which device handler object is executed in this slot.
+	 */
+	ExecutableObjectIF*	handler = nullptr;
+
+	/**
+	 * @brief	This attribute defines when a device handler object is executed.
+	 *
+	 * @details	The pollingTime attribute identifies the time the handler is executed in ms.
+	 * 			It must be smaller than the period length of the polling sequence.
+	 */
+	uint32_t	pollingTimeMs;
+
+	/**
+	 * @brief	This value defines the type of device communication.
+	 *
+	 * @details	The state of this value decides what communication routine is
+	 * 			called in the PST executable or the device handler object.
+	 */
+	uint8_t	opcode;
+
+	/**
+	 * @brief 	Operator overload for the comparison operator to
+	 * 			allow sorting by polling time.
+	 * @param fixedSequenceSlot
+	 * @return
+	 */
+	bool operator <(const FixedSequenceSlot & fixedSequenceSlot) const {
+		return pollingTimeMs < fixedSequenceSlot.pollingTimeMs;
+	}
+};
+
+
+#endif /* FIXEDSEQUENCESLOT_H_ */
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index 3e542bfce..27dfff2b2 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -1,124 +1,124 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tasks/FixedSlotSequence.h>
-#include <cstdlib>
-
-FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
-		lengthMs(setLengthMs) {
-	current = slotList.begin();
-}
-
-FixedSlotSequence::~FixedSlotSequence() {
-	// Call the destructor on each list entry.
-	slotList.clear();
-}
-
-void FixedSlotSequence::executeAndAdvance() {
-	current->handler->performOperation(current->opcode);
-//	if (returnValue != RETURN_OK) {
-//		this->sendErrorMessage( returnValue );
-//	}
-	//Increment the polling Sequence iterator
-	this->current++;
-	//Set it to the beginning, if the list's end is reached.
-	if (this->current == this->slotList.end()) {
-		this->current = this->slotList.begin();
-	}
-}
-
-uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
-	uint32_t oldTime;
-	SlotListIter slotListIter = current;
-	// Get the pollingTimeMs of the current slot object.
-	oldTime = slotListIter->pollingTimeMs;
-	// Advance to the next object.
-	slotListIter++;
-	// Find the next interval which is not 0.
-	while (slotListIter != slotList.end()) {
-		if (oldTime != slotListIter->pollingTimeMs) {
-			return slotListIter->pollingTimeMs - oldTime;
-		} else {
-			slotListIter++;
-		}
-	}
-	// If the list end is reached (this is definitely an interval != 0),
-	// the interval is calculated by subtracting the remaining time of the PST
-	// and adding the start time of the first handler in the list.
-	slotListIter = slotList.begin();
-	return lengthMs - oldTime + slotListIter->pollingTimeMs;
-}
-
-uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
-	uint32_t currentTime;
-	SlotListIter slotListIter = current;
-	// Get the pollingTimeMs of the current slot object.
-	currentTime = slotListIter->pollingTimeMs;
-
-	//if it is the first slot, calculate difference to last slot
-	if (slotListIter == slotList.begin()){
-		return lengthMs - (--slotList.end())->pollingTimeMs + currentTime;
-	}
-	// get previous slot
-	slotListIter--;
-
-	return currentTime - slotListIter->pollingTimeMs;
-}
-
-bool FixedSlotSequence::slotFollowsImmediately() {
-	uint32_t currentTime = current->pollingTimeMs;
-	SlotListIter fixedSequenceIter = this->current;
-	// Get the pollingTimeMs of the current slot object.
-	if (fixedSequenceIter == slotList.begin())
-		return false;
-	fixedSequenceIter--;
-	if (fixedSequenceIter->pollingTimeMs == currentTime) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-uint32_t FixedSlotSequence::getLengthMs() const {
-	return this->lengthMs;
-}
-
-ReturnValue_t FixedSlotSequence::checkSequence() const {
-	if(slotList.empty()) {
-		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	auto slotIt = slotList.begin();
-	uint32_t count = 0;
-	uint32_t time = 0;
-	while (slotIt != slotList.end()) {
-		if (slotIt->handler == nullptr) {
-			sif::error << "FixedSlotSequene::initialize: ObjectId does not exist!"
-					<< std::endl;
-			count++;
-		} else if (slotIt->pollingTimeMs < time) {
-			sif::error << "FixedSlotSequence::initialize: Time: "
-					<< slotIt->pollingTimeMs
-					<< " is smaller than previous with " << time << std::endl;
-			count++;
-		} else {
-			// All ok, print slot.
-			//info << "Current slot polling time: " << std::endl;
-			//info << std::dec << slotIt->pollingTimeMs << std::endl;
-		}
-		time = slotIt->pollingTimeMs;
-		slotIt++;
-	}
-	//info << "Number of elements in slot list: "
-	//	   << slotList.size() << std::endl;
-	if (count > 0) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
-		int8_t executionStep, PeriodicTaskIF* executingTask) {
-	this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs, executionStep,
-			executingTask));
-	this->current = slotList.begin();
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tasks/FixedSlotSequence.h"
+#include <cstdlib>
+
+FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
+		lengthMs(setLengthMs) {
+	current = slotList.begin();
+}
+
+FixedSlotSequence::~FixedSlotSequence() {
+	// Call the destructor on each list entry.
+	slotList.clear();
+}
+
+void FixedSlotSequence::executeAndAdvance() {
+	current->handler->performOperation(current->opcode);
+//	if (returnValue != RETURN_OK) {
+//		this->sendErrorMessage( returnValue );
+//	}
+	//Increment the polling Sequence iterator
+	this->current++;
+	//Set it to the beginning, if the list's end is reached.
+	if (this->current == this->slotList.end()) {
+		this->current = this->slotList.begin();
+	}
+}
+
+uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
+	uint32_t oldTime;
+	SlotListIter slotListIter = current;
+	// Get the pollingTimeMs of the current slot object.
+	oldTime = slotListIter->pollingTimeMs;
+	// Advance to the next object.
+	slotListIter++;
+	// Find the next interval which is not 0.
+	while (slotListIter != slotList.end()) {
+		if (oldTime != slotListIter->pollingTimeMs) {
+			return slotListIter->pollingTimeMs - oldTime;
+		} else {
+			slotListIter++;
+		}
+	}
+	// If the list end is reached (this is definitely an interval != 0),
+	// the interval is calculated by subtracting the remaining time of the PST
+	// and adding the start time of the first handler in the list.
+	slotListIter = slotList.begin();
+	return lengthMs - oldTime + slotListIter->pollingTimeMs;
+}
+
+uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
+	uint32_t currentTime;
+	SlotListIter slotListIter = current;
+	// Get the pollingTimeMs of the current slot object.
+	currentTime = slotListIter->pollingTimeMs;
+
+	//if it is the first slot, calculate difference to last slot
+	if (slotListIter == slotList.begin()){
+		return lengthMs - (--slotList.end())->pollingTimeMs + currentTime;
+	}
+	// get previous slot
+	slotListIter--;
+
+	return currentTime - slotListIter->pollingTimeMs;
+}
+
+bool FixedSlotSequence::slotFollowsImmediately() {
+	uint32_t currentTime = current->pollingTimeMs;
+	SlotListIter fixedSequenceIter = this->current;
+	// Get the pollingTimeMs of the current slot object.
+	if (fixedSequenceIter == slotList.begin())
+		return false;
+	fixedSequenceIter--;
+	if (fixedSequenceIter->pollingTimeMs == currentTime) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+uint32_t FixedSlotSequence::getLengthMs() const {
+	return this->lengthMs;
+}
+
+ReturnValue_t FixedSlotSequence::checkSequence() const {
+	if(slotList.empty()) {
+		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	auto slotIt = slotList.begin();
+	uint32_t count = 0;
+	uint32_t time = 0;
+	while (slotIt != slotList.end()) {
+		if (slotIt->handler == nullptr) {
+			sif::error << "FixedSlotSequene::initialize: ObjectId does not exist!"
+					<< std::endl;
+			count++;
+		} else if (slotIt->pollingTimeMs < time) {
+			sif::error << "FixedSlotSequence::initialize: Time: "
+					<< slotIt->pollingTimeMs
+					<< " is smaller than previous with " << time << std::endl;
+			count++;
+		} else {
+			// All ok, print slot.
+			//info << "Current slot polling time: " << std::endl;
+			//info << std::dec << slotIt->pollingTimeMs << std::endl;
+		}
+		time = slotIt->pollingTimeMs;
+		slotIt++;
+	}
+	//info << "Number of elements in slot list: "
+	//	   << slotList.size() << std::endl;
+	if (count > 0) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
+		int8_t executionStep, PeriodicTaskIF* executingTask) {
+	this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs, executionStep,
+			executingTask));
+	this->current = slotList.begin();
+}
diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 61883658a..67ce00947 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -1,154 +1,154 @@
-#ifndef FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
-#define FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/tasks/FixedSequenceSlot.h>
-
-#include <set>
-
-/**
- * @brief	This class is the representation of a Polling Sequence Table in software.
- * @details
- * The FixedSlotSequence object maintains the dynamic execution of
- * device handler objects.
- *
- * The main idea is to create a list of device handlers, to announce all
- * handlers to thepolling sequence and to maintain a list of
- * polling slot objects. This slot list represents the Polling Sequence Table
- * in software.
- *
- * Each polling slot contains information to indicate when and
- * which device handler shall be executed within a given polling period.
- * The sequence is then executed by iterating through this slot list.
- * Handlers are invoking by calling a certain function stored in the handler list.
- */
-class FixedSlotSequence {
-public:
-	using SlotList = std::multiset<FixedSequenceSlot>;
-	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
-
-	/**
-	 * @brief	The constructor of the FixedSlotSequence object.
-	 *
-	 * @details	The constructor takes two arguments, the period length and the init function.
-	 *
-	 * @param	setLength	The period length, expressed in ms.
-	 */
-	FixedSlotSequence(uint32_t setLengthMs);
-
-	/**
-	 * @brief	The destructor of the FixedSlotSequence object.
-	 *
-	 * @details	The destructor frees all allocated memory by iterating through the slotList
-	 *  		and deleting all allocated resources.
-	 */
-	virtual ~FixedSlotSequence();
-
-	/**
-	 * @brief	This is a method to add an PollingSlot object to slotList.
-	 *
-	 * @details	Here, a polling slot object is added to the slot list. It is appended
-	 * 			to the end of the list. The list is currently NOT reordered.
-	 * 			Afterwards, the iterator current is set to the beginning of the list.
-	 * 	@param Object ID of the object to add
-	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
-	 * 				   will be called inside the slot period.
-	 * 	@param setSequenceId ID which can be used to distinguish
-	 * 	                     different task operations
-	 * 	@param
-	 * 	@param
-	 */
-	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
-			PeriodicTaskIF* executingTask);
-
-	/**
-	 * Checks if the current slot shall be executed immediately after the one before.
-	 * This allows to distinguish between grouped and not grouped handlers.
-	 * @return 	- @c true if the slot has the same polling time as the previous
-	 * 			- @c false else
-	 */
-	bool slotFollowsImmediately();
-
-	/**
-	 * @brief	This method returns the time until the next software
-	 * 			component is invoked.
-	 *
-	 * @details
-	 * This method is vitally important for the operation of the PST.
-	 * By fetching the polling time of the current slot and that of the
-	 * next one (or the first one, if the list end is reached)
-	 * it calculates and returns the interval in milliseconds within
-	 * which the handler execution shall take place.
-	 * If the next slot has the same time as the current one, it is ignored
-	 * until a slot with different time or the end of the PST is found.
-	 */
-	uint32_t getIntervalToNextSlotMs();
-
-	/**
-	 * @brief	This method returns the time difference between the current
-	 * 			slot and the previous slot
-	 *
-	 * @details
-	 * This method is vitally important for the operation of the PST.
-	 * By fetching the polling time of the current slot and that of the previous
-	 * one (or the last one, if the slot is the first one) it calculates and
-	 * returns the interval in milliseconds that the handler execution shall
-	 * be delayed.
-	 */
-	uint32_t getIntervalToPreviousSlotMs();
-
-	/**
-	 * @brief	This method returns the length of this FixedSlotSequence instance.
-	 */
-	uint32_t getLengthMs() const;
-
-	/**
-	 * @brief	The method to execute the device handler entered in the current
-	 * 			PollingSlot object.
-	 *
-	 * @details
-	 * Within this method the device handler object to be executed is chosen by
-	 * looking up the handler address of the current slot in the handlerMap.
-	 * Either the device handler's talkToInterface or its listenToInterface
-	 * method is invoked, depending on the isTalking flag of the polling slot.
-	 * After execution the iterator current is increased or, by reaching the
-	 * end of slotList, reset to the beginning.
-	 */
-	void executeAndAdvance();
-
-	/**
-	 * @brief	An iterator that indicates the current polling slot to execute.
-	 *
-	 * @details	This is an iterator for slotList and always points to the
-	 * 			polling slot which is executed next.
-	 */
-	SlotListIter current;
-
-	/**
-	 * Iterate through slotList and check successful creation.
-	 * Checks if timing is ok (must be ascending) and if all handlers were found.
-	 * @return
-	 */
-	ReturnValue_t checkSequence() const;
-
-protected:
-
-	/**
-	 * @brief	This list contains all PollingSlot objects, defining order and
-	 * 			execution time of the device handler objects.
-	 *
-	 * @details
-	 * The slot list is a std:list object that contains all created
-	 * PollingSlot instances. They are NOT ordered automatically, so by
-	 * adding entries, the correct order needs to be ensured. By iterating
-	 * through this list the polling sequence is executed. Two entries with
-	 * identical polling times are executed immediately one after another.
-	 */
-	SlotList slotList;
-
-	uint32_t lengthMs;
-
-	bool isEmpty = false;
-};
-
-#endif /* FIXEDSLOTSEQUENCE_H_ */
+#ifndef FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
+#define FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/FixedSequenceSlot.h"
+
+#include <set>
+
+/**
+ * @brief	This class is the representation of a Polling Sequence Table in software.
+ * @details
+ * The FixedSlotSequence object maintains the dynamic execution of
+ * device handler objects.
+ *
+ * The main idea is to create a list of device handlers, to announce all
+ * handlers to thepolling sequence and to maintain a list of
+ * polling slot objects. This slot list represents the Polling Sequence Table
+ * in software.
+ *
+ * Each polling slot contains information to indicate when and
+ * which device handler shall be executed within a given polling period.
+ * The sequence is then executed by iterating through this slot list.
+ * Handlers are invoking by calling a certain function stored in the handler list.
+ */
+class FixedSlotSequence {
+public:
+	using SlotList = std::multiset<FixedSequenceSlot>;
+	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
+
+	/**
+	 * @brief	The constructor of the FixedSlotSequence object.
+	 *
+	 * @details	The constructor takes two arguments, the period length and the init function.
+	 *
+	 * @param	setLength	The period length, expressed in ms.
+	 */
+	FixedSlotSequence(uint32_t setLengthMs);
+
+	/**
+	 * @brief	The destructor of the FixedSlotSequence object.
+	 *
+	 * @details	The destructor frees all allocated memory by iterating through the slotList
+	 *  		and deleting all allocated resources.
+	 */
+	virtual ~FixedSlotSequence();
+
+	/**
+	 * @brief	This is a method to add an PollingSlot object to slotList.
+	 *
+	 * @details	Here, a polling slot object is added to the slot list. It is appended
+	 * 			to the end of the list. The list is currently NOT reordered.
+	 * 			Afterwards, the iterator current is set to the beginning of the list.
+	 * 	@param Object ID of the object to add
+	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
+	 * 				   will be called inside the slot period.
+	 * 	@param setSequenceId ID which can be used to distinguish
+	 * 	                     different task operations
+	 * 	@param
+	 * 	@param
+	 */
+	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
+			PeriodicTaskIF* executingTask);
+
+	/**
+	 * Checks if the current slot shall be executed immediately after the one before.
+	 * This allows to distinguish between grouped and not grouped handlers.
+	 * @return 	- @c true if the slot has the same polling time as the previous
+	 * 			- @c false else
+	 */
+	bool slotFollowsImmediately();
+
+	/**
+	 * @brief	This method returns the time until the next software
+	 * 			component is invoked.
+	 *
+	 * @details
+	 * This method is vitally important for the operation of the PST.
+	 * By fetching the polling time of the current slot and that of the
+	 * next one (or the first one, if the list end is reached)
+	 * it calculates and returns the interval in milliseconds within
+	 * which the handler execution shall take place.
+	 * If the next slot has the same time as the current one, it is ignored
+	 * until a slot with different time or the end of the PST is found.
+	 */
+	uint32_t getIntervalToNextSlotMs();
+
+	/**
+	 * @brief	This method returns the time difference between the current
+	 * 			slot and the previous slot
+	 *
+	 * @details
+	 * This method is vitally important for the operation of the PST.
+	 * By fetching the polling time of the current slot and that of the previous
+	 * one (or the last one, if the slot is the first one) it calculates and
+	 * returns the interval in milliseconds that the handler execution shall
+	 * be delayed.
+	 */
+	uint32_t getIntervalToPreviousSlotMs();
+
+	/**
+	 * @brief	This method returns the length of this FixedSlotSequence instance.
+	 */
+	uint32_t getLengthMs() const;
+
+	/**
+	 * @brief	The method to execute the device handler entered in the current
+	 * 			PollingSlot object.
+	 *
+	 * @details
+	 * Within this method the device handler object to be executed is chosen by
+	 * looking up the handler address of the current slot in the handlerMap.
+	 * Either the device handler's talkToInterface or its listenToInterface
+	 * method is invoked, depending on the isTalking flag of the polling slot.
+	 * After execution the iterator current is increased or, by reaching the
+	 * end of slotList, reset to the beginning.
+	 */
+	void executeAndAdvance();
+
+	/**
+	 * @brief	An iterator that indicates the current polling slot to execute.
+	 *
+	 * @details	This is an iterator for slotList and always points to the
+	 * 			polling slot which is executed next.
+	 */
+	SlotListIter current;
+
+	/**
+	 * Iterate through slotList and check successful creation.
+	 * Checks if timing is ok (must be ascending) and if all handlers were found.
+	 * @return
+	 */
+	ReturnValue_t checkSequence() const;
+
+protected:
+
+	/**
+	 * @brief	This list contains all PollingSlot objects, defining order and
+	 * 			execution time of the device handler objects.
+	 *
+	 * @details
+	 * The slot list is a std:list object that contains all created
+	 * PollingSlot instances. They are NOT ordered automatically, so by
+	 * adding entries, the correct order needs to be ensured. By iterating
+	 * through this list the polling sequence is executed. Two entries with
+	 * identical polling times are executed immediately one after another.
+	 */
+	SlotList slotList;
+
+	uint32_t lengthMs;
+
+	bool isEmpty = false;
+};
+
+#endif /* FIXEDSLOTSEQUENCE_H_ */
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index 023b5ee04..3456dae78 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -1,29 +1,29 @@
-#ifndef FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
-#define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
-
-/**
- * @brief Following the same principle as the base class IF.
- *        This is the interface for a Fixed timeslot task
- */
-class FixedTimeslotTaskIF : public PeriodicTaskIF {
-public:
-	virtual ~FixedTimeslotTaskIF() {}
-
-	/**
-	 * Add an object with a slot time and the execution step to the task.
-	 * The execution step shall be passed to the object.
-	 * @param componentId
-	 * @param slotTimeMs
-	 * @param executionStep
-	 * @return
-	 */
-	virtual ReturnValue_t addSlot(object_id_t componentId,
-			uint32_t slotTimeMs, int8_t executionStep) = 0;
-	/** Check whether the sequence is valid */
-	virtual ReturnValue_t checkSequence() const = 0;
-};
-
-#endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
+#ifndef FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
+#define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tasks/PeriodicTaskIF.h"
+
+/**
+ * @brief Following the same principle as the base class IF.
+ *        This is the interface for a Fixed timeslot task
+ */
+class FixedTimeslotTaskIF : public PeriodicTaskIF {
+public:
+	virtual ~FixedTimeslotTaskIF() {}
+
+	/**
+	 * Add an object with a slot time and the execution step to the task.
+	 * The execution step shall be passed to the object.
+	 * @param componentId
+	 * @param slotTimeMs
+	 * @param executionStep
+	 * @return
+	 */
+	virtual ReturnValue_t addSlot(object_id_t componentId,
+			uint32_t slotTimeMs, int8_t executionStep) = 0;
+	/** Check whether the sequence is valid */
+	virtual ReturnValue_t checkSequence() const = 0;
+};
+
+#endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
diff --git a/tasks/PeriodicTaskIF.h b/tasks/PeriodicTaskIF.h
index f54d61557..38cf201ba 100644
--- a/tasks/PeriodicTaskIF.h
+++ b/tasks/PeriodicTaskIF.h
@@ -1,49 +1,49 @@
-#ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_
-#define FRAMEWORK_TASK_PERIODICTASKIF_H_
-
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/timemanager/Clock.h>
-#include <cstddef>
-class ExecutableObjectIF;
-
-/**
- * New version of TaskIF
- * Follows RAII principles, i.e. there's no create or delete method.
- * Minimalistic.
-*/
-class PeriodicTaskIF {
-public:
-	static const size_t MINIMUM_STACK_SIZE;
-	/**
-	 * @brief	A virtual destructor as it is mandatory for interfaces.
-	 */
-	virtual ~PeriodicTaskIF() { }
-	/**
-	 * @brief	With the startTask method, a created task can be started
-	 *          for the first time.
-	 */
-	virtual ReturnValue_t startTask() = 0;
-
-	/**
-	 * Add a component (object) to a periodic task. The pointer to the
-	 * task can be set optionally
-	 * @param object
-	 * Add an object to the task. The most important case is to add an
-	 * executable object with a function which will be called regularly
-	 * (see ExecutableObjectIF)
-	 * @param setTaskIF
-	 * Can be used to specify whether the task object pointer is passed
-	 * to the component.
-	 * @return
-	 */
-	virtual ReturnValue_t addComponent(object_id_t object) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-
-	virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
-
-	virtual uint32_t getPeriodMs() const = 0;
-};
-
-
-#endif /* PERIODICTASKIF_H_ */
+#ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_
+#define FRAMEWORK_TASK_PERIODICTASKIF_H_
+
+#include "../objectmanager/SystemObjectIF.h"
+#include "../timemanager/Clock.h"
+#include <cstddef>
+class ExecutableObjectIF;
+
+/**
+ * New version of TaskIF
+ * Follows RAII principles, i.e. there's no create or delete method.
+ * Minimalistic.
+*/
+class PeriodicTaskIF {
+public:
+	static const size_t MINIMUM_STACK_SIZE;
+	/**
+	 * @brief	A virtual destructor as it is mandatory for interfaces.
+	 */
+	virtual ~PeriodicTaskIF() { }
+	/**
+	 * @brief	With the startTask method, a created task can be started
+	 *          for the first time.
+	 */
+	virtual ReturnValue_t startTask() = 0;
+
+	/**
+	 * Add a component (object) to a periodic task. The pointer to the
+	 * task can be set optionally
+	 * @param object
+	 * Add an object to the task. The most important case is to add an
+	 * executable object with a function which will be called regularly
+	 * (see ExecutableObjectIF)
+	 * @param setTaskIF
+	 * Can be used to specify whether the task object pointer is passed
+	 * to the component.
+	 * @return
+	 */
+	virtual ReturnValue_t addComponent(object_id_t object) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+
+	virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
+
+	virtual uint32_t getPeriodMs() const = 0;
+};
+
+
+#endif /* PERIODICTASKIF_H_ */
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index 7f8edaf12..b2f347889 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -1,49 +1,49 @@
-#ifndef FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
-#define FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
-#include <framework/tasks/SemaphoreIF.h>
-
-/**
- * Creates Semaphore.
- * This class is a "singleton" interface, i.e. it provides an
- * interface, but also is the base class for a singleton.
- */
-class SemaphoreFactory {
-public:
-	virtual ~SemaphoreFactory();
-	/**
-	 * Returns the single instance of SemaphoreFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static SemaphoreFactory* instance();
-
-	/**
-	 * Create a binary semaphore.
-	 * Creator function for a binary semaphore which may only be acquired once
-	 * @param argument Can be used to pass implementation specific information.
-	 * @return Pointer to newly created semaphore class instance.
-	 */
-	SemaphoreIF* createBinarySemaphore(uint32_t arguments = 0);
-	/**
-	 * Create a counting semaphore.
-	 * Creator functons for a counting semaphore which may be acquired multiple
-	 * times.
-	 * @param count Semaphore can be taken count times.
-	 * @param initCount Initial count value.
-	 * @param argument Can be used to pass implementation specific information.
-	 * @return
-	 */
-	SemaphoreIF* createCountingSemaphore(const uint8_t maxCount,
-			uint8_t initCount, uint32_t arguments = 0);
-
-	void deleteSemaphore(SemaphoreIF* semaphore);
-
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	SemaphoreFactory();
-	static SemaphoreFactory* factoryInstance;
-};
-
-#endif /* FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_ */
+#ifndef FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
+#define FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
+#include "../tasks/SemaphoreIF.h"
+
+/**
+ * Creates Semaphore.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class SemaphoreFactory {
+public:
+	virtual ~SemaphoreFactory();
+	/**
+	 * Returns the single instance of SemaphoreFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static SemaphoreFactory* instance();
+
+	/**
+	 * Create a binary semaphore.
+	 * Creator function for a binary semaphore which may only be acquired once
+	 * @param argument Can be used to pass implementation specific information.
+	 * @return Pointer to newly created semaphore class instance.
+	 */
+	SemaphoreIF* createBinarySemaphore(uint32_t arguments = 0);
+	/**
+	 * Create a counting semaphore.
+	 * Creator functons for a counting semaphore which may be acquired multiple
+	 * times.
+	 * @param count Semaphore can be taken count times.
+	 * @param initCount Initial count value.
+	 * @param argument Can be used to pass implementation specific information.
+	 * @return
+	 */
+	SemaphoreIF* createCountingSemaphore(const uint8_t maxCount,
+			uint8_t initCount, uint32_t arguments = 0);
+
+	void deleteSemaphore(SemaphoreIF* semaphore);
+
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	SemaphoreFactory();
+	static SemaphoreFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_ */
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index 4fc92ebd3..3fed4511f 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -1,72 +1,72 @@
-#ifndef FRAMEWORK_TASKS_SEMAPHOREIF_H_
-#define FRAMEWORK_TASKS_SEMAPHOREIF_H_
-#include <framework/returnvalues/FwClassIds.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstdint>
-
-/**
- * @brief 	Generic interface for semaphores, which can be used to achieve
- * 			task synchronization. This is a generic interface which can be
- * 			used for both binary semaphores and counting semaphores.
- * @details
- * A semaphore is a synchronization primitive.
- * See: https://en.wikipedia.org/wiki/Semaphore_(programming)
- * A semaphore can be used to achieve task synchonization and track the
- * availability of resources by using either the binary or the counting
- * semaphore types.
- *
- * If mutual exlcusion of a resource is desired, a mutex should be used,
- * which is a special form of a semaphore and has an own interface.
- */
-class SemaphoreIF {
-public:
-	virtual~ SemaphoreIF() {};
-	/**
-	 * @brief 	Timeout value used for polling lock attempt.
-	 * @details
-	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
-	 * immediately. Value needs to be defined in implementation.
-	 */
-	static const uint32_t POLLING;
-	/**
-	 * @brief 	Timeout value used for permanent blocking lock attempt.
-	 * @details
-	 * The task will be blocked (indefinitely) until the mutex is unlocked.
-	 * Value needs to be defined in implementation.
-	 */
-	static const uint32_t BLOCKING;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-	//! Semaphore timeout
-	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
-	//! The current semaphore can not be given, because it is not owned
-	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
-	static constexpr ReturnValue_t SEMAPHORE_INVALID = MAKE_RETURN_CODE(3);
-
-	/**
-	 * Generic call to acquire a semaphore.
-	 * If there are no more semaphores to be taken (for a counting semaphore,
-	 * a semaphore may be taken more than once), the taks will block
-	 * for a maximum of timeoutMs while trying to acquire the semaphore.
-	 * This can be used to achieve task synchrnization.
-	 * @param timeoutMs
-	 * @return - c RETURN_OK for successfull acquisition
-	 */
-	virtual ReturnValue_t acquire(uint32_t timeoutMs) = 0;
-
-	/**
-	 * Corrensponding call to release a semaphore.
-	 * @return -@c RETURN_OK for successfull release
-	 */
-	virtual ReturnValue_t release() = 0;
-
-	/**
-	 * If the semaphore is a counting semaphore then the semaphores current
-	 * count value is returned. If the semaphore is a binary semaphore then 1
-	 * is returned if the semaphore is available, and 0 is returned if the
-	 * semaphore is not available.
-	 */
-	virtual uint8_t getSemaphoreCounter() const = 0;
-};
-
-#endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */
+#ifndef FRAMEWORK_TASKS_SEMAPHOREIF_H_
+#define FRAMEWORK_TASKS_SEMAPHOREIF_H_
+#include "../returnvalues/FwClassIds.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstdint>
+
+/**
+ * @brief 	Generic interface for semaphores, which can be used to achieve
+ * 			task synchronization. This is a generic interface which can be
+ * 			used for both binary semaphores and counting semaphores.
+ * @details
+ * A semaphore is a synchronization primitive.
+ * See: https://en.wikipedia.org/wiki/Semaphore_(programming)
+ * A semaphore can be used to achieve task synchonization and track the
+ * availability of resources by using either the binary or the counting
+ * semaphore types.
+ *
+ * If mutual exlcusion of a resource is desired, a mutex should be used,
+ * which is a special form of a semaphore and has an own interface.
+ */
+class SemaphoreIF {
+public:
+	virtual~ SemaphoreIF() {};
+	/**
+	 * @brief 	Timeout value used for polling lock attempt.
+	 * @details
+	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
+	 * immediately. Value needs to be defined in implementation.
+	 */
+	static const uint32_t POLLING;
+	/**
+	 * @brief 	Timeout value used for permanent blocking lock attempt.
+	 * @details
+	 * The task will be blocked (indefinitely) until the mutex is unlocked.
+	 * Value needs to be defined in implementation.
+	 */
+	static const uint32_t BLOCKING;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+	//! Semaphore timeout
+	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
+	//! The current semaphore can not be given, because it is not owned
+	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t SEMAPHORE_INVALID = MAKE_RETURN_CODE(3);
+
+	/**
+	 * Generic call to acquire a semaphore.
+	 * If there are no more semaphores to be taken (for a counting semaphore,
+	 * a semaphore may be taken more than once), the taks will block
+	 * for a maximum of timeoutMs while trying to acquire the semaphore.
+	 * This can be used to achieve task synchrnization.
+	 * @param timeoutMs
+	 * @return - c RETURN_OK for successfull acquisition
+	 */
+	virtual ReturnValue_t acquire(uint32_t timeoutMs) = 0;
+
+	/**
+	 * Corrensponding call to release a semaphore.
+	 * @return -@c RETURN_OK for successfull release
+	 */
+	virtual ReturnValue_t release() = 0;
+
+	/**
+	 * If the semaphore is a counting semaphore then the semaphores current
+	 * count value is returned. If the semaphore is a binary semaphore then 1
+	 * is returned if the semaphore is available, and 0 is returned if the
+	 * semaphore is not available.
+	 */
+	virtual uint8_t getSemaphoreCounter() const = 0;
+};
+
+#endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index e1e2f5e2a..56b3083e5 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -1,73 +1,73 @@
-#ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
-#define FRAMEWORK_TASKS_TASKFACTORY_H_
-
-#include <cstdlib>
-#include <framework/tasks/FixedTimeslotTaskIF.h>
-#include <framework/tasks/Typedef.h>
-
-/**
- * Singleton Class that produces Tasks.
- */
-class TaskFactory {
-public:
-	virtual ~TaskFactory();
-	/**
-	 * Returns the single instance of TaskFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static TaskFactory* instance();
-
-	/**
-	 * Generic interface to create a periodic task
-	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack size if the task
-	 * @param periodInSeconds_ Period in seconds
-	 * @param deadLineMissedFunction_ This function is called if a deadline was
-	 * missed
-	 * @return Pointer to the created periodic task class
-	 */
-	PeriodicTaskIF* createPeriodicTask(TaskName name_,
-			TaskPriority taskPriority_, TaskStackSize stackSize_,
-			TaskPeriod periodInSeconds_,
-			TaskDeadlineMissedFunction deadLineMissedFunction_);
-
-	/**
-	 * Generic interface to create a fixed timeslot task
-	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack size if the task
-	 * @param periodInSeconds_ Period in seconds
-	 * @param deadLineMissedFunction_ This function is called if a deadline was
-	 * missed
-	 * @return Pointer to the created periodic task class
-	 */
-	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
-			TaskPriority taskPriority_, TaskStackSize stackSize_,
-			TaskPeriod periodInSeconds_,
-			TaskDeadlineMissedFunction deadLineMissedFunction_);
-
-	/**
-	 * Function to be called to delete a task
-	 * @param task The pointer to the task that shall be deleted,
-	 * 				NULL specifies current Task
-	 * @return Success of deletion
-	 */
-	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
-
-	/**
-	 * Function to be called to delay current task
-	 * @param delay The delay in milliseconds
-	 * @return Success of deletion
-	 */
-	static ReturnValue_t delayTask(uint32_t delayMs);
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	TaskFactory();
-	static TaskFactory* factoryInstance;
-};
-
-#endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */
+#ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
+#define FRAMEWORK_TASKS_TASKFACTORY_H_
+
+#include <cstdlib>
+#include "../tasks/FixedTimeslotTaskIF.h"
+#include "../tasks/Typedef.h"
+
+/**
+ * Singleton Class that produces Tasks.
+ */
+class TaskFactory {
+public:
+	virtual ~TaskFactory();
+	/**
+	 * Returns the single instance of TaskFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static TaskFactory* instance();
+
+	/**
+	 * Generic interface to create a periodic task
+	 * @param name_ Name of the task
+	 * @param taskPriority_ Priority of the task
+	 * @param stackSize_ Stack size if the task
+	 * @param periodInSeconds_ Period in seconds
+	 * @param deadLineMissedFunction_ This function is called if a deadline was
+	 * missed
+	 * @return Pointer to the created periodic task class
+	 */
+	PeriodicTaskIF* createPeriodicTask(TaskName name_,
+			TaskPriority taskPriority_, TaskStackSize stackSize_,
+			TaskPeriod periodInSeconds_,
+			TaskDeadlineMissedFunction deadLineMissedFunction_);
+
+	/**
+	 * Generic interface to create a fixed timeslot task
+	 * @param name_ Name of the task
+	 * @param taskPriority_ Priority of the task
+	 * @param stackSize_ Stack size if the task
+	 * @param periodInSeconds_ Period in seconds
+	 * @param deadLineMissedFunction_ This function is called if a deadline was
+	 * missed
+	 * @return Pointer to the created periodic task class
+	 */
+	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
+			TaskPriority taskPriority_, TaskStackSize stackSize_,
+			TaskPeriod periodInSeconds_,
+			TaskDeadlineMissedFunction deadLineMissedFunction_);
+
+	/**
+	 * Function to be called to delete a task
+	 * @param task The pointer to the task that shall be deleted,
+	 * 				NULL specifies current Task
+	 * @return Success of deletion
+	 */
+	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
+
+	/**
+	 * Function to be called to delay current task
+	 * @param delay The delay in milliseconds
+	 * @return Success of deletion
+	 */
+	static ReturnValue_t delayTask(uint32_t delayMs);
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	TaskFactory();
+	static TaskFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index 24c937302..68f26d2cf 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -1,82 +1,82 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tcdistribution/CCSDSDistributor.h>
-#include <framework/tmtcpacket/SpacePacketBase.h>
-
-CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
-		object_id_t setObjectId):
-		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
-}
-
-CCSDSDistributor::~CCSDSDistributor() {}
-
-TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
-//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
-//			this->currentMessage.getStorageId().pool_index << ", " <<
-//			this->currentMessage.getStorageId().packet_index << std::endl;
-	const uint8_t* packet = nullptr;
-	size_t size = 0;
-	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
-			&packet, &size );
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
-				"store failed!" << std::endl;
-	}
-	SpacePacketBase currentPacket(packet);
-
-//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
-//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
-	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
-	if ( position != this->queueMap.end() ) {
-		return position;
-	} else {
-		//The APID was not found. Forward packet to main SW-APID anyway to
-		// create acceptance failure report.
-		return this->queueMap.find( this->defaultApid );
-	}
-}
-
-MessageQueueId_t CCSDSDistributor::getRequestQueue() {
-	return tcQueue->getId();
-}
-
-ReturnValue_t CCSDSDistributor::registerApplication(
-		AcceptsTelecommandsIF* application) {
-	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( application->getIdentifier(), application->getRequestQueue() ) ).second;
-	if(  errorCode == false ) {
-		returnValue = RETURN_FAILED;
-	}
-	return returnValue;
-}
-
-ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
-		MessageQueueId_t id) {
-	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( apid, id ) ).second;
-	if(  errorCode == false ) {
-		returnValue = RETURN_FAILED;
-	}
-	return returnValue;
-
-}
-
-uint16_t CCSDSDistributor::getIdentifier() {
-	return 0;
-}
-
-ReturnValue_t CCSDSDistributor::initialize() {
-	ReturnValue_t status = this->TcDistributor::initialize();
-	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
-	if (this->tcStore == NULL) status = RETURN_FAILED;
-	return status;
-}
-
-ReturnValue_t CCSDSDistributor::callbackAfterSending(
-		ReturnValue_t queueStatus) {
-	if (queueStatus != RETURN_OK) {
-		tcStore->deleteData(currentMessage.getStorageId());
-	}
-	return RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/CCSDSDistributor.h"
+#include "../tmtcpacket/SpacePacketBase.h"
+
+CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
+		object_id_t setObjectId):
+		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
+}
+
+CCSDSDistributor::~CCSDSDistributor() {}
+
+TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
+//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
+//			this->currentMessage.getStorageId().pool_index << ", " <<
+//			this->currentMessage.getStorageId().packet_index << std::endl;
+	const uint8_t* packet = nullptr;
+	size_t size = 0;
+	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
+			&packet, &size );
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
+				"store failed!" << std::endl;
+	}
+	SpacePacketBase currentPacket(packet);
+
+//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
+//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
+	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
+	if ( position != this->queueMap.end() ) {
+		return position;
+	} else {
+		//The APID was not found. Forward packet to main SW-APID anyway to
+		// create acceptance failure report.
+		return this->queueMap.find( this->defaultApid );
+	}
+}
+
+MessageQueueId_t CCSDSDistributor::getRequestQueue() {
+	return tcQueue->getId();
+}
+
+ReturnValue_t CCSDSDistributor::registerApplication(
+		AcceptsTelecommandsIF* application) {
+	ReturnValue_t returnValue = RETURN_OK;
+	bool errorCode = true;
+	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( application->getIdentifier(), application->getRequestQueue() ) ).second;
+	if(  errorCode == false ) {
+		returnValue = RETURN_FAILED;
+	}
+	return returnValue;
+}
+
+ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
+		MessageQueueId_t id) {
+	ReturnValue_t returnValue = RETURN_OK;
+	bool errorCode = true;
+	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( apid, id ) ).second;
+	if(  errorCode == false ) {
+		returnValue = RETURN_FAILED;
+	}
+	return returnValue;
+
+}
+
+uint16_t CCSDSDistributor::getIdentifier() {
+	return 0;
+}
+
+ReturnValue_t CCSDSDistributor::initialize() {
+	ReturnValue_t status = this->TcDistributor::initialize();
+	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
+	if (this->tcStore == NULL) status = RETURN_FAILED;
+	return status;
+}
+
+ReturnValue_t CCSDSDistributor::callbackAfterSending(
+		ReturnValue_t queueStatus) {
+	if (queueStatus != RETURN_OK) {
+		tcStore->deleteData(currentMessage.getStorageId());
+	}
+	return RETURN_OK;
+}
diff --git a/tcdistribution/CCSDSDistributor.h b/tcdistribution/CCSDSDistributor.h
index 60877753e..e54b9fe4e 100644
--- a/tcdistribution/CCSDSDistributor.h
+++ b/tcdistribution/CCSDSDistributor.h
@@ -1,69 +1,69 @@
-#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
-#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tcdistribution/CCSDSDistributorIF.h>
-#include <framework/tcdistribution/TcDistributor.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-
-/**
- * @brief 	An instantiation of the CCSDSDistributorIF.
- * @details
- * It receives Space Packets, and selects a destination depending on the
- * APID of the telecommands.
- * The Secondary Header (with Service/Subservice) is ignored.
- * @ingroup tc_distribution
- */
-class CCSDSDistributor : public TcDistributor,
-		public CCSDSDistributorIF,
-		public AcceptsTelecommandsIF {
-public:
-	/**
-	 * @brief	The constructor sets the default APID and calls the
-	 * 			TcDistributor ctor with a certain object id.
-	 * @details
-	 * @c tcStore is set in the @c initialize method.
-	 * @param setDefaultApid The default APID, where packets with unknown
-	 * destination are sent to.
-	 */
-	CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
-	/**
-	 * The destructor is empty.
-	 */
-	virtual ~CCSDSDistributor();
-
-	MessageQueueId_t getRequestQueue() override;
-	ReturnValue_t registerApplication( uint16_t apid,
-			MessageQueueId_t id) override;
-	ReturnValue_t registerApplication(
-			AcceptsTelecommandsIF* application) override;
-	uint16_t getIdentifier();
-	ReturnValue_t initialize() override;
-
-protected:
-	/**
-	 * This implementation checks if an application with fitting APID has
-	 * registered and forwards the packet to the according message queue.
-	 * If the packet is not found, it returns the queue to @c defaultApid,
-	 * where a Acceptance Failure message should be generated.
-	 * @return Iterator to map entry of found APID or iterator to default APID.
-	 */
-	TcMqMapIter selectDestination() override;
-	/**
-	 * The default APID, where packets with unknown APID are sent to.
-	 */
-	uint16_t defaultApid;
-	/**
-	 * A reference to the TC storage must be maintained, as this class handles
-	 * pure Space Packets and there exists no SpacePacketStored class.
-	 */
-	StorageManagerIF* tcStore = nullptr;
-	/**
-	 * The callback here handles the generation of acceptance
-	 * success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
-};
-
-#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
+#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tcdistribution/CCSDSDistributorIF.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+
+/**
+ * @brief 	An instantiation of the CCSDSDistributorIF.
+ * @details
+ * It receives Space Packets, and selects a destination depending on the
+ * APID of the telecommands.
+ * The Secondary Header (with Service/Subservice) is ignored.
+ * @ingroup tc_distribution
+ */
+class CCSDSDistributor : public TcDistributor,
+		public CCSDSDistributorIF,
+		public AcceptsTelecommandsIF {
+public:
+	/**
+	 * @brief	The constructor sets the default APID and calls the
+	 * 			TcDistributor ctor with a certain object id.
+	 * @details
+	 * @c tcStore is set in the @c initialize method.
+	 * @param setDefaultApid The default APID, where packets with unknown
+	 * destination are sent to.
+	 */
+	CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~CCSDSDistributor();
+
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t registerApplication( uint16_t apid,
+			MessageQueueId_t id) override;
+	ReturnValue_t registerApplication(
+			AcceptsTelecommandsIF* application) override;
+	uint16_t getIdentifier();
+	ReturnValue_t initialize() override;
+
+protected:
+	/**
+	 * This implementation checks if an application with fitting APID has
+	 * registered and forwards the packet to the according message queue.
+	 * If the packet is not found, it returns the queue to @c defaultApid,
+	 * where a Acceptance Failure message should be generated.
+	 * @return Iterator to map entry of found APID or iterator to default APID.
+	 */
+	TcMqMapIter selectDestination() override;
+	/**
+	 * The default APID, where packets with unknown APID are sent to.
+	 */
+	uint16_t defaultApid;
+	/**
+	 * A reference to the TC storage must be maintained, as this class handles
+	 * pure Space Packets and there exists no SpacePacketStored class.
+	 */
+	StorageManagerIF* tcStore = nullptr;
+	/**
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+};
+
+#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/CCSDSDistributorIF.h b/tcdistribution/CCSDSDistributorIF.h
index dc1263a97..32198120a 100644
--- a/tcdistribution/CCSDSDistributorIF.h
+++ b/tcdistribution/CCSDSDistributorIF.h
@@ -1,40 +1,40 @@
-#ifndef CCSDSDISTRIBUTORIF_H_
-#define CCSDSDISTRIBUTORIF_H_
-
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-/**
- * This is the Interface to a CCSDS Distributor.
- * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves,
- * either by passing a pointer to themselves (and implementing the CCSDSApplicationIF,
- * or by explicitly passing an APID and a MessageQueueId to route the TC's to.
- * \ingroup tc_distribution
- */
-class CCSDSDistributorIF {
-public:
-	/**
-	 * With this call, a class implementing the CCSDSApplicationIF can register at the
-	 * distributor.
-	 * @param application A pointer to the Application to register.
-	 * @return	- \c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
-	 */
-	virtual ReturnValue_t registerApplication( AcceptsTelecommandsIF* application ) = 0;
-	/**
-	 * With this call, other Applications can register to the CCSDS distributor.
-	 * This is done by passing an APID and a MessageQueueId to the method.
-	 * @param apid	The APID to register.
-	 * @param id	The MessageQueueId of the message queue to send the TC Packets to.
-	 * @return	- \c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
-	 */
-	virtual ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id ) = 0;
-	/**
-	 * The empty virtual destructor.
-	 */
-	virtual ~CCSDSDistributorIF() {
-	}
-};
-
-
-#endif /* CCSDSDISTRIBUTORIF_H_ */
+#ifndef CCSDSDISTRIBUTORIF_H_
+#define CCSDSDISTRIBUTORIF_H_
+
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+/**
+ * This is the Interface to a CCSDS Distributor.
+ * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves,
+ * either by passing a pointer to themselves (and implementing the CCSDSApplicationIF,
+ * or by explicitly passing an APID and a MessageQueueId to route the TC's to.
+ * \ingroup tc_distribution
+ */
+class CCSDSDistributorIF {
+public:
+	/**
+	 * With this call, a class implementing the CCSDSApplicationIF can register at the
+	 * distributor.
+	 * @param application A pointer to the Application to register.
+	 * @return	- \c RETURN_OK on success,
+	 * 			- \c RETURN_FAILED on failure.
+	 */
+	virtual ReturnValue_t registerApplication( AcceptsTelecommandsIF* application ) = 0;
+	/**
+	 * With this call, other Applications can register to the CCSDS distributor.
+	 * This is done by passing an APID and a MessageQueueId to the method.
+	 * @param apid	The APID to register.
+	 * @param id	The MessageQueueId of the message queue to send the TC Packets to.
+	 * @return	- \c RETURN_OK on success,
+	 * 			- \c RETURN_FAILED on failure.
+	 */
+	virtual ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id ) = 0;
+	/**
+	 * The empty virtual destructor.
+	 */
+	virtual ~CCSDSDistributorIF() {
+	}
+};
+
+
+#endif /* CCSDSDISTRIBUTORIF_H_ */
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 5eb50103a..fee16f11e 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -1,92 +1,92 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tcdistribution/CCSDSDistributorIF.h>
-#include <framework/tcdistribution/PUSDistributor.h>
-#include <framework/tmtcpacket/pus/TcPacketStored.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-
-PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
-		object_id_t setPacketSource) :
-		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
-		currentPacket(), tcStatus(RETURN_FAILED),
-		packetSource(setPacketSource) {}
-
-PUSDistributor::~PUSDistributor() {}
-
-TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
-	TcMqMapIter queueMapIt = this->queueMap.end();
-	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
-	if (currentPacket.getWholeData() != NULL) {
-		tcStatus = checker.checkPacket(&currentPacket);
-//		sif::debug << "PUSDistributor::handlePacket: packetCheck returned with "
-//				<< (int)tcStatus << std::endl;
-		uint32_t queue_id = currentPacket.getService();
-		queueMapIt = this->queueMap.find(queue_id);
-	} else {
-		tcStatus = PACKET_LOST;
-	}
-	if (queueMapIt == this->queueMap.end()) {
-		tcStatus = DESTINATION_NOT_FOUND;
-	}
-
-	if (tcStatus != RETURN_OK) {
-		sif::debug << "PUSDistributor::handlePacket: Error with " << tcStatus
-				<< ", 0x"<< std::hex << tcStatus << std::dec << std::endl;
-		return this->queueMap.end();
-	} else {
-		return queueMapIt;
-	}
-
-}
-
-//uint16_t PUSDistributor::createDestination( uint8_t service_id, uint8_t subservice_id ) {
-//	return ( service_id << 8 ) + subservice_id;
-//}
-
-ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
-	uint16_t serviceId = service->getIdentifier();
-	//info << "Service ID: " << (int)serviceId << std::endl;
-	MessageQueueId_t queue = service->getRequestQueue();
-	auto returnPair = queueMap.emplace(serviceId, queue);
-	if (not returnPair.second) {
-		//TODO Return Code
-		sif::error << "PUSDistributor::registerService: Service ID already"
-				" exists in map." << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t PUSDistributor::getRequestQueue() {
-	return tcQueue->getId();
-}
-
-ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
-	if (queueStatus != RETURN_OK) {
-		tcStatus = queueStatus;
-	}
-	if (tcStatus != RETURN_OK) {
-		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
-				&currentPacket, tcStatus);
-		//A failed packet is deleted immediately after reporting, otherwise it will block memory.
-		currentPacket.deletePacket();
-		return RETURN_FAILED;
-	} else {
-		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
-				&currentPacket);
-		return RETURN_OK;
-	}
-}
-
-uint16_t PUSDistributor::getIdentifier() {
-	return checker.getApid();
-}
-
-ReturnValue_t PUSDistributor::initialize() {
-	CCSDSDistributorIF* ccsdsDistributor =
-			objectManager->get<CCSDSDistributorIF>(packetSource);
-	if (ccsdsDistributor == NULL) {
-		return RETURN_FAILED;
-	} else {
-		return ccsdsDistributor->registerApplication(this);
-	}
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/CCSDSDistributorIF.h"
+#include "../tcdistribution/PUSDistributor.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+		object_id_t setPacketSource) :
+		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
+		currentPacket(), tcStatus(RETURN_FAILED),
+		packetSource(setPacketSource) {}
+
+PUSDistributor::~PUSDistributor() {}
+
+TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
+	TcMqMapIter queueMapIt = this->queueMap.end();
+	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
+	if (currentPacket.getWholeData() != NULL) {
+		tcStatus = checker.checkPacket(&currentPacket);
+//		sif::debug << "PUSDistributor::handlePacket: packetCheck returned with "
+//				<< (int)tcStatus << std::endl;
+		uint32_t queue_id = currentPacket.getService();
+		queueMapIt = this->queueMap.find(queue_id);
+	} else {
+		tcStatus = PACKET_LOST;
+	}
+	if (queueMapIt == this->queueMap.end()) {
+		tcStatus = DESTINATION_NOT_FOUND;
+	}
+
+	if (tcStatus != RETURN_OK) {
+		sif::debug << "PUSDistributor::handlePacket: Error with " << tcStatus
+				<< ", 0x"<< std::hex << tcStatus << std::dec << std::endl;
+		return this->queueMap.end();
+	} else {
+		return queueMapIt;
+	}
+
+}
+
+//uint16_t PUSDistributor::createDestination( uint8_t service_id, uint8_t subservice_id ) {
+//	return ( service_id << 8 ) + subservice_id;
+//}
+
+ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
+	uint16_t serviceId = service->getIdentifier();
+	//info << "Service ID: " << (int)serviceId << std::endl;
+	MessageQueueId_t queue = service->getRequestQueue();
+	auto returnPair = queueMap.emplace(serviceId, queue);
+	if (not returnPair.second) {
+		//TODO Return Code
+		sif::error << "PUSDistributor::registerService: Service ID already"
+				" exists in map." << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t PUSDistributor::getRequestQueue() {
+	return tcQueue->getId();
+}
+
+ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+	if (queueStatus != RETURN_OK) {
+		tcStatus = queueStatus;
+	}
+	if (tcStatus != RETURN_OK) {
+		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
+				&currentPacket, tcStatus);
+		//A failed packet is deleted immediately after reporting, otherwise it will block memory.
+		currentPacket.deletePacket();
+		return RETURN_FAILED;
+	} else {
+		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
+				&currentPacket);
+		return RETURN_OK;
+	}
+}
+
+uint16_t PUSDistributor::getIdentifier() {
+	return checker.getApid();
+}
+
+ReturnValue_t PUSDistributor::initialize() {
+	CCSDSDistributorIF* ccsdsDistributor =
+			objectManager->get<CCSDSDistributorIF>(packetSource);
+	if (ccsdsDistributor == NULL) {
+		return RETURN_FAILED;
+	} else {
+		return ccsdsDistributor->registerApplication(this);
+	}
+}
diff --git a/tcdistribution/PUSDistributor.h b/tcdistribution/PUSDistributor.h
index 4a22f9367..be84de1b7 100644
--- a/tcdistribution/PUSDistributor.h
+++ b/tcdistribution/PUSDistributor.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
-#define FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tcdistribution/PUSDistributorIF.h>
-#include <framework/tcdistribution/TcDistributor.h>
-#include <framework/tcdistribution/TcPacketCheck.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/tmtcservices/VerificationReporter.h>
-
-/**
- * This class accepts PUS Telecommands and forwards them to Application
- * services. In addition, the class performs a formal packet check and
- * sends acceptance success or failure messages.
- * @ingroup tc_distribution
- */
-class PUSDistributor: public TcDistributor,
-		public PUSDistributorIF,
-		public AcceptsTelecommandsIF {
-public:
-	/**
-	 * The ctor passes @c set_apid to the checker class and calls the
-	 * TcDistribution ctor with a certain object id.
-	 * @param setApid The APID of this receiving Application.
-	 * @param setObjectId Object ID of the distributor itself
-	 * @param setPacketSource Object ID of the source of TC packets.
-	 * Must implement CCSDSDistributorIF.
-	 */
-	PUSDistributor(uint16_t setApid, object_id_t setObjectId,
-			object_id_t setPacketSource);
-	/**
-	 * The destructor is empty.
-	 */
-	virtual ~PUSDistributor();
-	ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
-	MessageQueueId_t getRequestQueue() override;
-	ReturnValue_t initialize() override;
-	uint16_t getIdentifier() override;
-
-protected:
-	/**
-	 * This attribute contains the class, that performs a formal packet check.
-	 */
-	TcPacketCheck checker;
-	/**
-	 * With this class, verification messages are sent to the
-	 * TC Verification service.
-	 */
-	VerificationReporter verifyChannel;
-	/**
-	 * The currently handled packet is stored here.
-	 */
-	TcPacketStored currentPacket;
-	/**
-	 * With this variable, the current check status is stored to generate
-	 * acceptance messages later.
-	 */
-	ReturnValue_t tcStatus;
-
-	const object_id_t packetSource;
-	/**
-	 * This method reads the packet service, checks if such a service is
-	 * registered and forwards the packet to the destination.
-	 * It also initiates the formal packet check and sending of verification
-	 * messages.
-	 * @return Iterator to map entry of found service id
-	 * or iterator to @c map.end().
-	 */
-	TcMqMapIter selectDestination() override;
-	/**
-	 * The callback here handles the generation of acceptance
-	 * success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
-};
-
-#endif /* FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
+#ifndef FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tcdistribution/TcPacketCheck.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../tmtcservices/VerificationReporter.h"
+
+/**
+ * This class accepts PUS Telecommands and forwards them to Application
+ * services. In addition, the class performs a formal packet check and
+ * sends acceptance success or failure messages.
+ * @ingroup tc_distribution
+ */
+class PUSDistributor: public TcDistributor,
+		public PUSDistributorIF,
+		public AcceptsTelecommandsIF {
+public:
+	/**
+	 * The ctor passes @c set_apid to the checker class and calls the
+	 * TcDistribution ctor with a certain object id.
+	 * @param setApid The APID of this receiving Application.
+	 * @param setObjectId Object ID of the distributor itself
+	 * @param setPacketSource Object ID of the source of TC packets.
+	 * Must implement CCSDSDistributorIF.
+	 */
+	PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+			object_id_t setPacketSource);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~PUSDistributor();
+	ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t initialize() override;
+	uint16_t getIdentifier() override;
+
+protected:
+	/**
+	 * This attribute contains the class, that performs a formal packet check.
+	 */
+	TcPacketCheck checker;
+	/**
+	 * With this class, verification messages are sent to the
+	 * TC Verification service.
+	 */
+	VerificationReporter verifyChannel;
+	/**
+	 * The currently handled packet is stored here.
+	 */
+	TcPacketStored currentPacket;
+	/**
+	 * With this variable, the current check status is stored to generate
+	 * acceptance messages later.
+	 */
+	ReturnValue_t tcStatus;
+
+	const object_id_t packetSource;
+	/**
+	 * This method reads the packet service, checks if such a service is
+	 * registered and forwards the packet to the destination.
+	 * It also initiates the formal packet check and sending of verification
+	 * messages.
+	 * @return Iterator to map entry of found service id
+	 * or iterator to @c map.end().
+	 */
+	TcMqMapIter selectDestination() override;
+	/**
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
+};
+
+#endif /* FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/PUSDistributorIF.h b/tcdistribution/PUSDistributorIF.h
index bb1011374..7967a74ed 100644
--- a/tcdistribution/PUSDistributorIF.h
+++ b/tcdistribution/PUSDistributorIF.h
@@ -1,26 +1,26 @@
-#ifndef PUSDISTRIBUTORIF_H_
-#define PUSDISTRIBUTORIF_H_
-
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-/**
- * This interface allows PUS Services to register themselves at a PUS Distributor.
- * \ingroup tc_distribution
- */
-class PUSDistributorIF {
-public:
-	/**
-	 * The empty virtual destructor.
-	 */
-	virtual ~PUSDistributorIF() {
-	}
-/**
- * With this method, Services can register themselves at the PUS Distributor.
- * @param service A pointer to the registering Service.
- * @return	- \c RETURN_OK on success,
- * 			- \c RETURN_FAILED on failure.
- */
-	virtual ReturnValue_t registerService( AcceptsTelecommandsIF* service ) = 0;
-};
-
-#endif /* PUSDISTRIBUTORIF_H_ */
+#ifndef PUSDISTRIBUTORIF_H_
+#define PUSDISTRIBUTORIF_H_
+
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+/**
+ * This interface allows PUS Services to register themselves at a PUS Distributor.
+ * \ingroup tc_distribution
+ */
+class PUSDistributorIF {
+public:
+	/**
+	 * The empty virtual destructor.
+	 */
+	virtual ~PUSDistributorIF() {
+	}
+/**
+ * With this method, Services can register themselves at the PUS Distributor.
+ * @param service A pointer to the registering Service.
+ * @return	- \c RETURN_OK on success,
+ * 			- \c RETURN_FAILED on failure.
+ */
+	virtual ReturnValue_t registerService( AcceptsTelecommandsIF* service ) = 0;
+};
+
+#endif /* PUSDISTRIBUTORIF_H_ */
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index 0190cc970..45a20fd92 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -1,54 +1,54 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tcdistribution/TcDistributor.h>
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <framework/ipc/QueueFactory.h>
-
-TcDistributor::TcDistributor(object_id_t set_object_id) :
-		SystemObject(set_object_id), tcQueue(NULL) {
-	tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
-}
-
-TcDistributor::~TcDistributor() {
-	QueueFactory::instance()->deleteMessageQueue(tcQueue);
-}
-
-ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
-	ReturnValue_t status = RETURN_OK;
-	for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
-			status = tcQueue->receiveMessage(&currentMessage)) {
-		status = handlePacket();
-	}
-	if (status == MessageQueueIF::EMPTY) {
-		return RETURN_OK;
-	} else {
-		return status;
-	}
-}
-
-ReturnValue_t TcDistributor::handlePacket() {
-
-	TcMqMapIter queueMapIt = this->selectDestination();
-	ReturnValue_t returnValue = RETURN_FAILED;
-	if (queueMapIt != this->queueMap.end()) {
-		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
-				&this->currentMessage);
-	}
-	return this->callbackAfterSending(returnValue);
-}
-
-void TcDistributor::print() {
-	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
-			<< std::endl;
-	for (TcMqMapIter it = this->queueMap.begin(); it != this->queueMap.end();
-			it++) {
-		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
-				<< std::endl;
-	}
-	sif::debug << std::dec;
-
-}
-
-ReturnValue_t TcDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
-	return RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+
+TcDistributor::TcDistributor(object_id_t set_object_id) :
+		SystemObject(set_object_id), tcQueue(NULL) {
+	tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
+}
+
+TcDistributor::~TcDistributor() {
+	QueueFactory::instance()->deleteMessageQueue(tcQueue);
+}
+
+ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
+	ReturnValue_t status = RETURN_OK;
+	for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
+			status = tcQueue->receiveMessage(&currentMessage)) {
+		status = handlePacket();
+	}
+	if (status == MessageQueueIF::EMPTY) {
+		return RETURN_OK;
+	} else {
+		return status;
+	}
+}
+
+ReturnValue_t TcDistributor::handlePacket() {
+
+	TcMqMapIter queueMapIt = this->selectDestination();
+	ReturnValue_t returnValue = RETURN_FAILED;
+	if (queueMapIt != this->queueMap.end()) {
+		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
+				&this->currentMessage);
+	}
+	return this->callbackAfterSending(returnValue);
+}
+
+void TcDistributor::print() {
+	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
+			<< std::endl;
+	for (TcMqMapIter it = this->queueMap.begin(); it != this->queueMap.end();
+			it++) {
+		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
+				<< std::endl;
+	}
+	sif::debug << std::dec;
+
+}
+
+ReturnValue_t TcDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+	return RETURN_OK;
+}
diff --git a/tcdistribution/TcDistributor.h b/tcdistribution/TcDistributor.h
index 73425302f..987f2eaa0 100644
--- a/tcdistribution/TcDistributor.h
+++ b/tcdistribution/TcDistributor.h
@@ -1,120 +1,120 @@
-#ifndef FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
-#define FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <map>
-
-/**
- * @defgroup tc_distribution Telecommand Distribution
- * All classes associated with Routing and Distribution of Telecommands
- * belong to this group.
- */
-
-
-/**
- * This is the base class to implement distributors for Space Packets.
- * Typically, the distribution is required to forward Telecommand packets
- * over the satellite applications and services. The class receives
- * Space Packets over a message queue and holds a map that links other
- * message queue ids to some identifier. The process of unpacking the
- * destination information from the packet is handled by the child class
- * implementations.
- * @ingroup tc_distribution
- */
-class TcDistributor : public SystemObject,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-public:
-	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
-	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
-	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
-	/**
-	 * Within the default constructor, the SystemObject id is set and the
-	 * message queue is initialized.
-	 * Filling the map is under control of the child classes.
-	 * @param set_object_id	This id is assigned to the distributor
-	 * 		implementation.
-	 */
-	TcDistributor( object_id_t set_object_id );
-	/**
-	 * The destructor is empty, the message queues are not in the vicinity of
-	 * this class.
-	 */
-	virtual ~TcDistributor();
-	/**
-	 * The method is called cyclically and fetches new incoming packets from
-	 * the message queue.
-	 * In case a new packet is found, it calls the handlePacket method to deal
-	 * with distribution.
-	 * @return The error code of the message queue call.
-	 */
-	ReturnValue_t performOperation(uint8_t opCode);
-	/**
-	 * A simple debug print, that prints all distribution information stored in
-	 * queueMap.
-	 */
-	void print();
-
-protected:
-	/**
-	 * This is the receiving queue for incoming Telecommands.
-	 * The child classes must make its queue id public.
-	 */
-	MessageQueueIF* tcQueue;
-	/**
-	 * The last received incoming packet information is stored in this
-	 * member.
-	 * As different child classes unpack the incoming packet differently
-	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
-	 * is not tried to unpack the packet information within this class.
-	 */
-	TmTcMessage currentMessage;
-	/**
-	 * The map that links certain packet information to a destination.
-	 * The packet information may be the APID of the packet or the service
-	 * identifier. Filling of the map is under control of the different child
-	 * classes.
-	 */
-	TcMessageQueueMap queueMap;
-	/**
-	 * This method shall unpack the routing information from the incoming
-	 * packet and select the map entry which represents the packet's target.
-	 * @return	An iterator to the map element to forward to or queuMap.end().
-	 */
-	virtual TcMqMapIter selectDestination() = 0;
-	/**
-	 * The handlePacket method calls the child class's selectDestination method
-	 * and forwards the packet to its destination, if found.
-	 * @return The message queue return value or \c RETURN_FAILED, in case no
-	 * 		destination was found.
-	 */
-	ReturnValue_t handlePacket();
-	/**
-	 * This method gives the child class a chance to perform some kind of operation
-	 * after the parent tried to forward the message.
-	 * A typically application would be sending success/failure messages.
-	 * The default implementation just returns \c RETURN_OK.
-	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
-	 * @return	- \c RETURN_OK on success
-	 * 			- \c RETURN_FAILED on failure
-	 */
-	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
-
-private:
-	/**
-	 * This constant sets the maximum number of packets distributed per call.
-	 */
-	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
-};
-
-
-#endif /* TCDISTRIBUTOR_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+#define FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/MessageQueueIF.h"
+#include <map>
+
+/**
+ * @defgroup tc_distribution Telecommand Distribution
+ * All classes associated with Routing and Distribution of Telecommands
+ * belong to this group.
+ */
+
+
+/**
+ * This is the base class to implement distributors for Space Packets.
+ * Typically, the distribution is required to forward Telecommand packets
+ * over the satellite applications and services. The class receives
+ * Space Packets over a message queue and holds a map that links other
+ * message queue ids to some identifier. The process of unpacking the
+ * destination information from the packet is handled by the child class
+ * implementations.
+ * @ingroup tc_distribution
+ */
+class TcDistributor : public SystemObject,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+public:
+	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
+	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
+	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
+	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	/**
+	 * Within the default constructor, the SystemObject id is set and the
+	 * message queue is initialized.
+	 * Filling the map is under control of the child classes.
+	 * @param set_object_id	This id is assigned to the distributor
+	 * 		implementation.
+	 */
+	TcDistributor( object_id_t set_object_id );
+	/**
+	 * The destructor is empty, the message queues are not in the vicinity of
+	 * this class.
+	 */
+	virtual ~TcDistributor();
+	/**
+	 * The method is called cyclically and fetches new incoming packets from
+	 * the message queue.
+	 * In case a new packet is found, it calls the handlePacket method to deal
+	 * with distribution.
+	 * @return The error code of the message queue call.
+	 */
+	ReturnValue_t performOperation(uint8_t opCode);
+	/**
+	 * A simple debug print, that prints all distribution information stored in
+	 * queueMap.
+	 */
+	void print();
+
+protected:
+	/**
+	 * This is the receiving queue for incoming Telecommands.
+	 * The child classes must make its queue id public.
+	 */
+	MessageQueueIF* tcQueue;
+	/**
+	 * The last received incoming packet information is stored in this
+	 * member.
+	 * As different child classes unpack the incoming packet differently
+	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
+	 * is not tried to unpack the packet information within this class.
+	 */
+	TmTcMessage currentMessage;
+	/**
+	 * The map that links certain packet information to a destination.
+	 * The packet information may be the APID of the packet or the service
+	 * identifier. Filling of the map is under control of the different child
+	 * classes.
+	 */
+	TcMessageQueueMap queueMap;
+	/**
+	 * This method shall unpack the routing information from the incoming
+	 * packet and select the map entry which represents the packet's target.
+	 * @return	An iterator to the map element to forward to or queuMap.end().
+	 */
+	virtual TcMqMapIter selectDestination() = 0;
+	/**
+	 * The handlePacket method calls the child class's selectDestination method
+	 * and forwards the packet to its destination, if found.
+	 * @return The message queue return value or \c RETURN_FAILED, in case no
+	 * 		destination was found.
+	 */
+	ReturnValue_t handlePacket();
+	/**
+	 * This method gives the child class a chance to perform some kind of operation
+	 * after the parent tried to forward the message.
+	 * A typically application would be sending success/failure messages.
+	 * The default implementation just returns \c RETURN_OK.
+	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
+	 * @return	- \c RETURN_OK on success
+	 * 			- \c RETURN_FAILED on failure
+	 */
+	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+
+private:
+	/**
+	 * This constant sets the maximum number of packets distributed per call.
+	 */
+	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
+};
+
+
+#endif /* TCDISTRIBUTOR_H_ */
diff --git a/tcdistribution/TcPacketCheck.cpp b/tcdistribution/TcPacketCheck.cpp
index 90a1167fa..98dfaeb89 100644
--- a/tcdistribution/TcPacketCheck.cpp
+++ b/tcdistribution/TcPacketCheck.cpp
@@ -1,37 +1,37 @@
-#include <framework/globalfunctions/CRC.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tcdistribution/TcPacketCheck.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-
-TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) {
-}
-
-ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* current_packet ) {
-	uint16_t calculated_crc = CRC::crc16ccitt( current_packet->getWholeData(), current_packet->getFullSize() );
-	if ( calculated_crc != 0 ) {
-		return INCORRECT_CHECKSUM;
-	}
-	bool condition = !(current_packet->hasSecondaryHeader()) ||
-			current_packet->getPacketVersionNumber() != CCSDS_VERSION_NUMBER ||
-			!(current_packet->isTelecommand());
-	if ( condition ) {
-		return INCORRECT_PRIMARY_HEADER;
-	}
-	if ( current_packet->getAPID() != this->apid )
-		return ILLEGAL_APID;
-
-	if ( !current_packet->isSizeCorrect() ) {
-		return INCOMPLETE_PACKET;
-	}
-	condition = (current_packet->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
-			(current_packet->getPusVersionNumber() != PUS_VERSION_NUMBER);
-	if ( condition ) {
-		return INCORRECT_SECONDARY_HEADER;
-	}
-	return RETURN_OK;
-}
-
-uint16_t TcPacketCheck::getApid() const {
-	return apid;
-}
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tcdistribution/TcPacketCheck.h"
+#include "../tmtcservices/VerificationCodes.h"
+
+TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) {
+}
+
+ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* current_packet ) {
+	uint16_t calculated_crc = CRC::crc16ccitt( current_packet->getWholeData(), current_packet->getFullSize() );
+	if ( calculated_crc != 0 ) {
+		return INCORRECT_CHECKSUM;
+	}
+	bool condition = !(current_packet->hasSecondaryHeader()) ||
+			current_packet->getPacketVersionNumber() != CCSDS_VERSION_NUMBER ||
+			!(current_packet->isTelecommand());
+	if ( condition ) {
+		return INCORRECT_PRIMARY_HEADER;
+	}
+	if ( current_packet->getAPID() != this->apid )
+		return ILLEGAL_APID;
+
+	if ( !current_packet->isSizeCorrect() ) {
+		return INCOMPLETE_PACKET;
+	}
+	condition = (current_packet->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
+			(current_packet->getPusVersionNumber() != PUS_VERSION_NUMBER);
+	if ( condition ) {
+		return INCORRECT_SECONDARY_HEADER;
+	}
+	return RETURN_OK;
+}
+
+uint16_t TcPacketCheck::getApid() const {
+	return apid;
+}
diff --git a/tcdistribution/TcPacketCheck.h b/tcdistribution/TcPacketCheck.h
index 88810ed7e..9fe1db721 100644
--- a/tcdistribution/TcPacketCheck.h
+++ b/tcdistribution/TcPacketCheck.h
@@ -1,59 +1,59 @@
-#ifndef TCPACKETCHECK_H_
-#define TCPACKETCHECK_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tmtcpacket/pus/TcPacketStored.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-/**
- * This class performs a formal packet check for incoming PUS Telecommand Packets.
- * Currently, it only checks if the APID and CRC are correct.
- * \ingroup tc_distribution
- */
-class TcPacketCheck : public HasReturnvaluesIF {
-protected:
-	/**
-	 * Describes the version number a packet must have to pass.
-	 */
-	static const uint8_t CCSDS_VERSION_NUMBER = 0;
-	/**
-	 * Describes the secondary header a packet must have to pass.
-	 */
-	static const uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
-	/**
-	 * Describes the TC Packet PUS Version Number a packet must have to pass.
-	 */
-	static const uint8_t PUS_VERSION_NUMBER = 1;
-	/**
-	 * The packet id each correct packet should have.
-	 * It is composed of the APID and some static fields.
-	 */
-	uint16_t apid;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TC_PACKET_CHECK;
-	static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE( 0 );
-	static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE( 2 );
-	static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE( 3 );
-	static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE( 4 );
-	static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE( 5 );
-	static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE( 6 );
-	/**
-	 * The constructor only sets the APID attribute.
-	 * @param set_apid The APID to set.
-	 */
-	TcPacketCheck( uint16_t set_apid );
-	/**
-	 * This is the actual method to formally check a certain Telecommand Packet.
-	 * The packet's Application Data can not be checked here.
-	 * @param current_packet The packt to check
-	 * @return	- \c RETURN_OK on success.
-	 * 			- \c INCORRECT_CHECKSUM if checksum is invalid.
-	 * 			- \c ILLEGAL_APID if APID does not match.
-	 */
-	ReturnValue_t checkPacket( TcPacketStored* current_packet );
-
-	uint16_t getApid() const;
-};
-
-
-#endif /* TCPACKETCHECK_H_ */
+#ifndef TCPACKETCHECK_H_
+#define TCPACKETCHECK_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/PusVerificationReport.h"
+/**
+ * This class performs a formal packet check for incoming PUS Telecommand Packets.
+ * Currently, it only checks if the APID and CRC are correct.
+ * \ingroup tc_distribution
+ */
+class TcPacketCheck : public HasReturnvaluesIF {
+protected:
+	/**
+	 * Describes the version number a packet must have to pass.
+	 */
+	static const uint8_t CCSDS_VERSION_NUMBER = 0;
+	/**
+	 * Describes the secondary header a packet must have to pass.
+	 */
+	static const uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
+	/**
+	 * Describes the TC Packet PUS Version Number a packet must have to pass.
+	 */
+	static const uint8_t PUS_VERSION_NUMBER = 1;
+	/**
+	 * The packet id each correct packet should have.
+	 * It is composed of the APID and some static fields.
+	 */
+	uint16_t apid;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TC_PACKET_CHECK;
+	static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE( 0 );
+	static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE( 1 );
+	static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE( 2 );
+	static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE( 3 );
+	static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE( 4 );
+	static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE( 5 );
+	static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE( 6 );
+	/**
+	 * The constructor only sets the APID attribute.
+	 * @param set_apid The APID to set.
+	 */
+	TcPacketCheck( uint16_t set_apid );
+	/**
+	 * This is the actual method to formally check a certain Telecommand Packet.
+	 * The packet's Application Data can not be checked here.
+	 * @param current_packet The packt to check
+	 * @return	- \c RETURN_OK on success.
+	 * 			- \c INCORRECT_CHECKSUM if checksum is invalid.
+	 * 			- \c ILLEGAL_APID if APID does not match.
+	 */
+	ReturnValue_t checkPacket( TcPacketStored* current_packet );
+
+	uint16_t getApid() const;
+};
+
+
+#endif /* TCPACKETCHECK_H_ */
diff --git a/thermal/AbstractTemperatureSensor.cpp b/thermal/AbstractTemperatureSensor.cpp
index 41230f591..5d8213679 100644
--- a/thermal/AbstractTemperatureSensor.cpp
+++ b/thermal/AbstractTemperatureSensor.cpp
@@ -1,70 +1,70 @@
-#include "AbstractTemperatureSensor.h"
-#include <framework/ipc/QueueFactory.h>
-
-AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
-		ThermalModuleIF *thermalModule) :
-		SystemObject(setObjectid), commandQueue(NULL), healthHelper(this,
-				setObjectid), parameterHelper(this) {
-	if (thermalModule != NULL) {
-		thermalModule->registerSensor(this);
-	}
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-AbstractTemperatureSensor::~AbstractTemperatureSensor() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-MessageQueueId_t AbstractTemperatureSensor::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t AbstractTemperatureSensor::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = parameterHelper.initialize();
-	return result;
-}
-
-ReturnValue_t AbstractTemperatureSensor::performOperation(uint8_t opCode) {
-	handleCommandQueue();
-	doChildOperation();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
-	handleCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void AbstractTemperatureSensor::handleCommandQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		result = parameterHelper.handleParameterMessage(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
-}
-
-ReturnValue_t AbstractTemperatureSensor::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-HasHealthIF::HealthState AbstractTemperatureSensor::getHealth() {
-	return healthHelper.getHealth();
-}
+#include "AbstractTemperatureSensor.h"
+#include "../ipc/QueueFactory.h"
+
+AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
+		ThermalModuleIF *thermalModule) :
+		SystemObject(setObjectid), commandQueue(NULL), healthHelper(this,
+				setObjectid), parameterHelper(this) {
+	if (thermalModule != NULL) {
+		thermalModule->registerSensor(this);
+	}
+	commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+AbstractTemperatureSensor::~AbstractTemperatureSensor() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+MessageQueueId_t AbstractTemperatureSensor::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t AbstractTemperatureSensor::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	return result;
+}
+
+ReturnValue_t AbstractTemperatureSensor::performOperation(uint8_t opCode) {
+	handleCommandQueue();
+	doChildOperation();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
+	handleCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void AbstractTemperatureSensor::handleCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		result = parameterHelper.handleParameterMessage(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		command.setToUnknownCommand();
+		commandQueue->reply(&command);
+	}
+}
+
+ReturnValue_t AbstractTemperatureSensor::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState AbstractTemperatureSensor::getHealth() {
+	return healthHelper.getHealth();
+}
diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h
index 4b8693655..462b41f25 100644
--- a/thermal/AbstractTemperatureSensor.h
+++ b/thermal/AbstractTemperatureSensor.h
@@ -1,64 +1,64 @@
-#ifndef ABSTRACTSENSOR_H_
-#define ABSTRACTSENSOR_H_
-
-#include <framework/health/HasHealthIF.h>
-#include <framework/health/HealthHelper.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/parameters/ParameterHelper.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include "ThermalModuleIF.h"
-#include "tcsDefinitions.h"
-
-/**
- * @defgroup thermal Thermal Components
- * @brief Contains all components related to thermal tasks (sensors, heaters)
- */
-
-/**
- * @brief Base class for Temperature Sensor, implements all important interfaces.
- *        Please use the TemperatureSensor class to implement the actual sensors.
- * @ingroup thermal
- */
-class AbstractTemperatureSensor: public HasHealthIF,
-		public SystemObject,
-		public ExecutableObjectIF,
-		public ReceivesParameterMessagesIF {
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::T_SENSORS;
-	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, SEVERITY::LOW);
-
-	static constexpr float ZERO_KELVIN_C = -273.15;
-	AbstractTemperatureSensor(object_id_t setObjectid,
-			ThermalModuleIF *thermalModule);
-	virtual ~AbstractTemperatureSensor();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t initialize();
-
-	ReturnValue_t performHealthOp();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual float getTemperature() = 0;
-	virtual bool isValid() = 0;
-
-	virtual void resetOldState() = 0;
-
-	ReturnValue_t setHealth(HealthState health);
-	HasHealthIF::HealthState getHealth();
-protected:
-	MessageQueueIF* commandQueue;
-	HealthHelper healthHelper;
-	ParameterHelper parameterHelper;
-
-	virtual void doChildOperation() = 0;
-
-	void handleCommandQueue();
-};
-
-#endif /* ABSTRACTSENSOR_H_ */
+#ifndef ABSTRACTSENSOR_H_
+#define ABSTRACTSENSOR_H_
+
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../parameters/ParameterHelper.h"
+#include "../ipc/MessageQueueIF.h"
+#include "ThermalModuleIF.h"
+#include "tcsDefinitions.h"
+
+/**
+ * @defgroup thermal Thermal Components
+ * @brief Contains all components related to thermal tasks (sensors, heaters)
+ */
+
+/**
+ * @brief Base class for Temperature Sensor, implements all important interfaces.
+ *        Please use the TemperatureSensor class to implement the actual sensors.
+ * @ingroup thermal
+ */
+class AbstractTemperatureSensor: public HasHealthIF,
+		public SystemObject,
+		public ExecutableObjectIF,
+		public ReceivesParameterMessagesIF {
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::T_SENSORS;
+	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, SEVERITY::LOW);
+
+	static constexpr float ZERO_KELVIN_C = -273.15;
+	AbstractTemperatureSensor(object_id_t setObjectid,
+			ThermalModuleIF *thermalModule);
+	virtual ~AbstractTemperatureSensor();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t initialize();
+
+	ReturnValue_t performHealthOp();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual float getTemperature() = 0;
+	virtual bool isValid() = 0;
+
+	virtual void resetOldState() = 0;
+
+	ReturnValue_t setHealth(HealthState health);
+	HasHealthIF::HealthState getHealth();
+protected:
+	MessageQueueIF* commandQueue;
+	HealthHelper healthHelper;
+	ParameterHelper parameterHelper;
+
+	virtual void doChildOperation() = 0;
+
+	void handleCommandQueue();
+};
+
+#endif /* ABSTRACTSENSOR_H_ */
diff --git a/thermal/AcceptsThermalMessagesIF.h b/thermal/AcceptsThermalMessagesIF.h
index 28c62af6a..9fe03499e 100644
--- a/thermal/AcceptsThermalMessagesIF.h
+++ b/thermal/AcceptsThermalMessagesIF.h
@@ -6,7 +6,7 @@
 
 #ifndef FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
 #define FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
-#include <framework/ipc/MessageQueueSenderIF.h>
+#include "../ipc/MessageQueueSenderIF.h"
 
 class AcceptsThermalMessagesIF {
 public:
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index a0736c714..87a6972e8 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -1,96 +1,96 @@
-#ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-#define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/thermal/ThermalComponentIF.h>
-#include <framework/thermal/AbstractTemperatureSensor.h>
-#include <framework/thermal/ThermalModule.h>
-#include <framework/thermal/ThermalMonitor.h>
-
-// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
-class CoreComponent: public ThermalComponentIF {
-public:
-	struct Parameters {
-		float lowerOpLimit;
-		float upperOpLimit;
-		float heaterOn;
-		float hysteresis;
-		float heaterSwitchoff;
-	};
-
-	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
-
-	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
-			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-			uint32_t requestPoolId, GlobDataSet *dataSet,
-			AbstractTemperatureSensor *sensor,
-			AbstractTemperatureSensor *firstRedundantSensor,
-			AbstractTemperatureSensor *secondRedundantSensor,
-			ThermalModuleIF *thermalModule, Parameters parameters,
-			Priority priority, StateRequest initialTargetState =
-					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
-
-	virtual ~CoreComponent();
-
-	virtual HeaterRequest performOperation(uint8_t opCode);
-
-	void markStateIgnored();
-
-	object_id_t getObjectId();
-
-	uint8_t getDomainId() const;
-
-	virtual float getLowerOpLimit();
-
-	ReturnValue_t setTargetState(int8_t newState);
-
-	virtual void setOutputInvalid();
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-protected:
-
-	AbstractTemperatureSensor *sensor;
-	AbstractTemperatureSensor *firstRedundantSensor;
-	AbstractTemperatureSensor *secondRedundantSensor;
-	ThermalModuleIF *thermalModule;
-
-	gp_float_t temperature;
-	gp_int8_t targetState;
-	gp_int8_t currentState;
-	gp_uint8_t heaterRequest;
-
-	bool isHeating;
-
-	bool isSafeComponent;
-
-	float minTemp;
-
-	float maxTemp;
-
-	Parameters parameters;
-
-	ThermalMonitor temperatureMonitor;
-
-	const uint8_t domainId;
-
-	virtual float getTemperature();
-	virtual State getState(float temperature, Parameters parameters,
-			int8_t targetState);
-
-	virtual void checkLimits(State state);
-
-	virtual HeaterRequest getHeaterRequest(int8_t targetState,
-			float temperature, Parameters parameters);
-
-	virtual State getIgnoredState(int8_t state);
-
-	void updateMinMaxTemp();
-
-	virtual Parameters getParameters();
-};
-
-#endif /* MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ */
+#ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
+#define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../thermal/ThermalComponentIF.h"
+#include "../thermal/AbstractTemperatureSensor.h"
+#include "../thermal/ThermalModule.h"
+#include "../thermal/ThermalMonitor.h"
+
+// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
+class CoreComponent: public ThermalComponentIF {
+public:
+	struct Parameters {
+		float lowerOpLimit;
+		float upperOpLimit;
+		float heaterOn;
+		float hysteresis;
+		float heaterSwitchoff;
+	};
+
+	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
+
+	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
+			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
+			uint32_t requestPoolId, GlobDataSet *dataSet,
+			AbstractTemperatureSensor *sensor,
+			AbstractTemperatureSensor *firstRedundantSensor,
+			AbstractTemperatureSensor *secondRedundantSensor,
+			ThermalModuleIF *thermalModule, Parameters parameters,
+			Priority priority, StateRequest initialTargetState =
+					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
+
+	virtual ~CoreComponent();
+
+	virtual HeaterRequest performOperation(uint8_t opCode);
+
+	void markStateIgnored();
+
+	object_id_t getObjectId();
+
+	uint8_t getDomainId() const;
+
+	virtual float getLowerOpLimit();
+
+	ReturnValue_t setTargetState(int8_t newState);
+
+	virtual void setOutputInvalid();
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+protected:
+
+	AbstractTemperatureSensor *sensor;
+	AbstractTemperatureSensor *firstRedundantSensor;
+	AbstractTemperatureSensor *secondRedundantSensor;
+	ThermalModuleIF *thermalModule;
+
+	gp_float_t temperature;
+	gp_int8_t targetState;
+	gp_int8_t currentState;
+	gp_uint8_t heaterRequest;
+
+	bool isHeating;
+
+	bool isSafeComponent;
+
+	float minTemp;
+
+	float maxTemp;
+
+	Parameters parameters;
+
+	ThermalMonitor temperatureMonitor;
+
+	const uint8_t domainId;
+
+	virtual float getTemperature();
+	virtual State getState(float temperature, Parameters parameters,
+			int8_t targetState);
+
+	virtual void checkLimits(State state);
+
+	virtual HeaterRequest getHeaterRequest(int8_t targetState,
+			float temperature, Parameters parameters);
+
+	virtual State getIgnoredState(int8_t state);
+
+	void updateMinMaxTemp();
+
+	virtual Parameters getParameters();
+};
+
+#endif /* MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ */
diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index b1cf38f2c..94dd91b5d 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -1,350 +1,350 @@
-#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include "Heater.h"
-
-#include <framework/power/Fuse.h>
-#include <framework/ipc/QueueFactory.h>
-
-Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) :
-		HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
-				NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(
-				false), timedOut(false), reactedToBeingFaulty(false), passive(
-				false), eventQueue(NULL), heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(
-				this), lastAction(CLEAR) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Heater::~Heater() {
-	QueueFactory::instance()->deleteMessageQueue(eventQueue);
-}
-
-ReturnValue_t Heater::set() {
-	passive = false;
-	//wait for clear before doing anything
-	if (internalState == STATE_WAIT) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	if (healthHelper.healthTable->isHealthy(getObjectId())) {
-		doAction(SET);
-		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		} else {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	} else {
-		if (healthHelper.healthTable->isFaulty(getObjectId())) {
-			if (!reactedToBeingFaulty) {
-				reactedToBeingFaulty = true;
-				doAction(CLEAR);
-			}
-		}
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-void Heater::clear(bool passive) {
-	this->passive = passive;
-	//Force switching off
-	if (internalState == STATE_WAIT) {
-		internalState = STATE_ON;
-	}
-	if (healthHelper.healthTable->isHealthy(getObjectId())) {
-		doAction(CLEAR);
-	} else if (healthHelper.healthTable->isFaulty(getObjectId())) {
-		if (!reactedToBeingFaulty) {
-			reactedToBeingFaulty = true;
-			doAction(CLEAR);
-		}
-	}
-}
-
-void Heater::doAction(Action action) {
-	//only act if we are not in the right state or in a transition
-	if (action == SET) {
-		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
-				|| (internalState == STATE_EXTERNAL_CONTROL)) {
-			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-			internalState = STATE_WAIT_FOR_SWITCHES_ON;
-			powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
-			powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
-		}
-	} else { //clear
-		if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
-				|| (internalState == STATE_EXTERNAL_CONTROL)) {
-			internalState = STATE_WAIT_FOR_SWITCHES_OFF;
-			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-			powerSwitcher->sendSwitchCommand(switch0,
-					PowerSwitchIF::SWITCH_OFF);
-			powerSwitcher->sendSwitchCommand(switch1,
-					PowerSwitchIF::SWITCH_OFF);
-		}
-	}
-}
-
-void Heater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
-	this->powerSwitcher = powerSwitch;
-}
-
-ReturnValue_t Heater::performOperation(uint8_t opCode) {
-	handleQueue();
-	handleEventQueue();
-
-	if (!healthHelper.healthTable->isFaulty(getObjectId())) {
-		reactedToBeingFaulty = false;
-	}
-
-	switch (internalState) {
-	case STATE_ON:
-		if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
-				|| (powerSwitcher->getSwitchState(switch1)
-						== PowerSwitchIF::SWITCH_OFF)) {
-			//switch went off on its own
-			//trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
-			//do not trigger FD events when under external control
-			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
-				triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
-			} else {
-				internalState = STATE_EXTERNAL_CONTROL;
-			}
-		}
-		break;
-	case STATE_OFF:
-		//check if heater is on, ie both switches are on
-		//if so, just command it to off, to resolve the situation or force a switch stayed on event
-		//But, only do anything if not already faulty (state off is the stable point for being faulty)
-		if ((!healthHelper.healthTable->isFaulty(getObjectId()))
-				&& (powerSwitcher->getSwitchState(switch0)
-						== PowerSwitchIF::SWITCH_ON)
-				&& (powerSwitcher->getSwitchState(switch1)
-						== PowerSwitchIF::SWITCH_ON)) {
-			//do not trigger FD events when under external control
-			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
-				internalState = STATE_WAIT_FOR_SWITCHES_OFF;
-				switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-				powerSwitcher->sendSwitchCommand(switch0,
-						PowerSwitchIF::SWITCH_OFF);
-				powerSwitcher->sendSwitchCommand(switch1,
-						PowerSwitchIF::SWITCH_OFF);
-			} else {
-				internalState = STATE_EXTERNAL_CONTROL;
-			}
-		}
-		break;
-	case STATE_PASSIVE:
-		break;
-	case STATE_WAIT_FOR_SWITCHES_ON:
-		if (switchCountdown.hasTimedOut()) {
-			if ((powerSwitcher->getSwitchState(switch0)
-					== PowerSwitchIF::SWITCH_OFF)
-					|| (powerSwitcher->getSwitchState(switch1)
-							== PowerSwitchIF::SWITCH_OFF)) {
-				triggerEvent(HEATER_STAYED_OFF);
-				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
-			} else {
-				triggerEvent(HEATER_ON);
-				internalState = STATE_ON;
-			}
-		}
-		break;
-	case STATE_WAIT_FOR_SWITCHES_OFF:
-		if (switchCountdown.hasTimedOut()) {
-			//only check for both being on (ie heater still on)
-			if ((powerSwitcher->getSwitchState(switch0)
-					== PowerSwitchIF::SWITCH_ON)
-					&& (powerSwitcher->getSwitchState(switch1)
-							== PowerSwitchIF::SWITCH_ON)) {
-				if (healthHelper.healthTable->isFaulty(getObjectId())) {
-					if (passive) {
-						internalState = STATE_PASSIVE;
-					} else {
-						internalState = STATE_OFF; //just accept it
-					}
-					triggerEvent(HEATER_ON); //but throw an event to make it more visible
-					break;
-				}
-				triggerEvent(HEATER_STAYED_ON);
-				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
-			} else {
-				triggerEvent(HEATER_OFF);
-				if (passive) {
-					internalState = STATE_PASSIVE;
-				} else {
-					internalState = STATE_OFF;
-				}
-			}
-		}
-		break;
-	default:
-		break;
-	}
-
-	if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
-			&& (powerSwitcher->getSwitchState(switch1)
-					== PowerSwitchIF::SWITCH_ON)) {
-		if (wasOn) {
-			if (heaterOnCountdown.hasTimedOut()) {
-				//SHOULDDO this means if a heater fails in single mode, the timeout will start again
-				//I am not sure if this is a bug, but atm I have no idea how to fix this and think
-				//it will be ok. whatcouldpossiblygowrongâ„¢
-				if (!timedOut) {
-					triggerEvent(HEATER_TIMEOUT);
-					timedOut = true;
-				}
-			}
-		} else {
-			wasOn = true;
-			heaterOnCountdown.resetTimer();
-			timedOut = false;
-		}
-	} else {
-		wasOn = false;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Heater::setSwitch(uint8_t number, ReturnValue_t state,
-		uint32_t* uptimeOfSwitching) {
-	if (powerSwitcher == NULL) {
-		return;
-	}
-	if (powerSwitcher->getSwitchState(number) == state) {
-		*uptimeOfSwitching = INVALID_UPTIME;
-	} else {
-		if ((*uptimeOfSwitching == INVALID_UPTIME)) {
-			powerSwitcher->sendSwitchCommand(number, state);
-			Clock::getUptime(uptimeOfSwitching);
-		} else {
-			uint32_t currentUptime;
-			Clock::getUptime(&currentUptime);
-			if (currentUptime - *uptimeOfSwitching
-					> powerSwitcher->getSwitchDelayMs()) {
-				*uptimeOfSwitching = INVALID_UPTIME;
-				if (healthHelper.healthTable->isHealthy(getObjectId())) {
-					if (state == PowerSwitchIF::SWITCH_ON) {
-						triggerEvent(HEATER_STAYED_OFF);
-					} else {
-						triggerEvent(HEATER_STAYED_ON);
-					}
-				}
-				//SHOULDDO MiniOps during switch timeout leads to a faulty switch
-			}
-		}
-	}
-}
-
-MessageQueueId_t Heater::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t Heater::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-			objects::EVENT_MANAGER);
-	if (manager == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	result = manager->registerListener(eventQueue->getId());
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
-			DeviceHandlerFailureIsolation::powerConfirmationId);
-	if (pcdu == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	pcduQueueId = pcdu->getEventReceptionQueue();
-
-	result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
-			getObjectId());
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Heater::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		parameterHelper.handleParameterMessage(&command);
-	}
-}
-
-ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	if (domainId != DOMAIN_ID_BASE) {
-		return INVALID_DOMAIN_ID;
-	}
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set(heaterOnCountdown.timeout);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Heater::handleEventQueue() {
-	EventMessage event;
-	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
-			result == HasReturnvaluesIF::RETURN_OK;
-			result = eventQueue->receiveMessage(&event)) {
-		switch (event.getMessageId()) {
-		case EventMessage::EVENT_MESSAGE:
-			switch (event.getEvent()) {
-			case Fuse::FUSE_WENT_OFF:
-			case HEATER_STAYED_OFF:
-			case HEATER_STAYED_ON://Setting it faulty does not help, but we need to reach a stable state and can check for being faulty before throwing this event again.
-				if (healthHelper.healthTable->isCommandable(getObjectId())) {
-					healthHelper.setHealth(HasHealthIF::FAULTY);
-					internalState = STATE_FAULTY;
-				}
-				break;
-			case PowerSwitchIF::SWITCH_WENT_OFF:
-				internalState = STATE_WAIT;
-				event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
-				if (pcduQueueId != 0) {
-					eventQueue->sendMessage(pcduQueueId, &event);
-				} else {
-					healthHelper.setHealth(HasHealthIF::FAULTY);
-					internalState = STATE_FAULTY;
-				}
-				break;
-			default:
-				return;
-			}
-			break;
-		case EventMessage::YOUR_FAULT:
-			healthHelper.setHealth(HasHealthIF::FAULTY);
-			internalState = STATE_FAULTY;
-			break;
-		case EventMessage::MY_FAULT:
-			//do nothing, we are already in STATE_WAIT and wait for a clear()
-			break;
-		default:
-			return;
-		}
-	}
-}
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+#include "Heater.h"
+
+#include "../power/Fuse.h"
+#include "../ipc/QueueFactory.h"
+
+Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) :
+		HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
+				NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(
+				false), timedOut(false), reactedToBeingFaulty(false), passive(
+				false), eventQueue(NULL), heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(
+				this), lastAction(CLEAR) {
+	eventQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Heater::~Heater() {
+	QueueFactory::instance()->deleteMessageQueue(eventQueue);
+}
+
+ReturnValue_t Heater::set() {
+	passive = false;
+	//wait for clear before doing anything
+	if (internalState == STATE_WAIT) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	if (healthHelper.healthTable->isHealthy(getObjectId())) {
+		doAction(SET);
+		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		} else {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	} else {
+		if (healthHelper.healthTable->isFaulty(getObjectId())) {
+			if (!reactedToBeingFaulty) {
+				reactedToBeingFaulty = true;
+				doAction(CLEAR);
+			}
+		}
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void Heater::clear(bool passive) {
+	this->passive = passive;
+	//Force switching off
+	if (internalState == STATE_WAIT) {
+		internalState = STATE_ON;
+	}
+	if (healthHelper.healthTable->isHealthy(getObjectId())) {
+		doAction(CLEAR);
+	} else if (healthHelper.healthTable->isFaulty(getObjectId())) {
+		if (!reactedToBeingFaulty) {
+			reactedToBeingFaulty = true;
+			doAction(CLEAR);
+		}
+	}
+}
+
+void Heater::doAction(Action action) {
+	//only act if we are not in the right state or in a transition
+	if (action == SET) {
+		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
+				|| (internalState == STATE_EXTERNAL_CONTROL)) {
+			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+			internalState = STATE_WAIT_FOR_SWITCHES_ON;
+			powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
+			powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
+		}
+	} else { //clear
+		if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
+				|| (internalState == STATE_EXTERNAL_CONTROL)) {
+			internalState = STATE_WAIT_FOR_SWITCHES_OFF;
+			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+			powerSwitcher->sendSwitchCommand(switch0,
+					PowerSwitchIF::SWITCH_OFF);
+			powerSwitcher->sendSwitchCommand(switch1,
+					PowerSwitchIF::SWITCH_OFF);
+		}
+	}
+}
+
+void Heater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
+	this->powerSwitcher = powerSwitch;
+}
+
+ReturnValue_t Heater::performOperation(uint8_t opCode) {
+	handleQueue();
+	handleEventQueue();
+
+	if (!healthHelper.healthTable->isFaulty(getObjectId())) {
+		reactedToBeingFaulty = false;
+	}
+
+	switch (internalState) {
+	case STATE_ON:
+		if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
+				|| (powerSwitcher->getSwitchState(switch1)
+						== PowerSwitchIF::SWITCH_OFF)) {
+			//switch went off on its own
+			//trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
+			//do not trigger FD events when under external control
+			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
+				triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
+			} else {
+				internalState = STATE_EXTERNAL_CONTROL;
+			}
+		}
+		break;
+	case STATE_OFF:
+		//check if heater is on, ie both switches are on
+		//if so, just command it to off, to resolve the situation or force a switch stayed on event
+		//But, only do anything if not already faulty (state off is the stable point for being faulty)
+		if ((!healthHelper.healthTable->isFaulty(getObjectId()))
+				&& (powerSwitcher->getSwitchState(switch0)
+						== PowerSwitchIF::SWITCH_ON)
+				&& (powerSwitcher->getSwitchState(switch1)
+						== PowerSwitchIF::SWITCH_ON)) {
+			//do not trigger FD events when under external control
+			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
+				internalState = STATE_WAIT_FOR_SWITCHES_OFF;
+				switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+				powerSwitcher->sendSwitchCommand(switch0,
+						PowerSwitchIF::SWITCH_OFF);
+				powerSwitcher->sendSwitchCommand(switch1,
+						PowerSwitchIF::SWITCH_OFF);
+			} else {
+				internalState = STATE_EXTERNAL_CONTROL;
+			}
+		}
+		break;
+	case STATE_PASSIVE:
+		break;
+	case STATE_WAIT_FOR_SWITCHES_ON:
+		if (switchCountdown.hasTimedOut()) {
+			if ((powerSwitcher->getSwitchState(switch0)
+					== PowerSwitchIF::SWITCH_OFF)
+					|| (powerSwitcher->getSwitchState(switch1)
+							== PowerSwitchIF::SWITCH_OFF)) {
+				triggerEvent(HEATER_STAYED_OFF);
+				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
+			} else {
+				triggerEvent(HEATER_ON);
+				internalState = STATE_ON;
+			}
+		}
+		break;
+	case STATE_WAIT_FOR_SWITCHES_OFF:
+		if (switchCountdown.hasTimedOut()) {
+			//only check for both being on (ie heater still on)
+			if ((powerSwitcher->getSwitchState(switch0)
+					== PowerSwitchIF::SWITCH_ON)
+					&& (powerSwitcher->getSwitchState(switch1)
+							== PowerSwitchIF::SWITCH_ON)) {
+				if (healthHelper.healthTable->isFaulty(getObjectId())) {
+					if (passive) {
+						internalState = STATE_PASSIVE;
+					} else {
+						internalState = STATE_OFF; //just accept it
+					}
+					triggerEvent(HEATER_ON); //but throw an event to make it more visible
+					break;
+				}
+				triggerEvent(HEATER_STAYED_ON);
+				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
+			} else {
+				triggerEvent(HEATER_OFF);
+				if (passive) {
+					internalState = STATE_PASSIVE;
+				} else {
+					internalState = STATE_OFF;
+				}
+			}
+		}
+		break;
+	default:
+		break;
+	}
+
+	if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
+			&& (powerSwitcher->getSwitchState(switch1)
+					== PowerSwitchIF::SWITCH_ON)) {
+		if (wasOn) {
+			if (heaterOnCountdown.hasTimedOut()) {
+				//SHOULDDO this means if a heater fails in single mode, the timeout will start again
+				//I am not sure if this is a bug, but atm I have no idea how to fix this and think
+				//it will be ok. whatcouldpossiblygowrongâ„¢
+				if (!timedOut) {
+					triggerEvent(HEATER_TIMEOUT);
+					timedOut = true;
+				}
+			}
+		} else {
+			wasOn = true;
+			heaterOnCountdown.resetTimer();
+			timedOut = false;
+		}
+	} else {
+		wasOn = false;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Heater::setSwitch(uint8_t number, ReturnValue_t state,
+		uint32_t* uptimeOfSwitching) {
+	if (powerSwitcher == NULL) {
+		return;
+	}
+	if (powerSwitcher->getSwitchState(number) == state) {
+		*uptimeOfSwitching = INVALID_UPTIME;
+	} else {
+		if ((*uptimeOfSwitching == INVALID_UPTIME)) {
+			powerSwitcher->sendSwitchCommand(number, state);
+			Clock::getUptime(uptimeOfSwitching);
+		} else {
+			uint32_t currentUptime;
+			Clock::getUptime(&currentUptime);
+			if (currentUptime - *uptimeOfSwitching
+					> powerSwitcher->getSwitchDelayMs()) {
+				*uptimeOfSwitching = INVALID_UPTIME;
+				if (healthHelper.healthTable->isHealthy(getObjectId())) {
+					if (state == PowerSwitchIF::SWITCH_ON) {
+						triggerEvent(HEATER_STAYED_OFF);
+					} else {
+						triggerEvent(HEATER_STAYED_ON);
+					}
+				}
+				//SHOULDDO MiniOps during switch timeout leads to a faulty switch
+			}
+		}
+	}
+}
+
+MessageQueueId_t Heater::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t Heater::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+			objects::EVENT_MANAGER);
+	if (manager == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	result = manager->registerListener(eventQueue->getId());
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
+			DeviceHandlerFailureIsolation::powerConfirmationId);
+	if (pcdu == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	pcduQueueId = pcdu->getEventReceptionQueue();
+
+	result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
+			getObjectId());
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = healthHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Heater::handleQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		parameterHelper.handleParameterMessage(&command);
+	}
+}
+
+ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	if (domainId != DOMAIN_ID_BASE) {
+		return INVALID_DOMAIN_ID;
+	}
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set(heaterOnCountdown.timeout);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Heater::handleEventQueue() {
+	EventMessage event;
+	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
+			result == HasReturnvaluesIF::RETURN_OK;
+			result = eventQueue->receiveMessage(&event)) {
+		switch (event.getMessageId()) {
+		case EventMessage::EVENT_MESSAGE:
+			switch (event.getEvent()) {
+			case Fuse::FUSE_WENT_OFF:
+			case HEATER_STAYED_OFF:
+			case HEATER_STAYED_ON://Setting it faulty does not help, but we need to reach a stable state and can check for being faulty before throwing this event again.
+				if (healthHelper.healthTable->isCommandable(getObjectId())) {
+					healthHelper.setHealth(HasHealthIF::FAULTY);
+					internalState = STATE_FAULTY;
+				}
+				break;
+			case PowerSwitchIF::SWITCH_WENT_OFF:
+				internalState = STATE_WAIT;
+				event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
+				if (pcduQueueId != 0) {
+					eventQueue->sendMessage(pcduQueueId, &event);
+				} else {
+					healthHelper.setHealth(HasHealthIF::FAULTY);
+					internalState = STATE_FAULTY;
+				}
+				break;
+			default:
+				return;
+			}
+			break;
+		case EventMessage::YOUR_FAULT:
+			healthHelper.setHealth(HasHealthIF::FAULTY);
+			internalState = STATE_FAULTY;
+			break;
+		case EventMessage::MY_FAULT:
+			//do nothing, we are already in STATE_WAIT and wait for a clear()
+			break;
+		default:
+			return;
+		}
+	}
+}
diff --git a/thermal/Heater.h b/thermal/Heater.h
index 41004e039..8121a7746 100644
--- a/thermal/Heater.h
+++ b/thermal/Heater.h
@@ -1,90 +1,90 @@
-#ifndef FRAMEWORK_THERMAL_HEATER_H_
-#define FRAMEWORK_THERMAL_HEATER_H_
-
-#include <framework/devicehandlers/HealthDevice.h>
-#include <framework/parameters/ParameterHelper.h>
-#include <framework/power/PowerSwitchIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/timemanager/Countdown.h>
-#include <stdint.h>
-//class RedundantHeater;
-
-class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
-	friend class RedundantHeater;
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
-	static const Event HEATER_ON = MAKE_EVENT(0, SEVERITY::INFO);
-	static const Event HEATER_OFF = MAKE_EVENT(1, SEVERITY::INFO);
-	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, SEVERITY::LOW);
-
-	Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
-	virtual ~Heater();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	ReturnValue_t initialize();
-
-	ReturnValue_t set();
-	void clear(bool passive);
-
-	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
-
-	MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-protected:
-	static const uint32_t INVALID_UPTIME = 0;
-
-	enum InternalState {
-		STATE_ON,
-		STATE_OFF,
-		STATE_PASSIVE,
-		STATE_WAIT_FOR_SWITCHES_ON,
-		STATE_WAIT_FOR_SWITCHES_OFF,
-		STATE_WAIT_FOR_FDIR, //used to avoid doing anything until fdir decided what to do
-		STATE_FAULTY,
-		STATE_WAIT, //used when waiting for system to recover from miniops
-		STATE_EXTERNAL_CONTROL //entered when under external control and a fdir reaction would be triggered. This is useful when leaving external control into an unknown state
-							   //if no fdir reaction is triggered under external control the state is still ok and no need for any special treatment is needed
-	} internalState;
-
-	PowerSwitchIF *powerSwitcher;
-	MessageQueueId_t pcduQueueId;
-
-	uint8_t switch0;
-	uint8_t switch1;
-
-	bool wasOn;
-
-	bool timedOut;
-
-	bool reactedToBeingFaulty;
-
-	bool passive;
-
-	MessageQueueIF* eventQueue;
-	Countdown heaterOnCountdown;
-	Countdown switchCountdown;
-	ParameterHelper parameterHelper;
-
-	enum Action {
-		SET, CLEAR
-	} lastAction;
-
-	void doAction(Action action);
-
-	void setSwitch(uint8_t number, ReturnValue_t state,
-			uint32_t *upTimeOfSwitching);
-
-	void handleQueue();
-
-	void handleEventQueue();
-};
-
-#endif /* FRAMEWORK_THERMAL_HEATER_H_ */
+#ifndef FRAMEWORK_THERMAL_HEATER_H_
+#define FRAMEWORK_THERMAL_HEATER_H_
+
+#include "../devicehandlers/HealthDevice.h"
+#include "../parameters/ParameterHelper.h"
+#include "../power/PowerSwitchIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Countdown.h"
+#include <stdint.h>
+//class RedundantHeater;
+
+class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
+	friend class RedundantHeater;
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
+	static const Event HEATER_ON = MAKE_EVENT(0, SEVERITY::INFO);
+	static const Event HEATER_OFF = MAKE_EVENT(1, SEVERITY::INFO);
+	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, SEVERITY::LOW);
+
+	Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
+	virtual ~Heater();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	ReturnValue_t initialize();
+
+	ReturnValue_t set();
+	void clear(bool passive);
+
+	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
+
+	MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+protected:
+	static const uint32_t INVALID_UPTIME = 0;
+
+	enum InternalState {
+		STATE_ON,
+		STATE_OFF,
+		STATE_PASSIVE,
+		STATE_WAIT_FOR_SWITCHES_ON,
+		STATE_WAIT_FOR_SWITCHES_OFF,
+		STATE_WAIT_FOR_FDIR, //used to avoid doing anything until fdir decided what to do
+		STATE_FAULTY,
+		STATE_WAIT, //used when waiting for system to recover from miniops
+		STATE_EXTERNAL_CONTROL //entered when under external control and a fdir reaction would be triggered. This is useful when leaving external control into an unknown state
+							   //if no fdir reaction is triggered under external control the state is still ok and no need for any special treatment is needed
+	} internalState;
+
+	PowerSwitchIF *powerSwitcher;
+	MessageQueueId_t pcduQueueId;
+
+	uint8_t switch0;
+	uint8_t switch1;
+
+	bool wasOn;
+
+	bool timedOut;
+
+	bool reactedToBeingFaulty;
+
+	bool passive;
+
+	MessageQueueIF* eventQueue;
+	Countdown heaterOnCountdown;
+	Countdown switchCountdown;
+	ParameterHelper parameterHelper;
+
+	enum Action {
+		SET, CLEAR
+	} lastAction;
+
+	void doAction(Action action);
+
+	void setSwitch(uint8_t number, ReturnValue_t state,
+			uint32_t *upTimeOfSwitching);
+
+	void handleQueue();
+
+	void handleEventQueue();
+};
+
+#endif /* FRAMEWORK_THERMAL_HEATER_H_ */
diff --git a/thermal/RedundantHeater.h b/thermal/RedundantHeater.h
index 55d402d75..4a82de078 100644
--- a/thermal/RedundantHeater.h
+++ b/thermal/RedundantHeater.h
@@ -1,50 +1,50 @@
-#ifndef REDUNDANTHEATER_H_
-#define REDUNDANTHEATER_H_
-
-#include <framework/thermal/Heater.h>
-
-class RedundantHeater {
-public:
-
-	struct Parameters {
-		Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
-				uint8_t switch0Heater0, uint8_t switch1Heater0,
-				uint8_t switch0Heater1, uint8_t switch1Heater1) :
-				objectIdHeater0(objectIdHeater0), objectIdHeater1(objectIdHeater1),
-				switch0Heater0(switch0Heater0),switch1Heater0(switch1Heater0),
-				switch0Heater1(switch0Heater1), switch1Heater1(switch1Heater1) {
-		}
-
-		Parameters() :
-				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0),
-				switch1Heater0(0), switch0Heater1(0), switch1Heater1(0) {
-		}
-
-		uint32_t objectIdHeater0;
-		uint32_t objectIdHeater1;
-		uint8_t switch0Heater0;
-		uint8_t switch1Heater0;
-		uint8_t switch0Heater1;
-		uint8_t switch1Heater1;
-	};
-
-	RedundantHeater(Parameters parameters);
-	virtual ~RedundantHeater();
-
-	void performOperation(uint8_t opCode);
-
-	void triggerHeaterEvent(Event event);
-
-	void set(bool on, bool both, bool passive = false);
-
-	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
-
-protected:
-
-	Heater heater0;
-	Heater heater1;
-
-};
-
-#endif /* REDUNDANTHEATER_H_ */
-
+#ifndef REDUNDANTHEATER_H_
+#define REDUNDANTHEATER_H_
+
+#include "../thermal/Heater.h"
+
+class RedundantHeater {
+public:
+
+	struct Parameters {
+		Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
+				uint8_t switch0Heater0, uint8_t switch1Heater0,
+				uint8_t switch0Heater1, uint8_t switch1Heater1) :
+				objectIdHeater0(objectIdHeater0), objectIdHeater1(objectIdHeater1),
+				switch0Heater0(switch0Heater0),switch1Heater0(switch1Heater0),
+				switch0Heater1(switch0Heater1), switch1Heater1(switch1Heater1) {
+		}
+
+		Parameters() :
+				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0),
+				switch1Heater0(0), switch0Heater1(0), switch1Heater1(0) {
+		}
+
+		uint32_t objectIdHeater0;
+		uint32_t objectIdHeater1;
+		uint8_t switch0Heater0;
+		uint8_t switch1Heater0;
+		uint8_t switch0Heater1;
+		uint8_t switch1Heater1;
+	};
+
+	RedundantHeater(Parameters parameters);
+	virtual ~RedundantHeater();
+
+	void performOperation(uint8_t opCode);
+
+	void triggerHeaterEvent(Event event);
+
+	void set(bool on, bool both, bool passive = false);
+
+	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
+
+protected:
+
+	Heater heater0;
+	Heater heater1;
+
+};
+
+#endif /* REDUNDANTHEATER_H_ */
+
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 27885b8be..cf2dffd48 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -1,222 +1,222 @@
-#ifndef TEMPERATURESENSOR_H_
-#define TEMPERATURESENSOR_H_
-
-#include <framework/thermal/AbstractTemperatureSensor.h>
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/monitoring/LimitMonitor.h>
-
-/**
- * @brief 	This building block handles non-linear value conversion and
- * 			range checks for analog temperature sensors.
- * @details This class can be used to perform all necessary tasks for temperature sensors.
- *          A sensor can be instantiated by calling the constructor.
- *          The temperature is calculated from an input value with
- *			the calculateOutputTemperature() function. Range checking and
- *			limit monitoring is performed automatically.
- *			The inputType specifies the type of the raw input while the
- *			limitType specifies the type of the upper and lower limit to check against.
- * @ingroup thermal
- */
-
-template<typename inputType, typename limitType = inputType>
-class TemperatureSensor: public AbstractTemperatureSensor {
-public:
-	/**
-	 * This structure contains parameters required for range checking
-	 * and the conversion from the input value to the output temperature.
-	 * a, b and c can be any parameters required to calculate the output
-	 * temperature from the input value, depending on the formula used.
-	 *
-	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
-	 *
-	 * The lower and upper limits can be specified in any type, for example float for C values
-	 * or any other type for raw values.
-	 */
-	struct Parameters {
-		float a;
-		float b;
-		float c;
-		limitType lowerLimit;
-		limitType upperLimit;
-		float maxGradient;
-	};
-
-	/**
-	 * Forward declaration for explicit instantiation of used parameters.
-	 */
-	struct UsedParameters {
-		UsedParameters(Parameters parameters) :
-			a(parameters.a), b(parameters.b), c(parameters.c),
-			gradient(parameters.maxGradient) {}
-		float a;
-		float b;
-		float c;
-		float gradient;
-	};
-
-	/**
-	 * Instantiate Temperature Sensor Object.
-	 * @param setObjectid objectId of the sensor object
-	 * @param inputValue Input value which is converted to a temperature
-	 * @param poolVariable Pool Variable to store the temperature value
-	 * @param vectorIndex Vector Index for the sensor monitor
-	 * @param parameters Calculation parameters, temperature limits, gradient limit
-	 * @param datapoolId Datapool ID of the output temperature
-	 * @param outputSet Output dataset for the output temperature to fetch it with read()
-	 * @param thermalModule respective thermal module, if it has one
-	 */
-	TemperatureSensor(object_id_t setObjectid,
-			inputType *inputValue, PoolVariableIF *poolVariable,
-			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
-			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
-			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
-			inputValue(inputValue), poolVariable(poolVariable),
-			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
-			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
-				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
-				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
-				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
-			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
-	}
-
-
-protected:
-	/**
-	 * This formula is used to calculate the temperature from an input value
-	 * with an arbitrary type.
-	 * A default implementation is provided but can be replaced depending
-	 * on the required calculation.
-	 * @param inputTemperature
-	 * @return
-	 */
-	virtual float calculateOutputTemperature(inputType inputValue) {
-		return parameters.a * inputValue * inputValue
-				+ parameters.b * inputValue + parameters.c;
-	}
-
-
-private:
-	void setInvalid() {
-		outputTemperature = INVALID_TEMPERATURE;
-		outputTemperature.setValid(false);
-		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
-		sensorMonitor.setToInvalid();
-	}
-protected:
-	static const int32_t INVALID_UPTIME = 0;
-
-	UsedParameters parameters;
-
-	inputType * inputValue;
-
-	PoolVariableIF *poolVariable;
-
-	gp_float_t outputTemperature;
-
-	LimitMonitor<limitType> sensorMonitor;
-
-	float oldTemperature;
-	timeval uptimeOfOldTemperature;
-
-	void doChildOperation() {
-		if (!poolVariable->isValid()
-				|| !healthHelper.healthTable->isHealthy(getObjectId())) {
-			setInvalid();
-			return;
-		}
-
-		outputTemperature = calculateOutputTemperature(*inputValue);
-		outputTemperature.setValid(PoolVariableIF::VALID);
-
-		timeval uptime;
-		Clock::getUptime(&uptime);
-
-		if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
-			//In theory, we could use an AbsValueMonitor to monitor the gradient.
-			//But this would require storing the maxGradient in DP and quite some overhead.
-			//The concept of delta limits is a bit strange anyway.
-			float deltaTime;
-			float deltaTemp;
-
-			deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.)
-					- (uptimeOfOldTemperature.tv_sec
-							+ uptimeOfOldTemperature.tv_usec / 1000000.);
-			deltaTemp = oldTemperature - outputTemperature;
-			if (deltaTemp < 0) {
-				deltaTemp = -deltaTemp;
-			}
-			if (parameters.gradient < deltaTemp / deltaTime) {
-				triggerEvent(TEMP_SENSOR_GRADIENT);
-				//Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
-			}
-		}
-
-		//Check is done against raw limits. SHOULDDO: Why? Using �C would be more easy to handle.
-		sensorMonitor.doCheck(outputTemperature.value);
-
-		if (sensorMonitor.isOutOfLimits()) {
-			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
-			outputTemperature.setValid(PoolVariableIF::INVALID);
-			outputTemperature = INVALID_TEMPERATURE;
-		} else {
-			oldTemperature = outputTemperature;
-			uptimeOfOldTemperature = uptime;
-		}
-	}
-
-public:
-	float getTemperature() {
-		return outputTemperature;
-	}
-
-	bool isValid() {
-		return outputTemperature.isValid();
-	}
-
-	static const uint16_t ADDRESS_A = 0;
-	static const uint16_t ADDRESS_B = 1;
-	static const uint16_t ADDRESS_C = 2;
-	static const uint16_t ADDRESS_GRADIENT = 3;
-
-	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
-
-	static const uint8_t DOMAIN_ID_SENSOR = 1;
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
-				parameterWrapper, newValues, startAtIndex);
-		if (result != INVALID_DOMAIN_ID) {
-			return result;
-		}
-		if (domainId != this->DOMAIN_ID_BASE) {
-			return INVALID_DOMAIN_ID;
-		}
-		switch (parameterId) {
-		case ADDRESS_A:
-			parameterWrapper->set(parameters.a);
-			break;
-		case ADDRESS_B:
-			parameterWrapper->set(parameters.b);
-			break;
-		case ADDRESS_C:
-			parameterWrapper->set(parameters.c);
-			break;
-		case ADDRESS_GRADIENT:
-			parameterWrapper->set(parameters.gradient);
-			break;
-		default:
-			return INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	virtual void resetOldState() {
-		sensorMonitor.setToUnchecked();
-	}
-
-};
-
-#endif /* TEMPERATURESENSOR_H_ */
+#ifndef TEMPERATURESENSOR_H_
+#define TEMPERATURESENSOR_H_
+
+#include "../thermal/AbstractTemperatureSensor.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../monitoring/LimitMonitor.h"
+
+/**
+ * @brief 	This building block handles non-linear value conversion and
+ * 			range checks for analog temperature sensors.
+ * @details This class can be used to perform all necessary tasks for temperature sensors.
+ *          A sensor can be instantiated by calling the constructor.
+ *          The temperature is calculated from an input value with
+ *			the calculateOutputTemperature() function. Range checking and
+ *			limit monitoring is performed automatically.
+ *			The inputType specifies the type of the raw input while the
+ *			limitType specifies the type of the upper and lower limit to check against.
+ * @ingroup thermal
+ */
+
+template<typename inputType, typename limitType = inputType>
+class TemperatureSensor: public AbstractTemperatureSensor {
+public:
+	/**
+	 * This structure contains parameters required for range checking
+	 * and the conversion from the input value to the output temperature.
+	 * a, b and c can be any parameters required to calculate the output
+	 * temperature from the input value, depending on the formula used.
+	 *
+	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
+	 *
+	 * The lower and upper limits can be specified in any type, for example float for C values
+	 * or any other type for raw values.
+	 */
+	struct Parameters {
+		float a;
+		float b;
+		float c;
+		limitType lowerLimit;
+		limitType upperLimit;
+		float maxGradient;
+	};
+
+	/**
+	 * Forward declaration for explicit instantiation of used parameters.
+	 */
+	struct UsedParameters {
+		UsedParameters(Parameters parameters) :
+			a(parameters.a), b(parameters.b), c(parameters.c),
+			gradient(parameters.maxGradient) {}
+		float a;
+		float b;
+		float c;
+		float gradient;
+	};
+
+	/**
+	 * Instantiate Temperature Sensor Object.
+	 * @param setObjectid objectId of the sensor object
+	 * @param inputValue Input value which is converted to a temperature
+	 * @param poolVariable Pool Variable to store the temperature value
+	 * @param vectorIndex Vector Index for the sensor monitor
+	 * @param parameters Calculation parameters, temperature limits, gradient limit
+	 * @param datapoolId Datapool ID of the output temperature
+	 * @param outputSet Output dataset for the output temperature to fetch it with read()
+	 * @param thermalModule respective thermal module, if it has one
+	 */
+	TemperatureSensor(object_id_t setObjectid,
+			inputType *inputValue, PoolVariableIF *poolVariable,
+			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
+			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
+			inputValue(inputValue), poolVariable(poolVariable),
+			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
+			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
+				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
+				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
+			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
+	}
+
+
+protected:
+	/**
+	 * This formula is used to calculate the temperature from an input value
+	 * with an arbitrary type.
+	 * A default implementation is provided but can be replaced depending
+	 * on the required calculation.
+	 * @param inputTemperature
+	 * @return
+	 */
+	virtual float calculateOutputTemperature(inputType inputValue) {
+		return parameters.a * inputValue * inputValue
+				+ parameters.b * inputValue + parameters.c;
+	}
+
+
+private:
+	void setInvalid() {
+		outputTemperature = INVALID_TEMPERATURE;
+		outputTemperature.setValid(false);
+		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
+		sensorMonitor.setToInvalid();
+	}
+protected:
+	static const int32_t INVALID_UPTIME = 0;
+
+	UsedParameters parameters;
+
+	inputType * inputValue;
+
+	PoolVariableIF *poolVariable;
+
+	gp_float_t outputTemperature;
+
+	LimitMonitor<limitType> sensorMonitor;
+
+	float oldTemperature;
+	timeval uptimeOfOldTemperature;
+
+	void doChildOperation() {
+		if (!poolVariable->isValid()
+				|| !healthHelper.healthTable->isHealthy(getObjectId())) {
+			setInvalid();
+			return;
+		}
+
+		outputTemperature = calculateOutputTemperature(*inputValue);
+		outputTemperature.setValid(PoolVariableIF::VALID);
+
+		timeval uptime;
+		Clock::getUptime(&uptime);
+
+		if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
+			//In theory, we could use an AbsValueMonitor to monitor the gradient.
+			//But this would require storing the maxGradient in DP and quite some overhead.
+			//The concept of delta limits is a bit strange anyway.
+			float deltaTime;
+			float deltaTemp;
+
+			deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.)
+					- (uptimeOfOldTemperature.tv_sec
+							+ uptimeOfOldTemperature.tv_usec / 1000000.);
+			deltaTemp = oldTemperature - outputTemperature;
+			if (deltaTemp < 0) {
+				deltaTemp = -deltaTemp;
+			}
+			if (parameters.gradient < deltaTemp / deltaTime) {
+				triggerEvent(TEMP_SENSOR_GRADIENT);
+				//Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
+			}
+		}
+
+		//Check is done against raw limits. SHOULDDO: Why? Using �C would be more easy to handle.
+		sensorMonitor.doCheck(outputTemperature.value);
+
+		if (sensorMonitor.isOutOfLimits()) {
+			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
+			outputTemperature.setValid(PoolVariableIF::INVALID);
+			outputTemperature = INVALID_TEMPERATURE;
+		} else {
+			oldTemperature = outputTemperature;
+			uptimeOfOldTemperature = uptime;
+		}
+	}
+
+public:
+	float getTemperature() {
+		return outputTemperature;
+	}
+
+	bool isValid() {
+		return outputTemperature.isValid();
+	}
+
+	static const uint16_t ADDRESS_A = 0;
+	static const uint16_t ADDRESS_B = 1;
+	static const uint16_t ADDRESS_C = 2;
+	static const uint16_t ADDRESS_GRADIENT = 3;
+
+	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
+
+	static const uint8_t DOMAIN_ID_SENSOR = 1;
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
+				parameterWrapper, newValues, startAtIndex);
+		if (result != INVALID_DOMAIN_ID) {
+			return result;
+		}
+		if (domainId != this->DOMAIN_ID_BASE) {
+			return INVALID_DOMAIN_ID;
+		}
+		switch (parameterId) {
+		case ADDRESS_A:
+			parameterWrapper->set(parameters.a);
+			break;
+		case ADDRESS_B:
+			parameterWrapper->set(parameters.b);
+			break;
+		case ADDRESS_C:
+			parameterWrapper->set(parameters.c);
+			break;
+		case ADDRESS_GRADIENT:
+			parameterWrapper->set(parameters.gradient);
+			break;
+		default:
+			return INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	virtual void resetOldState() {
+		sensorMonitor.setToUnchecked();
+	}
+
+};
+
+#endif /* TEMPERATURESENSOR_H_ */
diff --git a/thermal/ThermalComponentIF.h b/thermal/ThermalComponentIF.h
index ad8dbd0a8..f5f49ba1a 100644
--- a/thermal/ThermalComponentIF.h
+++ b/thermal/ThermalComponentIF.h
@@ -1,114 +1,114 @@
-#ifndef THERMALCOMPONENTIF_H_
-#define THERMALCOMPONENTIF_H_
-
-#include <framework/events/Event.h>
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-
-class ThermalComponentIF : public HasParametersIF {
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_1;
-	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, SEVERITY::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
-	static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t ABOVE_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF1);
-	static const ReturnValue_t BELOW_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF2);
-
-	enum State {
-		OUT_OF_RANGE_LOW = -2,
-		NON_OPERATIONAL_LOW = -1,
-		OPERATIONAL = 0,
-		NON_OPERATIONAL_HIGH = 1,
-		OUT_OF_RANGE_HIGH = 2,
-		OUT_OF_RANGE_LOW_IGNORED = OUT_OF_RANGE_LOW - 10,
-		NON_OPERATIONAL_LOW_IGNORED = NON_OPERATIONAL_LOW - 10,
-		OPERATIONAL_IGNORED = OPERATIONAL + 10,
-		NON_OPERATIONAL_HIGH_IGNORED = NON_OPERATIONAL_HIGH + 10,
-		OUT_OF_RANGE_HIGH_IGNORED = OUT_OF_RANGE_HIGH + 10,
-		UNKNOWN = 20
-	};
-
-	enum StateRequest {
-		STATE_REQUEST_HEATING = 4,
-		STATE_REQUEST_IGNORE = 3,
-		STATE_REQUEST_OPERATIONAL = 1,
-		STATE_REQUEST_NON_OPERATIONAL = 0
-	};
-
-	/**
-	 * The elements are ordered by priority, lowest have highest priority
-	 */
-	enum Priority {
-		SAFE = 0,             //!< SAFE
-		IDLE,                 //!< IDLE
-		PAYLOAD,              //!< PAYLOAD
-		NUMBER_OF_PRIORITIES          //!< MAX_PRIORITY
-	};
-
-	/**
-	 * The elements are ordered by priority, lowest have highest priority
-	 */
-	enum HeaterRequest {
-		HEATER_REQUEST_EMERGENCY_OFF = 0,          //!< REQUEST_EMERGENCY_OFF
-		HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
-		HEATER_REQUEST_OFF,          //!< REQUEST_OFF
-		HEATER_REQUEST_ON,           //!< REQUEST_ON
-		HEATER_DONT_CARE             //!< DONT_CARE
-	};
-
-	virtual ~ThermalComponentIF() {
-
-	}
-
-	virtual HeaterRequest performOperation(uint8_t opCode) = 0;
-
-	virtual object_id_t getObjectId() = 0;
-
-	virtual uint8_t getDomainId() const = 0;
-
-	virtual void markStateIgnored() = 0;
-
-	virtual float getLowerOpLimit() = 0;
-
-	virtual ReturnValue_t setTargetState(int8_t state) = 0;
-
-	virtual void setOutputInvalid() = 0;
-
-	static bool isOperational(int8_t state) {
-		return ((state == OPERATIONAL) || (state == OPERATIONAL_IGNORED));
-	}
-
-	static bool isOutOfRange(State state) {
-		return ((state == OUT_OF_RANGE_HIGH)
-				|| (state == OUT_OF_RANGE_HIGH_IGNORED)
-				|| (state == OUT_OF_RANGE_LOW)
-				|| (state == OUT_OF_RANGE_LOW_IGNORED) || (state == UNKNOWN));
-	}
-
-	static bool isNonOperational(State state) {
-		return !isOutOfRange(state);
-	}
-
-	static bool isIgnoredState(State state) {
-		switch (state) {
-		case OUT_OF_RANGE_LOW_IGNORED:
-		case OUT_OF_RANGE_HIGH_IGNORED:
-		case NON_OPERATIONAL_LOW_IGNORED:
-		case NON_OPERATIONAL_HIGH_IGNORED:
-		case OPERATIONAL_IGNORED:
-		case UNKNOWN:
-			return true;
-		default:
-			return false;
-		}
-	}
-};
-
-#endif /* THERMALCOMPONENTIF_H_ */
+#ifndef THERMALCOMPONENTIF_H_
+#define THERMALCOMPONENTIF_H_
+
+#include "../events/Event.h"
+#include "../parameters/HasParametersIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+
+class ThermalComponentIF : public HasParametersIF {
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_1;
+	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, SEVERITY::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
+	static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t ABOVE_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF1);
+	static const ReturnValue_t BELOW_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF2);
+
+	enum State {
+		OUT_OF_RANGE_LOW = -2,
+		NON_OPERATIONAL_LOW = -1,
+		OPERATIONAL = 0,
+		NON_OPERATIONAL_HIGH = 1,
+		OUT_OF_RANGE_HIGH = 2,
+		OUT_OF_RANGE_LOW_IGNORED = OUT_OF_RANGE_LOW - 10,
+		NON_OPERATIONAL_LOW_IGNORED = NON_OPERATIONAL_LOW - 10,
+		OPERATIONAL_IGNORED = OPERATIONAL + 10,
+		NON_OPERATIONAL_HIGH_IGNORED = NON_OPERATIONAL_HIGH + 10,
+		OUT_OF_RANGE_HIGH_IGNORED = OUT_OF_RANGE_HIGH + 10,
+		UNKNOWN = 20
+	};
+
+	enum StateRequest {
+		STATE_REQUEST_HEATING = 4,
+		STATE_REQUEST_IGNORE = 3,
+		STATE_REQUEST_OPERATIONAL = 1,
+		STATE_REQUEST_NON_OPERATIONAL = 0
+	};
+
+	/**
+	 * The elements are ordered by priority, lowest have highest priority
+	 */
+	enum Priority {
+		SAFE = 0,             //!< SAFE
+		IDLE,                 //!< IDLE
+		PAYLOAD,              //!< PAYLOAD
+		NUMBER_OF_PRIORITIES          //!< MAX_PRIORITY
+	};
+
+	/**
+	 * The elements are ordered by priority, lowest have highest priority
+	 */
+	enum HeaterRequest {
+		HEATER_REQUEST_EMERGENCY_OFF = 0,          //!< REQUEST_EMERGENCY_OFF
+		HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
+		HEATER_REQUEST_OFF,          //!< REQUEST_OFF
+		HEATER_REQUEST_ON,           //!< REQUEST_ON
+		HEATER_DONT_CARE             //!< DONT_CARE
+	};
+
+	virtual ~ThermalComponentIF() {
+
+	}
+
+	virtual HeaterRequest performOperation(uint8_t opCode) = 0;
+
+	virtual object_id_t getObjectId() = 0;
+
+	virtual uint8_t getDomainId() const = 0;
+
+	virtual void markStateIgnored() = 0;
+
+	virtual float getLowerOpLimit() = 0;
+
+	virtual ReturnValue_t setTargetState(int8_t state) = 0;
+
+	virtual void setOutputInvalid() = 0;
+
+	static bool isOperational(int8_t state) {
+		return ((state == OPERATIONAL) || (state == OPERATIONAL_IGNORED));
+	}
+
+	static bool isOutOfRange(State state) {
+		return ((state == OUT_OF_RANGE_HIGH)
+				|| (state == OUT_OF_RANGE_HIGH_IGNORED)
+				|| (state == OUT_OF_RANGE_LOW)
+				|| (state == OUT_OF_RANGE_LOW_IGNORED) || (state == UNKNOWN));
+	}
+
+	static bool isNonOperational(State state) {
+		return !isOutOfRange(state);
+	}
+
+	static bool isIgnoredState(State state) {
+		switch (state) {
+		case OUT_OF_RANGE_LOW_IGNORED:
+		case OUT_OF_RANGE_HIGH_IGNORED:
+		case NON_OPERATIONAL_LOW_IGNORED:
+		case NON_OPERATIONAL_HIGH_IGNORED:
+		case OPERATIONAL_IGNORED:
+		case UNKNOWN:
+			return true;
+		default:
+			return false;
+		}
+	}
+};
+
+#endif /* THERMALCOMPONENTIF_H_ */
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index 9dc1f2372..7ee6b96b2 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -1,288 +1,288 @@
-#include <framework/monitoring/LimitViolationReporter.h>
-#include <framework/monitoring/MonitoringMessageContent.h>
-#include "ThermalModule.h"
-
-#include "AbstractTemperatureSensor.h"
-
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
-		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
-		GlobDataSet *dataSet, Parameters parameters,
-		RedundantHeater::Parameters heaterParameters) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters(parameters), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
-				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
-				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
-	heater = new RedundantHeater(heaterParameters);
-}
-
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters( { 0, 0 }), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
-				NULL), currentState(PoolVariableIF::INVALID, dataSet,
-				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
-				dataSet, PoolVariableIF::VAR_READ) {
-}
-
-ThermalModule::~ThermalModule() {
-	delete heater;
-}
-
-void ThermalModule::performOperation(uint8_t opCode) {
-	if (heater != NULL) {
-		heater->performOperation(0);
-	}
-}
-
-void ThermalModule::performMode(Strategy strategy) {
-	calculateTemperature();
-
-	bool safeOnly = (strategy == ACTIVE_SURVIVAL);
-	ThermalComponentIF::HeaterRequest componentHeaterRequest =
-			letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
-
-	if (heater == NULL) {
-		informComponentsAboutHeaterState(false, NONE);
-		return;
-	}
-
-	bool heating = calculateModuleHeaterRequestAndSetModuleStatus(strategy);
-
-	if (componentHeaterRequest != ThermalComponentIF::HEATER_DONT_CARE) {
-		//Components overwrite the module request.
-		heating = ((componentHeaterRequest
-				== ThermalComponentIF::HEATER_REQUEST_ON)
-				|| (componentHeaterRequest
-						== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
-	}
-
-	bool dual = (strategy == ACTIVE_DUAL);
-
-	if (strategy == PASSIVE) {
-		informComponentsAboutHeaterState(false, NONE);
-		if (oldStrategy != PASSIVE) {
-			heater->set(false, false, true);
-		}
-	} else {
-		if (safeOnly) {
-			informComponentsAboutHeaterState(heating, SAFE);
-		} else {
-			informComponentsAboutHeaterState(heating, ALL);
-		}
-		heater->set(heating, dual);
-	}
-	oldStrategy = strategy;
-}
-
-float ThermalModule::getTemperature() {
-	return moduleTemperature;
-}
-
-void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
-	sensors.push_back(sensor);
-}
-
-void ThermalModule::registerComponent(ThermalComponentIF* component,
-		ThermalComponentIF::Priority priority) {
-	components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
-}
-
-void ThermalModule::calculateTemperature() {
-	uint32_t numberOfValidSensors = 0;
-	moduleTemperature = 0;
-	std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
-	for (; iter != sensors.end(); iter++) {
-		if ((*iter)->isValid()) {
-			moduleTemperature = moduleTemperature + (*iter)->getTemperature();
-			numberOfValidSensors++;
-		}
-	}
-	if (numberOfValidSensors != 0) {
-		moduleTemperature = moduleTemperature / numberOfValidSensors;
-		moduleTemperature.setValid(PoolVariableIF::VALID);
-	} else {
-		moduleTemperature = INVALID_TEMPERATURE;
-		moduleTemperature.setValid(PoolVariableIF::INVALID);
-	}
-}
-
-ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		if (iter->component->getObjectId() == objectId) {
-			return iter->component;
-		}
-	}
-	return NULL;
-}
-
-ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
-		bool safeOnly) {
-	ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
-
-	survivalTargetTemp = -999;
-	targetTemp = -999;
-
-	for (uint8_t i = 0; i < ThermalComponentIF::NUMBER_OF_PRIORITIES; i++) {
-		heaterRequests[i] = ThermalComponentIF::HEATER_DONT_CARE;
-	}
-
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		updateTargetTemperatures(iter->component,
-				iter->priority == ThermalComponentIF::SAFE);
-		ThermalComponentIF::HeaterRequest request =
-				iter->component->performOperation(0);
-		iter->request = request;
-		if (request != ThermalComponentIF::HEATER_DONT_CARE) {
-			if (request < heaterRequests[iter->priority]) {
-				heaterRequests[iter->priority] = request;
-			}
-		}
-	}
-
-	if (!safeOnly) {
-		for (uint8_t i = ThermalComponentIF::NUMBER_OF_PRIORITIES - 1; i > 0;
-				i--) {
-			if (heaterRequests[i - 1] == ThermalComponentIF::HEATER_DONT_CARE) {
-				heaterRequests[i - 1] = heaterRequests[i];
-			}
-		}
-	}
-	return heaterRequests[0];
-}
-
-void ThermalModule::informComponentsAboutHeaterState(bool heaterIsOn,
-		Informee whomToInform) {
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		switch (whomToInform) {
-		case ALL:
-			break;
-		case SAFE:
-			if (!(iter->priority == ThermalComponentIF::SAFE)) {
-				iter->component->markStateIgnored();
-				continue;
-			}
-			break;
-		case NONE:
-			iter->component->markStateIgnored();
-			continue;
-		}
-
-		if (heaterIsOn) {
-			if ((iter->request
-					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_OFF)
-					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_OFF)) {
-				iter->component->markStateIgnored();
-			}
-		} else {
-			if ((iter->request
-					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON)
-					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_ON)) {
-				iter->component->markStateIgnored();
-			}
-		}
-	}
-}
-
-void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
-	if (heater != NULL) {
-		heater->setPowerSwitcher(powerSwitch);
-	}
-
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		float componentLowerOpLimit = iter->component->getLowerOpLimit();
-		if (iter->priority == ThermalComponentIF::SAFE) {
-			if (componentLowerOpLimit > survivalTargetTemp) {
-				survivalTargetTemp = componentLowerOpLimit;
-			}
-		} else {
-			if (componentLowerOpLimit > targetTemp) {
-				targetTemp = componentLowerOpLimit;
-			}
-		}
-	}
-	if (survivalTargetTemp > targetTemp) {
-		targetTemp = survivalTargetTemp;
-	}
-}
-
-bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
-		Strategy strategy) {
-	currentState.setValid(PoolVariableIF::VALID);
-	if (moduleTemperature == INVALID_TEMPERATURE) {
-		currentState = UNKNOWN;
-		return false;
-	}
-
-	float limit = targetTemp;
-	bool heaterRequest = false;
-	if (strategy == ACTIVE_SURVIVAL) {
-		limit = survivalTargetTemp;
-	}
-
-	if (moduleTemperature >= limit) {
-		currentState = OPERATIONAL;
-	} else {
-		currentState = NON_OPERATIONAL;
-	}
-
-	limit += parameters.heaterOn;
-
-	if (heating) {
-		limit += parameters.hysteresis;
-	}
-
-	if (targetState == STATE_REQUEST_HEATING) {
-		if (moduleTemperature < limit) {
-			heaterRequest = true;
-		} else {
-			heaterRequest = false;
-		}
-	}
-
-	heating = heaterRequest;
-
-	return heaterRequest;
-}
-
-void ThermalModule::setHeating(bool on) {
-	GlobDataSet mySet;
-	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_WRITE);
-	if (on) {
-		writableTargetState = STATE_REQUEST_HEATING;
-	} else {
-		writableTargetState = STATE_REQUEST_PASSIVE;
-	}
-	mySet.commit(PoolVariableIF::VALID);
-}
-
-void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
-		bool isSafe) {
-	if (isSafe) {
-		if (component->getLowerOpLimit() > survivalTargetTemp) {
-			survivalTargetTemp = component->getLowerOpLimit();
-		}
-	} else {
-		if (component->getLowerOpLimit() > targetTemp) {
-			targetTemp = component->getLowerOpLimit();
-		}
-	}
-}
-
-void ThermalModule::setOutputInvalid() {
-	moduleTemperature = INVALID_TEMPERATURE;
-	moduleTemperature.setValid(PoolVariableIF::INVALID);
-	currentState.setValid(PoolVariableIF::INVALID);
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		iter->component->setOutputInvalid();
-	}
-	if (heater != NULL) {
-		heater->set(false,true);
-	}
-}
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "ThermalModule.h"
+
+#include "AbstractTemperatureSensor.h"
+
+ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
+		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
+		GlobDataSet *dataSet, Parameters parameters,
+		RedundantHeater::Parameters heaterParameters) :
+		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
+				false), parameters(parameters), moduleTemperature(
+				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
+				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
+				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
+	heater = new RedundantHeater(heaterParameters);
+}
+
+ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
+		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
+				false), parameters( { 0, 0 }), moduleTemperature(
+				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
+				NULL), currentState(PoolVariableIF::INVALID, dataSet,
+				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
+				dataSet, PoolVariableIF::VAR_READ) {
+}
+
+ThermalModule::~ThermalModule() {
+	delete heater;
+}
+
+void ThermalModule::performOperation(uint8_t opCode) {
+	if (heater != NULL) {
+		heater->performOperation(0);
+	}
+}
+
+void ThermalModule::performMode(Strategy strategy) {
+	calculateTemperature();
+
+	bool safeOnly = (strategy == ACTIVE_SURVIVAL);
+	ThermalComponentIF::HeaterRequest componentHeaterRequest =
+			letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
+
+	if (heater == NULL) {
+		informComponentsAboutHeaterState(false, NONE);
+		return;
+	}
+
+	bool heating = calculateModuleHeaterRequestAndSetModuleStatus(strategy);
+
+	if (componentHeaterRequest != ThermalComponentIF::HEATER_DONT_CARE) {
+		//Components overwrite the module request.
+		heating = ((componentHeaterRequest
+				== ThermalComponentIF::HEATER_REQUEST_ON)
+				|| (componentHeaterRequest
+						== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
+	}
+
+	bool dual = (strategy == ACTIVE_DUAL);
+
+	if (strategy == PASSIVE) {
+		informComponentsAboutHeaterState(false, NONE);
+		if (oldStrategy != PASSIVE) {
+			heater->set(false, false, true);
+		}
+	} else {
+		if (safeOnly) {
+			informComponentsAboutHeaterState(heating, SAFE);
+		} else {
+			informComponentsAboutHeaterState(heating, ALL);
+		}
+		heater->set(heating, dual);
+	}
+	oldStrategy = strategy;
+}
+
+float ThermalModule::getTemperature() {
+	return moduleTemperature;
+}
+
+void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
+	sensors.push_back(sensor);
+}
+
+void ThermalModule::registerComponent(ThermalComponentIF* component,
+		ThermalComponentIF::Priority priority) {
+	components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
+}
+
+void ThermalModule::calculateTemperature() {
+	uint32_t numberOfValidSensors = 0;
+	moduleTemperature = 0;
+	std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
+	for (; iter != sensors.end(); iter++) {
+		if ((*iter)->isValid()) {
+			moduleTemperature = moduleTemperature + (*iter)->getTemperature();
+			numberOfValidSensors++;
+		}
+	}
+	if (numberOfValidSensors != 0) {
+		moduleTemperature = moduleTemperature / numberOfValidSensors;
+		moduleTemperature.setValid(PoolVariableIF::VALID);
+	} else {
+		moduleTemperature = INVALID_TEMPERATURE;
+		moduleTemperature.setValid(PoolVariableIF::INVALID);
+	}
+}
+
+ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		if (iter->component->getObjectId() == objectId) {
+			return iter->component;
+		}
+	}
+	return NULL;
+}
+
+ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
+		bool safeOnly) {
+	ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
+
+	survivalTargetTemp = -999;
+	targetTemp = -999;
+
+	for (uint8_t i = 0; i < ThermalComponentIF::NUMBER_OF_PRIORITIES; i++) {
+		heaterRequests[i] = ThermalComponentIF::HEATER_DONT_CARE;
+	}
+
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		updateTargetTemperatures(iter->component,
+				iter->priority == ThermalComponentIF::SAFE);
+		ThermalComponentIF::HeaterRequest request =
+				iter->component->performOperation(0);
+		iter->request = request;
+		if (request != ThermalComponentIF::HEATER_DONT_CARE) {
+			if (request < heaterRequests[iter->priority]) {
+				heaterRequests[iter->priority] = request;
+			}
+		}
+	}
+
+	if (!safeOnly) {
+		for (uint8_t i = ThermalComponentIF::NUMBER_OF_PRIORITIES - 1; i > 0;
+				i--) {
+			if (heaterRequests[i - 1] == ThermalComponentIF::HEATER_DONT_CARE) {
+				heaterRequests[i - 1] = heaterRequests[i];
+			}
+		}
+	}
+	return heaterRequests[0];
+}
+
+void ThermalModule::informComponentsAboutHeaterState(bool heaterIsOn,
+		Informee whomToInform) {
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		switch (whomToInform) {
+		case ALL:
+			break;
+		case SAFE:
+			if (!(iter->priority == ThermalComponentIF::SAFE)) {
+				iter->component->markStateIgnored();
+				continue;
+			}
+			break;
+		case NONE:
+			iter->component->markStateIgnored();
+			continue;
+		}
+
+		if (heaterIsOn) {
+			if ((iter->request
+					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_OFF)
+					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_OFF)) {
+				iter->component->markStateIgnored();
+			}
+		} else {
+			if ((iter->request
+					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON)
+					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_ON)) {
+				iter->component->markStateIgnored();
+			}
+		}
+	}
+}
+
+void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
+	if (heater != NULL) {
+		heater->setPowerSwitcher(powerSwitch);
+	}
+
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		float componentLowerOpLimit = iter->component->getLowerOpLimit();
+		if (iter->priority == ThermalComponentIF::SAFE) {
+			if (componentLowerOpLimit > survivalTargetTemp) {
+				survivalTargetTemp = componentLowerOpLimit;
+			}
+		} else {
+			if (componentLowerOpLimit > targetTemp) {
+				targetTemp = componentLowerOpLimit;
+			}
+		}
+	}
+	if (survivalTargetTemp > targetTemp) {
+		targetTemp = survivalTargetTemp;
+	}
+}
+
+bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
+		Strategy strategy) {
+	currentState.setValid(PoolVariableIF::VALID);
+	if (moduleTemperature == INVALID_TEMPERATURE) {
+		currentState = UNKNOWN;
+		return false;
+	}
+
+	float limit = targetTemp;
+	bool heaterRequest = false;
+	if (strategy == ACTIVE_SURVIVAL) {
+		limit = survivalTargetTemp;
+	}
+
+	if (moduleTemperature >= limit) {
+		currentState = OPERATIONAL;
+	} else {
+		currentState = NON_OPERATIONAL;
+	}
+
+	limit += parameters.heaterOn;
+
+	if (heating) {
+		limit += parameters.hysteresis;
+	}
+
+	if (targetState == STATE_REQUEST_HEATING) {
+		if (moduleTemperature < limit) {
+			heaterRequest = true;
+		} else {
+			heaterRequest = false;
+		}
+	}
+
+	heating = heaterRequest;
+
+	return heaterRequest;
+}
+
+void ThermalModule::setHeating(bool on) {
+	GlobDataSet mySet;
+	gp_int8_t writableTargetState(targetState.getDataPoolId(),
+			&mySet, PoolVariableIF::VAR_WRITE);
+	if (on) {
+		writableTargetState = STATE_REQUEST_HEATING;
+	} else {
+		writableTargetState = STATE_REQUEST_PASSIVE;
+	}
+	mySet.commit(PoolVariableIF::VALID);
+}
+
+void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
+		bool isSafe) {
+	if (isSafe) {
+		if (component->getLowerOpLimit() > survivalTargetTemp) {
+			survivalTargetTemp = component->getLowerOpLimit();
+		}
+	} else {
+		if (component->getLowerOpLimit() > targetTemp) {
+			targetTemp = component->getLowerOpLimit();
+		}
+	}
+}
+
+void ThermalModule::setOutputInvalid() {
+	moduleTemperature = INVALID_TEMPERATURE;
+	moduleTemperature.setValid(PoolVariableIF::INVALID);
+	currentState.setValid(PoolVariableIF::INVALID);
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		iter->component->setOutputInvalid();
+	}
+	if (heater != NULL) {
+		heater->set(false,true);
+	}
+}
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index 21414f15c..466926401 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -1,95 +1,95 @@
-#ifndef THERMALMODULE_H_
-#define THERMALMODULE_H_
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/devicehandlers/HealthDevice.h>
-#include <framework/events/EventReportingProxyIF.h>
-#include "ThermalModuleIF.h"
-#include <list>
-#include "tcsDefinitions.h"
-#include "RedundantHeater.h"
-class PowerSwitchIF;
-
-/**
- * @brief Allows creation of different thermal control domains within a system.
- */
-class ThermalModule: public ThermalModuleIF {
-	friend class ThermalController;
-public:
-	struct Parameters {
-		float heaterOn;
-		float hysteresis;
-	};
-
-	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
-			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
-			RedundantHeater::Parameters heaterParameters);
-
-	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
-
-	virtual ~ThermalModule();
-
-	void performOperation(uint8_t opCode);
-
-	void performMode(Strategy strategy);
-
-	float getTemperature();
-
-	void registerSensor(AbstractTemperatureSensor *sensor);
-
-	void registerComponent(ThermalComponentIF *component,
-			ThermalComponentIF::Priority priority);
-
-	ThermalComponentIF *findComponent(object_id_t objectId);
-
-	void initialize(PowerSwitchIF* powerSwitch);
-
-	void setHeating(bool on);
-
-	virtual void setOutputInvalid();
-
-protected:
-	enum Informee {
-		ALL, SAFE, NONE
-	};
-
-	struct ComponentData {
-		ThermalComponentIF *component;
-		ThermalComponentIF::Priority priority;
-		ThermalComponentIF::HeaterRequest request;
-	};
-
-	Strategy oldStrategy;
-
-	float survivalTargetTemp;
-
-	float targetTemp;
-
-	bool heating;
-
-	Parameters parameters;
-
-	gp_float_t moduleTemperature;
-
-	RedundantHeater *heater;
-
-	gp_int8_t currentState;
-	gp_int8_t targetState;
-
-	std::list<AbstractTemperatureSensor *> sensors;
-	std::list<ComponentData> components;
-
-	void calculateTemperature();
-
-	ThermalComponentIF::HeaterRequest letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly);
-
-	void informComponentsAboutHeaterState(bool heaterIsOn,
-			Informee whomToInform);
-
-	bool calculateModuleHeaterRequestAndSetModuleStatus(Strategy strategy);
-
-	void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
-};
-
-#endif /* THERMALMODULE_H_ */
+#ifndef THERMALMODULE_H_
+#define THERMALMODULE_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../events/EventReportingProxyIF.h"
+#include "ThermalModuleIF.h"
+#include <list>
+#include "tcsDefinitions.h"
+#include "RedundantHeater.h"
+class PowerSwitchIF;
+
+/**
+ * @brief Allows creation of different thermal control domains within a system.
+ */
+class ThermalModule: public ThermalModuleIF {
+	friend class ThermalController;
+public:
+	struct Parameters {
+		float heaterOn;
+		float hysteresis;
+	};
+
+	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
+			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
+			RedundantHeater::Parameters heaterParameters);
+
+	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
+
+	virtual ~ThermalModule();
+
+	void performOperation(uint8_t opCode);
+
+	void performMode(Strategy strategy);
+
+	float getTemperature();
+
+	void registerSensor(AbstractTemperatureSensor *sensor);
+
+	void registerComponent(ThermalComponentIF *component,
+			ThermalComponentIF::Priority priority);
+
+	ThermalComponentIF *findComponent(object_id_t objectId);
+
+	void initialize(PowerSwitchIF* powerSwitch);
+
+	void setHeating(bool on);
+
+	virtual void setOutputInvalid();
+
+protected:
+	enum Informee {
+		ALL, SAFE, NONE
+	};
+
+	struct ComponentData {
+		ThermalComponentIF *component;
+		ThermalComponentIF::Priority priority;
+		ThermalComponentIF::HeaterRequest request;
+	};
+
+	Strategy oldStrategy;
+
+	float survivalTargetTemp;
+
+	float targetTemp;
+
+	bool heating;
+
+	Parameters parameters;
+
+	gp_float_t moduleTemperature;
+
+	RedundantHeater *heater;
+
+	gp_int8_t currentState;
+	gp_int8_t targetState;
+
+	std::list<AbstractTemperatureSensor *> sensors;
+	std::list<ComponentData> components;
+
+	void calculateTemperature();
+
+	ThermalComponentIF::HeaterRequest letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly);
+
+	void informComponentsAboutHeaterState(bool heaterIsOn,
+			Informee whomToInform);
+
+	bool calculateModuleHeaterRequestAndSetModuleStatus(Strategy strategy);
+
+	void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
+};
+
+#endif /* THERMALMODULE_H_ */
diff --git a/thermal/ThermalMonitor.cpp b/thermal/ThermalMonitor.cpp
index 773fa084f..af0413bf7 100644
--- a/thermal/ThermalMonitor.cpp
+++ b/thermal/ThermalMonitor.cpp
@@ -1,68 +1,68 @@
-#include <framework/thermal/ThermalMonitor.h>
-#include <framework/thermal/ThermalComponentIF.h>
-#include <framework/monitoring/MonitoringIF.h>
-ThermalMonitor::~ThermalMonitor() {
-}
-
-void ThermalMonitor::sendTransitionEvent(float currentValue,
-		ReturnValue_t state) {
-	switch (state) {
-	case MonitoringIF::BELOW_LOW_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_OOL_LOW, state);
-		break;
-	case MonitoringIF::ABOVE_HIGH_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH, state);
-		break;
-	case ThermalComponentIF::BELOW_OPERATIONAL_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_LOW, state);
-		break;
-	case ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_HIGH, state);
-		break;
-	default:
-		break;
-	}
-}
-
-bool ThermalMonitor::isAboveHighLimit() {
-	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-ReturnValue_t ThermalMonitor::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
-		float upperLimit, bool componentIsOperational) {
-	if (ThermalComponentIF::isIgnoredState(state)) {
-		setToUnchecked();
-		return MonitoringIF::UNCHECKED;
-	}
-	switch (state) {
-	case ThermalComponentIF::OUT_OF_RANGE_LOW:
-		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample, lowerLimit);
-	case ThermalComponentIF::NON_OPERATIONAL_LOW:
-		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT, sample, lowerLimit);
-		} else {
-			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-		}
-	case ThermalComponentIF::OPERATIONAL:
-		return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-	case ThermalComponentIF::NON_OPERATIONAL_HIGH:
-		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT, sample, upperLimit);
-		} else {
-			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-		}
-	case ThermalComponentIF::OUT_OF_RANGE_HIGH:
-		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample, upperLimit);
-	default:
-		//Never reached, all states covered.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
+#include "../thermal/ThermalMonitor.h"
+#include "../thermal/ThermalComponentIF.h"
+#include "../monitoring/MonitoringIF.h"
+ThermalMonitor::~ThermalMonitor() {
+}
+
+void ThermalMonitor::sendTransitionEvent(float currentValue,
+		ReturnValue_t state) {
+	switch (state) {
+	case MonitoringIF::BELOW_LOW_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_OOL_LOW, state);
+		break;
+	case MonitoringIF::ABOVE_HIGH_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH, state);
+		break;
+	case ThermalComponentIF::BELOW_OPERATIONAL_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_LOW, state);
+		break;
+	case ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_HIGH, state);
+		break;
+	default:
+		break;
+	}
+}
+
+bool ThermalMonitor::isAboveHighLimit() {
+	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+ReturnValue_t ThermalMonitor::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
+		float upperLimit, bool componentIsOperational) {
+	if (ThermalComponentIF::isIgnoredState(state)) {
+		setToUnchecked();
+		return MonitoringIF::UNCHECKED;
+	}
+	switch (state) {
+	case ThermalComponentIF::OUT_OF_RANGE_LOW:
+		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample, lowerLimit);
+	case ThermalComponentIF::NON_OPERATIONAL_LOW:
+		if (componentIsOperational) {
+			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT, sample, lowerLimit);
+		} else {
+			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+		}
+	case ThermalComponentIF::OPERATIONAL:
+		return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+	case ThermalComponentIF::NON_OPERATIONAL_HIGH:
+		if (componentIsOperational) {
+			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT, sample, upperLimit);
+		} else {
+			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+		}
+	case ThermalComponentIF::OUT_OF_RANGE_HIGH:
+		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample, upperLimit);
+	default:
+		//Never reached, all states covered.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
diff --git a/thermal/ThermalMonitor.h b/thermal/ThermalMonitor.h
index a38889d01..695286009 100644
--- a/thermal/ThermalMonitor.h
+++ b/thermal/ThermalMonitor.h
@@ -1,26 +1,26 @@
-#ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_
-#define FRAMEWORK_THERMAL_THERMALMONITOR_H_
-
-#include <framework/monitoring/MonitorReporter.h>
-#include <framework/thermal/ThermalComponentIF.h>
-
-/**
- * What does it do. How to use it.
- */
-class ThermalMonitor: public MonitorReporter<float> {
-public:
-	template<typename ... Args>
-	ThermalMonitor(Args ... args) :
-			MonitorReporter<float>(std::forward<Args>(args)...) {
-	}
-	~ThermalMonitor();
-	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
-			float lowerLimit, float upperLimit, bool componentIsOperational = true);
-
-	bool isAboveHighLimit();
-protected:
-	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
-
-};
-
-#endif /* FRAMEWORK_THERMAL_THERMALMONITOR_H_ */
+#ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_
+#define FRAMEWORK_THERMAL_THERMALMONITOR_H_
+
+#include "../monitoring/MonitorReporter.h"
+#include "../thermal/ThermalComponentIF.h"
+
+/**
+ * What does it do. How to use it.
+ */
+class ThermalMonitor: public MonitorReporter<float> {
+public:
+	template<typename ... Args>
+	ThermalMonitor(Args ... args) :
+			MonitorReporter<float>(std::forward<Args>(args)...) {
+	}
+	~ThermalMonitor();
+	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
+			float lowerLimit, float upperLimit, bool componentIsOperational = true);
+
+	bool isAboveHighLimit();
+protected:
+	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
+
+};
+
+#endif /* FRAMEWORK_THERMAL_THERMALMONITOR_H_ */
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 71b2539df..e073ad860 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,602 +1,602 @@
-#include <framework/timemanager/CCSDSTime.h>
-#include <stdio.h>
-#include <inttypes.h>
-#include <math.h>
-
-CCSDSTime::CCSDSTime() {
-}
-
-CCSDSTime::~CCSDSTime() {
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
-		const Clock::TimeOfDay_t* from) {
-	ReturnValue_t result = checkTimeOfDay(from);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	to->pField = (CCS << 4);
-
-	to->yearMSB = (from->year >> 8);
-	to->yearLSB = from->year & 0xff;
-	to->month = from->month;
-	to->day = from->day;
-	to->hour = from->hour;
-	to->minute = from->minute;
-	to->second = from->second;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
-		const Clock::TimeOfDay_t* from) {
-	ReturnValue_t result = checkTimeOfDay(from);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	to->pField = (CCS << 4) + 2;
-
-	to->yearMSB = (from->year >> 8);
-	to->yearLSB = from->year & 0xff;
-	to->month = from->month;
-	to->day = from->day;
-	to->hour = from->hour;
-	to->minute = from->minute;
-	to->second = from->second;
-	to->secondEminus2 = from->usecond / 10000;
-	to->secondEminus4 = (from->usecond % 10000) / 100;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint32_t length) {
-	ReturnValue_t result;
-	if (length > 0xFF) {
-		return LENGTH_MISMATCH;
-	}
-	result = convertFromASCII(to, from, length); //Try to parse it as ASCII
-	if (result == RETURN_OK) {
-		return RETURN_OK;
-	}
-
-	//Seems to be no ascii, try the other formats
-	uint8_t codeIdentification = (*from >> 4);
-	switch (codeIdentification) {
-	case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can... <- see bug 1133
-		return convertFromCUC(to, from, length);
-	case CDS:
-		return convertFromCDS(to, from, length);
-	case CCS: {
-		uint32_t temp = 0;
-		return convertFromCCS(to, from, &temp, length);
-	}
-
-	default:
-		return UNSUPPORTED_TIME_FORMAT;
-	}
-}
-
-ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
-	return UNSUPPORTED_TIME_FORMAT;
-}
-
-ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
-	timeval time;
-	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return convertTimevalToTimeOfDay(to, &time);
-}
-
-ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	uint8_t subsecondsLength = *from & 0b111;
-	uint32_t totalLength = subsecondsLength + 8;
-	if (maxLength < totalLength) {
-		return LENGTH_MISMATCH;
-	}
-
-	*foundLength = totalLength;
-
-	ReturnValue_t result = checkCcs(from, maxLength);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	Ccs_mseconds *temp = (Ccs_mseconds *) from;
-
-	to->year = (temp->yearMSB << 8) + temp->yearLSB;
-	to->hour = temp->hour;
-	to->minute = temp->minute;
-	to->second = temp->second;
-
-	if (temp->pField & (1 << 3)) { //day of year variation
-		uint16_t tempDay = (temp->month << 8) + temp->day;
-		ReturnValue_t result = convertDaysOfYear(tempDay, to->year,
-				&(temp->month), &(temp->day));
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-
-	to->month = temp->month;
-	to->day = temp->day;
-
-	to->usecond = 0;
-	if (subsecondsLength > 0) {
-		*foundLength += 1;
-		if (temp->secondEminus2 >= 100) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->usecond = temp->secondEminus2 * 10000;
-	}
-
-	if (subsecondsLength > 1) {
-		*foundLength += 1;
-		if (temp->secondEminus4 >= 100) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->usecond += temp->secondEminus4 * 100;
-	}
-
-	return RETURN_OK;
-
-}
-
-ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
-	if (length < 19) {
-		return RETURN_FAILED;
-	}
-// Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
-// Suggestion: use uint16 all the time. This should work on all systems.
-#ifdef NEWLIB_NANO_NO_C99_IO
-	uint16_t year;
-	uint16_t month;
-	uint16_t day;
-	uint16_t hour;
-	uint16_t minute;
-	float second;
-	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
-				&month, &day, &hour, &minute, &second);
-	if (count == 6) {
-		to->year = year;
-		to->month = month;
-		to->day = day;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-
-	// try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
-			&hour, &minute, &second);
-	if (count == 5) {
-		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
-				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
-		if (result != RETURN_OK) {
-			return RETURN_FAILED;
-		}
-		to->year = year;
-		to->month = month;
-		to->day = tempDay;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-// Warning: Compiler/Linker fails ambiguously if library does not implement
-// C99 I/O
-#else
-	uint16_t year;
-	uint8_t month;
-	uint16_t day;
-	uint8_t hour;
-	uint8_t minute;
-	float second;
-    //try Code A (yyyy-mm-dd)
-    int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16
-            "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year, &month, &day,
-            &hour, &minute, &second);
-	if (count == 6) {
-		to->year = year;
-		to->month = month;
-		to->day = day;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-
-    //try Code B (yyyy-ddd)
-    count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu8
-            ":%2" SCNu8 ":%fZ", &year, &day, &hour, &minute, &second);
-	if (count == 5) {
-		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
-				&tempDay);
-		if (result != RETURN_OK) {
-			return RETURN_FAILED;
-		}
-		to->year = year;
-		to->month = month;
-		to->day = tempDay;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-#endif
-
-	return UNSUPPORTED_TIME_FORMAT;
-}
-
-ReturnValue_t CCSDSTime::checkCcs(const uint8_t* time, uint8_t length) {
-	Ccs_mseconds *time_struct = (Ccs_mseconds *) time;
-
-	uint8_t additionalBytes = time_struct->pField & 0b111;
-	if ((additionalBytes == 0b111) || (length < (additionalBytes + 8))) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time_struct->pField & (1 << 3)) { //day of year variation
-		uint16_t day = (time_struct->month << 8) + time_struct->day;
-		if (day > 366) {
-			return INVALID_TIME_FORMAT;
-		}
-	} else {
-		if (time_struct->month > 12) {
-			return INVALID_TIME_FORMAT;
-		}
-		if (time_struct->day > 31) {
-			return INVALID_TIME_FORMAT;
-		}
-	}
-	if (time_struct->hour > 23) {
-		return INVALID_TIME_FORMAT;
-	}
-	if (time_struct->minute > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-	if (time_struct->second > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	uint8_t *additionalByte = &time_struct->secondEminus2;
-
-	for (; additionalBytes != 0; additionalBytes--) {
-		if (*additionalByte++ > 99) {
-			return INVALID_TIME_FORMAT;
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertDaysOfYear(uint16_t dayofYear, uint16_t year,
-		uint8_t* month, uint8_t* day) {
-	if (isLeapYear(year)) {
-		if (dayofYear > 366) {
-			return INVALID_DAY_OF_YEAR;
-		}
-	} else {
-		if (dayofYear > 365) {
-			return INVALID_DAY_OF_YEAR;
-		}
-	}
-	*month = 1;
-	if (dayofYear <= 31) {
-		*day = dayofYear;
-		return RETURN_OK;
-	}
-	*month += 1;
-	dayofYear -= 31;
-	if (isLeapYear(year)) {
-		if (dayofYear <= 29) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 29;
-	} else {
-		if (dayofYear <= 28) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 28;
-	}
-	while (*month <= 12) {
-		if (dayofYear <= 31) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 31;
-
-		if (*month == 8) {
-			continue;
-		}
-
-		if (dayofYear <= 30) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 30;
-	}
-	return INVALID_DAY_OF_YEAR;
-}
-
-bool CCSDSTime::isLeapYear(uint32_t year) {
-	if ((year % 400) == 0) {
-		return true;
-	}
-	if ((year % 100) == 0) {
-		return false;
-	}
-	if ((year % 4) == 0) {
-		return true;
-	}
-	return false;
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(CDS_short* to, const timeval* from) {
-	to->pField = (CDS << 4) + 0;
-	uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
-			+ DAYS_CCSDS_TO_UNIX_EPOCH;
-	if (days > (1 << 16)) {
-		//Date is beyond year 2137
-		return TIME_DOES_NOT_FIT_FORMAT;
-	}
-	to->dayMSB = (days & 0xFF00) >> 8;
-	to->dayLSB = (days & 0xFF);
-	uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
-			+ (from->tv_usec / 1000);
-	to->msDay_hh = (msDay & 0xFF000000) >> 24;
-	to->msDay_h = (msDay & 0xFF0000) >> 16;
-	to->msDay_l = (msDay & 0xFF00) >> 8;
-	to->msDay_ll = (msDay & 0xFF);
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
-	to->pFiled = (AGENCY_DEFINED << 4) + 5;
-	to->seconds_hh = (from->tv_sec >> 24) & 0xff;
-	to->seconds_h = (from->tv_sec >> 16) & 0xff;
-	to->seconds_l = (from->tv_sec >> 8) & 0xff;
-	to->seconds_ll = (from->tv_sec >> 0) & 0xff;
-
-	//convert the µs to 2E-16 seconds
-	uint64_t temp = from->tv_usec;
-	temp = temp << 16;
-	temp = temp / 1E6;
-
-	to->subsecondsMSB = (temp >> 8) & 0xff;
-	to->subsecondsLSB = temp & 0xff;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	//We don't expect ascii here. SHOULDDO
-	uint8_t codeIdentification = (*from >> 4);
-	switch (codeIdentification) {
-	//unsupported, as Leap second correction would have to be applied
-//	case CUC_LEVEL1:
-//		return convertFromCUC(to, from, foundLength, maxLength);
-	case CDS:
-		return convertFromCDS(to, from, foundLength, maxLength);
-	case CCS:
-		return convertFromCCS(to, from, foundLength, maxLength);
-	default:
-		return UNSUPPORTED_TIME_FORMAT;
-	}
-
-}
-
-ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	if (maxLength < 1) {
-		return INVALID_TIME_FORMAT;
-	}
-	uint8_t pField = *from;
-	from++;
-	ReturnValue_t result = convertFromCUC(to, pField, from, foundLength,
-			maxLength - 1);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		if (foundLength != NULL) {
-			*foundLength += 1;
-		}
-	}
-	return result;
-}
-
-ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
-	if ((time->month > 12) || (time->month == 0)) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->day == 0) {
-		return INVALID_TIME_FORMAT;
-	}
-	switch (time->month) {
-	case 2:
-		if (isLeapYear(time->year)) {
-			if (time->day > 29) {
-				return INVALID_TIME_FORMAT;
-			}
-		} else {
-			if (time->day > 28) {
-				return INVALID_TIME_FORMAT;
-			}
-		}
-		break;
-	case 4:
-	case 6:
-	case 9:
-	case 11:
-		if (time->day > 30) {
-			return INVALID_TIME_FORMAT;
-		}
-		break;
-	default:
-		if (time->day > 31) {
-			return INVALID_TIME_FORMAT;
-		}
-		break;
-	}
-
-	if (time->hour > 23) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->minute > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->second > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->usecond > 999999) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	return RETURN_OK;
-
-}
-
-ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
-		timeval* from) {
-//This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
-	return UNSUPPORTED_TIME_FORMAT;
-}
-
-ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	uint8_t pField = *from;
-	from++;
-//Check epoch
-	if (pField & 0b1000) {
-		return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
-	}
-//Check length
-	uint8_t expectedLength = 7; //Including p-Field.
-	bool extendedDays = pField & 0b100;
-	if (extendedDays) {
-		expectedLength += 1;
-	}
-	if ((pField & 0b11) == 0b01) {
-		expectedLength += 2;
-	} else if ((pField & 0b11) == 0b10) {
-		expectedLength += 4;
-	}
-	if (foundLength != NULL) {
-		*foundLength = expectedLength;
-	}
-	if (expectedLength > maxLength) {
-		return LENGTH_MISMATCH;
-	}
-//Check and count days
-	uint32_t days = 0;
-	if (extendedDays) {
-		days = (from[0] << 16) + (from[1] << 8) + from[2];
-		from += 3;
-	} else {
-		days = (from[0] << 8) + from[1];
-		from += 2;
-	}
-//Move to POSIX epoch.
-	if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
-		return INVALID_TIME_FORMAT;
-	}
-	days -= DAYS_CCSDS_TO_UNIX_EPOCH;
-	to->tv_sec = days * SECONDS_PER_DAY;
-	uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
-			+ from[3];
-	from += 4;
-	to->tv_sec += (msDay / 1000);
-	to->tv_usec = (msDay % 1000) * 1000;
-	if ((pField & 0b11) == 0b01) {
-		uint16_t usecs = (from[0] << 16) + from[1];
-		from += 2;
-		if (usecs > 999) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->tv_usec += usecs;
-	} else if ((pField & 0b11) == 0b10) {
-		uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
-				+ from[3];
-		from += 4;
-		if (picosecs > 999999) {
-			return INVALID_TIME_FORMAT;
-		}
-		//Not very useful.
-		to->tv_usec += (picosecs / 1000);
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
-		const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
-	uint32_t secs = 0;
-	uint32_t subSeconds = 0;
-	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
-	uint8_t nFine = (pField & 0b11);
-	uint32_t totalLength = nCoarse + nFine;
-	if (foundLength != NULL) {
-		*foundLength = totalLength;
-	}
-	if (totalLength > maxLength) {
-		return LENGTH_MISMATCH;
-	}
-	for (int count = 0; count < nCoarse; count++) {
-		secs += *from << ((nCoarse * 8 - 8) * (1 + count));
-		from++;
-	}
-	for (int count = 0; count < nFine; count++) {
-		subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
-		from++;
-	}
-	//Move to POSIX epoch.
-	to->tv_sec = secs;
-	if (pField & 0b10000) {
-		//CCSDS-Epoch
-		to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
-	}
-	to->tv_usec = subsecondsToMicroseconds(subSeconds);
-	return RETURN_OK;
-}
-
-uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
-	uint64_t temp = (uint64_t) subseconds * 1000000
-			/ (1 << (sizeof(subseconds) * 8));
-	return temp;
-}
-
-ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	Clock::TimeOfDay_t tempTime;
-	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
-			maxLength);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	return Clock::convertTimeOfDayToTimeval(&tempTime, to);
-
-}
+#include "../timemanager/CCSDSTime.h"
+#include <stdio.h>
+#include <inttypes.h>
+#include <math.h>
+
+CCSDSTime::CCSDSTime() {
+}
+
+CCSDSTime::~CCSDSTime() {
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
+		const Clock::TimeOfDay_t* from) {
+	ReturnValue_t result = checkTimeOfDay(from);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	to->pField = (CCS << 4);
+
+	to->yearMSB = (from->year >> 8);
+	to->yearLSB = from->year & 0xff;
+	to->month = from->month;
+	to->day = from->day;
+	to->hour = from->hour;
+	to->minute = from->minute;
+	to->second = from->second;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
+		const Clock::TimeOfDay_t* from) {
+	ReturnValue_t result = checkTimeOfDay(from);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	to->pField = (CCS << 4) + 2;
+
+	to->yearMSB = (from->year >> 8);
+	to->yearLSB = from->year & 0xff;
+	to->month = from->month;
+	to->day = from->day;
+	to->hour = from->hour;
+	to->minute = from->minute;
+	to->second = from->second;
+	to->secondEminus2 = from->usecond / 10000;
+	to->secondEminus4 = (from->usecond % 10000) / 100;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint32_t length) {
+	ReturnValue_t result;
+	if (length > 0xFF) {
+		return LENGTH_MISMATCH;
+	}
+	result = convertFromASCII(to, from, length); //Try to parse it as ASCII
+	if (result == RETURN_OK) {
+		return RETURN_OK;
+	}
+
+	//Seems to be no ascii, try the other formats
+	uint8_t codeIdentification = (*from >> 4);
+	switch (codeIdentification) {
+	case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can... <- see bug 1133
+		return convertFromCUC(to, from, length);
+	case CDS:
+		return convertFromCDS(to, from, length);
+	case CCS: {
+		uint32_t temp = 0;
+		return convertFromCCS(to, from, &temp, length);
+	}
+
+	default:
+		return UNSUPPORTED_TIME_FORMAT;
+	}
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	timeval time;
+	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return convertTimevalToTimeOfDay(to, &time);
+}
+
+ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	uint8_t subsecondsLength = *from & 0b111;
+	uint32_t totalLength = subsecondsLength + 8;
+	if (maxLength < totalLength) {
+		return LENGTH_MISMATCH;
+	}
+
+	*foundLength = totalLength;
+
+	ReturnValue_t result = checkCcs(from, maxLength);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	Ccs_mseconds *temp = (Ccs_mseconds *) from;
+
+	to->year = (temp->yearMSB << 8) + temp->yearLSB;
+	to->hour = temp->hour;
+	to->minute = temp->minute;
+	to->second = temp->second;
+
+	if (temp->pField & (1 << 3)) { //day of year variation
+		uint16_t tempDay = (temp->month << 8) + temp->day;
+		ReturnValue_t result = convertDaysOfYear(tempDay, to->year,
+				&(temp->month), &(temp->day));
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+
+	to->month = temp->month;
+	to->day = temp->day;
+
+	to->usecond = 0;
+	if (subsecondsLength > 0) {
+		*foundLength += 1;
+		if (temp->secondEminus2 >= 100) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->usecond = temp->secondEminus2 * 10000;
+	}
+
+	if (subsecondsLength > 1) {
+		*foundLength += 1;
+		if (temp->secondEminus4 >= 100) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->usecond += temp->secondEminus4 * 100;
+	}
+
+	return RETURN_OK;
+
+}
+
+ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	if (length < 19) {
+		return RETURN_FAILED;
+	}
+// Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
+// Suggestion: use uint16 all the time. This should work on all systems.
+#ifdef NEWLIB_NANO_NO_C99_IO
+	uint16_t year;
+	uint16_t month;
+	uint16_t day;
+	uint16_t hour;
+	uint16_t minute;
+	float second;
+	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
+				&month, &day, &hour, &minute, &second);
+	if (count == 6) {
+		to->year = year;
+		to->month = month;
+		to->day = day;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+
+	// try Code B (yyyy-ddd)
+	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
+			&hour, &minute, &second);
+	if (count == 5) {
+		uint8_t tempDay;
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
+				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
+		if (result != RETURN_OK) {
+			return RETURN_FAILED;
+		}
+		to->year = year;
+		to->month = month;
+		to->day = tempDay;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+// Warning: Compiler/Linker fails ambiguously if library does not implement
+// C99 I/O
+#else
+	uint16_t year;
+	uint8_t month;
+	uint16_t day;
+	uint8_t hour;
+	uint8_t minute;
+	float second;
+    //try Code A (yyyy-mm-dd)
+    int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16
+            "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year, &month, &day,
+            &hour, &minute, &second);
+	if (count == 6) {
+		to->year = year;
+		to->month = month;
+		to->day = day;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+
+    //try Code B (yyyy-ddd)
+    count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu8
+            ":%2" SCNu8 ":%fZ", &year, &day, &hour, &minute, &second);
+	if (count == 5) {
+		uint8_t tempDay;
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
+				&tempDay);
+		if (result != RETURN_OK) {
+			return RETURN_FAILED;
+		}
+		to->year = year;
+		to->month = month;
+		to->day = tempDay;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+#endif
+
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::checkCcs(const uint8_t* time, uint8_t length) {
+	Ccs_mseconds *time_struct = (Ccs_mseconds *) time;
+
+	uint8_t additionalBytes = time_struct->pField & 0b111;
+	if ((additionalBytes == 0b111) || (length < (additionalBytes + 8))) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time_struct->pField & (1 << 3)) { //day of year variation
+		uint16_t day = (time_struct->month << 8) + time_struct->day;
+		if (day > 366) {
+			return INVALID_TIME_FORMAT;
+		}
+	} else {
+		if (time_struct->month > 12) {
+			return INVALID_TIME_FORMAT;
+		}
+		if (time_struct->day > 31) {
+			return INVALID_TIME_FORMAT;
+		}
+	}
+	if (time_struct->hour > 23) {
+		return INVALID_TIME_FORMAT;
+	}
+	if (time_struct->minute > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+	if (time_struct->second > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	uint8_t *additionalByte = &time_struct->secondEminus2;
+
+	for (; additionalBytes != 0; additionalBytes--) {
+		if (*additionalByte++ > 99) {
+			return INVALID_TIME_FORMAT;
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertDaysOfYear(uint16_t dayofYear, uint16_t year,
+		uint8_t* month, uint8_t* day) {
+	if (isLeapYear(year)) {
+		if (dayofYear > 366) {
+			return INVALID_DAY_OF_YEAR;
+		}
+	} else {
+		if (dayofYear > 365) {
+			return INVALID_DAY_OF_YEAR;
+		}
+	}
+	*month = 1;
+	if (dayofYear <= 31) {
+		*day = dayofYear;
+		return RETURN_OK;
+	}
+	*month += 1;
+	dayofYear -= 31;
+	if (isLeapYear(year)) {
+		if (dayofYear <= 29) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 29;
+	} else {
+		if (dayofYear <= 28) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 28;
+	}
+	while (*month <= 12) {
+		if (dayofYear <= 31) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 31;
+
+		if (*month == 8) {
+			continue;
+		}
+
+		if (dayofYear <= 30) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 30;
+	}
+	return INVALID_DAY_OF_YEAR;
+}
+
+bool CCSDSTime::isLeapYear(uint32_t year) {
+	if ((year % 400) == 0) {
+		return true;
+	}
+	if ((year % 100) == 0) {
+		return false;
+	}
+	if ((year % 4) == 0) {
+		return true;
+	}
+	return false;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(CDS_short* to, const timeval* from) {
+	to->pField = (CDS << 4) + 0;
+	uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
+			+ DAYS_CCSDS_TO_UNIX_EPOCH;
+	if (days > (1 << 16)) {
+		//Date is beyond year 2137
+		return TIME_DOES_NOT_FIT_FORMAT;
+	}
+	to->dayMSB = (days & 0xFF00) >> 8;
+	to->dayLSB = (days & 0xFF);
+	uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
+			+ (from->tv_usec / 1000);
+	to->msDay_hh = (msDay & 0xFF000000) >> 24;
+	to->msDay_h = (msDay & 0xFF0000) >> 16;
+	to->msDay_l = (msDay & 0xFF00) >> 8;
+	to->msDay_ll = (msDay & 0xFF);
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
+	to->pFiled = (AGENCY_DEFINED << 4) + 5;
+	to->seconds_hh = (from->tv_sec >> 24) & 0xff;
+	to->seconds_h = (from->tv_sec >> 16) & 0xff;
+	to->seconds_l = (from->tv_sec >> 8) & 0xff;
+	to->seconds_ll = (from->tv_sec >> 0) & 0xff;
+
+	//convert the µs to 2E-16 seconds
+	uint64_t temp = from->tv_usec;
+	temp = temp << 16;
+	temp = temp / 1E6;
+
+	to->subsecondsMSB = (temp >> 8) & 0xff;
+	to->subsecondsLSB = temp & 0xff;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	//We don't expect ascii here. SHOULDDO
+	uint8_t codeIdentification = (*from >> 4);
+	switch (codeIdentification) {
+	//unsupported, as Leap second correction would have to be applied
+//	case CUC_LEVEL1:
+//		return convertFromCUC(to, from, foundLength, maxLength);
+	case CDS:
+		return convertFromCDS(to, from, foundLength, maxLength);
+	case CCS:
+		return convertFromCCS(to, from, foundLength, maxLength);
+	default:
+		return UNSUPPORTED_TIME_FORMAT;
+	}
+
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	if (maxLength < 1) {
+		return INVALID_TIME_FORMAT;
+	}
+	uint8_t pField = *from;
+	from++;
+	ReturnValue_t result = convertFromCUC(to, pField, from, foundLength,
+			maxLength - 1);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		if (foundLength != NULL) {
+			*foundLength += 1;
+		}
+	}
+	return result;
+}
+
+ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
+	if ((time->month > 12) || (time->month == 0)) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->day == 0) {
+		return INVALID_TIME_FORMAT;
+	}
+	switch (time->month) {
+	case 2:
+		if (isLeapYear(time->year)) {
+			if (time->day > 29) {
+				return INVALID_TIME_FORMAT;
+			}
+		} else {
+			if (time->day > 28) {
+				return INVALID_TIME_FORMAT;
+			}
+		}
+		break;
+	case 4:
+	case 6:
+	case 9:
+	case 11:
+		if (time->day > 30) {
+			return INVALID_TIME_FORMAT;
+		}
+		break;
+	default:
+		if (time->day > 31) {
+			return INVALID_TIME_FORMAT;
+		}
+		break;
+	}
+
+	if (time->hour > 23) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->minute > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->second > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->usecond > 999999) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	return RETURN_OK;
+
+}
+
+ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+		timeval* from) {
+//This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	uint8_t pField = *from;
+	from++;
+//Check epoch
+	if (pField & 0b1000) {
+		return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
+	}
+//Check length
+	uint8_t expectedLength = 7; //Including p-Field.
+	bool extendedDays = pField & 0b100;
+	if (extendedDays) {
+		expectedLength += 1;
+	}
+	if ((pField & 0b11) == 0b01) {
+		expectedLength += 2;
+	} else if ((pField & 0b11) == 0b10) {
+		expectedLength += 4;
+	}
+	if (foundLength != NULL) {
+		*foundLength = expectedLength;
+	}
+	if (expectedLength > maxLength) {
+		return LENGTH_MISMATCH;
+	}
+//Check and count days
+	uint32_t days = 0;
+	if (extendedDays) {
+		days = (from[0] << 16) + (from[1] << 8) + from[2];
+		from += 3;
+	} else {
+		days = (from[0] << 8) + from[1];
+		from += 2;
+	}
+//Move to POSIX epoch.
+	if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
+		return INVALID_TIME_FORMAT;
+	}
+	days -= DAYS_CCSDS_TO_UNIX_EPOCH;
+	to->tv_sec = days * SECONDS_PER_DAY;
+	uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
+			+ from[3];
+	from += 4;
+	to->tv_sec += (msDay / 1000);
+	to->tv_usec = (msDay % 1000) * 1000;
+	if ((pField & 0b11) == 0b01) {
+		uint16_t usecs = (from[0] << 16) + from[1];
+		from += 2;
+		if (usecs > 999) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->tv_usec += usecs;
+	} else if ((pField & 0b11) == 0b10) {
+		uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
+				+ from[3];
+		from += 4;
+		if (picosecs > 999999) {
+			return INVALID_TIME_FORMAT;
+		}
+		//Not very useful.
+		to->tv_usec += (picosecs / 1000);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
+		const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
+	uint32_t secs = 0;
+	uint32_t subSeconds = 0;
+	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
+	uint8_t nFine = (pField & 0b11);
+	uint32_t totalLength = nCoarse + nFine;
+	if (foundLength != NULL) {
+		*foundLength = totalLength;
+	}
+	if (totalLength > maxLength) {
+		return LENGTH_MISMATCH;
+	}
+	for (int count = 0; count < nCoarse; count++) {
+		secs += *from << ((nCoarse * 8 - 8) * (1 + count));
+		from++;
+	}
+	for (int count = 0; count < nFine; count++) {
+		subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
+		from++;
+	}
+	//Move to POSIX epoch.
+	to->tv_sec = secs;
+	if (pField & 0b10000) {
+		//CCSDS-Epoch
+		to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
+	}
+	to->tv_usec = subsecondsToMicroseconds(subSeconds);
+	return RETURN_OK;
+}
+
+uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
+	uint64_t temp = (uint64_t) subseconds * 1000000
+			/ (1 << (sizeof(subseconds) * 8));
+	return temp;
+}
+
+ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	Clock::TimeOfDay_t tempTime;
+	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
+			maxLength);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	return Clock::convertTimeOfDayToTimeval(&tempTime, to);
+
+}
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index 92060d5d7..6bb3a75c5 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -1,233 +1,233 @@
-#ifndef CCSDSTIME_H_
-#define CCSDSTIME_H_
-
-// COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
-
-#include <framework/timemanager/Clock.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <stdint.h>
-
-bool operator<(const timeval& lhs, const timeval& rhs);
-bool operator<=(const timeval& lhs, const timeval& rhs);
-bool operator==(const timeval& lhs, const timeval& rhs);
-/**
- * static helper class for CCSDS Time Code Formats
- *
- * as described in CCSDS 301.0-B-3
- *
- * Still work in progress
- */
-class CCSDSTime: public HasReturnvaluesIF {
-public:
-	/**
-	 * The Time code identifications, bits 4-6 in the P-Field
-	 */
-	enum TimeCodeIdentification {
-		CCS = 0b101,
-		CUC_LEVEL1 = 0b001,
-		CUC_LEVEL2 = 0b010,
-		CDS = 0b100,
-		AGENCY_DEFINED = 0b110
-	};
-	static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
-			+ 2;
-	static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
-			+ 2;
-	static const uint8_t P_FIELD_CDS_SHORT = (CDS << 4);
-	/**
-	 * Struct for CDS day-segmented format.
-	 */
-	struct CDS_short {
-		uint8_t pField;
-		uint8_t dayMSB;
-		uint8_t dayLSB;
-		uint8_t msDay_hh;
-		uint8_t msDay_h;
-		uint8_t msDay_l;
-		uint8_t msDay_ll;
-	};
-	/**
-	 * Struct for the CCS fromat in day of month variation with max resolution
-	 */
-	struct Ccs_seconds {
-		uint8_t pField;
-		uint8_t yearMSB;
-		uint8_t yearLSB;
-		uint8_t month;
-		uint8_t day;
-		uint8_t hour;
-		uint8_t minute;
-		uint8_t second;
-	};
-
-	/**
-	 * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
-	 */
-	struct Ccs_mseconds {
-		uint8_t pField;
-		uint8_t yearMSB;
-		uint8_t yearLSB;
-		uint8_t month;
-		uint8_t day;
-		uint8_t hour;
-		uint8_t minute;
-		uint8_t second;
-		uint8_t secondEminus2;
-		uint8_t secondEminus4;
-	};
-
-	struct OBT_FLP {
-		uint8_t pFiled;
-		uint8_t seconds_hh;
-		uint8_t seconds_h;
-		uint8_t seconds_l;
-		uint8_t seconds_ll;
-		uint8_t subsecondsMSB;
-		uint8_t subsecondsLSB;
-	};
-
-	struct TimevalLess {
-		bool operator()(const timeval& lhs, const timeval& rhs) const {
-			return (lhs < rhs);
-		}
-	};
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_TIME_HELPER_CLASS;
-	static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
-			MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
-
-	/**
-	 * convert a TimeofDay struct to ccs with seconds resolution
-	 *
-	 * @param to pointer to a CCS struct
-	 * @param from pointer to a TimeOfDay Struct
-	 * @return
-	 * 		- @c RETURN_OK if OK
-	 * 		- @c INVALID_TIMECODE if not OK
-	 */
-	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
-			Clock::TimeOfDay_t const *from);
-
-	/**
-	 * Converts to CDS format from timeval.
-	 * @param to pointer to the CDS struct to generate
-	 * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
-	 * @return
-	 * 		- @c RETURN_OK as it assumes a valid timeval.
-	 */
-	static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
-
-	static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
-
-	/**
-	 * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
-	 *
-	 * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
-	 *
-	 * @param to pointer to a CCS struct
-	 * @param from pointer to a TimeOfDay Struct
-	 * @return
-	 * 		- @c RETURN_OK if OK
-	 * 		- @c INVALID_TIMECODE if not OK
-	 */
-	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
-			Clock::TimeOfDay_t const *from);
-
-	/**
-	 * SHOULDDO: can this be modified to recognize padding?
-	 * Tries to interpret a Level 1 CCSDS time code
-	 *
-	 * It assumes binary formats contain a valid P Field and recognizes the ASCII format
-	 * by the lack of one.
-	 *
-	 * @param to an empty TimeOfDay struct
-	 * @param from pointer to an CCSDS Time code
-	 * @param length length of the Time code
-	 * @return
-	 * 		- @c RETURN_OK if successful
-	 * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
-	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
-	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
-	 */
-	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint32_t length);
-
-	/**
-	 * not implemented yet
-	 *
-	 * @param to
-	 * @param from
-	 * @return
-	 */
-	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
-
-	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
-
-	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
-
-	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
-private:
-	CCSDSTime();
-	virtual ~CCSDSTime();
-	/**
-	 * checks a ccs time stream for validity
-	 *
-	 * Stream may be longer than the actual timecode
-	 *
-	 * @param time pointer to an Ccs stream
-	 * @param length length of stream
-	 * @return
-	 */
-	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
-
-	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
-
-	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
-	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
-	static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
-	static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
-			* SECONDS_PER_DAY;
-	/**
-	 * @param dayofYear
-	 * @param year
-	 * @param month
-	 * @param day
-	 */
-	static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
-			uint8_t *month, uint8_t *day);
-
-	static bool isLeapYear(uint32_t year);
-	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
-			timeval* from);
-};
-
-#endif /* CCSDSTIME_H_ */
+#ifndef CCSDSTIME_H_
+#define CCSDSTIME_H_
+
+// COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
+
+#include "../timemanager/Clock.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <stdint.h>
+
+bool operator<(const timeval& lhs, const timeval& rhs);
+bool operator<=(const timeval& lhs, const timeval& rhs);
+bool operator==(const timeval& lhs, const timeval& rhs);
+/**
+ * static helper class for CCSDS Time Code Formats
+ *
+ * as described in CCSDS 301.0-B-3
+ *
+ * Still work in progress
+ */
+class CCSDSTime: public HasReturnvaluesIF {
+public:
+	/**
+	 * The Time code identifications, bits 4-6 in the P-Field
+	 */
+	enum TimeCodeIdentification {
+		CCS = 0b101,
+		CUC_LEVEL1 = 0b001,
+		CUC_LEVEL2 = 0b010,
+		CDS = 0b100,
+		AGENCY_DEFINED = 0b110
+	};
+	static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
+			+ 2;
+	static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
+			+ 2;
+	static const uint8_t P_FIELD_CDS_SHORT = (CDS << 4);
+	/**
+	 * Struct for CDS day-segmented format.
+	 */
+	struct CDS_short {
+		uint8_t pField;
+		uint8_t dayMSB;
+		uint8_t dayLSB;
+		uint8_t msDay_hh;
+		uint8_t msDay_h;
+		uint8_t msDay_l;
+		uint8_t msDay_ll;
+	};
+	/**
+	 * Struct for the CCS fromat in day of month variation with max resolution
+	 */
+	struct Ccs_seconds {
+		uint8_t pField;
+		uint8_t yearMSB;
+		uint8_t yearLSB;
+		uint8_t month;
+		uint8_t day;
+		uint8_t hour;
+		uint8_t minute;
+		uint8_t second;
+	};
+
+	/**
+	 * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
+	 */
+	struct Ccs_mseconds {
+		uint8_t pField;
+		uint8_t yearMSB;
+		uint8_t yearLSB;
+		uint8_t month;
+		uint8_t day;
+		uint8_t hour;
+		uint8_t minute;
+		uint8_t second;
+		uint8_t secondEminus2;
+		uint8_t secondEminus4;
+	};
+
+	struct OBT_FLP {
+		uint8_t pFiled;
+		uint8_t seconds_hh;
+		uint8_t seconds_h;
+		uint8_t seconds_l;
+		uint8_t seconds_ll;
+		uint8_t subsecondsMSB;
+		uint8_t subsecondsLSB;
+	};
+
+	struct TimevalLess {
+		bool operator()(const timeval& lhs, const timeval& rhs) const {
+			return (lhs < rhs);
+		}
+	};
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_TIME_HELPER_CLASS;
+	static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
+			MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
+
+	/**
+	 * convert a TimeofDay struct to ccs with seconds resolution
+	 *
+	 * @param to pointer to a CCS struct
+	 * @param from pointer to a TimeOfDay Struct
+	 * @return
+	 * 		- @c RETURN_OK if OK
+	 * 		- @c INVALID_TIMECODE if not OK
+	 */
+	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
+			Clock::TimeOfDay_t const *from);
+
+	/**
+	 * Converts to CDS format from timeval.
+	 * @param to pointer to the CDS struct to generate
+	 * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
+	 * @return
+	 * 		- @c RETURN_OK as it assumes a valid timeval.
+	 */
+	static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
+
+	static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
+
+	/**
+	 * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
+	 *
+	 * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
+	 *
+	 * @param to pointer to a CCS struct
+	 * @param from pointer to a TimeOfDay Struct
+	 * @return
+	 * 		- @c RETURN_OK if OK
+	 * 		- @c INVALID_TIMECODE if not OK
+	 */
+	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
+			Clock::TimeOfDay_t const *from);
+
+	/**
+	 * SHOULDDO: can this be modified to recognize padding?
+	 * Tries to interpret a Level 1 CCSDS time code
+	 *
+	 * It assumes binary formats contain a valid P Field and recognizes the ASCII format
+	 * by the lack of one.
+	 *
+	 * @param to an empty TimeOfDay struct
+	 * @param from pointer to an CCSDS Time code
+	 * @param length length of the Time code
+	 * @return
+	 * 		- @c RETURN_OK if successful
+	 * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
+	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
+	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
+	 */
+	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint32_t length);
+
+	/**
+	 * not implemented yet
+	 *
+	 * @param to
+	 * @param from
+	 * @return
+	 */
+	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
+			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
+			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
+private:
+	CCSDSTime();
+	virtual ~CCSDSTime();
+	/**
+	 * checks a ccs time stream for validity
+	 *
+	 * Stream may be longer than the actual timecode
+	 *
+	 * @param time pointer to an Ccs stream
+	 * @param length length of stream
+	 * @return
+	 */
+	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
+
+	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
+
+	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
+	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
+	static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
+	static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
+			* SECONDS_PER_DAY;
+	/**
+	 * @param dayofYear
+	 * @param year
+	 * @param month
+	 * @param day
+	 */
+	static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
+			uint8_t *month, uint8_t *day);
+
+	static bool isLeapYear(uint32_t year);
+	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+			timeval* from);
+};
+
+#endif /* CCSDSTIME_H_ */
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 65e152bfc..c7436252a 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -1,155 +1,155 @@
-#ifndef FRAMEWORK_TIMEMANAGER_CLOCK_H_
-#define FRAMEWORK_TIMEMANAGER_CLOCK_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MutexFactory.h>
-#include <framework/globalfunctions/timevalOperations.h>
-
-#include <cstdint>
-#include <sys/time.h>
-
-//! Don't use these for time points, type is not large enough for UNIX epoch.
-using dur_millis_t = uint32_t;
-using dur_seconds_t = double;
-
-class Clock {
-public:
-	typedef struct {
-	  uint32_t year; //!< Year, A.D.
-	  uint32_t month; //!< Month, 1 .. 12.
-	  uint32_t day; //!< Day, 1 .. 31.
-	  uint32_t hour; //!< Hour, 0 .. 23.
-	  uint32_t minute; //!< Minute, 0 .. 59.
-	  uint32_t second; //!< Second, 0 .. 59.
-	  uint32_t usecond; //!< Microseconds, 0 .. 999999
-	}   TimeOfDay_t;
-
-	/**
-	 * This method returns the number of clock ticks per second.
-	 * In RTEMS, this is typically 1000.
-	 * @return	The number of ticks.
-	 *
-	 * @deprecated, we should not worry about ticks, but only time
-	 */
-	static uint32_t getTicksPerSecond(void);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a TimeOfDay_t struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
-	 * 				is returned.
-	 */
-	static ReturnValue_t setClock(const TimeOfDay_t* time);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a timeval struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setClock(const timeval* time);
-	/**
-	 * This system call returns the current system clock in timeval format.
-	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
-	 * microseconds since an OS-defined epoch.
-	 * @param time	A pointer to a timeval struct where the current time is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_timeval(timeval* time);
-
-	/**
-	 * Get the time since boot in a timeval struct
-	 *
-	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 *
-	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
-	 */
-	static ReturnValue_t getUptime(timeval* uptime);
-
-	static timeval getUptime();
-
-	/**
-	 * Get the time since boot in milliseconds
-	 *
-	 * This value can overflow! Still, it can be used to calculate time intervalls
-	 * between two calls up to 49 days by always using uint32_t in the calculation
-	 *
-	 * @param ms uptime in ms
-	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getUptime(uint32_t* uptimeMs);
-
-	/**
-	 * Returns the time in microseconds since an OS-defined epoch.
-	 * The time is returned in a 64 bit unsigned integer.
-	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_usecs(uint64_t* time);
-	/**
-	 * Returns the time in a TimeOfDay_t struct.
-	 * @param time A pointer to a TimeOfDay_t struct.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
-
-	/**
-	 * Converts a time of day struct to POSIX seconds.
-	 * @param time The time of day as input
-	 * @param timeval The corresponding seconds since the epoch.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-			timeval* to);
-
-	/**
-	 * Converts a time represented as seconds and subseconds since unix epoch to days since J2000
-	 *
-	 * @param time seconds since unix epoch
-	 * @param[out] JD2000 days since J2000
-	 * @return \c RETURN_OK
-	 */
-	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
-
-	/**
-	 * Calculates and adds the offset between UTC and TT
-	 *
-	 * Depends on the leap seconds to be set correctly.
-	 *
-	 * @param utc timeval, corresponding to UTC time
-	 * @param[out] tt timeval, corresponding to Terrestial Time
-	 * @return \c RETURN_OK on success, \c RETURN_FAILED if leapSeconds are not set
-	 */
-	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
-
-	/**
-	 * Set the Leap Seconds since 1972
-	 *
-	 * @param leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
-
-	/**
-	 * Get the Leap Seconds since 1972
-	 *
-	 * Must be set before!
-	 *
-	 * @param[out] leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
-
-	/**
-	 * Function to check and create the Mutex for the clock
-	 * @return \c RETURN_OK on success. Otherwise \c RETURN_FAILED if not able to create one
-	 */
-	static ReturnValue_t checkOrCreateClockMutex();
-
-private:
-	static MutexIF* timeMutex;
-	static uint16_t leapSeconds;
-};
-
-
-#endif /* FRAMEWORK_TIMEMANAGER_CLOCK_H_ */
+#ifndef FRAMEWORK_TIMEMANAGER_CLOCK_H_
+#define FRAMEWORK_TIMEMANAGER_CLOCK_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MutexFactory.h"
+#include "../globalfunctions/timevalOperations.h"
+
+#include <cstdint>
+#include <sys/time.h>
+
+//! Don't use these for time points, type is not large enough for UNIX epoch.
+using dur_millis_t = uint32_t;
+using dur_seconds_t = double;
+
+class Clock {
+public:
+	typedef struct {
+	  uint32_t year; //!< Year, A.D.
+	  uint32_t month; //!< Month, 1 .. 12.
+	  uint32_t day; //!< Day, 1 .. 31.
+	  uint32_t hour; //!< Hour, 0 .. 23.
+	  uint32_t minute; //!< Minute, 0 .. 59.
+	  uint32_t second; //!< Second, 0 .. 59.
+	  uint32_t usecond; //!< Microseconds, 0 .. 999999
+	}   TimeOfDay_t;
+
+	/**
+	 * This method returns the number of clock ticks per second.
+	 * In RTEMS, this is typically 1000.
+	 * @return	The number of ticks.
+	 *
+	 * @deprecated, we should not worry about ticks, but only time
+	 */
+	static uint32_t getTicksPerSecond(void);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a TimeOfDay_t struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
+	 * 				is returned.
+	 */
+	static ReturnValue_t setClock(const TimeOfDay_t* time);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a timeval struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setClock(const timeval* time);
+	/**
+	 * This system call returns the current system clock in timeval format.
+	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
+	 * microseconds since an OS-defined epoch.
+	 * @param time	A pointer to a timeval struct where the current time is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_timeval(timeval* time);
+
+	/**
+	 * Get the time since boot in a timeval struct
+	 *
+	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 *
+	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
+	 */
+	static ReturnValue_t getUptime(timeval* uptime);
+
+	static timeval getUptime();
+
+	/**
+	 * Get the time since boot in milliseconds
+	 *
+	 * This value can overflow! Still, it can be used to calculate time intervalls
+	 * between two calls up to 49 days by always using uint32_t in the calculation
+	 *
+	 * @param ms uptime in ms
+	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getUptime(uint32_t* uptimeMs);
+
+	/**
+	 * Returns the time in microseconds since an OS-defined epoch.
+	 * The time is returned in a 64 bit unsigned integer.
+	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_usecs(uint64_t* time);
+	/**
+	 * Returns the time in a TimeOfDay_t struct.
+	 * @param time A pointer to a TimeOfDay_t struct.
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
+
+	/**
+	 * Converts a time of day struct to POSIX seconds.
+	 * @param time The time of day as input
+	 * @param timeval The corresponding seconds since the epoch.
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+			timeval* to);
+
+	/**
+	 * Converts a time represented as seconds and subseconds since unix epoch to days since J2000
+	 *
+	 * @param time seconds since unix epoch
+	 * @param[out] JD2000 days since J2000
+	 * @return \c RETURN_OK
+	 */
+	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
+
+	/**
+	 * Calculates and adds the offset between UTC and TT
+	 *
+	 * Depends on the leap seconds to be set correctly.
+	 *
+	 * @param utc timeval, corresponding to UTC time
+	 * @param[out] tt timeval, corresponding to Terrestial Time
+	 * @return \c RETURN_OK on success, \c RETURN_FAILED if leapSeconds are not set
+	 */
+	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
+
+	/**
+	 * Set the Leap Seconds since 1972
+	 *
+	 * @param leapSeconds_
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
+
+	/**
+	 * Get the Leap Seconds since 1972
+	 *
+	 * Must be set before!
+	 *
+	 * @param[out] leapSeconds_
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
+
+	/**
+	 * Function to check and create the Mutex for the clock
+	 * @return \c RETURN_OK on success. Otherwise \c RETURN_FAILED if not able to create one
+	 */
+	static ReturnValue_t checkOrCreateClockMutex();
+
+private:
+	static MutexIF* timeMutex;
+	static uint16_t leapSeconds;
+};
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_CLOCK_H_ */
diff --git a/timemanager/Countdown.cpp b/timemanager/Countdown.cpp
index e65659149..5b019f2b0 100644
--- a/timemanager/Countdown.cpp
+++ b/timemanager/Countdown.cpp
@@ -1,45 +1,45 @@
-/**
- * @file	Countdown.cpp
- * @brief	This file defines the Countdown class.
- * @date	21.03.2013
- * @author	baetz
- */
-
-
-#include <framework/timemanager/Countdown.h>
-
-Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) {
-}
-
-Countdown::~Countdown() {
-}
-
-ReturnValue_t Countdown::setTimeout(uint32_t miliseconds) {
-	ReturnValue_t return_value = Clock::getUptime( &startTime );
-	timeout = miliseconds;
-	return return_value;
-}
-
-bool Countdown::hasTimedOut() const {
-	uint32_t current_time;
-	Clock::getUptime( &current_time );
-	if ( uint32_t(current_time - startTime) >= timeout) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-bool Countdown::isBusy() const {
-	return !hasTimedOut();
-}
-
-ReturnValue_t Countdown::resetTimer() {
-	return setTimeout(timeout);
-}
-
-void Countdown::timeOut() {
-	uint32_t current_time;
-		Clock::getUptime( &current_time );
-	startTime= current_time - timeout;
-}
+/**
+ * @file	Countdown.cpp
+ * @brief	This file defines the Countdown class.
+ * @date	21.03.2013
+ * @author	baetz
+ */
+
+
+#include "../timemanager/Countdown.h"
+
+Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) {
+}
+
+Countdown::~Countdown() {
+}
+
+ReturnValue_t Countdown::setTimeout(uint32_t miliseconds) {
+	ReturnValue_t return_value = Clock::getUptime( &startTime );
+	timeout = miliseconds;
+	return return_value;
+}
+
+bool Countdown::hasTimedOut() const {
+	uint32_t current_time;
+	Clock::getUptime( &current_time );
+	if ( uint32_t(current_time - startTime) >= timeout) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+bool Countdown::isBusy() const {
+	return !hasTimedOut();
+}
+
+ReturnValue_t Countdown::resetTimer() {
+	return setTimeout(timeout);
+}
+
+void Countdown::timeOut() {
+	uint32_t current_time;
+		Clock::getUptime( &current_time );
+	startTime= current_time - timeout;
+}
diff --git a/timemanager/Countdown.h b/timemanager/Countdown.h
index 57a11f911..741ab0f81 100644
--- a/timemanager/Countdown.h
+++ b/timemanager/Countdown.h
@@ -1,31 +1,31 @@
-/**
- * @file	Countdown.h
- * @brief	This file defines the Countdown class.
- * @date	21.03.2013
- * @author	baetz
- */
-
-#ifndef COUNTDOWN_H_
-#define COUNTDOWN_H_
-
-#include <framework/timemanager/Clock.h>
-
-class Countdown {
-private:
-	uint32_t startTime;
-public:
-	uint32_t timeout;
-	Countdown(uint32_t initialTimeout = 0);
-	~Countdown();
-	ReturnValue_t setTimeout(uint32_t miliseconds);
-
-	bool hasTimedOut() const;
-
-	bool isBusy() const;
-
-	ReturnValue_t resetTimer(); //!< Use last set timeout value and restart timer.
-
-	void timeOut(); //!< Make hasTimedOut() return true
-};
-
-#endif /* COUNTDOWN_H_ */
+/**
+ * @file	Countdown.h
+ * @brief	This file defines the Countdown class.
+ * @date	21.03.2013
+ * @author	baetz
+ */
+
+#ifndef COUNTDOWN_H_
+#define COUNTDOWN_H_
+
+#include "../timemanager/Clock.h"
+
+class Countdown {
+private:
+	uint32_t startTime;
+public:
+	uint32_t timeout;
+	Countdown(uint32_t initialTimeout = 0);
+	~Countdown();
+	ReturnValue_t setTimeout(uint32_t miliseconds);
+
+	bool hasTimedOut() const;
+
+	bool isBusy() const;
+
+	ReturnValue_t resetTimer(); //!< Use last set timeout value and restart timer.
+
+	void timeOut(); //!< Make hasTimedOut() return true
+};
+
+#endif /* COUNTDOWN_H_ */
diff --git a/timemanager/ReceivesTimeInfoIF.h b/timemanager/ReceivesTimeInfoIF.h
index f65f9dadd..09915e83f 100644
--- a/timemanager/ReceivesTimeInfoIF.h
+++ b/timemanager/ReceivesTimeInfoIF.h
@@ -1,32 +1,32 @@
-/**
- * @file	ReceivesTimeInfoIF.h
- * @brief	This file defines the ReceivesTimeInfoIF class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#ifndef RECEIVESTIMEINFOIF_H_
-#define RECEIVESTIMEINFOIF_H_
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-/**
- * This is a Interface for classes that receive timing information
- * with the help of a dedicated message queue.
- */
-class ReceivesTimeInfoIF {
-public:
-	/**
-	 * Returns the id of the queue which receives the timing information.
-	 * @return Queue id of the timing queue.
-	 */
-	virtual MessageQueueId_t getTimeReceptionQueue() const = 0;
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~ReceivesTimeInfoIF() {
-	}
-
-};
-
-
-#endif /* RECEIVESTIMEINFOIF_H_ */
+/**
+ * @file	ReceivesTimeInfoIF.h
+ * @brief	This file defines the ReceivesTimeInfoIF class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#ifndef RECEIVESTIMEINFOIF_H_
+#define RECEIVESTIMEINFOIF_H_
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * This is a Interface for classes that receive timing information
+ * with the help of a dedicated message queue.
+ */
+class ReceivesTimeInfoIF {
+public:
+	/**
+	 * Returns the id of the queue which receives the timing information.
+	 * @return Queue id of the timing queue.
+	 */
+	virtual MessageQueueId_t getTimeReceptionQueue() const = 0;
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~ReceivesTimeInfoIF() {
+	}
+
+};
+
+
+#endif /* RECEIVESTIMEINFOIF_H_ */
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 52118d580..bf69d3ce1 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -1,5 +1,5 @@
-#include <framework/timemanager/Stopwatch.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../timemanager/Stopwatch.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 #include <iomanip>
 
 Stopwatch::Stopwatch(bool displayOnDestruction,
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 630202cc1..30735b2c6 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -1,6 +1,6 @@
 #ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
 #define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
-#include <framework/timemanager/Clock.h>
+#include "../timemanager/Clock.h"
 
 enum class StopwatchDisplayMode {
     MILLIS,
diff --git a/timemanager/TimeMessage.cpp b/timemanager/TimeMessage.cpp
index bf514317f..a60718a43 100644
--- a/timemanager/TimeMessage.cpp
+++ b/timemanager/TimeMessage.cpp
@@ -1,37 +1,37 @@
-/**
- * @file	TimeMessage.cpp
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#include <framework/timemanager/TimeMessage.h>
-
-TimeMessage::TimeMessage() {
-	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
-}
-
-TimeMessage::TimeMessage(timeval setTime, uint32_t CounterValue) {
-	memcpy (this->getData(), &setTime, sizeof(timeval));
-	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
-	memcpy (this->getData() + sizeof(timeval), &CounterValue, sizeof(uint32_t));
-}
-
-TimeMessage::~TimeMessage() {
-}
-
-timeval TimeMessage::getTime() {
-	timeval temp;
-	memcpy( &temp, this->getData(), sizeof(timeval));
-	return temp;
-}
-
-uint32_t TimeMessage::getCounterValue() {
-	uint32_t temp;
-	memcpy ( &temp, this->getData() + sizeof(timeval), sizeof(uint32_t));
-	return temp;
-}
-
-size_t TimeMessage::getMinimumMessageSize() {
-	return this->MAX_SIZE;
-}
+/**
+ * @file	TimeMessage.cpp
+ * @brief	This file defines the TimeMessage class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#include "../timemanager/TimeMessage.h"
+
+TimeMessage::TimeMessage() {
+	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
+}
+
+TimeMessage::TimeMessage(timeval setTime, uint32_t CounterValue) {
+	memcpy (this->getData(), &setTime, sizeof(timeval));
+	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
+	memcpy (this->getData() + sizeof(timeval), &CounterValue, sizeof(uint32_t));
+}
+
+TimeMessage::~TimeMessage() {
+}
+
+timeval TimeMessage::getTime() {
+	timeval temp;
+	memcpy( &temp, this->getData(), sizeof(timeval));
+	return temp;
+}
+
+uint32_t TimeMessage::getCounterValue() {
+	uint32_t temp;
+	memcpy ( &temp, this->getData() + sizeof(timeval), sizeof(uint32_t));
+	return temp;
+}
+
+size_t TimeMessage::getMinimumMessageSize() {
+	return this->MAX_SIZE;
+}
diff --git a/timemanager/TimeMessage.h b/timemanager/TimeMessage.h
index 95685fec2..1e440e5d3 100644
--- a/timemanager/TimeMessage.h
+++ b/timemanager/TimeMessage.h
@@ -1,56 +1,56 @@
-/**
- * @file	TimeMessage.h
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#ifndef TIMEMESSAGE_H_
-#define TIMEMESSAGE_H_
-
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/timemanager/Clock.h>
-#include <cstring>
-
-class TimeMessage : public MessageQueueMessage {
-protected:
-	/**
-	 * @brief	This call always returns the same fixed size of the message.
-	 * @return	Returns HEADER_SIZE + \c sizeof(timeval) + sizeof(uint32_t).
-	 */
-	size_t getMinimumMessageSize();
-public:
-
-	/**
-	 * @ brief the size of a TimeMessage
-	 */
-	static const uint32_t MAX_SIZE = HEADER_SIZE + sizeof(timeval) + sizeof(uint32_t);
-
-	/**
-	 * @brief	In the default constructor, only the message_size is set.
-	 */
-	TimeMessage();
-	/**
-	 * @brief	With this constructor, the passed time information is directly put
-	 * 			into the message.
-	 * @param 	setTime The time information to put into the message.
-	 * @param 	counterValue The counterValue to put into the message (GPS PPS).
-	 */
-	TimeMessage( timeval setTime, uint32_t counterValue = 0 );
-	/**
-	 * @brief	The class's destructor is empty.
-	 */
-	~TimeMessage();
-	/**
-	 * @brief	This getter returns the time information in timeval format.
-	 * @return	Returns the time stored in this packet.
-	 */
-	timeval getTime();
-	/**
-	 * @brief 	This getter returns the CounterValue in uint32_t format.
-	 * @return 	Returns the CounterValue stored in this packet.
-	 */
-	uint32_t getCounterValue();
-};
-
-#endif /* TIMEMESSAGE_H_ */
+/**
+ * @file	TimeMessage.h
+ * @brief	This file defines the TimeMessage class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#ifndef TIMEMESSAGE_H_
+#define TIMEMESSAGE_H_
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../timemanager/Clock.h"
+#include <cstring>
+
+class TimeMessage : public MessageQueueMessage {
+protected:
+	/**
+	 * @brief	This call always returns the same fixed size of the message.
+	 * @return	Returns HEADER_SIZE + \c sizeof(timeval) + sizeof(uint32_t).
+	 */
+	size_t getMinimumMessageSize();
+public:
+
+	/**
+	 * @ brief the size of a TimeMessage
+	 */
+	static const uint32_t MAX_SIZE = HEADER_SIZE + sizeof(timeval) + sizeof(uint32_t);
+
+	/**
+	 * @brief	In the default constructor, only the message_size is set.
+	 */
+	TimeMessage();
+	/**
+	 * @brief	With this constructor, the passed time information is directly put
+	 * 			into the message.
+	 * @param 	setTime The time information to put into the message.
+	 * @param 	counterValue The counterValue to put into the message (GPS PPS).
+	 */
+	TimeMessage( timeval setTime, uint32_t counterValue = 0 );
+	/**
+	 * @brief	The class's destructor is empty.
+	 */
+	~TimeMessage();
+	/**
+	 * @brief	This getter returns the time information in timeval format.
+	 * @return	Returns the time stored in this packet.
+	 */
+	timeval getTime();
+	/**
+	 * @brief 	This getter returns the CounterValue in uint32_t format.
+	 * @return 	Returns the CounterValue stored in this packet.
+	 */
+	uint32_t getCounterValue();
+};
+
+#endif /* TIMEMESSAGE_H_ */
diff --git a/timemanager/TimeStamperIF.h b/timemanager/TimeStamperIF.h
index 7ed453716..49e0ec18f 100644
--- a/timemanager/TimeStamperIF.h
+++ b/timemanager/TimeStamperIF.h
@@ -1,24 +1,24 @@
-#ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
-#define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-/**
- * A class implementing this IF provides facilities to add a time stamp to the
- * buffer provided.
- * Implementors need to ensure that calling the method is thread-safe, i.e.
- * addTimeStamp may be called in parallel from a different context.
- */
-class TimeStamperIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TIME_STAMPER_IF;
-	static const ReturnValue_t BAD_TIMESTAMP = MAKE_RETURN_CODE(1);
-
-	static const uint8_t MISSION_TIMESTAMP_SIZE = 8; //!< This is a mission-specific constant and determines the total size reserved for timestamps.
-	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize) = 0;
-	virtual ~TimeStamperIF() {}
-};
-
-
-
-#endif /* FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ */
+#ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+#define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * A class implementing this IF provides facilities to add a time stamp to the
+ * buffer provided.
+ * Implementors need to ensure that calling the method is thread-safe, i.e.
+ * addTimeStamp may be called in parallel from a different context.
+ */
+class TimeStamperIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TIME_STAMPER_IF;
+	static const ReturnValue_t BAD_TIMESTAMP = MAKE_RETURN_CODE(1);
+
+	static const uint8_t MISSION_TIMESTAMP_SIZE = 8; //!< This is a mission-specific constant and determines the total size reserved for timestamps.
+	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize) = 0;
+	virtual ~TimeStamperIF() {}
+};
+
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ */
diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index 9b913b35a..0e20a314e 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -1,95 +1,95 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/timemanager/Clock.h>
-class TmPacketInformation;
-class TmPacketMinimal;
-class SpacePacketBase;
-class ApidSsc;
-
-class TmStoreBackendIF : public HasParametersIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_BACKEND_IF;
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t NULL_REQUESTED = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t DUMP_ERROR = MAKE_RETURN_CODE(7);
-	static const ReturnValue_t CRC_ERROR = MAKE_RETURN_CODE(8);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(9);
-	static const ReturnValue_t IDLE_PACKET_FOUND = MAKE_RETURN_CODE(10);
-	static const ReturnValue_t TELECOMMAND_FOUND = MAKE_RETURN_CODE(11);
-	static const ReturnValue_t NO_PUS_A_TM = MAKE_RETURN_CODE(12);
-	static const ReturnValue_t TOO_SMALL = MAKE_RETURN_CODE(13);
-	static const ReturnValue_t BLOCK_NOT_FOUND = MAKE_RETURN_CODE(14);
-	static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
-	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, SEVERITY::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, SEVERITY::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_READ_FAILED = MAKE_EVENT(3, SEVERITY::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
-	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, SEVERITY::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
-	static const Event STORING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, SEVERITY::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, SEVERITY::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, SEVERITY::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
-	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, SEVERITY::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
-	static const Event STORE_INITIALIZE = MAKE_EVENT(10, SEVERITY::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event INIT_DONE = MAKE_EVENT(11, SEVERITY::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event DUMP_FINISHED = MAKE_EVENT(12, SEVERITY::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FINISHED = MAKE_EVENT(13, SEVERITY::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FAILED = MAKE_EVENT(14, SEVERITY::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
-	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
-
-	virtual ~TmStoreBackendIF() {}
-
-	/**
-	 * What do I need to implement here ?
-	 * @param opCode
-	 * @return
-	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
-	virtual ReturnValue_t initialize() = 0;
-
-	/**
-	 * Implement the storage of TM packets to mass memory
-	 * @param tmPacket
-	 * @return
-	 */
-	virtual ReturnValue_t storePacket(TmPacketMinimal* tmPacket) = 0;
-	virtual ReturnValue_t setFetchLimitTime(const timeval* loverLimit, const timeval* upperLimit) = 0;
-	virtual ReturnValue_t setFetchLimitBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
-	virtual ReturnValue_t fetchPackets(bool fromBegin = false) = 0;
-	virtual ReturnValue_t initializeStore(object_id_t dumpTarget) = 0;
-	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
-
-	/**
-	 * TODO: Adapt for file management system?
-	 * @param startAddress
-	 * @param endAddress
-	 * @return
-	 */
-	virtual ReturnValue_t deleteBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
-	virtual ReturnValue_t deleteTime(const timeval* timeUntil,
-				uint32_t* deletedPackets) = 0;
-	virtual void resetStore(bool clearStore, bool resetWrite, bool resetRead) = 0;
-	virtual bool isReady() = 0;
-	virtual uint32_t availableData() = 0;
-	virtual float getPercentageFilled() const = 0;
-	virtual uint32_t getStoredPacketsCount() const = 0;
-	virtual TmPacketInformation* getOldestPacket() = 0;
-	virtual TmPacketInformation* getYoungestPacket() = 0;
-	virtual float getDataRate() = 0;
-
-};
-
-
-
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
+#ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
+#define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../parameters/HasParametersIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../timemanager/Clock.h"
+class TmPacketInformation;
+class TmPacketMinimal;
+class SpacePacketBase;
+class ApidSsc;
+
+class TmStoreBackendIF : public HasParametersIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_BACKEND_IF;
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t NULL_REQUESTED = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t DUMP_ERROR = MAKE_RETURN_CODE(7);
+	static const ReturnValue_t CRC_ERROR = MAKE_RETURN_CODE(8);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(9);
+	static const ReturnValue_t IDLE_PACKET_FOUND = MAKE_RETURN_CODE(10);
+	static const ReturnValue_t TELECOMMAND_FOUND = MAKE_RETURN_CODE(11);
+	static const ReturnValue_t NO_PUS_A_TM = MAKE_RETURN_CODE(12);
+	static const ReturnValue_t TOO_SMALL = MAKE_RETURN_CODE(13);
+	static const ReturnValue_t BLOCK_NOT_FOUND = MAKE_RETURN_CODE(14);
+	static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
+	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, SEVERITY::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, SEVERITY::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_READ_FAILED = MAKE_EVENT(3, SEVERITY::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
+	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, SEVERITY::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
+	static const Event STORING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, SEVERITY::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, SEVERITY::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, SEVERITY::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
+	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, SEVERITY::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
+	static const Event STORE_INITIALIZE = MAKE_EVENT(10, SEVERITY::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event INIT_DONE = MAKE_EVENT(11, SEVERITY::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event DUMP_FINISHED = MAKE_EVENT(12, SEVERITY::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FINISHED = MAKE_EVENT(13, SEVERITY::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FAILED = MAKE_EVENT(14, SEVERITY::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
+	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
+
+	virtual ~TmStoreBackendIF() {}
+
+	/**
+	 * What do I need to implement here ?
+	 * @param opCode
+	 * @return
+	 */
+	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
+	virtual ReturnValue_t initialize() = 0;
+
+	/**
+	 * Implement the storage of TM packets to mass memory
+	 * @param tmPacket
+	 * @return
+	 */
+	virtual ReturnValue_t storePacket(TmPacketMinimal* tmPacket) = 0;
+	virtual ReturnValue_t setFetchLimitTime(const timeval* loverLimit, const timeval* upperLimit) = 0;
+	virtual ReturnValue_t setFetchLimitBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
+	virtual ReturnValue_t fetchPackets(bool fromBegin = false) = 0;
+	virtual ReturnValue_t initializeStore(object_id_t dumpTarget) = 0;
+	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
+
+	/**
+	 * TODO: Adapt for file management system?
+	 * @param startAddress
+	 * @param endAddress
+	 * @return
+	 */
+	virtual ReturnValue_t deleteBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
+	virtual ReturnValue_t deleteTime(const timeval* timeUntil,
+				uint32_t* deletedPackets) = 0;
+	virtual void resetStore(bool clearStore, bool resetWrite, bool resetRead) = 0;
+	virtual bool isReady() = 0;
+	virtual uint32_t availableData() = 0;
+	virtual float getPercentageFilled() const = 0;
+	virtual uint32_t getStoredPacketsCount() const = 0;
+	virtual TmPacketInformation* getOldestPacket() = 0;
+	virtual TmPacketInformation* getYoungestPacket() = 0;
+	virtual float getDataRate() = 0;
+
+};
+
+
+
+#endif /* PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
diff --git a/tmstorage/TmStoreFrontendIF.h b/tmstorage/TmStoreFrontendIF.h
index 7d38cfc6b..7a2b3c9ed 100644
--- a/tmstorage/TmStoreFrontendIF.h
+++ b/tmstorage/TmStoreFrontendIF.h
@@ -1,63 +1,63 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tmstorage/TmStorePackets.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-class TmPacketMinimal;
-class SpacePacketBase;
-class TmStoreBackendIF;
-
-class TmStoreFrontendIF {
-public:
-	virtual TmStoreBackendIF* getBackend() const = 0;
-
-	/**
-	 * What do I need to implement here?
-	 * This is propably used by PUS Service 15 so we should propably check for messages..
-	 * Provide base implementation?
-	 * @param opCode
-	 * @return
-	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
-	/**
-	 * Callback from the back-end to indicate a certain packet was received.
-	 * front-end takes care of discarding/downloading the packet.
-	 * @param packet	Pointer to the newly received Space Packet.
-	 * @param address	Start address of the packet found
-	 * @param isLastPacket	Indicates if no more packets can be fetched.
-	 * @return	If more packets shall be fetched, RETURN_OK must be returned.
-	 * 			Any other code stops fetching packets.
-	 */
-	virtual ReturnValue_t packetRetrieved(TmPacketMinimal* packet, uint32_t address) = 0;
-	virtual void noMorePacketsInStore() = 0;
-	virtual void handleRetrievalFailed(ReturnValue_t errorCode, uint32_t parameter1 = 0, uint32_t parameter2 = 0) = 0;
-	/**
-	 * To get the queue where commands shall be sent.
-	 * @return	Id of command queue.
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ReturnValue_t fetchPackets(ApidSsc start, ApidSsc end) = 0;
-	virtual ReturnValue_t deletePackets(ApidSsc upTo) = 0;
-	virtual ReturnValue_t checkPacket(SpacePacketBase* tmPacket) = 0;
-	virtual bool isEnabled() const = 0;
-	virtual void setEnabled(bool enabled) = 0;
-	virtual void resetDownlinkedPacketCount() = 0;
-	virtual ReturnValue_t setDumpTarget(object_id_t dumpTarget) = 0;
-	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_FRONTEND_IF;
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LAST_PACKET_FOUND = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t STOP_FETCH = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TM_CHANNEL_FULL = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t NOT_STORED = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t ALL_DELETED = MAKE_RETURN_CODE(7);
-	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(8);
-	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(9);
-	virtual ~TmStoreFrontendIF() {
-	}
-};
-
-
-
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
+#ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+#define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tmstorage/TmStorePackets.h"
+#include "../ipc/MessageQueueSenderIF.h"
+class TmPacketMinimal;
+class SpacePacketBase;
+class TmStoreBackendIF;
+
+class TmStoreFrontendIF {
+public:
+	virtual TmStoreBackendIF* getBackend() const = 0;
+
+	/**
+	 * What do I need to implement here?
+	 * This is propably used by PUS Service 15 so we should propably check for messages..
+	 * Provide base implementation?
+	 * @param opCode
+	 * @return
+	 */
+	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
+	/**
+	 * Callback from the back-end to indicate a certain packet was received.
+	 * front-end takes care of discarding/downloading the packet.
+	 * @param packet	Pointer to the newly received Space Packet.
+	 * @param address	Start address of the packet found
+	 * @param isLastPacket	Indicates if no more packets can be fetched.
+	 * @return	If more packets shall be fetched, RETURN_OK must be returned.
+	 * 			Any other code stops fetching packets.
+	 */
+	virtual ReturnValue_t packetRetrieved(TmPacketMinimal* packet, uint32_t address) = 0;
+	virtual void noMorePacketsInStore() = 0;
+	virtual void handleRetrievalFailed(ReturnValue_t errorCode, uint32_t parameter1 = 0, uint32_t parameter2 = 0) = 0;
+	/**
+	 * To get the queue where commands shall be sent.
+	 * @return	Id of command queue.
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ReturnValue_t fetchPackets(ApidSsc start, ApidSsc end) = 0;
+	virtual ReturnValue_t deletePackets(ApidSsc upTo) = 0;
+	virtual ReturnValue_t checkPacket(SpacePacketBase* tmPacket) = 0;
+	virtual bool isEnabled() const = 0;
+	virtual void setEnabled(bool enabled) = 0;
+	virtual void resetDownlinkedPacketCount() = 0;
+	virtual ReturnValue_t setDumpTarget(object_id_t dumpTarget) = 0;
+	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_FRONTEND_IF;
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LAST_PACKET_FOUND = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t STOP_FETCH = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TM_CHANNEL_FULL = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t NOT_STORED = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t ALL_DELETED = MAKE_RETURN_CODE(7);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(8);
+	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(9);
+	virtual ~TmStoreFrontendIF() {
+	}
+};
+
+
+
+#endif /* PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp
index 669ecc0e7..0436442bc 100644
--- a/tmstorage/TmStoreMessage.cpp
+++ b/tmstorage/TmStoreMessage.cpp
@@ -1,165 +1,165 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tmstorage/TmStoreMessage.h>
-
-TmStoreMessage::~TmStoreMessage() {
-	
-}
-
-TmStoreMessage::TmStoreMessage() {
-}
-
-ReturnValue_t TmStoreMessage::setEnableStoringMessage(CommandMessage* cmd,
-		bool setEnabled) {
-	cmd->setCommand(ENABLE_STORING);
-	cmd->setParameter(setEnabled);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TmStoreMessage::setDeleteContentMessage(CommandMessage* cmd,
-		ApidSsc upTo) {
-	cmd->setCommand(DELETE_STORE_CONTENT);
-	cmd->setParameter((upTo.apid<<16) + upTo.ssc);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TmStoreMessage::setDownlinkContentMessage(CommandMessage* cmd,
-		ApidSsc fromPacket,
-		ApidSsc toPacket) {
-	cmd->setCommand(DOWNLINK_STORE_CONTENT);
-	cmd->setParameter((fromPacket.apid<<16) + fromPacket.ssc);
-	cmd->setParameter2((toPacket.apid<<16) + toPacket.ssc);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ApidSsc TmStoreMessage::getPacketId1(CommandMessage* cmd) {
-	ApidSsc temp;
-	temp.apid = (cmd->getParameter() >> 16) & 0xFFFF;
-	temp.ssc = cmd->getParameter() & 0xFFFF;
-	return temp;
-}
-
-ApidSsc TmStoreMessage::getPacketId2(CommandMessage* cmd) {
-	ApidSsc temp;
-	temp.apid = (cmd->getParameter2() >> 16) & 0xFFFF;
-	temp.ssc = cmd->getParameter2() & 0xFFFF;
-	return temp;
-}
-
-bool TmStoreMessage::getEnableStoring(CommandMessage* cmd) {
-	return (bool)cmd->getParameter();
-}
-
-void TmStoreMessage::setChangeSelectionDefinitionMessage(
-		CommandMessage* cmd, bool addDefinition, store_address_t store_id) {
-	cmd->setCommand(CHANGE_SELECTION_DEFINITION);
-	cmd->setParameter(addDefinition);
-	cmd->setParameter2(store_id.raw);
-}
-
-void TmStoreMessage::clear(CommandMessage* cmd) {
-	switch(cmd->getCommand()) {
-	case SELECTION_DEFINITION_REPORT:
-	case STORE_CATALOGUE_REPORT:
-	case CHANGE_SELECTION_DEFINITION:
-	case INDEX_REPORT:
-	case DELETE_STORE_CONTENT_TIME:
-	case DOWNLINK_STORE_CONTENT_TIME: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(cmd));
-		}
-	}
-	/* NO BREAK falls through*/
-	case DELETE_STORE_CONTENT_BLOCKS:
-	case DOWNLINK_STORE_CONTENT_BLOCKS:
-	case REPORT_INDEX_REQUEST:
-		cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
-		cmd->setParameter(0);
-		cmd->setParameter2(0);
-		break;
-	default:
-		break;
-	}
-}
-
-store_address_t TmStoreMessage::getStoreId(const CommandMessage* cmd) {
-	store_address_t temp;
-	temp.raw = cmd->getParameter2();
-	return temp;
-}
-
-bool TmStoreMessage::getAddToSelection(CommandMessage* cmd) {
-	return (bool)cmd->getParameter();
-}
-
-ReturnValue_t TmStoreMessage::setReportSelectionDefinitionMessage(
-		CommandMessage* cmd) {
-	cmd->setCommand(REPORT_SELECTION_DEFINITION);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TmStoreMessage::setSelectionDefinitionReportMessage(
-		CommandMessage* cmd, store_address_t storeId) {
-	cmd->setCommand(SELECTION_DEFINITION_REPORT);
-	cmd->setParameter2(storeId.raw);
-}
-
-ReturnValue_t TmStoreMessage::setReportStoreCatalogueMessage(
-		CommandMessage* cmd) {
-	cmd->setCommand(REPORT_STORE_CATALOGUE);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TmStoreMessage::setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
-		store_address_t storeId) {
-	cmd->setCommand(STORE_CATALOGUE_REPORT);
-	cmd->setParameter(objectId);
-	cmd->setParameter2(storeId.raw);
-}
-
-object_id_t TmStoreMessage::getObjectId(CommandMessage* cmd) {
-	return cmd->getParameter();
-}
-
-void TmStoreMessage::setDownlinkContentTimeMessage(CommandMessage* cmd,
-		store_address_t storeId) {
-	cmd->setCommand(DOWNLINK_STORE_CONTENT_TIME);
-	cmd->setParameter2(storeId.raw);
-}
-
-uint32_t TmStoreMessage::getAddressLow(CommandMessage* cmd){
-	return cmd->getParameter();
-}
-uint32_t TmStoreMessage::getAddressHigh(CommandMessage* cmd){
-	return cmd->getParameter2();
-}
-
-void TmStoreMessage::setDeleteContentTimeMessage(CommandMessage* cmd,
-		store_address_t storeId) {
-	cmd->setCommand(DELETE_STORE_CONTENT_TIME);
-	cmd->setParameter2(storeId.raw);
-}
-
-ReturnValue_t TmStoreMessage::setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
-	cmd->setCommand(DELETE_STORE_CONTENT_BLOCKS);
-	cmd->setParameter(addressLow);
-	cmd->setParameter2(addressHigh);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-ReturnValue_t TmStoreMessage::setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
-	cmd->setCommand(DOWNLINK_STORE_CONTENT_BLOCKS);
-	cmd->setParameter(addressLow);
-	cmd->setParameter2(addressHigh);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-ReturnValue_t TmStoreMessage::setIndexRequestMessage(CommandMessage* cmd){
-	cmd->setCommand(REPORT_INDEX_REQUEST);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-void TmStoreMessage::setIndexReportMessage(CommandMessage* cmd, store_address_t storeId){
-	cmd->setCommand(INDEX_REPORT);
-	cmd->setParameter2(storeId.raw);
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tmstorage/TmStoreMessage.h"
+
+TmStoreMessage::~TmStoreMessage() {
+	
+}
+
+TmStoreMessage::TmStoreMessage() {
+}
+
+ReturnValue_t TmStoreMessage::setEnableStoringMessage(CommandMessage* cmd,
+		bool setEnabled) {
+	cmd->setCommand(ENABLE_STORING);
+	cmd->setParameter(setEnabled);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmStoreMessage::setDeleteContentMessage(CommandMessage* cmd,
+		ApidSsc upTo) {
+	cmd->setCommand(DELETE_STORE_CONTENT);
+	cmd->setParameter((upTo.apid<<16) + upTo.ssc);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmStoreMessage::setDownlinkContentMessage(CommandMessage* cmd,
+		ApidSsc fromPacket,
+		ApidSsc toPacket) {
+	cmd->setCommand(DOWNLINK_STORE_CONTENT);
+	cmd->setParameter((fromPacket.apid<<16) + fromPacket.ssc);
+	cmd->setParameter2((toPacket.apid<<16) + toPacket.ssc);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ApidSsc TmStoreMessage::getPacketId1(CommandMessage* cmd) {
+	ApidSsc temp;
+	temp.apid = (cmd->getParameter() >> 16) & 0xFFFF;
+	temp.ssc = cmd->getParameter() & 0xFFFF;
+	return temp;
+}
+
+ApidSsc TmStoreMessage::getPacketId2(CommandMessage* cmd) {
+	ApidSsc temp;
+	temp.apid = (cmd->getParameter2() >> 16) & 0xFFFF;
+	temp.ssc = cmd->getParameter2() & 0xFFFF;
+	return temp;
+}
+
+bool TmStoreMessage::getEnableStoring(CommandMessage* cmd) {
+	return (bool)cmd->getParameter();
+}
+
+void TmStoreMessage::setChangeSelectionDefinitionMessage(
+		CommandMessage* cmd, bool addDefinition, store_address_t store_id) {
+	cmd->setCommand(CHANGE_SELECTION_DEFINITION);
+	cmd->setParameter(addDefinition);
+	cmd->setParameter2(store_id.raw);
+}
+
+void TmStoreMessage::clear(CommandMessage* cmd) {
+	switch(cmd->getCommand()) {
+	case SELECTION_DEFINITION_REPORT:
+	case STORE_CATALOGUE_REPORT:
+	case CHANGE_SELECTION_DEFINITION:
+	case INDEX_REPORT:
+	case DELETE_STORE_CONTENT_TIME:
+	case DOWNLINK_STORE_CONTENT_TIME: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(cmd));
+		}
+	}
+	/* NO BREAK falls through*/
+	case DELETE_STORE_CONTENT_BLOCKS:
+	case DOWNLINK_STORE_CONTENT_BLOCKS:
+	case REPORT_INDEX_REQUEST:
+		cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
+		cmd->setParameter(0);
+		cmd->setParameter2(0);
+		break;
+	default:
+		break;
+	}
+}
+
+store_address_t TmStoreMessage::getStoreId(const CommandMessage* cmd) {
+	store_address_t temp;
+	temp.raw = cmd->getParameter2();
+	return temp;
+}
+
+bool TmStoreMessage::getAddToSelection(CommandMessage* cmd) {
+	return (bool)cmd->getParameter();
+}
+
+ReturnValue_t TmStoreMessage::setReportSelectionDefinitionMessage(
+		CommandMessage* cmd) {
+	cmd->setCommand(REPORT_SELECTION_DEFINITION);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmStoreMessage::setSelectionDefinitionReportMessage(
+		CommandMessage* cmd, store_address_t storeId) {
+	cmd->setCommand(SELECTION_DEFINITION_REPORT);
+	cmd->setParameter2(storeId.raw);
+}
+
+ReturnValue_t TmStoreMessage::setReportStoreCatalogueMessage(
+		CommandMessage* cmd) {
+	cmd->setCommand(REPORT_STORE_CATALOGUE);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmStoreMessage::setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
+		store_address_t storeId) {
+	cmd->setCommand(STORE_CATALOGUE_REPORT);
+	cmd->setParameter(objectId);
+	cmd->setParameter2(storeId.raw);
+}
+
+object_id_t TmStoreMessage::getObjectId(CommandMessage* cmd) {
+	return cmd->getParameter();
+}
+
+void TmStoreMessage::setDownlinkContentTimeMessage(CommandMessage* cmd,
+		store_address_t storeId) {
+	cmd->setCommand(DOWNLINK_STORE_CONTENT_TIME);
+	cmd->setParameter2(storeId.raw);
+}
+
+uint32_t TmStoreMessage::getAddressLow(CommandMessage* cmd){
+	return cmd->getParameter();
+}
+uint32_t TmStoreMessage::getAddressHigh(CommandMessage* cmd){
+	return cmd->getParameter2();
+}
+
+void TmStoreMessage::setDeleteContentTimeMessage(CommandMessage* cmd,
+		store_address_t storeId) {
+	cmd->setCommand(DELETE_STORE_CONTENT_TIME);
+	cmd->setParameter2(storeId.raw);
+}
+
+ReturnValue_t TmStoreMessage::setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
+	cmd->setCommand(DELETE_STORE_CONTENT_BLOCKS);
+	cmd->setParameter(addressLow);
+	cmd->setParameter2(addressHigh);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+ReturnValue_t TmStoreMessage::setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
+	cmd->setCommand(DOWNLINK_STORE_CONTENT_BLOCKS);
+	cmd->setParameter(addressLow);
+	cmd->setParameter2(addressHigh);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+ReturnValue_t TmStoreMessage::setIndexRequestMessage(CommandMessage* cmd){
+	cmd->setCommand(REPORT_INDEX_REQUEST);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+void TmStoreMessage::setIndexReportMessage(CommandMessage* cmd, store_address_t storeId){
+	cmd->setCommand(INDEX_REPORT);
+	cmd->setParameter2(storeId.raw);
+}
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index 93c23e40b..ce10519b7 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -1,63 +1,63 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tmstorage/TmStorePackets.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-class TmStoreMessage  {
-public:
-	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
-			bool setEnabled);
-	static ReturnValue_t setDeleteContentMessage(CommandMessage* cmd,
-			ApidSsc upTo);
-	static ReturnValue_t setDownlinkContentMessage(CommandMessage* cmd,
-			ApidSsc fromPacket, ApidSsc toPacket);
-	static void setChangeSelectionDefinitionMessage(CommandMessage* cmd,
-			bool addDefinition, store_address_t store_id);
-	static ReturnValue_t setReportSelectionDefinitionMessage(
-			CommandMessage* cmd);
-	static void setSelectionDefinitionReportMessage(CommandMessage* cmd,
-			store_address_t storeId);
-	static ReturnValue_t setReportStoreCatalogueMessage(CommandMessage* cmd);
-	static void setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
-			store_address_t storeId);
-	static void setDownlinkContentTimeMessage(CommandMessage* cmd,
-			store_address_t storeId);
-	static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
-	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
-	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
-	static ReturnValue_t setIndexRequestMessage(CommandMessage* cmd);
-	static void setDeleteContentTimeMessage(CommandMessage* cmd,
-			store_address_t storeId);
-	static void clear(CommandMessage* cmd);
-	static object_id_t getObjectId(CommandMessage* cmd);
-	static ApidSsc getPacketId1(CommandMessage* cmd);
-	static ApidSsc getPacketId2(CommandMessage* cmd);
-	static bool getEnableStoring(CommandMessage* cmd);
-	static bool getAddToSelection(CommandMessage* cmd);
-	static uint32_t getAddressLow(CommandMessage* cmd);
-	static uint32_t getAddressHigh(CommandMessage* cmd);
-
-	static store_address_t getStoreId(const CommandMessage* cmd);
-	virtual ~TmStoreMessage();
-	static const uint8_t MESSAGE_ID = messagetypes::TM_STORE;
-	static const Command_t ENABLE_STORING = MAKE_COMMAND_ID(1);
-	static const Command_t DELETE_STORE_CONTENT = MAKE_COMMAND_ID(2);
-	static const Command_t DOWNLINK_STORE_CONTENT = MAKE_COMMAND_ID(3);
-	static const Command_t CHANGE_SELECTION_DEFINITION = MAKE_COMMAND_ID(4);
-	static const Command_t REPORT_SELECTION_DEFINITION = MAKE_COMMAND_ID(5);
-	static const Command_t SELECTION_DEFINITION_REPORT = MAKE_COMMAND_ID(6);
-	static const Command_t REPORT_STORE_CATALOGUE = MAKE_COMMAND_ID(7);
-	static const Command_t STORE_CATALOGUE_REPORT = MAKE_COMMAND_ID(8);
-	static const Command_t DOWNLINK_STORE_CONTENT_TIME = MAKE_COMMAND_ID(9);
-	static const Command_t DELETE_STORE_CONTENT_TIME = MAKE_COMMAND_ID(10);
-	static const Command_t DELETE_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(11);
-	static const Command_t DOWNLINK_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(12);
-	static const Command_t REPORT_INDEX_REQUEST = MAKE_COMMAND_ID(13);
-	static const Command_t INDEX_REPORT = MAKE_COMMAND_ID(14);
-private:
-	TmStoreMessage();
-};
-
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ */
+#ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
+#define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tmstorage/TmStorePackets.h"
+#include "../objectmanager/SystemObjectIF.h"
+class TmStoreMessage  {
+public:
+	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
+			bool setEnabled);
+	static ReturnValue_t setDeleteContentMessage(CommandMessage* cmd,
+			ApidSsc upTo);
+	static ReturnValue_t setDownlinkContentMessage(CommandMessage* cmd,
+			ApidSsc fromPacket, ApidSsc toPacket);
+	static void setChangeSelectionDefinitionMessage(CommandMessage* cmd,
+			bool addDefinition, store_address_t store_id);
+	static ReturnValue_t setReportSelectionDefinitionMessage(
+			CommandMessage* cmd);
+	static void setSelectionDefinitionReportMessage(CommandMessage* cmd,
+			store_address_t storeId);
+	static ReturnValue_t setReportStoreCatalogueMessage(CommandMessage* cmd);
+	static void setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
+			store_address_t storeId);
+	static void setDownlinkContentTimeMessage(CommandMessage* cmd,
+			store_address_t storeId);
+	static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
+	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setIndexRequestMessage(CommandMessage* cmd);
+	static void setDeleteContentTimeMessage(CommandMessage* cmd,
+			store_address_t storeId);
+	static void clear(CommandMessage* cmd);
+	static object_id_t getObjectId(CommandMessage* cmd);
+	static ApidSsc getPacketId1(CommandMessage* cmd);
+	static ApidSsc getPacketId2(CommandMessage* cmd);
+	static bool getEnableStoring(CommandMessage* cmd);
+	static bool getAddToSelection(CommandMessage* cmd);
+	static uint32_t getAddressLow(CommandMessage* cmd);
+	static uint32_t getAddressHigh(CommandMessage* cmd);
+
+	static store_address_t getStoreId(const CommandMessage* cmd);
+	virtual ~TmStoreMessage();
+	static const uint8_t MESSAGE_ID = messagetypes::TM_STORE;
+	static const Command_t ENABLE_STORING = MAKE_COMMAND_ID(1);
+	static const Command_t DELETE_STORE_CONTENT = MAKE_COMMAND_ID(2);
+	static const Command_t DOWNLINK_STORE_CONTENT = MAKE_COMMAND_ID(3);
+	static const Command_t CHANGE_SELECTION_DEFINITION = MAKE_COMMAND_ID(4);
+	static const Command_t REPORT_SELECTION_DEFINITION = MAKE_COMMAND_ID(5);
+	static const Command_t SELECTION_DEFINITION_REPORT = MAKE_COMMAND_ID(6);
+	static const Command_t REPORT_STORE_CATALOGUE = MAKE_COMMAND_ID(7);
+	static const Command_t STORE_CATALOGUE_REPORT = MAKE_COMMAND_ID(8);
+	static const Command_t DOWNLINK_STORE_CONTENT_TIME = MAKE_COMMAND_ID(9);
+	static const Command_t DELETE_STORE_CONTENT_TIME = MAKE_COMMAND_ID(10);
+	static const Command_t DELETE_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(11);
+	static const Command_t DOWNLINK_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(12);
+	static const Command_t REPORT_INDEX_REQUEST = MAKE_COMMAND_ID(13);
+	static const Command_t INDEX_REPORT = MAKE_COMMAND_ID(14);
+private:
+	TmStoreMessage();
+};
+
+#endif /* FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ */
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 9a669a7d2..3c8e1a24f 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -1,300 +1,300 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
-
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serialize/SerialBufferAdapter.h>
-#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
-#include <framework/timemanager/TimeStamperIF.h>
-#include <framework/timemanager/CCSDSTime.h>
-#include <framework/globalfunctions/timevalOperations.h>
-
-class ServiceSubservice: public SerialLinkedListAdapter<SerializeIF> {
-public:
-	SerializeElement<uint8_t> service;
-	SerialFixedArrayListAdapter<uint8_t, 16> subservices;
-	LinkedElement<SerializeIF> linkedSubservices;
-	ServiceSubservice() :
-			SerialLinkedListAdapter<SerializeIF>(&service), linkedSubservices(
-					&subservices) {
-		service.setNext(&linkedSubservices);
-	}
-};
-
-class ApidSsc: public SerializeIF {
-public:
-	ApidSsc() :
-			apid(SpacePacketBase::LIMIT_APID), ssc(0) {
-	}
-	ApidSsc(uint16_t apid, uint16_t ssc) :
-			apid(apid), ssc(ssc) {
-	}
-	uint16_t apid;
-	uint16_t ssc;
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&apid,
-				buffer, size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::serialize(&ssc, buffer, size,
-				maxSize, streamEndianness);
-
-	}
-
-	size_t getSerializedSize() const {
-		return sizeof(apid) + sizeof(ssc);
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
-				buffer, size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::deSerialize(&ssc, buffer, size,
-				streamEndianness);
-	}
-};
-
-class ChangeSelectionDefinition: public SerialLinkedListAdapter<SerializeIF> {
-public:
-	SerializeElement<uint16_t> apid;
-	SerialFixedArrayListAdapter<ServiceSubservice, 16> serviceList;
-	LinkedElement<SerializeIF> linkedServiceList;
-	ChangeSelectionDefinition() :
-			SerialLinkedListAdapter<SerializeIF>(&apid), linkedServiceList(
-					&serviceList) {
-		apid.setNext(&linkedServiceList);
-	}
-};
-
-class TmPacketInformation: public SerializeIF {
-public:
-	TmPacketInformation(TmPacketMinimal* packet){
-		setContent(packet);
-	}
-	TmPacketInformation() :apid(
-					SpacePacketBase::LIMIT_APID), sourceSequenceCount(0), serviceType(
-					0), serviceSubtype(0), subCounter(0) {
-	}
-	void reset() {
-		apid = SpacePacketBase::LIMIT_APID;
-		sourceSequenceCount = 0;
-		serviceType = 0;
-		serviceSubtype = 0;
-		subCounter = 0;
-		memset(rawTimestamp, 0, sizeof(rawTimestamp));
-	}
-	void setContent(TmPacketMinimal* packet) {
-		apid = packet->getAPID();
-		sourceSequenceCount = packet->getPacketSequenceCount();
-		serviceType = packet->getService();
-		serviceSubtype = packet->getSubService();
-		subCounter = packet->getPacketSubcounter();
-		memset(rawTimestamp, 0, sizeof(rawTimestamp));
-		const uint8_t* pField = NULL;
-		uint32_t size = 0;
-		ReturnValue_t result = packet->getPacketTimeRaw(&pField, &size);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		if (*pField == CCSDSTime::P_FIELD_CDS_SHORT
-				&& size <= TimeStamperIF::MISSION_TIMESTAMP_SIZE) {
-			//Shortcut to avoid converting CDS back and forth.
-			memcpy(rawTimestamp, pField, size);
-			return;
-		}
-		timeval time = { 0, 0 };
-		result = packet->getPacketTime(&time);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-
-		CCSDSTime::CDS_short cdsFormat;
-		result = CCSDSTime::convertToCcsds(&cdsFormat, &time);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		memcpy(rawTimestamp, &cdsFormat, sizeof(cdsFormat));
-	}
-	void setContent(TmPacketInformation* content) {
-		apid = content->apid;
-		sourceSequenceCount = content->sourceSequenceCount;
-		serviceType = content->serviceType;
-		serviceSubtype = content->serviceSubtype;
-		subCounter = content->subCounter;
-		memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
-	}
-	bool isValid() const {
-		return (apid < SpacePacketBase::LIMIT_APID) ? true : false;
-	}
-	static void reset(TmPacketInformation* packet){
-		packet->reset();
-	}
-
-	static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime){
-		if(packet->isValid()){
-			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
-			if(packetTime <= *cmpTime){
-				return true;
-			}
-		}
-		return false;
-	}
-
-	static bool isNewerThan(const TmPacketInformation* packet, const timeval* cmpTime){
-		if(packet->isValid()){
-			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
-			if(packetTime >= *cmpTime){
-				return true;
-			}
-		}
-		return false;
-	}
-
-	static bool isSmallerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
-		if(packet->isValid()){
-			if(packet->apid == compareSSC->apid){
-				if(packet->sourceSequenceCount <= compareSSC->ssc){
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
-	static bool isLargerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
-		if(packet->isValid()){
-			if(packet->apid == compareSSC->apid){
-				if(packet->sourceSequenceCount >= compareSSC->ssc){
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
-	uint16_t getApid() const{
-		return apid;
-	}
-
-	uint16_t getSsc() const{
-		return sourceSequenceCount;
-	}
-
-	uint8_t getServiceType() const{
-		return serviceType;
-	}
-
-	uint8_t getServiceSubtype() const{
-		return serviceSubtype;
-	}
-
-	uint8_t getSubCounter() const{
-		return subCounter;
-	}
-
-	timeval getTime() const {
-		timeval packetTime = {0,0};
-		uint32_t foundlen = 0;
-		CCSDSTime::convertFromCcsds(&packetTime,&this->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
-		return packetTime;
-	}
-
-	bool operator==(const TmPacketInformation& other) {
-		//TODO Does not compare Raw Timestamp
-		return ((apid == other.getApid())
-				&& (sourceSequenceCount == other.getSsc())
-				&& (serviceType == other.getServiceType()) && (serviceSubtype =
-						other.getServiceSubtype()));
-	}
-
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.serialize(buffer,size,maxSize,streamEndianness);
-	}
-
-	size_t getSerializedSize() const {
-		uint32_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&apid);
-		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
-		size += SerializeAdapter::getSerializedSize(&serviceType);
-		size += SerializeAdapter::getSerializedSize(&serviceSubtype);
-		size += SerializeAdapter::getSerializedSize(&subCounter);
-		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		size += adapter.getSerializedSize();
-		return size;
-
-	};
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
-				size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
-				size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
-				size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.deSerialize(buffer,size,streamEndianness);
-	}
-
-private:
-	uint16_t apid;
-	uint16_t sourceSequenceCount;
-	uint8_t serviceType;
-	uint8_t serviceSubtype;
-	uint8_t subCounter;
-	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
-
-};
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ */
+#ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
+#define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
+
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../serialize/SerialBufferAdapter.h"
+#include "../tmtcpacket/pus/TmPacketMinimal.h"
+#include "../timemanager/TimeStamperIF.h"
+#include "../timemanager/CCSDSTime.h"
+#include "../globalfunctions/timevalOperations.h"
+
+class ServiceSubservice: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	SerializeElement<uint8_t> service;
+	SerialFixedArrayListAdapter<uint8_t, 16> subservices;
+	LinkedElement<SerializeIF> linkedSubservices;
+	ServiceSubservice() :
+			SerialLinkedListAdapter<SerializeIF>(&service), linkedSubservices(
+					&subservices) {
+		service.setNext(&linkedSubservices);
+	}
+};
+
+class ApidSsc: public SerializeIF {
+public:
+	ApidSsc() :
+			apid(SpacePacketBase::LIMIT_APID), ssc(0) {
+	}
+	ApidSsc(uint16_t apid, uint16_t ssc) :
+			apid(apid), ssc(ssc) {
+	}
+	uint16_t apid;
+	uint16_t ssc;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,
+				buffer, size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::serialize(&ssc, buffer, size,
+				maxSize, streamEndianness);
+
+	}
+
+	size_t getSerializedSize() const {
+		return sizeof(apid) + sizeof(ssc);
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
+				buffer, size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::deSerialize(&ssc, buffer, size,
+				streamEndianness);
+	}
+};
+
+class ChangeSelectionDefinition: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	SerializeElement<uint16_t> apid;
+	SerialFixedArrayListAdapter<ServiceSubservice, 16> serviceList;
+	LinkedElement<SerializeIF> linkedServiceList;
+	ChangeSelectionDefinition() :
+			SerialLinkedListAdapter<SerializeIF>(&apid), linkedServiceList(
+					&serviceList) {
+		apid.setNext(&linkedServiceList);
+	}
+};
+
+class TmPacketInformation: public SerializeIF {
+public:
+	TmPacketInformation(TmPacketMinimal* packet){
+		setContent(packet);
+	}
+	TmPacketInformation() :apid(
+					SpacePacketBase::LIMIT_APID), sourceSequenceCount(0), serviceType(
+					0), serviceSubtype(0), subCounter(0) {
+	}
+	void reset() {
+		apid = SpacePacketBase::LIMIT_APID;
+		sourceSequenceCount = 0;
+		serviceType = 0;
+		serviceSubtype = 0;
+		subCounter = 0;
+		memset(rawTimestamp, 0, sizeof(rawTimestamp));
+	}
+	void setContent(TmPacketMinimal* packet) {
+		apid = packet->getAPID();
+		sourceSequenceCount = packet->getPacketSequenceCount();
+		serviceType = packet->getService();
+		serviceSubtype = packet->getSubService();
+		subCounter = packet->getPacketSubcounter();
+		memset(rawTimestamp, 0, sizeof(rawTimestamp));
+		const uint8_t* pField = NULL;
+		uint32_t size = 0;
+		ReturnValue_t result = packet->getPacketTimeRaw(&pField, &size);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		if (*pField == CCSDSTime::P_FIELD_CDS_SHORT
+				&& size <= TimeStamperIF::MISSION_TIMESTAMP_SIZE) {
+			//Shortcut to avoid converting CDS back and forth.
+			memcpy(rawTimestamp, pField, size);
+			return;
+		}
+		timeval time = { 0, 0 };
+		result = packet->getPacketTime(&time);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+
+		CCSDSTime::CDS_short cdsFormat;
+		result = CCSDSTime::convertToCcsds(&cdsFormat, &time);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		memcpy(rawTimestamp, &cdsFormat, sizeof(cdsFormat));
+	}
+	void setContent(TmPacketInformation* content) {
+		apid = content->apid;
+		sourceSequenceCount = content->sourceSequenceCount;
+		serviceType = content->serviceType;
+		serviceSubtype = content->serviceSubtype;
+		subCounter = content->subCounter;
+		memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
+	}
+	bool isValid() const {
+		return (apid < SpacePacketBase::LIMIT_APID) ? true : false;
+	}
+	static void reset(TmPacketInformation* packet){
+		packet->reset();
+	}
+
+	static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime){
+		if(packet->isValid()){
+			timeval packetTime = {0,0};
+			uint32_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			if(packetTime <= *cmpTime){
+				return true;
+			}
+		}
+		return false;
+	}
+
+	static bool isNewerThan(const TmPacketInformation* packet, const timeval* cmpTime){
+		if(packet->isValid()){
+			timeval packetTime = {0,0};
+			uint32_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			if(packetTime >= *cmpTime){
+				return true;
+			}
+		}
+		return false;
+	}
+
+	static bool isSmallerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
+		if(packet->isValid()){
+			if(packet->apid == compareSSC->apid){
+				if(packet->sourceSequenceCount <= compareSSC->ssc){
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	static bool isLargerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
+		if(packet->isValid()){
+			if(packet->apid == compareSSC->apid){
+				if(packet->sourceSequenceCount >= compareSSC->ssc){
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	uint16_t getApid() const{
+		return apid;
+	}
+
+	uint16_t getSsc() const{
+		return sourceSequenceCount;
+	}
+
+	uint8_t getServiceType() const{
+		return serviceType;
+	}
+
+	uint8_t getServiceSubtype() const{
+		return serviceSubtype;
+	}
+
+	uint8_t getSubCounter() const{
+		return subCounter;
+	}
+
+	timeval getTime() const {
+		timeval packetTime = {0,0};
+		uint32_t foundlen = 0;
+		CCSDSTime::convertFromCcsds(&packetTime,&this->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+		return packetTime;
+	}
+
+	bool operator==(const TmPacketInformation& other) {
+		//TODO Does not compare Raw Timestamp
+		return ((apid == other.getApid())
+				&& (sourceSequenceCount == other.getSsc())
+				&& (serviceType == other.getServiceType()) && (serviceSubtype =
+						other.getServiceSubtype()));
+	}
+
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
+		return adapter.serialize(buffer,size,maxSize,streamEndianness);
+	}
+
+	size_t getSerializedSize() const {
+		uint32_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&apid);
+		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
+		size += SerializeAdapter::getSerializedSize(&serviceType);
+		size += SerializeAdapter::getSerializedSize(&serviceSubtype);
+		size += SerializeAdapter::getSerializedSize(&subCounter);
+		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
+		size += adapter.getSerializedSize();
+		return size;
+
+	};
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
+				size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
+				size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
+				size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
+		return adapter.deSerialize(buffer,size,streamEndianness);
+	}
+
+private:
+	uint16_t apid;
+	uint16_t sourceSequenceCount;
+	uint8_t serviceType;
+	uint8_t serviceSubtype;
+	uint8_t subCounter;
+	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+
+};
+#endif /* FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ */
diff --git a/tmtcpacket/SpacePacket.cpp b/tmtcpacket/SpacePacket.cpp
index d9bc08fa6..c04e143fd 100644
--- a/tmtcpacket/SpacePacket.cpp
+++ b/tmtcpacket/SpacePacket.cpp
@@ -1,27 +1,27 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcpacket/ccsds_header.h>
-#include <framework/tmtcpacket/SpacePacket.h>
-#include <string.h>
-
-SpacePacket::SpacePacket( uint16_t packetDataLength, bool isTelecommand, uint16_t apid, uint16_t sequenceCount ):
-SpacePacketBase( (uint8_t*)&this->localData ) {
-	initSpacePacketHeader(isTelecommand, false, apid, sequenceCount);
-	this->setPacketSequenceCount(sequenceCount);
-	if ( packetDataLength <= sizeof(this->localData.fields.buffer) ) {
-		this->setPacketDataLength(packetDataLength);
-	} else {
-		this->setPacketDataLength( sizeof(this->localData.fields.buffer) );
-	}
-}
-
-SpacePacket::~SpacePacket( void ) {
-}
-
-bool SpacePacket::addWholeData( const uint8_t* p_Data, uint32_t packet_size ) {
-	if ( packet_size <= sizeof(this->data) ) {
-		memcpy( &this->localData.byteStream, p_Data, packet_size );
-		return true;
-	} else {
-		return false;
-	}
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcpacket/ccsds_header.h"
+#include "../tmtcpacket/SpacePacket.h"
+#include <string.h>
+
+SpacePacket::SpacePacket( uint16_t packetDataLength, bool isTelecommand, uint16_t apid, uint16_t sequenceCount ):
+SpacePacketBase( (uint8_t*)&this->localData ) {
+	initSpacePacketHeader(isTelecommand, false, apid, sequenceCount);
+	this->setPacketSequenceCount(sequenceCount);
+	if ( packetDataLength <= sizeof(this->localData.fields.buffer) ) {
+		this->setPacketDataLength(packetDataLength);
+	} else {
+		this->setPacketDataLength( sizeof(this->localData.fields.buffer) );
+	}
+}
+
+SpacePacket::~SpacePacket( void ) {
+}
+
+bool SpacePacket::addWholeData( const uint8_t* p_Data, uint32_t packet_size ) {
+	if ( packet_size <= sizeof(this->data) ) {
+		memcpy( &this->localData.byteStream, p_Data, packet_size );
+		return true;
+	} else {
+		return false;
+	}
+}
diff --git a/tmtcpacket/SpacePacket.h b/tmtcpacket/SpacePacket.h
index f2d457528..a75b9ae33 100644
--- a/tmtcpacket/SpacePacket.h
+++ b/tmtcpacket/SpacePacket.h
@@ -1,70 +1,70 @@
-#ifndef SPACEPACKET_H_
-#define SPACEPACKET_H_
-
-#include <framework/tmtcpacket/SpacePacketBase.h>
-
-/**
- * The SpacePacket class is a representation of a simple CCSDS Space Packet
- * without (control over) a secondary header.
- * It can be instantiated with a size smaller than \c PACKET_MAX_SIZE. Its
- * main use is to serve as an idle packet in case no other packets are sent.
- * For the ECSS PUS part the TcPacket and TmPacket classes are used.
- * A pointer to \c local_data is passed to the \c SpacePacketBase parent class,
- * so the parent's methods are reachable.
- * @ingroup tmtcpackets
- */
-class SpacePacket: public SpacePacketBase {
-public:
-	static const uint16_t PACKET_MAX_SIZE = 1024;
-	/**
-	 * The constructor initializes the packet and sets all header information
-	 * according to the passed parameters.
-	 * @param packetDataLength Sets the packet data length field and therefore specifies the size of the packet.
-	 * @param isTelecommand Sets the packet type field to either TC (true) or TM (false).
-	 * @param apid Sets the packet's APID field. The default value describes an idle packet.
-	 * @param sequenceCount ets the packet's Source Sequence Count field.
-	 */
-	SpacePacket(uint16_t packetDataLength, bool isTelecommand = false,
-			uint16_t apid = APID_IDLE_PACKET, uint16_t sequenceCount = 0);
-	/**
-	 * The class's default destructor.
-	 */
-	virtual ~SpacePacket();
-	/**
-	 * With this call, the complete data content (including the CCSDS Primary
-	 * Header) is overwritten with the byte stream given.
-	 * @param p_data		Pointer to data to overwrite the content with
-	 * @param packet_size	Size of the data
-	 * @return	@li	\c true if packet_size is smaller than \c MAX_PACKET_SIZE.
-	 * 			@li \c false else.
-	 */
-	bool addWholeData(const uint8_t* p_data, uint32_t packet_size);
-protected:
-	/**
-	 * This structure defines the data structure of a Space Packet as local data.
-	 * There's a buffer which corresponds to the Space Packet Data Field with a
-	 * maximum size of \c PACKET_MAX_SIZE.
-	 */
-	struct PacketStructured {
-		CCSDSPrimaryHeader header;
-		uint8_t buffer[PACKET_MAX_SIZE];
-	};
-	/**
-	 * This union simplifies accessing the full data content of the Space Packet.
-	 * This is achieved by putting the \c PacketStructured struct in a union with
-	 * a plain buffer.
-	 */
-	union SpacePacketData {
-		PacketStructured fields;
-		uint8_t byteStream[PACKET_MAX_SIZE + sizeof(CCSDSPrimaryHeader)];
-	};
-	/**
-	 * This is the data representation of the class.
-	 * It is a struct of CCSDS Primary Header and a data field, which again is
-	 * packed in an union, so the data can be accessed as a byte stream without
-	 * a cast.
-	 */
-	SpacePacketData localData;
-};
-
-#endif /* SPACEPACKET_H_ */
+#ifndef SPACEPACKET_H_
+#define SPACEPACKET_H_
+
+#include "../tmtcpacket/SpacePacketBase.h"
+
+/**
+ * The SpacePacket class is a representation of a simple CCSDS Space Packet
+ * without (control over) a secondary header.
+ * It can be instantiated with a size smaller than \c PACKET_MAX_SIZE. Its
+ * main use is to serve as an idle packet in case no other packets are sent.
+ * For the ECSS PUS part the TcPacket and TmPacket classes are used.
+ * A pointer to \c local_data is passed to the \c SpacePacketBase parent class,
+ * so the parent's methods are reachable.
+ * @ingroup tmtcpackets
+ */
+class SpacePacket: public SpacePacketBase {
+public:
+	static const uint16_t PACKET_MAX_SIZE = 1024;
+	/**
+	 * The constructor initializes the packet and sets all header information
+	 * according to the passed parameters.
+	 * @param packetDataLength Sets the packet data length field and therefore specifies the size of the packet.
+	 * @param isTelecommand Sets the packet type field to either TC (true) or TM (false).
+	 * @param apid Sets the packet's APID field. The default value describes an idle packet.
+	 * @param sequenceCount ets the packet's Source Sequence Count field.
+	 */
+	SpacePacket(uint16_t packetDataLength, bool isTelecommand = false,
+			uint16_t apid = APID_IDLE_PACKET, uint16_t sequenceCount = 0);
+	/**
+	 * The class's default destructor.
+	 */
+	virtual ~SpacePacket();
+	/**
+	 * With this call, the complete data content (including the CCSDS Primary
+	 * Header) is overwritten with the byte stream given.
+	 * @param p_data		Pointer to data to overwrite the content with
+	 * @param packet_size	Size of the data
+	 * @return	@li	\c true if packet_size is smaller than \c MAX_PACKET_SIZE.
+	 * 			@li \c false else.
+	 */
+	bool addWholeData(const uint8_t* p_data, uint32_t packet_size);
+protected:
+	/**
+	 * This structure defines the data structure of a Space Packet as local data.
+	 * There's a buffer which corresponds to the Space Packet Data Field with a
+	 * maximum size of \c PACKET_MAX_SIZE.
+	 */
+	struct PacketStructured {
+		CCSDSPrimaryHeader header;
+		uint8_t buffer[PACKET_MAX_SIZE];
+	};
+	/**
+	 * This union simplifies accessing the full data content of the Space Packet.
+	 * This is achieved by putting the \c PacketStructured struct in a union with
+	 * a plain buffer.
+	 */
+	union SpacePacketData {
+		PacketStructured fields;
+		uint8_t byteStream[PACKET_MAX_SIZE + sizeof(CCSDSPrimaryHeader)];
+	};
+	/**
+	 * This is the data representation of the class.
+	 * It is a struct of CCSDS Primary Header and a data field, which again is
+	 * packed in an union, so the data can be accessed as a byte stream without
+	 * a cast.
+	 */
+	SpacePacketData localData;
+};
+
+#endif /* SPACEPACKET_H_ */
diff --git a/tmtcpacket/SpacePacketBase.cpp b/tmtcpacket/SpacePacketBase.cpp
index b9ae06843..3d3a51e34 100644
--- a/tmtcpacket/SpacePacketBase.cpp
+++ b/tmtcpacket/SpacePacketBase.cpp
@@ -1,104 +1,104 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcpacket/SpacePacketBase.h>
-#include <string.h>
-
-SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) {
-	this->data = (SpacePacketPointer*) set_address;
-}
-
-SpacePacketBase::~SpacePacketBase() {
-};
-
-//CCSDS Methods:
-uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
-	return (this->data->header.packet_id_h & 0b11100000) >> 5;
-}
-
-void SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
-		bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
-	//reset header to zero:
-	memset(data,0, sizeof(this->data->header) );
-	//Set TC/TM bit.
-	data->header.packet_id_h = ((isTelecommand? 1 : 0)) << 4;
-	//Set secondaryHeader bit
-	data->header.packet_id_h |= ((hasSecondaryHeader? 1 : 0)) << 3;
-	this->setAPID( apid );
-	//Always initialize as standalone packets.
-	data->header.sequence_control_h = 0b11000000;
-	setPacketSequenceCount(sequenceCount);
-
-}
-
-bool SpacePacketBase::isTelecommand( void ) {
-	return (this->data->header.packet_id_h & 0b00010000) >> 4;
-}
-
-bool SpacePacketBase::hasSecondaryHeader( void ) {
-	return (this->data->header.packet_id_h & 0b00001000) >> 3;
-}
-
-uint16_t SpacePacketBase::getPacketId() {
-	return ( (this->data->header.packet_id_h) << 8 ) +
-			this->data->header.packet_id_l;
-}
-
-uint16_t SpacePacketBase::getAPID( void ) const {
-	return ( (this->data->header.packet_id_h & 0b00000111) << 8 ) +
-			this->data->header.packet_id_l;
-}
-
-void SpacePacketBase::setAPID( uint16_t new_apid ) {
-	//Use first three bits of new APID, but keep rest of packet id as it was (see specification).
-	this->data->header.packet_id_h = (this->data->header.packet_id_h & 0b11111000) | ( ( new_apid & 0x0700 ) >> 8 );
-	this->data->header.packet_id_l = ( new_apid & 0x00FF );
-}
-
-uint16_t SpacePacketBase::getPacketSequenceControl( void ) {
-	return ( (this->data->header.sequence_control_h) << 8 )
-		+ this->data->header.sequence_control_l;
-}
-
-uint8_t SpacePacketBase::getSequenceFlags( void ) {
-	return (this->data->header.sequence_control_h & 0b11000000) >> 6 ;
-}
-
-uint16_t SpacePacketBase::getPacketSequenceCount( void ) const {
-	return ( (this->data->header.sequence_control_h & 0b00111111) << 8 )
-		+ this->data->header.sequence_control_l;
-}
-
-void SpacePacketBase::setPacketSequenceCount( uint16_t new_count) {
-	this->data->header.sequence_control_h = ( this->data->header.sequence_control_h & 0b11000000 ) | ( ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x3F00 ) >> 8 );
-	this->data->header.sequence_control_l = ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x00FF );
-}
-
-uint16_t SpacePacketBase::getPacketDataLength( void ) {
-	return ( (this->data->header.packet_length_h) << 8 )
-		+ this->data->header.packet_length_l;
-}
-
-void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
-	this->data->header.packet_length_h = ( ( new_length & 0xFF00 ) >> 8 );
-	this->data->header.packet_length_l = ( new_length & 0x00FF );
-}
-
-size_t SpacePacketBase::getFullSize() {
-	//+1 is done because size in packet data length field is: size of data field -1
-	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
-}
-
-uint8_t* SpacePacketBase::getWholeData() {
-	return (uint8_t*)this->data;
-}
-
-void SpacePacketBase::setData( const uint8_t* p_Data ) {
-	this->data = (SpacePacketPointer*)p_Data;
-}
-
-uint32_t SpacePacketBase::getApidAndSequenceCount() const {
-	return (getAPID() << 16) + getPacketSequenceCount();
-}
-
-uint8_t* SpacePacketBase::getPacketData() {
-	return &(data->packet_data);
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcpacket/SpacePacketBase.h"
+#include <string.h>
+
+SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) {
+	this->data = (SpacePacketPointer*) set_address;
+}
+
+SpacePacketBase::~SpacePacketBase() {
+};
+
+//CCSDS Methods:
+uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
+	return (this->data->header.packet_id_h & 0b11100000) >> 5;
+}
+
+void SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
+		bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
+	//reset header to zero:
+	memset(data,0, sizeof(this->data->header) );
+	//Set TC/TM bit.
+	data->header.packet_id_h = ((isTelecommand? 1 : 0)) << 4;
+	//Set secondaryHeader bit
+	data->header.packet_id_h |= ((hasSecondaryHeader? 1 : 0)) << 3;
+	this->setAPID( apid );
+	//Always initialize as standalone packets.
+	data->header.sequence_control_h = 0b11000000;
+	setPacketSequenceCount(sequenceCount);
+
+}
+
+bool SpacePacketBase::isTelecommand( void ) {
+	return (this->data->header.packet_id_h & 0b00010000) >> 4;
+}
+
+bool SpacePacketBase::hasSecondaryHeader( void ) {
+	return (this->data->header.packet_id_h & 0b00001000) >> 3;
+}
+
+uint16_t SpacePacketBase::getPacketId() {
+	return ( (this->data->header.packet_id_h) << 8 ) +
+			this->data->header.packet_id_l;
+}
+
+uint16_t SpacePacketBase::getAPID( void ) const {
+	return ( (this->data->header.packet_id_h & 0b00000111) << 8 ) +
+			this->data->header.packet_id_l;
+}
+
+void SpacePacketBase::setAPID( uint16_t new_apid ) {
+	//Use first three bits of new APID, but keep rest of packet id as it was (see specification).
+	this->data->header.packet_id_h = (this->data->header.packet_id_h & 0b11111000) | ( ( new_apid & 0x0700 ) >> 8 );
+	this->data->header.packet_id_l = ( new_apid & 0x00FF );
+}
+
+uint16_t SpacePacketBase::getPacketSequenceControl( void ) {
+	return ( (this->data->header.sequence_control_h) << 8 )
+		+ this->data->header.sequence_control_l;
+}
+
+uint8_t SpacePacketBase::getSequenceFlags( void ) {
+	return (this->data->header.sequence_control_h & 0b11000000) >> 6 ;
+}
+
+uint16_t SpacePacketBase::getPacketSequenceCount( void ) const {
+	return ( (this->data->header.sequence_control_h & 0b00111111) << 8 )
+		+ this->data->header.sequence_control_l;
+}
+
+void SpacePacketBase::setPacketSequenceCount( uint16_t new_count) {
+	this->data->header.sequence_control_h = ( this->data->header.sequence_control_h & 0b11000000 ) | ( ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x3F00 ) >> 8 );
+	this->data->header.sequence_control_l = ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x00FF );
+}
+
+uint16_t SpacePacketBase::getPacketDataLength( void ) {
+	return ( (this->data->header.packet_length_h) << 8 )
+		+ this->data->header.packet_length_l;
+}
+
+void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
+	this->data->header.packet_length_h = ( ( new_length & 0xFF00 ) >> 8 );
+	this->data->header.packet_length_l = ( new_length & 0x00FF );
+}
+
+size_t SpacePacketBase::getFullSize() {
+	//+1 is done because size in packet data length field is: size of data field -1
+	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
+}
+
+uint8_t* SpacePacketBase::getWholeData() {
+	return (uint8_t*)this->data;
+}
+
+void SpacePacketBase::setData( const uint8_t* p_Data ) {
+	this->data = (SpacePacketPointer*)p_Data;
+}
+
+uint32_t SpacePacketBase::getApidAndSequenceCount() const {
+	return (getAPID() << 16) + getPacketSequenceCount();
+}
+
+uint8_t* SpacePacketBase::getPacketData() {
+	return &(data->packet_data);
+}
diff --git a/tmtcpacket/SpacePacketBase.h b/tmtcpacket/SpacePacketBase.h
index 57a5df9c8..a132bfd16 100644
--- a/tmtcpacket/SpacePacketBase.h
+++ b/tmtcpacket/SpacePacketBase.h
@@ -1,177 +1,177 @@
-#ifndef SPACEPACKETBASE_H_
-#define SPACEPACKETBASE_H_
-
-#include <framework/tmtcpacket/ccsds_header.h>
-#include <cstddef>
-
-/**
- * @defgroup tmtcpackets Space Packets
- * This is the group, where all classes associated with Telecommand and
- * Telemetry packets belong to.
- * The class hierarchy resembles the dependency between the different standards
- * applied, namely the CCSDS Space Packet standard and the ECCSS Packet
- * Utilization Standard. Most field and structure names are taken from these
- * standards.
- */
-
-/**
- * This struct defines the data structure of a Space Packet when accessed
- * via a pointer.
- * @ingroup tmtcpackets
- */
-struct SpacePacketPointer {
-	CCSDSPrimaryHeader header;
-	uint8_t packet_data;
-};
-
-/**
- * This class is the basic data handler for any CCSDS Space Packet
- * compatible Telecommand and Telemetry packet.
- * It does not contain the packet data itself but a pointer to the
- * data must be set on instantiation. An invalid pointer may cause
- * damage, as no getter method checks data validity. Anyway, a NULL
- * check can be performed by making use of the getWholeData method.
- * Remark: All bit numbers in this documentation are counted from
- * the most significant bit (from left).
- * @ingroup tmtcpackets
- */
-class SpacePacketBase {
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet header.
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	SpacePacketPointer* data;
-public:
-	static const uint16_t LIMIT_APID = 2048; //2^1
-	static const uint16_t LIMIT_SEQUENCE_COUNT = 16384; // 2^14
-	static const uint16_t APID_IDLE_PACKET = 0x7FF;
-	static const uint8_t TELECOMMAND_PACKET = 1;
-	static const uint8_t TELEMETRY_PACKET = 0;
-	/**
-	 * This definition defines the CRC size in byte.
-	 */
-	static const uint8_t CRC_SIZE = 2;
-	/**
-	 * This is the minimum size of a SpacePacket.
-	 */
-	static const uint16_t MINIMUM_SIZE = sizeof(CCSDSPrimaryHeader) + CRC_SIZE;
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	SpacePacketBase( const uint8_t* set_address );
-	/**
-	 * No data is allocated, so the destructor is empty.
-	 */
-	virtual ~SpacePacketBase();
-
-	//CCSDS Methods:
-	/**
-	 * Getter for the packet version number field.
-	 * @return Returns the highest three bit of the packet in one byte.
-	 */
-	uint8_t getPacketVersionNumber( void );
-	/**
-	 * This method checks the type field in the header.
-	 * This bit specifies, if the command is interpreted as Telecommand of
-	 * as Telemetry. For a Telecommand, the bit is set.
-	 * @return Returns true if the bit is set and false if not.
-	 */
-	bool isTelecommand( void );
-
-	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount = 0);
-	/**
-	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
-	 *  which is checked with this method.
-	 * @return	Returns true if the bit is set and false if not.
-	 */
-	bool hasSecondaryHeader( void );
-	/**
-	 * Returns the complete first two bytes of the packet, which together form
-	 * the CCSDS packet id.
-	 * @return	The CCSDS packet id.
-	 */
-	uint16_t getPacketId( void );
-	/**
-	 * Returns the APID of a packet, which are the lowest 11 bit of the packet
-	 * id.
-	 * @return The CCSDS APID.
-	 */
-	uint16_t getAPID( void ) const;
-	/**
-	 * Sets the APID of a packet, which are the lowest 11 bit of the packet
-	 * id.
-	 * @param 	The APID to set. The highest five bits of the parameter are
-	 * 			ignored.
-	 */
-	void setAPID( uint16_t setAPID );
-	/**
-	 * Returns the CCSDS packet sequence control field, which are the third and
-	 * the fourth byte of the CCSDS primary header.
-	 * @return The CCSDS packet sequence control field.
-	 */
-	uint16_t getPacketSequenceControl( void );
-	/**
-	 * Returns the SequenceFlags, which are the highest two bit of the packet
-	 * sequence control field.
-	 * @return	The CCSDS sequence flags.
-	 */
-	uint8_t getSequenceFlags( void );
-	/**
-	 * Returns the packet sequence count, which are the lowest 14 bit of the
-	 * packet sequence control field.
-	 * @return The CCSDS sequence count.
-	 */
-	uint16_t getPacketSequenceCount( void ) const;
-	/**
-	 * Sets the packet sequence count, which are the lowest 14 bit of the
-	 * packet sequence control field.
-	 * setCount is modulo-divided by \c LIMIT_SEQUENCE_COUNT to avoid overflows.
-	 * @param setCount	The value to set the count to.
-	 */
-	void setPacketSequenceCount( uint16_t setCount );
-	/**
-	 * Returns the packet data length, which is the fifth and sixth byte of the
-	 * CCSDS Primary Header. The packet data length is the size of every kind
-	 * of data \b after the CCSDS Primary Header \b -1.
-	 * @return The CCSDS packet data length.
-	 */
-	uint16_t getPacketDataLength( void ); //uint16_t is sufficient, because this is limit in CCSDS standard
-	/**
-	 * Sets the packet data length, which is the fifth and sixth byte of the
-	 * CCSDS Primary Header.
-	 * @param setLength The value of the length to set. It must fit the true
-	 * 					CCSDS packet data length . The packet data length is
-	 * 					the size of every kind of data \b after the CCSDS
-	 * 					Primary Header \b -1.
-	 */
-	void setPacketDataLength( uint16_t setLength );
-
-	//Helper methods:
-	/**
-	 * This method returns a raw uint8_t pointer to the packet.
-	 * @return	A \c uint8_t pointer to the first byte of the CCSDS primary header.
-	 */
-	virtual uint8_t* getWholeData( void );
-
-	uint8_t* getPacketData();
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 * @param p_Data A pointer to another raw Space Packet.
-	 */
-	virtual void setData( const uint8_t* p_Data );
-	/**
-	 * This method returns the full raw packet size.
-	 * @return	The full size of the packet in bytes.
-	 */
-	size_t getFullSize();
-
-	uint32_t getApidAndSequenceCount() const;
-
-};
-
-#endif /* SPACEPACKETBASE_H_ */
+#ifndef SPACEPACKETBASE_H_
+#define SPACEPACKETBASE_H_
+
+#include "../tmtcpacket/ccsds_header.h"
+#include <cstddef>
+
+/**
+ * @defgroup tmtcpackets Space Packets
+ * This is the group, where all classes associated with Telecommand and
+ * Telemetry packets belong to.
+ * The class hierarchy resembles the dependency between the different standards
+ * applied, namely the CCSDS Space Packet standard and the ECCSS Packet
+ * Utilization Standard. Most field and structure names are taken from these
+ * standards.
+ */
+
+/**
+ * This struct defines the data structure of a Space Packet when accessed
+ * via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct SpacePacketPointer {
+	CCSDSPrimaryHeader header;
+	uint8_t packet_data;
+};
+
+/**
+ * This class is the basic data handler for any CCSDS Space Packet
+ * compatible Telecommand and Telemetry packet.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * Remark: All bit numbers in this documentation are counted from
+ * the most significant bit (from left).
+ * @ingroup tmtcpackets
+ */
+class SpacePacketBase {
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet header.
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	SpacePacketPointer* data;
+public:
+	static const uint16_t LIMIT_APID = 2048; //2^1
+	static const uint16_t LIMIT_SEQUENCE_COUNT = 16384; // 2^14
+	static const uint16_t APID_IDLE_PACKET = 0x7FF;
+	static const uint8_t TELECOMMAND_PACKET = 1;
+	static const uint8_t TELEMETRY_PACKET = 0;
+	/**
+	 * This definition defines the CRC size in byte.
+	 */
+	static const uint8_t CRC_SIZE = 2;
+	/**
+	 * This is the minimum size of a SpacePacket.
+	 */
+	static const uint16_t MINIMUM_SIZE = sizeof(CCSDSPrimaryHeader) + CRC_SIZE;
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	SpacePacketBase( const uint8_t* set_address );
+	/**
+	 * No data is allocated, so the destructor is empty.
+	 */
+	virtual ~SpacePacketBase();
+
+	//CCSDS Methods:
+	/**
+	 * Getter for the packet version number field.
+	 * @return Returns the highest three bit of the packet in one byte.
+	 */
+	uint8_t getPacketVersionNumber( void );
+	/**
+	 * This method checks the type field in the header.
+	 * This bit specifies, if the command is interpreted as Telecommand of
+	 * as Telemetry. For a Telecommand, the bit is set.
+	 * @return Returns true if the bit is set and false if not.
+	 */
+	bool isTelecommand( void );
+
+	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount = 0);
+	/**
+	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
+	 *  which is checked with this method.
+	 * @return	Returns true if the bit is set and false if not.
+	 */
+	bool hasSecondaryHeader( void );
+	/**
+	 * Returns the complete first two bytes of the packet, which together form
+	 * the CCSDS packet id.
+	 * @return	The CCSDS packet id.
+	 */
+	uint16_t getPacketId( void );
+	/**
+	 * Returns the APID of a packet, which are the lowest 11 bit of the packet
+	 * id.
+	 * @return The CCSDS APID.
+	 */
+	uint16_t getAPID( void ) const;
+	/**
+	 * Sets the APID of a packet, which are the lowest 11 bit of the packet
+	 * id.
+	 * @param 	The APID to set. The highest five bits of the parameter are
+	 * 			ignored.
+	 */
+	void setAPID( uint16_t setAPID );
+	/**
+	 * Returns the CCSDS packet sequence control field, which are the third and
+	 * the fourth byte of the CCSDS primary header.
+	 * @return The CCSDS packet sequence control field.
+	 */
+	uint16_t getPacketSequenceControl( void );
+	/**
+	 * Returns the SequenceFlags, which are the highest two bit of the packet
+	 * sequence control field.
+	 * @return	The CCSDS sequence flags.
+	 */
+	uint8_t getSequenceFlags( void );
+	/**
+	 * Returns the packet sequence count, which are the lowest 14 bit of the
+	 * packet sequence control field.
+	 * @return The CCSDS sequence count.
+	 */
+	uint16_t getPacketSequenceCount( void ) const;
+	/**
+	 * Sets the packet sequence count, which are the lowest 14 bit of the
+	 * packet sequence control field.
+	 * setCount is modulo-divided by \c LIMIT_SEQUENCE_COUNT to avoid overflows.
+	 * @param setCount	The value to set the count to.
+	 */
+	void setPacketSequenceCount( uint16_t setCount );
+	/**
+	 * Returns the packet data length, which is the fifth and sixth byte of the
+	 * CCSDS Primary Header. The packet data length is the size of every kind
+	 * of data \b after the CCSDS Primary Header \b -1.
+	 * @return The CCSDS packet data length.
+	 */
+	uint16_t getPacketDataLength( void ); //uint16_t is sufficient, because this is limit in CCSDS standard
+	/**
+	 * Sets the packet data length, which is the fifth and sixth byte of the
+	 * CCSDS Primary Header.
+	 * @param setLength The value of the length to set. It must fit the true
+	 * 					CCSDS packet data length . The packet data length is
+	 * 					the size of every kind of data \b after the CCSDS
+	 * 					Primary Header \b -1.
+	 */
+	void setPacketDataLength( uint16_t setLength );
+
+	//Helper methods:
+	/**
+	 * This method returns a raw uint8_t pointer to the packet.
+	 * @return	A \c uint8_t pointer to the first byte of the CCSDS primary header.
+	 */
+	virtual uint8_t* getWholeData( void );
+
+	uint8_t* getPacketData();
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 * @param p_Data A pointer to another raw Space Packet.
+	 */
+	virtual void setData( const uint8_t* p_Data );
+	/**
+	 * This method returns the full raw packet size.
+	 * @return	The full size of the packet in bytes.
+	 */
+	size_t getFullSize();
+
+	uint32_t getApidAndSequenceCount() const;
+
+};
+
+#endif /* SPACEPACKETBASE_H_ */
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 3080ffef8..7b1b89ff6 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -1,40 +1,40 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
-
-#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
-
-class ApidMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
-private:
-	uint16_t apid;
-public:
-	ApidMatcher(uint16_t setApid) :
-			apid(setApid) {
-	}
-	ApidMatcher(TmPacketMinimal* test) :
-			apid(test->getAPID()) {
-	}
-	bool match(TmPacketMinimal* packet) {
-		if (packet->getAPID() == apid) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&apid);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
-	}
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class ApidMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+private:
+	uint16_t apid;
+public:
+	ApidMatcher(uint16_t setApid) :
+			apid(setApid) {
+	}
+	ApidMatcher(TmPacketMinimal* test) :
+			apid(test->getAPID()) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getAPID() == apid) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&apid);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
+	}
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_ */
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.cpp b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
index d8f61ffb8..356467dca 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.cpp
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
@@ -1,195 +1,195 @@
-#include <framework/tmtcpacket/packetmatcher/ApidMatcher.h>
-#include <framework/tmtcpacket/packetmatcher/PacketMatchTree.h>
-#include <framework/tmtcpacket/packetmatcher/ServiceMatcher.h>
-#include <framework/tmtcpacket/packetmatcher/SubserviceMatcher.h>
-
-PacketMatchTree::PacketMatchTree(Node* root) :
-		MatchTree<TmPacketMinimal*>(root, 2), factoryBackend(0, POOL_SIZES,
-				N_ELEMENTS, false, true), factory(&factoryBackend) {
-}
-
-PacketMatchTree::PacketMatchTree(iterator root) :
-		MatchTree<TmPacketMinimal*>(root.element, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
-}
-
-PacketMatchTree::PacketMatchTree() :
-		MatchTree<TmPacketMinimal*>((Node*) NULL, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
-}
-
-PacketMatchTree::~PacketMatchTree() {
-}
-
-ReturnValue_t PacketMatchTree::addMatch(uint16_t apid, uint8_t type,
-		uint8_t subtype) {
-	//We assume adding APID is always requested.
-	TmPacketMinimal::TmPacketMinimalPointer data;
-	data.data_field.service_type = type;
-	data.data_field.service_subtype = subtype;
-	TmPacketMinimal testPacket((uint8_t*) &data);
-	testPacket.setAPID(apid);
-	iterator lastTest;
-	iterator rollback;
-	ReturnValue_t result = findOrInsertMatch<TmPacketMinimal*, ApidMatcher>(
-			this->begin(), &testPacket, &lastTest);
-	if (result == NEW_NODE_CREATED) {
-		rollback = lastTest;
-	} else if (result != RETURN_OK) {
-		return result;
-	}
-	if (type == 0) {
-		//Check if lastTest has no children, otherwise, delete them,
-		//as a more general check is requested.
-		if (lastTest.left() != this->end()) {
-			removeElementAndAllChildren(lastTest.left());
-		}
-		return RETURN_OK;
-	}
-	//Type insertion required.
-	result = findOrInsertMatch<TmPacketMinimal*, ServiceMatcher>(
-			lastTest.left(), &testPacket, &lastTest);
-	if (result == NEW_NODE_CREATED) {
-		if  (rollback == this->end()) {
-			rollback = lastTest;
-		}
-	} else if (result != RETURN_OK) {
-		if (rollback != this->end()) {
-			removeElementAndAllChildren(rollback);
-		}
-		return result;
-	}
-	if (subtype == 0) {
-		if (lastTest.left() != this->end()) {
-			//See above
-			removeElementAndAllChildren(lastTest.left());
-		}
-		return RETURN_OK;
-	}
-	//Subtype insertion required.
-	result = findOrInsertMatch<TmPacketMinimal*, SubServiceMatcher>(
-			lastTest.left(), &testPacket, &lastTest);
-	if (result == NEW_NODE_CREATED) {
-		return RETURN_OK;
-	} else if (result != RETURN_OK) {
-		if (rollback != this->end()) {
-			removeElementAndAllChildren(rollback);
-		}
-		return result;
-	}
-	return RETURN_OK;
-}
-
-template<typename VALUE_T, typename INSERTION_T>
-ReturnValue_t PacketMatchTree::findOrInsertMatch(iterator startAt, VALUE_T test,
-		iterator* lastTest) {
-	bool attachToBranch = AND;
-	iterator iter = startAt;
-	while (iter != this->end()) {
-		bool isMatch = iter->match(test);
-		attachToBranch = OR;
-		*lastTest = iter;
-		if (isMatch) {
-			return RETURN_OK;
-		} else {
-			//Go down OR branch.
-			iter = iter.right();
-		}
-	}
-	//Only reached if nothing was found.
-	SerializeableMatcherIF<VALUE_T>* newContent = factory.generate<INSERTION_T>(
-			test);
-	if (newContent == NULL) {
-		return FULL;
-	}
-	Node* newNode = factory.generate<Node>(newContent);
-	if (newNode == NULL) {
-		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
-		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
-		return FULL;
-	}
-	*lastTest = insert(attachToBranch, *lastTest, newNode);
-	if (*lastTest == end()) {
-		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
-		return RETURN_FAILED;
-	}
-	return NEW_NODE_CREATED;
-}
-
-ReturnValue_t PacketMatchTree::removeMatch(uint16_t apid, uint8_t type,
-		uint8_t subtype) {
-	TmPacketMinimal::TmPacketMinimalPointer data;
-	data.data_field.service_type = type;
-	data.data_field.service_subtype = subtype;
-	TmPacketMinimal testPacket((uint8_t*) &data);
-	testPacket.setAPID(apid);
-	iterator foundElement = findMatch(begin(), &testPacket);
-	if (foundElement == this->end()) {
-		return NO_MATCH;
-	}
-	if (type == 0) {
-		if (foundElement.left() == end()) {
-			return removeElementAndReconnectChildren(foundElement);
-		} else {
-			return TOO_GENERAL_REQUEST;
-		}
-	}
-	//Go down AND branch. Will abort if empty.
-	foundElement = findMatch(foundElement.left(), &testPacket);
-	if (foundElement == this->end()) {
-		return NO_MATCH;
-	}
-	if (subtype == 0) {
-		if (foundElement.left() == end()) {
-			return removeElementAndReconnectChildren(foundElement);
-		} else {
-			return TOO_GENERAL_REQUEST;
-		}
-	}
-	//Again, go down AND branch.
-	foundElement = findMatch(foundElement.left(), &testPacket);
-	if (foundElement == end()) {
-		return NO_MATCH;
-	}
-	return removeElementAndReconnectChildren(foundElement);
-}
-
-PacketMatchTree::iterator PacketMatchTree::findMatch(iterator startAt,
-		TmPacketMinimal* test) {
-	iterator iter = startAt;
-	while (iter != end()) {
-		bool isMatch = iter->match(test);
-		if (isMatch) {
-			break;
-		} else {
-			iter = iter.right(); //next OR element
-		}
-	}
-	return iter;
-}
-
-ReturnValue_t PacketMatchTree::initialize() {
-	return factoryBackend.initialize();
-}
-
-const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
-		sizeof(SubServiceMatcher), sizeof(ApidMatcher),
-		sizeof(PacketMatchTree::Node) };
-//Maximum number of types and subtypes to filter should be more than sufficient.
-const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
-
-ReturnValue_t PacketMatchTree::changeMatch(bool addToMatch, uint16_t apid,
-		uint8_t type, uint8_t subtype) {
-	if (addToMatch) {
-		return addMatch(apid, type, subtype);
-	} else {
-		return removeMatch(apid, type, subtype);
-	}
-}
-
-ReturnValue_t PacketMatchTree::cleanUpElement(iterator position) {
-	factory.destroy(position.element->value);
-	//Go on anyway, there's nothing we can do.
-	//SHOULDDO: Throw event, or write debug message?
-	return factory.destroy(position.element);
-}
+#include "../../tmtcpacket/packetmatcher/ApidMatcher.h"
+#include "../../tmtcpacket/packetmatcher/PacketMatchTree.h"
+#include "../../tmtcpacket/packetmatcher/ServiceMatcher.h"
+#include "../../tmtcpacket/packetmatcher/SubserviceMatcher.h"
+
+PacketMatchTree::PacketMatchTree(Node* root) :
+		MatchTree<TmPacketMinimal*>(root, 2), factoryBackend(0, POOL_SIZES,
+				N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::PacketMatchTree(iterator root) :
+		MatchTree<TmPacketMinimal*>(root.element, 2), factoryBackend(0,
+				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::PacketMatchTree() :
+		MatchTree<TmPacketMinimal*>((Node*) NULL, 2), factoryBackend(0,
+				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::~PacketMatchTree() {
+}
+
+ReturnValue_t PacketMatchTree::addMatch(uint16_t apid, uint8_t type,
+		uint8_t subtype) {
+	//We assume adding APID is always requested.
+	TmPacketMinimal::TmPacketMinimalPointer data;
+	data.data_field.service_type = type;
+	data.data_field.service_subtype = subtype;
+	TmPacketMinimal testPacket((uint8_t*) &data);
+	testPacket.setAPID(apid);
+	iterator lastTest;
+	iterator rollback;
+	ReturnValue_t result = findOrInsertMatch<TmPacketMinimal*, ApidMatcher>(
+			this->begin(), &testPacket, &lastTest);
+	if (result == NEW_NODE_CREATED) {
+		rollback = lastTest;
+	} else if (result != RETURN_OK) {
+		return result;
+	}
+	if (type == 0) {
+		//Check if lastTest has no children, otherwise, delete them,
+		//as a more general check is requested.
+		if (lastTest.left() != this->end()) {
+			removeElementAndAllChildren(lastTest.left());
+		}
+		return RETURN_OK;
+	}
+	//Type insertion required.
+	result = findOrInsertMatch<TmPacketMinimal*, ServiceMatcher>(
+			lastTest.left(), &testPacket, &lastTest);
+	if (result == NEW_NODE_CREATED) {
+		if  (rollback == this->end()) {
+			rollback = lastTest;
+		}
+	} else if (result != RETURN_OK) {
+		if (rollback != this->end()) {
+			removeElementAndAllChildren(rollback);
+		}
+		return result;
+	}
+	if (subtype == 0) {
+		if (lastTest.left() != this->end()) {
+			//See above
+			removeElementAndAllChildren(lastTest.left());
+		}
+		return RETURN_OK;
+	}
+	//Subtype insertion required.
+	result = findOrInsertMatch<TmPacketMinimal*, SubServiceMatcher>(
+			lastTest.left(), &testPacket, &lastTest);
+	if (result == NEW_NODE_CREATED) {
+		return RETURN_OK;
+	} else if (result != RETURN_OK) {
+		if (rollback != this->end()) {
+			removeElementAndAllChildren(rollback);
+		}
+		return result;
+	}
+	return RETURN_OK;
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+ReturnValue_t PacketMatchTree::findOrInsertMatch(iterator startAt, VALUE_T test,
+		iterator* lastTest) {
+	bool attachToBranch = AND;
+	iterator iter = startAt;
+	while (iter != this->end()) {
+		bool isMatch = iter->match(test);
+		attachToBranch = OR;
+		*lastTest = iter;
+		if (isMatch) {
+			return RETURN_OK;
+		} else {
+			//Go down OR branch.
+			iter = iter.right();
+		}
+	}
+	//Only reached if nothing was found.
+	SerializeableMatcherIF<VALUE_T>* newContent = factory.generate<INSERTION_T>(
+			test);
+	if (newContent == NULL) {
+		return FULL;
+	}
+	Node* newNode = factory.generate<Node>(newContent);
+	if (newNode == NULL) {
+		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
+		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
+		return FULL;
+	}
+	*lastTest = insert(attachToBranch, *lastTest, newNode);
+	if (*lastTest == end()) {
+		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
+		return RETURN_FAILED;
+	}
+	return NEW_NODE_CREATED;
+}
+
+ReturnValue_t PacketMatchTree::removeMatch(uint16_t apid, uint8_t type,
+		uint8_t subtype) {
+	TmPacketMinimal::TmPacketMinimalPointer data;
+	data.data_field.service_type = type;
+	data.data_field.service_subtype = subtype;
+	TmPacketMinimal testPacket((uint8_t*) &data);
+	testPacket.setAPID(apid);
+	iterator foundElement = findMatch(begin(), &testPacket);
+	if (foundElement == this->end()) {
+		return NO_MATCH;
+	}
+	if (type == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	//Go down AND branch. Will abort if empty.
+	foundElement = findMatch(foundElement.left(), &testPacket);
+	if (foundElement == this->end()) {
+		return NO_MATCH;
+	}
+	if (subtype == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	//Again, go down AND branch.
+	foundElement = findMatch(foundElement.left(), &testPacket);
+	if (foundElement == end()) {
+		return NO_MATCH;
+	}
+	return removeElementAndReconnectChildren(foundElement);
+}
+
+PacketMatchTree::iterator PacketMatchTree::findMatch(iterator startAt,
+		TmPacketMinimal* test) {
+	iterator iter = startAt;
+	while (iter != end()) {
+		bool isMatch = iter->match(test);
+		if (isMatch) {
+			break;
+		} else {
+			iter = iter.right(); //next OR element
+		}
+	}
+	return iter;
+}
+
+ReturnValue_t PacketMatchTree::initialize() {
+	return factoryBackend.initialize();
+}
+
+const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
+		sizeof(SubServiceMatcher), sizeof(ApidMatcher),
+		sizeof(PacketMatchTree::Node) };
+//Maximum number of types and subtypes to filter should be more than sufficient.
+const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
+
+ReturnValue_t PacketMatchTree::changeMatch(bool addToMatch, uint16_t apid,
+		uint8_t type, uint8_t subtype) {
+	if (addToMatch) {
+		return addMatch(apid, type, subtype);
+	} else {
+		return removeMatch(apid, type, subtype);
+	}
+}
+
+ReturnValue_t PacketMatchTree::cleanUpElement(iterator position) {
+	factory.destroy(position.element->value);
+	//Go on anyway, there's nothing we can do.
+	//SHOULDDO: Throw event, or write debug message?
+	return factory.destroy(position.element);
+}
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.h b/tmtcpacket/packetmatcher/PacketMatchTree.h
index a6c0c61e9..0d246d21a 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.h
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.h
@@ -1,36 +1,36 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
-
-#include <framework/container/PlacementFactory.h>
-#include <framework/globalfunctions/matching/MatchTree.h>
-#include <framework/storagemanager/LocalPool.h>
-#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
-
-class PacketMatchTree: public MatchTree<TmPacketMinimal*>, public HasReturnvaluesIF {
-public:
-	PacketMatchTree(Node* root);
-	PacketMatchTree(iterator root);
-	PacketMatchTree();
-	virtual ~PacketMatchTree();
-	ReturnValue_t changeMatch(bool addToMatch, uint16_t apid, uint8_t type = 0,
-			uint8_t subtype = 0);
-	ReturnValue_t addMatch(uint16_t apid, uint8_t type = 0,
-			uint8_t subtype = 0);
-	ReturnValue_t removeMatch(uint16_t apid, uint8_t type = 0,
-			uint8_t subtype = 0);
-	ReturnValue_t initialize();
-protected:
-	ReturnValue_t cleanUpElement(iterator position);
-private:
-	static const uint8_t N_POOLS = 4;
-	LocalPool<N_POOLS> factoryBackend;
-	PlacementFactory factory;
-	static const uint16_t POOL_SIZES[N_POOLS];
-	static const uint16_t N_ELEMENTS[N_POOLS];
-	template<typename VALUE_T, typename INSERTION_T>
-	ReturnValue_t findOrInsertMatch(iterator startAt, VALUE_T test, iterator* lastTest);
-	iterator findMatch(iterator startAt, TmPacketMinimal* test);
-};
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ */
-
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
+
+#include "../../container/PlacementFactory.h"
+#include "../../globalfunctions/matching/MatchTree.h"
+#include "../../storagemanager/LocalPool.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class PacketMatchTree: public MatchTree<TmPacketMinimal*>, public HasReturnvaluesIF {
+public:
+	PacketMatchTree(Node* root);
+	PacketMatchTree(iterator root);
+	PacketMatchTree();
+	virtual ~PacketMatchTree();
+	ReturnValue_t changeMatch(bool addToMatch, uint16_t apid, uint8_t type = 0,
+			uint8_t subtype = 0);
+	ReturnValue_t addMatch(uint16_t apid, uint8_t type = 0,
+			uint8_t subtype = 0);
+	ReturnValue_t removeMatch(uint16_t apid, uint8_t type = 0,
+			uint8_t subtype = 0);
+	ReturnValue_t initialize();
+protected:
+	ReturnValue_t cleanUpElement(iterator position);
+private:
+	static const uint8_t N_POOLS = 4;
+	LocalPool<N_POOLS> factoryBackend;
+	PlacementFactory factory;
+	static const uint16_t POOL_SIZES[N_POOLS];
+	static const uint16_t N_ELEMENTS[N_POOLS];
+	template<typename VALUE_T, typename INSERTION_T>
+	ReturnValue_t findOrInsertMatch(iterator startAt, VALUE_T test, iterator* lastTest);
+	iterator findMatch(iterator startAt, TmPacketMinimal* test);
+};
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ */
+
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index f6e9e3608..e22288f47 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -1,39 +1,39 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
-
-#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
-
-class ServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
-private:
-	uint8_t service;
-public:
-	ServiceMatcher(uint8_t setService) :
-			service(setService) {
-	}
-	ServiceMatcher(TmPacketMinimal* test) :
-			service(test->getService()) {
-	}
-	bool match(TmPacketMinimal* packet) {
-		if (packet->getService() == service) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&service);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
-	}
-};
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class ServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+private:
+	uint8_t service;
+public:
+	ServiceMatcher(uint8_t setService) :
+			service(setService) {
+	}
+	ServiceMatcher(TmPacketMinimal* test) :
+			service(test->getService()) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getService() == service) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&service);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
+	}
+};
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_ */
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 2e8b82b23..1b173b1a2 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -1,40 +1,40 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
-
-#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
-
-class SubServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
-public:
-	SubServiceMatcher(uint8_t subService) :
-			subService(subService) {
-	}
-	SubServiceMatcher(TmPacketMinimal* test) :
-			subService(test->getSubService()) {
-	}
-	bool match(TmPacketMinimal* packet) {
-		if (packet->getSubService() == subService) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&subService);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
-	}
-private:
-	uint8_t subService;
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class SubServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+public:
+	SubServiceMatcher(uint8_t subService) :
+			subService(subService) {
+	}
+	SubServiceMatcher(TmPacketMinimal* test) :
+			subService(test->getSubService()) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getSubService() == subService) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&subService);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
+	}
+private:
+	uint8_t subService;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_ */
diff --git a/tmtcpacket/pus/PacketTimestampInterpreterIF.h b/tmtcpacket/pus/PacketTimestampInterpreterIF.h
index 6e19381ac..9e442ed66 100644
--- a/tmtcpacket/pus/PacketTimestampInterpreterIF.h
+++ b/tmtcpacket/pus/PacketTimestampInterpreterIF.h
@@ -1,16 +1,16 @@
-#ifndef FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
-#define FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-class TmPacketMinimal;
-
-class PacketTimestampInterpreterIF {
-public:
-	virtual ~PacketTimestampInterpreterIF() {}
-	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet, timeval* timestamp) const = 0;
-	virtual ReturnValue_t getPacketTimeRaw(TmPacketMinimal* packet, const uint8_t** timePtr, uint32_t* size) const = 0;
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
+#define FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+class TmPacketMinimal;
+
+class PacketTimestampInterpreterIF {
+public:
+	virtual ~PacketTimestampInterpreterIF() {}
+	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet, timeval* timestamp) const = 0;
+	virtual ReturnValue_t getPacketTimeRaw(TmPacketMinimal* packet, const uint8_t** timePtr, uint32_t* size) const = 0;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_ */
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 733c36dfc..3dc158725 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -1,93 +1,93 @@
-#include <framework/globalfunctions/CRC.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcpacket/pus/TcPacketBase.h>
-#include <string.h>
-
-TcPacketBase::TcPacketBase(const uint8_t* set_data) :
-		SpacePacketBase(set_data) {
-	tcData = (TcPacketPointer*) set_data;
-}
-
-TcPacketBase::~TcPacketBase() {
-	//Nothing to do.
-}
-
-uint8_t TcPacketBase::getService() {
-	return tcData->dataField.service_type;
-}
-
-uint8_t TcPacketBase::getSubService() {
-	return tcData->dataField.service_subtype;
-}
-
-uint8_t TcPacketBase::getAcknowledgeFlags() {
-	return tcData->dataField.version_type_ack & 0b00001111;
-}
-
-const uint8_t* TcPacketBase::getApplicationData() const {
-	return &tcData->appData;
-}
-
-uint16_t TcPacketBase::getApplicationDataSize() {
-	return getPacketDataLength() - sizeof(tcData->dataField) - CRC_SIZE + 1;
-}
-
-uint16_t TcPacketBase::getErrorControl() {
-	uint16_t size = getApplicationDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tcData->appData;
-	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
-}
-
-void TcPacketBase::setErrorControl() {
-	uint32_t full_size = getFullSize();
-	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
-	uint32_t size = getApplicationDataSize();
-	(&tcData->appData)[size] = (crc & 0XFF00) >> 8;	// CRCH
-	(&tcData->appData)[size + 1] = (crc) & 0X00FF; 		// CRCL
-}
-
-void TcPacketBase::setData(const uint8_t* pData) {
-	SpacePacketBase::setData(pData);
-	tcData = (TcPacketPointer*) pData;
-}
-
-void TcPacketBase::setAppData(uint8_t * appData, uint16_t dataLen) {
-	memcpy(&tcData->appData, appData, dataLen);
-	SpacePacketBase::setPacketDataLength(dataLen +
-				sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
-}
-
-uint8_t TcPacketBase::getSecondaryHeaderFlag() {
-	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
-}
-
-uint8_t TcPacketBase::getPusVersionNumber() {
-	return (tcData->dataField.version_type_ack & 0b01110000) >> 4;
-}
-
-void TcPacketBase::print() {
-	uint8_t * wholeData = getWholeData();
-	sif::debug << "TcPacket contains: " << std::endl;
-	for (uint8_t count = 0; count < getFullSize(); ++count) {
-		sif::debug << std::hex << (uint16_t) wholeData[count] << " ";
-	}
-	sif::debug << std::dec << std::endl;
-}
-
-void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
-		uint8_t ack, uint8_t service, uint8_t subservice) {
-	initSpacePacketHeader(true, true, apid, sequenceCount);
-	memset(&tcData->dataField, 0, sizeof(tcData->dataField));
-	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
-	//Data Field Header:
-	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
-	tcData->dataField.version_type_ack = 0b00010000;
-	tcData->dataField.version_type_ack |= (ack & 0x0F);
-	tcData->dataField.service_type = service;
-	tcData->dataField.service_subtype = subservice;
-}
-
-size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
-	return sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) +
-			appDataLen + TcPacketBase::CRC_SIZE;
-}
+#include "../../globalfunctions/CRC.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TcPacketBase.h"
+#include <string.h>
+
+TcPacketBase::TcPacketBase(const uint8_t* set_data) :
+		SpacePacketBase(set_data) {
+	tcData = (TcPacketPointer*) set_data;
+}
+
+TcPacketBase::~TcPacketBase() {
+	//Nothing to do.
+}
+
+uint8_t TcPacketBase::getService() {
+	return tcData->dataField.service_type;
+}
+
+uint8_t TcPacketBase::getSubService() {
+	return tcData->dataField.service_subtype;
+}
+
+uint8_t TcPacketBase::getAcknowledgeFlags() {
+	return tcData->dataField.version_type_ack & 0b00001111;
+}
+
+const uint8_t* TcPacketBase::getApplicationData() const {
+	return &tcData->appData;
+}
+
+uint16_t TcPacketBase::getApplicationDataSize() {
+	return getPacketDataLength() - sizeof(tcData->dataField) - CRC_SIZE + 1;
+}
+
+uint16_t TcPacketBase::getErrorControl() {
+	uint16_t size = getApplicationDataSize() + CRC_SIZE;
+	uint8_t* p_to_buffer = &tcData->appData;
+	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
+}
+
+void TcPacketBase::setErrorControl() {
+	uint32_t full_size = getFullSize();
+	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
+	uint32_t size = getApplicationDataSize();
+	(&tcData->appData)[size] = (crc & 0XFF00) >> 8;	// CRCH
+	(&tcData->appData)[size + 1] = (crc) & 0X00FF; 		// CRCL
+}
+
+void TcPacketBase::setData(const uint8_t* pData) {
+	SpacePacketBase::setData(pData);
+	tcData = (TcPacketPointer*) pData;
+}
+
+void TcPacketBase::setAppData(uint8_t * appData, uint16_t dataLen) {
+	memcpy(&tcData->appData, appData, dataLen);
+	SpacePacketBase::setPacketDataLength(dataLen +
+				sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
+}
+
+uint8_t TcPacketBase::getSecondaryHeaderFlag() {
+	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
+}
+
+uint8_t TcPacketBase::getPusVersionNumber() {
+	return (tcData->dataField.version_type_ack & 0b01110000) >> 4;
+}
+
+void TcPacketBase::print() {
+	uint8_t * wholeData = getWholeData();
+	sif::debug << "TcPacket contains: " << std::endl;
+	for (uint8_t count = 0; count < getFullSize(); ++count) {
+		sif::debug << std::hex << (uint16_t) wholeData[count] << " ";
+	}
+	sif::debug << std::dec << std::endl;
+}
+
+void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
+		uint8_t ack, uint8_t service, uint8_t subservice) {
+	initSpacePacketHeader(true, true, apid, sequenceCount);
+	memset(&tcData->dataField, 0, sizeof(tcData->dataField));
+	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
+	//Data Field Header:
+	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
+	tcData->dataField.version_type_ack = 0b00010000;
+	tcData->dataField.version_type_ack |= (ack & 0x0F);
+	tcData->dataField.service_type = service;
+	tcData->dataField.service_subtype = subservice;
+}
+
+size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
+	return sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) +
+			appDataLen + TcPacketBase::CRC_SIZE;
+}
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index 730761769..1cfe233b9 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -1,204 +1,204 @@
-#ifndef TCPACKETBASE_H_
-#define TCPACKETBASE_H_
-
-#include <framework/tmtcpacket/SpacePacketBase.h>
-#include <cstddef>
-
-/**
- * This struct defines a byte-wise structured PUS TC Data Field Header.
- * Any optional fields in the header must be added or removed here.
- * Currently, the Source Id field is present with one byte.
- * @ingroup tmtcpackets
- */
-struct PUSTcDataFieldHeader {
-	uint8_t version_type_ack;
-	uint8_t service_type;
-	uint8_t service_subtype;
-	uint8_t source_id;
-};
-
-/**
- * This struct defines the data structure of a PUS Telecommand Packet when
- * accessed via a pointer.
- * @ingroup tmtcpackets
- */
-struct TcPacketPointer {
-	CCSDSPrimaryHeader primary;
-	PUSTcDataFieldHeader dataField;
-	uint8_t appData;
-};
-
-/**
- * This class is the basic data handler for any ECSS PUS Telecommand packet.
- *
- * In addition to \SpacePacketBase, the class provides methods to handle
- * the standardized entries of the PUS TC Packet Data Field Header.
- * It does not contain the packet data itself but a pointer to the
- * data must be set on instantiation. An invalid pointer may cause
- * damage, as no getter method checks data validity. Anyway, a NULL
- * check can be performed by making use of the getWholeData method.
- * @ingroup tmtcpackets
- */
-class TcPacketBase : public SpacePacketBase {
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TcPacketPointer* tcData;
-public:
-	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) + 2);
-	/**
-	 * With this constant for the acknowledge field responses on all levels are expected.
-	 */
-	static const uint8_t ACK_ALL = 0b1111;
-	/**
-	 * With this constant for the acknowledge field a response on acceptance is expected.
-	 */
-	static const uint8_t ACK_ACCEPTANCE = 0b0001;
-	/**
-	 * With this constant for the acknowledge field a response on start of execution is expected.
-	 */
-	static const uint8_t ACK_START = 0b0010;
-	/**
-	 * With this constant for the acknowledge field responses on execution steps are expected.
-	 */
-	static const uint8_t ACK_STEP = 0b0100;
-	/**
-	 * With this constant for the acknowledge field a response on completion is expected.
-	 */
-	static const uint8_t ACK_COMPLETION = 0b1000;
-	/**
-	 * With this constant for the acknowledge field no responses are expected.
-	 */
-	static const uint8_t ACK_NONE = 0b000;
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed and also
-	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	TcPacketBase( const uint8_t* set_data );
-	/**
-	 * This is the empty default destructor.
-	 */
-	virtual ~TcPacketBase();
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param sequenceCount Sequence Count in the primary header.
-	 * @param ack Which acknowledeges are expected from the receiver.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 */
-	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
-			uint8_t service, uint8_t subservice);
-	/**
-	 * This command returns the CCSDS Secondary Header Flag.
-	 * It shall always be zero for PUS Packets. This is the
-	 * highest bit of the first byte of the Data Field Header.
-	 * @return	the CCSDS Secondary Header Flag
-	 */
-	uint8_t getSecondaryHeaderFlag();
-	/**
-	 * This command returns the TC Packet PUS Version Number.
-	 * The version number of ECSS PUS 2003 is 1.
-	 * It consists of the second to fourth highest bits of the
-	 * first byte.
-	 * @return
-	 */
-	uint8_t getPusVersionNumber();
-	/**
-	 * This is a getter for the packet's Ack field, which are the lowest four
-	 * bits of the first byte of the Data Field Header.
-	 *
-	 * It is packed in a uint8_t variable.
-	 * @return	The packet's PUS Ack field.
-	 */
-	uint8_t getAcknowledgeFlags();
-	/**
-	 * This is a getter for the packet's PUS Service ID, which is the second
-	 * byte of the Data Field Header.
-	 * @return	The packet's PUS Service ID.
-	 */
-	uint8_t getService();
-	/**
-	 * This is a getter for the packet's PUS Service Subtype, which is the
-	 * third byte of the Data Field Header.
-	 * @return	The packet's PUS Service Subtype.
-	 */
-	uint8_t getSubService();
-	/**
-	 * This is a getter for a pointer to the packet's Application data.
-	 *
-	 * These are the bytes that follow after the Data Field Header. They form
-	 * the packet's application data.
-	 * @return	A pointer to the PUS Application Data.
-	 */
-	const uint8_t* getApplicationData() const;
-	/**
-	 * This method calculates the size of the PUS Application data field.
-	 *
-	 * It takes the information stored in the CCSDS Packet Data Length field
-	 * and subtracts the Data Field Header size and the CRC size.
-	 * @return	The size of the PUS Application Data (without Error Control
-	 * 		field)
-	 */
-	uint16_t getApplicationDataSize();
-	/**
-	 * This getter returns the Error Control Field of the packet.
-	 *
-	 * The field is placed after any possible Application Data. If no
-	 * Application Data is present there's still an Error Control field. It is
-	 * supposed to be a 16bit-CRC.
-	 * @return	The PUS Error Control
-	 */
-	uint16_t getErrorControl();
-	/**
-	 * With this method, the Error Control Field is updated to match the
-	 * current content of the packet.
-	 */
-	void setErrorControl();
-
-	/**
-	 * Copies the supplied data to the internal TC application data field.
-	 * @param pData
-	 * @param dataLen
-	 */
-	void setAppData(uint8_t * appData, uint16_t dataLen);
-
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telecommand Packet.
-	 */
-	void setData( const uint8_t* pData );
-
-	/**
-	 * This is a debugging helper method that prints the whole packet content
-	 * to the screen.
-	 */
-	void print();
-	/**
-	 * Calculate full packet length from application data length.
-	 * @param appDataLen
-	 * @return
-	 */
-	static size_t calculateFullPacketLength(size_t appDataLen);
-};
-
-
-#endif /* TCPACKETBASE_H_ */
+#ifndef TCPACKETBASE_H_
+#define TCPACKETBASE_H_
+
+#include "../../tmtcpacket/SpacePacketBase.h"
+#include <cstddef>
+
+/**
+ * This struct defines a byte-wise structured PUS TC Data Field Header.
+ * Any optional fields in the header must be added or removed here.
+ * Currently, the Source Id field is present with one byte.
+ * @ingroup tmtcpackets
+ */
+struct PUSTcDataFieldHeader {
+	uint8_t version_type_ack;
+	uint8_t service_type;
+	uint8_t service_subtype;
+	uint8_t source_id;
+};
+
+/**
+ * This struct defines the data structure of a PUS Telecommand Packet when
+ * accessed via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct TcPacketPointer {
+	CCSDSPrimaryHeader primary;
+	PUSTcDataFieldHeader dataField;
+	uint8_t appData;
+};
+
+/**
+ * This class is the basic data handler for any ECSS PUS Telecommand packet.
+ *
+ * In addition to \SpacePacketBase, the class provides methods to handle
+ * the standardized entries of the PUS TC Packet Data Field Header.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * @ingroup tmtcpackets
+ */
+class TcPacketBase : public SpacePacketBase {
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet's data.
+	 *
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	TcPacketPointer* tcData;
+public:
+	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) + 2);
+	/**
+	 * With this constant for the acknowledge field responses on all levels are expected.
+	 */
+	static const uint8_t ACK_ALL = 0b1111;
+	/**
+	 * With this constant for the acknowledge field a response on acceptance is expected.
+	 */
+	static const uint8_t ACK_ACCEPTANCE = 0b0001;
+	/**
+	 * With this constant for the acknowledge field a response on start of execution is expected.
+	 */
+	static const uint8_t ACK_START = 0b0010;
+	/**
+	 * With this constant for the acknowledge field responses on execution steps are expected.
+	 */
+	static const uint8_t ACK_STEP = 0b0100;
+	/**
+	 * With this constant for the acknowledge field a response on completion is expected.
+	 */
+	static const uint8_t ACK_COMPLETION = 0b1000;
+	/**
+	 * With this constant for the acknowledge field no responses are expected.
+	 */
+	static const uint8_t ACK_NONE = 0b000;
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed and also
+	 * forwards the data pointer to the parent SpacePacketBase class.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	TcPacketBase( const uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TcPacketBase();
+	/**
+	 * Initializes the Tc Packet header.
+	 * @param apid APID used.
+	 * @param service	PUS Service
+	 * @param subservice PUS Subservice
+	 * @param packetSubcounter Additional subcounter used.
+	 */
+	/**
+	 * Initializes the Tc Packet header.
+	 * @param apid APID used.
+	 * @param sequenceCount Sequence Count in the primary header.
+	 * @param ack Which acknowledeges are expected from the receiver.
+	 * @param service	PUS Service
+	 * @param subservice PUS Subservice
+	 */
+	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
+			uint8_t service, uint8_t subservice);
+	/**
+	 * This command returns the CCSDS Secondary Header Flag.
+	 * It shall always be zero for PUS Packets. This is the
+	 * highest bit of the first byte of the Data Field Header.
+	 * @return	the CCSDS Secondary Header Flag
+	 */
+	uint8_t getSecondaryHeaderFlag();
+	/**
+	 * This command returns the TC Packet PUS Version Number.
+	 * The version number of ECSS PUS 2003 is 1.
+	 * It consists of the second to fourth highest bits of the
+	 * first byte.
+	 * @return
+	 */
+	uint8_t getPusVersionNumber();
+	/**
+	 * This is a getter for the packet's Ack field, which are the lowest four
+	 * bits of the first byte of the Data Field Header.
+	 *
+	 * It is packed in a uint8_t variable.
+	 * @return	The packet's PUS Ack field.
+	 */
+	uint8_t getAcknowledgeFlags();
+	/**
+	 * This is a getter for the packet's PUS Service ID, which is the second
+	 * byte of the Data Field Header.
+	 * @return	The packet's PUS Service ID.
+	 */
+	uint8_t getService();
+	/**
+	 * This is a getter for the packet's PUS Service Subtype, which is the
+	 * third byte of the Data Field Header.
+	 * @return	The packet's PUS Service Subtype.
+	 */
+	uint8_t getSubService();
+	/**
+	 * This is a getter for a pointer to the packet's Application data.
+	 *
+	 * These are the bytes that follow after the Data Field Header. They form
+	 * the packet's application data.
+	 * @return	A pointer to the PUS Application Data.
+	 */
+	const uint8_t* getApplicationData() const;
+	/**
+	 * This method calculates the size of the PUS Application data field.
+	 *
+	 * It takes the information stored in the CCSDS Packet Data Length field
+	 * and subtracts the Data Field Header size and the CRC size.
+	 * @return	The size of the PUS Application Data (without Error Control
+	 * 		field)
+	 */
+	uint16_t getApplicationDataSize();
+	/**
+	 * This getter returns the Error Control Field of the packet.
+	 *
+	 * The field is placed after any possible Application Data. If no
+	 * Application Data is present there's still an Error Control field. It is
+	 * supposed to be a 16bit-CRC.
+	 * @return	The PUS Error Control
+	 */
+	uint16_t getErrorControl();
+	/**
+	 * With this method, the Error Control Field is updated to match the
+	 * current content of the packet.
+	 */
+	void setErrorControl();
+
+	/**
+	 * Copies the supplied data to the internal TC application data field.
+	 * @param pData
+	 * @param dataLen
+	 */
+	void setAppData(uint8_t * appData, uint16_t dataLen);
+
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 *
+	 * This call overwrites the parent's setData method to set both its
+	 * \c tc_data pointer and the parent's \c data pointer.
+	 *
+	 * @param p_data	A pointer to another PUS Telecommand Packet.
+	 */
+	void setData( const uint8_t* pData );
+
+	/**
+	 * This is a debugging helper method that prints the whole packet content
+	 * to the screen.
+	 */
+	void print();
+	/**
+	 * Calculate full packet length from application data length.
+	 * @param appDataLen
+	 * @return
+	 */
+	static size_t calculateFullPacketLength(size_t appDataLen);
+};
+
+
+#endif /* TCPACKETBASE_H_ */
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 64aa74dca..3f10cac0a 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -1,118 +1,118 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcpacket/pus/TcPacketStored.h>
-
-#include <cstring>
-
-TcPacketStored::TcPacketStored(store_address_t setAddress) :
-		TcPacketBase(nullptr), storeAddress(setAddress) {
-	this->setStoreAddress(this->storeAddress);
-}
-
-TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
-		uint16_t apid, uint8_t sequence_count, const uint8_t* data,
-		size_t size, uint8_t ack ) :
-		TcPacketBase(nullptr) {
-	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!this->checkAndSetStore()) {
-		return;
-	}
-	uint8_t* p_data = nullptr;
-	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
-			(TC_PACKET_MIN_SIZE + size), &p_data);
-	if (returnValue != this->store->RETURN_OK) {
-		sif::warning << "TcPacketStored: Could not get free element from store!"
-				<< std::endl;
-		return;
-	}
-	this->setData(p_data);
-	initializeTcPacket(apid, sequence_count, ack, service, subservice);
-	memcpy(&tcData->appData, data, size);
-	this->setPacketDataLength(
-			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
-	this->setErrorControl();
-}
-
-ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
-		size_t* dataSize) {
-	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
-	}
-	return result;
-}
-
-TcPacketStored::TcPacketStored() :
-		TcPacketBase(NULL) {
-	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	this->checkAndSetStore();
-
-}
-
-ReturnValue_t TcPacketStored::deletePacket() {
-	ReturnValue_t result = this->store->deleteData(this->storeAddress);
-	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	this->setData( NULL);
-	return result;
-}
-
-bool TcPacketStored::checkAndSetStore() {
-	if (this->store == NULL) {
-		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-		if (this->store == NULL) {
-			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
-					<< std::endl;
-			return false;
-		}
-	}
-	return true;
-}
-
-void TcPacketStored::setStoreAddress(store_address_t setAddress) {
-	this->storeAddress = setAddress;
-	const uint8_t* temp_data = NULL;
-	size_t temp_size;
-	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
-	if (this->checkAndSetStore()) {
-		status = this->store->getData(this->storeAddress, &temp_data,
-				&temp_size);
-	}
-	if (status == StorageManagerIF::RETURN_OK) {
-		this->setData(temp_data);
-	} else {
-		this->setData(NULL);
-		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	}
-}
-
-store_address_t TcPacketStored::getStoreAddress() {
-	return this->storeAddress;
-}
-
-bool TcPacketStored::isSizeCorrect() {
-	const uint8_t* temp_data = NULL;
-	size_t temp_size;
-	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
-			&temp_size);
-	if (status == StorageManagerIF::RETURN_OK) {
-		if (this->getFullSize() == temp_size) {
-			return true;
-		}
-	}
-	return false;
-}
-
-StorageManagerIF* TcPacketStored::store = NULL;
-
-TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
-		TcPacketBase(data) {
-	if (getFullSize() != size) {
-		return;
-	}
-	if (this->checkAndSetStore()) {
-		ReturnValue_t status = store->addData(&storeAddress, data, size);
-		if (status != HasReturnvaluesIF::RETURN_OK) {
-			this->setData(NULL);
-		}
-	}
-}
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TcPacketStored.h"
+
+#include <cstring>
+
+TcPacketStored::TcPacketStored(store_address_t setAddress) :
+		TcPacketBase(nullptr), storeAddress(setAddress) {
+	this->setStoreAddress(this->storeAddress);
+}
+
+TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
+		uint16_t apid, uint8_t sequence_count, const uint8_t* data,
+		size_t size, uint8_t ack ) :
+		TcPacketBase(nullptr) {
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if (!this->checkAndSetStore()) {
+		return;
+	}
+	uint8_t* p_data = nullptr;
+	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
+			(TC_PACKET_MIN_SIZE + size), &p_data);
+	if (returnValue != this->store->RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get free element from store!"
+				<< std::endl;
+		return;
+	}
+	this->setData(p_data);
+	initializeTcPacket(apid, sequence_count, ack, service, subservice);
+	memcpy(&tcData->appData, data, size);
+	this->setPacketDataLength(
+			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
+	this->setErrorControl();
+}
+
+ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
+		size_t* dataSize) {
+	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
+	}
+	return result;
+}
+
+TcPacketStored::TcPacketStored() :
+		TcPacketBase(NULL) {
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	this->checkAndSetStore();
+
+}
+
+ReturnValue_t TcPacketStored::deletePacket() {
+	ReturnValue_t result = this->store->deleteData(this->storeAddress);
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	this->setData( NULL);
+	return result;
+}
+
+bool TcPacketStored::checkAndSetStore() {
+	if (this->store == NULL) {
+		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+		if (this->store == NULL) {
+			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
+					<< std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+void TcPacketStored::setStoreAddress(store_address_t setAddress) {
+	this->storeAddress = setAddress;
+	const uint8_t* temp_data = NULL;
+	size_t temp_size;
+	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
+	if (this->checkAndSetStore()) {
+		status = this->store->getData(this->storeAddress, &temp_data,
+				&temp_size);
+	}
+	if (status == StorageManagerIF::RETURN_OK) {
+		this->setData(temp_data);
+	} else {
+		this->setData(NULL);
+		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	}
+}
+
+store_address_t TcPacketStored::getStoreAddress() {
+	return this->storeAddress;
+}
+
+bool TcPacketStored::isSizeCorrect() {
+	const uint8_t* temp_data = NULL;
+	size_t temp_size;
+	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
+			&temp_size);
+	if (status == StorageManagerIF::RETURN_OK) {
+		if (this->getFullSize() == temp_size) {
+			return true;
+		}
+	}
+	return false;
+}
+
+StorageManagerIF* TcPacketStored::store = NULL;
+
+TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
+		TcPacketBase(data) {
+	if (getFullSize() != size) {
+		return;
+	}
+	if (this->checkAndSetStore()) {
+		ReturnValue_t status = store->addData(&storeAddress, data, size);
+		if (status != HasReturnvaluesIF::RETURN_OK) {
+			this->setData(NULL);
+		}
+	}
+}
diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h
index de3eb85f7..90cf2fbaf 100644
--- a/tmtcpacket/pus/TcPacketStored.h
+++ b/tmtcpacket/pus/TcPacketStored.h
@@ -1,110 +1,110 @@
-#ifndef TCPACKETSTORED_H_
-#define TCPACKETSTORED_H_
-
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tmtcpacket/pus/TcPacketBase.h>
-
-/**
- *	This class generates a ECSS PUS Telecommand packet within a given
- *	intermediate storage.
- *	As most packets are passed between tasks with the help of a storage
- *	anyway, it seems logical to create a Packet-In-Storage access class
- *	which saves the user almost all storage handling operation.
- *	Packets can both be newly created with the class and be "linked" to
- *	packets in a store with the help of a storeAddress.
- *	@ingroup tmtcpackets
- */
-class TcPacketStored : public TcPacketBase {
-private:
-	/**
-	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
-	 * call tries to set it and throws an error message in case of failures.
-	 * The default store is objects::TC_STORE.
-	 */
-	static StorageManagerIF* store;
-	/**
-	 * The address where the packet data of the object instance is stored.
-	 */
-	store_address_t storeAddress;
-	/**
-	 * A helper method to check if a store is assigned to the class.
-	 * If not, the method tries to retrieve the store from the global
-	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
-	 */
-	bool checkAndSetStore();
-public:
-	/**
-	 * This is a default constructor which does not set the data pointer.
-	 * However, it does try to set the packet store.
-	 */
-	TcPacketStored();
-	/**
-	 * With this constructor, the class instance is linked to an existing
-	 * packet in the packet store.
-	 * The packet content is neither checked nor changed with this call. If
-	 * the packet could not be found, the data pointer is set to NULL.
-	 */
-	TcPacketStored( store_address_t setAddress );
-	/**
-	 * With this constructor, new space is allocated in the packet store and
-	 * a new PUS Telecommand Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet.
-	 * @param apid			Sets the packet's APID field.
-	 * @param ack			Set's the packet's Ack field,
-	 * 		which specifies number and size of verification packets returned
-	 * 		for this command.
-	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the destination service.
-	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the destination sub-service.
-	 * @param sequence_count	Sets the packet's Source Sequence Count field.
-	 * @param data		The data to be copied to the Application Data Field.
-	 * @param size		The amount of data to be copied.
-	 */
-	TcPacketStored( uint8_t service, uint8_t subservice, uint16_t apid,
-			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
-			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL );
-	/**
-	 * Another constructor to create a TcPacket from a raw packet stream.
-	 * Takes the data and adds it unchecked to the TcStore.
-	 * @param data	Pointer to the complete TC Space Packet.
-	 * @param Size size of the packet.
-	 */
-	TcPacketStored( const uint8_t* data, uint32_t size);
-
-	ReturnValue_t getData(const uint8_t ** dataPtr,
-			size_t* dataSize);
-	/**
-	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
-	 */
-	store_address_t getStoreAddress();
-	/**
-	 * With this call, the packet is deleted.
-	 * It removes itself from the store and sets its data pointer to NULL.
-	 * @return	returncode from deleting the data.
-	 */
-	ReturnValue_t deletePacket();
-	/**
-	 * With this call, a packet can be linked to another store. This is useful
-	 * if the packet is a class member and used for more than one packet.
-	 * @param setAddress	The new packet id to link to.
-	 */
-	void setStoreAddress( store_address_t setAddress );
-	/**
-	 * This method performs a size check.
-	 * It reads the stored size and compares it with the size entered in the
-	 * packet header. This class is the optimal place for such a check as it
-	 * has access to both the header data and the store.
-	 * @return	true if size is correct, false if packet is not registered in
-	 * 			store or size is incorrect.
-	 */
-	bool isSizeCorrect();
-};
-
-
-#endif /* TCPACKETSTORED_H_ */
+#ifndef TCPACKETSTORED_H_
+#define TCPACKETSTORED_H_
+
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../tmtcpacket/pus/TcPacketBase.h"
+
+/**
+ *	This class generates a ECSS PUS Telecommand packet within a given
+ *	intermediate storage.
+ *	As most packets are passed between tasks with the help of a storage
+ *	anyway, it seems logical to create a Packet-In-Storage access class
+ *	which saves the user almost all storage handling operation.
+ *	Packets can both be newly created with the class and be "linked" to
+ *	packets in a store with the help of a storeAddress.
+ *	@ingroup tmtcpackets
+ */
+class TcPacketStored : public TcPacketBase {
+private:
+	/**
+	 * This is a pointer to the store all instances of the class use.
+	 * If the store is not yet set (i.e. \c store is NULL), every constructor
+	 * call tries to set it and throws an error message in case of failures.
+	 * The default store is objects::TC_STORE.
+	 */
+	static StorageManagerIF* store;
+	/**
+	 * The address where the packet data of the object instance is stored.
+	 */
+	store_address_t storeAddress;
+	/**
+	 * A helper method to check if a store is assigned to the class.
+	 * If not, the method tries to retrieve the store from the global
+	 * ObjectManager.
+	 * @return	@li	\c true if the store is linked or could be created.
+	 * 			@li \c false otherwise.
+	 */
+	bool checkAndSetStore();
+public:
+	/**
+	 * This is a default constructor which does not set the data pointer.
+	 * However, it does try to set the packet store.
+	 */
+	TcPacketStored();
+	/**
+	 * With this constructor, the class instance is linked to an existing
+	 * packet in the packet store.
+	 * The packet content is neither checked nor changed with this call. If
+	 * the packet could not be found, the data pointer is set to NULL.
+	 */
+	TcPacketStored( store_address_t setAddress );
+	/**
+	 * With this constructor, new space is allocated in the packet store and
+	 * a new PUS Telecommand Packet is created there.
+	 * Packet Application Data passed in data is copied into the packet.
+	 * @param apid			Sets the packet's APID field.
+	 * @param ack			Set's the packet's Ack field,
+	 * 		which specifies number and size of verification packets returned
+	 * 		for this command.
+	 * @param service		Sets the packet's Service ID field.
+	 * 		This specifies the destination service.
+	 * @param subservice	Sets the packet's Service Subtype field.
+	 * 		This specifies the destination sub-service.
+	 * @param sequence_count	Sets the packet's Source Sequence Count field.
+	 * @param data		The data to be copied to the Application Data Field.
+	 * @param size		The amount of data to be copied.
+	 */
+	TcPacketStored( uint8_t service, uint8_t subservice, uint16_t apid,
+			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
+			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL );
+	/**
+	 * Another constructor to create a TcPacket from a raw packet stream.
+	 * Takes the data and adds it unchecked to the TcStore.
+	 * @param data	Pointer to the complete TC Space Packet.
+	 * @param Size size of the packet.
+	 */
+	TcPacketStored( const uint8_t* data, uint32_t size);
+
+	ReturnValue_t getData(const uint8_t ** dataPtr,
+			size_t* dataSize);
+	/**
+	 * This is a getter for the current store address of the packet.
+	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
+	 * 			the packet is not linked.
+	 */
+	store_address_t getStoreAddress();
+	/**
+	 * With this call, the packet is deleted.
+	 * It removes itself from the store and sets its data pointer to NULL.
+	 * @return	returncode from deleting the data.
+	 */
+	ReturnValue_t deletePacket();
+	/**
+	 * With this call, a packet can be linked to another store. This is useful
+	 * if the packet is a class member and used for more than one packet.
+	 * @param setAddress	The new packet id to link to.
+	 */
+	void setStoreAddress( store_address_t setAddress );
+	/**
+	 * This method performs a size check.
+	 * It reads the stored size and compares it with the size entered in the
+	 * packet header. This class is the optimal place for such a check as it
+	 * has access to both the header data and the store.
+	 * @return	true if size is correct, false if packet is not registered in
+	 * 			store or size is incorrect.
+	 */
+	bool isSizeCorrect();
+};
+
+
+#endif /* TCPACKETSTORED_H_ */
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index a2c27ce15..630471cc8 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -1,119 +1,119 @@
-#include <framework/globalfunctions/CRC.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcpacket/pus/TmPacketBase.h>
-#include <framework/timemanager/CCSDSTime.h>
-#include <string.h>
-
-TmPacketBase::TmPacketBase(uint8_t* set_data) :
-		SpacePacketBase(set_data) {
-	tm_data = (TmPacketPointer*) set_data;
-}
-
-TmPacketBase::~TmPacketBase() {
-	//Nothing to do.
-}
-
-uint8_t TmPacketBase::getService() {
-	return tm_data->data_field.service_type;
-}
-
-uint8_t TmPacketBase::getSubService() {
-	return tm_data->data_field.service_subtype;
-}
-
-uint8_t* TmPacketBase::getSourceData() {
-	return &tm_data->data;
-}
-
-uint16_t TmPacketBase::getSourceDataSize() {
-	return getPacketDataLength() - sizeof(tm_data->data_field)
-			- CRC_SIZE + 1;
-}
-
-uint16_t TmPacketBase::getErrorControl() {
-	uint32_t size = getSourceDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tm_data->data;
-	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
-}
-
-void TmPacketBase::setErrorControl() {
-	uint32_t full_size = getFullSize();
-	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
-	uint32_t size = getSourceDataSize();
-	getSourceData()[size] = (crc & 0XFF00) >> 8;	// CRCH
-	getSourceData()[size + 1] = (crc) & 0X00FF; 		// CRCL
-}
-
-void TmPacketBase::setData(const uint8_t* p_Data) {
-	SpacePacketBase::setData(p_Data);
-	tm_data = (TmPacketPointer*) p_Data;
-}
-
-void TmPacketBase::print() {
-	/*uint8_t * wholeData = getWholeData();
-	 debug << "TmPacket contains: " << std::endl;
-	 for (uint8_t count = 0; count < getFullSize(); ++count ) {
-	 debug << std::hex << (uint16_t)wholeData[count] << " ";
-	 }
-	 debug << std::dec << std::endl;*/
-}
-
-bool TmPacketBase::checkAndSetStamper() {
-	if (timeStamper == NULL) {
-		timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
-		if (timeStamper == NULL) {
-			sif::error << "TmPacketBase::checkAndSetStamper: Stamper not found!"
-					<< std::endl;
-			return false;
-		}
-	}
-	return true;
-}
-
-ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
-	uint32_t tempSize = 0;
-	return CCSDSTime::convertFromCcsds(timestamp, tm_data->data_field.time,
-			&tempSize, sizeof(tm_data->data_field.time));
-}
-
-uint8_t* TmPacketBase::getPacketTimeRaw() const{
-	return tm_data->data_field.time;
-
-}
-
-void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter) {
-	//Set primary header:
-	initSpacePacketHeader(false, true, apid);
-	//Set data Field Header:
-	//First, set to zero.
-	memset(&tm_data->data_field, 0, sizeof(tm_data->data_field));
-	//Set CCSDS_secondary header flag to 0, version number to 001 and ack to 0000
-	// NOTE: In PUS-C, the PUS Version is 2 and specified for the first 4 bits.
-	// The other 4 bits of the first byte are the spacecraft time reference status
-	// To change to PUS-C, set 0b00100000
-	tm_data->data_field.version_type_ack = 0b00010000;
-	tm_data->data_field.service_type = service;
-	tm_data->data_field.service_subtype = subservice;
-	tm_data->data_field.subcounter = packetSubcounter;
-	//Timestamp packet
-	if (checkAndSetStamper()) {
-		timeStamper->addTimeStamp(tm_data->data_field.time, sizeof(tm_data->data_field.time));
-	}
-}
-
-void TmPacketBase::setSourceData(uint8_t* sourceData, size_t sourceSize) {
-	memcpy(getSourceData(), sourceData, sourceSize);
-	setSourceDataSize(sourceSize);
-}
-
-void TmPacketBase::setSourceDataSize(uint16_t size) {
-	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
-}
-
-uint32_t TmPacketBase::getTimestampSize() const {
-	return sizeof(tm_data->data_field.time);
-}
-
-TimeStamperIF* TmPacketBase::timeStamper = NULL;
-object_id_t TmPacketBase::timeStamperId = 0;
+#include "../../globalfunctions/CRC.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TmPacketBase.h"
+#include "../../timemanager/CCSDSTime.h"
+#include <string.h>
+
+TmPacketBase::TmPacketBase(uint8_t* set_data) :
+		SpacePacketBase(set_data) {
+	tm_data = (TmPacketPointer*) set_data;
+}
+
+TmPacketBase::~TmPacketBase() {
+	//Nothing to do.
+}
+
+uint8_t TmPacketBase::getService() {
+	return tm_data->data_field.service_type;
+}
+
+uint8_t TmPacketBase::getSubService() {
+	return tm_data->data_field.service_subtype;
+}
+
+uint8_t* TmPacketBase::getSourceData() {
+	return &tm_data->data;
+}
+
+uint16_t TmPacketBase::getSourceDataSize() {
+	return getPacketDataLength() - sizeof(tm_data->data_field)
+			- CRC_SIZE + 1;
+}
+
+uint16_t TmPacketBase::getErrorControl() {
+	uint32_t size = getSourceDataSize() + CRC_SIZE;
+	uint8_t* p_to_buffer = &tm_data->data;
+	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
+}
+
+void TmPacketBase::setErrorControl() {
+	uint32_t full_size = getFullSize();
+	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
+	uint32_t size = getSourceDataSize();
+	getSourceData()[size] = (crc & 0XFF00) >> 8;	// CRCH
+	getSourceData()[size + 1] = (crc) & 0X00FF; 		// CRCL
+}
+
+void TmPacketBase::setData(const uint8_t* p_Data) {
+	SpacePacketBase::setData(p_Data);
+	tm_data = (TmPacketPointer*) p_Data;
+}
+
+void TmPacketBase::print() {
+	/*uint8_t * wholeData = getWholeData();
+	 debug << "TmPacket contains: " << std::endl;
+	 for (uint8_t count = 0; count < getFullSize(); ++count ) {
+	 debug << std::hex << (uint16_t)wholeData[count] << " ";
+	 }
+	 debug << std::dec << std::endl;*/
+}
+
+bool TmPacketBase::checkAndSetStamper() {
+	if (timeStamper == NULL) {
+		timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
+		if (timeStamper == NULL) {
+			sif::error << "TmPacketBase::checkAndSetStamper: Stamper not found!"
+					<< std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
+	uint32_t tempSize = 0;
+	return CCSDSTime::convertFromCcsds(timestamp, tm_data->data_field.time,
+			&tempSize, sizeof(tm_data->data_field.time));
+}
+
+uint8_t* TmPacketBase::getPacketTimeRaw() const{
+	return tm_data->data_field.time;
+
+}
+
+void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter) {
+	//Set primary header:
+	initSpacePacketHeader(false, true, apid);
+	//Set data Field Header:
+	//First, set to zero.
+	memset(&tm_data->data_field, 0, sizeof(tm_data->data_field));
+	//Set CCSDS_secondary header flag to 0, version number to 001 and ack to 0000
+	// NOTE: In PUS-C, the PUS Version is 2 and specified for the first 4 bits.
+	// The other 4 bits of the first byte are the spacecraft time reference status
+	// To change to PUS-C, set 0b00100000
+	tm_data->data_field.version_type_ack = 0b00010000;
+	tm_data->data_field.service_type = service;
+	tm_data->data_field.service_subtype = subservice;
+	tm_data->data_field.subcounter = packetSubcounter;
+	//Timestamp packet
+	if (checkAndSetStamper()) {
+		timeStamper->addTimeStamp(tm_data->data_field.time, sizeof(tm_data->data_field.time));
+	}
+}
+
+void TmPacketBase::setSourceData(uint8_t* sourceData, size_t sourceSize) {
+	memcpy(getSourceData(), sourceData, sourceSize);
+	setSourceDataSize(sourceSize);
+}
+
+void TmPacketBase::setSourceDataSize(uint16_t size) {
+	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+}
+
+uint32_t TmPacketBase::getTimestampSize() const {
+	return sizeof(tm_data->data_field.time);
+}
+
+TimeStamperIF* TmPacketBase::timeStamper = NULL;
+object_id_t TmPacketBase::timeStamperId = 0;
diff --git a/tmtcpacket/pus/TmPacketBase.h b/tmtcpacket/pus/TmPacketBase.h
index 6f3c4b597..acd08d725 100644
--- a/tmtcpacket/pus/TmPacketBase.h
+++ b/tmtcpacket/pus/TmPacketBase.h
@@ -1,186 +1,186 @@
-#ifndef TMPACKETBASE_H_
-#define TMPACKETBASE_H_
-
-#include <framework/timemanager/TimeStamperIF.h>
-#include <framework/tmtcpacket/SpacePacketBase.h>
-#include <framework/timemanager/Clock.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * This struct defines a byte-wise structured PUS TM Data Field Header.
- * Any optional fields in the header must be added or removed here.
- * Currently, no Destination field is present, but an eigth-byte representation
- * for a time tag [TBD].
- * @ingroup tmtcpackets
- */
-struct PUSTmDataFieldHeader {
-	uint8_t version_type_ack;
-	uint8_t service_type;
-	uint8_t service_subtype;
-	uint8_t subcounter;
-//	uint8_t destination;
-	uint8_t time[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
-};
-
-/**
- * This struct defines the data structure of a PUS Telecommand Packet when
- * accessed via a pointer.
- * @ingroup tmtcpackets
- */
-struct TmPacketPointer {
-	CCSDSPrimaryHeader primary;
-	PUSTmDataFieldHeader data_field;
-	uint8_t data;
-};
-
-/**
- * This class is the basic data handler for any ECSS PUS Telemetry packet.
- *
- * In addition to \SpacePacketBase, the class provides methods to handle
- * the standardized entries of the PUS TM Packet Data Field Header.
- * It does not contain the packet data itself but a pointer to the
- * data must be set on instantiation. An invalid pointer may cause
- * damage, as no getter method checks data validity. Anyway, a NULL
- * check can be performed by making use of the getWholeData method.
- * @ingroup tmtcpackets
- */
-class TmPacketBase : public SpacePacketBase {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	/**
-	 * This constant defines the minimum size of a valid PUS Telemetry Packet.
-	 */
-	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTmDataFieldHeader) + 2); //!< Minimum size of a valid PUS Telemetry Packet.
-	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048; //!< Maximum size of a TM Packet in this mission.
-	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000; //!< First byte of secondary header for PUS-A packets.
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed and also
-	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	TmPacketBase( uint8_t* set_data );
-	/**
-	 * This is the empty default destructor.
-	 */
-	virtual ~TmPacketBase();
-	/**
-	 * Initializes the Tm Packet header.
-	 * Does set the timestamp (to now), but not the error control field.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter);
-	/**
-	 * This is a getter for the packet's PUS Service ID, which is the second
-	 * byte of the Data Field Header.
-	 * @return	The packet's PUS Service ID.
-	 */
-	uint8_t getService();
-	/**
-	 * This is a getter for the packet's PUS Service Subtype, which is the
-	 * third byte of the Data Field Header.
-	 * @return	The packet's PUS Service Subtype.
-	 */
-	uint8_t getSubService();
-	/**
-	 * This is a getter for a pointer to the packet's Source data.
-	 *
-	 * These are the bytes that follow after the Data Field Header. They form
-	 * the packet's source data.
-	 * @return	A pointer to the PUS Source Data.
-	 */
-	uint8_t* getSourceData();
-	/**
-	 * This method calculates the size of the PUS Source data field.
-	 *
-	 * It takes the information stored in the CCSDS Packet Data Length field
-	 * and subtracts the Data Field Header size and the CRC size.
-	 * @return	The size of the PUS Source Data (without Error Control field)
-	 */
-	uint16_t getSourceDataSize();
-
-	/**
-	 * In case data was filled manually (almost never the case).
-	 * @param size Size of source data (without CRC and data filed header!).
-	 */
-	void setSourceDataSize(uint16_t size);
-	/**
-	 * This getter returns the Error Control Field of the packet.
-	 *
-	 * The field is placed after any possible Source Data. If no
-	 * Source Data is present there's still an Error Control field. It is
-	 * supposed to be a 16bit-CRC.
-	 * @return	The PUS Error Control
-	 */
-	uint16_t getErrorControl();
-	/**
-	 * With this method, the Error Control Field is updated to match the
-	 * current content of the packet.
-	 */
-	void setErrorControl();
-	/**
-	 * This sets the source data. It copies the provided data to
-	 * the internal TmPacketPointer source data location.
-	 * @param sourceData
-	 * @param sourceSize
-	 */
-	void setSourceData(uint8_t* sourceData, size_t sourceSize);
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telemetry Packet.
-	 */
-	void setData( const uint8_t* p_Data );
-	/**
-	 * This is a debugging helper method that prints the whole packet content
-	 * to the screen.
-	 */
-	void print();
-	/**
-	 * Interprets the "time"-field in the secondary header and returns it in timeval format.
-	 * @return Converted timestamp of packet.
-	 */
-	ReturnValue_t getPacketTime(timeval* timestamp) const;
-	/**
-	 * Returns a raw pointer to the beginning of the time field.
-	 * @return Raw pointer to time field.
-	 */
-	uint8_t* getPacketTimeRaw() const;
-
-	uint32_t getTimestampSize() const;
-
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TmPacketPointer* tm_data;
-	/**
-	 * The timeStamper is responsible for adding a timestamp to the packet.
-	 * It is initialized lazy.
-	 */
-	static TimeStamperIF* timeStamper;
-
-	static object_id_t timeStamperId; //!< The ID to use when looking for a time stamper.
-	/**
-	 * Checks if a time stamper is available and tries to set it if not.
-	 * @return Returns false if setting failed.
-	 */
-	bool checkAndSetStamper();
-};
-
-
-#endif /* TMPACKETBASE_H_ */
+#ifndef TMPACKETBASE_H_
+#define TMPACKETBASE_H_
+
+#include "../../timemanager/TimeStamperIF.h"
+#include "../../tmtcpacket/SpacePacketBase.h"
+#include "../../timemanager/Clock.h"
+#include "../../objectmanager/SystemObjectIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * This struct defines a byte-wise structured PUS TM Data Field Header.
+ * Any optional fields in the header must be added or removed here.
+ * Currently, no Destination field is present, but an eigth-byte representation
+ * for a time tag [TBD].
+ * @ingroup tmtcpackets
+ */
+struct PUSTmDataFieldHeader {
+	uint8_t version_type_ack;
+	uint8_t service_type;
+	uint8_t service_subtype;
+	uint8_t subcounter;
+//	uint8_t destination;
+	uint8_t time[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+};
+
+/**
+ * This struct defines the data structure of a PUS Telecommand Packet when
+ * accessed via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct TmPacketPointer {
+	CCSDSPrimaryHeader primary;
+	PUSTmDataFieldHeader data_field;
+	uint8_t data;
+};
+
+/**
+ * This class is the basic data handler for any ECSS PUS Telemetry packet.
+ *
+ * In addition to \SpacePacketBase, the class provides methods to handle
+ * the standardized entries of the PUS TM Packet Data Field Header.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * @ingroup tmtcpackets
+ */
+class TmPacketBase : public SpacePacketBase {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	/**
+	 * This constant defines the minimum size of a valid PUS Telemetry Packet.
+	 */
+	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTmDataFieldHeader) + 2); //!< Minimum size of a valid PUS Telemetry Packet.
+	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048; //!< Maximum size of a TM Packet in this mission.
+	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000; //!< First byte of secondary header for PUS-A packets.
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed and also
+	 * forwards the data pointer to the parent SpacePacketBase class.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	TmPacketBase( uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TmPacketBase();
+	/**
+	 * Initializes the Tm Packet header.
+	 * Does set the timestamp (to now), but not the error control field.
+	 * @param apid APID used.
+	 * @param service	PUS Service
+	 * @param subservice PUS Subservice
+	 * @param packetSubcounter Additional subcounter used.
+	 */
+	void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter);
+	/**
+	 * This is a getter for the packet's PUS Service ID, which is the second
+	 * byte of the Data Field Header.
+	 * @return	The packet's PUS Service ID.
+	 */
+	uint8_t getService();
+	/**
+	 * This is a getter for the packet's PUS Service Subtype, which is the
+	 * third byte of the Data Field Header.
+	 * @return	The packet's PUS Service Subtype.
+	 */
+	uint8_t getSubService();
+	/**
+	 * This is a getter for a pointer to the packet's Source data.
+	 *
+	 * These are the bytes that follow after the Data Field Header. They form
+	 * the packet's source data.
+	 * @return	A pointer to the PUS Source Data.
+	 */
+	uint8_t* getSourceData();
+	/**
+	 * This method calculates the size of the PUS Source data field.
+	 *
+	 * It takes the information stored in the CCSDS Packet Data Length field
+	 * and subtracts the Data Field Header size and the CRC size.
+	 * @return	The size of the PUS Source Data (without Error Control field)
+	 */
+	uint16_t getSourceDataSize();
+
+	/**
+	 * In case data was filled manually (almost never the case).
+	 * @param size Size of source data (without CRC and data filed header!).
+	 */
+	void setSourceDataSize(uint16_t size);
+	/**
+	 * This getter returns the Error Control Field of the packet.
+	 *
+	 * The field is placed after any possible Source Data. If no
+	 * Source Data is present there's still an Error Control field. It is
+	 * supposed to be a 16bit-CRC.
+	 * @return	The PUS Error Control
+	 */
+	uint16_t getErrorControl();
+	/**
+	 * With this method, the Error Control Field is updated to match the
+	 * current content of the packet.
+	 */
+	void setErrorControl();
+	/**
+	 * This sets the source data. It copies the provided data to
+	 * the internal TmPacketPointer source data location.
+	 * @param sourceData
+	 * @param sourceSize
+	 */
+	void setSourceData(uint8_t* sourceData, size_t sourceSize);
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 *
+	 * This call overwrites the parent's setData method to set both its
+	 * \c tc_data pointer and the parent's \c data pointer.
+	 *
+	 * @param p_data	A pointer to another PUS Telemetry Packet.
+	 */
+	void setData( const uint8_t* p_Data );
+	/**
+	 * This is a debugging helper method that prints the whole packet content
+	 * to the screen.
+	 */
+	void print();
+	/**
+	 * Interprets the "time"-field in the secondary header and returns it in timeval format.
+	 * @return Converted timestamp of packet.
+	 */
+	ReturnValue_t getPacketTime(timeval* timestamp) const;
+	/**
+	 * Returns a raw pointer to the beginning of the time field.
+	 * @return Raw pointer to time field.
+	 */
+	uint8_t* getPacketTimeRaw() const;
+
+	uint32_t getTimestampSize() const;
+
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet's data.
+	 *
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	TmPacketPointer* tm_data;
+	/**
+	 * The timeStamper is responsible for adding a timestamp to the packet.
+	 * It is initialized lazy.
+	 */
+	static TimeStamperIF* timeStamper;
+
+	static object_id_t timeStamperId; //!< The ID to use when looking for a time stamper.
+	/**
+	 * Checks if a time stamper is available and tries to set it if not.
+	 * @return Returns false if setting failed.
+	 */
+	bool checkAndSetStamper();
+};
+
+
+#endif /* TMPACKETBASE_H_ */
diff --git a/tmtcpacket/pus/TmPacketMinimal.cpp b/tmtcpacket/pus/TmPacketMinimal.cpp
index 9df0fe5db..ee56d46f4 100644
--- a/tmtcpacket/pus/TmPacketMinimal.cpp
+++ b/tmtcpacket/pus/TmPacketMinimal.cpp
@@ -1,45 +1,45 @@
-#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
-#include <stddef.h>
-#include <time.h>
-#include <framework/tmtcpacket/pus/PacketTimestampInterpreterIF.h>
-
-TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketBase( set_data ) {
-	this->tm_data = (TmPacketMinimalPointer*)set_data;
-}
-
-TmPacketMinimal::~TmPacketMinimal() {
-}
-
-uint8_t TmPacketMinimal::getService() {
-	return tm_data->data_field.service_type;
-}
-
-uint8_t TmPacketMinimal::getSubService() {
-	return tm_data->data_field.service_subtype;
-}
-
-uint8_t TmPacketMinimal::getPacketSubcounter() {
-	return tm_data->data_field.subcounter;
-}
-
-ReturnValue_t TmPacketMinimal::getPacketTime(timeval* timestamp) {
-	if (timestampInterpreter == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return timestampInterpreter->getPacketTime(this, timestamp);
-}
-
-ReturnValue_t TmPacketMinimal::getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size) {
-	if (timestampInterpreter == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return timestampInterpreter->getPacketTimeRaw(this, timePtr, size);
-}
-
-void TmPacketMinimal::setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter) {
-	if (TmPacketMinimal::timestampInterpreter == NULL) {
-		TmPacketMinimal::timestampInterpreter = interpreter;
-	}
-}
-
-PacketTimestampInterpreterIF* TmPacketMinimal::timestampInterpreter = NULL;
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+#include <stddef.h>
+#include <time.h>
+#include "../../tmtcpacket/pus/PacketTimestampInterpreterIF.h"
+
+TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketBase( set_data ) {
+	this->tm_data = (TmPacketMinimalPointer*)set_data;
+}
+
+TmPacketMinimal::~TmPacketMinimal() {
+}
+
+uint8_t TmPacketMinimal::getService() {
+	return tm_data->data_field.service_type;
+}
+
+uint8_t TmPacketMinimal::getSubService() {
+	return tm_data->data_field.service_subtype;
+}
+
+uint8_t TmPacketMinimal::getPacketSubcounter() {
+	return tm_data->data_field.subcounter;
+}
+
+ReturnValue_t TmPacketMinimal::getPacketTime(timeval* timestamp) {
+	if (timestampInterpreter == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return timestampInterpreter->getPacketTime(this, timestamp);
+}
+
+ReturnValue_t TmPacketMinimal::getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size) {
+	if (timestampInterpreter == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return timestampInterpreter->getPacketTimeRaw(this, timePtr, size);
+}
+
+void TmPacketMinimal::setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter) {
+	if (TmPacketMinimal::timestampInterpreter == NULL) {
+		TmPacketMinimal::timestampInterpreter = interpreter;
+	}
+}
+
+PacketTimestampInterpreterIF* TmPacketMinimal::timestampInterpreter = NULL;
diff --git a/tmtcpacket/pus/TmPacketMinimal.h b/tmtcpacket/pus/TmPacketMinimal.h
index 7bfe0883c..e7b362bfe 100644
--- a/tmtcpacket/pus/TmPacketMinimal.h
+++ b/tmtcpacket/pus/TmPacketMinimal.h
@@ -1,84 +1,84 @@
-#ifndef FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
-#define FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
-
-
-#include <framework/tmtcpacket/SpacePacketBase.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-struct timeval;
-class PacketTimestampInterpreterIF;
-/**
- * This is a minimal version of a PUS TmPacket without any variable field, or,
- * in other words with Service Type, Subtype and subcounter only.
- * This is required for handling TM packets with different APIDs with different
- * secondary headers.
- */
-class TmPacketMinimal : public SpacePacketBase {
-public:
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed and also
-	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	TmPacketMinimal( const uint8_t* set_data );
-	/**
-	 * This is the empty default destructor.
-	 */
-	virtual ~TmPacketMinimal();
-	/**
-	 * This is a getter for the packet's PUS Service ID, which is the second
-	 * byte of the Data Field Header.
-	 * @return	The packet's PUS Service ID.
-	 */
-	uint8_t getService();
-	/**
-	 * This is a getter for the packet's PUS Service Subtype, which is the
-	 * third byte of the Data Field Header.
-	 * @return	The packet's PUS Service Subtype.
-	 */
-	uint8_t getSubService();
-	/**
-	 * Returns the subcounter.
-	 * @return the subcounter of the Data Field Header.
-	 */
-	uint8_t getPacketSubcounter();
-	struct PUSTmMinimalHeader {
-		uint8_t version_type_ack;
-		uint8_t service_type;
-		uint8_t service_subtype;
-		uint8_t subcounter;
-	};
-
-	ReturnValue_t getPacketTime(timeval* timestamp);
-
-	ReturnValue_t getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size);
-
-	static void setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter);
-	/**
-	 * This struct defines the data structure of a PUS Telecommand Packet when
-	 * accessed via a pointer.
-	 * @ingroup tmtcpackets
-	 */
-	struct TmPacketMinimalPointer {
-		CCSDSPrimaryHeader primary;
-		PUSTmMinimalHeader data_field;
-		uint8_t rest;
-	};
-	//Must include a checksum and is therefore at least one larger than the above struct.
-	static const uint16_t MINIMUM_SIZE = sizeof(TmPacketMinimalPointer) +1;
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TmPacketMinimalPointer* tm_data;
-
-	static PacketTimestampInterpreterIF* timestampInterpreter;
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
+#define FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
+
+
+#include "../../tmtcpacket/SpacePacketBase.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+struct timeval;
+class PacketTimestampInterpreterIF;
+/**
+ * This is a minimal version of a PUS TmPacket without any variable field, or,
+ * in other words with Service Type, Subtype and subcounter only.
+ * This is required for handling TM packets with different APIDs with different
+ * secondary headers.
+ */
+class TmPacketMinimal : public SpacePacketBase {
+public:
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed and also
+	 * forwards the data pointer to the parent SpacePacketBase class.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	TmPacketMinimal( const uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TmPacketMinimal();
+	/**
+	 * This is a getter for the packet's PUS Service ID, which is the second
+	 * byte of the Data Field Header.
+	 * @return	The packet's PUS Service ID.
+	 */
+	uint8_t getService();
+	/**
+	 * This is a getter for the packet's PUS Service Subtype, which is the
+	 * third byte of the Data Field Header.
+	 * @return	The packet's PUS Service Subtype.
+	 */
+	uint8_t getSubService();
+	/**
+	 * Returns the subcounter.
+	 * @return the subcounter of the Data Field Header.
+	 */
+	uint8_t getPacketSubcounter();
+	struct PUSTmMinimalHeader {
+		uint8_t version_type_ack;
+		uint8_t service_type;
+		uint8_t service_subtype;
+		uint8_t subcounter;
+	};
+
+	ReturnValue_t getPacketTime(timeval* timestamp);
+
+	ReturnValue_t getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size);
+
+	static void setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter);
+	/**
+	 * This struct defines the data structure of a PUS Telecommand Packet when
+	 * accessed via a pointer.
+	 * @ingroup tmtcpackets
+	 */
+	struct TmPacketMinimalPointer {
+		CCSDSPrimaryHeader primary;
+		PUSTmMinimalHeader data_field;
+		uint8_t rest;
+	};
+	//Must include a checksum and is therefore at least one larger than the above struct.
+	static const uint16_t MINIMUM_SIZE = sizeof(TmPacketMinimalPointer) +1;
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet's data.
+	 *
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	TmPacketMinimalPointer* tm_data;
+
+	static PacketTimestampInterpreterIF* timestampInterpreter;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_ */
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 6eb852f05..e42f8cda8 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -1,145 +1,145 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcpacket/pus/TmPacketStored.h>
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <string.h>
-
-TmPacketStored::TmPacketStored(store_address_t setAddress) :
-		TmPacketBase(NULL), storeAddress(setAddress) {
-	setStoreAddress(storeAddress);
-}
-
-TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
-		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
-		TmPacketBase(NULL) {
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
-		return;
-	}
-	uint8_t *pData = NULL;
-	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
-			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
-
-	if (returnValue != store->RETURN_OK) {
-		sif::debug << "TM Packet Stored: Issue getting free storage" << std::endl;
-		checkAndReportLostTm();
-		return;
-	}
-	setData(pData);
-	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	memcpy(getSourceData(), headerData, headerSize);
-	memcpy(getSourceData() + headerSize, data, size);
-	setPacketDataLength(
-			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
-}
-
-// todo: Endianness flags as optional parameter?
-TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
-		SerializeIF *header) :
-		TmPacketBase(NULL) {
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
-		return;
-	}
-	size_t sourceDataSize = 0;
-	if (content != NULL) {
-		sourceDataSize += content->getSerializedSize();
-	}
-	if (header != NULL) {
-		sourceDataSize += header->getSerializedSize();
-	}
-	uint8_t *p_data = NULL;
-	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
-			(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
-	if (returnValue != store->RETURN_OK) {
-		checkAndReportLostTm();
-	}
-	setData(p_data);
-	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	uint8_t *putDataHere = getSourceData();
-	size_t size = 0;
-	if (header != NULL) {
-		header->serialize(&putDataHere, &size, sourceDataSize,
-				SerializeIF::Endianness::BIG);
-	}
-	if (content != NULL) {
-		content->serialize(&putDataHere, &size, sourceDataSize,
-				SerializeIF::Endianness::BIG);
-	}
-	setPacketDataLength(
-			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
-}
-
-store_address_t TmPacketStored::getStoreAddress() {
-	return storeAddress;
-}
-
-void TmPacketStored::deletePacket() {
-	store->deleteData(storeAddress);
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	setData(NULL);
-}
-
-void TmPacketStored::setStoreAddress(store_address_t setAddress) {
-	storeAddress = setAddress;
-	const uint8_t *temp_data = NULL;
-	size_t temp_size;
-	if (!checkAndSetStore()) {
-		return;
-	}
-	ReturnValue_t status = store->getData(storeAddress, &temp_data, &temp_size);
-	if (status == StorageManagerIF::RETURN_OK) {
-		setData(temp_data);
-	} else {
-		setData(NULL);
-		storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	}
-}
-
-bool TmPacketStored::checkAndSetStore() {
-	if (store == NULL) {
-		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
-		if (store == NULL) {
-			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
-					<< std::endl;
-			return false;
-		}
-	}
-	return true;
-}
-
-StorageManagerIF *TmPacketStored::store = NULL;
-InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
-
-ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
-		MessageQueueId_t sentFrom, bool doErrorReporting) {
-	if (getWholeData() == NULL) {
-		//SHOULDDO: More decent code.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	TmTcMessage tmMessage(getStoreAddress());
-	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
-			&tmMessage, sentFrom);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		deletePacket();
-		if (doErrorReporting) {
-			checkAndReportLostTm();
-		}
-		return result;
-	}
-	//SHOULDDO: In many cases, some counter is incremented for successfully sent packets. The check is often not done, but just incremented.
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-void TmPacketStored::checkAndReportLostTm() {
-	if (internalErrorReporter == NULL) {
-		internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-				objects::INTERNAL_ERROR_REPORTER);
-	}
-	if (internalErrorReporter != NULL) {
-		internalErrorReporter->lostTm();
-	}
-}
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TmPacketStored.h"
+#include "../../tmtcservices/TmTcMessage.h"
+#include <string.h>
+
+TmPacketStored::TmPacketStored(store_address_t setAddress) :
+		TmPacketBase(NULL), storeAddress(setAddress) {
+	setStoreAddress(storeAddress);
+}
+
+TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
+		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
+		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
+		TmPacketBase(NULL) {
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	uint8_t *pData = NULL;
+	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
+			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
+
+	if (returnValue != store->RETURN_OK) {
+		sif::debug << "TM Packet Stored: Issue getting free storage" << std::endl;
+		checkAndReportLostTm();
+		return;
+	}
+	setData(pData);
+	initializeTmPacket(apid, service, subservice, packetSubcounter);
+	memcpy(getSourceData(), headerData, headerSize);
+	memcpy(getSourceData() + headerSize, data, size);
+	setPacketDataLength(
+			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+}
+
+// todo: Endianness flags as optional parameter?
+TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
+		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
+		SerializeIF *header) :
+		TmPacketBase(NULL) {
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	size_t sourceDataSize = 0;
+	if (content != NULL) {
+		sourceDataSize += content->getSerializedSize();
+	}
+	if (header != NULL) {
+		sourceDataSize += header->getSerializedSize();
+	}
+	uint8_t *p_data = NULL;
+	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
+			(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
+	if (returnValue != store->RETURN_OK) {
+		checkAndReportLostTm();
+	}
+	setData(p_data);
+	initializeTmPacket(apid, service, subservice, packetSubcounter);
+	uint8_t *putDataHere = getSourceData();
+	size_t size = 0;
+	if (header != NULL) {
+		header->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
+	}
+	if (content != NULL) {
+		content->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
+	}
+	setPacketDataLength(
+			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+}
+
+store_address_t TmPacketStored::getStoreAddress() {
+	return storeAddress;
+}
+
+void TmPacketStored::deletePacket() {
+	store->deleteData(storeAddress);
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	setData(NULL);
+}
+
+void TmPacketStored::setStoreAddress(store_address_t setAddress) {
+	storeAddress = setAddress;
+	const uint8_t *temp_data = NULL;
+	size_t temp_size;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	ReturnValue_t status = store->getData(storeAddress, &temp_data, &temp_size);
+	if (status == StorageManagerIF::RETURN_OK) {
+		setData(temp_data);
+	} else {
+		setData(NULL);
+		storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	}
+}
+
+bool TmPacketStored::checkAndSetStore() {
+	if (store == NULL) {
+		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
+		if (store == NULL) {
+			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
+					<< std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+StorageManagerIF *TmPacketStored::store = NULL;
+InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
+
+ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
+		MessageQueueId_t sentFrom, bool doErrorReporting) {
+	if (getWholeData() == NULL) {
+		//SHOULDDO: More decent code.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	TmTcMessage tmMessage(getStoreAddress());
+	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
+			&tmMessage, sentFrom);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		deletePacket();
+		if (doErrorReporting) {
+			checkAndReportLostTm();
+		}
+		return result;
+	}
+	//SHOULDDO: In many cases, some counter is incremented for successfully sent packets. The check is often not done, but just incremented.
+	return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+void TmPacketStored::checkAndReportLostTm() {
+	if (internalErrorReporter == NULL) {
+		internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+				objects::INTERNAL_ERROR_REPORTER);
+	}
+	if (internalErrorReporter != NULL) {
+		internalErrorReporter->lostTm();
+	}
+}
diff --git a/tmtcpacket/pus/TmPacketStored.h b/tmtcpacket/pus/TmPacketStored.h
index eaa26ce75..195c3272e 100644
--- a/tmtcpacket/pus/TmPacketStored.h
+++ b/tmtcpacket/pus/TmPacketStored.h
@@ -1,96 +1,96 @@
-#ifndef TMPACKETSTORED_H_
-#define TMPACKETSTORED_H_
-
-#include <framework/serialize/SerializeIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tmtcpacket/pus/TmPacketBase.h>
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-/**
- *	This class generates a ECSS PUS Telemetry packet within a given
- *	intermediate storage.
- *	As most packets are passed between tasks with the help of a storage
- *	anyway, it seems logical to create a Packet-In-Storage access class
- *	which saves the user almost all storage handling operation.
- *	Packets can both be newly created with the class and be "linked" to
- *	packets in a store with the help of a storeAddress.
- *	@ingroup tmtcpackets
- */
-class TmPacketStored : public TmPacketBase {
-private:
-	/**
-	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
-	 * call tries to set it and throws an error message in case of failures.
-	 * The default store is objects::TM_STORE.
-	 */
-	static StorageManagerIF* store;
-
-	static InternalErrorReporterIF *internalErrorReporter;
-
-	/**
-	 * The address where the packet data of the object instance is stored.
-	 */
-	store_address_t storeAddress;
-	/**
-	 * A helper method to check if a store is assigned to the class.
-	 * If not, the method tries to retrieve the store from the global
-	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
-	 */
-	bool checkAndSetStore();
-
-	void checkAndReportLostTm();
-public:
-	/**
-	 * This is a default constructor which does not set the data pointer.
-	 * However, it does try to set the packet store.
-	 */
-	TmPacketStored( store_address_t setAddress );
-	/**
-	 * With this constructor, new space is allocated in the packet store and
-	 * a new PUS Telemetry Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet. The Application data is
-	 * passed in two parts, first a header, then a data field. This allows building a Telemetry
-	 * Packet from two separate data sources.
-	 * @param apid			Sets the packet's APID field.
-	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the source service.
-	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the source sub-service.
-	 * @param packet_counter	Sets the Packet counter field of this packet
-	 * @param data			The payload data to be copied to the Application Data Field
-	 * @param size			The amount of data to be copied.
-	 * @param headerData 	The header Data of the Application field; will be copied in front of data
-	 * @param headerSize	The size of the headerDataF
-	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter = 0, const uint8_t* data = NULL, uint32_t size = 0, const uint8_t* headerData = NULL, uint32_t headerSize = 0);
-	/**
-	 * Another ctor to directly pass structured content and header data to the packet to avoid additional buffers.
-	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter, SerializeIF* content, SerializeIF* header = NULL);
-	/**
-	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
-	 */
-	store_address_t getStoreAddress();
-	/**
-	 * With this call, the packet is deleted.
-	 * It removes itself from the store and sets its data pointer to NULL.
-	 */
-	void deletePacket();
-	/**
-	 * With this call, a packet can be linked to another store. This is useful
-	 * if the packet is a class member and used for more than one packet.
-	 * @param setAddress	The new packet id to link to.
-	 */
-	void setStoreAddress( store_address_t setAddress );
-
-	ReturnValue_t sendPacket( MessageQueueId_t destination, MessageQueueId_t sentFrom, bool doErrorReporting = true );
-};
-
-
-#endif /* TMPACKETSTORED_H_ */
+#ifndef TMPACKETSTORED_H_
+#define TMPACKETSTORED_H_
+
+#include "../../serialize/SerializeIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../tmtcpacket/pus/TmPacketBase.h"
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueSenderIF.h"
+
+/**
+ *	This class generates a ECSS PUS Telemetry packet within a given
+ *	intermediate storage.
+ *	As most packets are passed between tasks with the help of a storage
+ *	anyway, it seems logical to create a Packet-In-Storage access class
+ *	which saves the user almost all storage handling operation.
+ *	Packets can both be newly created with the class and be "linked" to
+ *	packets in a store with the help of a storeAddress.
+ *	@ingroup tmtcpackets
+ */
+class TmPacketStored : public TmPacketBase {
+private:
+	/**
+	 * This is a pointer to the store all instances of the class use.
+	 * If the store is not yet set (i.e. \c store is NULL), every constructor
+	 * call tries to set it and throws an error message in case of failures.
+	 * The default store is objects::TM_STORE.
+	 */
+	static StorageManagerIF* store;
+
+	static InternalErrorReporterIF *internalErrorReporter;
+
+	/**
+	 * The address where the packet data of the object instance is stored.
+	 */
+	store_address_t storeAddress;
+	/**
+	 * A helper method to check if a store is assigned to the class.
+	 * If not, the method tries to retrieve the store from the global
+	 * ObjectManager.
+	 * @return	@li	\c true if the store is linked or could be created.
+	 * 			@li \c false otherwise.
+	 */
+	bool checkAndSetStore();
+
+	void checkAndReportLostTm();
+public:
+	/**
+	 * This is a default constructor which does not set the data pointer.
+	 * However, it does try to set the packet store.
+	 */
+	TmPacketStored( store_address_t setAddress );
+	/**
+	 * With this constructor, new space is allocated in the packet store and
+	 * a new PUS Telemetry Packet is created there.
+	 * Packet Application Data passed in data is copied into the packet. The Application data is
+	 * passed in two parts, first a header, then a data field. This allows building a Telemetry
+	 * Packet from two separate data sources.
+	 * @param apid			Sets the packet's APID field.
+	 * @param service		Sets the packet's Service ID field.
+	 * 		This specifies the source service.
+	 * @param subservice	Sets the packet's Service Subtype field.
+	 * 		This specifies the source sub-service.
+	 * @param packet_counter	Sets the Packet counter field of this packet
+	 * @param data			The payload data to be copied to the Application Data Field
+	 * @param size			The amount of data to be copied.
+	 * @param headerData 	The header Data of the Application field; will be copied in front of data
+	 * @param headerSize	The size of the headerDataF
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter = 0, const uint8_t* data = NULL, uint32_t size = 0, const uint8_t* headerData = NULL, uint32_t headerSize = 0);
+	/**
+	 * Another ctor to directly pass structured content and header data to the packet to avoid additional buffers.
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter, SerializeIF* content, SerializeIF* header = NULL);
+	/**
+	 * This is a getter for the current store address of the packet.
+	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
+	 * 			the packet is not linked.
+	 */
+	store_address_t getStoreAddress();
+	/**
+	 * With this call, the packet is deleted.
+	 * It removes itself from the store and sets its data pointer to NULL.
+	 */
+	void deletePacket();
+	/**
+	 * With this call, a packet can be linked to another store. This is useful
+	 * if the packet is a class member and used for more than one packet.
+	 * @param setAddress	The new packet id to link to.
+	 */
+	void setStoreAddress( store_address_t setAddress );
+
+	ReturnValue_t sendPacket( MessageQueueId_t destination, MessageQueueId_t sentFrom, bool doErrorReporting = true );
+};
+
+
+#endif /* TMPACKETSTORED_H_ */
diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h
index 2878dd5d1..13928df5b 100644
--- a/tmtcservices/AcceptsTelecommandsIF.h
+++ b/tmtcservices/AcceptsTelecommandsIF.h
@@ -1,43 +1,43 @@
-#ifndef FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
-#define FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
-
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-/**
- * @brief 	This interface is implemented by classes that are sinks for
- * 			Telecommands.
- * @details	Any service receiving telecommands shall implement this interface
- * 			and thus make the service id and the receiving message queue public.
- */
-class AcceptsTelecommandsIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
-	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
-	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(5);
-	/**
-	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
-	 */
-	virtual ~AcceptsTelecommandsIF() {
-
-	}
-	/**
-	 * @brief	Getter for the service id.
-	 * @details	Any receiving service (at least any PUS service) shall have a
-	 * 			service ID. If the receiver can handle Telecommands, but for
-	 * 			some reason has no service id, it shall return 0.
-	 * @return	The service ID or 0.
-	 */
-	virtual uint16_t getIdentifier() = 0;
-	/**
-	 * @brief	This method returns the message queue id of the telecommand
-	 * 			receiving message queue.
-	 * @return	The telecommand reception message queue id.
-	 */
-	virtual MessageQueueId_t getRequestQueue() = 0;
-};
-
-
-#endif /* FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
+#define FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * @brief 	This interface is implemented by classes that are sinks for
+ * 			Telecommands.
+ * @details	Any service receiving telecommands shall implement this interface
+ * 			and thus make the service id and the receiving message queue public.
+ */
+class AcceptsTelecommandsIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
+	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
+	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(5);
+	/**
+	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
+	 */
+	virtual ~AcceptsTelecommandsIF() {
+
+	}
+	/**
+	 * @brief	Getter for the service id.
+	 * @details	Any receiving service (at least any PUS service) shall have a
+	 * 			service ID. If the receiver can handle Telecommands, but for
+	 * 			some reason has no service id, it shall return 0.
+	 * @return	The service ID or 0.
+	 */
+	virtual uint16_t getIdentifier() = 0;
+	/**
+	 * @brief	This method returns the message queue id of the telecommand
+	 * 			receiving message queue.
+	 * @return	The telecommand reception message queue id.
+	 */
+	virtual MessageQueueId_t getRequestQueue() = 0;
+};
+
+
+#endif /* FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_ */
diff --git a/tmtcservices/AcceptsTelemetryIF.h b/tmtcservices/AcceptsTelemetryIF.h
index 8c00b5c60..bcb386660 100644
--- a/tmtcservices/AcceptsTelemetryIF.h
+++ b/tmtcservices/AcceptsTelemetryIF.h
@@ -1,26 +1,26 @@
-#ifndef ACCEPTSTELEMETRYIF_H_
-#define ACCEPTSTELEMETRYIF_H_
-
-#include <framework/ipc/MessageQueueSenderIF.h>
-/**
- * @brief 	This interface is implemented by classes that are sinks for
- * 			Telemetry.
- * @details	Any object receiving telemetry shall implement this interface
- * 			and thus make the service id and the receiving message queue public.
- */
-class AcceptsTelemetryIF {
-public:
-	/**
-	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
-	 */
-	virtual ~AcceptsTelemetryIF() {
-	}
-	/**
-	 * @brief	This method returns the message queue id of the telemetry
-	 * 			receiving message queue.
-	 * @return	The telemetry reception message queue id.
-	 */
-	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) = 0;
-};
-
-#endif /* ACCEPTSTELEMETRYIF_H_ */
+#ifndef ACCEPTSTELEMETRYIF_H_
+#define ACCEPTSTELEMETRYIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+/**
+ * @brief 	This interface is implemented by classes that are sinks for
+ * 			Telemetry.
+ * @details	Any object receiving telemetry shall implement this interface
+ * 			and thus make the service id and the receiving message queue public.
+ */
+class AcceptsTelemetryIF {
+public:
+	/**
+	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
+	 */
+	virtual ~AcceptsTelemetryIF() {
+	}
+	/**
+	 * @brief	This method returns the message queue id of the telemetry
+	 * 			receiving message queue.
+	 * @return	The telemetry reception message queue id.
+	 */
+	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) = 0;
+};
+
+#endif /* ACCEPTSTELEMETRYIF_H_ */
diff --git a/tmtcservices/AcceptsVerifyMessageIF.h b/tmtcservices/AcceptsVerifyMessageIF.h
index fe8bb2886..a312390e6 100644
--- a/tmtcservices/AcceptsVerifyMessageIF.h
+++ b/tmtcservices/AcceptsVerifyMessageIF.h
@@ -1,15 +1,15 @@
-#ifndef ACCEPTSVERIFICATIONMESSAGEIF_H_
-#define ACCEPTSVERIFICATIONMESSAGEIF_H_
-
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class AcceptsVerifyMessageIF {
-public:
-	virtual ~AcceptsVerifyMessageIF() {
-
-	}
-	virtual MessageQueueId_t getVerificationQueue() = 0;
-};
-
-
-#endif /* ACCEPTSVERIFICATIONMESSAGEIF_H_ */
+#ifndef ACCEPTSVERIFICATIONMESSAGEIF_H_
+#define ACCEPTSVERIFICATIONMESSAGEIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+class AcceptsVerifyMessageIF {
+public:
+	virtual ~AcceptsVerifyMessageIF() {
+
+	}
+	virtual MessageQueueId_t getVerificationQueue() = 0;
+};
+
+
+#endif /* ACCEPTSVERIFICATIONMESSAGEIF_H_ */
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 330fd00f6..3325b10bf 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -1,427 +1,427 @@
-#include <framework/tcdistribution/PUSDistributorIF.h>
-#include <framework/tmtcservices/AcceptsTelemetryIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-#include <framework/tmtcservices/CommandingServiceBase.h>
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/tmtcpacket/pus/TcPacketStored.h>
-#include <framework/tmtcpacket/pus/TmPacketStored.h>
-
-object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
-object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
-
-CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
-		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
-		uint16_t commandTimeoutSeconds, size_t queueDepth) :
-		SystemObject(setObjectId), apid(apid), service(service),
-		timeoutSeconds(commandTimeoutSeconds),
-		commandMap(numberOfParallelCommands) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
-	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
-}
-
-void CommandingServiceBase::setPacketSource(object_id_t packetSource) {
-	this->packetSource = packetSource;
-}
-
-void CommandingServiceBase::setPacketDestination(
-		object_id_t packetDestination) {
-	this->packetDestination = packetDestination;
-}
-
-
-CommandingServiceBase::~CommandingServiceBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-	QueueFactory::instance()->deleteMessageQueue(requestQueue);
-}
-
-
-ReturnValue_t CommandingServiceBase::performOperation(uint8_t opCode) {
-	handleCommandQueue();
-	handleRequestQueue();
-	checkTimeout();
-	doPeriodicOperation();
-	return RETURN_OK;
-}
-
-
-uint16_t CommandingServiceBase::getIdentifier() {
-	return service;
-}
-
-
-MessageQueueId_t CommandingServiceBase::getRequestQueue() {
-	return requestQueue->getId();
-}
-
-
-ReturnValue_t CommandingServiceBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	if(packetDestination == objects::NO_OBJECT) {
-	    packetDestination = defaultPacketDestination;
-	}
-	AcceptsTelemetryIF* packetForwarding =
-			objectManager->get<AcceptsTelemetryIF>(packetDestination);
-
-	if(packetSource == objects::NO_OBJECT) {
-	    packetSource = defaultPacketSource;
-	}
-	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
-			packetSource);
-
-	if (packetForwarding == nullptr or distributor == nullptr) {
-	    sif::error << "CommandingServiceBase::intialize: Packet source or "
-	            "packet destination invalid!" << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	distributor->registerService(this);
-	requestQueue->setDefaultDestination(
-			packetForwarding->getReportReceptionQueue());
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-
-	if (IPCStore == nullptr or TCStore == nullptr) {
-	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
-	                    "not initialized yet!" << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	return RETURN_OK;
-
-}
-
-void CommandingServiceBase::handleCommandQueue() {
-	CommandMessage reply;
-	ReturnValue_t result = RETURN_FAILED;
-	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&reply)) {
-		handleCommandMessage(&reply);
-	}
-}
-
-
-void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
-	bool isStep = false;
-	CommandMessage nextCommand;
-	CommandMapIter iter = commandMap.find(reply->getSender());
-
-	// handle unrequested reply first
-	if (reply->getSender() == MessageQueueIF::NO_QUEUE or
-			iter == commandMap.end()) {
-		handleUnrequestedReply(reply);
-		return;
-	}
-	nextCommand.setCommand(CommandMessage::CMD_NONE);
-
-
-	// Implemented by child class, specifies what to do with reply.
-	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
-			&nextCommand, iter->objectId, &isStep);
-
-	/* If the child implementation does not implement special handling for
-	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
-	 * failure verification will be generated with the reason as the
-	 * return code and the initial command as failure parameter 1 */
-	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
-			(result == RETURN_FAILED or result == INVALID_REPLY)) {
-	    result = reply->getReplyRejectedReason();
-	    failureParameter1 = iter->command;
-	}
-
-	switch (result) {
-	case EXECUTION_COMPLETE:
-	case RETURN_OK:
-	case NO_STEP_MESSAGE:
-		// handle result of reply handler implemented by developer.
-		handleReplyHandlerResult(result, iter, &nextCommand, reply, isStep);
-		break;
-	case INVALID_REPLY:
-		//might be just an unrequested reply at a bad moment
-		handleUnrequestedReply(reply);
-		break;
-	default:
-		if (isStep) {
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					result, ++iter->step, failureParameter1,
-					failureParameter2);
-		} else {
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					result, 0, failureParameter1, failureParameter2);
-		}
-		failureParameter1 = 0;
-		failureParameter2 = 0;
-		checkAndExecuteFifo(iter);
-		break;
-	}
-
-}
-
-void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
-		CommandMapIter iter, CommandMessage* nextCommand,
-		CommandMessage* reply, bool& isStep) {
-	iter->command = nextCommand->getCommand();
-
-	// In case a new command is to be sent immediately, this is performed here.
-	// If no new command is sent, only analyse reply result by initializing
-	// sendResult as RETURN_OK
-	ReturnValue_t sendResult = RETURN_OK;
-	if (nextCommand->getCommand() != CommandMessage::CMD_NONE) {
-		sendResult = commandQueue->sendMessage(reply->getSender(),
-				nextCommand);
-	}
-
-	if (sendResult == RETURN_OK) {
-		if (isStep and result != NO_STEP_MESSAGE) {
-			verificationReporter.sendSuccessReport(
-					TC_VERIFY::PROGRESS_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, ++iter->step);
-		}
-		else {
-			verificationReporter.sendSuccessReport(
-					TC_VERIFY::COMPLETION_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, 0);
-			checkAndExecuteFifo(iter);
-		}
-	}
-	else {
-		if (isStep) {
-			nextCommand->clearCommandMessage();
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult,
-					++iter->step, failureParameter1, failureParameter2);
-		} else {
-			nextCommand->clearCommandMessage();
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult, 0,
-					failureParameter1, failureParameter2);
-		}
-		failureParameter1 = 0;
-		failureParameter2 = 0;
-		checkAndExecuteFifo(iter);
-	}
-}
-
-void CommandingServiceBase::handleRequestQueue() {
-	TmTcMessage message;
-	ReturnValue_t result;
-	store_address_t address;
-	TcPacketStored packet;
-	MessageQueueId_t queue;
-	object_id_t objectId;
-	for (result = requestQueue->receiveMessage(&message); result == RETURN_OK;
-			result = requestQueue->receiveMessage(&message)) {
-		address = message.getStorageId();
-		packet.setStoreAddress(address);
-
-		if ((packet.getSubService() == 0)
-				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
-			continue;
-		}
-		result = getMessageQueueAndObject(packet.getSubService(),
-				packet.getApplicationData(), packet.getApplicationDataSize(),
-				&queue, &objectId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, result);
-			continue;
-		}
-
-		//Is a command already active for the target object?
-		CommandMapIter iter;
-		iter = commandMap.find(queue);
-
-		if (iter != commandMap.end()) {
-			result = iter->fifo.insert(address);
-			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
-			}
-		} else {
-			CommandInfo newInfo; //Info will be set by startExecution if neccessary
-			newInfo.objectId = objectId;
-			result = commandMap.insert(queue, newInfo, &iter);
-			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, BUSY);
-			} else {
-				startExecution(&packet, iter);
-			}
-		}
-
-	}
-}
-
-
-ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
-		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
-		size_t headerSize) {
-	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-			this->tmPacketCounter, data, dataLen, headerData, headerSize);
-	ReturnValue_t result = tmPacketStored.sendPacket(
-			requestQueue->getDefaultDestination(), requestQueue->getId());
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		this->tmPacketCounter++;
-	}
-	return result;
-}
-
-
-ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
-        object_id_t objectId, const uint8_t *data, size_t dataLen) {
-    uint8_t buffer[sizeof(object_id_t)];
-    uint8_t* pBuffer = buffer;
-    size_t size = 0;
-    SerializeAdapter::serialize(&objectId, &pBuffer, &size,
-                sizeof(object_id_t), SerializeIF::Endianness::BIG);
-    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-            this->tmPacketCounter, data, dataLen, buffer, size);
-    ReturnValue_t result = tmPacketStored.sendPacket(
-            requestQueue->getDefaultDestination(), requestQueue->getId());
-    if (result == HasReturnvaluesIF::RETURN_OK) {
-        this->tmPacketCounter++;
-    }
-    return result;
-}
-
-
-ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
-        SerializeIF* content, SerializeIF* header) {
-    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-            this->tmPacketCounter, content, header);
-    ReturnValue_t result = tmPacketStored.sendPacket(
-            requestQueue->getDefaultDestination(), requestQueue->getId());
-    if (result == HasReturnvaluesIF::RETURN_OK) {
-        this->tmPacketCounter++;
-    }
-    return result;
-}
-
-
-void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
-        CommandMapIter iter) {
-    ReturnValue_t result = RETURN_OK;
-    CommandMessage command;
-    iter->subservice = storedPacket->getSubService();
-    result = prepareCommand(&command, iter->subservice,
-            storedPacket->getApplicationData(),
-            storedPacket->getApplicationDataSize(), &iter->state,
-            iter->objectId);
-
-    ReturnValue_t sendResult = RETURN_OK;
-	switch (result) {
-	case RETURN_OK:
-		if (command.getCommand() != CommandMessage::CMD_NONE) {
-			sendResult = commandQueue->sendMessage(iter.value->first,
-					&command);
-		}
-		if (sendResult == RETURN_OK) {
-			Clock::getUptime(&iter->uptimeOfStart);
-			iter->step = 0;
-			iter->subservice = storedPacket->getSubService();
-			iter->command = command.getCommand();
-			iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
-			iter->tcInfo.tcPacketId = storedPacket->getPacketId();
-			iter->tcInfo.tcSequenceControl =
-					storedPacket->getPacketSequenceControl();
-			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
-		} else {
-			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
-			checkAndExecuteFifo(iter);
-		}
-		break;
-	case EXECUTION_COMPLETE:
-		if (command.getCommand() != CommandMessage::CMD_NONE) {
-			//Fire-and-forget command.
-			sendResult = commandQueue->sendMessage(iter.value->first,
-					&command);
-		}
-		if (sendResult == RETURN_OK) {
-			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
-					storedPacket);
-			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
-			checkAndExecuteFifo(iter);
-		} else {
-			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
-			checkAndExecuteFifo(iter);
-		}
-		break;
-	default:
-		rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, result);
-		checkAndExecuteFifo(iter);
-		break;
-	}
-}
-
-
-void CommandingServiceBase::rejectPacket(uint8_t report_id,
-		TcPacketStored* packet, ReturnValue_t error_code) {
-	verificationReporter.sendFailureReport(report_id, packet, error_code);
-	packet->deletePacket();
-}
-
-
-void CommandingServiceBase::acceptPacket(uint8_t reportId,
-		TcPacketStored* packet) {
-	verificationReporter.sendSuccessReport(reportId, packet);
-	packet->deletePacket();
-}
-
-
-void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
-	store_address_t address;
-	if (iter->fifo.retrieve(&address) != RETURN_OK) {
-		commandMap.erase(&iter);
-	} else {
-		TcPacketStored newPacket(address);
-		startExecution(&newPacket, iter);
-	}
-}
-
-
-void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) {
-	reply->clearCommandMessage();
-}
-
-
-inline void CommandingServiceBase::doPeriodicOperation() {
-}
-
-MessageQueueId_t CommandingServiceBase::getCommandQueue() {
-	return commandQueue->getId();
-}
-
-void CommandingServiceBase::checkTimeout() {
-	uint32_t uptime;
-	Clock::getUptime(&uptime);
-	CommandMapIter iter;
-	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
-		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					TIMEOUT);
-			checkAndExecuteFifo(iter);
-		}
-	}
-}
-
-void CommandingServiceBase::setTaskIF(PeriodicTaskIF* task_) {
-    executingTask = task_;
-}
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+#include "../tmtcservices/CommandingServiceBase.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+
+object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
+
+CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
+		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
+		uint16_t commandTimeoutSeconds, size_t queueDepth) :
+		SystemObject(setObjectId), apid(apid), service(service),
+		timeoutSeconds(commandTimeoutSeconds),
+		commandMap(numberOfParallelCommands) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
+	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
+}
+
+void CommandingServiceBase::setPacketSource(object_id_t packetSource) {
+	this->packetSource = packetSource;
+}
+
+void CommandingServiceBase::setPacketDestination(
+		object_id_t packetDestination) {
+	this->packetDestination = packetDestination;
+}
+
+
+CommandingServiceBase::~CommandingServiceBase() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+	QueueFactory::instance()->deleteMessageQueue(requestQueue);
+}
+
+
+ReturnValue_t CommandingServiceBase::performOperation(uint8_t opCode) {
+	handleCommandQueue();
+	handleRequestQueue();
+	checkTimeout();
+	doPeriodicOperation();
+	return RETURN_OK;
+}
+
+
+uint16_t CommandingServiceBase::getIdentifier() {
+	return service;
+}
+
+
+MessageQueueId_t CommandingServiceBase::getRequestQueue() {
+	return requestQueue->getId();
+}
+
+
+ReturnValue_t CommandingServiceBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	if(packetDestination == objects::NO_OBJECT) {
+	    packetDestination = defaultPacketDestination;
+	}
+	AcceptsTelemetryIF* packetForwarding =
+			objectManager->get<AcceptsTelemetryIF>(packetDestination);
+
+	if(packetSource == objects::NO_OBJECT) {
+	    packetSource = defaultPacketSource;
+	}
+	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
+			packetSource);
+
+	if (packetForwarding == nullptr or distributor == nullptr) {
+	    sif::error << "CommandingServiceBase::intialize: Packet source or "
+	            "packet destination invalid!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	distributor->registerService(this);
+	requestQueue->setDefaultDestination(
+			packetForwarding->getReportReceptionQueue());
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+
+	if (IPCStore == nullptr or TCStore == nullptr) {
+	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
+	                    "not initialized yet!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	return RETURN_OK;
+
+}
+
+void CommandingServiceBase::handleCommandQueue() {
+	CommandMessage reply;
+	ReturnValue_t result = RETURN_FAILED;
+	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&reply)) {
+		handleCommandMessage(&reply);
+	}
+}
+
+
+void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
+	bool isStep = false;
+	CommandMessage nextCommand;
+	CommandMapIter iter = commandMap.find(reply->getSender());
+
+	// handle unrequested reply first
+	if (reply->getSender() == MessageQueueIF::NO_QUEUE or
+			iter == commandMap.end()) {
+		handleUnrequestedReply(reply);
+		return;
+	}
+	nextCommand.setCommand(CommandMessage::CMD_NONE);
+
+
+	// Implemented by child class, specifies what to do with reply.
+	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
+			&nextCommand, iter->objectId, &isStep);
+
+	/* If the child implementation does not implement special handling for
+	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
+	 * failure verification will be generated with the reason as the
+	 * return code and the initial command as failure parameter 1 */
+	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
+			(result == RETURN_FAILED or result == INVALID_REPLY)) {
+	    result = reply->getReplyRejectedReason();
+	    failureParameter1 = iter->command;
+	}
+
+	switch (result) {
+	case EXECUTION_COMPLETE:
+	case RETURN_OK:
+	case NO_STEP_MESSAGE:
+		// handle result of reply handler implemented by developer.
+		handleReplyHandlerResult(result, iter, &nextCommand, reply, isStep);
+		break;
+	case INVALID_REPLY:
+		//might be just an unrequested reply at a bad moment
+		handleUnrequestedReply(reply);
+		break;
+	default:
+		if (isStep) {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, ++iter->step, failureParameter1,
+					failureParameter2);
+		} else {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, 0, failureParameter1, failureParameter2);
+		}
+		failureParameter1 = 0;
+		failureParameter2 = 0;
+		checkAndExecuteFifo(iter);
+		break;
+	}
+
+}
+
+void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
+		CommandMapIter iter, CommandMessage* nextCommand,
+		CommandMessage* reply, bool& isStep) {
+	iter->command = nextCommand->getCommand();
+
+	// In case a new command is to be sent immediately, this is performed here.
+	// If no new command is sent, only analyse reply result by initializing
+	// sendResult as RETURN_OK
+	ReturnValue_t sendResult = RETURN_OK;
+	if (nextCommand->getCommand() != CommandMessage::CMD_NONE) {
+		sendResult = commandQueue->sendMessage(reply->getSender(),
+				nextCommand);
+	}
+
+	if (sendResult == RETURN_OK) {
+		if (isStep and result != NO_STEP_MESSAGE) {
+			verificationReporter.sendSuccessReport(
+					TC_VERIFY::PROGRESS_SUCCESS,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, ++iter->step);
+		}
+		else {
+			verificationReporter.sendSuccessReport(
+					TC_VERIFY::COMPLETION_SUCCESS,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, 0);
+			checkAndExecuteFifo(iter);
+		}
+	}
+	else {
+		if (isStep) {
+			nextCommand->clearCommandMessage();
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult,
+					++iter->step, failureParameter1, failureParameter2);
+		} else {
+			nextCommand->clearCommandMessage();
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult, 0,
+					failureParameter1, failureParameter2);
+		}
+		failureParameter1 = 0;
+		failureParameter2 = 0;
+		checkAndExecuteFifo(iter);
+	}
+}
+
+void CommandingServiceBase::handleRequestQueue() {
+	TmTcMessage message;
+	ReturnValue_t result;
+	store_address_t address;
+	TcPacketStored packet;
+	MessageQueueId_t queue;
+	object_id_t objectId;
+	for (result = requestQueue->receiveMessage(&message); result == RETURN_OK;
+			result = requestQueue->receiveMessage(&message)) {
+		address = message.getStorageId();
+		packet.setStoreAddress(address);
+
+		if ((packet.getSubService() == 0)
+				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
+			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
+			continue;
+		}
+		result = getMessageQueueAndObject(packet.getSubService(),
+				packet.getApplicationData(), packet.getApplicationDataSize(),
+				&queue, &objectId);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			rejectPacket(TC_VERIFY::START_FAILURE, &packet, result);
+			continue;
+		}
+
+		//Is a command already active for the target object?
+		CommandMapIter iter;
+		iter = commandMap.find(queue);
+
+		if (iter != commandMap.end()) {
+			result = iter->fifo.insert(address);
+			if (result != RETURN_OK) {
+				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
+			}
+		} else {
+			CommandInfo newInfo; //Info will be set by startExecution if neccessary
+			newInfo.objectId = objectId;
+			result = commandMap.insert(queue, newInfo, &iter);
+			if (result != RETURN_OK) {
+				rejectPacket(TC_VERIFY::START_FAILURE, &packet, BUSY);
+			} else {
+				startExecution(&packet, iter);
+			}
+		}
+
+	}
+}
+
+
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
+		size_t headerSize) {
+	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+			this->tmPacketCounter, data, dataLen, headerData, headerSize);
+	ReturnValue_t result = tmPacketStored.sendPacket(
+			requestQueue->getDefaultDestination(), requestQueue->getId());
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		this->tmPacketCounter++;
+	}
+	return result;
+}
+
+
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+        object_id_t objectId, const uint8_t *data, size_t dataLen) {
+    uint8_t buffer[sizeof(object_id_t)];
+    uint8_t* pBuffer = buffer;
+    size_t size = 0;
+    SerializeAdapter::serialize(&objectId, &pBuffer, &size,
+                sizeof(object_id_t), SerializeIF::Endianness::BIG);
+    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+            this->tmPacketCounter, data, dataLen, buffer, size);
+    ReturnValue_t result = tmPacketStored.sendPacket(
+            requestQueue->getDefaultDestination(), requestQueue->getId());
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        this->tmPacketCounter++;
+    }
+    return result;
+}
+
+
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+        SerializeIF* content, SerializeIF* header) {
+    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+            this->tmPacketCounter, content, header);
+    ReturnValue_t result = tmPacketStored.sendPacket(
+            requestQueue->getDefaultDestination(), requestQueue->getId());
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        this->tmPacketCounter++;
+    }
+    return result;
+}
+
+
+void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
+        CommandMapIter iter) {
+    ReturnValue_t result = RETURN_OK;
+    CommandMessage command;
+    iter->subservice = storedPacket->getSubService();
+    result = prepareCommand(&command, iter->subservice,
+            storedPacket->getApplicationData(),
+            storedPacket->getApplicationDataSize(), &iter->state,
+            iter->objectId);
+
+    ReturnValue_t sendResult = RETURN_OK;
+	switch (result) {
+	case RETURN_OK:
+		if (command.getCommand() != CommandMessage::CMD_NONE) {
+			sendResult = commandQueue->sendMessage(iter.value->first,
+					&command);
+		}
+		if (sendResult == RETURN_OK) {
+			Clock::getUptime(&iter->uptimeOfStart);
+			iter->step = 0;
+			iter->subservice = storedPacket->getSubService();
+			iter->command = command.getCommand();
+			iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
+			iter->tcInfo.tcPacketId = storedPacket->getPacketId();
+			iter->tcInfo.tcSequenceControl =
+					storedPacket->getPacketSequenceControl();
+			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
+		} else {
+			command.clearCommandMessage();
+			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			checkAndExecuteFifo(iter);
+		}
+		break;
+	case EXECUTION_COMPLETE:
+		if (command.getCommand() != CommandMessage::CMD_NONE) {
+			//Fire-and-forget command.
+			sendResult = commandQueue->sendMessage(iter.value->first,
+					&command);
+		}
+		if (sendResult == RETURN_OK) {
+			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
+					storedPacket);
+			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
+			checkAndExecuteFifo(iter);
+		} else {
+			command.clearCommandMessage();
+			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			checkAndExecuteFifo(iter);
+		}
+		break;
+	default:
+		rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, result);
+		checkAndExecuteFifo(iter);
+		break;
+	}
+}
+
+
+void CommandingServiceBase::rejectPacket(uint8_t report_id,
+		TcPacketStored* packet, ReturnValue_t error_code) {
+	verificationReporter.sendFailureReport(report_id, packet, error_code);
+	packet->deletePacket();
+}
+
+
+void CommandingServiceBase::acceptPacket(uint8_t reportId,
+		TcPacketStored* packet) {
+	verificationReporter.sendSuccessReport(reportId, packet);
+	packet->deletePacket();
+}
+
+
+void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
+	store_address_t address;
+	if (iter->fifo.retrieve(&address) != RETURN_OK) {
+		commandMap.erase(&iter);
+	} else {
+		TcPacketStored newPacket(address);
+		startExecution(&newPacket, iter);
+	}
+}
+
+
+void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) {
+	reply->clearCommandMessage();
+}
+
+
+inline void CommandingServiceBase::doPeriodicOperation() {
+}
+
+MessageQueueId_t CommandingServiceBase::getCommandQueue() {
+	return commandQueue->getId();
+}
+
+void CommandingServiceBase::checkTimeout() {
+	uint32_t uptime;
+	Clock::getUptime(&uptime);
+	CommandMapIter iter;
+	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
+		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					TIMEOUT);
+			checkAndExecuteFifo(iter);
+		}
+	}
+}
+
+void CommandingServiceBase::setTaskIF(PeriodicTaskIF* task_) {
+    executingTask = task_;
+}
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index b3a15985e..32173d81f 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -1,348 +1,348 @@
-#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-
-#include <framework/tmtcservices/VerificationReporter.h>
-#include <framework/ipc/CommandMessage.h>
-#include <framework/container/FixedMap.h>
-#include <framework/container/FIFO.h>
-#include <framework/serialize/SerializeIF.h>
-
-class TcPacketStored;
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @brief 	This class is the basis for all PUS Services, which have to
- * 			relay Telecommands to software bus.
- *
- * It manages Telecommand reception and the generation of Verification Reports
- * similar to PusServiceBase. This class is used if a telecommand can't be
- * handled immediately and must be relayed to the internal software bus.
- *   - isValidSubservice
- *   - getMessageQueueAndObject
- *   - prepareCommand
- *   - handleReply
- * @author gaisser
- * @ingroup pus_services
- */
-class CommandingServiceBase: public SystemObject,
-		public AcceptsTelecommandsIF,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
-	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t NO_STEP_MESSAGE = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t OBJECT_BUSY = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t INVALID_TC = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t INVALID_OBJECT = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t INVALID_REPLY = MAKE_RETURN_CODE(7);
-
-	/**
-	 * Class constructor. Initializes two important MessageQueues:
-	 * commandQueue for command reception and requestQueue for device reception
-	 * @param setObjectId
-	 * @param apid
-	 * @param service
-	 * @param numberOfParallelCommands
-	 * @param commandTimeout_seconds
-	 * @param setPacketSource
-	 * @param setPacketDestination
-	 * @param queueDepth
-	 */
-	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
-			uint8_t service, uint8_t numberOfParallelCommands,
-			uint16_t commandTimeoutSeconds, size_t queueDepth = 20);
-	virtual ~CommandingServiceBase();
-
-	/**
-	 * This setter can be used to set the packet source individually instead
-	 * of using the default static framework ID set in the factory.
-	 * This should be called at object initialization and not during run-time!
-	 * @param packetSource
-	 */
-	void setPacketSource(object_id_t packetSource);
-	/**
-	 * This setter can be used to set the packet destination individually
-	 * instead of using the default static framework ID set in the factory.
-	 * This should be called at object initialization and not during run-time!
-	 * @param packetDestination
-	 */
-	void setPacketDestination(object_id_t packetDestination);
-
-	/***
-	 * This is the periodically called function.
-	 * Handle request queue for external commands.
-	 * Handle command Queue for internal commands.
-	 * @param opCode is unused here at the moment
-	 * @return RETURN_OK
-	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-
-	virtual uint16_t getIdentifier();
-
-	/**
-	 * Returns the requestQueue MessageQueueId_t
-	 *
-	 * The requestQueue is the queue for external commands (TC)
-	 *
-	 * @return requestQueue messageQueueId_t
-	 */
-	virtual MessageQueueId_t getRequestQueue();
-
-	/**
-	 * Returns the commandQueue MessageQueueId_t
-	 *
-	 * Remember the CommandQueue is the queue for internal communication
-	 * @return commandQueue messageQueueId_t
-	 */
-	virtual MessageQueueId_t getCommandQueue();
-
-	virtual ReturnValue_t initialize() override;
-
-	/**
-	 * Implementation of ExecutableObjectIF function
-	 *
-	 * Used to setup the reference of the task, that executes this component
-	 * @param task Pointer to the taskIF of this task
-	 */
-	virtual void setTaskIF(PeriodicTaskIF* task) override;
-
-protected:
-	/**
-	 * Check the target subservice
-	 * @param subservice[in]
-	 * @return
-	 * -@c RETURN_OK Subservice valid, continue message handling
-     * -@c INVALID_SUBSERVICE if service is not known, rejects packet.
-	 */
-	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
-
-	/**
-	 * Once a TC Request is valid, the existence of the destination and its
-	 * target interface is checked and retrieved. The target message queue ID
-	 * can then be acquired by using the target interface.
-	 * @param subservice
-	 * @param tcData Application Data of TC Packet
-	 * @param tcDataLen
-	 * @param id MessageQueue ID is stored here
-	 * @param objectId Object ID is extracted and stored here
-	 * @return
-	 * - @c RETURN_OK Cotinue message handling
-	 * - @c RETURN_FAILED Reject the packet and generates a start failure
-	 *      verification
-	 */
-	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) = 0;
-
-	/**
-	 * After the Message Queue and Object ID are determined, the command is
-	 * prepared by using an implementation specific CommandMessage type
-	 * which is sent to the target object. It contains all necessary information
-	 * for the device to execute telecommands.
-	 * @param message [out] message which can be set and is sent to the object
-	 * @param subservice Subservice of the current communication
-	 * @param tcData Application data of command
-	 * @param tcDataLen Application data length
-	 * @param state [out/in] Setable state of the communication.
-	 * communication
-	 * @param objectId Target object ID
-	 * @return
-	 * - @c RETURN_OK to generate a verification start message
-	 * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
-	 *      verification message.
-	 * - @c Anything else rejects the packets and generates a start failure
-	 *      verification.
-	 */
-	virtual ReturnValue_t prepareCommand(CommandMessage* message,
-			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-			uint32_t *state, object_id_t objectId) = 0;
-
-	/**
-	 * This function is implemented by child services to specify how replies
-	 * to a command from another software component are handled.
-	 * @param reply
-	 * This is the reply in form of a generic read-only command message.
-	 * @param previousCommand
-	 * Command_t of related command
-	 * @param state [out/in]
-	 * Additional parameter which can be used to pass state information.
-	 * State of the communication
-	 * @param optionalNextCommand [out]
-	 * An optional next command which can be set in this function
-	 * @param objectId Source object ID
-	 * @param isStep Flag value to mark steps of command execution
-	 * @return
-	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
-	 *   generate TC verification success
-	 * - @c INVALID_REPLY Calls handleUnrequestedReply
-	 * - Anything else triggers a TC verification failure. If RETURN_FAILED or
-	 * 	 INVALID_REPLY is returned and the command ID is
-	 * 	 CommandMessage::REPLY_REJECTED, a failure verification message with
-	 * 	 the reason as the error parameter and the initial command as
-	 * 	 failure parameter 1 is generated.
-	 */
-	virtual ReturnValue_t handleReply(const CommandMessage* reply,
-			Command_t previousCommand, uint32_t *state,
-			CommandMessage* optionalNextCommand, object_id_t objectId,
-			bool *isStep) = 0;
-
-	/**
-	 * This function can be overidden to handle unrequested reply,
-	 * when the reply sender ID is unknown or is not found is the command map.
-	 * The default implementation will clear the command message and all
-	 * its contents.
-	 * @param reply
-	 * Reply which is non-const so the default implementation can clear the
-	 * message.
-	 */
-	virtual void handleUnrequestedReply(CommandMessage* reply);
-
-	virtual void doPeriodicOperation();
-
-
-	struct CommandInfo {
-		struct tcInfo {
-			uint8_t ackFlags;
-			uint16_t tcPacketId;
-			uint16_t tcSequenceControl;
-		} tcInfo;
-		uint32_t uptimeOfStart;
-		uint8_t step;
-		uint8_t subservice;
-		uint32_t state;
-		Command_t command;
-		object_id_t objectId;
-		FIFO<store_address_t, 3> fifo;
-	};
-
-	using CommandMapIter = FixedMap<MessageQueueId_t,
-	        CommandingServiceBase::CommandInfo>::Iterator;
-
-	const uint16_t apid;
-
-	const uint8_t service;
-
-	const uint16_t timeoutSeconds;
-
-	uint8_t tmPacketCounter = 0;
-
-	StorageManagerIF *IPCStore = nullptr;
-
-	StorageManagerIF *TCStore = nullptr;
-
-	MessageQueueIF* commandQueue = nullptr;
-
-	MessageQueueIF* requestQueue = nullptr;
-
-	VerificationReporter verificationReporter;
-
-	FixedMap<MessageQueueId_t, CommandInfo> commandMap;
-
-	/* May be set be children to return a more precise failure condition. */
-	uint32_t failureParameter1 = 0;
-	uint32_t failureParameter2 = 0;
-
-	static object_id_t defaultPacketSource;
-	object_id_t packetSource = objects::NO_OBJECT;
-	static object_id_t defaultPacketDestination;
-	object_id_t packetDestination = objects::NO_OBJECT;
-
-	/**
-	 * Pointer to the task which executes this component,
-	 * is invalid before setTaskIF was called.
-	 */
-	PeriodicTaskIF* executingTask = nullptr;
-
-	/**
-	 * @brief   Send TM data from pointer to data.
-	 *          If a header is supplied it is added before data
-	 * @param subservice Number of subservice
-	 * @param data Pointer to the data in the Packet
-	 * @param dataLen Lenght of data in the Packet
-	 * @param headerData HeaderData will be placed before data
-	 * @param headerSize Size of HeaderData
-	 */
-	ReturnValue_t sendTmPacket(uint8_t subservice, const uint8_t *data,
-	        size_t dataLen, const uint8_t* headerData = nullptr,
-	        size_t headerSize = 0);
-
-	/**
-	 * @brief   To send TM packets of objects that still need to be serialized
-	 *          and consist of an object ID with appended data.
-	 * @param subservice Number of subservice
-	 * @param objectId ObjectId is placed before data
-	 * @param data Data to append to the packet
-	 * @param dataLen Length of Data
-	 */
-	ReturnValue_t sendTmPacket(uint8_t subservice, object_id_t objectId,
-			const uint8_t *data, size_t dataLen);
-
-	/**
-	 * @brief   To send packets which are contained inside a class implementing
-	 *          SerializeIF.
-	 * @param subservice Number of subservice
-	 * @param content This is a pointer to the serialized packet
-	 * @param header Serialize IF header which will be placed before content
-	 */
-	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
-			SerializeIF* header = nullptr);
-
-	void checkAndExecuteFifo(CommandMapIter iter);
-
-private:
-	/**
-	 * This method handles internal execution of a command,
-	 * once it has been started by @sa{startExecution()} in the request
-	 * queue handler.
-	 * It handles replies generated by the devices and relayed by the specific
-	 * service implementation. This means that it determines further course of
-	 * action depending on the return values specified in the service
-	 * implementation.
-	 * This includes the generation of TC verification messages. Note that
-	 * the static framework object ID @c VerificationReporter::messageReceiver
-	 * needs to be set.
-	 *   - TM[1,5] Step Successs
-	 *   - TM[1,6] Step Failure
-	 *   - TM[1,7] Completion Success
-	 *   - TM[1,8] Completion Failure
-	 */
-	void handleCommandQueue();
-
-	/**
-	 * @brief       Handler function for request queue
-	 * @details
-	 * Sequence of request queue handling:
-	 * isValidSubservice -> getMessageQueueAndObject -> startExecution
-	 * Generates a Start Success Reports TM[1,3] in subfunction
-	 * @sa{startExecution()} or  a Start Failure Report TM[1,4] by using the
-	 * TC Verification Service.
-	 */
-	void handleRequestQueue();
-
-	void rejectPacket(uint8_t reportId, TcPacketStored* packet,
-			ReturnValue_t errorCode);
-
-	void acceptPacket(uint8_t reportId, TcPacketStored* packet);
-
-	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
-
-	void handleCommandMessage(CommandMessage* reply);
-	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
-			CommandMessage* nextCommand, CommandMessage* reply, bool& isStep);
-
-	void checkTimeout();
-};
-
-#endif /* COMMANDINGSERVICEBASE_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+
+#include "../tmtcservices/VerificationReporter.h"
+#include "../ipc/CommandMessage.h"
+#include "../container/FixedMap.h"
+#include "../container/FIFO.h"
+#include "../serialize/SerializeIF.h"
+
+class TcPacketStored;
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @brief 	This class is the basis for all PUS Services, which have to
+ * 			relay Telecommands to software bus.
+ *
+ * It manages Telecommand reception and the generation of Verification Reports
+ * similar to PusServiceBase. This class is used if a telecommand can't be
+ * handled immediately and must be relayed to the internal software bus.
+ *   - isValidSubservice
+ *   - getMessageQueueAndObject
+ *   - prepareCommand
+ *   - handleReply
+ * @author gaisser
+ * @ingroup pus_services
+ */
+class CommandingServiceBase: public SystemObject,
+		public AcceptsTelecommandsIF,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
+	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t NO_STEP_MESSAGE = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t OBJECT_BUSY = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t INVALID_TC = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t INVALID_OBJECT = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t INVALID_REPLY = MAKE_RETURN_CODE(7);
+
+	/**
+	 * Class constructor. Initializes two important MessageQueues:
+	 * commandQueue for command reception and requestQueue for device reception
+	 * @param setObjectId
+	 * @param apid
+	 * @param service
+	 * @param numberOfParallelCommands
+	 * @param commandTimeout_seconds
+	 * @param setPacketSource
+	 * @param setPacketDestination
+	 * @param queueDepth
+	 */
+	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
+			uint8_t service, uint8_t numberOfParallelCommands,
+			uint16_t commandTimeoutSeconds, size_t queueDepth = 20);
+	virtual ~CommandingServiceBase();
+
+	/**
+	 * This setter can be used to set the packet source individually instead
+	 * of using the default static framework ID set in the factory.
+	 * This should be called at object initialization and not during run-time!
+	 * @param packetSource
+	 */
+	void setPacketSource(object_id_t packetSource);
+	/**
+	 * This setter can be used to set the packet destination individually
+	 * instead of using the default static framework ID set in the factory.
+	 * This should be called at object initialization and not during run-time!
+	 * @param packetDestination
+	 */
+	void setPacketDestination(object_id_t packetDestination);
+
+	/***
+	 * This is the periodically called function.
+	 * Handle request queue for external commands.
+	 * Handle command Queue for internal commands.
+	 * @param opCode is unused here at the moment
+	 * @return RETURN_OK
+	 */
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+
+	virtual uint16_t getIdentifier();
+
+	/**
+	 * Returns the requestQueue MessageQueueId_t
+	 *
+	 * The requestQueue is the queue for external commands (TC)
+	 *
+	 * @return requestQueue messageQueueId_t
+	 */
+	virtual MessageQueueId_t getRequestQueue();
+
+	/**
+	 * Returns the commandQueue MessageQueueId_t
+	 *
+	 * Remember the CommandQueue is the queue for internal communication
+	 * @return commandQueue messageQueueId_t
+	 */
+	virtual MessageQueueId_t getCommandQueue();
+
+	virtual ReturnValue_t initialize() override;
+
+	/**
+	 * Implementation of ExecutableObjectIF function
+	 *
+	 * Used to setup the reference of the task, that executes this component
+	 * @param task Pointer to the taskIF of this task
+	 */
+	virtual void setTaskIF(PeriodicTaskIF* task) override;
+
+protected:
+	/**
+	 * Check the target subservice
+	 * @param subservice[in]
+	 * @return
+	 * -@c RETURN_OK Subservice valid, continue message handling
+     * -@c INVALID_SUBSERVICE if service is not known, rejects packet.
+	 */
+	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
+
+	/**
+	 * Once a TC Request is valid, the existence of the destination and its
+	 * target interface is checked and retrieved. The target message queue ID
+	 * can then be acquired by using the target interface.
+	 * @param subservice
+	 * @param tcData Application Data of TC Packet
+	 * @param tcDataLen
+	 * @param id MessageQueue ID is stored here
+	 * @param objectId Object ID is extracted and stored here
+	 * @return
+	 * - @c RETURN_OK Cotinue message handling
+	 * - @c RETURN_FAILED Reject the packet and generates a start failure
+	 *      verification
+	 */
+	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) = 0;
+
+	/**
+	 * After the Message Queue and Object ID are determined, the command is
+	 * prepared by using an implementation specific CommandMessage type
+	 * which is sent to the target object. It contains all necessary information
+	 * for the device to execute telecommands.
+	 * @param message [out] message which can be set and is sent to the object
+	 * @param subservice Subservice of the current communication
+	 * @param tcData Application data of command
+	 * @param tcDataLen Application data length
+	 * @param state [out/in] Setable state of the communication.
+	 * communication
+	 * @param objectId Target object ID
+	 * @return
+	 * - @c RETURN_OK to generate a verification start message
+	 * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
+	 *      verification message.
+	 * - @c Anything else rejects the packets and generates a start failure
+	 *      verification.
+	 */
+	virtual ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) = 0;
+
+	/**
+	 * This function is implemented by child services to specify how replies
+	 * to a command from another software component are handled.
+	 * @param reply
+	 * This is the reply in form of a generic read-only command message.
+	 * @param previousCommand
+	 * Command_t of related command
+	 * @param state [out/in]
+	 * Additional parameter which can be used to pass state information.
+	 * State of the communication
+	 * @param optionalNextCommand [out]
+	 * An optional next command which can be set in this function
+	 * @param objectId Source object ID
+	 * @param isStep Flag value to mark steps of command execution
+	 * @return
+	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
+	 *   generate TC verification success
+	 * - @c INVALID_REPLY Calls handleUnrequestedReply
+	 * - Anything else triggers a TC verification failure. If RETURN_FAILED or
+	 * 	 INVALID_REPLY is returned and the command ID is
+	 * 	 CommandMessage::REPLY_REJECTED, a failure verification message with
+	 * 	 the reason as the error parameter and the initial command as
+	 * 	 failure parameter 1 is generated.
+	 */
+	virtual ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) = 0;
+
+	/**
+	 * This function can be overidden to handle unrequested reply,
+	 * when the reply sender ID is unknown or is not found is the command map.
+	 * The default implementation will clear the command message and all
+	 * its contents.
+	 * @param reply
+	 * Reply which is non-const so the default implementation can clear the
+	 * message.
+	 */
+	virtual void handleUnrequestedReply(CommandMessage* reply);
+
+	virtual void doPeriodicOperation();
+
+
+	struct CommandInfo {
+		struct tcInfo {
+			uint8_t ackFlags;
+			uint16_t tcPacketId;
+			uint16_t tcSequenceControl;
+		} tcInfo;
+		uint32_t uptimeOfStart;
+		uint8_t step;
+		uint8_t subservice;
+		uint32_t state;
+		Command_t command;
+		object_id_t objectId;
+		FIFO<store_address_t, 3> fifo;
+	};
+
+	using CommandMapIter = FixedMap<MessageQueueId_t,
+	        CommandingServiceBase::CommandInfo>::Iterator;
+
+	const uint16_t apid;
+
+	const uint8_t service;
+
+	const uint16_t timeoutSeconds;
+
+	uint8_t tmPacketCounter = 0;
+
+	StorageManagerIF *IPCStore = nullptr;
+
+	StorageManagerIF *TCStore = nullptr;
+
+	MessageQueueIF* commandQueue = nullptr;
+
+	MessageQueueIF* requestQueue = nullptr;
+
+	VerificationReporter verificationReporter;
+
+	FixedMap<MessageQueueId_t, CommandInfo> commandMap;
+
+	/* May be set be children to return a more precise failure condition. */
+	uint32_t failureParameter1 = 0;
+	uint32_t failureParameter2 = 0;
+
+	static object_id_t defaultPacketSource;
+	object_id_t packetSource = objects::NO_OBJECT;
+	static object_id_t defaultPacketDestination;
+	object_id_t packetDestination = objects::NO_OBJECT;
+
+	/**
+	 * Pointer to the task which executes this component,
+	 * is invalid before setTaskIF was called.
+	 */
+	PeriodicTaskIF* executingTask = nullptr;
+
+	/**
+	 * @brief   Send TM data from pointer to data.
+	 *          If a header is supplied it is added before data
+	 * @param subservice Number of subservice
+	 * @param data Pointer to the data in the Packet
+	 * @param dataLen Lenght of data in the Packet
+	 * @param headerData HeaderData will be placed before data
+	 * @param headerSize Size of HeaderData
+	 */
+	ReturnValue_t sendTmPacket(uint8_t subservice, const uint8_t *data,
+	        size_t dataLen, const uint8_t* headerData = nullptr,
+	        size_t headerSize = 0);
+
+	/**
+	 * @brief   To send TM packets of objects that still need to be serialized
+	 *          and consist of an object ID with appended data.
+	 * @param subservice Number of subservice
+	 * @param objectId ObjectId is placed before data
+	 * @param data Data to append to the packet
+	 * @param dataLen Length of Data
+	 */
+	ReturnValue_t sendTmPacket(uint8_t subservice, object_id_t objectId,
+			const uint8_t *data, size_t dataLen);
+
+	/**
+	 * @brief   To send packets which are contained inside a class implementing
+	 *          SerializeIF.
+	 * @param subservice Number of subservice
+	 * @param content This is a pointer to the serialized packet
+	 * @param header Serialize IF header which will be placed before content
+	 */
+	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
+			SerializeIF* header = nullptr);
+
+	void checkAndExecuteFifo(CommandMapIter iter);
+
+private:
+	/**
+	 * This method handles internal execution of a command,
+	 * once it has been started by @sa{startExecution()} in the request
+	 * queue handler.
+	 * It handles replies generated by the devices and relayed by the specific
+	 * service implementation. This means that it determines further course of
+	 * action depending on the return values specified in the service
+	 * implementation.
+	 * This includes the generation of TC verification messages. Note that
+	 * the static framework object ID @c VerificationReporter::messageReceiver
+	 * needs to be set.
+	 *   - TM[1,5] Step Successs
+	 *   - TM[1,6] Step Failure
+	 *   - TM[1,7] Completion Success
+	 *   - TM[1,8] Completion Failure
+	 */
+	void handleCommandQueue();
+
+	/**
+	 * @brief       Handler function for request queue
+	 * @details
+	 * Sequence of request queue handling:
+	 * isValidSubservice -> getMessageQueueAndObject -> startExecution
+	 * Generates a Start Success Reports TM[1,3] in subfunction
+	 * @sa{startExecution()} or  a Start Failure Report TM[1,4] by using the
+	 * TC Verification Service.
+	 */
+	void handleRequestQueue();
+
+	void rejectPacket(uint8_t reportId, TcPacketStored* packet,
+			ReturnValue_t errorCode);
+
+	void acceptPacket(uint8_t reportId, TcPacketStored* packet);
+
+	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
+
+	void handleCommandMessage(CommandMessage* reply);
+	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
+			CommandMessage* nextCommand, CommandMessage* reply, bool& isStep);
+
+	void checkTimeout();
+};
+
+#endif /* COMMANDINGSERVICEBASE_H_ */
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index 3dd34a84b..f9a0fc577 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -1,114 +1,114 @@
-#include <framework/tmtcservices/PusParser.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-PusParser::PusParser(uint16_t maxExpectedPusPackets,
-		bool storeSplitPackets): indexSizePairFIFO(maxExpectedPusPackets) {
-}
-
-ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
-		size_t frameSize) {
-	if(frame == nullptr or frameSize < 5) {
-		sif::error << "PusParser::parsePusPackets: Frame invalid!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(indexSizePairFIFO.full()) {
-		sif::error << "PusParser::parsePusPackets: FIFO is full!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	size_t lengthField = frame[4] << 8 | frame[5];
-
-	if(lengthField == 0) {
-		return NO_PACKET_FOUND;
-	}
-
-	size_t packetSize = lengthField + 7;
-	// sif::debug << frameSize << std::endl;
-	// Size of a pus packet is the value in the packet length field plus 7.
-	if(packetSize > frameSize) {
-		if(storeSplitPackets) {
-			indexSizePairFIFO.insert(indexSizePair(0, frameSize));
-		}
-		else {
-			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
-					"larger than remaining frame," << std::endl;
-			sif::debug << "Throwing away packet. Detected packet size: "
-					<< packetSize << std::endl;
-		}
-		return SPLIT_PACKET;
-	}
-	else {
-		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
-		if(packetSize == frameSize) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-
-	// packet size is smaller than frame size, parse for more packets.
-	return readMultiplePackets(frame, frameSize, packetSize);
-}
-
-ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
-		size_t frameSize, size_t startIndex) {
-	while (startIndex < frameSize) {
-		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-DynamicFIFO<PusParser::indexSizePair>* PusParser::fifo(){
-	return &indexSizePairFIFO;
-}
-
-PusParser::indexSizePair PusParser::getNextFifoPair() {
-	indexSizePair nextIndexSizePair;
-	indexSizePairFIFO.retrieve(&nextIndexSizePair);
-	return nextIndexSizePair;
-}
-
-ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
-		size_t frameSize, size_t& currentIndex) {
-	// sif::debug << startIndex << std::endl;
-    if(currentIndex + 5 > frameSize) {
-        currentIndex = frameSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-	uint16_t lengthField = frame[currentIndex + 4] << 8 |
-			frame[currentIndex + 5];
-	if(lengthField == 0) {
-		// It is assumed that no packet follows.
-		currentIndex = frameSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	size_t nextPacketSize = lengthField + 7;
-	size_t remainingSize = frameSize - currentIndex;
-	if(nextPacketSize > remainingSize)
-	{
-		if(storeSplitPackets) {
-			indexSizePairFIFO.insert(indexSizePair(currentIndex, remainingSize));
-		}
-		else {
-			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
-					"larger than remaining frame," << std::endl;
-			sif::debug << "Throwing away packet. Detected packet size: "
-					<< nextPacketSize << std::endl;
-		}
-		return SPLIT_PACKET;
-	}
-
-	ReturnValue_t result = indexSizePairFIFO.insert(indexSizePair(currentIndex,
-			nextPacketSize));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		// FIFO full.
-		sif::debug << "PusParser: Issue inserting into start index size "
-		        "FIFO, it is full!" << std::endl;
-	}
-	currentIndex += nextPacketSize;
-
-	return result;
-}
+#include "../tmtcservices/PusParser.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+PusParser::PusParser(uint16_t maxExpectedPusPackets,
+		bool storeSplitPackets): indexSizePairFIFO(maxExpectedPusPackets) {
+}
+
+ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
+		size_t frameSize) {
+	if(frame == nullptr or frameSize < 5) {
+		sif::error << "PusParser::parsePusPackets: Frame invalid!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(indexSizePairFIFO.full()) {
+		sif::error << "PusParser::parsePusPackets: FIFO is full!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	size_t lengthField = frame[4] << 8 | frame[5];
+
+	if(lengthField == 0) {
+		return NO_PACKET_FOUND;
+	}
+
+	size_t packetSize = lengthField + 7;
+	// sif::debug << frameSize << std::endl;
+	// Size of a pus packet is the value in the packet length field plus 7.
+	if(packetSize > frameSize) {
+		if(storeSplitPackets) {
+			indexSizePairFIFO.insert(indexSizePair(0, frameSize));
+		}
+		else {
+			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
+					"larger than remaining frame," << std::endl;
+			sif::debug << "Throwing away packet. Detected packet size: "
+					<< packetSize << std::endl;
+		}
+		return SPLIT_PACKET;
+	}
+	else {
+		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
+		if(packetSize == frameSize) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+
+	// packet size is smaller than frame size, parse for more packets.
+	return readMultiplePackets(frame, frameSize, packetSize);
+}
+
+ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
+		size_t frameSize, size_t startIndex) {
+	while (startIndex < frameSize) {
+		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+DynamicFIFO<PusParser::indexSizePair>* PusParser::fifo(){
+	return &indexSizePairFIFO;
+}
+
+PusParser::indexSizePair PusParser::getNextFifoPair() {
+	indexSizePair nextIndexSizePair;
+	indexSizePairFIFO.retrieve(&nextIndexSizePair);
+	return nextIndexSizePair;
+}
+
+ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
+		size_t frameSize, size_t& currentIndex) {
+	// sif::debug << startIndex << std::endl;
+    if(currentIndex + 5 > frameSize) {
+        currentIndex = frameSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+	uint16_t lengthField = frame[currentIndex + 4] << 8 |
+			frame[currentIndex + 5];
+	if(lengthField == 0) {
+		// It is assumed that no packet follows.
+		currentIndex = frameSize;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	size_t nextPacketSize = lengthField + 7;
+	size_t remainingSize = frameSize - currentIndex;
+	if(nextPacketSize > remainingSize)
+	{
+		if(storeSplitPackets) {
+			indexSizePairFIFO.insert(indexSizePair(currentIndex, remainingSize));
+		}
+		else {
+			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
+					"larger than remaining frame," << std::endl;
+			sif::debug << "Throwing away packet. Detected packet size: "
+					<< nextPacketSize << std::endl;
+		}
+		return SPLIT_PACKET;
+	}
+
+	ReturnValue_t result = indexSizePairFIFO.insert(indexSizePair(currentIndex,
+			nextPacketSize));
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		// FIFO full.
+		sif::debug << "PusParser: Issue inserting into start index size "
+		        "FIFO, it is full!" << std::endl;
+	}
+	currentIndex += nextPacketSize;
+
+	return result;
+}
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
index d59673f68..24cba0c00 100644
--- a/tmtcservices/PusParser.h
+++ b/tmtcservices/PusParser.h
@@ -1,82 +1,82 @@
-#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
-#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
-
-#include <framework/container/DynamicFIFO.h>
-#include <utility>
-#include <cstdint>
-
-/**
- * @brief	This small helper class scans a given buffer for PUS packets.
- * 			Can be used if PUS packets are serialized in a tightly packed frame.
- * @details
- * The parser uses the payload length field of PUS packets to find
- * the respective PUS packet sizes.
- *
- * The parser parses a buffer by taking a pointer and the maximum size to scan.
- * If PUS packets are found, they are stored in a FIFO which stores pairs
- * consisting of the index in the buffer and the respective packet sizes.
- *
- * If the parser detects split packets (which means that the size of the
- * next packet is larger than the remaining size to scan), it can either
- * store that split packet or throw away the packet.
- */
-class PusParser {
-public:
-	//! The first entry is the index inside the buffer while the second index
-	//! is the size of the PUS packet starting at that index.
-	using indexSizePair = std::pair<size_t, size_t>;
-
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
-	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
-	static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);
-	/**
-	 * Parser constructor.
-	 * @param maxExpectedPusPackets
-	 * Maximum expected number of PUS packets. A good estimate is to divide
-	 * the frame size by the minimum size of a PUS packet (12 bytes)
-	 * @param storeSplitPackets
-	 * Specifies whether split packets are also stored inside the FIFO,
-	 * with the size being the remaining frame size.
-	 */
-	PusParser(uint16_t maxExpectedPusPackets, bool storeSplitPackets);
-
-	/**
-	 * Parse a given frame for PUS packets
-	 * @param frame
-	 * @param frameSize
-	 * @return -@c NO_PACKET_FOUND if no packet was found.
-	 */
-	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
-
-	/**
-	 * Accessor function to get a reference to the internal FIFO which
-	 * stores pairs of indexi and packet sizes. This FIFO is filled
-	 * by the parsePusPackets() function.
-	 * @return
-	 */
-	DynamicFIFO<indexSizePair>* fifo();
-
-	/**
-	 * Retrieve the next index and packet size pair from the FIFO.
-	 * This also removed it from the FIFO. Please note that if the FIFO
-	 * is empty, an empty pair will be returned.
-	 * @return
-	 */
-	indexSizePair getNextFifoPair();
-
-private:
-	/** A FIFO is used to store information about multiple PUS packets
-	 * inside the receive buffer. The maximum number of entries is defined
-	 * by the first constructor argument.
-	 */
-	DynamicFIFO<indexSizePair> indexSizePairFIFO;
-
-	bool storeSplitPackets = false;
-
-	ReturnValue_t readMultiplePackets(const uint8_t *frame, size_t frameSize,
-			size_t startIndex);
-	ReturnValue_t readNextPacket(const uint8_t *frame,
-			size_t frameSize, size_t& startIndex);
-};
-
-#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
+#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
+
+#include "../container/DynamicFIFO.h"
+#include <utility>
+#include <cstdint>
+
+/**
+ * @brief	This small helper class scans a given buffer for PUS packets.
+ * 			Can be used if PUS packets are serialized in a tightly packed frame.
+ * @details
+ * The parser uses the payload length field of PUS packets to find
+ * the respective PUS packet sizes.
+ *
+ * The parser parses a buffer by taking a pointer and the maximum size to scan.
+ * If PUS packets are found, they are stored in a FIFO which stores pairs
+ * consisting of the index in the buffer and the respective packet sizes.
+ *
+ * If the parser detects split packets (which means that the size of the
+ * next packet is larger than the remaining size to scan), it can either
+ * store that split packet or throw away the packet.
+ */
+class PusParser {
+public:
+	//! The first entry is the index inside the buffer while the second index
+	//! is the size of the PUS packet starting at that index.
+	using indexSizePair = std::pair<size_t, size_t>;
+
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
+	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
+	static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);
+	/**
+	 * Parser constructor.
+	 * @param maxExpectedPusPackets
+	 * Maximum expected number of PUS packets. A good estimate is to divide
+	 * the frame size by the minimum size of a PUS packet (12 bytes)
+	 * @param storeSplitPackets
+	 * Specifies whether split packets are also stored inside the FIFO,
+	 * with the size being the remaining frame size.
+	 */
+	PusParser(uint16_t maxExpectedPusPackets, bool storeSplitPackets);
+
+	/**
+	 * Parse a given frame for PUS packets
+	 * @param frame
+	 * @param frameSize
+	 * @return -@c NO_PACKET_FOUND if no packet was found.
+	 */
+	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
+
+	/**
+	 * Accessor function to get a reference to the internal FIFO which
+	 * stores pairs of indexi and packet sizes. This FIFO is filled
+	 * by the parsePusPackets() function.
+	 * @return
+	 */
+	DynamicFIFO<indexSizePair>* fifo();
+
+	/**
+	 * Retrieve the next index and packet size pair from the FIFO.
+	 * This also removed it from the FIFO. Please note that if the FIFO
+	 * is empty, an empty pair will be returned.
+	 * @return
+	 */
+	indexSizePair getNextFifoPair();
+
+private:
+	/** A FIFO is used to store information about multiple PUS packets
+	 * inside the receive buffer. The maximum number of entries is defined
+	 * by the first constructor argument.
+	 */
+	DynamicFIFO<indexSizePair> indexSizePairFIFO;
+
+	bool storeSplitPackets = false;
+
+	ReturnValue_t readMultiplePackets(const uint8_t *frame, size_t frameSize,
+			size_t startIndex);
+	ReturnValue_t readNextPacket(const uint8_t *frame,
+			size_t frameSize, size_t& startIndex);
+};
+
+#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index 877eff3e6..a8b74e392 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -1,123 +1,123 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tcdistribution/PUSDistributorIF.h>
-#include <framework/tmtcservices/AcceptsTelemetryIF.h>
-#include <framework/tmtcservices/PusServiceBase.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <framework/ipc/QueueFactory.h>
-
-object_id_t PusServiceBase::packetSource = 0;
-object_id_t PusServiceBase::packetDestination = 0;
-
-PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid,
-		uint8_t setServiceId) :
-		SystemObject(setObjectId), apid(setApid), serviceId(setServiceId) {
-	requestQueue = QueueFactory::instance()->
-			createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
-}
-
-PusServiceBase::~PusServiceBase() {
-	QueueFactory::instance()->deleteMessageQueue(requestQueue);
-}
-
-ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
-	handleRequestQueue();
-	ReturnValue_t result = this->performService();
-	if (result != RETURN_OK) {
-		sif::error << "PusService " << (uint16_t) this->serviceId
-				<< ": performService returned with " << (int16_t) result
-				<< std::endl;
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle) {
-    this->taskHandle = taskHandle;
-}
-
-void PusServiceBase::handleRequestQueue() {
-	TmTcMessage message;
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
-		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
-//		if(status != MessageQueueIF::EMPTY) {
-//			sif::debug << "PusServiceBase::performOperation: Receiving from "
-//					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
-//					<< std::setfill('0') << this->requestQueue->getId()
-//					<< std::dec << " returned: " << status << std::setfill(' ')
-//					<<  std::endl;
-//		}
-
-		if (status == RETURN_OK) {
-			this->currentPacket.setStoreAddress(message.getStorageId());
-			//info << "Service " << (uint16_t) this->serviceId <<
-			//     ": new packet!" << std::endl;
-
-			result = this->handleRequest(currentPacket.getSubService());
-
-			// debug << "Service " << (uint16_t)this->serviceId <<
-			//    ": handleRequest returned: " << (int)return_code << std::endl;
-			if (result == RETURN_OK) {
-				this->verifyReporter.sendSuccessReport(
-						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
-			}
-			else {
-				this->verifyReporter.sendFailureReport(
-						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
-						result, 0, errorParameter1, errorParameter2);
-			}
-			this->currentPacket.deletePacket();
-			errorParameter1 = 0;
-			errorParameter2 = 0;
-		}
-		else if (status == MessageQueueIF::EMPTY) {
-			status = RETURN_OK;
-			// debug << "PusService " << (uint16_t)this->serviceId <<
-			//      ": no new packet." << std::endl;
-			break;
-		}
-		else {
-			sif::error << "PusServiceBase::performOperation: Service "
-					<< this->serviceId << ": Error receiving packet. Code: "
-					<< std::hex << status << std::dec << std::endl;
-		}
-	}
-}
-
-uint16_t PusServiceBase::getIdentifier() {
-	return this->serviceId;
-}
-
-MessageQueueId_t PusServiceBase::getRequestQueue() {
-	return this->requestQueue->getId();
-}
-
-ReturnValue_t PusServiceBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	AcceptsTelemetryIF* destService = objectManager->get<AcceptsTelemetryIF>(
-			packetDestination);
-	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
-			packetSource);
-	if (destService == nullptr or distributor == nullptr) {
-		sif::error << "PusServiceBase::PusServiceBase: Service "
-				<< this->serviceId << ": Configuration error. Make sure "
-				<<	"packetSource and packetDestination are defined correctly"
-				<< std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	this->requestQueue->setDefaultDestination(
-			destService->getReportReceptionQueue());
-	distributor->registerService(this);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
-    // If task parameters, for example task frequency are required, this
-    // function should be overriden and the system object task IF can
-    // be used to get those parameters.
-    return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../tmtcservices/PusServiceBase.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+
+object_id_t PusServiceBase::packetSource = 0;
+object_id_t PusServiceBase::packetDestination = 0;
+
+PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid,
+		uint8_t setServiceId) :
+		SystemObject(setObjectId), apid(setApid), serviceId(setServiceId) {
+	requestQueue = QueueFactory::instance()->
+			createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
+}
+
+PusServiceBase::~PusServiceBase() {
+	QueueFactory::instance()->deleteMessageQueue(requestQueue);
+}
+
+ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
+	handleRequestQueue();
+	ReturnValue_t result = this->performService();
+	if (result != RETURN_OK) {
+		sif::error << "PusService " << (uint16_t) this->serviceId
+				<< ": performService returned with " << (int16_t) result
+				<< std::endl;
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle) {
+    this->taskHandle = taskHandle;
+}
+
+void PusServiceBase::handleRequestQueue() {
+	TmTcMessage message;
+	ReturnValue_t result = RETURN_FAILED;
+	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
+		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
+//		if(status != MessageQueueIF::EMPTY) {
+//			sif::debug << "PusServiceBase::performOperation: Receiving from "
+//					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
+//					<< std::setfill('0') << this->requestQueue->getId()
+//					<< std::dec << " returned: " << status << std::setfill(' ')
+//					<<  std::endl;
+//		}
+
+		if (status == RETURN_OK) {
+			this->currentPacket.setStoreAddress(message.getStorageId());
+			//info << "Service " << (uint16_t) this->serviceId <<
+			//     ": new packet!" << std::endl;
+
+			result = this->handleRequest(currentPacket.getSubService());
+
+			// debug << "Service " << (uint16_t)this->serviceId <<
+			//    ": handleRequest returned: " << (int)return_code << std::endl;
+			if (result == RETURN_OK) {
+				this->verifyReporter.sendSuccessReport(
+						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
+			}
+			else {
+				this->verifyReporter.sendFailureReport(
+						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
+						result, 0, errorParameter1, errorParameter2);
+			}
+			this->currentPacket.deletePacket();
+			errorParameter1 = 0;
+			errorParameter2 = 0;
+		}
+		else if (status == MessageQueueIF::EMPTY) {
+			status = RETURN_OK;
+			// debug << "PusService " << (uint16_t)this->serviceId <<
+			//      ": no new packet." << std::endl;
+			break;
+		}
+		else {
+			sif::error << "PusServiceBase::performOperation: Service "
+					<< this->serviceId << ": Error receiving packet. Code: "
+					<< std::hex << status << std::dec << std::endl;
+		}
+	}
+}
+
+uint16_t PusServiceBase::getIdentifier() {
+	return this->serviceId;
+}
+
+MessageQueueId_t PusServiceBase::getRequestQueue() {
+	return this->requestQueue->getId();
+}
+
+ReturnValue_t PusServiceBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	AcceptsTelemetryIF* destService = objectManager->get<AcceptsTelemetryIF>(
+			packetDestination);
+	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
+			packetSource);
+	if (destService == nullptr or distributor == nullptr) {
+		sif::error << "PusServiceBase::PusServiceBase: Service "
+				<< this->serviceId << ": Configuration error. Make sure "
+				<<	"packetSource and packetDestination are defined correctly"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	this->requestQueue->setDefaultDestination(
+			destService->getReportReceptionQueue());
+	distributor->registerService(this);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
+    // If task parameters, for example task frequency are required, this
+    // function should be overriden and the system object task IF can
+    // be used to get those parameters.
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 6d3d9bac6..f94312758 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -1,159 +1,159 @@
-#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/tmtcpacket/pus/TcPacketStored.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-#include <framework/tmtcservices/VerificationReporter.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @defgroup pus_services PUS Service Framework
- * These group contains all implementations of PUS Services in the OBSW.
- * Most of the Services are directly taken from the ECSS PUS Standard.
- */
-
-/**
- * @brief 	This class is the basis for all PUS Services,
- * 			which can immediately process Telecommand Packets.
- * @details
- * It manages Telecommand reception and the generation of Verification Reports.
- * Every class that inherits from this abstract class has to implement
- * handleRequest and performService. Services that are created with this
- * Base class have to handle any kind of request immediately on reception.
- * All PUS Services are System Objects, so an Object ID needs to be specified
- * on construction.
- * @ingroup pus_services
- */
-class PusServiceBase : public ExecutableObjectIF,
-        public AcceptsTelecommandsIF,
-        public SystemObject,
-        public HasReturnvaluesIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	/**
-	 * @brief	The passed values are set, but inter-object initialization is
-	 * 			done in the initialize method.
-	 * @param setObjectId
-	 * The system object identifier of this Service instance.
-	 * @param setApid
-	 * The APID the Service is instantiated for.
-	 * @param setServiceId
-	 * The Service Identifier as specified in ECSS PUS.
-	 */
-	PusServiceBase(	object_id_t setObjectId, uint16_t setApid,
-			uint8_t setServiceId);
-	/**
-	 * The destructor is empty.
-	 */
-	virtual ~PusServiceBase();
-	/**
-	 * @brief 	The handleRequest method shall handle any kind of Telecommand
-	 * 			Request immediately.
-	 * @details
-	 * Implemetations can take the Telecommand in currentPacket and perform
-	 * any kind of operation.
-	 * They may send additional "Start Success (1,3)" messages with the
-	 * verifyReporter, but Completion Success or Failure Reports are generated
-	 * automatically after execution of this method.
-	 *
-	 * If a Telecommand can not be executed within one call cycle,
-	 * this Base class is not the right parent.
-	 *
-	 * The child class may add additional error information by setting
-	 * #errorParameters which aren attached to the generated verification
-	 * message.
-	 *
-	 * Subservice checking should be implemented in this method.
-	 *
-	 * @return	The returned status_code is directly taken as main error code
-	 * 			in the Verification Report.
-	 * 			On success, RETURN_OK shall be returned.
-	 */
-	virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
-	/**
-	 * In performService, implementations can handle periodic,
-	 * non-TC-triggered activities.
-	 * The performService method is always called.
-	 * @return	Currently, everything other that RETURN_OK only triggers
-	 * 			diagnostic output.
-	 */
-	virtual ReturnValue_t performService() = 0;
-	/**
-	 * This method implements the typical activity of a simple PUS Service.
-	 * It checks for new requests, and, if found, calls handleRequest, sends
-	 * completion verification messages and deletes
-	 * the TC requests afterwards.
-	 * performService is always executed afterwards.
-	 * @return	@c RETURN_OK if the periodic performService was successful.
-	 * 			@c RETURN_FAILED else.
-	 */
-	ReturnValue_t performOperation(uint8_t opCode) override;
-	virtual uint16_t getIdentifier() override;
-	MessageQueueId_t getRequestQueue() override;
-	virtual ReturnValue_t initialize() override;
-
-	virtual void setTaskIF(PeriodicTaskIF* taskHandle) override;
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
-protected:
-	/**
-	 * @brief   Handle to the underlying task
-	 * @details
-	 * Will be set by setTaskIF(), which is called on task creation.
-	 */
-	PeriodicTaskIF* taskHandle = nullptr;
-	/**
-	 * The APID of this instance of the Service.
-	 */
-	uint16_t apid;
-	/**
-	 * The Service Identifier.
-	 */
-	uint8_t serviceId;
-	/**
-	 * One of two error parameters for additional error information.
-	 */
-	uint32_t errorParameter1 = 0;
-	/**
-	 * One of two error parameters for additional error information.
-	 */
-	uint32_t errorParameter2 = 0;
-	/**
-	 * This is a complete instance of the telecommand reception queue
-	 * of the class. It is initialized on construction of the class.
-	 */
-	MessageQueueIF* requestQueue = nullptr;
-	/**
-	 * An instance of the VerificationReporter class, that simplifies
-	 * sending any kind of verification message to the TC Verification Service.
-	 */
-	VerificationReporter verifyReporter;
-	/**
-	 * The current Telecommand to be processed.
-	 * It is deleted after handleRequest was executed.
-	 */
-	TcPacketStored currentPacket;
-
-	static object_id_t packetSource;
-
-	static object_id_t packetDestination;
-private:
-	/**
-	 * This constant sets the maximum number of packets accepted per call.
-	 * Remember that one packet must be completely handled in one
-	 * #handleRequest call.
-	 */
-	static const uint8_t PUS_SERVICE_MAX_RECEPTION = 10;
-
-	void handleRequestQueue();
-};
-
-#endif /* PUSSERVICEBASE_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../tmtcservices/VerificationCodes.h"
+#include "../tmtcservices/VerificationReporter.h"
+#include "../ipc/MessageQueueIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @defgroup pus_services PUS Service Framework
+ * These group contains all implementations of PUS Services in the OBSW.
+ * Most of the Services are directly taken from the ECSS PUS Standard.
+ */
+
+/**
+ * @brief 	This class is the basis for all PUS Services,
+ * 			which can immediately process Telecommand Packets.
+ * @details
+ * It manages Telecommand reception and the generation of Verification Reports.
+ * Every class that inherits from this abstract class has to implement
+ * handleRequest and performService. Services that are created with this
+ * Base class have to handle any kind of request immediately on reception.
+ * All PUS Services are System Objects, so an Object ID needs to be specified
+ * on construction.
+ * @ingroup pus_services
+ */
+class PusServiceBase : public ExecutableObjectIF,
+        public AcceptsTelecommandsIF,
+        public SystemObject,
+        public HasReturnvaluesIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	/**
+	 * @brief	The passed values are set, but inter-object initialization is
+	 * 			done in the initialize method.
+	 * @param setObjectId
+	 * The system object identifier of this Service instance.
+	 * @param setApid
+	 * The APID the Service is instantiated for.
+	 * @param setServiceId
+	 * The Service Identifier as specified in ECSS PUS.
+	 */
+	PusServiceBase(	object_id_t setObjectId, uint16_t setApid,
+			uint8_t setServiceId);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~PusServiceBase();
+	/**
+	 * @brief 	The handleRequest method shall handle any kind of Telecommand
+	 * 			Request immediately.
+	 * @details
+	 * Implemetations can take the Telecommand in currentPacket and perform
+	 * any kind of operation.
+	 * They may send additional "Start Success (1,3)" messages with the
+	 * verifyReporter, but Completion Success or Failure Reports are generated
+	 * automatically after execution of this method.
+	 *
+	 * If a Telecommand can not be executed within one call cycle,
+	 * this Base class is not the right parent.
+	 *
+	 * The child class may add additional error information by setting
+	 * #errorParameters which aren attached to the generated verification
+	 * message.
+	 *
+	 * Subservice checking should be implemented in this method.
+	 *
+	 * @return	The returned status_code is directly taken as main error code
+	 * 			in the Verification Report.
+	 * 			On success, RETURN_OK shall be returned.
+	 */
+	virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
+	/**
+	 * In performService, implementations can handle periodic,
+	 * non-TC-triggered activities.
+	 * The performService method is always called.
+	 * @return	Currently, everything other that RETURN_OK only triggers
+	 * 			diagnostic output.
+	 */
+	virtual ReturnValue_t performService() = 0;
+	/**
+	 * This method implements the typical activity of a simple PUS Service.
+	 * It checks for new requests, and, if found, calls handleRequest, sends
+	 * completion verification messages and deletes
+	 * the TC requests afterwards.
+	 * performService is always executed afterwards.
+	 * @return	@c RETURN_OK if the periodic performService was successful.
+	 * 			@c RETURN_FAILED else.
+	 */
+	ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual uint16_t getIdentifier() override;
+	MessageQueueId_t getRequestQueue() override;
+	virtual ReturnValue_t initialize() override;
+
+	virtual void setTaskIF(PeriodicTaskIF* taskHandle) override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+protected:
+	/**
+	 * @brief   Handle to the underlying task
+	 * @details
+	 * Will be set by setTaskIF(), which is called on task creation.
+	 */
+	PeriodicTaskIF* taskHandle = nullptr;
+	/**
+	 * The APID of this instance of the Service.
+	 */
+	uint16_t apid;
+	/**
+	 * The Service Identifier.
+	 */
+	uint8_t serviceId;
+	/**
+	 * One of two error parameters for additional error information.
+	 */
+	uint32_t errorParameter1 = 0;
+	/**
+	 * One of two error parameters for additional error information.
+	 */
+	uint32_t errorParameter2 = 0;
+	/**
+	 * This is a complete instance of the telecommand reception queue
+	 * of the class. It is initialized on construction of the class.
+	 */
+	MessageQueueIF* requestQueue = nullptr;
+	/**
+	 * An instance of the VerificationReporter class, that simplifies
+	 * sending any kind of verification message to the TC Verification Service.
+	 */
+	VerificationReporter verifyReporter;
+	/**
+	 * The current Telecommand to be processed.
+	 * It is deleted after handleRequest was executed.
+	 */
+	TcPacketStored currentPacket;
+
+	static object_id_t packetSource;
+
+	static object_id_t packetDestination;
+private:
+	/**
+	 * This constant sets the maximum number of packets accepted per call.
+	 * Remember that one packet must be completely handled in one
+	 * #handleRequest call.
+	 */
+	static const uint8_t PUS_SERVICE_MAX_RECEPTION = 10;
+
+	void handleRequestQueue();
+};
+
+#endif /* PUSSERVICEBASE_H_ */
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index 07631801d..d83380a21 100644
--- a/tmtcservices/PusVerificationReport.cpp
+++ b/tmtcservices/PusVerificationReport.cpp
@@ -1,163 +1,163 @@
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-
-PusVerificationMessage::PusVerificationMessage() {
-}
-
-//PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
-//		TcPacketBase* current_packet, ReturnValue_t set_error_code,
-//		uint8_t set_step, uint32_t parameter1, uint32_t parameter2) {
-//	uint8_t ackFlags = current_packet->getAcknowledgeFlags();
-//	uint16_t tcPacketId = current_packet->getPacketId();
-//	uint16_t tcSequenceControl = current_packet->getPacketSequenceControl();
-//	uint8_t* data = this->getBuffer();
-//	data[messageSize] = set_report_id;
-//	messageSize += sizeof(set_report_id);
-//	data[messageSize] = ackFlags;
-//	messageSize += sizeof(ackFlags);
-//	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
-//	messageSize += sizeof(tcPacketId);
-//	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
-//	messageSize += sizeof(tcSequenceControl);
-//	data[messageSize] = set_step;
-//	messageSize += sizeof(set_step);
-//	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
-//	messageSize += sizeof(set_error_code);
-//	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
-//	messageSize += sizeof(parameter1);
-//	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
-//	messageSize += sizeof(parameter2);
-//}
-
-PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
-		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
-		uint32_t parameter2) {
-	uint8_t *data = this->getBuffer();
-	data[messageSize] = set_report_id;
-	messageSize += sizeof(set_report_id);
-	data[messageSize] = ackFlags;
-	messageSize += sizeof(ackFlags);
-	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
-	messageSize += sizeof(tcPacketId);
-	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
-	messageSize += sizeof(tcSequenceControl);
-	data[messageSize] = set_step;
-	messageSize += sizeof(set_step);
-	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
-	messageSize += sizeof(set_error_code);
-	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
-	messageSize += sizeof(parameter1);
-	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
-	messageSize += sizeof(parameter2);
-}
-
-uint8_t PusVerificationMessage::getReportId() {
-
-	return getContent()->reportId;
-}
-
-uint8_t PusVerificationMessage::getAckFlags() {
-
-	return getContent()->ackFlags;
-}
-
-uint16_t PusVerificationMessage::getTcPacketId() {
-
-	uint16_t tcPacketId;
-	memcpy(&tcPacketId, &getContent()->packetId_0, sizeof(tcPacketId));
-	return tcPacketId;
-}
-
-uint16_t PusVerificationMessage::getTcSequenceControl() {
-
-	uint16_t tcSequenceControl;
-	memcpy(&tcSequenceControl, &getContent()->tcSequenceControl_0,
-			sizeof(tcSequenceControl));
-	return tcSequenceControl;
-}
-
-uint8_t PusVerificationMessage::getStep() {
-
-	return getContent()->step;
-}
-
-ReturnValue_t PusVerificationMessage::getErrorCode() {
-	ReturnValue_t errorCode;
-	memcpy(&errorCode, &getContent()->error_code_0, sizeof(errorCode));
-	return errorCode;
-}
-
-PusVerificationMessage::verifciationMessageContent* PusVerificationMessage::getContent() {
-	return (verifciationMessageContent*) this->getData();
-}
-
-uint32_t PusVerificationMessage::getParameter1() {
-	uint32_t parameter;
-	memcpy(&parameter, &getContent()->parameter1_0, sizeof(parameter));
-	return parameter;
-}
-
-uint32_t PusVerificationMessage::getParameter2() {
-	uint32_t parameter;
-	memcpy(&parameter, &getContent()->parameter2_0, sizeof(parameter));
-	return parameter;
-}
-
-PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
-		uint16_t setSequenceControl, uint8_t setStep) :
-		reportSize(0), pBuffer(reportBuffer) {
-	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	if (setStep != 0) {
-		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	}
-}
-
-PusSuccessReport::~PusSuccessReport() {
-
-}
-
-uint32_t PusSuccessReport::getSize() {
-	return reportSize;
-}
-
-uint8_t* PusSuccessReport::getReport() {
-	return reportBuffer;
-}
-
-PusFailureReport::PusFailureReport(uint16_t setPacketId,
-		uint16_t setSequenceControl, ReturnValue_t setErrorCode,
-		uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
-		reportSize(0), pBuffer(reportBuffer) {
-	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	if (setStep != 0) {
-		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	}
-	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-}
-
-PusFailureReport::~PusFailureReport() {
-}
-
-size_t PusFailureReport::getSize() {
-	return reportSize;
-}
-
-uint8_t* PusFailureReport::getReport() {
-	return reportBuffer;
-}
+#include "../serialize/SerializeAdapter.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+PusVerificationMessage::PusVerificationMessage() {
+}
+
+//PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
+//		TcPacketBase* current_packet, ReturnValue_t set_error_code,
+//		uint8_t set_step, uint32_t parameter1, uint32_t parameter2) {
+//	uint8_t ackFlags = current_packet->getAcknowledgeFlags();
+//	uint16_t tcPacketId = current_packet->getPacketId();
+//	uint16_t tcSequenceControl = current_packet->getPacketSequenceControl();
+//	uint8_t* data = this->getBuffer();
+//	data[messageSize] = set_report_id;
+//	messageSize += sizeof(set_report_id);
+//	data[messageSize] = ackFlags;
+//	messageSize += sizeof(ackFlags);
+//	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
+//	messageSize += sizeof(tcPacketId);
+//	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
+//	messageSize += sizeof(tcSequenceControl);
+//	data[messageSize] = set_step;
+//	messageSize += sizeof(set_step);
+//	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
+//	messageSize += sizeof(set_error_code);
+//	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
+//	messageSize += sizeof(parameter1);
+//	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
+//	messageSize += sizeof(parameter2);
+//}
+
+PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
+		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
+		uint32_t parameter2) {
+	uint8_t *data = this->getBuffer();
+	data[messageSize] = set_report_id;
+	messageSize += sizeof(set_report_id);
+	data[messageSize] = ackFlags;
+	messageSize += sizeof(ackFlags);
+	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
+	messageSize += sizeof(tcPacketId);
+	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
+	messageSize += sizeof(tcSequenceControl);
+	data[messageSize] = set_step;
+	messageSize += sizeof(set_step);
+	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
+	messageSize += sizeof(set_error_code);
+	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
+	messageSize += sizeof(parameter1);
+	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
+	messageSize += sizeof(parameter2);
+}
+
+uint8_t PusVerificationMessage::getReportId() {
+
+	return getContent()->reportId;
+}
+
+uint8_t PusVerificationMessage::getAckFlags() {
+
+	return getContent()->ackFlags;
+}
+
+uint16_t PusVerificationMessage::getTcPacketId() {
+
+	uint16_t tcPacketId;
+	memcpy(&tcPacketId, &getContent()->packetId_0, sizeof(tcPacketId));
+	return tcPacketId;
+}
+
+uint16_t PusVerificationMessage::getTcSequenceControl() {
+
+	uint16_t tcSequenceControl;
+	memcpy(&tcSequenceControl, &getContent()->tcSequenceControl_0,
+			sizeof(tcSequenceControl));
+	return tcSequenceControl;
+}
+
+uint8_t PusVerificationMessage::getStep() {
+
+	return getContent()->step;
+}
+
+ReturnValue_t PusVerificationMessage::getErrorCode() {
+	ReturnValue_t errorCode;
+	memcpy(&errorCode, &getContent()->error_code_0, sizeof(errorCode));
+	return errorCode;
+}
+
+PusVerificationMessage::verifciationMessageContent* PusVerificationMessage::getContent() {
+	return (verifciationMessageContent*) this->getData();
+}
+
+uint32_t PusVerificationMessage::getParameter1() {
+	uint32_t parameter;
+	memcpy(&parameter, &getContent()->parameter1_0, sizeof(parameter));
+	return parameter;
+}
+
+uint32_t PusVerificationMessage::getParameter2() {
+	uint32_t parameter;
+	memcpy(&parameter, &getContent()->parameter2_0, sizeof(parameter));
+	return parameter;
+}
+
+PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
+		uint16_t setSequenceControl, uint8_t setStep) :
+		reportSize(0), pBuffer(reportBuffer) {
+	//Serialization won't fail, because we know the necessary max-size of the buffer.
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	if (setStep != 0) {
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	}
+}
+
+PusSuccessReport::~PusSuccessReport() {
+
+}
+
+uint32_t PusSuccessReport::getSize() {
+	return reportSize;
+}
+
+uint8_t* PusSuccessReport::getReport() {
+	return reportBuffer;
+}
+
+PusFailureReport::PusFailureReport(uint16_t setPacketId,
+		uint16_t setSequenceControl, ReturnValue_t setErrorCode,
+		uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
+		reportSize(0), pBuffer(reportBuffer) {
+	//Serialization won't fail, because we know the necessary max-size of the buffer.
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	if (setStep != 0) {
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	}
+	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+}
+
+PusFailureReport::~PusFailureReport() {
+}
+
+size_t PusFailureReport::getSize() {
+	return reportSize;
+}
+
+uint8_t* PusFailureReport::getReport() {
+	return reportBuffer;
+}
diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h
index ee84f0c17..26a1eaedc 100644
--- a/tmtcservices/PusVerificationReport.h
+++ b/tmtcservices/PusVerificationReport.h
@@ -1,77 +1,77 @@
-#ifndef PUSVERIFICATIONREPORT_H_
-#define PUSVERIFICATIONREPORT_H_
-
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/tmtcpacket/pus/TcPacketBase.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-
-class PusVerificationMessage: public MessageQueueMessage {
-private:
-	struct verifciationMessageContent {
-		uint8_t reportId;
-		uint8_t ackFlags;
-		uint8_t packetId_0;
-		uint8_t packetId_1;
-		uint8_t tcSequenceControl_0;
-		uint8_t tcSequenceControl_1;
-		uint8_t step;
-		uint8_t error_code_0;
-		uint8_t error_code_1;
-		uint8_t parameter1_0;
-		uint8_t parameter1_1;
-		uint8_t parameter1_2;
-		uint8_t parameter1_3;
-		uint8_t parameter2_0;
-		uint8_t parameter2_1;
-		uint8_t parameter2_2;
-		uint8_t parameter2_3;
-	};
-	verifciationMessageContent* getContent();
-public:
-	static const uint8_t VERIFICATION_MIN_SIZE = 6;
-	PusVerificationMessage();
-//	PusVerificationMessage( uint8_t set_report_id, TcPacketBase* current_packet, ReturnValue_t set_error_code = 0, uint8_t set_step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
-	PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags,
-			uint16_t tcPacketId, uint16_t tcSequenceControl,
-			ReturnValue_t set_error_code = 0, uint8_t set_step = 0,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-	uint8_t getReportId();
-	uint8_t getAckFlags();
-	uint16_t getTcPacketId();
-	uint16_t getTcSequenceControl();
-	ReturnValue_t getErrorCode();
-	uint8_t getStep();
-	uint32_t getParameter1();
-	uint32_t getParameter2();
-};
-
-class PusSuccessReport {
-private:
-	static const uint16_t MAX_SIZE = 7;
-	uint8_t reportBuffer[MAX_SIZE];
-	size_t reportSize;
-	uint8_t * pBuffer;
-public:
-	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
-			uint8_t set_step = 0);
-	~PusSuccessReport();
-	uint32_t getSize();
-	uint8_t* getReport();
-};
-
-class PusFailureReport {
-private:
-	static const uint16_t MAX_SIZE = 16;
-	uint8_t reportBuffer[MAX_SIZE];
-	size_t reportSize;
-	uint8_t * pBuffer;
-public:
-	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
-			ReturnValue_t setErrorCode, uint8_t setStep = 0,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-	~PusFailureReport();
-	size_t getSize();
-	uint8_t* getReport();
-};
-
-#endif /* PUSVERIFICATIONREPORT_H_ */
+#ifndef PUSVERIFICATIONREPORT_H_
+#define PUSVERIFICATIONREPORT_H_
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../tmtcpacket/pus/TcPacketBase.h"
+#include "../tmtcservices/VerificationCodes.h"
+
+class PusVerificationMessage: public MessageQueueMessage {
+private:
+	struct verifciationMessageContent {
+		uint8_t reportId;
+		uint8_t ackFlags;
+		uint8_t packetId_0;
+		uint8_t packetId_1;
+		uint8_t tcSequenceControl_0;
+		uint8_t tcSequenceControl_1;
+		uint8_t step;
+		uint8_t error_code_0;
+		uint8_t error_code_1;
+		uint8_t parameter1_0;
+		uint8_t parameter1_1;
+		uint8_t parameter1_2;
+		uint8_t parameter1_3;
+		uint8_t parameter2_0;
+		uint8_t parameter2_1;
+		uint8_t parameter2_2;
+		uint8_t parameter2_3;
+	};
+	verifciationMessageContent* getContent();
+public:
+	static const uint8_t VERIFICATION_MIN_SIZE = 6;
+	PusVerificationMessage();
+//	PusVerificationMessage( uint8_t set_report_id, TcPacketBase* current_packet, ReturnValue_t set_error_code = 0, uint8_t set_step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
+	PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags,
+			uint16_t tcPacketId, uint16_t tcSequenceControl,
+			ReturnValue_t set_error_code = 0, uint8_t set_step = 0,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+	uint8_t getReportId();
+	uint8_t getAckFlags();
+	uint16_t getTcPacketId();
+	uint16_t getTcSequenceControl();
+	ReturnValue_t getErrorCode();
+	uint8_t getStep();
+	uint32_t getParameter1();
+	uint32_t getParameter2();
+};
+
+class PusSuccessReport {
+private:
+	static const uint16_t MAX_SIZE = 7;
+	uint8_t reportBuffer[MAX_SIZE];
+	size_t reportSize;
+	uint8_t * pBuffer;
+public:
+	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
+			uint8_t set_step = 0);
+	~PusSuccessReport();
+	uint32_t getSize();
+	uint8_t* getReport();
+};
+
+class PusFailureReport {
+private:
+	static const uint16_t MAX_SIZE = 16;
+	uint8_t reportBuffer[MAX_SIZE];
+	size_t reportSize;
+	uint8_t * pBuffer;
+public:
+	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
+			ReturnValue_t setErrorCode, uint8_t setStep = 0,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+	~PusFailureReport();
+	size_t getSize();
+	uint8_t* getReport();
+};
+
+#endif /* PUSVERIFICATIONREPORT_H_ */
diff --git a/tmtcservices/SourceSequenceCounter.h b/tmtcservices/SourceSequenceCounter.h
index b92a5c84c..0db533808 100644
--- a/tmtcservices/SourceSequenceCounter.h
+++ b/tmtcservices/SourceSequenceCounter.h
@@ -1,30 +1,30 @@
-/**
- * @file	SourceSequenceCounter.h
- * @brief	This file defines the SourceSequenceCounter class.
- * @date	04.02.2013
- * @author	baetz
- */
-
-#ifndef SOURCESEQUENCECOUNTER_H_
-#define SOURCESEQUENCECOUNTER_H_
-#include <framework/tmtcpacket/SpacePacketBase.h>
-
-class SourceSequenceCounter {
-private:
-	uint16_t sequenceCount;
-public:
-	SourceSequenceCounter() : sequenceCount(0) {}
-	void increment() {
-		sequenceCount = (sequenceCount+1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
-	}
-	void decrement() {
-		sequenceCount = (sequenceCount-1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
-	}
-	uint16_t get() { return this->sequenceCount; }
-	void reset(uint16_t toValue = 0) {
-		sequenceCount = toValue % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
-	}
-};
-
-
-#endif /* SOURCESEQUENCECOUNTER_H_ */
+/**
+ * @file	SourceSequenceCounter.h
+ * @brief	This file defines the SourceSequenceCounter class.
+ * @date	04.02.2013
+ * @author	baetz
+ */
+
+#ifndef SOURCESEQUENCECOUNTER_H_
+#define SOURCESEQUENCECOUNTER_H_
+#include "../tmtcpacket/SpacePacketBase.h"
+
+class SourceSequenceCounter {
+private:
+	uint16_t sequenceCount;
+public:
+	SourceSequenceCounter() : sequenceCount(0) {}
+	void increment() {
+		sequenceCount = (sequenceCount+1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+	}
+	void decrement() {
+		sequenceCount = (sequenceCount-1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+	}
+	uint16_t get() { return this->sequenceCount; }
+	void reset(uint16_t toValue = 0) {
+		sequenceCount = toValue % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+	}
+};
+
+
+#endif /* SOURCESEQUENCECOUNTER_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index b55803cbc..732a2ea1e 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -1,9 +1,9 @@
-#include <framework/tmtcservices/TmTcBridge.h>
+#include "../tmtcservices/TmTcBridge.h"
 
-#include <framework/ipc/QueueFactory.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/globalfunctions/arrayprinter.h>
+#include "../ipc/QueueFactory.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../globalfunctions/arrayprinter.h"
 
 TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
 		object_id_t tmStoreId, object_id_t tcStoreId):
@@ -105,8 +105,8 @@ ReturnValue_t TmTcBridge::handleTm() {
 
 ReturnValue_t TmTcBridge::handleTmQueue() {
 	TmTcMessage message;
-	const uint8_t* data = nullptr;
-	size_t size = 0;
+	const uint8_t* data = nullptr;
+	size_t size = 0;
 	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = tmTcReceptionQueue->receiveMessage(&message))
 	{
@@ -155,8 +155,8 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 		//info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
-		const uint8_t* data = nullptr;
-		size_t size = 0;
+		const uint8_t* data = nullptr;
+		size_t size = 0;
 		tmFifo.retrieve(&storeId);
 		result = tmStore->getData(storeId, &data, &size);
 
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 993cd5b99..b91425e1f 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,15 +1,15 @@
 #ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 #define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/tmtcservices/AcceptsTelemetryIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
+#include "../objectmanager/SystemObject.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
 
-#include <framework/container/FIFO.h>
-#include <framework/tmtcservices/TmTcMessage.h>
+#include "../container/FIFO.h"
+#include "../tmtcservices/TmTcMessage.h"
 
 class TmTcBridge : public AcceptsTelemetryIF,
 		public AcceptsTelecommandsIF,
diff --git a/tmtcservices/TmTcMessage.cpp b/tmtcservices/TmTcMessage.cpp
index d437b41ea..0fe3229c0 100644
--- a/tmtcservices/TmTcMessage.cpp
+++ b/tmtcservices/TmTcMessage.cpp
@@ -1,29 +1,29 @@
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <string.h>
-
-
-TmTcMessage::TmTcMessage() {
-	this->messageSize += sizeof(store_address_t);
-}
-
-TmTcMessage::~TmTcMessage() {
-}
-
-store_address_t TmTcMessage::getStorageId() {
-	store_address_t temp_id;
-	memcpy(&temp_id, this->getData(), sizeof(store_address_t) );
-	return temp_id;
-}
-
-TmTcMessage::TmTcMessage(store_address_t store_id) {
-	this->messageSize += sizeof(store_address_t);
-	this->setStorageId(store_id);
-}
-
-size_t TmTcMessage::getMinimumMessageSize() {
-	return this->HEADER_SIZE + sizeof(store_address_t);
-}
-
-void TmTcMessage::setStorageId(store_address_t store_id) {
-	memcpy(this->getData(), &store_id, sizeof(store_address_t) );
-}
+#include "../tmtcservices/TmTcMessage.h"
+#include <string.h>
+
+
+TmTcMessage::TmTcMessage() {
+	this->messageSize += sizeof(store_address_t);
+}
+
+TmTcMessage::~TmTcMessage() {
+}
+
+store_address_t TmTcMessage::getStorageId() {
+	store_address_t temp_id;
+	memcpy(&temp_id, this->getData(), sizeof(store_address_t) );
+	return temp_id;
+}
+
+TmTcMessage::TmTcMessage(store_address_t store_id) {
+	this->messageSize += sizeof(store_address_t);
+	this->setStorageId(store_id);
+}
+
+size_t TmTcMessage::getMinimumMessageSize() {
+	return this->HEADER_SIZE + sizeof(store_address_t);
+}
+
+void TmTcMessage::setStorageId(store_address_t store_id) {
+	memcpy(this->getData(), &store_id, sizeof(store_address_t) );
+}
diff --git a/tmtcservices/TmTcMessage.h b/tmtcservices/TmTcMessage.h
index 73f741fb6..ad97c0563 100644
--- a/tmtcservices/TmTcMessage.h
+++ b/tmtcservices/TmTcMessage.h
@@ -1,50 +1,50 @@
-#ifndef TMTCMESSAGE_H_
-#define TMTCMESSAGE_H_
-
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-/**
- * @brief	This message class is used to pass Telecommand and Telemetry
- * 			packets between tasks.
- * @details	Within such a packet, nothing is transported but the identifier of
- * 			a packet stored in one of the IPC stores (typically a special TM and
- * 			a special TC store). This makes passing commands very simple and
- * 			efficient.
- *	\ingroup message_queue
- */
-class TmTcMessage : public MessageQueueMessage {
-protected:
-	/**
-	 * @brief	This call always returns the same fixed size of the message.
-	 * @return	Returns HEADER_SIZE + \c sizeof(store_address_t).
-	 */
-	size_t getMinimumMessageSize();
-public:
-	/**
-	 * @brief	In the default constructor, only the message_size is set.
-	 */
-	TmTcMessage();
-	/**
-	 * @brief	With this constructor, the passed packet id is directly put
-	 * 			into the message.
-	 * @param packet_id	The packet id to put into the message.
-	 */
-	TmTcMessage( store_address_t packet_id );
-	/**
-	 * @brief	The class's destructor is empty.
-	 */
-	~TmTcMessage();
-	/**
-	 * @brief	This getter returns the packet id in the correct format.
-	 * @return	Returns the packet id.
-	 */
-	store_address_t getStorageId();
-	/**
-	 * @brief	In some cases it might be useful to have a setter for packet id
-	 * 			as well.
-	 * @param packet_id	The packet id to put into the message.
-	 */
-	void setStorageId( store_address_t packet_id );
-};
-
-#endif /* TMTCMESSAGE_H_ */
+#ifndef TMTCMESSAGE_H_
+#define TMTCMESSAGE_H_
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+/**
+ * @brief	This message class is used to pass Telecommand and Telemetry
+ * 			packets between tasks.
+ * @details	Within such a packet, nothing is transported but the identifier of
+ * 			a packet stored in one of the IPC stores (typically a special TM and
+ * 			a special TC store). This makes passing commands very simple and
+ * 			efficient.
+ *	\ingroup message_queue
+ */
+class TmTcMessage : public MessageQueueMessage {
+protected:
+	/**
+	 * @brief	This call always returns the same fixed size of the message.
+	 * @return	Returns HEADER_SIZE + \c sizeof(store_address_t).
+	 */
+	size_t getMinimumMessageSize();
+public:
+	/**
+	 * @brief	In the default constructor, only the message_size is set.
+	 */
+	TmTcMessage();
+	/**
+	 * @brief	With this constructor, the passed packet id is directly put
+	 * 			into the message.
+	 * @param packet_id	The packet id to put into the message.
+	 */
+	TmTcMessage( store_address_t packet_id );
+	/**
+	 * @brief	The class's destructor is empty.
+	 */
+	~TmTcMessage();
+	/**
+	 * @brief	This getter returns the packet id in the correct format.
+	 * @return	Returns the packet id.
+	 */
+	store_address_t getStorageId();
+	/**
+	 * @brief	In some cases it might be useful to have a setter for packet id
+	 * 			as well.
+	 * @param packet_id	The packet id to put into the message.
+	 */
+	void setStorageId( store_address_t packet_id );
+};
+
+#endif /* TMTCMESSAGE_H_ */
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 79e650f1b..e9a43855b 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -1,105 +1,105 @@
-#include <framework/tmtcservices/VerificationReporter.h>
-
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/tmtcservices/AcceptsVerifyMessageIF.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/objectmanager/frameworkObjects.h>
-
-object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1;
-
-VerificationReporter::VerificationReporter() :
-		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {
-}
-
-VerificationReporter::~VerificationReporter() {}
-
-void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
-		TcPacketBase* current_packet, uint8_t set_step) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
-		this->initialize();
-	}
-	PusVerificationMessage message(set_report_id,
-			current_packet->getAcknowledgeFlags(),
-			current_packet->getPacketId(),
-			current_packet->getPacketSequenceControl(), 0, set_step);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-			&message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
-		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-		uint8_t set_step) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE)  {
-		this->initialize();
-	}
-	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
-			tcSequenceControl, 0, set_step);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-			&message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::sendFailureReport(uint8_t report_id,
-		TcPacketBase* current_packet, ReturnValue_t error_code, uint8_t step,
-		uint32_t parameter1, uint32_t parameter2) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
-		this->initialize();
-	}
-	PusVerificationMessage message(report_id,
-			current_packet->getAcknowledgeFlags(),
-			current_packet->getPacketId(),
-			current_packet->getPacketSequenceControl(), error_code, step,
-			parameter1, parameter2);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendFailureReport Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::sendFailureReport(uint8_t report_id,
-		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-		ReturnValue_t error_code, uint8_t step, uint32_t parameter1,
-		uint32_t parameter2) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
-		this->initialize();
-	}
-	PusVerificationMessage message(report_id, ackFlags, tcPacketId,
-			tcSequenceControl, error_code, step, parameter1, parameter2);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendFailureReport Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::initialize() {
-	if(messageReceiver == objects::NO_OBJECT) {
-		sif::warning << "VerificationReporter::initialize: Verification message"
-				" receiver object ID not set yet in Factory!" << std::endl;
-		return;
-	}
-	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
-			messageReceiver);
-	if (temp == nullptr) {
-		sif::error << "VerificationReporter::initialize: Message "
-				<< "receiver invalid. Make sure it is set up properly and "
-				<<"implementsAcceptsVerifyMessageIF" << std::endl;
-
-	}
-	this->acknowledgeQueue = temp->getVerificationQueue();
-}
+#include "../tmtcservices/VerificationReporter.h"
+
+#include "../ipc/MessageQueueIF.h"
+#include "../tmtcservices/AcceptsVerifyMessageIF.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../objectmanager/frameworkObjects.h"
+
+object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1;
+
+VerificationReporter::VerificationReporter() :
+		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {
+}
+
+VerificationReporter::~VerificationReporter() {}
+
+void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
+		TcPacketBase* current_packet, uint8_t set_step) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+		this->initialize();
+	}
+	PusVerificationMessage message(set_report_id,
+			current_packet->getAcknowledgeFlags(),
+			current_packet->getPacketId(),
+			current_packet->getPacketSequenceControl(), 0, set_step);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+			&message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
+		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+		uint8_t set_step) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE)  {
+		this->initialize();
+	}
+	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
+			tcSequenceControl, 0, set_step);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+			&message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::sendFailureReport(uint8_t report_id,
+		TcPacketBase* current_packet, ReturnValue_t error_code, uint8_t step,
+		uint32_t parameter1, uint32_t parameter2) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+		this->initialize();
+	}
+	PusVerificationMessage message(report_id,
+			current_packet->getAcknowledgeFlags(),
+			current_packet->getPacketId(),
+			current_packet->getPacketSequenceControl(), error_code, step,
+			parameter1, parameter2);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendFailureReport Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::sendFailureReport(uint8_t report_id,
+		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+		ReturnValue_t error_code, uint8_t step, uint32_t parameter1,
+		uint32_t parameter2) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+		this->initialize();
+	}
+	PusVerificationMessage message(report_id, ackFlags, tcPacketId,
+			tcSequenceControl, error_code, step, parameter1, parameter2);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendFailureReport Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::initialize() {
+	if(messageReceiver == objects::NO_OBJECT) {
+		sif::warning << "VerificationReporter::initialize: Verification message"
+				" receiver object ID not set yet in Factory!" << std::endl;
+		return;
+	}
+	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
+			messageReceiver);
+	if (temp == nullptr) {
+		sif::error << "VerificationReporter::initialize: Message "
+				<< "receiver invalid. Make sure it is set up properly and "
+				<<"implementsAcceptsVerifyMessageIF" << std::endl;
+
+	}
+	this->acknowledgeQueue = temp->getVerificationQueue();
+}
diff --git a/tmtcservices/VerificationReporter.h b/tmtcservices/VerificationReporter.h
index f13998d9a..86aea8262 100644
--- a/tmtcservices/VerificationReporter.h
+++ b/tmtcservices/VerificationReporter.h
@@ -1,50 +1,50 @@
-#ifndef FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
-#define FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @brief 	This helper object is used to forward verification messages
- * 			which are generated by the Flight Software Framework.
- * @details
- * The messages can be relayed to an arbitrary object, for example a dedicated
- * Verification Reporter. The destination is set by setting the static framework
- * Id VerificationReporter::messageReceiver. The default verification reporter
- * will be the PUS service 1, which sends verification messages according
- * to the PUS standard.
- *
- */
-class VerificationReporter {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	VerificationReporter();
-	virtual ~VerificationReporter();
-
-	void sendSuccessReport( uint8_t set_report_id, TcPacketBase* current_packet,
-			uint8_t set_step = 0 );
-	void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags,
-			uint16_t tcPacketId, uint16_t tcSequenceControl,
-			uint8_t set_step = 0);
-
-	void sendFailureReport( uint8_t report_id, TcPacketBase* current_packet,
-			ReturnValue_t error_code = 0,
-			uint8_t step = 0, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0 );
-	void sendFailureReport(uint8_t report_id,
-			uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-			ReturnValue_t error_code = 0, uint8_t step = 0,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-
-	void initialize();
-
-private:
-	static object_id_t messageReceiver;
-	MessageQueueId_t acknowledgeQueue;
-};
-
-#endif /* FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
+#define FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @brief 	This helper object is used to forward verification messages
+ * 			which are generated by the Flight Software Framework.
+ * @details
+ * The messages can be relayed to an arbitrary object, for example a dedicated
+ * Verification Reporter. The destination is set by setting the static framework
+ * Id VerificationReporter::messageReceiver. The default verification reporter
+ * will be the PUS service 1, which sends verification messages according
+ * to the PUS standard.
+ *
+ */
+class VerificationReporter {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	VerificationReporter();
+	virtual ~VerificationReporter();
+
+	void sendSuccessReport( uint8_t set_report_id, TcPacketBase* current_packet,
+			uint8_t set_step = 0 );
+	void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags,
+			uint16_t tcPacketId, uint16_t tcSequenceControl,
+			uint8_t set_step = 0);
+
+	void sendFailureReport( uint8_t report_id, TcPacketBase* current_packet,
+			ReturnValue_t error_code = 0,
+			uint8_t step = 0, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0 );
+	void sendFailureReport(uint8_t report_id,
+			uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+			ReturnValue_t error_code = 0, uint8_t step = 0,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+
+	void initialize();
+
+private:
+	static object_id_t messageReceiver;
+	MessageQueueId_t acknowledgeQueue;
+};
+
+#endif /* FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_ */

From 5af50cfbf74fdf025b30030f0f2edfa29ed080b6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 18 Aug 2020 20:50:24 +0200
Subject: [PATCH 0639/1774] renamed .mk file

---
 framework.mk => fsfw.mk | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename framework.mk => fsfw.mk (100%)

diff --git a/framework.mk b/fsfw.mk
similarity index 100%
rename from framework.mk
rename to fsfw.mk

From a1d94ec556b6fbb35b6dbcc76499ba9620d663ef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 18 Aug 2020 20:51:13 +0200
Subject: [PATCH 0640/1774] added aditional comment

---
 fsfw.mk | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fsfw.mk b/fsfw.mk
index bfbd4b1f7..db1931ccd 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -1,3 +1,4 @@
+# This submake file needs to be included by the primary Makefile.
 # This file needs FRAMEWORK_PATH and OS_FSFW set correctly by another Makefile.
 # Valid API settings: rtems, linux, freeRTOS, host
 

From 7b998268cb782f90e8daab6d3bbe94c08cb37047 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 19 Aug 2020 13:17:40 +0200
Subject: [PATCH 0641/1774] error message improvement

---
 fsfw.mk | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fsfw.mk b/fsfw.mk
index db1931ccd..a548b6a88 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -38,7 +38,7 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
 else ifeq ($(OS_FSFW),host)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
 else
-$(error invalid OS specified, valid OS are rtems, linux, freeRTOS, host)
+$(error invalid OS_FSFW specified, valid OS_FSFW are rtems, linux, freeRTOS, host)
 endif
 
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/parameters/*.cpp)
@@ -59,4 +59,4 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)
\ No newline at end of file
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)

From f90bd012825b29ef0d4ec1d7b58f1b48da424103 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 19 Aug 2020 17:00:50 +0200
Subject: [PATCH 0642/1774] added srv17 and srv201

---
 pus/CService201HealthCommanding.cpp    | 84 ++++++++++++++++++++++++++
 pus/CService201HealthCommanding.h      | 58 ++++++++++++++++++
 pus/Service17Test.cpp                  | 41 +++++++++++++
 pus/Service17Test.h                    | 44 ++++++++++++++
 pus/servicepackets/Service201Packets.h | 48 +++++++++++++++
 5 files changed, 275 insertions(+)
 create mode 100644 pus/CService201HealthCommanding.cpp
 create mode 100644 pus/CService201HealthCommanding.h
 create mode 100644 pus/Service17Test.cpp
 create mode 100644 pus/Service17Test.h
 create mode 100644 pus/servicepackets/Service201Packets.h

diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
new file mode 100644
index 000000000..057ff707e
--- /dev/null
+++ b/pus/CService201HealthCommanding.cpp
@@ -0,0 +1,84 @@
+#include "CService201HealthCommanding.h"
+
+#include "../health/HasHealthIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../health/HealthMessage.h"
+#include "servicepackets/Service201Packets.h"
+
+CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId):
+	CommandingServiceBase(objectId, apid, serviceId,
+			NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {
+}
+
+CService201HealthCommanding::~CService201HealthCommanding() {
+}
+
+ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
+	switch(subservice) {
+	case(Subservice::COMMAND_SET_HEALTH):
+		return RETURN_OK;
+	default:
+		sif::error << "Invalid Subservice" << std::endl;
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t CService201HealthCommanding::getMessageQueueAndObject(
+        uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+        MessageQueueId_t *id, object_id_t *objectId) {
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG);
+
+    return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
+        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+    HasHealthIF * destination = objectManager->get<HasHealthIF>(*objectId);
+    if(destination == nullptr) {
+        return CommandingServiceBase::INVALID_OBJECT;
+    }
+
+    *messageQueueToSet = destination->getCommandQueue();
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CService201HealthCommanding::prepareCommand
+		(CommandMessage* message, uint8_t subservice, const uint8_t *tcData,
+		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
+	HealthCommand healthCommand;
+	ReturnValue_t result = healthCommand.deSerialize(&tcData, &tcDataLen,
+	        SerializeIF::Endianness::BIG);
+	if (result != RETURN_OK) {
+		return result;
+	} else {
+		HealthMessage::setHealthMessage(dynamic_cast<CommandMessage*>(message),
+				HealthMessage::HEALTH_SET, healthCommand.getHealth());
+		return result;
+	}
+}
+
+ReturnValue_t CService201HealthCommanding::handleReply
+		(const CommandMessage* reply, Command_t previousCommand,
+		uint32_t *state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool *isStep) {
+	Command_t replyId = reply->getCommand();
+	if (replyId == HealthMessage::REPLY_HEALTH_SET) {
+		prepareHealthSetReply(reply);
+	}
+	return RETURN_OK;
+}
+
+void CService201HealthCommanding::prepareHealthSetReply(
+        const CommandMessage* reply) {
+	prepareHealthSetReply(reply);
+	uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
+	uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
+	HealthSetReply healthSetReply(health, oldHealth);
+	sendTmPacket(Subservice::REPLY_HEALTH_SET,&healthSetReply);
+}
+
diff --git a/pus/CService201HealthCommanding.h b/pus/CService201HealthCommanding.h
new file mode 100644
index 000000000..85d2e24c3
--- /dev/null
+++ b/pus/CService201HealthCommanding.h
@@ -0,0 +1,58 @@
+#ifndef FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
+#define FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
+
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief   Custom PUS service to set health of all objects
+ *          implementing hasHealthIF.
+ *
+ * Examples: Device Handlers, Assemblies or Subsystems.
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * This service is very closely tied to the Commanding Service Base template
+ * class. There is constant interaction between this Service Base und a
+ * child class like this service
+ *
+ */
+class CService201HealthCommanding: public CommandingServiceBase {
+public:
+    static const uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
+    static const uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+
+	CService201HealthCommanding(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId);
+	virtual~ CService201HealthCommanding();
+protected:
+	/* CSB abstract function implementations */
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	/** Prepare health command */
+	ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) override;
+	/** Handle health reply */
+	ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) override;
+
+private:
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
+
+	void prepareHealthSetReply(const CommandMessage *reply);
+
+	enum Subservice {
+		COMMAND_SET_HEALTH = 1, //!< [EXPORT] : [TC] Set health of target object
+		REPLY_HEALTH_SET = 2 //!< [EXPORT] : [TM] Reply to health set command which also provides old health
+	};
+};
+
+#endif /* FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_ */
diff --git a/pus/Service17Test.cpp b/pus/Service17Test.cpp
new file mode 100644
index 000000000..2ef44490d
--- /dev/null
+++ b/pus/Service17Test.cpp
@@ -0,0 +1,41 @@
+#include "Service17Test.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+
+
+Service17Test::Service17Test(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId):
+    PusServiceBase(objectId, apid, serviceId),
+    packetSubCounter(0) {
+}
+
+Service17Test::~Service17Test() {
+}
+
+ReturnValue_t Service17Test::handleRequest(uint8_t subservice) {
+	switch(subservice){
+	case Subservice::CONNECTION_TEST: {
+		TmPacketStored connectionPacket(apid, serviceId,
+		        Subservice::CONNECTION_TEST_REPORT, packetSubCounter++);
+		connectionPacket.sendPacket(requestQueue->getDefaultDestination(),
+				requestQueue->getId());
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+    case Subservice::EVENT_TRIGGER_TEST: {
+        TmPacketStored connectionPacket(apid, serviceId,
+                Subservice::CONNECTION_TEST_REPORT, packetSubCounter++);
+        connectionPacket.sendPacket(requestQueue->getDefaultDestination(),
+                requestQueue->getId());
+        triggerEvent(TEST, 1234, 5678);
+        return RETURN_OK;
+    }
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service17Test::performService() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/pus/Service17Test.h b/pus/Service17Test.h
new file mode 100644
index 000000000..8d6a43770
--- /dev/null
+++ b/pus/Service17Test.h
@@ -0,0 +1,44 @@
+#ifndef MISSION_PUS_SERVICE17TEST_H_
+#define MISSION_PUS_SERVICE17TEST_H_
+
+#include "../tmtcservices/PusServiceBase.h"
+#include "../objectmanager/SystemObject.h"
+
+/**
+ * @brief Test Service
+ * Full Documentation: ECSS-E70-41A p.167
+ *
+ * The test service provides the capability to activate test functions
+ * implemented on-board and to report the results of such tests.
+ * Service capability:
+ *   - TC[17,1]: Perform connection test
+ *   - TM[17,2]: Send Connection Test Report
+ *   - TC[17,128]: Perform connection test and trigger event
+ *
+ * @ingroup pus_services
+ */
+class Service17Test: public PusServiceBase {
+public:
+	// Custom events which can be triggered
+	static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_17;
+	static constexpr Event TEST = MAKE_EVENT(0, SEVERITY::INFO);
+
+	enum Subservice: uint8_t {
+		//! [EXPORT] : [COMMAND] Perform connection test
+	    CONNECTION_TEST = 1,
+	    //! [EXPORT] : [REPLY] Connection test reply
+	    CONNECTION_TEST_REPORT = 2,
+		//!  [EXPORT] : [COMMAND] Trigger test reply and test event
+	    EVENT_TRIGGER_TEST = 128,
+	};
+
+	Service17Test(object_id_t objectId, uint16_t apid, uint8_t serviceId);
+	virtual ~Service17Test();
+	virtual ReturnValue_t handleRequest(uint8_t subservice) override;
+	virtual ReturnValue_t performService() override;
+
+protected:
+	uint16_t packetSubCounter = 0;
+};
+
+#endif /* MISSION_PUS_SERVICE17TEST_H_ */
diff --git a/pus/servicepackets/Service201Packets.h b/pus/servicepackets/Service201Packets.h
new file mode 100644
index 000000000..5ff5dcd51
--- /dev/null
+++ b/pus/servicepackets/Service201Packets.h
@@ -0,0 +1,48 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
+
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serialize/SerializeIF.h"
+#include "../../health/HasHealthIF.h"
+
+class HealthCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1
+public:
+
+	HealthCommand() {
+		setLinks();
+	}
+
+	HasHealthIF::HealthState getHealth() {
+		return static_cast<HasHealthIF::HealthState>(health.entry);
+	}
+private:
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&health);
+	}
+	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Target object Id
+	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] Health to set
+};
+
+
+class HealthSetReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 2
+public:
+	HealthSetReply(uint8_t health_, uint8_t oldHealth_):
+		health(health_), oldHealth(oldHealth_)
+	{
+		setLinks();
+	}
+
+private:
+	HealthSetReply(const HealthSetReply &reply);
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&health);
+		health.setNext(&oldHealth);
+	}
+	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Source object ID
+	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] New Health
+	SerializeElement<uint8_t> oldHealth; //!< [EXPORT] : [COMMENT] Old Health
+};
+
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_ */

From adbf39166f1cd7d9b86033148f02b9c18c21f438 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 20 Aug 2020 18:13:17 +0200
Subject: [PATCH 0643/1774] removed pus parser

---
 container/RingBufferBase.h     |   8 +--
 container/SimpleRingBuffer.cpp |   4 +-
 globalfunctions/DleEncoder.cpp |  26 ++++----
 globalfunctions/DleEncoder.h   |   6 +-
 returnvalues/FwClassIds.h      |   1 +
 tmtcservices/PusParser.cpp     | 114 ---------------------------------
 tmtcservices/PusParser.h       |  82 ------------------------
 7 files changed, 23 insertions(+), 218 deletions(-)
 delete mode 100644 tmtcservices/PusParser.cpp
 delete mode 100644 tmtcservices/PusParser.h

diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index b6ac20c10..0e784631c 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -21,10 +21,10 @@ public:
 		return (availableWriteSpace(n) == 0);
 	}
 	bool isEmpty(uint8_t n = 0) {
-		return (availableReadData(n) == 0);
+		return (getAvailableReadData(n) == 0);
 	}
 
-	size_t availableReadData(uint8_t n = 0) const {
+	size_t getAvailableReadData(uint8_t n = 0) const {
 		return ((write + size) - read[n]) % size;
 	}
 	size_t availableWriteSpace(uint8_t n = 0) const  {
@@ -36,7 +36,7 @@ public:
 		return overwriteOld;
 	}
 
-	size_t maxSize() const {
+	size_t getMaxSize() const {
 		return size - 1;
 	}
 
@@ -73,7 +73,7 @@ protected:
 	}
 
 	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
-		if (availableReadData(n) >= amount) {
+		if (getAvailableReadData(n) >= amount) {
 			incrementRead(amount, n);
 			return HasReturnvaluesIF::RETURN_OK;
 		} else {
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 8d817bb0b..0b7a175f9 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -71,7 +71,7 @@ ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
 
 ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
 		bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
-	size_t availableData = availableReadData(READ_PTR);
+	size_t availableData = getAvailableReadData(READ_PTR);
 	size_t amountTillWrap = readTillWrap(READ_PTR);
 	if (availableData < amount) {
 		if (readRemaining) {
@@ -110,7 +110,7 @@ void SimpleRingBuffer::moveExcessBytesToStart() {
 
 ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
 		bool deleteRemaining, size_t* trueAmount) {
-	size_t availableData = availableReadData(READ_PTR);
+	size_t availableData = getAvailableReadData(READ_PTR);
 	if (availableData < amount) {
 		if (deleteRemaining) {
 			amount = availableData;
diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index 8d74130f6..1a46637fb 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -13,7 +13,7 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 	size_t encodedIndex = 0, sourceIndex = 0;
 	uint8_t nextByte;
 	if (addStxEtx) {
-		destStream[0] = STX;
+		destStream[0] = STX_CHAR;
 		++encodedIndex;
 	}
 
@@ -21,12 +21,12 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 	{
 		nextByte = sourceStream[sourceIndex];
 		// STX, ETX and CR characters in the stream need to be escaped with DLE
-		if (nextByte == STX or nextByte == ETX or nextByte == CARRIAGE_RETURN) {
+		if (nextByte == STX_CHAR or nextByte == ETX_CHAR or nextByte == CARRIAGE_RETURN) {
 			if (encodedIndex + 1 >= maxDestLen) {
 				return STREAM_TOO_SHORT;
 			}
 			else {
-				destStream[encodedIndex] = DLE;
+				destStream[encodedIndex] = DLE_CHAR;
 				++encodedIndex;
 				/* Escaped byte will be actual byte + 0x40. This prevents
 				 * STX, ETX, and carriage return characters from appearing
@@ -39,14 +39,14 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 			}
 		}
 		// DLE characters are simply escaped with DLE.
-		else if (nextByte == DLE) {
+		else if (nextByte == DLE_CHAR) {
 			if (encodedIndex + 1 >= maxDestLen) {
 			    return STREAM_TOO_SHORT;
 			}
 			else {
-				destStream[encodedIndex] = DLE;
+				destStream[encodedIndex] = DLE_CHAR;
 				++encodedIndex;
-				destStream[encodedIndex] = DLE;
+				destStream[encodedIndex] = DLE_CHAR;
 			}
 		}
 		else {
@@ -58,7 +58,7 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 
 	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
 		if (addStxEtx) {
-			destStream[encodedIndex] = ETX;
+			destStream[encodedIndex] = ETX_CHAR;
 			++encodedIndex;
 		}
 		*encodedLen = encodedIndex;
@@ -74,19 +74,19 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 		size_t maxDestStreamlen, size_t *decodedLen) {
 	size_t encodedIndex = 0, decodedIndex = 0;
 	uint8_t nextByte;
-	if (*sourceStream != STX) {
+	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];
 			// 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) {
+			if (nextByte == DLE_CHAR) {
 				destStream[decodedIndex] = nextByte;
 			}
 			else {
@@ -111,7 +111,7 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 		++decodedIndex;
 	}
 
-	if (sourceStream[encodedIndex] != ETX) {
+	if (sourceStream[encodedIndex] != ETX_CHAR) {
 		return DECODING_ERROR;
 	}
 	else {
diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index da3bbaaf1..3c327a555 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -35,12 +35,12 @@ public:
 	static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
 
 	//! Start Of Text character. First character is encoded stream
-	static constexpr uint8_t STX = 0x02;
+	static constexpr uint8_t STX_CHAR = 0x02;
 	//! End Of Text character. Last character in encoded stream
-	static constexpr uint8_t ETX = 0x03;
+	static constexpr uint8_t ETX_CHAR = 0x03;
 	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
 	//! in the source stream.
-	static constexpr uint8_t DLE = 0x10;
+	static constexpr uint8_t DLE_CHAR = 0x10;
 	static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
 
     /**
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 7e4d89530..ebd1847d8 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -66,6 +66,7 @@ enum {
 	HOUSEKEEPING_MANAGER, //HKM 60
 	DLE_ENCODER, //DLEE 61
 	PUS_PARSER, //PUSP 62
+	SERIAL_ANALYZER, //SERA 63
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
deleted file mode 100644
index f9a0fc577..000000000
--- a/tmtcservices/PusParser.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-#include "../tmtcservices/PusParser.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-PusParser::PusParser(uint16_t maxExpectedPusPackets,
-		bool storeSplitPackets): indexSizePairFIFO(maxExpectedPusPackets) {
-}
-
-ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
-		size_t frameSize) {
-	if(frame == nullptr or frameSize < 5) {
-		sif::error << "PusParser::parsePusPackets: Frame invalid!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(indexSizePairFIFO.full()) {
-		sif::error << "PusParser::parsePusPackets: FIFO is full!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	size_t lengthField = frame[4] << 8 | frame[5];
-
-	if(lengthField == 0) {
-		return NO_PACKET_FOUND;
-	}
-
-	size_t packetSize = lengthField + 7;
-	// sif::debug << frameSize << std::endl;
-	// Size of a pus packet is the value in the packet length field plus 7.
-	if(packetSize > frameSize) {
-		if(storeSplitPackets) {
-			indexSizePairFIFO.insert(indexSizePair(0, frameSize));
-		}
-		else {
-			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
-					"larger than remaining frame," << std::endl;
-			sif::debug << "Throwing away packet. Detected packet size: "
-					<< packetSize << std::endl;
-		}
-		return SPLIT_PACKET;
-	}
-	else {
-		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
-		if(packetSize == frameSize) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-
-	// packet size is smaller than frame size, parse for more packets.
-	return readMultiplePackets(frame, frameSize, packetSize);
-}
-
-ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
-		size_t frameSize, size_t startIndex) {
-	while (startIndex < frameSize) {
-		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-DynamicFIFO<PusParser::indexSizePair>* PusParser::fifo(){
-	return &indexSizePairFIFO;
-}
-
-PusParser::indexSizePair PusParser::getNextFifoPair() {
-	indexSizePair nextIndexSizePair;
-	indexSizePairFIFO.retrieve(&nextIndexSizePair);
-	return nextIndexSizePair;
-}
-
-ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
-		size_t frameSize, size_t& currentIndex) {
-	// sif::debug << startIndex << std::endl;
-    if(currentIndex + 5 > frameSize) {
-        currentIndex = frameSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-	uint16_t lengthField = frame[currentIndex + 4] << 8 |
-			frame[currentIndex + 5];
-	if(lengthField == 0) {
-		// It is assumed that no packet follows.
-		currentIndex = frameSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	size_t nextPacketSize = lengthField + 7;
-	size_t remainingSize = frameSize - currentIndex;
-	if(nextPacketSize > remainingSize)
-	{
-		if(storeSplitPackets) {
-			indexSizePairFIFO.insert(indexSizePair(currentIndex, remainingSize));
-		}
-		else {
-			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
-					"larger than remaining frame," << std::endl;
-			sif::debug << "Throwing away packet. Detected packet size: "
-					<< nextPacketSize << std::endl;
-		}
-		return SPLIT_PACKET;
-	}
-
-	ReturnValue_t result = indexSizePairFIFO.insert(indexSizePair(currentIndex,
-			nextPacketSize));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		// FIFO full.
-		sif::debug << "PusParser: Issue inserting into start index size "
-		        "FIFO, it is full!" << std::endl;
-	}
-	currentIndex += nextPacketSize;
-
-	return result;
-}
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
deleted file mode 100644
index 24cba0c00..000000000
--- a/tmtcservices/PusParser.h
+++ /dev/null
@@ -1,82 +0,0 @@
-#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
-#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
-
-#include "../container/DynamicFIFO.h"
-#include <utility>
-#include <cstdint>
-
-/**
- * @brief	This small helper class scans a given buffer for PUS packets.
- * 			Can be used if PUS packets are serialized in a tightly packed frame.
- * @details
- * The parser uses the payload length field of PUS packets to find
- * the respective PUS packet sizes.
- *
- * The parser parses a buffer by taking a pointer and the maximum size to scan.
- * If PUS packets are found, they are stored in a FIFO which stores pairs
- * consisting of the index in the buffer and the respective packet sizes.
- *
- * If the parser detects split packets (which means that the size of the
- * next packet is larger than the remaining size to scan), it can either
- * store that split packet or throw away the packet.
- */
-class PusParser {
-public:
-	//! The first entry is the index inside the buffer while the second index
-	//! is the size of the PUS packet starting at that index.
-	using indexSizePair = std::pair<size_t, size_t>;
-
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
-	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
-	static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);
-	/**
-	 * Parser constructor.
-	 * @param maxExpectedPusPackets
-	 * Maximum expected number of PUS packets. A good estimate is to divide
-	 * the frame size by the minimum size of a PUS packet (12 bytes)
-	 * @param storeSplitPackets
-	 * Specifies whether split packets are also stored inside the FIFO,
-	 * with the size being the remaining frame size.
-	 */
-	PusParser(uint16_t maxExpectedPusPackets, bool storeSplitPackets);
-
-	/**
-	 * Parse a given frame for PUS packets
-	 * @param frame
-	 * @param frameSize
-	 * @return -@c NO_PACKET_FOUND if no packet was found.
-	 */
-	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
-
-	/**
-	 * Accessor function to get a reference to the internal FIFO which
-	 * stores pairs of indexi and packet sizes. This FIFO is filled
-	 * by the parsePusPackets() function.
-	 * @return
-	 */
-	DynamicFIFO<indexSizePair>* fifo();
-
-	/**
-	 * Retrieve the next index and packet size pair from the FIFO.
-	 * This also removed it from the FIFO. Please note that if the FIFO
-	 * is empty, an empty pair will be returned.
-	 * @return
-	 */
-	indexSizePair getNextFifoPair();
-
-private:
-	/** A FIFO is used to store information about multiple PUS packets
-	 * inside the receive buffer. The maximum number of entries is defined
-	 * by the first constructor argument.
-	 */
-	DynamicFIFO<indexSizePair> indexSizePairFIFO;
-
-	bool storeSplitPackets = false;
-
-	ReturnValue_t readMultiplePackets(const uint8_t *frame, size_t frameSize,
-			size_t startIndex);
-	ReturnValue_t readNextPacket(const uint8_t *frame,
-			size_t frameSize, size_t& startIndex);
-};
-
-#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */

From 9385f9024132a5f5edb23284ee70911e7a302110 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 20 Aug 2020 20:36:49 +0200
Subject: [PATCH 0644/1774] some bugfixes and improvements

---
 container/SimpleRingBuffer.cpp   | 10 +++++++++-
 container/SimpleRingBuffer.h     | 11 ++++++++++-
 globalfunctions/arrayprinter.cpp |  2 +-
 3 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 0b7a175f9..7ed019b25 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -42,7 +42,6 @@ ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
             excessBytes = amount - amountTillWrap;
         }
         *writePointer = &buffer[write];
-        incrementWrite(amount);
         return HasReturnvaluesIF::RETURN_OK;
     }
     else {
@@ -50,6 +49,14 @@ ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
     }
 }
 
+void SimpleRingBuffer::confirmBytesWritten(size_t amount) {
+	if(getExcessBytes() > 0) {
+		moveExcessBytesToStart();
+	}
+	incrementWrite(amount);
+
+}
+
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
 		size_t amount) {
 	if (availableWriteSpace() >= amount or overwriteOld) {
@@ -125,3 +132,4 @@ ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index a2cb96ab0..b13e9f2aa 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -56,7 +56,8 @@ public:
 	/**
 	 * Returns a pointer to a free element. If the remaining buffer is
 	 * not large enough, the data will be written past the actual size
-	 * and the amount of excess bytes will be cached.
+	 * and the amount of excess bytes will be cached. This function
+	 * does not increment the write pointer!
 	 * @param writePointer Pointer to a pointer which can be used to write
 	 * contiguous blocks into the ring buffer
 	 * @param amount
@@ -64,6 +65,14 @@ public:
 	 */
 	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
 
+	/**
+	 * This increments the write pointer and also copies the excess bytes
+	 * to the beginning. It should be called if the write operation
+	 * conducted after calling getFreeElement() was performed.
+	 * @return
+	 */
+	void confirmBytesWritten(size_t amount);
+
 	virtual size_t getExcessBytes() const;
 	/**
 	 * Helper functions which moves any excess bytes to the start
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index 3f02c882e..ca080cc5f 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -27,7 +27,7 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 		if(i < size - 1){
 			sif::info << " , ";
 			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
+				printf("\n");
 			}
 		}
 

From 15fd30b23f313a2f8678fb0946a7ec9c84c52266 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 20 Aug 2020 22:31:58 +0200
Subject: [PATCH 0645/1774] assigned read len for decoding error

---
 globalfunctions/DleEncoder.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index 1a46637fb..21dbd2e62 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -112,6 +112,7 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 	}
 
 	if (sourceStream[encodedIndex] != ETX_CHAR) {
+		*readLen = ++encodedIndex;
 		return DECODING_ERROR;
 	}
 	else {

From 0d476062299a1c5f305146327be3920480fd940a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 21 Aug 2020 15:49:06 +0200
Subject: [PATCH 0646/1774] tm/tc packet stored improvements

---
 tmtcpacket/pus/TcPacketStored.cpp | 10 +++++-----
 tmtcpacket/pus/TmPacketStored.cpp |  5 +++--
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 3f10cac0a..64b369eae 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -20,9 +20,9 @@ TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
 	uint8_t* p_data = nullptr;
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
 			(TC_PACKET_MIN_SIZE + size), &p_data);
-	if (returnValue != this->store->RETURN_OK) {
-		sif::warning << "TcPacketStored: Could not get free element from store!"
-				<< std::endl;
+	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
+		sif::warning << "TcPacketStored::TcPacketStored: Could not get "
+				"free element from store!" << std::endl;
 		return;
 	}
 	this->setData(p_data);
@@ -57,9 +57,9 @@ ReturnValue_t TcPacketStored::deletePacket() {
 }
 
 bool TcPacketStored::checkAndSetStore() {
-	if (this->store == NULL) {
+	if (this->store == nullptr) {
 		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-		if (this->store == NULL) {
+		if (this->store == nullptr) {
 			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
 					<< std::endl;
 			return false;
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index e42f8cda8..9476dcd6b 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -21,8 +21,9 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
 
-	if (returnValue != store->RETURN_OK) {
-		sif::debug << "TM Packet Stored: Issue getting free storage" << std::endl;
+	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "TmPacketStored::TmPacketStored: "
+				"Issue getting free storage" << std::endl;
 		checkAndReportLostTm();
 		return;
 	}

From cdaed4523bdbe6f27820de605344340fec6698b2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 21 Aug 2020 16:15:40 +0200
Subject: [PATCH 0647/1774] tmtc bridge todo added

---
 tmtcservices/TmTcBridge.cpp | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 732a2ea1e..5df8eee93 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -107,31 +107,33 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 	TmTcMessage message;
 	const uint8_t* data = nullptr;
 	size_t size = 0;
+	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = tmTcReceptionQueue->receiveMessage(&message))
 	{
 		if(communicationLinkUp == false) {
-			result = storeDownlinkData(&message);
-			return result;
+			storeDownlinkData(&message);
+			continue;
 		}
 
 		result = tmStore->getData(message.getStorageId(), &data, &size);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "TmTcBridge::handleTmQueue: Invalid store "
+					"ID!" << std::endl;
 			continue;
 		}
 
 		result = sendTm(data, size);
 		if (result != RETURN_OK) {
 			sif::warning << "TmTcBridge: Could not send TM packet" << std::endl;
-			tmStore->deleteData(message.getStorageId());
-			return result;
-
+			status = HasReturnvaluesIF::RETURN_FAILED;
 		}
 		tmStore->deleteData(message.getStorageId());
 	}
-	return RETURN_OK;
+	return status;
 }
 
+// todo: make it configurable whether old data is deleted.
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	store_address_t storeId = 0;
 

From 2b63f1b3f3557ae05bdb55791d90e2febf8a17c8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 23 Aug 2020 21:00:25 +0200
Subject: [PATCH 0648/1774] New reporting mode

---
 datapoollocal/LocalDataPoolManager.cpp | 22 ++++------------------
 datapoollocal/LocalDataPoolManager.h   | 14 ++++++++++++--
 devicehandlers/DeviceHandlerBase.cpp   |  7 +------
 devicehandlers/DeviceHandlerBase.h     |  2 --
 4 files changed, 17 insertions(+), 28 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index a437519ef..1121ac7bf 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -8,6 +8,8 @@
 #include <array>
 #include <cmath>
 
+object_id_t LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
+
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
         appendValidityBuffer(appendValidityBuffer) {
@@ -31,29 +33,13 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
 }
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
-        object_id_t hkDestination, uint8_t nonDiagInvlFactor) {
+        uint8_t nonDiagInvlFactor) {
     if(queueToUse == nullptr) {
         sif::error << "LocalDataPoolManager::initialize: Supplied queue "
                 "invalid!" << std::endl;
     }
     hkQueue = queueToUse;
 
-    if(hkDestination == objects::NO_OBJECT) {
-        return initializeHousekeepingPoolEntriesOnce();
-    }
-
-    AcceptsHkPacketsIF* hkReceiver =
-            objectManager->get<AcceptsHkPacketsIF>(hkDestination);
-    if(hkReceiver != nullptr) {
-        setHkPacketDestination(hkReceiver->getHkQueue());
-    }
-    else {
-        sif::warning << "LocalDataPoolManager::initialize: Could not retrieve"
-                " queue ID from HK destination object ID. " << std::flush;
-        sif::warning << "Make sure it exists and the object impements "
-                "AcceptsHkPacketsIF!" << std::endl;
-    }
-
     setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
     diagnosticMinimumInterval = owner->getPeriodicOperationFrequency();
     regularMinimumInterval = diagnosticMinimumInterval * nonDiagnosticIntervalFactor;
@@ -228,7 +214,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
             performPeriodicHkGeneration(receiver);
             break;
         }
-        case(ReportingType::ON_UPDATE): {
+        case(ReportingType::UPDATE_SNAPSHOT): {
             // check whether data has changed and send messages in case it has.
             break;
         }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index a4113ffe4..9403911b4 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -15,8 +15,13 @@
 
 #include <map>
 
+namespace Factory {
+void setStaticFrameworkObjectIds();
+}
+
 class LocalDataSetBase;
 
+
 /**
  * @brief 	This class is the managing instance for local data pool.
  * @details
@@ -40,6 +45,7 @@ class LocalDataPoolManager {
 	template<typename T, uint16_t vecSize>
 	friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
+	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
@@ -71,7 +77,7 @@ public:
 	 * @return
 	 */
 	ReturnValue_t initialize(MessageQueueIF* queueToUse,
-	        object_id_t hkDestination, uint8_t nonDiagInvlFactor = 5);
+			uint8_t nonDiagInvlFactor = 5);
 
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
@@ -136,9 +142,10 @@ public:
     enum class ReportingType: uint8_t {
         // Periodic generation of HK packets.
         PERIODIC,
+		UPDATE_NOTIFICATION,
         // Notification will be sent out as message.
         // Data is accessed via shared data set or multiple local data sets.
-        ON_UPDATE,
+        UPDATE_SNAPSHOT,
     };
 
     /* Copying forbidden */
@@ -157,6 +164,9 @@ private:
     dur_millis_t regularMinimumInterval = 0;
     dur_millis_t diagnosticMinimumInterval = 0;
 
+	/** Default receiver for periodic HK packets */
+	static object_id_t defaultHkDestination;
+
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
         /** Different member of this union will be used depending on the
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 8d66411a6..a3b861b5e 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -19,7 +19,6 @@
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::defaultHkDestination = objects::NO_OBJECT;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * comCookie,
@@ -194,11 +193,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-	if(hkDestination == objects::NO_OBJECT) {
-		hkDestination = defaultHkDestination;
-	}
-
-	result = hkManager.initialize(commandQueue, hkDestination);
+	result = hkManager.initialize(commandQueue);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 4aa54fd6d..c3640e2f2 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1043,8 +1043,6 @@ private:
 	/** the object used to set power switches */
 	PowerSwitchIF *powerSwitcher = nullptr;
 
-	/** Cached for initialize() */
-	static object_id_t defaultHkDestination;
 	/** HK destination can also be set individually */
 	object_id_t hkDestination = objects::NO_OBJECT;
 

From 687e124929f367f8009b517450e8f61322bb0613 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 23 Aug 2020 21:52:44 +0200
Subject: [PATCH 0649/1774] doc added

---
 datapoollocal/LocalDataPoolManager.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 9403911b4..8700fd389 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -140,11 +140,12 @@ public:
      *  full dataset updates.
      */
     enum class ReportingType: uint8_t {
-        // Periodic generation of HK packets.
+        //! Periodic generation of HK packets.
         PERIODIC,
+		//! Update notification will be sent out as message.
 		UPDATE_NOTIFICATION,
-        // Notification will be sent out as message.
-        // Data is accessed via shared data set or multiple local data sets.
+        //! Notification will be sent out as message and a snapshot of the
+        //! current data will be generated.
         UPDATE_SNAPSHOT,
     };
 

From a95bc6b293683e63c3070b5f2ce33a5e2b3f942f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 23 Aug 2020 22:33:22 +0200
Subject: [PATCH 0650/1774] sid cached now

---
 datapool/PoolDataSetBase.cpp           |  3 ---
 datapoollocal/LocalDataSet.cpp         | 32 +++++++------------------
 datapoollocal/LocalDataSet.h           |  5 ++--
 datapoollocal/LocalPoolDataSetBase.cpp | 33 ++++++++++++++++----------
 datapoollocal/LocalPoolDataSetBase.h   | 16 ++++++-------
 datapoollocal/SharedLocalDataSet.cpp   |  4 ++--
 datapoollocal/SharedLocalDataSet.h     |  2 +-
 datapoollocal/StaticLocalDataSet.h     |  4 ++--
 housekeeping/HousekeepingMessage.h     |  4 ++++
 9 files changed, 47 insertions(+), 56 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index f9a6f391c..1acd3fd3b 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -5,9 +5,6 @@ PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
         const size_t maxFillCount):
         registeredVariables(registeredVariablesArray),
         maxFillCount(maxFillCount) {
-	for (uint8_t count = 0; count < maxFillCount; count++) {
-		registeredVariables[count] = nullptr;
-	}
 }
 
 PoolDataSetBase::~PoolDataSetBase() {}
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index fe9b7d597..f6f13313f 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -5,32 +5,16 @@
 #include <cmath>
 #include <cstring>
 
-LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
-        const size_t maxNumberOfVariables):
-        LocalPoolDataSetBase(hkOwner,poolVarList.data(), maxNumberOfVariables) {
-    poolVarList.reserve(maxNumberOfVariables);
-    poolVarList.resize(maxNumberOfVariables);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
+LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner, uint32_t setId,
+        const size_t maxNumberOfVariables): poolVarList(maxNumberOfVariables),
+        LocalPoolDataSetBase(hkOwner, setId, nullptr, maxNumberOfVariables) {
+	this->setContainer(poolVarList.data());
 }
 
-LocalDataSet::LocalDataSet(object_id_t ownerId,
-        const size_t maxNumberOfVariables):
-        LocalPoolDataSetBase(ownerId, poolVarList.data(), maxNumberOfVariables)  {
-    poolVarList.reserve(maxNumberOfVariables);
-    poolVarList.resize(maxNumberOfVariables);
-    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
-            ownerId);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
+LocalDataSet::LocalDataSet(sid_t sid, const size_t maxNumberOfVariables):
+        LocalPoolDataSetBase(sid, nullptr, maxNumberOfVariables),
+		poolVarList(maxNumberOfVariables) {
+	this->setContainer(poolVarList.data());
 }
 
 LocalDataSet::~LocalDataSet() {}
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index d306fae38..5641ebfbc 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -5,8 +5,9 @@
 
 class LocalDataSet: public LocalPoolDataSetBase {
 public:
-    LocalDataSet(HasLocalDataPoolIF* hkOwner, const size_t maxSize);
-    LocalDataSet(object_id_t owner, const size_t maxSize);
+    LocalDataSet(HasLocalDataPoolIF* hkOwner, uint32_t setId,
+    		const size_t maxSize);
+    LocalDataSet(sid_t sid, const size_t maxSize);
     virtual~ LocalDataSet();
 
     //! Copying forbidden for now.
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index cbf2eeef3..8abdc0e35 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -6,7 +6,7 @@
 #include <cstring>
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-        PoolVariableIF** registeredVariablesArray,
+		uint32_t setId, PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
     if(hkOwner == nullptr) {
@@ -15,20 +15,23 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
+    this->sid.objectId = hkOwner->getObjectId();
+    this->sid.ownerSetId = setId;
 }
 
-LocalPoolDataSetBase::LocalPoolDataSetBase(object_id_t ownerId,
+LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
-            ownerId);
+            sid.objectId);
     if(hkOwner == nullptr) {
         sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
                 << std::endl;
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
+    this->sid = sid;
 }
 
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
@@ -123,14 +126,6 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
-    if(position > 7) {
-        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
-}
 
 size_t LocalPoolDataSetBase::getSerializedSize() const {
     if(withValidityBuffer) {
@@ -170,9 +165,21 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
     }
 }
 
-bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte, uint8_t position) const {
+void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
-        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+        sif::debug << "Pool Raw Access: Bit setting invalid position"
+        		<< std::endl;
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1 << shiftNumber;
+}
+
+bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
+		uint8_t position) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position"
+        		<< std::endl;
         return false;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 091670cff..bd127db49 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -30,28 +30,25 @@ class LocalDataPoolManager;
  *
  * @ingroup data_pool
  */
-// todo: make withValidityBuffer a member
 class LocalPoolDataSetBase: public PoolDataSetBase {
 public:
 	/**
 	 * @brief	Constructor for the creator of local pool data.
-	 * 			The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
 	 */
 	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-	        PoolVariableIF** registeredVariablesArray,
+			uint32_t setId, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
 	/**
 	 * @brief	Constructor for users of local pool data. The passed pool
 	 * 			owner should implement the HasHkPoolParametersIF.
-	 * 			The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
 	 * @details
-	 *
+	 * @param sid Unique identifier of dataset consisting of object ID and
+	 * set ID.
+	 * @param registeredVariablesArray
+	 * @param maxNumberOfVariables
 	 */
-	LocalPoolDataSetBase(object_id_t ownerId,
-	        PoolVariableIF** registeredVariablesArray,
+	LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
 	/**
@@ -96,6 +93,7 @@ public:
 	bool isValid() const override;
 
 protected:
+	sid_t sid;
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
 	 * data set we can use this flag.
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
index d44d1eb33..73e0e1fbd 100644
--- a/datapoollocal/SharedLocalDataSet.cpp
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -1,8 +1,8 @@
 #include "SharedLocalDataSet.h"
 
-SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, object_id_t owner,
+SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
         const size_t maxSize): SystemObject(objectId),
-        LocalPoolDataSetBase(owner, nullptr, maxSize) {
+        LocalPoolDataSetBase(sid, nullptr, maxSize) {
     this->setContainer(poolVarVector.data());
     datasetLock = MutexFactory::instance()->createMutex();
 }
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index c5949e0a0..f6748e4da 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -16,7 +16,7 @@ class SharedLocalDataSet: public SystemObject,
         public LocalPoolDataSetBase,
         public SharedDataSetIF {
 public:
-    SharedLocalDataSet(object_id_t objectId, object_id_t owner,
+    SharedLocalDataSet(object_id_t objectId, sid_t sid,
             const size_t maxSize);
     ReturnValue_t lockDataset(dur_millis_t mutexTimeout) override;
     ReturnValue_t unlockDataset() override;
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index 1819cc2d4..b3e8422c9 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -16,8 +16,8 @@
 template <uint8_t NUM_VARIABLES>
 class StaticLocalDataSet: public LocalPoolDataSetBase {
 public:
-    StaticLocalDataSet(object_id_t owner):
-        LocalPoolDataSetBase(owner, poolVarList.data(), NUM_VARIABLES) {
+    StaticLocalDataSet(sid_t sid):
+        LocalPoolDataSetBase(sid, poolVarList.data(), NUM_VARIABLES) {
     }
 
 private:
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index ff4b39f9a..75b315053 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -12,6 +12,10 @@ union sid_t {
 			std::numeric_limits<uint64_t>::max();
 	sid_t(): raw(INVALID_ADDRESS) {}
 
+	sid_t(object_id_t objectId, uint32_t setId):
+			objectId(objectId),
+			ownerSetId(setId) {}
+
 	struct {
 		object_id_t objectId ;
 		/**

From a5227115e5b0361ec33242453ae3435589033200 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 23 Aug 2020 23:24:48 +0200
Subject: [PATCH 0651/1774] first subscriptio nfunction written

---
 datapoollocal/LocalDataPoolManager.cpp | 157 ++++++++++++++-----------
 datapoollocal/LocalDataPoolManager.h   |  27 ++---
 2 files changed, 100 insertions(+), 84 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 1121ac7bf..a0f4337cb 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -32,6 +32,8 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
 	hkQueue = queueToUse;
 }
 
+LocalDataPoolManager::~LocalDataPoolManager() {}
+
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
         uint8_t nonDiagInvlFactor) {
     if(queueToUse == nullptr) {
@@ -42,17 +44,11 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
 
     setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
     diagnosticMinimumInterval = owner->getPeriodicOperationFrequency();
-    regularMinimumInterval = diagnosticMinimumInterval * nonDiagnosticIntervalFactor;
+    regularMinimumInterval = diagnosticMinimumInterval *
+    		nonDiagnosticIntervalFactor;
     return initializeHousekeepingPoolEntriesOnce();
 }
 
-void LocalDataPoolManager::setHkPacketDestination(
-        MessageQueueId_t hkDestination) {
-    this->hkDestination = hkDestination;
-}
-
-LocalDataPoolManager::~LocalDataPoolManager() {}
-
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	if(not mapInitialized) {
 		ReturnValue_t result = owner->initializePoolEntries(localPoolMap);
@@ -66,6 +62,58 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t LocalDataPoolManager::performHkOperation() {
+    for(auto& hkReceiversIter: hkReceiversMap) {
+        HkReceiver* receiver = &hkReceiversIter.second;
+        if(not receiver->reportingEnabled) {
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+
+        switch(receiver->reportingType) {
+        case(ReportingType::PERIODIC): {
+            if(receiver->dataId.dataSetSid.notSet()) {
+                // Periodic packets shall only be generated from datasets.
+                continue;
+            }
+            performPeriodicHkGeneration(receiver);
+            break;
+        }
+        case(ReportingType::UPDATE_SNAPSHOT): {
+            // check whether data has changed and send messages in case it has.
+            break;
+        }
+        default:
+            // This should never happen.
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
+		bool enableReporting, float collectionInterval, bool isDiagnostics,
+		object_id_t packetDestination) {
+	AcceptsHkPacketsIF* hkReceiverObject =
+			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	if(hkReceiverObject == nullptr) {
+		sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
+				" Invalid receiver!"<< std::endl;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataId.dataSetSid = sid;
+	hkReceiver.reportingType = ReportingType::PERIODIC;
+	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+	hkReceiver.reportingEnabled = enableReporting;
+	hkReceiver.hkParameter.collectionIntervalSeconds = collectionInterval;
+	hkReceiver.isDiagnostics = isDiagnostics;
+	hkReceiver.intervalCounter = 1;
+
+	hkReceiversMap.emplace(packetDestination, hkReceiver);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		CommandMessage* message) {
     Command_t command = message->getCommand();
@@ -106,46 +154,46 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
     return owner;
 }
 
-ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        float collectionInterval, MessageQueueId_t sendTo) {
-	LocalPoolDataSetBase* dataSetToSerialize = dynamic_cast<LocalPoolDataSetBase*>(
-			owner->getDataSetHandle(sid));
+ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
+	LocalPoolDataSetBase* dataSetToSerialize =
+			dynamic_cast<LocalPoolDataSetBase*>(owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
 				" Set ID not found" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	store_address_t storeId;
-	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
-	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
-	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-	    return result;
-	}
+//	store_address_t storeId;
+//	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
+//	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
+//	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId);
+//	if(result != HasReturnvaluesIF::RETURN_OK) {
+//	    return result;
+//	}
 
 	// and now we set a HK message and send it the HK packet destination.
-	CommandMessage hkMessage;
-	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
-	if(hkQueue == nullptr) {
-	    return QUEUE_OR_DESTINATION_NOT_SET;
-	}
+//	CommandMessage hkMessage;
+//	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+//	if(hkQueue == nullptr) {
+//	    return QUEUE_OR_DESTINATION_NOT_SET;
+//	}
+//
+//	if(sendTo != MessageQueueIF::NO_QUEUE) {
+//	    result = hkQueue->sendMessage(sendTo, &hkMessage);
+//	}
+//	else {
+//	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
+//	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
+//	                " Destination is not set properly!" << std::endl;
+//	        return QUEUE_OR_DESTINATION_NOT_SET;
+//	    }
+//	    else {
+//	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
+//	    }
+//	}
 
-	if(sendTo != MessageQueueIF::NO_QUEUE) {
-	    result = hkQueue->sendMessage(sendTo, &hkMessage);
-	}
-	else {
-	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
-	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
-	                " Destination is not set properly!" << std::endl;
-	        return QUEUE_OR_DESTINATION_NOT_SET;
-	    }
-	    else {
-	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
-	    }
-	}
-
-	return result;
+//	return result;
+	return 0;
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
@@ -198,40 +246,14 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 }
 
 
-ReturnValue_t LocalDataPoolManager::performHkOperation() {
-    for(auto& hkReceiversIter: hkReceiversMap) {
-        HkReceiver* receiver = &hkReceiversIter.second;
-        if(not receiver->reportingEnabled) {
-            return HasReturnvaluesIF::RETURN_OK;
-        }
 
-        switch(receiver->reportingType) {
-        case(ReportingType::PERIODIC): {
-            if(receiver->dataId.dataSetSid.notSet()) {
-                // Periodic packets shall only be generated from datasets.
-                continue;
-            }
-            performPeriodicHkGeneration(receiver);
-            break;
-        }
-        case(ReportingType::UPDATE_SNAPSHOT): {
-            // check whether data has changed and send messages in case it has.
-            break;
-        }
-        default:
-            // This should never happen.
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
     if(receiver->intervalCounter >= intervalSecondsToInterval(
             receiver->isDiagnostics,
             receiver->hkParameter.collectionIntervalSeconds)) {
         ReturnValue_t result = generateHousekeepingPacket(
-                receiver->dataId.dataSetSid, receiver->destinationQueue);
+                receiver->dataId.dataSetSid /*, receiver->destinationQueue */);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             // configuration error
             sif::debug << "LocalDataPoolManager::performHkOperation:"
@@ -259,7 +281,8 @@ uint32_t LocalDataPoolManager::intervalSecondsToInterval(bool isDiagnostics,
 float LocalDataPoolManager::intervalToIntervalSeconds(bool isDiagnostics,
         uint32_t collectionInterval) {
     if(isDiagnostics) {
-        return static_cast<float>(collectionInterval * diagnosticMinimumInterval);
+        return static_cast<float>(collectionInterval *
+        		diagnosticMinimumInterval);
     }
     else {
         return static_cast<float>(collectionInterval * regularMinimumInterval);
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 8700fd389..df2155ef9 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -53,7 +53,6 @@ public:
     static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
 
     static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
-    //static constexpr ReturnValue_t SET_NOT_FOUND = MAKE_RETURN_CODE(0x3);
 
     /**
      * This constructor is used by a class which wants to implement
@@ -79,6 +78,13 @@ public:
 	ReturnValue_t initialize(MessageQueueIF* queueToUse,
 			uint8_t nonDiagInvlFactor = 5);
 
+	/**
+	 * @return
+	 */
+	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
+			float collectionInterval, bool isDiagnostics,
+			object_id_t packetDestination = defaultHkDestination);
+
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
 	 * than diagnostic packets.
@@ -96,20 +102,13 @@ public:
 	 * @return
 	 */
 	ReturnValue_t performHkOperation();
-	/**
-	 * This function is used to set the default HK packet destination.
-	 * This destination will usually only be set once.
-	 * @param hkDestination
-	 */
-	void setHkPacketDestination(MessageQueueId_t hkDestination);
 
 	/**
 	 * Generate a housekeeping packet with a given SID.
 	 * @param sid
 	 * @return
 	 */
-	ReturnValue_t generateHousekeepingPacket(sid_t sid, float collectionInterval,
-	        MessageQueueId_t sendTo = MessageQueueIF::NO_QUEUE);
+	ReturnValue_t generateHousekeepingPacket(sid_t sid);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
@@ -174,14 +173,15 @@ private:
         type of data the receiver is interested in (full datasets or
         single data variables. */
         union DataId {
+        	DataId(): dataSetSid() {}
             /** Will be initialized to INVALID_ADDRESS */
             sid_t dataSetSid;
             lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
         };
         DataId dataId;
 
-        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         ReportingType reportingType = ReportingType::PERIODIC;
+        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         bool reportingEnabled = true;
         /** Different members of this union will be used depending on reporting
         type */
@@ -216,13 +216,6 @@ private:
 	 */
 	MessageQueueIF* hkQueue = nullptr;
 
-	/**
-	 * HK replies will always be a reply to the commander, but HK packet
-	 * can be sent to another destination by specifying this message queue
-	 * ID, for example to a dedicated housekeeping service implementation.
-	 */
-	MessageQueueId_t hkDestination = MessageQueueIF::NO_QUEUE;
-
 	/** Global IPC store is used to store all packets. */
 	StorageManagerIF* ipcStore = nullptr;
 	/**

From 8e7f167a6628c0b219b0cbe18e991a2b203a2170 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 24 Aug 2020 14:48:22 +0200
Subject: [PATCH 0652/1774] small fix taken over

---
 serialize/SerialBufferAdapter.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index b1e0856aa..5528331d7 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -30,15 +30,16 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
 	}
 	if (*size + serializedLength > maxSize) {
 		return BUFFER_TOO_SHORT;
-	} else {
+	} 
+	else {
 		if (serializeLength) {
 			SerializeAdapter::serialize(&bufferLength, buffer, size,
 					maxSize, streamEndianness);
 		}
-		if (constBuffer != nullptr) {
+		if (this->constBuffer != nullptr) {
 			memcpy(*buffer, this->constBuffer, bufferLength);
 		}
-		else if (buffer != nullptr) {
+		else if (this->buffer != nullptr) {
 			// This will propably be never reached, constBuffer should always be
 			// set if non-const buffer is set.
 			memcpy(*buffer, this->buffer, bufferLength);

From 11ce3d025fc58fd4205ddc3ef4302ab5262f8c2b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 24 Aug 2020 22:08:27 +0200
Subject: [PATCH 0653/1774] srv3 received reply now

---
 datapoollocal/HasLocalDataPoolIF.h        |  11 ++-
 datapoollocal/LocalDataPoolManager.cpp    | 113 ++++++++++++----------
 datapoollocal/LocalDataPoolManager.h      |  12 ++-
 datapoollocal/LocalDataSet.cpp            |   5 +-
 devicehandlers/DeviceHandlerBase.cpp      |  39 +++++---
 devicehandlers/DeviceHandlerBase.h        |  17 ++--
 housekeeping/HousekeepingPacketDownlink.h |   2 +-
 osal/FreeRTOS/FixedTimeslotTask.cpp       |  12 ++-
 osal/FreeRTOS/FixedTimeslotTask.h         |   2 +-
 osal/host/FixedTimeslotTask.cpp           |   2 +-
 osal/host/FixedTimeslotTask.h             |   2 +-
 osal/linux/FixedTimeslotTask.cpp          |   2 +-
 osal/linux/FixedTimeslotTask.h            |   2 +-
 osal/rtems/PollingTask.cpp                |   2 +-
 osal/rtems/PollingTask.h                  |   2 +-
 tasks/FixedSequenceSlot.cpp               |  13 +--
 tasks/FixedSequenceSlot.h                 |  16 +--
 tasks/FixedSlotSequence.cpp               |  51 +++++-----
 tasks/FixedSlotSequence.h                 |   9 +-
 tasks/FixedTimeslotTaskIF.h               |   8 +-
 20 files changed, 193 insertions(+), 129 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index d923b3919..9eb1c9f11 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -48,9 +48,14 @@ public:
 	/** Command queue for housekeeping messages. */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
-	/** Is used by pool owner to initialize the pool map once */
-	virtual ReturnValue_t initializePoolEntries(
-	        LocalDataPool& localDataPoolMap) = 0;
+	/**
+	 * Is used by pool owner to initialize the pool map once
+	 * The manager instance shall also be passed to this function.
+	 * It can be used to subscribe for periodic packets for for updates.
+	 */
+	virtual ReturnValue_t initializeLocalDataPool(
+	        LocalDataPool& localDataPoolMap,
+	        LocalDataPoolManager& poolManager) = 0;
 
 	/** Can be used to get a handle to the local data pool manager. */
 	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index a0f4337cb..87a0a3cb8 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -30,28 +30,41 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
 	}
 
 	hkQueue = queueToUse;
+
+	if(defaultHkDestination != objects::NO_OBJECT) {
+	    AcceptsHkPacketsIF* hkPacketReceiver =
+	            objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
+	    if(hkPacketReceiver != nullptr) {
+	        defaultHkDestinationId = hkPacketReceiver->getHkQueue();
+	    }
+	}
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
 
-ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
-        uint8_t nonDiagInvlFactor) {
+ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
         sif::error << "LocalDataPoolManager::initialize: Supplied queue "
                 "invalid!" << std::endl;
     }
     hkQueue = queueToUse;
 
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
+        uint8_t nonDiagInvlFactor) {
     setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
     diagnosticMinimumInterval = owner->getPeriodicOperationFrequency();
     regularMinimumInterval = diagnosticMinimumInterval *
-    		nonDiagnosticIntervalFactor;
+            nonDiagnosticIntervalFactor;
     return initializeHousekeepingPoolEntriesOnce();
 }
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	if(not mapInitialized) {
-		ReturnValue_t result = owner->initializePoolEntries(localPoolMap);
+		ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
+		        *this);
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			mapInitialized = true;
 		}
@@ -106,7 +119,16 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	hkReceiver.reportingType = ReportingType::PERIODIC;
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 	hkReceiver.reportingEnabled = enableReporting;
-	hkReceiver.hkParameter.collectionIntervalSeconds = collectionInterval;
+	if(not isDiagnostics) {
+	    hkReceiver.hkParameter.collectionIntervalTicks =
+	            intervalSecondsToInterval(isDiagnostics, collectionInterval *
+	            nonDiagnosticIntervalFactor);
+	}
+	else {
+	    hkReceiver.hkParameter.collectionIntervalTicks =
+	            intervalSecondsToInterval(isDiagnostics, collectionInterval);
+	}
+
 	hkReceiver.isDiagnostics = isDiagnostics;
 	hkReceiver.intervalCounter = 1;
 
@@ -154,54 +176,47 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
     return owner;
 }
 
-ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
+ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
+        float collectionInterval, MessageQueueId_t destination) {
 	LocalPoolDataSetBase* dataSetToSerialize =
 			dynamic_cast<LocalPoolDataSetBase*>(owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				" Set ID not found" << std::endl;
+				" Set ID not found or dataset not assigned!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-
-//	store_address_t storeId;
-//	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
-//	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
-//	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId);
-//	if(result != HasReturnvaluesIF::RETURN_OK) {
-//	    return result;
-//	}
+	sif::info << "hk gen called" << std::endl;
+	store_address_t storeId;
+	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
+	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
+	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+	    return result;
+	}
 
 	// and now we set a HK message and send it the HK packet destination.
-//	CommandMessage hkMessage;
-//	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
-//	if(hkQueue == nullptr) {
-//	    return QUEUE_OR_DESTINATION_NOT_SET;
-//	}
-//
-//	if(sendTo != MessageQueueIF::NO_QUEUE) {
-//	    result = hkQueue->sendMessage(sendTo, &hkMessage);
-//	}
-//	else {
-//	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
-//	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
-//	                " Destination is not set properly!" << std::endl;
-//	        return QUEUE_OR_DESTINATION_NOT_SET;
-//	    }
-//	    else {
-//	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
-//	    }
-//	}
+	CommandMessage hkMessage;
+	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+	if(hkQueue == nullptr) {
+	    return QUEUE_OR_DESTINATION_NOT_SET;
+	}
+	if(destination == MessageQueueIF::NO_QUEUE) {
+	    if(defaultHkDestinationId == MessageQueueIF::NO_QUEUE) {
+	        // error, all destinations invalid
+	        return HasReturnvaluesIF::RETURN_FAILED;
+	    }
+	    destination = defaultHkDestinationId;
+	}
 
-//	return result;
-	return 0;
+	return hkQueue->sendMessage(destination, &hkMessage);
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
         HousekeepingPacketDownlink& hkPacket,
         store_address_t *storeId) {
     uint8_t* dataPtr = nullptr;
-    size_t serializedSize = hkPacket.getSerializedSize();
-    const size_t maxSize = serializedSize;
+    size_t serializedSize = 0;
+    const size_t maxSize = hkPacket.getSerializedSize();
     ReturnValue_t  result = ipcStore->getFreeElement(storeId,
             serializedSize, &dataPtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
@@ -246,20 +261,17 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 }
 
 
-
-
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
-    if(receiver->intervalCounter >= intervalSecondsToInterval(
-            receiver->isDiagnostics,
-            receiver->hkParameter.collectionIntervalSeconds)) {
+    if(receiver->intervalCounter >=
+            receiver->hkParameter.collectionIntervalTicks) {
         ReturnValue_t result = generateHousekeepingPacket(
-                receiver->dataId.dataSetSid /*, receiver->destinationQueue */);
+                receiver->dataId.dataSetSid);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             // configuration error
             sif::debug << "LocalDataPoolManager::performHkOperation:"
                     << "0x" << std::setfill('0') << std::setw(8)
-            << owner->getObjectId() << " Error generating "
-            << "HK packet" << std::setfill(' ') << std::endl;
+                    << owner->getObjectId() << " Error generating "
+                    << "HK packet" << std::setfill(' ') << std::endl;
         }
         receiver->intervalCounter = 1;
     }
@@ -271,10 +283,12 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
 uint32_t LocalDataPoolManager::intervalSecondsToInterval(bool isDiagnostics,
         float collectionIntervalSeconds) {
     if(isDiagnostics) {
-        return std::ceil(collectionIntervalSeconds/diagnosticMinimumInterval);
+        return std::ceil(collectionIntervalSeconds * 1000
+                /diagnosticMinimumInterval);
     }
     else {
-        return std::ceil(collectionIntervalSeconds/regularMinimumInterval);
+        return std::ceil(collectionIntervalSeconds * 1000
+                /regularMinimumInterval);
     }
 }
 
@@ -285,6 +299,7 @@ float LocalDataPoolManager::intervalToIntervalSeconds(bool isDiagnostics,
         		diagnosticMinimumInterval);
     }
     else {
-        return static_cast<float>(collectionInterval * regularMinimumInterval);
+        return static_cast<float>(collectionInterval *
+                regularMinimumInterval);
     }
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index df2155ef9..c851978c4 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -75,8 +75,9 @@ public:
 	 * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
 	 * @return
 	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse,
-			uint8_t nonDiagInvlFactor = 5);
+	ReturnValue_t initialize(MessageQueueIF* queueToUse);
+
+	ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
 
 	/**
 	 * @return
@@ -108,7 +109,9 @@ public:
 	 * @param sid
 	 * @return
 	 */
-	ReturnValue_t generateHousekeepingPacket(sid_t sid);
+	ReturnValue_t generateHousekeepingPacket(sid_t sid,
+	        float collectionInterval = 0,
+	        MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
@@ -166,6 +169,7 @@ private:
 
 	/** Default receiver for periodic HK packets */
 	static object_id_t defaultHkDestination;
+	MessageQueueId_t defaultHkDestinationId = MessageQueueIF::NO_QUEUE;
 
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
@@ -187,7 +191,7 @@ private:
         type */
         union HkParameter {
             /** This parameter will be used for the PERIODIC type */
-            float collectionIntervalSeconds = 0;
+            uint32_t collectionIntervalTicks = 0;
             /** This parameter will be used for the ON_UPDATE type */
             bool hkDataChanged;
         };
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index f6f13313f..394a9abe9 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -6,8 +6,9 @@
 #include <cstring>
 
 LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner, uint32_t setId,
-        const size_t maxNumberOfVariables): poolVarList(maxNumberOfVariables),
-        LocalPoolDataSetBase(hkOwner, setId, nullptr, maxNumberOfVariables) {
+        const size_t maxNumberOfVariables):
+        LocalPoolDataSetBase(hkOwner, setId, nullptr, maxNumberOfVariables),
+        poolVarList(maxNumberOfVariables) {
 	this->setContainer(poolVarList.data());
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index a3b861b5e..0253d6a7c 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -391,24 +391,28 @@ 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) {
+		PoolDataSetIF* replyDataSet, 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) {
-		return insertInReplyMap(replyId, maxDelayCycles, replyLen, periodic);
+		return insertInReplyMap(replyId, maxDelayCycles,
+		        replyDataSet, replyLen, periodic);
 	} else {
-		return insertInReplyMap(deviceCommand, maxDelayCycles, replyLen, periodic);
+		return insertInReplyMap(deviceCommand, maxDelayCycles,
+		        replyDataSet, replyLen, periodic);
 	}
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, size_t replyLen, bool periodic) {
+		uint16_t maxDelayCycles, PoolDataSetIF* dataSet,
+		size_t replyLen, bool periodic) {
 	DeviceReplyInfo info;
 	info.maxDelayCycles = maxDelayCycles;
 	info.periodic = periodic;
 	info.delayCycles = 0;
 	info.replyLen = replyLen;
+	info.dataSet = dataSet;
 	info.command = deviceCommandMap.end();
 	auto resultPair = deviceReplyMap.emplace(replyId, info);
 	if (resultPair.second) {
@@ -434,13 +438,12 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(
 
 ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
 		uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
-	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
-			deviceReplyMap.find(deviceReply);
-	if (iter == deviceReplyMap.end()) {
+	auto replyIter = deviceReplyMap.find(deviceReply);
+	if (replyIter == deviceReplyMap.end()) {
 		triggerEvent(INVALID_DEVICE_COMMAND, deviceReply);
 		return RETURN_FAILED;
 	} else {
-		DeviceReplyInfo *info = &(iter->second);
+		DeviceReplyInfo *info = &(replyIter->second);
 		if (maxDelayCycles != 0) {
 			info->maxDelayCycles = maxDelayCycles;
 		}
@@ -450,6 +453,17 @@ ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceRep
 	}
 }
 
+
+ReturnValue_t DeviceHandlerBase::setReplyDataset(DeviceCommandId_t replyId,
+        PoolDataSetIF *dataSet) {
+    auto replyIter = deviceReplyMap.find(replyId);
+    if(replyIter == deviceReplyMap.end()) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    replyIter->second.dataSet = dataSet;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 void DeviceHandlerBase::callChildStatemachine() {
 	if (mode == _MODE_START_UP) {
 		doStartUp();
@@ -1363,8 +1377,9 @@ void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
 void DeviceHandlerBase::performOperationHook() {
 }
 
-ReturnValue_t DeviceHandlerBase::initializePoolEntries(
-		LocalDataPool &localDataPoolMap) {
+ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
+		LocalDataPool &localDataPoolMap,
+        LocalDataPoolManager& poolManager) {
 	return RETURN_OK;
 }
 
@@ -1379,6 +1394,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
     if(executingTask != nullptr) {
         pstIntervalMs = executingTask->getPeriodMs();
     }
+    this->hkManager.initializeAfterTaskCreation();
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -1399,3 +1415,4 @@ object_id_t DeviceHandlerBase::getObjectId() const {
 dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
     return pstIntervalMs;
 }
+
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index c3640e2f2..5357148e4 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -387,7 +387,8 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false,
+			uint16_t maxDelayCycles, PoolDataSetIF* replyDataSet = nullptr,
+			size_t replyLen = 0, bool periodic = false,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
 	/**
@@ -401,7 +402,8 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false);
+			uint16_t maxDelayCycles, PoolDataSetIF* dataSet = nullptr,
+			size_t replyLen = 0, bool periodic = false);
 
 	/**
 	 * @brief 	A simple command to add a command to the commandList.
@@ -429,6 +431,9 @@ protected:
 			uint16_t delayCycles, uint16_t maxDelayCycles,
 			bool periodic = false);
 
+	ReturnValue_t setReplyDataset(DeviceCommandId_t replyId,
+	        PoolDataSetIF* dataset);
+
 	/**
 	 * @brief   Can be implemented by child handler to
 	 *          perform debugging
@@ -482,8 +487,8 @@ protected:
 	 * @param localDataPoolMap
 	 * @return
 	 */
-	virtual ReturnValue_t initializePoolEntries(
-				LocalDataPool& localDataPoolMap) override;
+	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
+				LocalDataPoolManager& poolManager) override;
 
 	/** Get the HK manager object handle */
 	virtual LocalDataPoolManager* getHkManagerHandle() override;
@@ -656,7 +661,7 @@ protected:
 		//! 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;
+		PoolDataSetIF* dataSet = nullptr;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -1197,7 +1202,7 @@ private:
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
 	virtual ReturnValue_t initializeAfterTaskCreation() override;
-	DataSetIF* getDataSetHandle(sid_t sid) override;
+	virtual DataSetIF* getDataSetHandle(sid_t sid) override;
 
 	void parseReply(const uint8_t* receivedData,
 	            size_t receivedDataLen);
diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
index 97b6a9949..bee0bac10 100644
--- a/housekeeping/HousekeepingPacketDownlink.h
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -25,7 +25,7 @@ public:
 
     /**
      * Helper functions which can be used to move HK data from the IPC store
-     * to the telemetry store.
+     * to the telemetry store. TODO: maybe not needed.
      * @param formerStore
      * @param storeId
      * @param newStore
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 769f31e1b..a112092f8 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -8,7 +8,7 @@ const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
 FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
 		TaskStackSize setStack, TaskPeriod overallPeriod,
 		void (*setDeadlineMissedFunc)()) :
-		started(false), handle(NULL), pst(overallPeriod * 1000) {
+		started(false), handle(nullptr), pst(overallPeriod * 1000) {
 	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
 	xTaskCreate(taskEntryPoint, name, stackSize, this, setPriority, &handle);
 	// All additional attributes are applied to the object.
@@ -62,8 +62,10 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+    ExecutableObjectIF* handler =
+            objectManager->get<ExecutableObjectIF>(componentId);
+	if (handler != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, handler, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
@@ -76,8 +78,8 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 	return pst.getLengthMs();
 }
 
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
-	return pst.checkSequence();
+ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
+	return pst.checkAndInitializeSequence();
 }
 
 void FixedTimeslotTask::taskFunctionality() {
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 42af14b84..0e9611d20 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -54,7 +54,7 @@ public:
 
 	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t checkSequence() const override;
+	ReturnValue_t checkAndInitializeSequence() const override;
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
 
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 1999c9e62..2bb0f84d4 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -132,7 +132,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
     return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
+ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
     return pollingSeqTable.checkSequence();
 }
 
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index bbee94a63..861a072e4 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -61,7 +61,7 @@ public:
     ReturnValue_t addSlot(object_id_t componentId,
                    uint32_t slotTimeMs, int8_t executionStep);
 
-    ReturnValue_t checkSequence() const;
+    ReturnValue_t checkAndInitializeSequence() const;
 
     uint32_t getPeriodMs() const;
 
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 60ce9a63c..c381bb78d 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -49,7 +49,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
+ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
 	return pst.checkSequence();
 }
 
diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 83bf203e0..f7b6e9549 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -33,7 +33,7 @@ public:
 	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
 			int8_t executionStep);
 
-	virtual ReturnValue_t checkSequence() const;
+	virtual ReturnValue_t checkAndInitializeSequence() const;
 
 	/**
 	 * This static function can be used as #deadlineMissedFunc.
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index 527df367d..b53d6a5a4 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -82,7 +82,7 @@ uint32_t PollingTask::getPeriodMs() const {
 	return pst.getLengthMs();
 }
 
-ReturnValue_t PollingTask::checkSequence() const {
+ReturnValue_t PollingTask::checkAndInitializeSequence() const {
 	return pst.checkSequence();
 }
 
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 759ed43d7..60ce08164 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -42,7 +42,7 @@ class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
 
 	uint32_t getPeriodMs() const;
 
-	ReturnValue_t checkSequence() const;
+	ReturnValue_t checkAndInitializeSequence() const;
 
 	ReturnValue_t sleepFor(uint32_t ms);
 protected:
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index cccc6371f..9d290d19f 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -3,13 +3,14 @@
 #include <cstddef>
 
 FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
-		int8_t setSequenceId, PeriodicTaskIF* executingTask) :
+		int8_t setSequenceId, ExecutableObjectIF* executableObject,
+		PeriodicTaskIF* executingTask) :
 		pollingTimeMs(setTime), opcode(setSequenceId) {
-	handler = objectManager->get<ExecutableObjectIF>(handlerId);
-	if(executingTask != nullptr) {
-	    handler->setTaskIF(executingTask);
-	}
-	handler->initializeAfterTaskCreation();
+    if(executableObject == nullptr) {
+        return;
+    }
+    this->executableObject = executableObject;
+    this->executableObject->setTaskIF(executingTask);
 }
 
 FixedSequenceSlot::~FixedSequenceSlot() {}
diff --git a/tasks/FixedSequenceSlot.h b/tasks/FixedSequenceSlot.h
index e33134de9..9cf5894c0 100644
--- a/tasks/FixedSequenceSlot.h
+++ b/tasks/FixedSequenceSlot.h
@@ -16,21 +16,23 @@ class PeriodicTaskIF;
 class FixedSequenceSlot {
 public:
 	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
-			int8_t setSequenceId, PeriodicTaskIF* executingTask );
+			int8_t setSequenceId, ExecutableObjectIF* executableObject,
+			PeriodicTaskIF* executingTask);
 	virtual ~FixedSequenceSlot();
 
 	/**
-	 * @brief	Handler identifies which device handler object is executed in this slot.
+	 * @brief	Handler identifies which object is executed in this slot.
 	 */
-	ExecutableObjectIF*	handler = nullptr;
+	ExecutableObjectIF*	executableObject = nullptr;
 
 	/**
 	 * @brief	This attribute defines when a device handler object is executed.
-	 *
-	 * @details	The pollingTime attribute identifies the time the handler is executed in ms.
-	 * 			It must be smaller than the period length of the polling sequence.
+	 * @details
+	 * The pollingTime attribute identifies the time the handler is
+	 * executed in ms. It must be smaller than the period length of the
+	 * polling sequence.
 	 */
-	uint32_t	pollingTimeMs;
+	uint32_t pollingTimeMs;
 
 	/**
 	 * @brief	This value defines the type of device communication.
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index 27dfff2b2..e51762ea7 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -13,7 +13,7 @@ FixedSlotSequence::~FixedSlotSequence() {
 }
 
 void FixedSlotSequence::executeAndAdvance() {
-	current->handler->performOperation(current->opcode);
+	current->executableObject->performOperation(current->opcode);
 //	if (returnValue != RETURN_OK) {
 //		this->sendErrorMessage( returnValue );
 //	}
@@ -81,34 +81,38 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 	return this->lengthMs;
 }
 
-ReturnValue_t FixedSlotSequence::checkSequence() const {
+ReturnValue_t FixedSlotSequence::checkAndInitializeSequence() const {
 	if(slotList.empty()) {
 		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	auto slotIt = slotList.begin();
+	std::set<ExecutableObjectIF*> uniqueObjects;
 	uint32_t count = 0;
 	uint32_t time = 0;
-	while (slotIt != slotList.end()) {
-		if (slotIt->handler == nullptr) {
-			sif::error << "FixedSlotSequene::initialize: ObjectId does not exist!"
-					<< std::endl;
+	for(const auto& slot: slotList) {
+		if (slot.executableObject == nullptr) {
 			count++;
-		} else if (slotIt->pollingTimeMs < time) {
-			sif::error << "FixedSlotSequence::initialize: Time: "
-					<< slotIt->pollingTimeMs
-					<< " is smaller than previous with " << time << std::endl;
-			count++;
-		} else {
-			// All ok, print slot.
-			//info << "Current slot polling time: " << std::endl;
-			//info << std::dec << slotIt->pollingTimeMs << std::endl;
 		}
-		time = slotIt->pollingTimeMs;
-		slotIt++;
+		else if (slot.pollingTimeMs < time) {
+			sif::error << "FixedSlotSequence::initialize: Time: "
+					<< slot.pollingTimeMs << " is smaller than previous with "
+					<< time << std::endl;
+			count++;
+		}
+		else {
+			// All ok, print slot.
+			//sif::info << "Current slot polling time: " << std::endl;
+			//sif::info << std::dec << slotIt->pollingTimeMs << std::endl;
+		}
+		time = slot.pollingTimeMs;
+		// Ensure that each unique object is initialized once.
+		if(uniqueObjects.find(slot.executableObject) == uniqueObjects.end()) {
+		    slot.executableObject->initializeAfterTaskCreation();
+		    uniqueObjects.emplace(slot.executableObject);
+		}
 	}
-	//info << "Number of elements in slot list: "
+	//sif::info << "Number of elements in slot list: "
 	//	   << slotList.size() << std::endl;
 	if (count > 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
@@ -117,8 +121,9 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 }
 
 void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
-		int8_t executionStep, PeriodicTaskIF* executingTask) {
-	this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs, executionStep,
-			executingTask));
-	this->current = slotList.begin();
+		int8_t executionStep, ExecutableObjectIF* executableObject,
+		PeriodicTaskIF* executingTask) {
+    this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs,
+            executionStep, executableObject, executingTask));
+   this->current = slotList.begin();
 }
diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 67ce00947..1aa420ce5 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -59,7 +59,7 @@ public:
 	 * 	@param
 	 */
 	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
-			PeriodicTaskIF* executingTask);
+			ExecutableObjectIF* executableObject, PeriodicTaskIF* executingTask);
 
 	/**
 	 * Checks if the current slot shall be executed immediately after the one before.
@@ -125,11 +125,14 @@ public:
 	SlotListIter current;
 
 	/**
-	 * Iterate through slotList and check successful creation.
+	 * @brief   Check and initialize slot list.
+	 * @details
 	 * Checks if timing is ok (must be ascending) and if all handlers were found.
+	 * Also calls any initialization steps which are required after task
+	 * creation.
 	 * @return
 	 */
-	ReturnValue_t checkSequence() const;
+	ReturnValue_t checkAndInitializeSequence() const;
 
 protected:
 
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index 3456dae78..d31554903 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -22,8 +22,12 @@ public:
 	 */
 	virtual ReturnValue_t addSlot(object_id_t componentId,
 			uint32_t slotTimeMs, int8_t executionStep) = 0;
-	/** Check whether the sequence is valid */
-	virtual ReturnValue_t checkSequence() const = 0;
+
+	/**
+	 * Check whether the sequence is valid and perform all other required
+	 * initialization steps which are needed after task creation
+	 */
+	virtual ReturnValue_t checkAndInitializeSequence() const = 0;
 };
 
 #endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */

From c8ba486538fe6086ab8835a70c5656dd5a4ce1af Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Aug 2020 13:17:57 +0200
Subject: [PATCH 0654/1774] serial buffer adapter

---
 serialize/SerialBufferAdapter.cpp | 33 ++++++++++++++-----------------
 1 file changed, 15 insertions(+), 18 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 5528331d7..53d0b8d49 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -20,9 +20,9 @@ template<typename count_t>
 SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
 		serializedLength += SerializeAdapter::getSerializedSize(
@@ -53,8 +53,8 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
 	}
 }
 
-template<typename T>
-size_t SerialBufferAdapter<T>::getSerializedSize() const {
+template<typename count_t>
+size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
 	if (serializeLength) {
 		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
@@ -62,26 +62,22 @@ size_t SerialBufferAdapter<T>::getSerializedSize() const {
 	}
 }
 
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		size_t* size, Endianness streamEndianness) {
 	//TODO Ignores Endian flag!
-	if (buffer != NULL) {
+	if (this->buffer != nullptr) {
 		if(serializeLength){
-			T serializedSize = SerializeAdapter::getSerializedSize(
-					&bufferLength);
-			if(bufferLength + serializedSize <= *size) {
-				*buffer +=  serializedSize;
-				*size -= serializedSize;
-			}
-			else {
-				return STREAM_TOO_SHORT;
+			ReturnValue_t result = SerializeAdapter::deSerialize(&bufferLength,
+					buffer, size, streamEndianness);
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
 			}
 		}
 		//No Else If, go on with buffer
 		if (bufferLength <= *size) {
 			*size -= bufferLength;
-			memcpy(this->buffer, *buffer, bufferLength);
+			std::memcpy(this->buffer, *buffer, bufferLength);
 			(*buffer) += bufferLength;
 			return HasReturnvaluesIF::RETURN_OK;
 		}
@@ -107,7 +103,8 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
-		sif::error << "SerialBufferAdapter: Buffers are unitialized!" << std::endl;
+		sif::error << "SerialBufferAdapter::getConstBuffer:"
+				" Buffers are unitialized!" << std::endl;
 		return nullptr;
 	}
 	return constBuffer;

From b97128c12eed9d6b3e5d74f861ab99c6c7cea7ba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Aug 2020 13:29:10 +0200
Subject: [PATCH 0655/1774] deserialize improved

---
 serialize/SerialBufferAdapter.cpp | 39 +++++++++++++++++--------------
 1 file changed, 21 insertions(+), 18 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 53d0b8d49..8a5bef4a5 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -65,28 +65,31 @@ size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
 template<typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		size_t* size, Endianness streamEndianness) {
-	//TODO Ignores Endian flag!
-	if (this->buffer != nullptr) {
-		if(serializeLength){
-			ReturnValue_t result = SerializeAdapter::deSerialize(&bufferLength,
-					buffer, size, streamEndianness);
-			if(result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
+	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;
 		}
-		//No Else If, go on with buffer
-		if (bufferLength <= *size) {
-			*size -= bufferLength;
-			std::memcpy(this->buffer, *buffer, bufferLength);
-			(*buffer) += bufferLength;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-		else {
-			return STREAM_TOO_SHORT;
+		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 HasReturnvaluesIF::RETURN_FAILED;
+		return STREAM_TOO_SHORT;
 	}
 }
 

From 92e18b91a3a9d4dac069281971009b4dba5a1dd7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Aug 2020 13:38:53 +0200
Subject: [PATCH 0656/1774] seriasl buffer update

---
 serialize/SerialBufferAdapter.cpp | 49 ++++++++++++++++---------------
 1 file changed, 25 insertions(+), 24 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 8a5bef4a5..ab52262fb 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -23,34 +23,33 @@ 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 {
-	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
-		serializedLength += SerializeAdapter::getSerializedSize(
-				&bufferLength);
+		ReturnValue_t result = SerializeAdapter::serialize(&bufferLength,
+				buffer, size, maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 	}
-	if (*size + serializedLength > maxSize) {
+
+	if (*size + bufferLength > maxSize) {
 		return BUFFER_TOO_SHORT;
-	} 
-	else {
-		if (serializeLength) {
-			SerializeAdapter::serialize(&bufferLength, buffer, size,
-					maxSize, streamEndianness);
-		}
-		if (this->constBuffer != nullptr) {
-			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.
-			memcpy(*buffer, this->buffer, bufferLength);
-		}
-		else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		*size += bufferLength;
-		(*buffer) += bufferLength;
-		return HasReturnvaluesIF::RETURN_OK;
 	}
+
+	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>
@@ -126,4 +125,6 @@ void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
 template class SerialBufferAdapter<uint8_t>;
 template class SerialBufferAdapter<uint16_t>;
 template class SerialBufferAdapter<uint32_t>;
+template class SerialBufferAdapter<uint64_t>;
+template class SerialBufferAdapter<size_t>;
 

From 6afbeb8423cdb3d5a0cf2d2c41623d1310ed2e73 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Aug 2020 13:42:11 +0200
Subject: [PATCH 0657/1774] removed linker forward decl

---
 serialize/SerialBufferAdapter.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index ab52262fb..812cd34b2 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -126,5 +126,4 @@ template class SerialBufferAdapter<uint8_t>;
 template class SerialBufferAdapter<uint16_t>;
 template class SerialBufferAdapter<uint32_t>;
 template class SerialBufferAdapter<uint64_t>;
-template class SerialBufferAdapter<size_t>;
 

From da3b2b2500592047335c689d8f7d9b9b15f60a86 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Aug 2020 18:09:05 +0200
Subject: [PATCH 0658/1774] form improvements

---
 ipc/CommandMessage.cpp         |   4 +-
 ipc/CommandMessage.h           |  12 ++--
 ipc/CommandMessageIF.h         |  10 +--
 ipc/MessageQueueIF.h           | 111 ++++++++++++++++++++------------
 ipc/MessageQueueMessage.cpp    |   2 +-
 ipc/MessageQueueMessage.h      |   6 +-
 ipc/MessageQueueMessageIF.h    |   6 +-
 ipc/MutexHelper.h              |   6 +-
 ipc/QueueFactory.h             |   2 +-
 osal/FreeRTOS/MessageQueue.cpp |  10 +--
 osal/FreeRTOS/MessageQueue.h   | 113 ++++++++-------------------------
 11 files changed, 125 insertions(+), 157 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 6934e6ce8..16293608d 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,5 +1,5 @@
-#include "../ipc/CommandMessage.h"
-#include "../ipc/CommandMessageCleaner.h"
+#include "CommandMessage.h"
+#include "CommandMessageCleaner.h"
 #include <cstring>
 
 CommandMessage::CommandMessage() {
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 73b73dc91..3be9a1205 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,9 +1,9 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGE_H_
+#ifndef FSFW_IPC_COMMANDMESSAGE_H_
+#define FSFW_IPC_COMMANDMESSAGE_H_
 
-#include "../ipc/CommandMessageIF.h"
-#include "../ipc/MessageQueueMessage.h"
-#include "../ipc/FwMessageTypes.h"
+#include "CommandMessageIF.h"
+#include "MessageQueueMessage.h"
+#include "FwMessageTypes.h"
 
 /**
  * @brief 	Default command message used to pass command messages between tasks.
@@ -126,4 +126,4 @@ public:
     size_t getMinimumMessageSize() const override;
 };
 
-#endif /* COMMANDMESSAGE_H_ */
+#endif /* FSFW_IPC_COMMANDMESSAGE_H_ */
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index e5f962aec..68a8d9564 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
+#ifndef FSFW_IPC_COMMANDMESSAGEIF_H_
+#define FSFW_IPC_COMMANDMESSAGEIF_H_
 
-#include "../ipc/MessageQueueMessageIF.h"
-#include "../ipc/FwMessageTypes.h"
+#include "MessageQueueMessageIF.h"
+#include "FwMessageTypes.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
@@ -70,4 +70,4 @@ public:
 
 };
 
-#endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */
+#endif /* FSFW_IPC_COMMANDMESSAGEIF_H_ */
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 6ae852eae..1e80f7bd5 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
+#ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
+#define FSFW_IPC_MESSAGEQUEUEIF_H_
 
 // COULDDO: We could support blocking calls
 // semaphores are being implemented, which makes this idea even more iteresting.
@@ -30,21 +30,28 @@ public:
 	virtual ~MessageQueueIF() {}
 	/**
 	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter 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.
-	 * @return RETURN_OK if ok
-	 * @return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
+	 * @details
+	 * This operation simplifies answering an incoming message by using the
+	 * stored lastParnter 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.
+	 * @return
+	 * -@c RETURN_OK if ok
+	 * -@c NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found.
 	 */
-	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) = 0;
+	virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0;
 
 	/**
-	 * @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.
+	 * @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.
 	 */
 	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom) = 0;
@@ -57,7 +64,8 @@ public:
 	 * information is stored in theblastPartner 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.
+	 * @param message
+	 * A pointer to a message in which the received data is stored.
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::EMPTY if queue is empty
 	 */
@@ -69,24 +77,33 @@ public:
 	 */
 	virtual ReturnValue_t flush(uint32_t* count) = 0;
 	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
+	 * @brief	This method returns the message queue
+	 *          id of the last communication partner.
 	 */
 	virtual MessageQueueId_t getLastPartner() const = 0;
 	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
+	 * @brief	This method returns the message queue
+	 *          id of this class's message queue.
 	 */
 	virtual MessageQueueId_t getId() const = 0;
 
 	/**
-	 * @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 (if implemented).
+	 * @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 returnvalue 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 (if implemented).
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
@@ -96,21 +113,31 @@ public:
 
 	/**
 	 * @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.
+	 * @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.
 	 */
 	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
 
 	/**
-	 * @brief	The sendToDefaultFrom 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.
+	 * @brief	The sendToDefaultFrom 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.
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
@@ -118,19 +145,21 @@ public:
 			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
 	/**
 	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-	 * 			Implementation class and adds its queue id as "sentFrom" information.
+	 * @details
+	 * As in the sendMessage method, this function uses the sendToDefault
+	 * call of the Implementation class and adds its queue id as
+	 * "sentFrom" information.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
 	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
 	/**
-	 * \brief	This method is a simple setter for the default destination.
+	 * @brief	This method is a simple setter for the default destination.
 	 */
 	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) = 0;
 	/**
-	 * \brief	This method is a simple getter for the default destination.
+	 * @brief	This method is a simple getter for the default destination.
 	 */
 	virtual MessageQueueId_t getDefaultDestination() const = 0;
 
@@ -139,4 +168,4 @@ public:
 
 
 
-#endif /* FRAMEWORK_IPC_MESSAGEQUEUEIF_H_ */
+#endif /* FSFW_IPC_MESSAGEQUEUEIF_H_ */
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index d00321297..2f79cb3b9 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -1,4 +1,4 @@
-#include "../ipc/MessageQueueMessage.h"
+#include "MessageQueueMessage.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../globalfunctions/arrayprinter.h"
 #include <cstring>
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index cf06fde62..da5c78cb8 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
+#ifndef FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
+#define FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
 
 #include "../ipc/MessageQueueMessageIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
@@ -147,4 +147,4 @@ public:
 	void print(bool printWholeMessage);
 };
 
-#endif /* MESSAGEQUEUEMESSAGE_H_ */
+#endif /* FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ */
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index c6c677c1e..91753ced9 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -29,8 +29,10 @@ public:
 
 	/**
 	 * @brief	With this method, the whole content and the message
-	 * 			size is set to zero. Implementations should also take care
-	 * 			to clear data which is stored indirectly (e.g. storage data).
+	 * 			size is set to zero.
+	 * @details
+	 * Implementations should also take care to clear data which is stored
+	 * indirectly (e.g. storage data).
 	 */
 	virtual void clear() = 0;
 
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 31d8d9ecb..97e280072 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_MUTEXHELPER_H_
 #define FRAMEWORK_IPC_MUTEXHELPER_H_
 
-#include "../ipc/MutexFactory.h"
+#include "MutexFactory.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 class MutexHelper {
@@ -16,8 +16,8 @@ public:
 					<< timeoutMs << " milliseconds!" << std::endl;
 		}
 		else if(status != HasReturnvaluesIF::RETURN_OK){
-			sif::error << "MutexHelper: Lock of Mutex failed with code " <<
-					status << std::endl;
+			sif::error << "MutexHelper: Lock of Mutex failed with code "
+			        << status << std::endl;
 		}
 	}
 
diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index 8141a3cf2..e98919877 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
 #define FRAMEWORK_IPC_QUEUEFACTORY_H_
 
-#include "../ipc/MessageQueueIF.h"
+#include "MessageQueueIF.h"
 #include <cstdint>
 /**
  * Creates message queues.
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 933689e83..e3e0ef1c1 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/FreeRTOS/MessageQueue.h"
+#include "MessageQueue.h"
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
@@ -10,13 +10,13 @@
 MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		maxMessageSize(maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
-	if (handle == NULL) {
-		sif::error << "MessageQueue: Creation failed" << std::endl;
+	if (handle == nullptr) {
+		sif::error << "MessageQueue::MessageQueue Creation failed" << std::endl;
 	}
 }
 
 MessageQueue::~MessageQueue() {
-	if (handle != NULL) {
+	if (handle != nullptr) {
 		vQueueDelete(handle);
 	}
 }
@@ -126,7 +126,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	BaseType_t result = pdFALSE;
 	QueueHandle_t destination = nullptr;
 
-	if(sendTo == MessageQueueIF::NO_QUEUE) {
+	if(sendTo == MessageQueueIF::NO_QUEUE or sendTo == 0x00) {
 		return MessageQueueIF::DESTINVATION_INVALID;
 	}
 	else  {
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 48a5ab6a6..11986751e 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -1,5 +1,5 @@
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
+#ifndef FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
+#define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueIF.h"
@@ -43,11 +43,12 @@ 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 i case of failure, it is set to zero.
+	 * 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.
@@ -76,103 +77,39 @@ public:
 	 */
 	void switchSystemContext(CallContext callContext);
 
-	/**
-	 * @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.
-	 */
+	/** MessageQueueIF implementation */
 	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
-	 * 			lastParnter 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.
-	 */
+	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
 	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);
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	MessageQueueId_t getId() const;
 
-	/**
-	 * @brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * @brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
+	ReturnValue_t flush(uint32_t* count) override;
+
+	MessageQueueId_t getLastPartner() const override;
+
+	MessageQueueId_t getId() const override;
+
+	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+
+	MessageQueueId_t getDefaultDestination() const override;
+
+	bool isDefaultDestinationSet() const override;
 
-	bool isDefaultDestinationSet() const;
 protected:
 	/**
 	 * @brief 	Implementation to be called from any send Call within
@@ -205,8 +142,8 @@ private:
 	MessageQueueId_t defaultDestination = 0;
 	MessageQueueId_t lastPartner = 0;
 	const size_t maxMessageSize;
-	//!< Stores the current system context
+	//! Stores the current system context
 	CallContext callContext =  CallContext::TASK;
 };
 
-#endif /* MESSAGEQUEUE_H_ */
+#endif /* FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_ */

From c314792e86042a2d60a7ce3a6af265fea4da61a7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 26 Aug 2020 02:52:59 +0200
Subject: [PATCH 0659/1774] linebreak changed

---
 globalfunctions/arrayprinter.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index ca080cc5f..1e58ca755 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -27,7 +27,7 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 		if(i < size - 1){
 			sif::info << " , ";
 			if(i > 0 and i % maxCharPerLine == 0) {
-				printf("\n");
+				sif::info << "\r\n" << std::flush;
 			}
 		}
 

From 51b62fd9b189ea149b64a2015c0497240041129c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 26 Aug 2020 03:21:26 +0200
Subject: [PATCH 0660/1774] debug output fix

---
 pus/Service1TelecommandVerification.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index f6cbf6bf7..fb66c1608 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -53,7 +53,7 @@ ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
 		result = generateSuccessReport(message);
 	}
 	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Service1TelecommandVerification::initialize: "
+		sif::error << "Service1TelecommandVerification::sendVerificationReport: "
 		        "Sending verification packet failed !" << std::endl;
 	}
 	return result;

From 83c9d4fc1cb22228f1d58a0f6ba5a1f0f36b6fb0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 26 Aug 2020 14:55:27 +0200
Subject: [PATCH 0661/1774] improved tmtc bridge

---
 tmtcservices/TmTcBridge.cpp | 88 +++++++++++++++++++++++--------------
 tmtcservices/TmTcBridge.h   | 14 ++++--
 2 files changed, 65 insertions(+), 37 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 5df8eee93..29153dd5f 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -66,6 +66,8 @@ ReturnValue_t TmTcBridge::initialize() {
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
+	tmFifo = new DynamicFIFO<store_address_t>(maxNumberOfPacketsStored);
+
 	tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
 	return RETURN_OK;
 }
@@ -90,17 +92,25 @@ ReturnValue_t TmTcBridge::handleTc() {
 }
 
 ReturnValue_t TmTcBridge::handleTm() {
+    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
-		sif::warning << "TmTcBridge: Reading TM Queue failed" << std::endl;
-		return RETURN_FAILED;
+		sif::error << "TmTcBridge::handleTm: Error handling TM queue!"
+		        << std::endl;
+		status = result;
 	}
 
-	if(tmStored and communicationLinkUp) {
-		result = handleStoredTm();
+	if(tmStored and communicationLinkUp and
+	        (packetSentCounter < sentPacketsPerCycle)) {
+	    result = handleStoredTm();
+	    if(result != RETURN_OK) {
+	        sif::error << "TmTcBridge::handleTm: Error handling stored TMs!"
+	                << std::endl;
+	        status = result;
+	    }
 	}
-	return result;
-
+	packetSentCounter = 0;
+	return status;
 }
 
 ReturnValue_t TmTcBridge::handleTmQueue() {
@@ -109,85 +119,91 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 	size_t size = 0;
 	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
-		 result == RETURN_OK; result = tmTcReceptionQueue->receiveMessage(&message))
+		 result == HasReturnvaluesIF::RETURN_OK;
+		 result = tmTcReceptionQueue->receiveMessage(&message))
 	{
-		if(communicationLinkUp == false) {
+		if(communicationLinkUp == false or
+		        packetSentCounter >= sentPacketsPerCycle) {
 			storeDownlinkData(&message);
 			continue;
 		}
 
 		result = tmStore->getData(message.getStorageId(), &data, &size);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "TmTcBridge::handleTmQueue: Invalid store "
-					"ID!" << std::endl;
+			status = result;
 			continue;
 		}
 
 		result = sendTm(data, size);
-		if (result != RETURN_OK) {
-			sif::warning << "TmTcBridge: Could not send TM packet" << std::endl;
-			status = HasReturnvaluesIF::RETURN_FAILED;
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
 		}
 		tmStore->deleteData(message.getStorageId());
+		packetSentCounter++;
 	}
 	return status;
 }
 
-// todo: make it configurable whether old data is deleted.
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	store_address_t storeId = 0;
 
-	if(tmFifo.full()) {
-		sif::error << "TmTcBridge::storeDownlinkData: TM downlink max. number "
-		        << "of stored packet IDs reached! "
-		        << "Overwriting old data" << std::endl;
-		tmFifo.retrieve(&storeId);
-		tmStore->deleteData(storeId);
+	if(tmFifo->full()) {
+	    sif::debug << "TmTcBridge::storeDownlinkData: TM downlink max. number "
+	                    << "of stored packet IDs reached! " << std::endl;
+	    if(overwriteOld) {
+	        tmFifo->retrieve(&storeId);
+	                tmStore->deleteData(storeId);
+	    }
+	    else {
+	        return HasReturnvaluesIF::RETURN_FAILED;
+	    }
 	}
+
 	storeId = message->getStorageId();
-	tmFifo.insert(storeId);
+	tmFifo->insert(storeId);
 	tmStored = true;
 	return RETURN_OK;
 }
 
 ReturnValue_t TmTcBridge::handleStoredTm() {
-	uint8_t counter = 0;
-	ReturnValue_t result = RETURN_OK;
-	while(not tmFifo.empty() and counter < sentPacketsPerCycle) {
+    ReturnValue_t status = RETURN_OK;
+	while(not tmFifo->empty() and packetSentCounter < sentPacketsPerCycle) {
 		//info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
 		const uint8_t* data = nullptr;
 		size_t size = 0;
-		tmFifo.retrieve(&storeId);
-		result = tmStore->getData(storeId, &data, &size);
-
-		sendTm(data,size);
+		tmFifo->retrieve(&storeId);
+		ReturnValue_t result = tmStore->getData(storeId, &data, &size);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+		    status = result;
+		}
 
+		result = sendTm(data,size);
 		if(result != RETURN_OK) {
 			sif::error << "TMTC Bridge: Could not send stored downlink data"
 			      << std::endl;
-			result = RETURN_FAILED;
+			status = result;
 		}
-		counter ++;
+		packetSentCounter ++;
 
-		if(tmFifo.empty()) {
+		if(tmFifo->empty()) {
 			tmStored = false;
 		}
 		tmStore->deleteData(storeId);
 	}
-	return result;
+	return status;
 }
 
 void TmTcBridge::registerCommConnect() {
 	if(not communicationLinkUp) {
-		//info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
+		//sif::info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
 		communicationLinkUp = true;
 	}
 }
 
 void TmTcBridge::registerCommDisconnect() {
-	//info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
+	//sif::info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
 	if(communicationLinkUp) {
 		communicationLinkUp = false;
 	}
@@ -211,3 +227,7 @@ MessageQueueId_t TmTcBridge::getRequestQueue() {
 	// Default implementation: Relay TC messages to TC distributor directly.
 	return tmTcReceptionQueue->getDefaultDestination();
 }
+
+void TmTcBridge::setFifoToOverwriteOldData(bool overwriteOld) {
+    this->overwriteOld = overwriteOld;
+}
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index b91425e1f..763980dc6 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,14 +1,14 @@
 #ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 #define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 
+
 #include "../objectmanager/SystemObject.h"
 #include "../tmtcservices/AcceptsTelemetryIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
-
-#include "../container/FIFO.h"
+#include "../container/DynamicFIFO.h"
 #include "../tmtcservices/TmTcMessage.h"
 
 class TmTcBridge : public AcceptsTelemetryIF,
@@ -46,6 +46,12 @@ public:
 	 */
 	ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
 
+	/**
+	 * This will set up the bridge to overwrite old data in the FIFO.
+	 * @param overwriteOld
+	 */
+	void setFifoToOverwriteOldData(bool overwriteOld);
+
 	virtual void registerCommConnect();
 	virtual void registerCommDisconnect();
 
@@ -86,6 +92,8 @@ protected:
 	//! by default, so telemetry will be handled immediately.
 	bool communicationLinkUp = true;
 	bool tmStored = false;
+	bool overwriteOld = true;
+	uint8_t packetSentCounter = 0;
 
 	/**
 	 * @brief 	Handle TC reception
@@ -145,7 +153,7 @@ protected:
 	 * This fifo can be used to store downlink data
 	 * which can not be sent at the moment.
 	 */
-	FIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
+	DynamicFIFO<store_address_t>* tmFifo = nullptr;
     uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
     uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };

From 0f9930524b4b7ff8e3e4d5b13ea926ce4b3676f3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 26 Aug 2020 15:54:13 +0200
Subject: [PATCH 0662/1774] some minor improvements

---
 tmtcservices/TmTcBridge.cpp | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 29153dd5f..706bbbf2e 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -122,6 +122,7 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 		 result == HasReturnvaluesIF::RETURN_OK;
 		 result = tmTcReceptionQueue->receiveMessage(&message))
 	{
+	    //sif::info << (int) packetSentCounter << std::endl;
 		if(communicationLinkUp == false or
 		        packetSentCounter >= sentPacketsPerCycle) {
 			storeDownlinkData(&message);
@@ -138,8 +139,10 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			status = result;
 		}
-		tmStore->deleteData(message.getStorageId());
-		packetSentCounter++;
+		else {
+		    tmStore->deleteData(message.getStorageId());
+		    packetSentCounter++;
+		}
 	}
 	return status;
 }
@@ -152,7 +155,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	                    << "of stored packet IDs reached! " << std::endl;
 	    if(overwriteOld) {
 	        tmFifo->retrieve(&storeId);
-	                tmStore->deleteData(storeId);
+	        tmStore->deleteData(storeId);
 	    }
 	    else {
 	        return HasReturnvaluesIF::RETURN_FAILED;
@@ -168,8 +171,9 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 ReturnValue_t TmTcBridge::handleStoredTm() {
     ReturnValue_t status = RETURN_OK;
 	while(not tmFifo->empty() and packetSentCounter < sentPacketsPerCycle) {
-		//info << "TMTC Bridge: Sending stored TM data. There are "
-		//     << (int) fifo.size() << " left to send\r\n" << std::flush;
+		//sif::info << "TMTC Bridge: Sending stored TM data. There are "
+		//     << (int) tmFifo->size() << " left to send\r\n" << std::flush;
+
 		store_address_t storeId;
 		const uint8_t* data = nullptr;
 		size_t size = 0;

From 67ab1f6240772ba1c85c6c826f8e9ee097418127 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 14:17:13 +0200
Subject: [PATCH 0663/1774] initialize after task crteation moved

---
 controller/ControllerBase.cpp  | 15 ++++++----
 controller/ControllerBase.h    | 55 +++++++++++++++++++++-------------
 osal/FreeRTOS/PeriodicTask.cpp |  7 ++++-
 3 files changed, 50 insertions(+), 27 deletions(-)

diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 4ce854dc1..2f43b13e5 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -4,13 +4,12 @@
 #include "../ipc/QueueFactory.h"
 #include "../action/HasActionsIF.h"
 
-ControllerBase::ControllerBase(uint32_t setObjectId, uint32_t parentId,
+ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
 		size_t commandQueueDepth) :
-		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF), submode(
-				SUBMODE_NONE), commandQueue(NULL), modeHelper(
-				this), healthHelper(this, setObjectId),hkSwitcher(this),executingTask(NULL) {
+		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
+		submode(SUBMODE_NONE), modeHelper(this),
+		healthHelper(this, setObjectId), hkSwitcher(this) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
-
 }
 
 ControllerBase::~ControllerBase() {
@@ -24,7 +23,7 @@ ReturnValue_t ControllerBase::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;
@@ -135,3 +134,7 @@ void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
 
 void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 }
+
+ReturnValue_t ControllerBase::initializeAfterTaskCreation() {
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index d98a66652..5aacd9d87 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -1,5 +1,5 @@
-#ifndef CONTROLLERBASE_H_
-#define CONTROLLERBASE_H_
+#ifndef FSFW_CONTROLLER_CONTROLLERBASE_H_
+#define FSFW_CONTROLLER_CONTROLLERBASE_H_
 
 #include "../health/HasHealthIF.h"
 #include "../health/HealthHelper.h"
@@ -9,29 +9,32 @@
 #include "../tasks/ExecutableObjectIF.h"
 #include "../datapool/HkSwitchHelper.h"
 
-
+/**
+ * @brief  Generic base class for controller classes
+ * @details
+ * Implements common interfaces for controllers.
+ */
 class ControllerBase: public HasModesIF,
 		public HasHealthIF,
 		public ExecutableObjectIF,
 		public SystemObject,
 		public HasReturnvaluesIF {
 public:
-
 	static const Mode_t MODE_NORMAL = 2;
 
-	ControllerBase(uint32_t setObjectId, uint32_t parentId,
+	ControllerBase(object_id_t setObjectId, object_id_t parentId,
 			size_t commandQueueDepth = 3);
 	virtual ~ControllerBase();
 
-	ReturnValue_t initialize();
+	virtual ReturnValue_t initialize() override;
 
-	virtual MessageQueueId_t getCommandQueue() const;
+	virtual MessageQueueId_t getCommandQueue() const override;
 
-	virtual ReturnValue_t performOperation(uint8_t opCode);
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
-	virtual ReturnValue_t setHealth(HealthState health);
+	virtual ReturnValue_t setHealth(HealthState health) override;
 
-	virtual HasHealthIF::HealthState getHealth();
+	virtual HasHealthIF::HealthState getHealth() override;
 
 	/**
 	 * Implementation of ExecutableObjectIF function
@@ -39,17 +42,32 @@ public:
 	 * Used to setup the reference of the task, that executes this component
 	 * @param task_ Pointer to the taskIF of this task
 	 */
-	virtual  void setTaskIF(PeriodicTaskIF* task_);
+	virtual  void setTaskIF(PeriodicTaskIF* task_) override;
 
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
 
 protected:
-	const uint32_t parentId;
+
+	/**
+	 * Implemented by child class. Handle command messages which are not
+	 * mode or health messages.
+	 * @param message
+	 * @return
+	 */
+    virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+    virtual void performControlOperation() = 0;
+
+    virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+            uint32_t *msToReachTheMode) = 0;
+
+	const object_id_t parentId;
 
 	Mode_t mode;
 
 	Submode_t submode;
 
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 
 	ModeHelper modeHelper;
 
@@ -58,16 +76,13 @@ protected:
 	HkSwitchHelper hkSwitcher;
 
 	/**
-	 * 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;
+	PeriodicTaskIF* executingTask = nullptr;
 
 	void handleQueue();
 
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
-	virtual void performControlOperation() = 0;
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode) = 0;
 	virtual void modeChanged(Mode_t mode, Submode_t submode);
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
@@ -76,4 +91,4 @@ protected:
 	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 };
 
-#endif /* CONTROLLERBASE_H_ */
+#endif /* FSFW_CONTROLLER_CONTROLLERBASE_H_ */
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 662ece3b2..f99e8a4ed 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -64,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
@@ -93,7 +98,7 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	objectList.push_back(newObject);
 	newObject->setTaskIF(this);
 
-	return newObject->initializeAfterTaskCreation();
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 uint32_t PeriodicTask::getPeriodMs() const {

From 1dfdd65662583271a202ee759c2fb48cc0ad6386 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 14:42:10 +0200
Subject: [PATCH 0664/1774] new initializeSequence func

---
 osal/FreeRTOS/FixedTimeslotTask.cpp |  6 ++--
 osal/FreeRTOS/FixedTimeslotTask.h   |  2 +-
 osal/linux/FixedTimeslotTask.cpp    |  4 ++-
 osal/linux/FixedTimeslotTask.h      |  2 +-
 osal/linux/PeriodicPosixTask.cpp    |  1 +
 tasks/FixedSlotSequence.cpp         | 44 ++++++++++++++++++++---------
 tasks/FixedSlotSequence.h           |  4 ++-
 tasks/FixedTimeslotTaskIF.h         |  2 +-
 8 files changed, 45 insertions(+), 20 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index a112092f8..772c4bca6 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -78,8 +78,8 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 	return pst.getLengthMs();
 }
 
-ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
-	return pst.checkAndInitializeSequence();
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+	return pst.checkSequence();
 }
 
 void FixedTimeslotTask::taskFunctionality() {
@@ -87,6 +87,8 @@ void FixedTimeslotTask::taskFunctionality() {
     // start time for the first entry.
 	auto slotListIter = pst.current;
 
+	pst.intializeSequenceAfterTaskCreation();
+
 	//The start time for the first entry is read.
 	uint32_t intervalMs = slotListIter->pollingTimeMs;
 	TickType_t interval = pdMS_TO_TICKS(intervalMs);
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 0e9611d20..42af14b84 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -54,7 +54,7 @@ public:
 
 	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t checkAndInitializeSequence() const override;
+	ReturnValue_t checkSequence() const override;
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
 
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index c381bb78d..99acf6064 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -49,7 +49,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
 	return pst.checkSequence();
 }
 
@@ -58,6 +58,8 @@ void FixedTimeslotTask::taskFunctionality() {
 	if (!started) {
 		suspend();
 	}
+
+	pst.intializeSequenceAfterTaskCreation();
 	//The start time for the first entry is read.
 	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
 	uint64_t interval = pst.getIntervalToNextSlotMs();
diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index f7b6e9549..83bf203e0 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -33,7 +33,7 @@ public:
 	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
 			int8_t executionStep);
 
-	virtual ReturnValue_t checkAndInitializeSequence() const;
+	virtual ReturnValue_t checkSequence() const;
 
 	/**
 	 * This static function can be used as #deadlineMissedFunc.
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index 9b6148c5e..c0a29f47f 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -52,6 +52,7 @@ void PeriodicPosixTask::taskFunctionality(void) {
 	if(!started){
 		suspend();
 	}
+
 	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
 	//The task's "infinite" inner loop is entered.
 	while (1) {
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index e51762ea7..d803a4199 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -81,13 +81,20 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 	return this->lengthMs;
 }
 
-ReturnValue_t FixedSlotSequence::checkAndInitializeSequence() const {
+void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
+        int8_t executionStep, ExecutableObjectIF* executableObject,
+        PeriodicTaskIF* executingTask) {
+    this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs,
+            executionStep, executableObject, executingTask));
+   this->current = slotList.begin();
+}
+
+ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
 		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	std::set<ExecutableObjectIF*> uniqueObjects;
 	uint32_t count = 0;
 	uint32_t time = 0;
 	for(const auto& slot: slotList) {
@@ -106,11 +113,7 @@ ReturnValue_t FixedSlotSequence::checkAndInitializeSequence() const {
 			//sif::info << std::dec << slotIt->pollingTimeMs << std::endl;
 		}
 		time = slot.pollingTimeMs;
-		// Ensure that each unique object is initialized once.
-		if(uniqueObjects.find(slot.executableObject) == uniqueObjects.end()) {
-		    slot.executableObject->initializeAfterTaskCreation();
-		    uniqueObjects.emplace(slot.executableObject);
-		}
+
 	}
 	//sif::info << "Number of elements in slot list: "
 	//	   << slotList.size() << std::endl;
@@ -120,10 +123,25 @@ ReturnValue_t FixedSlotSequence::checkAndInitializeSequence() const {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
-		int8_t executionStep, ExecutableObjectIF* executableObject,
-		PeriodicTaskIF* executingTask) {
-    this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs,
-            executionStep, executableObject, executingTask));
-   this->current = slotList.begin();
+
+ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
+    std::set<ExecutableObjectIF*> uniqueObjects;
+    uint32_t count = 0;
+    for(const auto& slot: slotList) {
+        // Ensure that each unique object is initialized once.
+        if(uniqueObjects.find(slot.executableObject) == uniqueObjects.end()) {
+            ReturnValue_t result =
+                    slot.executableObject->initializeAfterTaskCreation();
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                count++;
+            }
+            uniqueObjects.emplace(slot.executableObject);
+        }
+    }
+    if (count > 0) {
+        sif::error << "FixedSlotSequence::intializeSequenceAfterTaskCreation:"
+                "Counted " << count << " failed initializations!"  << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 1aa420ce5..9ab845525 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -132,7 +132,9 @@ public:
 	 * creation.
 	 * @return
 	 */
-	ReturnValue_t checkAndInitializeSequence() const;
+	ReturnValue_t checkSequence() const;
+
+	ReturnValue_t intializeSequenceAfterTaskCreation() const;
 
 protected:
 
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index d31554903..daced7854 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -27,7 +27,7 @@ public:
 	 * Check whether the sequence is valid and perform all other required
 	 * initialization steps which are needed after task creation
 	 */
-	virtual ReturnValue_t checkAndInitializeSequence() const = 0;
+	virtual ReturnValue_t checkSequence() const = 0;
 };
 
 #endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */

From 6d3fdab9446d0129823b16aba8cc9e71e2067006 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 15:52:55 +0200
Subject: [PATCH 0665/1774] adapted semaphore IF to mutex IF

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 24 ++++++++++++---------
 osal/FreeRTOS/BinSemaphUsingTask.h        |  9 ++++----
 osal/FreeRTOS/BinarySemaphore.cpp         | 19 +++++++++++------
 osal/FreeRTOS/BinarySemaphore.h           |  8 +++----
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 24 ++++++++++++---------
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  6 ++++--
 osal/FreeRTOS/SemaphoreFactory.cpp        |  2 --
 tasks/SemaphoreIF.h                       | 26 ++++++++++-------------
 8 files changed, 64 insertions(+), 54 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 71c0aba9b..8c831bbe4 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -16,19 +16,23 @@ BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
 }
 
-ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::BLOCKING) {
-		timeout = SemaphoreIF::BLOCKING;
-	}
-	else if(timeoutMs > SemaphoreIF::POLLING){
-		timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-	return acquireWithTickTimeout(timeout);
+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(
-        TickType_t timeoutTicks) {
+        TimeoutType timeoutType, TickType_t timeoutTicks) {
 	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index e69899700..2d2cf159d 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -25,8 +25,8 @@ public:
 	//! @brief Default dtor
 	virtual~ BinarySemaphoreUsingTask();
 
-	ReturnValue_t acquire(uint32_t timeoutMs =
-	        SemaphoreIF::BLOCKING) override;
+	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);
@@ -39,8 +39,9 @@ public:
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
-	ReturnValue_t acquireWithTickTimeout(TickType_t timeoutTicks =
-	        SemaphoreIF::BLOCKING);
+	ReturnValue_t acquireWithTickTimeout(
+	        TimeoutType timeoutType = TimeoutType::BLOCKING,
+	        TickType_t timeoutTicks = portMAX_DELAY);
 
 	/**
 	 * Get handle to the task related to the semaphore.
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 8e15b7a55..f1c784739 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -35,18 +35,23 @@ BinarySemaphore& BinarySemaphore::operator =(
     return *this;
 }
 
-ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::BLOCKING) {
-	    timeout = SemaphoreIF::BLOCKING;
+ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    TickType_t timeout = 0;
+	if(timeoutType == TimeoutType::POLLING) {
+	    timeout = 0;
 	}
-	else if(timeoutMs > SemaphoreIF::POLLING){
+	else if(timeoutType == TimeoutType::WAITING){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
-	return acquireWithTickTimeout(timeout);
+	else {
+	    timeout = portMAX_DELAY;
+	}
+	return acquireWithTickTimeout(timeoutType, timeout);
 }
 
-ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TickType_t timeoutTicks) {
+ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TimeoutType timeoutType,
+        TickType_t timeoutTicks) {
 	if(handle == nullptr) {
 		return SemaphoreIF::SEMAPHORE_INVALID;
 	}
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 4cf270de7..5a32088a1 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -52,8 +52,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
-	ReturnValue_t acquire(uint32_t timeoutMs =
-			SemaphoreIF::BLOCKING) override;
+	ReturnValue_t acquire(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = portMAX_DELAY) override;
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -61,8 +61,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
-	ReturnValue_t  acquireWithTickTimeout(TickType_t timeoutTicks =
-			SemaphoreIF::BLOCKING);
+	ReturnValue_t  acquireWithTickTimeout(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, TickType_t timeoutTicks = portMAX_DELAY);
 
 	/**
 	 * Release the binary semaphore.
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 333865c89..e66671ac6 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -37,20 +37,24 @@ CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
 }
 
-ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::BLOCKING) {
-		timeout = SemaphoreIF::BLOCKING;
-	}
-	else if(timeoutMs > SemaphoreIF::POLLING){
-		timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-	return acquireWithTickTimeout(timeout);
+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(
-		TickType_t timeoutTicks) {
+        TimeoutType timeoutType, TickType_t timeoutTicks) {
 	// Decrement notfication value without resetting it.
 	BaseType_t oldCount = ulTaskNotifyTake(pdFALSE, timeoutTicks);
 	if (getSemaphoreCounter() == oldCount - 1) {
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 801e34309..e37333826 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -31,7 +31,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
-	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::BLOCKING) override;
+	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
+	        uint32_t timeoutMs = portMAX_DELAY) override;
 
 	/**
 	 * Release a semaphore, increasing the number of available counting
@@ -61,7 +62,8 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquireWithTickTimeout(
-			TickType_t timeoutTicks = SemaphoreIF::BLOCKING);
+	        TimeoutType timeoutType = TimeoutType::BLOCKING,
+			TickType_t timeoutTicks = portMAX_DELAY);
 
 	/**
 	 * Get handle to the task related to the semaphore.
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 453f22269..8575cf4aa 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -6,8 +6,6 @@
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = portMAX_DELAY;
 
 static const uint32_t USE_REGULAR_SEMAPHORES = 0;
 static const uint32_t USE_TASK_NOTIFICATIONS = 1;
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index 3fed4511f..30d4ed881 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -20,21 +20,16 @@
  */
 class SemaphoreIF {
 public:
+    /**
+     * Different types of timeout for the mutex lock.
+     */
+    enum TimeoutType {
+        POLLING, //!< If mutex is not available, return immediately
+        WAITING, //!< Wait a specified time for the mutex to become available
+        BLOCKING //!< Block indefinitely until the mutex becomes available.
+    };
+
 	virtual~ SemaphoreIF() {};
-	/**
-	 * @brief 	Timeout value used for polling lock attempt.
-	 * @details
-	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
-	 * immediately. Value needs to be defined in implementation.
-	 */
-	static const uint32_t POLLING;
-	/**
-	 * @brief 	Timeout value used for permanent blocking lock attempt.
-	 * @details
-	 * The task will be blocked (indefinitely) until the mutex is unlocked.
-	 * Value needs to be defined in implementation.
-	 */
-	static const uint32_t BLOCKING;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 	//! Semaphore timeout
@@ -52,7 +47,8 @@ public:
 	 * @param timeoutMs
 	 * @return - c RETURN_OK for successfull acquisition
 	 */
-	virtual ReturnValue_t acquire(uint32_t timeoutMs) = 0;
+	virtual ReturnValue_t acquire(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
 
 	/**
 	 * Corrensponding call to release a semaphore.

From fd42d8cd46bdefece3002e15e585fa18578f1372 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 16:14:42 +0200
Subject: [PATCH 0666/1774] periodic task taken over from master

---
 osal/FreeRTOS/PeriodicTask.cpp | 286 ++++++++++++++++-----------------
 osal/FreeRTOS/PeriodicTask.h   | 254 +++++++++++++++--------------
 2 files changed, 269 insertions(+), 271 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index f99e8a4ed..990d38d67 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -1,143 +1,143 @@
-#include "PeriodicTask.h"
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tasks/ExecutableObjectIF.h"
-
-PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
-		TaskStackSize setStack, TaskPeriod setPeriod,
-		TaskDeadlineMissedFunction deadlineMissedFunc) :
-		started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
-		deadlineMissedFunc)
-{
-	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
-	BaseType_t status = xTaskCreate(taskEntryPoint, name,
-			stackSize, this, setPriority, &handle);
-	if(status != pdPASS){
-		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
-		        "Status: " << status << std::endl;
-	}
-
-}
-
-PeriodicTask::~PeriodicTask(void) {
-	//Do not delete objects, we were responsible for ptrs only.
-}
-
-void PeriodicTask::taskEntryPoint(void* argument) {
-	// The argument is re-interpreted as PeriodicTask. The Task object is
-    // global, so it is found from any place.
-	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
-	/* Task should not start until explicitly requested,
-	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
-	 * is running but not if the scheduler is not running.
-	 * To be able to accommodate both cases we check a member which is set in
-	 * #startTask(). If it is not set and we get here, the scheduler was started
-	 * before #startTask() was called and we need to suspend if it is set,
-	 * the scheduler was not running before #startTask() was called and we
-	 * can continue */
-
-	if (not originalTask->started) {
-		vTaskSuspend(NULL);
-	}
-
-	originalTask->taskFunctionality();
-	sif::debug << "Polling task " << originalTask->handle
-			<< " returned from taskFunctionality." << std::endl;
-}
-
-ReturnValue_t PeriodicTask::startTask() {
-	started = true;
-
-	// We must not call resume if scheduler is not started yet
-	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
-		vTaskResume(handle);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
-	vTaskDelay(pdMS_TO_TICKS(ms));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-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
-	 internally within vTaskDelayUntil(). */
-	xLastWakeTime = xTaskGetTickCount();
-	/* Enter the loop that defines the task behavior. */
-	for (;;) {
-		for (auto const& object: objectList) {
-			object->performOperation();
-		}
-
-		checkMissedDeadline(xLastWakeTime, xPeriod);
-
-		vTaskDelayUntil(&xLastWakeTime, xPeriod);
-
-	}
-}
-
-ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == nullptr) {
-	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
-	            "it implement ExecutableObjectIF" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	newObject->setTaskIF(this);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t PeriodicTask::getPeriodMs() const {
-	return period * 1000;
-}
-
-void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-}
-
-TaskHandle_t PeriodicTask::getTaskHandle() {
-    return handle;
-}
-
-void PeriodicTask::handleMissedDeadline() {
-#ifdef DEBUG
-    sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
-            " missed deadline!\n" << std::flush;
-#endif
-    if(deadlineMissedFunc != nullptr) {
-        this->deadlineMissedFunc();
-    }
-}
+#include "PeriodicTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
+		TaskStackSize setStack, TaskPeriod setPeriod,
+		TaskDeadlineMissedFunction deadlineMissedFunc) :
+		started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
+		deadlineMissedFunc)
+{
+	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
+	BaseType_t status = xTaskCreate(taskEntryPoint, name,
+			stackSize, this, setPriority, &handle);
+	if(status != pdPASS){
+		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
+		        "Status: " << status << std::endl;
+	}
+
+}
+
+PeriodicTask::~PeriodicTask(void) {
+	//Do not delete objects, we were responsible for ptrs only.
+}
+
+void PeriodicTask::taskEntryPoint(void* argument) {
+	// The argument is re-interpreted as PeriodicTask. The Task object is
+    // global, so it is found from any place.
+	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
+
+	if (not originalTask->started) {
+		vTaskSuspend(NULL);
+	}
+
+	originalTask->taskFunctionality();
+	sif::debug << "Polling task " << originalTask->handle
+			<< " returned from taskFunctionality." << std::endl;
+}
+
+ReturnValue_t PeriodicTask::startTask() {
+	started = true;
+
+	// We must not call resume if scheduler is not started yet
+	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
+		vTaskResume(handle);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
+	vTaskDelay(pdMS_TO_TICKS(ms));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+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
+	 internally within vTaskDelayUntil(). */
+	xLastWakeTime = xTaskGetTickCount();
+	/* Enter the loop that defines the task behavior. */
+	for (;;) {
+		for (auto const& object: objectList) {
+			object->performOperation();
+		}
+
+		checkMissedDeadline(xLastWakeTime, xPeriod);
+
+		vTaskDelayUntil(&xLastWakeTime, xPeriod);
+
+	}
+}
+
+ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == nullptr) {
+	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+	            "it implement ExecutableObjectIF" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	newObject->setTaskIF(this);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t PeriodicTask::getPeriodMs() const {
+	return period * 1000;
+}
+
+void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Time to wake has not overflown.
+    if(timeToWake > xLastWakeTime) {
+        /* If the current time has overflown exclusively or the current
+         * tick count is simply larger than the time to wake, a deadline was
+         * missed */
+        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
+            handleMissedDeadline();
+        }
+    }
+    /* Time to wake has overflown. A deadline was missed if the current time
+     * is larger than the time to wake */
+    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
+        handleMissedDeadline();
+    }
+}
+
+TaskHandle_t PeriodicTask::getTaskHandle() {
+    return handle;
+}
+
+void PeriodicTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 1cdc3df70..87b8b6d2f 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -1,128 +1,126 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
-
-#include "../../osal/FreeRTOS/FreeRTOSTaskIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../tasks/PeriodicTaskIF.h"
-#include "../../tasks/Typedef.h"
-
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-#include <vector>
-
-class ExecutableObjectIF;
-
-/**
- * @brief 	This class represents a specialized task for
- * 			periodic activities of multiple objects.
- * @ingroup task_handling
- */
-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.
-	 * @param priority
-	 * Sets the priority of a task. Values depend on freeRTOS configuration,
-	 * high number means high priority.
-	 * @param stack_size
-	 * The stack size reserved by the operating system for the task.
-	 * @param setPeriod
-	 * The length of the period with which the task's
-	 * functionality will be executed. It is expressed in clock ticks.
-	 * @param setDeadlineMissedFunc
-	 * The function pointer to the deadline missed function that shall
-	 * be assigned.
-	 */
-	PeriodicTask(TaskName name, TaskPriority setPriority,
-	        TaskStackSize setStack, TaskPeriod setPeriod,
-	        TaskDeadlineMissedFunction deadlineMissedFunc);
-	/**
-	 * @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() override;
-	/**
-	 * 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) override;
-
-	uint32_t getPeriodMs() const override;
-
-	ReturnValue_t sleepFor(uint32_t ms) override;
-
-	TaskHandle_t getTaskHandle() override;
-protected:
-	bool started;
-	TaskHandle_t handle;
-
-	//! Typedef for the List of objects.
-	typedef std::vector<ExecutableObjectIF*> ObjectList;
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-	/**
-	 * @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.
-	 */
-
-	static 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);
-
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
-	void handleMissedDeadline();
-};
-
-#endif /* 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"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+#include <vector>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief 	This class represents a specialized task for
+ * 			periodic activities of multiple objects.
+ * @ingroup task_handling
+ */
+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".
+	 * @details
+	 * The class is initialized without allocated objects.
+	 * These need to be added with #addComponent.
+	 * @param priority
+	 * Sets the priority of a task. Values depend on freeRTOS configuration,
+	 * high number means high priority.
+	 * @param stack_size
+	 * The stack size reserved by the operating system for the task.
+	 * @param setPeriod
+	 * The length of the period with which the task's
+	 * functionality will be executed. It is expressed in clock ticks.
+	 * @param setDeadlineMissedFunc
+	 * The function pointer to the deadline missed function that shall
+	 * be assigned.
+	 */
+	PeriodicTask(TaskName name, TaskPriority setPriority,
+	        TaskStackSize setStack, TaskPeriod setPeriod,
+	        TaskDeadlineMissedFunction deadlineMissedFunc);
+	/**
+	 * @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() override;
+	/**
+	 * 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) override;
+
+	uint32_t getPeriodMs() const override;
+
+	ReturnValue_t sleepFor(uint32_t ms) override;
+
+	TaskHandle_t getTaskHandle() override;
+protected:
+	bool started;
+	TaskHandle_t handle;
+
+	//! Typedef for the List of objects.
+	typedef std::vector<ExecutableObjectIF*> ObjectList;
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+	/**
+	 * @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.
+	 */
+
+	static 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);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
+};
+
+#endif /* FSFW_OSAL_FREERTOS_PERIODICTASK_H_ */

From 5aa664648e8e0d102e29a68c42fac9b16c5ecbb9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 17:03:54 +0200
Subject: [PATCH 0667/1774] linux semaph update

---
 osal/linux/BinarySemaphore.cpp   | 9 +++++----
 osal/linux/BinarySemaphore.h     | 4 ++--
 osal/linux/FixedTimeslotTask.cpp | 7 +++++--
 osal/linux/SemaphoreFactory.cpp  | 3 ---
 4 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 37947b268..5216ff375 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -25,15 +25,16 @@ BinarySemaphore& BinarySemaphore::operator =(
 	return * this;
 }
 
-ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
+ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
+		 uint32_t timeoutMs) {
 	int result = 0;
-	if(timeoutMs == SemaphoreIF::POLLING) {
+	if(timeoutType == TimeoutType::POLLING) {
 		result = sem_trywait(&handle);
 	}
-	else if(timeoutMs == SemaphoreIF::BLOCKING) {
+	else if(timeoutType == TimeoutType::BLOCKING) {
 	    result = sem_wait(&handle);
 	}
-	else if(timeoutMs > SemaphoreIF::POLLING){
+	else if(timeoutType == TimeoutType::WAITING){
 		timespec timeOut;
 		clock_gettime(CLOCK_REALTIME, &timeOut);
 		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
diff --git a/osal/linux/BinarySemaphore.h b/osal/linux/BinarySemaphore.h
index 9ac9ba7f9..4181de857 100644
--- a/osal/linux/BinarySemaphore.h
+++ b/osal/linux/BinarySemaphore.h
@@ -49,8 +49,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
-	ReturnValue_t acquire(uint32_t timeoutMs =
-	       	   SemaphoreIF::BLOCKING) override;
+	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
+			uint32_t timeoutMs = 0) override;
 
 	/**
 	 * Release the binary semaphore.
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 99acf6064..12db83b13 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -39,8 +39,11 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+	ExecutableObjectIF* executableObject =
+			objectManager->get<ExecutableObjectIF>(componentId);
+	if (executableObject != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep,
+				executableObject,this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index 43b1978df..805865caa 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -3,9 +3,6 @@
 #include "../../osal/linux/CountingSemaphore.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = 0xffffffff;
-
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 
 SemaphoreFactory::SemaphoreFactory() {

From b9314cffb955b95234a7c82e1a847c9533fee57a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 17:13:52 +0200
Subject: [PATCH 0668/1774] small improvements

---
 osal/linux/SemaphoreFactory.cpp | 4 ++--
 tasks/SemaphoreFactory.h        | 7 ++++---
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index 805865caa..bcb5d16fe 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,6 +1,6 @@
 #include "../../tasks/SemaphoreFactory.h"
-#include "../../osal/linux/BinarySemaphore.h"
-#include "../../osal/linux/CountingSemaphore.h"
+#include "BinarySemaphore.h"
+#include "CountingSemaphore.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index b2f347889..2c41a1353 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -1,5 +1,6 @@
-#ifndef FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
-#define FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
+#ifndef FSFW_TASKS_SEMAPHOREFACTORY_H_
+#define FSFW_TASKS_SEMAPHOREFACTORY_H_
+
 #include "../tasks/SemaphoreIF.h"
 
 /**
@@ -46,4 +47,4 @@ private:
 	static SemaphoreFactory* factoryInstance;
 };
 
-#endif /* FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_ */
+#endif /* FSFW_TASKS_SEMAPHOREFACTORY_H_ */

From 4d1b1ba50662984bd90af489dfa811d8165be6fb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 17:24:40 +0200
Subject: [PATCH 0669/1774] additonal doc for freeRTOS semaphores

---
 osal/FreeRTOS/BinSemaphUsingTask.h      | 3 +++
 osal/FreeRTOS/CountingSemaphUsingTask.h | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 2d2cf159d..0b30c094f 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -14,6 +14,9 @@
  * @details
  * Additional information: https://www.freertos.org/RTOS-task-notifications.html
  * and general semaphore documentation.
+ * This semaphore is bound to the task it is created in!
+ * Take care of calling this function with the correct executing task,
+ * (for example in the initializeAfterTaskCreation() function).
  */
 class BinarySemaphoreUsingTask: public SemaphoreIF,
 		public HasReturnvaluesIF {
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index e37333826..d3b23ebe2 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -16,6 +16,9 @@ extern "C" {
  * @details
  *  Additional information: https://www.freertos.org/RTOS-task-notifications.html
  *  and general semaphore documentation.
+ *  This semaphore is bound to the task it is created in!
+ *  Take care of calling this function with the correct executing task,
+ *  (for example in the initializeAfterTaskCreation() function).
  */
 class CountingSemaphoreUsingTask: public SemaphoreIF {
 public:

From a6e99e443aaa483b705d8b5570d30ef2a524ec9e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 20:00:36 +0200
Subject: [PATCH 0670/1774] took over dHB failure isolation base fixes

---
 .../DeviceHandlerFailureIsolation.cpp         | 502 +++++++++---------
 .../DeviceHandlerFailureIsolation.h           | 107 ++--
 2 files changed, 304 insertions(+), 305 deletions(-)

diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 54788600a..8831f9aed 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -1,251 +1,251 @@
-#include "../devicehandlers/DeviceHandlerBase.h"
-#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
-#include "../health/HealthTableIF.h"
-#include "../power/Fuse.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../thermal/ThermalComponentIF.h"
-
-object_id_t DeviceHandlerFailureIsolation::powerConfirmationId = 0;
-
-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() {
-}
-
-ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event) {
-	if(isFdirInActionOrAreWeFaulty(event)) {
-		return RETURN_OK;
-	}
-	ReturnValue_t result = RETURN_FAILED;
-	switch (event->getEvent()) {
-	case HasModesIF::MODE_TRANSITION_FAILED:
-	case HasModesIF::OBJECT_IN_INVALID_MODE:
-		//We'll try a recovery as long as defined in MAX_REBOOT.
-		//Might cause some AssemblyBase cycles, so keep number low.
-		handleRecovery(event->getEvent());
-		break;
-	case DeviceHandlerIF::DEVICE_INTERPRETING_REPLY_FAILED:
-	case DeviceHandlerIF::DEVICE_READING_REPLY_FAILED:
-	case DeviceHandlerIF::DEVICE_UNREQUESTED_REPLY:
-	case DeviceHandlerIF::DEVICE_UNKNOWN_REPLY: //Some DH's generate generic reply-ids.
-	case DeviceHandlerIF::DEVICE_BUILDING_COMMAND_FAILED:
-		//These faults all mean that there were stupid replies from a device.
-		if (strangeReplyCount.incrementAndCheck()) {
-			handleRecovery(event->getEvent());
-		}
-		break;
-	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
-	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
-		//The two above should never be confirmed.
-	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
-		result = sendConfirmationRequest(event);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-		//else
-		if (missedReplyCount.incrementAndCheck()) {
-			handleRecovery(event->getEvent());
-		}
-		break;
-	case StorageManagerIF::GET_DATA_FAILED:
-	case StorageManagerIF::STORE_DATA_FAILED:
-		//Rather strange bugs, occur in RAW mode only. Ignore.
-		break;
-	case DeviceHandlerIF::INVALID_DEVICE_COMMAND:
-		//Ignore, is bad configuration. We can't do anything in flight.
-		break;
-	case HasHealthIF::HEALTH_INFO:
-	case HasModesIF::MODE_INFO:
-	case HasModesIF::CHANGING_MODE:
-		//Do nothing, but mark as handled.
-		break;
-		//****Power*****
-	case PowerSwitchIF::SWITCH_WENT_OFF:
-		if(hasPowerConfirmation) {
-			result = sendConfirmationRequest(event, powerConfirmation);
-			if (result == RETURN_OK) {
-				setFdirState(DEVICE_MIGHT_BE_OFF);
-			}
-		}
-		break;
-	case Fuse::FUSE_WENT_OFF:
-		//Not so good, because PCDU reacted.
-	case Fuse::POWER_ABOVE_HIGH_LIMIT:
-		//Better, because software detected over-current.
-		setFaulty(event->getEvent());
-		break;
-	case Fuse::POWER_BELOW_LOW_LIMIT:
-		//Device might got stuck during boot, retry.
-		handleRecovery(event->getEvent());
-		break;
-		//****Thermal*****
-	case ThermalComponentIF::COMPONENT_TEMP_LOW:
-	case ThermalComponentIF::COMPONENT_TEMP_HIGH:
-	case ThermalComponentIF::COMPONENT_TEMP_OOL_LOW:
-	case ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH:
-		//Well, the device is not really faulty, but it is required to stay off as long as possible.
-		setFaulty(event->getEvent());
-		break;
-	case ThermalComponentIF::TEMP_NOT_IN_OP_RANGE:
-		//Ignore, is information only.
-		break;
-		//*******Default monitoring variables. Are currently not used.*****
-//	case DeviceHandlerIF::MONITORING_LIMIT_EXCEEDED:
-//		setFaulty(event->getEvent());
-//		break;
-//	case DeviceHandlerIF::MONITORING_AMBIGUOUS:
-//		break;
-	default:
-		//We don't know the event, someone else should handle it.
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void DeviceHandlerFailureIsolation::eventConfirmed(EventMessage* event) {
-	switch (event->getEvent()) {
-	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
-	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
-	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
-		if (missedReplyCount.incrementAndCheck()) {
-			handleRecovery(event->getEvent());
-		}
-		break;
-	case PowerSwitchIF::SWITCH_WENT_OFF:
-		//This means the switch went off only for one device.
-		handleRecovery(event->getEvent());
-		break;
-	default:
-		break;
-	}
-}
-
-void DeviceHandlerFailureIsolation::decrementFaultCounters() {
-	strangeReplyCount.checkForDecrement();
-	missedReplyCount.checkForDecrement();
-	recoveryCounter.checkForDecrement();
-}
-
-void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
-	clearFaultCounters();
-	if (not recoveryCounter.incrementAndCheck()) {
-		startRecovery(reason);
-	} else {
-		setFaulty(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?
-	//Same issue in TxFailureIsolation!
-//	if ((event->getEvent() == PowerSwitchIF::SWITCH_WENT_OFF)
-//			&& (fdirState != RECOVERY_ONGOING)) {
-//		setFdirState(NONE);
-//	}
-}
-
-void DeviceHandlerFailureIsolation::clearFaultCounters() {
-	strangeReplyCount.clear();
-	missedReplyCount.clear();
-}
-
-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 != nullptr) {
-		powerConfirmation = power->getEventReceptionQueue();
-		hasPowerConfirmation = true;
-	}
-
-	return RETURN_OK;
-}
-
-void DeviceHandlerFailureIsolation::setFdirState(FDIRState state) {
-	FailureIsolationBase::throwFdirEvent(FDIR_CHANGED_STATE, state, fdirState);
-	fdirState = state;
-}
-
-void DeviceHandlerFailureIsolation::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	//Do not throw error events if fdirState != none.
-	//This will still forward MODE and HEALTH INFO events in any case.
-	if (fdirState == NONE || EVENT::getSeverity(event) == SEVERITY::INFO) {
-		FailureIsolationBase::triggerEvent(event, parameter1, parameter2);
-	}
-}
-
-bool DeviceHandlerFailureIsolation::isFdirActionInProgress() {
-	return (fdirState != NONE);
-}
-
-void DeviceHandlerFailureIsolation::startRecovery(Event reason) {
-	throwFdirEvent(FDIR_STARTS_RECOVERY, EVENT::getEventId(reason));
-	setOwnerHealth(HasHealthIF::NEEDS_RECOVERY);
-	setFdirState(RECOVERY_ONGOING);
-}
-
-ReturnValue_t DeviceHandlerFailureIsolation::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = strangeReplyCount.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = missedReplyCount.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = recoveryCounter.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	return INVALID_DOMAIN_ID;
-}
-
-void DeviceHandlerFailureIsolation::setFaulty(Event reason) {
-	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, EVENT::getEventId(reason));
-	setOwnerHealth(HasHealthIF::FAULTY);
-	setFdirState(AWAIT_SHUTDOWN);
-}
-
-bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
-		EventMessage* event) {
-	if (fdirState != NONE) {
-		//Only wait for those events, ignore all others.
-		if (event->getParameter1() == HasHealthIF::HEALTHY
-				&& event->getEvent() == HasHealthIF::HEALTH_INFO) {
-			setFdirState(NONE);
-		}
-		if (event->getEvent() == HasModesIF::MODE_INFO
-				&& fdirState != RECOVERY_ONGOING) {
-			setFdirState(NONE);
-		}
-		return true;
-	}
-	if (owner->getHealth() == HasHealthIF::FAULTY
-			|| owner->getHealth() == HasHealthIF::PERMANENT_FAULTY) {
-		//Ignore all events in case device is already faulty.
-		return true;
-	}
-	return false;
-}
+#include "DeviceHandlerBase.h"
+#include "DeviceHandlerFailureIsolation.h"
+#include "../health/HealthTableIF.h"
+#include "../power/Fuse.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../thermal/ThermalComponentIF.h"
+
+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() {
+}
+
+ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event) {
+	if(isFdirInActionOrAreWeFaulty(event)) {
+		return RETURN_OK;
+	}
+	ReturnValue_t result = RETURN_FAILED;
+	switch (event->getEvent()) {
+	case HasModesIF::MODE_TRANSITION_FAILED:
+	case HasModesIF::OBJECT_IN_INVALID_MODE:
+		//We'll try a recovery as long as defined in MAX_REBOOT.
+		//Might cause some AssemblyBase cycles, so keep number low.
+		handleRecovery(event->getEvent());
+		break;
+	case DeviceHandlerIF::DEVICE_INTERPRETING_REPLY_FAILED:
+	case DeviceHandlerIF::DEVICE_READING_REPLY_FAILED:
+	case DeviceHandlerIF::DEVICE_UNREQUESTED_REPLY:
+	case DeviceHandlerIF::DEVICE_UNKNOWN_REPLY: //Some DH's generate generic reply-ids.
+	case DeviceHandlerIF::DEVICE_BUILDING_COMMAND_FAILED:
+		//These faults all mean that there were stupid replies from a device.
+		if (strangeReplyCount.incrementAndCheck()) {
+			handleRecovery(event->getEvent());
+		}
+		break;
+	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
+	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
+		//The two above should never be confirmed.
+	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
+		result = sendConfirmationRequest(event);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+		//else
+		if (missedReplyCount.incrementAndCheck()) {
+			handleRecovery(event->getEvent());
+		}
+		break;
+	case StorageManagerIF::GET_DATA_FAILED:
+	case StorageManagerIF::STORE_DATA_FAILED:
+		//Rather strange bugs, occur in RAW mode only. Ignore.
+		break;
+	case DeviceHandlerIF::INVALID_DEVICE_COMMAND:
+		//Ignore, is bad configuration. We can't do anything in flight.
+		break;
+	case HasHealthIF::HEALTH_INFO:
+	case HasModesIF::MODE_INFO:
+	case HasModesIF::CHANGING_MODE:
+		//Do nothing, but mark as handled.
+		break;
+		//****Power*****
+	case PowerSwitchIF::SWITCH_WENT_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:
+		//Not so good, because PCDU reacted.
+	case Fuse::POWER_ABOVE_HIGH_LIMIT:
+		//Better, because software detected over-current.
+		setFaulty(event->getEvent());
+		break;
+	case Fuse::POWER_BELOW_LOW_LIMIT:
+		//Device might got stuck during boot, retry.
+		handleRecovery(event->getEvent());
+		break;
+		//****Thermal*****
+	case ThermalComponentIF::COMPONENT_TEMP_LOW:
+	case ThermalComponentIF::COMPONENT_TEMP_HIGH:
+	case ThermalComponentIF::COMPONENT_TEMP_OOL_LOW:
+	case ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH:
+		//Well, the device is not really faulty, but it is required to stay off as long as possible.
+		setFaulty(event->getEvent());
+		break;
+	case ThermalComponentIF::TEMP_NOT_IN_OP_RANGE:
+		//Ignore, is information only.
+		break;
+		//*******Default monitoring variables. Are currently not used.*****
+//	case DeviceHandlerIF::MONITORING_LIMIT_EXCEEDED:
+//		setFaulty(event->getEvent());
+//		break;
+//	case DeviceHandlerIF::MONITORING_AMBIGUOUS:
+//		break;
+	default:
+		//We don't know the event, someone else should handle it.
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void DeviceHandlerFailureIsolation::eventConfirmed(EventMessage* event) {
+	switch (event->getEvent()) {
+	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
+	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
+	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
+		if (missedReplyCount.incrementAndCheck()) {
+			handleRecovery(event->getEvent());
+		}
+		break;
+	case PowerSwitchIF::SWITCH_WENT_OFF:
+		//This means the switch went off only for one device.
+		handleRecovery(event->getEvent());
+		break;
+	default:
+		break;
+	}
+}
+
+void DeviceHandlerFailureIsolation::decrementFaultCounters() {
+	strangeReplyCount.checkForDecrement();
+	missedReplyCount.checkForDecrement();
+	recoveryCounter.checkForDecrement();
+}
+
+void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
+	clearFaultCounters();
+	if (not recoveryCounter.incrementAndCheck()) {
+		startRecovery(reason);
+	} else {
+		setFaulty(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?
+	//Same issue in TxFailureIsolation!
+//	if ((event->getEvent() == PowerSwitchIF::SWITCH_WENT_OFF)
+//			&& (fdirState != RECOVERY_ONGOING)) {
+//		setFdirState(NONE);
+//	}
+}
+
+void DeviceHandlerFailureIsolation::clearFaultCounters() {
+	strangeReplyCount.clear();
+	missedReplyCount.clear();
+}
+
+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 != nullptr) {
+		powerConfirmation = power->getEventReceptionQueue();
+	}
+
+	return RETURN_OK;
+}
+
+void DeviceHandlerFailureIsolation::setFdirState(FDIRState state) {
+	FailureIsolationBase::throwFdirEvent(FDIR_CHANGED_STATE, state, fdirState);
+	fdirState = state;
+}
+
+void DeviceHandlerFailureIsolation::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	//Do not throw error events if fdirState != none.
+	//This will still forward MODE and HEALTH INFO events in any case.
+	if (fdirState == NONE || EVENT::getSeverity(event) == SEVERITY::INFO) {
+		FailureIsolationBase::triggerEvent(event, parameter1, parameter2);
+	}
+}
+
+bool DeviceHandlerFailureIsolation::isFdirActionInProgress() {
+	return (fdirState != NONE);
+}
+
+void DeviceHandlerFailureIsolation::startRecovery(Event reason) {
+	throwFdirEvent(FDIR_STARTS_RECOVERY, EVENT::getEventId(reason));
+	setOwnerHealth(HasHealthIF::NEEDS_RECOVERY);
+	setFdirState(RECOVERY_ONGOING);
+}
+
+ReturnValue_t DeviceHandlerFailureIsolation::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	ReturnValue_t result = strangeReplyCount.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = missedReplyCount.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = recoveryCounter.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	return INVALID_DOMAIN_ID;
+}
+
+void DeviceHandlerFailureIsolation::setFaulty(Event reason) {
+	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, EVENT::getEventId(reason));
+	setOwnerHealth(HasHealthIF::FAULTY);
+	setFdirState(AWAIT_SHUTDOWN);
+}
+
+bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
+		EventMessage* event) {
+	if (fdirState != NONE) {
+		//Only wait for those events, ignore all others.
+		if (event->getParameter1() == HasHealthIF::HEALTHY
+				&& event->getEvent() == HasHealthIF::HEALTH_INFO) {
+			setFdirState(NONE);
+		}
+		if (event->getEvent() == HasModesIF::MODE_INFO
+				&& fdirState != RECOVERY_ONGOING) {
+			setFdirState(NONE);
+		}
+		return true;
+	}
+	if (owner->getHealth() == HasHealthIF::FAULTY
+			|| owner->getHealth() == HasHealthIF::PERMANENT_FAULTY) {
+		//Ignore all events in case device is already faulty.
+		return true;
+	}
+	return false;
+}
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.h b/devicehandlers/DeviceHandlerFailureIsolation.h
index 25247a8d0..6ed53efde 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.h
+++ b/devicehandlers/DeviceHandlerFailureIsolation.h
@@ -1,54 +1,53 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
-#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
-
-#include "../fdir/FaultCounter.h"
-#include "../fdir/FailureIsolationBase.h"
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-
-class DeviceHandlerFailureIsolation: public FailureIsolationBase {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-	friend class Heater;
-public:
-	DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent);
-	~DeviceHandlerFailureIsolation();
-	ReturnValue_t initialize();
-	void triggerEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);bool isFdirActionInProgress();
-	virtual ReturnValue_t getParameter(uint8_t domainId, 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;
-	bool hasPowerConfirmation = false;
-	MessageQueueId_t powerConfirmation;
-	static object_id_t powerConfirmationId;
-	// TODO: Are those hardcoded value? How can they be changed.
-	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;
-	virtual ReturnValue_t eventReceived(EventMessage* event);
-	virtual void eventConfirmed(EventMessage* event);
-	void wasParentsFault(EventMessage* event);
-	void decrementFaultCounters();
-	void handleRecovery(Event reason);
-	virtual void clearFaultCounters();
-	void setFdirState(FDIRState state);
-	void startRecovery(Event reason);
-	void setFaulty(Event reason);
-
-	bool isFdirInActionOrAreWeFaulty(EventMessage* event);
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+
+#include "../fdir/FaultCounter.h"
+#include "../fdir/FailureIsolationBase.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+class DeviceHandlerFailureIsolation: public FailureIsolationBase {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+	friend class Heater;
+public:
+	DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent);
+	~DeviceHandlerFailureIsolation();
+	ReturnValue_t initialize();
+	void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);bool isFdirActionInProgress();
+	virtual ReturnValue_t getParameter(uint8_t domainId, 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 = MessageQueueIF::NO_QUEUE;
+	static object_id_t powerConfirmationId;
+	// TODO: Are those hardcoded value? How can they be changed.
+	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;
+	virtual ReturnValue_t eventReceived(EventMessage* event);
+	virtual void eventConfirmed(EventMessage* event);
+	void wasParentsFault(EventMessage* event);
+	void decrementFaultCounters();
+	void handleRecovery(Event reason);
+	virtual void clearFaultCounters();
+	void setFdirState(FDIRState state);
+	void startRecovery(Event reason);
+	void setFaulty(Event reason);
+
+	bool isFdirInActionOrAreWeFaulty(EventMessage* event);
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */

From ed70f3861272b064fae00a6fab155ccfe67b1e93 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 20:04:17 +0200
Subject: [PATCH 0671/1774] some renaming

---
 .../DeviceHandlerFailureIsolation.cpp         |  6 ++---
 .../DeviceHandlerFailureIsolation.h           | 24 +++++++++++--------
 2 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 8831f9aed..2ca2df2a5 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -11,11 +11,11 @@ object_id_t DeviceHandlerFailureIsolation::powerConfirmationId =
 DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner,
 		object_id_t parent) :
 		FailureIsolationBase(owner, parent),
-		strangeReplyCount(MAX_STRANGE_REPLIES, STRANGE_REPLIES_TIME_MS,
+		strangeReplyCount(DEFAULT_MAX_STRANGE_REPLIES, DEFAULT_STRANGE_REPLIES_TIME_MS,
 				parameterDomainBase++),
-		missedReplyCount( MAX_MISSED_REPLY_COUNT, MISSED_REPLY_TIME_MS,
+		missedReplyCount( DEFAULT_MAX_MISSED_REPLY_COUNT, DEFAULT_MISSED_REPLY_TIME_MS,
 				parameterDomainBase++),
-		recoveryCounter(MAX_REBOOT, REBOOT_TIME_MS, parameterDomainBase++),
+		recoveryCounter(DEFAULT_MAX_REBOOT, DEFAULT_REBOOT_TIME_MS, parameterDomainBase++),
 		fdirState(NONE), powerConfirmation(0) {
 }
 
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.h b/devicehandlers/DeviceHandlerFailureIsolation.h
index 6ed53efde..8a3fd9dd9 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.h
+++ b/devicehandlers/DeviceHandlerFailureIsolation.h
@@ -1,5 +1,5 @@
-#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"
@@ -20,23 +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 = MessageQueueIF::NO_QUEUE;
 	static object_id_t powerConfirmationId;
-	// TODO: Are those hardcoded value? How can they be changed.
-	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);
@@ -50,4 +54,4 @@ protected:
 	bool isFdirInActionOrAreWeFaulty(EventMessage* event);
 };
 
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */

From 42dd665e2649b8e37a27862640f1f73c1147c627 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 20:06:19 +0200
Subject: [PATCH 0672/1774] include improvement

---
 devicehandlers/DeviceHandlerFailureIsolation.cpp | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 2ca2df2a5..9fbe71d85 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -1,5 +1,7 @@
-#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"
@@ -11,12 +13,15 @@ object_id_t DeviceHandlerFailureIsolation::powerConfirmationId =
 DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner,
 		object_id_t parent) :
 		FailureIsolationBase(owner, parent),
-		strangeReplyCount(DEFAULT_MAX_STRANGE_REPLIES, DEFAULT_STRANGE_REPLIES_TIME_MS,
+		strangeReplyCount(DEFAULT_MAX_STRANGE_REPLIES,
+		        DEFAULT_STRANGE_REPLIES_TIME_MS,
 				parameterDomainBase++),
-		missedReplyCount( DEFAULT_MAX_MISSED_REPLY_COUNT, DEFAULT_MISSED_REPLY_TIME_MS,
+		missedReplyCount( DEFAULT_MAX_MISSED_REPLY_COUNT,
+		        DEFAULT_MISSED_REPLY_TIME_MS,
 				parameterDomainBase++),
-		recoveryCounter(DEFAULT_MAX_REBOOT, DEFAULT_REBOOT_TIME_MS, parameterDomainBase++),
-		fdirState(NONE), powerConfirmation(0) {
+		recoveryCounter(DEFAULT_MAX_REBOOT, DEFAULT_REBOOT_TIME_MS,
+		        parameterDomainBase++),
+		fdirState(NONE) {
 }
 
 DeviceHandlerFailureIsolation::~DeviceHandlerFailureIsolation() {

From 5ca26a72ea2101786cdfbd6a812a2d9913809224 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:00:16 +0200
Subject: [PATCH 0673/1774] fixed some shadowing issues

---
 objectmanager/ObjectManager.cpp |    1 -
 subsystem/Subsystem.cpp         | 1320 +++++++++++++++----------------
 subsystem/Subsystem.h           |    6 +-
 timemanager/CCSDSTime.cpp       |    2 +-
 4 files changed, 662 insertions(+), 667 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 13d67559e..467eed4bc 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/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;
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index a4869eba4..400ecc830 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -1,662 +1,658 @@
-#include "../health/HealthMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../serialize/SerialArrayListAdapter.h"
-#include "../serialize/SerialFixedArrayListAdapter.h"
-#include "../serialize/SerializeElement.h"
-#include "../serialize/SerialLinkedListAdapter.h"
-#include "../subsystem/Subsystem.h"
-#include <string>
-
-Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
-		uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) :
-		SubsystemBase(setObjectId, parent, 0), isInTransition(false), childrenChangedHealth(
-				false), uptimeStartTable(0), currentTargetTable(), targetMode(
-				0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables(
-				maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore(
-		NULL)
-#ifdef USE_MODESTORE
-,modeStore(NULL)
-#endif
-{
-
-}
-
-Subsystem::~Subsystem() {
-	//Auto-generated destructor stub
-}
-
-ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
-		Mode_t fallbackSequence) {
-
-	//only check for existence, checking the fallback would lead to a (possibly infinite) recursion.
-	//the fallback sequence will be checked when it is needed.
-	if (!existsModeSequence(fallbackSequence)) {
-		return FALLBACK_SEQUENCE_DOES_NOT_EXIST;
-	}
-
-	if (iter.value == NULL) {
-		return NO_TARGET_TABLE;
-	}
-
-	for (; iter.value != NULL; ++iter) {
-		if (!existsModeTable(iter->getTableId())) {
-			return TABLE_DOES_NOT_EXIST;
-		} else {
-			ReturnValue_t result = checkTable(getTable(iter->getTableId()));
-			if (result != RETURN_OK) {
-				return result;
-			}
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t Subsystem::checkSequence(Mode_t sequence) {
-	if (!existsModeSequence(sequence)) {
-		return SEQUENCE_DOES_NOT_EXIST;
-	}
-	HybridIterator<ModeListEntry> iter = getSequence(sequence);
-	return checkSequence(iter, getFallbackSequence(sequence));
-}
-
-bool Subsystem::existsModeSequence(Mode_t id) {
-	return modeSequences.exists(id) == RETURN_OK;
-}
-
-bool Subsystem::existsModeTable(Mode_t id) {
-	return modeTables.exists(id) == RETURN_OK;
-}
-
-HybridIterator<ModeListEntry> Subsystem::getCurrentTable() {
-	return getTable(currentSequenceIterator->getTableId());
-}
-
-void Subsystem::performChildOperation() {
-	if (isInTransition) {
-		if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
-			if (currentSequenceIterator.value == NULL) { //we're through with this sequence
-				if (checkStateAgainstTable(currentTargetTable, targetSubmode)
-						== RETURN_OK) {
-					setMode(targetMode, targetSubmode);
-					isInTransition = false;
-					return;
-				} else {
-					transitionFailed(TARGET_TABLE_NOT_REACHED,
-							getSequence(targetMode)->getTableId());
-					return;
-				}
-			}
-			if (currentSequenceIterator->checkSuccess()) {
-				if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
-						!= RETURN_OK) {
-					transitionFailed(TABLE_CHECK_FAILED,
-							currentSequenceIterator->getTableId());
-					return;
-				}
-			}
-			if (currentSequenceIterator->getWaitSeconds() != 0) {
-				if (uptimeStartTable == 0) {
-					Clock::getUptime(&uptimeStartTable);
-					return;
-				} else {
-					uint32_t uptimeNow;
-					Clock::getUptime(&uptimeNow);
-					if ((uptimeNow - uptimeStartTable)
-							< (currentSequenceIterator->getWaitSeconds() * 1000)) {
-						return;
-					}
-				}
-			}
-			uptimeStartTable = 0;
-			//next Table, but only if there is one
-			if ((++currentSequenceIterator).value != NULL) { //we're through with this sequence
-				executeTable(getCurrentTable(), targetSubmode);
-			}
-		}
-	} else {
-		if (childrenChangedHealth) {
-			triggerEvent(CHILD_CHANGED_HEALTH, 0, 0);
-			childrenChangedHealth = false;
-			startTransition(mode, submode);
-		} else if (childrenChangedMode) {
-			if (checkStateAgainstTable(currentTargetTable, submode)
-					!= RETURN_OK) {
-				triggerEvent(CANT_KEEP_MODE, mode, submode);
-				cantKeepMode();
-			}
-		}
-	}
-}
-
-HybridIterator<ModeListEntry> Subsystem::getSequence(Mode_t id) {
-	SequenceInfo *sequenceInfo = modeSequences.findValue(id);
-	if (sequenceInfo->entries.islinked) {
-		return HybridIterator<ModeListEntry>(
-				sequenceInfo->entries.firstLinkedElement);
-	} else {
-		return HybridIterator<ModeListEntry>(
-				sequenceInfo->entries.array->front(),
-				sequenceInfo->entries.array->back());
-	}
-}
-
-HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
-	EntryPointer *entry = modeTables.findValue(id);
-	if (entry->islinked) {
-		return HybridIterator<ModeListEntry>(entry->firstLinkedElement);
-	} else {
-		return HybridIterator<ModeListEntry>(entry->array->front(),
-				entry->array->back());
-	}
-}
-
-ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
-	ReturnValue_t result;
-	switch (message->getCommand()) {
-	case HealthMessage::HEALTH_INFO: {
-		HealthState health = HealthMessage::getHealth(message);
-		if (health != EXTERNAL_CONTROL) {
-			//Ignore external control, as it has an effect only if the mode changes,
-			//which is communicated with an additional mode info event.
-			childrenChangedHealth = true;
-		}
-	}
-		break;
-	case ModeSequenceMessage::ADD_SEQUENCE: {
-		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
-		const uint8_t *pointer;
-		size_t sizeRead;
-		result = IPCStore->getData(
-				ModeSequenceMessage::getStoreAddress(message), &pointer,
-				&sizeRead);
-		if (result == RETURN_OK) {
-			Mode_t fallbackId;
-			size_t size = sizeRead;
-			result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
-					SerializeIF::Endianness::BIG);
-			if (result == RETURN_OK) {
-				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
-						&sequence, &pointer, &size,
-						SerializeIF::Endianness::BIG);
-				if (result == RETURN_OK) {
-					result = addSequence(&sequence,
-							ModeSequenceMessage::getSequenceId(message),
-							fallbackId);
-				}
-			}
-			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
-		}
-		replyToCommand(result, 0);
-	}
-		break;
-	case ModeSequenceMessage::ADD_TABLE: {
-		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
-		const uint8_t *pointer;
-		size_t sizeRead;
-		result = IPCStore->getData(
-				ModeSequenceMessage::getStoreAddress(message), &pointer,
-				&sizeRead);
-		if (result == RETURN_OK) {
-			size_t size = sizeRead;
-			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
-					&pointer, &size, SerializeIF::Endianness::BIG);
-			if (result == RETURN_OK) {
-				result = addTable(&table,
-						ModeSequenceMessage::getSequenceId(message));
-			}
-			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
-		}
-		replyToCommand(result, 0);
-
-	}
-		break;
-	case ModeSequenceMessage::DELETE_SEQUENCE:
-		if (isInTransition) {
-			replyToCommand(IN_TRANSITION, 0);
-			break;
-		}
-		result = deleteSequence(ModeSequenceMessage::getSequenceId(message));
-		replyToCommand(result, 0);
-		break;
-	case ModeSequenceMessage::DELETE_TABLE:
-		if (isInTransition) {
-			replyToCommand(IN_TRANSITION, 0);
-			break;
-		}
-		result = deleteTable(ModeSequenceMessage::getTableId(message));
-		replyToCommand(result, 0);
-		break;
-	case ModeSequenceMessage::LIST_SEQUENCES: {
-		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> sequences;
-		FixedMap<Mode_t, SequenceInfo>::Iterator iter;
-		for (iter = modeSequences.begin(); iter != modeSequences.end();
-				++iter) {
-			sequences.insert(iter.value->first);
-		}
-		SerializeIF *pointer = &sequences;
-		sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE_LIST,
-				&pointer, 1);
-	}
-		break;
-	case ModeSequenceMessage::LIST_TABLES: {
-		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> tables;
-		FixedMap<Mode_t, EntryPointer>::Iterator iter;
-		for (iter = modeTables.begin(); iter != modeTables.end(); ++iter) {
-			tables.insert(iter.value->first);
-		}
-		SerializeIF *pointer = &tables;
-		sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE_LIST,
-				&pointer, 1);
-	}
-		break;
-	case ModeSequenceMessage::READ_SEQUENCE: {
-		ReturnValue_t result;
-		Mode_t sequence = ModeSequenceMessage::getSequenceId(message);
-		SequenceInfo *sequenceInfo = NULL;
-		result = modeSequences.find(sequence, &sequenceInfo);
-		if (result != RETURN_OK) {
-			replyToCommand(result, 0);
-		}
-
-		SerializeIF *elements[3];
-		SerializeElement<Mode_t> sequenceId(sequence);
-		SerializeElement<Mode_t> fallbackSequenceId(
-				getFallbackSequence(sequence));
-
-		elements[0] = &sequenceId;
-		elements[1] = &fallbackSequenceId;
-
-		if (sequenceInfo->entries.islinked) {
-			SerialLinkedListAdapter<ModeListEntry> list(
-					sequenceInfo->entries.firstLinkedElement, true);
-			elements[2] = &list;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
-					elements, 3);
-		} else {
-			SerialArrayListAdapter<ModeListEntry> serializableArray(
-					sequenceInfo->entries.array);
-
-			elements[2] = &serializableArray;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
-					elements, 3);
-		}
-	}
-		break;
-	case ModeSequenceMessage::READ_TABLE: {
-		ReturnValue_t result;
-		Mode_t table = ModeSequenceMessage::getSequenceId(message);
-		EntryPointer *entry = NULL;
-		result = modeTables.find(table, &entry);
-		if (result != RETURN_OK) {
-			replyToCommand(result, 0);
-		}
-
-		SerializeIF *elements[2];
-		SerializeElement<Mode_t> tableId(table);
-
-		elements[0] = &tableId;
-
-		if (entry->islinked) {
-			SerialLinkedListAdapter<ModeListEntry> list(
-					entry->firstLinkedElement, true);
-			elements[1] = &list;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
-					elements, 2);
-		} else {
-			SerialArrayListAdapter<ModeListEntry> serializableArray(
-					entry->array);
-			elements[1] = &serializableArray;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
-					elements, 2);
-		}
-	}
-		break;
-	case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
-		uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
-		CommandMessage reply;
-		ModeSequenceMessage::setModeSequenceMessage(&reply,
-				ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
-		commandQueue->reply(&reply);
-	}
-		break;
-	case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
-		uint32_t free = modeTables.maxSize() - modeTables.size();
-		CommandMessage reply;
-		ModeSequenceMessage::setModeSequenceMessage(&reply,
-				ModeSequenceMessage::FREE_TABLE_SLOTS, free);
-		commandQueue->reply(&reply);
-	}
-		break;
-	default:
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
-	if (status == RETURN_OK) {
-		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
-		commandQueue->reply(&reply);
-	} else {
-		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0);
-		commandQueue->reply(&reply);
-	}
-}
-
-ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
-		Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
-
-	ReturnValue_t result;
-
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
-	//Sequences added before are checked by initialize()
-	if (!preInit) {
-		result = checkSequence(
-				HybridIterator<ModeListEntry>(sequence->front(),
-						sequence->back()), fallbackSequence);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-
-	SequenceInfo info;
-
-	info.fallbackSequence = fallbackSequence;
-
-	info.entries.islinked = inStore;
-	info.entries.array = sequence;
-
-	result = modeSequences.insert(id, info);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	if (inStore) {
-#ifdef USE_MODESTORE
-		result = modeStore->storeArray(sequence,
-				&(modeSequences.find(id)->entries.firstLinkedElement));
-		if (result != RETURN_OK) {
-			modeSequences.erase(id);
-		}
-#else
-		modeSequences.erase(id);
-		return RETURN_FAILED;
-#endif
-	}
-
-	return result;
-
-}
-
-ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
-		bool inStore, bool preInit) {
-
-	ReturnValue_t result;
-
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
-	//Tables added before are checked by initialize()
-	if (!preInit) {
-		result = checkTable(
-				HybridIterator<ModeListEntry>(table->front(), table->back()));
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-
-	EntryPointer pointer;
-
-	pointer.islinked = inStore;
-	pointer.array = table;
-
-	result = modeTables.insert(id, pointer);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	if (inStore) {
-#ifdef USE_MODESTORE
-		result = modeStore->storeArray(table,
-				&(modeTables.find(id)->firstLinkedElement));
-		if (result != RETURN_OK) {
-			modeTables.erase(id);
-		}
-#else
-		modeTables.erase(id);
-		return RETURN_FAILED;
-#endif
-	}
-	return result;
-}
-
-ReturnValue_t Subsystem::deleteSequence(Mode_t id) {
-
-	if (isFallbackSequence(id)) {
-		return IS_FALLBACK_SEQUENCE;
-	}
-
-	SequenceInfo *sequenceInfo;
-	ReturnValue_t result;
-	result = modeSequences.find(id, &sequenceInfo);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (!sequenceInfo->entries.islinked) {
-		return ACCESS_DENIED;
-	}
-
-#ifdef USE_MODESTORE
-	modeStore->deleteList(sequenceInfo->entries.firstLinkedElement);
-#endif
-	modeSequences.erase(id);
-	return RETURN_OK;
-}
-
-ReturnValue_t Subsystem::deleteTable(Mode_t id) {
-
-	if (isTableUsed(id)) {
-		return TABLE_IN_USE;
-	}
-
-	EntryPointer *pointer;
-	ReturnValue_t result;
-	result = modeTables.find(id, &pointer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (!pointer->islinked) {
-		return ACCESS_DENIED;
-	}
-
-#ifdef USE_MODESTORE
-	modeStore->deleteList(pointer->firstLinkedElement);
-#endif
-	modeSequences.erase(id);
-	return RETURN_OK;
-}
-
-ReturnValue_t Subsystem::initialize() {
-	ReturnValue_t result = SubsystemBase::initialize();
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (IPCStore == NULL) {
-		return RETURN_FAILED;
-	}
-
-#ifdef USE_MODESTORE
-	modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
-
-	if (modeStore == NULL) {
-		return RETURN_FAILED;
-	}
-#endif
-
-	if ((modeSequences.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)
-			|| (modeTables.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)) {
-		return TABLE_OR_SEQUENCE_LENGTH_INVALID;
-	}
-
-	mode = initialMode;
-
-	return RETURN_OK;
-}
-
-MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
-	return SubsystemBase::getCommandQueue();
-}
-
-ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
-		uint32_t *msToReachTheMode) {
-	//Need to accept all submodes to be able to inherit submodes
-//	if (submode != SUBMODE_NONE) {
-//		return INVALID_SUBMODE;
-//	}
-
-	if (isInTransition && (mode != getFallbackSequence(targetMode))) {
-		return HasModesIF::IN_TRANSITION;
-	} else {
-		return checkSequence(mode);
-	}
-}
-
-void Subsystem::startTransition(Mode_t sequence, Submode_t submode) {
-	if (modeHelper.isForced()) {
-		triggerEvent(FORCING_MODE, sequence, submode);
-	} else {
-		triggerEvent(CHANGING_MODE, sequence, submode);
-	}
-	targetMode = sequence;
-	targetSubmode = submode;
-	isInTransition = true;
-	commandsOutstanding = 0;
-	currentSequenceIterator = getSequence(sequence);
-
-	currentTargetTable = getTable(currentSequenceIterator->getTableId());
-
-	++currentSequenceIterator;
-
-	if (currentSequenceIterator.value != NULL) {
-		executeTable(getCurrentTable(), targetSubmode);
-	}
-}
-
-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 -1;
-}
-
-bool Subsystem::isFallbackSequence(Mode_t SequenceId) {
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
-			iter != modeSequences.end(); iter++) {
-		if (iter->fallbackSequence == SequenceId) {
-			return true;
-		}
-	}
-	return false;
-}
-
-bool Subsystem::isTableUsed(Mode_t tableId) {
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator sequence =
-			modeSequences.begin(); sequence != modeSequences.end();
-			sequence++) {
-		HybridIterator<ModeListEntry> sequenceIterator = getSequence(
-				sequence.value->first);
-		while (sequenceIterator.value != NULL) {
-			if (sequenceIterator->getTableId() == tableId) {
-				return true;
-			}
-			++sequenceIterator;
-		}
-	}
-	return false;
-}
-
-void Subsystem::transitionFailed(ReturnValue_t failureCode,
-		uint32_t parameter) {
-	triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter);
-	if (mode == targetMode) {
-		//already tried going back to the current mode
-		//go into fallback mode, also set current mode to fallback mode, so we come here at the next fail
-		modeHelper.setForced(true);
-		ReturnValue_t result;
-		if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
-			triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
-			isInTransition = false; //keep still and allow arbitrary mode commands to recover
-			return;
-		}
-		mode = getFallbackSequence(mode);
-		startTransition(mode, submode);
-	} else {
-		//try to go back to the current mode
-		startTransition(mode, submode);
-	}
-}
-
-void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
-		SerializeIF **elements, uint8_t count) {
-	ReturnValue_t result;
-	size_t maxSize = 0;
-	for (uint8_t i = 0; i < count; i++) {
-		maxSize += elements[i]->getSerializedSize();
-	}
-	uint8_t *storeBuffer;
-	store_address_t address;
-	size_t size = 0;
-
-	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		replyToCommand(result, 0);
-		return;
-	}
-	for (uint8_t i = 0; i < count; i++) {
-		elements[i]->serialize(&storeBuffer, &size, maxSize,
-				SerializeIF::Endianness::BIG);
-	}
-	CommandMessage reply;
-	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
-	if (commandQueue->reply(&reply) != RETURN_OK) {
-		IPCStore->deleteData(address);
-	}
-}
-
-ReturnValue_t Subsystem::checkObjectConnections() {
-	ReturnValue_t result = RETURN_OK;
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
-			iter != modeSequences.end(); iter++) {
-		result = checkSequence(iter.value->first);
-		if (result != RETURN_OK) {
-			return result;
-		}
-
-	}
-	return RETURN_OK;
-}
-
-void Subsystem::setInitialMode(Mode_t mode) {
-	initialMode = mode;
-}
-
-void Subsystem::cantKeepMode() {
-	ReturnValue_t result;
-	if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
-		triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
-		return;
-	}
-
-	modeHelper.setForced(true);
-
-	//already set the mode, so that we do not try to go back in our old mode when the transition fails
-	mode = getFallbackSequence(mode);
-	//SHOULDDO: We should store submodes for fallback sequence as well, otherwise we should get rid of submodes completely.
-	startTransition(mode, SUBMODE_NONE);
-}
+#include "Subsystem.h"
+#include "../health/HealthMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+
+#include <string>
+
+Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
+		uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) :
+		SubsystemBase(setObjectId, parent, 0), isInTransition(false),
+		childrenChangedHealth(false), currentTargetTable(),
+		targetMode(0), targetSubmode(SUBMODE_NONE), initialMode(0),
+		currentSequenceIterator(), modeTables(maxNumberOfTables),
+		modeSequences(maxNumberOfSequences) {}
+
+Subsystem::~Subsystem() {
+	//Auto-generated destructor stub
+}
+
+ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
+		Mode_t fallbackSequence) {
+
+	//only check for existence, checking the fallback would lead to a (possibly infinite) recursion.
+	//the fallback sequence will be checked when it is needed.
+	if (!existsModeSequence(fallbackSequence)) {
+		return FALLBACK_SEQUENCE_DOES_NOT_EXIST;
+	}
+
+	if (iter.value == NULL) {
+		return NO_TARGET_TABLE;
+	}
+
+	for (; iter.value != NULL; ++iter) {
+		if (!existsModeTable(iter->getTableId())) {
+			return TABLE_DOES_NOT_EXIST;
+		} else {
+			ReturnValue_t result = checkTable(getTable(iter->getTableId()));
+			if (result != RETURN_OK) {
+				return result;
+			}
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t Subsystem::checkSequence(Mode_t sequence) {
+	if (!existsModeSequence(sequence)) {
+		return SEQUENCE_DOES_NOT_EXIST;
+	}
+	HybridIterator<ModeListEntry> iter = getSequence(sequence);
+	return checkSequence(iter, getFallbackSequence(sequence));
+}
+
+bool Subsystem::existsModeSequence(Mode_t id) {
+	return modeSequences.exists(id) == RETURN_OK;
+}
+
+bool Subsystem::existsModeTable(Mode_t id) {
+	return modeTables.exists(id) == RETURN_OK;
+}
+
+HybridIterator<ModeListEntry> Subsystem::getCurrentTable() {
+	return getTable(currentSequenceIterator->getTableId());
+}
+
+void Subsystem::performChildOperation() {
+	if (isInTransition) {
+		if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
+			if (currentSequenceIterator.value == NULL) { //we're through with this sequence
+				if (checkStateAgainstTable(currentTargetTable, targetSubmode)
+						== RETURN_OK) {
+					setMode(targetMode, targetSubmode);
+					isInTransition = false;
+					return;
+				} else {
+					transitionFailed(TARGET_TABLE_NOT_REACHED,
+							getSequence(targetMode)->getTableId());
+					return;
+				}
+			}
+			if (currentSequenceIterator->checkSuccess()) {
+				if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
+						!= RETURN_OK) {
+					transitionFailed(TABLE_CHECK_FAILED,
+							currentSequenceIterator->getTableId());
+					return;
+				}
+			}
+			if (currentSequenceIterator->getWaitSeconds() != 0) {
+				if (uptimeStartTable == 0) {
+					Clock::getUptime(&uptimeStartTable);
+					return;
+				} else {
+					uint32_t uptimeNow;
+					Clock::getUptime(&uptimeNow);
+					if ((uptimeNow - uptimeStartTable)
+							< (currentSequenceIterator->getWaitSeconds() * 1000)) {
+						return;
+					}
+				}
+			}
+			uptimeStartTable = 0;
+			//next Table, but only if there is one
+			if ((++currentSequenceIterator).value != NULL) { //we're through with this sequence
+				executeTable(getCurrentTable(), targetSubmode);
+			}
+		}
+	} else {
+		if (childrenChangedHealth) {
+			triggerEvent(CHILD_CHANGED_HEALTH, 0, 0);
+			childrenChangedHealth = false;
+			startTransition(mode, submode);
+		} else if (childrenChangedMode) {
+			if (checkStateAgainstTable(currentTargetTable, submode)
+					!= RETURN_OK) {
+				triggerEvent(CANT_KEEP_MODE, mode, submode);
+				cantKeepMode();
+			}
+		}
+	}
+}
+
+HybridIterator<ModeListEntry> Subsystem::getSequence(Mode_t id) {
+	SequenceInfo *sequenceInfo = modeSequences.findValue(id);
+	if (sequenceInfo->entries.islinked) {
+		return HybridIterator<ModeListEntry>(
+				sequenceInfo->entries.firstLinkedElement);
+	} else {
+		return HybridIterator<ModeListEntry>(
+				sequenceInfo->entries.array->front(),
+				sequenceInfo->entries.array->back());
+	}
+}
+
+HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
+	EntryPointer *entry = modeTables.findValue(id);
+	if (entry->islinked) {
+		return HybridIterator<ModeListEntry>(entry->firstLinkedElement);
+	} else {
+		return HybridIterator<ModeListEntry>(entry->array->front(),
+				entry->array->back());
+	}
+}
+
+ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
+	switch (message->getCommand()) {
+	case HealthMessage::HEALTH_INFO: {
+		HealthState health = HealthMessage::getHealth(message);
+		if (health != EXTERNAL_CONTROL) {
+			//Ignore external control, as it has an effect only if the mode changes,
+			//which is communicated with an additional mode info event.
+			childrenChangedHealth = true;
+		}
+	}
+		break;
+	case ModeSequenceMessage::ADD_SEQUENCE: {
+		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
+		const uint8_t *pointer;
+		size_t sizeRead;
+		ReturnValue_t result = IPCStore->getData(
+				ModeSequenceMessage::getStoreAddress(message), &pointer,
+				&sizeRead);
+		if (result == RETURN_OK) {
+			Mode_t fallbackId;
+			size_t size = sizeRead;
+			result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
+					SerializeIF::Endianness::BIG);
+			if (result == RETURN_OK) {
+				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
+						&sequence, &pointer, &size,
+						SerializeIF::Endianness::BIG);
+				if (result == RETURN_OK) {
+					result = addSequence(&sequence,
+							ModeSequenceMessage::getSequenceId(message),
+							fallbackId);
+				}
+			}
+			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+		replyToCommand(result, 0);
+	}
+		break;
+	case ModeSequenceMessage::ADD_TABLE: {
+		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
+		const uint8_t *pointer;
+		size_t sizeRead;
+		ReturnValue_t result = IPCStore->getData(
+				ModeSequenceMessage::getStoreAddress(message), &pointer,
+				&sizeRead);
+		if (result == RETURN_OK) {
+			size_t size = sizeRead;
+			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
+					&pointer, &size, SerializeIF::Endianness::BIG);
+			if (result == RETURN_OK) {
+				result = addTable(&table,
+						ModeSequenceMessage::getSequenceId(message));
+			}
+			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+		replyToCommand(result, 0);
+
+	}
+		break;
+	case ModeSequenceMessage::DELETE_SEQUENCE:{
+		if (isInTransition) {
+			replyToCommand(IN_TRANSITION, 0);
+			break;
+		}
+		ReturnValue_t result = deleteSequence(ModeSequenceMessage::getSequenceId(message));
+		replyToCommand(result, 0);
+	}
+		break;
+	case ModeSequenceMessage::DELETE_TABLE:{
+		if (isInTransition) {
+			replyToCommand(IN_TRANSITION, 0);
+			break;
+		}
+		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;
+		FixedMap<Mode_t, SequenceInfo>::Iterator iter;
+		for (iter = modeSequences.begin(); iter != modeSequences.end();
+				++iter) {
+			sequences.insert(iter.value->first);
+		}
+		SerializeIF *pointer = &sequences;
+		sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE_LIST,
+				&pointer, 1);
+	}
+		break;
+	case ModeSequenceMessage::LIST_TABLES: {
+		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> tables;
+		FixedMap<Mode_t, EntryPointer>::Iterator iter;
+		for (iter = modeTables.begin(); iter != modeTables.end(); ++iter) {
+			tables.insert(iter.value->first);
+		}
+		SerializeIF *pointer = &tables;
+		sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE_LIST,
+				&pointer, 1);
+	}
+		break;
+	case ModeSequenceMessage::READ_SEQUENCE: {
+		ReturnValue_t result;
+		Mode_t sequence = ModeSequenceMessage::getSequenceId(message);
+		SequenceInfo *sequenceInfo = NULL;
+		result = modeSequences.find(sequence, &sequenceInfo);
+		if (result != RETURN_OK) {
+			replyToCommand(result, 0);
+		}
+
+		SerializeIF *elements[3];
+		SerializeElement<Mode_t> sequenceId(sequence);
+		SerializeElement<Mode_t> fallbackSequenceId(
+				getFallbackSequence(sequence));
+
+		elements[0] = &sequenceId;
+		elements[1] = &fallbackSequenceId;
+
+		if (sequenceInfo->entries.islinked) {
+			SerialLinkedListAdapter<ModeListEntry> list(
+					sequenceInfo->entries.firstLinkedElement, true);
+			elements[2] = &list;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
+					elements, 3);
+		} else {
+			SerialArrayListAdapter<ModeListEntry> serializableArray(
+					sequenceInfo->entries.array);
+
+			elements[2] = &serializableArray;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
+					elements, 3);
+		}
+	}
+		break;
+	case ModeSequenceMessage::READ_TABLE: {
+		ReturnValue_t result;
+		Mode_t table = ModeSequenceMessage::getSequenceId(message);
+		EntryPointer *entry = NULL;
+		result = modeTables.find(table, &entry);
+		if (result != RETURN_OK) {
+			replyToCommand(result, 0);
+		}
+
+		SerializeIF *elements[2];
+		SerializeElement<Mode_t> tableId(table);
+
+		elements[0] = &tableId;
+
+		if (entry->islinked) {
+			SerialLinkedListAdapter<ModeListEntry> list(
+					entry->firstLinkedElement, true);
+			elements[1] = &list;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
+					elements, 2);
+		} else {
+			SerialArrayListAdapter<ModeListEntry> serializableArray(
+					entry->array);
+			elements[1] = &serializableArray;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
+					elements, 2);
+		}
+	}
+		break;
+	case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
+		uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
+		CommandMessage reply;
+		ModeSequenceMessage::setModeSequenceMessage(&reply,
+				ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
+		commandQueue->reply(&reply);
+	}
+		break;
+	case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
+		uint32_t free = modeTables.maxSize() - modeTables.size();
+		CommandMessage reply;
+		ModeSequenceMessage::setModeSequenceMessage(&reply,
+				ModeSequenceMessage::FREE_TABLE_SLOTS, free);
+		commandQueue->reply(&reply);
+	}
+		break;
+	default:
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
+	if (status == RETURN_OK) {
+		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
+		commandQueue->reply(&reply);
+	} else {
+		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0);
+		commandQueue->reply(&reply);
+	}
+}
+
+ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
+		Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
+
+	ReturnValue_t result;
+
+	//Before initialize() is called, tables must not be checked as the children are not added yet.
+	//Sequences added before are checked by initialize()
+	if (!preInit) {
+		result = checkSequence(
+				HybridIterator<ModeListEntry>(sequence->front(),
+						sequence->back()), fallbackSequence);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+
+	SequenceInfo info;
+
+	info.fallbackSequence = fallbackSequence;
+
+	info.entries.islinked = inStore;
+	info.entries.array = sequence;
+
+	result = modeSequences.insert(id, info);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	if (inStore) {
+#ifdef USE_MODESTORE
+		result = modeStore->storeArray(sequence,
+				&(modeSequences.find(id)->entries.firstLinkedElement));
+		if (result != RETURN_OK) {
+			modeSequences.erase(id);
+		}
+#else
+		modeSequences.erase(id);
+		return RETURN_FAILED;
+#endif
+	}
+
+	return result;
+
+}
+
+ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
+		bool inStore, bool preInit) {
+
+	ReturnValue_t result;
+
+	//Before initialize() is called, tables must not be checked as the children are not added yet.
+	//Tables added before are checked by initialize()
+	if (!preInit) {
+		result = checkTable(
+				HybridIterator<ModeListEntry>(table->front(), table->back()));
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+
+	EntryPointer pointer;
+
+	pointer.islinked = inStore;
+	pointer.array = table;
+
+	result = modeTables.insert(id, pointer);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	if (inStore) {
+#ifdef USE_MODESTORE
+		result = modeStore->storeArray(table,
+				&(modeTables.find(id)->firstLinkedElement));
+		if (result != RETURN_OK) {
+			modeTables.erase(id);
+		}
+#else
+		modeTables.erase(id);
+		return RETURN_FAILED;
+#endif
+	}
+	return result;
+}
+
+ReturnValue_t Subsystem::deleteSequence(Mode_t id) {
+
+	if (isFallbackSequence(id)) {
+		return IS_FALLBACK_SEQUENCE;
+	}
+
+	SequenceInfo *sequenceInfo;
+	ReturnValue_t result;
+	result = modeSequences.find(id, &sequenceInfo);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (!sequenceInfo->entries.islinked) {
+		return ACCESS_DENIED;
+	}
+
+#ifdef USE_MODESTORE
+	modeStore->deleteList(sequenceInfo->entries.firstLinkedElement);
+#endif
+	modeSequences.erase(id);
+	return RETURN_OK;
+}
+
+ReturnValue_t Subsystem::deleteTable(Mode_t id) {
+
+	if (isTableUsed(id)) {
+		return TABLE_IN_USE;
+	}
+
+	EntryPointer *pointer;
+	ReturnValue_t result;
+	result = modeTables.find(id, &pointer);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (!pointer->islinked) {
+		return ACCESS_DENIED;
+	}
+
+#ifdef USE_MODESTORE
+	modeStore->deleteList(pointer->firstLinkedElement);
+#endif
+	modeSequences.erase(id);
+	return RETURN_OK;
+}
+
+ReturnValue_t Subsystem::initialize() {
+	ReturnValue_t result = SubsystemBase::initialize();
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (IPCStore == NULL) {
+		return RETURN_FAILED;
+	}
+
+#ifdef USE_MODESTORE
+	modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
+
+	if (modeStore == NULL) {
+		return RETURN_FAILED;
+	}
+#endif
+
+	if ((modeSequences.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)
+			|| (modeTables.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)) {
+		return TABLE_OR_SEQUENCE_LENGTH_INVALID;
+	}
+
+	mode = initialMode;
+
+	return RETURN_OK;
+}
+
+MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
+	return SubsystemBase::getCommandQueue();
+}
+
+ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
+		uint32_t *msToReachTheMode) {
+	//Need to accept all submodes to be able to inherit submodes
+//	if (submode != SUBMODE_NONE) {
+//		return INVALID_SUBMODE;
+//	}
+
+	if (isInTransition && (mode != getFallbackSequence(targetMode))) {
+		return HasModesIF::IN_TRANSITION;
+	} else {
+		return checkSequence(mode);
+	}
+}
+
+void Subsystem::startTransition(Mode_t sequence, Submode_t submode) {
+	if (modeHelper.isForced()) {
+		triggerEvent(FORCING_MODE, sequence, submode);
+	} else {
+		triggerEvent(CHANGING_MODE, sequence, submode);
+	}
+	targetMode = sequence;
+	targetSubmode = submode;
+	isInTransition = true;
+	commandsOutstanding = 0;
+	currentSequenceIterator = getSequence(sequence);
+
+	currentTargetTable = getTable(currentSequenceIterator->getTableId());
+
+	++currentSequenceIterator;
+
+	if (currentSequenceIterator.value != NULL) {
+		executeTable(getCurrentTable(), targetSubmode);
+	}
+}
+
+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 -1;
+}
+
+bool Subsystem::isFallbackSequence(Mode_t SequenceId) {
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
+			iter != modeSequences.end(); iter++) {
+		if (iter->fallbackSequence == SequenceId) {
+			return true;
+		}
+	}
+	return false;
+}
+
+bool Subsystem::isTableUsed(Mode_t tableId) {
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator sequence =
+			modeSequences.begin(); sequence != modeSequences.end();
+			sequence++) {
+		HybridIterator<ModeListEntry> sequenceIterator = getSequence(
+				sequence.value->first);
+		while (sequenceIterator.value != NULL) {
+			if (sequenceIterator->getTableId() == tableId) {
+				return true;
+			}
+			++sequenceIterator;
+		}
+	}
+	return false;
+}
+
+void Subsystem::transitionFailed(ReturnValue_t failureCode,
+		uint32_t parameter) {
+	triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter);
+	if (mode == targetMode) {
+		//already tried going back to the current mode
+		//go into fallback mode, also set current mode to fallback mode, so we come here at the next fail
+		modeHelper.setForced(true);
+		ReturnValue_t result;
+		if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
+			triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
+			isInTransition = false; //keep still and allow arbitrary mode commands to recover
+			return;
+		}
+		mode = getFallbackSequence(mode);
+		startTransition(mode, submode);
+	} else {
+		//try to go back to the current mode
+		startTransition(mode, submode);
+	}
+}
+
+void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
+		SerializeIF **elements, uint8_t count) {
+	ReturnValue_t result;
+	size_t maxSize = 0;
+	for (uint8_t i = 0; i < count; i++) {
+		maxSize += elements[i]->getSerializedSize();
+	}
+	uint8_t *storeBuffer;
+	store_address_t address;
+	size_t size = 0;
+
+	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		replyToCommand(result, 0);
+		return;
+	}
+	for (uint8_t i = 0; i < count; i++) {
+		elements[i]->serialize(&storeBuffer, &size, maxSize,
+				SerializeIF::Endianness::BIG);
+	}
+	CommandMessage reply;
+	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
+	if (commandQueue->reply(&reply) != RETURN_OK) {
+		IPCStore->deleteData(address);
+	}
+}
+
+ReturnValue_t Subsystem::checkObjectConnections() {
+	ReturnValue_t result = RETURN_OK;
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
+			iter != modeSequences.end(); iter++) {
+		result = checkSequence(iter.value->first);
+		if (result != RETURN_OK) {
+			return result;
+		}
+
+	}
+	return RETURN_OK;
+}
+
+void Subsystem::setInitialMode(Mode_t mode) {
+	initialMode = mode;
+}
+
+void Subsystem::cantKeepMode() {
+	ReturnValue_t result;
+	if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
+		triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
+		return;
+	}
+
+	modeHelper.setForced(true);
+
+	//already set the mode, so that we do not try to go back in our old mode when the transition fails
+	mode = getFallbackSequence(mode);
+	//SHOULDDO: We should store submodes for fallback sequence as well, otherwise we should get rid of submodes completely.
+	startTransition(mode, SUBMODE_NONE);
+}
diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index b296a2e88..de4761faa 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -92,7 +92,7 @@ protected:
 
 	bool childrenChangedHealth;
 
-	uint32_t uptimeStartTable;
+	uint32_t uptimeStartTable = 0;
 
 	HybridIterator<ModeListEntry> currentTargetTable;
 
@@ -108,10 +108,10 @@ protected:
 
 	FixedMap<Mode_t, SequenceInfo> modeSequences;
 
-	StorageManagerIF *IPCStore;
+	StorageManagerIF *IPCStore = nullptr;
 
 #ifdef USE_MODESTORE
-	ModeStoreIF *modeStore;
+	ModeStoreIF *modeStore = nullptr;
 #endif
 
 	bool existsModeSequence(Mode_t id);
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index e073ad860..7124d8bd9 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -119,7 +119,7 @@ ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* f
 
 	if (temp->pField & (1 << 3)) { //day of year variation
 		uint16_t tempDay = (temp->month << 8) + temp->day;
-		ReturnValue_t result = convertDaysOfYear(tempDay, to->year,
+		result = convertDaysOfYear(tempDay, to->year,
 				&(temp->month), &(temp->day));
 		if (result != RETURN_OK) {
 			return result;

From 468ebfb809f4ec6140492e3146f134f54b4f1d7d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:18:11 +0200
Subject: [PATCH 0674/1774] include improvement

---
 globalfunctions/timevalOperations.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/globalfunctions/timevalOperations.cpp b/globalfunctions/timevalOperations.cpp
index aa921511a..ae49ef216 100644
--- a/globalfunctions/timevalOperations.cpp
+++ b/globalfunctions/timevalOperations.cpp
@@ -1,4 +1,4 @@
-#include "../globalfunctions/timevalOperations.h"
+#include "timevalOperations.h"
 
 timeval& operator+=(timeval& lhs, const timeval& rhs) {
 	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;

From 8862f35ad136991e4f4a04d5551a507aba3ed31b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:35:27 +0200
Subject: [PATCH 0675/1774] git is weird

---
 action/ActionHelper.cpp        | 220 ++++++++++++++--------------
 action/ActionHelper.h          | 186 ++++++++++++------------
 action/ActionMessage.cpp       | 158 ++++++++++----------
 action/ActionMessage.h         |  64 ++++-----
 action/CommandActionHelper.cpp | 254 ++++++++++++++++-----------------
 action/CommandActionHelper.h   |  72 +++++-----
 action/CommandsActionsIF.h     |  68 ++++-----
 action/HasActionsIF.h          | 120 ++++++++--------
 action/SimpleActionHelper.cpp  | 148 +++++++++----------
 action/SimpleActionHelper.h    |  48 +++----
 10 files changed, 669 insertions(+), 669 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index a367af161..b43c676d0 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -1,110 +1,110 @@
-#include "../action/ActionHelper.h"
-#include "../action/HasActionsIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
-}
-
-ActionHelper::~ActionHelper() {
-}
-
-ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
-	if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
-		ActionId_t currentAction = ActionMessage::getActionId(command);
-		prepareExecution(command->getSender(), currentAction,
-				ActionMessage::getStoreId(command));
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return CommandMessage::UNKNOWN_COMMAND;
-	}
-}
-
-ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(queueToUse_ != nullptr) {
-		setQueueToUse(queueToUse_);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
-	queueToUse->sendMessage(reportTo, &reply);
-}
-
-void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setCompletionReply(&reply, commandId, result);
-	queueToUse->sendMessage(reportTo, &reply);
-}
-
-void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
-	queueToUse = queue;
-}
-
-void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-		store_address_t dataAddress) {
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-}
-
-ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
-		ActionId_t replyId, SerializeIF* data, bool hideSender) {
-	CommandMessage reply;
-	store_address_t storeAddress;
-	uint8_t *dataPtr;
-	size_t maxSize = data->getSerializedSize();
-	if (maxSize == 0) {
-		//No error, there's simply nothing to report.
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
-			&dataPtr);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeAddress);
-		return result;
-	}
-	//We don't need to report the objectId, as we receive REQUESTED data before the completion success message.
-	//True aperiodic replies need to be reported with another dedicated message.
-	ActionMessage::setDataReply(&reply, replyId, storeAddress);
-
-	//TODO Service Implementation sucks at the moment
-	if (hideSender){
-		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
-	} else {
-		result = queueToUse->sendMessage(reportTo, &reply);
-	}
-	if ( result != HasReturnvaluesIF::RETURN_OK){
-		ipcStore->deleteData(storeAddress);
-	}
-	return result;
-}
-
-void ActionHelper::resetHelper() {
-}
+#include "ActionHelper.h"
+#include "HasActionsIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
+		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
+}
+
+ActionHelper::~ActionHelper() {
+}
+
+ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
+	if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
+		ActionId_t currentAction = ActionMessage::getActionId(command);
+		prepareExecution(command->getSender(), currentAction,
+				ActionMessage::getStoreId(command));
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return CommandMessage::UNKNOWN_COMMAND;
+	}
+}
+
+ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(queueToUse_ != nullptr) {
+		setQueueToUse(queueToUse_);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+	CommandMessage reply;
+	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
+	queueToUse->sendMessage(reportTo, &reply);
+}
+
+void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+	CommandMessage reply;
+	ActionMessage::setCompletionReply(&reply, commandId, result);
+	queueToUse->sendMessage(reportTo, &reply);
+}
+
+void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
+	queueToUse = queue;
+}
+
+void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
+		store_address_t dataAddress) {
+	const uint8_t* dataPtr = NULL;
+	size_t size = 0;
+	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		CommandMessage reply;
+		ActionMessage::setStepReply(&reply, actionId, 0, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+		return;
+	}
+	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+	ipcStore->deleteData(dataAddress);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		CommandMessage reply;
+		ActionMessage::setStepReply(&reply, actionId, 0, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+		return;
+	}
+}
+
+ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
+		ActionId_t replyId, SerializeIF* data, bool hideSender) {
+	CommandMessage reply;
+	store_address_t storeAddress;
+	uint8_t *dataPtr;
+	size_t maxSize = data->getSerializedSize();
+	if (maxSize == 0) {
+		//No error, there's simply nothing to report.
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	size_t size = 0;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
+			&dataPtr);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		ipcStore->deleteData(storeAddress);
+		return result;
+	}
+	//We don't need to report the objectId, as we receive REQUESTED data before the completion success message.
+	//True aperiodic replies need to be reported with another dedicated message.
+	ActionMessage::setDataReply(&reply, replyId, storeAddress);
+
+	//TODO Service Implementation sucks at the moment
+	if (hideSender){
+		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+	} else {
+		result = queueToUse->sendMessage(reportTo, &reply);
+	}
+	if ( result != HasReturnvaluesIF::RETURN_OK){
+		ipcStore->deleteData(storeAddress);
+	}
+	return result;
+}
+
+void ActionHelper::resetHelper() {
+}
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index f528b0312..bbc6d114d 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -1,93 +1,93 @@
-#ifndef ACTIONHELPER_H_
-#define ACTIONHELPER_H_
-
-#include "../action/ActionMessage.h"
-#include "../serialize/SerializeIF.h"
-#include "../ipc/MessageQueueIF.h"
-/**
- * \brief Action Helper is a helper class which handles action messages
- *
- * Components which use the HasActionIF this helper can be used to handle the action messages.
- * It does handle step messages as well as other answers to action calls. It uses the executeAction function
- * of its owner as callback. The call of the initialize function is mandatory and it needs a valid messageQueueIF pointer!
- */
-class HasActionsIF;
-
-class ActionHelper {
-public:
-	/**
-	 * Constructor of the action helper
-	 * @param setOwner Pointer to the owner of the interface
-	 * @param useThisQueue messageQueue to be used, can be set during initialize function as well.
-	 */
-	ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-
-	virtual ~ActionHelper();
-	/**
-	 * Function to be called from the owner with a new command message
-	 *
-	 * If the message is a valid action message the helper will use the executeAction function from HasActionsIF.
-	 * If the message is invalid or the callback fails a message reply will be send to the sender of the message automatically.
-	 *
-	 * @param command Pointer to a command message received by the owner
-	 * @return HasReturnvaluesIF::RETURN_OK if the message is a action message, CommandMessage::UNKNOW_COMMAND if this message ID is unkown
-	 */
-	ReturnValue_t handleActionMessage(CommandMessage* command);
-	/**
-	 * Helper initialize function. Must be called before use of any other helper function
-	 * @param queueToUse_ Pointer to the messageQueue to be used
-	 * @return Returns RETURN_OK if successful
-	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
-	/**
-	 * Function to be called from the owner to send a step message. Success or failure will be determined by the result value.
-	 *
-	 * @param step Number of steps already done
-	 * @param reportTo The messageQueueId to report the step message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner to send a action completion message
-	 *
-	 * @param reportTo MessageQueueId_t to report the action completion message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner if an action does report data
-	 *
-	 * @param reportTo MessageQueueId_t to report the action completion message to
-	 * @param replyId ID of the executed command
-	 * @param data Pointer to the data
-	 * @return Returns RETURN_OK if successful, otherwise failure code
-	 */
-	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data, bool hideSender = false);
-	/**
-	 * Function to setup the MessageQueueIF* of the helper. Can be used to set the messageQueueIF* if
-	 * message queue is unavailable at construction and initialize but must be setup before first call of other functions.
-	 * @param queue Queue to be used by the helper
-	 */
-	void setQueueToUse(MessageQueueIF *queue);
-protected:
-	static const uint8_t STEP_OFFSET = 1;//!< Increase of value of this per step
-	HasActionsIF* owner;//!< Pointer to the owner
-	MessageQueueIF* queueToUse;//!< Queue to be used as response sender, has to be set with
-	StorageManagerIF* ipcStore;//!< Pointer to an IPC Store, initialized during construction or initialize(MessageQueueIF* queueToUse_) or with setQueueToUse(MessageQueueIF *queue)
-	/**
-	 *Internal function called by handleActionMessage(CommandMessage* command)
-	 *
-	 * @param commandedBy MessageQueueID of Commander
-	 * @param actionId ID of action to be done
-	 * @param dataAddress Address of additional data in IPC Store
-	 */
-	virtual void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
-	/**
-	 *
-	 */
-	virtual void resetHelper();
-};
-
-#endif /* ACTIONHELPER_H_ */
+#ifndef ACTIONHELPER_H_
+#define ACTIONHELPER_H_
+
+#include "ActionMessage.h"
+#include "../serialize/SerializeIF.h"
+#include "../ipc/MessageQueueIF.h"
+/**
+ * \brief Action Helper is a helper class which handles action messages
+ *
+ * Components which use the HasActionIF this helper can be used to handle the action messages.
+ * It does handle step messages as well as other answers to action calls. It uses the executeAction function
+ * of its owner as callback. The call of the initialize function is mandatory and it needs a valid messageQueueIF pointer!
+ */
+class HasActionsIF;
+
+class ActionHelper {
+public:
+	/**
+	 * Constructor of the action helper
+	 * @param setOwner Pointer to the owner of the interface
+	 * @param useThisQueue messageQueue to be used, can be set during initialize function as well.
+	 */
+	ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+
+	virtual ~ActionHelper();
+	/**
+	 * Function to be called from the owner with a new command message
+	 *
+	 * If the message is a valid action message the helper will use the executeAction function from HasActionsIF.
+	 * If the message is invalid or the callback fails a message reply will be send to the sender of the message automatically.
+	 *
+	 * @param command Pointer to a command message received by the owner
+	 * @return HasReturnvaluesIF::RETURN_OK if the message is a action message, CommandMessage::UNKNOW_COMMAND if this message ID is unkown
+	 */
+	ReturnValue_t handleActionMessage(CommandMessage* command);
+	/**
+	 * Helper initialize function. Must be called before use of any other helper function
+	 * @param queueToUse_ Pointer to the messageQueue to be used, optional if queue was set in constructor
+	 * @return Returns RETURN_OK if successful
+	 */
+	ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
+	/**
+	 * Function to be called from the owner to send a step message. Success or failure will be determined by the result value.
+	 *
+	 * @param step Number of steps already done
+	 * @param reportTo The messageQueueId to report the step message to
+	 * @param commandId ID of the executed command
+	 * @param result Result of the execution
+	 */
+	void step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	/**
+	 * Function to be called by the owner to send a action completion message
+	 *
+	 * @param reportTo MessageQueueId_t to report the action completion message to
+	 * @param commandId ID of the executed command
+	 * @param result Result of the execution
+	 */
+	void finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	/**
+	 * Function to be called by the owner if an action does report data
+	 *
+	 * @param reportTo MessageQueueId_t to report the action completion message to
+	 * @param replyId ID of the executed command
+	 * @param data Pointer to the data
+	 * @return Returns RETURN_OK if successful, otherwise failure code
+	 */
+	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data, bool hideSender = false);
+	/**
+	 * Function to setup the MessageQueueIF* of the helper. Can be used to set the messageQueueIF* if
+	 * message queue is unavailable at construction and initialize but must be setup before first call of other functions.
+	 * @param queue Queue to be used by the helper
+	 */
+	void setQueueToUse(MessageQueueIF *queue);
+protected:
+	static const uint8_t STEP_OFFSET = 1;//!< Increase of value of this per step
+	HasActionsIF* owner;//!< Pointer to the owner
+	MessageQueueIF* queueToUse;//!< Queue to be used as response sender, has to be set with
+	StorageManagerIF* ipcStore;//!< Pointer to an IPC Store, initialized during construction or initialize(MessageQueueIF* queueToUse_) or with setQueueToUse(MessageQueueIF *queue)
+	/**
+	 *Internal function called by handleActionMessage(CommandMessage* command)
+	 *
+	 * @param commandedBy MessageQueueID of Commander
+	 * @param actionId ID of action to be done
+	 * @param dataAddress Address of additional data in IPC Store
+	 */
+	virtual void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
+	/**
+	 *
+	 */
+	virtual void resetHelper();
+};
+
+#endif /* ACTIONHELPER_H_ */
diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index 5743cc740..b0bcabaa0 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -1,79 +1,79 @@
-#include "../action/ActionMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-
-ActionMessage::ActionMessage() {
-}
-
-ActionMessage::~ActionMessage() {
-}
-
-void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
-		store_address_t parameters) {
-	message->setCommand(EXECUTE_ACTION);
-	message->setParameter(fid);
-	message->setParameter2(parameters.raw);
-}
-
-ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
-	return ActionId_t(message->getParameter());
-}
-
-store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-void ActionMessage::setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
-		ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		message->setCommand(STEP_SUCCESS);
-	} else {
-		message->setCommand(STEP_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2((step << 16) + result);
-}
-
-uint8_t ActionMessage::getStep(const CommandMessage* message) {
-	return uint8_t((message->getParameter2() >> 16) & 0xFF);
-}
-
-ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
-	return message->getParameter2() & 0xFFFF;
-}
-
-void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
-		store_address_t data) {
-	message->setCommand(DATA_REPLY);
-	message->setParameter(actionId);
-	message->setParameter2(data.raw);
-}
-
-void ActionMessage::setCompletionReply(CommandMessage* message,
-		ActionId_t fid, ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		message->setCommand(COMPLETION_SUCCESS);
-	} else {
-		message->setCommand(COMPLETION_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2(result);
-}
-
-void ActionMessage::clear(CommandMessage* message) {
-	switch(message->getCommand()) {
-	case EXECUTE_ACTION:
-	case DATA_REPLY: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-}
+#include "ActionMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+ActionMessage::ActionMessage() {
+}
+
+ActionMessage::~ActionMessage() {
+}
+
+void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
+		store_address_t parameters) {
+	message->setCommand(EXECUTE_ACTION);
+	message->setParameter(fid);
+	message->setParameter2(parameters.raw);
+}
+
+ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
+	return ActionId_t(message->getParameter());
+}
+
+store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+void ActionMessage::setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
+		ReturnValue_t result) {
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		message->setCommand(STEP_SUCCESS);
+	} else {
+		message->setCommand(STEP_FAILED);
+	}
+	message->setParameter(fid);
+	message->setParameter2((step << 16) + result);
+}
+
+uint8_t ActionMessage::getStep(const CommandMessage* message) {
+	return uint8_t((message->getParameter2() >> 16) & 0xFF);
+}
+
+ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
+	return message->getParameter2() & 0xFFFF;
+}
+
+void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
+		store_address_t data) {
+	message->setCommand(DATA_REPLY);
+	message->setParameter(actionId);
+	message->setParameter2(data.raw);
+}
+
+void ActionMessage::setCompletionReply(CommandMessage* message,
+		ActionId_t fid, ReturnValue_t result) {
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		message->setCommand(COMPLETION_SUCCESS);
+	} else {
+		message->setCommand(COMPLETION_FAILED);
+	}
+	message->setParameter(fid);
+	message->setParameter2(result);
+}
+
+void ActionMessage::clear(CommandMessage* message) {
+	switch(message->getCommand()) {
+	case EXECUTE_ACTION:
+	case DATA_REPLY: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(message));
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index aae44e162..0a718aab6 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -1,32 +1,32 @@
-#ifndef ACTIONMESSAGE_H_
-#define ACTIONMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-typedef uint32_t ActionId_t;
-
-class ActionMessage {
-private:
-	ActionMessage();
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::ACTION;
-	static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
-	static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
-	static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
-	static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
-	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
-	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
-	virtual ~ActionMessage();
-	static void setCommand(CommandMessage* message, ActionId_t fid, store_address_t parameters);
-	static ActionId_t getActionId(const CommandMessage* message );
-	static store_address_t getStoreId(const CommandMessage* message );
-	static void setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static uint8_t getStep(const CommandMessage* message );
-	static ReturnValue_t getReturnCode(const CommandMessage* message );
-	static void setDataReply(CommandMessage* message, ActionId_t actionId, store_address_t data);
-	static void setCompletionReply(CommandMessage* message, ActionId_t fid, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static void clear(CommandMessage* message);
-};
-
-#endif /* ACTIONMESSAGE_H_ */
+#ifndef ACTIONMESSAGE_H_
+#define ACTIONMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+typedef uint32_t ActionId_t;
+
+class ActionMessage {
+private:
+	ActionMessage();
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::ACTION;
+	static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
+	static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
+	static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
+	static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
+	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
+	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
+	virtual ~ActionMessage();
+	static void setCommand(CommandMessage* message, ActionId_t fid, store_address_t parameters);
+	static ActionId_t getActionId(const CommandMessage* message );
+	static store_address_t getStoreId(const CommandMessage* message );
+	static void setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	static uint8_t getStep(const CommandMessage* message );
+	static ReturnValue_t getReturnCode(const CommandMessage* message );
+	static void setDataReply(CommandMessage* message, ActionId_t actionId, store_address_t data);
+	static void setCompletionReply(CommandMessage* message, ActionId_t fid, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	static void clear(CommandMessage* message);
+};
+
+#endif /* ACTIONMESSAGE_H_ */
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index d8d506aa8..4e88f3c34 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -1,127 +1,127 @@
-#include "../action/ActionMessage.h"
-#include "../action/CommandActionHelper.h"
-#include "../action/CommandsActionsIF.h"
-#include "../action/HasActionsIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
-		owner(setOwner), queueToUse(NULL), ipcStore(
-		NULL), commandCount(0), lastTarget(0) {
-}
-
-CommandActionHelper::~CommandActionHelper() {
-}
-
-ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, SerializeIF *data) {
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	uint8_t *storePointer;
-	size_t maxSize = data->getSerializedSize();
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
-			&storePointer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	size_t size = 0;
-	result = data->serialize(&storePointer, &size, maxSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
-}
-
-ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, const uint8_t *data, uint32_t size) {
-//	if (commandCount != 0) {
-//		return CommandsFunctionsIF::ALREADY_COMMANDING;
-//	}
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	ReturnValue_t result = ipcStore->addData(&storeId, data, size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
-}
-
-ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
-		ActionId_t actionId, store_address_t storeId) {
-	CommandMessage command;
-	ActionMessage::setCommand(&command, actionId, storeId);
-	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeId);
-	}
-	lastTarget = queueId;
-	commandCount++;
-	return result;
-}
-
-ReturnValue_t CommandActionHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	queueToUse = owner->getCommandQueuePtr();
-	if (queueToUse == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
-	if (reply->getSender() != lastTarget) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	switch (reply->getCommand()) {
-	case ActionMessage::COMPLETION_SUCCESS:
-		commandCount--;
-		owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::COMPLETION_FAILED:
-		commandCount--;
-		owner->completionFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_SUCCESS:
-		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_FAILED:
-		commandCount--;
-		owner->stepFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::DATA_REPLY:
-		extractDataForOwner(ActionMessage::getActionId(reply),
-				ActionMessage::getStoreId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t CommandActionHelper::getCommandCount() const {
-	return commandCount;
-}
-
-void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-	const uint8_t * data = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	owner->dataReceived(actionId, data, size);
-	ipcStore->deleteData(storeId);
-}
+#include "ActionMessage.h"
+#include "CommandActionHelper.h"
+#include "CommandsActionsIF.h"
+#include "HasActionsIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
+		owner(setOwner), queueToUse(NULL), ipcStore(
+		NULL), commandCount(0), lastTarget(0) {
+}
+
+CommandActionHelper::~CommandActionHelper() {
+}
+
+ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
+		ActionId_t actionId, SerializeIF *data) {
+	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+	if (receiver == NULL) {
+		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+	}
+	store_address_t storeId;
+	uint8_t *storePointer;
+	size_t maxSize = data->getSerializedSize();
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
+			&storePointer);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	size_t size = 0;
+	result = data->serialize(&storePointer, &size, maxSize,
+			SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+}
+
+ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
+		ActionId_t actionId, const uint8_t *data, uint32_t size) {
+//	if (commandCount != 0) {
+//		return CommandsFunctionsIF::ALREADY_COMMANDING;
+//	}
+	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+	if (receiver == NULL) {
+		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+	}
+	store_address_t storeId;
+	ReturnValue_t result = ipcStore->addData(&storeId, data, size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+}
+
+ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
+		ActionId_t actionId, store_address_t storeId) {
+	CommandMessage command;
+	ActionMessage::setCommand(&command, actionId, storeId);
+	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		ipcStore->deleteData(storeId);
+	}
+	lastTarget = queueId;
+	commandCount++;
+	return result;
+}
+
+ReturnValue_t CommandActionHelper::initialize() {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	queueToUse = owner->getCommandQueuePtr();
+	if (queueToUse == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
+	if (reply->getSender() != lastTarget) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	switch (reply->getCommand()) {
+	case ActionMessage::COMPLETION_SUCCESS:
+		commandCount--;
+		owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	case ActionMessage::COMPLETION_FAILED:
+		commandCount--;
+		owner->completionFailedReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getReturnCode(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	case ActionMessage::STEP_SUCCESS:
+		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getStep(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	case ActionMessage::STEP_FAILED:
+		commandCount--;
+		owner->stepFailedReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getStep(reply),
+				ActionMessage::getReturnCode(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	case ActionMessage::DATA_REPLY:
+		extractDataForOwner(ActionMessage::getActionId(reply),
+				ActionMessage::getStoreId(reply));
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t CommandActionHelper::getCommandCount() const {
+	return commandCount;
+}
+
+void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
+	const uint8_t * data = NULL;
+	size_t size = 0;
+	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	owner->dataReceived(actionId, data, size);
+	ipcStore->deleteData(storeId);
+}
diff --git a/action/CommandActionHelper.h b/action/CommandActionHelper.h
index edbcaaddd..cfed8c941 100644
--- a/action/CommandActionHelper.h
+++ b/action/CommandActionHelper.h
@@ -1,36 +1,36 @@
-#ifndef COMMANDACTIONHELPER_H_
-#define COMMANDACTIONHELPER_H_
-
-#include "../action/ActionMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerializeIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../ipc/MessageQueueIF.h"
-
-class CommandsActionsIF;
-
-class CommandActionHelper {
-	friend class CommandsActionsIF;
-public:
-	CommandActionHelper(CommandsActionsIF* owner);
-	virtual ~CommandActionHelper();
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, const uint8_t* data, uint32_t size);
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, SerializeIF* data);
-	ReturnValue_t initialize();
-	ReturnValue_t handleReply(CommandMessage* reply);
-	uint8_t getCommandCount() const;
-private:
-	CommandsActionsIF* owner;
-	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore;
-	uint8_t commandCount;
-	MessageQueueId_t lastTarget;
-	void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
-	ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
-			store_address_t storeId);
-};
-
-#endif /* COMMANDACTIONHELPER_H_ */
+#ifndef COMMANDACTIONHELPER_H_
+#define COMMANDACTIONHELPER_H_
+
+#include "ActionMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class CommandsActionsIF;
+
+class CommandActionHelper {
+	friend class CommandsActionsIF;
+public:
+	CommandActionHelper(CommandsActionsIF* owner);
+	virtual ~CommandActionHelper();
+	ReturnValue_t commandAction(object_id_t commandTo,
+			ActionId_t actionId, const uint8_t* data, uint32_t size);
+	ReturnValue_t commandAction(object_id_t commandTo,
+			ActionId_t actionId, SerializeIF* data);
+	ReturnValue_t initialize();
+	ReturnValue_t handleReply(CommandMessage* reply);
+	uint8_t getCommandCount() const;
+private:
+	CommandsActionsIF* owner;
+	MessageQueueIF* queueToUse;
+	StorageManagerIF* ipcStore;
+	uint8_t commandCount;
+	MessageQueueId_t lastTarget;
+	void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
+	ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
+			store_address_t storeId);
+};
+
+#endif /* COMMANDACTIONHELPER_H_ */
diff --git a/action/CommandsActionsIF.h b/action/CommandsActionsIF.h
index bead31406..3d04015d1 100644
--- a/action/CommandsActionsIF.h
+++ b/action/CommandsActionsIF.h
@@ -1,34 +1,34 @@
-#ifndef COMMANDSACTIONSIF_H_
-#define COMMANDSACTIONSIF_H_
-
-#include "../action/CommandActionHelper.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueIF.h"
-
-/**
- * Interface to separate commanding actions of other objects.
- * In next iteration, IF should be shortened to three calls:
- * - dataReceived(data)
- * - successReceived(id, step)
- * - failureReceived(id, step, cause)
- * or even
- * - replyReceived(id, step, cause) (if cause == OK, it's a success).
- */
-class CommandsActionsIF {
-	friend class CommandActionHelper;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
-	static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
-	virtual ~CommandsActionsIF() {}
-	virtual MessageQueueIF* getCommandQueuePtr() = 0;
-protected:
-	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
-	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) = 0;
-	virtual void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) = 0;
-	virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
-	virtual void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) = 0;
-};
-
-
-#endif /* COMMANDSACTIONSIF_H_ */
+#ifndef COMMANDSACTIONSIF_H_
+#define COMMANDSACTIONSIF_H_
+
+#include "CommandActionHelper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+/**
+ * Interface to separate commanding actions of other objects.
+ * In next iteration, IF should be shortened to three calls:
+ * - dataReceived(data)
+ * - successReceived(id, step)
+ * - failureReceived(id, step, cause)
+ * or even
+ * - replyReceived(id, step, cause) (if cause == OK, it's a success).
+ */
+class CommandsActionsIF {
+	friend class CommandActionHelper;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
+	static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
+	virtual ~CommandsActionsIF() {}
+	virtual MessageQueueIF* getCommandQueuePtr() = 0;
+protected:
+	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
+	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) = 0;
+	virtual void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) = 0;
+	virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
+	virtual void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) = 0;
+};
+
+
+#endif /* COMMANDSACTIONSIF_H_ */
diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 283664a3a..886d08377 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -1,60 +1,60 @@
-#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
-#define FRAMEWORK_ACTION_HASACTIONSIF_H_
-
-#include "../action/ActionHelper.h"
-#include "../action/ActionMessage.h"
-#include "../action/SimpleActionHelper.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueIF.h"
-/**
- * @brief
- * Interface for component which uses actions
- *
- * @details
- * This interface is used to execute actions in the component. Actions, in the
- * sense of this interface, are activities with a well-defined beginning and
- * end in time. They may adjust sub-states of components, but are not supposed
- * to change the main mode of operation, which is handled with the HasModesIF
- * described below.
- *
- * The HasActionsIF allows components to define such actions and make them
- * available for other components to use. Implementing the interface is
- * straightforward: There’s a single executeAction call, which provides an
- * identifier for the action to execute, as well as arbitrary parameters for
- * input.
- * Aside from direct, software-based actions, it is used in device handler
- * components as an interface to forward commands to devices.
- * Implementing components of the interface are supposed to check identifier
- * (ID) and parameters and immediately start execution of the action.
- * It is, however, not required to immediately finish execution.
- * Instead, this may be deferred to a later point in time, at which the
- * component needs to inform the caller about finished or failed execution.
- *
- * @ingroup interfaces
- */
-class HasActionsIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
-	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
-	virtual ~HasActionsIF() { }
-	/**
-	 * Function to get the MessageQueueId_t of the implementing object
-	 * @return MessageQueueId_t of the object
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	/**
-	 * Execute or initialize the execution of a certain function.
-	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to
-	 * be done. When needing more steps, return RETURN_OK and issue steps and
-	 * completion manually.
-	 * One "step failed" or completion report must be issued!
-	 */
-	virtual ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
-};
-
-
-#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */
+#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
+#define FRAMEWORK_ACTION_HASACTIONSIF_H_
+
+#include "ActionHelper.h"
+#include "ActionMessage.h"
+#include "SimpleActionHelper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+/**
+ * @brief
+ * Interface for component which uses actions
+ *
+ * @details
+ * This interface is used to execute actions in the component. Actions, in the
+ * sense of this interface, are activities with a well-defined beginning and
+ * end in time. They may adjust sub-states of components, but are not supposed
+ * to change the main mode of operation, which is handled with the HasModesIF
+ * described below.
+ *
+ * The HasActionsIF allows components to define such actions and make them
+ * available for other components to use. Implementing the interface is
+ * straightforward: There’s a single executeAction call, which provides an
+ * identifier for the action to execute, as well as arbitrary parameters for
+ * input.
+ * Aside from direct, software-based actions, it is used in device handler
+ * components as an interface to forward commands to devices.
+ * Implementing components of the interface are supposed to check identifier
+ * (ID) and parameters and immediately start execution of the action.
+ * It is, however, not required to immediately finish execution.
+ * Instead, this may be deferred to a later point in time, at which the
+ * component needs to inform the caller about finished or failed execution.
+ *
+ * @ingroup interfaces
+ */
+class HasActionsIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
+	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
+	virtual ~HasActionsIF() { }
+	/**
+	 * Function to get the MessageQueueId_t of the implementing object
+	 * @return MessageQueueId_t of the object
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	/**
+	 * Execute or initialize the execution of a certain function.
+	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to
+	 * be done. When needing more steps, return RETURN_OK and issue steps and
+	 * completion manually.
+	 * One "step failed" or completion report must be issued!
+	 */
+	virtual ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
+};
+
+
+#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index 83ce3c854..d79a3c977 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -1,74 +1,74 @@
-#include "../action/HasActionsIF.h"
-#include "../action/SimpleActionHelper.h"
-SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
-		MessageQueueIF* useThisQueue) :
-		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
-				0), lastAction(0), stepCount(0) {
-}
-
-SimpleActionHelper::~SimpleActionHelper() {
-}
-
-void SimpleActionHelper::step(ReturnValue_t result) {
-	//STEP_OFFESET is subtracted to compensate for adding offset in base method, which is not necessary here.
-	ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
-			result);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		resetHelper();
-	}
-}
-
-void SimpleActionHelper::finish(ReturnValue_t result) {
-	ActionHelper::finish(lastCommander, lastAction, result);
-	resetHelper();
-}
-
-ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
-	return ActionHelper::reportData(lastCommander, lastAction, data);
-}
-
-void SimpleActionHelper::resetHelper() {
-	stepCount = 0;
-	isExecuting = false;
-	lastAction = 0;
-	lastCommander = 0;
-}
-
-void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
-		ActionId_t actionId, store_address_t dataAddress) {
-	CommandMessage reply;
-	if (isExecuting) {
-		ipcStore->deleteData(dataAddress);
-		ActionMessage::setStepReply(&reply, actionId, 0,
-				HasActionsIF::IS_BUSY);
-		queueToUse->sendMessage(commandedBy, &reply);
-	}
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	lastCommander = commandedBy;
-	lastAction = actionId;
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	switch (result) {
-	case HasReturnvaluesIF::RETURN_OK:
-		isExecuting = true;
-		stepCount++;
-		break;
-	case HasActionsIF::EXECUTION_FINISHED:
-		ActionMessage::setCompletionReply(&reply, actionId,
-				HasReturnvaluesIF::RETURN_OK);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	default:
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	}
-
-}
+#include "HasActionsIF.h"
+#include "SimpleActionHelper.h"
+SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
+		MessageQueueIF* useThisQueue) :
+		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
+				0), lastAction(0), stepCount(0) {
+}
+
+SimpleActionHelper::~SimpleActionHelper() {
+}
+
+void SimpleActionHelper::step(ReturnValue_t result) {
+	//STEP_OFFESET is subtracted to compensate for adding offset in base method, which is not necessary here.
+	ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
+			result);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		resetHelper();
+	}
+}
+
+void SimpleActionHelper::finish(ReturnValue_t result) {
+	ActionHelper::finish(lastCommander, lastAction, result);
+	resetHelper();
+}
+
+ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
+	return ActionHelper::reportData(lastCommander, lastAction, data);
+}
+
+void SimpleActionHelper::resetHelper() {
+	stepCount = 0;
+	isExecuting = false;
+	lastAction = 0;
+	lastCommander = 0;
+}
+
+void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
+		ActionId_t actionId, store_address_t dataAddress) {
+	CommandMessage reply;
+	if (isExecuting) {
+		ipcStore->deleteData(dataAddress);
+		ActionMessage::setStepReply(&reply, actionId, 0,
+				HasActionsIF::IS_BUSY);
+		queueToUse->sendMessage(commandedBy, &reply);
+	}
+	const uint8_t* dataPtr = NULL;
+	size_t size = 0;
+	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		ActionMessage::setStepReply(&reply, actionId, 0, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+		return;
+	}
+	lastCommander = commandedBy;
+	lastAction = actionId;
+	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+	ipcStore->deleteData(dataAddress);
+	switch (result) {
+	case HasReturnvaluesIF::RETURN_OK:
+		isExecuting = true;
+		stepCount++;
+		break;
+	case HasActionsIF::EXECUTION_FINISHED:
+		ActionMessage::setCompletionReply(&reply, actionId,
+				HasReturnvaluesIF::RETURN_OK);
+		queueToUse->sendMessage(commandedBy, &reply);
+		break;
+	default:
+		ActionMessage::setStepReply(&reply, actionId, 0, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+		break;
+	}
+
+}
diff --git a/action/SimpleActionHelper.h b/action/SimpleActionHelper.h
index 05025f827..1329b5fb5 100644
--- a/action/SimpleActionHelper.h
+++ b/action/SimpleActionHelper.h
@@ -1,24 +1,24 @@
-#ifndef SIMPLEACTIONHELPER_H_
-#define SIMPLEACTIONHELPER_H_
-
-#include "../action/ActionHelper.h"
-
-class SimpleActionHelper: public ActionHelper {
-public:
-	SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-	virtual ~SimpleActionHelper();
-	void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	ReturnValue_t reportData(SerializeIF* data);
-
-protected:
-	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
-	virtual  void resetHelper();
-private:
-	bool isExecuting;
-	MessageQueueId_t lastCommander;
-	ActionId_t lastAction;
-	uint8_t stepCount;
-};
-
-#endif /* SIMPLEACTIONHELPER_H_ */
+#ifndef SIMPLEACTIONHELPER_H_
+#define SIMPLEACTIONHELPER_H_
+
+#include "ActionHelper.h"
+
+class SimpleActionHelper: public ActionHelper {
+public:
+	SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+	virtual ~SimpleActionHelper();
+	void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	ReturnValue_t reportData(SerializeIF* data);
+
+protected:
+	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
+	virtual  void resetHelper();
+private:
+	bool isExecuting;
+	MessageQueueId_t lastCommander;
+	ActionId_t lastAction;
+	uint8_t stepCount;
+};
+
+#endif /* SIMPLEACTIONHELPER_H_ */

From 5ce954672b023ea804d7915ac3031b284ad10091 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:40:21 +0200
Subject: [PATCH 0676/1774] taken over coordinates  from upstream

---
 coordinates/CoordinateTransformations.cpp | 454 ++++++++++-----------
 coordinates/CoordinateTransformations.h   |  68 ++--
 coordinates/Jgm3Model.h                   | 360 ++++++++---------
 coordinates/Sgp4Propagator.cpp            | 456 +++++++++++-----------
 coordinates/Sgp4Propagator.h              |  88 ++---
 5 files changed, 713 insertions(+), 713 deletions(-)

diff --git a/coordinates/CoordinateTransformations.cpp b/coordinates/CoordinateTransformations.cpp
index df9b3caca..4e2debbe8 100644
--- a/coordinates/CoordinateTransformations.cpp
+++ b/coordinates/CoordinateTransformations.cpp
@@ -1,227 +1,227 @@
-#include "../coordinates/CoordinateTransformations.h"
-#include "../globalfunctions/constants.h"
-#include "../globalfunctions/math/MatrixOperations.h"
-#include "../globalfunctions/math/VectorOperations.h"
-#include <stddef.h>
-#include <cmath>
-
-
-void CoordinateTransformations::positionEcfToEci(const double* ecfPosition,
-		double* eciPosition, timeval *timeUTC) {
-	ecfToEci(ecfPosition, eciPosition, NULL, timeUTC);
-
-}
-
-void CoordinateTransformations::velocityEcfToEci(const double* ecfVelocity,
-		const double* ecfPosition, double* eciVelocity, timeval *timeUTC) {
-	ecfToEci(ecfVelocity, eciVelocity, ecfPosition, timeUTC);
-}
-
-void CoordinateTransformations::positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC){
-	eciToEcf(eciCoordinates,ecfCoordinates,NULL,timeUTC);
-};
-
-void CoordinateTransformations::velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC){
-	eciToEcf(eciVelocity,ecfVelocity,eciPosition,timeUTC);
-}
-
-double CoordinateTransformations::getEarthRotationAngle(timeval timeUTC) {
-
-	double jD2000UTC;
-	Clock::convertTimevalToJD2000(timeUTC, &jD2000UTC);
-
-	double TTt2000 = getJuleanCenturiesTT(timeUTC);
-
-	double theta = 2 * Math::PI
-			* (0.779057273264 + 1.00273781191135448 * jD2000UTC);
-
-	//Correct theta according to IAU 2000 precession-nutation model
-	theta = theta + 7.03270725817493E-008 + 0.0223603701 * TTt2000
-			+ 6.77128219501896E-006 * TTt2000 * TTt2000
-			+ 4.5300990362875E-010 * TTt2000 * TTt2000 * TTt2000
-			+ 9.12419347848147E-011 * TTt2000 * TTt2000 * TTt2000 * TTt2000;
-	return theta;
-}
-
-void CoordinateTransformations::getEarthRotationMatrix(timeval timeUTC,
-		double matrix[][3]) {
-	double theta = getEarthRotationAngle(timeUTC);
-
-	matrix[0][0] = cos(theta);
-	matrix[0][1] = sin(theta);
-	matrix[0][2] = 0;
-	matrix[1][0] = -sin(theta);
-	matrix[1][1] = cos(theta);
-	matrix[1][2] = 0;
-	matrix[2][0] = 0;
-	matrix[2][1] = 0;
-	matrix[2][2] = 1;
-}
-
-void CoordinateTransformations::ecfToEci(const double* ecfCoordinates,
-		double* eciCoordinates,
-		const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin) {
-
-	timeval timeUTC;
-	if (timeUTCin != NULL) {
-		timeUTC = *timeUTCin;
-	} else {
-		Clock::getClock_timeval(&timeUTC);
-	}
-
-	double Tfi[3][3];
-	double Tif[3][3];
-	getTransMatrixECITOECF(timeUTC,Tfi);
-
-	MatrixOperations<double>::transpose(Tfi[0], Tif[0], 3);
-
-	MatrixOperations<double>::multiply(Tif[0], ecfCoordinates, eciCoordinates,
-			3, 3, 1);
-
-
-
-
-	if (ecfPositionIfCoordinatesAreVelocity != NULL) {
-
-		double Tdotfi[3][3];
-		double Tdotif[3][3];
-		double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
-				{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
-
-		MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
-				3);
-
-		MatrixOperations<double>::transpose(Tdotfi[0], Tdotif[0], 3);
-
-		double velocityCorrection[3];
-
-		MatrixOperations<double>::multiply(Tdotif[0],
-				ecfPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
-				1);
-
-		VectorOperations<double>::add(velocityCorrection, eciCoordinates,
-				eciCoordinates, 3);
-	}
-}
-
-double CoordinateTransformations::getJuleanCenturiesTT(timeval timeUTC) {
-	timeval timeTT;
-	Clock::convertUTCToTT(timeUTC, &timeTT);
-	double jD2000TT;
-	Clock::convertTimevalToJD2000(timeTT, &jD2000TT);
-
-	return jD2000TT / 36525.;
-}
-
-void CoordinateTransformations::eciToEcf(const double* eciCoordinates,
-		double* ecfCoordinates,
-		const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin){
-	timeval timeUTC;
-	if (timeUTCin != NULL) {
-		timeUTC = *timeUTCin;
-	}else{
-		Clock::getClock_timeval(&timeUTC);
-	}
-
-	double Tfi[3][3];
-
-	getTransMatrixECITOECF(timeUTC,Tfi);
-
-	MatrixOperations<double>::multiply(Tfi[0],eciCoordinates,ecfCoordinates,3,3,1);
-
-	if (eciPositionIfCoordinatesAreVelocity != NULL) {
-
-			double Tdotfi[3][3];
-			double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
-					{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
-
-			MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
-					3);
-
-			double velocityCorrection[3];
-
-			MatrixOperations<double>::multiply(Tdotfi[0],
-					eciPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
-					1);
-
-			VectorOperations<double>::add(ecfCoordinates, velocityCorrection,
-					ecfCoordinates, 3);
-		}
-};
-
-void CoordinateTransformations::getTransMatrixECITOECF(timeval timeUTC,double Tfi[3][3]){
-	double TTt2000 = getJuleanCenturiesTT(timeUTC);
-
-		//////////////////////////////////////////////////////////
-		// Calculate Precession Matrix
-
-		double zeta = 0.0111808609 * TTt2000
-				+ 1.46355554053347E-006 * TTt2000 * TTt2000
-				+ 8.72567663260943E-008 * TTt2000 * TTt2000 * TTt2000;
-		double theta_p = 0.0097171735 * TTt2000
-				- 2.06845757045384E-006 * TTt2000 * TTt2000
-				- 2.02812107218552E-007 * TTt2000 * TTt2000 * TTt2000;
-		double z = zeta + 3.8436028638364E-006 * TTt2000 * TTt2000
-				+ 0.000000001 * TTt2000 * TTt2000 * TTt2000;
-
-		double mPrecession[3][3];
-
-		mPrecession[0][0] = -sin(z) * sin(zeta) + cos(z) * cos(theta_p) * cos(zeta);
-		mPrecession[1][0] = cos(z) * sin(zeta) + sin(z) * cos(theta_p) * cos(zeta);
-		mPrecession[2][0] = sin(theta_p) * cos(zeta);
-
-		mPrecession[0][1] = -sin(z) * cos(zeta) - cos(z) * cos(theta_p) * sin(zeta);
-		mPrecession[1][1] = cos(z) * cos(zeta) - sin(z) * cos(theta_p) * sin(zeta);
-		mPrecession[2][1] = -sin(theta_p) * sin(zeta);
-
-		mPrecession[0][2] = -cos(z) * sin(theta_p);
-		mPrecession[1][2] = -sin(z) * sin(theta_p);
-		mPrecession[2][2] = cos(theta_p);
-
-		//////////////////////////////////////////////////////////
-		// Calculate Nutation Matrix
-
-		double omega_moon = 2.1824386244 - 33.7570459338 * TTt2000
-				+ 3.61428599267159E-005 * TTt2000 * TTt2000
-				+ 3.87850944887629E-008 * TTt2000 * TTt2000 * TTt2000;
-
-		double deltaPsi = -0.000083388 * sin(omega_moon);
-		double deltaEpsilon = 4.46174030725106E-005 * cos(omega_moon);
-
-		double epsilon = 0.4090928042 - 0.0002269655 * TTt2000
-				- 2.86040071854626E-009 * TTt2000 * TTt2000
-				+ 8.78967203851589E-009 * TTt2000 * TTt2000 * TTt2000;
-
-
-		double mNutation[3][3];
-
-		mNutation[0][0] = cos(deltaPsi);
-		mNutation[1][0] = cos(epsilon + deltaEpsilon) * sin(deltaPsi);
-		mNutation[2][0] = sin(epsilon + deltaEpsilon) * sin(deltaPsi);
-
-		mNutation[0][1] = -cos(epsilon) * sin(deltaPsi);
-		mNutation[1][1] = cos(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
-				+ sin(epsilon) * sin(epsilon + deltaEpsilon);
-		mNutation[2][1] = cos(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
-				- sin(epsilon) * cos(epsilon + deltaEpsilon);
-
-		mNutation[0][2] = -sin(epsilon) * sin(deltaPsi);
-		mNutation[1][2] = sin(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
-				- cos(epsilon) * sin(epsilon + deltaEpsilon);
-		mNutation[2][2] = sin(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
-				+ cos(epsilon) * cos(epsilon + deltaEpsilon);
-
-		//////////////////////////////////////////////////////////
-		// Calculate Earth rotation matrix
-		//calculate theta
-
-		double mTheta[3][3];
-		double Ttemp[3][3];
-		getEarthRotationMatrix(timeUTC, mTheta);
-
-		//polar motion is neglected
-		MatrixOperations<double>::multiply(mNutation[0], mPrecession[0], Ttemp[0],
-				3, 3, 3);
-
-		MatrixOperations<double>::multiply(mTheta[0], Ttemp[0], Tfi[0], 3, 3, 3);
-};
+#include "CoordinateTransformations.h"
+#include "../globalfunctions/constants.h"
+#include "../globalfunctions/math/MatrixOperations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include <stddef.h>
+#include <cmath>
+
+
+void CoordinateTransformations::positionEcfToEci(const double* ecfPosition,
+		double* eciPosition, timeval *timeUTC) {
+	ecfToEci(ecfPosition, eciPosition, NULL, timeUTC);
+
+}
+
+void CoordinateTransformations::velocityEcfToEci(const double* ecfVelocity,
+		const double* ecfPosition, double* eciVelocity, timeval *timeUTC) {
+	ecfToEci(ecfVelocity, eciVelocity, ecfPosition, timeUTC);
+}
+
+void CoordinateTransformations::positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC){
+	eciToEcf(eciCoordinates,ecfCoordinates,NULL,timeUTC);
+};
+
+void CoordinateTransformations::velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC){
+	eciToEcf(eciVelocity,ecfVelocity,eciPosition,timeUTC);
+}
+
+double CoordinateTransformations::getEarthRotationAngle(timeval timeUTC) {
+
+	double jD2000UTC;
+	Clock::convertTimevalToJD2000(timeUTC, &jD2000UTC);
+
+	double TTt2000 = getJuleanCenturiesTT(timeUTC);
+
+	double theta = 2 * Math::PI
+			* (0.779057273264 + 1.00273781191135448 * jD2000UTC);
+
+	//Correct theta according to IAU 2000 precession-nutation model
+	theta = theta + 7.03270725817493E-008 + 0.0223603701 * TTt2000
+			+ 6.77128219501896E-006 * TTt2000 * TTt2000
+			+ 4.5300990362875E-010 * TTt2000 * TTt2000 * TTt2000
+			+ 9.12419347848147E-011 * TTt2000 * TTt2000 * TTt2000 * TTt2000;
+	return theta;
+}
+
+void CoordinateTransformations::getEarthRotationMatrix(timeval timeUTC,
+		double matrix[][3]) {
+	double theta = getEarthRotationAngle(timeUTC);
+
+	matrix[0][0] = cos(theta);
+	matrix[0][1] = sin(theta);
+	matrix[0][2] = 0;
+	matrix[1][0] = -sin(theta);
+	matrix[1][1] = cos(theta);
+	matrix[1][2] = 0;
+	matrix[2][0] = 0;
+	matrix[2][1] = 0;
+	matrix[2][2] = 1;
+}
+
+void CoordinateTransformations::ecfToEci(const double* ecfCoordinates,
+		double* eciCoordinates,
+		const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin) {
+
+	timeval timeUTC;
+	if (timeUTCin != NULL) {
+		timeUTC = *timeUTCin;
+	} else {
+		Clock::getClock_timeval(&timeUTC);
+	}
+
+	double Tfi[3][3];
+	double Tif[3][3];
+	getTransMatrixECITOECF(timeUTC,Tfi);
+
+	MatrixOperations<double>::transpose(Tfi[0], Tif[0], 3);
+
+	MatrixOperations<double>::multiply(Tif[0], ecfCoordinates, eciCoordinates,
+			3, 3, 1);
+
+
+
+
+	if (ecfPositionIfCoordinatesAreVelocity != NULL) {
+
+		double Tdotfi[3][3];
+		double Tdotif[3][3];
+		double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
+				{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
+
+		MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
+				3);
+
+		MatrixOperations<double>::transpose(Tdotfi[0], Tdotif[0], 3);
+
+		double velocityCorrection[3];
+
+		MatrixOperations<double>::multiply(Tdotif[0],
+				ecfPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
+				1);
+
+		VectorOperations<double>::add(velocityCorrection, eciCoordinates,
+				eciCoordinates, 3);
+	}
+}
+
+double CoordinateTransformations::getJuleanCenturiesTT(timeval timeUTC) {
+	timeval timeTT;
+	Clock::convertUTCToTT(timeUTC, &timeTT);
+	double jD2000TT;
+	Clock::convertTimevalToJD2000(timeTT, &jD2000TT);
+
+	return jD2000TT / 36525.;
+}
+
+void CoordinateTransformations::eciToEcf(const double* eciCoordinates,
+		double* ecfCoordinates,
+		const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin){
+	timeval timeUTC;
+	if (timeUTCin != NULL) {
+		timeUTC = *timeUTCin;
+	}else{
+		Clock::getClock_timeval(&timeUTC);
+	}
+
+	double Tfi[3][3];
+
+	getTransMatrixECITOECF(timeUTC,Tfi);
+
+	MatrixOperations<double>::multiply(Tfi[0],eciCoordinates,ecfCoordinates,3,3,1);
+
+	if (eciPositionIfCoordinatesAreVelocity != NULL) {
+
+			double Tdotfi[3][3];
+			double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
+					{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
+
+			MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
+					3);
+
+			double velocityCorrection[3];
+
+			MatrixOperations<double>::multiply(Tdotfi[0],
+					eciPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
+					1);
+
+			VectorOperations<double>::add(ecfCoordinates, velocityCorrection,
+					ecfCoordinates, 3);
+		}
+};
+
+void CoordinateTransformations::getTransMatrixECITOECF(timeval timeUTC,double Tfi[3][3]){
+	double TTt2000 = getJuleanCenturiesTT(timeUTC);
+
+		//////////////////////////////////////////////////////////
+		// Calculate Precession Matrix
+
+		double zeta = 0.0111808609 * TTt2000
+				+ 1.46355554053347E-006 * TTt2000 * TTt2000
+				+ 8.72567663260943E-008 * TTt2000 * TTt2000 * TTt2000;
+		double theta_p = 0.0097171735 * TTt2000
+				- 2.06845757045384E-006 * TTt2000 * TTt2000
+				- 2.02812107218552E-007 * TTt2000 * TTt2000 * TTt2000;
+		double z = zeta + 3.8436028638364E-006 * TTt2000 * TTt2000
+				+ 0.000000001 * TTt2000 * TTt2000 * TTt2000;
+
+		double mPrecession[3][3];
+
+		mPrecession[0][0] = -sin(z) * sin(zeta) + cos(z) * cos(theta_p) * cos(zeta);
+		mPrecession[1][0] = cos(z) * sin(zeta) + sin(z) * cos(theta_p) * cos(zeta);
+		mPrecession[2][0] = sin(theta_p) * cos(zeta);
+
+		mPrecession[0][1] = -sin(z) * cos(zeta) - cos(z) * cos(theta_p) * sin(zeta);
+		mPrecession[1][1] = cos(z) * cos(zeta) - sin(z) * cos(theta_p) * sin(zeta);
+		mPrecession[2][1] = -sin(theta_p) * sin(zeta);
+
+		mPrecession[0][2] = -cos(z) * sin(theta_p);
+		mPrecession[1][2] = -sin(z) * sin(theta_p);
+		mPrecession[2][2] = cos(theta_p);
+
+		//////////////////////////////////////////////////////////
+		// Calculate Nutation Matrix
+
+		double omega_moon = 2.1824386244 - 33.7570459338 * TTt2000
+				+ 3.61428599267159E-005 * TTt2000 * TTt2000
+				+ 3.87850944887629E-008 * TTt2000 * TTt2000 * TTt2000;
+
+		double deltaPsi = -0.000083388 * sin(omega_moon);
+		double deltaEpsilon = 4.46174030725106E-005 * cos(omega_moon);
+
+		double epsilon = 0.4090928042 - 0.0002269655 * TTt2000
+				- 2.86040071854626E-009 * TTt2000 * TTt2000
+				+ 8.78967203851589E-009 * TTt2000 * TTt2000 * TTt2000;
+
+
+		double mNutation[3][3];
+
+		mNutation[0][0] = cos(deltaPsi);
+		mNutation[1][0] = cos(epsilon + deltaEpsilon) * sin(deltaPsi);
+		mNutation[2][0] = sin(epsilon + deltaEpsilon) * sin(deltaPsi);
+
+		mNutation[0][1] = -cos(epsilon) * sin(deltaPsi);
+		mNutation[1][1] = cos(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
+				+ sin(epsilon) * sin(epsilon + deltaEpsilon);
+		mNutation[2][1] = cos(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
+				- sin(epsilon) * cos(epsilon + deltaEpsilon);
+
+		mNutation[0][2] = -sin(epsilon) * sin(deltaPsi);
+		mNutation[1][2] = sin(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
+				- cos(epsilon) * sin(epsilon + deltaEpsilon);
+		mNutation[2][2] = sin(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
+				+ cos(epsilon) * cos(epsilon + deltaEpsilon);
+
+		//////////////////////////////////////////////////////////
+		// Calculate Earth rotation matrix
+		//calculate theta
+
+		double mTheta[3][3];
+		double Ttemp[3][3];
+		getEarthRotationMatrix(timeUTC, mTheta);
+
+		//polar motion is neglected
+		MatrixOperations<double>::multiply(mNutation[0], mPrecession[0], Ttemp[0],
+				3, 3, 3);
+
+		MatrixOperations<double>::multiply(mTheta[0], Ttemp[0], Tfi[0], 3, 3, 3);
+};
diff --git a/coordinates/CoordinateTransformations.h b/coordinates/CoordinateTransformations.h
index 0bfb203dd..09ea2c48c 100644
--- a/coordinates/CoordinateTransformations.h
+++ b/coordinates/CoordinateTransformations.h
@@ -1,34 +1,34 @@
-#ifndef COORDINATETRANSFORMATIONS_H_
-#define COORDINATETRANSFORMATIONS_H_
-
-#include "../timemanager/Clock.h"
-#include <cstring>
-
-class CoordinateTransformations {
-public:
-	static void positionEcfToEci(const double* ecfCoordinates, double* eciCoordinates, timeval *timeUTC = NULL);
-
-	static void velocityEcfToEci(const double* ecfVelocity,
-			const double* ecfPosition,
-			double* eciVelocity, timeval *timeUTC = NULL);
-
-	static void positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC = NULL);
-	static void velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC = NULL);
-
-	static double getEarthRotationAngle(timeval timeUTC);
-
-	static void getEarthRotationMatrix(timeval timeUTC, double matrix[][3]);
-private:
-	CoordinateTransformations();
-	static void ecfToEci(const double* ecfCoordinates, double* eciCoordinates,
-			const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin);
-	static void eciToEcf(const double* eciCoordinates,
-				double* ecfCoordinates,
-				const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin);
-
-	static double getJuleanCenturiesTT(timeval timeUTC);
-	static void getTransMatrixECITOECF(timeval time,double Tfi[3][3]);
-
-};
-
-#endif /* COORDINATETRANSFORMATIONS_H_ */
+#ifndef COORDINATETRANSFORMATIONS_H_
+#define COORDINATETRANSFORMATIONS_H_
+
+#include "../timemanager/Clock.h"
+#include <cstring>
+
+class CoordinateTransformations {
+public:
+	static void positionEcfToEci(const double* ecfCoordinates, double* eciCoordinates, timeval *timeUTC = NULL);
+
+	static void velocityEcfToEci(const double* ecfVelocity,
+			const double* ecfPosition,
+			double* eciVelocity, timeval *timeUTC = NULL);
+
+	static void positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC = NULL);
+	static void velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC = NULL);
+
+	static double getEarthRotationAngle(timeval timeUTC);
+
+	static void getEarthRotationMatrix(timeval timeUTC, double matrix[][3]);
+private:
+	CoordinateTransformations();
+	static void ecfToEci(const double* ecfCoordinates, double* eciCoordinates,
+			const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin);
+	static void eciToEcf(const double* eciCoordinates,
+				double* ecfCoordinates,
+				const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin);
+
+	static double getJuleanCenturiesTT(timeval timeUTC);
+	static void getTransMatrixECITOECF(timeval time,double Tfi[3][3]);
+
+};
+
+#endif /* COORDINATETRANSFORMATIONS_H_ */
diff --git a/coordinates/Jgm3Model.h b/coordinates/Jgm3Model.h
index fd74741dd..884ed1418 100644
--- a/coordinates/Jgm3Model.h
+++ b/coordinates/Jgm3Model.h
@@ -1,180 +1,180 @@
-#ifndef FRAMEWORK_COORDINATES_JGM3MODEL_H_
-#define FRAMEWORK_COORDINATES_JGM3MODEL_H_
-
-#include <stdint.h>
-#include "../coordinates/CoordinateTransformations.h"
-#include "../globalfunctions/math/VectorOperations.h"
-#include "../globalfunctions/timevalOperations.h"
-#include "../globalfunctions/constants.h"
-#include <memory.h>
-
-
-template<uint8_t DEGREE,uint8_t ORDER>
-class Jgm3Model {
-public:
-	static const uint32_t factorialLookupTable[DEGREE+3]; //This table is used instead of factorial calculation, must be increased if order or degree is higher
-
-	Jgm3Model() {
-		y0[0] = 0;
-		y0[1] = 0;
-		y0[2] = 0;
-		y0[3] = 0;
-		y0[4] = 0;
-		y0[5] = 0;
-
-		lastExecutionTime.tv_sec = 0;
-		lastExecutionTime.tv_usec = 0;
-	}
-	virtual ~Jgm3Model(){};
-
-	//double acsNavOrbit(double posECF[3],double velECF[3],timeval gpsTime);
-
-	double y0[6]; //position and velocity at beginning of RK step in EC
-	timeval lastExecutionTime; //Time of last execution
-
-
-	void accelDegOrd(const double pos[3],const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1],double* accel){
-		//Get radius of this position
-		double r = VectorOperations<double>::norm(pos,3);
-
-
-
-		//Initialize the V and W matrix
-		double V[DEGREE+2][ORDER+2] = {{0}};
-		double W[DEGREE+2][ORDER+2] = {{0}};
-
-		for(uint8_t m=0;m<(ORDER+2);m++){
-			for(uint8_t n=m;n<(DEGREE+2);n++){
-				if((n==0) && (m==0)){
-					//Montenbruck "Satellite Orbits Eq.3.31"
-					V[0][0] = Earth::MEAN_RADIUS / r;
-					W[0][0] = 0;
-				}else{
-					if(n==m){
-						//Montenbruck "Satellite Orbits Eq.3.29"
-						V[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1] - pos[1]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1]);
-						W[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1] + pos[1]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1]);
-					}else{
-						//Montenbruck "Satellite Orbits Eq.3.30"
-						V[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*V[n-1][m];
-						W[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*W[n-1][m];
-						if(n!=(m+1)){
-							V[n][m] = V[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * V[n-2][m]);
-							W[n][m] = W[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * W[n-2][m]);
-						}//End of if(n!=(m+1))
-					}//End of if(n==m){
-				}//End of if(n==0 and m==0)
-			}//End of for(uint8_t n=0;n<(DEGREE+1);n++)
-		}//End of for(uint8_t m=0;m<(ORDER+1);m++)
-
-
-		//overwrite accel if not properly initialized
-		accel[0] = 0;
-		accel[1] = 0;
-		accel[2] = 0;
-
-		for(uint8_t m=0;m<(ORDER+1);m++){
-			for(uint8_t n=m;n<(DEGREE+1);n++){
-				//Use table lookup to get factorial
-				double partAccel[3] = {0};
-				double factor = Earth::STANDARD_GRAVITATIONAL_PARAMETER/pow(Earth::MEAN_RADIUS,2);
-				if(m==0){
-					//Montenbruck "Satellite Orbits Eq.3.33"
-					partAccel[0] = factor * (-C[n][0]*V[n+1][1]);
-					partAccel[1] = factor * (-C[n][0]*W[n+1][1]);
-				}else{
-					double factMN = static_cast<double>(factorialLookupTable[n-m+2]) / static_cast<double>(factorialLookupTable[n-m]);
-					partAccel[0] = factor * 0.5 * ((-C[n][m]*V[n+1][m+1]-S[n][m]*W[n+1][m+1])+factMN*(C[n][m]*V[n+1][m-1]+S[n][m]*W[n+1][m-1]));
-					partAccel[1] = factor * 0.5 * ((-C[n][m]*W[n+1][m+1]+S[n][m]*V[n+1][m+1])+factMN*(-C[n][m]*W[n+1][m-1]+S[n][m]*V[n+1][m-1]));
-				}
-
-				partAccel[2] = factor * ((n-m+1)*(-C[n][m]*V[n+1][m]-S[n][m]*W[n+1][m]));
-
-
-				accel[0] += partAccel[0];
-				accel[1] += partAccel[1];
-				accel[2] += partAccel[2];
-			}//End of for(uint8_t n=0;n<DEGREE;n++)
-		}//End of uint8_t m=0;m<ORDER;m++
-	}
-
-	void initializeNavOrbit(const double position[3],const double velocity[3], timeval timeUTC){
-		CoordinateTransformations::positionEcfToEci(position,&y0[0],&timeUTC);
-		CoordinateTransformations::velocityEcfToEci(velocity,position,&y0[3],&timeUTC);
-		lastExecutionTime = timeUTC;
-	}
-
-
-	void acsNavOrbit(timeval timeUTC, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1], double outputPos[3],double outputVel[3]){
-
-		//RK4 Integration for this timestamp
-		double deltaT = timevalOperations::toDouble(timeUTC-lastExecutionTime);
-
-		double y0dot[6] = {0,0,0,0,0,0};
-		double yA[6] = {0,0,0,0,0,0};
-		double yAdot[6] = {0,0,0,0,0,0};
-		double yB[6] = {0,0,0,0,0,0};
-		double yBdot[6] = {0,0,0,0,0,0};
-		double yC[6] = {0,0,0,0,0,0};
-		double yCdot[6] = {0,0,0,0,0,0};
-
-		//Step One
-		rungeKuttaStep(y0,y0dot,lastExecutionTime,S,C);
-
-		//Step Two
-		VectorOperations<double>::mulScalar(y0dot,deltaT/2,yA,6);
-		VectorOperations<double>::add(y0,yA,yA,6);
-		rungeKuttaStep(yA,yAdot,lastExecutionTime,S,C);
-
-		//Step Three
-		VectorOperations<double>::mulScalar(yAdot,deltaT/2,yB,6);
-		VectorOperations<double>::add(y0,yB,yB,6);
-		rungeKuttaStep(yB,yBdot,lastExecutionTime,S,C);
-
-		//Step Four
-		VectorOperations<double>::mulScalar(yBdot,deltaT,yC,6);
-		VectorOperations<double>::add(y0,yC,yC,6);
-		rungeKuttaStep(yC,yCdot,lastExecutionTime,S,C);
-
-		//Calc new State
-		VectorOperations<double>::mulScalar(yAdot,2,yAdot,6);
-		VectorOperations<double>::mulScalar(yBdot,2,yBdot,6);
-		VectorOperations<double>::add(y0dot,yAdot,y0dot,6);
-		VectorOperations<double>::add(y0dot,yBdot,y0dot,6);
-		VectorOperations<double>::add(y0dot,yCdot,y0dot,6);
-		VectorOperations<double>::mulScalar(y0dot,1./6.*deltaT,y0dot,6);
-		VectorOperations<double>::add(y0,y0dot,y0,6);
-
-		CoordinateTransformations::positionEciToEcf(&y0[0],outputPos,&timeUTC);
-		CoordinateTransformations::velocityEciToEcf(&y0[3],&y0[0],outputVel,&timeUTC);
-
-		lastExecutionTime = timeUTC;
-
-
-	}
-
-
-	void rungeKuttaStep(const double* yIn,double* yOut,timeval time, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1]){
-		double rECF[3] = {0,0,0};
-		double rDotECF[3] = {0,0,0};
-		double accelECF[3] = {0,0,0};
-		double accelECI[3] = {0,0,0};
-
-
-		CoordinateTransformations::positionEciToEcf(&yIn[0],rECF,&time);
-		CoordinateTransformations::velocityEciToEcf(&yIn[3],&yIn[0],rDotECF,&time);
-		accelDegOrd(rECF,S,C,accelECF);
-		//This is not correct, as the acceleration would have derived terms but we don't know the velocity and position at that time
-		//Tests showed that a wrong velocity does make the equation worse than neglecting it
-		CoordinateTransformations::positionEcfToEci(accelECF,accelECI,&time);
-		memcpy(&yOut[0],&yIn[3],sizeof(yOut[0])*3);
-		memcpy(&yOut[3],accelECI,sizeof(yOut[0])*3);
-	}
-};
-
-
-
-
-
-
-#endif /* FRAMEWORK_COORDINATES_JGM3MODEL_H_ */
+#ifndef FRAMEWORK_COORDINATES_JGM3MODEL_H_
+#define FRAMEWORK_COORDINATES_JGM3MODEL_H_
+
+#include <stdint.h>
+#include "CoordinateTransformations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include "../globalfunctions/timevalOperations.h"
+#include "../globalfunctions/constants.h"
+#include <memory.h>
+
+
+template<uint8_t DEGREE,uint8_t ORDER>
+class Jgm3Model {
+public:
+	static const uint32_t factorialLookupTable[DEGREE+3]; //This table is used instead of factorial calculation, must be increased if order or degree is higher
+
+	Jgm3Model() {
+		y0[0] = 0;
+		y0[1] = 0;
+		y0[2] = 0;
+		y0[3] = 0;
+		y0[4] = 0;
+		y0[5] = 0;
+
+		lastExecutionTime.tv_sec = 0;
+		lastExecutionTime.tv_usec = 0;
+	}
+	virtual ~Jgm3Model(){};
+
+	//double acsNavOrbit(double posECF[3],double velECF[3],timeval gpsTime);
+
+	double y0[6]; //position and velocity at beginning of RK step in EC
+	timeval lastExecutionTime; //Time of last execution
+
+
+	void accelDegOrd(const double pos[3],const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1],double* accel){
+		//Get radius of this position
+		double r = VectorOperations<double>::norm(pos,3);
+
+
+
+		//Initialize the V and W matrix
+		double V[DEGREE+2][ORDER+2] = {{0}};
+		double W[DEGREE+2][ORDER+2] = {{0}};
+
+		for(uint8_t m=0;m<(ORDER+2);m++){
+			for(uint8_t n=m;n<(DEGREE+2);n++){
+				if((n==0) && (m==0)){
+					//Montenbruck "Satellite Orbits Eq.3.31"
+					V[0][0] = Earth::MEAN_RADIUS / r;
+					W[0][0] = 0;
+				}else{
+					if(n==m){
+						//Montenbruck "Satellite Orbits Eq.3.29"
+						V[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1] - pos[1]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1]);
+						W[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1] + pos[1]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1]);
+					}else{
+						//Montenbruck "Satellite Orbits Eq.3.30"
+						V[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*V[n-1][m];
+						W[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*W[n-1][m];
+						if(n!=(m+1)){
+							V[n][m] = V[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * V[n-2][m]);
+							W[n][m] = W[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * W[n-2][m]);
+						}//End of if(n!=(m+1))
+					}//End of if(n==m){
+				}//End of if(n==0 and m==0)
+			}//End of for(uint8_t n=0;n<(DEGREE+1);n++)
+		}//End of for(uint8_t m=0;m<(ORDER+1);m++)
+
+
+		//overwrite accel if not properly initialized
+		accel[0] = 0;
+		accel[1] = 0;
+		accel[2] = 0;
+
+		for(uint8_t m=0;m<(ORDER+1);m++){
+			for(uint8_t n=m;n<(DEGREE+1);n++){
+				//Use table lookup to get factorial
+				double partAccel[3] = {0};
+				double factor = Earth::STANDARD_GRAVITATIONAL_PARAMETER/pow(Earth::MEAN_RADIUS,2);
+				if(m==0){
+					//Montenbruck "Satellite Orbits Eq.3.33"
+					partAccel[0] = factor * (-C[n][0]*V[n+1][1]);
+					partAccel[1] = factor * (-C[n][0]*W[n+1][1]);
+				}else{
+					double factMN = static_cast<double>(factorialLookupTable[n-m+2]) / static_cast<double>(factorialLookupTable[n-m]);
+					partAccel[0] = factor * 0.5 * ((-C[n][m]*V[n+1][m+1]-S[n][m]*W[n+1][m+1])+factMN*(C[n][m]*V[n+1][m-1]+S[n][m]*W[n+1][m-1]));
+					partAccel[1] = factor * 0.5 * ((-C[n][m]*W[n+1][m+1]+S[n][m]*V[n+1][m+1])+factMN*(-C[n][m]*W[n+1][m-1]+S[n][m]*V[n+1][m-1]));
+				}
+
+				partAccel[2] = factor * ((n-m+1)*(-C[n][m]*V[n+1][m]-S[n][m]*W[n+1][m]));
+
+
+				accel[0] += partAccel[0];
+				accel[1] += partAccel[1];
+				accel[2] += partAccel[2];
+			}//End of for(uint8_t n=0;n<DEGREE;n++)
+		}//End of uint8_t m=0;m<ORDER;m++
+	}
+
+	void initializeNavOrbit(const double position[3],const double velocity[3], timeval timeUTC){
+		CoordinateTransformations::positionEcfToEci(position,&y0[0],&timeUTC);
+		CoordinateTransformations::velocityEcfToEci(velocity,position,&y0[3],&timeUTC);
+		lastExecutionTime = timeUTC;
+	}
+
+
+	void acsNavOrbit(timeval timeUTC, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1], double outputPos[3],double outputVel[3]){
+
+		//RK4 Integration for this timestamp
+		double deltaT = timevalOperations::toDouble(timeUTC-lastExecutionTime);
+
+		double y0dot[6] = {0,0,0,0,0,0};
+		double yA[6] = {0,0,0,0,0,0};
+		double yAdot[6] = {0,0,0,0,0,0};
+		double yB[6] = {0,0,0,0,0,0};
+		double yBdot[6] = {0,0,0,0,0,0};
+		double yC[6] = {0,0,0,0,0,0};
+		double yCdot[6] = {0,0,0,0,0,0};
+
+		//Step One
+		rungeKuttaStep(y0,y0dot,lastExecutionTime,S,C);
+
+		//Step Two
+		VectorOperations<double>::mulScalar(y0dot,deltaT/2,yA,6);
+		VectorOperations<double>::add(y0,yA,yA,6);
+		rungeKuttaStep(yA,yAdot,lastExecutionTime,S,C);
+
+		//Step Three
+		VectorOperations<double>::mulScalar(yAdot,deltaT/2,yB,6);
+		VectorOperations<double>::add(y0,yB,yB,6);
+		rungeKuttaStep(yB,yBdot,lastExecutionTime,S,C);
+
+		//Step Four
+		VectorOperations<double>::mulScalar(yBdot,deltaT,yC,6);
+		VectorOperations<double>::add(y0,yC,yC,6);
+		rungeKuttaStep(yC,yCdot,lastExecutionTime,S,C);
+
+		//Calc new State
+		VectorOperations<double>::mulScalar(yAdot,2,yAdot,6);
+		VectorOperations<double>::mulScalar(yBdot,2,yBdot,6);
+		VectorOperations<double>::add(y0dot,yAdot,y0dot,6);
+		VectorOperations<double>::add(y0dot,yBdot,y0dot,6);
+		VectorOperations<double>::add(y0dot,yCdot,y0dot,6);
+		VectorOperations<double>::mulScalar(y0dot,1./6.*deltaT,y0dot,6);
+		VectorOperations<double>::add(y0,y0dot,y0,6);
+
+		CoordinateTransformations::positionEciToEcf(&y0[0],outputPos,&timeUTC);
+		CoordinateTransformations::velocityEciToEcf(&y0[3],&y0[0],outputVel,&timeUTC);
+
+		lastExecutionTime = timeUTC;
+
+
+	}
+
+
+	void rungeKuttaStep(const double* yIn,double* yOut,timeval time, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1]){
+		double rECF[3] = {0,0,0};
+		double rDotECF[3] = {0,0,0};
+		double accelECF[3] = {0,0,0};
+		double accelECI[3] = {0,0,0};
+
+
+		CoordinateTransformations::positionEciToEcf(&yIn[0],rECF,&time);
+		CoordinateTransformations::velocityEciToEcf(&yIn[3],&yIn[0],rDotECF,&time);
+		accelDegOrd(rECF,S,C,accelECF);
+		//This is not correct, as the acceleration would have derived terms but we don't know the velocity and position at that time
+		//Tests showed that a wrong velocity does make the equation worse than neglecting it
+		CoordinateTransformations::positionEcfToEci(accelECF,accelECI,&time);
+		memcpy(&yOut[0],&yIn[3],sizeof(yOut[0])*3);
+		memcpy(&yOut[3],accelECI,sizeof(yOut[0])*3);
+	}
+};
+
+
+
+
+
+
+#endif /* FRAMEWORK_COORDINATES_JGM3MODEL_H_ */
diff --git a/coordinates/Sgp4Propagator.cpp b/coordinates/Sgp4Propagator.cpp
index 84a527997..5cb1497cf 100644
--- a/coordinates/Sgp4Propagator.cpp
+++ b/coordinates/Sgp4Propagator.cpp
@@ -1,228 +1,228 @@
-#include "../coordinates/CoordinateTransformations.h"
-#include "../coordinates/Sgp4Propagator.h"
-#include "../globalfunctions/constants.h"
-#include "../globalfunctions/math/MatrixOperations.h"
-#include "../globalfunctions/math/VectorOperations.h"
-#include "../globalfunctions/timevalOperations.h"
-#include <cstring>
-Sgp4Propagator::Sgp4Propagator() :
-		initialized(false), epoch({0, 0}), whichconst(wgs84) {
-
-}
-
-Sgp4Propagator::~Sgp4Propagator() {
-
-}
-
-void jday(int year, int mon, int day, int hr, int minute, double sec,
-		double& jd) {
-	jd = 367.0 * year - floor((7 * (year + floor((mon + 9) / 12.0))) * 0.25)
-			+ floor(275 * mon / 9.0) + day + 1721013.5
-			+ ((sec / 60.0 + minute) / 60.0 + hr) / 24.0;  // ut in days
-			// - 0.5*sgn(100.0*year + mon - 190002.5) + 0.5;
-}
-
-void days2mdhms(int year, double days, int& mon, int& day, int& hr, int& minute,
-		double& sec) {
-	int i, inttemp, dayofyr;
-	double temp;
-	int lmonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-
-	dayofyr = (int) floor(days);
-	/* ----------------- find month and day of month ---------------- */
-	if ((year % 4) == 0)
-		lmonth[1] = 29;
-
-	i = 1;
-	inttemp = 0;
-	while ((dayofyr > inttemp + lmonth[i - 1]) && (i < 12)) {
-		inttemp = inttemp + lmonth[i - 1];
-		i++;
-	}
-	mon = i;
-	day = dayofyr - inttemp;
-
-	/* ----------------- find hours minutes and seconds ------------- */
-	temp = (days - dayofyr) * 24.0;
-	hr = (int) floor(temp);
-	temp = (temp - hr) * 60.0;
-	minute = (int) floor(temp);
-	sec = (temp - minute) * 60.0;
-}
-
-ReturnValue_t Sgp4Propagator::initialize(const uint8_t* line1,
-		const uint8_t* line2) {
-
-	char longstr1[130];
-	char longstr2[130];
-
-	//need some space for decimal points
-	memcpy(longstr1, line1, 69);
-	memcpy(longstr2, line2, 69);
-
-	const double deg2rad = Math::PI / 180.0;    //   0.0174532925199433
-	const double xpdotp = 1440.0 / (2.0 * Math::PI); // 229.1831180523293
-
-	double sec, mu, radiusearthkm, tumin, xke, j2, j3, j4, j3oj2;
-	int cardnumb, numb, j;
-	long revnum = 0, elnum = 0;
-	char classification, intldesg[11];
-	int year = 0;
-	int mon, day, hr, minute, nexp, ibexp;
-
-	getgravconst(whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2);
-
-	satrec.error = 0;
-
-	// set the implied decimal points since doing a formated read
-	// fixes for bad input data values (missing, ...)
-	for (j = 10; j <= 15; j++)
-		if (longstr1[j] == ' ')
-			longstr1[j] = '_';
-
-	if (longstr1[44] != ' ')
-		longstr1[43] = longstr1[44];
-	longstr1[44] = '.';
-	if (longstr1[7] == ' ')
-		longstr1[7] = 'U';
-	if (longstr1[9] == ' ')
-		longstr1[9] = '.';
-	for (j = 45; j <= 49; j++)
-		if (longstr1[j] == ' ')
-			longstr1[j] = '0';
-	if (longstr1[51] == ' ')
-		longstr1[51] = '0';
-	if (longstr1[53] != ' ')
-		longstr1[52] = longstr1[53];
-	longstr1[53] = '.';
-	longstr2[25] = '.';
-	for (j = 26; j <= 32; j++)
-		if (longstr2[j] == ' ')
-			longstr2[j] = '0';
-	if (longstr1[62] == ' ')
-		longstr1[62] = '0';
-	if (longstr1[68] == ' ')
-		longstr1[68] = '0';
-
-	sscanf(longstr1,
-			"%2d %5ld %1c %10s %2d %12lf %11lf %7lf %2d %7lf %2d %2d %6ld ",
-			&cardnumb, &satrec.satnum, &classification, intldesg,
-			&satrec.epochyr, &satrec.epochdays, &satrec.ndot, &satrec.nddot,
-			&nexp, &satrec.bstar, &ibexp, &numb, &elnum);
-
-	if (longstr2[52] == ' ') {
-		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %10lf %6ld \n",
-				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
-				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
-	} else {
-		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %11lf %6ld \n",
-				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
-				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
-	}
-
-	// ---- find no, ndot, nddot ----
-	satrec.no = satrec.no / xpdotp; //* rad/min
-	satrec.nddot = satrec.nddot * pow(10.0, nexp);
-	satrec.bstar = satrec.bstar * pow(10.0, ibexp);
-
-	// ---- convert to sgp4 units ----
-	satrec.a = pow(satrec.no * tumin, (-2.0 / 3.0));
-	satrec.ndot = satrec.ndot / (xpdotp * 1440.0);  //* ? * minperday
-	satrec.nddot = satrec.nddot / (xpdotp * 1440.0 * 1440);
-
-	// ---- find standard orbital elements ----
-	satrec.inclo = satrec.inclo * deg2rad;
-	satrec.nodeo = satrec.nodeo * deg2rad;
-	satrec.argpo = satrec.argpo * deg2rad;
-	satrec.mo = satrec.mo * deg2rad;
-
-	satrec.alta = satrec.a * (1.0 + satrec.ecco) - 1.0;
-	satrec.altp = satrec.a * (1.0 - satrec.ecco) - 1.0;
-
-	// ----------------------------------------------------------------
-	// find sgp4epoch time of element set
-	// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
-	// and minutes from the epoch (time)
-	// ----------------------------------------------------------------
-
-	// ---------------- temp fix for years from 1957-2056 -------------------
-	// --------- correct fix will occur when year is 4-digit in tle ---------
-	if (satrec.epochyr < 57) {
-		year = satrec.epochyr + 2000;
-	} else {
-		year = satrec.epochyr + 1900;
-	}
-
-	days2mdhms(year, satrec.epochdays, mon, day, hr, minute, sec);
-	jday(year, mon, day, hr, minute, sec, satrec.jdsatepoch);
-
-	double unixSeconds = (satrec.jdsatepoch - 2451544.5) * 24 * 3600
-			+ 946684800;
-
-	epoch.tv_sec = unixSeconds;
-	double subseconds = unixSeconds - epoch.tv_sec;
-	epoch.tv_usec = subseconds * 1000000;
-
-	// ---------------- initialize the orbit at sgp4epoch -------------------
-	uint8_t result = sgp4init(whichconst, satrec.satnum,
-			satrec.jdsatepoch - 2433281.5, satrec.bstar, satrec.ecco,
-			satrec.argpo, satrec.inclo, satrec.mo, satrec.no, satrec.nodeo,
-			satrec);
-
-	if (result != 00) {
-		return MAKE_RETURN_CODE(result);
-	} else {
-		initialized = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-}
-
-ReturnValue_t Sgp4Propagator::propagate(double* position, double* velocity,
-		timeval time, uint8_t gpsUtcOffset) {
-
-	if (!initialized) {
-		return TLE_NOT_INITIALIZED;
-	}
-
-	//Time since epoch in minutes
-	timeval timeSinceEpoch = time - epoch;
-	double minutesSinceEpoch = timeSinceEpoch.tv_sec / 60.
-			+ timeSinceEpoch.tv_usec / 60000000.;
-
-	double yearsSinceEpoch = minutesSinceEpoch / 60 / 24 / 365;
-
-	if ((yearsSinceEpoch > 1) || (yearsSinceEpoch < -1)) {
-		return TLE_TOO_OLD;
-	}
-
-	double positionTEME[3];
-	double velocityTEME[3];
-
-	uint8_t result = sgp4(whichconst, satrec, minutesSinceEpoch, positionTEME,
-			velocityTEME);
-
-	VectorOperations<double>::mulScalar(positionTEME, 1000, positionTEME, 3);
-	VectorOperations<double>::mulScalar(velocityTEME, 1000, velocityTEME, 3);
-
-	//Transform to ECF
-	double earthRotationMatrix[3][3];
-	CoordinateTransformations::getEarthRotationMatrix(time,
-			earthRotationMatrix);
-
-	MatrixOperations<double>::multiply(earthRotationMatrix[0], positionTEME,
-			position, 3, 3, 1);
-	MatrixOperations<double>::multiply(earthRotationMatrix[0], velocityTEME,
-			velocity, 3, 3, 1);
-
-	double omegaEarth[3] = { 0, 0, Earth::OMEGA };
-	double velocityCorrection[3];
-	VectorOperations<double>::cross(omegaEarth, position, velocityCorrection);
-	VectorOperations<double>::subtract(velocity, velocityCorrection, velocity);
-
-	if (result != 0) {
-		return MAKE_RETURN_CODE(result || 0xB0);
-	} else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
+#include "CoordinateTransformations.h"
+#include "Sgp4Propagator.h"
+#include "../globalfunctions/constants.h"
+#include "../globalfunctions/math/MatrixOperations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include "../globalfunctions/timevalOperations.h"
+#include <cstring>
+Sgp4Propagator::Sgp4Propagator() :
+		initialized(false), epoch({0, 0}), whichconst(wgs84) {
+
+}
+
+Sgp4Propagator::~Sgp4Propagator() {
+
+}
+
+void jday(int year, int mon, int day, int hr, int minute, double sec,
+		double& jd) {
+	jd = 367.0 * year - floor((7 * (year + floor((mon + 9) / 12.0))) * 0.25)
+			+ floor(275 * mon / 9.0) + day + 1721013.5
+			+ ((sec / 60.0 + minute) / 60.0 + hr) / 24.0;  // ut in days
+			// - 0.5*sgn(100.0*year + mon - 190002.5) + 0.5;
+}
+
+void days2mdhms(int year, double days, int& mon, int& day, int& hr, int& minute,
+		double& sec) {
+	int i, inttemp, dayofyr;
+	double temp;
+	int lmonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+	dayofyr = (int) floor(days);
+	/* ----------------- find month and day of month ---------------- */
+	if ((year % 4) == 0)
+		lmonth[1] = 29;
+
+	i = 1;
+	inttemp = 0;
+	while ((dayofyr > inttemp + lmonth[i - 1]) && (i < 12)) {
+		inttemp = inttemp + lmonth[i - 1];
+		i++;
+	}
+	mon = i;
+	day = dayofyr - inttemp;
+
+	/* ----------------- find hours minutes and seconds ------------- */
+	temp = (days - dayofyr) * 24.0;
+	hr = (int) floor(temp);
+	temp = (temp - hr) * 60.0;
+	minute = (int) floor(temp);
+	sec = (temp - minute) * 60.0;
+}
+
+ReturnValue_t Sgp4Propagator::initialize(const uint8_t* line1,
+		const uint8_t* line2) {
+
+	char longstr1[130];
+	char longstr2[130];
+
+	//need some space for decimal points
+	memcpy(longstr1, line1, 69);
+	memcpy(longstr2, line2, 69);
+
+	const double deg2rad = Math::PI / 180.0;    //   0.0174532925199433
+	const double xpdotp = 1440.0 / (2.0 * Math::PI); // 229.1831180523293
+
+	double sec, mu, radiusearthkm, tumin, xke, j2, j3, j4, j3oj2;
+	int cardnumb, numb, j;
+	long revnum = 0, elnum = 0;
+	char classification, intldesg[11];
+	int year = 0;
+	int mon, day, hr, minute, nexp, ibexp;
+
+	getgravconst(whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2);
+
+	satrec.error = 0;
+
+	// set the implied decimal points since doing a formated read
+	// fixes for bad input data values (missing, ...)
+	for (j = 10; j <= 15; j++)
+		if (longstr1[j] == ' ')
+			longstr1[j] = '_';
+
+	if (longstr1[44] != ' ')
+		longstr1[43] = longstr1[44];
+	longstr1[44] = '.';
+	if (longstr1[7] == ' ')
+		longstr1[7] = 'U';
+	if (longstr1[9] == ' ')
+		longstr1[9] = '.';
+	for (j = 45; j <= 49; j++)
+		if (longstr1[j] == ' ')
+			longstr1[j] = '0';
+	if (longstr1[51] == ' ')
+		longstr1[51] = '0';
+	if (longstr1[53] != ' ')
+		longstr1[52] = longstr1[53];
+	longstr1[53] = '.';
+	longstr2[25] = '.';
+	for (j = 26; j <= 32; j++)
+		if (longstr2[j] == ' ')
+			longstr2[j] = '0';
+	if (longstr1[62] == ' ')
+		longstr1[62] = '0';
+	if (longstr1[68] == ' ')
+		longstr1[68] = '0';
+
+	sscanf(longstr1,
+			"%2d %5ld %1c %10s %2d %12lf %11lf %7lf %2d %7lf %2d %2d %6ld ",
+			&cardnumb, &satrec.satnum, &classification, intldesg,
+			&satrec.epochyr, &satrec.epochdays, &satrec.ndot, &satrec.nddot,
+			&nexp, &satrec.bstar, &ibexp, &numb, &elnum);
+
+	if (longstr2[52] == ' ') {
+		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %10lf %6ld \n",
+				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
+				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
+	} else {
+		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %11lf %6ld \n",
+				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
+				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
+	}
+
+	// ---- find no, ndot, nddot ----
+	satrec.no = satrec.no / xpdotp; //* rad/min
+	satrec.nddot = satrec.nddot * pow(10.0, nexp);
+	satrec.bstar = satrec.bstar * pow(10.0, ibexp);
+
+	// ---- convert to sgp4 units ----
+	satrec.a = pow(satrec.no * tumin, (-2.0 / 3.0));
+	satrec.ndot = satrec.ndot / (xpdotp * 1440.0);  //* ? * minperday
+	satrec.nddot = satrec.nddot / (xpdotp * 1440.0 * 1440);
+
+	// ---- find standard orbital elements ----
+	satrec.inclo = satrec.inclo * deg2rad;
+	satrec.nodeo = satrec.nodeo * deg2rad;
+	satrec.argpo = satrec.argpo * deg2rad;
+	satrec.mo = satrec.mo * deg2rad;
+
+	satrec.alta = satrec.a * (1.0 + satrec.ecco) - 1.0;
+	satrec.altp = satrec.a * (1.0 - satrec.ecco) - 1.0;
+
+	// ----------------------------------------------------------------
+	// find sgp4epoch time of element set
+	// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
+	// and minutes from the epoch (time)
+	// ----------------------------------------------------------------
+
+	// ---------------- temp fix for years from 1957-2056 -------------------
+	// --------- correct fix will occur when year is 4-digit in tle ---------
+	if (satrec.epochyr < 57) {
+		year = satrec.epochyr + 2000;
+	} else {
+		year = satrec.epochyr + 1900;
+	}
+
+	days2mdhms(year, satrec.epochdays, mon, day, hr, minute, sec);
+	jday(year, mon, day, hr, minute, sec, satrec.jdsatepoch);
+
+	double unixSeconds = (satrec.jdsatepoch - 2451544.5) * 24 * 3600
+			+ 946684800;
+
+	epoch.tv_sec = unixSeconds;
+	double subseconds = unixSeconds - epoch.tv_sec;
+	epoch.tv_usec = subseconds * 1000000;
+
+	// ---------------- initialize the orbit at sgp4epoch -------------------
+	uint8_t result = sgp4init(whichconst, satrec.satnum,
+			satrec.jdsatepoch - 2433281.5, satrec.bstar, satrec.ecco,
+			satrec.argpo, satrec.inclo, satrec.mo, satrec.no, satrec.nodeo,
+			satrec);
+
+	if (result != 00) {
+		return MAKE_RETURN_CODE(result);
+	} else {
+		initialized = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+}
+
+ReturnValue_t Sgp4Propagator::propagate(double* position, double* velocity,
+		timeval time, uint8_t gpsUtcOffset) {
+
+	if (!initialized) {
+		return TLE_NOT_INITIALIZED;
+	}
+
+	//Time since epoch in minutes
+	timeval timeSinceEpoch = time - epoch;
+	double minutesSinceEpoch = timeSinceEpoch.tv_sec / 60.
+			+ timeSinceEpoch.tv_usec / 60000000.;
+
+	double yearsSinceEpoch = minutesSinceEpoch / 60 / 24 / 365;
+
+	if ((yearsSinceEpoch > 1) || (yearsSinceEpoch < -1)) {
+		return TLE_TOO_OLD;
+	}
+
+	double positionTEME[3];
+	double velocityTEME[3];
+
+	uint8_t result = sgp4(whichconst, satrec, minutesSinceEpoch, positionTEME,
+			velocityTEME);
+
+	VectorOperations<double>::mulScalar(positionTEME, 1000, positionTEME, 3);
+	VectorOperations<double>::mulScalar(velocityTEME, 1000, velocityTEME, 3);
+
+	//Transform to ECF
+	double earthRotationMatrix[3][3];
+	CoordinateTransformations::getEarthRotationMatrix(time,
+			earthRotationMatrix);
+
+	MatrixOperations<double>::multiply(earthRotationMatrix[0], positionTEME,
+			position, 3, 3, 1);
+	MatrixOperations<double>::multiply(earthRotationMatrix[0], velocityTEME,
+			velocity, 3, 3, 1);
+
+	double omegaEarth[3] = { 0, 0, Earth::OMEGA };
+	double velocityCorrection[3];
+	VectorOperations<double>::cross(omegaEarth, position, velocityCorrection);
+	VectorOperations<double>::subtract(velocity, velocityCorrection, velocity);
+
+	if (result != 0) {
+		return MAKE_RETURN_CODE(result || 0xB0);
+	} else {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
diff --git a/coordinates/Sgp4Propagator.h b/coordinates/Sgp4Propagator.h
index f041ec075..3949547e1 100644
--- a/coordinates/Sgp4Propagator.h
+++ b/coordinates/Sgp4Propagator.h
@@ -1,44 +1,44 @@
-#ifndef SGP4PROPAGATOR_H_
-#define SGP4PROPAGATOR_H_
-
-#include <sys/time.h>
-#include "../contrib/sgp4/sgp4unit.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-class Sgp4Propagator {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SGP4PROPAGATOR_CLASS;
-	static const ReturnValue_t INVALID_ECCENTRICITY = MAKE_RETURN_CODE(0xA1);
-	static const ReturnValue_t INVALID_MEAN_MOTION = MAKE_RETURN_CODE(0xA2);
-	static const ReturnValue_t INVALID_PERTURBATION_ELEMENTS = MAKE_RETURN_CODE(0xA3);
-	static const ReturnValue_t INVALID_SEMI_LATUS_RECTUM = MAKE_RETURN_CODE(0xA4);
-	static const ReturnValue_t INVALID_EPOCH_ELEMENTS = MAKE_RETURN_CODE(0xA5);
-	static const ReturnValue_t SATELLITE_HAS_DECAYED = MAKE_RETURN_CODE(0xA6);
-	static const ReturnValue_t TLE_TOO_OLD = MAKE_RETURN_CODE(0xB1);
-	static const ReturnValue_t TLE_NOT_INITIALIZED = MAKE_RETURN_CODE(0xB2);
-
-
-
-	Sgp4Propagator();
-	virtual ~Sgp4Propagator();
-
-	ReturnValue_t initialize(const uint8_t *line1, const uint8_t *line2);
-
-	/**
-	 *
-	 * @param[out] position in ECF
-	 * @param[out] velocity in ECF
-	 * @param time to which to propagate
-	 * @return
-	 */
-	ReturnValue_t propagate(double *position, double *velocity, timeval time, uint8_t gpsUtcOffset);
-
-private:
-	bool initialized;
-	timeval epoch;
-	elsetrec satrec;
-	gravconsttype whichconst;
-
-};
-
-#endif /* SGP4PROPAGATOR_H_ */
+#ifndef SGP4PROPAGATOR_H_
+#define SGP4PROPAGATOR_H_
+
+#include <sys/time.h>
+#include "../contrib/sgp4/sgp4unit.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class Sgp4Propagator {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SGP4PROPAGATOR_CLASS;
+	static const ReturnValue_t INVALID_ECCENTRICITY = MAKE_RETURN_CODE(0xA1);
+	static const ReturnValue_t INVALID_MEAN_MOTION = MAKE_RETURN_CODE(0xA2);
+	static const ReturnValue_t INVALID_PERTURBATION_ELEMENTS = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t INVALID_SEMI_LATUS_RECTUM = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t INVALID_EPOCH_ELEMENTS = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t SATELLITE_HAS_DECAYED = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t TLE_TOO_OLD = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t TLE_NOT_INITIALIZED = MAKE_RETURN_CODE(0xB2);
+
+
+
+	Sgp4Propagator();
+	virtual ~Sgp4Propagator();
+
+	ReturnValue_t initialize(const uint8_t *line1, const uint8_t *line2);
+
+	/**
+	 *
+	 * @param[out] position in ECF
+	 * @param[out] velocity in ECF
+	 * @param time to which to propagate
+	 * @return
+	 */
+	ReturnValue_t propagate(double *position, double *velocity, timeval time, uint8_t gpsUtcOffset);
+
+private:
+	bool initialized;
+	timeval epoch;
+	elsetrec satrec;
+	gravconsttype whichconst;
+
+};
+
+#endif /* SGP4PROPAGATOR_H_ */

From d2ef2b2be46e6ac29a6b75a5b44e32f56a7f16b3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:40:53 +0200
Subject: [PATCH 0677/1774] taken over datalinklayer form upstream

---
 datalinklayer/BCFrame.h                   | 124 ++++-----
 datalinklayer/CCSDSReturnValuesIF.h       | 112 ++++----
 datalinklayer/Clcw.cpp                    | 126 ++++-----
 datalinklayer/Clcw.h                      | 132 +++++-----
 datalinklayer/DataLinkLayer.cpp           | 278 +++++++++----------
 datalinklayer/DataLinkLayer.h             | 224 ++++++++--------
 datalinklayer/Farm1StateIF.h              | 108 ++++----
 datalinklayer/Farm1StateLockout.cpp       |  70 ++---
 datalinklayer/Farm1StateLockout.h         | 118 ++++-----
 datalinklayer/Farm1StateOpen.cpp          |  98 +++----
 datalinklayer/Farm1StateOpen.h            | 124 ++++-----
 datalinklayer/Farm1StateWait.cpp          |  86 +++---
 datalinklayer/Farm1StateWait.h            | 116 ++++----
 datalinklayer/MapPacketExtraction.cpp     | 308 +++++++++++-----------
 datalinklayer/MapPacketExtraction.h       | 156 +++++------
 datalinklayer/MapPacketExtractionIF.h     |  94 +++----
 datalinklayer/TcTransferFrame.cpp         | 204 +++++++-------
 datalinklayer/TcTransferFrameLocal.cpp    |  98 +++----
 datalinklayer/TcTransferFrameLocal.h      |  98 +++----
 datalinklayer/VirtualChannelReception.cpp | 242 ++++++++---------
 datalinklayer/VirtualChannelReception.h   | 228 ++++++++--------
 datalinklayer/VirtualChannelReceptionIF.h | 114 ++++----
 22 files changed, 1629 insertions(+), 1629 deletions(-)

diff --git a/datalinklayer/BCFrame.h b/datalinklayer/BCFrame.h
index 785cbb755..b7795556d 100644
--- a/datalinklayer/BCFrame.h
+++ b/datalinklayer/BCFrame.h
@@ -1,62 +1,62 @@
-/**
- * @file	BCFrame.h
- * @brief	This file defines the BCFrame class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef BCFRAME_H_
-#define BCFRAME_H_
-
-#include "../datalinklayer/CCSDSReturnValuesIF.h"
-
-/**
- * Small helper class to identify a BcFrame.
- * @ingroup ccsds_handling
- */
-class BcFrame: public CCSDSReturnValuesIF {
-private:
-	static const uint8_t UNLOCK_COMMAND = 0b00000000;//! Identifier for a certain BC Command.
-	static const uint8_t SET_V_R_1 = 0b10000010;//! Identifier for a certain BC Command.
-	static const uint8_t SET_V_R_2 = 0b00000000;//! Identifier for a certain BC Command.
-
-public:
-	uint8_t byte1;	//!< First content byte
-	uint8_t byte2;	//!< Second content byte
-	uint8_t vR;	//!< vR byte
-	/**
-	 * Simple default constructor.
-	 */
-	BcFrame() :
-			byte1(0), byte2(0), vR(0) {
-	}
-	/**
-	 * Main and only useful method of the class.
-	 * With the buffer and size information passed, the class passes the content
-	 * and checks if it is one of the two valid BC Command Frames.
-	 * @param inBuffer	Content of the frame to check,
-	 * @param inSize	Size of the data to check.
-	 * @return 	- #BC_ILLEGAL_COMMAND if it is no command.
-	 * 			- #BC_IS_UNLOCK_COMMAND if it is an unlock command.
-	 * 			- #BC_IS_SET_VR_COMMAND if it is such.
-	 */
-	ReturnValue_t initialize(const uint8_t* inBuffer, uint16_t inSize) {
-		ReturnValue_t returnValue = BC_ILLEGAL_COMMAND;
-		if (inSize == 1) {
-			byte1 = inBuffer[0];
-			if (byte1 == UNLOCK_COMMAND) {
-				returnValue = BC_IS_UNLOCK_COMMAND;
-			}
-		} else if (inSize == 3) {
-			byte1 = inBuffer[0];
-			byte2 = inBuffer[1];
-			vR = inBuffer[2];
-			if (byte1 == SET_V_R_1 && byte2 == SET_V_R_2) {
-				returnValue = BC_IS_SET_VR_COMMAND;
-			}
-		}
-		return returnValue;
-	}
-};
-
-#endif /* BCFRAME_H_ */
+/**
+ * @file	BCFrame.h
+ * @brief	This file defines the BCFrame class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef BCFRAME_H_
+#define BCFRAME_H_
+
+#include "CCSDSReturnValuesIF.h"
+
+/**
+ * Small helper class to identify a BcFrame.
+ * @ingroup ccsds_handling
+ */
+class BcFrame: public CCSDSReturnValuesIF {
+private:
+	static const uint8_t UNLOCK_COMMAND = 0b00000000;//! Identifier for a certain BC Command.
+	static const uint8_t SET_V_R_1 = 0b10000010;//! Identifier for a certain BC Command.
+	static const uint8_t SET_V_R_2 = 0b00000000;//! Identifier for a certain BC Command.
+
+public:
+	uint8_t byte1;	//!< First content byte
+	uint8_t byte2;	//!< Second content byte
+	uint8_t vR;	//!< vR byte
+	/**
+	 * Simple default constructor.
+	 */
+	BcFrame() :
+			byte1(0), byte2(0), vR(0) {
+	}
+	/**
+	 * Main and only useful method of the class.
+	 * With the buffer and size information passed, the class passes the content
+	 * and checks if it is one of the two valid BC Command Frames.
+	 * @param inBuffer	Content of the frame to check,
+	 * @param inSize	Size of the data to check.
+	 * @return 	- #BC_ILLEGAL_COMMAND if it is no command.
+	 * 			- #BC_IS_UNLOCK_COMMAND if it is an unlock command.
+	 * 			- #BC_IS_SET_VR_COMMAND if it is such.
+	 */
+	ReturnValue_t initialize(const uint8_t* inBuffer, uint16_t inSize) {
+		ReturnValue_t returnValue = BC_ILLEGAL_COMMAND;
+		if (inSize == 1) {
+			byte1 = inBuffer[0];
+			if (byte1 == UNLOCK_COMMAND) {
+				returnValue = BC_IS_UNLOCK_COMMAND;
+			}
+		} else if (inSize == 3) {
+			byte1 = inBuffer[0];
+			byte2 = inBuffer[1];
+			vR = inBuffer[2];
+			if (byte1 == SET_V_R_1 && byte2 == SET_V_R_2) {
+				returnValue = BC_IS_SET_VR_COMMAND;
+			}
+		}
+		return returnValue;
+	}
+};
+
+#endif /* BCFRAME_H_ */
diff --git a/datalinklayer/CCSDSReturnValuesIF.h b/datalinklayer/CCSDSReturnValuesIF.h
index 054be9e78..805b6969f 100644
--- a/datalinklayer/CCSDSReturnValuesIF.h
+++ b/datalinklayer/CCSDSReturnValuesIF.h
@@ -1,56 +1,56 @@
-/**
- * @file	CCSDSReturnValuesIF.h
- * @brief	This file defines the CCSDSReturnValuesIF class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef CCSDSRETURNVALUESIF_H_
-#define CCSDSRETURNVALUESIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-/**
- * This is a helper class to collect special return values that come up during CCSDS Handling.
- * @ingroup ccsds_handling
- */
-class CCSDSReturnValuesIF: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER_IF;	//!< Basic ID of the interface.
-
-	static const ReturnValue_t BC_IS_SET_VR_COMMAND = MAKE_RETURN_CODE( 0x01 );	//!< A value to describe a BC frame.
-	static const ReturnValue_t BC_IS_UNLOCK_COMMAND = MAKE_RETURN_CODE( 0x02 );	//!< A value to describe a BC frame.
-	static const ReturnValue_t BC_ILLEGAL_COMMAND = MAKE_RETURN_CODE( 0xB0 );//!< A value to describe an illegal BC frame.
-	static const ReturnValue_t BOARD_READING_NOT_FINISHED = MAKE_RETURN_CODE( 0xB1 );	//! The CCSDS Board is not yet finished reading, it requires another cycle.
-
-	static const ReturnValue_t NS_POSITIVE_W = MAKE_RETURN_CODE( 0xF0 );//!< NS is in the positive window
-	static const ReturnValue_t NS_NEGATIVE_W = MAKE_RETURN_CODE( 0xF1 );//!< NS is in the negative window
-	static const ReturnValue_t NS_LOCKOUT = MAKE_RETURN_CODE( 0xF2 );	//!< NS is in lockout state
-	static const ReturnValue_t FARM_IN_LOCKOUT = MAKE_RETURN_CODE( 0xF3 );//!< FARM-1 is currently in lockout state
-	static const ReturnValue_t FARM_IN_WAIT = MAKE_RETURN_CODE( 0xF4 );	//!< FARM-1 is currently in wait state
-
-	static const ReturnValue_t WRONG_SYMBOL = MAKE_RETURN_CODE( 0xE0 );	//!< An error code in the FrameFinder.
-	static const ReturnValue_t DOUBLE_START = MAKE_RETURN_CODE( 0xE1 );	//!< An error code in the FrameFinder.
-	static const ReturnValue_t START_SYMBOL_MISSED = MAKE_RETURN_CODE( 0xE2 );//!< An error code in the FrameFinder.
-	static const ReturnValue_t END_WITHOUT_START = MAKE_RETURN_CODE( 0xE3 );//!< An error code in the FrameFinder.
-	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE( 0xE4 );//!< An error code for a frame.
-	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE( 0xE5 );//!< An error code for a frame.
-	static const ReturnValue_t WRONG_TF_VERSION = MAKE_RETURN_CODE( 0xE6 );	//!< An error code for a frame.
-	static const ReturnValue_t WRONG_SPACECRAFT_ID = MAKE_RETURN_CODE( 0xE7 );//!< An error code for a frame.
-	static const ReturnValue_t NO_VALID_FRAME_TYPE = MAKE_RETURN_CODE( 0xE8 );//!< An error code for a frame.
-	static const ReturnValue_t CRC_FAILED = MAKE_RETURN_CODE( 0xE9 );//!< An error code for a frame.
-	static const ReturnValue_t VC_NOT_FOUND = MAKE_RETURN_CODE( 0xEA );	//!< An error code for a frame.
-	static const ReturnValue_t FORWARDING_FAILED = MAKE_RETURN_CODE( 0xEB );//!< An error code for a frame.
-	static const ReturnValue_t CONTENT_TOO_LARGE = MAKE_RETURN_CODE( 0xEC );//!< An error code for a frame.
-	static const ReturnValue_t RESIDUAL_DATA = MAKE_RETURN_CODE( 0xED );//!< An error code for a frame.
-	static const ReturnValue_t DATA_CORRUPTED = MAKE_RETURN_CODE( 0xEE );//!< An error code for a frame.
-	static const ReturnValue_t ILLEGAL_SEGMENTATION_FLAG = MAKE_RETURN_CODE( 0xEF );//!< An error code for a frame.
-	static const ReturnValue_t ILLEGAL_FLAG_COMBINATION = MAKE_RETURN_CODE( 0xD0 );	//!< An error code for a frame.
-	static const ReturnValue_t SHORTER_THAN_HEADER = MAKE_RETURN_CODE( 0xD1 );	//!< An error code for a frame.
-	static const ReturnValue_t TOO_SHORT_BLOCKED_PACKET = MAKE_RETURN_CODE( 0xD2 );	//!< An error code for a frame.
-	static const ReturnValue_t TOO_SHORT_MAP_EXTRACTION = MAKE_RETURN_CODE( 0xD3 );	//!< An error code for a frame.
-
-	virtual ~CCSDSReturnValuesIF() {
-	} //!< Empty virtual destructor
-};
-
-#endif /* CCSDSRETURNVALUESIF_H_ */
+/**
+ * @file	CCSDSReturnValuesIF.h
+ * @brief	This file defines the CCSDSReturnValuesIF class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef CCSDSRETURNVALUESIF_H_
+#define CCSDSRETURNVALUESIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ * This is a helper class to collect special return values that come up during CCSDS Handling.
+ * @ingroup ccsds_handling
+ */
+class CCSDSReturnValuesIF: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER_IF;	//!< Basic ID of the interface.
+
+	static const ReturnValue_t BC_IS_SET_VR_COMMAND = MAKE_RETURN_CODE( 0x01 );	//!< A value to describe a BC frame.
+	static const ReturnValue_t BC_IS_UNLOCK_COMMAND = MAKE_RETURN_CODE( 0x02 );	//!< A value to describe a BC frame.
+	static const ReturnValue_t BC_ILLEGAL_COMMAND = MAKE_RETURN_CODE( 0xB0 );//!< A value to describe an illegal BC frame.
+	static const ReturnValue_t BOARD_READING_NOT_FINISHED = MAKE_RETURN_CODE( 0xB1 );	//! The CCSDS Board is not yet finished reading, it requires another cycle.
+
+	static const ReturnValue_t NS_POSITIVE_W = MAKE_RETURN_CODE( 0xF0 );//!< NS is in the positive window
+	static const ReturnValue_t NS_NEGATIVE_W = MAKE_RETURN_CODE( 0xF1 );//!< NS is in the negative window
+	static const ReturnValue_t NS_LOCKOUT = MAKE_RETURN_CODE( 0xF2 );	//!< NS is in lockout state
+	static const ReturnValue_t FARM_IN_LOCKOUT = MAKE_RETURN_CODE( 0xF3 );//!< FARM-1 is currently in lockout state
+	static const ReturnValue_t FARM_IN_WAIT = MAKE_RETURN_CODE( 0xF4 );	//!< FARM-1 is currently in wait state
+
+	static const ReturnValue_t WRONG_SYMBOL = MAKE_RETURN_CODE( 0xE0 );	//!< An error code in the FrameFinder.
+	static const ReturnValue_t DOUBLE_START = MAKE_RETURN_CODE( 0xE1 );	//!< An error code in the FrameFinder.
+	static const ReturnValue_t START_SYMBOL_MISSED = MAKE_RETURN_CODE( 0xE2 );//!< An error code in the FrameFinder.
+	static const ReturnValue_t END_WITHOUT_START = MAKE_RETURN_CODE( 0xE3 );//!< An error code in the FrameFinder.
+	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE( 0xE4 );//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE( 0xE5 );//!< An error code for a frame.
+	static const ReturnValue_t WRONG_TF_VERSION = MAKE_RETURN_CODE( 0xE6 );	//!< An error code for a frame.
+	static const ReturnValue_t WRONG_SPACECRAFT_ID = MAKE_RETURN_CODE( 0xE7 );//!< An error code for a frame.
+	static const ReturnValue_t NO_VALID_FRAME_TYPE = MAKE_RETURN_CODE( 0xE8 );//!< An error code for a frame.
+	static const ReturnValue_t CRC_FAILED = MAKE_RETURN_CODE( 0xE9 );//!< An error code for a frame.
+	static const ReturnValue_t VC_NOT_FOUND = MAKE_RETURN_CODE( 0xEA );	//!< An error code for a frame.
+	static const ReturnValue_t FORWARDING_FAILED = MAKE_RETURN_CODE( 0xEB );//!< An error code for a frame.
+	static const ReturnValue_t CONTENT_TOO_LARGE = MAKE_RETURN_CODE( 0xEC );//!< An error code for a frame.
+	static const ReturnValue_t RESIDUAL_DATA = MAKE_RETURN_CODE( 0xED );//!< An error code for a frame.
+	static const ReturnValue_t DATA_CORRUPTED = MAKE_RETURN_CODE( 0xEE );//!< An error code for a frame.
+	static const ReturnValue_t ILLEGAL_SEGMENTATION_FLAG = MAKE_RETURN_CODE( 0xEF );//!< An error code for a frame.
+	static const ReturnValue_t ILLEGAL_FLAG_COMBINATION = MAKE_RETURN_CODE( 0xD0 );	//!< An error code for a frame.
+	static const ReturnValue_t SHORTER_THAN_HEADER = MAKE_RETURN_CODE( 0xD1 );	//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT_BLOCKED_PACKET = MAKE_RETURN_CODE( 0xD2 );	//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT_MAP_EXTRACTION = MAKE_RETURN_CODE( 0xD3 );	//!< An error code for a frame.
+
+	virtual ~CCSDSReturnValuesIF() {
+	} //!< Empty virtual destructor
+};
+
+#endif /* CCSDSRETURNVALUESIF_H_ */
diff --git a/datalinklayer/Clcw.cpp b/datalinklayer/Clcw.cpp
index 53424e8a1..dc435a2b4 100644
--- a/datalinklayer/Clcw.cpp
+++ b/datalinklayer/Clcw.cpp
@@ -1,63 +1,63 @@
-/**
- * @file	Clcw.cpp
- * @brief	This file defines the Clcw class.
- * @date	17.04.2013
- * @author	baetz
- */
-
-
-
-#include "../datalinklayer/Clcw.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-Clcw::Clcw() {
-	content.raw = 0;
-	content.status = STATUS_FIELD_DEFAULT;
-}
-
-Clcw::~Clcw() {
-}
-
-void Clcw::setVirtualChannel(uint8_t setChannel) {
-	content.virtualChannelIdSpare = ((setChannel & 0x3F) << 2);
-}
-
-void Clcw::setLockoutFlag(bool lockout) {
-	content.flags = (content.flags & LOCKOUT_FLAG_MASK) | (lockout << LOCKOUT_FLAG_POSITION);
-}
-
-void Clcw::setWaitFlag(bool waitFlag) {
-	content.flags = (content.flags & WAIT_FLAG_MASK) | (waitFlag << WAIT_FLAG_POSITION);
-}
-
-void Clcw::setRetransmitFlag(bool retransmitFlag) {
-	content.flags = (content.flags & RETRANSMIT_FLAG_MASK) | (retransmitFlag << RETRANSMIT_FLAG_POSITION);
-}
-
-void Clcw::setFarmBCount(uint8_t count) {
-	content.flags = (content.flags & FARM_B_COUNT_MASK) | ((count & 0x03) << 1);
-}
-
-void Clcw::setReceiverFrameSequenceNumber(uint8_t vR) {
-	content.vRValue = vR;
-}
-
-uint32_t Clcw::getAsWhole() {
-	return content.raw;
-}
-
-void Clcw::setRFAvailable(bool rfAvailable) {
-	content.flags = (content.flags & NO_RF_AVIALABLE_MASK) | (!rfAvailable << NO_RF_AVIALABLE_POSITION);
-}
-
-void Clcw::setBitLock(bool bitLock) {
-	content.flags = (content.flags & NO_BIT_LOCK_MASK) | (!bitLock << NO_BIT_LOCK_POSITION);
-}
-
-void Clcw::print() {
-	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
-}
-
-void Clcw::setWhole(uint32_t rawClcw) {
-	content.raw = rawClcw;
-}
+/**
+ * @file	Clcw.cpp
+ * @brief	This file defines the Clcw class.
+ * @date	17.04.2013
+ * @author	baetz
+ */
+
+
+
+#include "Clcw.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+Clcw::Clcw() {
+	content.raw = 0;
+	content.status = STATUS_FIELD_DEFAULT;
+}
+
+Clcw::~Clcw() {
+}
+
+void Clcw::setVirtualChannel(uint8_t setChannel) {
+	content.virtualChannelIdSpare = ((setChannel & 0x3F) << 2);
+}
+
+void Clcw::setLockoutFlag(bool lockout) {
+	content.flags = (content.flags & LOCKOUT_FLAG_MASK) | (lockout << LOCKOUT_FLAG_POSITION);
+}
+
+void Clcw::setWaitFlag(bool waitFlag) {
+	content.flags = (content.flags & WAIT_FLAG_MASK) | (waitFlag << WAIT_FLAG_POSITION);
+}
+
+void Clcw::setRetransmitFlag(bool retransmitFlag) {
+	content.flags = (content.flags & RETRANSMIT_FLAG_MASK) | (retransmitFlag << RETRANSMIT_FLAG_POSITION);
+}
+
+void Clcw::setFarmBCount(uint8_t count) {
+	content.flags = (content.flags & FARM_B_COUNT_MASK) | ((count & 0x03) << 1);
+}
+
+void Clcw::setReceiverFrameSequenceNumber(uint8_t vR) {
+	content.vRValue = vR;
+}
+
+uint32_t Clcw::getAsWhole() {
+	return content.raw;
+}
+
+void Clcw::setRFAvailable(bool rfAvailable) {
+	content.flags = (content.flags & NO_RF_AVIALABLE_MASK) | (!rfAvailable << NO_RF_AVIALABLE_POSITION);
+}
+
+void Clcw::setBitLock(bool bitLock) {
+	content.flags = (content.flags & NO_BIT_LOCK_MASK) | (!bitLock << NO_BIT_LOCK_POSITION);
+}
+
+void Clcw::print() {
+	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
+}
+
+void Clcw::setWhole(uint32_t rawClcw) {
+	content.raw = rawClcw;
+}
diff --git a/datalinklayer/Clcw.h b/datalinklayer/Clcw.h
index 72ccd77ac..8116d63b6 100644
--- a/datalinklayer/Clcw.h
+++ b/datalinklayer/Clcw.h
@@ -1,66 +1,66 @@
-/**
- * @file	Clcw.h
- * @brief	This file defines the Clcw class.
- * @date	17.04.2013
- * @author	baetz
- */
-
-#ifndef CLCW_H_
-#define CLCW_H_
-
-#include "../datalinklayer/ClcwIF.h"
-/**
- * Small helper method to handle the Clcw values.
- * It has a content struct that manages the register and can be set externally.
- * @ingroup ccsds_handling
- */
-class Clcw : public ClcwIF {
-private:
-	static const uint8_t STATUS_FIELD_DEFAULT = 0b00000001; //!< Default for the status field.
-	static const uint8_t NO_RF_AVIALABLE_POSITION = 7;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t NO_BIT_LOCK_POSITION = 6;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t LOCKOUT_FLAG_POSITION = 5;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t WAIT_FLAG_POSITION = 4;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t RETRANSMIT_FLAG_POSITION = 3;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t NO_RF_AVIALABLE_MASK = 0xFF xor (1 << NO_RF_AVIALABLE_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t NO_BIT_LOCK_MASK = 0xFF xor (1 << NO_BIT_LOCK_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t LOCKOUT_FLAG_MASK = 0xFF xor (1 << LOCKOUT_FLAG_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t WAIT_FLAG_MASK = 0xFF xor (1 << WAIT_FLAG_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t RETRANSMIT_FLAG_MASK = 0xFF xor (1 << RETRANSMIT_FLAG_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t FARM_B_COUNT_MASK = 0b11111001;	//!< Mask for a counter in the register.
-	/**
-	 * This is the data structure of the CLCW register.
-	 */
-	union clcwContent {
-		uint32_t raw;
-		struct {
-			uint8_t status;
-			uint8_t virtualChannelIdSpare;
-			uint8_t flags;
-			uint8_t vRValue;
-		};
-	};
-	clcwContent content;	//!< Represents the content of the register.
-public:
-	/**
-	 * The constructor sets everything to default values.
-	 */
-	Clcw();
-	/**
-	 * Nothing happens in the destructor.
-	 */
-	~Clcw();
-	void setVirtualChannel( uint8_t setChannel );
-	void setLockoutFlag( bool lockout );
-	void setWaitFlag( bool waitFlag );
-	void setRetransmitFlag( bool retransmitFlag );
-	void setFarmBCount( uint8_t count );
-	void setReceiverFrameSequenceNumber( uint8_t vR );
-	void setRFAvailable( bool rfAvailable );
-	void setBitLock( bool bitLock );
-	uint32_t getAsWhole();
-	void setWhole( uint32_t rawClcw );
-	void print();
-};
-
-#endif /* CLCW_H_ */
+/**
+ * @file	Clcw.h
+ * @brief	This file defines the Clcw class.
+ * @date	17.04.2013
+ * @author	baetz
+ */
+
+#ifndef CLCW_H_
+#define CLCW_H_
+
+#include "ClcwIF.h"
+/**
+ * Small helper method to handle the Clcw values.
+ * It has a content struct that manages the register and can be set externally.
+ * @ingroup ccsds_handling
+ */
+class Clcw : public ClcwIF {
+private:
+	static const uint8_t STATUS_FIELD_DEFAULT = 0b00000001; //!< Default for the status field.
+	static const uint8_t NO_RF_AVIALABLE_POSITION = 7;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t NO_BIT_LOCK_POSITION = 6;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t LOCKOUT_FLAG_POSITION = 5;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t WAIT_FLAG_POSITION = 4;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t RETRANSMIT_FLAG_POSITION = 3;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t NO_RF_AVIALABLE_MASK = 0xFF xor (1 << NO_RF_AVIALABLE_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t NO_BIT_LOCK_MASK = 0xFF xor (1 << NO_BIT_LOCK_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t LOCKOUT_FLAG_MASK = 0xFF xor (1 << LOCKOUT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t WAIT_FLAG_MASK = 0xFF xor (1 << WAIT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t RETRANSMIT_FLAG_MASK = 0xFF xor (1 << RETRANSMIT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t FARM_B_COUNT_MASK = 0b11111001;	//!< Mask for a counter in the register.
+	/**
+	 * This is the data structure of the CLCW register.
+	 */
+	union clcwContent {
+		uint32_t raw;
+		struct {
+			uint8_t status;
+			uint8_t virtualChannelIdSpare;
+			uint8_t flags;
+			uint8_t vRValue;
+		};
+	};
+	clcwContent content;	//!< Represents the content of the register.
+public:
+	/**
+	 * The constructor sets everything to default values.
+	 */
+	Clcw();
+	/**
+	 * Nothing happens in the destructor.
+	 */
+	~Clcw();
+	void setVirtualChannel( uint8_t setChannel );
+	void setLockoutFlag( bool lockout );
+	void setWaitFlag( bool waitFlag );
+	void setRetransmitFlag( bool retransmitFlag );
+	void setFarmBCount( uint8_t count );
+	void setReceiverFrameSequenceNumber( uint8_t vR );
+	void setRFAvailable( bool rfAvailable );
+	void setBitLock( bool bitLock );
+	uint32_t getAsWhole();
+	void setWhole( uint32_t rawClcw );
+	void print();
+};
+
+#endif /* CLCW_H_ */
diff --git a/datalinklayer/DataLinkLayer.cpp b/datalinklayer/DataLinkLayer.cpp
index 83fe1e612..75f2edda0 100644
--- a/datalinklayer/DataLinkLayer.cpp
+++ b/datalinklayer/DataLinkLayer.cpp
@@ -1,139 +1,139 @@
-#include "../datalinklayer/DataLinkLayer.h"
-#include "../globalfunctions/CRC.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-DataLinkLayer::DataLinkLayer(uint8_t* set_frame_buffer, ClcwIF* setClcw,
-		uint8_t set_start_sequence_length, uint16_t set_scid) :
-		spacecraftId(set_scid), frameBuffer(set_frame_buffer), clcw(setClcw), receivedDataLength(0), currentFrame(
-				NULL), startSequenceLength(set_start_sequence_length) {
-	//Nothing to do except from setting the values above.
-}
-
-DataLinkLayer::~DataLinkLayer() {
-
-}
-
-ReturnValue_t DataLinkLayer::frameDelimitingAndFillRemoval() {
-	if ((receivedDataLength - startSequenceLength) < FRAME_PRIMARY_HEADER_LENGTH) {
-		return SHORTER_THAN_HEADER;
-	}
-	//Removing start sequence.
-	//SHOULDDO: Not implemented here.
-	while ( *frameBuffer == START_SEQUENCE_PATTERN ) {
-		frameBuffer++;
-	}
-	TcTransferFrame frame_candidate(frameBuffer);
-	this->currentFrame = frame_candidate; //should work with shallow copy.
-
-	return RETURN_OK;
-}
-
-ReturnValue_t DataLinkLayer::frameValidationCheck() {
-	//Check TF_version number
-	if (this->currentFrame.getVersionNumber() != FRAME_VERSION_NUMBER_DEFAULT) {
-		return WRONG_TF_VERSION;
-	}
-	//Check SpaceCraft ID
-	if (this->currentFrame.getSpacecraftId() != this->spacecraftId) {
-		return WRONG_SPACECRAFT_ID;
-	}
-	//Check other header limitations:
-	if (!this->currentFrame.bypassFlagSet() && this->currentFrame.controlCommandFlagSet()) {
-		return NO_VALID_FRAME_TYPE;
-	}
-	//- Spares are zero
-	if (!this->currentFrame.spareIsZero()) {
-		return NO_VALID_FRAME_TYPE;
-	}
-	//Compare detected frame length with the one in the header
-	uint16_t length = currentFrame.getFullSize();
-	if (length > receivedDataLength) {
-		//Frame is too long or just right
-//		error << "frameValidationCheck: Too short.";
-//		currentFrame.print();
-		return TOO_SHORT;
-	}
-	if (USE_CRC) {
-		return this->frameCheckCRC();
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t DataLinkLayer::frameCheckCRC() {
-	uint16_t checkValue = CRC::crc16ccitt(this->currentFrame.getFullFrame(),
-			this->currentFrame.getFullSize());
-	if (checkValue == 0) {
-		return RETURN_OK;
-	} else {
-		return CRC_FAILED;
-	}
-
-}
-
-ReturnValue_t DataLinkLayer::allFramesReception() {
-	ReturnValue_t status = this->frameDelimitingAndFillRemoval();
-	if (status != RETURN_OK) {
-		return status;
-	}
-	return this->frameValidationCheck();
-}
-
-ReturnValue_t DataLinkLayer::masterChannelDemultiplexing() {
-	//Nothing to do at present. Ideally, there would be a map of MCID's identifying which MC to use.
-	return virtualChannelDemultiplexing();
-}
-
-ReturnValue_t DataLinkLayer::virtualChannelDemultiplexing() {
-	uint8_t vcId = currentFrame.getVirtualChannelId();
-	virtualChannelIterator iter = virtualChannels.find(vcId);
-	if (iter == virtualChannels.end()) {
-		//Do not report because passive board will get this error all the time.
-		return RETURN_OK;
-	} else {
-		return (iter->second)->frameAcceptanceAndReportingMechanism(&currentFrame, clcw);
-	}
-}
-
-ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
-	receivedDataLength = length;
-	ReturnValue_t status = allFramesReception();
-	if (status != RETURN_OK) {
-		sif::error << "DataLinkLayer::processFrame: frame reception failed. "
-		         "Error code: " << std::hex << status << std::dec << std::endl;
-//		currentFrame.print();
-		return status;
-	} else {
-		return masterChannelDemultiplexing();
-	}
-}
-
-ReturnValue_t DataLinkLayer::addVirtualChannel(uint8_t virtualChannelId,
-		VirtualChannelReceptionIF* object) {
-	std::pair<virtualChannelIterator, bool> returnValue = virtualChannels.insert(
-			std::pair<uint8_t, VirtualChannelReceptionIF*>(virtualChannelId, object));
-	if (returnValue.second == true) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t DataLinkLayer::initialize() {
-	ReturnValue_t returnValue = RETURN_FAILED;
-	//Set Virtual Channel ID to first virtual channel instance in this DataLinkLayer instance to avoid faulty information (e.g. 0) in the VCID.
-	if ( virtualChannels.begin() != virtualChannels.end() ) {
-		clcw->setVirtualChannel( virtualChannels.begin()->second->getChannelId() );
-	} else {
-		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
-		return RETURN_FAILED;
-	}
-
-	for (virtualChannelIterator iterator = virtualChannels.begin();
-			iterator != virtualChannels.end(); iterator++) {
-		returnValue = iterator->second->initialize();
-		if (returnValue != RETURN_OK)
-			break;
-	}
-	return returnValue;
-
-}
+#include "DataLinkLayer.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+DataLinkLayer::DataLinkLayer(uint8_t* set_frame_buffer, ClcwIF* setClcw,
+		uint8_t set_start_sequence_length, uint16_t set_scid) :
+		spacecraftId(set_scid), frameBuffer(set_frame_buffer), clcw(setClcw), receivedDataLength(0), currentFrame(
+				NULL), startSequenceLength(set_start_sequence_length) {
+	//Nothing to do except from setting the values above.
+}
+
+DataLinkLayer::~DataLinkLayer() {
+
+}
+
+ReturnValue_t DataLinkLayer::frameDelimitingAndFillRemoval() {
+	if ((receivedDataLength - startSequenceLength) < FRAME_PRIMARY_HEADER_LENGTH) {
+		return SHORTER_THAN_HEADER;
+	}
+	//Removing start sequence.
+	//SHOULDDO: Not implemented here.
+	while ( *frameBuffer == START_SEQUENCE_PATTERN ) {
+		frameBuffer++;
+	}
+	TcTransferFrame frame_candidate(frameBuffer);
+	this->currentFrame = frame_candidate; //should work with shallow copy.
+
+	return RETURN_OK;
+}
+
+ReturnValue_t DataLinkLayer::frameValidationCheck() {
+	//Check TF_version number
+	if (this->currentFrame.getVersionNumber() != FRAME_VERSION_NUMBER_DEFAULT) {
+		return WRONG_TF_VERSION;
+	}
+	//Check SpaceCraft ID
+	if (this->currentFrame.getSpacecraftId() != this->spacecraftId) {
+		return WRONG_SPACECRAFT_ID;
+	}
+	//Check other header limitations:
+	if (!this->currentFrame.bypassFlagSet() && this->currentFrame.controlCommandFlagSet()) {
+		return NO_VALID_FRAME_TYPE;
+	}
+	//- Spares are zero
+	if (!this->currentFrame.spareIsZero()) {
+		return NO_VALID_FRAME_TYPE;
+	}
+	//Compare detected frame length with the one in the header
+	uint16_t length = currentFrame.getFullSize();
+	if (length > receivedDataLength) {
+		//Frame is too long or just right
+//		error << "frameValidationCheck: Too short.";
+//		currentFrame.print();
+		return TOO_SHORT;
+	}
+	if (USE_CRC) {
+		return this->frameCheckCRC();
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t DataLinkLayer::frameCheckCRC() {
+	uint16_t checkValue = CRC::crc16ccitt(this->currentFrame.getFullFrame(),
+			this->currentFrame.getFullSize());
+	if (checkValue == 0) {
+		return RETURN_OK;
+	} else {
+		return CRC_FAILED;
+	}
+
+}
+
+ReturnValue_t DataLinkLayer::allFramesReception() {
+	ReturnValue_t status = this->frameDelimitingAndFillRemoval();
+	if (status != RETURN_OK) {
+		return status;
+	}
+	return this->frameValidationCheck();
+}
+
+ReturnValue_t DataLinkLayer::masterChannelDemultiplexing() {
+	//Nothing to do at present. Ideally, there would be a map of MCID's identifying which MC to use.
+	return virtualChannelDemultiplexing();
+}
+
+ReturnValue_t DataLinkLayer::virtualChannelDemultiplexing() {
+	uint8_t vcId = currentFrame.getVirtualChannelId();
+	virtualChannelIterator iter = virtualChannels.find(vcId);
+	if (iter == virtualChannels.end()) {
+		//Do not report because passive board will get this error all the time.
+		return RETURN_OK;
+	} else {
+		return (iter->second)->frameAcceptanceAndReportingMechanism(&currentFrame, clcw);
+	}
+}
+
+ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
+	receivedDataLength = length;
+	ReturnValue_t status = allFramesReception();
+	if (status != RETURN_OK) {
+		sif::error << "DataLinkLayer::processFrame: frame reception failed. "
+		         "Error code: " << std::hex << status << std::dec << std::endl;
+//		currentFrame.print();
+		return status;
+	} else {
+		return masterChannelDemultiplexing();
+	}
+}
+
+ReturnValue_t DataLinkLayer::addVirtualChannel(uint8_t virtualChannelId,
+		VirtualChannelReceptionIF* object) {
+	std::pair<virtualChannelIterator, bool> returnValue = virtualChannels.insert(
+			std::pair<uint8_t, VirtualChannelReceptionIF*>(virtualChannelId, object));
+	if (returnValue.second == true) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t DataLinkLayer::initialize() {
+	ReturnValue_t returnValue = RETURN_FAILED;
+	//Set Virtual Channel ID to first virtual channel instance in this DataLinkLayer instance to avoid faulty information (e.g. 0) in the VCID.
+	if ( virtualChannels.begin() != virtualChannels.end() ) {
+		clcw->setVirtualChannel( virtualChannels.begin()->second->getChannelId() );
+	} else {
+		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
+		return RETURN_FAILED;
+	}
+
+	for (virtualChannelIterator iterator = virtualChannels.begin();
+			iterator != virtualChannels.end(); iterator++) {
+		returnValue = iterator->second->initialize();
+		if (returnValue != RETURN_OK)
+			break;
+	}
+	return returnValue;
+
+}
diff --git a/datalinklayer/DataLinkLayer.h b/datalinklayer/DataLinkLayer.h
index cf5cf42e5..5a900099e 100644
--- a/datalinklayer/DataLinkLayer.h
+++ b/datalinklayer/DataLinkLayer.h
@@ -1,112 +1,112 @@
-#ifndef DATALINKLAYER_H_
-#define DATALINKLAYER_H_
-
-#include "../datalinklayer/CCSDSReturnValuesIF.h"
-#include "../datalinklayer/ClcwIF.h"
-#include "../datalinklayer/TcTransferFrame.h"
-#include "../datalinklayer/VirtualChannelReceptionIF.h"
-#include "../events/Event.h"
-#include <map>
-
-
-class VirtualChannelReception;
-/**
- * A complete representation of the CCSDS Data Link Layer.
- * The operations of this layer are defined in the CCSDS TC Space Data Link Protocol
- * document. It is configured to handle a VC Demultiplexing function. All reception
- * steps are performed.
- */
-class DataLinkLayer : public CCSDSReturnValuesIF {
-public:
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_1;
-	static const Event RF_AVAILABLE = MAKE_EVENT(0, SEVERITY::INFO); //!< A RF available signal was detected. P1: raw RFA state, P2: 0
-	static const Event RF_LOST = MAKE_EVENT(1, SEVERITY::INFO); //!< A previously found RF available signal was lost. P1: raw RFA state, P2: 0
-	static const Event BIT_LOCK = MAKE_EVENT(2, SEVERITY::INFO); //!< A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0
-	static const Event BIT_LOCK_LOST = MAKE_EVENT(3, SEVERITY::INFO); //!< A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
-//	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, SEVERITY::INFO); //!< The CCSDS Board detected that either bit lock or RF available or both are lost. No parameters.
-	static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< The CCSDS Board could not interpret a TC
-	/**
-	 * The Constructor sets the passed parameters and nothing else.
-	 * @param set_frame_buffer The buffer in which incoming frame candidates are stored.
-	 * @param setClcw	The CLCW class to work on when returning CLCW information.
-	 * @param set_start_sequence_length	Length of the Start sequence in front of every TC Transfer Frame.
-	 * @param set_scid	The SCID to operate on.
-	 */
-	DataLinkLayer( uint8_t* set_frame_buffer, ClcwIF* setClcw, uint8_t set_start_sequence_length, uint16_t set_scid );
-	/**
-	 * Empty virtual destructor.
-	 */
-	~DataLinkLayer();
-	/**
-	 * This method tries to process a frame that is placed in #frameBuffer.
-	 * The procedures described in the Standard are performed.
-	 * @param length	Length of the incoming frame candidate.
-	 * @return	@c RETURN_OK on successful handling, otherwise the return codes of the higher methods.
-	 */
-	ReturnValue_t processFrame( uint16_t length );
-	/**
-	 * Configuration method to add a new TC Virtual Channel.
-	 * Shall only be called during initialization. As soon as the method was called, the layer can
-	 * handle Frames directed to this VC.
-	 * @param virtualChannelId	Id of the VC. Shall be smaller than 64.
-	 * @param object	Reference to the object that handles the Frame.
-	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t addVirtualChannel( uint8_t virtualChannelId, VirtualChannelReceptionIF* object );
-	/**
-	 * The initialization method calls the @c initialize routine of all virtual channels.
-	 * @return The return code of the first failed VC initialization or @c RETURN_OK.
-	 */
-	ReturnValue_t initialize();
-private:
-	typedef std::map<uint8_t, VirtualChannelReceptionIF*>::iterator virtualChannelIterator; //!< Typedef to simplify handling the #virtualChannels map.
-	static const uint8_t FRAME_VERSION_NUMBER_DEFAULT = 0x00;	//!< Constant for the default value of Frame Version Numbers.
-	static const uint8_t FRAME_PRIMARY_HEADER_LENGTH = 5;	//!< Length of the frame's primary header.
-	static const uint8_t START_SEQUENCE_PATTERN = 0x00; //!< The start sequence pattern which might be with the frame.
-	static const bool USE_CRC = true;	//!< A global, so called "Managed Parameter" that identifies if incoming frames have CRC's or not.
-	uint16_t spacecraftId;	//!< The Space Craft Identifier (SCID) configured.
-	uint8_t* frameBuffer;	//!< A pointer to point to the current incoming frame.
-	ClcwIF* clcw;	//!< Pointer to store the CLCW to work on.
-	uint16_t receivedDataLength;	//!< Stores the length of the currently processed frame.
-	TcTransferFrame currentFrame;	//!< Stores a more convenient access to the current frame.
-	uint8_t startSequenceLength;	//!< Configured length of the start sequence. Maybe this must be done more variable.
-	std::map<uint8_t, VirtualChannelReceptionIF*> virtualChannels;	//!< Map of all virtual channels assigned.
-	/**
-	 * Method that performs all possible frame validity checks (as specified).
-	 * @return	Various error codes or @c RETURN_OK on success.
-	 */
-	ReturnValue_t frameValidationCheck();
-	/**
-	 * First method to call.
-	 * Removes start sequence bytes and checks if the complete frame was received.
-	 * SHOULDDO: Maybe handling the start sequence must be done more variable.
-	 * @return @c RETURN_OK or @c TOO_SHORT.
-	 */
-	ReturnValue_t frameDelimitingAndFillRemoval();
-	/**
-	 * Small helper method to check the CRC of the Frame.
-	 * @return @c RETURN_OK or @c CRC_FAILED.
-	 */
-	ReturnValue_t frameCheckCRC();
-	/**
-	 * Method that groups the reception process of all Frames.
-	 * Calls #frameDelimitingAndFillRemoval and #frameValidationCheck.
-	 * @return The return codes of the sub calls.
-	 */
-	ReturnValue_t allFramesReception();
-	/**
-	 * Dummy method for master channel demultiplexing.
-	 * As there's only one Master Channel here, the method calls #virtualChannelDemultiplexing.
-	 * @return	The return codes of #virtualChannelDemultiplexing.
-	 */
-	ReturnValue_t masterChannelDemultiplexing();
-	/**
-	 * Method to demultiplex the Frames to Virtual Channels (VC's).
-	 * Looks up the requested VC in #virtualChannels and forwards the Frame to its
-	 * #frameAcceptanceAndReportingMechanism method, if found.
-	 * @return The higher method codes or @c VC_NOT_FOUND.
-	 */
-	ReturnValue_t virtualChannelDemultiplexing();
-};
-
-#endif /* DATALINKLAYER_H_ */
+#ifndef DATALINKLAYER_H_
+#define DATALINKLAYER_H_
+
+#include "CCSDSReturnValuesIF.h"
+#include "ClcwIF.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReceptionIF.h"
+#include "../events/Event.h"
+#include <map>
+
+
+class VirtualChannelReception;
+/**
+ * A complete representation of the CCSDS Data Link Layer.
+ * The operations of this layer are defined in the CCSDS TC Space Data Link Protocol
+ * document. It is configured to handle a VC Demultiplexing function. All reception
+ * steps are performed.
+ */
+class DataLinkLayer : public CCSDSReturnValuesIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_1;
+	static const Event RF_AVAILABLE = MAKE_EVENT(0, SEVERITY::INFO); //!< A RF available signal was detected. P1: raw RFA state, P2: 0
+	static const Event RF_LOST = MAKE_EVENT(1, SEVERITY::INFO); //!< A previously found RF available signal was lost. P1: raw RFA state, P2: 0
+	static const Event BIT_LOCK = MAKE_EVENT(2, SEVERITY::INFO); //!< A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0
+	static const Event BIT_LOCK_LOST = MAKE_EVENT(3, SEVERITY::INFO); //!< A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
+//	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, SEVERITY::INFO); //!< The CCSDS Board detected that either bit lock or RF available or both are lost. No parameters.
+	static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< The CCSDS Board could not interpret a TC
+	/**
+	 * The Constructor sets the passed parameters and nothing else.
+	 * @param set_frame_buffer The buffer in which incoming frame candidates are stored.
+	 * @param setClcw	The CLCW class to work on when returning CLCW information.
+	 * @param set_start_sequence_length	Length of the Start sequence in front of every TC Transfer Frame.
+	 * @param set_scid	The SCID to operate on.
+	 */
+	DataLinkLayer( uint8_t* set_frame_buffer, ClcwIF* setClcw, uint8_t set_start_sequence_length, uint16_t set_scid );
+	/**
+	 * Empty virtual destructor.
+	 */
+	~DataLinkLayer();
+	/**
+	 * This method tries to process a frame that is placed in #frameBuffer.
+	 * The procedures described in the Standard are performed.
+	 * @param length	Length of the incoming frame candidate.
+	 * @return	@c RETURN_OK on successful handling, otherwise the return codes of the higher methods.
+	 */
+	ReturnValue_t processFrame( uint16_t length );
+	/**
+	 * Configuration method to add a new TC Virtual Channel.
+	 * Shall only be called during initialization. As soon as the method was called, the layer can
+	 * handle Frames directed to this VC.
+	 * @param virtualChannelId	Id of the VC. Shall be smaller than 64.
+	 * @param object	Reference to the object that handles the Frame.
+	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t addVirtualChannel( uint8_t virtualChannelId, VirtualChannelReceptionIF* object );
+	/**
+	 * The initialization method calls the @c initialize routine of all virtual channels.
+	 * @return The return code of the first failed VC initialization or @c RETURN_OK.
+	 */
+	ReturnValue_t initialize();
+private:
+	typedef std::map<uint8_t, VirtualChannelReceptionIF*>::iterator virtualChannelIterator; //!< Typedef to simplify handling the #virtualChannels map.
+	static const uint8_t FRAME_VERSION_NUMBER_DEFAULT = 0x00;	//!< Constant for the default value of Frame Version Numbers.
+	static const uint8_t FRAME_PRIMARY_HEADER_LENGTH = 5;	//!< Length of the frame's primary header.
+	static const uint8_t START_SEQUENCE_PATTERN = 0x00; //!< The start sequence pattern which might be with the frame.
+	static const bool USE_CRC = true;	//!< A global, so called "Managed Parameter" that identifies if incoming frames have CRC's or not.
+	uint16_t spacecraftId;	//!< The Space Craft Identifier (SCID) configured.
+	uint8_t* frameBuffer;	//!< A pointer to point to the current incoming frame.
+	ClcwIF* clcw;	//!< Pointer to store the CLCW to work on.
+	uint16_t receivedDataLength;	//!< Stores the length of the currently processed frame.
+	TcTransferFrame currentFrame;	//!< Stores a more convenient access to the current frame.
+	uint8_t startSequenceLength;	//!< Configured length of the start sequence. Maybe this must be done more variable.
+	std::map<uint8_t, VirtualChannelReceptionIF*> virtualChannels;	//!< Map of all virtual channels assigned.
+	/**
+	 * Method that performs all possible frame validity checks (as specified).
+	 * @return	Various error codes or @c RETURN_OK on success.
+	 */
+	ReturnValue_t frameValidationCheck();
+	/**
+	 * First method to call.
+	 * Removes start sequence bytes and checks if the complete frame was received.
+	 * SHOULDDO: Maybe handling the start sequence must be done more variable.
+	 * @return @c RETURN_OK or @c TOO_SHORT.
+	 */
+	ReturnValue_t frameDelimitingAndFillRemoval();
+	/**
+	 * Small helper method to check the CRC of the Frame.
+	 * @return @c RETURN_OK or @c CRC_FAILED.
+	 */
+	ReturnValue_t frameCheckCRC();
+	/**
+	 * Method that groups the reception process of all Frames.
+	 * Calls #frameDelimitingAndFillRemoval and #frameValidationCheck.
+	 * @return The return codes of the sub calls.
+	 */
+	ReturnValue_t allFramesReception();
+	/**
+	 * Dummy method for master channel demultiplexing.
+	 * As there's only one Master Channel here, the method calls #virtualChannelDemultiplexing.
+	 * @return	The return codes of #virtualChannelDemultiplexing.
+	 */
+	ReturnValue_t masterChannelDemultiplexing();
+	/**
+	 * Method to demultiplex the Frames to Virtual Channels (VC's).
+	 * Looks up the requested VC in #virtualChannels and forwards the Frame to its
+	 * #frameAcceptanceAndReportingMechanism method, if found.
+	 * @return The higher method codes or @c VC_NOT_FOUND.
+	 */
+	ReturnValue_t virtualChannelDemultiplexing();
+};
+
+#endif /* DATALINKLAYER_H_ */
diff --git a/datalinklayer/Farm1StateIF.h b/datalinklayer/Farm1StateIF.h
index ef02d891e..71794d75e 100644
--- a/datalinklayer/Farm1StateIF.h
+++ b/datalinklayer/Farm1StateIF.h
@@ -1,54 +1,54 @@
-/**
- * @file	Farm1StateIF.h
- * @brief	This file defines the Farm1StateIF class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATEIF_H_
-#define FARM1STATEIF_H_
-
-#include "../datalinklayer/CCSDSReturnValuesIF.h"
-class VirtualChannelReception;
-class TcTransferFrame;
-class ClcwIF;
-
-/**
- * This is the interface for states of the FARM-1 state machine.
- * Classes implementing this interface can be used as FARM-1 states. This is a simple implementation
- * of the state pattern.
- */
-class Farm1StateIF : public CCSDSReturnValuesIF {
-public:
-	/**
-	 * A method that shall handle an incoming frame as AD Frame.
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
-	 * 			Otherwise, an appropriate return value or error code shall be generated.
-	 */
-	virtual ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
-	/**
-	 * This method shall handle frames that have been successfully identified as BC Unlock frames.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
-	 * 			Otherwise, an appropriate return value or error code shall be generated.
-	 */
-	virtual ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw ) = 0;
-	/**
-	 * This method shall handle frames that have been successfully identified as BC Set VR frames.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
-	 * 			Otherwise, an appropriate return value or error code shall be generated.
-	 */
-	virtual ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) = 0;
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~Farm1StateIF() {
-
-	}
-};
-
-#endif /* FARM1STATEIF_H_ */
+/**
+ * @file	Farm1StateIF.h
+ * @brief	This file defines the Farm1StateIF class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEIF_H_
+#define FARM1STATEIF_H_
+
+#include "CCSDSReturnValuesIF.h"
+class VirtualChannelReception;
+class TcTransferFrame;
+class ClcwIF;
+
+/**
+ * This is the interface for states of the FARM-1 state machine.
+ * Classes implementing this interface can be used as FARM-1 states. This is a simple implementation
+ * of the state pattern.
+ */
+class Farm1StateIF : public CCSDSReturnValuesIF {
+public:
+	/**
+	 * A method that shall handle an incoming frame as AD Frame.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
+	/**
+	 * This method shall handle frames that have been successfully identified as BC Unlock frames.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw ) = 0;
+	/**
+	 * This method shall handle frames that have been successfully identified as BC Set VR frames.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) = 0;
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~Farm1StateIF() {
+
+	}
+};
+
+#endif /* FARM1STATEIF_H_ */
diff --git a/datalinklayer/Farm1StateLockout.cpp b/datalinklayer/Farm1StateLockout.cpp
index f8dca9fdc..1b339a85f 100644
--- a/datalinklayer/Farm1StateLockout.cpp
+++ b/datalinklayer/Farm1StateLockout.cpp
@@ -1,35 +1,35 @@
-/**
- * @file	Farm1StateLockout.cpp
- * @brief	This file defines the Farm1StateLockout class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-
-
-#include "../datalinklayer/ClcwIF.h"
-#include "../datalinklayer/Farm1StateLockout.h"
-#include "../datalinklayer/TcTransferFrame.h"
-#include "../datalinklayer/VirtualChannelReception.h"
-Farm1StateLockout::Farm1StateLockout(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
-}
-
-ReturnValue_t Farm1StateLockout::handleADFrame(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-	return FARM_IN_LOCKOUT;
-}
-
-ReturnValue_t Farm1StateLockout::handleBCUnlockCommand(ClcwIF* clcw) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	clcw->setLockoutFlag( false );
-	clcw->setWaitFlag( false );
-	myVC->currentState = &(myVC->openState);
-	return BC_IS_UNLOCK_COMMAND;
-}
-
-ReturnValue_t Farm1StateLockout::handleBCSetVrCommand(ClcwIF* clcw,
-		uint8_t vr) {
-	myVC->farmBCounter++;
-	return BC_IS_SET_VR_COMMAND;
-}
+/**
+ * @file	Farm1StateLockout.cpp
+ * @brief	This file defines the Farm1StateLockout class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+
+
+#include "ClcwIF.h"
+#include "Farm1StateLockout.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReception.h"
+Farm1StateLockout::Farm1StateLockout(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
+}
+
+ReturnValue_t Farm1StateLockout::handleADFrame(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+	return FARM_IN_LOCKOUT;
+}
+
+ReturnValue_t Farm1StateLockout::handleBCUnlockCommand(ClcwIF* clcw) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	clcw->setLockoutFlag( false );
+	clcw->setWaitFlag( false );
+	myVC->currentState = &(myVC->openState);
+	return BC_IS_UNLOCK_COMMAND;
+}
+
+ReturnValue_t Farm1StateLockout::handleBCSetVrCommand(ClcwIF* clcw,
+		uint8_t vr) {
+	myVC->farmBCounter++;
+	return BC_IS_SET_VR_COMMAND;
+}
diff --git a/datalinklayer/Farm1StateLockout.h b/datalinklayer/Farm1StateLockout.h
index 9e3713ccd..63cdc4d2b 100644
--- a/datalinklayer/Farm1StateLockout.h
+++ b/datalinklayer/Farm1StateLockout.h
@@ -1,59 +1,59 @@
-/**
- * @file	Farm1StateLockout.h
- * @brief	This file defines the Farm1StateLockout class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATELOCKOUT_H_
-#define FARM1STATELOCKOUT_H_
-
-#include "../datalinklayer/Farm1StateIF.h"
-
-/**
- * This class represents the FARM-1 "Lockout" State.
- * The Lockout state is reached if the received Transfer Frame Sequence Number is completely wrong
- * (i.e. within the Lockout Window). No AD Frames are forwarded. To leave the State, a BC Unlock
- * command is required.
- */
-class Farm1StateLockout : public Farm1StateIF {
-private:
-	/**
-	 * This is a reference to the "owner" class the State works on.
-	 */
-	VirtualChannelReception* myVC;
-public:
-	/**
-	 * The default constructor if the State.
-	 * Sets the "owner" of the State.
-	 * @param setMyVC	The "owner" class.
-	 */
-	Farm1StateLockout( VirtualChannelReception* setMyVC );
-	/**
-	 * All AD Frames are rejected with FARM_IN_LOCKOUT
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return FARM_IN_LOCKOUT
-	 */
-	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State changes to Farm1StateOpen.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * The V(r) value is not set in Lockout State, even though the Command itself is accepted.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
-};
-
-
-#endif /* FARM1STATELOCKOUT_H_ */
+/**
+ * @file	Farm1StateLockout.h
+ * @brief	This file defines the Farm1StateLockout class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATELOCKOUT_H_
+#define FARM1STATELOCKOUT_H_
+
+#include "Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Lockout" State.
+ * The Lockout state is reached if the received Transfer Frame Sequence Number is completely wrong
+ * (i.e. within the Lockout Window). No AD Frames are forwarded. To leave the State, a BC Unlock
+ * command is required.
+ */
+class Farm1StateLockout : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateLockout( VirtualChannelReception* setMyVC );
+	/**
+	 * All AD Frames are rejected with FARM_IN_LOCKOUT
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return FARM_IN_LOCKOUT
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State changes to Farm1StateOpen.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * The V(r) value is not set in Lockout State, even though the Command itself is accepted.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATELOCKOUT_H_ */
diff --git a/datalinklayer/Farm1StateOpen.cpp b/datalinklayer/Farm1StateOpen.cpp
index b7837013c..61c0997f9 100644
--- a/datalinklayer/Farm1StateOpen.cpp
+++ b/datalinklayer/Farm1StateOpen.cpp
@@ -1,49 +1,49 @@
-/**
- * @file	Farm1StateOpen.cpp
- * @brief	This file defines the Farm1StateOpen class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-
-
-
-#include "../datalinklayer/ClcwIF.h"
-#include "../datalinklayer/Farm1StateOpen.h"
-#include "../datalinklayer/TcTransferFrame.h"
-#include "../datalinklayer/VirtualChannelReception.h"
-
-Farm1StateOpen::Farm1StateOpen(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
-}
-
-ReturnValue_t Farm1StateOpen::handleADFrame(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-	int8_t diff = frame->getSequenceNumber() - myVC->vR;
-	if (diff == 0 ) {
-		myVC->vR++;
-		clcw->setRetransmitFlag(false);
-		return RETURN_OK;
-	} else if (diff < myVC->positiveWindow && diff > 0 ) {
-		clcw->setRetransmitFlag(true);
-		return NS_POSITIVE_W;
-	} else if (diff < 0 && diff >= -myVC->negativeWindow) {
-		return NS_NEGATIVE_W;
-	} else {
-		clcw->setLockoutFlag(true);
-		myVC->currentState = &(myVC->lockoutState);
-		return NS_LOCKOUT;
-	}
-}
-
-ReturnValue_t Farm1StateOpen::handleBCUnlockCommand( ClcwIF* clcw ) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	return BC_IS_UNLOCK_COMMAND;
-}
-
-ReturnValue_t Farm1StateOpen::handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	myVC->vR = vr;
-	return BC_IS_SET_VR_COMMAND;
-}
+/**
+ * @file	Farm1StateOpen.cpp
+ * @brief	This file defines the Farm1StateOpen class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+
+
+
+#include "ClcwIF.h"
+#include "Farm1StateOpen.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReception.h"
+
+Farm1StateOpen::Farm1StateOpen(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
+}
+
+ReturnValue_t Farm1StateOpen::handleADFrame(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+	int8_t diff = frame->getSequenceNumber() - myVC->vR;
+	if (diff == 0 ) {
+		myVC->vR++;
+		clcw->setRetransmitFlag(false);
+		return RETURN_OK;
+	} else if (diff < myVC->positiveWindow && diff > 0 ) {
+		clcw->setRetransmitFlag(true);
+		return NS_POSITIVE_W;
+	} else if (diff < 0 && diff >= -myVC->negativeWindow) {
+		return NS_NEGATIVE_W;
+	} else {
+		clcw->setLockoutFlag(true);
+		myVC->currentState = &(myVC->lockoutState);
+		return NS_LOCKOUT;
+	}
+}
+
+ReturnValue_t Farm1StateOpen::handleBCUnlockCommand( ClcwIF* clcw ) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	return BC_IS_UNLOCK_COMMAND;
+}
+
+ReturnValue_t Farm1StateOpen::handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	myVC->vR = vr;
+	return BC_IS_SET_VR_COMMAND;
+}
diff --git a/datalinklayer/Farm1StateOpen.h b/datalinklayer/Farm1StateOpen.h
index ebc3b333a..3b3a26048 100644
--- a/datalinklayer/Farm1StateOpen.h
+++ b/datalinklayer/Farm1StateOpen.h
@@ -1,62 +1,62 @@
-/**
- * @file	Farm1StateOpen.h
- * @brief	This file defines the Farm1StateOpen class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATEOPEN_H_
-#define FARM1STATEOPEN_H_
-
-#include "../datalinklayer/Farm1StateIF.h"
-
-/**
- * This class represents the FARM-1 "Open" State.
- * The Open state is the state of normal operation. It handles all types of frames,
- * including AD Frames. If a wrong Frame Sequence Number is detected in an AD Frame, the
- * State reacts as specified.
- */
-class Farm1StateOpen : public Farm1StateIF {
-private:
-	/**
-	 * This is a reference to the "owner" class the State works on.
-	 */
-	VirtualChannelReception* myVC;
-public:
-	/**
-	 * The default constructor if the State.
-	 * Sets the "owner" of the State.
-	 * @param setMyVC	The "owner" class.
-	 */
-	Farm1StateOpen( VirtualChannelReception* setMyVC );
-	/**
-	 * Method to check the validity of AD Frames.
-	 * It checks the Frame Sequence Number and reacts as specified in the standard. The state may
-	 * change to Farm1StateLockout.
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return If the Sequence Number is ok, it returns #RETURN_OK. Otherwise either #NS_POSITIVE_W,
-	 * 			#NS_NEGATIVE_W or NS_LOCKOUT is returned.
-	 */
-	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State does not change.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State does not change.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
-};
-
-
-#endif /* FARM1STATEOPEN_H_ */
+/**
+ * @file	Farm1StateOpen.h
+ * @brief	This file defines the Farm1StateOpen class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEOPEN_H_
+#define FARM1STATEOPEN_H_
+
+#include "Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Open" State.
+ * The Open state is the state of normal operation. It handles all types of frames,
+ * including AD Frames. If a wrong Frame Sequence Number is detected in an AD Frame, the
+ * State reacts as specified.
+ */
+class Farm1StateOpen : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateOpen( VirtualChannelReception* setMyVC );
+	/**
+	 * Method to check the validity of AD Frames.
+	 * It checks the Frame Sequence Number and reacts as specified in the standard. The state may
+	 * change to Farm1StateLockout.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return If the Sequence Number is ok, it returns #RETURN_OK. Otherwise either #NS_POSITIVE_W,
+	 * 			#NS_NEGATIVE_W or NS_LOCKOUT is returned.
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State does not change.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State does not change.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATEOPEN_H_ */
diff --git a/datalinklayer/Farm1StateWait.cpp b/datalinklayer/Farm1StateWait.cpp
index c3cc85de7..9001e1f5f 100644
--- a/datalinklayer/Farm1StateWait.cpp
+++ b/datalinklayer/Farm1StateWait.cpp
@@ -1,43 +1,43 @@
-/**
- * @file	Farm1StateWait.cpp
- * @brief	This file defines the Farm1StateWait class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-
-#include "../datalinklayer/ClcwIF.h"
-#include "../datalinklayer/Farm1StateWait.h"
-#include "../datalinklayer/TcTransferFrame.h"
-#include "../datalinklayer/VirtualChannelReception.h"
-
-Farm1StateWait::Farm1StateWait(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
-}
-
-ReturnValue_t Farm1StateWait::handleADFrame(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-
-	int8_t diff = frame->getSequenceNumber() - myVC->vR;
-	if ( diff < -myVC->negativeWindow || diff >= myVC->positiveWindow ) {
-		clcw->setLockoutFlag(true);
-		myVC->currentState = &(myVC->lockoutState);
-	}
-	return FARM_IN_WAIT;
-}
-
-ReturnValue_t Farm1StateWait::handleBCUnlockCommand(ClcwIF* clcw) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	clcw->setWaitFlag( false );
-	myVC->currentState = &(myVC->openState);
-	return BC_IS_UNLOCK_COMMAND;
-}
-
-ReturnValue_t Farm1StateWait::handleBCSetVrCommand(ClcwIF* clcw, uint8_t vr) {
-	myVC->farmBCounter++;
-	clcw->setWaitFlag( false );
-	clcw->setRetransmitFlag(false);
-	myVC->vR = vr;
-	myVC->currentState = &(myVC->openState);
-	return BC_IS_SET_VR_COMMAND;
-}
+/**
+ * @file	Farm1StateWait.cpp
+ * @brief	This file defines the Farm1StateWait class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+
+#include "ClcwIF.h"
+#include "Farm1StateWait.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReception.h"
+
+Farm1StateWait::Farm1StateWait(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
+}
+
+ReturnValue_t Farm1StateWait::handleADFrame(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+
+	int8_t diff = frame->getSequenceNumber() - myVC->vR;
+	if ( diff < -myVC->negativeWindow || diff >= myVC->positiveWindow ) {
+		clcw->setLockoutFlag(true);
+		myVC->currentState = &(myVC->lockoutState);
+	}
+	return FARM_IN_WAIT;
+}
+
+ReturnValue_t Farm1StateWait::handleBCUnlockCommand(ClcwIF* clcw) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	clcw->setWaitFlag( false );
+	myVC->currentState = &(myVC->openState);
+	return BC_IS_UNLOCK_COMMAND;
+}
+
+ReturnValue_t Farm1StateWait::handleBCSetVrCommand(ClcwIF* clcw, uint8_t vr) {
+	myVC->farmBCounter++;
+	clcw->setWaitFlag( false );
+	clcw->setRetransmitFlag(false);
+	myVC->vR = vr;
+	myVC->currentState = &(myVC->openState);
+	return BC_IS_SET_VR_COMMAND;
+}
diff --git a/datalinklayer/Farm1StateWait.h b/datalinklayer/Farm1StateWait.h
index aa4566642..877c36c26 100644
--- a/datalinklayer/Farm1StateWait.h
+++ b/datalinklayer/Farm1StateWait.h
@@ -1,58 +1,58 @@
-/**
- * @file	Farm1StateWait.h
- * @brief	This file defines the Farm1StateWait class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATEWAIT_H_
-#define FARM1STATEWAIT_H_
-
-#include "../datalinklayer/Farm1StateIF.h"
-
-/**
- * This class represents the FARM-1 "Wait" State.
- * The Wait state is reached if higher level procedures inform the FARM-1 Machine to wait
- * for a certain period. Currently, it is not in use.
- */
-class Farm1StateWait : public Farm1StateIF {
-private:
-	/**
-	 * This is a reference to the "owner" class the State works on.
-	 */
-	VirtualChannelReception* myVC;
-public:
-	/**
-	 * The default constructor if the State.
-	 * Sets the "owner" of the State.
-	 * @param setMyVC	The "owner" class.
-	 */
-	Farm1StateWait( VirtualChannelReception* setMyVC );
-	/**
-	 * AD Frames are always discarded.
-	 * If the frame number is in the lockout window, the state changes to Farm1StateLockout.
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	Always returns FARM_IN_WAIT.
-	 */
-	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State changes to Farm1StateOpen.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
-};
-
-
-#endif /* FARM1STATEWAIT_H_ */
+/**
+ * @file	Farm1StateWait.h
+ * @brief	This file defines the Farm1StateWait class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEWAIT_H_
+#define FARM1STATEWAIT_H_
+
+#include "Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Wait" State.
+ * The Wait state is reached if higher level procedures inform the FARM-1 Machine to wait
+ * for a certain period. Currently, it is not in use.
+ */
+class Farm1StateWait : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateWait( VirtualChannelReception* setMyVC );
+	/**
+	 * AD Frames are always discarded.
+	 * If the frame number is in the lockout window, the state changes to Farm1StateLockout.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	Always returns FARM_IN_WAIT.
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State changes to Farm1StateOpen.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATEWAIT_H_ */
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index a14bcefeb..cb12b3210 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -1,154 +1,154 @@
-/**
- * @file	MapPacketExtraction.cpp
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
-#include "../datalinklayer/MapPacketExtraction.h"
-#include "../ipc/QueueFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tmtcpacket/SpacePacketBase.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../tmtcservices/TmTcMessage.h"
-#include <string.h>
-
-MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
-		object_id_t setPacketDestination) :
-		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
-		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
-		packetStore(nullptr), tcQueueId(MessageQueueMessageIF::NO_QUEUE) {
-	memset(packetBuffer, 0, sizeof(packetBuffer));
-}
-
-ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
-	uint8_t segmentationFlag = frame->getSequenceFlags();
-	ReturnValue_t status = TOO_SHORT_MAP_EXTRACTION;
-	switch (segmentationFlag) {
-	case NO_SEGMENTATION:
-		status = unpackBlockingPackets(frame);
-		break;
-	case FIRST_PORTION:
-		packetLength = frame->getDataLength();
-		if (packetLength <= MAX_PACKET_SIZE) {
-			memcpy(packetBuffer, frame->getDataField(), packetLength);
-			bufferPosition = &packetBuffer[packetLength];
-			status = RETURN_OK;
-		} else {
-			sif::error
-					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
-					<< packetLength << std::endl;
-			clearBuffers();
-			status = CONTENT_TOO_LARGE;
-		}
-		break;
-	case CONTINUING_PORTION:
-	case LAST_PORTION:
-		if (lastSegmentationFlag == FIRST_PORTION
-				|| lastSegmentationFlag == CONTINUING_PORTION) {
-			packetLength += frame->getDataLength();
-			if (packetLength <= MAX_PACKET_SIZE) {
-				memcpy(bufferPosition, frame->getDataField(),
-						frame->getDataLength());
-				bufferPosition = &packetBuffer[packetLength];
-				if (segmentationFlag == LAST_PORTION) {
-					status = sendCompletePacket(packetBuffer, packetLength);
-					clearBuffers();
-				}
-				status = RETURN_OK;
-			} else {
-				sif::error
-						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
-						<< packetLength << std::endl;
-				clearBuffers();
-				status = CONTENT_TOO_LARGE;
-			}
-		} else {
-			sif::error
-					<< "MapPacketExtraction::extractPackets. Illegal segment! Last flag: "
-					<< (int) lastSegmentationFlag << std::endl;
-			clearBuffers();
-			status = ILLEGAL_SEGMENTATION_FLAG;
-		}
-		break;
-	default:
-		sif::error
-				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
-				<< (int) segmentationFlag << std::endl;
-		clearBuffers();
-		status = DATA_CORRUPTED;
-		break;
-	}
-	lastSegmentationFlag = segmentationFlag;
-	return status;
-}
-
-ReturnValue_t MapPacketExtraction::unpackBlockingPackets(
-		TcTransferFrame* frame) {
-	ReturnValue_t status = TOO_SHORT_BLOCKED_PACKET;
-	uint32_t totalLength = frame->getDataLength();
-	if (totalLength > MAX_PACKET_SIZE)
-		return CONTENT_TOO_LARGE;
-	uint8_t* position = frame->getDataField();
-	while ((totalLength > SpacePacketBase::MINIMUM_SIZE)) {
-		SpacePacketBase packet(position);
-		uint32_t packetSize = packet.getFullSize();
-		if (packetSize <= totalLength) {
-			status = sendCompletePacket(packet.getWholeData(),
-					packet.getFullSize());
-			totalLength -= packet.getFullSize();
-			position += packet.getFullSize();
-			status = RETURN_OK;
-		} else {
-			status = DATA_CORRUPTED;
-			totalLength = 0;
-		}
-	}
-	if (totalLength > 0) {
-		status = RESIDUAL_DATA;
-	}
-	return status;
-}
-
-ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data,
-		uint32_t size) {
-	store_address_t store_id;
-	ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
-	if (status == RETURN_OK) {
-		TmTcMessage message(store_id);
-		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message);
-	}
-	return status;
-}
-
-void MapPacketExtraction::clearBuffers() {
-	memset(packetBuffer, 0, sizeof(packetBuffer));
-	bufferPosition = packetBuffer;
-	packetLength = 0;
-	lastSegmentationFlag = NO_SEGMENTATION;
-}
-
-ReturnValue_t MapPacketExtraction::initialize() {
-	packetStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-	AcceptsTelecommandsIF* distributor = objectManager->get<
-			AcceptsTelecommandsIF>(packetDestination);
-	if ((packetStore != NULL) && (distributor != NULL)) {
-		tcQueueId = distributor->getRequestQueue();
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-void MapPacketExtraction::printPacketBuffer(void) {
-	sif::debug << "DLL: packet_buffer contains: " << std::endl;
-	for (uint32_t i = 0; i < this->packetLength; ++i) {
-		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
-				<< (uint16_t) this->packetBuffer[i] << std::endl;
-	}
-}
-
-uint8_t MapPacketExtraction::getMapId() const {
-	return mapId;
-}
+/**
+ * @file	MapPacketExtraction.cpp
+ * @brief	This file defines the MapPacketExtraction class.
+ * @date	26.03.2013
+ * @author	baetz
+ */
+
+#include "MapPacketExtraction.h"
+#include "../ipc/QueueFactory.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tmtcpacket/SpacePacketBase.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include <string.h>
+
+MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
+		object_id_t setPacketDestination) :
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0), bufferPosition(
+				packetBuffer), packetDestination(setPacketDestination), packetStore(
+				NULL), tcQueueId(MessageQueueSenderIF::NO_QUEUE) {
+	memset(packetBuffer, 0, sizeof(packetBuffer));
+}
+
+ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
+	uint8_t segmentationFlag = frame->getSequenceFlags();
+	ReturnValue_t status = TOO_SHORT_MAP_EXTRACTION;
+	switch (segmentationFlag) {
+	case NO_SEGMENTATION:
+		status = unpackBlockingPackets(frame);
+		break;
+	case FIRST_PORTION:
+		packetLength = frame->getDataLength();
+		if (packetLength <= MAX_PACKET_SIZE) {
+			memcpy(packetBuffer, frame->getDataField(), packetLength);
+			bufferPosition = &packetBuffer[packetLength];
+			status = RETURN_OK;
+		} else {
+			sif::error
+					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
+					<< packetLength << std::endl;
+			clearBuffers();
+			status = CONTENT_TOO_LARGE;
+		}
+		break;
+	case CONTINUING_PORTION:
+	case LAST_PORTION:
+		if (lastSegmentationFlag == FIRST_PORTION
+				|| lastSegmentationFlag == CONTINUING_PORTION) {
+			packetLength += frame->getDataLength();
+			if (packetLength <= MAX_PACKET_SIZE) {
+				memcpy(bufferPosition, frame->getDataField(),
+						frame->getDataLength());
+				bufferPosition = &packetBuffer[packetLength];
+				if (segmentationFlag == LAST_PORTION) {
+					status = sendCompletePacket(packetBuffer, packetLength);
+					clearBuffers();
+				}
+				status = RETURN_OK;
+			} else {
+				sif::error
+						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
+						<< packetLength << std::endl;
+				clearBuffers();
+				status = CONTENT_TOO_LARGE;
+			}
+		} else {
+			sif::error
+					<< "MapPacketExtraction::extractPackets. Illegal segment! Last flag: "
+					<< (int) lastSegmentationFlag << std::endl;
+			clearBuffers();
+			status = ILLEGAL_SEGMENTATION_FLAG;
+		}
+		break;
+	default:
+		sif::error
+				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
+				<< (int) segmentationFlag << std::endl;
+		clearBuffers();
+		status = DATA_CORRUPTED;
+		break;
+	}
+	lastSegmentationFlag = segmentationFlag;
+	return status;
+}
+
+ReturnValue_t MapPacketExtraction::unpackBlockingPackets(
+		TcTransferFrame* frame) {
+	ReturnValue_t status = TOO_SHORT_BLOCKED_PACKET;
+	uint32_t totalLength = frame->getDataLength();
+	if (totalLength > MAX_PACKET_SIZE)
+		return CONTENT_TOO_LARGE;
+	uint8_t* position = frame->getDataField();
+	while ((totalLength > SpacePacketBase::MINIMUM_SIZE)) {
+		SpacePacketBase packet(position);
+		uint32_t packetSize = packet.getFullSize();
+		if (packetSize <= totalLength) {
+			status = sendCompletePacket(packet.getWholeData(),
+					packet.getFullSize());
+			totalLength -= packet.getFullSize();
+			position += packet.getFullSize();
+			status = RETURN_OK;
+		} else {
+			status = DATA_CORRUPTED;
+			totalLength = 0;
+		}
+	}
+	if (totalLength > 0) {
+		status = RESIDUAL_DATA;
+	}
+	return status;
+}
+
+ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data,
+		uint32_t size) {
+	store_address_t store_id;
+	ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
+	if (status == RETURN_OK) {
+		TmTcMessage message(store_id);
+		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message);
+	}
+	return status;
+}
+
+void MapPacketExtraction::clearBuffers() {
+	memset(packetBuffer, 0, sizeof(packetBuffer));
+	bufferPosition = packetBuffer;
+	packetLength = 0;
+	lastSegmentationFlag = NO_SEGMENTATION;
+}
+
+ReturnValue_t MapPacketExtraction::initialize() {
+	packetStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	AcceptsTelecommandsIF* distributor = objectManager->get<
+			AcceptsTelecommandsIF>(packetDestination);
+	if ((packetStore != NULL) && (distributor != NULL)) {
+		tcQueueId = distributor->getRequestQueue();
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+void MapPacketExtraction::printPacketBuffer(void) {
+	sif::debug << "DLL: packet_buffer contains: " << std::endl;
+	for (uint32_t i = 0; i < this->packetLength; ++i) {
+		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
+				<< (uint16_t) this->packetBuffer[i] << std::endl;
+	}
+}
+
+uint8_t MapPacketExtraction::getMapId() const {
+	return mapId;
+}
diff --git a/datalinklayer/MapPacketExtraction.h b/datalinklayer/MapPacketExtraction.h
index cb09c27f0..507f13dbe 100644
--- a/datalinklayer/MapPacketExtraction.h
+++ b/datalinklayer/MapPacketExtraction.h
@@ -1,78 +1,78 @@
-/**
- * @file	MapPacketExtraction.h
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
-#ifndef MAPPACKETEXTRACTION_H_
-#define MAPPACKETEXTRACTION_H_
-
-#include "../datalinklayer/MapPacketExtractionIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-class StorageManagerIF;
-
-/**
- * Implementation of a MAP Packet Extraction class.
- * The class implements the full MAP Packet Extraction functionality as described in the CCSDS
- * TC Space Data Link Protocol. It internally stores incomplete segmented packets until they are
- * fully received. All found packets are forwarded to a single distribution entity.
- */
-class MapPacketExtraction: public MapPacketExtractionIF {
-private:
-	static const uint32_t MAX_PACKET_SIZE = 4096;
-	uint8_t lastSegmentationFlag;	//!< The segmentation flag of the last received frame.
-	uint8_t mapId;	//!< MAP ID of this MAP Channel.
-	uint32_t packetLength;	//!< Complete length of the current Space Packet.
-	uint8_t* bufferPosition;	//!< Position to write to in the internal Packet buffer.
-	uint8_t packetBuffer[MAX_PACKET_SIZE];	//!< The internal Space Packet Buffer.
-	object_id_t packetDestination;
-	StorageManagerIF* packetStore;	//!< Pointer to the store where full TC packets are stored.
-	MessageQueueId_t tcQueueId;		//!< QueueId to send found packets to the distributor.
-	/**
-	 * Debug method to print the packet Buffer's content.
-	 */
-	void printPacketBuffer();
-	/**
-	 * Method that is called if the segmentation flag is @c NO_SEGMENTATION.
-	 * The method extracts one or more packets within the frame and forwards them to the OBSW.
-	 * @param frame	The TC Transfer Frame to work on.
-	 * @return	@c RETURN_OK if all Packets were extracted. If something is entirely wrong,
-	 * 	 @c DATA_CORRUPTED is returned, if some bytes are left over @c RESIDUAL_DATA.
-	 */
-	ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame);
-	/**
-	 * Helper method to forward a complete packet to the OBSW.
-	 * @param data	Pointer to the data, either directly from the frame or from the packetBuffer.
-	 * @param size	Complete total size of the packet.
-	 * @return	Return Code of the Packet Store or the Message Queue.
-	 */
-	ReturnValue_t sendCompletePacket( uint8_t* data, uint32_t size );
-	/**
-	 * Helper method to reset the internal buffer.
-	 */
-	void clearBuffers();
-public:
-	/**
-	 * Default constructor.
-	 * Members are set to default values.
-	 * @param setMapId	The MAP ID of the instance.
-	 */
-	MapPacketExtraction( uint8_t setMapId, object_id_t setPacketDestination );
-	ReturnValue_t extractPackets(TcTransferFrame* frame);
-	/**
-	 * The #packetStore and the default destination of #tcQueue are initialized here.
-	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t initialize();
-	/**
-	 * Getter.
-	 * @return The MAP ID of this instance.
-	 */
-	uint8_t getMapId() const;
-};
-
-#endif /* MAPPACKETEXTRACTION_H_ */
+/**
+ * @file	MapPacketExtraction.h
+ * @brief	This file defines the MapPacketExtraction class.
+ * @date	26.03.2013
+ * @author	baetz
+ */
+
+#ifndef MAPPACKETEXTRACTION_H_
+#define MAPPACKETEXTRACTION_H_
+
+#include "MapPacketExtractionIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class StorageManagerIF;
+
+/**
+ * Implementation of a MAP Packet Extraction class.
+ * The class implements the full MAP Packet Extraction functionality as described in the CCSDS
+ * TC Space Data Link Protocol. It internally stores incomplete segmented packets until they are
+ * fully received. All found packets are forwarded to a single distribution entity.
+ */
+class MapPacketExtraction: public MapPacketExtractionIF {
+private:
+	static const uint32_t MAX_PACKET_SIZE = 4096;
+	uint8_t lastSegmentationFlag;	//!< The segmentation flag of the last received frame.
+	uint8_t mapId;	//!< MAP ID of this MAP Channel.
+	uint32_t packetLength;	//!< Complete length of the current Space Packet.
+	uint8_t* bufferPosition;	//!< Position to write to in the internal Packet buffer.
+	uint8_t packetBuffer[MAX_PACKET_SIZE];	//!< The internal Space Packet Buffer.
+	object_id_t packetDestination;
+	StorageManagerIF* packetStore;	//!< Pointer to the store where full TC packets are stored.
+	MessageQueueId_t tcQueueId;		//!< QueueId to send found packets to the distributor.
+	/**
+	 * Debug method to print the packet Buffer's content.
+	 */
+	void printPacketBuffer();
+	/**
+	 * Method that is called if the segmentation flag is @c NO_SEGMENTATION.
+	 * The method extracts one or more packets within the frame and forwards them to the OBSW.
+	 * @param frame	The TC Transfer Frame to work on.
+	 * @return	@c RETURN_OK if all Packets were extracted. If something is entirely wrong,
+	 * 	 @c DATA_CORRUPTED is returned, if some bytes are left over @c RESIDUAL_DATA.
+	 */
+	ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame);
+	/**
+	 * Helper method to forward a complete packet to the OBSW.
+	 * @param data	Pointer to the data, either directly from the frame or from the packetBuffer.
+	 * @param size	Complete total size of the packet.
+	 * @return	Return Code of the Packet Store or the Message Queue.
+	 */
+	ReturnValue_t sendCompletePacket( uint8_t* data, uint32_t size );
+	/**
+	 * Helper method to reset the internal buffer.
+	 */
+	void clearBuffers();
+public:
+	/**
+	 * Default constructor.
+	 * Members are set to default values.
+	 * @param setMapId	The MAP ID of the instance.
+	 */
+	MapPacketExtraction( uint8_t setMapId, object_id_t setPacketDestination );
+	ReturnValue_t extractPackets(TcTransferFrame* frame);
+	/**
+	 * The #packetStore and the default destination of #tcQueue are initialized here.
+	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t initialize();
+	/**
+	 * Getter.
+	 * @return The MAP ID of this instance.
+	 */
+	uint8_t getMapId() const;
+};
+
+#endif /* MAPPACKETEXTRACTION_H_ */
diff --git a/datalinklayer/MapPacketExtractionIF.h b/datalinklayer/MapPacketExtractionIF.h
index d66831dee..e29ac6660 100644
--- a/datalinklayer/MapPacketExtractionIF.h
+++ b/datalinklayer/MapPacketExtractionIF.h
@@ -1,47 +1,47 @@
-/**
- * @file	MapPacketExtractionIF.h
- * @brief	This file defines the MapPacketExtractionIF class.
- * @date	25.03.2013
- * @author	baetz
- */
-
-#ifndef MAPPACKETEXTRACTIONIF_H_
-#define MAPPACKETEXTRACTIONIF_H_
-
-#include "../datalinklayer/CCSDSReturnValuesIF.h"
-#include "../datalinklayer/TcTransferFrame.h"
-
-/**
- * This is the interface for MAP Packet Extraction classes.
- * All classes implementing this interface shall be able to extract blocked or segmented Space
- * Packets on a certain MAP channel. This is done in accordance with the CCSDS TC Space Data Link
- * Protocol.
- */
-class MapPacketExtractionIF : public CCSDSReturnValuesIF {
-protected:
-	static const uint8_t FIRST_PORTION = 0b01;		//!< Identification of the first part of a segmented Packet.
-	static const uint8_t CONTINUING_PORTION = 0b00;	//!< Identification of a continuing part of segmented Packets.
-	static const uint8_t LAST_PORTION = 0b10;		//!< The last portion of a segmented Packet.
-	static const uint8_t NO_SEGMENTATION = 0b11;	//!< A Frame without segmentation but maybe with blocking.
-public:
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~MapPacketExtractionIF() {
-	}
-	/**
-	 * Method to call to handle a single Transfer Frame.
-	 * The method tries to extract Packets from the frame as stated in the Standard.
-	 * @param frame
-	 * @return
-	 */
-	virtual ReturnValue_t extractPackets( TcTransferFrame* frame ) = 0;
-	/**
-	 * Any post-instantiation initialization shall be done in this method.
-	 * @return
-	 */
-	virtual ReturnValue_t initialize() = 0;
-};
-
-
-#endif /* MAPPACKETEXTRACTIONIF_H_ */
+/**
+ * @file	MapPacketExtractionIF.h
+ * @brief	This file defines the MapPacketExtractionIF class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef MAPPACKETEXTRACTIONIF_H_
+#define MAPPACKETEXTRACTIONIF_H_
+
+#include "CCSDSReturnValuesIF.h"
+#include "TcTransferFrame.h"
+
+/**
+ * This is the interface for MAP Packet Extraction classes.
+ * All classes implementing this interface shall be able to extract blocked or segmented Space
+ * Packets on a certain MAP channel. This is done in accordance with the CCSDS TC Space Data Link
+ * Protocol.
+ */
+class MapPacketExtractionIF : public CCSDSReturnValuesIF {
+protected:
+	static const uint8_t FIRST_PORTION = 0b01;		//!< Identification of the first part of a segmented Packet.
+	static const uint8_t CONTINUING_PORTION = 0b00;	//!< Identification of a continuing part of segmented Packets.
+	static const uint8_t LAST_PORTION = 0b10;		//!< The last portion of a segmented Packet.
+	static const uint8_t NO_SEGMENTATION = 0b11;	//!< A Frame without segmentation but maybe with blocking.
+public:
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~MapPacketExtractionIF() {
+	}
+	/**
+	 * Method to call to handle a single Transfer Frame.
+	 * The method tries to extract Packets from the frame as stated in the Standard.
+	 * @param frame
+	 * @return
+	 */
+	virtual ReturnValue_t extractPackets( TcTransferFrame* frame ) = 0;
+	/**
+	 * Any post-instantiation initialization shall be done in this method.
+	 * @return
+	 */
+	virtual ReturnValue_t initialize() = 0;
+};
+
+
+#endif /* MAPPACKETEXTRACTIONIF_H_ */
diff --git a/datalinklayer/TcTransferFrame.cpp b/datalinklayer/TcTransferFrame.cpp
index 8a3e1d76d..f1a70bdcf 100644
--- a/datalinklayer/TcTransferFrame.cpp
+++ b/datalinklayer/TcTransferFrame.cpp
@@ -1,102 +1,102 @@
-/**
- * @file	TcTransferFrame.cpp
- * @brief	This file defines the TcTransferFrame class.
- * @date	27.04.2013
- * @author	baetz
- */
-
-
-
-#include "../datalinklayer/TcTransferFrame.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-TcTransferFrame::TcTransferFrame() {
-	 frame = NULL;
-}
-
-TcTransferFrame::TcTransferFrame(uint8_t* setData) {
-	 this->frame = (tc_transfer_frame*)setData;
-}
-
-uint8_t TcTransferFrame::getVersionNumber() {
-	 return (this->frame->header.flagsAndScid & 0b11000000) >> 6;
-}
-
-bool TcTransferFrame::bypassFlagSet() {
-	 return (this->frame->header.flagsAndScid & 0b00100000) != 0;
-}
-
-bool TcTransferFrame::controlCommandFlagSet() {
-	 return (this->frame->header.flagsAndScid & 0b00010000) != 0;
-}
-
-bool TcTransferFrame::spareIsZero() {
-	 return ( (this->frame->header.flagsAndScid & 0b00001100) == 0 );
-}
-
-uint16_t TcTransferFrame::getSpacecraftId() {
-	 return ( (this->frame->header.flagsAndScid & 0b00000011) << 8 ) + this->frame->header.spacecraftId_l;
-}
-
-uint8_t TcTransferFrame::getVirtualChannelId() {
-	 return (this->frame->header.vcidAndLength_h & 0b11111100) >> 2;
-}
-
-uint16_t TcTransferFrame::getFrameLength() {
-	 return  ( (this->frame->header.vcidAndLength_h & 0b00000011) << 8 ) + this->frame->header.length_l;
-}
-
-uint16_t TcTransferFrame::getDataLength() {
-	 return  this->getFrameLength() - this->getHeaderSize() -1 - FRAME_CRC_SIZE + 1; // -1 for the segment header.
-}
-
-uint8_t TcTransferFrame::getSequenceNumber() {
-	 return this->frame->header.sequenceNumber;
-}
-
-uint8_t TcTransferFrame::getSequenceFlags() {
-	 return (this->frame->dataField & 0b11000000)>>6;
-}
-
-uint8_t TcTransferFrame::getMAPId() {
-	 return this->frame->dataField & 0b00111111;
-}
-
-uint8_t* TcTransferFrame::getDataField() {
-	return &(this->frame->dataField) + 1;
-}
-
-uint8_t* TcTransferFrame::getFullFrame() {
-	return (uint8_t*)this->frame;
-}
-
-uint16_t TcTransferFrame::getFullSize() {
-	return this->getFrameLength() + 1;
-}
-
-uint16_t TcTransferFrame::getHeaderSize() {
-	 return sizeof(frame->header);
-}
-
-uint16_t TcTransferFrame::getFullDataLength() {
-	return this->getFrameLength() - this->getHeaderSize() - FRAME_CRC_SIZE + 1;
-}
-
-uint8_t* TcTransferFrame::getFullDataField() {
-	return &frame->dataField;
-}
-
-void TcTransferFrame::print() {
-	sif::debug << "Raw Frame: " << std::hex << std::endl;
-	for (uint16_t count = 0; count < this->getFullSize(); count++ ) {
-		sif::debug << (uint16_t)this->getFullFrame()[count] << " ";
-	}
-	sif::debug << std::dec << std::endl;
-//	debug << "Frame Header:" << std::endl;
-//	debug << "Version Number: " << std::hex << (uint16_t)this->current_frame.getVersionNumber() << std::endl;
-//	debug << "Bypass Flag set?| Ctrl Cmd Flag set?: " << (uint16_t)this->current_frame.bypassFlagSet() << " | " << (uint16_t)this->current_frame.controlCommandFlagSet()  << std::endl;
-//	debug << "SCID : " << this->current_frame.getSpacecraftId() << std::endl;
-//	debug << "VCID : " << (uint16_t)this->current_frame.getVirtualChannelId() << std::endl;
-//	debug << "Frame length: " << std::dec << this->current_frame.getFrameLength() << std::endl;
-//	debug << "Sequence Number: " << (uint16_t)this->current_frame.getSequenceNumber() << std::endl;
-}
+/**
+ * @file	TcTransferFrame.cpp
+ * @brief	This file defines the TcTransferFrame class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+
+
+#include "TcTransferFrame.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+TcTransferFrame::TcTransferFrame() {
+	 frame = NULL;
+}
+
+TcTransferFrame::TcTransferFrame(uint8_t* setData) {
+	 this->frame = (tc_transfer_frame*)setData;
+}
+
+uint8_t TcTransferFrame::getVersionNumber() {
+	 return (this->frame->header.flagsAndScid & 0b11000000) >> 6;
+}
+
+bool TcTransferFrame::bypassFlagSet() {
+	 return (this->frame->header.flagsAndScid & 0b00100000) != 0;
+}
+
+bool TcTransferFrame::controlCommandFlagSet() {
+	 return (this->frame->header.flagsAndScid & 0b00010000) != 0;
+}
+
+bool TcTransferFrame::spareIsZero() {
+	 return ( (this->frame->header.flagsAndScid & 0b00001100) == 0 );
+}
+
+uint16_t TcTransferFrame::getSpacecraftId() {
+	 return ( (this->frame->header.flagsAndScid & 0b00000011) << 8 ) + this->frame->header.spacecraftId_l;
+}
+
+uint8_t TcTransferFrame::getVirtualChannelId() {
+	 return (this->frame->header.vcidAndLength_h & 0b11111100) >> 2;
+}
+
+uint16_t TcTransferFrame::getFrameLength() {
+	 return  ( (this->frame->header.vcidAndLength_h & 0b00000011) << 8 ) + this->frame->header.length_l;
+}
+
+uint16_t TcTransferFrame::getDataLength() {
+	 return  this->getFrameLength() - this->getHeaderSize() -1 - FRAME_CRC_SIZE + 1; // -1 for the segment header.
+}
+
+uint8_t TcTransferFrame::getSequenceNumber() {
+	 return this->frame->header.sequenceNumber;
+}
+
+uint8_t TcTransferFrame::getSequenceFlags() {
+	 return (this->frame->dataField & 0b11000000)>>6;
+}
+
+uint8_t TcTransferFrame::getMAPId() {
+	 return this->frame->dataField & 0b00111111;
+}
+
+uint8_t* TcTransferFrame::getDataField() {
+	return &(this->frame->dataField) + 1;
+}
+
+uint8_t* TcTransferFrame::getFullFrame() {
+	return (uint8_t*)this->frame;
+}
+
+uint16_t TcTransferFrame::getFullSize() {
+	return this->getFrameLength() + 1;
+}
+
+uint16_t TcTransferFrame::getHeaderSize() {
+	 return sizeof(frame->header);
+}
+
+uint16_t TcTransferFrame::getFullDataLength() {
+	return this->getFrameLength() - this->getHeaderSize() - FRAME_CRC_SIZE + 1;
+}
+
+uint8_t* TcTransferFrame::getFullDataField() {
+	return &frame->dataField;
+}
+
+void TcTransferFrame::print() {
+	sif::debug << "Raw Frame: " << std::hex << std::endl;
+	for (uint16_t count = 0; count < this->getFullSize(); count++ ) {
+		sif::debug << (uint16_t)this->getFullFrame()[count] << " ";
+	}
+	sif::debug << std::dec << std::endl;
+//	debug << "Frame Header:" << std::endl;
+//	debug << "Version Number: " << std::hex << (uint16_t)this->current_frame.getVersionNumber() << std::endl;
+//	debug << "Bypass Flag set?| Ctrl Cmd Flag set?: " << (uint16_t)this->current_frame.bypassFlagSet() << " | " << (uint16_t)this->current_frame.controlCommandFlagSet()  << std::endl;
+//	debug << "SCID : " << this->current_frame.getSpacecraftId() << std::endl;
+//	debug << "VCID : " << (uint16_t)this->current_frame.getVirtualChannelId() << std::endl;
+//	debug << "Frame length: " << std::dec << this->current_frame.getFrameLength() << std::endl;
+//	debug << "Sequence Number: " << (uint16_t)this->current_frame.getSequenceNumber() << std::endl;
+}
diff --git a/datalinklayer/TcTransferFrameLocal.cpp b/datalinklayer/TcTransferFrameLocal.cpp
index 0bffa586a..e8785c92a 100644
--- a/datalinklayer/TcTransferFrameLocal.cpp
+++ b/datalinklayer/TcTransferFrameLocal.cpp
@@ -1,49 +1,49 @@
-/**
- * @file	TcTransferFrameLocal.cpp
- * @brief	This file defines the TcTransferFrameLocal class.
- * @date	27.04.2013
- * @author	baetz
- */
-
-#include "../datalinklayer/TcTransferFrameLocal.h"
-#include "../globalfunctions/CRC.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <string.h>
-
-TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid,
-		uint8_t vcId, uint8_t sequenceNumber, uint8_t setSegmentHeader, uint8_t* data, uint16_t dataSize, uint16_t forceCrc) {
-	this->frame = (tc_transfer_frame*)&localData;
-	frame->header.flagsAndScid = (bypass << 5) + (controlCommand << 4) + ((scid & 0x0300) >> 8);
-	frame->header.spacecraftId_l = (scid & 0x00FF);
-	frame->header.vcidAndLength_h = (vcId & 0b00111111) << 2;
-	frame->header.length_l = sizeof(TcTransferFramePrimaryHeader) -1;
-	frame->header.sequenceNumber = sequenceNumber;
-	frame->dataField = setSegmentHeader;
-	if (data != NULL) {
-		if (bypass && controlCommand) {
-			memcpy(&(frame->dataField), data, dataSize);
-			uint16_t totalSize = sizeof(TcTransferFramePrimaryHeader) + dataSize + FRAME_CRC_SIZE -1;
-			frame->header.vcidAndLength_h |= (totalSize & 0x0300) >> 8;
-			frame->header.length_l = (totalSize & 0x00FF);
-			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
-			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
-			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
-		} else if (dataSize <= 1016) {
-			memcpy(&(frame->dataField) +1, data, dataSize);
-			uint16_t dataCrcSize = sizeof(TcTransferFramePrimaryHeader) + 1 + dataSize + FRAME_CRC_SIZE -1;
-			frame->header.vcidAndLength_h |= (dataCrcSize & 0x0300) >> 8;
-			frame->header.length_l = (dataCrcSize & 0x00FF);
-			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
-			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
-			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
-		} else {
-			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
-		}
-	} else {
-		//No data in frame
-	}
-	if (forceCrc != 0 ) {
-		localData.data[getFullSize()-2] = (forceCrc & 0xFF00) >> 8;
-		localData.data[getFullSize()-1] = (forceCrc & 0x00FF);
-	}
-}
+/**
+ * @file	TcTransferFrameLocal.cpp
+ * @brief	This file defines the TcTransferFrameLocal class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+#include "TcTransferFrameLocal.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <string.h>
+
+TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid,
+		uint8_t vcId, uint8_t sequenceNumber, uint8_t setSegmentHeader, uint8_t* data, uint16_t dataSize, uint16_t forceCrc) {
+	this->frame = (tc_transfer_frame*)&localData;
+	frame->header.flagsAndScid = (bypass << 5) + (controlCommand << 4) + ((scid & 0x0300) >> 8);
+	frame->header.spacecraftId_l = (scid & 0x00FF);
+	frame->header.vcidAndLength_h = (vcId & 0b00111111) << 2;
+	frame->header.length_l = sizeof(TcTransferFramePrimaryHeader) -1;
+	frame->header.sequenceNumber = sequenceNumber;
+	frame->dataField = setSegmentHeader;
+	if (data != NULL) {
+		if (bypass && controlCommand) {
+			memcpy(&(frame->dataField), data, dataSize);
+			uint16_t totalSize = sizeof(TcTransferFramePrimaryHeader) + dataSize + FRAME_CRC_SIZE -1;
+			frame->header.vcidAndLength_h |= (totalSize & 0x0300) >> 8;
+			frame->header.length_l = (totalSize & 0x00FF);
+			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
+			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
+			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
+		} else if (dataSize <= 1016) {
+			memcpy(&(frame->dataField) +1, data, dataSize);
+			uint16_t dataCrcSize = sizeof(TcTransferFramePrimaryHeader) + 1 + dataSize + FRAME_CRC_SIZE -1;
+			frame->header.vcidAndLength_h |= (dataCrcSize & 0x0300) >> 8;
+			frame->header.length_l = (dataCrcSize & 0x00FF);
+			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
+			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
+			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
+		} else {
+			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
+		}
+	} else {
+		//No data in frame
+	}
+	if (forceCrc != 0 ) {
+		localData.data[getFullSize()-2] = (forceCrc & 0xFF00) >> 8;
+		localData.data[getFullSize()-1] = (forceCrc & 0x00FF);
+	}
+}
diff --git a/datalinklayer/TcTransferFrameLocal.h b/datalinklayer/TcTransferFrameLocal.h
index d98350fe1..487d8940b 100644
--- a/datalinklayer/TcTransferFrameLocal.h
+++ b/datalinklayer/TcTransferFrameLocal.h
@@ -1,49 +1,49 @@
-/**
- * @file	TcTransferFrameLocal.h
- * @brief	This file defines the TcTransferFrameLocal class.
- * @date	27.04.2013
- * @author	baetz
- */
-
-#ifndef TCTRANSFERFRAMELOCAL_H_
-#define TCTRANSFERFRAMELOCAL_H_
-
-#include "../datalinklayer/TcTransferFrame.h"
-
-/**
- * This is a helper class to locally create TC Transfer Frames.
- * This is mainly required for testing purposes and therefore not very sophisticated.
- * @ingroup ccsds_handling
- */
-class TcTransferFrameLocal : public TcTransferFrame {
-private:
-	/**
-	 * A stuct to locally store the complete data.
-	 */
-	struct frameData {
-		TcTransferFramePrimaryHeader header;	//!< The primary header.
-		uint8_t data[1019];	//!< The data field.
-	};
-public:
-	frameData localData; //!< The local data in the Frame.
-	/**
-	 * The default Constructor.
-	 * All parameters in the Header are passed.
-	 * If a BC Frame is detected no segment header is created.
-	 * Otherwise (AD and BD), the Segment Header is set.
-	 * @param bypass			The bypass flag.
-	 * @param controlCommand	The Control Command flag.
-	 * @param scid				The SCID.
-	 * @param vcId				The VCID.
-	 * @param sequenceNumber	The Frame Sequence Number N(s)
-	 * @param setSegmentHeader	A value for the Segment Header.
-	 * @param data				Data to put into the Frame Data Field.
-	 * @param dataSize			Size of the Data.
-	 * @param forceCrc			if != 0, the value is used as CRC.
-	 */
-	TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid, uint8_t vcId, uint8_t sequenceNumber,
-			uint8_t setSegmentHeader = 0xC0, uint8_t* data = NULL, uint16_t dataSize = 0, uint16_t forceCrc = 0);
-};
-
-
-#endif /* TCTRANSFERFRAMELOCAL_H_ */
+/**
+ * @file	TcTransferFrameLocal.h
+ * @brief	This file defines the TcTransferFrameLocal class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+#ifndef TCTRANSFERFRAMELOCAL_H_
+#define TCTRANSFERFRAMELOCAL_H_
+
+#include "TcTransferFrame.h"
+
+/**
+ * This is a helper class to locally create TC Transfer Frames.
+ * This is mainly required for testing purposes and therefore not very sophisticated.
+ * @ingroup ccsds_handling
+ */
+class TcTransferFrameLocal : public TcTransferFrame {
+private:
+	/**
+	 * A stuct to locally store the complete data.
+	 */
+	struct frameData {
+		TcTransferFramePrimaryHeader header;	//!< The primary header.
+		uint8_t data[1019];	//!< The data field.
+	};
+public:
+	frameData localData; //!< The local data in the Frame.
+	/**
+	 * The default Constructor.
+	 * All parameters in the Header are passed.
+	 * If a BC Frame is detected no segment header is created.
+	 * Otherwise (AD and BD), the Segment Header is set.
+	 * @param bypass			The bypass flag.
+	 * @param controlCommand	The Control Command flag.
+	 * @param scid				The SCID.
+	 * @param vcId				The VCID.
+	 * @param sequenceNumber	The Frame Sequence Number N(s)
+	 * @param setSegmentHeader	A value for the Segment Header.
+	 * @param data				Data to put into the Frame Data Field.
+	 * @param dataSize			Size of the Data.
+	 * @param forceCrc			if != 0, the value is used as CRC.
+	 */
+	TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid, uint8_t vcId, uint8_t sequenceNumber,
+			uint8_t setSegmentHeader = 0xC0, uint8_t* data = NULL, uint16_t dataSize = 0, uint16_t forceCrc = 0);
+};
+
+
+#endif /* TCTRANSFERFRAMELOCAL_H_ */
diff --git a/datalinklayer/VirtualChannelReception.cpp b/datalinklayer/VirtualChannelReception.cpp
index 55169c42f..cde28de37 100644
--- a/datalinklayer/VirtualChannelReception.cpp
+++ b/datalinklayer/VirtualChannelReception.cpp
@@ -1,121 +1,121 @@
-/**
- * @file	VirtualChannelReception.cpp
- * @brief	This file defines the VirtualChannelReception class.
- * @date	26.03.2013
- * @author	baetz
- */
-
-#include "../datalinklayer/BCFrame.h"
-#include "../datalinklayer/VirtualChannelReception.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-VirtualChannelReception::VirtualChannelReception(uint8_t setChannelId,
-		uint8_t setSlidingWindowWidth) :
-		channelId(setChannelId), slidingWindowWidth(setSlidingWindowWidth), positiveWindow(
-				setSlidingWindowWidth / 2), negativeWindow(setSlidingWindowWidth / 2), currentState(
-				&openState), openState(this), waitState(this), lockoutState(this), vR(0), farmBCounter(
-				0) {
-	internalClcw.setVirtualChannel(channelId);
-}
-
-ReturnValue_t VirtualChannelReception::mapDemultiplexing(TcTransferFrame* frame) {
-	uint8_t mapId = frame->getMAPId();
-	mapChannelIterator iter = mapChannels.find(mapId);
-	if (iter == mapChannels.end()) {
-//		error << "VirtualChannelReception::mapDemultiplexing on VC " << std::hex << (int) channelId
-//				<< ": MapChannel " << (int) mapId << std::dec << " not found." << std::endl;
-		return VC_NOT_FOUND;
-	} else {
-		return (iter->second)->extractPackets(frame);
-	}
-}
-
-ReturnValue_t VirtualChannelReception::doFARM(TcTransferFrame* frame, ClcwIF* clcw) {
-	uint8_t bypass = frame->bypassFlagSet();
-	uint8_t controlCommand = frame->controlCommandFlagSet();
-	uint8_t typeValue = (bypass << 1) + controlCommand;
-	switch (typeValue) {
-	case AD_FRAME:
-		return currentState->handleADFrame(frame, clcw);
-	case BD_FRAME:
-		return handleBDFrame(frame, clcw);
-	case BC_FRAME:
-		return handleBCFrame(frame, clcw);
-	default:
-		return ILLEGAL_FLAG_COMBINATION;
-	}
-}
-
-ReturnValue_t VirtualChannelReception::frameAcceptanceAndReportingMechanism(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-	ReturnValue_t result = RETURN_OK;
-	result = doFARM(frame, &internalClcw);
-	internalClcw.setReceiverFrameSequenceNumber(vR);
-	internalClcw.setFarmBCount(farmBCounter);
-	clcw->setWhole(internalClcw.getAsWhole());
-	switch (result) {
-	case RETURN_OK:
-		return mapDemultiplexing(frame);
-	case BC_IS_SET_VR_COMMAND:
-	case BC_IS_UNLOCK_COMMAND:
-		//Need to catch these codes to avoid error reporting later.
-		return RETURN_OK;
-	default:
-		break;
-	}
-	return result;
-}
-
-ReturnValue_t VirtualChannelReception::addMapChannel(uint8_t mapId, MapPacketExtractionIF* object) {
-	std::pair<mapChannelIterator, bool> returnValue = mapChannels.insert(
-			std::pair<uint8_t, MapPacketExtractionIF*>(mapId, object));
-	if (returnValue.second == true) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t VirtualChannelReception::handleBDFrame(TcTransferFrame* frame, ClcwIF* clcw) {
-	farmBCounter++;
-	return RETURN_OK;
-}
-
-ReturnValue_t VirtualChannelReception::handleBCFrame(TcTransferFrame* frame, ClcwIF* clcw) {
-	BcFrame content;
-	ReturnValue_t returnValue = content.initialize(frame->getFullDataField(),
-			frame->getFullDataLength());
-	if (returnValue == BC_IS_UNLOCK_COMMAND) {
-		returnValue = currentState->handleBCUnlockCommand(clcw);
-	} else if (returnValue == BC_IS_SET_VR_COMMAND) {
-		returnValue = currentState->handleBCSetVrCommand(clcw, content.vR);
-	} else {
-		//Do nothing
-	}
-	return returnValue;
-}
-
-uint8_t VirtualChannelReception::getChannelId() const {
-	return channelId;
-}
-
-ReturnValue_t VirtualChannelReception::initialize() {
-	ReturnValue_t returnValue = RETURN_FAILED;
-	if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
-		sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
-				<< (int) slidingWindowWidth << std::endl;
-		return RETURN_FAILED;
-	}
-	for (mapChannelIterator iterator = mapChannels.begin(); iterator != mapChannels.end();
-			iterator++) {
-		returnValue = iterator->second->initialize();
-		if (returnValue != RETURN_OK)
-			break;
-	}
-	return returnValue;
-}
-
-void VirtualChannelReception::setToWaitState() {
-	internalClcw.setWaitFlag(true);
-	this->currentState = &waitState;
-}
+/**
+ * @file	VirtualChannelReception.cpp
+ * @brief	This file defines the VirtualChannelReception class.
+ * @date	26.03.2013
+ * @author	baetz
+ */
+
+#include "BCFrame.h"
+#include "VirtualChannelReception.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+VirtualChannelReception::VirtualChannelReception(uint8_t setChannelId,
+		uint8_t setSlidingWindowWidth) :
+		channelId(setChannelId), slidingWindowWidth(setSlidingWindowWidth), positiveWindow(
+				setSlidingWindowWidth / 2), negativeWindow(setSlidingWindowWidth / 2), currentState(
+				&openState), openState(this), waitState(this), lockoutState(this), vR(0), farmBCounter(
+				0) {
+	internalClcw.setVirtualChannel(channelId);
+}
+
+ReturnValue_t VirtualChannelReception::mapDemultiplexing(TcTransferFrame* frame) {
+	uint8_t mapId = frame->getMAPId();
+	mapChannelIterator iter = mapChannels.find(mapId);
+	if (iter == mapChannels.end()) {
+//		error << "VirtualChannelReception::mapDemultiplexing on VC " << std::hex << (int) channelId
+//				<< ": MapChannel " << (int) mapId << std::dec << " not found." << std::endl;
+		return VC_NOT_FOUND;
+	} else {
+		return (iter->second)->extractPackets(frame);
+	}
+}
+
+ReturnValue_t VirtualChannelReception::doFARM(TcTransferFrame* frame, ClcwIF* clcw) {
+	uint8_t bypass = frame->bypassFlagSet();
+	uint8_t controlCommand = frame->controlCommandFlagSet();
+	uint8_t typeValue = (bypass << 1) + controlCommand;
+	switch (typeValue) {
+	case AD_FRAME:
+		return currentState->handleADFrame(frame, clcw);
+	case BD_FRAME:
+		return handleBDFrame(frame, clcw);
+	case BC_FRAME:
+		return handleBCFrame(frame, clcw);
+	default:
+		return ILLEGAL_FLAG_COMBINATION;
+	}
+}
+
+ReturnValue_t VirtualChannelReception::frameAcceptanceAndReportingMechanism(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+	ReturnValue_t result = RETURN_OK;
+	result = doFARM(frame, &internalClcw);
+	internalClcw.setReceiverFrameSequenceNumber(vR);
+	internalClcw.setFarmBCount(farmBCounter);
+	clcw->setWhole(internalClcw.getAsWhole());
+	switch (result) {
+	case RETURN_OK:
+		return mapDemultiplexing(frame);
+	case BC_IS_SET_VR_COMMAND:
+	case BC_IS_UNLOCK_COMMAND:
+		//Need to catch these codes to avoid error reporting later.
+		return RETURN_OK;
+	default:
+		break;
+	}
+	return result;
+}
+
+ReturnValue_t VirtualChannelReception::addMapChannel(uint8_t mapId, MapPacketExtractionIF* object) {
+	std::pair<mapChannelIterator, bool> returnValue = mapChannels.insert(
+			std::pair<uint8_t, MapPacketExtractionIF*>(mapId, object));
+	if (returnValue.second == true) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t VirtualChannelReception::handleBDFrame(TcTransferFrame* frame, ClcwIF* clcw) {
+	farmBCounter++;
+	return RETURN_OK;
+}
+
+ReturnValue_t VirtualChannelReception::handleBCFrame(TcTransferFrame* frame, ClcwIF* clcw) {
+	BcFrame content;
+	ReturnValue_t returnValue = content.initialize(frame->getFullDataField(),
+			frame->getFullDataLength());
+	if (returnValue == BC_IS_UNLOCK_COMMAND) {
+		returnValue = currentState->handleBCUnlockCommand(clcw);
+	} else if (returnValue == BC_IS_SET_VR_COMMAND) {
+		returnValue = currentState->handleBCSetVrCommand(clcw, content.vR);
+	} else {
+		//Do nothing
+	}
+	return returnValue;
+}
+
+uint8_t VirtualChannelReception::getChannelId() const {
+	return channelId;
+}
+
+ReturnValue_t VirtualChannelReception::initialize() {
+	ReturnValue_t returnValue = RETURN_FAILED;
+	if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
+		sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
+				<< (int) slidingWindowWidth << std::endl;
+		return RETURN_FAILED;
+	}
+	for (mapChannelIterator iterator = mapChannels.begin(); iterator != mapChannels.end();
+			iterator++) {
+		returnValue = iterator->second->initialize();
+		if (returnValue != RETURN_OK)
+			break;
+	}
+	return returnValue;
+}
+
+void VirtualChannelReception::setToWaitState() {
+	internalClcw.setWaitFlag(true);
+	this->currentState = &waitState;
+}
diff --git a/datalinklayer/VirtualChannelReception.h b/datalinklayer/VirtualChannelReception.h
index f7111e42a..9b4e2987e 100644
--- a/datalinklayer/VirtualChannelReception.h
+++ b/datalinklayer/VirtualChannelReception.h
@@ -1,114 +1,114 @@
-/**
- * @file	VirtualChannelReception.h
- * @brief	This file defines the VirtualChannelReception class.
- * @date	25.03.2013
- * @author	baetz
- */
-
-#ifndef VIRTUALCHANNELRECEPTION_H_
-#define VIRTUALCHANNELRECEPTION_H_
-
-#include "../datalinklayer/CCSDSReturnValuesIF.h"
-#include "../datalinklayer/Clcw.h"
-#include "../datalinklayer/Farm1StateIF.h"
-#include "../datalinklayer/Farm1StateLockout.h"
-#include "../datalinklayer/Farm1StateOpen.h"
-#include "../datalinklayer/Farm1StateWait.h"
-#include "../datalinklayer/MapPacketExtractionIF.h"
-#include "../datalinklayer/VirtualChannelReceptionIF.h"
-#include <map>
-/**
- * Implementation of a TC Virtual Channel.
- * This is a full implementation of a virtual channel as specified in the CCSDS TC Space Data Link
- * Protocol. It is designed to operate within an instance of the @c DataLinkLayer class.
- * Features:
- *  - any (6bit) Virtual Channel ID is assignable.
- *  - Supports an arbitrary number of MAP Channels (with a map).
- *  - Has a complete FARM-1 Machine built-in.
- *
- * The FARM-1 state machine uses the State Pattern.
- */
-class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSReturnValuesIF {
-	friend class Farm1StateOpen;
-	friend class Farm1StateWait;
-	friend class Farm1StateLockout;
-private:
-	uint8_t channelId;	//!< Stores the VCID that was assigned on construction.
-	uint8_t slidingWindowWidth;	//!< A constant to set the FARM-1 sliding window width.
-	uint8_t positiveWindow;	//!< The positive window for the FARM-1 machine.
-	uint8_t negativeWindow; //!< The negative window for the FARM-1 machine.
-protected:
-	Farm1StateIF* currentState;	//!< The current state. To change, one of the other states must be assigned to this pointer.
-	Farm1StateOpen openState;	//!< Instance of the FARM-1 State "Open".
-	Farm1StateWait waitState;	//!< Instance of the FARM-1 State "Wait".
-	Farm1StateLockout lockoutState;	//!< Instance of the FARM-1 State "Lockout".
-	Clcw internalClcw;	//!< A CLCW class to internally set the values before writing them back to the TTC System.
-	uint8_t vR;	//!< The Receiver Frame Sequence Number V(R) as it shall be maintained for every Virtual Channel.
-	uint8_t farmBCounter;	//!< The FARM-B COunter as it shall be maintained for every Virtual Channel.
-	typedef std::map<uint8_t, MapPacketExtractionIF*>::iterator mapChannelIterator;	//!< Typedef to simplify handling of the mapChannels map.
-	std::map<uint8_t, MapPacketExtractionIF*> mapChannels;	//!< A map that maintains all map Channels. Channels must be configured on initialization. MAy be omitted in a simplified version.
-	/**
-	 * This method handles demultiplexing to different map channels.
-	 * It parses the entries of #mapChannels and forwards the Frame to a found MAP Channel.
-	 * @param frame	The frame to forward.
-	 * @return	#VC_NOT_FOUND or the return value of the map channel extraction.
-	 */
-	ReturnValue_t mapDemultiplexing( TcTransferFrame* frame );
-	/**
-	 * A sub-method that actually does the FARM-1 handling for different Frame types.
-	 * @param frame	The Tc Transfer Frame to handle.
-	 * @param clcw	Any changes on the CLCW shall be done with this method.
-	 * @return	The return code of higher methods or @c ILLEGAL_FLAG_COMBINATION.
-	 */
-	ReturnValue_t doFARM(TcTransferFrame* frame, ClcwIF* clcw);
-	/**
-	 * Handles incoming BD Frames.
-	 * Handling these Frames is independent of the State, so no subcall to #currentState is
-	 * required.
-	 * @param frame	The Tc Transfer Frame to handle.
-	 * @param clcw	Any changes on the CLCW shall be done with this method.
-	 * @return Always returns @c RETURN_OK.
-	 */
-	ReturnValue_t handleBDFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * Handles incoming BC Frames.
-	 * The type of the BC Frame is detected and checked first, then methods of #currentState are called.
-	 * @param frame	The Tc Transfer Frame to handle.
-	 * @param clcw	Any changes on the CLCW shall be done with this method.
-	 * @return The failure code of BC Frame interpretation or the return code of higher methods.
-	 */
-	ReturnValue_t handleBCFrame( TcTransferFrame* frame, ClcwIF* clcw );
-public:
-	/**
-	 * Default constructor.
-	 * Only sets the channelId of the channel. Setting the Sliding Window width is possible as well.
-	 * @param setChannelId	Virtual Channel Identifier (VCID) of the channel.
-	 */
-	VirtualChannelReception( uint8_t setChannelId, uint8_t setSlidingWindowWidth );
-	ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * Helper method to simplify adding a mapChannel during construction.
-	 * @param mapId	The mapId of the object to add.
-	 * @param object	Pointer to the MapPacketExtraction object itself.
-	 * @return	@c RETURN_OK if the channel was successfully inserted, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t addMapChannel( uint8_t mapId, MapPacketExtractionIF* object );
-	/**
-	 * The initialization routine checks the set #slidingWindowWidth and initializes all MAP
-	 * channels.
-	 * @return	@c RETURN_OK on successful initialization, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t initialize();
-	/**
-	 * Getter for the VCID.
-	 * @return	The #channelId.
-	 */
-	uint8_t getChannelId() const;
-	/**
-	 * Small method to set the state to Farm1StateWait.
-	 */
-	void setToWaitState();
-};
-
-
-#endif /* VIRTUALCHANNELRECEPTION_H_ */
+/**
+ * @file	VirtualChannelReception.h
+ * @brief	This file defines the VirtualChannelReception class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef VIRTUALCHANNELRECEPTION_H_
+#define VIRTUALCHANNELRECEPTION_H_
+
+#include "CCSDSReturnValuesIF.h"
+#include "Clcw.h"
+#include "Farm1StateIF.h"
+#include "Farm1StateLockout.h"
+#include "Farm1StateOpen.h"
+#include "Farm1StateWait.h"
+#include "MapPacketExtractionIF.h"
+#include "VirtualChannelReceptionIF.h"
+#include <map>
+/**
+ * Implementation of a TC Virtual Channel.
+ * This is a full implementation of a virtual channel as specified in the CCSDS TC Space Data Link
+ * Protocol. It is designed to operate within an instance of the @c DataLinkLayer class.
+ * Features:
+ *  - any (6bit) Virtual Channel ID is assignable.
+ *  - Supports an arbitrary number of MAP Channels (with a map).
+ *  - Has a complete FARM-1 Machine built-in.
+ *
+ * The FARM-1 state machine uses the State Pattern.
+ */
+class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSReturnValuesIF {
+	friend class Farm1StateOpen;
+	friend class Farm1StateWait;
+	friend class Farm1StateLockout;
+private:
+	uint8_t channelId;	//!< Stores the VCID that was assigned on construction.
+	uint8_t slidingWindowWidth;	//!< A constant to set the FARM-1 sliding window width.
+	uint8_t positiveWindow;	//!< The positive window for the FARM-1 machine.
+	uint8_t negativeWindow; //!< The negative window for the FARM-1 machine.
+protected:
+	Farm1StateIF* currentState;	//!< The current state. To change, one of the other states must be assigned to this pointer.
+	Farm1StateOpen openState;	//!< Instance of the FARM-1 State "Open".
+	Farm1StateWait waitState;	//!< Instance of the FARM-1 State "Wait".
+	Farm1StateLockout lockoutState;	//!< Instance of the FARM-1 State "Lockout".
+	Clcw internalClcw;	//!< A CLCW class to internally set the values before writing them back to the TTC System.
+	uint8_t vR;	//!< The Receiver Frame Sequence Number V(R) as it shall be maintained for every Virtual Channel.
+	uint8_t farmBCounter;	//!< The FARM-B COunter as it shall be maintained for every Virtual Channel.
+	typedef std::map<uint8_t, MapPacketExtractionIF*>::iterator mapChannelIterator;	//!< Typedef to simplify handling of the mapChannels map.
+	std::map<uint8_t, MapPacketExtractionIF*> mapChannels;	//!< A map that maintains all map Channels. Channels must be configured on initialization. MAy be omitted in a simplified version.
+	/**
+	 * This method handles demultiplexing to different map channels.
+	 * It parses the entries of #mapChannels and forwards the Frame to a found MAP Channel.
+	 * @param frame	The frame to forward.
+	 * @return	#VC_NOT_FOUND or the return value of the map channel extraction.
+	 */
+	ReturnValue_t mapDemultiplexing( TcTransferFrame* frame );
+	/**
+	 * A sub-method that actually does the FARM-1 handling for different Frame types.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return	The return code of higher methods or @c ILLEGAL_FLAG_COMBINATION.
+	 */
+	ReturnValue_t doFARM(TcTransferFrame* frame, ClcwIF* clcw);
+	/**
+	 * Handles incoming BD Frames.
+	 * Handling these Frames is independent of the State, so no subcall to #currentState is
+	 * required.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return Always returns @c RETURN_OK.
+	 */
+	ReturnValue_t handleBDFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * Handles incoming BC Frames.
+	 * The type of the BC Frame is detected and checked first, then methods of #currentState are called.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return The failure code of BC Frame interpretation or the return code of higher methods.
+	 */
+	ReturnValue_t handleBCFrame( TcTransferFrame* frame, ClcwIF* clcw );
+public:
+	/**
+	 * Default constructor.
+	 * Only sets the channelId of the channel. Setting the Sliding Window width is possible as well.
+	 * @param setChannelId	Virtual Channel Identifier (VCID) of the channel.
+	 */
+	VirtualChannelReception( uint8_t setChannelId, uint8_t setSlidingWindowWidth );
+	ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * Helper method to simplify adding a mapChannel during construction.
+	 * @param mapId	The mapId of the object to add.
+	 * @param object	Pointer to the MapPacketExtraction object itself.
+	 * @return	@c RETURN_OK if the channel was successfully inserted, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t addMapChannel( uint8_t mapId, MapPacketExtractionIF* object );
+	/**
+	 * The initialization routine checks the set #slidingWindowWidth and initializes all MAP
+	 * channels.
+	 * @return	@c RETURN_OK on successful initialization, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t initialize();
+	/**
+	 * Getter for the VCID.
+	 * @return	The #channelId.
+	 */
+	uint8_t getChannelId() const;
+	/**
+	 * Small method to set the state to Farm1StateWait.
+	 */
+	void setToWaitState();
+};
+
+
+#endif /* VIRTUALCHANNELRECEPTION_H_ */
diff --git a/datalinklayer/VirtualChannelReceptionIF.h b/datalinklayer/VirtualChannelReceptionIF.h
index da5440814..36f60e8c4 100644
--- a/datalinklayer/VirtualChannelReceptionIF.h
+++ b/datalinklayer/VirtualChannelReceptionIF.h
@@ -1,57 +1,57 @@
-/**
- * @file	VirtualChannelReceptionIF.h
- * @brief	This file defines the VirtualChannelReceptionIF class.
- * @date	25.03.2013
- * @author	baetz
- */
-
-#ifndef VIRTUALCHANNELRECEPTIONIF_H_
-#define VIRTUALCHANNELRECEPTIONIF_H_
-
-#include "../datalinklayer/ClcwIF.h"
-#include "../datalinklayer/TcTransferFrame.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-/**
- * This is the interface for Virtual Channel reception classes.
- * It represents a single TC Virtual Channel that operates on one IO
- */
-class VirtualChannelReceptionIF {
-public:
-	/**
-	 * Enum including all valid types of frames.
-	 * The type is made up by two flags, so 0b1111 is definitely illegal.
-	 */
-	enum frameType  {
-		AD_FRAME = 0b00,
-		BC_FRAME = 0b11,
-		BD_FRAME = 0b10,
-		ILLEGAL_FRAME = 0b1111
-	};
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~VirtualChannelReceptionIF() {
-	}
-	/**
-	 * This method shall accept frames and do all FARM-1 stuff.
-	 * Handling the Frame includes forwarding to higher-level procedures.
-	 * @param frame	The Tc Transfer Frame that was received and checked.
-	 * @param clcw	Any changes to the CLCW value are forwarded by using this parameter.
-	 * @return The return Value shall indicate successful processing with @c RETURN_OK.
-	 */
-	virtual ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
-	/**
-	 * If any other System Objects are required for operation they shall be initialized here.
-	 * @return	@c RETURN_OK for successful initialization.
-	 */
-	virtual ReturnValue_t initialize() = 0;
-	/**
-	 * Getter for the VCID.
-	 * @return	The #channelId.
-	 */
-	virtual uint8_t getChannelId() const = 0;
-};
-
-
-#endif /* VIRTUALCHANNELRECEPTIONIF_H_ */
+/**
+ * @file	VirtualChannelReceptionIF.h
+ * @brief	This file defines the VirtualChannelReceptionIF class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef VIRTUALCHANNELRECEPTIONIF_H_
+#define VIRTUALCHANNELRECEPTIONIF_H_
+
+#include "ClcwIF.h"
+#include "TcTransferFrame.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * This is the interface for Virtual Channel reception classes.
+ * It represents a single TC Virtual Channel that operates on one IO
+ */
+class VirtualChannelReceptionIF {
+public:
+	/**
+	 * Enum including all valid types of frames.
+	 * The type is made up by two flags, so 0b1111 is definitely illegal.
+	 */
+	enum frameType  {
+		AD_FRAME = 0b00,
+		BC_FRAME = 0b11,
+		BD_FRAME = 0b10,
+		ILLEGAL_FRAME = 0b1111
+	};
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~VirtualChannelReceptionIF() {
+	}
+	/**
+	 * This method shall accept frames and do all FARM-1 stuff.
+	 * Handling the Frame includes forwarding to higher-level procedures.
+	 * @param frame	The Tc Transfer Frame that was received and checked.
+	 * @param clcw	Any changes to the CLCW value are forwarded by using this parameter.
+	 * @return The return Value shall indicate successful processing with @c RETURN_OK.
+	 */
+	virtual ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
+	/**
+	 * If any other System Objects are required for operation they shall be initialized here.
+	 * @return	@c RETURN_OK for successful initialization.
+	 */
+	virtual ReturnValue_t initialize() = 0;
+	/**
+	 * Getter for the VCID.
+	 * @return	The #channelId.
+	 */
+	virtual uint8_t getChannelId() const = 0;
+};
+
+
+#endif /* VIRTUALCHANNELRECEPTIONIF_H_ */

From e800aad97993d36f6800a35cc6ccd805a6e269d1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:44:10 +0200
Subject: [PATCH 0678/1774] event git update

---
 events/Event.cpp                              |  28 +-
 events/Event.h                                |  89 +++--
 events/EventManager.cpp                       | 320 +++++++++---------
 events/EventManager.h                         | 122 +++----
 events/EventManagerIF.h                       | 104 +++---
 events/EventMessage.cpp                       | 228 ++++++-------
 events/EventMessage.h                         | 104 +++---
 events/EventReportingProxyIF.h                |  38 +--
 events/eventmatching/EventIdRangeMatcher.cpp  |  24 +-
 events/eventmatching/EventIdRangeMatcher.h    |  26 +-
 events/eventmatching/EventMatchTree.cpp       | 298 ++++++++--------
 events/eventmatching/EventMatchTree.h         |  72 ++--
 events/eventmatching/EventRangeMatcherBase.h  |  58 ++--
 events/eventmatching/ReporterRangeMatcher.cpp |  26 +-
 events/eventmatching/ReporterRangeMatcher.h   |  26 +-
 events/eventmatching/SeverityRangeMatcher.cpp |  28 +-
 events/eventmatching/SeverityRangeMatcher.h   |  26 +-
 events/eventmatching/eventmatching.h          |  20 +-
 18 files changed, 813 insertions(+), 824 deletions(-)

diff --git a/events/Event.cpp b/events/Event.cpp
index a94ae6db3..ea3d46fe4 100644
--- a/events/Event.cpp
+++ b/events/Event.cpp
@@ -1,14 +1,14 @@
-#include "../events/Event.h"
-namespace EVENT {
-EventId_t getEventId(Event event) {
-	return (event & 0xFFFF);
-}
-
-EventSeverity_t getSeverity(Event event) {
-	return ((event >> 16) & 0xFF);
-}
-
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity) {
-	return (eventSeverity << 16) + (eventId & 0xFFFF);
-}
-}
+#include "Event.h"
+namespace EVENT {
+EventId_t getEventId(Event event) {
+	return (event & 0xFFFF);
+}
+
+EventSeverity_t getSeverity(Event event) {
+	return ((event >> 16) & 0xFF);
+}
+
+Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity) {
+	return (eventSeverity << 16) + (eventId & 0xFFFF);
+}
+}
diff --git a/events/Event.h b/events/Event.h
index f613e701d..e22c9db16 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -1,45 +1,44 @@
-#ifndef FRAMEWORK_EVENTS_EVENT_H_
-#define FRAMEWORK_EVENTS_EVENT_H_
-
-#include <cstdint>
-#include "../events/fwSubsystemIdRanges.h"
-//could be move to more suitable location
-#include <subsystemIdRanges.h>
-
-typedef uint16_t EventId_t;
-typedef uint8_t EventSeverity_t;
-
-#define MAKE_EVENT(id, severity) (((severity)<<16)+(SUBSYSTEM_ID*100)+(id))
-
-typedef uint32_t Event;
-
-namespace EVENT {
-EventId_t getEventId(Event event);
-
-EventSeverity_t getSeverity(Event event);
-
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
-
-}
-
-namespace SEVERITY {
-	static const EventSeverity_t INFO = 1;
-	static const EventSeverity_t LOW = 2;
-	static const EventSeverity_t MEDIUM = 3;
-	static const EventSeverity_t HIGH = 4;
-}
-
-//Unfortunately, this does not work nicely because of the inability to define static classes in headers.
-//struct Event {
-//	Event(uint8_t domain, uint8_t counter, EventSeverity_t severity) :
-//			id(domain*100+counter), severity(severity) {
-//	}
-//	EventId_t id;
-//	EventSeverity_t severity;
-//	static const EventSeverity_t INFO = 1;
-//	static const EventSeverity_t LOW = 2;
-//	static const EventSeverity_t MEDIUM = 3;
-//	static const EventSeverity_t HIGH = 4;
-//};
-
-#endif /* FRAMEWORK_EVENTS_EVENT_H_ */
+#ifndef EVENTOBJECT_EVENT_H_
+#define EVENTOBJECT_EVENT_H_
+
+#include <stdint.h>
+#include "fwSubsystemIdRanges.h"
+//could be move to more suitable location
+#include <config/tmtc/subsystemIdRanges.h>
+
+typedef uint16_t EventId_t;
+typedef uint8_t EventSeverity_t;
+
+#define MAKE_EVENT(id, severity) (((severity)<<16)+(SUBSYSTEM_ID*100)+(id))
+
+typedef uint32_t Event;
+
+namespace EVENT {
+EventId_t getEventId(Event event);
+
+EventSeverity_t getSeverity(Event event);
+
+Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
+
+}
+namespace SEVERITY {
+	static const EventSeverity_t INFO = 1;
+	static const EventSeverity_t LOW = 2;
+	static const EventSeverity_t MEDIUM = 3;
+	static const EventSeverity_t HIGH = 4;
+}
+
+//Unfortunately, this does not work nicely because of the inability to define static classes in headers.
+//struct Event {
+//	Event(uint8_t domain, uint8_t counter, EventSeverity_t severity) :
+//			id(domain*100+counter), severity(severity) {
+//	}
+//	EventId_t id;
+//	EventSeverity_t severity;
+//	static const EventSeverity_t INFO = 1;
+//	static const EventSeverity_t LOW = 2;
+//	static const EventSeverity_t MEDIUM = 3;
+//	static const EventSeverity_t HIGH = 4;
+//};
+
+#endif /* EVENTOBJECT_EVENT_H_ */
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 5848dd744..e58f251ac 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,165 +1,155 @@
-#include "../events/EventManager.h"
-#include "../events/EventMessage.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../ipc/QueueFactory.h"
-#include "../ipc/MutexFactory.h"
-
-
-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.
-// 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),
-		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
-	mutex = MutexFactory::instance()->createMutex();
-	eventReportQueue = QueueFactory::instance()->createMessageQueue(
-			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
-}
-
-EventManager::~EventManager() {
-	QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-MessageQueueId_t EventManager::getEventReportQueue() {
-	return eventReportQueue->getId();
-}
-
-ReturnValue_t EventManager::performOperation(uint8_t opCode) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	while (result == HasReturnvaluesIF::RETURN_OK) {
-		EventMessage message;
-		result = eventReportQueue->receiveMessage(&message);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-#ifdef DEBUG
-			printEvent(&message);
-#endif
-			notifyListeners(&message);
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void EventManager::notifyListeners(EventMessage* message) {
-	lockMutex();
-	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
-		if (iter->second.match(message)) {
-			MessageQueueSenderIF::sendMessage(iter->first, message,
-			        message->getSender());
-		}
-	}
-	unlockMutex();
-}
-
-ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
-bool forwardAllButSelected) {
-	auto result = listenerList.insert(
-			std::pair<MessageQueueId_t, EventMatchTree>(listener,
-					EventMatchTree(&factoryBackend, forwardAllButSelected)));
-	if (!result.second) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener,
-		EventId_t event) {
-	return subscribeToEventRange(listener, event);
-}
-
-ReturnValue_t EventManager::subscribeToAllEventsFrom(MessageQueueId_t listener,
-		object_id_t object) {
-	return subscribeToEventRange(listener, 0, 0, true, object);
-}
-
-ReturnValue_t EventManager::subscribeToEventRange(MessageQueueId_t listener,
-		EventId_t idFrom, EventId_t idTo, bool idInverted,
-		object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	auto iter = listenerList.find(listener);
-	if (iter == listenerList.end()) {
-		return LISTENER_NOT_FOUND;
-	}
-	lockMutex();
-	ReturnValue_t result = iter->second.addMatch(idFrom, idTo, idInverted,
-			reporterFrom, reporterTo, reporterInverted);
-	unlockMutex();
-	return result;
-}
-
-ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
-		EventId_t idFrom, EventId_t idTo, bool idInverted,
-		object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	auto iter = listenerList.find(listener);
-	if (iter == listenerList.end()) {
-		return LISTENER_NOT_FOUND;
-	}
-	lockMutex();
-	ReturnValue_t result = iter->second.removeMatch(idFrom, idTo, idInverted,
-			reporterFrom, reporterTo, reporterInverted);
-	unlockMutex();
-	return result;
-}
-
-#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:
-		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
-
-void EventManager::lockMutex() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-}
-
-void EventManager::unlockMutex() {
-	mutex->unlockMutex();
-}
+#include "EventManager.h"
+#include "EventMessage.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../ipc/QueueFactory.h"
+#include "../ipc/MutexFactory.h"
+
+
+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.
+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) {
+	mutex = MutexFactory::instance()->createMutex();
+	eventReportQueue = QueueFactory::instance()->createMessageQueue(
+			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
+}
+
+EventManager::~EventManager() {
+	QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+MessageQueueId_t EventManager::getEventReportQueue() {
+	return eventReportQueue->getId();
+}
+
+ReturnValue_t EventManager::performOperation(uint8_t opCode) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	while (result == HasReturnvaluesIF::RETURN_OK) {
+		EventMessage message;
+		result = eventReportQueue->receiveMessage(&message);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+#ifdef DEBUG
+			printEvent(&message);
+#endif
+			notifyListeners(&message);
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void EventManager::notifyListeners(EventMessage* message) {
+	lockMutex();
+	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
+		if (iter->second.match(message)) {
+			MessageQueueSenderIF::sendMessage(iter->first, message,
+					message->getSender());
+		}
+	}
+	unlockMutex();
+}
+
+ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
+bool forwardAllButSelected) {
+	auto result = listenerList.insert(
+			std::pair<MessageQueueId_t, EventMatchTree>(listener,
+					EventMatchTree(&factoryBackend, forwardAllButSelected)));
+	if (!result.second) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener,
+		EventId_t event) {
+	return subscribeToEventRange(listener, event);
+}
+
+ReturnValue_t EventManager::subscribeToAllEventsFrom(MessageQueueId_t listener,
+		object_id_t object) {
+	return subscribeToEventRange(listener, 0, 0, true, object);
+}
+
+ReturnValue_t EventManager::subscribeToEventRange(MessageQueueId_t listener,
+		EventId_t idFrom, EventId_t idTo, bool idInverted,
+		object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+	auto iter = listenerList.find(listener);
+	if (iter == listenerList.end()) {
+		return LISTENER_NOT_FOUND;
+	}
+	lockMutex();
+	ReturnValue_t result = iter->second.addMatch(idFrom, idTo, idInverted,
+			reporterFrom, reporterTo, reporterInverted);
+	unlockMutex();
+	return result;
+}
+
+ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
+		EventId_t idFrom, EventId_t idTo, bool idInverted,
+		object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+	auto iter = listenerList.find(listener);
+	if (iter == listenerList.end()) {
+		return LISTENER_NOT_FOUND;
+	}
+	lockMutex();
+	ReturnValue_t result = iter->second.removeMatch(idFrom, idTo, idInverted,
+			reporterFrom, reporterTo, reporterInverted);
+	unlockMutex();
+	return result;
+}
+
+#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:
+		string = translateObject(message->getReporter());
+		sif::error << "EVENT: ";
+		if (string != 0) {
+			sif::error << string;
+		} else {
+			sif::error << "0x" << std::hex << message->getReporter() << std::dec;
+		}
+		sif::error << " reported " << translateEvents(message->getEvent()) << " ("
+				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
+				<< message->getParameter1() << " P2: 0x"
+				<< message->getParameter2() << std::dec << std::endl;
+		break;
+	}
+
+}
+#endif
+
+void EventManager::lockMutex() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+}
+
+void EventManager::unlockMutex() {
+	mutex->unlockMutex();
+}
diff --git a/events/EventManager.h b/events/EventManager.h
index 5323edd8b..7badc3bf6 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -1,61 +1,61 @@
-#ifndef EVENTMANAGER_H_
-#define EVENTMANAGER_H_
-
-#include "../events/eventmatching/EventMatchTree.h"
-#include "../events/EventManagerIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../storagemanager/LocalPool.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../ipc/MutexIF.h"
-#include <map>
-
-class EventManager: public EventManagerIF,
-		public ExecutableObjectIF,
-		public SystemObject {
-public:
-	static const uint16_t MAX_EVENTS_PER_CYCLE = 80;
-
-	EventManager(object_id_t setObjectId);
-	virtual ~EventManager();
-
-	MessageQueueId_t getEventReportQueue();
-
-	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
-	ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
-	ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
-			object_id_t object);
-	ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	ReturnValue_t performOperation(uint8_t opCode);
-protected:
-
-	MessageQueueIF* eventReportQueue = nullptr;
-
-	std::map<MessageQueueId_t, EventMatchTree> listenerList;
-
-	MutexIF* mutex = nullptr;
-
-	static const uint8_t N_POOLS = 3;
-	LocalPool<N_POOLS> factoryBackend;
-	static const uint16_t POOL_SIZES[N_POOLS];
-	static const uint16_t N_ELEMENTS[N_POOLS];
-
-	void notifyListeners(EventMessage *message);
-
-#ifdef DEBUG
-	void printEvent(EventMessage *message);
-#endif
-
-	void lockMutex();
-
-	void unlockMutex();
-};
-
-#endif /* EVENTMANAGER_H_ */
+#ifndef EVENTMANAGER_H_
+#define EVENTMANAGER_H_
+
+#include "eventmatching/EventMatchTree.h"
+#include "EventManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../storagemanager/LocalPool.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+class EventManager: public EventManagerIF,
+		public ExecutableObjectIF,
+		public SystemObject {
+public:
+	static const uint16_t MAX_EVENTS_PER_CYCLE = 80;
+
+	EventManager(object_id_t setObjectId);
+	virtual ~EventManager();
+
+	MessageQueueId_t getEventReportQueue();
+
+	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
+	ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
+	ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
+			object_id_t object);
+	ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t performOperation(uint8_t opCode);
+protected:
+
+	MessageQueueIF* eventReportQueue;
+
+	std::map<MessageQueueId_t, EventMatchTree> listenerList;
+
+	MutexIF* mutex;
+
+	static const uint8_t N_POOLS = 3;
+	LocalPool<N_POOLS> factoryBackend;
+	static const uint16_t POOL_SIZES[N_POOLS];
+	static const uint16_t N_ELEMENTS[N_POOLS];
+
+	void notifyListeners(EventMessage *message);
+
+#ifdef DEBUG
+	void printEvent(EventMessage *message);
+#endif
+
+	void lockMutex();
+
+	void unlockMutex();
+};
+
+#endif /* EVENTMANAGER_H_ */
diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h
index bb36f0a31..f9ac420b3 100644
--- a/events/EventManagerIF.h
+++ b/events/EventManagerIF.h
@@ -1,52 +1,52 @@
-#ifndef EVENTMANAGERIF_H_
-#define EVENTMANAGERIF_H_
-
-#include "../events/eventmatching/eventmatching.h"
-#include "../events/EventMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-class EventManagerIF {
-public:
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::EVENT_MANAGER_IF;
-	static const ReturnValue_t LISTENER_NOT_FOUND = MAKE_RETURN_CODE(1);
-	virtual ~EventManagerIF() {
-	}
-
-	virtual MessageQueueId_t getEventReportQueue() = 0;
-
-	virtual ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false) = 0;
-	virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener,
-			EventId_t event) = 0;
-	virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
-			object_id_t object) = 0;
-	virtual ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false) = 0;
-	virtual ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false) = 0;
-
-	static void triggerEvent(object_id_t reportingObject, Event event,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0, MessageQueueId_t sentFrom = 0) {
-		EventMessage message(event, reportingObject, parameter1, parameter2);
-		triggerEvent(&message, sentFrom);
-	}
-	static void triggerEvent(EventMessage* message, MessageQueueId_t sentFrom = 0) {
-		static MessageQueueId_t eventmanagerQueue = 0;
-		if (eventmanagerQueue == 0) {
-			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
-					objects::EVENT_MANAGER);
-			if (eventmanager != NULL) {
-				eventmanagerQueue = eventmanager->getEventReportQueue();
-			}
-		}
-		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
-	}
-
-};
-
-#endif /* EVENTMANAGERIF_H_ */
+#ifndef EVENTMANAGERIF_H_
+#define EVENTMANAGERIF_H_
+
+#include "eventmatching/eventmatching.h"
+#include "EventMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class EventManagerIF {
+public:
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::EVENT_MANAGER_IF;
+	static const ReturnValue_t LISTENER_NOT_FOUND = MAKE_RETURN_CODE(1);
+	virtual ~EventManagerIF() {
+	}
+
+	virtual MessageQueueId_t getEventReportQueue() = 0;
+
+	virtual ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false) = 0;
+	virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener,
+			EventId_t event) = 0;
+	virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
+			object_id_t object) = 0;
+	virtual ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false) = 0;
+	virtual ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false) = 0;
+
+	static void triggerEvent(object_id_t reportingObject, Event event,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0, MessageQueueId_t sentFrom = 0) {
+		EventMessage message(event, reportingObject, parameter1, parameter2);
+		triggerEvent(&message, sentFrom);
+	}
+	static void triggerEvent(EventMessage* message, MessageQueueId_t sentFrom = 0) {
+		static MessageQueueId_t eventmanagerQueue = 0;
+		if (eventmanagerQueue == 0) {
+			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
+					objects::EVENT_MANAGER);
+			if (eventmanager != NULL) {
+				eventmanagerQueue = eventmanager->getEventReportQueue();
+			}
+		}
+		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
+	}
+
+};
+
+#endif /* EVENTMANAGERIF_H_ */
diff --git a/events/EventMessage.cpp b/events/EventMessage.cpp
index 28538f7f8..b911abab9 100644
--- a/events/EventMessage.cpp
+++ b/events/EventMessage.cpp
@@ -1,114 +1,114 @@
-#include "../events/EventMessage.h"
-#include <cstring>
-
-EventMessage::EventMessage() {
-	messageSize = EVENT_MESSAGE_SIZE;
-	clearEventMessage();
-}
-
-EventMessage::EventMessage(Event event, object_id_t reporter,
-		uint32_t parameter1, uint32_t parameter2) {
-	messageSize = EVENT_MESSAGE_SIZE;
-	setMessageId(EVENT_MESSAGE);
-	setEvent(event);
-	setReporter(reporter);
-	setParameter1(parameter1);
-	setParameter2(parameter2);
-}
-
-EventMessage::~EventMessage() {
-}
-
-Event EventMessage::getEvent() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return (event & 0xFFFFFF);
-}
-
-void EventMessage::setEvent(Event event) {
-	Event tempEvent;
-	memcpy(&tempEvent, getData(), sizeof(Event));
-	tempEvent = (tempEvent & 0xFF000000) + (event & 0xFFFFFF);
-	memcpy(getData(), &tempEvent, sizeof(Event));
-}
-
-uint8_t EventMessage::getMessageId() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return (event & 0xFF000000) >> 24;
-}
-
-void EventMessage::setMessageId(uint8_t id) {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	event = (event & 0x00FFFFFF) + (id << 24);
-	memcpy(getData(), &event, sizeof(Event));
-}
-
-EventSeverity_t EventMessage::getSeverity() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getSeverity(event);
-}
-
-void EventMessage::setSeverity(EventSeverity_t severity) {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	event = (event & 0xFF00FFFF) + (severity << 16);
-	memcpy(getData(), &event, sizeof(Event));
-}
-
-EventId_t EventMessage::getEventId() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getEventId(event);
-}
-
-void EventMessage::setEventId(EventId_t eventId) {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	event = (event & 0xFFFF0000) + eventId;
-	memcpy(getData(), &event, sizeof(Event));
-}
-
-object_id_t EventMessage::getReporter() {
-	object_id_t parameter;
-	memcpy(&parameter, getData() + sizeof(Event), sizeof(object_id_t));
-	return parameter;
-}
-
-void EventMessage::setReporter(object_id_t reporter) {
-	memcpy(getData() + sizeof(Event), &reporter, sizeof(object_id_t));
-}
-
-uint32_t EventMessage::getParameter1() {
-	uint32_t parameter;
-	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t), 4);
-	return parameter;
-}
-
-void EventMessage::setParameter1(uint32_t parameter) {
-	memcpy(getData() + sizeof(Event) + sizeof(object_id_t), &parameter, 4);
-}
-
-uint32_t EventMessage::getParameter2() {
-	uint32_t parameter;
-	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t) + 4, 4);
-	return parameter;
-}
-
-void EventMessage::setParameter2(uint32_t parameter) {
-	memcpy(getData() + sizeof(Event) + sizeof(object_id_t) + 4, &parameter, 4);
-}
-
-void EventMessage::clearEventMessage() {
-	setEvent(INVALID_EVENT);
-}
-
-bool EventMessage::isClearedEventMessage() {
-	return getEvent() == INVALID_EVENT;
-}
-
-size_t EventMessage::getMinimumMessageSize() {
-	return EVENT_MESSAGE_SIZE;
-}
+#include "EventMessage.h"
+#include <cstring>
+
+EventMessage::EventMessage() {
+	messageSize = EVENT_MESSAGE_SIZE;
+	clearEventMessage();
+}
+
+EventMessage::EventMessage(Event event, object_id_t reporter,
+		uint32_t parameter1, uint32_t parameter2) {
+	messageSize = EVENT_MESSAGE_SIZE;
+	setMessageId(EVENT_MESSAGE);
+	setEvent(event);
+	setReporter(reporter);
+	setParameter1(parameter1);
+	setParameter2(parameter2);
+}
+
+EventMessage::~EventMessage() {
+}
+
+Event EventMessage::getEvent() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return (event & 0xFFFFFF);
+}
+
+void EventMessage::setEvent(Event event) {
+	Event tempEvent;
+	memcpy(&tempEvent, getData(), sizeof(Event));
+	tempEvent = (tempEvent & 0xFF000000) + (event & 0xFFFFFF);
+	memcpy(getData(), &tempEvent, sizeof(Event));
+}
+
+uint8_t EventMessage::getMessageId() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return (event & 0xFF000000) >> 24;
+}
+
+void EventMessage::setMessageId(uint8_t id) {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	event = (event & 0x00FFFFFF) + (id << 24);
+	memcpy(getData(), &event, sizeof(Event));
+}
+
+EventSeverity_t EventMessage::getSeverity() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return EVENT::getSeverity(event);
+}
+
+void EventMessage::setSeverity(EventSeverity_t severity) {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	event = (event & 0xFF00FFFF) + (severity << 16);
+	memcpy(getData(), &event, sizeof(Event));
+}
+
+EventId_t EventMessage::getEventId() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return EVENT::getEventId(event);
+}
+
+void EventMessage::setEventId(EventId_t eventId) {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	event = (event & 0xFFFF0000) + eventId;
+	memcpy(getData(), &event, sizeof(Event));
+}
+
+object_id_t EventMessage::getReporter() {
+	object_id_t parameter;
+	memcpy(&parameter, getData() + sizeof(Event), sizeof(object_id_t));
+	return parameter;
+}
+
+void EventMessage::setReporter(object_id_t reporter) {
+	memcpy(getData() + sizeof(Event), &reporter, sizeof(object_id_t));
+}
+
+uint32_t EventMessage::getParameter1() {
+	uint32_t parameter;
+	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t), 4);
+	return parameter;
+}
+
+void EventMessage::setParameter1(uint32_t parameter) {
+	memcpy(getData() + sizeof(Event) + sizeof(object_id_t), &parameter, 4);
+}
+
+uint32_t EventMessage::getParameter2() {
+	uint32_t parameter;
+	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t) + 4, 4);
+	return parameter;
+}
+
+void EventMessage::setParameter2(uint32_t parameter) {
+	memcpy(getData() + sizeof(Event) + sizeof(object_id_t) + 4, &parameter, 4);
+}
+
+void EventMessage::clearEventMessage() {
+	setEvent(INVALID_EVENT);
+}
+
+bool EventMessage::isClearedEventMessage() {
+	return getEvent() == INVALID_EVENT;
+}
+
+size_t EventMessage::getMinimumMessageSize() {
+	return EVENT_MESSAGE_SIZE;
+}
diff --git a/events/EventMessage.h b/events/EventMessage.h
index 8769333b0..4d003bd7b 100644
--- a/events/EventMessage.h
+++ b/events/EventMessage.h
@@ -1,52 +1,52 @@
-#ifndef EVENTMESSAGE_H_
-#define EVENTMESSAGE_H_
-
-#include "../events/Event.h"
-#include "../ipc/MessageQueueMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-/**
- * Passing on events through IPC.
- * Event Id, severity and message type retrieval is a bit difficult.
- */
-class EventMessage: public MessageQueueMessage {
-public:
-	static const uint8_t EVENT_MESSAGE = 0; //!< Normal event
-	static const uint8_t CONFIRMATION_REQUEST = 1; //!< Request to parent if event is caused by child or not.
-	static const uint8_t YOUR_FAULT = 2; //!< The fault was caused by child, parent believes it's ok.
-	static const uint8_t MY_FAULT = 3; //!< The fault was caused by the parent, child is ok.
-	//Add other messageIDs here if necessary.
-	static const uint8_t EVENT_MESSAGE_SIZE = HEADER_SIZE + sizeof(Event)
-			+ 3 * sizeof(uint32_t);
-
-	EventMessage();
-//	EventMessage(EventId_t event, EventSeverity_t severity,
-//			object_id_t reporter, uint32_t parameter1, uint32_t parameter2 = 0);
-	EventMessage(Event event, object_id_t reporter, uint32_t parameter1,
-			uint32_t parameter2 = 0);
-	virtual ~EventMessage();
-	Event getEvent();
-	void setEvent(Event event);
-	uint8_t getMessageId();
-	void setMessageId(uint8_t id);
-	EventSeverity_t getSeverity();
-	void setSeverity(EventSeverity_t severity);
-	EventId_t getEventId();
-	void setEventId(EventId_t event);
-	object_id_t getReporter();
-	void setReporter(object_id_t reporter);
-	uint32_t getParameter1();
-	void setParameter1(uint32_t parameter);
-	uint32_t getParameter2();
-	void setParameter2(uint32_t parameter);
-
-	void clearEventMessage();
-	bool isClearedEventMessage();
-
-protected:
-	static const Event INVALID_EVENT = 0;
-	virtual size_t getMinimumMessageSize();
-
-};
-
-#endif /* EVENTMESSAGE_H_ */
+#ifndef EVENTMESSAGE_H_
+#define EVENTMESSAGE_H_
+
+#include "Event.h"
+#include "../ipc/MessageQueueMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+/**
+ * Passing on events through IPC.
+ * Event Id, severity and message type retrieval is a bit difficult.
+ */
+class EventMessage: public MessageQueueMessage {
+public:
+	static const uint8_t EVENT_MESSAGE = 0; //!< Normal event
+	static const uint8_t CONFIRMATION_REQUEST = 1; //!< Request to parent if event is caused by child or not.
+	static const uint8_t YOUR_FAULT = 2; //!< The fault was caused by child, parent believes it's ok.
+	static const uint8_t MY_FAULT = 3; //!< The fault was caused by the parent, child is ok.
+	//Add other messageIDs here if necessary.
+	static const uint8_t EVENT_MESSAGE_SIZE = HEADER_SIZE + sizeof(Event)
+			+ 3 * sizeof(uint32_t);
+
+	EventMessage();
+//	EventMessage(EventId_t event, EventSeverity_t severity,
+//			object_id_t reporter, uint32_t parameter1, uint32_t parameter2 = 0);
+	EventMessage(Event event, object_id_t reporter, uint32_t parameter1,
+			uint32_t parameter2 = 0);
+	virtual ~EventMessage();
+	Event getEvent();
+	void setEvent(Event event);
+	uint8_t getMessageId();
+	void setMessageId(uint8_t id);
+	EventSeverity_t getSeverity();
+	void setSeverity(EventSeverity_t severity);
+	EventId_t getEventId();
+	void setEventId(EventId_t event);
+	object_id_t getReporter();
+	void setReporter(object_id_t reporter);
+	uint32_t getParameter1();
+	void setParameter1(uint32_t parameter);
+	uint32_t getParameter2();
+	void setParameter2(uint32_t parameter);
+
+	void clearEventMessage();
+	bool isClearedEventMessage();
+
+protected:
+	static const Event INVALID_EVENT = 0;
+	virtual size_t getMinimumMessageSize();
+
+};
+
+#endif /* EVENTMESSAGE_H_ */
diff --git a/events/EventReportingProxyIF.h b/events/EventReportingProxyIF.h
index 1b8064bd1..7a96e3d18 100644
--- a/events/EventReportingProxyIF.h
+++ b/events/EventReportingProxyIF.h
@@ -1,19 +1,19 @@
-#ifndef FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
-#define FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
-
-#include "../events/Event.h"
-
-
-class EventReportingProxyIF {
-public:
-	virtual ~EventReportingProxyIF() {
-	}
-
-	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const = 0;
-
-};
-
-
-
-
-#endif /* FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
+#define FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
+
+#include "Event.h"
+
+
+class EventReportingProxyIF {
+public:
+	virtual ~EventReportingProxyIF() {
+	}
+
+	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const = 0;
+
+};
+
+
+
+
+#endif /* FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_ */
diff --git a/events/eventmatching/EventIdRangeMatcher.cpp b/events/eventmatching/EventIdRangeMatcher.cpp
index 40220e4b4..974567d4f 100644
--- a/events/eventmatching/EventIdRangeMatcher.cpp
+++ b/events/eventmatching/EventIdRangeMatcher.cpp
@@ -1,12 +1,12 @@
-#include "../../events/eventmatching/EventIdRangeMatcher.h"
-
-EventIdRangeMatcher::EventIdRangeMatcher(EventId_t lower, EventId_t upper,
-		bool inverted) : EventRangeMatcherBase<EventId_t>(lower, upper, inverted) {
-}
-
-EventIdRangeMatcher::~EventIdRangeMatcher() {
-}
-
-bool EventIdRangeMatcher::match(EventMessage* message) {
-	return rangeMatcher.match(message->getEventId());
-}
+#include "EventIdRangeMatcher.h"
+
+EventIdRangeMatcher::EventIdRangeMatcher(EventId_t lower, EventId_t upper,
+		bool inverted) : EventRangeMatcherBase<EventId_t>(lower, upper, inverted) {
+}
+
+EventIdRangeMatcher::~EventIdRangeMatcher() {
+}
+
+bool EventIdRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getEventId());
+}
diff --git a/events/eventmatching/EventIdRangeMatcher.h b/events/eventmatching/EventIdRangeMatcher.h
index ffc2ce80b..540d372f8 100644
--- a/events/eventmatching/EventIdRangeMatcher.h
+++ b/events/eventmatching/EventIdRangeMatcher.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
-
-#include "../../events/eventmatching/EventRangeMatcherBase.h"
-
-class EventIdRangeMatcher: public EventRangeMatcherBase<EventId_t> {
-public:
-	EventIdRangeMatcher(EventId_t lower, EventId_t upper, bool inverted);
-	~EventIdRangeMatcher();
-	bool match(EventMessage* message);
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
+
+#include "EventRangeMatcherBase.h"
+
+class EventIdRangeMatcher: public EventRangeMatcherBase<EventId_t> {
+public:
+	EventIdRangeMatcher(EventId_t lower, EventId_t upper, bool inverted);
+	~EventIdRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_ */
diff --git a/events/eventmatching/EventMatchTree.cpp b/events/eventmatching/EventMatchTree.cpp
index fef1b83ea..55e4083f4 100644
--- a/events/eventmatching/EventMatchTree.cpp
+++ b/events/eventmatching/EventMatchTree.cpp
@@ -1,149 +1,149 @@
-#include "../../events/eventmatching/EventIdRangeMatcher.h"
-#include "../../events/eventmatching/EventMatchTree.h"
-#include "../../events/eventmatching/ReporterRangeMatcher.h"
-#include "../../events/eventmatching/SeverityRangeMatcher.h"
-
-EventMatchTree::EventMatchTree(StorageManagerIF* storageBackend,
-		bool invertedMatch) :
-		MatchTree<EventMessage*>(end(), 1), factory(storageBackend), invertedMatch(
-				invertedMatch) {
-}
-
-EventMatchTree::~EventMatchTree() {
-}
-
-bool EventMatchTree::match(EventMessage* number) {
-	if (invertedMatch) {
-		return !MatchTree<EventMessage*>::match(number);
-	} else {
-		return MatchTree<EventMessage*>::match(number);
-	}
-}
-
-ReturnValue_t EventMatchTree::addMatch(EventId_t idFrom, EventId_t idTo,
-		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	if (idFrom == 0) {
-		//Assuming all events shall be forwarded.
-		idTo = 0;
-		idInverted = true;
-	}
-	if (idTo == 0) {
-		idTo = idFrom;
-	}
-	iterator lastTest;
-	ReturnValue_t result = findOrInsertRangeMatcher<EventId_t,
-			EventIdRangeMatcher>(begin(), idFrom, idTo, idInverted, &lastTest);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (reporterFrom == 0) {
-		//No need to add another AND branch
-		return RETURN_OK;
-	}
-	if (reporterTo == 0) {
-		reporterTo = reporterFrom;
-	}
-	return findOrInsertRangeMatcher<object_id_t, ReporterRangeMatcher>(
-			lastTest.left(), reporterFrom, reporterTo, reporterInverted,
-			&lastTest);
-}
-
-ReturnValue_t EventMatchTree::removeMatch(EventId_t idFrom, EventId_t idTo,
-		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-
-	iterator foundElement;
-
-	if (idFrom == 0) {
-		//Assuming a "forward all events" request.
-		idTo = 0;
-		idInverted = true;
-	}
-	if (idTo == 0) {
-		idTo = idFrom;
-	}
-	foundElement = findRangeMatcher<EventId_t, EventIdRangeMatcher>(begin(),
-			idFrom, idTo, idInverted);
-	if (foundElement == end()) {
-		return NO_MATCH; //Can't tell if too detailed or just not found.
-	}
-	if (reporterFrom == 0) {
-		if (foundElement.left() == end()) {
-			return removeElementAndReconnectChildren(foundElement);
-		} else {
-			return TOO_GENERAL_REQUEST;
-		}
-	}
-	if (reporterTo == 0) {
-		reporterTo = reporterFrom;
-	}
-	foundElement = findRangeMatcher<object_id_t, ReporterRangeMatcher>(
-			foundElement.left(), reporterFrom, reporterTo, reporterInverted);
-	if (foundElement == end()) {
-		return NO_MATCH;
-	} else {
-		return removeElementAndReconnectChildren(foundElement);
-	}
-}
-
-template<typename VALUE_T, typename INSERTION_T>
-inline ReturnValue_t EventMatchTree::findOrInsertRangeMatcher(iterator start,
-		VALUE_T idFrom, VALUE_T idTo, bool inverted, iterator* lastTest) {
-	bool attachToBranch = AND;
-	iterator iter = start;
-	while (iter != end()) {
-		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
-		attachToBranch = OR;
-		*lastTest = iter;
-		if ((matcher->rangeMatcher.lowerBound == idFrom)
-				&& (matcher->rangeMatcher.upperBound == idTo)
-				&& (matcher->rangeMatcher.inverted == inverted)) {
-			return RETURN_OK;
-		} else {
-			iter = iter.right();
-		}
-	}
-	//Only reached if nothing was found.
-	SerializeableMatcherIF<EventMessage*>* newContent = factory.generate<
-			INSERTION_T>(idFrom, idTo, inverted);
-	if (newContent == NULL) {
-		return FULL;
-	}
-	Node* newNode = factory.generate<Node>(newContent);
-	if (newNode == NULL) {
-		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
-		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
-		return FULL;
-	}
-	*lastTest = insert(attachToBranch, *lastTest, newNode);
-	if (*lastTest == end()) {
-		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-template<typename VALUE_T, typename INSERTION_T>
-EventMatchTree::iterator EventMatchTree::findRangeMatcher(iterator start,
-		VALUE_T idFrom, VALUE_T idTo, bool inverted) {
-	iterator iter = start;
-	while (iter != end()) {
-		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
-		if ((matcher->rangeMatcher.lowerBound == idFrom)
-				&& (matcher->rangeMatcher.upperBound == idTo)
-				&& (matcher->rangeMatcher.inverted == inverted)) {
-			break;
-		} else {
-			iter = iter.right(); //next OR element
-		}
-	}
-	return iter;
-}
-
-ReturnValue_t EventMatchTree::cleanUpElement(iterator position) {
-	factory.destroy(position.element->value);
-	//If deletion fails, delete element anyway, nothing we can do.
-	//SHOULDO: Throw event, or write debug output.
-	return factory.destroy(position.element);
-}
+#include "EventIdRangeMatcher.h"
+#include "EventMatchTree.h"
+#include "ReporterRangeMatcher.h"
+#include "SeverityRangeMatcher.h"
+
+EventMatchTree::EventMatchTree(StorageManagerIF* storageBackend,
+		bool invertedMatch) :
+		MatchTree<EventMessage*>(end(), 1), factory(storageBackend), invertedMatch(
+				invertedMatch) {
+}
+
+EventMatchTree::~EventMatchTree() {
+}
+
+bool EventMatchTree::match(EventMessage* number) {
+	if (invertedMatch) {
+		return !MatchTree<EventMessage*>::match(number);
+	} else {
+		return MatchTree<EventMessage*>::match(number);
+	}
+}
+
+ReturnValue_t EventMatchTree::addMatch(EventId_t idFrom, EventId_t idTo,
+		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+	if (idFrom == 0) {
+		//Assuming all events shall be forwarded.
+		idTo = 0;
+		idInverted = true;
+	}
+	if (idTo == 0) {
+		idTo = idFrom;
+	}
+	iterator lastTest;
+	ReturnValue_t result = findOrInsertRangeMatcher<EventId_t,
+			EventIdRangeMatcher>(begin(), idFrom, idTo, idInverted, &lastTest);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (reporterFrom == 0) {
+		//No need to add another AND branch
+		return RETURN_OK;
+	}
+	if (reporterTo == 0) {
+		reporterTo = reporterFrom;
+	}
+	return findOrInsertRangeMatcher<object_id_t, ReporterRangeMatcher>(
+			lastTest.left(), reporterFrom, reporterTo, reporterInverted,
+			&lastTest);
+}
+
+ReturnValue_t EventMatchTree::removeMatch(EventId_t idFrom, EventId_t idTo,
+		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+
+	iterator foundElement;
+
+	if (idFrom == 0) {
+		//Assuming a "forward all events" request.
+		idTo = 0;
+		idInverted = true;
+	}
+	if (idTo == 0) {
+		idTo = idFrom;
+	}
+	foundElement = findRangeMatcher<EventId_t, EventIdRangeMatcher>(begin(),
+			idFrom, idTo, idInverted);
+	if (foundElement == end()) {
+		return NO_MATCH; //Can't tell if too detailed or just not found.
+	}
+	if (reporterFrom == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	if (reporterTo == 0) {
+		reporterTo = reporterFrom;
+	}
+	foundElement = findRangeMatcher<object_id_t, ReporterRangeMatcher>(
+			foundElement.left(), reporterFrom, reporterTo, reporterInverted);
+	if (foundElement == end()) {
+		return NO_MATCH;
+	} else {
+		return removeElementAndReconnectChildren(foundElement);
+	}
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+inline ReturnValue_t EventMatchTree::findOrInsertRangeMatcher(iterator start,
+		VALUE_T idFrom, VALUE_T idTo, bool inverted, iterator* lastTest) {
+	bool attachToBranch = AND;
+	iterator iter = start;
+	while (iter != end()) {
+		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
+		attachToBranch = OR;
+		*lastTest = iter;
+		if ((matcher->rangeMatcher.lowerBound == idFrom)
+				&& (matcher->rangeMatcher.upperBound == idTo)
+				&& (matcher->rangeMatcher.inverted == inverted)) {
+			return RETURN_OK;
+		} else {
+			iter = iter.right();
+		}
+	}
+	//Only reached if nothing was found.
+	SerializeableMatcherIF<EventMessage*>* newContent = factory.generate<
+			INSERTION_T>(idFrom, idTo, inverted);
+	if (newContent == NULL) {
+		return FULL;
+	}
+	Node* newNode = factory.generate<Node>(newContent);
+	if (newNode == NULL) {
+		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
+		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
+		return FULL;
+	}
+	*lastTest = insert(attachToBranch, *lastTest, newNode);
+	if (*lastTest == end()) {
+		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+EventMatchTree::iterator EventMatchTree::findRangeMatcher(iterator start,
+		VALUE_T idFrom, VALUE_T idTo, bool inverted) {
+	iterator iter = start;
+	while (iter != end()) {
+		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
+		if ((matcher->rangeMatcher.lowerBound == idFrom)
+				&& (matcher->rangeMatcher.upperBound == idTo)
+				&& (matcher->rangeMatcher.inverted == inverted)) {
+			break;
+		} else {
+			iter = iter.right(); //next OR element
+		}
+	}
+	return iter;
+}
+
+ReturnValue_t EventMatchTree::cleanUpElement(iterator position) {
+	factory.destroy(position.element->value);
+	//If deletion fails, delete element anyway, nothing we can do.
+	//SHOULDO: Throw event, or write debug output.
+	return factory.destroy(position.element);
+}
diff --git a/events/eventmatching/EventMatchTree.h b/events/eventmatching/EventMatchTree.h
index ba02217ac..82a6de817 100644
--- a/events/eventmatching/EventMatchTree.h
+++ b/events/eventmatching/EventMatchTree.h
@@ -1,36 +1,36 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
-
-#include "../../container/PlacementFactory.h"
-#include "../../events/EventMessage.h"
-#include "../../globalfunctions/matching/MatchTree.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-class StorageManagerIF;
-
-class EventMatchTree: public MatchTree<EventMessage*>, public HasReturnvaluesIF {
-public:
-	EventMatchTree(StorageManagerIF* storageBackend, bool invertedMatch);
-	virtual ~EventMatchTree();
-	ReturnValue_t addMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	ReturnValue_t removeMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	bool match(EventMessage* number);
-protected:
-	ReturnValue_t cleanUpElement(iterator position);
-private:
-	PlacementFactory factory;
-	bool invertedMatch;
-	template<typename VALUE_T, typename INSERTION_T>
-	ReturnValue_t findOrInsertRangeMatcher(iterator start, VALUE_T idFrom,
-			VALUE_T idTo, bool inverted, iterator* lastTest);
-
-	template<typename VALUE_T, typename INSERTION_T>
-	iterator findRangeMatcher(iterator start, VALUE_T idFrom, VALUE_T idTo,
-			bool inverted);
-
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
+
+#include "../../container/PlacementFactory.h"
+#include "../../events/EventMessage.h"
+#include "../../globalfunctions/matching/MatchTree.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+class StorageManagerIF;
+
+class EventMatchTree: public MatchTree<EventMessage*>, public HasReturnvaluesIF {
+public:
+	EventMatchTree(StorageManagerIF* storageBackend, bool invertedMatch);
+	virtual ~EventMatchTree();
+	ReturnValue_t addMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t removeMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	bool match(EventMessage* number);
+protected:
+	ReturnValue_t cleanUpElement(iterator position);
+private:
+	PlacementFactory factory;
+	bool invertedMatch;
+	template<typename VALUE_T, typename INSERTION_T>
+	ReturnValue_t findOrInsertRangeMatcher(iterator start, VALUE_T idFrom,
+			VALUE_T idTo, bool inverted, iterator* lastTest);
+
+	template<typename VALUE_T, typename INSERTION_T>
+	iterator findRangeMatcher(iterator start, VALUE_T idFrom, VALUE_T idTo,
+			bool inverted);
+
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_ */
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index ab42800a9..e9d57f1c2 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -1,29 +1,29 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
-
-#include "../../events/EventMessage.h"
-#include "../../globalfunctions/matching/RangeMatcher.h"
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-
-template <typename T>
-class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
-	friend class EventMatchTree;
-public:
-	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
-	virtual ~EventRangeMatcherBase() { }
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return rangeMatcher.getSerializedSize();
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
-	}
-protected:
-	RangeMatcher<T> rangeMatcher;
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
+
+#include "../../events/EventMessage.h"
+#include "../../globalfunctions/matching/RangeMatcher.h"
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+
+template <typename T>
+class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
+	friend class EventMatchTree;
+public:
+	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
+	virtual ~EventRangeMatcherBase() { }
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return rangeMatcher.getSerializedSize();
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
+	}
+protected:
+	RangeMatcher<T> rangeMatcher;
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_ */
diff --git a/events/eventmatching/ReporterRangeMatcher.cpp b/events/eventmatching/ReporterRangeMatcher.cpp
index 6751b5e0c..611797260 100644
--- a/events/eventmatching/ReporterRangeMatcher.cpp
+++ b/events/eventmatching/ReporterRangeMatcher.cpp
@@ -1,13 +1,13 @@
-#include "../../events/eventmatching/ReporterRangeMatcher.h"
-
-ReporterRangeMatcher::ReporterRangeMatcher(object_id_t lower, object_id_t upper,
-		bool inverted) : EventRangeMatcherBase<object_id_t>(lower, upper, inverted) {
-}
-
-ReporterRangeMatcher::~ReporterRangeMatcher() {
-	
-}
-
-bool ReporterRangeMatcher::match(EventMessage* message) {
-	return rangeMatcher.match(message->getReporter());
-}
+#include "ReporterRangeMatcher.h"
+
+ReporterRangeMatcher::ReporterRangeMatcher(object_id_t lower, object_id_t upper,
+		bool inverted) : EventRangeMatcherBase<object_id_t>(lower, upper, inverted) {
+}
+
+ReporterRangeMatcher::~ReporterRangeMatcher() {
+	
+}
+
+bool ReporterRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getReporter());
+}
diff --git a/events/eventmatching/ReporterRangeMatcher.h b/events/eventmatching/ReporterRangeMatcher.h
index ee23d0768..9a0a5fcf3 100644
--- a/events/eventmatching/ReporterRangeMatcher.h
+++ b/events/eventmatching/ReporterRangeMatcher.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
-
-#include "../../events/eventmatching/EventRangeMatcherBase.h"
-
-class ReporterRangeMatcher: public EventRangeMatcherBase<object_id_t> {
-public:
-	ReporterRangeMatcher(object_id_t lower, object_id_t upper, bool inverted);
-	~ReporterRangeMatcher();
-	bool match(EventMessage* message);
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
+
+#include "EventRangeMatcherBase.h"
+
+class ReporterRangeMatcher: public EventRangeMatcherBase<object_id_t> {
+public:
+	ReporterRangeMatcher(object_id_t lower, object_id_t upper, bool inverted);
+	~ReporterRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_ */
diff --git a/events/eventmatching/SeverityRangeMatcher.cpp b/events/eventmatching/SeverityRangeMatcher.cpp
index 41eb90207..6fd382714 100644
--- a/events/eventmatching/SeverityRangeMatcher.cpp
+++ b/events/eventmatching/SeverityRangeMatcher.cpp
@@ -1,14 +1,14 @@
-#include "../../events/eventmatching/SeverityRangeMatcher.h"
-#include "../../events/EventMessage.h"
-#include "../../serialize/SerializeAdapter.h"
-
-SeverityRangeMatcher::SeverityRangeMatcher(EventSeverity_t from,
-		EventSeverity_t till, bool inverted) : EventRangeMatcherBase<EventSeverity_t>(from, till, inverted) {
-}
-
-SeverityRangeMatcher::~SeverityRangeMatcher() {
-}
-
-bool SeverityRangeMatcher::match(EventMessage* message) {
-	return rangeMatcher.match(message->getSeverity());
-}
+#include "SeverityRangeMatcher.h"
+#include "../../events/EventMessage.h"
+#include "../../serialize/SerializeAdapter.h"
+
+SeverityRangeMatcher::SeverityRangeMatcher(EventSeverity_t from,
+		EventSeverity_t till, bool inverted) : EventRangeMatcherBase<EventSeverity_t>(from, till, inverted) {
+}
+
+SeverityRangeMatcher::~SeverityRangeMatcher() {
+}
+
+bool SeverityRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getSeverity());
+}
diff --git a/events/eventmatching/SeverityRangeMatcher.h b/events/eventmatching/SeverityRangeMatcher.h
index b3c3fbc81..3f7cc418b 100644
--- a/events/eventmatching/SeverityRangeMatcher.h
+++ b/events/eventmatching/SeverityRangeMatcher.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
-
-#include "../../events/eventmatching/EventRangeMatcherBase.h"
-
-class SeverityRangeMatcher: public EventRangeMatcherBase<EventSeverity_t> {
-public:
-	SeverityRangeMatcher(EventSeverity_t from, EventSeverity_t till, bool inverted);
-	~SeverityRangeMatcher();
-	bool match(EventMessage* message);
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
+
+#include "EventRangeMatcherBase.h"
+
+class SeverityRangeMatcher: public EventRangeMatcherBase<EventSeverity_t> {
+public:
+	SeverityRangeMatcher(EventSeverity_t from, EventSeverity_t till, bool inverted);
+	~SeverityRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_ */
diff --git a/events/eventmatching/eventmatching.h b/events/eventmatching/eventmatching.h
index 85b852a5b..7a87e177b 100644
--- a/events/eventmatching/eventmatching.h
+++ b/events/eventmatching/eventmatching.h
@@ -1,10 +1,10 @@
-#ifndef EVENTMATCHING_H_
-#define EVENTMATCHING_H_
-
-#include "../../events/eventmatching/EventIdRangeMatcher.h"
-#include "../../events/eventmatching/EventMatchTree.h"
-#include "../../events/eventmatching/ReporterRangeMatcher.h"
-#include "../../events/eventmatching/SeverityRangeMatcher.h"
-
-
-#endif /* EVENTMATCHING_H_ */
+#ifndef EVENTMATCHING_H_
+#define EVENTMATCHING_H_
+
+#include "EventIdRangeMatcher.h"
+#include "EventMatchTree.h"
+#include "ReporterRangeMatcher.h"
+#include "SeverityRangeMatcher.h"
+
+
+#endif /* EVENTMATCHING_H_ */

From 9f522466f0529e4fc56abc0ebf2d952e82d39e89 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:52:13 +0200
Subject: [PATCH 0679/1774] wrapped info output in additonal ifdef

---
 events/EventManager.cpp | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 5848dd744..d459fa4c8 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -111,25 +111,27 @@ 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);
+// forward declaration, should be implemented by mission
+extern const char* translateObject(object_id_t object);
+extern 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;
+#ifdef DEBUG_INFO_EVENT
+		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;
+#endif
 		break;
 	default:
 		string = translateObject(message->getReporter());
@@ -152,7 +154,6 @@ void EventManager::printEvent(EventMessage* message) {
 				<< std::endl;
 		break;
 	}
-
 }
 #endif
 

From b71cab399330f3ae631bb51fd2cfdbb43dd32cf7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:55:13 +0200
Subject: [PATCH 0680/1774] integrated all changes

---
 events/EventManager.cpp | 59 +++++++++++++++++++++++------------------
 events/EventManager.h   | 10 +++++--
 2 files changed, 41 insertions(+), 28 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index e58f251ac..e71951e36 100644
--- a/events/EventManager.cpp
+++ b/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
 
diff --git a/events/EventManager.h b/events/EventManager.h
index 7badc3bf6..2602aeb23 100644
--- a/events/EventManager.h
+++ b/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;

From 9abd796e6fd1ad0d8fa91e78bf7b68e8d61ca61b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:58:36 +0200
Subject: [PATCH 0681/1774] updated map packet extraction

---
 datalinklayer/MapPacketExtraction.cpp | 17 +++++------------
 datalinklayer/MapPacketExtraction.h   |  8 +-------
 2 files changed, 6 insertions(+), 19 deletions(-)

diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index cb12b3210..45f7d3f8b 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -1,10 +1,3 @@
-/**
- * @file	MapPacketExtraction.cpp
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
 #include "MapPacketExtraction.h"
 #include "../ipc/QueueFactory.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
@@ -12,14 +5,14 @@
 #include "../tmtcpacket/SpacePacketBase.h"
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../tmtcservices/TmTcMessage.h"
-#include <string.h>
+#include <cstring>
 
 MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
 		object_id_t setPacketDestination) :
-		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0), bufferPosition(
-				packetBuffer), packetDestination(setPacketDestination), packetStore(
-				NULL), tcQueueId(MessageQueueSenderIF::NO_QUEUE) {
-	memset(packetBuffer, 0, sizeof(packetBuffer));
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
+		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
+		packetStore(NULL), tcQueueId(MessageQueueIF::NO_QUEUE) {
+	std::memset(packetBuffer, 0, sizeof(packetBuffer));
 }
 
 ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
diff --git a/datalinklayer/MapPacketExtraction.h b/datalinklayer/MapPacketExtraction.h
index 507f13dbe..eff9b7c3c 100644
--- a/datalinklayer/MapPacketExtraction.h
+++ b/datalinklayer/MapPacketExtraction.h
@@ -1,10 +1,3 @@
-/**
- * @file	MapPacketExtraction.h
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
 #ifndef MAPPACKETEXTRACTION_H_
 #define MAPPACKETEXTRACTION_H_
 
@@ -20,6 +13,7 @@ class StorageManagerIF;
  * The class implements the full MAP Packet Extraction functionality as described in the CCSDS
  * TC Space Data Link Protocol. It internally stores incomplete segmented packets until they are
  * fully received. All found packets are forwarded to a single distribution entity.
+ * @author B. Baetz
  */
 class MapPacketExtraction: public MapPacketExtractionIF {
 private:

From 1b9c8446b7bb7fa005eaf7ce390c12800a3a2177 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 18:33:29 +0200
Subject: [PATCH 0682/1774] renormalized line endings

---
 container/ArrayList.h                         |  494 +-
 container/DynamicFIFO.h                       |   84 +-
 container/FIFO.h                              |   68 +-
 container/FIFOBase.h                          |  130 +-
 container/FixedArrayList.h                    |  114 +-
 container/FixedMap.h                          |  450 +-
 container/HybridIterator.h                    |  180 +-
 container/IndexedRingMemoryArray.h            | 1442 +++---
 container/PlacementFactory.h                  |   70 +-
 container/RingBufferBase.h                    |  226 +-
 container/SharedRingBuffer.cpp                |   60 +-
 container/SharedRingBuffer.h                  |  136 +-
 container/SimpleRingBuffer.cpp                |  270 +-
 container/SimpleRingBuffer.h                  |  256 +-
 contrib/sgp4/sgp4unit.cpp                     | 4180 ++++++++---------
 contrib/sgp4/sgp4unit.h                       |  234 +-
 controller/ControllerBase.cpp                 |  280 +-
 controller/ControllerBase.h                   |  188 +-
 datapool/ControllerSet.cpp                    |   28 +-
 datapool/ControllerSet.h                      |   30 +-
 datapool/HkSwitchHelper.cpp                   |  150 +-
 datapool/HkSwitchHelper.h                     |   92 +-
 datapool/PoolEntry.cpp                        |  174 +-
 datapool/PoolEntry.h                          |  260 +-
 datapool/PoolEntryIF.h                        |  126 +-
 datapool/PoolRawAccessHelper.cpp              |  376 +-
 datapool/PoolRawAccessHelper.h                |  222 +-
 datapool/PoolVarList.h                        |   56 +-
 datapoolglob/DataPoolAdmin.cpp                |  600 +--
 datapoolglob/DataPoolAdmin.h                  |  118 +-
 datapoolglob/DataPoolParameterWrapper.cpp     |  358 +-
 datapoolglob/DataPoolParameterWrapper.h       |   76 +-
 datapoolglob/GlobalDataPool.cpp               |  266 +-
 datapoolglob/GlobalDataPool.h                 |  298 +-
 datapoolglob/GlobalPoolVariable.h             |  426 +-
 datapoolglob/GlobalPoolVector.h               |  370 +-
 datapoolglob/PIDReader.h                      |  328 +-
 datapoolglob/PIDReaderList.h                  |   54 +-
 datapoolglob/PoolRawAccess.cpp                |  478 +-
 datapoolglob/PoolRawAccess.h                  |  440 +-
 datapoollocal/LocalPoolVector.h               |  400 +-
 datapoollocal/SharedLocalDataSet.cpp          |   32 +-
 devicehandlers/AcceptsDeviceResponsesIF.h     |   38 +-
 devicehandlers/AssemblyBase.cpp               |  546 +--
 devicehandlers/AssemblyBase.h                 |  326 +-
 devicehandlers/ChildHandlerBase.cpp           |   94 +-
 devicehandlers/ChildHandlerBase.h             |   48 +-
 devicehandlers/ChildHandlerFDIR.cpp           |   20 +-
 devicehandlers/ChildHandlerFDIR.h             |   40 +-
 devicehandlers/CommunicationMessage.cpp       |  402 +-
 devicehandlers/CommunicationMessage.h         |  346 +-
 devicehandlers/DeviceCommunicationIF.h        |  254 +-
 devicehandlers/DeviceHandlerIF.h              |  310 +-
 devicehandlers/DeviceHandlerMessage.cpp       |  202 +-
 devicehandlers/DeviceHandlerMessage.h         |  182 +-
 devicehandlers/DeviceTmReportingWrapper.cpp   |   92 +-
 devicehandlers/DeviceTmReportingWrapper.h     |   54 +-
 devicehandlers/HealthDevice.cpp               |  118 +-
 devicehandlers/HealthDevice.h                 |   80 +-
 fdir/ConfirmsFailuresIF.h                     |   40 +-
 fdir/EventCorrelation.cpp                     |   88 +-
 fdir/EventCorrelation.h                       |   46 +-
 fdir/FailureIsolationBase.cpp                 |  328 +-
 fdir/FailureIsolationBase.h                   |  112 +-
 fdir/FaultCounter.cpp                         |  172 +-
 fdir/FaultCounter.h                           |   76 +-
 globalfunctions/AsciiConverter.cpp            |  460 +-
 globalfunctions/AsciiConverter.h              |   78 +-
 globalfunctions/CRC.cpp                       |  278 +-
 globalfunctions/DleEncoder.cpp                |  248 +-
 globalfunctions/DleEncoder.h                  |  158 +-
 globalfunctions/Type.cpp                      |  362 +-
 globalfunctions/Type.h                        |  188 +-
 globalfunctions/arrayprinter.cpp              |  122 +-
 globalfunctions/matching/BinaryMatcher.h      |   82 +-
 globalfunctions/matching/DecimalMatcher.h     |  100 +-
 globalfunctions/matching/MatchTree.h          |  432 +-
 globalfunctions/matching/RangeMatcher.h       |  140 +-
 .../matching/SerializeableMatcherIF.h         |   26 +-
 globalfunctions/math/QuaternionOperations.cpp |  312 +-
 globalfunctions/timevalOperations.cpp         |  198 +-
 health/HasHealthIF.h                          |  100 +-
 health/HealthHelper.cpp                       |  210 +-
 health/HealthHelper.h                         |  242 +-
 health/HealthMessage.cpp                      |   56 +-
 health/HealthMessage.h                        |   60 +-
 health/HealthTable.cpp                        |  200 +-
 health/HealthTable.h                          |   70 +-
 health/HealthTableIF.h                        |   56 +-
 health/ManagesHealthIF.h                      |  104 +-
 housekeeping/AcceptsHkPacketsIF.h             |   22 +-
 internalError/InternalErrorReporter.cpp       |  250 +-
 internalError/InternalErrorReporter.h         |  100 +-
 ipc/CommandMessage.cpp                        |  222 +-
 ipc/CommandMessage.h                          |  258 +-
 ipc/CommandMessageCleaner.cpp                 |   90 +-
 ipc/CommandMessageCleaner.h                   |   32 +-
 ipc/CommandMessageIF.h                        |  146 +-
 ipc/MessageQueueIF.h                          |  342 +-
 ipc/MessageQueueMessage.cpp                   |  168 +-
 ipc/MessageQueueMessage.h                     |  300 +-
 ipc/MessageQueueSenderIF.h                    |   50 +-
 ipc/MutexFactory.h                            |   68 +-
 ipc/MutexHelper.h                             |   60 +-
 ipc/MutexIF.h                                 |  178 +-
 ipc/QueueFactory.h                            |   66 +-
 memory/AcceptsMemoryMessagesIF.h              |   42 +-
 memory/FileSystemMessage.cpp                  |   56 +-
 memory/FileSystemMessage.h                    |   60 +-
 memory/HasFileSystemIF.h                      |   72 +-
 memory/HasMemoryIF.h                          |   94 +-
 memory/MemoryHelper.cpp                       |  386 +-
 memory/MemoryHelper.h                         |   74 +-
 memory/MemoryMessage.cpp                      |  224 +-
 memory/MemoryMessage.h                        |   78 +-
 memory/MemoryProxyIF.h                        |   44 +-
 modes/HasModesIF.h                            |  114 +-
 modes/ModeHelper.cpp                          |  270 +-
 modes/ModeHelper.h                            |  106 +-
 modes/ModeMessage.cpp                         |   62 +-
 modes/ModeMessage.h                           |   80 +-
 monitoring/AbsLimitMonitor.h                  |  146 +-
 monitoring/HasMonitorsIF.h                    |   60 +-
 monitoring/LimitMonitor.h                     |  190 +-
 monitoring/LimitViolationReporter.cpp         |  120 +-
 monitoring/LimitViolationReporter.h           |   62 +-
 monitoring/MonitorBase.h                      |  124 +-
 monitoring/MonitorReporter.h                  |  356 +-
 monitoring/MonitoringIF.h                     |  134 +-
 monitoring/MonitoringMessage.cpp              |   76 +-
 monitoring/MonitoringMessage.h                |   42 +-
 monitoring/MonitoringMessageContent.h         |  154 +-
 monitoring/ReceivesMonitoringReportsIF.h      |   30 +-
 monitoring/TriplexMonitor.h                   |  310 +-
 monitoring/TwoValueLimitMonitor.h             |   88 +-
 objectmanager/ObjectManager.cpp               |  214 +-
 objectmanager/ObjectManager.h                 |  134 +-
 objectmanager/ObjectManagerIF.h               |  190 +-
 objectmanager/SystemObject.cpp                |   74 +-
 objectmanager/SystemObjectIF.h                |  124 +-
 osal/FreeRTOS/BinSemaphUsingTask.cpp          |  190 +-
 osal/FreeRTOS/BinSemaphUsingTask.h            |  158 +-
 osal/FreeRTOS/BinarySemaphore.cpp             |  216 +-
 osal/FreeRTOS/BinarySemaphore.h               |  214 +-
 osal/FreeRTOS/Clock.cpp                       |  392 +-
 osal/FreeRTOS/CountingSemaphUsingTask.cpp     |  228 +-
 osal/FreeRTOS/CountingSemaphUsingTask.h       |  210 +-
 osal/FreeRTOS/CountingSemaphore.cpp           |   86 +-
 osal/FreeRTOS/CountingSemaphore.h             |   68 +-
 osal/FreeRTOS/FixedTimeslotTask.cpp           |  332 +-
 osal/FreeRTOS/FixedTimeslotTask.h             |  202 +-
 osal/FreeRTOS/MessageQueue.h                  |  298 +-
 osal/FreeRTOS/Mutex.cpp                       |  102 +-
 osal/FreeRTOS/Mutex.h                         |   58 +-
 osal/FreeRTOS/MutexFactory.cpp                |   56 +-
 osal/FreeRTOS/QueueFactory.cpp                |   72 +-
 osal/FreeRTOS/SemaphoreFactory.cpp            |  118 +-
 osal/FreeRTOS/TaskFactory.cpp                 |  106 +-
 osal/FreeRTOS/TaskManagement.cpp              |   48 +-
 osal/FreeRTOS/TaskManagement.h                |  128 +-
 osal/FreeRTOS/Timekeeper.cpp                  |   82 +-
 osal/FreeRTOS/Timekeeper.h                    |   80 +-
 osal/InternalErrorCodes.h                     |   78 +-
 osal/host/Clock.cpp                           |  454 +-
 osal/host/FixedTimeslotTask.cpp               |  382 +-
 osal/host/FixedTimeslotTask.h                 |  260 +-
 osal/host/MessageQueue.cpp                    |  310 +-
 osal/host/MessageQueue.h                      |  460 +-
 osal/host/Mutex.cpp                           |   80 +-
 osal/host/Mutex.h                             |   56 +-
 osal/host/MutexFactory.cpp                    |   56 +-
 osal/host/PeriodicTask.cpp                    |  352 +-
 osal/host/PeriodicTask.h                      |  246 +-
 osal/host/QueueFactory.cpp                    |   82 +-
 osal/host/QueueMapManager.cpp                 |  102 +-
 osal/host/QueueMapManager.h                   |   94 +-
 osal/host/SemaphoreFactory.cpp                |   84 +-
 osal/host/TaskFactory.cpp                     |  110 +-
 osal/linux/BinarySemaphore.cpp                |  298 +-
 osal/linux/BinarySemaphore.h                  |  162 +-
 osal/linux/Clock.cpp                          |  440 +-
 osal/linux/CountingSemaphore.cpp              |  108 +-
 osal/linux/CountingSemaphore.h                |   74 +-
 osal/linux/FixedTimeslotTask.cpp              |  192 +-
 osal/linux/FixedTimeslotTask.h                |  154 +-
 osal/linux/InternalErrorCodes.cpp             |   28 +-
 osal/linux/MessageQueue.cpp                   |  738 +--
 osal/linux/MessageQueue.h                     |  374 +-
 osal/linux/Mutex.cpp                          |  222 +-
 osal/linux/Mutex.h                            |   44 +-
 osal/linux/MutexFactory.cpp                   |   46 +-
 osal/linux/PeriodicPosixTask.cpp              |  166 +-
 osal/linux/PeriodicPosixTask.h                |  180 +-
 osal/linux/PosixThread.cpp                    |  434 +-
 osal/linux/PosixThread.h                      |  154 +-
 osal/linux/QueueFactory.cpp                   |   76 +-
 osal/linux/SemaphoreFactory.cpp               |   66 +-
 osal/linux/TaskFactory.cpp                    |   84 +-
 osal/linux/TcUnixUdpPollingTask.cpp           |  274 +-
 osal/linux/TcUnixUdpPollingTask.h             |  134 +-
 osal/linux/Timer.cpp                          |   84 +-
 osal/linux/TmTcUnixUdpBridge.cpp              |  336 +-
 osal/linux/TmTcUnixUdpBridge.h                |   96 +-
 osal/rtems/Clock.cpp                          |  396 +-
 osal/rtems/CpuUsage.cpp                       |  366 +-
 osal/rtems/CpuUsage.h                         |  106 +-
 osal/rtems/InternalErrorCodes.cpp             |  120 +-
 osal/rtems/Interrupt.h                        |  100 +-
 osal/rtems/MessageQueue.cpp                   |  294 +-
 osal/rtems/MessageQueue.h                     |  362 +-
 osal/rtems/MultiObjectTask.cpp                |  174 +-
 osal/rtems/MultiObjectTask.h                  |  226 +-
 osal/rtems/Mutex.cpp                          |  130 +-
 osal/rtems/Mutex.h                            |   36 +-
 osal/rtems/MutexFactory.cpp                   |   48 +-
 osal/rtems/PollingTask.cpp                    |  244 +-
 osal/rtems/PollingTask.h                      |  170 +-
 osal/rtems/QueueFactory.cpp                   |  118 +-
 osal/rtems/RtemsBasic.h                       |   50 +-
 osal/rtems/TaskBase.cpp                       |  164 +-
 osal/rtems/TaskBase.h                         |   94 +-
 osal/rtems/TaskFactory.cpp                    |   82 +-
 parameters/HasParametersIF.h                  |  134 +-
 parameters/ParameterHelper.cpp                |  264 +-
 parameters/ParameterHelper.h                  |   72 +-
 parameters/ParameterMessage.cpp               |   96 +-
 parameters/ParameterMessage.h                 |   58 +-
 parameters/ParameterWrapper.cpp               |  560 +--
 parameters/ParameterWrapper.h                 |  324 +-
 parameters/ReceivesParameterMessagesIF.h      |   38 +-
 power/Fuse.cpp                                |  520 +-
 power/Fuse.h                                  |  212 +-
 power/PowerComponent.cpp                      |  172 +-
 power/PowerComponent.h                        |   96 +-
 power/PowerComponentIF.h                      |   48 +-
 power/PowerSensor.cpp                         |  256 +-
 power/PowerSensor.h                           |  142 +-
 power/PowerSwitchIF.h                         |  160 +-
 power/PowerSwitcher.cpp                       |  254 +-
 power/PowerSwitcher.h                         |   90 +-
 pus/CService200ModeCommanding.cpp             |  238 +-
 pus/CService200ModeCommanding.h               |  170 +-
 pus/CService201HealthCommanding.cpp           |  168 +-
 pus/CService201HealthCommanding.h             |  116 +-
 pus/Service1TelecommandVerification.cpp       |  200 +-
 pus/Service1TelecommandVerification.h         |  188 +-
 pus/Service2DeviceAccess.cpp                  |  330 +-
 pus/Service2DeviceAccess.h                    |  184 +-
 pus/Service5EventReporting.cpp                |  182 +-
 pus/Service5EventReporting.h                  |  172 +-
 pus/Service8FunctionManagement.cpp            |  284 +-
 pus/Service8FunctionManagement.h              |  134 +-
 pus/servicepackets/Service1Packets.h          |  332 +-
 pus/servicepackets/Service200Packets.h        |  126 +-
 pus/servicepackets/Service201Packets.h        |   96 +-
 pus/servicepackets/Service2Packets.h          |  152 +-
 pus/servicepackets/Service5Packets.h          |  152 +-
 pus/servicepackets/Service8Packets.h          |  242 +-
 returnvalues/HasReturnvaluesIF.h              |   62 +-
 rmap/RMAP.cpp                                 |  178 +-
 rmap/RMAP.h                                   |  454 +-
 rmap/RMAPChannelIF.h                          |  232 +-
 rmap/RMAPCookie.cpp                           |  248 +-
 rmap/RMAPCookie.h                             |  118 +-
 rmap/RmapDeviceCommunicationIF.cpp            |   94 +-
 rmap/RmapDeviceCommunicationIF.h              |  178 +-
 serialize/EndianConverter.h                   |  248 +-
 serialize/SerialArrayListAdapter.h            |  182 +-
 serialize/SerialBufferAdapter.cpp             |  258 +-
 serialize/SerialBufferAdapter.h               |  156 +-
 serialize/SerialFixedArrayListAdapter.h       |  126 +-
 serialize/SerialLinkedListAdapter.h           |  266 +-
 serialize/SerializeAdapter.h                  |  350 +-
 serialize/SerializeElement.h                  |  120 +-
 serialize/SerializeIF.h                       |  116 +-
 serviceinterface/ServiceInterfaceBuffer.cpp   |  434 +-
 serviceinterface/ServiceInterfaceBuffer.h     |  290 +-
 serviceinterface/ServiceInterfaceStream.cpp   |   64 +-
 serviceinterface/ServiceInterfaceStream.h     |  116 +-
 storagemanager/ConstStorageAccessor.cpp       |  174 +-
 storagemanager/ConstStorageAccessor.h         |  232 +-
 storagemanager/LocalPool.h                    |  378 +-
 storagemanager/PoolManager.h                  |   98 +-
 storagemanager/StorageAccessor.cpp            |  134 +-
 storagemanager/StorageAccessor.h              |   90 +-
 storagemanager/StorageManagerIF.h             |  334 +-
 subsystem/Subsystem.h                         |  328 +-
 subsystem/SubsystemBase.cpp                   |  712 +--
 subsystem/SubsystemBase.h                     |  258 +-
 subsystem/modes/HasModeSequenceIF.h           |   40 +-
 subsystem/modes/ModeDefinitions.h             |  304 +-
 subsystem/modes/ModeSequenceMessage.cpp       |  178 +-
 subsystem/modes/ModeSequenceMessage.h         |   96 +-
 subsystem/modes/ModeStore.cpp                 |  252 +-
 subsystem/modes/ModeStore.h                   |   90 +-
 subsystem/modes/ModeStoreIF.h                 |   74 +-
 tasks/ExecutableObjectIF.h                    |  106 +-
 tasks/FixedSequenceSlot.cpp                   |   34 +-
 tasks/FixedSequenceSlot.h                     |  114 +-
 tasks/FixedSlotSequence.cpp                   |  294 +-
 tasks/FixedSlotSequence.h                     |  318 +-
 tasks/FixedTimeslotTaskIF.h                   |   66 +-
 tasks/PeriodicTaskIF.h                        |   98 +-
 tasks/SemaphoreFactory.h                      |  100 +-
 tasks/SemaphoreIF.h                           |  136 +-
 tasks/TaskFactory.h                           |  146 +-
 tcdistribution/CCSDSDistributor.cpp           |  164 +-
 tcdistribution/CCSDSDistributor.h             |  138 +-
 tcdistribution/CCSDSDistributorIF.h           |   80 +-
 tcdistribution/PUSDistributor.cpp             |  184 +-
 tcdistribution/PUSDistributor.h               |  154 +-
 tcdistribution/PUSDistributorIF.h             |   52 +-
 tcdistribution/TcDistributor.cpp              |  108 +-
 tcdistribution/TcDistributor.h                |  240 +-
 tcdistribution/TcPacketCheck.cpp              |   74 +-
 tcdistribution/TcPacketCheck.h                |  118 +-
 thermal/AbstractTemperatureSensor.cpp         |  140 +-
 thermal/AbstractTemperatureSensor.h           |  128 +-
 thermal/AcceptsThermalMessagesIF.h            |   44 +-
 thermal/CoreComponent.h                       |  192 +-
 thermal/Heater.cpp                            |  700 +--
 thermal/Heater.h                              |  180 +-
 thermal/RedundantHeater.h                     |  100 +-
 thermal/TemperatureSensor.h                   |  444 +-
 thermal/ThermalComponentIF.h                  |  228 +-
 thermal/ThermalModule.cpp                     |  576 +--
 thermal/ThermalModule.h                       |  190 +-
 thermal/ThermalMonitor.cpp                    |  136 +-
 thermal/ThermalMonitor.h                      |   52 +-
 timemanager/CCSDSTime.cpp                     | 1204 ++---
 timemanager/CCSDSTime.h                       |  466 +-
 timemanager/Clock.h                           |  310 +-
 timemanager/Countdown.cpp                     |   90 +-
 timemanager/Countdown.h                       |   62 +-
 timemanager/ReceivesTimeInfoIF.h              |   64 +-
 timemanager/Stopwatch.cpp                     |  114 +-
 timemanager/Stopwatch.h                       |  142 +-
 timemanager/TimeMessage.cpp                   |   74 +-
 timemanager/TimeMessage.h                     |  112 +-
 timemanager/TimeStamperIF.h                   |   48 +-
 tmstorage/TmStoreBackendIF.h                  |  190 +-
 tmstorage/TmStoreFrontendIF.h                 |  126 +-
 tmstorage/TmStoreMessage.cpp                  |  330 +-
 tmstorage/TmStoreMessage.h                    |  126 +-
 tmstorage/TmStorePackets.h                    |  600 +--
 tmtcpacket/SpacePacket.cpp                    |   54 +-
 tmtcpacket/SpacePacket.h                      |  140 +-
 tmtcpacket/SpacePacketBase.cpp                |  208 +-
 tmtcpacket/SpacePacketBase.h                  |  354 +-
 tmtcpacket/packetmatcher/ApidMatcher.h        |   80 +-
 tmtcpacket/packetmatcher/PacketMatchTree.cpp  |  390 +-
 tmtcpacket/packetmatcher/PacketMatchTree.h    |   72 +-
 tmtcpacket/packetmatcher/ServiceMatcher.h     |   78 +-
 tmtcpacket/packetmatcher/SubserviceMatcher.h  |   80 +-
 tmtcpacket/pus/PacketTimestampInterpreterIF.h |   32 +-
 tmtcpacket/pus/TcPacketBase.cpp               |  186 +-
 tmtcpacket/pus/TcPacketBase.h                 |  408 +-
 tmtcpacket/pus/TcPacketStored.cpp             |  236 +-
 tmtcpacket/pus/TcPacketStored.h               |  220 +-
 tmtcpacket/pus/TmPacketBase.cpp               |  238 +-
 tmtcpacket/pus/TmPacketBase.h                 |  372 +-
 tmtcpacket/pus/TmPacketMinimal.cpp            |   90 +-
 tmtcpacket/pus/TmPacketMinimal.h              |  168 +-
 tmtcpacket/pus/TmPacketStored.cpp             |  292 +-
 tmtcpacket/pus/TmPacketStored.h               |  192 +-
 tmtcservices/AcceptsTelecommandsIF.h          |   86 +-
 tmtcservices/AcceptsTelemetryIF.h             |   52 +-
 tmtcservices/AcceptsVerifyMessageIF.h         |   30 +-
 tmtcservices/CommandingServiceBase.cpp        |  854 ++--
 tmtcservices/CommandingServiceBase.h          |  696 +--
 tmtcservices/PusServiceBase.cpp               |  246 +-
 tmtcservices/PusServiceBase.h                 |  318 +-
 tmtcservices/PusVerificationReport.cpp        |  326 +-
 tmtcservices/PusVerificationReport.h          |  154 +-
 tmtcservices/SourceSequenceCounter.h          |   60 +-
 tmtcservices/TmTcBridge.cpp                   |  474 +-
 tmtcservices/TmTcBridge.h                     |  324 +-
 tmtcservices/TmTcMessage.cpp                  |   58 +-
 tmtcservices/TmTcMessage.h                    |  100 +-
 tmtcservices/VerificationReporter.cpp         |  210 +-
 tmtcservices/VerificationReporter.h           |  100 +-
 381 files changed, 38723 insertions(+), 38723 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 436dc7161..9f5e76dee 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -1,247 +1,247 @@
-#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
-#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serialize/SerializeIF.h"
-
-/**
- * @brief 	A List that stores its values in an array.
- * @details
- * The underlying storage is an array that can be allocated by the class
- * itself or supplied via ctor.
- *
- * @ingroup container
- */
-template<typename T, typename count_t = uint8_t>
-class ArrayList {
-	template<typename U, typename count> friend class SerialArrayListAdapter;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
-
-    /**
-     * Copying is forbiden by declaring copy ctor and copy assignment deleted
-     * It is too ambigous in this case.
-     * (Allocate a new backend? Use the same? What to do in an modifying call?)
-     */
-	ArrayList(const ArrayList& other) = delete;
-	const ArrayList& operator=(const ArrayList& other) = delete;
-
-	/**
-	 * Number of Elements stored in this List
-	 */
-	count_t size;
-
-	/**
-	 * This is the allocating constructor;
-	 *
-	 * It allocates an array of the specified size.
-	 *
-	 * @param maxSize
-	 */
-	ArrayList(count_t maxSize) :
-			size(0), maxSize_(maxSize), allocated(true) {
-		entries = new T[maxSize];
-	}
-
-	/**
-	 * This is the non-allocating constructor
-	 *
-	 * It expects a pointer to an array of a certain size and initializes itself to it.
-	 *
-	 * @param storage the array to use as backend
-	 * @param maxSize size of storage
-	 * @param size size of data already present in storage
-	 */
-	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
-			size(size), entries(storage), maxSize_(maxSize), allocated(false) {
-	}
-
-	/**
-	 * Destructor, if the allocating constructor was used, it deletes the array.
-	 */
-	virtual ~ArrayList() {
-		if (allocated) {
-			delete[] entries;
-		}
-	}
-
-    /**
-     * An Iterator to go trough an ArrayList
-     *
-     * It stores a pointer to an element and increments the
-     * pointer when incremented itself.
-     */
-    class Iterator {
-    public:
-        /**
-         * Empty ctor, points to NULL
-         */
-        Iterator(): value(0) {}
-
-        /**
-         * Initializes the Iterator to point to an element
-         *
-         * @param initialize
-         */
-        Iterator(T *initialize) {
-            value = initialize;
-        }
-
-        /**
-         * The current element the iterator points to
-         */
-        T *value;
-
-        Iterator& operator++() {
-            value++;
-            return *this;
-        }
-
-        Iterator operator++(int) {
-            Iterator tmp(*this);
-            operator++();
-            return tmp;
-        }
-
-        Iterator& operator--() {
-            value--;
-            return *this;
-        }
-
-        Iterator operator--(int) {
-            Iterator tmp(*this);
-            operator--();
-            return tmp;
-        }
-
-        T operator*() {
-            return *value;
-        }
-
-        T *operator->() {
-            return value;
-        }
-
-        const T *operator->() const{
-            return value;
-        }
-
-        //SHOULDDO this should be implemented as non-member
-        bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const{
-            return (value == other.value);
-        }
-
-        //SHOULDDO this should be implemented as non-member
-        bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
-            return !(*this == other);
-        }
-    };
-
-	/**
-	 * Iterator pointing to the first stored elmement
-	 *
-	 * @return Iterator to the first element
-	 */
-	Iterator begin() const {
-		return Iterator(&entries[0]);
-	}
-
-	/**
-	 * returns an Iterator pointing to the element after the last stored entry
-	 *
-	 * @return Iterator to the element after the last entry
-	 */
-	Iterator end() const {
-		return Iterator(&entries[size]);
-	}
-
-	T & operator[](count_t i) const {
-		return entries[i];
-	}
-
-	/**
-	 * The first element
-	 *
-	 * @return pointer to the first stored element
-	 */
-	T *front() {
-		return entries;
-	}
-
-	/**
-	 * The last element
-	 *
-	 * does not return a valid pointer if called on an empty list.
-	 *
-	 * @return pointer to the last stored element
-	 */
-	T *back() {
-		return &entries[size - 1];
-		//Alternative solution
-		//return const_cast<T*>(static_cast<const T*>(*this).back());
-	}
-
-	const T* back() const{
-		return &entries[size-1];
-	}
-
-	/**
-	 * The maximum number of elements this List can contain
-	 *
-	 * @return maximum number of elements
-	 */
-	uint32_t maxSize() const {
-		return this->maxSize_;
-	}
-
-	/**
-	 * Insert a new element into the list.
-	 *
-	 * The new element is inserted after the last stored element.
-	 *
-	 * @param entry
-	 * @return
-	 *          -@c FULL if the List is full
-	 *          -@c RETURN_OK else
-	 */
-	ReturnValue_t insert(T entry) {
-		if (size >= maxSize_) {
-			return FULL;
-		}
-		entries[size] = entry;
-		++size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	/**
-	 * clear the List
-	 *
-	 * This does not actually clear all entries, it only sets the size to 0.
-	 */
-	void clear() {
-		size = 0;
-	}
-
-	count_t remaining() {
-		return (maxSize_ - size);
-	}
-
-protected:
-	/**
-	 * pointer to the array in which the entries are stored
-	 */
-	T *entries;
-	/**
-	 * remembering the maximum size
-	 */
-	uint32_t maxSize_;
-
-	/**
-	 * true if the array was allocated and needs to be deleted in the destructor.
-	 */
-	bool allocated;
-};
-
-#endif /* ARRAYLIST_H_ */
+#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
+#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeIF.h"
+
+/**
+ * @brief 	A List that stores its values in an array.
+ * @details
+ * The underlying storage is an array that can be allocated by the class
+ * itself or supplied via ctor.
+ *
+ * @ingroup container
+ */
+template<typename T, typename count_t = uint8_t>
+class ArrayList {
+	template<typename U, typename count> friend class SerialArrayListAdapter;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
+
+    /**
+     * Copying is forbiden by declaring copy ctor and copy assignment deleted
+     * It is too ambigous in this case.
+     * (Allocate a new backend? Use the same? What to do in an modifying call?)
+     */
+	ArrayList(const ArrayList& other) = delete;
+	const ArrayList& operator=(const ArrayList& other) = delete;
+
+	/**
+	 * Number of Elements stored in this List
+	 */
+	count_t size;
+
+	/**
+	 * This is the allocating constructor;
+	 *
+	 * It allocates an array of the specified size.
+	 *
+	 * @param maxSize
+	 */
+	ArrayList(count_t maxSize) :
+			size(0), maxSize_(maxSize), allocated(true) {
+		entries = new T[maxSize];
+	}
+
+	/**
+	 * This is the non-allocating constructor
+	 *
+	 * It expects a pointer to an array of a certain size and initializes itself to it.
+	 *
+	 * @param storage the array to use as backend
+	 * @param maxSize size of storage
+	 * @param size size of data already present in storage
+	 */
+	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
+			size(size), entries(storage), maxSize_(maxSize), allocated(false) {
+	}
+
+	/**
+	 * Destructor, if the allocating constructor was used, it deletes the array.
+	 */
+	virtual ~ArrayList() {
+		if (allocated) {
+			delete[] entries;
+		}
+	}
+
+    /**
+     * An Iterator to go trough an ArrayList
+     *
+     * It stores a pointer to an element and increments the
+     * pointer when incremented itself.
+     */
+    class Iterator {
+    public:
+        /**
+         * Empty ctor, points to NULL
+         */
+        Iterator(): value(0) {}
+
+        /**
+         * Initializes the Iterator to point to an element
+         *
+         * @param initialize
+         */
+        Iterator(T *initialize) {
+            value = initialize;
+        }
+
+        /**
+         * The current element the iterator points to
+         */
+        T *value;
+
+        Iterator& operator++() {
+            value++;
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
+
+        Iterator& operator--() {
+            value--;
+            return *this;
+        }
+
+        Iterator operator--(int) {
+            Iterator tmp(*this);
+            operator--();
+            return tmp;
+        }
+
+        T operator*() {
+            return *value;
+        }
+
+        T *operator->() {
+            return value;
+        }
+
+        const T *operator->() const{
+            return value;
+        }
+
+        //SHOULDDO this should be implemented as non-member
+        bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const{
+            return (value == other.value);
+        }
+
+        //SHOULDDO this should be implemented as non-member
+        bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
+            return !(*this == other);
+        }
+    };
+
+	/**
+	 * Iterator pointing to the first stored elmement
+	 *
+	 * @return Iterator to the first element
+	 */
+	Iterator begin() const {
+		return Iterator(&entries[0]);
+	}
+
+	/**
+	 * returns an Iterator pointing to the element after the last stored entry
+	 *
+	 * @return Iterator to the element after the last entry
+	 */
+	Iterator end() const {
+		return Iterator(&entries[size]);
+	}
+
+	T & operator[](count_t i) const {
+		return entries[i];
+	}
+
+	/**
+	 * The first element
+	 *
+	 * @return pointer to the first stored element
+	 */
+	T *front() {
+		return entries;
+	}
+
+	/**
+	 * The last element
+	 *
+	 * does not return a valid pointer if called on an empty list.
+	 *
+	 * @return pointer to the last stored element
+	 */
+	T *back() {
+		return &entries[size - 1];
+		//Alternative solution
+		//return const_cast<T*>(static_cast<const T*>(*this).back());
+	}
+
+	const T* back() const{
+		return &entries[size-1];
+	}
+
+	/**
+	 * The maximum number of elements this List can contain
+	 *
+	 * @return maximum number of elements
+	 */
+	uint32_t maxSize() const {
+		return this->maxSize_;
+	}
+
+	/**
+	 * Insert a new element into the list.
+	 *
+	 * The new element is inserted after the last stored element.
+	 *
+	 * @param entry
+	 * @return
+	 *          -@c FULL if the List is full
+	 *          -@c RETURN_OK else
+	 */
+	ReturnValue_t insert(T entry) {
+		if (size >= maxSize_) {
+			return FULL;
+		}
+		entries[size] = entry;
+		++size;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	/**
+	 * clear the List
+	 *
+	 * This does not actually clear all entries, it only sets the size to 0.
+	 */
+	void clear() {
+		size = 0;
+	}
+
+	count_t remaining() {
+		return (maxSize_ - size);
+	}
+
+protected:
+	/**
+	 * pointer to the array in which the entries are stored
+	 */
+	T *entries;
+	/**
+	 * remembering the maximum size
+	 */
+	uint32_t maxSize_;
+
+	/**
+	 * true if the array was allocated and needs to be deleted in the destructor.
+	 */
+	bool allocated;
+};
+
+#endif /* ARRAYLIST_H_ */
diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index b63cee657..9af98f966 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -1,42 +1,42 @@
-#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
-#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
-
-#include "../container/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->setData(fifoVector.data());
-	};
-
-	/**
-	 * @brief	Custom copy constructor which prevents setting the
-	 * 	        underlying pointer wrong.
-	 */
-	DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
-			fifoVector(other.maxCapacity) {
-		this->setData(fifoVector.data());
-	}
-
-
-private:
-	std::vector<T> fifoVector;
-};
-
-#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
+#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+
+#include "../container/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->setData(fifoVector.data());
+	};
+
+	/**
+	 * @brief	Custom copy constructor which prevents setting the
+	 * 	        underlying pointer wrong.
+	 */
+	DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
+			fifoVector(other.maxCapacity) {
+		this->setData(fifoVector.data());
+	}
+
+
+private:
+	std::vector<T> fifoVector;
+};
+
+#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index a870e773e..4688a7b05 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -1,34 +1,34 @@
-#ifndef FRAMEWORK_CONTAINER_FIFO_H_
-#define FRAMEWORK_CONTAINER_FIFO_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../container/FIFOBase.h"
-#include <array>
-
-/**
- * @brief 	Simple First-In-First-Out data structure with size fixed at
- * 			compile time
- * @details
- * Performs no dynamic memory allocation.
- * The public interface of FIFOBase exposes the user interface for the FIFO.
- * @tparam T Entry Type
- * @tparam capacity Maximum capacity
- */
-template<typename T, size_t capacity>
-class FIFO: public FIFOBase<T> {
-public:
-	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
-
-	/**
-	 * @brief 	Custom copy constructor to set pointer correctly.
-	 * @param other
-	 */
-	FIFO(const FIFO& other): FIFOBase<T>(other) {
-		this->setData(fifoArray.data());
-	}
-
-private:
-	std::array<T, capacity> fifoArray;
-};
-
-#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
+#ifndef FRAMEWORK_CONTAINER_FIFO_H_
+#define FRAMEWORK_CONTAINER_FIFO_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../container/FIFOBase.h"
+#include <array>
+
+/**
+ * @brief 	Simple First-In-First-Out data structure with size fixed at
+ * 			compile time
+ * @details
+ * Performs no dynamic memory allocation.
+ * The public interface of FIFOBase exposes the user interface for the FIFO.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+template<typename T, size_t capacity>
+class FIFO: public FIFOBase<T> {
+public:
+	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
+
+	/**
+	 * @brief 	Custom copy constructor to set pointer correctly.
+	 * @param other
+	 */
+	FIFO(const FIFO& other): FIFOBase<T>(other) {
+		this->setData(fifoArray.data());
+	}
+
+private:
+	std::array<T, capacity> fifoArray;
+};
+
+#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index ddccbdd42..410e52a5b 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -1,65 +1,65 @@
-#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
-#define FRAMEWORK_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 setData(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 "../container/FIFOBase.tpp"
-
-#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
+#define FRAMEWORK_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 setData(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 "../container/FIFOBase.tpp"
+
+#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index 70a1d5e2b..da85c6233 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -1,57 +1,57 @@
-#ifndef FIXEDARRAYLIST_H_
-#define FIXEDARRAYLIST_H_
-
-#include "../container/ArrayList.h"
-
-/**
- * @brief 	Array List with a fixed maximum size
- * @ingroup container
- */
-template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
-class FixedArrayList: public ArrayList<T, count_t> {
-private:
-	T data[MAX_SIZE];
-public:
-	/**
-	 * (Robin) Maybe we should also implement move assignment and move ctor.
-	 * Or at least delete them.
-	 */
-	FixedArrayList() :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-	}
-
-	// (Robin): We could create a constructor to initialize the fixed array list
-	// with data and the known size field
-	// so it can be used for serialization too (with SerialFixedArrrayListAdapter)
-	// is this feasible?
-	/**
-	 * Initialize a fixed array list with data and number of data fields.
-	 * Endianness of entries can be swapped optionally.
-	 * @param data_
-	 * @param count
-	 * @param swapArrayListEndianess
-	 */
-	FixedArrayList(T * data_, count_t count):
-		ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, data_, count * sizeof(T));
-		this->size = count;
-	}
-
-	FixedArrayList(const FixedArrayList& other) :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-	}
-
-	FixedArrayList& operator=(FixedArrayList other) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		return *this;
-	}
-
-	virtual ~FixedArrayList() {
-	}
-
-};
-
-#endif /* FIXEDARRAYLIST_H_ */
+#ifndef FIXEDARRAYLIST_H_
+#define FIXEDARRAYLIST_H_
+
+#include "../container/ArrayList.h"
+
+/**
+ * @brief 	Array List with a fixed maximum size
+ * @ingroup container
+ */
+template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
+class FixedArrayList: public ArrayList<T, count_t> {
+private:
+	T data[MAX_SIZE];
+public:
+	/**
+	 * (Robin) Maybe we should also implement move assignment and move ctor.
+	 * Or at least delete them.
+	 */
+	FixedArrayList() :
+			ArrayList<T, count_t>(data, MAX_SIZE) {
+	}
+
+	// (Robin): We could create a constructor to initialize the fixed array list
+	// with data and the known size field
+	// so it can be used for serialization too (with SerialFixedArrrayListAdapter)
+	// is this feasible?
+	/**
+	 * Initialize a fixed array list with data and number of data fields.
+	 * Endianness of entries can be swapped optionally.
+	 * @param data_
+	 * @param count
+	 * @param swapArrayListEndianess
+	 */
+	FixedArrayList(T * data_, count_t count):
+		ArrayList<T, count_t>(data, MAX_SIZE) {
+		memcpy(this->data, data_, count * sizeof(T));
+		this->size = count;
+	}
+
+	FixedArrayList(const FixedArrayList& other) :
+			ArrayList<T, count_t>(data, MAX_SIZE) {
+		memcpy(this->data, other.data, sizeof(this->data));
+		this->entries = data;
+	}
+
+	FixedArrayList& operator=(FixedArrayList other) {
+		memcpy(this->data, other.data, sizeof(this->data));
+		this->entries = data;
+		return *this;
+	}
+
+	virtual ~FixedArrayList() {
+	}
+
+};
+
+#endif /* FIXEDARRAYLIST_H_ */
diff --git a/container/FixedMap.h b/container/FixedMap.h
index a3afc0238..3da65784b 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -1,225 +1,225 @@
-#ifndef FIXEDMAP_H_
-#define FIXEDMAP_H_
-
-#include "../container/ArrayList.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <utility>
-
-/**
- * @brief 	Map implementation for maps with a pre-defined size.
- * @details Can be initialized with desired maximum size.
- * 	        Iterator is used to access <key,value> pair and
- * 	        iterate through map entries. Complexity O(n).
- * @ingroup container
- */
-template<typename key_t, typename T>
-class FixedMap: public SerializeIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
-
-private:
-	static const key_t EMPTY_SLOT = -1;
-	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
-
-	uint32_t findIndex(key_t key) const {
-		if (_size == 0) {
-			return 1;
-		}
-		uint32_t i = 0;
-		for (i = 0; i < _size; ++i) {
-			if (theMap[i].first == key) {
-				return i;
-			}
-		}
-		return i;
-	}
-public:
-	FixedMap(uint32_t maxSize) :
-			theMap(maxSize), _size(0) {
-	}
-
-	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-	public:
-		Iterator() :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
-		}
-
-		Iterator(std::pair<key_t, T> *pair) :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
-		}
-
-		T operator*() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		// -> operator overloaded, can be used to access value
-		T *operator->() {
-			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		// Can be used to access the key of the iterator
-		key_t first() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->first;
-		}
-
-		// Alternative to access value, similar to std::map implementation
-		T second() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-	};
-
-
-
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
-
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
-
-	uint32_t size() const {
-		return _size;
-	}
-
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
-		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
-			return FixedMap::KEY_ALREADY_EXISTS;
-		}
-		if (_size == theMap.maxSize()) {
-			return FixedMap::MAP_FULL;
-		}
-		theMap[_size].first = key;
-		theMap[_size].second = value;
-		if (storedValue != NULL) {
-			*storedValue = Iterator(&theMap[_size]);
-		}
-		++_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.first, pair.second);
-	}
-
-	ReturnValue_t exists(key_t key) const {
-		ReturnValue_t result = KEY_DOES_NOT_EXIST;
-		if (findIndex(key) < _size) {
-			result = HasReturnvaluesIF::RETURN_OK;
-		}
-		return result;
-	}
-
-	ReturnValue_t erase(Iterator *iter) {
-		uint32_t i;
-		if ((i = findIndex((*iter).value->first)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		--((*iter).value);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t erase(key_t key) {
-		uint32_t i;
-		if ((i = findIndex(key)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	T *findValue(key_t key) const {
-		return &theMap[findIndex(key)].second;
-	}
-
-	Iterator find(key_t key) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findIndex(key)]);
-	}
-
-	ReturnValue_t find(key_t key, T **value) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		*value = &theMap[findIndex(key)].second;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	void clear() {
-		_size = 0;
-	}
-
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
-
-
-	bool full() {
-		if(_size == theMap.maxSize()) {
-			return true;
-		}
-		else {
-			return false;
-		}
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
-				buffer, size, maxSize, streamEndianness);
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
-					size, maxSize, streamEndianness);
-			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const {
-		uint32_t printSize = sizeof(_size);
-		uint32_t i = 0;
-
-		for (i = 0; i < _size; ++i) {
-			printSize += SerializeAdapter::getSerializedSize(
-					&theMap[i].first);
-			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
-		}
-
-		return printSize;
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
-				buffer, size, streamEndianness);
-		if (this->_size > theMap.maxSize()) {
-			return SerializeIF::TOO_MANY_ELEMENTS;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
-					size, streamEndianness);
-			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-};
-
-#endif /* FIXEDMAP_H_ */
+#ifndef FIXEDMAP_H_
+#define FIXEDMAP_H_
+
+#include "../container/ArrayList.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <utility>
+
+/**
+ * @brief 	Map implementation for maps with a pre-defined size.
+ * @details Can be initialized with desired maximum size.
+ * 	        Iterator is used to access <key,value> pair and
+ * 	        iterate through map entries. Complexity O(n).
+ * @ingroup container
+ */
+template<typename key_t, typename T>
+class FixedMap: public SerializeIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
+	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+
+private:
+	static const key_t EMPTY_SLOT = -1;
+	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
+	uint32_t _size;
+
+	uint32_t findIndex(key_t key) const {
+		if (_size == 0) {
+			return 1;
+		}
+		uint32_t i = 0;
+		for (i = 0; i < _size; ++i) {
+			if (theMap[i].first == key) {
+				return i;
+			}
+		}
+		return i;
+	}
+public:
+	FixedMap(uint32_t maxSize) :
+			theMap(maxSize), _size(0) {
+	}
+
+	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
+	public:
+		Iterator() :
+				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
+		}
+
+		Iterator(std::pair<key_t, T> *pair) :
+				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
+		}
+
+		T operator*() {
+			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
+
+		// -> operator overloaded, can be used to access value
+		T *operator->() {
+			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
+
+		// Can be used to access the key of the iterator
+		key_t first() {
+			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->first;
+		}
+
+		// Alternative to access value, similar to std::map implementation
+		T second() {
+			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
+	};
+
+
+
+	Iterator begin() const {
+		return Iterator(&theMap[0]);
+	}
+
+	Iterator end() const {
+		return Iterator(&theMap[_size]);
+	}
+
+	uint32_t size() const {
+		return _size;
+	}
+
+	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
+		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
+			return FixedMap::KEY_ALREADY_EXISTS;
+		}
+		if (_size == theMap.maxSize()) {
+			return FixedMap::MAP_FULL;
+		}
+		theMap[_size].first = key;
+		theMap[_size].second = value;
+		if (storedValue != NULL) {
+			*storedValue = Iterator(&theMap[_size]);
+		}
+		++_size;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t insert(std::pair<key_t, T> pair) {
+		return insert(pair.first, pair.second);
+	}
+
+	ReturnValue_t exists(key_t key) const {
+		ReturnValue_t result = KEY_DOES_NOT_EXIST;
+		if (findIndex(key) < _size) {
+			result = HasReturnvaluesIF::RETURN_OK;
+		}
+		return result;
+	}
+
+	ReturnValue_t erase(Iterator *iter) {
+		uint32_t i;
+		if ((i = findIndex((*iter).value->first)) >= _size) {
+			return KEY_DOES_NOT_EXIST;
+		}
+		theMap[i] = theMap[_size - 1];
+		--_size;
+		--((*iter).value);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t erase(key_t key) {
+		uint32_t i;
+		if ((i = findIndex(key)) >= _size) {
+			return KEY_DOES_NOT_EXIST;
+		}
+		theMap[i] = theMap[_size - 1];
+		--_size;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	T *findValue(key_t key) const {
+		return &theMap[findIndex(key)].second;
+	}
+
+	Iterator find(key_t key) const {
+		ReturnValue_t result = exists(key);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return end();
+		}
+		return Iterator(&theMap[findIndex(key)]);
+	}
+
+	ReturnValue_t find(key_t key, T **value) const {
+		ReturnValue_t result = exists(key);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		*value = &theMap[findIndex(key)].second;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	void clear() {
+		_size = 0;
+	}
+
+	uint32_t maxSize() const {
+		return theMap.maxSize();
+	}
+
+
+	bool full() {
+		if(_size == theMap.maxSize()) {
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
+				buffer, size, maxSize, streamEndianness);
+		uint32_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
+					size, maxSize, streamEndianness);
+			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
+					maxSize, streamEndianness);
+			++i;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const {
+		uint32_t printSize = sizeof(_size);
+		uint32_t i = 0;
+
+		for (i = 0; i < _size; ++i) {
+			printSize += SerializeAdapter::getSerializedSize(
+					&theMap[i].first);
+			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
+		}
+
+		return printSize;
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
+				buffer, size, streamEndianness);
+		if (this->_size > theMap.maxSize()) {
+			return SerializeIF::TOO_MANY_ELEMENTS;
+		}
+		uint32_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
+					size, streamEndianness);
+			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
+					streamEndianness);
+			++i;
+		}
+		return result;
+	}
+
+};
+
+#endif /* FIXEDMAP_H_ */
diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index 118813266..630bae28d 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -1,90 +1,90 @@
-#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
-#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
-
-#include "../container/ArrayList.h"
-#include "../container/SinglyLinkedList.h"
-
-template<typename T, typename count_t = uint8_t>
-class HybridIterator: public LinkedElement<T>::Iterator,
-		public ArrayList<T, count_t>::Iterator {
-public:
-	HybridIterator() {}
-
-	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
-		LinkedElement<T>::Iterator(*iter), value(iter->value),
-		linked(true) {
-
-	}
-
-	HybridIterator(LinkedElement<T> *start) :
-		LinkedElement<T>::Iterator(start), value(start->value),
-		linked(true) {
-
-	}
-
-	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
-			typename ArrayList<T, count_t>::Iterator end) :
-			ArrayList<T, count_t>::Iterator(start), value(start.value),
-			linked(false), end(end.value) {
-		if (value == this->end) {
-			value = NULL;
-		}
-	}
-
-	HybridIterator(T *firstElement, T *lastElement) :
-			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
-			linked(false), end(++lastElement) {
-		if (value == end) {
-			value = NULL;
-		}
-	}
-
-	HybridIterator& operator++() {
-		if (linked) {
-			LinkedElement<T>::Iterator::operator++();
-			if (LinkedElement<T>::Iterator::value != nullptr) {
-				value = LinkedElement<T>::Iterator::value->value;
-			} else {
-				value = nullptr;
-			}
-		} else {
-			ArrayList<T, count_t>::Iterator::operator++();
-			value = ArrayList<T, count_t>::Iterator::value;
-
-			if (value == end) {
-				value = nullptr;
-			}
-		}
-		return *this;
-	}
-
-	HybridIterator operator++(int) {
-		HybridIterator tmp(*this);
-		operator++();
-		return tmp;
-	}
-
-	bool operator==(const HybridIterator& other) const {
-		return value == other.value;
-	}
-
-	bool operator!=(const HybridIterator& other) const {
-		return !(*this == other);
-	}
-
-	T operator*() {
-		return *value;
-	}
-
-	T *operator->() {
-		return value;
-	}
-
-	T* value = nullptr;
-
-private:
-	bool linked = false;
-	T *end = nullptr;
-};
-
-#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
+#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+
+#include "../container/ArrayList.h"
+#include "../container/SinglyLinkedList.h"
+
+template<typename T, typename count_t = uint8_t>
+class HybridIterator: public LinkedElement<T>::Iterator,
+		public ArrayList<T, count_t>::Iterator {
+public:
+	HybridIterator() {}
+
+	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
+		LinkedElement<T>::Iterator(*iter), value(iter->value),
+		linked(true) {
+
+	}
+
+	HybridIterator(LinkedElement<T> *start) :
+		LinkedElement<T>::Iterator(start), value(start->value),
+		linked(true) {
+
+	}
+
+	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
+			typename ArrayList<T, count_t>::Iterator end) :
+			ArrayList<T, count_t>::Iterator(start), value(start.value),
+			linked(false), end(end.value) {
+		if (value == this->end) {
+			value = NULL;
+		}
+	}
+
+	HybridIterator(T *firstElement, T *lastElement) :
+			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
+			linked(false), end(++lastElement) {
+		if (value == end) {
+			value = NULL;
+		}
+	}
+
+	HybridIterator& operator++() {
+		if (linked) {
+			LinkedElement<T>::Iterator::operator++();
+			if (LinkedElement<T>::Iterator::value != nullptr) {
+				value = LinkedElement<T>::Iterator::value->value;
+			} else {
+				value = nullptr;
+			}
+		} else {
+			ArrayList<T, count_t>::Iterator::operator++();
+			value = ArrayList<T, count_t>::Iterator::value;
+
+			if (value == end) {
+				value = nullptr;
+			}
+		}
+		return *this;
+	}
+
+	HybridIterator operator++(int) {
+		HybridIterator tmp(*this);
+		operator++();
+		return tmp;
+	}
+
+	bool operator==(const HybridIterator& other) const {
+		return value == other.value;
+	}
+
+	bool operator!=(const HybridIterator& other) const {
+		return !(*this == other);
+	}
+
+	T operator*() {
+		return *value;
+	}
+
+	T *operator->() {
+		return value;
+	}
+
+	T* value = nullptr;
+
+private:
+	bool linked = false;
+	T *end = nullptr;
+};
+
+#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 282916e19..0968abfa7 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -1,721 +1,721 @@
-#ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
-#define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
-
-#include "../container/ArrayList.h"
-#include "../globalfunctions/CRC.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerialArrayListAdapter.h"
-#include <cmath>
-
-/**
- * Index is the Type used for the list of indices.
- *
- * @tparam T Type which destribes the index. Needs to be a child of SerializeIF
- * 			 to be able to make it persistent
- */
-template<typename T>
-class Index: public SerializeIF{
-	/**
-	 *
-	 */
-	static_assert(std::is_base_of<SerializeIF,T>::value,
-			"Wrong Type for Index, Type must implement SerializeIF");
-public:
-	Index():blockStartAddress(0),size(0),storedPackets(0){}
-
-	Index(uint32_t startAddress):blockStartAddress(startAddress),
-			size(0),storedPackets(0) {
-	}
-
-	void setBlockStartAddress(uint32_t newAddress) {
-		this->blockStartAddress = newAddress;
-	}
-
-	uint32_t getBlockStartAddress() const {
-		return blockStartAddress;
-	}
-
-	const T* getIndexType() const {
-		return &indexType;
-	}
-
-	T* modifyIndexType() {
-		return &indexType;
-	}
-	/**
-	 * Updates the index Type. Uses = operator
-	 * @param indexType Type to copy from
-	 */
-	void setIndexType(T* indexType) {
-		this->indexType = *indexType;
-	}
-
-	uint32_t getSize() const {
-		return size;
-	}
-
-	void setSize(uint32_t size) {
-		this->size = size;
-	}
-
-	void addSize(uint32_t size){
-		this->size += size;
-	}
-
-	void setStoredPackets(uint32_t newStoredPackets){
-		this->storedPackets = newStoredPackets;
-	}
-
-	void addStoredPackets(uint32_t packets){
-		this->storedPackets += packets;
-	}
-
-	uint32_t getStoredPackets() const{
-		return this->storedPackets;
-	}
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		return result;
-	}
-
-	size_t getSerializedSize() const {
-		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
-		size += indexType.getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
-		return size;
-	}
-
-
-	bool operator==(const Index<T>& other){
-		return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
-	}
-
-private:
-	uint32_t blockStartAddress;
-	uint32_t size;
-	uint32_t storedPackets;
-	T indexType;
-};
-
-
-/**
- * @brief Indexed Ring Memory Array is a class for a ring memory with indices.
- * @details
- * It assumes that the newest data comes in last
- * It uses the currentWriteBlock as pointer to the current writing position
- * The currentReadBlock must be set manually
- * @tparam T
- */
-template<typename T>
-class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
-	/**
-	 *
-	 */
-public:
-	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
-			SerializeIF* additionalInfo, bool overwriteOld):
-			ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),
-			indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),
-			lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld)
-	{
-		//Calculate the maximum number of indices needed for this blocksize
-		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
-
-		//Calculate the Size needeed for the index itself
-		size_t serializedSize = 0;
-		if(additionalInfo!=NULL) {
-			serializedSize += additionalInfo->getSerializedSize();
-		}
-
-		//Size of current iterator type
-		Index<T> tempIndex;
-		serializedSize += tempIndex.getSerializedSize();
-
-		//Add Size of Array
-		serializedSize += sizeof(uint32_t); //size of array
-		serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
-		serializedSize += sizeof(uint16_t); //size of crc
-
-		//Calculate new size after index
-		if(serializedSize > totalSize){
-			error << "IndexedRingMemory: Store is too small for index" << std::endl;
-		}
-		uint32_t useableSize = totalSize - serializedSize;
-
-		//Update the totalSize for calculations
-		totalSize = useableSize;
-
-		//True StartAddress
-		uint32_t trueStartAddress = indexAddress + serializedSize;
-
-		//Calculate True number of Blocks and reset size of true Number of Blocks
-		uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
-
-		//allocate memory now
-		this->entries = new Index<T>[trueNumberOfBlocks];
-		this->size = trueNumberOfBlocks;
-		this->maxSize_ = trueNumberOfBlocks;
-		this->allocated = true;
-
-		//Check trueNumberOfBlocks
-		if(trueNumberOfBlocks<1) {
-			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
-		}
-
-		//Fill address into index
-		uint32_t address = trueStartAddress;
-		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
-			it->setBlockStartAddress(address);
-			it->setSize(0);
-			it->setStoredPackets(0);
-			address += bytesPerBlock;
-		}
-
-		//Initialize iterators
-		currentWriteBlock = this->begin();
-		currentReadBlock = this->begin();
-		lastBlockToRead = this->begin();
-
-		//Check last blockSize
-		uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
-		if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
-			//remove the last Block so the second last block has more size
-			this->size -= 1;
-			debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
-		}
-	}
-
-	/**
-	 * Resets the whole index, the iterators and executes the given reset function on every index type
-	 * @param typeResetFnc static reset function which accepts a pointer to the index Type
-	 */
-	void reset(void (*typeResetFnc)(T*)){
-		currentReadBlock = this->begin();
-		currentWriteBlock = this->begin();
-		lastBlockToRead = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = 0;
-		lastBlockToReadSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
-			it->setSize(0);
-			it->setStoredPackets(0);
-			(*typeResetFnc)(it->modifyIndexType());
-		}
-	}
-
-	void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
-		it->setSize(0);
-		it->setStoredPackets(0);
-		(*typeResetFnc)(it->modifyIndexType());
-	}
-
-	/**
-	 * Reading
-	 * @param it
-	 */
-	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
-		currentReadBlock = it;
-		currentReadBlockSizeCached = it->getSize();
-	}
-
-	void resetRead(){
-		currentReadBlock = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = this->begin()->getSize();
-		lastBlockToRead = currentWriteBlock;
-		lastBlockToReadSize = currentWriteBlock->getSize();
-	}
-
-	/**
-	 * Sets the last block to read to this iterator.
-	 * Can be used to dump until block x
-	 * @param it The iterator for the last read block
-	 */
-	void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
-		lastBlockToRead = it;
-		lastBlockToReadSize = it->getSize();
-	}
-
-	/**
-	 * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
-	 * Can be the currentWriteBlock as well
-	 */
-	void readOldest(){
-		resetRead();
-		currentReadBlock = getNextNonEmptyBlock();
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-
-	}
-
-	/**
-	 * Sets the current read iterator to the next Block and resets the current read size
-	 * The current size of the block will be cached to avoid race condition between write and read
-	 * If the end of the ring is reached the read pointer will be set to the begin
-	 */
-	void readNext(){
-		currentReadSize = 0;
-		if((this->size != 0) && (currentReadBlock.value ==this->back())){
-			currentReadBlock = this->begin();
-		}else{
-			currentReadBlock++;
-		}
-
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-	}
-
-	/**
-	 * Returns the address which is currently read from
-	 * @return Address to read from
-	 */
-	uint32_t getCurrentReadAddress() const {
-		return getAddressOfCurrentReadBlock() + currentReadSize;
-	}
-
-	/**
-	 * Adds readSize to the current size and checks if the read has no more data
-	 * left and advances the read block.
-	 * @param readSize The size that was read
-	 * @return Returns true if the read can go on
-	 */
-	bool addReadSize(uint32_t readSize) {
-		if(currentReadBlock == lastBlockToRead) {
-			//The current read block is the last to read
-			if((currentReadSize+readSize)<lastBlockToReadSize) {
-				//the block has more data -> return true
-				currentReadSize += readSize;
-				return true;
-			}
-			else {
-				//Reached end of read -> return false
-				currentReadSize = lastBlockToReadSize;
-				return false;
-			}
-		}
-		else {
-			//We are not in the last Block
-			if((currentReadSize + readSize)<currentReadBlockSizeCached) {
-				//The current Block has more data
-				currentReadSize += readSize;
-				return true;
-			}
-			// TODO: Maybe some logic blocks should be extracted
-			else {
-				//The current block is written completely
-				readNext();
-				if(currentReadBlockSizeCached==0) {
-					//Next block is empty
-					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
-					//Search if any block between this and the last block is not empty
-					for(;it!=lastBlockToRead;++it){
-						if(it == this->end()){
-							//This is the end, next block is the begin
-							it = this->begin();
-							if(it == lastBlockToRead){
-								//Break if the begin is the lastBlockToRead
-								break;
-							}
-						}
-						if(it->getSize()!=0){
-							//This is a non empty block. Go on reading with this block
-							currentReadBlock = it;
-							currentReadBlockSizeCached = it->getSize();
-							return true;
-						}
-					}
-					//reached lastBlockToRead and every block was empty, check if the last block is also empty
-					if(lastBlockToReadSize!=0){
-						//go on with last Block
-						currentReadBlock = lastBlockToRead;
-						currentReadBlockSizeCached = lastBlockToReadSize;
-						return true;
-					}
-					//There is no non empty block left
-					return false;
-				}
-				//Size is larger than 0
-				return true;
-			}
-		}
-	}
-	uint32_t getRemainigSizeOfCurrentReadBlock() const{
-		if(currentReadBlock == lastBlockToRead){
-			return (lastBlockToReadSize - currentReadSize);
-		}else{
-			return (currentReadBlockSizeCached - currentReadSize);
-		}
-	}
-
-	uint32_t getAddressOfCurrentReadBlock() const {
-		return currentReadBlock->getBlockStartAddress();
-	}
-
-	/**
-	 * Gets the next non empty Block after the current write block,
-	 * @return Returns the iterator to the block. If there is non, the current write block is returned
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
-		for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
-				if(it == this->end()){
-					it = this->begin();
-					if(it == currentWriteBlock){
-						break;
-					}
-				}
-				if(it->getSize()!=0){
-					return it;
-				}
-		}
-		return currentWriteBlock;
-	}
-
-	/**
-	 * Returns a copy of the oldest Index type
-	 * @return Type of Index
-	 */
-	T* getOldest(){
-		return (getNextNonEmptyBlock()->modifyIndexType());
-	}
-
-
-	/*
-	 * Writing
-	 */
-	uint32_t getAddressOfCurrentWriteBlock() const{
-		return currentWriteBlock->getBlockStartAddress();
-	}
-
-	uint32_t getSizeOfCurrentWriteBlock() const{
-		return currentWriteBlock->getSize();
-	}
-
-	uint32_t getCurrentWriteAddress() const{
-		return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
-	}
-
-	void clearCurrentWriteBlock(){
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-	}
-
-	void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
-		currentWriteBlock->addSize(size);
-		currentWriteBlock->addStoredPackets(storedPackets);
-	}
-
-	T* modifyCurrentWriteBlockIndexType(){
-		return currentWriteBlock->modifyIndexType();
-	}
-
-	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
-		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
-		it->addSize(size);
-		it->addStoredPackets(storedPackets);
-	}
-
-	/**
-	 * Checks if the block has enough space for sizeToWrite
-	 * @param sizeToWrite The data to be written in the Block
-	 * @return Returns true if size to write is smaller the remaining size of the block
-	 */
-	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
-		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
-		uint32_t addressOfNextBlock = next->getBlockStartAddress();
-		uint32_t availableSize =
-				( ( addressOfNextBlock + totalSize ) -
-				(getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock()))
-				% totalSize;
-		return (sizeToWrite < availableSize);
-	}
-
-	/**
-	 * Checks if the store is full if overwrite old is false
-	 * @return Returns true if it is writeable and false if not
-	 */
-	bool isNextBlockWritable(){
-		//First check if this is the end of the list
-		typename IndexedRingMemoryArray<T>::Iterator next;
-		next = getNextWrite();
-		if((next->getSize()!=0) && (!overwriteOld)){
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * Updates current write Block Index Type
-	 * @param infoOfNewBlock
-	 */
-	void updateCurrentBlock(T* infoOfNewBlock){
-		currentWriteBlock->setIndexType(infoOfNewBlock);
-	}
-
-
-	/**
-	 * Succeed to next block, returns FAILED if overwrite is false and the store is full
-	 * @return
-	 */
-	ReturnValue_t writeNext(){
-		//Check Next Block
-		if(!isNextBlockWritable()){
-			//The Index is full and does not overwrite old
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		//Next block can be written, update Metadata
-		currentWriteBlock = getNextWrite();
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	/**
-	 * Serializes the Index and calculates the CRC.
-	 * Parameters according to HasSerializeIF
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param streamEndianness
-	 * @return
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const{
-		uint8_t* crcBuffer = *buffer;
-		uint32_t oldSize = *size;
-		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
-		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
-
-
-	/**
-	 * Get the serialized Size of the index
-	 * @return The serialized size of the index
-	 */
-	size_t getSerializedSize() const {
-
-		size_t size = 0;
-		if(additionalInfo!=NULL){
-			size += additionalInfo->getSerializedSize();
-		}
-		size += currentWriteBlock->getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += (this->entries[0].getSerializedSize()) * this->size;
-		uint16_t crc = 0;
-		size += SerializeAdapter::getSerializedSize(&crc);
-		return size;
-	}
-	/**
-	 * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
-	 * CRC Has to be checked before!
-	 * @param buffer
-	 * @param size
-	 * @param streamEndianness
-	 * @return
-	 */
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-
-		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		uint32_t tempSize = 0;
-		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		if(this->size != tempSize){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::deSerialize(
-					&this->entries[i], buffer, size,
-					streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			if(*(cmp.value) == *(it.value)){
-				currentWriteBlock = it;
-				return HasReturnvaluesIF::RETURN_OK;
-			}
-		}
-		//Reached if current write block iterator is not found
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint32_t getIndexAddress() const {
-		return indexAddress;
-	}
-
-
-	/*
-	 * Statistics
-	 */
-	uint32_t getStoredPackets() const {
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getStoredPackets();
-		}
-		return size;
-	}
-
-	uint32_t getTotalSize() const {
-		return totalSize;
-	}
-
-	uint32_t getCurrentSize() const{
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getSize();
-		}
-		return size;
-	}
-
-	bool isEmpty() const{
-		return getCurrentSize()==0;
-	}
-
-	double getPercentageFilled() const{
-		uint32_t filledSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			filledSize += it->getSize();
-		}
-
-		return (double)filledSize/(double)this->totalSize;
-	}
-
-	typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
-		return currentWriteBlock;
-	}
-	/**
-	 * Get the next block of the currentWriteBlock.
-	 * Returns the first one if currentWriteBlock is the last one
-	 * @return Iterator pointing to the next block after currentWriteBlock
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
-		typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
-		if((this->size != 0) && (currentWriteBlock.value == this->back())){
-			next = this->begin();
-		}else{
-			++next;
-		}
-		return next;
-	}
-	/**
-	 * Get the block in front of the Iterator
-	 * Returns the last block if it is the first block
-	 * @param it iterator which you want the previous block from
-	 * @return pointing to the block before it
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
-		if(this->begin() == it){
-			typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
-			return next;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator next(it);
-		--next;
-		return next;
-	}
-private:
-	//The total size used by the blocks (without index)
-	uint32_t totalSize;
-
-	//The address of the index
-	const uint32_t indexAddress;
-
-	//The iterators for writing and reading
-	typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
-	typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
-
-	//How much of the current read block is read already
-	uint32_t currentReadSize;
-
-	//Cached Size of current read block
-	uint32_t currentReadBlockSizeCached;
-
-	//Last block of current write (should be write block)
-	typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
-	//current size of last Block to read
-	uint32_t lastBlockToReadSize;
-
-	//Additional Info to be serialized with the index
-	SerializeIF* additionalInfo;
-
-	//Does it overwrite old blocks?
-	const bool overwriteOld;
-
-};
-
-#endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */
+#ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
+#define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
+
+#include "../container/ArrayList.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include <cmath>
+
+/**
+ * Index is the Type used for the list of indices.
+ *
+ * @tparam T Type which destribes the index. Needs to be a child of SerializeIF
+ * 			 to be able to make it persistent
+ */
+template<typename T>
+class Index: public SerializeIF{
+	/**
+	 *
+	 */
+	static_assert(std::is_base_of<SerializeIF,T>::value,
+			"Wrong Type for Index, Type must implement SerializeIF");
+public:
+	Index():blockStartAddress(0),size(0),storedPackets(0){}
+
+	Index(uint32_t startAddress):blockStartAddress(startAddress),
+			size(0),storedPackets(0) {
+	}
+
+	void setBlockStartAddress(uint32_t newAddress) {
+		this->blockStartAddress = newAddress;
+	}
+
+	uint32_t getBlockStartAddress() const {
+		return blockStartAddress;
+	}
+
+	const T* getIndexType() const {
+		return &indexType;
+	}
+
+	T* modifyIndexType() {
+		return &indexType;
+	}
+	/**
+	 * Updates the index Type. Uses = operator
+	 * @param indexType Type to copy from
+	 */
+	void setIndexType(T* indexType) {
+		this->indexType = *indexType;
+	}
+
+	uint32_t getSize() const {
+		return size;
+	}
+
+	void setSize(uint32_t size) {
+		this->size = size;
+	}
+
+	void addSize(uint32_t size){
+		this->size += size;
+	}
+
+	void setStoredPackets(uint32_t newStoredPackets){
+		this->storedPackets = newStoredPackets;
+	}
+
+	void addStoredPackets(uint32_t packets){
+		this->storedPackets += packets;
+	}
+
+	uint32_t getStoredPackets() const{
+		return this->storedPackets;
+	}
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
+		return result;
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness){
+		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = indexType.deSerialize(buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		return result;
+	}
+
+	size_t getSerializedSize() const {
+		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
+		size += indexType.getSerializedSize();
+		size += SerializeAdapter::getSerializedSize(&this->size);
+		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
+		return size;
+	}
+
+
+	bool operator==(const Index<T>& other){
+		return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
+	}
+
+private:
+	uint32_t blockStartAddress;
+	uint32_t size;
+	uint32_t storedPackets;
+	T indexType;
+};
+
+
+/**
+ * @brief Indexed Ring Memory Array is a class for a ring memory with indices.
+ * @details
+ * It assumes that the newest data comes in last
+ * It uses the currentWriteBlock as pointer to the current writing position
+ * The currentReadBlock must be set manually
+ * @tparam T
+ */
+template<typename T>
+class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
+	/**
+	 *
+	 */
+public:
+	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
+			SerializeIF* additionalInfo, bool overwriteOld):
+			ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),
+			indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),
+			lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld)
+	{
+		//Calculate the maximum number of indices needed for this blocksize
+		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
+
+		//Calculate the Size needeed for the index itself
+		size_t serializedSize = 0;
+		if(additionalInfo!=NULL) {
+			serializedSize += additionalInfo->getSerializedSize();
+		}
+
+		//Size of current iterator type
+		Index<T> tempIndex;
+		serializedSize += tempIndex.getSerializedSize();
+
+		//Add Size of Array
+		serializedSize += sizeof(uint32_t); //size of array
+		serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
+		serializedSize += sizeof(uint16_t); //size of crc
+
+		//Calculate new size after index
+		if(serializedSize > totalSize){
+			error << "IndexedRingMemory: Store is too small for index" << std::endl;
+		}
+		uint32_t useableSize = totalSize - serializedSize;
+
+		//Update the totalSize for calculations
+		totalSize = useableSize;
+
+		//True StartAddress
+		uint32_t trueStartAddress = indexAddress + serializedSize;
+
+		//Calculate True number of Blocks and reset size of true Number of Blocks
+		uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
+
+		//allocate memory now
+		this->entries = new Index<T>[trueNumberOfBlocks];
+		this->size = trueNumberOfBlocks;
+		this->maxSize_ = trueNumberOfBlocks;
+		this->allocated = true;
+
+		//Check trueNumberOfBlocks
+		if(trueNumberOfBlocks<1) {
+			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
+		}
+
+		//Fill address into index
+		uint32_t address = trueStartAddress;
+		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
+			it->setBlockStartAddress(address);
+			it->setSize(0);
+			it->setStoredPackets(0);
+			address += bytesPerBlock;
+		}
+
+		//Initialize iterators
+		currentWriteBlock = this->begin();
+		currentReadBlock = this->begin();
+		lastBlockToRead = this->begin();
+
+		//Check last blockSize
+		uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
+		if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
+			//remove the last Block so the second last block has more size
+			this->size -= 1;
+			debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
+		}
+	}
+
+	/**
+	 * Resets the whole index, the iterators and executes the given reset function on every index type
+	 * @param typeResetFnc static reset function which accepts a pointer to the index Type
+	 */
+	void reset(void (*typeResetFnc)(T*)){
+		currentReadBlock = this->begin();
+		currentWriteBlock = this->begin();
+		lastBlockToRead = this->begin();
+		currentReadSize = 0;
+		currentReadBlockSizeCached = 0;
+		lastBlockToReadSize = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
+			it->setSize(0);
+			it->setStoredPackets(0);
+			(*typeResetFnc)(it->modifyIndexType());
+		}
+	}
+
+	void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
+		it->setSize(0);
+		it->setStoredPackets(0);
+		(*typeResetFnc)(it->modifyIndexType());
+	}
+
+	/**
+	 * Reading
+	 * @param it
+	 */
+	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
+		currentReadBlock = it;
+		currentReadBlockSizeCached = it->getSize();
+	}
+
+	void resetRead(){
+		currentReadBlock = this->begin();
+		currentReadSize = 0;
+		currentReadBlockSizeCached = this->begin()->getSize();
+		lastBlockToRead = currentWriteBlock;
+		lastBlockToReadSize = currentWriteBlock->getSize();
+	}
+
+	/**
+	 * Sets the last block to read to this iterator.
+	 * Can be used to dump until block x
+	 * @param it The iterator for the last read block
+	 */
+	void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
+		lastBlockToRead = it;
+		lastBlockToReadSize = it->getSize();
+	}
+
+	/**
+	 * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
+	 * Can be the currentWriteBlock as well
+	 */
+	void readOldest(){
+		resetRead();
+		currentReadBlock = getNextNonEmptyBlock();
+		currentReadBlockSizeCached = currentReadBlock->getSize();
+
+	}
+
+	/**
+	 * Sets the current read iterator to the next Block and resets the current read size
+	 * The current size of the block will be cached to avoid race condition between write and read
+	 * If the end of the ring is reached the read pointer will be set to the begin
+	 */
+	void readNext(){
+		currentReadSize = 0;
+		if((this->size != 0) && (currentReadBlock.value ==this->back())){
+			currentReadBlock = this->begin();
+		}else{
+			currentReadBlock++;
+		}
+
+		currentReadBlockSizeCached = currentReadBlock->getSize();
+	}
+
+	/**
+	 * Returns the address which is currently read from
+	 * @return Address to read from
+	 */
+	uint32_t getCurrentReadAddress() const {
+		return getAddressOfCurrentReadBlock() + currentReadSize;
+	}
+
+	/**
+	 * Adds readSize to the current size and checks if the read has no more data
+	 * left and advances the read block.
+	 * @param readSize The size that was read
+	 * @return Returns true if the read can go on
+	 */
+	bool addReadSize(uint32_t readSize) {
+		if(currentReadBlock == lastBlockToRead) {
+			//The current read block is the last to read
+			if((currentReadSize+readSize)<lastBlockToReadSize) {
+				//the block has more data -> return true
+				currentReadSize += readSize;
+				return true;
+			}
+			else {
+				//Reached end of read -> return false
+				currentReadSize = lastBlockToReadSize;
+				return false;
+			}
+		}
+		else {
+			//We are not in the last Block
+			if((currentReadSize + readSize)<currentReadBlockSizeCached) {
+				//The current Block has more data
+				currentReadSize += readSize;
+				return true;
+			}
+			// TODO: Maybe some logic blocks should be extracted
+			else {
+				//The current block is written completely
+				readNext();
+				if(currentReadBlockSizeCached==0) {
+					//Next block is empty
+					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
+					//Search if any block between this and the last block is not empty
+					for(;it!=lastBlockToRead;++it){
+						if(it == this->end()){
+							//This is the end, next block is the begin
+							it = this->begin();
+							if(it == lastBlockToRead){
+								//Break if the begin is the lastBlockToRead
+								break;
+							}
+						}
+						if(it->getSize()!=0){
+							//This is a non empty block. Go on reading with this block
+							currentReadBlock = it;
+							currentReadBlockSizeCached = it->getSize();
+							return true;
+						}
+					}
+					//reached lastBlockToRead and every block was empty, check if the last block is also empty
+					if(lastBlockToReadSize!=0){
+						//go on with last Block
+						currentReadBlock = lastBlockToRead;
+						currentReadBlockSizeCached = lastBlockToReadSize;
+						return true;
+					}
+					//There is no non empty block left
+					return false;
+				}
+				//Size is larger than 0
+				return true;
+			}
+		}
+	}
+	uint32_t getRemainigSizeOfCurrentReadBlock() const{
+		if(currentReadBlock == lastBlockToRead){
+			return (lastBlockToReadSize - currentReadSize);
+		}else{
+			return (currentReadBlockSizeCached - currentReadSize);
+		}
+	}
+
+	uint32_t getAddressOfCurrentReadBlock() const {
+		return currentReadBlock->getBlockStartAddress();
+	}
+
+	/**
+	 * Gets the next non empty Block after the current write block,
+	 * @return Returns the iterator to the block. If there is non, the current write block is returned
+	 */
+	typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
+		for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
+				if(it == this->end()){
+					it = this->begin();
+					if(it == currentWriteBlock){
+						break;
+					}
+				}
+				if(it->getSize()!=0){
+					return it;
+				}
+		}
+		return currentWriteBlock;
+	}
+
+	/**
+	 * Returns a copy of the oldest Index type
+	 * @return Type of Index
+	 */
+	T* getOldest(){
+		return (getNextNonEmptyBlock()->modifyIndexType());
+	}
+
+
+	/*
+	 * Writing
+	 */
+	uint32_t getAddressOfCurrentWriteBlock() const{
+		return currentWriteBlock->getBlockStartAddress();
+	}
+
+	uint32_t getSizeOfCurrentWriteBlock() const{
+		return currentWriteBlock->getSize();
+	}
+
+	uint32_t getCurrentWriteAddress() const{
+		return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
+	}
+
+	void clearCurrentWriteBlock(){
+		currentWriteBlock->setSize(0);
+		currentWriteBlock->setStoredPackets(0);
+	}
+
+	void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
+		currentWriteBlock->addSize(size);
+		currentWriteBlock->addStoredPackets(storedPackets);
+	}
+
+	T* modifyCurrentWriteBlockIndexType(){
+		return currentWriteBlock->modifyIndexType();
+	}
+
+	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
+		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
+		it->addSize(size);
+		it->addStoredPackets(storedPackets);
+	}
+
+	/**
+	 * Checks if the block has enough space for sizeToWrite
+	 * @param sizeToWrite The data to be written in the Block
+	 * @return Returns true if size to write is smaller the remaining size of the block
+	 */
+	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
+		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
+		uint32_t addressOfNextBlock = next->getBlockStartAddress();
+		uint32_t availableSize =
+				( ( addressOfNextBlock + totalSize ) -
+				(getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock()))
+				% totalSize;
+		return (sizeToWrite < availableSize);
+	}
+
+	/**
+	 * Checks if the store is full if overwrite old is false
+	 * @return Returns true if it is writeable and false if not
+	 */
+	bool isNextBlockWritable(){
+		//First check if this is the end of the list
+		typename IndexedRingMemoryArray<T>::Iterator next;
+		next = getNextWrite();
+		if((next->getSize()!=0) && (!overwriteOld)){
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Updates current write Block Index Type
+	 * @param infoOfNewBlock
+	 */
+	void updateCurrentBlock(T* infoOfNewBlock){
+		currentWriteBlock->setIndexType(infoOfNewBlock);
+	}
+
+
+	/**
+	 * Succeed to next block, returns FAILED if overwrite is false and the store is full
+	 * @return
+	 */
+	ReturnValue_t writeNext(){
+		//Check Next Block
+		if(!isNextBlockWritable()){
+			//The Index is full and does not overwrite old
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		//Next block can be written, update Metadata
+		currentWriteBlock = getNextWrite();
+		currentWriteBlock->setSize(0);
+		currentWriteBlock->setStoredPackets(0);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	/**
+	 * Serializes the Index and calculates the CRC.
+	 * Parameters according to HasSerializeIF
+	 * @param buffer
+	 * @param size
+	 * @param maxSize
+	 * @param streamEndianness
+	 * @return
+	 */
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const{
+		uint8_t* crcBuffer = *buffer;
+		uint32_t oldSize = *size;
+		if(additionalInfo!=NULL){
+			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
+		}
+		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+
+		uint32_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
+					maxSize, streamEndianness);
+			++i;
+		}
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
+		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
+		return result;
+	}
+
+
+	/**
+	 * Get the serialized Size of the index
+	 * @return The serialized size of the index
+	 */
+	size_t getSerializedSize() const {
+
+		size_t size = 0;
+		if(additionalInfo!=NULL){
+			size += additionalInfo->getSerializedSize();
+		}
+		size += currentWriteBlock->getSerializedSize();
+		size += SerializeAdapter::getSerializedSize(&this->size);
+		size += (this->entries[0].getSerializedSize()) * this->size;
+		uint16_t crc = 0;
+		size += SerializeAdapter::getSerializedSize(&crc);
+		return size;
+	}
+	/**
+	 * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
+	 * CRC Has to be checked before!
+	 * @param buffer
+	 * @param size
+	 * @param streamEndianness
+	 * @return
+	 */
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness){
+
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		if(additionalInfo!=NULL){
+			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
+		}
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+
+		Index<T> tempIndex;
+		result = tempIndex.deSerialize(buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		uint32_t tempSize = 0;
+		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		if(this->size != tempSize){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		uint32_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+			result = SerializeAdapter::deSerialize(
+					&this->entries[i], buffer, size,
+					streamEndianness);
+			++i;
+		}
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			if(*(cmp.value) == *(it.value)){
+				currentWriteBlock = it;
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+		//Reached if current write block iterator is not found
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint32_t getIndexAddress() const {
+		return indexAddress;
+	}
+
+
+	/*
+	 * Statistics
+	 */
+	uint32_t getStoredPackets() const {
+		uint32_t size = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			size += it->getStoredPackets();
+		}
+		return size;
+	}
+
+	uint32_t getTotalSize() const {
+		return totalSize;
+	}
+
+	uint32_t getCurrentSize() const{
+		uint32_t size = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			size += it->getSize();
+		}
+		return size;
+	}
+
+	bool isEmpty() const{
+		return getCurrentSize()==0;
+	}
+
+	double getPercentageFilled() const{
+		uint32_t filledSize = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			filledSize += it->getSize();
+		}
+
+		return (double)filledSize/(double)this->totalSize;
+	}
+
+	typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
+		return currentWriteBlock;
+	}
+	/**
+	 * Get the next block of the currentWriteBlock.
+	 * Returns the first one if currentWriteBlock is the last one
+	 * @return Iterator pointing to the next block after currentWriteBlock
+	 */
+	typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
+		typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
+		if((this->size != 0) && (currentWriteBlock.value == this->back())){
+			next = this->begin();
+		}else{
+			++next;
+		}
+		return next;
+	}
+	/**
+	 * Get the block in front of the Iterator
+	 * Returns the last block if it is the first block
+	 * @param it iterator which you want the previous block from
+	 * @return pointing to the block before it
+	 */
+	typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
+		if(this->begin() == it){
+			typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
+			return next;
+		}
+		typename IndexedRingMemoryArray<T>::Iterator next(it);
+		--next;
+		return next;
+	}
+private:
+	//The total size used by the blocks (without index)
+	uint32_t totalSize;
+
+	//The address of the index
+	const uint32_t indexAddress;
+
+	//The iterators for writing and reading
+	typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
+	typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
+
+	//How much of the current read block is read already
+	uint32_t currentReadSize;
+
+	//Cached Size of current read block
+	uint32_t currentReadBlockSizeCached;
+
+	//Last block of current write (should be write block)
+	typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
+	//current size of last Block to read
+	uint32_t lastBlockToReadSize;
+
+	//Additional Info to be serialized with the index
+	SerializeIF* additionalInfo;
+
+	//Does it overwrite old blocks?
+	const bool overwriteOld;
+
+};
+
+#endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */
diff --git a/container/PlacementFactory.h b/container/PlacementFactory.h
index 4a1b7df27..055384780 100644
--- a/container/PlacementFactory.h
+++ b/container/PlacementFactory.h
@@ -1,35 +1,35 @@
-#ifndef FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
-#define FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
-
-#include "../storagemanager/StorageManagerIF.h"
-#include <utility>
-
-class PlacementFactory {
-public:
-	PlacementFactory(StorageManagerIF* backend) :
-			dataBackend(backend) {
-	}
-	template<typename T, typename ... Args>
-	T* generate(Args&&... args) {
-		store_address_t tempId;
-		uint8_t* pData = NULL;
-		ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
-				&pData);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return NULL;
-		}
-		T* temp = new (pData) T(std::forward<Args>(args)...);
-		return temp;
-	}
-	template<typename T>
-	ReturnValue_t destroy(T* thisElement) {
-		//Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
-		thisElement->~T();
-		uint8_t* pointer = (uint8_t*) (thisElement);
-		return dataBackend->deleteData(pointer, sizeof(T));
-	}
-private:
-	StorageManagerIF* dataBackend;
-};
-
-#endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */
+#ifndef FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
+#define FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
+
+#include "../storagemanager/StorageManagerIF.h"
+#include <utility>
+
+class PlacementFactory {
+public:
+	PlacementFactory(StorageManagerIF* backend) :
+			dataBackend(backend) {
+	}
+	template<typename T, typename ... Args>
+	T* generate(Args&&... args) {
+		store_address_t tempId;
+		uint8_t* pData = NULL;
+		ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
+				&pData);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return NULL;
+		}
+		T* temp = new (pData) T(std::forward<Args>(args)...);
+		return temp;
+	}
+	template<typename T>
+	ReturnValue_t destroy(T* thisElement) {
+		//Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
+		thisElement->~T();
+		uint8_t* pointer = (uint8_t*) (thisElement);
+		return dataBackend->deleteData(pointer, sizeof(T));
+	}
+private:
+	StorageManagerIF* dataBackend;
+};
+
+#endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */
diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 0e784631c..243a2915e 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -1,113 +1,113 @@
-#ifndef FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
-#define FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
-
-template<uint8_t N_READ_PTRS = 1>
-class RingBufferBase {
-public:
-	RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
-			start(startAddress), write(startAddress), size(size),
-			overwriteOld(overwriteOld) {
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = startAddress;
-		}
-	}
-
-	virtual ~RingBufferBase() {}
-
-	bool isFull(uint8_t n = 0) {
-		return (availableWriteSpace(n) == 0);
-	}
-	bool isEmpty(uint8_t n = 0) {
-		return (getAvailableReadData(n) == 0);
-	}
-
-	size_t getAvailableReadData(uint8_t n = 0) const {
-		return ((write + size) - read[n]) % size;
-	}
-	size_t availableWriteSpace(uint8_t n = 0) const  {
-		//One less to avoid ambiguous full/empty problem.
-		return (((read[n] + size) - write - 1) % size);
-	}
-
-	bool overwritesOld() const {
-		return overwriteOld;
-	}
-
-	size_t getMaxSize() const {
-		return size - 1;
-	}
-
-	void clear() {
-		write = start;
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = start;
-		}
-	}
-
-	size_t writeTillWrap() {
-		return (start + size) - write;
-	}
-
-	size_t readTillWrap(uint8_t n = 0) {
-		return (start + size) - read[n];
-	}
-
-	size_t getStart() const {
-		return start;
-	}
-
-protected:
-	const size_t start;
-	size_t write;
-	size_t read[N_READ_PTRS];
-	const size_t size;
-	const bool overwriteOld;
-	void incrementWrite(uint32_t amount) {
-		write = ((write + amount - start) % size) + start;
-	}
-	void incrementRead(uint32_t amount, uint8_t n = 0) {
-		read[n] = ((read[n] + amount - start) % size) + start;
-	}
-
-	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
-		if (getAvailableReadData(n) >= amount) {
-			incrementRead(amount, n);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-
-	ReturnValue_t writeData(uint32_t amount) {
-		if (availableWriteSpace() >= amount or overwriteOld) {
-			incrementWrite(amount);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-
-
-	size_t getRead(uint8_t n = 0) const {
-		return read[n];
-	}
-
-	void setRead(uint32_t read, uint8_t n = 0) {
-		if (read >= start && read < (start+size)) {
-			this->read[n] = read;
-		}
-	}
-
-	uint32_t getWrite() const {
-		return write;
-	}
-
-	void setWrite(uint32_t write) {
-		this->write = write;
-	}
-};
-
-#endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
+#ifndef FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
+#define FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+template<uint8_t N_READ_PTRS = 1>
+class RingBufferBase {
+public:
+	RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
+			start(startAddress), write(startAddress), size(size),
+			overwriteOld(overwriteOld) {
+		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+			read[count] = startAddress;
+		}
+	}
+
+	virtual ~RingBufferBase() {}
+
+	bool isFull(uint8_t n = 0) {
+		return (availableWriteSpace(n) == 0);
+	}
+	bool isEmpty(uint8_t n = 0) {
+		return (getAvailableReadData(n) == 0);
+	}
+
+	size_t getAvailableReadData(uint8_t n = 0) const {
+		return ((write + size) - read[n]) % size;
+	}
+	size_t availableWriteSpace(uint8_t n = 0) const  {
+		//One less to avoid ambiguous full/empty problem.
+		return (((read[n] + size) - write - 1) % size);
+	}
+
+	bool overwritesOld() const {
+		return overwriteOld;
+	}
+
+	size_t getMaxSize() const {
+		return size - 1;
+	}
+
+	void clear() {
+		write = start;
+		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+			read[count] = start;
+		}
+	}
+
+	size_t writeTillWrap() {
+		return (start + size) - write;
+	}
+
+	size_t readTillWrap(uint8_t n = 0) {
+		return (start + size) - read[n];
+	}
+
+	size_t getStart() const {
+		return start;
+	}
+
+protected:
+	const size_t start;
+	size_t write;
+	size_t read[N_READ_PTRS];
+	const size_t size;
+	const bool overwriteOld;
+	void incrementWrite(uint32_t amount) {
+		write = ((write + amount - start) % size) + start;
+	}
+	void incrementRead(uint32_t amount, uint8_t n = 0) {
+		read[n] = ((read[n] + amount - start) % size) + start;
+	}
+
+	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
+		if (getAvailableReadData(n) >= amount) {
+			incrementRead(amount, n);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+
+	ReturnValue_t writeData(uint32_t amount) {
+		if (availableWriteSpace() >= amount or overwriteOld) {
+			incrementWrite(amount);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+
+
+	size_t getRead(uint8_t n = 0) const {
+		return read[n];
+	}
+
+	void setRead(uint32_t read, uint8_t n = 0) {
+		if (read >= start && read < (start+size)) {
+			this->read[n] = read;
+		}
+	}
+
+	uint32_t getWrite() const {
+		return write;
+	}
+
+	void setWrite(uint32_t write) {
+		this->write = write;
+	}
+};
+
+#endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index c41e8d30d..490988e55 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -1,30 +1,30 @@
-#include "../container/SharedRingBuffer.h"
-#include "../ipc/MutexFactory.h"
-#include "../ipc/MutexHelper.h"
-
-SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
-		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
-		const size_t size, bool overwriteOld, size_t maxExcessBytes):
-		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
-        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
-    return mutex->lockMutex(timeoutType, timeout);
-}
-
-ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
-    return mutex->unlockMutex();
-}
-
-MutexIF* SharedRingBuffer::getMutexHandle() const {
-    return mutex;
-}
+#include "../container/SharedRingBuffer.h"
+#include "../ipc/MutexFactory.h"
+#include "../ipc/MutexHelper.h"
+
+SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
+		bool overwriteOld, size_t maxExcessBytes):
+		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
+		maxExcessBytes) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
+		const size_t size, bool overwriteOld, size_t maxExcessBytes):
+		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
+		maxExcessBytes) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
+        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
+    return mutex->lockMutex(timeoutType, timeout);
+}
+
+ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
+    return mutex->unlockMutex();
+}
+
+MutexIF* SharedRingBuffer::getMutexHandle() const {
+    return mutex;
+}
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index c6d958cc2..394dcaaa5 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -1,68 +1,68 @@
-#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
-
-#include "../container/SimpleRingBuffer.h"
-#include "../ipc/MutexIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../timemanager/Clock.h"
-
-/**
- * @brief   Ring buffer which can be shared among multiple objects
- * @details
- * This class offers a mutex to perform thread-safe operation on the ring
- * buffer. It is still up to the developer to actually perform the lock
- * and unlock operations.
- */
-class SharedRingBuffer: public SystemObject,
-		public SimpleRingBuffer {
-public:
-	/**
-	 * This constructor allocates a new internal buffer with the supplied size.
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes);
-
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes);
-
-	/**
-	 * Unless a read-only constant value is read, all operations on the
-	 * shared ring buffer should be protected by calling this function.
-	 * @param timeoutType
-	 * @param timeout
-	 * @return
-	 */
-	virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
-	        dur_millis_t timeout);
-	/**
-	 * Any locked mutex also has to be unlocked, otherwise, access to the
-	 * shared ring buffer will be blocked.
-	 * @return
-	 */
-	virtual ReturnValue_t unlockRingBufferMutex();
-
-	/**
-	 * The mutex handle can be accessed directly, for example to perform
-	 * the lock with the #MutexHelper for a RAII compliant lock operation.
-	 * @return
-	 */
-	MutexIF* getMutexHandle() const;
-private:
-	MutexIF* mutex = nullptr;
-};
-
-
-
-#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
+#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+
+#include "../container/SimpleRingBuffer.h"
+#include "../ipc/MutexIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../timemanager/Clock.h"
+
+/**
+ * @brief   Ring buffer which can be shared among multiple objects
+ * @details
+ * This class offers a mutex to perform thread-safe operation on the ring
+ * buffer. It is still up to the developer to actually perform the lock
+ * and unlock operations.
+ */
+class SharedRingBuffer: public SystemObject,
+		public SimpleRingBuffer {
+public:
+	/**
+	 * This constructor allocates a new internal buffer with the supplied size.
+	 * @param size
+	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+	 * will be overwritten.
+	 */
+	SharedRingBuffer(object_id_t objectId, const size_t size,
+			bool overwriteOld, size_t maxExcessBytes);
+
+	/**
+	 * This constructor takes an external buffer with the specified size.
+	 * @param buffer
+	 * @param size
+	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+	 * will be overwritten.
+	 */
+	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
+			bool overwriteOld, size_t maxExcessBytes);
+
+	/**
+	 * Unless a read-only constant value is read, all operations on the
+	 * shared ring buffer should be protected by calling this function.
+	 * @param timeoutType
+	 * @param timeout
+	 * @return
+	 */
+	virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
+	        dur_millis_t timeout);
+	/**
+	 * Any locked mutex also has to be unlocked, otherwise, access to the
+	 * shared ring buffer will be blocked.
+	 * @return
+	 */
+	virtual ReturnValue_t unlockRingBufferMutex();
+
+	/**
+	 * The mutex handle can be accessed directly, for example to perform
+	 * the lock with the #MutexHelper for a RAII compliant lock operation.
+	 * @return
+	 */
+	MutexIF* getMutexHandle() const;
+private:
+	MutexIF* mutex = nullptr;
+};
+
+
+
+#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 7ed019b25..d6b6f5aff 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -1,135 +1,135 @@
-#include "../container/SimpleRingBuffer.h"
-#include <cstring>
-
-SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
-		size_t maxExcessBytes) :
-		RingBufferBase<>(0, size, overwriteOld),
-		maxExcessBytes(maxExcessBytes) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
-	buffer = new uint8_t[size + maxExcessBytes];
-}
-
-SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
-        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
-}
-
-
-SimpleRingBuffer::~SimpleRingBuffer() {
-	delete[] buffer;
-}
-
-
-ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
-        size_t amount) {
-    if (availableWriteSpace() >= amount or overwriteOld) {
-        size_t amountTillWrap = writeTillWrap();
-        if (amountTillWrap < amount) {
-            if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
-                return HasReturnvaluesIF::RETURN_FAILED;
-            }
-            excessBytes = amount - amountTillWrap;
-        }
-        *writePointer = &buffer[write];
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-}
-
-void SimpleRingBuffer::confirmBytesWritten(size_t amount) {
-	if(getExcessBytes() > 0) {
-		moveExcessBytesToStart();
-	}
-	incrementWrite(amount);
-
-}
-
-ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
-		size_t amount) {
-	if (availableWriteSpace() >= amount or overwriteOld) {
-		size_t amountTillWrap = writeTillWrap();
-		if (amountTillWrap >= amount) {
-			// remaining size in buffer is sufficient to fit full amount.
-			memcpy(&buffer[write], data, amount);
-		}
-		else {
-			memcpy(&buffer[write], data, amountTillWrap);
-			memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
-		}
-		incrementWrite(amount);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
-		bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
-	size_t availableData = getAvailableReadData(READ_PTR);
-	size_t amountTillWrap = readTillWrap(READ_PTR);
-	if (availableData < amount) {
-		if (readRemaining) {
-			// more data available than amount specified.
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	if (amountTillWrap >= amount) {
-		memcpy(data, &buffer[read[READ_PTR]], amount);
-	} else {
-		memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
-		memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
-	}
-
-	if(incrementReadPtr) {
-		deleteData(amount, readRemaining);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-size_t SimpleRingBuffer::getExcessBytes() const {
-    return excessBytes;
-}
-
-void SimpleRingBuffer::moveExcessBytesToStart() {
-    if(excessBytes > 0) {
-        std::memcpy(buffer, &buffer[size], excessBytes);
-        excessBytes = 0;
-    }
-}
-
-ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
-		bool deleteRemaining, size_t* trueAmount) {
-	size_t availableData = getAvailableReadData(READ_PTR);
-	if (availableData < amount) {
-		if (deleteRemaining) {
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	incrementRead(amount, READ_PTR);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
+#include "../container/SimpleRingBuffer.h"
+#include <cstring>
+
+SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
+		size_t maxExcessBytes) :
+		RingBufferBase<>(0, size, overwriteOld),
+		maxExcessBytes(maxExcessBytes) {
+	if(maxExcessBytes > size) {
+		this->maxExcessBytes = size;
+	}
+	else {
+		this->maxExcessBytes = maxExcessBytes;
+	}
+	buffer = new uint8_t[size + maxExcessBytes];
+}
+
+SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
+		bool overwriteOld, size_t maxExcessBytes):
+        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
+	if(maxExcessBytes > size) {
+		this->maxExcessBytes = size;
+	}
+	else {
+		this->maxExcessBytes = maxExcessBytes;
+	}
+}
+
+
+SimpleRingBuffer::~SimpleRingBuffer() {
+	delete[] buffer;
+}
+
+
+ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
+        size_t amount) {
+    if (availableWriteSpace() >= amount or overwriteOld) {
+        size_t amountTillWrap = writeTillWrap();
+        if (amountTillWrap < amount) {
+            if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
+                return HasReturnvaluesIF::RETURN_FAILED;
+            }
+            excessBytes = amount - amountTillWrap;
+        }
+        *writePointer = &buffer[write];
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+}
+
+void SimpleRingBuffer::confirmBytesWritten(size_t amount) {
+	if(getExcessBytes() > 0) {
+		moveExcessBytesToStart();
+	}
+	incrementWrite(amount);
+
+}
+
+ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
+		size_t amount) {
+	if (availableWriteSpace() >= amount or overwriteOld) {
+		size_t amountTillWrap = writeTillWrap();
+		if (amountTillWrap >= amount) {
+			// remaining size in buffer is sufficient to fit full amount.
+			memcpy(&buffer[write], data, amount);
+		}
+		else {
+			memcpy(&buffer[write], data, amountTillWrap);
+			memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
+		}
+		incrementWrite(amount);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
+		bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
+	size_t availableData = getAvailableReadData(READ_PTR);
+	size_t amountTillWrap = readTillWrap(READ_PTR);
+	if (availableData < amount) {
+		if (readRemaining) {
+			// more data available than amount specified.
+			amount = availableData;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	if (trueAmount != nullptr) {
+		*trueAmount = amount;
+	}
+	if (amountTillWrap >= amount) {
+		memcpy(data, &buffer[read[READ_PTR]], amount);
+	} else {
+		memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
+		memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
+	}
+
+	if(incrementReadPtr) {
+		deleteData(amount, readRemaining);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+size_t SimpleRingBuffer::getExcessBytes() const {
+    return excessBytes;
+}
+
+void SimpleRingBuffer::moveExcessBytesToStart() {
+    if(excessBytes > 0) {
+        std::memcpy(buffer, &buffer[size], excessBytes);
+        excessBytes = 0;
+    }
+}
+
+ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
+		bool deleteRemaining, size_t* trueAmount) {
+	size_t availableData = getAvailableReadData(READ_PTR);
+	if (availableData < amount) {
+		if (deleteRemaining) {
+			amount = availableData;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	if (trueAmount != nullptr) {
+		*trueAmount = amount;
+	}
+	incrementRead(amount, READ_PTR);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index b13e9f2aa..dcf2684bd 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -1,128 +1,128 @@
-#ifndef FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
-
-#include "../container/RingBufferBase.h"
-#include <cstddef>
-
-/**
- * @brief 	Circular buffer implementation, useful for buffering
- *          into data streams.
- * @details
- * Note that the deleteData() has to be called to increment the read pointer.
- * This class allocated dynamically, so
- * @ingroup containers
- */
-class SimpleRingBuffer: public RingBufferBase<> {
-public:
-    /**
-     * This constructor allocates a new internal buffer with the supplied size.
-     *
-     * @param size
-     * @param overwriteOld If the ring buffer is overflowing at a write
-     * operation, the oldest data will be overwritten.
-     * @param maxExcessBytes These additional bytes will be allocated in addtion
-     * to the specified size to accomodate contiguous write operations
-     * with getFreeElement.
-     *
-     */
-	SimpleRingBuffer(const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-     * will be overwritten.
-	 * @param maxExcessBytes
-	 * If the buffer can accomodate additional bytes for contigous write
-	 * operations with getFreeElement, this is the maximum allowed additional
-	 * size
-	 */
-	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
-
-	virtual ~SimpleRingBuffer();
-
-	/**
-	 * Write to circular buffer and increment write pointer by amount.
-	 * @param data
-	 * @param amount
-	 * @return -@c RETURN_OK if write operation was successfull
-	 * -@c RETURN_FAILED if
-	 */
-	ReturnValue_t writeData(const uint8_t* data, size_t amount);
-
-	/**
-	 * Returns a pointer to a free element. If the remaining buffer is
-	 * not large enough, the data will be written past the actual size
-	 * and the amount of excess bytes will be cached. This function
-	 * does not increment the write pointer!
-	 * @param writePointer Pointer to a pointer which can be used to write
-	 * contiguous blocks into the ring buffer
-	 * @param amount
-	 * @return
-	 */
-	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
-
-	/**
-	 * This increments the write pointer and also copies the excess bytes
-	 * to the beginning. It should be called if the write operation
-	 * conducted after calling getFreeElement() was performed.
-	 * @return
-	 */
-	void confirmBytesWritten(size_t amount);
-
-	virtual size_t getExcessBytes() const;
-	/**
-	 * Helper functions which moves any excess bytes to the start
-	 * of the ring buffer.
-	 * @return
-	 */
-	virtual void moveExcessBytesToStart();
-
-	/**
-	 * Read from circular buffer at read pointer.
-	 * @param data
-	 * @param amount
-	 * @param incrementReadPtr
-	 * If this is set to true, the read pointer will be incremented.
-	 * If readRemaining is set to true, the read pointer will be incremented
-	 * accordingly.
-	 * @param readRemaining
-	 * If this is set to true, the data will be read even if the amount
-	 * specified exceeds the read data available.
-	 * @param trueAmount [out]
-	 * If readRemaining was set to true, the true amount read will be assigned
-	 * to the passed value.
-	 * @return
-	 * - @c RETURN_OK if data was read successfully
-	 * - @c RETURN_FAILED if not enough data was available and readRemaining
-	 *      was set to false.
-	 */
-	ReturnValue_t readData(uint8_t* data, size_t amount,
-			bool incrementReadPtr = false, bool readRemaining = false,
-			size_t* trueAmount = nullptr);
-
-	/**
-	 * Delete data by incrementing read pointer.
-	 * @param amount
-	 * @param deleteRemaining
-	 * If the amount specified is larger than the remaing size to read and this
-	 * is set to true, the remaining amount will be deleted as well
-	 * @param trueAmount [out]
-	 * If deleteRemaining was set to true, the amount deleted will be assigned
-	 * to the passed value.
-	 * @return
-	 */
-	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
-	        size_t* trueAmount = nullptr);
-private:
-	static const uint8_t READ_PTR = 0;
-	uint8_t* buffer = nullptr;
-	size_t maxExcessBytes;
-	size_t excessBytes = 0;
-};
-
-#endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */
-
+#ifndef FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
+#define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
+
+#include "../container/RingBufferBase.h"
+#include <cstddef>
+
+/**
+ * @brief 	Circular buffer implementation, useful for buffering
+ *          into data streams.
+ * @details
+ * Note that the deleteData() has to be called to increment the read pointer.
+ * This class allocated dynamically, so
+ * @ingroup containers
+ */
+class SimpleRingBuffer: public RingBufferBase<> {
+public:
+    /**
+     * This constructor allocates a new internal buffer with the supplied size.
+     *
+     * @param size
+     * @param overwriteOld If the ring buffer is overflowing at a write
+     * operation, the oldest data will be overwritten.
+     * @param maxExcessBytes These additional bytes will be allocated in addtion
+     * to the specified size to accomodate contiguous write operations
+     * with getFreeElement.
+     *
+     */
+	SimpleRingBuffer(const size_t size, bool overwriteOld,
+	        size_t maxExcessBytes = 0);
+	/**
+	 * This constructor takes an external buffer with the specified size.
+	 * @param buffer
+	 * @param size
+	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+	 * @param maxExcessBytes
+	 * If the buffer can accomodate additional bytes for contigous write
+	 * operations with getFreeElement, this is the maximum allowed additional
+	 * size
+	 */
+	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
+	        size_t maxExcessBytes = 0);
+
+	virtual ~SimpleRingBuffer();
+
+	/**
+	 * Write to circular buffer and increment write pointer by amount.
+	 * @param data
+	 * @param amount
+	 * @return -@c RETURN_OK if write operation was successfull
+	 * -@c RETURN_FAILED if
+	 */
+	ReturnValue_t writeData(const uint8_t* data, size_t amount);
+
+	/**
+	 * Returns a pointer to a free element. If the remaining buffer is
+	 * not large enough, the data will be written past the actual size
+	 * and the amount of excess bytes will be cached. This function
+	 * does not increment the write pointer!
+	 * @param writePointer Pointer to a pointer which can be used to write
+	 * contiguous blocks into the ring buffer
+	 * @param amount
+	 * @return
+	 */
+	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
+
+	/**
+	 * This increments the write pointer and also copies the excess bytes
+	 * to the beginning. It should be called if the write operation
+	 * conducted after calling getFreeElement() was performed.
+	 * @return
+	 */
+	void confirmBytesWritten(size_t amount);
+
+	virtual size_t getExcessBytes() const;
+	/**
+	 * Helper functions which moves any excess bytes to the start
+	 * of the ring buffer.
+	 * @return
+	 */
+	virtual void moveExcessBytesToStart();
+
+	/**
+	 * Read from circular buffer at read pointer.
+	 * @param data
+	 * @param amount
+	 * @param incrementReadPtr
+	 * If this is set to true, the read pointer will be incremented.
+	 * If readRemaining is set to true, the read pointer will be incremented
+	 * accordingly.
+	 * @param readRemaining
+	 * If this is set to true, the data will be read even if the amount
+	 * specified exceeds the read data available.
+	 * @param trueAmount [out]
+	 * If readRemaining was set to true, the true amount read will be assigned
+	 * to the passed value.
+	 * @return
+	 * - @c RETURN_OK if data was read successfully
+	 * - @c RETURN_FAILED if not enough data was available and readRemaining
+	 *      was set to false.
+	 */
+	ReturnValue_t readData(uint8_t* data, size_t amount,
+			bool incrementReadPtr = false, bool readRemaining = false,
+			size_t* trueAmount = nullptr);
+
+	/**
+	 * Delete data by incrementing read pointer.
+	 * @param amount
+	 * @param deleteRemaining
+	 * If the amount specified is larger than the remaing size to read and this
+	 * is set to true, the remaining amount will be deleted as well
+	 * @param trueAmount [out]
+	 * If deleteRemaining was set to true, the amount deleted will be assigned
+	 * to the passed value.
+	 * @return
+	 */
+	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
+	        size_t* trueAmount = nullptr);
+private:
+	static const uint8_t READ_PTR = 0;
+	uint8_t* buffer = nullptr;
+	size_t maxExcessBytes;
+	size_t excessBytes = 0;
+};
+
+#endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */
+
diff --git a/contrib/sgp4/sgp4unit.cpp b/contrib/sgp4/sgp4unit.cpp
index 24d63aa93..b707a7a2d 100644
--- a/contrib/sgp4/sgp4unit.cpp
+++ b/contrib/sgp4/sgp4unit.cpp
@@ -1,2090 +1,2090 @@
-/*     ----------------------------------------------------------------
-*
-*                               sgp4unit.cpp
-*
-*    this file contains the sgp4 procedures for analytical propagation
-*    of a satellite. the code was originally released in the 1980 and 1986
-*    spacetrack papers. a detailed discussion of the theory and history
-*    may be found in the 2006 aiaa paper by vallado, crawford, hujsak,
-*    and kelso.
-*
-*                            companion code for
-*               fundamentals of astrodynamics and applications
-*                                    2007
-*                              by david vallado
-*
-*       (w) 719-573-2600, email dvallado@agi.com
-*
-*    current :
-*              16 nov 07  david vallado
-*                           misc fixes for better compliance
-*    changes :
-*              20 apr 07  david vallado
-*                           misc fixes for constants
-*              11 aug 06  david vallado
-*                           chg lyddane choice back to strn3, constants, misc doc
-*              15 dec 05  david vallado
-*                           misc fixes
-*              26 jul 05  david vallado
-*                           fixes for paper
-*                           note that each fix is preceded by a
-*                           comment with "sgp4fix" and an explanation of
-*                           what was changed
-*              10 aug 04  david vallado
-*                           2nd printing baseline working
-*              14 may 01  david vallado
-*                           2nd edition baseline
-*                     80  norad
-*                           original baseline
-*       ----------------------------------------------------------------      */
-
-#include "sgp4unit.h"
-
-const char help = 'n';
-FILE *dbgfile;
-
-#define pi 3.14159265358979323846
-
-
-/* ----------- local functions - only ever used internally by sgp4 ---------- */
-static void dpper
-     (
-       double e3,     double ee2,    double peo,     double pgho,   double pho,
-       double pinco,  double plo,    double se2,     double se3,    double sgh2,
-       double sgh3,   double sgh4,   double sh2,     double sh3,    double si2,
-       double si3,    double sl2,    double sl3,     double sl4,    double t,
-       double xgh2,   double xgh3,   double xgh4,    double xh2,    double xh3,
-       double xi2,    double xi3,    double xl2,     double xl3,    double xl4,
-       double zmol,   double zmos,   double inclo,
-       char init,
-       double& ep,    double& inclp, double& nodep,  double& argpp, double& mp
-     );
-
-static void dscom
-     (
-       double epoch,  double ep,     double argpp,   double tc,     double inclp,
-       double nodep,  double np,
-       double& snodm, double& cnodm, double& sinim,  double& cosim, double& sinomm,
-       double& cosomm,double& day,   double& e3,     double& ee2,   double& em,
-       double& emsq,  double& gam,   double& peo,    double& pgho,  double& pho,
-       double& pinco, double& plo,   double& rtemsq, double& se2,   double& se3,
-       double& sgh2,  double& sgh3,  double& sgh4,   double& sh2,   double& sh3,
-       double& si2,   double& si3,   double& sl2,    double& sl3,   double& sl4,
-       double& s1,    double& s2,    double& s3,     double& s4,    double& s5,
-       double& s6,    double& s7,    double& ss1,    double& ss2,   double& ss3,
-       double& ss4,   double& ss5,   double& ss6,    double& ss7,   double& sz1,
-       double& sz2,   double& sz3,   double& sz11,   double& sz12,  double& sz13,
-       double& sz21,  double& sz22,  double& sz23,   double& sz31,  double& sz32,
-       double& sz33,  double& xgh2,  double& xgh3,   double& xgh4,  double& xh2,
-       double& xh3,   double& xi2,   double& xi3,    double& xl2,   double& xl3,
-       double& xl4,   double& nm,    double& z1,     double& z2,    double& z3,
-       double& z11,   double& z12,   double& z13,    double& z21,   double& z22,
-       double& z23,   double& z31,   double& z32,    double& z33,   double& zmol,
-       double& zmos
-     );
-
-static void dsinit
-     (
-       gravconsttype whichconst,
-       double cosim,  double emsq,   double argpo,   double s1,     double s2,
-       double s3,     double s4,     double s5,      double sinim,  double ss1,
-       double ss2,    double ss3,    double ss4,     double ss5,    double sz1,
-       double sz3,    double sz11,   double sz13,    double sz21,   double sz23,
-       double sz31,   double sz33,   double t,       double tc,     double gsto,
-       double mo,     double mdot,   double no,      double nodeo,  double nodedot,
-       double xpidot, double z1,     double z3,      double z11,    double z13,
-       double z21,    double z23,    double z31,     double z33,    double ecco,
-       double eccsq,  double& em,    double& argpm,  double& inclm, double& mm,
-       double& nm,    double& nodem,
-       int& irez,
-       double& atime, double& d2201, double& d2211,  double& d3210, double& d3222,
-       double& d4410, double& d4422, double& d5220,  double& d5232, double& d5421,
-       double& d5433, double& dedt,  double& didt,   double& dmdt,  double& dndt,
-       double& dnodt, double& domdt, double& del1,   double& del2,  double& del3,
-       double& xfact, double& xlamo, double& xli,    double& xni
-     );
-
-static void dspace
-     (
-       int irez,
-       double d2201,  double d2211,  double d3210,   double d3222,  double d4410,
-       double d4422,  double d5220,  double d5232,   double d5421,  double d5433,
-       double dedt,   double del1,   double del2,    double del3,   double didt,
-       double dmdt,   double dnodt,  double domdt,   double argpo,  double argpdot,
-       double t,      double tc,     double gsto,    double xfact,  double xlamo,
-       double no,
-       double& atime, double& em,    double& argpm,  double& inclm, double& xli,
-       double& mm,    double& xni,   double& nodem,  double& dndt,  double& nm
-     );
-
-static void initl
-     (
-       int satn,      gravconsttype whichconst,
-       double ecco,   double epoch,  double inclo,   double& no,
-       char& method,
-       double& ainv,  double& ao,    double& con41,  double& con42, double& cosio,
-       double& cosio2,double& eccsq, double& omeosq, double& posq,
-       double& rp,    double& rteosq,double& sinio , double& gsto
-     );
-
-/* -----------------------------------------------------------------------------
-*
-*                           procedure dpper
-*
-*  this procedure provides deep space long period periodic contributions
-*    to the mean elements.  by design, these periodics are zero at epoch.
-*    this used to be dscom which included initialization, but it's really a
-*    recurring function.
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    e3          -
-*    ee2         -
-*    peo         -
-*    pgho        -
-*    pho         -
-*    pinco       -
-*    plo         -
-*    se2 , se3 , sgh2, sgh3, sgh4, sh2, sh3, si2, si3, sl2, sl3, sl4 -
-*    t           -
-*    xh2, xh3, xi2, xi3, xl2, xl3, xl4 -
-*    zmol        -
-*    zmos        -
-*    ep          - eccentricity                           0.0 - 1.0
-*    inclo       - inclination - needed for lyddane modification
-*    nodep       - right ascension of ascending node
-*    argpp       - argument of perigee
-*    mp          - mean anomaly
-*
-*  outputs       :
-*    ep          - eccentricity                           0.0 - 1.0
-*    inclp       - inclination
-*    nodep        - right ascension of ascending node
-*    argpp       - argument of perigee
-*    mp          - mean anomaly
-*
-*  locals        :
-*    alfdp       -
-*    betdp       -
-*    cosip  , sinip  , cosop  , sinop  ,
-*    dalf        -
-*    dbet        -
-*    dls         -
-*    f2, f3      -
-*    pe          -
-*    pgh         -
-*    ph          -
-*    pinc        -
-*    pl          -
-*    sel   , ses   , sghl  , sghs  , shl   , shs   , sil   , sinzf , sis   ,
-*    sll   , sls
-*    xls         -
-*    xnoh        -
-*    zf          -
-*    zm          -
-*
-*  coupling      :
-*    none.
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-static void dpper
-     (
-       double e3,     double ee2,    double peo,     double pgho,   double pho,
-       double pinco,  double plo,    double se2,     double se3,    double sgh2,
-       double sgh3,   double sgh4,   double sh2,     double sh3,    double si2,
-       double si3,    double sl2,    double sl3,     double sl4,    double t,
-       double xgh2,   double xgh3,   double xgh4,    double xh2,    double xh3,
-       double xi2,    double xi3,    double xl2,     double xl3,    double xl4,
-       double zmol,   double zmos,   double inclo,
-       char init,
-       double& ep,    double& inclp, double& nodep,  double& argpp, double& mp
-     )
-{
-     /* --------------------- local variables ------------------------ */
-     const double twopi = 2.0 * pi;
-     double alfdp, betdp, cosip, cosop, dalf, dbet, dls,
-          f2,    f3,    pe,    pgh,   ph,   pinc, pl ,
-          sel,   ses,   sghl,  sghs,  shll, shs,  sil,
-          sinip, sinop, sinzf, sis,   sll,  sls,  xls,
-          xnoh,  zf,    zm,    zel,   zes,  znl,  zns;
-
-     /* ---------------------- constants ----------------------------- */
-     zns   = 1.19459e-5;
-     zes   = 0.01675;
-     znl   = 1.5835218e-4;
-     zel   = 0.05490;
-
-     /* --------------- calculate time varying periodics ----------- */
-     zm    = zmos + zns * t;
-     // be sure that the initial call has time set to zero
-     if (init == 'y')
-         zm = zmos;
-     zf    = zm + 2.0 * zes * sin(zm);
-     sinzf = sin(zf);
-     f2    =  0.5 * sinzf * sinzf - 0.25;
-     f3    = -0.5 * sinzf * cos(zf);
-     ses   = se2* f2 + se3 * f3;
-     sis   = si2 * f2 + si3 * f3;
-     sls   = sl2 * f2 + sl3 * f3 + sl4 * sinzf;
-     sghs  = sgh2 * f2 + sgh3 * f3 + sgh4 * sinzf;
-     shs   = sh2 * f2 + sh3 * f3;
-     zm    = zmol + znl * t;
-     if (init == 'y')
-         zm = zmol;
-     zf    = zm + 2.0 * zel * sin(zm);
-     sinzf = sin(zf);
-     f2    =  0.5 * sinzf * sinzf - 0.25;
-     f3    = -0.5 * sinzf * cos(zf);
-     sel   = ee2 * f2 + e3 * f3;
-     sil   = xi2 * f2 + xi3 * f3;
-     sll   = xl2 * f2 + xl3 * f3 + xl4 * sinzf;
-     sghl  = xgh2 * f2 + xgh3 * f3 + xgh4 * sinzf;
-     shll  = xh2 * f2 + xh3 * f3;
-     pe    = ses + sel;
-     pinc  = sis + sil;
-     pl    = sls + sll;
-     pgh   = sghs + sghl;
-     ph    = shs + shll;
-
-     if (init == 'n')
-       {
-       pe    = pe - peo;
-       pinc  = pinc - pinco;
-       pl    = pl - plo;
-       pgh   = pgh - pgho;
-       ph    = ph - pho;
-       inclp = inclp + pinc;
-       ep    = ep + pe;
-       sinip = sin(inclp);
-       cosip = cos(inclp);
-
-       /* ----------------- apply periodics directly ------------ */
-       //  sgp4fix for lyddane choice
-       //  strn3 used original inclination - this is technically feasible
-       //  gsfc used perturbed inclination - also technically feasible
-       //  probably best to readjust the 0.2 limit value and limit discontinuity
-       //  0.2 rad = 11.45916 deg
-       //  use next line for original strn3 approach and original inclination
-       //  if (inclo >= 0.2)
-       //  use next line for gsfc version and perturbed inclination
-       if (inclp >= 0.2)
-         {
-           ph     = ph / sinip;
-           pgh    = pgh - cosip * ph;
-           argpp  = argpp + pgh;
-           nodep  = nodep + ph;
-           mp     = mp + pl;
-         }
-         else
-         {
-           /* ---- apply periodics with lyddane modification ---- */
-           sinop  = sin(nodep);
-           cosop  = cos(nodep);
-           alfdp  = sinip * sinop;
-           betdp  = sinip * cosop;
-           dalf   =  ph * cosop + pinc * cosip * sinop;
-           dbet   = -ph * sinop + pinc * cosip * cosop;
-           alfdp  = alfdp + dalf;
-           betdp  = betdp + dbet;
-           nodep  = fmod(nodep, twopi);
-           //  sgp4fix for afspc written intrinsic functions
-           // nodep used without a trigonometric function ahead
-           if (nodep < 0.0)
-               nodep = nodep + twopi;
-           xls    = mp + argpp + cosip * nodep;
-           dls    = pl + pgh - pinc * nodep * sinip;
-           xls    = xls + dls;
-           xnoh   = nodep;
-           nodep  = atan2(alfdp, betdp);
-           //  sgp4fix for afspc written intrinsic functions
-           // nodep used without a trigonometric function ahead
-           if (nodep < 0.0)
-               nodep = nodep + twopi;
-           if (fabs(xnoh - nodep) > pi){
-             if (nodep < xnoh)
-                nodep = nodep + twopi;
-               else
-                nodep = nodep - twopi;
-           }
-           mp    = mp + pl;
-           argpp = xls - mp - cosip * nodep;
-         }
-       }   // if init == 'n'
-
-//#include "debug1.cpp"
-}  // end dpper
-
-/*-----------------------------------------------------------------------------
-*
-*                           procedure dscom
-*
-*  this procedure provides deep space common items used by both the secular
-*    and periodics subroutines.  input is provided as shown. this routine
-*    used to be called dpper, but the functions inside weren't well organized.
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    epoch       -
-*    ep          - eccentricity
-*    argpp       - argument of perigee
-*    tc          -
-*    inclp       - inclination
-*    nodep       - right ascension of ascending node
-*    np          - mean motion
-*
-*  outputs       :
-*    sinim  , cosim  , sinomm , cosomm , snodm  , cnodm
-*    day         -
-*    e3          -
-*    ee2         -
-*    em          - eccentricity
-*    emsq        - eccentricity squared
-*    gam         -
-*    peo         -
-*    pgho        -
-*    pho         -
-*    pinco       -
-*    plo         -
-*    rtemsq      -
-*    se2, se3         -
-*    sgh2, sgh3, sgh4        -
-*    sh2, sh3, si2, si3, sl2, sl3, sl4         -
-*    s1, s2, s3, s4, s5, s6, s7          -
-*    ss1, ss2, ss3, ss4, ss5, ss6, ss7, sz1, sz2, sz3         -
-*    sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33        -
-*    xgh2, xgh3, xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4         -
-*    nm          - mean motion
-*    z1, z2, z3, z11, z12, z13, z21, z22, z23, z31, z32, z33         -
-*    zmol        -
-*    zmos        -
-*
-*  locals        :
-*    a1, a2, a3, a4, a5, a6, a7, a8, a9, a10         -
-*    betasq      -
-*    cc          -
-*    ctem, stem        -
-*    x1, x2, x3, x4, x5, x6, x7, x8          -
-*    xnodce      -
-*    xnoi        -
-*    zcosg  , zsing  , zcosgl , zsingl , zcosh  , zsinh  , zcoshl , zsinhl ,
-*    zcosi  , zsini  , zcosil , zsinil ,
-*    zx          -
-*    zy          -
-*
-*  coupling      :
-*    none.
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-static void dscom
-     (
-       double epoch,  double ep,     double argpp,   double tc,     double inclp,
-       double nodep,  double np,
-       double& snodm, double& cnodm, double& sinim,  double& cosim, double& sinomm,
-       double& cosomm,double& day,   double& e3,     double& ee2,   double& em,
-       double& emsq,  double& gam,   double& peo,    double& pgho,  double& pho,
-       double& pinco, double& plo,   double& rtemsq, double& se2,   double& se3,
-       double& sgh2,  double& sgh3,  double& sgh4,   double& sh2,   double& sh3,
-       double& si2,   double& si3,   double& sl2,    double& sl3,   double& sl4,
-       double& s1,    double& s2,    double& s3,     double& s4,    double& s5,
-       double& s6,    double& s7,    double& ss1,    double& ss2,   double& ss3,
-       double& ss4,   double& ss5,   double& ss6,    double& ss7,   double& sz1,
-       double& sz2,   double& sz3,   double& sz11,   double& sz12,  double& sz13,
-       double& sz21,  double& sz22,  double& sz23,   double& sz31,  double& sz32,
-       double& sz33,  double& xgh2,  double& xgh3,   double& xgh4,  double& xh2,
-       double& xh3,   double& xi2,   double& xi3,    double& xl2,   double& xl3,
-       double& xl4,   double& nm,    double& z1,     double& z2,    double& z3,
-       double& z11,   double& z12,   double& z13,    double& z21,   double& z22,
-       double& z23,   double& z31,   double& z32,    double& z33,   double& zmol,
-       double& zmos
-     )
-{
-     /* -------------------------- constants ------------------------- */
-     const double zes     =  0.01675;
-     const double zel     =  0.05490;
-     const double c1ss    =  2.9864797e-6;
-     const double c1l     =  4.7968065e-7;
-     const double zsinis  =  0.39785416;
-     const double zcosis  =  0.91744867;
-     const double zcosgs  =  0.1945905;
-     const double zsings  = -0.98088458;
-     const double twopi   =  2.0 * pi;
-
-     /* --------------------- local variables ------------------------ */
-     int lsflg;
-     double a1    , a2    , a3    , a4    , a5    , a6    , a7    ,
-        a8    , a9    , a10   , betasq, cc    , ctem  , stem  ,
-        x1    , x2    , x3    , x4    , x5    , x6    , x7    ,
-        x8    , xnodce, xnoi  , zcosg , zcosgl, zcosh , zcoshl,
-        zcosi , zcosil, zsing , zsingl, zsinh , zsinhl, zsini ,
-        zsinil, zx    , zy;
-
-     nm     = np;
-     em     = ep;
-     snodm  = sin(nodep);
-     cnodm  = cos(nodep);
-     sinomm = sin(argpp);
-     cosomm = cos(argpp);
-     sinim  = sin(inclp);
-     cosim  = cos(inclp);
-     emsq   = em * em;
-     betasq = 1.0 - emsq;
-     rtemsq = sqrt(betasq);
-
-     /* ----------------- initialize lunar solar terms --------------- */
-     peo    = 0.0;
-     pinco  = 0.0;
-     plo    = 0.0;
-     pgho   = 0.0;
-     pho    = 0.0;
-     day    = epoch + 18261.5 + tc / 1440.0;
-     xnodce = fmod(4.5236020 - 9.2422029e-4 * day, twopi);
-     stem   = sin(xnodce);
-     ctem   = cos(xnodce);
-     zcosil = 0.91375164 - 0.03568096 * ctem;
-     zsinil = sqrt(1.0 - zcosil * zcosil);
-     zsinhl = 0.089683511 * stem / zsinil;
-     zcoshl = sqrt(1.0 - zsinhl * zsinhl);
-     gam    = 5.8351514 + 0.0019443680 * day;
-     zx     = 0.39785416 * stem / zsinil;
-     zy     = zcoshl * ctem + 0.91744867 * zsinhl * stem;
-     zx     = atan2(zx, zy);
-     zx     = gam + zx - xnodce;
-     zcosgl = cos(zx);
-     zsingl = sin(zx);
-
-     /* ------------------------- do solar terms --------------------- */
-     zcosg = zcosgs;
-     zsing = zsings;
-     zcosi = zcosis;
-     zsini = zsinis;
-     zcosh = cnodm;
-     zsinh = snodm;
-     cc    = c1ss;
-     xnoi  = 1.0 / nm;
-
-     for (lsflg = 1; lsflg <= 2; lsflg++)
-       {
-         a1  =   zcosg * zcosh + zsing * zcosi * zsinh;
-         a3  =  -zsing * zcosh + zcosg * zcosi * zsinh;
-         a7  =  -zcosg * zsinh + zsing * zcosi * zcosh;
-         a8  =   zsing * zsini;
-         a9  =   zsing * zsinh + zcosg * zcosi * zcosh;
-         a10 =   zcosg * zsini;
-         a2  =   cosim * a7 + sinim * a8;
-         a4  =   cosim * a9 + sinim * a10;
-         a5  =  -sinim * a7 + cosim * a8;
-         a6  =  -sinim * a9 + cosim * a10;
-
-         x1  =  a1 * cosomm + a2 * sinomm;
-         x2  =  a3 * cosomm + a4 * sinomm;
-         x3  = -a1 * sinomm + a2 * cosomm;
-         x4  = -a3 * sinomm + a4 * cosomm;
-         x5  =  a5 * sinomm;
-         x6  =  a6 * sinomm;
-         x7  =  a5 * cosomm;
-         x8  =  a6 * cosomm;
-
-         z31 = 12.0 * x1 * x1 - 3.0 * x3 * x3;
-         z32 = 24.0 * x1 * x2 - 6.0 * x3 * x4;
-         z33 = 12.0 * x2 * x2 - 3.0 * x4 * x4;
-         z1  =  3.0 *  (a1 * a1 + a2 * a2) + z31 * emsq;
-         z2  =  6.0 *  (a1 * a3 + a2 * a4) + z32 * emsq;
-         z3  =  3.0 *  (a3 * a3 + a4 * a4) + z33 * emsq;
-         z11 = -6.0 * a1 * a5 + emsq *  (-24.0 * x1 * x7-6.0 * x3 * x5);
-         z12 = -6.0 *  (a1 * a6 + a3 * a5) + emsq *
-                (-24.0 * (x2 * x7 + x1 * x8) - 6.0 * (x3 * x6 + x4 * x5));
-         z13 = -6.0 * a3 * a6 + emsq * (-24.0 * x2 * x8 - 6.0 * x4 * x6);
-         z21 =  6.0 * a2 * a5 + emsq * (24.0 * x1 * x5 - 6.0 * x3 * x7);
-         z22 =  6.0 *  (a4 * a5 + a2 * a6) + emsq *
-                (24.0 * (x2 * x5 + x1 * x6) - 6.0 * (x4 * x7 + x3 * x8));
-         z23 =  6.0 * a4 * a6 + emsq * (24.0 * x2 * x6 - 6.0 * x4 * x8);
-         z1  = z1 + z1 + betasq * z31;
-         z2  = z2 + z2 + betasq * z32;
-         z3  = z3 + z3 + betasq * z33;
-         s3  = cc * xnoi;
-         s2  = -0.5 * s3 / rtemsq;
-         s4  = s3 * rtemsq;
-         s1  = -15.0 * em * s4;
-         s5  = x1 * x3 + x2 * x4;
-         s6  = x2 * x3 + x1 * x4;
-         s7  = x2 * x4 - x1 * x3;
-
-         /* ----------------------- do lunar terms ------------------- */
-         if (lsflg == 1)
-           {
-             ss1   = s1;
-             ss2   = s2;
-             ss3   = s3;
-             ss4   = s4;
-             ss5   = s5;
-             ss6   = s6;
-             ss7   = s7;
-             sz1   = z1;
-             sz2   = z2;
-             sz3   = z3;
-             sz11  = z11;
-             sz12  = z12;
-             sz13  = z13;
-             sz21  = z21;
-             sz22  = z22;
-             sz23  = z23;
-             sz31  = z31;
-             sz32  = z32;
-             sz33  = z33;
-             zcosg = zcosgl;
-             zsing = zsingl;
-             zcosi = zcosil;
-             zsini = zsinil;
-             zcosh = zcoshl * cnodm + zsinhl * snodm;
-             zsinh = snodm * zcoshl - cnodm * zsinhl;
-             cc    = c1l;
-          }
-       }
-
-     zmol = fmod(4.7199672 + 0.22997150  * day - gam, twopi);
-     zmos = fmod(6.2565837 + 0.017201977 * day, twopi);
-
-     /* ------------------------ do solar terms ---------------------- */
-     se2  =   2.0 * ss1 * ss6;
-     se3  =   2.0 * ss1 * ss7;
-     si2  =   2.0 * ss2 * sz12;
-     si3  =   2.0 * ss2 * (sz13 - sz11);
-     sl2  =  -2.0 * ss3 * sz2;
-     sl3  =  -2.0 * ss3 * (sz3 - sz1);
-     sl4  =  -2.0 * ss3 * (-21.0 - 9.0 * emsq) * zes;
-     sgh2 =   2.0 * ss4 * sz32;
-     sgh3 =   2.0 * ss4 * (sz33 - sz31);
-     sgh4 = -18.0 * ss4 * zes;
-     sh2  =  -2.0 * ss2 * sz22;
-     sh3  =  -2.0 * ss2 * (sz23 - sz21);
-
-     /* ------------------------ do lunar terms ---------------------- */
-     ee2  =   2.0 * s1 * s6;
-     e3   =   2.0 * s1 * s7;
-     xi2  =   2.0 * s2 * z12;
-     xi3  =   2.0 * s2 * (z13 - z11);
-     xl2  =  -2.0 * s3 * z2;
-     xl3  =  -2.0 * s3 * (z3 - z1);
-     xl4  =  -2.0 * s3 * (-21.0 - 9.0 * emsq) * zel;
-     xgh2 =   2.0 * s4 * z32;
-     xgh3 =   2.0 * s4 * (z33 - z31);
-     xgh4 = -18.0 * s4 * zel;
-     xh2  =  -2.0 * s2 * z22;
-     xh3  =  -2.0 * s2 * (z23 - z21);
-
-//#include "debug2.cpp"
-}  // end dscom
-
-/*-----------------------------------------------------------------------------
-*
-*                           procedure dsinit
-*
-*  this procedure provides deep space contributions to mean motion dot due
-*    to geopotential resonance with half day and one day orbits.
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    cosim, sinim-
-*    emsq        - eccentricity squared
-*    argpo       - argument of perigee
-*    s1, s2, s3, s4, s5      -
-*    ss1, ss2, ss3, ss4, ss5 -
-*    sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33 -
-*    t           - time
-*    tc          -
-*    gsto        - greenwich sidereal time                   rad
-*    mo          - mean anomaly
-*    mdot        - mean anomaly dot (rate)
-*    no          - mean motion
-*    nodeo       - right ascension of ascending node
-*    nodedot     - right ascension of ascending node dot (rate)
-*    xpidot      -
-*    z1, z3, z11, z13, z21, z23, z31, z33 -
-*    eccm        - eccentricity
-*    argpm       - argument of perigee
-*    inclm       - inclination
-*    mm          - mean anomaly
-*    xn          - mean motion
-*    nodem       - right ascension of ascending node
-*
-*  outputs       :
-*    em          - eccentricity
-*    argpm       - argument of perigee
-*    inclm       - inclination
-*    mm          - mean anomaly
-*    nm          - mean motion
-*    nodem       - right ascension of ascending node
-*    irez        - flag for resonance           0-none, 1-one day, 2-half day
-*    atime       -
-*    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433    -
-*    dedt        -
-*    didt        -
-*    dmdt        -
-*    dndt        -
-*    dnodt       -
-*    domdt       -
-*    del1, del2, del3        -
-*    ses  , sghl , sghs , sgs  , shl  , shs  , sis  , sls
-*    theta       -
-*    xfact       -
-*    xlamo       -
-*    xli         -
-*    xni
-*
-*  locals        :
-*    ainv2       -
-*    aonv        -
-*    cosisq      -
-*    eoc         -
-*    f220, f221, f311, f321, f322, f330, f441, f442, f522, f523, f542, f543  -
-*    g200, g201, g211, g300, g310, g322, g410, g422, g520, g521, g532, g533  -
-*    sini2       -
-*    temp        -
-*    temp1       -
-*    theta       -
-*    xno2        -
-*
-*  coupling      :
-*    getgravconst
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-static void dsinit
-     (
-       gravconsttype whichconst,
-       double cosim,  double emsq,   double argpo,   double s1,     double s2,
-       double s3,     double s4,     double s5,      double sinim,  double ss1,
-       double ss2,    double ss3,    double ss4,     double ss5,    double sz1,
-       double sz3,    double sz11,   double sz13,    double sz21,   double sz23,
-       double sz31,   double sz33,   double t,       double tc,     double gsto,
-       double mo,     double mdot,   double no,      double nodeo,  double nodedot,
-       double xpidot, double z1,     double z3,      double z11,    double z13,
-       double z21,    double z23,    double z31,     double z33,    double ecco,
-       double eccsq,  double& em,    double& argpm,  double& inclm, double& mm,
-       double& nm,    double& nodem,
-       int& irez,
-       double& atime, double& d2201, double& d2211,  double& d3210, double& d3222,
-       double& d4410, double& d4422, double& d5220,  double& d5232, double& d5421,
-       double& d5433, double& dedt,  double& didt,   double& dmdt,  double& dndt,
-       double& dnodt, double& domdt, double& del1,   double& del2,  double& del3,
-       double& xfact, double& xlamo, double& xli,    double& xni
-     )
-{
-     /* --------------------- local variables ------------------------ */
-     const double twopi = 2.0 * pi;
-
-     double ainv2 , aonv=0.0, cosisq, eoc, f220 , f221  , f311  ,
-          f321  , f322  , f330  , f441  , f442  , f522  , f523  ,
-          f542  , f543  , g200  , g201  , g211  , g300  , g310  ,
-          g322  , g410  , g422  , g520  , g521  , g532  , g533  ,
-          ses   , sgs   , sghl  , sghs  , shs   , shll  , sis   ,
-          sini2 , sls   , temp  , temp1 , theta , xno2  , q22   ,
-          q31   , q33   , root22, root44, root54, rptim , root32,
-          root52, x2o3  , xke   , znl   , emo   , zns   , emsqo,
-          tumin, mu, radiusearthkm, j2, j3, j4, j3oj2;
-
-     q22    = 1.7891679e-6;
-     q31    = 2.1460748e-6;
-     q33    = 2.2123015e-7;
-     root22 = 1.7891679e-6;
-     root44 = 7.3636953e-9;
-     root54 = 2.1765803e-9;
-     rptim  = 4.37526908801129966e-3; // this equates to 7.29211514668855e-5 rad/sec
-     root32 = 3.7393792e-7;
-     root52 = 1.1428639e-7;
-     x2o3   = 2.0 / 3.0;
-     znl    = 1.5835218e-4;
-     zns    = 1.19459e-5;
-
-     // sgp4fix identify constants and allow alternate values
-     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
-
-     /* -------------------- deep space initialization ------------ */
-     irez = 0;
-     if ((nm < 0.0052359877) && (nm > 0.0034906585))
-         irez = 1;
-     if ((nm >= 8.26e-3) && (nm <= 9.24e-3) && (em >= 0.5))
-         irez = 2;
-
-     /* ------------------------ do solar terms ------------------- */
-     ses  =  ss1 * zns * ss5;
-     sis  =  ss2 * zns * (sz11 + sz13);
-     sls  = -zns * ss3 * (sz1 + sz3 - 14.0 - 6.0 * emsq);
-     sghs =  ss4 * zns * (sz31 + sz33 - 6.0);
-     shs  = -zns * ss2 * (sz21 + sz23);
-     // sgp4fix for 180 deg incl
-     if ((inclm < 5.2359877e-2) || (inclm > pi - 5.2359877e-2))
-       shs = 0.0;
-     if (sinim != 0.0)
-       shs = shs / sinim;
-     sgs  = sghs - cosim * shs;
-
-     /* ------------------------- do lunar terms ------------------ */
-     dedt = ses + s1 * znl * s5;
-     didt = sis + s2 * znl * (z11 + z13);
-     dmdt = sls - znl * s3 * (z1 + z3 - 14.0 - 6.0 * emsq);
-     sghl = s4 * znl * (z31 + z33 - 6.0);
-     shll = -znl * s2 * (z21 + z23);
-     // sgp4fix for 180 deg incl
-     if ((inclm < 5.2359877e-2) || (inclm > pi - 5.2359877e-2))
-         shll = 0.0;
-     domdt = sgs + sghl;
-     dnodt = shs;
-     if (sinim != 0.0)
-       {
-         domdt = domdt - cosim / sinim * shll;
-         dnodt = dnodt + shll / sinim;
-       }
-
-     /* ----------- calculate deep space resonance effects -------- */
-     dndt   = 0.0;
-     theta  = fmod(gsto + tc * rptim, twopi);
-     em     = em + dedt * t;
-     inclm  = inclm + didt * t;
-     argpm  = argpm + domdt * t;
-     nodem  = nodem + dnodt * t;
-     mm     = mm + dmdt * t;
-     //   sgp4fix for negative inclinations
-     //   the following if statement should be commented out
-     //if (inclm < 0.0)
-     //  {
-     //    inclm  = -inclm;
-     //    argpm  = argpm - pi;
-     //    nodem = nodem + pi;
-     //  }
-
-     /* -------------- initialize the resonance terms ------------- */
-     if (irez != 0)
-       {
-         aonv = pow(nm / xke, x2o3);
-
-         /* ---------- geopotential resonance for 12 hour orbits ------ */
-         if (irez == 2)
-           {
-             cosisq = cosim * cosim;
-             emo    = em;
-             em     = ecco;
-             emsqo  = emsq;
-             emsq   = eccsq;
-             eoc    = em * emsq;
-             g201   = -0.306 - (em - 0.64) * 0.440;
-
-             if (em <= 0.65)
-               {
-                 g211 =    3.616  -  13.2470 * em +  16.2900 * emsq;
-                 g310 =  -19.302  + 117.3900 * em - 228.4190 * emsq +  156.5910 * eoc;
-                 g322 =  -18.9068 + 109.7927 * em - 214.6334 * emsq +  146.5816 * eoc;
-                 g410 =  -41.122  + 242.6940 * em - 471.0940 * emsq +  313.9530 * eoc;
-                 g422 = -146.407  + 841.8800 * em - 1629.014 * emsq + 1083.4350 * eoc;
-                 g520 = -532.114  + 3017.977 * em - 5740.032 * emsq + 3708.2760 * eoc;
-               }
-               else
-               {
-                 g211 =   -72.099 +   331.819 * em -   508.738 * emsq +   266.724 * eoc;
-                 g310 =  -346.844 +  1582.851 * em -  2415.925 * emsq +  1246.113 * eoc;
-                 g322 =  -342.585 +  1554.908 * em -  2366.899 * emsq +  1215.972 * eoc;
-                 g410 = -1052.797 +  4758.686 * em -  7193.992 * emsq +  3651.957 * eoc;
-                 g422 = -3581.690 + 16178.110 * em - 24462.770 * emsq + 12422.520 * eoc;
-                 if (em > 0.715)
-                     g520 =-5149.66 + 29936.92 * em - 54087.36 * emsq + 31324.56 * eoc;
-                   else
-                     g520 = 1464.74 -  4664.75 * em +  3763.64 * emsq;
-               }
-             if (em < 0.7)
-               {
-                 g533 = -919.22770 + 4988.6100 * em - 9064.7700 * emsq + 5542.21  * eoc;
-                 g521 = -822.71072 + 4568.6173 * em - 8491.4146 * emsq + 5337.524 * eoc;
-                 g532 = -853.66600 + 4690.2500 * em - 8624.7700 * emsq + 5341.4  * eoc;
-               }
-               else
-               {
-                 g533 =-37995.780 + 161616.52 * em - 229838.20 * emsq + 109377.94 * eoc;
-                 g521 =-51752.104 + 218913.95 * em - 309468.16 * emsq + 146349.42 * eoc;
-                 g532 =-40023.880 + 170470.89 * em - 242699.48 * emsq + 115605.82 * eoc;
-               }
-
-             sini2=  sinim * sinim;
-             f220 =  0.75 * (1.0 + 2.0 * cosim+cosisq);
-             f221 =  1.5 * sini2;
-             f321 =  1.875 * sinim  *  (1.0 - 2.0 * cosim - 3.0 * cosisq);
-             f322 = -1.875 * sinim  *  (1.0 + 2.0 * cosim - 3.0 * cosisq);
-             f441 = 35.0 * sini2 * f220;
-             f442 = 39.3750 * sini2 * sini2;
-             f522 =  9.84375 * sinim * (sini2 * (1.0 - 2.0 * cosim- 5.0 * cosisq) +
-                     0.33333333 * (-2.0 + 4.0 * cosim + 6.0 * cosisq) );
-             f523 = sinim * (4.92187512 * sini2 * (-2.0 - 4.0 * cosim +
-                    10.0 * cosisq) + 6.56250012 * (1.0+2.0 * cosim - 3.0 * cosisq));
-             f542 = 29.53125 * sinim * (2.0 - 8.0 * cosim+cosisq *
-                    (-12.0 + 8.0 * cosim + 10.0 * cosisq));
-             f543 = 29.53125 * sinim * (-2.0 - 8.0 * cosim+cosisq *
-                    (12.0 + 8.0 * cosim - 10.0 * cosisq));
-             xno2  =  nm * nm;
-             ainv2 =  aonv * aonv;
-             temp1 =  3.0 * xno2 * ainv2;
-             temp  =  temp1 * root22;
-             d2201 =  temp * f220 * g201;
-             d2211 =  temp * f221 * g211;
-             temp1 =  temp1 * aonv;
-             temp  =  temp1 * root32;
-             d3210 =  temp * f321 * g310;
-             d3222 =  temp * f322 * g322;
-             temp1 =  temp1 * aonv;
-             temp  =  2.0 * temp1 * root44;
-             d4410 =  temp * f441 * g410;
-             d4422 =  temp * f442 * g422;
-             temp1 =  temp1 * aonv;
-             temp  =  temp1 * root52;
-             d5220 =  temp * f522 * g520;
-             d5232 =  temp * f523 * g532;
-             temp  =  2.0 * temp1 * root54;
-             d5421 =  temp * f542 * g521;
-             d5433 =  temp * f543 * g533;
-             xlamo =  fmod(mo + nodeo + nodeo-theta - theta, twopi);
-             xfact =  mdot + dmdt + 2.0 * (nodedot + dnodt - rptim) - no;
-             em    = emo;
-             emsq  = emsqo;
-           }
-
-         /* ---------------- synchronous resonance terms -------------- */
-         if (irez == 1)
-           {
-             g200  = 1.0 + emsq * (-2.5 + 0.8125 * emsq);
-             g310  = 1.0 + 2.0 * emsq;
-             g300  = 1.0 + emsq * (-6.0 + 6.60937 * emsq);
-             f220  = 0.75 * (1.0 + cosim) * (1.0 + cosim);
-             f311  = 0.9375 * sinim * sinim * (1.0 + 3.0 * cosim) - 0.75 * (1.0 + cosim);
-             f330  = 1.0 + cosim;
-             f330  = 1.875 * f330 * f330 * f330;
-             del1  = 3.0 * nm * nm * aonv * aonv;
-             del2  = 2.0 * del1 * f220 * g200 * q22;
-             del3  = 3.0 * del1 * f330 * g300 * q33 * aonv;
-             del1  = del1 * f311 * g310 * q31 * aonv;
-             xlamo = fmod(mo + nodeo + argpo - theta, twopi);
-             xfact = mdot + xpidot - rptim + dmdt + domdt + dnodt - no;
-           }
-
-         /* ------------ for sgp4, initialize the integrator ---------- */
-         xli   = xlamo;
-         xni   = no;
-         atime = 0.0;
-         nm    = no + dndt;
-       }
-
-//#include "debug3.cpp"
-}  // end dsinit
-
-/*-----------------------------------------------------------------------------
-*
-*                           procedure dspace
-*
-*  this procedure provides deep space contributions to mean elements for
-*    perturbing third body.  these effects have been averaged over one
-*    revolution of the sun and moon.  for earth resonance effects, the
-*    effects have been averaged over no revolutions of the satellite.
-*    (mean motion)
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433 -
-*    dedt        -
-*    del1, del2, del3  -
-*    didt        -
-*    dmdt        -
-*    dnodt       -
-*    domdt       -
-*    irez        - flag for resonance           0-none, 1-one day, 2-half day
-*    argpo       - argument of perigee
-*    argpdot     - argument of perigee dot (rate)
-*    t           - time
-*    tc          -
-*    gsto        - gst
-*    xfact       -
-*    xlamo       -
-*    no          - mean motion
-*    atime       -
-*    em          - eccentricity
-*    ft          -
-*    argpm       - argument of perigee
-*    inclm       - inclination
-*    xli         -
-*    mm          - mean anomaly
-*    xni         - mean motion
-*    nodem       - right ascension of ascending node
-*
-*  outputs       :
-*    atime       -
-*    em          - eccentricity
-*    argpm       - argument of perigee
-*    inclm       - inclination
-*    xli         -
-*    mm          - mean anomaly
-*    xni         -
-*    nodem       - right ascension of ascending node
-*    dndt        -
-*    nm          - mean motion
-*
-*  locals        :
-*    delt        -
-*    ft          -
-*    theta       -
-*    x2li        -
-*    x2omi       -
-*    xl          -
-*    xldot       -
-*    xnddt       -
-*    xndt        -
-*    xomi        -
-*
-*  coupling      :
-*    none        -
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-static void dspace
-     (
-       int irez,
-       double d2201,  double d2211,  double d3210,   double d3222,  double d4410,
-       double d4422,  double d5220,  double d5232,   double d5421,  double d5433,
-       double dedt,   double del1,   double del2,    double del3,   double didt,
-       double dmdt,   double dnodt,  double domdt,   double argpo,  double argpdot,
-       double t,      double tc,     double gsto,    double xfact,  double xlamo,
-       double no,
-       double& atime, double& em,    double& argpm,  double& inclm, double& xli,
-       double& mm,    double& xni,   double& nodem,  double& dndt,  double& nm
-     )
-{
-     const double twopi = 2.0 * pi;
-     int iretn , iret;
-     double delt, ft, theta, x2li, x2omi, xl, xldot , xnddt, xndt, xomi, g22, g32,
-          g44, g52, g54, fasx2, fasx4, fasx6, rptim , step2, stepn , stepp;
-
-     ft    = 0.0;
-     fasx2 = 0.13130908;
-     fasx4 = 2.8843198;
-     fasx6 = 0.37448087;
-     g22   = 5.7686396;
-     g32   = 0.95240898;
-     g44   = 1.8014998;
-     g52   = 1.0508330;
-     g54   = 4.4108898;
-     rptim = 4.37526908801129966e-3; // this equates to 7.29211514668855e-5 rad/sec
-     stepp =    720.0;
-     stepn =   -720.0;
-     step2 = 259200.0;
-
-     /* ----------- calculate deep space resonance effects ----------- */
-     dndt   = 0.0;
-     theta  = fmod(gsto + tc * rptim, twopi);
-     em     = em + dedt * t;
-
-     inclm  = inclm + didt * t;
-     argpm  = argpm + domdt * t;
-     nodem  = nodem + dnodt * t;
-     mm     = mm + dmdt * t;
-
-     //   sgp4fix for negative inclinations
-     //   the following if statement should be commented out
-     //  if (inclm < 0.0)
-     // {
-     //    inclm = -inclm;
-     //    argpm = argpm - pi;
-     //    nodem = nodem + pi;
-     //  }
-
-     /* - update resonances : numerical (euler-maclaurin) integration - */
-     /* ------------------------- epoch restart ----------------------  */
-     //   sgp4fix for propagator problems
-     //   the following integration works for negative time steps and periods
-     //   the specific changes are unknown because the original code was so convoluted
-
-     ft    = 0.0;
-     atime = 0.0;
-     if (irez != 0)
-       {
-         if ((atime == 0.0) || ((t >= 0.0) && (atime < 0.0)) ||
-             ((t < 0.0) && (atime >= 0.0)))
-           {
-             if (t >= 0.0)
-                 delt = stepp;
-               else
-                 delt = stepn;
-             atime  = 0.0;
-             xni    = no;
-             xli    = xlamo;
-           }
-         iretn = 381; // added for do loop
-         iret  =   0; // added for loop
-         while (iretn == 381)
-           {
-             if ((fabs(t) < fabs(atime)) || (iret == 351))
-               {
-                 if (t >= 0.0)
-                     delt = stepn;
-                   else
-                     delt = stepp;
-                 iret  = 351;
-                 iretn = 381;
-               }
-               else
-               {
-                 if (t > 0.0)  // error if prev if has atime:=0.0 and t:=0.0 (ge)
-                     delt = stepp;
-                   else
-                     delt = stepn;
-                 if (fabs(t - atime) >= stepp)
-                   {
-                     iret  = 0;
-                     iretn = 381;
-                   }
-                   else
-                   {
-                     ft    = t - atime;
-                     iretn = 0;
-                   }
-               }
-
-             /* ------------------- dot terms calculated ------------- */
-             /* ----------- near - synchronous resonance terms ------- */
-             if (irez != 2)
-               {
-                 xndt  = del1 * sin(xli - fasx2) + del2 * sin(2.0 * (xli - fasx4)) +
-                         del3 * sin(3.0 * (xli - fasx6));
-                 xldot = xni + xfact;
-                 xnddt = del1 * cos(xli - fasx2) +
-                         2.0 * del2 * cos(2.0 * (xli - fasx4)) +
-                         3.0 * del3 * cos(3.0 * (xli - fasx6));
-                 xnddt = xnddt * xldot;
-               }
-               else
-               {
-                 /* --------- near - half-day resonance terms -------- */
-                 xomi  = argpo + argpdot * atime;
-                 x2omi = xomi + xomi;
-                 x2li  = xli + xli;
-                 xndt  = d2201 * sin(x2omi + xli - g22) + d2211 * sin(xli - g22) +
-                       d3210 * sin(xomi + xli - g32)  + d3222 * sin(-xomi + xli - g32)+
-                       d4410 * sin(x2omi + x2li - g44)+ d4422 * sin(x2li - g44) +
-                       d5220 * sin(xomi + xli - g52)  + d5232 * sin(-xomi + xli - g52)+
-                       d5421 * sin(xomi + x2li - g54) + d5433 * sin(-xomi + x2li - g54);
-                 xldot = xni + xfact;
-                 xnddt = d2201 * cos(x2omi + xli - g22) + d2211 * cos(xli - g22) +
-                       d3210 * cos(xomi + xli - g32) + d3222 * cos(-xomi + xli - g32) +
-                       d5220 * cos(xomi + xli - g52) + d5232 * cos(-xomi + xli - g52) +
-                       2.0 * (d4410 * cos(x2omi + x2li - g44) +
-                       d4422 * cos(x2li - g44) + d5421 * cos(xomi + x2li - g54) +
-                       d5433 * cos(-xomi + x2li - g54));
-                 xnddt = xnddt * xldot;
-               }
-
-             /* ----------------------- integrator ------------------- */
-             if (iretn == 381)
-               {
-                 xli   = xli + xldot * delt + xndt * step2;
-                 xni   = xni + xndt * delt + xnddt * step2;
-                 atime = atime + delt;
-               }
-           }  // while iretn = 381
-
-         nm = xni + xndt * ft + xnddt * ft * ft * 0.5;
-         xl = xli + xldot * ft + xndt * ft * ft * 0.5;
-         if (irez != 1)
-           {
-             mm   = xl - 2.0 * nodem + 2.0 * theta;
-             dndt = nm - no;
-           }
-           else
-           {
-             mm   = xl - nodem - argpm + theta;
-             dndt = nm - no;
-           }
-         nm = no + dndt;
-       }
-
-//#include "debug4.cpp"
-}  // end dsspace
-
-/*-----------------------------------------------------------------------------
-*
-*                           procedure initl
-*
-*  this procedure initializes the spg4 propagator. all the initialization is
-*    consolidated here instead of having multiple loops inside other routines.
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    ecco        - eccentricity                           0.0 - 1.0
-*    epoch       - epoch time in days from jan 0, 1950. 0 hr
-*    inclo       - inclination of satellite
-*    no          - mean motion of satellite
-*    satn        - satellite number
-*
-*  outputs       :
-*    ainv        - 1.0 / a
-*    ao          - semi major axis
-*    con41       -
-*    con42       - 1.0 - 5.0 cos(i)
-*    cosio       - cosine of inclination
-*    cosio2      - cosio squared
-*    eccsq       - eccentricity squared
-*    method      - flag for deep space                    'd', 'n'
-*    omeosq      - 1.0 - ecco * ecco
-*    posq        - semi-parameter squared
-*    rp          - radius of perigee
-*    rteosq      - square root of (1.0 - ecco*ecco)
-*    sinio       - sine of inclination
-*    gsto        - gst at time of observation               rad
-*    no          - mean motion of satellite
-*
-*  locals        :
-*    ak          -
-*    d1          -
-*    del         -
-*    adel        -
-*    po          -
-*
-*  coupling      :
-*    getgravconst
-*    gstime      - find greenwich sidereal time from the julian date
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-static void initl
-     (
-       int satn,      gravconsttype whichconst,
-       double ecco,   double epoch,  double inclo,   double& no,
-       char& method,
-       double& ainv,  double& ao,    double& con41,  double& con42, double& cosio,
-       double& cosio2,double& eccsq, double& omeosq, double& posq,
-       double& rp,    double& rteosq,double& sinio , double& gsto
-     )
-{
-     /* --------------------- local variables ------------------------ */
-     double ak, d1, del, adel, po, x2o3, j2, xke,
-            tumin, mu, radiusearthkm, j3, j4, j3oj2;
-
-     // sgp4fix use old way of finding gst
-     int ids70;
-     double ts70, ds70, tfrac, c1, thgr70, fk5r, c1p2p;
-     const double twopi = 2.0 * pi;
-
-     /* ----------------------- earth constants ---------------------- */
-     // sgp4fix identify constants and allow alternate values
-     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
-     x2o3   = 2.0 / 3.0;
-
-     /* ------------- calculate auxillary epoch quantities ---------- */
-     eccsq  = ecco * ecco;
-     omeosq = 1.0 - eccsq;
-     rteosq = sqrt(omeosq);
-     cosio  = cos(inclo);
-     cosio2 = cosio * cosio;
-
-     /* ------------------ un-kozai the mean motion ----------------- */
-     ak    = pow(xke / no, x2o3);
-     d1    = 0.75 * j2 * (3.0 * cosio2 - 1.0) / (rteosq * omeosq);
-     del   = d1 / (ak * ak);
-     adel  = ak * (1.0 - del * del - del *
-             (1.0 / 3.0 + 134.0 * del * del / 81.0));
-     del   = d1/(adel * adel);
-     no    = no / (1.0 + del);
-
-     ao    = pow(xke / no, x2o3);
-     sinio = sin(inclo);
-     po    = ao * omeosq;
-     con42 = 1.0 - 5.0 * cosio2;
-     con41 = -con42-cosio2-cosio2;
-     ainv  = 1.0 / ao;
-     posq  = po * po;
-     rp    = ao * (1.0 - ecco);
-     method = 'n';
-
-     // sgp4fix modern approach to finding sidereal timew
-     // gsto = gstime(epoch + 2433281.5);
-
-     // sgp4fix use old way of finding gst
-     // count integer number of days from 0 jan 1970
-     ts70  = epoch - 7305.0;
-     ids70 = floor(ts70 + 1.0e-8);
-     ds70  = ids70;
-     tfrac = ts70 - ds70;
-     // find greenwich location at epoch
-     c1    = 1.72027916940703639e-2;
-     thgr70= 1.7321343856509374;
-     fk5r  = 5.07551419432269442e-15;
-     c1p2p = c1 + twopi;
-     gsto  = fmod( thgr70 + c1*ds70 + c1p2p*tfrac + ts70*ts70*fk5r, twopi);
-     if ( gsto < 0.0 )
-         gsto = gsto + twopi;
-
-//#include "debug5.cpp"
-}  // end initl
-
-/*-----------------------------------------------------------------------------
-*
-*                             procedure sgp4init
-*
-*  this procedure initializes variables for sgp4.
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    satn        - satellite number
-*    bstar       - sgp4 type drag coefficient              kg/m2er
-*    ecco        - eccentricity
-*    epoch       - epoch time in days from jan 0, 1950. 0 hr
-*    argpo       - argument of perigee (output if ds)
-*    inclo       - inclination
-*    mo          - mean anomaly (output if ds)
-*    no          - mean motion
-*    nodeo       - right ascension of ascending node
-*
-*  outputs       :
-*    satrec      - common values for subsequent calls
-*    return code - non-zero on error.
-*                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
-*                   2 - mean motion less than 0.0
-*                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
-*                   4 - semi-latus rectum < 0.0
-*                   5 - epoch elements are sub-orbital
-*                   6 - satellite has decayed
-*
-*  locals        :
-*    cnodm  , snodm  , cosim  , sinim  , cosomm , sinomm
-*    cc1sq  , cc2    , cc3
-*    coef   , coef1
-*    cosio4      -
-*    day         -
-*    dndt        -
-*    em          - eccentricity
-*    emsq        - eccentricity squared
-*    eeta        -
-*    etasq       -
-*    gam         -
-*    argpm       - argument of perigee
-*    nodem       -
-*    inclm       - inclination
-*    mm          - mean anomaly
-*    nm          - mean motion
-*    perige      - perigee
-*    pinvsq      -
-*    psisq       -
-*    qzms24      -
-*    rtemsq      -
-*    s1, s2, s3, s4, s5, s6, s7          -
-*    sfour       -
-*    ss1, ss2, ss3, ss4, ss5, ss6, ss7         -
-*    sz1, sz2, sz3
-*    sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33        -
-*    tc          -
-*    temp        -
-*    temp1, temp2, temp3       -
-*    tsi         -
-*    xpidot      -
-*    xhdot1      -
-*    z1, z2, z3          -
-*    z11, z12, z13, z21, z22, z23, z31, z32, z33         -
-*
-*  coupling      :
-*    getgravconst-
-*    initl       -
-*    dscom       -
-*    dpper       -
-*    dsinit      -
-*    sgp4        -
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-int sgp4init
-     (
-       gravconsttype whichconst,       const int satn,     const double epoch,
-       const double xbstar,  const double xecco, const double xargpo,
-       const double xinclo,  const double xmo,   const double xno,
-       const double xnodeo,  elsetrec& satrec
-     )
-{
-     /* --------------------- local variables ------------------------ */
-     double ao, ainv,   con42, cosio, sinio, cosio2, eccsq,
-          omeosq, posq,   rp,     rteosq,
-          cnodm , snodm , cosim , sinim , cosomm, sinomm, cc1sq ,
-          cc2   , cc3   , coef  , coef1 , cosio4, day   , dndt  ,
-          em    , emsq  , eeta  , etasq , gam   , argpm , nodem ,
-          inclm , mm    , nm    , perige, pinvsq, psisq , qzms24,
-          rtemsq, s1    , s2    , s3    , s4    , s5    , s6    ,
-          s7    , sfour , ss1 = 0   , ss2 = 0   , ss3 = 0   , ss4 = 0   , ss5 = 0   ,
-          ss6 = 0   , ss7 = 0   , sz1 = 0   , sz2 = 0   , sz3 = 0   , sz11 = 0  , sz12 = 0  ,
-          sz13 = 0  , sz21 = 0  , sz22 = 0  , sz23 = 0  , sz31 = 0  , sz32 = 0  , sz33 = 0  ,
-          tc    , temp  , temp1 , temp2 , temp3 , tsi   , xpidot,
-          xhdot1, z1    , z2    , z3    , z11   , z12   , z13   ,
-          z21   , z22   , z23   , z31   , z32   , z33,
-          qzms2t, ss, j2, j3oj2, j4, x2o3, r[3], v[3],
-          tumin, mu, radiusearthkm, xke, j3;
-
-     /* ------------------------ initialization --------------------- */
-     // sgp4fix divisor for divide by zero check on inclination
-     const double temp4    =   1.0 + cos(pi-1.0e-9);
-
-     /* ----------- set all near earth variables to zero ------------ */
-     satrec.isimp   = 0;   satrec.method = 'n'; satrec.aycof    = 0.0;
-     satrec.con41   = 0.0; satrec.cc1    = 0.0; satrec.cc4      = 0.0;
-     satrec.cc5     = 0.0; satrec.d2     = 0.0; satrec.d3       = 0.0;
-     satrec.d4      = 0.0; satrec.delmo  = 0.0; satrec.eta      = 0.0;
-     satrec.argpdot = 0.0; satrec.omgcof = 0.0; satrec.sinmao   = 0.0;
-     satrec.t       = 0.0; satrec.t2cof  = 0.0; satrec.t3cof    = 0.0;
-     satrec.t4cof   = 0.0; satrec.t5cof  = 0.0; satrec.x1mth2   = 0.0;
-     satrec.x7thm1  = 0.0; satrec.mdot   = 0.0; satrec.nodedot  = 0.0;
-     satrec.xlcof   = 0.0; satrec.xmcof  = 0.0; satrec.nodecf   = 0.0;
-
-     /* ----------- set all deep space variables to zero ------------ */
-     satrec.irez  = 0;   satrec.d2201 = 0.0; satrec.d2211 = 0.0;
-     satrec.d3210 = 0.0; satrec.d3222 = 0.0; satrec.d4410 = 0.0;
-     satrec.d4422 = 0.0; satrec.d5220 = 0.0; satrec.d5232 = 0.0;
-     satrec.d5421 = 0.0; satrec.d5433 = 0.0; satrec.dedt  = 0.0;
-     satrec.del1  = 0.0; satrec.del2  = 0.0; satrec.del3  = 0.0;
-     satrec.didt  = 0.0; satrec.dmdt  = 0.0; satrec.dnodt = 0.0;
-     satrec.domdt = 0.0; satrec.e3    = 0.0; satrec.ee2   = 0.0;
-     satrec.peo   = 0.0; satrec.pgho  = 0.0; satrec.pho   = 0.0;
-     satrec.pinco = 0.0; satrec.plo   = 0.0; satrec.se2   = 0.0;
-     satrec.se3   = 0.0; satrec.sgh2  = 0.0; satrec.sgh3  = 0.0;
-     satrec.sgh4  = 0.0; satrec.sh2   = 0.0; satrec.sh3   = 0.0;
-     satrec.si2   = 0.0; satrec.si3   = 0.0; satrec.sl2   = 0.0;
-     satrec.sl3   = 0.0; satrec.sl4   = 0.0; satrec.gsto  = 0.0;
-     satrec.xfact = 0.0; satrec.xgh2  = 0.0; satrec.xgh3  = 0.0;
-     satrec.xgh4  = 0.0; satrec.xh2   = 0.0; satrec.xh3   = 0.0;
-     satrec.xi2   = 0.0; satrec.xi3   = 0.0; satrec.xl2   = 0.0;
-     satrec.xl3   = 0.0; satrec.xl4   = 0.0; satrec.xlamo = 0.0;
-     satrec.zmol  = 0.0; satrec.zmos  = 0.0; satrec.atime = 0.0;
-     satrec.xli   = 0.0; satrec.xni   = 0.0;
-
-     // sgp4fix - note the following variables are also passed directly via satrec.
-     // it is possible to streamline the sgp4init call by deleting the "x"
-     // variables, but the user would need to set the satrec.* values first. we
-     // include the additional assignments in case twoline2rv is not used.
-     satrec.bstar   = xbstar;
-     satrec.ecco    = xecco;
-     satrec.argpo   = xargpo;
-     satrec.inclo   = xinclo;
-     satrec.mo	    = xmo;
-     satrec.no	    = xno;
-     satrec.nodeo   = xnodeo;
-
-     /* ------------------------ earth constants ----------------------- */
-     // sgp4fix identify constants and allow alternate values
-     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
-     ss     = 78.0 / radiusearthkm + 1.0;
-     qzms2t = pow(((120.0 - 78.0) / radiusearthkm), 4);
-     x2o3   =  2.0 / 3.0;
-
-     satrec.init = 'y';
-     satrec.t	 = 0.0;
-
-     initl
-         (
-           satn, whichconst, satrec.ecco, epoch, satrec.inclo, satrec.no, satrec.method,
-           ainv, ao, satrec.con41, con42, cosio, cosio2, eccsq, omeosq,
-           posq, rp, rteosq, sinio, satrec.gsto
-         );
-     satrec.error = 0;
-
-     if (rp < 1.0)
-       {
-//         printf("# *** satn%d epoch elts sub-orbital ***\n", satn);
-         satrec.error = 5;
-       }
-
-     if ((omeosq >= 0.0 ) || ( satrec.no >= 0.0))
-       {
-         satrec.isimp = 0;
-         if (rp < (220.0 / radiusearthkm + 1.0))
-             satrec.isimp = 1;
-         sfour  = ss;
-         qzms24 = qzms2t;
-         perige = (rp - 1.0) * radiusearthkm;
-
-         /* - for perigees below 156 km, s and qoms2t are altered - */
-         if (perige < 156.0)
-           {
-             sfour = perige - 78.0;
-             if (perige < 98.0)
-                 sfour = 20.0;
-             qzms24 = pow(((120.0 - sfour) / radiusearthkm), 4.0);
-             sfour  = sfour / radiusearthkm + 1.0;
-           }
-         pinvsq = 1.0 / posq;
-
-         tsi  = 1.0 / (ao - sfour);
-         satrec.eta  = ao * satrec.ecco * tsi;
-         etasq = satrec.eta * satrec.eta;
-         eeta  = satrec.ecco * satrec.eta;
-         psisq = fabs(1.0 - etasq);
-         coef  = qzms24 * pow(tsi, 4.0);
-         coef1 = coef / pow(psisq, 3.5);
-         cc2   = coef1 * satrec.no * (ao * (1.0 + 1.5 * etasq + eeta *
-                        (4.0 + etasq)) + 0.375 * j2 * tsi / psisq * satrec.con41 *
-                        (8.0 + 3.0 * etasq * (8.0 + etasq)));
-         satrec.cc1   = satrec.bstar * cc2;
-         cc3   = 0.0;
-         if (satrec.ecco > 1.0e-4)
-             cc3 = -2.0 * coef * tsi * j3oj2 * satrec.no * sinio / satrec.ecco;
-         satrec.x1mth2 = 1.0 - cosio2;
-         satrec.cc4    = 2.0* satrec.no * coef1 * ao * omeosq *
-                           (satrec.eta * (2.0 + 0.5 * etasq) + satrec.ecco *
-                           (0.5 + 2.0 * etasq) - j2 * tsi / (ao * psisq) *
-                           (-3.0 * satrec.con41 * (1.0 - 2.0 * eeta + etasq *
-                           (1.5 - 0.5 * eeta)) + 0.75 * satrec.x1mth2 *
-                           (2.0 * etasq - eeta * (1.0 + etasq)) * cos(2.0 * satrec.argpo)));
-         satrec.cc5 = 2.0 * coef1 * ao * omeosq * (1.0 + 2.75 *
-                        (etasq + eeta) + eeta * etasq);
-         cosio4 = cosio2 * cosio2;
-         temp1  = 1.5 * j2 * pinvsq * satrec.no;
-         temp2  = 0.5 * temp1 * j2 * pinvsq;
-         temp3  = -0.46875 * j4 * pinvsq * pinvsq * satrec.no;
-         satrec.mdot     = satrec.no + 0.5 * temp1 * rteosq * satrec.con41 + 0.0625 *
-                            temp2 * rteosq * (13.0 - 78.0 * cosio2 + 137.0 * cosio4);
-         satrec.argpdot  = -0.5 * temp1 * con42 + 0.0625 * temp2 *
-                             (7.0 - 114.0 * cosio2 + 395.0 * cosio4) +
-                             temp3 * (3.0 - 36.0 * cosio2 + 49.0 * cosio4);
-         xhdot1            = -temp1 * cosio;
-         satrec.nodedot = xhdot1 + (0.5 * temp2 * (4.0 - 19.0 * cosio2) +
-                              2.0 * temp3 * (3.0 - 7.0 * cosio2)) * cosio;
-         xpidot            =  satrec.argpdot+ satrec.nodedot;
-         satrec.omgcof   = satrec.bstar * cc3 * cos(satrec.argpo);
-         satrec.xmcof    = 0.0;
-         if (satrec.ecco > 1.0e-4)
-             satrec.xmcof = -x2o3 * coef * satrec.bstar / eeta;
-         satrec.nodecf = 3.5 * omeosq * xhdot1 * satrec.cc1;
-         satrec.t2cof   = 1.5 * satrec.cc1;
-         // sgp4fix for divide by zero with xinco = 180 deg
-         if (fabs(cosio+1.0) > 1.5e-12)
-             satrec.xlcof = -0.25 * j3oj2 * sinio * (3.0 + 5.0 * cosio) / (1.0 + cosio);
-           else
-             satrec.xlcof = -0.25 * j3oj2 * sinio * (3.0 + 5.0 * cosio) / temp4;
-         satrec.aycof   = -0.5 * j3oj2 * sinio;
-         satrec.delmo   = pow((1.0 + satrec.eta * cos(satrec.mo)), 3);
-         satrec.sinmao  = sin(satrec.mo);
-         satrec.x7thm1  = 7.0 * cosio2 - 1.0;
-
-         /* --------------- deep space initialization ------------- */
-         if ((2*pi / satrec.no) >= 225.0)
-           {
-             satrec.method = 'd';
-             satrec.isimp  = 1;
-             tc    =  0.0;
-             inclm = satrec.inclo;
-
-             dscom
-                 (
-                   epoch, satrec.ecco, satrec.argpo, tc, satrec.inclo, satrec.nodeo,
-                   satrec.no, snodm, cnodm,  sinim, cosim,sinomm,     cosomm,
-                   day, satrec.e3, satrec.ee2, em,         emsq, gam,
-                   satrec.peo,  satrec.pgho,   satrec.pho, satrec.pinco,
-                   satrec.plo,  rtemsq,        satrec.se2, satrec.se3,
-                   satrec.sgh2, satrec.sgh3,   satrec.sgh4,
-                   satrec.sh2,  satrec.sh3,    satrec.si2, satrec.si3,
-                   satrec.sl2,  satrec.sl3,    satrec.sl4, s1, s2, s3, s4, s5,
-                   s6,   s7,   ss1,  ss2,  ss3,  ss4,  ss5,  ss6,  ss7, sz1, sz2, sz3,
-                   sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33,
-                   satrec.xgh2, satrec.xgh3,   satrec.xgh4, satrec.xh2,
-                   satrec.xh3,  satrec.xi2,    satrec.xi3,  satrec.xl2,
-                   satrec.xl3,  satrec.xl4,    nm, z1, z2, z3, z11,
-                   z12, z13, z21, z22, z23, z31, z32, z33,
-                   satrec.zmol, satrec.zmos
-                 );
-             dpper
-                 (
-                   satrec.e3, satrec.ee2, satrec.peo, satrec.pgho,
-                   satrec.pho, satrec.pinco, satrec.plo, satrec.se2,
-                   satrec.se3, satrec.sgh2, satrec.sgh3, satrec.sgh4,
-                   satrec.sh2, satrec.sh3, satrec.si2,  satrec.si3,
-                   satrec.sl2, satrec.sl3, satrec.sl4,  satrec.t,
-                   satrec.xgh2,satrec.xgh3,satrec.xgh4, satrec.xh2,
-                   satrec.xh3, satrec.xi2, satrec.xi3,  satrec.xl2,
-                   satrec.xl3, satrec.xl4, satrec.zmol, satrec.zmos, inclm, satrec.init,
-                   satrec.ecco, satrec.inclo, satrec.nodeo, satrec.argpo, satrec.mo
-                 );
-
-             argpm  = 0.0;
-             nodem  = 0.0;
-             mm     = 0.0;
-
-             dsinit
-                 (
-                   whichconst,
-                   cosim, emsq, satrec.argpo, s1, s2, s3, s4, s5, sinim, ss1, ss2, ss3, ss4,
-                   ss5, sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33, satrec.t, tc,
-                   satrec.gsto, satrec.mo, satrec.mdot, satrec.no, satrec.nodeo,
-                   satrec.nodedot, xpidot, z1, z3, z11, z13, z21, z23, z31, z33,
-                   satrec.ecco, eccsq, em, argpm, inclm, mm, nm, nodem,
-                   satrec.irez,  satrec.atime,
-                   satrec.d2201, satrec.d2211, satrec.d3210, satrec.d3222 ,
-                   satrec.d4410, satrec.d4422, satrec.d5220, satrec.d5232,
-                   satrec.d5421, satrec.d5433, satrec.dedt,  satrec.didt,
-                   satrec.dmdt,  dndt,         satrec.dnodt, satrec.domdt ,
-                   satrec.del1,  satrec.del2,  satrec.del3,  satrec.xfact,
-                   satrec.xlamo, satrec.xli,   satrec.xni
-                 );
-           }
-
-       /* ----------- set variables if not deep space ----------- */
-       if (satrec.isimp != 1)
-         {
-           cc1sq          = satrec.cc1 * satrec.cc1;
-           satrec.d2    = 4.0 * ao * tsi * cc1sq;
-           temp           = satrec.d2 * tsi * satrec.cc1 / 3.0;
-           satrec.d3    = (17.0 * ao + sfour) * temp;
-           satrec.d4    = 0.5 * temp * ao * tsi * (221.0 * ao + 31.0 * sfour) *
-                            satrec.cc1;
-           satrec.t3cof = satrec.d2 + 2.0 * cc1sq;
-           satrec.t4cof = 0.25 * (3.0 * satrec.d3 + satrec.cc1 *
-                            (12.0 * satrec.d2 + 10.0 * cc1sq));
-           satrec.t5cof = 0.2 * (3.0 * satrec.d4 +
-                            12.0 * satrec.cc1 * satrec.d3 +
-                            6.0 * satrec.d2 * satrec.d2 +
-                            15.0 * cc1sq * (2.0 * satrec.d2 + cc1sq));
-         }
-       } // if omeosq = 0 ...
-
-       /* finally propogate to zero epoch to initialise all others. */
-       if(satrec.error == 0)
-           sgp4(whichconst, satrec, 0.0, r, v);
-
-       satrec.init = 'n';
-
-//#include "debug6.cpp"
-       return satrec.error;
-}  // end sgp4init
-
-/*-----------------------------------------------------------------------------
-*
-*                             procedure sgp4
-*
-*  this procedure is the sgp4 prediction model from space command. this is an
-*    updated and combined version of sgp4 and sdp4, which were originally
-*    published separately in spacetrack report #3. this version follows the
-*    methodology from the aiaa paper (2006) describing the history and
-*    development of the code.
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    satrec	 - initialised structure from sgp4init() call.
-*    tsince	 - time eince epoch (minutes)
-*
-*  outputs       :
-*    r           - position vector                     km
-*    v           - velocity                            km/sec
-*  return code - non-zero on error.
-*                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
-*                   2 - mean motion less than 0.0
-*                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
-*                   4 - semi-latus rectum < 0.0
-*                   5 - epoch elements are sub-orbital
-*                   6 - satellite has decayed
-*
-*  locals        :
-*    am          -
-*    axnl, aynl        -
-*    betal       -
-*    cosim   , sinim   , cosomm  , sinomm  , cnod    , snod    , cos2u   ,
-*    sin2u   , coseo1  , sineo1  , cosi    , sini    , cosip   , sinip   ,
-*    cosisq  , cossu   , sinsu   , cosu    , sinu
-*    delm        -
-*    delomg      -
-*    dndt        -
-*    eccm        -
-*    emsq        -
-*    ecose       -
-*    el2         -
-*    eo1         -
-*    eccp        -
-*    esine       -
-*    argpm       -
-*    argpp       -
-*    omgadf      -
-*    pl          -
-*    r           -
-*    rtemsq      -
-*    rdotl       -
-*    rl          -
-*    rvdot       -
-*    rvdotl      -
-*    su          -
-*    t2  , t3   , t4    , tc
-*    tem5, temp , temp1 , temp2  , tempa  , tempe  , templ
-*    u   , ux   , uy    , uz     , vx     , vy     , vz
-*    inclm       - inclination
-*    mm          - mean anomaly
-*    nm          - mean motion
-*    nodem       - right asc of ascending node
-*    xinc        -
-*    xincp       -
-*    xl          -
-*    xlm         -
-*    mp          -
-*    xmdf        -
-*    xmx         -
-*    xmy         -
-*    nodedf      -
-*    xnode       -
-*    nodep       -
-*    np          -
-*
-*  coupling      :
-*    getgravconst-
-*    dpper
-*    dpspace
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-int sgp4
-     (
-       gravconsttype whichconst, elsetrec& satrec,  double tsince,
-       double r[3],  double v[3]
-     )
-{
-     double am   , axnl  , aynl , betal ,  cosim , cnod  ,
-         cos2u, coseo1, cosi , cosip ,  cosisq, cossu , cosu,
-         delm , delomg, em   , emsq  ,  ecose , el2   , eo1 ,
-         ep   , esine , argpm, argpp ,  argpdf, pl,     mrt = 0.0,
-         mvt  , rdotl , rl   , rvdot ,  rvdotl, sinim ,
-         sin2u, sineo1, sini , sinip ,  sinsu , sinu  ,
-         snod , su    , t2   , t3    ,  t4    , tem5  , temp,
-         temp1, temp2 , tempa, tempe ,  templ , u     , ux  ,
-         uy   , uz    , vx   , vy    ,  vz    , inclm , mm  ,
-         nm   , nodem, xinc , xincp ,  xl    , xlm   , mp  ,
-         xmdf , xmx   , xmy  , nodedf, xnode , nodep, tc  , dndt,
-         twopi, x2o3  , j2   , j3    , tumin, j4 , xke   , j3oj2, radiusearthkm,
-         mu, vkmpersec;
-     int ktr;
-
-     /* ------------------ set mathematical constants --------------- */
-     // sgp4fix divisor for divide by zero check on inclination
-     const double temp4    =   1.0 + cos(pi-1.0e-9);
-     twopi = 2.0 * pi;
-     x2o3  = 2.0 / 3.0;
-     // sgp4fix identify constants and allow alternate values
-     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
-     vkmpersec     = radiusearthkm * xke/60.0;
-
-     /* --------------------- clear sgp4 error flag ----------------- */
-     satrec.t     = tsince;
-     satrec.error = 0;
-
-     /* ------- update for secular gravity and atmospheric drag ----- */
-     xmdf    = satrec.mo + satrec.mdot * satrec.t;
-     argpdf  = satrec.argpo + satrec.argpdot * satrec.t;
-     nodedf  = satrec.nodeo + satrec.nodedot * satrec.t;
-     argpm   = argpdf;
-     mm      = xmdf;
-     t2      = satrec.t * satrec.t;
-     nodem   = nodedf + satrec.nodecf * t2;
-     tempa   = 1.0 - satrec.cc1 * satrec.t;
-     tempe   = satrec.bstar * satrec.cc4 * satrec.t;
-     templ   = satrec.t2cof * t2;
-
-     if (satrec.isimp != 1)
-       {
-         delomg = satrec.omgcof * satrec.t;
-         delm   = satrec.xmcof *
-                  (pow((1.0 + satrec.eta * cos(xmdf)), 3) -
-                  satrec.delmo);
-         temp   = delomg + delm;
-         mm     = xmdf + temp;
-         argpm  = argpdf - temp;
-         t3     = t2 * satrec.t;
-         t4     = t3 * satrec.t;
-         tempa  = tempa - satrec.d2 * t2 - satrec.d3 * t3 -
-                          satrec.d4 * t4;
-         tempe  = tempe + satrec.bstar * satrec.cc5 * (sin(mm) -
-                          satrec.sinmao);
-         templ  = templ + satrec.t3cof * t3 + t4 * (satrec.t4cof +
-                          satrec.t * satrec.t5cof);
-       }
-
-     nm    = satrec.no;
-     em    = satrec.ecco;
-     inclm = satrec.inclo;
-     if (satrec.method == 'd')
-       {
-         tc = satrec.t;
-         dspace
-             (
-               satrec.irez,
-               satrec.d2201, satrec.d2211, satrec.d3210,
-               satrec.d3222, satrec.d4410, satrec.d4422,
-               satrec.d5220, satrec.d5232, satrec.d5421,
-               satrec.d5433, satrec.dedt,  satrec.del1,
-               satrec.del2,  satrec.del3,  satrec.didt,
-               satrec.dmdt,  satrec.dnodt, satrec.domdt,
-               satrec.argpo, satrec.argpdot, satrec.t, tc,
-               satrec.gsto, satrec.xfact, satrec.xlamo,
-               satrec.no, satrec.atime,
-               em, argpm, inclm, satrec.xli, mm, satrec.xni,
-               nodem, dndt, nm
-             );
-       } // if method = d
-
-     if (nm <= 0.0)
-       {
-//         printf("# error nm %f\n", nm);
-         satrec.error = 2;
-       }
-     am = pow((xke / nm),x2o3) * tempa * tempa;
-     nm = xke / pow(am, 1.5);
-     em = em - tempe;
-
-     // fix tolerance for error recognition
-     if ((em >= 1.0) || (em < -0.001) || (am < 0.95))
-       {
-//         printf("# error em %f\n", em);
-         satrec.error = 1;
-       }
-     if (em < 0.0)
-         em  = 1.0e-6;
-     mm     = mm + satrec.no * templ;
-     xlm    = mm + argpm + nodem;
-     emsq   = em * em;
-     temp   = 1.0 - emsq;
-
-     nodem  = fmod(nodem, twopi);
-     argpm  = fmod(argpm, twopi);
-     xlm    = fmod(xlm, twopi);
-     mm     = fmod(xlm - argpm - nodem, twopi);
-
-     /* ----------------- compute extra mean quantities ------------- */
-     sinim = sin(inclm);
-     cosim = cos(inclm);
-
-     /* -------------------- add lunar-solar periodics -------------- */
-     ep     = em;
-     xincp  = inclm;
-     argpp  = argpm;
-     nodep  = nodem;
-     mp     = mm;
-     sinip  = sinim;
-     cosip  = cosim;
-     if (satrec.method == 'd')
-       {
-         dpper
-             (
-               satrec.e3,   satrec.ee2,  satrec.peo,
-               satrec.pgho, satrec.pho,  satrec.pinco,
-               satrec.plo,  satrec.se2,  satrec.se3,
-               satrec.sgh2, satrec.sgh3, satrec.sgh4,
-               satrec.sh2,  satrec.sh3,  satrec.si2,
-               satrec.si3,  satrec.sl2,  satrec.sl3,
-               satrec.sl4,  satrec.t,    satrec.xgh2,
-               satrec.xgh3, satrec.xgh4, satrec.xh2,
-               satrec.xh3,  satrec.xi2,  satrec.xi3,
-               satrec.xl2,  satrec.xl3,  satrec.xl4,
-               satrec.zmol, satrec.zmos, satrec.inclo,
-               'n', ep, xincp, nodep, argpp, mp
-             );
-         if (xincp < 0.0)
-           {
-             xincp  = -xincp;
-             nodep = nodep + pi;
-             argpp  = argpp - pi;
-           }
-         if ((ep < 0.0 ) || ( ep > 1.0))
-           {
- //            printf("# error ep %f\n", ep);
-             satrec.error = 3;
-           }
-       } // if method = d
-
-     /* -------------------- long period periodics ------------------ */
-     if (satrec.method == 'd')
-       {
-         sinip =  sin(xincp);
-         cosip =  cos(xincp);
-         satrec.aycof = -0.5*j3oj2*sinip;
-         // sgp4fix for divide by zero for xincp = 180 deg
-         if (fabs(cosip+1.0) > 1.5e-12)
-             satrec.xlcof = -0.25 * j3oj2 * sinip * (3.0 + 5.0 * cosip) / (1.0 + cosip);
-           else
-             satrec.xlcof = -0.25 * j3oj2 * sinip * (3.0 + 5.0 * cosip) / temp4;
-       }
-     axnl = ep * cos(argpp);
-     temp = 1.0 / (am * (1.0 - ep * ep));
-     aynl = ep* sin(argpp) + temp * satrec.aycof;
-     xl   = mp + argpp + nodep + temp * satrec.xlcof * axnl;
-
-     /* --------------------- solve kepler's equation --------------- */
-     u    = fmod(xl - nodep, twopi);
-     eo1  = u;
-     tem5 = 9999.9;
-     ktr = 1;
-     //   sgp4fix for kepler iteration
-     //   the following iteration needs better limits on corrections
-     while (( fabs(tem5) >= 1.0e-12) && (ktr <= 10) )
-       {
-         sineo1 = sin(eo1);
-         coseo1 = cos(eo1);
-         tem5   = 1.0 - coseo1 * axnl - sineo1 * aynl;
-         tem5   = (u - aynl * coseo1 + axnl * sineo1 - eo1) / tem5;
-         if(fabs(tem5) >= 0.95)
-             tem5 = tem5 > 0.0 ? 0.95 : -0.95;
-         eo1    = eo1 + tem5;
-         ktr = ktr + 1;
-       }
-
-     /* ------------- short period preliminary quantities ----------- */
-     ecose = axnl*coseo1 + aynl*sineo1;
-     esine = axnl*sineo1 - aynl*coseo1;
-     el2   = axnl*axnl + aynl*aynl;
-     pl    = am*(1.0-el2);
-     if (pl < 0.0)
-       {
-//         printf("# error pl %f\n", pl);
-         satrec.error = 4;
-       }
-       else
-       {
-         rl     = am * (1.0 - ecose);
-         rdotl  = sqrt(am) * esine/rl;
-         rvdotl = sqrt(pl) / rl;
-         betal  = sqrt(1.0 - el2);
-         temp   = esine / (1.0 + betal);
-         sinu   = am / rl * (sineo1 - aynl - axnl * temp);
-         cosu   = am / rl * (coseo1 - axnl + aynl * temp);
-         su     = atan2(sinu, cosu);
-         sin2u  = (cosu + cosu) * sinu;
-         cos2u  = 1.0 - 2.0 * sinu * sinu;
-         temp   = 1.0 / pl;
-         temp1  = 0.5 * j2 * temp;
-         temp2  = temp1 * temp;
-
-         /* -------------- update for short period periodics ------------ */
-         if (satrec.method == 'd')
-           {
-             cosisq                 = cosip * cosip;
-             satrec.con41  = 3.0*cosisq - 1.0;
-             satrec.x1mth2 = 1.0 - cosisq;
-             satrec.x7thm1 = 7.0*cosisq - 1.0;
-           }
-         mrt   = rl * (1.0 - 1.5 * temp2 * betal * satrec.con41) +
-                 0.5 * temp1 * satrec.x1mth2 * cos2u;
-         su    = su - 0.25 * temp2 * satrec.x7thm1 * sin2u;
-         xnode = nodep + 1.5 * temp2 * cosip * sin2u;
-         xinc  = xincp + 1.5 * temp2 * cosip * sinip * cos2u;
-         mvt   = rdotl - nm * temp1 * satrec.x1mth2 * sin2u / xke;
-         rvdot = rvdotl + nm * temp1 * (satrec.x1mth2 * cos2u +
-                 1.5 * satrec.con41) / xke;
-
-         /* --------------------- orientation vectors ------------------- */
-         sinsu =  sin(su);
-         cossu =  cos(su);
-         snod  =  sin(xnode);
-         cnod  =  cos(xnode);
-         sini  =  sin(xinc);
-         cosi  =  cos(xinc);
-         xmx   = -snod * cosi;
-         xmy   =  cnod * cosi;
-         ux    =  xmx * sinsu + cnod * cossu;
-         uy    =  xmy * sinsu + snod * cossu;
-         uz    =  sini * sinsu;
-         vx    =  xmx * cossu - cnod * sinsu;
-         vy    =  xmy * cossu - snod * sinsu;
-         vz    =  sini * cossu;
-
-         /* --------- position and velocity (in km and km/sec) ---------- */
-         r[0] = (mrt * ux)* radiusearthkm;
-         r[1] = (mrt * uy)* radiusearthkm;
-         r[2] = (mrt * uz)* radiusearthkm;
-         v[0] = (mvt * ux + rvdot * vx) * vkmpersec;
-         v[1] = (mvt * uy + rvdot * vy) * vkmpersec;
-         v[2] = (mvt * uz + rvdot * vz) * vkmpersec;
-       }  // if pl > 0
-
-     // sgp4fix for decaying satellites
-     if (mrt < 1.0)
-       {
-//         printf("# decay condition %11.6f \n",mrt);
-         satrec.error = 6;
-       }
-
-
-//#include "debug7.cpp"
-     return satrec.error;
-}  // end sgp4
-
-
-/* -----------------------------------------------------------------------------
-*
-*                           function gstime
-*
-*  this function finds the greenwich sidereal time.
-*
-*  author        : david vallado                  719-573-2600    1 mar 2001
-*
-*  inputs          description                    range / units
-*    jdut1       - julian date in ut1             days from 4713 bc
-*
-*  outputs       :
-*    gstime      - greenwich sidereal time        0 to 2pi rad
-*
-*  locals        :
-*    temp        - temporary variable for doubles   rad
-*    tut1        - julian centuries from the
-*                  jan 1, 2000 12 h epoch (ut1)
-*
-*  coupling      :
-*    none
-*
-*  references    :
-*    vallado       2004, 191, eq 3-45
-* --------------------------------------------------------------------------- */
-
-double  gstime
-        (
-          double jdut1
-        )
-   {
-     const double twopi = 2.0 * pi;
-     const double deg2rad = pi / 180.0;
-     double       temp, tut1;
-
-     tut1 = (jdut1 - 2451545.0) / 36525.0;
-     temp = -6.2e-6* tut1 * tut1 * tut1 + 0.093104 * tut1 * tut1 +
-             (876600.0*3600 + 8640184.812866) * tut1 + 67310.54841;  // sec
-     temp = fmod(temp * deg2rad / 240.0, twopi); //360/86400 = 1/240, to deg, to rad
-
-     // ------------------------ check quadrants ---------------------
-     if (temp < 0.0)
-         temp += twopi;
-
-     return temp;
-   }  // end gstime
-
-/* -----------------------------------------------------------------------------
-*
-*                           function getgravconst
-*
-*  this function gets constants for the propagator. note that mu is identified to
-*    facilitiate comparisons with newer models. the common useage is wgs72.
-*
-*  author        : david vallado                  719-573-2600   21 jul 2006
-*
-*  inputs        :
-*    whichconst  - which set of constants to use  wgs72old, wgs72, wgs84
-*
-*  outputs       :
-*    tumin       - minutes in one time unit
-*    mu          - earth gravitational parameter
-*    radiusearthkm - radius of the earth in km
-*    xke         - reciprocal of tumin
-*    j2, j3, j4  - un-normalized zonal harmonic values
-*    j3oj2       - j3 divided by j2
-*
-*  locals        :
-*
-*  coupling      :
-*    none
-*
-*  references    :
-*    norad spacetrack report #3
-*    vallado, crawford, hujsak, kelso  2006
-  --------------------------------------------------------------------------- */
-
-void getgravconst
-     (
-      gravconsttype whichconst,
-      double& tumin,
-      double& mu,
-      double& radiusearthkm,
-      double& xke,
-      double& j2,
-      double& j3,
-      double& j4,
-      double& j3oj2
-     )
-     {
-
-       switch (whichconst)
-         {
-           // -- wgs-72 low precision str#3 constants --
-           case wgs72old:
-           mu     = 398600.79964;        // in km3 / s2
-           radiusearthkm = 6378.135;     // km
-           xke    = 0.0743669161;
-           tumin  = 1.0 / xke;
-           j2     =   0.001082616;
-           j3     =  -0.00000253881;
-           j4     =  -0.00000165597;
-           j3oj2  =  j3 / j2;
-         break;
-           // ------------ wgs-72 constants ------------
-           case wgs72:
-           mu     = 398600.8;            // in km3 / s2
-           radiusearthkm = 6378.135;     // km
-           xke    = 60.0 / sqrt(radiusearthkm*radiusearthkm*radiusearthkm/mu);
-           tumin  = 1.0 / xke;
-           j2     =   0.001082616;
-           j3     =  -0.00000253881;
-           j4     =  -0.00000165597;
-           j3oj2  =  j3 / j2;
-         break;
-           case wgs84:
-           // ------------ wgs-84 constants ------------
-           mu     = 398600.5;            // in km3 / s2
-           radiusearthkm = 6378.137;     // km
-           xke    = 60.0 / sqrt(radiusearthkm*radiusearthkm*radiusearthkm/mu);
-           tumin  = 1.0 / xke;
-           j2     =   0.00108262998905;
-           j3     =  -0.00000253215306;
-           j4     =  -0.00000161098761;
-           j3oj2  =  j3 / j2;
-         break;
-         default:
-           fprintf(stderr,"unknown gravity option (%d)\n",whichconst);
-         break;
-         }
-
-     }   // end getgravconst
-
-
-
-
-
+/*     ----------------------------------------------------------------
+*
+*                               sgp4unit.cpp
+*
+*    this file contains the sgp4 procedures for analytical propagation
+*    of a satellite. the code was originally released in the 1980 and 1986
+*    spacetrack papers. a detailed discussion of the theory and history
+*    may be found in the 2006 aiaa paper by vallado, crawford, hujsak,
+*    and kelso.
+*
+*                            companion code for
+*               fundamentals of astrodynamics and applications
+*                                    2007
+*                              by david vallado
+*
+*       (w) 719-573-2600, email dvallado@agi.com
+*
+*    current :
+*              16 nov 07  david vallado
+*                           misc fixes for better compliance
+*    changes :
+*              20 apr 07  david vallado
+*                           misc fixes for constants
+*              11 aug 06  david vallado
+*                           chg lyddane choice back to strn3, constants, misc doc
+*              15 dec 05  david vallado
+*                           misc fixes
+*              26 jul 05  david vallado
+*                           fixes for paper
+*                           note that each fix is preceded by a
+*                           comment with "sgp4fix" and an explanation of
+*                           what was changed
+*              10 aug 04  david vallado
+*                           2nd printing baseline working
+*              14 may 01  david vallado
+*                           2nd edition baseline
+*                     80  norad
+*                           original baseline
+*       ----------------------------------------------------------------      */
+
+#include "sgp4unit.h"
+
+const char help = 'n';
+FILE *dbgfile;
+
+#define pi 3.14159265358979323846
+
+
+/* ----------- local functions - only ever used internally by sgp4 ---------- */
+static void dpper
+     (
+       double e3,     double ee2,    double peo,     double pgho,   double pho,
+       double pinco,  double plo,    double se2,     double se3,    double sgh2,
+       double sgh3,   double sgh4,   double sh2,     double sh3,    double si2,
+       double si3,    double sl2,    double sl3,     double sl4,    double t,
+       double xgh2,   double xgh3,   double xgh4,    double xh2,    double xh3,
+       double xi2,    double xi3,    double xl2,     double xl3,    double xl4,
+       double zmol,   double zmos,   double inclo,
+       char init,
+       double& ep,    double& inclp, double& nodep,  double& argpp, double& mp
+     );
+
+static void dscom
+     (
+       double epoch,  double ep,     double argpp,   double tc,     double inclp,
+       double nodep,  double np,
+       double& snodm, double& cnodm, double& sinim,  double& cosim, double& sinomm,
+       double& cosomm,double& day,   double& e3,     double& ee2,   double& em,
+       double& emsq,  double& gam,   double& peo,    double& pgho,  double& pho,
+       double& pinco, double& plo,   double& rtemsq, double& se2,   double& se3,
+       double& sgh2,  double& sgh3,  double& sgh4,   double& sh2,   double& sh3,
+       double& si2,   double& si3,   double& sl2,    double& sl3,   double& sl4,
+       double& s1,    double& s2,    double& s3,     double& s4,    double& s5,
+       double& s6,    double& s7,    double& ss1,    double& ss2,   double& ss3,
+       double& ss4,   double& ss5,   double& ss6,    double& ss7,   double& sz1,
+       double& sz2,   double& sz3,   double& sz11,   double& sz12,  double& sz13,
+       double& sz21,  double& sz22,  double& sz23,   double& sz31,  double& sz32,
+       double& sz33,  double& xgh2,  double& xgh3,   double& xgh4,  double& xh2,
+       double& xh3,   double& xi2,   double& xi3,    double& xl2,   double& xl3,
+       double& xl4,   double& nm,    double& z1,     double& z2,    double& z3,
+       double& z11,   double& z12,   double& z13,    double& z21,   double& z22,
+       double& z23,   double& z31,   double& z32,    double& z33,   double& zmol,
+       double& zmos
+     );
+
+static void dsinit
+     (
+       gravconsttype whichconst,
+       double cosim,  double emsq,   double argpo,   double s1,     double s2,
+       double s3,     double s4,     double s5,      double sinim,  double ss1,
+       double ss2,    double ss3,    double ss4,     double ss5,    double sz1,
+       double sz3,    double sz11,   double sz13,    double sz21,   double sz23,
+       double sz31,   double sz33,   double t,       double tc,     double gsto,
+       double mo,     double mdot,   double no,      double nodeo,  double nodedot,
+       double xpidot, double z1,     double z3,      double z11,    double z13,
+       double z21,    double z23,    double z31,     double z33,    double ecco,
+       double eccsq,  double& em,    double& argpm,  double& inclm, double& mm,
+       double& nm,    double& nodem,
+       int& irez,
+       double& atime, double& d2201, double& d2211,  double& d3210, double& d3222,
+       double& d4410, double& d4422, double& d5220,  double& d5232, double& d5421,
+       double& d5433, double& dedt,  double& didt,   double& dmdt,  double& dndt,
+       double& dnodt, double& domdt, double& del1,   double& del2,  double& del3,
+       double& xfact, double& xlamo, double& xli,    double& xni
+     );
+
+static void dspace
+     (
+       int irez,
+       double d2201,  double d2211,  double d3210,   double d3222,  double d4410,
+       double d4422,  double d5220,  double d5232,   double d5421,  double d5433,
+       double dedt,   double del1,   double del2,    double del3,   double didt,
+       double dmdt,   double dnodt,  double domdt,   double argpo,  double argpdot,
+       double t,      double tc,     double gsto,    double xfact,  double xlamo,
+       double no,
+       double& atime, double& em,    double& argpm,  double& inclm, double& xli,
+       double& mm,    double& xni,   double& nodem,  double& dndt,  double& nm
+     );
+
+static void initl
+     (
+       int satn,      gravconsttype whichconst,
+       double ecco,   double epoch,  double inclo,   double& no,
+       char& method,
+       double& ainv,  double& ao,    double& con41,  double& con42, double& cosio,
+       double& cosio2,double& eccsq, double& omeosq, double& posq,
+       double& rp,    double& rteosq,double& sinio , double& gsto
+     );
+
+/* -----------------------------------------------------------------------------
+*
+*                           procedure dpper
+*
+*  this procedure provides deep space long period periodic contributions
+*    to the mean elements.  by design, these periodics are zero at epoch.
+*    this used to be dscom which included initialization, but it's really a
+*    recurring function.
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    e3          -
+*    ee2         -
+*    peo         -
+*    pgho        -
+*    pho         -
+*    pinco       -
+*    plo         -
+*    se2 , se3 , sgh2, sgh3, sgh4, sh2, sh3, si2, si3, sl2, sl3, sl4 -
+*    t           -
+*    xh2, xh3, xi2, xi3, xl2, xl3, xl4 -
+*    zmol        -
+*    zmos        -
+*    ep          - eccentricity                           0.0 - 1.0
+*    inclo       - inclination - needed for lyddane modification
+*    nodep       - right ascension of ascending node
+*    argpp       - argument of perigee
+*    mp          - mean anomaly
+*
+*  outputs       :
+*    ep          - eccentricity                           0.0 - 1.0
+*    inclp       - inclination
+*    nodep        - right ascension of ascending node
+*    argpp       - argument of perigee
+*    mp          - mean anomaly
+*
+*  locals        :
+*    alfdp       -
+*    betdp       -
+*    cosip  , sinip  , cosop  , sinop  ,
+*    dalf        -
+*    dbet        -
+*    dls         -
+*    f2, f3      -
+*    pe          -
+*    pgh         -
+*    ph          -
+*    pinc        -
+*    pl          -
+*    sel   , ses   , sghl  , sghs  , shl   , shs   , sil   , sinzf , sis   ,
+*    sll   , sls
+*    xls         -
+*    xnoh        -
+*    zf          -
+*    zm          -
+*
+*  coupling      :
+*    none.
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+static void dpper
+     (
+       double e3,     double ee2,    double peo,     double pgho,   double pho,
+       double pinco,  double plo,    double se2,     double se3,    double sgh2,
+       double sgh3,   double sgh4,   double sh2,     double sh3,    double si2,
+       double si3,    double sl2,    double sl3,     double sl4,    double t,
+       double xgh2,   double xgh3,   double xgh4,    double xh2,    double xh3,
+       double xi2,    double xi3,    double xl2,     double xl3,    double xl4,
+       double zmol,   double zmos,   double inclo,
+       char init,
+       double& ep,    double& inclp, double& nodep,  double& argpp, double& mp
+     )
+{
+     /* --------------------- local variables ------------------------ */
+     const double twopi = 2.0 * pi;
+     double alfdp, betdp, cosip, cosop, dalf, dbet, dls,
+          f2,    f3,    pe,    pgh,   ph,   pinc, pl ,
+          sel,   ses,   sghl,  sghs,  shll, shs,  sil,
+          sinip, sinop, sinzf, sis,   sll,  sls,  xls,
+          xnoh,  zf,    zm,    zel,   zes,  znl,  zns;
+
+     /* ---------------------- constants ----------------------------- */
+     zns   = 1.19459e-5;
+     zes   = 0.01675;
+     znl   = 1.5835218e-4;
+     zel   = 0.05490;
+
+     /* --------------- calculate time varying periodics ----------- */
+     zm    = zmos + zns * t;
+     // be sure that the initial call has time set to zero
+     if (init == 'y')
+         zm = zmos;
+     zf    = zm + 2.0 * zes * sin(zm);
+     sinzf = sin(zf);
+     f2    =  0.5 * sinzf * sinzf - 0.25;
+     f3    = -0.5 * sinzf * cos(zf);
+     ses   = se2* f2 + se3 * f3;
+     sis   = si2 * f2 + si3 * f3;
+     sls   = sl2 * f2 + sl3 * f3 + sl4 * sinzf;
+     sghs  = sgh2 * f2 + sgh3 * f3 + sgh4 * sinzf;
+     shs   = sh2 * f2 + sh3 * f3;
+     zm    = zmol + znl * t;
+     if (init == 'y')
+         zm = zmol;
+     zf    = zm + 2.0 * zel * sin(zm);
+     sinzf = sin(zf);
+     f2    =  0.5 * sinzf * sinzf - 0.25;
+     f3    = -0.5 * sinzf * cos(zf);
+     sel   = ee2 * f2 + e3 * f3;
+     sil   = xi2 * f2 + xi3 * f3;
+     sll   = xl2 * f2 + xl3 * f3 + xl4 * sinzf;
+     sghl  = xgh2 * f2 + xgh3 * f3 + xgh4 * sinzf;
+     shll  = xh2 * f2 + xh3 * f3;
+     pe    = ses + sel;
+     pinc  = sis + sil;
+     pl    = sls + sll;
+     pgh   = sghs + sghl;
+     ph    = shs + shll;
+
+     if (init == 'n')
+       {
+       pe    = pe - peo;
+       pinc  = pinc - pinco;
+       pl    = pl - plo;
+       pgh   = pgh - pgho;
+       ph    = ph - pho;
+       inclp = inclp + pinc;
+       ep    = ep + pe;
+       sinip = sin(inclp);
+       cosip = cos(inclp);
+
+       /* ----------------- apply periodics directly ------------ */
+       //  sgp4fix for lyddane choice
+       //  strn3 used original inclination - this is technically feasible
+       //  gsfc used perturbed inclination - also technically feasible
+       //  probably best to readjust the 0.2 limit value and limit discontinuity
+       //  0.2 rad = 11.45916 deg
+       //  use next line for original strn3 approach and original inclination
+       //  if (inclo >= 0.2)
+       //  use next line for gsfc version and perturbed inclination
+       if (inclp >= 0.2)
+         {
+           ph     = ph / sinip;
+           pgh    = pgh - cosip * ph;
+           argpp  = argpp + pgh;
+           nodep  = nodep + ph;
+           mp     = mp + pl;
+         }
+         else
+         {
+           /* ---- apply periodics with lyddane modification ---- */
+           sinop  = sin(nodep);
+           cosop  = cos(nodep);
+           alfdp  = sinip * sinop;
+           betdp  = sinip * cosop;
+           dalf   =  ph * cosop + pinc * cosip * sinop;
+           dbet   = -ph * sinop + pinc * cosip * cosop;
+           alfdp  = alfdp + dalf;
+           betdp  = betdp + dbet;
+           nodep  = fmod(nodep, twopi);
+           //  sgp4fix for afspc written intrinsic functions
+           // nodep used without a trigonometric function ahead
+           if (nodep < 0.0)
+               nodep = nodep + twopi;
+           xls    = mp + argpp + cosip * nodep;
+           dls    = pl + pgh - pinc * nodep * sinip;
+           xls    = xls + dls;
+           xnoh   = nodep;
+           nodep  = atan2(alfdp, betdp);
+           //  sgp4fix for afspc written intrinsic functions
+           // nodep used without a trigonometric function ahead
+           if (nodep < 0.0)
+               nodep = nodep + twopi;
+           if (fabs(xnoh - nodep) > pi){
+             if (nodep < xnoh)
+                nodep = nodep + twopi;
+               else
+                nodep = nodep - twopi;
+           }
+           mp    = mp + pl;
+           argpp = xls - mp - cosip * nodep;
+         }
+       }   // if init == 'n'
+
+//#include "debug1.cpp"
+}  // end dpper
+
+/*-----------------------------------------------------------------------------
+*
+*                           procedure dscom
+*
+*  this procedure provides deep space common items used by both the secular
+*    and periodics subroutines.  input is provided as shown. this routine
+*    used to be called dpper, but the functions inside weren't well organized.
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    epoch       -
+*    ep          - eccentricity
+*    argpp       - argument of perigee
+*    tc          -
+*    inclp       - inclination
+*    nodep       - right ascension of ascending node
+*    np          - mean motion
+*
+*  outputs       :
+*    sinim  , cosim  , sinomm , cosomm , snodm  , cnodm
+*    day         -
+*    e3          -
+*    ee2         -
+*    em          - eccentricity
+*    emsq        - eccentricity squared
+*    gam         -
+*    peo         -
+*    pgho        -
+*    pho         -
+*    pinco       -
+*    plo         -
+*    rtemsq      -
+*    se2, se3         -
+*    sgh2, sgh3, sgh4        -
+*    sh2, sh3, si2, si3, sl2, sl3, sl4         -
+*    s1, s2, s3, s4, s5, s6, s7          -
+*    ss1, ss2, ss3, ss4, ss5, ss6, ss7, sz1, sz2, sz3         -
+*    sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33        -
+*    xgh2, xgh3, xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4         -
+*    nm          - mean motion
+*    z1, z2, z3, z11, z12, z13, z21, z22, z23, z31, z32, z33         -
+*    zmol        -
+*    zmos        -
+*
+*  locals        :
+*    a1, a2, a3, a4, a5, a6, a7, a8, a9, a10         -
+*    betasq      -
+*    cc          -
+*    ctem, stem        -
+*    x1, x2, x3, x4, x5, x6, x7, x8          -
+*    xnodce      -
+*    xnoi        -
+*    zcosg  , zsing  , zcosgl , zsingl , zcosh  , zsinh  , zcoshl , zsinhl ,
+*    zcosi  , zsini  , zcosil , zsinil ,
+*    zx          -
+*    zy          -
+*
+*  coupling      :
+*    none.
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+static void dscom
+     (
+       double epoch,  double ep,     double argpp,   double tc,     double inclp,
+       double nodep,  double np,
+       double& snodm, double& cnodm, double& sinim,  double& cosim, double& sinomm,
+       double& cosomm,double& day,   double& e3,     double& ee2,   double& em,
+       double& emsq,  double& gam,   double& peo,    double& pgho,  double& pho,
+       double& pinco, double& plo,   double& rtemsq, double& se2,   double& se3,
+       double& sgh2,  double& sgh3,  double& sgh4,   double& sh2,   double& sh3,
+       double& si2,   double& si3,   double& sl2,    double& sl3,   double& sl4,
+       double& s1,    double& s2,    double& s3,     double& s4,    double& s5,
+       double& s6,    double& s7,    double& ss1,    double& ss2,   double& ss3,
+       double& ss4,   double& ss5,   double& ss6,    double& ss7,   double& sz1,
+       double& sz2,   double& sz3,   double& sz11,   double& sz12,  double& sz13,
+       double& sz21,  double& sz22,  double& sz23,   double& sz31,  double& sz32,
+       double& sz33,  double& xgh2,  double& xgh3,   double& xgh4,  double& xh2,
+       double& xh3,   double& xi2,   double& xi3,    double& xl2,   double& xl3,
+       double& xl4,   double& nm,    double& z1,     double& z2,    double& z3,
+       double& z11,   double& z12,   double& z13,    double& z21,   double& z22,
+       double& z23,   double& z31,   double& z32,    double& z33,   double& zmol,
+       double& zmos
+     )
+{
+     /* -------------------------- constants ------------------------- */
+     const double zes     =  0.01675;
+     const double zel     =  0.05490;
+     const double c1ss    =  2.9864797e-6;
+     const double c1l     =  4.7968065e-7;
+     const double zsinis  =  0.39785416;
+     const double zcosis  =  0.91744867;
+     const double zcosgs  =  0.1945905;
+     const double zsings  = -0.98088458;
+     const double twopi   =  2.0 * pi;
+
+     /* --------------------- local variables ------------------------ */
+     int lsflg;
+     double a1    , a2    , a3    , a4    , a5    , a6    , a7    ,
+        a8    , a9    , a10   , betasq, cc    , ctem  , stem  ,
+        x1    , x2    , x3    , x4    , x5    , x6    , x7    ,
+        x8    , xnodce, xnoi  , zcosg , zcosgl, zcosh , zcoshl,
+        zcosi , zcosil, zsing , zsingl, zsinh , zsinhl, zsini ,
+        zsinil, zx    , zy;
+
+     nm     = np;
+     em     = ep;
+     snodm  = sin(nodep);
+     cnodm  = cos(nodep);
+     sinomm = sin(argpp);
+     cosomm = cos(argpp);
+     sinim  = sin(inclp);
+     cosim  = cos(inclp);
+     emsq   = em * em;
+     betasq = 1.0 - emsq;
+     rtemsq = sqrt(betasq);
+
+     /* ----------------- initialize lunar solar terms --------------- */
+     peo    = 0.0;
+     pinco  = 0.0;
+     plo    = 0.0;
+     pgho   = 0.0;
+     pho    = 0.0;
+     day    = epoch + 18261.5 + tc / 1440.0;
+     xnodce = fmod(4.5236020 - 9.2422029e-4 * day, twopi);
+     stem   = sin(xnodce);
+     ctem   = cos(xnodce);
+     zcosil = 0.91375164 - 0.03568096 * ctem;
+     zsinil = sqrt(1.0 - zcosil * zcosil);
+     zsinhl = 0.089683511 * stem / zsinil;
+     zcoshl = sqrt(1.0 - zsinhl * zsinhl);
+     gam    = 5.8351514 + 0.0019443680 * day;
+     zx     = 0.39785416 * stem / zsinil;
+     zy     = zcoshl * ctem + 0.91744867 * zsinhl * stem;
+     zx     = atan2(zx, zy);
+     zx     = gam + zx - xnodce;
+     zcosgl = cos(zx);
+     zsingl = sin(zx);
+
+     /* ------------------------- do solar terms --------------------- */
+     zcosg = zcosgs;
+     zsing = zsings;
+     zcosi = zcosis;
+     zsini = zsinis;
+     zcosh = cnodm;
+     zsinh = snodm;
+     cc    = c1ss;
+     xnoi  = 1.0 / nm;
+
+     for (lsflg = 1; lsflg <= 2; lsflg++)
+       {
+         a1  =   zcosg * zcosh + zsing * zcosi * zsinh;
+         a3  =  -zsing * zcosh + zcosg * zcosi * zsinh;
+         a7  =  -zcosg * zsinh + zsing * zcosi * zcosh;
+         a8  =   zsing * zsini;
+         a9  =   zsing * zsinh + zcosg * zcosi * zcosh;
+         a10 =   zcosg * zsini;
+         a2  =   cosim * a7 + sinim * a8;
+         a4  =   cosim * a9 + sinim * a10;
+         a5  =  -sinim * a7 + cosim * a8;
+         a6  =  -sinim * a9 + cosim * a10;
+
+         x1  =  a1 * cosomm + a2 * sinomm;
+         x2  =  a3 * cosomm + a4 * sinomm;
+         x3  = -a1 * sinomm + a2 * cosomm;
+         x4  = -a3 * sinomm + a4 * cosomm;
+         x5  =  a5 * sinomm;
+         x6  =  a6 * sinomm;
+         x7  =  a5 * cosomm;
+         x8  =  a6 * cosomm;
+
+         z31 = 12.0 * x1 * x1 - 3.0 * x3 * x3;
+         z32 = 24.0 * x1 * x2 - 6.0 * x3 * x4;
+         z33 = 12.0 * x2 * x2 - 3.0 * x4 * x4;
+         z1  =  3.0 *  (a1 * a1 + a2 * a2) + z31 * emsq;
+         z2  =  6.0 *  (a1 * a3 + a2 * a4) + z32 * emsq;
+         z3  =  3.0 *  (a3 * a3 + a4 * a4) + z33 * emsq;
+         z11 = -6.0 * a1 * a5 + emsq *  (-24.0 * x1 * x7-6.0 * x3 * x5);
+         z12 = -6.0 *  (a1 * a6 + a3 * a5) + emsq *
+                (-24.0 * (x2 * x7 + x1 * x8) - 6.0 * (x3 * x6 + x4 * x5));
+         z13 = -6.0 * a3 * a6 + emsq * (-24.0 * x2 * x8 - 6.0 * x4 * x6);
+         z21 =  6.0 * a2 * a5 + emsq * (24.0 * x1 * x5 - 6.0 * x3 * x7);
+         z22 =  6.0 *  (a4 * a5 + a2 * a6) + emsq *
+                (24.0 * (x2 * x5 + x1 * x6) - 6.0 * (x4 * x7 + x3 * x8));
+         z23 =  6.0 * a4 * a6 + emsq * (24.0 * x2 * x6 - 6.0 * x4 * x8);
+         z1  = z1 + z1 + betasq * z31;
+         z2  = z2 + z2 + betasq * z32;
+         z3  = z3 + z3 + betasq * z33;
+         s3  = cc * xnoi;
+         s2  = -0.5 * s3 / rtemsq;
+         s4  = s3 * rtemsq;
+         s1  = -15.0 * em * s4;
+         s5  = x1 * x3 + x2 * x4;
+         s6  = x2 * x3 + x1 * x4;
+         s7  = x2 * x4 - x1 * x3;
+
+         /* ----------------------- do lunar terms ------------------- */
+         if (lsflg == 1)
+           {
+             ss1   = s1;
+             ss2   = s2;
+             ss3   = s3;
+             ss4   = s4;
+             ss5   = s5;
+             ss6   = s6;
+             ss7   = s7;
+             sz1   = z1;
+             sz2   = z2;
+             sz3   = z3;
+             sz11  = z11;
+             sz12  = z12;
+             sz13  = z13;
+             sz21  = z21;
+             sz22  = z22;
+             sz23  = z23;
+             sz31  = z31;
+             sz32  = z32;
+             sz33  = z33;
+             zcosg = zcosgl;
+             zsing = zsingl;
+             zcosi = zcosil;
+             zsini = zsinil;
+             zcosh = zcoshl * cnodm + zsinhl * snodm;
+             zsinh = snodm * zcoshl - cnodm * zsinhl;
+             cc    = c1l;
+          }
+       }
+
+     zmol = fmod(4.7199672 + 0.22997150  * day - gam, twopi);
+     zmos = fmod(6.2565837 + 0.017201977 * day, twopi);
+
+     /* ------------------------ do solar terms ---------------------- */
+     se2  =   2.0 * ss1 * ss6;
+     se3  =   2.0 * ss1 * ss7;
+     si2  =   2.0 * ss2 * sz12;
+     si3  =   2.0 * ss2 * (sz13 - sz11);
+     sl2  =  -2.0 * ss3 * sz2;
+     sl3  =  -2.0 * ss3 * (sz3 - sz1);
+     sl4  =  -2.0 * ss3 * (-21.0 - 9.0 * emsq) * zes;
+     sgh2 =   2.0 * ss4 * sz32;
+     sgh3 =   2.0 * ss4 * (sz33 - sz31);
+     sgh4 = -18.0 * ss4 * zes;
+     sh2  =  -2.0 * ss2 * sz22;
+     sh3  =  -2.0 * ss2 * (sz23 - sz21);
+
+     /* ------------------------ do lunar terms ---------------------- */
+     ee2  =   2.0 * s1 * s6;
+     e3   =   2.0 * s1 * s7;
+     xi2  =   2.0 * s2 * z12;
+     xi3  =   2.0 * s2 * (z13 - z11);
+     xl2  =  -2.0 * s3 * z2;
+     xl3  =  -2.0 * s3 * (z3 - z1);
+     xl4  =  -2.0 * s3 * (-21.0 - 9.0 * emsq) * zel;
+     xgh2 =   2.0 * s4 * z32;
+     xgh3 =   2.0 * s4 * (z33 - z31);
+     xgh4 = -18.0 * s4 * zel;
+     xh2  =  -2.0 * s2 * z22;
+     xh3  =  -2.0 * s2 * (z23 - z21);
+
+//#include "debug2.cpp"
+}  // end dscom
+
+/*-----------------------------------------------------------------------------
+*
+*                           procedure dsinit
+*
+*  this procedure provides deep space contributions to mean motion dot due
+*    to geopotential resonance with half day and one day orbits.
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    cosim, sinim-
+*    emsq        - eccentricity squared
+*    argpo       - argument of perigee
+*    s1, s2, s3, s4, s5      -
+*    ss1, ss2, ss3, ss4, ss5 -
+*    sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33 -
+*    t           - time
+*    tc          -
+*    gsto        - greenwich sidereal time                   rad
+*    mo          - mean anomaly
+*    mdot        - mean anomaly dot (rate)
+*    no          - mean motion
+*    nodeo       - right ascension of ascending node
+*    nodedot     - right ascension of ascending node dot (rate)
+*    xpidot      -
+*    z1, z3, z11, z13, z21, z23, z31, z33 -
+*    eccm        - eccentricity
+*    argpm       - argument of perigee
+*    inclm       - inclination
+*    mm          - mean anomaly
+*    xn          - mean motion
+*    nodem       - right ascension of ascending node
+*
+*  outputs       :
+*    em          - eccentricity
+*    argpm       - argument of perigee
+*    inclm       - inclination
+*    mm          - mean anomaly
+*    nm          - mean motion
+*    nodem       - right ascension of ascending node
+*    irez        - flag for resonance           0-none, 1-one day, 2-half day
+*    atime       -
+*    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433    -
+*    dedt        -
+*    didt        -
+*    dmdt        -
+*    dndt        -
+*    dnodt       -
+*    domdt       -
+*    del1, del2, del3        -
+*    ses  , sghl , sghs , sgs  , shl  , shs  , sis  , sls
+*    theta       -
+*    xfact       -
+*    xlamo       -
+*    xli         -
+*    xni
+*
+*  locals        :
+*    ainv2       -
+*    aonv        -
+*    cosisq      -
+*    eoc         -
+*    f220, f221, f311, f321, f322, f330, f441, f442, f522, f523, f542, f543  -
+*    g200, g201, g211, g300, g310, g322, g410, g422, g520, g521, g532, g533  -
+*    sini2       -
+*    temp        -
+*    temp1       -
+*    theta       -
+*    xno2        -
+*
+*  coupling      :
+*    getgravconst
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+static void dsinit
+     (
+       gravconsttype whichconst,
+       double cosim,  double emsq,   double argpo,   double s1,     double s2,
+       double s3,     double s4,     double s5,      double sinim,  double ss1,
+       double ss2,    double ss3,    double ss4,     double ss5,    double sz1,
+       double sz3,    double sz11,   double sz13,    double sz21,   double sz23,
+       double sz31,   double sz33,   double t,       double tc,     double gsto,
+       double mo,     double mdot,   double no,      double nodeo,  double nodedot,
+       double xpidot, double z1,     double z3,      double z11,    double z13,
+       double z21,    double z23,    double z31,     double z33,    double ecco,
+       double eccsq,  double& em,    double& argpm,  double& inclm, double& mm,
+       double& nm,    double& nodem,
+       int& irez,
+       double& atime, double& d2201, double& d2211,  double& d3210, double& d3222,
+       double& d4410, double& d4422, double& d5220,  double& d5232, double& d5421,
+       double& d5433, double& dedt,  double& didt,   double& dmdt,  double& dndt,
+       double& dnodt, double& domdt, double& del1,   double& del2,  double& del3,
+       double& xfact, double& xlamo, double& xli,    double& xni
+     )
+{
+     /* --------------------- local variables ------------------------ */
+     const double twopi = 2.0 * pi;
+
+     double ainv2 , aonv=0.0, cosisq, eoc, f220 , f221  , f311  ,
+          f321  , f322  , f330  , f441  , f442  , f522  , f523  ,
+          f542  , f543  , g200  , g201  , g211  , g300  , g310  ,
+          g322  , g410  , g422  , g520  , g521  , g532  , g533  ,
+          ses   , sgs   , sghl  , sghs  , shs   , shll  , sis   ,
+          sini2 , sls   , temp  , temp1 , theta , xno2  , q22   ,
+          q31   , q33   , root22, root44, root54, rptim , root32,
+          root52, x2o3  , xke   , znl   , emo   , zns   , emsqo,
+          tumin, mu, radiusearthkm, j2, j3, j4, j3oj2;
+
+     q22    = 1.7891679e-6;
+     q31    = 2.1460748e-6;
+     q33    = 2.2123015e-7;
+     root22 = 1.7891679e-6;
+     root44 = 7.3636953e-9;
+     root54 = 2.1765803e-9;
+     rptim  = 4.37526908801129966e-3; // this equates to 7.29211514668855e-5 rad/sec
+     root32 = 3.7393792e-7;
+     root52 = 1.1428639e-7;
+     x2o3   = 2.0 / 3.0;
+     znl    = 1.5835218e-4;
+     zns    = 1.19459e-5;
+
+     // sgp4fix identify constants and allow alternate values
+     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
+
+     /* -------------------- deep space initialization ------------ */
+     irez = 0;
+     if ((nm < 0.0052359877) && (nm > 0.0034906585))
+         irez = 1;
+     if ((nm >= 8.26e-3) && (nm <= 9.24e-3) && (em >= 0.5))
+         irez = 2;
+
+     /* ------------------------ do solar terms ------------------- */
+     ses  =  ss1 * zns * ss5;
+     sis  =  ss2 * zns * (sz11 + sz13);
+     sls  = -zns * ss3 * (sz1 + sz3 - 14.0 - 6.0 * emsq);
+     sghs =  ss4 * zns * (sz31 + sz33 - 6.0);
+     shs  = -zns * ss2 * (sz21 + sz23);
+     // sgp4fix for 180 deg incl
+     if ((inclm < 5.2359877e-2) || (inclm > pi - 5.2359877e-2))
+       shs = 0.0;
+     if (sinim != 0.0)
+       shs = shs / sinim;
+     sgs  = sghs - cosim * shs;
+
+     /* ------------------------- do lunar terms ------------------ */
+     dedt = ses + s1 * znl * s5;
+     didt = sis + s2 * znl * (z11 + z13);
+     dmdt = sls - znl * s3 * (z1 + z3 - 14.0 - 6.0 * emsq);
+     sghl = s4 * znl * (z31 + z33 - 6.0);
+     shll = -znl * s2 * (z21 + z23);
+     // sgp4fix for 180 deg incl
+     if ((inclm < 5.2359877e-2) || (inclm > pi - 5.2359877e-2))
+         shll = 0.0;
+     domdt = sgs + sghl;
+     dnodt = shs;
+     if (sinim != 0.0)
+       {
+         domdt = domdt - cosim / sinim * shll;
+         dnodt = dnodt + shll / sinim;
+       }
+
+     /* ----------- calculate deep space resonance effects -------- */
+     dndt   = 0.0;
+     theta  = fmod(gsto + tc * rptim, twopi);
+     em     = em + dedt * t;
+     inclm  = inclm + didt * t;
+     argpm  = argpm + domdt * t;
+     nodem  = nodem + dnodt * t;
+     mm     = mm + dmdt * t;
+     //   sgp4fix for negative inclinations
+     //   the following if statement should be commented out
+     //if (inclm < 0.0)
+     //  {
+     //    inclm  = -inclm;
+     //    argpm  = argpm - pi;
+     //    nodem = nodem + pi;
+     //  }
+
+     /* -------------- initialize the resonance terms ------------- */
+     if (irez != 0)
+       {
+         aonv = pow(nm / xke, x2o3);
+
+         /* ---------- geopotential resonance for 12 hour orbits ------ */
+         if (irez == 2)
+           {
+             cosisq = cosim * cosim;
+             emo    = em;
+             em     = ecco;
+             emsqo  = emsq;
+             emsq   = eccsq;
+             eoc    = em * emsq;
+             g201   = -0.306 - (em - 0.64) * 0.440;
+
+             if (em <= 0.65)
+               {
+                 g211 =    3.616  -  13.2470 * em +  16.2900 * emsq;
+                 g310 =  -19.302  + 117.3900 * em - 228.4190 * emsq +  156.5910 * eoc;
+                 g322 =  -18.9068 + 109.7927 * em - 214.6334 * emsq +  146.5816 * eoc;
+                 g410 =  -41.122  + 242.6940 * em - 471.0940 * emsq +  313.9530 * eoc;
+                 g422 = -146.407  + 841.8800 * em - 1629.014 * emsq + 1083.4350 * eoc;
+                 g520 = -532.114  + 3017.977 * em - 5740.032 * emsq + 3708.2760 * eoc;
+               }
+               else
+               {
+                 g211 =   -72.099 +   331.819 * em -   508.738 * emsq +   266.724 * eoc;
+                 g310 =  -346.844 +  1582.851 * em -  2415.925 * emsq +  1246.113 * eoc;
+                 g322 =  -342.585 +  1554.908 * em -  2366.899 * emsq +  1215.972 * eoc;
+                 g410 = -1052.797 +  4758.686 * em -  7193.992 * emsq +  3651.957 * eoc;
+                 g422 = -3581.690 + 16178.110 * em - 24462.770 * emsq + 12422.520 * eoc;
+                 if (em > 0.715)
+                     g520 =-5149.66 + 29936.92 * em - 54087.36 * emsq + 31324.56 * eoc;
+                   else
+                     g520 = 1464.74 -  4664.75 * em +  3763.64 * emsq;
+               }
+             if (em < 0.7)
+               {
+                 g533 = -919.22770 + 4988.6100 * em - 9064.7700 * emsq + 5542.21  * eoc;
+                 g521 = -822.71072 + 4568.6173 * em - 8491.4146 * emsq + 5337.524 * eoc;
+                 g532 = -853.66600 + 4690.2500 * em - 8624.7700 * emsq + 5341.4  * eoc;
+               }
+               else
+               {
+                 g533 =-37995.780 + 161616.52 * em - 229838.20 * emsq + 109377.94 * eoc;
+                 g521 =-51752.104 + 218913.95 * em - 309468.16 * emsq + 146349.42 * eoc;
+                 g532 =-40023.880 + 170470.89 * em - 242699.48 * emsq + 115605.82 * eoc;
+               }
+
+             sini2=  sinim * sinim;
+             f220 =  0.75 * (1.0 + 2.0 * cosim+cosisq);
+             f221 =  1.5 * sini2;
+             f321 =  1.875 * sinim  *  (1.0 - 2.0 * cosim - 3.0 * cosisq);
+             f322 = -1.875 * sinim  *  (1.0 + 2.0 * cosim - 3.0 * cosisq);
+             f441 = 35.0 * sini2 * f220;
+             f442 = 39.3750 * sini2 * sini2;
+             f522 =  9.84375 * sinim * (sini2 * (1.0 - 2.0 * cosim- 5.0 * cosisq) +
+                     0.33333333 * (-2.0 + 4.0 * cosim + 6.0 * cosisq) );
+             f523 = sinim * (4.92187512 * sini2 * (-2.0 - 4.0 * cosim +
+                    10.0 * cosisq) + 6.56250012 * (1.0+2.0 * cosim - 3.0 * cosisq));
+             f542 = 29.53125 * sinim * (2.0 - 8.0 * cosim+cosisq *
+                    (-12.0 + 8.0 * cosim + 10.0 * cosisq));
+             f543 = 29.53125 * sinim * (-2.0 - 8.0 * cosim+cosisq *
+                    (12.0 + 8.0 * cosim - 10.0 * cosisq));
+             xno2  =  nm * nm;
+             ainv2 =  aonv * aonv;
+             temp1 =  3.0 * xno2 * ainv2;
+             temp  =  temp1 * root22;
+             d2201 =  temp * f220 * g201;
+             d2211 =  temp * f221 * g211;
+             temp1 =  temp1 * aonv;
+             temp  =  temp1 * root32;
+             d3210 =  temp * f321 * g310;
+             d3222 =  temp * f322 * g322;
+             temp1 =  temp1 * aonv;
+             temp  =  2.0 * temp1 * root44;
+             d4410 =  temp * f441 * g410;
+             d4422 =  temp * f442 * g422;
+             temp1 =  temp1 * aonv;
+             temp  =  temp1 * root52;
+             d5220 =  temp * f522 * g520;
+             d5232 =  temp * f523 * g532;
+             temp  =  2.0 * temp1 * root54;
+             d5421 =  temp * f542 * g521;
+             d5433 =  temp * f543 * g533;
+             xlamo =  fmod(mo + nodeo + nodeo-theta - theta, twopi);
+             xfact =  mdot + dmdt + 2.0 * (nodedot + dnodt - rptim) - no;
+             em    = emo;
+             emsq  = emsqo;
+           }
+
+         /* ---------------- synchronous resonance terms -------------- */
+         if (irez == 1)
+           {
+             g200  = 1.0 + emsq * (-2.5 + 0.8125 * emsq);
+             g310  = 1.0 + 2.0 * emsq;
+             g300  = 1.0 + emsq * (-6.0 + 6.60937 * emsq);
+             f220  = 0.75 * (1.0 + cosim) * (1.0 + cosim);
+             f311  = 0.9375 * sinim * sinim * (1.0 + 3.0 * cosim) - 0.75 * (1.0 + cosim);
+             f330  = 1.0 + cosim;
+             f330  = 1.875 * f330 * f330 * f330;
+             del1  = 3.0 * nm * nm * aonv * aonv;
+             del2  = 2.0 * del1 * f220 * g200 * q22;
+             del3  = 3.0 * del1 * f330 * g300 * q33 * aonv;
+             del1  = del1 * f311 * g310 * q31 * aonv;
+             xlamo = fmod(mo + nodeo + argpo - theta, twopi);
+             xfact = mdot + xpidot - rptim + dmdt + domdt + dnodt - no;
+           }
+
+         /* ------------ for sgp4, initialize the integrator ---------- */
+         xli   = xlamo;
+         xni   = no;
+         atime = 0.0;
+         nm    = no + dndt;
+       }
+
+//#include "debug3.cpp"
+}  // end dsinit
+
+/*-----------------------------------------------------------------------------
+*
+*                           procedure dspace
+*
+*  this procedure provides deep space contributions to mean elements for
+*    perturbing third body.  these effects have been averaged over one
+*    revolution of the sun and moon.  for earth resonance effects, the
+*    effects have been averaged over no revolutions of the satellite.
+*    (mean motion)
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433 -
+*    dedt        -
+*    del1, del2, del3  -
+*    didt        -
+*    dmdt        -
+*    dnodt       -
+*    domdt       -
+*    irez        - flag for resonance           0-none, 1-one day, 2-half day
+*    argpo       - argument of perigee
+*    argpdot     - argument of perigee dot (rate)
+*    t           - time
+*    tc          -
+*    gsto        - gst
+*    xfact       -
+*    xlamo       -
+*    no          - mean motion
+*    atime       -
+*    em          - eccentricity
+*    ft          -
+*    argpm       - argument of perigee
+*    inclm       - inclination
+*    xli         -
+*    mm          - mean anomaly
+*    xni         - mean motion
+*    nodem       - right ascension of ascending node
+*
+*  outputs       :
+*    atime       -
+*    em          - eccentricity
+*    argpm       - argument of perigee
+*    inclm       - inclination
+*    xli         -
+*    mm          - mean anomaly
+*    xni         -
+*    nodem       - right ascension of ascending node
+*    dndt        -
+*    nm          - mean motion
+*
+*  locals        :
+*    delt        -
+*    ft          -
+*    theta       -
+*    x2li        -
+*    x2omi       -
+*    xl          -
+*    xldot       -
+*    xnddt       -
+*    xndt        -
+*    xomi        -
+*
+*  coupling      :
+*    none        -
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+static void dspace
+     (
+       int irez,
+       double d2201,  double d2211,  double d3210,   double d3222,  double d4410,
+       double d4422,  double d5220,  double d5232,   double d5421,  double d5433,
+       double dedt,   double del1,   double del2,    double del3,   double didt,
+       double dmdt,   double dnodt,  double domdt,   double argpo,  double argpdot,
+       double t,      double tc,     double gsto,    double xfact,  double xlamo,
+       double no,
+       double& atime, double& em,    double& argpm,  double& inclm, double& xli,
+       double& mm,    double& xni,   double& nodem,  double& dndt,  double& nm
+     )
+{
+     const double twopi = 2.0 * pi;
+     int iretn , iret;
+     double delt, ft, theta, x2li, x2omi, xl, xldot , xnddt, xndt, xomi, g22, g32,
+          g44, g52, g54, fasx2, fasx4, fasx6, rptim , step2, stepn , stepp;
+
+     ft    = 0.0;
+     fasx2 = 0.13130908;
+     fasx4 = 2.8843198;
+     fasx6 = 0.37448087;
+     g22   = 5.7686396;
+     g32   = 0.95240898;
+     g44   = 1.8014998;
+     g52   = 1.0508330;
+     g54   = 4.4108898;
+     rptim = 4.37526908801129966e-3; // this equates to 7.29211514668855e-5 rad/sec
+     stepp =    720.0;
+     stepn =   -720.0;
+     step2 = 259200.0;
+
+     /* ----------- calculate deep space resonance effects ----------- */
+     dndt   = 0.0;
+     theta  = fmod(gsto + tc * rptim, twopi);
+     em     = em + dedt * t;
+
+     inclm  = inclm + didt * t;
+     argpm  = argpm + domdt * t;
+     nodem  = nodem + dnodt * t;
+     mm     = mm + dmdt * t;
+
+     //   sgp4fix for negative inclinations
+     //   the following if statement should be commented out
+     //  if (inclm < 0.0)
+     // {
+     //    inclm = -inclm;
+     //    argpm = argpm - pi;
+     //    nodem = nodem + pi;
+     //  }
+
+     /* - update resonances : numerical (euler-maclaurin) integration - */
+     /* ------------------------- epoch restart ----------------------  */
+     //   sgp4fix for propagator problems
+     //   the following integration works for negative time steps and periods
+     //   the specific changes are unknown because the original code was so convoluted
+
+     ft    = 0.0;
+     atime = 0.0;
+     if (irez != 0)
+       {
+         if ((atime == 0.0) || ((t >= 0.0) && (atime < 0.0)) ||
+             ((t < 0.0) && (atime >= 0.0)))
+           {
+             if (t >= 0.0)
+                 delt = stepp;
+               else
+                 delt = stepn;
+             atime  = 0.0;
+             xni    = no;
+             xli    = xlamo;
+           }
+         iretn = 381; // added for do loop
+         iret  =   0; // added for loop
+         while (iretn == 381)
+           {
+             if ((fabs(t) < fabs(atime)) || (iret == 351))
+               {
+                 if (t >= 0.0)
+                     delt = stepn;
+                   else
+                     delt = stepp;
+                 iret  = 351;
+                 iretn = 381;
+               }
+               else
+               {
+                 if (t > 0.0)  // error if prev if has atime:=0.0 and t:=0.0 (ge)
+                     delt = stepp;
+                   else
+                     delt = stepn;
+                 if (fabs(t - atime) >= stepp)
+                   {
+                     iret  = 0;
+                     iretn = 381;
+                   }
+                   else
+                   {
+                     ft    = t - atime;
+                     iretn = 0;
+                   }
+               }
+
+             /* ------------------- dot terms calculated ------------- */
+             /* ----------- near - synchronous resonance terms ------- */
+             if (irez != 2)
+               {
+                 xndt  = del1 * sin(xli - fasx2) + del2 * sin(2.0 * (xli - fasx4)) +
+                         del3 * sin(3.0 * (xli - fasx6));
+                 xldot = xni + xfact;
+                 xnddt = del1 * cos(xli - fasx2) +
+                         2.0 * del2 * cos(2.0 * (xli - fasx4)) +
+                         3.0 * del3 * cos(3.0 * (xli - fasx6));
+                 xnddt = xnddt * xldot;
+               }
+               else
+               {
+                 /* --------- near - half-day resonance terms -------- */
+                 xomi  = argpo + argpdot * atime;
+                 x2omi = xomi + xomi;
+                 x2li  = xli + xli;
+                 xndt  = d2201 * sin(x2omi + xli - g22) + d2211 * sin(xli - g22) +
+                       d3210 * sin(xomi + xli - g32)  + d3222 * sin(-xomi + xli - g32)+
+                       d4410 * sin(x2omi + x2li - g44)+ d4422 * sin(x2li - g44) +
+                       d5220 * sin(xomi + xli - g52)  + d5232 * sin(-xomi + xli - g52)+
+                       d5421 * sin(xomi + x2li - g54) + d5433 * sin(-xomi + x2li - g54);
+                 xldot = xni + xfact;
+                 xnddt = d2201 * cos(x2omi + xli - g22) + d2211 * cos(xli - g22) +
+                       d3210 * cos(xomi + xli - g32) + d3222 * cos(-xomi + xli - g32) +
+                       d5220 * cos(xomi + xli - g52) + d5232 * cos(-xomi + xli - g52) +
+                       2.0 * (d4410 * cos(x2omi + x2li - g44) +
+                       d4422 * cos(x2li - g44) + d5421 * cos(xomi + x2li - g54) +
+                       d5433 * cos(-xomi + x2li - g54));
+                 xnddt = xnddt * xldot;
+               }
+
+             /* ----------------------- integrator ------------------- */
+             if (iretn == 381)
+               {
+                 xli   = xli + xldot * delt + xndt * step2;
+                 xni   = xni + xndt * delt + xnddt * step2;
+                 atime = atime + delt;
+               }
+           }  // while iretn = 381
+
+         nm = xni + xndt * ft + xnddt * ft * ft * 0.5;
+         xl = xli + xldot * ft + xndt * ft * ft * 0.5;
+         if (irez != 1)
+           {
+             mm   = xl - 2.0 * nodem + 2.0 * theta;
+             dndt = nm - no;
+           }
+           else
+           {
+             mm   = xl - nodem - argpm + theta;
+             dndt = nm - no;
+           }
+         nm = no + dndt;
+       }
+
+//#include "debug4.cpp"
+}  // end dsspace
+
+/*-----------------------------------------------------------------------------
+*
+*                           procedure initl
+*
+*  this procedure initializes the spg4 propagator. all the initialization is
+*    consolidated here instead of having multiple loops inside other routines.
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    ecco        - eccentricity                           0.0 - 1.0
+*    epoch       - epoch time in days from jan 0, 1950. 0 hr
+*    inclo       - inclination of satellite
+*    no          - mean motion of satellite
+*    satn        - satellite number
+*
+*  outputs       :
+*    ainv        - 1.0 / a
+*    ao          - semi major axis
+*    con41       -
+*    con42       - 1.0 - 5.0 cos(i)
+*    cosio       - cosine of inclination
+*    cosio2      - cosio squared
+*    eccsq       - eccentricity squared
+*    method      - flag for deep space                    'd', 'n'
+*    omeosq      - 1.0 - ecco * ecco
+*    posq        - semi-parameter squared
+*    rp          - radius of perigee
+*    rteosq      - square root of (1.0 - ecco*ecco)
+*    sinio       - sine of inclination
+*    gsto        - gst at time of observation               rad
+*    no          - mean motion of satellite
+*
+*  locals        :
+*    ak          -
+*    d1          -
+*    del         -
+*    adel        -
+*    po          -
+*
+*  coupling      :
+*    getgravconst
+*    gstime      - find greenwich sidereal time from the julian date
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+static void initl
+     (
+       int satn,      gravconsttype whichconst,
+       double ecco,   double epoch,  double inclo,   double& no,
+       char& method,
+       double& ainv,  double& ao,    double& con41,  double& con42, double& cosio,
+       double& cosio2,double& eccsq, double& omeosq, double& posq,
+       double& rp,    double& rteosq,double& sinio , double& gsto
+     )
+{
+     /* --------------------- local variables ------------------------ */
+     double ak, d1, del, adel, po, x2o3, j2, xke,
+            tumin, mu, radiusearthkm, j3, j4, j3oj2;
+
+     // sgp4fix use old way of finding gst
+     int ids70;
+     double ts70, ds70, tfrac, c1, thgr70, fk5r, c1p2p;
+     const double twopi = 2.0 * pi;
+
+     /* ----------------------- earth constants ---------------------- */
+     // sgp4fix identify constants and allow alternate values
+     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
+     x2o3   = 2.0 / 3.0;
+
+     /* ------------- calculate auxillary epoch quantities ---------- */
+     eccsq  = ecco * ecco;
+     omeosq = 1.0 - eccsq;
+     rteosq = sqrt(omeosq);
+     cosio  = cos(inclo);
+     cosio2 = cosio * cosio;
+
+     /* ------------------ un-kozai the mean motion ----------------- */
+     ak    = pow(xke / no, x2o3);
+     d1    = 0.75 * j2 * (3.0 * cosio2 - 1.0) / (rteosq * omeosq);
+     del   = d1 / (ak * ak);
+     adel  = ak * (1.0 - del * del - del *
+             (1.0 / 3.0 + 134.0 * del * del / 81.0));
+     del   = d1/(adel * adel);
+     no    = no / (1.0 + del);
+
+     ao    = pow(xke / no, x2o3);
+     sinio = sin(inclo);
+     po    = ao * omeosq;
+     con42 = 1.0 - 5.0 * cosio2;
+     con41 = -con42-cosio2-cosio2;
+     ainv  = 1.0 / ao;
+     posq  = po * po;
+     rp    = ao * (1.0 - ecco);
+     method = 'n';
+
+     // sgp4fix modern approach to finding sidereal timew
+     // gsto = gstime(epoch + 2433281.5);
+
+     // sgp4fix use old way of finding gst
+     // count integer number of days from 0 jan 1970
+     ts70  = epoch - 7305.0;
+     ids70 = floor(ts70 + 1.0e-8);
+     ds70  = ids70;
+     tfrac = ts70 - ds70;
+     // find greenwich location at epoch
+     c1    = 1.72027916940703639e-2;
+     thgr70= 1.7321343856509374;
+     fk5r  = 5.07551419432269442e-15;
+     c1p2p = c1 + twopi;
+     gsto  = fmod( thgr70 + c1*ds70 + c1p2p*tfrac + ts70*ts70*fk5r, twopi);
+     if ( gsto < 0.0 )
+         gsto = gsto + twopi;
+
+//#include "debug5.cpp"
+}  // end initl
+
+/*-----------------------------------------------------------------------------
+*
+*                             procedure sgp4init
+*
+*  this procedure initializes variables for sgp4.
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    satn        - satellite number
+*    bstar       - sgp4 type drag coefficient              kg/m2er
+*    ecco        - eccentricity
+*    epoch       - epoch time in days from jan 0, 1950. 0 hr
+*    argpo       - argument of perigee (output if ds)
+*    inclo       - inclination
+*    mo          - mean anomaly (output if ds)
+*    no          - mean motion
+*    nodeo       - right ascension of ascending node
+*
+*  outputs       :
+*    satrec      - common values for subsequent calls
+*    return code - non-zero on error.
+*                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
+*                   2 - mean motion less than 0.0
+*                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
+*                   4 - semi-latus rectum < 0.0
+*                   5 - epoch elements are sub-orbital
+*                   6 - satellite has decayed
+*
+*  locals        :
+*    cnodm  , snodm  , cosim  , sinim  , cosomm , sinomm
+*    cc1sq  , cc2    , cc3
+*    coef   , coef1
+*    cosio4      -
+*    day         -
+*    dndt        -
+*    em          - eccentricity
+*    emsq        - eccentricity squared
+*    eeta        -
+*    etasq       -
+*    gam         -
+*    argpm       - argument of perigee
+*    nodem       -
+*    inclm       - inclination
+*    mm          - mean anomaly
+*    nm          - mean motion
+*    perige      - perigee
+*    pinvsq      -
+*    psisq       -
+*    qzms24      -
+*    rtemsq      -
+*    s1, s2, s3, s4, s5, s6, s7          -
+*    sfour       -
+*    ss1, ss2, ss3, ss4, ss5, ss6, ss7         -
+*    sz1, sz2, sz3
+*    sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33        -
+*    tc          -
+*    temp        -
+*    temp1, temp2, temp3       -
+*    tsi         -
+*    xpidot      -
+*    xhdot1      -
+*    z1, z2, z3          -
+*    z11, z12, z13, z21, z22, z23, z31, z32, z33         -
+*
+*  coupling      :
+*    getgravconst-
+*    initl       -
+*    dscom       -
+*    dpper       -
+*    dsinit      -
+*    sgp4        -
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+int sgp4init
+     (
+       gravconsttype whichconst,       const int satn,     const double epoch,
+       const double xbstar,  const double xecco, const double xargpo,
+       const double xinclo,  const double xmo,   const double xno,
+       const double xnodeo,  elsetrec& satrec
+     )
+{
+     /* --------------------- local variables ------------------------ */
+     double ao, ainv,   con42, cosio, sinio, cosio2, eccsq,
+          omeosq, posq,   rp,     rteosq,
+          cnodm , snodm , cosim , sinim , cosomm, sinomm, cc1sq ,
+          cc2   , cc3   , coef  , coef1 , cosio4, day   , dndt  ,
+          em    , emsq  , eeta  , etasq , gam   , argpm , nodem ,
+          inclm , mm    , nm    , perige, pinvsq, psisq , qzms24,
+          rtemsq, s1    , s2    , s3    , s4    , s5    , s6    ,
+          s7    , sfour , ss1 = 0   , ss2 = 0   , ss3 = 0   , ss4 = 0   , ss5 = 0   ,
+          ss6 = 0   , ss7 = 0   , sz1 = 0   , sz2 = 0   , sz3 = 0   , sz11 = 0  , sz12 = 0  ,
+          sz13 = 0  , sz21 = 0  , sz22 = 0  , sz23 = 0  , sz31 = 0  , sz32 = 0  , sz33 = 0  ,
+          tc    , temp  , temp1 , temp2 , temp3 , tsi   , xpidot,
+          xhdot1, z1    , z2    , z3    , z11   , z12   , z13   ,
+          z21   , z22   , z23   , z31   , z32   , z33,
+          qzms2t, ss, j2, j3oj2, j4, x2o3, r[3], v[3],
+          tumin, mu, radiusearthkm, xke, j3;
+
+     /* ------------------------ initialization --------------------- */
+     // sgp4fix divisor for divide by zero check on inclination
+     const double temp4    =   1.0 + cos(pi-1.0e-9);
+
+     /* ----------- set all near earth variables to zero ------------ */
+     satrec.isimp   = 0;   satrec.method = 'n'; satrec.aycof    = 0.0;
+     satrec.con41   = 0.0; satrec.cc1    = 0.0; satrec.cc4      = 0.0;
+     satrec.cc5     = 0.0; satrec.d2     = 0.0; satrec.d3       = 0.0;
+     satrec.d4      = 0.0; satrec.delmo  = 0.0; satrec.eta      = 0.0;
+     satrec.argpdot = 0.0; satrec.omgcof = 0.0; satrec.sinmao   = 0.0;
+     satrec.t       = 0.0; satrec.t2cof  = 0.0; satrec.t3cof    = 0.0;
+     satrec.t4cof   = 0.0; satrec.t5cof  = 0.0; satrec.x1mth2   = 0.0;
+     satrec.x7thm1  = 0.0; satrec.mdot   = 0.0; satrec.nodedot  = 0.0;
+     satrec.xlcof   = 0.0; satrec.xmcof  = 0.0; satrec.nodecf   = 0.0;
+
+     /* ----------- set all deep space variables to zero ------------ */
+     satrec.irez  = 0;   satrec.d2201 = 0.0; satrec.d2211 = 0.0;
+     satrec.d3210 = 0.0; satrec.d3222 = 0.0; satrec.d4410 = 0.0;
+     satrec.d4422 = 0.0; satrec.d5220 = 0.0; satrec.d5232 = 0.0;
+     satrec.d5421 = 0.0; satrec.d5433 = 0.0; satrec.dedt  = 0.0;
+     satrec.del1  = 0.0; satrec.del2  = 0.0; satrec.del3  = 0.0;
+     satrec.didt  = 0.0; satrec.dmdt  = 0.0; satrec.dnodt = 0.0;
+     satrec.domdt = 0.0; satrec.e3    = 0.0; satrec.ee2   = 0.0;
+     satrec.peo   = 0.0; satrec.pgho  = 0.0; satrec.pho   = 0.0;
+     satrec.pinco = 0.0; satrec.plo   = 0.0; satrec.se2   = 0.0;
+     satrec.se3   = 0.0; satrec.sgh2  = 0.0; satrec.sgh3  = 0.0;
+     satrec.sgh4  = 0.0; satrec.sh2   = 0.0; satrec.sh3   = 0.0;
+     satrec.si2   = 0.0; satrec.si3   = 0.0; satrec.sl2   = 0.0;
+     satrec.sl3   = 0.0; satrec.sl4   = 0.0; satrec.gsto  = 0.0;
+     satrec.xfact = 0.0; satrec.xgh2  = 0.0; satrec.xgh3  = 0.0;
+     satrec.xgh4  = 0.0; satrec.xh2   = 0.0; satrec.xh3   = 0.0;
+     satrec.xi2   = 0.0; satrec.xi3   = 0.0; satrec.xl2   = 0.0;
+     satrec.xl3   = 0.0; satrec.xl4   = 0.0; satrec.xlamo = 0.0;
+     satrec.zmol  = 0.0; satrec.zmos  = 0.0; satrec.atime = 0.0;
+     satrec.xli   = 0.0; satrec.xni   = 0.0;
+
+     // sgp4fix - note the following variables are also passed directly via satrec.
+     // it is possible to streamline the sgp4init call by deleting the "x"
+     // variables, but the user would need to set the satrec.* values first. we
+     // include the additional assignments in case twoline2rv is not used.
+     satrec.bstar   = xbstar;
+     satrec.ecco    = xecco;
+     satrec.argpo   = xargpo;
+     satrec.inclo   = xinclo;
+     satrec.mo	    = xmo;
+     satrec.no	    = xno;
+     satrec.nodeo   = xnodeo;
+
+     /* ------------------------ earth constants ----------------------- */
+     // sgp4fix identify constants and allow alternate values
+     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
+     ss     = 78.0 / radiusearthkm + 1.0;
+     qzms2t = pow(((120.0 - 78.0) / radiusearthkm), 4);
+     x2o3   =  2.0 / 3.0;
+
+     satrec.init = 'y';
+     satrec.t	 = 0.0;
+
+     initl
+         (
+           satn, whichconst, satrec.ecco, epoch, satrec.inclo, satrec.no, satrec.method,
+           ainv, ao, satrec.con41, con42, cosio, cosio2, eccsq, omeosq,
+           posq, rp, rteosq, sinio, satrec.gsto
+         );
+     satrec.error = 0;
+
+     if (rp < 1.0)
+       {
+//         printf("# *** satn%d epoch elts sub-orbital ***\n", satn);
+         satrec.error = 5;
+       }
+
+     if ((omeosq >= 0.0 ) || ( satrec.no >= 0.0))
+       {
+         satrec.isimp = 0;
+         if (rp < (220.0 / radiusearthkm + 1.0))
+             satrec.isimp = 1;
+         sfour  = ss;
+         qzms24 = qzms2t;
+         perige = (rp - 1.0) * radiusearthkm;
+
+         /* - for perigees below 156 km, s and qoms2t are altered - */
+         if (perige < 156.0)
+           {
+             sfour = perige - 78.0;
+             if (perige < 98.0)
+                 sfour = 20.0;
+             qzms24 = pow(((120.0 - sfour) / radiusearthkm), 4.0);
+             sfour  = sfour / radiusearthkm + 1.0;
+           }
+         pinvsq = 1.0 / posq;
+
+         tsi  = 1.0 / (ao - sfour);
+         satrec.eta  = ao * satrec.ecco * tsi;
+         etasq = satrec.eta * satrec.eta;
+         eeta  = satrec.ecco * satrec.eta;
+         psisq = fabs(1.0 - etasq);
+         coef  = qzms24 * pow(tsi, 4.0);
+         coef1 = coef / pow(psisq, 3.5);
+         cc2   = coef1 * satrec.no * (ao * (1.0 + 1.5 * etasq + eeta *
+                        (4.0 + etasq)) + 0.375 * j2 * tsi / psisq * satrec.con41 *
+                        (8.0 + 3.0 * etasq * (8.0 + etasq)));
+         satrec.cc1   = satrec.bstar * cc2;
+         cc3   = 0.0;
+         if (satrec.ecco > 1.0e-4)
+             cc3 = -2.0 * coef * tsi * j3oj2 * satrec.no * sinio / satrec.ecco;
+         satrec.x1mth2 = 1.0 - cosio2;
+         satrec.cc4    = 2.0* satrec.no * coef1 * ao * omeosq *
+                           (satrec.eta * (2.0 + 0.5 * etasq) + satrec.ecco *
+                           (0.5 + 2.0 * etasq) - j2 * tsi / (ao * psisq) *
+                           (-3.0 * satrec.con41 * (1.0 - 2.0 * eeta + etasq *
+                           (1.5 - 0.5 * eeta)) + 0.75 * satrec.x1mth2 *
+                           (2.0 * etasq - eeta * (1.0 + etasq)) * cos(2.0 * satrec.argpo)));
+         satrec.cc5 = 2.0 * coef1 * ao * omeosq * (1.0 + 2.75 *
+                        (etasq + eeta) + eeta * etasq);
+         cosio4 = cosio2 * cosio2;
+         temp1  = 1.5 * j2 * pinvsq * satrec.no;
+         temp2  = 0.5 * temp1 * j2 * pinvsq;
+         temp3  = -0.46875 * j4 * pinvsq * pinvsq * satrec.no;
+         satrec.mdot     = satrec.no + 0.5 * temp1 * rteosq * satrec.con41 + 0.0625 *
+                            temp2 * rteosq * (13.0 - 78.0 * cosio2 + 137.0 * cosio4);
+         satrec.argpdot  = -0.5 * temp1 * con42 + 0.0625 * temp2 *
+                             (7.0 - 114.0 * cosio2 + 395.0 * cosio4) +
+                             temp3 * (3.0 - 36.0 * cosio2 + 49.0 * cosio4);
+         xhdot1            = -temp1 * cosio;
+         satrec.nodedot = xhdot1 + (0.5 * temp2 * (4.0 - 19.0 * cosio2) +
+                              2.0 * temp3 * (3.0 - 7.0 * cosio2)) * cosio;
+         xpidot            =  satrec.argpdot+ satrec.nodedot;
+         satrec.omgcof   = satrec.bstar * cc3 * cos(satrec.argpo);
+         satrec.xmcof    = 0.0;
+         if (satrec.ecco > 1.0e-4)
+             satrec.xmcof = -x2o3 * coef * satrec.bstar / eeta;
+         satrec.nodecf = 3.5 * omeosq * xhdot1 * satrec.cc1;
+         satrec.t2cof   = 1.5 * satrec.cc1;
+         // sgp4fix for divide by zero with xinco = 180 deg
+         if (fabs(cosio+1.0) > 1.5e-12)
+             satrec.xlcof = -0.25 * j3oj2 * sinio * (3.0 + 5.0 * cosio) / (1.0 + cosio);
+           else
+             satrec.xlcof = -0.25 * j3oj2 * sinio * (3.0 + 5.0 * cosio) / temp4;
+         satrec.aycof   = -0.5 * j3oj2 * sinio;
+         satrec.delmo   = pow((1.0 + satrec.eta * cos(satrec.mo)), 3);
+         satrec.sinmao  = sin(satrec.mo);
+         satrec.x7thm1  = 7.0 * cosio2 - 1.0;
+
+         /* --------------- deep space initialization ------------- */
+         if ((2*pi / satrec.no) >= 225.0)
+           {
+             satrec.method = 'd';
+             satrec.isimp  = 1;
+             tc    =  0.0;
+             inclm = satrec.inclo;
+
+             dscom
+                 (
+                   epoch, satrec.ecco, satrec.argpo, tc, satrec.inclo, satrec.nodeo,
+                   satrec.no, snodm, cnodm,  sinim, cosim,sinomm,     cosomm,
+                   day, satrec.e3, satrec.ee2, em,         emsq, gam,
+                   satrec.peo,  satrec.pgho,   satrec.pho, satrec.pinco,
+                   satrec.plo,  rtemsq,        satrec.se2, satrec.se3,
+                   satrec.sgh2, satrec.sgh3,   satrec.sgh4,
+                   satrec.sh2,  satrec.sh3,    satrec.si2, satrec.si3,
+                   satrec.sl2,  satrec.sl3,    satrec.sl4, s1, s2, s3, s4, s5,
+                   s6,   s7,   ss1,  ss2,  ss3,  ss4,  ss5,  ss6,  ss7, sz1, sz2, sz3,
+                   sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33,
+                   satrec.xgh2, satrec.xgh3,   satrec.xgh4, satrec.xh2,
+                   satrec.xh3,  satrec.xi2,    satrec.xi3,  satrec.xl2,
+                   satrec.xl3,  satrec.xl4,    nm, z1, z2, z3, z11,
+                   z12, z13, z21, z22, z23, z31, z32, z33,
+                   satrec.zmol, satrec.zmos
+                 );
+             dpper
+                 (
+                   satrec.e3, satrec.ee2, satrec.peo, satrec.pgho,
+                   satrec.pho, satrec.pinco, satrec.plo, satrec.se2,
+                   satrec.se3, satrec.sgh2, satrec.sgh3, satrec.sgh4,
+                   satrec.sh2, satrec.sh3, satrec.si2,  satrec.si3,
+                   satrec.sl2, satrec.sl3, satrec.sl4,  satrec.t,
+                   satrec.xgh2,satrec.xgh3,satrec.xgh4, satrec.xh2,
+                   satrec.xh3, satrec.xi2, satrec.xi3,  satrec.xl2,
+                   satrec.xl3, satrec.xl4, satrec.zmol, satrec.zmos, inclm, satrec.init,
+                   satrec.ecco, satrec.inclo, satrec.nodeo, satrec.argpo, satrec.mo
+                 );
+
+             argpm  = 0.0;
+             nodem  = 0.0;
+             mm     = 0.0;
+
+             dsinit
+                 (
+                   whichconst,
+                   cosim, emsq, satrec.argpo, s1, s2, s3, s4, s5, sinim, ss1, ss2, ss3, ss4,
+                   ss5, sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33, satrec.t, tc,
+                   satrec.gsto, satrec.mo, satrec.mdot, satrec.no, satrec.nodeo,
+                   satrec.nodedot, xpidot, z1, z3, z11, z13, z21, z23, z31, z33,
+                   satrec.ecco, eccsq, em, argpm, inclm, mm, nm, nodem,
+                   satrec.irez,  satrec.atime,
+                   satrec.d2201, satrec.d2211, satrec.d3210, satrec.d3222 ,
+                   satrec.d4410, satrec.d4422, satrec.d5220, satrec.d5232,
+                   satrec.d5421, satrec.d5433, satrec.dedt,  satrec.didt,
+                   satrec.dmdt,  dndt,         satrec.dnodt, satrec.domdt ,
+                   satrec.del1,  satrec.del2,  satrec.del3,  satrec.xfact,
+                   satrec.xlamo, satrec.xli,   satrec.xni
+                 );
+           }
+
+       /* ----------- set variables if not deep space ----------- */
+       if (satrec.isimp != 1)
+         {
+           cc1sq          = satrec.cc1 * satrec.cc1;
+           satrec.d2    = 4.0 * ao * tsi * cc1sq;
+           temp           = satrec.d2 * tsi * satrec.cc1 / 3.0;
+           satrec.d3    = (17.0 * ao + sfour) * temp;
+           satrec.d4    = 0.5 * temp * ao * tsi * (221.0 * ao + 31.0 * sfour) *
+                            satrec.cc1;
+           satrec.t3cof = satrec.d2 + 2.0 * cc1sq;
+           satrec.t4cof = 0.25 * (3.0 * satrec.d3 + satrec.cc1 *
+                            (12.0 * satrec.d2 + 10.0 * cc1sq));
+           satrec.t5cof = 0.2 * (3.0 * satrec.d4 +
+                            12.0 * satrec.cc1 * satrec.d3 +
+                            6.0 * satrec.d2 * satrec.d2 +
+                            15.0 * cc1sq * (2.0 * satrec.d2 + cc1sq));
+         }
+       } // if omeosq = 0 ...
+
+       /* finally propogate to zero epoch to initialise all others. */
+       if(satrec.error == 0)
+           sgp4(whichconst, satrec, 0.0, r, v);
+
+       satrec.init = 'n';
+
+//#include "debug6.cpp"
+       return satrec.error;
+}  // end sgp4init
+
+/*-----------------------------------------------------------------------------
+*
+*                             procedure sgp4
+*
+*  this procedure is the sgp4 prediction model from space command. this is an
+*    updated and combined version of sgp4 and sdp4, which were originally
+*    published separately in spacetrack report #3. this version follows the
+*    methodology from the aiaa paper (2006) describing the history and
+*    development of the code.
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    satrec	 - initialised structure from sgp4init() call.
+*    tsince	 - time eince epoch (minutes)
+*
+*  outputs       :
+*    r           - position vector                     km
+*    v           - velocity                            km/sec
+*  return code - non-zero on error.
+*                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
+*                   2 - mean motion less than 0.0
+*                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
+*                   4 - semi-latus rectum < 0.0
+*                   5 - epoch elements are sub-orbital
+*                   6 - satellite has decayed
+*
+*  locals        :
+*    am          -
+*    axnl, aynl        -
+*    betal       -
+*    cosim   , sinim   , cosomm  , sinomm  , cnod    , snod    , cos2u   ,
+*    sin2u   , coseo1  , sineo1  , cosi    , sini    , cosip   , sinip   ,
+*    cosisq  , cossu   , sinsu   , cosu    , sinu
+*    delm        -
+*    delomg      -
+*    dndt        -
+*    eccm        -
+*    emsq        -
+*    ecose       -
+*    el2         -
+*    eo1         -
+*    eccp        -
+*    esine       -
+*    argpm       -
+*    argpp       -
+*    omgadf      -
+*    pl          -
+*    r           -
+*    rtemsq      -
+*    rdotl       -
+*    rl          -
+*    rvdot       -
+*    rvdotl      -
+*    su          -
+*    t2  , t3   , t4    , tc
+*    tem5, temp , temp1 , temp2  , tempa  , tempe  , templ
+*    u   , ux   , uy    , uz     , vx     , vy     , vz
+*    inclm       - inclination
+*    mm          - mean anomaly
+*    nm          - mean motion
+*    nodem       - right asc of ascending node
+*    xinc        -
+*    xincp       -
+*    xl          -
+*    xlm         -
+*    mp          -
+*    xmdf        -
+*    xmx         -
+*    xmy         -
+*    nodedf      -
+*    xnode       -
+*    nodep       -
+*    np          -
+*
+*  coupling      :
+*    getgravconst-
+*    dpper
+*    dpspace
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+int sgp4
+     (
+       gravconsttype whichconst, elsetrec& satrec,  double tsince,
+       double r[3],  double v[3]
+     )
+{
+     double am   , axnl  , aynl , betal ,  cosim , cnod  ,
+         cos2u, coseo1, cosi , cosip ,  cosisq, cossu , cosu,
+         delm , delomg, em   , emsq  ,  ecose , el2   , eo1 ,
+         ep   , esine , argpm, argpp ,  argpdf, pl,     mrt = 0.0,
+         mvt  , rdotl , rl   , rvdot ,  rvdotl, sinim ,
+         sin2u, sineo1, sini , sinip ,  sinsu , sinu  ,
+         snod , su    , t2   , t3    ,  t4    , tem5  , temp,
+         temp1, temp2 , tempa, tempe ,  templ , u     , ux  ,
+         uy   , uz    , vx   , vy    ,  vz    , inclm , mm  ,
+         nm   , nodem, xinc , xincp ,  xl    , xlm   , mp  ,
+         xmdf , xmx   , xmy  , nodedf, xnode , nodep, tc  , dndt,
+         twopi, x2o3  , j2   , j3    , tumin, j4 , xke   , j3oj2, radiusearthkm,
+         mu, vkmpersec;
+     int ktr;
+
+     /* ------------------ set mathematical constants --------------- */
+     // sgp4fix divisor for divide by zero check on inclination
+     const double temp4    =   1.0 + cos(pi-1.0e-9);
+     twopi = 2.0 * pi;
+     x2o3  = 2.0 / 3.0;
+     // sgp4fix identify constants and allow alternate values
+     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
+     vkmpersec     = radiusearthkm * xke/60.0;
+
+     /* --------------------- clear sgp4 error flag ----------------- */
+     satrec.t     = tsince;
+     satrec.error = 0;
+
+     /* ------- update for secular gravity and atmospheric drag ----- */
+     xmdf    = satrec.mo + satrec.mdot * satrec.t;
+     argpdf  = satrec.argpo + satrec.argpdot * satrec.t;
+     nodedf  = satrec.nodeo + satrec.nodedot * satrec.t;
+     argpm   = argpdf;
+     mm      = xmdf;
+     t2      = satrec.t * satrec.t;
+     nodem   = nodedf + satrec.nodecf * t2;
+     tempa   = 1.0 - satrec.cc1 * satrec.t;
+     tempe   = satrec.bstar * satrec.cc4 * satrec.t;
+     templ   = satrec.t2cof * t2;
+
+     if (satrec.isimp != 1)
+       {
+         delomg = satrec.omgcof * satrec.t;
+         delm   = satrec.xmcof *
+                  (pow((1.0 + satrec.eta * cos(xmdf)), 3) -
+                  satrec.delmo);
+         temp   = delomg + delm;
+         mm     = xmdf + temp;
+         argpm  = argpdf - temp;
+         t3     = t2 * satrec.t;
+         t4     = t3 * satrec.t;
+         tempa  = tempa - satrec.d2 * t2 - satrec.d3 * t3 -
+                          satrec.d4 * t4;
+         tempe  = tempe + satrec.bstar * satrec.cc5 * (sin(mm) -
+                          satrec.sinmao);
+         templ  = templ + satrec.t3cof * t3 + t4 * (satrec.t4cof +
+                          satrec.t * satrec.t5cof);
+       }
+
+     nm    = satrec.no;
+     em    = satrec.ecco;
+     inclm = satrec.inclo;
+     if (satrec.method == 'd')
+       {
+         tc = satrec.t;
+         dspace
+             (
+               satrec.irez,
+               satrec.d2201, satrec.d2211, satrec.d3210,
+               satrec.d3222, satrec.d4410, satrec.d4422,
+               satrec.d5220, satrec.d5232, satrec.d5421,
+               satrec.d5433, satrec.dedt,  satrec.del1,
+               satrec.del2,  satrec.del3,  satrec.didt,
+               satrec.dmdt,  satrec.dnodt, satrec.domdt,
+               satrec.argpo, satrec.argpdot, satrec.t, tc,
+               satrec.gsto, satrec.xfact, satrec.xlamo,
+               satrec.no, satrec.atime,
+               em, argpm, inclm, satrec.xli, mm, satrec.xni,
+               nodem, dndt, nm
+             );
+       } // if method = d
+
+     if (nm <= 0.0)
+       {
+//         printf("# error nm %f\n", nm);
+         satrec.error = 2;
+       }
+     am = pow((xke / nm),x2o3) * tempa * tempa;
+     nm = xke / pow(am, 1.5);
+     em = em - tempe;
+
+     // fix tolerance for error recognition
+     if ((em >= 1.0) || (em < -0.001) || (am < 0.95))
+       {
+//         printf("# error em %f\n", em);
+         satrec.error = 1;
+       }
+     if (em < 0.0)
+         em  = 1.0e-6;
+     mm     = mm + satrec.no * templ;
+     xlm    = mm + argpm + nodem;
+     emsq   = em * em;
+     temp   = 1.0 - emsq;
+
+     nodem  = fmod(nodem, twopi);
+     argpm  = fmod(argpm, twopi);
+     xlm    = fmod(xlm, twopi);
+     mm     = fmod(xlm - argpm - nodem, twopi);
+
+     /* ----------------- compute extra mean quantities ------------- */
+     sinim = sin(inclm);
+     cosim = cos(inclm);
+
+     /* -------------------- add lunar-solar periodics -------------- */
+     ep     = em;
+     xincp  = inclm;
+     argpp  = argpm;
+     nodep  = nodem;
+     mp     = mm;
+     sinip  = sinim;
+     cosip  = cosim;
+     if (satrec.method == 'd')
+       {
+         dpper
+             (
+               satrec.e3,   satrec.ee2,  satrec.peo,
+               satrec.pgho, satrec.pho,  satrec.pinco,
+               satrec.plo,  satrec.se2,  satrec.se3,
+               satrec.sgh2, satrec.sgh3, satrec.sgh4,
+               satrec.sh2,  satrec.sh3,  satrec.si2,
+               satrec.si3,  satrec.sl2,  satrec.sl3,
+               satrec.sl4,  satrec.t,    satrec.xgh2,
+               satrec.xgh3, satrec.xgh4, satrec.xh2,
+               satrec.xh3,  satrec.xi2,  satrec.xi3,
+               satrec.xl2,  satrec.xl3,  satrec.xl4,
+               satrec.zmol, satrec.zmos, satrec.inclo,
+               'n', ep, xincp, nodep, argpp, mp
+             );
+         if (xincp < 0.0)
+           {
+             xincp  = -xincp;
+             nodep = nodep + pi;
+             argpp  = argpp - pi;
+           }
+         if ((ep < 0.0 ) || ( ep > 1.0))
+           {
+ //            printf("# error ep %f\n", ep);
+             satrec.error = 3;
+           }
+       } // if method = d
+
+     /* -------------------- long period periodics ------------------ */
+     if (satrec.method == 'd')
+       {
+         sinip =  sin(xincp);
+         cosip =  cos(xincp);
+         satrec.aycof = -0.5*j3oj2*sinip;
+         // sgp4fix for divide by zero for xincp = 180 deg
+         if (fabs(cosip+1.0) > 1.5e-12)
+             satrec.xlcof = -0.25 * j3oj2 * sinip * (3.0 + 5.0 * cosip) / (1.0 + cosip);
+           else
+             satrec.xlcof = -0.25 * j3oj2 * sinip * (3.0 + 5.0 * cosip) / temp4;
+       }
+     axnl = ep * cos(argpp);
+     temp = 1.0 / (am * (1.0 - ep * ep));
+     aynl = ep* sin(argpp) + temp * satrec.aycof;
+     xl   = mp + argpp + nodep + temp * satrec.xlcof * axnl;
+
+     /* --------------------- solve kepler's equation --------------- */
+     u    = fmod(xl - nodep, twopi);
+     eo1  = u;
+     tem5 = 9999.9;
+     ktr = 1;
+     //   sgp4fix for kepler iteration
+     //   the following iteration needs better limits on corrections
+     while (( fabs(tem5) >= 1.0e-12) && (ktr <= 10) )
+       {
+         sineo1 = sin(eo1);
+         coseo1 = cos(eo1);
+         tem5   = 1.0 - coseo1 * axnl - sineo1 * aynl;
+         tem5   = (u - aynl * coseo1 + axnl * sineo1 - eo1) / tem5;
+         if(fabs(tem5) >= 0.95)
+             tem5 = tem5 > 0.0 ? 0.95 : -0.95;
+         eo1    = eo1 + tem5;
+         ktr = ktr + 1;
+       }
+
+     /* ------------- short period preliminary quantities ----------- */
+     ecose = axnl*coseo1 + aynl*sineo1;
+     esine = axnl*sineo1 - aynl*coseo1;
+     el2   = axnl*axnl + aynl*aynl;
+     pl    = am*(1.0-el2);
+     if (pl < 0.0)
+       {
+//         printf("# error pl %f\n", pl);
+         satrec.error = 4;
+       }
+       else
+       {
+         rl     = am * (1.0 - ecose);
+         rdotl  = sqrt(am) * esine/rl;
+         rvdotl = sqrt(pl) / rl;
+         betal  = sqrt(1.0 - el2);
+         temp   = esine / (1.0 + betal);
+         sinu   = am / rl * (sineo1 - aynl - axnl * temp);
+         cosu   = am / rl * (coseo1 - axnl + aynl * temp);
+         su     = atan2(sinu, cosu);
+         sin2u  = (cosu + cosu) * sinu;
+         cos2u  = 1.0 - 2.0 * sinu * sinu;
+         temp   = 1.0 / pl;
+         temp1  = 0.5 * j2 * temp;
+         temp2  = temp1 * temp;
+
+         /* -------------- update for short period periodics ------------ */
+         if (satrec.method == 'd')
+           {
+             cosisq                 = cosip * cosip;
+             satrec.con41  = 3.0*cosisq - 1.0;
+             satrec.x1mth2 = 1.0 - cosisq;
+             satrec.x7thm1 = 7.0*cosisq - 1.0;
+           }
+         mrt   = rl * (1.0 - 1.5 * temp2 * betal * satrec.con41) +
+                 0.5 * temp1 * satrec.x1mth2 * cos2u;
+         su    = su - 0.25 * temp2 * satrec.x7thm1 * sin2u;
+         xnode = nodep + 1.5 * temp2 * cosip * sin2u;
+         xinc  = xincp + 1.5 * temp2 * cosip * sinip * cos2u;
+         mvt   = rdotl - nm * temp1 * satrec.x1mth2 * sin2u / xke;
+         rvdot = rvdotl + nm * temp1 * (satrec.x1mth2 * cos2u +
+                 1.5 * satrec.con41) / xke;
+
+         /* --------------------- orientation vectors ------------------- */
+         sinsu =  sin(su);
+         cossu =  cos(su);
+         snod  =  sin(xnode);
+         cnod  =  cos(xnode);
+         sini  =  sin(xinc);
+         cosi  =  cos(xinc);
+         xmx   = -snod * cosi;
+         xmy   =  cnod * cosi;
+         ux    =  xmx * sinsu + cnod * cossu;
+         uy    =  xmy * sinsu + snod * cossu;
+         uz    =  sini * sinsu;
+         vx    =  xmx * cossu - cnod * sinsu;
+         vy    =  xmy * cossu - snod * sinsu;
+         vz    =  sini * cossu;
+
+         /* --------- position and velocity (in km and km/sec) ---------- */
+         r[0] = (mrt * ux)* radiusearthkm;
+         r[1] = (mrt * uy)* radiusearthkm;
+         r[2] = (mrt * uz)* radiusearthkm;
+         v[0] = (mvt * ux + rvdot * vx) * vkmpersec;
+         v[1] = (mvt * uy + rvdot * vy) * vkmpersec;
+         v[2] = (mvt * uz + rvdot * vz) * vkmpersec;
+       }  // if pl > 0
+
+     // sgp4fix for decaying satellites
+     if (mrt < 1.0)
+       {
+//         printf("# decay condition %11.6f \n",mrt);
+         satrec.error = 6;
+       }
+
+
+//#include "debug7.cpp"
+     return satrec.error;
+}  // end sgp4
+
+
+/* -----------------------------------------------------------------------------
+*
+*                           function gstime
+*
+*  this function finds the greenwich sidereal time.
+*
+*  author        : david vallado                  719-573-2600    1 mar 2001
+*
+*  inputs          description                    range / units
+*    jdut1       - julian date in ut1             days from 4713 bc
+*
+*  outputs       :
+*    gstime      - greenwich sidereal time        0 to 2pi rad
+*
+*  locals        :
+*    temp        - temporary variable for doubles   rad
+*    tut1        - julian centuries from the
+*                  jan 1, 2000 12 h epoch (ut1)
+*
+*  coupling      :
+*    none
+*
+*  references    :
+*    vallado       2004, 191, eq 3-45
+* --------------------------------------------------------------------------- */
+
+double  gstime
+        (
+          double jdut1
+        )
+   {
+     const double twopi = 2.0 * pi;
+     const double deg2rad = pi / 180.0;
+     double       temp, tut1;
+
+     tut1 = (jdut1 - 2451545.0) / 36525.0;
+     temp = -6.2e-6* tut1 * tut1 * tut1 + 0.093104 * tut1 * tut1 +
+             (876600.0*3600 + 8640184.812866) * tut1 + 67310.54841;  // sec
+     temp = fmod(temp * deg2rad / 240.0, twopi); //360/86400 = 1/240, to deg, to rad
+
+     // ------------------------ check quadrants ---------------------
+     if (temp < 0.0)
+         temp += twopi;
+
+     return temp;
+   }  // end gstime
+
+/* -----------------------------------------------------------------------------
+*
+*                           function getgravconst
+*
+*  this function gets constants for the propagator. note that mu is identified to
+*    facilitiate comparisons with newer models. the common useage is wgs72.
+*
+*  author        : david vallado                  719-573-2600   21 jul 2006
+*
+*  inputs        :
+*    whichconst  - which set of constants to use  wgs72old, wgs72, wgs84
+*
+*  outputs       :
+*    tumin       - minutes in one time unit
+*    mu          - earth gravitational parameter
+*    radiusearthkm - radius of the earth in km
+*    xke         - reciprocal of tumin
+*    j2, j3, j4  - un-normalized zonal harmonic values
+*    j3oj2       - j3 divided by j2
+*
+*  locals        :
+*
+*  coupling      :
+*    none
+*
+*  references    :
+*    norad spacetrack report #3
+*    vallado, crawford, hujsak, kelso  2006
+  --------------------------------------------------------------------------- */
+
+void getgravconst
+     (
+      gravconsttype whichconst,
+      double& tumin,
+      double& mu,
+      double& radiusearthkm,
+      double& xke,
+      double& j2,
+      double& j3,
+      double& j4,
+      double& j3oj2
+     )
+     {
+
+       switch (whichconst)
+         {
+           // -- wgs-72 low precision str#3 constants --
+           case wgs72old:
+           mu     = 398600.79964;        // in km3 / s2
+           radiusearthkm = 6378.135;     // km
+           xke    = 0.0743669161;
+           tumin  = 1.0 / xke;
+           j2     =   0.001082616;
+           j3     =  -0.00000253881;
+           j4     =  -0.00000165597;
+           j3oj2  =  j3 / j2;
+         break;
+           // ------------ wgs-72 constants ------------
+           case wgs72:
+           mu     = 398600.8;            // in km3 / s2
+           radiusearthkm = 6378.135;     // km
+           xke    = 60.0 / sqrt(radiusearthkm*radiusearthkm*radiusearthkm/mu);
+           tumin  = 1.0 / xke;
+           j2     =   0.001082616;
+           j3     =  -0.00000253881;
+           j4     =  -0.00000165597;
+           j3oj2  =  j3 / j2;
+         break;
+           case wgs84:
+           // ------------ wgs-84 constants ------------
+           mu     = 398600.5;            // in km3 / s2
+           radiusearthkm = 6378.137;     // km
+           xke    = 60.0 / sqrt(radiusearthkm*radiusearthkm*radiusearthkm/mu);
+           tumin  = 1.0 / xke;
+           j2     =   0.00108262998905;
+           j3     =  -0.00000253215306;
+           j4     =  -0.00000161098761;
+           j3oj2  =  j3 / j2;
+         break;
+         default:
+           fprintf(stderr,"unknown gravity option (%d)\n",whichconst);
+         break;
+         }
+
+     }   // end getgravconst
+
+
+
+
+
diff --git a/contrib/sgp4/sgp4unit.h b/contrib/sgp4/sgp4unit.h
index 48c113d73..f16acbd92 100644
--- a/contrib/sgp4/sgp4unit.h
+++ b/contrib/sgp4/sgp4unit.h
@@ -1,117 +1,117 @@
-#ifndef _sgp4unit_
-#define _sgp4unit_
-/*     ----------------------------------------------------------------
-*
-*                                 sgp4unit.h
-*
-*    this file contains the sgp4 procedures for analytical propagation
-*    of a satellite. the code was originally released in the 1980 and 1986
-*    spacetrack papers. a detailed discussion of the theory and history
-*    may be found in the 2006 aiaa paper by vallado, crawford, hujsak,
-*    and kelso.
-*
-*                            companion code for
-*               fundamentals of astrodynamics and applications
-*                                    2007
-*                              by david vallado
-*
-*       (w) 719-573-2600, email dvallado@agi.com
-*
-*    current :
-*              20 apr 07  david vallado
-*                           misc fixes for constants
-*    changes :
-*              11 aug 06  david vallado
-*                           chg lyddane choice back to strn3, constants, misc doc
-*              15 dec 05  david vallado
-*                           misc fixes
-*              26 jul 05  david vallado
-*                           fixes for paper
-*                           note that each fix is preceded by a
-*                           comment with "sgp4fix" and an explanation of
-*                           what was changed
-*              10 aug 04  david vallado
-*                           2nd printing baseline working
-*              14 may 01  david vallado
-*                           2nd edition baseline
-*                     80  norad
-*                           original baseline
-*       ----------------------------------------------------------------      */
-
-#include <math.h>
-#include <stdio.h>
-
-// -------------------------- structure declarations ----------------------------
-typedef enum
-{
-  wgs72old,
-  wgs72,
-  wgs84
-} gravconsttype;
-
-typedef struct elsetrec
-{
-  long int  satnum;
-  int       epochyr, epochtynumrev;
-  int       error;
-  char      init, method;
-
-  /* Near Earth */
-  int    isimp;
-  double aycof  , con41  , cc1    , cc4      , cc5    , d2      , d3   , d4    ,
-         delmo  , eta    , argpdot, omgcof   , sinmao , t       , t2cof, t3cof ,
-         t4cof  , t5cof  , x1mth2 , x7thm1   , mdot   , nodedot, xlcof , xmcof ,
-         nodecf;
-
-  /* Deep Space */
-  int    irez;
-  double d2201  , d2211  , d3210  , d3222    , d4410  , d4422   , d5220 , d5232 ,
-         d5421  , d5433  , dedt   , del1     , del2   , del3    , didt  , dmdt  ,
-         dnodt  , domdt  , e3     , ee2      , peo    , pgho    , pho   , pinco ,
-         plo    , se2    , se3    , sgh2     , sgh3   , sgh4    , sh2   , sh3   ,
-         si2    , si3    , sl2    , sl3      , sl4    , gsto    , xfact , xgh2  ,
-         xgh3   , xgh4   , xh2    , xh3      , xi2    , xi3     , xl2   , xl3   ,
-         xl4    , xlamo  , zmol   , zmos     , atime  , xli     , xni;
-
-  double a      , altp   , alta   , epochdays, jdsatepoch       , nddot , ndot  ,
-         bstar  , rcse   , inclo  , nodeo    , ecco             , argpo , mo    ,
-         no;
-} elsetrec;
-
-// --------------------------- function declarations ----------------------------
-int sgp4init
-       (
-         gravconsttype whichconst,      const int satn,     const double epoch,
-         const double xbstar, const double xecco, const double xargpo,
-         const double xinclo, const double xmo,   const double xno,
-         const double xnodeo,
-         elsetrec& satrec
-       );
-
-int sgp4
-       (
-         gravconsttype whichconst,
-         elsetrec& satrec, double tsince,
-         double r[], double v[]
-       );
-
-double  gstime
-       (
-         double
-       );
-
-void getgravconst
-      (
-       gravconsttype,
-       double&,
-       double&,
-       double&,
-       double&,
-       double&,
-       double&,
-       double&,
-       double&
-      );
-
-#endif
-
+#ifndef _sgp4unit_
+#define _sgp4unit_
+/*     ----------------------------------------------------------------
+*
+*                                 sgp4unit.h
+*
+*    this file contains the sgp4 procedures for analytical propagation
+*    of a satellite. the code was originally released in the 1980 and 1986
+*    spacetrack papers. a detailed discussion of the theory and history
+*    may be found in the 2006 aiaa paper by vallado, crawford, hujsak,
+*    and kelso.
+*
+*                            companion code for
+*               fundamentals of astrodynamics and applications
+*                                    2007
+*                              by david vallado
+*
+*       (w) 719-573-2600, email dvallado@agi.com
+*
+*    current :
+*              20 apr 07  david vallado
+*                           misc fixes for constants
+*    changes :
+*              11 aug 06  david vallado
+*                           chg lyddane choice back to strn3, constants, misc doc
+*              15 dec 05  david vallado
+*                           misc fixes
+*              26 jul 05  david vallado
+*                           fixes for paper
+*                           note that each fix is preceded by a
+*                           comment with "sgp4fix" and an explanation of
+*                           what was changed
+*              10 aug 04  david vallado
+*                           2nd printing baseline working
+*              14 may 01  david vallado
+*                           2nd edition baseline
+*                     80  norad
+*                           original baseline
+*       ----------------------------------------------------------------      */
+
+#include <math.h>
+#include <stdio.h>
+
+// -------------------------- structure declarations ----------------------------
+typedef enum
+{
+  wgs72old,
+  wgs72,
+  wgs84
+} gravconsttype;
+
+typedef struct elsetrec
+{
+  long int  satnum;
+  int       epochyr, epochtynumrev;
+  int       error;
+  char      init, method;
+
+  /* Near Earth */
+  int    isimp;
+  double aycof  , con41  , cc1    , cc4      , cc5    , d2      , d3   , d4    ,
+         delmo  , eta    , argpdot, omgcof   , sinmao , t       , t2cof, t3cof ,
+         t4cof  , t5cof  , x1mth2 , x7thm1   , mdot   , nodedot, xlcof , xmcof ,
+         nodecf;
+
+  /* Deep Space */
+  int    irez;
+  double d2201  , d2211  , d3210  , d3222    , d4410  , d4422   , d5220 , d5232 ,
+         d5421  , d5433  , dedt   , del1     , del2   , del3    , didt  , dmdt  ,
+         dnodt  , domdt  , e3     , ee2      , peo    , pgho    , pho   , pinco ,
+         plo    , se2    , se3    , sgh2     , sgh3   , sgh4    , sh2   , sh3   ,
+         si2    , si3    , sl2    , sl3      , sl4    , gsto    , xfact , xgh2  ,
+         xgh3   , xgh4   , xh2    , xh3      , xi2    , xi3     , xl2   , xl3   ,
+         xl4    , xlamo  , zmol   , zmos     , atime  , xli     , xni;
+
+  double a      , altp   , alta   , epochdays, jdsatepoch       , nddot , ndot  ,
+         bstar  , rcse   , inclo  , nodeo    , ecco             , argpo , mo    ,
+         no;
+} elsetrec;
+
+// --------------------------- function declarations ----------------------------
+int sgp4init
+       (
+         gravconsttype whichconst,      const int satn,     const double epoch,
+         const double xbstar, const double xecco, const double xargpo,
+         const double xinclo, const double xmo,   const double xno,
+         const double xnodeo,
+         elsetrec& satrec
+       );
+
+int sgp4
+       (
+         gravconsttype whichconst,
+         elsetrec& satrec, double tsince,
+         double r[], double v[]
+       );
+
+double  gstime
+       (
+         double
+       );
+
+void getgravconst
+      (
+       gravconsttype,
+       double&,
+       double&,
+       double&,
+       double&,
+       double&,
+       double&,
+       double&,
+       double&
+      );
+
+#endif
+
diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 2f43b13e5..da84ed277 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -1,140 +1,140 @@
-#include "../subsystem/SubsystemBase.h"
-#include "../controller/ControllerBase.h"
-#include "../subsystem/SubsystemBase.h"
-#include "../ipc/QueueFactory.h"
-#include "../action/HasActionsIF.h"
-
-ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
-		size_t commandQueueDepth) :
-		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
-		submode(SUBMODE_NONE), modeHelper(this),
-		healthHelper(this, setObjectId), hkSwitcher(this) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
-}
-
-ControllerBase::~ControllerBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t ControllerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	MessageQueueId_t parentQueue = 0;
-	if (parentId != objects::NO_OBJECT) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
-
-		parent->registerChild(getObjectId());
-	}
-
-	result = healthHelper.initialize(parentQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	result = modeHelper.initialize(parentQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	result = hkSwitcher.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	return RETURN_OK;
-}
-
-MessageQueueId_t ControllerBase::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void ControllerBase::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result;
-	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
-
-		result = modeHelper.handleModeCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-		result = handleCommandMessage(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
-
-}
-
-void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
-	changeHK(this->mode, this->submode, false);
-	triggerEvent(CHANGING_MODE, mode, submode);
-	this->mode = mode;
-	this->submode = submode;
-	modeHelper.modeChanged(mode, submode);
-	modeChanged(mode, submode);
-	announceMode(false);
-	changeHK(this->mode, this->submode, true);
-}
-
-void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
-}
-
-void ControllerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
-}
-
-void ControllerBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
-}
-
-ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
-	handleQueue();
-	hkSwitcher.performOperation();
-	performControlOperation();
-	return RETURN_OK;
-}
-
-void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
-	return;
-}
-
-ReturnValue_t ControllerBase::setHealth(HealthState health) {
-	switch (health) {
-	case HEALTHY:
-	case EXTERNAL_CONTROL:
-		healthHelper.setHealth(health);
-		return RETURN_OK;
-	default:
-		return INVALID_HEALTH_STATE;
-	}
-}
-
-HasHealthIF::HealthState ControllerBase::getHealth() {
-	return healthHelper.getHealth();
-}
-void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
-			executingTask = task_;
-}
-
-void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
-}
-
-ReturnValue_t ControllerBase::initializeAfterTaskCreation() {
-    return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../subsystem/SubsystemBase.h"
+#include "../controller/ControllerBase.h"
+#include "../subsystem/SubsystemBase.h"
+#include "../ipc/QueueFactory.h"
+#include "../action/HasActionsIF.h"
+
+ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
+		size_t commandQueueDepth) :
+		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
+		submode(SUBMODE_NONE), modeHelper(this),
+		healthHelper(this, setObjectId), hkSwitcher(this) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
+}
+
+ControllerBase::~ControllerBase() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t ControllerBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	MessageQueueId_t parentQueue = 0;
+	if (parentId != objects::NO_OBJECT) {
+		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		if (parent == NULL) {
+			return RETURN_FAILED;
+		}
+		parentQueue = parent->getCommandQueue();
+
+		parent->registerChild(getObjectId());
+	}
+
+	result = healthHelper.initialize(parentQueue);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	result = modeHelper.initialize(parentQueue);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	result = hkSwitcher.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	return RETURN_OK;
+}
+
+MessageQueueId_t ControllerBase::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void ControllerBase::handleQueue() {
+	CommandMessage command;
+	ReturnValue_t result;
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
+
+		result = modeHelper.handleModeCommand(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+		result = handleCommandMessage(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+		command.setToUnknownCommand();
+		commandQueue->reply(&command);
+	}
+
+}
+
+void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
+	changeHK(this->mode, this->submode, false);
+	triggerEvent(CHANGING_MODE, mode, submode);
+	this->mode = mode;
+	this->submode = submode;
+	modeHelper.modeChanged(mode, submode);
+	modeChanged(mode, submode);
+	announceMode(false);
+	changeHK(this->mode, this->submode, true);
+}
+
+void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
+	*mode = this->mode;
+	*submode = this->submode;
+}
+
+void ControllerBase::setToExternalControl() {
+	healthHelper.setHealth(EXTERNAL_CONTROL);
+}
+
+void ControllerBase::announceMode(bool recursive) {
+	triggerEvent(MODE_INFO, mode, submode);
+}
+
+ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
+	handleQueue();
+	hkSwitcher.performOperation();
+	performControlOperation();
+	return RETURN_OK;
+}
+
+void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
+	return;
+}
+
+ReturnValue_t ControllerBase::setHealth(HealthState health) {
+	switch (health) {
+	case HEALTHY:
+	case EXTERNAL_CONTROL:
+		healthHelper.setHealth(health);
+		return RETURN_OK;
+	default:
+		return INVALID_HEALTH_STATE;
+	}
+}
+
+HasHealthIF::HealthState ControllerBase::getHealth() {
+	return healthHelper.getHealth();
+}
+void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
+			executingTask = task_;
+}
+
+void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
+}
+
+ReturnValue_t ControllerBase::initializeAfterTaskCreation() {
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 5aacd9d87..400c3bb6c 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -1,94 +1,94 @@
-#ifndef FSFW_CONTROLLER_CONTROLLERBASE_H_
-#define FSFW_CONTROLLER_CONTROLLERBASE_H_
-
-#include "../health/HasHealthIF.h"
-#include "../health/HealthHelper.h"
-#include "../modes/HasModesIF.h"
-#include "../modes/ModeHelper.h"
-#include "../objectmanager/SystemObject.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../datapool/HkSwitchHelper.h"
-
-/**
- * @brief  Generic base class for controller classes
- * @details
- * Implements common interfaces for controllers.
- */
-class ControllerBase: public HasModesIF,
-		public HasHealthIF,
-		public ExecutableObjectIF,
-		public SystemObject,
-		public HasReturnvaluesIF {
-public:
-	static const Mode_t MODE_NORMAL = 2;
-
-	ControllerBase(object_id_t setObjectId, object_id_t parentId,
-			size_t commandQueueDepth = 3);
-	virtual ~ControllerBase();
-
-	virtual ReturnValue_t initialize() override;
-
-	virtual MessageQueueId_t getCommandQueue() const override;
-
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-
-	virtual ReturnValue_t setHealth(HealthState health) override;
-
-	virtual HasHealthIF::HealthState getHealth() override;
-
-	/**
-	 * Implementation of ExecutableObjectIF function
-	 *
-	 * Used to setup the reference of the task, that executes this component
-	 * @param task_ Pointer to the taskIF of this task
-	 */
-	virtual  void setTaskIF(PeriodicTaskIF* task_) override;
-
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
-
-protected:
-
-	/**
-	 * Implemented by child class. Handle command messages which are not
-	 * mode or health messages.
-	 * @param message
-	 * @return
-	 */
-    virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
-
-    virtual void performControlOperation() = 0;
-
-    virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-            uint32_t *msToReachTheMode) = 0;
-
-	const object_id_t parentId;
-
-	Mode_t mode;
-
-	Submode_t submode;
-
-	MessageQueueIF* commandQueue = nullptr;
-
-	ModeHelper modeHelper;
-
-	HealthHelper healthHelper;
-
-	HkSwitchHelper hkSwitcher;
-
-	/**
-	 * Pointer to the task which executes this component,
-	 * is invalid before setTaskIF was called.
-	 */
-	PeriodicTaskIF* executingTask = nullptr;
-
-	void handleQueue();
-
-	virtual void modeChanged(Mode_t mode, Submode_t submode);
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-	virtual void setToExternalControl();
-	virtual void announceMode(bool recursive);
-	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
-};
-
-#endif /* FSFW_CONTROLLER_CONTROLLERBASE_H_ */
+#ifndef FSFW_CONTROLLER_CONTROLLERBASE_H_
+#define FSFW_CONTROLLER_CONTROLLERBASE_H_
+
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../modes/HasModesIF.h"
+#include "../modes/ModeHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../datapool/HkSwitchHelper.h"
+
+/**
+ * @brief  Generic base class for controller classes
+ * @details
+ * Implements common interfaces for controllers.
+ */
+class ControllerBase: public HasModesIF,
+		public HasHealthIF,
+		public ExecutableObjectIF,
+		public SystemObject,
+		public HasReturnvaluesIF {
+public:
+	static const Mode_t MODE_NORMAL = 2;
+
+	ControllerBase(object_id_t setObjectId, object_id_t parentId,
+			size_t commandQueueDepth = 3);
+	virtual ~ControllerBase();
+
+	virtual ReturnValue_t initialize() override;
+
+	virtual MessageQueueId_t getCommandQueue() const override;
+
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+
+	virtual ReturnValue_t setHealth(HealthState health) override;
+
+	virtual HasHealthIF::HealthState getHealth() override;
+
+	/**
+	 * Implementation of ExecutableObjectIF function
+	 *
+	 * Used to setup the reference of the task, that executes this component
+	 * @param task_ Pointer to the taskIF of this task
+	 */
+	virtual  void setTaskIF(PeriodicTaskIF* task_) override;
+
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+
+	/**
+	 * Implemented by child class. Handle command messages which are not
+	 * mode or health messages.
+	 * @param message
+	 * @return
+	 */
+    virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+    virtual void performControlOperation() = 0;
+
+    virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+            uint32_t *msToReachTheMode) = 0;
+
+	const object_id_t parentId;
+
+	Mode_t mode;
+
+	Submode_t submode;
+
+	MessageQueueIF* commandQueue = nullptr;
+
+	ModeHelper modeHelper;
+
+	HealthHelper healthHelper;
+
+	HkSwitchHelper hkSwitcher;
+
+	/**
+	 * Pointer to the task which executes this component,
+	 * is invalid before setTaskIF was called.
+	 */
+	PeriodicTaskIF* executingTask = nullptr;
+
+	void handleQueue();
+
+	virtual void modeChanged(Mode_t mode, Submode_t submode);
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+	virtual void getMode(Mode_t *mode, Submode_t *submode);
+	virtual void setToExternalControl();
+	virtual void announceMode(bool recursive);
+	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
+};
+
+#endif /* FSFW_CONTROLLER_CONTROLLERBASE_H_ */
diff --git a/datapool/ControllerSet.cpp b/datapool/ControllerSet.cpp
index f83b38d58..4055158bc 100644
--- a/datapool/ControllerSet.cpp
+++ b/datapool/ControllerSet.cpp
@@ -1,14 +1,14 @@
-#include "../datapool/ControllerSet.h"
-
-ControllerSet::ControllerSet() {
-
-}
-
-ControllerSet::~ControllerSet() {
-}
-
-void ControllerSet::setInvalid() {
-	read();
-	setToDefault();
-	commit(PoolVariableIF::INVALID);
-}
+#include "../datapool/ControllerSet.h"
+
+ControllerSet::ControllerSet() {
+
+}
+
+ControllerSet::~ControllerSet() {
+}
+
+void ControllerSet::setInvalid() {
+	read();
+	setToDefault();
+	commit(PoolVariableIF::INVALID);
+}
diff --git a/datapool/ControllerSet.h b/datapool/ControllerSet.h
index da6a9bf4b..43e1cbf21 100644
--- a/datapool/ControllerSet.h
+++ b/datapool/ControllerSet.h
@@ -1,15 +1,15 @@
-#ifndef CONTROLLERSET_H_
-#define CONTROLLERSET_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-
-class ControllerSet :public GlobDataSet {
-public:
-	ControllerSet();
-	virtual ~ControllerSet();
-
-	virtual void setToDefault() = 0;
-	void setInvalid();
-};
-
-#endif /* CONTROLLERSET_H_ */
+#ifndef CONTROLLERSET_H_
+#define CONTROLLERSET_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+
+class ControllerSet :public GlobDataSet {
+public:
+	ControllerSet();
+	virtual ~ControllerSet();
+
+	virtual void setToDefault() = 0;
+	void setInvalid();
+};
+
+#endif /* CONTROLLERSET_H_ */
diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp
index 5a59f94c4..1a2a25eb9 100644
--- a/datapool/HkSwitchHelper.cpp
+++ b/datapool/HkSwitchHelper.cpp
@@ -1,75 +1,75 @@
-#include "../datapool/HkSwitchHelper.h"
-#include "../ipc/QueueFactory.h"
-
-HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
-		commandActionHelper(this), eventProxy(eventProxy) {
-	actionQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-HkSwitchHelper::~HkSwitchHelper() {
-	// TODO Auto-generated destructor stub
-}
-
-ReturnValue_t HkSwitchHelper::initialize() {
-	ReturnValue_t result = commandActionHelper.initialize();
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	return result;
-}
-
-ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
-	CommandMessage command;
-	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
-		ReturnValue_t result = commandActionHelper.handleReply(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			continue;
-		}
-		command.setToUnknownCommand();
-		actionQueue->reply(&command);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HkSwitchHelper::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {
-}
-
-void HkSwitchHelper::stepFailedReceived(ActionId_t actionId, uint8_t step,
-		ReturnValue_t returnCode) {
-	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
-}
-
-void HkSwitchHelper::dataReceived(ActionId_t actionId, const uint8_t* data,
-		uint32_t size) {
-}
-
-void HkSwitchHelper::completionSuccessfulReceived(ActionId_t actionId) {
-}
-
-void HkSwitchHelper::completionFailedReceived(ActionId_t actionId,
-		ReturnValue_t returnCode) {
-	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
-}
-
-ReturnValue_t HkSwitchHelper::switchHK(SerializeIF* sids, bool enable) {
-//	ActionId_t action = HKService::DISABLE_HK;
-//	if (enable) {
-//		action = HKService::ENABLE_HK;
-//	}
-//
-//	ReturnValue_t result = commandActionHelper.commandAction(
-//			objects::PUS_HK_SERVICE, action, sids);
-//
-//	if (result != HasReturnvaluesIF::RETURN_OK) {
-//		eventProxy->forwardEvent(SWITCHING_TM_FAILED, result);
-//	}
-//	return result;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueIF* HkSwitchHelper::getCommandQueuePtr() {
-	return actionQueue;
-}
+#include "../datapool/HkSwitchHelper.h"
+#include "../ipc/QueueFactory.h"
+
+HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
+		commandActionHelper(this), eventProxy(eventProxy) {
+	actionQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+HkSwitchHelper::~HkSwitchHelper() {
+	// TODO Auto-generated destructor stub
+}
+
+ReturnValue_t HkSwitchHelper::initialize() {
+	ReturnValue_t result = commandActionHelper.initialize();
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return result;
+}
+
+ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
+	CommandMessage command;
+	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
+		ReturnValue_t result = commandActionHelper.handleReply(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			continue;
+		}
+		command.setToUnknownCommand();
+		actionQueue->reply(&command);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void HkSwitchHelper::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {
+}
+
+void HkSwitchHelper::stepFailedReceived(ActionId_t actionId, uint8_t step,
+		ReturnValue_t returnCode) {
+	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
+}
+
+void HkSwitchHelper::dataReceived(ActionId_t actionId, const uint8_t* data,
+		uint32_t size) {
+}
+
+void HkSwitchHelper::completionSuccessfulReceived(ActionId_t actionId) {
+}
+
+void HkSwitchHelper::completionFailedReceived(ActionId_t actionId,
+		ReturnValue_t returnCode) {
+	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
+}
+
+ReturnValue_t HkSwitchHelper::switchHK(SerializeIF* sids, bool enable) {
+//	ActionId_t action = HKService::DISABLE_HK;
+//	if (enable) {
+//		action = HKService::ENABLE_HK;
+//	}
+//
+//	ReturnValue_t result = commandActionHelper.commandAction(
+//			objects::PUS_HK_SERVICE, action, sids);
+//
+//	if (result != HasReturnvaluesIF::RETURN_OK) {
+//		eventProxy->forwardEvent(SWITCHING_TM_FAILED, result);
+//	}
+//	return result;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueIF* HkSwitchHelper::getCommandQueuePtr() {
+	return actionQueue;
+}
diff --git a/datapool/HkSwitchHelper.h b/datapool/HkSwitchHelper.h
index de34ab233..385b2047f 100644
--- a/datapool/HkSwitchHelper.h
+++ b/datapool/HkSwitchHelper.h
@@ -1,46 +1,46 @@
-#ifndef FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
-#define FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
-
-#include "../tasks/ExecutableObjectIF.h"
-#include "../action/CommandsActionsIF.h"
-#include "../events/EventReportingProxyIF.h"
-
-//TODO this class violations separation between mission and framework
-//but it is only a transitional solution until the Datapool is
-//implemented decentrally
-
-class HkSwitchHelper: public ExecutableObjectIF, public CommandsActionsIF {
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HK;
-	static const Event SWITCHING_TM_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Commanding the HK Service failed, p1: error code, p2 action: 0 disable / 1 enable
-
-	HkSwitchHelper(EventReportingProxyIF *eventProxy);
-	virtual ~HkSwitchHelper();
-
-	ReturnValue_t initialize();
-
-	virtual ReturnValue_t  performOperation(uint8_t operationCode = 0);
-
-	ReturnValue_t switchHK(SerializeIF *sids, bool enable);
-
-	virtual void setTaskIF(PeriodicTaskIF* task_){};
-
-protected:
-	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step);
-	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
-			ReturnValue_t returnCode);
-	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
-			uint32_t size);
-	virtual void completionSuccessfulReceived(ActionId_t actionId);
-	virtual void completionFailedReceived(ActionId_t actionId,
-			ReturnValue_t returnCode);
-	virtual MessageQueueIF* getCommandQueuePtr();
-
-private:
-	CommandActionHelper commandActionHelper;
-	MessageQueueIF* actionQueue;
-	EventReportingProxyIF *eventProxy;
-};
-
-#endif /* FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ */
+#ifndef FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
+#define FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
+
+#include "../tasks/ExecutableObjectIF.h"
+#include "../action/CommandsActionsIF.h"
+#include "../events/EventReportingProxyIF.h"
+
+//TODO this class violations separation between mission and framework
+//but it is only a transitional solution until the Datapool is
+//implemented decentrally
+
+class HkSwitchHelper: public ExecutableObjectIF, public CommandsActionsIF {
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HK;
+	static const Event SWITCHING_TM_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Commanding the HK Service failed, p1: error code, p2 action: 0 disable / 1 enable
+
+	HkSwitchHelper(EventReportingProxyIF *eventProxy);
+	virtual ~HkSwitchHelper();
+
+	ReturnValue_t initialize();
+
+	virtual ReturnValue_t  performOperation(uint8_t operationCode = 0);
+
+	ReturnValue_t switchHK(SerializeIF *sids, bool enable);
+
+	virtual void setTaskIF(PeriodicTaskIF* task_){};
+
+protected:
+	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step);
+	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
+			ReturnValue_t returnCode);
+	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
+			uint32_t size);
+	virtual void completionSuccessfulReceived(ActionId_t actionId);
+	virtual void completionFailedReceived(ActionId_t actionId,
+			ReturnValue_t returnCode);
+	virtual MessageQueueIF* getCommandQueuePtr();
+
+private:
+	CommandActionHelper commandActionHelper;
+	MessageQueueIF* actionQueue;
+	EventReportingProxyIF *eventProxy;
+};
+
+#endif /* FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ */
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index a21d521f5..b0506b824 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,87 +1,87 @@
-#include "../datapool/PoolEntry.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../globalfunctions/arrayprinter.h"
-#include <cstring>
-
-template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
-		bool setValid ) : length(setLength), valid(setValid) {
-	this->address = new T[this->length];
-	if(initValue.size() == 0) {
-		std::memset(this->address, 0, this->getByteSize());
-	}
-	else if (initValue.size() != setLength){
-		sif::warning << "PoolEntry: setLength is not equal to initializer list"
-				"length! Performing zero initialization with given setLength"
-				<< std::endl;
-		std::memset(this->address, 0, this->getByteSize());
-	}
-	else {
-		std::copy(initValue.begin(), initValue.end(), this->address);
-	}
-}
-
-template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t setLength, bool setValid ) :
-		length(setLength), valid(setValid) {
-	this->address = new T[this->length];
-	if (initValue != nullptr) {
-		std::memcpy(this->address, initValue, this->getByteSize() );
-	} else {
-		std::memset(this->address, 0, this->getByteSize() );
-	}
-}
-
-//As the data pool is global, this dtor is only be called on program exit.
-//Warning! Never copy pool entries!
-template <typename T>
-PoolEntry<T>::~PoolEntry() {
-	delete[] this->address;
-}
-
-template <typename T>
-uint16_t PoolEntry<T>::getByteSize() {
-	return ( sizeof(T) * this->length );
-}
-
-template <typename T>
-uint8_t PoolEntry<T>::getSize() {
-	return this->length;
-}
-
-template <typename T>
-void* PoolEntry<T>::getRawData() {
-	return this->address;
-}
-
-template <typename T>
-void PoolEntry<T>::setValid(bool isValid) {
-	this->valid = isValid;
-}
-
-template <typename T>
-bool PoolEntry<T>::getValid() {
-	return valid;
-}
-
-template <typename T>
-void PoolEntry<T>::print() {
-	 sif::debug << "Pool Entry Validity: " <<
-			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
-	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
-	sif::debug << std::dec << std::endl;
-}
-
-template<typename T>
-Type PoolEntry<T>::getType() {
-	return PodTypeConversion<T>::type;
-}
-
-template class PoolEntry<uint8_t>;
-template class PoolEntry<uint16_t>;
-template class PoolEntry<uint32_t>;
-template class PoolEntry<int8_t>;
-template class PoolEntry<int16_t>;
-template class PoolEntry<int32_t>;
-template class PoolEntry<float>;
-template class PoolEntry<double>;
+#include "../datapool/PoolEntry.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../globalfunctions/arrayprinter.h"
+#include <cstring>
+
+template <typename T>
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
+		bool setValid ) : length(setLength), valid(setValid) {
+	this->address = new T[this->length];
+	if(initValue.size() == 0) {
+		std::memset(this->address, 0, this->getByteSize());
+	}
+	else if (initValue.size() != setLength){
+		sif::warning << "PoolEntry: setLength is not equal to initializer list"
+				"length! Performing zero initialization with given setLength"
+				<< std::endl;
+		std::memset(this->address, 0, this->getByteSize());
+	}
+	else {
+		std::copy(initValue.begin(), initValue.end(), this->address);
+	}
+}
+
+template <typename T>
+PoolEntry<T>::PoolEntry( T* initValue, uint8_t setLength, bool setValid ) :
+		length(setLength), valid(setValid) {
+	this->address = new T[this->length];
+	if (initValue != nullptr) {
+		std::memcpy(this->address, initValue, this->getByteSize() );
+	} else {
+		std::memset(this->address, 0, this->getByteSize() );
+	}
+}
+
+//As the data pool is global, this dtor is only be called on program exit.
+//Warning! Never copy pool entries!
+template <typename T>
+PoolEntry<T>::~PoolEntry() {
+	delete[] this->address;
+}
+
+template <typename T>
+uint16_t PoolEntry<T>::getByteSize() {
+	return ( sizeof(T) * this->length );
+}
+
+template <typename T>
+uint8_t PoolEntry<T>::getSize() {
+	return this->length;
+}
+
+template <typename T>
+void* PoolEntry<T>::getRawData() {
+	return this->address;
+}
+
+template <typename T>
+void PoolEntry<T>::setValid(bool isValid) {
+	this->valid = isValid;
+}
+
+template <typename T>
+bool PoolEntry<T>::getValid() {
+	return valid;
+}
+
+template <typename T>
+void PoolEntry<T>::print() {
+	 sif::debug << "Pool Entry Validity: " <<
+			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
+	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
+	sif::debug << std::dec << std::endl;
+}
+
+template<typename T>
+Type PoolEntry<T>::getType() {
+	return PodTypeConversion<T>::type;
+}
+
+template class PoolEntry<uint8_t>;
+template class PoolEntry<uint16_t>;
+template class PoolEntry<uint32_t>;
+template class PoolEntry<int8_t>;
+template class PoolEntry<int16_t>;
+template class PoolEntry<int32_t>;
+template class PoolEntry<float>;
+template class PoolEntry<double>;
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 67891af88..6a3daacf9 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -1,130 +1,130 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
-
-#include "../datapool/PoolEntryIF.h"
-
-#include <initializer_list>
-#include <type_traits>
-#include <cstddef>
-
-/**
- * @brief	This is a small helper class that defines a single data pool entry.
- * @details
- * The helper is used to store all information together with the data as a
- * single data pool entry. The content's type is defined by the template
- * argument.
- *
- * It is prepared for use with plain old data types, but may be
- * extended to complex types if necessary. It can be initialized with a
- * certain value, size and validity flag.
- *
- * It holds a pointer to the real data and offers methods to access this data
- * and to acquire additional information (such as validity and array/byte size).
- * It is NOT intended to be used outside DataPool implementations as it performs
- * dynamic memory allocation.
- *
- * @ingroup data_pool
- */
-template <typename T>
-class PoolEntry : public PoolEntryIF {
-public:
-	static_assert(not std::is_same<T, bool>::value,
-				"Do not use boolean for the PoolEntry type, use uint8_t "
-				"instead! The ECSS standard defines a boolean as a one bit "
-				"field. Therefore it is preferred to store a boolean as an "
-				"uint8_t");
-	/**
-	 * @brief	In the classe's constructor, space is allocated on the heap and
-	 * 			potential init values are copied to that space.
-	 * @details
-	 * Not passing any arguments will initialize an non-array pool entry
-	 * (setLength = 1) with an initial invalid state.
-	 * Please note that if an initializer list is passed, the correct
-	 * corresponding length should be passed too, otherwise a zero
-	 * initialization will be performed with the given setLength.
-	 * @param initValue
-	 * Initializer list with values to initialize with, for example {0,0} to
-	 * initialize the two entries to zero.
-	 * @param setLength
-	 * Defines the array length of this entry. Should be equal to the
-	 * intializer list length.
-	 * @param setValid
-	 * Sets the initialization flag. It is invalid by default.
-	 */
-	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
-			bool setValid = false);
-	/**
-	 * @brief	In the classe's constructor, space is allocated on the heap and
-	 * 			potential init values are copied to that space.
-	 * @param initValue
-	 * A pointer to the single value or array that holds the init value.
-	 * With the default value (nullptr), the entry is initalized with all 0.
-	 * @param setLength
-	 * Defines the array length of this entry.
-	 * @param setValid
-	 * Sets the initialization flag. It is invalid by default.
-	 */
-	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
-
-	//! Explicitely deleted copy ctor, copying is not allowed!
-	PoolEntry(const PoolEntry&) = delete;
-	//! Explicitely deleted copy assignment, copying is not allowed!
-	PoolEntry& operator=(const PoolEntry&) = delete;
-
-	/**
-	 * @brief	The allocated memory for the variable is freed
-	 * 			in the destructor.
-	 * @details
-	 * As the data pool is global, this dtor is only called on program exit.
-	 * PoolEntries shall never be copied, as a copy might delete the variable
-	 * on the heap.
-	 */
-	~PoolEntry();
-
-	/**
-	 * @brief	This is the address pointing to the allocated memory.
-	 */
-	T* address;
-	/**
-	 * @brief	This attribute stores the length information.
-	 */
-	uint8_t length;
-	/**
-	 * @brief	Here, the validity information for a variable is stored.
-	 * 			Every entry (single variable or vector) has one valid flag.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	getSize returns the array size of the entry.
-	 * @details	A single parameter has size 1.
-	 */
-	uint8_t getSize();
-	/**
-	 * @brief	This operation returns the size in bytes.
-	 * @details	The size is calculated by sizeof(type) * array_size.
-	 */
-	uint16_t getByteSize();
-	/**
-	 * @brief	This operation returns a the address pointer casted to void*.
-	 */
-	void* getRawData();
-	/**
-	 * @brief	This method allows to set the valid information
-	 * 			of the pool entry.
-	 */
-	void setValid( bool isValid );
-	/**
-	 * @brief	This method allows to get the valid information
-	 * 			of the pool entry.
-	 */
-	bool getValid();
-	/**
-	 * @brief	This is a debug method that prints all values and the valid
-	 * 			information to the screen. It prints all array entries in a row.
-	 */
-	void print();
-
-	Type getType();
-};
-
-#endif /* POOLENTRY_H_ */
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
+#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
+
+#include "../datapool/PoolEntryIF.h"
+
+#include <initializer_list>
+#include <type_traits>
+#include <cstddef>
+
+/**
+ * @brief	This is a small helper class that defines a single data pool entry.
+ * @details
+ * The helper is used to store all information together with the data as a
+ * single data pool entry. The content's type is defined by the template
+ * argument.
+ *
+ * It is prepared for use with plain old data types, but may be
+ * extended to complex types if necessary. It can be initialized with a
+ * certain value, size and validity flag.
+ *
+ * It holds a pointer to the real data and offers methods to access this data
+ * and to acquire additional information (such as validity and array/byte size).
+ * It is NOT intended to be used outside DataPool implementations as it performs
+ * dynamic memory allocation.
+ *
+ * @ingroup data_pool
+ */
+template <typename T>
+class PoolEntry : public PoolEntryIF {
+public:
+	static_assert(not std::is_same<T, bool>::value,
+				"Do not use boolean for the PoolEntry type, use uint8_t "
+				"instead! The ECSS standard defines a boolean as a one bit "
+				"field. Therefore it is preferred to store a boolean as an "
+				"uint8_t");
+	/**
+	 * @brief	In the classe's constructor, space is allocated on the heap and
+	 * 			potential init values are copied to that space.
+	 * @details
+	 * Not passing any arguments will initialize an non-array pool entry
+	 * (setLength = 1) with an initial invalid state.
+	 * Please note that if an initializer list is passed, the correct
+	 * corresponding length should be passed too, otherwise a zero
+	 * initialization will be performed with the given setLength.
+	 * @param initValue
+	 * Initializer list with values to initialize with, for example {0,0} to
+	 * initialize the two entries to zero.
+	 * @param setLength
+	 * Defines the array length of this entry. Should be equal to the
+	 * intializer list length.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
+	 */
+	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
+			bool setValid = false);
+	/**
+	 * @brief	In the classe's constructor, space is allocated on the heap and
+	 * 			potential init values are copied to that space.
+	 * @param initValue
+	 * A pointer to the single value or array that holds the init value.
+	 * With the default value (nullptr), the entry is initalized with all 0.
+	 * @param setLength
+	 * Defines the array length of this entry.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
+	 */
+	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
+
+	//! Explicitely deleted copy ctor, copying is not allowed!
+	PoolEntry(const PoolEntry&) = delete;
+	//! Explicitely deleted copy assignment, copying is not allowed!
+	PoolEntry& operator=(const PoolEntry&) = delete;
+
+	/**
+	 * @brief	The allocated memory for the variable is freed
+	 * 			in the destructor.
+	 * @details
+	 * As the data pool is global, this dtor is only called on program exit.
+	 * PoolEntries shall never be copied, as a copy might delete the variable
+	 * on the heap.
+	 */
+	~PoolEntry();
+
+	/**
+	 * @brief	This is the address pointing to the allocated memory.
+	 */
+	T* address;
+	/**
+	 * @brief	This attribute stores the length information.
+	 */
+	uint8_t length;
+	/**
+	 * @brief	Here, the validity information for a variable is stored.
+	 * 			Every entry (single variable or vector) has one valid flag.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	getSize returns the array size of the entry.
+	 * @details	A single parameter has size 1.
+	 */
+	uint8_t getSize();
+	/**
+	 * @brief	This operation returns the size in bytes.
+	 * @details	The size is calculated by sizeof(type) * array_size.
+	 */
+	uint16_t getByteSize();
+	/**
+	 * @brief	This operation returns a the address pointer casted to void*.
+	 */
+	void* getRawData();
+	/**
+	 * @brief	This method allows to set the valid information
+	 * 			of the pool entry.
+	 */
+	void setValid( bool isValid );
+	/**
+	 * @brief	This method allows to get the valid information
+	 * 			of the pool entry.
+	 */
+	bool getValid();
+	/**
+	 * @brief	This is a debug method that prints all values and the valid
+	 * 			information to the screen. It prints all array entries in a row.
+	 */
+	void print();
+
+	Type getType();
+};
+
+#endif /* POOLENTRY_H_ */
diff --git a/datapool/PoolEntryIF.h b/datapool/PoolEntryIF.h
index a9fb44ef3..462de18b8 100644
--- a/datapool/PoolEntryIF.h
+++ b/datapool/PoolEntryIF.h
@@ -1,63 +1,63 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-
-#include "../globalfunctions/Type.h"
-#include <cstdint>
-
-/**
- * @brief	This interface defines the access possibilities to a
- * 			single data pool entry.
- * @details
- * The interface provides methods to determine the size and the validity
- * information of a value. It also defines a method to receive a pointer to the
- * raw data content. It is mainly used by DataPool itself, but also as a
- * return pointer.
- *
- * @author	Bastian Baetz
- * @ingroup data_pool
- *
- */
-class PoolEntryIF {
-public:
-	/**
-	 * @brief	This is an empty virtual destructor,
-	 * 			as it is required for C++ interfaces.
-	 */
-	virtual ~PoolEntryIF() {
-	}
-	/**
-	 * @brief	getSize returns the array size of the entry.
-	 * 			A single variable parameter has size 1.
-	 */
-	virtual uint8_t getSize() = 0;
-	/**
-	 * @brief	This operation returns the size in bytes, which is calculated by
-	 * 			sizeof(type) * array_size.
-	 */
-	virtual uint16_t getByteSize() = 0;
-	/**
-	 * @brief	This operation returns a the address pointer casted to void*.
-	 */
-	virtual void* getRawData() = 0;
-	/**
-	 * @brief	This method allows to set the valid information of the pool entry.
-	 */
-	virtual void setValid(bool isValid) = 0;
-	/**
-	 * @brief	This method allows to set the valid information of the pool entry.
-	 */
-	virtual bool getValid() = 0;
-	/**
-	 * @brief	This is a debug method that prints all values and the valid
-	 * 			information to the screen. It prints all array entries in a row.
-	 * @details
-	 * Also displays whether the pool entry is valid or invalid.
-	 */
-	virtual void print() = 0;
-	/**
-	 * Returns the type of the entry.
-	 */
-	virtual Type getType() = 0;
-};
-
-#endif /* POOLENTRYIF_H_ */
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+
+#include "../globalfunctions/Type.h"
+#include <cstdint>
+
+/**
+ * @brief	This interface defines the access possibilities to a
+ * 			single data pool entry.
+ * @details
+ * The interface provides methods to determine the size and the validity
+ * information of a value. It also defines a method to receive a pointer to the
+ * raw data content. It is mainly used by DataPool itself, but also as a
+ * return pointer.
+ *
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ *
+ */
+class PoolEntryIF {
+public:
+	/**
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is required for C++ interfaces.
+	 */
+	virtual ~PoolEntryIF() {
+	}
+	/**
+	 * @brief	getSize returns the array size of the entry.
+	 * 			A single variable parameter has size 1.
+	 */
+	virtual uint8_t getSize() = 0;
+	/**
+	 * @brief	This operation returns the size in bytes, which is calculated by
+	 * 			sizeof(type) * array_size.
+	 */
+	virtual uint16_t getByteSize() = 0;
+	/**
+	 * @brief	This operation returns a the address pointer casted to void*.
+	 */
+	virtual void* getRawData() = 0;
+	/**
+	 * @brief	This method allows to set the valid information of the pool entry.
+	 */
+	virtual void setValid(bool isValid) = 0;
+	/**
+	 * @brief	This method allows to set the valid information of the pool entry.
+	 */
+	virtual bool getValid() = 0;
+	/**
+	 * @brief	This is a debug method that prints all values and the valid
+	 * 			information to the screen. It prints all array entries in a row.
+	 * @details
+	 * Also displays whether the pool entry is valid or invalid.
+	 */
+	virtual void print() = 0;
+	/**
+	 * Returns the type of the entry.
+	 */
+	virtual Type getType() = 0;
+};
+
+#endif /* POOLENTRYIF_H_ */
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 272bb5023..3696a21d1 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -1,188 +1,188 @@
-/**
- * @file PoolRawAccessHelper.cpp
- *
- * @date 22.12.2019
- * @author R. Mueller
- */
-
-#include "../datapool/PoolRawAccessHelper.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-#include <cmath>
-#include <cstring>
-
-PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
-		uint8_t  numberOfParameters_):
-		poolIdBuffer(reinterpret_cast<uint8_t * >(poolIdBuffer_)),
-		numberOfParameters(numberOfParameters_), validBufferIndex(0),
-		validBufferIndexBit(1) {
-}
-
-PoolRawAccessHelper::~PoolRawAccessHelper() {
-}
-
-ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
-		const size_t max_size, SerializeIF::Endianness streamEndianness) {
-	SerializationArgs serializationArgs = {buffer, size, max_size,
-	        streamEndianness};
-	ReturnValue_t result = RETURN_OK;
-	size_t remainingParametersSize = numberOfParameters * 4;
-	for(uint8_t count=0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
-				&remainingParametersSize, false);
-		if(result != RETURN_OK) {
-			return result;
-		}
-	}
-	if(remainingParametersSize != 0) {
-		sif::debug << "PoolRawAccessHelper: "
-				"Remaining parameters size not 0 !" << std::endl;
-		result = RETURN_FAILED;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
-		size_t * size, const size_t max_size,
-		SerializeIF::Endianness streamEndianness) {
-	ReturnValue_t result = RETURN_OK;
-	SerializationArgs argStruct = {buffer, size, max_size, streamEndianness};
-	size_t remainingParametersSize = numberOfParameters * 4;
-	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
-	uint8_t validityMask[validityMaskSize];
-	memset(validityMask,0, validityMaskSize);
-	for(uint8_t count = 0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(argStruct,
-				&remainingParametersSize,true,validityMask);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	if(remainingParametersSize != 0) {
-		sif::debug << "PoolRawAccessHelper: Remaining "
-				"parameters size not 0 !" << std::endl;
-		result = RETURN_FAILED;
-	}
-
-	memcpy(*argStruct.buffer, validityMask, validityMaskSize);
-	*size += validityMaskSize;
-	validBufferIndex = 1;
-	validBufferIndexBit = 0;
-	return result;
-}
-
-ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
-		SerializationArgs argStruct, size_t * remainingParameters,
-		bool withValidMask, uint8_t * validityMask) {
-	uint32_t currentPoolId;
-	// Deserialize current pool ID from pool ID buffer
-	ReturnValue_t result = SerializeAdapter::deSerialize(&currentPoolId,
-			&poolIdBuffer,remainingParameters, SerializeIF::Endianness::MACHINE);
-	if(result != RETURN_OK) {
-		sif::debug << std::hex << "PoolRawAccessHelper: Error deSeralizing "
-				"pool IDs" << std::dec << std::endl;
-		return result;
-	}
-	result = handlePoolEntrySerialization(currentPoolId, argStruct,
-			withValidMask, validityMask);
-	return result;
-}
-
-ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
-		uint32_t currentPoolId,SerializationArgs argStruct, bool withValidMask,
-		uint8_t * validityMask) {
-	ReturnValue_t result = RETURN_FAILED;
-	uint8_t arrayPosition = 0;
-	uint8_t counter = 0;
-	bool poolEntrySerialized = false;
-	//debug << "Pool Raw Access Helper: Handling Pool ID: "
-	//      << std::hex <<  currentPoolId << std::endl;
-	while(not poolEntrySerialized) {
-
-		if(counter > GlobDataSet::DATA_SET_MAX_SIZE) {
-			sif::error << "PoolRawAccessHelper: Config error, "
-					 "max. number of possible data set variables exceeded"
-				  << std::endl;
-			return result;
-		}
-		counter ++;
-
-		GlobDataSet currentDataSet;
-		//debug << "Current array position: " << (int)arrayPosition << std::endl;
-		PoolRawAccess currentPoolRawAccess(currentPoolId, arrayPosition,
-				&currentDataSet, PoolVariableIF::VAR_READ);
-
-		result = currentDataSet.read();
-		if (result != RETURN_OK) {
-			sif::debug << std::hex << "PoolRawAccessHelper: Error reading raw "
-					"dataset with returncode 0x" << result << std::dec << std::endl;
-			return result;
-		}
-
-		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized,
-				&arrayPosition);
-		if(result != RETURN_OK) {
-			sif::error << "Pool Raw Access Helper: Configuration Error at pool ID "
-				  << std::hex << currentPoolId
-				  << ". Size till end smaller than 0" << std::dec << std::endl;
-			return result;
-		}
-
-		// set valid mask bit if necessary
-		if(withValidMask) {
-			if(currentPoolRawAccess.isValid()) {
-				handleMaskModification(validityMask);
-			}
-			validBufferIndexBit ++;
-		}
-
-		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
-				argStruct.max_size, argStruct.streamEndianness);
-		if (result != RETURN_OK) {
-			sif::debug << "Pool Raw Access Helper: Error serializing pool data with "
-					 "ID 0x" << std::hex << currentPoolId << " into send buffer "
-					 "with return code " << result << std::dec << std::endl;
-			return result;
-		}
-
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess*
-		currentPoolRawAccess, bool * isSerialized, uint8_t * arrayPosition) {
-	int8_t remainingSize = currentPoolRawAccess->getSizeTillEnd() -
-			currentPoolRawAccess->getSizeOfType();
-	if(remainingSize == 0) {
-		*isSerialized = true;
-	}
-	else if(remainingSize > 0) {
-		*arrayPosition += 1;
-	}
-	else {
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
-	validityMask[validBufferIndex] =
-			bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
-	if(validBufferIndexBit == 8) {
-		validBufferIndex ++;
-		validBufferIndexBit = 1;
-	}
-}
-
-uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position,
-		bool value) {
-	if(position < 1 or position > 8) {
-		sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
-		return byte;
-	}
-	uint8_t shiftNumber = position + (6 - 2 * (position - 1));
-	byte |= 1UL << shiftNumber;
-	return byte;
-}
+/**
+ * @file PoolRawAccessHelper.cpp
+ *
+ * @date 22.12.2019
+ * @author R. Mueller
+ */
+
+#include "../datapool/PoolRawAccessHelper.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+#include <cmath>
+#include <cstring>
+
+PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
+		uint8_t  numberOfParameters_):
+		poolIdBuffer(reinterpret_cast<uint8_t * >(poolIdBuffer_)),
+		numberOfParameters(numberOfParameters_), validBufferIndex(0),
+		validBufferIndexBit(1) {
+}
+
+PoolRawAccessHelper::~PoolRawAccessHelper() {
+}
+
+ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
+		const size_t max_size, SerializeIF::Endianness streamEndianness) {
+	SerializationArgs serializationArgs = {buffer, size, max_size,
+	        streamEndianness};
+	ReturnValue_t result = RETURN_OK;
+	size_t remainingParametersSize = numberOfParameters * 4;
+	for(uint8_t count=0; count < numberOfParameters; count++) {
+		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
+				&remainingParametersSize, false);
+		if(result != RETURN_OK) {
+			return result;
+		}
+	}
+	if(remainingParametersSize != 0) {
+		sif::debug << "PoolRawAccessHelper: "
+				"Remaining parameters size not 0 !" << std::endl;
+		result = RETURN_FAILED;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
+		size_t * size, const size_t max_size,
+		SerializeIF::Endianness streamEndianness) {
+	ReturnValue_t result = RETURN_OK;
+	SerializationArgs argStruct = {buffer, size, max_size, streamEndianness};
+	size_t remainingParametersSize = numberOfParameters * 4;
+	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
+	uint8_t validityMask[validityMaskSize];
+	memset(validityMask,0, validityMaskSize);
+	for(uint8_t count = 0; count < numberOfParameters; count++) {
+		result = serializeCurrentPoolEntryIntoBuffer(argStruct,
+				&remainingParametersSize,true,validityMask);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	if(remainingParametersSize != 0) {
+		sif::debug << "PoolRawAccessHelper: Remaining "
+				"parameters size not 0 !" << std::endl;
+		result = RETURN_FAILED;
+	}
+
+	memcpy(*argStruct.buffer, validityMask, validityMaskSize);
+	*size += validityMaskSize;
+	validBufferIndex = 1;
+	validBufferIndexBit = 0;
+	return result;
+}
+
+ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
+		SerializationArgs argStruct, size_t * remainingParameters,
+		bool withValidMask, uint8_t * validityMask) {
+	uint32_t currentPoolId;
+	// Deserialize current pool ID from pool ID buffer
+	ReturnValue_t result = SerializeAdapter::deSerialize(&currentPoolId,
+			&poolIdBuffer,remainingParameters, SerializeIF::Endianness::MACHINE);
+	if(result != RETURN_OK) {
+		sif::debug << std::hex << "PoolRawAccessHelper: Error deSeralizing "
+				"pool IDs" << std::dec << std::endl;
+		return result;
+	}
+	result = handlePoolEntrySerialization(currentPoolId, argStruct,
+			withValidMask, validityMask);
+	return result;
+}
+
+ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
+		uint32_t currentPoolId,SerializationArgs argStruct, bool withValidMask,
+		uint8_t * validityMask) {
+	ReturnValue_t result = RETURN_FAILED;
+	uint8_t arrayPosition = 0;
+	uint8_t counter = 0;
+	bool poolEntrySerialized = false;
+	//debug << "Pool Raw Access Helper: Handling Pool ID: "
+	//      << std::hex <<  currentPoolId << std::endl;
+	while(not poolEntrySerialized) {
+
+		if(counter > GlobDataSet::DATA_SET_MAX_SIZE) {
+			sif::error << "PoolRawAccessHelper: Config error, "
+					 "max. number of possible data set variables exceeded"
+				  << std::endl;
+			return result;
+		}
+		counter ++;
+
+		GlobDataSet currentDataSet;
+		//debug << "Current array position: " << (int)arrayPosition << std::endl;
+		PoolRawAccess currentPoolRawAccess(currentPoolId, arrayPosition,
+				&currentDataSet, PoolVariableIF::VAR_READ);
+
+		result = currentDataSet.read();
+		if (result != RETURN_OK) {
+			sif::debug << std::hex << "PoolRawAccessHelper: Error reading raw "
+					"dataset with returncode 0x" << result << std::dec << std::endl;
+			return result;
+		}
+
+		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized,
+				&arrayPosition);
+		if(result != RETURN_OK) {
+			sif::error << "Pool Raw Access Helper: Configuration Error at pool ID "
+				  << std::hex << currentPoolId
+				  << ". Size till end smaller than 0" << std::dec << std::endl;
+			return result;
+		}
+
+		// set valid mask bit if necessary
+		if(withValidMask) {
+			if(currentPoolRawAccess.isValid()) {
+				handleMaskModification(validityMask);
+			}
+			validBufferIndexBit ++;
+		}
+
+		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
+				argStruct.max_size, argStruct.streamEndianness);
+		if (result != RETURN_OK) {
+			sif::debug << "Pool Raw Access Helper: Error serializing pool data with "
+					 "ID 0x" << std::hex << currentPoolId << " into send buffer "
+					 "with return code " << result << std::dec << std::endl;
+			return result;
+		}
+
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess*
+		currentPoolRawAccess, bool * isSerialized, uint8_t * arrayPosition) {
+	int8_t remainingSize = currentPoolRawAccess->getSizeTillEnd() -
+			currentPoolRawAccess->getSizeOfType();
+	if(remainingSize == 0) {
+		*isSerialized = true;
+	}
+	else if(remainingSize > 0) {
+		*arrayPosition += 1;
+	}
+	else {
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
+	validityMask[validBufferIndex] =
+			bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
+	if(validBufferIndexBit == 8) {
+		validBufferIndex ++;
+		validBufferIndexBit = 1;
+	}
+}
+
+uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position,
+		bool value) {
+	if(position < 1 or position > 8) {
+		sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+		return byte;
+	}
+	uint8_t shiftNumber = position + (6 - 2 * (position - 1));
+	byte |= 1UL << shiftNumber;
+	return byte;
+}
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index a09f7a2f7..db25acdf8 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -1,111 +1,111 @@
-/**
- * @file PoolRawAccessHelper.h
- *
- * @date 22.12.2019
- */
-
-#ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
-#define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/PoolRawAccess.h"
-
-/**
- * @brief 	This helper function simplifies accessing data pool entries
- *  	  	via PoolRawAccess
- * @details Can be used for a Housekeeping Service
- * 			like  ECSS PUS Service 3 if the type of the datapool entries is unknown.
- * 			The provided dataset can be serialized into a provided buffer automatically by
- * 			providing a buffer of pool IDs
- * @ingroup data_pool
- */
-class PoolRawAccessHelper: public HasReturnvaluesIF {
-public:
-	/**
-	 * Call this constructor if a dataset needs to be serialized via
-	 * Pool Raw Access
-	 * @param dataSet_ This dataset will be used to perform thread-safe reading
-	 * @param poolIdBuffer_ A buffer of uint32_t pool IDs
-	 * @param numberOfParameters_ The number of parameters / pool IDs
-	 */
-	PoolRawAccessHelper(uint32_t * poolIdBuffer_, uint8_t numberOfParameters_);
-	virtual ~PoolRawAccessHelper();
-
-	/**
-	 * Serialize the datapool entries derived from the pool ID buffer
-	 * directly into a provided buffer
-	 * @param [out] buffer
-	 * @param [out] size Size of the serialized buffer
-	 * @param max_size
-	 * @param bigEndian
-	 * @return 	@c RETURN_OK On success
-	 * 			@c RETURN_FAILED on failure
-	 */
-	ReturnValue_t serialize(uint8_t ** buffer, size_t * size,
-			const size_t max_size, SerializeIF::Endianness streamEndianness);
-
-	/**
-	 * Serializes data pool entries into provided buffer with the validity mask buffer
-	 * at the end of the buffer. Every bit of the validity mask denotes
-	 * the validity of a corresponding data pool entry from left to right.
-	 * @param [out] buffer
-	 * @param [out] size Size of the serialized buffer plus size
-	 *                   of the validity mask
-	 * @return 	@c RETURN_OK On success
-	 * 			@c RETURN_FAILED on failure
-	 */
-	ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, size_t * size,
-			const size_t max_size, SerializeIF::Endianness streamEndianness);
-
-
-private:
-	// DataSet * dataSet;
-	const uint8_t * poolIdBuffer;
-	uint8_t numberOfParameters;
-
-	uint8_t validBufferIndex;
-	uint8_t validBufferIndexBit;
-
-	struct SerializationArgs {
-		uint8_t ** buffer;
-		size_t * size;
-		const size_t max_size;
-		SerializeIF::Endianness streamEndianness;
-	};
-	/**
-	 * Helper function to serialize single pool entries
-	 * @param pPoolIdBuffer
-	 * @param buffer
-	 * @param remainingParameters
-	 * @param hkDataSize
-	 * @param max_size
-	 * @param bigEndian
-	 * @param withValidMask Can be set optionally to set a
-	 *        provided validity mask
-	 * @param validityMask Can be supplied and will be set if
-	 *  	  @c withValidMask is set to true
-	 * @return
-	 */
-	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(
-			SerializationArgs argStruct, size_t * remainingParameters,
-			bool withValidMask = false, uint8_t * validityMask = nullptr);
-
-	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,
-			SerializationArgs argStruct, bool withValidMask = false,
-			uint8_t * validityMask = nullptr);
-
-	ReturnValue_t checkRemainingSize(PoolRawAccess * currentPoolRawAccess,
-			bool * isSerialized, uint8_t * arrayPosition);
-	void handleMaskModification(uint8_t * validityMask);
-	/**
-	 * Sets specific bit of a byte
-	 * @param byte
-	 * @param position Position of byte to set from 1 to 8
-	 * @param value Binary value to set
-	 * @return
-	 */
-	uint8_t bitSetter(uint8_t byte, uint8_t position, bool value);
-};
-
-#endif /* FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_ */
+/**
+ * @file PoolRawAccessHelper.h
+ *
+ * @date 22.12.2019
+ */
+
+#ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
+#define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/PoolRawAccess.h"
+
+/**
+ * @brief 	This helper function simplifies accessing data pool entries
+ *  	  	via PoolRawAccess
+ * @details Can be used for a Housekeeping Service
+ * 			like  ECSS PUS Service 3 if the type of the datapool entries is unknown.
+ * 			The provided dataset can be serialized into a provided buffer automatically by
+ * 			providing a buffer of pool IDs
+ * @ingroup data_pool
+ */
+class PoolRawAccessHelper: public HasReturnvaluesIF {
+public:
+	/**
+	 * Call this constructor if a dataset needs to be serialized via
+	 * Pool Raw Access
+	 * @param dataSet_ This dataset will be used to perform thread-safe reading
+	 * @param poolIdBuffer_ A buffer of uint32_t pool IDs
+	 * @param numberOfParameters_ The number of parameters / pool IDs
+	 */
+	PoolRawAccessHelper(uint32_t * poolIdBuffer_, uint8_t numberOfParameters_);
+	virtual ~PoolRawAccessHelper();
+
+	/**
+	 * Serialize the datapool entries derived from the pool ID buffer
+	 * directly into a provided buffer
+	 * @param [out] buffer
+	 * @param [out] size Size of the serialized buffer
+	 * @param max_size
+	 * @param bigEndian
+	 * @return 	@c RETURN_OK On success
+	 * 			@c RETURN_FAILED on failure
+	 */
+	ReturnValue_t serialize(uint8_t ** buffer, size_t * size,
+			const size_t max_size, SerializeIF::Endianness streamEndianness);
+
+	/**
+	 * Serializes data pool entries into provided buffer with the validity mask buffer
+	 * at the end of the buffer. Every bit of the validity mask denotes
+	 * the validity of a corresponding data pool entry from left to right.
+	 * @param [out] buffer
+	 * @param [out] size Size of the serialized buffer plus size
+	 *                   of the validity mask
+	 * @return 	@c RETURN_OK On success
+	 * 			@c RETURN_FAILED on failure
+	 */
+	ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, size_t * size,
+			const size_t max_size, SerializeIF::Endianness streamEndianness);
+
+
+private:
+	// DataSet * dataSet;
+	const uint8_t * poolIdBuffer;
+	uint8_t numberOfParameters;
+
+	uint8_t validBufferIndex;
+	uint8_t validBufferIndexBit;
+
+	struct SerializationArgs {
+		uint8_t ** buffer;
+		size_t * size;
+		const size_t max_size;
+		SerializeIF::Endianness streamEndianness;
+	};
+	/**
+	 * Helper function to serialize single pool entries
+	 * @param pPoolIdBuffer
+	 * @param buffer
+	 * @param remainingParameters
+	 * @param hkDataSize
+	 * @param max_size
+	 * @param bigEndian
+	 * @param withValidMask Can be set optionally to set a
+	 *        provided validity mask
+	 * @param validityMask Can be supplied and will be set if
+	 *  	  @c withValidMask is set to true
+	 * @return
+	 */
+	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(
+			SerializationArgs argStruct, size_t * remainingParameters,
+			bool withValidMask = false, uint8_t * validityMask = nullptr);
+
+	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,
+			SerializationArgs argStruct, bool withValidMask = false,
+			uint8_t * validityMask = nullptr);
+
+	ReturnValue_t checkRemainingSize(PoolRawAccess * currentPoolRawAccess,
+			bool * isSerialized, uint8_t * arrayPosition);
+	void handleMaskModification(uint8_t * validityMask);
+	/**
+	 * Sets specific bit of a byte
+	 * @param byte
+	 * @param position Position of byte to set from 1 to 8
+	 * @param value Binary value to set
+	 * @return
+	 */
+	uint8_t bitSetter(uint8_t byte, uint8_t position, bool value);
+};
+
+#endif /* FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_ */
diff --git a/datapool/PoolVarList.h b/datapool/PoolVarList.h
index 10c0e074a..1c8a7be48 100644
--- a/datapool/PoolVarList.h
+++ b/datapool/PoolVarList.h
@@ -1,28 +1,28 @@
-#ifndef POOLVARLIST_H_
-#define POOLVARLIST_H_
-
-#include "../datapool/PoolVariableIF.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-template <class T, uint8_t n_var>
-class PoolVarList {
-private:
-	GlobPoolVar<T> variables[n_var];
-public:
-	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
-		//I really should have a look at the new init list c++ syntax.
-		if (dataSet == NULL) {
-			return;
-		}
-		for (uint8_t count = 0; count < n_var; count++) {
-			variables[count].dataPoolId = set_id[count];
-			variables[count].readWriteMode = setReadWriteMode;
-			dataSet->registerVariable(&variables[count]);
-		}
-	}
-
-	GlobPoolVar<T> &operator [](int i) { return variables[i]; }
-};
-
-
-
-#endif /* POOLVARLIST_H_ */
+#ifndef POOLVARLIST_H_
+#define POOLVARLIST_H_
+
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+template <class T, uint8_t n_var>
+class PoolVarList {
+private:
+	GlobPoolVar<T> variables[n_var];
+public:
+	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
+		//I really should have a look at the new init list c++ syntax.
+		if (dataSet == NULL) {
+			return;
+		}
+		for (uint8_t count = 0; count < n_var; count++) {
+			variables[count].dataPoolId = set_id[count];
+			variables[count].readWriteMode = setReadWriteMode;
+			dataSet->registerVariable(&variables[count]);
+		}
+	}
+
+	GlobPoolVar<T> &operator [](int i) { return variables[i]; }
+};
+
+
+
+#endif /* POOLVARLIST_H_ */
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 669bcc00c..029a336d1 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,300 +1,300 @@
-#include "../datapoolglob/DataPoolAdmin.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapoolglob/PoolRawAccess.h"
-#include "../ipc/CommandMessage.h"
-#include "../ipc/QueueFactory.h"
-#include "../parameters/ParameterMessage.h"
-
-DataPoolAdmin::DataPoolAdmin(object_id_t objectId) :
-		SystemObject(objectId), storage(NULL), commandQueue(NULL), memoryHelper(
-				this, NULL), actionHelper(this, NULL) {
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-DataPoolAdmin::~DataPoolAdmin() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t DataPoolAdmin::performOperation(uint8_t opCode) {
-	handleCommand();
-	return RETURN_OK;
-}
-
-MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
-	if (actionId != SET_VALIDITY) {
-		return INVALID_ACTION_ID;
-	}
-
-	if (size != 5) {
-		return INVALID_PARAMETERS;
-	}
-
-	uint32_t address = (data[0] << 24) | (data[1] << 16) | (data[2] << 8)
-			| data[3];
-
-	uint8_t valid = data[4];
-
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-
-	GlobDataSet mySet;
-	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
-	ReturnValue_t status = mySet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	if (valid != 0) {
-		variable.setValid(PoolVariableIF::VALID);
-	} else {
-		variable.setValid(PoolVariableIF::INVALID);
-	}
-
-	mySet.commit();
-
-	return EXECUTION_FINISHED;
-}
-
-ReturnValue_t DataPoolAdmin::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-void DataPoolAdmin::handleCommand() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != RETURN_OK) {
-		return;
-	}
-
-	result = actionHelper.handleActionMessage(&command);
-
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-
-	result = handleParameterCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-
-	result = memoryHelper.handleMemoryCommand(&command);
-	if (result != RETURN_OK) {
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
-}
-
-ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
-		const uint8_t* data, size_t size, uint8_t** dataPointer) {
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
-	GlobDataSet testSet;
-	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
-			PoolVariableIF::VAR_READ);
-	ReturnValue_t status = testSet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	uint8_t typeSize = varToGetSize.getSizeOfType();
-
-	if (size % typeSize != 0) {
-		return INVALID_SIZE;
-	}
-
-	if (size > varToGetSize.getSizeTillEnd()) {
-		return INVALID_SIZE;
-	}
-	const uint8_t* readPosition = data;
-
-	for (; size > 0; size -= typeSize) {
-		GlobDataSet rawSet;
-		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
-				PoolVariableIF::VAR_READ_WRITE);
-		status = rawSet.read();
-		if (status == RETURN_OK) {
-			status = variable.setEntryFromBigEndian(readPosition, typeSize);
-			if (status == RETURN_OK) {
-				status = rawSet.commit();
-			}
-		}
-		arrayIndex += 1;
-		readPosition += typeSize;
-	}
-	return ACTIVITY_COMPLETED;
-}
-
-ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
-		uint8_t** dataPointer, uint8_t* copyHere) {
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
-	GlobDataSet testSet;
-	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
-			PoolVariableIF::VAR_READ);
-	ReturnValue_t status = testSet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	uint8_t typeSize = varToGetSize.getSizeOfType();
-	if (size > varToGetSize.getSizeTillEnd()) {
-		return INVALID_SIZE;
-	}
-	uint8_t* ptrToCopy = copyHere;
-	for (; size > 0; size -= typeSize) {
-		GlobDataSet rawSet;
-		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
-				PoolVariableIF::VAR_READ);
-		status = rawSet.read();
-		if (status == RETURN_OK) {
-			size_t temp = 0;
-			status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
-			if (status != RETURN_OK) {
-				return RETURN_FAILED;
-			}
-		} else {
-			//Error reading parameter.
-		}
-		arrayIndex += 1;
-		ptrToCopy += typeSize;
-	}
-	return ACTIVITY_COMPLETED;
-}
-
-ReturnValue_t DataPoolAdmin::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = memoryHelper.initialize(commandQueue);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (storage == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	result = actionHelper.initialize(commandQueue);
-
-	return result;
-}
-
-//mostly identical to ParameterHelper::handleParameterMessage()
-ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch (command->getCommand()) {
-	case ParameterMessage::CMD_PARAMETER_DUMP: {
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(command));
-
-		DataPoolParameterWrapper wrapper;
-		result = wrapper.set(domain, parameterId);
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(command->getSender(),
-					ParameterMessage::getParameterId(command), &wrapper);
-		}
-	}
-		break;
-	case ParameterMessage::CMD_PARAMETER_LOAD: {
-
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(command));
-		uint8_t index = HasParametersIF::getIndex(
-				ParameterMessage::getParameterId(command));
-
-		const uint8_t *storedStream;
-		size_t storedStreamSize;
-		result = storage->getData(ParameterMessage::getStoreId(command),
-				&storedStream, &storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-
-		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(storedStream, storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(command));
-			break;
-		}
-
-		DataPoolParameterWrapper poolWrapper;
-		result = poolWrapper.set(domain, parameterId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(command));
-			break;
-		}
-
-		result = poolWrapper.copyFrom(&streamWrapper, index);
-
-		storage->deleteData(ParameterMessage::getStoreId(command));
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(command->getSender(),
-					ParameterMessage::getParameterId(command), &poolWrapper);
-		}
-	}
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		rejectCommand(command->getSender(), result, command->getCommand());
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-//identical to ParameterHelper::sendParameter()
-ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
-		const DataPoolParameterWrapper* wrapper) {
-	size_t serializedSize = wrapper->getSerializedSize();
-
-	uint8_t *storeElement;
-	store_address_t address;
-
-	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
-			&storeElement);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	size_t storeElementSize = 0;
-
-	result = wrapper->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		storage->deleteData(address);
-		return result;
-	}
-
-	CommandMessage reply;
-
-	ParameterMessage::setParameterDumpReply(&reply, id, address);
-
-	commandQueue->sendMessage(to, &reply);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//identical to ParameterHelper::rejectCommand()
-void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-		Command_t initialCommand) {
-	CommandMessage reply;
-	reply.setReplyRejected(reason, initialCommand);
-	commandQueue->sendMessage(to, &reply);
-}
+#include "../datapoolglob/DataPoolAdmin.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../ipc/CommandMessage.h"
+#include "../ipc/QueueFactory.h"
+#include "../parameters/ParameterMessage.h"
+
+DataPoolAdmin::DataPoolAdmin(object_id_t objectId) :
+		SystemObject(objectId), storage(NULL), commandQueue(NULL), memoryHelper(
+				this, NULL), actionHelper(this, NULL) {
+	commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+DataPoolAdmin::~DataPoolAdmin() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t DataPoolAdmin::performOperation(uint8_t opCode) {
+	handleCommand();
+	return RETURN_OK;
+}
+
+MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
+	if (actionId != SET_VALIDITY) {
+		return INVALID_ACTION_ID;
+	}
+
+	if (size != 5) {
+		return INVALID_PARAMETERS;
+	}
+
+	uint32_t address = (data[0] << 24) | (data[1] << 16) | (data[2] << 8)
+			| data[3];
+
+	uint8_t valid = data[4];
+
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+
+	GlobDataSet mySet;
+	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
+	ReturnValue_t status = mySet.read();
+	if (status != RETURN_OK) {
+		return INVALID_ADDRESS;
+	}
+	if (valid != 0) {
+		variable.setValid(PoolVariableIF::VALID);
+	} else {
+		variable.setValid(PoolVariableIF::INVALID);
+	}
+
+	mySet.commit();
+
+	return EXECUTION_FINISHED;
+}
+
+ReturnValue_t DataPoolAdmin::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+void DataPoolAdmin::handleCommand() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != RETURN_OK) {
+		return;
+	}
+
+	result = actionHelper.handleActionMessage(&command);
+
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+
+	result = handleParameterCommand(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+
+	result = memoryHelper.handleMemoryCommand(&command);
+	if (result != RETURN_OK) {
+		command.setToUnknownCommand();
+		commandQueue->reply(&command);
+	}
+}
+
+ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
+		const uint8_t* data, size_t size, uint8_t** dataPointer) {
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
+	GlobDataSet testSet;
+	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
+			PoolVariableIF::VAR_READ);
+	ReturnValue_t status = testSet.read();
+	if (status != RETURN_OK) {
+		return INVALID_ADDRESS;
+	}
+	uint8_t typeSize = varToGetSize.getSizeOfType();
+
+	if (size % typeSize != 0) {
+		return INVALID_SIZE;
+	}
+
+	if (size > varToGetSize.getSizeTillEnd()) {
+		return INVALID_SIZE;
+	}
+	const uint8_t* readPosition = data;
+
+	for (; size > 0; size -= typeSize) {
+		GlobDataSet rawSet;
+		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
+				PoolVariableIF::VAR_READ_WRITE);
+		status = rawSet.read();
+		if (status == RETURN_OK) {
+			status = variable.setEntryFromBigEndian(readPosition, typeSize);
+			if (status == RETURN_OK) {
+				status = rawSet.commit();
+			}
+		}
+		arrayIndex += 1;
+		readPosition += typeSize;
+	}
+	return ACTIVITY_COMPLETED;
+}
+
+ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
+		uint8_t** dataPointer, uint8_t* copyHere) {
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
+	GlobDataSet testSet;
+	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
+			PoolVariableIF::VAR_READ);
+	ReturnValue_t status = testSet.read();
+	if (status != RETURN_OK) {
+		return INVALID_ADDRESS;
+	}
+	uint8_t typeSize = varToGetSize.getSizeOfType();
+	if (size > varToGetSize.getSizeTillEnd()) {
+		return INVALID_SIZE;
+	}
+	uint8_t* ptrToCopy = copyHere;
+	for (; size > 0; size -= typeSize) {
+		GlobDataSet rawSet;
+		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
+				PoolVariableIF::VAR_READ);
+		status = rawSet.read();
+		if (status == RETURN_OK) {
+			size_t temp = 0;
+			status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
+			if (status != RETURN_OK) {
+				return RETURN_FAILED;
+			}
+		} else {
+			//Error reading parameter.
+		}
+		arrayIndex += 1;
+		ptrToCopy += typeSize;
+	}
+	return ACTIVITY_COMPLETED;
+}
+
+ReturnValue_t DataPoolAdmin::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = memoryHelper.initialize(commandQueue);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (storage == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	result = actionHelper.initialize(commandQueue);
+
+	return result;
+}
+
+//mostly identical to ParameterHelper::handleParameterMessage()
+ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	switch (command->getCommand()) {
+	case ParameterMessage::CMD_PARAMETER_DUMP: {
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(command));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(command));
+
+		DataPoolParameterWrapper wrapper;
+		result = wrapper.set(domain, parameterId);
+
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(command->getSender(),
+					ParameterMessage::getParameterId(command), &wrapper);
+		}
+	}
+		break;
+	case ParameterMessage::CMD_PARAMETER_LOAD: {
+
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(command));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(command));
+		uint8_t index = HasParametersIF::getIndex(
+				ParameterMessage::getParameterId(command));
+
+		const uint8_t *storedStream;
+		size_t storedStreamSize;
+		result = storage->getData(ParameterMessage::getStoreId(command),
+				&storedStream, &storedStreamSize);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+
+		ParameterWrapper streamWrapper;
+		result = streamWrapper.set(storedStream, storedStreamSize);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(command));
+			break;
+		}
+
+		DataPoolParameterWrapper poolWrapper;
+		result = poolWrapper.set(domain, parameterId);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(command));
+			break;
+		}
+
+		result = poolWrapper.copyFrom(&streamWrapper, index);
+
+		storage->deleteData(ParameterMessage::getStoreId(command));
+
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(command->getSender(),
+					ParameterMessage::getParameterId(command), &poolWrapper);
+		}
+	}
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		rejectCommand(command->getSender(), result, command->getCommand());
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+//identical to ParameterHelper::sendParameter()
+ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
+		const DataPoolParameterWrapper* wrapper) {
+	size_t serializedSize = wrapper->getSerializedSize();
+
+	uint8_t *storeElement;
+	store_address_t address;
+
+	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
+			&storeElement);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	size_t storeElementSize = 0;
+
+	result = wrapper->serialize(&storeElement, &storeElementSize,
+			serializedSize, SerializeIF::Endianness::BIG);
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		storage->deleteData(address);
+		return result;
+	}
+
+	CommandMessage reply;
+
+	ParameterMessage::setParameterDumpReply(&reply, id, address);
+
+	commandQueue->sendMessage(to, &reply);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+//identical to ParameterHelper::rejectCommand()
+void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+		Command_t initialCommand) {
+	CommandMessage reply;
+	reply.setReplyRejected(reason, initialCommand);
+	commandQueue->sendMessage(to, &reply);
+}
diff --git a/datapoolglob/DataPoolAdmin.h b/datapoolglob/DataPoolAdmin.h
index 3d5d4d0c0..a08f322d9 100644
--- a/datapoolglob/DataPoolAdmin.h
+++ b/datapoolglob/DataPoolAdmin.h
@@ -1,59 +1,59 @@
-#ifndef DATAPOOLADMIN_H_
-#define DATAPOOLADMIN_H_
-
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../action/HasActionsIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../parameters/ReceivesParameterMessagesIF.h"
-
-#include "../memory/MemoryHelper.h"
-#include "../action/SimpleActionHelper.h"
-#include "../datapoolglob/DataPoolParameterWrapper.h"
-
-class DataPoolAdmin: public HasActionsIF,
-		public ExecutableObjectIF,
-		public AcceptsMemoryMessagesIF,
-		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF,
-		public SystemObject {
-public:
-	static const ActionId_t SET_VALIDITY = 1;
-
-	DataPoolAdmin(object_id_t objectId);
-
-	~DataPoolAdmin();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
-			size_t size, uint8_t** dataPointer);
-	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
-			uint8_t** dataPointer, uint8_t* copyHere);
-
-	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
-
-	//not implemented as ParameterHelper is no used
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-	ReturnValue_t initialize();
-private:
-	StorageManagerIF *storage;
-	MessageQueueIF* commandQueue;
-	MemoryHelper memoryHelper;
-	SimpleActionHelper actionHelper;
-	void handleCommand();
-	ReturnValue_t handleParameterCommand(CommandMessage *command);
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
-			const DataPoolParameterWrapper* wrapper);
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-			Command_t initialCommand);
-};
-
-#endif /* DATAPOOLADMIN_H_ */
+#ifndef DATAPOOLADMIN_H_
+#define DATAPOOLADMIN_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../action/HasActionsIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../parameters/ReceivesParameterMessagesIF.h"
+
+#include "../memory/MemoryHelper.h"
+#include "../action/SimpleActionHelper.h"
+#include "../datapoolglob/DataPoolParameterWrapper.h"
+
+class DataPoolAdmin: public HasActionsIF,
+		public ExecutableObjectIF,
+		public AcceptsMemoryMessagesIF,
+		public HasReturnvaluesIF,
+		public ReceivesParameterMessagesIF,
+		public SystemObject {
+public:
+	static const ActionId_t SET_VALIDITY = 1;
+
+	DataPoolAdmin(object_id_t objectId);
+
+	~DataPoolAdmin();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
+			size_t size, uint8_t** dataPointer);
+	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
+			uint8_t** dataPointer, uint8_t* copyHere);
+
+	ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
+
+	//not implemented as ParameterHelper is no used
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+	ReturnValue_t initialize();
+private:
+	StorageManagerIF *storage;
+	MessageQueueIF* commandQueue;
+	MemoryHelper memoryHelper;
+	SimpleActionHelper actionHelper;
+	void handleCommand();
+	ReturnValue_t handleParameterCommand(CommandMessage *command);
+	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
+			const DataPoolParameterWrapper* wrapper);
+	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+			Command_t initialCommand);
+};
+
+#endif /* DATAPOOLADMIN_H_ */
diff --git a/datapoolglob/DataPoolParameterWrapper.cpp b/datapoolglob/DataPoolParameterWrapper.cpp
index 597cc86b7..3a57d90df 100644
--- a/datapoolglob/DataPoolParameterWrapper.cpp
+++ b/datapoolglob/DataPoolParameterWrapper.cpp
@@ -1,179 +1,179 @@
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/DataPoolParameterWrapper.h"
-#include "../datapoolglob/PoolRawAccess.h"
-#include "../parameters/HasParametersIF.h"
-
-
-DataPoolParameterWrapper::DataPoolParameterWrapper() :
-		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
-				PoolVariableIF::NO_PARAMETER) {
-
-}
-
-DataPoolParameterWrapper::~DataPoolParameterWrapper() {
-
-}
-
-ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
-		uint16_t parameterId) {
-	poolId = (domainId << 16) + parameterId;
-
-	GlobDataSet mySet;
-	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
-	ReturnValue_t status = mySet.read();
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		//should only fail for invalid pool id
-		return HasParametersIF::INVALID_MATRIX_ID;
-	}
-
-	type = raw.getType();
-	rows = raw.getArraySize();
-	columns = 1;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result;
-
-	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&columns, buffer, size,
-			maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	for (uint8_t index = 0; index < rows; index++){
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
-		mySet.read();
-		result = raw.serialize(buffer,size,maxSize,streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//same as ParameterWrapper
-size_t DataPoolParameterWrapper::getSerializedSize() const {
-	size_t serializedSize = 0;
-	serializedSize += type.getSerializedSize();
-	serializedSize += sizeof(rows);
-	serializedSize += sizeof(columns);
-	serializedSize += rows * columns * type.getSize();
-
-	return serializedSize;
-}
-
-ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-template<typename T>
-ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
-		uint8_t startingColumn, const void* from, uint8_t fromRows) {
-	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t *) from;
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-
-	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
-
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
-				PoolVariableIF::VAR_READ_WRITE);
-		mySet.read();
-
-		result = raw.setEntryFromBigEndian(fromAsStream, sizeof(T));
-
-		fromAsStream += sizeof(T);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		mySet.commit();
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::copyFrom(const ParameterWrapper* from,
-		uint16_t startWritingAtIndex) {
-	if (poolId == PoolVariableIF::NO_PARAMETER) {
-		return ParameterWrapper::NOT_SET;
-	}
-
-	if (type != from->type) {
-		return ParameterWrapper::DATATYPE_MISSMATCH;
-	}
-
-	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
-
-	if ((from->rows > (rows - startingRow))
-			|| (from->columns > (columns - startingColumn))) {
-		return ParameterWrapper::TOO_BIG;
-	}
-
-	ReturnValue_t result;
-	//copy data
-	if (from->pointsToStream) {
-		switch (type) {
-		case Type::UINT8_T:
-			result = deSerializeData<uint8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT8_T:
-			result = deSerializeData<int8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT16_T:
-			result = deSerializeData<uint16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT16_T:
-			result = deSerializeData<int16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT32_T:
-			result = deSerializeData<uint32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT32_T:
-			result = deSerializeData<int32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::FLOAT:
-			result = deSerializeData<float>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::DOUBLE:
-			result = deSerializeData<double>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		default:
-			result = ParameterWrapper::UNKNOW_DATATYPE;
-			break;
-		}
-	} else {
-		//not supported
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	return result;
-}
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/DataPoolParameterWrapper.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../parameters/HasParametersIF.h"
+
+
+DataPoolParameterWrapper::DataPoolParameterWrapper() :
+		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
+				PoolVariableIF::NO_PARAMETER) {
+
+}
+
+DataPoolParameterWrapper::~DataPoolParameterWrapper() {
+
+}
+
+ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
+		uint16_t parameterId) {
+	poolId = (domainId << 16) + parameterId;
+
+	GlobDataSet mySet;
+	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
+	ReturnValue_t status = mySet.read();
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		//should only fail for invalid pool id
+		return HasParametersIF::INVALID_MATRIX_ID;
+	}
+
+	type = raw.getType();
+	rows = raw.getArraySize();
+	columns = 1;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result;
+
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&columns, buffer, size,
+			maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	for (uint8_t index = 0; index < rows; index++){
+		GlobDataSet mySet;
+		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
+		mySet.read();
+		result = raw.serialize(buffer,size,maxSize,streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+//same as ParameterWrapper
+size_t DataPoolParameterWrapper::getSerializedSize() const {
+	size_t serializedSize = 0;
+	serializedSize += type.getSerializedSize();
+	serializedSize += sizeof(rows);
+	serializedSize += sizeof(columns);
+	serializedSize += rows * columns * type.getSize();
+
+	return serializedSize;
+}
+
+ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+template<typename T>
+ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
+		uint8_t startingColumn, const void* from, uint8_t fromRows) {
+	//treat from as a continuous Stream as we copy all of it
+	const uint8_t *fromAsStream = (const uint8_t *) from;
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+
+	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
+
+		GlobDataSet mySet;
+		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
+				PoolVariableIF::VAR_READ_WRITE);
+		mySet.read();
+
+		result = raw.setEntryFromBigEndian(fromAsStream, sizeof(T));
+
+		fromAsStream += sizeof(T);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		mySet.commit();
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataPoolParameterWrapper::copyFrom(const ParameterWrapper* from,
+		uint16_t startWritingAtIndex) {
+	if (poolId == PoolVariableIF::NO_PARAMETER) {
+		return ParameterWrapper::NOT_SET;
+	}
+
+	if (type != from->type) {
+		return ParameterWrapper::DATATYPE_MISSMATCH;
+	}
+
+	//check if from fits into this
+	uint8_t startingRow = startWritingAtIndex / columns;
+	uint8_t startingColumn = startWritingAtIndex % columns;
+
+	if ((from->rows > (rows - startingRow))
+			|| (from->columns > (columns - startingColumn))) {
+		return ParameterWrapper::TOO_BIG;
+	}
+
+	ReturnValue_t result;
+	//copy data
+	if (from->pointsToStream) {
+		switch (type) {
+		case Type::UINT8_T:
+			result = deSerializeData<uint8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::INT8_T:
+			result = deSerializeData<int8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::UINT16_T:
+			result = deSerializeData<uint16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::INT16_T:
+			result = deSerializeData<int16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::UINT32_T:
+			result = deSerializeData<uint32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::INT32_T:
+			result = deSerializeData<int32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::FLOAT:
+			result = deSerializeData<float>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::DOUBLE:
+			result = deSerializeData<double>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		default:
+			result = ParameterWrapper::UNKNOW_DATATYPE;
+			break;
+		}
+	} else {
+		//not supported
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	return result;
+}
diff --git a/datapoolglob/DataPoolParameterWrapper.h b/datapoolglob/DataPoolParameterWrapper.h
index 0c5c65ea5..b1e505a75 100644
--- a/datapoolglob/DataPoolParameterWrapper.h
+++ b/datapoolglob/DataPoolParameterWrapper.h
@@ -1,38 +1,38 @@
-#ifndef DATAPOOLPARAMETERWRAPPER_H_
-#define DATAPOOLPARAMETERWRAPPER_H_
-
-#include "../globalfunctions/Type.h"
-#include "../parameters/ParameterWrapper.h"
-
-class DataPoolParameterWrapper: public SerializeIF {
-public:
-	DataPoolParameterWrapper();
-	virtual ~DataPoolParameterWrapper();
-
-	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
-
-	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;
-
-	ReturnValue_t copyFrom(const ParameterWrapper *from,
-			uint16_t startWritingAtIndex);
-
-private:
-	Type type;
-	uint8_t rows;
-	uint8_t columns;
-
-	uint32_t poolId;
-
-	template<typename T>
-	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
-			const void *from, uint8_t fromRows);
-
-};
-
-#endif /* DATAPOOLPARAMETERWRAPPER_H_ */
+#ifndef DATAPOOLPARAMETERWRAPPER_H_
+#define DATAPOOLPARAMETERWRAPPER_H_
+
+#include "../globalfunctions/Type.h"
+#include "../parameters/ParameterWrapper.h"
+
+class DataPoolParameterWrapper: public SerializeIF {
+public:
+	DataPoolParameterWrapper();
+	virtual ~DataPoolParameterWrapper();
+
+	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
+
+	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;
+
+	ReturnValue_t copyFrom(const ParameterWrapper *from,
+			uint16_t startWritingAtIndex);
+
+private:
+	Type type;
+	uint8_t rows;
+	uint8_t columns;
+
+	uint32_t poolId;
+
+	template<typename T>
+	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
+			const void *from, uint8_t fromRows);
+
+};
+
+#endif /* DATAPOOLPARAMETERWRAPPER_H_ */
diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
index aa6831f87..afb27b772 100644
--- a/datapoolglob/GlobalDataPool.cpp
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -1,133 +1,133 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../ipc/MutexFactory.h"
-
-GlobalDataPool::GlobalDataPool(
-		void(*initFunction)(GlobPoolMap* pool_map)) {
-	mutex = MutexFactory::instance()->createMutex();
-	if (initFunction != NULL ) {
-		initFunction( &this->globDataPool );
-	}
-}
-
-GlobalDataPool::~GlobalDataPool() {
-	MutexFactory::instance()->deleteMutex(mutex);
-	for(GlobPoolMapIter it = this->globDataPool.begin();
-	    it != this->globDataPool.end(); ++it )
-	{
-		delete it->second;
-	}
-}
-
-// The function checks PID, type and array length before returning a copy of
-// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
-template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
-		uint8_t sizeOrPosition ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
-		if (entry != nullptr ) {
-			if ( sizeOrPosition <= entry->length ) {
-				return entry;
-			}
-		}
-	}
-	return nullptr;
-}
-
-PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		return it->second;
-	} else {
-		return nullptr;
-	}
-}
-
-ReturnValue_t GlobalDataPool::unlockDataPool() {
-	ReturnValue_t status = mutex->unlockMutex();
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: unlock of mutex failed with"
-				" error code: " << status << std::endl;
-	}
-	return status;
-}
-
-ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
-	        timeoutMs);
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: lock of mutex failed "
-				"with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-void GlobalDataPool::print() {
-	sif::debug << "DataPool contains: " << std::endl;
-	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
-	dataPoolIt = this->globDataPool.begin();
-	while( dataPoolIt != this->globDataPool.end() ) {
-		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
-		dataPoolIt->second->print();
-		dataPoolIt++;
-	}
-}
-
-uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
-	return (parameter_id >> 8) & 0x00FFFFFF;
-}
-
-uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
-	return (parameter_id & 0x000000FF);
-}
-
-uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
-	return (poolId << 8) + index;
-}
-
-
-//SHOULDDO: Do we need a mutex lock here... I don't think so,
-//as we only check static const values of elements in a list that do not change.
-//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
-ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
-	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
-	if ( it != this->globDataPool.end() ) {
-		*type = it->second->getType();
-		return RETURN_OK;
-	} else {
-		*type = Type::UNKNOWN_TYPE;
-		return RETURN_FAILED;
-	}
-}
-
-bool GlobalDataPool::exists(uint32_t parameterId) {
-	uint32_t poolId = PIDToDataPoolId(parameterId);
-	uint32_t index = PIDToArrayIndex(parameterId);
-	GlobPoolMapIter it = this->globDataPool.find( poolId );
-	if (it != globDataPool.end()) {
-		if (it->second->getSize() >= index) {
-			return true;
-		}
-	}
-	return false;
-}
-
-template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
-		uint32_t data_pool_id, uint8_t size);
-template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<float>* GlobalDataPool::getData<float>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<double>* GlobalDataPool::getData<double>(
-		uint32_t data_pool_id, uint8_t size);
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../ipc/MutexFactory.h"
+
+GlobalDataPool::GlobalDataPool(
+		void(*initFunction)(GlobPoolMap* pool_map)) {
+	mutex = MutexFactory::instance()->createMutex();
+	if (initFunction != NULL ) {
+		initFunction( &this->globDataPool );
+	}
+}
+
+GlobalDataPool::~GlobalDataPool() {
+	MutexFactory::instance()->deleteMutex(mutex);
+	for(GlobPoolMapIter it = this->globDataPool.begin();
+	    it != this->globDataPool.end(); ++it )
+	{
+		delete it->second;
+	}
+}
+
+// The function checks PID, type and array length before returning a copy of
+// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
+template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
+		uint8_t sizeOrPosition ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
+		if (entry != nullptr ) {
+			if ( sizeOrPosition <= entry->length ) {
+				return entry;
+			}
+		}
+	}
+	return nullptr;
+}
+
+PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		return it->second;
+	} else {
+		return nullptr;
+	}
+}
+
+ReturnValue_t GlobalDataPool::unlockDataPool() {
+	ReturnValue_t status = mutex->unlockMutex();
+	if(status != RETURN_OK) {
+		sif::error << "DataPool::DataPool: unlock of mutex failed with"
+				" error code: " << status << std::endl;
+	}
+	return status;
+}
+
+ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
+	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
+	        timeoutMs);
+	if(status != RETURN_OK) {
+		sif::error << "DataPool::DataPool: lock of mutex failed "
+				"with error code: " << status << std::endl;
+	}
+	return status;
+}
+
+void GlobalDataPool::print() {
+	sif::debug << "DataPool contains: " << std::endl;
+	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
+	dataPoolIt = this->globDataPool.begin();
+	while( dataPoolIt != this->globDataPool.end() ) {
+		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
+		dataPoolIt->second->print();
+		dataPoolIt++;
+	}
+}
+
+uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
+	return (parameter_id >> 8) & 0x00FFFFFF;
+}
+
+uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
+	return (parameter_id & 0x000000FF);
+}
+
+uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
+	return (poolId << 8) + index;
+}
+
+
+//SHOULDDO: Do we need a mutex lock here... I don't think so,
+//as we only check static const values of elements in a list that do not change.
+//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
+ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
+	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
+	if ( it != this->globDataPool.end() ) {
+		*type = it->second->getType();
+		return RETURN_OK;
+	} else {
+		*type = Type::UNKNOWN_TYPE;
+		return RETURN_FAILED;
+	}
+}
+
+bool GlobalDataPool::exists(uint32_t parameterId) {
+	uint32_t poolId = PIDToDataPoolId(parameterId);
+	uint32_t index = PIDToArrayIndex(parameterId);
+	GlobPoolMapIter it = this->globDataPool.find( poolId );
+	if (it != globDataPool.end()) {
+		if (it->second->getSize() >= index) {
+			return true;
+		}
+	}
+	return false;
+}
+
+template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
+		uint32_t data_pool_id, uint8_t size);
+template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<float>* GlobalDataPool::getData<float>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<double>* GlobalDataPool::getData<double>(
+		uint32_t data_pool_id, uint8_t size);
diff --git a/datapoolglob/GlobalDataPool.h b/datapoolglob/GlobalDataPool.h
index 37a4057bd..ce5b132c0 100644
--- a/datapoolglob/GlobalDataPool.h
+++ b/datapoolglob/GlobalDataPool.h
@@ -1,149 +1,149 @@
-#ifndef GLOBALDATAPOOL_H_
-#define GLOBALDATAPOOL_H_
-
-#include "../datapool/PoolEntry.h"
-#include "../globalfunctions/Type.h"
-#include "../ipc/MutexIF.h"
-#include <map>
-
-/**
- * @defgroup data_pool Global data pool
- * This is the group, where all classes associated with global
- * data pool handling belong to.
- * This includes classes to access Data Pool variables.
- */
-
-/**
- * Typedefs for the global pool representations
- */
-using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
-using GlobPoolMapIter = GlobPoolMap::iterator;
-
-/**
- * @brief		This class represents the OBSW global data-pool.
- *
- * @details
- * All variables are registered and space is allocated in an initialization
- * function, which is passed do the constructor. Space for the variables is
- * allocated on the heap (with a new call).
- *
- * The data is found by a data pool id, which uniquely represents a variable.
- * Data pool variables should be used with a blackboard logic in mind,
- * which means read data is valid (if flagged so),
- * but not necessarily up-to-date.
- *
- * Variables are either single values or arrays.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class GlobalDataPool : public HasReturnvaluesIF {
-private:
-	/**
-	 * @brief	This is the actual data pool itself.
-	 * @details	It is represented by a map with the data pool id as index
-	 * 			and a pointer to a single PoolEntry as value.
-	 */
-	GlobPoolMap globDataPool;
-
-	/**
-	 * @brief	The mutex is created in the constructor and makes
-	 * 			access mutual exclusive.
-	 * @details	Locking and unlocking the pool is only done by the DataSet class.
-	 */
-	MutexIF*	mutex;
-public:
-	/**
-	 * @brief	In the classes constructor,
-	 * 			the passed initialization function is called.
-	 * @details
-	 * To enable filling the pool, a pointer to the map is passed,
-	 * allowing direct access to the pool's content.
-	 * On runtime, adding or removing variables is forbidden.
-	 */
-	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
-
-	/**
-	 * 	@brief	The destructor iterates through the data_pool map and
-	 * 			calls all entries destructors to clean up the heap.
-	 */
-	~GlobalDataPool();
-
-	/**
-	 * @brief	This is the default call to access the pool.
-	 * @details
-	 * A pointer to the PoolEntry object is returned.
-	 * The call checks data pool id, type and array size.
-	 * Returns NULL in case of failure.
-	 * @param data_pool_id	The data pool id to search.
-	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
-	 * or the position the user wants to read.
-	 * 			If smaller than the entry size, everything's ok.
-	 */
-	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
-			uint8_t sizeOrPosition );
-
-	/**
-	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
-	 * 			(i.e. in Housekeeping Telemetry).
-	 * @details	It returns a basic interface and does NOT perform
-	 * 			a size check. The caller has to assure he does not copy too much data.
-	 * 			Returns NULL in case the entry is not found.
-	 * @param data_pool_id	The data pool id to search.
-	 */
-	PoolEntryIF* getRawData( uint32_t data_pool_id );
-	/**
-	 * @brief	This is a small helper function to facilitate locking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
-	/**
-	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to free the mutex.
-	 */
-	ReturnValue_t unlockDataPool();
-	/**
-	 * @brief	The print call is a simple debug method.
-	 * @details	It prints the current content of the data pool.
-	 *  		It iterates through the data_pool map and calls each entry's print() method.
-	 */
-	void print();
-	/**
-	 * Extracts the data pool id from a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The data pool id as used within the OBSW.
-	 */
-	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
-	/**
-	 * Extracts an array index out of a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The index of the corresponding data pool entry.
-	 */
-	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
-	/**
-	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
-	 */
-	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
-
-	/**
-	 * Method to return the type of a pool variable.
-	 * @param parameter_id A parameterID (not pool id) of a DP member.
-	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
-	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
-	 */
-	ReturnValue_t getType( uint32_t parameter_id, Type* type );
-
-	/**
-	 * Method to check if a PID exists. Does not lock, as there's no
-	 * possibility to alter the list that is checked during run-time.
-	 * @param parameterId The PID (not pool id!) of a parameter.
-	 * @return	true if exists, false else.
-	 */
-	bool exists(uint32_t parameterId);
-};
-
-//We assume someone globally instantiates a DataPool.
-namespace glob {
-extern GlobalDataPool dataPool;
-}
-
-#endif /* DATAPOOL_H_ */
+#ifndef GLOBALDATAPOOL_H_
+#define GLOBALDATAPOOL_H_
+
+#include "../datapool/PoolEntry.h"
+#include "../globalfunctions/Type.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+/**
+ * @defgroup data_pool Global data pool
+ * This is the group, where all classes associated with global
+ * data pool handling belong to.
+ * This includes classes to access Data Pool variables.
+ */
+
+/**
+ * Typedefs for the global pool representations
+ */
+using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
+using GlobPoolMapIter = GlobPoolMap::iterator;
+
+/**
+ * @brief		This class represents the OBSW global data-pool.
+ *
+ * @details
+ * All variables are registered and space is allocated in an initialization
+ * function, which is passed do the constructor. Space for the variables is
+ * allocated on the heap (with a new call).
+ *
+ * The data is found by a data pool id, which uniquely represents a variable.
+ * Data pool variables should be used with a blackboard logic in mind,
+ * which means read data is valid (if flagged so),
+ * but not necessarily up-to-date.
+ *
+ * Variables are either single values or arrays.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class GlobalDataPool : public HasReturnvaluesIF {
+private:
+	/**
+	 * @brief	This is the actual data pool itself.
+	 * @details	It is represented by a map with the data pool id as index
+	 * 			and a pointer to a single PoolEntry as value.
+	 */
+	GlobPoolMap globDataPool;
+
+	/**
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking the pool is only done by the DataSet class.
+	 */
+	MutexIF*	mutex;
+public:
+	/**
+	 * @brief	In the classes constructor,
+	 * 			the passed initialization function is called.
+	 * @details
+	 * To enable filling the pool, a pointer to the map is passed,
+	 * allowing direct access to the pool's content.
+	 * On runtime, adding or removing variables is forbidden.
+	 */
+	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
+
+	/**
+	 * 	@brief	The destructor iterates through the data_pool map and
+	 * 			calls all entries destructors to clean up the heap.
+	 */
+	~GlobalDataPool();
+
+	/**
+	 * @brief	This is the default call to access the pool.
+	 * @details
+	 * A pointer to the PoolEntry object is returned.
+	 * The call checks data pool id, type and array size.
+	 * Returns NULL in case of failure.
+	 * @param data_pool_id	The data pool id to search.
+	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
+	 * or the position the user wants to read.
+	 * 			If smaller than the entry size, everything's ok.
+	 */
+	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
+			uint8_t sizeOrPosition );
+
+	/**
+	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
+	 * 			(i.e. in Housekeeping Telemetry).
+	 * @details	It returns a basic interface and does NOT perform
+	 * 			a size check. The caller has to assure he does not copy too much data.
+	 * 			Returns NULL in case the entry is not found.
+	 * @param data_pool_id	The data pool id to search.
+	 */
+	PoolEntryIF* getRawData( uint32_t data_pool_id );
+	/**
+	 * @brief	This is a small helper function to facilitate locking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
+	/**
+	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to free the mutex.
+	 */
+	ReturnValue_t unlockDataPool();
+	/**
+	 * @brief	The print call is a simple debug method.
+	 * @details	It prints the current content of the data pool.
+	 *  		It iterates through the data_pool map and calls each entry's print() method.
+	 */
+	void print();
+	/**
+	 * Extracts the data pool id from a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The data pool id as used within the OBSW.
+	 */
+	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
+	/**
+	 * Extracts an array index out of a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The index of the corresponding data pool entry.
+	 */
+	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
+	/**
+	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
+	 */
+	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
+
+	/**
+	 * Method to return the type of a pool variable.
+	 * @param parameter_id A parameterID (not pool id) of a DP member.
+	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
+	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
+	 */
+	ReturnValue_t getType( uint32_t parameter_id, Type* type );
+
+	/**
+	 * Method to check if a PID exists. Does not lock, as there's no
+	 * possibility to alter the list that is checked during run-time.
+	 * @param parameterId The PID (not pool id!) of a parameter.
+	 * @return	true if exists, false else.
+	 */
+	bool exists(uint32_t parameterId);
+};
+
+//We assume someone globally instantiates a DataPool.
+namespace glob {
+extern GlobalDataPool dataPool;
+}
+
+#endif /* DATAPOOL_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index f5fc49f8b..a995bfaf2 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -1,213 +1,213 @@
-#ifndef GLOBALPOOLVARIABLE_H_
-#define GLOBALPOOLVARIABLE_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-template<typename T, uint8_t n_var> class PoolVarList;
-
-
-/**
- * @brief	This is the access class for non-array data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly
- * on the data pool entries, but on local copies. This class provides simple
- * type-safe access to single data pool entries (i.e. entries with length = 1).
- * The class can be instantiated as read-write and read only.
- * It provides a commit-and-roll-back semantic, which means that the
- * variable's value in the data pool is not changed until the
- * commit call is executed.
- * 	@tparam	T The template parameter sets the type of the variable.
- * 	Currently, all plain data types are supported, but in principle
- * 	any type is possible.
- *	@ingroup data_pool
- */
-template<typename T>
-class GlobPoolVar: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PoolVarList;
-	static_assert(not std::is_same<T, bool>::value,
-			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
-			"There is no boolean type in CCSDS.");
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if nullptr is not passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but
-	 * sets the value attribute to default (0).
-	 * The value is fetched within the read() operation.
-	 * @param set_id	This is the id in the global data pool
-	 * 					this instance of the access class corresponds to.
-	 * @param dataSet	The data set in which the variable shall register
-	 * 					itself. If NULL, the variable is not registered.
-	 * @param setWritable If this flag is set to true, changes in the value
-	 * 			attribute can be written back to the data pool, otherwise not.
-	 */
-	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value = 0;
-
-	/**
-	 * @brief 	Copy ctor to copy classes containing Pool Variables.
-	 * 			(Robin): This only copies member variables, which is done
-	 * 			by the default copy ctor. maybe we can ommit this ctor?
-	 */
-	GlobPoolVar(const GlobPoolVar& rhs);
-
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVar() {}
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * The commit call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool is stored.
-	 */
-	uint32_t dataPoolId;
-
-	/**
-	 * @brief	The valid information as it was stored in the data pool is
-	 * 			copied to this attribute.
-	 */
-	uint8_t valid;
-
-	/**
-	 * @brief	The information whether the class is read-write or read-only
-	 * 			is stored here.
-	 */
-	pool_rwm_t readWriteMode;
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	GlobPoolVar();
-public:
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const override;
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const override;
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-
-	uint8_t getValid();
-
-	void setValid(bool valid) override;
-
-	operator T() {
-		return value;
-	}
-
-	operator T() const {
-		return value;
-	}
-
-	GlobPoolVar<T> &operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
-		value = newPoolVariable.value;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size,
-			SerializeIF::Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, max_size,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-		        streamEndianness);
-	}
-};
-
-#include "../datapoolglob/GlobalPoolVariable.tpp"
-
-typedef GlobPoolVar<uint8_t> gp_bool_t;
-typedef GlobPoolVar<uint8_t> gp_uint8_t;
-typedef GlobPoolVar<uint16_t> gp_uint16_t;
-typedef GlobPoolVar<uint32_t> gp_uint32_t;
-typedef GlobPoolVar<int8_t> gp_int8_t;
-typedef GlobPoolVar<int16_t> gp_int16_t;
-typedef GlobPoolVar<int32_t> gp_int32_t;
-typedef GlobPoolVar<float> gp_float_t;
-typedef GlobPoolVar<double> gp_double_t;
-
-#endif /* POOLVARIABLE_H_ */
+#ifndef GLOBALPOOLVARIABLE_H_
+#define GLOBALPOOLVARIABLE_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+template<typename T, uint8_t n_var> class PoolVarList;
+
+
+/**
+ * @brief	This is the access class for non-array data pool entries.
+ *
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly
+ * on the data pool entries, but on local copies. This class provides simple
+ * type-safe access to single data pool entries (i.e. entries with length = 1).
+ * The class can be instantiated as read-write and read only.
+ * It provides a commit-and-roll-back semantic, which means that the
+ * variable's value in the data pool is not changed until the
+ * commit call is executed.
+ * 	@tparam	T The template parameter sets the type of the variable.
+ * 	Currently, all plain data types are supported, but in principle
+ * 	any type is possible.
+ *	@ingroup data_pool
+ */
+template<typename T>
+class GlobPoolVar: public PoolVariableIF {
+	template<typename U, uint8_t n_var> friend class PoolVarList;
+	static_assert(not std::is_same<T, bool>::value,
+			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
+			"There is no boolean type in CCSDS.");
+public:
+	/**
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if nullptr is not passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but
+	 * sets the value attribute to default (0).
+	 * The value is fetched within the read() operation.
+	 * @param set_id	This is the id in the global data pool
+	 * 					this instance of the access class corresponds to.
+	 * @param dataSet	The data set in which the variable shall register
+	 * 					itself. If NULL, the variable is not registered.
+	 * @param setWritable If this flag is set to true, changes in the value
+	 * 			attribute can be written back to the data pool, otherwise not.
+	 */
+	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
+			ReadWriteMode_t setReadWriteMode);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a simple local variable.
+	 */
+	T value = 0;
+
+	/**
+	 * @brief 	Copy ctor to copy classes containing Pool Variables.
+	 * 			(Robin): This only copies member variables, which is done
+	 * 			by the default copy ctor. maybe we can ommit this ctor?
+	 */
+	GlobPoolVar(const GlobPoolVar& rhs);
+
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVar() {}
+
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout) override;
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * The commit call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool is stored.
+	 */
+	uint32_t dataPoolId;
+
+	/**
+	 * @brief	The valid information as it was stored in the data pool is
+	 * 			copied to this attribute.
+	 */
+	uint8_t valid;
+
+	/**
+	 * @brief	The information whether the class is read-write or read-only
+	 * 			is stored here.
+	 */
+	pool_rwm_t readWriteMode;
+
+	/**
+	 * Empty ctor for List initialization
+	 */
+	GlobPoolVar();
+public:
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const override;
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const override;
+	/**
+	 * This operation sets the data pool id of the variable.
+	 * The method is necessary to set id's of data pool member variables with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+
+	uint8_t getValid();
+
+	void setValid(bool valid) override;
+
+	operator T() {
+		return value;
+	}
+
+	operator T() const {
+		return value;
+	}
+
+	GlobPoolVar<T> &operator=(T newValue) {
+		value = newValue;
+		return *this;
+	}
+
+	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
+		value = newPoolVariable.value;
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size,
+			SerializeIF::Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, max_size,
+				streamEndianness);
+	}
+
+	virtual size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+		        streamEndianness);
+	}
+};
+
+#include "../datapoolglob/GlobalPoolVariable.tpp"
+
+typedef GlobPoolVar<uint8_t> gp_bool_t;
+typedef GlobPoolVar<uint8_t> gp_uint8_t;
+typedef GlobPoolVar<uint16_t> gp_uint16_t;
+typedef GlobPoolVar<uint32_t> gp_uint32_t;
+typedef GlobPoolVar<int8_t> gp_int8_t;
+typedef GlobPoolVar<int16_t> gp_int16_t;
+typedef GlobPoolVar<int32_t> gp_int32_t;
+typedef GlobPoolVar<float> gp_float_t;
+typedef GlobPoolVar<double> gp_double_t;
+
+#endif /* POOLVARIABLE_H_ */
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index eb40d1f18..6b592fc67 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -1,185 +1,185 @@
-#ifndef GLOBALPOOLVECTOR_H_
-#define GLOBALPOOLVECTOR_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-/**
- * @brief	This is the access class for array-type data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly on the
- * data pool entries, but on local copies. This class provides simple type-
- * and length-safe access to vector-style data pool entries (i.e. entries with
- * length > 1). The class can be instantiated as read-write and read only.
- *
- * It provides a commit-and-roll-back semantic, which means that no array
- * entry in the data pool is changed until the commit call is executed.
- * There are two template parameters:
- * @tparam	T
- * This template parameter specifies the data type of an array entry. Currently,
- * all plain data types are supported, but in principle any type is possible.
- * @tparam  vector_size
- * This template parameter specifies the vector size of this entry. Using a
- * template parameter for this is not perfect, but avoids
- * dynamic memory allocation.
- * @ingroup data_pool
- */
-template<typename T, uint16_t vectorSize>
-class GlobPoolVector: public PoolVariableIF {
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if no nullptr is passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but sets the
-	 * value attribute to default (0). The value is fetched within the
-	 * read() operation.
-	 * @param set_id
-	 * This is the id in the global data pool this instance of the access
-	 * class corresponds to.
-	 * @param dataSet
-	 * The data set in which the variable shall register itself. If nullptr,
-	 * the variable is not registered.
-	 * @param setWritable
-	 * If this flag is set to true, changes in the value attribute can be
-	 * written back to the data pool, otherwise not.
-	 */
-	GlobPoolVector(uint32_t set_id, DataSetIF* set,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * @brief This operation sets the data pool id of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid != INVALID)
-			return true;
-		else
-			return false;
-	}
-	void setValid(bool valid) {this->valid = valid;}
-	uint8_t getValid() {return valid;}
-
-	T &operator [](int i) {return value[i];}
-	const T &operator [](int i) const {return value[i];}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t max_size, Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) override;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies all array values
-	 * and the valid information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The commit call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#include "../datapoolglob/GlobalPoolVector.tpp"
-
-template<typename T, uint16_t vectorSize>
-using gp_vec_t = GlobPoolVector<T, vectorSize>;
-
-#endif /* POOLVECTOR_H_ */
+#ifndef GLOBALPOOLVECTOR_H_
+#define GLOBALPOOLVECTOR_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ *
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class GlobPoolVector: public PoolVariableIF {
+public:
+	/**
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if no nullptr is passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but sets the
+	 * value attribute to default (0). The value is fetched within the
+	 * read() operation.
+	 * @param set_id
+	 * This is the id in the global data pool this instance of the access
+	 * class corresponds to.
+	 * @param dataSet
+	 * The data set in which the variable shall register itself. If nullptr,
+	 * the variable is not registered.
+	 * @param setWritable
+	 * If this flag is set to true, changes in the value attribute can be
+	 * written back to the data pool, otherwise not.
+	 */
+	GlobPoolVector(uint32_t set_id, DataSetIF* set,
+			ReadWriteMode_t setReadWriteMode);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a local array of this type.
+	 */
+	T value[vectorSize];
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVector() {};
+	/**
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
+	 */
+	uint8_t getSize() {
+		return vectorSize;
+	}
+	/**
+	 * @brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const {
+		return dataPoolId;
+	}
+	/**
+	 * @brief This operation sets the data pool id of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId) {
+		dataPoolId = poolId;
+	}
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const {
+		return readWriteMode;
+	}
+
+
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const {
+		if (valid != INVALID)
+			return true;
+		else
+			return false;
+	}
+	void setValid(bool valid) {this->valid = valid;}
+	uint8_t getValid() {return valid;}
+
+	T &operator [](int i) {return value[i];}
+	const T &operator [](int i) const {return value[i];}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t max_size, Endianness streamEndianness) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies all array values
+	 * and the valid information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The commit call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+};
+
+#include "../datapoolglob/GlobalPoolVector.tpp"
+
+template<typename T, uint16_t vectorSize>
+using gp_vec_t = GlobPoolVector<T, vectorSize>;
+
+#endif /* POOLVECTOR_H_ */
diff --git a/datapoolglob/PIDReader.h b/datapoolglob/PIDReader.h
index 7d12a0fd6..9431e1d40 100644
--- a/datapoolglob/PIDReader.h
+++ b/datapoolglob/PIDReader.h
@@ -1,164 +1,164 @@
-#ifndef PIDREADER_H_
-#define PIDREADER_H_
-#include "../datapool/DataSetIF.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-template<typename U, uint8_t n_var> class PIDReaderList;
-
-template<typename T>
-class PIDReader: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PIDReaderList;
-protected:
-	uint32_t parameterId;
-	uint8_t valid;
-	ReturnValue_t readWithoutLock() {
-		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
-				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
-		if (read_out != NULL) {
-			valid = read_out->valid;
-			value = read_out->address[arrayIndex];
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			value = 0;
-			valid = false;
-			sif::error << "PIDReader: read of PID 0x" << std::hex << parameterId
-					<< std::dec << " failed." << std::endl;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * Never commit, is read-only.
-	 * Reason is the possibility to access a single DP vector element, but if we commit,
-	 * we set validity of the whole vector.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t commitWithoutLock() override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	PIDReader() :
-			parameterId(PoolVariableIF::NO_PARAMETER), valid(
-					PoolVariableIF::INVALID), value(0) {
-
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 */
-	T value;
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
-	 */
-	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
-			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
-					0) {
-		if (dataSet != NULL) {
-			dataSet->registerVariable(this);
-		}
-	}
-
-	ReturnValue_t read(uint32_t lockTimeout) override {
-		ReturnValue_t result = glob::dataPool.lockDataPool();
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = readWithoutLock();
-		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "PIDReader::read: Could not unlock data pool!"
-					<< std::endl;
-		}
-		return result;
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-	PIDReader(const PIDReader &rhs) :
-			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
-	}
-
-	/**
-	 * \brief	The classes destructor is empty.
-	 */
-	~PIDReader() {
-
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return GlobalDataPool::PIDToDataPoolId(parameterId);
-	}
-	uint32_t getParameterId() const {
-		return parameterId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return VAR_READ;
-	}
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid)
-			return true;
-		else
-			return false;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	void setValid(bool valid) {
-		this->valid = valid;
-	}
-
-	operator T() {
-		return value;
-	}
-
-	PIDReader<T>& operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-				streamEndianness);
-	}
-};
-
-#endif /* PIDREADER_H_ */
+#ifndef PIDREADER_H_
+#define PIDREADER_H_
+#include "../datapool/DataSetIF.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+template<typename U, uint8_t n_var> class PIDReaderList;
+
+template<typename T>
+class PIDReader: public PoolVariableIF {
+	template<typename U, uint8_t n_var> friend class PIDReaderList;
+protected:
+	uint32_t parameterId;
+	uint8_t valid;
+	ReturnValue_t readWithoutLock() {
+		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
+		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
+				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
+		if (read_out != NULL) {
+			valid = read_out->valid;
+			value = read_out->address[arrayIndex];
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			value = 0;
+			valid = false;
+			sif::error << "PIDReader: read of PID 0x" << std::hex << parameterId
+					<< std::dec << " failed." << std::endl;
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	/**
+	 * Never commit, is read-only.
+	 * Reason is the possibility to access a single DP vector element, but if we commit,
+	 * we set validity of the whole vector.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t commitWithoutLock() override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	/**
+	 * Empty ctor for List initialization
+	 */
+	PIDReader() :
+			parameterId(PoolVariableIF::NO_PARAMETER), valid(
+					PoolVariableIF::INVALID), value(0) {
+
+	}
+public:
+	/**
+	 * \brief	This is the local copy of the data pool entry.
+	 */
+	T value;
+	/**
+	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
+	 * 			passed).
+	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
+	 * 			attribute to default (0). The value is fetched within the read() operation.
+	 * \param set_id	This is the id in the global data pool this instance of the access class
+	 * 					corresponds to.
+	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
+	 * 					the variable is not registered.
+	 * \param setWritable If this flag is set to true, changes in the value attribute can be
+	 * 					written back to the data pool, otherwise not.
+	 */
+	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
+			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
+					0) {
+		if (dataSet != NULL) {
+			dataSet->registerVariable(this);
+		}
+	}
+
+	ReturnValue_t read(uint32_t lockTimeout) override {
+		ReturnValue_t result = glob::dataPool.lockDataPool();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = readWithoutLock();
+		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "PIDReader::read: Could not unlock data pool!"
+					<< std::endl;
+		}
+		return result;
+	}
+	/**
+	 * Copy ctor to copy classes containing Pool Variables.
+	 */
+	PIDReader(const PIDReader &rhs) :
+			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
+	}
+
+	/**
+	 * \brief	The classes destructor is empty.
+	 */
+	~PIDReader() {
+
+	}
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const {
+		return GlobalDataPool::PIDToDataPoolId(parameterId);
+	}
+	uint32_t getParameterId() const {
+		return parameterId;
+	}
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const {
+		return VAR_READ;
+	}
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const {
+		if (valid)
+			return true;
+		else
+			return false;
+	}
+
+	uint8_t getValid() {
+		return valid;
+	}
+
+	void setValid(bool valid) {
+		this->valid = valid;
+	}
+
+	operator T() {
+		return value;
+	}
+
+	PIDReader<T>& operator=(T newValue) {
+		value = newValue;
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	virtual size_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+				streamEndianness);
+	}
+};
+
+#endif /* PIDREADER_H_ */
diff --git a/datapoolglob/PIDReaderList.h b/datapoolglob/PIDReaderList.h
index b167feaa0..ae99f3aa2 100644
--- a/datapoolglob/PIDReaderList.h
+++ b/datapoolglob/PIDReaderList.h
@@ -1,27 +1,27 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-
-#include "../datapool/PoolVariableIF.h"
-#include "../datapoolglob/PIDReader.h"
-template <class T, uint8_t n_var>
-class PIDReaderList {
-private:
-	PIDReader<T> variables[n_var];
-public:
-	PIDReaderList( const uint32_t setPid[n_var], DataSetIF* dataSet) {
-		//I really should have a look at the new init list c++ syntax.
-		if (dataSet == NULL) {
-			return;
-		}
-		for (uint8_t count = 0; count < n_var; count++) {
-			variables[count].parameterId = setPid[count];
-			dataSet->registerVariable(&variables[count]);
-		}
-	}
-
-	PIDReader<T> &operator [](int i) { return variables[i]; }
-};
-
-
-
-#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
+#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
+#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
+
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoolglob/PIDReader.h"
+template <class T, uint8_t n_var>
+class PIDReaderList {
+private:
+	PIDReader<T> variables[n_var];
+public:
+	PIDReaderList( const uint32_t setPid[n_var], DataSetIF* dataSet) {
+		//I really should have a look at the new init list c++ syntax.
+		if (dataSet == NULL) {
+			return;
+		}
+		for (uint8_t count = 0; count < n_var; count++) {
+			variables[count].parameterId = setPid[count];
+			dataSet->registerVariable(&variables[count]);
+		}
+	}
+
+	PIDReader<T> &operator [](int i) { return variables[i]; }
+};
+
+
+
+#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index 09093cd6e..53706c6d3 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -1,239 +1,239 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapoolglob/PoolRawAccess.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serialize/EndianConverter.h"
-
-#include <cstring>
-
-PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
-		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
-		readWriteMode(setReadWriteMode) {
-	memset(value, 0, sizeof(value));
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
-
-PoolRawAccess::~PoolRawAccess() {}
-
-ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::readWithoutLock() {
-	ReturnValue_t result = RETURN_FAILED;
-	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
-	if (readOut != nullptr) {
-		result = handleReadOut(readOut);
-		if(result == RETURN_OK) {
-			return result;
-		}
-	} else {
-		result = READ_ENTRY_NON_EXISTENT;
-	}
-	handleReadError(result);
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
-	ReturnValue_t result = RETURN_FAILED;
-	valid = readOut->getValid();
-	if (readOut->getSize() > arrayEntry) {
-		arraySize = readOut->getSize();
-		typeSize = readOut->getByteSize() / readOut->getSize();
-		type = readOut->getType();
-		if (typeSize <= sizeof(value)) {
-			uint16_t arrayPosition = arrayEntry * typeSize;
-			sizeTillEnd = readOut->getByteSize() - arrayPosition;
-			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
-			memcpy(value, ptr, typeSize);
-			return RETURN_OK;
-		} else {
-			result = READ_TYPE_TOO_LARGE;
-		}
-	} else {
-		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
-		result = READ_INDEX_TOO_LARGE;
-	}
-	return result;
-}
-
-void PoolRawAccess::handleReadError(ReturnValue_t result) {
-	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed, ";
-	if(result == READ_TYPE_TOO_LARGE) {
-		sif::error << "type too large." << std::endl;
-	}
-	else if(result == READ_INDEX_TOO_LARGE) {
-		sif::error << "index too large." << std::endl;
-	}
-	else if(result == READ_ENTRY_NON_EXISTENT) {
-		sif::error << "entry does not exist." << std::endl;
-	}
-
-	valid = INVALID;
-	typeSize = 0;
-	sizeTillEnd = 0;
-	memset(value, 0, sizeof(value));
-}
-
-ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::commitWithoutLock() {
-	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
-	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-		write_back->setValid(valid);
-		uint8_t array_position = arrayEntry * typeSize;
-		uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position];
-		memcpy(ptr, value, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t* PoolRawAccess::getEntry() {
-	return value;
-}
-
-ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		size_t* writtenBytes, size_t max_size) {
-	uint8_t* data_ptr = getEntry();
-	// debug << "PoolRawAccess::getEntry: Array position: " <<
-	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
-	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
-	if (typeSize == 0)
-		return DATA_POOL_ACCESS_FAILED;
-	if (typeSize > max_size)
-		return INCORRECT_SIZE;
-	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
-	*writtenBytes = typeSize;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-        size_t maxSize, Endianness streamEndianness) const {
-    if (typeSize + *size <= maxSize) {
-    	switch(streamEndianness) {
-    	case(Endianness::BIG):
-    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::MACHINE):
-    	default:
-            memcpy(*buffer, value, typeSize);
-            break;
-        }
-        *size += typeSize;
-        (*buffer) += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    } else {
-        return SerializeIF::BUFFER_TOO_SHORT;
-    }
-}
-
-
-Type PoolRawAccess::getType() {
-	return type;
-}
-
-size_t PoolRawAccess::getSizeOfType() {
-	return typeSize;
-}
-
-size_t PoolRawAccess::getArraySize(){
-	return arraySize;
-}
-
-uint32_t PoolRawAccess::getDataPoolId() const {
-	return dataPoolId;
-}
-
-PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
-	return readWriteMode;
-}
-
-ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
-		size_t setSize) {
-	if (typeSize == setSize) {
-		EndianConverter::convertBigEndian(value, buffer, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
-				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
-				<< std::endl;
-		return INCORRECT_SIZE;
-	}
-}
-
-bool PoolRawAccess::isValid() const {
-	if (valid != INVALID)
-		return true;
-	else
-		return false;
-}
-
-void PoolRawAccess::setValid(bool valid) {
-	this->valid = valid;
-}
-
-size_t PoolRawAccess::getSizeTillEnd() const {
-	return sizeTillEnd;
-}
-
-
-size_t PoolRawAccess::getSerializedSize() const {
-	return typeSize;
-}
-
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
-        Endianness streamEndianness) {
-
-    if (*size >= typeSize) {
-        switch(streamEndianness) {
-        case(Endianness::BIG):
-			EndianConverter::convertBigEndian(value, *buffer, typeSize);
-		    break;
-        case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
-		   	break;
-        case(Endianness::MACHINE):
-        default:
-            memcpy(value, *buffer, typeSize);
-            break;
-        }
-    	*size -= typeSize;
-        *buffer += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-    	return SerializeIF::STREAM_TOO_SHORT;
-    }
-}
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serialize/EndianConverter.h"
+
+#include <cstring>
+
+PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
+		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
+		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
+		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
+		readWriteMode(setReadWriteMode) {
+	memset(value, 0, sizeof(value));
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+PoolRawAccess::~PoolRawAccess() {}
+
+ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::readWithoutLock() {
+	ReturnValue_t result = RETURN_FAILED;
+	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
+	if (readOut != nullptr) {
+		result = handleReadOut(readOut);
+		if(result == RETURN_OK) {
+			return result;
+		}
+	} else {
+		result = READ_ENTRY_NON_EXISTENT;
+	}
+	handleReadError(result);
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
+	ReturnValue_t result = RETURN_FAILED;
+	valid = readOut->getValid();
+	if (readOut->getSize() > arrayEntry) {
+		arraySize = readOut->getSize();
+		typeSize = readOut->getByteSize() / readOut->getSize();
+		type = readOut->getType();
+		if (typeSize <= sizeof(value)) {
+			uint16_t arrayPosition = arrayEntry * typeSize;
+			sizeTillEnd = readOut->getByteSize() - arrayPosition;
+			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
+			memcpy(value, ptr, typeSize);
+			return RETURN_OK;
+		} else {
+			result = READ_TYPE_TOO_LARGE;
+		}
+	} else {
+		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
+		result = READ_INDEX_TOO_LARGE;
+	}
+	return result;
+}
+
+void PoolRawAccess::handleReadError(ReturnValue_t result) {
+	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
+			<< std::dec << " failed, ";
+	if(result == READ_TYPE_TOO_LARGE) {
+		sif::error << "type too large." << std::endl;
+	}
+	else if(result == READ_INDEX_TOO_LARGE) {
+		sif::error << "index too large." << std::endl;
+	}
+	else if(result == READ_ENTRY_NON_EXISTENT) {
+		sif::error << "entry does not exist." << std::endl;
+	}
+
+	valid = INVALID;
+	typeSize = 0;
+	sizeTillEnd = 0;
+	memset(value, 0, sizeof(value));
+}
+
+ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::commitWithoutLock() {
+	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
+	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
+		write_back->setValid(valid);
+		uint8_t array_position = arrayEntry * typeSize;
+		uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position];
+		memcpy(ptr, value, typeSize);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t* PoolRawAccess::getEntry() {
+	return value;
+}
+
+ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
+		size_t* writtenBytes, size_t max_size) {
+	uint8_t* data_ptr = getEntry();
+	// debug << "PoolRawAccess::getEntry: Array position: " <<
+	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
+	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
+	if (typeSize == 0)
+		return DATA_POOL_ACCESS_FAILED;
+	if (typeSize > max_size)
+		return INCORRECT_SIZE;
+	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
+	*writtenBytes = typeSize;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+        size_t maxSize, Endianness streamEndianness) const {
+    if (typeSize + *size <= maxSize) {
+    	switch(streamEndianness) {
+    	case(Endianness::BIG):
+    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::MACHINE):
+    	default:
+            memcpy(*buffer, value, typeSize);
+            break;
+        }
+        *size += typeSize;
+        (*buffer) += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return SerializeIF::BUFFER_TOO_SHORT;
+    }
+}
+
+
+Type PoolRawAccess::getType() {
+	return type;
+}
+
+size_t PoolRawAccess::getSizeOfType() {
+	return typeSize;
+}
+
+size_t PoolRawAccess::getArraySize(){
+	return arraySize;
+}
+
+uint32_t PoolRawAccess::getDataPoolId() const {
+	return dataPoolId;
+}
+
+PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
+	return readWriteMode;
+}
+
+ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
+		size_t setSize) {
+	if (typeSize == setSize) {
+		EndianConverter::convertBigEndian(value, buffer, typeSize);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
+				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
+				<< std::endl;
+		return INCORRECT_SIZE;
+	}
+}
+
+bool PoolRawAccess::isValid() const {
+	if (valid != INVALID)
+		return true;
+	else
+		return false;
+}
+
+void PoolRawAccess::setValid(bool valid) {
+	this->valid = valid;
+}
+
+size_t PoolRawAccess::getSizeTillEnd() const {
+	return sizeTillEnd;
+}
+
+
+size_t PoolRawAccess::getSerializedSize() const {
+	return typeSize;
+}
+
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
+        Endianness streamEndianness) {
+
+    if (*size >= typeSize) {
+        switch(streamEndianness) {
+        case(Endianness::BIG):
+			EndianConverter::convertBigEndian(value, *buffer, typeSize);
+		    break;
+        case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
+		   	break;
+        case(Endianness::MACHINE):
+        default:
+            memcpy(value, *buffer, typeSize);
+            break;
+        }
+    	*size -= typeSize;
+        *buffer += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+    	return SerializeIF::STREAM_TOO_SHORT;
+    }
+}
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index a1bed466d..15643a41c 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -1,220 +1,220 @@
-#ifndef POOLRAWACCESS_H_
-#define POOLRAWACCESS_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntryIF.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../globalfunctions/Type.h"
-
-/**
- * @brief This class allows accessing Data Pool variables as raw bytes.
- * @details
- * This is necessary to have an access method for HK data, as the PID's alone
- * do not provide type information. Please note that the the raw pool access
- * read() and commit() calls are not thread-safe.
- *
- * Please supply a data set and use the data set read(), commit() calls for
- * thread-safe data pool access.
- * @ingroup data_pool
- */
-class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
-public:
-	/**
-	 * This constructor is used to access a data pool entry with a
-	 * given ID if the target type is not known. A DataSet object is supplied
-	 * and the data pool entry with the given ID is registered to that data set.
-	 * Please note that a pool raw access buffer only has a buffer
-	 * with a size of double. As such, for vector entries which have
-	 * @param data_pool_id Target data pool entry ID
-	 * @param arrayEntry
-	 * @param data_set Dataset to register data pool entry to
-	 * @param setReadWriteMode
-	 * @param registerVectors If set to true, the constructor checks if
-	 *                        there are multiple vector entries to registers
-	 *                        and registers all of them recursively into the data_set
-	 *
-	 */
-	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
-			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-					PoolVariableIF::VAR_READ);
-
-	/**
-	 * @brief	This operation returns a pointer to the entry fetched.
-	 * @details	Return pointer to the buffer containing the raw data
-	 *          Size and number of data can be retrieved by other means.
-	 */
-	uint8_t* getEntry();
-	/**
-	 * @brief 	This operation returns the fetched entry from the data pool and
-	 * 			flips the bytes, if necessary.
-	 * @details	It makes use of the getEntry call of this function, but additionally flips the
-	 * 			bytes to big endian, which is the default for external communication (as House-
-	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given max_size.
-	 * @param buffer	A pointer to a buffer to write to
-	 * @param writtenBytes	The number of bytes written is returned with this value.
-	 * @param max_size	The maximum size that the function may write to buffer.
-	 * @return	- @c RETURN_OK if entry could be acquired
-	 * 			- @c RETURN_FAILED else.
-	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
-			size_t maxSize);
-
-	/**
-	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @param buffer Provided buffer. Raw pool data will be copied here
-	 * @param size [out] Increment provided size value by serialized size
-	 * @param max_size Maximum allowed serialization size
-	 * @param bigEndian Specify endianess
-	 * @return - @c RETURN_OK if serialization was successfull
-	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
-	 */
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-	        size_t maxSize, Endianness streamEndianness) const override;
-
-    size_t getSerializedSize() const override;
-
-    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-            Endianness streamEndianness) override;
-
-	/**
-	 * With this method, the content can be set from a big endian buffer safely.
-	 * @param buffer	Pointer to the data to set
-	 * @param size		Size of the data to write. Must fit this->size.
-	 * @return	- @c RETURN_OK on success
-	 * 			- @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			size_t setSize);
-	/**
-	 *  @brief This operation returns the type of the entry currently stored.
-	 */
-	Type getType();
-	/**
-	 *  @brief This operation returns the size of the entry currently stored.
-	 */
-	size_t getSizeOfType();
-	/**
-	 *
-	 * @return the size of the datapool array
-	 */
-	size_t getArraySize();
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
-	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
-	uint8_t value[RAW_MAX_SIZE];
-
-
-	/**
-	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolRawAccess();
-
-	/**
-	 * This method returns if the variable is read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const;
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const;
-
-	void setValid(bool valid);
-	/**
-	 * Getter for the remaining size.
-	 */
-	size_t getSizeTillEnd() const;
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The call is protected by a lock of the global data pool.
-	 * @return -@c RETURN_OK Read successfull
-	 * 		   -@c READ_TYPE_TOO_LARGE
-	 * 		   -@c READ_INDEX_TOO_LARGE
-	 * 		   -@c READ_ENTRY_NON_EXISTENT
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The call is protected by a lock of the global data pool.
-	 *
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
-	void handleReadError(ReturnValue_t result);
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The array entry that is fetched from the data pool.
-	 */
-	uint8_t arrayEntry;
-	/**
-	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	This value contains the type of the data pool entry.
-	 */
-	Type type;
-	/**
-	 * @brief	This value contains the size of the data pool entry type in bytes.
-	 */
-	size_t typeSize;
-	/**
-	 * The size of the DP array (single values return 1)
-	 */
-	size_t arraySize;
-	/**
-	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
-	 */
-	size_t sizeTillEnd;
-	/**
-	 * @brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#endif /* POOLRAWACCESS_H_ */
+#ifndef POOLRAWACCESS_H_
+#define POOLRAWACCESS_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntryIF.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../globalfunctions/Type.h"
+
+/**
+ * @brief This class allows accessing Data Pool variables as raw bytes.
+ * @details
+ * This is necessary to have an access method for HK data, as the PID's alone
+ * do not provide type information. Please note that the the raw pool access
+ * read() and commit() calls are not thread-safe.
+ *
+ * Please supply a data set and use the data set read(), commit() calls for
+ * thread-safe data pool access.
+ * @ingroup data_pool
+ */
+class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
+public:
+	/**
+	 * This constructor is used to access a data pool entry with a
+	 * given ID if the target type is not known. A DataSet object is supplied
+	 * and the data pool entry with the given ID is registered to that data set.
+	 * Please note that a pool raw access buffer only has a buffer
+	 * with a size of double. As such, for vector entries which have
+	 * @param data_pool_id Target data pool entry ID
+	 * @param arrayEntry
+	 * @param data_set Dataset to register data pool entry to
+	 * @param setReadWriteMode
+	 * @param registerVectors If set to true, the constructor checks if
+	 *                        there are multiple vector entries to registers
+	 *                        and registers all of them recursively into the data_set
+	 *
+	 */
+	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
+			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
+					PoolVariableIF::VAR_READ);
+
+	/**
+	 * @brief	This operation returns a pointer to the entry fetched.
+	 * @details	Return pointer to the buffer containing the raw data
+	 *          Size and number of data can be retrieved by other means.
+	 */
+	uint8_t* getEntry();
+	/**
+	 * @brief 	This operation returns the fetched entry from the data pool and
+	 * 			flips the bytes, if necessary.
+	 * @details	It makes use of the getEntry call of this function, but additionally flips the
+	 * 			bytes to big endian, which is the default for external communication (as House-
+	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
+	 * 			buffer, if it fits in the given max_size.
+	 * @param buffer	A pointer to a buffer to write to
+	 * @param writtenBytes	The number of bytes written is returned with this value.
+	 * @param max_size	The maximum size that the function may write to buffer.
+	 * @return	- @c RETURN_OK if entry could be acquired
+	 * 			- @c RETURN_FAILED else.
+	 */
+	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
+			size_t maxSize);
+
+	/**
+	 * @brief 	Serialize raw pool entry into provided buffer directly
+	 * @param buffer Provided buffer. Raw pool data will be copied here
+	 * @param size [out] Increment provided size value by serialized size
+	 * @param max_size Maximum allowed serialization size
+	 * @param bigEndian Specify endianess
+	 * @return - @c RETURN_OK if serialization was successfull
+	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
+	 */
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+	        size_t maxSize, Endianness streamEndianness) const override;
+
+    size_t getSerializedSize() const override;
+
+    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+            Endianness streamEndianness) override;
+
+	/**
+	 * With this method, the content can be set from a big endian buffer safely.
+	 * @param buffer	Pointer to the data to set
+	 * @param size		Size of the data to write. Must fit this->size.
+	 * @return	- @c RETURN_OK on success
+	 * 			- @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
+			size_t setSize);
+	/**
+	 *  @brief This operation returns the type of the entry currently stored.
+	 */
+	Type getType();
+	/**
+	 *  @brief This operation returns the size of the entry currently stored.
+	 */
+	size_t getSizeOfType();
+	/**
+	 *
+	 * @return the size of the datapool array
+	 */
+	size_t getArraySize();
+	/**
+	 * @brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
+	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
+	static const uint8_t RAW_MAX_SIZE = sizeof(double);
+	uint8_t value[RAW_MAX_SIZE];
+
+
+	/**
+	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~PoolRawAccess();
+
+	/**
+	 * This method returns if the variable is read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const;
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const;
+
+	void setValid(bool valid);
+	/**
+	 * Getter for the remaining size.
+	 */
+	size_t getSizeTillEnd() const;
+
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The call is protected by a lock of the global data pool.
+	 * @return -@c RETURN_OK Read successfull
+	 * 		   -@c READ_TYPE_TOO_LARGE
+	 * 		   -@c READ_INDEX_TOO_LARGE
+	 * 		   -@c READ_ENTRY_NON_EXISTENT
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The call is protected by a lock of the global data pool.
+	 *
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
+	void handleReadError(ReturnValue_t result);
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * 			is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * @brief	The array entry that is fetched from the data pool.
+	 */
+	uint8_t arrayEntry;
+	/**
+	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	This value contains the type of the data pool entry.
+	 */
+	Type type;
+	/**
+	 * @brief	This value contains the size of the data pool entry type in bytes.
+	 */
+	size_t typeSize;
+	/**
+	 * The size of the DP array (single values return 1)
+	 */
+	size_t arraySize;
+	/**
+	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
+	 */
+	size_t sizeTillEnd;
+	/**
+	 * @brief	The information whether the class is read-write or read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+};
+
+#endif /* POOLRAWACCESS_H_ */
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 8c3c50dbc..86705bb0d 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,200 +1,200 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../datapoollocal/LocalDataPoolManager.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-
-/**
- * @brief	This is the access class for array-type data pool entries.
- * @details
- * To ensure safe usage of the data pool, operation is not done directly on the
- * data pool entries, but on local copies. This class provides simple type-
- * and length-safe access to vector-style data pool entries (i.e. entries with
- * length > 1). The class can be instantiated as read-write and read only.
- *
- * It provides a commit-and-roll-back semantic, which means that no array
- * entry in the data pool is changed until the commit call is executed.
- * There are two template parameters:
- * @tparam	T
- * This template parameter specifies the data type of an array entry. Currently,
- * all plain data types are supported, but in principle any type is possible.
- * @tparam  vector_size
- * This template parameter specifies the vector size of this entry. Using a
- * template parameter for this is not perfect, but avoids
- * dynamic memory allocation.
- * @ingroup data_pool
- */
-template<typename T, uint16_t vectorSize>
-class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
-public:
-	LocalPoolVector() = delete;
-	/**
-	 * This constructor is used by the data creators to have pool variable
-	 * instances which can also be stored in datasets.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
-
-	/**
-	 * This constructor is used by data users like controllers to have
-	 * access to the local pool variables of data creators by supplying
-	 * the respective creator object ID.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details
-	 * The user can work on this attribute just like he would on a local
-	 * array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~LocalPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
-
-	uint32_t getDataPoolId() const override;
-	/**
-	 * @brief This operation sets the data pool ID of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	pool_rwm_t getReadWriteMode() const;
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-	void setValid(bool valid) override;
-	uint8_t getValid() const;
-
-	T& operator [](int i);
-	const T &operator [](int i) const;
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t maxSize,
-			SerializeIF::Endianness streamEndiannes) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the data pool and copies all array values and the valid
-	 * information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the local valid flag is written back as well.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t localPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	bool valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	//! @brief	Pointer to the class which manages the HK pool.
-	LocalDataPoolManager* hkManager;
-
-	// std::ostream is the type for object std::cout
-	template <typename U, uint16_t otherSize>
-	friend std::ostream& operator<< (std::ostream &out,
-	        const LocalPoolVector<U, otherSize> &var);
-
-
-};
-
-#include "../datapoollocal/LocalPoolVector.tpp"
-
-template<typename T, uint16_t vectorSize>
-using lp_vec_t = LocalPoolVector<T, vectorSize>;
-
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
+public:
+	LocalPoolVector() = delete;
+	/**
+	 * This constructor is used by the data creators to have pool variable
+	 * instances which can also be stored in datasets.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * This constructor is used by data users like controllers to have
+	 * access to the local pool variables of data creators by supplying
+	 * the respective creator object ID.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details
+	 * The user can work on this attribute just like he would on a local
+	 * array of this type.
+	 */
+	T value[vectorSize];
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~LocalPoolVector() {};
+	/**
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
+	 */
+	uint8_t getSize() {
+		return vectorSize;
+	}
+
+	uint32_t getDataPoolId() const override;
+	/**
+	 * @brief This operation sets the data pool ID of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	pool_rwm_t getReadWriteMode() const;
+
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+	void setValid(bool valid) override;
+	uint8_t getValid() const;
+
+	T& operator [](int i);
+	const T &operator [](int i) const;
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t maxSize,
+			SerializeIF::Endianness streamEndiannes) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the data pool and copies all array values and the valid
+	 * information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the local valid flag is written back as well.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t localPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	bool valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+	//! @brief	Pointer to the class which manages the HK pool.
+	LocalDataPoolManager* hkManager;
+
+	// std::ostream is the type for object std::cout
+	template <typename U, uint16_t otherSize>
+	friend std::ostream& operator<< (std::ostream &out,
+	        const LocalPoolVector<U, otherSize> &var);
+
+
+};
+
+#include "../datapoollocal/LocalPoolVector.tpp"
+
+template<typename T, uint16_t vectorSize>
+using lp_vec_t = LocalPoolVector<T, vectorSize>;
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
index 73e0e1fbd..dd1bdcc40 100644
--- a/datapoollocal/SharedLocalDataSet.cpp
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -1,16 +1,16 @@
-#include "SharedLocalDataSet.h"
-
-SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
-        const size_t maxSize): SystemObject(objectId),
-        LocalPoolDataSetBase(sid, nullptr, maxSize) {
-    this->setContainer(poolVarVector.data());
-    datasetLock = MutexFactory::instance()->createMutex();
-}
-
-ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
-    return datasetLock->lockMutex(MutexIF::TimeoutType::WAITING, mutexTimeout);
-}
-
-ReturnValue_t SharedLocalDataSet::unlockDataset() {
-    return datasetLock->unlockMutex();
-}
+#include "SharedLocalDataSet.h"
+
+SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
+        const size_t maxSize): SystemObject(objectId),
+        LocalPoolDataSetBase(sid, nullptr, maxSize) {
+    this->setContainer(poolVarVector.data());
+    datasetLock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
+    return datasetLock->lockMutex(MutexIF::TimeoutType::WAITING, mutexTimeout);
+}
+
+ReturnValue_t SharedLocalDataSet::unlockDataset() {
+    return datasetLock->unlockMutex();
+}
diff --git a/devicehandlers/AcceptsDeviceResponsesIF.h b/devicehandlers/AcceptsDeviceResponsesIF.h
index d7e117149..eb7780dbe 100644
--- a/devicehandlers/AcceptsDeviceResponsesIF.h
+++ b/devicehandlers/AcceptsDeviceResponsesIF.h
@@ -1,19 +1,19 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
-#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
-
-#include "../ipc/MessageQueueSenderIF.h"
-
-/**
- * This interface is used by the device handler to send a device response
- * to the queue ID, which is returned in the implemented abstract method.
- */
-class AcceptsDeviceResponsesIF {
-public:
-	/**
-	 * Default empty virtual destructor.
-	 */
-	virtual ~AcceptsDeviceResponsesIF() {}
-	virtual MessageQueueId_t getDeviceQueue() = 0;
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * This interface is used by the device handler to send a device response
+ * to the queue ID, which is returned in the implemented abstract method.
+ */
+class AcceptsDeviceResponsesIF {
+public:
+	/**
+	 * Default empty virtual destructor.
+	 */
+	virtual ~AcceptsDeviceResponsesIF() {}
+	virtual MessageQueueId_t getDeviceQueue() = 0;
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index c98a9f678..3bcb8a112 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -1,273 +1,273 @@
-#include "../devicehandlers/AssemblyBase.h"
-
-AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
-		uint16_t commandQueueDepth) :
-		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
-		internalState(STATE_NONE), recoveryState(RECOVERY_IDLE),
-		recoveringDevice(childrenMap.end()), targetMode(MODE_OFF),
-		targetSubmode(SUBMODE_NONE) {
-	recoveryOffTimer.setTimeout(POWER_OFF_TIME_MS);
-}
-
-AssemblyBase::~AssemblyBase() {
-}
-
-ReturnValue_t AssemblyBase::handleCommandMessage(CommandMessage* message) {
-	return handleHealthReply(message);
-}
-
-void AssemblyBase::performChildOperation() {
-	if (isInTransition()) {
-		handleChildrenTransition();
-	} else {
-		handleChildrenChanged();
-	}
-}
-
-void AssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
-	doStartTransition(mode, submode);
-	if (modeHelper.isForced()) {
-		triggerEvent(FORCING_MODE, mode, submode);
-	} else {
-		triggerEvent(CHANGING_MODE, mode, submode);
-	}
-}
-
-void AssemblyBase::doStartTransition(Mode_t mode, Submode_t submode) {
-	targetMode = mode;
-	targetSubmode = submode;
-	internalState = STATE_SINGLE_STEP;
-	ReturnValue_t result = commandChildren(mode, submode);
-	if (result == NEED_SECOND_STEP) {
-		internalState = STATE_NEED_SECOND_STEP;
-	}
-}
-
-bool AssemblyBase::isInTransition() {
-	return (internalState != STATE_NONE) || (recoveryState != RECOVERY_IDLE);
-}
-
-bool AssemblyBase::handleChildrenChanged() {
-	if (childrenChangedMode) {
-		ReturnValue_t result = checkChildrenState();
-		if (result != RETURN_OK) {
-			handleChildrenLostMode(result);
-		}
-		return true;
-	} else {
-		return handleChildrenChangedHealth();
-	}
-}
-
-void AssemblyBase::handleChildrenLostMode(ReturnValue_t result) {
-	triggerEvent(CANT_KEEP_MODE, mode, submode);
-	startTransition(MODE_OFF, SUBMODE_NONE);
-}
-
-bool AssemblyBase::handleChildrenChangedHealth() {
-	auto iter = childrenMap.begin();
-	for (; iter != childrenMap.end(); iter++) {
-		if (iter->second.healthChanged) {
-			iter->second.healthChanged = false;
-			break;
-		}
-	}
-	if (iter == childrenMap.end()) {
-		return false;
-	}
-	HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
-	if (healthState == HasHealthIF::NEEDS_RECOVERY) {
-		triggerEvent(TRYING_RECOVERY);
-		recoveryState = RECOVERY_STARTED;
-		recoveringDevice = iter;
-		doStartTransition(targetMode, targetSubmode);
-	} else {
-		triggerEvent(CHILD_CHANGED_HEALTH);
-		doStartTransition(mode, submode);
-	}
-	if (modeHelper.isForced()) {
-		triggerEvent(FORCING_MODE, targetMode, targetSubmode);
-	}
-	return true;
-}
-
-void AssemblyBase::handleChildrenTransition() {
-	if (commandsOutstanding <= 0) {
-		switch (internalState) {
-		case STATE_NEED_SECOND_STEP:
-			internalState = STATE_SECOND_STEP;
-			commandChildren(targetMode, targetSubmode);
-			return;
-		case STATE_OVERWRITE_HEALTH: {
-			internalState = STATE_SINGLE_STEP;
-			ReturnValue_t result = commandChildren(mode, submode);
-			if (result == NEED_SECOND_STEP) {
-				internalState = STATE_NEED_SECOND_STEP;
-			}
-			return;
-		}
-		case STATE_NONE:
-			//Valid state, used in recovery.
-		case STATE_SINGLE_STEP:
-		case STATE_SECOND_STEP:
-			if (checkAndHandleRecovery()) {
-				return;
-			}
-			break;
-		}
-		ReturnValue_t result = checkChildrenState();
-		if (result == RETURN_OK) {
-			handleModeReached();
-		} else {
-			handleModeTransitionFailed(result);
-		}
-	}
-}
-
-void AssemblyBase::handleModeReached() {
-	internalState = STATE_NONE;
-	setMode(targetMode, targetSubmode);
-}
-
-void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
-//always accept transition to OFF, there is nothing we can do except sending an info event
-//In theory this should never happen, but we would risk an infinite loop otherwise
-	if (targetMode == MODE_OFF) {
-		triggerEvent(CHILD_PROBLEMS, result);
-		internalState = STATE_NONE;
-		setMode(targetMode, targetSubmode);
-	} else {
-		if (handleChildrenChangedHealth()) {
-			//If any health change is pending, handle that first.
-			return;
-		}
-		triggerEvent(MODE_TRANSITION_FAILED, result);
-		startTransition(MODE_OFF, SUBMODE_NONE);
-	}
-}
-
-void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
-		HealthState health) {
-	CommandMessage command;
-	HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
-			health);
-	if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
-		commandsOutstanding++;
-	}
-}
-
-ReturnValue_t AssemblyBase::checkChildrenState() {
-	if (targetMode == MODE_OFF) {
-		return checkChildrenStateOff();
-	} else {
-		return checkChildrenStateOn(targetMode, targetSubmode);
-	}
-}
-
-ReturnValue_t AssemblyBase::checkChildrenStateOff() {
-	for (const auto& childIter: childrenMap) {
-		if (checkChildOff(childIter.first) != RETURN_OK) {
-			return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t AssemblyBase::checkChildOff(uint32_t objectId) {
-	ChildInfo childInfo = childrenMap.find(objectId)->second;
-	if (healthHelper.healthTable->isCommandable(objectId)) {
-		if (childInfo.submode != SUBMODE_NONE) {
-			return RETURN_FAILED;
-		} else {
-			if ((childInfo.mode != MODE_OFF)
-					&& (childInfo.mode != DeviceHandlerIF::MODE_ERROR_ON)) {
-				return RETURN_FAILED;
-			}
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t AssemblyBase::checkModeCommand(Mode_t mode, Submode_t submode,
-		uint32_t* msToReachTheMode) {
-
-//always accept transition to OFF
-	if (mode == MODE_OFF) {
-		if (submode != SUBMODE_NONE) {
-			return INVALID_SUBMODE;
-		}
-		return RETURN_OK;
-	}
-
-	if ((mode != MODE_ON) && (mode != DeviceHandlerIF::MODE_NORMAL)) {
-		return INVALID_MODE;
-	}
-
-	if (internalState != STATE_NONE) {
-		return IN_TRANSITION;
-	}
-
-	return isModeCombinationValid(mode, submode);
-}
-
-ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
-	if (message->getCommand() == HealthMessage::HEALTH_INFO) {
-		HealthState health = HealthMessage::getHealth(message);
-		if (health != EXTERNAL_CONTROL) {
-			updateChildChangedHealth(message->getSender(), true);
-		}
-		return RETURN_OK;
-	}
-	if (message->getCommand() == HealthMessage::REPLY_HEALTH_SET
-			|| (message->getCommand() == CommandMessage::REPLY_REJECTED
-					&& message->getParameter2() == HealthMessage::HEALTH_SET)) {
-		if (isInTransition()) {
-			commandsOutstanding--;
-		}
-		return RETURN_OK;
-	}
-	return RETURN_FAILED;
-}
-
-bool AssemblyBase::checkAndHandleRecovery() {
-	switch (recoveryState) {
-	case RECOVERY_STARTED:
-		recoveryState = RECOVERY_WAIT;
-		recoveryOffTimer.resetTimer();
-		return true;
-	case RECOVERY_WAIT:
-		if (recoveryOffTimer.isBusy()) {
-			return true;
-		}
-		triggerEvent(RECOVERY_STEP, 0);
-		sendHealthCommand(recoveringDevice->second.commandQueue, HEALTHY);
-		internalState = STATE_NONE;
-		recoveryState = RECOVERY_ONGOING;
-		//Don't check state!
-		return true;
-	case RECOVERY_ONGOING:
-		triggerEvent(RECOVERY_STEP, 1);
-		recoveryState = RECOVERY_ONGOING_2;
-		recoveringDevice->second.healthChanged = false;
-		//Device should be healthy again, so restart a transition.
-		//Might be including second step, but that's already handled.
-		doStartTransition(targetMode, targetSubmode);
-		return true;
-	case RECOVERY_ONGOING_2:
-		triggerEvent(RECOVERY_DONE);
-		//Now we're through, but not sure if it was successful.
-		recoveryState = RECOVERY_IDLE;
-		return false;
-	case RECOVERY_IDLE:
-	default:
-		return false;
-	}
-}
-
-void AssemblyBase::overwriteDeviceHealth(object_id_t objectId,
-		HasHealthIF::HealthState oldHealth) {
-	triggerEvent(OVERWRITING_HEALTH, objectId, oldHealth);
-	internalState = STATE_OVERWRITE_HEALTH;
-	modeHelper.setForced(true);
-	sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
-}
+#include "../devicehandlers/AssemblyBase.h"
+
+AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
+		uint16_t commandQueueDepth) :
+		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
+		internalState(STATE_NONE), recoveryState(RECOVERY_IDLE),
+		recoveringDevice(childrenMap.end()), targetMode(MODE_OFF),
+		targetSubmode(SUBMODE_NONE) {
+	recoveryOffTimer.setTimeout(POWER_OFF_TIME_MS);
+}
+
+AssemblyBase::~AssemblyBase() {
+}
+
+ReturnValue_t AssemblyBase::handleCommandMessage(CommandMessage* message) {
+	return handleHealthReply(message);
+}
+
+void AssemblyBase::performChildOperation() {
+	if (isInTransition()) {
+		handleChildrenTransition();
+	} else {
+		handleChildrenChanged();
+	}
+}
+
+void AssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
+	doStartTransition(mode, submode);
+	if (modeHelper.isForced()) {
+		triggerEvent(FORCING_MODE, mode, submode);
+	} else {
+		triggerEvent(CHANGING_MODE, mode, submode);
+	}
+}
+
+void AssemblyBase::doStartTransition(Mode_t mode, Submode_t submode) {
+	targetMode = mode;
+	targetSubmode = submode;
+	internalState = STATE_SINGLE_STEP;
+	ReturnValue_t result = commandChildren(mode, submode);
+	if (result == NEED_SECOND_STEP) {
+		internalState = STATE_NEED_SECOND_STEP;
+	}
+}
+
+bool AssemblyBase::isInTransition() {
+	return (internalState != STATE_NONE) || (recoveryState != RECOVERY_IDLE);
+}
+
+bool AssemblyBase::handleChildrenChanged() {
+	if (childrenChangedMode) {
+		ReturnValue_t result = checkChildrenState();
+		if (result != RETURN_OK) {
+			handleChildrenLostMode(result);
+		}
+		return true;
+	} else {
+		return handleChildrenChangedHealth();
+	}
+}
+
+void AssemblyBase::handleChildrenLostMode(ReturnValue_t result) {
+	triggerEvent(CANT_KEEP_MODE, mode, submode);
+	startTransition(MODE_OFF, SUBMODE_NONE);
+}
+
+bool AssemblyBase::handleChildrenChangedHealth() {
+	auto iter = childrenMap.begin();
+	for (; iter != childrenMap.end(); iter++) {
+		if (iter->second.healthChanged) {
+			iter->second.healthChanged = false;
+			break;
+		}
+	}
+	if (iter == childrenMap.end()) {
+		return false;
+	}
+	HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
+	if (healthState == HasHealthIF::NEEDS_RECOVERY) {
+		triggerEvent(TRYING_RECOVERY);
+		recoveryState = RECOVERY_STARTED;
+		recoveringDevice = iter;
+		doStartTransition(targetMode, targetSubmode);
+	} else {
+		triggerEvent(CHILD_CHANGED_HEALTH);
+		doStartTransition(mode, submode);
+	}
+	if (modeHelper.isForced()) {
+		triggerEvent(FORCING_MODE, targetMode, targetSubmode);
+	}
+	return true;
+}
+
+void AssemblyBase::handleChildrenTransition() {
+	if (commandsOutstanding <= 0) {
+		switch (internalState) {
+		case STATE_NEED_SECOND_STEP:
+			internalState = STATE_SECOND_STEP;
+			commandChildren(targetMode, targetSubmode);
+			return;
+		case STATE_OVERWRITE_HEALTH: {
+			internalState = STATE_SINGLE_STEP;
+			ReturnValue_t result = commandChildren(mode, submode);
+			if (result == NEED_SECOND_STEP) {
+				internalState = STATE_NEED_SECOND_STEP;
+			}
+			return;
+		}
+		case STATE_NONE:
+			//Valid state, used in recovery.
+		case STATE_SINGLE_STEP:
+		case STATE_SECOND_STEP:
+			if (checkAndHandleRecovery()) {
+				return;
+			}
+			break;
+		}
+		ReturnValue_t result = checkChildrenState();
+		if (result == RETURN_OK) {
+			handleModeReached();
+		} else {
+			handleModeTransitionFailed(result);
+		}
+	}
+}
+
+void AssemblyBase::handleModeReached() {
+	internalState = STATE_NONE;
+	setMode(targetMode, targetSubmode);
+}
+
+void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
+//always accept transition to OFF, there is nothing we can do except sending an info event
+//In theory this should never happen, but we would risk an infinite loop otherwise
+	if (targetMode == MODE_OFF) {
+		triggerEvent(CHILD_PROBLEMS, result);
+		internalState = STATE_NONE;
+		setMode(targetMode, targetSubmode);
+	} else {
+		if (handleChildrenChangedHealth()) {
+			//If any health change is pending, handle that first.
+			return;
+		}
+		triggerEvent(MODE_TRANSITION_FAILED, result);
+		startTransition(MODE_OFF, SUBMODE_NONE);
+	}
+}
+
+void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
+		HealthState health) {
+	CommandMessage command;
+	HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
+			health);
+	if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
+		commandsOutstanding++;
+	}
+}
+
+ReturnValue_t AssemblyBase::checkChildrenState() {
+	if (targetMode == MODE_OFF) {
+		return checkChildrenStateOff();
+	} else {
+		return checkChildrenStateOn(targetMode, targetSubmode);
+	}
+}
+
+ReturnValue_t AssemblyBase::checkChildrenStateOff() {
+	for (const auto& childIter: childrenMap) {
+		if (checkChildOff(childIter.first) != RETURN_OK) {
+			return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t AssemblyBase::checkChildOff(uint32_t objectId) {
+	ChildInfo childInfo = childrenMap.find(objectId)->second;
+	if (healthHelper.healthTable->isCommandable(objectId)) {
+		if (childInfo.submode != SUBMODE_NONE) {
+			return RETURN_FAILED;
+		} else {
+			if ((childInfo.mode != MODE_OFF)
+					&& (childInfo.mode != DeviceHandlerIF::MODE_ERROR_ON)) {
+				return RETURN_FAILED;
+			}
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t AssemblyBase::checkModeCommand(Mode_t mode, Submode_t submode,
+		uint32_t* msToReachTheMode) {
+
+//always accept transition to OFF
+	if (mode == MODE_OFF) {
+		if (submode != SUBMODE_NONE) {
+			return INVALID_SUBMODE;
+		}
+		return RETURN_OK;
+	}
+
+	if ((mode != MODE_ON) && (mode != DeviceHandlerIF::MODE_NORMAL)) {
+		return INVALID_MODE;
+	}
+
+	if (internalState != STATE_NONE) {
+		return IN_TRANSITION;
+	}
+
+	return isModeCombinationValid(mode, submode);
+}
+
+ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
+	if (message->getCommand() == HealthMessage::HEALTH_INFO) {
+		HealthState health = HealthMessage::getHealth(message);
+		if (health != EXTERNAL_CONTROL) {
+			updateChildChangedHealth(message->getSender(), true);
+		}
+		return RETURN_OK;
+	}
+	if (message->getCommand() == HealthMessage::REPLY_HEALTH_SET
+			|| (message->getCommand() == CommandMessage::REPLY_REJECTED
+					&& message->getParameter2() == HealthMessage::HEALTH_SET)) {
+		if (isInTransition()) {
+			commandsOutstanding--;
+		}
+		return RETURN_OK;
+	}
+	return RETURN_FAILED;
+}
+
+bool AssemblyBase::checkAndHandleRecovery() {
+	switch (recoveryState) {
+	case RECOVERY_STARTED:
+		recoveryState = RECOVERY_WAIT;
+		recoveryOffTimer.resetTimer();
+		return true;
+	case RECOVERY_WAIT:
+		if (recoveryOffTimer.isBusy()) {
+			return true;
+		}
+		triggerEvent(RECOVERY_STEP, 0);
+		sendHealthCommand(recoveringDevice->second.commandQueue, HEALTHY);
+		internalState = STATE_NONE;
+		recoveryState = RECOVERY_ONGOING;
+		//Don't check state!
+		return true;
+	case RECOVERY_ONGOING:
+		triggerEvent(RECOVERY_STEP, 1);
+		recoveryState = RECOVERY_ONGOING_2;
+		recoveringDevice->second.healthChanged = false;
+		//Device should be healthy again, so restart a transition.
+		//Might be including second step, but that's already handled.
+		doStartTransition(targetMode, targetSubmode);
+		return true;
+	case RECOVERY_ONGOING_2:
+		triggerEvent(RECOVERY_DONE);
+		//Now we're through, but not sure if it was successful.
+		recoveryState = RECOVERY_IDLE;
+		return false;
+	case RECOVERY_IDLE:
+	default:
+		return false;
+	}
+}
+
+void AssemblyBase::overwriteDeviceHealth(object_id_t objectId,
+		HasHealthIF::HealthState oldHealth) {
+	triggerEvent(OVERWRITING_HEALTH, objectId, oldHealth);
+	internalState = STATE_OVERWRITE_HEALTH;
+	modeHelper.setForced(true);
+	sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
+}
diff --git a/devicehandlers/AssemblyBase.h b/devicehandlers/AssemblyBase.h
index 7c66b21d9..b67c551e5 100644
--- a/devicehandlers/AssemblyBase.h
+++ b/devicehandlers/AssemblyBase.h
@@ -1,163 +1,163 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
-#define FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
-
-#include "../container/FixedArrayList.h"
-#include "../devicehandlers/DeviceHandlerBase.h"
-#include "../subsystem/SubsystemBase.h"
-
-/**
- * @brief   Base class to implement reconfiguration and failure handling for
- *          redundant devices by monitoring their modes health states.
- * @details
- * Documentation: Dissertation Baetz p.156, 157.
- *
- * This class reduces the complexity of controller components which would
- * otherwise be needed for the handling of redundant devices.
- *
- * The template class monitors mode and health state of its children
- * and checks availability of devices on every detected change.
- * AssemblyBase does not implement any redundancy logic by itself, but provides
- * adaptation points for implementations to do so. Since most monitoring
- * activities rely on mode and health state only and are therefore
- * generic, it is sufficient for subclasses to provide:
- *
- * 1. check logic when active-> checkChildrenStateOn
- * 2. transition logic to change the mode -> commandChildren
- *
- */
-class AssemblyBase: public SubsystemBase {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ASSEMBLY_BASE;
-	static const ReturnValue_t NEED_SECOND_STEP = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t NEED_TO_RECONFIGURE = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t MODE_FALLBACK = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t CHILD_NOT_COMMANDABLE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t NEED_TO_CHANGE_HEALTH = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE =
-			MAKE_RETURN_CODE(0xa1);
-
-	AssemblyBase(object_id_t objectId, object_id_t parentId,
-	        uint16_t commandQueueDepth = 8);
-	virtual ~AssemblyBase();
-
-protected:
-
-    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
-    // (or return internalState directly?)
-    /**
-     * Command children to reach [mode,submode] combination
-     * Can be done by setting #commandsOutstanding correctly,
-     * or using executeTable()
-     * @param mode
-     * @param submode
-     * @return
-     *    - @c RETURN_OK if ok
-     *    - @c NEED_SECOND_STEP if children need to be commanded again
-     */
-    virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
-
-    /**
-     * Check whether desired assembly mode was achieved by checking the modes
-     * or/and health states of child device handlers.
-     * The assembly template class will also call this function if a health
-     * or mode change of a child device handler was detected.
-     * @param wantedMode
-     * @param wantedSubmode
-     * @return
-     */
-    virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
-            Submode_t wantedSubmode) = 0;
-
-    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
-            Submode_t submode) = 0;
-
-	enum InternalState {
-		STATE_NONE,
-		STATE_OVERWRITE_HEALTH,
-		STATE_NEED_SECOND_STEP,
-		STATE_SINGLE_STEP,
-		STATE_SECOND_STEP,
-	} internalState;
-
-	enum RecoveryState {
-		RECOVERY_IDLE,
-		RECOVERY_STARTED,
-		RECOVERY_ONGOING,
-		RECOVERY_ONGOING_2,
-		RECOVERY_WAIT
-	} recoveryState; //!< Indicates if one of the children requested a recovery.
-	ChildrenMap::iterator recoveringDevice;
-
-	/**
-	 * the mode the current transition is trying to achieve.
-	 * Can be different from the modehelper.commandedMode!
-	 */
-	Mode_t targetMode;
-
-	/**
-	 * the submode the current transition is trying to achieve.
-	 * Can be different from the modehelper.commandedSubmode!
-	 */
-	Submode_t targetSubmode;
-
-	Countdown recoveryOffTimer;
-
-	static const uint32_t POWER_OFF_TIME_MS = 1000;
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
-
-	virtual ReturnValue_t handleHealthReply(CommandMessage *message);
-
-	virtual void performChildOperation();
-
-	bool handleChildrenChanged();
-
-	/**
-	 * This method is called if the children changed its mode in a way that
-	 * the current mode can't be kept.
-	 * Default behavior is to go to MODE_OFF.
-	 * @param result The failure code which was returned by checkChildrenState.
-	 */
-	virtual void handleChildrenLostMode(ReturnValue_t result);
-
-	bool handleChildrenChangedHealth();
-
-	virtual void handleChildrenTransition();
-
-	ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode);
-
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-
-	virtual void doStartTransition(Mode_t mode, Submode_t submode);
-
-	virtual bool isInTransition();
-
-	virtual void handleModeReached();
-
-	virtual void handleModeTransitionFailed(ReturnValue_t result);
-
-	void sendHealthCommand(MessageQueueId_t sendTo, HealthState health);
-
-	virtual ReturnValue_t checkChildrenStateOff();
-
-	ReturnValue_t checkChildrenState();
-
-	virtual ReturnValue_t checkChildOff(uint32_t objectId);
-
-	/**
-	 * Manages recovery of a device
-	 * @return true if recovery is still ongoing, false else.
-	 */
-	bool checkAndHandleRecovery();
-
-	/**
-	 * Helper method to overwrite health state of one of the children.
-	 * Also sets state to STATE_OVERWRITE_HEATH.
-	 * @param objectId Must be a registered child.
-	 */
-	void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
-
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
+#define FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
+
+#include "../container/FixedArrayList.h"
+#include "../devicehandlers/DeviceHandlerBase.h"
+#include "../subsystem/SubsystemBase.h"
+
+/**
+ * @brief   Base class to implement reconfiguration and failure handling for
+ *          redundant devices by monitoring their modes health states.
+ * @details
+ * Documentation: Dissertation Baetz p.156, 157.
+ *
+ * This class reduces the complexity of controller components which would
+ * otherwise be needed for the handling of redundant devices.
+ *
+ * The template class monitors mode and health state of its children
+ * and checks availability of devices on every detected change.
+ * AssemblyBase does not implement any redundancy logic by itself, but provides
+ * adaptation points for implementations to do so. Since most monitoring
+ * activities rely on mode and health state only and are therefore
+ * generic, it is sufficient for subclasses to provide:
+ *
+ * 1. check logic when active-> checkChildrenStateOn
+ * 2. transition logic to change the mode -> commandChildren
+ *
+ */
+class AssemblyBase: public SubsystemBase {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ASSEMBLY_BASE;
+	static const ReturnValue_t NEED_SECOND_STEP = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t NEED_TO_RECONFIGURE = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t MODE_FALLBACK = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t CHILD_NOT_COMMANDABLE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t NEED_TO_CHANGE_HEALTH = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE =
+			MAKE_RETURN_CODE(0xa1);
+
+	AssemblyBase(object_id_t objectId, object_id_t parentId,
+	        uint16_t commandQueueDepth = 8);
+	virtual ~AssemblyBase();
+
+protected:
+
+    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
+    // (or return internalState directly?)
+    /**
+     * Command children to reach [mode,submode] combination
+     * Can be done by setting #commandsOutstanding correctly,
+     * or using executeTable()
+     * @param mode
+     * @param submode
+     * @return
+     *    - @c RETURN_OK if ok
+     *    - @c NEED_SECOND_STEP if children need to be commanded again
+     */
+    virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
+
+    /**
+     * Check whether desired assembly mode was achieved by checking the modes
+     * or/and health states of child device handlers.
+     * The assembly template class will also call this function if a health
+     * or mode change of a child device handler was detected.
+     * @param wantedMode
+     * @param wantedSubmode
+     * @return
+     */
+    virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
+            Submode_t wantedSubmode) = 0;
+
+    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+            Submode_t submode) = 0;
+
+	enum InternalState {
+		STATE_NONE,
+		STATE_OVERWRITE_HEALTH,
+		STATE_NEED_SECOND_STEP,
+		STATE_SINGLE_STEP,
+		STATE_SECOND_STEP,
+	} internalState;
+
+	enum RecoveryState {
+		RECOVERY_IDLE,
+		RECOVERY_STARTED,
+		RECOVERY_ONGOING,
+		RECOVERY_ONGOING_2,
+		RECOVERY_WAIT
+	} recoveryState; //!< Indicates if one of the children requested a recovery.
+	ChildrenMap::iterator recoveringDevice;
+
+	/**
+	 * the mode the current transition is trying to achieve.
+	 * Can be different from the modehelper.commandedMode!
+	 */
+	Mode_t targetMode;
+
+	/**
+	 * the submode the current transition is trying to achieve.
+	 * Can be different from the modehelper.commandedSubmode!
+	 */
+	Submode_t targetSubmode;
+
+	Countdown recoveryOffTimer;
+
+	static const uint32_t POWER_OFF_TIME_MS = 1000;
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
+
+	virtual ReturnValue_t handleHealthReply(CommandMessage *message);
+
+	virtual void performChildOperation();
+
+	bool handleChildrenChanged();
+
+	/**
+	 * This method is called if the children changed its mode in a way that
+	 * the current mode can't be kept.
+	 * Default behavior is to go to MODE_OFF.
+	 * @param result The failure code which was returned by checkChildrenState.
+	 */
+	virtual void handleChildrenLostMode(ReturnValue_t result);
+
+	bool handleChildrenChangedHealth();
+
+	virtual void handleChildrenTransition();
+
+	ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode);
+
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+
+	virtual void doStartTransition(Mode_t mode, Submode_t submode);
+
+	virtual bool isInTransition();
+
+	virtual void handleModeReached();
+
+	virtual void handleModeTransitionFailed(ReturnValue_t result);
+
+	void sendHealthCommand(MessageQueueId_t sendTo, HealthState health);
+
+	virtual ReturnValue_t checkChildrenStateOff();
+
+	ReturnValue_t checkChildrenState();
+
+	virtual ReturnValue_t checkChildOff(uint32_t objectId);
+
+	/**
+	 * Manages recovery of a device
+	 * @return true if recovery is still ongoing, false else.
+	 */
+	bool checkAndHandleRecovery();
+
+	/**
+	 * Helper method to overwrite health state of one of the children.
+	 * Also sets state to STATE_OVERWRITE_HEATH.
+	 * @param objectId Must be a registered child.
+	 */
+	void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
+
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index acc1b5a04..976c252ad 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -1,47 +1,47 @@
-#include "../subsystem/SubsystemBase.h"
-#include "../devicehandlers/ChildHandlerBase.h"
-#include "../subsystem/SubsystemBase.h"
-
-ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
-		object_id_t deviceCommunication, CookieIF * cookie,
-		object_id_t hkDestination, uint32_t thermalStatePoolId,
-		uint32_t thermalRequestPoolId,
-		object_id_t parent,
-		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
-		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
-			(customFdir == nullptr? &childHandlerFdir : customFdir),
-			cmdQueueSize),
-		parentId(parent), childHandlerFdir(setObjectId) {
-	this->setHkDestination(hkDestination);
-	this->setThermalStateRequestPoolIds(thermalStatePoolId,
-			thermalRequestPoolId);
-
-}
-
-ChildHandlerBase::~ChildHandlerBase() {
-}
-
-ReturnValue_t ChildHandlerBase::initialize() {
-	ReturnValue_t result = DeviceHandlerBase::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	MessageQueueId_t parentQueue = 0;
-
-	if (parentId != objects::NO_OBJECT) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
-
-		parent->registerChild(getObjectId());
-	}
-
-	healthHelper.setParentQueue(parentQueue);
-
-	modeHelper.setParentQueue(parentQueue);
-
-	return RETURN_OK;
-}
+#include "../subsystem/SubsystemBase.h"
+#include "../devicehandlers/ChildHandlerBase.h"
+#include "../subsystem/SubsystemBase.h"
+
+ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
+		object_id_t deviceCommunication, CookieIF * cookie,
+		object_id_t hkDestination, uint32_t thermalStatePoolId,
+		uint32_t thermalRequestPoolId,
+		object_id_t parent,
+		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
+		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
+			(customFdir == nullptr? &childHandlerFdir : customFdir),
+			cmdQueueSize),
+		parentId(parent), childHandlerFdir(setObjectId) {
+	this->setHkDestination(hkDestination);
+	this->setThermalStateRequestPoolIds(thermalStatePoolId,
+			thermalRequestPoolId);
+
+}
+
+ChildHandlerBase::~ChildHandlerBase() {
+}
+
+ReturnValue_t ChildHandlerBase::initialize() {
+	ReturnValue_t result = DeviceHandlerBase::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	MessageQueueId_t parentQueue = 0;
+
+	if (parentId != objects::NO_OBJECT) {
+		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		if (parent == NULL) {
+			return RETURN_FAILED;
+		}
+		parentQueue = parent->getCommandQueue();
+
+		parent->registerChild(getObjectId());
+	}
+
+	healthHelper.setParentQueue(parentQueue);
+
+	modeHelper.setParentQueue(parentQueue);
+
+	return RETURN_OK;
+}
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 625955f0f..19e0fc80e 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -1,24 +1,24 @@
-#ifndef PAYLOADHANDLERBASE_H_
-#define PAYLOADHANDLERBASE_H_
-
-#include "../devicehandlers/ChildHandlerFDIR.h"
-#include "../devicehandlers/DeviceHandlerBase.h"
-
-class ChildHandlerBase: public DeviceHandlerBase {
-public:
-	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * cookie, object_id_t hkDestination,
-			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-			object_id_t parent = objects::NO_OBJECT,
-			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
-	virtual ~ChildHandlerBase();
-
-	virtual ReturnValue_t initialize();
-
-protected:
-	const uint32_t parentId;
-	ChildHandlerFDIR childHandlerFdir;
-
-};
-
-#endif /* PAYLOADHANDLERBASE_H_ */
+#ifndef PAYLOADHANDLERBASE_H_
+#define PAYLOADHANDLERBASE_H_
+
+#include "../devicehandlers/ChildHandlerFDIR.h"
+#include "../devicehandlers/DeviceHandlerBase.h"
+
+class ChildHandlerBase: public DeviceHandlerBase {
+public:
+	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+			CookieIF * cookie, object_id_t hkDestination,
+			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+			object_id_t parent = objects::NO_OBJECT,
+			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
+	virtual ~ChildHandlerBase();
+
+	virtual ReturnValue_t initialize();
+
+protected:
+	const uint32_t parentId;
+	ChildHandlerFDIR childHandlerFdir;
+
+};
+
+#endif /* PAYLOADHANDLERBASE_H_ */
diff --git a/devicehandlers/ChildHandlerFDIR.cpp b/devicehandlers/ChildHandlerFDIR.cpp
index bab5a7e52..9589b44fc 100644
--- a/devicehandlers/ChildHandlerFDIR.cpp
+++ b/devicehandlers/ChildHandlerFDIR.cpp
@@ -1,10 +1,10 @@
-#include "../devicehandlers/ChildHandlerFDIR.h"
-
-ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent, uint32_t recoveryCount) :
-		DeviceHandlerFailureIsolation(owner, faultTreeParent) {
-	recoveryCounter.setFailureThreshold(recoveryCount);
-}
-
-ChildHandlerFDIR::~ChildHandlerFDIR() {
-}
-
+#include "../devicehandlers/ChildHandlerFDIR.h"
+
+ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent, uint32_t recoveryCount) :
+		DeviceHandlerFailureIsolation(owner, faultTreeParent) {
+	recoveryCounter.setFailureThreshold(recoveryCount);
+}
+
+ChildHandlerFDIR::~ChildHandlerFDIR() {
+}
+
diff --git a/devicehandlers/ChildHandlerFDIR.h b/devicehandlers/ChildHandlerFDIR.h
index 83f79a636..203fc9443 100644
--- a/devicehandlers/ChildHandlerFDIR.h
+++ b/devicehandlers/ChildHandlerFDIR.h
@@ -1,20 +1,20 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
-#define FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
-
-#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
-
-/**
- * Very simple extension to normal FDIR.
- * Does not have a default fault tree parent and
- * allows to make the recovery count settable to 0.
- */
-class ChildHandlerFDIR: public DeviceHandlerFailureIsolation {
-public:
-	ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent =
-			NO_FAULT_TREE_PARENT, uint32_t recoveryCount = 0);
-	virtual ~ChildHandlerFDIR();
-protected:
-	static const object_id_t NO_FAULT_TREE_PARENT = 0;
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+#define FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+
+/**
+ * Very simple extension to normal FDIR.
+ * Does not have a default fault tree parent and
+ * allows to make the recovery count settable to 0.
+ */
+class ChildHandlerFDIR: public DeviceHandlerFailureIsolation {
+public:
+	ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent =
+			NO_FAULT_TREE_PARENT, uint32_t recoveryCount = 0);
+	virtual ~ChildHandlerFDIR();
+protected:
+	static const object_id_t NO_FAULT_TREE_PARENT = 0;
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_ */
diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index aacf55803..abdfd3a86 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -1,201 +1,201 @@
-/**
- * @file CommunicationMessage.cpp
- *
- * @date 28.02.2020
- */
-
-#include "../devicehandlers/CommunicationMessage.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <cstring>
-
-CommunicationMessage::CommunicationMessage(): uninitialized(true) {
-}
-
-CommunicationMessage::~CommunicationMessage() {}
-
-void CommunicationMessage::setSendRequestFromPointer(uint32_t address,
-		uint32_t dataLen, const uint8_t * data) {
-	setMessageType(SEND_DATA_FROM_POINTER);
-	setAddress(address);
-	setDataLen(dataLen);
-	setDataPointer(data);
-}
-
-void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_address_t storeId) {
-	setMessageType(SEND_DATA_FROM_IPC_STORE);
-	setAddress(address);
-	setStoreId(storeId.raw);
-}
-
-void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length,
-		uint16_t sendBufferPosition) {
-	setMessageType(SEND_DATA_RAW);
-	setAddress(address);
-	setDataLen(length);
-	if(sendBufferPosition != 0) {
-		setBufferPosition(sendBufferPosition);
-	}
-}
-
-void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) {
-	setMessageType(REPLY_DATA_IPC_STORE);
-	setAddress(address);
-	setStoreId(storeId.raw);
-}
-void CommunicationMessage::setDataReplyFromPointer(uint32_t address,
-		uint32_t dataLen, uint8_t *data) {
-	setMessageType(REPLY_DATA_FROM_POINTER);
-	setAddress(address);
-	setDataLen(dataLen);
-	setDataPointer(data);
-}
-
-void CommunicationMessage::setDataReplyRaw(uint32_t address,
-		uint32_t length, uint16_t receiveBufferPosition) {
-	setMessageType(REPLY_DATA_RAW);
-	setAddress(address);
-	setDataLen(length);
-	if(receiveBufferPosition != 0) {
-		setBufferPosition(receiveBufferPosition);
-	}
-}
-
-void CommunicationMessage::setMessageType(messageType status) {
-	uint8_t status_uint8 = status;
-	memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8));
-}
-
-void CommunicationMessage::setAddress(address_t address) {
-	memcpy(getData(),&address,sizeof(address));
-}
-
-address_t CommunicationMessage::getAddress() const {
-	address_t address;
-	memcpy(&address,getData(),sizeof(address));
-	return address;
-}
-
-void CommunicationMessage::setBufferPosition(uint16_t bufferPosition) {
-	memcpy(getData() + sizeof(uint32_t) + sizeof(uint16_t),
-			&bufferPosition, sizeof(bufferPosition));
-}
-
-uint16_t CommunicationMessage::getBufferPosition() const {
-	uint16_t bufferPosition;
-	memcpy(&bufferPosition,
-			getData() + sizeof(uint32_t) + sizeof(uint16_t), sizeof(bufferPosition));
-	return bufferPosition;
-}
-
-void CommunicationMessage::setDataPointer(const void * data) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(uint32_t));
-}
-
-void CommunicationMessage::setStoreId(store_address_t storeId) {
-	memcpy(getData() + 2 * sizeof(uint32_t), &storeId.raw, sizeof(uint32_t));
-}
-
-store_address_t CommunicationMessage::getStoreId() const{
-	store_address_t temp;
-	memcpy(&temp.raw,getData() + 2 * sizeof(uint32_t), sizeof(uint32_t));
-	return temp;
-}
-
-void CommunicationMessage::setDataLen(uint32_t length) {
-	memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length));
-}
-
-uint32_t CommunicationMessage::getDataLen() const {
-	uint32_t len;
-	memcpy(&len, getData() + 2 * sizeof(uint32_t), sizeof(len));
-	return len;
-}
-
-void CommunicationMessage::setUint32Data(uint32_t data) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(data));
-}
-
-uint32_t CommunicationMessage::getUint32Data() const{
-	uint32_t data;
-	memcpy(&data,getData() + 3 * sizeof(uint32_t),  sizeof(data));
-	return data;
-}
-
-void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
-	if(0 <= position && position <= 3) {
-		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte));
-	}
-	else {
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-}
-
-uint8_t CommunicationMessage::getDataByte(uint8_t position) const {
-	if(0 <= position && position <= 3) {
-		uint8_t byte;
-		memcpy(&byte, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), sizeof(byte));
-		return byte;
-	}
-	else {
-		return 0;
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-}
-
-void CommunicationMessage::setDataUint16(uint16_t data, uint8_t position) {
-	if(position == 0 || position == 1) {
-		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), &data, sizeof(data));
-	}
-	else {
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-
-}
-
-uint16_t CommunicationMessage::getDataUint16(uint8_t position) const{
-	if(position == 0 || position == 1) {
-		uint16_t data;
-		memcpy(&data, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), sizeof(data));
-		return data;
-	}
-	else {
-		return 0;
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-}
-
-CommunicationMessage::messageType CommunicationMessage::getMessageType() const{
-	messageType messageType;
-	memcpy(&messageType, getData() + sizeof(uint32_t),sizeof(uint8_t));
-	return messageType;
-}
-
-void CommunicationMessage::setMessageId(uint8_t messageId) {
-	memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t), &messageId, sizeof(messageId));
-}
-
-uint8_t CommunicationMessage::getMessageId() const {
-	uint8_t messageId;
-	memcpy(&messageId, getData() + sizeof(uint32_t) + sizeof(uint8_t), sizeof(messageId));
-	return messageId;
-}
-
-void CommunicationMessage::clearCommunicationMessage() {
-	messageType messageType = getMessageType();
-	switch(messageType) {
-	case(messageType::REPLY_DATA_IPC_STORE):
-	case(messageType::SEND_DATA_FROM_IPC_STORE): {
-		store_address_t storeId = getStoreId();
-		StorageManagerIF *ipcStore = objectManager->
-				get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(storeId);
-		}
-	}
-	/* NO BREAK falls through*/
-	default:
-		memset(getData(),0,4*sizeof(uint32_t));
-		break;
-	}
-}
-
+/**
+ * @file CommunicationMessage.cpp
+ *
+ * @date 28.02.2020
+ */
+
+#include "../devicehandlers/CommunicationMessage.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+CommunicationMessage::CommunicationMessage(): uninitialized(true) {
+}
+
+CommunicationMessage::~CommunicationMessage() {}
+
+void CommunicationMessage::setSendRequestFromPointer(uint32_t address,
+		uint32_t dataLen, const uint8_t * data) {
+	setMessageType(SEND_DATA_FROM_POINTER);
+	setAddress(address);
+	setDataLen(dataLen);
+	setDataPointer(data);
+}
+
+void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_address_t storeId) {
+	setMessageType(SEND_DATA_FROM_IPC_STORE);
+	setAddress(address);
+	setStoreId(storeId.raw);
+}
+
+void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length,
+		uint16_t sendBufferPosition) {
+	setMessageType(SEND_DATA_RAW);
+	setAddress(address);
+	setDataLen(length);
+	if(sendBufferPosition != 0) {
+		setBufferPosition(sendBufferPosition);
+	}
+}
+
+void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) {
+	setMessageType(REPLY_DATA_IPC_STORE);
+	setAddress(address);
+	setStoreId(storeId.raw);
+}
+void CommunicationMessage::setDataReplyFromPointer(uint32_t address,
+		uint32_t dataLen, uint8_t *data) {
+	setMessageType(REPLY_DATA_FROM_POINTER);
+	setAddress(address);
+	setDataLen(dataLen);
+	setDataPointer(data);
+}
+
+void CommunicationMessage::setDataReplyRaw(uint32_t address,
+		uint32_t length, uint16_t receiveBufferPosition) {
+	setMessageType(REPLY_DATA_RAW);
+	setAddress(address);
+	setDataLen(length);
+	if(receiveBufferPosition != 0) {
+		setBufferPosition(receiveBufferPosition);
+	}
+}
+
+void CommunicationMessage::setMessageType(messageType status) {
+	uint8_t status_uint8 = status;
+	memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8));
+}
+
+void CommunicationMessage::setAddress(address_t address) {
+	memcpy(getData(),&address,sizeof(address));
+}
+
+address_t CommunicationMessage::getAddress() const {
+	address_t address;
+	memcpy(&address,getData(),sizeof(address));
+	return address;
+}
+
+void CommunicationMessage::setBufferPosition(uint16_t bufferPosition) {
+	memcpy(getData() + sizeof(uint32_t) + sizeof(uint16_t),
+			&bufferPosition, sizeof(bufferPosition));
+}
+
+uint16_t CommunicationMessage::getBufferPosition() const {
+	uint16_t bufferPosition;
+	memcpy(&bufferPosition,
+			getData() + sizeof(uint32_t) + sizeof(uint16_t), sizeof(bufferPosition));
+	return bufferPosition;
+}
+
+void CommunicationMessage::setDataPointer(const void * data) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(uint32_t));
+}
+
+void CommunicationMessage::setStoreId(store_address_t storeId) {
+	memcpy(getData() + 2 * sizeof(uint32_t), &storeId.raw, sizeof(uint32_t));
+}
+
+store_address_t CommunicationMessage::getStoreId() const{
+	store_address_t temp;
+	memcpy(&temp.raw,getData() + 2 * sizeof(uint32_t), sizeof(uint32_t));
+	return temp;
+}
+
+void CommunicationMessage::setDataLen(uint32_t length) {
+	memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length));
+}
+
+uint32_t CommunicationMessage::getDataLen() const {
+	uint32_t len;
+	memcpy(&len, getData() + 2 * sizeof(uint32_t), sizeof(len));
+	return len;
+}
+
+void CommunicationMessage::setUint32Data(uint32_t data) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(data));
+}
+
+uint32_t CommunicationMessage::getUint32Data() const{
+	uint32_t data;
+	memcpy(&data,getData() + 3 * sizeof(uint32_t),  sizeof(data));
+	return data;
+}
+
+void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
+	if(0 <= position && position <= 3) {
+		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte));
+	}
+	else {
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
+	}
+}
+
+uint8_t CommunicationMessage::getDataByte(uint8_t position) const {
+	if(0 <= position && position <= 3) {
+		uint8_t byte;
+		memcpy(&byte, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), sizeof(byte));
+		return byte;
+	}
+	else {
+		return 0;
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
+	}
+}
+
+void CommunicationMessage::setDataUint16(uint16_t data, uint8_t position) {
+	if(position == 0 || position == 1) {
+		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), &data, sizeof(data));
+	}
+	else {
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
+	}
+
+}
+
+uint16_t CommunicationMessage::getDataUint16(uint8_t position) const{
+	if(position == 0 || position == 1) {
+		uint16_t data;
+		memcpy(&data, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), sizeof(data));
+		return data;
+	}
+	else {
+		return 0;
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
+	}
+}
+
+CommunicationMessage::messageType CommunicationMessage::getMessageType() const{
+	messageType messageType;
+	memcpy(&messageType, getData() + sizeof(uint32_t),sizeof(uint8_t));
+	return messageType;
+}
+
+void CommunicationMessage::setMessageId(uint8_t messageId) {
+	memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t), &messageId, sizeof(messageId));
+}
+
+uint8_t CommunicationMessage::getMessageId() const {
+	uint8_t messageId;
+	memcpy(&messageId, getData() + sizeof(uint32_t) + sizeof(uint8_t), sizeof(messageId));
+	return messageId;
+}
+
+void CommunicationMessage::clearCommunicationMessage() {
+	messageType messageType = getMessageType();
+	switch(messageType) {
+	case(messageType::REPLY_DATA_IPC_STORE):
+	case(messageType::SEND_DATA_FROM_IPC_STORE): {
+		store_address_t storeId = getStoreId();
+		StorageManagerIF *ipcStore = objectManager->
+				get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(storeId);
+		}
+	}
+	/* NO BREAK falls through*/
+	default:
+		memset(getData(),0,4*sizeof(uint32_t));
+		break;
+	}
+}
+
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
index a31e270c3..5b429d9ae 100644
--- a/devicehandlers/CommunicationMessage.h
+++ b/devicehandlers/CommunicationMessage.h
@@ -1,173 +1,173 @@
-/**
- * @file CommunicationMessage.h
- *
- * @date 28.02.2020
- */
-
-#ifndef FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
-#define FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
-#include "../devicehandlers/CommunicationMessage.h"
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../devicehandlers/DeviceHandlerBase.h"
-
-/**
- * @brief Message type to send larger messages
- *
- * @details
- * Can be used to pass information like data pointers and
- * data sizes between communication tasks.
- *
- */
-class CommunicationMessage: public MessageQueueMessage {
-public:
-	enum messageType {
-		NONE,
-		SEND_DATA_FROM_POINTER,
-		SEND_DATA_FROM_IPC_STORE,
-		SEND_DATA_RAW,
-		REPLY_DATA_FROM_POINTER,
-		REPLY_DATA_IPC_STORE,
-		REPLY_DATA_RAW,
-		FAULTY,
-	};
-
-	//Add other messageIDs here if necessary.
-	static const uint8_t COMMUNICATION_MESSAGE_SIZE = HEADER_SIZE + 4 * sizeof(uint32_t);
-
-	CommunicationMessage();
-	virtual ~CommunicationMessage();
-
-	/**
-	 * Message Type is stored as the fifth byte of the message data
-	 * @param status
-	 */
-	void setMessageType(messageType status);
-	messageType getMessageType() const;
-
-	/**
-	 * This is a unique ID which can be used to handle different kinds of messages.
-	 * For example, the same interface (e.g. SPI) could be used to exchange raw data
-	 * (e.g. sensor values) and data stored in the IPC store.
-	 * The ID can be used to distinguish the messages in child implementations.
-	 * The message ID is stored as the sixth byte of the message data.
-	 * @param messageId
-	 */
-	void setMessageId(uint8_t messageId);
-	uint8_t getMessageId() const;
-
-	/**
-	 * Send requests with pointer to the data to be sent and send data length
-	 * @param address Target Address, first four bytes
-	 * @param dataLen Length of data to send, next four bytes
-	 * @param data Pointer to data to send
-	 *
-	 */
-	void setSendRequestFromPointer(uint32_t address, uint32_t dataLen, const uint8_t * data);
-
-	/**
-	 * Send requests with a store ID, using the IPC store
-	 * @param address Target Address, first four bytes
-	 * @param storeId Store ID in the IPC store
-	 *
-	 */
-	void setSendRequestFromIpcStore(uint32_t address, store_address_t storeId);
-
-	/**
-	 * Send requests with data length and data in message (max. 4 bytes)
-	 * @param address Target Address, first four bytes
-	 * @param dataLen Length of data to send, next four bytes
-	 * @param data Pointer to data to send
-	 *
-	 */
-	void setSendRequestRaw(uint32_t address, uint32_t length,
-			uint16_t sendBufferPosition = 0);
-
-	/**
-	 * Data message with data stored in IPC store
-	 * @param address Target Address, first four bytes
-	 * @param length
-	 * @param storeId
-	 */
-	void setDataReplyFromIpcStore(uint32_t address, store_address_t storeId);
-
-	/**
-	 * Data reply with data stored in buffer, passing the pointer to
-	 * the buffer and the data size
-	 * @param address Target Address, first four bytes
-	 * @param dataLen Length of data to send, next four bytes
-	 * @param data Pointer to the data
-	 */
-	void setDataReplyFromPointer(uint32_t address, uint32_t dataLen, uint8_t * data);
-
-	/**
-	 * Data message with data stored in actual message.
-	 * 4 byte datafield is intialized with 0.
-	 * Set data with specific setter functions below.
-	 * Can also be used to supply information at which position the raw data should be stored
-	 * in a receive buffer.
-	 */
-	void setDataReplyRaw(uint32_t address, uint32_t length, uint16_t receiveBufferPosition = 0);
-
-	/**
-	 * First four bytes of message data
-	 * @param address
-	 */
-	void setAddress(address_t address);
-
-	address_t getAddress() const;
-	/**
-	 * Set byte as position of 4 byte data field
-	 * @param byte
-	 * @param position Position, 0 to 3 possible
-	 */
-	void setDataByte(uint8_t byte, uint8_t position);
-	uint8_t getDataByte(uint8_t position) const;
-
-	/**
-	 * Set 2 byte value at position 1 or 2 of data field
-	 * @param data
-	 * @param position 0 or 1 possible
-	 */
-	void setDataUint16(uint16_t data, uint8_t position);
-	uint16_t getDataUint16(uint8_t position) const;
-
-	void setUint32Data(uint32_t data);
-	uint32_t getUint32Data() const;
-
-	/**
-	 * Stored in Bytes 13-16 of message data
-	 * @param length
-	 */
-	void setDataLen(uint32_t length);
-
-	uint32_t getDataLen() const;
-
-	/**
-	 * Stored in last four bytes (Bytes 17-20) of message data
-	 * @param sendData
-	 */
-	void setDataPointer(const void * data);
-
-	/**
-	 * In case the send request data or reply data is to be stored in a buffer,
-	 * a buffer Position can be stored here as the seventh and eigth byte of
-	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now.
-	 * @param bufferPosition In case the data is stored in a buffer, the position can be supplied here
-	 */
-	void setBufferPosition(uint16_t bufferPosition);
-	uint16_t getBufferPosition() const;
-	void setStoreId(store_address_t storeId);
-	store_address_t getStoreId() const;
-
-	/**
-	 * Clear the message. Deletes IPC Store data
-	 * and sets all data to 0. Also sets message type to NONE
-	 */
-	void clearCommunicationMessage();
-private:
-	bool uninitialized; //!< Could be used to warn if data has not been set.
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_ */
+/**
+ * @file CommunicationMessage.h
+ *
+ * @date 28.02.2020
+ */
+
+#ifndef FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
+#define FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
+#include "../devicehandlers/CommunicationMessage.h"
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../devicehandlers/DeviceHandlerBase.h"
+
+/**
+ * @brief Message type to send larger messages
+ *
+ * @details
+ * Can be used to pass information like data pointers and
+ * data sizes between communication tasks.
+ *
+ */
+class CommunicationMessage: public MessageQueueMessage {
+public:
+	enum messageType {
+		NONE,
+		SEND_DATA_FROM_POINTER,
+		SEND_DATA_FROM_IPC_STORE,
+		SEND_DATA_RAW,
+		REPLY_DATA_FROM_POINTER,
+		REPLY_DATA_IPC_STORE,
+		REPLY_DATA_RAW,
+		FAULTY,
+	};
+
+	//Add other messageIDs here if necessary.
+	static const uint8_t COMMUNICATION_MESSAGE_SIZE = HEADER_SIZE + 4 * sizeof(uint32_t);
+
+	CommunicationMessage();
+	virtual ~CommunicationMessage();
+
+	/**
+	 * Message Type is stored as the fifth byte of the message data
+	 * @param status
+	 */
+	void setMessageType(messageType status);
+	messageType getMessageType() const;
+
+	/**
+	 * This is a unique ID which can be used to handle different kinds of messages.
+	 * For example, the same interface (e.g. SPI) could be used to exchange raw data
+	 * (e.g. sensor values) and data stored in the IPC store.
+	 * The ID can be used to distinguish the messages in child implementations.
+	 * The message ID is stored as the sixth byte of the message data.
+	 * @param messageId
+	 */
+	void setMessageId(uint8_t messageId);
+	uint8_t getMessageId() const;
+
+	/**
+	 * Send requests with pointer to the data to be sent and send data length
+	 * @param address Target Address, first four bytes
+	 * @param dataLen Length of data to send, next four bytes
+	 * @param data Pointer to data to send
+	 *
+	 */
+	void setSendRequestFromPointer(uint32_t address, uint32_t dataLen, const uint8_t * data);
+
+	/**
+	 * Send requests with a store ID, using the IPC store
+	 * @param address Target Address, first four bytes
+	 * @param storeId Store ID in the IPC store
+	 *
+	 */
+	void setSendRequestFromIpcStore(uint32_t address, store_address_t storeId);
+
+	/**
+	 * Send requests with data length and data in message (max. 4 bytes)
+	 * @param address Target Address, first four bytes
+	 * @param dataLen Length of data to send, next four bytes
+	 * @param data Pointer to data to send
+	 *
+	 */
+	void setSendRequestRaw(uint32_t address, uint32_t length,
+			uint16_t sendBufferPosition = 0);
+
+	/**
+	 * Data message with data stored in IPC store
+	 * @param address Target Address, first four bytes
+	 * @param length
+	 * @param storeId
+	 */
+	void setDataReplyFromIpcStore(uint32_t address, store_address_t storeId);
+
+	/**
+	 * Data reply with data stored in buffer, passing the pointer to
+	 * the buffer and the data size
+	 * @param address Target Address, first four bytes
+	 * @param dataLen Length of data to send, next four bytes
+	 * @param data Pointer to the data
+	 */
+	void setDataReplyFromPointer(uint32_t address, uint32_t dataLen, uint8_t * data);
+
+	/**
+	 * Data message with data stored in actual message.
+	 * 4 byte datafield is intialized with 0.
+	 * Set data with specific setter functions below.
+	 * Can also be used to supply information at which position the raw data should be stored
+	 * in a receive buffer.
+	 */
+	void setDataReplyRaw(uint32_t address, uint32_t length, uint16_t receiveBufferPosition = 0);
+
+	/**
+	 * First four bytes of message data
+	 * @param address
+	 */
+	void setAddress(address_t address);
+
+	address_t getAddress() const;
+	/**
+	 * Set byte as position of 4 byte data field
+	 * @param byte
+	 * @param position Position, 0 to 3 possible
+	 */
+	void setDataByte(uint8_t byte, uint8_t position);
+	uint8_t getDataByte(uint8_t position) const;
+
+	/**
+	 * Set 2 byte value at position 1 or 2 of data field
+	 * @param data
+	 * @param position 0 or 1 possible
+	 */
+	void setDataUint16(uint16_t data, uint8_t position);
+	uint16_t getDataUint16(uint8_t position) const;
+
+	void setUint32Data(uint32_t data);
+	uint32_t getUint32Data() const;
+
+	/**
+	 * Stored in Bytes 13-16 of message data
+	 * @param length
+	 */
+	void setDataLen(uint32_t length);
+
+	uint32_t getDataLen() const;
+
+	/**
+	 * Stored in last four bytes (Bytes 17-20) of message data
+	 * @param sendData
+	 */
+	void setDataPointer(const void * data);
+
+	/**
+	 * In case the send request data or reply data is to be stored in a buffer,
+	 * a buffer Position can be stored here as the seventh and eigth byte of
+	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now.
+	 * @param bufferPosition In case the data is stored in a buffer, the position can be supplied here
+	 */
+	void setBufferPosition(uint16_t bufferPosition);
+	uint16_t getBufferPosition() const;
+	void setStoreId(store_address_t storeId);
+	store_address_t getStoreId() const;
+
+	/**
+	 * Clear the message. Deletes IPC Store data
+	 * and sets all data to 0. Also sets message type to NONE
+	 */
+	void clearCommunicationMessage();
+private:
+	bool uninitialized; //!< Could be used to warn if data has not been set.
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index cbff54115..db37eade2 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -1,127 +1,127 @@
-#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
-#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
-
-#include "../devicehandlers/CookieIF.h"
-#include "../devicehandlers/DeviceHandlerIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-/**
- * @defgroup interfaces Interfaces
- * @brief Interfaces for flight software objects
- */
-
-/**
- * @defgroup comm Communication
- * @brief Communication software components.
- */
-
-/**
- * @brief This is an interface to decouple device communication from
- * the device handler to allow reuse of these components.
- * @details
- * Documentation: Dissertation Baetz p.138.
- * It works with the assumption that received data  is polled by a component.
- * There are four generic steps of device communication:
- *
- *   1. Send data to a device
- *   2. Get acknowledgement for sending
- *   3. Request reading data from a device
- *   4. Read received data
- *
- *  To identify different connection over a single interface can return
- *  so-called cookies to components.
- *  The CommunicationMessage message type can be used to extend the
- *  functionality of the ComIF if a separate polling task is required.
- *  @ingroup interfaces
- *  @ingroup comm
- */
-class DeviceCommunicationIF: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
-
-	//! This is returned in readReceivedMessage() if no reply was reived.
-	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0x01);
-
-	//! General protocol error. Define more concrete errors in child handler
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
-	//! If cookie is a null pointer
-	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x04);
-	// is this needed if there is no open/close call?
-	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
-
-	virtual ~DeviceCommunicationIF() {}
-
-	/**
-	 * @brief Device specific initialization, using the cookie.
-	 * @details
-	 * The cookie is already prepared in the factory. If the communication
-	 * interface needs to be set up in some way and requires cookie information,
-	 * this can be performed in this function, which is called on device handler
-	 * initialization.
-	 * @param cookie
-	 * @return
-	 *  - @c RETURN_OK if initialization was successfull
-	 *  - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendWrite().
-	 * This function is used to send data to the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param data
-	 * @param len If this is 0, nothing shall be sent.
-	 * @return
-	 *  - @c RETURN_OK for successfull send
-	 *  - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t sendMessage(CookieIF *cookie,
-	        const uint8_t * sendData, size_t sendLen) = 0;
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetWrite().
-	 * Get send confirmation that the data in sendMessage() was sent successfully.
-	 * @param cookie
-	 * @return - @c RETURN_OK if data was sent successfull
-	 * 		   - Everything else triggers falure event with
-	 * 		     returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * It is assumed that it is always possible to request a reply
-	 * from a device. If a requestLen of 0 is supplied, no reply was enabled
-	 * and communication specific action should be taken (e.g. read nothing
-	 * or read everything).
-	 *
-	 * @param cookie
-	 * @param requestLen Size of data to read
-	 * @return - @c RETURN_OK to confirm the request for data has been sent.
-	 *         - Everything else triggers failure event with
-	 *           returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-	        size_t requestLen) = 0;
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetRead().
-	 * This function is used to receive data from the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param buffer [out] Set reply here (by using *buffer = ...)
-	 * @param size [out] size pointer to set (by using *size = ...).
-	 * 	           Set to 0 if no reply was received
-	 * @return - @c RETURN_OK for successfull receive
-	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
-	 * 		   	   0 has the same effect
-	 *         - Everything else triggers failure event with
-	 *           returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
-	        uint8_t **buffer, size_t *size) = 0;
-};
-
-#endif /* DEVICECOMMUNICATIONIF_H_ */
+#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+
+#include "../devicehandlers/CookieIF.h"
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ * @defgroup interfaces Interfaces
+ * @brief Interfaces for flight software objects
+ */
+
+/**
+ * @defgroup comm Communication
+ * @brief Communication software components.
+ */
+
+/**
+ * @brief This is an interface to decouple device communication from
+ * the device handler to allow reuse of these components.
+ * @details
+ * Documentation: Dissertation Baetz p.138.
+ * It works with the assumption that received data  is polled by a component.
+ * There are four generic steps of device communication:
+ *
+ *   1. Send data to a device
+ *   2. Get acknowledgement for sending
+ *   3. Request reading data from a device
+ *   4. Read received data
+ *
+ *  To identify different connection over a single interface can return
+ *  so-called cookies to components.
+ *  The CommunicationMessage message type can be used to extend the
+ *  functionality of the ComIF if a separate polling task is required.
+ *  @ingroup interfaces
+ *  @ingroup comm
+ */
+class DeviceCommunicationIF: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
+
+	//! This is returned in readReceivedMessage() if no reply was reived.
+	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0x01);
+
+	//! General protocol error. Define more concrete errors in child handler
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
+	//! If cookie is a null pointer
+	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x04);
+	// is this needed if there is no open/close call?
+	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
+
+	virtual ~DeviceCommunicationIF() {}
+
+	/**
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return
+	 *  - @c RETURN_OK if initialization was successfull
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len If this is 0, nothing shall be sent.
+	 * @return
+	 *  - @c RETURN_OK for successfull send
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t sendMessage(CookieIF *cookie,
+	        const uint8_t * sendData, size_t sendLen) = 0;
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return - @c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with
+	 * 		     returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device. If a requestLen of 0 is supplied, no reply was enabled
+	 * and communication specific action should be taken (e.g. read nothing
+	 * or read everything).
+	 *
+	 * @param cookie
+	 * @param requestLen Size of data to read
+	 * @return - @c RETURN_OK to confirm the request for data has been sent.
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
+	        size_t requestLen) = 0;
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param buffer [out] Set reply here (by using *buffer = ...)
+	 * @param size [out] size pointer to set (by using *size = ...).
+	 * 	           Set to 0 if no reply was received
+	 * @return - @c RETURN_OK for successfull receive
+	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
+	 * 		   	   0 has the same effect
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
+	        uint8_t **buffer, size_t *size) = 0;
+};
+
+#endif /* DEVICECOMMUNICATIONIF_H_ */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 67ab37f71..e3fa3b882 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,155 +1,155 @@
-#ifndef DEVICEHANDLERIF_H_
-#define DEVICEHANDLERIF_H_
-
-#include "../action/HasActionsIF.h"
-#include "../devicehandlers/DeviceHandlerMessage.h"
-#include "../events/Event.h"
-#include "../modes/HasModesIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-/**
- * @brief 	This is the Interface used to communicate with a device handler.
- * @details Includes all expected return values, events and modes.
- *
- */
-class DeviceHandlerIF {
-public:
-
-	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
-	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
-
-	/**
-	 * @brief This is the mode the <strong>device handler</strong> is in.
-	 *
-	 * @details The mode of the device handler must not be confused with the mode the device is in.
-	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
-	 * MODE_ON and MODE_OFF are included in hasModesIF.h
-	 */
-
-	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	//! The device is powered on and the device handler periodically sends
-	//! commands. The commands to be sent are selected by the handler
-	//! according to the submode.
-	static const Mode_t MODE_NORMAL = 2;
-	//! The device is powered on and ready to perform operations. In this mode,
-	//! raw commands can be sent. The device handler will send all replies
-	//! received from the command back to the commanding object.
-	static const Mode_t MODE_RAW = 3;
-	//! The device is shut down but the switch could not be turned off, so the
-	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
-	//! can be commanded, which tries to switch off the device again.
-	static const Mode_t MODE_ERROR_ON = 4;
-	//! This is a transitional state which can not be commanded. The device
-	//! handler performs all commands to get the device in a state ready to
-	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
-	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
-	//! This is a transitional state which can not be commanded.
-	//! The device handler performs all actions and commands to get the device
-	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
-	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
-	//! transition if available.
-	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
-	//! It is possible to set the mode to _MODE_TO_ON to use the to on
-	//! transition if available.
-	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
-	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
-	//! transition if available.
-	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
-	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
-	//! transition if available.
-	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
-	//! This is a transitional state which can not be commanded.
-	//! The device is shut down and ready to be switched off.
-	//! After the command to set the switch off has been sent,
-	//! the mode changes to @c MODE_WAIT_OFF
-	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
-	//! This is a transitional state which can not be commanded. The device
-	//! will be switched on in this state. After the command to set the switch
-	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
-	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
-	//! This is a transitional state which can not be commanded. The switch has
-	//! been commanded off and the handler waits for it to be off.
-	//! When the switch is off, the mode changes to @c MODE_OFF.
-	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
-	//! This is a transitional state which can not be commanded. The switch
-	//! has been commanded on and the handler waits for it to be on.
-	//! When the switch is on, the mode changes to @c MODE_TO_ON.
-	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
-	//! This is a transitional state which can not be commanded. The switch has
-	//! been commanded off and is off now. This state is only to do an RMAP
-	//! cycle once more where the doSendRead() function will set the mode to
-	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
-	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
-	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
-	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
-	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
-	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
-	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
-	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
-
-	// Standard codes used when building commands.
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
-	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
-	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
-	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
-	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA4);
-	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
-	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
-	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
-	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
-
-	// Standard codes used in scanForReply
-	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB0);
-	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB1);
-	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB2);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB3);
-
-	// Standard codes used in  interpretDeviceReply
-	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
-	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
-	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
-	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
-
-	// Standard codes used in buildCommandFromCommand
-	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
-	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
-
-	/**
-	 * Communication action that will be executed.
-	 *
-	 * This is used by the child class to tell the base class what to do.
-	 */
-	enum CommunicationAction_t: uint8_t {
-		SEND_WRITE,//!< Send write
-		GET_WRITE, //!< Get write
-		SEND_READ, //!< Send read
-		GET_READ,  //!< Get read
-		NOTHING    //!< Do nothing.
-	};
-
-	/**
-	 * Default Destructor
-	 */
-	virtual ~DeviceHandlerIF() {}
-
-	/**
-	 * This MessageQueue is used to command the device handler.
-	 * @return the id of the MessageQueue
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-
-};
-
-#endif /* DEVICEHANDLERIF_H_ */
+#ifndef DEVICEHANDLERIF_H_
+#define DEVICEHANDLERIF_H_
+
+#include "../action/HasActionsIF.h"
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../events/Event.h"
+#include "../modes/HasModesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * @brief 	This is the Interface used to communicate with a device handler.
+ * @details Includes all expected return values, events and modes.
+ *
+ */
+class DeviceHandlerIF {
+public:
+
+	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
+	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
+
+	/**
+	 * @brief This is the mode the <strong>device handler</strong> is in.
+	 *
+	 * @details The mode of the device handler must not be confused with the mode the device is in.
+	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
+	 * MODE_ON and MODE_OFF are included in hasModesIF.h
+	 */
+
+	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	//! The device is powered on and the device handler periodically sends
+	//! commands. The commands to be sent are selected by the handler
+	//! according to the submode.
+	static const Mode_t MODE_NORMAL = 2;
+	//! The device is powered on and ready to perform operations. In this mode,
+	//! raw commands can be sent. The device handler will send all replies
+	//! received from the command back to the commanding object.
+	static const Mode_t MODE_RAW = 3;
+	//! The device is shut down but the switch could not be turned off, so the
+	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
+	//! can be commanded, which tries to switch off the device again.
+	static const Mode_t MODE_ERROR_ON = 4;
+	//! This is a transitional state which can not be commanded. The device
+	//! handler performs all commands to get the device in a state ready to
+	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
+	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
+	//! This is a transitional state which can not be commanded.
+	//! The device handler performs all actions and commands to get the device
+	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
+	//! transition if available.
+	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
+	//! It is possible to set the mode to _MODE_TO_ON to use the to on
+	//! transition if available.
+	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
+	//! transition if available.
+	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
+	//! transition if available.
+	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
+	//! This is a transitional state which can not be commanded.
+	//! The device is shut down and ready to be switched off.
+	//! After the command to set the switch off has been sent,
+	//! the mode changes to @c MODE_WAIT_OFF
+	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
+	//! This is a transitional state which can not be commanded. The device
+	//! will be switched on in this state. After the command to set the switch
+	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
+	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and the handler waits for it to be off.
+	//! When the switch is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
+	//! This is a transitional state which can not be commanded. The switch
+	//! has been commanded on and the handler waits for it to be on.
+	//! When the switch is on, the mode changes to @c MODE_TO_ON.
+	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and is off now. This state is only to do an RMAP
+	//! cycle once more where the doSendRead() function will set the mode to
+	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
+	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
+	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
+	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
+	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
+	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
+	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
+	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
+
+	// Standard codes used when building commands.
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
+	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
+	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
+	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
+	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
+	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
+	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
+
+	// Standard codes used in scanForReply
+	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB0);
+	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB2);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB3);
+
+	// Standard codes used in  interpretDeviceReply
+	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
+	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
+	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
+
+	// Standard codes used in buildCommandFromCommand
+	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
+	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
+
+	/**
+	 * Communication action that will be executed.
+	 *
+	 * This is used by the child class to tell the base class what to do.
+	 */
+	enum CommunicationAction_t: uint8_t {
+		SEND_WRITE,//!< Send write
+		GET_WRITE, //!< Get write
+		SEND_READ, //!< Send read
+		GET_READ,  //!< Get read
+		NOTHING    //!< Do nothing.
+	};
+
+	/**
+	 * Default Destructor
+	 */
+	virtual ~DeviceHandlerIF() {}
+
+	/**
+	 * This MessageQueue is used to command the device handler.
+	 * @return the id of the MessageQueue
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+};
+
+#endif /* DEVICEHANDLERIF_H_ */
diff --git a/devicehandlers/DeviceHandlerMessage.cpp b/devicehandlers/DeviceHandlerMessage.cpp
index 95e5ae0c0..b4963dbf7 100644
--- a/devicehandlers/DeviceHandlerMessage.cpp
+++ b/devicehandlers/DeviceHandlerMessage.cpp
@@ -1,101 +1,101 @@
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../devicehandlers/DeviceHandlerMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-DeviceHandlerMessage::DeviceHandlerMessage() {
-}
-
-store_address_t DeviceHandlerMessage::getStoreAddress(
-		const CommandMessage* message) {
-	return store_address_t(message->getParameter2());
-}
-
-uint32_t DeviceHandlerMessage::getDeviceCommandId(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-object_id_t DeviceHandlerMessage::getIoBoardObjectId(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-uint8_t DeviceHandlerMessage::getWiretappingMode(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
-//		CommandMessage* message, DeviceCommandId_t deviceCommand,
-//		store_address_t commandParametersStoreId) {
-//	message->setCommand(CMD_DIRECT);
-//	message->setParameter(deviceCommand);
-//	message->setParameter2(commandParametersStoreId.raw);
-//}
-
-void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
-		CommandMessage* message, store_address_t rawPacketStoreId) {
-	message->setCommand(CMD_RAW);
-	message->setParameter2(rawPacketStoreId.raw);
-}
-
-void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
-		CommandMessage* message, uint8_t wiretappingMode) {
-	message->setCommand(CMD_WIRETAPPING);
-	message->setParameter(wiretappingMode);
-}
-
-void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
-		CommandMessage* message, uint32_t ioBoardIdentifier) {
-	message->setCommand(CMD_SWITCH_ADDRESS);
-	message->setParameter(ioBoardIdentifier);
-}
-
-object_id_t DeviceHandlerMessage::getDeviceObjectId(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-void DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(
-		CommandMessage* message, object_id_t deviceObjectid,
-		store_address_t rawPacketStoreId, bool isCommand) {
-	if (isCommand) {
-		message->setCommand(REPLY_RAW_COMMAND);
-	} else {
-		message->setCommand(REPLY_RAW_REPLY);
-	}
-	message->setParameter(deviceObjectid);
-	message->setParameter2(rawPacketStoreId.raw);
-}
-
-void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
-		CommandMessage* message, object_id_t deviceObjectid,
-		store_address_t commandParametersStoreId) {
-	message->setCommand(REPLY_DIRECT_COMMAND_DATA);
-	message->setParameter(deviceObjectid);
-	message->setParameter2(commandParametersStoreId.raw);
-}
-
-void DeviceHandlerMessage::clear(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case CMD_RAW:
-//	case CMD_DIRECT:
-	case REPLY_RAW_COMMAND:
-	case REPLY_RAW_REPLY:
-	case REPLY_DIRECT_COMMAND_DATA: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreAddress(message));
-		}
-	}
-		/* NO BREAK falls through*/
-	case CMD_SWITCH_ADDRESS:
-	case CMD_WIRETAPPING:
-		message->setCommand(CommandMessage::CMD_NONE);
-		message->setParameter(0);
-		message->setParameter2(0);
-		break;
-	}
-
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+DeviceHandlerMessage::DeviceHandlerMessage() {
+}
+
+store_address_t DeviceHandlerMessage::getStoreAddress(
+		const CommandMessage* message) {
+	return store_address_t(message->getParameter2());
+}
+
+uint32_t DeviceHandlerMessage::getDeviceCommandId(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+object_id_t DeviceHandlerMessage::getIoBoardObjectId(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+uint8_t DeviceHandlerMessage::getWiretappingMode(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
+//		CommandMessage* message, DeviceCommandId_t deviceCommand,
+//		store_address_t commandParametersStoreId) {
+//	message->setCommand(CMD_DIRECT);
+//	message->setParameter(deviceCommand);
+//	message->setParameter2(commandParametersStoreId.raw);
+//}
+
+void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
+		CommandMessage* message, store_address_t rawPacketStoreId) {
+	message->setCommand(CMD_RAW);
+	message->setParameter2(rawPacketStoreId.raw);
+}
+
+void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
+		CommandMessage* message, uint8_t wiretappingMode) {
+	message->setCommand(CMD_WIRETAPPING);
+	message->setParameter(wiretappingMode);
+}
+
+void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
+		CommandMessage* message, uint32_t ioBoardIdentifier) {
+	message->setCommand(CMD_SWITCH_ADDRESS);
+	message->setParameter(ioBoardIdentifier);
+}
+
+object_id_t DeviceHandlerMessage::getDeviceObjectId(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+void DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(
+		CommandMessage* message, object_id_t deviceObjectid,
+		store_address_t rawPacketStoreId, bool isCommand) {
+	if (isCommand) {
+		message->setCommand(REPLY_RAW_COMMAND);
+	} else {
+		message->setCommand(REPLY_RAW_REPLY);
+	}
+	message->setParameter(deviceObjectid);
+	message->setParameter2(rawPacketStoreId.raw);
+}
+
+void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
+		CommandMessage* message, object_id_t deviceObjectid,
+		store_address_t commandParametersStoreId) {
+	message->setCommand(REPLY_DIRECT_COMMAND_DATA);
+	message->setParameter(deviceObjectid);
+	message->setParameter2(commandParametersStoreId.raw);
+}
+
+void DeviceHandlerMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_RAW:
+//	case CMD_DIRECT:
+	case REPLY_RAW_COMMAND:
+	case REPLY_RAW_REPLY:
+	case REPLY_DIRECT_COMMAND_DATA: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreAddress(message));
+		}
+	}
+		/* NO BREAK falls through*/
+	case CMD_SWITCH_ADDRESS:
+	case CMD_WIRETAPPING:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+	}
+
+}
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index 6b54392be..5f4583d2c 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -1,91 +1,91 @@
-#ifndef DEVICEHANDLERMESSAGE_H_
-#define DEVICEHANDLERMESSAGE_H_
-
-#include "../action/ActionMessage.h"
-#include "../ipc/CommandMessage.h"
-#include "../objectmanager/SystemObjectIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
-
-/**
- * This is used to uniquely identify commands that are sent to a device
- *
- * The values are defined in the device-specific implementations
- */
-typedef uint32_t DeviceCommandId_t;
-
-/**
- * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
- */
-class DeviceHandlerMessage {
-private:
-	DeviceHandlerMessage();
-public:
-
-	/**
-	 * These are the commands that can be sent to a DeviceHandlerBase
-	 */
-	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_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
-	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
-
-	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
-	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
-	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
-
-	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
-
-	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
-	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
-	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
-	 */
-	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
-	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
-	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
-	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
-
-	/**
-	 * Default Destructor
-	 */
-	virtual ~DeviceHandlerMessage() {
-	}
-
-	static store_address_t getStoreAddress(const CommandMessage* message);
-	static uint32_t getDeviceCommandId(const CommandMessage* message);
-	static object_id_t getDeviceObjectId(const CommandMessage *message);
-	static object_id_t getIoBoardObjectId(const CommandMessage* message);
-	static uint8_t getWiretappingMode(const CommandMessage* message);
-
-//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
-//			DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-
-	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
-			object_id_t deviceObjectid,
-			store_address_t commandParametersStoreId);
-
-	static void setDeviceHandlerRawCommandMessage(CommandMessage* message,
-			store_address_t rawPacketStoreId);
-
-	static void setDeviceHandlerRawReplyMessage(CommandMessage* message,
-			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
-			bool isCommand);
-
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, store_address_t rawPacketStoreId);
-	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
-			uint8_t wiretappingMode);
-	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
-			object_id_t ioBoardIdentifier);
-
-	static void clear(CommandMessage* message);
-};
-
-#endif /* DEVICEHANDLERMESSAGE_H_ */
+#ifndef DEVICEHANDLERMESSAGE_H_
+#define DEVICEHANDLERMESSAGE_H_
+
+#include "../action/ActionMessage.h"
+#include "../ipc/CommandMessage.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
+
+/**
+ * This is used to uniquely identify commands that are sent to a device
+ *
+ * The values are defined in the device-specific implementations
+ */
+typedef uint32_t DeviceCommandId_t;
+
+/**
+ * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
+ */
+class DeviceHandlerMessage {
+private:
+	DeviceHandlerMessage();
+public:
+
+	/**
+	 * These are the commands that can be sent to a DeviceHandlerBase
+	 */
+	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_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
+
+	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
+	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
+	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
+
+	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
+	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
+	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
+
+	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
+	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
+	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
+	 */
+	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
+	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
+	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
+	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
+
+	/**
+	 * Default Destructor
+	 */
+	virtual ~DeviceHandlerMessage() {
+	}
+
+	static store_address_t getStoreAddress(const CommandMessage* message);
+	static uint32_t getDeviceCommandId(const CommandMessage* message);
+	static object_id_t getDeviceObjectId(const CommandMessage *message);
+	static object_id_t getIoBoardObjectId(const CommandMessage* message);
+	static uint8_t getWiretappingMode(const CommandMessage* message);
+
+//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
+//			DeviceCommandId_t deviceCommand,
+//			store_address_t commandParametersStoreId);
+
+	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
+			object_id_t deviceObjectid,
+			store_address_t commandParametersStoreId);
+
+	static void setDeviceHandlerRawCommandMessage(CommandMessage* message,
+			store_address_t rawPacketStoreId);
+
+	static void setDeviceHandlerRawReplyMessage(CommandMessage* message,
+			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
+			bool isCommand);
+
+//	static void setDeviceHandlerMessage(CommandMessage* message,
+//			Command_t command, DeviceCommandId_t deviceCommand,
+//			store_address_t commandParametersStoreId);
+//	static void setDeviceHandlerMessage(CommandMessage* message,
+//			Command_t command, store_address_t rawPacketStoreId);
+	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
+			uint8_t wiretappingMode);
+	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
+			object_id_t ioBoardIdentifier);
+
+	static void clear(CommandMessage* message);
+};
+
+#endif /* DEVICEHANDLERMESSAGE_H_ */
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index f19b02e9b..25d8932ff 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -1,46 +1,46 @@
-#include "../serialize/SerializeAdapter.h"
-#include "../devicehandlers/DeviceTmReportingWrapper.h"
-#include "../serialize/SerializeAdapter.h"
-
-DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId,
-		ActionId_t actionId, SerializeIF* data) :
-		objectId(objectId), actionId(actionId), data(data) {
-}
-
-DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
-
-}
-
-ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
-			buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&actionId, buffer,
-			size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return data->serialize(buffer, size, maxSize, streamEndianness);
-}
-
-size_t DeviceTmReportingWrapper::getSerializedSize() const {
-	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
-}
-
-ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
-			buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::deSerialize(&actionId, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return data->deSerialize(buffer, size, streamEndianness);
-}
+#include "../serialize/SerializeAdapter.h"
+#include "../devicehandlers/DeviceTmReportingWrapper.h"
+#include "../serialize/SerializeAdapter.h"
+
+DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId,
+		ActionId_t actionId, SerializeIF* data) :
+		objectId(objectId), actionId(actionId), data(data) {
+}
+
+DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
+
+}
+
+ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
+			buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&actionId, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return data->serialize(buffer, size, maxSize, streamEndianness);
+}
+
+size_t DeviceTmReportingWrapper::getSerializedSize() const {
+	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
+}
+
+ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
+			buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&actionId, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return data->deSerialize(buffer, size, streamEndianness);
+}
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index ecf7089a8..a14c4261d 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -1,27 +1,27 @@
-#ifndef DEVICETMREPORTINGWRAPPER_H_
-#define DEVICETMREPORTINGWRAPPER_H_
-
-#include "../action/HasActionsIF.h"
-#include "../objectmanager/SystemObjectIF.h"
-#include "../serialize/SerializeIF.h"
-
-class DeviceTmReportingWrapper: public SerializeIF {
-public:
-	DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId,
-			SerializeIF *data);
-	virtual ~DeviceTmReportingWrapper();
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-private:
-	object_id_t objectId;
-	ActionId_t actionId;
-	SerializeIF *data;
-};
-
-#endif /* DEVICETMREPORTINGWRAPPER_H_ */
+#ifndef DEVICETMREPORTINGWRAPPER_H_
+#define DEVICETMREPORTINGWRAPPER_H_
+
+#include "../action/HasActionsIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../serialize/SerializeIF.h"
+
+class DeviceTmReportingWrapper: public SerializeIF {
+public:
+	DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId,
+			SerializeIF *data);
+	virtual ~DeviceTmReportingWrapper();
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+private:
+	object_id_t objectId;
+	ActionId_t actionId;
+	SerializeIF *data;
+};
+
+#endif /* DEVICETMREPORTINGWRAPPER_H_ */
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index de7e4d8ca..666f86bbd 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -1,59 +1,59 @@
-#include "../devicehandlers/HealthDevice.h"
-#include "../ipc/QueueFactory.h"
-
-HealthDevice::HealthDevice(object_id_t setObjectId,
-		MessageQueueId_t parentQueue) :
-		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
-				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
-}
-
-HealthDevice::~HealthDevice() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		healthHelper.handleHealthCommand(&command);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t HealthDevice::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (parentQueue != 0) {
-		return healthHelper.initialize(parentQueue);
-	} else {
-		return healthHelper.initialize();
-	}
-}
-
-MessageQueueId_t HealthDevice::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
-	healthHelper.setParentQueue(parentQueue);
-}
-
-bool HealthDevice::hasHealthChanged() {
-	bool changed;
-	HealthState currentHealth = healthHelper.getHealth();
-	changed = currentHealth != lastHealth;
-	lastHealth = currentHealth;
-	return changed;
-}
-
-ReturnValue_t HealthDevice::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-HasHealthIF::HealthState HealthDevice::getHealth() {
-	return healthHelper.getHealth();
-}
+#include "../devicehandlers/HealthDevice.h"
+#include "../ipc/QueueFactory.h"
+
+HealthDevice::HealthDevice(object_id_t setObjectId,
+		MessageQueueId_t parentQueue) :
+		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
+				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
+}
+
+HealthDevice::~HealthDevice() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		healthHelper.handleHealthCommand(&command);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t HealthDevice::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (parentQueue != 0) {
+		return healthHelper.initialize(parentQueue);
+	} else {
+		return healthHelper.initialize();
+	}
+}
+
+MessageQueueId_t HealthDevice::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
+	healthHelper.setParentQueue(parentQueue);
+}
+
+bool HealthDevice::hasHealthChanged() {
+	bool changed;
+	HealthState currentHealth = healthHelper.getHealth();
+	changed = currentHealth != lastHealth;
+	lastHealth = currentHealth;
+	return changed;
+}
+
+ReturnValue_t HealthDevice::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState HealthDevice::getHealth() {
+	return healthHelper.getHealth();
+}
diff --git a/devicehandlers/HealthDevice.h b/devicehandlers/HealthDevice.h
index fb38584ea..53b0ab097 100644
--- a/devicehandlers/HealthDevice.h
+++ b/devicehandlers/HealthDevice.h
@@ -1,40 +1,40 @@
-#ifndef HEALTHDEVICE_H_
-#define HEALTHDEVICE_H_
-
-#include "../health/HasHealthIF.h"
-#include "../health/HealthHelper.h"
-#include "../objectmanager/SystemObject.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../ipc/MessageQueueIF.h"
-
-class HealthDevice: public SystemObject,
-		public ExecutableObjectIF,
-		public HasHealthIF {
-public:
-	HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue);
-	virtual ~HealthDevice();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	ReturnValue_t initialize();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	void setParentQueue(MessageQueueId_t parentQueue);
-
-	bool hasHealthChanged();
-
-	virtual ReturnValue_t setHealth(HealthState health);
-
-	virtual HealthState getHealth();
-
-protected:
-	HealthState lastHealth;
-
-	MessageQueueId_t parentQueue;
-	MessageQueueIF* commandQueue;
-public:
-	HealthHelper healthHelper;
-};
-
-#endif /* HEALTHDEVICE_H_ */
+#ifndef HEALTHDEVICE_H_
+#define HEALTHDEVICE_H_
+
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class HealthDevice: public SystemObject,
+		public ExecutableObjectIF,
+		public HasHealthIF {
+public:
+	HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue);
+	virtual ~HealthDevice();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	ReturnValue_t initialize();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	void setParentQueue(MessageQueueId_t parentQueue);
+
+	bool hasHealthChanged();
+
+	virtual ReturnValue_t setHealth(HealthState health);
+
+	virtual HealthState getHealth();
+
+protected:
+	HealthState lastHealth;
+
+	MessageQueueId_t parentQueue;
+	MessageQueueIF* commandQueue;
+public:
+	HealthHelper healthHelper;
+};
+
+#endif /* HEALTHDEVICE_H_ */
diff --git a/fdir/ConfirmsFailuresIF.h b/fdir/ConfirmsFailuresIF.h
index 1896d24ae..6cb2c47de 100644
--- a/fdir/ConfirmsFailuresIF.h
+++ b/fdir/ConfirmsFailuresIF.h
@@ -1,20 +1,20 @@
-#ifndef FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
-#define FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-// TODO: Documentation.
-class ConfirmsFailuresIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HANDLES_FAILURES_IF;
-	static const ReturnValue_t YOUR_FAULT = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t MY_FAULT = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t CONFIRM_LATER = MAKE_RETURN_CODE(2);
-	virtual ~ConfirmsFailuresIF() {}
-	virtual MessageQueueId_t getEventReceptionQueue() = 0;
-};
-
-
-
-#endif /* FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_ */
+#ifndef FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
+#define FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+// TODO: Documentation.
+class ConfirmsFailuresIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HANDLES_FAILURES_IF;
+	static const ReturnValue_t YOUR_FAULT = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t MY_FAULT = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t CONFIRM_LATER = MAKE_RETURN_CODE(2);
+	virtual ~ConfirmsFailuresIF() {}
+	virtual MessageQueueId_t getEventReceptionQueue() = 0;
+};
+
+
+
+#endif /* FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_ */
diff --git a/fdir/EventCorrelation.cpp b/fdir/EventCorrelation.cpp
index dea6a5699..f98d22236 100644
--- a/fdir/EventCorrelation.cpp
+++ b/fdir/EventCorrelation.cpp
@@ -1,44 +1,44 @@
-#include "../fdir/EventCorrelation.h"
-
-EventCorrelation::EventCorrelation(uint32_t timeout) :
-		eventPending(false) {
-	correlationTimer.setTimeout(timeout);
-}
-
-EventCorrelation::~EventCorrelation() {
-}
-
-EventCorrelation::State EventCorrelation::doesEventCorrelate() {
-	if (correlationTimer.isBusy()) {
-		eventPending = false;
-		return CORRELATED;
-	} else {
-		if (eventPending) {
-			return ALREADY_STARTED;
-		} else {
-			eventPending = true;
-			correlationTimer.resetTimer();
-			return CORRELATION_STARTED;
-		}
-	}
-}
-
-bool EventCorrelation::isEventPending() {
-	if (eventPending) {
-		eventPending = false;
-		return true;
-	} else {
-		correlationTimer.resetTimer();
-		return false;
-	}
-}
-
-bool EventCorrelation::hasPendingEventTimedOut() {
-	if (correlationTimer.hasTimedOut()) {
-		bool temp = eventPending;
-		eventPending = false;
-		return temp;
-	} else {
-		return false;
-	}
-}
+#include "../fdir/EventCorrelation.h"
+
+EventCorrelation::EventCorrelation(uint32_t timeout) :
+		eventPending(false) {
+	correlationTimer.setTimeout(timeout);
+}
+
+EventCorrelation::~EventCorrelation() {
+}
+
+EventCorrelation::State EventCorrelation::doesEventCorrelate() {
+	if (correlationTimer.isBusy()) {
+		eventPending = false;
+		return CORRELATED;
+	} else {
+		if (eventPending) {
+			return ALREADY_STARTED;
+		} else {
+			eventPending = true;
+			correlationTimer.resetTimer();
+			return CORRELATION_STARTED;
+		}
+	}
+}
+
+bool EventCorrelation::isEventPending() {
+	if (eventPending) {
+		eventPending = false;
+		return true;
+	} else {
+		correlationTimer.resetTimer();
+		return false;
+	}
+}
+
+bool EventCorrelation::hasPendingEventTimedOut() {
+	if (correlationTimer.hasTimedOut()) {
+		bool temp = eventPending;
+		eventPending = false;
+		return temp;
+	} else {
+		return false;
+	}
+}
diff --git a/fdir/EventCorrelation.h b/fdir/EventCorrelation.h
index bbfe92c17..b8793edfb 100644
--- a/fdir/EventCorrelation.h
+++ b/fdir/EventCorrelation.h
@@ -1,23 +1,23 @@
-#ifndef FRAMEWORK_FDIR_EVENTCORRELATION_H_
-#define FRAMEWORK_FDIR_EVENTCORRELATION_H_
-
-#include "../timemanager/Countdown.h"
-
-class EventCorrelation {
-public:
-	enum State {
-		CORRELATION_STARTED,
-		CORRELATED,
-		ALREADY_STARTED
-	};
-	EventCorrelation(uint32_t timeout);
-	~EventCorrelation();
-	EventCorrelation::State doesEventCorrelate();
-	bool isEventPending();
-	bool hasPendingEventTimedOut();
-	Countdown correlationTimer;
-private:
-	bool eventPending;
-};
-
-#endif /* FRAMEWORK_FDIR_EVENTCORRELATION_H_ */
+#ifndef FRAMEWORK_FDIR_EVENTCORRELATION_H_
+#define FRAMEWORK_FDIR_EVENTCORRELATION_H_
+
+#include "../timemanager/Countdown.h"
+
+class EventCorrelation {
+public:
+	enum State {
+		CORRELATION_STARTED,
+		CORRELATED,
+		ALREADY_STARTED
+	};
+	EventCorrelation(uint32_t timeout);
+	~EventCorrelation();
+	EventCorrelation::State doesEventCorrelate();
+	bool isEventPending();
+	bool hasPendingEventTimedOut();
+	Countdown correlationTimer;
+private:
+	bool eventPending;
+};
+
+#endif /* FRAMEWORK_FDIR_EVENTCORRELATION_H_ */
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index b9994dc3e..ab462a97d 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -1,164 +1,164 @@
-#include "../events/EventManagerIF.h"
-#include "../fdir/FailureIsolationBase.h"
-#include "../health/HasHealthIF.h"
-#include "../health/HealthMessage.h"
-#include "../ipc/QueueFactory.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-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() {
-	QueueFactory::instance()->deleteMessageQueue(eventQueue);
-}
-
-ReturnValue_t FailureIsolationBase::initialize() {
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-			objects::EVENT_MANAGER);
-	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 != objects::NO_OBJECT) {
-		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		owner = objectManager->get<HasHealthIF>(ownerId);
-		if (owner == nullptr) {
-			sif::error << "FailureIsolationBase::intialize: Owner object "
-					"invalid. Make sure it implements HasHealthIF" << std::endl;
-			return ObjectManagerIF::CHILD_INIT_FAILED;
-		}
-	}
-	if (faultTreeParent != objects::NO_OBJECT) {
-		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
-				faultTreeParent);
-		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());
-	}
-	return RETURN_OK;
-}
-
-void FailureIsolationBase::checkForFailures() {
-	EventMessage event;
-	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
-			result == RETURN_OK; result = eventQueue->receiveMessage(&event)) {
-		if (event.getSender() == eventQueue->getId()) {
-			//We already got this event, because we sent it.
-			continue;
-		}
-		switch (event.getMessageId()) {
-		case EventMessage::EVENT_MESSAGE:
-			if (isFdirDisabledForSeverity(event.getSeverity())) {
-				//We do not handle events when disabled.
-				continue;
-			}
-			eventReceived(&event);
-			break;
-		case EventMessage::CONFIRMATION_REQUEST:
-			doConfirmFault(&event);
-			break;
-		case EventMessage::YOUR_FAULT:
-			eventConfirmed(&event);
-			break;
-		case EventMessage::MY_FAULT:
-			wasParentsFault(&event);
-			break;
-		default:
-			break;
-		}
-	}
-	decrementFaultCounters();
-}
-
-void FailureIsolationBase::setOwnerHealth(HasHealthIF::HealthState health) {
-	if (owner != NULL) {
-		owner->setHealth(health);
-	}
-	//else: owner has no health.
-
-}
-
-MessageQueueId_t FailureIsolationBase::getEventReceptionQueue() {
-	return eventQueue->getId();
-}
-
-ReturnValue_t FailureIsolationBase::sendConfirmationRequest(EventMessage* event,
-		MessageQueueId_t destination) {
-	event->setMessageId(EventMessage::CONFIRMATION_REQUEST);
-	if (destination != MessageQueueIF::NO_QUEUE) {
-		return eventQueue->sendMessage(destination, event);
-	} else if (faultTreeParent != objects::NO_OBJECT) {
-		return eventQueue->sendToDefault(event);
-	}
-	return RETURN_FAILED;
-}
-
-void FailureIsolationBase::eventConfirmed(EventMessage* event) {
-}
-
-void FailureIsolationBase::wasParentsFault(EventMessage* event) {
-}
-
-void FailureIsolationBase::doConfirmFault(EventMessage* event) {
-	ReturnValue_t result = confirmFault(event);
-	if (result == YOUR_FAULT) {
-		event->setMessageId(EventMessage::YOUR_FAULT);
-		eventQueue->reply(event);
-	} else if (result == MY_FAULT) {
-		event->setMessageId(EventMessage::MY_FAULT);
-		eventQueue->reply(event);
-	} else {
-
-	}
-}
-
-ReturnValue_t FailureIsolationBase::confirmFault(EventMessage* event) {
-	return YOUR_FAULT;
-}
-
-void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	//With this mechanism, all events are disabled for a certain device.
-	//That's not so good for visibility.
-	if (isFdirDisabledForSeverity(EVENT::getSeverity(event))) {
-		return;
-	}
-	EventMessage message(event, ownerId, parameter1, parameter2);
-	EventManagerIF::triggerEvent(&message, eventQueue->getId());
-	eventReceived(&message);
-}
-
-bool FailureIsolationBase::isFdirDisabledForSeverity(EventSeverity_t severity) {
-	if ((owner != NULL) && (severity != SEVERITY::INFO)) {
-		if (owner->getHealth() == HasHealthIF::EXTERNAL_CONTROL) {
-			//External control disables handling of fault messages.
-			return true;
-		}
-	}
-	return false;
-}
-
-void FailureIsolationBase::throwFdirEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	EventMessage message(event, ownerId, parameter1, parameter2);
-	EventManagerIF::triggerEvent(&message, eventQueue->getId());
-}
+#include "../events/EventManagerIF.h"
+#include "../fdir/FailureIsolationBase.h"
+#include "../health/HasHealthIF.h"
+#include "../health/HealthMessage.h"
+#include "../ipc/QueueFactory.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+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() {
+	QueueFactory::instance()->deleteMessageQueue(eventQueue);
+}
+
+ReturnValue_t FailureIsolationBase::initialize() {
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+			objects::EVENT_MANAGER);
+	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 != objects::NO_OBJECT) {
+		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		owner = objectManager->get<HasHealthIF>(ownerId);
+		if (owner == nullptr) {
+			sif::error << "FailureIsolationBase::intialize: Owner object "
+					"invalid. Make sure it implements HasHealthIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
+		}
+	}
+	if (faultTreeParent != objects::NO_OBJECT) {
+		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
+				faultTreeParent);
+		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());
+	}
+	return RETURN_OK;
+}
+
+void FailureIsolationBase::checkForFailures() {
+	EventMessage event;
+	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
+			result == RETURN_OK; result = eventQueue->receiveMessage(&event)) {
+		if (event.getSender() == eventQueue->getId()) {
+			//We already got this event, because we sent it.
+			continue;
+		}
+		switch (event.getMessageId()) {
+		case EventMessage::EVENT_MESSAGE:
+			if (isFdirDisabledForSeverity(event.getSeverity())) {
+				//We do not handle events when disabled.
+				continue;
+			}
+			eventReceived(&event);
+			break;
+		case EventMessage::CONFIRMATION_REQUEST:
+			doConfirmFault(&event);
+			break;
+		case EventMessage::YOUR_FAULT:
+			eventConfirmed(&event);
+			break;
+		case EventMessage::MY_FAULT:
+			wasParentsFault(&event);
+			break;
+		default:
+			break;
+		}
+	}
+	decrementFaultCounters();
+}
+
+void FailureIsolationBase::setOwnerHealth(HasHealthIF::HealthState health) {
+	if (owner != NULL) {
+		owner->setHealth(health);
+	}
+	//else: owner has no health.
+
+}
+
+MessageQueueId_t FailureIsolationBase::getEventReceptionQueue() {
+	return eventQueue->getId();
+}
+
+ReturnValue_t FailureIsolationBase::sendConfirmationRequest(EventMessage* event,
+		MessageQueueId_t destination) {
+	event->setMessageId(EventMessage::CONFIRMATION_REQUEST);
+	if (destination != MessageQueueIF::NO_QUEUE) {
+		return eventQueue->sendMessage(destination, event);
+	} else if (faultTreeParent != objects::NO_OBJECT) {
+		return eventQueue->sendToDefault(event);
+	}
+	return RETURN_FAILED;
+}
+
+void FailureIsolationBase::eventConfirmed(EventMessage* event) {
+}
+
+void FailureIsolationBase::wasParentsFault(EventMessage* event) {
+}
+
+void FailureIsolationBase::doConfirmFault(EventMessage* event) {
+	ReturnValue_t result = confirmFault(event);
+	if (result == YOUR_FAULT) {
+		event->setMessageId(EventMessage::YOUR_FAULT);
+		eventQueue->reply(event);
+	} else if (result == MY_FAULT) {
+		event->setMessageId(EventMessage::MY_FAULT);
+		eventQueue->reply(event);
+	} else {
+
+	}
+}
+
+ReturnValue_t FailureIsolationBase::confirmFault(EventMessage* event) {
+	return YOUR_FAULT;
+}
+
+void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	//With this mechanism, all events are disabled for a certain device.
+	//That's not so good for visibility.
+	if (isFdirDisabledForSeverity(EVENT::getSeverity(event))) {
+		return;
+	}
+	EventMessage message(event, ownerId, parameter1, parameter2);
+	EventManagerIF::triggerEvent(&message, eventQueue->getId());
+	eventReceived(&message);
+}
+
+bool FailureIsolationBase::isFdirDisabledForSeverity(EventSeverity_t severity) {
+	if ((owner != NULL) && (severity != SEVERITY::INFO)) {
+		if (owner->getHealth() == HasHealthIF::EXTERNAL_CONTROL) {
+			//External control disables handling of fault messages.
+			return true;
+		}
+	}
+	return false;
+}
+
+void FailureIsolationBase::throwFdirEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	EventMessage message(event, ownerId, parameter1, parameter2);
+	EventManagerIF::triggerEvent(&message, eventQueue->getId());
+}
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index b2735e6d1..f8a307b33 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -1,56 +1,56 @@
-#ifndef FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
-#define FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
-
-#include "../events/EventMessage.h"
-#include "../fdir/ConfirmsFailuresIF.h"
-#include "../fdir/FaultCounter.h"
-#include "../health/HealthMessage.h"
-#include "../parameters/HasParametersIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueIF.h"
-
-class FailureIsolationBase: public HasReturnvaluesIF,
-		public ConfirmsFailuresIF,
-		public HasParametersIF {
-public:
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
-	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 = 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() override;
-	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);
-protected:
-	MessageQueueIF* eventQueue = nullptr;
-	object_id_t ownerId;
-	HasHealthIF* owner = nullptr;
-	object_id_t faultTreeParent;
-	uint8_t parameterDomainBase;
-	void setOwnerHealth(HasHealthIF::HealthState health);
-	virtual ReturnValue_t eventReceived(EventMessage* event) = 0;
-	virtual void eventConfirmed(EventMessage* event);
-	virtual void wasParentsFault(EventMessage* event);
-	virtual ReturnValue_t confirmFault(EventMessage* event);
-	virtual void decrementFaultCounters() = 0;
-	ReturnValue_t sendConfirmationRequest(EventMessage* event,
-			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
-	void throwFdirEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);
-private:
-	void doConfirmFault(EventMessage* event);bool isFdirDisabledForSeverity(
-			EventSeverity_t severity);
-};
-
-#endif /* FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_ */
+#ifndef FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
+#define FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
+
+#include "../events/EventMessage.h"
+#include "../fdir/ConfirmsFailuresIF.h"
+#include "../fdir/FaultCounter.h"
+#include "../health/HealthMessage.h"
+#include "../parameters/HasParametersIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class FailureIsolationBase: public HasReturnvaluesIF,
+		public ConfirmsFailuresIF,
+		public HasParametersIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
+	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 = 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() override;
+	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
+protected:
+	MessageQueueIF* eventQueue = nullptr;
+	object_id_t ownerId;
+	HasHealthIF* owner = nullptr;
+	object_id_t faultTreeParent;
+	uint8_t parameterDomainBase;
+	void setOwnerHealth(HasHealthIF::HealthState health);
+	virtual ReturnValue_t eventReceived(EventMessage* event) = 0;
+	virtual void eventConfirmed(EventMessage* event);
+	virtual void wasParentsFault(EventMessage* event);
+	virtual ReturnValue_t confirmFault(EventMessage* event);
+	virtual void decrementFaultCounters() = 0;
+	ReturnValue_t sendConfirmationRequest(EventMessage* event,
+			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
+	void throwFdirEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
+private:
+	void doConfirmFault(EventMessage* event);bool isFdirDisabledForSeverity(
+			EventSeverity_t severity);
+};
+
+#endif /* FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_ */
diff --git a/fdir/FaultCounter.cpp b/fdir/FaultCounter.cpp
index 674d278a9..b75bd48fd 100644
--- a/fdir/FaultCounter.cpp
+++ b/fdir/FaultCounter.cpp
@@ -1,86 +1,86 @@
-#include "../fdir/FaultCounter.h"
-
-FaultCounter::FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
-		uint8_t setParameterDomain) :
-		parameterDomain(setParameterDomain), timer(), faultCount(0), failureThreshold(
-				failureThreshold) {
-	timer.setTimeout(decrementAfterMs);
-}
-
-FaultCounter::~FaultCounter() {
-}
-
-void FaultCounter::increment(uint32_t amount) {
-	if (faultCount == 0) {
-		timer.resetTimer();
-	}
-	faultCount += amount;
-}
-
-bool FaultCounter::checkForDecrement() {
-	if (timer.hasTimedOut()) {
-		timer.resetTimer();
-		if (faultCount > 0) {
-			faultCount--;
-			return true;
-		}
-	}
-	return false;
-}
-
-bool FaultCounter::incrementAndCheck(uint32_t amount) {
-	increment(amount);
-	return aboveThreshold();
-}
-
-bool FaultCounter::aboveThreshold() {
-	if (faultCount > failureThreshold) {
-		faultCount = 0;
-		return true;
-	} else {
-		return false;
-	}
-}
-
-void FaultCounter::clear() {
-	faultCount = 0;
-}
-
-void FaultCounter::setFailureThreshold(uint32_t failureThreshold) {
-	this->failureThreshold = failureThreshold;
-}
-
-void FaultCounter::setFaultDecrementTimeMs(uint32_t timeMs) {
-	timer.setTimeout(timeMs);
-}
-
-FaultCounter::FaultCounter() :
-		parameterDomain(0), timer(), faultCount(0), failureThreshold(0) {
-}
-
-ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	if (domainId != parameterDomain) {
-		return INVALID_DOMAIN_ID;
-	}
-
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set(failureThreshold);
-		break;
-	case 1:
-		parameterWrapper->set(faultCount);
-		break;
-	case 2:
-		parameterWrapper->set(timer.timeout);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void FaultCounter::setParameterDomain(uint8_t domain) {
-	parameterDomain = domain;
-}
+#include "../fdir/FaultCounter.h"
+
+FaultCounter::FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
+		uint8_t setParameterDomain) :
+		parameterDomain(setParameterDomain), timer(), faultCount(0), failureThreshold(
+				failureThreshold) {
+	timer.setTimeout(decrementAfterMs);
+}
+
+FaultCounter::~FaultCounter() {
+}
+
+void FaultCounter::increment(uint32_t amount) {
+	if (faultCount == 0) {
+		timer.resetTimer();
+	}
+	faultCount += amount;
+}
+
+bool FaultCounter::checkForDecrement() {
+	if (timer.hasTimedOut()) {
+		timer.resetTimer();
+		if (faultCount > 0) {
+			faultCount--;
+			return true;
+		}
+	}
+	return false;
+}
+
+bool FaultCounter::incrementAndCheck(uint32_t amount) {
+	increment(amount);
+	return aboveThreshold();
+}
+
+bool FaultCounter::aboveThreshold() {
+	if (faultCount > failureThreshold) {
+		faultCount = 0;
+		return true;
+	} else {
+		return false;
+	}
+}
+
+void FaultCounter::clear() {
+	faultCount = 0;
+}
+
+void FaultCounter::setFailureThreshold(uint32_t failureThreshold) {
+	this->failureThreshold = failureThreshold;
+}
+
+void FaultCounter::setFaultDecrementTimeMs(uint32_t timeMs) {
+	timer.setTimeout(timeMs);
+}
+
+FaultCounter::FaultCounter() :
+		parameterDomain(0), timer(), faultCount(0), failureThreshold(0) {
+}
+
+ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	if (domainId != parameterDomain) {
+		return INVALID_DOMAIN_ID;
+	}
+
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set(failureThreshold);
+		break;
+	case 1:
+		parameterWrapper->set(faultCount);
+		break;
+	case 2:
+		parameterWrapper->set(timer.timeout);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FaultCounter::setParameterDomain(uint8_t domain) {
+	parameterDomain = domain;
+}
diff --git a/fdir/FaultCounter.h b/fdir/FaultCounter.h
index 17e2a3dfe..dc929debd 100644
--- a/fdir/FaultCounter.h
+++ b/fdir/FaultCounter.h
@@ -1,38 +1,38 @@
-#ifndef FRAMEWORK_FDIR_FAULTCOUNTER_H_
-#define FRAMEWORK_FDIR_FAULTCOUNTER_H_
-
-#include "../parameters/HasParametersIF.h"
-#include "../timemanager/Countdown.h"
-
-class FaultCounter: public HasParametersIF {
-public:
-	FaultCounter();
-	FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
-			uint8_t setParameterDomain = 0);
-	virtual ~FaultCounter();
-
-	bool incrementAndCheck(uint32_t amount = 1);
-
-	void increment(uint32_t amount = 1);
-
-	bool checkForDecrement();
-
-	bool aboveThreshold();
-
-	void clear();
-	void setFailureThreshold(uint32_t failureThreshold);
-	void setFaultDecrementTimeMs(uint32_t timeMs);
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-	void setParameterDomain(uint8_t domain);
-private:
-	uint8_t parameterDomain;
-	Countdown timer;
-	uint32_t faultCount;
-	uint32_t failureThreshold;
-};
-
-#endif /* FRAMEWORK_FDIR_FAULTCOUNTER_H_ */
+#ifndef FRAMEWORK_FDIR_FAULTCOUNTER_H_
+#define FRAMEWORK_FDIR_FAULTCOUNTER_H_
+
+#include "../parameters/HasParametersIF.h"
+#include "../timemanager/Countdown.h"
+
+class FaultCounter: public HasParametersIF {
+public:
+	FaultCounter();
+	FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
+			uint8_t setParameterDomain = 0);
+	virtual ~FaultCounter();
+
+	bool incrementAndCheck(uint32_t amount = 1);
+
+	void increment(uint32_t amount = 1);
+
+	bool checkForDecrement();
+
+	bool aboveThreshold();
+
+	void clear();
+	void setFailureThreshold(uint32_t failureThreshold);
+	void setFaultDecrementTimeMs(uint32_t timeMs);
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+	void setParameterDomain(uint8_t domain);
+private:
+	uint8_t parameterDomain;
+	Countdown timer;
+	uint32_t faultCount;
+	uint32_t failureThreshold;
+};
+
+#endif /* FRAMEWORK_FDIR_FAULTCOUNTER_H_ */
diff --git a/globalfunctions/AsciiConverter.cpp b/globalfunctions/AsciiConverter.cpp
index f54af6a88..c57125e26 100644
--- a/globalfunctions/AsciiConverter.cpp
+++ b/globalfunctions/AsciiConverter.cpp
@@ -1,230 +1,230 @@
-#include "../globalfunctions/AsciiConverter.h"
-#include <limits>
-#include <cmath>
-
-template<typename T>
-ReturnValue_t AsciiConverter::scanAsciiDecimalNumber(const uint8_t** dataPtr,
-		uint8_t len, T* value) {
-	if (len > std::numeric_limits<T>().digits10) {
-		return TOO_LONG_FOR_TARGET_TYPE;
-	}
-
-	double temp;
-
-	ReturnValue_t result = scanAsciiDecimalNumber_(dataPtr, len, &temp);
-
-	*value = temp;
-
-	return result;
-}
-
-ReturnValue_t AsciiConverter::scanAsciiHexByte(const uint8_t** dataPtr,
-		uint8_t* value) {
-	int8_t tmp;
-
-	tmp = convertHexChar(*dataPtr);
-	(*dataPtr)++;
-	if (tmp == -1) {
-		return INVALID_CHARACTERS;
-	}
-	if (tmp == -2) {
-		tmp = 0;
-	}
-
-	*value = tmp << 4;
-
-	tmp = convertHexChar(*dataPtr);
-	(*dataPtr)++;
-	if (tmp == -1) {
-		return INVALID_CHARACTERS;
-	}
-	if (tmp != -2) {
-		*value += tmp;
-	} else {
-		*value = *value >> 4;
-	}
-
-	return RETURN_OK;
-}
-
-ReturnValue_t AsciiConverter::scanAsciiDecimalNumber_(uint8_t const ** dataPtr,
-		uint8_t len, double* value) {
-
-	uint8_t const *ptr = *dataPtr;
-	int8_t sign = 1;
-	float decimal = 0;
-	bool abort = false;
-
-	*value = 0;
-
-	//ignore leading space
-	ptr = clearSpace(ptr, len);
-
-	while ((ptr - *dataPtr < len) && !abort) {
-		switch (*ptr) {
-		case '+':
-			sign = 1;
-			break;
-		case '-':
-			sign = -1;
-			break;
-		case '.':
-			decimal = 1;
-			break;
-		case ' ':
-		case 0x0d:
-		case 0x0a:
-			//ignore trailing space
-			ptr = clearSpace(ptr, len - (ptr - *dataPtr)) - 1; //before aborting the loop, ptr will be incremented
-			abort = true;
-			break;
-		default:
-			if ((*ptr < 0x30) || (*ptr > 0x39)) {
-				return INVALID_CHARACTERS;
-			}
-			*value = *value * 10 + (*ptr - 0x30);
-			if (decimal > 0) {
-				decimal *= 10;
-			}
-			break;
-		}
-		ptr++;
-	}
-
-	if (decimal == 0) {
-		decimal = 1;
-	}
-
-	*value = *value / (decimal) * sign;
-
-	*dataPtr = ptr;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t AsciiConverter::printFloat(uint8_t* buffer, uint32_t bufferLength,
-		float value, uint8_t decimalPlaces, uint32_t *printedSize) {
-	*printedSize = 0;
-	uint32_t streamposition = 0, integerSize;
-	bool negative = (value < 0);
-	int32_t digits = bufferLength - decimalPlaces - 1;
-	if (digits <= 0) {
-		return BUFFER_TOO_SMALL;
-	}
-	if (negative) {
-		digits -= 1;
-		buffer[streamposition++] = '-';
-		value = -value;
-	}
-	float maximumNumber = pow(10, digits);
-	if (value >= maximumNumber) {
-		return BUFFER_TOO_SMALL;
-	}
-	//print the numbers before the decimal point;
-	ReturnValue_t result = printInteger(buffer + streamposition,
-			bufferLength - streamposition - decimalPlaces - 1, value,
-			&integerSize);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	streamposition += integerSize;
-	//The decimal Point
-	buffer[streamposition++] = '.';
-
-	//Print the decimals
-	uint32_t integerValue = value;
-	value -= integerValue;
-	value = value * pow(10, decimalPlaces);
-	result = printInteger(buffer + streamposition, decimalPlaces, round(value),
-			&integerSize, true);
-	*printedSize = integerSize + streamposition;
-	return result;
-}
-
-ReturnValue_t AsciiConverter::printInteger(uint8_t* buffer,
-		uint32_t bufferLength, uint32_t value, uint32_t *printedSize,
-		bool leadingZeros) {
-	*printedSize = 0;
-	if (bufferLength == 0) {
-		return BUFFER_TOO_SMALL;
-	}
-	uint32_t maximumNumber = -1;
-	if (bufferLength < 10) {
-		maximumNumber = pow(10, bufferLength);
-		if (value >= maximumNumber) {
-			return BUFFER_TOO_SMALL;
-		}
-		maximumNumber /= 10;
-	} else {
-		if (!(value <= maximumNumber)) {
-			return BUFFER_TOO_SMALL;
-		}
-		maximumNumber = 1000000000;
-	}
-	if (!leadingZeros && (value == 0)) {
-		buffer[(*printedSize)++] = '0';
-		return RETURN_OK;
-	}
-	while (maximumNumber >= 1) {
-		uint8_t number = value / maximumNumber;
-		value = value - (number * maximumNumber);
-		if (!leadingZeros && number == 0) {
-			maximumNumber /= 10;
-		} else {
-			leadingZeros = true;
-			buffer[(*printedSize)++] = '0' + number;
-			maximumNumber /= 10;
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t AsciiConverter::printSignedInteger(uint8_t* buffer,
-		uint32_t bufferLength, int32_t value, uint32_t *printedSize) {
-	bool negative = false;
-	if ((bufferLength > 0) && (value < 0)) {
-		*buffer++ = '-';
-		bufferLength--;
-		value = -value;
-		negative = true;
-	}
-	ReturnValue_t result = printInteger(buffer, bufferLength, value,
-			printedSize);
-	if (negative) {
-		(*printedSize)++;
-	}
-	return result;
-}
-
-int8_t AsciiConverter::convertHexChar(const uint8_t* character) {
-	if ((*character > 0x60) && (*character < 0x67)) {
-		return *character - 0x61 + 10;
-	} else if ((*character > 0x40) && (*character < 0x47)) {
-		return *character - 0x41 + 10;
-	} else if ((*character > 0x2F) && (*character < 0x3A)) {
-		return *character - 0x30;
-	} else if (*character == ' ') {
-		return -2;
-	}
-	return -1;
-}
-
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<float>(
-		const uint8_t** dataPtr, uint8_t len, float* value);
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint8_t>(
-		const uint8_t** dataPtr, uint8_t len, uint8_t* value);
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint16_t>(
-		const uint8_t** dataPtr, uint8_t len, uint16_t* value);
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<double>(
-		const uint8_t** dataPtr, uint8_t len, double* value);
-
-const uint8_t* AsciiConverter::clearSpace(const uint8_t* data, uint8_t len) {
-	while (len > 0) {
-		if ((*data != ' ') && (*data != 0x0a) && (*data != 0x0d)) {
-			return data;
-		}
-		data++;
-		len--;
-	}
-	return data;
-}
+#include "../globalfunctions/AsciiConverter.h"
+#include <limits>
+#include <cmath>
+
+template<typename T>
+ReturnValue_t AsciiConverter::scanAsciiDecimalNumber(const uint8_t** dataPtr,
+		uint8_t len, T* value) {
+	if (len > std::numeric_limits<T>().digits10) {
+		return TOO_LONG_FOR_TARGET_TYPE;
+	}
+
+	double temp;
+
+	ReturnValue_t result = scanAsciiDecimalNumber_(dataPtr, len, &temp);
+
+	*value = temp;
+
+	return result;
+}
+
+ReturnValue_t AsciiConverter::scanAsciiHexByte(const uint8_t** dataPtr,
+		uint8_t* value) {
+	int8_t tmp;
+
+	tmp = convertHexChar(*dataPtr);
+	(*dataPtr)++;
+	if (tmp == -1) {
+		return INVALID_CHARACTERS;
+	}
+	if (tmp == -2) {
+		tmp = 0;
+	}
+
+	*value = tmp << 4;
+
+	tmp = convertHexChar(*dataPtr);
+	(*dataPtr)++;
+	if (tmp == -1) {
+		return INVALID_CHARACTERS;
+	}
+	if (tmp != -2) {
+		*value += tmp;
+	} else {
+		*value = *value >> 4;
+	}
+
+	return RETURN_OK;
+}
+
+ReturnValue_t AsciiConverter::scanAsciiDecimalNumber_(uint8_t const ** dataPtr,
+		uint8_t len, double* value) {
+
+	uint8_t const *ptr = *dataPtr;
+	int8_t sign = 1;
+	float decimal = 0;
+	bool abort = false;
+
+	*value = 0;
+
+	//ignore leading space
+	ptr = clearSpace(ptr, len);
+
+	while ((ptr - *dataPtr < len) && !abort) {
+		switch (*ptr) {
+		case '+':
+			sign = 1;
+			break;
+		case '-':
+			sign = -1;
+			break;
+		case '.':
+			decimal = 1;
+			break;
+		case ' ':
+		case 0x0d:
+		case 0x0a:
+			//ignore trailing space
+			ptr = clearSpace(ptr, len - (ptr - *dataPtr)) - 1; //before aborting the loop, ptr will be incremented
+			abort = true;
+			break;
+		default:
+			if ((*ptr < 0x30) || (*ptr > 0x39)) {
+				return INVALID_CHARACTERS;
+			}
+			*value = *value * 10 + (*ptr - 0x30);
+			if (decimal > 0) {
+				decimal *= 10;
+			}
+			break;
+		}
+		ptr++;
+	}
+
+	if (decimal == 0) {
+		decimal = 1;
+	}
+
+	*value = *value / (decimal) * sign;
+
+	*dataPtr = ptr;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t AsciiConverter::printFloat(uint8_t* buffer, uint32_t bufferLength,
+		float value, uint8_t decimalPlaces, uint32_t *printedSize) {
+	*printedSize = 0;
+	uint32_t streamposition = 0, integerSize;
+	bool negative = (value < 0);
+	int32_t digits = bufferLength - decimalPlaces - 1;
+	if (digits <= 0) {
+		return BUFFER_TOO_SMALL;
+	}
+	if (negative) {
+		digits -= 1;
+		buffer[streamposition++] = '-';
+		value = -value;
+	}
+	float maximumNumber = pow(10, digits);
+	if (value >= maximumNumber) {
+		return BUFFER_TOO_SMALL;
+	}
+	//print the numbers before the decimal point;
+	ReturnValue_t result = printInteger(buffer + streamposition,
+			bufferLength - streamposition - decimalPlaces - 1, value,
+			&integerSize);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	streamposition += integerSize;
+	//The decimal Point
+	buffer[streamposition++] = '.';
+
+	//Print the decimals
+	uint32_t integerValue = value;
+	value -= integerValue;
+	value = value * pow(10, decimalPlaces);
+	result = printInteger(buffer + streamposition, decimalPlaces, round(value),
+			&integerSize, true);
+	*printedSize = integerSize + streamposition;
+	return result;
+}
+
+ReturnValue_t AsciiConverter::printInteger(uint8_t* buffer,
+		uint32_t bufferLength, uint32_t value, uint32_t *printedSize,
+		bool leadingZeros) {
+	*printedSize = 0;
+	if (bufferLength == 0) {
+		return BUFFER_TOO_SMALL;
+	}
+	uint32_t maximumNumber = -1;
+	if (bufferLength < 10) {
+		maximumNumber = pow(10, bufferLength);
+		if (value >= maximumNumber) {
+			return BUFFER_TOO_SMALL;
+		}
+		maximumNumber /= 10;
+	} else {
+		if (!(value <= maximumNumber)) {
+			return BUFFER_TOO_SMALL;
+		}
+		maximumNumber = 1000000000;
+	}
+	if (!leadingZeros && (value == 0)) {
+		buffer[(*printedSize)++] = '0';
+		return RETURN_OK;
+	}
+	while (maximumNumber >= 1) {
+		uint8_t number = value / maximumNumber;
+		value = value - (number * maximumNumber);
+		if (!leadingZeros && number == 0) {
+			maximumNumber /= 10;
+		} else {
+			leadingZeros = true;
+			buffer[(*printedSize)++] = '0' + number;
+			maximumNumber /= 10;
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t AsciiConverter::printSignedInteger(uint8_t* buffer,
+		uint32_t bufferLength, int32_t value, uint32_t *printedSize) {
+	bool negative = false;
+	if ((bufferLength > 0) && (value < 0)) {
+		*buffer++ = '-';
+		bufferLength--;
+		value = -value;
+		negative = true;
+	}
+	ReturnValue_t result = printInteger(buffer, bufferLength, value,
+			printedSize);
+	if (negative) {
+		(*printedSize)++;
+	}
+	return result;
+}
+
+int8_t AsciiConverter::convertHexChar(const uint8_t* character) {
+	if ((*character > 0x60) && (*character < 0x67)) {
+		return *character - 0x61 + 10;
+	} else if ((*character > 0x40) && (*character < 0x47)) {
+		return *character - 0x41 + 10;
+	} else if ((*character > 0x2F) && (*character < 0x3A)) {
+		return *character - 0x30;
+	} else if (*character == ' ') {
+		return -2;
+	}
+	return -1;
+}
+
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<float>(
+		const uint8_t** dataPtr, uint8_t len, float* value);
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint8_t>(
+		const uint8_t** dataPtr, uint8_t len, uint8_t* value);
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint16_t>(
+		const uint8_t** dataPtr, uint8_t len, uint16_t* value);
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<double>(
+		const uint8_t** dataPtr, uint8_t len, double* value);
+
+const uint8_t* AsciiConverter::clearSpace(const uint8_t* data, uint8_t len) {
+	while (len > 0) {
+		if ((*data != ' ') && (*data != 0x0a) && (*data != 0x0d)) {
+			return data;
+		}
+		data++;
+		len--;
+	}
+	return data;
+}
diff --git a/globalfunctions/AsciiConverter.h b/globalfunctions/AsciiConverter.h
index 27bed4e75..7af3cb3d4 100644
--- a/globalfunctions/AsciiConverter.h
+++ b/globalfunctions/AsciiConverter.h
@@ -1,39 +1,39 @@
-#ifndef ASCIICONVERTER_H_
-#define ASCIICONVERTER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-class AsciiConverter: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ASCII_CONVERTER;
-	static const ReturnValue_t TOO_LONG_FOR_TARGET_TYPE = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_CHARACTERS = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t BUFFER_TOO_SMALL = MAKE_RETURN_CODE(0x3);
-
-	template<typename T>
-	static ReturnValue_t scanAsciiDecimalNumber(const uint8_t **dataPtr,
-			uint8_t len, T *value);
-
-	static ReturnValue_t scanAsciiHexByte(const uint8_t **dataPtr,
-			uint8_t *value);
-
-	static ReturnValue_t printFloat(uint8_t *buffer, uint32_t bufferLength,
-			float value, uint8_t decimalPlaces, uint32_t *printedSize);
-
-	static ReturnValue_t printInteger(uint8_t *buffer, uint32_t bufferLength,
-			uint32_t value, uint32_t *printedSize, bool leadingZeros = false);
-
-	static ReturnValue_t printSignedInteger(uint8_t *buffer,
-			uint32_t bufferLength, int32_t value, uint32_t *printedSize);
-
-private:
-	AsciiConverter();
-	static ReturnValue_t scanAsciiDecimalNumber_(const uint8_t **dataPtr,
-			uint8_t len, double *value);
-
-	static int8_t convertHexChar(const uint8_t *character);
-
-	static const uint8_t *clearSpace(const uint8_t *data, uint8_t len);
-};
-
-#endif /* ASCIICONVERTER_H_ */
+#ifndef ASCIICONVERTER_H_
+#define ASCIICONVERTER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class AsciiConverter: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ASCII_CONVERTER;
+	static const ReturnValue_t TOO_LONG_FOR_TARGET_TYPE = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID_CHARACTERS = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t BUFFER_TOO_SMALL = MAKE_RETURN_CODE(0x3);
+
+	template<typename T>
+	static ReturnValue_t scanAsciiDecimalNumber(const uint8_t **dataPtr,
+			uint8_t len, T *value);
+
+	static ReturnValue_t scanAsciiHexByte(const uint8_t **dataPtr,
+			uint8_t *value);
+
+	static ReturnValue_t printFloat(uint8_t *buffer, uint32_t bufferLength,
+			float value, uint8_t decimalPlaces, uint32_t *printedSize);
+
+	static ReturnValue_t printInteger(uint8_t *buffer, uint32_t bufferLength,
+			uint32_t value, uint32_t *printedSize, bool leadingZeros = false);
+
+	static ReturnValue_t printSignedInteger(uint8_t *buffer,
+			uint32_t bufferLength, int32_t value, uint32_t *printedSize);
+
+private:
+	AsciiConverter();
+	static ReturnValue_t scanAsciiDecimalNumber_(const uint8_t **dataPtr,
+			uint8_t len, double *value);
+
+	static int8_t convertHexChar(const uint8_t *character);
+
+	static const uint8_t *clearSpace(const uint8_t *data, uint8_t len);
+};
+
+#endif /* ASCIICONVERTER_H_ */
diff --git a/globalfunctions/CRC.cpp b/globalfunctions/CRC.cpp
index 6156b558f..1258b6989 100644
--- a/globalfunctions/CRC.cpp
+++ b/globalfunctions/CRC.cpp
@@ -1,139 +1,139 @@
-#include "../globalfunctions/CRC.h"
-#include <math.h>
-
-const uint16_t CRC::crc16ccitt_table[256] = {
-    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
-    0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
-    0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
-    0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
-    0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
-    0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
-    0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
-    0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
-    0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
-    0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
-    0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
-    0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
-    0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
-    0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
-    0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
-    0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
-    0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
-    0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
-    0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
-    0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
-    0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
-    0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
-    0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
-    0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
-    0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
-    0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
-    0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
-    0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
-    0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
-    0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
-    0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
-    0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
-};
-
-
-// CRC implementation
-uint16_t CRC::crc16ccitt(uint8_t const input[], uint32_t length, uint16_t startingCrc)
-{
-	uint8_t *data = (uint8_t *)input;
-	unsigned int tbl_idx;
-
-    while (length--) {
-        tbl_idx = ((startingCrc >> 8) ^ *data) & 0xff;
-        startingCrc = (crc16ccitt_table[tbl_idx] ^ (startingCrc << 8)) & 0xffff;
-
-        data++;
-    }
-    return startingCrc & 0xffff;
-
-    //The part below is not used!
-//	bool temr[16];
-//	bool xor_out[16];
-//	bool r[16];
-//	bool d[8];
-//	uint16_t crc_value = 0;
-//
-//
-//	for (int i=0; i<16 ;i++) {
-//		temr[i] = false;
-//		xor_out[i] = false;
-//	}
-//
-//
-//	for (int i=0; i<16 ;i++)
-//			r[i] = true;    // initialize with 0xFFFF
-//
-//
-//
-//	for (int j=0; j<length ;j++)
-//	{
-//
-//	for (int i=0; i<8 ;i++)
-//		if ((input[j] & 1<<i) == 1<<i)
-//			d[7-i]=true;			// reverse   input data
-//		else
-//			d[7-i]=false;			// reverse input data
-//
-//
-//
-//		  temr[0] = d[4] ^ d[0];
-//		  temr[1] = d[5] ^ d[1];
-//		  temr[2] = d[6] ^ d[2];
-//		  temr[3] = d[7] ^ d[3];
-//		  temr[4] = r[12] ^ r[8];
-//		  temr[5] = r[13] ^ r[9];
-//		  temr[6] = r[14] ^ r[10];
-//		  temr[7] = r[15] ^ r[11];
-//		  temr[8] = d[4] ^ r[12];
-//		  temr[9] = d[5] ^ r[13];
-//		  temr[10] = d[6] ^ r[14];
-//		  temr[11] = d[7] ^ r[15];
-//		  temr[12] = temr[0] ^ temr[4];
-//		  temr[13] = temr[1] ^ temr[5];
-//		  temr[14] = temr[2] ^ temr[6];
-//		  temr[15] = temr[3] ^ temr[7];
-//
-//
-//		  xor_out[0] = temr[12];
-//		  xor_out[1] = temr[13];
-//		  xor_out[2] = temr[14];
-//		  xor_out[3] = temr[15];
-//		  xor_out[4] = temr[8];
-//		  xor_out[5] = temr[9] ^ temr[12];
-//		  xor_out[6] = temr[10] ^ temr[13];
-//		  xor_out[7] = temr[11] ^ temr[14];
-//		  xor_out[8] = temr[15] ^ r[0];
-//		  xor_out[9] = temr[8] ^ r[1];
-//		  xor_out[10] = temr[9] ^ r[2];
-//		  xor_out[11] = temr[10] ^ r[3];
-//		  xor_out[12] = temr[11] ^ temr[12] ^ r[4];
-//		  xor_out[13] = temr[13] ^ r[5];
-//		  xor_out[14] = temr[14] ^ r[6];
-//		  xor_out[15] = temr[15] ^ r[7];
-//
-//	 for (int i=0; i<16 ;i++)
-//	 {
-//		  r[i]= xor_out[i] ;
-//	 }
-//
-//	}
-//
-//
-//
-//	for (int i=0; i<16 ;i++)
-//	{
-//		 if  (xor_out[i] == true)
-//			 crc_value = crc_value + pow(2,(15 -i));   // reverse CrC result before Final XOR
-//	}
-//
-//	crc_value = 0;// for debug mode
-//	return (crc_value);
-
-}   /* Calculate_CRC() */
-
-
+#include "../globalfunctions/CRC.h"
+#include <math.h>
+
+const uint16_t CRC::crc16ccitt_table[256] = {
+    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
+    0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
+    0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
+    0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
+    0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
+    0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
+    0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
+    0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
+    0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
+    0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
+    0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
+    0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
+    0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
+    0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
+    0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
+    0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
+    0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
+    0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
+    0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
+    0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
+    0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
+    0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+    0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
+    0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
+    0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
+    0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
+    0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
+    0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
+    0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
+    0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
+    0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
+    0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
+};
+
+
+// CRC implementation
+uint16_t CRC::crc16ccitt(uint8_t const input[], uint32_t length, uint16_t startingCrc)
+{
+	uint8_t *data = (uint8_t *)input;
+	unsigned int tbl_idx;
+
+    while (length--) {
+        tbl_idx = ((startingCrc >> 8) ^ *data) & 0xff;
+        startingCrc = (crc16ccitt_table[tbl_idx] ^ (startingCrc << 8)) & 0xffff;
+
+        data++;
+    }
+    return startingCrc & 0xffff;
+
+    //The part below is not used!
+//	bool temr[16];
+//	bool xor_out[16];
+//	bool r[16];
+//	bool d[8];
+//	uint16_t crc_value = 0;
+//
+//
+//	for (int i=0; i<16 ;i++) {
+//		temr[i] = false;
+//		xor_out[i] = false;
+//	}
+//
+//
+//	for (int i=0; i<16 ;i++)
+//			r[i] = true;    // initialize with 0xFFFF
+//
+//
+//
+//	for (int j=0; j<length ;j++)
+//	{
+//
+//	for (int i=0; i<8 ;i++)
+//		if ((input[j] & 1<<i) == 1<<i)
+//			d[7-i]=true;			// reverse   input data
+//		else
+//			d[7-i]=false;			// reverse input data
+//
+//
+//
+//		  temr[0] = d[4] ^ d[0];
+//		  temr[1] = d[5] ^ d[1];
+//		  temr[2] = d[6] ^ d[2];
+//		  temr[3] = d[7] ^ d[3];
+//		  temr[4] = r[12] ^ r[8];
+//		  temr[5] = r[13] ^ r[9];
+//		  temr[6] = r[14] ^ r[10];
+//		  temr[7] = r[15] ^ r[11];
+//		  temr[8] = d[4] ^ r[12];
+//		  temr[9] = d[5] ^ r[13];
+//		  temr[10] = d[6] ^ r[14];
+//		  temr[11] = d[7] ^ r[15];
+//		  temr[12] = temr[0] ^ temr[4];
+//		  temr[13] = temr[1] ^ temr[5];
+//		  temr[14] = temr[2] ^ temr[6];
+//		  temr[15] = temr[3] ^ temr[7];
+//
+//
+//		  xor_out[0] = temr[12];
+//		  xor_out[1] = temr[13];
+//		  xor_out[2] = temr[14];
+//		  xor_out[3] = temr[15];
+//		  xor_out[4] = temr[8];
+//		  xor_out[5] = temr[9] ^ temr[12];
+//		  xor_out[6] = temr[10] ^ temr[13];
+//		  xor_out[7] = temr[11] ^ temr[14];
+//		  xor_out[8] = temr[15] ^ r[0];
+//		  xor_out[9] = temr[8] ^ r[1];
+//		  xor_out[10] = temr[9] ^ r[2];
+//		  xor_out[11] = temr[10] ^ r[3];
+//		  xor_out[12] = temr[11] ^ temr[12] ^ r[4];
+//		  xor_out[13] = temr[13] ^ r[5];
+//		  xor_out[14] = temr[14] ^ r[6];
+//		  xor_out[15] = temr[15] ^ r[7];
+//
+//	 for (int i=0; i<16 ;i++)
+//	 {
+//		  r[i]= xor_out[i] ;
+//	 }
+//
+//	}
+//
+//
+//
+//	for (int i=0; i<16 ;i++)
+//	{
+//		 if  (xor_out[i] == true)
+//			 crc_value = crc_value + pow(2,(15 -i));   // reverse CrC result before Final XOR
+//	}
+//
+//	crc_value = 0;// for debug mode
+//	return (crc_value);
+
+}   /* Calculate_CRC() */
+
+
diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index 21dbd2e62..6bd402d7e 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -1,124 +1,124 @@
-#include "../globalfunctions/DleEncoder.h"
-
-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,
-		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_CHAR) {
-		return DECODING_ERROR;
-	}
-	++encodedIndex;
-
-	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
-			&& (sourceStream[encodedIndex] != ETX_CHAR)
-			&& (sourceStream[encodedIndex] != STX_CHAR)) {
-		if (sourceStream[encodedIndex] == DLE_CHAR) {
-			nextByte = sourceStream[encodedIndex + 1];
-			// 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 {
-			    /* 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 preven 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 DECODING_ERROR;
-				}
-			}
-			++encodedIndex;
-		}
-		else {
-			destStream[decodedIndex] = sourceStream[encodedIndex];
-		}
-
-		++encodedIndex;
-		++decodedIndex;
-	}
-
-	if (sourceStream[encodedIndex] != ETX_CHAR) {
-		*readLen = ++encodedIndex;
-		return DECODING_ERROR;
-	}
-	else {
-		*readLen = ++encodedIndex;
-		*decodedLen = decodedIndex;
-		return RETURN_OK;
-	}
-}
-
+#include "../globalfunctions/DleEncoder.h"
+
+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,
+		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_CHAR) {
+		return DECODING_ERROR;
+	}
+	++encodedIndex;
+
+	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
+			&& (sourceStream[encodedIndex] != ETX_CHAR)
+			&& (sourceStream[encodedIndex] != STX_CHAR)) {
+		if (sourceStream[encodedIndex] == DLE_CHAR) {
+			nextByte = sourceStream[encodedIndex + 1];
+			// 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 {
+			    /* 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 preven 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 DECODING_ERROR;
+				}
+			}
+			++encodedIndex;
+		}
+		else {
+			destStream[decodedIndex] = sourceStream[encodedIndex];
+		}
+
+		++encodedIndex;
+		++decodedIndex;
+	}
+
+	if (sourceStream[encodedIndex] != ETX_CHAR) {
+		*readLen = ++encodedIndex;
+		return DECODING_ERROR;
+	}
+	else {
+		*readLen = ++encodedIndex;
+		*decodedLen = decodedIndex;
+		return RETURN_OK;
+	}
+}
+
diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index 3c327a555..3c535d1f3 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -1,79 +1,79 @@
-#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 occurences 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 enoded 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 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 occurences
-	//! 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 decoing 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,
-			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
-			size_t maxDestStreamlen, size_t *decodedLen);
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_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 occurences 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 enoded 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 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 occurences
+	//! 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 decoing 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,
+			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+			size_t maxDestStreamlen, size_t *decodedLen);
+};
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index 9589bed3d..97f38473e 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -1,181 +1,181 @@
-#include "../globalfunctions/Type.h"
-#include "../serialize/SerializeAdapter.h"
-
-Type::Type() :
-		actualType(UNKNOWN_TYPE) {
-}
-
-Type::Type(ActualType_t actualType) :
-		actualType(actualType) {
-}
-
-Type::Type(const Type& type) :
-		actualType(type.actualType) {
-}
-
-Type& Type::operator =(Type rhs) {
-	this->actualType = rhs.actualType;
-	return *this;
-}
-
-Type& Type::operator =(ActualType_t actualType) {
-	this->actualType = actualType;
-	return *this;
-}
-
-Type::operator Type::ActualType_t() const {
-	return actualType;
-}
-
-bool Type::operator ==(const Type& rhs) {
-	return this->actualType == rhs.actualType;
-}
-
-bool Type::operator !=(const Type& rhs) {
-	return !operator==(rhs);
-}
-
-uint8_t Type::getSize() const {
-	switch (actualType) {
-	case UINT8_T:
-		return sizeof(uint8_t);
-	case INT8_T:
-		return sizeof(int8_t);
-	case UINT16_T:
-		return sizeof(uint16_t);
-	case INT16_T:
-		return sizeof(int16_t);
-	case UINT32_T:
-		return sizeof(uint32_t);
-	case INT32_T:
-		return sizeof(int32_t);
-	case FLOAT:
-		return sizeof(float);
-	case DOUBLE:
-		return sizeof(double);
-	default:
-		return 0;
-	}
-}
-
-ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	uint8_t ptc;
-	uint8_t pfc;
-	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
-			streamEndianness);
-
-	return result;
-
-}
-
-size_t Type::getSerializedSize() const {
-	uint8_t dontcare = 0;
-	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
-}
-
-ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
-		Endianness streamEndianness) {
-	uint8_t ptc;
-	uint8_t pfc;
-	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	actualType = getActualType(ptc, pfc);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Type::getPtcPfc(uint8_t* ptc, uint8_t* pfc) const {
-	switch (actualType) {
-	case UINT8_T:
-		*ptc = 3;
-		*pfc = 4;
-		break;
-	case INT8_T:
-		*ptc = 4;
-		*pfc = 4;
-		break;
-	case UINT16_T:
-		*ptc = 3;
-		*pfc = 12;
-		break;
-	case INT16_T:
-		*ptc = 4;
-		*pfc = 12;
-		break;
-	case UINT32_T:
-		*ptc = 3;
-		*pfc = 14;
-		break;
-	case INT32_T:
-		*ptc = 4;
-		*pfc = 14;
-		break;
-	case FLOAT:
-		*ptc = 5;
-		*pfc = 1;
-		break;
-	case DOUBLE:
-		*ptc = 5;
-		*pfc = 2;
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-Type::ActualType_t Type::getActualType(uint8_t ptc, uint8_t pfc) {
-	switch (ptc) {
-	case 3:
-		switch (pfc) {
-		case 4:
-			return UINT8_T;
-		case 12:
-			return UINT16_T;
-		case 14:
-			return UINT32_T;
-		}
-		break;
-	case 4:
-		switch (pfc) {
-		case 4:
-			return INT8_T;
-		case 12:
-			return INT16_T;
-		case 14:
-			return INT32_T;
-		}
-		break;
-	case 5:
-		switch (pfc) {
-		case 1:
-			return FLOAT;
-		case 2:
-			return DOUBLE;
-		}
-		break;
-	}
-	return UNKNOWN_TYPE;
-}
+#include "../globalfunctions/Type.h"
+#include "../serialize/SerializeAdapter.h"
+
+Type::Type() :
+		actualType(UNKNOWN_TYPE) {
+}
+
+Type::Type(ActualType_t actualType) :
+		actualType(actualType) {
+}
+
+Type::Type(const Type& type) :
+		actualType(type.actualType) {
+}
+
+Type& Type::operator =(Type rhs) {
+	this->actualType = rhs.actualType;
+	return *this;
+}
+
+Type& Type::operator =(ActualType_t actualType) {
+	this->actualType = actualType;
+	return *this;
+}
+
+Type::operator Type::ActualType_t() const {
+	return actualType;
+}
+
+bool Type::operator ==(const Type& rhs) {
+	return this->actualType == rhs.actualType;
+}
+
+bool Type::operator !=(const Type& rhs) {
+	return !operator==(rhs);
+}
+
+uint8_t Type::getSize() const {
+	switch (actualType) {
+	case UINT8_T:
+		return sizeof(uint8_t);
+	case INT8_T:
+		return sizeof(int8_t);
+	case UINT16_T:
+		return sizeof(uint16_t);
+	case INT16_T:
+		return sizeof(int16_t);
+	case UINT32_T:
+		return sizeof(uint32_t);
+	case INT32_T:
+		return sizeof(int32_t);
+	case FLOAT:
+		return sizeof(float);
+	case DOUBLE:
+		return sizeof(double);
+	default:
+		return 0;
+	}
+}
+
+ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	uint8_t ptc;
+	uint8_t pfc;
+	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
+			streamEndianness);
+
+	return result;
+
+}
+
+size_t Type::getSerializedSize() const {
+	uint8_t dontcare = 0;
+	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
+}
+
+ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
+	uint8_t ptc;
+	uint8_t pfc;
+	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	actualType = getActualType(ptc, pfc);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Type::getPtcPfc(uint8_t* ptc, uint8_t* pfc) const {
+	switch (actualType) {
+	case UINT8_T:
+		*ptc = 3;
+		*pfc = 4;
+		break;
+	case INT8_T:
+		*ptc = 4;
+		*pfc = 4;
+		break;
+	case UINT16_T:
+		*ptc = 3;
+		*pfc = 12;
+		break;
+	case INT16_T:
+		*ptc = 4;
+		*pfc = 12;
+		break;
+	case UINT32_T:
+		*ptc = 3;
+		*pfc = 14;
+		break;
+	case INT32_T:
+		*ptc = 4;
+		*pfc = 14;
+		break;
+	case FLOAT:
+		*ptc = 5;
+		*pfc = 1;
+		break;
+	case DOUBLE:
+		*ptc = 5;
+		*pfc = 2;
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+Type::ActualType_t Type::getActualType(uint8_t ptc, uint8_t pfc) {
+	switch (ptc) {
+	case 3:
+		switch (pfc) {
+		case 4:
+			return UINT8_T;
+		case 12:
+			return UINT16_T;
+		case 14:
+			return UINT32_T;
+		}
+		break;
+	case 4:
+		switch (pfc) {
+		case 4:
+			return INT8_T;
+		case 12:
+			return INT16_T;
+		case 14:
+			return INT32_T;
+		}
+		break;
+	case 5:
+		switch (pfc) {
+		case 1:
+			return FLOAT;
+		case 2:
+			return DOUBLE;
+		}
+		break;
+	}
+	return UNKNOWN_TYPE;
+}
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index c10511f89..6910f9091 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -1,94 +1,94 @@
-#ifndef TYPE_H_
-#define TYPE_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerializeIF.h"
-
-/**
- * @brief 	Type definition for CCSDS or ECSS.
- */
-class Type: public SerializeIF {
-public:
-	enum ActualType_t {
-		UINT8_T,
-		INT8_T,
-		UINT16_T,
-		INT16_T,
-		UINT32_T,
-		INT32_T,
-		FLOAT,
-		DOUBLE,
-		UNKNOWN_TYPE
-	};
-
-	Type();
-
-	Type(ActualType_t actualType);
-
-	Type(const Type &type);
-
-	Type& operator=(Type rhs);
-
-	Type& operator=(ActualType_t actualType);
-
-	operator ActualType_t() const;
-
-	bool operator==(const Type &rhs);
-	bool operator!=(const Type &rhs);
-
-	uint8_t getSize() const;
-
-	ReturnValue_t getPtcPfc(uint8_t *ptc, uint8_t *pfc) const;
-
-	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
-
-	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:
-	ActualType_t actualType;
-};
-
-template<typename T>
-struct PodTypeConversion {
-	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
-};
-template<>
-struct PodTypeConversion<uint8_t> {
-	static const Type::ActualType_t type = Type::UINT8_T;
-};
-template<>
-struct PodTypeConversion<uint16_t> {
-	static const Type::ActualType_t type = Type::UINT16_T;
-};
-template<>
-struct PodTypeConversion<uint32_t> {
-	static const Type::ActualType_t type = Type::UINT32_T;
-};
-template<>
-struct PodTypeConversion<int8_t> {
-	static const Type::ActualType_t type = Type::INT8_T;
-};
-template<>
-struct PodTypeConversion<int16_t> {
-	static const Type::ActualType_t type = Type::INT16_T;
-};
-template<>
-struct PodTypeConversion<int32_t> {
-	static const Type::ActualType_t type = Type::INT32_T;
-};
-template<>
-struct PodTypeConversion<float> {
-	static const Type::ActualType_t type = Type::FLOAT;
-};
-template<>
-struct PodTypeConversion<double> {
-	static const Type::ActualType_t type = Type::DOUBLE;
-};
-
-#endif /* TYPE_H_ */
+#ifndef TYPE_H_
+#define TYPE_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+
+/**
+ * @brief 	Type definition for CCSDS or ECSS.
+ */
+class Type: public SerializeIF {
+public:
+	enum ActualType_t {
+		UINT8_T,
+		INT8_T,
+		UINT16_T,
+		INT16_T,
+		UINT32_T,
+		INT32_T,
+		FLOAT,
+		DOUBLE,
+		UNKNOWN_TYPE
+	};
+
+	Type();
+
+	Type(ActualType_t actualType);
+
+	Type(const Type &type);
+
+	Type& operator=(Type rhs);
+
+	Type& operator=(ActualType_t actualType);
+
+	operator ActualType_t() const;
+
+	bool operator==(const Type &rhs);
+	bool operator!=(const Type &rhs);
+
+	uint8_t getSize() const;
+
+	ReturnValue_t getPtcPfc(uint8_t *ptc, uint8_t *pfc) const;
+
+	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
+
+	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:
+	ActualType_t actualType;
+};
+
+template<typename T>
+struct PodTypeConversion {
+	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
+};
+template<>
+struct PodTypeConversion<uint8_t> {
+	static const Type::ActualType_t type = Type::UINT8_T;
+};
+template<>
+struct PodTypeConversion<uint16_t> {
+	static const Type::ActualType_t type = Type::UINT16_T;
+};
+template<>
+struct PodTypeConversion<uint32_t> {
+	static const Type::ActualType_t type = Type::UINT32_T;
+};
+template<>
+struct PodTypeConversion<int8_t> {
+	static const Type::ActualType_t type = Type::INT8_T;
+};
+template<>
+struct PodTypeConversion<int16_t> {
+	static const Type::ActualType_t type = Type::INT16_T;
+};
+template<>
+struct PodTypeConversion<int32_t> {
+	static const Type::ActualType_t type = Type::INT32_T;
+};
+template<>
+struct PodTypeConversion<float> {
+	static const Type::ActualType_t type = Type::FLOAT;
+};
+template<>
+struct PodTypeConversion<double> {
+	static const Type::ActualType_t type = Type::DOUBLE;
+};
+
+#endif /* TYPE_H_ */
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index 1e58ca755..fa89c0dcd 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -1,61 +1,61 @@
-#include "../globalfunctions/arrayprinter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <bitset>
-
-void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
-		bool printInfo, size_t maxCharPerLine) {
-	if(printInfo) {
-		sif::info << "Printing data with size " << size << ": ";
-	}
-	sif::info << "[";
-	if(type == OutputType::HEX) {
-		arrayprinter::printHex(data, size, maxCharPerLine);
-	}
-	else if (type == OutputType::DEC) {
-		arrayprinter::printDec(data, size, maxCharPerLine);
-	}
-	else if(type == OutputType::BIN) {
-	    arrayprinter::printBin(data, size);
-	}
-}
-
-void arrayprinter::printHex(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-	sif::info << std::hex;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << "0x" << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << "\r\n" << std::flush;
-			}
-		}
-
-	}
-	sif::info << std::dec;
-	sif::info << "]" << std::endl;
-}
-
-void arrayprinter::printDec(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-	sif::info << std::dec;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-			}
-		}
-	}
-	sif::info << "]" << std::endl;
-}
-
-void arrayprinter::printBin(const uint8_t *data, size_t size) {
-    sif::info << "\n" << std::flush;
-    for(size_t i = 0; i < size; i++) {
-        sif::info << "Byte " << i + 1 << ": 0b"<<
-                std::bitset<8>(data[i]) << ",\n" << std::flush;
-    }
-    sif::info << "]" << std::endl;
-}
+#include "../globalfunctions/arrayprinter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <bitset>
+
+void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
+		bool printInfo, size_t maxCharPerLine) {
+	if(printInfo) {
+		sif::info << "Printing data with size " << size << ": ";
+	}
+	sif::info << "[";
+	if(type == OutputType::HEX) {
+		arrayprinter::printHex(data, size, maxCharPerLine);
+	}
+	else if (type == OutputType::DEC) {
+		arrayprinter::printDec(data, size, maxCharPerLine);
+	}
+	else if(type == OutputType::BIN) {
+	    arrayprinter::printBin(data, size);
+	}
+}
+
+void arrayprinter::printHex(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::hex;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << "0x" << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << "\r\n" << std::flush;
+			}
+		}
+
+	}
+	sif::info << std::dec;
+	sif::info << "]" << std::endl;
+}
+
+void arrayprinter::printDec(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::dec;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
+		}
+	}
+	sif::info << "]" << std::endl;
+}
+
+void arrayprinter::printBin(const uint8_t *data, size_t size) {
+    sif::info << "\n" << std::flush;
+    for(size_t i = 0; i < size; i++) {
+        sif::info << "Byte " << i + 1 << ": 0b"<<
+                std::bitset<8>(data[i]) << ",\n" << std::flush;
+    }
+    sif::info << "]" << std::endl;
+}
diff --git a/globalfunctions/matching/BinaryMatcher.h b/globalfunctions/matching/BinaryMatcher.h
index 60e055a11..550439ab6 100644
--- a/globalfunctions/matching/BinaryMatcher.h
+++ b/globalfunctions/matching/BinaryMatcher.h
@@ -1,41 +1,41 @@
-#ifndef BINARYMATCHER_H_
-#define BINARYMATCHER_H_
-
-#include "../../globalfunctions/matching/MatcherIF.h"
-
-template<typename T>
-class BinaryMatcher: public MatcherIF<T> {
-public:
-	bool inverted;
-	T mask, matchField;
-
-	BinaryMatcher() :
-			inverted(false), mask(0), matchField(0) {
-	}
-
-	BinaryMatcher(T mask, T match, bool inverted = false) :
-			inverted(inverted), mask(mask), matchField(match) {
-	}
-
-	bool match(T input) {
-		if (inverted) {
-			return ~doMatch(input, mask, matchField);
-		} else {
-			return doMatch(input, mask, matchField);
-		}
-	}
-
-protected:
-
-	bool doMatch(T input, T mask, T match) {
-		match = match & mask;
-		input = input & mask;
-		if (input == match) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-};
-
-#endif /* BINARYMATCHER_H_ */
+#ifndef BINARYMATCHER_H_
+#define BINARYMATCHER_H_
+
+#include "../../globalfunctions/matching/MatcherIF.h"
+
+template<typename T>
+class BinaryMatcher: public MatcherIF<T> {
+public:
+	bool inverted;
+	T mask, matchField;
+
+	BinaryMatcher() :
+			inverted(false), mask(0), matchField(0) {
+	}
+
+	BinaryMatcher(T mask, T match, bool inverted = false) :
+			inverted(inverted), mask(mask), matchField(match) {
+	}
+
+	bool match(T input) {
+		if (inverted) {
+			return ~doMatch(input, mask, matchField);
+		} else {
+			return doMatch(input, mask, matchField);
+		}
+	}
+
+protected:
+
+	bool doMatch(T input, T mask, T match) {
+		match = match & mask;
+		input = input & mask;
+		if (input == match) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+};
+
+#endif /* BINARYMATCHER_H_ */
diff --git a/globalfunctions/matching/DecimalMatcher.h b/globalfunctions/matching/DecimalMatcher.h
index 24f399eff..3c765cd7c 100644
--- a/globalfunctions/matching/DecimalMatcher.h
+++ b/globalfunctions/matching/DecimalMatcher.h
@@ -1,50 +1,50 @@
-#ifndef DECIMALMATCHER_H_
-#define DECIMALMATCHER_H_
-
-#include "../../globalfunctions/matching/MatcherIF.h"
-
-template<typename T>
-class DecimalMatcher: public MatcherIF<T> {
-public:
-	bool inverted;
-	T mask, matchField;
-
-	DecimalMatcher() :
-			inverted(false), mask(0), matchField(0) {
-	}
-
-	DecimalMatcher(T mask, T match, bool inverted = false) :
-			inverted(inverted), mask(mask), matchField(match) {
-	}
-
-	bool match(T input) {
-		if (inverted) {
-			return ~doMatch(input, mask, matchField);
-		} else {
-			return doMatch(input, mask, matchField);
-		}
-	}
-
-protected:
-	bool doMatch(T input, T mask, T match) {
-		T decimal = 1, remainderMask, remainderMatch, remainderInput;
-
-		while (mask != 0) {
-			remainderMask = mask % (decimal * 10);
-			remainderMatch = match % (decimal * 10);
-			remainderInput = input % (decimal * 10);
-			if (remainderMask != 0) {
-				if (remainderMatch != remainderInput) {
-					return false;
-				}
-			}
-			mask -= remainderMask;
-			match -= remainderMatch;
-			input -= remainderInput;
-			decimal *= 10;
-		}
-		return true;
-	}
-};
-
-#endif /* DECIMALMATCHER_H_ */
+#ifndef DECIMALMATCHER_H_
+#define DECIMALMATCHER_H_
+
+#include "../../globalfunctions/matching/MatcherIF.h"
+
+template<typename T>
+class DecimalMatcher: public MatcherIF<T> {
+public:
+	bool inverted;
+	T mask, matchField;
+
+	DecimalMatcher() :
+			inverted(false), mask(0), matchField(0) {
+	}
+
+	DecimalMatcher(T mask, T match, bool inverted = false) :
+			inverted(inverted), mask(mask), matchField(match) {
+	}
+
+	bool match(T input) {
+		if (inverted) {
+			return ~doMatch(input, mask, matchField);
+		} else {
+			return doMatch(input, mask, matchField);
+		}
+	}
+
+protected:
+	bool doMatch(T input, T mask, T match) {
+		T decimal = 1, remainderMask, remainderMatch, remainderInput;
+
+		while (mask != 0) {
+			remainderMask = mask % (decimal * 10);
+			remainderMatch = match % (decimal * 10);
+			remainderInput = input % (decimal * 10);
+			if (remainderMask != 0) {
+				if (remainderMatch != remainderInput) {
+					return false;
+				}
+			}
+			mask -= remainderMask;
+			match -= remainderMatch;
+			input -= remainderInput;
+			decimal *= 10;
+		}
+		return true;
+	}
+};
+
+#endif /* DECIMALMATCHER_H_ */
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 2d380bbb0..46245c25c 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -1,216 +1,216 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
-
-#include "../../container/BinaryTree.h"
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-#include "../../serialize/SerializeAdapter.h"
-
-template<typename T>
-class MatchTree: public SerializeableMatcherIF<T>, public BinaryTree<
-		SerializeableMatcherIF<T>> {
-public:
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::MATCH_TREE_CLASS;
-	static const ReturnValue_t TOO_DETAILED_REQUEST = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t TOO_GENERAL_REQUEST = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t NO_MATCH = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t NEW_NODE_CREATED = MAKE_RETURN_CODE(5);
-
-	typedef typename BinaryTree<SerializeableMatcherIF<T>>::iterator iterator;
-	typedef BinaryNode<SerializeableMatcherIF<T>> Node;
-	static const bool AND = true; //LEFT
-	static const bool OR = false; //RIGHT
-	MatchTree(BinaryNode<SerializeableMatcherIF<T>>* root,
-			uint8_t maxDepth = -1) :
-			BinaryTree<SerializeableMatcherIF<T>>(root), maxDepth(maxDepth) {
-	}
-	MatchTree(iterator root, uint8_t maxDepth = -1) :
-			BinaryTree<SerializeableMatcherIF<T>>(root.element), maxDepth(
-					maxDepth) {
-	}
-	MatchTree() :
-			BinaryTree<SerializeableMatcherIF<T>>(), maxDepth(-1) {
-	}
-	virtual ~MatchTree() {
-	}
-	virtual bool match(T number) {
-		return matchesTree(number);
-	}
-	bool matchesTree(T number) {
-		iterator iter = this->begin();
-		if (iter == this->end()) {
-			return false;
-		}
-		return matchSubtree(iter, number);
-	}
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
-		iterator iter = this->begin();
-		uint8_t count = this->countRight(iter);
-		ReturnValue_t result = SerializeAdapter::serialize(&count,
-				buffer, size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (iter == this->end()) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-		result = iter->serialize(buffer, size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (maxDepth > 0) {
-			MatchTree<T> temp(iter.left(), maxDepth - 1);
-			result = temp.serialize(buffer, size, maxSize, streamEndianness);
-		}
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		iter = iter.right();
-		while (iter != this->end()) {
-			result = iter->serialize(buffer, size, maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-			if (maxDepth > 0) {
-				MatchTree<T> temp(iter.left(), maxDepth - 1);
-				result = temp.serialize(buffer, size, maxSize, streamEndianness);
-			}
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-			iter = iter.right();
-		}
-		return result;
-	}
-
-	size_t getSerializedSize() const override {
-		//Analogous to serialize!
-		uint32_t size = 1; //One for count
-		iterator iter = this->begin();
-		if (iter == this->end()) {
-			return size;
-		}
-		//Count object itself
-		size += iter->getSerializedSize();
-		//Handle everything below on AND side
-		if (maxDepth > 0) {
-			MatchTree<T> temp(iter.left(), maxDepth - 1);
-			size += temp.getSerializedSize();
-		}
-		//Handle everything on OR side
-		iter = iter.right();
-		//Iterate over every object on the OR branch
-		while (iter != this->end()) {
-			size += iter->getSerializedSize();
-			if (maxDepth > 0) {
-				//If we are allowed to go deeper, handle AND elements.
-				MatchTree<T> temp(iter.left(), maxDepth - 1);
-				size += temp.getSerializedSize();
-			}
-			iter = iter.right();
-		}
-		return size;
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-protected:
-
-	bool isOnAndBranch(iterator position) {
-		if ((position == this->end()) || (position.up() == this->end())) {
-			return false;
-		}
-		if (position.up().left() == position) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	//SHOULDDO: What to do if insertion/deletion fails. Throw event?
-	ReturnValue_t removeElementAndAllChildren(iterator position) {
-		auto children = this->erase(position);
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if (children.first != this->end()) {
-			result = removeElementAndAllChildren(children.first);
-		}
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (children.second != this->end()) {
-			result = removeElementAndAllChildren(children.second);
-		}
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		//Delete element itself.
-		return cleanUpElement(position);
-	}
-
-	ReturnValue_t removeElementAndReconnectChildren(iterator position) {
-		if (position == this->end()) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-		//Delete everything from the AND branch.
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if (position.left() != this->end()) {
-			result = removeElementAndAllChildren(position.left());
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-
-		if (position.right() != this->end()) {
-			//There's something at the OR branch, reconnect to parent.
-			if (isOnAndBranch(position)) {
-				//Either one hierarchy up AND branch...
-				this->insert(AND, position.up(), position.right().element);
-			} else {
-				//or on another OR'ed element (or install new root node).
-				this->insert(OR, position.up(), position.right().element);
-			}
-		} else {
-			if (isOnAndBranch(position)) {
-				//Recursively delete parent node as well, because it is not expected to be there anymore.
-				return removeElementAndReconnectChildren(position.up());
-			} else {
-				//simply delete self.
-				this->erase(position);
-			}
-
-		}
-		//Delete element itself.
-		return cleanUpElement(position);
-	}
-
-	virtual ReturnValue_t cleanUpElement(iterator position) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	bool matchSubtree(iterator iter, T number) {
-		bool isMatch = iter->match(number);
-		if (isMatch) {
-			if (iter.left() == this->end()) {
-				return true;
-			}
-			isMatch = matchSubtree(iter.left(), number);
-			if (isMatch) {
-				return true;
-			}
-		}
-		if (iter.right() == this->end()) {
-			return false;
-		}
-		return matchSubtree(iter.right(), number);
-	}
-private:
-	uint8_t maxDepth;
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_ */
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
+
+#include "../../container/BinaryTree.h"
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+
+template<typename T>
+class MatchTree: public SerializeableMatcherIF<T>, public BinaryTree<
+		SerializeableMatcherIF<T>> {
+public:
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::MATCH_TREE_CLASS;
+	static const ReturnValue_t TOO_DETAILED_REQUEST = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t TOO_GENERAL_REQUEST = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t NO_MATCH = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t NEW_NODE_CREATED = MAKE_RETURN_CODE(5);
+
+	typedef typename BinaryTree<SerializeableMatcherIF<T>>::iterator iterator;
+	typedef BinaryNode<SerializeableMatcherIF<T>> Node;
+	static const bool AND = true; //LEFT
+	static const bool OR = false; //RIGHT
+	MatchTree(BinaryNode<SerializeableMatcherIF<T>>* root,
+			uint8_t maxDepth = -1) :
+			BinaryTree<SerializeableMatcherIF<T>>(root), maxDepth(maxDepth) {
+	}
+	MatchTree(iterator root, uint8_t maxDepth = -1) :
+			BinaryTree<SerializeableMatcherIF<T>>(root.element), maxDepth(
+					maxDepth) {
+	}
+	MatchTree() :
+			BinaryTree<SerializeableMatcherIF<T>>(), maxDepth(-1) {
+	}
+	virtual ~MatchTree() {
+	}
+	virtual bool match(T number) {
+		return matchesTree(number);
+	}
+	bool matchesTree(T number) {
+		iterator iter = this->begin();
+		if (iter == this->end()) {
+			return false;
+		}
+		return matchSubtree(iter, number);
+	}
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
+		iterator iter = this->begin();
+		uint8_t count = this->countRight(iter);
+		ReturnValue_t result = SerializeAdapter::serialize(&count,
+				buffer, size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (iter == this->end()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+		result = iter->serialize(buffer, size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (maxDepth > 0) {
+			MatchTree<T> temp(iter.left(), maxDepth - 1);
+			result = temp.serialize(buffer, size, maxSize, streamEndianness);
+		}
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		iter = iter.right();
+		while (iter != this->end()) {
+			result = iter->serialize(buffer, size, maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+			if (maxDepth > 0) {
+				MatchTree<T> temp(iter.left(), maxDepth - 1);
+				result = temp.serialize(buffer, size, maxSize, streamEndianness);
+			}
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+			iter = iter.right();
+		}
+		return result;
+	}
+
+	size_t getSerializedSize() const override {
+		//Analogous to serialize!
+		uint32_t size = 1; //One for count
+		iterator iter = this->begin();
+		if (iter == this->end()) {
+			return size;
+		}
+		//Count object itself
+		size += iter->getSerializedSize();
+		//Handle everything below on AND side
+		if (maxDepth > 0) {
+			MatchTree<T> temp(iter.left(), maxDepth - 1);
+			size += temp.getSerializedSize();
+		}
+		//Handle everything on OR side
+		iter = iter.right();
+		//Iterate over every object on the OR branch
+		while (iter != this->end()) {
+			size += iter->getSerializedSize();
+			if (maxDepth > 0) {
+				//If we are allowed to go deeper, handle AND elements.
+				MatchTree<T> temp(iter.left(), maxDepth - 1);
+				size += temp.getSerializedSize();
+			}
+			iter = iter.right();
+		}
+		return size;
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+protected:
+
+	bool isOnAndBranch(iterator position) {
+		if ((position == this->end()) || (position.up() == this->end())) {
+			return false;
+		}
+		if (position.up().left() == position) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	//SHOULDDO: What to do if insertion/deletion fails. Throw event?
+	ReturnValue_t removeElementAndAllChildren(iterator position) {
+		auto children = this->erase(position);
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		if (children.first != this->end()) {
+			result = removeElementAndAllChildren(children.first);
+		}
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (children.second != this->end()) {
+			result = removeElementAndAllChildren(children.second);
+		}
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		//Delete element itself.
+		return cleanUpElement(position);
+	}
+
+	ReturnValue_t removeElementAndReconnectChildren(iterator position) {
+		if (position == this->end()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+		//Delete everything from the AND branch.
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		if (position.left() != this->end()) {
+			result = removeElementAndAllChildren(position.left());
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+
+		if (position.right() != this->end()) {
+			//There's something at the OR branch, reconnect to parent.
+			if (isOnAndBranch(position)) {
+				//Either one hierarchy up AND branch...
+				this->insert(AND, position.up(), position.right().element);
+			} else {
+				//or on another OR'ed element (or install new root node).
+				this->insert(OR, position.up(), position.right().element);
+			}
+		} else {
+			if (isOnAndBranch(position)) {
+				//Recursively delete parent node as well, because it is not expected to be there anymore.
+				return removeElementAndReconnectChildren(position.up());
+			} else {
+				//simply delete self.
+				this->erase(position);
+			}
+
+		}
+		//Delete element itself.
+		return cleanUpElement(position);
+	}
+
+	virtual ReturnValue_t cleanUpElement(iterator position) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	bool matchSubtree(iterator iter, T number) {
+		bool isMatch = iter->match(number);
+		if (isMatch) {
+			if (iter.left() == this->end()) {
+				return true;
+			}
+			isMatch = matchSubtree(iter.left(), number);
+			if (isMatch) {
+				return true;
+			}
+		}
+		if (iter.right() == this->end()) {
+			return false;
+		}
+		return matchSubtree(iter.right(), number);
+	}
+private:
+	uint8_t maxDepth;
+};
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_ */
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index ac67e8b83..04c9c3fac 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -1,70 +1,70 @@
-#ifndef RANGEMATCHER_H_
-#define RANGEMATCHER_H_
-
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-#include "../../serialize/SerializeAdapter.h"
-
-template<typename T>
-class RangeMatcher: public SerializeableMatcherIF<T> {
-public:
-	bool inverted;
-	T lowerBound;
-	T upperBound;
-
-	RangeMatcher() :
-			inverted(true), lowerBound(1), upperBound(0) {
-	}
-	RangeMatcher(T lowerBound, T upperBound, bool inverted = false) :
-			inverted(inverted), lowerBound(lowerBound), upperBound(upperBound) {
-	}
-
-	bool match(T input) {
-		if (inverted) {
-			return !doMatch(input);
-		} else {
-			return doMatch(input);
-		}
-	}
-
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&upperBound, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	size_t getSerializedSize() const override {
-		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
-	}
-
-	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			SerializeIF::Endianness streamEndianness) override {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
-				buffer, size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::deSerialize(&inverted, buffer, size,
-				streamEndianness);
-	}
-protected:
-	bool doMatch(T input) {
-		return (input >= lowerBound) && (input <= upperBound);
-	}
-};
-
-#endif /* RANGEMATCHER_H_ */
+#ifndef RANGEMATCHER_H_
+#define RANGEMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+
+template<typename T>
+class RangeMatcher: public SerializeableMatcherIF<T> {
+public:
+	bool inverted;
+	T lowerBound;
+	T upperBound;
+
+	RangeMatcher() :
+			inverted(true), lowerBound(1), upperBound(0) {
+	}
+	RangeMatcher(T lowerBound, T upperBound, bool inverted = false) :
+			inverted(inverted), lowerBound(lowerBound), upperBound(upperBound) {
+	}
+
+	bool match(T input) {
+		if (inverted) {
+			return !doMatch(input);
+		} else {
+			return doMatch(input);
+		}
+	}
+
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&upperBound, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	size_t getSerializedSize() const override {
+		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
+	}
+
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
+				buffer, size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::deSerialize(&inverted, buffer, size,
+				streamEndianness);
+	}
+protected:
+	bool doMatch(T input) {
+		return (input >= lowerBound) && (input <= upperBound);
+	}
+};
+
+#endif /* RANGEMATCHER_H_ */
diff --git a/globalfunctions/matching/SerializeableMatcherIF.h b/globalfunctions/matching/SerializeableMatcherIF.h
index 0d2873ef2..f99c69642 100644
--- a/globalfunctions/matching/SerializeableMatcherIF.h
+++ b/globalfunctions/matching/SerializeableMatcherIF.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
-
-#include "../../globalfunctions/matching/MatcherIF.h"
-#include "../../serialize/SerializeIF.h"
-
-template<typename T>
-class SerializeableMatcherIF : public MatcherIF<T>, public SerializeIF {
-public:
-	virtual ~SerializeableMatcherIF() {}
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_ */
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
+
+#include "../../globalfunctions/matching/MatcherIF.h"
+#include "../../serialize/SerializeIF.h"
+
+template<typename T>
+class SerializeableMatcherIF : public MatcherIF<T>, public SerializeIF {
+public:
+	virtual ~SerializeableMatcherIF() {}
+};
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_ */
diff --git a/globalfunctions/math/QuaternionOperations.cpp b/globalfunctions/math/QuaternionOperations.cpp
index 448d30f10..c6778de4a 100644
--- a/globalfunctions/math/QuaternionOperations.cpp
+++ b/globalfunctions/math/QuaternionOperations.cpp
@@ -1,156 +1,156 @@
-#include "QuaternionOperations.h"
-#include "../../globalfunctions/math/VectorOperations.h"
-
-#include <cmath>
-#include <cstring>
-#include <stdint.h>
-
-QuaternionOperations::~QuaternionOperations() {
-}
-
-void QuaternionOperations::multiply(const double* q1, const double* q2,
-		double* q) {
-	double out[4];
-
-	out[0] = q1[3] * q2[0] + q1[2] * q2[1] - q1[1] * q2[2] + q1[0] * q2[3];
-	out[1] = -q1[2] * q2[0] + q1[3] * q2[1] + q1[0] * q2[2] + q1[1] * q2[3];
-	out[2] = q1[1] * q2[0] - q1[0] * q2[1] + q1[3] * q2[2] + q1[2] * q2[3];
-	out[3] = -q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2] + q1[3] * q2[3];
-
-	memcpy(q, out, 4 * sizeof(*q));
-}
-
-void QuaternionOperations::toDcm(const double* quaternion, double dcm[][3]) {
-	dcm[0][0] = 2
-			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[0][1] = 2
-			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
-	dcm[0][2] = 2
-			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
-
-	dcm[1][0] = 2
-			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
-	dcm[1][1] = 2
-			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[1][2] = 2
-			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
-
-	dcm[2][0] = 2
-			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
-	dcm[2][1] = 2
-			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
-	dcm[2][2] = 2
-			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
-			- 1;
-}
-
-void QuaternionOperations::inverse(const double* quaternion,
-		double* inverseQuaternion) {
-	memcpy(inverseQuaternion, quaternion, 4 * sizeof(*quaternion));
-	VectorOperations<double>::mulScalar(inverseQuaternion, -1,
-			inverseQuaternion, 3);
-}
-
-QuaternionOperations::QuaternionOperations() {
-
-}
-
-void QuaternionOperations::normalize(const double* quaternion,
-		double* unitQuaternion) {
-	VectorOperations<double>::normalize(quaternion, unitQuaternion, 4);
-}
-
-float QuaternionOperations::norm(const double* quaternion) {
-	return VectorOperations<double>::norm(quaternion, 4);
-}
-
-void QuaternionOperations::fromDcm(const double dcm[][3], double* quaternion,
-		uint8_t *index) {
-
-	double a[4];
-
-	a[0] = 1 + dcm[0][0] - dcm[1][1] - dcm[2][2];
-	a[1] = 1 - dcm[0][0] + dcm[1][1] - dcm[2][2];
-	a[2] = 1 - dcm[0][0] - dcm[1][1] + dcm[2][2];
-	a[3] = 1 + dcm[0][0] + dcm[1][1] + dcm[2][2];
-
-	uint8_t maxAIndex = 0;
-
-	VectorOperations<double>::maxValue(a, 4, &maxAIndex);
-
-	if (index != 0) {
-		*index = maxAIndex;
-	}
-
-	switch (maxAIndex) {
-	case 0:
-		quaternion[0] = 0.5 * sqrt(a[0]);
-		quaternion[1] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[0]));
-		quaternion[2] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[0]));
-		quaternion[3] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[0]));
-		break;
-	case 1:
-		quaternion[0] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[1]));
-		quaternion[1] = 0.5 * sqrt(a[1]);
-		quaternion[2] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[1]));
-		quaternion[3] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[1]));
-		break;
-	case 2:
-		quaternion[0] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[2]));
-		quaternion[1] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[2]));
-		quaternion[2] = 0.5 * sqrt(a[2]);
-		quaternion[3] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[2]));
-		break;
-	case 3:
-		quaternion[0] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[3]));
-		quaternion[1] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[3]));
-		quaternion[2] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[3]));
-		quaternion[3] = 0.5 * sqrt(a[3]);
-		break;
-	}
-
-}
-
-void QuaternionOperations::toDcm(const double* quaternion, float dcm[][3]) {
-	dcm[0][0] = 2
-			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[0][1] = 2
-			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
-	dcm[0][2] = 2
-			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
-
-	dcm[1][0] = 2
-			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
-	dcm[1][1] = 2
-			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[1][2] = 2
-			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
-
-	dcm[2][0] = 2
-			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
-	dcm[2][1] = 2
-			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
-	dcm[2][2] = 2
-			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
-			- 1;
-}
-
-void QuaternionOperations::normalize(double* quaternion) {
-	normalize(quaternion, quaternion);
-}
-
-double QuaternionOperations::getAngle(const double* quaternion, bool abs) {
-	if (quaternion[3] >= 0) {
-		return 2 * acos(quaternion[3]);
-	} else {
-		if (abs) {
-			return 2 * acos(-quaternion[3]);
-		} else {
-			return -2 * acos(-quaternion[3]);
-		}
-	}
-}
+#include "QuaternionOperations.h"
+#include "../../globalfunctions/math/VectorOperations.h"
+
+#include <cmath>
+#include <cstring>
+#include <stdint.h>
+
+QuaternionOperations::~QuaternionOperations() {
+}
+
+void QuaternionOperations::multiply(const double* q1, const double* q2,
+		double* q) {
+	double out[4];
+
+	out[0] = q1[3] * q2[0] + q1[2] * q2[1] - q1[1] * q2[2] + q1[0] * q2[3];
+	out[1] = -q1[2] * q2[0] + q1[3] * q2[1] + q1[0] * q2[2] + q1[1] * q2[3];
+	out[2] = q1[1] * q2[0] - q1[0] * q2[1] + q1[3] * q2[2] + q1[2] * q2[3];
+	out[3] = -q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2] + q1[3] * q2[3];
+
+	memcpy(q, out, 4 * sizeof(*q));
+}
+
+void QuaternionOperations::toDcm(const double* quaternion, double dcm[][3]) {
+	dcm[0][0] = 2
+			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[0][1] = 2
+			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
+	dcm[0][2] = 2
+			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
+
+	dcm[1][0] = 2
+			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
+	dcm[1][1] = 2
+			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[1][2] = 2
+			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
+
+	dcm[2][0] = 2
+			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
+	dcm[2][1] = 2
+			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
+	dcm[2][2] = 2
+			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
+			- 1;
+}
+
+void QuaternionOperations::inverse(const double* quaternion,
+		double* inverseQuaternion) {
+	memcpy(inverseQuaternion, quaternion, 4 * sizeof(*quaternion));
+	VectorOperations<double>::mulScalar(inverseQuaternion, -1,
+			inverseQuaternion, 3);
+}
+
+QuaternionOperations::QuaternionOperations() {
+
+}
+
+void QuaternionOperations::normalize(const double* quaternion,
+		double* unitQuaternion) {
+	VectorOperations<double>::normalize(quaternion, unitQuaternion, 4);
+}
+
+float QuaternionOperations::norm(const double* quaternion) {
+	return VectorOperations<double>::norm(quaternion, 4);
+}
+
+void QuaternionOperations::fromDcm(const double dcm[][3], double* quaternion,
+		uint8_t *index) {
+
+	double a[4];
+
+	a[0] = 1 + dcm[0][0] - dcm[1][1] - dcm[2][2];
+	a[1] = 1 - dcm[0][0] + dcm[1][1] - dcm[2][2];
+	a[2] = 1 - dcm[0][0] - dcm[1][1] + dcm[2][2];
+	a[3] = 1 + dcm[0][0] + dcm[1][1] + dcm[2][2];
+
+	uint8_t maxAIndex = 0;
+
+	VectorOperations<double>::maxValue(a, 4, &maxAIndex);
+
+	if (index != 0) {
+		*index = maxAIndex;
+	}
+
+	switch (maxAIndex) {
+	case 0:
+		quaternion[0] = 0.5 * sqrt(a[0]);
+		quaternion[1] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[0]));
+		quaternion[2] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[0]));
+		quaternion[3] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[0]));
+		break;
+	case 1:
+		quaternion[0] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[1]));
+		quaternion[1] = 0.5 * sqrt(a[1]);
+		quaternion[2] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[1]));
+		quaternion[3] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[1]));
+		break;
+	case 2:
+		quaternion[0] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[2]));
+		quaternion[1] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[2]));
+		quaternion[2] = 0.5 * sqrt(a[2]);
+		quaternion[3] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[2]));
+		break;
+	case 3:
+		quaternion[0] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[3]));
+		quaternion[1] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[3]));
+		quaternion[2] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[3]));
+		quaternion[3] = 0.5 * sqrt(a[3]);
+		break;
+	}
+
+}
+
+void QuaternionOperations::toDcm(const double* quaternion, float dcm[][3]) {
+	dcm[0][0] = 2
+			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[0][1] = 2
+			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
+	dcm[0][2] = 2
+			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
+
+	dcm[1][0] = 2
+			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
+	dcm[1][1] = 2
+			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[1][2] = 2
+			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
+
+	dcm[2][0] = 2
+			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
+	dcm[2][1] = 2
+			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
+	dcm[2][2] = 2
+			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
+			- 1;
+}
+
+void QuaternionOperations::normalize(double* quaternion) {
+	normalize(quaternion, quaternion);
+}
+
+double QuaternionOperations::getAngle(const double* quaternion, bool abs) {
+	if (quaternion[3] >= 0) {
+		return 2 * acos(quaternion[3]);
+	} else {
+		if (abs) {
+			return 2 * acos(-quaternion[3]);
+		} else {
+			return -2 * acos(-quaternion[3]);
+		}
+	}
+}
diff --git a/globalfunctions/timevalOperations.cpp b/globalfunctions/timevalOperations.cpp
index ae49ef216..1228da047 100644
--- a/globalfunctions/timevalOperations.cpp
+++ b/globalfunctions/timevalOperations.cpp
@@ -1,99 +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.;
-}
-
-timeval timevalOperations::toTimeval(const double seconds) {
-	timeval tval;
-	tval.tv_sec = seconds;
-	tval.tv_usec = seconds *(double) 1e6 - (tval.tv_sec *1e6);
-	return tval;
-}
+#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;
+}
diff --git a/health/HasHealthIF.h b/health/HasHealthIF.h
index 9ef8c1e99..ac4043008 100644
--- a/health/HasHealthIF.h
+++ b/health/HasHealthIF.h
@@ -1,50 +1,50 @@
-#ifndef HASHEALTHIF_H_
-#define HASHEALTHIF_H_
-
-#include "../events/Event.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-class HasHealthIF {
-public:
-
-	typedef enum {
-		HEALTHY = 1, FAULTY = 0, EXTERNAL_CONTROL = 2, NEEDS_RECOVERY = 3, PERMANENT_FAULTY = 4
-	} HealthState;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
-	static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
-	static const Event HEALTH_INFO = MAKE_EVENT(6, SEVERITY::INFO);
-	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, SEVERITY::INFO);
-	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, SEVERITY::LOW);
-	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, SEVERITY::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
-	static const Event TRYING_RECOVERY = MAKE_EVENT(10, SEVERITY::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
-	static const Event RECOVERY_STEP = MAKE_EVENT(11, SEVERITY::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
-	static const Event RECOVERY_DONE = MAKE_EVENT(12, SEVERITY::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
-
-	virtual ~HasHealthIF() {
-	}
-
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-
-	/**
-	 * set the Health State
-	 *
-	 * The parent will be informed, if the Health changes
-	 *
-	 * @param health
-	 */
-	virtual ReturnValue_t setHealth(HealthState health) = 0;
-
-	/**
-	 * get Health State
-	 *
-	 * @return Health State of the object
-	 */
-	virtual HasHealthIF::HealthState getHealth() = 0;
-};
-
-#endif /* HASHEALTHIF_H_ */
+#ifndef HASHEALTHIF_H_
+#define HASHEALTHIF_H_
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class HasHealthIF {
+public:
+
+	typedef enum {
+		HEALTHY = 1, FAULTY = 0, EXTERNAL_CONTROL = 2, NEEDS_RECOVERY = 3, PERMANENT_FAULTY = 4
+	} HealthState;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
+	static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
+	static const Event HEALTH_INFO = MAKE_EVENT(6, SEVERITY::INFO);
+	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, SEVERITY::INFO);
+	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, SEVERITY::LOW);
+	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, SEVERITY::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
+	static const Event TRYING_RECOVERY = MAKE_EVENT(10, SEVERITY::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
+	static const Event RECOVERY_STEP = MAKE_EVENT(11, SEVERITY::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
+	static const Event RECOVERY_DONE = MAKE_EVENT(12, SEVERITY::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
+
+	virtual ~HasHealthIF() {
+	}
+
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+	/**
+	 * set the Health State
+	 *
+	 * The parent will be informed, if the Health changes
+	 *
+	 * @param health
+	 */
+	virtual ReturnValue_t setHealth(HealthState health) = 0;
+
+	/**
+	 * get Health State
+	 *
+	 * @return Health State of the object
+	 */
+	virtual HasHealthIF::HealthState getHealth() = 0;
+};
+
+#endif /* HASHEALTHIF_H_ */
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index 800d6e367..61718f993 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -1,105 +1,105 @@
-#include "../health/HealthHelper.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
-		objectId(objectId), owner(owner) {
-}
-
-HealthHelper::~HealthHelper() {
-}
-
-ReturnValue_t HealthHelper::handleHealthCommand(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case HealthMessage::HEALTH_SET:
-		handleSetHealthCommand(message);
-		return HasReturnvaluesIF::RETURN_OK;
-	case HealthMessage::HEALTH_ANNOUNCE: {
-		eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, getHealth(),
-				getHealth());
-	}
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-HasHealthIF::HealthState HealthHelper::getHealth() {
-	return healthTable->getHealth(objectId);
-}
-
-ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
-	setParentQueue(parentQueue);
-	return initialize();
-}
-
-void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
-	this->parentQueue = parentQueue;
-}
-
-ReturnValue_t HealthHelper::initialize() {
-	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
-	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
-
-	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) {
-		return result;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HealthHelper::setHealth(HasHealthIF::HealthState health) {
-	HasHealthIF::HealthState oldHealth = getHealth();
-	eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, health, oldHealth);
-	if (health != oldHealth) {
-		healthTable->setHealth(objectId, health);
-		informParent(health, oldHealth);
-	}
-}
-
-void HealthHelper::informParent(HasHealthIF::HealthState health,
-		HasHealthIF::HealthState oldHealth) {
-	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
-		return;
-	}
-	CommandMessage information;
-	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
-			health, oldHealth);
-	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
-	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "HealthHelper::informParent: sending health reply failed."
-				<< std::endl;
-	}
-}
-
-void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
-	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
-	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
-		return;
-	}
-	CommandMessage reply;
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		HealthMessage::setHealthMessage(&reply,
-				HealthMessage::REPLY_HEALTH_SET);
-	} else {
-		reply.setReplyRejected(result, command->getCommand());
-	}
-	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "HealthHelper::handleHealthCommand: sending health "
-		        "reply failed." << std::endl;
-
-	}
-}
+#include "../health/HealthHelper.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
+		objectId(objectId), owner(owner) {
+}
+
+HealthHelper::~HealthHelper() {
+}
+
+ReturnValue_t HealthHelper::handleHealthCommand(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case HealthMessage::HEALTH_SET:
+		handleSetHealthCommand(message);
+		return HasReturnvaluesIF::RETURN_OK;
+	case HealthMessage::HEALTH_ANNOUNCE: {
+		eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, getHealth(),
+				getHealth());
+	}
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+HasHealthIF::HealthState HealthHelper::getHealth() {
+	return healthTable->getHealth(objectId);
+}
+
+ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
+	setParentQueue(parentQueue);
+	return initialize();
+}
+
+void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
+	this->parentQueue = parentQueue;
+}
+
+ReturnValue_t HealthHelper::initialize() {
+	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
+	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
+
+	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) {
+		return result;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void HealthHelper::setHealth(HasHealthIF::HealthState health) {
+	HasHealthIF::HealthState oldHealth = getHealth();
+	eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, health, oldHealth);
+	if (health != oldHealth) {
+		healthTable->setHealth(objectId, health);
+		informParent(health, oldHealth);
+	}
+}
+
+void HealthHelper::informParent(HasHealthIF::HealthState health,
+		HasHealthIF::HealthState oldHealth) {
+	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
+		return;
+	}
+	CommandMessage information;
+	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
+			health, oldHealth);
+	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "HealthHelper::informParent: sending health reply failed."
+				<< std::endl;
+	}
+}
+
+void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
+	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
+	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
+		return;
+	}
+	CommandMessage reply;
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		HealthMessage::setHealthMessage(&reply,
+				HealthMessage::REPLY_HEALTH_SET);
+	} else {
+		reply.setReplyRejected(result, command->getCommand());
+	}
+	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "HealthHelper::handleHealthCommand: sending health "
+		        "reply failed." << std::endl;
+
+	}
+}
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index 99bb501fb..d8b81ca96 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -1,121 +1,121 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHHELPER_H_
-#define FRAMEWORK_HEALTH_HEALTHHELPER_H_
-
-#include "../events/EventManagerIF.h"
-#include "../events/EventReportingProxyIF.h"
-#include "../health/HasHealthIF.h"
-#include "../health/HealthMessage.h"
-#include "../health/HealthTableIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-/**
- * Helper class for Objects that implement HasHealthIF
- *
- * It takes care of registering with the Health Table as well as handling health commands
- * (including replying to the sender) and updating the Health Table.
- *
- * If a parent is set in the ctor, the parent will be informed with a @c HEALTH_INFO message
- * about changes in the health state. Note that a @c HEALTH_INFO is only generated if the Health
- * changes, not for all @c HEALTH_SET commands received.
- *
- * It does NOT handle @c HEALTH_INFO messages
- */
-class HealthHelper {
-public:
-
-	/**
-	 * ctor
-	 *
-	 * @param owner
-	 * @param objectId the object Id to use when communication with the HealthTable
-	 */
-	HealthHelper(HasHealthIF* owner, object_id_t objectId);
-
-	virtual ~HealthHelper();
-
-	/**
-	 * Pointer to the Health Table
-	 *
-	 * only valid after initialize() has been called
-	 */
-	HealthTableIF *healthTable = nullptr;
-
-	/**
-	 * Proxy to forward events.
-	 */
-	EventReportingProxyIF* eventSender = nullptr;
-
-	/**
-	 * Try to handle the message.
-	 *
-	 * This function handles @c HEALTH_SET and @c HEALTH_READ commands.
-	 * it updates the Health Table and generates a reply to the sender.
-	 *
-	 * @param message
-	 * @return
-	 * 			-@c RETURN_OK if the message was handled
-	 * 			-@c RETURN_FAILED if the message could not be handled (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
-	 */
-	ReturnValue_t handleHealthCommand(CommandMessage *message);
-
-	/**
-	 * set the Health State
-	 *
-	 * The parent will be informed, if the Health changes
-	 *
-	 * @param health
-	 */
-	void setHealth(HasHealthIF::HealthState health);
-
-	/**
-	 * get Health State
-	 *
-	 * @return Health State of the object
-	 */
-	HasHealthIF::HealthState getHealth();
-
-	/**
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
-	 */
-	void setParentQueue(MessageQueueId_t parentQueue);
-
-	/**
-	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
-	 * @return
-	 * 			-@c RETURN_OK if the Health Table was found and the object could be registered
-	 * 			-@c RETURN_FAILED else
-	 */
-	ReturnValue_t initialize(MessageQueueId_t parentQueue );
-
-	ReturnValue_t initialize();
-
-private:
-	/**
-	 * the object id to use when communicating with the Health Table
-	 */
-	object_id_t objectId;
-
-	/**
-	 * The Queue of the parent
-	 */
-	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
-
-	/**
-	 * The one using the healthHelper.
-	 */
-	HasHealthIF* owner;
-
-	/**
-	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message will be sent to this queue
-	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
-	 * @param oldHealth information of the previous health state.
-	 */
-	void informParent(HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth);
-
-	void handleSetHealthCommand(CommandMessage *message);
-};
-
-#endif /* HEALTHHELPER_H_ */
+#ifndef FRAMEWORK_HEALTH_HEALTHHELPER_H_
+#define FRAMEWORK_HEALTH_HEALTHHELPER_H_
+
+#include "../events/EventManagerIF.h"
+#include "../events/EventReportingProxyIF.h"
+#include "../health/HasHealthIF.h"
+#include "../health/HealthMessage.h"
+#include "../health/HealthTableIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * Helper class for Objects that implement HasHealthIF
+ *
+ * It takes care of registering with the Health Table as well as handling health commands
+ * (including replying to the sender) and updating the Health Table.
+ *
+ * If a parent is set in the ctor, the parent will be informed with a @c HEALTH_INFO message
+ * about changes in the health state. Note that a @c HEALTH_INFO is only generated if the Health
+ * changes, not for all @c HEALTH_SET commands received.
+ *
+ * It does NOT handle @c HEALTH_INFO messages
+ */
+class HealthHelper {
+public:
+
+	/**
+	 * ctor
+	 *
+	 * @param owner
+	 * @param objectId the object Id to use when communication with the HealthTable
+	 */
+	HealthHelper(HasHealthIF* owner, object_id_t objectId);
+
+	virtual ~HealthHelper();
+
+	/**
+	 * Pointer to the Health Table
+	 *
+	 * only valid after initialize() has been called
+	 */
+	HealthTableIF *healthTable = nullptr;
+
+	/**
+	 * Proxy to forward events.
+	 */
+	EventReportingProxyIF* eventSender = nullptr;
+
+	/**
+	 * Try to handle the message.
+	 *
+	 * This function handles @c HEALTH_SET and @c HEALTH_READ commands.
+	 * it updates the Health Table and generates a reply to the sender.
+	 *
+	 * @param message
+	 * @return
+	 * 			-@c RETURN_OK if the message was handled
+	 * 			-@c RETURN_FAILED if the message could not be handled (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
+	 */
+	ReturnValue_t handleHealthCommand(CommandMessage *message);
+
+	/**
+	 * set the Health State
+	 *
+	 * The parent will be informed, if the Health changes
+	 *
+	 * @param health
+	 */
+	void setHealth(HasHealthIF::HealthState health);
+
+	/**
+	 * get Health State
+	 *
+	 * @return Health State of the object
+	 */
+	HasHealthIF::HealthState getHealth();
+
+	/**
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 */
+	void setParentQueue(MessageQueueId_t parentQueue);
+
+	/**
+	 *
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @return
+	 * 			-@c RETURN_OK if the Health Table was found and the object could be registered
+	 * 			-@c RETURN_FAILED else
+	 */
+	ReturnValue_t initialize(MessageQueueId_t parentQueue );
+
+	ReturnValue_t initialize();
+
+private:
+	/**
+	 * the object id to use when communicating with the Health Table
+	 */
+	object_id_t objectId;
+
+	/**
+	 * The Queue of the parent
+	 */
+	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
+
+	/**
+	 * The one using the healthHelper.
+	 */
+	HasHealthIF* owner;
+
+	/**
+	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message will be sent to this queue
+	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
+	 * @param oldHealth information of the previous health state.
+	 */
+	void informParent(HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth);
+
+	void handleSetHealthCommand(CommandMessage *message);
+};
+
+#endif /* HEALTHHELPER_H_ */
diff --git a/health/HealthMessage.cpp b/health/HealthMessage.cpp
index c5f5b733d..39c53fb1c 100644
--- a/health/HealthMessage.cpp
+++ b/health/HealthMessage.cpp
@@ -1,28 +1,28 @@
-#include "../health/HealthMessage.h"
-
-void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
-		HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth) {
-	message->setCommand(command);
-	message->setParameter(health);
-	message->setParameter2(oldHealth);
-}
-
-void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command) {
-	message->setCommand(command);
-}
-
-HasHealthIF::HealthState HealthMessage::getHealth(const CommandMessage* message) {
-	return (HasHealthIF::HealthState) message->getParameter();
-}
-
-void HealthMessage::clear(CommandMessage* message) {
-	message->setCommand(CommandMessage::CMD_NONE);
-}
-
-HealthMessage::HealthMessage() {
-}
-
-HasHealthIF::HealthState HealthMessage::getOldHealth(
-		const CommandMessage* message) {
-	return (HasHealthIF::HealthState) message->getParameter2();
-}
+#include "../health/HealthMessage.h"
+
+void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
+		HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth) {
+	message->setCommand(command);
+	message->setParameter(health);
+	message->setParameter2(oldHealth);
+}
+
+void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command) {
+	message->setCommand(command);
+}
+
+HasHealthIF::HealthState HealthMessage::getHealth(const CommandMessage* message) {
+	return (HasHealthIF::HealthState) message->getParameter();
+}
+
+void HealthMessage::clear(CommandMessage* message) {
+	message->setCommand(CommandMessage::CMD_NONE);
+}
+
+HealthMessage::HealthMessage() {
+}
+
+HasHealthIF::HealthState HealthMessage::getOldHealth(
+		const CommandMessage* message) {
+	return (HasHealthIF::HealthState) message->getParameter2();
+}
diff --git a/health/HealthMessage.h b/health/HealthMessage.h
index d16c65db1..fa773d421 100644
--- a/health/HealthMessage.h
+++ b/health/HealthMessage.h
@@ -1,30 +1,30 @@
-#ifndef HEALTHMESSAGE_H_
-#define HEALTHMESSAGE_H_
-
-#include "../health/HasHealthIF.h"
-#include "../ipc/CommandMessage.h"
-
-class HealthMessage {
-public:
-	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);
-	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
-
-	static void setHealthMessage(CommandMessage *message, Command_t command,
-			HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
-
-	static void setHealthMessage(CommandMessage *message, Command_t command);
-
-	static HasHealthIF::HealthState getHealth(const CommandMessage *message);
-
-	static HasHealthIF::HealthState getOldHealth(const CommandMessage *message);
-
-	static void clear(CommandMessage *message);
-
-private:
-	HealthMessage();
-};
-
-#endif /* HEALTHMESSAGE_H_ */
+#ifndef HEALTHMESSAGE_H_
+#define HEALTHMESSAGE_H_
+
+#include "../health/HasHealthIF.h"
+#include "../ipc/CommandMessage.h"
+
+class HealthMessage {
+public:
+	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);
+	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
+
+	static void setHealthMessage(CommandMessage *message, Command_t command,
+			HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
+
+	static void setHealthMessage(CommandMessage *message, Command_t command);
+
+	static HasHealthIF::HealthState getHealth(const CommandMessage *message);
+
+	static HasHealthIF::HealthState getOldHealth(const CommandMessage *message);
+
+	static void clear(CommandMessage *message);
+
+private:
+	HealthMessage();
+};
+
+#endif /* HEALTHMESSAGE_H_ */
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 88db89b19..1aa5a3ae6 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -1,100 +1,100 @@
-#include "../health/HealthTable.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../ipc/MutexFactory.h"
-
-HealthTable::HealthTable(object_id_t objectid) :
-		SystemObject(objectid) {
-	mutex = MutexFactory::instance()->createMutex();;
-
-	mapIterator = healthMap.begin();
-}
-
-HealthTable::~HealthTable() {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-ReturnValue_t HealthTable::registerObject(object_id_t object,
-		HasHealthIF::HealthState initilialState) {
-	if (healthMap.count(object) != 0) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	healthMap.insert(
-			std::pair<object_id_t, HasHealthIF::HealthState>(object,
-					initilialState));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HealthTable::setHealth(object_id_t object,
-		HasHealthIF::HealthState newState) {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	HealthMap::iterator iter = healthMap.find(object);
-	if (iter != healthMap.end()) {
-		iter->second = newState;
-	}
-	mutex->unlockMutex();
-}
-
-HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
-	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	HealthMap::iterator iter = healthMap.find(object);
-	if (iter != healthMap.end()) {
-		state = iter->second;
-	}
-	mutex->unlockMutex();
-	return state;
-}
-
-uint32_t HealthTable::getPrintSize() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	uint32_t size = healthMap.size() * 5 + 2;
-	mutex->unlockMutex();
-	return size;
-}
-
-bool HealthTable::hasHealth(object_id_t object) {
-	bool exits = false;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	HealthMap::iterator iter = healthMap.find(object);
-	if (iter != healthMap.end()) {
-		exits = true;
-	}
-	mutex->unlockMutex();
-	return exits;
-}
-
-void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	size_t size = 0;
-	uint16_t count = healthMap.size();
-	ReturnValue_t result = SerializeAdapter::serialize(&count,
-			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-	HealthMap::iterator iter;
-	for (iter = healthMap.begin();
-			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
-			++iter) {
-		result = SerializeAdapter::serialize(&iter->first,
-				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-		uint8_t health = iter->second;
-		result = SerializeAdapter::serialize(&health, &pointer, &size,
-				maxSize, SerializeIF::Endianness::BIG);
-	}
-	mutex->unlockMutex();
-}
-
-ReturnValue_t HealthTable::iterate(
-		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	if (reset) {
-		mapIterator = healthMap.begin();
-	}
-	if (mapIterator == healthMap.end()) {
-		result = HasReturnvaluesIF::RETURN_FAILED;
-	}
-	*value = *mapIterator;
-	mapIterator++;
-	mutex->unlockMutex();
-
-	return result;
-}
+#include "../health/HealthTable.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../ipc/MutexFactory.h"
+
+HealthTable::HealthTable(object_id_t objectid) :
+		SystemObject(objectid) {
+	mutex = MutexFactory::instance()->createMutex();;
+
+	mapIterator = healthMap.begin();
+}
+
+HealthTable::~HealthTable() {
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+ReturnValue_t HealthTable::registerObject(object_id_t object,
+		HasHealthIF::HealthState initilialState) {
+	if (healthMap.count(object) != 0) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	healthMap.insert(
+			std::pair<object_id_t, HasHealthIF::HealthState>(object,
+					initilialState));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void HealthTable::setHealth(object_id_t object,
+		HasHealthIF::HealthState newState) {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	HealthMap::iterator iter = healthMap.find(object);
+	if (iter != healthMap.end()) {
+		iter->second = newState;
+	}
+	mutex->unlockMutex();
+}
+
+HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
+	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	HealthMap::iterator iter = healthMap.find(object);
+	if (iter != healthMap.end()) {
+		state = iter->second;
+	}
+	mutex->unlockMutex();
+	return state;
+}
+
+uint32_t HealthTable::getPrintSize() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	uint32_t size = healthMap.size() * 5 + 2;
+	mutex->unlockMutex();
+	return size;
+}
+
+bool HealthTable::hasHealth(object_id_t object) {
+	bool exits = false;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	HealthMap::iterator iter = healthMap.find(object);
+	if (iter != healthMap.end()) {
+		exits = true;
+	}
+	mutex->unlockMutex();
+	return exits;
+}
+
+void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	size_t size = 0;
+	uint16_t count = healthMap.size();
+	ReturnValue_t result = SerializeAdapter::serialize(&count,
+			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
+	HealthMap::iterator iter;
+	for (iter = healthMap.begin();
+			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
+			++iter) {
+		result = SerializeAdapter::serialize(&iter->first,
+				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
+		uint8_t health = iter->second;
+		result = SerializeAdapter::serialize(&health, &pointer, &size,
+				maxSize, SerializeIF::Endianness::BIG);
+	}
+	mutex->unlockMutex();
+}
+
+ReturnValue_t HealthTable::iterate(
+		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	if (reset) {
+		mapIterator = healthMap.begin();
+	}
+	if (mapIterator == healthMap.end()) {
+		result = HasReturnvaluesIF::RETURN_FAILED;
+	}
+	*value = *mapIterator;
+	mapIterator++;
+	mutex->unlockMutex();
+
+	return result;
+}
diff --git a/health/HealthTable.h b/health/HealthTable.h
index 5ed450412..0f54a2641 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -1,35 +1,35 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHTABLE_H_
-#define FRAMEWORK_HEALTH_HEALTHTABLE_H_
-
-#include "../health/HealthTableIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../ipc/MutexIF.h"
-#include <map>
-
-typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
-
-class HealthTable: public HealthTableIF, public SystemObject {
-public:
-	HealthTable(object_id_t objectid);
-	virtual ~HealthTable();
-
-	virtual ReturnValue_t registerObject(object_id_t object,
-			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY);
-
-	virtual bool hasHealth(object_id_t object);
-	virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState);
-	virtual HasHealthIF::HealthState getHealth(object_id_t);
-
-	virtual uint32_t getPrintSize();
-	virtual void printAll(uint8_t *pointer, size_t maxSize);
-
-protected:
-	MutexIF* mutex;
-	HealthMap healthMap;
-
-	HealthMap::iterator mapIterator;
-
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false);
-};
-
-#endif /* HEALTHTABLE_H_ */
+#ifndef FRAMEWORK_HEALTH_HEALTHTABLE_H_
+#define FRAMEWORK_HEALTH_HEALTHTABLE_H_
+
+#include "../health/HealthTableIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
+
+class HealthTable: public HealthTableIF, public SystemObject {
+public:
+	HealthTable(object_id_t objectid);
+	virtual ~HealthTable();
+
+	virtual ReturnValue_t registerObject(object_id_t object,
+			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY);
+
+	virtual bool hasHealth(object_id_t object);
+	virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState);
+	virtual HasHealthIF::HealthState getHealth(object_id_t);
+
+	virtual uint32_t getPrintSize();
+	virtual void printAll(uint8_t *pointer, size_t maxSize);
+
+protected:
+	MutexIF* mutex;
+	HealthMap healthMap;
+
+	HealthMap::iterator mapIterator;
+
+	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false);
+};
+
+#endif /* HEALTHTABLE_H_ */
diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h
index bc4a8cfba..f18f03155 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -1,28 +1,28 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
-#define FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
-
-#include "../health/ManagesHealthIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <map>
-
-
-class HealthTableIF: public ManagesHealthIF {
-	// TODO: This is in the mission folder and not in the framework folder.
-	// delete it?
-	friend class HealthCommandingService;
-public:
-	virtual ~HealthTableIF() {
-	}
-
-	virtual ReturnValue_t registerObject(object_id_t object,
-			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
-
-	virtual uint32_t getPrintSize() = 0;
-	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
-
-protected:
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
-};
-
-#endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */
+#ifndef FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
+#define FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
+
+#include "../health/ManagesHealthIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <map>
+
+
+class HealthTableIF: public ManagesHealthIF {
+	// TODO: This is in the mission folder and not in the framework folder.
+	// delete it?
+	friend class HealthCommandingService;
+public:
+	virtual ~HealthTableIF() {
+	}
+
+	virtual ReturnValue_t registerObject(object_id_t object,
+			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
+
+	virtual uint32_t getPrintSize() = 0;
+	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
+
+protected:
+	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
+};
+
+#endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */
diff --git a/health/ManagesHealthIF.h b/health/ManagesHealthIF.h
index 57996dda0..8ca170125 100644
--- a/health/ManagesHealthIF.h
+++ b/health/ManagesHealthIF.h
@@ -1,52 +1,52 @@
-#ifndef FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
-#define FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
-
-#include "../health/HasHealthIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-class ManagesHealthIF {
-public:
-	virtual ~ManagesHealthIF() {
-	}
-	virtual bool hasHealth(object_id_t object) = 0;
-	virtual void setHealth(object_id_t object,
-			HasHealthIF::HealthState newState) = 0;
-	virtual HasHealthIF::HealthState getHealth(object_id_t) = 0;
-
-	virtual bool isHealthy(object_id_t object) {
-		return (getHealth(object) == HasHealthIF::HEALTHY);
-	}
-
-	virtual bool isHealthy(HasHealthIF::HealthState health) {
-		return (health == HasHealthIF::HEALTHY);
-	}
-
-	virtual bool isFaulty(object_id_t object) {
-		HasHealthIF::HealthState health = getHealth(object);
-		return isFaulty(health);
-	}
-
-	virtual bool isPermanentFaulty(object_id_t object) {
-		HasHealthIF::HealthState health = getHealth(object);
-		return isPermanentFaulty(health);
-	}
-
-	virtual bool isPermanentFaulty(HasHealthIF::HealthState health) {
-		return (health == HasHealthIF::PERMANENT_FAULTY);
-	}
-
-	static bool isFaulty(HasHealthIF::HealthState health) {
-		return ((health == HasHealthIF::FAULTY)
-				|| (health == HasHealthIF::PERMANENT_FAULTY)
-				|| (health == HasHealthIF::NEEDS_RECOVERY));
-	}
-
-	virtual bool isCommandable(object_id_t object) {
-		return (getHealth(object) != HasHealthIF::EXTERNAL_CONTROL);
-	}
-
-	virtual bool isCommandable(HasHealthIF::HealthState health) {
-		return (health != HasHealthIF::EXTERNAL_CONTROL);
-	}
-};
-
-#endif /* FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ */
+#ifndef FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
+#define FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
+
+#include "../health/HasHealthIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+class ManagesHealthIF {
+public:
+	virtual ~ManagesHealthIF() {
+	}
+	virtual bool hasHealth(object_id_t object) = 0;
+	virtual void setHealth(object_id_t object,
+			HasHealthIF::HealthState newState) = 0;
+	virtual HasHealthIF::HealthState getHealth(object_id_t) = 0;
+
+	virtual bool isHealthy(object_id_t object) {
+		return (getHealth(object) == HasHealthIF::HEALTHY);
+	}
+
+	virtual bool isHealthy(HasHealthIF::HealthState health) {
+		return (health == HasHealthIF::HEALTHY);
+	}
+
+	virtual bool isFaulty(object_id_t object) {
+		HasHealthIF::HealthState health = getHealth(object);
+		return isFaulty(health);
+	}
+
+	virtual bool isPermanentFaulty(object_id_t object) {
+		HasHealthIF::HealthState health = getHealth(object);
+		return isPermanentFaulty(health);
+	}
+
+	virtual bool isPermanentFaulty(HasHealthIF::HealthState health) {
+		return (health == HasHealthIF::PERMANENT_FAULTY);
+	}
+
+	static bool isFaulty(HasHealthIF::HealthState health) {
+		return ((health == HasHealthIF::FAULTY)
+				|| (health == HasHealthIF::PERMANENT_FAULTY)
+				|| (health == HasHealthIF::NEEDS_RECOVERY));
+	}
+
+	virtual bool isCommandable(object_id_t object) {
+		return (getHealth(object) != HasHealthIF::EXTERNAL_CONTROL);
+	}
+
+	virtual bool isCommandable(HasHealthIF::HealthState health) {
+		return (health != HasHealthIF::EXTERNAL_CONTROL);
+	}
+};
+
+#endif /* FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ */
diff --git a/housekeeping/AcceptsHkPacketsIF.h b/housekeeping/AcceptsHkPacketsIF.h
index 879aaf8e4..b3ba6e7c0 100644
--- a/housekeeping/AcceptsHkPacketsIF.h
+++ b/housekeeping/AcceptsHkPacketsIF.h
@@ -1,11 +1,11 @@
-#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
-#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
-#include "../ipc/MessageQueueMessageIF.h"
-
-class AcceptsHkPacketsIF {
-public:
-    virtual~ AcceptsHkPacketsIF() {};
-    virtual MessageQueueId_t getHkQueue() const = 0;
-};
-
-#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */
+#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#include "../ipc/MessageQueueMessageIF.h"
+
+class AcceptsHkPacketsIF {
+public:
+    virtual~ AcceptsHkPacketsIF() {};
+    virtual MessageQueueId_t getHkQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index ed064da65..3424266bd 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,125 +1,125 @@
-#include "../datapoolglob/GlobalDataSet.h"
-#include "InternalErrorReporter.h"
-
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../ipc/MutexFactory.h"
-
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
-		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
-		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
-		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
-		storeHits(0) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-InternalErrorReporter::~InternalErrorReporter() {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
-
-	GlobDataSet mySet;
-	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-
-	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
-
-	uint32_t newQueueHits = getAndResetQueueHits();
-	uint32_t newTmHits = getAndResetTmHits();
-	uint32_t newStoreHits = getAndResetStoreHits();
-
-	queueHitsInPool.value += newQueueHits;
-	tmHitsInPool.value += newTmHits;
-	storeHitsInPool.value += newStoreHits;
-
-	mySet.commit(PoolVariableIF::VALID);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void InternalErrorReporter::queueMessageNotSent() {
-	incrementQueueHits();
-}
-
-void InternalErrorReporter::lostTm() {
-	incrementTmHits();
-}
-
-uint32_t InternalErrorReporter::getAndResetQueueHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = queueHits;
-	queueHits = 0;
-	mutex->unlockMutex();
-	return value;
-}
-
-uint32_t InternalErrorReporter::getQueueHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = queueHits;
-	mutex->unlockMutex();
-	return value;
-}
-
-void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	queueHits++;
-	mutex->unlockMutex();
-}
-
-uint32_t InternalErrorReporter::getAndResetTmHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = tmHits;
-	tmHits = 0;
-	mutex->unlockMutex();
-	return value;
-}
-
-uint32_t InternalErrorReporter::getTmHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = tmHits;
-	mutex->unlockMutex();
-	return value;
-}
-
-void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	tmHits++;
-	mutex->unlockMutex();
-}
-
-void InternalErrorReporter::storeFull() {
-	incrementStoreHits();
-}
-
-uint32_t InternalErrorReporter::getAndResetStoreHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = storeHits;
-	storeHits = 0;
-	mutex->unlockMutex();
-	return value;
-}
-
-uint32_t InternalErrorReporter::getStoreHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = storeHits;
-	mutex->unlockMutex();
-	return value;
-}
-
-void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	storeHits++;
-	mutex->unlockMutex();
-}
+#include "../datapoolglob/GlobalDataSet.h"
+#include "InternalErrorReporter.h"
+
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../ipc/MutexFactory.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
+		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
+		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
+		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
+		storeHits(0) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+InternalErrorReporter::~InternalErrorReporter() {
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
+
+	GlobDataSet mySet;
+	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
+			PoolVariableIF::VAR_READ_WRITE);
+	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
+			PoolVariableIF::VAR_READ_WRITE);
+
+	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
+			PoolVariableIF::VAR_READ_WRITE);
+	mySet.read();
+
+	uint32_t newQueueHits = getAndResetQueueHits();
+	uint32_t newTmHits = getAndResetTmHits();
+	uint32_t newStoreHits = getAndResetStoreHits();
+
+	queueHitsInPool.value += newQueueHits;
+	tmHitsInPool.value += newTmHits;
+	storeHitsInPool.value += newStoreHits;
+
+	mySet.commit(PoolVariableIF::VALID);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void InternalErrorReporter::queueMessageNotSent() {
+	incrementQueueHits();
+}
+
+void InternalErrorReporter::lostTm() {
+	incrementTmHits();
+}
+
+uint32_t InternalErrorReporter::getAndResetQueueHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = queueHits;
+	queueHits = 0;
+	mutex->unlockMutex();
+	return value;
+}
+
+uint32_t InternalErrorReporter::getQueueHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = queueHits;
+	mutex->unlockMutex();
+	return value;
+}
+
+void InternalErrorReporter::incrementQueueHits() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	queueHits++;
+	mutex->unlockMutex();
+}
+
+uint32_t InternalErrorReporter::getAndResetTmHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = tmHits;
+	tmHits = 0;
+	mutex->unlockMutex();
+	return value;
+}
+
+uint32_t InternalErrorReporter::getTmHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = tmHits;
+	mutex->unlockMutex();
+	return value;
+}
+
+void InternalErrorReporter::incrementTmHits() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	tmHits++;
+	mutex->unlockMutex();
+}
+
+void InternalErrorReporter::storeFull() {
+	incrementStoreHits();
+}
+
+uint32_t InternalErrorReporter::getAndResetStoreHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = storeHits;
+	storeHits = 0;
+	mutex->unlockMutex();
+	return value;
+}
+
+uint32_t InternalErrorReporter::getStoreHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = storeHits;
+	mutex->unlockMutex();
+	return value;
+}
+
+void InternalErrorReporter::incrementStoreHits() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	storeHits++;
+	mutex->unlockMutex();
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 1fe7426db..9aa24a0fa 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -1,50 +1,50 @@
-#ifndef INTERNALERRORREPORTER_H_
-#define INTERNALERRORREPORTER_H_
-
-#include "InternalErrorReporterIF.h"
-
-#include "../tasks/ExecutableObjectIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../ipc/MutexIF.h"
-
-class InternalErrorReporter: public SystemObject,
-		public ExecutableObjectIF,
-		public InternalErrorReporterIF {
-public:
-	InternalErrorReporter(object_id_t setObjectId, uint32_t queuePoolId,
-			uint32_t tmPoolId, uint32_t storePoolId);
-	virtual ~InternalErrorReporter();
-
-	virtual ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual void queueMessageNotSent();
-
-	virtual void lostTm();
-
-	virtual void storeFull();
-protected:
-	MutexIF* mutex;
-
-	uint32_t queuePoolId;
-	uint32_t tmPoolId;
-	uint32_t storePoolId;
-
-	uint32_t queueHits;
-	uint32_t tmHits;
-	uint32_t storeHits;
-
-	uint32_t getAndResetQueueHits();
-	uint32_t getQueueHits();
-	void incrementQueueHits();
-
-	uint32_t getAndResetTmHits();
-	uint32_t getTmHits();
-	void incrementTmHits();
-
-	uint32_t getAndResetStoreHits();
-	uint32_t getStoreHits();
-	void incrementStoreHits();
-
-};
-
-#endif /* INTERNALERRORREPORTER_H_ */
+#ifndef INTERNALERRORREPORTER_H_
+#define INTERNALERRORREPORTER_H_
+
+#include "InternalErrorReporterIF.h"
+
+#include "../tasks/ExecutableObjectIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../ipc/MutexIF.h"
+
+class InternalErrorReporter: public SystemObject,
+		public ExecutableObjectIF,
+		public InternalErrorReporterIF {
+public:
+	InternalErrorReporter(object_id_t setObjectId, uint32_t queuePoolId,
+			uint32_t tmPoolId, uint32_t storePoolId);
+	virtual ~InternalErrorReporter();
+
+	virtual ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual void queueMessageNotSent();
+
+	virtual void lostTm();
+
+	virtual void storeFull();
+protected:
+	MutexIF* mutex;
+
+	uint32_t queuePoolId;
+	uint32_t tmPoolId;
+	uint32_t storePoolId;
+
+	uint32_t queueHits;
+	uint32_t tmHits;
+	uint32_t storeHits;
+
+	uint32_t getAndResetQueueHits();
+	uint32_t getQueueHits();
+	void incrementQueueHits();
+
+	uint32_t getAndResetTmHits();
+	uint32_t getTmHits();
+	void incrementTmHits();
+
+	uint32_t getAndResetStoreHits();
+	uint32_t getStoreHits();
+	void incrementStoreHits();
+
+};
+
+#endif /* INTERNALERRORREPORTER_H_ */
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 16293608d..513debd3d 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,111 +1,111 @@
-#include "CommandMessage.h"
-#include "CommandMessageCleaner.h"
-#include <cstring>
-
-CommandMessage::CommandMessage() {
-    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
-    setCommand(CMD_NONE);
-}
-
-CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
-        uint32_t parameter2) {
-    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
-    setCommand(command);
-    setParameter(parameter1);
-    setParameter2(parameter2);
-}
-
-Command_t CommandMessage::getCommand() const {
-    Command_t command;
-    std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
-    return command;
-}
-
-void CommandMessage::setCommand(Command_t command) {
-    std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
-}
-
-uint8_t CommandMessage::getMessageType() const {
-    // first byte of command ID.
-    return getCommand() >> 8 & 0xff;
-}
-
-uint32_t CommandMessage::getParameter() const {
-    uint32_t parameter1;
-    std::memcpy(&parameter1, this->getData(), sizeof(parameter1));
-    return parameter1;
-}
-
-void CommandMessage::setParameter(uint32_t parameter1) {
-    std::memcpy(this->getData(), &parameter1, sizeof(parameter1));
-}
-
-uint32_t CommandMessage::getParameter2() const {
-    uint32_t parameter2;
-    std::memcpy(&parameter2, this->getData() + sizeof(uint32_t),
-            sizeof(parameter2));
-    return parameter2;
-}
-
-void CommandMessage::setParameter2(uint32_t parameter2) {
-    std::memcpy(this->getData()  + sizeof(uint32_t), &parameter2,
-            sizeof(parameter2));
-}
-
-uint32_t CommandMessage::getParameter3() const {
-    uint32_t parameter3;
-    std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
-            sizeof(parameter3));
-    return parameter3;
-}
-
-void CommandMessage::setParameter3(uint32_t parameter3) {
-    std::memcpy(this->getData()  + 2 * sizeof(uint32_t), &parameter3,
-            sizeof(parameter3));
-}
-
-size_t CommandMessage::getMinimumMessageSize() const {
-    return MINIMUM_COMMAND_MESSAGE_SIZE;
-}
-
-void CommandMessage::clearCommandMessage() {
-    clear();
-}
-
-void CommandMessage::clear() {
-    CommandMessageCleaner::clearCommandMessage(this);
-}
-
-bool CommandMessage::isClearedCommandMessage() {
-    return getCommand() == CMD_NONE;
-}
-
-void CommandMessage::setToUnknownCommand() {
-    Command_t initialCommand = getCommand();
-    this->clear();
-    setReplyRejected(UNKNOWN_COMMAND, initialCommand);
-}
-
-void CommandMessage::setReplyRejected(ReturnValue_t reason,
-        Command_t initialCommand) {
-	setCommand(REPLY_REJECTED);
-    setParameter(reason);
-    setParameter2(initialCommand);
-}
-
-ReturnValue_t CommandMessage::getReplyRejectedReason(
-        Command_t *initialCommand) const {
-    ReturnValue_t reason = getParameter();
-    if(initialCommand != nullptr) {
-        *initialCommand = getParameter2();
-    }
-    return reason;
-}
-
-uint8_t* CommandMessage::getData() {
-    return MessageQueueMessage::getData() + sizeof(Command_t);
-}
-
-const uint8_t* CommandMessage::getData() const {
-    return MessageQueueMessage::getData() + sizeof(Command_t);
-}
+#include "CommandMessage.h"
+#include "CommandMessageCleaner.h"
+#include <cstring>
+
+CommandMessage::CommandMessage() {
+    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
+    setCommand(CMD_NONE);
+}
+
+CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
+        uint32_t parameter2) {
+    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
+    setCommand(command);
+    setParameter(parameter1);
+    setParameter2(parameter2);
+}
+
+Command_t CommandMessage::getCommand() const {
+    Command_t command;
+    std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
+    return command;
+}
+
+void CommandMessage::setCommand(Command_t command) {
+    std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
+}
+
+uint8_t CommandMessage::getMessageType() const {
+    // first byte of command ID.
+    return getCommand() >> 8 & 0xff;
+}
+
+uint32_t CommandMessage::getParameter() const {
+    uint32_t parameter1;
+    std::memcpy(&parameter1, this->getData(), sizeof(parameter1));
+    return parameter1;
+}
+
+void CommandMessage::setParameter(uint32_t parameter1) {
+    std::memcpy(this->getData(), &parameter1, sizeof(parameter1));
+}
+
+uint32_t CommandMessage::getParameter2() const {
+    uint32_t parameter2;
+    std::memcpy(&parameter2, this->getData() + sizeof(uint32_t),
+            sizeof(parameter2));
+    return parameter2;
+}
+
+void CommandMessage::setParameter2(uint32_t parameter2) {
+    std::memcpy(this->getData()  + sizeof(uint32_t), &parameter2,
+            sizeof(parameter2));
+}
+
+uint32_t CommandMessage::getParameter3() const {
+    uint32_t parameter3;
+    std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
+            sizeof(parameter3));
+    return parameter3;
+}
+
+void CommandMessage::setParameter3(uint32_t parameter3) {
+    std::memcpy(this->getData()  + 2 * sizeof(uint32_t), &parameter3,
+            sizeof(parameter3));
+}
+
+size_t CommandMessage::getMinimumMessageSize() const {
+    return MINIMUM_COMMAND_MESSAGE_SIZE;
+}
+
+void CommandMessage::clearCommandMessage() {
+    clear();
+}
+
+void CommandMessage::clear() {
+    CommandMessageCleaner::clearCommandMessage(this);
+}
+
+bool CommandMessage::isClearedCommandMessage() {
+    return getCommand() == CMD_NONE;
+}
+
+void CommandMessage::setToUnknownCommand() {
+    Command_t initialCommand = getCommand();
+    this->clear();
+    setReplyRejected(UNKNOWN_COMMAND, initialCommand);
+}
+
+void CommandMessage::setReplyRejected(ReturnValue_t reason,
+        Command_t initialCommand) {
+	setCommand(REPLY_REJECTED);
+    setParameter(reason);
+    setParameter2(initialCommand);
+}
+
+ReturnValue_t CommandMessage::getReplyRejectedReason(
+        Command_t *initialCommand) const {
+    ReturnValue_t reason = getParameter();
+    if(initialCommand != nullptr) {
+        *initialCommand = getParameter2();
+    }
+    return reason;
+}
+
+uint8_t* CommandMessage::getData() {
+    return MessageQueueMessage::getData() + sizeof(Command_t);
+}
+
+const uint8_t* CommandMessage::getData() const {
+    return MessageQueueMessage::getData() + sizeof(Command_t);
+}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 3be9a1205..ca7b817f1 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,129 +1,129 @@
-#ifndef FSFW_IPC_COMMANDMESSAGE_H_
-#define FSFW_IPC_COMMANDMESSAGE_H_
-
-#include "CommandMessageIF.h"
-#include "MessageQueueMessage.h"
-#include "FwMessageTypes.h"
-
-/**
- * @brief 	Default command message used to pass command messages between tasks.
- * 			Primary message type for IPC. Contains sender, 2-byte command ID
- * 			field, and 2 4-byte parameters.
- * @details
- * It operates on an external memory which is contained inside a
- * class implementing MessageQueueMessageIF by taking its address.
- * This allows for a more flexible designs of message implementations.
- * The pointer can be passed to different message implementations without
- * the need of unnecessary copying.
- *
- * The command message is based of the generic MessageQueueMessage which
- * currently has an internal message size of 28 bytes.
- * @author	Bastian Baetz
- */
-class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
-public:
-    /**
-     * Default size can accomodate 2 4-byte parameters.
-     */
-    static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
-            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
-
-	/**
-	 * @brief   Default Constructor, does not initialize anything.
-	 * @details
-	 * This constructor should be used when receiving a Message, as the
-	 * content is filled by the MessageQueue.
-	 */
-	CommandMessage();
-	/**
-	 * This constructor creates a new message with all message content
-	 * initialized
-	 *
-	 * @param command	The DeviceHandlerCommand_t that will be sent
-	 * @param parameter1	The first parameter
-	 * @param parameter2	The second parameter
-	 */
-	CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
-
-	/**
-	 * @brief 	Default Destructor
-	 */
-	virtual ~CommandMessage() {}
-
-    /**
-     * Read the DeviceHandlerCommand_t that is stored in the message,
-     * usually used after receiving.
-     *
-     * @return the Command stored in the Message
-     */
-    virtual Command_t getCommand() const override;
-    /**
-     * Set the command type of the message. Default implementation also
-     * sets the message type, which will be the first byte of the command ID.
-     * @param the Command to be sent
-     */
-    virtual void setCommand(Command_t command);
-
-    virtual uint8_t* getData() override;
-    virtual const uint8_t* getData() const override;
-
-	/**
-	 * Get the first parameter of the message
-	 * @return the first Parameter of the message
-	 */
-	uint32_t getParameter() const;
-	/**
-	 * Set the first parameter of the message
-	 * @param the first parameter of the message
-	 */
-	void setParameter(uint32_t parameter1);
-	uint32_t getParameter2() const;
-	void setParameter2(uint32_t parameter2);
-	uint32_t getParameter3() const;
-	void setParameter3(uint32_t parameter3);
-
-	/**
-	 * check if a message was cleared
-	 *
-	 * @return if the command is CMD_NONE
-	 */
-	bool isClearedCommandMessage();
-
-	/**
-	 * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
-	 * Is needed quite often, so we better code it once only.
-	 */
-	void setToUnknownCommand() override;
-
-    /**
-     * A command message can be rejected and needs to offer a function
-     * to set a rejected reply
-     * @param reason
-     * @param initialCommand
-     */
-    void setReplyRejected(ReturnValue_t reason,
-            Command_t initialCommand) override;
-    /**
-     * Corrensonding getter function.
-     * @param initialCommand
-     * @return
-     */
-    ReturnValue_t getReplyRejectedReason(
-            Command_t* initialCommand = nullptr) const override;
-
-
-    virtual void clear() override;
-    void clearCommandMessage();
-
-    /**
-     * Extract message ID, which is the first byte of the command ID for the
-     * default implementation.
-     * @return
-     */
-    virtual uint8_t getMessageType() const override;
-
-    /** MessageQueueMessageIF functions used for minimum size check. */
-    size_t getMinimumMessageSize() const override;
-};
-
-#endif /* FSFW_IPC_COMMANDMESSAGE_H_ */
+#ifndef FSFW_IPC_COMMANDMESSAGE_H_
+#define FSFW_IPC_COMMANDMESSAGE_H_
+
+#include "CommandMessageIF.h"
+#include "MessageQueueMessage.h"
+#include "FwMessageTypes.h"
+
+/**
+ * @brief 	Default command message used to pass command messages between tasks.
+ * 			Primary message type for IPC. Contains sender, 2-byte command ID
+ * 			field, and 2 4-byte parameters.
+ * @details
+ * It operates on an external memory which is contained inside a
+ * class implementing MessageQueueMessageIF by taking its address.
+ * This allows for a more flexible designs of message implementations.
+ * The pointer can be passed to different message implementations without
+ * the need of unnecessary copying.
+ *
+ * The command message is based of the generic MessageQueueMessage which
+ * currently has an internal message size of 28 bytes.
+ * @author	Bastian Baetz
+ */
+class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
+public:
+    /**
+     * Default size can accomodate 2 4-byte parameters.
+     */
+    static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
+            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
+
+	/**
+	 * @brief   Default Constructor, does not initialize anything.
+	 * @details
+	 * This constructor should be used when receiving a Message, as the
+	 * content is filled by the MessageQueue.
+	 */
+	CommandMessage();
+	/**
+	 * This constructor creates a new message with all message content
+	 * initialized
+	 *
+	 * @param command	The DeviceHandlerCommand_t that will be sent
+	 * @param parameter1	The first parameter
+	 * @param parameter2	The second parameter
+	 */
+	CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
+
+	/**
+	 * @brief 	Default Destructor
+	 */
+	virtual ~CommandMessage() {}
+
+    /**
+     * Read the DeviceHandlerCommand_t that is stored in the message,
+     * usually used after receiving.
+     *
+     * @return the Command stored in the Message
+     */
+    virtual Command_t getCommand() const override;
+    /**
+     * Set the command type of the message. Default implementation also
+     * sets the message type, which will be the first byte of the command ID.
+     * @param the Command to be sent
+     */
+    virtual void setCommand(Command_t command);
+
+    virtual uint8_t* getData() override;
+    virtual const uint8_t* getData() const override;
+
+	/**
+	 * Get the first parameter of the message
+	 * @return the first Parameter of the message
+	 */
+	uint32_t getParameter() const;
+	/**
+	 * Set the first parameter of the message
+	 * @param the first parameter of the message
+	 */
+	void setParameter(uint32_t parameter1);
+	uint32_t getParameter2() const;
+	void setParameter2(uint32_t parameter2);
+	uint32_t getParameter3() const;
+	void setParameter3(uint32_t parameter3);
+
+	/**
+	 * check if a message was cleared
+	 *
+	 * @return if the command is CMD_NONE
+	 */
+	bool isClearedCommandMessage();
+
+	/**
+	 * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
+	 * Is needed quite often, so we better code it once only.
+	 */
+	void setToUnknownCommand() override;
+
+    /**
+     * A command message can be rejected and needs to offer a function
+     * to set a rejected reply
+     * @param reason
+     * @param initialCommand
+     */
+    void setReplyRejected(ReturnValue_t reason,
+            Command_t initialCommand) override;
+    /**
+     * Corrensonding getter function.
+     * @param initialCommand
+     * @return
+     */
+    ReturnValue_t getReplyRejectedReason(
+            Command_t* initialCommand = nullptr) const override;
+
+
+    virtual void clear() override;
+    void clearCommandMessage();
+
+    /**
+     * Extract message ID, which is the first byte of the command ID for the
+     * default implementation.
+     * @return
+     */
+    virtual uint8_t getMessageType() const override;
+
+    /** MessageQueueMessageIF functions used for minimum size check. */
+    size_t getMinimumMessageSize() const override;
+};
+
+#endif /* FSFW_IPC_COMMANDMESSAGE_H_ */
diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
index a4dec78df..6a99b4d2d 100644
--- a/ipc/CommandMessageCleaner.cpp
+++ b/ipc/CommandMessageCleaner.cpp
@@ -1,45 +1,45 @@
-#include "../ipc/CommandMessageCleaner.h"
-
-#include "../devicehandlers/DeviceHandlerMessage.h"
-#include "../health/HealthMessage.h"
-#include "../memory/MemoryMessage.h"
-#include "../modes/ModeMessage.h"
-#include "../monitoring/MonitoringMessage.h"
-#include "../subsystem/modes/ModeSequenceMessage.h"
-#include "../tmstorage/TmStoreMessage.h"
-#include "../parameters/ParameterMessage.h"
-
-void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
-	switch(message->getMessageType()){
-	case  messagetypes::MODE_COMMAND:
-		ModeMessage::clear(message);
-		break;
-	case messagetypes::HEALTH_COMMAND:
-		HealthMessage::clear(message);
-		break;
-	case messagetypes::MODE_SEQUENCE:
-		ModeSequenceMessage::clear(message);
-		break;
-	case messagetypes::ACTION:
-		ActionMessage::clear(message);
-		break;
-	case messagetypes::DEVICE_HANDLER_COMMAND:
-		DeviceHandlerMessage::clear(message);
-		break;
-	case messagetypes::MEMORY:
-		MemoryMessage::clear(message);
-		break;
-	case messagetypes::MONITORING:
-		MonitoringMessage::clear(message);
-		break;
-	case messagetypes::TM_STORE:
-		TmStoreMessage::clear(message);
-		break;
-	case messagetypes::PARAMETER:
-		ParameterMessage::clear(message);
-		break;
-	default:
-		messagetypes::clearMissionMessage(message);
-		break;
-	}
-}
+#include "../ipc/CommandMessageCleaner.h"
+
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../health/HealthMessage.h"
+#include "../memory/MemoryMessage.h"
+#include "../modes/ModeMessage.h"
+#include "../monitoring/MonitoringMessage.h"
+#include "../subsystem/modes/ModeSequenceMessage.h"
+#include "../tmstorage/TmStoreMessage.h"
+#include "../parameters/ParameterMessage.h"
+
+void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
+	switch(message->getMessageType()){
+	case  messagetypes::MODE_COMMAND:
+		ModeMessage::clear(message);
+		break;
+	case messagetypes::HEALTH_COMMAND:
+		HealthMessage::clear(message);
+		break;
+	case messagetypes::MODE_SEQUENCE:
+		ModeSequenceMessage::clear(message);
+		break;
+	case messagetypes::ACTION:
+		ActionMessage::clear(message);
+		break;
+	case messagetypes::DEVICE_HANDLER_COMMAND:
+		DeviceHandlerMessage::clear(message);
+		break;
+	case messagetypes::MEMORY:
+		MemoryMessage::clear(message);
+		break;
+	case messagetypes::MONITORING:
+		MonitoringMessage::clear(message);
+		break;
+	case messagetypes::TM_STORE:
+		TmStoreMessage::clear(message);
+		break;
+	case messagetypes::PARAMETER:
+		ParameterMessage::clear(message);
+		break;
+	default:
+		messagetypes::clearMissionMessage(message);
+		break;
+	}
+}
diff --git a/ipc/CommandMessageCleaner.h b/ipc/CommandMessageCleaner.h
index f17bf282b..2bf4a1932 100644
--- a/ipc/CommandMessageCleaner.h
+++ b/ipc/CommandMessageCleaner.h
@@ -1,16 +1,16 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
-#include "../ipc/CommandMessage.h"
-
-namespace messagetypes {
-// Implemented in config.
-void clearMissionMessage(CommandMessage* message);
-}
-
-class CommandMessageCleaner {
-public:
-	static void clearCommandMessage(CommandMessage* message);
-};
-
-
-#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#include "../ipc/CommandMessage.h"
+
+namespace messagetypes {
+// Implemented in config.
+void clearMissionMessage(CommandMessage* message);
+}
+
+class CommandMessageCleaner {
+public:
+	static void clearCommandMessage(CommandMessage* message);
+};
+
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index 68a8d9564..aafa40ef8 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -1,73 +1,73 @@
-#ifndef FSFW_IPC_COMMANDMESSAGEIF_H_
-#define FSFW_IPC_COMMANDMESSAGEIF_H_
-
-#include "MessageQueueMessageIF.h"
-#include "FwMessageTypes.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-#define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
-typedef uint16_t Command_t;
-
-class CommandMessageIF {
-public:
-    /**
-     * Header consists of sender ID and command ID.
-     */
-	static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
-			sizeof(Command_t);
-	/**
-	 * This minimum size is derived from the interface requirement to be able
-     * to set a rejected reply, which contains a returnvalue and the initial
-     * command.
-	 */
-	static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
-	        CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
-	        sizeof(Command_t);
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
-	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
-
-	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
-	//! Used internally, shall be ignored
-	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
-	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
-	//! Reply indicating that the current command was rejected,
-	//! par1 should contain the error code
-	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
-
-	virtual ~CommandMessageIF() {};
-
-	/**
-	 * A command message shall have a uint16_t command ID field.
-	 * @return
-	 */
-	virtual Command_t getCommand() const = 0;
-	/**
-	 * A command message shall have a uint8_t message type ID field.
-	 * @return
-	 */
-	virtual uint8_t getMessageType() const = 0;
-
-	/**
-	 * A command message can be rejected and needs to offer a function
-	 * to set a rejected reply
-	 * @param reason
-	 * @param initialCommand
-	 */
-	virtual void setReplyRejected(ReturnValue_t reason,
-			Command_t initialCommand) = 0;
-	/**
-	 * Corrensonding getter function.
-	 * @param initialCommand
-	 * @return
-	 */
-	virtual ReturnValue_t getReplyRejectedReason(
-			Command_t* initialCommand = nullptr) const  = 0;
-
-	virtual void setToUnknownCommand() = 0;
-
-	virtual void clear() = 0;
-
-};
-
-#endif /* FSFW_IPC_COMMANDMESSAGEIF_H_ */
+#ifndef FSFW_IPC_COMMANDMESSAGEIF_H_
+#define FSFW_IPC_COMMANDMESSAGEIF_H_
+
+#include "MessageQueueMessageIF.h"
+#include "FwMessageTypes.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+#define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
+typedef uint16_t Command_t;
+
+class CommandMessageIF {
+public:
+    /**
+     * Header consists of sender ID and command ID.
+     */
+	static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
+			sizeof(Command_t);
+	/**
+	 * This minimum size is derived from the interface requirement to be able
+     * to set a rejected reply, which contains a returnvalue and the initial
+     * command.
+	 */
+	static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
+	        CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
+	        sizeof(Command_t);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
+	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
+
+	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
+	//! Used internally, shall be ignored
+	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
+	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
+	//! Reply indicating that the current command was rejected,
+	//! par1 should contain the error code
+	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
+
+	virtual ~CommandMessageIF() {};
+
+	/**
+	 * A command message shall have a uint16_t command ID field.
+	 * @return
+	 */
+	virtual Command_t getCommand() const = 0;
+	/**
+	 * A command message shall have a uint8_t message type ID field.
+	 * @return
+	 */
+	virtual uint8_t getMessageType() const = 0;
+
+	/**
+	 * A command message can be rejected and needs to offer a function
+	 * to set a rejected reply
+	 * @param reason
+	 * @param initialCommand
+	 */
+	virtual void setReplyRejected(ReturnValue_t reason,
+			Command_t initialCommand) = 0;
+	/**
+	 * Corrensonding getter function.
+	 * @param initialCommand
+	 * @return
+	 */
+	virtual ReturnValue_t getReplyRejectedReason(
+			Command_t* initialCommand = nullptr) const  = 0;
+
+	virtual void setToUnknownCommand() = 0;
+
+	virtual void clear() = 0;
+
+};
+
+#endif /* FSFW_IPC_COMMANDMESSAGEIF_H_ */
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 1e80f7bd5..96bd379f9 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -1,171 +1,171 @@
-#ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
-#define FSFW_IPC_MESSAGEQUEUEIF_H_
-
-// COULDDO: We could support blocking calls
-// semaphores are being implemented, which makes this idea even more iteresting.
-
-
-/**
- * @defgroup message_queue Message Queue
- * @brief Message Queue related software components
- */
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../ipc/MessageQueueSenderIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-class MessageQueueIF {
-public:
-	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
-	//! No new messages on the queue
-	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(1);
-	//! No space left for more messages
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
-	//! Returned if a reply method was called without partner
-	static const ReturnValue_t NO_REPLY_PARTNER = MAKE_RETURN_CODE(3);
-	//! Returned if the target destination is invalid.
-	static constexpr ReturnValue_t DESTINVATION_INVALID = MAKE_RETURN_CODE(4);
-
-	virtual ~MessageQueueIF() {}
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details
-	 * This operation simplifies answering an incoming message by using the
-	 * stored lastParnter 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.
-	 * @return
-	 * -@c RETURN_OK if ok
-	 * -@c NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found.
-	 */
-	virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0;
-
-	/**
-	 * @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.
-	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) = 0;
-
-	/**
-	 * @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 theblastPartner 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.
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::EMPTY if queue is empty
-	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
-	/**
-	 * Deletes all pending messages in the queue.
-	 * @param count The number of flushed messages.
-	 * @return RETURN_OK on success.
-	 */
-	virtual ReturnValue_t flush(uint32_t* count) = 0;
-	/**
-	 * @brief	This method returns the message queue
-	 *          id of the last communication partner.
-	 */
-	virtual MessageQueueId_t getLastPartner() const = 0;
-	/**
-	 * @brief	This method returns the message queue
-	 *          id of this class's message queue.
-	 */
-	virtual MessageQueueId_t getId() const = 0;
-
-	/**
-	 * @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 returnvalue 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 (if implemented).
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::FULL if queue is full
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false ) = 0;
-
-	/**
-	 * @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.
-	 */
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
-
-	/**
-	 * @brief	The sendToDefaultFrom 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.
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::FULL if queue is full
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details
-	 * As in the sendMessage method, this function uses the sendToDefault
-	 * call of the Implementation class and adds its queue id as
-	 * "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::FULL if queue is full
-	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
-	/**
-	 * @brief	This method is a simple setter for the default destination.
-	 */
-	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) = 0;
-	/**
-	 * @brief	This method is a simple getter for the default destination.
-	 */
-	virtual MessageQueueId_t getDefaultDestination() const = 0;
-
-	virtual bool isDefaultDestinationSet() const = 0;
-};
-
-
-
-#endif /* FSFW_IPC_MESSAGEQUEUEIF_H_ */
+#ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
+#define FSFW_IPC_MESSAGEQUEUEIF_H_
+
+// COULDDO: We could support blocking calls
+// semaphores are being implemented, which makes this idea even more iteresting.
+
+
+/**
+ * @defgroup message_queue Message Queue
+ * @brief Message Queue related software components
+ */
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+class MessageQueueIF {
+public:
+	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
+	//! No new messages on the queue
+	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(1);
+	//! No space left for more messages
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
+	//! Returned if a reply method was called without partner
+	static const ReturnValue_t NO_REPLY_PARTNER = MAKE_RETURN_CODE(3);
+	//! Returned if the target destination is invalid.
+	static constexpr ReturnValue_t DESTINVATION_INVALID = MAKE_RETURN_CODE(4);
+
+	virtual ~MessageQueueIF() {}
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details
+	 * This operation simplifies answering an incoming message by using the
+	 * stored lastParnter 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.
+	 * @return
+	 * -@c RETURN_OK if ok
+	 * -@c NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found.
+	 */
+	virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0;
+
+	/**
+	 * @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.
+	 */
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) = 0;
+
+	/**
+	 * @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 theblastPartner 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.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::EMPTY if queue is empty
+	 */
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	virtual ReturnValue_t flush(uint32_t* count) = 0;
+	/**
+	 * @brief	This method returns the message queue
+	 *          id of the last communication partner.
+	 */
+	virtual MessageQueueId_t getLastPartner() const = 0;
+	/**
+	 * @brief	This method returns the message queue
+	 *          id of this class's message queue.
+	 */
+	virtual MessageQueueId_t getId() const = 0;
+
+	/**
+	 * @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 returnvalue 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 (if implemented).
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) = 0;
+
+	/**
+	 * @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.
+	 */
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
+
+	/**
+	 * @brief	The sendToDefaultFrom 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.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details
+	 * As in the sendMessage method, this function uses the sendToDefault
+	 * call of the Implementation class and adds its queue id as
+	 * "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
+	/**
+	 * @brief	This method is a simple setter for the default destination.
+	 */
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) = 0;
+	/**
+	 * @brief	This method is a simple getter for the default destination.
+	 */
+	virtual MessageQueueId_t getDefaultDestination() const = 0;
+
+	virtual bool isDefaultDestinationSet() const = 0;
+};
+
+
+
+#endif /* FSFW_IPC_MESSAGEQUEUEIF_H_ */
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index 2f79cb3b9..dcd4def35 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -1,84 +1,84 @@
-#include "MessageQueueMessage.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../globalfunctions/arrayprinter.h"
-#include <cstring>
-
-MessageQueueMessage::MessageQueueMessage() :
-		messageSize(getMinimumMessageSize()) {
-	memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
-}
-
-MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
-		messageSize(this->HEADER_SIZE + size) {
-	if (size <= this->MAX_DATA_SIZE) {
-		memcpy(this->getData(), data, size);
-		this->messageSize = this->HEADER_SIZE + size;
-	}
-	else {
-		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
-				"allowed size! Setting content to 0" << std::endl;
-		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
-		this->messageSize = this->HEADER_SIZE;
-	}
-}
-
-MessageQueueMessage::~MessageQueueMessage() {
-}
-
-const uint8_t* MessageQueueMessage::getBuffer() const {
-	return this->internalBuffer;
-}
-
-uint8_t* MessageQueueMessage::getBuffer() {
-	return this->internalBuffer;
-}
-
-const uint8_t* MessageQueueMessage::getData() const {
-	return this->internalBuffer + this->HEADER_SIZE;
-}
-
-uint8_t* MessageQueueMessage::getData() {
-	return this->internalBuffer + this->HEADER_SIZE;
-}
-
-MessageQueueId_t MessageQueueMessage::getSender() const {
-	MessageQueueId_t temp_id;
-	memcpy(&temp_id, this->internalBuffer, sizeof(MessageQueueId_t));
-	return temp_id;
-}
-
-void MessageQueueMessage::setSender(MessageQueueId_t setId) {
-	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
-}
-
-void MessageQueueMessage::print(bool printWholeMessage) {
-	sif::debug << "MessageQueueMessage content: " << std::endl;
-	if(printWholeMessage) {
-	    arrayprinter::print(getData(), getMaximumMessageSize());
-	}
-	else {
-	    arrayprinter::print(getData(), getMessageSize());
-	}
-
-}
-
-void MessageQueueMessage::clear() {
-	memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
-}
-
-size_t MessageQueueMessage::getMessageSize() const {
-	return this->messageSize;
-}
-
-void MessageQueueMessage::setMessageSize(size_t messageSize) {
-	this->messageSize = messageSize;
-}
-
-size_t MessageQueueMessage::getMinimumMessageSize() const {
-    return this->MIN_MESSAGE_SIZE;
-}
-
-size_t MessageQueueMessage::getMaximumMessageSize() const {
-    return this->MAX_MESSAGE_SIZE;
-}
-
+#include "MessageQueueMessage.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../globalfunctions/arrayprinter.h"
+#include <cstring>
+
+MessageQueueMessage::MessageQueueMessage() :
+		messageSize(getMinimumMessageSize()) {
+	memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
+}
+
+MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
+		messageSize(this->HEADER_SIZE + size) {
+	if (size <= this->MAX_DATA_SIZE) {
+		memcpy(this->getData(), data, size);
+		this->messageSize = this->HEADER_SIZE + size;
+	}
+	else {
+		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
+				"allowed size! Setting content to 0" << std::endl;
+		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
+		this->messageSize = this->HEADER_SIZE;
+	}
+}
+
+MessageQueueMessage::~MessageQueueMessage() {
+}
+
+const uint8_t* MessageQueueMessage::getBuffer() const {
+	return this->internalBuffer;
+}
+
+uint8_t* MessageQueueMessage::getBuffer() {
+	return this->internalBuffer;
+}
+
+const uint8_t* MessageQueueMessage::getData() const {
+	return this->internalBuffer + this->HEADER_SIZE;
+}
+
+uint8_t* MessageQueueMessage::getData() {
+	return this->internalBuffer + this->HEADER_SIZE;
+}
+
+MessageQueueId_t MessageQueueMessage::getSender() const {
+	MessageQueueId_t temp_id;
+	memcpy(&temp_id, this->internalBuffer, sizeof(MessageQueueId_t));
+	return temp_id;
+}
+
+void MessageQueueMessage::setSender(MessageQueueId_t setId) {
+	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
+}
+
+void MessageQueueMessage::print(bool printWholeMessage) {
+	sif::debug << "MessageQueueMessage content: " << std::endl;
+	if(printWholeMessage) {
+	    arrayprinter::print(getData(), getMaximumMessageSize());
+	}
+	else {
+	    arrayprinter::print(getData(), getMessageSize());
+	}
+
+}
+
+void MessageQueueMessage::clear() {
+	memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
+}
+
+size_t MessageQueueMessage::getMessageSize() const {
+	return this->messageSize;
+}
+
+void MessageQueueMessage::setMessageSize(size_t messageSize) {
+	this->messageSize = messageSize;
+}
+
+size_t MessageQueueMessage::getMinimumMessageSize() const {
+    return this->MIN_MESSAGE_SIZE;
+}
+
+size_t MessageQueueMessage::getMaximumMessageSize() const {
+    return this->MAX_MESSAGE_SIZE;
+}
+
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index da5c78cb8..f68e9b9f9 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -1,150 +1,150 @@
-#ifndef FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
-#define FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
-
-#include "../ipc/MessageQueueMessageIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-#include <cstddef>
-
-/**
- *	@brief		This class is the representation and data organizer
- *				for interprocess messages.
- *	@details
- *	To facilitate and standardize interprocess communication, this class was
- *	created to handle a lightweight "interprocess message protocol".
- *
- *	It adds a header with the sender's queue id to every sent message and
- *	defines the maximum total message size. Specialized messages, such as
- *	device commanding messages, can be created by inheriting from this class
- *	and filling the buffer provided by getData with additional content.
- *
- *	If larger amounts of data must be sent between processes, the data shall
- *	be stored in the IPC Store object and only the storage id is passed in a
- *	queue message.The class is used both to generate and send messages and to
- *	receive messages from other tasks.
- *	@ingroup message_queue
- */
-class MessageQueueMessage: public MessageQueueMessageIF {
-public:
-	/**
-	 * @brief	The class is initialized empty with this constructor.
-	 * @details
-	 * The messageSize attribute is set to the header's size and the whole
-	 * content is set to zero.
-	 */
-	MessageQueueMessage();
-	/**
-	 * @brief	With this constructor the class is initialized with
-	 * 			the given content.
-	 * @details
-	 * If the passed message size fits into the buffer, the passed data is
-	 * copied to the internal buffer and the messageSize information is set.
-	 * Otherwise, messageSize is set to the header's size and the whole
-	 * content is set to zero.
-	 * @param data	The data to be put in the message.
-	 * @param size	Size of the data to be copied. Must be smaller than
-	 * 				MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
-	 */
-	MessageQueueMessage(uint8_t* data, size_t size);
-
-	/**
-	 * @brief	As no memory is allocated in this class,
-	 * 		    the destructor is empty.
-	 */
-	virtual ~MessageQueueMessage();
-
-	/**
-	 * @brief	The size information of each message is stored in
-	 *  			this attribute.
-	 * @details
-	 * It is public to simplify usage and to allow for passing the size
-	 * address as a pointer. Care must be taken when inheriting from this class,
-	 * as every child class is responsible for managing the size information by
-	 * itself. When using the class to receive a message, the size information
-	 * is updated automatically.
-	 *
-	 * Please note that the minimum size is limited by the size of the header
-	 * while the maximum size is limited by the maximum allowed message size.
-	 */
-	size_t messageSize;
-	/**
-	 * @brief	This constant defines the maximum size of the data content,
-	 * 			excluding the header.
-	 * @details
-	 * It may be changed if necessary, but in general should be kept
-	 * as small as possible.
-	 */
-	static const size_t MAX_DATA_SIZE = 24;
-
-	/**
-	 * @brief	This constant defines the maximum total size in bytes
-	 * 			of a sent message.
-	 * @details
-	 * It is the sum of the maximum data and the header size. Be aware that
-	 * this constant is used to define the buffer sizes for every message
-	 * queue in the system. So, a change here may have significant impact on
-	 * the required resources.
-	 */
-	static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
-	/**
-	 * @brief Defines the minimum size of a message where only the
-	 * 		  header is included
-	 */
-	static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
-private:
-	/**
-	 * @brief	This is the internal buffer that contains the
-	 * 			actual message data.
-	 */
-	uint8_t internalBuffer[MAX_MESSAGE_SIZE];
-public:
-	/**
-	 * @brief	This method is used to get the complete data of the message.
-	 */
-	const uint8_t* getBuffer() const override;
-	/**
-	 * @brief	This method is used to get the complete data of the message.
-	 */
-	uint8_t* getBuffer() override;
-	/**
-	 * @brief	This method is used to fetch the data content of the message.
-	 * @details
-	 * It shall be used by child classes to add data at the right position.
-	 */
-	const uint8_t* getData() const override;
-	/**
-	 * @brief	This method is used to fetch the data content of the message.
-	 * @details
-	 * It shall be used by child classes to add data at the right position.
-	 */
-	uint8_t* getData() override;
-	/**
-	 * @brief	This method is used to extract the sender's message
-	 * 			queue id information from a received message.
-	 */
-	MessageQueueId_t getSender() const override;
-	/**
-	 * @brief	With this method, the whole content
-	 * 			and the message size is set to zero.
-	 */
-	void clear() override;
-
-	/**
-	 * @brief	This method is used to set the sender's message queue id
-	 * 			information prior to ing the message.
-	 * @param setId
-	 * The message queue id that identifies the sending message queue.
-	 */
-	void setSender(MessageQueueId_t setId) override;
-
-	virtual size_t getMessageSize() const override;
-	virtual void setMessageSize(size_t messageSize) override;
-	virtual size_t getMinimumMessageSize() const override;
-	virtual size_t getMaximumMessageSize() const override;
-
-	/**
-	 * @brief	This is a debug method that prints the content.
-	 */
-	void print(bool printWholeMessage);
-};
-
-#endif /* FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ */
+#ifndef FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
+#define FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
+
+#include "../ipc/MessageQueueMessageIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include <cstddef>
+
+/**
+ *	@brief		This class is the representation and data organizer
+ *				for interprocess messages.
+ *	@details
+ *	To facilitate and standardize interprocess communication, this class was
+ *	created to handle a lightweight "interprocess message protocol".
+ *
+ *	It adds a header with the sender's queue id to every sent message and
+ *	defines the maximum total message size. Specialized messages, such as
+ *	device commanding messages, can be created by inheriting from this class
+ *	and filling the buffer provided by getData with additional content.
+ *
+ *	If larger amounts of data must be sent between processes, the data shall
+ *	be stored in the IPC Store object and only the storage id is passed in a
+ *	queue message.The class is used both to generate and send messages and to
+ *	receive messages from other tasks.
+ *	@ingroup message_queue
+ */
+class MessageQueueMessage: public MessageQueueMessageIF {
+public:
+	/**
+	 * @brief	The class is initialized empty with this constructor.
+	 * @details
+	 * The messageSize attribute is set to the header's size and the whole
+	 * content is set to zero.
+	 */
+	MessageQueueMessage();
+	/**
+	 * @brief	With this constructor the class is initialized with
+	 * 			the given content.
+	 * @details
+	 * If the passed message size fits into the buffer, the passed data is
+	 * copied to the internal buffer and the messageSize information is set.
+	 * Otherwise, messageSize is set to the header's size and the whole
+	 * content is set to zero.
+	 * @param data	The data to be put in the message.
+	 * @param size	Size of the data to be copied. Must be smaller than
+	 * 				MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
+	 */
+	MessageQueueMessage(uint8_t* data, size_t size);
+
+	/**
+	 * @brief	As no memory is allocated in this class,
+	 * 		    the destructor is empty.
+	 */
+	virtual ~MessageQueueMessage();
+
+	/**
+	 * @brief	The size information of each message is stored in
+	 *  			this attribute.
+	 * @details
+	 * It is public to simplify usage and to allow for passing the size
+	 * address as a pointer. Care must be taken when inheriting from this class,
+	 * as every child class is responsible for managing the size information by
+	 * itself. When using the class to receive a message, the size information
+	 * is updated automatically.
+	 *
+	 * Please note that the minimum size is limited by the size of the header
+	 * while the maximum size is limited by the maximum allowed message size.
+	 */
+	size_t messageSize;
+	/**
+	 * @brief	This constant defines the maximum size of the data content,
+	 * 			excluding the header.
+	 * @details
+	 * It may be changed if necessary, but in general should be kept
+	 * as small as possible.
+	 */
+	static const size_t MAX_DATA_SIZE = 24;
+
+	/**
+	 * @brief	This constant defines the maximum total size in bytes
+	 * 			of a sent message.
+	 * @details
+	 * It is the sum of the maximum data and the header size. Be aware that
+	 * this constant is used to define the buffer sizes for every message
+	 * queue in the system. So, a change here may have significant impact on
+	 * the required resources.
+	 */
+	static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
+	/**
+	 * @brief Defines the minimum size of a message where only the
+	 * 		  header is included
+	 */
+	static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
+private:
+	/**
+	 * @brief	This is the internal buffer that contains the
+	 * 			actual message data.
+	 */
+	uint8_t internalBuffer[MAX_MESSAGE_SIZE];
+public:
+	/**
+	 * @brief	This method is used to get the complete data of the message.
+	 */
+	const uint8_t* getBuffer() const override;
+	/**
+	 * @brief	This method is used to get the complete data of the message.
+	 */
+	uint8_t* getBuffer() override;
+	/**
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
+	 */
+	const uint8_t* getData() const override;
+	/**
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
+	 */
+	uint8_t* getData() override;
+	/**
+	 * @brief	This method is used to extract the sender's message
+	 * 			queue id information from a received message.
+	 */
+	MessageQueueId_t getSender() const override;
+	/**
+	 * @brief	With this method, the whole content
+	 * 			and the message size is set to zero.
+	 */
+	void clear() override;
+
+	/**
+	 * @brief	This method is used to set the sender's message queue id
+	 * 			information prior to ing the message.
+	 * @param setId
+	 * The message queue id that identifies the sending message queue.
+	 */
+	void setSender(MessageQueueId_t setId) override;
+
+	virtual size_t getMessageSize() const override;
+	virtual void setMessageSize(size_t messageSize) override;
+	virtual size_t getMinimumMessageSize() const override;
+	virtual size_t getMaximumMessageSize() const override;
+
+	/**
+	 * @brief	This is a debug method that prints the content.
+	 */
+	void print(bool printWholeMessage);
+};
+
+#endif /* FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ */
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 806231578..b967bbdf5 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,25 +1,25 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
-
-#include "../ipc/MessageQueueMessageIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-class MessageQueueSenderIF {
-public:
-
-	virtual ~MessageQueueSenderIF() {}
-
-	/**
-	 * Allows sending messages without actually "owning" a message queue.
-	 * Not sure whether this is actually a good idea.
-	 */
-	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
-			bool ignoreFault = false);
-private:
-	MessageQueueSenderIF() {}
-};
-
-
-#endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */
+#ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
+#define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
+
+#include "../ipc/MessageQueueMessageIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+class MessageQueueSenderIF {
+public:
+
+	virtual ~MessageQueueSenderIF() {}
+
+	/**
+	 * Allows sending messages without actually "owning" a message queue.
+	 * Not sure whether this is actually a good idea.
+	 */
+	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
+			bool ignoreFault = false);
+private:
+	MessageQueueSenderIF() {}
+};
+
+
+#endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */
diff --git a/ipc/MutexFactory.h b/ipc/MutexFactory.h
index 91e909073..f34d3b04c 100644
--- a/ipc/MutexFactory.h
+++ b/ipc/MutexFactory.h
@@ -1,34 +1,34 @@
-#ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
-#define FRAMEWORK_IPC_MUTEXFACTORY_H_
-
-#include "../ipc/MutexIF.h"
-/**
- * Creates Mutex.
- * This class is a "singleton" interface, i.e. it provides an
- * interface, but also is the base class for a singleton.
- */
-class MutexFactory {
-public:
-	virtual ~MutexFactory();
-	/**
-	 * Returns the single instance of MutexFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static MutexFactory* instance();
-
-	MutexIF* createMutex();
-
-	void deleteMutex(MutexIF* mutex);
-
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	MutexFactory();
-	static MutexFactory* factoryInstance;
-};
-
-
-
-#endif /* FRAMEWORK_IPC_MUTEXFACTORY_H_ */
+#ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
+#define FRAMEWORK_IPC_MUTEXFACTORY_H_
+
+#include "../ipc/MutexIF.h"
+/**
+ * Creates Mutex.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class MutexFactory {
+public:
+	virtual ~MutexFactory();
+	/**
+	 * Returns the single instance of MutexFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static MutexFactory* instance();
+
+	MutexIF* createMutex();
+
+	void deleteMutex(MutexIF* mutex);
+
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	MutexFactory();
+	static MutexFactory* factoryInstance;
+};
+
+
+
+#endif /* FRAMEWORK_IPC_MUTEXFACTORY_H_ */
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 97e280072..97001ade9 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -1,30 +1,30 @@
-#ifndef FRAMEWORK_IPC_MUTEXHELPER_H_
-#define FRAMEWORK_IPC_MUTEXHELPER_H_
-
-#include "MutexFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-class MutexHelper {
-public:
-	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
-			internalMutex(mutex) {
-		ReturnValue_t status = mutex->lockMutex(timeoutType,
-		        timeoutMs);
-		if(status == MutexIF::MUTEX_TIMEOUT) {
-			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
-					<< timeoutMs << " milliseconds!" << std::endl;
-		}
-		else if(status != HasReturnvaluesIF::RETURN_OK){
-			sif::error << "MutexHelper: Lock of Mutex failed with code "
-			        << status << std::endl;
-		}
-	}
-
-	~MutexHelper() {
-		internalMutex->unlockMutex();
-	}
-private:
-	MutexIF* internalMutex;
-};
-#endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */
+#ifndef FRAMEWORK_IPC_MUTEXHELPER_H_
+#define FRAMEWORK_IPC_MUTEXHELPER_H_
+
+#include "MutexFactory.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+class MutexHelper {
+public:
+	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
+			internalMutex(mutex) {
+		ReturnValue_t status = mutex->lockMutex(timeoutType,
+		        timeoutMs);
+		if(status == MutexIF::MUTEX_TIMEOUT) {
+			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
+					<< timeoutMs << " milliseconds!" << std::endl;
+		}
+		else if(status != HasReturnvaluesIF::RETURN_OK){
+			sif::error << "MutexHelper: Lock of Mutex failed with code "
+			        << status << std::endl;
+		}
+	}
+
+	~MutexHelper() {
+		internalMutex->unlockMutex();
+	}
+private:
+	MutexIF* internalMutex;
+};
+#endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */
diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 7bca4c9de..5673e4d79 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -1,89 +1,89 @@
-#ifndef FRAMEWORK_IPC_MUTEXIF_H_
-#define FRAMEWORK_IPC_MUTEXIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-/**
- * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
- * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
- * @ingroup osal
- * @ingroup interface
- */
-class MutexIF {
-public:
-    /**
-     * Different types of timeout for the mutex lock.
-     */
-    enum TimeoutType {
-        POLLING, //!< If mutex is not available, return immediately
-        WAITING, //!< Wait a specified time for the mutex to become available
-        BLOCKING //!< Block indefinitely until the mutex becomes available.
-    };
-
-    /**
-     * Lock the mutex. The timeout value will only be used for
-     * TimeoutType::WAITING
-     * @param timeoutType
-     * @param timeoutMs
-     * @return
-     */
-    virtual ReturnValue_t lockMutex(TimeoutType timeoutType =
-            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
-    virtual ReturnValue_t unlockMutex() = 0;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
-	/**
-	 * The system lacked the necessary resources (other than memory) to initialize another mutex.
-	 */
-	static const ReturnValue_t NOT_ENOUGH_RESOURCES = MAKE_RETURN_CODE(1);
-	/**
-	 * Insufficient memory to create or init Mutex
-	 */
-	static const ReturnValue_t INSUFFICIENT_MEMORY = MAKE_RETURN_CODE(2);
-	/**
-	 * Caller does not have enough or right privilege
-	 */
-	static const ReturnValue_t NO_PRIVILEGE =  MAKE_RETURN_CODE(3);
-	/**
-	 * Wrong Attribute Setting
-	 */
-	static const ReturnValue_t WRONG_ATTRIBUTE_SETTING = MAKE_RETURN_CODE(4);
-	/**
-	 * The mutex is already locked
-	 */
-	static const ReturnValue_t MUTEX_ALREADY_LOCKED = MAKE_RETURN_CODE(5);
-	/**
-	 * Mutex object not found
-	 */
-	static const ReturnValue_t MUTEX_NOT_FOUND = MAKE_RETURN_CODE(6);
-	/**
-	 * Mutex could not be locked because max amount of recursive locks
-	 */
-	static const ReturnValue_t MUTEX_MAX_LOCKS = MAKE_RETURN_CODE(7);
-	/**
-	 * The current thread already owns this mutex
-	 */
-	static const ReturnValue_t CURR_THREAD_ALREADY_OWNS_MUTEX = MAKE_RETURN_CODE(8);
-	/**
-	 * Current thread does not own this mutex
-	 */
-	static const ReturnValue_t CURR_THREAD_DOES_NOT_OWN_MUTEX = MAKE_RETURN_CODE(9);
-	/**
-	 * The Mutex could not be blocked before timeout
-	 */
-	static const ReturnValue_t MUTEX_TIMEOUT = MAKE_RETURN_CODE(10);
-	/**
-	 * Invalid Mutex ID
-	 */
-	static const ReturnValue_t MUTEX_INVALID_ID = MAKE_RETURN_CODE(11);
-	/**
-	 * Mutex destroyed while waiting
-	 */
-	static const ReturnValue_t MUTEX_DESTROYED_WHILE_WAITING = MAKE_RETURN_CODE(12);
-
-    virtual ~MutexIF() {}
-};
-
-
-
-#endif /* FRAMEWORK_IPC_MUTEXIF_H_ */
+#ifndef FRAMEWORK_IPC_MUTEXIF_H_
+#define FRAMEWORK_IPC_MUTEXIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
+ * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
+ * @ingroup osal
+ * @ingroup interface
+ */
+class MutexIF {
+public:
+    /**
+     * Different types of timeout for the mutex lock.
+     */
+    enum TimeoutType {
+        POLLING, //!< If mutex is not available, return immediately
+        WAITING, //!< Wait a specified time for the mutex to become available
+        BLOCKING //!< Block indefinitely until the mutex becomes available.
+    };
+
+    /**
+     * Lock the mutex. The timeout value will only be used for
+     * TimeoutType::WAITING
+     * @param timeoutType
+     * @param timeoutMs
+     * @return
+     */
+    virtual ReturnValue_t lockMutex(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
+    virtual ReturnValue_t unlockMutex() = 0;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
+	/**
+	 * The system lacked the necessary resources (other than memory) to initialize another mutex.
+	 */
+	static const ReturnValue_t NOT_ENOUGH_RESOURCES = MAKE_RETURN_CODE(1);
+	/**
+	 * Insufficient memory to create or init Mutex
+	 */
+	static const ReturnValue_t INSUFFICIENT_MEMORY = MAKE_RETURN_CODE(2);
+	/**
+	 * Caller does not have enough or right privilege
+	 */
+	static const ReturnValue_t NO_PRIVILEGE =  MAKE_RETURN_CODE(3);
+	/**
+	 * Wrong Attribute Setting
+	 */
+	static const ReturnValue_t WRONG_ATTRIBUTE_SETTING = MAKE_RETURN_CODE(4);
+	/**
+	 * The mutex is already locked
+	 */
+	static const ReturnValue_t MUTEX_ALREADY_LOCKED = MAKE_RETURN_CODE(5);
+	/**
+	 * Mutex object not found
+	 */
+	static const ReturnValue_t MUTEX_NOT_FOUND = MAKE_RETURN_CODE(6);
+	/**
+	 * Mutex could not be locked because max amount of recursive locks
+	 */
+	static const ReturnValue_t MUTEX_MAX_LOCKS = MAKE_RETURN_CODE(7);
+	/**
+	 * The current thread already owns this mutex
+	 */
+	static const ReturnValue_t CURR_THREAD_ALREADY_OWNS_MUTEX = MAKE_RETURN_CODE(8);
+	/**
+	 * Current thread does not own this mutex
+	 */
+	static const ReturnValue_t CURR_THREAD_DOES_NOT_OWN_MUTEX = MAKE_RETURN_CODE(9);
+	/**
+	 * The Mutex could not be blocked before timeout
+	 */
+	static const ReturnValue_t MUTEX_TIMEOUT = MAKE_RETURN_CODE(10);
+	/**
+	 * Invalid Mutex ID
+	 */
+	static const ReturnValue_t MUTEX_INVALID_ID = MAKE_RETURN_CODE(11);
+	/**
+	 * Mutex destroyed while waiting
+	 */
+	static const ReturnValue_t MUTEX_DESTROYED_WHILE_WAITING = MAKE_RETURN_CODE(12);
+
+    virtual ~MutexIF() {}
+};
+
+
+
+#endif /* FRAMEWORK_IPC_MUTEXIF_H_ */
diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index e98919877..be5544061 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -1,33 +1,33 @@
-#ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
-#define FRAMEWORK_IPC_QUEUEFACTORY_H_
-
-#include "MessageQueueIF.h"
-#include <cstdint>
-/**
- * Creates message queues.
- * This class is a "singleton" interface, i.e. it provides an
- * interface, but also is the base class for a singleton.
- */
-class QueueFactory {
-public:
-	virtual ~QueueFactory();
-	/**
-	 * Returns the single instance of QueueFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static QueueFactory* instance();
-
-	MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
-			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
-
-	void deleteMessageQueue(MessageQueueIF* queue);
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	QueueFactory();
-	static QueueFactory* factoryInstance;
-};
-
-#endif /* FRAMEWORK_IPC_QUEUEFACTORY_H_ */
+#ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
+#define FRAMEWORK_IPC_QUEUEFACTORY_H_
+
+#include "MessageQueueIF.h"
+#include <cstdint>
+/**
+ * Creates message queues.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class QueueFactory {
+public:
+	virtual ~QueueFactory();
+	/**
+	 * Returns the single instance of QueueFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static QueueFactory* instance();
+
+	MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
+
+	void deleteMessageQueue(MessageQueueIF* queue);
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	QueueFactory();
+	static QueueFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_IPC_QUEUEFACTORY_H_ */
diff --git a/memory/AcceptsMemoryMessagesIF.h b/memory/AcceptsMemoryMessagesIF.h
index 044f22360..4c222dece 100644
--- a/memory/AcceptsMemoryMessagesIF.h
+++ b/memory/AcceptsMemoryMessagesIF.h
@@ -1,21 +1,21 @@
-/**
- * @file	AcceptsMemoryMessagesIF.h
- * @brief	This file defines the AcceptsMemoryMessagesIF class.
- * @date	11.07.2013
- * @author	baetz
- */
-
-#ifndef ACCEPTSMEMORYMESSAGESIF_H_
-#define ACCEPTSMEMORYMESSAGESIF_H_
-
-#include "../memory/HasMemoryIF.h"
-#include "../memory/MemoryMessage.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-class AcceptsMemoryMessagesIF : public HasMemoryIF {
-public:
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-};
-
-
-#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */
+/**
+ * @file	AcceptsMemoryMessagesIF.h
+ * @brief	This file defines the AcceptsMemoryMessagesIF class.
+ * @date	11.07.2013
+ * @author	baetz
+ */
+
+#ifndef ACCEPTSMEMORYMESSAGESIF_H_
+#define ACCEPTSMEMORYMESSAGESIF_H_
+
+#include "../memory/HasMemoryIF.h"
+#include "../memory/MemoryMessage.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class AcceptsMemoryMessagesIF : public HasMemoryIF {
+public:
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+};
+
+
+#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */
diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index a1c3955f5..30437a623 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -1,28 +1,28 @@
-/*
- * FileSystemMessage.cpp
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#include "FileSystemMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-ReturnValue_t FileSystemMessage::setWriteToFileCommand(CommandMessage* message,
-		MessageQueueId_t replyQueueId, store_address_t storageID) {
-	message->setCommand(WRITE_TO_FILE);
-	message->setParameter(replyQueueId);
-	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-store_address_t FileSystemMessage::getStoreID(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-MessageQueueId_t FileSystemMessage::getReplyQueueId(const CommandMessage* message){
-	return message->getParameter();
-}
-
+/*
+ * FileSystemMessage.cpp
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#include "FileSystemMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+ReturnValue_t FileSystemMessage::setWriteToFileCommand(CommandMessage* message,
+		MessageQueueId_t replyQueueId, store_address_t storageID) {
+	message->setCommand(WRITE_TO_FILE);
+	message->setParameter(replyQueueId);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+store_address_t FileSystemMessage::getStoreID(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+MessageQueueId_t FileSystemMessage::getReplyQueueId(const CommandMessage* message){
+	return message->getParameter();
+}
+
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index 9ef9a2f49..da5b3181e 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -1,30 +1,30 @@
-/*
- * FileSystemMessage.h
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
-#define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../objectmanager/SystemObject.h"
-
-class FileSystemMessage {
-private:
-	FileSystemMessage(); //A private ctor inhibits instantiation
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
-	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
-	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
-	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
-
-	static ReturnValue_t setWriteToFileCommand(CommandMessage* message, MessageQueueId_t replyToQueue, store_address_t storageID );
-	static store_address_t getStoreID( const CommandMessage* message );
-	static MessageQueueId_t getReplyQueueId(const CommandMessage* message);
-
-};
-
-#endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */
+/*
+ * FileSystemMessage.h
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
+#define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+
+class FileSystemMessage {
+private:
+	FileSystemMessage(); //A private ctor inhibits instantiation
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
+	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
+	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
+	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
+
+	static ReturnValue_t setWriteToFileCommand(CommandMessage* message, MessageQueueId_t replyToQueue, store_address_t storageID );
+	static store_address_t getStoreID( const CommandMessage* message );
+	static MessageQueueId_t getReplyQueueId(const CommandMessage* message);
+
+};
+
+#endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */
diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 49a2ae54b..b6d439811 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -1,36 +1,36 @@
-/*
- * HasFileSystemIF.h
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#ifndef FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
-#define FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-class HasFileSystemIF {
-public:
-
-	virtual ~HasFileSystemIF() {}
-	/**
-	 * Function to get the MessageQueueId_t of the implementing object
-	 * @return MessageQueueId_t of the object
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	/**
-	 * Function to write to a file
-	 * @param dirname Directory of the file
-	 * @param filename The filename of the file
-	 * @param data The data to write to the file
-	 * @param size The size of the data to write
-	 * @param packetNumber Counts the number of packets. For large files the write procedure must be split in multiple calls to writeToFile
-	 */
-	virtual ReturnValue_t writeToFile(const char* dirname, char* filename, const uint8_t* data, uint32_t size, uint16_t packetNumber) = 0;
-	virtual ReturnValue_t createFile(const char* dirname, const char* filename, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t deleteFile(const char* dirname, const char* filename) = 0;
-};
-
-
-#endif /* FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_ */
+/*
+ * HasFileSystemIF.h
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#ifndef FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+#define FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class HasFileSystemIF {
+public:
+
+	virtual ~HasFileSystemIF() {}
+	/**
+	 * Function to get the MessageQueueId_t of the implementing object
+	 * @return MessageQueueId_t of the object
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	/**
+	 * Function to write to a file
+	 * @param dirname Directory of the file
+	 * @param filename The filename of the file
+	 * @param data The data to write to the file
+	 * @param size The size of the data to write
+	 * @param packetNumber Counts the number of packets. For large files the write procedure must be split in multiple calls to writeToFile
+	 */
+	virtual ReturnValue_t writeToFile(const char* dirname, char* filename, const uint8_t* data, uint32_t size, uint16_t packetNumber) = 0;
+	virtual ReturnValue_t createFile(const char* dirname, const char* filename, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t deleteFile(const char* dirname, const char* filename) = 0;
+};
+
+
+#endif /* FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_ */
diff --git a/memory/HasMemoryIF.h b/memory/HasMemoryIF.h
index 788a86b6d..4096d1b74 100644
--- a/memory/HasMemoryIF.h
+++ b/memory/HasMemoryIF.h
@@ -1,47 +1,47 @@
-#ifndef HASMEMORYIF_H_
-#define HASMEMORYIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-class HasMemoryIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MEMORY_IF;
-	static const ReturnValue_t DO_IT_MYSELF = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t POINTS_TO_VARIABLE = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t POINTS_TO_MEMORY =  MAKE_RETURN_CODE(3);
-	static const ReturnValue_t ACTIVITY_COMPLETED  =  MAKE_RETURN_CODE(4);
-	static const ReturnValue_t POINTS_TO_VECTOR_UINT8 = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t POINTS_TO_VECTOR_UINT16 = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t POINTS_TO_VECTOR_UINT32 = MAKE_RETURN_CODE(7);
-	static const ReturnValue_t POINTS_TO_VECTOR_FLOAT = MAKE_RETURN_CODE(8);
-	static const ReturnValue_t DUMP_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA0);
-	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t INVALID_CONTENT = MAKE_RETURN_CODE(0xE2);
-	static const ReturnValue_t UNALIGNED_ACCESS = MAKE_RETURN_CODE(0xE3);
-	static const ReturnValue_t WRITE_PROTECTED = MAKE_RETURN_CODE(0xE4);
-//	static const ReturnValue_t TARGET_BUSY = MAKE_RETURN_CODE(0xE5);
-	virtual ~HasMemoryIF() {}
-	virtual ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data, uint32_t size, uint8_t** dataPointer) = 0;
-	virtual ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size, uint8_t** dataPointer, uint8_t* dumpTarget ) = 0;
-	/**
-	 * Sets the address of the memory, if possible.
-	 * startAddress is a proposal for an address, or the base address if multiple addresses are set.
-	 */
-	virtual ReturnValue_t setAddress( uint32_t* startAddress ) { return HasReturnvaluesIF::RETURN_FAILED; }
-	static bool memAccessWasSuccessful(ReturnValue_t result) {
-		switch (result) {
-		case DO_IT_MYSELF:
-		case POINTS_TO_MEMORY:
-		case POINTS_TO_VARIABLE:
-		case HasReturnvaluesIF::RETURN_OK:
-		case ACTIVITY_COMPLETED:
-			return true;
-		default:
-			return false;
-		}
-	}
-};
-
-
-#endif /* HASMEMORYIF_H_ */
+#ifndef HASMEMORYIF_H_
+#define HASMEMORYIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class HasMemoryIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MEMORY_IF;
+	static const ReturnValue_t DO_IT_MYSELF = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t POINTS_TO_VARIABLE = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t POINTS_TO_MEMORY =  MAKE_RETURN_CODE(3);
+	static const ReturnValue_t ACTIVITY_COMPLETED  =  MAKE_RETURN_CODE(4);
+	static const ReturnValue_t POINTS_TO_VECTOR_UINT8 = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t POINTS_TO_VECTOR_UINT16 = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t POINTS_TO_VECTOR_UINT32 = MAKE_RETURN_CODE(7);
+	static const ReturnValue_t POINTS_TO_VECTOR_FLOAT = MAKE_RETURN_CODE(8);
+	static const ReturnValue_t DUMP_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA0);
+	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
+	static const ReturnValue_t INVALID_CONTENT = MAKE_RETURN_CODE(0xE2);
+	static const ReturnValue_t UNALIGNED_ACCESS = MAKE_RETURN_CODE(0xE3);
+	static const ReturnValue_t WRITE_PROTECTED = MAKE_RETURN_CODE(0xE4);
+//	static const ReturnValue_t TARGET_BUSY = MAKE_RETURN_CODE(0xE5);
+	virtual ~HasMemoryIF() {}
+	virtual ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data, uint32_t size, uint8_t** dataPointer) = 0;
+	virtual ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size, uint8_t** dataPointer, uint8_t* dumpTarget ) = 0;
+	/**
+	 * Sets the address of the memory, if possible.
+	 * startAddress is a proposal for an address, or the base address if multiple addresses are set.
+	 */
+	virtual ReturnValue_t setAddress( uint32_t* startAddress ) { return HasReturnvaluesIF::RETURN_FAILED; }
+	static bool memAccessWasSuccessful(ReturnValue_t result) {
+		switch (result) {
+		case DO_IT_MYSELF:
+		case POINTS_TO_MEMORY:
+		case POINTS_TO_VARIABLE:
+		case HasReturnvaluesIF::RETURN_OK:
+		case ACTIVITY_COMPLETED:
+			return true;
+		default:
+			return false;
+		}
+	}
+};
+
+
+#endif /* HASMEMORYIF_H_ */
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index c74b7d9f9..2daddf634 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -1,193 +1,193 @@
-#include "../globalfunctions/CRC.h"
-#include "../memory/MemoryHelper.h"
-#include "../memory/MemoryMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../serialize/EndianConverter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
-		MessageQueueIF* useThisQueue):
-		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(nullptr),
-		ipcAddress(), lastCommand(CommandMessage::CMD_NONE), busy(false) {
-}
-
-ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
-	lastSender = message->getSender();
-	lastCommand = message->getCommand();
-	if (busy) {
-		sif::debug << "MemHelper: Busy!" << std::endl;
-	}
-	switch (lastCommand) {
-	case MemoryMessage::CMD_MEMORY_DUMP:
-		handleMemoryCheckOrDump(message);
-		return RETURN_OK;
-	case MemoryMessage::CMD_MEMORY_LOAD:
-		handleMemoryLoad(message);
-		return RETURN_OK;
-	case MemoryMessage::CMD_MEMORY_CHECK:
-		handleMemoryCheckOrDump(message);
-		return RETURN_OK;
-	default:
-		lastCommand = CommandMessage::CMD_NONE;
-		return UNKNOWN_CMD;
-	}
-}
-
-void MemoryHelper::completeLoad(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
-	busy = false;
-	switch (errorCode) {
-	case HasMemoryIF::DO_IT_MYSELF:
-		busy = true;
-		return;
-	case HasMemoryIF::POINTS_TO_MEMORY:
-		memcpy(copyHere, dataToCopy, size);
-		break;
-	case HasMemoryIF::POINTS_TO_VARIABLE:
-		EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
-		break;
-	case HasMemoryIF::ACTIVITY_COMPLETED:
-	case RETURN_OK:
-		break;
-	default:
-		ipcStore->deleteData(ipcAddress);
-		CommandMessage reply;
-		MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
-				MemoryMessage::CMD_MEMORY_LOAD);
-		queueToUse->sendMessage(lastSender, &reply);
-		return;
-	}
-	//Only reached on success
-	CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
-	queueToUse->sendMessage(lastSender, &reply);
-	ipcStore->deleteData(ipcAddress);
-}
-
-void MemoryHelper::completeDump(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size) {
-	busy = false;
-	CommandMessage reply;
-	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
-	switch (errorCode) {
-	case HasMemoryIF::DO_IT_MYSELF:
-		busy = true;
-		return;
-	case HasReturnvaluesIF::RETURN_OK:
-	case HasMemoryIF::POINTS_TO_MEMORY:
-	case HasMemoryIF::POINTS_TO_VARIABLE:
-		//"data" must be valid pointer!
-		if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
-			EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
-		} else {
-			memcpy(reservedSpaceInIPC, dataToCopy, size);
-		}
-		/* NO BREAK falls through*/
-	case HasMemoryIF::ACTIVITY_COMPLETED:
-		switch (lastCommand) {
-		case MemoryMessage::CMD_MEMORY_DUMP: {
-			MemoryMessage::setMemoryDumpReply(&reply, ipcAddress);
-			break;
-		}
-		case MemoryMessage::CMD_MEMORY_CHECK: {
-			uint16_t crc = CRC::crc16ccitt(reservedSpaceInIPC, size);
-			//Delete data immediately, was temporary.
-			ipcStore->deleteData(ipcAddress);
-			MemoryMessage::setMemoryCheckReply(&reply, crc);
-			break;
-		}
-		default:
-			//This should never happen!
-			//Is it ok to send message? Otherwise: return;
-			ipcStore->deleteData(ipcAddress);
-			reply.setParameter(STATE_MISMATCH);
-			break;
-		}
-		break;
-	case HasMemoryIF::DUMP_NOT_SUPPORTED:
-		if (lastCommand == MemoryMessage::CMD_MEMORY_CHECK){
-			MemoryMessage::setMemoryCheckReply(&reply, 0);
-			MemoryMessage::setCrcReturnValue(&reply,HasMemoryIF::DUMP_NOT_SUPPORTED);
-		}
-		ipcStore->deleteData(ipcAddress);
-		break;
-	default:
-		//Reply is already set to REJECTED.
-		ipcStore->deleteData(ipcAddress);
-		break;
-	}
-	if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
-		reply.clear();
-	}
-}
-
-void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
-		uint32_t totalSize, uint8_t datatypeSize) {
-	if (totalSize % datatypeSize != 0){
-		return;
-	}
-
-	while (totalSize > 0){
-		EndianConverter::convertBigEndian(out,in,datatypeSize);
-		out += datatypeSize;
-		in += datatypeSize;
-		totalSize -= datatypeSize;
-	}
-}
-
-MemoryHelper::~MemoryHelper() {
-	//Nothing to destroy
-}
-
-void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
-	uint32_t address = MemoryMessage::getAddress(message);
-	ipcAddress = MemoryMessage::getStoreID(message);
-	const uint8_t* p_data = NULL;
-	uint8_t* dataPointer = NULL;
-	size_t size = 0;
-	ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
-	if (returnCode == RETURN_OK) {
-		returnCode = workOnThis->handleMemoryLoad(address, p_data, size,
-				&dataPointer);
-		completeLoad(returnCode, p_data, size, dataPointer);
-	} else {
-		//At least inform sender.
-		CommandMessage reply;
-		MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
-				MemoryMessage::CMD_MEMORY_LOAD);
-		queueToUse->sendMessage(lastSender, &reply);
-	}
-}
-
-void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
-	uint32_t address = MemoryMessage::getAddress(message);
-	uint32_t size = MemoryMessage::getLength(message);
-	uint8_t* dataPointer = NULL;
-	ReturnValue_t returnCode = ipcStore->getFreeElement(&ipcAddress, size,
-			&reservedSpaceInIPC);
-	if (returnCode == RETURN_OK) {
-		returnCode = workOnThis->handleMemoryDump(address, size, &dataPointer,
-				reservedSpaceInIPC);
-		completeDump(returnCode, dataPointer, size);
-	} else {
-		CommandMessage reply;
-		MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
-		queueToUse->sendMessage(lastSender, &reply);
-	}
-}
-
-ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
-	if(queueToUse_ == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	this->queueToUse = queueToUse_;
-	return initialize();
-}
-
-ReturnValue_t MemoryHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore != nullptr) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
+#include "../globalfunctions/CRC.h"
+#include "../memory/MemoryHelper.h"
+#include "../memory/MemoryMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/EndianConverter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
+		MessageQueueIF* useThisQueue):
+		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(nullptr),
+		ipcAddress(), lastCommand(CommandMessage::CMD_NONE), busy(false) {
+}
+
+ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
+	lastSender = message->getSender();
+	lastCommand = message->getCommand();
+	if (busy) {
+		sif::debug << "MemHelper: Busy!" << std::endl;
+	}
+	switch (lastCommand) {
+	case MemoryMessage::CMD_MEMORY_DUMP:
+		handleMemoryCheckOrDump(message);
+		return RETURN_OK;
+	case MemoryMessage::CMD_MEMORY_LOAD:
+		handleMemoryLoad(message);
+		return RETURN_OK;
+	case MemoryMessage::CMD_MEMORY_CHECK:
+		handleMemoryCheckOrDump(message);
+		return RETURN_OK;
+	default:
+		lastCommand = CommandMessage::CMD_NONE;
+		return UNKNOWN_CMD;
+	}
+}
+
+void MemoryHelper::completeLoad(ReturnValue_t errorCode,
+		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
+	busy = false;
+	switch (errorCode) {
+	case HasMemoryIF::DO_IT_MYSELF:
+		busy = true;
+		return;
+	case HasMemoryIF::POINTS_TO_MEMORY:
+		memcpy(copyHere, dataToCopy, size);
+		break;
+	case HasMemoryIF::POINTS_TO_VARIABLE:
+		EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
+		break;
+	case HasMemoryIF::ACTIVITY_COMPLETED:
+	case RETURN_OK:
+		break;
+	default:
+		ipcStore->deleteData(ipcAddress);
+		CommandMessage reply;
+		MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
+				MemoryMessage::CMD_MEMORY_LOAD);
+		queueToUse->sendMessage(lastSender, &reply);
+		return;
+	}
+	//Only reached on success
+	CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
+	queueToUse->sendMessage(lastSender, &reply);
+	ipcStore->deleteData(ipcAddress);
+}
+
+void MemoryHelper::completeDump(ReturnValue_t errorCode,
+		const uint8_t* dataToCopy, const uint32_t size) {
+	busy = false;
+	CommandMessage reply;
+	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
+	switch (errorCode) {
+	case HasMemoryIF::DO_IT_MYSELF:
+		busy = true;
+		return;
+	case HasReturnvaluesIF::RETURN_OK:
+	case HasMemoryIF::POINTS_TO_MEMORY:
+	case HasMemoryIF::POINTS_TO_VARIABLE:
+		//"data" must be valid pointer!
+		if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
+			EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
+		} else {
+			memcpy(reservedSpaceInIPC, dataToCopy, size);
+		}
+		/* NO BREAK falls through*/
+	case HasMemoryIF::ACTIVITY_COMPLETED:
+		switch (lastCommand) {
+		case MemoryMessage::CMD_MEMORY_DUMP: {
+			MemoryMessage::setMemoryDumpReply(&reply, ipcAddress);
+			break;
+		}
+		case MemoryMessage::CMD_MEMORY_CHECK: {
+			uint16_t crc = CRC::crc16ccitt(reservedSpaceInIPC, size);
+			//Delete data immediately, was temporary.
+			ipcStore->deleteData(ipcAddress);
+			MemoryMessage::setMemoryCheckReply(&reply, crc);
+			break;
+		}
+		default:
+			//This should never happen!
+			//Is it ok to send message? Otherwise: return;
+			ipcStore->deleteData(ipcAddress);
+			reply.setParameter(STATE_MISMATCH);
+			break;
+		}
+		break;
+	case HasMemoryIF::DUMP_NOT_SUPPORTED:
+		if (lastCommand == MemoryMessage::CMD_MEMORY_CHECK){
+			MemoryMessage::setMemoryCheckReply(&reply, 0);
+			MemoryMessage::setCrcReturnValue(&reply,HasMemoryIF::DUMP_NOT_SUPPORTED);
+		}
+		ipcStore->deleteData(ipcAddress);
+		break;
+	default:
+		//Reply is already set to REJECTED.
+		ipcStore->deleteData(ipcAddress);
+		break;
+	}
+	if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
+		reply.clear();
+	}
+}
+
+void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
+		uint32_t totalSize, uint8_t datatypeSize) {
+	if (totalSize % datatypeSize != 0){
+		return;
+	}
+
+	while (totalSize > 0){
+		EndianConverter::convertBigEndian(out,in,datatypeSize);
+		out += datatypeSize;
+		in += datatypeSize;
+		totalSize -= datatypeSize;
+	}
+}
+
+MemoryHelper::~MemoryHelper() {
+	//Nothing to destroy
+}
+
+void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
+	uint32_t address = MemoryMessage::getAddress(message);
+	ipcAddress = MemoryMessage::getStoreID(message);
+	const uint8_t* p_data = NULL;
+	uint8_t* dataPointer = NULL;
+	size_t size = 0;
+	ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
+	if (returnCode == RETURN_OK) {
+		returnCode = workOnThis->handleMemoryLoad(address, p_data, size,
+				&dataPointer);
+		completeLoad(returnCode, p_data, size, dataPointer);
+	} else {
+		//At least inform sender.
+		CommandMessage reply;
+		MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
+				MemoryMessage::CMD_MEMORY_LOAD);
+		queueToUse->sendMessage(lastSender, &reply);
+	}
+}
+
+void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
+	uint32_t address = MemoryMessage::getAddress(message);
+	uint32_t size = MemoryMessage::getLength(message);
+	uint8_t* dataPointer = NULL;
+	ReturnValue_t returnCode = ipcStore->getFreeElement(&ipcAddress, size,
+			&reservedSpaceInIPC);
+	if (returnCode == RETURN_OK) {
+		returnCode = workOnThis->handleMemoryDump(address, size, &dataPointer,
+				reservedSpaceInIPC);
+		completeDump(returnCode, dataPointer, size);
+	} else {
+		CommandMessage reply;
+		MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
+		queueToUse->sendMessage(lastSender, &reply);
+	}
+}
+
+ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
+	if(queueToUse_ == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	this->queueToUse = queueToUse_;
+	return initialize();
+}
+
+ReturnValue_t MemoryHelper::initialize() {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore != nullptr) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
diff --git a/memory/MemoryHelper.h b/memory/MemoryHelper.h
index 90dbafb49..418cf50d3 100644
--- a/memory/MemoryHelper.h
+++ b/memory/MemoryHelper.h
@@ -1,37 +1,37 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYHELPER_H_
-#define FRAMEWORK_MEMORY_MEMORYHELPER_H_
-#include "../ipc/CommandMessage.h"
-#include "../memory/AcceptsMemoryMessagesIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../ipc/MessageQueueIF.h"
-
-class MemoryHelper : public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER;
-	static const ReturnValue_t UNKNOWN_CMD = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2);
-	static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3);
-private:
-	HasMemoryIF* workOnThis;
-	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore = nullptr;
-	store_address_t ipcAddress;
-	Command_t lastCommand;
-	MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
-	uint8_t* reservedSpaceInIPC = nullptr;
-	bool busy;
-	void handleMemoryLoad(CommandMessage* message);
-	void handleMemoryCheckOrDump(CommandMessage* message);
-	ReturnValue_t initialize();
-public:
-	ReturnValue_t handleMemoryCommand(CommandMessage* message);
-	void completeLoad( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0, uint8_t* copyHere = NULL );
-	void completeDump(  ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0);
-	void swapMatrixCopy( uint8_t *out, const uint8_t *in, uint32_t totalSize, uint8_t datatypeSize);
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
-	MemoryHelper( HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue );
-	~MemoryHelper();
-};
-#endif /* MEMORYHELPER_H_ */
+#ifndef FRAMEWORK_MEMORY_MEMORYHELPER_H_
+#define FRAMEWORK_MEMORY_MEMORYHELPER_H_
+#include "../ipc/CommandMessage.h"
+#include "../memory/AcceptsMemoryMessagesIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class MemoryHelper : public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER;
+	static const ReturnValue_t UNKNOWN_CMD = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
+	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2);
+	static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3);
+private:
+	HasMemoryIF* workOnThis;
+	MessageQueueIF* queueToUse;
+	StorageManagerIF* ipcStore = nullptr;
+	store_address_t ipcAddress;
+	Command_t lastCommand;
+	MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
+	uint8_t* reservedSpaceInIPC = nullptr;
+	bool busy;
+	void handleMemoryLoad(CommandMessage* message);
+	void handleMemoryCheckOrDump(CommandMessage* message);
+	ReturnValue_t initialize();
+public:
+	ReturnValue_t handleMemoryCommand(CommandMessage* message);
+	void completeLoad( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0, uint8_t* copyHere = NULL );
+	void completeDump(  ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0);
+	void swapMatrixCopy( uint8_t *out, const uint8_t *in, uint32_t totalSize, uint8_t datatypeSize);
+	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
+	MemoryHelper( HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue );
+	~MemoryHelper();
+};
+#endif /* MEMORYHELPER_H_ */
diff --git a/memory/MemoryMessage.cpp b/memory/MemoryMessage.cpp
index 16a60502c..4e077dee8 100644
--- a/memory/MemoryMessage.cpp
+++ b/memory/MemoryMessage.cpp
@@ -1,112 +1,112 @@
-#include "../memory/MemoryMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-MemoryMessage::MemoryMessage() {
-}
-
-uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-store_address_t MemoryMessage::getStoreID(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-uint32_t MemoryMessage::getLength(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
-		uint32_t address, uint32_t length) {
-	message->setCommand(CMD_MEMORY_DUMP);
-	message->setParameter( address );
-	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_address_t storageID) {
-	message->setCommand(REPLY_MEMORY_DUMP);
-	message->setParameter2( storageID.raw );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
-		uint32_t address, store_address_t storageID) {
-	message->setCommand(CMD_MEMORY_LOAD);
-	message->setParameter( address );
-	message->setParameter2( storageID.raw );
-}
-
-ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-void MemoryMessage::clear(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case CMD_MEMORY_LOAD:
-	case REPLY_MEMORY_DUMP: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreID(message));
-		}
-	}
-	/* NO BREAK falls through*/
-	case CMD_MEMORY_DUMP:
-	case CMD_MEMORY_CHECK:
-	case REPLY_MEMORY_CHECK:
-	case END_OF_MEMORY_COPY:
-		message->setCommand(CommandMessage::CMD_NONE);
-		message->setParameter(0);
-		message->setParameter2(0);
-		break;
-		}
-}
-
-ReturnValue_t MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
-		uint32_t address, uint32_t length) {
-	message->setCommand(CMD_MEMORY_CHECK);
-	message->setParameter( address );
-	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message,
-		uint16_t crc) {
-	message->setCommand(REPLY_MEMORY_CHECK);
-	message->setParameter( crc );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void MemoryMessage::setCrcReturnValue(CommandMessage* message, ReturnValue_t returnValue){
-	message->setParameter(returnValue<<16);
-};
-
-uint16_t MemoryMessage::getCrc(const CommandMessage* message) {
-	return (uint16_t)(message->getParameter());
-}
-
-ReturnValue_t MemoryMessage::getCrcReturnValue(const CommandMessage* message){
-	return (message->getParameter()>>16);
-}
-
-Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
-		ReturnValue_t errorCode, Command_t initialCommand) {
-	message->setCommand(REPLY_MEMORY_FAILED);
-	message->setParameter(errorCode);
-	message->setParameter2(initialCommand);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
-	message->setCommand(END_OF_MEMORY_COPY);
-	message->setParameter(0);
-	message->setParameter2(0);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
+#include "../memory/MemoryMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+MemoryMessage::MemoryMessage() {
+}
+
+uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+store_address_t MemoryMessage::getStoreID(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+uint32_t MemoryMessage::getLength(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
+		uint32_t address, uint32_t length) {
+	message->setCommand(CMD_MEMORY_DUMP);
+	message->setParameter( address );
+	message->setParameter2( length );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_address_t storageID) {
+	message->setCommand(REPLY_MEMORY_DUMP);
+	message->setParameter2( storageID.raw );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
+		uint32_t address, store_address_t storageID) {
+	message->setCommand(CMD_MEMORY_LOAD);
+	message->setParameter( address );
+	message->setParameter2( storageID.raw );
+}
+
+ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+void MemoryMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_MEMORY_LOAD:
+	case REPLY_MEMORY_DUMP: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreID(message));
+		}
+	}
+	/* NO BREAK falls through*/
+	case CMD_MEMORY_DUMP:
+	case CMD_MEMORY_CHECK:
+	case REPLY_MEMORY_CHECK:
+	case END_OF_MEMORY_COPY:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+		}
+}
+
+ReturnValue_t MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
+		uint32_t address, uint32_t length) {
+	message->setCommand(CMD_MEMORY_CHECK);
+	message->setParameter( address );
+	message->setParameter2( length );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message,
+		uint16_t crc) {
+	message->setCommand(REPLY_MEMORY_CHECK);
+	message->setParameter( crc );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void MemoryMessage::setCrcReturnValue(CommandMessage* message, ReturnValue_t returnValue){
+	message->setParameter(returnValue<<16);
+};
+
+uint16_t MemoryMessage::getCrc(const CommandMessage* message) {
+	return (uint16_t)(message->getParameter());
+}
+
+ReturnValue_t MemoryMessage::getCrcReturnValue(const CommandMessage* message){
+	return (message->getParameter()>>16);
+}
+
+Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
+		ReturnValue_t errorCode, Command_t initialCommand) {
+	message->setCommand(REPLY_MEMORY_FAILED);
+	message->setParameter(errorCode);
+	message->setParameter2(initialCommand);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
+	message->setCommand(END_OF_MEMORY_COPY);
+	message->setParameter(0);
+	message->setParameter2(0);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
diff --git a/memory/MemoryMessage.h b/memory/MemoryMessage.h
index af936c1fb..a366eb9a3 100644
--- a/memory/MemoryMessage.h
+++ b/memory/MemoryMessage.h
@@ -1,39 +1,39 @@
-#ifndef MEMORYMESSAGE_H_
-#define MEMORYMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-
-
-class MemoryMessage {
-private:
-	MemoryMessage(); //A private ctor inhibits instantiation
-public:
-	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 );
-	static const Command_t REPLY_MEMORY_DUMP = MAKE_COMMAND_ID( 0x10 );
-	static const Command_t REPLY_MEMORY_CHECK = MAKE_COMMAND_ID( 0x30 );
-	static const Command_t REPLY_MEMORY_FAILED = MAKE_COMMAND_ID( 0xE0 );
-	static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
-
-	static uint32_t getAddress( const CommandMessage* message );
-	static store_address_t getStoreID( const CommandMessage* message );
-	static uint32_t getLength( const CommandMessage* message );
-	static ReturnValue_t getErrorCode( const CommandMessage* message );
-	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
-	static void setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
-	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
-	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
-	static ReturnValue_t setMemoryCopyEnd( CommandMessage* message);
-	static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue);
-	static uint16_t getCrc( const CommandMessage* message );
-	static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
-	static Command_t getInitialCommand( const CommandMessage* message );
-	static void clear(CommandMessage* message);
-};
-
-#endif /* MEMORYMESSAGE_H_ */
+#ifndef MEMORYMESSAGE_H_
+#define MEMORYMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+
+class MemoryMessage {
+private:
+	MemoryMessage(); //A private ctor inhibits instantiation
+public:
+	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 );
+	static const Command_t REPLY_MEMORY_DUMP = MAKE_COMMAND_ID( 0x10 );
+	static const Command_t REPLY_MEMORY_CHECK = MAKE_COMMAND_ID( 0x30 );
+	static const Command_t REPLY_MEMORY_FAILED = MAKE_COMMAND_ID( 0xE0 );
+	static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
+
+	static uint32_t getAddress( const CommandMessage* message );
+	static store_address_t getStoreID( const CommandMessage* message );
+	static uint32_t getLength( const CommandMessage* message );
+	static ReturnValue_t getErrorCode( const CommandMessage* message );
+	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
+	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
+	static void setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
+	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
+	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
+	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
+	static ReturnValue_t setMemoryCopyEnd( CommandMessage* message);
+	static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue);
+	static uint16_t getCrc( const CommandMessage* message );
+	static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
+	static Command_t getInitialCommand( const CommandMessage* message );
+	static void clear(CommandMessage* message);
+};
+
+#endif /* MEMORYMESSAGE_H_ */
diff --git a/memory/MemoryProxyIF.h b/memory/MemoryProxyIF.h
index a30165c39..31045d3f9 100644
--- a/memory/MemoryProxyIF.h
+++ b/memory/MemoryProxyIF.h
@@ -1,22 +1,22 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-
-#include "../memory/AcceptsMemoryMessagesIF.h"
-
-/**
- * This was a nice idea to transparently forward incoming messages to another object.
- * But it doesn't work like that.
- */
-class MemoryProxyIF : public AcceptsMemoryMessagesIF {
-public:
-	virtual MessageQueueId_t getProxyQueue() const = 0;
-	MessageQueueId_t getCommandQueue() const {
-		return getProxyQueue();
-	}
-	virtual ~MemoryProxyIF() {}
-
-};
-
-
-
-#endif /* FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ */
+#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
+#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
+
+#include "../memory/AcceptsMemoryMessagesIF.h"
+
+/**
+ * This was a nice idea to transparently forward incoming messages to another object.
+ * But it doesn't work like that.
+ */
+class MemoryProxyIF : public AcceptsMemoryMessagesIF {
+public:
+	virtual MessageQueueId_t getProxyQueue() const = 0;
+	MessageQueueId_t getCommandQueue() const {
+		return getProxyQueue();
+	}
+	virtual ~MemoryProxyIF() {}
+
+};
+
+
+
+#endif /* FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ */
diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h
index eade3613e..c3abaaaff 100644
--- a/modes/HasModesIF.h
+++ b/modes/HasModesIF.h
@@ -1,57 +1,57 @@
-/**
- * @file	HasModesIF.h
- * @brief	This file defines the HasModesIF class.
- * @date	20.06.2013
- * @author	baetz
- */
-
-#ifndef HASMODESIF_H_
-#define HASMODESIF_H_
-
-#include "../events/Event.h"
-#include "../modes/ModeHelper.h"
-#include "../modes/ModeMessage.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
-
-
-class HasModesIF {
-	friend class ModeHelper;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MODES_IF;
-	static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t TRANS_NOT_ALLOWED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t IN_TRANSITION = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-	static const Event CHANGING_MODE = MAKE_EVENT(0, SEVERITY::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
-	static const Event MODE_INFO = MAKE_EVENT(1, SEVERITY::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
-	static const Event FALLBACK_FAILED = MAKE_EVENT(2, SEVERITY::HIGH);
-	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, SEVERITY::HIGH);
-	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, SEVERITY::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
-	static const Event FORCING_MODE = MAKE_EVENT(6, SEVERITY::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
-	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, SEVERITY::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
-
-	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	static const Submode_t SUBMODE_NONE = 0; //!< To avoid checks against magic number "0".
-	virtual ~HasModesIF() {
-	}
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
-protected:
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	virtual void startTransition(Mode_t mode, Submode_t submode) {
-	}
-	virtual void setToExternalControl() {
-	}
-	virtual void announceMode(bool recursive) {
-	}
-};
-
-#endif /* HASMODESIF_H_ */
+/**
+ * @file	HasModesIF.h
+ * @brief	This file defines the HasModesIF class.
+ * @date	20.06.2013
+ * @author	baetz
+ */
+
+#ifndef HASMODESIF_H_
+#define HASMODESIF_H_
+
+#include "../events/Event.h"
+#include "../modes/ModeHelper.h"
+#include "../modes/ModeMessage.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <stdint.h>
+
+
+class HasModesIF {
+	friend class ModeHelper;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MODES_IF;
+	static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t TRANS_NOT_ALLOWED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t IN_TRANSITION = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
+	static const Event CHANGING_MODE = MAKE_EVENT(0, SEVERITY::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
+	static const Event MODE_INFO = MAKE_EVENT(1, SEVERITY::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
+	static const Event FALLBACK_FAILED = MAKE_EVENT(2, SEVERITY::HIGH);
+	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, SEVERITY::HIGH);
+	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, SEVERITY::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
+	static const Event FORCING_MODE = MAKE_EVENT(6, SEVERITY::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
+	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, SEVERITY::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
+
+	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	static const Submode_t SUBMODE_NONE = 0; //!< To avoid checks against magic number "0".
+	virtual ~HasModesIF() {
+	}
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
+protected:
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	virtual void startTransition(Mode_t mode, Submode_t submode) {
+	}
+	virtual void setToExternalControl() {
+	}
+	virtual void announceMode(bool recursive) {
+	}
+};
+
+#endif /* HASMODESIF_H_ */
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index d6cbf2c9f..e7fc0bcb4 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,135 +1,135 @@
-#include "../modes/HasModesIF.h"
-#include "../modes/ModeHelper.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-ModeHelper::ModeHelper(HasModesIF *owner) :
-		commandedMode(HasModesIF::MODE_OFF),
-		commandedSubmode(HasModesIF::SUBMODE_NONE),
-		owner(owner), forced(false) {}
-
-ModeHelper::~ModeHelper() {
-
-}
-
-ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
-	CommandMessage reply;
-	Mode_t mode;
-	Submode_t submode;
-	switch (command->getCommand()) {
-	case ModeMessage::CMD_MODE_COMMAND_FORCED:
-		forced = true;
-		/* NO BREAK falls through*/
-	case ModeMessage::CMD_MODE_COMMAND: {
-		mode = ModeMessage::getMode(command);
-		submode = ModeMessage::getSubmode(command);
-		uint32_t timeout;
-		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			ModeMessage::cantReachMode(&reply, result);
-			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-			        owner->getCommandQueue());
-			break;
-		}
-		//Free to start transition
-		theOneWhoCommandedAMode = command->getSender();
-		commandedMode = mode;
-		commandedSubmode = submode;
-
-		if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
-				&& (theOneWhoCommandedAMode != parentQueueId)) {
-			owner->setToExternalControl();
-		}
-
-		countdown.setTimeout(timeout);
-		owner->startTransition(mode, submode);
-	}
-		break;
-	case ModeMessage::CMD_MODE_READ: {
-		owner->getMode(&mode, &submode);
-		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
-				submode);
-		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-		       owner->getCommandQueue());
-	}
-		break;
-	case ModeMessage::CMD_MODE_ANNOUNCE:
-		owner->announceMode(false);
-		break;
-	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
-		owner->announceMode(true);
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
-	setParentQueue(parentQueueId);
-	return initialize();
-}
-
-void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
-	forced = false;
-	sendModeReplyMessage(ownerMode, ownerSubmode);
-	sendModeInfoMessage(ownerMode, ownerSubmode);
-	theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
-}
-
-void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
-		Submode_t ownerSubmode) {
-	CommandMessage reply;
-	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
-	{
-		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
-		{
-			ModeMessage::setModeMessage(&reply,
-					ModeMessage::REPLY_WRONG_MODE_REPLY, ownerMode,
-					ownerSubmode);
-		}
-		else
-		{
-			ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY,
-					ownerMode, ownerSubmode);
-		}
-		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
-		        owner->getCommandQueue());
-	}
-}
-
-void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
-		Submode_t ownerSubmode) {
-	CommandMessage reply;
-	if (theOneWhoCommandedAMode != parentQueueId
-			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
-	{
-		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
-				ownerMode, ownerSubmode);
-		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
-		        owner->getCommandQueue());
-	}
-}
-
-void ModeHelper::startTimer(uint32_t timeoutMs) {
-	countdown.setTimeout(timeoutMs);
-}
-
-void ModeHelper::setParentQueue(MessageQueueId_t parentQueueId) {
-	this->parentQueueId = parentQueueId;
-}
-
-ReturnValue_t ModeHelper::initialize(void) {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-bool ModeHelper::isTimedOut() {
-	return countdown.hasTimedOut();
-}
-
-bool ModeHelper::isForced() {
-	return forced;
-}
-
-void ModeHelper::setForced(bool forced) {
-	this->forced = forced;
-}
+#include "../modes/HasModesIF.h"
+#include "../modes/ModeHelper.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+ModeHelper::ModeHelper(HasModesIF *owner) :
+		commandedMode(HasModesIF::MODE_OFF),
+		commandedSubmode(HasModesIF::SUBMODE_NONE),
+		owner(owner), forced(false) {}
+
+ModeHelper::~ModeHelper() {
+
+}
+
+ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
+	CommandMessage reply;
+	Mode_t mode;
+	Submode_t submode;
+	switch (command->getCommand()) {
+	case ModeMessage::CMD_MODE_COMMAND_FORCED:
+		forced = true;
+		/* NO BREAK falls through*/
+	case ModeMessage::CMD_MODE_COMMAND: {
+		mode = ModeMessage::getMode(command);
+		submode = ModeMessage::getSubmode(command);
+		uint32_t timeout;
+		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			ModeMessage::cantReachMode(&reply, result);
+			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+			        owner->getCommandQueue());
+			break;
+		}
+		//Free to start transition
+		theOneWhoCommandedAMode = command->getSender();
+		commandedMode = mode;
+		commandedSubmode = submode;
+
+		if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
+				&& (theOneWhoCommandedAMode != parentQueueId)) {
+			owner->setToExternalControl();
+		}
+
+		countdown.setTimeout(timeout);
+		owner->startTransition(mode, submode);
+	}
+		break;
+	case ModeMessage::CMD_MODE_READ: {
+		owner->getMode(&mode, &submode);
+		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
+				submode);
+		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+		       owner->getCommandQueue());
+	}
+		break;
+	case ModeMessage::CMD_MODE_ANNOUNCE:
+		owner->announceMode(false);
+		break;
+	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
+		owner->announceMode(true);
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
+	setParentQueue(parentQueueId);
+	return initialize();
+}
+
+void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
+	forced = false;
+	sendModeReplyMessage(ownerMode, ownerSubmode);
+	sendModeInfoMessage(ownerMode, ownerSubmode);
+	theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
+}
+
+void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
+	CommandMessage reply;
+	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
+	{
+		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
+		{
+			ModeMessage::setModeMessage(&reply,
+					ModeMessage::REPLY_WRONG_MODE_REPLY, ownerMode,
+					ownerSubmode);
+		}
+		else
+		{
+			ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY,
+					ownerMode, ownerSubmode);
+		}
+		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
+		        owner->getCommandQueue());
+	}
+}
+
+void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
+	CommandMessage reply;
+	if (theOneWhoCommandedAMode != parentQueueId
+			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
+	{
+		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
+				ownerMode, ownerSubmode);
+		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
+		        owner->getCommandQueue());
+	}
+}
+
+void ModeHelper::startTimer(uint32_t timeoutMs) {
+	countdown.setTimeout(timeoutMs);
+}
+
+void ModeHelper::setParentQueue(MessageQueueId_t parentQueueId) {
+	this->parentQueueId = parentQueueId;
+}
+
+ReturnValue_t ModeHelper::initialize(void) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+bool ModeHelper::isTimedOut() {
+	return countdown.hasTimedOut();
+}
+
+bool ModeHelper::isForced() {
+	return forced;
+}
+
+void ModeHelper::setForced(bool forced) {
+	this->forced = forced;
+}
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index 1e51bce5e..02cf5799b 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -1,53 +1,53 @@
-#ifndef MODEHELPER_H_
-#define MODEHELPER_H_
-
-#include "../ipc/MessageQueueIF.h"
-#include "../modes/ModeMessage.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../timemanager/Countdown.h"
-
-class HasModesIF;
-
-class ModeHelper {
-public:
-	MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
-	Mode_t commandedMode;
-	Submode_t commandedSubmode;
-
-	ModeHelper(HasModesIF *owner);
-	virtual ~ModeHelper();
-
-	ReturnValue_t handleModeCommand(CommandMessage *message);
-
-	/**
-	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
-	 */
-	void setParentQueue(MessageQueueId_t parentQueueId);
-
-	ReturnValue_t initialize(MessageQueueId_t parentQueueId);
-
-	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
-
-	void modeChanged(Mode_t mode, Submode_t submode);
-
-	void startTimer(uint32_t timeoutMs);
-
-	bool isTimedOut();
-
-	bool isForced();
-
-	void setForced(bool forced);
-protected:
-	HasModesIF *owner;
-	MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
-
-	Countdown countdown;
-
-	bool forced;
-private:
-	void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
-	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
-};
-
-#endif /* MODEHELPER_H_ */
+#ifndef MODEHELPER_H_
+#define MODEHELPER_H_
+
+#include "../ipc/MessageQueueIF.h"
+#include "../modes/ModeMessage.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Countdown.h"
+
+class HasModesIF;
+
+class ModeHelper {
+public:
+	MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
+	Mode_t commandedMode;
+	Submode_t commandedSubmode;
+
+	ModeHelper(HasModesIF *owner);
+	virtual ~ModeHelper();
+
+	ReturnValue_t handleModeCommand(CommandMessage *message);
+
+	/**
+	 *
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 */
+	void setParentQueue(MessageQueueId_t parentQueueId);
+
+	ReturnValue_t initialize(MessageQueueId_t parentQueueId);
+
+	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
+
+	void modeChanged(Mode_t mode, Submode_t submode);
+
+	void startTimer(uint32_t timeoutMs);
+
+	bool isTimedOut();
+
+	bool isForced();
+
+	void setForced(bool forced);
+protected:
+	HasModesIF *owner;
+	MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
+
+	Countdown countdown;
+
+	bool forced;
+private:
+	void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
+	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
+};
+
+#endif /* MODEHELPER_H_ */
diff --git a/modes/ModeMessage.cpp b/modes/ModeMessage.cpp
index de3fc69c9..7ad7d06fd 100644
--- a/modes/ModeMessage.cpp
+++ b/modes/ModeMessage.cpp
@@ -1,31 +1,31 @@
-#include "../modes/ModeMessage.h"
-
-Mode_t ModeMessage::getMode(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-Submode_t ModeMessage::getSubmode(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t command,
-		Mode_t mode, Submode_t submode) {
-	message->setCommand( command );
-	message->setParameter( mode );
-	message->setParameter2( submode );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-void ModeMessage::clear(CommandMessage* message) {
-	message->setCommand(CommandMessage::CMD_NONE);
-}
-
-void ModeMessage::cantReachMode(CommandMessage* message, ReturnValue_t reason) {
-	message->setCommand(REPLY_CANT_REACH_MODE);
-	message->setParameter(reason);
-	message->setParameter2(0);
-}
+#include "../modes/ModeMessage.h"
+
+Mode_t ModeMessage::getMode(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+Submode_t ModeMessage::getSubmode(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t command,
+		Mode_t mode, Submode_t submode) {
+	message->setCommand( command );
+	message->setParameter( mode );
+	message->setParameter2( submode );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+void ModeMessage::clear(CommandMessage* message) {
+	message->setCommand(CommandMessage::CMD_NONE);
+}
+
+void ModeMessage::cantReachMode(CommandMessage* message, ReturnValue_t reason) {
+	message->setCommand(REPLY_CANT_REACH_MODE);
+	message->setParameter(reason);
+	message->setParameter2(0);
+}
diff --git a/modes/ModeMessage.h b/modes/ModeMessage.h
index 63624b1df..925f3fc16 100644
--- a/modes/ModeMessage.h
+++ b/modes/ModeMessage.h
@@ -1,40 +1,40 @@
-/**
- * @file	ModeMessage.h
- * @brief	This file defines the ModeMessage class.
- * @date	17.07.2013
- * @author	baetz
- */
-
-#ifndef MODEMESSAGE_H_
-#define MODEMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-
-typedef uint32_t Mode_t;
-typedef uint8_t Submode_t;
-
-class ModeMessage {
-private:
-	ModeMessage();
-public:
-	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
-	static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);	//!> Unrequested info about the current mode (used for composites to inform their container of a changed mode)
-	static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04); //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
-	static const Command_t REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);//!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded and a transition started but was aborted; the parameters contain the mode that was reached
-	static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);//!> Command to read the current mode and reply with a REPLY_MODE_REPLY
-	static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);//!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
-	static const Command_t CMD_MODE_ANNOUNCE_RECURSIVELY = MAKE_COMMAND_ID(0x08);//!> Command to trigger an ModeInfo Event and to send this command to every child. This command does NOT have a reply.
-
-	static Mode_t getMode(const CommandMessage* message);
-	static Submode_t getSubmode(const CommandMessage* message);
-	static ReturnValue_t setModeMessage(CommandMessage* message,
-			Command_t command, Mode_t mode, Submode_t submode);
-	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
-	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
-	static void clear(CommandMessage* message);
-};
-
-#endif /* MODEMESSAGE_H_ */
+/**
+ * @file	ModeMessage.h
+ * @brief	This file defines the ModeMessage class.
+ * @date	17.07.2013
+ * @author	baetz
+ */
+
+#ifndef MODEMESSAGE_H_
+#define MODEMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+
+typedef uint32_t Mode_t;
+typedef uint8_t Submode_t;
+
+class ModeMessage {
+private:
+	ModeMessage();
+public:
+	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
+	static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);	//!> Unrequested info about the current mode (used for composites to inform their container of a changed mode)
+	static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04); //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
+	static const Command_t REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);//!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded and a transition started but was aborted; the parameters contain the mode that was reached
+	static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);//!> Command to read the current mode and reply with a REPLY_MODE_REPLY
+	static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);//!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
+	static const Command_t CMD_MODE_ANNOUNCE_RECURSIVELY = MAKE_COMMAND_ID(0x08);//!> Command to trigger an ModeInfo Event and to send this command to every child. This command does NOT have a reply.
+
+	static Mode_t getMode(const CommandMessage* message);
+	static Submode_t getSubmode(const CommandMessage* message);
+	static ReturnValue_t setModeMessage(CommandMessage* message,
+			Command_t command, Mode_t mode, Submode_t submode);
+	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
+	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
+	static void clear(CommandMessage* message);
+};
+
+#endif /* MODEMESSAGE_H_ */
diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index 6b546bd02..c32c63ef0 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -1,73 +1,73 @@
-#ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
-
-#include "../monitoring/MonitorBase.h"
-#include <cmath>
-
-template<typename T>
-class AbsLimitMonitor: public MonitorBase<T> {
-public:
-	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
-			uint16_t confirmationLimit, T limit, Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE, bool aboveIsViolation = true) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), limit(limit), violationEvent(violationEvent), aboveIsViolation(aboveIsViolation) {
-	}
-	virtual ~AbsLimitMonitor() {
-	}
-	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
-		*crossedLimit = limit;
-		if (aboveIsViolation) {
-			if ((std::abs(sample) > limit)) {
-				return MonitoringIF::OUT_OF_RANGE;
-			}
-		} else {
-			if ((std::abs(sample) < limit)) {
-				return MonitoringIF::OUT_OF_RANGE;
-			}
-		}
-		return HasReturnvaluesIF::RETURN_OK; //We're not out of range.
-	}
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
-				parameterId, parameterWrapper, newValues, startAtIndex);
-		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
-			return result;
-		}
-		switch (parameterId) {
-		case 10:
-			parameterWrapper->set(this->limit);
-			break;
-		default:
-			return this->INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	bool isOutOfLimits() {
-		if (this->oldState == MonitoringIF::OUT_OF_RANGE) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	void setLimit(T value) {
-		limit = value;
-	}
-protected:
-	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
-		switch (state) {
-		case MonitoringIF::OUT_OF_RANGE:
-			EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->parameterId);
-			break;
-		default:
-			break;
-		}
-	}
-	T limit;
-	const Event violationEvent;
-	const bool aboveIsViolation;
-};
-
-#endif /* FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
+#define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
+
+#include "../monitoring/MonitorBase.h"
+#include <cmath>
+
+template<typename T>
+class AbsLimitMonitor: public MonitorBase<T> {
+public:
+	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
+			uint16_t confirmationLimit, T limit, Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE, bool aboveIsViolation = true) :
+			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), limit(limit), violationEvent(violationEvent), aboveIsViolation(aboveIsViolation) {
+	}
+	virtual ~AbsLimitMonitor() {
+	}
+	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
+		*crossedLimit = limit;
+		if (aboveIsViolation) {
+			if ((std::abs(sample) > limit)) {
+				return MonitoringIF::OUT_OF_RANGE;
+			}
+		} else {
+			if ((std::abs(sample) < limit)) {
+				return MonitoringIF::OUT_OF_RANGE;
+			}
+		}
+		return HasReturnvaluesIF::RETURN_OK; //We're not out of range.
+	}
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
+				parameterId, parameterWrapper, newValues, startAtIndex);
+		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
+		if (result != this->INVALID_MATRIX_ID) {
+			return result;
+		}
+		switch (parameterId) {
+		case 10:
+			parameterWrapper->set(this->limit);
+			break;
+		default:
+			return this->INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	bool isOutOfLimits() {
+		if (this->oldState == MonitoringIF::OUT_OF_RANGE) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	void setLimit(T value) {
+		limit = value;
+	}
+protected:
+	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+		switch (state) {
+		case MonitoringIF::OUT_OF_RANGE:
+			EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->parameterId);
+			break;
+		default:
+			break;
+		}
+	}
+	T limit;
+	const Event violationEvent;
+	const bool aboveIsViolation;
+};
+
+#endif /* FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ */
diff --git a/monitoring/HasMonitorsIF.h b/monitoring/HasMonitorsIF.h
index be561efd8..85d92b6b9 100644
--- a/monitoring/HasMonitorsIF.h
+++ b/monitoring/HasMonitorsIF.h
@@ -1,30 +1,30 @@
-/**
- * @file	HasMonitorsIF.h
- * @brief	This file defines the HasMonitorsIF class.
- * @date	28.07.2014
- * @author	baetz
- */
-#ifndef HASMONITORSIF_H_
-#define HASMONITORSIF_H_
-
-#include "../events/EventReportingProxyIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-class HasMonitorsIF {
-public:
-	static const uint8_t MAX_N_PARAMETER = 10;
-//	static const uint8_t MAX_N_LIMIT_ID = 10;
-	virtual ReturnValue_t setCheckingOfParameters(uint8_t checkingStrategy,
-			bool forOnePid = false, uint32_t parameterId = 0) = 0;
-	virtual ReturnValue_t modifyParameterMonitor(uint8_t limitType,
-			uint32_t parameterId, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t modifyObjectMonitor(uint32_t objectId,
-			const uint8_t* data, const uint32_t size) = 0;
-	virtual void setAllMonitorsToUnchecked() = 0;
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ~HasMonitorsIF() {
-	}
-};
-
-#endif /* HASMONITORSIF_H_ */
+/**
+ * @file	HasMonitorsIF.h
+ * @brief	This file defines the HasMonitorsIF class.
+ * @date	28.07.2014
+ * @author	baetz
+ */
+#ifndef HASMONITORSIF_H_
+#define HASMONITORSIF_H_
+
+#include "../events/EventReportingProxyIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class HasMonitorsIF {
+public:
+	static const uint8_t MAX_N_PARAMETER = 10;
+//	static const uint8_t MAX_N_LIMIT_ID = 10;
+	virtual ReturnValue_t setCheckingOfParameters(uint8_t checkingStrategy,
+			bool forOnePid = false, uint32_t parameterId = 0) = 0;
+	virtual ReturnValue_t modifyParameterMonitor(uint8_t limitType,
+			uint32_t parameterId, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t modifyObjectMonitor(uint32_t objectId,
+			const uint8_t* data, const uint32_t size) = 0;
+	virtual void setAllMonitorsToUnchecked() = 0;
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ~HasMonitorsIF() {
+	}
+};
+
+#endif /* HASMONITORSIF_H_ */
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index 465d72e83..4aec86695 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -1,95 +1,95 @@
-#ifndef FRAMEWORK_MONITORING_LIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_LIMITMONITOR_H_
-
-#include "../monitoring/MonitorBase.h"
-
-/**
- * Variant of a limit checking class.
- * Newer version as compared to LimitCheckMonitor.
- * Functionality is more or less the same, but does not use
- * heavy weight MonitoringIF.
- */
-template<typename T>
-class LimitMonitor: public MonitorBase<T> {
-public:
-	LimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
-			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
-			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
-			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit),
-			lowerLimit(lowerLimit), upperLimit(upperLimit), belowLowEvent(belowLowEvent),
-			aboveHighEvent(aboveHighEvent) {
-	}
-
-	virtual ~LimitMonitor() {}
-
-	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
-		*crossedLimit = 0.0;
-		if (sample > upperLimit) {
-			*crossedLimit = upperLimit;
-			return MonitoringIF::ABOVE_HIGH_LIMIT;
-		} else if (sample < lowerLimit) {
-			*crossedLimit = lowerLimit;
-			return MonitoringIF::BELOW_LOW_LIMIT;
-		} else {
-			return HasReturnvaluesIF::RETURN_OK; //Within limits.
-		}
-	}
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
-				parameterId, parameterWrapper, newValues, startAtIndex);
-		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
-			return result;
-		}
-		switch (parameterId) {
-		case 10:
-			parameterWrapper->set(this->lowerLimit);
-			break;
-		case 11:
-			parameterWrapper->set(this->upperLimit);
-			break;
-		default:
-			return this->INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	bool isOutOfLimits() {
-		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT || this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	T getLowerLimit() const {
-		return lowerLimit;
-	}
-
-	T getUpperLimit() const {
-		return upperLimit;
-	}
-
-protected:
-	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
-		switch (state) {
-		case MonitoringIF::BELOW_LOW_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent, this->parameterId);
-			break;
-		case MonitoringIF::ABOVE_HIGH_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent, this->parameterId);
-			break;
-		default:
-			break;
-		}
-	}
-	T lowerLimit;
-	T upperLimit;
-	const Event belowLowEvent;
-	const Event aboveHighEvent;
-};
-
-#endif /* FRAMEWORK_MONITORING_LIMITMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_LIMITMONITOR_H_
+#define FRAMEWORK_MONITORING_LIMITMONITOR_H_
+
+#include "../monitoring/MonitorBase.h"
+
+/**
+ * Variant of a limit checking class.
+ * Newer version as compared to LimitCheckMonitor.
+ * Functionality is more or less the same, but does not use
+ * heavy weight MonitoringIF.
+ */
+template<typename T>
+class LimitMonitor: public MonitorBase<T> {
+public:
+	LimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
+			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
+			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
+			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
+			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit),
+			lowerLimit(lowerLimit), upperLimit(upperLimit), belowLowEvent(belowLowEvent),
+			aboveHighEvent(aboveHighEvent) {
+	}
+
+	virtual ~LimitMonitor() {}
+
+	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
+		*crossedLimit = 0.0;
+		if (sample > upperLimit) {
+			*crossedLimit = upperLimit;
+			return MonitoringIF::ABOVE_HIGH_LIMIT;
+		} else if (sample < lowerLimit) {
+			*crossedLimit = lowerLimit;
+			return MonitoringIF::BELOW_LOW_LIMIT;
+		} else {
+			return HasReturnvaluesIF::RETURN_OK; //Within limits.
+		}
+	}
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
+				parameterId, parameterWrapper, newValues, startAtIndex);
+		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
+		if (result != this->INVALID_MATRIX_ID) {
+			return result;
+		}
+		switch (parameterId) {
+		case 10:
+			parameterWrapper->set(this->lowerLimit);
+			break;
+		case 11:
+			parameterWrapper->set(this->upperLimit);
+			break;
+		default:
+			return this->INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	bool isOutOfLimits() {
+		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT || this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	T getLowerLimit() const {
+		return lowerLimit;
+	}
+
+	T getUpperLimit() const {
+		return upperLimit;
+	}
+
+protected:
+	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+		switch (state) {
+		case MonitoringIF::BELOW_LOW_LIMIT:
+			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent, this->parameterId);
+			break;
+		case MonitoringIF::ABOVE_HIGH_LIMIT:
+			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent, this->parameterId);
+			break;
+		default:
+			break;
+		}
+	}
+	T lowerLimit;
+	T upperLimit;
+	const Event belowLowEvent;
+	const Event aboveHighEvent;
+};
+
+#endif /* FRAMEWORK_MONITORING_LIMITMONITOR_H_ */
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 7869dc2ba..87278f4e1 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -1,60 +1,60 @@
-/**
- * @file	LimitViolationReporter.cpp
- * @brief	This file defines the LimitViolationReporter class.
- * @date	17.07.2014
- * @author	baetz
- */
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../monitoring/ReceivesMonitoringReportsIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../serialize/SerializeAdapter.h"
-
-ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF* data) {
-	ReturnValue_t result = checkClassLoaded();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	store_address_t storeId;
-	uint8_t* dataTarget = NULL;
-	size_t maxSize = data->getSerializedSize();
-	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
-		return MonitoringIF::INVALID_SIZE;
-	}
-	result = ipcStore->getFreeElement(&storeId, maxSize,
-			&dataTarget);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	size_t size = 0;
-	result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	CommandMessage report;
-	MonitoringMessage::setLimitViolationReport(&report, storeId);
-	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
-}
-
-ReturnValue_t LimitViolationReporter::checkClassLoaded() {
-	if (reportQueue == 0) {
-		ReceivesMonitoringReportsIF* receiver = objectManager->get<
-				ReceivesMonitoringReportsIF>(reportingTarget);
-		if (receiver == NULL) {
-			return ObjectManagerIF::NOT_FOUND;
-		}
-		reportQueue = receiver->getCommandQueue();
-	}
-	if (ipcStore == NULL) {
-		ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//Lazy initialization.
-MessageQueueId_t LimitViolationReporter::reportQueue = 0;
-StorageManagerIF* LimitViolationReporter::ipcStore = NULL;
-object_id_t LimitViolationReporter::reportingTarget = 0;
+/**
+ * @file	LimitViolationReporter.cpp
+ * @brief	This file defines the LimitViolationReporter class.
+ * @date	17.07.2014
+ * @author	baetz
+ */
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/ReceivesMonitoringReportsIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerializeAdapter.h"
+
+ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF* data) {
+	ReturnValue_t result = checkClassLoaded();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	store_address_t storeId;
+	uint8_t* dataTarget = NULL;
+	size_t maxSize = data->getSerializedSize();
+	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
+		return MonitoringIF::INVALID_SIZE;
+	}
+	result = ipcStore->getFreeElement(&storeId, maxSize,
+			&dataTarget);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	size_t size = 0;
+	result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	CommandMessage report;
+	MonitoringMessage::setLimitViolationReport(&report, storeId);
+	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
+}
+
+ReturnValue_t LimitViolationReporter::checkClassLoaded() {
+	if (reportQueue == 0) {
+		ReceivesMonitoringReportsIF* receiver = objectManager->get<
+				ReceivesMonitoringReportsIF>(reportingTarget);
+		if (receiver == NULL) {
+			return ObjectManagerIF::NOT_FOUND;
+		}
+		reportQueue = receiver->getCommandQueue();
+	}
+	if (ipcStore == NULL) {
+		ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+//Lazy initialization.
+MessageQueueId_t LimitViolationReporter::reportQueue = 0;
+StorageManagerIF* LimitViolationReporter::ipcStore = NULL;
+object_id_t LimitViolationReporter::reportingTarget = 0;
diff --git a/monitoring/LimitViolationReporter.h b/monitoring/LimitViolationReporter.h
index 53d67b9d4..a71b972ff 100644
--- a/monitoring/LimitViolationReporter.h
+++ b/monitoring/LimitViolationReporter.h
@@ -1,31 +1,31 @@
-/**
- * @file	LimitViolationReporter.h
- * @brief	This file defines the LimitViolationReporter class.
- * @date	17.07.2014
- * @author	baetz
- */
-#ifndef LIMITVIOLATIONREPORTER_H_
-#define LIMITVIOLATIONREPORTER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerializeIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-class LimitViolationReporter {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	static ReturnValue_t sendLimitViolationReport(const SerializeIF* data);
-private:
-	static object_id_t reportingTarget;
-	static MessageQueueId_t reportQueue;
-	static StorageManagerIF* ipcStore;
-	static ReturnValue_t checkClassLoaded();
-	LimitViolationReporter();
-};
-
-#endif /* LIMITVIOLATIONREPORTER_H_ */
+/**
+ * @file	LimitViolationReporter.h
+ * @brief	This file defines the LimitViolationReporter class.
+ * @date	17.07.2014
+ * @author	baetz
+ */
+#ifndef LIMITVIOLATIONREPORTER_H_
+#define LIMITVIOLATIONREPORTER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+class LimitViolationReporter {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	static ReturnValue_t sendLimitViolationReport(const SerializeIF* data);
+private:
+	static object_id_t reportingTarget;
+	static MessageQueueId_t reportQueue;
+	static StorageManagerIF* ipcStore;
+	static ReturnValue_t checkClassLoaded();
+	LimitViolationReporter();
+};
+
+#endif /* LIMITVIOLATIONREPORTER_H_ */
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 45fe22ec0..5173c4798 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,62 +1,62 @@
-#ifndef MONITORBASE_H_
-#define MONITORBASE_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/PIDReader.h"
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../monitoring/MonitoringMessageContent.h"
-#include "../monitoring/MonitorReporter.h"
-
-/**
- * Base class for monitoring of parameters.
- * Can be used anywhere, specializations need to implement checkSample and should override sendTransitionEvent.
- * Manages state handling, enabling and disabling of events/reports and forwarding of transition
- * reports via MonitorReporter. In addition, it provides default implementations for fetching the parameter sample from
- * the data pool and a simple confirmation counter.
- */
-template<typename T>
-class MonitorBase: public MonitorReporter<T> {
-public:
-	MonitorBase(object_id_t reporterId, uint8_t monitorId,
-			uint32_t parameterId, uint16_t confirmationLimit) :
-			MonitorReporter<T>(reporterId, monitorId, parameterId, confirmationLimit) {
-	}
-	virtual ~MonitorBase() {
-	}
-	virtual ReturnValue_t check() {
-		//1. Fetch sample of type T, return validity.
-		T sample = 0;
-		ReturnValue_t validity = fetchSample(&sample);
-
-		//2. If returning from fetch != OK, parameter is invalid. Report (if oldState is != invalidity).
-		if (validity != HasReturnvaluesIF::RETURN_OK) {
-			this->monitorStateIs(validity, sample, 0);
-			//3. Otherwise, check sample.
-		} else {
-			this->oldState = doCheck(sample);
-		}
-		return this->oldState;
-	}
-	virtual ReturnValue_t doCheck(T sample) {
-		T crossedLimit = 0.0;
-		ReturnValue_t currentState = checkSample(sample, &crossedLimit);
-		return this->monitorStateIs(currentState,sample, crossedLimit);
-	}
-	//Abstract or default.
-	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
-
-protected:
-	virtual ReturnValue_t fetchSample(T* sample) {
-		GlobDataSet mySet;
-		PIDReader<T> parameter(this->parameterId, &mySet);
-		mySet.read();
-		if (!parameter.isValid()) {
-			return MonitoringIF::INVALID;
-		}
-		*sample = parameter.value;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-#endif /* MONITORBASE_H_ */
+#ifndef MONITORBASE_H_
+#define MONITORBASE_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../monitoring/MonitorReporter.h"
+
+/**
+ * Base class for monitoring of parameters.
+ * Can be used anywhere, specializations need to implement checkSample and should override sendTransitionEvent.
+ * Manages state handling, enabling and disabling of events/reports and forwarding of transition
+ * reports via MonitorReporter. In addition, it provides default implementations for fetching the parameter sample from
+ * the data pool and a simple confirmation counter.
+ */
+template<typename T>
+class MonitorBase: public MonitorReporter<T> {
+public:
+	MonitorBase(object_id_t reporterId, uint8_t monitorId,
+			uint32_t parameterId, uint16_t confirmationLimit) :
+			MonitorReporter<T>(reporterId, monitorId, parameterId, confirmationLimit) {
+	}
+	virtual ~MonitorBase() {
+	}
+	virtual ReturnValue_t check() {
+		//1. Fetch sample of type T, return validity.
+		T sample = 0;
+		ReturnValue_t validity = fetchSample(&sample);
+
+		//2. If returning from fetch != OK, parameter is invalid. Report (if oldState is != invalidity).
+		if (validity != HasReturnvaluesIF::RETURN_OK) {
+			this->monitorStateIs(validity, sample, 0);
+			//3. Otherwise, check sample.
+		} else {
+			this->oldState = doCheck(sample);
+		}
+		return this->oldState;
+	}
+	virtual ReturnValue_t doCheck(T sample) {
+		T crossedLimit = 0.0;
+		ReturnValue_t currentState = checkSample(sample, &crossedLimit);
+		return this->monitorStateIs(currentState,sample, crossedLimit);
+	}
+	//Abstract or default.
+	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
+
+protected:
+	virtual ReturnValue_t fetchSample(T* sample) {
+		GlobDataSet mySet;
+		PIDReader<T> parameter(this->parameterId, &mySet);
+		mySet.read();
+		if (!parameter.isValid()) {
+			return MonitoringIF::INVALID;
+		}
+		*sample = parameter.value;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+#endif /* MONITORBASE_H_ */
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 69bb00eaa..9823cde01 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -1,178 +1,178 @@
-#ifndef FRAMEWORK_MONITORING_MONITORREPORTER_H_
-#define FRAMEWORK_MONITORING_MONITORREPORTER_H_
-
-#include "../events/EventManagerIF.h"
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../monitoring/MonitoringMessageContent.h"
-#include "../parameters/HasParametersIF.h"
-
-template<typename T>
-class MonitorReporter: public HasParametersIF {
-public:
-
-	static const uint8_t ENABLED = 1;
-	static const uint8_t DISABLED = 0;
-
-	MonitorReporter(object_id_t reportingId, uint8_t monitorId, uint32_t parameterId, uint16_t confirmationLimit) :
-			monitorId(monitorId), parameterId(parameterId), reportingId(
-					reportingId), oldState(MonitoringIF::UNCHECKED), reportingEnabled(
-			ENABLED), eventEnabled(ENABLED), currentCounter(0), confirmationLimit(
-					confirmationLimit) {
-	}
-
-	virtual ~MonitorReporter() {
-	}
-
-	ReturnValue_t monitorStateIs(ReturnValue_t state, T parameterValue = 0,
-			T crossedLimit = 0) {
-		if (state != oldState) {
-			if (isConfirmed(state)) {
-				if (eventEnabled == ENABLED) {
-					sendTransitionEvent(parameterValue, state);
-				}
-				if (reportingEnabled == ENABLED) {
-					sendTransitionReport(parameterValue, crossedLimit, state);
-				}
-				oldState = state;
-			} else {
-				//This is to ensure confirmation works.
-				//Needs to be reset to be able to confirm against oldState again next time.
-				return oldState;
-			}
-		} else {
-			resetConfirmation();
-		}
-		return state;
-	}
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		if (domainId != monitorId) {
-			return INVALID_DOMAIN_ID;
-		}
-		switch (parameterId) {
-		case 0:
-			parameterWrapper->set(this->confirmationLimit);
-			break;
-		case 1:
-			parameterWrapper->set(this->reportingEnabled);
-			break;
-		case 2:
-			parameterWrapper->set(this->eventEnabled);
-			break;
-		default:
-			return INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t setToUnchecked() {
-		return setToState(MonitoringIF::UNCHECKED);
-	}
-	virtual ReturnValue_t setToInvalid() {
-		return setToState(MonitoringIF::INVALID);
-	}
-	object_id_t getReporterId() const {
-		return reportingId;
-	}
-
-	void setEventEnabled(uint8_t eventEnabled) {
-		this->eventEnabled = eventEnabled;
-	}
-
-	void setReportingEnabled(uint8_t reportingEnabled) {
-		this->reportingEnabled = reportingEnabled;
-	}
-
-	bool isEventEnabled() const {
-		return (eventEnabled == ENABLED);
-	}
-
-protected:
-	const uint8_t monitorId;
-	const uint32_t parameterId;
-	object_id_t reportingId;
-	ReturnValue_t oldState;
-
-	uint8_t reportingEnabled;
-
-	uint8_t eventEnabled;
-
-	uint16_t currentCounter;
-	uint16_t confirmationLimit;
-
-	bool isConfirmed(ReturnValue_t state) {
-		//Confirm INVALID and UNCHECKED immediately.
-		if (state == MonitoringIF::INVALID
-				|| state == MonitoringIF::UNCHECKED) {
-			currentCounter = 0;
-			return true;
-		}
-		return doesChildConfirm(state);
-	}
-
-	/**
-	 * This is the most simple form of confirmation.
-	 * A counter counts any violation and compares the number to maxCounter.
-	 * @param state The state, indicating the type of violation. Not used here.
-	 * @return true if counter > maxCounter, else false.
-	 */
-	virtual bool doesChildConfirm(ReturnValue_t state) {
-		currentCounter += 1;
-		if (currentCounter > confirmationLimit) {
-			currentCounter = 0;
-			return true;
-		} else {
-			return false;
-		}
-	}
-	/**
-	 * This method needs to reset the confirmation in case a valid sample was found.
-	 * Here, simply resets the current counter.
-	 */
-	virtual void resetConfirmation() {
-		currentCounter = 0;
-	}
-	/**
-	 * Default version of sending transitional events.
-	 * Should be overridden from specialized monitors.
-	 * @param currentValue The current value which was monitored.
-	 * @param state The state the monitor changed to.
-	 */
-	virtual void sendTransitionEvent(T currentValue, ReturnValue_t state) {
-		switch(state) {
-		case MonitoringIF::UNCHECKED:
-		case MonitoringIF::UNSELECTED:
-		case MonitoringIF::INVALID:
-		case HasReturnvaluesIF::RETURN_OK:
-			break;
-		default:
-			EventManagerIF::triggerEvent(reportingId, MonitoringIF::MONITOR_CHANGED_STATE, state);
-			break;
-		}
-	}
-	/**
-	 * Default implementation for sending transition report.
-	 * May be overridden, but is seldom necessary.
-	 * @param parameterValue Current value of the parameter
-	 * @param crossedLimit The limit crossed (if applicable).
-	 * @param state Current state the monitor is in.
-	 */
-	virtual void sendTransitionReport(T parameterValue, T crossedLimit, ReturnValue_t state) {
-		MonitoringReportContent<T> report(parameterId,
-				parameterValue, crossedLimit, oldState, state);
-		LimitViolationReporter::sendLimitViolationReport(&report);
-	}
-	ReturnValue_t setToState(ReturnValue_t state) {
-		if (oldState != state && reportingEnabled) {
-			MonitoringReportContent<T> report(parameterId, 0, 0, oldState,
-					state);
-			LimitViolationReporter::sendLimitViolationReport(&report);
-			oldState = state;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-#endif /* FRAMEWORK_MONITORING_MONITORREPORTER_H_ */
+#ifndef FRAMEWORK_MONITORING_MONITORREPORTER_H_
+#define FRAMEWORK_MONITORING_MONITORREPORTER_H_
+
+#include "../events/EventManagerIF.h"
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../parameters/HasParametersIF.h"
+
+template<typename T>
+class MonitorReporter: public HasParametersIF {
+public:
+
+	static const uint8_t ENABLED = 1;
+	static const uint8_t DISABLED = 0;
+
+	MonitorReporter(object_id_t reportingId, uint8_t monitorId, uint32_t parameterId, uint16_t confirmationLimit) :
+			monitorId(monitorId), parameterId(parameterId), reportingId(
+					reportingId), oldState(MonitoringIF::UNCHECKED), reportingEnabled(
+			ENABLED), eventEnabled(ENABLED), currentCounter(0), confirmationLimit(
+					confirmationLimit) {
+	}
+
+	virtual ~MonitorReporter() {
+	}
+
+	ReturnValue_t monitorStateIs(ReturnValue_t state, T parameterValue = 0,
+			T crossedLimit = 0) {
+		if (state != oldState) {
+			if (isConfirmed(state)) {
+				if (eventEnabled == ENABLED) {
+					sendTransitionEvent(parameterValue, state);
+				}
+				if (reportingEnabled == ENABLED) {
+					sendTransitionReport(parameterValue, crossedLimit, state);
+				}
+				oldState = state;
+			} else {
+				//This is to ensure confirmation works.
+				//Needs to be reset to be able to confirm against oldState again next time.
+				return oldState;
+			}
+		} else {
+			resetConfirmation();
+		}
+		return state;
+	}
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		if (domainId != monitorId) {
+			return INVALID_DOMAIN_ID;
+		}
+		switch (parameterId) {
+		case 0:
+			parameterWrapper->set(this->confirmationLimit);
+			break;
+		case 1:
+			parameterWrapper->set(this->reportingEnabled);
+			break;
+		case 2:
+			parameterWrapper->set(this->eventEnabled);
+			break;
+		default:
+			return INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t setToUnchecked() {
+		return setToState(MonitoringIF::UNCHECKED);
+	}
+	virtual ReturnValue_t setToInvalid() {
+		return setToState(MonitoringIF::INVALID);
+	}
+	object_id_t getReporterId() const {
+		return reportingId;
+	}
+
+	void setEventEnabled(uint8_t eventEnabled) {
+		this->eventEnabled = eventEnabled;
+	}
+
+	void setReportingEnabled(uint8_t reportingEnabled) {
+		this->reportingEnabled = reportingEnabled;
+	}
+
+	bool isEventEnabled() const {
+		return (eventEnabled == ENABLED);
+	}
+
+protected:
+	const uint8_t monitorId;
+	const uint32_t parameterId;
+	object_id_t reportingId;
+	ReturnValue_t oldState;
+
+	uint8_t reportingEnabled;
+
+	uint8_t eventEnabled;
+
+	uint16_t currentCounter;
+	uint16_t confirmationLimit;
+
+	bool isConfirmed(ReturnValue_t state) {
+		//Confirm INVALID and UNCHECKED immediately.
+		if (state == MonitoringIF::INVALID
+				|| state == MonitoringIF::UNCHECKED) {
+			currentCounter = 0;
+			return true;
+		}
+		return doesChildConfirm(state);
+	}
+
+	/**
+	 * This is the most simple form of confirmation.
+	 * A counter counts any violation and compares the number to maxCounter.
+	 * @param state The state, indicating the type of violation. Not used here.
+	 * @return true if counter > maxCounter, else false.
+	 */
+	virtual bool doesChildConfirm(ReturnValue_t state) {
+		currentCounter += 1;
+		if (currentCounter > confirmationLimit) {
+			currentCounter = 0;
+			return true;
+		} else {
+			return false;
+		}
+	}
+	/**
+	 * This method needs to reset the confirmation in case a valid sample was found.
+	 * Here, simply resets the current counter.
+	 */
+	virtual void resetConfirmation() {
+		currentCounter = 0;
+	}
+	/**
+	 * Default version of sending transitional events.
+	 * Should be overridden from specialized monitors.
+	 * @param currentValue The current value which was monitored.
+	 * @param state The state the monitor changed to.
+	 */
+	virtual void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+		switch(state) {
+		case MonitoringIF::UNCHECKED:
+		case MonitoringIF::UNSELECTED:
+		case MonitoringIF::INVALID:
+		case HasReturnvaluesIF::RETURN_OK:
+			break;
+		default:
+			EventManagerIF::triggerEvent(reportingId, MonitoringIF::MONITOR_CHANGED_STATE, state);
+			break;
+		}
+	}
+	/**
+	 * Default implementation for sending transition report.
+	 * May be overridden, but is seldom necessary.
+	 * @param parameterValue Current value of the parameter
+	 * @param crossedLimit The limit crossed (if applicable).
+	 * @param state Current state the monitor is in.
+	 */
+	virtual void sendTransitionReport(T parameterValue, T crossedLimit, ReturnValue_t state) {
+		MonitoringReportContent<T> report(parameterId,
+				parameterValue, crossedLimit, oldState, state);
+		LimitViolationReporter::sendLimitViolationReport(&report);
+	}
+	ReturnValue_t setToState(ReturnValue_t state) {
+		if (oldState != state && reportingEnabled) {
+			MonitoringReportContent<T> report(parameterId, 0, 0, oldState,
+					state);
+			LimitViolationReporter::sendLimitViolationReport(&report);
+			oldState = state;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+#endif /* FRAMEWORK_MONITORING_MONITORREPORTER_H_ */
diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h
index a4c0666cb..d9ea339f4 100644
--- a/monitoring/MonitoringIF.h
+++ b/monitoring/MonitoringIF.h
@@ -1,67 +1,67 @@
-#ifndef MONITORINGIF_H_
-#define MONITORINGIF_H_
-
-#include "../memory/HasMemoryIF.h"
-#include "../monitoring/MonitoringMessage.h"
-#include "../serialize/SerializeIF.h"
-
-class MonitoringIF : public SerializeIF {
-public:
-	static const uint8_t VIOLATION_REPORT_MAX_SIZE = 32;
-	static const uint8_t LIMIT_TYPE_NO_TYPE = 0xFF;
-	static const uint8_t LIMIT_TYPE_LIMIT_CHECK = 0;
-	static const uint8_t LIMIT_TYPE_DELTA_CHECK = 1;
-	static const uint8_t LIMIT_TYPE_ABSOLUTE_CHECK = 2;
-	static const uint8_t LIMIT_TYPE_OBJECT = 128;
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_2;
-	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, SEVERITY::LOW);
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::LIMITS_IF;
-	static const ReturnValue_t UNCHECKED = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t UNSELECTED = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t BELOW_LOW_LIMIT = MAKE_RETURN_CODE(4);
-//	static const ReturnValue_t CHECKING_STATUS_BELOW_LOW_THRESHOLD = MAKE_RETURN_CODE(4);
-//	static const ReturnValue_t CHECKING_STATUS_ABOVE_HIGH_THRESHOLD = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t ABOVE_HIGH_LIMIT = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t UNEXPECTED_VALUE = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t OUT_OF_RANGE = MAKE_RETURN_CODE(7);
-
-
-	static const ReturnValue_t FIRST_SAMPLE = MAKE_RETURN_CODE(0xA0);
-	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t WRONG_TYPE = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t WRONG_PID = MAKE_RETURN_CODE(0xE2);
-	static const ReturnValue_t WRONG_LIMIT_ID = MAKE_RETURN_CODE(0xE3);
-	static const ReturnValue_t MONITOR_NOT_FOUND = MAKE_RETURN_CODE(0xEE);
-
-	static const uint8_t REPORT_NONE = 0;
-	static const uint8_t REPORT_EVENTS_ONLY = 1;
-	static const uint8_t REPORT_REPORTS_ONLY = 2;
-	static const uint8_t REPORT_ALL = 3;
-
-//	static const ReturnValue_t STILL_IN_LOW_WARNING = MAKE_RETURN_CODE(0x11);
-//	static const ReturnValue_t STILL_IN_LOW_LIMIT = MAKE_RETURN_CODE(0x12);
-//	static const ReturnValue_t STILL_IN_HIGH_WARNING = MAKE_RETURN_CODE(0x13);
-//	static const ReturnValue_t STILL_IN_HIGH_LIMIT = MAKE_RETURN_CODE(0x14);
-//	static const ReturnValue_t VARIABLE_IS_INVALID = MAKE_RETURN_CODE(0xE0);
-//	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE1);
-//	static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xE2);
-	virtual ReturnValue_t check() = 0;
-	virtual ReturnValue_t setLimits( uint8_t type, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t setChecking(uint8_t strategy) = 0;
-	virtual ReturnValue_t setToUnchecked() = 0;
-	virtual uint8_t getLimitType() const = 0;
-	virtual uint32_t getLimitId() const = 0;
-//	virtual ReturnValue_t setEventReporting(bool active) = 0;
-	virtual ~MonitoringIF() {
-	}
-};
-
-
-
-#endif /* MONITORINGIF_H_ */
+#ifndef MONITORINGIF_H_
+#define MONITORINGIF_H_
+
+#include "../memory/HasMemoryIF.h"
+#include "../monitoring/MonitoringMessage.h"
+#include "../serialize/SerializeIF.h"
+
+class MonitoringIF : public SerializeIF {
+public:
+	static const uint8_t VIOLATION_REPORT_MAX_SIZE = 32;
+	static const uint8_t LIMIT_TYPE_NO_TYPE = 0xFF;
+	static const uint8_t LIMIT_TYPE_LIMIT_CHECK = 0;
+	static const uint8_t LIMIT_TYPE_DELTA_CHECK = 1;
+	static const uint8_t LIMIT_TYPE_ABSOLUTE_CHECK = 2;
+	static const uint8_t LIMIT_TYPE_OBJECT = 128;
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_2;
+	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, SEVERITY::LOW);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::LIMITS_IF;
+	static const ReturnValue_t UNCHECKED = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t UNSELECTED = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BELOW_LOW_LIMIT = MAKE_RETURN_CODE(4);
+//	static const ReturnValue_t CHECKING_STATUS_BELOW_LOW_THRESHOLD = MAKE_RETURN_CODE(4);
+//	static const ReturnValue_t CHECKING_STATUS_ABOVE_HIGH_THRESHOLD = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t ABOVE_HIGH_LIMIT = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t UNEXPECTED_VALUE = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t OUT_OF_RANGE = MAKE_RETURN_CODE(7);
+
+
+	static const ReturnValue_t FIRST_SAMPLE = MAKE_RETURN_CODE(0xA0);
+	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t WRONG_TYPE = MAKE_RETURN_CODE(0xE1);
+	static const ReturnValue_t WRONG_PID = MAKE_RETURN_CODE(0xE2);
+	static const ReturnValue_t WRONG_LIMIT_ID = MAKE_RETURN_CODE(0xE3);
+	static const ReturnValue_t MONITOR_NOT_FOUND = MAKE_RETURN_CODE(0xEE);
+
+	static const uint8_t REPORT_NONE = 0;
+	static const uint8_t REPORT_EVENTS_ONLY = 1;
+	static const uint8_t REPORT_REPORTS_ONLY = 2;
+	static const uint8_t REPORT_ALL = 3;
+
+//	static const ReturnValue_t STILL_IN_LOW_WARNING = MAKE_RETURN_CODE(0x11);
+//	static const ReturnValue_t STILL_IN_LOW_LIMIT = MAKE_RETURN_CODE(0x12);
+//	static const ReturnValue_t STILL_IN_HIGH_WARNING = MAKE_RETURN_CODE(0x13);
+//	static const ReturnValue_t STILL_IN_HIGH_LIMIT = MAKE_RETURN_CODE(0x14);
+//	static const ReturnValue_t VARIABLE_IS_INVALID = MAKE_RETURN_CODE(0xE0);
+//	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE1);
+//	static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xE2);
+	virtual ReturnValue_t check() = 0;
+	virtual ReturnValue_t setLimits( uint8_t type, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t setChecking(uint8_t strategy) = 0;
+	virtual ReturnValue_t setToUnchecked() = 0;
+	virtual uint8_t getLimitType() const = 0;
+	virtual uint32_t getLimitId() const = 0;
+//	virtual ReturnValue_t setEventReporting(bool active) = 0;
+	virtual ~MonitoringIF() {
+	}
+};
+
+
+
+#endif /* MONITORINGIF_H_ */
diff --git a/monitoring/MonitoringMessage.cpp b/monitoring/MonitoringMessage.cpp
index 9edf16d5b..2cfe1ecee 100644
--- a/monitoring/MonitoringMessage.cpp
+++ b/monitoring/MonitoringMessage.cpp
@@ -1,38 +1,38 @@
-#include "../monitoring/MonitoringMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-MonitoringMessage::~MonitoringMessage() {
-}
-
-void MonitoringMessage::setLimitViolationReport(CommandMessage* message,
-		store_address_t storeId) {
-	setTypicalMessage(message, LIMIT_VIOLATION_REPORT, storeId);
-}
-
-void MonitoringMessage::setTypicalMessage(CommandMessage* message,
-		Command_t type, store_address_t storeId) {
-	message->setCommand(type);
-	message->setParameter2(storeId.raw);
-}
-
-store_address_t MonitoringMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-void MonitoringMessage::clear(CommandMessage* message) {
-	message->setCommand(CommandMessage::CMD_NONE);
-	switch (message->getCommand()) {
-	case MonitoringMessage::LIMIT_VIOLATION_REPORT: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-}
+#include "../monitoring/MonitoringMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+MonitoringMessage::~MonitoringMessage() {
+}
+
+void MonitoringMessage::setLimitViolationReport(CommandMessage* message,
+		store_address_t storeId) {
+	setTypicalMessage(message, LIMIT_VIOLATION_REPORT, storeId);
+}
+
+void MonitoringMessage::setTypicalMessage(CommandMessage* message,
+		Command_t type, store_address_t storeId) {
+	message->setCommand(type);
+	message->setParameter2(storeId.raw);
+}
+
+store_address_t MonitoringMessage::getStoreId(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+void MonitoringMessage::clear(CommandMessage* message) {
+	message->setCommand(CommandMessage::CMD_NONE);
+	switch (message->getCommand()) {
+	case MonitoringMessage::LIMIT_VIOLATION_REPORT: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(message));
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
diff --git a/monitoring/MonitoringMessage.h b/monitoring/MonitoringMessage.h
index 55d3ea5c2..84b027504 100644
--- a/monitoring/MonitoringMessage.h
+++ b/monitoring/MonitoringMessage.h
@@ -1,21 +1,21 @@
-#ifndef MONITORINGMESSAGE_H_
-#define MONITORINGMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-
-class MonitoringMessage: public CommandMessage {
-public:
-	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();
-	static void setLimitViolationReport(CommandMessage* message, store_address_t storeId);
-	static void clear(CommandMessage* message);
-	static store_address_t getStoreId(const CommandMessage* message);
-	static void setTypicalMessage(CommandMessage* message, Command_t type, store_address_t storeId);
-
-};
-
-
-#endif /* MONITORINGMESSAGE_H_ */
+#ifndef MONITORINGMESSAGE_H_
+#define MONITORINGMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+class MonitoringMessage: public CommandMessage {
+public:
+	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();
+	static void setLimitViolationReport(CommandMessage* message, store_address_t storeId);
+	static void clear(CommandMessage* message);
+	static store_address_t getStoreId(const CommandMessage* message);
+	static void setTypicalMessage(CommandMessage* message, Command_t type, store_address_t storeId);
+
+};
+
+
+#endif /* MONITORINGMESSAGE_H_ */
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index a0934c14c..ea52962b2 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -1,77 +1,77 @@
-#ifndef MONITORINGMESSAGECONTENT_H_
-#define MONITORINGMESSAGECONTENT_H_
-
-#include "../monitoring/HasMonitorsIF.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../serialize/SerialBufferAdapter.h"
-#include "../serialize/SerialFixedArrayListAdapter.h"
-#include "../serialize/SerializeElement.h"
-#include "../serialize/SerialLinkedListAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../timemanager/TimeStamperIF.h"
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-//PID(uint32_t), TYPE, LIMIT_ID, value,limitValue, previous, later, timestamp
-template<typename T>
-class MonitoringReportContent: public SerialLinkedListAdapter<SerializeIF> {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	SerializeElement<uint8_t> monitorId;
-	SerializeElement<uint32_t> parameterId;
-	SerializeElement<T> parameterValue;
-	SerializeElement<T> limitValue;
-	SerializeElement<ReturnValue_t> oldState;
-	SerializeElement<ReturnValue_t> newState;
-	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
-	SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
-	TimeStamperIF* timeStamper;
-	MonitoringReportContent() :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					0), parameterValue(0), limitValue(0), oldState(0), newState(
-					0), rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
-					sizeof(rawTimestamp)), timeStamper(NULL) {
-		setAllNext();
-	}
-	MonitoringReportContent(uint32_t setPID, T value, T limitValue,
-			ReturnValue_t oldState, ReturnValue_t newState) :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					setPID), parameterValue(value), limitValue(limitValue), oldState(
-					oldState), newState(newState), timestampSerializer(rawTimestamp,
-							sizeof(rawTimestamp)), timeStamper(NULL) {
-		setAllNext();
-		if (checkAndSetStamper()) {
-			timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
-		}
-	}
-private:
-
-	static object_id_t timeStamperId;
-	void setAllNext() {
-		parameterId.setNext(&parameterValue);
-		parameterValue.setNext(&limitValue);
-		limitValue.setNext(&oldState);
-		oldState.setNext(&newState);
-		newState.setNext(&timestampSerializer);
-	}
-	bool checkAndSetStamper() {
-		if (timeStamper == NULL) {
-			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
-			if ( timeStamper == NULL ) {
-				sif::error << "MonitoringReportContent::checkAndSetStamper: "
-				        "Stamper not found!" << std::endl;
-				return false;
-			}
-		}
-		return true;
-	}
-};
-template<typename T>
-object_id_t MonitoringReportContent<T>::timeStamperId = 0;
-
-#endif /* MONITORINGMESSAGECONTENT_H_ */
+#ifndef MONITORINGMESSAGECONTENT_H_
+#define MONITORINGMESSAGECONTENT_H_
+
+#include "../monitoring/HasMonitorsIF.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../timemanager/TimeStamperIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+//PID(uint32_t), TYPE, LIMIT_ID, value,limitValue, previous, later, timestamp
+template<typename T>
+class MonitoringReportContent: public SerialLinkedListAdapter<SerializeIF> {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	SerializeElement<uint8_t> monitorId;
+	SerializeElement<uint32_t> parameterId;
+	SerializeElement<T> parameterValue;
+	SerializeElement<T> limitValue;
+	SerializeElement<ReturnValue_t> oldState;
+	SerializeElement<ReturnValue_t> newState;
+	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+	SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
+	TimeStamperIF* timeStamper;
+	MonitoringReportContent() :
+			SerialLinkedListAdapter<SerializeIF>(
+					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
+					0), parameterValue(0), limitValue(0), oldState(0), newState(
+					0), rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
+					sizeof(rawTimestamp)), timeStamper(NULL) {
+		setAllNext();
+	}
+	MonitoringReportContent(uint32_t setPID, T value, T limitValue,
+			ReturnValue_t oldState, ReturnValue_t newState) :
+			SerialLinkedListAdapter<SerializeIF>(
+					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
+					setPID), parameterValue(value), limitValue(limitValue), oldState(
+					oldState), newState(newState), timestampSerializer(rawTimestamp,
+							sizeof(rawTimestamp)), timeStamper(NULL) {
+		setAllNext();
+		if (checkAndSetStamper()) {
+			timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
+		}
+	}
+private:
+
+	static object_id_t timeStamperId;
+	void setAllNext() {
+		parameterId.setNext(&parameterValue);
+		parameterValue.setNext(&limitValue);
+		limitValue.setNext(&oldState);
+		oldState.setNext(&newState);
+		newState.setNext(&timestampSerializer);
+	}
+	bool checkAndSetStamper() {
+		if (timeStamper == NULL) {
+			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
+			if ( timeStamper == NULL ) {
+				sif::error << "MonitoringReportContent::checkAndSetStamper: "
+				        "Stamper not found!" << std::endl;
+				return false;
+			}
+		}
+		return true;
+	}
+};
+template<typename T>
+object_id_t MonitoringReportContent<T>::timeStamperId = 0;
+
+#endif /* MONITORINGMESSAGECONTENT_H_ */
diff --git a/monitoring/ReceivesMonitoringReportsIF.h b/monitoring/ReceivesMonitoringReportsIF.h
index 16595f33c..fb37c16c4 100644
--- a/monitoring/ReceivesMonitoringReportsIF.h
+++ b/monitoring/ReceivesMonitoringReportsIF.h
@@ -1,15 +1,15 @@
-#ifndef RECEIVESMONITORINGREPORTSIF_H_
-#define RECEIVESMONITORINGREPORTSIF_H_
-
-#include "../ipc/MessageQueueSenderIF.h"
-
-class ReceivesMonitoringReportsIF {
-public:
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ~ReceivesMonitoringReportsIF() {
-	}
-};
-
-
-
-#endif /* RECEIVESMONITORINGREPORTSIF_H_ */
+#ifndef RECEIVESMONITORINGREPORTSIF_H_
+#define RECEIVESMONITORINGREPORTSIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+class ReceivesMonitoringReportsIF {
+public:
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ~ReceivesMonitoringReportsIF() {
+	}
+};
+
+
+
+#endif /* RECEIVESMONITORINGREPORTSIF_H_ */
diff --git a/monitoring/TriplexMonitor.h b/monitoring/TriplexMonitor.h
index 6f190361d..9b60aeb63 100644
--- a/monitoring/TriplexMonitor.h
+++ b/monitoring/TriplexMonitor.h
@@ -1,155 +1,155 @@
-#ifndef FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
-#define FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
-
-#include "../datapool/DataSet.h"
-#include "../datapool/PIDReaderList.h"
-#include "../health/HealthTableIF.h"
-#include "../parameters/HasParametersIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-
-//SHOULDDO: This is by far not perfect. Could be merged with new Monitor classes. But still, it's over-engineering.
-template<typename T>
-class TriplexMonitor : public HasParametersIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TRIPLE_REDUNDACY_CHECK;
-	static const ReturnValue_t NOT_ENOUGH_SENSORS = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LOWEST_VALUE_OOL = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t HIGHEST_VALUE_OOL = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t BOTH_VALUES_OOL = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t DUPLEX_OOL = MAKE_RETURN_CODE(5);
-
-	static const uint8_t THREE = 3;
-
-	TriplexMonitor(const uint32_t parameterIds[3], uint8_t domainId, const T initialLimit,
-			Event eventTripleCheck, Event eventDualCheck) :
-			values(parameterIds, &dataSet), limit(initialLimit), eventTripleCheck(
-					eventTripleCheck), eventDualCheck(eventDualCheck), healthTable(
-					NULL), domainId(domainId) {
-
-	}
-	virtual ~TriplexMonitor() {
-	}
-	ReturnValue_t check() {
-		dataSet.read();
-		//check health and validity
-		uint8_t availableIndex[2] = { 0, 0 };
-		bool first = true;
-		uint8_t nAvailable = 0;
-		for (uint8_t count = 0; count < THREE; count++) {
-			if (values[count].isValid() && checkObjectHealthState(count)) {
-				if (first) {
-					availableIndex[0] = count;
-					first = false;
-				} else {
-					//Might be filled twice, but then it's not needed anyway.
-					availableIndex[1] = count;
-				}
-				nAvailable++;
-			}
-		}
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-		switch (nAvailable) {
-		case 3:
-			result = doTriplexMonitoring();
-			break;
-		case 2:
-			result = doDuplexMonitoring(availableIndex);
-			break;
-		default:
-			result = NOT_ENOUGH_SENSORS;
-			break;
-		}
-		dataSet.commit();
-		return result;
-	}
-	ReturnValue_t initialize() {
-		healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
-		if (healthTable == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		if (domainId != this->domainId) {
-			return INVALID_DOMAIN_ID;
-		}
-		switch (parameterId) {
-		case 0:
-			parameterWrapper->set(limit);
-			break;
-		default:
-			return INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-protected:
-	DataSet dataSet;
-	PIDReaderList<T, THREE> values;
-	T limit;
-	Event eventTripleCheck;
-	Event eventDualCheck;
-	HealthTableIF* healthTable;
-	uint8_t domainId;
-	ReturnValue_t doTriplexMonitoring() {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		//Find middle value, by ordering indices
-		uint8_t index[3] = { 0, 1, 2 };
-		if (values[index[0]].value > values[index[1]].value) {
-			std::swap(index[0], index[1]);
-		}
-		if (values[index[0]].value > values[index[2]].value) {
-			std::swap(index[0], index[2]);
-		}
-		if (values[index[1]].value > values[index[2]].value) {
-			std::swap(index[1], index[2]);
-		}
-		//Test if smallest value is out-of-limit.
-		if (values[index[0]] < (values[index[1]] - limit)) {
-			EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
-					eventTripleCheck, LOWEST_VALUE_OOL, 0);
-			result = LOWEST_VALUE_OOL;
-		}
-		//Test if largest value is out-of-limit.
-		if (values[index[2]] > (values[index[1]] + limit)) {
-			EventManagerIF::triggerEvent(getRefereneceObject(index[2]),
-					eventTripleCheck, HIGHEST_VALUE_OOL, 0);
-			if (result == HasReturnvaluesIF::RETURN_OK) {
-				result = HIGHEST_VALUE_OOL;
-			} else {
-				result = BOTH_VALUES_OOL;
-			}
-		}
-		return result;
-	}
-
-	ReturnValue_t doDuplexMonitoring(uint8_t index[2]) {
-		T mean = (values[index[0]] + values[index[1]]) / 2;
-		if (values[index[0]] > values[index[1]]) {
-			if (values[index[0]] > (mean + limit)) {
-				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
-						eventDualCheck, 0, 0);
-				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
-						eventDualCheck, 0, 0);
-				return DUPLEX_OOL;
-			}
-		} else {
-			if (values[index[1]] > (mean + limit)) {
-				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
-						eventDualCheck, 0, 0);
-				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
-						eventDualCheck, 0, 0);
-				return DUPLEX_OOL;
-			}
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual bool checkObjectHealthState(uint8_t valueIndex) = 0;
-	virtual object_id_t getRefereneceObject(uint8_t valueIndex) = 0;
-};
-
-#endif /* FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
+#define FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
+
+#include "../datapool/DataSet.h"
+#include "../datapool/PIDReaderList.h"
+#include "../health/HealthTableIF.h"
+#include "../parameters/HasParametersIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+
+//SHOULDDO: This is by far not perfect. Could be merged with new Monitor classes. But still, it's over-engineering.
+template<typename T>
+class TriplexMonitor : public HasParametersIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TRIPLE_REDUNDACY_CHECK;
+	static const ReturnValue_t NOT_ENOUGH_SENSORS = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LOWEST_VALUE_OOL = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t HIGHEST_VALUE_OOL = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BOTH_VALUES_OOL = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t DUPLEX_OOL = MAKE_RETURN_CODE(5);
+
+	static const uint8_t THREE = 3;
+
+	TriplexMonitor(const uint32_t parameterIds[3], uint8_t domainId, const T initialLimit,
+			Event eventTripleCheck, Event eventDualCheck) :
+			values(parameterIds, &dataSet), limit(initialLimit), eventTripleCheck(
+					eventTripleCheck), eventDualCheck(eventDualCheck), healthTable(
+					NULL), domainId(domainId) {
+
+	}
+	virtual ~TriplexMonitor() {
+	}
+	ReturnValue_t check() {
+		dataSet.read();
+		//check health and validity
+		uint8_t availableIndex[2] = { 0, 0 };
+		bool first = true;
+		uint8_t nAvailable = 0;
+		for (uint8_t count = 0; count < THREE; count++) {
+			if (values[count].isValid() && checkObjectHealthState(count)) {
+				if (first) {
+					availableIndex[0] = count;
+					first = false;
+				} else {
+					//Might be filled twice, but then it's not needed anyway.
+					availableIndex[1] = count;
+				}
+				nAvailable++;
+			}
+		}
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+		switch (nAvailable) {
+		case 3:
+			result = doTriplexMonitoring();
+			break;
+		case 2:
+			result = doDuplexMonitoring(availableIndex);
+			break;
+		default:
+			result = NOT_ENOUGH_SENSORS;
+			break;
+		}
+		dataSet.commit();
+		return result;
+	}
+	ReturnValue_t initialize() {
+		healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
+		if (healthTable == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+				ParameterWrapper *parameterWrapper,
+				const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		if (domainId != this->domainId) {
+			return INVALID_DOMAIN_ID;
+		}
+		switch (parameterId) {
+		case 0:
+			parameterWrapper->set(limit);
+			break;
+		default:
+			return INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+protected:
+	DataSet dataSet;
+	PIDReaderList<T, THREE> values;
+	T limit;
+	Event eventTripleCheck;
+	Event eventDualCheck;
+	HealthTableIF* healthTable;
+	uint8_t domainId;
+	ReturnValue_t doTriplexMonitoring() {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		//Find middle value, by ordering indices
+		uint8_t index[3] = { 0, 1, 2 };
+		if (values[index[0]].value > values[index[1]].value) {
+			std::swap(index[0], index[1]);
+		}
+		if (values[index[0]].value > values[index[2]].value) {
+			std::swap(index[0], index[2]);
+		}
+		if (values[index[1]].value > values[index[2]].value) {
+			std::swap(index[1], index[2]);
+		}
+		//Test if smallest value is out-of-limit.
+		if (values[index[0]] < (values[index[1]] - limit)) {
+			EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
+					eventTripleCheck, LOWEST_VALUE_OOL, 0);
+			result = LOWEST_VALUE_OOL;
+		}
+		//Test if largest value is out-of-limit.
+		if (values[index[2]] > (values[index[1]] + limit)) {
+			EventManagerIF::triggerEvent(getRefereneceObject(index[2]),
+					eventTripleCheck, HIGHEST_VALUE_OOL, 0);
+			if (result == HasReturnvaluesIF::RETURN_OK) {
+				result = HIGHEST_VALUE_OOL;
+			} else {
+				result = BOTH_VALUES_OOL;
+			}
+		}
+		return result;
+	}
+
+	ReturnValue_t doDuplexMonitoring(uint8_t index[2]) {
+		T mean = (values[index[0]] + values[index[1]]) / 2;
+		if (values[index[0]] > values[index[1]]) {
+			if (values[index[0]] > (mean + limit)) {
+				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
+						eventDualCheck, 0, 0);
+				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
+						eventDualCheck, 0, 0);
+				return DUPLEX_OOL;
+			}
+		} else {
+			if (values[index[1]] > (mean + limit)) {
+				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
+						eventDualCheck, 0, 0);
+				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
+						eventDualCheck, 0, 0);
+				return DUPLEX_OOL;
+			}
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual bool checkObjectHealthState(uint8_t valueIndex) = 0;
+	virtual object_id_t getRefereneceObject(uint8_t valueIndex) = 0;
+};
+
+#endif /* FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_ */
diff --git a/monitoring/TwoValueLimitMonitor.h b/monitoring/TwoValueLimitMonitor.h
index ac0ef1ee3..74934828e 100644
--- a/monitoring/TwoValueLimitMonitor.h
+++ b/monitoring/TwoValueLimitMonitor.h
@@ -1,44 +1,44 @@
-#ifndef FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
-
-#include "../monitoring/LimitMonitor.h"
-
-template<typename T>
-class TwoValueLimitMonitor: public LimitMonitor<T> {
-public:
-	TwoValueLimitMonitor(object_id_t reporterId, uint8_t monitorId,
-			uint32_t lowParameterId, uint32_t highParameterId,
-			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
-			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
-			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			LimitMonitor<T>(reporterId, monitorId, lowParameterId,
-					confirmationLimit, lowerLimit, upperLimit, belowLowEvent,
-					aboveHighEvent), highValueParameterId(highParameterId) {
-	}
-	virtual ~TwoValueLimitMonitor() {
-	}
-	ReturnValue_t doCheck(T lowSample, T highSample) {
-		T crossedLimit;
-		ReturnValue_t currentState = this->checkSample(lowSample, &crossedLimit);
-		if (currentState != HasReturnvaluesIF::RETURN_OK) {
-			return this->monitorStateIs(currentState, lowSample, crossedLimit);
-		}
-		currentState = this->checkSample(highSample, &crossedLimit);
-		return this->monitorStateIs(currentState, highSample, crossedLimit);
-	}
-protected:
-	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
-			ReturnValue_t state) {
-		uint32_t usedParameterId = this->parameterId;
-		if (state == MonitoringIF::ABOVE_HIGH_LIMIT) {
-			usedParameterId = this->highValueParameterId;
-		}
-		MonitoringReportContent<T> report(usedParameterId, parameterValue,
-				crossedLimit, this->oldState, state);
-		LimitViolationReporter::sendLimitViolationReport(&report);
-	}
-private:
-	const uint32_t highValueParameterId;
-};
-
-#endif /* FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
+#define FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
+
+#include "../monitoring/LimitMonitor.h"
+
+template<typename T>
+class TwoValueLimitMonitor: public LimitMonitor<T> {
+public:
+	TwoValueLimitMonitor(object_id_t reporterId, uint8_t monitorId,
+			uint32_t lowParameterId, uint32_t highParameterId,
+			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
+			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
+			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
+			LimitMonitor<T>(reporterId, monitorId, lowParameterId,
+					confirmationLimit, lowerLimit, upperLimit, belowLowEvent,
+					aboveHighEvent), highValueParameterId(highParameterId) {
+	}
+	virtual ~TwoValueLimitMonitor() {
+	}
+	ReturnValue_t doCheck(T lowSample, T highSample) {
+		T crossedLimit;
+		ReturnValue_t currentState = this->checkSample(lowSample, &crossedLimit);
+		if (currentState != HasReturnvaluesIF::RETURN_OK) {
+			return this->monitorStateIs(currentState, lowSample, crossedLimit);
+		}
+		currentState = this->checkSample(highSample, &crossedLimit);
+		return this->monitorStateIs(currentState, highSample, crossedLimit);
+	}
+protected:
+	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
+			ReturnValue_t state) {
+		uint32_t usedParameterId = this->parameterId;
+		if (state == MonitoringIF::ABOVE_HIGH_LIMIT) {
+			usedParameterId = this->highValueParameterId;
+		}
+		MonitoringReportContent<T> report(usedParameterId, parameterValue,
+				crossedLimit, this->oldState, state);
+		LimitViolationReporter::sendLimitViolationReport(&report);
+	}
+private:
+	const uint32_t highValueParameterId;
+};
+
+#endif /* FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_ */
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 467eed4bc..a8c844159 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,107 +1,107 @@
-#include "../objectmanager/ObjectManager.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <iomanip>
-#include <cstdlib>
-
-ObjectManager::ObjectManager( void (*setProducer)() ):
-		produceObjects(setProducer) {
-	//There's nothing special to do in the constructor.
-}
-
-
-ObjectManager::~ObjectManager() {
-	for (auto const& iter : objectList) {
-		delete iter.second;
-	}
-}
-
-ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
-	auto returnPair = objectList.emplace(id, object);
-	if (returnPair.second) {
-	    // sif::debug << "ObjectManager::insert: Object " << std::hex
-	    //            << (int)id << std::dec << " inserted." << std::endl;
-		return this->RETURN_OK;
-	} else {
-		sif::error << "ObjectManager::insert: Object id " << std::hex
-		           << (int)id << std::dec << " is already in use!" << std::endl;
-		sif::error << "Terminating program." << std::endl;
-		//This is very severe and difficult to handle in other places.
-		std::exit(INSERTION_FAILED);
-	}
-}
-
-ReturnValue_t ObjectManager::remove( object_id_t id ) {
-	if ( this->getSystemObject(id) != NULL ) {
-		this->objectList.erase( id );
-		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
-		//           << (int)id << std::dec << " removed." << std::endl;
-		return RETURN_OK;
-	} else {
-		sif::error << "ObjectManager::removeObject: Requested object "
-		        << std::hex << (int)id << std::dec << " not found." << std::endl;
-		return NOT_FOUND;
-	}
-}
-
-
-
-SystemObjectIF* ObjectManager::getSystemObject( object_id_t id ) {
-	auto listIter = this->objectList.find( id );
-	if (listIter == this->objectList.end() ) {
-		return nullptr;
-	} else {
-		return listIter->second;
-	}
-}
-
-ObjectManager::ObjectManager() : produceObjects(nullptr) {
-
-}
-
-void ObjectManager::initialize() {
-	if(produceObjects == nullptr) {
-		sif::error << "ObjectManager::initialize: Passed produceObjects "
-				"functions is nullptr!" << std::endl;
-		return;
-	}
-	this->produceObjects();
-	ReturnValue_t result = RETURN_FAILED;
-	uint32_t errorCount = 0;
-	for (auto const& it : objectList) {
-		result = it.second->initialize();
-		if ( result != RETURN_OK ) {
-			object_id_t var = it.first;
-			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
-					std::setw(8) << std::setfill('0')<< var << " failed to "
-					"initialize with code 0x" << result << std::dec <<
-					std::setfill(' ') << std::endl;
-			errorCount++;
-		}
-	}
-	if (errorCount > 0) {
-		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
-		           << " failed initializations." << std::endl;
-	}
-	//Init was successful. Now check successful interconnections.
-	errorCount = 0;
-	for (auto const& it : objectList) {
-		result = it.second->checkObjectConnections();
-		if ( result != RETURN_OK ) {
-			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
-					(int) it.first  << " connection check failed with code 0x"
-					<< result << std::dec << std::endl;
-			errorCount++;
-		}
-	}
-	if (errorCount > 0) {
-		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
-		           << " failed connection checks." << std::endl;
-	}
-}
-
-void ObjectManager::printList() {
-	sif::debug << "ObjectManager: Object List contains:" << std::endl;
-	for (auto const& it : objectList) {
-		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
-	}
-}
+#include "../objectmanager/ObjectManager.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <iomanip>
+#include <cstdlib>
+
+ObjectManager::ObjectManager( void (*setProducer)() ):
+		produceObjects(setProducer) {
+	//There's nothing special to do in the constructor.
+}
+
+
+ObjectManager::~ObjectManager() {
+	for (auto const& iter : objectList) {
+		delete iter.second;
+	}
+}
+
+ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
+	auto returnPair = objectList.emplace(id, object);
+	if (returnPair.second) {
+	    // sif::debug << "ObjectManager::insert: Object " << std::hex
+	    //            << (int)id << std::dec << " inserted." << std::endl;
+		return this->RETURN_OK;
+	} else {
+		sif::error << "ObjectManager::insert: Object id " << std::hex
+		           << (int)id << std::dec << " is already in use!" << std::endl;
+		sif::error << "Terminating program." << std::endl;
+		//This is very severe and difficult to handle in other places.
+		std::exit(INSERTION_FAILED);
+	}
+}
+
+ReturnValue_t ObjectManager::remove( object_id_t id ) {
+	if ( this->getSystemObject(id) != NULL ) {
+		this->objectList.erase( id );
+		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
+		//           << (int)id << std::dec << " removed." << std::endl;
+		return RETURN_OK;
+	} else {
+		sif::error << "ObjectManager::removeObject: Requested object "
+		        << std::hex << (int)id << std::dec << " not found." << std::endl;
+		return NOT_FOUND;
+	}
+}
+
+
+
+SystemObjectIF* ObjectManager::getSystemObject( object_id_t id ) {
+	auto listIter = this->objectList.find( id );
+	if (listIter == this->objectList.end() ) {
+		return nullptr;
+	} else {
+		return listIter->second;
+	}
+}
+
+ObjectManager::ObjectManager() : produceObjects(nullptr) {
+
+}
+
+void ObjectManager::initialize() {
+	if(produceObjects == nullptr) {
+		sif::error << "ObjectManager::initialize: Passed produceObjects "
+				"functions is nullptr!" << std::endl;
+		return;
+	}
+	this->produceObjects();
+	ReturnValue_t result = RETURN_FAILED;
+	uint32_t errorCount = 0;
+	for (auto const& it : objectList) {
+		result = it.second->initialize();
+		if ( result != RETURN_OK ) {
+			object_id_t var = it.first;
+			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
+					std::setw(8) << std::setfill('0')<< var << " failed to "
+					"initialize with code 0x" << result << std::dec <<
+					std::setfill(' ') << std::endl;
+			errorCount++;
+		}
+	}
+	if (errorCount > 0) {
+		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
+		           << " failed initializations." << std::endl;
+	}
+	//Init was successful. Now check successful interconnections.
+	errorCount = 0;
+	for (auto const& it : objectList) {
+		result = it.second->checkObjectConnections();
+		if ( result != RETURN_OK ) {
+			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
+					(int) it.first  << " connection check failed with code 0x"
+					<< result << std::dec << std::endl;
+			errorCount++;
+		}
+	}
+	if (errorCount > 0) {
+		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
+		           << " failed connection checks." << std::endl;
+	}
+}
+
+void ObjectManager::printList() {
+	sif::debug << "ObjectManager: Object List contains:" << std::endl;
+	for (auto const& it : objectList) {
+		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
+	}
+}
diff --git a/objectmanager/ObjectManager.h b/objectmanager/ObjectManager.h
index 0bc525bed..e582584cd 100644
--- a/objectmanager/ObjectManager.h
+++ b/objectmanager/ObjectManager.h
@@ -1,67 +1,67 @@
-/**
- * @file	ObjectManager.h
- * @brief	This file contains the implementation of the ObjectManager class
- * @date	18.09.2012
- * @author	Bastian Baetz
- */
-
-#ifndef OBJECTMANAGER_H_
-#define OBJECTMANAGER_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../objectmanager/SystemObjectIF.h"
-#include <map>
-
-/**
- * @brief	This class implements a global object manager.
- * @details	This manager handles a list of available objects with system-wide
- * 			relevance, such as device handlers, and TM/TC services. Objects can
- * 			be inserted, removed and retrieved from the list. In addition, the
- * 			class holds a so-called factory, that creates and inserts new
- * 			objects if they are not already in the list. This feature automates
- * 			most of the system initialization.
- * 			As the system is static after initialization, no new objects are
- * 			created or inserted into the list after startup.
- * \ingroup system_objects
- */
-class ObjectManager : public ObjectManagerIF {
-private:
-	//comparison?
-	/**
-	 * \brief	This is the map of all initialized objects in the manager.
-	 * \details	Objects in the List must inherit the SystemObjectIF.
-	 */
-	std::map<object_id_t, SystemObjectIF*> objectList;
-protected:
-	SystemObjectIF* getSystemObject( object_id_t id );
-	/**
-	 * @brief	This attribute is initialized with the factory function
-	 * 			that creates new objects.
-	 * @details	The function is called if an object was requested with
-	 * 			getSystemObject, but not found in objectList.
-	 * @param 	The id of the object to be created.
-	 * @return	Returns a pointer to the newly created object or NULL.
-	 */
-	void (*produceObjects)();
-public:
-	/**
-	 * @brief	Apart from setting the producer function, nothing special
-	 * 			happens in the constructor.
-	 * @param setProducer	A pointer to a factory function.
-	 */
-	ObjectManager( void (*produce)() );
-	ObjectManager();
-	/**
-	 *	@brief	In the class's destructor, all objects in the list are deleted.
-	 */
-	//SHOULDDO: If, for some reason, deleting an ObjectManager instance is required, check if this works.
-	virtual ~ObjectManager( void );
-	ReturnValue_t insert( object_id_t id, SystemObjectIF* object );
-	ReturnValue_t remove( object_id_t id );
-	void initialize();
-	void printList();
-};
-
-
-
-#endif /* OBJECTMANAGER_H_ */
+/**
+ * @file	ObjectManager.h
+ * @brief	This file contains the implementation of the ObjectManager class
+ * @date	18.09.2012
+ * @author	Bastian Baetz
+ */
+
+#ifndef OBJECTMANAGER_H_
+#define OBJECTMANAGER_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include <map>
+
+/**
+ * @brief	This class implements a global object manager.
+ * @details	This manager handles a list of available objects with system-wide
+ * 			relevance, such as device handlers, and TM/TC services. Objects can
+ * 			be inserted, removed and retrieved from the list. In addition, the
+ * 			class holds a so-called factory, that creates and inserts new
+ * 			objects if they are not already in the list. This feature automates
+ * 			most of the system initialization.
+ * 			As the system is static after initialization, no new objects are
+ * 			created or inserted into the list after startup.
+ * \ingroup system_objects
+ */
+class ObjectManager : public ObjectManagerIF {
+private:
+	//comparison?
+	/**
+	 * \brief	This is the map of all initialized objects in the manager.
+	 * \details	Objects in the List must inherit the SystemObjectIF.
+	 */
+	std::map<object_id_t, SystemObjectIF*> objectList;
+protected:
+	SystemObjectIF* getSystemObject( object_id_t id );
+	/**
+	 * @brief	This attribute is initialized with the factory function
+	 * 			that creates new objects.
+	 * @details	The function is called if an object was requested with
+	 * 			getSystemObject, but not found in objectList.
+	 * @param 	The id of the object to be created.
+	 * @return	Returns a pointer to the newly created object or NULL.
+	 */
+	void (*produceObjects)();
+public:
+	/**
+	 * @brief	Apart from setting the producer function, nothing special
+	 * 			happens in the constructor.
+	 * @param setProducer	A pointer to a factory function.
+	 */
+	ObjectManager( void (*produce)() );
+	ObjectManager();
+	/**
+	 *	@brief	In the class's destructor, all objects in the list are deleted.
+	 */
+	//SHOULDDO: If, for some reason, deleting an ObjectManager instance is required, check if this works.
+	virtual ~ObjectManager( void );
+	ReturnValue_t insert( object_id_t id, SystemObjectIF* object );
+	ReturnValue_t remove( object_id_t id );
+	void initialize();
+	void printList();
+};
+
+
+
+#endif /* OBJECTMANAGER_H_ */
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 5dfe8e4eb..16619e23a 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -1,95 +1,95 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
-#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
-
-#include "../objectmanager/frameworkObjects.h"
-#include "../objectmanager/SystemObjectIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-/**
- * @brief	This class provides an interface to the global object manager.
- * @details	This manager handles a list of available objects with system-wide
- * 			relevance, such as device handlers, and TM/TC services. They can be
- * 			inserted, removed and retrieved from the list. On getting the
- * 			object, the call checks if the object implements the requested
- * 			interface.
- * @author	Bastian Baetz
- * @ingroup system_objects
- */
-class ObjectManagerIF : public HasReturnvaluesIF {
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
-	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
-	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
-	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
-	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
-
-protected:
-	/**
-	 * @brief	This method is used to hide the template-based get call from
-	 * 			a specific implementation.
-	 * @details	So, an implementation only has to implement this call.
-	 * @param id	The object id of the requested object.
-	 * @return	The method returns a pointer to an object implementing (at
-	 * 			least) the SystemObjectIF, or NULL.
-	 */
-	virtual  SystemObjectIF* getSystemObject( object_id_t id ) = 0;
-public:
-	/**
-	 * @brief	This is the empty virtual destructor as requested by C++ interfaces.
-	 */
-	virtual ~ObjectManagerIF( void ) {};
-	/**
-	 * @brief	With this call, new objects are inserted to the list.
-	 * @details	The implementation shall return an error code in case the
-	 * 			object can't be added (e.g. the id is already in use).
-	 * @param id		The new id to be added to the list.
-	 * @param object	A pointer to the object to be added.
-	 * @return	@li INSERTION_FAILED in case the object could not be inserted.
-	 * 			@li RETURN_OK in case the object was successfully inserted
-	 */
-	virtual ReturnValue_t insert( object_id_t id, SystemObjectIF* object ) = 0;
-	/**
-	 * @brief	With the get call, interfaces of an object can be retrieved in
-	 * 			a type-safe manner.
-	 * @details With the template-based call, the object list is searched with the
-	 * 			getSystemObject method and afterwards it is checked, if the object
-	 * 			implements the requested interface (with a dynamic_cast).
-	 * @param id	The object id of the requested object.
-	 * @return	The method returns a pointer to an object implementing the
-	 * 			requested interface, or NULL.
-	 */
-	template <typename T> T* get( object_id_t id );
-	/**
-	 * @brief	With this call, an object is removed from the list.
-	 * @param id	The object id of the object to be removed.
-	 * @return	\li NOT_FOUND in case the object was not found
-	 * 			\li RETURN_OK in case the object was successfully removed
-	 */
-	virtual ReturnValue_t remove( object_id_t id ) = 0;
-	virtual void initialize() = 0;
-	/**
-	 * @brief	This is a debug function, that prints the current content of the
-	 * 			object list.
-	 */
-	virtual void printList() = 0;
-};
-
-
-/**
- * @brief	This is the forward declaration of the global objectManager instance.
- */
-extern ObjectManagerIF *objectManager;
-
-/*Documentation can be found in the class method declaration above.*/
-template <typename T>
-T* ObjectManagerIF::get( object_id_t id ) {
-	if(objectManager == nullptr) {
-		sif::error << "ObjectManagerIF: Global object manager has not "
-				"been initialized yet!" << std::endl;
-	}
-	SystemObjectIF* temp = this->getSystemObject(id);
-	return dynamic_cast<T*>(temp);
-}
-
-#endif /* OBJECTMANAGERIF_H_ */
+#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+
+#include "../objectmanager/frameworkObjects.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+/**
+ * @brief	This class provides an interface to the global object manager.
+ * @details	This manager handles a list of available objects with system-wide
+ * 			relevance, such as device handlers, and TM/TC services. They can be
+ * 			inserted, removed and retrieved from the list. On getting the
+ * 			object, the call checks if the object implements the requested
+ * 			interface.
+ * @author	Bastian Baetz
+ * @ingroup system_objects
+ */
+class ObjectManagerIF : public HasReturnvaluesIF {
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
+	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
+	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
+
+protected:
+	/**
+	 * @brief	This method is used to hide the template-based get call from
+	 * 			a specific implementation.
+	 * @details	So, an implementation only has to implement this call.
+	 * @param id	The object id of the requested object.
+	 * @return	The method returns a pointer to an object implementing (at
+	 * 			least) the SystemObjectIF, or NULL.
+	 */
+	virtual  SystemObjectIF* getSystemObject( object_id_t id ) = 0;
+public:
+	/**
+	 * @brief	This is the empty virtual destructor as requested by C++ interfaces.
+	 */
+	virtual ~ObjectManagerIF( void ) {};
+	/**
+	 * @brief	With this call, new objects are inserted to the list.
+	 * @details	The implementation shall return an error code in case the
+	 * 			object can't be added (e.g. the id is already in use).
+	 * @param id		The new id to be added to the list.
+	 * @param object	A pointer to the object to be added.
+	 * @return	@li INSERTION_FAILED in case the object could not be inserted.
+	 * 			@li RETURN_OK in case the object was successfully inserted
+	 */
+	virtual ReturnValue_t insert( object_id_t id, SystemObjectIF* object ) = 0;
+	/**
+	 * @brief	With the get call, interfaces of an object can be retrieved in
+	 * 			a type-safe manner.
+	 * @details With the template-based call, the object list is searched with the
+	 * 			getSystemObject method and afterwards it is checked, if the object
+	 * 			implements the requested interface (with a dynamic_cast).
+	 * @param id	The object id of the requested object.
+	 * @return	The method returns a pointer to an object implementing the
+	 * 			requested interface, or NULL.
+	 */
+	template <typename T> T* get( object_id_t id );
+	/**
+	 * @brief	With this call, an object is removed from the list.
+	 * @param id	The object id of the object to be removed.
+	 * @return	\li NOT_FOUND in case the object was not found
+	 * 			\li RETURN_OK in case the object was successfully removed
+	 */
+	virtual ReturnValue_t remove( object_id_t id ) = 0;
+	virtual void initialize() = 0;
+	/**
+	 * @brief	This is a debug function, that prints the current content of the
+	 * 			object list.
+	 */
+	virtual void printList() = 0;
+};
+
+
+/**
+ * @brief	This is the forward declaration of the global objectManager instance.
+ */
+extern ObjectManagerIF *objectManager;
+
+/*Documentation can be found in the class method declaration above.*/
+template <typename T>
+T* ObjectManagerIF::get( object_id_t id ) {
+	if(objectManager == nullptr) {
+		sif::error << "ObjectManagerIF: Global object manager has not "
+				"been initialized yet!" << std::endl;
+	}
+	SystemObjectIF* temp = this->getSystemObject(id);
+	return dynamic_cast<T*>(temp);
+}
+
+#endif /* OBJECTMANAGERIF_H_ */
diff --git a/objectmanager/SystemObject.cpp b/objectmanager/SystemObject.cpp
index e3eb22eed..61eaf90af 100644
--- a/objectmanager/SystemObject.cpp
+++ b/objectmanager/SystemObject.cpp
@@ -1,37 +1,37 @@
-#include "../events/EventManagerIF.h"
-#include "../objectmanager/ObjectManager.h"
-#include "../objectmanager/SystemObject.h"
-
-SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
-		objectId(setObjectId), registered(doRegister) {
-	if (registered) {
-		objectManager->insert(objectId, this);
-	}
-}
-
-SystemObject::~SystemObject() {
-	if (registered) {
-		objectManager->remove(objectId);
-	}
-}
-
-object_id_t SystemObject::getObjectId() const {
-	return objectId;
-}
-
-void SystemObject::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
-}
-
-ReturnValue_t SystemObject::initialize() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t SystemObject::checkObjectConnections() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void SystemObject::forwardEvent(Event event, uint32_t parameter1, uint32_t parameter2) const {
-	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
-}
+#include "../events/EventManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
+#include "../objectmanager/SystemObject.h"
+
+SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
+		objectId(setObjectId), registered(doRegister) {
+	if (registered) {
+		objectManager->insert(objectId, this);
+	}
+}
+
+SystemObject::~SystemObject() {
+	if (registered) {
+		objectManager->remove(objectId);
+	}
+}
+
+object_id_t SystemObject::getObjectId() const {
+	return objectId;
+}
+
+void SystemObject::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
+}
+
+ReturnValue_t SystemObject::initialize() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SystemObject::checkObjectConnections() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void SystemObject::forwardEvent(Event event, uint32_t parameter1, uint32_t parameter2) const {
+	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
+}
diff --git a/objectmanager/SystemObjectIF.h b/objectmanager/SystemObjectIF.h
index 54a2e8668..108717af5 100644
--- a/objectmanager/SystemObjectIF.h
+++ b/objectmanager/SystemObjectIF.h
@@ -1,62 +1,62 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
-#define FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
-
-#include "../events/EventReportingProxyIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstdint>
-/**
- * @defgroup system_objects Software System Object Management
- * The classes to create System Objects and classes to manage these are
- * contained in this group. System Objects are software elements that can be
- * controlled externally. They all have a unique object identifier.
- */
-
-/**
- * This is the typedef for object identifiers.
- * @ingroup system_objects
- */
-typedef uint32_t object_id_t;
-
-/**
- * This interface allows a class to be included in the object manager
- * list.
- * It does not provide any method definitions, still it is required to
- * perform a type check with dynamic_cast.
- * @author  Bastian Baetz
- * @ingroup system_objects
- */
-class SystemObjectIF : public EventReportingProxyIF {
-public:
-	/**
-	 * This is a simple getter to return the object identifier.
-	 * @return	Returns the object id of this object.
-	 */
-	virtual object_id_t getObjectId() const = 0;
-	/**
-	 * The empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~SystemObjectIF() {}
-	/**
-	 * @brief   Initializes the object.
-	 * There are initialization steps which can also be done in the constructor.
-	 * However, there is no clean way to get a returnvalue from a constructor.
-	 * Furthermore some components require other system object to be created
-	 * which might not have been built yet.
-	 * Therefore, a two-step initialization resolves this problem and prevents
-	 * circular dependencies of not-fully initialized objects on start up.
-	 * @return	- @c RETURN_OK in case the initialization was successful
-	 * 			- @c RETURN_FAILED otherwise
-	 */
-	virtual ReturnValue_t initialize() = 0;
-	/**
-	 * @brief   Checks if all object-object interconnections are satisfying
-	 *          for operation.
-	 * Some objects need certain other objects (or a certain number), to be
-	 * registered as children. These checks can be done in this method.
-	 * @return	- @c RETURN_OK in case the check was successful
-	 * 			- @c any other code otherwise
-	 */
-	virtual ReturnValue_t checkObjectConnections() = 0;
-};
-
-#endif /* FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */
+#ifndef FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+#define FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+
+#include "../events/EventReportingProxyIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstdint>
+/**
+ * @defgroup system_objects Software System Object Management
+ * The classes to create System Objects and classes to manage these are
+ * contained in this group. System Objects are software elements that can be
+ * controlled externally. They all have a unique object identifier.
+ */
+
+/**
+ * This is the typedef for object identifiers.
+ * @ingroup system_objects
+ */
+typedef uint32_t object_id_t;
+
+/**
+ * This interface allows a class to be included in the object manager
+ * list.
+ * It does not provide any method definitions, still it is required to
+ * perform a type check with dynamic_cast.
+ * @author  Bastian Baetz
+ * @ingroup system_objects
+ */
+class SystemObjectIF : public EventReportingProxyIF {
+public:
+	/**
+	 * This is a simple getter to return the object identifier.
+	 * @return	Returns the object id of this object.
+	 */
+	virtual object_id_t getObjectId() const = 0;
+	/**
+	 * The empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~SystemObjectIF() {}
+	/**
+	 * @brief   Initializes the object.
+	 * There are initialization steps which can also be done in the constructor.
+	 * However, there is no clean way to get a returnvalue from a constructor.
+	 * Furthermore some components require other system object to be created
+	 * which might not have been built yet.
+	 * Therefore, a two-step initialization resolves this problem and prevents
+	 * circular dependencies of not-fully initialized objects on start up.
+	 * @return	- @c RETURN_OK in case the initialization was successful
+	 * 			- @c RETURN_FAILED otherwise
+	 */
+	virtual ReturnValue_t initialize() = 0;
+	/**
+	 * @brief   Checks if all object-object interconnections are satisfying
+	 *          for operation.
+	 * Some objects need certain other objects (or a certain number), to be
+	 * registered as children. These checks can be done in this method.
+	 * @return	- @c RETURN_OK in case the check was successful
+	 * 			- @c any other code otherwise
+	 */
+	virtual ReturnValue_t checkObjectConnections() = 0;
+};
+
+#endif /* FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 8c831bbe4..dd1e48ca9 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -1,95 +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;
-}
+#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;
+}
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 0b30c094f..4317e0b23 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -1,79 +1,79 @@
-#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.
- * This semaphore is bound to the task it is created in!
- * Take care of calling this function with the correct executing task,
- * (for example in the initializeAfterTaskCreation() function).
- */
-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_ */
+#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.
+ * This semaphore is bound to the task it is created in!
+ * Take care of calling this function with the correct executing task,
+ * (for example in the initializeAfterTaskCreation() function).
+ */
+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_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index f1c784739..8cc3c4957 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -1,108 +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;
-	}
-}
+#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;
+	}
+}
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 5a32088a1..c6cedc539 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -1,107 +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_ */
+#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_ */
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index 48d7bc078..d556444c4 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -1,196 +1,196 @@
-#include "../../timemanager/Clock.h"
-#include "../../globalfunctions/timevalOperations.h"
-#include "../../osal/FreeRTOS/Timekeeper.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-#include <stdlib.h>
-#include <time.h>
-
-//TODO sanitize input?
-//TODO much of this code can be reused for tick-only systems
-
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = nullptr;
-
-uint32_t Clock::getTicksPerSecond(void) {
-	return 1000;
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-
-	timeval time_timeval;
-
-	ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
-
-	return setClock(&time_timeval);
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	timeval uptime = getUptime();
-
-	timeval offset = *time - uptime;
-
-	Timekeeper::instance()->setOffset(offset);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	timeval uptime = getUptime();
-
-	timeval offset = Timekeeper::instance()->getOffset();
-
-	*time = offset + uptime;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	*uptime = getUptime();
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-timeval Clock::getUptime() {
-	TickType_t ticksSinceStart = xTaskGetTickCount();
-	return Timekeeper::ticksToTimeval(ticksSinceStart);
-}
-
-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::getClock_usecs(uint64_t* time) {
-	timeval time_timeval;
-	ReturnValue_t result = getClock_timeval(&time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	*time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	timeval time_timeval;
-	ReturnValue_t result = getClock_timeval(&time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	struct tm time_tm;
-
-	gmtime_r(&time_timeval.tv_sec,&time_tm);
-
-	time->year = time_tm.tm_year + 1900;
-	time->month = time_tm.tm_mon + 1;
-	time->day = time_tm.tm_mday;
-
-	time->hour = time_tm.tm_hour;
-	time->minute = time_tm.tm_min;
-	time->second = time_tm.tm_sec;
-
-	time->usecond = time_timeval.tv_usec;
-
-
-	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;
-}
-
-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 == nullptr) {
-		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 == NULL) {
-		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 == NULL) {
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../timemanager/Clock.h"
+#include "../../globalfunctions/timevalOperations.h"
+#include "../../osal/FreeRTOS/Timekeeper.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+#include <stdlib.h>
+#include <time.h>
+
+//TODO sanitize input?
+//TODO much of this code can be reused for tick-only systems
+
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = nullptr;
+
+uint32_t Clock::getTicksPerSecond(void) {
+	return 1000;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+
+	timeval time_timeval;
+
+	ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
+	if (result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+
+	return setClock(&time_timeval);
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	timeval uptime = getUptime();
+
+	timeval offset = *time - uptime;
+
+	Timekeeper::instance()->setOffset(offset);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+	timeval uptime = getUptime();
+
+	timeval offset = Timekeeper::instance()->getOffset();
+
+	*time = offset + uptime;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	*uptime = getUptime();
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+timeval Clock::getUptime() {
+	TickType_t ticksSinceStart = xTaskGetTickCount();
+	return Timekeeper::ticksToTimeval(ticksSinceStart);
+}
+
+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::getClock_usecs(uint64_t* time) {
+	timeval time_timeval;
+	ReturnValue_t result = getClock_timeval(&time_timeval);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	*time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	timeval time_timeval;
+	ReturnValue_t result = getClock_timeval(&time_timeval);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	struct tm time_tm;
+
+	gmtime_r(&time_timeval.tv_sec,&time_tm);
+
+	time->year = time_tm.tm_year + 1900;
+	time->month = time_tm.tm_mon + 1;
+	time->day = time_tm.tm_mday;
+
+	time->hour = time_tm.tm_hour;
+	time->minute = time_tm.tm_min;
+	time->second = time_tm.tm_sec;
+
+	time->usecond = time_timeval.tv_usec;
+
+
+	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;
+}
+
+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 == nullptr) {
+		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 == NULL) {
+		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 == NULL) {
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index e66671ac6..a47341bcb 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -1,114 +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;
-}
+#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;
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index d3b23ebe2..49ff3ee54 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -1,105 +1,105 @@
-#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.
- *  This semaphore is bound to the task it is created in!
- *  Take care of calling this function with the correct executing task,
- *  (for example in the initializeAfterTaskCreation() function).
- */
-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_ */
+#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.
+ *  This semaphore is bound to the task it is created in!
+ *  Take care of calling this function with the correct executing task,
+ *  (for example in the initializeAfterTaskCreation() function).
+ */
+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_ */
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index 0b218e544..d1310a6ab 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,43 +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;
-}
+#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;
+}
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index 9432ed81e..ae2f62aee 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -1,34 +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_ */
+#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_ */
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 772c4bca6..404c3c05c 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -1,166 +1,166 @@
-#include "FixedTimeslotTask.h"
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
-
-FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
-		TaskStackSize setStack, TaskPeriod overallPeriod,
-		void (*setDeadlineMissedFunc)()) :
-		started(false), handle(nullptr), pst(overallPeriod * 1000) {
-	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;
-}
-
-FixedTimeslotTask::~FixedTimeslotTask() {
-}
-
-void FixedTimeslotTask::taskEntryPoint(void* argument) {
-
-	// The argument is re-interpreted as FixedTimeslotTask. The Task object is
-    // global, so it is found from any place.
-	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
-	/* Task should not start until explicitly requested,
-	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
-	 * is running but not if the scheduler is not running.
-	 * To be able to accommodate both cases we check a member which is set in
-	 * #startTask(). If it is not set and we get here, the scheduler was started
-	 * before #startTask() was called and we need to suspend if it is set,
-	 * the scheduler was not running before #startTask() was called and we
-	 * can continue */
-
-	if (not originalTask->started) {
-		vTaskSuspend(NULL);
-	}
-
-	originalTask->taskFunctionality();
-	sif::debug << "Polling task " << originalTask->handle
-			<< " returned from taskFunctionality." << std::endl;
-}
-
-void FixedTimeslotTask::missedDeadlineCounter() {
-	FixedTimeslotTask::deadlineMissedCount++;
-	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
-				<< " deadlines." << std::endl;
-	}
-}
-
-ReturnValue_t FixedTimeslotTask::startTask() {
-	started = true;
-
-	// We must not call resume if scheduler is not started yet
-	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
-		vTaskResume(handle);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-    ExecutableObjectIF* handler =
-            objectManager->get<ExecutableObjectIF>(componentId);
-	if (handler != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, handler, this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t FixedTimeslotTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
-	return pst.checkSequence();
-}
-
-void FixedTimeslotTask::taskFunctionality() {
-	// A local iterator for the Polling Sequence Table is created to find the
-    // start time for the first entry.
-	auto slotListIter = pst.current;
-
-	pst.intializeSequenceAfterTaskCreation();
-
-	//The start time for the first entry is read.
-	uint32_t intervalMs = slotListIter->pollingTimeMs;
-	TickType_t interval = pdMS_TO_TICKS(intervalMs);
-
-	TickType_t xLastWakeTime;
-	/* 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
-	 internally within vTaskDelayUntil(). */
-	xLastWakeTime = xTaskGetTickCount();
-
-	// wait for first entry's start time
-	if(interval > 0) {
-	    vTaskDelayUntil(&xLastWakeTime, interval);
-	}
-
-	/* Enter the loop that defines the task behavior. */
-	for (;;) {
-		//The component for this slot is executed and the next one is chosen.
-	    this->pst.executeAndAdvance();
-	    if (not pst.slotFollowsImmediately()) {
-	        // Get the interval till execution of the next slot.
-	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
-	        interval = pdMS_TO_TICKS(intervalMs);
-
-	        checkMissedDeadline(xLastWakeTime, interval);
-
-	        // Wait for the interval. This exits immediately if a deadline was
-	        // missed while also updating the last wake time.
-	        vTaskDelayUntil(&xLastWakeTime, interval);
-	    }
-	}
-}
-
-void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-}
-
-void FixedTimeslotTask::handleMissedDeadline() {
-#ifdef DEBUG
-    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
-            " missed deadline!\n" << std::flush;
-#endif
-    if(deadlineMissedFunc != nullptr) {
-        this->deadlineMissedFunc();
-    }
-}
-
-ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
-	vTaskDelay(pdMS_TO_TICKS(ms));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-TaskHandle_t FixedTimeslotTask::getTaskHandle() {
-    return handle;
-}
+#include "FixedTimeslotTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
+
+FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
+		TaskStackSize setStack, TaskPeriod overallPeriod,
+		void (*setDeadlineMissedFunc)()) :
+		started(false), handle(nullptr), pst(overallPeriod * 1000) {
+	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;
+}
+
+FixedTimeslotTask::~FixedTimeslotTask() {
+}
+
+void FixedTimeslotTask::taskEntryPoint(void* argument) {
+
+	// The argument is re-interpreted as FixedTimeslotTask. The Task object is
+    // global, so it is found from any place.
+	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
+
+	if (not originalTask->started) {
+		vTaskSuspend(NULL);
+	}
+
+	originalTask->taskFunctionality();
+	sif::debug << "Polling task " << originalTask->handle
+			<< " returned from taskFunctionality." << std::endl;
+}
+
+void FixedTimeslotTask::missedDeadlineCounter() {
+	FixedTimeslotTask::deadlineMissedCount++;
+	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
+				<< " deadlines." << std::endl;
+	}
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+	started = true;
+
+	// We must not call resume if scheduler is not started yet
+	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
+		vTaskResume(handle);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+		uint32_t slotTimeMs, int8_t executionStep) {
+    ExecutableObjectIF* handler =
+            objectManager->get<ExecutableObjectIF>(componentId);
+	if (handler != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, handler, this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+	return pst.getLengthMs();
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+	return pst.checkSequence();
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+	// A local iterator for the Polling Sequence Table is created to find the
+    // start time for the first entry.
+	auto slotListIter = pst.current;
+
+	pst.intializeSequenceAfterTaskCreation();
+
+	//The start time for the first entry is read.
+	uint32_t intervalMs = slotListIter->pollingTimeMs;
+	TickType_t interval = pdMS_TO_TICKS(intervalMs);
+
+	TickType_t xLastWakeTime;
+	/* 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
+	 internally within vTaskDelayUntil(). */
+	xLastWakeTime = xTaskGetTickCount();
+
+	// wait for first entry's start time
+	if(interval > 0) {
+	    vTaskDelayUntil(&xLastWakeTime, interval);
+	}
+
+	/* Enter the loop that defines the task behavior. */
+	for (;;) {
+		//The component for this slot is executed and the next one is chosen.
+	    this->pst.executeAndAdvance();
+	    if (not pst.slotFollowsImmediately()) {
+	        // Get the interval till execution of the next slot.
+	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
+	        interval = pdMS_TO_TICKS(intervalMs);
+
+	        checkMissedDeadline(xLastWakeTime, interval);
+
+	        // Wait for the interval. This exits immediately if a deadline was
+	        // missed while also updating the last wake time.
+	        vTaskDelayUntil(&xLastWakeTime, interval);
+	    }
+	}
+}
+
+void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Time to wake has not overflown.
+    if(timeToWake > xLastWakeTime) {
+        /* If the current time has overflown exclusively or the current
+         * tick count is simply larger than the time to wake, a deadline was
+         * missed */
+        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
+            handleMissedDeadline();
+        }
+    }
+    /* Time to wake has overflown. A deadline was missed if the current time
+     * is larger than the time to wake */
+    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
+        handleMissedDeadline();
+    }
+}
+
+void FixedTimeslotTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
+	vTaskDelay(pdMS_TO_TICKS(ms));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+TaskHandle_t FixedTimeslotTask::getTaskHandle() {
+    return handle;
+}
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 42af14b84..c46de5b7b 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,101 +1,101 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
-
-#include "../../osal/FreeRTOS/FreeRTOSTaskIF.h"
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../tasks/FixedTimeslotTaskIF.h"
-#include "../../tasks/Typedef.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-class FixedTimeslotTask: public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
-public:
-
-	/**
-	 * Keep in mind that you need to call before vTaskStartScheduler()!
-	 * A lot of task parameters are set in "FreeRTOSConfig.h".
-	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
-	 * @param setPriority Number of priorities specified by
-	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
-	 * @param setStack	Stack size in words (not bytes!).
-	 * Lower limit specified by configMINIMAL_STACK_SIZE
-	 * @param overallPeriod		Period in seconds.
-	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
-	 * @return Pointer to the newly created task.
-	 */
-	FixedTimeslotTask(TaskName name, TaskPriority setPriority,
-			TaskStackSize setStack, TaskPeriod overallPeriod,
-			void (*setDeadlineMissedFunc)());
-
-	/**
-	 * @brief	The destructor of the class.
-	 * @details
-	 * The destructor frees all heap memory that was allocated on thread
-	 * initialization for the PST and the device handlers. This is done by
-	 * calling the PST's destructor.
-	 */
-	virtual ~FixedTimeslotTask(void);
-
-	ReturnValue_t startTask(void);
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines
-	 * every 10th time.
-	 */
-	static void missedDeadlineCounter();
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-			int8_t executionStep) override;
-
-	uint32_t getPeriodMs() const override;
-
-	ReturnValue_t checkSequence() const override;
-
-	ReturnValue_t sleepFor(uint32_t ms) override;
-
-	TaskHandle_t getTaskHandle() override;
-
-protected:
-	bool started;
-	TaskHandle_t handle;
-
-	FixedSlotSequence pst;
-
-	/**
-	 * @brief	This attribute holds a function pointer that is executed when
-	 *          a deadline was missed.
-	 * @details
-	 * Another function may be announced to determine the actions to perform
-	 * when a deadline was missed. Currently, only one function for missing
-	 * any deadline is allowed. If not used, it shall be declared NULL.
-	 */
-	void (*deadlineMissedFunc)(void);
-	/**
-	 * @brief	This is the entry point for a new task.
-	 * @details
-	 * This method starts the task by calling taskFunctionality(), as soon as
-	 * all requirements (task scheduler has started and startTask()
-	 * has been called) are met.
-	 */
-	static void taskEntryPoint(void* argument);
-
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 * @details
-	 * Core function holding the main functionality of the task
-	 * It links the functionalities provided by FixedSlotSequence with the
-	 * OS's System Calls to keep the timing of the periods.
-	 */
-	void taskFunctionality(void);
-
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
-	void handleMissedDeadline();
-};
-
-#endif /* POLLINGTASK_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+
+#include "../../osal/FreeRTOS/FreeRTOSTaskIF.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+class FixedTimeslotTask: public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
+public:
+
+	/**
+	 * Keep in mind that you need to call before vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
+	 * @param setPriority Number of priorities specified by
+	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
+	 * @param setStack	Stack size in words (not bytes!).
+	 * Lower limit specified by configMINIMAL_STACK_SIZE
+	 * @param overallPeriod		Period in seconds.
+	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
+	 * @return Pointer to the newly created task.
+	 */
+	FixedTimeslotTask(TaskName name, TaskPriority setPriority,
+			TaskStackSize setStack, TaskPeriod overallPeriod,
+			void (*setDeadlineMissedFunc)());
+
+	/**
+	 * @brief	The destructor of the class.
+	 * @details
+	 * The destructor frees all heap memory that was allocated on thread
+	 * initialization for the PST and the device handlers. This is done by
+	 * calling the PST's destructor.
+	 */
+	virtual ~FixedTimeslotTask(void);
+
+	ReturnValue_t startTask(void);
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines
+	 * every 10th time.
+	 */
+	static void missedDeadlineCounter();
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+			int8_t executionStep) override;
+
+	uint32_t getPeriodMs() const override;
+
+	ReturnValue_t checkSequence() const override;
+
+	ReturnValue_t sleepFor(uint32_t ms) override;
+
+	TaskHandle_t getTaskHandle() override;
+
+protected:
+	bool started;
+	TaskHandle_t handle;
+
+	FixedSlotSequence pst;
+
+	/**
+	 * @brief	This attribute holds a function pointer that is executed when
+	 *          a deadline was missed.
+	 * @details
+	 * Another function may be announced to determine the actions to perform
+	 * when a deadline was missed. Currently, only one function for missing
+	 * any deadline is allowed. If not used, it shall be declared NULL.
+	 */
+	void (*deadlineMissedFunc)(void);
+	/**
+	 * @brief	This is the entry point for a new task.
+	 * @details
+	 * This method starts the task by calling taskFunctionality(), as soon as
+	 * all requirements (task scheduler has started and startTask()
+	 * has been called) are met.
+	 */
+	static void taskEntryPoint(void* argument);
+
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 * @details
+	 * Core function holding the main functionality of the task
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
+	 */
+	void taskFunctionality(void);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
+};
+
+#endif /* POLLINGTASK_H_ */
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 11986751e..e953ec34b 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -1,149 +1,149 @@
-#ifndef FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
-#define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
-
-#include "../../internalError/InternalErrorReporterIF.h"
-#include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/MessageQueueMessageIF.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/queue.h>
-
-// TODO: this class assumes that MessageQueueId_t is the same size as void*
-// (the FreeRTOS handle type), compiler will catch this but it might be nice
-// to have something checking or even an always working solution
-// https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
-
-/**
- * @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();
-
-	/**
-	 * This function is used to switch the call context. This has to be called
-	 * if a message is sent or received from an ISR!
-	 * @param callContext
-	 */
-	void switchSystemContext(CallContext callContext);
-
-	/** MessageQueueIF implementation */
-	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false) override;
-
-	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-
-	ReturnValue_t reply(MessageQueueMessageIF* message) override;
-	virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault = false) override;
-
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault = false) override;
-
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) override;
-
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
-
-	ReturnValue_t flush(uint32_t* count) override;
-
-	MessageQueueId_t getLastPartner() const override;
-
-	MessageQueueId_t getId() const override;
-
-	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
-
-	MessageQueueId_t getDefaultDestination() const override;
-
-	bool isDefaultDestinationSet() const override;
-
-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, CallContext callContext = CallContext::TASK);
-
-	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
-
-private:
-	bool defaultDestinationSet = false;
-	QueueHandle_t handle;
-	MessageQueueId_t defaultDestination = 0;
-	MessageQueueId_t lastPartner = 0;
-	const size_t maxMessageSize;
-	//! Stores the current system context
-	CallContext callContext =  CallContext::TASK;
-};
-
-#endif /* FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_ */
+#ifndef FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
+#define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessageIF.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+
+// TODO: this class assumes that MessageQueueId_t is the same size as void*
+// (the FreeRTOS handle type), compiler will catch this but it might be nice
+// to have something checking or even an always working solution
+// https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
+
+/**
+ * @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();
+
+	/**
+	 * This function is used to switch the call context. This has to be called
+	 * if a message is sent or received from an ISR!
+	 * @param callContext
+	 */
+	void switchSystemContext(CallContext callContext);
+
+	/** MessageQueueIF implementation */
+	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false) override;
+
+	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
+	virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) override;
+
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
+
+	ReturnValue_t flush(uint32_t* count) override;
+
+	MessageQueueId_t getLastPartner() const override;
+
+	MessageQueueId_t getId() const override;
+
+	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+
+	MessageQueueId_t getDefaultDestination() const override;
+
+	bool isDefaultDestinationSet() const override;
+
+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, CallContext callContext = CallContext::TASK);
+
+	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
+private:
+	bool defaultDestinationSet = false;
+	QueueHandle_t handle;
+	MessageQueueId_t defaultDestination = 0;
+	MessageQueueId_t lastPartner = 0;
+	const size_t maxMessageSize;
+	//! Stores the current system context
+	CallContext callContext =  CallContext::TASK;
+};
+
+#endif /* FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_ */
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 8d2e43b87..82f23ff98 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -1,51 +1,51 @@
-#include "../../osal/FreeRTOS/Mutex.h"
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-Mutex::Mutex() {
-	handle = xSemaphoreCreateMutex();
-	if(handle == nullptr) {
-		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
-	}
-}
-
-Mutex::~Mutex() {
-	if (handle != nullptr) {
-		vSemaphoreDelete(handle);
-	}
-
-}
-
-ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType,
-        uint32_t timeoutMs) {
-	if (handle == nullptr) {
-		return MutexIF::MUTEX_NOT_FOUND;
-	}
-	// If the timeout type is BLOCKING, this will be the correct value.
-	uint32_t timeout = portMAX_DELAY;
-	if(timeoutType == TimeoutType::POLLING) {
-		timeout = 0;
-	}
-	else if(timeoutType == TimeoutType::WAITING){
-		timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-
-	BaseType_t returncode = xSemaphoreTake(handle, timeout);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return MutexIF::MUTEX_TIMEOUT;
-	}
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	if (handle == nullptr) {
-		return MutexIF::MUTEX_NOT_FOUND;
-	}
-	BaseType_t returncode = xSemaphoreGive(handle);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	}
-}
+#include "../../osal/FreeRTOS/Mutex.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+Mutex::Mutex() {
+	handle = xSemaphoreCreateMutex();
+	if(handle == nullptr) {
+		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
+	}
+}
+
+Mutex::~Mutex() {
+	if (handle != nullptr) {
+		vSemaphoreDelete(handle);
+	}
+
+}
+
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+	if (handle == nullptr) {
+		return MutexIF::MUTEX_NOT_FOUND;
+	}
+	// If the timeout type is BLOCKING, this will be the correct value.
+	uint32_t timeout = portMAX_DELAY;
+	if(timeoutType == TimeoutType::POLLING) {
+		timeout = 0;
+	}
+	else if(timeoutType == TimeoutType::WAITING){
+		timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+
+	BaseType_t returncode = xSemaphoreTake(handle, timeout);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return MutexIF::MUTEX_TIMEOUT;
+	}
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	if (handle == nullptr) {
+		return MutexIF::MUTEX_NOT_FOUND;
+	}
+	BaseType_t returncode = xSemaphoreGive(handle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	}
+}
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 5cbc6a72e..156d431c2 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -1,29 +1,29 @@
-#ifndef FRAMEWORK_FREERTOS_MUTEX_H_
-#define FRAMEWORK_FREERTOS_MUTEX_H_
-
-#include "../../ipc/MutexIF.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/semphr.h>
-
-/**
- * @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();
-	~Mutex();
-	ReturnValue_t lockMutex(TimeoutType timeoutType,
-	        uint32_t timeoutMs) override;
-	ReturnValue_t unlockMutex() override;
-
-private:
-	SemaphoreHandle_t handle;
-};
-
-#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
+#ifndef FRAMEWORK_FREERTOS_MUTEX_H_
+#define FRAMEWORK_FREERTOS_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+
+/**
+ * @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();
+	~Mutex();
+	ReturnValue_t lockMutex(TimeoutType timeoutType,
+	        uint32_t timeoutMs) override;
+	ReturnValue_t unlockMutex() override;
+
+private:
+	SemaphoreHandle_t handle;
+};
+
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/osal/FreeRTOS/MutexFactory.cpp b/osal/FreeRTOS/MutexFactory.cpp
index 9dcd85363..1f34cc18f 100644
--- a/osal/FreeRTOS/MutexFactory.cpp
+++ b/osal/FreeRTOS/MutexFactory.cpp
@@ -1,28 +1,28 @@
-#include "../../ipc/MutexFactory.h"
-#include "../../osal/FreeRTOS/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;
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/FreeRTOS/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;
+}
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index 050917335..cd99afd98 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -1,36 +1,36 @@
-#include "../../ipc/QueueFactory.h"
-
-#include "../../osal/FreeRTOS/MessageQueue.h"
-
-
-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);
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == nullptr) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+
+#include "../../osal/FreeRTOS/MessageQueue.h"
+
+
+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);
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == nullptr) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 8575cf4aa..beb0d096d 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -1,59 +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;
-}
+#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;
+}
diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index b68b05b3e..3ac5cb495 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -1,53 +1,53 @@
-#include "../../tasks/TaskFactory.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-#include "PeriodicTask.h"
-#include "FixedTimeslotTask.h"
-
-
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
-		TaskPriority taskPriority_, TaskStackSize stackSize_,
-		TaskPeriod period_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return dynamic_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_,
-			stackSize_, period_, deadLineMissedFunction_));
-}
-
-/**
- * Keep in Mind that you need to call before this vTaskStartScheduler()!
- */
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-		TaskPriority taskPriority_, TaskStackSize stackSize_,
-		TaskPeriod period_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return dynamic_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_,
-			taskPriority_,stackSize_, period_, deadLineMissedFunction_));
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	if (task == nullptr) {
-		//delete self
-		vTaskDelete(nullptr);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		//TODO not implemented
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
-	vTaskDelay(pdMS_TO_TICKS(delayMs));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-TaskFactory::TaskFactory() {
-}
+#include "../../tasks/TaskFactory.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+#include "PeriodicTask.h"
+#include "FixedTimeslotTask.h"
+
+
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_, TaskStackSize stackSize_,
+		TaskPeriod period_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return dynamic_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_,
+			stackSize_, period_, deadLineMissedFunction_));
+}
+
+/**
+ * Keep in Mind that you need to call before this vTaskStartScheduler()!
+ */
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_, TaskStackSize stackSize_,
+		TaskPeriod period_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return dynamic_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_,
+			taskPriority_,stackSize_, period_, deadLineMissedFunction_));
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	if (task == nullptr) {
+		//delete self
+		vTaskDelete(nullptr);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		//TODO not implemented
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
+	vTaskDelay(pdMS_TO_TICKS(delayMs));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+TaskFactory::TaskFactory() {
+}
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 16682d361..b77f12a9e 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,24 +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);
-}
+#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);
+}
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 43003d763..4b7fe3eb3 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -1,64 +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_ */
+#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_ */
diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index f7a3c8f85..836f0b21d 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -1,41 +1,41 @@
-#include "../../osal/FreeRTOS/Timekeeper.h"
-
-#include "FreeRTOSConfig.h"
-
-Timekeeper * Timekeeper::myinstance = nullptr;
-
-Timekeeper::Timekeeper() : offset( { 0, 0 } ) {}
-
-Timekeeper::~Timekeeper() {}
-
-const timeval& Timekeeper::getOffset() const {
-	return offset;
-}
-
-Timekeeper* Timekeeper::instance() {
-	if (myinstance == nullptr) {
-		myinstance = new Timekeeper();
-	}
-	return myinstance;
-}
-
-void Timekeeper::setOffset(const timeval& offset) {
-	this->offset = offset;
-}
-
-timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
-	timeval uptime;
-	uptime.tv_sec = ticks / configTICK_RATE_HZ;
-
-	//TODO explain, think about overflow
-	uint32_t subsecondTicks = ticks % configTICK_RATE_HZ;
-	uint64_t usecondTicks = subsecondTicks * 1000000;
-
-	uptime.tv_usec = usecondTicks / configTICK_RATE_HZ;
-
-	return uptime;
-}
-
-TickType_t Timekeeper::getTicks() {
-    return xTaskGetTickCount();
-}
+#include "../../osal/FreeRTOS/Timekeeper.h"
+
+#include "FreeRTOSConfig.h"
+
+Timekeeper * Timekeeper::myinstance = nullptr;
+
+Timekeeper::Timekeeper() : offset( { 0, 0 } ) {}
+
+Timekeeper::~Timekeeper() {}
+
+const timeval& Timekeeper::getOffset() const {
+	return offset;
+}
+
+Timekeeper* Timekeeper::instance() {
+	if (myinstance == nullptr) {
+		myinstance = new Timekeeper();
+	}
+	return myinstance;
+}
+
+void Timekeeper::setOffset(const timeval& offset) {
+	this->offset = offset;
+}
+
+timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
+	timeval uptime;
+	uptime.tv_sec = ticks / configTICK_RATE_HZ;
+
+	//TODO explain, think about overflow
+	uint32_t subsecondTicks = ticks % configTICK_RATE_HZ;
+	uint64_t usecondTicks = subsecondTicks * 1000000;
+
+	uptime.tv_usec = usecondTicks / configTICK_RATE_HZ;
+
+	return uptime;
+}
+
+TickType_t Timekeeper::getTicks() {
+    return xTaskGetTickCount();
+}
diff --git a/osal/FreeRTOS/Timekeeper.h b/osal/FreeRTOS/Timekeeper.h
index fc1664e20..7d583f7db 100644
--- a/osal/FreeRTOS/Timekeeper.h
+++ b/osal/FreeRTOS/Timekeeper.h
@@ -1,40 +1,40 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
-#define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
-
-#include "../../timemanager/Clock.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-
-/**
- * A Class to basically store the time difference between uptime and UTC
- * so the "time-agnostic" FreeRTOS can keep an UTC Time
- *
- * Implemented as Singleton, so the FSFW Clock Implementation (see Clock.cpp)
- * can use it without having a member.
- */
-
-class Timekeeper {
-private:
-	Timekeeper();
-
-	timeval offset;
-
-	static Timekeeper * myinstance;
-public:
-	static Timekeeper * instance();
-	virtual ~Timekeeper();
-
-	static timeval ticksToTimeval(TickType_t ticks);
-    /**
-     * Get elapsed time in system ticks.
-     * @return
-     */
-    static TickType_t getTicks();
-
-	const timeval& getOffset() const;
-	void setOffset(const timeval& offset);
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
+#define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
+
+#include "../../timemanager/Clock.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+
+/**
+ * A Class to basically store the time difference between uptime and UTC
+ * so the "time-agnostic" FreeRTOS can keep an UTC Time
+ *
+ * Implemented as Singleton, so the FSFW Clock Implementation (see Clock.cpp)
+ * can use it without having a member.
+ */
+
+class Timekeeper {
+private:
+	Timekeeper();
+
+	timeval offset;
+
+	static Timekeeper * myinstance;
+public:
+	static Timekeeper * instance();
+	virtual ~Timekeeper();
+
+	static timeval ticksToTimeval(TickType_t ticks);
+    /**
+     * Get elapsed time in system ticks.
+     * @return
+     */
+    static TickType_t getTicks();
+
+	const timeval& getOffset() const;
+	void setOffset(const timeval& offset);
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ */
diff --git a/osal/InternalErrorCodes.h b/osal/InternalErrorCodes.h
index d89eb230f..1da116fa3 100644
--- a/osal/InternalErrorCodes.h
+++ b/osal/InternalErrorCodes.h
@@ -1,39 +1,39 @@
-#ifndef INTERNALERRORCODES_H_
-#define INTERNALERRORCODES_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-class InternalErrorCodes {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::INTERNAL_ERROR_CODES;
-
-static const ReturnValue_t NO_CONFIGURATION_TABLE = MAKE_RETURN_CODE(0x01 );
-static const ReturnValue_t NO_CPU_TABLE = MAKE_RETURN_CODE(0x02 );
-static const ReturnValue_t INVALID_WORKSPACE_ADDRESS = MAKE_RETURN_CODE(0x03 );
-static const ReturnValue_t TOO_LITTLE_WORKSPACE = MAKE_RETURN_CODE(0x04 );
-static const ReturnValue_t WORKSPACE_ALLOCATION = MAKE_RETURN_CODE(0x05 );
-static const ReturnValue_t INTERRUPT_STACK_TOO_SMALL = MAKE_RETURN_CODE(0x06 );
-static const ReturnValue_t THREAD_EXITTED = MAKE_RETURN_CODE(0x07 );
-static const ReturnValue_t INCONSISTENT_MP_INFORMATION = MAKE_RETURN_CODE(0x08 );
-static const ReturnValue_t INVALID_NODE = MAKE_RETURN_CODE(0x09 );
-static const ReturnValue_t NO_MPCI = MAKE_RETURN_CODE(0x0a );
-static const ReturnValue_t BAD_PACKET = MAKE_RETURN_CODE(0x0b );
-static const ReturnValue_t OUT_OF_PACKETS = MAKE_RETURN_CODE(0x0c );
-static const ReturnValue_t OUT_OF_GLOBAL_OBJECTS = MAKE_RETURN_CODE(0x0d );
-static const ReturnValue_t OUT_OF_PROXIES = MAKE_RETURN_CODE(0x0e );
-static const ReturnValue_t INVALID_GLOBAL_ID = MAKE_RETURN_CODE(0x0f );
-static const ReturnValue_t BAD_STACK_HOOK = MAKE_RETURN_CODE(0x10 );
-static const ReturnValue_t BAD_ATTRIBUTES = MAKE_RETURN_CODE(0x11 );
-static const ReturnValue_t IMPLEMENTATION_KEY_CREATE_INCONSISTENCY = MAKE_RETURN_CODE(0x12 );
-static const ReturnValue_t IMPLEMENTATION_BLOCKING_OPERATION_CANCEL = MAKE_RETURN_CODE(0x13 );
-static const ReturnValue_t MUTEX_OBTAIN_FROM_BAD_STATE = MAKE_RETURN_CODE(0x14 );
-static const ReturnValue_t UNLIMITED_AND_MAXIMUM_IS_0 = MAKE_RETURN_CODE(0x15 );
-
-	virtual ~InternalErrorCodes();
-
-	static ReturnValue_t translate(uint8_t code);
-private:
-	InternalErrorCodes();
-};
-
-#endif /* INTERNALERRORCODES_H_ */
+#ifndef INTERNALERRORCODES_H_
+#define INTERNALERRORCODES_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class InternalErrorCodes {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::INTERNAL_ERROR_CODES;
+
+static const ReturnValue_t NO_CONFIGURATION_TABLE = MAKE_RETURN_CODE(0x01 );
+static const ReturnValue_t NO_CPU_TABLE = MAKE_RETURN_CODE(0x02 );
+static const ReturnValue_t INVALID_WORKSPACE_ADDRESS = MAKE_RETURN_CODE(0x03 );
+static const ReturnValue_t TOO_LITTLE_WORKSPACE = MAKE_RETURN_CODE(0x04 );
+static const ReturnValue_t WORKSPACE_ALLOCATION = MAKE_RETURN_CODE(0x05 );
+static const ReturnValue_t INTERRUPT_STACK_TOO_SMALL = MAKE_RETURN_CODE(0x06 );
+static const ReturnValue_t THREAD_EXITTED = MAKE_RETURN_CODE(0x07 );
+static const ReturnValue_t INCONSISTENT_MP_INFORMATION = MAKE_RETURN_CODE(0x08 );
+static const ReturnValue_t INVALID_NODE = MAKE_RETURN_CODE(0x09 );
+static const ReturnValue_t NO_MPCI = MAKE_RETURN_CODE(0x0a );
+static const ReturnValue_t BAD_PACKET = MAKE_RETURN_CODE(0x0b );
+static const ReturnValue_t OUT_OF_PACKETS = MAKE_RETURN_CODE(0x0c );
+static const ReturnValue_t OUT_OF_GLOBAL_OBJECTS = MAKE_RETURN_CODE(0x0d );
+static const ReturnValue_t OUT_OF_PROXIES = MAKE_RETURN_CODE(0x0e );
+static const ReturnValue_t INVALID_GLOBAL_ID = MAKE_RETURN_CODE(0x0f );
+static const ReturnValue_t BAD_STACK_HOOK = MAKE_RETURN_CODE(0x10 );
+static const ReturnValue_t BAD_ATTRIBUTES = MAKE_RETURN_CODE(0x11 );
+static const ReturnValue_t IMPLEMENTATION_KEY_CREATE_INCONSISTENCY = MAKE_RETURN_CODE(0x12 );
+static const ReturnValue_t IMPLEMENTATION_BLOCKING_OPERATION_CANCEL = MAKE_RETURN_CODE(0x13 );
+static const ReturnValue_t MUTEX_OBTAIN_FROM_BAD_STATE = MAKE_RETURN_CODE(0x14 );
+static const ReturnValue_t UNLIMITED_AND_MAXIMUM_IS_0 = MAKE_RETURN_CODE(0x15 );
+
+	virtual ~InternalErrorCodes();
+
+	static ReturnValue_t translate(uint8_t code);
+private:
+	InternalErrorCodes();
+};
+
+#endif /* INTERNALERRORCODES_H_ */
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 52d0d5f0e..41321eeb5 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -1,227 +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;
-}
+#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;
+}
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 2bb0f84d4..1139badbd 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -1,191 +1,191 @@
-#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() {
-    // A local iterator for the Polling Sequence Table is created to
-    // find the start time for the first entry.
-    FixedSlotSequence::SlotListIter 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) {
-    if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, 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::checkAndInitializeSequence() 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;
-
-}
-
-
-
-
+#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() {
+    // A local iterator for the Polling Sequence Table is created to
+    // find the start time for the first entry.
+    FixedSlotSequence::SlotListIter 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) {
+    if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, 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::checkAndInitializeSequence() 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;
+
+}
+
+
+
+
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index 861a072e4..3ea97b977 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -1,130 +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 checkAndInitializeSequence() const;
-
-    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_ */
+#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 checkAndInitializeSequence() const;
+
+    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_ */
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 6fd428494..8a34282c9 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -1,155 +1,155 @@
-#include "../../osal/host/MessageQueue.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/host/QueueMapManager.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: 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, 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, 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(dur_millis_t lockTimeout) {
-	return queueLock->lockMutex(lockTimeout);
-}
-
-ReturnValue_t MessageQueue::unlockQueue() {
-	return queueLock->unlockMutex();
-}
+#include "../../osal/host/MessageQueue.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/host/QueueMapManager.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: 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, 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, 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(dur_millis_t lockTimeout) {
+	return queueLock->lockMutex(lockTimeout);
+}
+
+ReturnValue_t MessageQueue::unlockQueue() {
+	return queueLock->unlockMutex();
+}
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
index d2da24022..21a016630 100644
--- a/osal/host/MessageQueue.h
+++ b/osal/host/MessageQueue.h
@@ -1,230 +1,230 @@
-#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(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_ */
+#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(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_ */
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index 28768507c..2718f2b99 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -1,40 +1,40 @@
-#include "../../osal/host/Mutex.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-const uint32_t MutexIF::POLLING = 0;
-const uint32_t MutexIF::BLOCKING = 0xffffffff;
-
-ReturnValue_t Mutex::lockMutex(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;
-}
+#include "../../osal/host/Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t MutexIF::POLLING = 0;
+const uint32_t MutexIF::BLOCKING = 0xffffffff;
+
+ReturnValue_t Mutex::lockMutex(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;
+}
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index 4d49bac7e..4461e5f2f 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -1,28 +1,28 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
-#define FRAMEWORK_OSAL_FREERTOS_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() = default;
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
-	ReturnValue_t unlockMutex() override;
-
-	std::timed_mutex* getMutexHandle();
-private:
-	bool locked = false;
-	std::timed_mutex mutex;
-};
-
-#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
+#define FRAMEWORK_OSAL_FREERTOS_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() = default;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
+	ReturnValue_t unlockMutex() override;
+
+	std::timed_mutex* getMutexHandle();
+private:
+	bool locked = false;
+	std::timed_mutex mutex;
+};
+
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/osal/host/MutexFactory.cpp b/osal/host/MutexFactory.cpp
index 284ce59f7..bf7707d11 100644
--- a/osal/host/MutexFactory.cpp
+++ b/osal/host/MutexFactory.cpp
@@ -1,28 +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;
-}
+#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;
+}
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index c4cf9f569..0b5f8bbe0 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -1,176 +1,176 @@
-#include "../../ipc/MutexFactory.h"
-#include "../../osal/host/Mutex.h"
-#include "../../osal/host/PeriodicTask.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;
-
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/host/Mutex.h"
+#include "../../osal/host/PeriodicTask.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;
+
+}
diff --git a/osal/host/PeriodicTask.h b/osal/host/PeriodicTask.h
index 7eb768cb6..7689788ac 100644
--- a/osal/host/PeriodicTask.h
+++ b/osal/host/PeriodicTask.h
@@ -1,123 +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_ */
+#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_ */
diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
index 052671caf..da3fea55a 100644
--- a/osal/host/QueueFactory.cpp
+++ b/osal/host/QueueFactory.cpp
@@ -1,41 +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;
-}
+#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;
+}
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 35db204e8..47687bc1a 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -1,51 +1,51 @@
-#include "../../ipc/MutexFactory.h"
-#include "../../ipc/MutexHelper.h"
-#include "../../osal/host/QueueMapManager.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, 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;
-	}
-}
-
+#include "../../ipc/MutexFactory.h"
+#include "../../ipc/MutexHelper.h"
+#include "../../osal/host/QueueMapManager.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, 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;
+	}
+}
+
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
index acf203898..823fd4c2b 100644
--- a/osal/host/QueueMapManager.h
+++ b/osal/host/QueueMapManager.h
@@ -1,47 +1,47 @@
-#ifndef FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
-#define FRAMEWORK_OSAL_HOST_QUEUEMAP_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 /* FRAMEWORK_OSAL_HOST_QUEUEMAP_H_ */
+#ifndef FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
+#define FRAMEWORK_OSAL_HOST_QUEUEMAP_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 /* FRAMEWORK_OSAL_HOST_QUEUEMAP_H_ */
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index 580404288..c354c47cf 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -1,42 +1,42 @@
-#include "../../tasks/SemaphoreFactory.h"
-#include "../../osal/linux/BinarySemaphore.h"
-#include "../../osal/linux/CountingSemaphore.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = 0xFFFFFFFF;
-
-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;
-}
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../osal/linux/BinarySemaphore.h"
+#include "../../osal/linux/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t SemaphoreIF::POLLING = 0;
+const uint32_t SemaphoreIF::BLOCKING = 0xFFFFFFFF;
+
+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;
+}
diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
index 3f527130e..37df981a3 100644
--- a/osal/host/TaskFactory.cpp
+++ b/osal/host/TaskFactory.cpp
@@ -1,55 +1,55 @@
-#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_) {
-	// This is going to be interesting. Time now learn the C++ threading library
-	// :-)
-	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
-			deadLineMissedFunction_);
-}
-
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	// This is going to be interesting. Time now learn the C++ threading library
-	// :-)
-	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;
-}
-
-
+#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_) {
+	// This is going to be interesting. Time now learn the C++ threading library
+	// :-)
+	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
+			deadLineMissedFunction_);
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	// This is going to be interesting. Time now learn the C++ threading library
+	// :-)
+	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;
+}
+
+
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 5216ff375..8c0eeae71 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -1,149 +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;
-}
+#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;
+}
diff --git a/osal/linux/BinarySemaphore.h b/osal/linux/BinarySemaphore.h
index 4181de857..e9bb8bb66 100644
--- a/osal/linux/BinarySemaphore.h
+++ b/osal/linux/BinarySemaphore.h
@@ -1,81 +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_ */
+#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_ */
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 370c77f7f..5f764a6fc 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,220 +1,220 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../timemanager/Clock.h"
-
-#include <sys/time.h>
-#include <sys/sysinfo.h>
-#include <linux/sysinfo.h>
-#include <time.h>
-#include <unistd.h>
-
-//#include <fstream>
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
-uint32_t Clock::getTicksPerSecond(void){
-	uint32_t ticks = sysconf(_SC_CLK_TCK);
-	return ticks;
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-	timespec timeUnix;
-	timeval timeTimeval;
-	convertTimeOfDayToTimeval(time,&timeTimeval);
-	timeUnix.tv_sec = timeTimeval.tv_sec;
-	timeUnix.tv_nsec = (__syscall_slong_t) timeTimeval.tv_usec * 1000;
-
-	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
-	if(status!=0){
-		//TODO errno
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	timespec timeUnix;
-	timeUnix.tv_sec = time->tv_sec;
-	timeUnix.tv_nsec = (__syscall_slong_t) time->tv_usec * 1000;
-	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
-	if(status!=0){
-		//TODO errno
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	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;
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval timeVal;
-	ReturnValue_t result = getClock_timeval(&timeVal);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
-	*time = (uint64_t)timeVal.tv_sec*1e6 + timeVal.tv_usec;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-timeval Clock::getUptime() {
-	timeval uptime;
-	auto result = getUptime(&uptime);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
-	}
-	return uptime;
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	//TODO This is not posix compatible and delivers only seconds precision
-	struct sysinfo sysInfo;
-	int result = sysinfo(&sysInfo);
-	if(result != 0){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	uptime->tv_sec = sysInfo.uptime;
-	uptime->tv_usec = 0;
-
-
-	//Linux specific file read but more precise
-//	double uptimeSeconds;
-//	if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
-//		uptime->tv_sec = uptimeSeconds;
-//		uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
-//	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	timeval uptime;
-	ReturnValue_t result = getUptime(&uptime);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
-	*uptimeMs = uptime.tv_sec * 1e3 + uptime.tv_usec / 1e3;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	timespec timeUnix;
-	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
-	if(status != 0){
-		//TODO errno
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	struct tm* timeInfo;
-	timeInfo = gmtime(&timeUnix.tv_sec);
-	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;
-	time->usecond = timeUnix.tv_nsec / 1000.0;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-
-	tm fromTm;
-	//Note: Fails for years before AD
-	fromTm.tm_year = from->year - 1900;
-	fromTm.tm_mon = from->month - 1;
-	fromTm.tm_mday = from->day;
-	fromTm.tm_hour = from->hour;
-	fromTm.tm_min = from->minute;
-	fromTm.tm_sec = from->second;
-
-	to->tv_sec = mktime(&fromTm);
-	to->tv_usec = from->usecond;
-	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==NULL){
-		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==NULL){
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Clock.h"
+
+#include <sys/time.h>
+#include <sys/sysinfo.h>
+#include <linux/sysinfo.h>
+#include <time.h>
+#include <unistd.h>
+
+//#include <fstream>
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
+uint32_t Clock::getTicksPerSecond(void){
+	uint32_t ticks = sysconf(_SC_CLK_TCK);
+	return ticks;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+	timespec timeUnix;
+	timeval timeTimeval;
+	convertTimeOfDayToTimeval(time,&timeTimeval);
+	timeUnix.tv_sec = timeTimeval.tv_sec;
+	timeUnix.tv_nsec = (__syscall_slong_t) timeTimeval.tv_usec * 1000;
+
+	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		//TODO errno
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	timespec timeUnix;
+	timeUnix.tv_sec = time->tv_sec;
+	timeUnix.tv_nsec = (__syscall_slong_t) time->tv_usec * 1000;
+	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		//TODO errno
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+	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;
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	timeval timeVal;
+	ReturnValue_t result = getClock_timeval(&timeVal);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+	*time = (uint64_t)timeVal.tv_sec*1e6 + timeVal.tv_usec;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+timeval Clock::getUptime() {
+	timeval uptime;
+	auto result = getUptime(&uptime);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
+	}
+	return uptime;
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	//TODO This is not posix compatible and delivers only seconds precision
+	struct sysinfo sysInfo;
+	int result = sysinfo(&sysInfo);
+	if(result != 0){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	uptime->tv_sec = sysInfo.uptime;
+	uptime->tv_usec = 0;
+
+
+	//Linux specific file read but more precise
+//	double uptimeSeconds;
+//	if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
+//		uptime->tv_sec = uptimeSeconds;
+//		uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
+//	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	timeval uptime;
+	ReturnValue_t result = getUptime(&uptime);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+	*uptimeMs = uptime.tv_sec * 1e3 + uptime.tv_usec / 1e3;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	timespec timeUnix;
+	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
+	if(status != 0){
+		//TODO errno
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	struct tm* timeInfo;
+	timeInfo = gmtime(&timeUnix.tv_sec);
+	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;
+	time->usecond = timeUnix.tv_nsec / 1000.0;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+
+	tm fromTm;
+	//Note: Fails for years before AD
+	fromTm.tm_year = from->year - 1900;
+	fromTm.tm_mon = from->month - 1;
+	fromTm.tm_mday = from->day;
+	fromTm.tm_hour = from->hour;
+	fromTm.tm_min = from->minute;
+	fromTm.tm_sec = from->second;
+
+	to->tv_sec = mktime(&fromTm);
+	to->tv_usec = from->usecond;
+	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==NULL){
+		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==NULL){
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
index ef32539b3..183393994 100644
--- a/osal/linux/CountingSemaphore.cpp
+++ b/osal/linux/CountingSemaphore.cpp
@@ -1,54 +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;
-}
-
+#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;
+}
+
diff --git a/osal/linux/CountingSemaphore.h b/osal/linux/CountingSemaphore.h
index afe21a614..e0fbb9921 100644
--- a/osal/linux/CountingSemaphore.h
+++ b/osal/linux/CountingSemaphore.h
@@ -1,37 +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_ */
+#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_ */
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 12db83b13..b634b4cf7 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -1,96 +1,96 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/FixedTimeslotTask.h"
-
-#include <limits.h>
-
-uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
-
-FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_,
-		size_t stackSize_, uint32_t periodMs_):
-		PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
-}
-
-FixedTimeslotTask::~FixedTimeslotTask() {
-
-}
-
-void* FixedTimeslotTask::taskEntryPoint(void* arg) {
-	//The argument is re-interpreted as PollingTask.
-	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-	return nullptr;
-}
-
-ReturnValue_t FixedTimeslotTask::startTask() {
-	started = true;
-	createTask(&taskEntryPoint,this);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
-	return PosixThread::sleep((uint64_t)ms*1000000);
-}
-
-uint32_t FixedTimeslotTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-	ExecutableObjectIF* executableObject =
-			objectManager->get<ExecutableObjectIF>(componentId);
-	if (executableObject != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep,
-				executableObject,this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::dec << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
-	return pst.checkSequence();
-}
-
-void FixedTimeslotTask::taskFunctionality() {
-	//Like FreeRTOS pthreads are running as soon as they are created
-	if (!started) {
-		suspend();
-	}
-
-	pst.intializeSequenceAfterTaskCreation();
-	//The start time for the first entry is read.
-	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
-	uint64_t interval = pst.getIntervalToNextSlotMs();
-
-
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		} else {
-			//The interval for the next polling slot is selected.
-			interval = this->pst.getIntervalToPreviousSlotMs();
-			//The period is checked and restarted with the new interval.
-			//If the deadline was missed, the deadlineMissedFunc is called.
-			if(!PosixThread::delayUntil(&lastWakeTime,interval)) {
-				//No time left on timer -> we missed the deadline
-				missedDeadlineCounter();
-			}
-		}
-		//The device handler for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-	}
-}
-
-void FixedTimeslotTask::missedDeadlineCounter() {
-	FixedTimeslotTask::deadlineMissedCount++;
-	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
-				   << " deadlines." << std::endl;
-	}
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/FixedTimeslotTask.h"
+
+#include <limits.h>
+
+uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
+
+FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_,
+		size_t stackSize_, uint32_t periodMs_):
+		PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
+}
+
+FixedTimeslotTask::~FixedTimeslotTask() {
+
+}
+
+void* FixedTimeslotTask::taskEntryPoint(void* arg) {
+	//The argument is re-interpreted as PollingTask.
+	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
+	//The task's functionality is called.
+	originalTask->taskFunctionality();
+	return nullptr;
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+	started = true;
+	createTask(&taskEntryPoint,this);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
+	return PosixThread::sleep((uint64_t)ms*1000000);
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+	return pst.getLengthMs();
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+		uint32_t slotTimeMs, int8_t executionStep) {
+	ExecutableObjectIF* executableObject =
+			objectManager->get<ExecutableObjectIF>(componentId);
+	if (executableObject != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep,
+				executableObject,this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::dec << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+	return pst.checkSequence();
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+	//Like FreeRTOS pthreads are running as soon as they are created
+	if (!started) {
+		suspend();
+	}
+
+	pst.intializeSequenceAfterTaskCreation();
+	//The start time for the first entry is read.
+	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
+	uint64_t interval = pst.getIntervalToNextSlotMs();
+
+
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		if (pst.slotFollowsImmediately()) {
+			//Do nothing
+		} else {
+			//The interval for the next polling slot is selected.
+			interval = this->pst.getIntervalToPreviousSlotMs();
+			//The period is checked and restarted with the new interval.
+			//If the deadline was missed, the deadlineMissedFunc is called.
+			if(!PosixThread::delayUntil(&lastWakeTime,interval)) {
+				//No time left on timer -> we missed the deadline
+				missedDeadlineCounter();
+			}
+		}
+		//The device handler for this slot is executed and the next one is chosen.
+		this->pst.executeAndAdvance();
+	}
+}
+
+void FixedTimeslotTask::missedDeadlineCounter() {
+	FixedTimeslotTask::deadlineMissedCount++;
+	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
+				   << " deadlines." << std::endl;
+	}
+}
diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 83bf203e0..0148922dd 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
-
-#include "../../tasks/FixedTimeslotTaskIF.h"
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../osal/linux/PosixThread.h"
-#include <pthread.h>
-
-class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
-public:
-	/**
-	 * Create a generic periodic task.
-	 * @param name_
-	 * Name, maximum allowed size of linux is 16 chars, everything else will
-	 * be truncated.
-	 * @param priority_
-	 * Real-time priority, ranges from 1 to 99 for Linux.
-	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
-	 * @param stackSize_
-	 * @param period_
-	 * @param deadlineMissedFunc_
-	 */
-	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
-			uint32_t periodMs_);
-	virtual ~FixedTimeslotTask();
-
-	virtual ReturnValue_t startTask();
-
-	virtual ReturnValue_t sleepFor(uint32_t ms);
-
-	virtual uint32_t getPeriodMs() const;
-
-	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-			int8_t executionStep);
-
-	virtual ReturnValue_t checkSequence() const;
-
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-	 */
-	static void missedDeadlineCounter();
-
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-protected:
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 * @details
-	 * Holding the main functionality of the task, this method is most important.
-	 * It links the functionalities provided by FixedSlotSequence with the
-	 * OS's System Calls to keep the timing of the periods.
-	 */
-	virtual void taskFunctionality();
-
-private:
-	/**
-	 * @brief	This is the entry point in a new thread.
-	 *
-	 * @details
-	 * This method, that is the entry point in the new thread and calls
-	 * taskFunctionality of the child class. Needs a valid pointer to the
-	 * derived class.
-	 *
-	 * The void* returnvalue is not used yet but could be used to return
-	 * arbitrary data.
-	 */
-	static void* taskEntryPoint(void* arg);
-	FixedSlotSequence pst;
-
-	bool started;
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
+
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../osal/linux/PosixThread.h"
+#include <pthread.h>
+
+class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
+public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
+	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t periodMs_);
+	virtual ~FixedTimeslotTask();
+
+	virtual ReturnValue_t startTask();
+
+	virtual ReturnValue_t sleepFor(uint32_t ms);
+
+	virtual uint32_t getPeriodMs() const;
+
+	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+			int8_t executionStep);
+
+	virtual ReturnValue_t checkSequence() const;
+
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+	 */
+	static void missedDeadlineCounter();
+
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+protected:
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 * @details
+	 * Holding the main functionality of the task, this method is most important.
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
+	 */
+	virtual void taskFunctionality();
+
+private:
+	/**
+	 * @brief	This is the entry point in a new thread.
+	 *
+	 * @details
+	 * This method, that is the entry point in the new thread and calls
+	 * taskFunctionality of the child class. Needs a valid pointer to the
+	 * derived class.
+	 *
+	 * The void* returnvalue is not used yet but could be used to return
+	 * arbitrary data.
+	 */
+	static void* taskEntryPoint(void* arg);
+	FixedSlotSequence pst;
+
+	bool started;
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */
diff --git a/osal/linux/InternalErrorCodes.cpp b/osal/linux/InternalErrorCodes.cpp
index 724cb4bc6..a01cc72ac 100644
--- a/osal/linux/InternalErrorCodes.cpp
+++ b/osal/linux/InternalErrorCodes.cpp
@@ -1,14 +1,14 @@
-#include "../../osal/InternalErrorCodes.h"
-
-ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
-	//TODO This class can be removed
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-InternalErrorCodes::InternalErrorCodes() {
-}
-
-InternalErrorCodes::~InternalErrorCodes() {
-	
-}
-
+#include "../../osal/InternalErrorCodes.h"
+
+ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
+	//TODO This class can be removed
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+InternalErrorCodes::InternalErrorCodes() {
+}
+
+InternalErrorCodes::~InternalErrorCodes() {
+	
+}
+
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 97c895520..872517241 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,369 +1,369 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/MessageQueue.h"
-
-#include <fstream>
-
-#include <fcntl.h>           /* For O_* constants */
-#include <sys/stat.h>        /* For mode constants */
-#include <cstring>
-#include <errno.h>
-
-
-MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
-		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
-		defaultDestination(MessageQueueIF::NO_QUEUE),
-		maxMessageSize(maxMessageSize) {
-	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
-	mq_attr attributes;
-	this->id = 0;
-	//Set attributes
-	attributes.mq_curmsgs = 0;
-	attributes.mq_maxmsg = messageDepth;
-	attributes.mq_msgsize = maxMessageSize;
-	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
-	//Set the name of the queue. The slash is mandatory!
-	sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
-
-	// Create a nonblocking queue if the name is available (the queue is read
-	// and writable for the owner as well as the group)
-	int oflag = O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL;
-	mode_t mode = S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH;
-	mqd_t tempId = mq_open(name, oflag, mode, &attributes);
-	if (tempId == -1) {
-		handleError(&attributes, messageDepth);
-	}
-	else {
-		//Successful mq_open call
-		this->id = tempId;
-	}
-}
-
-MessageQueue::~MessageQueue() {
-	int status = mq_close(this->id);
-	if(status != 0){
-		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
-				   << strerror(errno) <<std::endl;
-	}
-	status = mq_unlink(name);
-	if(status != 0){
-		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
-				   << strerror(errno) << std::endl;
-	}
-}
-
-ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
-		uint32_t messageDepth) {
-	switch(errno) {
-	case(EINVAL): {
-		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
-				" for message size" << std::endl;
-		size_t defaultMqMaxMsg = 0;
-		// Not POSIX conformant, but should work for all UNIX systems.
-		// Just an additional helpful printout :-)
-		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
-				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
-			/*
-			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
-			This happens if the msg_max value is not large enough
-			It is ignored if the executable is run in privileged mode.
-		    Run the unlockRealtime script or grant the mode manually by using:
-			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
-
-			Persistent solution for session:
-			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
-
-			Permanent solution:
-			sudo nano /etc/sysctl.conf
-			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
-			Apply changes with: sudo sysctl -p
-			*/
-			sif::error << "MessageQueue::MessageQueue: Default MQ size "
-					<< defaultMqMaxMsg << " is too small for requested size "
-					<< messageDepth << std::endl;
-			sif::error << "This error can be fixed by setting the maximum "
-					"allowed message size higher!" << std::endl;
-
-		}
-		break;
-	}
-	case(EEXIST): {
-		// An error occured during open
-		// We need to distinguish if it is caused by an already created queue
-		//There's another queue with the same name
-		//We unlink the other queue
-		int status = mq_unlink(name);
-		if (status != 0) {
-			sif::error << "mq_unlink Failed with status: " << strerror(errno)
-													<< std::endl;
-		}
-		else {
-			// Successful unlinking, try to open again
-			mqd_t tempId = mq_open(name,
-					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
-			if (tempId != -1) {
-				//Successful mq_open
-				this->id = tempId;
-				return HasReturnvaluesIF::RETURN_OK;
-			}
-		}
-		break;
-	}
-
-	default:
-		// Failed either the first time or the second time
-		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-		<< name << std::dec << " failed with status: "
-		<< strerror(errno) << std::endl;
-
-	}
-	return HasReturnvaluesIF::RETURN_FAILED;
-
-
-
-}
-
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, bool ignoreFault) {
-	return sendMessageFrom(sendTo, message, this->getId(), false);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
-	return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != 0) {
-		return sendMessageFrom(this->lastPartner, message, this->getId());
-	} else {
-		return NO_REPLY_PARTNER;
-	}
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
-		MessageQueueId_t* receivedFrom) {
-	ReturnValue_t status = this->receiveMessage(message);
-	*receivedFrom = this->lastPartner;
-	return status;
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
-	if(message == nullptr) {
-		sif::error << "MessageQueue::receiveMessage: Message is "
-				"nullptr!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(message->getMaximumMessageSize() < maxMessageSize) {
-		sif::error << "MessageQueue::receiveMessage: Message size "
-				<< message->getMaximumMessageSize()
-				<< " too small to receive data!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	unsigned int messagePriority = 0;
-	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
-			message->getMaximumMessageSize(),&messagePriority);
-	if (status > 0) {
-		this->lastPartner = message->getSender();
-		//Check size of incoming message.
-		if (message->getMessageSize() < message->getMinimumMessageSize()) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}else if(status==0){
-		//Success but no message received
-		return MessageQueueIF::EMPTY;
-	} else {
-		//No message was received. Keep lastPartner anyway, I might send
-		//something later. But still, delete packet content.
-		memset(message->getData(), 0, message->getMaximumMessageSize());
-		switch(errno){
-		case EAGAIN:
-			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
-			//currently on the specified queue.
-			return MessageQueueIF::EMPTY;
-		case EBADF:
-			//mqdes doesn't represent a valid queue open for reading.
-			sif::error << "MessageQueue::receive: configuration error "
-			           << strerror(errno)  << std::endl;
-			/*NO BREAK*/
-		case EINVAL:
-			/*
-			 * This value indicates one of the following:
-			 * - The pointer to the buffer for storing the received message,
-			 *   msg_ptr, is NULL.
-			 * - The number of bytes requested, msg_len is less than zero.
-			 * - msg_len is anything other than the mq_msgsize of the specified
-			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
-			 *   been set in the queue's mq_flags.
-			 */
-			sif::error << "MessageQueue::receive: configuration error "
-					   << strerror(errno)  << std::endl;
-			/*NO BREAK*/
-		case EMSGSIZE:
-			/*
-			 * This value indicates one of the following:
-			 * - the QNX extended option MQ_READBUF_DYNAMIC hasn't been set,
-			 *   and the given msg_len is shorter than the mq_msgsize for
-			 *   the given queue.
-			 * - the extended option MQ_READBUF_DYNAMIC has been set, but the
-			 *   given msg_len is too short for the message that would have
-			 *   been received.
-			 */
-			sif::error << "MessageQueue::receive: configuration error "
-			           << strerror(errno)  << std::endl;
-			/*NO BREAK*/
-		case EINTR:
-			//The operation was interrupted by a signal.
-		default:
-
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-
-	}
-}
-
-MessageQueueId_t MessageQueue::getLastPartner() const {
-	return this->lastPartner;
-}
-
-ReturnValue_t MessageQueue::flush(uint32_t* count) {
-	mq_attr attrib;
-	int status = mq_getattr(id,&attrib);
-	if(status != 0){
-		switch(errno){
-		case EBADF:
-			//mqdes doesn't represent a valid message queue.
-			sif::error << "MessageQueue::flush configuration error, "
-					"called flush with an invalid queue ID" << std::endl;
-			/*NO BREAK*/
-		case EINVAL:
-			//mq_attr is NULL
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	*count = attrib.mq_curmsgs;
-	attrib.mq_curmsgs = 0;
-	status = mq_setattr(id,&attrib,NULL);
-	if(status != 0){
-		switch(errno){
-		case EBADF:
-			//mqdes doesn't represent a valid message queue.
-			sif::error << "MessageQueue::flush configuration error, "
-					"called flush with an invalid queue ID" << std::endl;
-			/*NO BREAK*/
-		case EINVAL:
-			/*
-			 * This value indicates one of the following:
-			 *  - mq_attr is NULL.
-			 *  - MQ_MULT_NOTIFY had been set for this queue, and the given
-			 *    mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once
-			 *    MQ_MULT_NOTIFY has been turned on, it may never be turned off.
-			 */
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t MessageQueue::getId() const {
-	return this->id;
-}
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-	this->defaultDestination = defaultDestination;
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
-}
-
-
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message, sentFrom,ignoreFault);
-
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const {
-	return this->defaultDestination;
-}
-
-bool MessageQueue::isDefaultDestinationSet() const {
-	return (defaultDestination != NO_QUEUE);
-}
-
-uint16_t MessageQueue::queueCounter = 0;
-
-ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	if(message == nullptr) {
-		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
-				"nullptr!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	message->setSender(sentFrom);
-	int result = mq_send(sendTo,
-			reinterpret_cast<const char*>(message->getBuffer()),
-			message->getMessageSize(),0);
-
-	//TODO: Check if we're in ISR.
-	if (result != 0) {
-		if(!ignoreFault){
-			InternalErrorReporterIF* internalErrorReporter =
-					objectManager->get<InternalErrorReporterIF>(
-						objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != NULL) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		switch(errno){
-		case EAGAIN:
-			//The O_NONBLOCK flag was set when opening the queue, or the
-			//MQ_NONBLOCK flag was set in its attributes, and the
-			//specified queue is full.
-			return MessageQueueIF::FULL;
-		case EBADF: {
-			//mq_des doesn't represent a valid message queue descriptor,
-			//or mq_des wasn't opened for writing.
-			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
-					<< " destination invalid."  << std::endl;
-			sif::error << strerror(errno) << " in "
-					<<"mq_send to: " << sendTo << " sent from "
-					<< sentFrom << std::endl;
-			return DESTINVATION_INVALID;
-		}
-		case EINTR:
-			//The call was interrupted by a signal.
-		case EINVAL:
-			/*
-			 * This value indicates one of the following:
-			 * - msg_ptr is NULL.
-			 * - msg_len is negative.
-			 * - msg_prio is greater than MQ_PRIO_MAX.
-			 * - msg_prio is less than 0.
-			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
-			 *   msg_prio is greater than the priority of the calling process.
-			 */
-			sif::error << "MessageQueue::sendMessage: Configuration error "
-			           << strerror(errno) << " in mq_send" << std::endl;
-			/*NO BREAK*/
-		case EMSGSIZE:
-			// The msg_len is greater than the msgsize associated with
-			//the specified queue.
-			sif::error << "MessageQueue::sendMessage: Size error [" <<
-					strerror(errno) << "] in mq_send" << std::endl;
-			/*NO BREAK*/
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/MessageQueue.h"
+
+#include <fstream>
+
+#include <fcntl.h>           /* For O_* constants */
+#include <sys/stat.h>        /* For mode constants */
+#include <cstring>
+#include <errno.h>
+
+
+MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
+		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
+		defaultDestination(MessageQueueIF::NO_QUEUE),
+		maxMessageSize(maxMessageSize) {
+	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
+	mq_attr attributes;
+	this->id = 0;
+	//Set attributes
+	attributes.mq_curmsgs = 0;
+	attributes.mq_maxmsg = messageDepth;
+	attributes.mq_msgsize = maxMessageSize;
+	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
+	//Set the name of the queue. The slash is mandatory!
+	sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
+
+	// Create a nonblocking queue if the name is available (the queue is read
+	// and writable for the owner as well as the group)
+	int oflag = O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL;
+	mode_t mode = S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH;
+	mqd_t tempId = mq_open(name, oflag, mode, &attributes);
+	if (tempId == -1) {
+		handleError(&attributes, messageDepth);
+	}
+	else {
+		//Successful mq_open call
+		this->id = tempId;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	int status = mq_close(this->id);
+	if(status != 0){
+		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
+				   << strerror(errno) <<std::endl;
+	}
+	status = mq_unlink(name);
+	if(status != 0){
+		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
+				   << strerror(errno) << std::endl;
+	}
+}
+
+ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
+		uint32_t messageDepth) {
+	switch(errno) {
+	case(EINVAL): {
+		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
+				" for message size" << std::endl;
+		size_t defaultMqMaxMsg = 0;
+		// Not POSIX conformant, but should work for all UNIX systems.
+		// Just an additional helpful printout :-)
+		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
+				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
+			/*
+			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
+			This happens if the msg_max value is not large enough
+			It is ignored if the executable is run in privileged mode.
+		    Run the unlockRealtime script or grant the mode manually by using:
+			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
+
+			Persistent solution for session:
+			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
+
+			Permanent solution:
+			sudo nano /etc/sysctl.conf
+			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
+			Apply changes with: sudo sysctl -p
+			*/
+			sif::error << "MessageQueue::MessageQueue: Default MQ size "
+					<< defaultMqMaxMsg << " is too small for requested size "
+					<< messageDepth << std::endl;
+			sif::error << "This error can be fixed by setting the maximum "
+					"allowed message size higher!" << std::endl;
+
+		}
+		break;
+	}
+	case(EEXIST): {
+		// An error occured during open
+		// We need to distinguish if it is caused by an already created queue
+		//There's another queue with the same name
+		//We unlink the other queue
+		int status = mq_unlink(name);
+		if (status != 0) {
+			sif::error << "mq_unlink Failed with status: " << strerror(errno)
+													<< std::endl;
+		}
+		else {
+			// Successful unlinking, try to open again
+			mqd_t tempId = mq_open(name,
+					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
+			if (tempId != -1) {
+				//Successful mq_open
+				this->id = tempId;
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+		break;
+	}
+
+	default:
+		// Failed either the first time or the second time
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+		<< name << std::dec << " failed with status: "
+		<< strerror(errno) << std::endl;
+
+	}
+	return HasReturnvaluesIF::RETURN_FAILED;
+
+
+
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), false);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+	if (this->lastPartner != 0) {
+		return sendMessageFrom(this->lastPartner, message, this->getId());
+	} else {
+		return NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	*receivedFrom = this->lastPartner;
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::receiveMessage: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(message->getMaximumMessageSize() < maxMessageSize) {
+		sif::error << "MessageQueue::receiveMessage: Message size "
+				<< message->getMaximumMessageSize()
+				<< " too small to receive data!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	unsigned int messagePriority = 0;
+	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
+			message->getMaximumMessageSize(),&messagePriority);
+	if (status > 0) {
+		this->lastPartner = message->getSender();
+		//Check size of incoming message.
+		if (message->getMessageSize() < message->getMinimumMessageSize()) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}else if(status==0){
+		//Success but no message received
+		return MessageQueueIF::EMPTY;
+	} else {
+		//No message was received. Keep lastPartner anyway, I might send
+		//something later. But still, delete packet content.
+		memset(message->getData(), 0, message->getMaximumMessageSize());
+		switch(errno){
+		case EAGAIN:
+			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
+			//currently on the specified queue.
+			return MessageQueueIF::EMPTY;
+		case EBADF:
+			//mqdes doesn't represent a valid queue open for reading.
+			sif::error << "MessageQueue::receive: configuration error "
+			           << strerror(errno)  << std::endl;
+			/*NO BREAK*/
+		case EINVAL:
+			/*
+			 * This value indicates one of the following:
+			 * - The pointer to the buffer for storing the received message,
+			 *   msg_ptr, is NULL.
+			 * - The number of bytes requested, msg_len is less than zero.
+			 * - msg_len is anything other than the mq_msgsize of the specified
+			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
+			 *   been set in the queue's mq_flags.
+			 */
+			sif::error << "MessageQueue::receive: configuration error "
+					   << strerror(errno)  << std::endl;
+			/*NO BREAK*/
+		case EMSGSIZE:
+			/*
+			 * This value indicates one of the following:
+			 * - the QNX extended option MQ_READBUF_DYNAMIC hasn't been set,
+			 *   and the given msg_len is shorter than the mq_msgsize for
+			 *   the given queue.
+			 * - the extended option MQ_READBUF_DYNAMIC has been set, but the
+			 *   given msg_len is too short for the message that would have
+			 *   been received.
+			 */
+			sif::error << "MessageQueue::receive: configuration error "
+			           << strerror(errno)  << std::endl;
+			/*NO BREAK*/
+		case EINTR:
+			//The operation was interrupted by a signal.
+		default:
+
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+	}
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return this->lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	mq_attr attrib;
+	int status = mq_getattr(id,&attrib);
+	if(status != 0){
+		switch(errno){
+		case EBADF:
+			//mqdes doesn't represent a valid message queue.
+			sif::error << "MessageQueue::flush configuration error, "
+					"called flush with an invalid queue ID" << std::endl;
+			/*NO BREAK*/
+		case EINVAL:
+			//mq_attr is NULL
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	*count = attrib.mq_curmsgs;
+	attrib.mq_curmsgs = 0;
+	status = mq_setattr(id,&attrib,NULL);
+	if(status != 0){
+		switch(errno){
+		case EBADF:
+			//mqdes doesn't represent a valid message queue.
+			sif::error << "MessageQueue::flush configuration error, "
+					"called flush with an invalid queue ID" << std::endl;
+			/*NO BREAK*/
+		case EINVAL:
+			/*
+			 * This value indicates one of the following:
+			 *  - mq_attr is NULL.
+			 *  - MQ_MULT_NOTIFY had been set for this queue, and the given
+			 *    mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once
+			 *    MQ_MULT_NOTIFY has been turned on, it may never be turned off.
+			 */
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return this->id;
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	this->defaultDestination = defaultDestination;
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
+}
+
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo,message, sentFrom,ignoreFault);
+
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return this->defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return (defaultDestination != NO_QUEUE);
+}
+
+uint16_t MessageQueue::queueCounter = 0;
+
+ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	message->setSender(sentFrom);
+	int result = mq_send(sendTo,
+			reinterpret_cast<const char*>(message->getBuffer()),
+			message->getMessageSize(),0);
+
+	//TODO: Check if we're in ISR.
+	if (result != 0) {
+		if(!ignoreFault){
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
+						objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != NULL) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		switch(errno){
+		case EAGAIN:
+			//The O_NONBLOCK flag was set when opening the queue, or the
+			//MQ_NONBLOCK flag was set in its attributes, and the
+			//specified queue is full.
+			return MessageQueueIF::FULL;
+		case EBADF: {
+			//mq_des doesn't represent a valid message queue descriptor,
+			//or mq_des wasn't opened for writing.
+			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
+					<< " destination invalid."  << std::endl;
+			sif::error << strerror(errno) << " in "
+					<<"mq_send to: " << sendTo << " sent from "
+					<< sentFrom << std::endl;
+			return DESTINVATION_INVALID;
+		}
+		case EINTR:
+			//The call was interrupted by a signal.
+		case EINVAL:
+			/*
+			 * This value indicates one of the following:
+			 * - msg_ptr is NULL.
+			 * - msg_len is negative.
+			 * - msg_prio is greater than MQ_PRIO_MAX.
+			 * - msg_prio is less than 0.
+			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
+			 *   msg_prio is greater than the priority of the calling process.
+			 */
+			sif::error << "MessageQueue::sendMessage: Configuration error "
+			           << strerror(errno) << " in mq_send" << std::endl;
+			/*NO BREAK*/
+		case EMSGSIZE:
+			// The msg_len is greater than the msgsize associated with
+			//the specified queue.
+			sif::error << "MessageQueue::sendMessage: Size error [" <<
+					strerror(errno) << "] in mq_send" << std::endl;
+			/*NO BREAK*/
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index 35d16e254..c0b770192 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -1,187 +1,187 @@
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
-
-#include "../../internalError/InternalErrorReporterIF.h"
-#include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/MessageQueueMessage.h"
-
-#include <mqueue.h>
-/**
- * @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".
- *
- * The creation of message queues, as well as sending and receiving messages,
- * makes use of the operating system calls provided.
- *	@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 i 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(uint32_t messageDepth = 3,
-			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
-	/**
-	 * @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.
-	 */
-	virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false );
-	/**
-	 * @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.
-	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter 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 );
-
-	/**
-	 * @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);
-
-	/**
-	 * @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);
-	/**
-	 * 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);
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	MessageQueueId_t getId() const;
-	/**
-	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * \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,
-			bool ignoreFault = false );
-	/**
-	 * \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 );
-	/**
-	 * \brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * \brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
-
-	bool isDefaultDestinationSet() const;
-protected:
-	/**
-	 * 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.
-	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false);
-private:
-	/**
-	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
-	 * 			If initialization fails, the queue id is set to zero.
-	 */
-	MessageQueueId_t id;
-	/**
-	 * @brief	In this attribute, the queue id of the last communication partner is stored
-	 * 			to allow for replying.
-	 */
-	MessageQueueId_t lastPartner;
-	/**
-	 * @brief	The message queue's name -a user specific information for the operating system-  is
-	 * 			generated automatically with the help of this static counter.
-	 */
-	/**
-	 * \brief	This attribute stores a default destination to send messages to.
-	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
-	 * 			be set in the constructor or by a setter call to setDefaultDestination.
-	 */
-	MessageQueueId_t defaultDestination;
-
-	/**
-	 * The name of the message queue, stored for unlinking
-	 */
-	char name[16];
-
-	static uint16_t queueCounter;
-	const size_t maxMessageSize;
-
-	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
-};
-
-#endif /* MESSAGEQUEUE_H_ */
+#ifndef MESSAGEQUEUE_H_
+#define MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessage.h"
+
+#include <mqueue.h>
+/**
+ * @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".
+ *
+ * The creation of message queues, as well as sending and receiving messages,
+ * makes use of the operating system calls provided.
+ *	@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 i 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(uint32_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	/**
+	 * @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.
+	 */
+	virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false );
+	/**
+	 * @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.
+	 */
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using the stored
+	 * 			lastParnter 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 );
+
+	/**
+	 * @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);
+
+	/**
+	 * @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);
+	/**
+	 * 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);
+	/**
+	 * @brief	This method returns the message queue id of the last communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const;
+	/**
+	 * @brief	This method returns the message queue id of this class's message queue.
+	 */
+	MessageQueueId_t getId() const;
+	/**
+	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * \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,
+			bool ignoreFault = false );
+	/**
+	 * \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 );
+	/**
+	 * \brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination);
+	/**
+	 * \brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const;
+
+	bool isDefaultDestinationSet() const;
+protected:
+	/**
+	 * 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.
+	 */
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false);
+private:
+	/**
+	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the queue id is set to zero.
+	 */
+	MessageQueueId_t id;
+	/**
+	 * @brief	In this attribute, the queue id of the last communication partner is stored
+	 * 			to allow for replying.
+	 */
+	MessageQueueId_t lastPartner;
+	/**
+	 * @brief	The message queue's name -a user specific information for the operating system-  is
+	 * 			generated automatically with the help of this static counter.
+	 */
+	/**
+	 * \brief	This attribute stores a default destination to send messages to.
+	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
+	 * 			be set in the constructor or by a setter call to setDefaultDestination.
+	 */
+	MessageQueueId_t defaultDestination;
+
+	/**
+	 * The name of the message queue, stored for unlinking
+	 */
+	char name[16];
+
+	static uint16_t queueCounter;
+	const size_t maxMessageSize;
+
+	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
+};
+
+#endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index 20be8aee4..2ecae0cb8 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -1,111 +1,111 @@
-#include "../../osal/linux/Mutex.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../timemanager/Clock.h"
-
-uint8_t Mutex::count = 0;
-
-
-#include <cstring>
-#include <errno.h>
-
-Mutex::Mutex() {
-	pthread_mutexattr_t mutexAttr;
-	int status = pthread_mutexattr_init(&mutexAttr);
-	if (status != 0) {
-		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
-	}
-	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
-	if (status != 0) {
-		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
-				<< std::endl;
-	}
-	status = pthread_mutex_init(&mutex, &mutexAttr);
-	if (status != 0) {
-		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
-				<< ", " << " failed with " << strerror(status) << std::endl;
-	}
-	// After a mutex attributes object has been used to initialize one or more
-	// mutexes, any function affecting the attributes object
-	// (including destruction) shall not affect any previously initialized mutexes.
-	status = pthread_mutexattr_destroy(&mutexAttr);
-	if (status != 0) {
-		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
-	}
-}
-
-Mutex::~Mutex() {
-	//No Status check yet
-	pthread_mutex_destroy(&mutex);
-}
-
-ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
-	int status = 0;
-
-	if(timeoutType == TimeoutType::POLLING) {
-	    status = pthread_mutex_trylock(&mutex);
-	}
-	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;
-		status = pthread_mutex_timedlock(&mutex, &timeOut);
-	}
-	else if(timeoutType == TimeoutType::BLOCKING) {
-		status = pthread_mutex_lock(&mutex);
-	}
-
-	switch (status) {
-	case EINVAL:
-		// The mutex was created with the protocol attribute having the value
-		// PTHREAD_PRIO_PROTECT and the calling thread's priority is higher
-		// than the mutex's current priority ceiling.
-		return WRONG_ATTRIBUTE_SETTING;
-		// The process or thread would have blocked, and the abs_timeout
-		// parameter specified a nanoseconds field value less than zero or
-		// greater than or equal to 1000 million.
-		// The value specified by mutex does not refer to an initialized mutex object.
-		//return MUTEX_NOT_FOUND;
-	case EBUSY:
-		// The mutex could not be acquired because it was already locked.
-		return MUTEX_ALREADY_LOCKED;
-	case ETIMEDOUT:
-		// The mutex could not be locked before the specified timeout expired.
-		return MUTEX_TIMEOUT;
-	case EAGAIN:
-		// The mutex could not be acquired because the maximum number of
-		// recursive locks for mutex has been exceeded.
-		return MUTEX_MAX_LOCKS;
-	case EDEADLK:
-		// A deadlock condition was detected or the current thread
-		// already owns the mutex.
-		return CURR_THREAD_ALREADY_OWNS_MUTEX;
-	case 0:
-		//Success
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	};
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	int status = pthread_mutex_unlock(&mutex);
-	switch (status) {
-	case EINVAL:
-		//The value specified by mutex does not refer to an initialized mutex object.
-		return MUTEX_NOT_FOUND;
-	case EAGAIN:
-		//The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded.
-		return MUTEX_MAX_LOCKS;
-	case EPERM:
-		//The current thread does not own the mutex.
-		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	case 0:
-		//Success
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	};
-}
+#include "../../osal/linux/Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Clock.h"
+
+uint8_t Mutex::count = 0;
+
+
+#include <cstring>
+#include <errno.h>
+
+Mutex::Mutex() {
+	pthread_mutexattr_t mutexAttr;
+	int status = pthread_mutexattr_init(&mutexAttr);
+	if (status != 0) {
+		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
+	}
+	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
+	if (status != 0) {
+		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
+				<< std::endl;
+	}
+	status = pthread_mutex_init(&mutex, &mutexAttr);
+	if (status != 0) {
+		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
+				<< ", " << " failed with " << strerror(status) << std::endl;
+	}
+	// After a mutex attributes object has been used to initialize one or more
+	// mutexes, any function affecting the attributes object
+	// (including destruction) shall not affect any previously initialized mutexes.
+	status = pthread_mutexattr_destroy(&mutexAttr);
+	if (status != 0) {
+		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
+	}
+}
+
+Mutex::~Mutex() {
+	//No Status check yet
+	pthread_mutex_destroy(&mutex);
+}
+
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
+	int status = 0;
+
+	if(timeoutType == TimeoutType::POLLING) {
+	    status = pthread_mutex_trylock(&mutex);
+	}
+	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;
+		status = pthread_mutex_timedlock(&mutex, &timeOut);
+	}
+	else if(timeoutType == TimeoutType::BLOCKING) {
+		status = pthread_mutex_lock(&mutex);
+	}
+
+	switch (status) {
+	case EINVAL:
+		// The mutex was created with the protocol attribute having the value
+		// PTHREAD_PRIO_PROTECT and the calling thread's priority is higher
+		// than the mutex's current priority ceiling.
+		return WRONG_ATTRIBUTE_SETTING;
+		// The process or thread would have blocked, and the abs_timeout
+		// parameter specified a nanoseconds field value less than zero or
+		// greater than or equal to 1000 million.
+		// The value specified by mutex does not refer to an initialized mutex object.
+		//return MUTEX_NOT_FOUND;
+	case EBUSY:
+		// The mutex could not be acquired because it was already locked.
+		return MUTEX_ALREADY_LOCKED;
+	case ETIMEDOUT:
+		// The mutex could not be locked before the specified timeout expired.
+		return MUTEX_TIMEOUT;
+	case EAGAIN:
+		// The mutex could not be acquired because the maximum number of
+		// recursive locks for mutex has been exceeded.
+		return MUTEX_MAX_LOCKS;
+	case EDEADLK:
+		// A deadlock condition was detected or the current thread
+		// already owns the mutex.
+		return CURR_THREAD_ALREADY_OWNS_MUTEX;
+	case 0:
+		//Success
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	};
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	int status = pthread_mutex_unlock(&mutex);
+	switch (status) {
+	case EINVAL:
+		//The value specified by mutex does not refer to an initialized mutex object.
+		return MUTEX_NOT_FOUND;
+	case EAGAIN:
+		//The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded.
+		return MUTEX_MAX_LOCKS;
+	case EPERM:
+		//The current thread does not own the mutex.
+		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	case 0:
+		//Success
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	};
+}
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index 77a11fe4a..3acb6d90c 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -1,22 +1,22 @@
-#ifndef OS_LINUX_MUTEX_H_
-#define OS_LINUX_MUTEX_H_
-
-#include "../../ipc/MutexIF.h"
-
-extern "C" {
-#include <pthread.h>
-}
-
-
-class Mutex : public MutexIF {
-public:
-	Mutex();
-	virtual ~Mutex();
-	virtual ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs);
-	virtual ReturnValue_t unlockMutex();
-private:
-	pthread_mutex_t mutex;
-	static uint8_t count;
-};
-
-#endif /* OS_RTEMS_MUTEX_H_ */
+#ifndef OS_LINUX_MUTEX_H_
+#define OS_LINUX_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+
+extern "C" {
+#include <pthread.h>
+}
+
+
+class Mutex : public MutexIF {
+public:
+	Mutex();
+	virtual ~Mutex();
+	virtual ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs);
+	virtual ReturnValue_t unlockMutex();
+private:
+	pthread_mutex_t mutex;
+	static uint8_t count;
+};
+
+#endif /* OS_RTEMS_MUTEX_H_ */
diff --git a/osal/linux/MutexFactory.cpp b/osal/linux/MutexFactory.cpp
index 70dc3c710..73ab10a2f 100644
--- a/osal/linux/MutexFactory.cpp
+++ b/osal/linux/MutexFactory.cpp
@@ -1,23 +1,23 @@
-#include "../../ipc/MutexFactory.h"
-#include "../../osal/linux/Mutex.h"
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-
-MutexFactory::MutexFactory() {
-}
-
-MutexFactory::~MutexFactory() {
-}
-
-MutexFactory* MutexFactory::instance() {
-	return MutexFactory::factoryInstance;
-}
-
-MutexIF* MutexFactory::createMutex() {
-	return new Mutex();
-}
-
-void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/linux/Mutex.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index c0a29f47f..bbf33b01d 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -1,83 +1,83 @@
-#include "../../tasks/ExecutableObjectIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/PeriodicPosixTask.h"
-
-#include <errno.h>
-
-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_) {
-}
-
-PeriodicPosixTask::~PeriodicPosixTask() {
-	//Not Implemented
-}
-
-void* PeriodicPosixTask::taskEntryPoint(void* arg) {
-	//The argument is re-interpreted as PollingTask.
-	PeriodicPosixTask *originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-	return NULL;
-}
-
-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);
-	newObject->setTaskIF(this);
-
-	return newObject->initializeAfterTaskCreation();
-}
-
-ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
-	return PosixThread::sleep((uint64_t)ms*1000000);
-}
-
-
-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){
-		suspend();
-	}
-
-	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();
-		}
-		if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
-			char name[20] = {0};
-			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
-			if(status == 0){
-				//sif::error << "PeriodicPosixTask " << name << ": Deadline "
-				//		"missed." << std::endl;
-			}
-			else {
-				//sif::error << "PeriodicPosixTask X: Deadline missed. " <<
-				//		status << std::endl;
-			}
-			if (this->deadlineMissedFunc != nullptr) {
-				this->deadlineMissedFunc();
-			}
-		}
-	}
-}
-
-uint32_t PeriodicPosixTask::getPeriodMs() const {
-	return periodMs;
-}
+#include "../../tasks/ExecutableObjectIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/PeriodicPosixTask.h"
+
+#include <errno.h>
+
+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_) {
+}
+
+PeriodicPosixTask::~PeriodicPosixTask() {
+	//Not Implemented
+}
+
+void* PeriodicPosixTask::taskEntryPoint(void* arg) {
+	//The argument is re-interpreted as PollingTask.
+	PeriodicPosixTask *originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
+	//The task's functionality is called.
+	originalTask->taskFunctionality();
+	return NULL;
+}
+
+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);
+	newObject->setTaskIF(this);
+
+	return newObject->initializeAfterTaskCreation();
+}
+
+ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
+	return PosixThread::sleep((uint64_t)ms*1000000);
+}
+
+
+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){
+		suspend();
+	}
+
+	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();
+		}
+		if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
+			char name[20] = {0};
+			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
+			if(status == 0){
+				//sif::error << "PeriodicPosixTask " << name << ": Deadline "
+				//		"missed." << std::endl;
+			}
+			else {
+				//sif::error << "PeriodicPosixTask X: Deadline missed. " <<
+				//		status << std::endl;
+			}
+			if (this->deadlineMissedFunc != nullptr) {
+				this->deadlineMissedFunc();
+			}
+		}
+	}
+}
+
+uint32_t PeriodicPosixTask::getPeriodMs() const {
+	return periodMs;
+}
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 59302e433..38825bbf3 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -1,90 +1,90 @@
-#ifndef FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
-#define FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
-
-#include "../../tasks/PeriodicTaskIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../osal/linux/PosixThread.h"
-#include "../../tasks/ExecutableObjectIF.h"
-#include <vector>
-
-class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
-public:
-	/**
-	 * Create a generic periodic task.
-	 * @param name_
-	 * Name, maximum allowed size of linux is 16 chars, everything else will
-	 * be truncated.
-	 * @param priority_
-	 * Real-time priority, ranges from 1 to 99 for Linux.
-	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
-	 * @param stackSize_
-	 * @param period_
-	 * @param deadlineMissedFunc_
-	 */
-	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
-			uint32_t period_, void(*deadlineMissedFunc_)());
-	virtual ~PeriodicPosixTask();
-
-	/**
-	 * @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) override;
-	/**
-	 * 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 RETURN_OK on success, RETURN_FAILED if the object could not be added.
-	 */
-	ReturnValue_t addComponent(object_id_t object) override;
-
-	uint32_t getPeriodMs() const override;
-
-	ReturnValue_t sleepFor(uint32_t ms) override;
-
-private:
-	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-
-	/**
-	 * @brief Flag to indicate that the task was started and is allowed to run
-	 */
-	bool started;
-
-
-	/**
-	 * @brief Period of the task in milliseconds
-	 */
-	uint32_t periodMs;
-	/**
-	 * @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 indefinitely. Within the loop, all performOperation methods of the added
-	 * 			objects are called. Afterwards the task will be blocked until the next period.
-	 * 			On missing the deadline, the deadlineMissedFunction is executed.
-	 */
-	virtual void taskFunctionality(void);
-	/**
-	 * @brief	This is the entry point in a new thread.
-	 *
-	 * @details	This method, that is the entry point in the new thread and calls taskFunctionality of the child class.
-	 * 			Needs a valid pointer to the derived class.
-	 */
-	static void* taskEntryPoint(void* arg);
-	/**
-	 * @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)();
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
+#define FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
+
+#include "../../tasks/PeriodicTaskIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../osal/linux/PosixThread.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include <vector>
+
+class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
+public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
+	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t period_, void(*deadlineMissedFunc_)());
+	virtual ~PeriodicPosixTask();
+
+	/**
+	 * @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) override;
+	/**
+	 * 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 RETURN_OK on success, RETURN_FAILED if the object could not be added.
+	 */
+	ReturnValue_t addComponent(object_id_t object) override;
+
+	uint32_t getPeriodMs() const override;
+
+	ReturnValue_t sleepFor(uint32_t ms) override;
+
+private:
+	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+
+	/**
+	 * @brief Flag to indicate that the task was started and is allowed to run
+	 */
+	bool started;
+
+
+	/**
+	 * @brief Period of the task in milliseconds
+	 */
+	uint32_t periodMs;
+	/**
+	 * @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 indefinitely. Within the loop, all performOperation methods of the added
+	 * 			objects are called. Afterwards the task will be blocked until the next period.
+	 * 			On missing the deadline, the deadlineMissedFunction is executed.
+	 */
+	virtual void taskFunctionality(void);
+	/**
+	 * @brief	This is the entry point in a new thread.
+	 *
+	 * @details	This method, that is the entry point in the new thread and calls taskFunctionality of the child class.
+	 * 			Needs a valid pointer to the derived class.
+	 */
+	static void* taskEntryPoint(void* arg);
+	/**
+	 * @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)();
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_ */
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 70c63c4a8..f6ace3805 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,217 +1,217 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/PosixThread.h"
-#include <cstring>
-#include <errno.h>
-
-PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
-		thread(0),priority(priority_),stackSize(stackSize_) {
-    name[0] = '\0';
-    std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
-}
-
-PosixThread::~PosixThread() {
-	//No deletion and no free of Stack Pointer
-}
-
-ReturnValue_t PosixThread::sleep(uint64_t ns) {
-	//TODO sleep might be better with timer instead of sleep()
-	timespec time;
-	time.tv_sec = ns/1000000000;
-	time.tv_nsec = ns - time.tv_sec*1e9;
-
-	//Remaining Time is not set here
-	int status = nanosleep(&time,NULL);
-	if(status != 0){
-		switch(errno){
-		case EINTR:
-			//The nanosleep() function was interrupted by a signal.
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case EINVAL:
-			//The rqtp argument specified a nanosecond value less than zero or
-			// greater than or equal to 1000 million.
-			return HasReturnvaluesIF::RETURN_FAILED;
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void PosixThread::suspend() {
-	//Wait for SIGUSR1
-	int caughtSig = 0;
-	sigset_t waitSignal;
-	sigemptyset(&waitSignal);
-	sigaddset(&waitSignal, SIGUSR1);
-	sigwait(&waitSignal, &caughtSig);
-	if (caughtSig != SIGUSR1) {
-		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
-				caughtSig << std::endl;
-	}
-}
-
-void PosixThread::resume(){
-	/* Signal the thread to start. Makes sense to call kill to start or? ;)
-	 *
-	*	According to Posix raise(signal) will call pthread_kill(pthread_self(), sig),
-	*	but as the call must be done from the thread itsself this is not possible here
-	*/
-	pthread_kill(thread,SIGUSR1);
-}
-
-bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
-		const uint64_t delayTime_ms) {
-	uint64_t nextTimeToWake_ms;
-	bool shouldDelay = false;
-	//Get current Time
-	const uint64_t currentTime_ms = getCurrentMonotonicTimeMs();
-	/* Generate the tick time at which the task wants to wake. */
-	nextTimeToWake_ms = (*prevoiusWakeTime_ms) + delayTime_ms;
-
-	if (currentTime_ms < *prevoiusWakeTime_ms) {
-		/* 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 < *prevoiusWakeTime_ms)
-				&& (nextTimeToWake_ms > currentTime_ms)) {
-			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 < *prevoiusWakeTime_ms)
-				|| (nextTimeToWake_ms > currentTime_ms)) {
-			shouldDelay = true;
-		}
-	}
-
-	/* Update the wake time ready for the next call. */
-
-	(*prevoiusWakeTime_ms) =  nextTimeToWake_ms;
-
-	if (shouldDelay) {
-		uint64_t sleepTime = nextTimeToWake_ms - currentTime_ms;
-		PosixThread::sleep(sleepTime * 1000000ull);
-		return true;
-	}
-	//We are shifting the time in case the deadline was missed like rtems
-	(*prevoiusWakeTime_ms) = currentTime_ms;
-	return false;
-
-}
-
-
-uint64_t PosixThread::getCurrentMonotonicTimeMs(){
-	timespec timeNow;
-	clock_gettime(CLOCK_MONOTONIC_RAW, &timeNow);
-	uint64_t currentTime_ms = (uint64_t) timeNow.tv_sec * 1000
-				+ timeNow.tv_nsec / 1000000;
-
-	return currentTime_ms;
-}
-
-
-void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
-	//sif::debug << "PosixThread::createTask" << std::endl;
-	/*
-	 * The attr argument points to a pthread_attr_t structure whose contents
-       are used at thread creation time to determine attributes for the new
-       thread; this structure is initialized using pthread_attr_init(3) and
-       related functions.  If attr is NULL, then the thread is created with
-       default attributes.
-	 */
-	pthread_attr_t attributes;
-	int status = pthread_attr_init(&attributes);
-	if(status != 0){
-		sif::error << "Posix Thread attribute init failed with: " <<
-				strerror(status) << std::endl;
-	}
-	void* stackPointer;
-	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
-	if(status != 0){
-		sif::error << "PosixThread::createTask: Stack init failed with: " <<
-				strerror(status) << std::endl;
-		if(errno == ENOMEM) {
-			uint64_t stackMb = stackSize/10e6;
-			sif::error << "PosixThread::createTask: Insufficient memory for"
-					" the requested " << stackMb << " MB" << std::endl;
-		}
-		else if(errno == EINVAL) {
-			sif::error << "PosixThread::createTask: Wrong alignment argument!"
-					<< std::endl;
-		}
-		return;
-	}
-
-	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
-	if(status != 0){
-		sif::error << "PosixThread::createTask: pthread_attr_setstack "
-				" failed with: " << strerror(status) <<  std::endl;
-		sif::error << "Make sure the specified stack size is valid and is "
-				"larger than the minimum allowed stack size." << std::endl;
-	}
-
-	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
-	if(status != 0){
-			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
-					strerror(status) << std::endl;
-	}
-
-	// TODO FIFO -> This needs root privileges for the process
-	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
-	if(status != 0){
-		sif::error << "Posix Thread attribute schedule policy failed with: " <<
-				strerror(status) << std::endl;
-	}
-
-	sched_param scheduleParams;
-	scheduleParams.__sched_priority = priority;
-	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
-	if(status != 0){
-		sif::error << "Posix Thread attribute schedule params failed with: " <<
-				strerror(status) << std::endl;
-	}
-
-	//Set Signal Mask for suspend until startTask is called
-	sigset_t waitSignal;
-	sigemptyset(&waitSignal);
-	sigaddset(&waitSignal, SIGUSR1);
-	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
-	if(status != 0){
-		sif::error << "Posix Thread sigmask failed failed with: " <<
-				strerror(status) << " errno: " << strerror(errno) << std::endl;
-	}
-
-
-	status = pthread_create(&thread,&attributes,fnc_,arg_);
-	if(status != 0){
-		sif::error << "Posix Thread create failed with: " <<
-				strerror(status) << std::endl;
-	}
-
-	status = pthread_setname_np(thread,name);
-	if(status != 0){
-		sif::error << "PosixThread::createTask: setname failed with: " <<
-				strerror(status) << std::endl;
-		if(status == ERANGE) {
-			sif::error << "PosixThread::createTask: Task name length longer"
-					" than 16 chars. Truncating.." << std::endl;
-			name[15] = '\0';
-			status = pthread_setname_np(thread,name);
-			if(status != 0){
-				sif::error << "PosixThread::createTask: Setting name"
-						" did not work.." << std::endl;
-			}
-		}
-	}
-
-	status = pthread_attr_destroy(&attributes);
-	if(status!=0){
-		sif::error << "Posix Thread attribute destroy failed with: " <<
-				strerror(status) << std::endl;
-	}
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/PosixThread.h"
+#include <cstring>
+#include <errno.h>
+
+PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
+		thread(0),priority(priority_),stackSize(stackSize_) {
+    name[0] = '\0';
+    std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
+}
+
+PosixThread::~PosixThread() {
+	//No deletion and no free of Stack Pointer
+}
+
+ReturnValue_t PosixThread::sleep(uint64_t ns) {
+	//TODO sleep might be better with timer instead of sleep()
+	timespec time;
+	time.tv_sec = ns/1000000000;
+	time.tv_nsec = ns - time.tv_sec*1e9;
+
+	//Remaining Time is not set here
+	int status = nanosleep(&time,NULL);
+	if(status != 0){
+		switch(errno){
+		case EINTR:
+			//The nanosleep() function was interrupted by a signal.
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case EINVAL:
+			//The rqtp argument specified a nanosecond value less than zero or
+			// greater than or equal to 1000 million.
+			return HasReturnvaluesIF::RETURN_FAILED;
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PosixThread::suspend() {
+	//Wait for SIGUSR1
+	int caughtSig = 0;
+	sigset_t waitSignal;
+	sigemptyset(&waitSignal);
+	sigaddset(&waitSignal, SIGUSR1);
+	sigwait(&waitSignal, &caughtSig);
+	if (caughtSig != SIGUSR1) {
+		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
+				caughtSig << std::endl;
+	}
+}
+
+void PosixThread::resume(){
+	/* Signal the thread to start. Makes sense to call kill to start or? ;)
+	 *
+	*	According to Posix raise(signal) will call pthread_kill(pthread_self(), sig),
+	*	but as the call must be done from the thread itsself this is not possible here
+	*/
+	pthread_kill(thread,SIGUSR1);
+}
+
+bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
+		const uint64_t delayTime_ms) {
+	uint64_t nextTimeToWake_ms;
+	bool shouldDelay = false;
+	//Get current Time
+	const uint64_t currentTime_ms = getCurrentMonotonicTimeMs();
+	/* Generate the tick time at which the task wants to wake. */
+	nextTimeToWake_ms = (*prevoiusWakeTime_ms) + delayTime_ms;
+
+	if (currentTime_ms < *prevoiusWakeTime_ms) {
+		/* 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 < *prevoiusWakeTime_ms)
+				&& (nextTimeToWake_ms > currentTime_ms)) {
+			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 < *prevoiusWakeTime_ms)
+				|| (nextTimeToWake_ms > currentTime_ms)) {
+			shouldDelay = true;
+		}
+	}
+
+	/* Update the wake time ready for the next call. */
+
+	(*prevoiusWakeTime_ms) =  nextTimeToWake_ms;
+
+	if (shouldDelay) {
+		uint64_t sleepTime = nextTimeToWake_ms - currentTime_ms;
+		PosixThread::sleep(sleepTime * 1000000ull);
+		return true;
+	}
+	//We are shifting the time in case the deadline was missed like rtems
+	(*prevoiusWakeTime_ms) = currentTime_ms;
+	return false;
+
+}
+
+
+uint64_t PosixThread::getCurrentMonotonicTimeMs(){
+	timespec timeNow;
+	clock_gettime(CLOCK_MONOTONIC_RAW, &timeNow);
+	uint64_t currentTime_ms = (uint64_t) timeNow.tv_sec * 1000
+				+ timeNow.tv_nsec / 1000000;
+
+	return currentTime_ms;
+}
+
+
+void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
+	//sif::debug << "PosixThread::createTask" << std::endl;
+	/*
+	 * The attr argument points to a pthread_attr_t structure whose contents
+       are used at thread creation time to determine attributes for the new
+       thread; this structure is initialized using pthread_attr_init(3) and
+       related functions.  If attr is NULL, then the thread is created with
+       default attributes.
+	 */
+	pthread_attr_t attributes;
+	int status = pthread_attr_init(&attributes);
+	if(status != 0){
+		sif::error << "Posix Thread attribute init failed with: " <<
+				strerror(status) << std::endl;
+	}
+	void* stackPointer;
+	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
+	if(status != 0){
+		sif::error << "PosixThread::createTask: Stack init failed with: " <<
+				strerror(status) << std::endl;
+		if(errno == ENOMEM) {
+			uint64_t stackMb = stackSize/10e6;
+			sif::error << "PosixThread::createTask: Insufficient memory for"
+					" the requested " << stackMb << " MB" << std::endl;
+		}
+		else if(errno == EINVAL) {
+			sif::error << "PosixThread::createTask: Wrong alignment argument!"
+					<< std::endl;
+		}
+		return;
+	}
+
+	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
+	if(status != 0){
+		sif::error << "PosixThread::createTask: pthread_attr_setstack "
+				" failed with: " << strerror(status) <<  std::endl;
+		sif::error << "Make sure the specified stack size is valid and is "
+				"larger than the minimum allowed stack size." << std::endl;
+	}
+
+	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
+	if(status != 0){
+			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
+					strerror(status) << std::endl;
+	}
+
+	// TODO FIFO -> This needs root privileges for the process
+	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
+	if(status != 0){
+		sif::error << "Posix Thread attribute schedule policy failed with: " <<
+				strerror(status) << std::endl;
+	}
+
+	sched_param scheduleParams;
+	scheduleParams.__sched_priority = priority;
+	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
+	if(status != 0){
+		sif::error << "Posix Thread attribute schedule params failed with: " <<
+				strerror(status) << std::endl;
+	}
+
+	//Set Signal Mask for suspend until startTask is called
+	sigset_t waitSignal;
+	sigemptyset(&waitSignal);
+	sigaddset(&waitSignal, SIGUSR1);
+	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
+	if(status != 0){
+		sif::error << "Posix Thread sigmask failed failed with: " <<
+				strerror(status) << " errno: " << strerror(errno) << std::endl;
+	}
+
+
+	status = pthread_create(&thread,&attributes,fnc_,arg_);
+	if(status != 0){
+		sif::error << "Posix Thread create failed with: " <<
+				strerror(status) << std::endl;
+	}
+
+	status = pthread_setname_np(thread,name);
+	if(status != 0){
+		sif::error << "PosixThread::createTask: setname failed with: " <<
+				strerror(status) << std::endl;
+		if(status == ERANGE) {
+			sif::error << "PosixThread::createTask: Task name length longer"
+					" than 16 chars. Truncating.." << std::endl;
+			name[15] = '\0';
+			status = pthread_setname_np(thread,name);
+			if(status != 0){
+				sif::error << "PosixThread::createTask: Setting name"
+						" did not work.." << std::endl;
+			}
+		}
+	}
+
+	status = pthread_attr_destroy(&attributes);
+	if(status!=0){
+		sif::error << "Posix Thread attribute destroy failed with: " <<
+				strerror(status) << std::endl;
+	}
+}
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index 9d6097f74..7d8d349aa 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
-#define FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include <pthread.h>
-#include <signal.h>
-#include <cstdlib>
-#include <unistd.h>
-
-class PosixThread {
-public:
-	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
-	PosixThread(const char* name_, int priority_, size_t stackSize_);
-	virtual ~PosixThread();
-	/**
-	 * Set the Thread to sleep state
-	 * @param ns Nanosecond sleep time
-	 * @return Returns Failed if sleep fails
-	 */
-	static ReturnValue_t sleep(uint64_t ns);
-	/**
-	 * @brief Function to suspend the task until SIGUSR1 was received
-	 *
-	 *  @details Will be called in the beginning to suspend execution until startTask() is called explicitly.
-	 */
-	void suspend();
-
-	/**
-	 * @brief Function to allow a other thread to start the thread again from suspend state
-	 *
-	 * @details Restarts the Thread after suspend call
-	 */
-	void resume();
-
-
-	/**
-	 * Delay function similar to FreeRtos delayUntil function
-	 *
-	 * @param prevoiusWakeTime_ms Needs the previous wake time and returns the next wakeup time
-	 * @param delayTime_ms Time period to delay
-	 *
-	 * @return False If deadline was missed; True if task was delayed
-	 */
-	static bool delayUntil(uint64_t* const prevoiusWakeTime_ms, const uint64_t delayTime_ms);
-
-	/**
-	 * Returns the current time in milliseconds from CLOCK_MONOTONIC
-	 *
-	 * @return current time in milliseconds from CLOCK_MONOTONIC
-	 */
-	static uint64_t getCurrentMonotonicTimeMs();
-
-protected:
-	pthread_t thread;
-
-	/**
-	 * @brief 	Function that has to be called by derived class because the
-	 *  		derived class pointer has to be valid as argument.
-	 * @details
-	 * This function creates a pthread with the given parameters. As the
-	 * function requires a pointer to the derived object it has to be called
-	 * after the this pointer of the derived object is valid.
-	 * Sets the taskEntryPoint as function to be called by new a thread.
-	 * @param fnc_ Function which will be executed by the thread.
-	 * @param arg_
-	 * argument of the taskEntryPoint function, needs to be this pointer
-	 * of derived class
-	 */
-	void createTask(void* (*fnc_)(void*),void* arg_);
-
-private:
-	char name[PTHREAD_MAX_NAMELEN];
-	int priority;
-	size_t stackSize = 0;
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
+#define FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <pthread.h>
+#include <signal.h>
+#include <cstdlib>
+#include <unistd.h>
+
+class PosixThread {
+public:
+	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
+	PosixThread(const char* name_, int priority_, size_t stackSize_);
+	virtual ~PosixThread();
+	/**
+	 * Set the Thread to sleep state
+	 * @param ns Nanosecond sleep time
+	 * @return Returns Failed if sleep fails
+	 */
+	static ReturnValue_t sleep(uint64_t ns);
+	/**
+	 * @brief Function to suspend the task until SIGUSR1 was received
+	 *
+	 *  @details Will be called in the beginning to suspend execution until startTask() is called explicitly.
+	 */
+	void suspend();
+
+	/**
+	 * @brief Function to allow a other thread to start the thread again from suspend state
+	 *
+	 * @details Restarts the Thread after suspend call
+	 */
+	void resume();
+
+
+	/**
+	 * Delay function similar to FreeRtos delayUntil function
+	 *
+	 * @param prevoiusWakeTime_ms Needs the previous wake time and returns the next wakeup time
+	 * @param delayTime_ms Time period to delay
+	 *
+	 * @return False If deadline was missed; True if task was delayed
+	 */
+	static bool delayUntil(uint64_t* const prevoiusWakeTime_ms, const uint64_t delayTime_ms);
+
+	/**
+	 * Returns the current time in milliseconds from CLOCK_MONOTONIC
+	 *
+	 * @return current time in milliseconds from CLOCK_MONOTONIC
+	 */
+	static uint64_t getCurrentMonotonicTimeMs();
+
+protected:
+	pthread_t thread;
+
+	/**
+	 * @brief 	Function that has to be called by derived class because the
+	 *  		derived class pointer has to be valid as argument.
+	 * @details
+	 * This function creates a pthread with the given parameters. As the
+	 * function requires a pointer to the derived object it has to be called
+	 * after the this pointer of the derived object is valid.
+	 * Sets the taskEntryPoint as function to be called by new a thread.
+	 * @param fnc_ Function which will be executed by the thread.
+	 * @param arg_
+	 * argument of the taskEntryPoint function, needs to be this pointer
+	 * of derived class
+	 */
+	void createTask(void* (*fnc_)(void*),void* arg_);
+
+private:
+	char name[PTHREAD_MAX_NAMELEN];
+	int priority;
+	size_t stackSize = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index d1332504e..fb8f6df7d 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -1,38 +1,38 @@
-#include "../../ipc/QueueFactory.h"
-#include <mqueue.h>
-#include <errno.h>
-#include "../../osal/linux/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);
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == nullptr) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+#include <mqueue.h>
+#include <errno.h>
+#include "../../osal/linux/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);
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == nullptr) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index bcb5d16fe..e4710933e 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,33 +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;
-}
+#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;
+}
diff --git a/osal/linux/TaskFactory.cpp b/osal/linux/TaskFactory.cpp
index 1cd0b2b10..a25b817d7 100644
--- a/osal/linux/TaskFactory.cpp
+++ b/osal/linux/TaskFactory.cpp
@@ -1,42 +1,42 @@
-#include "../../osal/linux/FixedTimeslotTask.h"
-#include "../../osal/linux/PeriodicPosixTask.h"
-#include "../../tasks/TaskFactory.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return new PeriodicPosixTask(name_, taskPriority_,stackSize_,
-			periodInSeconds_ * 1000, deadLineMissedFunction_);
-}
-
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return new FixedTimeslotTask(name_, taskPriority_,stackSize_,
-			periodInSeconds_*1000);
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	//TODO not implemented
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
-	return PosixThread::sleep(delayMs*1000000ull);
-}
-
-TaskFactory::TaskFactory() {
-}
+#include "../../osal/linux/FixedTimeslotTask.h"
+#include "../../osal/linux/PeriodicPosixTask.h"
+#include "../../tasks/TaskFactory.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new PeriodicPosixTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_ * 1000, deadLineMissedFunction_);
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new FixedTimeslotTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_*1000);
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	//TODO not implemented
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
+	return PosixThread::sleep(delayMs*1000000ull);
+}
+
+TaskFactory::TaskFactory() {
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 04c1d2555..d8a398699 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,137 +1,137 @@
-#include "../../osal/linux/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;
-	}
-}
-
-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;
-	}
-	}
-}
+#include "../../osal/linux/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;
+	}
+}
+
+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;
+	}
+	}
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index 9d678a81c..cc0325616 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -1,67 +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_ */
+#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_ */
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index e45395219..b458fd905 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -1,42 +1,42 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include <errno.h>
-#include "../../osal/linux/Timer.h"
-
-Timer::Timer() {
-	sigevent sigEvent;
-	sigEvent.sigev_notify = SIGEV_NONE;
-	sigEvent.sigev_signo = 0;
-	sigEvent.sigev_value.sival_ptr = &timerId;
-	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
-	if(status!=0){
-		sif::error << "Timer creation failed with: " << status <<
-				" errno: " << errno << std::endl;
-	}
-}
-
-Timer::~Timer() {
-	timer_delete(timerId);
-}
-
-int Timer::setTimer(uint32_t intervalMs) {
-	itimerspec timer;
-	timer.it_value.tv_sec = intervalMs / 1000;
-	timer.it_value.tv_nsec = (intervalMs * 1000000) % (1000000000);
-	timer.it_interval.tv_sec = 0;
-	timer.it_interval.tv_nsec = 0;
-	return timer_settime(timerId, 0, &timer, NULL);
-}
-
-
-int Timer::getTimer(uint32_t* remainingTimeMs){
-	itimerspec timer;
-	timer.it_value.tv_sec = 0;
-	timer.it_value.tv_nsec = 0;
-	timer.it_interval.tv_sec = 0;
-	timer.it_interval.tv_nsec = 0;
-	int status = timer_gettime(timerId, &timer);
-
-	*remainingTimeMs = timer.it_value.tv_sec * 1000 + timer.it_value.tv_nsec / 1000000;
-
-	return status;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <errno.h>
+#include "../../osal/linux/Timer.h"
+
+Timer::Timer() {
+	sigevent sigEvent;
+	sigEvent.sigev_notify = SIGEV_NONE;
+	sigEvent.sigev_signo = 0;
+	sigEvent.sigev_value.sival_ptr = &timerId;
+	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
+	if(status!=0){
+		sif::error << "Timer creation failed with: " << status <<
+				" errno: " << errno << std::endl;
+	}
+}
+
+Timer::~Timer() {
+	timer_delete(timerId);
+}
+
+int Timer::setTimer(uint32_t intervalMs) {
+	itimerspec timer;
+	timer.it_value.tv_sec = intervalMs / 1000;
+	timer.it_value.tv_nsec = (intervalMs * 1000000) % (1000000000);
+	timer.it_interval.tv_sec = 0;
+	timer.it_interval.tv_nsec = 0;
+	return timer_settime(timerId, 0, &timer, NULL);
+}
+
+
+int Timer::getTimer(uint32_t* remainingTimeMs){
+	itimerspec timer;
+	timer.it_value.tv_sec = 0;
+	timer.it_value.tv_nsec = 0;
+	timer.it_interval.tv_sec = 0;
+	timer.it_interval.tv_nsec = 0;
+	int status = timer_gettime(timerId, &timer);
+
+	*remainingTimeMs = timer.it_value.tv_sec * 1000 + timer.it_value.tv_nsec / 1000000;
+
+	return status;
+}
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 57722b3f6..3e9674f3e 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,168 +1,168 @@
-#include "../../osal/linux/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(socket < 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 << "Error: " << strerror(errno) << std::endl;
-	}
-}
-
+#include "../../osal/linux/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(socket < 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 << "Error: " << strerror(errno) << std::endl;
+	}
+}
+
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index e4aa8b1a0..5245c44cb 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -1,48 +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_ */
+#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_ */
diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index 826d0b141..eeffd7f33 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -1,198 +1,198 @@
-#include "../../timemanager/Clock.h"
-#include "RtemsBasic.h"
-#include <rtems/score/todimpl.h>
-
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
-uint32_t Clock::getTicksPerSecond(void){
-	rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-	return static_cast<uint32_t>(ticks_per_second);
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-	rtems_time_of_day timeRtems;
-	timeRtems.year = time->year;
-	timeRtems.month = time->month;
-	timeRtems.day = time->day;
-	timeRtems.hour = time->hour;
-	timeRtems.minute  = time->minute;
-	timeRtems.second = time->second;
-	timeRtems.ticks = time->usecond * getTicksPerSecond() / 1e6;
-	rtems_status_code status = rtems_clock_set(&timeRtems);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_INVALID_ADDRESS:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_CLOCK:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	//TODO This routine uses _TOD_Set which is not
-	timespec newTime;
-	newTime.tv_sec = time->tv_sec;
-	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
-	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
-	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
-	//TODO Second parameter is ISR_lock_Context
-	_TOD_Set(&newTime,NULL);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	//Callable from ISR
-	rtems_status_code status = rtems_clock_get_tod_timeval(time);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_DEFINED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	//According to docs.rtems.org for rtems 5 this method is more accurate than rtems_clock_get_ticks_since_boot
-	timespec time;
-	rtems_status_code status = rtems_clock_get_uptime(&time);
-	uptime->tv_sec = time.tv_sec;
-	time.tv_nsec = time.tv_nsec / 1000;
-	uptime->tv_usec = time.tv_nsec;
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	//This counter overflows after 50 days
-	*uptimeMs = rtems_clock_get_ticks_since_boot();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval temp_time;
-	rtems_status_code returnValue = rtems_clock_get_tod_timeval(&temp_time);
-	*time = ((uint64_t) temp_time.tv_sec * 1000000) + temp_time.tv_usec;
-	switch(returnValue){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
-	rtems_status_code status = rtems_clock_get_tod(timeRtems);
-	switch (status) {
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_DEFINED:
-		//system date and time is not set
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		//time_buffer is NULL
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-	//Fails in 2038..
-	rtems_time_of_day timeRtems;
-	timeRtems.year = from->year;
-	timeRtems.month = from->month;
-	timeRtems.day = from->day;
-	timeRtems.hour = from->hour;
-	timeRtems.minute  = from->minute;
-	timeRtems.second = from->second;
-	timeRtems.ticks = from->usecond * getTicksPerSecond() / 1e6;
-	to->tv_sec = _TOD_To_seconds(&timeRtems);
-	to->tv_usec = from->usecond;
-	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::NO_TIMEOUT);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	leapSeconds = leapSeconds_;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if(timeMutex==NULL){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	*leapSeconds_ = leapSeconds;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex==NULL){
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../timemanager/Clock.h"
+#include "RtemsBasic.h"
+#include <rtems/score/todimpl.h>
+
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
+uint32_t Clock::getTicksPerSecond(void){
+	rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+	return static_cast<uint32_t>(ticks_per_second);
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+	rtems_time_of_day timeRtems;
+	timeRtems.year = time->year;
+	timeRtems.month = time->month;
+	timeRtems.day = time->day;
+	timeRtems.hour = time->hour;
+	timeRtems.minute  = time->minute;
+	timeRtems.second = time->second;
+	timeRtems.ticks = time->usecond * getTicksPerSecond() / 1e6;
+	rtems_status_code status = rtems_clock_set(&timeRtems);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_INVALID_ADDRESS:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_CLOCK:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	//TODO This routine uses _TOD_Set which is not
+	timespec newTime;
+	newTime.tv_sec = time->tv_sec;
+	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
+	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
+	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
+	//TODO Second parameter is ISR_lock_Context
+	_TOD_Set(&newTime,NULL);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+	//Callable from ISR
+	rtems_status_code status = rtems_clock_get_tod_timeval(time);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_NOT_DEFINED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	//According to docs.rtems.org for rtems 5 this method is more accurate than rtems_clock_get_ticks_since_boot
+	timespec time;
+	rtems_status_code status = rtems_clock_get_uptime(&time);
+	uptime->tv_sec = time.tv_sec;
+	time.tv_nsec = time.tv_nsec / 1000;
+	uptime->tv_usec = time.tv_nsec;
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	//This counter overflows after 50 days
+	*uptimeMs = rtems_clock_get_ticks_since_boot();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	timeval temp_time;
+	rtems_status_code returnValue = rtems_clock_get_tod_timeval(&temp_time);
+	*time = ((uint64_t) temp_time.tv_sec * 1000000) + temp_time.tv_usec;
+	switch(returnValue){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
+	rtems_status_code status = rtems_clock_get_tod(timeRtems);
+	switch (status) {
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_NOT_DEFINED:
+		//system date and time is not set
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		//time_buffer is NULL
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+	//Fails in 2038..
+	rtems_time_of_day timeRtems;
+	timeRtems.year = from->year;
+	timeRtems.month = from->month;
+	timeRtems.day = from->day;
+	timeRtems.hour = from->hour;
+	timeRtems.minute  = from->minute;
+	timeRtems.second = from->second;
+	timeRtems.ticks = from->usecond * getTicksPerSecond() / 1e6;
+	to->tv_sec = _TOD_To_seconds(&timeRtems);
+	to->tv_usec = from->usecond;
+	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::NO_TIMEOUT);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	leapSeconds = leapSeconds_;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+	if(timeMutex==NULL){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	*leapSeconds_ = leapSeconds;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::checkOrCreateClockMutex(){
+	if(timeMutex==NULL){
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index c5fac6535..d49de4ad6 100644
--- a/osal/rtems/CpuUsage.cpp
+++ b/osal/rtems/CpuUsage.cpp
@@ -1,183 +1,183 @@
-#include "CpuUsage.h"
-#include "../../serialize/SerialArrayListAdapter.h"
-#include "../../serialize/SerializeAdapter.h"
-#include <string.h>
-
-extern "C" {
-#include <rtems/cpuuse.h>
-}
-
-int handlePrint(void * token, const char *format, ...) {
-	CpuUsage *cpuUsage = (CpuUsage *) token;
-
-	if (cpuUsage->counter == 0) {
-		//header
-		cpuUsage->counter++;
-		return 0;
-	}
-
-	if (cpuUsage->counter % 2 == 1) {
-		{
-			//we can not tell when the last call is so we assume it be every uneven time
-			va_list vl;
-			va_start(vl, format);
-			float timeSinceLastReset = va_arg(vl,uint32_t);
-			uint32_t timeSinceLastResetDecimals = va_arg(vl,uint32_t);
-
-			timeSinceLastReset = timeSinceLastReset
-					+ (timeSinceLastResetDecimals / 1000.);
-
-			cpuUsage->timeSinceLastReset = timeSinceLastReset;
-
-			va_end(vl);
-		}
-		//task name and id
-		va_list vl;
-		va_start(vl, format);
-
-		cpuUsage->cachedValue.id = va_arg(vl,uint32_t);
-		const char *name = va_arg(vl,const char *);
-		memcpy(cpuUsage->cachedValue.name, name,
-				CpuUsage::ThreadData::MAX_LENGTH_OF_THREAD_NAME);
-
-		va_end(vl);
-
-	} else {
-		//statistics
-		va_list vl;
-		va_start(vl, format);
-		float run = va_arg(vl,uint32_t);
-		uint32_t runDecimals = va_arg(vl,uint32_t);
-		float percent = va_arg(vl,uint32_t);
-		uint32_t percent_decimals = va_arg(vl,uint32_t);
-
-		run = run + (runDecimals / 1000.);
-		percent = percent + (percent_decimals / 1000.);
-
-		cpuUsage->cachedValue.percentUsage = percent;
-		cpuUsage->cachedValue.timeRunning = run;
-
-		cpuUsage->threadData.insert(cpuUsage->cachedValue);
-
-		va_end(vl);
-	}
-	cpuUsage->counter++;
-
-	return 0;
-}
-
-CpuUsage::CpuUsage() :
-		counter(0), timeSinceLastReset(0) {
-
-}
-
-CpuUsage::~CpuUsage() {
-
-}
-
-void CpuUsage::resetCpuUsage() {
-	rtems_cpu_usage_reset();
-}
-
-void CpuUsage::read() {
-	//rtems_cpu_usage_report_with_plugin(this, &handlePrint);
-}
-
-void CpuUsage::clear() {
-	counter = 0;
-	timeSinceLastReset = 0;
-	threadData.clear();
-}
-
-ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(
-			&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
-			size, maxSize, streamEndianness);
-}
-
-uint32_t CpuUsage::getSerializedSize() const {
-	uint32_t size = 0;
-
-	size += sizeof(timeSinceLastReset);
-	size += SerialArrayListAdapter<ThreadData>::getSerializedSize(&threadData);
-
-	return size;
-}
-
-ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
-		Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(
-			&timeSinceLastReset, buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
-			size, streamEndianness);
-}
-
-ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
-			size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
-		return BUFFER_TOO_SHORT;
-	}
-	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
-	*size += MAX_LENGTH_OF_THREAD_NAME;
-	*buffer += MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter::serialize(&timeRunning,
-			buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&percentUsage,
-			buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t CpuUsage::ThreadData::getSerializedSize() const {
-	uint32_t size = 0;
-
-	size += sizeof(id);
-	size += MAX_LENGTH_OF_THREAD_NAME;
-	size += sizeof(timeRunning);
-	size += sizeof(percentUsage);
-
-	return size;
-}
-
-ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
-		int32_t* size, Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if ((*size = *size - MAX_LENGTH_OF_THREAD_NAME) < 0) {
-		return STREAM_TOO_SHORT;
-	}
-	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
-	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter::deSerialize(&timeRunning,
-			buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::deSerialize(&percentUsage,
-			buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "CpuUsage.h"
+#include "../../serialize/SerialArrayListAdapter.h"
+#include "../../serialize/SerializeAdapter.h"
+#include <string.h>
+
+extern "C" {
+#include <rtems/cpuuse.h>
+}
+
+int handlePrint(void * token, const char *format, ...) {
+	CpuUsage *cpuUsage = (CpuUsage *) token;
+
+	if (cpuUsage->counter == 0) {
+		//header
+		cpuUsage->counter++;
+		return 0;
+	}
+
+	if (cpuUsage->counter % 2 == 1) {
+		{
+			//we can not tell when the last call is so we assume it be every uneven time
+			va_list vl;
+			va_start(vl, format);
+			float timeSinceLastReset = va_arg(vl,uint32_t);
+			uint32_t timeSinceLastResetDecimals = va_arg(vl,uint32_t);
+
+			timeSinceLastReset = timeSinceLastReset
+					+ (timeSinceLastResetDecimals / 1000.);
+
+			cpuUsage->timeSinceLastReset = timeSinceLastReset;
+
+			va_end(vl);
+		}
+		//task name and id
+		va_list vl;
+		va_start(vl, format);
+
+		cpuUsage->cachedValue.id = va_arg(vl,uint32_t);
+		const char *name = va_arg(vl,const char *);
+		memcpy(cpuUsage->cachedValue.name, name,
+				CpuUsage::ThreadData::MAX_LENGTH_OF_THREAD_NAME);
+
+		va_end(vl);
+
+	} else {
+		//statistics
+		va_list vl;
+		va_start(vl, format);
+		float run = va_arg(vl,uint32_t);
+		uint32_t runDecimals = va_arg(vl,uint32_t);
+		float percent = va_arg(vl,uint32_t);
+		uint32_t percent_decimals = va_arg(vl,uint32_t);
+
+		run = run + (runDecimals / 1000.);
+		percent = percent + (percent_decimals / 1000.);
+
+		cpuUsage->cachedValue.percentUsage = percent;
+		cpuUsage->cachedValue.timeRunning = run;
+
+		cpuUsage->threadData.insert(cpuUsage->cachedValue);
+
+		va_end(vl);
+	}
+	cpuUsage->counter++;
+
+	return 0;
+}
+
+CpuUsage::CpuUsage() :
+		counter(0), timeSinceLastReset(0) {
+
+}
+
+CpuUsage::~CpuUsage() {
+
+}
+
+void CpuUsage::resetCpuUsage() {
+	rtems_cpu_usage_reset();
+}
+
+void CpuUsage::read() {
+	//rtems_cpu_usage_report_with_plugin(this, &handlePrint);
+}
+
+void CpuUsage::clear() {
+	counter = 0;
+	timeSinceLastReset = 0;
+	threadData.clear();
+}
+
+ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(
+			&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
+			size, maxSize, streamEndianness);
+}
+
+uint32_t CpuUsage::getSerializedSize() const {
+	uint32_t size = 0;
+
+	size += sizeof(timeSinceLastReset);
+	size += SerialArrayListAdapter<ThreadData>::getSerializedSize(&threadData);
+
+	return size;
+}
+
+ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(
+			&timeSinceLastReset, buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
+			size, streamEndianness);
+}
+
+ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
+		return BUFFER_TOO_SHORT;
+	}
+	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
+	*size += MAX_LENGTH_OF_THREAD_NAME;
+	*buffer += MAX_LENGTH_OF_THREAD_NAME;
+	result = SerializeAdapter::serialize(&timeRunning,
+			buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&percentUsage,
+			buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t CpuUsage::ThreadData::getSerializedSize() const {
+	uint32_t size = 0;
+
+	size += sizeof(id);
+	size += MAX_LENGTH_OF_THREAD_NAME;
+	size += sizeof(timeRunning);
+	size += sizeof(percentUsage);
+
+	return size;
+}
+
+ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
+		int32_t* size, Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if ((*size = *size - MAX_LENGTH_OF_THREAD_NAME) < 0) {
+		return STREAM_TOO_SHORT;
+	}
+	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
+	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
+	result = SerializeAdapter::deSerialize(&timeRunning,
+			buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&percentUsage,
+			buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/rtems/CpuUsage.h b/osal/rtems/CpuUsage.h
index 24cbb919b..f487e1911 100644
--- a/osal/rtems/CpuUsage.h
+++ b/osal/rtems/CpuUsage.h
@@ -1,53 +1,53 @@
-#ifndef CPUUSAGE_H_
-#define CPUUSAGE_H_
-
-#include "../../container/FixedArrayList.h"
-#include "../../serialize/SerializeIF.h"
-#include <stdarg.h>
-
-class CpuUsage : public SerializeIF {
-public:
-	static const uint8_t MAXIMUM_NUMBER_OF_THREADS = 30;
-
-	class ThreadData: public SerializeIF {
-	public:
-		static const uint8_t MAX_LENGTH_OF_THREAD_NAME = 4;
-
-		uint32_t id;
-		char name[MAX_LENGTH_OF_THREAD_NAME];
-		float timeRunning;
-		float percentUsage;
-
-		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;
-	};
-
-	CpuUsage();
-	virtual ~CpuUsage();
-
-	uint8_t counter;
-	float timeSinceLastReset;
-	FixedArrayList<ThreadData, MAXIMUM_NUMBER_OF_THREADS> threadData;
-	ThreadData cachedValue;
-
-	static void resetCpuUsage();
-
-	void read();
-
-	void clear();
-
-	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;
-};
-
-#endif /* CPUUSAGE_H_ */
+#ifndef CPUUSAGE_H_
+#define CPUUSAGE_H_
+
+#include "../../container/FixedArrayList.h"
+#include "../../serialize/SerializeIF.h"
+#include <stdarg.h>
+
+class CpuUsage : public SerializeIF {
+public:
+	static const uint8_t MAXIMUM_NUMBER_OF_THREADS = 30;
+
+	class ThreadData: public SerializeIF {
+	public:
+		static const uint8_t MAX_LENGTH_OF_THREAD_NAME = 4;
+
+		uint32_t id;
+		char name[MAX_LENGTH_OF_THREAD_NAME];
+		float timeRunning;
+		float percentUsage;
+
+		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;
+	};
+
+	CpuUsage();
+	virtual ~CpuUsage();
+
+	uint8_t counter;
+	float timeSinceLastReset;
+	FixedArrayList<ThreadData, MAXIMUM_NUMBER_OF_THREADS> threadData;
+	ThreadData cachedValue;
+
+	static void resetCpuUsage();
+
+	void read();
+
+	void clear();
+
+	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;
+};
+
+#endif /* CPUUSAGE_H_ */
diff --git a/osal/rtems/InternalErrorCodes.cpp b/osal/rtems/InternalErrorCodes.cpp
index 3542ecced..9346cf15d 100644
--- a/osal/rtems/InternalErrorCodes.cpp
+++ b/osal/rtems/InternalErrorCodes.cpp
@@ -1,60 +1,60 @@
-#include "../../osal/InternalErrorCodes.h"
-#include <rtems/score/interr.h>
-
-ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
-	switch (code) {
-	//TODO It looks like RTEMS-5 does not provide the same error codes
-//	case INTERNAL_ERROR_NO_CONFIGURATION_TABLE:
-//		return NO_CONFIGURATION_TABLE;
-//	case INTERNAL_ERROR_NO_CPU_TABLE:
-//		return NO_CPU_TABLE;
-//	case INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS:
-//		return INVALID_WORKSPACE_ADDRESS;
-	case INTERNAL_ERROR_TOO_LITTLE_WORKSPACE:
-		return TOO_LITTLE_WORKSPACE;
-	case INTERNAL_ERROR_WORKSPACE_ALLOCATION:
-		return WORKSPACE_ALLOCATION;
-//	case INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL:
-//		return INTERRUPT_STACK_TOO_SMALL;
-	case INTERNAL_ERROR_THREAD_EXITTED:
-		return THREAD_EXITTED;
-	case INTERNAL_ERROR_INCONSISTENT_MP_INFORMATION:
-		return INCONSISTENT_MP_INFORMATION;
-	case INTERNAL_ERROR_INVALID_NODE:
-		return INVALID_NODE;
-	case INTERNAL_ERROR_NO_MPCI:
-		return NO_MPCI;
-	case INTERNAL_ERROR_BAD_PACKET:
-		return BAD_PACKET;
-	case INTERNAL_ERROR_OUT_OF_PACKETS:
-		return OUT_OF_PACKETS;
-	case INTERNAL_ERROR_OUT_OF_GLOBAL_OBJECTS:
-		return OUT_OF_GLOBAL_OBJECTS;
-	case INTERNAL_ERROR_OUT_OF_PROXIES:
-		return OUT_OF_PROXIES;
-	case INTERNAL_ERROR_INVALID_GLOBAL_ID:
-		return INVALID_GLOBAL_ID;
-	case INTERNAL_ERROR_BAD_STACK_HOOK:
-		return BAD_STACK_HOOK;
-//	case INTERNAL_ERROR_BAD_ATTRIBUTES:
-//		return BAD_ATTRIBUTES;
-//	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:
-//		return IMPLEMENTATION_KEY_CREATE_INCONSISTENCY;
-//	case INTERNAL_ERROR_IMPLEMENTATION_BLOCKING_OPERATION_CANCEL:
-//		return IMPLEMENTATION_BLOCKING_OPERATION_CANCEL;
-//	case INTERNAL_ERROR_MUTEX_OBTAIN_FROM_BAD_STATE:
-//		return MUTEX_OBTAIN_FROM_BAD_STATE;
-//	case INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0:
-//		return UNLIMITED_AND_MAXIMUM_IS_0;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-InternalErrorCodes::InternalErrorCodes() {
-}
-
-InternalErrorCodes::~InternalErrorCodes() {
-	
-}
-
+#include "../../osal/InternalErrorCodes.h"
+#include <rtems/score/interr.h>
+
+ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
+	switch (code) {
+	//TODO It looks like RTEMS-5 does not provide the same error codes
+//	case INTERNAL_ERROR_NO_CONFIGURATION_TABLE:
+//		return NO_CONFIGURATION_TABLE;
+//	case INTERNAL_ERROR_NO_CPU_TABLE:
+//		return NO_CPU_TABLE;
+//	case INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS:
+//		return INVALID_WORKSPACE_ADDRESS;
+	case INTERNAL_ERROR_TOO_LITTLE_WORKSPACE:
+		return TOO_LITTLE_WORKSPACE;
+	case INTERNAL_ERROR_WORKSPACE_ALLOCATION:
+		return WORKSPACE_ALLOCATION;
+//	case INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL:
+//		return INTERRUPT_STACK_TOO_SMALL;
+	case INTERNAL_ERROR_THREAD_EXITTED:
+		return THREAD_EXITTED;
+	case INTERNAL_ERROR_INCONSISTENT_MP_INFORMATION:
+		return INCONSISTENT_MP_INFORMATION;
+	case INTERNAL_ERROR_INVALID_NODE:
+		return INVALID_NODE;
+	case INTERNAL_ERROR_NO_MPCI:
+		return NO_MPCI;
+	case INTERNAL_ERROR_BAD_PACKET:
+		return BAD_PACKET;
+	case INTERNAL_ERROR_OUT_OF_PACKETS:
+		return OUT_OF_PACKETS;
+	case INTERNAL_ERROR_OUT_OF_GLOBAL_OBJECTS:
+		return OUT_OF_GLOBAL_OBJECTS;
+	case INTERNAL_ERROR_OUT_OF_PROXIES:
+		return OUT_OF_PROXIES;
+	case INTERNAL_ERROR_INVALID_GLOBAL_ID:
+		return INVALID_GLOBAL_ID;
+	case INTERNAL_ERROR_BAD_STACK_HOOK:
+		return BAD_STACK_HOOK;
+//	case INTERNAL_ERROR_BAD_ATTRIBUTES:
+//		return BAD_ATTRIBUTES;
+//	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:
+//		return IMPLEMENTATION_KEY_CREATE_INCONSISTENCY;
+//	case INTERNAL_ERROR_IMPLEMENTATION_BLOCKING_OPERATION_CANCEL:
+//		return IMPLEMENTATION_BLOCKING_OPERATION_CANCEL;
+//	case INTERNAL_ERROR_MUTEX_OBTAIN_FROM_BAD_STATE:
+//		return MUTEX_OBTAIN_FROM_BAD_STATE;
+//	case INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0:
+//		return UNLIMITED_AND_MAXIMUM_IS_0;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+InternalErrorCodes::InternalErrorCodes() {
+}
+
+InternalErrorCodes::~InternalErrorCodes() {
+	
+}
+
diff --git a/osal/rtems/Interrupt.h b/osal/rtems/Interrupt.h
index 076a6704f..2152e2f03 100644
--- a/osal/rtems/Interrupt.h
+++ b/osal/rtems/Interrupt.h
@@ -1,50 +1,50 @@
-#ifndef OS_RTEMS_INTERRUPT_H_
-#define OS_RTEMS_INTERRUPT_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include <cstring>
-#include <rtems.h>
-
-typedef rtems_isr_entry IsrHandler_t;
-typedef rtems_isr IsrReturn_t;
-typedef rtems_vector_number InterruptNumber_t;
-
-class Interrupt {
-public:
-	virtual ~Interrupt(){};
-
-	/**
-	 * Establishes a new interrupt service routine.
-	 * @param handler	The service routine to establish
-	 * @param interrupt	The interrupt (NOT trap type) the routine shall react to.
-	 * @return	RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setInterruptServiceRoutine(IsrHandler_t handler,
-			InterruptNumber_t interrupt, IsrHandler_t *oldHandler = NULL);
-	static ReturnValue_t enableInterrupt(InterruptNumber_t interruptNumber);
-	static ReturnValue_t disableInterrupt(InterruptNumber_t interruptNumber);
-	/**
-	 * Enables the interrupt given.
-	 * The function tests, if the InterruptMask register was written successfully.
-	 * @param interrupt The interrupt to enable.
-	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
-	 */
-	static ReturnValue_t enableGpioInterrupt(InterruptNumber_t interrupt);
-	/**
-	 * Disables the interrupt given.
-	 * @param interrupt The interrupt to disable.
-	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
-	 */
-	static ReturnValue_t disableGpioInterrupt(InterruptNumber_t interrupt);
-
-
-	/**
-	 * Checks if the current executing context is an ISR.
-	 * @return true if handling an interrupt, false else.
-	 */
-	static bool isInterruptInProgress();
-
-};
-
-
-#endif /* OS_RTEMS_INTERRUPT_H_ */
+#ifndef OS_RTEMS_INTERRUPT_H_
+#define OS_RTEMS_INTERRUPT_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <cstring>
+#include <rtems.h>
+
+typedef rtems_isr_entry IsrHandler_t;
+typedef rtems_isr IsrReturn_t;
+typedef rtems_vector_number InterruptNumber_t;
+
+class Interrupt {
+public:
+	virtual ~Interrupt(){};
+
+	/**
+	 * Establishes a new interrupt service routine.
+	 * @param handler	The service routine to establish
+	 * @param interrupt	The interrupt (NOT trap type) the routine shall react to.
+	 * @return	RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setInterruptServiceRoutine(IsrHandler_t handler,
+			InterruptNumber_t interrupt, IsrHandler_t *oldHandler = NULL);
+	static ReturnValue_t enableInterrupt(InterruptNumber_t interruptNumber);
+	static ReturnValue_t disableInterrupt(InterruptNumber_t interruptNumber);
+	/**
+	 * Enables the interrupt given.
+	 * The function tests, if the InterruptMask register was written successfully.
+	 * @param interrupt The interrupt to enable.
+	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
+	 */
+	static ReturnValue_t enableGpioInterrupt(InterruptNumber_t interrupt);
+	/**
+	 * Disables the interrupt given.
+	 * @param interrupt The interrupt to disable.
+	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
+	 */
+	static ReturnValue_t disableGpioInterrupt(InterruptNumber_t interrupt);
+
+
+	/**
+	 * Checks if the current executing context is an ISR.
+	 * @return true if handling an interrupt, false else.
+	 */
+	static bool isInterruptInProgress();
+
+};
+
+
+#endif /* OS_RTEMS_INTERRUPT_H_ */
diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index e0752409c..700db444e 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -1,147 +1,147 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "MessageQueue.h"
-#include "RtemsBasic.h"
-#include <cstring>
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(NULL) {
-	rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
-	rtems_status_code status = rtems_message_queue_create(name, message_depth,
-			max_message_size, 0, &(this->id));
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-				<< name << std::dec << " failed with status:"
-				<< (uint32_t) status << std::endl;
-		this->id = 0;
-	}
-}
-
-MessageQueue::~MessageQueue() {
-	rtems_message_queue_delete(id);
-}
-
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
-	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
-	return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
-	if (this->lastPartner != 0) {
-		return sendMessage(this->lastPartner, message, this->getId());
-	} else {
-		return NO_REPLY_PARTNER;
-	}
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
-		MessageQueueId_t* receivedFrom) {
-	ReturnValue_t status = this->receiveMessage(message);
-	*receivedFrom = this->lastPartner;
-	return status;
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
-	rtems_status_code status = rtems_message_queue_receive(id,
-			message->getBuffer(), &(message->messageSize),
-			RTEMS_NO_WAIT, 1);
-	if (status == RTEMS_SUCCESSFUL) {
-		this->lastPartner = message->getSender();
-		//Check size of incoming message.
-		if (message->messageSize < message->getMinimumMessageSize()) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	} else {
-		//No message was received. Keep lastPartner anyway, I might send something later.
-		//But still, delete packet content.
-		memset(message->getData(), 0, message->MAX_DATA_SIZE);
-	}
-	return convertReturnCode(status);
-}
-
-MessageQueueId_t MessageQueue::getLastPartner() const {
-	return this->lastPartner;
-}
-
-ReturnValue_t MessageQueue::flush(uint32_t* count) {
-	rtems_status_code status = rtems_message_queue_flush(id, count);
-	return convertReturnCode(status);
-}
-
-MessageQueueId_t MessageQueue::getId() const {
-	return this->id;
-}
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-	this->defaultDestination = defaultDestination;
-}
-
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-
-	message->setSender(sentFrom);
-	rtems_status_code result = rtems_message_queue_send(sendTo,
-			message->getBuffer(), message->messageSize);
-
-	//TODO: Check if we're in ISR.
-	if (result != RTEMS_SUCCESSFUL && !ignoreFault) {
-		if (internalErrorReporter == NULL) {
-			internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-					objects::INTERNAL_ERROR_REPORTER);
-		}
-		if (internalErrorReporter != NULL) {
-			internalErrorReporter->queueMessageNotSent();
-		}
-	}
-
-	ReturnValue_t returnCode = convertReturnCode(result);
-	if(result == MessageQueueIF::EMPTY){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	return returnCode;
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const {
-	return this->defaultDestination;
-}
-
-bool MessageQueue::isDefaultDestinationSet() const {
-	return (defaultDestination != NO_QUEUE);
-}
-
-ReturnValue_t MessageQueue::convertReturnCode(rtems_status_code inValue){
-		switch(inValue){
-		case RTEMS_SUCCESSFUL:
-			return HasReturnvaluesIF::RETURN_OK;
-		case  RTEMS_INVALID_ID:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_TIMEOUT:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_OBJECT_WAS_DELETED:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_INVALID_ADDRESS:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_INVALID_SIZE:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_TOO_MANY:
-			return MessageQueueIF::FULL;
-		case RTEMS_UNSATISFIED:
-			return MessageQueueIF::EMPTY;
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-
-}
-
-
-
-uint16_t MessageQueue::queueCounter = 0;
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "MessageQueue.h"
+#include "RtemsBasic.h"
+#include <cstring>
+MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
+		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(NULL) {
+	rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
+	rtems_status_code status = rtems_message_queue_create(name, message_depth,
+			max_message_size, 0, &(this->id));
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+				<< name << std::dec << " failed with status:"
+				<< (uint32_t) status << std::endl;
+		this->id = 0;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	rtems_message_queue_delete(id);
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+	if (this->lastPartner != 0) {
+		return sendMessage(this->lastPartner, message, this->getId());
+	} else {
+		return NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	*receivedFrom = this->lastPartner;
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+	rtems_status_code status = rtems_message_queue_receive(id,
+			message->getBuffer(), &(message->messageSize),
+			RTEMS_NO_WAIT, 1);
+	if (status == RTEMS_SUCCESSFUL) {
+		this->lastPartner = message->getSender();
+		//Check size of incoming message.
+		if (message->messageSize < message->getMinimumMessageSize()) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	} else {
+		//No message was received. Keep lastPartner anyway, I might send something later.
+		//But still, delete packet content.
+		memset(message->getData(), 0, message->MAX_DATA_SIZE);
+	}
+	return convertReturnCode(status);
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return this->lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	rtems_status_code status = rtems_message_queue_flush(id, count);
+	return convertReturnCode(status);
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return this->id;
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	this->defaultDestination = defaultDestination;
+}
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+
+	message->setSender(sentFrom);
+	rtems_status_code result = rtems_message_queue_send(sendTo,
+			message->getBuffer(), message->messageSize);
+
+	//TODO: Check if we're in ISR.
+	if (result != RTEMS_SUCCESSFUL && !ignoreFault) {
+		if (internalErrorReporter == NULL) {
+			internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+		}
+		if (internalErrorReporter != NULL) {
+			internalErrorReporter->queueMessageNotSent();
+		}
+	}
+
+	ReturnValue_t returnCode = convertReturnCode(result);
+	if(result == MessageQueueIF::EMPTY){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	return returnCode;
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return this->defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return (defaultDestination != NO_QUEUE);
+}
+
+ReturnValue_t MessageQueue::convertReturnCode(rtems_status_code inValue){
+		switch(inValue){
+		case RTEMS_SUCCESSFUL:
+			return HasReturnvaluesIF::RETURN_OK;
+		case  RTEMS_INVALID_ID:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_TIMEOUT:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_OBJECT_WAS_DELETED:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_INVALID_ADDRESS:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_INVALID_SIZE:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_TOO_MANY:
+			return MessageQueueIF::FULL;
+		case RTEMS_UNSATISFIED:
+			return MessageQueueIF::EMPTY;
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+}
+
+
+
+uint16_t MessageQueue::queueCounter = 0;
diff --git a/osal/rtems/MessageQueue.h b/osal/rtems/MessageQueue.h
index 2d1bd8db8..c6fc62d52 100644
--- a/osal/rtems/MessageQueue.h
+++ b/osal/rtems/MessageQueue.h
@@ -1,181 +1,181 @@
-/**
- *	@file	MessageQueue.h
- *
- *  @date	10/02/2012
- *	@author	Bastian Baetz
- *
- *	@brief	This file contains the definition of the MessageQueue class.
- */
-
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
-
-#include "../../internalError/InternalErrorReporterIF.h"
-#include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/MessageQueueMessage.h"
-#include "RtemsBasic.h"
-
-/**
- *	@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.
- *	\ingroup message_queue
- */
-class MessageQueue : public MessageQueueIF {
-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 i 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 message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
-	/**
-	 * @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,
-			MessageQueueMessage* message, bool ignoreFault = false );
-	/**
-	 * @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( MessageQueueMessage* message );
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter 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( MessageQueueMessage* message );
-
-	/**
-	 * @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(MessageQueueMessage* message,
-			MessageQueueId_t *receivedFrom);
-
-	/**
-	 * @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(MessageQueueMessage* message);
-	/**
-	 * 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);
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	MessageQueueId_t getId() const;
-	/**
-	 * \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, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \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( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * \brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
-
-	bool isDefaultDestinationSet() const;
-private:
-	/**
-	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
-	 * 			If initialization fails, the queue id is set to zero.
-	 */
-	MessageQueueId_t id;
-	/**
-	 * @brief	In this attribute, the queue id of the last communication partner is stored
-	 * 			to allow for replying.
-	 */
-	MessageQueueId_t lastPartner;
-	/**
-	 * @brief	The message queue's name -a user specific information for the operating system-  is
-	 * 			generated automatically with the help of this static counter.
-	 */
-	/**
-	 * \brief	This attribute stores a default destination to send messages to.
-	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
-	 * 			be set in the constructor or by a setter call to setDefaultDestination.
-	 */
-	MessageQueueId_t defaultDestination;
-
-	/**
-	 * \brief	This attribute stores a reference to the internal error reporter for reporting full queues.
-	 * \details	In the event of a full destination queue, the reporter will be notified. The reference is set
-	 * 			by lazy loading
-	 */
-	InternalErrorReporterIF *internalErrorReporter;
-
-	static uint16_t queueCounter;
-	/**
-	 * A method to convert an OS-specific return code to the frameworks return value concept.
-	 * @param inValue The return code coming from the OS.
-	 * @return The converted return value.
-	 */
-	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
-};
-
-#endif /* MESSAGEQUEUE_H_ */
+/**
+ *	@file	MessageQueue.h
+ *
+ *  @date	10/02/2012
+ *	@author	Bastian Baetz
+ *
+ *	@brief	This file contains the definition of the MessageQueue class.
+ */
+
+#ifndef MESSAGEQUEUE_H_
+#define MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessage.h"
+#include "RtemsBasic.h"
+
+/**
+ *	@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.
+ *	\ingroup message_queue
+ */
+class MessageQueue : public MessageQueueIF {
+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 i 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 message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	/**
+	 * @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,
+			MessageQueueMessage* message, bool ignoreFault = false );
+	/**
+	 * @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( MessageQueueMessage* message );
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using the stored
+	 * 			lastParnter 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( MessageQueueMessage* message );
+
+	/**
+	 * @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(MessageQueueMessage* message,
+			MessageQueueId_t *receivedFrom);
+
+	/**
+	 * @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(MessageQueueMessage* message);
+	/**
+	 * 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);
+	/**
+	 * @brief	This method returns the message queue id of the last communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const;
+	/**
+	 * @brief	This method returns the message queue id of this class's message queue.
+	 */
+	MessageQueueId_t getId() const;
+	/**
+	 * \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, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	/**
+	 * \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( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	/**
+	 * \brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination);
+	/**
+	 * \brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const;
+
+	bool isDefaultDestinationSet() const;
+private:
+	/**
+	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the queue id is set to zero.
+	 */
+	MessageQueueId_t id;
+	/**
+	 * @brief	In this attribute, the queue id of the last communication partner is stored
+	 * 			to allow for replying.
+	 */
+	MessageQueueId_t lastPartner;
+	/**
+	 * @brief	The message queue's name -a user specific information for the operating system-  is
+	 * 			generated automatically with the help of this static counter.
+	 */
+	/**
+	 * \brief	This attribute stores a default destination to send messages to.
+	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
+	 * 			be set in the constructor or by a setter call to setDefaultDestination.
+	 */
+	MessageQueueId_t defaultDestination;
+
+	/**
+	 * \brief	This attribute stores a reference to the internal error reporter for reporting full queues.
+	 * \details	In the event of a full destination queue, the reporter will be notified. The reference is set
+	 * 			by lazy loading
+	 */
+	InternalErrorReporterIF *internalErrorReporter;
+
+	static uint16_t queueCounter;
+	/**
+	 * A method to convert an OS-specific return code to the frameworks return value concept.
+	 * @param inValue The return code coming from the OS.
+	 * @return The converted return value.
+	 */
+	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
+};
+
+#endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index 8cec10f7e..8f969a1d1 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -1,87 +1,87 @@
-/**
- * @file	MultiObjectTask.cpp
- * @brief	This file defines the MultiObjectTask class.
- * @date	30.01.2014
- * @author	baetz
- */
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tasks/ExecutableObjectIF.h"
-#include "MultiObjectTask.h"
-
-MultiObjectTask::MultiObjectTask(const char *name, rtems_task_priority setPriority,
-		size_t setStack, rtems_interval setPeriod, void (*setDeadlineMissedFunc)()) :
-		TaskBase(setPriority, setStack, name), periodTicks(
-				RtemsBasic::convertMsToTicks(setPeriod)), periodId(0), deadlineMissedFunc(
-				setDeadlineMissedFunc) {
-}
-
-MultiObjectTask::~MultiObjectTask(void) {
-	//Do not delete objects, we were responsible for ptrs only.
-	rtems_rate_monotonic_delete(periodId);
-}
-rtems_task MultiObjectTask::taskEntryPoint(rtems_task_argument argument) {
-	//The argument is re-interpreted as MultiObjectTask. The Task object is global, so it is found from any place.
-	MultiObjectTask *originalTask(reinterpret_cast<MultiObjectTask*>(argument));
-	originalTask->taskFunctionality();
-}
-
-ReturnValue_t MultiObjectTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
-			rtems_task_argument((void *) this));
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "ObjectTask::startTask for " << std::hex << this->getId()
-				<< std::dec << " failed." << std::endl;
-	}
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ask started successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-/*		RTEMS_INVALID_ADDRESS - invalid task entry point
-		RTEMS_INVALID_ID - invalid task id
-		RTEMS_INCORRECT_STATE - task not in the dormant state
-		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t MultiObjectTask::sleepFor(uint32_t ms) {
-	return TaskBase::sleepFor(ms);
-}
-
-void MultiObjectTask::taskFunctionality() {
-	TaskBase::setAndStartPeriod(periodTicks,&periodId);
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
-		}
-		rtems_status_code status = TaskBase::restartPeriod(periodTicks,periodId);
-		if (status == RTEMS_TIMEOUT) {
-			char nameSpace[8] = { 0 };
-			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
-					nameSpace);
-			error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
-			if (this->deadlineMissedFunc != NULL) {
-				this->deadlineMissedFunc();
-			}
-		}
-	}
-}
-
-ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	ReturnValue_t result = newObject->initializeAfterTaskCreation();
-	return result;
-}
-
-uint32_t MultiObjectTask::getPeriodMs() const {
-	return RtemsBasic::convertTicksToMs(periodTicks);
-}
+/**
+ * @file	MultiObjectTask.cpp
+ * @brief	This file defines the MultiObjectTask class.
+ * @date	30.01.2014
+ * @author	baetz
+ */
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include "MultiObjectTask.h"
+
+MultiObjectTask::MultiObjectTask(const char *name, rtems_task_priority setPriority,
+		size_t setStack, rtems_interval setPeriod, void (*setDeadlineMissedFunc)()) :
+		TaskBase(setPriority, setStack, name), periodTicks(
+				RtemsBasic::convertMsToTicks(setPeriod)), periodId(0), deadlineMissedFunc(
+				setDeadlineMissedFunc) {
+}
+
+MultiObjectTask::~MultiObjectTask(void) {
+	//Do not delete objects, we were responsible for ptrs only.
+	rtems_rate_monotonic_delete(periodId);
+}
+rtems_task MultiObjectTask::taskEntryPoint(rtems_task_argument argument) {
+	//The argument is re-interpreted as MultiObjectTask. The Task object is global, so it is found from any place.
+	MultiObjectTask *originalTask(reinterpret_cast<MultiObjectTask*>(argument));
+	originalTask->taskFunctionality();
+}
+
+ReturnValue_t MultiObjectTask::startTask() {
+	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
+			rtems_task_argument((void *) this));
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "ObjectTask::startTask for " << std::hex << this->getId()
+				<< std::dec << " failed." << std::endl;
+	}
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//ask started successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+/*		RTEMS_INVALID_ADDRESS - invalid task entry point
+		RTEMS_INVALID_ID - invalid task id
+		RTEMS_INCORRECT_STATE - task not in the dormant state
+		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t MultiObjectTask::sleepFor(uint32_t ms) {
+	return TaskBase::sleepFor(ms);
+}
+
+void MultiObjectTask::taskFunctionality() {
+	TaskBase::setAndStartPeriod(periodTicks,&periodId);
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		for (ObjectList::iterator it = objectList.begin();
+				it != objectList.end(); ++it) {
+			(*it)->performOperation();
+		}
+		rtems_status_code status = TaskBase::restartPeriod(periodTicks,periodId);
+		if (status == RTEMS_TIMEOUT) {
+			char nameSpace[8] = { 0 };
+			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
+					nameSpace);
+			error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
+			if (this->deadlineMissedFunc != NULL) {
+				this->deadlineMissedFunc();
+			}
+		}
+	}
+}
+
+ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	ReturnValue_t result = newObject->initializeAfterTaskCreation();
+	return result;
+}
+
+uint32_t MultiObjectTask::getPeriodMs() const {
+	return RtemsBasic::convertTicksToMs(periodTicks);
+}
diff --git a/osal/rtems/MultiObjectTask.h b/osal/rtems/MultiObjectTask.h
index b3ff66c2e..28d05fb1a 100644
--- a/osal/rtems/MultiObjectTask.h
+++ b/osal/rtems/MultiObjectTask.h
@@ -1,113 +1,113 @@
-/**
- * @file	MultiObjectTask.h
- * @brief	This file defines the MultiObjectTask class.
- * @date	30.01.2014
- * @author	baetz
- */
-#ifndef MULTIOBJECTTASK_H_
-#define MULTIOBJECTTASK_H_
-
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../tasks/PeriodicTaskIF.h"
-
-#include "TaskBase.h"
-#include <vector>
-
-class ExecutableObjectIF;
-
-/**
- * @brief This class represents a specialized task for periodic activities of multiple objects.
- *
- * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
- * 			multiple objects that implement the ExecutableObjectIF interface. The objects must be
- * 			added prior to starting the task.
- *
- * @ingroup task_handling
- */
-class MultiObjectTask: public TaskBase, public PeriodicTaskIF {
-public:
-	/**
-	 * @brief	Standard constructor of the class.
-	 * @details	The class is initialized without allocated objects. These need to be added
-	 * 			with #addObject.
-	 * 			In the underlying TaskBase class, a new operating system task is created.
-	 * 			In addition to the TaskBase parameters, the period, the pointer to the
-	 * 			aforementioned initialization function and an optional "deadline-missed"
-	 * 			function pointer is passed.
-	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
-	 * @param stack_size	The stack size reserved by the operating system for the task.
-	 * @param setPeriod 	The length of the period with which the task's functionality will be
-	 * 						executed. It is expressed in clock ticks.
-	 * @param setDeadlineMissedFunc	The function pointer to the deadline missed function
-	 * 								that shall be assigned.
-	 */
-	MultiObjectTask(const char *name, rtems_task_priority setPriority, size_t setStack, rtems_interval 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 ~MultiObjectTask(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 RETURN_OK on success, 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:
-	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-	/**
-	 * @brief	The period of the task.
-	 * @details	The period determines the frequency of the task's execution. It is expressed in clock ticks.
-	 */
-	rtems_interval periodTicks;
-	/**
-	 * @brief id of the associated OS period
-	 */
-	rtems_id periodId;
-	/**
-	 * @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.
-	 */
-	static rtems_task taskEntryPoint(rtems_task_argument 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);
-};
-
-#endif /* MULTIOBJECTTASK_H_ */
+/**
+ * @file	MultiObjectTask.h
+ * @brief	This file defines the MultiObjectTask class.
+ * @date	30.01.2014
+ * @author	baetz
+ */
+#ifndef MULTIOBJECTTASK_H_
+#define MULTIOBJECTTASK_H_
+
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+
+#include "TaskBase.h"
+#include <vector>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief This class represents a specialized task for periodic activities of multiple objects.
+ *
+ * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
+ * 			multiple objects that implement the ExecutableObjectIF interface. The objects must be
+ * 			added prior to starting the task.
+ *
+ * @ingroup task_handling
+ */
+class MultiObjectTask: public TaskBase, public PeriodicTaskIF {
+public:
+	/**
+	 * @brief	Standard constructor of the class.
+	 * @details	The class is initialized without allocated objects. These need to be added
+	 * 			with #addObject.
+	 * 			In the underlying TaskBase class, a new operating system task is created.
+	 * 			In addition to the TaskBase parameters, the period, the pointer to the
+	 * 			aforementioned initialization function and an optional "deadline-missed"
+	 * 			function pointer is passed.
+	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
+	 * @param stack_size	The stack size reserved by the operating system for the task.
+	 * @param setPeriod 	The length of the period with which the task's functionality will be
+	 * 						executed. It is expressed in clock ticks.
+	 * @param setDeadlineMissedFunc	The function pointer to the deadline missed function
+	 * 								that shall be assigned.
+	 */
+	MultiObjectTask(const char *name, rtems_task_priority setPriority, size_t setStack, rtems_interval 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 ~MultiObjectTask(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 RETURN_OK on success, 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:
+	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+	/**
+	 * @brief	The period of the task.
+	 * @details	The period determines the frequency of the task's execution. It is expressed in clock ticks.
+	 */
+	rtems_interval periodTicks;
+	/**
+	 * @brief id of the associated OS period
+	 */
+	rtems_id periodId;
+	/**
+	 * @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.
+	 */
+	static rtems_task taskEntryPoint(rtems_task_argument 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);
+};
+
+#endif /* MULTIOBJECTTASK_H_ */
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index 7ead88518..d8babcde7 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -1,65 +1,65 @@
-#include "Mutex.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-const uint32_t MutexIF::NO_TIMEOUT = RTEMS_NO_TIMEOUT;
-uint8_t Mutex::count = 0;
-
-Mutex::Mutex() :
-		mutexId(0) {
-	rtems_name mutexName = ('M' << 24) + ('T' << 16) + ('X' << 8) + count++;
-	rtems_status_code status = rtems_semaphore_create(mutexName, 1,
-	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
-			&mutexId);
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
-				<< " failed with " << status << std::endl;
-	}
-}
-
-Mutex::~Mutex() {
-	rtems_status_code status = rtems_semaphore_delete(mutexId);
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "Mutex: deletion for id " << mutexId
-				<< " failed with " << status << std::endl;
-	}
-}
-
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	rtems_status_code status = rtems_semaphore_obtain(mutexId, RTEMS_WAIT, timeoutMs);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//semaphore obtained successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_UNSATISFIED:
-		//semaphore not available
-		return MUTEX_NOT_FOUND;
-	case RTEMS_TIMEOUT:
-		//timed out waiting for semaphore
-		return MUTEX_TIMEOUT;
-	case RTEMS_OBJECT_WAS_DELETED:
-		//semaphore deleted while waiting
-		return MUTEX_DESTROYED_WHILE_WAITING;
-	case RTEMS_INVALID_ID:
-		//invalid semaphore id
-		return MUTEX_INVALID_ID;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	rtems_status_code status = rtems_semaphore_release(mutexId);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//semaphore obtained successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_OWNER_OF_RESOURCE:
-		//semaphore not available
-		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	case RTEMS_INVALID_ID:
-		//invalid semaphore id
-		return MUTEX_INVALID_ID;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
+#include "Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t MutexIF::NO_TIMEOUT = RTEMS_NO_TIMEOUT;
+uint8_t Mutex::count = 0;
+
+Mutex::Mutex() :
+		mutexId(0) {
+	rtems_name mutexName = ('M' << 24) + ('T' << 16) + ('X' << 8) + count++;
+	rtems_status_code status = rtems_semaphore_create(mutexName, 1,
+	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
+			&mutexId);
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
+				<< " failed with " << status << std::endl;
+	}
+}
+
+Mutex::~Mutex() {
+	rtems_status_code status = rtems_semaphore_delete(mutexId);
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "Mutex: deletion for id " << mutexId
+				<< " failed with " << status << std::endl;
+	}
+}
+
+ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+	rtems_status_code status = rtems_semaphore_obtain(mutexId, RTEMS_WAIT, timeoutMs);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//semaphore obtained successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_UNSATISFIED:
+		//semaphore not available
+		return MUTEX_NOT_FOUND;
+	case RTEMS_TIMEOUT:
+		//timed out waiting for semaphore
+		return MUTEX_TIMEOUT;
+	case RTEMS_OBJECT_WAS_DELETED:
+		//semaphore deleted while waiting
+		return MUTEX_DESTROYED_WHILE_WAITING;
+	case RTEMS_INVALID_ID:
+		//invalid semaphore id
+		return MUTEX_INVALID_ID;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	rtems_status_code status = rtems_semaphore_release(mutexId);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//semaphore obtained successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_NOT_OWNER_OF_RESOURCE:
+		//semaphore not available
+		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	case RTEMS_INVALID_ID:
+		//invalid semaphore id
+		return MUTEX_INVALID_ID;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
diff --git a/osal/rtems/Mutex.h b/osal/rtems/Mutex.h
index fd76b86a3..340bb16b7 100644
--- a/osal/rtems/Mutex.h
+++ b/osal/rtems/Mutex.h
@@ -1,18 +1,18 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
-
-#include "../../ipc/MutexIF.h"
-#include "RtemsBasic.h"
-
-class Mutex : public MutexIF {
-public:
-	Mutex();
-	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs);
-	ReturnValue_t unlockMutex();
-private:
-	rtems_id mutexId;
-	static uint8_t count;
-};
-
-#endif /* OS_RTEMS_MUTEX_H_ */
+#ifndef OS_RTEMS_MUTEX_H_
+#define OS_RTEMS_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+#include "RtemsBasic.h"
+
+class Mutex : public MutexIF {
+public:
+	Mutex();
+	~Mutex();
+	ReturnValue_t lockMutex(uint32_t timeoutMs);
+	ReturnValue_t unlockMutex();
+private:
+	rtems_id mutexId;
+	static uint8_t count;
+};
+
+#endif /* OS_RTEMS_MUTEX_H_ */
diff --git a/osal/rtems/MutexFactory.cpp b/osal/rtems/MutexFactory.cpp
index 3ffab927c..ea5947895 100644
--- a/osal/rtems/MutexFactory.cpp
+++ b/osal/rtems/MutexFactory.cpp
@@ -1,24 +1,24 @@
-#include "../../ipc/MutexFactory.h"
-#include "Mutex.h"
-#include "RtemsBasic.h"
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-
-MutexFactory::MutexFactory() {
-}
-
-MutexFactory::~MutexFactory() {
-}
-
-MutexFactory* MutexFactory::instance() {
-	return MutexFactory::factoryInstance;
-}
-
-MutexIF* MutexFactory::createMutex() {
-	return new Mutex();
-}
-
-void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
-}
+#include "../../ipc/MutexFactory.h"
+#include "Mutex.h"
+#include "RtemsBasic.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index b53d6a5a4..efb425d97 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -1,122 +1,122 @@
-#include "../../tasks/FixedSequenceSlot.h"
-#include "../../objectmanager/SystemObjectIF.h"
-#include "../../osal/rtems/PollingTask.h"
-#include "../../osal/rtems/RtemsBasic.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include <rtems/bspIo.h>
-#include <rtems/rtems/ratemon.h>
-#include <rtems/rtems/status.h>
-#include <rtems/rtems/tasks.h>
-#include <rtems/rtems/types.h>
-#include <stddef.h>
-#include <sys/_stdint.h>
-#include <iostream>
-#include <list>
-
-uint32_t PollingTask::deadlineMissedCount = 0;
-
-PollingTask::PollingTask(const char *name, rtems_task_priority setPriority,
-		size_t setStack, uint32_t setOverallPeriod,
-		void (*setDeadlineMissedFunc)()) :
-		TaskBase(setPriority, setStack, name), periodId(0), pst(
-				setOverallPeriod) {
-	// All additional attributes are applied to the object.
-	this->deadlineMissedFunc = setDeadlineMissedFunc;
-}
-
-PollingTask::~PollingTask() {
-}
-
-rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
-
-	//The argument is re-interpreted as PollingTask.
-	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-	debug << "Polling task " << originalTask->getId()
-			<< " returned from taskFunctionality." << std::endl;
-}
-
-void PollingTask::missedDeadlineCounter() {
-	PollingTask::deadlineMissedCount++;
-	if (PollingTask::deadlineMissedCount % 10 == 0) {
-		error << "PST missed " << PollingTask::deadlineMissedCount
-				<< " deadlines." << std::endl;
-	}
-}
-
-ReturnValue_t PollingTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
-			rtems_task_argument((void *) this));
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "PollingTask::startTask for " << std::hex << this->getId()
-				<< std::dec << " failed." << std::endl;
-	}
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ask started successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-/*		RTEMS_INVALID_ADDRESS - invalid task entry point
-		RTEMS_INVALID_ID - invalid task id
-		RTEMS_INCORRECT_STATE - task not in the dormant state
-		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t PollingTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t PollingTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t PollingTask::checkAndInitializeSequence() const {
-	return pst.checkSequence();
-}
-
-#include <rtems/io.h>
-
-void PollingTask::taskFunctionality() {
-	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
-	std::list<FixedSequenceSlot*>::iterator it = pst.current;
-
-	//The start time for the first entry is read.
-	rtems_interval interval = RtemsBasic::convertMsToTicks(
-			(*it)->pollingTimeMs);
-	TaskBase::setAndStartPeriod(interval,&periodId);
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		} else {
-			//The interval for the next polling slot is selected.
-			interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
-			//The period is checked and restarted with the new interval.
-			//If the deadline was missed, the deadlineMissedFunc is called.
-			rtems_status_code status = TaskBase::restartPeriod(interval,periodId);
-			if (status == RTEMS_TIMEOUT) {
-				if (this->deadlineMissedFunc != NULL) {
-					this->deadlineMissedFunc();
-				}
-			}
-		}
-		//The device handler for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-	}
-}
-
-ReturnValue_t PollingTask::sleepFor(uint32_t ms){
-	return TaskBase::sleepFor(ms);
-};
+#include "../../tasks/FixedSequenceSlot.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../osal/rtems/PollingTask.h"
+#include "../../osal/rtems/RtemsBasic.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <rtems/bspIo.h>
+#include <rtems/rtems/ratemon.h>
+#include <rtems/rtems/status.h>
+#include <rtems/rtems/tasks.h>
+#include <rtems/rtems/types.h>
+#include <stddef.h>
+#include <sys/_stdint.h>
+#include <iostream>
+#include <list>
+
+uint32_t PollingTask::deadlineMissedCount = 0;
+
+PollingTask::PollingTask(const char *name, rtems_task_priority setPriority,
+		size_t setStack, uint32_t setOverallPeriod,
+		void (*setDeadlineMissedFunc)()) :
+		TaskBase(setPriority, setStack, name), periodId(0), pst(
+				setOverallPeriod) {
+	// All additional attributes are applied to the object.
+	this->deadlineMissedFunc = setDeadlineMissedFunc;
+}
+
+PollingTask::~PollingTask() {
+}
+
+rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
+
+	//The argument is re-interpreted as PollingTask.
+	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
+	//The task's functionality is called.
+	originalTask->taskFunctionality();
+	debug << "Polling task " << originalTask->getId()
+			<< " returned from taskFunctionality." << std::endl;
+}
+
+void PollingTask::missedDeadlineCounter() {
+	PollingTask::deadlineMissedCount++;
+	if (PollingTask::deadlineMissedCount % 10 == 0) {
+		error << "PST missed " << PollingTask::deadlineMissedCount
+				<< " deadlines." << std::endl;
+	}
+}
+
+ReturnValue_t PollingTask::startTask() {
+	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
+			rtems_task_argument((void *) this));
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "PollingTask::startTask for " << std::hex << this->getId()
+				<< std::dec << " failed." << std::endl;
+	}
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//ask started successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+/*		RTEMS_INVALID_ADDRESS - invalid task entry point
+		RTEMS_INVALID_ID - invalid task id
+		RTEMS_INCORRECT_STATE - task not in the dormant state
+		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t PollingTask::addSlot(object_id_t componentId,
+		uint32_t slotTimeMs, int8_t executionStep) {
+	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t PollingTask::getPeriodMs() const {
+	return pst.getLengthMs();
+}
+
+ReturnValue_t PollingTask::checkAndInitializeSequence() const {
+	return pst.checkSequence();
+}
+
+#include <rtems/io.h>
+
+void PollingTask::taskFunctionality() {
+	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
+	std::list<FixedSequenceSlot*>::iterator it = pst.current;
+
+	//The start time for the first entry is read.
+	rtems_interval interval = RtemsBasic::convertMsToTicks(
+			(*it)->pollingTimeMs);
+	TaskBase::setAndStartPeriod(interval,&periodId);
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		if (pst.slotFollowsImmediately()) {
+			//Do nothing
+		} else {
+			//The interval for the next polling slot is selected.
+			interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
+			//The period is checked and restarted with the new interval.
+			//If the deadline was missed, the deadlineMissedFunc is called.
+			rtems_status_code status = TaskBase::restartPeriod(interval,periodId);
+			if (status == RTEMS_TIMEOUT) {
+				if (this->deadlineMissedFunc != NULL) {
+					this->deadlineMissedFunc();
+				}
+			}
+		}
+		//The device handler for this slot is executed and the next one is chosen.
+		this->pst.executeAndAdvance();
+	}
+}
+
+ReturnValue_t PollingTask::sleepFor(uint32_t ms){
+	return TaskBase::sleepFor(ms);
+};
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 60ce08164..1502f0c60 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -1,85 +1,85 @@
-#ifndef POLLINGTASK_H_
-#define POLLINGTASK_H_
-
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../tasks/FixedTimeslotTaskIF.h"
-#include "TaskBase.h"
-
-class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
-	public:
-	/**
-	 * @brief	The standard constructor of the class.
-	 *
-	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
-	 * 			the following variables are passed:
-	 *
-	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
-	 *
-	 * @param	getPst The object id of the completely initialized polling sequence.
-	 */
-	PollingTask( const char *name, rtems_task_priority setPriority, size_t setStackSize, uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
-
-	/**
-	 * @brief	The destructor of the class.
-	 *
-	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
-	 * 			the device handlers. This is done by calling the PST's destructor.
-	 */
-	virtual ~PollingTask( void );
-
-	ReturnValue_t startTask( void );
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-	 */
-	static void missedDeadlineCounter();
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
-
-	uint32_t getPeriodMs() const;
-
-	ReturnValue_t checkAndInitializeSequence() const;
-
-	ReturnValue_t sleepFor(uint32_t ms);
-protected:
-	/**
-	* @brief id of the associated OS period
-	*/
-	rtems_id periodId;
-
-	FixedSlotSequence pst;
-
-	/**
-	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
-	 *
-	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
-	 * 			Currently, only one function for missing any deadline is allowed.
-	 * 			If not used, it shall be declared NULL.
-	 */
-	void ( *deadlineMissedFunc )( void );
-	/**
-	 * @brief	This is the entry point in a new polling thread.
-	 *
-	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
-	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
-	 * 			on success. If operation of the task is ended for some reason,
-	 * 			the destructor is called to free allocated memory.
-	 */
-	static rtems_task taskEntryPoint( rtems_task_argument argument );
-
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 *
-	 *
-	 * @details	Holding the main functionality of the task, this method is most important.
-	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
-	 * 			to keep the timing of the periods.
-	 */
-	void taskFunctionality( void );
-};
-
-#endif /* POLLINGTASK_H_ */
+#ifndef POLLINGTASK_H_
+#define POLLINGTASK_H_
+
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "TaskBase.h"
+
+class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
+	public:
+	/**
+	 * @brief	The standard constructor of the class.
+	 *
+	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
+	 * 			the following variables are passed:
+	 *
+	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
+	 *
+	 * @param	getPst The object id of the completely initialized polling sequence.
+	 */
+	PollingTask( const char *name, rtems_task_priority setPriority, size_t setStackSize, uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
+
+	/**
+	 * @brief	The destructor of the class.
+	 *
+	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
+	 * 			the device handlers. This is done by calling the PST's destructor.
+	 */
+	virtual ~PollingTask( void );
+
+	ReturnValue_t startTask( void );
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+	 */
+	static void missedDeadlineCounter();
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+
+	uint32_t getPeriodMs() const;
+
+	ReturnValue_t checkAndInitializeSequence() const;
+
+	ReturnValue_t sleepFor(uint32_t ms);
+protected:
+	/**
+	* @brief id of the associated OS period
+	*/
+	rtems_id periodId;
+
+	FixedSlotSequence pst;
+
+	/**
+	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
+	 *
+	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
+	 * 			Currently, only one function for missing any deadline is allowed.
+	 * 			If not used, it shall be declared NULL.
+	 */
+	void ( *deadlineMissedFunc )( void );
+	/**
+	 * @brief	This is the entry point in a new polling thread.
+	 *
+	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
+	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
+	 * 			on success. If operation of the task is ended for some reason,
+	 * 			the destructor is called to free allocated memory.
+	 */
+	static rtems_task taskEntryPoint( rtems_task_argument argument );
+
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 *
+	 *
+	 * @details	Holding the main functionality of the task, this method is most important.
+	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
+	 * 			to keep the timing of the periods.
+	 */
+	void taskFunctionality( void );
+};
+
+#endif /* POLLINGTASK_H_ */
diff --git a/osal/rtems/QueueFactory.cpp b/osal/rtems/QueueFactory.cpp
index a492d4004..fce55a0e4 100644
--- a/osal/rtems/QueueFactory.cpp
+++ b/osal/rtems/QueueFactory.cpp
@@ -1,59 +1,59 @@
-#include "../../ipc/QueueFactory.h"
-#include "MessageQueue.h"
-#include "RtemsBasic.h"
-
-QueueFactory* QueueFactory::factoryInstance = NULL;
-
-
-ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
-	//TODO add ignoreFault functionality
-	message->setSender(sentFrom);
-	rtems_status_code result = rtems_message_queue_send(sendTo, message->getBuffer(),
-			message->messageSize);
-	switch(result){
-	case RTEMS_SUCCESSFUL:
-			//message sent successfully
-			return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_INVALID_ID:
-			//invalid queue id
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_SIZE:
-		// invalid message size
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		//buffer is NULL
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_UNSATISFIED:
-		//out of message buffers
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_TOO_MANY:
-		//queue's limit has been reached
-		return MessageQueueIF::FULL;
-
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == NULL) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+#include "MessageQueue.h"
+#include "RtemsBasic.h"
+
+QueueFactory* QueueFactory::factoryInstance = NULL;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
+	//TODO add ignoreFault functionality
+	message->setSender(sentFrom);
+	rtems_status_code result = rtems_message_queue_send(sendTo, message->getBuffer(),
+			message->messageSize);
+	switch(result){
+	case RTEMS_SUCCESSFUL:
+			//message sent successfully
+			return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_INVALID_ID:
+			//invalid queue id
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_SIZE:
+		// invalid message size
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		//buffer is NULL
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_UNSATISFIED:
+		//out of message buffers
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_TOO_MANY:
+		//queue's limit has been reached
+		return MessageQueueIF::FULL;
+
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == NULL) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/rtems/RtemsBasic.h b/osal/rtems/RtemsBasic.h
index b9aa33e88..78e0d46e7 100644
--- a/osal/rtems/RtemsBasic.h
+++ b/osal/rtems/RtemsBasic.h
@@ -1,25 +1,25 @@
-#ifndef OS_RTEMS_RTEMSBASIC_H_
-#define OS_RTEMS_RTEMSBASIC_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include <rtems.h>
-#include <rtems/libio.h>
-#include <rtems/error.h>
-#include <rtems/stackchk.h>
-#include <stddef.h>
-
-
-class RtemsBasic {
-public:
-	static rtems_interval convertMsToTicks(uint32_t msIn) {
-		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-		return (ticks_per_second * msIn) / 1000;
-	}
-
-	static rtems_interval convertTicksToMs(rtems_interval ticksIn) {
-		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-		return (ticksIn * 1000) / ticks_per_second;
-	}
-};
-
-#endif /* OS_RTEMS_RTEMSBASIC_H_ */
+#ifndef OS_RTEMS_RTEMSBASIC_H_
+#define OS_RTEMS_RTEMSBASIC_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <rtems.h>
+#include <rtems/libio.h>
+#include <rtems/error.h>
+#include <rtems/stackchk.h>
+#include <stddef.h>
+
+
+class RtemsBasic {
+public:
+	static rtems_interval convertMsToTicks(uint32_t msIn) {
+		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+		return (ticks_per_second * msIn) / 1000;
+	}
+
+	static rtems_interval convertTicksToMs(rtems_interval ticksIn) {
+		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+		return (ticksIn * 1000) / ticks_per_second;
+	}
+};
+
+#endif /* OS_RTEMS_RTEMSBASIC_H_ */
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index b95ab51f8..adf6ee707 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -1,82 +1,82 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "TaskBase.h"
-
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE=RTEMS_MINIMUM_STACK_SIZE;
-
-TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
-		const char *name) {
-	rtems_name osalName = 0;
-	for (uint8_t i = 0; i < 4; i++) {
-		if (name[i] == 0) {
-			break;
-		}
-		osalName += name[i] << (8 * (3 - i));
-	}
-	//The task is created with the operating system's system call.
-	rtems_status_code status = RTEMS_UNSATISFIED;
-	if (set_priority >= 0 && set_priority <= 99) {
-		 status = rtems_task_create(osalName,
-				(0xFF - 2 * set_priority), stack_size,
-				RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
-				RTEMS_FLOATING_POINT, &id);
-	}
-	ReturnValue_t result = convertReturnCode(status);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		error << "TaskBase::TaskBase: createTask with name " << std::hex
-				<< osalName << std::dec << " failed with return code "
-				<< (uint32_t) status << std::endl;
-		this->id = 0;
-	}
-}
-
-TaskBase::~TaskBase() {
-	rtems_task_delete(id);
-}
-
-rtems_id TaskBase::getId() {
-	return this->id;
-}
-
-ReturnValue_t TaskBase::sleepFor(uint32_t ms) {
-	rtems_status_code status = rtems_task_wake_after(RtemsBasic::convertMsToTicks(ms));
-	return convertReturnCode(status);
-}
-
-
-ReturnValue_t TaskBase::convertReturnCode(rtems_status_code inValue) {
-	switch (inValue) {
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_MP_NOT_CONFIGURED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_NAME:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_TOO_MANY:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_UNSATISFIED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_PRIORITY:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-}
-
-
-ReturnValue_t TaskBase::setAndStartPeriod(rtems_interval period, rtems_id *periodId) {
-	rtems_name periodName = (('P' << 24) + ('e' << 16) + ('r' << 8) + 'd');
-	rtems_status_code status = rtems_rate_monotonic_create(periodName, periodId);
-	if (status == RTEMS_SUCCESSFUL) {
-		status = restartPeriod(period,*periodId);
-	}
-	return convertReturnCode(status);
-}
-
-rtems_status_code TaskBase::restartPeriod(rtems_interval period, rtems_id periodId){
-	//This is necessary to avoid a call with period = 0, which does not start the period.
-	rtems_status_code status = rtems_rate_monotonic_period(periodId, period + 1);
-	return status;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "TaskBase.h"
+
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE=RTEMS_MINIMUM_STACK_SIZE;
+
+TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
+		const char *name) {
+	rtems_name osalName = 0;
+	for (uint8_t i = 0; i < 4; i++) {
+		if (name[i] == 0) {
+			break;
+		}
+		osalName += name[i] << (8 * (3 - i));
+	}
+	//The task is created with the operating system's system call.
+	rtems_status_code status = RTEMS_UNSATISFIED;
+	if (set_priority >= 0 && set_priority <= 99) {
+		 status = rtems_task_create(osalName,
+				(0xFF - 2 * set_priority), stack_size,
+				RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
+				RTEMS_FLOATING_POINT, &id);
+	}
+	ReturnValue_t result = convertReturnCode(status);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		error << "TaskBase::TaskBase: createTask with name " << std::hex
+				<< osalName << std::dec << " failed with return code "
+				<< (uint32_t) status << std::endl;
+		this->id = 0;
+	}
+}
+
+TaskBase::~TaskBase() {
+	rtems_task_delete(id);
+}
+
+rtems_id TaskBase::getId() {
+	return this->id;
+}
+
+ReturnValue_t TaskBase::sleepFor(uint32_t ms) {
+	rtems_status_code status = rtems_task_wake_after(RtemsBasic::convertMsToTicks(ms));
+	return convertReturnCode(status);
+}
+
+
+ReturnValue_t TaskBase::convertReturnCode(rtems_status_code inValue) {
+	switch (inValue) {
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_MP_NOT_CONFIGURED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_NAME:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_TOO_MANY:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_UNSATISFIED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_PRIORITY:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+}
+
+
+ReturnValue_t TaskBase::setAndStartPeriod(rtems_interval period, rtems_id *periodId) {
+	rtems_name periodName = (('P' << 24) + ('e' << 16) + ('r' << 8) + 'd');
+	rtems_status_code status = rtems_rate_monotonic_create(periodName, periodId);
+	if (status == RTEMS_SUCCESSFUL) {
+		status = restartPeriod(period,*periodId);
+	}
+	return convertReturnCode(status);
+}
+
+rtems_status_code TaskBase::restartPeriod(rtems_interval period, rtems_id periodId){
+	//This is necessary to avoid a call with period = 0, which does not start the period.
+	rtems_status_code status = rtems_rate_monotonic_period(periodId, period + 1);
+	return status;
+}
diff --git a/osal/rtems/TaskBase.h b/osal/rtems/TaskBase.h
index 3010a9728..410d9110e 100644
--- a/osal/rtems/TaskBase.h
+++ b/osal/rtems/TaskBase.h
@@ -1,47 +1,47 @@
-#ifndef TASKBASE_H_
-#define TASKBASE_H_
-
-#include "RtemsBasic.h"
-#include "../../tasks/PeriodicTaskIF.h"
-
-/**
- * @brief	This is the basic task handling class for rtems.
- *
- * @details Task creation base class for rtems.
- */
-class TaskBase {
-protected:
-	/**
-	 * @brief	The class stores the task id it got assigned from the operating system in this attribute.
-	 * 			If initialization fails, the id is set to zero.
-	 */
-	rtems_id id;
-public:
-	/**
-	 * @brief	The constructor creates and initializes a task.
-	 * @details	This is accomplished by using the operating system call to create a task. The name is
-	 * 			created automatically with the help od taskCounter. Priority and stack size are
-	 * 			adjustable, all other attributes are set with default values.
-	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
-	 * @param stack_size	The stack size reserved by the operating system for the task.
-	 * @param nam			The name of the Task, as a null-terminated String. Currently max 4 chars supported (excluding Null-terminator), rest will be truncated
-	 */
-	TaskBase( rtems_task_priority priority, size_t stack_size, const char  *name);
-	/**
-	 * @brief	In the destructor, the created task is deleted.
-	 */
-	virtual ~TaskBase();
-	/**
-	 * @brief	This method returns the task id of this class.
-	 */
-	rtems_id getId();
-
-	ReturnValue_t sleepFor(uint32_t ms);
-	static ReturnValue_t setAndStartPeriod(rtems_interval period, rtems_id *periodId);
-	static rtems_status_code restartPeriod(rtems_interval period, rtems_id periodId);
-private:
-	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
-};
-
-
-#endif /* TASKBASE_H_ */
+#ifndef TASKBASE_H_
+#define TASKBASE_H_
+
+#include "RtemsBasic.h"
+#include "../../tasks/PeriodicTaskIF.h"
+
+/**
+ * @brief	This is the basic task handling class for rtems.
+ *
+ * @details Task creation base class for rtems.
+ */
+class TaskBase {
+protected:
+	/**
+	 * @brief	The class stores the task id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the id is set to zero.
+	 */
+	rtems_id id;
+public:
+	/**
+	 * @brief	The constructor creates and initializes a task.
+	 * @details	This is accomplished by using the operating system call to create a task. The name is
+	 * 			created automatically with the help od taskCounter. Priority and stack size are
+	 * 			adjustable, all other attributes are set with default values.
+	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
+	 * @param stack_size	The stack size reserved by the operating system for the task.
+	 * @param nam			The name of the Task, as a null-terminated String. Currently max 4 chars supported (excluding Null-terminator), rest will be truncated
+	 */
+	TaskBase( rtems_task_priority priority, size_t stack_size, const char  *name);
+	/**
+	 * @brief	In the destructor, the created task is deleted.
+	 */
+	virtual ~TaskBase();
+	/**
+	 * @brief	This method returns the task id of this class.
+	 */
+	rtems_id getId();
+
+	ReturnValue_t sleepFor(uint32_t ms);
+	static ReturnValue_t setAndStartPeriod(rtems_interval period, rtems_id *periodId);
+	static rtems_status_code restartPeriod(rtems_interval period, rtems_id periodId);
+private:
+	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
+};
+
+
+#endif /* TASKBASE_H_ */
diff --git a/osal/rtems/TaskFactory.cpp b/osal/rtems/TaskFactory.cpp
index f79571f07..bab48a44e 100644
--- a/osal/rtems/TaskFactory.cpp
+++ b/osal/rtems/TaskFactory.cpp
@@ -1,41 +1,41 @@
-#include "../../tasks/TaskFactory.h"
-#include "MultiObjectTask.h"
-#include "PollingTask.h"
-#include "InitTask.h"
-#include "RtemsBasic.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
-
-	return static_cast<PeriodicTaskIF*>(new MultiObjectTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
-}
-
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
-	return static_cast<FixedTimeslotTaskIF*>(new PollingTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	//TODO not implemented
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
-	rtems_task_wake_after(RtemsBasic::convertMsToTicks(delayMs));
-	//Only return value is "RTEMS_SUCCESSFUL - always successful" so it has been neglected
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-TaskFactory::TaskFactory() {
-}
+#include "../../tasks/TaskFactory.h"
+#include "MultiObjectTask.h"
+#include "PollingTask.h"
+#include "InitTask.h"
+#include "RtemsBasic.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
+
+	return static_cast<PeriodicTaskIF*>(new MultiObjectTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
+	return static_cast<FixedTimeslotTaskIF*>(new PollingTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	//TODO not implemented
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
+	rtems_task_wake_after(RtemsBasic::convertMsToTicks(delayMs));
+	//Only return value is "RTEMS_SUCCESSFUL - always successful" so it has been neglected
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+TaskFactory::TaskFactory() {
+}
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 14446e3c1..0c6afc12b 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -1,67 +1,67 @@
-#ifndef HASPARAMETERSIF_H_
-#define HASPARAMETERSIF_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;
-	static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
-
-	static uint8_t getDomain(ParameterId_t id) {
-		return id >> 24;
-	}
-
-	static uint16_t getMatrixId(ParameterId_t id) {
-		return id >> 8;
-	}
-
-	static uint8_t getIndex(ParameterId_t id) {
-		return id;
-	}
-
-	static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
-			uint8_t index) {
-		return (domainId << 24) + (parameterId << 8) + index;
-	}
-
-	virtual ~HasParametersIF() {}
-
-	/**
-	 * Always set parameter before checking newValues!
-	 *
-	 * @param domainId
-	 * @param parameterId
-	 * @param parameterWrapper
-	 * @param newValues
-	 * @param startAtIndex
-	 * @return
-	 */
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
-};
-
-#endif /* HASPARAMETERSIF_H_ */
+#ifndef HASPARAMETERSIF_H_
+#define HASPARAMETERSIF_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;
+	static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
+
+	static uint8_t getDomain(ParameterId_t id) {
+		return id >> 24;
+	}
+
+	static uint16_t getMatrixId(ParameterId_t id) {
+		return id >> 8;
+	}
+
+	static uint8_t getIndex(ParameterId_t id) {
+		return id;
+	}
+
+	static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
+			uint8_t index) {
+		return (domainId << 24) + (parameterId << 8) + index;
+	}
+
+	virtual ~HasParametersIF() {}
+
+	/**
+	 * Always set parameter before checking newValues!
+	 *
+	 * @param domainId
+	 * @param parameterId
+	 * @param parameterWrapper
+	 * @param newValues
+	 * @param startAtIndex
+	 * @return
+	 */
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
+};
+
+#endif /* HASPARAMETERSIF_H_ */
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 55633566f..ec7ded3c7 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -1,132 +1,132 @@
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../parameters/ParameterHelper.h"
-#include "../parameters/ParameterMessage.h"
-
-ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-		owner(owner) {}
-
-ParameterHelper::~ParameterHelper() {
-}
-
-ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch (message->getCommand()) {
-	case ParameterMessage::CMD_PARAMETER_DUMP: {
-		ParameterWrapper description;
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(message));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(message));
-		result = owner->getParameter(domain, parameterId,
-				&description, &description, 0);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &description);
-		}
-	}
-		break;
-	case ParameterMessage::CMD_PARAMETER_LOAD: {
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(message));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(message));
-		uint8_t index = HasParametersIF::getIndex(
-				ParameterMessage::getParameterId(message));
-
-		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;
-		}
-
-		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(storedStream, storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
-		}
-
-		ParameterWrapper ownerWrapper;
-		result = owner->getParameter(domain, parameterId, &ownerWrapper,
-				&streamWrapper, index);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
-		}
-
-		result = ownerWrapper.copyFrom(&streamWrapper, index);
-
-		storage->deleteData(ParameterMessage::getStoreId(message));
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &ownerWrapper);
-		}
-	}
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		rejectCommand(message->getSender(), result, message->getCommand());
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
-		const ParameterWrapper* description) {
-	size_t serializedSize = description->getSerializedSize();
-
-	uint8_t *storeElement;
-	store_address_t address;
-
-	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
-			&storeElement);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	size_t storeElementSize = 0;
-
-	result = description->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		storage->deleteData(address);
-		return result;
-	}
-
-	CommandMessage reply;
-
-	ParameterMessage::setParameterDumpReply(&reply, id, address);
-
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ParameterHelper::initialize() {
-	ownerQueueId = owner->getCommandQueue();
-
-
-	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (storage == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	} else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
-
-void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-		Command_t initialCommand) {
-	CommandMessage reply;
-	reply.setReplyRejected(reason, initialCommand);
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../parameters/ParameterHelper.h"
+#include "../parameters/ParameterMessage.h"
+
+ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
+		owner(owner) {}
+
+ParameterHelper::~ParameterHelper() {
+}
+
+ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	switch (message->getCommand()) {
+	case ParameterMessage::CMD_PARAMETER_DUMP: {
+		ParameterWrapper description;
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(message));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(message));
+		result = owner->getParameter(domain, parameterId,
+				&description, &description, 0);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(message->getSender(),
+					ParameterMessage::getParameterId(message), &description);
+		}
+	}
+		break;
+	case ParameterMessage::CMD_PARAMETER_LOAD: {
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(message));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(message));
+		uint8_t index = HasParametersIF::getIndex(
+				ParameterMessage::getParameterId(message));
+
+		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;
+		}
+
+		ParameterWrapper streamWrapper;
+		result = streamWrapper.set(storedStream, storedStreamSize);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(message));
+			break;
+		}
+
+		ParameterWrapper ownerWrapper;
+		result = owner->getParameter(domain, parameterId, &ownerWrapper,
+				&streamWrapper, index);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(message));
+			break;
+		}
+
+		result = ownerWrapper.copyFrom(&streamWrapper, index);
+
+		storage->deleteData(ParameterMessage::getStoreId(message));
+
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(message->getSender(),
+					ParameterMessage::getParameterId(message), &ownerWrapper);
+		}
+	}
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		rejectCommand(message->getSender(), result, message->getCommand());
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
+		const ParameterWrapper* description) {
+	size_t serializedSize = description->getSerializedSize();
+
+	uint8_t *storeElement;
+	store_address_t address;
+
+	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
+			&storeElement);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	size_t storeElementSize = 0;
+
+	result = description->serialize(&storeElement, &storeElementSize,
+			serializedSize, SerializeIF::Endianness::BIG);
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		storage->deleteData(address);
+		return result;
+	}
+
+	CommandMessage reply;
+
+	ParameterMessage::setParameterDumpReply(&reply, id, address);
+
+	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterHelper::initialize() {
+	ownerQueueId = owner->getCommandQueue();
+
+
+	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (storage == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	} else {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
+void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+		Command_t initialCommand) {
+	CommandMessage reply;
+	reply.setReplyRejected(reason, initialCommand);
+	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+}
diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index 668bb081c..5dd78b641 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -1,36 +1,36 @@
-#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
-#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
-
-#include "../ipc/MessageQueueIF.h"
-#include "../parameters/ParameterMessage.h"
-#include "../parameters/ReceivesParameterMessagesIF.h"
-
-/**
- * @brief	Helper class to handle parameter messages
- * @details
- * This class simplfiies handling of parameter messages, which are sent
- * to a class which implements ReceivesParameterMessagesIF.
- */
-class ParameterHelper {
-public:
-	ParameterHelper(ReceivesParameterMessagesIF *owner);
-	virtual ~ParameterHelper();
-
-	ReturnValue_t handleParameterMessage(CommandMessage *message);
-
-	ReturnValue_t initialize();
-private:
-	ReceivesParameterMessagesIF *owner;
-
-	MessageQueueId_t ownerQueueId = MessageQueueIF::NO_QUEUE;
-
-	StorageManagerIF *storage = nullptr;
-
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
-			const ParameterWrapper *description);
-
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-			Command_t initialCommand);
-};
-
-#endif /* PARAMETERHELPER_H_ */
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
+#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
+
+#include "../ipc/MessageQueueIF.h"
+#include "../parameters/ParameterMessage.h"
+#include "../parameters/ReceivesParameterMessagesIF.h"
+
+/**
+ * @brief	Helper class to handle parameter messages
+ * @details
+ * This class simplfiies handling of parameter messages, which are sent
+ * to a class which implements ReceivesParameterMessagesIF.
+ */
+class ParameterHelper {
+public:
+	ParameterHelper(ReceivesParameterMessagesIF *owner);
+	virtual ~ParameterHelper();
+
+	ReturnValue_t handleParameterMessage(CommandMessage *message);
+
+	ReturnValue_t initialize();
+private:
+	ReceivesParameterMessagesIF *owner;
+
+	MessageQueueId_t ownerQueueId = MessageQueueIF::NO_QUEUE;
+
+	StorageManagerIF *storage = nullptr;
+
+	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
+			const ParameterWrapper *description);
+
+	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+			Command_t initialCommand);
+};
+
+#endif /* PARAMETERHELPER_H_ */
diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp
index 0cc4dd90a..e9f3191fc 100644
--- a/parameters/ParameterMessage.cpp
+++ b/parameters/ParameterMessage.cpp
@@ -1,48 +1,48 @@
-#include "../parameters/ParameterMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-store_address_t ParameterMessage::getStoreId(const CommandMessage* message) {
-	store_address_t address;
-	address.raw = message->getParameter2();
-	return address;
-}
-
-void ParameterMessage::setParameterDumpCommand(CommandMessage* message,
-		ParameterId_t id) {
-	message->setCommand(CMD_PARAMETER_DUMP);
-	message->setParameter(id);
-}
-
-void ParameterMessage::setParameterDumpReply(CommandMessage* message,
-		ParameterId_t id, store_address_t storageID) {
-	message->setCommand(REPLY_PARAMETER_DUMP);
-	message->setParameter(id);
-	message->setParameter2(storageID.raw);
-}
-
-void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
-		ParameterId_t id, store_address_t storageID) {
-	message->setCommand(CMD_PARAMETER_LOAD);
-	message->setParameter(id);
-	message->setParameter2(storageID.raw);
-}
-
-void ParameterMessage::clear(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case CMD_PARAMETER_LOAD:
-	case REPLY_PARAMETER_DUMP: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-}
+#include "../parameters/ParameterMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+store_address_t ParameterMessage::getStoreId(const CommandMessage* message) {
+	store_address_t address;
+	address.raw = message->getParameter2();
+	return address;
+}
+
+void ParameterMessage::setParameterDumpCommand(CommandMessage* message,
+		ParameterId_t id) {
+	message->setCommand(CMD_PARAMETER_DUMP);
+	message->setParameter(id);
+}
+
+void ParameterMessage::setParameterDumpReply(CommandMessage* message,
+		ParameterId_t id, store_address_t storageID) {
+	message->setCommand(REPLY_PARAMETER_DUMP);
+	message->setParameter(id);
+	message->setParameter2(storageID.raw);
+}
+
+void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
+		ParameterId_t id, store_address_t storageID) {
+	message->setCommand(CMD_PARAMETER_LOAD);
+	message->setParameter(id);
+	message->setParameter2(storageID.raw);
+}
+
+void ParameterMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_PARAMETER_LOAD:
+	case REPLY_PARAMETER_DUMP: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(message));
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 51321f2b7..de68dcfcd 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -1,29 +1,29 @@
-#ifndef PARAMETERMESSAGE_H_
-#define PARAMETERMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../parameters/HasParametersIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-
-class ParameterMessage {
-private:
-	ParameterMessage();
-public:
-	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 );
-
-	static ParameterId_t getParameterId(const CommandMessage* message);
-	static store_address_t getStoreId(const CommandMessage* message);
-	static void setParameterDumpCommand(CommandMessage* message,
-			ParameterId_t id);
-	static void setParameterDumpReply(CommandMessage* message,
-			ParameterId_t id,  store_address_t storageID);
-	static void setParameterLoadCommand(CommandMessage* message,
-			ParameterId_t id, store_address_t storageID);
-	static void clear(CommandMessage* message);
-
-};
-
-#endif /* PARAMETERMESSAGE_H_ */
+#ifndef PARAMETERMESSAGE_H_
+#define PARAMETERMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../parameters/HasParametersIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+class ParameterMessage {
+private:
+	ParameterMessage();
+public:
+	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 );
+
+	static ParameterId_t getParameterId(const CommandMessage* message);
+	static store_address_t getStoreId(const CommandMessage* message);
+	static void setParameterDumpCommand(CommandMessage* message,
+			ParameterId_t id);
+	static void setParameterDumpReply(CommandMessage* message,
+			ParameterId_t id,  store_address_t storageID);
+	static void setParameterLoadCommand(CommandMessage* message,
+			ParameterId_t id, store_address_t storageID);
+	static void clear(CommandMessage* message);
+
+};
+
+#endif /* PARAMETERMESSAGE_H_ */
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 8e6dd86c0..fd36a0a92 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -1,280 +1,280 @@
-#include "../parameters/ParameterWrapper.h"
-
-ParameterWrapper::ParameterWrapper() :
-		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) {
-}
-
-ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-		const void *data) :
-		pointsToStream(false), type(type), rows(rows), columns(columns),
-		data(nullptr), readonlyData(data) {
-}
-
-ParameterWrapper::~ParameterWrapper() {
-}
-
-ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result;
-
-	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	//serialize uses readonlyData, as it is always valid
-	if (readonlyData == NULL) {
-		return NOT_SET;
-	}
-	switch (type) {
-	case Type::UINT8_T:
-		result = serializeData<uint8_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::INT8_T:
-		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
-		break;
-	case Type::UINT16_T:
-		result = serializeData<uint16_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::INT16_T:
-		result = serializeData<int16_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::UINT32_T:
-		result = serializeData<uint32_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::INT32_T:
-		result = serializeData<int32_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::FLOAT:
-		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
-		break;
-	case Type::DOUBLE:
-		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
-		break;
-	default:
-		result = UNKNOW_DATATYPE;
-		break;
-	}
-	return result;
-}
-
-size_t ParameterWrapper::getSerializedSize() const {
-	uint32_t serializedSize = 0;
-	serializedSize += type.getSerializedSize();
-	serializedSize += sizeof(rows);
-	serializedSize += sizeof(columns);
-	serializedSize += rows * columns * type.getSize();
-
-	return serializedSize;
-}
-
-template<typename T>
-ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
-		size_t maxSize, Endianness streamEndianness) const {
-	const T *element = (const T*) readonlyData;
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	uint16_t dataSize = columns * rows;
-	while (dataSize != 0) {
-		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		element++;
-		dataSize--;
-	}
-	return result;
-}
-
-template<typename T>
-ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
-		uint8_t startingColumn, const void *from, uint8_t fromRows,
-		uint8_t fromColumns) {
-
-	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t*) from;
-	size_t streamSize = fromRows * fromColumns * sizeof(T);
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-
-	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
-
-		//get the start element of this row in data
-		T *dataWithDataType = ((T*) data)
-				+ (((startingRow + fromRow) * columns) + startingColumn);
-
-		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
-			result = SerializeAdapter::deSerialize(
-					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
-					SerializeIF::Endianness::BIG);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-	}
-
-	return result;
-
-}
-
-
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
-		size_t *size, Endianness streamEndianness) {
-	return deSerialize(buffer, size, streamEndianness, 0);
-}
-
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
-		size_t *size, Endianness streamEndianness,
-		uint16_t startWritingAtIndex) {
-	ParameterWrapper streamDescription;
-
-	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	return copyFrom(&streamDescription, startWritingAtIndex);
-}
-
-ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
-		const uint8_t **remainingStream, size_t *remainingSize) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
-			&streamSize, SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	size_t dataSize = type.getSize() * rows * columns;
-
-	if (streamSize < dataSize) {
-		return SerializeIF::STREAM_TOO_SHORT;
-	}
-
-	data = nullptr;
-	readonlyData = stream;
-	pointsToStream = true;
-
-	stream += dataSize;
-	if (remainingStream !=  nullptr) {
-		*remainingStream = stream;
-	}
-	streamSize -= dataSize;
-	if (remainingSize != nullptr) {
-		*remainingSize = streamSize;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
-		uint16_t startWritingAtIndex) {
-	if (data == NULL) {
-		return READONLY;
-	}
-
-	if (from->readonlyData == NULL) {
-		return SOURCE_NOT_SET;
-	}
-
-	if (type != from->type) {
-		return DATATYPE_MISSMATCH;
-	}
-
-	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
-
-	if ((from->rows > (rows - startingRow))
-			|| (from->columns > (columns - startingColumn))) {
-		return TOO_BIG;
-	}
-
-	uint8_t typeSize = type.getSize();
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	//copy data
-	if (from->pointsToStream) {
-		switch (type) {
-		case Type::UINT8_T:
-			result = deSerializeData<uint8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::INT8_T:
-			result = deSerializeData<int8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::UINT16_T:
-			result = deSerializeData<uint16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::INT16_T:
-			result = deSerializeData<int16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::UINT32_T:
-			result = deSerializeData<uint32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::INT32_T:
-			result = deSerializeData<int32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::FLOAT:
-			result = deSerializeData<float>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::DOUBLE:
-			result = deSerializeData<double>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		default:
-			result = UNKNOW_DATATYPE;
-			break;
-		}
-	}
-	else {
-		//need a type to do arithmetic
-		uint8_t* typedData = static_cast<uint8_t*>(data);
-		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
-			uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
-			std::memcpy(typedData +  offset, from->readonlyData,
-					typeSize * from->columns);
-		}
-	}
-
-	return result;
-}
+#include "../parameters/ParameterWrapper.h"
+
+ParameterWrapper::ParameterWrapper() :
+		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) {
+}
+
+ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+		const void *data) :
+		pointsToStream(false), type(type), rows(rows), columns(columns),
+		data(nullptr), readonlyData(data) {
+}
+
+ParameterWrapper::~ParameterWrapper() {
+}
+
+ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result;
+
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	//serialize uses readonlyData, as it is always valid
+	if (readonlyData == NULL) {
+		return NOT_SET;
+	}
+	switch (type) {
+	case Type::UINT8_T:
+		result = serializeData<uint8_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT8_T:
+		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
+		break;
+	case Type::UINT16_T:
+		result = serializeData<uint16_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT16_T:
+		result = serializeData<int16_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::UINT32_T:
+		result = serializeData<uint32_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT32_T:
+		result = serializeData<int32_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::FLOAT:
+		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
+		break;
+	case Type::DOUBLE:
+		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
+		break;
+	default:
+		result = UNKNOW_DATATYPE;
+		break;
+	}
+	return result;
+}
+
+size_t ParameterWrapper::getSerializedSize() const {
+	uint32_t serializedSize = 0;
+	serializedSize += type.getSerializedSize();
+	serializedSize += sizeof(rows);
+	serializedSize += sizeof(columns);
+	serializedSize += rows * columns * type.getSize();
+
+	return serializedSize;
+}
+
+template<typename T>
+ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
+	const T *element = (const T*) readonlyData;
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	uint16_t dataSize = columns * rows;
+	while (dataSize != 0) {
+		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		element++;
+		dataSize--;
+	}
+	return result;
+}
+
+template<typename T>
+ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
+		uint8_t startingColumn, const void *from, uint8_t fromRows,
+		uint8_t fromColumns) {
+
+	//treat from as a continuous Stream as we copy all of it
+	const uint8_t *fromAsStream = (const uint8_t*) from;
+	size_t streamSize = fromRows * fromColumns * sizeof(T);
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+
+	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
+
+		//get the start element of this row in data
+		T *dataWithDataType = ((T*) data)
+				+ (((startingRow + fromRow) * columns) + startingColumn);
+
+		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
+			result = SerializeAdapter::deSerialize(
+					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
+					SerializeIF::Endianness::BIG);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+	}
+
+	return result;
+
+}
+
+
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness) {
+	return deSerialize(buffer, size, streamEndianness, 0);
+}
+
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness,
+		uint16_t startWritingAtIndex) {
+	ParameterWrapper streamDescription;
+
+	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return copyFrom(&streamDescription, startWritingAtIndex);
+}
+
+ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
+		const uint8_t **remainingStream, size_t *remainingSize) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
+			&streamSize, SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	size_t dataSize = type.getSize() * rows * columns;
+
+	if (streamSize < dataSize) {
+		return SerializeIF::STREAM_TOO_SHORT;
+	}
+
+	data = nullptr;
+	readonlyData = stream;
+	pointsToStream = true;
+
+	stream += dataSize;
+	if (remainingStream !=  nullptr) {
+		*remainingStream = stream;
+	}
+	streamSize -= dataSize;
+	if (remainingSize != nullptr) {
+		*remainingSize = streamSize;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
+		uint16_t startWritingAtIndex) {
+	if (data == NULL) {
+		return READONLY;
+	}
+
+	if (from->readonlyData == NULL) {
+		return SOURCE_NOT_SET;
+	}
+
+	if (type != from->type) {
+		return DATATYPE_MISSMATCH;
+	}
+
+	//check if from fits into this
+	uint8_t startingRow = startWritingAtIndex / columns;
+	uint8_t startingColumn = startWritingAtIndex % columns;
+
+	if ((from->rows > (rows - startingRow))
+			|| (from->columns > (columns - startingColumn))) {
+		return TOO_BIG;
+	}
+
+	uint8_t typeSize = type.getSize();
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	//copy data
+	if (from->pointsToStream) {
+		switch (type) {
+		case Type::UINT8_T:
+			result = deSerializeData<uint8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT8_T:
+			result = deSerializeData<int8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::UINT16_T:
+			result = deSerializeData<uint16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT16_T:
+			result = deSerializeData<int16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::UINT32_T:
+			result = deSerializeData<uint32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT32_T:
+			result = deSerializeData<int32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::FLOAT:
+			result = deSerializeData<float>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::DOUBLE:
+			result = deSerializeData<double>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		default:
+			result = UNKNOW_DATATYPE;
+			break;
+		}
+	}
+	else {
+		//need a type to do arithmetic
+		uint8_t* typedData = static_cast<uint8_t*>(data);
+		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
+			uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
+			std::memcpy(typedData +  offset, from->readonlyData,
+					typeSize * from->columns);
+		}
+	}
+
+	return result;
+}
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 1f38f6915..350459594 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -1,162 +1,162 @@
-#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
-#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serialize/SerializeIF.h"
-#include <stddef.h>
-#include "../globalfunctions/Type.h"
-
-/**
- * @brief
- * @details
- */
-class ParameterWrapper: public SerializeIF {
-	friend class DataPoolParameterWrapper;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::PARAMETER_WRAPPER;
-	static const ReturnValue_t UNKNOW_DATATYPE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
-	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
-
-	ParameterWrapper();
-	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
-	ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-			const void *data);
-	virtual ~ParameterWrapper();
-
-	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;
-
-	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;
-
-	template<typename T>
-	void set(T *data, uint8_t rows, uint8_t columns) {
-		this->data = data;
-		this->readonlyData = data;
-		this->type = PodTypeConversion<T>::type;
-		this->rows = rows;
-		this->columns = columns;
-		this->pointsToStream = false;
-	}
-
-	template<typename T>
-	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
-		this->data = NULL;
-		this->readonlyData = readonlyData;
-		this->type = PodTypeConversion<T>::type;
-		this->rows = rows;
-		this->columns = columns;
-		this->pointsToStream = false;
-	}
-
-	template<typename T>
-	void set(T& member) {
-		this->set(&member, 1, 1);
-	}
-
-	template<typename T>
-	void set(const T& readonlyMember) {
-		this->set(&readonlyMember, 1, 1);
-	}
-
-	template<typename T>
-	void setVector(T& member) {
-		this->set(member, sizeof(member)/sizeof(member[0]), 1);
-	}
-
-	template<typename T>
-	void setVector(const T& member) {
-		this->set(member, 1, sizeof(member)/sizeof(member[0]));
-	}
-	template<typename T>
-	void setMatrix(T& member) {
-		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
-	}
-
-	template<typename T>
-	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 = nullptr,
-			size_t *remainingSize = nullptr);
-
-	ReturnValue_t copyFrom(const ParameterWrapper *from,
-			uint16_t startWritingAtIndex);
-
-private:
-	bool pointsToStream = false;
-
-	Type type;
-	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,
-			size_t maxSize, Endianness streamEndianness) const;
-
-	template<typename T>
-	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
-			const void *from, uint8_t fromRows, uint8_t fromColumns);
-};
-
-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 /* PARAMETERWRAPPER_H_ */
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
+#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeIF.h"
+#include <stddef.h>
+#include "../globalfunctions/Type.h"
+
+/**
+ * @brief
+ * @details
+ */
+class ParameterWrapper: public SerializeIF {
+	friend class DataPoolParameterWrapper;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::PARAMETER_WRAPPER;
+	static const ReturnValue_t UNKNOW_DATATYPE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
+	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
+
+	ParameterWrapper();
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+			const void *data);
+	virtual ~ParameterWrapper();
+
+	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;
+
+	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;
+
+	template<typename T>
+	void set(T *data, uint8_t rows, uint8_t columns) {
+		this->data = data;
+		this->readonlyData = data;
+		this->type = PodTypeConversion<T>::type;
+		this->rows = rows;
+		this->columns = columns;
+		this->pointsToStream = false;
+	}
+
+	template<typename T>
+	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
+		this->data = NULL;
+		this->readonlyData = readonlyData;
+		this->type = PodTypeConversion<T>::type;
+		this->rows = rows;
+		this->columns = columns;
+		this->pointsToStream = false;
+	}
+
+	template<typename T>
+	void set(T& member) {
+		this->set(&member, 1, 1);
+	}
+
+	template<typename T>
+	void set(const T& readonlyMember) {
+		this->set(&readonlyMember, 1, 1);
+	}
+
+	template<typename T>
+	void setVector(T& member) {
+		this->set(member, sizeof(member)/sizeof(member[0]), 1);
+	}
+
+	template<typename T>
+	void setVector(const T& member) {
+		this->set(member, 1, sizeof(member)/sizeof(member[0]));
+	}
+	template<typename T>
+	void setMatrix(T& member) {
+		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+	}
+
+	template<typename T>
+	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 = nullptr,
+			size_t *remainingSize = nullptr);
+
+	ReturnValue_t copyFrom(const ParameterWrapper *from,
+			uint16_t startWritingAtIndex);
+
+private:
+	bool pointsToStream = false;
+
+	Type type;
+	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,
+			size_t maxSize, Endianness streamEndianness) const;
+
+	template<typename T>
+	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
+			const void *from, uint8_t fromRows, uint8_t fromColumns);
+};
+
+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 /* PARAMETERWRAPPER_H_ */
diff --git a/parameters/ReceivesParameterMessagesIF.h b/parameters/ReceivesParameterMessagesIF.h
index 9a280b4f1..f8c3746e5 100644
--- a/parameters/ReceivesParameterMessagesIF.h
+++ b/parameters/ReceivesParameterMessagesIF.h
@@ -1,19 +1,19 @@
-#ifndef RECEIVESPARAMETERMESSAGESIF_H_
-#define RECEIVESPARAMETERMESSAGESIF_H_
-
-
-#include "../parameters/HasParametersIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-class ReceivesParameterMessagesIF : public HasParametersIF {
-public:
-
-	static const uint8_t DOMAIN_ID_BASE = 0;
-	virtual ~ReceivesParameterMessagesIF() {
-	}
-
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-};
-
-
-#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
+#ifndef RECEIVESPARAMETERMESSAGESIF_H_
+#define RECEIVESPARAMETERMESSAGESIF_H_
+
+
+#include "../parameters/HasParametersIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class ReceivesParameterMessagesIF : public HasParametersIF {
+public:
+
+	static const uint8_t DOMAIN_ID_BASE = 0;
+	virtual ~ReceivesParameterMessagesIF() {
+	}
+
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+};
+
+
+#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 59d60491c..3ea0b18cc 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -1,260 +1,260 @@
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringMessageContent.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../power/Fuse.h"
-#include "../serialize/SerialFixedArrayListAdapter.h"
-#include "../ipc/QueueFactory.h"
-
-object_id_t Fuse::powerSwitchId = 0;
-
-Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
-		float maxCurrent, uint16_t confirmationCount) :
-		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
-		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
-				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
-				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
-				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
-				ids.pidCurrent, &set), state(ids.pidState, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
-				NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Fuse::~Fuse() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-void Fuse::addDevice(PowerComponentIF* switchSet) {
-	devices.push_back(switchSet);
-}
-
-ReturnValue_t Fuse::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = parameterHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = healthHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	powerIF = objectManager->get<PowerSwitchIF>(powerSwitchId);
-	if (powerIF == NULL) {
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void Fuse::calculatePowerLimits(float* low, float* high) {
-	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
-			iter++) {
-		if (areSwitchesOfComponentOn(iter)) {
-			*low += (*iter)->getMin();
-			*high += (*iter)->getMax();
-		}
-	}
-}
-
-ReturnValue_t Fuse::check() {
-	set.read();
-	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
-		setAllMonitorsToUnchecked();
-		set.commit(PoolVariableIF::INVALID);
-		return RETURN_OK;
-	}
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	checkFuseState();
-	calculateFusePower();
-	//Check if power is valid and if fuse state is off or invalid.
-	if (!power.isValid() || (state == 0) || !state.isValid()) {
-		result = powerMonitor.setToInvalid();
-	} else {
-		float lowLimit = 0.0;
-		float highLimit = RESIDUAL_POWER;
-		calculatePowerLimits(&lowLimit, &highLimit);
-		result = powerMonitor.checkPower(power, lowLimit, highLimit);
-		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
-			reportEvents(POWER_BELOW_LOW_LIMIT);
-		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
-			reportEvents(POWER_ABOVE_HIGH_LIMIT);
-		}
-	}
-	set.commit();
-	return result;
-}
-
-ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = RETURN_FAILED;
-	for (DeviceList::const_iterator iter = devices.begin();
-			iter != devices.end(); iter++) {
-		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return RETURN_OK;
-}
-
-size_t Fuse::getSerializedSize() const {
-	uint32_t size = 0;
-	for (DeviceList::const_iterator iter = devices.begin();
-			iter != devices.end(); iter++) {
-		size += (*iter)->getSerializedSize();
-	}
-	return size;
-}
-
-ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
-        Endianness streamEndianness) {
-	ReturnValue_t result = RETURN_FAILED;
-	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
-			iter++) {
-		result = (*iter)->deSerialize(buffer, size, streamEndianness);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return RETURN_OK;
-}
-
-uint8_t Fuse::getFuseId() const {
-	return fuseId;
-}
-
-void Fuse::calculateFusePower() {
-	ReturnValue_t result1 = currentLimit.check();
-	if (result1 != HasReturnvaluesIF::RETURN_OK || !(voltage.isValid())) {
-		power.setValid(PoolVariableIF::INVALID);
-		return;
-	}
-	//Calculate fuse power.
-	power = current * voltage;
-	power.setValid(PoolVariableIF::VALID);
-}
-
-ReturnValue_t Fuse::performOperation(uint8_t opCode) {
-	checkCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Fuse::reportEvents(Event event) {
-	if (!powerMonitor.isEventEnabled()) {
-		return;
-	}
-	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
-			iter++) {
-		if (areSwitchesOfComponentOn(iter)) {
-			EventManagerIF::triggerEvent((*iter)->getDeviceObjectId(), event);
-		}
-	}
-}
-
-MessageQueueId_t Fuse::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void Fuse::setAllMonitorsToUnchecked() {
-	currentLimit.setToUnchecked();
-	powerMonitor.setToUnchecked();
-}
-
-void Fuse::checkCommandQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = healthHelper.handleHealthCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = parameterHelper.handleParameterMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	command.setToUnknownCommand();
-	commandQueue->reply(&command);
-}
-
-void Fuse::checkFuseState() {
-	if (!state.isValid()) {
-		oldFuseState = 0;
-		return;
-	}
-	if (state == 0) {
-		if (oldFuseState != 0) {
-			reportEvents(FUSE_WENT_OFF);
-		}
-	}
-	oldFuseState = state;
-}
-
-float Fuse::getPower() {
-	if (power.isValid()) {
-		return power;
-	} else {
-		return 0.0;
-	}
-}
-
-void Fuse::setDataPoolEntriesInvalid() {
-	set.read();
-	set.commit(PoolVariableIF::INVALID);
-}
-
-ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = powerMonitor.getParameter(domainId, parameterId, parameterWrapper,
-			newValues, startAtIndex);
-	return result;
-}
-
-bool Fuse::areSwitchesOfComponentOn(DeviceList::iterator iter) {
-	if (powerIF->getSwitchState((*iter)->getSwitchId1())
-			!= PowerSwitchIF::SWITCH_ON) {
-		return false;
-	}
-	if ((*iter)->hasTwoSwitches()) {
-		if ((powerIF->getSwitchState((*iter)->getSwitchId2())
-				!= PowerSwitchIF::SWITCH_ON)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool Fuse::isPowerValid() {
-	return power.isValid();
-}
-
-ReturnValue_t Fuse::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return RETURN_OK;
-}
-
-HasHealthIF::HealthState Fuse::getHealth() {
-	return healthHelper.getHealth();
-}
-
-ReturnValue_t Fuse::PowerMonitor::checkPower(float sample, float lowerLimit,
-		float upperLimit) {
-	if (sample > upperLimit) {
-		return this->monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
-				upperLimit);
-	} else if (sample < lowerLimit) {
-		return this->monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
-				lowerLimit);
-	} else {
-		return this->monitorStateIs(RETURN_OK, sample, 0.0); //Within limits.
-	}
-}
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../power/Fuse.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../ipc/QueueFactory.h"
+
+object_id_t Fuse::powerSwitchId = 0;
+
+Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
+		float maxCurrent, uint16_t confirmationCount) :
+		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
+		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
+				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
+				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
+				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
+				ids.pidCurrent, &set), state(ids.pidState, &set), power(
+				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
+				NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
+	commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Fuse::~Fuse() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+void Fuse::addDevice(PowerComponentIF* switchSet) {
+	devices.push_back(switchSet);
+}
+
+ReturnValue_t Fuse::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	powerIF = objectManager->get<PowerSwitchIF>(powerSwitchId);
+	if (powerIF == NULL) {
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void Fuse::calculatePowerLimits(float* low, float* high) {
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		if (areSwitchesOfComponentOn(iter)) {
+			*low += (*iter)->getMin();
+			*high += (*iter)->getMax();
+		}
+	}
+}
+
+ReturnValue_t Fuse::check() {
+	set.read();
+	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
+		setAllMonitorsToUnchecked();
+		set.commit(PoolVariableIF::INVALID);
+		return RETURN_OK;
+	}
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	checkFuseState();
+	calculateFusePower();
+	//Check if power is valid and if fuse state is off or invalid.
+	if (!power.isValid() || (state == 0) || !state.isValid()) {
+		result = powerMonitor.setToInvalid();
+	} else {
+		float lowLimit = 0.0;
+		float highLimit = RESIDUAL_POWER;
+		calculatePowerLimits(&lowLimit, &highLimit);
+		result = powerMonitor.checkPower(power, lowLimit, highLimit);
+		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
+			reportEvents(POWER_BELOW_LOW_LIMIT);
+		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
+			reportEvents(POWER_ABOVE_HIGH_LIMIT);
+		}
+	}
+	set.commit();
+	return result;
+}
+
+ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = RETURN_FAILED;
+	for (DeviceList::const_iterator iter = devices.begin();
+			iter != devices.end(); iter++) {
+		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return RETURN_OK;
+}
+
+size_t Fuse::getSerializedSize() const {
+	uint32_t size = 0;
+	for (DeviceList::const_iterator iter = devices.begin();
+			iter != devices.end(); iter++) {
+		size += (*iter)->getSerializedSize();
+	}
+	return size;
+}
+
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
+        Endianness streamEndianness) {
+	ReturnValue_t result = RETURN_FAILED;
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		result = (*iter)->deSerialize(buffer, size, streamEndianness);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return RETURN_OK;
+}
+
+uint8_t Fuse::getFuseId() const {
+	return fuseId;
+}
+
+void Fuse::calculateFusePower() {
+	ReturnValue_t result1 = currentLimit.check();
+	if (result1 != HasReturnvaluesIF::RETURN_OK || !(voltage.isValid())) {
+		power.setValid(PoolVariableIF::INVALID);
+		return;
+	}
+	//Calculate fuse power.
+	power = current * voltage;
+	power.setValid(PoolVariableIF::VALID);
+}
+
+ReturnValue_t Fuse::performOperation(uint8_t opCode) {
+	checkCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Fuse::reportEvents(Event event) {
+	if (!powerMonitor.isEventEnabled()) {
+		return;
+	}
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		if (areSwitchesOfComponentOn(iter)) {
+			EventManagerIF::triggerEvent((*iter)->getDeviceObjectId(), event);
+		}
+	}
+}
+
+MessageQueueId_t Fuse::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void Fuse::setAllMonitorsToUnchecked() {
+	currentLimit.setToUnchecked();
+	powerMonitor.setToUnchecked();
+}
+
+void Fuse::checkCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = parameterHelper.handleParameterMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	command.setToUnknownCommand();
+	commandQueue->reply(&command);
+}
+
+void Fuse::checkFuseState() {
+	if (!state.isValid()) {
+		oldFuseState = 0;
+		return;
+	}
+	if (state == 0) {
+		if (oldFuseState != 0) {
+			reportEvents(FUSE_WENT_OFF);
+		}
+	}
+	oldFuseState = state;
+}
+
+float Fuse::getPower() {
+	if (power.isValid()) {
+		return power;
+	} else {
+		return 0.0;
+	}
+}
+
+void Fuse::setDataPoolEntriesInvalid() {
+	set.read();
+	set.commit(PoolVariableIF::INVALID);
+}
+
+ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = powerMonitor.getParameter(domainId, parameterId, parameterWrapper,
+			newValues, startAtIndex);
+	return result;
+}
+
+bool Fuse::areSwitchesOfComponentOn(DeviceList::iterator iter) {
+	if (powerIF->getSwitchState((*iter)->getSwitchId1())
+			!= PowerSwitchIF::SWITCH_ON) {
+		return false;
+	}
+	if ((*iter)->hasTwoSwitches()) {
+		if ((powerIF->getSwitchState((*iter)->getSwitchId2())
+				!= PowerSwitchIF::SWITCH_ON)) {
+			return false;
+		}
+	}
+	return true;
+}
+
+bool Fuse::isPowerValid() {
+	return power.isValid();
+}
+
+ReturnValue_t Fuse::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return RETURN_OK;
+}
+
+HasHealthIF::HealthState Fuse::getHealth() {
+	return healthHelper.getHealth();
+}
+
+ReturnValue_t Fuse::PowerMonitor::checkPower(float sample, float lowerLimit,
+		float upperLimit) {
+	if (sample > upperLimit) {
+		return this->monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
+				upperLimit);
+	} else if (sample < lowerLimit) {
+		return this->monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
+				lowerLimit);
+	} else {
+		return this->monitorStateIs(RETURN_OK, sample, 0.0); //Within limits.
+	}
+}
diff --git a/power/Fuse.h b/power/Fuse.h
index e6d6929c7..dd8759f47 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -1,106 +1,106 @@
-#ifndef FUSE_H_
-#define FUSE_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../datapoolglob/PIDReader.h"
-#include "../devicehandlers/HealthDevice.h"
-#include "../monitoring/AbsLimitMonitor.h"
-#include "../power/PowerComponentIF.h"
-#include "../power/PowerSwitchIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../parameters/ParameterHelper.h"
-#include <list>
-
-namespace Factory {
-void setStaticFrameworkObjectIds();
-}
-
-class Fuse: public SystemObject,
-		public HasHealthIF,
-		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF,
-		public SerializeIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-private:
-	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
-public:
-	struct VariableIds {
-		uint32_t pidVoltage;
-		uint32_t pidCurrent;
-		uint32_t pidState;
-		uint32_t poolIdPower;
-	};
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
-	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
-	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
-	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
-	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
-
-	typedef std::list<PowerComponentIF*> DeviceList;
-	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
-			float maxCurrent, uint16_t confirmationCount = 2);
-	virtual ~Fuse();
-	void addDevice(PowerComponentIF *set);
-	float getPower();
-
-	bool isPowerValid();
-
-	ReturnValue_t check();
-	uint8_t getFuseId() const;
-	ReturnValue_t initialize();
-	DeviceList devices;
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override;
-	size_t getSerializedSize() const override;
-	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			SerializeIF::Endianness streamEndianness) override;
-	void setAllMonitorsToUnchecked();
-	ReturnValue_t performOperation(uint8_t opCode);
-	MessageQueueId_t getCommandQueue() const;
-	void setDataPoolEntriesInvalid();
-	ReturnValue_t setHealth(HealthState health);
-	HasHealthIF::HealthState getHealth();
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-private:
-	uint8_t oldFuseState;
-	uint8_t fuseId;
-	PowerSwitchIF *powerIF; //could be static in our case.
-	AbsLimitMonitor<float> currentLimit;
-	class PowerMonitor: public MonitorReporter<float> {
-	public:
-		template<typename ... Args>
-		PowerMonitor(Args ... args) :
-				MonitorReporter<float>(std::forward<Args>(args)...) {
-		}
-		ReturnValue_t checkPower(float sample, float lowerLimit,
-				float upperLimit);
-		void sendTransitionEvent(float currentValue, ReturnValue_t state) {
-		}
-
-	};
-	PowerMonitor powerMonitor;
-	GlobDataSet set;
-	PIDReader<float> voltage;
-	PIDReader<float> current;
-	PIDReader<uint8_t> state;
-	gp_float_t power;
-	MessageQueueIF* commandQueue;
-	ParameterHelper parameterHelper;
-	HealthHelper healthHelper;
-	static object_id_t powerSwitchId;
-	void calculatePowerLimits(float *low, float *high);
-	void calculateFusePower();
-	void checkFuseState();
-	void reportEvents(Event event);
-	void checkCommandQueue();
-
-	bool areSwitchesOfComponentOn(DeviceList::iterator iter);
-};
-
-#endif /* FUSE_H_ */
+#ifndef FUSE_H_
+#define FUSE_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../monitoring/AbsLimitMonitor.h"
+#include "../power/PowerComponentIF.h"
+#include "../power/PowerSwitchIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../parameters/ParameterHelper.h"
+#include <list>
+
+namespace Factory {
+void setStaticFrameworkObjectIds();
+}
+
+class Fuse: public SystemObject,
+		public HasHealthIF,
+		public HasReturnvaluesIF,
+		public ReceivesParameterMessagesIF,
+		public SerializeIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+private:
+	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
+public:
+	struct VariableIds {
+		uint32_t pidVoltage;
+		uint32_t pidCurrent;
+		uint32_t pidState;
+		uint32_t poolIdPower;
+	};
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
+	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
+	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
+	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
+	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
+
+	typedef std::list<PowerComponentIF*> DeviceList;
+	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
+			float maxCurrent, uint16_t confirmationCount = 2);
+	virtual ~Fuse();
+	void addDevice(PowerComponentIF *set);
+	float getPower();
+
+	bool isPowerValid();
+
+	ReturnValue_t check();
+	uint8_t getFuseId() const;
+	ReturnValue_t initialize();
+	DeviceList devices;
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override;
+	size_t getSerializedSize() const override;
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override;
+	void setAllMonitorsToUnchecked();
+	ReturnValue_t performOperation(uint8_t opCode);
+	MessageQueueId_t getCommandQueue() const;
+	void setDataPoolEntriesInvalid();
+	ReturnValue_t setHealth(HealthState health);
+	HasHealthIF::HealthState getHealth();
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+private:
+	uint8_t oldFuseState;
+	uint8_t fuseId;
+	PowerSwitchIF *powerIF; //could be static in our case.
+	AbsLimitMonitor<float> currentLimit;
+	class PowerMonitor: public MonitorReporter<float> {
+	public:
+		template<typename ... Args>
+		PowerMonitor(Args ... args) :
+				MonitorReporter<float>(std::forward<Args>(args)...) {
+		}
+		ReturnValue_t checkPower(float sample, float lowerLimit,
+				float upperLimit);
+		void sendTransitionEvent(float currentValue, ReturnValue_t state) {
+		}
+
+	};
+	PowerMonitor powerMonitor;
+	GlobDataSet set;
+	PIDReader<float> voltage;
+	PIDReader<float> current;
+	PIDReader<uint8_t> state;
+	gp_float_t power;
+	MessageQueueIF* commandQueue;
+	ParameterHelper parameterHelper;
+	HealthHelper healthHelper;
+	static object_id_t powerSwitchId;
+	void calculatePowerLimits(float *low, float *high);
+	void calculateFusePower();
+	void checkFuseState();
+	void reportEvents(Event event);
+	void checkCommandQueue();
+
+	bool areSwitchesOfComponentOn(DeviceList::iterator iter);
+};
+
+#endif /* FUSE_H_ */
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index ef852e64c..a37970553 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -1,86 +1,86 @@
-/**
- * @file	PowerComponent.cpp
- * @brief	This file defines the PowerComponent class.
- * @date	28.08.2014
- * @author	baetz
- */
-
-#include "../power/PowerComponent.h"
-
-PowerComponent::PowerComponent() :
-		deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
-		false), min(0.0), max(0.0), moduleId(0) {
-}
-PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
-		uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
-		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2), doIHaveTwoSwitches(
-				twoSwitches), min(min), max(max), moduleId(moduleId) {
-}
-
-ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
-			size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
-			streamEndianness);
-}
-
-size_t PowerComponent::getSerializedSize() const {
-	return sizeof(min) + sizeof(max);
-}
-
-object_id_t PowerComponent::getDeviceObjectId() {
-	return deviceObjectId;
-}
-
-uint8_t PowerComponent::getSwitchId1() {
-	return switchId1;
-}
-
-uint8_t PowerComponent::getSwitchId2() {
-	return switchId2;
-}
-
-bool PowerComponent::hasTwoSwitches() {
-	return doIHaveTwoSwitches;
-}
-
-float PowerComponent::getMin() {
-	return min;
-}
-
-float PowerComponent::getMax() {
-	return max;
-}
-
-ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
-        Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
-}
-
-ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	if (domainId != moduleId) {
-		return INVALID_DOMAIN_ID;
-	}
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set<>(min);
-		break;
-	case 1:
-		parameterWrapper->set<>(max);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+/**
+ * @file	PowerComponent.cpp
+ * @brief	This file defines the PowerComponent class.
+ * @date	28.08.2014
+ * @author	baetz
+ */
+
+#include "../power/PowerComponent.h"
+
+PowerComponent::PowerComponent() :
+		deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
+		false), min(0.0), max(0.0), moduleId(0) {
+}
+PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
+		uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
+		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2), doIHaveTwoSwitches(
+				twoSwitches), min(min), max(max), moduleId(moduleId) {
+}
+
+ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
+			streamEndianness);
+}
+
+size_t PowerComponent::getSerializedSize() const {
+	return sizeof(min) + sizeof(max);
+}
+
+object_id_t PowerComponent::getDeviceObjectId() {
+	return deviceObjectId;
+}
+
+uint8_t PowerComponent::getSwitchId1() {
+	return switchId1;
+}
+
+uint8_t PowerComponent::getSwitchId2() {
+	return switchId2;
+}
+
+bool PowerComponent::hasTwoSwitches() {
+	return doIHaveTwoSwitches;
+}
+
+float PowerComponent::getMin() {
+	return min;
+}
+
+float PowerComponent::getMax() {
+	return max;
+}
+
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
+        Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
+}
+
+ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	if (domainId != moduleId) {
+		return INVALID_DOMAIN_ID;
+	}
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set<>(min);
+		break;
+	case 1:
+		parameterWrapper->set<>(max);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 2e11fa82e..dc5217be1 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -1,48 +1,48 @@
-#ifndef POWERCOMPONENT_H_
-#define POWERCOMPONENT_H_
-
-#include "../objectmanager/SystemObjectIF.h"
-#include "../power/PowerComponentIF.h"
-
-class PowerComponent: public PowerComponentIF {
-public:
-	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
-			bool twoSwitches = false, uint8_t switchId2 = 0xFF);
-
-	virtual object_id_t getDeviceObjectId();
-
-	virtual uint8_t getSwitchId1();
-	virtual uint8_t getSwitchId2();
-
-	bool hasTwoSwitches();
-
-	float getMin();
-	float getMax();
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	size_t getSerializedSize() const override;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex);
-private:
-	const object_id_t deviceObjectId;
-	const uint8_t switchId1;
-	const uint8_t switchId2;
-
-	const bool doIHaveTwoSwitches;
-
-	float min;
-	float max;
-
-	uint8_t moduleId;
-
-	PowerComponent();
-};
-
-#endif /* POWERCOMPONENT_H_ */
+#ifndef POWERCOMPONENT_H_
+#define POWERCOMPONENT_H_
+
+#include "../objectmanager/SystemObjectIF.h"
+#include "../power/PowerComponentIF.h"
+
+class PowerComponent: public PowerComponentIF {
+public:
+	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
+			bool twoSwitches = false, uint8_t switchId2 = 0xFF);
+
+	virtual object_id_t getDeviceObjectId();
+
+	virtual uint8_t getSwitchId1();
+	virtual uint8_t getSwitchId2();
+
+	bool hasTwoSwitches();
+
+	float getMin();
+	float getMax();
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	size_t getSerializedSize() const override;
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+				ParameterWrapper *parameterWrapper,
+				const ParameterWrapper *newValues, uint16_t startAtIndex);
+private:
+	const object_id_t deviceObjectId;
+	const uint8_t switchId1;
+	const uint8_t switchId2;
+
+	const bool doIHaveTwoSwitches;
+
+	float min;
+	float max;
+
+	uint8_t moduleId;
+
+	PowerComponent();
+};
+
+#endif /* POWERCOMPONENT_H_ */
diff --git a/power/PowerComponentIF.h b/power/PowerComponentIF.h
index eeaa39fb5..c2e3a6a56 100644
--- a/power/PowerComponentIF.h
+++ b/power/PowerComponentIF.h
@@ -1,24 +1,24 @@
-#ifndef POWERCOMPONENTIF_H_
-#define POWERCOMPONENTIF_H_
-
-#include "../serialize/SerializeIF.h"
-#include "../parameters/HasParametersIF.h"
-
-class PowerComponentIF : public SerializeIF, public HasParametersIF {
-public:
-	virtual ~PowerComponentIF() {
-
-	}
-
-	virtual object_id_t getDeviceObjectId()=0;
-
-	virtual uint8_t getSwitchId1()=0;
-	virtual uint8_t getSwitchId2()=0;
-	virtual bool hasTwoSwitches()=0;
-
-	virtual float getMin() = 0;
-	virtual float getMax() = 0;
-
-};
-
-#endif /* POWERCOMPONENTIF_H_ */
+#ifndef POWERCOMPONENTIF_H_
+#define POWERCOMPONENTIF_H_
+
+#include "../serialize/SerializeIF.h"
+#include "../parameters/HasParametersIF.h"
+
+class PowerComponentIF : public SerializeIF, public HasParametersIF {
+public:
+	virtual ~PowerComponentIF() {
+
+	}
+
+	virtual object_id_t getDeviceObjectId()=0;
+
+	virtual uint8_t getSwitchId1()=0;
+	virtual uint8_t getSwitchId2()=0;
+	virtual bool hasTwoSwitches()=0;
+
+	virtual float getMin() = 0;
+	virtual float getMax() = 0;
+
+};
+
+#endif /* POWERCOMPONENTIF_H_ */
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 51300db73..df26fb8e3 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -1,128 +1,128 @@
-#include "../power/PowerSensor.h"
-#include "../ipc/QueueFactory.h"
-
-PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
-		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
-		SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
-				ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
-				setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
-				limits.currentMin, limits.currentMax, events.currentLow,
-				events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
-				ids.pidVoltage, confirmationCount, limits.voltageMin,
-				limits.voltageMax, events.voltageLow, events.voltageHigh) {
-		commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-PowerSensor::~PowerSensor() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t PowerSensor::calculatePower() {
-	set.read();
-	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
-	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
-	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
-			&& current.isValid()) {
-		result1 = voltageLimit.doCheck(voltage);
-		result2 = currentLimit.doCheck(current);
-	} else {
-		voltageLimit.setToInvalid();
-		currentLimit.setToInvalid();
-		result1 = OBJECT_NOT_HEALTHY;
-	}
-	if (result1 != HasReturnvaluesIF::RETURN_OK
-			|| result2 != HasReturnvaluesIF::RETURN_OK) {
-		result1 = MonitoringIF::INVALID;
-		power.setValid(PoolVariableIF::INVALID);
-	} else {
-		power.setValid(PoolVariableIF::VALID);
-		power = current * voltage;
-	}
-	set.commit();
-	return result1;
-}
-
-ReturnValue_t PowerSensor::performOperation(uint8_t opCode) {
-	checkCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t PowerSensor::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t PowerSensor::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return result;
-}
-
-void PowerSensor::setAllMonitorsToUnchecked() {
-	currentLimit.setToUnchecked();
-	voltageLimit.setToUnchecked();
-}
-
-void PowerSensor::checkCommandQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = healthHelper.handleHealthCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = parameterHelper.handleParameterMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	command.setToUnknownCommand();
-	commandQueue->reply(&command);
-}
-
-void PowerSensor::setDataPoolEntriesInvalid() {
-	set.read();
-	set.commit(PoolVariableIF::INVALID);
-}
-
-float PowerSensor::getPower() {
-	if (power.isValid()) {
-		return power.value;
-	} else {
-		return 0.0;
-	}
-
-}
-
-ReturnValue_t PowerSensor::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-HasHealthIF::HealthState PowerSensor::getHealth() {
-	return healthHelper.getHealth();
-}
-
-ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = voltageLimit.getParameter(domainId, parameterId, parameterWrapper,
-			newValues, startAtIndex);
-	return result;
-}
+#include "../power/PowerSensor.h"
+#include "../ipc/QueueFactory.h"
+
+PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
+		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
+		SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
+				ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
+				ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
+				setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
+				limits.currentMin, limits.currentMax, events.currentLow,
+				events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
+				ids.pidVoltage, confirmationCount, limits.voltageMin,
+				limits.voltageMax, events.voltageLow, events.voltageHigh) {
+		commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+PowerSensor::~PowerSensor() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t PowerSensor::calculatePower() {
+	set.read();
+	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
+	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
+	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
+			&& current.isValid()) {
+		result1 = voltageLimit.doCheck(voltage);
+		result2 = currentLimit.doCheck(current);
+	} else {
+		voltageLimit.setToInvalid();
+		currentLimit.setToInvalid();
+		result1 = OBJECT_NOT_HEALTHY;
+	}
+	if (result1 != HasReturnvaluesIF::RETURN_OK
+			|| result2 != HasReturnvaluesIF::RETURN_OK) {
+		result1 = MonitoringIF::INVALID;
+		power.setValid(PoolVariableIF::INVALID);
+	} else {
+		power.setValid(PoolVariableIF::VALID);
+		power = current * voltage;
+	}
+	set.commit();
+	return result1;
+}
+
+ReturnValue_t PowerSensor::performOperation(uint8_t opCode) {
+	checkCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t PowerSensor::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t PowerSensor::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return result;
+}
+
+void PowerSensor::setAllMonitorsToUnchecked() {
+	currentLimit.setToUnchecked();
+	voltageLimit.setToUnchecked();
+}
+
+void PowerSensor::checkCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = parameterHelper.handleParameterMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	command.setToUnknownCommand();
+	commandQueue->reply(&command);
+}
+
+void PowerSensor::setDataPoolEntriesInvalid() {
+	set.read();
+	set.commit(PoolVariableIF::INVALID);
+}
+
+float PowerSensor::getPower() {
+	if (power.isValid()) {
+		return power.value;
+	} else {
+		return 0.0;
+	}
+
+}
+
+ReturnValue_t PowerSensor::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState PowerSensor::getHealth() {
+	return healthHelper.getHealth();
+}
+
+ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = voltageLimit.getParameter(domainId, parameterId, parameterWrapper,
+			newValues, startAtIndex);
+	return result;
+}
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index dc859ab35..da0bd8c73 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -1,71 +1,71 @@
-#ifndef POWERSENSOR_H_
-#define POWERSENSOR_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../datapoolglob/PIDReader.h"
-#include "../devicehandlers/HealthDevice.h"
-#include "../monitoring/LimitMonitor.h"
-#include "../parameters/ParameterHelper.h"
-#include "../objectmanager/SystemObject.h"
-#include "../ipc/MessageQueueIF.h"
-
-class PowerController;
-
-class PowerSensor: public SystemObject,
-		public ReceivesParameterMessagesIF,
-		public HasHealthIF {
-	friend class PowerController;
-public:
-	struct VariableIds {
-		uint32_t pidCurrent;
-		uint32_t pidVoltage;
-		uint32_t poolIdPower;
-	};
-	struct DefaultLimits {
-		float currentMin;
-		float currentMax;
-		float voltageMin;
-		float voltageMax;
-	};
-	struct SensorEvents {
-		Event currentLow;
-		Event currentHigh;
-		Event voltageLow;
-		Event voltageHigh;
-	};
-	PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
-			SensorEvents events, uint16_t confirmationCount = 0);
-	virtual ~PowerSensor();
-	ReturnValue_t calculatePower();
-	ReturnValue_t performOperation(uint8_t opCode);
-	void setAllMonitorsToUnchecked();
-	MessageQueueId_t getCommandQueue() const;
-	ReturnValue_t initialize();
-	void setDataPoolEntriesInvalid();
-	float getPower();
-	ReturnValue_t setHealth(HealthState health);
-	HasHealthIF::HealthState getHealth();
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-private:
-	MessageQueueIF* commandQueue;
-	ParameterHelper parameterHelper;
-	HealthHelper healthHelper;
-	GlobDataSet set;
-	//Variables in
-	PIDReader<float> current;
-	PIDReader<float> voltage;
-	//Variables out
-	gp_float_t power;
-
-	static const uint8_t MODULE_ID_CURRENT = 1;
-	static const uint8_t MODULE_ID_VOLTAGE = 2;
-	void checkCommandQueue();
-protected:
-	LimitMonitor<float> currentLimit;
-	LimitMonitor<float> voltageLimit;
-};
-
-#endif /* POWERSENSOR_H_ */
+#ifndef POWERSENSOR_H_
+#define POWERSENSOR_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../monitoring/LimitMonitor.h"
+#include "../parameters/ParameterHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../ipc/MessageQueueIF.h"
+
+class PowerController;
+
+class PowerSensor: public SystemObject,
+		public ReceivesParameterMessagesIF,
+		public HasHealthIF {
+	friend class PowerController;
+public:
+	struct VariableIds {
+		uint32_t pidCurrent;
+		uint32_t pidVoltage;
+		uint32_t poolIdPower;
+	};
+	struct DefaultLimits {
+		float currentMin;
+		float currentMax;
+		float voltageMin;
+		float voltageMax;
+	};
+	struct SensorEvents {
+		Event currentLow;
+		Event currentHigh;
+		Event voltageLow;
+		Event voltageHigh;
+	};
+	PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
+			SensorEvents events, uint16_t confirmationCount = 0);
+	virtual ~PowerSensor();
+	ReturnValue_t calculatePower();
+	ReturnValue_t performOperation(uint8_t opCode);
+	void setAllMonitorsToUnchecked();
+	MessageQueueId_t getCommandQueue() const;
+	ReturnValue_t initialize();
+	void setDataPoolEntriesInvalid();
+	float getPower();
+	ReturnValue_t setHealth(HealthState health);
+	HasHealthIF::HealthState getHealth();
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+private:
+	MessageQueueIF* commandQueue;
+	ParameterHelper parameterHelper;
+	HealthHelper healthHelper;
+	GlobDataSet set;
+	//Variables in
+	PIDReader<float> current;
+	PIDReader<float> voltage;
+	//Variables out
+	gp_float_t power;
+
+	static const uint8_t MODULE_ID_CURRENT = 1;
+	static const uint8_t MODULE_ID_VOLTAGE = 2;
+	void checkCommandQueue();
+protected:
+	LimitMonitor<float> currentLimit;
+	LimitMonitor<float> voltageLimit;
+};
+
+#endif /* POWERSENSOR_H_ */
diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h
index 817c4ce1d..876a82c59 100644
--- a/power/PowerSwitchIF.h
+++ b/power/PowerSwitchIF.h
@@ -1,80 +1,80 @@
-/**
- * @file	PowerSwitchIF.h
- * @brief	This file defines the PowerSwitchIF class.
- * @date	20.03.2013
- * @author	baetz
- */
-
-#ifndef POWERSWITCHIF_H_
-#define POWERSWITCHIF_H_
-
-#include "../events/Event.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-/**
- *
- * @brief   This interface defines a connection to a device that is capable of turning on and off
- *          switches of devices identified by a switch ID.
- * @details The virtual functions of this interface do not allow to make any assignments
- *          because they can be called asynchronosuly (const ending).
- *
- * @ingroup interfaces
- */
-class PowerSwitchIF : public HasReturnvaluesIF {
-public:
-	/**
-	 * Empty dtor.
-	 */
-	virtual ~PowerSwitchIF() {
-
-	}
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCH_IF;
-	static const ReturnValue_t SWITCH_ON = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t SWITCH_OFF = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
-	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
-	/**
-	 * send a direct command to the Power Unit to enable/disable the specified switch.
-	 *
-	 * @param switchNr
-	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
-	 */
-	virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const = 0;
-	/**
-	 * Sends a command to the Power Unit to enable a certain fuse.
-	 */
-	virtual void sendFuseOnCommand(uint8_t fuseNr) const = 0;
-
-	/**
-	 * get the state of the Switches.
-	 * @param switchNr
-	 * @return
-	 *     - @c SWITCH_ON if the specified switch is on.
-	 *     - @c SWITCH_OFF if the specified switch is off.
-	 *     - @c RETURN_FAILED if an error occured
-	 */
-	virtual ReturnValue_t getSwitchState( uint8_t switchNr ) const = 0;
-	/**
-	 * get state of a fuse.
-	 * @param fuseNr
-	 * @return
-	 *     - @c FUSE_ON if the specified fuse is on.
-	 *     - @c FUSE_OFF if the specified fuse is off.
-	 *     - @c RETURN_FAILED if an error occured
-	 */
-	virtual ReturnValue_t getFuseState( uint8_t fuseNr ) const = 0;
-	/**
-	 * The maximum delay that it will take to change a switch
-	 *
-	 * This may take into account the time to send a command, wait for it to be executed and see the switch changed.
-	 */
-	virtual uint32_t getSwitchDelayMs(void) const = 0;
-};
-
-
-#endif /* POWERSWITCHIF_H_ */
+/**
+ * @file	PowerSwitchIF.h
+ * @brief	This file defines the PowerSwitchIF class.
+ * @date	20.03.2013
+ * @author	baetz
+ */
+
+#ifndef POWERSWITCHIF_H_
+#define POWERSWITCHIF_H_
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ *
+ * @brief   This interface defines a connection to a device that is capable of turning on and off
+ *          switches of devices identified by a switch ID.
+ * @details The virtual functions of this interface do not allow to make any assignments
+ *          because they can be called asynchronosuly (const ending).
+ *
+ * @ingroup interfaces
+ */
+class PowerSwitchIF : public HasReturnvaluesIF {
+public:
+	/**
+	 * Empty dtor.
+	 */
+	virtual ~PowerSwitchIF() {
+
+	}
+	/**
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
+	 */
+	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCH_IF;
+	static const ReturnValue_t SWITCH_ON = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t SWITCH_OFF = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
+	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
+	/**
+	 * send a direct command to the Power Unit to enable/disable the specified switch.
+	 *
+	 * @param switchNr
+	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
+	 */
+	virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const = 0;
+	/**
+	 * Sends a command to the Power Unit to enable a certain fuse.
+	 */
+	virtual void sendFuseOnCommand(uint8_t fuseNr) const = 0;
+
+	/**
+	 * get the state of the Switches.
+	 * @param switchNr
+	 * @return
+	 *     - @c SWITCH_ON if the specified switch is on.
+	 *     - @c SWITCH_OFF if the specified switch is off.
+	 *     - @c RETURN_FAILED if an error occured
+	 */
+	virtual ReturnValue_t getSwitchState( uint8_t switchNr ) const = 0;
+	/**
+	 * get state of a fuse.
+	 * @param fuseNr
+	 * @return
+	 *     - @c FUSE_ON if the specified fuse is on.
+	 *     - @c FUSE_OFF if the specified fuse is off.
+	 *     - @c RETURN_FAILED if an error occured
+	 */
+	virtual ReturnValue_t getFuseState( uint8_t fuseNr ) const = 0;
+	/**
+	 * The maximum delay that it will take to change a switch
+	 *
+	 * This may take into account the time to send a command, wait for it to be executed and see the switch changed.
+	 */
+	virtual uint32_t getSwitchDelayMs(void) const = 0;
+};
+
+
+#endif /* POWERSWITCHIF_H_ */
diff --git a/power/PowerSwitcher.cpp b/power/PowerSwitcher.cpp
index 73d9f89bc..1844a11af 100644
--- a/power/PowerSwitcher.cpp
+++ b/power/PowerSwitcher.cpp
@@ -1,127 +1,127 @@
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../power/PowerSwitcher.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
-		PowerSwitcher::State_t setStartState) :
-		state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
-}
-
-ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
-	power = objectManager->get<PowerSwitchIF>(powerSwitchId);
-	if (power == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PowerSwitcher::getStateOfSwitches() {
-	SwitchReturn_t result = howManySwitches();
-	switch (result) {
-	case ONE_SWITCH:
-		return power->getSwitchState(firstSwitch);
-	case TWO_SWITCHES:
-		if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
-			return PowerSwitchIF::SWITCH_ON;
-		} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
-			return PowerSwitchIF::SWITCH_OFF;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
-	SwitchReturn_t result = howManySwitches();
-	switch (result) {
-	case TWO_SWITCHES:
-		power->sendSwitchCommand(secondSwitch, onOff);
-		/* NO BREAK falls through*/
-	case ONE_SWITCH:
-		power->sendSwitchCommand(firstSwitch, onOff);
-		break;
-	}
-	return;
-
-}
-
-void PowerSwitcher::turnOn() {
-	commandSwitches(PowerSwitchIF::SWITCH_ON);
-	state = WAIT_ON;
-}
-
-void PowerSwitcher::turnOff() {
-	commandSwitches(PowerSwitchIF::SWITCH_OFF);
-	state = WAIT_OFF;
-}
-
-PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
-	if (secondSwitch == NO_SWITCH) {
-		return ONE_SWITCH;
-	} else {
-		return TWO_SWITCHES;
-	}
-}
-
-void PowerSwitcher::doStateMachine() {
-	switch (state) {
-	case SWITCH_IS_OFF:
-	case SWITCH_IS_ON:
-		//Do nothing.
-		break;
-	case WAIT_OFF:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
-			state = SWITCH_IS_OFF;
-		}
-		break;
-	case WAIT_ON:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
-			state = SWITCH_IS_ON;
-		}
-		break;
-	default:
-		//Should never happen.
-		break;
-	}
-}
-
-ReturnValue_t PowerSwitcher::checkSwitchState() {
-	switch (state) {
-	case WAIT_OFF:
-	case WAIT_ON:
-		return IN_POWER_TRANSITION;
-	case SWITCH_IS_OFF:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
-			return RETURN_OK;
-		} else {
-			return SWITCH_STATE_MISMATCH;
-		}
-	case SWITCH_IS_ON:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
-			return RETURN_OK;
-		} else {
-			return SWITCH_STATE_MISMATCH;
-		}
-	}
-	return RETURN_FAILED;
-}
-
-PowerSwitcher::State_t PowerSwitcher::getState() {
-	return state;
-}
-
-uint32_t PowerSwitcher::getSwitchDelay() {
-	return power->getSwitchDelayMs();
-}
-
-uint8_t PowerSwitcher::getFirstSwitch() const {
-	return firstSwitch;
-}
-
-uint8_t PowerSwitcher::getSecondSwitch() const {
-	return secondSwitch;
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../power/PowerSwitcher.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
+		PowerSwitcher::State_t setStartState) :
+		state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
+}
+
+ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
+	power = objectManager->get<PowerSwitchIF>(powerSwitchId);
+	if (power == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PowerSwitcher::getStateOfSwitches() {
+	SwitchReturn_t result = howManySwitches();
+	switch (result) {
+	case ONE_SWITCH:
+		return power->getSwitchState(firstSwitch);
+	case TWO_SWITCHES:
+		if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
+				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
+			return PowerSwitchIF::SWITCH_ON;
+		} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
+				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
+			return PowerSwitchIF::SWITCH_OFF;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
+	SwitchReturn_t result = howManySwitches();
+	switch (result) {
+	case TWO_SWITCHES:
+		power->sendSwitchCommand(secondSwitch, onOff);
+		/* NO BREAK falls through*/
+	case ONE_SWITCH:
+		power->sendSwitchCommand(firstSwitch, onOff);
+		break;
+	}
+	return;
+
+}
+
+void PowerSwitcher::turnOn() {
+	commandSwitches(PowerSwitchIF::SWITCH_ON);
+	state = WAIT_ON;
+}
+
+void PowerSwitcher::turnOff() {
+	commandSwitches(PowerSwitchIF::SWITCH_OFF);
+	state = WAIT_OFF;
+}
+
+PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
+	if (secondSwitch == NO_SWITCH) {
+		return ONE_SWITCH;
+	} else {
+		return TWO_SWITCHES;
+	}
+}
+
+void PowerSwitcher::doStateMachine() {
+	switch (state) {
+	case SWITCH_IS_OFF:
+	case SWITCH_IS_ON:
+		//Do nothing.
+		break;
+	case WAIT_OFF:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
+			state = SWITCH_IS_OFF;
+		}
+		break;
+	case WAIT_ON:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
+			state = SWITCH_IS_ON;
+		}
+		break;
+	default:
+		//Should never happen.
+		break;
+	}
+}
+
+ReturnValue_t PowerSwitcher::checkSwitchState() {
+	switch (state) {
+	case WAIT_OFF:
+	case WAIT_ON:
+		return IN_POWER_TRANSITION;
+	case SWITCH_IS_OFF:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
+			return RETURN_OK;
+		} else {
+			return SWITCH_STATE_MISMATCH;
+		}
+	case SWITCH_IS_ON:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
+			return RETURN_OK;
+		} else {
+			return SWITCH_STATE_MISMATCH;
+		}
+	}
+	return RETURN_FAILED;
+}
+
+PowerSwitcher::State_t PowerSwitcher::getState() {
+	return state;
+}
+
+uint32_t PowerSwitcher::getSwitchDelay() {
+	return power->getSwitchDelayMs();
+}
+
+uint8_t PowerSwitcher::getFirstSwitch() const {
+	return firstSwitch;
+}
+
+uint8_t PowerSwitcher::getSecondSwitch() const {
+	return secondSwitch;
+}
diff --git a/power/PowerSwitcher.h b/power/PowerSwitcher.h
index 39f44f505..515ce0428 100644
--- a/power/PowerSwitcher.h
+++ b/power/PowerSwitcher.h
@@ -1,45 +1,45 @@
-#ifndef POWERSWITCHER_H_
-#define POWERSWITCHER_H_
-#include "../power/PowerSwitchIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../timemanager/Countdown.h"
-
-class PowerSwitcher : public HasReturnvaluesIF {
-public:
-	enum State_t {
-		WAIT_OFF,
-		WAIT_ON,
-		SWITCH_IS_OFF,
-		SWITCH_IS_ON,
-	};
-	State_t state;
-	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
-	static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
-	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
-	ReturnValue_t initialize(object_id_t powerSwitchId);
-	void turnOn();
-	void turnOff();
-	void doStateMachine();
-	State_t getState();
-	ReturnValue_t checkSwitchState();
-	uint32_t getSwitchDelay();
-	uint8_t getFirstSwitch() const;
-	uint8_t getSecondSwitch() const;
-private:
-	uint8_t firstSwitch;
-	uint8_t secondSwitch;
-	PowerSwitchIF* power;
-	static const uint8_t NO_SWITCH = 0xFF;
-	enum SwitchReturn_t {
-		ONE_SWITCH = 1,
-		TWO_SWITCHES = 2
-	};
-	ReturnValue_t getStateOfSwitches();
-	void commandSwitches( ReturnValue_t onOff );
-	SwitchReturn_t howManySwitches();
-};
-
-
-
-#endif /* POWERSWITCHER_H_ */
+#ifndef POWERSWITCHER_H_
+#define POWERSWITCHER_H_
+#include "../power/PowerSwitchIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Countdown.h"
+
+class PowerSwitcher : public HasReturnvaluesIF {
+public:
+	enum State_t {
+		WAIT_OFF,
+		WAIT_ON,
+		SWITCH_IS_OFF,
+		SWITCH_IS_ON,
+	};
+	State_t state;
+	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
+	static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
+	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
+	ReturnValue_t initialize(object_id_t powerSwitchId);
+	void turnOn();
+	void turnOff();
+	void doStateMachine();
+	State_t getState();
+	ReturnValue_t checkSwitchState();
+	uint32_t getSwitchDelay();
+	uint8_t getFirstSwitch() const;
+	uint8_t getSecondSwitch() const;
+private:
+	uint8_t firstSwitch;
+	uint8_t secondSwitch;
+	PowerSwitchIF* power;
+	static const uint8_t NO_SWITCH = 0xFF;
+	enum SwitchReturn_t {
+		ONE_SWITCH = 1,
+		TWO_SWITCHES = 2
+	};
+	ReturnValue_t getStateOfSwitches();
+	void commandSwitches( ReturnValue_t onOff );
+	SwitchReturn_t howManySwitches();
+};
+
+
+
+#endif /* POWERSWITCHER_H_ */
diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index 8a51469fb..dda58e038 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -1,119 +1,119 @@
-#include "../pus/CService200ModeCommanding.h"
-#include "../pus/servicepackets/Service200Packets.h"
-
-#include "../modes/HasModesIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serialize/SerialLinkedListAdapter.h"
-#include "../modes/ModeMessage.h"
-
-CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId):
-        CommandingServiceBase(objectId, apid, serviceId,
-	    NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {}
-
-CService200ModeCommanding::~CService200ModeCommanding() {}
-
-ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
-	switch(subservice) {
-	case(Subservice::COMMAND_MODE_COMMAND):
-	case(Subservice::COMMAND_MODE_READ):
-	case(Subservice::COMMAND_MODE_ANNCOUNCE):
-		return RETURN_OK;
-	default:
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-
-ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject(
-		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-		MessageQueueId_t *id, object_id_t *objectId) {
-    if(tcDataLen < sizeof(object_id_t)) {
-        return CommandingServiceBase::INVALID_TC;
-    }
-    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
-            SerializeIF::Endianness::BIG);
-
-	return checkInterfaceAndAcquireMessageQueue(id,objectId);
-}
-
-ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
-        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-    HasModesIF * destination = objectManager->get<HasModesIF>(*objectId);
-    if(destination == nullptr) {
-        return CommandingServiceBase::INVALID_OBJECT;
-
-    }
-
-    *messageQueueToSet = destination->getCommandQueue();
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t CService200ModeCommanding::prepareCommand(
-		CommandMessage* message,uint8_t subservice, const uint8_t *tcData,
-		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
-	ModePacket modeCommandPacket;
-	ReturnValue_t result = modeCommandPacket.deSerialize(&tcData,
-			&tcDataLen, SerializeIF::Endianness::BIG);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
-	        ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
-	        modeCommandPacket.getSubmode());
-	return result;
-}
-
-
-ReturnValue_t CService200ModeCommanding::handleReply(
-		const CommandMessage* reply, Command_t previousCommand,
-		uint32_t *state, CommandMessage* optionalNextCommand,
-		object_id_t objectId, bool *isStep) {
-	Command_t replyId = reply->getCommand();
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch(replyId) {
-	case(ModeMessage::REPLY_MODE_REPLY): {
-		result = prepareModeReply(reply, objectId);
-		break;
-	}
-	case(ModeMessage::REPLY_WRONG_MODE_REPLY): {
-		result = prepareWrongModeReply(reply, objectId);
-		break;
-	}
-	case(ModeMessage::REPLY_CANT_REACH_MODE): {
-		result = prepareCantReachModeReply(reply, objectId);
-		break;
-	}
-	case(ModeMessage::REPLY_MODE_INFO):
-		result = INVALID_REPLY;
-		break;
-	default:
-		result = RETURN_FAILED;
-	}
-	return result;
-}
-
-ReturnValue_t CService200ModeCommanding::prepareModeReply(
-		const CommandMessage *reply, object_id_t objectId) {
-	ModePacket modeReplyPacket(objectId,
-			ModeMessage::getMode(reply),
-			ModeMessage::getSubmode(reply));
-	return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket);
-}
-
-ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(
-		const CommandMessage *reply, object_id_t objectId) {
-	ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply),
-			ModeMessage::getSubmode(reply));
-	return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
-}
-
-ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
-		const CommandMessage *reply, object_id_t objectId) {
-	CantReachModePacket cantReachModePacket(objectId,
-	        ModeMessage::getCantReachModeReason(reply));
-	return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
-	        &cantReachModePacket);
-}
+#include "../pus/CService200ModeCommanding.h"
+#include "../pus/servicepackets/Service200Packets.h"
+
+#include "../modes/HasModesIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../modes/ModeMessage.h"
+
+CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId):
+        CommandingServiceBase(objectId, apid, serviceId,
+	    NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {}
+
+CService200ModeCommanding::~CService200ModeCommanding() {}
+
+ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
+	switch(subservice) {
+	case(Subservice::COMMAND_MODE_COMMAND):
+	case(Subservice::COMMAND_MODE_READ):
+	case(Subservice::COMMAND_MODE_ANNCOUNCE):
+		return RETURN_OK;
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+
+ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject(
+		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+		MessageQueueId_t *id, object_id_t *objectId) {
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG);
+
+	return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
+        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+    HasModesIF * destination = objectManager->get<HasModesIF>(*objectId);
+    if(destination == nullptr) {
+        return CommandingServiceBase::INVALID_OBJECT;
+
+    }
+
+    *messageQueueToSet = destination->getCommandQueue();
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t CService200ModeCommanding::prepareCommand(
+		CommandMessage* message,uint8_t subservice, const uint8_t *tcData,
+		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
+	ModePacket modeCommandPacket;
+	ReturnValue_t result = modeCommandPacket.deSerialize(&tcData,
+			&tcDataLen, SerializeIF::Endianness::BIG);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
+	        ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
+	        modeCommandPacket.getSubmode());
+	return result;
+}
+
+
+ReturnValue_t CService200ModeCommanding::handleReply(
+		const CommandMessage* reply, Command_t previousCommand,
+		uint32_t *state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool *isStep) {
+	Command_t replyId = reply->getCommand();
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	switch(replyId) {
+	case(ModeMessage::REPLY_MODE_REPLY): {
+		result = prepareModeReply(reply, objectId);
+		break;
+	}
+	case(ModeMessage::REPLY_WRONG_MODE_REPLY): {
+		result = prepareWrongModeReply(reply, objectId);
+		break;
+	}
+	case(ModeMessage::REPLY_CANT_REACH_MODE): {
+		result = prepareCantReachModeReply(reply, objectId);
+		break;
+	}
+	case(ModeMessage::REPLY_MODE_INFO):
+		result = INVALID_REPLY;
+		break;
+	default:
+		result = RETURN_FAILED;
+	}
+	return result;
+}
+
+ReturnValue_t CService200ModeCommanding::prepareModeReply(
+		const CommandMessage *reply, object_id_t objectId) {
+	ModePacket modeReplyPacket(objectId,
+			ModeMessage::getMode(reply),
+			ModeMessage::getSubmode(reply));
+	return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket);
+}
+
+ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(
+		const CommandMessage *reply, object_id_t objectId) {
+	ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply),
+			ModeMessage::getSubmode(reply));
+	return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
+}
+
+ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
+		const CommandMessage *reply, object_id_t objectId) {
+	CantReachModePacket cantReachModePacket(objectId,
+	        ModeMessage::getCantReachModeReason(reply));
+	return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
+	        &cantReachModePacket);
+}
diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h
index dfb4dfa60..89347dbd8 100644
--- a/pus/CService200ModeCommanding.h
+++ b/pus/CService200ModeCommanding.h
@@ -1,85 +1,85 @@
-#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
-#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
-
-#include "../tmtcservices/CommandingServiceBase.h"
-
-/**
- * @brief Custom PUS service to set mode of all objects implementing HasModesIF
- *
- * Examples: Device Handlers, Assemblies or Subsystems.
- * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
- * Dissertation Baetz p. 115, 116, 165-167.
- *
- * This is a gateway service. It relays device commands using the software bus.
- * @ingroup pus_services
- */
-class CService200ModeCommanding: public CommandingServiceBase {
-public:
-	static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
-	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
-
-	CService200ModeCommanding(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId);
-	virtual~ CService200ModeCommanding();
-
-protected:
-	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
-	ReturnValue_t isValidSubservice(uint8_t subservice) override;
-	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) override;
-	ReturnValue_t prepareCommand(CommandMessage* message,
-			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-			uint32_t *state, object_id_t objectId) override;
-	ReturnValue_t handleReply(const CommandMessage* reply,
-			Command_t previousCommand, uint32_t *state,
-			CommandMessage* optionalNextCommand, object_id_t objectId,
-			bool *isStep) override;
-
-private:
-	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
-			const uint8_t* tcData, uint32_t tcDataLen);
-	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
-			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
-
-	ReturnValue_t prepareModeReply(const CommandMessage *reply,
-			object_id_t objectId);
-	ReturnValue_t prepareWrongModeReply(const CommandMessage *reply,
-			object_id_t objectId);
-	ReturnValue_t prepareCantReachModeReply(const CommandMessage *reply,
-			object_id_t objectId);
-
-	enum Subservice { //!< [EXPORT] : [COMMENT] Mode Commanding Subservices
-		//!< [EXPORT] : [COMMAND] Command assembly, subsystem or device mode
-		COMMAND_MODE_COMMAND = 1,
-		//!< [EXPORT] : [COMMAND] Command to set the specified Mode,
-		//! regardless of external control flag
-		COMMAND_MODE_COMMAND_FORCED = 2,
-		//!< [EXPORT] : [COMMAND] Read the current mode and
-		//! reply with a REPLY_MODE_REPLY
-		COMMAND_MODE_READ = 3,
-		//!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event.
-		//! This command does NOT have a reply
-		COMMAND_MODE_ANNCOUNCE = 4,
-		//!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this
-		//! command to every child. This command does NOT have a reply.
-		COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5,
-		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
-		REPLY_MODE_REPLY = 6,
-		//!< [EXPORT] : [REPLY] Reply in case a mode command can't be executed.
-		REPLY_CANT_REACH_MODE = 7,
-		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND, indicating that a
-		//! mode was commanded and a transition started but was aborted,
-		//! the parameters contain the mode that was reached
-		REPLY_WRONG_MODE_REPLY = 8
-	};
-
-	enum modeParameters {
-		MODE_OFF = 0,
-		MODE_ON = 1,
-		MODE_NORMAL = 2,
-		MODE_RAW = 3
-	};
-};
-
-#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */
+#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
+#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
+
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief Custom PUS service to set mode of all objects implementing HasModesIF
+ *
+ * Examples: Device Handlers, Assemblies or Subsystems.
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * @ingroup pus_services
+ */
+class CService200ModeCommanding: public CommandingServiceBase {
+public:
+	static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
+	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+
+	CService200ModeCommanding(object_id_t objectId,
+	        uint16_t apid, uint8_t serviceId);
+	virtual~ CService200ModeCommanding();
+
+protected:
+	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) override;
+
+private:
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+			const uint8_t* tcData, uint32_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
+
+	ReturnValue_t prepareModeReply(const CommandMessage *reply,
+			object_id_t objectId);
+	ReturnValue_t prepareWrongModeReply(const CommandMessage *reply,
+			object_id_t objectId);
+	ReturnValue_t prepareCantReachModeReply(const CommandMessage *reply,
+			object_id_t objectId);
+
+	enum Subservice { //!< [EXPORT] : [COMMENT] Mode Commanding Subservices
+		//!< [EXPORT] : [COMMAND] Command assembly, subsystem or device mode
+		COMMAND_MODE_COMMAND = 1,
+		//!< [EXPORT] : [COMMAND] Command to set the specified Mode,
+		//! regardless of external control flag
+		COMMAND_MODE_COMMAND_FORCED = 2,
+		//!< [EXPORT] : [COMMAND] Read the current mode and
+		//! reply with a REPLY_MODE_REPLY
+		COMMAND_MODE_READ = 3,
+		//!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event.
+		//! This command does NOT have a reply
+		COMMAND_MODE_ANNCOUNCE = 4,
+		//!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this
+		//! command to every child. This command does NOT have a reply.
+		COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5,
+		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
+		REPLY_MODE_REPLY = 6,
+		//!< [EXPORT] : [REPLY] Reply in case a mode command can't be executed.
+		REPLY_CANT_REACH_MODE = 7,
+		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND, indicating that a
+		//! mode was commanded and a transition started but was aborted,
+		//! the parameters contain the mode that was reached
+		REPLY_WRONG_MODE_REPLY = 8
+	};
+
+	enum modeParameters {
+		MODE_OFF = 0,
+		MODE_ON = 1,
+		MODE_NORMAL = 2,
+		MODE_RAW = 3
+	};
+};
+
+#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */
diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index 057ff707e..cc5dd640c 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -1,84 +1,84 @@
-#include "CService201HealthCommanding.h"
-
-#include "../health/HasHealthIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../health/HealthMessage.h"
-#include "servicepackets/Service201Packets.h"
-
-CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId):
-	CommandingServiceBase(objectId, apid, serviceId,
-			NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {
-}
-
-CService201HealthCommanding::~CService201HealthCommanding() {
-}
-
-ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
-	switch(subservice) {
-	case(Subservice::COMMAND_SET_HEALTH):
-		return RETURN_OK;
-	default:
-		sif::error << "Invalid Subservice" << std::endl;
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-ReturnValue_t CService201HealthCommanding::getMessageQueueAndObject(
-        uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-        MessageQueueId_t *id, object_id_t *objectId) {
-    if(tcDataLen < sizeof(object_id_t)) {
-        return CommandingServiceBase::INVALID_TC;
-    }
-    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
-            SerializeIF::Endianness::BIG);
-
-    return checkInterfaceAndAcquireMessageQueue(id,objectId);
-}
-
-ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
-        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-    HasHealthIF * destination = objectManager->get<HasHealthIF>(*objectId);
-    if(destination == nullptr) {
-        return CommandingServiceBase::INVALID_OBJECT;
-    }
-
-    *messageQueueToSet = destination->getCommandQueue();
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t CService201HealthCommanding::prepareCommand
-		(CommandMessage* message, uint8_t subservice, const uint8_t *tcData,
-		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
-	HealthCommand healthCommand;
-	ReturnValue_t result = healthCommand.deSerialize(&tcData, &tcDataLen,
-	        SerializeIF::Endianness::BIG);
-	if (result != RETURN_OK) {
-		return result;
-	} else {
-		HealthMessage::setHealthMessage(dynamic_cast<CommandMessage*>(message),
-				HealthMessage::HEALTH_SET, healthCommand.getHealth());
-		return result;
-	}
-}
-
-ReturnValue_t CService201HealthCommanding::handleReply
-		(const CommandMessage* reply, Command_t previousCommand,
-		uint32_t *state, CommandMessage* optionalNextCommand,
-		object_id_t objectId, bool *isStep) {
-	Command_t replyId = reply->getCommand();
-	if (replyId == HealthMessage::REPLY_HEALTH_SET) {
-		prepareHealthSetReply(reply);
-	}
-	return RETURN_OK;
-}
-
-void CService201HealthCommanding::prepareHealthSetReply(
-        const CommandMessage* reply) {
-	prepareHealthSetReply(reply);
-	uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
-	uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
-	HealthSetReply healthSetReply(health, oldHealth);
-	sendTmPacket(Subservice::REPLY_HEALTH_SET,&healthSetReply);
-}
-
+#include "CService201HealthCommanding.h"
+
+#include "../health/HasHealthIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../health/HealthMessage.h"
+#include "servicepackets/Service201Packets.h"
+
+CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId):
+	CommandingServiceBase(objectId, apid, serviceId,
+			NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {
+}
+
+CService201HealthCommanding::~CService201HealthCommanding() {
+}
+
+ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
+	switch(subservice) {
+	case(Subservice::COMMAND_SET_HEALTH):
+		return RETURN_OK;
+	default:
+		sif::error << "Invalid Subservice" << std::endl;
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t CService201HealthCommanding::getMessageQueueAndObject(
+        uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+        MessageQueueId_t *id, object_id_t *objectId) {
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG);
+
+    return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
+        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+    HasHealthIF * destination = objectManager->get<HasHealthIF>(*objectId);
+    if(destination == nullptr) {
+        return CommandingServiceBase::INVALID_OBJECT;
+    }
+
+    *messageQueueToSet = destination->getCommandQueue();
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CService201HealthCommanding::prepareCommand
+		(CommandMessage* message, uint8_t subservice, const uint8_t *tcData,
+		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
+	HealthCommand healthCommand;
+	ReturnValue_t result = healthCommand.deSerialize(&tcData, &tcDataLen,
+	        SerializeIF::Endianness::BIG);
+	if (result != RETURN_OK) {
+		return result;
+	} else {
+		HealthMessage::setHealthMessage(dynamic_cast<CommandMessage*>(message),
+				HealthMessage::HEALTH_SET, healthCommand.getHealth());
+		return result;
+	}
+}
+
+ReturnValue_t CService201HealthCommanding::handleReply
+		(const CommandMessage* reply, Command_t previousCommand,
+		uint32_t *state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool *isStep) {
+	Command_t replyId = reply->getCommand();
+	if (replyId == HealthMessage::REPLY_HEALTH_SET) {
+		prepareHealthSetReply(reply);
+	}
+	return RETURN_OK;
+}
+
+void CService201HealthCommanding::prepareHealthSetReply(
+        const CommandMessage* reply) {
+	prepareHealthSetReply(reply);
+	uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
+	uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
+	HealthSetReply healthSetReply(health, oldHealth);
+	sendTmPacket(Subservice::REPLY_HEALTH_SET,&healthSetReply);
+}
+
diff --git a/pus/CService201HealthCommanding.h b/pus/CService201HealthCommanding.h
index 85d2e24c3..100f675e2 100644
--- a/pus/CService201HealthCommanding.h
+++ b/pus/CService201HealthCommanding.h
@@ -1,58 +1,58 @@
-#ifndef FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
-#define FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
-
-#include "../tmtcservices/CommandingServiceBase.h"
-
-/**
- * @brief   Custom PUS service to set health of all objects
- *          implementing hasHealthIF.
- *
- * Examples: Device Handlers, Assemblies or Subsystems.
- * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
- * Dissertation Baetz p. 115, 116, 165-167.
- *
- * This is a gateway service. It relays device commands using the software bus.
- * This service is very closely tied to the Commanding Service Base template
- * class. There is constant interaction between this Service Base und a
- * child class like this service
- *
- */
-class CService201HealthCommanding: public CommandingServiceBase {
-public:
-    static const uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
-    static const uint16_t COMMAND_TIMEOUT_SECONDS = 60;
-
-	CService201HealthCommanding(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId);
-	virtual~ CService201HealthCommanding();
-protected:
-	/* CSB abstract function implementations */
-	ReturnValue_t isValidSubservice(uint8_t subservice) override;
-	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) override;
-	/** Prepare health command */
-	ReturnValue_t prepareCommand(CommandMessage* message,
-			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-			uint32_t *state, object_id_t objectId) override;
-	/** Handle health reply */
-	ReturnValue_t handleReply(const CommandMessage* reply,
-			Command_t previousCommand, uint32_t *state,
-			CommandMessage* optionalNextCommand, object_id_t objectId,
-			bool *isStep) override;
-
-private:
-	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
-			const uint8_t* tcData, size_t tcDataLen);
-	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
-			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
-
-	void prepareHealthSetReply(const CommandMessage *reply);
-
-	enum Subservice {
-		COMMAND_SET_HEALTH = 1, //!< [EXPORT] : [TC] Set health of target object
-		REPLY_HEALTH_SET = 2 //!< [EXPORT] : [TM] Reply to health set command which also provides old health
-	};
-};
-
-#endif /* FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_ */
+#ifndef FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
+#define FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
+
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief   Custom PUS service to set health of all objects
+ *          implementing hasHealthIF.
+ *
+ * Examples: Device Handlers, Assemblies or Subsystems.
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * This service is very closely tied to the Commanding Service Base template
+ * class. There is constant interaction between this Service Base und a
+ * child class like this service
+ *
+ */
+class CService201HealthCommanding: public CommandingServiceBase {
+public:
+    static const uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
+    static const uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+
+	CService201HealthCommanding(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId);
+	virtual~ CService201HealthCommanding();
+protected:
+	/* CSB abstract function implementations */
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	/** Prepare health command */
+	ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) override;
+	/** Handle health reply */
+	ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) override;
+
+private:
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
+
+	void prepareHealthSetReply(const CommandMessage *reply);
+
+	enum Subservice {
+		COMMAND_SET_HEALTH = 1, //!< [EXPORT] : [TC] Set health of target object
+		REPLY_HEALTH_SET = 2 //!< [EXPORT] : [TM] Reply to health set command which also provides old health
+	};
+};
+
+#endif /* FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_ */
diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index fb66c1608..9b17eba58 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -1,100 +1,100 @@
-#include "../pus/Service1TelecommandVerification.h"
-#include "../pus/servicepackets/Service1Packets.h"
-
-#include "../ipc/QueueFactory.h"
-#include "../tmtcservices/PusVerificationReport.h"
-#include "../tmtcpacket/pus/TmPacketStored.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-
-Service1TelecommandVerification::Service1TelecommandVerification(
-        object_id_t objectId, uint16_t apid, uint8_t serviceId,
-        object_id_t targetDestination):
-        SystemObject(objectId), apid(apid), serviceId(serviceId),
-        targetDestination(targetDestination) {
-	tmQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Service1TelecommandVerification::~Service1TelecommandVerification() {}
-
-MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
-	return tmQueue->getId();
-}
-
-
-ReturnValue_t Service1TelecommandVerification::performOperation(
-		uint8_t operationCode){
-	PusVerificationMessage message;
-	ReturnValue_t status = tmQueue->receiveMessage(&message);
-	while(status == HasReturnvaluesIF::RETURN_OK) {
-		status = sendVerificationReport(&message);
-		if(status != HasReturnvaluesIF::RETURN_OK) {
-			return status;
-		}
-		status = tmQueue->receiveMessage(&message);
-	}
-	if (status == MessageQueueIF::EMPTY) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return status;
-	}
-}
-
-
-ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
-		PusVerificationMessage* message) {
-	ReturnValue_t result;
-	if(message->getReportId() % 2 == 0) {
-		result = generateFailureReport(message);
-	} else {
-		result = generateSuccessReport(message);
-	}
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Service1TelecommandVerification::sendVerificationReport: "
-		        "Sending verification packet failed !" << std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t Service1TelecommandVerification::generateFailureReport(
-        PusVerificationMessage *message) {
-	FailureReport report(
-			message->getReportId(), message->getTcPacketId(),
-			message->getTcSequenceControl(), message->getStep(),
-			message->getErrorCode(), message->getParameter1(),
-			message->getParameter2());
-	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
-	        packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
-			tmQueue->getId());
-	return result;
-}
-
-ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
-        PusVerificationMessage *message) {
-	SuccessReport report(message->getReportId(),message->getTcPacketId(),
-			message->getTcSequenceControl(),message->getStep());
-	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
-	        packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
-			tmQueue->getId());
-	return result;
-}
-
-
-ReturnValue_t Service1TelecommandVerification::initialize() {
-	// Get target object for TC verification messages
-	AcceptsTelemetryIF* funnel = objectManager->
-			get<AcceptsTelemetryIF>(targetDestination);
-	if(funnel == nullptr){
-	    sif::error << "Service1TelecommandVerification::initialize: Specified"
-	            " TM funnel invalid. Make sure it is set up and implements"
-	            " AcceptsTelemetryIF." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
-	return SystemObject::initialize();
-}
+#include "../pus/Service1TelecommandVerification.h"
+#include "../pus/servicepackets/Service1Packets.h"
+
+#include "../ipc/QueueFactory.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+
+Service1TelecommandVerification::Service1TelecommandVerification(
+        object_id_t objectId, uint16_t apid, uint8_t serviceId,
+        object_id_t targetDestination):
+        SystemObject(objectId), apid(apid), serviceId(serviceId),
+        targetDestination(targetDestination) {
+	tmQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Service1TelecommandVerification::~Service1TelecommandVerification() {}
+
+MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
+	return tmQueue->getId();
+}
+
+
+ReturnValue_t Service1TelecommandVerification::performOperation(
+		uint8_t operationCode){
+	PusVerificationMessage message;
+	ReturnValue_t status = tmQueue->receiveMessage(&message);
+	while(status == HasReturnvaluesIF::RETURN_OK) {
+		status = sendVerificationReport(&message);
+		if(status != HasReturnvaluesIF::RETURN_OK) {
+			return status;
+		}
+		status = tmQueue->receiveMessage(&message);
+	}
+	if (status == MessageQueueIF::EMPTY) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return status;
+	}
+}
+
+
+ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
+		PusVerificationMessage* message) {
+	ReturnValue_t result;
+	if(message->getReportId() % 2 == 0) {
+		result = generateFailureReport(message);
+	} else {
+		result = generateSuccessReport(message);
+	}
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Service1TelecommandVerification::sendVerificationReport: "
+		        "Sending verification packet failed !" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t Service1TelecommandVerification::generateFailureReport(
+        PusVerificationMessage *message) {
+	FailureReport report(
+			message->getReportId(), message->getTcPacketId(),
+			message->getTcSequenceControl(), message->getStep(),
+			message->getErrorCode(), message->getParameter1(),
+			message->getParameter2());
+	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	        packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
+			tmQueue->getId());
+	return result;
+}
+
+ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
+        PusVerificationMessage *message) {
+	SuccessReport report(message->getReportId(),message->getTcPacketId(),
+			message->getTcSequenceControl(),message->getStep());
+	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	        packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
+			tmQueue->getId());
+	return result;
+}
+
+
+ReturnValue_t Service1TelecommandVerification::initialize() {
+	// Get target object for TC verification messages
+	AcceptsTelemetryIF* funnel = objectManager->
+			get<AcceptsTelemetryIF>(targetDestination);
+	if(funnel == nullptr){
+	    sif::error << "Service1TelecommandVerification::initialize: Specified"
+	            " TM funnel invalid. Make sure it is set up and implements"
+	            " AcceptsTelemetryIF." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
+	return SystemObject::initialize();
+}
diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h
index 91275cfb0..37562d1c9 100644
--- a/pus/Service1TelecommandVerification.h
+++ b/pus/Service1TelecommandVerification.h
@@ -1,94 +1,94 @@
-#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../tmtcservices/AcceptsVerifyMessageIF.h"
-#include "../tmtcservices/PusVerificationReport.h"
-#include "../ipc/MessageQueueIF.h"
-
-/**
- * @brief Verify TC acceptance, start, progress and execution.
- *
- * Full Documentation: ECSS-E70-41A p.51
- *
- * The telecommand verification service provides the capability for
- * explicit verification of each distinct stage of execution of a telecommand
- * packet, from on-board acceptance through to completion of execution.
- *
- * Minimum capabilities of this service:
- *
- *  - TM[1,1]: Telecommand Acceptance Report - Success.
- *  - TM[1,2]: Telecommand Acceptance Report - Failure.
- *
- * Additional capabilities of this service:
- *
- *  - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4).
- *  - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3).
- *  - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6).
- *  - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5).
- *  - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8).
- *  - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7).
- *
- * This Service is not inherited from PUSServiceBase unlike other PUS Services
- * because all services implementing PUSServiceBase use this service to
- * generate verification reports.
- * @ingroup pus_services
- */
-class Service1TelecommandVerification: public AcceptsVerifyMessageIF,
-		public SystemObject,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-public:
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
-
-	Service1TelecommandVerification(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
-	virtual ~Service1TelecommandVerification();
-
-	/**
-	 *
-	 * @return ID of Verification Queue
-	 */
-	virtual MessageQueueId_t getVerificationQueue();
-
-	/**
-	 * Performs the service periodically as specified in init_mission().
-	 * Triggers the handlePacket function to send TC verification messages
-	 * @param operationCode
-	 * @return
-	 */
-	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
-
-	/**
-	 * Initializes the destination for TC verification messages and initializes
-	 * Service 1 as a system object
-	 * @return
-	 */
-	ReturnValue_t initialize() override;
-private:
-	uint16_t apid = 0;
-	uint8_t serviceId = 0;
-
-	object_id_t targetDestination = objects::NO_OBJECT;
-
-	ReturnValue_t sendVerificationReport(PusVerificationMessage* message);
-	ReturnValue_t generateFailureReport(PusVerificationMessage* message);
-	ReturnValue_t generateSuccessReport(PusVerificationMessage* message);
-
-	uint16_t packetSubCounter = 0;
-
-	MessageQueueIF* tmQueue = nullptr;
-
-	enum class Subservice: uint8_t {
-		VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM]
-		VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM]
-		VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM]
-		VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM]
-		VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM]
-		VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM]
-	};
-};
-
-#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
+#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcservices/AcceptsVerifyMessageIF.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../ipc/MessageQueueIF.h"
+
+/**
+ * @brief Verify TC acceptance, start, progress and execution.
+ *
+ * Full Documentation: ECSS-E70-41A p.51
+ *
+ * The telecommand verification service provides the capability for
+ * explicit verification of each distinct stage of execution of a telecommand
+ * packet, from on-board acceptance through to completion of execution.
+ *
+ * Minimum capabilities of this service:
+ *
+ *  - TM[1,1]: Telecommand Acceptance Report - Success.
+ *  - TM[1,2]: Telecommand Acceptance Report - Failure.
+ *
+ * Additional capabilities of this service:
+ *
+ *  - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4).
+ *  - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3).
+ *  - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6).
+ *  - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5).
+ *  - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8).
+ *  - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7).
+ *
+ * This Service is not inherited from PUSServiceBase unlike other PUS Services
+ * because all services implementing PUSServiceBase use this service to
+ * generate verification reports.
+ * @ingroup pus_services
+ */
+class Service1TelecommandVerification: public AcceptsVerifyMessageIF,
+		public SystemObject,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
+
+	Service1TelecommandVerification(object_id_t objectId,
+	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
+	virtual ~Service1TelecommandVerification();
+
+	/**
+	 *
+	 * @return ID of Verification Queue
+	 */
+	virtual MessageQueueId_t getVerificationQueue();
+
+	/**
+	 * Performs the service periodically as specified in init_mission().
+	 * Triggers the handlePacket function to send TC verification messages
+	 * @param operationCode
+	 * @return
+	 */
+	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+	/**
+	 * Initializes the destination for TC verification messages and initializes
+	 * Service 1 as a system object
+	 * @return
+	 */
+	ReturnValue_t initialize() override;
+private:
+	uint16_t apid = 0;
+	uint8_t serviceId = 0;
+
+	object_id_t targetDestination = objects::NO_OBJECT;
+
+	ReturnValue_t sendVerificationReport(PusVerificationMessage* message);
+	ReturnValue_t generateFailureReport(PusVerificationMessage* message);
+	ReturnValue_t generateSuccessReport(PusVerificationMessage* message);
+
+	uint16_t packetSubCounter = 0;
+
+	MessageQueueIF* tmQueue = nullptr;
+
+	enum class Subservice: uint8_t {
+		VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM]
+		VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM]
+		VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM]
+		VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM]
+		VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM]
+		VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM]
+	};
+};
+
+#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 26639de61..9529c675e 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -1,165 +1,165 @@
-#include "../pus/Service2DeviceAccess.h"
-#include "../pus/servicepackets/Service2Packets.h"
-
-#include "../devicehandlers/DeviceHandlerIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../devicehandlers/DeviceHandlerMessage.h"
-#include "../serialize/EndianConverter.h"
-#include "../action/ActionMessage.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serialize/SerialLinkedListAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands,
-        uint16_t commandTimeoutSeconds):
-        CommandingServiceBase(objectId, apid, serviceId,
-	        numberOfParallelCommands, commandTimeoutSeconds) {}
-
-Service2DeviceAccess::~Service2DeviceAccess() {}
-
-
-ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
-	switch(static_cast<Subservice>(subservice)){
-	case Subservice::RAW_COMMANDING:
-	case Subservice::TOGGLE_WIRETAPPING:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		sif::error << "Invalid Subservice" << std::endl;
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
-		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
-		MessageQueueId_t* id, object_id_t* objectId) {
-    if(tcDataLen < sizeof(object_id_t)) {
-        return CommandingServiceBase::INVALID_TC;
-    }
-    SerializeAdapter::deSerialize(objectId, &tcData,
-                &tcDataLen, SerializeIF::Endianness::BIG);
-
-	ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
-	return result;
-}
-
-ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
-		MessageQueueId_t * messageQueueToSet, object_id_t *objectId) {
-	DeviceHandlerIF* possibleTarget =
-			objectManager->get<DeviceHandlerIF>(*objectId);
-	if(possibleTarget == nullptr) {
-		return CommandingServiceBase::INVALID_OBJECT;
-	}
-	*messageQueueToSet = possibleTarget->getCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
-		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
-		uint32_t* state, object_id_t objectId) {
-	switch(static_cast<Subservice>(subservice)){
-	case Subservice::RAW_COMMANDING: {
-		return prepareRawCommand(message, tcData, tcDataLen);
-	}
-	break;
-	case Subservice::TOGGLE_WIRETAPPING: {
-		return prepareWiretappingCommand(message, tcData, tcDataLen);
-	}
-	break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Service2DeviceAccess::prepareRawCommand(
-        CommandMessage* messageToSet, const uint8_t *tcData,size_t tcDataLen) {
-	RawCommand RawCommand(tcData,tcDataLen);
-	// store command into the Inter Process Communication Store
-	store_address_t storeAddress;
-	ReturnValue_t result = IPCStore->addData(&storeAddress,
-	        RawCommand.getCommand(), RawCommand.getCommandSize());
-	DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet,
-	        storeAddress);
-	return result;
-}
-
-ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand(
-		CommandMessage *messageToSet, const uint8_t *tcData,
-		size_t tcDataLen) {
-	if(tcDataLen != WiretappingToggle::WIRETAPPING_COMMAND_SIZE) {
-		return CommandingServiceBase::INVALID_TC;
-	}
-	WiretappingToggle command;
-	ReturnValue_t result = command.deSerialize(&tcData, &tcDataLen,
-	        SerializeIF::Endianness::BIG);
-	DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(messageToSet,
-			command.getWiretappingMode());
-	return result;
-}
-
-
-ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply,
-		Command_t previousCommand, uint32_t* state,
-		CommandMessage* optionalNextCommand, object_id_t objectId,
-		bool* isStep) {
-	switch(reply->getCommand()) {
-	case CommandMessage::REPLY_COMMAND_OK:
-		return HasReturnvaluesIF::RETURN_OK;
-	case CommandMessage::REPLY_REJECTED:
-		return reply->getReplyRejectedReason();
-	default:
-		return CommandingServiceBase::INVALID_REPLY;
-	}
-}
-
-// All device handlers set service 2 as default raw receiver for wiretapping
-// so we have to handle those unrequested messages.
-void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
-	switch(reply->getCommand()) {
-	case DeviceHandlerMessage::REPLY_RAW_COMMAND:
-		sendWiretappingTm(reply,
-				static_cast<uint8_t>(Subservice::WIRETAPPING_RAW_TC));
-		break;
-	case DeviceHandlerMessage::REPLY_RAW_REPLY:
-		sendWiretappingTm(reply,
-				static_cast<uint8_t>(Subservice::RAW_REPLY));
-		break;
-	default:
-		sif::error << "Unknown message in Service2DeviceAccess::"
-				"handleUnrequestedReply with command ID " <<
-				reply->getCommand() << std::endl;
-		break;
-	}
-	//Must be reached by all cases to clear message
-	reply->clear();
-}
-
-void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
-		uint8_t subservice) {
-	// Raw Wiretapping
-	// Get Address of Data from Message
-	store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply);
-	const uint8_t* data = nullptr;
-	size_t size = 0;
-	ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
-		        "handleUnrequestedReply with failure ID "<< result
-		        << std::endl;
-		return;
-	}
-
-	// Init our dummy packet and correct endianness of object ID before
-	// sending it back.
-	WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply),
-	        data);
-	TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId);
-	sendTmPacket(subservice, TmPacket.data,size, reinterpret_cast<uint8_t*>(
-			&TmPacket.objectId), sizeof(TmPacket.objectId));
-}
-
-MessageQueueId_t Service2DeviceAccess::getDeviceQueue() {
-	return commandQueue->getId();
-}
-
+#include "../pus/Service2DeviceAccess.h"
+#include "../pus/servicepackets/Service2Packets.h"
+
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../serialize/EndianConverter.h"
+#include "../action/ActionMessage.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands,
+        uint16_t commandTimeoutSeconds):
+        CommandingServiceBase(objectId, apid, serviceId,
+	        numberOfParallelCommands, commandTimeoutSeconds) {}
+
+Service2DeviceAccess::~Service2DeviceAccess() {}
+
+
+ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
+	switch(static_cast<Subservice>(subservice)){
+	case Subservice::RAW_COMMANDING:
+	case Subservice::TOGGLE_WIRETAPPING:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		sif::error << "Invalid Subservice" << std::endl;
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
+		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+		MessageQueueId_t* id, object_id_t* objectId) {
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData,
+                &tcDataLen, SerializeIF::Endianness::BIG);
+
+	ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
+	return result;
+}
+
+ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t * messageQueueToSet, object_id_t *objectId) {
+	DeviceHandlerIF* possibleTarget =
+			objectManager->get<DeviceHandlerIF>(*objectId);
+	if(possibleTarget == nullptr) {
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+	*messageQueueToSet = possibleTarget->getCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
+		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+		uint32_t* state, object_id_t objectId) {
+	switch(static_cast<Subservice>(subservice)){
+	case Subservice::RAW_COMMANDING: {
+		return prepareRawCommand(message, tcData, tcDataLen);
+	}
+	break;
+	case Subservice::TOGGLE_WIRETAPPING: {
+		return prepareWiretappingCommand(message, tcData, tcDataLen);
+	}
+	break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Service2DeviceAccess::prepareRawCommand(
+        CommandMessage* messageToSet, const uint8_t *tcData,size_t tcDataLen) {
+	RawCommand RawCommand(tcData,tcDataLen);
+	// store command into the Inter Process Communication Store
+	store_address_t storeAddress;
+	ReturnValue_t result = IPCStore->addData(&storeAddress,
+	        RawCommand.getCommand(), RawCommand.getCommandSize());
+	DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet,
+	        storeAddress);
+	return result;
+}
+
+ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand(
+		CommandMessage *messageToSet, const uint8_t *tcData,
+		size_t tcDataLen) {
+	if(tcDataLen != WiretappingToggle::WIRETAPPING_COMMAND_SIZE) {
+		return CommandingServiceBase::INVALID_TC;
+	}
+	WiretappingToggle command;
+	ReturnValue_t result = command.deSerialize(&tcData, &tcDataLen,
+	        SerializeIF::Endianness::BIG);
+	DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(messageToSet,
+			command.getWiretappingMode());
+	return result;
+}
+
+
+ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply,
+		Command_t previousCommand, uint32_t* state,
+		CommandMessage* optionalNextCommand, object_id_t objectId,
+		bool* isStep) {
+	switch(reply->getCommand()) {
+	case CommandMessage::REPLY_COMMAND_OK:
+		return HasReturnvaluesIF::RETURN_OK;
+	case CommandMessage::REPLY_REJECTED:
+		return reply->getReplyRejectedReason();
+	default:
+		return CommandingServiceBase::INVALID_REPLY;
+	}
+}
+
+// All device handlers set service 2 as default raw receiver for wiretapping
+// so we have to handle those unrequested messages.
+void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
+	switch(reply->getCommand()) {
+	case DeviceHandlerMessage::REPLY_RAW_COMMAND:
+		sendWiretappingTm(reply,
+				static_cast<uint8_t>(Subservice::WIRETAPPING_RAW_TC));
+		break;
+	case DeviceHandlerMessage::REPLY_RAW_REPLY:
+		sendWiretappingTm(reply,
+				static_cast<uint8_t>(Subservice::RAW_REPLY));
+		break;
+	default:
+		sif::error << "Unknown message in Service2DeviceAccess::"
+				"handleUnrequestedReply with command ID " <<
+				reply->getCommand() << std::endl;
+		break;
+	}
+	//Must be reached by all cases to clear message
+	reply->clear();
+}
+
+void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
+		uint8_t subservice) {
+	// Raw Wiretapping
+	// Get Address of Data from Message
+	store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply);
+	const uint8_t* data = nullptr;
+	size_t size = 0;
+	ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
+		        "handleUnrequestedReply with failure ID "<< result
+		        << std::endl;
+		return;
+	}
+
+	// Init our dummy packet and correct endianness of object ID before
+	// sending it back.
+	WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply),
+	        data);
+	TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId);
+	sendTmPacket(subservice, TmPacket.data,size, reinterpret_cast<uint8_t*>(
+			&TmPacket.objectId), sizeof(TmPacket.objectId));
+}
+
+MessageQueueId_t Service2DeviceAccess::getDeviceQueue() {
+	return commandQueue->getId();
+}
+
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index 3fb9e8301..f6aa8b521 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -1,92 +1,92 @@
-#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
-#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
-
-#include "../objectmanager/SystemObjectIF.h"
-#include "../devicehandlers/AcceptsDeviceResponsesIF.h"
-#include "../tmtcservices/CommandingServiceBase.h"
-
-/**
- * @brief   Raw Commanding and Wiretapping of devices.
- * @details
- * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
- * Dissertation Baetz p. 115, 116, 165-167.
- *
- * This service provides the capability to communicate with devices in their
- * native protocols with raw commands through the DeviceHandlerIF.
- *
- * This is a gateway service. It relays device commands to the software bus.
- * This service is very closely tied to the CommandingServiceBase
- * template class.
- *
- * There are 4 adaption points for component implementation through the
- * CommandingServiceBase.
- *
- * This service employs custom subservices exclusively.  This includes a
- * wiretapping subservice to monitor all traffic between target devices and
- * this service.
- *
- *   - TC[2,128]: Raw Commanding
- *   - TC[2,129]: Toggle Wiretapping
- *   - TM[2,130]: Wiretapping Packet TM
- *   - TM[2,131]: Wiretapping Packet TC
- * @ingroup pus_services
- */
-class Service2DeviceAccess : public CommandingServiceBase,
-		public AcceptsDeviceResponsesIF
-{
-public:
-	Service2DeviceAccess(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, uint8_t numberOfParallelCommands = 4,
-	        uint16_t commandTimeoutSeconds = 60);
-	virtual ~Service2DeviceAccess();
-
-protected:
-	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
-	ReturnValue_t isValidSubservice(uint8_t subservice) override;
-	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-	        const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) override;
-	ReturnValue_t prepareCommand(CommandMessage* message, uint8_t subservice,
-	        const uint8_t *tcData, size_t tcDataLen, uint32_t *state,
-	        object_id_t objectId) override;
-	ReturnValue_t handleReply(const CommandMessage* reply,
-				Command_t previousCommand, uint32_t *state,
-				CommandMessage* optionalNextCommand, object_id_t objectId,
-				bool *isStep) override;
-
-	/**
-	 * @brief 	Generates TM packets containing either the TC wiretapping
-	 * 			packets or the TM wiretapping packets.
-	 * Note that for service 2, all telemetry will be treated as an
-	 * unrequested reply regardless of wiretapping mode.
-	 * @param reply
-	 */
-	void handleUnrequestedReply(CommandMessage* reply) override;
-
-	MessageQueueId_t getDeviceQueue() override;
-private:
-	/**
-	 * Generates TM packets for Wiretapping Service
-	 * @param reply
-	 * @param subservice
-	 */
-	void sendWiretappingTm(CommandMessage* reply,uint8_t subservice);
-
-	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
-	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
-
-	ReturnValue_t prepareRawCommand(CommandMessage* messageToSet,
-	        const uint8_t* tcData, size_t tcDataLen);
-	ReturnValue_t prepareWiretappingCommand(CommandMessage* messageToSet,
-	        const uint8_t* tcData, size_t tcDataLen);
-
-	enum class Subservice {
-		RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol
-		TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
-		RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
-		WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
-	};
-};
-
-
-#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */
+#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
+#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
+
+#include "../objectmanager/SystemObjectIF.h"
+#include "../devicehandlers/AcceptsDeviceResponsesIF.h"
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief   Raw Commanding and Wiretapping of devices.
+ * @details
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This service provides the capability to communicate with devices in their
+ * native protocols with raw commands through the DeviceHandlerIF.
+ *
+ * This is a gateway service. It relays device commands to the software bus.
+ * This service is very closely tied to the CommandingServiceBase
+ * template class.
+ *
+ * There are 4 adaption points for component implementation through the
+ * CommandingServiceBase.
+ *
+ * This service employs custom subservices exclusively.  This includes a
+ * wiretapping subservice to monitor all traffic between target devices and
+ * this service.
+ *
+ *   - TC[2,128]: Raw Commanding
+ *   - TC[2,129]: Toggle Wiretapping
+ *   - TM[2,130]: Wiretapping Packet TM
+ *   - TM[2,131]: Wiretapping Packet TC
+ * @ingroup pus_services
+ */
+class Service2DeviceAccess : public CommandingServiceBase,
+		public AcceptsDeviceResponsesIF
+{
+public:
+	Service2DeviceAccess(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId, uint8_t numberOfParallelCommands = 4,
+	        uint16_t commandTimeoutSeconds = 60);
+	virtual ~Service2DeviceAccess();
+
+protected:
+	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+	        const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message, uint8_t subservice,
+	        const uint8_t *tcData, size_t tcDataLen, uint32_t *state,
+	        object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+				Command_t previousCommand, uint32_t *state,
+				CommandMessage* optionalNextCommand, object_id_t objectId,
+				bool *isStep) override;
+
+	/**
+	 * @brief 	Generates TM packets containing either the TC wiretapping
+	 * 			packets or the TM wiretapping packets.
+	 * Note that for service 2, all telemetry will be treated as an
+	 * unrequested reply regardless of wiretapping mode.
+	 * @param reply
+	 */
+	void handleUnrequestedReply(CommandMessage* reply) override;
+
+	MessageQueueId_t getDeviceQueue() override;
+private:
+	/**
+	 * Generates TM packets for Wiretapping Service
+	 * @param reply
+	 * @param subservice
+	 */
+	void sendWiretappingTm(CommandMessage* reply,uint8_t subservice);
+
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
+
+	ReturnValue_t prepareRawCommand(CommandMessage* messageToSet,
+	        const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t prepareWiretappingCommand(CommandMessage* messageToSet,
+	        const uint8_t* tcData, size_t tcDataLen);
+
+	enum class Subservice {
+		RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol
+		TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
+		RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
+		WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
+	};
+};
+
+
+#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index 5343b3184..02031df4b 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -1,91 +1,91 @@
-#include "../pus/Service5EventReporting.h"
-#include "../pus/servicepackets/Service5Packets.h"
-
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../events/EventManagerIF.h"
-#include "../ipc/QueueFactory.h"
-#include "../tmtcpacket/pus/TmPacketStored.h"
-
-
-Service5EventReporting::Service5EventReporting(object_id_t objectId,
-            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
-		PusServiceBase(objectId, apid, serviceId),
-		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Service5EventReporting::~Service5EventReporting(){}
-
-ReturnValue_t Service5EventReporting::performService() {
-	EventMessage message;
-	ReturnValue_t status = RETURN_OK;
-	for(uint8_t counter = 0;
-	        counter < maxNumberReportsPerCycle;
-	        counter++)
-	{
-	    // Receive messages even if reporting is disabled for now.
-	    status = eventQueue->receiveMessage(&message);
-	    if(status == MessageQueueIF::EMPTY) {
-	        return HasReturnvaluesIF::RETURN_OK;
-	    }
-
-	    if(enableEventReport) {
-	       status = generateEventReport(message);
-	       if(status != HasReturnvaluesIF::RETURN_OK) {
-	           return status;
-	       }
-	    }
-	}
-	sif::debug <<  "Service5EventReporting::generateEventReport:"
-	        " Too many events" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Service5EventReporting::generateEventReport(
-		EventMessage message)
-{
-	EventReport report(message.getEventId(),message.getReporter(),
-			message.getParameter1(),message.getParameter2());
-	TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
-			message.getSeverity(), packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(
-	        requestQueue->getDefaultDestination(),requestQueue->getId());
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "Service5EventReporting::generateEventReport:"
-		        " Could not send TM packet" << std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
-	switch(subservice) {
-	case Subservice::ENABLE: {
-		enableEventReport = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	case Subservice::DISABLE: {
-		enableEventReport = false;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	default:
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-
-// In addition to the default PUSServiceBase initialization, this service needs
-// to be registered to the event manager to listen for events.
-ReturnValue_t Service5EventReporting::initialize() {
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-				objects::EVENT_MANAGER);
-	if (manager == NULL) {
-			return RETURN_FAILED;
-	}
-	// register Service 5 as listener for events
-	ReturnValue_t result =  manager->registerListener(eventQueue->getId(),true);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-	     return result;
-	}
-	return PusServiceBase::initialize();
-}
+#include "../pus/Service5EventReporting.h"
+#include "../pus/servicepackets/Service5Packets.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../events/EventManagerIF.h"
+#include "../ipc/QueueFactory.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+
+
+Service5EventReporting::Service5EventReporting(object_id_t objectId,
+            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
+		PusServiceBase(objectId, apid, serviceId),
+		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
+	eventQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Service5EventReporting::~Service5EventReporting(){}
+
+ReturnValue_t Service5EventReporting::performService() {
+	EventMessage message;
+	ReturnValue_t status = RETURN_OK;
+	for(uint8_t counter = 0;
+	        counter < maxNumberReportsPerCycle;
+	        counter++)
+	{
+	    // Receive messages even if reporting is disabled for now.
+	    status = eventQueue->receiveMessage(&message);
+	    if(status == MessageQueueIF::EMPTY) {
+	        return HasReturnvaluesIF::RETURN_OK;
+	    }
+
+	    if(enableEventReport) {
+	       status = generateEventReport(message);
+	       if(status != HasReturnvaluesIF::RETURN_OK) {
+	           return status;
+	       }
+	    }
+	}
+	sif::debug <<  "Service5EventReporting::generateEventReport:"
+	        " Too many events" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service5EventReporting::generateEventReport(
+		EventMessage message)
+{
+	EventReport report(message.getEventId(),message.getReporter(),
+			message.getParameter1(),message.getParameter2());
+	TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
+			message.getSeverity(), packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(
+	        requestQueue->getDefaultDestination(),requestQueue->getId());
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "Service5EventReporting::generateEventReport:"
+		        " Could not send TM packet" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
+	switch(subservice) {
+	case Subservice::ENABLE: {
+		enableEventReport = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case Subservice::DISABLE: {
+		enableEventReport = false;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+
+// In addition to the default PUSServiceBase initialization, this service needs
+// to be registered to the event manager to listen for events.
+ReturnValue_t Service5EventReporting::initialize() {
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+				objects::EVENT_MANAGER);
+	if (manager == NULL) {
+			return RETURN_FAILED;
+	}
+	// register Service 5 as listener for events
+	ReturnValue_t result =  manager->registerListener(eventQueue->getId(),true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+	     return result;
+	}
+	return PusServiceBase::initialize();
+}
diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h
index 3f0c8cdf4..0b6ee9a8c 100644
--- a/pus/Service5EventReporting.h
+++ b/pus/Service5EventReporting.h
@@ -1,86 +1,86 @@
-#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-
-#include "../tmtcservices/PusServiceBase.h"
-#include "../events/EventMessage.h"
-
-/**
- * @brief Report on-board events like information or errors
- * @details
- * Full Documentation: ECSS-E70-41A p.79
- * Implements the PusServiceBase template class.
- * Documentation: Dissertation Baetz p.135,136
- *
- * This service provides for the reporting to the service user of information of
- * operational significance.
- *   1. reporting of failures or anomalies detected on-board;
- *   2. reporting of autonomous on-board actions;
- *   3. reporting of normal progress of operations and activities, e.g.
- *   detection of events which are not anomalous (such as payload events),
- *   reaching of predefined steps in an operation. Some reports can combine
- *   more than one of these events.
- *
- * Minimum capabilities of this service:
- *
- * - TM[5,1]: Normal/Progress Report
- * - TM[5,2]: Error/Anomaly Report - Low Severity
- * - TM[5,3]: Error/Anomaly Report - Medium Severity
- * - TM[5,4]: Error/Anomaly Report - High Severity
- *
- * Events can be translated by using translator files located in
- * /config/objects/ and /config/events/. Description to events can be added by
- * adding a comment behind the event definition with [//!<] as leading string
- *
- * Additional capabilities of this service:
- *
- *  - TC[5,5]: Enable Event Report Generation (Req. 6)
- *  - TC[5,6]: Disable Event Report Generation (Req. 5)
- * @author 	R. Mueller
- * @ingroup pus_services
- */
-class Service5EventReporting: public PusServiceBase {
-public:
-
-	Service5EventReporting(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
-	virtual ~Service5EventReporting();
-
-	/***
-	* Check for events and generate event reports if required.
-	* @return
-	*/
-	ReturnValue_t performService() override;
-
-	/***
-	 * Turn event generation on or off.
-	 * @return
-	 */
-	ReturnValue_t handleRequest(uint8_t subservice) override;
-
-	/**
-	 * The default PusServiceBase initialize has been overridden but is still
-	 * executed. Registers this service as a listener for events at the
-	 * EventManager.
-	 * @return
-	 */
-	ReturnValue_t initialize() override;
-
-	enum Subservice: uint8_t {
-		NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report
-		ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity
-		ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity
-		ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity
-		ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation
-		DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation
-	};
-
-private:
-	uint16_t packetSubCounter = 0;
-	MessageQueueIF* eventQueue = nullptr;
-	bool enableEventReport = true;
-	const uint8_t maxNumberReportsPerCycle;
-
-	ReturnValue_t generateEventReport(EventMessage message);
-};
-
-#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
+#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+
+#include "../tmtcservices/PusServiceBase.h"
+#include "../events/EventMessage.h"
+
+/**
+ * @brief Report on-board events like information or errors
+ * @details
+ * Full Documentation: ECSS-E70-41A p.79
+ * Implements the PusServiceBase template class.
+ * Documentation: Dissertation Baetz p.135,136
+ *
+ * This service provides for the reporting to the service user of information of
+ * operational significance.
+ *   1. reporting of failures or anomalies detected on-board;
+ *   2. reporting of autonomous on-board actions;
+ *   3. reporting of normal progress of operations and activities, e.g.
+ *   detection of events which are not anomalous (such as payload events),
+ *   reaching of predefined steps in an operation. Some reports can combine
+ *   more than one of these events.
+ *
+ * Minimum capabilities of this service:
+ *
+ * - TM[5,1]: Normal/Progress Report
+ * - TM[5,2]: Error/Anomaly Report - Low Severity
+ * - TM[5,3]: Error/Anomaly Report - Medium Severity
+ * - TM[5,4]: Error/Anomaly Report - High Severity
+ *
+ * Events can be translated by using translator files located in
+ * /config/objects/ and /config/events/. Description to events can be added by
+ * adding a comment behind the event definition with [//!<] as leading string
+ *
+ * Additional capabilities of this service:
+ *
+ *  - TC[5,5]: Enable Event Report Generation (Req. 6)
+ *  - TC[5,6]: Disable Event Report Generation (Req. 5)
+ * @author 	R. Mueller
+ * @ingroup pus_services
+ */
+class Service5EventReporting: public PusServiceBase {
+public:
+
+	Service5EventReporting(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
+	virtual ~Service5EventReporting();
+
+	/***
+	* Check for events and generate event reports if required.
+	* @return
+	*/
+	ReturnValue_t performService() override;
+
+	/***
+	 * Turn event generation on or off.
+	 * @return
+	 */
+	ReturnValue_t handleRequest(uint8_t subservice) override;
+
+	/**
+	 * The default PusServiceBase initialize has been overridden but is still
+	 * executed. Registers this service as a listener for events at the
+	 * EventManager.
+	 * @return
+	 */
+	ReturnValue_t initialize() override;
+
+	enum Subservice: uint8_t {
+		NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report
+		ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity
+		ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity
+		ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity
+		ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation
+		DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation
+	};
+
+private:
+	uint16_t packetSubCounter = 0;
+	MessageQueueIF* eventQueue = nullptr;
+	bool enableEventReport = true;
+	const uint8_t maxNumberReportsPerCycle;
+
+	ReturnValue_t generateEventReport(EventMessage message);
+};
+
+#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 7174566af..3c94071d0 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -1,142 +1,142 @@
-#include "../pus/Service8FunctionManagement.h"
-#include "../pus/servicepackets/Service8Packets.h"
-
-#include "../objectmanager/SystemObjectIF.h"
-#include "../action/HasActionsIF.h"
-#include "../devicehandlers/DeviceHandlerIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
-		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
-		uint16_t commandTimeoutSeconds):
-		CommandingServiceBase(object_id, apid, serviceId, numParallelCommands,
-		commandTimeoutSeconds) {}
-
-Service8FunctionManagement::~Service8FunctionManagement() {}
-
-
-ReturnValue_t Service8FunctionManagement::isValidSubservice(
-		uint8_t subservice) {
-	switch(static_cast<Subservice>(subservice)) {
-	case Subservice::DIRECT_COMMANDING:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject(
-		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
-		MessageQueueId_t* id, object_id_t* objectId) {
-	if(tcDataLen < sizeof(object_id_t)) {
-		return CommandingServiceBase::INVALID_TC;
-	}
-	SerializeAdapter::deSerialize(objectId, &tcData,
-			&tcDataLen, SerializeIF::Endianness::BIG);
-
-	return checkInterfaceAndAcquireMessageQueue(id,objectId);
-}
-
-ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue(
-		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-	// check HasActionIF property of target
-	HasActionsIF* possibleTarget = objectManager->get<HasActionsIF>(*objectId);
-	if(possibleTarget == nullptr){
-		return CommandingServiceBase::INVALID_OBJECT;
-	}
-	*messageQueueToSet = possibleTarget->getCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Service8FunctionManagement::prepareCommand(
-		CommandMessage* message, uint8_t subservice, const uint8_t* tcData,
-		size_t tcDataLen, uint32_t* state, object_id_t objectId) {
-	return prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
-				tcData, tcDataLen);
-}
-
-ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
-		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
-    if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
-        sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
-                << " TC size smaller thant minimum size of direct command."
-                << std::endl;
-        return CommandingServiceBase::INVALID_TC;
-    }
-
-	// Create direct command instance by extracting data from Telecommand
-	DirectCommand command(tcData, tcDataLen);
-
-	// store additional parameters into the IPC Store
-	store_address_t parameterAddress;
-	ReturnValue_t result = IPCStore->addData(&parameterAddress,
-			command.getParameters(),command.getParametersSize());
-
-	// setCommand expects a Command Message, an Action ID and a store adress
-	// pointing to additional parameters
-	ActionMessage::setCommand(message,command.getActionId(),parameterAddress);
-	return result;
-}
-
-
-ReturnValue_t Service8FunctionManagement::handleReply(
-		const CommandMessage* reply, Command_t previousCommand,
-		uint32_t* state, CommandMessage* optionalNextCommand,
-		object_id_t objectId, bool* isStep) {
-	Command_t replyId = reply->getCommand();
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	ActionId_t actionId = ActionMessage::getActionId(reply);
-	ReturnValue_t returnCode = ActionMessage::getReturnCode(reply);
-
-	switch(replyId)  {
-	case ActionMessage::COMPLETION_SUCCESS: {
-		DirectReply completionReply(objectId, actionId,returnCode);
-		result = CommandingServiceBase::EXECUTION_COMPLETE;
-		break;
-	}
-	case ActionMessage::STEP_SUCCESS: {
-		*isStep = true;
-		result = HasReturnvaluesIF::RETURN_OK;
-		break;
-	}
-	case ActionMessage::DATA_REPLY: {
-	    result = handleDataReply(reply, objectId, actionId);
-		break;
-	}
-	case ActionMessage::STEP_FAILED:
-		*isStep = true;
-		/*No break, falls through*/
-	case ActionMessage::COMPLETION_FAILED:
-		result = ActionMessage::getReturnCode(reply);
-		break;
-	default:
-		result = INVALID_REPLY;
-	}
-	return result;
-}
-
-ReturnValue_t Service8FunctionManagement::handleDataReply(
-        const CommandMessage* reply, object_id_t objectId,
-        ActionId_t actionId) {
-    store_address_t storeId = ActionMessage::getStoreId(reply);
-    size_t size = 0;
-    const uint8_t * buffer = nullptr;
-    ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
-    if(result != RETURN_OK) {
-        sif::error << "Service 8: Could not retrieve data for data reply"
-                << std::endl;
-        return result;
-    }
-    DataReply dataReply(objectId, actionId, buffer, size);
-    result = sendTmPacket(static_cast<uint8_t>(
-            Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
-
-    auto deletionResult = IPCStore->deleteData(storeId);
-    if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
-        sif::warning << "Service8FunctionManagement::handleReply: Deletion"
-                << " of data in pool failed." << std::endl;
-    }
-    return result;
-}
+#include "../pus/Service8FunctionManagement.h"
+#include "../pus/servicepackets/Service8Packets.h"
+
+#include "../objectmanager/SystemObjectIF.h"
+#include "../action/HasActionsIF.h"
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
+		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
+		uint16_t commandTimeoutSeconds):
+		CommandingServiceBase(object_id, apid, serviceId, numParallelCommands,
+		commandTimeoutSeconds) {}
+
+Service8FunctionManagement::~Service8FunctionManagement() {}
+
+
+ReturnValue_t Service8FunctionManagement::isValidSubservice(
+		uint8_t subservice) {
+	switch(static_cast<Subservice>(subservice)) {
+	case Subservice::DIRECT_COMMANDING:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject(
+		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+		MessageQueueId_t* id, object_id_t* objectId) {
+	if(tcDataLen < sizeof(object_id_t)) {
+		return CommandingServiceBase::INVALID_TC;
+	}
+	SerializeAdapter::deSerialize(objectId, &tcData,
+			&tcDataLen, SerializeIF::Endianness::BIG);
+
+	return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+	// check HasActionIF property of target
+	HasActionsIF* possibleTarget = objectManager->get<HasActionsIF>(*objectId);
+	if(possibleTarget == nullptr){
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+	*messageQueueToSet = possibleTarget->getCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service8FunctionManagement::prepareCommand(
+		CommandMessage* message, uint8_t subservice, const uint8_t* tcData,
+		size_t tcDataLen, uint32_t* state, object_id_t objectId) {
+	return prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
+				tcData, tcDataLen);
+}
+
+ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
+		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
+    if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
+        sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
+                << " TC size smaller thant minimum size of direct command."
+                << std::endl;
+        return CommandingServiceBase::INVALID_TC;
+    }
+
+	// Create direct command instance by extracting data from Telecommand
+	DirectCommand command(tcData, tcDataLen);
+
+	// store additional parameters into the IPC Store
+	store_address_t parameterAddress;
+	ReturnValue_t result = IPCStore->addData(&parameterAddress,
+			command.getParameters(),command.getParametersSize());
+
+	// setCommand expects a Command Message, an Action ID and a store adress
+	// pointing to additional parameters
+	ActionMessage::setCommand(message,command.getActionId(),parameterAddress);
+	return result;
+}
+
+
+ReturnValue_t Service8FunctionManagement::handleReply(
+		const CommandMessage* reply, Command_t previousCommand,
+		uint32_t* state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool* isStep) {
+	Command_t replyId = reply->getCommand();
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	ActionId_t actionId = ActionMessage::getActionId(reply);
+	ReturnValue_t returnCode = ActionMessage::getReturnCode(reply);
+
+	switch(replyId)  {
+	case ActionMessage::COMPLETION_SUCCESS: {
+		DirectReply completionReply(objectId, actionId,returnCode);
+		result = CommandingServiceBase::EXECUTION_COMPLETE;
+		break;
+	}
+	case ActionMessage::STEP_SUCCESS: {
+		*isStep = true;
+		result = HasReturnvaluesIF::RETURN_OK;
+		break;
+	}
+	case ActionMessage::DATA_REPLY: {
+	    result = handleDataReply(reply, objectId, actionId);
+		break;
+	}
+	case ActionMessage::STEP_FAILED:
+		*isStep = true;
+		/*No break, falls through*/
+	case ActionMessage::COMPLETION_FAILED:
+		result = ActionMessage::getReturnCode(reply);
+		break;
+	default:
+		result = INVALID_REPLY;
+	}
+	return result;
+}
+
+ReturnValue_t Service8FunctionManagement::handleDataReply(
+        const CommandMessage* reply, object_id_t objectId,
+        ActionId_t actionId) {
+    store_address_t storeId = ActionMessage::getStoreId(reply);
+    size_t size = 0;
+    const uint8_t * buffer = nullptr;
+    ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
+    if(result != RETURN_OK) {
+        sif::error << "Service 8: Could not retrieve data for data reply"
+                << std::endl;
+        return result;
+    }
+    DataReply dataReply(objectId, actionId, buffer, size);
+    result = sendTmPacket(static_cast<uint8_t>(
+            Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
+
+    auto deletionResult = IPCStore->deleteData(storeId);
+    if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "Service8FunctionManagement::handleReply: Deletion"
+                << " of data in pool failed." << std::endl;
+    }
+    return result;
+}
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index 165235332..b5ebcda8b 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -1,67 +1,67 @@
-#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
-#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
-
-#include "../action/ActionMessage.h"
-#include "../tmtcservices/CommandingServiceBase.h"
-
-/**
- * @brief Functional commanding.
- * Full Documentation: ECSS-E-ST-70-41C p.64, p. 451
- * Dissertation Baetz p. 115, 116, 165-167
- *
- * This service provides the capability to perform functions of an
- * application process and provides high-level commanding as opposed to the
- * Raw Access provided by Service 2. Examples for these functions can include
- * control and operation of payload or the AOCS subsystem.
- * This service will be the primary means to control the spacecraft as it is
- * considered safer than the Raw Access provided
- * by Service 2 and is generally sufficient for most tasks.
- *
- * This is a gateway service. It relays device commands using the software bus.
- * This service is very closely tied to the Commanding Service Base template
- * class. There is constant interaction between this Service Base und a
- * subclass like this service.
- *
- * Service Capability:
- * 	 - TC[8,128]: Direct Commanding
- *   - TM[8,130]: Direct Commanding Data Reply
- *
- * @ingroup pus_services
- */
-class Service8FunctionManagement : public CommandingServiceBase
-{
-public:
-	Service8FunctionManagement(object_id_t objectId, uint16_t apid,
-			uint8_t serviceId, uint8_t numParallelCommands = 4,
-			uint16_t commandTimeoutSeconds = 60);
-	virtual ~Service8FunctionManagement();
-
-protected:
-	/* CSB abstract functions implementation . See CSB documentation. */
-	ReturnValue_t isValidSubservice(uint8_t subservice) override;
-	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) override;
-	ReturnValue_t prepareCommand(CommandMessage* message,
-				uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-				uint32_t *state, object_id_t objectId) override;
-	ReturnValue_t handleReply(const CommandMessage* reply,
-				Command_t previousCommand, uint32_t *state,
-				CommandMessage* optionalNextCommand, object_id_t objectId,
-				bool *isStep) override;
-
-private:
-	enum class Subservice {
-		DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding
-		DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply
-	};
-
-	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
-	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
-	ReturnValue_t prepareDirectCommand(CommandMessage* message,
-			const uint8_t* tcData, size_t tcDataLen);
-	ReturnValue_t handleDataReply(const CommandMessage* reply,
-	        object_id_t objectId, ActionId_t actionId);
-};
-
-#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
+#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
+#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
+
+#include "../action/ActionMessage.h"
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief Functional commanding.
+ * Full Documentation: ECSS-E-ST-70-41C p.64, p. 451
+ * Dissertation Baetz p. 115, 116, 165-167
+ *
+ * This service provides the capability to perform functions of an
+ * application process and provides high-level commanding as opposed to the
+ * Raw Access provided by Service 2. Examples for these functions can include
+ * control and operation of payload or the AOCS subsystem.
+ * This service will be the primary means to control the spacecraft as it is
+ * considered safer than the Raw Access provided
+ * by Service 2 and is generally sufficient for most tasks.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * This service is very closely tied to the Commanding Service Base template
+ * class. There is constant interaction between this Service Base und a
+ * subclass like this service.
+ *
+ * Service Capability:
+ * 	 - TC[8,128]: Direct Commanding
+ *   - TM[8,130]: Direct Commanding Data Reply
+ *
+ * @ingroup pus_services
+ */
+class Service8FunctionManagement : public CommandingServiceBase
+{
+public:
+	Service8FunctionManagement(object_id_t objectId, uint16_t apid,
+			uint8_t serviceId, uint8_t numParallelCommands = 4,
+			uint16_t commandTimeoutSeconds = 60);
+	virtual ~Service8FunctionManagement();
+
+protected:
+	/* CSB abstract functions implementation . See CSB documentation. */
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message,
+				uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+				uint32_t *state, object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+				Command_t previousCommand, uint32_t *state,
+				CommandMessage* optionalNextCommand, object_id_t objectId,
+				bool *isStep) override;
+
+private:
+	enum class Subservice {
+		DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding
+		DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply
+	};
+
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
+	ReturnValue_t prepareDirectCommand(CommandMessage* message,
+			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t handleDataReply(const CommandMessage* reply,
+	        object_id_t objectId, ActionId_t actionId);
+};
+
+#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index f4acbb615..8c5cb005f 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -1,166 +1,166 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcservices/VerificationCodes.h"
-
-/**
- * @defgroup spacepackets PUS Packet Definitions
- *  This group contains all implemented TM or TM packages that are sent to
- *  or sent by the OBC.They are exported later to display
- *  packet structures in Mission Information Base (MIB).
- */
-
-/**
- * @brief 	FailureReport class to serialize a failure report
- * @brief 	Subservice 1, 3, 5, 7
- * @ingroup spacepackets
- */
-class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
-public:
-	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
-			uint16_t packetSequenceControl_, uint8_t stepNumber_,
-			ReturnValue_t errorCode_, uint32_t errorParameter1_,
-			uint32_t errorParameter2_) :
-			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
-			stepNumber(stepNumber_), errorCode(errorCode_),
-			errorParameter1(errorParameter1_), errorParameter2(errorParameter2_),
-			failureSubtype(failureSubtype_) {}
-
-	/**
-	 * This function is called by the FSFW when calling the tm packet send
-	 * function and supplying the SerializeIF* as parameter
-	 * @param buffer Object content is serialized into the buffer
-	 * @param size
-	 * @param max_size
-	 * @param bigEndian
-	 * @return
-	 */
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-	        size_t maxSize, SerializeIF::Endianness streamEndianness
-	        ) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
-			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
-			        maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		result = SerializeAdapter::serialize(&errorCode, buffer, size,
-		        maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&errorParameter1, buffer, size,
-		        maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		result = SerializeAdapter::serialize(&errorParameter2, buffer, size,
-		        maxSize, streamEndianness);
-		return result;
-	}
-
-
-	virtual size_t getSerializedSize() const {
-		size_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&packetId);
-		size += sizeof(packetSequenceControl);
-		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
-			size += SerializeAdapter::getSerializedSize(&stepNumber);
-		}
-		size += SerializeAdapter::getSerializedSize(&errorCode);
-		size += SerializeAdapter::getSerializedSize(&errorParameter1);
-		size += SerializeAdapter::getSerializedSize(&errorParameter2);
-		return size;
-	}
-
-	/**
-	 * Deserialization is not allowed for a report.
-	 * @param buffer
-	 * @param size
-	 * @param bigEndian
-	 * @return
-	 */
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
-	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
-	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
-	ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file
-	uint32_t errorParameter1;
-	uint32_t errorParameter2;
-	const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE]
-};
-
-/**
- * @brief       Subservices 2, 4, 6, 8
- * @ingroup     spacepackets
- */
-class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
-public:
-	SuccessReport(uint8_t subtype_, uint16_t packetId_,
-			uint16_t packetSequenceControl_,uint8_t stepNumber_) :
-			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
-			stepNumber(stepNumber_), subtype(subtype_) {}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, SerializeIF::Endianness streamEndianness
-			) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
-			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
-					maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		size_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&packetId);
-		size += sizeof(packetSequenceControl);
-		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
-			size += SerializeAdapter::getSerializedSize(&stepNumber);
-		}
-		return size;
-
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
-	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
-	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
-	const uint8_t subtype; //!< [EXPORT] : [IGNORE]
-};
-
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcservices/VerificationCodes.h"
+
+/**
+ * @defgroup spacepackets PUS Packet Definitions
+ *  This group contains all implemented TM or TM packages that are sent to
+ *  or sent by the OBC.They are exported later to display
+ *  packet structures in Mission Information Base (MIB).
+ */
+
+/**
+ * @brief 	FailureReport class to serialize a failure report
+ * @brief 	Subservice 1, 3, 5, 7
+ * @ingroup spacepackets
+ */
+class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
+public:
+	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
+			uint16_t packetSequenceControl_, uint8_t stepNumber_,
+			ReturnValue_t errorCode_, uint32_t errorParameter1_,
+			uint32_t errorParameter2_) :
+			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
+			stepNumber(stepNumber_), errorCode(errorCode_),
+			errorParameter1(errorParameter1_), errorParameter2(errorParameter2_),
+			failureSubtype(failureSubtype_) {}
+
+	/**
+	 * This function is called by the FSFW when calling the tm packet send
+	 * function and supplying the SerializeIF* as parameter
+	 * @param buffer Object content is serialized into the buffer
+	 * @param size
+	 * @param max_size
+	 * @param bigEndian
+	 * @return
+	 */
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	        size_t maxSize, SerializeIF::Endianness streamEndianness
+	        ) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
+			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
+			        maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		result = SerializeAdapter::serialize(&errorCode, buffer, size,
+		        maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&errorParameter1, buffer, size,
+		        maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		result = SerializeAdapter::serialize(&errorParameter2, buffer, size,
+		        maxSize, streamEndianness);
+		return result;
+	}
+
+
+	virtual size_t getSerializedSize() const {
+		size_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&packetId);
+		size += sizeof(packetSequenceControl);
+		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
+			size += SerializeAdapter::getSerializedSize(&stepNumber);
+		}
+		size += SerializeAdapter::getSerializedSize(&errorCode);
+		size += SerializeAdapter::getSerializedSize(&errorParameter1);
+		size += SerializeAdapter::getSerializedSize(&errorParameter2);
+		return size;
+	}
+
+	/**
+	 * Deserialization is not allowed for a report.
+	 * @param buffer
+	 * @param size
+	 * @param bigEndian
+	 * @return
+	 */
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
+	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
+	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
+	ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file
+	uint32_t errorParameter1;
+	uint32_t errorParameter2;
+	const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE]
+};
+
+/**
+ * @brief       Subservices 2, 4, 6, 8
+ * @ingroup     spacepackets
+ */
+class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
+public:
+	SuccessReport(uint8_t subtype_, uint16_t packetId_,
+			uint16_t packetSequenceControl_,uint8_t stepNumber_) :
+			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
+			stepNumber(stepNumber_), subtype(subtype_) {}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, SerializeIF::Endianness streamEndianness
+			) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
+			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
+					maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		size_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&packetId);
+		size += sizeof(packetSequenceControl);
+		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
+			size += SerializeAdapter::getSerializedSize(&stepNumber);
+		}
+		return size;
+
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
+	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
+	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
+	const uint8_t subtype; //!< [EXPORT] : [IGNORE]
+};
+
+#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */
diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h
index 6a700b50a..efcf65fcf 100644
--- a/pus/servicepackets/Service200Packets.h
+++ b/pus/servicepackets/Service200Packets.h
@@ -1,63 +1,63 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
-
-#include "../../serialize/SerialLinkedListAdapter.h"
-#include "../../modes/ModeMessage.h"
-#include "../../serialize/SerializeIF.h"
-
-/**
- * @brief Subservice 1, 2, 3, 4, 5
- * @ingroup spacepackets
- */
-class ModePacket : public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6
-public:
-
-	ModePacket() {
-		setLinks();
-	}
-
-	ModePacket(object_id_t objectId, Mode_t mode, Submode_t submode) :
-	        objectId(objectId), mode(mode), submode(submode) {
-		setLinks();
-	}
-
-	Mode_t getMode() {
-		return mode.entry;
-	}
-
-	Submode_t getSubmode() {
-		return submode.entry;
-	}
-
-	// Forbid copying, pointers are used.
-	ModePacket(const ModePacket&) = delete;
-	ModePacket& operator=(const ModePacket&) = delete;
-private:
-
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&mode);
-		mode.setNext(&submode);
-	}
-	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Target or source object
-	SerializeElement<Mode_t> mode; //!< [EXPORT] : [COMMENT] 0: MODE_OFF, 1: MODE_ON, 2: MODE_NORMAL, 3: MODE_RAW
-	SerializeElement<Submode_t> submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible
-};
-
-/**
- * @brief Subservice 7
- * @ingroup spacepackets
- */
-class CantReachModePacket: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 7
-public:
-    CantReachModePacket(object_id_t objectId, ReturnValue_t reason):
-            objectId(objectId), reason(reason) {
-        setStart(&this->objectId);
-        this->objectId.setNext(&this->reason);
-    }
-
-    SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Reply source object
-	SerializeElement<ReturnValue_t> reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached
-};
-
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
+#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../modes/ModeMessage.h"
+#include "../../serialize/SerializeIF.h"
+
+/**
+ * @brief Subservice 1, 2, 3, 4, 5
+ * @ingroup spacepackets
+ */
+class ModePacket : public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6
+public:
+
+	ModePacket() {
+		setLinks();
+	}
+
+	ModePacket(object_id_t objectId, Mode_t mode, Submode_t submode) :
+	        objectId(objectId), mode(mode), submode(submode) {
+		setLinks();
+	}
+
+	Mode_t getMode() {
+		return mode.entry;
+	}
+
+	Submode_t getSubmode() {
+		return submode.entry;
+	}
+
+	// Forbid copying, pointers are used.
+	ModePacket(const ModePacket&) = delete;
+	ModePacket& operator=(const ModePacket&) = delete;
+private:
+
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&mode);
+		mode.setNext(&submode);
+	}
+	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Target or source object
+	SerializeElement<Mode_t> mode; //!< [EXPORT] : [COMMENT] 0: MODE_OFF, 1: MODE_ON, 2: MODE_NORMAL, 3: MODE_RAW
+	SerializeElement<Submode_t> submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible
+};
+
+/**
+ * @brief Subservice 7
+ * @ingroup spacepackets
+ */
+class CantReachModePacket: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 7
+public:
+    CantReachModePacket(object_id_t objectId, ReturnValue_t reason):
+            objectId(objectId), reason(reason) {
+        setStart(&this->objectId);
+        this->objectId.setNext(&this->reason);
+    }
+
+    SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Reply source object
+	SerializeElement<ReturnValue_t> reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached
+};
+
+#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
diff --git a/pus/servicepackets/Service201Packets.h b/pus/servicepackets/Service201Packets.h
index 5ff5dcd51..8dce88e5b 100644
--- a/pus/servicepackets/Service201Packets.h
+++ b/pus/servicepackets/Service201Packets.h
@@ -1,48 +1,48 @@
-#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
-#define FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
-
-#include "../../serialize/SerialLinkedListAdapter.h"
-#include "../../serialize/SerializeIF.h"
-#include "../../health/HasHealthIF.h"
-
-class HealthCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1
-public:
-
-	HealthCommand() {
-		setLinks();
-	}
-
-	HasHealthIF::HealthState getHealth() {
-		return static_cast<HasHealthIF::HealthState>(health.entry);
-	}
-private:
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&health);
-	}
-	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Target object Id
-	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] Health to set
-};
-
-
-class HealthSetReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 2
-public:
-	HealthSetReply(uint8_t health_, uint8_t oldHealth_):
-		health(health_), oldHealth(oldHealth_)
-	{
-		setLinks();
-	}
-
-private:
-	HealthSetReply(const HealthSetReply &reply);
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&health);
-		health.setNext(&oldHealth);
-	}
-	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Source object ID
-	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] New Health
-	SerializeElement<uint8_t> oldHealth; //!< [EXPORT] : [COMMENT] Old Health
-};
-
-#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_ */
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
+
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serialize/SerializeIF.h"
+#include "../../health/HasHealthIF.h"
+
+class HealthCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1
+public:
+
+	HealthCommand() {
+		setLinks();
+	}
+
+	HasHealthIF::HealthState getHealth() {
+		return static_cast<HasHealthIF::HealthState>(health.entry);
+	}
+private:
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&health);
+	}
+	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Target object Id
+	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] Health to set
+};
+
+
+class HealthSetReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 2
+public:
+	HealthSetReply(uint8_t health_, uint8_t oldHealth_):
+		health(health_), oldHealth(oldHealth_)
+	{
+		setLinks();
+	}
+
+private:
+	HealthSetReply(const HealthSetReply &reply);
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&health);
+		health.setNext(&oldHealth);
+	}
+	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Source object ID
+	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] New Health
+	SerializeElement<uint8_t> oldHealth; //!< [EXPORT] : [COMMENT] Old Health
+};
+
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_ */
diff --git a/pus/servicepackets/Service2Packets.h b/pus/servicepackets/Service2Packets.h
index a0b1305d7..d4f3fb170 100644
--- a/pus/servicepackets/Service2Packets.h
+++ b/pus/servicepackets/Service2Packets.h
@@ -1,76 +1,76 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
-
-#include "../../action/ActionMessage.h"
-#include "../../objectmanager/SystemObjectIF.h"
-#include "../../serialize/SerialLinkedListAdapter.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-/**
- * @brief Subservice 128
- * @ingroup spacepackets
- */
-class RawCommand { //!< [EXPORT] : [SUBSERVICE] 128
-public:
-	RawCommand(const uint8_t* buffer, size_t size) {
-		// Deserialize Adapter to get correct endianness
-		SerializeAdapter::deSerialize(&objectId, &buffer, &size,
-		        SerializeIF::Endianness::BIG);
-		commandBuffer = buffer;
-		// size is decremented by AutoSerializeAdapter,
-		// remaining size is data size
-		dataSize = size;
-	}
-	object_id_t getObjectId() const {
-		return objectId;
-	}
-
-	const uint8_t*  getCommand() {
-		return commandBuffer;
-	}
-
-	size_t getCommandSize() const {
-		return dataSize;
-	}
-private:
-	object_id_t objectId = 0;
-	const uint8_t* commandBuffer = nullptr; //!< [EXPORT] : [MAXSIZE] 256 Bytes
-	size_t dataSize = 0; //!< [EXPORT] : [IGNORE]
-};
-
-
-/**
- * @brief Subservice 129: Command packet to set wiretapping mode
- * @ingroup spacepackets
- */
-class WiretappingToggle: public SerialLinkedListAdapter<SerializeIF>{ //!< [EXPORT] : [SUBSERVICE] 129
-public:
-	static const size_t WIRETAPPING_COMMAND_SIZE = 5;
-	WiretappingToggle(){
-		setStart(&objectId);
-		objectId.setNext(&wiretappingMode);
-	}
-
-	uint8_t getWiretappingMode() const {
-		return wiretappingMode.entry;
-	}
-private:
-	SerializeElement<object_id_t> objectId;
-	SerializeElement<uint8_t> wiretappingMode; //!< [EXPORT] : [INPUT] Mode 0: OFF, Mode 1: RAW
-};
-
-
-/**
- * @brief Subservices 130 and 131: TM packets
- * @ingroup spacepackets
- */
-class WiretappingPacket { //!< [EXPORT] : [SUBSERVICE] 130, 131
-public:
-	object_id_t objectId; //!< [EXPORT] : [COMMENT] Object ID of source object
-	const uint8_t* data; //!< [EXPORT] : [MAXSIZE] Raw Command Max. Size
-	WiretappingPacket(object_id_t objectId, const uint8_t* buffer):
-	    objectId(objectId), data(buffer) {
-	}
-};
-
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
+#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+
+#include "../../action/ActionMessage.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+/**
+ * @brief Subservice 128
+ * @ingroup spacepackets
+ */
+class RawCommand { //!< [EXPORT] : [SUBSERVICE] 128
+public:
+	RawCommand(const uint8_t* buffer, size_t size) {
+		// Deserialize Adapter to get correct endianness
+		SerializeAdapter::deSerialize(&objectId, &buffer, &size,
+		        SerializeIF::Endianness::BIG);
+		commandBuffer = buffer;
+		// size is decremented by AutoSerializeAdapter,
+		// remaining size is data size
+		dataSize = size;
+	}
+	object_id_t getObjectId() const {
+		return objectId;
+	}
+
+	const uint8_t*  getCommand() {
+		return commandBuffer;
+	}
+
+	size_t getCommandSize() const {
+		return dataSize;
+	}
+private:
+	object_id_t objectId = 0;
+	const uint8_t* commandBuffer = nullptr; //!< [EXPORT] : [MAXSIZE] 256 Bytes
+	size_t dataSize = 0; //!< [EXPORT] : [IGNORE]
+};
+
+
+/**
+ * @brief Subservice 129: Command packet to set wiretapping mode
+ * @ingroup spacepackets
+ */
+class WiretappingToggle: public SerialLinkedListAdapter<SerializeIF>{ //!< [EXPORT] : [SUBSERVICE] 129
+public:
+	static const size_t WIRETAPPING_COMMAND_SIZE = 5;
+	WiretappingToggle(){
+		setStart(&objectId);
+		objectId.setNext(&wiretappingMode);
+	}
+
+	uint8_t getWiretappingMode() const {
+		return wiretappingMode.entry;
+	}
+private:
+	SerializeElement<object_id_t> objectId;
+	SerializeElement<uint8_t> wiretappingMode; //!< [EXPORT] : [INPUT] Mode 0: OFF, Mode 1: RAW
+};
+
+
+/**
+ * @brief Subservices 130 and 131: TM packets
+ * @ingroup spacepackets
+ */
+class WiretappingPacket { //!< [EXPORT] : [SUBSERVICE] 130, 131
+public:
+	object_id_t objectId; //!< [EXPORT] : [COMMENT] Object ID of source object
+	const uint8_t* data; //!< [EXPORT] : [MAXSIZE] Raw Command Max. Size
+	WiretappingPacket(object_id_t objectId, const uint8_t* buffer):
+	    objectId(objectId), data(buffer) {
+	}
+};
+
+#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h
index 0b52be3c9..9655608aa 100644
--- a/pus/servicepackets/Service5Packets.h
+++ b/pus/servicepackets/Service5Packets.h
@@ -1,76 +1,76 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcservices/VerificationCodes.h"
-
-
-/**
- * @brief Subservice 1, 2, 3, 4
- * Structure of Event Report.
- * It consists of:
- *      1. Report ID(RID). This is the Event ID in the FSFW
- *      2. Object ID of the reporter (e.g. subsystem)
- *      2. Parameter 1
- *      3. Parameter 2
- *
- * @ingroup spacepackets
- */
-class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
-public:
-
-	EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
-			uint32_t parameter2_):
-			reportId(reportId_),objectId(objectId_), parameter1(parameter1_),
-			parameter2(parameter2_) {}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override
-	{
-		ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&objectId, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&parameter1, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&parameter2, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		uint32_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&reportId);
-		size += SerializeAdapter::getSerializedSize(&objectId);
-		size += SerializeAdapter::getSerializedSize(&parameter1);
-		size += SerializeAdapter::getSerializedSize(&parameter2);
-		return size;
-
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	EventId_t reportId;
-	object_id_t objectId;
-	uint32_t parameter1;
-	uint32_t parameter2;
-};
-
-
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcservices/VerificationCodes.h"
+
+
+/**
+ * @brief Subservice 1, 2, 3, 4
+ * Structure of Event Report.
+ * It consists of:
+ *      1. Report ID(RID). This is the Event ID in the FSFW
+ *      2. Object ID of the reporter (e.g. subsystem)
+ *      2. Parameter 1
+ *      3. Parameter 2
+ *
+ * @ingroup spacepackets
+ */
+class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
+public:
+
+	EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
+			uint32_t parameter2_):
+			reportId(reportId_),objectId(objectId_), parameter1(parameter1_),
+			parameter2(parameter2_) {}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override
+	{
+		ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&objectId, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&parameter1, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&parameter2, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		uint32_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&reportId);
+		size += SerializeAdapter::getSerializedSize(&objectId);
+		size += SerializeAdapter::getSerializedSize(&parameter1);
+		size += SerializeAdapter::getSerializedSize(&parameter2);
+		return size;
+
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	EventId_t reportId;
+	object_id_t objectId;
+	uint32_t parameter1;
+	uint32_t parameter2;
+};
+
+
+#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
index d16309ec8..14f8b6e6e 100644
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@@ -1,121 +1,121 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
-
-#include "../../action/ActionMessage.h"
-#include "../../objectmanager/SystemObjectIF.h"
-#include "../../serialize/SerialBufferAdapter.h"
-#include "../../serialize/SerializeElement.h"
-#include "../../serialize/SerialLinkedListAdapter.h"
-#include "../../serialize/SerialFixedArrayListAdapter.h"
-
-
-/**
- * @brief Subservice 128
- * @ingroup spacepackets
- */
-class DirectCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
-public:
-
-	DirectCommand(const uint8_t* tcData, size_t size) {
-		SerializeAdapter::deSerialize(&objectId, &tcData, &size,
-		        SerializeIF::Endianness::BIG);
-		SerializeAdapter::deSerialize(&actionId, &tcData, &size,
-		        SerializeIF::Endianness::BIG);
-		parameterBuffer = tcData;
-		parametersSize = size;
-	}
-
-	ActionId_t getActionId() const {
-		return actionId;
-	}
-
-	object_id_t getObjectId() const {
-		return objectId;
-	}
-
-	const uint8_t*  getParameters() {
-		return parameterBuffer;
-	}
-
-	uint32_t getParametersSize() const {
-		return parametersSize;
-	}
-
-private:
-	DirectCommand(const DirectCommand &command);
-	object_id_t objectId;
-	ActionId_t actionId;
-	uint32_t parametersSize; //!< [EXPORT] : [IGNORE]
-	const uint8_t * parameterBuffer; //!< [EXPORT] : [MAXSIZE] 65535 Bytes
-
-};
-
-
-/**
- * @brief Subservice 130
- * Data reply (subservice 130) consists of
- *   1. Target Object ID
- *   2. Action ID
- *   3. Data
- * @ingroup spacepackets
- */
-class DataReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 130
-public:
-	typedef uint16_t typeOfMaxDataSize;
-	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
-	DataReply(object_id_t objectId_, ActionId_t actionId_,
-		const uint8_t * replyDataBuffer_ = NULL, uint16_t replyDataSize_ = 0):
-		objectId(objectId_), actionId(actionId_), replyData(replyDataBuffer_,replyDataSize_){
-		setLinks();
-	}
-
-private:
-	DataReply(const DataReply &reply);
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&actionId);
-		actionId.setNext(&replyData);
-	}
-	SerializeElement<object_id_t> objectId;
-	SerializeElement<ActionId_t> actionId;
-	SerializeElement<SerialBufferAdapter<uint16_t>> replyData;
-};
-
-
-/**
- * @brief Subservice 132
- * @details
- * Not used yet. Telecommand Verification takes care of this.
- * @ingroup spacepackets
- */
-class DirectReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 132
-public:
-	typedef uint16_t typeOfMaxDataSize;
-	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
-
-	DirectReply(object_id_t objectId_, ActionId_t actionId_, ReturnValue_t returnCode_,
-			bool isStep_ = false, uint8_t step_ = 0):
-			isStep(isStep_), objectId(objectId_), actionId(actionId_),
-			returnCode(returnCode_),step(step_)  {
-		setLinks();
-	}
-private:
-
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&actionId);
-		actionId.setNext(&returnCode);
-		if(isStep) {
-			returnCode.setNext(&step);
-		}
-	}
-
-	bool isStep; //!< [EXPORT] : [IGNORE]
-	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [IGNORE]
-	SerializeElement<ActionId_t> actionId; //!< [EXPORT] : [IGNORE]
-	SerializeElement<ReturnValue_t> returnCode; //!< [EXPORT] : [IGNORE]
-	SerializeElement<uint8_t> step; //!< [EXPORT] : [OPTIONAL] [IGNORE]
-
-};
-
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */
+#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+
+#include "../../action/ActionMessage.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../serialize/SerialBufferAdapter.h"
+#include "../../serialize/SerializeElement.h"
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serialize/SerialFixedArrayListAdapter.h"
+
+
+/**
+ * @brief Subservice 128
+ * @ingroup spacepackets
+ */
+class DirectCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
+public:
+
+	DirectCommand(const uint8_t* tcData, size_t size) {
+		SerializeAdapter::deSerialize(&objectId, &tcData, &size,
+		        SerializeIF::Endianness::BIG);
+		SerializeAdapter::deSerialize(&actionId, &tcData, &size,
+		        SerializeIF::Endianness::BIG);
+		parameterBuffer = tcData;
+		parametersSize = size;
+	}
+
+	ActionId_t getActionId() const {
+		return actionId;
+	}
+
+	object_id_t getObjectId() const {
+		return objectId;
+	}
+
+	const uint8_t*  getParameters() {
+		return parameterBuffer;
+	}
+
+	uint32_t getParametersSize() const {
+		return parametersSize;
+	}
+
+private:
+	DirectCommand(const DirectCommand &command);
+	object_id_t objectId;
+	ActionId_t actionId;
+	uint32_t parametersSize; //!< [EXPORT] : [IGNORE]
+	const uint8_t * parameterBuffer; //!< [EXPORT] : [MAXSIZE] 65535 Bytes
+
+};
+
+
+/**
+ * @brief Subservice 130
+ * Data reply (subservice 130) consists of
+ *   1. Target Object ID
+ *   2. Action ID
+ *   3. Data
+ * @ingroup spacepackets
+ */
+class DataReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 130
+public:
+	typedef uint16_t typeOfMaxDataSize;
+	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
+	DataReply(object_id_t objectId_, ActionId_t actionId_,
+		const uint8_t * replyDataBuffer_ = NULL, uint16_t replyDataSize_ = 0):
+		objectId(objectId_), actionId(actionId_), replyData(replyDataBuffer_,replyDataSize_){
+		setLinks();
+	}
+
+private:
+	DataReply(const DataReply &reply);
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&actionId);
+		actionId.setNext(&replyData);
+	}
+	SerializeElement<object_id_t> objectId;
+	SerializeElement<ActionId_t> actionId;
+	SerializeElement<SerialBufferAdapter<uint16_t>> replyData;
+};
+
+
+/**
+ * @brief Subservice 132
+ * @details
+ * Not used yet. Telecommand Verification takes care of this.
+ * @ingroup spacepackets
+ */
+class DirectReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 132
+public:
+	typedef uint16_t typeOfMaxDataSize;
+	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
+
+	DirectReply(object_id_t objectId_, ActionId_t actionId_, ReturnValue_t returnCode_,
+			bool isStep_ = false, uint8_t step_ = 0):
+			isStep(isStep_), objectId(objectId_), actionId(actionId_),
+			returnCode(returnCode_),step(step_)  {
+		setLinks();
+	}
+private:
+
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&actionId);
+		actionId.setNext(&returnCode);
+		if(isStep) {
+			returnCode.setNext(&step);
+		}
+	}
+
+	bool isStep; //!< [EXPORT] : [IGNORE]
+	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [IGNORE]
+	SerializeElement<ActionId_t> actionId; //!< [EXPORT] : [IGNORE]
+	SerializeElement<ReturnValue_t> returnCode; //!< [EXPORT] : [IGNORE]
+	SerializeElement<uint8_t> step; //!< [EXPORT] : [OPTIONAL] [IGNORE]
+
+};
+
+#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 893ad1db9..9000b23c4 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -1,31 +1,31 @@
-#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
-#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
-
-#include "../returnvalues/FwClassIds.h"
-#include <config/returnvalues/classIds.h>
-#include <cstdint>
-
-#define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
-typedef uint16_t ReturnValue_t;
-
-
-class HasReturnvaluesIF {
-public:
-	static const ReturnValue_t RETURN_OK = 0;
-	static const ReturnValue_t RETURN_FAILED = 1;
-	virtual ~HasReturnvaluesIF() {}
-
-	/**
-	 * It is discouraged to use the input parameters 0,0 and 0,1 as this
-	 * will generate the RETURN_OK and RETURN_FAILED returnvalues.
-	 * @param interfaceId
-	 * @param number
-	 * @return
-	 */
-	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
-			uint8_t number) {
-	    return (interfaceId << 8) + number;
-	}
-};
-
-#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
+#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+
+#include "../returnvalues/FwClassIds.h"
+#include <config/returnvalues/classIds.h>
+#include <cstdint>
+
+#define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
+typedef uint16_t ReturnValue_t;
+
+
+class HasReturnvaluesIF {
+public:
+	static const ReturnValue_t RETURN_OK = 0;
+	static const ReturnValue_t RETURN_FAILED = 1;
+	virtual ~HasReturnvaluesIF() {}
+
+	/**
+	 * It is discouraged to use the input parameters 0,0 and 0,1 as this
+	 * will generate the RETURN_OK and RETURN_FAILED returnvalues.
+	 * @param interfaceId
+	 * @param number
+	 * @return
+	 */
+	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
+			uint8_t number) {
+	    return (interfaceId << 8) + number;
+	}
+};
+
+#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
diff --git a/rmap/RMAP.cpp b/rmap/RMAP.cpp
index 8bc91bb5e..d0872c8e6 100644
--- a/rmap/RMAP.cpp
+++ b/rmap/RMAP.cpp
@@ -1,89 +1,89 @@
-#include "../devicehandlers/DeviceCommunicationIF.h"
-#include "../rmap/rmapStructs.h"
-#include "../rmap/RMAP.h"
-#include "../rmap/RMAPChannelIF.h"
-#include <stddef.h>
-
-ReturnValue_t RMAP::reset(RMAPCookie* cookie) {
-	return cookie->getChannel()->reset();
-}
-
-RMAP::RMAP(){
-
-}
-
-ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
-		size_t length) {
-	uint8_t instruction;
-
-	if ((buffer == NULL) && (length != 0)) {
-		return DeviceCommunicationIF::NULLPOINTER;
-	}
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	instruction = RMAPIds::RMAP_COMMAND_WRITE | cookie->getCommandMask();
-	return cookie->getChannel()->sendCommand(cookie, instruction, buffer,
-			length);
-
-}
-
-ReturnValue_t RMAP::getWriteReply(RMAPCookie *cookie) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
-		return cookie->getChannel()->getReply(cookie, NULL, NULL);
-	} else {
-		return REPLY_MISSMATCH;
-	}
-}
-
-ReturnValue_t RMAP::writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
-		uint32_t length, uint32_t timeout_us) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	return cookie->getChannel()->sendCommandBlocking(cookie, buffer, length,
-			NULL, NULL, timeout_us);
-
-}
-ReturnValue_t RMAP::sendReadCommand(RMAPCookie *cookie, uint32_t expLength) {
-	uint8_t command;
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	command =  RMAPIds::RMAP_COMMAND_READ
-			| (cookie->getCommandMask() & ~(1 <<  RMAPIds::RMAP_COMMAND_BIT_VERIFY));
-
-	return cookie->getChannel()->sendCommand(cookie, command, NULL, expLength);
-
-}
-
-ReturnValue_t RMAP::getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-		size_t *size) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	if (buffer == NULL || size == NULL) {
-		return DeviceCommunicationIF::NULLPOINTER;
-	}
-	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
-		return REPLY_MISSMATCH;
-	} else {
-		return cookie->getChannel()->getReply(cookie, buffer, size);
-	}
-
-}
-
-ReturnValue_t RMAP::readBlocking(RMAPCookie *cookie, uint32_t expLength,
-		uint8_t** buffer, uint32_t *size, uint32_t timeout_us) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	if (buffer == NULL || size == NULL) {
-		return DeviceCommunicationIF::NULLPOINTER;
-	}
-	return cookie->getChannel()->sendCommandBlocking(cookie, NULL, expLength,
-			buffer, size, timeout_us);
-}
+#include "../devicehandlers/DeviceCommunicationIF.h"
+#include "../rmap/rmapStructs.h"
+#include "../rmap/RMAP.h"
+#include "../rmap/RMAPChannelIF.h"
+#include <stddef.h>
+
+ReturnValue_t RMAP::reset(RMAPCookie* cookie) {
+	return cookie->getChannel()->reset();
+}
+
+RMAP::RMAP(){
+
+}
+
+ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+		size_t length) {
+	uint8_t instruction;
+
+	if ((buffer == NULL) && (length != 0)) {
+		return DeviceCommunicationIF::NULLPOINTER;
+	}
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	instruction = RMAPIds::RMAP_COMMAND_WRITE | cookie->getCommandMask();
+	return cookie->getChannel()->sendCommand(cookie, instruction, buffer,
+			length);
+
+}
+
+ReturnValue_t RMAP::getWriteReply(RMAPCookie *cookie) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
+		return cookie->getChannel()->getReply(cookie, NULL, NULL);
+	} else {
+		return REPLY_MISSMATCH;
+	}
+}
+
+ReturnValue_t RMAP::writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
+		uint32_t length, uint32_t timeout_us) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	return cookie->getChannel()->sendCommandBlocking(cookie, buffer, length,
+			NULL, NULL, timeout_us);
+
+}
+ReturnValue_t RMAP::sendReadCommand(RMAPCookie *cookie, uint32_t expLength) {
+	uint8_t command;
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	command =  RMAPIds::RMAP_COMMAND_READ
+			| (cookie->getCommandMask() & ~(1 <<  RMAPIds::RMAP_COMMAND_BIT_VERIFY));
+
+	return cookie->getChannel()->sendCommand(cookie, command, NULL, expLength);
+
+}
+
+ReturnValue_t RMAP::getReadReply(RMAPCookie *cookie, uint8_t **buffer,
+		size_t *size) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	if (buffer == NULL || size == NULL) {
+		return DeviceCommunicationIF::NULLPOINTER;
+	}
+	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
+		return REPLY_MISSMATCH;
+	} else {
+		return cookie->getChannel()->getReply(cookie, buffer, size);
+	}
+
+}
+
+ReturnValue_t RMAP::readBlocking(RMAPCookie *cookie, uint32_t expLength,
+		uint8_t** buffer, uint32_t *size, uint32_t timeout_us) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	if (buffer == NULL || size == NULL) {
+		return DeviceCommunicationIF::NULLPOINTER;
+	}
+	return cookie->getChannel()->sendCommandBlocking(cookie, NULL, expLength,
+			buffer, size, timeout_us);
+}
diff --git a/rmap/RMAP.h b/rmap/RMAP.h
index 9ab6b87db..e083d407f 100644
--- a/rmap/RMAP.h
+++ b/rmap/RMAP.h
@@ -1,227 +1,227 @@
-#ifndef RMAPpp_H_
-#define RMAPpp_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../rmap/RMAPCookie.h"
-
-//SHOULDTODO: clean up includes for RMAP, should be enough to include RMAP.h but right now it's quite chaotic...
-
-/**
- * API for a Cookie/Channel based RMAP implementation.
- *
- * The API offers the four basic RMAP actions: sending a Read or Write command and getting the reply to each.
- * As RMAP is an asynchronous protocol, these are implemented as four seperate calls. There are blocking
- * calls which combine a send and get call using a timeout, but these are "real" blocking, looping in between
- * the calls.
- *
- * Cookies are used to contain Information between a send[Read,Write]Command and a get[Read,Write]Reply call,
- * one can think of them like *nix file descriptors. A cookie is valid from a sendX call until the related getX
- * call. That means if a cookie is used in a getX call, the reply to the sendX call the cookie was used with
- * previously is returned.
- * Depending on the underlying RMAPChannel implementation, a cookie can also be valid for more than one getX
- * call, but this should not be assumed generally.
- * A cookie encapsulates information like the RMAP Channel to use, as well as the RMAP Address
- * and a Command Mask used for specifying which RMAP capabilities are used.
- * Cookies are created without interaction with this API, there is no open() call. The RMAP implementation
- * will initialize all fields which are not set by the cookie's constructor.
- *
- * The RMAP implementation relies on Channels. A channel is used to construct the RMAP Headers and handle the
- * protocol. It is access via the RMAPChannelIF. Thus it is possible to use different Implementations which only
- * need to implement the RMAPChannelIF. A channel is also responsible for accessing the lower layers, for example
- * a SPaceWire transport layer.
- *
- * There is one RMAP Channel per physical device. The cookie-channel as well as the device-channel assignment
- * can be changed at runtime to allow for example redundancy switching. This API is static as the information which
- * channel to use is contained within the cookie.
- */
-class RMAP: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::RMAP_CHANNEL;
-
-	//static const ReturnValue_t COMMAND_OK = MAKE_RETURN_CODE(0x00);
-	static const ReturnValue_t COMMAND_NO_DESCRIPTORS_AVAILABLE =
-			MAKE_RETURN_CODE(0xE1); //no descriptors available for sending command; command was not sent
-	static const ReturnValue_t COMMAND_BUFFER_FULL = MAKE_RETURN_CODE(0xE2); //no receiver buffer available for expected len; command was not sent
-	static const ReturnValue_t COMMAND_CHANNEL_OUT_OF_RANGE = MAKE_RETURN_CODE(
-			0xE3); //The cookie points to an invalid channel; command was not sent
-//Replaced by DeviceCommunicationIF::TOO_MUCH_DATA	static const ReturnValue_t COMMAND_TOO_BIG = MAKE_RETURN_CODE(0xE4); //the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command)
-	//command was not sent
-//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t COMMAND_NULLPOINTER = MAKE_RETURN_CODE(0xE5); //datalen was != 0 but data was == NULL in write command, or nullpointer in read command
-	static const ReturnValue_t COMMAND_CHANNEL_DEACTIVATED = MAKE_RETURN_CODE(
-			0xE6);	//the channel has no port set
-	static const ReturnValue_t COMMAND_PORT_OUT_OF_RANGE = MAKE_RETURN_CODE(
-			0xE7);	//The specified port is not valid
-	static const ReturnValue_t COMMAND_PORT_IN_USE = MAKE_RETURN_CODE(0xE8);//The specified port is already in use
-	static const ReturnValue_t COMMAND_NO_CHANNEL = MAKE_RETURN_CODE(0xE9);//The cookie to work with has no channel assigned.
-	static const ReturnValue_t NO_HW_CRC = MAKE_RETURN_CODE(0xEA);//The SpW port does not support HW CRC generation, which is unsupported
-	//return values for both get_write_reply and get_read_reply
-	static const ReturnValue_t REPLY_NO_REPLY = MAKE_RETURN_CODE(0xD0);	//no reply was received
-	static const ReturnValue_t REPLY_NOT_SENT = MAKE_RETURN_CODE(0xD1);	//command was not sent, implies no reply
-	static const ReturnValue_t REPLY_NOT_YET_SENT = MAKE_RETURN_CODE(0xD2);	//command is still waiting to be sent
-	static const ReturnValue_t REPLY_MISSMATCH = MAKE_RETURN_CODE(0xD3);//a read command was issued, but get_write_rply called, or other way round
-	static const ReturnValue_t REPLY_TIMEOUT = MAKE_RETURN_CODE(0xD4);//timeout
-//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t REPLY_NULLPOINTER = MAKE_RETURN_CODE(0xD5);//one of the arguments in a read reply was NULL
-	//return values for get_reply
-	static const ReturnValue_t REPLY_INTERFACE_BUSY = MAKE_RETURN_CODE(
-			0xC0);//Interface is busy (transmission buffer still being processed)
-	static const ReturnValue_t REPLY_TRANSMISSION_ERROR =
-			MAKE_RETURN_CODE(0xC1);	//Interface encountered errors during last operation, data could not be processed. (transmission error)
-	static const ReturnValue_t REPLY_INVALID_DATA = MAKE_RETURN_CODE(
-			0xC2);	//Invalid data (amount / value)
-	static const ReturnValue_t REPLY_NOT_SUPPORTED = MAKE_RETURN_CODE(
-			0xC3);
-
-	//return values for reset
-	static const ReturnValue_t LINK_DOWN = MAKE_RETURN_CODE(0xF0);//The spw link is down
-	//Other SpW codes:
-	static const ReturnValue_t SPW_CREDIT = MAKE_RETURN_CODE(0xF1);
-	static const ReturnValue_t SPW_ESCAPE = MAKE_RETURN_CODE(0xF2);
-	static const ReturnValue_t SPW_DISCONNECT = MAKE_RETURN_CODE(0xF3);
-	static const ReturnValue_t SPW_PARITY = MAKE_RETURN_CODE(0xF4);
-	static const ReturnValue_t SPW_WRITE_SYNC = MAKE_RETURN_CODE(0xF5);
-	static const ReturnValue_t SPW_INVALID_ADDRESS = MAKE_RETURN_CODE(0xF6);
-	static const ReturnValue_t SPW_EARLY_EOP = MAKE_RETURN_CODE(0xF7);
-	static const ReturnValue_t SPW_DMA = MAKE_RETURN_CODE(0xF8);
-	static const ReturnValue_t SPW_LINK_ERROR = MAKE_RETURN_CODE(0xF9);
-
-
-	//RMAP standard replies
-	static const ReturnValue_t REPLY_OK = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t REPLY_GENERAL_ERROR_CODE = MAKE_RETURN_CODE(1);// The detected error does not fit into the other
-	// error cases or the node does not support
-	// further distinction between the errors
-	static const ReturnValue_t REPLY_UNUSED_PACKET_TYPE_OR_COMMAND_CODE =
-			MAKE_RETURN_CODE(2);	// The Header CRC was decoded correctly but
-	// the packet type is reserved or the command
-	// is not used by the RMAP protocol.
-	static const ReturnValue_t REPLY_INVALID_KEY = MAKE_RETURN_CODE(3);	// The Header CRC was decoded correctly but
-	// the device key did not match that expected
-	// by the target user application
-	static const ReturnValue_t REPLY_INVALID_DATA_CRC = MAKE_RETURN_CODE(4);// Error in the CRC of the data field
-	static const ReturnValue_t REPLY_EARLY_EOP = MAKE_RETURN_CODE(5);// EOP marker detected before the end of the data
-	static const ReturnValue_t REPLY_TOO_MUCH_DATA = MAKE_RETURN_CODE(6);// More than the expected amount of data in a
-	// command has been received
-	static const ReturnValue_t REPLY_EEP = MAKE_RETURN_CODE(7);	// EEP marker detected immediately after the
-	// header CRC or during the transfer of data
-	// and Data CRC or immediately thereafter.
-	// Indicates that there was a communication
-	// failure of some sort on the network
-	static const ReturnValue_t REPLY_RESERVED = MAKE_RETURN_CODE(8);// Reserved
-	static const ReturnValue_t REPLY_VERIFY_BUFFER_OVERRUN = MAKE_RETURN_CODE(
-			9);	// The verify before write bit of the command
-	// was set so that the data field was buffered in
-	// order to verify the Data CRC before
-	// transferring the data to target memory. The
-	// data field was longer than able to fit inside
-	// the verify buffer resulting in a buffer overrun
-	// Note that the command is not executed in
-	// this case
-	static const ReturnValue_t REPLY_COMMAND_NOT_IMPLEMENTED_OR_NOT_AUTHORISED =
-			MAKE_RETURN_CODE(10);// The target user application did not authorise
-	// the requested operation. This may be because
-	// the command requested has not been
-	// implemented
-	static const ReturnValue_t REPLY_RMW_DATA_LENGTH_ERROR = MAKE_RETURN_CODE(
-			11);	// The amount of data in a RMW command is
-	// invalid (0x01	 0x03	 0x05	 0x07 or  greater
-	// than 0x08)
-	static const ReturnValue_t REPLY_INVALID_TARGET_LOGICAL_ADDRESS =
-			MAKE_RETURN_CODE(12);	// The Header CRC was decoded correctly but
-	// the Target Logical Address was not the value
-	// expected by the target
-
-	/**
-	 * Resets the underlying channel.
-	 *
-	 * @param cookie The cookie which points to the channel to reset
-	 * @return
-	 */
-	static ReturnValue_t reset(RMAPCookie *cookie);
-
-	/**
-	 * send an RMAP write command
-	 *
-	 * datalen is only 24bit wide, rest will be ignored
-	 * IMPORTANT: the data buffer must be datalen+1 large, as the driver might
-	 * write a CRC sum at data[datalen]
-	 * if you want to send an empty packet, just do datalen = 0 and data = NULL
-	 *
-	 * @param cookie The cookie to write to
-	 * @param buffer the data to write
-	 * @param length length of data
-	 * @return
-	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command
-	 *      - return codes of RMAPChannelIF::sendCommand()
-	 */
-	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
-			size_t length);
-
-	/**
-	 * get the reply to a write command
-	 *
-	 * @param cookie the cookie the command was sent with
-	 * @return
-	 *      - @c REPLY_MISSMATCH			a read command was issued, but getWriteReply called
-	 *      - return codes of RMAPChannelIF::getReply()
-	 */
-	static ReturnValue_t getWriteReply(RMAPCookie *cookie);
-
-	/**
-	 * @see sendWriteCommand()
-	 * @see getWriteReply()
-	 *
-	 * @param timeout_us the time after the function returns, if no reply was received
-	 *
-	 * @return
-	 *       - All of sendWriteCommand()
-	 *       - All of getWriteReply()
-	 *       - @c REPLY_TIMEOUT				timeout
-	 */
-	static ReturnValue_t writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
-			uint32_t length, uint32_t timeout_us);
-
-	/**
-	 * send an RMAP read command
-	 *
-	 * @param cookie to cookie to read from
-	 * @param expLength the expected maximum length of the reply
-	 * @return
-	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command, or nullpointer in read command
-	 *      - return codes of RMAPChannelIF::sendCommand()
-	 */
-	static ReturnValue_t sendReadCommand(RMAPCookie *cookie,
-			uint32_t expLength);
-
-	/**
-	 * get a reply to an RMAP read command
-	 *
-	 * @param cookie the cookie that was read from
-	 * @param[out] buffer the location of the data
-	 * @param[out] size size of the data
-	 * @return
-	 *      - @c COMMAND_NULLPOINTER		buffer or size was NULL
-	 *      - @c REPLY_MISSMATCH			a write command was issued, but getReadReply called
-	 *      - return codes of RMAPChannelIF::getReply()
-	 */
-	static ReturnValue_t getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-			size_t *size);
-
-	/**
-	 * @see sendReadCommand()
-	 * @see getReadReply()
-	 *
-	 * @param timeout_us the time after the function returns, if no reply was received
-	 *
-	 * @return
-	 *       - All of sendReadCommand()
-	 *       - All of getReadReply()
-	 *       - @c REPLY_TIMEOUT				timeout
-	 */
-	static ReturnValue_t readBlocking(RMAPCookie *cookie, uint32_t expLength,
-			uint8_t** buffer, uint32_t *size, uint32_t timeout_us);
-
-protected:
-	RMAP();
-};
-
-#endif /* RMAPpp_H_ */
+#ifndef RMAPpp_H_
+#define RMAPpp_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../rmap/RMAPCookie.h"
+
+//SHOULDTODO: clean up includes for RMAP, should be enough to include RMAP.h but right now it's quite chaotic...
+
+/**
+ * API for a Cookie/Channel based RMAP implementation.
+ *
+ * The API offers the four basic RMAP actions: sending a Read or Write command and getting the reply to each.
+ * As RMAP is an asynchronous protocol, these are implemented as four seperate calls. There are blocking
+ * calls which combine a send and get call using a timeout, but these are "real" blocking, looping in between
+ * the calls.
+ *
+ * Cookies are used to contain Information between a send[Read,Write]Command and a get[Read,Write]Reply call,
+ * one can think of them like *nix file descriptors. A cookie is valid from a sendX call until the related getX
+ * call. That means if a cookie is used in a getX call, the reply to the sendX call the cookie was used with
+ * previously is returned.
+ * Depending on the underlying RMAPChannel implementation, a cookie can also be valid for more than one getX
+ * call, but this should not be assumed generally.
+ * A cookie encapsulates information like the RMAP Channel to use, as well as the RMAP Address
+ * and a Command Mask used for specifying which RMAP capabilities are used.
+ * Cookies are created without interaction with this API, there is no open() call. The RMAP implementation
+ * will initialize all fields which are not set by the cookie's constructor.
+ *
+ * The RMAP implementation relies on Channels. A channel is used to construct the RMAP Headers and handle the
+ * protocol. It is access via the RMAPChannelIF. Thus it is possible to use different Implementations which only
+ * need to implement the RMAPChannelIF. A channel is also responsible for accessing the lower layers, for example
+ * a SPaceWire transport layer.
+ *
+ * There is one RMAP Channel per physical device. The cookie-channel as well as the device-channel assignment
+ * can be changed at runtime to allow for example redundancy switching. This API is static as the information which
+ * channel to use is contained within the cookie.
+ */
+class RMAP: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::RMAP_CHANNEL;
+
+	//static const ReturnValue_t COMMAND_OK = MAKE_RETURN_CODE(0x00);
+	static const ReturnValue_t COMMAND_NO_DESCRIPTORS_AVAILABLE =
+			MAKE_RETURN_CODE(0xE1); //no descriptors available for sending command; command was not sent
+	static const ReturnValue_t COMMAND_BUFFER_FULL = MAKE_RETURN_CODE(0xE2); //no receiver buffer available for expected len; command was not sent
+	static const ReturnValue_t COMMAND_CHANNEL_OUT_OF_RANGE = MAKE_RETURN_CODE(
+			0xE3); //The cookie points to an invalid channel; command was not sent
+//Replaced by DeviceCommunicationIF::TOO_MUCH_DATA	static const ReturnValue_t COMMAND_TOO_BIG = MAKE_RETURN_CODE(0xE4); //the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command)
+	//command was not sent
+//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t COMMAND_NULLPOINTER = MAKE_RETURN_CODE(0xE5); //datalen was != 0 but data was == NULL in write command, or nullpointer in read command
+	static const ReturnValue_t COMMAND_CHANNEL_DEACTIVATED = MAKE_RETURN_CODE(
+			0xE6);	//the channel has no port set
+	static const ReturnValue_t COMMAND_PORT_OUT_OF_RANGE = MAKE_RETURN_CODE(
+			0xE7);	//The specified port is not valid
+	static const ReturnValue_t COMMAND_PORT_IN_USE = MAKE_RETURN_CODE(0xE8);//The specified port is already in use
+	static const ReturnValue_t COMMAND_NO_CHANNEL = MAKE_RETURN_CODE(0xE9);//The cookie to work with has no channel assigned.
+	static const ReturnValue_t NO_HW_CRC = MAKE_RETURN_CODE(0xEA);//The SpW port does not support HW CRC generation, which is unsupported
+	//return values for both get_write_reply and get_read_reply
+	static const ReturnValue_t REPLY_NO_REPLY = MAKE_RETURN_CODE(0xD0);	//no reply was received
+	static const ReturnValue_t REPLY_NOT_SENT = MAKE_RETURN_CODE(0xD1);	//command was not sent, implies no reply
+	static const ReturnValue_t REPLY_NOT_YET_SENT = MAKE_RETURN_CODE(0xD2);	//command is still waiting to be sent
+	static const ReturnValue_t REPLY_MISSMATCH = MAKE_RETURN_CODE(0xD3);//a read command was issued, but get_write_rply called, or other way round
+	static const ReturnValue_t REPLY_TIMEOUT = MAKE_RETURN_CODE(0xD4);//timeout
+//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t REPLY_NULLPOINTER = MAKE_RETURN_CODE(0xD5);//one of the arguments in a read reply was NULL
+	//return values for get_reply
+	static const ReturnValue_t REPLY_INTERFACE_BUSY = MAKE_RETURN_CODE(
+			0xC0);//Interface is busy (transmission buffer still being processed)
+	static const ReturnValue_t REPLY_TRANSMISSION_ERROR =
+			MAKE_RETURN_CODE(0xC1);	//Interface encountered errors during last operation, data could not be processed. (transmission error)
+	static const ReturnValue_t REPLY_INVALID_DATA = MAKE_RETURN_CODE(
+			0xC2);	//Invalid data (amount / value)
+	static const ReturnValue_t REPLY_NOT_SUPPORTED = MAKE_RETURN_CODE(
+			0xC3);
+
+	//return values for reset
+	static const ReturnValue_t LINK_DOWN = MAKE_RETURN_CODE(0xF0);//The spw link is down
+	//Other SpW codes:
+	static const ReturnValue_t SPW_CREDIT = MAKE_RETURN_CODE(0xF1);
+	static const ReturnValue_t SPW_ESCAPE = MAKE_RETURN_CODE(0xF2);
+	static const ReturnValue_t SPW_DISCONNECT = MAKE_RETURN_CODE(0xF3);
+	static const ReturnValue_t SPW_PARITY = MAKE_RETURN_CODE(0xF4);
+	static const ReturnValue_t SPW_WRITE_SYNC = MAKE_RETURN_CODE(0xF5);
+	static const ReturnValue_t SPW_INVALID_ADDRESS = MAKE_RETURN_CODE(0xF6);
+	static const ReturnValue_t SPW_EARLY_EOP = MAKE_RETURN_CODE(0xF7);
+	static const ReturnValue_t SPW_DMA = MAKE_RETURN_CODE(0xF8);
+	static const ReturnValue_t SPW_LINK_ERROR = MAKE_RETURN_CODE(0xF9);
+
+
+	//RMAP standard replies
+	static const ReturnValue_t REPLY_OK = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t REPLY_GENERAL_ERROR_CODE = MAKE_RETURN_CODE(1);// The detected error does not fit into the other
+	// error cases or the node does not support
+	// further distinction between the errors
+	static const ReturnValue_t REPLY_UNUSED_PACKET_TYPE_OR_COMMAND_CODE =
+			MAKE_RETURN_CODE(2);	// The Header CRC was decoded correctly but
+	// the packet type is reserved or the command
+	// is not used by the RMAP protocol.
+	static const ReturnValue_t REPLY_INVALID_KEY = MAKE_RETURN_CODE(3);	// The Header CRC was decoded correctly but
+	// the device key did not match that expected
+	// by the target user application
+	static const ReturnValue_t REPLY_INVALID_DATA_CRC = MAKE_RETURN_CODE(4);// Error in the CRC of the data field
+	static const ReturnValue_t REPLY_EARLY_EOP = MAKE_RETURN_CODE(5);// EOP marker detected before the end of the data
+	static const ReturnValue_t REPLY_TOO_MUCH_DATA = MAKE_RETURN_CODE(6);// More than the expected amount of data in a
+	// command has been received
+	static const ReturnValue_t REPLY_EEP = MAKE_RETURN_CODE(7);	// EEP marker detected immediately after the
+	// header CRC or during the transfer of data
+	// and Data CRC or immediately thereafter.
+	// Indicates that there was a communication
+	// failure of some sort on the network
+	static const ReturnValue_t REPLY_RESERVED = MAKE_RETURN_CODE(8);// Reserved
+	static const ReturnValue_t REPLY_VERIFY_BUFFER_OVERRUN = MAKE_RETURN_CODE(
+			9);	// The verify before write bit of the command
+	// was set so that the data field was buffered in
+	// order to verify the Data CRC before
+	// transferring the data to target memory. The
+	// data field was longer than able to fit inside
+	// the verify buffer resulting in a buffer overrun
+	// Note that the command is not executed in
+	// this case
+	static const ReturnValue_t REPLY_COMMAND_NOT_IMPLEMENTED_OR_NOT_AUTHORISED =
+			MAKE_RETURN_CODE(10);// The target user application did not authorise
+	// the requested operation. This may be because
+	// the command requested has not been
+	// implemented
+	static const ReturnValue_t REPLY_RMW_DATA_LENGTH_ERROR = MAKE_RETURN_CODE(
+			11);	// The amount of data in a RMW command is
+	// invalid (0x01	 0x03	 0x05	 0x07 or  greater
+	// than 0x08)
+	static const ReturnValue_t REPLY_INVALID_TARGET_LOGICAL_ADDRESS =
+			MAKE_RETURN_CODE(12);	// The Header CRC was decoded correctly but
+	// the Target Logical Address was not the value
+	// expected by the target
+
+	/**
+	 * Resets the underlying channel.
+	 *
+	 * @param cookie The cookie which points to the channel to reset
+	 * @return
+	 */
+	static ReturnValue_t reset(RMAPCookie *cookie);
+
+	/**
+	 * send an RMAP write command
+	 *
+	 * datalen is only 24bit wide, rest will be ignored
+	 * IMPORTANT: the data buffer must be datalen+1 large, as the driver might
+	 * write a CRC sum at data[datalen]
+	 * if you want to send an empty packet, just do datalen = 0 and data = NULL
+	 *
+	 * @param cookie The cookie to write to
+	 * @param buffer the data to write
+	 * @param length length of data
+	 * @return
+	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command
+	 *      - return codes of RMAPChannelIF::sendCommand()
+	 */
+	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+			size_t length);
+
+	/**
+	 * get the reply to a write command
+	 *
+	 * @param cookie the cookie the command was sent with
+	 * @return
+	 *      - @c REPLY_MISSMATCH			a read command was issued, but getWriteReply called
+	 *      - return codes of RMAPChannelIF::getReply()
+	 */
+	static ReturnValue_t getWriteReply(RMAPCookie *cookie);
+
+	/**
+	 * @see sendWriteCommand()
+	 * @see getWriteReply()
+	 *
+	 * @param timeout_us the time after the function returns, if no reply was received
+	 *
+	 * @return
+	 *       - All of sendWriteCommand()
+	 *       - All of getWriteReply()
+	 *       - @c REPLY_TIMEOUT				timeout
+	 */
+	static ReturnValue_t writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
+			uint32_t length, uint32_t timeout_us);
+
+	/**
+	 * send an RMAP read command
+	 *
+	 * @param cookie to cookie to read from
+	 * @param expLength the expected maximum length of the reply
+	 * @return
+	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command, or nullpointer in read command
+	 *      - return codes of RMAPChannelIF::sendCommand()
+	 */
+	static ReturnValue_t sendReadCommand(RMAPCookie *cookie,
+			uint32_t expLength);
+
+	/**
+	 * get a reply to an RMAP read command
+	 *
+	 * @param cookie the cookie that was read from
+	 * @param[out] buffer the location of the data
+	 * @param[out] size size of the data
+	 * @return
+	 *      - @c COMMAND_NULLPOINTER		buffer or size was NULL
+	 *      - @c REPLY_MISSMATCH			a write command was issued, but getReadReply called
+	 *      - return codes of RMAPChannelIF::getReply()
+	 */
+	static ReturnValue_t getReadReply(RMAPCookie *cookie, uint8_t **buffer,
+			size_t *size);
+
+	/**
+	 * @see sendReadCommand()
+	 * @see getReadReply()
+	 *
+	 * @param timeout_us the time after the function returns, if no reply was received
+	 *
+	 * @return
+	 *       - All of sendReadCommand()
+	 *       - All of getReadReply()
+	 *       - @c REPLY_TIMEOUT				timeout
+	 */
+	static ReturnValue_t readBlocking(RMAPCookie *cookie, uint32_t expLength,
+			uint8_t** buffer, uint32_t *size, uint32_t timeout_us);
+
+protected:
+	RMAP();
+};
+
+#endif /* RMAPpp_H_ */
diff --git a/rmap/RMAPChannelIF.h b/rmap/RMAPChannelIF.h
index 037d6d27f..d851885b1 100644
--- a/rmap/RMAPChannelIF.h
+++ b/rmap/RMAPChannelIF.h
@@ -1,116 +1,116 @@
-#ifndef RMAPCHANNELIF_H_
-#define RMAPCHANNELIF_H_
-
-#include "../rmap/RMAPCookie.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
-
-class RMAPChannelIF {
-public:
-	virtual ~RMAPChannelIF(){};
-	/**
-	 * Reset an RMAP channel
-	 *
-	 * Clears the receive buffer (all received messages are deleted) and resets the descriptor table.
-	 * Also checks for errors in the descriptors and submits them to FDIR (aka stdout)
-	 *
-	 * @param channel to reset
-	 *
-	 * @return
-	 *      - @c LINK_DOWN	when the link is down and all replies were missed
-	 *      - @c COMMAND_CHANNEL_DEACTIVATED if the channel's port is NULL
-	 *      - @c RETURN_OK else
-	 */
-	virtual ReturnValue_t reset()=0;
-
-	/**
-	 * Check if a channel is active (ie has a port)
-	 *
-	 * @param channel_nr
-	 * @return
-	 *      - @c COMMAND_OK if channel is active
-	 *      - @c COMMAND_CHANNEL_DEACTIVATED if channel is deactivated
-	 */
-	virtual ReturnValue_t isActive()=0;
-
-	/**
-	 * Assign a SpaceWire port to the Channel
-	 *
-	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
-	 * @param dest_addr	the destination address used by all packets sent from this channel
-	 * @param src_addr the source address used by all packets sent from this channel and used when checking incoming packets
-	 * @return
-	 *      - @c COMMAND_OK if port was changed
-	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
-	 */
-	virtual ReturnValue_t setPort(int8_t port, uint8_t dest_addr,
-			uint8_t src_addr)=0;
-
-	/**
-	 * Assign a SpaceWire port to the Channel
-	 *
-	 * same as setPort(int8_t port, uint8_t dest_addr, uint8_t src_addr), only the addresses are left unchanged
-	 *
-	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
-	 * @return
-	 *      - @c COMMAND_OK if port was changed
-	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
-	 */
-	virtual ReturnValue_t setPort(int8_t port)=0;
-
-	/**
-	 * Send an RMAP command
-	 *
-	 * @param cookie the cookie used with this call
-	 * @param instruction the instruction byte that will be sent (this defines if it is a read or write command)
-	 * @param data data to be sent
-	 * @param datalen length of data
-	 * @return
-	 *      - @c RETURN_OK
-	 *      - @c COMMAND_NO_DESCRIPTORS_AVAILABLE 	no descriptors available for sending command; command was not sent
-	 *      - @c COMMAND_BUFFER_FULL				no receiver buffer available for expected len; command was not sent
-	 *      - @c COMMAND_TOO_BIG					the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command) command was not sent
-	 *      - @c COMMAND_CHANNEL_DEACTIVATED		the channel has no port set
-	 *      - @c NOT_SUPPORTED						if you dont feel like implementing something...
-	 */
-	virtual ReturnValue_t sendCommand(RMAPCookie *cookie, uint8_t instruction,
-			const uint8_t *data, size_t datalen)=0;
-
-	/**
-	 * get the reply to an rmap command
-	 *
-	 * @param cookie the cookie the command was sent with
-	 * @param databuffer a pointer to a pointer the location of the reply will be written to
-	 * @param len a pointer to the variable the length of the reply will be written to
-	 * @return
-	 *      - @c REPLY_NO_REPLY				no reply was received
-	 *      - @c REPLY_NOT_SENT				command was not sent, implies no reply
-	 *      - @c REPLY_NOT_YET_SENT			command is still waiting to be sent
-	 *      - @c WRITE_REPLY_INTERFACE_BUSY			Interface is busy (transmission buffer still being processed)
-	 *      - @c WRITE_REPLY_TRANSMISSION_ERROR		Interface encountered errors during last operation, data could not be processed. (transmission error)
-	 *      - @c WRITE_REPLY_INVALID_DATA			Invalid data (amount / value)
-	 *      - @c WRITE_REPLY_NOT_SUPPORTED
-	 *      - all RMAP standard replies
-	 */
-	virtual ReturnValue_t getReply(RMAPCookie *cookie, uint8_t **databuffer,
-			size_t *len)=0;
-
-	/**
-	 *
-	 * @param cookie
-	 * @param data
-	 * @param datalen
-	 * @param databuffer
-	 * @param len
-	 * @param timeout_us
-	 * @return
-	 *       - all replies of sendCommand() and getReply()
-	 *       - @c REPLY_TIMEOUT				timeout
-	 */
-	virtual ReturnValue_t sendCommandBlocking(RMAPCookie *cookie, uint8_t *data,
-			uint32_t datalen, uint8_t **databuffer, uint32_t *len,
-			uint32_t timeout_us)=0;
-
-};
-
-#endif /* RMAPCHANNELIF_H_ */
+#ifndef RMAPCHANNELIF_H_
+#define RMAPCHANNELIF_H_
+
+#include "../rmap/RMAPCookie.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+class RMAPChannelIF {
+public:
+	virtual ~RMAPChannelIF(){};
+	/**
+	 * Reset an RMAP channel
+	 *
+	 * Clears the receive buffer (all received messages are deleted) and resets the descriptor table.
+	 * Also checks for errors in the descriptors and submits them to FDIR (aka stdout)
+	 *
+	 * @param channel to reset
+	 *
+	 * @return
+	 *      - @c LINK_DOWN	when the link is down and all replies were missed
+	 *      - @c COMMAND_CHANNEL_DEACTIVATED if the channel's port is NULL
+	 *      - @c RETURN_OK else
+	 */
+	virtual ReturnValue_t reset()=0;
+
+	/**
+	 * Check if a channel is active (ie has a port)
+	 *
+	 * @param channel_nr
+	 * @return
+	 *      - @c COMMAND_OK if channel is active
+	 *      - @c COMMAND_CHANNEL_DEACTIVATED if channel is deactivated
+	 */
+	virtual ReturnValue_t isActive()=0;
+
+	/**
+	 * Assign a SpaceWire port to the Channel
+	 *
+	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
+	 * @param dest_addr	the destination address used by all packets sent from this channel
+	 * @param src_addr the source address used by all packets sent from this channel and used when checking incoming packets
+	 * @return
+	 *      - @c COMMAND_OK if port was changed
+	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
+	 */
+	virtual ReturnValue_t setPort(int8_t port, uint8_t dest_addr,
+			uint8_t src_addr)=0;
+
+	/**
+	 * Assign a SpaceWire port to the Channel
+	 *
+	 * same as setPort(int8_t port, uint8_t dest_addr, uint8_t src_addr), only the addresses are left unchanged
+	 *
+	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
+	 * @return
+	 *      - @c COMMAND_OK if port was changed
+	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
+	 */
+	virtual ReturnValue_t setPort(int8_t port)=0;
+
+	/**
+	 * Send an RMAP command
+	 *
+	 * @param cookie the cookie used with this call
+	 * @param instruction the instruction byte that will be sent (this defines if it is a read or write command)
+	 * @param data data to be sent
+	 * @param datalen length of data
+	 * @return
+	 *      - @c RETURN_OK
+	 *      - @c COMMAND_NO_DESCRIPTORS_AVAILABLE 	no descriptors available for sending command; command was not sent
+	 *      - @c COMMAND_BUFFER_FULL				no receiver buffer available for expected len; command was not sent
+	 *      - @c COMMAND_TOO_BIG					the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command) command was not sent
+	 *      - @c COMMAND_CHANNEL_DEACTIVATED		the channel has no port set
+	 *      - @c NOT_SUPPORTED						if you dont feel like implementing something...
+	 */
+	virtual ReturnValue_t sendCommand(RMAPCookie *cookie, uint8_t instruction,
+			const uint8_t *data, size_t datalen)=0;
+
+	/**
+	 * get the reply to an rmap command
+	 *
+	 * @param cookie the cookie the command was sent with
+	 * @param databuffer a pointer to a pointer the location of the reply will be written to
+	 * @param len a pointer to the variable the length of the reply will be written to
+	 * @return
+	 *      - @c REPLY_NO_REPLY				no reply was received
+	 *      - @c REPLY_NOT_SENT				command was not sent, implies no reply
+	 *      - @c REPLY_NOT_YET_SENT			command is still waiting to be sent
+	 *      - @c WRITE_REPLY_INTERFACE_BUSY			Interface is busy (transmission buffer still being processed)
+	 *      - @c WRITE_REPLY_TRANSMISSION_ERROR		Interface encountered errors during last operation, data could not be processed. (transmission error)
+	 *      - @c WRITE_REPLY_INVALID_DATA			Invalid data (amount / value)
+	 *      - @c WRITE_REPLY_NOT_SUPPORTED
+	 *      - all RMAP standard replies
+	 */
+	virtual ReturnValue_t getReply(RMAPCookie *cookie, uint8_t **databuffer,
+			size_t *len)=0;
+
+	/**
+	 *
+	 * @param cookie
+	 * @param data
+	 * @param datalen
+	 * @param databuffer
+	 * @param len
+	 * @param timeout_us
+	 * @return
+	 *       - all replies of sendCommand() and getReply()
+	 *       - @c REPLY_TIMEOUT				timeout
+	 */
+	virtual ReturnValue_t sendCommandBlocking(RMAPCookie *cookie, uint8_t *data,
+			uint32_t datalen, uint8_t **databuffer, uint32_t *len,
+			uint32_t timeout_us)=0;
+
+};
+
+#endif /* RMAPCHANNELIF_H_ */
diff --git a/rmap/RMAPCookie.cpp b/rmap/RMAPCookie.cpp
index 74101ffa5..c92ee4337 100644
--- a/rmap/RMAPCookie.cpp
+++ b/rmap/RMAPCookie.cpp
@@ -1,124 +1,124 @@
-#include "../rmap/RMAPChannelIF.h"
-#include "../rmap/RMAPCookie.h"
-#include <stddef.h>
-
-
-RMAPCookie::RMAPCookie() {
-	this->header.dest_address = 0;
-	this->header.protocol = 0x01;
-	this->header.instruction = 0;
-	this->header.dest_key = 0;
-	this->header.source_address = 0;
-	this->header.tid_h = 0;
-	this->header.tid_l = 0;
-	this->header.extended_address = 0;
-	this->header.address_hh = 0;
-	this->header.address_h = 0;
-	this->header.address_l = 0;
-	this->header.address_ll = 0;
-	this->header.datalen_h = 0;
-	this->header.datalen_m = 0;
-	this->header.datalen_l = 0;
-	this->header.header_crc = 0;
-	this->channel = NULL;
-	this->command_mask = 0;
-
-	this->dataCRC = 0;
-
-	this->maxReplyLen = 0;
-}
-
-
-
-RMAPCookie::RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-		RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen) {
-	this->header.dest_address = 0;
-	this->header.protocol = 0x01;
-	this->header.instruction = 0;
-	this->header.dest_key = 0;
-	this->header.source_address = 0;
-	this->header.tid_h = 0;
-	this->header.tid_l = 0;
-	this->header.extended_address = set_extended_address;
-	setAddress(set_address);
-	this->header.datalen_h = 0;
-	this->header.datalen_m = 0;
-	this->header.datalen_l = 0;
-	this->header.header_crc = 0;
-	this->channel = set_channel;
-	this->command_mask = set_command_mask;
-	this->dataCRC = 0;
-
-	this->maxReplyLen = maxReplyLen;
-}
-
-
-void RMAPCookie::setAddress(uint32_t address) {
-	this->header.address_hh = (address & 0xFF000000) >> 24;
-	this->header.address_h = (address & 0x00FF0000) >> 16;
-	this->header.address_l = (address & 0x0000FF00) >> 8;
-	this->header.address_ll = address & 0x000000FF;
-}
-
-void RMAPCookie::setExtendedAddress(uint8_t extendedAddress) {
-	this->header.extended_address = extendedAddress;
-}
-
-void RMAPCookie::setChannel(RMAPChannelIF *channel) {
-	this->channel = channel;
-}
-
-void RMAPCookie::setCommandMask(uint8_t commandMask) {
-	this->command_mask = commandMask;
-}
-
-uint32_t RMAPCookie::getAddress() {
-	return (header.address_hh << 24) + (header.address_h << 16)
-			+ (header.address_l << 8) + (header.address_ll);
-}
-
-uint8_t RMAPCookie::getExtendedAddress() {
-	return header.extended_address;
-}
-
-RMAPChannelIF *RMAPCookie::getChannel() {
-	return channel;
-}
-
-uint8_t RMAPCookie::getCommandMask() {
-	return command_mask;
-}
-
-RMAPCookie::~RMAPCookie() {
-
-}
-
-size_t RMAPCookie::getMaxReplyLen() const {
-	return maxReplyLen;
-}
-
-void RMAPCookie::setMaxReplyLen(size_t maxReplyLen) {
-	this->maxReplyLen = maxReplyLen;
-}
-
-RMAPStructs::rmap_cmd_header* RMAPCookie::getHeader(){
-	return &this->header;
-}
-
-uint16_t RMAPCookie::getTransactionIdentifier() const {
-	return static_cast<uint16_t>((header.tid_h << 8) | (header.tid_l));
-}
-
-void RMAPCookie::setTransactionIdentifier(uint16_t id_) {
-	header.tid_l  = id_ & 0xFF;
-	header.tid_h = (id_ >> 8 ) & 0xFF;
-}
-
-uint32_t RMAPCookie::getDataLength() const {
-	return static_cast<uint32_t>(header.datalen_h << 16 | header.datalen_m << 8 | header.datalen_l);
-}
-void RMAPCookie::setDataLength(uint32_t length_) {
-	header.datalen_l = length_ & 0xff;
-	header.datalen_m = (length_ >> 8) & 0xff;
-	header.datalen_h = (length_ >> 16) & 0xff;
-}
+#include "../rmap/RMAPChannelIF.h"
+#include "../rmap/RMAPCookie.h"
+#include <stddef.h>
+
+
+RMAPCookie::RMAPCookie() {
+	this->header.dest_address = 0;
+	this->header.protocol = 0x01;
+	this->header.instruction = 0;
+	this->header.dest_key = 0;
+	this->header.source_address = 0;
+	this->header.tid_h = 0;
+	this->header.tid_l = 0;
+	this->header.extended_address = 0;
+	this->header.address_hh = 0;
+	this->header.address_h = 0;
+	this->header.address_l = 0;
+	this->header.address_ll = 0;
+	this->header.datalen_h = 0;
+	this->header.datalen_m = 0;
+	this->header.datalen_l = 0;
+	this->header.header_crc = 0;
+	this->channel = NULL;
+	this->command_mask = 0;
+
+	this->dataCRC = 0;
+
+	this->maxReplyLen = 0;
+}
+
+
+
+RMAPCookie::RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
+		RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen) {
+	this->header.dest_address = 0;
+	this->header.protocol = 0x01;
+	this->header.instruction = 0;
+	this->header.dest_key = 0;
+	this->header.source_address = 0;
+	this->header.tid_h = 0;
+	this->header.tid_l = 0;
+	this->header.extended_address = set_extended_address;
+	setAddress(set_address);
+	this->header.datalen_h = 0;
+	this->header.datalen_m = 0;
+	this->header.datalen_l = 0;
+	this->header.header_crc = 0;
+	this->channel = set_channel;
+	this->command_mask = set_command_mask;
+	this->dataCRC = 0;
+
+	this->maxReplyLen = maxReplyLen;
+}
+
+
+void RMAPCookie::setAddress(uint32_t address) {
+	this->header.address_hh = (address & 0xFF000000) >> 24;
+	this->header.address_h = (address & 0x00FF0000) >> 16;
+	this->header.address_l = (address & 0x0000FF00) >> 8;
+	this->header.address_ll = address & 0x000000FF;
+}
+
+void RMAPCookie::setExtendedAddress(uint8_t extendedAddress) {
+	this->header.extended_address = extendedAddress;
+}
+
+void RMAPCookie::setChannel(RMAPChannelIF *channel) {
+	this->channel = channel;
+}
+
+void RMAPCookie::setCommandMask(uint8_t commandMask) {
+	this->command_mask = commandMask;
+}
+
+uint32_t RMAPCookie::getAddress() {
+	return (header.address_hh << 24) + (header.address_h << 16)
+			+ (header.address_l << 8) + (header.address_ll);
+}
+
+uint8_t RMAPCookie::getExtendedAddress() {
+	return header.extended_address;
+}
+
+RMAPChannelIF *RMAPCookie::getChannel() {
+	return channel;
+}
+
+uint8_t RMAPCookie::getCommandMask() {
+	return command_mask;
+}
+
+RMAPCookie::~RMAPCookie() {
+
+}
+
+size_t RMAPCookie::getMaxReplyLen() const {
+	return maxReplyLen;
+}
+
+void RMAPCookie::setMaxReplyLen(size_t maxReplyLen) {
+	this->maxReplyLen = maxReplyLen;
+}
+
+RMAPStructs::rmap_cmd_header* RMAPCookie::getHeader(){
+	return &this->header;
+}
+
+uint16_t RMAPCookie::getTransactionIdentifier() const {
+	return static_cast<uint16_t>((header.tid_h << 8) | (header.tid_l));
+}
+
+void RMAPCookie::setTransactionIdentifier(uint16_t id_) {
+	header.tid_l  = id_ & 0xFF;
+	header.tid_h = (id_ >> 8 ) & 0xFF;
+}
+
+uint32_t RMAPCookie::getDataLength() const {
+	return static_cast<uint32_t>(header.datalen_h << 16 | header.datalen_m << 8 | header.datalen_l);
+}
+void RMAPCookie::setDataLength(uint32_t length_) {
+	header.datalen_l = length_ & 0xff;
+	header.datalen_m = (length_ >> 8) & 0xff;
+	header.datalen_h = (length_ >> 16) & 0xff;
+}
diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h
index 0da03e308..8832f857b 100644
--- a/rmap/RMAPCookie.h
+++ b/rmap/RMAPCookie.h
@@ -1,59 +1,59 @@
-#ifndef RMAPCOOKIE_H_
-#define RMAPCOOKIE_H_
-
-#include "../devicehandlers/CookieIF.h"
-#include "../rmap/rmapStructs.h"
-#include <cstddef>
-
-class RMAPChannelIF;
-
-class RMAPCookie : public CookieIF {
-public:
-	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
-	RMAPCookie();
-
-	RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-			RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen = 0);
-	virtual ~RMAPCookie();
-
-
-	void setAddress(uint32_t address);
-	uint32_t getAddress();
-
-	void setExtendedAddress(uint8_t);
-	uint8_t getExtendedAddress();
-
-	void setChannel(RMAPChannelIF *channel);
-	RMAPChannelIF *getChannel();
-
-	void setCommandMask(uint8_t commandMask);
-	uint8_t getCommandMask();
-
-	size_t getMaxReplyLen() const;
-	void setMaxReplyLen(size_t maxReplyLen);
-
-	uint16_t getTransactionIdentifier() const;
-	void setTransactionIdentifier(uint16_t id_);
-
-	RMAPStructs::rmap_cmd_header* getHeader();
-
-	uint32_t getDataLength() const;
-	void setDataLength(uint32_t lenght_);
-
-	uint8_t getDataCrc() const {
-		return dataCRC;
-	}
-
-	void setDataCrc(uint8_t dataCrc) {
-		dataCRC = dataCrc;
-	}
-
-protected:
-	RMAPStructs::rmap_cmd_header header;
-	RMAPChannelIF *channel;
-	uint8_t command_mask;
-	uint32_t maxReplyLen;
-	uint8_t dataCRC;
-};
-
-#endif /* RMAPCOOKIE_H_ */
+#ifndef RMAPCOOKIE_H_
+#define RMAPCOOKIE_H_
+
+#include "../devicehandlers/CookieIF.h"
+#include "../rmap/rmapStructs.h"
+#include <cstddef>
+
+class RMAPChannelIF;
+
+class RMAPCookie : public CookieIF {
+public:
+	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
+	RMAPCookie();
+
+	RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
+			RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen = 0);
+	virtual ~RMAPCookie();
+
+
+	void setAddress(uint32_t address);
+	uint32_t getAddress();
+
+	void setExtendedAddress(uint8_t);
+	uint8_t getExtendedAddress();
+
+	void setChannel(RMAPChannelIF *channel);
+	RMAPChannelIF *getChannel();
+
+	void setCommandMask(uint8_t commandMask);
+	uint8_t getCommandMask();
+
+	size_t getMaxReplyLen() const;
+	void setMaxReplyLen(size_t maxReplyLen);
+
+	uint16_t getTransactionIdentifier() const;
+	void setTransactionIdentifier(uint16_t id_);
+
+	RMAPStructs::rmap_cmd_header* getHeader();
+
+	uint32_t getDataLength() const;
+	void setDataLength(uint32_t lenght_);
+
+	uint8_t getDataCrc() const {
+		return dataCRC;
+	}
+
+	void setDataCrc(uint8_t dataCrc) {
+		dataCRC = dataCrc;
+	}
+
+protected:
+	RMAPStructs::rmap_cmd_header header;
+	RMAPChannelIF *channel;
+	uint8_t command_mask;
+	uint32_t maxReplyLen;
+	uint8_t dataCRC;
+};
+
+#endif /* RMAPCOOKIE_H_ */
diff --git a/rmap/RmapDeviceCommunicationIF.cpp b/rmap/RmapDeviceCommunicationIF.cpp
index 36247ce6f..62a3f3ef3 100644
--- a/rmap/RmapDeviceCommunicationIF.cpp
+++ b/rmap/RmapDeviceCommunicationIF.cpp
@@ -1,47 +1,47 @@
-#include "../rmap/RmapDeviceCommunicationIF.h"
-#include "../rmap/RMAP.h"
-
-//TODO Cast here are all potential bugs
-RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF *cookie,
-		const uint8_t * sendData, size_t sendLen) {
-	return RMAP::sendWriteCommand((RMAPCookie *) cookie, sendData, sendLen);
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
-	return RMAP::getWriteReply((RMAPCookie *) cookie);
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::requestReceiveMessage(
-		CookieIF *cookie, size_t requestLen) {
-	return RMAP::sendReadCommand((RMAPCookie *) cookie,
-				((RMAPCookie *) cookie)->getMaxReplyLen());
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
-		uint8_t** buffer, size_t * size) {
-	return RMAP::getReadReply((RMAPCookie *) cookie, buffer, size);
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::setAddress(CookieIF* cookie,
-		uint32_t address) {
-
-	((RMAPCookie *) cookie)->setAddress(address);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t RmapDeviceCommunicationIF::getAddress(CookieIF* cookie) {
-	return ((RMAPCookie *) cookie)->getAddress();
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::setParameter(CookieIF* cookie,
-		uint32_t parameter) {
-	//TODO Empty?
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t RmapDeviceCommunicationIF::getParameter(CookieIF* cookie) {
-	return 0;
-}
+#include "../rmap/RmapDeviceCommunicationIF.h"
+#include "../rmap/RMAP.h"
+
+//TODO Cast here are all potential bugs
+RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF *cookie,
+		const uint8_t * sendData, size_t sendLen) {
+	return RMAP::sendWriteCommand((RMAPCookie *) cookie, sendData, sendLen);
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
+	return RMAP::getWriteReply((RMAPCookie *) cookie);
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::requestReceiveMessage(
+		CookieIF *cookie, size_t requestLen) {
+	return RMAP::sendReadCommand((RMAPCookie *) cookie,
+				((RMAPCookie *) cookie)->getMaxReplyLen());
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
+		uint8_t** buffer, size_t * size) {
+	return RMAP::getReadReply((RMAPCookie *) cookie, buffer, size);
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::setAddress(CookieIF* cookie,
+		uint32_t address) {
+
+	((RMAPCookie *) cookie)->setAddress(address);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t RmapDeviceCommunicationIF::getAddress(CookieIF* cookie) {
+	return ((RMAPCookie *) cookie)->getAddress();
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::setParameter(CookieIF* cookie,
+		uint32_t parameter) {
+	//TODO Empty?
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t RmapDeviceCommunicationIF::getParameter(CookieIF* cookie) {
+	return 0;
+}
diff --git a/rmap/RmapDeviceCommunicationIF.h b/rmap/RmapDeviceCommunicationIF.h
index b05641935..52efa3de9 100644
--- a/rmap/RmapDeviceCommunicationIF.h
+++ b/rmap/RmapDeviceCommunicationIF.h
@@ -1,89 +1,89 @@
-#ifndef MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
-#define MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
-
-#include "../devicehandlers/DeviceCommunicationIF.h"
-
-/**
- * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls.
- *          It expects RMAPCookies or a derived class of RMAPCookies
- *
- * @details	The open, close and reOpen calls are mission specific
- * 			The open call might return any child of RMAPCookies
- *
- * \ingroup rmap
- */
-class RmapDeviceCommunicationIF: public DeviceCommunicationIF {
-
-public:
-	virtual ~RmapDeviceCommunicationIF();
-
-	/**
-	 * @brief Device specific initialization, using the cookie.
-	 * @details
-	 * The cookie is already prepared in the factory. If the communication
-	 * interface needs to be set up in some way and requires cookie information,
-	 * this can be performed in this function, which is called on device handler
-	 * initialization.
-	 * @param cookie
-	 * @return -@c RETURN_OK if initialization was successfull
-	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendWrite().
-	 * This function is used to send data to the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param data
-	 * @param len
-	 * @return -@c RETURN_OK for successfull send
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
-			size_t sendLen);
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetWrite().
-	 * Get send confirmation that the data in sendMessage() was sent successfully.
-	 * @param cookie
-	 * @return -@c RETURN_OK if data was sent successfull
-	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * It is assumed that it is always possible to request a reply
-	 * from a device.
-	 *
-	 * @param cookie
-	 * @return -@c RETURN_OK to confirm the request for data has been sent.
-	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
-	 *         	   will not be called in the respective communication cycle.
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen);
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetRead().
-	 * This function is used to receive data from the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param data
-	 * @param len
-	 * @return @c RETURN_OK for successfull receive
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
-			size_t *size);
-
-	ReturnValue_t setAddress(CookieIF* cookie,
-			uint32_t address);
-	uint32_t getAddress(CookieIF* cookie);
-	ReturnValue_t setParameter(CookieIF* cookie,
-			uint32_t parameter);
-	uint32_t getParameter(CookieIF* cookie);
-};
-
-#endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
+#ifndef MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+#define MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+
+#include "../devicehandlers/DeviceCommunicationIF.h"
+
+/**
+ * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls.
+ *          It expects RMAPCookies or a derived class of RMAPCookies
+ *
+ * @details	The open, close and reOpen calls are mission specific
+ * 			The open call might return any child of RMAPCookies
+ *
+ * \ingroup rmap
+ */
+class RmapDeviceCommunicationIF: public DeviceCommunicationIF {
+
+public:
+	virtual ~RmapDeviceCommunicationIF();
+
+	/**
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return -@c RETURN_OK if initialization was successfull
+	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return -@c RETURN_OK for successfull send
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
+			size_t sendLen);
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return -@c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device.
+	 *
+	 * @param cookie
+	 * @return -@c RETURN_OK to confirm the request for data has been sent.
+	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
+	 *         	   will not be called in the respective communication cycle.
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen);
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return @c RETURN_OK for successfull receive
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+			size_t *size);
+
+	ReturnValue_t setAddress(CookieIF* cookie,
+			uint32_t address);
+	uint32_t getAddress(CookieIF* cookie);
+	ReturnValue_t setParameter(CookieIF* cookie,
+			uint32_t parameter);
+	uint32_t getParameter(CookieIF* cookie);
+};
+
+#endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index fae10bcaf..f981751d0 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -1,124 +1,124 @@
-#ifndef ENDIANSWAPPER_H_
-#define ENDIANSWAPPER_H_
-
-#include "../osal/Endiness.h"
-#include <cstring>
-#include <iostream>
-
-/**
- * Helper class to convert variables or bitstreams between machine
- * endian and either big or little endian.
- * Machine endian is the endianness used by the machine running the
- * program and is one of big or little endian. As this is portable
- * code, it is not known at coding time which it is. At compile time
- * it is however, which is why this is implemented using compiler
- * macros and translates to a copy operation at runtime.
- *
- * This changes the layout of multi-byte variables in the machine's
- * memory. In most cases, you should not need to use this class.
- * Probably what you are looking for is the SerializeAdapter.
- * If you still decide you need this class, please read and understand
- * the code first.
- *
- * The order of the individual bytes of the multi-byte variable is
- * reversed, the byte at the highest address is moved to the lowest
- * address and vice versa, same for the bytes in between.
- *
- * Note that the conversion is also its inversion, that is converting
- * from machine to a specified endianness is the same operation as
- * converting from specified to machine (I looked it up, mathematicians
- * would call it an involution):
- *
- * X == convertBigEndian(convertBigEndian(X))
- *
- * Thus, there is only one function supplied to do the conversion.
- */
-class EndianConverter {
-private:
-	EndianConverter() {};
-public:
-	/**
-	 * Convert a typed variable between big endian and machine endian.
-	 * Intended for plain old datatypes.
-	 */
-	template<typename T>
-	static T convertBigEndian(T in) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		T tmp;
-		uint8_t *pointerOut = (uint8_t*) &tmp;
-		uint8_t *pointerIn = (uint8_t*) &in;
-		for (size_t count = 0; count < sizeof(T); count++) {
-			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
-		}
-		return tmp;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		return in;
-#else
-#error Unknown Byte Order
-#endif
-	}
-
-	/**
-	 * convert a bytestream representing a single variable between big endian
-	 * and machine endian.
-	 */
-	static void convertBigEndian(uint8_t *out, const uint8_t *in,
-			size_t size) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		for (size_t count = 0; count < size; count++) {
-			out[size - count - 1] = in[count];
-		}
-		return;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		memcpy(out, in, size);
-		return;
-#endif
-	}
-
-	/**
-	 * Convert a typed variable between little endian and machine endian.
-	 * Intended for plain old datatypes.
-	 */
-	template<typename T>
-	static T convertLittleEndian(T in) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			T tmp;
-			uint8_t *pointerOut = (uint8_t *) &tmp;
-			uint8_t *pointerIn = (uint8_t *) &in;
-			for (size_t count = 0; count < sizeof(T); count++) {
-				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
-			}
-			return tmp;
-	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		return in;
-#else
-	#error Unknown Byte Order
-	#endif
-	}
-	/**
-	 * convert a bytestream representing a single variable between little endian
-	 * and machine endian.
-	 */
-	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
-			size_t size) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			for (size_t count = 0; count < size; count++) {
-				out[size - count - 1] = in[count];
-			}
-			return;
-	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		memcpy(out, in, size);
-		return;
-#endif
-	}
-};
-
-#endif /* ENDIANSWAPPER_H_ */
+#ifndef ENDIANSWAPPER_H_
+#define ENDIANSWAPPER_H_
+
+#include "../osal/Endiness.h"
+#include <cstring>
+#include <iostream>
+
+/**
+ * Helper class to convert variables or bitstreams between machine
+ * endian and either big or little endian.
+ * Machine endian is the endianness used by the machine running the
+ * program and is one of big or little endian. As this is portable
+ * code, it is not known at coding time which it is. At compile time
+ * it is however, which is why this is implemented using compiler
+ * macros and translates to a copy operation at runtime.
+ *
+ * This changes the layout of multi-byte variables in the machine's
+ * memory. In most cases, you should not need to use this class.
+ * Probably what you are looking for is the SerializeAdapter.
+ * If you still decide you need this class, please read and understand
+ * the code first.
+ *
+ * The order of the individual bytes of the multi-byte variable is
+ * reversed, the byte at the highest address is moved to the lowest
+ * address and vice versa, same for the bytes in between.
+ *
+ * Note that the conversion is also its inversion, that is converting
+ * from machine to a specified endianness is the same operation as
+ * converting from specified to machine (I looked it up, mathematicians
+ * would call it an involution):
+ *
+ * X == convertBigEndian(convertBigEndian(X))
+ *
+ * Thus, there is only one function supplied to do the conversion.
+ */
+class EndianConverter {
+private:
+	EndianConverter() {};
+public:
+	/**
+	 * Convert a typed variable between big endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertBigEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		T tmp;
+		uint8_t *pointerOut = (uint8_t*) &tmp;
+		uint8_t *pointerIn = (uint8_t*) &in;
+		for (size_t count = 0; count < sizeof(T); count++) {
+			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+		}
+		return tmp;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		return in;
+#else
+#error Unknown Byte Order
+#endif
+	}
+
+	/**
+	 * convert a bytestream representing a single variable between big endian
+	 * and machine endian.
+	 */
+	static void convertBigEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		for (size_t count = 0; count < size; count++) {
+			out[size - count - 1] = in[count];
+		}
+		return;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+
+	/**
+	 * Convert a typed variable between little endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertLittleEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			T tmp;
+			uint8_t *pointerOut = (uint8_t *) &tmp;
+			uint8_t *pointerIn = (uint8_t *) &in;
+			for (size_t count = 0; count < sizeof(T); count++) {
+				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+			}
+			return tmp;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		return in;
+#else
+	#error Unknown Byte Order
+	#endif
+	}
+	/**
+	 * convert a bytestream representing a single variable between little endian
+	 * and machine endian.
+	 */
+	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			for (size_t count = 0; count < size; count++) {
+				out[size - count - 1] = in[count];
+			}
+			return;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+};
+
+#endif /* ENDIANSWAPPER_H_ */
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 19190abd6..69afdd4af 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -1,91 +1,91 @@
-/**
- * @file	SerialArrayListAdapter.h
- * @brief	This file defines the SerialArrayListAdapter class.
- * @date	22.07.2014
- * @author	baetz
- */
-#ifndef SERIALARRAYLISTADAPTER_H_
-#define SERIALARRAYLISTADAPTER_H_
-
-#include "../container/ArrayList.h"
-#include "../serialize/SerializeIF.h"
-#include <utility>
-
-/**
- * Also serializes length field !
- * @ingroup serialize
- */
-template<typename T, typename count_t = uint8_t>
-class SerialArrayListAdapter : public SerializeIF {
-public:
-	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
-	}
-
-	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, 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);
-			++i;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const {
-		return getSerializedSize(adaptee);
-	}
-
-	static uint32_t getSerializedSize(const ArrayList<T, count_t>* list) {
-		uint32_t printSize = sizeof(count_t);
-		count_t i = 0;
-
-		for (i = 0; i < list->size; ++i) {
-			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
-		}
-
-		return printSize;
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return deSerialize(adaptee, buffer, size, streamEndianness);
-	}
-
-	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		count_t tempSize = 0;
-		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
-				buffer, size, streamEndianness);
-		if (tempSize > list->maxSize()) {
-			return SerializeIF::TOO_MANY_ELEMENTS;
-		}
-		list->size = tempSize;
-		count_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter::deSerialize(
-					&list->front()[i], buffer, size,
-					streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-
-	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
-		list->swapArrayListEndianness();
-	}
-private:
-	ArrayList<T, count_t> *adaptee;
-};
-
-
-
-#endif /* SERIALARRAYLISTADAPTER_H_ */
+/**
+ * @file	SerialArrayListAdapter.h
+ * @brief	This file defines the SerialArrayListAdapter class.
+ * @date	22.07.2014
+ * @author	baetz
+ */
+#ifndef SERIALARRAYLISTADAPTER_H_
+#define SERIALARRAYLISTADAPTER_H_
+
+#include "../container/ArrayList.h"
+#include "../serialize/SerializeIF.h"
+#include <utility>
+
+/**
+ * Also serializes length field !
+ * @ingroup serialize
+ */
+template<typename T, typename count_t = uint8_t>
+class SerialArrayListAdapter : public SerializeIF {
+public:
+	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
+	}
+
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, 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);
+			++i;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const {
+		return getSerializedSize(adaptee);
+	}
+
+	static uint32_t getSerializedSize(const ArrayList<T, count_t>* list) {
+		uint32_t printSize = sizeof(count_t);
+		count_t i = 0;
+
+		for (i = 0; i < list->size; ++i) {
+			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
+		}
+
+		return printSize;
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return deSerialize(adaptee, buffer, size, streamEndianness);
+	}
+
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		count_t tempSize = 0;
+		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
+				buffer, size, streamEndianness);
+		if (tempSize > list->maxSize()) {
+			return SerializeIF::TOO_MANY_ELEMENTS;
+		}
+		list->size = tempSize;
+		count_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
+			result = SerializeAdapter::deSerialize(
+					&list->front()[i], buffer, size,
+					streamEndianness);
+			++i;
+		}
+		return result;
+	}
+
+
+	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
+		list->swapArrayListEndianness();
+	}
+private:
+	ArrayList<T, count_t> *adaptee;
+};
+
+
+
+#endif /* SERIALARRAYLISTADAPTER_H_ */
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 812cd34b2..1c11afd4b 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,129 +1,129 @@
-#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>;
-
+#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>;
+
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index c3dfcd8fb..9a89e18ba 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -1,78 +1,78 @@
-#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_ */
+#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_ */
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 7968b4204..c866df868 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -1,63 +1,63 @@
-#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
-#define SERIALFIXEDARRAYLISTADAPTER_H_
-
-#include "../container/FixedArrayList.h"
-#include "../serialize/SerialArrayListAdapter.h"
-
-/**
- * @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.
- *
- *  - Buffers with a size header inside that class can be declared with
- *    @code
- *    SerialFixedArrayListAdapter<BUFFER_TYPE,
- *          MAX_SIZE, count_t> mySerialFixedArrayList(...).
- *    @endcode
- *
- *  - MAX_SIZE: specifies the maximum allowed number of elements
- *    in FixedArrayList.
- *  - BUFFER_TYPE: specifies the data type of the buffer
- *  - count_t: specifies the type/size of the length field
- *    which defaults to one byte.
- *
- * @ingroup serialize
- */
-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<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_ */
+#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
+#define SERIALFIXEDARRAYLISTADAPTER_H_
+
+#include "../container/FixedArrayList.h"
+#include "../serialize/SerialArrayListAdapter.h"
+
+/**
+ * @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.
+ *
+ *  - Buffers with a size header inside that class can be declared with
+ *    @code
+ *    SerialFixedArrayListAdapter<BUFFER_TYPE,
+ *          MAX_SIZE, count_t> mySerialFixedArrayList(...).
+ *    @endcode
+ *
+ *  - MAX_SIZE: specifies the maximum allowed number of elements
+ *    in FixedArrayList.
+ *  - BUFFER_TYPE: specifies the data type of the buffer
+ *  - count_t: specifies the type/size of the length field
+ *    which defaults to one byte.
+ *
+ * @ingroup serialize
+ */
+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<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_ */
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index a46520285..987fa70ea 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -1,133 +1,133 @@
-/**
- * @file	SerialLinkedListAdapter.h
- * @brief	This file defines the SerialLinkedListAdapter class.
- * @date	22.07.2014
- * @author	baetz
- */
-#ifndef SERIALLINKEDLISTADAPTER_H_
-#define SERIALLINKEDLISTADAPTER_H_
-
-#include "../container/SinglyLinkedList.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serialize/SerializeElement.h"
-#include "../serialize/SerializeIF.h"
-//This is where we need the SerializeAdapter!
-
- /**
- * @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 with a known size
- *   - 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.
- *
- * @ingroup serialize
- */
-template<typename T, typename count_t = uint8_t>
-class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
-public:
-	/**
-	 * 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;
-
-	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) {
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override {
-		if (printCount) {
-			count_t mySize = SinglyLinkedList<T>::getSize();
-			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
-					buffer, size, maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	static ReturnValue_t serialize(const LinkedElement<T>* element,
-			uint8_t** buffer, size_t* size, size_t maxSize,
-			Endianness streamEndianness) {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			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()
-					+ sizeof(count_t);
-		} else {
-			return getSerializedSize(SinglyLinkedList<T>::start);
-		}
-	}
-
-	static size_t getSerializedSize(const LinkedElement<T> *element) {
-		size_t size = 0;
-		while (element != NULL) {
-			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);
-	}
-
-	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)) {
-			result = element->value->deSerialize(buffer, size, streamEndianness);
-			element = element->getNext();
-		}
-		return result;
-	}
-
-	bool printCount;
-};
-
-#endif /* SERIALLINKEDLISTADAPTER_H_ */
+/**
+ * @file	SerialLinkedListAdapter.h
+ * @brief	This file defines the SerialLinkedListAdapter class.
+ * @date	22.07.2014
+ * @author	baetz
+ */
+#ifndef SERIALLINKEDLISTADAPTER_H_
+#define SERIALLINKEDLISTADAPTER_H_
+
+#include "../container/SinglyLinkedList.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerializeIF.h"
+//This is where we need the SerializeAdapter!
+
+ /**
+ * @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 with a known size
+ *   - 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.
+ *
+ * @ingroup serialize
+ */
+template<typename T, typename count_t = uint8_t>
+class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
+public:
+	/**
+	 * 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;
+
+	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) {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		if (printCount) {
+			count_t mySize = SinglyLinkedList<T>::getSize();
+			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
+					buffer, size, maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	static ReturnValue_t serialize(const LinkedElement<T>* element,
+			uint8_t** buffer, size_t* size, size_t maxSize,
+			Endianness streamEndianness) {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
+			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()
+					+ sizeof(count_t);
+		} else {
+			return getSerializedSize(SinglyLinkedList<T>::start);
+		}
+	}
+
+	static size_t getSerializedSize(const LinkedElement<T> *element) {
+		size_t size = 0;
+		while (element != NULL) {
+			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);
+	}
+
+	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)) {
+			result = element->value->deSerialize(buffer, size, streamEndianness);
+			element = element->getNext();
+		}
+		return result;
+	}
+
+	bool printCount;
+};
+
+#endif /* SERIALLINKEDLISTADAPTER_H_ */
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index bcddb71a0..3e84bdf95 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -1,175 +1,175 @@
-#ifndef SERIALIZEADAPTER_H_
-#define SERIALIZEADAPTER_H_
-
-#include "../container/IsDerivedFrom.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/EndianConverter.h"
-#include "../serialize/SerializeIF.h"
-#include <type_traits>
-
- /**
- * @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
- *
- * A report class is converted into a TM buffer. The report class implements a
- * serialize functions and calls the AutoSerializeAdapter::serialize function
- * repeatedly on all object data fields. The getSerializedSize function is
- * implemented by calling the AutoSerializeAdapter::getSerializedSize function
- * repeatedly on all data fields.
- *
- * The AutoSerializeAdapter functions can also be used as an alternative to
- * memcpy to retrieve data out of a buffer directly into a class variable
- * with data type T while being able to specify endianness. The boolean
- * bigEndian specifies whether an endian swap is performed on the data before
- * serialization or deserialization.
- *
- * There are three ways to retrieve data out of a buffer to be used in the FSFW
- * to use regular aligned (big endian) data. Examples:
- *
- *   1. Use the AutoSerializeAdapter::deSerialize function
- *		The pointer *buffer will be incremented automatically by the typeSize
- *		 of the object, so this function can be called on &buffer repeatedly
- *		without adjusting pointer position. Set bigEndian parameter to true
- *		to perform endian swapping, if necessary
- *		@code
- *   	uint16_t data;
- *   	int32_t dataLen = sizeof(data);
- *   	ReturnValue_t result =
- *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
- *   	@endcode
- *
- *   2. Perform a bitshift operation. Watch for for endianness:
- *		@code
- *   	uint16_t data;
- *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
- *   	data = EndianSwapper::swap(data); //optional, or swap order above
- *   	@endcode
- *
- *   3. memcpy or std::copy can also be used, but watch out if system
- *   	endianness is different from required data endianness.
- *   	Perform endian-swapping if necessary.
- *		@code
- *   	uint16_t data;
- *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
- *   	data = EndianSwapper::swap(data); //optional
- *   	@endcode
- *
- * When serializing for downlink, the packets are generally serialized assuming
- * big endian data format like seen in TmPacketStored.cpp for example.
- *
- * @ingroup serialize
- */
-
-class SerializeAdapter {
-public:
-	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;
-		return adapter.serialize(object, buffer, size, maxSize,
-				streamEndianness);
-	}
-	template<typename T>
-	static uint32_t getSerializedSize(const T *object) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.getSerializedSize(object);
-	}
-	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;
-		return adapter.deSerialize(object, buffer, size, streamEndianness);
-	}
-private:
-	template<typename T, int>
-	class InternalSerializeAdapter {
-	public:
-		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
-				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
-			size_t ignoredSize = 0;
-			if (size == NULL) {
-				size = &ignoredSize;
-			}
-			//TODO check integer overflow of *size
-			if (sizeof(T) + *size <= max_size) {
-				T tmp;
-				switch (streamEndianness) {
-				case SerializeIF::Endianness::BIG:
-					tmp = EndianConverter::convertBigEndian<T>(*object);
-					break;
-				case SerializeIF::Endianness::LITTLE:
-					tmp = EndianConverter::convertLittleEndian<T>(*object);
-					break;
-				default:
-				case SerializeIF::Endianness::MACHINE:
-					tmp = *object;
-					break;
-				}
-				memcpy(*buffer, &tmp, sizeof(T));
-				*size += sizeof(T);
-				(*buffer) += sizeof(T);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				return SerializeIF::BUFFER_TOO_SHORT;
-			}
-		}
-
-		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-				size_t *size, SerializeIF::Endianness streamEndianness) {
-			T tmp;
-			if (*size >= sizeof(T)) {
-				*size -= sizeof(T);
-				memcpy(&tmp, *buffer, sizeof(T));
-				switch (streamEndianness) {
-				case SerializeIF::Endianness::BIG:
-					*object = EndianConverter::convertBigEndian<T>(tmp);
-					break;
-				case SerializeIF::Endianness::LITTLE:
-					*object = EndianConverter::convertLittleEndian<T>(tmp);
-					break;
-				default:
-				case SerializeIF::Endianness::MACHINE:
-					*object = tmp;
-					break;
-				}
-
-				*buffer += sizeof(T);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				return SerializeIF::STREAM_TOO_SHORT;
-			}
-		}
-
-		uint32_t getSerializedSize(const T *object) {
-			return sizeof(T);
-		}
-
-	};
-
-	template<typename T>
-	class InternalSerializeAdapter<T, 1> {
-	public:
-		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) {
-				size = &ignoredSize;
-			}
-			return object->serialize(buffer, size, max_size, streamEndianness);
-		}
-		uint32_t getSerializedSize(const T *object) const {
-			return object->getSerializedSize();
-		}
-
-		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-				size_t *size, SerializeIF::Endianness streamEndianness) {
-			return object->deSerialize(buffer, size, streamEndianness);
-		}
-	};
-};
-
-#endif /* SERIALIZEADAPTER_H_ */
+#ifndef SERIALIZEADAPTER_H_
+#define SERIALIZEADAPTER_H_
+
+#include "../container/IsDerivedFrom.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/EndianConverter.h"
+#include "../serialize/SerializeIF.h"
+#include <type_traits>
+
+ /**
+ * @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
+ *
+ * A report class is converted into a TM buffer. The report class implements a
+ * serialize functions and calls the AutoSerializeAdapter::serialize function
+ * repeatedly on all object data fields. The getSerializedSize function is
+ * implemented by calling the AutoSerializeAdapter::getSerializedSize function
+ * repeatedly on all data fields.
+ *
+ * The AutoSerializeAdapter functions can also be used as an alternative to
+ * memcpy to retrieve data out of a buffer directly into a class variable
+ * with data type T while being able to specify endianness. The boolean
+ * bigEndian specifies whether an endian swap is performed on the data before
+ * serialization or deserialization.
+ *
+ * There are three ways to retrieve data out of a buffer to be used in the FSFW
+ * to use regular aligned (big endian) data. Examples:
+ *
+ *   1. Use the AutoSerializeAdapter::deSerialize function
+ *		The pointer *buffer will be incremented automatically by the typeSize
+ *		 of the object, so this function can be called on &buffer repeatedly
+ *		without adjusting pointer position. Set bigEndian parameter to true
+ *		to perform endian swapping, if necessary
+ *		@code
+ *   	uint16_t data;
+ *   	int32_t dataLen = sizeof(data);
+ *   	ReturnValue_t result =
+ *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
+ *   	@endcode
+ *
+ *   2. Perform a bitshift operation. Watch for for endianness:
+ *		@code
+ *   	uint16_t data;
+ *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
+ *   	data = EndianSwapper::swap(data); //optional, or swap order above
+ *   	@endcode
+ *
+ *   3. memcpy or std::copy can also be used, but watch out if system
+ *   	endianness is different from required data endianness.
+ *   	Perform endian-swapping if necessary.
+ *		@code
+ *   	uint16_t data;
+ *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
+ *   	data = EndianSwapper::swap(data); //optional
+ *   	@endcode
+ *
+ * When serializing for downlink, the packets are generally serialized assuming
+ * big endian data format like seen in TmPacketStored.cpp for example.
+ *
+ * @ingroup serialize
+ */
+
+class SerializeAdapter {
+public:
+	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;
+		return adapter.serialize(object, buffer, size, maxSize,
+				streamEndianness);
+	}
+	template<typename T>
+	static uint32_t getSerializedSize(const T *object) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.getSerializedSize(object);
+	}
+	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;
+		return adapter.deSerialize(object, buffer, size, streamEndianness);
+	}
+private:
+	template<typename T, int>
+	class InternalSerializeAdapter {
+	public:
+		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
+			size_t ignoredSize = 0;
+			if (size == NULL) {
+				size = &ignoredSize;
+			}
+			//TODO check integer overflow of *size
+			if (sizeof(T) + *size <= max_size) {
+				T tmp;
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					tmp = EndianConverter::convertBigEndian<T>(*object);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					tmp = EndianConverter::convertLittleEndian<T>(*object);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					tmp = *object;
+					break;
+				}
+				memcpy(*buffer, &tmp, sizeof(T));
+				*size += sizeof(T);
+				(*buffer) += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::BUFFER_TOO_SHORT;
+			}
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			T tmp;
+			if (*size >= sizeof(T)) {
+				*size -= sizeof(T);
+				memcpy(&tmp, *buffer, sizeof(T));
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					*object = EndianConverter::convertBigEndian<T>(tmp);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					*object = EndianConverter::convertLittleEndian<T>(tmp);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					*object = tmp;
+					break;
+				}
+
+				*buffer += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::STREAM_TOO_SHORT;
+			}
+		}
+
+		uint32_t getSerializedSize(const T *object) {
+			return sizeof(T);
+		}
+
+	};
+
+	template<typename T>
+	class InternalSerializeAdapter<T, 1> {
+	public:
+		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) {
+				size = &ignoredSize;
+			}
+			return object->serialize(buffer, size, max_size, streamEndianness);
+		}
+		uint32_t getSerializedSize(const T *object) const {
+			return object->getSerializedSize();
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			return object->deSerialize(buffer, size, streamEndianness);
+		}
+	};
+};
+
+#endif /* SERIALIZEADAPTER_H_ */
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index e33192ca7..8c3472b2c 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -1,60 +1,60 @@
-#ifndef SERIALIZEELEMENT_H_
-#define SERIALIZEELEMENT_H_
-
-#include "../container/SinglyLinkedList.h"
-#include "../serialize/SerializeAdapter.h"
-#include <utility>
-
-/**
- * @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().
- * Serilization and Deserialization is then performed automatically in
- * specified sequence order.
- * @ingroup serialize
- */
-template<typename T>
-class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
-public:
-	template<typename ... Args>
-	SerializeElement(Args ... args) :
-			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
-
-	}
-	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,
-				streamEndianness);
-	}
-
-	size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&entry);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&entry, buffer, size,
-				streamEndianness);
-	}
-
-	operator T() {
-		return entry;
-	}
-
-	SerializeElement<T>& operator=(T newValue) {
-		entry = newValue;
-		return *this;
-	}
-	T* operator->() {
-		return &entry;
-	}
-};
-
-#endif /* SERIALIZEELEMENT_H_ */
+#ifndef SERIALIZEELEMENT_H_
+#define SERIALIZEELEMENT_H_
+
+#include "../container/SinglyLinkedList.h"
+#include "../serialize/SerializeAdapter.h"
+#include <utility>
+
+/**
+ * @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().
+ * Serilization and Deserialization is then performed automatically in
+ * specified sequence order.
+ * @ingroup serialize
+ */
+template<typename T>
+class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
+public:
+	template<typename ... Args>
+	SerializeElement(Args ... args) :
+			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
+
+	}
+	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,
+				streamEndianness);
+	}
+
+	size_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&entry);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&entry, buffer, size,
+				streamEndianness);
+	}
+
+	operator T() {
+		return entry;
+	}
+
+	SerializeElement<T>& operator=(T newValue) {
+		entry = newValue;
+		return *this;
+	}
+	T* operator->() {
+		return &entry;
+	}
+};
+
+#endif /* SERIALIZEELEMENT_H_ */
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 8dc4894a0..6d5a0dda4 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -1,58 +1,58 @@
-#ifndef SERIALIZEIF_H_
-#define SERIALIZEIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
-
-/**
- * @defgroup serialize Serialization
- * Contains serialisation services.
- */
-
-/**
- * @brief An interface for alle classes which require
- *        translation of objects data into data streams and vice-versa.
- * @details
- * If the target architecture is little endian (e.g. ARM), any data types
- * created might  have the wrong endianess if they are to be used for the FSFW.
- * Depending on the system architecture, endian correctness must be assured,
- * This is important for incoming and outgoing data. The internal handling
- * of data should be performed in the native system endianness.
- * There are three ways to copy data (with different options to ensure
- * endian correctness):
- *
- *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
- *      the endian flag)
- *   2. Perform a bitshift operation (with correct order)
- *   3. @c memcpy (with @c EndianSwapper if necessary)
- *
- * When serializing for downlink, the packets are generally serialized
- * assuming big endian data format like seen in TmPacketStored.cpp for example.
- *
- * @ingroup serialize
- */
-class SerializeIF {
-public:
-	enum class Endianness : uint8_t {
-		BIG, LITTLE, MACHINE
-	};
-
-	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);
-
-	virtual ~SerializeIF() {
-	}
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const = 0;
-
-	virtual size_t getSerializedSize() const = 0;
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) = 0;
-
-};
-
-#endif /* SERIALIZEIF_H_ */
+#ifndef SERIALIZEIF_H_
+#define SERIALIZEIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+/**
+ * @defgroup serialize Serialization
+ * Contains serialisation services.
+ */
+
+/**
+ * @brief An interface for alle classes which require
+ *        translation of objects data into data streams and vice-versa.
+ * @details
+ * If the target architecture is little endian (e.g. ARM), any data types
+ * created might  have the wrong endianess if they are to be used for the FSFW.
+ * Depending on the system architecture, endian correctness must be assured,
+ * This is important for incoming and outgoing data. The internal handling
+ * of data should be performed in the native system endianness.
+ * There are three ways to copy data (with different options to ensure
+ * endian correctness):
+ *
+ *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
+ *      the endian flag)
+ *   2. Perform a bitshift operation (with correct order)
+ *   3. @c memcpy (with @c EndianSwapper if necessary)
+ *
+ * When serializing for downlink, the packets are generally serialized
+ * assuming big endian data format like seen in TmPacketStored.cpp for example.
+ *
+ * @ingroup serialize
+ */
+class SerializeIF {
+public:
+	enum class Endianness : uint8_t {
+		BIG, LITTLE, MACHINE
+	};
+
+	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);
+
+	virtual ~SerializeIF() {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const = 0;
+
+	virtual size_t getSerializedSize() const = 0;
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) = 0;
+
+};
+
+#endif /* SERIALIZEIF_H_ */
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index e7b2a43ed..880f51e12 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,217 +1,217 @@
-#include "../timemanager/Clock.h"
-#include "../serviceinterface/ServiceInterfaceBuffer.h"
-#include <cstring>
-#include <inttypes.h>
-
-// to be implemented by bsp
-extern "C" void printChar(const char*, bool errStream);
-
-#ifndef UT699
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
-		bool addCrToPreamble, bool buffered , bool errStream, uint16_t port):
-		isActive(true), logMessage(setMessage),
-		addCrToPreamble(addCrToPreamble), buffered(buffered),
-		errStream(errStream) {
-	if(buffered) {
-		// Set pointers if the stream is buffered.
-		setp( buf, buf + BUF_SIZE );
-	}
-	preamble.reserve(MAX_PREAMBLE_SIZE);
-	preamble.resize(MAX_PREAMBLE_SIZE);
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	for(; begin != end; begin++){
-		if(errStream) {
-			printChar(begin, true);
-		}
-		else {
-			printChar(begin, false);
-		}
-	}
-}
-
-#endif
-
-int ServiceInterfaceBuffer::overflow(int c) {
-	if(not buffered and this->isActive) {
-		if (c != Traits::eof()) {
-			if(errStream) {
-				printChar(reinterpret_cast<const char*>(&c), true);
-			}
-			else {
-				printChar(reinterpret_cast<const char*>(&c), false);
-			}
-		}
-		return 0;
-	}
-	// Handle output
-	putChars(pbase(), pptr());
-	if (c != Traits::eof()) {
-		char c2 = c;
-		// Handle the one character that didn't fit to buffer
-		putChars(&c2, &c2 + 1);
-	}
-	// This tells that buffer is empty again
-	setp(buf, buf + BUF_SIZE - 1);
-	// I'm not sure about this return value!
-	return 0;
-}
-
-int ServiceInterfaceBuffer::sync(void) {
-	if(not this->isActive and not buffered) {
-		if(not buffered) {
-			setp(buf, buf + BUF_SIZE - 1);
-		}
-		return 0;
-	}
-	if(not buffered) {
-		return 0;
-	}
-
-	size_t preambleSize  = 0;
-	std::string* preamble = getPreamble(&preambleSize);
-	// Write logMessage and time
-	this->putChars(preamble->data(), preamble->data() + preambleSize);
-	// Handle output
-	this->putChars(pbase(), pptr());
-	// This tells that buffer is empty again
-	setp(buf, buf + BUF_SIZE - 1);
-	return 0;
-}
-
-bool ServiceInterfaceBuffer::isBuffered() const {
-	return buffered;
-}
-
-std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
-	Clock::TimeOfDay_t loggerTime;
-	Clock::getDateAndTime(&loggerTime);
-	size_t currentSize = 0;
-	char* parsePosition = &preamble[0];
-	if(addCrToPreamble) {
-		preamble[0] = '\r';
-		currentSize += 1;
-		parsePosition += 1;
-	}
-	int32_t charCount = sprintf(parsePosition,
-			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
-					this->logMessage.c_str(), loggerTime.hour,
-					loggerTime.minute,
-					loggerTime.second,
-					loggerTime.usecond /1000);
-	if(charCount < 0) {
-		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
-		return &preamble;
-	}
-	if(charCount > MAX_PREAMBLE_SIZE) {
-		printf("ServiceInterfaceBuffer: Char count too large for maximum "
-				"preamble size");
-		return &preamble;
-	}
-	currentSize += charCount;
-	if(preambleSize != nullptr) {
-		*preambleSize = currentSize;
-	}
-	return &preamble;
-}
-
-
-
-#ifdef UT699
-#include "../osal/rtems/Interrupt.h"
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-		uint16_t port) {
-	this->log_message = set_message;
-	this->isActive = true;
-	setp( buf, buf + BUF_SIZE );
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	if (!Interrupt::isInterruptInProgress()) {
-		std::cout << array;
-	} else {
-		//Uncomment the following line if you need ISR debug output.
-//		printk(array);
-	}
-}
-#endif //UT699
-
-#ifdef ML505
-#include <bsp_flp/network/networkconfig.h>
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-		uint16_t port) :
-		isActive(true), log_message(set_message), udpSocket(0), remoteAddressLength(
-				sizeof(remoteAddress)) {
-	setp(buf, buf + BUF_SIZE);
-	memset((uint8_t*) &remoteAddress, 0, sizeof(remoteAddress));
-	remoteAddress.sin_family = AF_INET;
-	remoteAddress.sin_port = htons(port);
-	remoteAddress.sin_addr.s_addr = htonl(inet_addr("192.168.250.100"));
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	if (udpSocket <= 0) {
-		initSocket();
-	}
-
-	if (udpSocket > 0) {
-		sendto(udpSocket, array, length, 0, (sockaddr*) &remoteAddress,
-				sizeof(remoteAddress));
-	}
-
-}
-
-void ServiceInterfaceBuffer::initSocket() {
-	sockaddr_in address;
-	memset((uint8_t*) &address, 0, sizeof(address));
-	address.sin_family = AF_INET;
-	address.sin_port = htons(0);
-	address.sin_addr.s_addr = htonl(INADDR_ANY);
-
-	udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
-	if (socket < 0) {
-		printf("Error opening socket!\n");
-		return;
-	}
-	timeval timeout = { 0, 20 };
-	if (setsockopt(udpSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout,
-			sizeof(timeout)) < 0) {
-		printf("Error setting SO_RCVTIMEO socket options!\n");
-		return;
-	}
-	if (setsockopt(udpSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout,
-			sizeof(timeout)) < 0) {
-		printf("Error setting SO_SNDTIMEO socket options!\n");
-		return;
-	}
-	if (bind(udpSocket, (sockaddr *) &address, sizeof(address)) < 0) {
-		printf("Error binding socket!\n");
-	}
-}
-
-#endif //ML505
+#include "../timemanager/Clock.h"
+#include "../serviceinterface/ServiceInterfaceBuffer.h"
+#include <cstring>
+#include <inttypes.h>
+
+// to be implemented by bsp
+extern "C" void printChar(const char*, bool errStream);
+
+#ifndef UT699
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
+		bool addCrToPreamble, bool buffered , bool errStream, uint16_t port):
+		isActive(true), logMessage(setMessage),
+		addCrToPreamble(addCrToPreamble), buffered(buffered),
+		errStream(errStream) {
+	if(buffered) {
+		// Set pointers if the stream is buffered.
+		setp( buf, buf + BUF_SIZE );
+	}
+	preamble.reserve(MAX_PREAMBLE_SIZE);
+	preamble.resize(MAX_PREAMBLE_SIZE);
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	for(; begin != end; begin++){
+		if(errStream) {
+			printChar(begin, true);
+		}
+		else {
+			printChar(begin, false);
+		}
+	}
+}
+
+#endif
+
+int ServiceInterfaceBuffer::overflow(int c) {
+	if(not buffered and this->isActive) {
+		if (c != Traits::eof()) {
+			if(errStream) {
+				printChar(reinterpret_cast<const char*>(&c), true);
+			}
+			else {
+				printChar(reinterpret_cast<const char*>(&c), false);
+			}
+		}
+		return 0;
+	}
+	// Handle output
+	putChars(pbase(), pptr());
+	if (c != Traits::eof()) {
+		char c2 = c;
+		// Handle the one character that didn't fit to buffer
+		putChars(&c2, &c2 + 1);
+	}
+	// This tells that buffer is empty again
+	setp(buf, buf + BUF_SIZE - 1);
+	// I'm not sure about this return value!
+	return 0;
+}
+
+int ServiceInterfaceBuffer::sync(void) {
+	if(not this->isActive and not buffered) {
+		if(not buffered) {
+			setp(buf, buf + BUF_SIZE - 1);
+		}
+		return 0;
+	}
+	if(not buffered) {
+		return 0;
+	}
+
+	size_t preambleSize  = 0;
+	std::string* preamble = getPreamble(&preambleSize);
+	// Write logMessage and time
+	this->putChars(preamble->data(), preamble->data() + preambleSize);
+	// Handle output
+	this->putChars(pbase(), pptr());
+	// This tells that buffer is empty again
+	setp(buf, buf + BUF_SIZE - 1);
+	return 0;
+}
+
+bool ServiceInterfaceBuffer::isBuffered() const {
+	return buffered;
+}
+
+std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
+	Clock::TimeOfDay_t loggerTime;
+	Clock::getDateAndTime(&loggerTime);
+	size_t currentSize = 0;
+	char* parsePosition = &preamble[0];
+	if(addCrToPreamble) {
+		preamble[0] = '\r';
+		currentSize += 1;
+		parsePosition += 1;
+	}
+	int32_t charCount = sprintf(parsePosition,
+			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
+					this->logMessage.c_str(), loggerTime.hour,
+					loggerTime.minute,
+					loggerTime.second,
+					loggerTime.usecond /1000);
+	if(charCount < 0) {
+		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
+		return &preamble;
+	}
+	if(charCount > MAX_PREAMBLE_SIZE) {
+		printf("ServiceInterfaceBuffer: Char count too large for maximum "
+				"preamble size");
+		return &preamble;
+	}
+	currentSize += charCount;
+	if(preambleSize != nullptr) {
+		*preambleSize = currentSize;
+	}
+	return &preamble;
+}
+
+
+
+#ifdef UT699
+#include "../osal/rtems/Interrupt.h"
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+		uint16_t port) {
+	this->log_message = set_message;
+	this->isActive = true;
+	setp( buf, buf + BUF_SIZE );
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	if (!Interrupt::isInterruptInProgress()) {
+		std::cout << array;
+	} else {
+		//Uncomment the following line if you need ISR debug output.
+//		printk(array);
+	}
+}
+#endif //UT699
+
+#ifdef ML505
+#include <bsp_flp/network/networkconfig.h>
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+		uint16_t port) :
+		isActive(true), log_message(set_message), udpSocket(0), remoteAddressLength(
+				sizeof(remoteAddress)) {
+	setp(buf, buf + BUF_SIZE);
+	memset((uint8_t*) &remoteAddress, 0, sizeof(remoteAddress));
+	remoteAddress.sin_family = AF_INET;
+	remoteAddress.sin_port = htons(port);
+	remoteAddress.sin_addr.s_addr = htonl(inet_addr("192.168.250.100"));
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	if (udpSocket <= 0) {
+		initSocket();
+	}
+
+	if (udpSocket > 0) {
+		sendto(udpSocket, array, length, 0, (sockaddr*) &remoteAddress,
+				sizeof(remoteAddress));
+	}
+
+}
+
+void ServiceInterfaceBuffer::initSocket() {
+	sockaddr_in address;
+	memset((uint8_t*) &address, 0, sizeof(address));
+	address.sin_family = AF_INET;
+	address.sin_port = htons(0);
+	address.sin_addr.s_addr = htonl(INADDR_ANY);
+
+	udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
+	if (socket < 0) {
+		printf("Error opening socket!\n");
+		return;
+	}
+	timeval timeout = { 0, 20 };
+	if (setsockopt(udpSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout,
+			sizeof(timeout)) < 0) {
+		printf("Error setting SO_RCVTIMEO socket options!\n");
+		return;
+	}
+	if (setsockopt(udpSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout,
+			sizeof(timeout)) < 0) {
+		printf("Error setting SO_SNDTIMEO socket options!\n");
+		return;
+	}
+	if (bind(udpSocket, (sockaddr *) &address, sizeof(address)) < 0) {
+		printf("Error binding socket!\n");
+	}
+}
+
+#endif //ML505
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index a5c135b66..c5d5b2584 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -1,145 +1,145 @@
-#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
-#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <iostream>
-#include <sstream>
-#include <iomanip>
-
-#ifndef UT699
-
-/**
- * @brief 	This is the underlying stream buffer which implements the
- * 			streambuf class and overloads the overflow() and sync() methods
- * @details
- * This class is used to modify the output of the stream, for example by adding.
- * It also calls the char printing function which is implemented in the
- * board supply package (BSP).
- */
-class ServiceInterfaceBuffer:
-        public std::streambuf {
-	friend class ServiceInterfaceStream;
-public:
-	static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
-
-	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
-			bool buffered, bool errStream, uint16_t port);
-
-protected:
-	bool isActive;
-	//! This is called when buffer becomes full. If
-	//! buffer is not used, then this is called every
-	//! time when characters are put to stream.
-	int overflow(int c = Traits::eof()) override;
-
-	//! This function is called when stream is flushed,
-	//! for example when std::endl is put to stream.
-	int sync(void) override;
-
-	bool isBuffered() const;
-private:
-	//! For additional message information
-	std::string logMessage;
-	std::string preamble;
-	// For EOF detection
-	typedef std::char_traits<char> Traits;
-
-	//! This is useful for some terminal programs which do not have
-	//! implicit carriage return with newline characters.
-	bool addCrToPreamble;
-
-	//! Specifies whether the stream operates in buffered or unbuffered mode.
-	bool buffered;
-	//! This specifies to print to stderr and work in unbuffered mode.
-	bool errStream;
-
-	//! Needed for buffered mode.
-	static size_t const BUF_SIZE = 128;
-	char buf[BUF_SIZE];
-
-	//! In this function, the characters are parsed.
-	void putChars(char const* begin, char const* end);
-
-	std::string* getPreamble(size_t * preambleSize = nullptr);
-};
-
-#endif
-
-
-#ifdef UT699
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
-	friend class ServiceInterfaceStream;
-public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
-protected:
-	bool isActive;
-	// This is called when buffer becomes full. If
-	// buffer is not used, then this is called every
-	// time when characters are put to stream.
-	virtual int overflow(int c = Traits::eof());
-
-	// This function is called when stream is flushed,
-	// for example when std::endl is put to stream.
-	virtual int sync(void);
-
-private:
-	// For additional message information
-	std::string log_message;
-	// For EOF detection
-	typedef std::char_traits<char> Traits;
-
-	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 128;
-	char buf[BUF_SIZE];
-
-	// In this function, the characters are parsed.
-	void putChars(char const* begin, char const* end);
-};
-#endif //UT699
-
-#ifdef ML505
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <netinet/udp.h>
-
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
-	friend class ServiceInterfaceStream;
-public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
-protected:
-	bool isActive;
-	// This is called when buffer becomes full. If
-	// buffer is not used, then this is called every
-	// time when characters are put to stream.
-	virtual int overflow(int c = Traits::eof());
-
-	// This function is called when stream is flushed,
-	// for example when std::endl is put to stream.
-	virtual int sync(void);
-
-private:
-	// For additional message information
-	std::string log_message;
-	// For EOF detection
-	typedef std::char_traits<char> Traits;
-
-	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 128;
-	char buf[BUF_SIZE];
-
-	// In this function, the characters are parsed.
-	void putChars(char const* begin, char const* end);
-
-	int udpSocket;
-	sockaddr_in remoteAddress;
-	socklen_t remoteAddressLength;
-	void initSocket();
-};
-#endif //ML505
-
-
-#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+
+#ifndef UT699
+
+/**
+ * @brief 	This is the underlying stream buffer which implements the
+ * 			streambuf class and overloads the overflow() and sync() methods
+ * @details
+ * This class is used to modify the output of the stream, for example by adding.
+ * It also calls the char printing function which is implemented in the
+ * board supply package (BSP).
+ */
+class ServiceInterfaceBuffer:
+        public std::streambuf {
+	friend class ServiceInterfaceStream;
+public:
+	static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
+
+	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
+			bool buffered, bool errStream, uint16_t port);
+
+protected:
+	bool isActive;
+	//! This is called when buffer becomes full. If
+	//! buffer is not used, then this is called every
+	//! time when characters are put to stream.
+	int overflow(int c = Traits::eof()) override;
+
+	//! This function is called when stream is flushed,
+	//! for example when std::endl is put to stream.
+	int sync(void) override;
+
+	bool isBuffered() const;
+private:
+	//! For additional message information
+	std::string logMessage;
+	std::string preamble;
+	// For EOF detection
+	typedef std::char_traits<char> Traits;
+
+	//! This is useful for some terminal programs which do not have
+	//! implicit carriage return with newline characters.
+	bool addCrToPreamble;
+
+	//! Specifies whether the stream operates in buffered or unbuffered mode.
+	bool buffered;
+	//! This specifies to print to stderr and work in unbuffered mode.
+	bool errStream;
+
+	//! Needed for buffered mode.
+	static size_t const BUF_SIZE = 128;
+	char buf[BUF_SIZE];
+
+	//! In this function, the characters are parsed.
+	void putChars(char const* begin, char const* end);
+
+	std::string* getPreamble(size_t * preambleSize = nullptr);
+};
+
+#endif
+
+
+#ifdef UT699
+class ServiceInterfaceBuffer: public std::basic_streambuf<char,
+		std::char_traits<char> > {
+	friend class ServiceInterfaceStream;
+public:
+	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+protected:
+	bool isActive;
+	// This is called when buffer becomes full. If
+	// buffer is not used, then this is called every
+	// time when characters are put to stream.
+	virtual int overflow(int c = Traits::eof());
+
+	// This function is called when stream is flushed,
+	// for example when std::endl is put to stream.
+	virtual int sync(void);
+
+private:
+	// For additional message information
+	std::string log_message;
+	// For EOF detection
+	typedef std::char_traits<char> Traits;
+
+	// Work in buffer mode. It is also possible to work without buffer.
+	static size_t const BUF_SIZE = 128;
+	char buf[BUF_SIZE];
+
+	// In this function, the characters are parsed.
+	void putChars(char const* begin, char const* end);
+};
+#endif //UT699
+
+#ifdef ML505
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+
+class ServiceInterfaceBuffer: public std::basic_streambuf<char,
+		std::char_traits<char> > {
+	friend class ServiceInterfaceStream;
+public:
+	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+protected:
+	bool isActive;
+	// This is called when buffer becomes full. If
+	// buffer is not used, then this is called every
+	// time when characters are put to stream.
+	virtual int overflow(int c = Traits::eof());
+
+	// This function is called when stream is flushed,
+	// for example when std::endl is put to stream.
+	virtual int sync(void);
+
+private:
+	// For additional message information
+	std::string log_message;
+	// For EOF detection
+	typedef std::char_traits<char> Traits;
+
+	// Work in buffer mode. It is also possible to work without buffer.
+	static size_t const BUF_SIZE = 128;
+	char buf[BUF_SIZE];
+
+	// In this function, the characters are parsed.
+	void putChars(char const* begin, char const* end);
+
+	int udpSocket;
+	sockaddr_in remoteAddress;
+	socklen_t remoteAddressLength;
+	void initSocket();
+};
+#endif //ML505
+
+
+#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 7c6676ddd..8a3589991 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,32 +1,32 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
-		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
-		std::ostream(&streambuf),
-		streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
-
-void ServiceInterfaceStream::setActive( bool myActive) {
-	this->streambuf.isActive = myActive;
-}
-
-std::string* ServiceInterfaceStream::getPreamble() {
-	return streambuf.getPreamble();
-}
-
-void ServiceInterfaceStream::print(std::string error,
-		bool withPreamble, bool withNewline, bool flush) {
-	if(not streambuf.isBuffered() and withPreamble) {
-		*this << getPreamble() << error;
-	}
-	else {
-		*this << error;
-	}
-
-	if(withNewline) {
-		*this << "\n";
-	}
-	// if mode is non-buffered, no need to flush.
-	if(flush and streambuf.isBuffered()) {
-		this->flush();
-	}
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
+		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
+		std::ostream(&streambuf),
+		streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
+
+void ServiceInterfaceStream::setActive( bool myActive) {
+	this->streambuf.isActive = myActive;
+}
+
+std::string* ServiceInterfaceStream::getPreamble() {
+	return streambuf.getPreamble();
+}
+
+void ServiceInterfaceStream::print(std::string error,
+		bool withPreamble, bool withNewline, bool flush) {
+	if(not streambuf.isBuffered() and withPreamble) {
+		*this << getPreamble() << error;
+	}
+	else {
+		*this << error;
+	}
+
+	if(withNewline) {
+		*this << "\n";
+	}
+	// if mode is non-buffered, no need to flush.
+	if(flush and streambuf.isBuffered()) {
+		this->flush();
+	}
+}
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index b1786a380..051500f5b 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -1,58 +1,58 @@
-#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
-#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
-
-#include "../serviceinterface/ServiceInterfaceBuffer.h"
-#include <iostream>
-#include <cstdio>
-
-/**
- * Generic service interface stream which can be used like std::cout or
- * std::cerr but has additional capability. Add preamble and timestamp
- * to output. Can be run in buffered or unbuffered mode.
- */
-class ServiceInterfaceStream : public std::ostream {
-public:
-	/**
-	 * This constructor is used by specifying the preamble message.
-	 * Optionally, the output can be directed to stderr and a CR character
-	 * can be prepended to the preamble.
-	 * @param setMessage message of preamble.
-	 * @param addCrToPreamble Useful for applications like Puttty.
-	 * @param buffered specify whether to use buffered mode.
-	 * @param errStream specify which output stream to use (stderr or stdout).
-	 */
-	ServiceInterfaceStream(std::string setMessage,
-			bool addCrToPreamble = false, bool buffered = true,
-			bool errStream = false, uint16_t port = 1234);
-
-	//! An inactive stream will not print anything.
-	void setActive( bool );
-
-	/**
-	 * This can be used to retrieve the preamble in case it should be printed in
-	 * the unbuffered mode.
-	 * @return Preamle consisting of log message and timestamp.
-	 */
-	std::string* getPreamble();
-
-	/**
-	 * This prints an error with a preamble. Useful if using the unbuffered
-	 * mode. Flushes in default mode (prints immediately).
-	 */
-	void print(std::string error, bool withPreamble = true,
-			bool withNewline = true, bool flush = true);
-
-protected:
-	ServiceInterfaceBuffer streambuf;
-};
-
-// Forward declaration of interface streams. These should be instantiated in
-// main. They can then be used like std::cout or std::cerr.
-namespace sif {
-extern ServiceInterfaceStream debug;
-extern ServiceInterfaceStream info;
-extern ServiceInterfaceStream warning;
-extern ServiceInterfaceStream error;
-}
-
-#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+
+#include "../serviceinterface/ServiceInterfaceBuffer.h"
+#include <iostream>
+#include <cstdio>
+
+/**
+ * Generic service interface stream which can be used like std::cout or
+ * std::cerr but has additional capability. Add preamble and timestamp
+ * to output. Can be run in buffered or unbuffered mode.
+ */
+class ServiceInterfaceStream : public std::ostream {
+public:
+	/**
+	 * This constructor is used by specifying the preamble message.
+	 * Optionally, the output can be directed to stderr and a CR character
+	 * can be prepended to the preamble.
+	 * @param setMessage message of preamble.
+	 * @param addCrToPreamble Useful for applications like Puttty.
+	 * @param buffered specify whether to use buffered mode.
+	 * @param errStream specify which output stream to use (stderr or stdout).
+	 */
+	ServiceInterfaceStream(std::string setMessage,
+			bool addCrToPreamble = false, bool buffered = true,
+			bool errStream = false, uint16_t port = 1234);
+
+	//! An inactive stream will not print anything.
+	void setActive( bool );
+
+	/**
+	 * This can be used to retrieve the preamble in case it should be printed in
+	 * the unbuffered mode.
+	 * @return Preamle consisting of log message and timestamp.
+	 */
+	std::string* getPreamble();
+
+	/**
+	 * This prints an error with a preamble. Useful if using the unbuffered
+	 * mode. Flushes in default mode (prints immediately).
+	 */
+	void print(std::string error, bool withPreamble = true,
+			bool withNewline = true, bool flush = true);
+
+protected:
+	ServiceInterfaceBuffer streambuf;
+};
+
+// Forward declaration of interface streams. These should be instantiated in
+// main. They can then be used like std::cout or std::cerr.
+namespace sif {
+extern ServiceInterfaceStream debug;
+extern ServiceInterfaceStream info;
+extern ServiceInterfaceStream warning;
+extern ServiceInterfaceStream error;
+}
+
+#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */
diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index ea9f2e444..4ada7f801 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -1,87 +1,87 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../storagemanager/ConstStorageAccessor.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../globalfunctions/arrayprinter.h"
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
-		storeId(storeId) {}
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
-		StorageManagerIF* store):
-		storeId(storeId), store(store) {
-	internalState = AccessState::ASSIGNED;
-}
-
-ConstStorageAccessor::~ConstStorageAccessor() {
-	if(deleteData and store != nullptr) {
-		sif::debug << "deleting store data" << std::endl;
-		store->deleteData(storeId);
-	}
-}
-
-ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
-		constDataPointer(other.constDataPointer), storeId(other.storeId),
-		size_(other.size_), store(other.store), deleteData(other.deleteData),
-		internalState(other.internalState) {
-	// This prevent premature deletion
-	other.store = nullptr;
-}
-
-ConstStorageAccessor& ConstStorageAccessor::operator=(
-		ConstStorageAccessor&& other) {
-	constDataPointer = other.constDataPointer;
-	storeId = other.storeId;
-	store = other.store;
-	size_ = other.size_;
-	deleteData = other.deleteData;
-	this->store = other.store;
-	// This prevents premature deletion
-	other.store = nullptr;
-	return *this;
-}
-
-const uint8_t* ConstStorageAccessor::data() const {
-	return constDataPointer;
-}
-
-size_t ConstStorageAccessor::size() const {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return size_;
-}
-
-ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
-		size_t maxSize) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(constDataPointer, constDataPointer + size_, pointer);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void ConstStorageAccessor::release() {
-	deleteData = false;
-}
-
-store_address_t ConstStorageAccessor::getId() const {
-	return storeId;
-}
-
-void ConstStorageAccessor::print() const {
-	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return;
-	}
-	arrayprinter::print(constDataPointer, size_);
-}
-
-void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
-	internalState = AccessState::ASSIGNED;
-	this->store = store;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/ConstStorageAccessor.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../globalfunctions/arrayprinter.h"
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
+		storeId(storeId) {}
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		storeId(storeId), store(store) {
+	internalState = AccessState::ASSIGNED;
+}
+
+ConstStorageAccessor::~ConstStorageAccessor() {
+	if(deleteData and store != nullptr) {
+		sif::debug << "deleting store data" << std::endl;
+		store->deleteData(storeId);
+	}
+}
+
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
+ConstStorageAccessor& ConstStorageAccessor::operator=(
+		ConstStorageAccessor&& other) {
+	constDataPointer = other.constDataPointer;
+	storeId = other.storeId;
+	store = other.store;
+	size_ = other.size_;
+	deleteData = other.deleteData;
+	this->store = other.store;
+	// This prevents premature deletion
+	other.store = nullptr;
+	return *this;
+}
+
+const uint8_t* ConstStorageAccessor::data() const {
+	return constDataPointer;
+}
+
+size_t ConstStorageAccessor::size() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return size_;
+}
+
+ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
+		size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(constDataPointer, constDataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ConstStorageAccessor::release() {
+	deleteData = false;
+}
+
+store_address_t ConstStorageAccessor::getId() const {
+	return storeId;
+}
+
+void ConstStorageAccessor::print() const {
+	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	arrayprinter::print(constDataPointer, size_);
+}
+
+void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+	internalState = AccessState::ASSIGNED;
+	this->store = store;
+}
diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index ec2da8cef..573892da5 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -1,116 +1,116 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
-
-#include "../storagemanager/storeAddress.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
-
-class StorageManagerIF;
-
-/**
- * @brief 	Helper classes to facilitate safe access to storages which is also
- * 			conforming to RAII principles
- * @details
- * Accessor class which can be returned by pool manager or passed and set by
- * pool managers to have safe access to the pool resources.
- *
- * These helper can be used together with the StorageManager classes to manage
- * access to a storage. It can take care of thread-safety while also providing
- * mechanisms to automatically clear storage data.
- */
-class ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	/**
-	 * @brief	Simple constructor which takes the store ID of the storage
-	 * 			entry to access.
-	 * @param storeId
-	 */
-	ConstStorageAccessor(store_address_t storeId);
-	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
-
-	/**
-	 * @brief 	The destructor in default configuration takes care of
-	 * 			deleting the accessed pool entry and unlocking the mutex
-	 */
-	virtual ~ConstStorageAccessor();
-
-	/**
-	 * @brief	Returns a pointer to the read-only data
-	 * @return
-	 */
-	const uint8_t* data() const;
-
-	/**
-	 * @brief	Copies the read-only data to the supplied pointer
-	 * @param pointer
-	 */
-	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
-
-	/**
-	 * @brief   Calling this will prevent the Accessor from deleting the data
-	 *          when the destructor is called.
-	 */
-	void release();
-
-	/**
-	 * Get the size of the data
-	 * @return
-	 */
-	size_t size() const;
-
-	/**
-	 * Get the storage ID.
-	 * @return
-	 */
-	store_address_t getId() const;
-
-	void print() const;
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor(ConstStorageAccessor&&);
-
-	//! The copy ctor and copy assignemnt should be deleted implicitely
-	//! according to https://foonathan.net/2019/02/special-member-functions/
-	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
-	ConstStorageAccessor(const ConstStorageAccessor&) = delete;
-protected:
-	const uint8_t* constDataPointer = nullptr;
-	store_address_t storeId;
-	size_t size_ = 0;
-	//! Managing pool, has to assign itself.
-	StorageManagerIF* store = nullptr;
-	bool deleteData = true;
-
-	enum class AccessState {
-		UNINIT,
-		ASSIGNED
-	};
-	//! Internal state for safety reasons.
-	AccessState internalState = AccessState::UNINIT;
-	/**
-	 * Used by the pool manager instances to assign themselves to the
-	 * accessor. This is necessary to delete the data when the acessor
-	 * exits the scope ! The internal state will be considered read
-	 * when this function is called, so take care all data is set properly as
-	 * well.
-	 * @param
-	 */
-	void assignStore(StorageManagerIF*);
-};
-
-
-#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+
+#include "../storagemanager/storeAddress.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+class StorageManagerIF;
+
+/**
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details
+ * Accessor class which can be returned by pool manager or passed and set by
+ * pool managers to have safe access to the pool resources.
+ *
+ * These helper can be used together with the StorageManager classes to manage
+ * access to a storage. It can take care of thread-safety while also providing
+ * mechanisms to automatically clear storage data.
+ */
+class ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	/**
+	 * @brief	Simple constructor which takes the store ID of the storage
+	 * 			entry to access.
+	 * @param storeId
+	 */
+	ConstStorageAccessor(store_address_t storeId);
+	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
+	/**
+	 * @brief 	The destructor in default configuration takes care of
+	 * 			deleting the accessed pool entry and unlocking the mutex
+	 */
+	virtual ~ConstStorageAccessor();
+
+	/**
+	 * @brief	Returns a pointer to the read-only data
+	 * @return
+	 */
+	const uint8_t* data() const;
+
+	/**
+	 * @brief	Copies the read-only data to the supplied pointer
+	 * @param pointer
+	 */
+	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
+
+	/**
+	 * @brief   Calling this will prevent the Accessor from deleting the data
+	 *          when the destructor is called.
+	 */
+	void release();
+
+	/**
+	 * Get the size of the data
+	 * @return
+	 */
+	size_t size() const;
+
+	/**
+	 * Get the storage ID.
+	 * @return
+	 */
+	store_address_t getId() const;
+
+	void print() const;
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+	ConstStorageAccessor(ConstStorageAccessor&&);
+
+	//! The copy ctor and copy assignemnt should be deleted implicitely
+	//! according to https://foonathan.net/2019/02/special-member-functions/
+	//! but I still deleted them to make it more explicit. (remember rule of 5).
+	ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
+	ConstStorageAccessor(const ConstStorageAccessor&) = delete;
+protected:
+	const uint8_t* constDataPointer = nullptr;
+	store_address_t storeId;
+	size_t size_ = 0;
+	//! Managing pool, has to assign itself.
+	StorageManagerIF* store = nullptr;
+	bool deleteData = true;
+
+	enum class AccessState {
+		UNINIT,
+		ASSIGNED
+	};
+	//! Internal state for safety reasons.
+	AccessState internalState = AccessState::UNINIT;
+	/**
+	 * Used by the pool manager instances to assign themselves to the
+	 * accessor. This is necessary to delete the data when the acessor
+	 * exits the scope ! The internal state will be considered read
+	 * when this function is called, so take care all data is set properly as
+	 * well.
+	 * @param
+	 */
+	void assignStore(StorageManagerIF*);
+};
+
+
+#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 5ead79812..2a526b6a3 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -1,189 +1,189 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-
-#include "../objectmanager/SystemObject.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../internalError/InternalErrorReporterIF.h"
-#include "../storagemanager/StorageAccessor.h"
-#include <cstring>
-
-/**
- * @brief	The LocalPool class provides an intermediate data storage with
- * 			a fixed pool size policy.
- * @details	The class implements the StorageManagerIF interface. While the
- * 			total number of pools is fixed, the element sizes in one pool and
- * 			the number of pool elements per pool are set on construction.
- * 			The full amount of memory is allocated on construction.
- * 			The overhead is 4 byte per pool element to store the size
- * 			information of each stored element.
- * 			To maintain an "empty" information, the pool size is limited to
- * 			0xFFFF-1 bytes.
- * 			It is possible to store empty packets in the pool.
- * 			The local pool is NOT thread-safe.
- * @author 	Bastian Baetz
- */
-template<uint8_t NUMBER_OF_POOLS = 5>
-class LocalPool: public SystemObject, public StorageManagerIF {
-public:
-	/**
-	 * @brief	This definition generally sets the number of different sized pools.
-	 * @details This must be less than the maximum number of pools (currently 0xff).
-	 */
-	//	static const uint32_t NUMBER_OF_POOLS;
-	/**
-	 * @brief	This is the default constructor for a pool manager instance.
-	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
-	 * 			allocates memory (with @c new) for store and size_list. These
-	 * 			regions are all set to zero on start up.
-	 * @param setObjectId	The object identifier to be set. This allows for
-	 * 						multiple instances of LocalPool in the system.
-	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
-	 * 						of a single element in each pool is determined.
-	 * 						<b>The sizes must be provided in ascending order.
-	 * 						</b>
-	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
-	 * 						number of elements for each pool is determined.
-	 * 						The position of these values correspond to those in
-	 * 						element_sizes.
-	 * @param registered	Register the pool in object manager or not.
-	 * Default is false (local pool).
-	 * @param spillsToHigherPools A variable to determine whether
-	 * higher n pools are used if the store is full.
-	 */
-	LocalPool(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS],
-			bool registered = false,
-			bool spillsToHigherPools = false);
-	/**
-	 * @brief	In the LocalPool's destructor all allocated memory is freed.
-	 */
-	virtual ~LocalPool(void);
-
-	/**
-	 * Documentation: See StorageManagerIF.h
-	 */
-	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
-			size_t size, bool ignoreFault = false) override;
-	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
-			uint8_t** p_data, bool ignoreFault = false) override;
-
-	ConstAccessorPair getData(store_address_t packet_id) override;
-	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
-	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
-			size_t * size) override;
-
-	AccessorPair modifyData(store_address_t packet_id) override;
-	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
-	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			size_t * size) override;
-
-	virtual ReturnValue_t deleteData(store_address_t) override;
-	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
-			store_address_t* storeId = NULL) override;
-	void clearStore() override;
-	ReturnValue_t initialize() override;
-protected:
-	/**
-	 * With this helper method, a free element of @c size is reserved.
-	 * @param size	The minimum packet size that shall be reserved.
-	 * @param[out] address Storage ID of the reserved data.
-	 * @return	- #RETURN_OK on success,
-	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
-	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size,
-			store_address_t* address, bool ignoreFault);
-
-	InternalErrorReporterIF *internalErrorReporter;
-private:
-	/**
-	 * Indicates that this element is free.
-	 * This value limits the maximum size of a pool. Change to larger data type
-	 * if increase is required.
-	 */
-	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
-	/**
-	 * @brief	In this array, the element sizes of each pool is stored.
-	 * @details	The sizes are maintained for internal pool management. The sizes
-	 * 			must be set in ascending order on construction.
-	 */
-	uint32_t element_sizes[NUMBER_OF_POOLS];
-	/**
-	 * @brief	n_elements stores the number of elements per pool.
-	 * @details	These numbers are maintained for internal pool management.
-	 */
-	uint16_t n_elements[NUMBER_OF_POOLS];
-	/**
-	 * @brief	store represents the actual memory pool.
-	 * @details	It is an array of pointers to memory, which was allocated with
-	 * 			a @c new call on construction.
-	 */
-	uint8_t* store[NUMBER_OF_POOLS];
-	/**
-	 * @brief	The size_list attribute stores the size values of every pool element.
-	 * @details	As the number of elements is determined on construction, the size list
-	 * 			is also dynamically allocated there.
-	 */
-	uint32_t* size_list[NUMBER_OF_POOLS];
-	//! A variable to determine whether higher n pools are used if
-	//! the store is full.
-	bool spillsToHigherPools;
-	/**
-	 * @brief	This method safely stores the given data in the given packet_id.
-	 * @details	It also sets the size in size_list. The method does not perform
-	 * 			any range checks, these are done in advance.
-	 * @param packet_id	The storage identifier in which the data shall be stored.
-	 * @param data		The data to be stored.
-	 * @param size		The size of the data to be stored.
-	 */
-	void write(store_address_t packet_id, const uint8_t* data, size_t size);
-	/**
-	 * @brief	A helper method to read the element size of a certain pool.
-	 * @param pool_index	The pool in which to look.
-	 * @return	Returns the size of an element or 0.
-	 */
-	uint32_t getPageSize(uint16_t pool_index);
-	/**
-	 * @brief	This helper method looks up a fitting pool for a given size.
-	 * @details	The pools are looked up in ascending order, so the first that
-	 * 			fits is used.
-	 * @param packet_size	The size of the data to be stored.
-	 * @return	Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
-	 */
-	/**
-	 * @brief	This helper method looks up a fitting pool for a given size.
-	 * @details	The pools are looked up in ascending order, so the first that
-	 * 			fits is used.
-	 * @param packet_size		The size of the data to be stored.
-	 * @param[out] poolIndex	The fitting pool index found.
-	 * @return	- #RETURN_OK on success,
-	 * 			- #DATA_TOO_LARGE otherwise.
-	 */
-	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
-			uint16_t startAtIndex = 0);
-	/**
-	 * @brief	This helper method calculates the true array position in store
-	 * 			of a given packet id.
-	 * @details	The method does not perform any range checks, these are done in
-	 * 			advance.
-	 * @param packet_id	The packet id to look up.
-	 * @return	Returns the position of the data in store.
-	 */
-	uint32_t getRawPosition(store_address_t packet_id);
-	/**
-	 * @brief	This is a helper method to find an empty element in a given pool.
-	 * @details	The method searches size_list for the first empty element, so
-	 * 			duration grows with the fill level of the pool.
-	 * @param pool_index	The pool in which the search is performed.
-	 * @param[out] element	The first found element in the pool.
-	 * @return	- #RETURN_OK on success,
-	 * 			- #DATA_STORAGE_FULL if the store is full
-	 */
-	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
-};
-
-#include "../storagemanager/LocalPool.tpp"
-
-#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../internalError/InternalErrorReporterIF.h"
+#include "../storagemanager/StorageAccessor.h"
+#include <cstring>
+
+/**
+ * @brief	The LocalPool class provides an intermediate data storage with
+ * 			a fixed pool size policy.
+ * @details	The class implements the StorageManagerIF interface. While the
+ * 			total number of pools is fixed, the element sizes in one pool and
+ * 			the number of pool elements per pool are set on construction.
+ * 			The full amount of memory is allocated on construction.
+ * 			The overhead is 4 byte per pool element to store the size
+ * 			information of each stored element.
+ * 			To maintain an "empty" information, the pool size is limited to
+ * 			0xFFFF-1 bytes.
+ * 			It is possible to store empty packets in the pool.
+ * 			The local pool is NOT thread-safe.
+ * @author 	Bastian Baetz
+ */
+template<uint8_t NUMBER_OF_POOLS = 5>
+class LocalPool: public SystemObject, public StorageManagerIF {
+public:
+	/**
+	 * @brief	This definition generally sets the number of different sized pools.
+	 * @details This must be less than the maximum number of pools (currently 0xff).
+	 */
+	//	static const uint32_t NUMBER_OF_POOLS;
+	/**
+	 * @brief	This is the default constructor for a pool manager instance.
+	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
+	 * 			allocates memory (with @c new) for store and size_list. These
+	 * 			regions are all set to zero on start up.
+	 * @param setObjectId	The object identifier to be set. This allows for
+	 * 						multiple instances of LocalPool in the system.
+	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
+	 * 						of a single element in each pool is determined.
+	 * 						<b>The sizes must be provided in ascending order.
+	 * 						</b>
+	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
+	 * 						number of elements for each pool is determined.
+	 * 						The position of these values correspond to those in
+	 * 						element_sizes.
+	 * @param registered	Register the pool in object manager or not.
+	 * Default is false (local pool).
+	 * @param spillsToHigherPools A variable to determine whether
+	 * higher n pools are used if the store is full.
+	 */
+	LocalPool(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS],
+			bool registered = false,
+			bool spillsToHigherPools = false);
+	/**
+	 * @brief	In the LocalPool's destructor all allocated memory is freed.
+	 */
+	virtual ~LocalPool(void);
+
+	/**
+	 * Documentation: See StorageManagerIF.h
+	 */
+	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
+			size_t size, bool ignoreFault = false) override;
+	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
+			uint8_t** p_data, bool ignoreFault = false) override;
+
+	ConstAccessorPair getData(store_address_t packet_id) override;
+	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
+	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
+			size_t * size) override;
+
+	AccessorPair modifyData(store_address_t packet_id) override;
+	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
+	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
+			size_t * size) override;
+
+	virtual ReturnValue_t deleteData(store_address_t) override;
+	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
+			store_address_t* storeId = NULL) override;
+	void clearStore() override;
+	ReturnValue_t initialize() override;
+protected:
+	/**
+	 * With this helper method, a free element of @c size is reserved.
+	 * @param size	The minimum packet size that shall be reserved.
+	 * @param[out] address Storage ID of the reserved data.
+	 * @return	- #RETURN_OK on success,
+	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
+	 */
+	virtual ReturnValue_t reserveSpace(const uint32_t size,
+			store_address_t* address, bool ignoreFault);
+
+	InternalErrorReporterIF *internalErrorReporter;
+private:
+	/**
+	 * Indicates that this element is free.
+	 * This value limits the maximum size of a pool. Change to larger data type
+	 * if increase is required.
+	 */
+	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
+	/**
+	 * @brief	In this array, the element sizes of each pool is stored.
+	 * @details	The sizes are maintained for internal pool management. The sizes
+	 * 			must be set in ascending order on construction.
+	 */
+	uint32_t element_sizes[NUMBER_OF_POOLS];
+	/**
+	 * @brief	n_elements stores the number of elements per pool.
+	 * @details	These numbers are maintained for internal pool management.
+	 */
+	uint16_t n_elements[NUMBER_OF_POOLS];
+	/**
+	 * @brief	store represents the actual memory pool.
+	 * @details	It is an array of pointers to memory, which was allocated with
+	 * 			a @c new call on construction.
+	 */
+	uint8_t* store[NUMBER_OF_POOLS];
+	/**
+	 * @brief	The size_list attribute stores the size values of every pool element.
+	 * @details	As the number of elements is determined on construction, the size list
+	 * 			is also dynamically allocated there.
+	 */
+	uint32_t* size_list[NUMBER_OF_POOLS];
+	//! A variable to determine whether higher n pools are used if
+	//! the store is full.
+	bool spillsToHigherPools;
+	/**
+	 * @brief	This method safely stores the given data in the given packet_id.
+	 * @details	It also sets the size in size_list. The method does not perform
+	 * 			any range checks, these are done in advance.
+	 * @param packet_id	The storage identifier in which the data shall be stored.
+	 * @param data		The data to be stored.
+	 * @param size		The size of the data to be stored.
+	 */
+	void write(store_address_t packet_id, const uint8_t* data, size_t size);
+	/**
+	 * @brief	A helper method to read the element size of a certain pool.
+	 * @param pool_index	The pool in which to look.
+	 * @return	Returns the size of an element or 0.
+	 */
+	uint32_t getPageSize(uint16_t pool_index);
+	/**
+	 * @brief	This helper method looks up a fitting pool for a given size.
+	 * @details	The pools are looked up in ascending order, so the first that
+	 * 			fits is used.
+	 * @param packet_size	The size of the data to be stored.
+	 * @return	Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
+	 */
+	/**
+	 * @brief	This helper method looks up a fitting pool for a given size.
+	 * @details	The pools are looked up in ascending order, so the first that
+	 * 			fits is used.
+	 * @param packet_size		The size of the data to be stored.
+	 * @param[out] poolIndex	The fitting pool index found.
+	 * @return	- #RETURN_OK on success,
+	 * 			- #DATA_TOO_LARGE otherwise.
+	 */
+	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
+			uint16_t startAtIndex = 0);
+	/**
+	 * @brief	This helper method calculates the true array position in store
+	 * 			of a given packet id.
+	 * @details	The method does not perform any range checks, these are done in
+	 * 			advance.
+	 * @param packet_id	The packet id to look up.
+	 * @return	Returns the position of the data in store.
+	 */
+	uint32_t getRawPosition(store_address_t packet_id);
+	/**
+	 * @brief	This is a helper method to find an empty element in a given pool.
+	 * @details	The method searches size_list for the first empty element, so
+	 * 			duration grows with the fill level of the pool.
+	 * @param pool_index	The pool in which the search is performed.
+	 * @param[out] element	The first found element in the pool.
+	 * @return	- #RETURN_OK on success,
+	 * 			- #DATA_STORAGE_FULL if the store is full
+	 */
+	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
+};
+
+#include "../storagemanager/LocalPool.tpp"
+
+#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 2dc3266ac..76bddb8ff 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,49 +1,49 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-
-#include "../storagemanager/LocalPool.h"
-#include "../ipc/MutexHelper.h"
-#include "../storagemanager/StorageAccessor.h"
-
-/**
- * @brief	The PoolManager class provides an intermediate data storage with
- * 			a fixed pool size policy for inter-process communication.
- * @details	Uses local pool calls but is thread safe by protecting the call
- * 			with a lock.
- * @author 	Bastian Baetz
- */
-template <uint8_t NUMBER_OF_POOLS = 5>
-class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
-public:
-	PoolManager(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS]);
-
-	//! @brief	In the PoolManager's destructor all allocated memory is freed.
-	virtual ~PoolManager();
-
-	//! @brief LocalPool overrides for thread-safety. Decorator function which
-	//! 	   wraps LocalPool calls with a mutex protection.
-	ReturnValue_t deleteData(store_address_t) override;
-	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
-			store_address_t* storeId = nullptr) override;
-
-protected:
-	//! Default mutex timeout value to prevent permanent blocking.
-	static constexpr uint32_t mutexTimeout = 50;
-
-	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
-			bool ignoreFault) override;
-
-	/**
-	 * @brief	The mutex is created in the constructor and makes
-	 * 			access mutual exclusive.
-	 * @details	Locking and unlocking is done during searching for free slots
-	 * 			and deleting existing slots.
-	 */
-	MutexIF* mutex;
-};
-
-#include "PoolManager.tpp"
-
-#endif /* POOLMANAGER_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+
+#include "../storagemanager/LocalPool.h"
+#include "../ipc/MutexHelper.h"
+#include "../storagemanager/StorageAccessor.h"
+
+/**
+ * @brief	The PoolManager class provides an intermediate data storage with
+ * 			a fixed pool size policy for inter-process communication.
+ * @details	Uses local pool calls but is thread safe by protecting the call
+ * 			with a lock.
+ * @author 	Bastian Baetz
+ */
+template <uint8_t NUMBER_OF_POOLS = 5>
+class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
+public:
+	PoolManager(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS]);
+
+	//! @brief	In the PoolManager's destructor all allocated memory is freed.
+	virtual ~PoolManager();
+
+	//! @brief LocalPool overrides for thread-safety. Decorator function which
+	//! 	   wraps LocalPool calls with a mutex protection.
+	ReturnValue_t deleteData(store_address_t) override;
+	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = nullptr) override;
+
+protected:
+	//! Default mutex timeout value to prevent permanent blocking.
+	static constexpr uint32_t mutexTimeout = 50;
+
+	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
+			bool ignoreFault) override;
+
+	/**
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking is done during searching for free slots
+	 * 			and deleting existing slots.
+	 */
+	MutexIF* mutex;
+};
+
+#include "PoolManager.tpp"
+
+#endif /* POOLMANAGER_H_ */
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index d4d2a54d8..60bd41304 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,67 +1,67 @@
-#include "../storagemanager/StorageAccessor.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-StorageAccessor::StorageAccessor(store_address_t storeId):
-		ConstStorageAccessor(storeId) {
-}
-
-StorageAccessor::StorageAccessor(store_address_t storeId,
-		StorageManagerIF* store):
-		ConstStorageAccessor(storeId, store) {
-}
-
-StorageAccessor& StorageAccessor::operator =(
-		StorageAccessor&& other) {
-	// Call the parent move assignment and also assign own member.
-	dataPointer = other.dataPointer;
-	StorageAccessor::operator=(std::move(other));
-	return * this;
-}
-
-// Call the parent move ctor and also transfer own member.
-StorageAccessor::StorageAccessor(StorageAccessor&& other):
-		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
-}
-
-ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large "
-				"enough" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(dataPointer, dataPointer + size_, pointer);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint8_t* StorageAccessor::data() {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return dataPointer;
-}
-
-ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
-		uint16_t offset) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(offset + size > size_) {
-		sif::error << "StorageAccessor: Data too large for pool "
-				"entry!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(data, data + size, dataPointer + offset);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void StorageAccessor::assignConstPointer() {
-	constDataPointer = dataPointer;
-}
-
-
+#include "../storagemanager/StorageAccessor.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+StorageAccessor::StorageAccessor(store_address_t storeId):
+		ConstStorageAccessor(storeId) {
+}
+
+StorageAccessor::StorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		ConstStorageAccessor(storeId, store) {
+}
+
+StorageAccessor& StorageAccessor::operator =(
+		StorageAccessor&& other) {
+	// Call the parent move assignment and also assign own member.
+	dataPointer = other.dataPointer;
+	StorageAccessor::operator=(std::move(other));
+	return * this;
+}
+
+// Call the parent move ctor and also transfer own member.
+StorageAccessor::StorageAccessor(StorageAccessor&& other):
+		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+}
+
+ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large "
+				"enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(dataPointer, dataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t* StorageAccessor::data() {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return dataPointer;
+}
+
+ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
+		uint16_t offset) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(offset + size > size_) {
+		sif::error << "StorageAccessor: Data too large for pool "
+				"entry!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(data, data + size, dataPointer + offset);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void StorageAccessor::assignConstPointer() {
+	constDataPointer = dataPointer;
+}
+
+
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 1ca5f7ddc..a65427b8b 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,45 +1,45 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
-
-#include "../storagemanager/ConstStorageAccessor.h"
-
-class StorageManagerIF;
-
-/**
- * @brief   Child class for modifyable data. Also has a normal pointer member.
- */
-class StorageAccessor: public ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	StorageAccessor(store_address_t storeId);
-	StorageAccessor(store_address_t storeId, StorageManagerIF* store);
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being freed prematurely.
-	 * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * 		move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	StorageAccessor& operator=(StorageAccessor&&);
-	StorageAccessor(StorageAccessor&&);
-
-	ReturnValue_t write(uint8_t *data, size_t size,
-		uint16_t offset = 0);
-	uint8_t* data();
-	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
-
-private:
-	//! Non-const pointer for modifyable data.
-	uint8_t* dataPointer = nullptr;
-	//! For modifyable data, the const pointer is assigned to the normal
-	//! pointer by the pool manager so both access functions can be used safely
-	void assignConstPointer();
-};
-
-#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+
+#include "../storagemanager/ConstStorageAccessor.h"
+
+class StorageManagerIF;
+
+/**
+ * @brief   Child class for modifyable data. Also has a normal pointer member.
+ */
+class StorageAccessor: public ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	StorageAccessor(store_address_t storeId);
+	StorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being freed prematurely.
+	 * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * 		move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	StorageAccessor& operator=(StorageAccessor&&);
+	StorageAccessor(StorageAccessor&&);
+
+	ReturnValue_t write(uint8_t *data, size_t size,
+		uint16_t offset = 0);
+	uint8_t* data();
+	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
+
+private:
+	//! Non-const pointer for modifyable data.
+	uint8_t* dataPointer = nullptr;
+	//! For modifyable data, the const pointer is assigned to the normal
+	//! pointer by the pool manager so both access functions can be used safely
+	void assignConstPointer();
+};
+
+#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 85341f2e8..2229cdf89 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -1,167 +1,167 @@
-#ifndef STORAGEMANAGERIF_H_H
-#define STORAGEMANAGERIF_H_H
-
-#include "../events/Event.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../storagemanager/StorageAccessor.h"
-#include "../storagemanager/storeAddress.h"
-#include <utility>
-#include <cstddef>
-
-using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
-using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
-
-/**
- * @brief	This class provides an interface for intermediate data storage.
- * @details	The Storage manager classes shall be used to store larger chunks of
- * 			data in RAM for exchange between tasks. This interface expects the
- * 			data to be stored in one consecutive block of memory, so tasks can
- * 			write directly to the destination pointer.
- * 			For interprocess communication, the stores must be locked during
- * 			insertion and deletion. If the receiving storage identifier is
- * 			passed token-like between tasks, a lock during read and write
- * 			operations is not necessary.
- * @author	Bastian Baetz
- * @date	18.09.2012
- */
-class StorageManagerIF : public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
-	static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
-	static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
-	static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
-	static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
-	static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
-	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-
-	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
-	/**
-	 * @brief This is the empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~StorageManagerIF() {
-	}
-	;
-	/**
-	 * @brief	With addData, a free storage position is allocated and data
-	 * 			stored there.
-	 * @details	During the allocation, the StorageManager is blocked.
-	 * @param storageId A pointer to the storageId to retrieve.
-	 * @param data	The data to be stored in the StorageManager.
-	 * @param size	The amount of data to be stored.
-	 * @return	Returns @li RETURN_OK if data was added.
-	 * 					@li	RETURN_FAILED if data could not be added.
-	 * 						storageId is unchanged then.
-	 */
-	virtual ReturnValue_t addData(store_address_t* storageId,
-			const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
-	/**
-	 * @brief	With deleteData, the storageManager frees the memory region
-	 * 			identified by packet_id.
-	 * @param packet_id	The identifier of the memory region to be freed.
-	 * @return	@li RETURN_OK on success.
-	 * 			@li	RETURN_FAILED if deletion did not work
-	 * 				(e.g. an illegal packet_id was passed).
-	 */
-	virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
-	/**
-	 * @brief	Another deleteData which uses the pointer and size of the
-	 * 			stored data to delete the content.
-	 * @param buffer	Pointer to the data.
-	 * @param size		Size of data to be stored.
-	 * @param storeId	Store id of the deleted element (optional)
-	 * @return	@li RETURN_OK on success.
-	 * 			@li	failure code if deletion did not work
-	 */
-	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
-			store_address_t* storeId = nullptr) = 0;
-
-
-	/**
-	 * @brief 	Access the data by supplying a store ID.
-	 * @details
-	 * A pair consisting of the retrieval result and an instance of a
-	 * ConstStorageAccessor class is returned
-	 * @param storeId
-	 * @return Pair of return value and a ConstStorageAccessor instance
-	 */
-	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
-
-	/**
-	 * @brief 	Access the data by supplying a store ID and a helper
-	 * 			instance
-	 * @param storeId
-	 * @param constAccessor Wrapper function to access store data.
-	 * @return
-	 */
-	virtual ReturnValue_t getData(store_address_t storeId,
-			ConstStorageAccessor& constAccessor) = 0;
-
-
-	/**
-	 * @brief	getData returns an address to data and the size of the data
-	 * 			for a given packet_id.
-	 * @param packet_id		The id of the data to be returned
-	 * @param packet_ptr	The passed pointer address is set to the the memory
-	 * 						position
-	 * @param size			The exact size of the stored data is returned here.
-	 * @return	@li RETURN_OK on success.
-	 * 			@li	RETURN_FAILED if fetching data did not work
-	 * 				(e.g. an illegal packet_id was passed).
-	 */
-	virtual ReturnValue_t getData(store_address_t packet_id,
-			const uint8_t** packet_ptr, size_t* size) = 0;
-
-
-	/**
-	 * Modify data by supplying a store ID
-	 * @param storeId
-	 * @return Pair of return value and StorageAccessor helper
-	 */
-	virtual AccessorPair modifyData(store_address_t storeId) = 0;
-
-	/**
-	 * Modify data by supplying a store ID and a StorageAccessor helper instance.
-	 * @param storeId
-	 * @param accessor Helper class to access the modifiable data.
-	 * @return
-	 */
-	virtual ReturnValue_t modifyData(store_address_t storeId,
-				StorageAccessor& accessor) = 0;
-
-	/**
-	 * Get pointer and size of modifiable data by supplying the storeId
-	 * @param packet_id
-	 * @param packet_ptr [out] Pointer to pointer of data to set
-	 * @param size [out] Pointer to size to set
-	 * @return
-	 */
-	virtual ReturnValue_t modifyData(store_address_t packet_id,
-			uint8_t** packet_ptr, size_t* size) = 0;
-	/**
-	 * This method reserves an element of \c size.
-	 *
-	 * It returns the packet id of this element as well as a direct pointer to the
-	 * data of the element. It must be assured that exactly \c size data is
-	 * written to p_data!
-	 * @param storageId A pointer to the storageId to retrieve.
-	 * @param size		The size of the space to be reserved.
-	 * @param p_data	A pointer to the element data is returned here.
-	 * @return	Returns @li RETURN_OK if data was added.
-	 * 					@li	RETURN_FAILED if data could not be added.
-	 * 						storageId is unchanged then.
-	 */
-	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
-			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
-
-	/**
-	 * Clears the whole store.
-	 * Use with care!
-	 */
-	virtual void clearStore() = 0;
-};
-
-#endif /* STORAGEMANAGERIF_H_ */
+#ifndef STORAGEMANAGERIF_H_H
+#define STORAGEMANAGERIF_H_H
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageAccessor.h"
+#include "../storagemanager/storeAddress.h"
+#include <utility>
+#include <cstddef>
+
+using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
+using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
+
+/**
+ * @brief	This class provides an interface for intermediate data storage.
+ * @details	The Storage manager classes shall be used to store larger chunks of
+ * 			data in RAM for exchange between tasks. This interface expects the
+ * 			data to be stored in one consecutive block of memory, so tasks can
+ * 			write directly to the destination pointer.
+ * 			For interprocess communication, the stores must be locked during
+ * 			insertion and deletion. If the receiving storage identifier is
+ * 			passed token-like between tasks, a lock during read and write
+ * 			operations is not necessary.
+ * @author	Bastian Baetz
+ * @date	18.09.2012
+ */
+class StorageManagerIF : public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
+	static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
+	static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
+	static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
+	static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
+	static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
+	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+
+	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
+	/**
+	 * @brief This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~StorageManagerIF() {
+	}
+	;
+	/**
+	 * @brief	With addData, a free storage position is allocated and data
+	 * 			stored there.
+	 * @details	During the allocation, the StorageManager is blocked.
+	 * @param storageId A pointer to the storageId to retrieve.
+	 * @param data	The data to be stored in the StorageManager.
+	 * @param size	The amount of data to be stored.
+	 * @return	Returns @li RETURN_OK if data was added.
+	 * 					@li	RETURN_FAILED if data could not be added.
+	 * 						storageId is unchanged then.
+	 */
+	virtual ReturnValue_t addData(store_address_t* storageId,
+			const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
+	/**
+	 * @brief	With deleteData, the storageManager frees the memory region
+	 * 			identified by packet_id.
+	 * @param packet_id	The identifier of the memory region to be freed.
+	 * @return	@li RETURN_OK on success.
+	 * 			@li	RETURN_FAILED if deletion did not work
+	 * 				(e.g. an illegal packet_id was passed).
+	 */
+	virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
+	/**
+	 * @brief	Another deleteData which uses the pointer and size of the
+	 * 			stored data to delete the content.
+	 * @param buffer	Pointer to the data.
+	 * @param size		Size of data to be stored.
+	 * @param storeId	Store id of the deleted element (optional)
+	 * @return	@li RETURN_OK on success.
+	 * 			@li	failure code if deletion did not work
+	 */
+	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = nullptr) = 0;
+
+
+	/**
+	 * @brief 	Access the data by supplying a store ID.
+	 * @details
+	 * A pair consisting of the retrieval result and an instance of a
+	 * ConstStorageAccessor class is returned
+	 * @param storeId
+	 * @return Pair of return value and a ConstStorageAccessor instance
+	 */
+	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
+
+	/**
+	 * @brief 	Access the data by supplying a store ID and a helper
+	 * 			instance
+	 * @param storeId
+	 * @param constAccessor Wrapper function to access store data.
+	 * @return
+	 */
+	virtual ReturnValue_t getData(store_address_t storeId,
+			ConstStorageAccessor& constAccessor) = 0;
+
+
+	/**
+	 * @brief	getData returns an address to data and the size of the data
+	 * 			for a given packet_id.
+	 * @param packet_id		The id of the data to be returned
+	 * @param packet_ptr	The passed pointer address is set to the the memory
+	 * 						position
+	 * @param size			The exact size of the stored data is returned here.
+	 * @return	@li RETURN_OK on success.
+	 * 			@li	RETURN_FAILED if fetching data did not work
+	 * 				(e.g. an illegal packet_id was passed).
+	 */
+	virtual ReturnValue_t getData(store_address_t packet_id,
+			const uint8_t** packet_ptr, size_t* size) = 0;
+
+
+	/**
+	 * Modify data by supplying a store ID
+	 * @param storeId
+	 * @return Pair of return value and StorageAccessor helper
+	 */
+	virtual AccessorPair modifyData(store_address_t storeId) = 0;
+
+	/**
+	 * Modify data by supplying a store ID and a StorageAccessor helper instance.
+	 * @param storeId
+	 * @param accessor Helper class to access the modifiable data.
+	 * @return
+	 */
+	virtual ReturnValue_t modifyData(store_address_t storeId,
+				StorageAccessor& accessor) = 0;
+
+	/**
+	 * Get pointer and size of modifiable data by supplying the storeId
+	 * @param packet_id
+	 * @param packet_ptr [out] Pointer to pointer of data to set
+	 * @param size [out] Pointer to size to set
+	 * @return
+	 */
+	virtual ReturnValue_t modifyData(store_address_t packet_id,
+			uint8_t** packet_ptr, size_t* size) = 0;
+	/**
+	 * This method reserves an element of \c size.
+	 *
+	 * It returns the packet id of this element as well as a direct pointer to the
+	 * data of the element. It must be assured that exactly \c size data is
+	 * written to p_data!
+	 * @param storageId A pointer to the storageId to retrieve.
+	 * @param size		The size of the space to be reserved.
+	 * @param p_data	A pointer to the element data is returned here.
+	 * @return	Returns @li RETURN_OK if data was added.
+	 * 					@li	RETURN_FAILED if data could not be added.
+	 * 						storageId is unchanged then.
+	 */
+	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
+			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+
+	/**
+	 * Clears the whole store.
+	 * Use with care!
+	 */
+	virtual void clearStore() = 0;
+};
+
+#endif /* STORAGEMANAGERIF_H_ */
diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index de4761faa..2b501574f 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -1,164 +1,164 @@
-#ifndef SUBSYSTEM_H_
-#define SUBSYSTEM_H_
-
-#include "../container/FixedArrayList.h"
-#include "../container/FixedMap.h"
-#include "../container/HybridIterator.h"
-#include "../container/SinglyLinkedList.h"
-#include "../serialize/SerialArrayListAdapter.h"
-#include "../subsystem/modes/ModeDefinitions.h"
-#include "../subsystem/SubsystemBase.h"
-
-class Subsystem: public SubsystemBase, public HasModeSequenceIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM;
-	static const ReturnValue_t SEQUENCE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t TABLE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t TABLE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t TABLE_OR_SEQUENCE_LENGTH_INVALID = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t SEQUENCE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
-			MAKE_RETURN_CODE(0x06);
-	static const ReturnValue_t FALLBACK_SEQUENCE_DOES_NOT_EXIST =
-			MAKE_RETURN_CODE(0x07);
-	static const ReturnValue_t NO_TARGET_TABLE = MAKE_RETURN_CODE(0x08);
-	static const ReturnValue_t SEQUENCE_OR_TABLE_TOO_LONG = MAKE_RETURN_CODE(0x09);
-	static const ReturnValue_t IS_FALLBACK_SEQUENCE = MAKE_RETURN_CODE(0x0B);
-	static const ReturnValue_t ACCESS_DENIED = MAKE_RETURN_CODE(0x0C);
-	static const ReturnValue_t TABLE_IN_USE = MAKE_RETURN_CODE(0x0E);
-
-	static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1);
-	static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2);
-
-
-
-	Subsystem(object_id_t setObjectId, object_id_t parent,
-			uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
-	virtual ~Subsystem();
-
-	ReturnValue_t addSequence(ArrayList<ModeListEntry>* sequence, Mode_t id,
-			Mode_t fallbackSequence, bool inStore = true, bool preInit = true);
-
-	ReturnValue_t addTable(ArrayList<ModeListEntry> *table, Mode_t id,
-			bool inStore = true, bool preInit = true);
-
-	void setInitialMode(Mode_t mode);
-
-	virtual ReturnValue_t initialize();
-
-	virtual ReturnValue_t checkObjectConnections();
-
-	virtual MessageQueueId_t getSequenceCommandQueue() const;
-
-	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
-	 * @param sequence
-	 * @return
-	 */
-	ReturnValue_t checkSequence(Mode_t sequence);
-
-	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
-	 * @param iter
-	 * @return
-	 */
-	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter, Mode_t fallbackSequence);
-protected:
-
-	struct EntryPointer {
-		bool islinked;
-		union {
-			ModeListEntry *firstLinkedElement;
-			ArrayList<ModeListEntry> *array;
-		};
-	};
-
-	struct SequenceInfo {
-		Mode_t fallbackSequence;
-		EntryPointer entries;
-	};
-
-	static const uint8_t MAX_NUMBER_OF_TABLES_OR_SEQUENCES = 70;
-
-	static const uint8_t MAX_LENGTH_OF_TABLE_OR_SEQUENCE = 20;
-
-	bool isInTransition;
-
-	bool childrenChangedHealth;
-
-	uint32_t uptimeStartTable = 0;
-
-	HybridIterator<ModeListEntry> currentTargetTable;
-
-	Mode_t targetMode;
-
-	Submode_t targetSubmode;
-
-	Mode_t initialMode;
-
-	HybridIterator<ModeListEntry> currentSequenceIterator;
-
-	FixedMap<Mode_t, EntryPointer> modeTables;
-
-	FixedMap<Mode_t, SequenceInfo> modeSequences;
-
-	StorageManagerIF *IPCStore = nullptr;
-
-#ifdef USE_MODESTORE
-	ModeStoreIF *modeStore = nullptr;
-#endif
-
-	bool existsModeSequence(Mode_t id);
-
-	HybridIterator<ModeListEntry> getSequence(Mode_t id);
-
-	bool existsModeTable(Mode_t id);
-
-	HybridIterator<ModeListEntry> getTable(Mode_t id);
-
-	HybridIterator<ModeListEntry> getCurrentTable();
-
-//	void startSequence(Mode_t sequence);
-
-	/**
-	 * DO NOT USE ON NON EXISTING SEQUENCE
-	 *
-	 * @param a sequence
-	 * @return the fallback sequence's Id
-	 */
-	Mode_t getFallbackSequence(Mode_t sequence);
-
-	void replyToCommand(ReturnValue_t status, uint32_t parameter);
-
-	ReturnValue_t deleteSequence(Mode_t id);
-
-	ReturnValue_t deleteTable(Mode_t id);
-
-	virtual void performChildOperation();
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
-
-	bool isFallbackSequence(Mode_t SequenceId);
-
-	bool isTableUsed(Mode_t tableId);
-
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode);
-
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-
-	void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);
-
-	void transitionFailed(ReturnValue_t failureCode, uint32_t parameter);
-
-	void cantKeepMode();
-
-};
-
-#endif /* SUBSYSTEM_H_ */
+#ifndef SUBSYSTEM_H_
+#define SUBSYSTEM_H_
+
+#include "../container/FixedArrayList.h"
+#include "../container/FixedMap.h"
+#include "../container/HybridIterator.h"
+#include "../container/SinglyLinkedList.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include "../subsystem/modes/ModeDefinitions.h"
+#include "../subsystem/SubsystemBase.h"
+
+class Subsystem: public SubsystemBase, public HasModeSequenceIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM;
+	static const ReturnValue_t SEQUENCE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t TABLE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t TABLE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t TABLE_OR_SEQUENCE_LENGTH_INVALID = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t SEQUENCE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
+			MAKE_RETURN_CODE(0x06);
+	static const ReturnValue_t FALLBACK_SEQUENCE_DOES_NOT_EXIST =
+			MAKE_RETURN_CODE(0x07);
+	static const ReturnValue_t NO_TARGET_TABLE = MAKE_RETURN_CODE(0x08);
+	static const ReturnValue_t SEQUENCE_OR_TABLE_TOO_LONG = MAKE_RETURN_CODE(0x09);
+	static const ReturnValue_t IS_FALLBACK_SEQUENCE = MAKE_RETURN_CODE(0x0B);
+	static const ReturnValue_t ACCESS_DENIED = MAKE_RETURN_CODE(0x0C);
+	static const ReturnValue_t TABLE_IN_USE = MAKE_RETURN_CODE(0x0E);
+
+	static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1);
+	static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2);
+
+
+
+	Subsystem(object_id_t setObjectId, object_id_t parent,
+			uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
+	virtual ~Subsystem();
+
+	ReturnValue_t addSequence(ArrayList<ModeListEntry>* sequence, Mode_t id,
+			Mode_t fallbackSequence, bool inStore = true, bool preInit = true);
+
+	ReturnValue_t addTable(ArrayList<ModeListEntry> *table, Mode_t id,
+			bool inStore = true, bool preInit = true);
+
+	void setInitialMode(Mode_t mode);
+
+	virtual ReturnValue_t initialize();
+
+	virtual ReturnValue_t checkObjectConnections();
+
+	virtual MessageQueueId_t getSequenceCommandQueue() const;
+
+	/**
+	 *
+	 *
+	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
+	 *
+	 * @param sequence
+	 * @return
+	 */
+	ReturnValue_t checkSequence(Mode_t sequence);
+
+	/**
+	 *
+	 *
+	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
+	 *
+	 * @param iter
+	 * @return
+	 */
+	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter, Mode_t fallbackSequence);
+protected:
+
+	struct EntryPointer {
+		bool islinked;
+		union {
+			ModeListEntry *firstLinkedElement;
+			ArrayList<ModeListEntry> *array;
+		};
+	};
+
+	struct SequenceInfo {
+		Mode_t fallbackSequence;
+		EntryPointer entries;
+	};
+
+	static const uint8_t MAX_NUMBER_OF_TABLES_OR_SEQUENCES = 70;
+
+	static const uint8_t MAX_LENGTH_OF_TABLE_OR_SEQUENCE = 20;
+
+	bool isInTransition;
+
+	bool childrenChangedHealth;
+
+	uint32_t uptimeStartTable = 0;
+
+	HybridIterator<ModeListEntry> currentTargetTable;
+
+	Mode_t targetMode;
+
+	Submode_t targetSubmode;
+
+	Mode_t initialMode;
+
+	HybridIterator<ModeListEntry> currentSequenceIterator;
+
+	FixedMap<Mode_t, EntryPointer> modeTables;
+
+	FixedMap<Mode_t, SequenceInfo> modeSequences;
+
+	StorageManagerIF *IPCStore = nullptr;
+
+#ifdef USE_MODESTORE
+	ModeStoreIF *modeStore = nullptr;
+#endif
+
+	bool existsModeSequence(Mode_t id);
+
+	HybridIterator<ModeListEntry> getSequence(Mode_t id);
+
+	bool existsModeTable(Mode_t id);
+
+	HybridIterator<ModeListEntry> getTable(Mode_t id);
+
+	HybridIterator<ModeListEntry> getCurrentTable();
+
+//	void startSequence(Mode_t sequence);
+
+	/**
+	 * DO NOT USE ON NON EXISTING SEQUENCE
+	 *
+	 * @param a sequence
+	 * @return the fallback sequence's Id
+	 */
+	Mode_t getFallbackSequence(Mode_t sequence);
+
+	void replyToCommand(ReturnValue_t status, uint32_t parameter);
+
+	ReturnValue_t deleteSequence(Mode_t id);
+
+	ReturnValue_t deleteTable(Mode_t id);
+
+	virtual void performChildOperation();
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
+
+	bool isFallbackSequence(Mode_t SequenceId);
+
+	bool isTableUsed(Mode_t tableId);
+
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode);
+
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+
+	void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);
+
+	void transitionFailed(ReturnValue_t failureCode, uint32_t parameter);
+
+	void cantKeepMode();
+
+};
+
+#endif /* SUBSYSTEM_H_ */
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 2bd6c1ad3..17599808f 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -1,356 +1,356 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../subsystem/SubsystemBase.h"
-#include "../ipc/QueueFactory.h"
-
-SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
-		Mode_t initialMode, uint16_t commandQueueDepth) :
-		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
-		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
-		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
-			MessageQueueMessage::MAX_MESSAGE_SIZE);
-}
-
-SubsystemBase::~SubsystemBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-
-}
-
-ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
-	ChildInfo info;
-
-	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
-	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
-	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
-	if (child == nullptr) {
-		if (healthChild == nullptr) {
-			return CHILD_DOESNT_HAVE_MODES;
-		} else {
-			info.commandQueue = healthChild->getCommandQueue();
-			info.mode = MODE_OFF;
-		}
-	} else {
-		info.commandQueue = child->getCommandQueue();
-		info.mode = -1;	//intentional to force an initial command during system startup
-	}
-
-	info.submode = SUBMODE_NONE;
-	info.healthChanged = false;
-
-	std::pair<std::map<object_id_t, ChildInfo>::iterator, bool> returnValue =
-			childrenMap.insert(
-					std::pair<object_id_t, ChildInfo>(objectId, info));
-	if (!(returnValue.second)) {
-		return COULD_NOT_INSERT_CHILD;
-	} else {
-		return RETURN_OK;
-	}
-}
-
-ReturnValue_t SubsystemBase::checkStateAgainstTable(
-		HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
-
-	std::map<object_id_t, ChildInfo>::iterator childIter;
-
-	for (; tableIter.value != NULL; ++tableIter) {
-		object_id_t object = tableIter.value->getObject();
-
-		if ((childIter = childrenMap.find(object)) == childrenMap.end()) {
-			return RETURN_FAILED;
-		}
-
-		if (childIter->second.mode != tableIter.value->getMode()) {
-			return RETURN_FAILED;
-		}
-
-		Submode_t submodeToCheckAgainst = tableIter.value->getSubmode();
-		if (tableIter.value->inheritSubmode()) {
-			submodeToCheckAgainst = targetSubmode;
-		}
-
-		if (childIter->second.submode != submodeToCheckAgainst) {
-			return RETURN_FAILED;
-		}
-	}
-	return RETURN_OK;
-}
-
-void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
-        Submode_t targetSubmode) {
-	CommandMessage command;
-
-	std::map<object_id_t, ChildInfo>::iterator iter;
-
-	commandsOutstanding = 0;
-
-	for (; tableIter.value != nullptr; ++tableIter) {
-		object_id_t object = tableIter.value->getObject();
-		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
-			//illegal table entry, should only happen due to misconfigured mode table
-			sif::debug << std::hex << getObjectId() << ": invalid mode table entry"
-					<< std::endl;
-			continue;
-		}
-
-		Submode_t submodeToCommand = tableIter.value->getSubmode();
-		if (tableIter.value->inheritSubmode()) {
-			submodeToCommand = targetSubmode;
-		}
-
-		if (healthHelper.healthTable->hasHealth(object)) {
-			if (healthHelper.healthTable->isFaulty(object)) {
-				ModeMessage::setModeMessage(&command,
-						ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
-						SUBMODE_NONE);
-			} else {
-				if (modeHelper.isForced()) {
-					ModeMessage::setModeMessage(&command,
-							ModeMessage::CMD_MODE_COMMAND_FORCED,
-							tableIter.value->getMode(), submodeToCommand);
-				} else {
-					if (healthHelper.healthTable->isCommandable(object)) {
-						ModeMessage::setModeMessage(&command,
-								ModeMessage::CMD_MODE_COMMAND,
-								tableIter.value->getMode(), submodeToCommand);
-					} else {
-						continue;
-					}
-				}
-			}
-		} else {
-			ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
-					tableIter.value->getMode(), submodeToCommand);
-		}
-
-		if ((iter->second.mode == ModeMessage::getMode(&command))
-				&& (iter->second.submode == ModeMessage::getSubmode(&command))
-				&& !modeHelper.isForced()) {
-			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
-		}
-		ReturnValue_t result = commandQueue->sendMessage(
-				iter->second.commandQueue, &command);
-		if (result == RETURN_OK) {
-			++commandsOutstanding;
-		}
-	}
-
-}
-
-ReturnValue_t SubsystemBase::updateChildMode(MessageQueueId_t queue,
-		Mode_t mode, Submode_t submode) {
-	std::map<object_id_t, ChildInfo>::iterator iter;
-
-	for (iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
-		if (iter->second.commandQueue == queue) {
-			iter->second.mode = mode;
-			iter->second.submode = submode;
-			return RETURN_OK;
-		}
-	}
-	return CHILD_NOT_FOUND;
-}
-
-ReturnValue_t SubsystemBase::updateChildChangedHealth(MessageQueueId_t queue,
-bool changedHealth) {
-	for (auto iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
-		if (iter->second.commandQueue == queue) {
-			iter->second.healthChanged = changedHealth;
-			return RETURN_OK;
-		}
-	}
-	return CHILD_NOT_FOUND;
-}
-
-MessageQueueId_t SubsystemBase::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t SubsystemBase::initialize() {
-	MessageQueueId_t parentQueue = 0;
-	ReturnValue_t result = SystemObject::initialize();
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	if (parentId != 0) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
-
-		parent->registerChild(getObjectId());
-	}
-
-	result = healthHelper.initialize(parentQueue);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	result = modeHelper.initialize(parentQueue);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	return RETURN_OK;
-}
-
-ReturnValue_t SubsystemBase::performOperation(uint8_t opCode) {
-
-	childrenChangedMode = false;
-
-	checkCommandQueue();
-
-	performChildOperation();
-
-	return RETURN_OK;
-}
-
-ReturnValue_t SubsystemBase::handleModeReply(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case ModeMessage::REPLY_MODE_INFO:
-		updateChildMode(message->getSender(), ModeMessage::getMode(message),
-				ModeMessage::getSubmode(message));
-		childrenChangedMode = true;
-		return RETURN_OK;
-	case ModeMessage::REPLY_MODE_REPLY:
-	case ModeMessage::REPLY_WRONG_MODE_REPLY:
-		updateChildMode(message->getSender(), ModeMessage::getMode(message),
-				ModeMessage::getSubmode(message));
-		childrenChangedMode = true;
-		commandsOutstanding--;
-		return RETURN_OK;
-	case ModeMessage::REPLY_CANT_REACH_MODE:
-		commandsOutstanding--;
-		{
-			for (auto iter = childrenMap.begin(); iter != childrenMap.end();
-					iter++) {
-				if (iter->second.commandQueue == message->getSender()) {
-					triggerEvent(MODE_CMD_REJECTED, iter->first,
-							message->getParameter());
-				}
-			}
-		}
-		return RETURN_OK;
-//	case ModeMessage::CMD_MODE_COMMAND:
-//		handleCommandedMode(message);
-//		return RETURN_OK;
-//	case ModeMessage::CMD_MODE_ANNOUNCE:
-//		triggerEvent(MODE_INFO, mode, submode);
-//		return RETURN_OK;
-//	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
-//		triggerEvent(MODE_INFO, mode, submode);
-//		commandAllChildren(message);
-//		return RETURN_OK;
-	default:
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t SubsystemBase::checkTable(
-		HybridIterator<ModeListEntry> tableIter) {
-	for (; tableIter.value != NULL; ++tableIter) {
-		if (childrenMap.find(tableIter.value->getObject())
-				== childrenMap.end()) {
-			return TABLE_CONTAINS_INVALID_OBJECT_ID;
-		}
-	}
-	return RETURN_OK;
-}
-
-void SubsystemBase::replyToCommand(CommandMessage* message) {
-	commandQueue->reply(message);
-}
-
-void SubsystemBase::setMode(Mode_t newMode, Submode_t newSubmode) {
-	modeHelper.modeChanged(newMode, newSubmode);
-	mode = newMode;
-	submode = newSubmode;
-	modeChanged();
-	announceMode(false);
-}
-
-void SubsystemBase::setMode(Mode_t newMode) {
-	setMode(newMode, submode);
-}
-
-void SubsystemBase::commandAllChildren(CommandMessage* message) {
-	std::map<object_id_t, ChildInfo>::iterator iter;
-	for (iter = childrenMap.begin(); iter != childrenMap.end(); ++iter) {
-		commandQueue->sendMessage(iter->second.commandQueue, message);
-	}
-}
-
-void SubsystemBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
-}
-
-void SubsystemBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
-}
-
-void SubsystemBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
-	if (recursive) {
-		CommandMessage command;
-		ModeMessage::setModeMessage(&command,
-				ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
-		commandAllChildren(&command);
-	}
-}
-
-void SubsystemBase::checkCommandQueue() {
-	ReturnValue_t result;
-	CommandMessage command;
-
-	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
-
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = modeHelper.handleModeCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = handleModeReply(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = handleCommandMessage(&command);
-		if (result != RETURN_OK) {
-			CommandMessage reply;
-			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
-					command.getCommand());
-			replyToCommand(&reply);
-		}
-	}
-}
-
-ReturnValue_t SubsystemBase::setHealth(HealthState health) {
-	switch (health) {
-	case HEALTHY:
-	case EXTERNAL_CONTROL:
-		healthHelper.setHealth(health);
-		return RETURN_OK;
-	default:
-		return INVALID_HEALTH_STATE;
-	}
-}
-
-HasHealthIF::HealthState SubsystemBase::getHealth() {
-	return healthHelper.getHealth();
-}
-
-void SubsystemBase::modeChanged() {
-}
-
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../subsystem/SubsystemBase.h"
+#include "../ipc/QueueFactory.h"
+
+SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
+		Mode_t initialMode, uint16_t commandQueueDepth) :
+		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
+		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
+		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
+			MessageQueueMessage::MAX_MESSAGE_SIZE);
+}
+
+SubsystemBase::~SubsystemBase() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+
+}
+
+ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
+	ChildInfo info;
+
+	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
+	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
+	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
+	if (child == nullptr) {
+		if (healthChild == nullptr) {
+			return CHILD_DOESNT_HAVE_MODES;
+		} else {
+			info.commandQueue = healthChild->getCommandQueue();
+			info.mode = MODE_OFF;
+		}
+	} else {
+		info.commandQueue = child->getCommandQueue();
+		info.mode = -1;	//intentional to force an initial command during system startup
+	}
+
+	info.submode = SUBMODE_NONE;
+	info.healthChanged = false;
+
+	std::pair<std::map<object_id_t, ChildInfo>::iterator, bool> returnValue =
+			childrenMap.insert(
+					std::pair<object_id_t, ChildInfo>(objectId, info));
+	if (!(returnValue.second)) {
+		return COULD_NOT_INSERT_CHILD;
+	} else {
+		return RETURN_OK;
+	}
+}
+
+ReturnValue_t SubsystemBase::checkStateAgainstTable(
+		HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
+
+	std::map<object_id_t, ChildInfo>::iterator childIter;
+
+	for (; tableIter.value != NULL; ++tableIter) {
+		object_id_t object = tableIter.value->getObject();
+
+		if ((childIter = childrenMap.find(object)) == childrenMap.end()) {
+			return RETURN_FAILED;
+		}
+
+		if (childIter->second.mode != tableIter.value->getMode()) {
+			return RETURN_FAILED;
+		}
+
+		Submode_t submodeToCheckAgainst = tableIter.value->getSubmode();
+		if (tableIter.value->inheritSubmode()) {
+			submodeToCheckAgainst = targetSubmode;
+		}
+
+		if (childIter->second.submode != submodeToCheckAgainst) {
+			return RETURN_FAILED;
+		}
+	}
+	return RETURN_OK;
+}
+
+void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
+        Submode_t targetSubmode) {
+	CommandMessage command;
+
+	std::map<object_id_t, ChildInfo>::iterator iter;
+
+	commandsOutstanding = 0;
+
+	for (; tableIter.value != nullptr; ++tableIter) {
+		object_id_t object = tableIter.value->getObject();
+		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
+			//illegal table entry, should only happen due to misconfigured mode table
+			sif::debug << std::hex << getObjectId() << ": invalid mode table entry"
+					<< std::endl;
+			continue;
+		}
+
+		Submode_t submodeToCommand = tableIter.value->getSubmode();
+		if (tableIter.value->inheritSubmode()) {
+			submodeToCommand = targetSubmode;
+		}
+
+		if (healthHelper.healthTable->hasHealth(object)) {
+			if (healthHelper.healthTable->isFaulty(object)) {
+				ModeMessage::setModeMessage(&command,
+						ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
+						SUBMODE_NONE);
+			} else {
+				if (modeHelper.isForced()) {
+					ModeMessage::setModeMessage(&command,
+							ModeMessage::CMD_MODE_COMMAND_FORCED,
+							tableIter.value->getMode(), submodeToCommand);
+				} else {
+					if (healthHelper.healthTable->isCommandable(object)) {
+						ModeMessage::setModeMessage(&command,
+								ModeMessage::CMD_MODE_COMMAND,
+								tableIter.value->getMode(), submodeToCommand);
+					} else {
+						continue;
+					}
+				}
+			}
+		} else {
+			ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
+					tableIter.value->getMode(), submodeToCommand);
+		}
+
+		if ((iter->second.mode == ModeMessage::getMode(&command))
+				&& (iter->second.submode == ModeMessage::getSubmode(&command))
+				&& !modeHelper.isForced()) {
+			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
+		}
+		ReturnValue_t result = commandQueue->sendMessage(
+				iter->second.commandQueue, &command);
+		if (result == RETURN_OK) {
+			++commandsOutstanding;
+		}
+	}
+
+}
+
+ReturnValue_t SubsystemBase::updateChildMode(MessageQueueId_t queue,
+		Mode_t mode, Submode_t submode) {
+	std::map<object_id_t, ChildInfo>::iterator iter;
+
+	for (iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
+		if (iter->second.commandQueue == queue) {
+			iter->second.mode = mode;
+			iter->second.submode = submode;
+			return RETURN_OK;
+		}
+	}
+	return CHILD_NOT_FOUND;
+}
+
+ReturnValue_t SubsystemBase::updateChildChangedHealth(MessageQueueId_t queue,
+bool changedHealth) {
+	for (auto iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
+		if (iter->second.commandQueue == queue) {
+			iter->second.healthChanged = changedHealth;
+			return RETURN_OK;
+		}
+	}
+	return CHILD_NOT_FOUND;
+}
+
+MessageQueueId_t SubsystemBase::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t SubsystemBase::initialize() {
+	MessageQueueId_t parentQueue = 0;
+	ReturnValue_t result = SystemObject::initialize();
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	if (parentId != 0) {
+		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		if (parent == NULL) {
+			return RETURN_FAILED;
+		}
+		parentQueue = parent->getCommandQueue();
+
+		parent->registerChild(getObjectId());
+	}
+
+	result = healthHelper.initialize(parentQueue);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	result = modeHelper.initialize(parentQueue);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	return RETURN_OK;
+}
+
+ReturnValue_t SubsystemBase::performOperation(uint8_t opCode) {
+
+	childrenChangedMode = false;
+
+	checkCommandQueue();
+
+	performChildOperation();
+
+	return RETURN_OK;
+}
+
+ReturnValue_t SubsystemBase::handleModeReply(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case ModeMessage::REPLY_MODE_INFO:
+		updateChildMode(message->getSender(), ModeMessage::getMode(message),
+				ModeMessage::getSubmode(message));
+		childrenChangedMode = true;
+		return RETURN_OK;
+	case ModeMessage::REPLY_MODE_REPLY:
+	case ModeMessage::REPLY_WRONG_MODE_REPLY:
+		updateChildMode(message->getSender(), ModeMessage::getMode(message),
+				ModeMessage::getSubmode(message));
+		childrenChangedMode = true;
+		commandsOutstanding--;
+		return RETURN_OK;
+	case ModeMessage::REPLY_CANT_REACH_MODE:
+		commandsOutstanding--;
+		{
+			for (auto iter = childrenMap.begin(); iter != childrenMap.end();
+					iter++) {
+				if (iter->second.commandQueue == message->getSender()) {
+					triggerEvent(MODE_CMD_REJECTED, iter->first,
+							message->getParameter());
+				}
+			}
+		}
+		return RETURN_OK;
+//	case ModeMessage::CMD_MODE_COMMAND:
+//		handleCommandedMode(message);
+//		return RETURN_OK;
+//	case ModeMessage::CMD_MODE_ANNOUNCE:
+//		triggerEvent(MODE_INFO, mode, submode);
+//		return RETURN_OK;
+//	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
+//		triggerEvent(MODE_INFO, mode, submode);
+//		commandAllChildren(message);
+//		return RETURN_OK;
+	default:
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t SubsystemBase::checkTable(
+		HybridIterator<ModeListEntry> tableIter) {
+	for (; tableIter.value != NULL; ++tableIter) {
+		if (childrenMap.find(tableIter.value->getObject())
+				== childrenMap.end()) {
+			return TABLE_CONTAINS_INVALID_OBJECT_ID;
+		}
+	}
+	return RETURN_OK;
+}
+
+void SubsystemBase::replyToCommand(CommandMessage* message) {
+	commandQueue->reply(message);
+}
+
+void SubsystemBase::setMode(Mode_t newMode, Submode_t newSubmode) {
+	modeHelper.modeChanged(newMode, newSubmode);
+	mode = newMode;
+	submode = newSubmode;
+	modeChanged();
+	announceMode(false);
+}
+
+void SubsystemBase::setMode(Mode_t newMode) {
+	setMode(newMode, submode);
+}
+
+void SubsystemBase::commandAllChildren(CommandMessage* message) {
+	std::map<object_id_t, ChildInfo>::iterator iter;
+	for (iter = childrenMap.begin(); iter != childrenMap.end(); ++iter) {
+		commandQueue->sendMessage(iter->second.commandQueue, message);
+	}
+}
+
+void SubsystemBase::getMode(Mode_t* mode, Submode_t* submode) {
+	*mode = this->mode;
+	*submode = this->submode;
+}
+
+void SubsystemBase::setToExternalControl() {
+	healthHelper.setHealth(EXTERNAL_CONTROL);
+}
+
+void SubsystemBase::announceMode(bool recursive) {
+	triggerEvent(MODE_INFO, mode, submode);
+	if (recursive) {
+		CommandMessage command;
+		ModeMessage::setModeMessage(&command,
+				ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
+		commandAllChildren(&command);
+	}
+}
+
+void SubsystemBase::checkCommandQueue() {
+	ReturnValue_t result;
+	CommandMessage command;
+
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
+
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = modeHelper.handleModeCommand(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = handleModeReply(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = handleCommandMessage(&command);
+		if (result != RETURN_OK) {
+			CommandMessage reply;
+			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
+					command.getCommand());
+			replyToCommand(&reply);
+		}
+	}
+}
+
+ReturnValue_t SubsystemBase::setHealth(HealthState health) {
+	switch (health) {
+	case HEALTHY:
+	case EXTERNAL_CONTROL:
+		healthHelper.setHealth(health);
+		return RETURN_OK;
+	default:
+		return INVALID_HEALTH_STATE;
+	}
+}
+
+HasHealthIF::HealthState SubsystemBase::getHealth() {
+	return healthHelper.getHealth();
+}
+
+void SubsystemBase::modeChanged() {
+}
+
diff --git a/subsystem/SubsystemBase.h b/subsystem/SubsystemBase.h
index c0abbe400..2d949b56c 100644
--- a/subsystem/SubsystemBase.h
+++ b/subsystem/SubsystemBase.h
@@ -1,129 +1,129 @@
-#ifndef SUBSYSTEMBASE_H_
-#define SUBSYSTEMBASE_H_
-
-#include "../container/HybridIterator.h"
-#include "../health/HasHealthIF.h"
-#include "../health/HealthHelper.h"
-#include "../modes/HasModesIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../subsystem/modes/HasModeSequenceIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include <map>
-
-/**
- * @defgroup subsystems Subsystem Objects
- * Contains all Subsystem and Assemblies
- */
-class SubsystemBase: public SystemObject,
-		public HasModesIF,
-		public HasHealthIF,
-		public HasReturnvaluesIF,
-		public ExecutableObjectIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM_BASE;
-	static const ReturnValue_t CHILD_NOT_FOUND = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t CHILD_INFO_UPDATED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t CHILD_DOESNT_HAVE_MODES = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t COULD_NOT_INSERT_CHILD = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
-			MAKE_RETURN_CODE(0x05);
-
-	SubsystemBase(object_id_t setObjectId, object_id_t parent,
-			Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
-	virtual ~SubsystemBase();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t registerChild(object_id_t objectId);
-
-	virtual ReturnValue_t initialize();
-
-	virtual ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual ReturnValue_t setHealth(HealthState health);
-
-	virtual HasHealthIF::HealthState getHealth();
-
-protected:
-	struct ChildInfo {
-		MessageQueueId_t commandQueue;
-		Mode_t mode;
-		Submode_t submode;bool healthChanged;
-	};
-
-	Mode_t mode;
-
-	Submode_t submode;
-
-	bool childrenChangedMode;
-
-	/**
-	 * Always check this against <=0, so you are robust against too many replies
-	 */
-	int32_t commandsOutstanding;
-
-	MessageQueueIF* commandQueue;
-
-	HealthHelper healthHelper;
-
-	ModeHelper modeHelper;
-
-	const object_id_t parentId;
-
-	typedef std::map<object_id_t, ChildInfo> ChildrenMap;
-	ChildrenMap childrenMap;
-
-	void checkCommandQueue();
-
-	/**
-	 * We need to know the target Submode, as children are able to inherit the submode
-	 */
-	ReturnValue_t checkStateAgainstTable(
-			HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode);
-
-	/**
-	 * We need to know the target Submode, as children are able to inherit the submode
-	 * Still, we have a default for all child implementations which do not use submode inheritance
-	 */
-	void executeTable(HybridIterator<ModeListEntry> tableIter,
-			Submode_t targetSubmode = SUBMODE_NONE);
-
-	ReturnValue_t updateChildMode(MessageQueueId_t queue, Mode_t mode,
-			Submode_t submode);
-
-	ReturnValue_t updateChildChangedHealth(MessageQueueId_t queue,
-			bool changedHealth = true);
-
-	virtual ReturnValue_t handleModeReply(CommandMessage *message);
-
-	void commandAllChildren(CommandMessage *message);
-
-	ReturnValue_t checkTable(HybridIterator<ModeListEntry> tableIter);
-
-	void replyToCommand(CommandMessage *message);
-
-	void setMode(Mode_t newMode, Submode_t newSubmode);
-
-	void setMode(Mode_t newMode);
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
-
-	virtual void performChildOperation() = 0;
-
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode) = 0;
-
-	virtual void startTransition(Mode_t mode, Submode_t submode) = 0;
-
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-
-	virtual void setToExternalControl();
-
-	virtual void announceMode(bool recursive);
-
-	virtual void modeChanged();
-};
-
-#endif /* SUBSYSTEMBASE_H_ */
+#ifndef SUBSYSTEMBASE_H_
+#define SUBSYSTEMBASE_H_
+
+#include "../container/HybridIterator.h"
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../modes/HasModesIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../subsystem/modes/HasModeSequenceIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include <map>
+
+/**
+ * @defgroup subsystems Subsystem Objects
+ * Contains all Subsystem and Assemblies
+ */
+class SubsystemBase: public SystemObject,
+		public HasModesIF,
+		public HasHealthIF,
+		public HasReturnvaluesIF,
+		public ExecutableObjectIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM_BASE;
+	static const ReturnValue_t CHILD_NOT_FOUND = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t CHILD_INFO_UPDATED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t CHILD_DOESNT_HAVE_MODES = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t COULD_NOT_INSERT_CHILD = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
+			MAKE_RETURN_CODE(0x05);
+
+	SubsystemBase(object_id_t setObjectId, object_id_t parent,
+			Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
+	virtual ~SubsystemBase();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t registerChild(object_id_t objectId);
+
+	virtual ReturnValue_t initialize();
+
+	virtual ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual ReturnValue_t setHealth(HealthState health);
+
+	virtual HasHealthIF::HealthState getHealth();
+
+protected:
+	struct ChildInfo {
+		MessageQueueId_t commandQueue;
+		Mode_t mode;
+		Submode_t submode;bool healthChanged;
+	};
+
+	Mode_t mode;
+
+	Submode_t submode;
+
+	bool childrenChangedMode;
+
+	/**
+	 * Always check this against <=0, so you are robust against too many replies
+	 */
+	int32_t commandsOutstanding;
+
+	MessageQueueIF* commandQueue;
+
+	HealthHelper healthHelper;
+
+	ModeHelper modeHelper;
+
+	const object_id_t parentId;
+
+	typedef std::map<object_id_t, ChildInfo> ChildrenMap;
+	ChildrenMap childrenMap;
+
+	void checkCommandQueue();
+
+	/**
+	 * We need to know the target Submode, as children are able to inherit the submode
+	 */
+	ReturnValue_t checkStateAgainstTable(
+			HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode);
+
+	/**
+	 * We need to know the target Submode, as children are able to inherit the submode
+	 * Still, we have a default for all child implementations which do not use submode inheritance
+	 */
+	void executeTable(HybridIterator<ModeListEntry> tableIter,
+			Submode_t targetSubmode = SUBMODE_NONE);
+
+	ReturnValue_t updateChildMode(MessageQueueId_t queue, Mode_t mode,
+			Submode_t submode);
+
+	ReturnValue_t updateChildChangedHealth(MessageQueueId_t queue,
+			bool changedHealth = true);
+
+	virtual ReturnValue_t handleModeReply(CommandMessage *message);
+
+	void commandAllChildren(CommandMessage *message);
+
+	ReturnValue_t checkTable(HybridIterator<ModeListEntry> tableIter);
+
+	void replyToCommand(CommandMessage *message);
+
+	void setMode(Mode_t newMode, Submode_t newSubmode);
+
+	void setMode(Mode_t newMode);
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+	virtual void performChildOperation() = 0;
+
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode) = 0;
+
+	virtual void startTransition(Mode_t mode, Submode_t submode) = 0;
+
+	virtual void getMode(Mode_t *mode, Submode_t *submode);
+
+	virtual void setToExternalControl();
+
+	virtual void announceMode(bool recursive);
+
+	virtual void modeChanged();
+};
+
+#endif /* SUBSYSTEMBASE_H_ */
diff --git a/subsystem/modes/HasModeSequenceIF.h b/subsystem/modes/HasModeSequenceIF.h
index 90007d800..06bde2aae 100644
--- a/subsystem/modes/HasModeSequenceIF.h
+++ b/subsystem/modes/HasModeSequenceIF.h
@@ -1,20 +1,20 @@
-#ifndef HASMODESEQUENCEIF_H_
-#define HASMODESEQUENCEIF_H_
-
-#include "../../subsystem/modes/ModeDefinitions.h"
-#include "../../subsystem/modes/ModeSequenceMessage.h"
-#include "../../subsystem/modes/ModeStoreIF.h"
-
-
-class HasModeSequenceIF {
-public:
-	virtual ~HasModeSequenceIF() {
-
-	}
-
-	virtual MessageQueueId_t getSequenceCommandQueue() const = 0;
-
-};
-
-
-#endif /* HASMODESEQUENCEIF_H_ */
+#ifndef HASMODESEQUENCEIF_H_
+#define HASMODESEQUENCEIF_H_
+
+#include "../../subsystem/modes/ModeDefinitions.h"
+#include "../../subsystem/modes/ModeSequenceMessage.h"
+#include "../../subsystem/modes/ModeStoreIF.h"
+
+
+class HasModeSequenceIF {
+public:
+	virtual ~HasModeSequenceIF() {
+
+	}
+
+	virtual MessageQueueId_t getSequenceCommandQueue() const = 0;
+
+};
+
+
+#endif /* HASMODESEQUENCEIF_H_ */
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 0514b3571..a865ab0cf 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -1,152 +1,152 @@
-#ifndef MODEDEFINITIONS_H_
-#define MODEDEFINITIONS_H_
-
-#include "../../modes/HasModesIF.h"
-#include "../../objectmanager/SystemObjectIF.h"
-#include "../../serialize/SerializeIF.h"
-#include "../../serialize/SerialLinkedListAdapter.h"
-class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
-public:
-	ModeListEntry() :
-			LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0), value4(
-					0) {
-
-	}
-
-	uint32_t value1;
-	uint32_t value2;
-	uint8_t value3;
-	uint8_t value4;
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-
-		ReturnValue_t result;
-
-		result = SerializeAdapter::serialize(&value1, buffer, size,
-				maxSize, streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&value2, buffer, size,
-				maxSize, streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&value3, buffer, size,
-				maxSize, streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		result = SerializeAdapter::serialize(&value4, buffer, size,
-				maxSize, streamEndianness);
-
-		return result;
-
-	}
-
-	virtual size_t getSerializedSize() const {
-		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	Endianness streamEndianness) {
-		ReturnValue_t result;
-
-		result = SerializeAdapter::deSerialize(&value1, buffer, size,
-				streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&value2, buffer, size,
-				streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&value3, buffer, size,
-				streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&value4, buffer, size,
-				streamEndianness);
-
-		return result;
-	}
-
-	//for Sequences
-	Mode_t getTableId() const {
-		return value1;
-	}
-
-	void setTableId(Mode_t tableId) {
-		this->value1 = tableId;
-	}
-
-	uint8_t getWaitSeconds() const {
-		return value2;
-	}
-
-	void setWaitSeconds(uint8_t waitSeconds) {
-		this->value2 = waitSeconds;
-	}
-
-	bool checkSuccess() const {
-		return value3 == 1;
-	}
-
-	void setCheckSuccess(bool checkSuccess) {
-		this->value3 = checkSuccess;
-	}
-
-	//for Tables
-	object_id_t getObject() const {
-		return value1;
-	}
-
-	void setObject(object_id_t object) {
-		this->value1 = object;
-	}
-
-	Mode_t getMode() const {
-		return value2;
-	}
-
-	void setMode(Mode_t mode) {
-		this->value2 = mode;
-	}
-
-	Submode_t getSubmode() const {
-		return value3;
-	}
-
-	void setSubmode(Submode_t submode) {
-		this->value3 = submode;
-	}
-
-	bool inheritSubmode() const {
-		return value4 == 1;
-	}
-
-	void setInheritSubmode(bool inherit){
-		if (inherit){
-			value4 = 1;
-		} else {
-			value4 = 0;
-		}
-	}
-
-	bool operator==(ModeListEntry other) {
-		return ((value1 == other.value1) && (value2 == other.value2)
-				&& (value3 == other.value3));
-	}
-};
-
-#endif //MODEDEFINITIONS_H_
+#ifndef MODEDEFINITIONS_H_
+#define MODEDEFINITIONS_H_
+
+#include "../../modes/HasModesIF.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../serialize/SerializeIF.h"
+#include "../../serialize/SerialLinkedListAdapter.h"
+class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
+public:
+	ModeListEntry() :
+			LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0), value4(
+					0) {
+
+	}
+
+	uint32_t value1;
+	uint32_t value2;
+	uint8_t value3;
+	uint8_t value4;
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+
+		ReturnValue_t result;
+
+		result = SerializeAdapter::serialize(&value1, buffer, size,
+				maxSize, streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&value2, buffer, size,
+				maxSize, streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&value3, buffer, size,
+				maxSize, streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		result = SerializeAdapter::serialize(&value4, buffer, size,
+				maxSize, streamEndianness);
+
+		return result;
+
+	}
+
+	virtual size_t getSerializedSize() const {
+		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	Endianness streamEndianness) {
+		ReturnValue_t result;
+
+		result = SerializeAdapter::deSerialize(&value1, buffer, size,
+				streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&value2, buffer, size,
+				streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&value3, buffer, size,
+				streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&value4, buffer, size,
+				streamEndianness);
+
+		return result;
+	}
+
+	//for Sequences
+	Mode_t getTableId() const {
+		return value1;
+	}
+
+	void setTableId(Mode_t tableId) {
+		this->value1 = tableId;
+	}
+
+	uint8_t getWaitSeconds() const {
+		return value2;
+	}
+
+	void setWaitSeconds(uint8_t waitSeconds) {
+		this->value2 = waitSeconds;
+	}
+
+	bool checkSuccess() const {
+		return value3 == 1;
+	}
+
+	void setCheckSuccess(bool checkSuccess) {
+		this->value3 = checkSuccess;
+	}
+
+	//for Tables
+	object_id_t getObject() const {
+		return value1;
+	}
+
+	void setObject(object_id_t object) {
+		this->value1 = object;
+	}
+
+	Mode_t getMode() const {
+		return value2;
+	}
+
+	void setMode(Mode_t mode) {
+		this->value2 = mode;
+	}
+
+	Submode_t getSubmode() const {
+		return value3;
+	}
+
+	void setSubmode(Submode_t submode) {
+		this->value3 = submode;
+	}
+
+	bool inheritSubmode() const {
+		return value4 == 1;
+	}
+
+	void setInheritSubmode(bool inherit){
+		if (inherit){
+			value4 = 1;
+		} else {
+			value4 = 0;
+		}
+	}
+
+	bool operator==(ModeListEntry other) {
+		return ((value1 == other.value1) && (value2 == other.value2)
+				&& (value3 == other.value3));
+	}
+};
+
+#endif //MODEDEFINITIONS_H_
diff --git a/subsystem/modes/ModeSequenceMessage.cpp b/subsystem/modes/ModeSequenceMessage.cpp
index 3eb4ebe83..e092380ef 100644
--- a/subsystem/modes/ModeSequenceMessage.cpp
+++ b/subsystem/modes/ModeSequenceMessage.cpp
@@ -1,89 +1,89 @@
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../storagemanager/StorageManagerIF.h"
-#include "../../subsystem/modes/ModeSequenceMessage.h"
-
-void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-		Command_t command, Mode_t sequence, store_address_t storeAddress) {
-	message->setCommand(command);
-	message->setParameter(storeAddress.raw);
-	message->setParameter2(sequence);
-}
-
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table, store_address_t storeAddress) {
-//	message->setCommand(command);
-//	message->setParameter(storeAddress.raw);
-//	message->setParameter2(table);
-//}
-
-void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-		Command_t command, Mode_t sequence) {
-	message->setCommand(command);
-	message->setParameter2(sequence);
-}
-
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table) {
-//	message->setCommand(command);
-//	message->setParameter2(table);
-//}
-
-void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-		Command_t command, store_address_t storeAddress) {
-	message->setCommand(command);
-	message->setParameter(storeAddress.raw);
-}
-
-store_address_t ModeSequenceMessage::getStoreAddress(
-		const CommandMessage* message) {
-	store_address_t address;
-	address.raw = message->getParameter();
-	return address;
-}
-
-Mode_t ModeSequenceMessage::getSequenceId(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-Mode_t ModeSequenceMessage::getTableId(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-
-uint32_t ModeSequenceMessage::getNumber(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-void ModeSequenceMessage::clear(CommandMessage *message) {
-	switch (message->getCommand()) {
-	case ADD_SEQUENCE:
-	case ADD_TABLE:
-	case SEQUENCE_LIST:
-	case TABLE_LIST:
-	case TABLE:
-	case SEQUENCE:{
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore != NULL){
-			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
-		}
-	}
-	/* NO BREAK falls through*/
-	case DELETE_SEQUENCE:
-	case DELETE_TABLE:
-	case READ_SEQUENCE:
-	case READ_TABLE:
-	case LIST_SEQUENCES:
-	case LIST_TABLES:
-	case READ_FREE_SEQUENCE_SLOTS:
-	case FREE_SEQUENCE_SLOTS:
-	case READ_FREE_TABLE_SLOTS:
-	case FREE_TABLE_SLOTS:
-	default:
-		message->setCommand(CommandMessage::CMD_NONE);
-		message->setParameter(0);
-		message->setParameter2(0);
-		break;
-	}
-}
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../subsystem/modes/ModeSequenceMessage.h"
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, Mode_t sequence, store_address_t storeAddress) {
+	message->setCommand(command);
+	message->setParameter(storeAddress.raw);
+	message->setParameter2(sequence);
+}
+
+//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+//		Command_t command, ModeTableId_t table, store_address_t storeAddress) {
+//	message->setCommand(command);
+//	message->setParameter(storeAddress.raw);
+//	message->setParameter2(table);
+//}
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, Mode_t sequence) {
+	message->setCommand(command);
+	message->setParameter2(sequence);
+}
+
+//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+//		Command_t command, ModeTableId_t table) {
+//	message->setCommand(command);
+//	message->setParameter2(table);
+//}
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, store_address_t storeAddress) {
+	message->setCommand(command);
+	message->setParameter(storeAddress.raw);
+}
+
+store_address_t ModeSequenceMessage::getStoreAddress(
+		const CommandMessage* message) {
+	store_address_t address;
+	address.raw = message->getParameter();
+	return address;
+}
+
+Mode_t ModeSequenceMessage::getSequenceId(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+Mode_t ModeSequenceMessage::getTableId(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+
+uint32_t ModeSequenceMessage::getNumber(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+void ModeSequenceMessage::clear(CommandMessage *message) {
+	switch (message->getCommand()) {
+	case ADD_SEQUENCE:
+	case ADD_TABLE:
+	case SEQUENCE_LIST:
+	case TABLE_LIST:
+	case TABLE:
+	case SEQUENCE:{
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore != NULL){
+			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+	}
+	/* NO BREAK falls through*/
+	case DELETE_SEQUENCE:
+	case DELETE_TABLE:
+	case READ_SEQUENCE:
+	case READ_TABLE:
+	case LIST_SEQUENCES:
+	case LIST_TABLES:
+	case READ_FREE_SEQUENCE_SLOTS:
+	case FREE_SEQUENCE_SLOTS:
+	case READ_FREE_TABLE_SLOTS:
+	case FREE_TABLE_SLOTS:
+	default:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+	}
+}
diff --git a/subsystem/modes/ModeSequenceMessage.h b/subsystem/modes/ModeSequenceMessage.h
index fcb5b2e7f..61ba30f31 100644
--- a/subsystem/modes/ModeSequenceMessage.h
+++ b/subsystem/modes/ModeSequenceMessage.h
@@ -1,48 +1,48 @@
-#ifndef MODESEQUENCEMESSAGE_H_
-#define MODESEQUENCEMESSAGE_H_
-
-#include "../../ipc/CommandMessage.h"
-#include "../../storagemanager/StorageManagerIF.h"
-#include "../../subsystem/modes/ModeDefinitions.h"
-
-class ModeSequenceMessage {
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::MODE_SEQUENCE;
-
-	static const Command_t ADD_SEQUENCE = MAKE_COMMAND_ID(0x01);
-	static const Command_t ADD_TABLE = MAKE_COMMAND_ID(0x02);
-	static const Command_t DELETE_SEQUENCE = MAKE_COMMAND_ID(0x03);
-	static const Command_t DELETE_TABLE = MAKE_COMMAND_ID(0x04);
-	static const Command_t READ_SEQUENCE = MAKE_COMMAND_ID(0x05);
-	static const Command_t READ_TABLE = MAKE_COMMAND_ID(0x06);
-	static const Command_t LIST_SEQUENCES = MAKE_COMMAND_ID(0x07);
-	static const Command_t LIST_TABLES = MAKE_COMMAND_ID(0x08);
-	static const Command_t SEQUENCE_LIST = MAKE_COMMAND_ID(0x09);
-	static const Command_t TABLE_LIST = MAKE_COMMAND_ID(0x0A);
-	static const Command_t TABLE = MAKE_COMMAND_ID(0x0B);
-	static const Command_t SEQUENCE = MAKE_COMMAND_ID(0x0C);
-	static const Command_t READ_FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0D);
-	static const Command_t FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0E);
-	static const Command_t READ_FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x0F);
-	static const Command_t FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x10);
-
-	static void setModeSequenceMessage(CommandMessage *message,
-			Command_t command, Mode_t sequenceOrTable,
-			store_address_t storeAddress);
-	static void setModeSequenceMessage(CommandMessage *message,
-			Command_t command, Mode_t sequenceOrTable);
-	static void setModeSequenceMessage(CommandMessage *message,
-			Command_t command, store_address_t storeAddress);
-
-	static store_address_t getStoreAddress(const CommandMessage *message);
-	static Mode_t getSequenceId(const CommandMessage *message);
-	static Mode_t getTableId(const CommandMessage *message);
-	static uint32_t getNumber(const CommandMessage *message);
-
-	static void clear(CommandMessage *message);
-
-private:
-	ModeSequenceMessage();
-};
-
-#endif /* MODESEQUENCEMESSAGE_H_ */
+#ifndef MODESEQUENCEMESSAGE_H_
+#define MODESEQUENCEMESSAGE_H_
+
+#include "../../ipc/CommandMessage.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../subsystem/modes/ModeDefinitions.h"
+
+class ModeSequenceMessage {
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::MODE_SEQUENCE;
+
+	static const Command_t ADD_SEQUENCE = MAKE_COMMAND_ID(0x01);
+	static const Command_t ADD_TABLE = MAKE_COMMAND_ID(0x02);
+	static const Command_t DELETE_SEQUENCE = MAKE_COMMAND_ID(0x03);
+	static const Command_t DELETE_TABLE = MAKE_COMMAND_ID(0x04);
+	static const Command_t READ_SEQUENCE = MAKE_COMMAND_ID(0x05);
+	static const Command_t READ_TABLE = MAKE_COMMAND_ID(0x06);
+	static const Command_t LIST_SEQUENCES = MAKE_COMMAND_ID(0x07);
+	static const Command_t LIST_TABLES = MAKE_COMMAND_ID(0x08);
+	static const Command_t SEQUENCE_LIST = MAKE_COMMAND_ID(0x09);
+	static const Command_t TABLE_LIST = MAKE_COMMAND_ID(0x0A);
+	static const Command_t TABLE = MAKE_COMMAND_ID(0x0B);
+	static const Command_t SEQUENCE = MAKE_COMMAND_ID(0x0C);
+	static const Command_t READ_FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0D);
+	static const Command_t FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0E);
+	static const Command_t READ_FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x0F);
+	static const Command_t FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x10);
+
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, Mode_t sequenceOrTable,
+			store_address_t storeAddress);
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, Mode_t sequenceOrTable);
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, store_address_t storeAddress);
+
+	static store_address_t getStoreAddress(const CommandMessage *message);
+	static Mode_t getSequenceId(const CommandMessage *message);
+	static Mode_t getTableId(const CommandMessage *message);
+	static uint32_t getNumber(const CommandMessage *message);
+
+	static void clear(CommandMessage *message);
+
+private:
+	ModeSequenceMessage();
+};
+
+#endif /* MODESEQUENCEMESSAGE_H_ */
diff --git a/subsystem/modes/ModeStore.cpp b/subsystem/modes/ModeStore.cpp
index 409a5f0fd..dce2931c1 100644
--- a/subsystem/modes/ModeStore.cpp
+++ b/subsystem/modes/ModeStore.cpp
@@ -1,126 +1,126 @@
-#include "../../subsystem/modes/ModeStore.h"
-
-#ifdef USE_MODESTORE
-
-ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
-		SystemObject(objectId), store(slots), emptySlot(store.front()) {
-	mutex = MutexFactory::instance()->createMutex();;
-	OSAL::createMutex(objectId + 1, mutex);
-	clear();
-}
-
-ModeStore::~ModeStore() {
-	delete mutex;
-}
-
-uint32_t ModeStore::getFreeSlots() {
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	uint32_t count = 0;
-	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
-	for (iter = store.begin(); iter != store.end(); ++iter) {
-		if (iter->getNext() == emptySlot) {
-			++count;
-		}
-	}
-	OSAL::unlockMutex(mutex);
-	return count;
-}
-
-ReturnValue_t ModeStore::storeArray(ArrayList<ModeListEntry>* sequence,
-		ModeListEntry** storedFirstEntry) {
-	if (sequence->size == 0) {
-		return CANT_STORE_EMPTY;
-	}
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	*storedFirstEntry = findEmptySlotNoLock(store.front());
-
-	ModeListEntry* pointer =
-			*storedFirstEntry;
-	pointer->setNext(pointer);
-
-	ArrayList<ModeListEntry>::Iterator iter;
-	for (iter = sequence->begin(); iter != sequence->end(); ++iter) {
-		//SHOULDDO: I need to check this in detail. What is the idea? Why does it not work?
-		pointer = pointer->getNext()->value;
-		if (pointer == NULL) {
-			deleteListNoLock(*storedFirstEntry);
-			OSAL::unlockMutex(mutex);
-			return TOO_MANY_ELEMENTS;
-		}
-		pointer->value->value1 = iter->value1;
-		pointer->value->value2 = iter->value2;
-		pointer->value->value3 = iter->value3;
-		pointer->setNext(findEmptySlotNoLock(pointer + 1));
-	}
-	pointer->setNext(NULL);
-	OSAL::unlockMutex(mutex);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeStore::deleteList(ModeListEntry* sequence) {
-	ReturnValue_t result = isValidEntry(sequence);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-		deleteListNoLock(sequence);
-		OSAL::unlockMutex(mutex);
-		return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeStore::readList(ModeListEntry* sequence,
-		ArrayList<ModeListEntry>* into) {
-	ReturnValue_t result = isValidEntry(sequence);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	result = into->insert(*sequence->value);
-	while ((result == HasReturnvaluesIF::RETURN_OK) && (sequence->getNext() != NULL)) {
-		result = into->insert(*sequence->value);
-		sequence = sequence->getNext()->value;
-	}
-	OSAL::unlockMutex(mutex);
-	return result;
-}
-
-void ModeStore::clear() {
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	store.size = store.maxSize();
-	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
-	for (iter = store.begin(); iter != store.end(); ++iter) {
-		iter->setNext(emptySlot);
-	}
-	OSAL::unlockMutex(mutex);
-}
-
-ModeListEntry* ModeStore::findEmptySlotNoLock(ModeListEntry* startFrom) {
-	ArrayList<ModeListEntry, uint32_t>::Iterator iter(
-			startFrom);
-	for (; iter != store.end(); ++iter) {
-		if (iter.value->getNext() == emptySlot) {
-			OSAL::unlockMutex(mutex);
-			return iter.value;
-		}
-	}
-	return NULL;
-}
-
-void ModeStore::deleteListNoLock(ModeListEntry* sequence) {
-	ModeListEntry* next = sequence;
-	while (next != NULL) {
-		next = sequence->getNext()->value;
-		sequence->setNext(emptySlot);
-		sequence = next;
-	}
-}
-
-ReturnValue_t ModeStore::isValidEntry(ModeListEntry* sequence) {
-	if ((sequence < store.front()) || (sequence > store.back())
-			|| sequence->getNext() == emptySlot) {
-		return INVALID_ENTRY;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-#endif
+#include "../../subsystem/modes/ModeStore.h"
+
+#ifdef USE_MODESTORE
+
+ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
+		SystemObject(objectId), store(slots), emptySlot(store.front()) {
+	mutex = MutexFactory::instance()->createMutex();;
+	OSAL::createMutex(objectId + 1, mutex);
+	clear();
+}
+
+ModeStore::~ModeStore() {
+	delete mutex;
+}
+
+uint32_t ModeStore::getFreeSlots() {
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	uint32_t count = 0;
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
+	for (iter = store.begin(); iter != store.end(); ++iter) {
+		if (iter->getNext() == emptySlot) {
+			++count;
+		}
+	}
+	OSAL::unlockMutex(mutex);
+	return count;
+}
+
+ReturnValue_t ModeStore::storeArray(ArrayList<ModeListEntry>* sequence,
+		ModeListEntry** storedFirstEntry) {
+	if (sequence->size == 0) {
+		return CANT_STORE_EMPTY;
+	}
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	*storedFirstEntry = findEmptySlotNoLock(store.front());
+
+	ModeListEntry* pointer =
+			*storedFirstEntry;
+	pointer->setNext(pointer);
+
+	ArrayList<ModeListEntry>::Iterator iter;
+	for (iter = sequence->begin(); iter != sequence->end(); ++iter) {
+		//SHOULDDO: I need to check this in detail. What is the idea? Why does it not work?
+		pointer = pointer->getNext()->value;
+		if (pointer == NULL) {
+			deleteListNoLock(*storedFirstEntry);
+			OSAL::unlockMutex(mutex);
+			return TOO_MANY_ELEMENTS;
+		}
+		pointer->value->value1 = iter->value1;
+		pointer->value->value2 = iter->value2;
+		pointer->value->value3 = iter->value3;
+		pointer->setNext(findEmptySlotNoLock(pointer + 1));
+	}
+	pointer->setNext(NULL);
+	OSAL::unlockMutex(mutex);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeStore::deleteList(ModeListEntry* sequence) {
+	ReturnValue_t result = isValidEntry(sequence);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+		deleteListNoLock(sequence);
+		OSAL::unlockMutex(mutex);
+		return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeStore::readList(ModeListEntry* sequence,
+		ArrayList<ModeListEntry>* into) {
+	ReturnValue_t result = isValidEntry(sequence);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	result = into->insert(*sequence->value);
+	while ((result == HasReturnvaluesIF::RETURN_OK) && (sequence->getNext() != NULL)) {
+		result = into->insert(*sequence->value);
+		sequence = sequence->getNext()->value;
+	}
+	OSAL::unlockMutex(mutex);
+	return result;
+}
+
+void ModeStore::clear() {
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	store.size = store.maxSize();
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
+	for (iter = store.begin(); iter != store.end(); ++iter) {
+		iter->setNext(emptySlot);
+	}
+	OSAL::unlockMutex(mutex);
+}
+
+ModeListEntry* ModeStore::findEmptySlotNoLock(ModeListEntry* startFrom) {
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter(
+			startFrom);
+	for (; iter != store.end(); ++iter) {
+		if (iter.value->getNext() == emptySlot) {
+			OSAL::unlockMutex(mutex);
+			return iter.value;
+		}
+	}
+	return NULL;
+}
+
+void ModeStore::deleteListNoLock(ModeListEntry* sequence) {
+	ModeListEntry* next = sequence;
+	while (next != NULL) {
+		next = sequence->getNext()->value;
+		sequence->setNext(emptySlot);
+		sequence = next;
+	}
+}
+
+ReturnValue_t ModeStore::isValidEntry(ModeListEntry* sequence) {
+	if ((sequence < store.front()) || (sequence > store.back())
+			|| sequence->getNext() == emptySlot) {
+		return INVALID_ENTRY;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+#endif
diff --git a/subsystem/modes/ModeStore.h b/subsystem/modes/ModeStore.h
index cb3404430..3d031cc80 100644
--- a/subsystem/modes/ModeStore.h
+++ b/subsystem/modes/ModeStore.h
@@ -1,45 +1,45 @@
-#ifndef MODESTORE_H_
-#define MODESTORE_H_
-
-#ifdef USE_MODESTORE
-
-#include "../../container/ArrayList.h"
-#include "../../container/SinglyLinkedList.h"
-#include "../../objectmanager/SystemObject.h"
-#include "../../subsystem/modes/ModeStoreIF.h"
-
-class ModeStore: public ModeStoreIF, public SystemObject {
-public:
-	ModeStore(object_id_t objectId, uint32_t slots);
-	virtual ~ModeStore();
-
-	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
-			ModeListEntry **storedFirstEntry);
-
-	virtual ReturnValue_t deleteList(
-			ModeListEntry *sequence);
-
-	virtual ReturnValue_t readList(
-			ModeListEntry *sequence,
-			ArrayList<ModeListEntry> *into);
-
-	virtual uint32_t getFreeSlots();
-
-private:
-	MutexId_t* mutex;
-	ArrayList<ModeListEntry, uint32_t> store;
-	ModeListEntry *emptySlot;
-
-	void clear();
-	ModeListEntry* findEmptySlotNoLock(
-			ModeListEntry* startFrom);
-	void deleteListNoLock(
-			ModeListEntry *sequence);
-
-	ReturnValue_t isValidEntry(ModeListEntry *sequence);
-};
-
-#endif
-
-#endif /* MODESTORE_H_ */
-
+#ifndef MODESTORE_H_
+#define MODESTORE_H_
+
+#ifdef USE_MODESTORE
+
+#include "../../container/ArrayList.h"
+#include "../../container/SinglyLinkedList.h"
+#include "../../objectmanager/SystemObject.h"
+#include "../../subsystem/modes/ModeStoreIF.h"
+
+class ModeStore: public ModeStoreIF, public SystemObject {
+public:
+	ModeStore(object_id_t objectId, uint32_t slots);
+	virtual ~ModeStore();
+
+	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
+			ModeListEntry **storedFirstEntry);
+
+	virtual ReturnValue_t deleteList(
+			ModeListEntry *sequence);
+
+	virtual ReturnValue_t readList(
+			ModeListEntry *sequence,
+			ArrayList<ModeListEntry> *into);
+
+	virtual uint32_t getFreeSlots();
+
+private:
+	MutexId_t* mutex;
+	ArrayList<ModeListEntry, uint32_t> store;
+	ModeListEntry *emptySlot;
+
+	void clear();
+	ModeListEntry* findEmptySlotNoLock(
+			ModeListEntry* startFrom);
+	void deleteListNoLock(
+			ModeListEntry *sequence);
+
+	ReturnValue_t isValidEntry(ModeListEntry *sequence);
+};
+
+#endif
+
+#endif /* MODESTORE_H_ */
+
diff --git a/subsystem/modes/ModeStoreIF.h b/subsystem/modes/ModeStoreIF.h
index b9f2df70b..30cca1f7b 100644
--- a/subsystem/modes/ModeStoreIF.h
+++ b/subsystem/modes/ModeStoreIF.h
@@ -1,37 +1,37 @@
-#ifndef MODESTOREIF_H_
-#define MODESTOREIF_H_
-
-#ifdef USE_MODESTORE
-
-#include "../../container/ArrayList.h"
-#include "../../container/SinglyLinkedList.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../subsystem/modes/ModeDefinitions.h"
-
-class ModeStoreIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::MODE_STORE_IF;
-	static const ReturnValue_t INVALID_ENTRY = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t CANT_STORE_EMPTY = MAKE_RETURN_CODE(0x04);
-
-	virtual ~ModeStoreIF() {
-
-	}
-
-	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
-			ModeListEntry **storedFirstEntry) = 0;
-
-	virtual ReturnValue_t deleteList(
-			ModeListEntry *sequence) = 0;
-
-	virtual ReturnValue_t readList(
-			ModeListEntry *sequence,
-			ArrayList<ModeListEntry> *into) = 0;
-
-	virtual uint32_t getFreeSlots() = 0;
-};
-
-#endif
-
-#endif /* MODESTOREIF_H_ */
+#ifndef MODESTOREIF_H_
+#define MODESTOREIF_H_
+
+#ifdef USE_MODESTORE
+
+#include "../../container/ArrayList.h"
+#include "../../container/SinglyLinkedList.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../subsystem/modes/ModeDefinitions.h"
+
+class ModeStoreIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::MODE_STORE_IF;
+	static const ReturnValue_t INVALID_ENTRY = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t CANT_STORE_EMPTY = MAKE_RETURN_CODE(0x04);
+
+	virtual ~ModeStoreIF() {
+
+	}
+
+	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
+			ModeListEntry **storedFirstEntry) = 0;
+
+	virtual ReturnValue_t deleteList(
+			ModeListEntry *sequence) = 0;
+
+	virtual ReturnValue_t readList(
+			ModeListEntry *sequence,
+			ArrayList<ModeListEntry> *into) = 0;
+
+	virtual uint32_t getFreeSlots() = 0;
+};
+
+#endif
+
+#endif /* MODESTOREIF_H_ */
diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h
index 902b2e3c9..06b837db8 100644
--- a/tasks/ExecutableObjectIF.h
+++ b/tasks/ExecutableObjectIF.h
@@ -1,53 +1,53 @@
-#ifndef FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
-#define FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
-
-class PeriodicTaskIF;
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-#include <cstring>
-/**
- * @brief	The interface provides a method to execute objects within a task.
- * @details	The performOperation method, that is required by the interface is
- * 			executed cyclically within a task context.
- * @author  Bastian Baetz
- */
-class ExecutableObjectIF {
-public:
-	/**
-	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~ExecutableObjectIF() { }
-	/**
-	 * @brief	The performOperation method is executed in a task.
-	 * @details	There are no restrictions for calls within this method, so any
-	 * 			other member of the class can be used.
-	 * @return	Currently, the return value is ignored.
-	 */
-	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) = 0;
-
-	/**
-	 * @brief Function called during setup assignment of object to task
-	 * @details
-	 * Has to be called from the function that assigns the object to a task and
-	 * enables the object implementation to overwrite this function and get
-	 * a reference to the executing task
-	 * @param task_ Pointer to the taskIF of this task
-	 */
-	virtual void setTaskIF(PeriodicTaskIF* task_) {};
-
-	/**
-	 * This function should be called after the object was assigned to a
-	 * specific task.
-	 *
-	 * Example: Can be used to get task execution frequency.
-	 * The task is created after initialize() and the object ctors have been
-	 * called so the execution frequency can't be cached in initialize()
-	 * @return
-	 */
-	virtual ReturnValue_t initializeAfterTaskCreation() {
-	    return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-#endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */
+#ifndef FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
+#define FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
+
+class PeriodicTaskIF;
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+#include <cstring>
+/**
+ * @brief	The interface provides a method to execute objects within a task.
+ * @details	The performOperation method, that is required by the interface is
+ * 			executed cyclically within a task context.
+ * @author  Bastian Baetz
+ */
+class ExecutableObjectIF {
+public:
+	/**
+	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~ExecutableObjectIF() { }
+	/**
+	 * @brief	The performOperation method is executed in a task.
+	 * @details	There are no restrictions for calls within this method, so any
+	 * 			other member of the class can be used.
+	 * @return	Currently, the return value is ignored.
+	 */
+	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) = 0;
+
+	/**
+	 * @brief Function called during setup assignment of object to task
+	 * @details
+	 * Has to be called from the function that assigns the object to a task and
+	 * enables the object implementation to overwrite this function and get
+	 * a reference to the executing task
+	 * @param task_ Pointer to the taskIF of this task
+	 */
+	virtual void setTaskIF(PeriodicTaskIF* task_) {};
+
+	/**
+	 * This function should be called after the object was assigned to a
+	 * specific task.
+	 *
+	 * Example: Can be used to get task execution frequency.
+	 * The task is created after initialize() and the object ctors have been
+	 * called so the execution frequency can't be cached in initialize()
+	 * @return
+	 */
+	virtual ReturnValue_t initializeAfterTaskCreation() {
+	    return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+#endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index 9d290d19f..a38734a2c 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -1,17 +1,17 @@
-#include "../objectmanager/SystemObjectIF.h"
-#include "../tasks/FixedSequenceSlot.h"
-#include <cstddef>
-
-FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
-		int8_t setSequenceId, ExecutableObjectIF* executableObject,
-		PeriodicTaskIF* executingTask) :
-		pollingTimeMs(setTime), opcode(setSequenceId) {
-    if(executableObject == nullptr) {
-        return;
-    }
-    this->executableObject = executableObject;
-    this->executableObject->setTaskIF(executingTask);
-}
-
-FixedSequenceSlot::~FixedSequenceSlot() {}
-
+#include "../objectmanager/SystemObjectIF.h"
+#include "../tasks/FixedSequenceSlot.h"
+#include <cstddef>
+
+FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
+		int8_t setSequenceId, ExecutableObjectIF* executableObject,
+		PeriodicTaskIF* executingTask) :
+		pollingTimeMs(setTime), opcode(setSequenceId) {
+    if(executableObject == nullptr) {
+        return;
+    }
+    this->executableObject = executableObject;
+    this->executableObject->setTaskIF(executingTask);
+}
+
+FixedSequenceSlot::~FixedSequenceSlot() {}
+
diff --git a/tasks/FixedSequenceSlot.h b/tasks/FixedSequenceSlot.h
index 9cf5894c0..6ec9ae132 100644
--- a/tasks/FixedSequenceSlot.h
+++ b/tasks/FixedSequenceSlot.h
@@ -1,57 +1,57 @@
-#ifndef FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
-#define FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-class PeriodicTaskIF;
-
-/**
- * @brief	This class is the representation of a single polling sequence
- *          table entry.
- * @details
- * The PollingSlot class is the representation of a single polling
- * sequence table entry.
- * @author  baetz
- */
-class FixedSequenceSlot {
-public:
-	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
-			int8_t setSequenceId, ExecutableObjectIF* executableObject,
-			PeriodicTaskIF* executingTask);
-	virtual ~FixedSequenceSlot();
-
-	/**
-	 * @brief	Handler identifies which object is executed in this slot.
-	 */
-	ExecutableObjectIF*	executableObject = nullptr;
-
-	/**
-	 * @brief	This attribute defines when a device handler object is executed.
-	 * @details
-	 * The pollingTime attribute identifies the time the handler is
-	 * executed in ms. It must be smaller than the period length of the
-	 * polling sequence.
-	 */
-	uint32_t pollingTimeMs;
-
-	/**
-	 * @brief	This value defines the type of device communication.
-	 *
-	 * @details	The state of this value decides what communication routine is
-	 * 			called in the PST executable or the device handler object.
-	 */
-	uint8_t	opcode;
-
-	/**
-	 * @brief 	Operator overload for the comparison operator to
-	 * 			allow sorting by polling time.
-	 * @param fixedSequenceSlot
-	 * @return
-	 */
-	bool operator <(const FixedSequenceSlot & fixedSequenceSlot) const {
-		return pollingTimeMs < fixedSequenceSlot.pollingTimeMs;
-	}
-};
-
-
-#endif /* FIXEDSEQUENCESLOT_H_ */
+#ifndef FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
+#define FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+class PeriodicTaskIF;
+
+/**
+ * @brief	This class is the representation of a single polling sequence
+ *          table entry.
+ * @details
+ * The PollingSlot class is the representation of a single polling
+ * sequence table entry.
+ * @author  baetz
+ */
+class FixedSequenceSlot {
+public:
+	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
+			int8_t setSequenceId, ExecutableObjectIF* executableObject,
+			PeriodicTaskIF* executingTask);
+	virtual ~FixedSequenceSlot();
+
+	/**
+	 * @brief	Handler identifies which object is executed in this slot.
+	 */
+	ExecutableObjectIF*	executableObject = nullptr;
+
+	/**
+	 * @brief	This attribute defines when a device handler object is executed.
+	 * @details
+	 * The pollingTime attribute identifies the time the handler is
+	 * executed in ms. It must be smaller than the period length of the
+	 * polling sequence.
+	 */
+	uint32_t pollingTimeMs;
+
+	/**
+	 * @brief	This value defines the type of device communication.
+	 *
+	 * @details	The state of this value decides what communication routine is
+	 * 			called in the PST executable or the device handler object.
+	 */
+	uint8_t	opcode;
+
+	/**
+	 * @brief 	Operator overload for the comparison operator to
+	 * 			allow sorting by polling time.
+	 * @param fixedSequenceSlot
+	 * @return
+	 */
+	bool operator <(const FixedSequenceSlot & fixedSequenceSlot) const {
+		return pollingTimeMs < fixedSequenceSlot.pollingTimeMs;
+	}
+};
+
+
+#endif /* FIXEDSEQUENCESLOT_H_ */
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index d803a4199..59859ce51 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -1,147 +1,147 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tasks/FixedSlotSequence.h"
-#include <cstdlib>
-
-FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
-		lengthMs(setLengthMs) {
-	current = slotList.begin();
-}
-
-FixedSlotSequence::~FixedSlotSequence() {
-	// Call the destructor on each list entry.
-	slotList.clear();
-}
-
-void FixedSlotSequence::executeAndAdvance() {
-	current->executableObject->performOperation(current->opcode);
-//	if (returnValue != RETURN_OK) {
-//		this->sendErrorMessage( returnValue );
-//	}
-	//Increment the polling Sequence iterator
-	this->current++;
-	//Set it to the beginning, if the list's end is reached.
-	if (this->current == this->slotList.end()) {
-		this->current = this->slotList.begin();
-	}
-}
-
-uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
-	uint32_t oldTime;
-	SlotListIter slotListIter = current;
-	// Get the pollingTimeMs of the current slot object.
-	oldTime = slotListIter->pollingTimeMs;
-	// Advance to the next object.
-	slotListIter++;
-	// Find the next interval which is not 0.
-	while (slotListIter != slotList.end()) {
-		if (oldTime != slotListIter->pollingTimeMs) {
-			return slotListIter->pollingTimeMs - oldTime;
-		} else {
-			slotListIter++;
-		}
-	}
-	// If the list end is reached (this is definitely an interval != 0),
-	// the interval is calculated by subtracting the remaining time of the PST
-	// and adding the start time of the first handler in the list.
-	slotListIter = slotList.begin();
-	return lengthMs - oldTime + slotListIter->pollingTimeMs;
-}
-
-uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
-	uint32_t currentTime;
-	SlotListIter slotListIter = current;
-	// Get the pollingTimeMs of the current slot object.
-	currentTime = slotListIter->pollingTimeMs;
-
-	//if it is the first slot, calculate difference to last slot
-	if (slotListIter == slotList.begin()){
-		return lengthMs - (--slotList.end())->pollingTimeMs + currentTime;
-	}
-	// get previous slot
-	slotListIter--;
-
-	return currentTime - slotListIter->pollingTimeMs;
-}
-
-bool FixedSlotSequence::slotFollowsImmediately() {
-	uint32_t currentTime = current->pollingTimeMs;
-	SlotListIter fixedSequenceIter = this->current;
-	// Get the pollingTimeMs of the current slot object.
-	if (fixedSequenceIter == slotList.begin())
-		return false;
-	fixedSequenceIter--;
-	if (fixedSequenceIter->pollingTimeMs == currentTime) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-uint32_t FixedSlotSequence::getLengthMs() const {
-	return this->lengthMs;
-}
-
-void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
-        int8_t executionStep, ExecutableObjectIF* executableObject,
-        PeriodicTaskIF* executingTask) {
-    this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs,
-            executionStep, executableObject, executingTask));
-   this->current = slotList.begin();
-}
-
-ReturnValue_t FixedSlotSequence::checkSequence() const {
-	if(slotList.empty()) {
-		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint32_t count = 0;
-	uint32_t time = 0;
-	for(const auto& slot: slotList) {
-		if (slot.executableObject == nullptr) {
-			count++;
-		}
-		else if (slot.pollingTimeMs < time) {
-			sif::error << "FixedSlotSequence::initialize: Time: "
-					<< slot.pollingTimeMs << " is smaller than previous with "
-					<< time << std::endl;
-			count++;
-		}
-		else {
-			// All ok, print slot.
-			//sif::info << "Current slot polling time: " << std::endl;
-			//sif::info << std::dec << slotIt->pollingTimeMs << std::endl;
-		}
-		time = slot.pollingTimeMs;
-
-	}
-	//sif::info << "Number of elements in slot list: "
-	//	   << slotList.size() << std::endl;
-	if (count > 0) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
-    std::set<ExecutableObjectIF*> uniqueObjects;
-    uint32_t count = 0;
-    for(const auto& slot: slotList) {
-        // Ensure that each unique object is initialized once.
-        if(uniqueObjects.find(slot.executableObject) == uniqueObjects.end()) {
-            ReturnValue_t result =
-                    slot.executableObject->initializeAfterTaskCreation();
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                count++;
-            }
-            uniqueObjects.emplace(slot.executableObject);
-        }
-    }
-    if (count > 0) {
-        sif::error << "FixedSlotSequence::intializeSequenceAfterTaskCreation:"
-                "Counted " << count << " failed initializations!"  << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tasks/FixedSlotSequence.h"
+#include <cstdlib>
+
+FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
+		lengthMs(setLengthMs) {
+	current = slotList.begin();
+}
+
+FixedSlotSequence::~FixedSlotSequence() {
+	// Call the destructor on each list entry.
+	slotList.clear();
+}
+
+void FixedSlotSequence::executeAndAdvance() {
+	current->executableObject->performOperation(current->opcode);
+//	if (returnValue != RETURN_OK) {
+//		this->sendErrorMessage( returnValue );
+//	}
+	//Increment the polling Sequence iterator
+	this->current++;
+	//Set it to the beginning, if the list's end is reached.
+	if (this->current == this->slotList.end()) {
+		this->current = this->slotList.begin();
+	}
+}
+
+uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
+	uint32_t oldTime;
+	SlotListIter slotListIter = current;
+	// Get the pollingTimeMs of the current slot object.
+	oldTime = slotListIter->pollingTimeMs;
+	// Advance to the next object.
+	slotListIter++;
+	// Find the next interval which is not 0.
+	while (slotListIter != slotList.end()) {
+		if (oldTime != slotListIter->pollingTimeMs) {
+			return slotListIter->pollingTimeMs - oldTime;
+		} else {
+			slotListIter++;
+		}
+	}
+	// If the list end is reached (this is definitely an interval != 0),
+	// the interval is calculated by subtracting the remaining time of the PST
+	// and adding the start time of the first handler in the list.
+	slotListIter = slotList.begin();
+	return lengthMs - oldTime + slotListIter->pollingTimeMs;
+}
+
+uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
+	uint32_t currentTime;
+	SlotListIter slotListIter = current;
+	// Get the pollingTimeMs of the current slot object.
+	currentTime = slotListIter->pollingTimeMs;
+
+	//if it is the first slot, calculate difference to last slot
+	if (slotListIter == slotList.begin()){
+		return lengthMs - (--slotList.end())->pollingTimeMs + currentTime;
+	}
+	// get previous slot
+	slotListIter--;
+
+	return currentTime - slotListIter->pollingTimeMs;
+}
+
+bool FixedSlotSequence::slotFollowsImmediately() {
+	uint32_t currentTime = current->pollingTimeMs;
+	SlotListIter fixedSequenceIter = this->current;
+	// Get the pollingTimeMs of the current slot object.
+	if (fixedSequenceIter == slotList.begin())
+		return false;
+	fixedSequenceIter--;
+	if (fixedSequenceIter->pollingTimeMs == currentTime) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+uint32_t FixedSlotSequence::getLengthMs() const {
+	return this->lengthMs;
+}
+
+void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
+        int8_t executionStep, ExecutableObjectIF* executableObject,
+        PeriodicTaskIF* executingTask) {
+    this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs,
+            executionStep, executableObject, executingTask));
+   this->current = slotList.begin();
+}
+
+ReturnValue_t FixedSlotSequence::checkSequence() const {
+	if(slotList.empty()) {
+		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint32_t count = 0;
+	uint32_t time = 0;
+	for(const auto& slot: slotList) {
+		if (slot.executableObject == nullptr) {
+			count++;
+		}
+		else if (slot.pollingTimeMs < time) {
+			sif::error << "FixedSlotSequence::initialize: Time: "
+					<< slot.pollingTimeMs << " is smaller than previous with "
+					<< time << std::endl;
+			count++;
+		}
+		else {
+			// All ok, print slot.
+			//sif::info << "Current slot polling time: " << std::endl;
+			//sif::info << std::dec << slotIt->pollingTimeMs << std::endl;
+		}
+		time = slot.pollingTimeMs;
+
+	}
+	//sif::info << "Number of elements in slot list: "
+	//	   << slotList.size() << std::endl;
+	if (count > 0) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
+    std::set<ExecutableObjectIF*> uniqueObjects;
+    uint32_t count = 0;
+    for(const auto& slot: slotList) {
+        // Ensure that each unique object is initialized once.
+        if(uniqueObjects.find(slot.executableObject) == uniqueObjects.end()) {
+            ReturnValue_t result =
+                    slot.executableObject->initializeAfterTaskCreation();
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                count++;
+            }
+            uniqueObjects.emplace(slot.executableObject);
+        }
+    }
+    if (count > 0) {
+        sif::error << "FixedSlotSequence::intializeSequenceAfterTaskCreation:"
+                "Counted " << count << " failed initializations!"  << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 9ab845525..1140dd254 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -1,159 +1,159 @@
-#ifndef FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
-#define FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
-
-#include "../objectmanager/SystemObject.h"
-#include "../tasks/FixedSequenceSlot.h"
-
-#include <set>
-
-/**
- * @brief	This class is the representation of a Polling Sequence Table in software.
- * @details
- * The FixedSlotSequence object maintains the dynamic execution of
- * device handler objects.
- *
- * The main idea is to create a list of device handlers, to announce all
- * handlers to thepolling sequence and to maintain a list of
- * polling slot objects. This slot list represents the Polling Sequence Table
- * in software.
- *
- * Each polling slot contains information to indicate when and
- * which device handler shall be executed within a given polling period.
- * The sequence is then executed by iterating through this slot list.
- * Handlers are invoking by calling a certain function stored in the handler list.
- */
-class FixedSlotSequence {
-public:
-	using SlotList = std::multiset<FixedSequenceSlot>;
-	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
-
-	/**
-	 * @brief	The constructor of the FixedSlotSequence object.
-	 *
-	 * @details	The constructor takes two arguments, the period length and the init function.
-	 *
-	 * @param	setLength	The period length, expressed in ms.
-	 */
-	FixedSlotSequence(uint32_t setLengthMs);
-
-	/**
-	 * @brief	The destructor of the FixedSlotSequence object.
-	 *
-	 * @details	The destructor frees all allocated memory by iterating through the slotList
-	 *  		and deleting all allocated resources.
-	 */
-	virtual ~FixedSlotSequence();
-
-	/**
-	 * @brief	This is a method to add an PollingSlot object to slotList.
-	 *
-	 * @details	Here, a polling slot object is added to the slot list. It is appended
-	 * 			to the end of the list. The list is currently NOT reordered.
-	 * 			Afterwards, the iterator current is set to the beginning of the list.
-	 * 	@param Object ID of the object to add
-	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
-	 * 				   will be called inside the slot period.
-	 * 	@param setSequenceId ID which can be used to distinguish
-	 * 	                     different task operations
-	 * 	@param
-	 * 	@param
-	 */
-	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
-			ExecutableObjectIF* executableObject, PeriodicTaskIF* executingTask);
-
-	/**
-	 * Checks if the current slot shall be executed immediately after the one before.
-	 * This allows to distinguish between grouped and not grouped handlers.
-	 * @return 	- @c true if the slot has the same polling time as the previous
-	 * 			- @c false else
-	 */
-	bool slotFollowsImmediately();
-
-	/**
-	 * @brief	This method returns the time until the next software
-	 * 			component is invoked.
-	 *
-	 * @details
-	 * This method is vitally important for the operation of the PST.
-	 * By fetching the polling time of the current slot and that of the
-	 * next one (or the first one, if the list end is reached)
-	 * it calculates and returns the interval in milliseconds within
-	 * which the handler execution shall take place.
-	 * If the next slot has the same time as the current one, it is ignored
-	 * until a slot with different time or the end of the PST is found.
-	 */
-	uint32_t getIntervalToNextSlotMs();
-
-	/**
-	 * @brief	This method returns the time difference between the current
-	 * 			slot and the previous slot
-	 *
-	 * @details
-	 * This method is vitally important for the operation of the PST.
-	 * By fetching the polling time of the current slot and that of the previous
-	 * one (or the last one, if the slot is the first one) it calculates and
-	 * returns the interval in milliseconds that the handler execution shall
-	 * be delayed.
-	 */
-	uint32_t getIntervalToPreviousSlotMs();
-
-	/**
-	 * @brief	This method returns the length of this FixedSlotSequence instance.
-	 */
-	uint32_t getLengthMs() const;
-
-	/**
-	 * @brief	The method to execute the device handler entered in the current
-	 * 			PollingSlot object.
-	 *
-	 * @details
-	 * Within this method the device handler object to be executed is chosen by
-	 * looking up the handler address of the current slot in the handlerMap.
-	 * Either the device handler's talkToInterface or its listenToInterface
-	 * method is invoked, depending on the isTalking flag of the polling slot.
-	 * After execution the iterator current is increased or, by reaching the
-	 * end of slotList, reset to the beginning.
-	 */
-	void executeAndAdvance();
-
-	/**
-	 * @brief	An iterator that indicates the current polling slot to execute.
-	 *
-	 * @details	This is an iterator for slotList and always points to the
-	 * 			polling slot which is executed next.
-	 */
-	SlotListIter current;
-
-	/**
-	 * @brief   Check and initialize slot list.
-	 * @details
-	 * Checks if timing is ok (must be ascending) and if all handlers were found.
-	 * Also calls any initialization steps which are required after task
-	 * creation.
-	 * @return
-	 */
-	ReturnValue_t checkSequence() const;
-
-	ReturnValue_t intializeSequenceAfterTaskCreation() const;
-
-protected:
-
-	/**
-	 * @brief	This list contains all PollingSlot objects, defining order and
-	 * 			execution time of the device handler objects.
-	 *
-	 * @details
-	 * The slot list is a std:list object that contains all created
-	 * PollingSlot instances. They are NOT ordered automatically, so by
-	 * adding entries, the correct order needs to be ensured. By iterating
-	 * through this list the polling sequence is executed. Two entries with
-	 * identical polling times are executed immediately one after another.
-	 */
-	SlotList slotList;
-
-	uint32_t lengthMs;
-
-	bool isEmpty = false;
-};
-
-#endif /* FIXEDSLOTSEQUENCE_H_ */
+#ifndef FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
+#define FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/FixedSequenceSlot.h"
+
+#include <set>
+
+/**
+ * @brief	This class is the representation of a Polling Sequence Table in software.
+ * @details
+ * The FixedSlotSequence object maintains the dynamic execution of
+ * device handler objects.
+ *
+ * The main idea is to create a list of device handlers, to announce all
+ * handlers to thepolling sequence and to maintain a list of
+ * polling slot objects. This slot list represents the Polling Sequence Table
+ * in software.
+ *
+ * Each polling slot contains information to indicate when and
+ * which device handler shall be executed within a given polling period.
+ * The sequence is then executed by iterating through this slot list.
+ * Handlers are invoking by calling a certain function stored in the handler list.
+ */
+class FixedSlotSequence {
+public:
+	using SlotList = std::multiset<FixedSequenceSlot>;
+	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
+
+	/**
+	 * @brief	The constructor of the FixedSlotSequence object.
+	 *
+	 * @details	The constructor takes two arguments, the period length and the init function.
+	 *
+	 * @param	setLength	The period length, expressed in ms.
+	 */
+	FixedSlotSequence(uint32_t setLengthMs);
+
+	/**
+	 * @brief	The destructor of the FixedSlotSequence object.
+	 *
+	 * @details	The destructor frees all allocated memory by iterating through the slotList
+	 *  		and deleting all allocated resources.
+	 */
+	virtual ~FixedSlotSequence();
+
+	/**
+	 * @brief	This is a method to add an PollingSlot object to slotList.
+	 *
+	 * @details	Here, a polling slot object is added to the slot list. It is appended
+	 * 			to the end of the list. The list is currently NOT reordered.
+	 * 			Afterwards, the iterator current is set to the beginning of the list.
+	 * 	@param Object ID of the object to add
+	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
+	 * 				   will be called inside the slot period.
+	 * 	@param setSequenceId ID which can be used to distinguish
+	 * 	                     different task operations
+	 * 	@param
+	 * 	@param
+	 */
+	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
+			ExecutableObjectIF* executableObject, PeriodicTaskIF* executingTask);
+
+	/**
+	 * Checks if the current slot shall be executed immediately after the one before.
+	 * This allows to distinguish between grouped and not grouped handlers.
+	 * @return 	- @c true if the slot has the same polling time as the previous
+	 * 			- @c false else
+	 */
+	bool slotFollowsImmediately();
+
+	/**
+	 * @brief	This method returns the time until the next software
+	 * 			component is invoked.
+	 *
+	 * @details
+	 * This method is vitally important for the operation of the PST.
+	 * By fetching the polling time of the current slot and that of the
+	 * next one (or the first one, if the list end is reached)
+	 * it calculates and returns the interval in milliseconds within
+	 * which the handler execution shall take place.
+	 * If the next slot has the same time as the current one, it is ignored
+	 * until a slot with different time or the end of the PST is found.
+	 */
+	uint32_t getIntervalToNextSlotMs();
+
+	/**
+	 * @brief	This method returns the time difference between the current
+	 * 			slot and the previous slot
+	 *
+	 * @details
+	 * This method is vitally important for the operation of the PST.
+	 * By fetching the polling time of the current slot and that of the previous
+	 * one (or the last one, if the slot is the first one) it calculates and
+	 * returns the interval in milliseconds that the handler execution shall
+	 * be delayed.
+	 */
+	uint32_t getIntervalToPreviousSlotMs();
+
+	/**
+	 * @brief	This method returns the length of this FixedSlotSequence instance.
+	 */
+	uint32_t getLengthMs() const;
+
+	/**
+	 * @brief	The method to execute the device handler entered in the current
+	 * 			PollingSlot object.
+	 *
+	 * @details
+	 * Within this method the device handler object to be executed is chosen by
+	 * looking up the handler address of the current slot in the handlerMap.
+	 * Either the device handler's talkToInterface or its listenToInterface
+	 * method is invoked, depending on the isTalking flag of the polling slot.
+	 * After execution the iterator current is increased or, by reaching the
+	 * end of slotList, reset to the beginning.
+	 */
+	void executeAndAdvance();
+
+	/**
+	 * @brief	An iterator that indicates the current polling slot to execute.
+	 *
+	 * @details	This is an iterator for slotList and always points to the
+	 * 			polling slot which is executed next.
+	 */
+	SlotListIter current;
+
+	/**
+	 * @brief   Check and initialize slot list.
+	 * @details
+	 * Checks if timing is ok (must be ascending) and if all handlers were found.
+	 * Also calls any initialization steps which are required after task
+	 * creation.
+	 * @return
+	 */
+	ReturnValue_t checkSequence() const;
+
+	ReturnValue_t intializeSequenceAfterTaskCreation() const;
+
+protected:
+
+	/**
+	 * @brief	This list contains all PollingSlot objects, defining order and
+	 * 			execution time of the device handler objects.
+	 *
+	 * @details
+	 * The slot list is a std:list object that contains all created
+	 * PollingSlot instances. They are NOT ordered automatically, so by
+	 * adding entries, the correct order needs to be ensured. By iterating
+	 * through this list the polling sequence is executed. Two entries with
+	 * identical polling times are executed immediately one after another.
+	 */
+	SlotList slotList;
+
+	uint32_t lengthMs;
+
+	bool isEmpty = false;
+};
+
+#endif /* FIXEDSLOTSEQUENCE_H_ */
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index daced7854..6344efa52 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -1,33 +1,33 @@
-#ifndef FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
-#define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../tasks/PeriodicTaskIF.h"
-
-/**
- * @brief Following the same principle as the base class IF.
- *        This is the interface for a Fixed timeslot task
- */
-class FixedTimeslotTaskIF : public PeriodicTaskIF {
-public:
-	virtual ~FixedTimeslotTaskIF() {}
-
-	/**
-	 * Add an object with a slot time and the execution step to the task.
-	 * The execution step shall be passed to the object.
-	 * @param componentId
-	 * @param slotTimeMs
-	 * @param executionStep
-	 * @return
-	 */
-	virtual ReturnValue_t addSlot(object_id_t componentId,
-			uint32_t slotTimeMs, int8_t executionStep) = 0;
-
-	/**
-	 * Check whether the sequence is valid and perform all other required
-	 * initialization steps which are needed after task creation
-	 */
-	virtual ReturnValue_t checkSequence() const = 0;
-};
-
-#endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
+#ifndef FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
+#define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tasks/PeriodicTaskIF.h"
+
+/**
+ * @brief Following the same principle as the base class IF.
+ *        This is the interface for a Fixed timeslot task
+ */
+class FixedTimeslotTaskIF : public PeriodicTaskIF {
+public:
+	virtual ~FixedTimeslotTaskIF() {}
+
+	/**
+	 * Add an object with a slot time and the execution step to the task.
+	 * The execution step shall be passed to the object.
+	 * @param componentId
+	 * @param slotTimeMs
+	 * @param executionStep
+	 * @return
+	 */
+	virtual ReturnValue_t addSlot(object_id_t componentId,
+			uint32_t slotTimeMs, int8_t executionStep) = 0;
+
+	/**
+	 * Check whether the sequence is valid and perform all other required
+	 * initialization steps which are needed after task creation
+	 */
+	virtual ReturnValue_t checkSequence() const = 0;
+};
+
+#endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
diff --git a/tasks/PeriodicTaskIF.h b/tasks/PeriodicTaskIF.h
index 38cf201ba..4df376450 100644
--- a/tasks/PeriodicTaskIF.h
+++ b/tasks/PeriodicTaskIF.h
@@ -1,49 +1,49 @@
-#ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_
-#define FRAMEWORK_TASK_PERIODICTASKIF_H_
-
-#include "../objectmanager/SystemObjectIF.h"
-#include "../timemanager/Clock.h"
-#include <cstddef>
-class ExecutableObjectIF;
-
-/**
- * New version of TaskIF
- * Follows RAII principles, i.e. there's no create or delete method.
- * Minimalistic.
-*/
-class PeriodicTaskIF {
-public:
-	static const size_t MINIMUM_STACK_SIZE;
-	/**
-	 * @brief	A virtual destructor as it is mandatory for interfaces.
-	 */
-	virtual ~PeriodicTaskIF() { }
-	/**
-	 * @brief	With the startTask method, a created task can be started
-	 *          for the first time.
-	 */
-	virtual ReturnValue_t startTask() = 0;
-
-	/**
-	 * Add a component (object) to a periodic task. The pointer to the
-	 * task can be set optionally
-	 * @param object
-	 * Add an object to the task. The most important case is to add an
-	 * executable object with a function which will be called regularly
-	 * (see ExecutableObjectIF)
-	 * @param setTaskIF
-	 * Can be used to specify whether the task object pointer is passed
-	 * to the component.
-	 * @return
-	 */
-	virtual ReturnValue_t addComponent(object_id_t object) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-
-	virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
-
-	virtual uint32_t getPeriodMs() const = 0;
-};
-
-
-#endif /* PERIODICTASKIF_H_ */
+#ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_
+#define FRAMEWORK_TASK_PERIODICTASKIF_H_
+
+#include "../objectmanager/SystemObjectIF.h"
+#include "../timemanager/Clock.h"
+#include <cstddef>
+class ExecutableObjectIF;
+
+/**
+ * New version of TaskIF
+ * Follows RAII principles, i.e. there's no create or delete method.
+ * Minimalistic.
+*/
+class PeriodicTaskIF {
+public:
+	static const size_t MINIMUM_STACK_SIZE;
+	/**
+	 * @brief	A virtual destructor as it is mandatory for interfaces.
+	 */
+	virtual ~PeriodicTaskIF() { }
+	/**
+	 * @brief	With the startTask method, a created task can be started
+	 *          for the first time.
+	 */
+	virtual ReturnValue_t startTask() = 0;
+
+	/**
+	 * Add a component (object) to a periodic task. The pointer to the
+	 * task can be set optionally
+	 * @param object
+	 * Add an object to the task. The most important case is to add an
+	 * executable object with a function which will be called regularly
+	 * (see ExecutableObjectIF)
+	 * @param setTaskIF
+	 * Can be used to specify whether the task object pointer is passed
+	 * to the component.
+	 * @return
+	 */
+	virtual ReturnValue_t addComponent(object_id_t object) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+
+	virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
+
+	virtual uint32_t getPeriodMs() const = 0;
+};
+
+
+#endif /* PERIODICTASKIF_H_ */
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index 2c41a1353..01c09d1b5 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -1,50 +1,50 @@
-#ifndef FSFW_TASKS_SEMAPHOREFACTORY_H_
-#define FSFW_TASKS_SEMAPHOREFACTORY_H_
-
-#include "../tasks/SemaphoreIF.h"
-
-/**
- * Creates Semaphore.
- * This class is a "singleton" interface, i.e. it provides an
- * interface, but also is the base class for a singleton.
- */
-class SemaphoreFactory {
-public:
-	virtual ~SemaphoreFactory();
-	/**
-	 * Returns the single instance of SemaphoreFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static SemaphoreFactory* instance();
-
-	/**
-	 * Create a binary semaphore.
-	 * Creator function for a binary semaphore which may only be acquired once
-	 * @param argument Can be used to pass implementation specific information.
-	 * @return Pointer to newly created semaphore class instance.
-	 */
-	SemaphoreIF* createBinarySemaphore(uint32_t arguments = 0);
-	/**
-	 * Create a counting semaphore.
-	 * Creator functons for a counting semaphore which may be acquired multiple
-	 * times.
-	 * @param count Semaphore can be taken count times.
-	 * @param initCount Initial count value.
-	 * @param argument Can be used to pass implementation specific information.
-	 * @return
-	 */
-	SemaphoreIF* createCountingSemaphore(const uint8_t maxCount,
-			uint8_t initCount, uint32_t arguments = 0);
-
-	void deleteSemaphore(SemaphoreIF* semaphore);
-
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	SemaphoreFactory();
-	static SemaphoreFactory* factoryInstance;
-};
-
-#endif /* FSFW_TASKS_SEMAPHOREFACTORY_H_ */
+#ifndef FSFW_TASKS_SEMAPHOREFACTORY_H_
+#define FSFW_TASKS_SEMAPHOREFACTORY_H_
+
+#include "../tasks/SemaphoreIF.h"
+
+/**
+ * Creates Semaphore.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class SemaphoreFactory {
+public:
+	virtual ~SemaphoreFactory();
+	/**
+	 * Returns the single instance of SemaphoreFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static SemaphoreFactory* instance();
+
+	/**
+	 * Create a binary semaphore.
+	 * Creator function for a binary semaphore which may only be acquired once
+	 * @param argument Can be used to pass implementation specific information.
+	 * @return Pointer to newly created semaphore class instance.
+	 */
+	SemaphoreIF* createBinarySemaphore(uint32_t arguments = 0);
+	/**
+	 * Create a counting semaphore.
+	 * Creator functons for a counting semaphore which may be acquired multiple
+	 * times.
+	 * @param count Semaphore can be taken count times.
+	 * @param initCount Initial count value.
+	 * @param argument Can be used to pass implementation specific information.
+	 * @return
+	 */
+	SemaphoreIF* createCountingSemaphore(const uint8_t maxCount,
+			uint8_t initCount, uint32_t arguments = 0);
+
+	void deleteSemaphore(SemaphoreIF* semaphore);
+
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	SemaphoreFactory();
+	static SemaphoreFactory* factoryInstance;
+};
+
+#endif /* FSFW_TASKS_SEMAPHOREFACTORY_H_ */
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index 30d4ed881..dd327e230 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -1,68 +1,68 @@
-#ifndef FRAMEWORK_TASKS_SEMAPHOREIF_H_
-#define FRAMEWORK_TASKS_SEMAPHOREIF_H_
-#include "../returnvalues/FwClassIds.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstdint>
-
-/**
- * @brief 	Generic interface for semaphores, which can be used to achieve
- * 			task synchronization. This is a generic interface which can be
- * 			used for both binary semaphores and counting semaphores.
- * @details
- * A semaphore is a synchronization primitive.
- * See: https://en.wikipedia.org/wiki/Semaphore_(programming)
- * A semaphore can be used to achieve task synchonization and track the
- * availability of resources by using either the binary or the counting
- * semaphore types.
- *
- * If mutual exlcusion of a resource is desired, a mutex should be used,
- * which is a special form of a semaphore and has an own interface.
- */
-class SemaphoreIF {
-public:
-    /**
-     * Different types of timeout for the mutex lock.
-     */
-    enum TimeoutType {
-        POLLING, //!< If mutex is not available, return immediately
-        WAITING, //!< Wait a specified time for the mutex to become available
-        BLOCKING //!< Block indefinitely until the mutex becomes available.
-    };
-
-	virtual~ SemaphoreIF() {};
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-	//! Semaphore timeout
-	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
-	//! The current semaphore can not be given, because it is not owned
-	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
-	static constexpr ReturnValue_t SEMAPHORE_INVALID = MAKE_RETURN_CODE(3);
-
-	/**
-	 * Generic call to acquire a semaphore.
-	 * If there are no more semaphores to be taken (for a counting semaphore,
-	 * a semaphore may be taken more than once), the taks will block
-	 * for a maximum of timeoutMs while trying to acquire the semaphore.
-	 * This can be used to achieve task synchrnization.
-	 * @param timeoutMs
-	 * @return - c RETURN_OK for successfull acquisition
-	 */
-	virtual ReturnValue_t acquire(TimeoutType timeoutType =
-            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
-
-	/**
-	 * Corrensponding call to release a semaphore.
-	 * @return -@c RETURN_OK for successfull release
-	 */
-	virtual ReturnValue_t release() = 0;
-
-	/**
-	 * If the semaphore is a counting semaphore then the semaphores current
-	 * count value is returned. If the semaphore is a binary semaphore then 1
-	 * is returned if the semaphore is available, and 0 is returned if the
-	 * semaphore is not available.
-	 */
-	virtual uint8_t getSemaphoreCounter() const = 0;
-};
-
-#endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */
+#ifndef FRAMEWORK_TASKS_SEMAPHOREIF_H_
+#define FRAMEWORK_TASKS_SEMAPHOREIF_H_
+#include "../returnvalues/FwClassIds.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstdint>
+
+/**
+ * @brief 	Generic interface for semaphores, which can be used to achieve
+ * 			task synchronization. This is a generic interface which can be
+ * 			used for both binary semaphores and counting semaphores.
+ * @details
+ * A semaphore is a synchronization primitive.
+ * See: https://en.wikipedia.org/wiki/Semaphore_(programming)
+ * A semaphore can be used to achieve task synchonization and track the
+ * availability of resources by using either the binary or the counting
+ * semaphore types.
+ *
+ * If mutual exlcusion of a resource is desired, a mutex should be used,
+ * which is a special form of a semaphore and has an own interface.
+ */
+class SemaphoreIF {
+public:
+    /**
+     * Different types of timeout for the mutex lock.
+     */
+    enum TimeoutType {
+        POLLING, //!< If mutex is not available, return immediately
+        WAITING, //!< Wait a specified time for the mutex to become available
+        BLOCKING //!< Block indefinitely until the mutex becomes available.
+    };
+
+	virtual~ SemaphoreIF() {};
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+	//! Semaphore timeout
+	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
+	//! The current semaphore can not be given, because it is not owned
+	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t SEMAPHORE_INVALID = MAKE_RETURN_CODE(3);
+
+	/**
+	 * Generic call to acquire a semaphore.
+	 * If there are no more semaphores to be taken (for a counting semaphore,
+	 * a semaphore may be taken more than once), the taks will block
+	 * for a maximum of timeoutMs while trying to acquire the semaphore.
+	 * This can be used to achieve task synchrnization.
+	 * @param timeoutMs
+	 * @return - c RETURN_OK for successfull acquisition
+	 */
+	virtual ReturnValue_t acquire(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
+
+	/**
+	 * Corrensponding call to release a semaphore.
+	 * @return -@c RETURN_OK for successfull release
+	 */
+	virtual ReturnValue_t release() = 0;
+
+	/**
+	 * If the semaphore is a counting semaphore then the semaphores current
+	 * count value is returned. If the semaphore is a binary semaphore then 1
+	 * is returned if the semaphore is available, and 0 is returned if the
+	 * semaphore is not available.
+	 */
+	virtual uint8_t getSemaphoreCounter() const = 0;
+};
+
+#endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 56b3083e5..fd2f4460d 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -1,73 +1,73 @@
-#ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
-#define FRAMEWORK_TASKS_TASKFACTORY_H_
-
-#include <cstdlib>
-#include "../tasks/FixedTimeslotTaskIF.h"
-#include "../tasks/Typedef.h"
-
-/**
- * Singleton Class that produces Tasks.
- */
-class TaskFactory {
-public:
-	virtual ~TaskFactory();
-	/**
-	 * Returns the single instance of TaskFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static TaskFactory* instance();
-
-	/**
-	 * Generic interface to create a periodic task
-	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack size if the task
-	 * @param periodInSeconds_ Period in seconds
-	 * @param deadLineMissedFunction_ This function is called if a deadline was
-	 * missed
-	 * @return Pointer to the created periodic task class
-	 */
-	PeriodicTaskIF* createPeriodicTask(TaskName name_,
-			TaskPriority taskPriority_, TaskStackSize stackSize_,
-			TaskPeriod periodInSeconds_,
-			TaskDeadlineMissedFunction deadLineMissedFunction_);
-
-	/**
-	 * Generic interface to create a fixed timeslot task
-	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack size if the task
-	 * @param periodInSeconds_ Period in seconds
-	 * @param deadLineMissedFunction_ This function is called if a deadline was
-	 * missed
-	 * @return Pointer to the created periodic task class
-	 */
-	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
-			TaskPriority taskPriority_, TaskStackSize stackSize_,
-			TaskPeriod periodInSeconds_,
-			TaskDeadlineMissedFunction deadLineMissedFunction_);
-
-	/**
-	 * Function to be called to delete a task
-	 * @param task The pointer to the task that shall be deleted,
-	 * 				NULL specifies current Task
-	 * @return Success of deletion
-	 */
-	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
-
-	/**
-	 * Function to be called to delay current task
-	 * @param delay The delay in milliseconds
-	 * @return Success of deletion
-	 */
-	static ReturnValue_t delayTask(uint32_t delayMs);
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	TaskFactory();
-	static TaskFactory* factoryInstance;
-};
-
-#endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */
+#ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
+#define FRAMEWORK_TASKS_TASKFACTORY_H_
+
+#include <cstdlib>
+#include "../tasks/FixedTimeslotTaskIF.h"
+#include "../tasks/Typedef.h"
+
+/**
+ * Singleton Class that produces Tasks.
+ */
+class TaskFactory {
+public:
+	virtual ~TaskFactory();
+	/**
+	 * Returns the single instance of TaskFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static TaskFactory* instance();
+
+	/**
+	 * Generic interface to create a periodic task
+	 * @param name_ Name of the task
+	 * @param taskPriority_ Priority of the task
+	 * @param stackSize_ Stack size if the task
+	 * @param periodInSeconds_ Period in seconds
+	 * @param deadLineMissedFunction_ This function is called if a deadline was
+	 * missed
+	 * @return Pointer to the created periodic task class
+	 */
+	PeriodicTaskIF* createPeriodicTask(TaskName name_,
+			TaskPriority taskPriority_, TaskStackSize stackSize_,
+			TaskPeriod periodInSeconds_,
+			TaskDeadlineMissedFunction deadLineMissedFunction_);
+
+	/**
+	 * Generic interface to create a fixed timeslot task
+	 * @param name_ Name of the task
+	 * @param taskPriority_ Priority of the task
+	 * @param stackSize_ Stack size if the task
+	 * @param periodInSeconds_ Period in seconds
+	 * @param deadLineMissedFunction_ This function is called if a deadline was
+	 * missed
+	 * @return Pointer to the created periodic task class
+	 */
+	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
+			TaskPriority taskPriority_, TaskStackSize stackSize_,
+			TaskPeriod periodInSeconds_,
+			TaskDeadlineMissedFunction deadLineMissedFunction_);
+
+	/**
+	 * Function to be called to delete a task
+	 * @param task The pointer to the task that shall be deleted,
+	 * 				NULL specifies current Task
+	 * @return Success of deletion
+	 */
+	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
+
+	/**
+	 * Function to be called to delay current task
+	 * @param delay The delay in milliseconds
+	 * @return Success of deletion
+	 */
+	static ReturnValue_t delayTask(uint32_t delayMs);
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	TaskFactory();
+	static TaskFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index 68f26d2cf..dda26d7f9 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -1,82 +1,82 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/CCSDSDistributor.h"
-#include "../tmtcpacket/SpacePacketBase.h"
-
-CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
-		object_id_t setObjectId):
-		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
-}
-
-CCSDSDistributor::~CCSDSDistributor() {}
-
-TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
-//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
-//			this->currentMessage.getStorageId().pool_index << ", " <<
-//			this->currentMessage.getStorageId().packet_index << std::endl;
-	const uint8_t* packet = nullptr;
-	size_t size = 0;
-	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
-			&packet, &size );
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
-				"store failed!" << std::endl;
-	}
-	SpacePacketBase currentPacket(packet);
-
-//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
-//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
-	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
-	if ( position != this->queueMap.end() ) {
-		return position;
-	} else {
-		//The APID was not found. Forward packet to main SW-APID anyway to
-		// create acceptance failure report.
-		return this->queueMap.find( this->defaultApid );
-	}
-}
-
-MessageQueueId_t CCSDSDistributor::getRequestQueue() {
-	return tcQueue->getId();
-}
-
-ReturnValue_t CCSDSDistributor::registerApplication(
-		AcceptsTelecommandsIF* application) {
-	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( application->getIdentifier(), application->getRequestQueue() ) ).second;
-	if(  errorCode == false ) {
-		returnValue = RETURN_FAILED;
-	}
-	return returnValue;
-}
-
-ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
-		MessageQueueId_t id) {
-	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( apid, id ) ).second;
-	if(  errorCode == false ) {
-		returnValue = RETURN_FAILED;
-	}
-	return returnValue;
-
-}
-
-uint16_t CCSDSDistributor::getIdentifier() {
-	return 0;
-}
-
-ReturnValue_t CCSDSDistributor::initialize() {
-	ReturnValue_t status = this->TcDistributor::initialize();
-	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
-	if (this->tcStore == NULL) status = RETURN_FAILED;
-	return status;
-}
-
-ReturnValue_t CCSDSDistributor::callbackAfterSending(
-		ReturnValue_t queueStatus) {
-	if (queueStatus != RETURN_OK) {
-		tcStore->deleteData(currentMessage.getStorageId());
-	}
-	return RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/CCSDSDistributor.h"
+#include "../tmtcpacket/SpacePacketBase.h"
+
+CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
+		object_id_t setObjectId):
+		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
+}
+
+CCSDSDistributor::~CCSDSDistributor() {}
+
+TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
+//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
+//			this->currentMessage.getStorageId().pool_index << ", " <<
+//			this->currentMessage.getStorageId().packet_index << std::endl;
+	const uint8_t* packet = nullptr;
+	size_t size = 0;
+	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
+			&packet, &size );
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
+				"store failed!" << std::endl;
+	}
+	SpacePacketBase currentPacket(packet);
+
+//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
+//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
+	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
+	if ( position != this->queueMap.end() ) {
+		return position;
+	} else {
+		//The APID was not found. Forward packet to main SW-APID anyway to
+		// create acceptance failure report.
+		return this->queueMap.find( this->defaultApid );
+	}
+}
+
+MessageQueueId_t CCSDSDistributor::getRequestQueue() {
+	return tcQueue->getId();
+}
+
+ReturnValue_t CCSDSDistributor::registerApplication(
+		AcceptsTelecommandsIF* application) {
+	ReturnValue_t returnValue = RETURN_OK;
+	bool errorCode = true;
+	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( application->getIdentifier(), application->getRequestQueue() ) ).second;
+	if(  errorCode == false ) {
+		returnValue = RETURN_FAILED;
+	}
+	return returnValue;
+}
+
+ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
+		MessageQueueId_t id) {
+	ReturnValue_t returnValue = RETURN_OK;
+	bool errorCode = true;
+	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( apid, id ) ).second;
+	if(  errorCode == false ) {
+		returnValue = RETURN_FAILED;
+	}
+	return returnValue;
+
+}
+
+uint16_t CCSDSDistributor::getIdentifier() {
+	return 0;
+}
+
+ReturnValue_t CCSDSDistributor::initialize() {
+	ReturnValue_t status = this->TcDistributor::initialize();
+	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
+	if (this->tcStore == NULL) status = RETURN_FAILED;
+	return status;
+}
+
+ReturnValue_t CCSDSDistributor::callbackAfterSending(
+		ReturnValue_t queueStatus) {
+	if (queueStatus != RETURN_OK) {
+		tcStore->deleteData(currentMessage.getStorageId());
+	}
+	return RETURN_OK;
+}
diff --git a/tcdistribution/CCSDSDistributor.h b/tcdistribution/CCSDSDistributor.h
index e54b9fe4e..6abd952b4 100644
--- a/tcdistribution/CCSDSDistributor.h
+++ b/tcdistribution/CCSDSDistributor.h
@@ -1,69 +1,69 @@
-#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
-#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tcdistribution/CCSDSDistributorIF.h"
-#include "../tcdistribution/TcDistributor.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-
-/**
- * @brief 	An instantiation of the CCSDSDistributorIF.
- * @details
- * It receives Space Packets, and selects a destination depending on the
- * APID of the telecommands.
- * The Secondary Header (with Service/Subservice) is ignored.
- * @ingroup tc_distribution
- */
-class CCSDSDistributor : public TcDistributor,
-		public CCSDSDistributorIF,
-		public AcceptsTelecommandsIF {
-public:
-	/**
-	 * @brief	The constructor sets the default APID and calls the
-	 * 			TcDistributor ctor with a certain object id.
-	 * @details
-	 * @c tcStore is set in the @c initialize method.
-	 * @param setDefaultApid The default APID, where packets with unknown
-	 * destination are sent to.
-	 */
-	CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
-	/**
-	 * The destructor is empty.
-	 */
-	virtual ~CCSDSDistributor();
-
-	MessageQueueId_t getRequestQueue() override;
-	ReturnValue_t registerApplication( uint16_t apid,
-			MessageQueueId_t id) override;
-	ReturnValue_t registerApplication(
-			AcceptsTelecommandsIF* application) override;
-	uint16_t getIdentifier();
-	ReturnValue_t initialize() override;
-
-protected:
-	/**
-	 * This implementation checks if an application with fitting APID has
-	 * registered and forwards the packet to the according message queue.
-	 * If the packet is not found, it returns the queue to @c defaultApid,
-	 * where a Acceptance Failure message should be generated.
-	 * @return Iterator to map entry of found APID or iterator to default APID.
-	 */
-	TcMqMapIter selectDestination() override;
-	/**
-	 * The default APID, where packets with unknown APID are sent to.
-	 */
-	uint16_t defaultApid;
-	/**
-	 * A reference to the TC storage must be maintained, as this class handles
-	 * pure Space Packets and there exists no SpacePacketStored class.
-	 */
-	StorageManagerIF* tcStore = nullptr;
-	/**
-	 * The callback here handles the generation of acceptance
-	 * success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
-};
-
-#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
+#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tcdistribution/CCSDSDistributorIF.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+
+/**
+ * @brief 	An instantiation of the CCSDSDistributorIF.
+ * @details
+ * It receives Space Packets, and selects a destination depending on the
+ * APID of the telecommands.
+ * The Secondary Header (with Service/Subservice) is ignored.
+ * @ingroup tc_distribution
+ */
+class CCSDSDistributor : public TcDistributor,
+		public CCSDSDistributorIF,
+		public AcceptsTelecommandsIF {
+public:
+	/**
+	 * @brief	The constructor sets the default APID and calls the
+	 * 			TcDistributor ctor with a certain object id.
+	 * @details
+	 * @c tcStore is set in the @c initialize method.
+	 * @param setDefaultApid The default APID, where packets with unknown
+	 * destination are sent to.
+	 */
+	CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~CCSDSDistributor();
+
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t registerApplication( uint16_t apid,
+			MessageQueueId_t id) override;
+	ReturnValue_t registerApplication(
+			AcceptsTelecommandsIF* application) override;
+	uint16_t getIdentifier();
+	ReturnValue_t initialize() override;
+
+protected:
+	/**
+	 * This implementation checks if an application with fitting APID has
+	 * registered and forwards the packet to the according message queue.
+	 * If the packet is not found, it returns the queue to @c defaultApid,
+	 * where a Acceptance Failure message should be generated.
+	 * @return Iterator to map entry of found APID or iterator to default APID.
+	 */
+	TcMqMapIter selectDestination() override;
+	/**
+	 * The default APID, where packets with unknown APID are sent to.
+	 */
+	uint16_t defaultApid;
+	/**
+	 * A reference to the TC storage must be maintained, as this class handles
+	 * pure Space Packets and there exists no SpacePacketStored class.
+	 */
+	StorageManagerIF* tcStore = nullptr;
+	/**
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+};
+
+#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/CCSDSDistributorIF.h b/tcdistribution/CCSDSDistributorIF.h
index 32198120a..be3c28114 100644
--- a/tcdistribution/CCSDSDistributorIF.h
+++ b/tcdistribution/CCSDSDistributorIF.h
@@ -1,40 +1,40 @@
-#ifndef CCSDSDISTRIBUTORIF_H_
-#define CCSDSDISTRIBUTORIF_H_
-
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-/**
- * This is the Interface to a CCSDS Distributor.
- * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves,
- * either by passing a pointer to themselves (and implementing the CCSDSApplicationIF,
- * or by explicitly passing an APID and a MessageQueueId to route the TC's to.
- * \ingroup tc_distribution
- */
-class CCSDSDistributorIF {
-public:
-	/**
-	 * With this call, a class implementing the CCSDSApplicationIF can register at the
-	 * distributor.
-	 * @param application A pointer to the Application to register.
-	 * @return	- \c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
-	 */
-	virtual ReturnValue_t registerApplication( AcceptsTelecommandsIF* application ) = 0;
-	/**
-	 * With this call, other Applications can register to the CCSDS distributor.
-	 * This is done by passing an APID and a MessageQueueId to the method.
-	 * @param apid	The APID to register.
-	 * @param id	The MessageQueueId of the message queue to send the TC Packets to.
-	 * @return	- \c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
-	 */
-	virtual ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id ) = 0;
-	/**
-	 * The empty virtual destructor.
-	 */
-	virtual ~CCSDSDistributorIF() {
-	}
-};
-
-
-#endif /* CCSDSDISTRIBUTORIF_H_ */
+#ifndef CCSDSDISTRIBUTORIF_H_
+#define CCSDSDISTRIBUTORIF_H_
+
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+/**
+ * This is the Interface to a CCSDS Distributor.
+ * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves,
+ * either by passing a pointer to themselves (and implementing the CCSDSApplicationIF,
+ * or by explicitly passing an APID and a MessageQueueId to route the TC's to.
+ * \ingroup tc_distribution
+ */
+class CCSDSDistributorIF {
+public:
+	/**
+	 * With this call, a class implementing the CCSDSApplicationIF can register at the
+	 * distributor.
+	 * @param application A pointer to the Application to register.
+	 * @return	- \c RETURN_OK on success,
+	 * 			- \c RETURN_FAILED on failure.
+	 */
+	virtual ReturnValue_t registerApplication( AcceptsTelecommandsIF* application ) = 0;
+	/**
+	 * With this call, other Applications can register to the CCSDS distributor.
+	 * This is done by passing an APID and a MessageQueueId to the method.
+	 * @param apid	The APID to register.
+	 * @param id	The MessageQueueId of the message queue to send the TC Packets to.
+	 * @return	- \c RETURN_OK on success,
+	 * 			- \c RETURN_FAILED on failure.
+	 */
+	virtual ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id ) = 0;
+	/**
+	 * The empty virtual destructor.
+	 */
+	virtual ~CCSDSDistributorIF() {
+	}
+};
+
+
+#endif /* CCSDSDISTRIBUTORIF_H_ */
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index fee16f11e..0c710ef28 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -1,92 +1,92 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/CCSDSDistributorIF.h"
-#include "../tcdistribution/PUSDistributor.h"
-#include "../tmtcpacket/pus/TcPacketStored.h"
-#include "../tmtcservices/PusVerificationReport.h"
-
-PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
-		object_id_t setPacketSource) :
-		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
-		currentPacket(), tcStatus(RETURN_FAILED),
-		packetSource(setPacketSource) {}
-
-PUSDistributor::~PUSDistributor() {}
-
-TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
-	TcMqMapIter queueMapIt = this->queueMap.end();
-	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
-	if (currentPacket.getWholeData() != NULL) {
-		tcStatus = checker.checkPacket(&currentPacket);
-//		sif::debug << "PUSDistributor::handlePacket: packetCheck returned with "
-//				<< (int)tcStatus << std::endl;
-		uint32_t queue_id = currentPacket.getService();
-		queueMapIt = this->queueMap.find(queue_id);
-	} else {
-		tcStatus = PACKET_LOST;
-	}
-	if (queueMapIt == this->queueMap.end()) {
-		tcStatus = DESTINATION_NOT_FOUND;
-	}
-
-	if (tcStatus != RETURN_OK) {
-		sif::debug << "PUSDistributor::handlePacket: Error with " << tcStatus
-				<< ", 0x"<< std::hex << tcStatus << std::dec << std::endl;
-		return this->queueMap.end();
-	} else {
-		return queueMapIt;
-	}
-
-}
-
-//uint16_t PUSDistributor::createDestination( uint8_t service_id, uint8_t subservice_id ) {
-//	return ( service_id << 8 ) + subservice_id;
-//}
-
-ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
-	uint16_t serviceId = service->getIdentifier();
-	//info << "Service ID: " << (int)serviceId << std::endl;
-	MessageQueueId_t queue = service->getRequestQueue();
-	auto returnPair = queueMap.emplace(serviceId, queue);
-	if (not returnPair.second) {
-		//TODO Return Code
-		sif::error << "PUSDistributor::registerService: Service ID already"
-				" exists in map." << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t PUSDistributor::getRequestQueue() {
-	return tcQueue->getId();
-}
-
-ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
-	if (queueStatus != RETURN_OK) {
-		tcStatus = queueStatus;
-	}
-	if (tcStatus != RETURN_OK) {
-		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
-				&currentPacket, tcStatus);
-		//A failed packet is deleted immediately after reporting, otherwise it will block memory.
-		currentPacket.deletePacket();
-		return RETURN_FAILED;
-	} else {
-		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
-				&currentPacket);
-		return RETURN_OK;
-	}
-}
-
-uint16_t PUSDistributor::getIdentifier() {
-	return checker.getApid();
-}
-
-ReturnValue_t PUSDistributor::initialize() {
-	CCSDSDistributorIF* ccsdsDistributor =
-			objectManager->get<CCSDSDistributorIF>(packetSource);
-	if (ccsdsDistributor == NULL) {
-		return RETURN_FAILED;
-	} else {
-		return ccsdsDistributor->registerApplication(this);
-	}
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/CCSDSDistributorIF.h"
+#include "../tcdistribution/PUSDistributor.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+		object_id_t setPacketSource) :
+		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
+		currentPacket(), tcStatus(RETURN_FAILED),
+		packetSource(setPacketSource) {}
+
+PUSDistributor::~PUSDistributor() {}
+
+TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
+	TcMqMapIter queueMapIt = this->queueMap.end();
+	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
+	if (currentPacket.getWholeData() != NULL) {
+		tcStatus = checker.checkPacket(&currentPacket);
+//		sif::debug << "PUSDistributor::handlePacket: packetCheck returned with "
+//				<< (int)tcStatus << std::endl;
+		uint32_t queue_id = currentPacket.getService();
+		queueMapIt = this->queueMap.find(queue_id);
+	} else {
+		tcStatus = PACKET_LOST;
+	}
+	if (queueMapIt == this->queueMap.end()) {
+		tcStatus = DESTINATION_NOT_FOUND;
+	}
+
+	if (tcStatus != RETURN_OK) {
+		sif::debug << "PUSDistributor::handlePacket: Error with " << tcStatus
+				<< ", 0x"<< std::hex << tcStatus << std::dec << std::endl;
+		return this->queueMap.end();
+	} else {
+		return queueMapIt;
+	}
+
+}
+
+//uint16_t PUSDistributor::createDestination( uint8_t service_id, uint8_t subservice_id ) {
+//	return ( service_id << 8 ) + subservice_id;
+//}
+
+ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
+	uint16_t serviceId = service->getIdentifier();
+	//info << "Service ID: " << (int)serviceId << std::endl;
+	MessageQueueId_t queue = service->getRequestQueue();
+	auto returnPair = queueMap.emplace(serviceId, queue);
+	if (not returnPair.second) {
+		//TODO Return Code
+		sif::error << "PUSDistributor::registerService: Service ID already"
+				" exists in map." << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t PUSDistributor::getRequestQueue() {
+	return tcQueue->getId();
+}
+
+ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+	if (queueStatus != RETURN_OK) {
+		tcStatus = queueStatus;
+	}
+	if (tcStatus != RETURN_OK) {
+		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
+				&currentPacket, tcStatus);
+		//A failed packet is deleted immediately after reporting, otherwise it will block memory.
+		currentPacket.deletePacket();
+		return RETURN_FAILED;
+	} else {
+		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
+				&currentPacket);
+		return RETURN_OK;
+	}
+}
+
+uint16_t PUSDistributor::getIdentifier() {
+	return checker.getApid();
+}
+
+ReturnValue_t PUSDistributor::initialize() {
+	CCSDSDistributorIF* ccsdsDistributor =
+			objectManager->get<CCSDSDistributorIF>(packetSource);
+	if (ccsdsDistributor == NULL) {
+		return RETURN_FAILED;
+	} else {
+		return ccsdsDistributor->registerApplication(this);
+	}
+}
diff --git a/tcdistribution/PUSDistributor.h b/tcdistribution/PUSDistributor.h
index be84de1b7..b8cff1f44 100644
--- a/tcdistribution/PUSDistributor.h
+++ b/tcdistribution/PUSDistributor.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
-#define FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tcdistribution/PUSDistributorIF.h"
-#include "../tcdistribution/TcDistributor.h"
-#include "../tcdistribution/TcPacketCheck.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../tmtcservices/VerificationReporter.h"
-
-/**
- * This class accepts PUS Telecommands and forwards them to Application
- * services. In addition, the class performs a formal packet check and
- * sends acceptance success or failure messages.
- * @ingroup tc_distribution
- */
-class PUSDistributor: public TcDistributor,
-		public PUSDistributorIF,
-		public AcceptsTelecommandsIF {
-public:
-	/**
-	 * The ctor passes @c set_apid to the checker class and calls the
-	 * TcDistribution ctor with a certain object id.
-	 * @param setApid The APID of this receiving Application.
-	 * @param setObjectId Object ID of the distributor itself
-	 * @param setPacketSource Object ID of the source of TC packets.
-	 * Must implement CCSDSDistributorIF.
-	 */
-	PUSDistributor(uint16_t setApid, object_id_t setObjectId,
-			object_id_t setPacketSource);
-	/**
-	 * The destructor is empty.
-	 */
-	virtual ~PUSDistributor();
-	ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
-	MessageQueueId_t getRequestQueue() override;
-	ReturnValue_t initialize() override;
-	uint16_t getIdentifier() override;
-
-protected:
-	/**
-	 * This attribute contains the class, that performs a formal packet check.
-	 */
-	TcPacketCheck checker;
-	/**
-	 * With this class, verification messages are sent to the
-	 * TC Verification service.
-	 */
-	VerificationReporter verifyChannel;
-	/**
-	 * The currently handled packet is stored here.
-	 */
-	TcPacketStored currentPacket;
-	/**
-	 * With this variable, the current check status is stored to generate
-	 * acceptance messages later.
-	 */
-	ReturnValue_t tcStatus;
-
-	const object_id_t packetSource;
-	/**
-	 * This method reads the packet service, checks if such a service is
-	 * registered and forwards the packet to the destination.
-	 * It also initiates the formal packet check and sending of verification
-	 * messages.
-	 * @return Iterator to map entry of found service id
-	 * or iterator to @c map.end().
-	 */
-	TcMqMapIter selectDestination() override;
-	/**
-	 * The callback here handles the generation of acceptance
-	 * success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
-};
-
-#endif /* FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
+#ifndef FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tcdistribution/TcPacketCheck.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../tmtcservices/VerificationReporter.h"
+
+/**
+ * This class accepts PUS Telecommands and forwards them to Application
+ * services. In addition, the class performs a formal packet check and
+ * sends acceptance success or failure messages.
+ * @ingroup tc_distribution
+ */
+class PUSDistributor: public TcDistributor,
+		public PUSDistributorIF,
+		public AcceptsTelecommandsIF {
+public:
+	/**
+	 * The ctor passes @c set_apid to the checker class and calls the
+	 * TcDistribution ctor with a certain object id.
+	 * @param setApid The APID of this receiving Application.
+	 * @param setObjectId Object ID of the distributor itself
+	 * @param setPacketSource Object ID of the source of TC packets.
+	 * Must implement CCSDSDistributorIF.
+	 */
+	PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+			object_id_t setPacketSource);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~PUSDistributor();
+	ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t initialize() override;
+	uint16_t getIdentifier() override;
+
+protected:
+	/**
+	 * This attribute contains the class, that performs a formal packet check.
+	 */
+	TcPacketCheck checker;
+	/**
+	 * With this class, verification messages are sent to the
+	 * TC Verification service.
+	 */
+	VerificationReporter verifyChannel;
+	/**
+	 * The currently handled packet is stored here.
+	 */
+	TcPacketStored currentPacket;
+	/**
+	 * With this variable, the current check status is stored to generate
+	 * acceptance messages later.
+	 */
+	ReturnValue_t tcStatus;
+
+	const object_id_t packetSource;
+	/**
+	 * This method reads the packet service, checks if such a service is
+	 * registered and forwards the packet to the destination.
+	 * It also initiates the formal packet check and sending of verification
+	 * messages.
+	 * @return Iterator to map entry of found service id
+	 * or iterator to @c map.end().
+	 */
+	TcMqMapIter selectDestination() override;
+	/**
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
+};
+
+#endif /* FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/PUSDistributorIF.h b/tcdistribution/PUSDistributorIF.h
index 7967a74ed..5e27b35c5 100644
--- a/tcdistribution/PUSDistributorIF.h
+++ b/tcdistribution/PUSDistributorIF.h
@@ -1,26 +1,26 @@
-#ifndef PUSDISTRIBUTORIF_H_
-#define PUSDISTRIBUTORIF_H_
-
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-/**
- * This interface allows PUS Services to register themselves at a PUS Distributor.
- * \ingroup tc_distribution
- */
-class PUSDistributorIF {
-public:
-	/**
-	 * The empty virtual destructor.
-	 */
-	virtual ~PUSDistributorIF() {
-	}
-/**
- * With this method, Services can register themselves at the PUS Distributor.
- * @param service A pointer to the registering Service.
- * @return	- \c RETURN_OK on success,
- * 			- \c RETURN_FAILED on failure.
- */
-	virtual ReturnValue_t registerService( AcceptsTelecommandsIF* service ) = 0;
-};
-
-#endif /* PUSDISTRIBUTORIF_H_ */
+#ifndef PUSDISTRIBUTORIF_H_
+#define PUSDISTRIBUTORIF_H_
+
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+/**
+ * This interface allows PUS Services to register themselves at a PUS Distributor.
+ * \ingroup tc_distribution
+ */
+class PUSDistributorIF {
+public:
+	/**
+	 * The empty virtual destructor.
+	 */
+	virtual ~PUSDistributorIF() {
+	}
+/**
+ * With this method, Services can register themselves at the PUS Distributor.
+ * @param service A pointer to the registering Service.
+ * @return	- \c RETURN_OK on success,
+ * 			- \c RETURN_FAILED on failure.
+ */
+	virtual ReturnValue_t registerService( AcceptsTelecommandsIF* service ) = 0;
+};
+
+#endif /* PUSDISTRIBUTORIF_H_ */
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index 45a20fd92..b03545581 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -1,54 +1,54 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/TcDistributor.h"
-#include "../tmtcservices/TmTcMessage.h"
-#include "../ipc/QueueFactory.h"
-
-TcDistributor::TcDistributor(object_id_t set_object_id) :
-		SystemObject(set_object_id), tcQueue(NULL) {
-	tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
-}
-
-TcDistributor::~TcDistributor() {
-	QueueFactory::instance()->deleteMessageQueue(tcQueue);
-}
-
-ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
-	ReturnValue_t status = RETURN_OK;
-	for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
-			status = tcQueue->receiveMessage(&currentMessage)) {
-		status = handlePacket();
-	}
-	if (status == MessageQueueIF::EMPTY) {
-		return RETURN_OK;
-	} else {
-		return status;
-	}
-}
-
-ReturnValue_t TcDistributor::handlePacket() {
-
-	TcMqMapIter queueMapIt = this->selectDestination();
-	ReturnValue_t returnValue = RETURN_FAILED;
-	if (queueMapIt != this->queueMap.end()) {
-		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
-				&this->currentMessage);
-	}
-	return this->callbackAfterSending(returnValue);
-}
-
-void TcDistributor::print() {
-	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
-			<< std::endl;
-	for (TcMqMapIter it = this->queueMap.begin(); it != this->queueMap.end();
-			it++) {
-		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
-				<< std::endl;
-	}
-	sif::debug << std::dec;
-
-}
-
-ReturnValue_t TcDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
-	return RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+
+TcDistributor::TcDistributor(object_id_t set_object_id) :
+		SystemObject(set_object_id), tcQueue(NULL) {
+	tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
+}
+
+TcDistributor::~TcDistributor() {
+	QueueFactory::instance()->deleteMessageQueue(tcQueue);
+}
+
+ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
+	ReturnValue_t status = RETURN_OK;
+	for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
+			status = tcQueue->receiveMessage(&currentMessage)) {
+		status = handlePacket();
+	}
+	if (status == MessageQueueIF::EMPTY) {
+		return RETURN_OK;
+	} else {
+		return status;
+	}
+}
+
+ReturnValue_t TcDistributor::handlePacket() {
+
+	TcMqMapIter queueMapIt = this->selectDestination();
+	ReturnValue_t returnValue = RETURN_FAILED;
+	if (queueMapIt != this->queueMap.end()) {
+		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
+				&this->currentMessage);
+	}
+	return this->callbackAfterSending(returnValue);
+}
+
+void TcDistributor::print() {
+	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
+			<< std::endl;
+	for (TcMqMapIter it = this->queueMap.begin(); it != this->queueMap.end();
+			it++) {
+		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
+				<< std::endl;
+	}
+	sif::debug << std::dec;
+
+}
+
+ReturnValue_t TcDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+	return RETURN_OK;
+}
diff --git a/tcdistribution/TcDistributor.h b/tcdistribution/TcDistributor.h
index 987f2eaa0..95b7d25b8 100644
--- a/tcdistribution/TcDistributor.h
+++ b/tcdistribution/TcDistributor.h
@@ -1,120 +1,120 @@
-#ifndef FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
-#define FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../tmtcservices/TmTcMessage.h"
-#include "../ipc/MessageQueueIF.h"
-#include <map>
-
-/**
- * @defgroup tc_distribution Telecommand Distribution
- * All classes associated with Routing and Distribution of Telecommands
- * belong to this group.
- */
-
-
-/**
- * This is the base class to implement distributors for Space Packets.
- * Typically, the distribution is required to forward Telecommand packets
- * over the satellite applications and services. The class receives
- * Space Packets over a message queue and holds a map that links other
- * message queue ids to some identifier. The process of unpacking the
- * destination information from the packet is handled by the child class
- * implementations.
- * @ingroup tc_distribution
- */
-class TcDistributor : public SystemObject,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-public:
-	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
-	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
-	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
-	/**
-	 * Within the default constructor, the SystemObject id is set and the
-	 * message queue is initialized.
-	 * Filling the map is under control of the child classes.
-	 * @param set_object_id	This id is assigned to the distributor
-	 * 		implementation.
-	 */
-	TcDistributor( object_id_t set_object_id );
-	/**
-	 * The destructor is empty, the message queues are not in the vicinity of
-	 * this class.
-	 */
-	virtual ~TcDistributor();
-	/**
-	 * The method is called cyclically and fetches new incoming packets from
-	 * the message queue.
-	 * In case a new packet is found, it calls the handlePacket method to deal
-	 * with distribution.
-	 * @return The error code of the message queue call.
-	 */
-	ReturnValue_t performOperation(uint8_t opCode);
-	/**
-	 * A simple debug print, that prints all distribution information stored in
-	 * queueMap.
-	 */
-	void print();
-
-protected:
-	/**
-	 * This is the receiving queue for incoming Telecommands.
-	 * The child classes must make its queue id public.
-	 */
-	MessageQueueIF* tcQueue;
-	/**
-	 * The last received incoming packet information is stored in this
-	 * member.
-	 * As different child classes unpack the incoming packet differently
-	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
-	 * is not tried to unpack the packet information within this class.
-	 */
-	TmTcMessage currentMessage;
-	/**
-	 * The map that links certain packet information to a destination.
-	 * The packet information may be the APID of the packet or the service
-	 * identifier. Filling of the map is under control of the different child
-	 * classes.
-	 */
-	TcMessageQueueMap queueMap;
-	/**
-	 * This method shall unpack the routing information from the incoming
-	 * packet and select the map entry which represents the packet's target.
-	 * @return	An iterator to the map element to forward to or queuMap.end().
-	 */
-	virtual TcMqMapIter selectDestination() = 0;
-	/**
-	 * The handlePacket method calls the child class's selectDestination method
-	 * and forwards the packet to its destination, if found.
-	 * @return The message queue return value or \c RETURN_FAILED, in case no
-	 * 		destination was found.
-	 */
-	ReturnValue_t handlePacket();
-	/**
-	 * This method gives the child class a chance to perform some kind of operation
-	 * after the parent tried to forward the message.
-	 * A typically application would be sending success/failure messages.
-	 * The default implementation just returns \c RETURN_OK.
-	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
-	 * @return	- \c RETURN_OK on success
-	 * 			- \c RETURN_FAILED on failure
-	 */
-	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
-
-private:
-	/**
-	 * This constant sets the maximum number of packets distributed per call.
-	 */
-	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
-};
-
-
-#endif /* TCDISTRIBUTOR_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+#define FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/MessageQueueIF.h"
+#include <map>
+
+/**
+ * @defgroup tc_distribution Telecommand Distribution
+ * All classes associated with Routing and Distribution of Telecommands
+ * belong to this group.
+ */
+
+
+/**
+ * This is the base class to implement distributors for Space Packets.
+ * Typically, the distribution is required to forward Telecommand packets
+ * over the satellite applications and services. The class receives
+ * Space Packets over a message queue and holds a map that links other
+ * message queue ids to some identifier. The process of unpacking the
+ * destination information from the packet is handled by the child class
+ * implementations.
+ * @ingroup tc_distribution
+ */
+class TcDistributor : public SystemObject,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+public:
+	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
+	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
+	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
+	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	/**
+	 * Within the default constructor, the SystemObject id is set and the
+	 * message queue is initialized.
+	 * Filling the map is under control of the child classes.
+	 * @param set_object_id	This id is assigned to the distributor
+	 * 		implementation.
+	 */
+	TcDistributor( object_id_t set_object_id );
+	/**
+	 * The destructor is empty, the message queues are not in the vicinity of
+	 * this class.
+	 */
+	virtual ~TcDistributor();
+	/**
+	 * The method is called cyclically and fetches new incoming packets from
+	 * the message queue.
+	 * In case a new packet is found, it calls the handlePacket method to deal
+	 * with distribution.
+	 * @return The error code of the message queue call.
+	 */
+	ReturnValue_t performOperation(uint8_t opCode);
+	/**
+	 * A simple debug print, that prints all distribution information stored in
+	 * queueMap.
+	 */
+	void print();
+
+protected:
+	/**
+	 * This is the receiving queue for incoming Telecommands.
+	 * The child classes must make its queue id public.
+	 */
+	MessageQueueIF* tcQueue;
+	/**
+	 * The last received incoming packet information is stored in this
+	 * member.
+	 * As different child classes unpack the incoming packet differently
+	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
+	 * is not tried to unpack the packet information within this class.
+	 */
+	TmTcMessage currentMessage;
+	/**
+	 * The map that links certain packet information to a destination.
+	 * The packet information may be the APID of the packet or the service
+	 * identifier. Filling of the map is under control of the different child
+	 * classes.
+	 */
+	TcMessageQueueMap queueMap;
+	/**
+	 * This method shall unpack the routing information from the incoming
+	 * packet and select the map entry which represents the packet's target.
+	 * @return	An iterator to the map element to forward to or queuMap.end().
+	 */
+	virtual TcMqMapIter selectDestination() = 0;
+	/**
+	 * The handlePacket method calls the child class's selectDestination method
+	 * and forwards the packet to its destination, if found.
+	 * @return The message queue return value or \c RETURN_FAILED, in case no
+	 * 		destination was found.
+	 */
+	ReturnValue_t handlePacket();
+	/**
+	 * This method gives the child class a chance to perform some kind of operation
+	 * after the parent tried to forward the message.
+	 * A typically application would be sending success/failure messages.
+	 * The default implementation just returns \c RETURN_OK.
+	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
+	 * @return	- \c RETURN_OK on success
+	 * 			- \c RETURN_FAILED on failure
+	 */
+	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+
+private:
+	/**
+	 * This constant sets the maximum number of packets distributed per call.
+	 */
+	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
+};
+
+
+#endif /* TCDISTRIBUTOR_H_ */
diff --git a/tcdistribution/TcPacketCheck.cpp b/tcdistribution/TcPacketCheck.cpp
index 98dfaeb89..4701ce238 100644
--- a/tcdistribution/TcPacketCheck.cpp
+++ b/tcdistribution/TcPacketCheck.cpp
@@ -1,37 +1,37 @@
-#include "../globalfunctions/CRC.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tcdistribution/TcPacketCheck.h"
-#include "../tmtcservices/VerificationCodes.h"
-
-TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) {
-}
-
-ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* current_packet ) {
-	uint16_t calculated_crc = CRC::crc16ccitt( current_packet->getWholeData(), current_packet->getFullSize() );
-	if ( calculated_crc != 0 ) {
-		return INCORRECT_CHECKSUM;
-	}
-	bool condition = !(current_packet->hasSecondaryHeader()) ||
-			current_packet->getPacketVersionNumber() != CCSDS_VERSION_NUMBER ||
-			!(current_packet->isTelecommand());
-	if ( condition ) {
-		return INCORRECT_PRIMARY_HEADER;
-	}
-	if ( current_packet->getAPID() != this->apid )
-		return ILLEGAL_APID;
-
-	if ( !current_packet->isSizeCorrect() ) {
-		return INCOMPLETE_PACKET;
-	}
-	condition = (current_packet->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
-			(current_packet->getPusVersionNumber() != PUS_VERSION_NUMBER);
-	if ( condition ) {
-		return INCORRECT_SECONDARY_HEADER;
-	}
-	return RETURN_OK;
-}
-
-uint16_t TcPacketCheck::getApid() const {
-	return apid;
-}
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tcdistribution/TcPacketCheck.h"
+#include "../tmtcservices/VerificationCodes.h"
+
+TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) {
+}
+
+ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* current_packet ) {
+	uint16_t calculated_crc = CRC::crc16ccitt( current_packet->getWholeData(), current_packet->getFullSize() );
+	if ( calculated_crc != 0 ) {
+		return INCORRECT_CHECKSUM;
+	}
+	bool condition = !(current_packet->hasSecondaryHeader()) ||
+			current_packet->getPacketVersionNumber() != CCSDS_VERSION_NUMBER ||
+			!(current_packet->isTelecommand());
+	if ( condition ) {
+		return INCORRECT_PRIMARY_HEADER;
+	}
+	if ( current_packet->getAPID() != this->apid )
+		return ILLEGAL_APID;
+
+	if ( !current_packet->isSizeCorrect() ) {
+		return INCOMPLETE_PACKET;
+	}
+	condition = (current_packet->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
+			(current_packet->getPusVersionNumber() != PUS_VERSION_NUMBER);
+	if ( condition ) {
+		return INCORRECT_SECONDARY_HEADER;
+	}
+	return RETURN_OK;
+}
+
+uint16_t TcPacketCheck::getApid() const {
+	return apid;
+}
diff --git a/tcdistribution/TcPacketCheck.h b/tcdistribution/TcPacketCheck.h
index 9fe1db721..4ba269f5e 100644
--- a/tcdistribution/TcPacketCheck.h
+++ b/tcdistribution/TcPacketCheck.h
@@ -1,59 +1,59 @@
-#ifndef TCPACKETCHECK_H_
-#define TCPACKETCHECK_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tmtcpacket/pus/TcPacketStored.h"
-#include "../tmtcservices/PusVerificationReport.h"
-/**
- * This class performs a formal packet check for incoming PUS Telecommand Packets.
- * Currently, it only checks if the APID and CRC are correct.
- * \ingroup tc_distribution
- */
-class TcPacketCheck : public HasReturnvaluesIF {
-protected:
-	/**
-	 * Describes the version number a packet must have to pass.
-	 */
-	static const uint8_t CCSDS_VERSION_NUMBER = 0;
-	/**
-	 * Describes the secondary header a packet must have to pass.
-	 */
-	static const uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
-	/**
-	 * Describes the TC Packet PUS Version Number a packet must have to pass.
-	 */
-	static const uint8_t PUS_VERSION_NUMBER = 1;
-	/**
-	 * The packet id each correct packet should have.
-	 * It is composed of the APID and some static fields.
-	 */
-	uint16_t apid;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TC_PACKET_CHECK;
-	static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE( 0 );
-	static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE( 2 );
-	static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE( 3 );
-	static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE( 4 );
-	static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE( 5 );
-	static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE( 6 );
-	/**
-	 * The constructor only sets the APID attribute.
-	 * @param set_apid The APID to set.
-	 */
-	TcPacketCheck( uint16_t set_apid );
-	/**
-	 * This is the actual method to formally check a certain Telecommand Packet.
-	 * The packet's Application Data can not be checked here.
-	 * @param current_packet The packt to check
-	 * @return	- \c RETURN_OK on success.
-	 * 			- \c INCORRECT_CHECKSUM if checksum is invalid.
-	 * 			- \c ILLEGAL_APID if APID does not match.
-	 */
-	ReturnValue_t checkPacket( TcPacketStored* current_packet );
-
-	uint16_t getApid() const;
-};
-
-
-#endif /* TCPACKETCHECK_H_ */
+#ifndef TCPACKETCHECK_H_
+#define TCPACKETCHECK_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/PusVerificationReport.h"
+/**
+ * This class performs a formal packet check for incoming PUS Telecommand Packets.
+ * Currently, it only checks if the APID and CRC are correct.
+ * \ingroup tc_distribution
+ */
+class TcPacketCheck : public HasReturnvaluesIF {
+protected:
+	/**
+	 * Describes the version number a packet must have to pass.
+	 */
+	static const uint8_t CCSDS_VERSION_NUMBER = 0;
+	/**
+	 * Describes the secondary header a packet must have to pass.
+	 */
+	static const uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
+	/**
+	 * Describes the TC Packet PUS Version Number a packet must have to pass.
+	 */
+	static const uint8_t PUS_VERSION_NUMBER = 1;
+	/**
+	 * The packet id each correct packet should have.
+	 * It is composed of the APID and some static fields.
+	 */
+	uint16_t apid;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TC_PACKET_CHECK;
+	static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE( 0 );
+	static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE( 1 );
+	static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE( 2 );
+	static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE( 3 );
+	static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE( 4 );
+	static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE( 5 );
+	static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE( 6 );
+	/**
+	 * The constructor only sets the APID attribute.
+	 * @param set_apid The APID to set.
+	 */
+	TcPacketCheck( uint16_t set_apid );
+	/**
+	 * This is the actual method to formally check a certain Telecommand Packet.
+	 * The packet's Application Data can not be checked here.
+	 * @param current_packet The packt to check
+	 * @return	- \c RETURN_OK on success.
+	 * 			- \c INCORRECT_CHECKSUM if checksum is invalid.
+	 * 			- \c ILLEGAL_APID if APID does not match.
+	 */
+	ReturnValue_t checkPacket( TcPacketStored* current_packet );
+
+	uint16_t getApid() const;
+};
+
+
+#endif /* TCPACKETCHECK_H_ */
diff --git a/thermal/AbstractTemperatureSensor.cpp b/thermal/AbstractTemperatureSensor.cpp
index 5d8213679..40b305af9 100644
--- a/thermal/AbstractTemperatureSensor.cpp
+++ b/thermal/AbstractTemperatureSensor.cpp
@@ -1,70 +1,70 @@
-#include "AbstractTemperatureSensor.h"
-#include "../ipc/QueueFactory.h"
-
-AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
-		ThermalModuleIF *thermalModule) :
-		SystemObject(setObjectid), commandQueue(NULL), healthHelper(this,
-				setObjectid), parameterHelper(this) {
-	if (thermalModule != NULL) {
-		thermalModule->registerSensor(this);
-	}
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-AbstractTemperatureSensor::~AbstractTemperatureSensor() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-MessageQueueId_t AbstractTemperatureSensor::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t AbstractTemperatureSensor::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = parameterHelper.initialize();
-	return result;
-}
-
-ReturnValue_t AbstractTemperatureSensor::performOperation(uint8_t opCode) {
-	handleCommandQueue();
-	doChildOperation();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
-	handleCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void AbstractTemperatureSensor::handleCommandQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		result = parameterHelper.handleParameterMessage(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
-}
-
-ReturnValue_t AbstractTemperatureSensor::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-HasHealthIF::HealthState AbstractTemperatureSensor::getHealth() {
-	return healthHelper.getHealth();
-}
+#include "AbstractTemperatureSensor.h"
+#include "../ipc/QueueFactory.h"
+
+AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
+		ThermalModuleIF *thermalModule) :
+		SystemObject(setObjectid), commandQueue(NULL), healthHelper(this,
+				setObjectid), parameterHelper(this) {
+	if (thermalModule != NULL) {
+		thermalModule->registerSensor(this);
+	}
+	commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+AbstractTemperatureSensor::~AbstractTemperatureSensor() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+MessageQueueId_t AbstractTemperatureSensor::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t AbstractTemperatureSensor::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	return result;
+}
+
+ReturnValue_t AbstractTemperatureSensor::performOperation(uint8_t opCode) {
+	handleCommandQueue();
+	doChildOperation();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
+	handleCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void AbstractTemperatureSensor::handleCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		result = parameterHelper.handleParameterMessage(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		command.setToUnknownCommand();
+		commandQueue->reply(&command);
+	}
+}
+
+ReturnValue_t AbstractTemperatureSensor::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState AbstractTemperatureSensor::getHealth() {
+	return healthHelper.getHealth();
+}
diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h
index 462b41f25..cc064ce47 100644
--- a/thermal/AbstractTemperatureSensor.h
+++ b/thermal/AbstractTemperatureSensor.h
@@ -1,64 +1,64 @@
-#ifndef ABSTRACTSENSOR_H_
-#define ABSTRACTSENSOR_H_
-
-#include "../health/HasHealthIF.h"
-#include "../health/HealthHelper.h"
-#include "../objectmanager/SystemObject.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../parameters/ParameterHelper.h"
-#include "../ipc/MessageQueueIF.h"
-#include "ThermalModuleIF.h"
-#include "tcsDefinitions.h"
-
-/**
- * @defgroup thermal Thermal Components
- * @brief Contains all components related to thermal tasks (sensors, heaters)
- */
-
-/**
- * @brief Base class for Temperature Sensor, implements all important interfaces.
- *        Please use the TemperatureSensor class to implement the actual sensors.
- * @ingroup thermal
- */
-class AbstractTemperatureSensor: public HasHealthIF,
-		public SystemObject,
-		public ExecutableObjectIF,
-		public ReceivesParameterMessagesIF {
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::T_SENSORS;
-	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, SEVERITY::LOW);
-
-	static constexpr float ZERO_KELVIN_C = -273.15;
-	AbstractTemperatureSensor(object_id_t setObjectid,
-			ThermalModuleIF *thermalModule);
-	virtual ~AbstractTemperatureSensor();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t initialize();
-
-	ReturnValue_t performHealthOp();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual float getTemperature() = 0;
-	virtual bool isValid() = 0;
-
-	virtual void resetOldState() = 0;
-
-	ReturnValue_t setHealth(HealthState health);
-	HasHealthIF::HealthState getHealth();
-protected:
-	MessageQueueIF* commandQueue;
-	HealthHelper healthHelper;
-	ParameterHelper parameterHelper;
-
-	virtual void doChildOperation() = 0;
-
-	void handleCommandQueue();
-};
-
-#endif /* ABSTRACTSENSOR_H_ */
+#ifndef ABSTRACTSENSOR_H_
+#define ABSTRACTSENSOR_H_
+
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../parameters/ParameterHelper.h"
+#include "../ipc/MessageQueueIF.h"
+#include "ThermalModuleIF.h"
+#include "tcsDefinitions.h"
+
+/**
+ * @defgroup thermal Thermal Components
+ * @brief Contains all components related to thermal tasks (sensors, heaters)
+ */
+
+/**
+ * @brief Base class for Temperature Sensor, implements all important interfaces.
+ *        Please use the TemperatureSensor class to implement the actual sensors.
+ * @ingroup thermal
+ */
+class AbstractTemperatureSensor: public HasHealthIF,
+		public SystemObject,
+		public ExecutableObjectIF,
+		public ReceivesParameterMessagesIF {
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::T_SENSORS;
+	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, SEVERITY::LOW);
+
+	static constexpr float ZERO_KELVIN_C = -273.15;
+	AbstractTemperatureSensor(object_id_t setObjectid,
+			ThermalModuleIF *thermalModule);
+	virtual ~AbstractTemperatureSensor();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t initialize();
+
+	ReturnValue_t performHealthOp();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual float getTemperature() = 0;
+	virtual bool isValid() = 0;
+
+	virtual void resetOldState() = 0;
+
+	ReturnValue_t setHealth(HealthState health);
+	HasHealthIF::HealthState getHealth();
+protected:
+	MessageQueueIF* commandQueue;
+	HealthHelper healthHelper;
+	ParameterHelper parameterHelper;
+
+	virtual void doChildOperation() = 0;
+
+	void handleCommandQueue();
+};
+
+#endif /* ABSTRACTSENSOR_H_ */
diff --git a/thermal/AcceptsThermalMessagesIF.h b/thermal/AcceptsThermalMessagesIF.h
index 9fe03499e..5fbd6bb38 100644
--- a/thermal/AcceptsThermalMessagesIF.h
+++ b/thermal/AcceptsThermalMessagesIF.h
@@ -1,22 +1,22 @@
-/**
- * \file AcceptsThermalMessagesIF.h
- *
- * \date 16.02.2020
- */
-
-#ifndef FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
-#define FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
-#include "../ipc/MessageQueueSenderIF.h"
-
-class AcceptsThermalMessagesIF {
-public:
-
-	/**
-	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~AcceptsThermalMessagesIF() { }
-
-	virtual MessageQueueId_t getReceptionQueue() const = 0;
-};
-
-#endif /* FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_ */
+/**
+ * \file AcceptsThermalMessagesIF.h
+ *
+ * \date 16.02.2020
+ */
+
+#ifndef FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
+#define FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
+#include "../ipc/MessageQueueSenderIF.h"
+
+class AcceptsThermalMessagesIF {
+public:
+
+	/**
+	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~AcceptsThermalMessagesIF() { }
+
+	virtual MessageQueueId_t getReceptionQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_ */
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index 87a6972e8..8093711d6 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -1,96 +1,96 @@
-#ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-#define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../thermal/ThermalComponentIF.h"
-#include "../thermal/AbstractTemperatureSensor.h"
-#include "../thermal/ThermalModule.h"
-#include "../thermal/ThermalMonitor.h"
-
-// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
-class CoreComponent: public ThermalComponentIF {
-public:
-	struct Parameters {
-		float lowerOpLimit;
-		float upperOpLimit;
-		float heaterOn;
-		float hysteresis;
-		float heaterSwitchoff;
-	};
-
-	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
-
-	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
-			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-			uint32_t requestPoolId, GlobDataSet *dataSet,
-			AbstractTemperatureSensor *sensor,
-			AbstractTemperatureSensor *firstRedundantSensor,
-			AbstractTemperatureSensor *secondRedundantSensor,
-			ThermalModuleIF *thermalModule, Parameters parameters,
-			Priority priority, StateRequest initialTargetState =
-					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
-
-	virtual ~CoreComponent();
-
-	virtual HeaterRequest performOperation(uint8_t opCode);
-
-	void markStateIgnored();
-
-	object_id_t getObjectId();
-
-	uint8_t getDomainId() const;
-
-	virtual float getLowerOpLimit();
-
-	ReturnValue_t setTargetState(int8_t newState);
-
-	virtual void setOutputInvalid();
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-protected:
-
-	AbstractTemperatureSensor *sensor;
-	AbstractTemperatureSensor *firstRedundantSensor;
-	AbstractTemperatureSensor *secondRedundantSensor;
-	ThermalModuleIF *thermalModule;
-
-	gp_float_t temperature;
-	gp_int8_t targetState;
-	gp_int8_t currentState;
-	gp_uint8_t heaterRequest;
-
-	bool isHeating;
-
-	bool isSafeComponent;
-
-	float minTemp;
-
-	float maxTemp;
-
-	Parameters parameters;
-
-	ThermalMonitor temperatureMonitor;
-
-	const uint8_t domainId;
-
-	virtual float getTemperature();
-	virtual State getState(float temperature, Parameters parameters,
-			int8_t targetState);
-
-	virtual void checkLimits(State state);
-
-	virtual HeaterRequest getHeaterRequest(int8_t targetState,
-			float temperature, Parameters parameters);
-
-	virtual State getIgnoredState(int8_t state);
-
-	void updateMinMaxTemp();
-
-	virtual Parameters getParameters();
-};
-
-#endif /* MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ */
+#ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
+#define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../thermal/ThermalComponentIF.h"
+#include "../thermal/AbstractTemperatureSensor.h"
+#include "../thermal/ThermalModule.h"
+#include "../thermal/ThermalMonitor.h"
+
+// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
+class CoreComponent: public ThermalComponentIF {
+public:
+	struct Parameters {
+		float lowerOpLimit;
+		float upperOpLimit;
+		float heaterOn;
+		float hysteresis;
+		float heaterSwitchoff;
+	};
+
+	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
+
+	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
+			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
+			uint32_t requestPoolId, GlobDataSet *dataSet,
+			AbstractTemperatureSensor *sensor,
+			AbstractTemperatureSensor *firstRedundantSensor,
+			AbstractTemperatureSensor *secondRedundantSensor,
+			ThermalModuleIF *thermalModule, Parameters parameters,
+			Priority priority, StateRequest initialTargetState =
+					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
+
+	virtual ~CoreComponent();
+
+	virtual HeaterRequest performOperation(uint8_t opCode);
+
+	void markStateIgnored();
+
+	object_id_t getObjectId();
+
+	uint8_t getDomainId() const;
+
+	virtual float getLowerOpLimit();
+
+	ReturnValue_t setTargetState(int8_t newState);
+
+	virtual void setOutputInvalid();
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+protected:
+
+	AbstractTemperatureSensor *sensor;
+	AbstractTemperatureSensor *firstRedundantSensor;
+	AbstractTemperatureSensor *secondRedundantSensor;
+	ThermalModuleIF *thermalModule;
+
+	gp_float_t temperature;
+	gp_int8_t targetState;
+	gp_int8_t currentState;
+	gp_uint8_t heaterRequest;
+
+	bool isHeating;
+
+	bool isSafeComponent;
+
+	float minTemp;
+
+	float maxTemp;
+
+	Parameters parameters;
+
+	ThermalMonitor temperatureMonitor;
+
+	const uint8_t domainId;
+
+	virtual float getTemperature();
+	virtual State getState(float temperature, Parameters parameters,
+			int8_t targetState);
+
+	virtual void checkLimits(State state);
+
+	virtual HeaterRequest getHeaterRequest(int8_t targetState,
+			float temperature, Parameters parameters);
+
+	virtual State getIgnoredState(int8_t state);
+
+	void updateMinMaxTemp();
+
+	virtual Parameters getParameters();
+};
+
+#endif /* MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ */
diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index 94dd91b5d..2bee47f1c 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -1,350 +1,350 @@
-#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
-#include "Heater.h"
-
-#include "../power/Fuse.h"
-#include "../ipc/QueueFactory.h"
-
-Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) :
-		HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
-				NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(
-				false), timedOut(false), reactedToBeingFaulty(false), passive(
-				false), eventQueue(NULL), heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(
-				this), lastAction(CLEAR) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Heater::~Heater() {
-	QueueFactory::instance()->deleteMessageQueue(eventQueue);
-}
-
-ReturnValue_t Heater::set() {
-	passive = false;
-	//wait for clear before doing anything
-	if (internalState == STATE_WAIT) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	if (healthHelper.healthTable->isHealthy(getObjectId())) {
-		doAction(SET);
-		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		} else {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	} else {
-		if (healthHelper.healthTable->isFaulty(getObjectId())) {
-			if (!reactedToBeingFaulty) {
-				reactedToBeingFaulty = true;
-				doAction(CLEAR);
-			}
-		}
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-void Heater::clear(bool passive) {
-	this->passive = passive;
-	//Force switching off
-	if (internalState == STATE_WAIT) {
-		internalState = STATE_ON;
-	}
-	if (healthHelper.healthTable->isHealthy(getObjectId())) {
-		doAction(CLEAR);
-	} else if (healthHelper.healthTable->isFaulty(getObjectId())) {
-		if (!reactedToBeingFaulty) {
-			reactedToBeingFaulty = true;
-			doAction(CLEAR);
-		}
-	}
-}
-
-void Heater::doAction(Action action) {
-	//only act if we are not in the right state or in a transition
-	if (action == SET) {
-		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
-				|| (internalState == STATE_EXTERNAL_CONTROL)) {
-			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-			internalState = STATE_WAIT_FOR_SWITCHES_ON;
-			powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
-			powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
-		}
-	} else { //clear
-		if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
-				|| (internalState == STATE_EXTERNAL_CONTROL)) {
-			internalState = STATE_WAIT_FOR_SWITCHES_OFF;
-			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-			powerSwitcher->sendSwitchCommand(switch0,
-					PowerSwitchIF::SWITCH_OFF);
-			powerSwitcher->sendSwitchCommand(switch1,
-					PowerSwitchIF::SWITCH_OFF);
-		}
-	}
-}
-
-void Heater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
-	this->powerSwitcher = powerSwitch;
-}
-
-ReturnValue_t Heater::performOperation(uint8_t opCode) {
-	handleQueue();
-	handleEventQueue();
-
-	if (!healthHelper.healthTable->isFaulty(getObjectId())) {
-		reactedToBeingFaulty = false;
-	}
-
-	switch (internalState) {
-	case STATE_ON:
-		if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
-				|| (powerSwitcher->getSwitchState(switch1)
-						== PowerSwitchIF::SWITCH_OFF)) {
-			//switch went off on its own
-			//trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
-			//do not trigger FD events when under external control
-			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
-				triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
-			} else {
-				internalState = STATE_EXTERNAL_CONTROL;
-			}
-		}
-		break;
-	case STATE_OFF:
-		//check if heater is on, ie both switches are on
-		//if so, just command it to off, to resolve the situation or force a switch stayed on event
-		//But, only do anything if not already faulty (state off is the stable point for being faulty)
-		if ((!healthHelper.healthTable->isFaulty(getObjectId()))
-				&& (powerSwitcher->getSwitchState(switch0)
-						== PowerSwitchIF::SWITCH_ON)
-				&& (powerSwitcher->getSwitchState(switch1)
-						== PowerSwitchIF::SWITCH_ON)) {
-			//do not trigger FD events when under external control
-			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
-				internalState = STATE_WAIT_FOR_SWITCHES_OFF;
-				switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-				powerSwitcher->sendSwitchCommand(switch0,
-						PowerSwitchIF::SWITCH_OFF);
-				powerSwitcher->sendSwitchCommand(switch1,
-						PowerSwitchIF::SWITCH_OFF);
-			} else {
-				internalState = STATE_EXTERNAL_CONTROL;
-			}
-		}
-		break;
-	case STATE_PASSIVE:
-		break;
-	case STATE_WAIT_FOR_SWITCHES_ON:
-		if (switchCountdown.hasTimedOut()) {
-			if ((powerSwitcher->getSwitchState(switch0)
-					== PowerSwitchIF::SWITCH_OFF)
-					|| (powerSwitcher->getSwitchState(switch1)
-							== PowerSwitchIF::SWITCH_OFF)) {
-				triggerEvent(HEATER_STAYED_OFF);
-				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
-			} else {
-				triggerEvent(HEATER_ON);
-				internalState = STATE_ON;
-			}
-		}
-		break;
-	case STATE_WAIT_FOR_SWITCHES_OFF:
-		if (switchCountdown.hasTimedOut()) {
-			//only check for both being on (ie heater still on)
-			if ((powerSwitcher->getSwitchState(switch0)
-					== PowerSwitchIF::SWITCH_ON)
-					&& (powerSwitcher->getSwitchState(switch1)
-							== PowerSwitchIF::SWITCH_ON)) {
-				if (healthHelper.healthTable->isFaulty(getObjectId())) {
-					if (passive) {
-						internalState = STATE_PASSIVE;
-					} else {
-						internalState = STATE_OFF; //just accept it
-					}
-					triggerEvent(HEATER_ON); //but throw an event to make it more visible
-					break;
-				}
-				triggerEvent(HEATER_STAYED_ON);
-				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
-			} else {
-				triggerEvent(HEATER_OFF);
-				if (passive) {
-					internalState = STATE_PASSIVE;
-				} else {
-					internalState = STATE_OFF;
-				}
-			}
-		}
-		break;
-	default:
-		break;
-	}
-
-	if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
-			&& (powerSwitcher->getSwitchState(switch1)
-					== PowerSwitchIF::SWITCH_ON)) {
-		if (wasOn) {
-			if (heaterOnCountdown.hasTimedOut()) {
-				//SHOULDDO this means if a heater fails in single mode, the timeout will start again
-				//I am not sure if this is a bug, but atm I have no idea how to fix this and think
-				//it will be ok. whatcouldpossiblygowrongâ„¢
-				if (!timedOut) {
-					triggerEvent(HEATER_TIMEOUT);
-					timedOut = true;
-				}
-			}
-		} else {
-			wasOn = true;
-			heaterOnCountdown.resetTimer();
-			timedOut = false;
-		}
-	} else {
-		wasOn = false;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Heater::setSwitch(uint8_t number, ReturnValue_t state,
-		uint32_t* uptimeOfSwitching) {
-	if (powerSwitcher == NULL) {
-		return;
-	}
-	if (powerSwitcher->getSwitchState(number) == state) {
-		*uptimeOfSwitching = INVALID_UPTIME;
-	} else {
-		if ((*uptimeOfSwitching == INVALID_UPTIME)) {
-			powerSwitcher->sendSwitchCommand(number, state);
-			Clock::getUptime(uptimeOfSwitching);
-		} else {
-			uint32_t currentUptime;
-			Clock::getUptime(&currentUptime);
-			if (currentUptime - *uptimeOfSwitching
-					> powerSwitcher->getSwitchDelayMs()) {
-				*uptimeOfSwitching = INVALID_UPTIME;
-				if (healthHelper.healthTable->isHealthy(getObjectId())) {
-					if (state == PowerSwitchIF::SWITCH_ON) {
-						triggerEvent(HEATER_STAYED_OFF);
-					} else {
-						triggerEvent(HEATER_STAYED_ON);
-					}
-				}
-				//SHOULDDO MiniOps during switch timeout leads to a faulty switch
-			}
-		}
-	}
-}
-
-MessageQueueId_t Heater::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t Heater::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-			objects::EVENT_MANAGER);
-	if (manager == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	result = manager->registerListener(eventQueue->getId());
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
-			DeviceHandlerFailureIsolation::powerConfirmationId);
-	if (pcdu == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	pcduQueueId = pcdu->getEventReceptionQueue();
-
-	result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
-			getObjectId());
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Heater::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		parameterHelper.handleParameterMessage(&command);
-	}
-}
-
-ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	if (domainId != DOMAIN_ID_BASE) {
-		return INVALID_DOMAIN_ID;
-	}
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set(heaterOnCountdown.timeout);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Heater::handleEventQueue() {
-	EventMessage event;
-	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
-			result == HasReturnvaluesIF::RETURN_OK;
-			result = eventQueue->receiveMessage(&event)) {
-		switch (event.getMessageId()) {
-		case EventMessage::EVENT_MESSAGE:
-			switch (event.getEvent()) {
-			case Fuse::FUSE_WENT_OFF:
-			case HEATER_STAYED_OFF:
-			case HEATER_STAYED_ON://Setting it faulty does not help, but we need to reach a stable state and can check for being faulty before throwing this event again.
-				if (healthHelper.healthTable->isCommandable(getObjectId())) {
-					healthHelper.setHealth(HasHealthIF::FAULTY);
-					internalState = STATE_FAULTY;
-				}
-				break;
-			case PowerSwitchIF::SWITCH_WENT_OFF:
-				internalState = STATE_WAIT;
-				event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
-				if (pcduQueueId != 0) {
-					eventQueue->sendMessage(pcduQueueId, &event);
-				} else {
-					healthHelper.setHealth(HasHealthIF::FAULTY);
-					internalState = STATE_FAULTY;
-				}
-				break;
-			default:
-				return;
-			}
-			break;
-		case EventMessage::YOUR_FAULT:
-			healthHelper.setHealth(HasHealthIF::FAULTY);
-			internalState = STATE_FAULTY;
-			break;
-		case EventMessage::MY_FAULT:
-			//do nothing, we are already in STATE_WAIT and wait for a clear()
-			break;
-		default:
-			return;
-		}
-	}
-}
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+#include "Heater.h"
+
+#include "../power/Fuse.h"
+#include "../ipc/QueueFactory.h"
+
+Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) :
+		HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
+				NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(
+				false), timedOut(false), reactedToBeingFaulty(false), passive(
+				false), eventQueue(NULL), heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(
+				this), lastAction(CLEAR) {
+	eventQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Heater::~Heater() {
+	QueueFactory::instance()->deleteMessageQueue(eventQueue);
+}
+
+ReturnValue_t Heater::set() {
+	passive = false;
+	//wait for clear before doing anything
+	if (internalState == STATE_WAIT) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	if (healthHelper.healthTable->isHealthy(getObjectId())) {
+		doAction(SET);
+		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		} else {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	} else {
+		if (healthHelper.healthTable->isFaulty(getObjectId())) {
+			if (!reactedToBeingFaulty) {
+				reactedToBeingFaulty = true;
+				doAction(CLEAR);
+			}
+		}
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void Heater::clear(bool passive) {
+	this->passive = passive;
+	//Force switching off
+	if (internalState == STATE_WAIT) {
+		internalState = STATE_ON;
+	}
+	if (healthHelper.healthTable->isHealthy(getObjectId())) {
+		doAction(CLEAR);
+	} else if (healthHelper.healthTable->isFaulty(getObjectId())) {
+		if (!reactedToBeingFaulty) {
+			reactedToBeingFaulty = true;
+			doAction(CLEAR);
+		}
+	}
+}
+
+void Heater::doAction(Action action) {
+	//only act if we are not in the right state or in a transition
+	if (action == SET) {
+		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
+				|| (internalState == STATE_EXTERNAL_CONTROL)) {
+			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+			internalState = STATE_WAIT_FOR_SWITCHES_ON;
+			powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
+			powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
+		}
+	} else { //clear
+		if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
+				|| (internalState == STATE_EXTERNAL_CONTROL)) {
+			internalState = STATE_WAIT_FOR_SWITCHES_OFF;
+			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+			powerSwitcher->sendSwitchCommand(switch0,
+					PowerSwitchIF::SWITCH_OFF);
+			powerSwitcher->sendSwitchCommand(switch1,
+					PowerSwitchIF::SWITCH_OFF);
+		}
+	}
+}
+
+void Heater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
+	this->powerSwitcher = powerSwitch;
+}
+
+ReturnValue_t Heater::performOperation(uint8_t opCode) {
+	handleQueue();
+	handleEventQueue();
+
+	if (!healthHelper.healthTable->isFaulty(getObjectId())) {
+		reactedToBeingFaulty = false;
+	}
+
+	switch (internalState) {
+	case STATE_ON:
+		if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
+				|| (powerSwitcher->getSwitchState(switch1)
+						== PowerSwitchIF::SWITCH_OFF)) {
+			//switch went off on its own
+			//trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
+			//do not trigger FD events when under external control
+			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
+				triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
+			} else {
+				internalState = STATE_EXTERNAL_CONTROL;
+			}
+		}
+		break;
+	case STATE_OFF:
+		//check if heater is on, ie both switches are on
+		//if so, just command it to off, to resolve the situation or force a switch stayed on event
+		//But, only do anything if not already faulty (state off is the stable point for being faulty)
+		if ((!healthHelper.healthTable->isFaulty(getObjectId()))
+				&& (powerSwitcher->getSwitchState(switch0)
+						== PowerSwitchIF::SWITCH_ON)
+				&& (powerSwitcher->getSwitchState(switch1)
+						== PowerSwitchIF::SWITCH_ON)) {
+			//do not trigger FD events when under external control
+			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
+				internalState = STATE_WAIT_FOR_SWITCHES_OFF;
+				switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+				powerSwitcher->sendSwitchCommand(switch0,
+						PowerSwitchIF::SWITCH_OFF);
+				powerSwitcher->sendSwitchCommand(switch1,
+						PowerSwitchIF::SWITCH_OFF);
+			} else {
+				internalState = STATE_EXTERNAL_CONTROL;
+			}
+		}
+		break;
+	case STATE_PASSIVE:
+		break;
+	case STATE_WAIT_FOR_SWITCHES_ON:
+		if (switchCountdown.hasTimedOut()) {
+			if ((powerSwitcher->getSwitchState(switch0)
+					== PowerSwitchIF::SWITCH_OFF)
+					|| (powerSwitcher->getSwitchState(switch1)
+							== PowerSwitchIF::SWITCH_OFF)) {
+				triggerEvent(HEATER_STAYED_OFF);
+				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
+			} else {
+				triggerEvent(HEATER_ON);
+				internalState = STATE_ON;
+			}
+		}
+		break;
+	case STATE_WAIT_FOR_SWITCHES_OFF:
+		if (switchCountdown.hasTimedOut()) {
+			//only check for both being on (ie heater still on)
+			if ((powerSwitcher->getSwitchState(switch0)
+					== PowerSwitchIF::SWITCH_ON)
+					&& (powerSwitcher->getSwitchState(switch1)
+							== PowerSwitchIF::SWITCH_ON)) {
+				if (healthHelper.healthTable->isFaulty(getObjectId())) {
+					if (passive) {
+						internalState = STATE_PASSIVE;
+					} else {
+						internalState = STATE_OFF; //just accept it
+					}
+					triggerEvent(HEATER_ON); //but throw an event to make it more visible
+					break;
+				}
+				triggerEvent(HEATER_STAYED_ON);
+				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
+			} else {
+				triggerEvent(HEATER_OFF);
+				if (passive) {
+					internalState = STATE_PASSIVE;
+				} else {
+					internalState = STATE_OFF;
+				}
+			}
+		}
+		break;
+	default:
+		break;
+	}
+
+	if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
+			&& (powerSwitcher->getSwitchState(switch1)
+					== PowerSwitchIF::SWITCH_ON)) {
+		if (wasOn) {
+			if (heaterOnCountdown.hasTimedOut()) {
+				//SHOULDDO this means if a heater fails in single mode, the timeout will start again
+				//I am not sure if this is a bug, but atm I have no idea how to fix this and think
+				//it will be ok. whatcouldpossiblygowrongâ„¢
+				if (!timedOut) {
+					triggerEvent(HEATER_TIMEOUT);
+					timedOut = true;
+				}
+			}
+		} else {
+			wasOn = true;
+			heaterOnCountdown.resetTimer();
+			timedOut = false;
+		}
+	} else {
+		wasOn = false;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Heater::setSwitch(uint8_t number, ReturnValue_t state,
+		uint32_t* uptimeOfSwitching) {
+	if (powerSwitcher == NULL) {
+		return;
+	}
+	if (powerSwitcher->getSwitchState(number) == state) {
+		*uptimeOfSwitching = INVALID_UPTIME;
+	} else {
+		if ((*uptimeOfSwitching == INVALID_UPTIME)) {
+			powerSwitcher->sendSwitchCommand(number, state);
+			Clock::getUptime(uptimeOfSwitching);
+		} else {
+			uint32_t currentUptime;
+			Clock::getUptime(&currentUptime);
+			if (currentUptime - *uptimeOfSwitching
+					> powerSwitcher->getSwitchDelayMs()) {
+				*uptimeOfSwitching = INVALID_UPTIME;
+				if (healthHelper.healthTable->isHealthy(getObjectId())) {
+					if (state == PowerSwitchIF::SWITCH_ON) {
+						triggerEvent(HEATER_STAYED_OFF);
+					} else {
+						triggerEvent(HEATER_STAYED_ON);
+					}
+				}
+				//SHOULDDO MiniOps during switch timeout leads to a faulty switch
+			}
+		}
+	}
+}
+
+MessageQueueId_t Heater::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t Heater::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+			objects::EVENT_MANAGER);
+	if (manager == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	result = manager->registerListener(eventQueue->getId());
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
+			DeviceHandlerFailureIsolation::powerConfirmationId);
+	if (pcdu == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	pcduQueueId = pcdu->getEventReceptionQueue();
+
+	result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
+			getObjectId());
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = healthHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Heater::handleQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		parameterHelper.handleParameterMessage(&command);
+	}
+}
+
+ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	if (domainId != DOMAIN_ID_BASE) {
+		return INVALID_DOMAIN_ID;
+	}
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set(heaterOnCountdown.timeout);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Heater::handleEventQueue() {
+	EventMessage event;
+	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
+			result == HasReturnvaluesIF::RETURN_OK;
+			result = eventQueue->receiveMessage(&event)) {
+		switch (event.getMessageId()) {
+		case EventMessage::EVENT_MESSAGE:
+			switch (event.getEvent()) {
+			case Fuse::FUSE_WENT_OFF:
+			case HEATER_STAYED_OFF:
+			case HEATER_STAYED_ON://Setting it faulty does not help, but we need to reach a stable state and can check for being faulty before throwing this event again.
+				if (healthHelper.healthTable->isCommandable(getObjectId())) {
+					healthHelper.setHealth(HasHealthIF::FAULTY);
+					internalState = STATE_FAULTY;
+				}
+				break;
+			case PowerSwitchIF::SWITCH_WENT_OFF:
+				internalState = STATE_WAIT;
+				event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
+				if (pcduQueueId != 0) {
+					eventQueue->sendMessage(pcduQueueId, &event);
+				} else {
+					healthHelper.setHealth(HasHealthIF::FAULTY);
+					internalState = STATE_FAULTY;
+				}
+				break;
+			default:
+				return;
+			}
+			break;
+		case EventMessage::YOUR_FAULT:
+			healthHelper.setHealth(HasHealthIF::FAULTY);
+			internalState = STATE_FAULTY;
+			break;
+		case EventMessage::MY_FAULT:
+			//do nothing, we are already in STATE_WAIT and wait for a clear()
+			break;
+		default:
+			return;
+		}
+	}
+}
diff --git a/thermal/Heater.h b/thermal/Heater.h
index 8121a7746..63fe20667 100644
--- a/thermal/Heater.h
+++ b/thermal/Heater.h
@@ -1,90 +1,90 @@
-#ifndef FRAMEWORK_THERMAL_HEATER_H_
-#define FRAMEWORK_THERMAL_HEATER_H_
-
-#include "../devicehandlers/HealthDevice.h"
-#include "../parameters/ParameterHelper.h"
-#include "../power/PowerSwitchIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../timemanager/Countdown.h"
-#include <stdint.h>
-//class RedundantHeater;
-
-class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
-	friend class RedundantHeater;
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
-	static const Event HEATER_ON = MAKE_EVENT(0, SEVERITY::INFO);
-	static const Event HEATER_OFF = MAKE_EVENT(1, SEVERITY::INFO);
-	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, SEVERITY::LOW);
-
-	Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
-	virtual ~Heater();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	ReturnValue_t initialize();
-
-	ReturnValue_t set();
-	void clear(bool passive);
-
-	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
-
-	MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-protected:
-	static const uint32_t INVALID_UPTIME = 0;
-
-	enum InternalState {
-		STATE_ON,
-		STATE_OFF,
-		STATE_PASSIVE,
-		STATE_WAIT_FOR_SWITCHES_ON,
-		STATE_WAIT_FOR_SWITCHES_OFF,
-		STATE_WAIT_FOR_FDIR, //used to avoid doing anything until fdir decided what to do
-		STATE_FAULTY,
-		STATE_WAIT, //used when waiting for system to recover from miniops
-		STATE_EXTERNAL_CONTROL //entered when under external control and a fdir reaction would be triggered. This is useful when leaving external control into an unknown state
-							   //if no fdir reaction is triggered under external control the state is still ok and no need for any special treatment is needed
-	} internalState;
-
-	PowerSwitchIF *powerSwitcher;
-	MessageQueueId_t pcduQueueId;
-
-	uint8_t switch0;
-	uint8_t switch1;
-
-	bool wasOn;
-
-	bool timedOut;
-
-	bool reactedToBeingFaulty;
-
-	bool passive;
-
-	MessageQueueIF* eventQueue;
-	Countdown heaterOnCountdown;
-	Countdown switchCountdown;
-	ParameterHelper parameterHelper;
-
-	enum Action {
-		SET, CLEAR
-	} lastAction;
-
-	void doAction(Action action);
-
-	void setSwitch(uint8_t number, ReturnValue_t state,
-			uint32_t *upTimeOfSwitching);
-
-	void handleQueue();
-
-	void handleEventQueue();
-};
-
-#endif /* FRAMEWORK_THERMAL_HEATER_H_ */
+#ifndef FRAMEWORK_THERMAL_HEATER_H_
+#define FRAMEWORK_THERMAL_HEATER_H_
+
+#include "../devicehandlers/HealthDevice.h"
+#include "../parameters/ParameterHelper.h"
+#include "../power/PowerSwitchIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Countdown.h"
+#include <stdint.h>
+//class RedundantHeater;
+
+class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
+	friend class RedundantHeater;
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
+	static const Event HEATER_ON = MAKE_EVENT(0, SEVERITY::INFO);
+	static const Event HEATER_OFF = MAKE_EVENT(1, SEVERITY::INFO);
+	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, SEVERITY::LOW);
+
+	Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
+	virtual ~Heater();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	ReturnValue_t initialize();
+
+	ReturnValue_t set();
+	void clear(bool passive);
+
+	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
+
+	MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+protected:
+	static const uint32_t INVALID_UPTIME = 0;
+
+	enum InternalState {
+		STATE_ON,
+		STATE_OFF,
+		STATE_PASSIVE,
+		STATE_WAIT_FOR_SWITCHES_ON,
+		STATE_WAIT_FOR_SWITCHES_OFF,
+		STATE_WAIT_FOR_FDIR, //used to avoid doing anything until fdir decided what to do
+		STATE_FAULTY,
+		STATE_WAIT, //used when waiting for system to recover from miniops
+		STATE_EXTERNAL_CONTROL //entered when under external control and a fdir reaction would be triggered. This is useful when leaving external control into an unknown state
+							   //if no fdir reaction is triggered under external control the state is still ok and no need for any special treatment is needed
+	} internalState;
+
+	PowerSwitchIF *powerSwitcher;
+	MessageQueueId_t pcduQueueId;
+
+	uint8_t switch0;
+	uint8_t switch1;
+
+	bool wasOn;
+
+	bool timedOut;
+
+	bool reactedToBeingFaulty;
+
+	bool passive;
+
+	MessageQueueIF* eventQueue;
+	Countdown heaterOnCountdown;
+	Countdown switchCountdown;
+	ParameterHelper parameterHelper;
+
+	enum Action {
+		SET, CLEAR
+	} lastAction;
+
+	void doAction(Action action);
+
+	void setSwitch(uint8_t number, ReturnValue_t state,
+			uint32_t *upTimeOfSwitching);
+
+	void handleQueue();
+
+	void handleEventQueue();
+};
+
+#endif /* FRAMEWORK_THERMAL_HEATER_H_ */
diff --git a/thermal/RedundantHeater.h b/thermal/RedundantHeater.h
index 4a82de078..765375420 100644
--- a/thermal/RedundantHeater.h
+++ b/thermal/RedundantHeater.h
@@ -1,50 +1,50 @@
-#ifndef REDUNDANTHEATER_H_
-#define REDUNDANTHEATER_H_
-
-#include "../thermal/Heater.h"
-
-class RedundantHeater {
-public:
-
-	struct Parameters {
-		Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
-				uint8_t switch0Heater0, uint8_t switch1Heater0,
-				uint8_t switch0Heater1, uint8_t switch1Heater1) :
-				objectIdHeater0(objectIdHeater0), objectIdHeater1(objectIdHeater1),
-				switch0Heater0(switch0Heater0),switch1Heater0(switch1Heater0),
-				switch0Heater1(switch0Heater1), switch1Heater1(switch1Heater1) {
-		}
-
-		Parameters() :
-				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0),
-				switch1Heater0(0), switch0Heater1(0), switch1Heater1(0) {
-		}
-
-		uint32_t objectIdHeater0;
-		uint32_t objectIdHeater1;
-		uint8_t switch0Heater0;
-		uint8_t switch1Heater0;
-		uint8_t switch0Heater1;
-		uint8_t switch1Heater1;
-	};
-
-	RedundantHeater(Parameters parameters);
-	virtual ~RedundantHeater();
-
-	void performOperation(uint8_t opCode);
-
-	void triggerHeaterEvent(Event event);
-
-	void set(bool on, bool both, bool passive = false);
-
-	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
-
-protected:
-
-	Heater heater0;
-	Heater heater1;
-
-};
-
-#endif /* REDUNDANTHEATER_H_ */
-
+#ifndef REDUNDANTHEATER_H_
+#define REDUNDANTHEATER_H_
+
+#include "../thermal/Heater.h"
+
+class RedundantHeater {
+public:
+
+	struct Parameters {
+		Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
+				uint8_t switch0Heater0, uint8_t switch1Heater0,
+				uint8_t switch0Heater1, uint8_t switch1Heater1) :
+				objectIdHeater0(objectIdHeater0), objectIdHeater1(objectIdHeater1),
+				switch0Heater0(switch0Heater0),switch1Heater0(switch1Heater0),
+				switch0Heater1(switch0Heater1), switch1Heater1(switch1Heater1) {
+		}
+
+		Parameters() :
+				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0),
+				switch1Heater0(0), switch0Heater1(0), switch1Heater1(0) {
+		}
+
+		uint32_t objectIdHeater0;
+		uint32_t objectIdHeater1;
+		uint8_t switch0Heater0;
+		uint8_t switch1Heater0;
+		uint8_t switch0Heater1;
+		uint8_t switch1Heater1;
+	};
+
+	RedundantHeater(Parameters parameters);
+	virtual ~RedundantHeater();
+
+	void performOperation(uint8_t opCode);
+
+	void triggerHeaterEvent(Event event);
+
+	void set(bool on, bool both, bool passive = false);
+
+	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
+
+protected:
+
+	Heater heater0;
+	Heater heater1;
+
+};
+
+#endif /* REDUNDANTHEATER_H_ */
+
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index cf2dffd48..9b4f0e605 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -1,222 +1,222 @@
-#ifndef TEMPERATURESENSOR_H_
-#define TEMPERATURESENSOR_H_
-
-#include "../thermal/AbstractTemperatureSensor.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../monitoring/LimitMonitor.h"
-
-/**
- * @brief 	This building block handles non-linear value conversion and
- * 			range checks for analog temperature sensors.
- * @details This class can be used to perform all necessary tasks for temperature sensors.
- *          A sensor can be instantiated by calling the constructor.
- *          The temperature is calculated from an input value with
- *			the calculateOutputTemperature() function. Range checking and
- *			limit monitoring is performed automatically.
- *			The inputType specifies the type of the raw input while the
- *			limitType specifies the type of the upper and lower limit to check against.
- * @ingroup thermal
- */
-
-template<typename inputType, typename limitType = inputType>
-class TemperatureSensor: public AbstractTemperatureSensor {
-public:
-	/**
-	 * This structure contains parameters required for range checking
-	 * and the conversion from the input value to the output temperature.
-	 * a, b and c can be any parameters required to calculate the output
-	 * temperature from the input value, depending on the formula used.
-	 *
-	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
-	 *
-	 * The lower and upper limits can be specified in any type, for example float for C values
-	 * or any other type for raw values.
-	 */
-	struct Parameters {
-		float a;
-		float b;
-		float c;
-		limitType lowerLimit;
-		limitType upperLimit;
-		float maxGradient;
-	};
-
-	/**
-	 * Forward declaration for explicit instantiation of used parameters.
-	 */
-	struct UsedParameters {
-		UsedParameters(Parameters parameters) :
-			a(parameters.a), b(parameters.b), c(parameters.c),
-			gradient(parameters.maxGradient) {}
-		float a;
-		float b;
-		float c;
-		float gradient;
-	};
-
-	/**
-	 * Instantiate Temperature Sensor Object.
-	 * @param setObjectid objectId of the sensor object
-	 * @param inputValue Input value which is converted to a temperature
-	 * @param poolVariable Pool Variable to store the temperature value
-	 * @param vectorIndex Vector Index for the sensor monitor
-	 * @param parameters Calculation parameters, temperature limits, gradient limit
-	 * @param datapoolId Datapool ID of the output temperature
-	 * @param outputSet Output dataset for the output temperature to fetch it with read()
-	 * @param thermalModule respective thermal module, if it has one
-	 */
-	TemperatureSensor(object_id_t setObjectid,
-			inputType *inputValue, PoolVariableIF *poolVariable,
-			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
-			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
-			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
-			inputValue(inputValue), poolVariable(poolVariable),
-			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
-			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
-				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
-				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
-				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
-			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
-	}
-
-
-protected:
-	/**
-	 * This formula is used to calculate the temperature from an input value
-	 * with an arbitrary type.
-	 * A default implementation is provided but can be replaced depending
-	 * on the required calculation.
-	 * @param inputTemperature
-	 * @return
-	 */
-	virtual float calculateOutputTemperature(inputType inputValue) {
-		return parameters.a * inputValue * inputValue
-				+ parameters.b * inputValue + parameters.c;
-	}
-
-
-private:
-	void setInvalid() {
-		outputTemperature = INVALID_TEMPERATURE;
-		outputTemperature.setValid(false);
-		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
-		sensorMonitor.setToInvalid();
-	}
-protected:
-	static const int32_t INVALID_UPTIME = 0;
-
-	UsedParameters parameters;
-
-	inputType * inputValue;
-
-	PoolVariableIF *poolVariable;
-
-	gp_float_t outputTemperature;
-
-	LimitMonitor<limitType> sensorMonitor;
-
-	float oldTemperature;
-	timeval uptimeOfOldTemperature;
-
-	void doChildOperation() {
-		if (!poolVariable->isValid()
-				|| !healthHelper.healthTable->isHealthy(getObjectId())) {
-			setInvalid();
-			return;
-		}
-
-		outputTemperature = calculateOutputTemperature(*inputValue);
-		outputTemperature.setValid(PoolVariableIF::VALID);
-
-		timeval uptime;
-		Clock::getUptime(&uptime);
-
-		if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
-			//In theory, we could use an AbsValueMonitor to monitor the gradient.
-			//But this would require storing the maxGradient in DP and quite some overhead.
-			//The concept of delta limits is a bit strange anyway.
-			float deltaTime;
-			float deltaTemp;
-
-			deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.)
-					- (uptimeOfOldTemperature.tv_sec
-							+ uptimeOfOldTemperature.tv_usec / 1000000.);
-			deltaTemp = oldTemperature - outputTemperature;
-			if (deltaTemp < 0) {
-				deltaTemp = -deltaTemp;
-			}
-			if (parameters.gradient < deltaTemp / deltaTime) {
-				triggerEvent(TEMP_SENSOR_GRADIENT);
-				//Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
-			}
-		}
-
-		//Check is done against raw limits. SHOULDDO: Why? Using �C would be more easy to handle.
-		sensorMonitor.doCheck(outputTemperature.value);
-
-		if (sensorMonitor.isOutOfLimits()) {
-			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
-			outputTemperature.setValid(PoolVariableIF::INVALID);
-			outputTemperature = INVALID_TEMPERATURE;
-		} else {
-			oldTemperature = outputTemperature;
-			uptimeOfOldTemperature = uptime;
-		}
-	}
-
-public:
-	float getTemperature() {
-		return outputTemperature;
-	}
-
-	bool isValid() {
-		return outputTemperature.isValid();
-	}
-
-	static const uint16_t ADDRESS_A = 0;
-	static const uint16_t ADDRESS_B = 1;
-	static const uint16_t ADDRESS_C = 2;
-	static const uint16_t ADDRESS_GRADIENT = 3;
-
-	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
-
-	static const uint8_t DOMAIN_ID_SENSOR = 1;
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
-				parameterWrapper, newValues, startAtIndex);
-		if (result != INVALID_DOMAIN_ID) {
-			return result;
-		}
-		if (domainId != this->DOMAIN_ID_BASE) {
-			return INVALID_DOMAIN_ID;
-		}
-		switch (parameterId) {
-		case ADDRESS_A:
-			parameterWrapper->set(parameters.a);
-			break;
-		case ADDRESS_B:
-			parameterWrapper->set(parameters.b);
-			break;
-		case ADDRESS_C:
-			parameterWrapper->set(parameters.c);
-			break;
-		case ADDRESS_GRADIENT:
-			parameterWrapper->set(parameters.gradient);
-			break;
-		default:
-			return INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	virtual void resetOldState() {
-		sensorMonitor.setToUnchecked();
-	}
-
-};
-
-#endif /* TEMPERATURESENSOR_H_ */
+#ifndef TEMPERATURESENSOR_H_
+#define TEMPERATURESENSOR_H_
+
+#include "../thermal/AbstractTemperatureSensor.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../monitoring/LimitMonitor.h"
+
+/**
+ * @brief 	This building block handles non-linear value conversion and
+ * 			range checks for analog temperature sensors.
+ * @details This class can be used to perform all necessary tasks for temperature sensors.
+ *          A sensor can be instantiated by calling the constructor.
+ *          The temperature is calculated from an input value with
+ *			the calculateOutputTemperature() function. Range checking and
+ *			limit monitoring is performed automatically.
+ *			The inputType specifies the type of the raw input while the
+ *			limitType specifies the type of the upper and lower limit to check against.
+ * @ingroup thermal
+ */
+
+template<typename inputType, typename limitType = inputType>
+class TemperatureSensor: public AbstractTemperatureSensor {
+public:
+	/**
+	 * This structure contains parameters required for range checking
+	 * and the conversion from the input value to the output temperature.
+	 * a, b and c can be any parameters required to calculate the output
+	 * temperature from the input value, depending on the formula used.
+	 *
+	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
+	 *
+	 * The lower and upper limits can be specified in any type, for example float for C values
+	 * or any other type for raw values.
+	 */
+	struct Parameters {
+		float a;
+		float b;
+		float c;
+		limitType lowerLimit;
+		limitType upperLimit;
+		float maxGradient;
+	};
+
+	/**
+	 * Forward declaration for explicit instantiation of used parameters.
+	 */
+	struct UsedParameters {
+		UsedParameters(Parameters parameters) :
+			a(parameters.a), b(parameters.b), c(parameters.c),
+			gradient(parameters.maxGradient) {}
+		float a;
+		float b;
+		float c;
+		float gradient;
+	};
+
+	/**
+	 * Instantiate Temperature Sensor Object.
+	 * @param setObjectid objectId of the sensor object
+	 * @param inputValue Input value which is converted to a temperature
+	 * @param poolVariable Pool Variable to store the temperature value
+	 * @param vectorIndex Vector Index for the sensor monitor
+	 * @param parameters Calculation parameters, temperature limits, gradient limit
+	 * @param datapoolId Datapool ID of the output temperature
+	 * @param outputSet Output dataset for the output temperature to fetch it with read()
+	 * @param thermalModule respective thermal module, if it has one
+	 */
+	TemperatureSensor(object_id_t setObjectid,
+			inputType *inputValue, PoolVariableIF *poolVariable,
+			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
+			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
+			inputValue(inputValue), poolVariable(poolVariable),
+			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
+			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
+				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
+				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
+			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
+	}
+
+
+protected:
+	/**
+	 * This formula is used to calculate the temperature from an input value
+	 * with an arbitrary type.
+	 * A default implementation is provided but can be replaced depending
+	 * on the required calculation.
+	 * @param inputTemperature
+	 * @return
+	 */
+	virtual float calculateOutputTemperature(inputType inputValue) {
+		return parameters.a * inputValue * inputValue
+				+ parameters.b * inputValue + parameters.c;
+	}
+
+
+private:
+	void setInvalid() {
+		outputTemperature = INVALID_TEMPERATURE;
+		outputTemperature.setValid(false);
+		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
+		sensorMonitor.setToInvalid();
+	}
+protected:
+	static const int32_t INVALID_UPTIME = 0;
+
+	UsedParameters parameters;
+
+	inputType * inputValue;
+
+	PoolVariableIF *poolVariable;
+
+	gp_float_t outputTemperature;
+
+	LimitMonitor<limitType> sensorMonitor;
+
+	float oldTemperature;
+	timeval uptimeOfOldTemperature;
+
+	void doChildOperation() {
+		if (!poolVariable->isValid()
+				|| !healthHelper.healthTable->isHealthy(getObjectId())) {
+			setInvalid();
+			return;
+		}
+
+		outputTemperature = calculateOutputTemperature(*inputValue);
+		outputTemperature.setValid(PoolVariableIF::VALID);
+
+		timeval uptime;
+		Clock::getUptime(&uptime);
+
+		if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
+			//In theory, we could use an AbsValueMonitor to monitor the gradient.
+			//But this would require storing the maxGradient in DP and quite some overhead.
+			//The concept of delta limits is a bit strange anyway.
+			float deltaTime;
+			float deltaTemp;
+
+			deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.)
+					- (uptimeOfOldTemperature.tv_sec
+							+ uptimeOfOldTemperature.tv_usec / 1000000.);
+			deltaTemp = oldTemperature - outputTemperature;
+			if (deltaTemp < 0) {
+				deltaTemp = -deltaTemp;
+			}
+			if (parameters.gradient < deltaTemp / deltaTime) {
+				triggerEvent(TEMP_SENSOR_GRADIENT);
+				//Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
+			}
+		}
+
+		//Check is done against raw limits. SHOULDDO: Why? Using �C would be more easy to handle.
+		sensorMonitor.doCheck(outputTemperature.value);
+
+		if (sensorMonitor.isOutOfLimits()) {
+			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
+			outputTemperature.setValid(PoolVariableIF::INVALID);
+			outputTemperature = INVALID_TEMPERATURE;
+		} else {
+			oldTemperature = outputTemperature;
+			uptimeOfOldTemperature = uptime;
+		}
+	}
+
+public:
+	float getTemperature() {
+		return outputTemperature;
+	}
+
+	bool isValid() {
+		return outputTemperature.isValid();
+	}
+
+	static const uint16_t ADDRESS_A = 0;
+	static const uint16_t ADDRESS_B = 1;
+	static const uint16_t ADDRESS_C = 2;
+	static const uint16_t ADDRESS_GRADIENT = 3;
+
+	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
+
+	static const uint8_t DOMAIN_ID_SENSOR = 1;
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
+				parameterWrapper, newValues, startAtIndex);
+		if (result != INVALID_DOMAIN_ID) {
+			return result;
+		}
+		if (domainId != this->DOMAIN_ID_BASE) {
+			return INVALID_DOMAIN_ID;
+		}
+		switch (parameterId) {
+		case ADDRESS_A:
+			parameterWrapper->set(parameters.a);
+			break;
+		case ADDRESS_B:
+			parameterWrapper->set(parameters.b);
+			break;
+		case ADDRESS_C:
+			parameterWrapper->set(parameters.c);
+			break;
+		case ADDRESS_GRADIENT:
+			parameterWrapper->set(parameters.gradient);
+			break;
+		default:
+			return INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	virtual void resetOldState() {
+		sensorMonitor.setToUnchecked();
+	}
+
+};
+
+#endif /* TEMPERATURESENSOR_H_ */
diff --git a/thermal/ThermalComponentIF.h b/thermal/ThermalComponentIF.h
index f5f49ba1a..522d4e443 100644
--- a/thermal/ThermalComponentIF.h
+++ b/thermal/ThermalComponentIF.h
@@ -1,114 +1,114 @@
-#ifndef THERMALCOMPONENTIF_H_
-#define THERMALCOMPONENTIF_H_
-
-#include "../events/Event.h"
-#include "../parameters/HasParametersIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../objectmanager/SystemObjectIF.h"
-
-class ThermalComponentIF : public HasParametersIF {
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_1;
-	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, SEVERITY::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
-	static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t ABOVE_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF1);
-	static const ReturnValue_t BELOW_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF2);
-
-	enum State {
-		OUT_OF_RANGE_LOW = -2,
-		NON_OPERATIONAL_LOW = -1,
-		OPERATIONAL = 0,
-		NON_OPERATIONAL_HIGH = 1,
-		OUT_OF_RANGE_HIGH = 2,
-		OUT_OF_RANGE_LOW_IGNORED = OUT_OF_RANGE_LOW - 10,
-		NON_OPERATIONAL_LOW_IGNORED = NON_OPERATIONAL_LOW - 10,
-		OPERATIONAL_IGNORED = OPERATIONAL + 10,
-		NON_OPERATIONAL_HIGH_IGNORED = NON_OPERATIONAL_HIGH + 10,
-		OUT_OF_RANGE_HIGH_IGNORED = OUT_OF_RANGE_HIGH + 10,
-		UNKNOWN = 20
-	};
-
-	enum StateRequest {
-		STATE_REQUEST_HEATING = 4,
-		STATE_REQUEST_IGNORE = 3,
-		STATE_REQUEST_OPERATIONAL = 1,
-		STATE_REQUEST_NON_OPERATIONAL = 0
-	};
-
-	/**
-	 * The elements are ordered by priority, lowest have highest priority
-	 */
-	enum Priority {
-		SAFE = 0,             //!< SAFE
-		IDLE,                 //!< IDLE
-		PAYLOAD,              //!< PAYLOAD
-		NUMBER_OF_PRIORITIES          //!< MAX_PRIORITY
-	};
-
-	/**
-	 * The elements are ordered by priority, lowest have highest priority
-	 */
-	enum HeaterRequest {
-		HEATER_REQUEST_EMERGENCY_OFF = 0,          //!< REQUEST_EMERGENCY_OFF
-		HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
-		HEATER_REQUEST_OFF,          //!< REQUEST_OFF
-		HEATER_REQUEST_ON,           //!< REQUEST_ON
-		HEATER_DONT_CARE             //!< DONT_CARE
-	};
-
-	virtual ~ThermalComponentIF() {
-
-	}
-
-	virtual HeaterRequest performOperation(uint8_t opCode) = 0;
-
-	virtual object_id_t getObjectId() = 0;
-
-	virtual uint8_t getDomainId() const = 0;
-
-	virtual void markStateIgnored() = 0;
-
-	virtual float getLowerOpLimit() = 0;
-
-	virtual ReturnValue_t setTargetState(int8_t state) = 0;
-
-	virtual void setOutputInvalid() = 0;
-
-	static bool isOperational(int8_t state) {
-		return ((state == OPERATIONAL) || (state == OPERATIONAL_IGNORED));
-	}
-
-	static bool isOutOfRange(State state) {
-		return ((state == OUT_OF_RANGE_HIGH)
-				|| (state == OUT_OF_RANGE_HIGH_IGNORED)
-				|| (state == OUT_OF_RANGE_LOW)
-				|| (state == OUT_OF_RANGE_LOW_IGNORED) || (state == UNKNOWN));
-	}
-
-	static bool isNonOperational(State state) {
-		return !isOutOfRange(state);
-	}
-
-	static bool isIgnoredState(State state) {
-		switch (state) {
-		case OUT_OF_RANGE_LOW_IGNORED:
-		case OUT_OF_RANGE_HIGH_IGNORED:
-		case NON_OPERATIONAL_LOW_IGNORED:
-		case NON_OPERATIONAL_HIGH_IGNORED:
-		case OPERATIONAL_IGNORED:
-		case UNKNOWN:
-			return true;
-		default:
-			return false;
-		}
-	}
-};
-
-#endif /* THERMALCOMPONENTIF_H_ */
+#ifndef THERMALCOMPONENTIF_H_
+#define THERMALCOMPONENTIF_H_
+
+#include "../events/Event.h"
+#include "../parameters/HasParametersIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+
+class ThermalComponentIF : public HasParametersIF {
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_1;
+	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, SEVERITY::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
+	static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t ABOVE_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF1);
+	static const ReturnValue_t BELOW_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF2);
+
+	enum State {
+		OUT_OF_RANGE_LOW = -2,
+		NON_OPERATIONAL_LOW = -1,
+		OPERATIONAL = 0,
+		NON_OPERATIONAL_HIGH = 1,
+		OUT_OF_RANGE_HIGH = 2,
+		OUT_OF_RANGE_LOW_IGNORED = OUT_OF_RANGE_LOW - 10,
+		NON_OPERATIONAL_LOW_IGNORED = NON_OPERATIONAL_LOW - 10,
+		OPERATIONAL_IGNORED = OPERATIONAL + 10,
+		NON_OPERATIONAL_HIGH_IGNORED = NON_OPERATIONAL_HIGH + 10,
+		OUT_OF_RANGE_HIGH_IGNORED = OUT_OF_RANGE_HIGH + 10,
+		UNKNOWN = 20
+	};
+
+	enum StateRequest {
+		STATE_REQUEST_HEATING = 4,
+		STATE_REQUEST_IGNORE = 3,
+		STATE_REQUEST_OPERATIONAL = 1,
+		STATE_REQUEST_NON_OPERATIONAL = 0
+	};
+
+	/**
+	 * The elements are ordered by priority, lowest have highest priority
+	 */
+	enum Priority {
+		SAFE = 0,             //!< SAFE
+		IDLE,                 //!< IDLE
+		PAYLOAD,              //!< PAYLOAD
+		NUMBER_OF_PRIORITIES          //!< MAX_PRIORITY
+	};
+
+	/**
+	 * The elements are ordered by priority, lowest have highest priority
+	 */
+	enum HeaterRequest {
+		HEATER_REQUEST_EMERGENCY_OFF = 0,          //!< REQUEST_EMERGENCY_OFF
+		HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
+		HEATER_REQUEST_OFF,          //!< REQUEST_OFF
+		HEATER_REQUEST_ON,           //!< REQUEST_ON
+		HEATER_DONT_CARE             //!< DONT_CARE
+	};
+
+	virtual ~ThermalComponentIF() {
+
+	}
+
+	virtual HeaterRequest performOperation(uint8_t opCode) = 0;
+
+	virtual object_id_t getObjectId() = 0;
+
+	virtual uint8_t getDomainId() const = 0;
+
+	virtual void markStateIgnored() = 0;
+
+	virtual float getLowerOpLimit() = 0;
+
+	virtual ReturnValue_t setTargetState(int8_t state) = 0;
+
+	virtual void setOutputInvalid() = 0;
+
+	static bool isOperational(int8_t state) {
+		return ((state == OPERATIONAL) || (state == OPERATIONAL_IGNORED));
+	}
+
+	static bool isOutOfRange(State state) {
+		return ((state == OUT_OF_RANGE_HIGH)
+				|| (state == OUT_OF_RANGE_HIGH_IGNORED)
+				|| (state == OUT_OF_RANGE_LOW)
+				|| (state == OUT_OF_RANGE_LOW_IGNORED) || (state == UNKNOWN));
+	}
+
+	static bool isNonOperational(State state) {
+		return !isOutOfRange(state);
+	}
+
+	static bool isIgnoredState(State state) {
+		switch (state) {
+		case OUT_OF_RANGE_LOW_IGNORED:
+		case OUT_OF_RANGE_HIGH_IGNORED:
+		case NON_OPERATIONAL_LOW_IGNORED:
+		case NON_OPERATIONAL_HIGH_IGNORED:
+		case OPERATIONAL_IGNORED:
+		case UNKNOWN:
+			return true;
+		default:
+			return false;
+		}
+	}
+};
+
+#endif /* THERMALCOMPONENTIF_H_ */
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index 7ee6b96b2..fbd6939e7 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -1,288 +1,288 @@
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringMessageContent.h"
-#include "ThermalModule.h"
-
-#include "AbstractTemperatureSensor.h"
-
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
-		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
-		GlobDataSet *dataSet, Parameters parameters,
-		RedundantHeater::Parameters heaterParameters) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters(parameters), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
-				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
-				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
-	heater = new RedundantHeater(heaterParameters);
-}
-
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters( { 0, 0 }), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
-				NULL), currentState(PoolVariableIF::INVALID, dataSet,
-				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
-				dataSet, PoolVariableIF::VAR_READ) {
-}
-
-ThermalModule::~ThermalModule() {
-	delete heater;
-}
-
-void ThermalModule::performOperation(uint8_t opCode) {
-	if (heater != NULL) {
-		heater->performOperation(0);
-	}
-}
-
-void ThermalModule::performMode(Strategy strategy) {
-	calculateTemperature();
-
-	bool safeOnly = (strategy == ACTIVE_SURVIVAL);
-	ThermalComponentIF::HeaterRequest componentHeaterRequest =
-			letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
-
-	if (heater == NULL) {
-		informComponentsAboutHeaterState(false, NONE);
-		return;
-	}
-
-	bool heating = calculateModuleHeaterRequestAndSetModuleStatus(strategy);
-
-	if (componentHeaterRequest != ThermalComponentIF::HEATER_DONT_CARE) {
-		//Components overwrite the module request.
-		heating = ((componentHeaterRequest
-				== ThermalComponentIF::HEATER_REQUEST_ON)
-				|| (componentHeaterRequest
-						== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
-	}
-
-	bool dual = (strategy == ACTIVE_DUAL);
-
-	if (strategy == PASSIVE) {
-		informComponentsAboutHeaterState(false, NONE);
-		if (oldStrategy != PASSIVE) {
-			heater->set(false, false, true);
-		}
-	} else {
-		if (safeOnly) {
-			informComponentsAboutHeaterState(heating, SAFE);
-		} else {
-			informComponentsAboutHeaterState(heating, ALL);
-		}
-		heater->set(heating, dual);
-	}
-	oldStrategy = strategy;
-}
-
-float ThermalModule::getTemperature() {
-	return moduleTemperature;
-}
-
-void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
-	sensors.push_back(sensor);
-}
-
-void ThermalModule::registerComponent(ThermalComponentIF* component,
-		ThermalComponentIF::Priority priority) {
-	components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
-}
-
-void ThermalModule::calculateTemperature() {
-	uint32_t numberOfValidSensors = 0;
-	moduleTemperature = 0;
-	std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
-	for (; iter != sensors.end(); iter++) {
-		if ((*iter)->isValid()) {
-			moduleTemperature = moduleTemperature + (*iter)->getTemperature();
-			numberOfValidSensors++;
-		}
-	}
-	if (numberOfValidSensors != 0) {
-		moduleTemperature = moduleTemperature / numberOfValidSensors;
-		moduleTemperature.setValid(PoolVariableIF::VALID);
-	} else {
-		moduleTemperature = INVALID_TEMPERATURE;
-		moduleTemperature.setValid(PoolVariableIF::INVALID);
-	}
-}
-
-ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		if (iter->component->getObjectId() == objectId) {
-			return iter->component;
-		}
-	}
-	return NULL;
-}
-
-ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
-		bool safeOnly) {
-	ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
-
-	survivalTargetTemp = -999;
-	targetTemp = -999;
-
-	for (uint8_t i = 0; i < ThermalComponentIF::NUMBER_OF_PRIORITIES; i++) {
-		heaterRequests[i] = ThermalComponentIF::HEATER_DONT_CARE;
-	}
-
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		updateTargetTemperatures(iter->component,
-				iter->priority == ThermalComponentIF::SAFE);
-		ThermalComponentIF::HeaterRequest request =
-				iter->component->performOperation(0);
-		iter->request = request;
-		if (request != ThermalComponentIF::HEATER_DONT_CARE) {
-			if (request < heaterRequests[iter->priority]) {
-				heaterRequests[iter->priority] = request;
-			}
-		}
-	}
-
-	if (!safeOnly) {
-		for (uint8_t i = ThermalComponentIF::NUMBER_OF_PRIORITIES - 1; i > 0;
-				i--) {
-			if (heaterRequests[i - 1] == ThermalComponentIF::HEATER_DONT_CARE) {
-				heaterRequests[i - 1] = heaterRequests[i];
-			}
-		}
-	}
-	return heaterRequests[0];
-}
-
-void ThermalModule::informComponentsAboutHeaterState(bool heaterIsOn,
-		Informee whomToInform) {
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		switch (whomToInform) {
-		case ALL:
-			break;
-		case SAFE:
-			if (!(iter->priority == ThermalComponentIF::SAFE)) {
-				iter->component->markStateIgnored();
-				continue;
-			}
-			break;
-		case NONE:
-			iter->component->markStateIgnored();
-			continue;
-		}
-
-		if (heaterIsOn) {
-			if ((iter->request
-					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_OFF)
-					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_OFF)) {
-				iter->component->markStateIgnored();
-			}
-		} else {
-			if ((iter->request
-					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON)
-					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_ON)) {
-				iter->component->markStateIgnored();
-			}
-		}
-	}
-}
-
-void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
-	if (heater != NULL) {
-		heater->setPowerSwitcher(powerSwitch);
-	}
-
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		float componentLowerOpLimit = iter->component->getLowerOpLimit();
-		if (iter->priority == ThermalComponentIF::SAFE) {
-			if (componentLowerOpLimit > survivalTargetTemp) {
-				survivalTargetTemp = componentLowerOpLimit;
-			}
-		} else {
-			if (componentLowerOpLimit > targetTemp) {
-				targetTemp = componentLowerOpLimit;
-			}
-		}
-	}
-	if (survivalTargetTemp > targetTemp) {
-		targetTemp = survivalTargetTemp;
-	}
-}
-
-bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
-		Strategy strategy) {
-	currentState.setValid(PoolVariableIF::VALID);
-	if (moduleTemperature == INVALID_TEMPERATURE) {
-		currentState = UNKNOWN;
-		return false;
-	}
-
-	float limit = targetTemp;
-	bool heaterRequest = false;
-	if (strategy == ACTIVE_SURVIVAL) {
-		limit = survivalTargetTemp;
-	}
-
-	if (moduleTemperature >= limit) {
-		currentState = OPERATIONAL;
-	} else {
-		currentState = NON_OPERATIONAL;
-	}
-
-	limit += parameters.heaterOn;
-
-	if (heating) {
-		limit += parameters.hysteresis;
-	}
-
-	if (targetState == STATE_REQUEST_HEATING) {
-		if (moduleTemperature < limit) {
-			heaterRequest = true;
-		} else {
-			heaterRequest = false;
-		}
-	}
-
-	heating = heaterRequest;
-
-	return heaterRequest;
-}
-
-void ThermalModule::setHeating(bool on) {
-	GlobDataSet mySet;
-	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_WRITE);
-	if (on) {
-		writableTargetState = STATE_REQUEST_HEATING;
-	} else {
-		writableTargetState = STATE_REQUEST_PASSIVE;
-	}
-	mySet.commit(PoolVariableIF::VALID);
-}
-
-void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
-		bool isSafe) {
-	if (isSafe) {
-		if (component->getLowerOpLimit() > survivalTargetTemp) {
-			survivalTargetTemp = component->getLowerOpLimit();
-		}
-	} else {
-		if (component->getLowerOpLimit() > targetTemp) {
-			targetTemp = component->getLowerOpLimit();
-		}
-	}
-}
-
-void ThermalModule::setOutputInvalid() {
-	moduleTemperature = INVALID_TEMPERATURE;
-	moduleTemperature.setValid(PoolVariableIF::INVALID);
-	currentState.setValid(PoolVariableIF::INVALID);
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		iter->component->setOutputInvalid();
-	}
-	if (heater != NULL) {
-		heater->set(false,true);
-	}
-}
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "ThermalModule.h"
+
+#include "AbstractTemperatureSensor.h"
+
+ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
+		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
+		GlobDataSet *dataSet, Parameters parameters,
+		RedundantHeater::Parameters heaterParameters) :
+		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
+				false), parameters(parameters), moduleTemperature(
+				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
+				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
+				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
+	heater = new RedundantHeater(heaterParameters);
+}
+
+ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
+		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
+				false), parameters( { 0, 0 }), moduleTemperature(
+				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
+				NULL), currentState(PoolVariableIF::INVALID, dataSet,
+				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
+				dataSet, PoolVariableIF::VAR_READ) {
+}
+
+ThermalModule::~ThermalModule() {
+	delete heater;
+}
+
+void ThermalModule::performOperation(uint8_t opCode) {
+	if (heater != NULL) {
+		heater->performOperation(0);
+	}
+}
+
+void ThermalModule::performMode(Strategy strategy) {
+	calculateTemperature();
+
+	bool safeOnly = (strategy == ACTIVE_SURVIVAL);
+	ThermalComponentIF::HeaterRequest componentHeaterRequest =
+			letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
+
+	if (heater == NULL) {
+		informComponentsAboutHeaterState(false, NONE);
+		return;
+	}
+
+	bool heating = calculateModuleHeaterRequestAndSetModuleStatus(strategy);
+
+	if (componentHeaterRequest != ThermalComponentIF::HEATER_DONT_CARE) {
+		//Components overwrite the module request.
+		heating = ((componentHeaterRequest
+				== ThermalComponentIF::HEATER_REQUEST_ON)
+				|| (componentHeaterRequest
+						== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
+	}
+
+	bool dual = (strategy == ACTIVE_DUAL);
+
+	if (strategy == PASSIVE) {
+		informComponentsAboutHeaterState(false, NONE);
+		if (oldStrategy != PASSIVE) {
+			heater->set(false, false, true);
+		}
+	} else {
+		if (safeOnly) {
+			informComponentsAboutHeaterState(heating, SAFE);
+		} else {
+			informComponentsAboutHeaterState(heating, ALL);
+		}
+		heater->set(heating, dual);
+	}
+	oldStrategy = strategy;
+}
+
+float ThermalModule::getTemperature() {
+	return moduleTemperature;
+}
+
+void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
+	sensors.push_back(sensor);
+}
+
+void ThermalModule::registerComponent(ThermalComponentIF* component,
+		ThermalComponentIF::Priority priority) {
+	components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
+}
+
+void ThermalModule::calculateTemperature() {
+	uint32_t numberOfValidSensors = 0;
+	moduleTemperature = 0;
+	std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
+	for (; iter != sensors.end(); iter++) {
+		if ((*iter)->isValid()) {
+			moduleTemperature = moduleTemperature + (*iter)->getTemperature();
+			numberOfValidSensors++;
+		}
+	}
+	if (numberOfValidSensors != 0) {
+		moduleTemperature = moduleTemperature / numberOfValidSensors;
+		moduleTemperature.setValid(PoolVariableIF::VALID);
+	} else {
+		moduleTemperature = INVALID_TEMPERATURE;
+		moduleTemperature.setValid(PoolVariableIF::INVALID);
+	}
+}
+
+ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		if (iter->component->getObjectId() == objectId) {
+			return iter->component;
+		}
+	}
+	return NULL;
+}
+
+ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
+		bool safeOnly) {
+	ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
+
+	survivalTargetTemp = -999;
+	targetTemp = -999;
+
+	for (uint8_t i = 0; i < ThermalComponentIF::NUMBER_OF_PRIORITIES; i++) {
+		heaterRequests[i] = ThermalComponentIF::HEATER_DONT_CARE;
+	}
+
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		updateTargetTemperatures(iter->component,
+				iter->priority == ThermalComponentIF::SAFE);
+		ThermalComponentIF::HeaterRequest request =
+				iter->component->performOperation(0);
+		iter->request = request;
+		if (request != ThermalComponentIF::HEATER_DONT_CARE) {
+			if (request < heaterRequests[iter->priority]) {
+				heaterRequests[iter->priority] = request;
+			}
+		}
+	}
+
+	if (!safeOnly) {
+		for (uint8_t i = ThermalComponentIF::NUMBER_OF_PRIORITIES - 1; i > 0;
+				i--) {
+			if (heaterRequests[i - 1] == ThermalComponentIF::HEATER_DONT_CARE) {
+				heaterRequests[i - 1] = heaterRequests[i];
+			}
+		}
+	}
+	return heaterRequests[0];
+}
+
+void ThermalModule::informComponentsAboutHeaterState(bool heaterIsOn,
+		Informee whomToInform) {
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		switch (whomToInform) {
+		case ALL:
+			break;
+		case SAFE:
+			if (!(iter->priority == ThermalComponentIF::SAFE)) {
+				iter->component->markStateIgnored();
+				continue;
+			}
+			break;
+		case NONE:
+			iter->component->markStateIgnored();
+			continue;
+		}
+
+		if (heaterIsOn) {
+			if ((iter->request
+					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_OFF)
+					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_OFF)) {
+				iter->component->markStateIgnored();
+			}
+		} else {
+			if ((iter->request
+					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON)
+					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_ON)) {
+				iter->component->markStateIgnored();
+			}
+		}
+	}
+}
+
+void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
+	if (heater != NULL) {
+		heater->setPowerSwitcher(powerSwitch);
+	}
+
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		float componentLowerOpLimit = iter->component->getLowerOpLimit();
+		if (iter->priority == ThermalComponentIF::SAFE) {
+			if (componentLowerOpLimit > survivalTargetTemp) {
+				survivalTargetTemp = componentLowerOpLimit;
+			}
+		} else {
+			if (componentLowerOpLimit > targetTemp) {
+				targetTemp = componentLowerOpLimit;
+			}
+		}
+	}
+	if (survivalTargetTemp > targetTemp) {
+		targetTemp = survivalTargetTemp;
+	}
+}
+
+bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
+		Strategy strategy) {
+	currentState.setValid(PoolVariableIF::VALID);
+	if (moduleTemperature == INVALID_TEMPERATURE) {
+		currentState = UNKNOWN;
+		return false;
+	}
+
+	float limit = targetTemp;
+	bool heaterRequest = false;
+	if (strategy == ACTIVE_SURVIVAL) {
+		limit = survivalTargetTemp;
+	}
+
+	if (moduleTemperature >= limit) {
+		currentState = OPERATIONAL;
+	} else {
+		currentState = NON_OPERATIONAL;
+	}
+
+	limit += parameters.heaterOn;
+
+	if (heating) {
+		limit += parameters.hysteresis;
+	}
+
+	if (targetState == STATE_REQUEST_HEATING) {
+		if (moduleTemperature < limit) {
+			heaterRequest = true;
+		} else {
+			heaterRequest = false;
+		}
+	}
+
+	heating = heaterRequest;
+
+	return heaterRequest;
+}
+
+void ThermalModule::setHeating(bool on) {
+	GlobDataSet mySet;
+	gp_int8_t writableTargetState(targetState.getDataPoolId(),
+			&mySet, PoolVariableIF::VAR_WRITE);
+	if (on) {
+		writableTargetState = STATE_REQUEST_HEATING;
+	} else {
+		writableTargetState = STATE_REQUEST_PASSIVE;
+	}
+	mySet.commit(PoolVariableIF::VALID);
+}
+
+void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
+		bool isSafe) {
+	if (isSafe) {
+		if (component->getLowerOpLimit() > survivalTargetTemp) {
+			survivalTargetTemp = component->getLowerOpLimit();
+		}
+	} else {
+		if (component->getLowerOpLimit() > targetTemp) {
+			targetTemp = component->getLowerOpLimit();
+		}
+	}
+}
+
+void ThermalModule::setOutputInvalid() {
+	moduleTemperature = INVALID_TEMPERATURE;
+	moduleTemperature.setValid(PoolVariableIF::INVALID);
+	currentState.setValid(PoolVariableIF::INVALID);
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		iter->component->setOutputInvalid();
+	}
+	if (heater != NULL) {
+		heater->set(false,true);
+	}
+}
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index 466926401..41be6baae 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -1,95 +1,95 @@
-#ifndef THERMALMODULE_H_
-#define THERMALMODULE_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../devicehandlers/HealthDevice.h"
-#include "../events/EventReportingProxyIF.h"
-#include "ThermalModuleIF.h"
-#include <list>
-#include "tcsDefinitions.h"
-#include "RedundantHeater.h"
-class PowerSwitchIF;
-
-/**
- * @brief Allows creation of different thermal control domains within a system.
- */
-class ThermalModule: public ThermalModuleIF {
-	friend class ThermalController;
-public:
-	struct Parameters {
-		float heaterOn;
-		float hysteresis;
-	};
-
-	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
-			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
-			RedundantHeater::Parameters heaterParameters);
-
-	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
-
-	virtual ~ThermalModule();
-
-	void performOperation(uint8_t opCode);
-
-	void performMode(Strategy strategy);
-
-	float getTemperature();
-
-	void registerSensor(AbstractTemperatureSensor *sensor);
-
-	void registerComponent(ThermalComponentIF *component,
-			ThermalComponentIF::Priority priority);
-
-	ThermalComponentIF *findComponent(object_id_t objectId);
-
-	void initialize(PowerSwitchIF* powerSwitch);
-
-	void setHeating(bool on);
-
-	virtual void setOutputInvalid();
-
-protected:
-	enum Informee {
-		ALL, SAFE, NONE
-	};
-
-	struct ComponentData {
-		ThermalComponentIF *component;
-		ThermalComponentIF::Priority priority;
-		ThermalComponentIF::HeaterRequest request;
-	};
-
-	Strategy oldStrategy;
-
-	float survivalTargetTemp;
-
-	float targetTemp;
-
-	bool heating;
-
-	Parameters parameters;
-
-	gp_float_t moduleTemperature;
-
-	RedundantHeater *heater;
-
-	gp_int8_t currentState;
-	gp_int8_t targetState;
-
-	std::list<AbstractTemperatureSensor *> sensors;
-	std::list<ComponentData> components;
-
-	void calculateTemperature();
-
-	ThermalComponentIF::HeaterRequest letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly);
-
-	void informComponentsAboutHeaterState(bool heaterIsOn,
-			Informee whomToInform);
-
-	bool calculateModuleHeaterRequestAndSetModuleStatus(Strategy strategy);
-
-	void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
-};
-
-#endif /* THERMALMODULE_H_ */
+#ifndef THERMALMODULE_H_
+#define THERMALMODULE_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../events/EventReportingProxyIF.h"
+#include "ThermalModuleIF.h"
+#include <list>
+#include "tcsDefinitions.h"
+#include "RedundantHeater.h"
+class PowerSwitchIF;
+
+/**
+ * @brief Allows creation of different thermal control domains within a system.
+ */
+class ThermalModule: public ThermalModuleIF {
+	friend class ThermalController;
+public:
+	struct Parameters {
+		float heaterOn;
+		float hysteresis;
+	};
+
+	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
+			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
+			RedundantHeater::Parameters heaterParameters);
+
+	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
+
+	virtual ~ThermalModule();
+
+	void performOperation(uint8_t opCode);
+
+	void performMode(Strategy strategy);
+
+	float getTemperature();
+
+	void registerSensor(AbstractTemperatureSensor *sensor);
+
+	void registerComponent(ThermalComponentIF *component,
+			ThermalComponentIF::Priority priority);
+
+	ThermalComponentIF *findComponent(object_id_t objectId);
+
+	void initialize(PowerSwitchIF* powerSwitch);
+
+	void setHeating(bool on);
+
+	virtual void setOutputInvalid();
+
+protected:
+	enum Informee {
+		ALL, SAFE, NONE
+	};
+
+	struct ComponentData {
+		ThermalComponentIF *component;
+		ThermalComponentIF::Priority priority;
+		ThermalComponentIF::HeaterRequest request;
+	};
+
+	Strategy oldStrategy;
+
+	float survivalTargetTemp;
+
+	float targetTemp;
+
+	bool heating;
+
+	Parameters parameters;
+
+	gp_float_t moduleTemperature;
+
+	RedundantHeater *heater;
+
+	gp_int8_t currentState;
+	gp_int8_t targetState;
+
+	std::list<AbstractTemperatureSensor *> sensors;
+	std::list<ComponentData> components;
+
+	void calculateTemperature();
+
+	ThermalComponentIF::HeaterRequest letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly);
+
+	void informComponentsAboutHeaterState(bool heaterIsOn,
+			Informee whomToInform);
+
+	bool calculateModuleHeaterRequestAndSetModuleStatus(Strategy strategy);
+
+	void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
+};
+
+#endif /* THERMALMODULE_H_ */
diff --git a/thermal/ThermalMonitor.cpp b/thermal/ThermalMonitor.cpp
index af0413bf7..fc0823c3c 100644
--- a/thermal/ThermalMonitor.cpp
+++ b/thermal/ThermalMonitor.cpp
@@ -1,68 +1,68 @@
-#include "../thermal/ThermalMonitor.h"
-#include "../thermal/ThermalComponentIF.h"
-#include "../monitoring/MonitoringIF.h"
-ThermalMonitor::~ThermalMonitor() {
-}
-
-void ThermalMonitor::sendTransitionEvent(float currentValue,
-		ReturnValue_t state) {
-	switch (state) {
-	case MonitoringIF::BELOW_LOW_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_OOL_LOW, state);
-		break;
-	case MonitoringIF::ABOVE_HIGH_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH, state);
-		break;
-	case ThermalComponentIF::BELOW_OPERATIONAL_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_LOW, state);
-		break;
-	case ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_HIGH, state);
-		break;
-	default:
-		break;
-	}
-}
-
-bool ThermalMonitor::isAboveHighLimit() {
-	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-ReturnValue_t ThermalMonitor::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
-		float upperLimit, bool componentIsOperational) {
-	if (ThermalComponentIF::isIgnoredState(state)) {
-		setToUnchecked();
-		return MonitoringIF::UNCHECKED;
-	}
-	switch (state) {
-	case ThermalComponentIF::OUT_OF_RANGE_LOW:
-		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample, lowerLimit);
-	case ThermalComponentIF::NON_OPERATIONAL_LOW:
-		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT, sample, lowerLimit);
-		} else {
-			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-		}
-	case ThermalComponentIF::OPERATIONAL:
-		return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-	case ThermalComponentIF::NON_OPERATIONAL_HIGH:
-		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT, sample, upperLimit);
-		} else {
-			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-		}
-	case ThermalComponentIF::OUT_OF_RANGE_HIGH:
-		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample, upperLimit);
-	default:
-		//Never reached, all states covered.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
+#include "../thermal/ThermalMonitor.h"
+#include "../thermal/ThermalComponentIF.h"
+#include "../monitoring/MonitoringIF.h"
+ThermalMonitor::~ThermalMonitor() {
+}
+
+void ThermalMonitor::sendTransitionEvent(float currentValue,
+		ReturnValue_t state) {
+	switch (state) {
+	case MonitoringIF::BELOW_LOW_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_OOL_LOW, state);
+		break;
+	case MonitoringIF::ABOVE_HIGH_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH, state);
+		break;
+	case ThermalComponentIF::BELOW_OPERATIONAL_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_LOW, state);
+		break;
+	case ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_HIGH, state);
+		break;
+	default:
+		break;
+	}
+}
+
+bool ThermalMonitor::isAboveHighLimit() {
+	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+ReturnValue_t ThermalMonitor::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
+		float upperLimit, bool componentIsOperational) {
+	if (ThermalComponentIF::isIgnoredState(state)) {
+		setToUnchecked();
+		return MonitoringIF::UNCHECKED;
+	}
+	switch (state) {
+	case ThermalComponentIF::OUT_OF_RANGE_LOW:
+		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample, lowerLimit);
+	case ThermalComponentIF::NON_OPERATIONAL_LOW:
+		if (componentIsOperational) {
+			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT, sample, lowerLimit);
+		} else {
+			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+		}
+	case ThermalComponentIF::OPERATIONAL:
+		return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+	case ThermalComponentIF::NON_OPERATIONAL_HIGH:
+		if (componentIsOperational) {
+			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT, sample, upperLimit);
+		} else {
+			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+		}
+	case ThermalComponentIF::OUT_OF_RANGE_HIGH:
+		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample, upperLimit);
+	default:
+		//Never reached, all states covered.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
diff --git a/thermal/ThermalMonitor.h b/thermal/ThermalMonitor.h
index 695286009..680c0cb05 100644
--- a/thermal/ThermalMonitor.h
+++ b/thermal/ThermalMonitor.h
@@ -1,26 +1,26 @@
-#ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_
-#define FRAMEWORK_THERMAL_THERMALMONITOR_H_
-
-#include "../monitoring/MonitorReporter.h"
-#include "../thermal/ThermalComponentIF.h"
-
-/**
- * What does it do. How to use it.
- */
-class ThermalMonitor: public MonitorReporter<float> {
-public:
-	template<typename ... Args>
-	ThermalMonitor(Args ... args) :
-			MonitorReporter<float>(std::forward<Args>(args)...) {
-	}
-	~ThermalMonitor();
-	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
-			float lowerLimit, float upperLimit, bool componentIsOperational = true);
-
-	bool isAboveHighLimit();
-protected:
-	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
-
-};
-
-#endif /* FRAMEWORK_THERMAL_THERMALMONITOR_H_ */
+#ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_
+#define FRAMEWORK_THERMAL_THERMALMONITOR_H_
+
+#include "../monitoring/MonitorReporter.h"
+#include "../thermal/ThermalComponentIF.h"
+
+/**
+ * What does it do. How to use it.
+ */
+class ThermalMonitor: public MonitorReporter<float> {
+public:
+	template<typename ... Args>
+	ThermalMonitor(Args ... args) :
+			MonitorReporter<float>(std::forward<Args>(args)...) {
+	}
+	~ThermalMonitor();
+	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
+			float lowerLimit, float upperLimit, bool componentIsOperational = true);
+
+	bool isAboveHighLimit();
+protected:
+	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
+
+};
+
+#endif /* FRAMEWORK_THERMAL_THERMALMONITOR_H_ */
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 7124d8bd9..130b3175c 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,602 +1,602 @@
-#include "../timemanager/CCSDSTime.h"
-#include <stdio.h>
-#include <inttypes.h>
-#include <math.h>
-
-CCSDSTime::CCSDSTime() {
-}
-
-CCSDSTime::~CCSDSTime() {
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
-		const Clock::TimeOfDay_t* from) {
-	ReturnValue_t result = checkTimeOfDay(from);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	to->pField = (CCS << 4);
-
-	to->yearMSB = (from->year >> 8);
-	to->yearLSB = from->year & 0xff;
-	to->month = from->month;
-	to->day = from->day;
-	to->hour = from->hour;
-	to->minute = from->minute;
-	to->second = from->second;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
-		const Clock::TimeOfDay_t* from) {
-	ReturnValue_t result = checkTimeOfDay(from);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	to->pField = (CCS << 4) + 2;
-
-	to->yearMSB = (from->year >> 8);
-	to->yearLSB = from->year & 0xff;
-	to->month = from->month;
-	to->day = from->day;
-	to->hour = from->hour;
-	to->minute = from->minute;
-	to->second = from->second;
-	to->secondEminus2 = from->usecond / 10000;
-	to->secondEminus4 = (from->usecond % 10000) / 100;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint32_t length) {
-	ReturnValue_t result;
-	if (length > 0xFF) {
-		return LENGTH_MISMATCH;
-	}
-	result = convertFromASCII(to, from, length); //Try to parse it as ASCII
-	if (result == RETURN_OK) {
-		return RETURN_OK;
-	}
-
-	//Seems to be no ascii, try the other formats
-	uint8_t codeIdentification = (*from >> 4);
-	switch (codeIdentification) {
-	case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can... <- see bug 1133
-		return convertFromCUC(to, from, length);
-	case CDS:
-		return convertFromCDS(to, from, length);
-	case CCS: {
-		uint32_t temp = 0;
-		return convertFromCCS(to, from, &temp, length);
-	}
-
-	default:
-		return UNSUPPORTED_TIME_FORMAT;
-	}
-}
-
-ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
-	return UNSUPPORTED_TIME_FORMAT;
-}
-
-ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
-	timeval time;
-	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return convertTimevalToTimeOfDay(to, &time);
-}
-
-ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	uint8_t subsecondsLength = *from & 0b111;
-	uint32_t totalLength = subsecondsLength + 8;
-	if (maxLength < totalLength) {
-		return LENGTH_MISMATCH;
-	}
-
-	*foundLength = totalLength;
-
-	ReturnValue_t result = checkCcs(from, maxLength);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	Ccs_mseconds *temp = (Ccs_mseconds *) from;
-
-	to->year = (temp->yearMSB << 8) + temp->yearLSB;
-	to->hour = temp->hour;
-	to->minute = temp->minute;
-	to->second = temp->second;
-
-	if (temp->pField & (1 << 3)) { //day of year variation
-		uint16_t tempDay = (temp->month << 8) + temp->day;
-		result = convertDaysOfYear(tempDay, to->year,
-				&(temp->month), &(temp->day));
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-
-	to->month = temp->month;
-	to->day = temp->day;
-
-	to->usecond = 0;
-	if (subsecondsLength > 0) {
-		*foundLength += 1;
-		if (temp->secondEminus2 >= 100) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->usecond = temp->secondEminus2 * 10000;
-	}
-
-	if (subsecondsLength > 1) {
-		*foundLength += 1;
-		if (temp->secondEminus4 >= 100) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->usecond += temp->secondEminus4 * 100;
-	}
-
-	return RETURN_OK;
-
-}
-
-ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
-	if (length < 19) {
-		return RETURN_FAILED;
-	}
-// Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
-// Suggestion: use uint16 all the time. This should work on all systems.
-#ifdef NEWLIB_NANO_NO_C99_IO
-	uint16_t year;
-	uint16_t month;
-	uint16_t day;
-	uint16_t hour;
-	uint16_t minute;
-	float second;
-	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
-				&month, &day, &hour, &minute, &second);
-	if (count == 6) {
-		to->year = year;
-		to->month = month;
-		to->day = day;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-
-	// try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
-			&hour, &minute, &second);
-	if (count == 5) {
-		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
-				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
-		if (result != RETURN_OK) {
-			return RETURN_FAILED;
-		}
-		to->year = year;
-		to->month = month;
-		to->day = tempDay;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-// Warning: Compiler/Linker fails ambiguously if library does not implement
-// C99 I/O
-#else
-	uint16_t year;
-	uint8_t month;
-	uint16_t day;
-	uint8_t hour;
-	uint8_t minute;
-	float second;
-    //try Code A (yyyy-mm-dd)
-    int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16
-            "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year, &month, &day,
-            &hour, &minute, &second);
-	if (count == 6) {
-		to->year = year;
-		to->month = month;
-		to->day = day;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-
-    //try Code B (yyyy-ddd)
-    count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu8
-            ":%2" SCNu8 ":%fZ", &year, &day, &hour, &minute, &second);
-	if (count == 5) {
-		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
-				&tempDay);
-		if (result != RETURN_OK) {
-			return RETURN_FAILED;
-		}
-		to->year = year;
-		to->month = month;
-		to->day = tempDay;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-#endif
-
-	return UNSUPPORTED_TIME_FORMAT;
-}
-
-ReturnValue_t CCSDSTime::checkCcs(const uint8_t* time, uint8_t length) {
-	Ccs_mseconds *time_struct = (Ccs_mseconds *) time;
-
-	uint8_t additionalBytes = time_struct->pField & 0b111;
-	if ((additionalBytes == 0b111) || (length < (additionalBytes + 8))) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time_struct->pField & (1 << 3)) { //day of year variation
-		uint16_t day = (time_struct->month << 8) + time_struct->day;
-		if (day > 366) {
-			return INVALID_TIME_FORMAT;
-		}
-	} else {
-		if (time_struct->month > 12) {
-			return INVALID_TIME_FORMAT;
-		}
-		if (time_struct->day > 31) {
-			return INVALID_TIME_FORMAT;
-		}
-	}
-	if (time_struct->hour > 23) {
-		return INVALID_TIME_FORMAT;
-	}
-	if (time_struct->minute > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-	if (time_struct->second > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	uint8_t *additionalByte = &time_struct->secondEminus2;
-
-	for (; additionalBytes != 0; additionalBytes--) {
-		if (*additionalByte++ > 99) {
-			return INVALID_TIME_FORMAT;
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertDaysOfYear(uint16_t dayofYear, uint16_t year,
-		uint8_t* month, uint8_t* day) {
-	if (isLeapYear(year)) {
-		if (dayofYear > 366) {
-			return INVALID_DAY_OF_YEAR;
-		}
-	} else {
-		if (dayofYear > 365) {
-			return INVALID_DAY_OF_YEAR;
-		}
-	}
-	*month = 1;
-	if (dayofYear <= 31) {
-		*day = dayofYear;
-		return RETURN_OK;
-	}
-	*month += 1;
-	dayofYear -= 31;
-	if (isLeapYear(year)) {
-		if (dayofYear <= 29) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 29;
-	} else {
-		if (dayofYear <= 28) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 28;
-	}
-	while (*month <= 12) {
-		if (dayofYear <= 31) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 31;
-
-		if (*month == 8) {
-			continue;
-		}
-
-		if (dayofYear <= 30) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 30;
-	}
-	return INVALID_DAY_OF_YEAR;
-}
-
-bool CCSDSTime::isLeapYear(uint32_t year) {
-	if ((year % 400) == 0) {
-		return true;
-	}
-	if ((year % 100) == 0) {
-		return false;
-	}
-	if ((year % 4) == 0) {
-		return true;
-	}
-	return false;
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(CDS_short* to, const timeval* from) {
-	to->pField = (CDS << 4) + 0;
-	uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
-			+ DAYS_CCSDS_TO_UNIX_EPOCH;
-	if (days > (1 << 16)) {
-		//Date is beyond year 2137
-		return TIME_DOES_NOT_FIT_FORMAT;
-	}
-	to->dayMSB = (days & 0xFF00) >> 8;
-	to->dayLSB = (days & 0xFF);
-	uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
-			+ (from->tv_usec / 1000);
-	to->msDay_hh = (msDay & 0xFF000000) >> 24;
-	to->msDay_h = (msDay & 0xFF0000) >> 16;
-	to->msDay_l = (msDay & 0xFF00) >> 8;
-	to->msDay_ll = (msDay & 0xFF);
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
-	to->pFiled = (AGENCY_DEFINED << 4) + 5;
-	to->seconds_hh = (from->tv_sec >> 24) & 0xff;
-	to->seconds_h = (from->tv_sec >> 16) & 0xff;
-	to->seconds_l = (from->tv_sec >> 8) & 0xff;
-	to->seconds_ll = (from->tv_sec >> 0) & 0xff;
-
-	//convert the µs to 2E-16 seconds
-	uint64_t temp = from->tv_usec;
-	temp = temp << 16;
-	temp = temp / 1E6;
-
-	to->subsecondsMSB = (temp >> 8) & 0xff;
-	to->subsecondsLSB = temp & 0xff;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	//We don't expect ascii here. SHOULDDO
-	uint8_t codeIdentification = (*from >> 4);
-	switch (codeIdentification) {
-	//unsupported, as Leap second correction would have to be applied
-//	case CUC_LEVEL1:
-//		return convertFromCUC(to, from, foundLength, maxLength);
-	case CDS:
-		return convertFromCDS(to, from, foundLength, maxLength);
-	case CCS:
-		return convertFromCCS(to, from, foundLength, maxLength);
-	default:
-		return UNSUPPORTED_TIME_FORMAT;
-	}
-
-}
-
-ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	if (maxLength < 1) {
-		return INVALID_TIME_FORMAT;
-	}
-	uint8_t pField = *from;
-	from++;
-	ReturnValue_t result = convertFromCUC(to, pField, from, foundLength,
-			maxLength - 1);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		if (foundLength != NULL) {
-			*foundLength += 1;
-		}
-	}
-	return result;
-}
-
-ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
-	if ((time->month > 12) || (time->month == 0)) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->day == 0) {
-		return INVALID_TIME_FORMAT;
-	}
-	switch (time->month) {
-	case 2:
-		if (isLeapYear(time->year)) {
-			if (time->day > 29) {
-				return INVALID_TIME_FORMAT;
-			}
-		} else {
-			if (time->day > 28) {
-				return INVALID_TIME_FORMAT;
-			}
-		}
-		break;
-	case 4:
-	case 6:
-	case 9:
-	case 11:
-		if (time->day > 30) {
-			return INVALID_TIME_FORMAT;
-		}
-		break;
-	default:
-		if (time->day > 31) {
-			return INVALID_TIME_FORMAT;
-		}
-		break;
-	}
-
-	if (time->hour > 23) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->minute > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->second > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->usecond > 999999) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	return RETURN_OK;
-
-}
-
-ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
-		timeval* from) {
-//This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
-	return UNSUPPORTED_TIME_FORMAT;
-}
-
-ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	uint8_t pField = *from;
-	from++;
-//Check epoch
-	if (pField & 0b1000) {
-		return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
-	}
-//Check length
-	uint8_t expectedLength = 7; //Including p-Field.
-	bool extendedDays = pField & 0b100;
-	if (extendedDays) {
-		expectedLength += 1;
-	}
-	if ((pField & 0b11) == 0b01) {
-		expectedLength += 2;
-	} else if ((pField & 0b11) == 0b10) {
-		expectedLength += 4;
-	}
-	if (foundLength != NULL) {
-		*foundLength = expectedLength;
-	}
-	if (expectedLength > maxLength) {
-		return LENGTH_MISMATCH;
-	}
-//Check and count days
-	uint32_t days = 0;
-	if (extendedDays) {
-		days = (from[0] << 16) + (from[1] << 8) + from[2];
-		from += 3;
-	} else {
-		days = (from[0] << 8) + from[1];
-		from += 2;
-	}
-//Move to POSIX epoch.
-	if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
-		return INVALID_TIME_FORMAT;
-	}
-	days -= DAYS_CCSDS_TO_UNIX_EPOCH;
-	to->tv_sec = days * SECONDS_PER_DAY;
-	uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
-			+ from[3];
-	from += 4;
-	to->tv_sec += (msDay / 1000);
-	to->tv_usec = (msDay % 1000) * 1000;
-	if ((pField & 0b11) == 0b01) {
-		uint16_t usecs = (from[0] << 16) + from[1];
-		from += 2;
-		if (usecs > 999) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->tv_usec += usecs;
-	} else if ((pField & 0b11) == 0b10) {
-		uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
-				+ from[3];
-		from += 4;
-		if (picosecs > 999999) {
-			return INVALID_TIME_FORMAT;
-		}
-		//Not very useful.
-		to->tv_usec += (picosecs / 1000);
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
-		const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
-	uint32_t secs = 0;
-	uint32_t subSeconds = 0;
-	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
-	uint8_t nFine = (pField & 0b11);
-	uint32_t totalLength = nCoarse + nFine;
-	if (foundLength != NULL) {
-		*foundLength = totalLength;
-	}
-	if (totalLength > maxLength) {
-		return LENGTH_MISMATCH;
-	}
-	for (int count = 0; count < nCoarse; count++) {
-		secs += *from << ((nCoarse * 8 - 8) * (1 + count));
-		from++;
-	}
-	for (int count = 0; count < nFine; count++) {
-		subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
-		from++;
-	}
-	//Move to POSIX epoch.
-	to->tv_sec = secs;
-	if (pField & 0b10000) {
-		//CCSDS-Epoch
-		to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
-	}
-	to->tv_usec = subsecondsToMicroseconds(subSeconds);
-	return RETURN_OK;
-}
-
-uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
-	uint64_t temp = (uint64_t) subseconds * 1000000
-			/ (1 << (sizeof(subseconds) * 8));
-	return temp;
-}
-
-ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	Clock::TimeOfDay_t tempTime;
-	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
-			maxLength);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	return Clock::convertTimeOfDayToTimeval(&tempTime, to);
-
-}
+#include "../timemanager/CCSDSTime.h"
+#include <stdio.h>
+#include <inttypes.h>
+#include <math.h>
+
+CCSDSTime::CCSDSTime() {
+}
+
+CCSDSTime::~CCSDSTime() {
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
+		const Clock::TimeOfDay_t* from) {
+	ReturnValue_t result = checkTimeOfDay(from);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	to->pField = (CCS << 4);
+
+	to->yearMSB = (from->year >> 8);
+	to->yearLSB = from->year & 0xff;
+	to->month = from->month;
+	to->day = from->day;
+	to->hour = from->hour;
+	to->minute = from->minute;
+	to->second = from->second;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
+		const Clock::TimeOfDay_t* from) {
+	ReturnValue_t result = checkTimeOfDay(from);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	to->pField = (CCS << 4) + 2;
+
+	to->yearMSB = (from->year >> 8);
+	to->yearLSB = from->year & 0xff;
+	to->month = from->month;
+	to->day = from->day;
+	to->hour = from->hour;
+	to->minute = from->minute;
+	to->second = from->second;
+	to->secondEminus2 = from->usecond / 10000;
+	to->secondEminus4 = (from->usecond % 10000) / 100;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint32_t length) {
+	ReturnValue_t result;
+	if (length > 0xFF) {
+		return LENGTH_MISMATCH;
+	}
+	result = convertFromASCII(to, from, length); //Try to parse it as ASCII
+	if (result == RETURN_OK) {
+		return RETURN_OK;
+	}
+
+	//Seems to be no ascii, try the other formats
+	uint8_t codeIdentification = (*from >> 4);
+	switch (codeIdentification) {
+	case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can... <- see bug 1133
+		return convertFromCUC(to, from, length);
+	case CDS:
+		return convertFromCDS(to, from, length);
+	case CCS: {
+		uint32_t temp = 0;
+		return convertFromCCS(to, from, &temp, length);
+	}
+
+	default:
+		return UNSUPPORTED_TIME_FORMAT;
+	}
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	timeval time;
+	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return convertTimevalToTimeOfDay(to, &time);
+}
+
+ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	uint8_t subsecondsLength = *from & 0b111;
+	uint32_t totalLength = subsecondsLength + 8;
+	if (maxLength < totalLength) {
+		return LENGTH_MISMATCH;
+	}
+
+	*foundLength = totalLength;
+
+	ReturnValue_t result = checkCcs(from, maxLength);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	Ccs_mseconds *temp = (Ccs_mseconds *) from;
+
+	to->year = (temp->yearMSB << 8) + temp->yearLSB;
+	to->hour = temp->hour;
+	to->minute = temp->minute;
+	to->second = temp->second;
+
+	if (temp->pField & (1 << 3)) { //day of year variation
+		uint16_t tempDay = (temp->month << 8) + temp->day;
+		result = convertDaysOfYear(tempDay, to->year,
+				&(temp->month), &(temp->day));
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+
+	to->month = temp->month;
+	to->day = temp->day;
+
+	to->usecond = 0;
+	if (subsecondsLength > 0) {
+		*foundLength += 1;
+		if (temp->secondEminus2 >= 100) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->usecond = temp->secondEminus2 * 10000;
+	}
+
+	if (subsecondsLength > 1) {
+		*foundLength += 1;
+		if (temp->secondEminus4 >= 100) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->usecond += temp->secondEminus4 * 100;
+	}
+
+	return RETURN_OK;
+
+}
+
+ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	if (length < 19) {
+		return RETURN_FAILED;
+	}
+// Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
+// Suggestion: use uint16 all the time. This should work on all systems.
+#ifdef NEWLIB_NANO_NO_C99_IO
+	uint16_t year;
+	uint16_t month;
+	uint16_t day;
+	uint16_t hour;
+	uint16_t minute;
+	float second;
+	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
+				&month, &day, &hour, &minute, &second);
+	if (count == 6) {
+		to->year = year;
+		to->month = month;
+		to->day = day;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+
+	// try Code B (yyyy-ddd)
+	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
+			&hour, &minute, &second);
+	if (count == 5) {
+		uint8_t tempDay;
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
+				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
+		if (result != RETURN_OK) {
+			return RETURN_FAILED;
+		}
+		to->year = year;
+		to->month = month;
+		to->day = tempDay;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+// Warning: Compiler/Linker fails ambiguously if library does not implement
+// C99 I/O
+#else
+	uint16_t year;
+	uint8_t month;
+	uint16_t day;
+	uint8_t hour;
+	uint8_t minute;
+	float second;
+    //try Code A (yyyy-mm-dd)
+    int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16
+            "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year, &month, &day,
+            &hour, &minute, &second);
+	if (count == 6) {
+		to->year = year;
+		to->month = month;
+		to->day = day;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+
+    //try Code B (yyyy-ddd)
+    count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu8
+            ":%2" SCNu8 ":%fZ", &year, &day, &hour, &minute, &second);
+	if (count == 5) {
+		uint8_t tempDay;
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
+				&tempDay);
+		if (result != RETURN_OK) {
+			return RETURN_FAILED;
+		}
+		to->year = year;
+		to->month = month;
+		to->day = tempDay;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+#endif
+
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::checkCcs(const uint8_t* time, uint8_t length) {
+	Ccs_mseconds *time_struct = (Ccs_mseconds *) time;
+
+	uint8_t additionalBytes = time_struct->pField & 0b111;
+	if ((additionalBytes == 0b111) || (length < (additionalBytes + 8))) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time_struct->pField & (1 << 3)) { //day of year variation
+		uint16_t day = (time_struct->month << 8) + time_struct->day;
+		if (day > 366) {
+			return INVALID_TIME_FORMAT;
+		}
+	} else {
+		if (time_struct->month > 12) {
+			return INVALID_TIME_FORMAT;
+		}
+		if (time_struct->day > 31) {
+			return INVALID_TIME_FORMAT;
+		}
+	}
+	if (time_struct->hour > 23) {
+		return INVALID_TIME_FORMAT;
+	}
+	if (time_struct->minute > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+	if (time_struct->second > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	uint8_t *additionalByte = &time_struct->secondEminus2;
+
+	for (; additionalBytes != 0; additionalBytes--) {
+		if (*additionalByte++ > 99) {
+			return INVALID_TIME_FORMAT;
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertDaysOfYear(uint16_t dayofYear, uint16_t year,
+		uint8_t* month, uint8_t* day) {
+	if (isLeapYear(year)) {
+		if (dayofYear > 366) {
+			return INVALID_DAY_OF_YEAR;
+		}
+	} else {
+		if (dayofYear > 365) {
+			return INVALID_DAY_OF_YEAR;
+		}
+	}
+	*month = 1;
+	if (dayofYear <= 31) {
+		*day = dayofYear;
+		return RETURN_OK;
+	}
+	*month += 1;
+	dayofYear -= 31;
+	if (isLeapYear(year)) {
+		if (dayofYear <= 29) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 29;
+	} else {
+		if (dayofYear <= 28) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 28;
+	}
+	while (*month <= 12) {
+		if (dayofYear <= 31) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 31;
+
+		if (*month == 8) {
+			continue;
+		}
+
+		if (dayofYear <= 30) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 30;
+	}
+	return INVALID_DAY_OF_YEAR;
+}
+
+bool CCSDSTime::isLeapYear(uint32_t year) {
+	if ((year % 400) == 0) {
+		return true;
+	}
+	if ((year % 100) == 0) {
+		return false;
+	}
+	if ((year % 4) == 0) {
+		return true;
+	}
+	return false;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(CDS_short* to, const timeval* from) {
+	to->pField = (CDS << 4) + 0;
+	uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
+			+ DAYS_CCSDS_TO_UNIX_EPOCH;
+	if (days > (1 << 16)) {
+		//Date is beyond year 2137
+		return TIME_DOES_NOT_FIT_FORMAT;
+	}
+	to->dayMSB = (days & 0xFF00) >> 8;
+	to->dayLSB = (days & 0xFF);
+	uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
+			+ (from->tv_usec / 1000);
+	to->msDay_hh = (msDay & 0xFF000000) >> 24;
+	to->msDay_h = (msDay & 0xFF0000) >> 16;
+	to->msDay_l = (msDay & 0xFF00) >> 8;
+	to->msDay_ll = (msDay & 0xFF);
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
+	to->pFiled = (AGENCY_DEFINED << 4) + 5;
+	to->seconds_hh = (from->tv_sec >> 24) & 0xff;
+	to->seconds_h = (from->tv_sec >> 16) & 0xff;
+	to->seconds_l = (from->tv_sec >> 8) & 0xff;
+	to->seconds_ll = (from->tv_sec >> 0) & 0xff;
+
+	//convert the µs to 2E-16 seconds
+	uint64_t temp = from->tv_usec;
+	temp = temp << 16;
+	temp = temp / 1E6;
+
+	to->subsecondsMSB = (temp >> 8) & 0xff;
+	to->subsecondsLSB = temp & 0xff;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	//We don't expect ascii here. SHOULDDO
+	uint8_t codeIdentification = (*from >> 4);
+	switch (codeIdentification) {
+	//unsupported, as Leap second correction would have to be applied
+//	case CUC_LEVEL1:
+//		return convertFromCUC(to, from, foundLength, maxLength);
+	case CDS:
+		return convertFromCDS(to, from, foundLength, maxLength);
+	case CCS:
+		return convertFromCCS(to, from, foundLength, maxLength);
+	default:
+		return UNSUPPORTED_TIME_FORMAT;
+	}
+
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	if (maxLength < 1) {
+		return INVALID_TIME_FORMAT;
+	}
+	uint8_t pField = *from;
+	from++;
+	ReturnValue_t result = convertFromCUC(to, pField, from, foundLength,
+			maxLength - 1);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		if (foundLength != NULL) {
+			*foundLength += 1;
+		}
+	}
+	return result;
+}
+
+ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
+	if ((time->month > 12) || (time->month == 0)) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->day == 0) {
+		return INVALID_TIME_FORMAT;
+	}
+	switch (time->month) {
+	case 2:
+		if (isLeapYear(time->year)) {
+			if (time->day > 29) {
+				return INVALID_TIME_FORMAT;
+			}
+		} else {
+			if (time->day > 28) {
+				return INVALID_TIME_FORMAT;
+			}
+		}
+		break;
+	case 4:
+	case 6:
+	case 9:
+	case 11:
+		if (time->day > 30) {
+			return INVALID_TIME_FORMAT;
+		}
+		break;
+	default:
+		if (time->day > 31) {
+			return INVALID_TIME_FORMAT;
+		}
+		break;
+	}
+
+	if (time->hour > 23) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->minute > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->second > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->usecond > 999999) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	return RETURN_OK;
+
+}
+
+ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+		timeval* from) {
+//This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	uint8_t pField = *from;
+	from++;
+//Check epoch
+	if (pField & 0b1000) {
+		return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
+	}
+//Check length
+	uint8_t expectedLength = 7; //Including p-Field.
+	bool extendedDays = pField & 0b100;
+	if (extendedDays) {
+		expectedLength += 1;
+	}
+	if ((pField & 0b11) == 0b01) {
+		expectedLength += 2;
+	} else if ((pField & 0b11) == 0b10) {
+		expectedLength += 4;
+	}
+	if (foundLength != NULL) {
+		*foundLength = expectedLength;
+	}
+	if (expectedLength > maxLength) {
+		return LENGTH_MISMATCH;
+	}
+//Check and count days
+	uint32_t days = 0;
+	if (extendedDays) {
+		days = (from[0] << 16) + (from[1] << 8) + from[2];
+		from += 3;
+	} else {
+		days = (from[0] << 8) + from[1];
+		from += 2;
+	}
+//Move to POSIX epoch.
+	if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
+		return INVALID_TIME_FORMAT;
+	}
+	days -= DAYS_CCSDS_TO_UNIX_EPOCH;
+	to->tv_sec = days * SECONDS_PER_DAY;
+	uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
+			+ from[3];
+	from += 4;
+	to->tv_sec += (msDay / 1000);
+	to->tv_usec = (msDay % 1000) * 1000;
+	if ((pField & 0b11) == 0b01) {
+		uint16_t usecs = (from[0] << 16) + from[1];
+		from += 2;
+		if (usecs > 999) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->tv_usec += usecs;
+	} else if ((pField & 0b11) == 0b10) {
+		uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
+				+ from[3];
+		from += 4;
+		if (picosecs > 999999) {
+			return INVALID_TIME_FORMAT;
+		}
+		//Not very useful.
+		to->tv_usec += (picosecs / 1000);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
+		const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
+	uint32_t secs = 0;
+	uint32_t subSeconds = 0;
+	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
+	uint8_t nFine = (pField & 0b11);
+	uint32_t totalLength = nCoarse + nFine;
+	if (foundLength != NULL) {
+		*foundLength = totalLength;
+	}
+	if (totalLength > maxLength) {
+		return LENGTH_MISMATCH;
+	}
+	for (int count = 0; count < nCoarse; count++) {
+		secs += *from << ((nCoarse * 8 - 8) * (1 + count));
+		from++;
+	}
+	for (int count = 0; count < nFine; count++) {
+		subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
+		from++;
+	}
+	//Move to POSIX epoch.
+	to->tv_sec = secs;
+	if (pField & 0b10000) {
+		//CCSDS-Epoch
+		to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
+	}
+	to->tv_usec = subsecondsToMicroseconds(subSeconds);
+	return RETURN_OK;
+}
+
+uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
+	uint64_t temp = (uint64_t) subseconds * 1000000
+			/ (1 << (sizeof(subseconds) * 8));
+	return temp;
+}
+
+ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	Clock::TimeOfDay_t tempTime;
+	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
+			maxLength);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	return Clock::convertTimeOfDayToTimeval(&tempTime, to);
+
+}
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index 6bb3a75c5..b9efa49cb 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -1,233 +1,233 @@
-#ifndef CCSDSTIME_H_
-#define CCSDSTIME_H_
-
-// COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
-
-#include "../timemanager/Clock.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
-
-bool operator<(const timeval& lhs, const timeval& rhs);
-bool operator<=(const timeval& lhs, const timeval& rhs);
-bool operator==(const timeval& lhs, const timeval& rhs);
-/**
- * static helper class for CCSDS Time Code Formats
- *
- * as described in CCSDS 301.0-B-3
- *
- * Still work in progress
- */
-class CCSDSTime: public HasReturnvaluesIF {
-public:
-	/**
-	 * The Time code identifications, bits 4-6 in the P-Field
-	 */
-	enum TimeCodeIdentification {
-		CCS = 0b101,
-		CUC_LEVEL1 = 0b001,
-		CUC_LEVEL2 = 0b010,
-		CDS = 0b100,
-		AGENCY_DEFINED = 0b110
-	};
-	static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
-			+ 2;
-	static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
-			+ 2;
-	static const uint8_t P_FIELD_CDS_SHORT = (CDS << 4);
-	/**
-	 * Struct for CDS day-segmented format.
-	 */
-	struct CDS_short {
-		uint8_t pField;
-		uint8_t dayMSB;
-		uint8_t dayLSB;
-		uint8_t msDay_hh;
-		uint8_t msDay_h;
-		uint8_t msDay_l;
-		uint8_t msDay_ll;
-	};
-	/**
-	 * Struct for the CCS fromat in day of month variation with max resolution
-	 */
-	struct Ccs_seconds {
-		uint8_t pField;
-		uint8_t yearMSB;
-		uint8_t yearLSB;
-		uint8_t month;
-		uint8_t day;
-		uint8_t hour;
-		uint8_t minute;
-		uint8_t second;
-	};
-
-	/**
-	 * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
-	 */
-	struct Ccs_mseconds {
-		uint8_t pField;
-		uint8_t yearMSB;
-		uint8_t yearLSB;
-		uint8_t month;
-		uint8_t day;
-		uint8_t hour;
-		uint8_t minute;
-		uint8_t second;
-		uint8_t secondEminus2;
-		uint8_t secondEminus4;
-	};
-
-	struct OBT_FLP {
-		uint8_t pFiled;
-		uint8_t seconds_hh;
-		uint8_t seconds_h;
-		uint8_t seconds_l;
-		uint8_t seconds_ll;
-		uint8_t subsecondsMSB;
-		uint8_t subsecondsLSB;
-	};
-
-	struct TimevalLess {
-		bool operator()(const timeval& lhs, const timeval& rhs) const {
-			return (lhs < rhs);
-		}
-	};
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_TIME_HELPER_CLASS;
-	static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
-			MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
-
-	/**
-	 * convert a TimeofDay struct to ccs with seconds resolution
-	 *
-	 * @param to pointer to a CCS struct
-	 * @param from pointer to a TimeOfDay Struct
-	 * @return
-	 * 		- @c RETURN_OK if OK
-	 * 		- @c INVALID_TIMECODE if not OK
-	 */
-	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
-			Clock::TimeOfDay_t const *from);
-
-	/**
-	 * Converts to CDS format from timeval.
-	 * @param to pointer to the CDS struct to generate
-	 * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
-	 * @return
-	 * 		- @c RETURN_OK as it assumes a valid timeval.
-	 */
-	static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
-
-	static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
-
-	/**
-	 * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
-	 *
-	 * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
-	 *
-	 * @param to pointer to a CCS struct
-	 * @param from pointer to a TimeOfDay Struct
-	 * @return
-	 * 		- @c RETURN_OK if OK
-	 * 		- @c INVALID_TIMECODE if not OK
-	 */
-	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
-			Clock::TimeOfDay_t const *from);
-
-	/**
-	 * SHOULDDO: can this be modified to recognize padding?
-	 * Tries to interpret a Level 1 CCSDS time code
-	 *
-	 * It assumes binary formats contain a valid P Field and recognizes the ASCII format
-	 * by the lack of one.
-	 *
-	 * @param to an empty TimeOfDay struct
-	 * @param from pointer to an CCSDS Time code
-	 * @param length length of the Time code
-	 * @return
-	 * 		- @c RETURN_OK if successful
-	 * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
-	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
-	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
-	 */
-	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint32_t length);
-
-	/**
-	 * not implemented yet
-	 *
-	 * @param to
-	 * @param from
-	 * @return
-	 */
-	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
-
-	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
-
-	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
-
-	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
-private:
-	CCSDSTime();
-	virtual ~CCSDSTime();
-	/**
-	 * checks a ccs time stream for validity
-	 *
-	 * Stream may be longer than the actual timecode
-	 *
-	 * @param time pointer to an Ccs stream
-	 * @param length length of stream
-	 * @return
-	 */
-	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
-
-	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
-
-	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
-	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
-	static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
-	static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
-			* SECONDS_PER_DAY;
-	/**
-	 * @param dayofYear
-	 * @param year
-	 * @param month
-	 * @param day
-	 */
-	static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
-			uint8_t *month, uint8_t *day);
-
-	static bool isLeapYear(uint32_t year);
-	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
-			timeval* from);
-};
-
-#endif /* CCSDSTIME_H_ */
+#ifndef CCSDSTIME_H_
+#define CCSDSTIME_H_
+
+// COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
+
+#include "../timemanager/Clock.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <stdint.h>
+
+bool operator<(const timeval& lhs, const timeval& rhs);
+bool operator<=(const timeval& lhs, const timeval& rhs);
+bool operator==(const timeval& lhs, const timeval& rhs);
+/**
+ * static helper class for CCSDS Time Code Formats
+ *
+ * as described in CCSDS 301.0-B-3
+ *
+ * Still work in progress
+ */
+class CCSDSTime: public HasReturnvaluesIF {
+public:
+	/**
+	 * The Time code identifications, bits 4-6 in the P-Field
+	 */
+	enum TimeCodeIdentification {
+		CCS = 0b101,
+		CUC_LEVEL1 = 0b001,
+		CUC_LEVEL2 = 0b010,
+		CDS = 0b100,
+		AGENCY_DEFINED = 0b110
+	};
+	static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
+			+ 2;
+	static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
+			+ 2;
+	static const uint8_t P_FIELD_CDS_SHORT = (CDS << 4);
+	/**
+	 * Struct for CDS day-segmented format.
+	 */
+	struct CDS_short {
+		uint8_t pField;
+		uint8_t dayMSB;
+		uint8_t dayLSB;
+		uint8_t msDay_hh;
+		uint8_t msDay_h;
+		uint8_t msDay_l;
+		uint8_t msDay_ll;
+	};
+	/**
+	 * Struct for the CCS fromat in day of month variation with max resolution
+	 */
+	struct Ccs_seconds {
+		uint8_t pField;
+		uint8_t yearMSB;
+		uint8_t yearLSB;
+		uint8_t month;
+		uint8_t day;
+		uint8_t hour;
+		uint8_t minute;
+		uint8_t second;
+	};
+
+	/**
+	 * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
+	 */
+	struct Ccs_mseconds {
+		uint8_t pField;
+		uint8_t yearMSB;
+		uint8_t yearLSB;
+		uint8_t month;
+		uint8_t day;
+		uint8_t hour;
+		uint8_t minute;
+		uint8_t second;
+		uint8_t secondEminus2;
+		uint8_t secondEminus4;
+	};
+
+	struct OBT_FLP {
+		uint8_t pFiled;
+		uint8_t seconds_hh;
+		uint8_t seconds_h;
+		uint8_t seconds_l;
+		uint8_t seconds_ll;
+		uint8_t subsecondsMSB;
+		uint8_t subsecondsLSB;
+	};
+
+	struct TimevalLess {
+		bool operator()(const timeval& lhs, const timeval& rhs) const {
+			return (lhs < rhs);
+		}
+	};
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_TIME_HELPER_CLASS;
+	static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
+			MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
+
+	/**
+	 * convert a TimeofDay struct to ccs with seconds resolution
+	 *
+	 * @param to pointer to a CCS struct
+	 * @param from pointer to a TimeOfDay Struct
+	 * @return
+	 * 		- @c RETURN_OK if OK
+	 * 		- @c INVALID_TIMECODE if not OK
+	 */
+	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
+			Clock::TimeOfDay_t const *from);
+
+	/**
+	 * Converts to CDS format from timeval.
+	 * @param to pointer to the CDS struct to generate
+	 * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
+	 * @return
+	 * 		- @c RETURN_OK as it assumes a valid timeval.
+	 */
+	static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
+
+	static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
+
+	/**
+	 * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
+	 *
+	 * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
+	 *
+	 * @param to pointer to a CCS struct
+	 * @param from pointer to a TimeOfDay Struct
+	 * @return
+	 * 		- @c RETURN_OK if OK
+	 * 		- @c INVALID_TIMECODE if not OK
+	 */
+	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
+			Clock::TimeOfDay_t const *from);
+
+	/**
+	 * SHOULDDO: can this be modified to recognize padding?
+	 * Tries to interpret a Level 1 CCSDS time code
+	 *
+	 * It assumes binary formats contain a valid P Field and recognizes the ASCII format
+	 * by the lack of one.
+	 *
+	 * @param to an empty TimeOfDay struct
+	 * @param from pointer to an CCSDS Time code
+	 * @param length length of the Time code
+	 * @return
+	 * 		- @c RETURN_OK if successful
+	 * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
+	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
+	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
+	 */
+	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint32_t length);
+
+	/**
+	 * not implemented yet
+	 *
+	 * @param to
+	 * @param from
+	 * @return
+	 */
+	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
+			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
+			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
+private:
+	CCSDSTime();
+	virtual ~CCSDSTime();
+	/**
+	 * checks a ccs time stream for validity
+	 *
+	 * Stream may be longer than the actual timecode
+	 *
+	 * @param time pointer to an Ccs stream
+	 * @param length length of stream
+	 * @return
+	 */
+	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
+
+	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
+
+	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
+	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
+	static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
+	static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
+			* SECONDS_PER_DAY;
+	/**
+	 * @param dayofYear
+	 * @param year
+	 * @param month
+	 * @param day
+	 */
+	static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
+			uint8_t *month, uint8_t *day);
+
+	static bool isLeapYear(uint32_t year);
+	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+			timeval* from);
+};
+
+#endif /* CCSDSTIME_H_ */
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index c7436252a..9463b5a6e 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -1,155 +1,155 @@
-#ifndef FRAMEWORK_TIMEMANAGER_CLOCK_H_
-#define FRAMEWORK_TIMEMANAGER_CLOCK_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MutexFactory.h"
-#include "../globalfunctions/timevalOperations.h"
-
-#include <cstdint>
-#include <sys/time.h>
-
-//! Don't use these for time points, type is not large enough for UNIX epoch.
-using dur_millis_t = uint32_t;
-using dur_seconds_t = double;
-
-class Clock {
-public:
-	typedef struct {
-	  uint32_t year; //!< Year, A.D.
-	  uint32_t month; //!< Month, 1 .. 12.
-	  uint32_t day; //!< Day, 1 .. 31.
-	  uint32_t hour; //!< Hour, 0 .. 23.
-	  uint32_t minute; //!< Minute, 0 .. 59.
-	  uint32_t second; //!< Second, 0 .. 59.
-	  uint32_t usecond; //!< Microseconds, 0 .. 999999
-	}   TimeOfDay_t;
-
-	/**
-	 * This method returns the number of clock ticks per second.
-	 * In RTEMS, this is typically 1000.
-	 * @return	The number of ticks.
-	 *
-	 * @deprecated, we should not worry about ticks, but only time
-	 */
-	static uint32_t getTicksPerSecond(void);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a TimeOfDay_t struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
-	 * 				is returned.
-	 */
-	static ReturnValue_t setClock(const TimeOfDay_t* time);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a timeval struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setClock(const timeval* time);
-	/**
-	 * This system call returns the current system clock in timeval format.
-	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
-	 * microseconds since an OS-defined epoch.
-	 * @param time	A pointer to a timeval struct where the current time is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_timeval(timeval* time);
-
-	/**
-	 * Get the time since boot in a timeval struct
-	 *
-	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 *
-	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
-	 */
-	static ReturnValue_t getUptime(timeval* uptime);
-
-	static timeval getUptime();
-
-	/**
-	 * Get the time since boot in milliseconds
-	 *
-	 * This value can overflow! Still, it can be used to calculate time intervalls
-	 * between two calls up to 49 days by always using uint32_t in the calculation
-	 *
-	 * @param ms uptime in ms
-	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getUptime(uint32_t* uptimeMs);
-
-	/**
-	 * Returns the time in microseconds since an OS-defined epoch.
-	 * The time is returned in a 64 bit unsigned integer.
-	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_usecs(uint64_t* time);
-	/**
-	 * Returns the time in a TimeOfDay_t struct.
-	 * @param time A pointer to a TimeOfDay_t struct.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
-
-	/**
-	 * Converts a time of day struct to POSIX seconds.
-	 * @param time The time of day as input
-	 * @param timeval The corresponding seconds since the epoch.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-			timeval* to);
-
-	/**
-	 * Converts a time represented as seconds and subseconds since unix epoch to days since J2000
-	 *
-	 * @param time seconds since unix epoch
-	 * @param[out] JD2000 days since J2000
-	 * @return \c RETURN_OK
-	 */
-	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
-
-	/**
-	 * Calculates and adds the offset between UTC and TT
-	 *
-	 * Depends on the leap seconds to be set correctly.
-	 *
-	 * @param utc timeval, corresponding to UTC time
-	 * @param[out] tt timeval, corresponding to Terrestial Time
-	 * @return \c RETURN_OK on success, \c RETURN_FAILED if leapSeconds are not set
-	 */
-	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
-
-	/**
-	 * Set the Leap Seconds since 1972
-	 *
-	 * @param leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
-
-	/**
-	 * Get the Leap Seconds since 1972
-	 *
-	 * Must be set before!
-	 *
-	 * @param[out] leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
-
-	/**
-	 * Function to check and create the Mutex for the clock
-	 * @return \c RETURN_OK on success. Otherwise \c RETURN_FAILED if not able to create one
-	 */
-	static ReturnValue_t checkOrCreateClockMutex();
-
-private:
-	static MutexIF* timeMutex;
-	static uint16_t leapSeconds;
-};
-
-
-#endif /* FRAMEWORK_TIMEMANAGER_CLOCK_H_ */
+#ifndef FRAMEWORK_TIMEMANAGER_CLOCK_H_
+#define FRAMEWORK_TIMEMANAGER_CLOCK_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MutexFactory.h"
+#include "../globalfunctions/timevalOperations.h"
+
+#include <cstdint>
+#include <sys/time.h>
+
+//! Don't use these for time points, type is not large enough for UNIX epoch.
+using dur_millis_t = uint32_t;
+using dur_seconds_t = double;
+
+class Clock {
+public:
+	typedef struct {
+	  uint32_t year; //!< Year, A.D.
+	  uint32_t month; //!< Month, 1 .. 12.
+	  uint32_t day; //!< Day, 1 .. 31.
+	  uint32_t hour; //!< Hour, 0 .. 23.
+	  uint32_t minute; //!< Minute, 0 .. 59.
+	  uint32_t second; //!< Second, 0 .. 59.
+	  uint32_t usecond; //!< Microseconds, 0 .. 999999
+	}   TimeOfDay_t;
+
+	/**
+	 * This method returns the number of clock ticks per second.
+	 * In RTEMS, this is typically 1000.
+	 * @return	The number of ticks.
+	 *
+	 * @deprecated, we should not worry about ticks, but only time
+	 */
+	static uint32_t getTicksPerSecond(void);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a TimeOfDay_t struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
+	 * 				is returned.
+	 */
+	static ReturnValue_t setClock(const TimeOfDay_t* time);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a timeval struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setClock(const timeval* time);
+	/**
+	 * This system call returns the current system clock in timeval format.
+	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
+	 * microseconds since an OS-defined epoch.
+	 * @param time	A pointer to a timeval struct where the current time is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_timeval(timeval* time);
+
+	/**
+	 * Get the time since boot in a timeval struct
+	 *
+	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 *
+	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
+	 */
+	static ReturnValue_t getUptime(timeval* uptime);
+
+	static timeval getUptime();
+
+	/**
+	 * Get the time since boot in milliseconds
+	 *
+	 * This value can overflow! Still, it can be used to calculate time intervalls
+	 * between two calls up to 49 days by always using uint32_t in the calculation
+	 *
+	 * @param ms uptime in ms
+	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getUptime(uint32_t* uptimeMs);
+
+	/**
+	 * Returns the time in microseconds since an OS-defined epoch.
+	 * The time is returned in a 64 bit unsigned integer.
+	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_usecs(uint64_t* time);
+	/**
+	 * Returns the time in a TimeOfDay_t struct.
+	 * @param time A pointer to a TimeOfDay_t struct.
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
+
+	/**
+	 * Converts a time of day struct to POSIX seconds.
+	 * @param time The time of day as input
+	 * @param timeval The corresponding seconds since the epoch.
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+			timeval* to);
+
+	/**
+	 * Converts a time represented as seconds and subseconds since unix epoch to days since J2000
+	 *
+	 * @param time seconds since unix epoch
+	 * @param[out] JD2000 days since J2000
+	 * @return \c RETURN_OK
+	 */
+	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
+
+	/**
+	 * Calculates and adds the offset between UTC and TT
+	 *
+	 * Depends on the leap seconds to be set correctly.
+	 *
+	 * @param utc timeval, corresponding to UTC time
+	 * @param[out] tt timeval, corresponding to Terrestial Time
+	 * @return \c RETURN_OK on success, \c RETURN_FAILED if leapSeconds are not set
+	 */
+	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
+
+	/**
+	 * Set the Leap Seconds since 1972
+	 *
+	 * @param leapSeconds_
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
+
+	/**
+	 * Get the Leap Seconds since 1972
+	 *
+	 * Must be set before!
+	 *
+	 * @param[out] leapSeconds_
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
+
+	/**
+	 * Function to check and create the Mutex for the clock
+	 * @return \c RETURN_OK on success. Otherwise \c RETURN_FAILED if not able to create one
+	 */
+	static ReturnValue_t checkOrCreateClockMutex();
+
+private:
+	static MutexIF* timeMutex;
+	static uint16_t leapSeconds;
+};
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_CLOCK_H_ */
diff --git a/timemanager/Countdown.cpp b/timemanager/Countdown.cpp
index 5b019f2b0..95cce029a 100644
--- a/timemanager/Countdown.cpp
+++ b/timemanager/Countdown.cpp
@@ -1,45 +1,45 @@
-/**
- * @file	Countdown.cpp
- * @brief	This file defines the Countdown class.
- * @date	21.03.2013
- * @author	baetz
- */
-
-
-#include "../timemanager/Countdown.h"
-
-Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) {
-}
-
-Countdown::~Countdown() {
-}
-
-ReturnValue_t Countdown::setTimeout(uint32_t miliseconds) {
-	ReturnValue_t return_value = Clock::getUptime( &startTime );
-	timeout = miliseconds;
-	return return_value;
-}
-
-bool Countdown::hasTimedOut() const {
-	uint32_t current_time;
-	Clock::getUptime( &current_time );
-	if ( uint32_t(current_time - startTime) >= timeout) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-bool Countdown::isBusy() const {
-	return !hasTimedOut();
-}
-
-ReturnValue_t Countdown::resetTimer() {
-	return setTimeout(timeout);
-}
-
-void Countdown::timeOut() {
-	uint32_t current_time;
-		Clock::getUptime( &current_time );
-	startTime= current_time - timeout;
-}
+/**
+ * @file	Countdown.cpp
+ * @brief	This file defines the Countdown class.
+ * @date	21.03.2013
+ * @author	baetz
+ */
+
+
+#include "../timemanager/Countdown.h"
+
+Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) {
+}
+
+Countdown::~Countdown() {
+}
+
+ReturnValue_t Countdown::setTimeout(uint32_t miliseconds) {
+	ReturnValue_t return_value = Clock::getUptime( &startTime );
+	timeout = miliseconds;
+	return return_value;
+}
+
+bool Countdown::hasTimedOut() const {
+	uint32_t current_time;
+	Clock::getUptime( &current_time );
+	if ( uint32_t(current_time - startTime) >= timeout) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+bool Countdown::isBusy() const {
+	return !hasTimedOut();
+}
+
+ReturnValue_t Countdown::resetTimer() {
+	return setTimeout(timeout);
+}
+
+void Countdown::timeOut() {
+	uint32_t current_time;
+		Clock::getUptime( &current_time );
+	startTime= current_time - timeout;
+}
diff --git a/timemanager/Countdown.h b/timemanager/Countdown.h
index 741ab0f81..20380e715 100644
--- a/timemanager/Countdown.h
+++ b/timemanager/Countdown.h
@@ -1,31 +1,31 @@
-/**
- * @file	Countdown.h
- * @brief	This file defines the Countdown class.
- * @date	21.03.2013
- * @author	baetz
- */
-
-#ifndef COUNTDOWN_H_
-#define COUNTDOWN_H_
-
-#include "../timemanager/Clock.h"
-
-class Countdown {
-private:
-	uint32_t startTime;
-public:
-	uint32_t timeout;
-	Countdown(uint32_t initialTimeout = 0);
-	~Countdown();
-	ReturnValue_t setTimeout(uint32_t miliseconds);
-
-	bool hasTimedOut() const;
-
-	bool isBusy() const;
-
-	ReturnValue_t resetTimer(); //!< Use last set timeout value and restart timer.
-
-	void timeOut(); //!< Make hasTimedOut() return true
-};
-
-#endif /* COUNTDOWN_H_ */
+/**
+ * @file	Countdown.h
+ * @brief	This file defines the Countdown class.
+ * @date	21.03.2013
+ * @author	baetz
+ */
+
+#ifndef COUNTDOWN_H_
+#define COUNTDOWN_H_
+
+#include "../timemanager/Clock.h"
+
+class Countdown {
+private:
+	uint32_t startTime;
+public:
+	uint32_t timeout;
+	Countdown(uint32_t initialTimeout = 0);
+	~Countdown();
+	ReturnValue_t setTimeout(uint32_t miliseconds);
+
+	bool hasTimedOut() const;
+
+	bool isBusy() const;
+
+	ReturnValue_t resetTimer(); //!< Use last set timeout value and restart timer.
+
+	void timeOut(); //!< Make hasTimedOut() return true
+};
+
+#endif /* COUNTDOWN_H_ */
diff --git a/timemanager/ReceivesTimeInfoIF.h b/timemanager/ReceivesTimeInfoIF.h
index 09915e83f..680e94f2d 100644
--- a/timemanager/ReceivesTimeInfoIF.h
+++ b/timemanager/ReceivesTimeInfoIF.h
@@ -1,32 +1,32 @@
-/**
- * @file	ReceivesTimeInfoIF.h
- * @brief	This file defines the ReceivesTimeInfoIF class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#ifndef RECEIVESTIMEINFOIF_H_
-#define RECEIVESTIMEINFOIF_H_
-#include "../ipc/MessageQueueSenderIF.h"
-
-/**
- * This is a Interface for classes that receive timing information
- * with the help of a dedicated message queue.
- */
-class ReceivesTimeInfoIF {
-public:
-	/**
-	 * Returns the id of the queue which receives the timing information.
-	 * @return Queue id of the timing queue.
-	 */
-	virtual MessageQueueId_t getTimeReceptionQueue() const = 0;
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~ReceivesTimeInfoIF() {
-	}
-
-};
-
-
-#endif /* RECEIVESTIMEINFOIF_H_ */
+/**
+ * @file	ReceivesTimeInfoIF.h
+ * @brief	This file defines the ReceivesTimeInfoIF class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#ifndef RECEIVESTIMEINFOIF_H_
+#define RECEIVESTIMEINFOIF_H_
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * This is a Interface for classes that receive timing information
+ * with the help of a dedicated message queue.
+ */
+class ReceivesTimeInfoIF {
+public:
+	/**
+	 * Returns the id of the queue which receives the timing information.
+	 * @return Queue id of the timing queue.
+	 */
+	virtual MessageQueueId_t getTimeReceptionQueue() const = 0;
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~ReceivesTimeInfoIF() {
+	}
+
+};
+
+
+#endif /* RECEIVESTIMEINFOIF_H_ */
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index bf69d3ce1..637c50780 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -1,57 +1,57 @@
-#include "../timemanager/Stopwatch.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <iomanip>
-
-Stopwatch::Stopwatch(bool displayOnDestruction,
-        StopwatchDisplayMode displayMode): displayOnDestruction(
-        displayOnDestruction), displayMode(displayMode) {
-    // Measures start time on initialization.
-    Clock::getClock_timeval(&startTime);
-}
-
-void Stopwatch::start() {
-    Clock::getClock_timeval(&startTime);
-}
-
-dur_millis_t Stopwatch::stop() {
-    stopInternal();
-    return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
-}
-
-dur_seconds_t Stopwatch::stopSeconds() {
-    stopInternal();
-    return timevalOperations::toDouble(elapsedTime);
-}
-
-void Stopwatch::display() {
-    if(displayMode == StopwatchDisplayMode::MILLIS) {
-        sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
-                elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
-    }
-    else if(displayMode == StopwatchDisplayMode::SECONDS) {
-        sif::info <<"Stopwatch: Operation took "  << std::setprecision(3)
-             << std::fixed << timevalOperations::toDouble(elapsedTime)
-             << " seconds" << std::endl;
-    }
-}
-
-Stopwatch::~Stopwatch() {
-    if(displayOnDestruction) {
-        stopInternal();
-        display();
-    }
-}
-
-void Stopwatch::setDisplayMode(StopwatchDisplayMode displayMode) {
-    this->displayMode = displayMode;
-}
-
-StopwatchDisplayMode Stopwatch::getDisplayMode() const {
-    return displayMode;
-}
-
-void Stopwatch::stopInternal() {
-	timeval endTime;
-	Clock::getClock_timeval(&endTime);
-    elapsedTime = endTime - startTime;
-}
+#include "../timemanager/Stopwatch.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <iomanip>
+
+Stopwatch::Stopwatch(bool displayOnDestruction,
+        StopwatchDisplayMode displayMode): displayOnDestruction(
+        displayOnDestruction), displayMode(displayMode) {
+    // Measures start time on initialization.
+    Clock::getClock_timeval(&startTime);
+}
+
+void Stopwatch::start() {
+    Clock::getClock_timeval(&startTime);
+}
+
+dur_millis_t Stopwatch::stop() {
+    stopInternal();
+    return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
+}
+
+dur_seconds_t Stopwatch::stopSeconds() {
+    stopInternal();
+    return timevalOperations::toDouble(elapsedTime);
+}
+
+void Stopwatch::display() {
+    if(displayMode == StopwatchDisplayMode::MILLIS) {
+        sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
+                elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
+    }
+    else if(displayMode == StopwatchDisplayMode::SECONDS) {
+        sif::info <<"Stopwatch: Operation took "  << std::setprecision(3)
+             << std::fixed << timevalOperations::toDouble(elapsedTime)
+             << " seconds" << std::endl;
+    }
+}
+
+Stopwatch::~Stopwatch() {
+    if(displayOnDestruction) {
+        stopInternal();
+        display();
+    }
+}
+
+void Stopwatch::setDisplayMode(StopwatchDisplayMode displayMode) {
+    this->displayMode = displayMode;
+}
+
+StopwatchDisplayMode Stopwatch::getDisplayMode() const {
+    return displayMode;
+}
+
+void Stopwatch::stopInternal() {
+	timeval endTime;
+	Clock::getClock_timeval(&endTime);
+    elapsedTime = endTime - startTime;
+}
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 30735b2c6..191929dc1 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -1,71 +1,71 @@
-#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
-#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
-#include "../timemanager/Clock.h"
-
-enum class StopwatchDisplayMode {
-    MILLIS,
-    SECONDS
-};
-
-/**
- * @brief 	Simple Stopwatch implementation to measure elapsed time
- * @details
- * This class can be used to measure elapsed times. It also displays elapsed
- * times automatically on destruction if not explicitely deactivated in the
- * constructor. The default time format is the elapsed time in miliseconds
- * in seconds as a double.
- * @author 	R. Mueller
- */
-class Stopwatch {
-public:
-    /**
-     * Default constructor. Call "Stopwatch stopwatch" without brackets if
-     * no parameters are required!
-     * @param displayOnDestruction If set to true, displays measured time on
-     *        object destruction
-     * @param displayMode Display format is either MS rounded or MS as double
-     *        format
-     * @param outputPrecision If using double format, specify precision here.
-     */
-    Stopwatch(bool displayOnDestruction = true, StopwatchDisplayMode displayMode
-              = StopwatchDisplayMode::MILLIS);
-    virtual~ Stopwatch();
-
-    /**
-     * Caches the start time
-     */
-    void start();
-
-    /**
-     * Calculates the elapsed time since start and returns it
-     * @return elapsed time in milliseconds (rounded)
-     */
-    dur_millis_t stop();
-    /**
-     * Calculates the elapsed time since start and returns it
-     * @return elapsed time in seconds (double precision)
-     */
-    dur_seconds_t stopSeconds();
-
-    /**
-     * Displays the elapsed times on the osstream, depending on internal display
-     * mode.
-     */
-    void display();
-
-    StopwatchDisplayMode getDisplayMode() const;
-    void setDisplayMode(StopwatchDisplayMode displayMode);
-    bool displayOnDestruction = true;
-private:
-    timeval startTime {0, 0};
-    timeval elapsedTime {0, 0};
-
-    StopwatchDisplayMode displayMode = StopwatchDisplayMode::MILLIS;
-
-    void stopInternal();
-};
-
-
-
-
-#endif /* FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ */
+#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#include "../timemanager/Clock.h"
+
+enum class StopwatchDisplayMode {
+    MILLIS,
+    SECONDS
+};
+
+/**
+ * @brief 	Simple Stopwatch implementation to measure elapsed time
+ * @details
+ * This class can be used to measure elapsed times. It also displays elapsed
+ * times automatically on destruction if not explicitely deactivated in the
+ * constructor. The default time format is the elapsed time in miliseconds
+ * in seconds as a double.
+ * @author 	R. Mueller
+ */
+class Stopwatch {
+public:
+    /**
+     * Default constructor. Call "Stopwatch stopwatch" without brackets if
+     * no parameters are required!
+     * @param displayOnDestruction If set to true, displays measured time on
+     *        object destruction
+     * @param displayMode Display format is either MS rounded or MS as double
+     *        format
+     * @param outputPrecision If using double format, specify precision here.
+     */
+    Stopwatch(bool displayOnDestruction = true, StopwatchDisplayMode displayMode
+              = StopwatchDisplayMode::MILLIS);
+    virtual~ Stopwatch();
+
+    /**
+     * Caches the start time
+     */
+    void start();
+
+    /**
+     * Calculates the elapsed time since start and returns it
+     * @return elapsed time in milliseconds (rounded)
+     */
+    dur_millis_t stop();
+    /**
+     * Calculates the elapsed time since start and returns it
+     * @return elapsed time in seconds (double precision)
+     */
+    dur_seconds_t stopSeconds();
+
+    /**
+     * Displays the elapsed times on the osstream, depending on internal display
+     * mode.
+     */
+    void display();
+
+    StopwatchDisplayMode getDisplayMode() const;
+    void setDisplayMode(StopwatchDisplayMode displayMode);
+    bool displayOnDestruction = true;
+private:
+    timeval startTime {0, 0};
+    timeval elapsedTime {0, 0};
+
+    StopwatchDisplayMode displayMode = StopwatchDisplayMode::MILLIS;
+
+    void stopInternal();
+};
+
+
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ */
diff --git a/timemanager/TimeMessage.cpp b/timemanager/TimeMessage.cpp
index a60718a43..6e8dcd609 100644
--- a/timemanager/TimeMessage.cpp
+++ b/timemanager/TimeMessage.cpp
@@ -1,37 +1,37 @@
-/**
- * @file	TimeMessage.cpp
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#include "../timemanager/TimeMessage.h"
-
-TimeMessage::TimeMessage() {
-	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
-}
-
-TimeMessage::TimeMessage(timeval setTime, uint32_t CounterValue) {
-	memcpy (this->getData(), &setTime, sizeof(timeval));
-	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
-	memcpy (this->getData() + sizeof(timeval), &CounterValue, sizeof(uint32_t));
-}
-
-TimeMessage::~TimeMessage() {
-}
-
-timeval TimeMessage::getTime() {
-	timeval temp;
-	memcpy( &temp, this->getData(), sizeof(timeval));
-	return temp;
-}
-
-uint32_t TimeMessage::getCounterValue() {
-	uint32_t temp;
-	memcpy ( &temp, this->getData() + sizeof(timeval), sizeof(uint32_t));
-	return temp;
-}
-
-size_t TimeMessage::getMinimumMessageSize() {
-	return this->MAX_SIZE;
-}
+/**
+ * @file	TimeMessage.cpp
+ * @brief	This file defines the TimeMessage class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#include "../timemanager/TimeMessage.h"
+
+TimeMessage::TimeMessage() {
+	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
+}
+
+TimeMessage::TimeMessage(timeval setTime, uint32_t CounterValue) {
+	memcpy (this->getData(), &setTime, sizeof(timeval));
+	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
+	memcpy (this->getData() + sizeof(timeval), &CounterValue, sizeof(uint32_t));
+}
+
+TimeMessage::~TimeMessage() {
+}
+
+timeval TimeMessage::getTime() {
+	timeval temp;
+	memcpy( &temp, this->getData(), sizeof(timeval));
+	return temp;
+}
+
+uint32_t TimeMessage::getCounterValue() {
+	uint32_t temp;
+	memcpy ( &temp, this->getData() + sizeof(timeval), sizeof(uint32_t));
+	return temp;
+}
+
+size_t TimeMessage::getMinimumMessageSize() {
+	return this->MAX_SIZE;
+}
diff --git a/timemanager/TimeMessage.h b/timemanager/TimeMessage.h
index 1e440e5d3..bb83708cd 100644
--- a/timemanager/TimeMessage.h
+++ b/timemanager/TimeMessage.h
@@ -1,56 +1,56 @@
-/**
- * @file	TimeMessage.h
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#ifndef TIMEMESSAGE_H_
-#define TIMEMESSAGE_H_
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../timemanager/Clock.h"
-#include <cstring>
-
-class TimeMessage : public MessageQueueMessage {
-protected:
-	/**
-	 * @brief	This call always returns the same fixed size of the message.
-	 * @return	Returns HEADER_SIZE + \c sizeof(timeval) + sizeof(uint32_t).
-	 */
-	size_t getMinimumMessageSize();
-public:
-
-	/**
-	 * @ brief the size of a TimeMessage
-	 */
-	static const uint32_t MAX_SIZE = HEADER_SIZE + sizeof(timeval) + sizeof(uint32_t);
-
-	/**
-	 * @brief	In the default constructor, only the message_size is set.
-	 */
-	TimeMessage();
-	/**
-	 * @brief	With this constructor, the passed time information is directly put
-	 * 			into the message.
-	 * @param 	setTime The time information to put into the message.
-	 * @param 	counterValue The counterValue to put into the message (GPS PPS).
-	 */
-	TimeMessage( timeval setTime, uint32_t counterValue = 0 );
-	/**
-	 * @brief	The class's destructor is empty.
-	 */
-	~TimeMessage();
-	/**
-	 * @brief	This getter returns the time information in timeval format.
-	 * @return	Returns the time stored in this packet.
-	 */
-	timeval getTime();
-	/**
-	 * @brief 	This getter returns the CounterValue in uint32_t format.
-	 * @return 	Returns the CounterValue stored in this packet.
-	 */
-	uint32_t getCounterValue();
-};
-
-#endif /* TIMEMESSAGE_H_ */
+/**
+ * @file	TimeMessage.h
+ * @brief	This file defines the TimeMessage class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#ifndef TIMEMESSAGE_H_
+#define TIMEMESSAGE_H_
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../timemanager/Clock.h"
+#include <cstring>
+
+class TimeMessage : public MessageQueueMessage {
+protected:
+	/**
+	 * @brief	This call always returns the same fixed size of the message.
+	 * @return	Returns HEADER_SIZE + \c sizeof(timeval) + sizeof(uint32_t).
+	 */
+	size_t getMinimumMessageSize();
+public:
+
+	/**
+	 * @ brief the size of a TimeMessage
+	 */
+	static const uint32_t MAX_SIZE = HEADER_SIZE + sizeof(timeval) + sizeof(uint32_t);
+
+	/**
+	 * @brief	In the default constructor, only the message_size is set.
+	 */
+	TimeMessage();
+	/**
+	 * @brief	With this constructor, the passed time information is directly put
+	 * 			into the message.
+	 * @param 	setTime The time information to put into the message.
+	 * @param 	counterValue The counterValue to put into the message (GPS PPS).
+	 */
+	TimeMessage( timeval setTime, uint32_t counterValue = 0 );
+	/**
+	 * @brief	The class's destructor is empty.
+	 */
+	~TimeMessage();
+	/**
+	 * @brief	This getter returns the time information in timeval format.
+	 * @return	Returns the time stored in this packet.
+	 */
+	timeval getTime();
+	/**
+	 * @brief 	This getter returns the CounterValue in uint32_t format.
+	 * @return 	Returns the CounterValue stored in this packet.
+	 */
+	uint32_t getCounterValue();
+};
+
+#endif /* TIMEMESSAGE_H_ */
diff --git a/timemanager/TimeStamperIF.h b/timemanager/TimeStamperIF.h
index 49e0ec18f..bdc5e7e37 100644
--- a/timemanager/TimeStamperIF.h
+++ b/timemanager/TimeStamperIF.h
@@ -1,24 +1,24 @@
-#ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
-#define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-/**
- * A class implementing this IF provides facilities to add a time stamp to the
- * buffer provided.
- * Implementors need to ensure that calling the method is thread-safe, i.e.
- * addTimeStamp may be called in parallel from a different context.
- */
-class TimeStamperIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TIME_STAMPER_IF;
-	static const ReturnValue_t BAD_TIMESTAMP = MAKE_RETURN_CODE(1);
-
-	static const uint8_t MISSION_TIMESTAMP_SIZE = 8; //!< This is a mission-specific constant and determines the total size reserved for timestamps.
-	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize) = 0;
-	virtual ~TimeStamperIF() {}
-};
-
-
-
-#endif /* FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ */
+#ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+#define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * A class implementing this IF provides facilities to add a time stamp to the
+ * buffer provided.
+ * Implementors need to ensure that calling the method is thread-safe, i.e.
+ * addTimeStamp may be called in parallel from a different context.
+ */
+class TimeStamperIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TIME_STAMPER_IF;
+	static const ReturnValue_t BAD_TIMESTAMP = MAKE_RETURN_CODE(1);
+
+	static const uint8_t MISSION_TIMESTAMP_SIZE = 8; //!< This is a mission-specific constant and determines the total size reserved for timestamps.
+	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize) = 0;
+	virtual ~TimeStamperIF() {}
+};
+
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ */
diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index 0e20a314e..bfabdd31d 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -1,95 +1,95 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../objectmanager/SystemObjectIF.h"
-#include "../parameters/HasParametersIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../timemanager/Clock.h"
-class TmPacketInformation;
-class TmPacketMinimal;
-class SpacePacketBase;
-class ApidSsc;
-
-class TmStoreBackendIF : public HasParametersIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_BACKEND_IF;
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t NULL_REQUESTED = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t DUMP_ERROR = MAKE_RETURN_CODE(7);
-	static const ReturnValue_t CRC_ERROR = MAKE_RETURN_CODE(8);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(9);
-	static const ReturnValue_t IDLE_PACKET_FOUND = MAKE_RETURN_CODE(10);
-	static const ReturnValue_t TELECOMMAND_FOUND = MAKE_RETURN_CODE(11);
-	static const ReturnValue_t NO_PUS_A_TM = MAKE_RETURN_CODE(12);
-	static const ReturnValue_t TOO_SMALL = MAKE_RETURN_CODE(13);
-	static const ReturnValue_t BLOCK_NOT_FOUND = MAKE_RETURN_CODE(14);
-	static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
-	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, SEVERITY::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, SEVERITY::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_READ_FAILED = MAKE_EVENT(3, SEVERITY::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
-	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, SEVERITY::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
-	static const Event STORING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, SEVERITY::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, SEVERITY::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, SEVERITY::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
-	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, SEVERITY::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
-	static const Event STORE_INITIALIZE = MAKE_EVENT(10, SEVERITY::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event INIT_DONE = MAKE_EVENT(11, SEVERITY::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event DUMP_FINISHED = MAKE_EVENT(12, SEVERITY::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FINISHED = MAKE_EVENT(13, SEVERITY::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FAILED = MAKE_EVENT(14, SEVERITY::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
-	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
-
-	virtual ~TmStoreBackendIF() {}
-
-	/**
-	 * What do I need to implement here ?
-	 * @param opCode
-	 * @return
-	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
-	virtual ReturnValue_t initialize() = 0;
-
-	/**
-	 * Implement the storage of TM packets to mass memory
-	 * @param tmPacket
-	 * @return
-	 */
-	virtual ReturnValue_t storePacket(TmPacketMinimal* tmPacket) = 0;
-	virtual ReturnValue_t setFetchLimitTime(const timeval* loverLimit, const timeval* upperLimit) = 0;
-	virtual ReturnValue_t setFetchLimitBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
-	virtual ReturnValue_t fetchPackets(bool fromBegin = false) = 0;
-	virtual ReturnValue_t initializeStore(object_id_t dumpTarget) = 0;
-	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
-
-	/**
-	 * TODO: Adapt for file management system?
-	 * @param startAddress
-	 * @param endAddress
-	 * @return
-	 */
-	virtual ReturnValue_t deleteBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
-	virtual ReturnValue_t deleteTime(const timeval* timeUntil,
-				uint32_t* deletedPackets) = 0;
-	virtual void resetStore(bool clearStore, bool resetWrite, bool resetRead) = 0;
-	virtual bool isReady() = 0;
-	virtual uint32_t availableData() = 0;
-	virtual float getPercentageFilled() const = 0;
-	virtual uint32_t getStoredPacketsCount() const = 0;
-	virtual TmPacketInformation* getOldestPacket() = 0;
-	virtual TmPacketInformation* getYoungestPacket() = 0;
-	virtual float getDataRate() = 0;
-
-};
-
-
-
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
+#ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
+#define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../parameters/HasParametersIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../timemanager/Clock.h"
+class TmPacketInformation;
+class TmPacketMinimal;
+class SpacePacketBase;
+class ApidSsc;
+
+class TmStoreBackendIF : public HasParametersIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_BACKEND_IF;
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t NULL_REQUESTED = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t DUMP_ERROR = MAKE_RETURN_CODE(7);
+	static const ReturnValue_t CRC_ERROR = MAKE_RETURN_CODE(8);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(9);
+	static const ReturnValue_t IDLE_PACKET_FOUND = MAKE_RETURN_CODE(10);
+	static const ReturnValue_t TELECOMMAND_FOUND = MAKE_RETURN_CODE(11);
+	static const ReturnValue_t NO_PUS_A_TM = MAKE_RETURN_CODE(12);
+	static const ReturnValue_t TOO_SMALL = MAKE_RETURN_CODE(13);
+	static const ReturnValue_t BLOCK_NOT_FOUND = MAKE_RETURN_CODE(14);
+	static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
+	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, SEVERITY::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, SEVERITY::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_READ_FAILED = MAKE_EVENT(3, SEVERITY::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
+	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, SEVERITY::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
+	static const Event STORING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, SEVERITY::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, SEVERITY::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, SEVERITY::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
+	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, SEVERITY::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
+	static const Event STORE_INITIALIZE = MAKE_EVENT(10, SEVERITY::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event INIT_DONE = MAKE_EVENT(11, SEVERITY::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event DUMP_FINISHED = MAKE_EVENT(12, SEVERITY::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FINISHED = MAKE_EVENT(13, SEVERITY::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FAILED = MAKE_EVENT(14, SEVERITY::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
+	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
+
+	virtual ~TmStoreBackendIF() {}
+
+	/**
+	 * What do I need to implement here ?
+	 * @param opCode
+	 * @return
+	 */
+	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
+	virtual ReturnValue_t initialize() = 0;
+
+	/**
+	 * Implement the storage of TM packets to mass memory
+	 * @param tmPacket
+	 * @return
+	 */
+	virtual ReturnValue_t storePacket(TmPacketMinimal* tmPacket) = 0;
+	virtual ReturnValue_t setFetchLimitTime(const timeval* loverLimit, const timeval* upperLimit) = 0;
+	virtual ReturnValue_t setFetchLimitBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
+	virtual ReturnValue_t fetchPackets(bool fromBegin = false) = 0;
+	virtual ReturnValue_t initializeStore(object_id_t dumpTarget) = 0;
+	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
+
+	/**
+	 * TODO: Adapt for file management system?
+	 * @param startAddress
+	 * @param endAddress
+	 * @return
+	 */
+	virtual ReturnValue_t deleteBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
+	virtual ReturnValue_t deleteTime(const timeval* timeUntil,
+				uint32_t* deletedPackets) = 0;
+	virtual void resetStore(bool clearStore, bool resetWrite, bool resetRead) = 0;
+	virtual bool isReady() = 0;
+	virtual uint32_t availableData() = 0;
+	virtual float getPercentageFilled() const = 0;
+	virtual uint32_t getStoredPacketsCount() const = 0;
+	virtual TmPacketInformation* getOldestPacket() = 0;
+	virtual TmPacketInformation* getYoungestPacket() = 0;
+	virtual float getDataRate() = 0;
+
+};
+
+
+
+#endif /* PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
diff --git a/tmstorage/TmStoreFrontendIF.h b/tmstorage/TmStoreFrontendIF.h
index 7a2b3c9ed..e0a7e0782 100644
--- a/tmstorage/TmStoreFrontendIF.h
+++ b/tmstorage/TmStoreFrontendIF.h
@@ -1,63 +1,63 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tmstorage/TmStorePackets.h"
-#include "../ipc/MessageQueueSenderIF.h"
-class TmPacketMinimal;
-class SpacePacketBase;
-class TmStoreBackendIF;
-
-class TmStoreFrontendIF {
-public:
-	virtual TmStoreBackendIF* getBackend() const = 0;
-
-	/**
-	 * What do I need to implement here?
-	 * This is propably used by PUS Service 15 so we should propably check for messages..
-	 * Provide base implementation?
-	 * @param opCode
-	 * @return
-	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
-	/**
-	 * Callback from the back-end to indicate a certain packet was received.
-	 * front-end takes care of discarding/downloading the packet.
-	 * @param packet	Pointer to the newly received Space Packet.
-	 * @param address	Start address of the packet found
-	 * @param isLastPacket	Indicates if no more packets can be fetched.
-	 * @return	If more packets shall be fetched, RETURN_OK must be returned.
-	 * 			Any other code stops fetching packets.
-	 */
-	virtual ReturnValue_t packetRetrieved(TmPacketMinimal* packet, uint32_t address) = 0;
-	virtual void noMorePacketsInStore() = 0;
-	virtual void handleRetrievalFailed(ReturnValue_t errorCode, uint32_t parameter1 = 0, uint32_t parameter2 = 0) = 0;
-	/**
-	 * To get the queue where commands shall be sent.
-	 * @return	Id of command queue.
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ReturnValue_t fetchPackets(ApidSsc start, ApidSsc end) = 0;
-	virtual ReturnValue_t deletePackets(ApidSsc upTo) = 0;
-	virtual ReturnValue_t checkPacket(SpacePacketBase* tmPacket) = 0;
-	virtual bool isEnabled() const = 0;
-	virtual void setEnabled(bool enabled) = 0;
-	virtual void resetDownlinkedPacketCount() = 0;
-	virtual ReturnValue_t setDumpTarget(object_id_t dumpTarget) = 0;
-	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_FRONTEND_IF;
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LAST_PACKET_FOUND = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t STOP_FETCH = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TM_CHANNEL_FULL = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t NOT_STORED = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t ALL_DELETED = MAKE_RETURN_CODE(7);
-	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(8);
-	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(9);
-	virtual ~TmStoreFrontendIF() {
-	}
-};
-
-
-
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
+#ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+#define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tmstorage/TmStorePackets.h"
+#include "../ipc/MessageQueueSenderIF.h"
+class TmPacketMinimal;
+class SpacePacketBase;
+class TmStoreBackendIF;
+
+class TmStoreFrontendIF {
+public:
+	virtual TmStoreBackendIF* getBackend() const = 0;
+
+	/**
+	 * What do I need to implement here?
+	 * This is propably used by PUS Service 15 so we should propably check for messages..
+	 * Provide base implementation?
+	 * @param opCode
+	 * @return
+	 */
+	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
+	/**
+	 * Callback from the back-end to indicate a certain packet was received.
+	 * front-end takes care of discarding/downloading the packet.
+	 * @param packet	Pointer to the newly received Space Packet.
+	 * @param address	Start address of the packet found
+	 * @param isLastPacket	Indicates if no more packets can be fetched.
+	 * @return	If more packets shall be fetched, RETURN_OK must be returned.
+	 * 			Any other code stops fetching packets.
+	 */
+	virtual ReturnValue_t packetRetrieved(TmPacketMinimal* packet, uint32_t address) = 0;
+	virtual void noMorePacketsInStore() = 0;
+	virtual void handleRetrievalFailed(ReturnValue_t errorCode, uint32_t parameter1 = 0, uint32_t parameter2 = 0) = 0;
+	/**
+	 * To get the queue where commands shall be sent.
+	 * @return	Id of command queue.
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ReturnValue_t fetchPackets(ApidSsc start, ApidSsc end) = 0;
+	virtual ReturnValue_t deletePackets(ApidSsc upTo) = 0;
+	virtual ReturnValue_t checkPacket(SpacePacketBase* tmPacket) = 0;
+	virtual bool isEnabled() const = 0;
+	virtual void setEnabled(bool enabled) = 0;
+	virtual void resetDownlinkedPacketCount() = 0;
+	virtual ReturnValue_t setDumpTarget(object_id_t dumpTarget) = 0;
+	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_FRONTEND_IF;
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LAST_PACKET_FOUND = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t STOP_FETCH = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TM_CHANNEL_FULL = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t NOT_STORED = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t ALL_DELETED = MAKE_RETURN_CODE(7);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(8);
+	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(9);
+	virtual ~TmStoreFrontendIF() {
+	}
+};
+
+
+
+#endif /* PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp
index 0436442bc..753ac1b74 100644
--- a/tmstorage/TmStoreMessage.cpp
+++ b/tmstorage/TmStoreMessage.cpp
@@ -1,165 +1,165 @@
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../tmstorage/TmStoreMessage.h"
-
-TmStoreMessage::~TmStoreMessage() {
-	
-}
-
-TmStoreMessage::TmStoreMessage() {
-}
-
-ReturnValue_t TmStoreMessage::setEnableStoringMessage(CommandMessage* cmd,
-		bool setEnabled) {
-	cmd->setCommand(ENABLE_STORING);
-	cmd->setParameter(setEnabled);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TmStoreMessage::setDeleteContentMessage(CommandMessage* cmd,
-		ApidSsc upTo) {
-	cmd->setCommand(DELETE_STORE_CONTENT);
-	cmd->setParameter((upTo.apid<<16) + upTo.ssc);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TmStoreMessage::setDownlinkContentMessage(CommandMessage* cmd,
-		ApidSsc fromPacket,
-		ApidSsc toPacket) {
-	cmd->setCommand(DOWNLINK_STORE_CONTENT);
-	cmd->setParameter((fromPacket.apid<<16) + fromPacket.ssc);
-	cmd->setParameter2((toPacket.apid<<16) + toPacket.ssc);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ApidSsc TmStoreMessage::getPacketId1(CommandMessage* cmd) {
-	ApidSsc temp;
-	temp.apid = (cmd->getParameter() >> 16) & 0xFFFF;
-	temp.ssc = cmd->getParameter() & 0xFFFF;
-	return temp;
-}
-
-ApidSsc TmStoreMessage::getPacketId2(CommandMessage* cmd) {
-	ApidSsc temp;
-	temp.apid = (cmd->getParameter2() >> 16) & 0xFFFF;
-	temp.ssc = cmd->getParameter2() & 0xFFFF;
-	return temp;
-}
-
-bool TmStoreMessage::getEnableStoring(CommandMessage* cmd) {
-	return (bool)cmd->getParameter();
-}
-
-void TmStoreMessage::setChangeSelectionDefinitionMessage(
-		CommandMessage* cmd, bool addDefinition, store_address_t store_id) {
-	cmd->setCommand(CHANGE_SELECTION_DEFINITION);
-	cmd->setParameter(addDefinition);
-	cmd->setParameter2(store_id.raw);
-}
-
-void TmStoreMessage::clear(CommandMessage* cmd) {
-	switch(cmd->getCommand()) {
-	case SELECTION_DEFINITION_REPORT:
-	case STORE_CATALOGUE_REPORT:
-	case CHANGE_SELECTION_DEFINITION:
-	case INDEX_REPORT:
-	case DELETE_STORE_CONTENT_TIME:
-	case DOWNLINK_STORE_CONTENT_TIME: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(cmd));
-		}
-	}
-	/* NO BREAK falls through*/
-	case DELETE_STORE_CONTENT_BLOCKS:
-	case DOWNLINK_STORE_CONTENT_BLOCKS:
-	case REPORT_INDEX_REQUEST:
-		cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
-		cmd->setParameter(0);
-		cmd->setParameter2(0);
-		break;
-	default:
-		break;
-	}
-}
-
-store_address_t TmStoreMessage::getStoreId(const CommandMessage* cmd) {
-	store_address_t temp;
-	temp.raw = cmd->getParameter2();
-	return temp;
-}
-
-bool TmStoreMessage::getAddToSelection(CommandMessage* cmd) {
-	return (bool)cmd->getParameter();
-}
-
-ReturnValue_t TmStoreMessage::setReportSelectionDefinitionMessage(
-		CommandMessage* cmd) {
-	cmd->setCommand(REPORT_SELECTION_DEFINITION);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TmStoreMessage::setSelectionDefinitionReportMessage(
-		CommandMessage* cmd, store_address_t storeId) {
-	cmd->setCommand(SELECTION_DEFINITION_REPORT);
-	cmd->setParameter2(storeId.raw);
-}
-
-ReturnValue_t TmStoreMessage::setReportStoreCatalogueMessage(
-		CommandMessage* cmd) {
-	cmd->setCommand(REPORT_STORE_CATALOGUE);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TmStoreMessage::setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
-		store_address_t storeId) {
-	cmd->setCommand(STORE_CATALOGUE_REPORT);
-	cmd->setParameter(objectId);
-	cmd->setParameter2(storeId.raw);
-}
-
-object_id_t TmStoreMessage::getObjectId(CommandMessage* cmd) {
-	return cmd->getParameter();
-}
-
-void TmStoreMessage::setDownlinkContentTimeMessage(CommandMessage* cmd,
-		store_address_t storeId) {
-	cmd->setCommand(DOWNLINK_STORE_CONTENT_TIME);
-	cmd->setParameter2(storeId.raw);
-}
-
-uint32_t TmStoreMessage::getAddressLow(CommandMessage* cmd){
-	return cmd->getParameter();
-}
-uint32_t TmStoreMessage::getAddressHigh(CommandMessage* cmd){
-	return cmd->getParameter2();
-}
-
-void TmStoreMessage::setDeleteContentTimeMessage(CommandMessage* cmd,
-		store_address_t storeId) {
-	cmd->setCommand(DELETE_STORE_CONTENT_TIME);
-	cmd->setParameter2(storeId.raw);
-}
-
-ReturnValue_t TmStoreMessage::setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
-	cmd->setCommand(DELETE_STORE_CONTENT_BLOCKS);
-	cmd->setParameter(addressLow);
-	cmd->setParameter2(addressHigh);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-ReturnValue_t TmStoreMessage::setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
-	cmd->setCommand(DOWNLINK_STORE_CONTENT_BLOCKS);
-	cmd->setParameter(addressLow);
-	cmd->setParameter2(addressHigh);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-ReturnValue_t TmStoreMessage::setIndexRequestMessage(CommandMessage* cmd){
-	cmd->setCommand(REPORT_INDEX_REQUEST);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-void TmStoreMessage::setIndexReportMessage(CommandMessage* cmd, store_address_t storeId){
-	cmd->setCommand(INDEX_REPORT);
-	cmd->setParameter2(storeId.raw);
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tmstorage/TmStoreMessage.h"
+
+TmStoreMessage::~TmStoreMessage() {
+	
+}
+
+TmStoreMessage::TmStoreMessage() {
+}
+
+ReturnValue_t TmStoreMessage::setEnableStoringMessage(CommandMessage* cmd,
+		bool setEnabled) {
+	cmd->setCommand(ENABLE_STORING);
+	cmd->setParameter(setEnabled);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmStoreMessage::setDeleteContentMessage(CommandMessage* cmd,
+		ApidSsc upTo) {
+	cmd->setCommand(DELETE_STORE_CONTENT);
+	cmd->setParameter((upTo.apid<<16) + upTo.ssc);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmStoreMessage::setDownlinkContentMessage(CommandMessage* cmd,
+		ApidSsc fromPacket,
+		ApidSsc toPacket) {
+	cmd->setCommand(DOWNLINK_STORE_CONTENT);
+	cmd->setParameter((fromPacket.apid<<16) + fromPacket.ssc);
+	cmd->setParameter2((toPacket.apid<<16) + toPacket.ssc);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ApidSsc TmStoreMessage::getPacketId1(CommandMessage* cmd) {
+	ApidSsc temp;
+	temp.apid = (cmd->getParameter() >> 16) & 0xFFFF;
+	temp.ssc = cmd->getParameter() & 0xFFFF;
+	return temp;
+}
+
+ApidSsc TmStoreMessage::getPacketId2(CommandMessage* cmd) {
+	ApidSsc temp;
+	temp.apid = (cmd->getParameter2() >> 16) & 0xFFFF;
+	temp.ssc = cmd->getParameter2() & 0xFFFF;
+	return temp;
+}
+
+bool TmStoreMessage::getEnableStoring(CommandMessage* cmd) {
+	return (bool)cmd->getParameter();
+}
+
+void TmStoreMessage::setChangeSelectionDefinitionMessage(
+		CommandMessage* cmd, bool addDefinition, store_address_t store_id) {
+	cmd->setCommand(CHANGE_SELECTION_DEFINITION);
+	cmd->setParameter(addDefinition);
+	cmd->setParameter2(store_id.raw);
+}
+
+void TmStoreMessage::clear(CommandMessage* cmd) {
+	switch(cmd->getCommand()) {
+	case SELECTION_DEFINITION_REPORT:
+	case STORE_CATALOGUE_REPORT:
+	case CHANGE_SELECTION_DEFINITION:
+	case INDEX_REPORT:
+	case DELETE_STORE_CONTENT_TIME:
+	case DOWNLINK_STORE_CONTENT_TIME: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(cmd));
+		}
+	}
+	/* NO BREAK falls through*/
+	case DELETE_STORE_CONTENT_BLOCKS:
+	case DOWNLINK_STORE_CONTENT_BLOCKS:
+	case REPORT_INDEX_REQUEST:
+		cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
+		cmd->setParameter(0);
+		cmd->setParameter2(0);
+		break;
+	default:
+		break;
+	}
+}
+
+store_address_t TmStoreMessage::getStoreId(const CommandMessage* cmd) {
+	store_address_t temp;
+	temp.raw = cmd->getParameter2();
+	return temp;
+}
+
+bool TmStoreMessage::getAddToSelection(CommandMessage* cmd) {
+	return (bool)cmd->getParameter();
+}
+
+ReturnValue_t TmStoreMessage::setReportSelectionDefinitionMessage(
+		CommandMessage* cmd) {
+	cmd->setCommand(REPORT_SELECTION_DEFINITION);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmStoreMessage::setSelectionDefinitionReportMessage(
+		CommandMessage* cmd, store_address_t storeId) {
+	cmd->setCommand(SELECTION_DEFINITION_REPORT);
+	cmd->setParameter2(storeId.raw);
+}
+
+ReturnValue_t TmStoreMessage::setReportStoreCatalogueMessage(
+		CommandMessage* cmd) {
+	cmd->setCommand(REPORT_STORE_CATALOGUE);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmStoreMessage::setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
+		store_address_t storeId) {
+	cmd->setCommand(STORE_CATALOGUE_REPORT);
+	cmd->setParameter(objectId);
+	cmd->setParameter2(storeId.raw);
+}
+
+object_id_t TmStoreMessage::getObjectId(CommandMessage* cmd) {
+	return cmd->getParameter();
+}
+
+void TmStoreMessage::setDownlinkContentTimeMessage(CommandMessage* cmd,
+		store_address_t storeId) {
+	cmd->setCommand(DOWNLINK_STORE_CONTENT_TIME);
+	cmd->setParameter2(storeId.raw);
+}
+
+uint32_t TmStoreMessage::getAddressLow(CommandMessage* cmd){
+	return cmd->getParameter();
+}
+uint32_t TmStoreMessage::getAddressHigh(CommandMessage* cmd){
+	return cmd->getParameter2();
+}
+
+void TmStoreMessage::setDeleteContentTimeMessage(CommandMessage* cmd,
+		store_address_t storeId) {
+	cmd->setCommand(DELETE_STORE_CONTENT_TIME);
+	cmd->setParameter2(storeId.raw);
+}
+
+ReturnValue_t TmStoreMessage::setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
+	cmd->setCommand(DELETE_STORE_CONTENT_BLOCKS);
+	cmd->setParameter(addressLow);
+	cmd->setParameter2(addressHigh);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+ReturnValue_t TmStoreMessage::setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
+	cmd->setCommand(DOWNLINK_STORE_CONTENT_BLOCKS);
+	cmd->setParameter(addressLow);
+	cmd->setParameter2(addressHigh);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+ReturnValue_t TmStoreMessage::setIndexRequestMessage(CommandMessage* cmd){
+	cmd->setCommand(REPORT_INDEX_REQUEST);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+void TmStoreMessage::setIndexReportMessage(CommandMessage* cmd, store_address_t storeId){
+	cmd->setCommand(INDEX_REPORT);
+	cmd->setParameter2(storeId.raw);
+}
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index ce10519b7..59354a203 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -1,63 +1,63 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tmstorage/TmStorePackets.h"
-#include "../objectmanager/SystemObjectIF.h"
-class TmStoreMessage  {
-public:
-	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
-			bool setEnabled);
-	static ReturnValue_t setDeleteContentMessage(CommandMessage* cmd,
-			ApidSsc upTo);
-	static ReturnValue_t setDownlinkContentMessage(CommandMessage* cmd,
-			ApidSsc fromPacket, ApidSsc toPacket);
-	static void setChangeSelectionDefinitionMessage(CommandMessage* cmd,
-			bool addDefinition, store_address_t store_id);
-	static ReturnValue_t setReportSelectionDefinitionMessage(
-			CommandMessage* cmd);
-	static void setSelectionDefinitionReportMessage(CommandMessage* cmd,
-			store_address_t storeId);
-	static ReturnValue_t setReportStoreCatalogueMessage(CommandMessage* cmd);
-	static void setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
-			store_address_t storeId);
-	static void setDownlinkContentTimeMessage(CommandMessage* cmd,
-			store_address_t storeId);
-	static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
-	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
-	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
-	static ReturnValue_t setIndexRequestMessage(CommandMessage* cmd);
-	static void setDeleteContentTimeMessage(CommandMessage* cmd,
-			store_address_t storeId);
-	static void clear(CommandMessage* cmd);
-	static object_id_t getObjectId(CommandMessage* cmd);
-	static ApidSsc getPacketId1(CommandMessage* cmd);
-	static ApidSsc getPacketId2(CommandMessage* cmd);
-	static bool getEnableStoring(CommandMessage* cmd);
-	static bool getAddToSelection(CommandMessage* cmd);
-	static uint32_t getAddressLow(CommandMessage* cmd);
-	static uint32_t getAddressHigh(CommandMessage* cmd);
-
-	static store_address_t getStoreId(const CommandMessage* cmd);
-	virtual ~TmStoreMessage();
-	static const uint8_t MESSAGE_ID = messagetypes::TM_STORE;
-	static const Command_t ENABLE_STORING = MAKE_COMMAND_ID(1);
-	static const Command_t DELETE_STORE_CONTENT = MAKE_COMMAND_ID(2);
-	static const Command_t DOWNLINK_STORE_CONTENT = MAKE_COMMAND_ID(3);
-	static const Command_t CHANGE_SELECTION_DEFINITION = MAKE_COMMAND_ID(4);
-	static const Command_t REPORT_SELECTION_DEFINITION = MAKE_COMMAND_ID(5);
-	static const Command_t SELECTION_DEFINITION_REPORT = MAKE_COMMAND_ID(6);
-	static const Command_t REPORT_STORE_CATALOGUE = MAKE_COMMAND_ID(7);
-	static const Command_t STORE_CATALOGUE_REPORT = MAKE_COMMAND_ID(8);
-	static const Command_t DOWNLINK_STORE_CONTENT_TIME = MAKE_COMMAND_ID(9);
-	static const Command_t DELETE_STORE_CONTENT_TIME = MAKE_COMMAND_ID(10);
-	static const Command_t DELETE_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(11);
-	static const Command_t DOWNLINK_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(12);
-	static const Command_t REPORT_INDEX_REQUEST = MAKE_COMMAND_ID(13);
-	static const Command_t INDEX_REPORT = MAKE_COMMAND_ID(14);
-private:
-	TmStoreMessage();
-};
-
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ */
+#ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
+#define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tmstorage/TmStorePackets.h"
+#include "../objectmanager/SystemObjectIF.h"
+class TmStoreMessage  {
+public:
+	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
+			bool setEnabled);
+	static ReturnValue_t setDeleteContentMessage(CommandMessage* cmd,
+			ApidSsc upTo);
+	static ReturnValue_t setDownlinkContentMessage(CommandMessage* cmd,
+			ApidSsc fromPacket, ApidSsc toPacket);
+	static void setChangeSelectionDefinitionMessage(CommandMessage* cmd,
+			bool addDefinition, store_address_t store_id);
+	static ReturnValue_t setReportSelectionDefinitionMessage(
+			CommandMessage* cmd);
+	static void setSelectionDefinitionReportMessage(CommandMessage* cmd,
+			store_address_t storeId);
+	static ReturnValue_t setReportStoreCatalogueMessage(CommandMessage* cmd);
+	static void setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
+			store_address_t storeId);
+	static void setDownlinkContentTimeMessage(CommandMessage* cmd,
+			store_address_t storeId);
+	static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
+	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setIndexRequestMessage(CommandMessage* cmd);
+	static void setDeleteContentTimeMessage(CommandMessage* cmd,
+			store_address_t storeId);
+	static void clear(CommandMessage* cmd);
+	static object_id_t getObjectId(CommandMessage* cmd);
+	static ApidSsc getPacketId1(CommandMessage* cmd);
+	static ApidSsc getPacketId2(CommandMessage* cmd);
+	static bool getEnableStoring(CommandMessage* cmd);
+	static bool getAddToSelection(CommandMessage* cmd);
+	static uint32_t getAddressLow(CommandMessage* cmd);
+	static uint32_t getAddressHigh(CommandMessage* cmd);
+
+	static store_address_t getStoreId(const CommandMessage* cmd);
+	virtual ~TmStoreMessage();
+	static const uint8_t MESSAGE_ID = messagetypes::TM_STORE;
+	static const Command_t ENABLE_STORING = MAKE_COMMAND_ID(1);
+	static const Command_t DELETE_STORE_CONTENT = MAKE_COMMAND_ID(2);
+	static const Command_t DOWNLINK_STORE_CONTENT = MAKE_COMMAND_ID(3);
+	static const Command_t CHANGE_SELECTION_DEFINITION = MAKE_COMMAND_ID(4);
+	static const Command_t REPORT_SELECTION_DEFINITION = MAKE_COMMAND_ID(5);
+	static const Command_t SELECTION_DEFINITION_REPORT = MAKE_COMMAND_ID(6);
+	static const Command_t REPORT_STORE_CATALOGUE = MAKE_COMMAND_ID(7);
+	static const Command_t STORE_CATALOGUE_REPORT = MAKE_COMMAND_ID(8);
+	static const Command_t DOWNLINK_STORE_CONTENT_TIME = MAKE_COMMAND_ID(9);
+	static const Command_t DELETE_STORE_CONTENT_TIME = MAKE_COMMAND_ID(10);
+	static const Command_t DELETE_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(11);
+	static const Command_t DOWNLINK_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(12);
+	static const Command_t REPORT_INDEX_REQUEST = MAKE_COMMAND_ID(13);
+	static const Command_t INDEX_REPORT = MAKE_COMMAND_ID(14);
+private:
+	TmStoreMessage();
+};
+
+#endif /* FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ */
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 3c8e1a24f..4ce64fe64 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -1,300 +1,300 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
-
-#include "../serialize/SerialFixedArrayListAdapter.h"
-#include "../serialize/SerializeElement.h"
-#include "../serialize/SerialLinkedListAdapter.h"
-#include "../serialize/SerialBufferAdapter.h"
-#include "../tmtcpacket/pus/TmPacketMinimal.h"
-#include "../timemanager/TimeStamperIF.h"
-#include "../timemanager/CCSDSTime.h"
-#include "../globalfunctions/timevalOperations.h"
-
-class ServiceSubservice: public SerialLinkedListAdapter<SerializeIF> {
-public:
-	SerializeElement<uint8_t> service;
-	SerialFixedArrayListAdapter<uint8_t, 16> subservices;
-	LinkedElement<SerializeIF> linkedSubservices;
-	ServiceSubservice() :
-			SerialLinkedListAdapter<SerializeIF>(&service), linkedSubservices(
-					&subservices) {
-		service.setNext(&linkedSubservices);
-	}
-};
-
-class ApidSsc: public SerializeIF {
-public:
-	ApidSsc() :
-			apid(SpacePacketBase::LIMIT_APID), ssc(0) {
-	}
-	ApidSsc(uint16_t apid, uint16_t ssc) :
-			apid(apid), ssc(ssc) {
-	}
-	uint16_t apid;
-	uint16_t ssc;
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&apid,
-				buffer, size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::serialize(&ssc, buffer, size,
-				maxSize, streamEndianness);
-
-	}
-
-	size_t getSerializedSize() const {
-		return sizeof(apid) + sizeof(ssc);
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
-				buffer, size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::deSerialize(&ssc, buffer, size,
-				streamEndianness);
-	}
-};
-
-class ChangeSelectionDefinition: public SerialLinkedListAdapter<SerializeIF> {
-public:
-	SerializeElement<uint16_t> apid;
-	SerialFixedArrayListAdapter<ServiceSubservice, 16> serviceList;
-	LinkedElement<SerializeIF> linkedServiceList;
-	ChangeSelectionDefinition() :
-			SerialLinkedListAdapter<SerializeIF>(&apid), linkedServiceList(
-					&serviceList) {
-		apid.setNext(&linkedServiceList);
-	}
-};
-
-class TmPacketInformation: public SerializeIF {
-public:
-	TmPacketInformation(TmPacketMinimal* packet){
-		setContent(packet);
-	}
-	TmPacketInformation() :apid(
-					SpacePacketBase::LIMIT_APID), sourceSequenceCount(0), serviceType(
-					0), serviceSubtype(0), subCounter(0) {
-	}
-	void reset() {
-		apid = SpacePacketBase::LIMIT_APID;
-		sourceSequenceCount = 0;
-		serviceType = 0;
-		serviceSubtype = 0;
-		subCounter = 0;
-		memset(rawTimestamp, 0, sizeof(rawTimestamp));
-	}
-	void setContent(TmPacketMinimal* packet) {
-		apid = packet->getAPID();
-		sourceSequenceCount = packet->getPacketSequenceCount();
-		serviceType = packet->getService();
-		serviceSubtype = packet->getSubService();
-		subCounter = packet->getPacketSubcounter();
-		memset(rawTimestamp, 0, sizeof(rawTimestamp));
-		const uint8_t* pField = NULL;
-		uint32_t size = 0;
-		ReturnValue_t result = packet->getPacketTimeRaw(&pField, &size);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		if (*pField == CCSDSTime::P_FIELD_CDS_SHORT
-				&& size <= TimeStamperIF::MISSION_TIMESTAMP_SIZE) {
-			//Shortcut to avoid converting CDS back and forth.
-			memcpy(rawTimestamp, pField, size);
-			return;
-		}
-		timeval time = { 0, 0 };
-		result = packet->getPacketTime(&time);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-
-		CCSDSTime::CDS_short cdsFormat;
-		result = CCSDSTime::convertToCcsds(&cdsFormat, &time);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		memcpy(rawTimestamp, &cdsFormat, sizeof(cdsFormat));
-	}
-	void setContent(TmPacketInformation* content) {
-		apid = content->apid;
-		sourceSequenceCount = content->sourceSequenceCount;
-		serviceType = content->serviceType;
-		serviceSubtype = content->serviceSubtype;
-		subCounter = content->subCounter;
-		memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
-	}
-	bool isValid() const {
-		return (apid < SpacePacketBase::LIMIT_APID) ? true : false;
-	}
-	static void reset(TmPacketInformation* packet){
-		packet->reset();
-	}
-
-	static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime){
-		if(packet->isValid()){
-			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
-			if(packetTime <= *cmpTime){
-				return true;
-			}
-		}
-		return false;
-	}
-
-	static bool isNewerThan(const TmPacketInformation* packet, const timeval* cmpTime){
-		if(packet->isValid()){
-			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
-			if(packetTime >= *cmpTime){
-				return true;
-			}
-		}
-		return false;
-	}
-
-	static bool isSmallerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
-		if(packet->isValid()){
-			if(packet->apid == compareSSC->apid){
-				if(packet->sourceSequenceCount <= compareSSC->ssc){
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
-	static bool isLargerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
-		if(packet->isValid()){
-			if(packet->apid == compareSSC->apid){
-				if(packet->sourceSequenceCount >= compareSSC->ssc){
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
-	uint16_t getApid() const{
-		return apid;
-	}
-
-	uint16_t getSsc() const{
-		return sourceSequenceCount;
-	}
-
-	uint8_t getServiceType() const{
-		return serviceType;
-	}
-
-	uint8_t getServiceSubtype() const{
-		return serviceSubtype;
-	}
-
-	uint8_t getSubCounter() const{
-		return subCounter;
-	}
-
-	timeval getTime() const {
-		timeval packetTime = {0,0};
-		uint32_t foundlen = 0;
-		CCSDSTime::convertFromCcsds(&packetTime,&this->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
-		return packetTime;
-	}
-
-	bool operator==(const TmPacketInformation& other) {
-		//TODO Does not compare Raw Timestamp
-		return ((apid == other.getApid())
-				&& (sourceSequenceCount == other.getSsc())
-				&& (serviceType == other.getServiceType()) && (serviceSubtype =
-						other.getServiceSubtype()));
-	}
-
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.serialize(buffer,size,maxSize,streamEndianness);
-	}
-
-	size_t getSerializedSize() const {
-		uint32_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&apid);
-		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
-		size += SerializeAdapter::getSerializedSize(&serviceType);
-		size += SerializeAdapter::getSerializedSize(&serviceSubtype);
-		size += SerializeAdapter::getSerializedSize(&subCounter);
-		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		size += adapter.getSerializedSize();
-		return size;
-
-	};
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
-				size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
-				size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
-				size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.deSerialize(buffer,size,streamEndianness);
-	}
-
-private:
-	uint16_t apid;
-	uint16_t sourceSequenceCount;
-	uint8_t serviceType;
-	uint8_t serviceSubtype;
-	uint8_t subCounter;
-	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
-
-};
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ */
+#ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
+#define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
+
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../serialize/SerialBufferAdapter.h"
+#include "../tmtcpacket/pus/TmPacketMinimal.h"
+#include "../timemanager/TimeStamperIF.h"
+#include "../timemanager/CCSDSTime.h"
+#include "../globalfunctions/timevalOperations.h"
+
+class ServiceSubservice: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	SerializeElement<uint8_t> service;
+	SerialFixedArrayListAdapter<uint8_t, 16> subservices;
+	LinkedElement<SerializeIF> linkedSubservices;
+	ServiceSubservice() :
+			SerialLinkedListAdapter<SerializeIF>(&service), linkedSubservices(
+					&subservices) {
+		service.setNext(&linkedSubservices);
+	}
+};
+
+class ApidSsc: public SerializeIF {
+public:
+	ApidSsc() :
+			apid(SpacePacketBase::LIMIT_APID), ssc(0) {
+	}
+	ApidSsc(uint16_t apid, uint16_t ssc) :
+			apid(apid), ssc(ssc) {
+	}
+	uint16_t apid;
+	uint16_t ssc;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,
+				buffer, size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::serialize(&ssc, buffer, size,
+				maxSize, streamEndianness);
+
+	}
+
+	size_t getSerializedSize() const {
+		return sizeof(apid) + sizeof(ssc);
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
+				buffer, size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::deSerialize(&ssc, buffer, size,
+				streamEndianness);
+	}
+};
+
+class ChangeSelectionDefinition: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	SerializeElement<uint16_t> apid;
+	SerialFixedArrayListAdapter<ServiceSubservice, 16> serviceList;
+	LinkedElement<SerializeIF> linkedServiceList;
+	ChangeSelectionDefinition() :
+			SerialLinkedListAdapter<SerializeIF>(&apid), linkedServiceList(
+					&serviceList) {
+		apid.setNext(&linkedServiceList);
+	}
+};
+
+class TmPacketInformation: public SerializeIF {
+public:
+	TmPacketInformation(TmPacketMinimal* packet){
+		setContent(packet);
+	}
+	TmPacketInformation() :apid(
+					SpacePacketBase::LIMIT_APID), sourceSequenceCount(0), serviceType(
+					0), serviceSubtype(0), subCounter(0) {
+	}
+	void reset() {
+		apid = SpacePacketBase::LIMIT_APID;
+		sourceSequenceCount = 0;
+		serviceType = 0;
+		serviceSubtype = 0;
+		subCounter = 0;
+		memset(rawTimestamp, 0, sizeof(rawTimestamp));
+	}
+	void setContent(TmPacketMinimal* packet) {
+		apid = packet->getAPID();
+		sourceSequenceCount = packet->getPacketSequenceCount();
+		serviceType = packet->getService();
+		serviceSubtype = packet->getSubService();
+		subCounter = packet->getPacketSubcounter();
+		memset(rawTimestamp, 0, sizeof(rawTimestamp));
+		const uint8_t* pField = NULL;
+		uint32_t size = 0;
+		ReturnValue_t result = packet->getPacketTimeRaw(&pField, &size);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		if (*pField == CCSDSTime::P_FIELD_CDS_SHORT
+				&& size <= TimeStamperIF::MISSION_TIMESTAMP_SIZE) {
+			//Shortcut to avoid converting CDS back and forth.
+			memcpy(rawTimestamp, pField, size);
+			return;
+		}
+		timeval time = { 0, 0 };
+		result = packet->getPacketTime(&time);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+
+		CCSDSTime::CDS_short cdsFormat;
+		result = CCSDSTime::convertToCcsds(&cdsFormat, &time);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		memcpy(rawTimestamp, &cdsFormat, sizeof(cdsFormat));
+	}
+	void setContent(TmPacketInformation* content) {
+		apid = content->apid;
+		sourceSequenceCount = content->sourceSequenceCount;
+		serviceType = content->serviceType;
+		serviceSubtype = content->serviceSubtype;
+		subCounter = content->subCounter;
+		memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
+	}
+	bool isValid() const {
+		return (apid < SpacePacketBase::LIMIT_APID) ? true : false;
+	}
+	static void reset(TmPacketInformation* packet){
+		packet->reset();
+	}
+
+	static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime){
+		if(packet->isValid()){
+			timeval packetTime = {0,0};
+			uint32_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			if(packetTime <= *cmpTime){
+				return true;
+			}
+		}
+		return false;
+	}
+
+	static bool isNewerThan(const TmPacketInformation* packet, const timeval* cmpTime){
+		if(packet->isValid()){
+			timeval packetTime = {0,0};
+			uint32_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			if(packetTime >= *cmpTime){
+				return true;
+			}
+		}
+		return false;
+	}
+
+	static bool isSmallerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
+		if(packet->isValid()){
+			if(packet->apid == compareSSC->apid){
+				if(packet->sourceSequenceCount <= compareSSC->ssc){
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	static bool isLargerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
+		if(packet->isValid()){
+			if(packet->apid == compareSSC->apid){
+				if(packet->sourceSequenceCount >= compareSSC->ssc){
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	uint16_t getApid() const{
+		return apid;
+	}
+
+	uint16_t getSsc() const{
+		return sourceSequenceCount;
+	}
+
+	uint8_t getServiceType() const{
+		return serviceType;
+	}
+
+	uint8_t getServiceSubtype() const{
+		return serviceSubtype;
+	}
+
+	uint8_t getSubCounter() const{
+		return subCounter;
+	}
+
+	timeval getTime() const {
+		timeval packetTime = {0,0};
+		uint32_t foundlen = 0;
+		CCSDSTime::convertFromCcsds(&packetTime,&this->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+		return packetTime;
+	}
+
+	bool operator==(const TmPacketInformation& other) {
+		//TODO Does not compare Raw Timestamp
+		return ((apid == other.getApid())
+				&& (sourceSequenceCount == other.getSsc())
+				&& (serviceType == other.getServiceType()) && (serviceSubtype =
+						other.getServiceSubtype()));
+	}
+
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
+		return adapter.serialize(buffer,size,maxSize,streamEndianness);
+	}
+
+	size_t getSerializedSize() const {
+		uint32_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&apid);
+		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
+		size += SerializeAdapter::getSerializedSize(&serviceType);
+		size += SerializeAdapter::getSerializedSize(&serviceSubtype);
+		size += SerializeAdapter::getSerializedSize(&subCounter);
+		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
+		size += adapter.getSerializedSize();
+		return size;
+
+	};
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
+				size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
+				size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
+				size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
+		return adapter.deSerialize(buffer,size,streamEndianness);
+	}
+
+private:
+	uint16_t apid;
+	uint16_t sourceSequenceCount;
+	uint8_t serviceType;
+	uint8_t serviceSubtype;
+	uint8_t subCounter;
+	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+
+};
+#endif /* FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ */
diff --git a/tmtcpacket/SpacePacket.cpp b/tmtcpacket/SpacePacket.cpp
index c04e143fd..2bf6e3dcd 100644
--- a/tmtcpacket/SpacePacket.cpp
+++ b/tmtcpacket/SpacePacket.cpp
@@ -1,27 +1,27 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tmtcpacket/ccsds_header.h"
-#include "../tmtcpacket/SpacePacket.h"
-#include <string.h>
-
-SpacePacket::SpacePacket( uint16_t packetDataLength, bool isTelecommand, uint16_t apid, uint16_t sequenceCount ):
-SpacePacketBase( (uint8_t*)&this->localData ) {
-	initSpacePacketHeader(isTelecommand, false, apid, sequenceCount);
-	this->setPacketSequenceCount(sequenceCount);
-	if ( packetDataLength <= sizeof(this->localData.fields.buffer) ) {
-		this->setPacketDataLength(packetDataLength);
-	} else {
-		this->setPacketDataLength( sizeof(this->localData.fields.buffer) );
-	}
-}
-
-SpacePacket::~SpacePacket( void ) {
-}
-
-bool SpacePacket::addWholeData( const uint8_t* p_Data, uint32_t packet_size ) {
-	if ( packet_size <= sizeof(this->data) ) {
-		memcpy( &this->localData.byteStream, p_Data, packet_size );
-		return true;
-	} else {
-		return false;
-	}
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcpacket/ccsds_header.h"
+#include "../tmtcpacket/SpacePacket.h"
+#include <string.h>
+
+SpacePacket::SpacePacket( uint16_t packetDataLength, bool isTelecommand, uint16_t apid, uint16_t sequenceCount ):
+SpacePacketBase( (uint8_t*)&this->localData ) {
+	initSpacePacketHeader(isTelecommand, false, apid, sequenceCount);
+	this->setPacketSequenceCount(sequenceCount);
+	if ( packetDataLength <= sizeof(this->localData.fields.buffer) ) {
+		this->setPacketDataLength(packetDataLength);
+	} else {
+		this->setPacketDataLength( sizeof(this->localData.fields.buffer) );
+	}
+}
+
+SpacePacket::~SpacePacket( void ) {
+}
+
+bool SpacePacket::addWholeData( const uint8_t* p_Data, uint32_t packet_size ) {
+	if ( packet_size <= sizeof(this->data) ) {
+		memcpy( &this->localData.byteStream, p_Data, packet_size );
+		return true;
+	} else {
+		return false;
+	}
+}
diff --git a/tmtcpacket/SpacePacket.h b/tmtcpacket/SpacePacket.h
index a75b9ae33..ea1d0468a 100644
--- a/tmtcpacket/SpacePacket.h
+++ b/tmtcpacket/SpacePacket.h
@@ -1,70 +1,70 @@
-#ifndef SPACEPACKET_H_
-#define SPACEPACKET_H_
-
-#include "../tmtcpacket/SpacePacketBase.h"
-
-/**
- * The SpacePacket class is a representation of a simple CCSDS Space Packet
- * without (control over) a secondary header.
- * It can be instantiated with a size smaller than \c PACKET_MAX_SIZE. Its
- * main use is to serve as an idle packet in case no other packets are sent.
- * For the ECSS PUS part the TcPacket and TmPacket classes are used.
- * A pointer to \c local_data is passed to the \c SpacePacketBase parent class,
- * so the parent's methods are reachable.
- * @ingroup tmtcpackets
- */
-class SpacePacket: public SpacePacketBase {
-public:
-	static const uint16_t PACKET_MAX_SIZE = 1024;
-	/**
-	 * The constructor initializes the packet and sets all header information
-	 * according to the passed parameters.
-	 * @param packetDataLength Sets the packet data length field and therefore specifies the size of the packet.
-	 * @param isTelecommand Sets the packet type field to either TC (true) or TM (false).
-	 * @param apid Sets the packet's APID field. The default value describes an idle packet.
-	 * @param sequenceCount ets the packet's Source Sequence Count field.
-	 */
-	SpacePacket(uint16_t packetDataLength, bool isTelecommand = false,
-			uint16_t apid = APID_IDLE_PACKET, uint16_t sequenceCount = 0);
-	/**
-	 * The class's default destructor.
-	 */
-	virtual ~SpacePacket();
-	/**
-	 * With this call, the complete data content (including the CCSDS Primary
-	 * Header) is overwritten with the byte stream given.
-	 * @param p_data		Pointer to data to overwrite the content with
-	 * @param packet_size	Size of the data
-	 * @return	@li	\c true if packet_size is smaller than \c MAX_PACKET_SIZE.
-	 * 			@li \c false else.
-	 */
-	bool addWholeData(const uint8_t* p_data, uint32_t packet_size);
-protected:
-	/**
-	 * This structure defines the data structure of a Space Packet as local data.
-	 * There's a buffer which corresponds to the Space Packet Data Field with a
-	 * maximum size of \c PACKET_MAX_SIZE.
-	 */
-	struct PacketStructured {
-		CCSDSPrimaryHeader header;
-		uint8_t buffer[PACKET_MAX_SIZE];
-	};
-	/**
-	 * This union simplifies accessing the full data content of the Space Packet.
-	 * This is achieved by putting the \c PacketStructured struct in a union with
-	 * a plain buffer.
-	 */
-	union SpacePacketData {
-		PacketStructured fields;
-		uint8_t byteStream[PACKET_MAX_SIZE + sizeof(CCSDSPrimaryHeader)];
-	};
-	/**
-	 * This is the data representation of the class.
-	 * It is a struct of CCSDS Primary Header and a data field, which again is
-	 * packed in an union, so the data can be accessed as a byte stream without
-	 * a cast.
-	 */
-	SpacePacketData localData;
-};
-
-#endif /* SPACEPACKET_H_ */
+#ifndef SPACEPACKET_H_
+#define SPACEPACKET_H_
+
+#include "../tmtcpacket/SpacePacketBase.h"
+
+/**
+ * The SpacePacket class is a representation of a simple CCSDS Space Packet
+ * without (control over) a secondary header.
+ * It can be instantiated with a size smaller than \c PACKET_MAX_SIZE. Its
+ * main use is to serve as an idle packet in case no other packets are sent.
+ * For the ECSS PUS part the TcPacket and TmPacket classes are used.
+ * A pointer to \c local_data is passed to the \c SpacePacketBase parent class,
+ * so the parent's methods are reachable.
+ * @ingroup tmtcpackets
+ */
+class SpacePacket: public SpacePacketBase {
+public:
+	static const uint16_t PACKET_MAX_SIZE = 1024;
+	/**
+	 * The constructor initializes the packet and sets all header information
+	 * according to the passed parameters.
+	 * @param packetDataLength Sets the packet data length field and therefore specifies the size of the packet.
+	 * @param isTelecommand Sets the packet type field to either TC (true) or TM (false).
+	 * @param apid Sets the packet's APID field. The default value describes an idle packet.
+	 * @param sequenceCount ets the packet's Source Sequence Count field.
+	 */
+	SpacePacket(uint16_t packetDataLength, bool isTelecommand = false,
+			uint16_t apid = APID_IDLE_PACKET, uint16_t sequenceCount = 0);
+	/**
+	 * The class's default destructor.
+	 */
+	virtual ~SpacePacket();
+	/**
+	 * With this call, the complete data content (including the CCSDS Primary
+	 * Header) is overwritten with the byte stream given.
+	 * @param p_data		Pointer to data to overwrite the content with
+	 * @param packet_size	Size of the data
+	 * @return	@li	\c true if packet_size is smaller than \c MAX_PACKET_SIZE.
+	 * 			@li \c false else.
+	 */
+	bool addWholeData(const uint8_t* p_data, uint32_t packet_size);
+protected:
+	/**
+	 * This structure defines the data structure of a Space Packet as local data.
+	 * There's a buffer which corresponds to the Space Packet Data Field with a
+	 * maximum size of \c PACKET_MAX_SIZE.
+	 */
+	struct PacketStructured {
+		CCSDSPrimaryHeader header;
+		uint8_t buffer[PACKET_MAX_SIZE];
+	};
+	/**
+	 * This union simplifies accessing the full data content of the Space Packet.
+	 * This is achieved by putting the \c PacketStructured struct in a union with
+	 * a plain buffer.
+	 */
+	union SpacePacketData {
+		PacketStructured fields;
+		uint8_t byteStream[PACKET_MAX_SIZE + sizeof(CCSDSPrimaryHeader)];
+	};
+	/**
+	 * This is the data representation of the class.
+	 * It is a struct of CCSDS Primary Header and a data field, which again is
+	 * packed in an union, so the data can be accessed as a byte stream without
+	 * a cast.
+	 */
+	SpacePacketData localData;
+};
+
+#endif /* SPACEPACKET_H_ */
diff --git a/tmtcpacket/SpacePacketBase.cpp b/tmtcpacket/SpacePacketBase.cpp
index 3d3a51e34..044ce510d 100644
--- a/tmtcpacket/SpacePacketBase.cpp
+++ b/tmtcpacket/SpacePacketBase.cpp
@@ -1,104 +1,104 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tmtcpacket/SpacePacketBase.h"
-#include <string.h>
-
-SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) {
-	this->data = (SpacePacketPointer*) set_address;
-}
-
-SpacePacketBase::~SpacePacketBase() {
-};
-
-//CCSDS Methods:
-uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
-	return (this->data->header.packet_id_h & 0b11100000) >> 5;
-}
-
-void SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
-		bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
-	//reset header to zero:
-	memset(data,0, sizeof(this->data->header) );
-	//Set TC/TM bit.
-	data->header.packet_id_h = ((isTelecommand? 1 : 0)) << 4;
-	//Set secondaryHeader bit
-	data->header.packet_id_h |= ((hasSecondaryHeader? 1 : 0)) << 3;
-	this->setAPID( apid );
-	//Always initialize as standalone packets.
-	data->header.sequence_control_h = 0b11000000;
-	setPacketSequenceCount(sequenceCount);
-
-}
-
-bool SpacePacketBase::isTelecommand( void ) {
-	return (this->data->header.packet_id_h & 0b00010000) >> 4;
-}
-
-bool SpacePacketBase::hasSecondaryHeader( void ) {
-	return (this->data->header.packet_id_h & 0b00001000) >> 3;
-}
-
-uint16_t SpacePacketBase::getPacketId() {
-	return ( (this->data->header.packet_id_h) << 8 ) +
-			this->data->header.packet_id_l;
-}
-
-uint16_t SpacePacketBase::getAPID( void ) const {
-	return ( (this->data->header.packet_id_h & 0b00000111) << 8 ) +
-			this->data->header.packet_id_l;
-}
-
-void SpacePacketBase::setAPID( uint16_t new_apid ) {
-	//Use first three bits of new APID, but keep rest of packet id as it was (see specification).
-	this->data->header.packet_id_h = (this->data->header.packet_id_h & 0b11111000) | ( ( new_apid & 0x0700 ) >> 8 );
-	this->data->header.packet_id_l = ( new_apid & 0x00FF );
-}
-
-uint16_t SpacePacketBase::getPacketSequenceControl( void ) {
-	return ( (this->data->header.sequence_control_h) << 8 )
-		+ this->data->header.sequence_control_l;
-}
-
-uint8_t SpacePacketBase::getSequenceFlags( void ) {
-	return (this->data->header.sequence_control_h & 0b11000000) >> 6 ;
-}
-
-uint16_t SpacePacketBase::getPacketSequenceCount( void ) const {
-	return ( (this->data->header.sequence_control_h & 0b00111111) << 8 )
-		+ this->data->header.sequence_control_l;
-}
-
-void SpacePacketBase::setPacketSequenceCount( uint16_t new_count) {
-	this->data->header.sequence_control_h = ( this->data->header.sequence_control_h & 0b11000000 ) | ( ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x3F00 ) >> 8 );
-	this->data->header.sequence_control_l = ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x00FF );
-}
-
-uint16_t SpacePacketBase::getPacketDataLength( void ) {
-	return ( (this->data->header.packet_length_h) << 8 )
-		+ this->data->header.packet_length_l;
-}
-
-void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
-	this->data->header.packet_length_h = ( ( new_length & 0xFF00 ) >> 8 );
-	this->data->header.packet_length_l = ( new_length & 0x00FF );
-}
-
-size_t SpacePacketBase::getFullSize() {
-	//+1 is done because size in packet data length field is: size of data field -1
-	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
-}
-
-uint8_t* SpacePacketBase::getWholeData() {
-	return (uint8_t*)this->data;
-}
-
-void SpacePacketBase::setData( const uint8_t* p_Data ) {
-	this->data = (SpacePacketPointer*)p_Data;
-}
-
-uint32_t SpacePacketBase::getApidAndSequenceCount() const {
-	return (getAPID() << 16) + getPacketSequenceCount();
-}
-
-uint8_t* SpacePacketBase::getPacketData() {
-	return &(data->packet_data);
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcpacket/SpacePacketBase.h"
+#include <string.h>
+
+SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) {
+	this->data = (SpacePacketPointer*) set_address;
+}
+
+SpacePacketBase::~SpacePacketBase() {
+};
+
+//CCSDS Methods:
+uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
+	return (this->data->header.packet_id_h & 0b11100000) >> 5;
+}
+
+void SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
+		bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
+	//reset header to zero:
+	memset(data,0, sizeof(this->data->header) );
+	//Set TC/TM bit.
+	data->header.packet_id_h = ((isTelecommand? 1 : 0)) << 4;
+	//Set secondaryHeader bit
+	data->header.packet_id_h |= ((hasSecondaryHeader? 1 : 0)) << 3;
+	this->setAPID( apid );
+	//Always initialize as standalone packets.
+	data->header.sequence_control_h = 0b11000000;
+	setPacketSequenceCount(sequenceCount);
+
+}
+
+bool SpacePacketBase::isTelecommand( void ) {
+	return (this->data->header.packet_id_h & 0b00010000) >> 4;
+}
+
+bool SpacePacketBase::hasSecondaryHeader( void ) {
+	return (this->data->header.packet_id_h & 0b00001000) >> 3;
+}
+
+uint16_t SpacePacketBase::getPacketId() {
+	return ( (this->data->header.packet_id_h) << 8 ) +
+			this->data->header.packet_id_l;
+}
+
+uint16_t SpacePacketBase::getAPID( void ) const {
+	return ( (this->data->header.packet_id_h & 0b00000111) << 8 ) +
+			this->data->header.packet_id_l;
+}
+
+void SpacePacketBase::setAPID( uint16_t new_apid ) {
+	//Use first three bits of new APID, but keep rest of packet id as it was (see specification).
+	this->data->header.packet_id_h = (this->data->header.packet_id_h & 0b11111000) | ( ( new_apid & 0x0700 ) >> 8 );
+	this->data->header.packet_id_l = ( new_apid & 0x00FF );
+}
+
+uint16_t SpacePacketBase::getPacketSequenceControl( void ) {
+	return ( (this->data->header.sequence_control_h) << 8 )
+		+ this->data->header.sequence_control_l;
+}
+
+uint8_t SpacePacketBase::getSequenceFlags( void ) {
+	return (this->data->header.sequence_control_h & 0b11000000) >> 6 ;
+}
+
+uint16_t SpacePacketBase::getPacketSequenceCount( void ) const {
+	return ( (this->data->header.sequence_control_h & 0b00111111) << 8 )
+		+ this->data->header.sequence_control_l;
+}
+
+void SpacePacketBase::setPacketSequenceCount( uint16_t new_count) {
+	this->data->header.sequence_control_h = ( this->data->header.sequence_control_h & 0b11000000 ) | ( ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x3F00 ) >> 8 );
+	this->data->header.sequence_control_l = ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x00FF );
+}
+
+uint16_t SpacePacketBase::getPacketDataLength( void ) {
+	return ( (this->data->header.packet_length_h) << 8 )
+		+ this->data->header.packet_length_l;
+}
+
+void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
+	this->data->header.packet_length_h = ( ( new_length & 0xFF00 ) >> 8 );
+	this->data->header.packet_length_l = ( new_length & 0x00FF );
+}
+
+size_t SpacePacketBase::getFullSize() {
+	//+1 is done because size in packet data length field is: size of data field -1
+	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
+}
+
+uint8_t* SpacePacketBase::getWholeData() {
+	return (uint8_t*)this->data;
+}
+
+void SpacePacketBase::setData( const uint8_t* p_Data ) {
+	this->data = (SpacePacketPointer*)p_Data;
+}
+
+uint32_t SpacePacketBase::getApidAndSequenceCount() const {
+	return (getAPID() << 16) + getPacketSequenceCount();
+}
+
+uint8_t* SpacePacketBase::getPacketData() {
+	return &(data->packet_data);
+}
diff --git a/tmtcpacket/SpacePacketBase.h b/tmtcpacket/SpacePacketBase.h
index a132bfd16..c7a63ae68 100644
--- a/tmtcpacket/SpacePacketBase.h
+++ b/tmtcpacket/SpacePacketBase.h
@@ -1,177 +1,177 @@
-#ifndef SPACEPACKETBASE_H_
-#define SPACEPACKETBASE_H_
-
-#include "../tmtcpacket/ccsds_header.h"
-#include <cstddef>
-
-/**
- * @defgroup tmtcpackets Space Packets
- * This is the group, where all classes associated with Telecommand and
- * Telemetry packets belong to.
- * The class hierarchy resembles the dependency between the different standards
- * applied, namely the CCSDS Space Packet standard and the ECCSS Packet
- * Utilization Standard. Most field and structure names are taken from these
- * standards.
- */
-
-/**
- * This struct defines the data structure of a Space Packet when accessed
- * via a pointer.
- * @ingroup tmtcpackets
- */
-struct SpacePacketPointer {
-	CCSDSPrimaryHeader header;
-	uint8_t packet_data;
-};
-
-/**
- * This class is the basic data handler for any CCSDS Space Packet
- * compatible Telecommand and Telemetry packet.
- * It does not contain the packet data itself but a pointer to the
- * data must be set on instantiation. An invalid pointer may cause
- * damage, as no getter method checks data validity. Anyway, a NULL
- * check can be performed by making use of the getWholeData method.
- * Remark: All bit numbers in this documentation are counted from
- * the most significant bit (from left).
- * @ingroup tmtcpackets
- */
-class SpacePacketBase {
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet header.
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	SpacePacketPointer* data;
-public:
-	static const uint16_t LIMIT_APID = 2048; //2^1
-	static const uint16_t LIMIT_SEQUENCE_COUNT = 16384; // 2^14
-	static const uint16_t APID_IDLE_PACKET = 0x7FF;
-	static const uint8_t TELECOMMAND_PACKET = 1;
-	static const uint8_t TELEMETRY_PACKET = 0;
-	/**
-	 * This definition defines the CRC size in byte.
-	 */
-	static const uint8_t CRC_SIZE = 2;
-	/**
-	 * This is the minimum size of a SpacePacket.
-	 */
-	static const uint16_t MINIMUM_SIZE = sizeof(CCSDSPrimaryHeader) + CRC_SIZE;
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	SpacePacketBase( const uint8_t* set_address );
-	/**
-	 * No data is allocated, so the destructor is empty.
-	 */
-	virtual ~SpacePacketBase();
-
-	//CCSDS Methods:
-	/**
-	 * Getter for the packet version number field.
-	 * @return Returns the highest three bit of the packet in one byte.
-	 */
-	uint8_t getPacketVersionNumber( void );
-	/**
-	 * This method checks the type field in the header.
-	 * This bit specifies, if the command is interpreted as Telecommand of
-	 * as Telemetry. For a Telecommand, the bit is set.
-	 * @return Returns true if the bit is set and false if not.
-	 */
-	bool isTelecommand( void );
-
-	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount = 0);
-	/**
-	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
-	 *  which is checked with this method.
-	 * @return	Returns true if the bit is set and false if not.
-	 */
-	bool hasSecondaryHeader( void );
-	/**
-	 * Returns the complete first two bytes of the packet, which together form
-	 * the CCSDS packet id.
-	 * @return	The CCSDS packet id.
-	 */
-	uint16_t getPacketId( void );
-	/**
-	 * Returns the APID of a packet, which are the lowest 11 bit of the packet
-	 * id.
-	 * @return The CCSDS APID.
-	 */
-	uint16_t getAPID( void ) const;
-	/**
-	 * Sets the APID of a packet, which are the lowest 11 bit of the packet
-	 * id.
-	 * @param 	The APID to set. The highest five bits of the parameter are
-	 * 			ignored.
-	 */
-	void setAPID( uint16_t setAPID );
-	/**
-	 * Returns the CCSDS packet sequence control field, which are the third and
-	 * the fourth byte of the CCSDS primary header.
-	 * @return The CCSDS packet sequence control field.
-	 */
-	uint16_t getPacketSequenceControl( void );
-	/**
-	 * Returns the SequenceFlags, which are the highest two bit of the packet
-	 * sequence control field.
-	 * @return	The CCSDS sequence flags.
-	 */
-	uint8_t getSequenceFlags( void );
-	/**
-	 * Returns the packet sequence count, which are the lowest 14 bit of the
-	 * packet sequence control field.
-	 * @return The CCSDS sequence count.
-	 */
-	uint16_t getPacketSequenceCount( void ) const;
-	/**
-	 * Sets the packet sequence count, which are the lowest 14 bit of the
-	 * packet sequence control field.
-	 * setCount is modulo-divided by \c LIMIT_SEQUENCE_COUNT to avoid overflows.
-	 * @param setCount	The value to set the count to.
-	 */
-	void setPacketSequenceCount( uint16_t setCount );
-	/**
-	 * Returns the packet data length, which is the fifth and sixth byte of the
-	 * CCSDS Primary Header. The packet data length is the size of every kind
-	 * of data \b after the CCSDS Primary Header \b -1.
-	 * @return The CCSDS packet data length.
-	 */
-	uint16_t getPacketDataLength( void ); //uint16_t is sufficient, because this is limit in CCSDS standard
-	/**
-	 * Sets the packet data length, which is the fifth and sixth byte of the
-	 * CCSDS Primary Header.
-	 * @param setLength The value of the length to set. It must fit the true
-	 * 					CCSDS packet data length . The packet data length is
-	 * 					the size of every kind of data \b after the CCSDS
-	 * 					Primary Header \b -1.
-	 */
-	void setPacketDataLength( uint16_t setLength );
-
-	//Helper methods:
-	/**
-	 * This method returns a raw uint8_t pointer to the packet.
-	 * @return	A \c uint8_t pointer to the first byte of the CCSDS primary header.
-	 */
-	virtual uint8_t* getWholeData( void );
-
-	uint8_t* getPacketData();
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 * @param p_Data A pointer to another raw Space Packet.
-	 */
-	virtual void setData( const uint8_t* p_Data );
-	/**
-	 * This method returns the full raw packet size.
-	 * @return	The full size of the packet in bytes.
-	 */
-	size_t getFullSize();
-
-	uint32_t getApidAndSequenceCount() const;
-
-};
-
-#endif /* SPACEPACKETBASE_H_ */
+#ifndef SPACEPACKETBASE_H_
+#define SPACEPACKETBASE_H_
+
+#include "../tmtcpacket/ccsds_header.h"
+#include <cstddef>
+
+/**
+ * @defgroup tmtcpackets Space Packets
+ * This is the group, where all classes associated with Telecommand and
+ * Telemetry packets belong to.
+ * The class hierarchy resembles the dependency between the different standards
+ * applied, namely the CCSDS Space Packet standard and the ECCSS Packet
+ * Utilization Standard. Most field and structure names are taken from these
+ * standards.
+ */
+
+/**
+ * This struct defines the data structure of a Space Packet when accessed
+ * via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct SpacePacketPointer {
+	CCSDSPrimaryHeader header;
+	uint8_t packet_data;
+};
+
+/**
+ * This class is the basic data handler for any CCSDS Space Packet
+ * compatible Telecommand and Telemetry packet.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * Remark: All bit numbers in this documentation are counted from
+ * the most significant bit (from left).
+ * @ingroup tmtcpackets
+ */
+class SpacePacketBase {
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet header.
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	SpacePacketPointer* data;
+public:
+	static const uint16_t LIMIT_APID = 2048; //2^1
+	static const uint16_t LIMIT_SEQUENCE_COUNT = 16384; // 2^14
+	static const uint16_t APID_IDLE_PACKET = 0x7FF;
+	static const uint8_t TELECOMMAND_PACKET = 1;
+	static const uint8_t TELEMETRY_PACKET = 0;
+	/**
+	 * This definition defines the CRC size in byte.
+	 */
+	static const uint8_t CRC_SIZE = 2;
+	/**
+	 * This is the minimum size of a SpacePacket.
+	 */
+	static const uint16_t MINIMUM_SIZE = sizeof(CCSDSPrimaryHeader) + CRC_SIZE;
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	SpacePacketBase( const uint8_t* set_address );
+	/**
+	 * No data is allocated, so the destructor is empty.
+	 */
+	virtual ~SpacePacketBase();
+
+	//CCSDS Methods:
+	/**
+	 * Getter for the packet version number field.
+	 * @return Returns the highest three bit of the packet in one byte.
+	 */
+	uint8_t getPacketVersionNumber( void );
+	/**
+	 * This method checks the type field in the header.
+	 * This bit specifies, if the command is interpreted as Telecommand of
+	 * as Telemetry. For a Telecommand, the bit is set.
+	 * @return Returns true if the bit is set and false if not.
+	 */
+	bool isTelecommand( void );
+
+	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount = 0);
+	/**
+	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
+	 *  which is checked with this method.
+	 * @return	Returns true if the bit is set and false if not.
+	 */
+	bool hasSecondaryHeader( void );
+	/**
+	 * Returns the complete first two bytes of the packet, which together form
+	 * the CCSDS packet id.
+	 * @return	The CCSDS packet id.
+	 */
+	uint16_t getPacketId( void );
+	/**
+	 * Returns the APID of a packet, which are the lowest 11 bit of the packet
+	 * id.
+	 * @return The CCSDS APID.
+	 */
+	uint16_t getAPID( void ) const;
+	/**
+	 * Sets the APID of a packet, which are the lowest 11 bit of the packet
+	 * id.
+	 * @param 	The APID to set. The highest five bits of the parameter are
+	 * 			ignored.
+	 */
+	void setAPID( uint16_t setAPID );
+	/**
+	 * Returns the CCSDS packet sequence control field, which are the third and
+	 * the fourth byte of the CCSDS primary header.
+	 * @return The CCSDS packet sequence control field.
+	 */
+	uint16_t getPacketSequenceControl( void );
+	/**
+	 * Returns the SequenceFlags, which are the highest two bit of the packet
+	 * sequence control field.
+	 * @return	The CCSDS sequence flags.
+	 */
+	uint8_t getSequenceFlags( void );
+	/**
+	 * Returns the packet sequence count, which are the lowest 14 bit of the
+	 * packet sequence control field.
+	 * @return The CCSDS sequence count.
+	 */
+	uint16_t getPacketSequenceCount( void ) const;
+	/**
+	 * Sets the packet sequence count, which are the lowest 14 bit of the
+	 * packet sequence control field.
+	 * setCount is modulo-divided by \c LIMIT_SEQUENCE_COUNT to avoid overflows.
+	 * @param setCount	The value to set the count to.
+	 */
+	void setPacketSequenceCount( uint16_t setCount );
+	/**
+	 * Returns the packet data length, which is the fifth and sixth byte of the
+	 * CCSDS Primary Header. The packet data length is the size of every kind
+	 * of data \b after the CCSDS Primary Header \b -1.
+	 * @return The CCSDS packet data length.
+	 */
+	uint16_t getPacketDataLength( void ); //uint16_t is sufficient, because this is limit in CCSDS standard
+	/**
+	 * Sets the packet data length, which is the fifth and sixth byte of the
+	 * CCSDS Primary Header.
+	 * @param setLength The value of the length to set. It must fit the true
+	 * 					CCSDS packet data length . The packet data length is
+	 * 					the size of every kind of data \b after the CCSDS
+	 * 					Primary Header \b -1.
+	 */
+	void setPacketDataLength( uint16_t setLength );
+
+	//Helper methods:
+	/**
+	 * This method returns a raw uint8_t pointer to the packet.
+	 * @return	A \c uint8_t pointer to the first byte of the CCSDS primary header.
+	 */
+	virtual uint8_t* getWholeData( void );
+
+	uint8_t* getPacketData();
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 * @param p_Data A pointer to another raw Space Packet.
+	 */
+	virtual void setData( const uint8_t* p_Data );
+	/**
+	 * This method returns the full raw packet size.
+	 * @return	The full size of the packet in bytes.
+	 */
+	size_t getFullSize();
+
+	uint32_t getApidAndSequenceCount() const;
+
+};
+
+#endif /* SPACEPACKETBASE_H_ */
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 7b1b89ff6..4f196ac97 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -1,40 +1,40 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
-
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcpacket/pus/TmPacketMinimal.h"
-
-class ApidMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
-private:
-	uint16_t apid;
-public:
-	ApidMatcher(uint16_t setApid) :
-			apid(setApid) {
-	}
-	ApidMatcher(TmPacketMinimal* test) :
-			apid(test->getAPID()) {
-	}
-	bool match(TmPacketMinimal* packet) {
-		if (packet->getAPID() == apid) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&apid);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
-	}
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class ApidMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+private:
+	uint16_t apid;
+public:
+	ApidMatcher(uint16_t setApid) :
+			apid(setApid) {
+	}
+	ApidMatcher(TmPacketMinimal* test) :
+			apid(test->getAPID()) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getAPID() == apid) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&apid);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
+	}
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_ */
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.cpp b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
index 356467dca..610829e5f 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.cpp
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
@@ -1,195 +1,195 @@
-#include "../../tmtcpacket/packetmatcher/ApidMatcher.h"
-#include "../../tmtcpacket/packetmatcher/PacketMatchTree.h"
-#include "../../tmtcpacket/packetmatcher/ServiceMatcher.h"
-#include "../../tmtcpacket/packetmatcher/SubserviceMatcher.h"
-
-PacketMatchTree::PacketMatchTree(Node* root) :
-		MatchTree<TmPacketMinimal*>(root, 2), factoryBackend(0, POOL_SIZES,
-				N_ELEMENTS, false, true), factory(&factoryBackend) {
-}
-
-PacketMatchTree::PacketMatchTree(iterator root) :
-		MatchTree<TmPacketMinimal*>(root.element, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
-}
-
-PacketMatchTree::PacketMatchTree() :
-		MatchTree<TmPacketMinimal*>((Node*) NULL, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
-}
-
-PacketMatchTree::~PacketMatchTree() {
-}
-
-ReturnValue_t PacketMatchTree::addMatch(uint16_t apid, uint8_t type,
-		uint8_t subtype) {
-	//We assume adding APID is always requested.
-	TmPacketMinimal::TmPacketMinimalPointer data;
-	data.data_field.service_type = type;
-	data.data_field.service_subtype = subtype;
-	TmPacketMinimal testPacket((uint8_t*) &data);
-	testPacket.setAPID(apid);
-	iterator lastTest;
-	iterator rollback;
-	ReturnValue_t result = findOrInsertMatch<TmPacketMinimal*, ApidMatcher>(
-			this->begin(), &testPacket, &lastTest);
-	if (result == NEW_NODE_CREATED) {
-		rollback = lastTest;
-	} else if (result != RETURN_OK) {
-		return result;
-	}
-	if (type == 0) {
-		//Check if lastTest has no children, otherwise, delete them,
-		//as a more general check is requested.
-		if (lastTest.left() != this->end()) {
-			removeElementAndAllChildren(lastTest.left());
-		}
-		return RETURN_OK;
-	}
-	//Type insertion required.
-	result = findOrInsertMatch<TmPacketMinimal*, ServiceMatcher>(
-			lastTest.left(), &testPacket, &lastTest);
-	if (result == NEW_NODE_CREATED) {
-		if  (rollback == this->end()) {
-			rollback = lastTest;
-		}
-	} else if (result != RETURN_OK) {
-		if (rollback != this->end()) {
-			removeElementAndAllChildren(rollback);
-		}
-		return result;
-	}
-	if (subtype == 0) {
-		if (lastTest.left() != this->end()) {
-			//See above
-			removeElementAndAllChildren(lastTest.left());
-		}
-		return RETURN_OK;
-	}
-	//Subtype insertion required.
-	result = findOrInsertMatch<TmPacketMinimal*, SubServiceMatcher>(
-			lastTest.left(), &testPacket, &lastTest);
-	if (result == NEW_NODE_CREATED) {
-		return RETURN_OK;
-	} else if (result != RETURN_OK) {
-		if (rollback != this->end()) {
-			removeElementAndAllChildren(rollback);
-		}
-		return result;
-	}
-	return RETURN_OK;
-}
-
-template<typename VALUE_T, typename INSERTION_T>
-ReturnValue_t PacketMatchTree::findOrInsertMatch(iterator startAt, VALUE_T test,
-		iterator* lastTest) {
-	bool attachToBranch = AND;
-	iterator iter = startAt;
-	while (iter != this->end()) {
-		bool isMatch = iter->match(test);
-		attachToBranch = OR;
-		*lastTest = iter;
-		if (isMatch) {
-			return RETURN_OK;
-		} else {
-			//Go down OR branch.
-			iter = iter.right();
-		}
-	}
-	//Only reached if nothing was found.
-	SerializeableMatcherIF<VALUE_T>* newContent = factory.generate<INSERTION_T>(
-			test);
-	if (newContent == NULL) {
-		return FULL;
-	}
-	Node* newNode = factory.generate<Node>(newContent);
-	if (newNode == NULL) {
-		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
-		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
-		return FULL;
-	}
-	*lastTest = insert(attachToBranch, *lastTest, newNode);
-	if (*lastTest == end()) {
-		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
-		return RETURN_FAILED;
-	}
-	return NEW_NODE_CREATED;
-}
-
-ReturnValue_t PacketMatchTree::removeMatch(uint16_t apid, uint8_t type,
-		uint8_t subtype) {
-	TmPacketMinimal::TmPacketMinimalPointer data;
-	data.data_field.service_type = type;
-	data.data_field.service_subtype = subtype;
-	TmPacketMinimal testPacket((uint8_t*) &data);
-	testPacket.setAPID(apid);
-	iterator foundElement = findMatch(begin(), &testPacket);
-	if (foundElement == this->end()) {
-		return NO_MATCH;
-	}
-	if (type == 0) {
-		if (foundElement.left() == end()) {
-			return removeElementAndReconnectChildren(foundElement);
-		} else {
-			return TOO_GENERAL_REQUEST;
-		}
-	}
-	//Go down AND branch. Will abort if empty.
-	foundElement = findMatch(foundElement.left(), &testPacket);
-	if (foundElement == this->end()) {
-		return NO_MATCH;
-	}
-	if (subtype == 0) {
-		if (foundElement.left() == end()) {
-			return removeElementAndReconnectChildren(foundElement);
-		} else {
-			return TOO_GENERAL_REQUEST;
-		}
-	}
-	//Again, go down AND branch.
-	foundElement = findMatch(foundElement.left(), &testPacket);
-	if (foundElement == end()) {
-		return NO_MATCH;
-	}
-	return removeElementAndReconnectChildren(foundElement);
-}
-
-PacketMatchTree::iterator PacketMatchTree::findMatch(iterator startAt,
-		TmPacketMinimal* test) {
-	iterator iter = startAt;
-	while (iter != end()) {
-		bool isMatch = iter->match(test);
-		if (isMatch) {
-			break;
-		} else {
-			iter = iter.right(); //next OR element
-		}
-	}
-	return iter;
-}
-
-ReturnValue_t PacketMatchTree::initialize() {
-	return factoryBackend.initialize();
-}
-
-const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
-		sizeof(SubServiceMatcher), sizeof(ApidMatcher),
-		sizeof(PacketMatchTree::Node) };
-//Maximum number of types and subtypes to filter should be more than sufficient.
-const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
-
-ReturnValue_t PacketMatchTree::changeMatch(bool addToMatch, uint16_t apid,
-		uint8_t type, uint8_t subtype) {
-	if (addToMatch) {
-		return addMatch(apid, type, subtype);
-	} else {
-		return removeMatch(apid, type, subtype);
-	}
-}
-
-ReturnValue_t PacketMatchTree::cleanUpElement(iterator position) {
-	factory.destroy(position.element->value);
-	//Go on anyway, there's nothing we can do.
-	//SHOULDDO: Throw event, or write debug message?
-	return factory.destroy(position.element);
-}
+#include "../../tmtcpacket/packetmatcher/ApidMatcher.h"
+#include "../../tmtcpacket/packetmatcher/PacketMatchTree.h"
+#include "../../tmtcpacket/packetmatcher/ServiceMatcher.h"
+#include "../../tmtcpacket/packetmatcher/SubserviceMatcher.h"
+
+PacketMatchTree::PacketMatchTree(Node* root) :
+		MatchTree<TmPacketMinimal*>(root, 2), factoryBackend(0, POOL_SIZES,
+				N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::PacketMatchTree(iterator root) :
+		MatchTree<TmPacketMinimal*>(root.element, 2), factoryBackend(0,
+				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::PacketMatchTree() :
+		MatchTree<TmPacketMinimal*>((Node*) NULL, 2), factoryBackend(0,
+				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::~PacketMatchTree() {
+}
+
+ReturnValue_t PacketMatchTree::addMatch(uint16_t apid, uint8_t type,
+		uint8_t subtype) {
+	//We assume adding APID is always requested.
+	TmPacketMinimal::TmPacketMinimalPointer data;
+	data.data_field.service_type = type;
+	data.data_field.service_subtype = subtype;
+	TmPacketMinimal testPacket((uint8_t*) &data);
+	testPacket.setAPID(apid);
+	iterator lastTest;
+	iterator rollback;
+	ReturnValue_t result = findOrInsertMatch<TmPacketMinimal*, ApidMatcher>(
+			this->begin(), &testPacket, &lastTest);
+	if (result == NEW_NODE_CREATED) {
+		rollback = lastTest;
+	} else if (result != RETURN_OK) {
+		return result;
+	}
+	if (type == 0) {
+		//Check if lastTest has no children, otherwise, delete them,
+		//as a more general check is requested.
+		if (lastTest.left() != this->end()) {
+			removeElementAndAllChildren(lastTest.left());
+		}
+		return RETURN_OK;
+	}
+	//Type insertion required.
+	result = findOrInsertMatch<TmPacketMinimal*, ServiceMatcher>(
+			lastTest.left(), &testPacket, &lastTest);
+	if (result == NEW_NODE_CREATED) {
+		if  (rollback == this->end()) {
+			rollback = lastTest;
+		}
+	} else if (result != RETURN_OK) {
+		if (rollback != this->end()) {
+			removeElementAndAllChildren(rollback);
+		}
+		return result;
+	}
+	if (subtype == 0) {
+		if (lastTest.left() != this->end()) {
+			//See above
+			removeElementAndAllChildren(lastTest.left());
+		}
+		return RETURN_OK;
+	}
+	//Subtype insertion required.
+	result = findOrInsertMatch<TmPacketMinimal*, SubServiceMatcher>(
+			lastTest.left(), &testPacket, &lastTest);
+	if (result == NEW_NODE_CREATED) {
+		return RETURN_OK;
+	} else if (result != RETURN_OK) {
+		if (rollback != this->end()) {
+			removeElementAndAllChildren(rollback);
+		}
+		return result;
+	}
+	return RETURN_OK;
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+ReturnValue_t PacketMatchTree::findOrInsertMatch(iterator startAt, VALUE_T test,
+		iterator* lastTest) {
+	bool attachToBranch = AND;
+	iterator iter = startAt;
+	while (iter != this->end()) {
+		bool isMatch = iter->match(test);
+		attachToBranch = OR;
+		*lastTest = iter;
+		if (isMatch) {
+			return RETURN_OK;
+		} else {
+			//Go down OR branch.
+			iter = iter.right();
+		}
+	}
+	//Only reached if nothing was found.
+	SerializeableMatcherIF<VALUE_T>* newContent = factory.generate<INSERTION_T>(
+			test);
+	if (newContent == NULL) {
+		return FULL;
+	}
+	Node* newNode = factory.generate<Node>(newContent);
+	if (newNode == NULL) {
+		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
+		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
+		return FULL;
+	}
+	*lastTest = insert(attachToBranch, *lastTest, newNode);
+	if (*lastTest == end()) {
+		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
+		return RETURN_FAILED;
+	}
+	return NEW_NODE_CREATED;
+}
+
+ReturnValue_t PacketMatchTree::removeMatch(uint16_t apid, uint8_t type,
+		uint8_t subtype) {
+	TmPacketMinimal::TmPacketMinimalPointer data;
+	data.data_field.service_type = type;
+	data.data_field.service_subtype = subtype;
+	TmPacketMinimal testPacket((uint8_t*) &data);
+	testPacket.setAPID(apid);
+	iterator foundElement = findMatch(begin(), &testPacket);
+	if (foundElement == this->end()) {
+		return NO_MATCH;
+	}
+	if (type == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	//Go down AND branch. Will abort if empty.
+	foundElement = findMatch(foundElement.left(), &testPacket);
+	if (foundElement == this->end()) {
+		return NO_MATCH;
+	}
+	if (subtype == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	//Again, go down AND branch.
+	foundElement = findMatch(foundElement.left(), &testPacket);
+	if (foundElement == end()) {
+		return NO_MATCH;
+	}
+	return removeElementAndReconnectChildren(foundElement);
+}
+
+PacketMatchTree::iterator PacketMatchTree::findMatch(iterator startAt,
+		TmPacketMinimal* test) {
+	iterator iter = startAt;
+	while (iter != end()) {
+		bool isMatch = iter->match(test);
+		if (isMatch) {
+			break;
+		} else {
+			iter = iter.right(); //next OR element
+		}
+	}
+	return iter;
+}
+
+ReturnValue_t PacketMatchTree::initialize() {
+	return factoryBackend.initialize();
+}
+
+const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
+		sizeof(SubServiceMatcher), sizeof(ApidMatcher),
+		sizeof(PacketMatchTree::Node) };
+//Maximum number of types and subtypes to filter should be more than sufficient.
+const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
+
+ReturnValue_t PacketMatchTree::changeMatch(bool addToMatch, uint16_t apid,
+		uint8_t type, uint8_t subtype) {
+	if (addToMatch) {
+		return addMatch(apid, type, subtype);
+	} else {
+		return removeMatch(apid, type, subtype);
+	}
+}
+
+ReturnValue_t PacketMatchTree::cleanUpElement(iterator position) {
+	factory.destroy(position.element->value);
+	//Go on anyway, there's nothing we can do.
+	//SHOULDDO: Throw event, or write debug message?
+	return factory.destroy(position.element);
+}
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.h b/tmtcpacket/packetmatcher/PacketMatchTree.h
index 0d246d21a..86fb087ed 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.h
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.h
@@ -1,36 +1,36 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
-
-#include "../../container/PlacementFactory.h"
-#include "../../globalfunctions/matching/MatchTree.h"
-#include "../../storagemanager/LocalPool.h"
-#include "../../tmtcpacket/pus/TmPacketMinimal.h"
-
-class PacketMatchTree: public MatchTree<TmPacketMinimal*>, public HasReturnvaluesIF {
-public:
-	PacketMatchTree(Node* root);
-	PacketMatchTree(iterator root);
-	PacketMatchTree();
-	virtual ~PacketMatchTree();
-	ReturnValue_t changeMatch(bool addToMatch, uint16_t apid, uint8_t type = 0,
-			uint8_t subtype = 0);
-	ReturnValue_t addMatch(uint16_t apid, uint8_t type = 0,
-			uint8_t subtype = 0);
-	ReturnValue_t removeMatch(uint16_t apid, uint8_t type = 0,
-			uint8_t subtype = 0);
-	ReturnValue_t initialize();
-protected:
-	ReturnValue_t cleanUpElement(iterator position);
-private:
-	static const uint8_t N_POOLS = 4;
-	LocalPool<N_POOLS> factoryBackend;
-	PlacementFactory factory;
-	static const uint16_t POOL_SIZES[N_POOLS];
-	static const uint16_t N_ELEMENTS[N_POOLS];
-	template<typename VALUE_T, typename INSERTION_T>
-	ReturnValue_t findOrInsertMatch(iterator startAt, VALUE_T test, iterator* lastTest);
-	iterator findMatch(iterator startAt, TmPacketMinimal* test);
-};
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ */
-
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
+
+#include "../../container/PlacementFactory.h"
+#include "../../globalfunctions/matching/MatchTree.h"
+#include "../../storagemanager/LocalPool.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class PacketMatchTree: public MatchTree<TmPacketMinimal*>, public HasReturnvaluesIF {
+public:
+	PacketMatchTree(Node* root);
+	PacketMatchTree(iterator root);
+	PacketMatchTree();
+	virtual ~PacketMatchTree();
+	ReturnValue_t changeMatch(bool addToMatch, uint16_t apid, uint8_t type = 0,
+			uint8_t subtype = 0);
+	ReturnValue_t addMatch(uint16_t apid, uint8_t type = 0,
+			uint8_t subtype = 0);
+	ReturnValue_t removeMatch(uint16_t apid, uint8_t type = 0,
+			uint8_t subtype = 0);
+	ReturnValue_t initialize();
+protected:
+	ReturnValue_t cleanUpElement(iterator position);
+private:
+	static const uint8_t N_POOLS = 4;
+	LocalPool<N_POOLS> factoryBackend;
+	PlacementFactory factory;
+	static const uint16_t POOL_SIZES[N_POOLS];
+	static const uint16_t N_ELEMENTS[N_POOLS];
+	template<typename VALUE_T, typename INSERTION_T>
+	ReturnValue_t findOrInsertMatch(iterator startAt, VALUE_T test, iterator* lastTest);
+	iterator findMatch(iterator startAt, TmPacketMinimal* test);
+};
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ */
+
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index e22288f47..eba23d755 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -1,39 +1,39 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
-
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcpacket/pus/TmPacketMinimal.h"
-
-class ServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
-private:
-	uint8_t service;
-public:
-	ServiceMatcher(uint8_t setService) :
-			service(setService) {
-	}
-	ServiceMatcher(TmPacketMinimal* test) :
-			service(test->getService()) {
-	}
-	bool match(TmPacketMinimal* packet) {
-		if (packet->getService() == service) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&service);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
-	}
-};
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class ServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+private:
+	uint8_t service;
+public:
+	ServiceMatcher(uint8_t setService) :
+			service(setService) {
+	}
+	ServiceMatcher(TmPacketMinimal* test) :
+			service(test->getService()) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getService() == service) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&service);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
+	}
+};
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_ */
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 1b173b1a2..a9b6def89 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -1,40 +1,40 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
-
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcpacket/pus/TmPacketMinimal.h"
-
-class SubServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
-public:
-	SubServiceMatcher(uint8_t subService) :
-			subService(subService) {
-	}
-	SubServiceMatcher(TmPacketMinimal* test) :
-			subService(test->getSubService()) {
-	}
-	bool match(TmPacketMinimal* packet) {
-		if (packet->getSubService() == subService) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&subService);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
-	}
-private:
-	uint8_t subService;
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class SubServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+public:
+	SubServiceMatcher(uint8_t subService) :
+			subService(subService) {
+	}
+	SubServiceMatcher(TmPacketMinimal* test) :
+			subService(test->getSubService()) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getSubService() == subService) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&subService);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
+	}
+private:
+	uint8_t subService;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_ */
diff --git a/tmtcpacket/pus/PacketTimestampInterpreterIF.h b/tmtcpacket/pus/PacketTimestampInterpreterIF.h
index 9e442ed66..dd0c03285 100644
--- a/tmtcpacket/pus/PacketTimestampInterpreterIF.h
+++ b/tmtcpacket/pus/PacketTimestampInterpreterIF.h
@@ -1,16 +1,16 @@
-#ifndef FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
-#define FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-class TmPacketMinimal;
-
-class PacketTimestampInterpreterIF {
-public:
-	virtual ~PacketTimestampInterpreterIF() {}
-	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet, timeval* timestamp) const = 0;
-	virtual ReturnValue_t getPacketTimeRaw(TmPacketMinimal* packet, const uint8_t** timePtr, uint32_t* size) const = 0;
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
+#define FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+class TmPacketMinimal;
+
+class PacketTimestampInterpreterIF {
+public:
+	virtual ~PacketTimestampInterpreterIF() {}
+	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet, timeval* timestamp) const = 0;
+	virtual ReturnValue_t getPacketTimeRaw(TmPacketMinimal* packet, const uint8_t** timePtr, uint32_t* size) const = 0;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_ */
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 3dc158725..b62db535e 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -1,93 +1,93 @@
-#include "../../globalfunctions/CRC.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TcPacketBase.h"
-#include <string.h>
-
-TcPacketBase::TcPacketBase(const uint8_t* set_data) :
-		SpacePacketBase(set_data) {
-	tcData = (TcPacketPointer*) set_data;
-}
-
-TcPacketBase::~TcPacketBase() {
-	//Nothing to do.
-}
-
-uint8_t TcPacketBase::getService() {
-	return tcData->dataField.service_type;
-}
-
-uint8_t TcPacketBase::getSubService() {
-	return tcData->dataField.service_subtype;
-}
-
-uint8_t TcPacketBase::getAcknowledgeFlags() {
-	return tcData->dataField.version_type_ack & 0b00001111;
-}
-
-const uint8_t* TcPacketBase::getApplicationData() const {
-	return &tcData->appData;
-}
-
-uint16_t TcPacketBase::getApplicationDataSize() {
-	return getPacketDataLength() - sizeof(tcData->dataField) - CRC_SIZE + 1;
-}
-
-uint16_t TcPacketBase::getErrorControl() {
-	uint16_t size = getApplicationDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tcData->appData;
-	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
-}
-
-void TcPacketBase::setErrorControl() {
-	uint32_t full_size = getFullSize();
-	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
-	uint32_t size = getApplicationDataSize();
-	(&tcData->appData)[size] = (crc & 0XFF00) >> 8;	// CRCH
-	(&tcData->appData)[size + 1] = (crc) & 0X00FF; 		// CRCL
-}
-
-void TcPacketBase::setData(const uint8_t* pData) {
-	SpacePacketBase::setData(pData);
-	tcData = (TcPacketPointer*) pData;
-}
-
-void TcPacketBase::setAppData(uint8_t * appData, uint16_t dataLen) {
-	memcpy(&tcData->appData, appData, dataLen);
-	SpacePacketBase::setPacketDataLength(dataLen +
-				sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
-}
-
-uint8_t TcPacketBase::getSecondaryHeaderFlag() {
-	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
-}
-
-uint8_t TcPacketBase::getPusVersionNumber() {
-	return (tcData->dataField.version_type_ack & 0b01110000) >> 4;
-}
-
-void TcPacketBase::print() {
-	uint8_t * wholeData = getWholeData();
-	sif::debug << "TcPacket contains: " << std::endl;
-	for (uint8_t count = 0; count < getFullSize(); ++count) {
-		sif::debug << std::hex << (uint16_t) wholeData[count] << " ";
-	}
-	sif::debug << std::dec << std::endl;
-}
-
-void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
-		uint8_t ack, uint8_t service, uint8_t subservice) {
-	initSpacePacketHeader(true, true, apid, sequenceCount);
-	memset(&tcData->dataField, 0, sizeof(tcData->dataField));
-	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
-	//Data Field Header:
-	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
-	tcData->dataField.version_type_ack = 0b00010000;
-	tcData->dataField.version_type_ack |= (ack & 0x0F);
-	tcData->dataField.service_type = service;
-	tcData->dataField.service_subtype = subservice;
-}
-
-size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
-	return sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) +
-			appDataLen + TcPacketBase::CRC_SIZE;
-}
+#include "../../globalfunctions/CRC.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TcPacketBase.h"
+#include <string.h>
+
+TcPacketBase::TcPacketBase(const uint8_t* set_data) :
+		SpacePacketBase(set_data) {
+	tcData = (TcPacketPointer*) set_data;
+}
+
+TcPacketBase::~TcPacketBase() {
+	//Nothing to do.
+}
+
+uint8_t TcPacketBase::getService() {
+	return tcData->dataField.service_type;
+}
+
+uint8_t TcPacketBase::getSubService() {
+	return tcData->dataField.service_subtype;
+}
+
+uint8_t TcPacketBase::getAcknowledgeFlags() {
+	return tcData->dataField.version_type_ack & 0b00001111;
+}
+
+const uint8_t* TcPacketBase::getApplicationData() const {
+	return &tcData->appData;
+}
+
+uint16_t TcPacketBase::getApplicationDataSize() {
+	return getPacketDataLength() - sizeof(tcData->dataField) - CRC_SIZE + 1;
+}
+
+uint16_t TcPacketBase::getErrorControl() {
+	uint16_t size = getApplicationDataSize() + CRC_SIZE;
+	uint8_t* p_to_buffer = &tcData->appData;
+	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
+}
+
+void TcPacketBase::setErrorControl() {
+	uint32_t full_size = getFullSize();
+	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
+	uint32_t size = getApplicationDataSize();
+	(&tcData->appData)[size] = (crc & 0XFF00) >> 8;	// CRCH
+	(&tcData->appData)[size + 1] = (crc) & 0X00FF; 		// CRCL
+}
+
+void TcPacketBase::setData(const uint8_t* pData) {
+	SpacePacketBase::setData(pData);
+	tcData = (TcPacketPointer*) pData;
+}
+
+void TcPacketBase::setAppData(uint8_t * appData, uint16_t dataLen) {
+	memcpy(&tcData->appData, appData, dataLen);
+	SpacePacketBase::setPacketDataLength(dataLen +
+				sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
+}
+
+uint8_t TcPacketBase::getSecondaryHeaderFlag() {
+	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
+}
+
+uint8_t TcPacketBase::getPusVersionNumber() {
+	return (tcData->dataField.version_type_ack & 0b01110000) >> 4;
+}
+
+void TcPacketBase::print() {
+	uint8_t * wholeData = getWholeData();
+	sif::debug << "TcPacket contains: " << std::endl;
+	for (uint8_t count = 0; count < getFullSize(); ++count) {
+		sif::debug << std::hex << (uint16_t) wholeData[count] << " ";
+	}
+	sif::debug << std::dec << std::endl;
+}
+
+void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
+		uint8_t ack, uint8_t service, uint8_t subservice) {
+	initSpacePacketHeader(true, true, apid, sequenceCount);
+	memset(&tcData->dataField, 0, sizeof(tcData->dataField));
+	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
+	//Data Field Header:
+	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
+	tcData->dataField.version_type_ack = 0b00010000;
+	tcData->dataField.version_type_ack |= (ack & 0x0F);
+	tcData->dataField.service_type = service;
+	tcData->dataField.service_subtype = subservice;
+}
+
+size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
+	return sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) +
+			appDataLen + TcPacketBase::CRC_SIZE;
+}
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index 1cfe233b9..b3ef5fe7b 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -1,204 +1,204 @@
-#ifndef TCPACKETBASE_H_
-#define TCPACKETBASE_H_
-
-#include "../../tmtcpacket/SpacePacketBase.h"
-#include <cstddef>
-
-/**
- * This struct defines a byte-wise structured PUS TC Data Field Header.
- * Any optional fields in the header must be added or removed here.
- * Currently, the Source Id field is present with one byte.
- * @ingroup tmtcpackets
- */
-struct PUSTcDataFieldHeader {
-	uint8_t version_type_ack;
-	uint8_t service_type;
-	uint8_t service_subtype;
-	uint8_t source_id;
-};
-
-/**
- * This struct defines the data structure of a PUS Telecommand Packet when
- * accessed via a pointer.
- * @ingroup tmtcpackets
- */
-struct TcPacketPointer {
-	CCSDSPrimaryHeader primary;
-	PUSTcDataFieldHeader dataField;
-	uint8_t appData;
-};
-
-/**
- * This class is the basic data handler for any ECSS PUS Telecommand packet.
- *
- * In addition to \SpacePacketBase, the class provides methods to handle
- * the standardized entries of the PUS TC Packet Data Field Header.
- * It does not contain the packet data itself but a pointer to the
- * data must be set on instantiation. An invalid pointer may cause
- * damage, as no getter method checks data validity. Anyway, a NULL
- * check can be performed by making use of the getWholeData method.
- * @ingroup tmtcpackets
- */
-class TcPacketBase : public SpacePacketBase {
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TcPacketPointer* tcData;
-public:
-	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) + 2);
-	/**
-	 * With this constant for the acknowledge field responses on all levels are expected.
-	 */
-	static const uint8_t ACK_ALL = 0b1111;
-	/**
-	 * With this constant for the acknowledge field a response on acceptance is expected.
-	 */
-	static const uint8_t ACK_ACCEPTANCE = 0b0001;
-	/**
-	 * With this constant for the acknowledge field a response on start of execution is expected.
-	 */
-	static const uint8_t ACK_START = 0b0010;
-	/**
-	 * With this constant for the acknowledge field responses on execution steps are expected.
-	 */
-	static const uint8_t ACK_STEP = 0b0100;
-	/**
-	 * With this constant for the acknowledge field a response on completion is expected.
-	 */
-	static const uint8_t ACK_COMPLETION = 0b1000;
-	/**
-	 * With this constant for the acknowledge field no responses are expected.
-	 */
-	static const uint8_t ACK_NONE = 0b000;
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed and also
-	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	TcPacketBase( const uint8_t* set_data );
-	/**
-	 * This is the empty default destructor.
-	 */
-	virtual ~TcPacketBase();
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param sequenceCount Sequence Count in the primary header.
-	 * @param ack Which acknowledeges are expected from the receiver.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 */
-	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
-			uint8_t service, uint8_t subservice);
-	/**
-	 * This command returns the CCSDS Secondary Header Flag.
-	 * It shall always be zero for PUS Packets. This is the
-	 * highest bit of the first byte of the Data Field Header.
-	 * @return	the CCSDS Secondary Header Flag
-	 */
-	uint8_t getSecondaryHeaderFlag();
-	/**
-	 * This command returns the TC Packet PUS Version Number.
-	 * The version number of ECSS PUS 2003 is 1.
-	 * It consists of the second to fourth highest bits of the
-	 * first byte.
-	 * @return
-	 */
-	uint8_t getPusVersionNumber();
-	/**
-	 * This is a getter for the packet's Ack field, which are the lowest four
-	 * bits of the first byte of the Data Field Header.
-	 *
-	 * It is packed in a uint8_t variable.
-	 * @return	The packet's PUS Ack field.
-	 */
-	uint8_t getAcknowledgeFlags();
-	/**
-	 * This is a getter for the packet's PUS Service ID, which is the second
-	 * byte of the Data Field Header.
-	 * @return	The packet's PUS Service ID.
-	 */
-	uint8_t getService();
-	/**
-	 * This is a getter for the packet's PUS Service Subtype, which is the
-	 * third byte of the Data Field Header.
-	 * @return	The packet's PUS Service Subtype.
-	 */
-	uint8_t getSubService();
-	/**
-	 * This is a getter for a pointer to the packet's Application data.
-	 *
-	 * These are the bytes that follow after the Data Field Header. They form
-	 * the packet's application data.
-	 * @return	A pointer to the PUS Application Data.
-	 */
-	const uint8_t* getApplicationData() const;
-	/**
-	 * This method calculates the size of the PUS Application data field.
-	 *
-	 * It takes the information stored in the CCSDS Packet Data Length field
-	 * and subtracts the Data Field Header size and the CRC size.
-	 * @return	The size of the PUS Application Data (without Error Control
-	 * 		field)
-	 */
-	uint16_t getApplicationDataSize();
-	/**
-	 * This getter returns the Error Control Field of the packet.
-	 *
-	 * The field is placed after any possible Application Data. If no
-	 * Application Data is present there's still an Error Control field. It is
-	 * supposed to be a 16bit-CRC.
-	 * @return	The PUS Error Control
-	 */
-	uint16_t getErrorControl();
-	/**
-	 * With this method, the Error Control Field is updated to match the
-	 * current content of the packet.
-	 */
-	void setErrorControl();
-
-	/**
-	 * Copies the supplied data to the internal TC application data field.
-	 * @param pData
-	 * @param dataLen
-	 */
-	void setAppData(uint8_t * appData, uint16_t dataLen);
-
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telecommand Packet.
-	 */
-	void setData( const uint8_t* pData );
-
-	/**
-	 * This is a debugging helper method that prints the whole packet content
-	 * to the screen.
-	 */
-	void print();
-	/**
-	 * Calculate full packet length from application data length.
-	 * @param appDataLen
-	 * @return
-	 */
-	static size_t calculateFullPacketLength(size_t appDataLen);
-};
-
-
-#endif /* TCPACKETBASE_H_ */
+#ifndef TCPACKETBASE_H_
+#define TCPACKETBASE_H_
+
+#include "../../tmtcpacket/SpacePacketBase.h"
+#include <cstddef>
+
+/**
+ * This struct defines a byte-wise structured PUS TC Data Field Header.
+ * Any optional fields in the header must be added or removed here.
+ * Currently, the Source Id field is present with one byte.
+ * @ingroup tmtcpackets
+ */
+struct PUSTcDataFieldHeader {
+	uint8_t version_type_ack;
+	uint8_t service_type;
+	uint8_t service_subtype;
+	uint8_t source_id;
+};
+
+/**
+ * This struct defines the data structure of a PUS Telecommand Packet when
+ * accessed via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct TcPacketPointer {
+	CCSDSPrimaryHeader primary;
+	PUSTcDataFieldHeader dataField;
+	uint8_t appData;
+};
+
+/**
+ * This class is the basic data handler for any ECSS PUS Telecommand packet.
+ *
+ * In addition to \SpacePacketBase, the class provides methods to handle
+ * the standardized entries of the PUS TC Packet Data Field Header.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * @ingroup tmtcpackets
+ */
+class TcPacketBase : public SpacePacketBase {
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet's data.
+	 *
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	TcPacketPointer* tcData;
+public:
+	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) + 2);
+	/**
+	 * With this constant for the acknowledge field responses on all levels are expected.
+	 */
+	static const uint8_t ACK_ALL = 0b1111;
+	/**
+	 * With this constant for the acknowledge field a response on acceptance is expected.
+	 */
+	static const uint8_t ACK_ACCEPTANCE = 0b0001;
+	/**
+	 * With this constant for the acknowledge field a response on start of execution is expected.
+	 */
+	static const uint8_t ACK_START = 0b0010;
+	/**
+	 * With this constant for the acknowledge field responses on execution steps are expected.
+	 */
+	static const uint8_t ACK_STEP = 0b0100;
+	/**
+	 * With this constant for the acknowledge field a response on completion is expected.
+	 */
+	static const uint8_t ACK_COMPLETION = 0b1000;
+	/**
+	 * With this constant for the acknowledge field no responses are expected.
+	 */
+	static const uint8_t ACK_NONE = 0b000;
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed and also
+	 * forwards the data pointer to the parent SpacePacketBase class.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	TcPacketBase( const uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TcPacketBase();
+	/**
+	 * Initializes the Tc Packet header.
+	 * @param apid APID used.
+	 * @param service	PUS Service
+	 * @param subservice PUS Subservice
+	 * @param packetSubcounter Additional subcounter used.
+	 */
+	/**
+	 * Initializes the Tc Packet header.
+	 * @param apid APID used.
+	 * @param sequenceCount Sequence Count in the primary header.
+	 * @param ack Which acknowledeges are expected from the receiver.
+	 * @param service	PUS Service
+	 * @param subservice PUS Subservice
+	 */
+	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
+			uint8_t service, uint8_t subservice);
+	/**
+	 * This command returns the CCSDS Secondary Header Flag.
+	 * It shall always be zero for PUS Packets. This is the
+	 * highest bit of the first byte of the Data Field Header.
+	 * @return	the CCSDS Secondary Header Flag
+	 */
+	uint8_t getSecondaryHeaderFlag();
+	/**
+	 * This command returns the TC Packet PUS Version Number.
+	 * The version number of ECSS PUS 2003 is 1.
+	 * It consists of the second to fourth highest bits of the
+	 * first byte.
+	 * @return
+	 */
+	uint8_t getPusVersionNumber();
+	/**
+	 * This is a getter for the packet's Ack field, which are the lowest four
+	 * bits of the first byte of the Data Field Header.
+	 *
+	 * It is packed in a uint8_t variable.
+	 * @return	The packet's PUS Ack field.
+	 */
+	uint8_t getAcknowledgeFlags();
+	/**
+	 * This is a getter for the packet's PUS Service ID, which is the second
+	 * byte of the Data Field Header.
+	 * @return	The packet's PUS Service ID.
+	 */
+	uint8_t getService();
+	/**
+	 * This is a getter for the packet's PUS Service Subtype, which is the
+	 * third byte of the Data Field Header.
+	 * @return	The packet's PUS Service Subtype.
+	 */
+	uint8_t getSubService();
+	/**
+	 * This is a getter for a pointer to the packet's Application data.
+	 *
+	 * These are the bytes that follow after the Data Field Header. They form
+	 * the packet's application data.
+	 * @return	A pointer to the PUS Application Data.
+	 */
+	const uint8_t* getApplicationData() const;
+	/**
+	 * This method calculates the size of the PUS Application data field.
+	 *
+	 * It takes the information stored in the CCSDS Packet Data Length field
+	 * and subtracts the Data Field Header size and the CRC size.
+	 * @return	The size of the PUS Application Data (without Error Control
+	 * 		field)
+	 */
+	uint16_t getApplicationDataSize();
+	/**
+	 * This getter returns the Error Control Field of the packet.
+	 *
+	 * The field is placed after any possible Application Data. If no
+	 * Application Data is present there's still an Error Control field. It is
+	 * supposed to be a 16bit-CRC.
+	 * @return	The PUS Error Control
+	 */
+	uint16_t getErrorControl();
+	/**
+	 * With this method, the Error Control Field is updated to match the
+	 * current content of the packet.
+	 */
+	void setErrorControl();
+
+	/**
+	 * Copies the supplied data to the internal TC application data field.
+	 * @param pData
+	 * @param dataLen
+	 */
+	void setAppData(uint8_t * appData, uint16_t dataLen);
+
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 *
+	 * This call overwrites the parent's setData method to set both its
+	 * \c tc_data pointer and the parent's \c data pointer.
+	 *
+	 * @param p_data	A pointer to another PUS Telecommand Packet.
+	 */
+	void setData( const uint8_t* pData );
+
+	/**
+	 * This is a debugging helper method that prints the whole packet content
+	 * to the screen.
+	 */
+	void print();
+	/**
+	 * Calculate full packet length from application data length.
+	 * @param appDataLen
+	 * @return
+	 */
+	static size_t calculateFullPacketLength(size_t appDataLen);
+};
+
+
+#endif /* TCPACKETBASE_H_ */
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 64b369eae..d34745691 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -1,118 +1,118 @@
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TcPacketStored.h"
-
-#include <cstring>
-
-TcPacketStored::TcPacketStored(store_address_t setAddress) :
-		TcPacketBase(nullptr), storeAddress(setAddress) {
-	this->setStoreAddress(this->storeAddress);
-}
-
-TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
-		uint16_t apid, uint8_t sequence_count, const uint8_t* data,
-		size_t size, uint8_t ack ) :
-		TcPacketBase(nullptr) {
-	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!this->checkAndSetStore()) {
-		return;
-	}
-	uint8_t* p_data = nullptr;
-	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
-			(TC_PACKET_MIN_SIZE + size), &p_data);
-	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
-		sif::warning << "TcPacketStored::TcPacketStored: Could not get "
-				"free element from store!" << std::endl;
-		return;
-	}
-	this->setData(p_data);
-	initializeTcPacket(apid, sequence_count, ack, service, subservice);
-	memcpy(&tcData->appData, data, size);
-	this->setPacketDataLength(
-			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
-	this->setErrorControl();
-}
-
-ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
-		size_t* dataSize) {
-	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
-	}
-	return result;
-}
-
-TcPacketStored::TcPacketStored() :
-		TcPacketBase(NULL) {
-	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	this->checkAndSetStore();
-
-}
-
-ReturnValue_t TcPacketStored::deletePacket() {
-	ReturnValue_t result = this->store->deleteData(this->storeAddress);
-	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	this->setData( NULL);
-	return result;
-}
-
-bool TcPacketStored::checkAndSetStore() {
-	if (this->store == nullptr) {
-		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-		if (this->store == nullptr) {
-			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
-					<< std::endl;
-			return false;
-		}
-	}
-	return true;
-}
-
-void TcPacketStored::setStoreAddress(store_address_t setAddress) {
-	this->storeAddress = setAddress;
-	const uint8_t* temp_data = NULL;
-	size_t temp_size;
-	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
-	if (this->checkAndSetStore()) {
-		status = this->store->getData(this->storeAddress, &temp_data,
-				&temp_size);
-	}
-	if (status == StorageManagerIF::RETURN_OK) {
-		this->setData(temp_data);
-	} else {
-		this->setData(NULL);
-		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	}
-}
-
-store_address_t TcPacketStored::getStoreAddress() {
-	return this->storeAddress;
-}
-
-bool TcPacketStored::isSizeCorrect() {
-	const uint8_t* temp_data = NULL;
-	size_t temp_size;
-	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
-			&temp_size);
-	if (status == StorageManagerIF::RETURN_OK) {
-		if (this->getFullSize() == temp_size) {
-			return true;
-		}
-	}
-	return false;
-}
-
-StorageManagerIF* TcPacketStored::store = NULL;
-
-TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
-		TcPacketBase(data) {
-	if (getFullSize() != size) {
-		return;
-	}
-	if (this->checkAndSetStore()) {
-		ReturnValue_t status = store->addData(&storeAddress, data, size);
-		if (status != HasReturnvaluesIF::RETURN_OK) {
-			this->setData(NULL);
-		}
-	}
-}
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TcPacketStored.h"
+
+#include <cstring>
+
+TcPacketStored::TcPacketStored(store_address_t setAddress) :
+		TcPacketBase(nullptr), storeAddress(setAddress) {
+	this->setStoreAddress(this->storeAddress);
+}
+
+TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
+		uint16_t apid, uint8_t sequence_count, const uint8_t* data,
+		size_t size, uint8_t ack ) :
+		TcPacketBase(nullptr) {
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if (!this->checkAndSetStore()) {
+		return;
+	}
+	uint8_t* p_data = nullptr;
+	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
+			(TC_PACKET_MIN_SIZE + size), &p_data);
+	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
+		sif::warning << "TcPacketStored::TcPacketStored: Could not get "
+				"free element from store!" << std::endl;
+		return;
+	}
+	this->setData(p_data);
+	initializeTcPacket(apid, sequence_count, ack, service, subservice);
+	memcpy(&tcData->appData, data, size);
+	this->setPacketDataLength(
+			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
+	this->setErrorControl();
+}
+
+ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
+		size_t* dataSize) {
+	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
+	}
+	return result;
+}
+
+TcPacketStored::TcPacketStored() :
+		TcPacketBase(NULL) {
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	this->checkAndSetStore();
+
+}
+
+ReturnValue_t TcPacketStored::deletePacket() {
+	ReturnValue_t result = this->store->deleteData(this->storeAddress);
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	this->setData( NULL);
+	return result;
+}
+
+bool TcPacketStored::checkAndSetStore() {
+	if (this->store == nullptr) {
+		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+		if (this->store == nullptr) {
+			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
+					<< std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+void TcPacketStored::setStoreAddress(store_address_t setAddress) {
+	this->storeAddress = setAddress;
+	const uint8_t* temp_data = NULL;
+	size_t temp_size;
+	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
+	if (this->checkAndSetStore()) {
+		status = this->store->getData(this->storeAddress, &temp_data,
+				&temp_size);
+	}
+	if (status == StorageManagerIF::RETURN_OK) {
+		this->setData(temp_data);
+	} else {
+		this->setData(NULL);
+		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	}
+}
+
+store_address_t TcPacketStored::getStoreAddress() {
+	return this->storeAddress;
+}
+
+bool TcPacketStored::isSizeCorrect() {
+	const uint8_t* temp_data = NULL;
+	size_t temp_size;
+	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
+			&temp_size);
+	if (status == StorageManagerIF::RETURN_OK) {
+		if (this->getFullSize() == temp_size) {
+			return true;
+		}
+	}
+	return false;
+}
+
+StorageManagerIF* TcPacketStored::store = NULL;
+
+TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
+		TcPacketBase(data) {
+	if (getFullSize() != size) {
+		return;
+	}
+	if (this->checkAndSetStore()) {
+		ReturnValue_t status = store->addData(&storeAddress, data, size);
+		if (status != HasReturnvaluesIF::RETURN_OK) {
+			this->setData(NULL);
+		}
+	}
+}
diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h
index 90cf2fbaf..c81b71b77 100644
--- a/tmtcpacket/pus/TcPacketStored.h
+++ b/tmtcpacket/pus/TcPacketStored.h
@@ -1,110 +1,110 @@
-#ifndef TCPACKETSTORED_H_
-#define TCPACKETSTORED_H_
-
-#include "../../storagemanager/StorageManagerIF.h"
-#include "../../tmtcpacket/pus/TcPacketBase.h"
-
-/**
- *	This class generates a ECSS PUS Telecommand packet within a given
- *	intermediate storage.
- *	As most packets are passed between tasks with the help of a storage
- *	anyway, it seems logical to create a Packet-In-Storage access class
- *	which saves the user almost all storage handling operation.
- *	Packets can both be newly created with the class and be "linked" to
- *	packets in a store with the help of a storeAddress.
- *	@ingroup tmtcpackets
- */
-class TcPacketStored : public TcPacketBase {
-private:
-	/**
-	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
-	 * call tries to set it and throws an error message in case of failures.
-	 * The default store is objects::TC_STORE.
-	 */
-	static StorageManagerIF* store;
-	/**
-	 * The address where the packet data of the object instance is stored.
-	 */
-	store_address_t storeAddress;
-	/**
-	 * A helper method to check if a store is assigned to the class.
-	 * If not, the method tries to retrieve the store from the global
-	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
-	 */
-	bool checkAndSetStore();
-public:
-	/**
-	 * This is a default constructor which does not set the data pointer.
-	 * However, it does try to set the packet store.
-	 */
-	TcPacketStored();
-	/**
-	 * With this constructor, the class instance is linked to an existing
-	 * packet in the packet store.
-	 * The packet content is neither checked nor changed with this call. If
-	 * the packet could not be found, the data pointer is set to NULL.
-	 */
-	TcPacketStored( store_address_t setAddress );
-	/**
-	 * With this constructor, new space is allocated in the packet store and
-	 * a new PUS Telecommand Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet.
-	 * @param apid			Sets the packet's APID field.
-	 * @param ack			Set's the packet's Ack field,
-	 * 		which specifies number and size of verification packets returned
-	 * 		for this command.
-	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the destination service.
-	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the destination sub-service.
-	 * @param sequence_count	Sets the packet's Source Sequence Count field.
-	 * @param data		The data to be copied to the Application Data Field.
-	 * @param size		The amount of data to be copied.
-	 */
-	TcPacketStored( uint8_t service, uint8_t subservice, uint16_t apid,
-			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
-			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL );
-	/**
-	 * Another constructor to create a TcPacket from a raw packet stream.
-	 * Takes the data and adds it unchecked to the TcStore.
-	 * @param data	Pointer to the complete TC Space Packet.
-	 * @param Size size of the packet.
-	 */
-	TcPacketStored( const uint8_t* data, uint32_t size);
-
-	ReturnValue_t getData(const uint8_t ** dataPtr,
-			size_t* dataSize);
-	/**
-	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
-	 */
-	store_address_t getStoreAddress();
-	/**
-	 * With this call, the packet is deleted.
-	 * It removes itself from the store and sets its data pointer to NULL.
-	 * @return	returncode from deleting the data.
-	 */
-	ReturnValue_t deletePacket();
-	/**
-	 * With this call, a packet can be linked to another store. This is useful
-	 * if the packet is a class member and used for more than one packet.
-	 * @param setAddress	The new packet id to link to.
-	 */
-	void setStoreAddress( store_address_t setAddress );
-	/**
-	 * This method performs a size check.
-	 * It reads the stored size and compares it with the size entered in the
-	 * packet header. This class is the optimal place for such a check as it
-	 * has access to both the header data and the store.
-	 * @return	true if size is correct, false if packet is not registered in
-	 * 			store or size is incorrect.
-	 */
-	bool isSizeCorrect();
-};
-
-
-#endif /* TCPACKETSTORED_H_ */
+#ifndef TCPACKETSTORED_H_
+#define TCPACKETSTORED_H_
+
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../tmtcpacket/pus/TcPacketBase.h"
+
+/**
+ *	This class generates a ECSS PUS Telecommand packet within a given
+ *	intermediate storage.
+ *	As most packets are passed between tasks with the help of a storage
+ *	anyway, it seems logical to create a Packet-In-Storage access class
+ *	which saves the user almost all storage handling operation.
+ *	Packets can both be newly created with the class and be "linked" to
+ *	packets in a store with the help of a storeAddress.
+ *	@ingroup tmtcpackets
+ */
+class TcPacketStored : public TcPacketBase {
+private:
+	/**
+	 * This is a pointer to the store all instances of the class use.
+	 * If the store is not yet set (i.e. \c store is NULL), every constructor
+	 * call tries to set it and throws an error message in case of failures.
+	 * The default store is objects::TC_STORE.
+	 */
+	static StorageManagerIF* store;
+	/**
+	 * The address where the packet data of the object instance is stored.
+	 */
+	store_address_t storeAddress;
+	/**
+	 * A helper method to check if a store is assigned to the class.
+	 * If not, the method tries to retrieve the store from the global
+	 * ObjectManager.
+	 * @return	@li	\c true if the store is linked or could be created.
+	 * 			@li \c false otherwise.
+	 */
+	bool checkAndSetStore();
+public:
+	/**
+	 * This is a default constructor which does not set the data pointer.
+	 * However, it does try to set the packet store.
+	 */
+	TcPacketStored();
+	/**
+	 * With this constructor, the class instance is linked to an existing
+	 * packet in the packet store.
+	 * The packet content is neither checked nor changed with this call. If
+	 * the packet could not be found, the data pointer is set to NULL.
+	 */
+	TcPacketStored( store_address_t setAddress );
+	/**
+	 * With this constructor, new space is allocated in the packet store and
+	 * a new PUS Telecommand Packet is created there.
+	 * Packet Application Data passed in data is copied into the packet.
+	 * @param apid			Sets the packet's APID field.
+	 * @param ack			Set's the packet's Ack field,
+	 * 		which specifies number and size of verification packets returned
+	 * 		for this command.
+	 * @param service		Sets the packet's Service ID field.
+	 * 		This specifies the destination service.
+	 * @param subservice	Sets the packet's Service Subtype field.
+	 * 		This specifies the destination sub-service.
+	 * @param sequence_count	Sets the packet's Source Sequence Count field.
+	 * @param data		The data to be copied to the Application Data Field.
+	 * @param size		The amount of data to be copied.
+	 */
+	TcPacketStored( uint8_t service, uint8_t subservice, uint16_t apid,
+			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
+			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL );
+	/**
+	 * Another constructor to create a TcPacket from a raw packet stream.
+	 * Takes the data and adds it unchecked to the TcStore.
+	 * @param data	Pointer to the complete TC Space Packet.
+	 * @param Size size of the packet.
+	 */
+	TcPacketStored( const uint8_t* data, uint32_t size);
+
+	ReturnValue_t getData(const uint8_t ** dataPtr,
+			size_t* dataSize);
+	/**
+	 * This is a getter for the current store address of the packet.
+	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
+	 * 			the packet is not linked.
+	 */
+	store_address_t getStoreAddress();
+	/**
+	 * With this call, the packet is deleted.
+	 * It removes itself from the store and sets its data pointer to NULL.
+	 * @return	returncode from deleting the data.
+	 */
+	ReturnValue_t deletePacket();
+	/**
+	 * With this call, a packet can be linked to another store. This is useful
+	 * if the packet is a class member and used for more than one packet.
+	 * @param setAddress	The new packet id to link to.
+	 */
+	void setStoreAddress( store_address_t setAddress );
+	/**
+	 * This method performs a size check.
+	 * It reads the stored size and compares it with the size entered in the
+	 * packet header. This class is the optimal place for such a check as it
+	 * has access to both the header data and the store.
+	 * @return	true if size is correct, false if packet is not registered in
+	 * 			store or size is incorrect.
+	 */
+	bool isSizeCorrect();
+};
+
+
+#endif /* TCPACKETSTORED_H_ */
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index 630471cc8..66d67600b 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -1,119 +1,119 @@
-#include "../../globalfunctions/CRC.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TmPacketBase.h"
-#include "../../timemanager/CCSDSTime.h"
-#include <string.h>
-
-TmPacketBase::TmPacketBase(uint8_t* set_data) :
-		SpacePacketBase(set_data) {
-	tm_data = (TmPacketPointer*) set_data;
-}
-
-TmPacketBase::~TmPacketBase() {
-	//Nothing to do.
-}
-
-uint8_t TmPacketBase::getService() {
-	return tm_data->data_field.service_type;
-}
-
-uint8_t TmPacketBase::getSubService() {
-	return tm_data->data_field.service_subtype;
-}
-
-uint8_t* TmPacketBase::getSourceData() {
-	return &tm_data->data;
-}
-
-uint16_t TmPacketBase::getSourceDataSize() {
-	return getPacketDataLength() - sizeof(tm_data->data_field)
-			- CRC_SIZE + 1;
-}
-
-uint16_t TmPacketBase::getErrorControl() {
-	uint32_t size = getSourceDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tm_data->data;
-	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
-}
-
-void TmPacketBase::setErrorControl() {
-	uint32_t full_size = getFullSize();
-	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
-	uint32_t size = getSourceDataSize();
-	getSourceData()[size] = (crc & 0XFF00) >> 8;	// CRCH
-	getSourceData()[size + 1] = (crc) & 0X00FF; 		// CRCL
-}
-
-void TmPacketBase::setData(const uint8_t* p_Data) {
-	SpacePacketBase::setData(p_Data);
-	tm_data = (TmPacketPointer*) p_Data;
-}
-
-void TmPacketBase::print() {
-	/*uint8_t * wholeData = getWholeData();
-	 debug << "TmPacket contains: " << std::endl;
-	 for (uint8_t count = 0; count < getFullSize(); ++count ) {
-	 debug << std::hex << (uint16_t)wholeData[count] << " ";
-	 }
-	 debug << std::dec << std::endl;*/
-}
-
-bool TmPacketBase::checkAndSetStamper() {
-	if (timeStamper == NULL) {
-		timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
-		if (timeStamper == NULL) {
-			sif::error << "TmPacketBase::checkAndSetStamper: Stamper not found!"
-					<< std::endl;
-			return false;
-		}
-	}
-	return true;
-}
-
-ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
-	uint32_t tempSize = 0;
-	return CCSDSTime::convertFromCcsds(timestamp, tm_data->data_field.time,
-			&tempSize, sizeof(tm_data->data_field.time));
-}
-
-uint8_t* TmPacketBase::getPacketTimeRaw() const{
-	return tm_data->data_field.time;
-
-}
-
-void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter) {
-	//Set primary header:
-	initSpacePacketHeader(false, true, apid);
-	//Set data Field Header:
-	//First, set to zero.
-	memset(&tm_data->data_field, 0, sizeof(tm_data->data_field));
-	//Set CCSDS_secondary header flag to 0, version number to 001 and ack to 0000
-	// NOTE: In PUS-C, the PUS Version is 2 and specified for the first 4 bits.
-	// The other 4 bits of the first byte are the spacecraft time reference status
-	// To change to PUS-C, set 0b00100000
-	tm_data->data_field.version_type_ack = 0b00010000;
-	tm_data->data_field.service_type = service;
-	tm_data->data_field.service_subtype = subservice;
-	tm_data->data_field.subcounter = packetSubcounter;
-	//Timestamp packet
-	if (checkAndSetStamper()) {
-		timeStamper->addTimeStamp(tm_data->data_field.time, sizeof(tm_data->data_field.time));
-	}
-}
-
-void TmPacketBase::setSourceData(uint8_t* sourceData, size_t sourceSize) {
-	memcpy(getSourceData(), sourceData, sourceSize);
-	setSourceDataSize(sourceSize);
-}
-
-void TmPacketBase::setSourceDataSize(uint16_t size) {
-	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
-}
-
-uint32_t TmPacketBase::getTimestampSize() const {
-	return sizeof(tm_data->data_field.time);
-}
-
-TimeStamperIF* TmPacketBase::timeStamper = NULL;
-object_id_t TmPacketBase::timeStamperId = 0;
+#include "../../globalfunctions/CRC.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TmPacketBase.h"
+#include "../../timemanager/CCSDSTime.h"
+#include <string.h>
+
+TmPacketBase::TmPacketBase(uint8_t* set_data) :
+		SpacePacketBase(set_data) {
+	tm_data = (TmPacketPointer*) set_data;
+}
+
+TmPacketBase::~TmPacketBase() {
+	//Nothing to do.
+}
+
+uint8_t TmPacketBase::getService() {
+	return tm_data->data_field.service_type;
+}
+
+uint8_t TmPacketBase::getSubService() {
+	return tm_data->data_field.service_subtype;
+}
+
+uint8_t* TmPacketBase::getSourceData() {
+	return &tm_data->data;
+}
+
+uint16_t TmPacketBase::getSourceDataSize() {
+	return getPacketDataLength() - sizeof(tm_data->data_field)
+			- CRC_SIZE + 1;
+}
+
+uint16_t TmPacketBase::getErrorControl() {
+	uint32_t size = getSourceDataSize() + CRC_SIZE;
+	uint8_t* p_to_buffer = &tm_data->data;
+	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
+}
+
+void TmPacketBase::setErrorControl() {
+	uint32_t full_size = getFullSize();
+	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
+	uint32_t size = getSourceDataSize();
+	getSourceData()[size] = (crc & 0XFF00) >> 8;	// CRCH
+	getSourceData()[size + 1] = (crc) & 0X00FF; 		// CRCL
+}
+
+void TmPacketBase::setData(const uint8_t* p_Data) {
+	SpacePacketBase::setData(p_Data);
+	tm_data = (TmPacketPointer*) p_Data;
+}
+
+void TmPacketBase::print() {
+	/*uint8_t * wholeData = getWholeData();
+	 debug << "TmPacket contains: " << std::endl;
+	 for (uint8_t count = 0; count < getFullSize(); ++count ) {
+	 debug << std::hex << (uint16_t)wholeData[count] << " ";
+	 }
+	 debug << std::dec << std::endl;*/
+}
+
+bool TmPacketBase::checkAndSetStamper() {
+	if (timeStamper == NULL) {
+		timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
+		if (timeStamper == NULL) {
+			sif::error << "TmPacketBase::checkAndSetStamper: Stamper not found!"
+					<< std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
+	uint32_t tempSize = 0;
+	return CCSDSTime::convertFromCcsds(timestamp, tm_data->data_field.time,
+			&tempSize, sizeof(tm_data->data_field.time));
+}
+
+uint8_t* TmPacketBase::getPacketTimeRaw() const{
+	return tm_data->data_field.time;
+
+}
+
+void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter) {
+	//Set primary header:
+	initSpacePacketHeader(false, true, apid);
+	//Set data Field Header:
+	//First, set to zero.
+	memset(&tm_data->data_field, 0, sizeof(tm_data->data_field));
+	//Set CCSDS_secondary header flag to 0, version number to 001 and ack to 0000
+	// NOTE: In PUS-C, the PUS Version is 2 and specified for the first 4 bits.
+	// The other 4 bits of the first byte are the spacecraft time reference status
+	// To change to PUS-C, set 0b00100000
+	tm_data->data_field.version_type_ack = 0b00010000;
+	tm_data->data_field.service_type = service;
+	tm_data->data_field.service_subtype = subservice;
+	tm_data->data_field.subcounter = packetSubcounter;
+	//Timestamp packet
+	if (checkAndSetStamper()) {
+		timeStamper->addTimeStamp(tm_data->data_field.time, sizeof(tm_data->data_field.time));
+	}
+}
+
+void TmPacketBase::setSourceData(uint8_t* sourceData, size_t sourceSize) {
+	memcpy(getSourceData(), sourceData, sourceSize);
+	setSourceDataSize(sourceSize);
+}
+
+void TmPacketBase::setSourceDataSize(uint16_t size) {
+	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+}
+
+uint32_t TmPacketBase::getTimestampSize() const {
+	return sizeof(tm_data->data_field.time);
+}
+
+TimeStamperIF* TmPacketBase::timeStamper = NULL;
+object_id_t TmPacketBase::timeStamperId = 0;
diff --git a/tmtcpacket/pus/TmPacketBase.h b/tmtcpacket/pus/TmPacketBase.h
index acd08d725..96dbd5c63 100644
--- a/tmtcpacket/pus/TmPacketBase.h
+++ b/tmtcpacket/pus/TmPacketBase.h
@@ -1,186 +1,186 @@
-#ifndef TMPACKETBASE_H_
-#define TMPACKETBASE_H_
-
-#include "../../timemanager/TimeStamperIF.h"
-#include "../../tmtcpacket/SpacePacketBase.h"
-#include "../../timemanager/Clock.h"
-#include "../../objectmanager/SystemObjectIF.h"
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * This struct defines a byte-wise structured PUS TM Data Field Header.
- * Any optional fields in the header must be added or removed here.
- * Currently, no Destination field is present, but an eigth-byte representation
- * for a time tag [TBD].
- * @ingroup tmtcpackets
- */
-struct PUSTmDataFieldHeader {
-	uint8_t version_type_ack;
-	uint8_t service_type;
-	uint8_t service_subtype;
-	uint8_t subcounter;
-//	uint8_t destination;
-	uint8_t time[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
-};
-
-/**
- * This struct defines the data structure of a PUS Telecommand Packet when
- * accessed via a pointer.
- * @ingroup tmtcpackets
- */
-struct TmPacketPointer {
-	CCSDSPrimaryHeader primary;
-	PUSTmDataFieldHeader data_field;
-	uint8_t data;
-};
-
-/**
- * This class is the basic data handler for any ECSS PUS Telemetry packet.
- *
- * In addition to \SpacePacketBase, the class provides methods to handle
- * the standardized entries of the PUS TM Packet Data Field Header.
- * It does not contain the packet data itself but a pointer to the
- * data must be set on instantiation. An invalid pointer may cause
- * damage, as no getter method checks data validity. Anyway, a NULL
- * check can be performed by making use of the getWholeData method.
- * @ingroup tmtcpackets
- */
-class TmPacketBase : public SpacePacketBase {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	/**
-	 * This constant defines the minimum size of a valid PUS Telemetry Packet.
-	 */
-	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTmDataFieldHeader) + 2); //!< Minimum size of a valid PUS Telemetry Packet.
-	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048; //!< Maximum size of a TM Packet in this mission.
-	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000; //!< First byte of secondary header for PUS-A packets.
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed and also
-	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	TmPacketBase( uint8_t* set_data );
-	/**
-	 * This is the empty default destructor.
-	 */
-	virtual ~TmPacketBase();
-	/**
-	 * Initializes the Tm Packet header.
-	 * Does set the timestamp (to now), but not the error control field.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter);
-	/**
-	 * This is a getter for the packet's PUS Service ID, which is the second
-	 * byte of the Data Field Header.
-	 * @return	The packet's PUS Service ID.
-	 */
-	uint8_t getService();
-	/**
-	 * This is a getter for the packet's PUS Service Subtype, which is the
-	 * third byte of the Data Field Header.
-	 * @return	The packet's PUS Service Subtype.
-	 */
-	uint8_t getSubService();
-	/**
-	 * This is a getter for a pointer to the packet's Source data.
-	 *
-	 * These are the bytes that follow after the Data Field Header. They form
-	 * the packet's source data.
-	 * @return	A pointer to the PUS Source Data.
-	 */
-	uint8_t* getSourceData();
-	/**
-	 * This method calculates the size of the PUS Source data field.
-	 *
-	 * It takes the information stored in the CCSDS Packet Data Length field
-	 * and subtracts the Data Field Header size and the CRC size.
-	 * @return	The size of the PUS Source Data (without Error Control field)
-	 */
-	uint16_t getSourceDataSize();
-
-	/**
-	 * In case data was filled manually (almost never the case).
-	 * @param size Size of source data (without CRC and data filed header!).
-	 */
-	void setSourceDataSize(uint16_t size);
-	/**
-	 * This getter returns the Error Control Field of the packet.
-	 *
-	 * The field is placed after any possible Source Data. If no
-	 * Source Data is present there's still an Error Control field. It is
-	 * supposed to be a 16bit-CRC.
-	 * @return	The PUS Error Control
-	 */
-	uint16_t getErrorControl();
-	/**
-	 * With this method, the Error Control Field is updated to match the
-	 * current content of the packet.
-	 */
-	void setErrorControl();
-	/**
-	 * This sets the source data. It copies the provided data to
-	 * the internal TmPacketPointer source data location.
-	 * @param sourceData
-	 * @param sourceSize
-	 */
-	void setSourceData(uint8_t* sourceData, size_t sourceSize);
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telemetry Packet.
-	 */
-	void setData( const uint8_t* p_Data );
-	/**
-	 * This is a debugging helper method that prints the whole packet content
-	 * to the screen.
-	 */
-	void print();
-	/**
-	 * Interprets the "time"-field in the secondary header and returns it in timeval format.
-	 * @return Converted timestamp of packet.
-	 */
-	ReturnValue_t getPacketTime(timeval* timestamp) const;
-	/**
-	 * Returns a raw pointer to the beginning of the time field.
-	 * @return Raw pointer to time field.
-	 */
-	uint8_t* getPacketTimeRaw() const;
-
-	uint32_t getTimestampSize() const;
-
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TmPacketPointer* tm_data;
-	/**
-	 * The timeStamper is responsible for adding a timestamp to the packet.
-	 * It is initialized lazy.
-	 */
-	static TimeStamperIF* timeStamper;
-
-	static object_id_t timeStamperId; //!< The ID to use when looking for a time stamper.
-	/**
-	 * Checks if a time stamper is available and tries to set it if not.
-	 * @return Returns false if setting failed.
-	 */
-	bool checkAndSetStamper();
-};
-
-
-#endif /* TMPACKETBASE_H_ */
+#ifndef TMPACKETBASE_H_
+#define TMPACKETBASE_H_
+
+#include "../../timemanager/TimeStamperIF.h"
+#include "../../tmtcpacket/SpacePacketBase.h"
+#include "../../timemanager/Clock.h"
+#include "../../objectmanager/SystemObjectIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * This struct defines a byte-wise structured PUS TM Data Field Header.
+ * Any optional fields in the header must be added or removed here.
+ * Currently, no Destination field is present, but an eigth-byte representation
+ * for a time tag [TBD].
+ * @ingroup tmtcpackets
+ */
+struct PUSTmDataFieldHeader {
+	uint8_t version_type_ack;
+	uint8_t service_type;
+	uint8_t service_subtype;
+	uint8_t subcounter;
+//	uint8_t destination;
+	uint8_t time[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+};
+
+/**
+ * This struct defines the data structure of a PUS Telecommand Packet when
+ * accessed via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct TmPacketPointer {
+	CCSDSPrimaryHeader primary;
+	PUSTmDataFieldHeader data_field;
+	uint8_t data;
+};
+
+/**
+ * This class is the basic data handler for any ECSS PUS Telemetry packet.
+ *
+ * In addition to \SpacePacketBase, the class provides methods to handle
+ * the standardized entries of the PUS TM Packet Data Field Header.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * @ingroup tmtcpackets
+ */
+class TmPacketBase : public SpacePacketBase {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	/**
+	 * This constant defines the minimum size of a valid PUS Telemetry Packet.
+	 */
+	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTmDataFieldHeader) + 2); //!< Minimum size of a valid PUS Telemetry Packet.
+	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048; //!< Maximum size of a TM Packet in this mission.
+	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000; //!< First byte of secondary header for PUS-A packets.
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed and also
+	 * forwards the data pointer to the parent SpacePacketBase class.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	TmPacketBase( uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TmPacketBase();
+	/**
+	 * Initializes the Tm Packet header.
+	 * Does set the timestamp (to now), but not the error control field.
+	 * @param apid APID used.
+	 * @param service	PUS Service
+	 * @param subservice PUS Subservice
+	 * @param packetSubcounter Additional subcounter used.
+	 */
+	void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter);
+	/**
+	 * This is a getter for the packet's PUS Service ID, which is the second
+	 * byte of the Data Field Header.
+	 * @return	The packet's PUS Service ID.
+	 */
+	uint8_t getService();
+	/**
+	 * This is a getter for the packet's PUS Service Subtype, which is the
+	 * third byte of the Data Field Header.
+	 * @return	The packet's PUS Service Subtype.
+	 */
+	uint8_t getSubService();
+	/**
+	 * This is a getter for a pointer to the packet's Source data.
+	 *
+	 * These are the bytes that follow after the Data Field Header. They form
+	 * the packet's source data.
+	 * @return	A pointer to the PUS Source Data.
+	 */
+	uint8_t* getSourceData();
+	/**
+	 * This method calculates the size of the PUS Source data field.
+	 *
+	 * It takes the information stored in the CCSDS Packet Data Length field
+	 * and subtracts the Data Field Header size and the CRC size.
+	 * @return	The size of the PUS Source Data (without Error Control field)
+	 */
+	uint16_t getSourceDataSize();
+
+	/**
+	 * In case data was filled manually (almost never the case).
+	 * @param size Size of source data (without CRC and data filed header!).
+	 */
+	void setSourceDataSize(uint16_t size);
+	/**
+	 * This getter returns the Error Control Field of the packet.
+	 *
+	 * The field is placed after any possible Source Data. If no
+	 * Source Data is present there's still an Error Control field. It is
+	 * supposed to be a 16bit-CRC.
+	 * @return	The PUS Error Control
+	 */
+	uint16_t getErrorControl();
+	/**
+	 * With this method, the Error Control Field is updated to match the
+	 * current content of the packet.
+	 */
+	void setErrorControl();
+	/**
+	 * This sets the source data. It copies the provided data to
+	 * the internal TmPacketPointer source data location.
+	 * @param sourceData
+	 * @param sourceSize
+	 */
+	void setSourceData(uint8_t* sourceData, size_t sourceSize);
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 *
+	 * This call overwrites the parent's setData method to set both its
+	 * \c tc_data pointer and the parent's \c data pointer.
+	 *
+	 * @param p_data	A pointer to another PUS Telemetry Packet.
+	 */
+	void setData( const uint8_t* p_Data );
+	/**
+	 * This is a debugging helper method that prints the whole packet content
+	 * to the screen.
+	 */
+	void print();
+	/**
+	 * Interprets the "time"-field in the secondary header and returns it in timeval format.
+	 * @return Converted timestamp of packet.
+	 */
+	ReturnValue_t getPacketTime(timeval* timestamp) const;
+	/**
+	 * Returns a raw pointer to the beginning of the time field.
+	 * @return Raw pointer to time field.
+	 */
+	uint8_t* getPacketTimeRaw() const;
+
+	uint32_t getTimestampSize() const;
+
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet's data.
+	 *
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	TmPacketPointer* tm_data;
+	/**
+	 * The timeStamper is responsible for adding a timestamp to the packet.
+	 * It is initialized lazy.
+	 */
+	static TimeStamperIF* timeStamper;
+
+	static object_id_t timeStamperId; //!< The ID to use when looking for a time stamper.
+	/**
+	 * Checks if a time stamper is available and tries to set it if not.
+	 * @return Returns false if setting failed.
+	 */
+	bool checkAndSetStamper();
+};
+
+
+#endif /* TMPACKETBASE_H_ */
diff --git a/tmtcpacket/pus/TmPacketMinimal.cpp b/tmtcpacket/pus/TmPacketMinimal.cpp
index ee56d46f4..c7c495ae3 100644
--- a/tmtcpacket/pus/TmPacketMinimal.cpp
+++ b/tmtcpacket/pus/TmPacketMinimal.cpp
@@ -1,45 +1,45 @@
-#include "../../tmtcpacket/pus/TmPacketMinimal.h"
-#include <stddef.h>
-#include <time.h>
-#include "../../tmtcpacket/pus/PacketTimestampInterpreterIF.h"
-
-TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketBase( set_data ) {
-	this->tm_data = (TmPacketMinimalPointer*)set_data;
-}
-
-TmPacketMinimal::~TmPacketMinimal() {
-}
-
-uint8_t TmPacketMinimal::getService() {
-	return tm_data->data_field.service_type;
-}
-
-uint8_t TmPacketMinimal::getSubService() {
-	return tm_data->data_field.service_subtype;
-}
-
-uint8_t TmPacketMinimal::getPacketSubcounter() {
-	return tm_data->data_field.subcounter;
-}
-
-ReturnValue_t TmPacketMinimal::getPacketTime(timeval* timestamp) {
-	if (timestampInterpreter == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return timestampInterpreter->getPacketTime(this, timestamp);
-}
-
-ReturnValue_t TmPacketMinimal::getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size) {
-	if (timestampInterpreter == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return timestampInterpreter->getPacketTimeRaw(this, timePtr, size);
-}
-
-void TmPacketMinimal::setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter) {
-	if (TmPacketMinimal::timestampInterpreter == NULL) {
-		TmPacketMinimal::timestampInterpreter = interpreter;
-	}
-}
-
-PacketTimestampInterpreterIF* TmPacketMinimal::timestampInterpreter = NULL;
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+#include <stddef.h>
+#include <time.h>
+#include "../../tmtcpacket/pus/PacketTimestampInterpreterIF.h"
+
+TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketBase( set_data ) {
+	this->tm_data = (TmPacketMinimalPointer*)set_data;
+}
+
+TmPacketMinimal::~TmPacketMinimal() {
+}
+
+uint8_t TmPacketMinimal::getService() {
+	return tm_data->data_field.service_type;
+}
+
+uint8_t TmPacketMinimal::getSubService() {
+	return tm_data->data_field.service_subtype;
+}
+
+uint8_t TmPacketMinimal::getPacketSubcounter() {
+	return tm_data->data_field.subcounter;
+}
+
+ReturnValue_t TmPacketMinimal::getPacketTime(timeval* timestamp) {
+	if (timestampInterpreter == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return timestampInterpreter->getPacketTime(this, timestamp);
+}
+
+ReturnValue_t TmPacketMinimal::getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size) {
+	if (timestampInterpreter == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return timestampInterpreter->getPacketTimeRaw(this, timePtr, size);
+}
+
+void TmPacketMinimal::setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter) {
+	if (TmPacketMinimal::timestampInterpreter == NULL) {
+		TmPacketMinimal::timestampInterpreter = interpreter;
+	}
+}
+
+PacketTimestampInterpreterIF* TmPacketMinimal::timestampInterpreter = NULL;
diff --git a/tmtcpacket/pus/TmPacketMinimal.h b/tmtcpacket/pus/TmPacketMinimal.h
index e7b362bfe..728acb154 100644
--- a/tmtcpacket/pus/TmPacketMinimal.h
+++ b/tmtcpacket/pus/TmPacketMinimal.h
@@ -1,84 +1,84 @@
-#ifndef FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
-#define FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
-
-
-#include "../../tmtcpacket/SpacePacketBase.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-struct timeval;
-class PacketTimestampInterpreterIF;
-/**
- * This is a minimal version of a PUS TmPacket without any variable field, or,
- * in other words with Service Type, Subtype and subcounter only.
- * This is required for handling TM packets with different APIDs with different
- * secondary headers.
- */
-class TmPacketMinimal : public SpacePacketBase {
-public:
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed and also
-	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	TmPacketMinimal( const uint8_t* set_data );
-	/**
-	 * This is the empty default destructor.
-	 */
-	virtual ~TmPacketMinimal();
-	/**
-	 * This is a getter for the packet's PUS Service ID, which is the second
-	 * byte of the Data Field Header.
-	 * @return	The packet's PUS Service ID.
-	 */
-	uint8_t getService();
-	/**
-	 * This is a getter for the packet's PUS Service Subtype, which is the
-	 * third byte of the Data Field Header.
-	 * @return	The packet's PUS Service Subtype.
-	 */
-	uint8_t getSubService();
-	/**
-	 * Returns the subcounter.
-	 * @return the subcounter of the Data Field Header.
-	 */
-	uint8_t getPacketSubcounter();
-	struct PUSTmMinimalHeader {
-		uint8_t version_type_ack;
-		uint8_t service_type;
-		uint8_t service_subtype;
-		uint8_t subcounter;
-	};
-
-	ReturnValue_t getPacketTime(timeval* timestamp);
-
-	ReturnValue_t getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size);
-
-	static void setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter);
-	/**
-	 * This struct defines the data structure of a PUS Telecommand Packet when
-	 * accessed via a pointer.
-	 * @ingroup tmtcpackets
-	 */
-	struct TmPacketMinimalPointer {
-		CCSDSPrimaryHeader primary;
-		PUSTmMinimalHeader data_field;
-		uint8_t rest;
-	};
-	//Must include a checksum and is therefore at least one larger than the above struct.
-	static const uint16_t MINIMUM_SIZE = sizeof(TmPacketMinimalPointer) +1;
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TmPacketMinimalPointer* tm_data;
-
-	static PacketTimestampInterpreterIF* timestampInterpreter;
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
+#define FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
+
+
+#include "../../tmtcpacket/SpacePacketBase.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+struct timeval;
+class PacketTimestampInterpreterIF;
+/**
+ * This is a minimal version of a PUS TmPacket without any variable field, or,
+ * in other words with Service Type, Subtype and subcounter only.
+ * This is required for handling TM packets with different APIDs with different
+ * secondary headers.
+ */
+class TmPacketMinimal : public SpacePacketBase {
+public:
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed and also
+	 * forwards the data pointer to the parent SpacePacketBase class.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	TmPacketMinimal( const uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TmPacketMinimal();
+	/**
+	 * This is a getter for the packet's PUS Service ID, which is the second
+	 * byte of the Data Field Header.
+	 * @return	The packet's PUS Service ID.
+	 */
+	uint8_t getService();
+	/**
+	 * This is a getter for the packet's PUS Service Subtype, which is the
+	 * third byte of the Data Field Header.
+	 * @return	The packet's PUS Service Subtype.
+	 */
+	uint8_t getSubService();
+	/**
+	 * Returns the subcounter.
+	 * @return the subcounter of the Data Field Header.
+	 */
+	uint8_t getPacketSubcounter();
+	struct PUSTmMinimalHeader {
+		uint8_t version_type_ack;
+		uint8_t service_type;
+		uint8_t service_subtype;
+		uint8_t subcounter;
+	};
+
+	ReturnValue_t getPacketTime(timeval* timestamp);
+
+	ReturnValue_t getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size);
+
+	static void setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter);
+	/**
+	 * This struct defines the data structure of a PUS Telecommand Packet when
+	 * accessed via a pointer.
+	 * @ingroup tmtcpackets
+	 */
+	struct TmPacketMinimalPointer {
+		CCSDSPrimaryHeader primary;
+		PUSTmMinimalHeader data_field;
+		uint8_t rest;
+	};
+	//Must include a checksum and is therefore at least one larger than the above struct.
+	static const uint16_t MINIMUM_SIZE = sizeof(TmPacketMinimalPointer) +1;
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet's data.
+	 *
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	TmPacketMinimalPointer* tm_data;
+
+	static PacketTimestampInterpreterIF* timestampInterpreter;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_ */
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 9476dcd6b..17b49f43a 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -1,146 +1,146 @@
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TmPacketStored.h"
-#include "../../tmtcservices/TmTcMessage.h"
-#include <string.h>
-
-TmPacketStored::TmPacketStored(store_address_t setAddress) :
-		TmPacketBase(NULL), storeAddress(setAddress) {
-	setStoreAddress(storeAddress);
-}
-
-TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
-		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
-		TmPacketBase(NULL) {
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
-		return;
-	}
-	uint8_t *pData = NULL;
-	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
-			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
-
-	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "TmPacketStored::TmPacketStored: "
-				"Issue getting free storage" << std::endl;
-		checkAndReportLostTm();
-		return;
-	}
-	setData(pData);
-	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	memcpy(getSourceData(), headerData, headerSize);
-	memcpy(getSourceData() + headerSize, data, size);
-	setPacketDataLength(
-			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
-}
-
-// todo: Endianness flags as optional parameter?
-TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
-		SerializeIF *header) :
-		TmPacketBase(NULL) {
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
-		return;
-	}
-	size_t sourceDataSize = 0;
-	if (content != NULL) {
-		sourceDataSize += content->getSerializedSize();
-	}
-	if (header != NULL) {
-		sourceDataSize += header->getSerializedSize();
-	}
-	uint8_t *p_data = NULL;
-	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
-			(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
-	if (returnValue != store->RETURN_OK) {
-		checkAndReportLostTm();
-	}
-	setData(p_data);
-	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	uint8_t *putDataHere = getSourceData();
-	size_t size = 0;
-	if (header != NULL) {
-		header->serialize(&putDataHere, &size, sourceDataSize,
-				SerializeIF::Endianness::BIG);
-	}
-	if (content != NULL) {
-		content->serialize(&putDataHere, &size, sourceDataSize,
-				SerializeIF::Endianness::BIG);
-	}
-	setPacketDataLength(
-			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
-}
-
-store_address_t TmPacketStored::getStoreAddress() {
-	return storeAddress;
-}
-
-void TmPacketStored::deletePacket() {
-	store->deleteData(storeAddress);
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	setData(NULL);
-}
-
-void TmPacketStored::setStoreAddress(store_address_t setAddress) {
-	storeAddress = setAddress;
-	const uint8_t *temp_data = NULL;
-	size_t temp_size;
-	if (!checkAndSetStore()) {
-		return;
-	}
-	ReturnValue_t status = store->getData(storeAddress, &temp_data, &temp_size);
-	if (status == StorageManagerIF::RETURN_OK) {
-		setData(temp_data);
-	} else {
-		setData(NULL);
-		storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	}
-}
-
-bool TmPacketStored::checkAndSetStore() {
-	if (store == NULL) {
-		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
-		if (store == NULL) {
-			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
-					<< std::endl;
-			return false;
-		}
-	}
-	return true;
-}
-
-StorageManagerIF *TmPacketStored::store = NULL;
-InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
-
-ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
-		MessageQueueId_t sentFrom, bool doErrorReporting) {
-	if (getWholeData() == NULL) {
-		//SHOULDDO: More decent code.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	TmTcMessage tmMessage(getStoreAddress());
-	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
-			&tmMessage, sentFrom);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		deletePacket();
-		if (doErrorReporting) {
-			checkAndReportLostTm();
-		}
-		return result;
-	}
-	//SHOULDDO: In many cases, some counter is incremented for successfully sent packets. The check is often not done, but just incremented.
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-void TmPacketStored::checkAndReportLostTm() {
-	if (internalErrorReporter == NULL) {
-		internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-				objects::INTERNAL_ERROR_REPORTER);
-	}
-	if (internalErrorReporter != NULL) {
-		internalErrorReporter->lostTm();
-	}
-}
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TmPacketStored.h"
+#include "../../tmtcservices/TmTcMessage.h"
+#include <string.h>
+
+TmPacketStored::TmPacketStored(store_address_t setAddress) :
+		TmPacketBase(NULL), storeAddress(setAddress) {
+	setStoreAddress(storeAddress);
+}
+
+TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
+		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
+		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
+		TmPacketBase(NULL) {
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	uint8_t *pData = NULL;
+	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
+			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
+
+	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "TmPacketStored::TmPacketStored: "
+				"Issue getting free storage" << std::endl;
+		checkAndReportLostTm();
+		return;
+	}
+	setData(pData);
+	initializeTmPacket(apid, service, subservice, packetSubcounter);
+	memcpy(getSourceData(), headerData, headerSize);
+	memcpy(getSourceData() + headerSize, data, size);
+	setPacketDataLength(
+			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+}
+
+// todo: Endianness flags as optional parameter?
+TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
+		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
+		SerializeIF *header) :
+		TmPacketBase(NULL) {
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	size_t sourceDataSize = 0;
+	if (content != NULL) {
+		sourceDataSize += content->getSerializedSize();
+	}
+	if (header != NULL) {
+		sourceDataSize += header->getSerializedSize();
+	}
+	uint8_t *p_data = NULL;
+	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
+			(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
+	if (returnValue != store->RETURN_OK) {
+		checkAndReportLostTm();
+	}
+	setData(p_data);
+	initializeTmPacket(apid, service, subservice, packetSubcounter);
+	uint8_t *putDataHere = getSourceData();
+	size_t size = 0;
+	if (header != NULL) {
+		header->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
+	}
+	if (content != NULL) {
+		content->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
+	}
+	setPacketDataLength(
+			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+}
+
+store_address_t TmPacketStored::getStoreAddress() {
+	return storeAddress;
+}
+
+void TmPacketStored::deletePacket() {
+	store->deleteData(storeAddress);
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	setData(NULL);
+}
+
+void TmPacketStored::setStoreAddress(store_address_t setAddress) {
+	storeAddress = setAddress;
+	const uint8_t *temp_data = NULL;
+	size_t temp_size;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	ReturnValue_t status = store->getData(storeAddress, &temp_data, &temp_size);
+	if (status == StorageManagerIF::RETURN_OK) {
+		setData(temp_data);
+	} else {
+		setData(NULL);
+		storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	}
+}
+
+bool TmPacketStored::checkAndSetStore() {
+	if (store == NULL) {
+		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
+		if (store == NULL) {
+			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
+					<< std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+StorageManagerIF *TmPacketStored::store = NULL;
+InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
+
+ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
+		MessageQueueId_t sentFrom, bool doErrorReporting) {
+	if (getWholeData() == NULL) {
+		//SHOULDDO: More decent code.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	TmTcMessage tmMessage(getStoreAddress());
+	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
+			&tmMessage, sentFrom);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		deletePacket();
+		if (doErrorReporting) {
+			checkAndReportLostTm();
+		}
+		return result;
+	}
+	//SHOULDDO: In many cases, some counter is incremented for successfully sent packets. The check is often not done, but just incremented.
+	return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+void TmPacketStored::checkAndReportLostTm() {
+	if (internalErrorReporter == NULL) {
+		internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+				objects::INTERNAL_ERROR_REPORTER);
+	}
+	if (internalErrorReporter != NULL) {
+		internalErrorReporter->lostTm();
+	}
+}
diff --git a/tmtcpacket/pus/TmPacketStored.h b/tmtcpacket/pus/TmPacketStored.h
index 195c3272e..98e37ed53 100644
--- a/tmtcpacket/pus/TmPacketStored.h
+++ b/tmtcpacket/pus/TmPacketStored.h
@@ -1,96 +1,96 @@
-#ifndef TMPACKETSTORED_H_
-#define TMPACKETSTORED_H_
-
-#include "../../serialize/SerializeIF.h"
-#include "../../storagemanager/StorageManagerIF.h"
-#include "../../tmtcpacket/pus/TmPacketBase.h"
-#include "../../internalError/InternalErrorReporterIF.h"
-#include "../../ipc/MessageQueueSenderIF.h"
-
-/**
- *	This class generates a ECSS PUS Telemetry packet within a given
- *	intermediate storage.
- *	As most packets are passed between tasks with the help of a storage
- *	anyway, it seems logical to create a Packet-In-Storage access class
- *	which saves the user almost all storage handling operation.
- *	Packets can both be newly created with the class and be "linked" to
- *	packets in a store with the help of a storeAddress.
- *	@ingroup tmtcpackets
- */
-class TmPacketStored : public TmPacketBase {
-private:
-	/**
-	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
-	 * call tries to set it and throws an error message in case of failures.
-	 * The default store is objects::TM_STORE.
-	 */
-	static StorageManagerIF* store;
-
-	static InternalErrorReporterIF *internalErrorReporter;
-
-	/**
-	 * The address where the packet data of the object instance is stored.
-	 */
-	store_address_t storeAddress;
-	/**
-	 * A helper method to check if a store is assigned to the class.
-	 * If not, the method tries to retrieve the store from the global
-	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
-	 */
-	bool checkAndSetStore();
-
-	void checkAndReportLostTm();
-public:
-	/**
-	 * This is a default constructor which does not set the data pointer.
-	 * However, it does try to set the packet store.
-	 */
-	TmPacketStored( store_address_t setAddress );
-	/**
-	 * With this constructor, new space is allocated in the packet store and
-	 * a new PUS Telemetry Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet. The Application data is
-	 * passed in two parts, first a header, then a data field. This allows building a Telemetry
-	 * Packet from two separate data sources.
-	 * @param apid			Sets the packet's APID field.
-	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the source service.
-	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the source sub-service.
-	 * @param packet_counter	Sets the Packet counter field of this packet
-	 * @param data			The payload data to be copied to the Application Data Field
-	 * @param size			The amount of data to be copied.
-	 * @param headerData 	The header Data of the Application field; will be copied in front of data
-	 * @param headerSize	The size of the headerDataF
-	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter = 0, const uint8_t* data = NULL, uint32_t size = 0, const uint8_t* headerData = NULL, uint32_t headerSize = 0);
-	/**
-	 * Another ctor to directly pass structured content and header data to the packet to avoid additional buffers.
-	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter, SerializeIF* content, SerializeIF* header = NULL);
-	/**
-	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
-	 */
-	store_address_t getStoreAddress();
-	/**
-	 * With this call, the packet is deleted.
-	 * It removes itself from the store and sets its data pointer to NULL.
-	 */
-	void deletePacket();
-	/**
-	 * With this call, a packet can be linked to another store. This is useful
-	 * if the packet is a class member and used for more than one packet.
-	 * @param setAddress	The new packet id to link to.
-	 */
-	void setStoreAddress( store_address_t setAddress );
-
-	ReturnValue_t sendPacket( MessageQueueId_t destination, MessageQueueId_t sentFrom, bool doErrorReporting = true );
-};
-
-
-#endif /* TMPACKETSTORED_H_ */
+#ifndef TMPACKETSTORED_H_
+#define TMPACKETSTORED_H_
+
+#include "../../serialize/SerializeIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../tmtcpacket/pus/TmPacketBase.h"
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueSenderIF.h"
+
+/**
+ *	This class generates a ECSS PUS Telemetry packet within a given
+ *	intermediate storage.
+ *	As most packets are passed between tasks with the help of a storage
+ *	anyway, it seems logical to create a Packet-In-Storage access class
+ *	which saves the user almost all storage handling operation.
+ *	Packets can both be newly created with the class and be "linked" to
+ *	packets in a store with the help of a storeAddress.
+ *	@ingroup tmtcpackets
+ */
+class TmPacketStored : public TmPacketBase {
+private:
+	/**
+	 * This is a pointer to the store all instances of the class use.
+	 * If the store is not yet set (i.e. \c store is NULL), every constructor
+	 * call tries to set it and throws an error message in case of failures.
+	 * The default store is objects::TM_STORE.
+	 */
+	static StorageManagerIF* store;
+
+	static InternalErrorReporterIF *internalErrorReporter;
+
+	/**
+	 * The address where the packet data of the object instance is stored.
+	 */
+	store_address_t storeAddress;
+	/**
+	 * A helper method to check if a store is assigned to the class.
+	 * If not, the method tries to retrieve the store from the global
+	 * ObjectManager.
+	 * @return	@li	\c true if the store is linked or could be created.
+	 * 			@li \c false otherwise.
+	 */
+	bool checkAndSetStore();
+
+	void checkAndReportLostTm();
+public:
+	/**
+	 * This is a default constructor which does not set the data pointer.
+	 * However, it does try to set the packet store.
+	 */
+	TmPacketStored( store_address_t setAddress );
+	/**
+	 * With this constructor, new space is allocated in the packet store and
+	 * a new PUS Telemetry Packet is created there.
+	 * Packet Application Data passed in data is copied into the packet. The Application data is
+	 * passed in two parts, first a header, then a data field. This allows building a Telemetry
+	 * Packet from two separate data sources.
+	 * @param apid			Sets the packet's APID field.
+	 * @param service		Sets the packet's Service ID field.
+	 * 		This specifies the source service.
+	 * @param subservice	Sets the packet's Service Subtype field.
+	 * 		This specifies the source sub-service.
+	 * @param packet_counter	Sets the Packet counter field of this packet
+	 * @param data			The payload data to be copied to the Application Data Field
+	 * @param size			The amount of data to be copied.
+	 * @param headerData 	The header Data of the Application field; will be copied in front of data
+	 * @param headerSize	The size of the headerDataF
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter = 0, const uint8_t* data = NULL, uint32_t size = 0, const uint8_t* headerData = NULL, uint32_t headerSize = 0);
+	/**
+	 * Another ctor to directly pass structured content and header data to the packet to avoid additional buffers.
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter, SerializeIF* content, SerializeIF* header = NULL);
+	/**
+	 * This is a getter for the current store address of the packet.
+	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
+	 * 			the packet is not linked.
+	 */
+	store_address_t getStoreAddress();
+	/**
+	 * With this call, the packet is deleted.
+	 * It removes itself from the store and sets its data pointer to NULL.
+	 */
+	void deletePacket();
+	/**
+	 * With this call, a packet can be linked to another store. This is useful
+	 * if the packet is a class member and used for more than one packet.
+	 * @param setAddress	The new packet id to link to.
+	 */
+	void setStoreAddress( store_address_t setAddress );
+
+	ReturnValue_t sendPacket( MessageQueueId_t destination, MessageQueueId_t sentFrom, bool doErrorReporting = true );
+};
+
+
+#endif /* TMPACKETSTORED_H_ */
diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h
index 13928df5b..bff0e9550 100644
--- a/tmtcservices/AcceptsTelecommandsIF.h
+++ b/tmtcservices/AcceptsTelecommandsIF.h
@@ -1,43 +1,43 @@
-#ifndef FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
-#define FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
-
-#include "../ipc/MessageQueueSenderIF.h"
-
-/**
- * @brief 	This interface is implemented by classes that are sinks for
- * 			Telecommands.
- * @details	Any service receiving telecommands shall implement this interface
- * 			and thus make the service id and the receiving message queue public.
- */
-class AcceptsTelecommandsIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
-	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
-	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(5);
-	/**
-	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
-	 */
-	virtual ~AcceptsTelecommandsIF() {
-
-	}
-	/**
-	 * @brief	Getter for the service id.
-	 * @details	Any receiving service (at least any PUS service) shall have a
-	 * 			service ID. If the receiver can handle Telecommands, but for
-	 * 			some reason has no service id, it shall return 0.
-	 * @return	The service ID or 0.
-	 */
-	virtual uint16_t getIdentifier() = 0;
-	/**
-	 * @brief	This method returns the message queue id of the telecommand
-	 * 			receiving message queue.
-	 * @return	The telecommand reception message queue id.
-	 */
-	virtual MessageQueueId_t getRequestQueue() = 0;
-};
-
-
-#endif /* FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
+#define FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * @brief 	This interface is implemented by classes that are sinks for
+ * 			Telecommands.
+ * @details	Any service receiving telecommands shall implement this interface
+ * 			and thus make the service id and the receiving message queue public.
+ */
+class AcceptsTelecommandsIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
+	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
+	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(5);
+	/**
+	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
+	 */
+	virtual ~AcceptsTelecommandsIF() {
+
+	}
+	/**
+	 * @brief	Getter for the service id.
+	 * @details	Any receiving service (at least any PUS service) shall have a
+	 * 			service ID. If the receiver can handle Telecommands, but for
+	 * 			some reason has no service id, it shall return 0.
+	 * @return	The service ID or 0.
+	 */
+	virtual uint16_t getIdentifier() = 0;
+	/**
+	 * @brief	This method returns the message queue id of the telecommand
+	 * 			receiving message queue.
+	 * @return	The telecommand reception message queue id.
+	 */
+	virtual MessageQueueId_t getRequestQueue() = 0;
+};
+
+
+#endif /* FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_ */
diff --git a/tmtcservices/AcceptsTelemetryIF.h b/tmtcservices/AcceptsTelemetryIF.h
index bcb386660..2325dbe08 100644
--- a/tmtcservices/AcceptsTelemetryIF.h
+++ b/tmtcservices/AcceptsTelemetryIF.h
@@ -1,26 +1,26 @@
-#ifndef ACCEPTSTELEMETRYIF_H_
-#define ACCEPTSTELEMETRYIF_H_
-
-#include "../ipc/MessageQueueSenderIF.h"
-/**
- * @brief 	This interface is implemented by classes that are sinks for
- * 			Telemetry.
- * @details	Any object receiving telemetry shall implement this interface
- * 			and thus make the service id and the receiving message queue public.
- */
-class AcceptsTelemetryIF {
-public:
-	/**
-	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
-	 */
-	virtual ~AcceptsTelemetryIF() {
-	}
-	/**
-	 * @brief	This method returns the message queue id of the telemetry
-	 * 			receiving message queue.
-	 * @return	The telemetry reception message queue id.
-	 */
-	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) = 0;
-};
-
-#endif /* ACCEPTSTELEMETRYIF_H_ */
+#ifndef ACCEPTSTELEMETRYIF_H_
+#define ACCEPTSTELEMETRYIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+/**
+ * @brief 	This interface is implemented by classes that are sinks for
+ * 			Telemetry.
+ * @details	Any object receiving telemetry shall implement this interface
+ * 			and thus make the service id and the receiving message queue public.
+ */
+class AcceptsTelemetryIF {
+public:
+	/**
+	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
+	 */
+	virtual ~AcceptsTelemetryIF() {
+	}
+	/**
+	 * @brief	This method returns the message queue id of the telemetry
+	 * 			receiving message queue.
+	 * @return	The telemetry reception message queue id.
+	 */
+	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) = 0;
+};
+
+#endif /* ACCEPTSTELEMETRYIF_H_ */
diff --git a/tmtcservices/AcceptsVerifyMessageIF.h b/tmtcservices/AcceptsVerifyMessageIF.h
index a312390e6..c9318ab01 100644
--- a/tmtcservices/AcceptsVerifyMessageIF.h
+++ b/tmtcservices/AcceptsVerifyMessageIF.h
@@ -1,15 +1,15 @@
-#ifndef ACCEPTSVERIFICATIONMESSAGEIF_H_
-#define ACCEPTSVERIFICATIONMESSAGEIF_H_
-
-#include "../ipc/MessageQueueSenderIF.h"
-
-class AcceptsVerifyMessageIF {
-public:
-	virtual ~AcceptsVerifyMessageIF() {
-
-	}
-	virtual MessageQueueId_t getVerificationQueue() = 0;
-};
-
-
-#endif /* ACCEPTSVERIFICATIONMESSAGEIF_H_ */
+#ifndef ACCEPTSVERIFICATIONMESSAGEIF_H_
+#define ACCEPTSVERIFICATIONMESSAGEIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+class AcceptsVerifyMessageIF {
+public:
+	virtual ~AcceptsVerifyMessageIF() {
+
+	}
+	virtual MessageQueueId_t getVerificationQueue() = 0;
+};
+
+
+#endif /* ACCEPTSVERIFICATIONMESSAGEIF_H_ */
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 3325b10bf..e5a87f180 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -1,427 +1,427 @@
-#include "../tcdistribution/PUSDistributorIF.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-#include "../tmtcservices/CommandingServiceBase.h"
-#include "../tmtcservices/TmTcMessage.h"
-#include "../ipc/QueueFactory.h"
-#include "../tmtcpacket/pus/TcPacketStored.h"
-#include "../tmtcpacket/pus/TmPacketStored.h"
-
-object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
-object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
-
-CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
-		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
-		uint16_t commandTimeoutSeconds, size_t queueDepth) :
-		SystemObject(setObjectId), apid(apid), service(service),
-		timeoutSeconds(commandTimeoutSeconds),
-		commandMap(numberOfParallelCommands) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
-	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
-}
-
-void CommandingServiceBase::setPacketSource(object_id_t packetSource) {
-	this->packetSource = packetSource;
-}
-
-void CommandingServiceBase::setPacketDestination(
-		object_id_t packetDestination) {
-	this->packetDestination = packetDestination;
-}
-
-
-CommandingServiceBase::~CommandingServiceBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-	QueueFactory::instance()->deleteMessageQueue(requestQueue);
-}
-
-
-ReturnValue_t CommandingServiceBase::performOperation(uint8_t opCode) {
-	handleCommandQueue();
-	handleRequestQueue();
-	checkTimeout();
-	doPeriodicOperation();
-	return RETURN_OK;
-}
-
-
-uint16_t CommandingServiceBase::getIdentifier() {
-	return service;
-}
-
-
-MessageQueueId_t CommandingServiceBase::getRequestQueue() {
-	return requestQueue->getId();
-}
-
-
-ReturnValue_t CommandingServiceBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	if(packetDestination == objects::NO_OBJECT) {
-	    packetDestination = defaultPacketDestination;
-	}
-	AcceptsTelemetryIF* packetForwarding =
-			objectManager->get<AcceptsTelemetryIF>(packetDestination);
-
-	if(packetSource == objects::NO_OBJECT) {
-	    packetSource = defaultPacketSource;
-	}
-	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
-			packetSource);
-
-	if (packetForwarding == nullptr or distributor == nullptr) {
-	    sif::error << "CommandingServiceBase::intialize: Packet source or "
-	            "packet destination invalid!" << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	distributor->registerService(this);
-	requestQueue->setDefaultDestination(
-			packetForwarding->getReportReceptionQueue());
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-
-	if (IPCStore == nullptr or TCStore == nullptr) {
-	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
-	                    "not initialized yet!" << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	return RETURN_OK;
-
-}
-
-void CommandingServiceBase::handleCommandQueue() {
-	CommandMessage reply;
-	ReturnValue_t result = RETURN_FAILED;
-	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&reply)) {
-		handleCommandMessage(&reply);
-	}
-}
-
-
-void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
-	bool isStep = false;
-	CommandMessage nextCommand;
-	CommandMapIter iter = commandMap.find(reply->getSender());
-
-	// handle unrequested reply first
-	if (reply->getSender() == MessageQueueIF::NO_QUEUE or
-			iter == commandMap.end()) {
-		handleUnrequestedReply(reply);
-		return;
-	}
-	nextCommand.setCommand(CommandMessage::CMD_NONE);
-
-
-	// Implemented by child class, specifies what to do with reply.
-	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
-			&nextCommand, iter->objectId, &isStep);
-
-	/* If the child implementation does not implement special handling for
-	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
-	 * failure verification will be generated with the reason as the
-	 * return code and the initial command as failure parameter 1 */
-	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
-			(result == RETURN_FAILED or result == INVALID_REPLY)) {
-	    result = reply->getReplyRejectedReason();
-	    failureParameter1 = iter->command;
-	}
-
-	switch (result) {
-	case EXECUTION_COMPLETE:
-	case RETURN_OK:
-	case NO_STEP_MESSAGE:
-		// handle result of reply handler implemented by developer.
-		handleReplyHandlerResult(result, iter, &nextCommand, reply, isStep);
-		break;
-	case INVALID_REPLY:
-		//might be just an unrequested reply at a bad moment
-		handleUnrequestedReply(reply);
-		break;
-	default:
-		if (isStep) {
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					result, ++iter->step, failureParameter1,
-					failureParameter2);
-		} else {
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					result, 0, failureParameter1, failureParameter2);
-		}
-		failureParameter1 = 0;
-		failureParameter2 = 0;
-		checkAndExecuteFifo(iter);
-		break;
-	}
-
-}
-
-void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
-		CommandMapIter iter, CommandMessage* nextCommand,
-		CommandMessage* reply, bool& isStep) {
-	iter->command = nextCommand->getCommand();
-
-	// In case a new command is to be sent immediately, this is performed here.
-	// If no new command is sent, only analyse reply result by initializing
-	// sendResult as RETURN_OK
-	ReturnValue_t sendResult = RETURN_OK;
-	if (nextCommand->getCommand() != CommandMessage::CMD_NONE) {
-		sendResult = commandQueue->sendMessage(reply->getSender(),
-				nextCommand);
-	}
-
-	if (sendResult == RETURN_OK) {
-		if (isStep and result != NO_STEP_MESSAGE) {
-			verificationReporter.sendSuccessReport(
-					TC_VERIFY::PROGRESS_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, ++iter->step);
-		}
-		else {
-			verificationReporter.sendSuccessReport(
-					TC_VERIFY::COMPLETION_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, 0);
-			checkAndExecuteFifo(iter);
-		}
-	}
-	else {
-		if (isStep) {
-			nextCommand->clearCommandMessage();
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult,
-					++iter->step, failureParameter1, failureParameter2);
-		} else {
-			nextCommand->clearCommandMessage();
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult, 0,
-					failureParameter1, failureParameter2);
-		}
-		failureParameter1 = 0;
-		failureParameter2 = 0;
-		checkAndExecuteFifo(iter);
-	}
-}
-
-void CommandingServiceBase::handleRequestQueue() {
-	TmTcMessage message;
-	ReturnValue_t result;
-	store_address_t address;
-	TcPacketStored packet;
-	MessageQueueId_t queue;
-	object_id_t objectId;
-	for (result = requestQueue->receiveMessage(&message); result == RETURN_OK;
-			result = requestQueue->receiveMessage(&message)) {
-		address = message.getStorageId();
-		packet.setStoreAddress(address);
-
-		if ((packet.getSubService() == 0)
-				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
-			continue;
-		}
-		result = getMessageQueueAndObject(packet.getSubService(),
-				packet.getApplicationData(), packet.getApplicationDataSize(),
-				&queue, &objectId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, result);
-			continue;
-		}
-
-		//Is a command already active for the target object?
-		CommandMapIter iter;
-		iter = commandMap.find(queue);
-
-		if (iter != commandMap.end()) {
-			result = iter->fifo.insert(address);
-			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
-			}
-		} else {
-			CommandInfo newInfo; //Info will be set by startExecution if neccessary
-			newInfo.objectId = objectId;
-			result = commandMap.insert(queue, newInfo, &iter);
-			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, BUSY);
-			} else {
-				startExecution(&packet, iter);
-			}
-		}
-
-	}
-}
-
-
-ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
-		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
-		size_t headerSize) {
-	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-			this->tmPacketCounter, data, dataLen, headerData, headerSize);
-	ReturnValue_t result = tmPacketStored.sendPacket(
-			requestQueue->getDefaultDestination(), requestQueue->getId());
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		this->tmPacketCounter++;
-	}
-	return result;
-}
-
-
-ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
-        object_id_t objectId, const uint8_t *data, size_t dataLen) {
-    uint8_t buffer[sizeof(object_id_t)];
-    uint8_t* pBuffer = buffer;
-    size_t size = 0;
-    SerializeAdapter::serialize(&objectId, &pBuffer, &size,
-                sizeof(object_id_t), SerializeIF::Endianness::BIG);
-    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-            this->tmPacketCounter, data, dataLen, buffer, size);
-    ReturnValue_t result = tmPacketStored.sendPacket(
-            requestQueue->getDefaultDestination(), requestQueue->getId());
-    if (result == HasReturnvaluesIF::RETURN_OK) {
-        this->tmPacketCounter++;
-    }
-    return result;
-}
-
-
-ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
-        SerializeIF* content, SerializeIF* header) {
-    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-            this->tmPacketCounter, content, header);
-    ReturnValue_t result = tmPacketStored.sendPacket(
-            requestQueue->getDefaultDestination(), requestQueue->getId());
-    if (result == HasReturnvaluesIF::RETURN_OK) {
-        this->tmPacketCounter++;
-    }
-    return result;
-}
-
-
-void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
-        CommandMapIter iter) {
-    ReturnValue_t result = RETURN_OK;
-    CommandMessage command;
-    iter->subservice = storedPacket->getSubService();
-    result = prepareCommand(&command, iter->subservice,
-            storedPacket->getApplicationData(),
-            storedPacket->getApplicationDataSize(), &iter->state,
-            iter->objectId);
-
-    ReturnValue_t sendResult = RETURN_OK;
-	switch (result) {
-	case RETURN_OK:
-		if (command.getCommand() != CommandMessage::CMD_NONE) {
-			sendResult = commandQueue->sendMessage(iter.value->first,
-					&command);
-		}
-		if (sendResult == RETURN_OK) {
-			Clock::getUptime(&iter->uptimeOfStart);
-			iter->step = 0;
-			iter->subservice = storedPacket->getSubService();
-			iter->command = command.getCommand();
-			iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
-			iter->tcInfo.tcPacketId = storedPacket->getPacketId();
-			iter->tcInfo.tcSequenceControl =
-					storedPacket->getPacketSequenceControl();
-			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
-		} else {
-			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
-			checkAndExecuteFifo(iter);
-		}
-		break;
-	case EXECUTION_COMPLETE:
-		if (command.getCommand() != CommandMessage::CMD_NONE) {
-			//Fire-and-forget command.
-			sendResult = commandQueue->sendMessage(iter.value->first,
-					&command);
-		}
-		if (sendResult == RETURN_OK) {
-			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
-					storedPacket);
-			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
-			checkAndExecuteFifo(iter);
-		} else {
-			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
-			checkAndExecuteFifo(iter);
-		}
-		break;
-	default:
-		rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, result);
-		checkAndExecuteFifo(iter);
-		break;
-	}
-}
-
-
-void CommandingServiceBase::rejectPacket(uint8_t report_id,
-		TcPacketStored* packet, ReturnValue_t error_code) {
-	verificationReporter.sendFailureReport(report_id, packet, error_code);
-	packet->deletePacket();
-}
-
-
-void CommandingServiceBase::acceptPacket(uint8_t reportId,
-		TcPacketStored* packet) {
-	verificationReporter.sendSuccessReport(reportId, packet);
-	packet->deletePacket();
-}
-
-
-void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
-	store_address_t address;
-	if (iter->fifo.retrieve(&address) != RETURN_OK) {
-		commandMap.erase(&iter);
-	} else {
-		TcPacketStored newPacket(address);
-		startExecution(&newPacket, iter);
-	}
-}
-
-
-void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) {
-	reply->clearCommandMessage();
-}
-
-
-inline void CommandingServiceBase::doPeriodicOperation() {
-}
-
-MessageQueueId_t CommandingServiceBase::getCommandQueue() {
-	return commandQueue->getId();
-}
-
-void CommandingServiceBase::checkTimeout() {
-	uint32_t uptime;
-	Clock::getUptime(&uptime);
-	CommandMapIter iter;
-	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
-		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					TIMEOUT);
-			checkAndExecuteFifo(iter);
-		}
-	}
-}
-
-void CommandingServiceBase::setTaskIF(PeriodicTaskIF* task_) {
-    executingTask = task_;
-}
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+#include "../tmtcservices/CommandingServiceBase.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+
+object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
+
+CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
+		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
+		uint16_t commandTimeoutSeconds, size_t queueDepth) :
+		SystemObject(setObjectId), apid(apid), service(service),
+		timeoutSeconds(commandTimeoutSeconds),
+		commandMap(numberOfParallelCommands) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
+	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
+}
+
+void CommandingServiceBase::setPacketSource(object_id_t packetSource) {
+	this->packetSource = packetSource;
+}
+
+void CommandingServiceBase::setPacketDestination(
+		object_id_t packetDestination) {
+	this->packetDestination = packetDestination;
+}
+
+
+CommandingServiceBase::~CommandingServiceBase() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+	QueueFactory::instance()->deleteMessageQueue(requestQueue);
+}
+
+
+ReturnValue_t CommandingServiceBase::performOperation(uint8_t opCode) {
+	handleCommandQueue();
+	handleRequestQueue();
+	checkTimeout();
+	doPeriodicOperation();
+	return RETURN_OK;
+}
+
+
+uint16_t CommandingServiceBase::getIdentifier() {
+	return service;
+}
+
+
+MessageQueueId_t CommandingServiceBase::getRequestQueue() {
+	return requestQueue->getId();
+}
+
+
+ReturnValue_t CommandingServiceBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	if(packetDestination == objects::NO_OBJECT) {
+	    packetDestination = defaultPacketDestination;
+	}
+	AcceptsTelemetryIF* packetForwarding =
+			objectManager->get<AcceptsTelemetryIF>(packetDestination);
+
+	if(packetSource == objects::NO_OBJECT) {
+	    packetSource = defaultPacketSource;
+	}
+	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
+			packetSource);
+
+	if (packetForwarding == nullptr or distributor == nullptr) {
+	    sif::error << "CommandingServiceBase::intialize: Packet source or "
+	            "packet destination invalid!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	distributor->registerService(this);
+	requestQueue->setDefaultDestination(
+			packetForwarding->getReportReceptionQueue());
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+
+	if (IPCStore == nullptr or TCStore == nullptr) {
+	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
+	                    "not initialized yet!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	return RETURN_OK;
+
+}
+
+void CommandingServiceBase::handleCommandQueue() {
+	CommandMessage reply;
+	ReturnValue_t result = RETURN_FAILED;
+	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&reply)) {
+		handleCommandMessage(&reply);
+	}
+}
+
+
+void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
+	bool isStep = false;
+	CommandMessage nextCommand;
+	CommandMapIter iter = commandMap.find(reply->getSender());
+
+	// handle unrequested reply first
+	if (reply->getSender() == MessageQueueIF::NO_QUEUE or
+			iter == commandMap.end()) {
+		handleUnrequestedReply(reply);
+		return;
+	}
+	nextCommand.setCommand(CommandMessage::CMD_NONE);
+
+
+	// Implemented by child class, specifies what to do with reply.
+	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
+			&nextCommand, iter->objectId, &isStep);
+
+	/* If the child implementation does not implement special handling for
+	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
+	 * failure verification will be generated with the reason as the
+	 * return code and the initial command as failure parameter 1 */
+	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
+			(result == RETURN_FAILED or result == INVALID_REPLY)) {
+	    result = reply->getReplyRejectedReason();
+	    failureParameter1 = iter->command;
+	}
+
+	switch (result) {
+	case EXECUTION_COMPLETE:
+	case RETURN_OK:
+	case NO_STEP_MESSAGE:
+		// handle result of reply handler implemented by developer.
+		handleReplyHandlerResult(result, iter, &nextCommand, reply, isStep);
+		break;
+	case INVALID_REPLY:
+		//might be just an unrequested reply at a bad moment
+		handleUnrequestedReply(reply);
+		break;
+	default:
+		if (isStep) {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, ++iter->step, failureParameter1,
+					failureParameter2);
+		} else {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, 0, failureParameter1, failureParameter2);
+		}
+		failureParameter1 = 0;
+		failureParameter2 = 0;
+		checkAndExecuteFifo(iter);
+		break;
+	}
+
+}
+
+void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
+		CommandMapIter iter, CommandMessage* nextCommand,
+		CommandMessage* reply, bool& isStep) {
+	iter->command = nextCommand->getCommand();
+
+	// In case a new command is to be sent immediately, this is performed here.
+	// If no new command is sent, only analyse reply result by initializing
+	// sendResult as RETURN_OK
+	ReturnValue_t sendResult = RETURN_OK;
+	if (nextCommand->getCommand() != CommandMessage::CMD_NONE) {
+		sendResult = commandQueue->sendMessage(reply->getSender(),
+				nextCommand);
+	}
+
+	if (sendResult == RETURN_OK) {
+		if (isStep and result != NO_STEP_MESSAGE) {
+			verificationReporter.sendSuccessReport(
+					TC_VERIFY::PROGRESS_SUCCESS,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, ++iter->step);
+		}
+		else {
+			verificationReporter.sendSuccessReport(
+					TC_VERIFY::COMPLETION_SUCCESS,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, 0);
+			checkAndExecuteFifo(iter);
+		}
+	}
+	else {
+		if (isStep) {
+			nextCommand->clearCommandMessage();
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult,
+					++iter->step, failureParameter1, failureParameter2);
+		} else {
+			nextCommand->clearCommandMessage();
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult, 0,
+					failureParameter1, failureParameter2);
+		}
+		failureParameter1 = 0;
+		failureParameter2 = 0;
+		checkAndExecuteFifo(iter);
+	}
+}
+
+void CommandingServiceBase::handleRequestQueue() {
+	TmTcMessage message;
+	ReturnValue_t result;
+	store_address_t address;
+	TcPacketStored packet;
+	MessageQueueId_t queue;
+	object_id_t objectId;
+	for (result = requestQueue->receiveMessage(&message); result == RETURN_OK;
+			result = requestQueue->receiveMessage(&message)) {
+		address = message.getStorageId();
+		packet.setStoreAddress(address);
+
+		if ((packet.getSubService() == 0)
+				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
+			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
+			continue;
+		}
+		result = getMessageQueueAndObject(packet.getSubService(),
+				packet.getApplicationData(), packet.getApplicationDataSize(),
+				&queue, &objectId);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			rejectPacket(TC_VERIFY::START_FAILURE, &packet, result);
+			continue;
+		}
+
+		//Is a command already active for the target object?
+		CommandMapIter iter;
+		iter = commandMap.find(queue);
+
+		if (iter != commandMap.end()) {
+			result = iter->fifo.insert(address);
+			if (result != RETURN_OK) {
+				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
+			}
+		} else {
+			CommandInfo newInfo; //Info will be set by startExecution if neccessary
+			newInfo.objectId = objectId;
+			result = commandMap.insert(queue, newInfo, &iter);
+			if (result != RETURN_OK) {
+				rejectPacket(TC_VERIFY::START_FAILURE, &packet, BUSY);
+			} else {
+				startExecution(&packet, iter);
+			}
+		}
+
+	}
+}
+
+
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
+		size_t headerSize) {
+	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+			this->tmPacketCounter, data, dataLen, headerData, headerSize);
+	ReturnValue_t result = tmPacketStored.sendPacket(
+			requestQueue->getDefaultDestination(), requestQueue->getId());
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		this->tmPacketCounter++;
+	}
+	return result;
+}
+
+
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+        object_id_t objectId, const uint8_t *data, size_t dataLen) {
+    uint8_t buffer[sizeof(object_id_t)];
+    uint8_t* pBuffer = buffer;
+    size_t size = 0;
+    SerializeAdapter::serialize(&objectId, &pBuffer, &size,
+                sizeof(object_id_t), SerializeIF::Endianness::BIG);
+    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+            this->tmPacketCounter, data, dataLen, buffer, size);
+    ReturnValue_t result = tmPacketStored.sendPacket(
+            requestQueue->getDefaultDestination(), requestQueue->getId());
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        this->tmPacketCounter++;
+    }
+    return result;
+}
+
+
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+        SerializeIF* content, SerializeIF* header) {
+    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+            this->tmPacketCounter, content, header);
+    ReturnValue_t result = tmPacketStored.sendPacket(
+            requestQueue->getDefaultDestination(), requestQueue->getId());
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        this->tmPacketCounter++;
+    }
+    return result;
+}
+
+
+void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
+        CommandMapIter iter) {
+    ReturnValue_t result = RETURN_OK;
+    CommandMessage command;
+    iter->subservice = storedPacket->getSubService();
+    result = prepareCommand(&command, iter->subservice,
+            storedPacket->getApplicationData(),
+            storedPacket->getApplicationDataSize(), &iter->state,
+            iter->objectId);
+
+    ReturnValue_t sendResult = RETURN_OK;
+	switch (result) {
+	case RETURN_OK:
+		if (command.getCommand() != CommandMessage::CMD_NONE) {
+			sendResult = commandQueue->sendMessage(iter.value->first,
+					&command);
+		}
+		if (sendResult == RETURN_OK) {
+			Clock::getUptime(&iter->uptimeOfStart);
+			iter->step = 0;
+			iter->subservice = storedPacket->getSubService();
+			iter->command = command.getCommand();
+			iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
+			iter->tcInfo.tcPacketId = storedPacket->getPacketId();
+			iter->tcInfo.tcSequenceControl =
+					storedPacket->getPacketSequenceControl();
+			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
+		} else {
+			command.clearCommandMessage();
+			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			checkAndExecuteFifo(iter);
+		}
+		break;
+	case EXECUTION_COMPLETE:
+		if (command.getCommand() != CommandMessage::CMD_NONE) {
+			//Fire-and-forget command.
+			sendResult = commandQueue->sendMessage(iter.value->first,
+					&command);
+		}
+		if (sendResult == RETURN_OK) {
+			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
+					storedPacket);
+			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
+			checkAndExecuteFifo(iter);
+		} else {
+			command.clearCommandMessage();
+			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			checkAndExecuteFifo(iter);
+		}
+		break;
+	default:
+		rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, result);
+		checkAndExecuteFifo(iter);
+		break;
+	}
+}
+
+
+void CommandingServiceBase::rejectPacket(uint8_t report_id,
+		TcPacketStored* packet, ReturnValue_t error_code) {
+	verificationReporter.sendFailureReport(report_id, packet, error_code);
+	packet->deletePacket();
+}
+
+
+void CommandingServiceBase::acceptPacket(uint8_t reportId,
+		TcPacketStored* packet) {
+	verificationReporter.sendSuccessReport(reportId, packet);
+	packet->deletePacket();
+}
+
+
+void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
+	store_address_t address;
+	if (iter->fifo.retrieve(&address) != RETURN_OK) {
+		commandMap.erase(&iter);
+	} else {
+		TcPacketStored newPacket(address);
+		startExecution(&newPacket, iter);
+	}
+}
+
+
+void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) {
+	reply->clearCommandMessage();
+}
+
+
+inline void CommandingServiceBase::doPeriodicOperation() {
+}
+
+MessageQueueId_t CommandingServiceBase::getCommandQueue() {
+	return commandQueue->getId();
+}
+
+void CommandingServiceBase::checkTimeout() {
+	uint32_t uptime;
+	Clock::getUptime(&uptime);
+	CommandMapIter iter;
+	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
+		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					TIMEOUT);
+			checkAndExecuteFifo(iter);
+		}
+	}
+}
+
+void CommandingServiceBase::setTaskIF(PeriodicTaskIF* task_) {
+    executingTask = task_;
+}
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 32173d81f..4a1804452 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -1,348 +1,348 @@
-#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
-
-#include "../objectmanager/SystemObject.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-
-#include "../tmtcservices/VerificationReporter.h"
-#include "../ipc/CommandMessage.h"
-#include "../container/FixedMap.h"
-#include "../container/FIFO.h"
-#include "../serialize/SerializeIF.h"
-
-class TcPacketStored;
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @brief 	This class is the basis for all PUS Services, which have to
- * 			relay Telecommands to software bus.
- *
- * It manages Telecommand reception and the generation of Verification Reports
- * similar to PusServiceBase. This class is used if a telecommand can't be
- * handled immediately and must be relayed to the internal software bus.
- *   - isValidSubservice
- *   - getMessageQueueAndObject
- *   - prepareCommand
- *   - handleReply
- * @author gaisser
- * @ingroup pus_services
- */
-class CommandingServiceBase: public SystemObject,
-		public AcceptsTelecommandsIF,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
-	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t NO_STEP_MESSAGE = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t OBJECT_BUSY = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t INVALID_TC = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t INVALID_OBJECT = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t INVALID_REPLY = MAKE_RETURN_CODE(7);
-
-	/**
-	 * Class constructor. Initializes two important MessageQueues:
-	 * commandQueue for command reception and requestQueue for device reception
-	 * @param setObjectId
-	 * @param apid
-	 * @param service
-	 * @param numberOfParallelCommands
-	 * @param commandTimeout_seconds
-	 * @param setPacketSource
-	 * @param setPacketDestination
-	 * @param queueDepth
-	 */
-	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
-			uint8_t service, uint8_t numberOfParallelCommands,
-			uint16_t commandTimeoutSeconds, size_t queueDepth = 20);
-	virtual ~CommandingServiceBase();
-
-	/**
-	 * This setter can be used to set the packet source individually instead
-	 * of using the default static framework ID set in the factory.
-	 * This should be called at object initialization and not during run-time!
-	 * @param packetSource
-	 */
-	void setPacketSource(object_id_t packetSource);
-	/**
-	 * This setter can be used to set the packet destination individually
-	 * instead of using the default static framework ID set in the factory.
-	 * This should be called at object initialization and not during run-time!
-	 * @param packetDestination
-	 */
-	void setPacketDestination(object_id_t packetDestination);
-
-	/***
-	 * This is the periodically called function.
-	 * Handle request queue for external commands.
-	 * Handle command Queue for internal commands.
-	 * @param opCode is unused here at the moment
-	 * @return RETURN_OK
-	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-
-	virtual uint16_t getIdentifier();
-
-	/**
-	 * Returns the requestQueue MessageQueueId_t
-	 *
-	 * The requestQueue is the queue for external commands (TC)
-	 *
-	 * @return requestQueue messageQueueId_t
-	 */
-	virtual MessageQueueId_t getRequestQueue();
-
-	/**
-	 * Returns the commandQueue MessageQueueId_t
-	 *
-	 * Remember the CommandQueue is the queue for internal communication
-	 * @return commandQueue messageQueueId_t
-	 */
-	virtual MessageQueueId_t getCommandQueue();
-
-	virtual ReturnValue_t initialize() override;
-
-	/**
-	 * Implementation of ExecutableObjectIF function
-	 *
-	 * Used to setup the reference of the task, that executes this component
-	 * @param task Pointer to the taskIF of this task
-	 */
-	virtual void setTaskIF(PeriodicTaskIF* task) override;
-
-protected:
-	/**
-	 * Check the target subservice
-	 * @param subservice[in]
-	 * @return
-	 * -@c RETURN_OK Subservice valid, continue message handling
-     * -@c INVALID_SUBSERVICE if service is not known, rejects packet.
-	 */
-	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
-
-	/**
-	 * Once a TC Request is valid, the existence of the destination and its
-	 * target interface is checked and retrieved. The target message queue ID
-	 * can then be acquired by using the target interface.
-	 * @param subservice
-	 * @param tcData Application Data of TC Packet
-	 * @param tcDataLen
-	 * @param id MessageQueue ID is stored here
-	 * @param objectId Object ID is extracted and stored here
-	 * @return
-	 * - @c RETURN_OK Cotinue message handling
-	 * - @c RETURN_FAILED Reject the packet and generates a start failure
-	 *      verification
-	 */
-	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) = 0;
-
-	/**
-	 * After the Message Queue and Object ID are determined, the command is
-	 * prepared by using an implementation specific CommandMessage type
-	 * which is sent to the target object. It contains all necessary information
-	 * for the device to execute telecommands.
-	 * @param message [out] message which can be set and is sent to the object
-	 * @param subservice Subservice of the current communication
-	 * @param tcData Application data of command
-	 * @param tcDataLen Application data length
-	 * @param state [out/in] Setable state of the communication.
-	 * communication
-	 * @param objectId Target object ID
-	 * @return
-	 * - @c RETURN_OK to generate a verification start message
-	 * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
-	 *      verification message.
-	 * - @c Anything else rejects the packets and generates a start failure
-	 *      verification.
-	 */
-	virtual ReturnValue_t prepareCommand(CommandMessage* message,
-			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-			uint32_t *state, object_id_t objectId) = 0;
-
-	/**
-	 * This function is implemented by child services to specify how replies
-	 * to a command from another software component are handled.
-	 * @param reply
-	 * This is the reply in form of a generic read-only command message.
-	 * @param previousCommand
-	 * Command_t of related command
-	 * @param state [out/in]
-	 * Additional parameter which can be used to pass state information.
-	 * State of the communication
-	 * @param optionalNextCommand [out]
-	 * An optional next command which can be set in this function
-	 * @param objectId Source object ID
-	 * @param isStep Flag value to mark steps of command execution
-	 * @return
-	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
-	 *   generate TC verification success
-	 * - @c INVALID_REPLY Calls handleUnrequestedReply
-	 * - Anything else triggers a TC verification failure. If RETURN_FAILED or
-	 * 	 INVALID_REPLY is returned and the command ID is
-	 * 	 CommandMessage::REPLY_REJECTED, a failure verification message with
-	 * 	 the reason as the error parameter and the initial command as
-	 * 	 failure parameter 1 is generated.
-	 */
-	virtual ReturnValue_t handleReply(const CommandMessage* reply,
-			Command_t previousCommand, uint32_t *state,
-			CommandMessage* optionalNextCommand, object_id_t objectId,
-			bool *isStep) = 0;
-
-	/**
-	 * This function can be overidden to handle unrequested reply,
-	 * when the reply sender ID is unknown or is not found is the command map.
-	 * The default implementation will clear the command message and all
-	 * its contents.
-	 * @param reply
-	 * Reply which is non-const so the default implementation can clear the
-	 * message.
-	 */
-	virtual void handleUnrequestedReply(CommandMessage* reply);
-
-	virtual void doPeriodicOperation();
-
-
-	struct CommandInfo {
-		struct tcInfo {
-			uint8_t ackFlags;
-			uint16_t tcPacketId;
-			uint16_t tcSequenceControl;
-		} tcInfo;
-		uint32_t uptimeOfStart;
-		uint8_t step;
-		uint8_t subservice;
-		uint32_t state;
-		Command_t command;
-		object_id_t objectId;
-		FIFO<store_address_t, 3> fifo;
-	};
-
-	using CommandMapIter = FixedMap<MessageQueueId_t,
-	        CommandingServiceBase::CommandInfo>::Iterator;
-
-	const uint16_t apid;
-
-	const uint8_t service;
-
-	const uint16_t timeoutSeconds;
-
-	uint8_t tmPacketCounter = 0;
-
-	StorageManagerIF *IPCStore = nullptr;
-
-	StorageManagerIF *TCStore = nullptr;
-
-	MessageQueueIF* commandQueue = nullptr;
-
-	MessageQueueIF* requestQueue = nullptr;
-
-	VerificationReporter verificationReporter;
-
-	FixedMap<MessageQueueId_t, CommandInfo> commandMap;
-
-	/* May be set be children to return a more precise failure condition. */
-	uint32_t failureParameter1 = 0;
-	uint32_t failureParameter2 = 0;
-
-	static object_id_t defaultPacketSource;
-	object_id_t packetSource = objects::NO_OBJECT;
-	static object_id_t defaultPacketDestination;
-	object_id_t packetDestination = objects::NO_OBJECT;
-
-	/**
-	 * Pointer to the task which executes this component,
-	 * is invalid before setTaskIF was called.
-	 */
-	PeriodicTaskIF* executingTask = nullptr;
-
-	/**
-	 * @brief   Send TM data from pointer to data.
-	 *          If a header is supplied it is added before data
-	 * @param subservice Number of subservice
-	 * @param data Pointer to the data in the Packet
-	 * @param dataLen Lenght of data in the Packet
-	 * @param headerData HeaderData will be placed before data
-	 * @param headerSize Size of HeaderData
-	 */
-	ReturnValue_t sendTmPacket(uint8_t subservice, const uint8_t *data,
-	        size_t dataLen, const uint8_t* headerData = nullptr,
-	        size_t headerSize = 0);
-
-	/**
-	 * @brief   To send TM packets of objects that still need to be serialized
-	 *          and consist of an object ID with appended data.
-	 * @param subservice Number of subservice
-	 * @param objectId ObjectId is placed before data
-	 * @param data Data to append to the packet
-	 * @param dataLen Length of Data
-	 */
-	ReturnValue_t sendTmPacket(uint8_t subservice, object_id_t objectId,
-			const uint8_t *data, size_t dataLen);
-
-	/**
-	 * @brief   To send packets which are contained inside a class implementing
-	 *          SerializeIF.
-	 * @param subservice Number of subservice
-	 * @param content This is a pointer to the serialized packet
-	 * @param header Serialize IF header which will be placed before content
-	 */
-	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
-			SerializeIF* header = nullptr);
-
-	void checkAndExecuteFifo(CommandMapIter iter);
-
-private:
-	/**
-	 * This method handles internal execution of a command,
-	 * once it has been started by @sa{startExecution()} in the request
-	 * queue handler.
-	 * It handles replies generated by the devices and relayed by the specific
-	 * service implementation. This means that it determines further course of
-	 * action depending on the return values specified in the service
-	 * implementation.
-	 * This includes the generation of TC verification messages. Note that
-	 * the static framework object ID @c VerificationReporter::messageReceiver
-	 * needs to be set.
-	 *   - TM[1,5] Step Successs
-	 *   - TM[1,6] Step Failure
-	 *   - TM[1,7] Completion Success
-	 *   - TM[1,8] Completion Failure
-	 */
-	void handleCommandQueue();
-
-	/**
-	 * @brief       Handler function for request queue
-	 * @details
-	 * Sequence of request queue handling:
-	 * isValidSubservice -> getMessageQueueAndObject -> startExecution
-	 * Generates a Start Success Reports TM[1,3] in subfunction
-	 * @sa{startExecution()} or  a Start Failure Report TM[1,4] by using the
-	 * TC Verification Service.
-	 */
-	void handleRequestQueue();
-
-	void rejectPacket(uint8_t reportId, TcPacketStored* packet,
-			ReturnValue_t errorCode);
-
-	void acceptPacket(uint8_t reportId, TcPacketStored* packet);
-
-	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
-
-	void handleCommandMessage(CommandMessage* reply);
-	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
-			CommandMessage* nextCommand, CommandMessage* reply, bool& isStep);
-
-	void checkTimeout();
-};
-
-#endif /* COMMANDINGSERVICEBASE_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+
+#include "../tmtcservices/VerificationReporter.h"
+#include "../ipc/CommandMessage.h"
+#include "../container/FixedMap.h"
+#include "../container/FIFO.h"
+#include "../serialize/SerializeIF.h"
+
+class TcPacketStored;
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @brief 	This class is the basis for all PUS Services, which have to
+ * 			relay Telecommands to software bus.
+ *
+ * It manages Telecommand reception and the generation of Verification Reports
+ * similar to PusServiceBase. This class is used if a telecommand can't be
+ * handled immediately and must be relayed to the internal software bus.
+ *   - isValidSubservice
+ *   - getMessageQueueAndObject
+ *   - prepareCommand
+ *   - handleReply
+ * @author gaisser
+ * @ingroup pus_services
+ */
+class CommandingServiceBase: public SystemObject,
+		public AcceptsTelecommandsIF,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
+	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t NO_STEP_MESSAGE = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t OBJECT_BUSY = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t INVALID_TC = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t INVALID_OBJECT = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t INVALID_REPLY = MAKE_RETURN_CODE(7);
+
+	/**
+	 * Class constructor. Initializes two important MessageQueues:
+	 * commandQueue for command reception and requestQueue for device reception
+	 * @param setObjectId
+	 * @param apid
+	 * @param service
+	 * @param numberOfParallelCommands
+	 * @param commandTimeout_seconds
+	 * @param setPacketSource
+	 * @param setPacketDestination
+	 * @param queueDepth
+	 */
+	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
+			uint8_t service, uint8_t numberOfParallelCommands,
+			uint16_t commandTimeoutSeconds, size_t queueDepth = 20);
+	virtual ~CommandingServiceBase();
+
+	/**
+	 * This setter can be used to set the packet source individually instead
+	 * of using the default static framework ID set in the factory.
+	 * This should be called at object initialization and not during run-time!
+	 * @param packetSource
+	 */
+	void setPacketSource(object_id_t packetSource);
+	/**
+	 * This setter can be used to set the packet destination individually
+	 * instead of using the default static framework ID set in the factory.
+	 * This should be called at object initialization and not during run-time!
+	 * @param packetDestination
+	 */
+	void setPacketDestination(object_id_t packetDestination);
+
+	/***
+	 * This is the periodically called function.
+	 * Handle request queue for external commands.
+	 * Handle command Queue for internal commands.
+	 * @param opCode is unused here at the moment
+	 * @return RETURN_OK
+	 */
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+
+	virtual uint16_t getIdentifier();
+
+	/**
+	 * Returns the requestQueue MessageQueueId_t
+	 *
+	 * The requestQueue is the queue for external commands (TC)
+	 *
+	 * @return requestQueue messageQueueId_t
+	 */
+	virtual MessageQueueId_t getRequestQueue();
+
+	/**
+	 * Returns the commandQueue MessageQueueId_t
+	 *
+	 * Remember the CommandQueue is the queue for internal communication
+	 * @return commandQueue messageQueueId_t
+	 */
+	virtual MessageQueueId_t getCommandQueue();
+
+	virtual ReturnValue_t initialize() override;
+
+	/**
+	 * Implementation of ExecutableObjectIF function
+	 *
+	 * Used to setup the reference of the task, that executes this component
+	 * @param task Pointer to the taskIF of this task
+	 */
+	virtual void setTaskIF(PeriodicTaskIF* task) override;
+
+protected:
+	/**
+	 * Check the target subservice
+	 * @param subservice[in]
+	 * @return
+	 * -@c RETURN_OK Subservice valid, continue message handling
+     * -@c INVALID_SUBSERVICE if service is not known, rejects packet.
+	 */
+	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
+
+	/**
+	 * Once a TC Request is valid, the existence of the destination and its
+	 * target interface is checked and retrieved. The target message queue ID
+	 * can then be acquired by using the target interface.
+	 * @param subservice
+	 * @param tcData Application Data of TC Packet
+	 * @param tcDataLen
+	 * @param id MessageQueue ID is stored here
+	 * @param objectId Object ID is extracted and stored here
+	 * @return
+	 * - @c RETURN_OK Cotinue message handling
+	 * - @c RETURN_FAILED Reject the packet and generates a start failure
+	 *      verification
+	 */
+	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) = 0;
+
+	/**
+	 * After the Message Queue and Object ID are determined, the command is
+	 * prepared by using an implementation specific CommandMessage type
+	 * which is sent to the target object. It contains all necessary information
+	 * for the device to execute telecommands.
+	 * @param message [out] message which can be set and is sent to the object
+	 * @param subservice Subservice of the current communication
+	 * @param tcData Application data of command
+	 * @param tcDataLen Application data length
+	 * @param state [out/in] Setable state of the communication.
+	 * communication
+	 * @param objectId Target object ID
+	 * @return
+	 * - @c RETURN_OK to generate a verification start message
+	 * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
+	 *      verification message.
+	 * - @c Anything else rejects the packets and generates a start failure
+	 *      verification.
+	 */
+	virtual ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) = 0;
+
+	/**
+	 * This function is implemented by child services to specify how replies
+	 * to a command from another software component are handled.
+	 * @param reply
+	 * This is the reply in form of a generic read-only command message.
+	 * @param previousCommand
+	 * Command_t of related command
+	 * @param state [out/in]
+	 * Additional parameter which can be used to pass state information.
+	 * State of the communication
+	 * @param optionalNextCommand [out]
+	 * An optional next command which can be set in this function
+	 * @param objectId Source object ID
+	 * @param isStep Flag value to mark steps of command execution
+	 * @return
+	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
+	 *   generate TC verification success
+	 * - @c INVALID_REPLY Calls handleUnrequestedReply
+	 * - Anything else triggers a TC verification failure. If RETURN_FAILED or
+	 * 	 INVALID_REPLY is returned and the command ID is
+	 * 	 CommandMessage::REPLY_REJECTED, a failure verification message with
+	 * 	 the reason as the error parameter and the initial command as
+	 * 	 failure parameter 1 is generated.
+	 */
+	virtual ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) = 0;
+
+	/**
+	 * This function can be overidden to handle unrequested reply,
+	 * when the reply sender ID is unknown or is not found is the command map.
+	 * The default implementation will clear the command message and all
+	 * its contents.
+	 * @param reply
+	 * Reply which is non-const so the default implementation can clear the
+	 * message.
+	 */
+	virtual void handleUnrequestedReply(CommandMessage* reply);
+
+	virtual void doPeriodicOperation();
+
+
+	struct CommandInfo {
+		struct tcInfo {
+			uint8_t ackFlags;
+			uint16_t tcPacketId;
+			uint16_t tcSequenceControl;
+		} tcInfo;
+		uint32_t uptimeOfStart;
+		uint8_t step;
+		uint8_t subservice;
+		uint32_t state;
+		Command_t command;
+		object_id_t objectId;
+		FIFO<store_address_t, 3> fifo;
+	};
+
+	using CommandMapIter = FixedMap<MessageQueueId_t,
+	        CommandingServiceBase::CommandInfo>::Iterator;
+
+	const uint16_t apid;
+
+	const uint8_t service;
+
+	const uint16_t timeoutSeconds;
+
+	uint8_t tmPacketCounter = 0;
+
+	StorageManagerIF *IPCStore = nullptr;
+
+	StorageManagerIF *TCStore = nullptr;
+
+	MessageQueueIF* commandQueue = nullptr;
+
+	MessageQueueIF* requestQueue = nullptr;
+
+	VerificationReporter verificationReporter;
+
+	FixedMap<MessageQueueId_t, CommandInfo> commandMap;
+
+	/* May be set be children to return a more precise failure condition. */
+	uint32_t failureParameter1 = 0;
+	uint32_t failureParameter2 = 0;
+
+	static object_id_t defaultPacketSource;
+	object_id_t packetSource = objects::NO_OBJECT;
+	static object_id_t defaultPacketDestination;
+	object_id_t packetDestination = objects::NO_OBJECT;
+
+	/**
+	 * Pointer to the task which executes this component,
+	 * is invalid before setTaskIF was called.
+	 */
+	PeriodicTaskIF* executingTask = nullptr;
+
+	/**
+	 * @brief   Send TM data from pointer to data.
+	 *          If a header is supplied it is added before data
+	 * @param subservice Number of subservice
+	 * @param data Pointer to the data in the Packet
+	 * @param dataLen Lenght of data in the Packet
+	 * @param headerData HeaderData will be placed before data
+	 * @param headerSize Size of HeaderData
+	 */
+	ReturnValue_t sendTmPacket(uint8_t subservice, const uint8_t *data,
+	        size_t dataLen, const uint8_t* headerData = nullptr,
+	        size_t headerSize = 0);
+
+	/**
+	 * @brief   To send TM packets of objects that still need to be serialized
+	 *          and consist of an object ID with appended data.
+	 * @param subservice Number of subservice
+	 * @param objectId ObjectId is placed before data
+	 * @param data Data to append to the packet
+	 * @param dataLen Length of Data
+	 */
+	ReturnValue_t sendTmPacket(uint8_t subservice, object_id_t objectId,
+			const uint8_t *data, size_t dataLen);
+
+	/**
+	 * @brief   To send packets which are contained inside a class implementing
+	 *          SerializeIF.
+	 * @param subservice Number of subservice
+	 * @param content This is a pointer to the serialized packet
+	 * @param header Serialize IF header which will be placed before content
+	 */
+	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
+			SerializeIF* header = nullptr);
+
+	void checkAndExecuteFifo(CommandMapIter iter);
+
+private:
+	/**
+	 * This method handles internal execution of a command,
+	 * once it has been started by @sa{startExecution()} in the request
+	 * queue handler.
+	 * It handles replies generated by the devices and relayed by the specific
+	 * service implementation. This means that it determines further course of
+	 * action depending on the return values specified in the service
+	 * implementation.
+	 * This includes the generation of TC verification messages. Note that
+	 * the static framework object ID @c VerificationReporter::messageReceiver
+	 * needs to be set.
+	 *   - TM[1,5] Step Successs
+	 *   - TM[1,6] Step Failure
+	 *   - TM[1,7] Completion Success
+	 *   - TM[1,8] Completion Failure
+	 */
+	void handleCommandQueue();
+
+	/**
+	 * @brief       Handler function for request queue
+	 * @details
+	 * Sequence of request queue handling:
+	 * isValidSubservice -> getMessageQueueAndObject -> startExecution
+	 * Generates a Start Success Reports TM[1,3] in subfunction
+	 * @sa{startExecution()} or  a Start Failure Report TM[1,4] by using the
+	 * TC Verification Service.
+	 */
+	void handleRequestQueue();
+
+	void rejectPacket(uint8_t reportId, TcPacketStored* packet,
+			ReturnValue_t errorCode);
+
+	void acceptPacket(uint8_t reportId, TcPacketStored* packet);
+
+	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
+
+	void handleCommandMessage(CommandMessage* reply);
+	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
+			CommandMessage* nextCommand, CommandMessage* reply, bool& isStep);
+
+	void checkTimeout();
+};
+
+#endif /* COMMANDINGSERVICEBASE_H_ */
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index a8b74e392..9d4aabd96 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -1,123 +1,123 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/PUSDistributorIF.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../tmtcservices/PusServiceBase.h"
-#include "../tmtcservices/PusVerificationReport.h"
-#include "../tmtcservices/TmTcMessage.h"
-#include "../ipc/QueueFactory.h"
-
-object_id_t PusServiceBase::packetSource = 0;
-object_id_t PusServiceBase::packetDestination = 0;
-
-PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid,
-		uint8_t setServiceId) :
-		SystemObject(setObjectId), apid(setApid), serviceId(setServiceId) {
-	requestQueue = QueueFactory::instance()->
-			createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
-}
-
-PusServiceBase::~PusServiceBase() {
-	QueueFactory::instance()->deleteMessageQueue(requestQueue);
-}
-
-ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
-	handleRequestQueue();
-	ReturnValue_t result = this->performService();
-	if (result != RETURN_OK) {
-		sif::error << "PusService " << (uint16_t) this->serviceId
-				<< ": performService returned with " << (int16_t) result
-				<< std::endl;
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle) {
-    this->taskHandle = taskHandle;
-}
-
-void PusServiceBase::handleRequestQueue() {
-	TmTcMessage message;
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
-		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
-//		if(status != MessageQueueIF::EMPTY) {
-//			sif::debug << "PusServiceBase::performOperation: Receiving from "
-//					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
-//					<< std::setfill('0') << this->requestQueue->getId()
-//					<< std::dec << " returned: " << status << std::setfill(' ')
-//					<<  std::endl;
-//		}
-
-		if (status == RETURN_OK) {
-			this->currentPacket.setStoreAddress(message.getStorageId());
-			//info << "Service " << (uint16_t) this->serviceId <<
-			//     ": new packet!" << std::endl;
-
-			result = this->handleRequest(currentPacket.getSubService());
-
-			// debug << "Service " << (uint16_t)this->serviceId <<
-			//    ": handleRequest returned: " << (int)return_code << std::endl;
-			if (result == RETURN_OK) {
-				this->verifyReporter.sendSuccessReport(
-						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
-			}
-			else {
-				this->verifyReporter.sendFailureReport(
-						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
-						result, 0, errorParameter1, errorParameter2);
-			}
-			this->currentPacket.deletePacket();
-			errorParameter1 = 0;
-			errorParameter2 = 0;
-		}
-		else if (status == MessageQueueIF::EMPTY) {
-			status = RETURN_OK;
-			// debug << "PusService " << (uint16_t)this->serviceId <<
-			//      ": no new packet." << std::endl;
-			break;
-		}
-		else {
-			sif::error << "PusServiceBase::performOperation: Service "
-					<< this->serviceId << ": Error receiving packet. Code: "
-					<< std::hex << status << std::dec << std::endl;
-		}
-	}
-}
-
-uint16_t PusServiceBase::getIdentifier() {
-	return this->serviceId;
-}
-
-MessageQueueId_t PusServiceBase::getRequestQueue() {
-	return this->requestQueue->getId();
-}
-
-ReturnValue_t PusServiceBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	AcceptsTelemetryIF* destService = objectManager->get<AcceptsTelemetryIF>(
-			packetDestination);
-	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
-			packetSource);
-	if (destService == nullptr or distributor == nullptr) {
-		sif::error << "PusServiceBase::PusServiceBase: Service "
-				<< this->serviceId << ": Configuration error. Make sure "
-				<<	"packetSource and packetDestination are defined correctly"
-				<< std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	this->requestQueue->setDefaultDestination(
-			destService->getReportReceptionQueue());
-	distributor->registerService(this);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
-    // If task parameters, for example task frequency are required, this
-    // function should be overriden and the system object task IF can
-    // be used to get those parameters.
-    return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../tmtcservices/PusServiceBase.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+
+object_id_t PusServiceBase::packetSource = 0;
+object_id_t PusServiceBase::packetDestination = 0;
+
+PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid,
+		uint8_t setServiceId) :
+		SystemObject(setObjectId), apid(setApid), serviceId(setServiceId) {
+	requestQueue = QueueFactory::instance()->
+			createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
+}
+
+PusServiceBase::~PusServiceBase() {
+	QueueFactory::instance()->deleteMessageQueue(requestQueue);
+}
+
+ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
+	handleRequestQueue();
+	ReturnValue_t result = this->performService();
+	if (result != RETURN_OK) {
+		sif::error << "PusService " << (uint16_t) this->serviceId
+				<< ": performService returned with " << (int16_t) result
+				<< std::endl;
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle) {
+    this->taskHandle = taskHandle;
+}
+
+void PusServiceBase::handleRequestQueue() {
+	TmTcMessage message;
+	ReturnValue_t result = RETURN_FAILED;
+	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
+		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
+//		if(status != MessageQueueIF::EMPTY) {
+//			sif::debug << "PusServiceBase::performOperation: Receiving from "
+//					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
+//					<< std::setfill('0') << this->requestQueue->getId()
+//					<< std::dec << " returned: " << status << std::setfill(' ')
+//					<<  std::endl;
+//		}
+
+		if (status == RETURN_OK) {
+			this->currentPacket.setStoreAddress(message.getStorageId());
+			//info << "Service " << (uint16_t) this->serviceId <<
+			//     ": new packet!" << std::endl;
+
+			result = this->handleRequest(currentPacket.getSubService());
+
+			// debug << "Service " << (uint16_t)this->serviceId <<
+			//    ": handleRequest returned: " << (int)return_code << std::endl;
+			if (result == RETURN_OK) {
+				this->verifyReporter.sendSuccessReport(
+						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
+			}
+			else {
+				this->verifyReporter.sendFailureReport(
+						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
+						result, 0, errorParameter1, errorParameter2);
+			}
+			this->currentPacket.deletePacket();
+			errorParameter1 = 0;
+			errorParameter2 = 0;
+		}
+		else if (status == MessageQueueIF::EMPTY) {
+			status = RETURN_OK;
+			// debug << "PusService " << (uint16_t)this->serviceId <<
+			//      ": no new packet." << std::endl;
+			break;
+		}
+		else {
+			sif::error << "PusServiceBase::performOperation: Service "
+					<< this->serviceId << ": Error receiving packet. Code: "
+					<< std::hex << status << std::dec << std::endl;
+		}
+	}
+}
+
+uint16_t PusServiceBase::getIdentifier() {
+	return this->serviceId;
+}
+
+MessageQueueId_t PusServiceBase::getRequestQueue() {
+	return this->requestQueue->getId();
+}
+
+ReturnValue_t PusServiceBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	AcceptsTelemetryIF* destService = objectManager->get<AcceptsTelemetryIF>(
+			packetDestination);
+	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
+			packetSource);
+	if (destService == nullptr or distributor == nullptr) {
+		sif::error << "PusServiceBase::PusServiceBase: Service "
+				<< this->serviceId << ": Configuration error. Make sure "
+				<<	"packetSource and packetDestination are defined correctly"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	this->requestQueue->setDefaultDestination(
+			destService->getReportReceptionQueue());
+	distributor->registerService(this);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
+    // If task parameters, for example task frequency are required, this
+    // function should be overriden and the system object task IF can
+    // be used to get those parameters.
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index f94312758..7c8f504c1 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -1,159 +1,159 @@
-#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../tmtcpacket/pus/TcPacketStored.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../tmtcservices/VerificationCodes.h"
-#include "../tmtcservices/VerificationReporter.h"
-#include "../ipc/MessageQueueIF.h"
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @defgroup pus_services PUS Service Framework
- * These group contains all implementations of PUS Services in the OBSW.
- * Most of the Services are directly taken from the ECSS PUS Standard.
- */
-
-/**
- * @brief 	This class is the basis for all PUS Services,
- * 			which can immediately process Telecommand Packets.
- * @details
- * It manages Telecommand reception and the generation of Verification Reports.
- * Every class that inherits from this abstract class has to implement
- * handleRequest and performService. Services that are created with this
- * Base class have to handle any kind of request immediately on reception.
- * All PUS Services are System Objects, so an Object ID needs to be specified
- * on construction.
- * @ingroup pus_services
- */
-class PusServiceBase : public ExecutableObjectIF,
-        public AcceptsTelecommandsIF,
-        public SystemObject,
-        public HasReturnvaluesIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	/**
-	 * @brief	The passed values are set, but inter-object initialization is
-	 * 			done in the initialize method.
-	 * @param setObjectId
-	 * The system object identifier of this Service instance.
-	 * @param setApid
-	 * The APID the Service is instantiated for.
-	 * @param setServiceId
-	 * The Service Identifier as specified in ECSS PUS.
-	 */
-	PusServiceBase(	object_id_t setObjectId, uint16_t setApid,
-			uint8_t setServiceId);
-	/**
-	 * The destructor is empty.
-	 */
-	virtual ~PusServiceBase();
-	/**
-	 * @brief 	The handleRequest method shall handle any kind of Telecommand
-	 * 			Request immediately.
-	 * @details
-	 * Implemetations can take the Telecommand in currentPacket and perform
-	 * any kind of operation.
-	 * They may send additional "Start Success (1,3)" messages with the
-	 * verifyReporter, but Completion Success or Failure Reports are generated
-	 * automatically after execution of this method.
-	 *
-	 * If a Telecommand can not be executed within one call cycle,
-	 * this Base class is not the right parent.
-	 *
-	 * The child class may add additional error information by setting
-	 * #errorParameters which aren attached to the generated verification
-	 * message.
-	 *
-	 * Subservice checking should be implemented in this method.
-	 *
-	 * @return	The returned status_code is directly taken as main error code
-	 * 			in the Verification Report.
-	 * 			On success, RETURN_OK shall be returned.
-	 */
-	virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
-	/**
-	 * In performService, implementations can handle periodic,
-	 * non-TC-triggered activities.
-	 * The performService method is always called.
-	 * @return	Currently, everything other that RETURN_OK only triggers
-	 * 			diagnostic output.
-	 */
-	virtual ReturnValue_t performService() = 0;
-	/**
-	 * This method implements the typical activity of a simple PUS Service.
-	 * It checks for new requests, and, if found, calls handleRequest, sends
-	 * completion verification messages and deletes
-	 * the TC requests afterwards.
-	 * performService is always executed afterwards.
-	 * @return	@c RETURN_OK if the periodic performService was successful.
-	 * 			@c RETURN_FAILED else.
-	 */
-	ReturnValue_t performOperation(uint8_t opCode) override;
-	virtual uint16_t getIdentifier() override;
-	MessageQueueId_t getRequestQueue() override;
-	virtual ReturnValue_t initialize() override;
-
-	virtual void setTaskIF(PeriodicTaskIF* taskHandle) override;
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
-protected:
-	/**
-	 * @brief   Handle to the underlying task
-	 * @details
-	 * Will be set by setTaskIF(), which is called on task creation.
-	 */
-	PeriodicTaskIF* taskHandle = nullptr;
-	/**
-	 * The APID of this instance of the Service.
-	 */
-	uint16_t apid;
-	/**
-	 * The Service Identifier.
-	 */
-	uint8_t serviceId;
-	/**
-	 * One of two error parameters for additional error information.
-	 */
-	uint32_t errorParameter1 = 0;
-	/**
-	 * One of two error parameters for additional error information.
-	 */
-	uint32_t errorParameter2 = 0;
-	/**
-	 * This is a complete instance of the telecommand reception queue
-	 * of the class. It is initialized on construction of the class.
-	 */
-	MessageQueueIF* requestQueue = nullptr;
-	/**
-	 * An instance of the VerificationReporter class, that simplifies
-	 * sending any kind of verification message to the TC Verification Service.
-	 */
-	VerificationReporter verifyReporter;
-	/**
-	 * The current Telecommand to be processed.
-	 * It is deleted after handleRequest was executed.
-	 */
-	TcPacketStored currentPacket;
-
-	static object_id_t packetSource;
-
-	static object_id_t packetDestination;
-private:
-	/**
-	 * This constant sets the maximum number of packets accepted per call.
-	 * Remember that one packet must be completely handled in one
-	 * #handleRequest call.
-	 */
-	static const uint8_t PUS_SERVICE_MAX_RECEPTION = 10;
-
-	void handleRequestQueue();
-};
-
-#endif /* PUSSERVICEBASE_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../tmtcservices/VerificationCodes.h"
+#include "../tmtcservices/VerificationReporter.h"
+#include "../ipc/MessageQueueIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @defgroup pus_services PUS Service Framework
+ * These group contains all implementations of PUS Services in the OBSW.
+ * Most of the Services are directly taken from the ECSS PUS Standard.
+ */
+
+/**
+ * @brief 	This class is the basis for all PUS Services,
+ * 			which can immediately process Telecommand Packets.
+ * @details
+ * It manages Telecommand reception and the generation of Verification Reports.
+ * Every class that inherits from this abstract class has to implement
+ * handleRequest and performService. Services that are created with this
+ * Base class have to handle any kind of request immediately on reception.
+ * All PUS Services are System Objects, so an Object ID needs to be specified
+ * on construction.
+ * @ingroup pus_services
+ */
+class PusServiceBase : public ExecutableObjectIF,
+        public AcceptsTelecommandsIF,
+        public SystemObject,
+        public HasReturnvaluesIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	/**
+	 * @brief	The passed values are set, but inter-object initialization is
+	 * 			done in the initialize method.
+	 * @param setObjectId
+	 * The system object identifier of this Service instance.
+	 * @param setApid
+	 * The APID the Service is instantiated for.
+	 * @param setServiceId
+	 * The Service Identifier as specified in ECSS PUS.
+	 */
+	PusServiceBase(	object_id_t setObjectId, uint16_t setApid,
+			uint8_t setServiceId);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~PusServiceBase();
+	/**
+	 * @brief 	The handleRequest method shall handle any kind of Telecommand
+	 * 			Request immediately.
+	 * @details
+	 * Implemetations can take the Telecommand in currentPacket and perform
+	 * any kind of operation.
+	 * They may send additional "Start Success (1,3)" messages with the
+	 * verifyReporter, but Completion Success or Failure Reports are generated
+	 * automatically after execution of this method.
+	 *
+	 * If a Telecommand can not be executed within one call cycle,
+	 * this Base class is not the right parent.
+	 *
+	 * The child class may add additional error information by setting
+	 * #errorParameters which aren attached to the generated verification
+	 * message.
+	 *
+	 * Subservice checking should be implemented in this method.
+	 *
+	 * @return	The returned status_code is directly taken as main error code
+	 * 			in the Verification Report.
+	 * 			On success, RETURN_OK shall be returned.
+	 */
+	virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
+	/**
+	 * In performService, implementations can handle periodic,
+	 * non-TC-triggered activities.
+	 * The performService method is always called.
+	 * @return	Currently, everything other that RETURN_OK only triggers
+	 * 			diagnostic output.
+	 */
+	virtual ReturnValue_t performService() = 0;
+	/**
+	 * This method implements the typical activity of a simple PUS Service.
+	 * It checks for new requests, and, if found, calls handleRequest, sends
+	 * completion verification messages and deletes
+	 * the TC requests afterwards.
+	 * performService is always executed afterwards.
+	 * @return	@c RETURN_OK if the periodic performService was successful.
+	 * 			@c RETURN_FAILED else.
+	 */
+	ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual uint16_t getIdentifier() override;
+	MessageQueueId_t getRequestQueue() override;
+	virtual ReturnValue_t initialize() override;
+
+	virtual void setTaskIF(PeriodicTaskIF* taskHandle) override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+protected:
+	/**
+	 * @brief   Handle to the underlying task
+	 * @details
+	 * Will be set by setTaskIF(), which is called on task creation.
+	 */
+	PeriodicTaskIF* taskHandle = nullptr;
+	/**
+	 * The APID of this instance of the Service.
+	 */
+	uint16_t apid;
+	/**
+	 * The Service Identifier.
+	 */
+	uint8_t serviceId;
+	/**
+	 * One of two error parameters for additional error information.
+	 */
+	uint32_t errorParameter1 = 0;
+	/**
+	 * One of two error parameters for additional error information.
+	 */
+	uint32_t errorParameter2 = 0;
+	/**
+	 * This is a complete instance of the telecommand reception queue
+	 * of the class. It is initialized on construction of the class.
+	 */
+	MessageQueueIF* requestQueue = nullptr;
+	/**
+	 * An instance of the VerificationReporter class, that simplifies
+	 * sending any kind of verification message to the TC Verification Service.
+	 */
+	VerificationReporter verifyReporter;
+	/**
+	 * The current Telecommand to be processed.
+	 * It is deleted after handleRequest was executed.
+	 */
+	TcPacketStored currentPacket;
+
+	static object_id_t packetSource;
+
+	static object_id_t packetDestination;
+private:
+	/**
+	 * This constant sets the maximum number of packets accepted per call.
+	 * Remember that one packet must be completely handled in one
+	 * #handleRequest call.
+	 */
+	static const uint8_t PUS_SERVICE_MAX_RECEPTION = 10;
+
+	void handleRequestQueue();
+};
+
+#endif /* PUSSERVICEBASE_H_ */
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index d83380a21..369519d8a 100644
--- a/tmtcservices/PusVerificationReport.cpp
+++ b/tmtcservices/PusVerificationReport.cpp
@@ -1,163 +1,163 @@
-#include "../serialize/SerializeAdapter.h"
-#include "../tmtcservices/PusVerificationReport.h"
-
-PusVerificationMessage::PusVerificationMessage() {
-}
-
-//PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
-//		TcPacketBase* current_packet, ReturnValue_t set_error_code,
-//		uint8_t set_step, uint32_t parameter1, uint32_t parameter2) {
-//	uint8_t ackFlags = current_packet->getAcknowledgeFlags();
-//	uint16_t tcPacketId = current_packet->getPacketId();
-//	uint16_t tcSequenceControl = current_packet->getPacketSequenceControl();
-//	uint8_t* data = this->getBuffer();
-//	data[messageSize] = set_report_id;
-//	messageSize += sizeof(set_report_id);
-//	data[messageSize] = ackFlags;
-//	messageSize += sizeof(ackFlags);
-//	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
-//	messageSize += sizeof(tcPacketId);
-//	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
-//	messageSize += sizeof(tcSequenceControl);
-//	data[messageSize] = set_step;
-//	messageSize += sizeof(set_step);
-//	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
-//	messageSize += sizeof(set_error_code);
-//	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
-//	messageSize += sizeof(parameter1);
-//	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
-//	messageSize += sizeof(parameter2);
-//}
-
-PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
-		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
-		uint32_t parameter2) {
-	uint8_t *data = this->getBuffer();
-	data[messageSize] = set_report_id;
-	messageSize += sizeof(set_report_id);
-	data[messageSize] = ackFlags;
-	messageSize += sizeof(ackFlags);
-	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
-	messageSize += sizeof(tcPacketId);
-	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
-	messageSize += sizeof(tcSequenceControl);
-	data[messageSize] = set_step;
-	messageSize += sizeof(set_step);
-	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
-	messageSize += sizeof(set_error_code);
-	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
-	messageSize += sizeof(parameter1);
-	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
-	messageSize += sizeof(parameter2);
-}
-
-uint8_t PusVerificationMessage::getReportId() {
-
-	return getContent()->reportId;
-}
-
-uint8_t PusVerificationMessage::getAckFlags() {
-
-	return getContent()->ackFlags;
-}
-
-uint16_t PusVerificationMessage::getTcPacketId() {
-
-	uint16_t tcPacketId;
-	memcpy(&tcPacketId, &getContent()->packetId_0, sizeof(tcPacketId));
-	return tcPacketId;
-}
-
-uint16_t PusVerificationMessage::getTcSequenceControl() {
-
-	uint16_t tcSequenceControl;
-	memcpy(&tcSequenceControl, &getContent()->tcSequenceControl_0,
-			sizeof(tcSequenceControl));
-	return tcSequenceControl;
-}
-
-uint8_t PusVerificationMessage::getStep() {
-
-	return getContent()->step;
-}
-
-ReturnValue_t PusVerificationMessage::getErrorCode() {
-	ReturnValue_t errorCode;
-	memcpy(&errorCode, &getContent()->error_code_0, sizeof(errorCode));
-	return errorCode;
-}
-
-PusVerificationMessage::verifciationMessageContent* PusVerificationMessage::getContent() {
-	return (verifciationMessageContent*) this->getData();
-}
-
-uint32_t PusVerificationMessage::getParameter1() {
-	uint32_t parameter;
-	memcpy(&parameter, &getContent()->parameter1_0, sizeof(parameter));
-	return parameter;
-}
-
-uint32_t PusVerificationMessage::getParameter2() {
-	uint32_t parameter;
-	memcpy(&parameter, &getContent()->parameter2_0, sizeof(parameter));
-	return parameter;
-}
-
-PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
-		uint16_t setSequenceControl, uint8_t setStep) :
-		reportSize(0), pBuffer(reportBuffer) {
-	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	if (setStep != 0) {
-		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	}
-}
-
-PusSuccessReport::~PusSuccessReport() {
-
-}
-
-uint32_t PusSuccessReport::getSize() {
-	return reportSize;
-}
-
-uint8_t* PusSuccessReport::getReport() {
-	return reportBuffer;
-}
-
-PusFailureReport::PusFailureReport(uint16_t setPacketId,
-		uint16_t setSequenceControl, ReturnValue_t setErrorCode,
-		uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
-		reportSize(0), pBuffer(reportBuffer) {
-	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	if (setStep != 0) {
-		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	}
-	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-}
-
-PusFailureReport::~PusFailureReport() {
-}
-
-size_t PusFailureReport::getSize() {
-	return reportSize;
-}
-
-uint8_t* PusFailureReport::getReport() {
-	return reportBuffer;
-}
+#include "../serialize/SerializeAdapter.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+PusVerificationMessage::PusVerificationMessage() {
+}
+
+//PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
+//		TcPacketBase* current_packet, ReturnValue_t set_error_code,
+//		uint8_t set_step, uint32_t parameter1, uint32_t parameter2) {
+//	uint8_t ackFlags = current_packet->getAcknowledgeFlags();
+//	uint16_t tcPacketId = current_packet->getPacketId();
+//	uint16_t tcSequenceControl = current_packet->getPacketSequenceControl();
+//	uint8_t* data = this->getBuffer();
+//	data[messageSize] = set_report_id;
+//	messageSize += sizeof(set_report_id);
+//	data[messageSize] = ackFlags;
+//	messageSize += sizeof(ackFlags);
+//	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
+//	messageSize += sizeof(tcPacketId);
+//	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
+//	messageSize += sizeof(tcSequenceControl);
+//	data[messageSize] = set_step;
+//	messageSize += sizeof(set_step);
+//	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
+//	messageSize += sizeof(set_error_code);
+//	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
+//	messageSize += sizeof(parameter1);
+//	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
+//	messageSize += sizeof(parameter2);
+//}
+
+PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
+		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
+		uint32_t parameter2) {
+	uint8_t *data = this->getBuffer();
+	data[messageSize] = set_report_id;
+	messageSize += sizeof(set_report_id);
+	data[messageSize] = ackFlags;
+	messageSize += sizeof(ackFlags);
+	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
+	messageSize += sizeof(tcPacketId);
+	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
+	messageSize += sizeof(tcSequenceControl);
+	data[messageSize] = set_step;
+	messageSize += sizeof(set_step);
+	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
+	messageSize += sizeof(set_error_code);
+	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
+	messageSize += sizeof(parameter1);
+	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
+	messageSize += sizeof(parameter2);
+}
+
+uint8_t PusVerificationMessage::getReportId() {
+
+	return getContent()->reportId;
+}
+
+uint8_t PusVerificationMessage::getAckFlags() {
+
+	return getContent()->ackFlags;
+}
+
+uint16_t PusVerificationMessage::getTcPacketId() {
+
+	uint16_t tcPacketId;
+	memcpy(&tcPacketId, &getContent()->packetId_0, sizeof(tcPacketId));
+	return tcPacketId;
+}
+
+uint16_t PusVerificationMessage::getTcSequenceControl() {
+
+	uint16_t tcSequenceControl;
+	memcpy(&tcSequenceControl, &getContent()->tcSequenceControl_0,
+			sizeof(tcSequenceControl));
+	return tcSequenceControl;
+}
+
+uint8_t PusVerificationMessage::getStep() {
+
+	return getContent()->step;
+}
+
+ReturnValue_t PusVerificationMessage::getErrorCode() {
+	ReturnValue_t errorCode;
+	memcpy(&errorCode, &getContent()->error_code_0, sizeof(errorCode));
+	return errorCode;
+}
+
+PusVerificationMessage::verifciationMessageContent* PusVerificationMessage::getContent() {
+	return (verifciationMessageContent*) this->getData();
+}
+
+uint32_t PusVerificationMessage::getParameter1() {
+	uint32_t parameter;
+	memcpy(&parameter, &getContent()->parameter1_0, sizeof(parameter));
+	return parameter;
+}
+
+uint32_t PusVerificationMessage::getParameter2() {
+	uint32_t parameter;
+	memcpy(&parameter, &getContent()->parameter2_0, sizeof(parameter));
+	return parameter;
+}
+
+PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
+		uint16_t setSequenceControl, uint8_t setStep) :
+		reportSize(0), pBuffer(reportBuffer) {
+	//Serialization won't fail, because we know the necessary max-size of the buffer.
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	if (setStep != 0) {
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	}
+}
+
+PusSuccessReport::~PusSuccessReport() {
+
+}
+
+uint32_t PusSuccessReport::getSize() {
+	return reportSize;
+}
+
+uint8_t* PusSuccessReport::getReport() {
+	return reportBuffer;
+}
+
+PusFailureReport::PusFailureReport(uint16_t setPacketId,
+		uint16_t setSequenceControl, ReturnValue_t setErrorCode,
+		uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
+		reportSize(0), pBuffer(reportBuffer) {
+	//Serialization won't fail, because we know the necessary max-size of the buffer.
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	if (setStep != 0) {
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	}
+	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+}
+
+PusFailureReport::~PusFailureReport() {
+}
+
+size_t PusFailureReport::getSize() {
+	return reportSize;
+}
+
+uint8_t* PusFailureReport::getReport() {
+	return reportBuffer;
+}
diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h
index 26a1eaedc..c0a467585 100644
--- a/tmtcservices/PusVerificationReport.h
+++ b/tmtcservices/PusVerificationReport.h
@@ -1,77 +1,77 @@
-#ifndef PUSVERIFICATIONREPORT_H_
-#define PUSVERIFICATIONREPORT_H_
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../tmtcpacket/pus/TcPacketBase.h"
-#include "../tmtcservices/VerificationCodes.h"
-
-class PusVerificationMessage: public MessageQueueMessage {
-private:
-	struct verifciationMessageContent {
-		uint8_t reportId;
-		uint8_t ackFlags;
-		uint8_t packetId_0;
-		uint8_t packetId_1;
-		uint8_t tcSequenceControl_0;
-		uint8_t tcSequenceControl_1;
-		uint8_t step;
-		uint8_t error_code_0;
-		uint8_t error_code_1;
-		uint8_t parameter1_0;
-		uint8_t parameter1_1;
-		uint8_t parameter1_2;
-		uint8_t parameter1_3;
-		uint8_t parameter2_0;
-		uint8_t parameter2_1;
-		uint8_t parameter2_2;
-		uint8_t parameter2_3;
-	};
-	verifciationMessageContent* getContent();
-public:
-	static const uint8_t VERIFICATION_MIN_SIZE = 6;
-	PusVerificationMessage();
-//	PusVerificationMessage( uint8_t set_report_id, TcPacketBase* current_packet, ReturnValue_t set_error_code = 0, uint8_t set_step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
-	PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags,
-			uint16_t tcPacketId, uint16_t tcSequenceControl,
-			ReturnValue_t set_error_code = 0, uint8_t set_step = 0,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-	uint8_t getReportId();
-	uint8_t getAckFlags();
-	uint16_t getTcPacketId();
-	uint16_t getTcSequenceControl();
-	ReturnValue_t getErrorCode();
-	uint8_t getStep();
-	uint32_t getParameter1();
-	uint32_t getParameter2();
-};
-
-class PusSuccessReport {
-private:
-	static const uint16_t MAX_SIZE = 7;
-	uint8_t reportBuffer[MAX_SIZE];
-	size_t reportSize;
-	uint8_t * pBuffer;
-public:
-	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
-			uint8_t set_step = 0);
-	~PusSuccessReport();
-	uint32_t getSize();
-	uint8_t* getReport();
-};
-
-class PusFailureReport {
-private:
-	static const uint16_t MAX_SIZE = 16;
-	uint8_t reportBuffer[MAX_SIZE];
-	size_t reportSize;
-	uint8_t * pBuffer;
-public:
-	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
-			ReturnValue_t setErrorCode, uint8_t setStep = 0,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-	~PusFailureReport();
-	size_t getSize();
-	uint8_t* getReport();
-};
-
-#endif /* PUSVERIFICATIONREPORT_H_ */
+#ifndef PUSVERIFICATIONREPORT_H_
+#define PUSVERIFICATIONREPORT_H_
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../tmtcpacket/pus/TcPacketBase.h"
+#include "../tmtcservices/VerificationCodes.h"
+
+class PusVerificationMessage: public MessageQueueMessage {
+private:
+	struct verifciationMessageContent {
+		uint8_t reportId;
+		uint8_t ackFlags;
+		uint8_t packetId_0;
+		uint8_t packetId_1;
+		uint8_t tcSequenceControl_0;
+		uint8_t tcSequenceControl_1;
+		uint8_t step;
+		uint8_t error_code_0;
+		uint8_t error_code_1;
+		uint8_t parameter1_0;
+		uint8_t parameter1_1;
+		uint8_t parameter1_2;
+		uint8_t parameter1_3;
+		uint8_t parameter2_0;
+		uint8_t parameter2_1;
+		uint8_t parameter2_2;
+		uint8_t parameter2_3;
+	};
+	verifciationMessageContent* getContent();
+public:
+	static const uint8_t VERIFICATION_MIN_SIZE = 6;
+	PusVerificationMessage();
+//	PusVerificationMessage( uint8_t set_report_id, TcPacketBase* current_packet, ReturnValue_t set_error_code = 0, uint8_t set_step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
+	PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags,
+			uint16_t tcPacketId, uint16_t tcSequenceControl,
+			ReturnValue_t set_error_code = 0, uint8_t set_step = 0,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+	uint8_t getReportId();
+	uint8_t getAckFlags();
+	uint16_t getTcPacketId();
+	uint16_t getTcSequenceControl();
+	ReturnValue_t getErrorCode();
+	uint8_t getStep();
+	uint32_t getParameter1();
+	uint32_t getParameter2();
+};
+
+class PusSuccessReport {
+private:
+	static const uint16_t MAX_SIZE = 7;
+	uint8_t reportBuffer[MAX_SIZE];
+	size_t reportSize;
+	uint8_t * pBuffer;
+public:
+	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
+			uint8_t set_step = 0);
+	~PusSuccessReport();
+	uint32_t getSize();
+	uint8_t* getReport();
+};
+
+class PusFailureReport {
+private:
+	static const uint16_t MAX_SIZE = 16;
+	uint8_t reportBuffer[MAX_SIZE];
+	size_t reportSize;
+	uint8_t * pBuffer;
+public:
+	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
+			ReturnValue_t setErrorCode, uint8_t setStep = 0,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+	~PusFailureReport();
+	size_t getSize();
+	uint8_t* getReport();
+};
+
+#endif /* PUSVERIFICATIONREPORT_H_ */
diff --git a/tmtcservices/SourceSequenceCounter.h b/tmtcservices/SourceSequenceCounter.h
index 0db533808..1cc587587 100644
--- a/tmtcservices/SourceSequenceCounter.h
+++ b/tmtcservices/SourceSequenceCounter.h
@@ -1,30 +1,30 @@
-/**
- * @file	SourceSequenceCounter.h
- * @brief	This file defines the SourceSequenceCounter class.
- * @date	04.02.2013
- * @author	baetz
- */
-
-#ifndef SOURCESEQUENCECOUNTER_H_
-#define SOURCESEQUENCECOUNTER_H_
-#include "../tmtcpacket/SpacePacketBase.h"
-
-class SourceSequenceCounter {
-private:
-	uint16_t sequenceCount;
-public:
-	SourceSequenceCounter() : sequenceCount(0) {}
-	void increment() {
-		sequenceCount = (sequenceCount+1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
-	}
-	void decrement() {
-		sequenceCount = (sequenceCount-1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
-	}
-	uint16_t get() { return this->sequenceCount; }
-	void reset(uint16_t toValue = 0) {
-		sequenceCount = toValue % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
-	}
-};
-
-
-#endif /* SOURCESEQUENCECOUNTER_H_ */
+/**
+ * @file	SourceSequenceCounter.h
+ * @brief	This file defines the SourceSequenceCounter class.
+ * @date	04.02.2013
+ * @author	baetz
+ */
+
+#ifndef SOURCESEQUENCECOUNTER_H_
+#define SOURCESEQUENCECOUNTER_H_
+#include "../tmtcpacket/SpacePacketBase.h"
+
+class SourceSequenceCounter {
+private:
+	uint16_t sequenceCount;
+public:
+	SourceSequenceCounter() : sequenceCount(0) {}
+	void increment() {
+		sequenceCount = (sequenceCount+1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+	}
+	void decrement() {
+		sequenceCount = (sequenceCount-1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+	}
+	uint16_t get() { return this->sequenceCount; }
+	void reset(uint16_t toValue = 0) {
+		sequenceCount = toValue % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+	}
+};
+
+
+#endif /* SOURCESEQUENCECOUNTER_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 706bbbf2e..8c2f15e5b 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -1,237 +1,237 @@
-#include "../tmtcservices/TmTcBridge.h"
-
-#include "../ipc/QueueFactory.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../globalfunctions/arrayprinter.h"
-
-TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
-		object_id_t tmStoreId, object_id_t tcStoreId):
-		SystemObject(objectId),tmStoreId(tmStoreId), tcStoreId(tcStoreId),
-		tcDestination(tcDestination)
-
-{
-    tmTcReceptionQueue = QueueFactory::instance()->
-            createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
-}
-
-TmTcBridge::~TmTcBridge() {}
-
-ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
-		uint8_t sentPacketsPerCycle) {
-	if(sentPacketsPerCycle <= LIMIT_STORED_DATA_SENT_PER_CYCLE) {
-		this->sentPacketsPerCycle = sentPacketsPerCycle;
-		return RETURN_OK;
-	}
-	else {
-	    sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of "
-	             << "packets sent per cycle exceeds limits. "
-	             << "Keeping default value." << std::endl;
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
-        uint8_t maxNumberOfPacketsStored) {
-    if(maxNumberOfPacketsStored <= LIMIT_DOWNLINK_PACKETS_STORED) {
-        this->maxNumberOfPacketsStored = maxNumberOfPacketsStored;
-        return RETURN_OK;
-    }
-    else {
-        sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of "
-                << "packets stored exceeds limits. "
-                << "Keeping default value." << std::endl;
-        return RETURN_FAILED;
-    }
-}
-
-ReturnValue_t TmTcBridge::initialize() {
-	tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
-	if (tcStore == nullptr) {
-		sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
-				"it is created and set up properly." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
-	if (tmStore == nullptr) {
-		sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
-				"it is created and set up properly." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	AcceptsTelecommandsIF* tcDistributor =
-			objectManager->get<AcceptsTelecommandsIF>(tcDestination);
-	if (tcDistributor == nullptr) {
-		sif::error << "TmTcBridge::initialize: TC Distributor invalid"
-				<< std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	tmFifo = new DynamicFIFO<store_address_t>(maxNumberOfPacketsStored);
-
-	tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
-	return RETURN_OK;
-}
-
-ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
-	ReturnValue_t result;
-	result = handleTc();
-	if(result != RETURN_OK) {
-		sif::debug << "TmTcBridge::performOperation: "
-		        << "Error handling TCs" << std::endl;
-	}
-	result = handleTm();
-	if (result != RETURN_OK) {
-	    sif::debug << "TmTcBridge::performOperation: "
-	                    << "Error handling TMs" << std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t TmTcBridge::handleTc() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TmTcBridge::handleTm() {
-    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-	ReturnValue_t result = handleTmQueue();
-	if(result != RETURN_OK) {
-		sif::error << "TmTcBridge::handleTm: Error handling TM queue!"
-		        << std::endl;
-		status = result;
-	}
-
-	if(tmStored and communicationLinkUp and
-	        (packetSentCounter < sentPacketsPerCycle)) {
-	    result = handleStoredTm();
-	    if(result != RETURN_OK) {
-	        sif::error << "TmTcBridge::handleTm: Error handling stored TMs!"
-	                << std::endl;
-	        status = result;
-	    }
-	}
-	packetSentCounter = 0;
-	return status;
-}
-
-ReturnValue_t TmTcBridge::handleTmQueue() {
-	TmTcMessage message;
-	const uint8_t* data = nullptr;
-	size_t size = 0;
-	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
-		 result == HasReturnvaluesIF::RETURN_OK;
-		 result = tmTcReceptionQueue->receiveMessage(&message))
-	{
-	    //sif::info << (int) packetSentCounter << std::endl;
-		if(communicationLinkUp == false or
-		        packetSentCounter >= sentPacketsPerCycle) {
-			storeDownlinkData(&message);
-			continue;
-		}
-
-		result = tmStore->getData(message.getStorageId(), &data, &size);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			status = result;
-			continue;
-		}
-
-		result = sendTm(data, size);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			status = result;
-		}
-		else {
-		    tmStore->deleteData(message.getStorageId());
-		    packetSentCounter++;
-		}
-	}
-	return status;
-}
-
-ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
-	store_address_t storeId = 0;
-
-	if(tmFifo->full()) {
-	    sif::debug << "TmTcBridge::storeDownlinkData: TM downlink max. number "
-	                    << "of stored packet IDs reached! " << std::endl;
-	    if(overwriteOld) {
-	        tmFifo->retrieve(&storeId);
-	        tmStore->deleteData(storeId);
-	    }
-	    else {
-	        return HasReturnvaluesIF::RETURN_FAILED;
-	    }
-	}
-
-	storeId = message->getStorageId();
-	tmFifo->insert(storeId);
-	tmStored = true;
-	return RETURN_OK;
-}
-
-ReturnValue_t TmTcBridge::handleStoredTm() {
-    ReturnValue_t status = RETURN_OK;
-	while(not tmFifo->empty() and packetSentCounter < sentPacketsPerCycle) {
-		//sif::info << "TMTC Bridge: Sending stored TM data. There are "
-		//     << (int) tmFifo->size() << " left to send\r\n" << std::flush;
-
-		store_address_t storeId;
-		const uint8_t* data = nullptr;
-		size_t size = 0;
-		tmFifo->retrieve(&storeId);
-		ReturnValue_t result = tmStore->getData(storeId, &data, &size);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-		    status = result;
-		}
-
-		result = sendTm(data,size);
-		if(result != RETURN_OK) {
-			sif::error << "TMTC Bridge: Could not send stored downlink data"
-			      << std::endl;
-			status = result;
-		}
-		packetSentCounter ++;
-
-		if(tmFifo->empty()) {
-			tmStored = false;
-		}
-		tmStore->deleteData(storeId);
-	}
-	return status;
-}
-
-void TmTcBridge::registerCommConnect() {
-	if(not communicationLinkUp) {
-		//sif::info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
-		communicationLinkUp = true;
-	}
-}
-
-void TmTcBridge::registerCommDisconnect() {
-	//sif::info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
-	if(communicationLinkUp) {
-		communicationLinkUp = false;
-	}
-}
-
-MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
-	return tmTcReceptionQueue->getId();
-}
-
-
-void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
-	arrayprinter::print(data, dataLen);
-}
-
-uint16_t TmTcBridge::getIdentifier() {
-	// This is no PUS service, so we just return 0
-	return 0;
-}
-
-MessageQueueId_t TmTcBridge::getRequestQueue() {
-	// Default implementation: Relay TC messages to TC distributor directly.
-	return tmTcReceptionQueue->getDefaultDestination();
-}
-
-void TmTcBridge::setFifoToOverwriteOldData(bool overwriteOld) {
-    this->overwriteOld = overwriteOld;
-}
+#include "../tmtcservices/TmTcBridge.h"
+
+#include "../ipc/QueueFactory.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../globalfunctions/arrayprinter.h"
+
+TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
+		object_id_t tmStoreId, object_id_t tcStoreId):
+		SystemObject(objectId),tmStoreId(tmStoreId), tcStoreId(tcStoreId),
+		tcDestination(tcDestination)
+
+{
+    tmTcReceptionQueue = QueueFactory::instance()->
+            createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
+}
+
+TmTcBridge::~TmTcBridge() {}
+
+ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
+		uint8_t sentPacketsPerCycle) {
+	if(sentPacketsPerCycle <= LIMIT_STORED_DATA_SENT_PER_CYCLE) {
+		this->sentPacketsPerCycle = sentPacketsPerCycle;
+		return RETURN_OK;
+	}
+	else {
+	    sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of "
+	             << "packets sent per cycle exceeds limits. "
+	             << "Keeping default value." << std::endl;
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
+        uint8_t maxNumberOfPacketsStored) {
+    if(maxNumberOfPacketsStored <= LIMIT_DOWNLINK_PACKETS_STORED) {
+        this->maxNumberOfPacketsStored = maxNumberOfPacketsStored;
+        return RETURN_OK;
+    }
+    else {
+        sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of "
+                << "packets stored exceeds limits. "
+                << "Keeping default value." << std::endl;
+        return RETURN_FAILED;
+    }
+}
+
+ReturnValue_t TmTcBridge::initialize() {
+	tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
+	if (tcStore == nullptr) {
+		sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
+				"it is created and set up properly." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
+	if (tmStore == nullptr) {
+		sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
+				"it is created and set up properly." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	AcceptsTelecommandsIF* tcDistributor =
+			objectManager->get<AcceptsTelecommandsIF>(tcDestination);
+	if (tcDistributor == nullptr) {
+		sif::error << "TmTcBridge::initialize: TC Distributor invalid"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	tmFifo = new DynamicFIFO<store_address_t>(maxNumberOfPacketsStored);
+
+	tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
+	return RETURN_OK;
+}
+
+ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
+	ReturnValue_t result;
+	result = handleTc();
+	if(result != RETURN_OK) {
+		sif::debug << "TmTcBridge::performOperation: "
+		        << "Error handling TCs" << std::endl;
+	}
+	result = handleTm();
+	if (result != RETURN_OK) {
+	    sif::debug << "TmTcBridge::performOperation: "
+	                    << "Error handling TMs" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t TmTcBridge::handleTc() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmTcBridge::handleTm() {
+    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+	ReturnValue_t result = handleTmQueue();
+	if(result != RETURN_OK) {
+		sif::error << "TmTcBridge::handleTm: Error handling TM queue!"
+		        << std::endl;
+		status = result;
+	}
+
+	if(tmStored and communicationLinkUp and
+	        (packetSentCounter < sentPacketsPerCycle)) {
+	    result = handleStoredTm();
+	    if(result != RETURN_OK) {
+	        sif::error << "TmTcBridge::handleTm: Error handling stored TMs!"
+	                << std::endl;
+	        status = result;
+	    }
+	}
+	packetSentCounter = 0;
+	return status;
+}
+
+ReturnValue_t TmTcBridge::handleTmQueue() {
+	TmTcMessage message;
+	const uint8_t* data = nullptr;
+	size_t size = 0;
+	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
+		 result == HasReturnvaluesIF::RETURN_OK;
+		 result = tmTcReceptionQueue->receiveMessage(&message))
+	{
+	    //sif::info << (int) packetSentCounter << std::endl;
+		if(communicationLinkUp == false or
+		        packetSentCounter >= sentPacketsPerCycle) {
+			storeDownlinkData(&message);
+			continue;
+		}
+
+		result = tmStore->getData(message.getStorageId(), &data, &size);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+			continue;
+		}
+
+		result = sendTm(data, size);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+		else {
+		    tmStore->deleteData(message.getStorageId());
+		    packetSentCounter++;
+		}
+	}
+	return status;
+}
+
+ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
+	store_address_t storeId = 0;
+
+	if(tmFifo->full()) {
+	    sif::debug << "TmTcBridge::storeDownlinkData: TM downlink max. number "
+	                    << "of stored packet IDs reached! " << std::endl;
+	    if(overwriteOld) {
+	        tmFifo->retrieve(&storeId);
+	        tmStore->deleteData(storeId);
+	    }
+	    else {
+	        return HasReturnvaluesIF::RETURN_FAILED;
+	    }
+	}
+
+	storeId = message->getStorageId();
+	tmFifo->insert(storeId);
+	tmStored = true;
+	return RETURN_OK;
+}
+
+ReturnValue_t TmTcBridge::handleStoredTm() {
+    ReturnValue_t status = RETURN_OK;
+	while(not tmFifo->empty() and packetSentCounter < sentPacketsPerCycle) {
+		//sif::info << "TMTC Bridge: Sending stored TM data. There are "
+		//     << (int) tmFifo->size() << " left to send\r\n" << std::flush;
+
+		store_address_t storeId;
+		const uint8_t* data = nullptr;
+		size_t size = 0;
+		tmFifo->retrieve(&storeId);
+		ReturnValue_t result = tmStore->getData(storeId, &data, &size);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+		    status = result;
+		}
+
+		result = sendTm(data,size);
+		if(result != RETURN_OK) {
+			sif::error << "TMTC Bridge: Could not send stored downlink data"
+			      << std::endl;
+			status = result;
+		}
+		packetSentCounter ++;
+
+		if(tmFifo->empty()) {
+			tmStored = false;
+		}
+		tmStore->deleteData(storeId);
+	}
+	return status;
+}
+
+void TmTcBridge::registerCommConnect() {
+	if(not communicationLinkUp) {
+		//sif::info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
+		communicationLinkUp = true;
+	}
+}
+
+void TmTcBridge::registerCommDisconnect() {
+	//sif::info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
+	if(communicationLinkUp) {
+		communicationLinkUp = false;
+	}
+}
+
+MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
+	return tmTcReceptionQueue->getId();
+}
+
+
+void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
+	arrayprinter::print(data, dataLen);
+}
+
+uint16_t TmTcBridge::getIdentifier() {
+	// This is no PUS service, so we just return 0
+	return 0;
+}
+
+MessageQueueId_t TmTcBridge::getRequestQueue() {
+	// Default implementation: Relay TC messages to TC distributor directly.
+	return tmTcReceptionQueue->getDefaultDestination();
+}
+
+void TmTcBridge::setFifoToOverwriteOldData(bool overwriteOld) {
+    this->overwriteOld = overwriteOld;
+}
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 763980dc6..62cfdaac6 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,162 +1,162 @@
-#ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
-#define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
-
-
-#include "../objectmanager/SystemObject.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../container/DynamicFIFO.h"
-#include "../tmtcservices/TmTcMessage.h"
-
-class TmTcBridge : public AcceptsTelemetryIF,
-		public AcceptsTelecommandsIF,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF,
-		public SystemObject {
-public:
-	static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
-	static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15;
-	static constexpr uint8_t LIMIT_DOWNLINK_PACKETS_STORED = 20;
-
-	static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
-	static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
-
-	TmTcBridge(object_id_t objectId, object_id_t tcDestination,
-			object_id_t tmStoreId, object_id_t tcStoreId);
-	virtual ~TmTcBridge();
-
-	/**
-	 * Set number of packets sent per performOperation().Please note that this
-	 * value must be smaller than MAX_STORED_DATA_SENT_PER_CYCLE
-	 * @param sentPacketsPerCycle
-	 * @return -@c RETURN_OK if value was set successfully
-	 * 		   -@c RETURN_FAILED otherwise, stored value stays the same
-	 */
-	ReturnValue_t setNumberOfSentPacketsPerCycle(uint8_t sentPacketsPerCycle);
-
-	/**
-	 * Set number of packets sent per performOperation().Please note that this
-	 * value must be smaller than MAX_DOWNLINK_PACKETS_STORED
-	 * @param sentPacketsPerCycle
-	 * @return -@c RETURN_OK if value was set successfully
-	 *         -@c RETURN_FAILED otherwise, stored value stays the same
-	 */
-	ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
-
-	/**
-	 * This will set up the bridge to overwrite old data in the FIFO.
-	 * @param overwriteOld
-	 */
-	void setFifoToOverwriteOldData(bool overwriteOld);
-
-	virtual void registerCommConnect();
-	virtual void registerCommDisconnect();
-
-	/**
-	 * Initializes necessary FSFW components for the TMTC Bridge
-	 * @return
-	 */
-	virtual ReturnValue_t initialize() override;
-
-	/**
-	 * @brief	Handles TMTC reception
-	 */
-	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
-
-
-	/** AcceptsTelemetryIF override */
-	virtual MessageQueueId_t getReportReceptionQueue(
-			uint8_t virtualChannel = 0) override;
-
-	/** AcceptsTelecommandsIF override */
-	virtual uint16_t getIdentifier() override;
-	virtual MessageQueueId_t getRequestQueue() override;
-
-protected:
-	//! Cached for initialize function.
-	object_id_t tmStoreId = objects::NO_OBJECT;
-	object_id_t tcStoreId = objects::NO_OBJECT;
-	object_id_t tcDestination = objects::NO_OBJECT;
-
-	//! Used to send and receive TMTC messages.
-	//! The TmTcMessage class is used to transport messages between tasks.
-	MessageQueueIF* tmTcReceptionQueue = nullptr;
-
-	StorageManagerIF* tmStore = nullptr;
-	StorageManagerIF* tcStore = nullptr;
-
-	//! Used to specify whether communication link is up. Will be true
-	//! by default, so telemetry will be handled immediately.
-	bool communicationLinkUp = true;
-	bool tmStored = false;
-	bool overwriteOld = true;
-	uint8_t packetSentCounter = 0;
-
-	/**
-	 * @brief 	Handle TC reception
-	 * @details
-	 * Default implementation provided, but is empty.
-	 * In most cases, TC reception will be handled in a separate task anyway.
-	 * @return
-	 */
-	virtual ReturnValue_t handleTc();
-
-	/**
-	 * Handle Telemetry. Default implementation provided.
-	 * Calls sendTm()
-	 * @return
-	 */
-	virtual ReturnValue_t handleTm();
-
-	/**
-	 * Read the TM Queue and send TM if necessary.
-	 * Default implementation provided
-	 * @return
-	 */
-	virtual ReturnValue_t handleTmQueue();
-
-	/**
-	 * Send stored data if communication link is active
-	 * @return
-	 */
-	virtual ReturnValue_t handleStoredTm();
-
-	/**
-	 * Implemented by child class. Perform sending of Telemetry by implementing
-	 * communication drivers or wrappers, e.g. serial communication or a socket
-	 * call.
-	 * @param data
-	 * @param dataLen
-	 * @return
-	 */
-	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) = 0;
-
-	/**
-	 * Store data to be sent later if communication link is not up.
-	 * @param message
-	 * @return
-	 */
-	virtual ReturnValue_t storeDownlinkData(TmTcMessage * message);
-
-
-	/**
-	 * Print data as hexidecimal array
-	 * @param data
-	 * @param dataLen
-	 */
-	void printData(uint8_t * data, size_t dataLen);
-
-	/**
-	 * This fifo can be used to store downlink data
-	 * which can not be sent at the moment.
-	 */
-	DynamicFIFO<store_address_t>* tmFifo = nullptr;
-    uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
-    uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
-};
-
-
-#endif /* FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
+#define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
+
+
+#include "../objectmanager/SystemObject.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../container/DynamicFIFO.h"
+#include "../tmtcservices/TmTcMessage.h"
+
+class TmTcBridge : public AcceptsTelemetryIF,
+		public AcceptsTelecommandsIF,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF,
+		public SystemObject {
+public:
+	static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
+	static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15;
+	static constexpr uint8_t LIMIT_DOWNLINK_PACKETS_STORED = 20;
+
+	static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
+	static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
+
+	TmTcBridge(object_id_t objectId, object_id_t tcDestination,
+			object_id_t tmStoreId, object_id_t tcStoreId);
+	virtual ~TmTcBridge();
+
+	/**
+	 * Set number of packets sent per performOperation().Please note that this
+	 * value must be smaller than MAX_STORED_DATA_SENT_PER_CYCLE
+	 * @param sentPacketsPerCycle
+	 * @return -@c RETURN_OK if value was set successfully
+	 * 		   -@c RETURN_FAILED otherwise, stored value stays the same
+	 */
+	ReturnValue_t setNumberOfSentPacketsPerCycle(uint8_t sentPacketsPerCycle);
+
+	/**
+	 * Set number of packets sent per performOperation().Please note that this
+	 * value must be smaller than MAX_DOWNLINK_PACKETS_STORED
+	 * @param sentPacketsPerCycle
+	 * @return -@c RETURN_OK if value was set successfully
+	 *         -@c RETURN_FAILED otherwise, stored value stays the same
+	 */
+	ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
+
+	/**
+	 * This will set up the bridge to overwrite old data in the FIFO.
+	 * @param overwriteOld
+	 */
+	void setFifoToOverwriteOldData(bool overwriteOld);
+
+	virtual void registerCommConnect();
+	virtual void registerCommDisconnect();
+
+	/**
+	 * Initializes necessary FSFW components for the TMTC Bridge
+	 * @return
+	 */
+	virtual ReturnValue_t initialize() override;
+
+	/**
+	 * @brief	Handles TMTC reception
+	 */
+	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+
+	/** AcceptsTelemetryIF override */
+	virtual MessageQueueId_t getReportReceptionQueue(
+			uint8_t virtualChannel = 0) override;
+
+	/** AcceptsTelecommandsIF override */
+	virtual uint16_t getIdentifier() override;
+	virtual MessageQueueId_t getRequestQueue() override;
+
+protected:
+	//! Cached for initialize function.
+	object_id_t tmStoreId = objects::NO_OBJECT;
+	object_id_t tcStoreId = objects::NO_OBJECT;
+	object_id_t tcDestination = objects::NO_OBJECT;
+
+	//! Used to send and receive TMTC messages.
+	//! The TmTcMessage class is used to transport messages between tasks.
+	MessageQueueIF* tmTcReceptionQueue = nullptr;
+
+	StorageManagerIF* tmStore = nullptr;
+	StorageManagerIF* tcStore = nullptr;
+
+	//! Used to specify whether communication link is up. Will be true
+	//! by default, so telemetry will be handled immediately.
+	bool communicationLinkUp = true;
+	bool tmStored = false;
+	bool overwriteOld = true;
+	uint8_t packetSentCounter = 0;
+
+	/**
+	 * @brief 	Handle TC reception
+	 * @details
+	 * Default implementation provided, but is empty.
+	 * In most cases, TC reception will be handled in a separate task anyway.
+	 * @return
+	 */
+	virtual ReturnValue_t handleTc();
+
+	/**
+	 * Handle Telemetry. Default implementation provided.
+	 * Calls sendTm()
+	 * @return
+	 */
+	virtual ReturnValue_t handleTm();
+
+	/**
+	 * Read the TM Queue and send TM if necessary.
+	 * Default implementation provided
+	 * @return
+	 */
+	virtual ReturnValue_t handleTmQueue();
+
+	/**
+	 * Send stored data if communication link is active
+	 * @return
+	 */
+	virtual ReturnValue_t handleStoredTm();
+
+	/**
+	 * Implemented by child class. Perform sending of Telemetry by implementing
+	 * communication drivers or wrappers, e.g. serial communication or a socket
+	 * call.
+	 * @param data
+	 * @param dataLen
+	 * @return
+	 */
+	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) = 0;
+
+	/**
+	 * Store data to be sent later if communication link is not up.
+	 * @param message
+	 * @return
+	 */
+	virtual ReturnValue_t storeDownlinkData(TmTcMessage * message);
+
+
+	/**
+	 * Print data as hexidecimal array
+	 * @param data
+	 * @param dataLen
+	 */
+	void printData(uint8_t * data, size_t dataLen);
+
+	/**
+	 * This fifo can be used to store downlink data
+	 * which can not be sent at the moment.
+	 */
+	DynamicFIFO<store_address_t>* tmFifo = nullptr;
+    uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
+    uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
+};
+
+
+#endif /* FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ */
diff --git a/tmtcservices/TmTcMessage.cpp b/tmtcservices/TmTcMessage.cpp
index 0fe3229c0..a715225b4 100644
--- a/tmtcservices/TmTcMessage.cpp
+++ b/tmtcservices/TmTcMessage.cpp
@@ -1,29 +1,29 @@
-#include "../tmtcservices/TmTcMessage.h"
-#include <string.h>
-
-
-TmTcMessage::TmTcMessage() {
-	this->messageSize += sizeof(store_address_t);
-}
-
-TmTcMessage::~TmTcMessage() {
-}
-
-store_address_t TmTcMessage::getStorageId() {
-	store_address_t temp_id;
-	memcpy(&temp_id, this->getData(), sizeof(store_address_t) );
-	return temp_id;
-}
-
-TmTcMessage::TmTcMessage(store_address_t store_id) {
-	this->messageSize += sizeof(store_address_t);
-	this->setStorageId(store_id);
-}
-
-size_t TmTcMessage::getMinimumMessageSize() {
-	return this->HEADER_SIZE + sizeof(store_address_t);
-}
-
-void TmTcMessage::setStorageId(store_address_t store_id) {
-	memcpy(this->getData(), &store_id, sizeof(store_address_t) );
-}
+#include "../tmtcservices/TmTcMessage.h"
+#include <string.h>
+
+
+TmTcMessage::TmTcMessage() {
+	this->messageSize += sizeof(store_address_t);
+}
+
+TmTcMessage::~TmTcMessage() {
+}
+
+store_address_t TmTcMessage::getStorageId() {
+	store_address_t temp_id;
+	memcpy(&temp_id, this->getData(), sizeof(store_address_t) );
+	return temp_id;
+}
+
+TmTcMessage::TmTcMessage(store_address_t store_id) {
+	this->messageSize += sizeof(store_address_t);
+	this->setStorageId(store_id);
+}
+
+size_t TmTcMessage::getMinimumMessageSize() {
+	return this->HEADER_SIZE + sizeof(store_address_t);
+}
+
+void TmTcMessage::setStorageId(store_address_t store_id) {
+	memcpy(this->getData(), &store_id, sizeof(store_address_t) );
+}
diff --git a/tmtcservices/TmTcMessage.h b/tmtcservices/TmTcMessage.h
index ad97c0563..b5e1ff8d4 100644
--- a/tmtcservices/TmTcMessage.h
+++ b/tmtcservices/TmTcMessage.h
@@ -1,50 +1,50 @@
-#ifndef TMTCMESSAGE_H_
-#define TMTCMESSAGE_H_
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-/**
- * @brief	This message class is used to pass Telecommand and Telemetry
- * 			packets between tasks.
- * @details	Within such a packet, nothing is transported but the identifier of
- * 			a packet stored in one of the IPC stores (typically a special TM and
- * 			a special TC store). This makes passing commands very simple and
- * 			efficient.
- *	\ingroup message_queue
- */
-class TmTcMessage : public MessageQueueMessage {
-protected:
-	/**
-	 * @brief	This call always returns the same fixed size of the message.
-	 * @return	Returns HEADER_SIZE + \c sizeof(store_address_t).
-	 */
-	size_t getMinimumMessageSize();
-public:
-	/**
-	 * @brief	In the default constructor, only the message_size is set.
-	 */
-	TmTcMessage();
-	/**
-	 * @brief	With this constructor, the passed packet id is directly put
-	 * 			into the message.
-	 * @param packet_id	The packet id to put into the message.
-	 */
-	TmTcMessage( store_address_t packet_id );
-	/**
-	 * @brief	The class's destructor is empty.
-	 */
-	~TmTcMessage();
-	/**
-	 * @brief	This getter returns the packet id in the correct format.
-	 * @return	Returns the packet id.
-	 */
-	store_address_t getStorageId();
-	/**
-	 * @brief	In some cases it might be useful to have a setter for packet id
-	 * 			as well.
-	 * @param packet_id	The packet id to put into the message.
-	 */
-	void setStorageId( store_address_t packet_id );
-};
-
-#endif /* TMTCMESSAGE_H_ */
+#ifndef TMTCMESSAGE_H_
+#define TMTCMESSAGE_H_
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+/**
+ * @brief	This message class is used to pass Telecommand and Telemetry
+ * 			packets between tasks.
+ * @details	Within such a packet, nothing is transported but the identifier of
+ * 			a packet stored in one of the IPC stores (typically a special TM and
+ * 			a special TC store). This makes passing commands very simple and
+ * 			efficient.
+ *	\ingroup message_queue
+ */
+class TmTcMessage : public MessageQueueMessage {
+protected:
+	/**
+	 * @brief	This call always returns the same fixed size of the message.
+	 * @return	Returns HEADER_SIZE + \c sizeof(store_address_t).
+	 */
+	size_t getMinimumMessageSize();
+public:
+	/**
+	 * @brief	In the default constructor, only the message_size is set.
+	 */
+	TmTcMessage();
+	/**
+	 * @brief	With this constructor, the passed packet id is directly put
+	 * 			into the message.
+	 * @param packet_id	The packet id to put into the message.
+	 */
+	TmTcMessage( store_address_t packet_id );
+	/**
+	 * @brief	The class's destructor is empty.
+	 */
+	~TmTcMessage();
+	/**
+	 * @brief	This getter returns the packet id in the correct format.
+	 * @return	Returns the packet id.
+	 */
+	store_address_t getStorageId();
+	/**
+	 * @brief	In some cases it might be useful to have a setter for packet id
+	 * 			as well.
+	 * @param packet_id	The packet id to put into the message.
+	 */
+	void setStorageId( store_address_t packet_id );
+};
+
+#endif /* TMTCMESSAGE_H_ */
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index e9a43855b..4f9f4e54e 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -1,105 +1,105 @@
-#include "../tmtcservices/VerificationReporter.h"
-
-#include "../ipc/MessageQueueIF.h"
-#include "../tmtcservices/AcceptsVerifyMessageIF.h"
-#include "../tmtcservices/PusVerificationReport.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../objectmanager/frameworkObjects.h"
-
-object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1;
-
-VerificationReporter::VerificationReporter() :
-		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {
-}
-
-VerificationReporter::~VerificationReporter() {}
-
-void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
-		TcPacketBase* current_packet, uint8_t set_step) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
-		this->initialize();
-	}
-	PusVerificationMessage message(set_report_id,
-			current_packet->getAcknowledgeFlags(),
-			current_packet->getPacketId(),
-			current_packet->getPacketSequenceControl(), 0, set_step);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-			&message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
-		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-		uint8_t set_step) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE)  {
-		this->initialize();
-	}
-	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
-			tcSequenceControl, 0, set_step);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-			&message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::sendFailureReport(uint8_t report_id,
-		TcPacketBase* current_packet, ReturnValue_t error_code, uint8_t step,
-		uint32_t parameter1, uint32_t parameter2) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
-		this->initialize();
-	}
-	PusVerificationMessage message(report_id,
-			current_packet->getAcknowledgeFlags(),
-			current_packet->getPacketId(),
-			current_packet->getPacketSequenceControl(), error_code, step,
-			parameter1, parameter2);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendFailureReport Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::sendFailureReport(uint8_t report_id,
-		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-		ReturnValue_t error_code, uint8_t step, uint32_t parameter1,
-		uint32_t parameter2) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
-		this->initialize();
-	}
-	PusVerificationMessage message(report_id, ackFlags, tcPacketId,
-			tcSequenceControl, error_code, step, parameter1, parameter2);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendFailureReport Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::initialize() {
-	if(messageReceiver == objects::NO_OBJECT) {
-		sif::warning << "VerificationReporter::initialize: Verification message"
-				" receiver object ID not set yet in Factory!" << std::endl;
-		return;
-	}
-	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
-			messageReceiver);
-	if (temp == nullptr) {
-		sif::error << "VerificationReporter::initialize: Message "
-				<< "receiver invalid. Make sure it is set up properly and "
-				<<"implementsAcceptsVerifyMessageIF" << std::endl;
-
-	}
-	this->acknowledgeQueue = temp->getVerificationQueue();
-}
+#include "../tmtcservices/VerificationReporter.h"
+
+#include "../ipc/MessageQueueIF.h"
+#include "../tmtcservices/AcceptsVerifyMessageIF.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../objectmanager/frameworkObjects.h"
+
+object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1;
+
+VerificationReporter::VerificationReporter() :
+		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {
+}
+
+VerificationReporter::~VerificationReporter() {}
+
+void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
+		TcPacketBase* current_packet, uint8_t set_step) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+		this->initialize();
+	}
+	PusVerificationMessage message(set_report_id,
+			current_packet->getAcknowledgeFlags(),
+			current_packet->getPacketId(),
+			current_packet->getPacketSequenceControl(), 0, set_step);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+			&message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
+		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+		uint8_t set_step) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE)  {
+		this->initialize();
+	}
+	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
+			tcSequenceControl, 0, set_step);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+			&message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::sendFailureReport(uint8_t report_id,
+		TcPacketBase* current_packet, ReturnValue_t error_code, uint8_t step,
+		uint32_t parameter1, uint32_t parameter2) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+		this->initialize();
+	}
+	PusVerificationMessage message(report_id,
+			current_packet->getAcknowledgeFlags(),
+			current_packet->getPacketId(),
+			current_packet->getPacketSequenceControl(), error_code, step,
+			parameter1, parameter2);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendFailureReport Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::sendFailureReport(uint8_t report_id,
+		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+		ReturnValue_t error_code, uint8_t step, uint32_t parameter1,
+		uint32_t parameter2) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+		this->initialize();
+	}
+	PusVerificationMessage message(report_id, ackFlags, tcPacketId,
+			tcSequenceControl, error_code, step, parameter1, parameter2);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendFailureReport Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::initialize() {
+	if(messageReceiver == objects::NO_OBJECT) {
+		sif::warning << "VerificationReporter::initialize: Verification message"
+				" receiver object ID not set yet in Factory!" << std::endl;
+		return;
+	}
+	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
+			messageReceiver);
+	if (temp == nullptr) {
+		sif::error << "VerificationReporter::initialize: Message "
+				<< "receiver invalid. Make sure it is set up properly and "
+				<<"implementsAcceptsVerifyMessageIF" << std::endl;
+
+	}
+	this->acknowledgeQueue = temp->getVerificationQueue();
+}
diff --git a/tmtcservices/VerificationReporter.h b/tmtcservices/VerificationReporter.h
index 86aea8262..4d92f6b38 100644
--- a/tmtcservices/VerificationReporter.h
+++ b/tmtcservices/VerificationReporter.h
@@ -1,50 +1,50 @@
-#ifndef FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
-#define FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../tmtcservices/PusVerificationReport.h"
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @brief 	This helper object is used to forward verification messages
- * 			which are generated by the Flight Software Framework.
- * @details
- * The messages can be relayed to an arbitrary object, for example a dedicated
- * Verification Reporter. The destination is set by setting the static framework
- * Id VerificationReporter::messageReceiver. The default verification reporter
- * will be the PUS service 1, which sends verification messages according
- * to the PUS standard.
- *
- */
-class VerificationReporter {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	VerificationReporter();
-	virtual ~VerificationReporter();
-
-	void sendSuccessReport( uint8_t set_report_id, TcPacketBase* current_packet,
-			uint8_t set_step = 0 );
-	void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags,
-			uint16_t tcPacketId, uint16_t tcSequenceControl,
-			uint8_t set_step = 0);
-
-	void sendFailureReport( uint8_t report_id, TcPacketBase* current_packet,
-			ReturnValue_t error_code = 0,
-			uint8_t step = 0, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0 );
-	void sendFailureReport(uint8_t report_id,
-			uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-			ReturnValue_t error_code = 0, uint8_t step = 0,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-
-	void initialize();
-
-private:
-	static object_id_t messageReceiver;
-	MessageQueueId_t acknowledgeQueue;
-};
-
-#endif /* FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
+#define FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @brief 	This helper object is used to forward verification messages
+ * 			which are generated by the Flight Software Framework.
+ * @details
+ * The messages can be relayed to an arbitrary object, for example a dedicated
+ * Verification Reporter. The destination is set by setting the static framework
+ * Id VerificationReporter::messageReceiver. The default verification reporter
+ * will be the PUS service 1, which sends verification messages according
+ * to the PUS standard.
+ *
+ */
+class VerificationReporter {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	VerificationReporter();
+	virtual ~VerificationReporter();
+
+	void sendSuccessReport( uint8_t set_report_id, TcPacketBase* current_packet,
+			uint8_t set_step = 0 );
+	void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags,
+			uint16_t tcPacketId, uint16_t tcSequenceControl,
+			uint8_t set_step = 0);
+
+	void sendFailureReport( uint8_t report_id, TcPacketBase* current_packet,
+			ReturnValue_t error_code = 0,
+			uint8_t step = 0, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0 );
+	void sendFailureReport(uint8_t report_id,
+			uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+			ReturnValue_t error_code = 0, uint8_t step = 0,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+
+	void initialize();
+
+private:
+	static object_id_t messageReceiver;
+	MessageQueueId_t acknowledgeQueue;
+};
+
+#endif /* FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_ */

From b6a19f911d177e4129dfc0a5a10e0e499aa1ba88 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 18:45:19 +0200
Subject: [PATCH 0683/1774] include guards improved

---
 parameters/HasParametersIF.h             |  6 +++---
 parameters/ParameterHelper.cpp           |  4 ++--
 parameters/ParameterHelper.h             | 10 +++++-----
 parameters/ParameterMessage.h            |  8 ++++----
 parameters/ParameterWrapper.cpp          |  2 +-
 parameters/ParameterWrapper.h            |  8 ++++----
 parameters/ReceivesParameterMessagesIF.h |  8 ++++----
 7 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 0c6afc12b..005403fa5 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -1,5 +1,5 @@
-#ifndef HASPARAMETERSIF_H_
-#define HASPARAMETERSIF_H_
+#ifndef FSFW_PARAMETERS_HASPARAMETERSIF_H_
+#define FSFW_PARAMETERS_HASPARAMETERSIF_H_
 
 #include "../parameters/ParameterWrapper.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -64,4 +64,4 @@ public:
 			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
 };
 
-#endif /* HASPARAMETERSIF_H_ */
+#endif /* FSFW_PARAMETERS_HASPARAMETERSIF_H_ */
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index ec7ded3c7..659b00def 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -1,6 +1,6 @@
+#include "ParameterHelper.h"
+#include "ParameterMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../parameters/ParameterHelper.h"
-#include "../parameters/ParameterMessage.h"
 
 ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
 		owner(owner) {}
diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index 5dd78b641..6b06ffdc6 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -1,9 +1,9 @@
-#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
-#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
+#ifndef FSFW_PARAMETERS_PARAMETERHELPER_H_
+#define FSFW_PARAMETERS_PARAMETERHELPER_H_
 
+#include "ParameterMessage.h"
+#include "ReceivesParameterMessagesIF.h"
 #include "../ipc/MessageQueueIF.h"
-#include "../parameters/ParameterMessage.h"
-#include "../parameters/ReceivesParameterMessagesIF.h"
 
 /**
  * @brief	Helper class to handle parameter messages
@@ -33,4 +33,4 @@ private:
 			Command_t initialCommand);
 };
 
-#endif /* PARAMETERHELPER_H_ */
+#endif /* FSFW_PARAMETERS_PARAMETERHELPER_H_ */
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index de68dcfcd..31d7fe0bc 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -1,8 +1,8 @@
-#ifndef PARAMETERMESSAGE_H_
-#define PARAMETERMESSAGE_H_
+#ifndef FSFW_PARAMETERS_PARAMETERMESSAGE_H_
+#define FSFW_PARAMETERS_PARAMETERMESSAGE_H_
 
+#include "HasParametersIF.h"
 #include "../ipc/CommandMessage.h"
-#include "../parameters/HasParametersIF.h"
 #include "../storagemanager/StorageManagerIF.h"
 
 class ParameterMessage {
@@ -26,4 +26,4 @@ public:
 
 };
 
-#endif /* PARAMETERMESSAGE_H_ */
+#endif /* FSFW_PARAMETERS_PARAMETERMESSAGE_H_ */
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index fd36a0a92..d020da331 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -1,4 +1,4 @@
-#include "../parameters/ParameterWrapper.h"
+#include "ParameterWrapper.h"
 
 ParameterWrapper::ParameterWrapper() :
 		pointsToStream(false), type(Type::UNKNOWN_TYPE) {
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 350459594..f07205d4b 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -1,11 +1,11 @@
-#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
-#define FRAMEWORK_PARAMETERS_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
@@ -159,4 +159,4 @@ inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
 	}
 }
 
-#endif /* PARAMETERWRAPPER_H_ */
+#endif /* FSFW_PARAMETERS_PARAMETERWRAPPER_H_ */
diff --git a/parameters/ReceivesParameterMessagesIF.h b/parameters/ReceivesParameterMessagesIF.h
index f8c3746e5..e8c7fa692 100644
--- a/parameters/ReceivesParameterMessagesIF.h
+++ b/parameters/ReceivesParameterMessagesIF.h
@@ -1,8 +1,8 @@
-#ifndef RECEIVESPARAMETERMESSAGESIF_H_
-#define RECEIVESPARAMETERMESSAGESIF_H_
+#ifndef FSFW_PARAMETERS_RECEIVESPARAMETERMESSAGESIF_H_
+#define FSFW_PARAMETERS_RECEIVESPARAMETERMESSAGESIF_H_
 
 
-#include "../parameters/HasParametersIF.h"
+#include "HasParametersIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 
 class ReceivesParameterMessagesIF : public HasParametersIF {
@@ -16,4 +16,4 @@ public:
 };
 
 
-#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
+#endif /* FSFW_PARAMETERS_RECEIVESPARAMETERMESSAGESIF_H_ */

From b0673c7fa6e7f66d9c76a5f66c3d209579a759f1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 18:47:11 +0200
Subject: [PATCH 0684/1774] typo fixes

---
 parameters/ParameterHelper.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index 6b06ffdc6..595b4bc50 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -6,9 +6,9 @@
 #include "../ipc/MessageQueueIF.h"
 
 /**
- * @brief	Helper class to handle parameter messages
+ * @brief	Helper class to handle parameter messages.
  * @details
- * This class simplfiies handling of parameter messages, which are sent
+ * This class simplfies handling of parameter messages, which are sent
  * to a class which implements ReceivesParameterMessagesIF.
  */
 class ParameterHelper {

From 6c02776975fbebb9a49302825943c0244c3ebc55 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 29 Aug 2020 00:16:40 +0200
Subject: [PATCH 0685/1774] added srv9

---
 pus/Service9TimeManagement.cpp       | 58 ++++++++++++++++++++++++++++
 pus/Service9TimeManagement.h         | 42 ++++++++++++++++++++
 pus/servicepackets/Service9Packets.h | 32 +++++++++++++++
 returnvalues/FwClassIds.h            |  1 +
 4 files changed, 133 insertions(+)
 create mode 100644 pus/Service9TimeManagement.cpp
 create mode 100644 pus/Service9TimeManagement.h
 create mode 100644 pus/servicepackets/Service9Packets.h

diff --git a/pus/Service9TimeManagement.cpp b/pus/Service9TimeManagement.cpp
new file mode 100644
index 000000000..5625bdd8f
--- /dev/null
+++ b/pus/Service9TimeManagement.cpp
@@ -0,0 +1,58 @@
+#include "Service9TimeManagement.h"
+#include "servicepackets/Service9Packets.h"
+
+#include "../timemanager/CCSDSTime.h"
+#include "../events/EventManagerIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+
+Service9TimeManagement::Service9TimeManagement(object_id_t objectId,
+		uint16_t apid, uint8_t serviceId) :
+	PusServiceBase(objectId, apid , serviceId) {
+}
+
+Service9TimeManagement::~Service9TimeManagement() {}
+
+ReturnValue_t Service9TimeManagement::performService() {
+	return RETURN_OK;
+}
+
+ReturnValue_t Service9TimeManagement::handleRequest(uint8_t subservice) {
+	switch(subservice){
+		case SUBSERVICE::SET_TIME:{
+			return setTime();
+		}
+		default:
+			return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+		}
+}
+
+ReturnValue_t Service9TimeManagement::setTime() {
+	Clock::TimeOfDay_t timeToSet;
+	TimePacket timePacket(currentPacket.getApplicationData(),
+			currentPacket.getApplicationDataSize());
+	ReturnValue_t result = CCSDSTime::convertFromCcsds(&timeToSet,
+			timePacket.getTime(), timePacket.getTimeSize());
+	if(result != RETURN_OK) {
+		triggerEvent(CLOCK_SET_FAILURE, result, 0);
+		return result;
+	}
+
+	uint32_t formerUptime;
+	Clock::getUptime(&formerUptime);
+	result = Clock::setClock(&timeToSet);
+
+	if(result == RETURN_OK) {
+		uint32_t newUptime;
+		Clock::getUptime(&newUptime);
+		triggerEvent(CLOCK_SET,newUptime,formerUptime);
+		return RETURN_OK;
+	}
+	else {
+		triggerEvent(CLOCK_SET_FAILURE, result, 0);
+		return RETURN_FAILED;
+	}
+}
+
+
+
diff --git a/pus/Service9TimeManagement.h b/pus/Service9TimeManagement.h
new file mode 100644
index 000000000..4ad6be6e3
--- /dev/null
+++ b/pus/Service9TimeManagement.h
@@ -0,0 +1,42 @@
+#ifndef FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_
+#define FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_
+
+#include <fsfw/tmtcservices/PusServiceBase.h>
+
+class Service9TimeManagement: public PusServiceBase {
+public:
+
+	static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_9;
+	static constexpr Event CLOCK_SET = MAKE_EVENT(0, SEVERITY::INFO); //!< Clock has been set. P1: New Uptime. P2: Old Uptime
+	static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(1, SEVERITY::LOW); //!< Clock could not be set. P1: Returncode.
+
+	static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_9;
+
+	/**
+	 * 	@brief This service provides the capability to set the on-board time.
+	 */
+	Service9TimeManagement(object_id_t objectId, uint16_t apid,
+			uint8_t serviceId);
+
+	virtual ~Service9TimeManagement();
+
+	virtual ReturnValue_t performService() override;
+
+	/**
+	 * 	@brief Sets the onboard-time by retrieving the time to set from TC[9,128].
+	 */
+	virtual ReturnValue_t handleRequest(uint8_t subservice) override;
+
+	virtual ReturnValue_t setTime();
+private:
+
+	enum SUBSERVICE {
+		SET_TIME = 128 //!< [EXPORT] : [COMMAND] Time command in ASCII, CUC or CDS format
+	};
+
+	void setIsisClock(Clock::TimeOfDay_t& timeOfDay);
+};
+
+
+
+#endif /* FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_ */
diff --git a/pus/servicepackets/Service9Packets.h b/pus/servicepackets/Service9Packets.h
new file mode 100644
index 000000000..11bd26001
--- /dev/null
+++ b/pus/servicepackets/Service9Packets.h
@@ -0,0 +1,32 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_
+
+#include "../../serialize/SerialLinkedListAdapter.h"
+
+/**
+ * @brief Subservice 128
+ * @details
+ * It only contains the time encoded as ASCII, CRC, CUC or CDS
+ * @ingroup spacepackets
+ */
+class TimePacket : SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
+public:
+	TimePacket(const uint8_t * timeBuffer_, uint32_t timeSize_) {
+		timeBuffer = timeBuffer_;
+		timeSize = timeSize_;
+	}
+	const uint8_t*  getTime() {
+		return timeBuffer;
+	}
+
+	uint32_t getTimeSize() const {
+		return timeSize;
+	}
+
+private:
+	TimePacket(const TimePacket &command);
+	const uint8_t * timeBuffer;
+	uint32_t timeSize; //!< [EXPORT] : [IGNORE]
+};
+
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_ */
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index ebd1847d8..12877b404 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -67,6 +67,7 @@ enum {
 	DLE_ENCODER, //DLEE 61
 	PUS_PARSER, //PUSP 62
 	SERIAL_ANALYZER, //SERA 63
+	PUS_SERVICE_9,
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 15bb0aee985cc5b558cea21e635b1600db5905f5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 29 Aug 2020 19:08:10 +0200
Subject: [PATCH 0686/1774] handler ID cached, debug output improved

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 13 +++++++++----
 tasks/FixedSequenceSlot.cpp         |  2 +-
 tasks/FixedSequenceSlot.h           |  2 ++
 3 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 404c3c05c..309574eb7 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -147,13 +147,18 @@ void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
 }
 
 void FixedTimeslotTask::handleMissedDeadline() {
-#ifdef DEBUG
-    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
-            " missed deadline!\n" << std::flush;
-#endif
     if(deadlineMissedFunc != nullptr) {
         this->deadlineMissedFunc();
     }
+
+#ifdef DEBUG
+    object_id_t handlerId = pst.current->handlerId;
+    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) << " with"
+            << " object ID 0x" << std::setfill('0') << std::setw(8) << std::hex
+            << handlerId <<  " missed deadline!" << std::setfill(' ')
+            << std::dec << std::endl;
+#endif
+
 }
 
 ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index a38734a2c..d7aeff0af 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -4,7 +4,7 @@
 
 FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
 		int8_t setSequenceId, ExecutableObjectIF* executableObject,
-		PeriodicTaskIF* executingTask) :
+		PeriodicTaskIF* executingTask) : handlerId(handlerId),
 		pollingTimeMs(setTime), opcode(setSequenceId) {
     if(executableObject == nullptr) {
         return;
diff --git a/tasks/FixedSequenceSlot.h b/tasks/FixedSequenceSlot.h
index 6ec9ae132..151173e96 100644
--- a/tasks/FixedSequenceSlot.h
+++ b/tasks/FixedSequenceSlot.h
@@ -20,6 +20,8 @@ public:
 			PeriodicTaskIF* executingTask);
 	virtual ~FixedSequenceSlot();
 
+	object_id_t handlerId;
+
 	/**
 	 * @brief	Handler identifies which object is executed in this slot.
 	 */

From edde2ee58b54270aa832193312ecd289940fe0d2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Sep 2020 12:43:50 +0200
Subject: [PATCH 0687/1774] offsetr update

---
 parameters/ParameterWrapper.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index d020da331..6adc6857c 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -270,7 +270,8 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		//need a type to do arithmetic
 		uint8_t* typedData = static_cast<uint8_t*>(data);
 		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
-			uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
+			size_t offset = (((startingRow + fromRow) * columns) +
+					startingColumn) * typeSize;
 			std::memcpy(typedData +  offset, from->readonlyData,
 					typeSize * from->columns);
 		}

From f7f134ac20ca6bb76fedd14804290fc06455c44a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Sep 2020 12:48:11 +0200
Subject: [PATCH 0688/1774] corrections

---
 container/FIFOBase.tpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index c73e9d590..e1287dcf8 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_CONTAINER_FIFOBASE_TPP_
-#define FRAMEWORK_CONTAINER_FIFOBASE_TPP_
+#ifndef FSFW_CONTAINER_FIFOBASE_TPP_
+#define FSFW_CONTAINER_FIFOBASE_TPP_
 
-#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
+#ifndef FSFW_CONTAINER_FIFOBASE_H_
 #error Include FIFOBase.h before FIFOBase.tpp!
 #endif
 

From 7cf79c17a9e54de41fd9a10e630ad07fd967829f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Sep 2020 12:48:51 +0200
Subject: [PATCH 0689/1774] fifo update

---
 container/FIFO.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/container/FIFO.h b/container/FIFO.h
index 4688a7b05..e60a4979d 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -1,8 +1,7 @@
 #ifndef FRAMEWORK_CONTAINER_FIFO_H_
 #define FRAMEWORK_CONTAINER_FIFO_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../container/FIFOBase.h"
+#include "FIFOBase.h"
 #include <array>
 
 /**

From a634875b4b08cde12d2c2ea14d50303ab13d573d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Sep 2020 12:50:17 +0200
Subject: [PATCH 0690/1774] dynamic fifo update

---
 container/DynamicFIFO.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 9af98f966..7fa0c32cd 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
-#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+#ifndef FSFW_CONTAINER_DYNAMICFIFO_H_
+#define FSFW_CONTAINER_DYNAMICFIFO_H_
 
-#include "../container/FIFOBase.h"
+#include "FIFOBase.h"
 #include <vector>
 
 /**
@@ -39,4 +39,4 @@ private:
 	std::vector<T> fifoVector;
 };
 
-#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
+#endif /* FSFW_CONTAINER_DYNAMICFIFO_H_ */

From bec562ece0ae8cc5f7c81d7e998f47ebfaaa083b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Sep 2020 12:54:33 +0200
Subject: [PATCH 0691/1774] FIFO updates

---
 container/DynamicFIFO.h |  4 ++--
 container/FIFO.h        | 12 +++++++-----
 container/FIFOBase.h    | 10 +++++-----
 container/FIFOBase.tpp  |  2 +-
 4 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 7fa0c32cd..abb533308 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -22,7 +22,7 @@ public:
 		// 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->setData(fifoVector.data());
+		this->setContainer(fifoVector.data());
 	};
 
 	/**
@@ -31,7 +31,7 @@ public:
 	 */
 	DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
 			fifoVector(other.maxCapacity) {
-		this->setData(fifoVector.data());
+		this->setContainer(fifoVector.data());
 	}
 
 
diff --git a/container/FIFO.h b/container/FIFO.h
index e60a4979d..19f763fc8 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_CONTAINER_FIFO_H_
-#define FRAMEWORK_CONTAINER_FIFO_H_
+#ifndef FSFW_CONTAINER_FIFO_H_
+#define FSFW_CONTAINER_FIFO_H_
 
 #include "FIFOBase.h"
 #include <array>
@@ -16,18 +16,20 @@
 template<typename T, size_t capacity>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
+	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->setData(fifoArray.data());
+		this->setContainer(fifoArray.data());
 	}
 
 private:
 	std::array<T, capacity> fifoArray;
 };
 
-#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
+#endif /* FSFW_CONTAINER_FIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index 410e52a5b..b744706d4 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
-#define FRAMEWORK_CONTAINER_FIFOBASE_H_
+#ifndef FSFW_CONTAINER_FIFOBASE_H_
+#define FSFW_CONTAINER_FIFOBASE_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
@@ -48,7 +48,7 @@ public:
 	size_t getMaxCapacity() const;
 
 protected:
-	void setData(T* data);
+	void setContainer(T* data);
 	size_t maxCapacity = 0;
 
 	T* values;
@@ -60,6 +60,6 @@ protected:
 	size_t next(size_t current);
 };
 
-#include "../container/FIFOBase.tpp"
+#include "FIFOBase.tpp"
 
-#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
+#endif /* FSFW_CONTAINER_FIFOBASE_H_ */
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index e1287dcf8..d54b3f8f9 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -80,7 +80,7 @@ inline size_t FIFOBase<T>::getMaxCapacity() const {
 
 
 template<typename T>
-inline void FIFOBase<T>::setData(T *data) {
+inline void FIFOBase<T>::setContainer(T *data) {
 	this->values = data;
 }
 

From 33039f8c6055b45cb75b39a4e86a8a38430222a9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Sep 2020 12:57:56 +0200
Subject: [PATCH 0692/1774] include  guard correction

---
 tmtcservices/CommandingServiceBase.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 4a1804452..29ab967a1 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+#ifndef FSFW_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+#define FSFW_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
 
 #include "../objectmanager/SystemObject.h"
 #include "../storagemanager/StorageManagerIF.h"
@@ -345,4 +345,4 @@ private:
 	void checkTimeout();
 };
 
-#endif /* COMMANDINGSERVICEBASE_H_ */
+#endif /* FSFW_TMTCSERVICES_COMMANDINGSERVICEBASE_H_ */

From ae9bc39bdaadb7323dfe009b5e93276e620e6d76 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 2 Sep 2020 17:59:26 +0200
Subject: [PATCH 0693/1774] some bugfixes and improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 13 ++++++++-----
 devicehandlers/DeviceHandlerBase.h   |  2 ++
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 0253d6a7c..820a2cceb 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -678,7 +678,7 @@ void DeviceHandlerBase::doGetRead() {
 void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		size_t receivedDataLen) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	DeviceCommandId_t foundId = 0xFFFFFFFF;
+	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
@@ -709,7 +709,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 			break;
 		}
 		case IGNORE_REPLY_DATA:
-			break;
+			continue;
 		case IGNORE_FULL_PACKET:
 			return;
 		default:
@@ -741,16 +741,19 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 	DeviceReplyInfo *info = &(iter->second);
 
 	if (info->delayCycles != 0) {
+	    result = interpretDeviceReply(foundId, receivedData);
 
-		if (info->periodic != false) {
+	    if(result == IGNORE_REPLY_DATA) {
+	        return;
+	    }
+
+		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);
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 5357148e4..abab78752 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -323,6 +323,8 @@ protected:
 	 * @param packet
 	 * @return
 	 *     - @c RETURN_OK when the reply was interpreted.
+	 *     - @c IGNORE_REPLY_DATA Ignore the reply and don't reset reply cycle
+	 *          counter.
 	 *     - @c RETURN_FAILED when the reply could not be interpreted,
 	 *     e.g. logical errors or range violations occurred
 	 */

From 6069c64048b2850f7cb080cac2d0f836c4543be0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 2 Sep 2020 23:36:54 +0200
Subject: [PATCH 0694/1774] doc improved

---
 devicehandlers/DeviceHandlerBase.h | 63 ++++++++++++------------------
 1 file changed, 25 insertions(+), 38 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index abab78752..5f76f7e41 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -39,9 +39,10 @@ class StorageManagerIF;
  * Documentation: Dissertation Baetz p.138,139, p.141-149
  *
  * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink,
- * communication with physical devices, using the @link DeviceCommunicationIF @endlink,
- * and communication with commanding objects.
- * It inherits SystemObject and thus can be created by the ObjectManagerIF.
+ * communication with physical devices, using the
+ * @link DeviceCommunicationIF @endlink, and communication with commanding
+ * objects. It inherits SystemObject and thus can be created by the
+ * ObjectManagerIF.
  *
  * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
  * For each step an RMAP action is selected and executed.
@@ -49,7 +50,7 @@ class StorageManagerIF;
  * 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.
+ * NOTE: RMAP is a standard which is used for Flying Laptop.
  * 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.
@@ -70,9 +71,6 @@ class StorageManagerIF;
  *
  * Other important virtual methods with a default implementation
  * are the getTransitionDelayMs() function and the getSwitches() function.
- * Please ensure that getSwitches() returns DeviceHandlerIF::NO_SWITCHES if
- * power switches are not implemented yet. Otherwise, the device handler will
- * not transition to MODE_ON, even if setMode(MODE_ON) is called.
  * If a transition to MODE_ON is desired without commanding, override the
  * intialize() function and call setMode(_MODE_START_UP) before calling
  * DeviceHandlerBase::initialize().
@@ -94,13 +92,10 @@ public:
 	 * The constructor passes the objectId to the SystemObject().
 	 *
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
-	 * @param setDeviceSwitch the switch the device is connected to,
-	 * for devices using two switches, overwrite getSwitches()
 	 * @param deviceCommuncation Communcation Interface object which is used
 	 * to implement communication functions
-	 * @param thermalStatePoolId
-	 * @param thermalRequestPoolId
+	 * @param comCookie This object will be passed to the communication inter-
+	 * face and can contain user-defined information about the communication.
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
@@ -352,22 +347,10 @@ protected:
 	 *    set to the maximum expected number of PST cycles between two replies
 	 *    (also a tolerance should be added, as an FDIR message will be
 	 *    generated if it is missed).
-	 *
-	 *    (Robin) This part confuses me. "must do as soon as" implies that
-	 *    the developer must do something somewhere else in the code. Is
-	 *    that really the case? If I understood correctly, DHB performs
-	 *    almost everything (e.g. in erirm function) as long as the commands
-	 *    are inserted correctly.
-	 *
-	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must
-	 *    be set to true, DeviceCommandInfo.delayCycles to
-	 *    DeviceCommandInfo.maxDelayCycles.
 	 *    From then on, the base class handles the reception.
 	 *    Then, scanForReply returns the id of the reply or the placeholder id
 	 *    and the base class will take care of checking that all replies are
 	 *    received and the interval is correct.
-	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set
-	 *    to 0, DeviceCommandInfo.delayCycles to 0;
 	 *
 	 *  - Aperiodic, unrequested replies. These are replies that are sent
 	 *    by the device without any preceding command and not in a defined
@@ -705,14 +688,18 @@ protected:
 	uint32_t deviceThermalRequestPoolId = PoolVariableIF::NO_PARAMETER;
 
 	/**
-	 * Optional Error code
-	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
+	 * Optional Error code. Can be set in doStartUp(), doShutDown() and
+	 * doTransition() to signal cause for Transition failure.
 	 */
 	ReturnValue_t childTransitionFailure;
 
-	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
+	/** Counts if communication channel lost a reply, so some missed
+	 * replys can be ignored. */
+	uint32_t ignoreMissedRepliesCount = 0;
 
-	FailureIsolationBase* fdirInstance; //!< Pointer to the used FDIR instance. If not provided by child, default class is instantiated.
+	/** Pointer to the used FDIR instance. If not provided by child,
+	 * default class is instantiated. */
+	FailureIsolationBase* fdirInstance;
 
 	HkSwitchHelper hkSwitcher;
 
@@ -1099,11 +1086,6 @@ private:
 	void buildRawDeviceCommand(CommandMessage* message);
 	void buildInternalCommand(void);
 
-//	/**
-//	 * Send a reply with the current mode and submode.
-//	 */
-//	void announceMode(void);
-
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
@@ -1130,10 +1112,14 @@ private:
 	/**
 	 * Build and send a command to the device.
 	 *
-	 * This routine checks whether a raw or direct command has been received, checks the content of the received command and
-	 * calls buildCommandFromCommand() for direct commands or sets #rawpacket to the received raw packet.
-	 * If no external command is received or the received command is invalid and the current mode is @c MODE_NORMAL or a transitional mode,
-	 * it asks the child class to build a command (via getNormalDeviceCommand() or getTransitionalDeviceCommand() and buildCommand()) and
+	 * This routine checks whether a raw or direct command has been received,
+	 * checks the content of the received command and calls
+	 * buildCommandFromCommand() for direct commands or sets #rawpacket
+	 * to the received raw packet.
+	 * If no external command is received or the received command is invalid and
+	 * the current mode is @c MODE_NORMAL or a transitional mode, it asks the
+	 * child class to build a command (via getNormalDeviceCommand() or
+	 * getTransitionalDeviceCommand() and buildCommand()) and
 	 * sends the command via RMAP.
 	 */
 	void doSendWrite(void);
@@ -1196,7 +1182,8 @@ private:
 	 * @param newChannel the object Id of the channel to switch to
 	 * @return
 	 *     - @c RETURN_OK when cookie was changed
-	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
+	 *     - @c RETURN_FAILED when cookies could not be changed,
+	 *          e.g. because the newChannel is not enabled
 	 *     - @c returnvalues of RMAPChannelIF::isActive()
 	 */
 	ReturnValue_t switchCookieChannel(object_id_t newChannelId);

From e8fa9816ceea383d1e15e55b6bbf84d1e6327702 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 2 Sep 2020 23:45:14 +0200
Subject: [PATCH 0695/1774] doc improved

---
 devicehandlers/DeviceHandlerBase.h | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 5f76f7e41..f809953e9 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -44,12 +44,10 @@ class StorageManagerIF;
  * objects. It inherits SystemObject and thus can be created by the
  * ObjectManagerIF.
  *
- * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
- * For each step an RMAP action is selected and executed.
- * 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.
+ * This class uses the opcode of ExecutableObjectIF to perform a
+ * step-wise execution. For each step a different action is selected and
+ * executed. Currently, the device handler base performs a 4-step
+ * execution related to 4 communication steps (based on RMAP).
  * NOTE: RMAP is a standard which is used for Flying Laptop.
  * RMAP communication is not mandatory for projects implementing the FSFW.
  * However, the communication principles are similar to RMAP as there are

From 822a908353608f053590fecd9e0a3115c37cb6f9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 3 Sep 2020 00:17:01 +0200
Subject: [PATCH 0696/1774] separated steps, everything seems to work

---
 devicehandlers/DeviceHandlerBase.cpp | 47 ++++++++++++----------------
 devicehandlers/DeviceHandlerBase.h   |  2 +-
 devicehandlers/DeviceHandlerIF.h     |  3 +-
 3 files changed, 23 insertions(+), 29 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 820a2cceb..7cba6dba8 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -72,8 +72,11 @@ DeviceHandlerBase::~DeviceHandlerBase() {
 
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	this->pstStep = counter;
+	if (getComAction() == CommunicationAction::NOTHING) {
+	    return HasReturnvaluesIF::RETURN_OK;
+	}
 
-	if (getComAction() == SEND_WRITE) {
+	if (getComAction() == CommunicationAction::PERFORM_OPERATION) {
 		cookieInfo.state = COOKIE_UNUSED;
 		readCommandQueue();
 		doStateMachine();
@@ -88,21 +91,21 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		return RETURN_OK;
 	}
 	switch (getComAction()) {
-	case SEND_WRITE:
-		if ((cookieInfo.state == COOKIE_UNUSED)) {
+	case CommunicationAction::SEND_WRITE:
+		if (cookieInfo.state == COOKIE_UNUSED) {
+		    // if no external command was specified, build internal command.
 			buildInternalCommand();
 		}
 		doSendWrite();
 		break;
-	case GET_WRITE:
+	case CommunicationAction::GET_WRITE:
 		doGetWrite();
 		break;
-	case SEND_READ:
+	case CommunicationAction::SEND_READ:
 		doSendRead();
 		break;
-	case GET_READ:
+	case CommunicationAction::GET_READ:
 		doGetRead();
-		cookieInfo.state = COOKIE_UNUSED;
 		break;
 	default:
 		break;
@@ -821,24 +824,27 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 }
 
 //Default child implementations
-DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
+DeviceHandlerIF::CommunicationAction DeviceHandlerBase::getComAction() {
 	switch (pstStep) {
 	case 0:
-		return SEND_WRITE;
+		return CommunicationAction::PERFORM_OPERATION;
 		break;
 	case 1:
-		return GET_WRITE;
-		break;
+	    return CommunicationAction::SEND_WRITE;
+	    break;
 	case 2:
-		return SEND_READ;
+		return CommunicationAction::GET_WRITE;
 		break;
 	case 3:
-		return GET_READ;
+		return CommunicationAction::SEND_READ;
+		break;
+	case 4:
+		return CommunicationAction::GET_READ;
 		break;
 	default:
 		break;
 	}
-	return NOTHING;
+	return CommunicationAction::NOTHING;
 }
 
 MessageQueueId_t DeviceHandlerBase::getCommandQueue() const {
@@ -1129,19 +1135,6 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
-//		if (mode != MODE_OFF) {
-//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-//		} else {
-//			result = switchCookieChannel(
-//					DeviceHandlerMessage::getIoBoardObjectId(message));
-//			if (result == RETURN_OK) {
-//				replyReturnvalueToCommand(RETURN_OK);
-//			} else {
-//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
-//			}
-//		}
-//		return RETURN_OK;
 	case DeviceHandlerMessage::CMD_RAW:
 		if ((mode != MODE_RAW)) {
 			DeviceHandlerMessage::clear(message);
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index f809953e9..e0e2b2d5f 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -819,7 +819,7 @@ protected:
 	 * @return The Rmap action to execute in this step
 	 */
 
-	virtual CommunicationAction_t getComAction();
+	virtual CommunicationAction getComAction();
 
 	/**
 	 * Build the device command to send for raw mode.
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index e3fa3b882..fcf501287 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -131,7 +131,8 @@ public:
 	 *
 	 * This is used by the child class to tell the base class what to do.
 	 */
-	enum CommunicationAction_t: uint8_t {
+	enum CommunicationAction: uint8_t {
+	    PERFORM_OPERATION,
 		SEND_WRITE,//!< Send write
 		GET_WRITE, //!< Get write
 		SEND_READ, //!< Send read

From dbb394f761a147aae4a2fb722cb7ffc264452079 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 3 Sep 2020 00:22:16 +0200
Subject: [PATCH 0697/1774] new member to store last step

---
 devicehandlers/DeviceHandlerBase.cpp | 5 +++++
 devicehandlers/DeviceHandlerBase.h   | 1 +
 2 files changed, 6 insertions(+)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 7cba6dba8..ffb94359c 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -72,6 +72,8 @@ DeviceHandlerBase::~DeviceHandlerBase() {
 
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	this->pstStep = counter;
+	this->lastStep = this->pstStep;
+
 	if (getComAction() == CommunicationAction::NOTHING) {
 	    return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -86,10 +88,13 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		hkSwitcher.performOperation();
 		hkManager.performHkOperation();
 		performOperationHook();
+		return RETURN_OK;
 	}
+
 	if (mode == MODE_OFF) {
 		return RETURN_OK;
 	}
+
 	switch (getComAction()) {
 	case CommunicationAction::SEND_WRITE:
 		if (cookieInfo.state == COOKIE_UNUSED) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index e0e2b2d5f..8c4fb04ec 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -555,6 +555,7 @@ protected:
 
 	/** This is the counter value from performOperation(). */
 	uint8_t pstStep = 0;
+	uint8_t lastStep = 0;
 	uint32_t pstIntervalMs = 0;
 
 	/**

From 403d83f32cedcd6c655e95e25e4f421df9e94971 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 3 Sep 2020 13:01:14 +0200
Subject: [PATCH 0698/1774] removed commented out code

---
 devicehandlers/DeviceHandlerBase.cpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 820a2cceb..45cf37815 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1129,19 +1129,6 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
-//		if (mode != MODE_OFF) {
-//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-//		} else {
-//			result = switchCookieChannel(
-//					DeviceHandlerMessage::getIoBoardObjectId(message));
-//			if (result == RETURN_OK) {
-//				replyReturnvalueToCommand(RETURN_OK);
-//			} else {
-//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
-//			}
-//		}
-//		return RETURN_OK;
 	case DeviceHandlerMessage::CMD_RAW:
 		if ((mode != MODE_RAW)) {
 			DeviceHandlerMessage::clear(message);

From 31c16382fc5d40cccc9ca3a58a8a60cef5d7a04f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 14:28:43 +0200
Subject: [PATCH 0699/1774] took over changed for fixed slot sequence

---
 osal/FreeRTOS/FixedTimeslotTask.h |  8 +--
 tasks/FixedSequenceSlot.cpp       |  4 +-
 tasks/FixedSequenceSlot.h         |  9 ++--
 tasks/FixedSlotSequence.cpp       | 29 ++++++++---
 tasks/FixedSlotSequence.h         | 81 ++++++++++++++++++-------------
 5 files changed, 80 insertions(+), 51 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index c46de5b7b..7d2cdb703 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+#ifndef FSFW_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+#define FSFW_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 
-#include "../../osal/FreeRTOS/FreeRTOSTaskIF.h"
+#include "FreeRTOSTaskIF.h"
 #include "../../tasks/FixedSlotSequence.h"
 #include "../../tasks/FixedTimeslotTaskIF.h"
 #include "../../tasks/Typedef.h"
@@ -98,4 +98,4 @@ protected:
 	void handleMissedDeadline();
 };
 
-#endif /* POLLINGTASK_H_ */
+#endif /* FSFW_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_ */
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index d7aeff0af..f5d82178d 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -1,5 +1,5 @@
-#include "../objectmanager/SystemObjectIF.h"
-#include "../tasks/FixedSequenceSlot.h"
+#include "FixedSequenceSlot.h"
+#include "PeriodicTaskIF.h"
 #include <cstddef>
 
 FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
diff --git a/tasks/FixedSequenceSlot.h b/tasks/FixedSequenceSlot.h
index 151173e96..1744ec198 100644
--- a/tasks/FixedSequenceSlot.h
+++ b/tasks/FixedSequenceSlot.h
@@ -1,8 +1,9 @@
-#ifndef FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
-#define FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
+#ifndef FSFW_TASKS_FIXEDSEQUENCESLOT_H_
+#define FSFW_TASKS_FIXEDSEQUENCESLOT_H_
 
+#include "ExecutableObjectIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../tasks/ExecutableObjectIF.h"
+
 class PeriodicTaskIF;
 
 /**
@@ -56,4 +57,4 @@ public:
 };
 
 
-#endif /* FIXEDSEQUENCESLOT_H_ */
+#endif /* FSFW_TASKS_FIXEDSEQUENCESLOT_H_ */
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index 59859ce51..e5db4301e 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -1,5 +1,5 @@
+#include "FixedSlotSequence.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tasks/FixedSlotSequence.h"
 #include <cstdlib>
 
 FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
@@ -91,21 +91,31 @@ void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
-		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
+		sif::error << "FixedSlotSequence::checkSequence:"
+				<< " Slot list is empty!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	uint32_t count = 0;
+	if(customCheckFunction != nullptr) {
+		ReturnValue_t result = customCheckFunction(slotList);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			// Continue for now but print error output.
+			sif::error << "FixedSlotSequence::checkSequence:"
+					<< " Custom check failed!" << std::endl;
+		}
+	}
+
+	uint32_t errorCount = 0;
 	uint32_t time = 0;
 	for(const auto& slot: slotList) {
 		if (slot.executableObject == nullptr) {
-			count++;
+			errorCount++;
 		}
 		else if (slot.pollingTimeMs < time) {
-			sif::error << "FixedSlotSequence::initialize: Time: "
+			sif::error << "FixedSlotSequence::checkSequence: Time: "
 					<< slot.pollingTimeMs << " is smaller than previous with "
 					<< time << std::endl;
-			count++;
+			errorCount++;
 		}
 		else {
 			// All ok, print slot.
@@ -117,7 +127,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 	}
 	//sif::info << "Number of elements in slot list: "
 	//	   << slotList.size() << std::endl;
-	if (count > 0) {
+	if (errorCount > 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
@@ -145,3 +155,8 @@ ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
+
+void FixedSlotSequence::addCustomCheck(ReturnValue_t
+		(*customCheckFunction)(const SlotList&)) {
+	this->customCheckFunction = customCheckFunction;
+}
diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 1140dd254..19a05f210 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -1,26 +1,30 @@
-#ifndef FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
-#define FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
+#ifndef FSFW_TASKS_FIXEDSLOTSEQUENCE_H_
+#define FSFW_TASKS_FIXEDSLOTSEQUENCE_H_
 
+#include "FixedSequenceSlot.h"
 #include "../objectmanager/SystemObject.h"
-#include "../tasks/FixedSequenceSlot.h"
 
 #include <set>
 
 /**
- * @brief	This class is the representation of a Polling Sequence Table in software.
+ * @brief	This class is the representation of a
+ * 			Polling Sequence Table in software.
  * @details
  * The FixedSlotSequence object maintains the dynamic execution of
- * device handler objects.
+ * objects with stricter timing requirements for the FixedTimeslotTask.
  *
- * The main idea is to create a list of device handlers, to announce all
- * handlers to thepolling sequence and to maintain a list of
- * polling slot objects. This slot list represents the Polling Sequence Table
- * in software.
+ * The main idea is to create a list of executable objects (for example
+ * device handlers), to announce all handlers to the polling sequence and to
+ * maintain a list of polling slot objects.
+ * This slot list represents the Polling Sequence Table in software.
  *
  * Each polling slot contains information to indicate when and
- * which device handler shall be executed within a given polling period.
- * The sequence is then executed by iterating through this slot list.
- * Handlers are invoking by calling a certain function stored in the handler list.
+ * which executable object shall be executed within a given polling period.
+ * When adding a slot, a pointer to the executing task, a pointer to the
+ * executable object and a step number can be passed. The step number will be
+ * passed to the periodic handler.
+ * The sequence is executed by iterating through the slot sequence and
+ * executing the executable object in the correct timeslot.
  */
 class FixedSlotSequence {
 public:
@@ -29,41 +33,44 @@ public:
 
 	/**
 	 * @brief	The constructor of the FixedSlotSequence object.
-	 *
-	 * @details	The constructor takes two arguments, the period length and the init function.
-	 *
 	 * @param	setLength	The period length, expressed in ms.
 	 */
 	FixedSlotSequence(uint32_t setLengthMs);
 
 	/**
 	 * @brief	The destructor of the FixedSlotSequence object.
-	 *
-	 * @details	The destructor frees all allocated memory by iterating through the slotList
-	 *  		and deleting all allocated resources.
+	 * @details
+	 * The destructor frees all allocated memory by iterating through the
+	 * slotList and deleting all allocated resources.
 	 */
 	virtual ~FixedSlotSequence();
 
 	/**
 	 * @brief	This is a method to add an PollingSlot object to slotList.
 	 *
-	 * @details	Here, a polling slot object is added to the slot list. It is appended
-	 * 			to the end of the list. The list is currently NOT reordered.
-	 * 			Afterwards, the iterator current is set to the beginning of the list.
-	 * 	@param Object ID of the object to add
-	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
-	 * 				   will be called inside the slot period.
-	 * 	@param setSequenceId ID which can be used to distinguish
-	 * 	                     different task operations
+	 * @details
+	 * Here, a polling slot object is added to the slot list. It is appended
+	 * to the end of the list. The list is currently NOT reordered.
+	 * Afterwards, the iterator current is set to the beginning of the list.
+	 * 	@param handlerId ID of the object to add
+	 * 	@param setTime
+	 * 	Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
+	 * 	will be called inside the slot period.
+	 * 	@param setSequenceId
+	 * 	ID which can be used to distinguish different task operations. This
+	 * 	value will be passed to the executable function.
 	 * 	@param
 	 * 	@param
 	 */
 	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
-			ExecutableObjectIF* executableObject, PeriodicTaskIF* executingTask);
+			ExecutableObjectIF* executableObject,
+			PeriodicTaskIF* executingTask);
 
 	/**
-	 * Checks if the current slot shall be executed immediately after the one before.
-	 * This allows to distinguish between grouped and not grouped handlers.
+	 * @brief	Checks if the current slot shall be executed immediately
+	 * 			after the one before.
+	 * @details
+	 * This allows to distinguish between grouped and separated handlers.
 	 * @return 	- @c true if the slot has the same polling time as the previous
 	 * 			- @c false else
 	 */
@@ -128,12 +135,18 @@ public:
 	 * @brief   Check and initialize slot list.
 	 * @details
 	 * Checks if timing is ok (must be ascending) and if all handlers were found.
-	 * Also calls any initialization steps which are required after task
-	 * creation.
 	 * @return
 	 */
 	ReturnValue_t checkSequence() const;
 
+	void addCustomCheck(ReturnValue_t (*customCheckFunction)(const SlotList &));
+
+	/**
+	 * @brief 	Perform any initialization steps required after the executing
+	 * 			task has been created. This function should be called from the
+	 * 			executing task!
+	 * @return
+	 */
 	ReturnValue_t intializeSequenceAfterTaskCreation() const;
 
 protected:
@@ -151,9 +164,9 @@ protected:
 	 */
 	SlotList slotList;
 
-	uint32_t lengthMs;
+	ReturnValue_t (*customCheckFunction)(const SlotList&) = nullptr;
 
-	bool isEmpty = false;
+	uint32_t lengthMs;
 };
 
-#endif /* FIXEDSLOTSEQUENCE_H_ */
+#endif /* FSFW_TASKS_FIXEDSLOTSEQUENCE_H_ */

From 6980245c984c69f052c8d1ba2ad1c5c240f50c56 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 14:30:04 +0200
Subject: [PATCH 0700/1774] added line break

---
 osal/linux/FixedTimeslotTask.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index b634b4cf7..cffdd1c51 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -63,6 +63,7 @@ void FixedTimeslotTask::taskFunctionality() {
 	}
 
 	pst.intializeSequenceAfterTaskCreation();
+
 	//The start time for the first entry is read.
 	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
 	uint64_t interval = pst.getIntervalToNextSlotMs();

From 9d1f292af0f2973f595b0db09957a45a94782662 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 14:32:32 +0200
Subject: [PATCH 0701/1774] changed taken over

---
 osal/linux/FixedTimeslotTask.cpp | 2 +-
 osal/linux/FixedTimeslotTask.h   | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index cffdd1c51..247a34ed8 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -1,5 +1,5 @@
+#include "FixedTimeslotTask.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/FixedTimeslotTask.h"
 
 #include <limits.h>
 
diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 0148922dd..5c5c18148 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -1,9 +1,9 @@
-#ifndef FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
+#ifndef FSFW_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
+#define FSFW_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
 
+#include "PosixThread.h"
 #include "../../tasks/FixedTimeslotTaskIF.h"
 #include "../../tasks/FixedSlotSequence.h"
-#include "../../osal/linux/PosixThread.h"
 #include <pthread.h>
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
@@ -74,4 +74,4 @@ private:
 	bool started;
 };
 
-#endif /* FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */
+#endif /* FSFW_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */

From 94b45d7407bd6413926184e8ec8f746fda648cfe Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 14:49:27 +0200
Subject: [PATCH 0702/1774] changed taken over

---
 osal/linux/PeriodicPosixTask.cpp | 35 +++++++++++++++++---------------
 osal/linux/PeriodicPosixTask.h   |  4 ++--
 2 files changed, 21 insertions(+), 18 deletions(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index bbf33b01d..3c1df6bb1 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -1,8 +1,7 @@
 #include "../../tasks/ExecutableObjectIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/PeriodicPosixTask.h"
-
 #include <errno.h>
+#include "PeriodicPosixTask.h"
 
 PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
 		size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
@@ -26,14 +25,14 @@ 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;
+		sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+				<< " it implements ExecutableObjectIF!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
 	newObject->setTaskIF(this);
 
-	return newObject->initializeAfterTaskCreation();
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
@@ -49,27 +48,31 @@ ReturnValue_t PeriodicPosixTask::startTask(void) {
 }
 
 void PeriodicPosixTask::taskFunctionality(void) {
-	if(!started){
+	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){
-				//sif::error << "PeriodicPosixTask " << name << ": Deadline "
-				//		"missed." << std::endl;
+			int status = pthread_getname_np(pthread_self(), name, sizeof(name));
+			if(status == 0) {
+				sif::error << "PeriodicPosixTask " << name << ": Deadline "
+						"missed." << std::endl;
 			}
 			else {
-				//sif::error << "PeriodicPosixTask X: Deadline missed. " <<
-				//		status << std::endl;
+				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
+						status << std::endl;
 			}
 			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 38825bbf3..ffee236bc 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -3,7 +3,7 @@
 
 #include "../../tasks/PeriodicTaskIF.h"
 #include "../../objectmanager/ObjectManagerIF.h"
-#include "../../osal/linux/PosixThread.h"
+#include "PosixThread.h"
 #include "../../tasks/ExecutableObjectIF.h"
 #include <vector>
 
@@ -32,7 +32,7 @@ public:
 	 * 			The address of the task object is passed as an argument
 	 * 			to the system call.
 	 */
-	ReturnValue_t startTask(void) override;
+	ReturnValue_t startTask() override;
 	/**
 	 * Adds an object to the list of objects to be executed.
 	 * The objects are executed in the order added.

From f4a50677751b01417a476dc1f309b5074e337601 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 14:53:27 +0200
Subject: [PATCH 0703/1774] update fw class Ids

---
 returnvalues/FwClassIds.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 12877b404..781320e3f 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -67,7 +67,7 @@ enum {
 	DLE_ENCODER, //DLEE 61
 	PUS_PARSER, //PUSP 62
 	SERIAL_ANALYZER, //SERA 63
-	PUS_SERVICE_9,
+	PUS_SERVICE_9, // PUS9 64
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 147ab94149e2dff309ea628b5d77e74ed9a58208 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:13:32 +0200
Subject: [PATCH 0704/1774] include guard improvements

---
 container/SharedRingBuffer.cpp | 2 +-
 container/SharedRingBuffer.h   | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 490988e55..800e75d37 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -1,4 +1,4 @@
-#include "../container/SharedRingBuffer.h"
+#include "SharedRingBuffer.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
 
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 394dcaaa5..80c068b3d 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#ifndef FSFW_CONTAINER_SHAREDRINGBUFFER_H_
+#define FSFW_CONTAINER_SHAREDRINGBUFFER_H_
 
-#include "../container/SimpleRingBuffer.h"
+#include "SimpleRingBuffer.h"
 #include "../ipc/MutexIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../timemanager/Clock.h"
@@ -65,4 +65,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
+#endif /* FSFW_CONTAINER_SHAREDRINGBUFFER_H_ */

From fff0131c9b27b25d8705ce42837f432035b51741 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:20:07 +0200
Subject: [PATCH 0705/1774] taken over changes

---
 health/HealthHelper.cpp |  2 +-
 health/HealthHelper.h   | 13 +++++++------
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index 61718f993..cced11d9b 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -1,4 +1,4 @@
-#include "../health/HealthHelper.h"
+#include "HealthHelper.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index d8b81ca96..d1f1945c2 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -1,11 +1,12 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHHELPER_H_
-#define FRAMEWORK_HEALTH_HEALTHHELPER_H_
+#ifndef FSFW_HEALTH_HEALTHHELPER_H_
+#define FSFW_HEALTH_HEALTHHELPER_H_
+
+#include "HasHealthIF.h"
+#include "HealthMessage.h"
+#include "HealthTableIF.h"
 
 #include "../events/EventManagerIF.h"
 #include "../events/EventReportingProxyIF.h"
-#include "../health/HasHealthIF.h"
-#include "../health/HealthMessage.h"
-#include "../health/HealthTableIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -118,4 +119,4 @@ private:
 	void handleSetHealthCommand(CommandMessage *message);
 };
 
-#endif /* HEALTHHELPER_H_ */
+#endif /* FSFW_HEALTH_HEALTHHELPER_H_ */

From cfa952d9829b4b686ab615b5383c5fa59de285d1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:33:36 +0200
Subject: [PATCH 0706/1774] hybrid iterator same to FSFW

---
 container/HybridIterator.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index 630bae28d..8d020cb93 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -1,8 +1,8 @@
 #ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
 #define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
 
-#include "../container/ArrayList.h"
-#include "../container/SinglyLinkedList.h"
+#include "ArrayList.h"
+#include "SinglyLinkedList.h"
 
 template<typename T, typename count_t = uint8_t>
 class HybridIterator: public LinkedElement<T>::Iterator,

From be89e7ebb73f273077c4211eb01078e01d8f537a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:36:53 +0200
Subject: [PATCH 0707/1774] taken over from upstream with little tweak

---
 serialize/SerializeIF.h | 81 ++++++++++++++++++++++++++++-------------
 1 file changed, 55 insertions(+), 26 deletions(-)

diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 6d5a0dda4..3c0540f92 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -1,34 +1,19 @@
-#ifndef SERIALIZEIF_H_
-#define SERIALIZEIF_H_
+#ifndef FSFW_SERIALIZE_SERIALIZEIF_H_
+#define FSFW_SERIALIZE_SERIALIZEIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
 
 /**
  * @defgroup serialize Serialization
- * Contains serialisation services.
+ * Contains serialization services.
  */
 
 /**
- * @brief An interface for alle classes which require
- *        translation of objects data into data streams and vice-versa.
+ * @brief 	Translation of objects into data streams and from data streams.
  * @details
- * If the target architecture is little endian (e.g. ARM), any data types
- * created might  have the wrong endianess if they are to be used for the FSFW.
- * Depending on the system architecture, endian correctness must be assured,
- * This is important for incoming and outgoing data. The internal handling
- * of data should be performed in the native system endianness.
- * There are three ways to copy data (with different options to ensure
- * endian correctness):
- *
- *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
- *      the endian flag)
- *   2. Perform a bitshift operation (with correct order)
- *   3. @c memcpy (with @c EndianSwapper if necessary)
- *
- * When serializing for downlink, the packets are generally serialized
- * assuming big endian data format like seen in TmPacketStored.cpp for example.
- *
+ * Also provides options to convert from/to data with different endianness.
+ * variables.
  * @ingroup serialize
  */
 class SerializeIF {
@@ -38,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
+	 * 		- @¢ 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_ */

From 37764f7ca710f3ae0ab3b41b7e6b72ea6ba3a14b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:39:17 +0200
Subject: [PATCH 0708/1774] include guard fixed

---
 serialize/EndianConverter.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index f981751d0..c888a905a 100644
--- a/serialize/EndianConverter.h
+++ b/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>
@@ -121,4 +121,4 @@ public:
 	}
 };
 
-#endif /* ENDIANSWAPPER_H_ */
+#endif /* FSFW_SERIALIZE_ENDIANCONVERTER_H_ */

From 0d69e9beca4b0f35b2c0aea86d5c6df983e9ccaa Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:42:15 +0200
Subject: [PATCH 0709/1774] taken over serial uffer adapter from upstream

---
 serialize/SerialBufferAdapter.cpp | 258 +++++++++++++++---------------
 serialize/SerialBufferAdapter.h   | 156 +++++++++---------
 2 files changed, 207 insertions(+), 207 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 1c11afd4b..812cd34b2 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,129 +1,129 @@
-#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>;
-
+#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>;
+
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 9a89e18ba..c3dfcd8fb 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -1,78 +1,78 @@
-#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_ */
+#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_ */

From f2f7a5de87b728868e13d96765846e50349a789f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:47:33 +0200
Subject: [PATCH 0710/1774] taken over convergence changes

---
 serialize/SerialFixedArrayListAdapter.h | 30 ++++++++++---------------
 1 file changed, 12 insertions(+), 18 deletions(-)

diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index c866df868..70ca987ac 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -1,8 +1,8 @@
-#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
-#define SERIALFIXEDARRAYLISTADAPTER_H_
+#ifndef FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_
+#define FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_
 
+#include "SerialArrayListAdapter.h"
 #include "../container/FixedArrayList.h"
-#include "../serialize/SerialArrayListAdapter.h"
 
 /**
  * @brief 	This adapter provides an interface for SerializeIF to serialize and
@@ -13,18 +13,11 @@
  * The sequence of objects is defined in the constructor by
  * using the setStart and setNext functions.
  *
- *  - Buffers with a size header inside that class can be declared with
- *    @code
- *    SerialFixedArrayListAdapter<BUFFER_TYPE,
- *          MAX_SIZE, count_t> mySerialFixedArrayList(...).
- *    @endcode
- *
- *  - MAX_SIZE: specifies the maximum allowed number of elements
- *    in FixedArrayList.
- *  - BUFFER_TYPE: specifies the data type of the buffer
- *  - count_t: specifies the type/size of the length field
- *    which defaults to one byte.
- *
+ * @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 BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
@@ -33,7 +26,7 @@ class SerialFixedArrayListAdapter :
 		public SerializeIF {
 public:
 	/**
-	 * Constructor Arguments are forwarded to FixedArrayList constructor.
+	 * Constructor arguments are forwarded to FixedArrayList constructor.
 	 * Refer to the fixed array list constructors for different options.
 	 * @param args
 	 */
@@ -49,7 +42,8 @@ public:
     }
 
     size_t getSerializedSize() const {
-        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
+        		getSerializedSize(this);
     }
 
     ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
@@ -60,4 +54,4 @@ public:
 
 };
 
-#endif /* SERIALFIXEDARRAYLISTADAPTER_H_ */
+#endif /* FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_ */

From 305d8ef84079a9e0e0861b4708147e3b562d2e10 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:56:52 +0200
Subject: [PATCH 0711/1774] taken over changes

---
 serialize/SerializeAdapter.h | 71 +++++++-----------------------------
 1 file changed, 14 insertions(+), 57 deletions(-)

diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 3e84bdf95..24f6111ef 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -1,11 +1,12 @@
-#ifndef SERIALIZEADAPTER_H_
-#define SERIALIZEADAPTER_H_
+#ifndef FSFW_SERIALIZE_SERIALIZEADAPTER_H_
+#define FSFW_SERIALIZE_SERIALIZEADAPTER_H_
+
+#include "EndianConverter.h"
+#include "SerializeIF.h"
 
 #include "../container/IsDerivedFrom.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/EndianConverter.h"
-#include "../serialize/SerializeIF.h"
-#include <type_traits>
+#include <cstring>
 
  /**
  * @brief These adapters provides an interface to use the SerializeIF functions
@@ -13,56 +14,11 @@
  * 		  serialization of classes with different multiple different data types
  * 		  into buffers and vice-versa.
  * @details
- *
- * A report class is converted into a TM buffer. The report class implements a
- * serialize functions and calls the AutoSerializeAdapter::serialize function
- * repeatedly on all object data fields. The getSerializedSize function is
- * implemented by calling the AutoSerializeAdapter::getSerializedSize function
- * repeatedly on all data fields.
- *
- * The AutoSerializeAdapter functions can also be used as an alternative to
- * memcpy to retrieve data out of a buffer directly into a class variable
- * with data type T while being able to specify endianness. The boolean
- * bigEndian specifies whether an endian swap is performed on the data before
- * serialization or deserialization.
- *
- * There are three ways to retrieve data out of a buffer to be used in the FSFW
- * to use regular aligned (big endian) data. Examples:
- *
- *   1. Use the AutoSerializeAdapter::deSerialize function
- *		The pointer *buffer will be incremented automatically by the typeSize
- *		 of the object, so this function can be called on &buffer repeatedly
- *		without adjusting pointer position. Set bigEndian parameter to true
- *		to perform endian swapping, if necessary
- *		@code
- *   	uint16_t data;
- *   	int32_t dataLen = sizeof(data);
- *   	ReturnValue_t result =
- *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
- *   	@endcode
- *
- *   2. Perform a bitshift operation. Watch for for endianness:
- *		@code
- *   	uint16_t data;
- *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
- *   	data = EndianSwapper::swap(data); //optional, or swap order above
- *   	@endcode
- *
- *   3. memcpy or std::copy can also be used, but watch out if system
- *   	endianness is different from required data endianness.
- *   	Perform endian-swapping if necessary.
- *		@code
- *   	uint16_t data;
- *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
- *   	data = EndianSwapper::swap(data); //optional
- *   	@endcode
- *
- * When serializing for downlink, the packets are generally serialized assuming
- * big endian data format like seen in TmPacketStored.cpp for example.
+ * The correct serialization or deserialization function is chosen at
+ * compile time with template type deduction.
  *
  * @ingroup serialize
  */
-
 class SerializeAdapter {
 public:
 	template<typename T>
@@ -88,9 +44,10 @@ private:
 	class InternalSerializeAdapter {
 	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
@@ -108,7 +65,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;
@@ -122,7 +79,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);
@@ -156,7 +113,7 @@ private:
 				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);

From 721b981df2df5ea852d0ad8a0381b488099f2d32 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 16:01:18 +0200
Subject: [PATCH 0712/1774] changes taken over

---
 serialize/SerialLinkedListAdapter.h | 51 +++++++++++++----------------
 1 file changed, 23 insertions(+), 28 deletions(-)

diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 987fa70ea..430a21ac2 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -1,17 +1,10 @@
-/**
- * @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 "../serialize/SerializeAdapter.h"
-#include "../serialize/SerializeElement.h"
-#include "../serialize/SerializeIF.h"
-//This is where we need the SerializeAdapter!
+#include "SerializeAdapter.h"
+#include "SerializeElement.h"
+#include "SerializeIF.h"
 
  /**
  * @brief  	Implement the conversion of object data to data streams
@@ -22,7 +15,7 @@
  *     SerializeElement<element_type> members inside the class
  *     implementing this adapter.
  *   - The element type can also be a SerialBufferAdapter to
- *     de-/serialize buffers with a known size
+ *     de-/serialize buffers.
  *   - The element type can also be a SerialFixedArrayListAdapter to
  *     de-/serialize buffers with a size header, which is scanned automatically.
  *
@@ -37,21 +30,12 @@
  *    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:
-	/**
-	 * 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;
 
 	SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
 			bool printCount = false) :
@@ -85,7 +69,7 @@ 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();
@@ -104,7 +88,7 @@ public:
 
 	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();
 		}
@@ -114,20 +98,31 @@ public:
 
 	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;
 	}
 
+	/**
+	 * 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_ */

From 1803030640f2201a006a3e3e30e8029cf001464b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 16:04:11 +0200
Subject: [PATCH 0713/1774] taken over serialize element changes

---
 serialize/SerializeElement.h | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 8c3472b2c..470802927 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -1,8 +1,8 @@
-#ifndef SERIALIZEELEMENT_H_
-#define SERIALIZEELEMENT_H_
+#ifndef FSFW_SERIALIZE_SERIALIZEELEMENT_H_
+#define FSFW_SERIALIZE_SERIALIZEELEMENT_H_
 
+#include "SerializeAdapter.h"
 #include "../container/SinglyLinkedList.h"
-#include "../serialize/SerializeAdapter.h"
 #include <utility>
 
 /**
@@ -12,7 +12,7 @@
  * Used by declaring any arbitrary datatype with SerializeElement<T> myVariable,
  * inside a SerialLinkedListAdapter implementation and setting the sequence
  * of objects with setNext() and setStart().
- * Serilization and Deserialization is then performed automatically in
+ * Serialization and Deserialization is then performed automatically in
  * specified sequence order.
  * @ingroup serialize
  */
@@ -27,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,
@@ -52,9 +52,12 @@ public:
 		entry = newValue;
 		return *this;
 	}
+
 	T* operator->() {
 		return &entry;
 	}
+
+	T entry;
 };
 
-#endif /* SERIALIZEELEMENT_H_ */
+#endif /* FSFW_SERIALIZE_SERIALIZEELEMENT_H_ */

From faeeca8707857dc75451f06fb78e1c5bffd22b63 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 16:07:54 +0200
Subject: [PATCH 0714/1774] seiralize folder converged

---
 serialize/SerialArrayListAdapter.h | 33 +++++++++++++-----------------
 1 file changed, 14 insertions(+), 19 deletions(-)

diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 69afdd4af..daa3fe7f1 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -1,18 +1,13 @@
-/**
- * @file	SerialArrayListAdapter.h
- * @brief	This file defines the SerialArrayListAdapter class.
- * @date	22.07.2014
- * @author	baetz
- */
-#ifndef SERIALARRAYLISTADAPTER_H_
-#define SERIALARRAYLISTADAPTER_H_
+#ifndef FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_
+#define FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_
 
+#include "SerializeIF.h"
 #include "../container/ArrayList.h"
-#include "../serialize/SerializeIF.h"
 #include <utility>
 
 /**
  * Also serializes length field !
+ * @author 	baetz
  * @ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
@@ -26,8 +21,9 @@ public:
 		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
 	}
 
-	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) {
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list,
+			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;
@@ -59,14 +55,19 @@ public:
 		return deSerialize(adaptee, buffer, size, streamEndianness);
 	}
 
-	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
+			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;
+		}
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
+
 		list->size = tempSize;
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
@@ -78,14 +79,8 @@ public:
 		return result;
 	}
 
-
-	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
-		list->swapArrayListEndianness();
-	}
 private:
 	ArrayList<T, count_t> *adaptee;
 };
 
-
-
-#endif /* SERIALARRAYLISTADAPTER_H_ */
+#endif /* FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_ */

From 05814dc805e3901aecdfd353c6e63712e9ed2c27 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 15:58:53 +0200
Subject: [PATCH 0715/1774] added way to start DH immediately, bugfix in event
 manager

---
 devicehandlers/DeviceHandlerBase.cpp          |  8 +++
 devicehandlers/DeviceHandlerBase.h            | 52 +++++++++++--------
 .../DeviceHandlerFailureIsolation.cpp         |  8 +++
 events/EventManagerIF.h                       | 22 +++++---
 modes/HasModesIF.h                            | 12 ++---
 5 files changed, 66 insertions(+), 36 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 45cf37815..86fd01b1d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1385,6 +1385,10 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
         pstIntervalMs = executingTask->getPeriodMs();
     }
     this->hkManager.initializeAfterTaskCreation();
+
+    if(setStartupImmediately) {
+        startTransition(MODE_ON, SUBMODE_NONE);
+    }
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -1402,6 +1406,10 @@ object_id_t DeviceHandlerBase::getObjectId() const {
     return SystemObject::getObjectId();
 }
 
+void DeviceHandlerBase::setStartUpImmediately() {
+    this->setStartupImmediately = true;
+}
+
 dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
     return pstIntervalMs;
 }
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index f809953e9..c3748172d 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -104,6 +104,16 @@ public:
 	void setHkDestination(object_id_t hkDestination);
 	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
 			uint32_t thermalRequestPoolId);
+	/**
+	 * @brief   Helper function to easy device handler development.
+	 * This will instruct the transition to MODE_ON immediately
+	 * (leading to doStartUp() being called for the transition to the ON mode),
+	 * so external mode commanding is not necessary anymore.
+	 *
+	 * This has to be called before the task is started!
+	 * (e.g. in the task factory)
+	 */
+	void setStartUpImmediately();
 
 	/**
 	 * @brief 	This function is the device handler base core component and is
@@ -149,6 +159,14 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t initialize();
+
+	/**
+	 * @brief   Intialization steps performed after all tasks have been created.
+	 *          This function will be called by the executing task.
+	 * @return
+	 */
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+
 	/** Destructor. */
 	virtual ~DeviceHandlerBase();
 
@@ -945,14 +963,17 @@ protected:
 
 	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
 			uint32_t *msToReachTheMode);
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-	virtual void setToExternalControl();
-	virtual void announceMode(bool recursive);
+
+	/* HasModesIF overrides */
+	virtual void startTransition(Mode_t mode, Submode_t submode) override;
+	virtual void setToExternalControl() override;
+	virtual void announceMode(bool recursive) override;
 
 	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
 	/**
-	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper" faster about executed events.
+	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper"
+	 * faster about executed events.
 	 * This is a bit sneaky, but improves responsiveness of the device FDIR.
 	 * @param event	The event to be thrown
 	 * @param parameter1	Optional parameter 1
@@ -1044,6 +1065,8 @@ private:
 	 */
 	uint32_t timeoutStart = 0;
 
+	bool setStartupImmediately = false;
+
 	/**
 	 * Delay for the current mode transition, used for time out
 	 */
@@ -1162,7 +1185,6 @@ private:
 	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
 			uint32_t *len);
 
-
 	/**
 	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
 	 */
@@ -1173,28 +1195,14 @@ private:
 	 */
 	void callChildStatemachine();
 
-	/**
-	 * Switches the channel of the cookie used for the communication
-	 *
-	 *
-	 * @param newChannel the object Id of the channel to switch to
-	 * @return
-	 *     - @c RETURN_OK when cookie was changed
-	 *     - @c RETURN_FAILED when cookies could not be changed,
-	 *          e.g. because the newChannel is not enabled
-	 *     - @c returnvalues of RMAPChannelIF::isActive()
-	 */
-	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
-
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
 	virtual DataSetIF* getDataSetHandle(sid_t sid) override;
 
-	void parseReply(const uint8_t* receivedData,
-	            size_t receivedDataLen);
-
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
+
+    void parseReply(const uint8_t* receivedData,
+                size_t receivedDataLen);
 };
 
 #endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 9fbe71d85..24fe15a03 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -247,6 +247,14 @@ bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
 		}
 		return true;
 	}
+
+	if (owner == nullptr) {
+	    // Configuration error.
+	    sif::error << "DeviceHandlerFailureIsolation::"
+	            << "isFdirInActionOrAreWeFaulty: Owner not set!" << std::endl;
+	    return false;
+	}
+
 	if (owner->getHealth() == HasHealthIF::FAULTY
 			|| owner->getHealth() == HasHealthIF::PERMANENT_FAULTY) {
 		//Ignore all events in case device is already faulty.
diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h
index f9ac420b3..253e6910c 100644
--- a/events/EventManagerIF.h
+++ b/events/EventManagerIF.h
@@ -1,10 +1,11 @@
 #ifndef EVENTMANAGERIF_H_
 #define EVENTMANAGERIF_H_
 
-#include "eventmatching/eventmatching.h"
 #include "EventMessage.h"
+#include "eventmatching/eventmatching.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
+#include "../ipc/MessageQueueIF.h"
 
 class EventManagerIF {
 public:
@@ -16,7 +17,8 @@ public:
 
 	virtual MessageQueueId_t getEventReportQueue() = 0;
 
-	virtual ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false) = 0;
+	virtual ReturnValue_t registerListener(MessageQueueId_t listener,
+	        bool forwardAllButSelected = false) = 0;
 	virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener,
 			EventId_t event) = 0;
 	virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
@@ -31,18 +33,22 @@ public:
 			bool reporterInverted = false) = 0;
 
 	static void triggerEvent(object_id_t reportingObject, Event event,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0, MessageQueueId_t sentFrom = 0) {
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0,
+			MessageQueueId_t sentFrom = 0) {
 		EventMessage message(event, reportingObject, parameter1, parameter2);
 		triggerEvent(&message, sentFrom);
 	}
-	static void triggerEvent(EventMessage* message, MessageQueueId_t sentFrom = 0) {
-		static MessageQueueId_t eventmanagerQueue = 0;
-		if (eventmanagerQueue == 0) {
+
+	static void triggerEvent(EventMessage* message,
+	        MessageQueueId_t sentFrom = 0) {
+		static MessageQueueId_t eventmanagerQueue = MessageQueueIF::NO_QUEUE;
+		if (eventmanagerQueue == MessageQueueIF::NO_QUEUE) {
 			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
 					objects::EVENT_MANAGER);
-			if (eventmanager != NULL) {
-				eventmanagerQueue = eventmanager->getEventReportQueue();
+			if (eventmanager == nullptr) {
+			    return;
 			}
+			eventmanagerQueue = eventmanager->getEventReportQueue();
 		}
 		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
 	}
diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h
index c3abaaaff..39a50c2a0 100644
--- a/modes/HasModesIF.h
+++ b/modes/HasModesIF.h
@@ -46,12 +46,12 @@ protected:
 			uint32_t *msToReachTheMode) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	virtual void startTransition(Mode_t mode, Submode_t submode) {
-	}
-	virtual void setToExternalControl() {
-	}
-	virtual void announceMode(bool recursive) {
-	}
+
+	virtual void startTransition(Mode_t mode, Submode_t submode) {}
+
+	virtual void setToExternalControl() {}
+
+	virtual void announceMode(bool recursive) {}
 };
 
 #endif /* HASMODESIF_H_ */

From 39b675cf9984a1b22c215979821073a81202b273 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 20:39:10 +0200
Subject: [PATCH 0716/1774] repairing host osal

---
 osal/host/FixedTimeslotTask.cpp |  7 +++++--
 osal/host/MessageQueue.cpp      | 10 ++++++----
 osal/host/MessageQueue.h        |  3 ++-
 osal/host/Mutex.cpp             |  7 +++----
 osal/host/Mutex.h               |  5 +++--
 osal/host/QueueMapManager.cpp   |  2 +-
 osal/host/SemaphoreFactory.cpp  |  3 ---
 7 files changed, 20 insertions(+), 17 deletions(-)

diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 1139badbd..1257eb16a 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -122,8 +122,11 @@ void FixedTimeslotTask::taskFunctionality() {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
         uint32_t slotTimeMs, int8_t executionStep) {
-    if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, this);
+    ExecutableObjectIF* executableObject = objectManager->
+            get<ExecutableObjectIF>(componentId);
+    if (executableObject!= nullptr) {
+        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep,
+                executableObject, this);
         return HasReturnvaluesIF::RETURN_OK;
     }
 
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 8a34282c9..598250845 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -61,7 +61,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	}
 	// not sure this will work..
 	//*message = std::move(messageQueue.front());
-	MutexHelper mutexLock(queueLock, 20);
+	MutexHelper mutexLock(queueLock, MutexIF::TimeoutType::WAITING, 20);
 	MessageQueueMessage* currentMessage = &messageQueue.front();
 	std::copy(currentMessage->getBuffer(),
 			currentMessage->getBuffer() + messageSize, message->getBuffer());
@@ -126,7 +126,8 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	}
 
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
-		MutexHelper mutexLock(targetQueue->queueLock, 20);
+		MutexHelper mutexLock(targetQueue->queueLock,
+		        MutexIF::TimeoutType::WAITING, 20);
 		// not ideal, works for now though.
 		MessageQueueMessage* mqmMessage =
 				dynamic_cast<MessageQueueMessage*>(message);
@@ -146,8 +147,9 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MessageQueue::lockQueue(dur_millis_t lockTimeout) {
-	return queueLock->lockMutex(lockTimeout);
+ReturnValue_t MessageQueue::lockQueue(MutexIF::TimeoutType timeoutType,
+        dur_millis_t lockTimeout) {
+	return queueLock->lockMutex(timeoutType, lockTimeout);
 }
 
 ReturnValue_t MessageQueue::unlockQueue() {
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
index 21a016630..97a9e4915 100644
--- a/osal/host/MessageQueue.h
+++ b/osal/host/MessageQueue.h
@@ -182,7 +182,8 @@ public:
 
 	bool isDefaultDestinationSet() const override;
 
-	ReturnValue_t lockQueue(dur_millis_t lockTimeout);
+	ReturnValue_t lockQueue(MutexIF::TimeoutType timeoutType,
+	        dur_millis_t lockTimeout);
 	ReturnValue_t unlockQueue();
 protected:
 	/**
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index 2718f2b99..8471cab80 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -1,10 +1,9 @@
-#include "../../osal/host/Mutex.h"
+#include "Mutex.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-const uint32_t MutexIF::POLLING = 0;
-const uint32_t MutexIF::BLOCKING = 0xffffffff;
+Mutex::Mutex() {}
 
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
 	if(timeoutMs == MutexIF::BLOCKING) {
 		mutex.lock();
 		locked = true;
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index 4461e5f2f..b755bc307 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -15,8 +15,9 @@
  */
 class Mutex : public MutexIF {
 public:
-	Mutex() = default;
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
+	Mutex();
+	ReturnValue_t lockMutex(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) override;
 	ReturnValue_t unlockMutex() override;
 
 	std::timed_mutex* getMutexHandle();
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 47687bc1a..a466c3f84 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -37,7 +37,7 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 
 MessageQueueIF* QueueMapManager::getMessageQueue(
 		MessageQueueId_t messageQueueId) const {
-	MutexHelper(mapLock, 50);
+	MutexHelper(MutexIF::TimeoutType::WAITING, mapLock, 50);
 	auto queueIter = queueMap.find(messageQueueId);
 	if(queueIter != queueMap.end()) {
 		return queueIter->second;
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index c354c47cf..b19b2c75a 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -3,9 +3,6 @@
 #include "../../osal/linux/CountingSemaphore.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = 0xFFFFFFFF;
-
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 
 SemaphoreFactory::SemaphoreFactory() {

From 80e60566d82c5a6ed35c91af6f3d6cc21866dd7f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:11:27 +0200
Subject: [PATCH 0717/1774] compiling and working again

---
 osal/host/FixedTimeslotTask.cpp | 9 ++++++---
 osal/host/FixedTimeslotTask.h   | 2 +-
 osal/host/QueueMapManager.cpp   | 2 +-
 timemanager/CCSDSTime.cpp       | 4 ++++
 4 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 1257eb16a..e78c974a4 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -90,9 +90,12 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 }
 
 void FixedTimeslotTask::taskFunctionality() {
+    pollingSeqTable.intializeSequenceAfterTaskCreation();
+
     // A local iterator for the Polling Sequence Table is created to
     // find the start time for the first entry.
-    FixedSlotSequence::SlotListIter slotListIter = pollingSeqTable.current;
+    auto slotListIter = pollingSeqTable.current;
+
     // Get start time for first entry.
     chron_ms interval(slotListIter->pollingTimeMs);
     auto currentStartTime {
@@ -124,7 +127,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
         uint32_t slotTimeMs, int8_t executionStep) {
     ExecutableObjectIF* executableObject = objectManager->
             get<ExecutableObjectIF>(componentId);
-    if (executableObject!= nullptr) {
+    if (executableObject != nullptr) {
         pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep,
                 executableObject, this);
         return HasReturnvaluesIF::RETURN_OK;
@@ -135,7 +138,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
     return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
     return pollingSeqTable.checkSequence();
 }
 
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index 3ea97b977..9985e2ee6 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -61,7 +61,7 @@ public:
     ReturnValue_t addSlot(object_id_t componentId,
                    uint32_t slotTimeMs, int8_t executionStep);
 
-    ReturnValue_t checkAndInitializeSequence() const;
+    ReturnValue_t checkSequence() const override;
 
     uint32_t getPeriodMs() const;
 
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index a466c3f84..6007e9f31 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -37,7 +37,7 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 
 MessageQueueIF* QueueMapManager::getMessageQueue(
 		MessageQueueId_t messageQueueId) const {
-	MutexHelper(MutexIF::TimeoutType::WAITING, mapLock, 50);
+	MutexHelper(mapLock, MutexIF::TimeoutType::WAITING, 50);
 	auto queueIter = queueMap.find(messageQueueId);
 	if(queueIter != queueMap.end()) {
 		return queueIter->second;
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 130b3175c..12ecf34af 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -3,6 +3,10 @@
 #include <inttypes.h>
 #include <math.h>
 
+#ifndef SCNu8
+  #define SCNu8 "hhu"
+#endif
+
 CCSDSTime::CCSDSTime() {
 }
 

From 883103af2b4de3e099180e1fb999af974675e7ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:13:07 +0200
Subject: [PATCH 0718/1774] queue map manager update

---
 osal/host/QueueMapManager.cpp | 3 ++-
 osal/host/QueueMapManager.h   | 6 +++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 6007e9f31..1b2094e91 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -1,6 +1,7 @@
+#include "QueueMapManager.h"
+
 #include "../../ipc/MutexFactory.h"
 #include "../../ipc/MutexHelper.h"
-#include "../../osal/host/QueueMapManager.h"
 
 QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
 
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
index 823fd4c2b..d7d5c9154 100644
--- a/osal/host/QueueMapManager.h
+++ b/osal/host/QueueMapManager.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
-#define FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
+#ifndef FSFW_OSAL_HOST_QUEUEMAPMANAGER_H_
+#define FSFW_OSAL_HOST_QUEUEMAPMANAGER_H_
 
 #include "../../ipc/MessageQueueSenderIF.h"
 #include "../../osal/host/MessageQueue.h"
@@ -44,4 +44,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_OSAL_HOST_QUEUEMAP_H_ */
+#endif /* FSFW_OSAL_HOST_QUEUEMAPMANAGER_H_ */

From c43ae66205f6fc4c594075660d34b0f6317569fa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:18:30 +0200
Subject: [PATCH 0719/1774] some tweaks

---
 osal/host/MessageQueue.cpp | 8 +++++---
 osal/host/Mutex.h          | 6 +++---
 osal/host/PeriodicTask.cpp | 6 +++---
 3 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 598250845..bced37139 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -1,6 +1,7 @@
-#include "../../osal/host/MessageQueue.h"
+#include "MessageQueue.h"
+#include "QueueMapManager.h"
+
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/host/QueueMapManager.h"
 #include "../../ipc/MutexFactory.h"
 #include "../../ipc/MutexHelper.h"
 
@@ -9,7 +10,8 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 	queueLock = MutexFactory::instance()->createMutex();
 	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "MessageQueue: Could not be created" << std::endl;
+		sif::error << "MessageQueue::MessageQueue:"
+		        << " Could not be created" << std::endl;
 	}
 }
 
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index b755bc307..24dafbbda 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
-#define FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
+#ifndef FSFW_OSAL_HOSTED_MUTEX_H_
+#define FSFW_OSAL_HOSTED_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 
@@ -26,4 +26,4 @@ private:
 	std::timed_mutex mutex;
 };
 
-#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
+#endif /* FSFW_OSAL_HOSTED_MUTEX_H_ */
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 0b5f8bbe0..f4ee079b1 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -1,7 +1,7 @@
-#include "../../ipc/MutexFactory.h"
-#include "../../osal/host/Mutex.h"
-#include "../../osal/host/PeriodicTask.h"
+#include "Mutex.h"
+#include "PeriodicTask.h"
 
+#include "../../ipc/MutexFactory.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../tasks/ExecutableObjectIF.h"
 

From 7a24f899158ad8b6a3a74ff2da8a0ba530dc8539 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:19:15 +0200
Subject: [PATCH 0720/1774] removed comment

---
 osal/host/TaskFactory.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
index 37df981a3..bc65504c8 100644
--- a/osal/host/TaskFactory.cpp
+++ b/osal/host/TaskFactory.cpp
@@ -25,8 +25,6 @@ PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
 		TaskPriority taskPriority_,TaskStackSize stackSize_,
 		TaskPeriod periodInSeconds_,
 		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	// This is going to be interesting. Time now learn the C++ threading library
-	// :-)
 	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
 			deadLineMissedFunction_);
 }
@@ -35,8 +33,6 @@ FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
 		TaskPriority taskPriority_,TaskStackSize stackSize_,
 		TaskPeriod periodInSeconds_,
 		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	// This is going to be interesting. Time now learn the C++ threading library
-	// :-)
 	return new FixedTimeslotTask(name_, taskPriority_, stackSize_,
 	        periodInSeconds_, deadLineMissedFunction_);
 }

From cb970b1883b35412b64145ddff4f1c5eb1604529 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:24:59 +0200
Subject: [PATCH 0721/1774] task IF is set now

---
 osal/host/PeriodicTask.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index f4ee079b1..3157ffb79 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -101,13 +101,14 @@ void PeriodicTask::taskFunctionality() {
 		if(terminateThread.load()) {
 			break;
 		}
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
+		for (const auto& object: objectList) {
+			object->performOperation();
 		}
 		if(not delayForInterval(&currentStartTime, periodChrono)) {
+#ifdef DEBUG
 			sif::warning << "PeriodicTask: " << taskName <<
 					" missed deadline!\n" << std::flush;
+#endif
 			if(deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
@@ -121,6 +122,7 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	if (newObject == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	newObject->setTaskIF(this);
 	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }

From c7606b7b1e870b510488da7d72c0dbe9b47e6ddb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:51:17 +0200
Subject: [PATCH 0722/1774] updating and cleaning pool files

---
 datapool/PoolDataSetBase.h         | 11 ++++++-----
 datapool/PoolDataSetIF.h           |  7 ++++---
 datapool/PoolEntry.cpp             |  3 ++-
 datapool/PoolEntry.h               |  8 ++++----
 datapool/PoolEntryIF.h             |  6 +++---
 datapool/PoolRawAccessHelper.cpp   |  9 +--------
 datapool/PoolRawAccessHelper.h     | 10 ++--------
 datapoolglob/DataPoolAdmin.cpp     |  9 +++++----
 datapoolglob/DataPoolAdmin.h       | 13 +++++++------
 datapoolglob/GlobalPoolVector.h    |  6 +++---
 datapoolglob/GlobalPoolVector.tpp  |  4 ++--
 datapoollocal/HasLocalDataPoolIF.h |  7 ++++---
 datapoollocal/LocalDataSet.h       |  9 +++++----
 13 files changed, 48 insertions(+), 54 deletions(-)

diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 666624138..a8931d628 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -1,7 +1,8 @@
-#ifndef FRAMEWORK_DATAPOOL_DATASETBASE_H_
-#define FRAMEWORK_DATAPOOL_DATASETBASE_H_
-#include "../datapool/PoolDataSetIF.h"
-#include "../datapool/PoolVariableIF.h"
+#ifndef FSFW_DATAPOOL_POOLDATASETBASE_H_
+#define FSFW_DATAPOOL_POOLDATASETBASE_H_
+
+#include "PoolDataSetIF.h"
+#include "PoolVariableIF.h"
 #include "../ipc/MutexIF.h"
 
 /**
@@ -148,4 +149,4 @@ private:
 	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
 };
 
-#endif /* FRAMEWORK_DATAPOOL_POOLPOOLDATASETBASE_H_ */
+#endif /* FSFW_DATAPOOL_POOLDATASETBASE_H_ */
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index 44ca468bd..78c05d433 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -1,5 +1,6 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLDATASETIF_H_
-#define FRAMEWORK_DATAPOOL_POOLDATASETIF_H_
+#ifndef FSFW_DATAPOOL_POOLDATASETIF_H_
+#define FSFW_DATAPOOL_POOLDATASETIF_H_
+
 #include "DataSetIF.h"
 
 class PoolDataSetIF: public DataSetIF {
@@ -25,4 +26,4 @@ public:
     virtual bool isValid() const = 0;
 };
 
-#endif /* FRAMEWORK_DATAPOOL_POOLDATASETIF_H_ */
+#endif /* FSFW_DATAPOOL_POOLDATASETIF_H_ */
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index b0506b824..fb73328ca 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,4 +1,5 @@
-#include "../datapool/PoolEntry.h"
+#include "PoolEntry.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../globalfunctions/arrayprinter.h"
 #include <cstring>
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 6a3daacf9..033db40d0 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
+#ifndef FSFW_DATAPOOL_POOLENTRY_H_
+#define FSFW_DATAPOOL_POOLENTRY_H_
 
-#include "../datapool/PoolEntryIF.h"
+#include "PoolEntryIF.h"
 
 #include <initializer_list>
 #include <type_traits>
@@ -127,4 +127,4 @@ public:
 	Type getType();
 };
 
-#endif /* POOLENTRY_H_ */
+#endif /* FSFW_DATAPOOL_POOLENTRY_H_ */
diff --git a/datapool/PoolEntryIF.h b/datapool/PoolEntryIF.h
index 462de18b8..d9db52375 100644
--- a/datapool/PoolEntryIF.h
+++ b/datapool/PoolEntryIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+#ifndef FSFW_DATAPOOL_POOLENTRYIF_H_
+#define FSFW_DATAPOOL_POOLENTRYIF_H_
 
 #include "../globalfunctions/Type.h"
 #include <cstdint>
@@ -60,4 +60,4 @@ public:
 	virtual Type getType() = 0;
 };
 
-#endif /* POOLENTRYIF_H_ */
+#endif /* FSFW_DATAPOOL_POOLENTRYIF_H_ */
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 3696a21d1..5a6827b66 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -1,11 +1,4 @@
-/**
- * @file PoolRawAccessHelper.cpp
- *
- * @date 22.12.2019
- * @author R. Mueller
- */
-
-#include "../datapool/PoolRawAccessHelper.h"
+#include "PoolRawAccessHelper.h"
 #include "../datapoolglob/GlobalDataSet.h"
 #include "../serialize/SerializeAdapter.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index db25acdf8..6ff3e955a 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -1,11 +1,5 @@
-/**
- * @file PoolRawAccessHelper.h
- *
- * @date 22.12.2019
- */
-
-#ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
-#define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
+#ifndef FSFW_DATAPOOL_POOLRAWACCESSHELPER_H_
+#define FSFW_DATAPOOL_POOLRAWACCESSHELPER_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../datapoolglob/GlobalDataSet.h"
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 029a336d1..6ede0841e 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,7 +1,8 @@
-#include "../datapoolglob/DataPoolAdmin.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapoolglob/PoolRawAccess.h"
+#include "DataPoolAdmin.h"
+#include "GlobalDataSet.h"
+#include "GlobalDataPool.h"
+#include "PoolRawAccess.h"
+
 #include "../ipc/CommandMessage.h"
 #include "../ipc/QueueFactory.h"
 #include "../parameters/ParameterMessage.h"
diff --git a/datapoolglob/DataPoolAdmin.h b/datapoolglob/DataPoolAdmin.h
index a08f322d9..d8871b651 100644
--- a/datapoolglob/DataPoolAdmin.h
+++ b/datapoolglob/DataPoolAdmin.h
@@ -1,5 +1,7 @@
-#ifndef DATAPOOLADMIN_H_
-#define DATAPOOLADMIN_H_
+#ifndef FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_
+#define FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_
+
+#include "DataPoolParameterWrapper.h"
 
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -7,10 +9,9 @@
 #include "../action/HasActionsIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../parameters/ReceivesParameterMessagesIF.h"
-
-#include "../memory/MemoryHelper.h"
 #include "../action/SimpleActionHelper.h"
-#include "../datapoolglob/DataPoolParameterWrapper.h"
+#include "../memory/MemoryHelper.h"
+
 
 class DataPoolAdmin: public HasActionsIF,
 		public ExecutableObjectIF,
@@ -56,4 +57,4 @@ private:
 			Command_t initialCommand);
 };
 
-#endif /* DATAPOOLADMIN_H_ */
+#endif /* FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_ */
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 6b592fc67..0f5daacd8 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -1,5 +1,5 @@
-#ifndef GLOBALPOOLVECTOR_H_
-#define GLOBALPOOLVECTOR_H_
+#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_
+#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_
 
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
@@ -182,4 +182,4 @@ private:
 template<typename T, uint16_t vectorSize>
 using gp_vec_t = GlobPoolVector<T, vectorSize>;
 
-#endif /* POOLVECTOR_H_ */
+#endif /* FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_ */
diff --git a/datapoolglob/GlobalPoolVector.tpp b/datapoolglob/GlobalPoolVector.tpp
index ccf33138d..013a682a4 100644
--- a/datapoolglob/GlobalPoolVector.tpp
+++ b/datapoolglob/GlobalPoolVector.tpp
@@ -1,5 +1,5 @@
-#ifndef GLOBALPOOLVECTOR_TPP_
-#define GLOBALPOOLVECTOR_TPP_
+#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
+#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
 
 
 template<typename T, uint16_t vectorSize>
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 9eb1c9f11..3e6b843f1 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,5 +1,6 @@
-#ifndef FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
-#define FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
+
 #include "../datapool/PoolEntryIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
@@ -89,4 +90,4 @@ public:
 	};
 };
 
-#endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 5641ebfbc..0368f26d1 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -1,6 +1,7 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
-#include "../datapoollocal/LocalPoolDataSetBase.h"
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDATASET_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDATASET_H_
+
+#include "LocalPoolDataSetBase.h"
 #include <vector>
 
 class LocalDataSet: public LocalPoolDataSetBase {
@@ -17,4 +18,4 @@ private:
     std::vector<PoolVariableIF*> poolVarList;
 };
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDATASET_H_ */

From f698275a0bafc6494780f9b65858ca7d920e8e5a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:59:17 +0200
Subject: [PATCH 0723/1774] removed seconds typedef, confusing

---
 datapoollocal/HasLocalDataPoolIF.h   |  4 +++-
 datapoollocal/LocalPoolDataSetBase.h |  9 +++++----
 datapoollocal/SharedLocalDataSet.h   |  9 +++++----
 datapoollocal/StaticLocalDataSet.h   | 12 +++++++-----
 timemanager/Clock.h                  |  1 -
 timemanager/Stopwatch.cpp            |  2 +-
 timemanager/Stopwatch.h              |  2 +-
 7 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 3e6b843f1..4b49ee119 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -4,6 +4,8 @@
 #include "../datapool/PoolEntryIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
+#include "../timemanager/Clock.h"
+
 #include <map>
 
 class LocalDataPoolManager;
@@ -85,7 +87,7 @@ public:
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
 	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
-	        dur_seconds_t newInterval) {
+	        float newIntervalSeconds) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
 };
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index bd127db49..77c1df1ba 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,8 +1,9 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+
+#include "HasLocalDataPoolIF.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
-#include "../datapoollocal/HasLocalDataPoolIF.h"
 #include "../serialize/SerializeIF.h"
 
 #include <vector>
@@ -130,4 +131,4 @@ private:
 
 };
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ */
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index f6748e4da..b1f9aa3d3 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -1,7 +1,8 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
-#define FRAMEWORK_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+#ifndef FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+#define FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+
+#include "LocalPoolDataSetBase.h"
 #include "../datapool/SharedDataSetIF.h"
-#include "../datapoollocal/LocalPoolDataSetBase.h"
 #include "../objectmanager/SystemObject.h"
 #include <vector>
 
@@ -28,4 +29,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_ */
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index b3e8422c9..7c2f0039c 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -1,5 +1,6 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#ifndef FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#define FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+
 #include "LocalPoolDataSetBase.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include <array>
@@ -16,12 +17,13 @@
 template <uint8_t NUM_VARIABLES>
 class StaticLocalDataSet: public LocalPoolDataSetBase {
 public:
-    StaticLocalDataSet(sid_t sid):
-        LocalPoolDataSetBase(sid, poolVarList.data(), NUM_VARIABLES) {
+    StaticLocalDataSet(sid_t sid): LocalPoolDataSetBase(sid, nullptr,
+            NUM_VARIABLES) {
+        this->setContainer(poolVarList.data());
     }
 
 private:
     std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList;
 };
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 9463b5a6e..acb68e2ec 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -10,7 +10,6 @@
 
 //! Don't use these for time points, type is not large enough for UNIX epoch.
 using dur_millis_t = uint32_t;
-using dur_seconds_t = double;
 
 class Clock {
 public:
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 637c50780..28ae45437 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -18,7 +18,7 @@ dur_millis_t Stopwatch::stop() {
     return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
 }
 
-dur_seconds_t Stopwatch::stopSeconds() {
+double Stopwatch::stopSeconds() {
     stopInternal();
     return timevalOperations::toDouble(elapsedTime);
 }
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 191929dc1..49b686f9e 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -45,7 +45,7 @@ public:
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in seconds (double precision)
      */
-    dur_seconds_t stopSeconds();
+    double stopSeconds();
 
     /**
      * Displays the elapsed times on the osstream, depending on internal display

From 08ffbfefae6ea75186a6b405afacc1b9e73e0f55 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 09:33:02 +0200
Subject: [PATCH 0724/1774] added windows udp bridge

---
 osal/host/FixedTimeslotTask.cpp  | 17 +++++-----
 osal/host/Mutex.h                |  6 ++--
 osal/host/TmTcWinUdpBridge.cpp   | 57 ++++++++++++++++++++++++++++++++
 osal/host/TmTcWinUdpBridge.h     | 47 ++++++++++++++++++++++++++
 osal/linux/TmTcUnixUdpBridge.cpp |  2 +-
 5 files changed, 116 insertions(+), 13 deletions(-)
 create mode 100644 osal/host/TmTcWinUdpBridge.cpp
 create mode 100644 osal/host/TmTcWinUdpBridge.h

diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index e78c974a4..3c31eb760 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -1,9 +1,7 @@
-#include "../../osal/host/FixedTimeslotTask.h"
+#include "FixedTimeslotTask.h"
+#include "Mutex.h"
 
 #include "../../ipc/MutexFactory.h"
-#include "../../osal/host/Mutex.h"
-#include "../../osal/host/FixedTimeslotTask.h"
-
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../tasks/ExecutableObjectIF.h"
 
@@ -35,15 +33,15 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             ABOVE_NORMAL_PRIORITY_CLASS);
     if(result != 0) {
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
+        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;
+        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.
@@ -60,7 +58,8 @@ FixedTimeslotTask::~FixedTimeslotTask(void) {
 }
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
-    FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+    FixedTimeslotTask *originalTask(
+            reinterpret_cast<FixedTimeslotTask*>(argument));
 
     if (not originalTask->started) {
         // we have to suspend/block here until the task is started.
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index 24dafbbda..af56b8f79 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef FSFW_OSAL_HOSTED_MUTEX_H_
-#define FSFW_OSAL_HOSTED_MUTEX_H_
+#ifndef FSFW_OSAL_HOST_MUTEX_H_
+#define FSFW_OSAL_HOST_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 
@@ -26,4 +26,4 @@ private:
 	std::timed_mutex mutex;
 };
 
-#endif /* FSFW_OSAL_HOSTED_MUTEX_H_ */
+#endif /* FSFW_OSAL_HOST_MUTEX_H_ */
diff --git a/osal/host/TmTcWinUdpBridge.cpp b/osal/host/TmTcWinUdpBridge.cpp
new file mode 100644
index 000000000..b7b43b131
--- /dev/null
+++ b/osal/host/TmTcWinUdpBridge.cpp
@@ -0,0 +1,57 @@
+#include "TmTcWinUdpBridge.h"
+
+TmTcWinUdpBridge::TmTcWinUdpBridge(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(socket < 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,
+            reinterpret_cast<const char*>(&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;
+    }
+}
+
+
diff --git a/osal/host/TmTcWinUdpBridge.h b/osal/host/TmTcWinUdpBridge.h
new file mode 100644
index 000000000..66463065d
--- /dev/null
+++ b/osal/host/TmTcWinUdpBridge.h
@@ -0,0 +1,47 @@
+#ifndef FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_
+#define FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_
+
+#include "../../tmtcservices/TmTcBridge.h"
+#include <Winsock.h>
+
+class TmTcWinUdpBridge: public TmTcBridge {
+    friend class TcWinUdpPollingTask;
+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;
+
+    TmTcWinUdpBridge(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~ TmTcWinUdpBridge();
+
+    void checkAndSetClientAddress(sockaddr_in clientAddress);
+
+protected:
+    virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
+
+private:
+    SOCKET 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 /* FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_ */
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 3e9674f3e..d0c9517fc 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -24,7 +24,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	// 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(socket < 0) {
+	if(serverSocket < 0) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
 				" UDP socket!" << std::endl;
 		handleSocketError();

From 0c85b05aca4d7a1adc8f5bf1a85133c845ecc63f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 09:54:22 +0200
Subject: [PATCH 0725/1774] continued win bridge

---
 osal/host/TmTcWinUdpBridge.cpp | 24 ++++++++++++++++++++----
 osal/host/TmTcWinUdpBridge.h   |  4 ++--
 2 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/osal/host/TmTcWinUdpBridge.cpp b/osal/host/TmTcWinUdpBridge.cpp
index b7b43b131..4bb9a3b1f 100644
--- a/osal/host/TmTcWinUdpBridge.cpp
+++ b/osal/host/TmTcWinUdpBridge.cpp
@@ -19,8 +19,8 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     // 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(socket < 0) {
-        sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
+    if(serverSocket != 0) {
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open"
                 " UDP socket!" << std::endl;
         handleSocketError();
         return;
@@ -32,7 +32,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     //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);
+    serverAddressLen = sizeof(serverAddress);
     setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR,
             reinterpret_cast<const char*>(&serverSocketOptions),
             sizeof(serverSocketOptions));
@@ -40,7 +40,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     clientAddress.sin_family = AF_INET;
     clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
     clientAddress.sin_port = htons(setClientPort);
-    //clientAddressLen = sizeof(clientAddress);
+    clientAddressLen = sizeof(clientAddress);
 
     int result = bind(serverSocket,
             reinterpret_cast<struct sockaddr*>(&serverAddress),
@@ -54,4 +54,20 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     }
 }
 
+TmTcWinUdpBridge::~TmTcWinUdpBridge() {}
 
+void TmTcWinUdpBridge::handleSocketError() {
+}
+
+void TmTcWinUdpBridge::handleBindError() {
+}
+
+ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in clientAddress) {
+}
+
+void TmTcWinUdpBridge::handleSendError() {
+}
diff --git a/osal/host/TmTcWinUdpBridge.h b/osal/host/TmTcWinUdpBridge.h
index 66463065d..8e6bb0fda 100644
--- a/osal/host/TmTcWinUdpBridge.h
+++ b/osal/host/TmTcWinUdpBridge.h
@@ -28,10 +28,10 @@ private:
     const int serverSocketOptions = 0;
 
     struct sockaddr_in clientAddress;
-    //socklen_t clientAddressLen = 0;
+    int clientAddressLen = 0;
 
     struct sockaddr_in serverAddress;
-    //socklen_t serverAddressLen = 0;
+    int serverAddressLen = 0;
 
     //! Access to the client address is mutex protected as it is set
     //! by another task.

From b7c4f5ce05ec1c235cbea3b825d21ce4497dd095 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 10:36:39 +0200
Subject: [PATCH 0726/1774] continued win sockets

---
 osal/linux/TcUnixUdpPollingTask.cpp         |  2 +-
 osal/linux/TmTcUnixUdpBridge.cpp            |  3 +-
 osal/{host => windows}/TmTcWinUdpBridge.cpp | 73 ++++++++++++++++++---
 osal/{host => windows}/TmTcWinUdpBridge.h   | 10 +--
 4 files changed, 73 insertions(+), 15 deletions(-)
 rename osal/{host => windows}/TmTcWinUdpBridge.cpp (54%)
 rename osal/{host => windows}/TmTcWinUdpBridge.h (88%)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index d8a398699..95910b028 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/linux/TcUnixUdpPollingTask.h"
+#include "TcUnixUdpPollingTask.h"
 #include "../../globalfunctions/arrayprinter.h"
 
 TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index d0c9517fc..2549a4b79 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,10 +1,11 @@
-#include "../../osal/linux/TmTcUnixUdpBridge.h"
+#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):
diff --git a/osal/host/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
similarity index 54%
rename from osal/host/TmTcWinUdpBridge.cpp
rename to osal/windows/TmTcWinUdpBridge.cpp
index 4bb9a3b1f..c5902e884 100644
--- a/osal/host/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -6,6 +6,18 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
         TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
     mutex = MutexFactory::instance()->createMutex();
 
+    // Initiates Winsock DLL.
+    WSAData wsaData;
+    WORD wVersionRequested = MAKEWORD(2, 2);
+    int err = WSAStartup(wVersionRequested, &wsaData);
+    if (err != 0) {
+        /* Tell the user that we could not find a usable */
+        /* Winsock DLL.                                  */
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge:"
+                "WSAStartup failed with error: " << err << std::endl;
+        return;
+    }
+
     uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
     if(serverPort != 0xFFFF) {
         setServerPort = serverPort;
@@ -45,8 +57,8 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     int result = bind(serverSocket,
             reinterpret_cast<struct sockaddr*>(&serverAddress),
             serverAddressLen);
-    if(result == -1) {
-        sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
+    if(result != 0) {
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
                 "local port " << setServerPort << " to server socket!"
                 << std::endl;
         handleBindError();
@@ -54,12 +66,8 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     }
 }
 
-TmTcWinUdpBridge::~TmTcWinUdpBridge() {}
-
-void TmTcWinUdpBridge::handleSocketError() {
-}
-
-void TmTcWinUdpBridge::handleBindError() {
+TmTcWinUdpBridge::~TmTcWinUdpBridge() {
+    WSACleanup();
 }
 
 ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
@@ -69,5 +77,52 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in clientAddress) {
 }
 
-void TmTcWinUdpBridge::handleSendError() {
+void TmTcWinUdpBridge::handleSocketError() {
+    int errCode = WSAGetLastError();
+    switch(errCode) {
+    case(WSANOTINITIALISED): {
+        sif::info << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: "
+                << "WSAStartup(...) call " << "necessary" << std::endl;
+        break;
+    }
+    default: {
+        sif::info << "TmTcWinUdpBridge::handleSocketError: Error code: "
+                << errCode << std::endl;
+        break;
+    }
+    }
 }
+
+void TmTcWinUdpBridge::handleBindError() {
+    int errCode = WSAGetLastError();
+    switch(errCode) {
+    case(WSANOTINITIALISED): {
+        sif::info << "TmTcWinUdpBridge::handleBindError: WSANOTINITIALISED: "
+                << "WSAStartup(...) call " << "necessary" << std::endl;
+        break;
+    }
+    default: {
+        sif::info << "TmTcWinUdpBridge::handleBindError: Error code: "
+                << errCode << std::endl;
+        break;
+    }
+    }
+}
+
+void TmTcWinUdpBridge::handleSendError() {
+    int errCode = WSAGetLastError();
+    switch(errCode) {
+    case(WSANOTINITIALISED): {
+        sif::info << "TmTcWinUdpBridge::handleSendError: WSANOTINITIALISED: "
+                << "WSAStartup(...) call " << "necessary" << std::endl;
+        break;
+    }
+    default: {
+        sif::info << "TmTcWinUdpBridge::handleSendError: Error code: "
+                << errCode << std::endl;
+        break;
+    }
+    }
+}
+
+#endif
diff --git a/osal/host/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
similarity index 88%
rename from osal/host/TmTcWinUdpBridge.h
rename to osal/windows/TmTcWinUdpBridge.h
index 8e6bb0fda..8188039c0 100644
--- a/osal/host/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -1,14 +1,15 @@
-#ifndef FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_
-#define FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_
+#ifndef FSFW_OSAL_WINDOWS_TMTCWINUDPBRIDGE_H_
+#define FSFW_OSAL_WINDOWS_TMTCWINUDPBRIDGE_H_
 
 #include "../../tmtcservices/TmTcBridge.h"
-#include <Winsock.h>
+
+#include <winsock2.h>
+#include <windows.h>
 
 class TmTcWinUdpBridge: public TmTcBridge {
     friend class TcWinUdpPollingTask;
 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;
 
@@ -45,3 +46,4 @@ private:
 
 
 #endif /* FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_ */
+

From 3e0819f954d3eb6b6fb090f7b0d157d867f4ed6c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 11:48:32 +0200
Subject: [PATCH 0727/1774] some bugfixes

---
 fsfw.mk                              |   4 +
 osal/host/PeriodicTask.cpp           |   4 +
 osal/host/QueueMapManager.cpp        |  14 ++-
 osal/windows/TcWinUdpPollingTask.cpp | 147 +++++++++++++++++++++++++++
 osal/windows/TcWinUdpPollingTask.h   |  67 ++++++++++++
 osal/windows/TmTcWinUdpBridge.cpp    |   4 +-
 6 files changed, 234 insertions(+), 6 deletions(-)
 create mode 100644 osal/windows/TcWinUdpPollingTask.cpp
 create mode 100644 osal/windows/TcWinUdpPollingTask.h

diff --git a/fsfw.mk b/fsfw.mk
index a548b6a88..b8e9ff987 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -37,6 +37,10 @@ else ifeq ($(OS_FSFW),freeRTOS)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
 else ifeq ($(OS_FSFW),host)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
+ifeq ($(OS),Windows_NT)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/windows/*.cpp)
+endif
+
 else
 $(error invalid OS_FSFW specified, valid OS_FSFW are rtems, linux, freeRTOS, host)
 endif
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 3157ffb79..f7807a171 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -96,6 +96,10 @@ void PeriodicTask::taskFunctionality() {
 	};
 	auto nextStartTime{ currentStartTime };
 
+	for (const auto& object: objectList) {
+	    object->initializeAfterTaskCreation();
+	}
+
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
 		if(terminateThread.load()) {
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 1b2094e91..c3d945848 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -44,9 +44,17 @@ MessageQueueIF* QueueMapManager::getMessageQueue(
 		return queueIter->second;
 	}
 	else {
-		sif::warning << "QueueMapManager::getQueueHandle: The ID" <<
-				messageQueueId << " does not exists in the map" << std::endl;
-		return nullptr;
+	    if(messageQueueId == MessageQueueIF::NO_QUEUE) {
+	        sif::error << "QueueMapManager::getQueueHandle: Configuration"
+	                << " error, NO_QUEUE was passed to this function!"
+	                << std::endl;
+	    }
+	    else {
+	        sif::warning << "QueueMapManager::getQueueHandle: The ID "
+	                << messageQueueId << " does not exists in the map."
+	                << std::endl;
+	    }
+	    return nullptr;
 	}
 }
 
diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
new file mode 100644
index 000000000..661d596a9
--- /dev/null
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -0,0 +1,147 @@
+#include "TcWinUdpPollingTask.h"
+#include "../../globalfunctions/arrayprinter.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+#include <winsock2.h>
+#include <windows.h>
+
+TcWinUdpPollingTask::TcWinUdpPollingTask(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);
+	}
+}
+
+TcWinUdpPollingTask::~TcWinUdpPollingTask() {}
+
+ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
+	// Poll for new UDP datagrams in permanent loop.
+	while(1) {
+		//! Sender Address is cached here.
+		struct sockaddr_in senderAddress;
+		int senderAddressSize = sizeof(senderAddress);
+		ssize_t bytesReceived = recvfrom(serverUdpSocket,
+				reinterpret_cast<char*>(receptionBuffer.data()), frameSize,
+				receptionFlags, reinterpret_cast<sockaddr*>(&senderAddress),
+				&senderAddressSize);
+		if(bytesReceived == SOCKET_ERROR) {
+			// handle error
+			sif::error << "TcWinUdpPollingTask::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 TcWinUdpPollingTask::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 TcWinUdpPollingTask::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<TmTcWinUdpBridge>(tmtcBridgeId);
+	if(tmtcBridge == nullptr) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
+				" TMTC bridge object!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	serverUdpSocket = tmtcBridge->serverSocket;
+	//sif::info << "TcWinUdpPollingTask::initialize: Server UDP socket "
+	//        << serverUdpSocket << std::endl;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TcWinUdpPollingTask::initializeAfterTaskCreation() {
+	// Initialize the destination after task creation. This ensures
+	// that the destination has already been set in the TMTC bridge.
+	targetTcDestination = tmtcBridge->getRequestQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
+	DWORD timeoutMs = timeoutSeconds * 1000.0;
+	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+			reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
+	if(result == -1) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+				"receive timeout failed with " << strerror(errno) << std::endl;
+	}
+}
+
+void TcWinUdpPollingTask::handleReadError() {
+    int error = WSAGetLastError();
+    switch(error) {
+    case(WSANOTINITIALISED): {
+        sif::info << "TmTcWinUdpBridge::handleReadError: WSANOTINITIALISED: "
+                << "WSAStartup(...) call " << "necessary" << std::endl;
+        break;
+    }
+    case(WSAEFAULT): {
+        sif::info << "TmTcWinUdpBridge::handleReadError: WSADEFAULT: "
+                << "Bad address " << std::endl;
+        Sleep(2000);
+        break;
+    }
+    default: {
+        sif::info << "TmTcWinUdpBridge::handleReadError: Error code: "
+                << error << std::endl;
+        break;
+    }
+    }
+}
diff --git a/osal/windows/TcWinUdpPollingTask.h b/osal/windows/TcWinUdpPollingTask.h
new file mode 100644
index 000000000..50d39d25f
--- /dev/null
+++ b/osal/windows/TcWinUdpPollingTask.h
@@ -0,0 +1,67 @@
+#ifndef FSFW_OSAL_WINDOWS_TCSOCKETPOLLINGTASK_H_
+#define FSFW_OSAL_WINDOWS_TCSOCKETPOLLINGTASK_H_
+
+#include "TmTcWinUdpBridge.h"
+#include "../../objectmanager/SystemObject.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include "../../storagemanager/StorageManagerIF.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 TcWinUdpPollingTask: public SystemObject,
+		public ExecutableObjectIF {
+	friend class TmTcWinUdpBridge;
+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};
+
+	TcWinUdpPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+			size_t frameSize = 0, double timeoutSeconds = -1);
+	virtual~ TcWinUdpPollingTask();
+
+	/**
+	 * 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;
+	TmTcWinUdpBridge* 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
+	SOCKET 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_ */
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index c5902e884..2ea6ae97b 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -31,7 +31,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     // 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) {
+    if(serverSocket == INVALID_SOCKET) {
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open"
                 " UDP socket!" << std::endl;
         handleSocketError();
@@ -62,7 +62,6 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
                 "local port " << setServerPort << " to server socket!"
                 << std::endl;
         handleBindError();
-        return;
     }
 }
 
@@ -125,4 +124,3 @@ void TmTcWinUdpBridge::handleSendError() {
     }
 }
 
-#endif

From 7774434d7a211f212ec376bb8296d6aa9f63aab7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 11:58:12 +0200
Subject: [PATCH 0728/1774] windows sockets working

---
 osal/windows/TmTcWinUdpBridge.cpp | 53 ++++++++++++++++++++++++++++++-
 1 file changed, 52 insertions(+), 1 deletion(-)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 2ea6ae97b..3e2735070 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/ipc/MutexHelper.h>
 #include "TmTcWinUdpBridge.h"
 
 TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
@@ -70,10 +71,43 @@ TmTcWinUdpBridge::~TmTcWinUdpBridge() {
 }
 
 ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+    int flags = 0;
+
+    //clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
+    //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,
+            reinterpret_cast<const char*>(data), dataLen, flags,
+            reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
+    if(bytesSent == SOCKET_ERROR) {
+        sif::error << "TmTcWinUdpBridge::sendTm: Send operation failed."
+                << std::endl;
+        handleSendError();
+    }
+//  sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+//          " sent." << std::endl;
+    return HasReturnvaluesIF::RETURN_OK;
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in clientAddress) {
+void TmTcWinUdpBridge::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 TmTcWinUdpBridge::handleSocketError() {
@@ -85,6 +119,10 @@ void TmTcWinUdpBridge::handleSocketError() {
         break;
     }
     default: {
+        /*
+        https://docs.microsoft.com/en-us/windows/win32/winsock/
+        windows-sockets-error-codes-2
+         */
         sif::info << "TmTcWinUdpBridge::handleSocketError: Error code: "
                 << errCode << std::endl;
         break;
@@ -101,6 +139,10 @@ void TmTcWinUdpBridge::handleBindError() {
         break;
     }
     default: {
+        /*
+        https://docs.microsoft.com/en-us/windows/win32/winsock/
+        windows-sockets-error-codes-2
+        */
         sif::info << "TmTcWinUdpBridge::handleBindError: Error code: "
                 << errCode << std::endl;
         break;
@@ -116,7 +158,16 @@ void TmTcWinUdpBridge::handleSendError() {
                 << "WSAStartup(...) call " << "necessary" << std::endl;
         break;
     }
+    case(WSAEADDRNOTAVAIL): {
+        sif::info << "TmTcWinUdpBridge::handleReadError: WSAEADDRNOTAVAIL: "
+                << "Check target address. " << std::endl;
+        break;
+    }
     default: {
+        /*
+        https://docs.microsoft.com/en-us/windows/win32/winsock/
+        windows-sockets-error-codes-2
+        */
         sif::info << "TmTcWinUdpBridge::handleSendError: Error code: "
                 << errCode << std::endl;
         break;

From 8db9a4a1911862a359d6c9a27569fb4e640670a8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 12:00:57 +0200
Subject: [PATCH 0729/1774] some minor tweaks

---
 osal/windows/TcWinUdpPollingTask.cpp | 9 +++++----
 osal/windows/TmTcWinUdpBridge.cpp    | 3 +--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 661d596a9..7b54bb2cf 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -33,7 +33,7 @@ TcWinUdpPollingTask::~TcWinUdpPollingTask() {}
 
 ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 	// Poll for new UDP datagrams in permanent loop.
-	while(1) {
+	while(true) {
 		//! Sender Address is cached here.
 		struct sockaddr_in senderAddress;
 		int senderAddressSize = sizeof(senderAddress);
@@ -48,8 +48,8 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 			handleReadError();
 			continue;
 		}
-		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
-				<< " bytes received" << std::endl;
+		//sif::debug << "TcWinUdpPollingTask::performOperation: " << bytesReceived
+		//		<< " bytes received" << std::endl;
 
 		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
 		if(result != HasReturnvaluesIF::RETURN_FAILED) {
@@ -135,7 +135,6 @@ void TcWinUdpPollingTask::handleReadError() {
     case(WSAEFAULT): {
         sif::info << "TmTcWinUdpBridge::handleReadError: WSADEFAULT: "
                 << "Bad address " << std::endl;
-        Sleep(2000);
         break;
     }
     default: {
@@ -144,4 +143,6 @@ void TcWinUdpPollingTask::handleReadError() {
         break;
     }
     }
+    // to prevent spam.
+    Sleep(1000);
 }
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 3e2735070..7e283c2a7 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -41,8 +41,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
 
     serverAddress.sin_family = AF_INET;
 
-    // Accept packets from any interface.
-    //serverAddress.sin_addr.s_addr = inet_addr("127.73.73.0");
+    // Accept packets from any interface. (potentially insecure).
     serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
     serverAddress.sin_port = htons(setServerPort);
     serverAddressLen = sizeof(serverAddress);

From efa41b29aa2fb45180d7bd6c2805a8ced32378fd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 12:16:43 +0200
Subject: [PATCH 0730/1774] added informative comment

---
 fsfw.mk | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/fsfw.mk b/fsfw.mk
index b8e9ff987..c58475540 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -31,14 +31,23 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/*.cpp)
 # select the OS
 ifeq ($(OS_FSFW),rtems)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/rtems/*.cpp)
+
 else ifeq ($(OS_FSFW),linux)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/linux/*.cpp)
+
 else ifeq ($(OS_FSFW),freeRTOS)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
+
 else ifeq ($(OS_FSFW),host)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
 ifeq ($(OS),Windows_NT)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/windows/*.cpp)
+else
+# For now, the linux UDP bridge sources needs to be included manually by upper makefile
+# for host OS because we can't be sure the OS is linux.
+# Following lines can be used to do this:
+# CXXSRC += $(FRAMEWORK_PATH)/osal/linux/TcUnixUdpPollingTask.cpp
+# CXXSRC += $(FRAMEWORK_PATH)/osal/linux/TmTcUnixUdpBridge.cpp
 endif
 
 else

From ac2f6c5ed4dff00bf3ce3228896e393813998bf7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 12:59:59 +0200
Subject: [PATCH 0731/1774] minor improvements

---
 osal/linux/TcUnixUdpPollingTask.cpp | 1 +
 osal/linux/TmTcUnixUdpBridge.cpp    | 5 +++--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 95910b028..670ba8044 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -120,6 +120,7 @@ void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
 	}
 }
 
+// TODO: sleep after error detection to prevent spam
 void TcUnixUdpPollingTask::handleReadError() {
 	switch(errno) {
 	case(EAGAIN): {
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 2549a4b79..b55291b3d 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -101,8 +101,8 @@ void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
 	}
 }
 
-void TmTcUnixUdpBridge::handleSocketError() {
 
+void TmTcUnixUdpBridge::handleSocketError() {
 	// See: https://man7.org/linux/man-pages/man2/socket.2.html
 	switch(errno) {
 	case(EACCES):
@@ -163,7 +163,8 @@ void TmTcUnixUdpBridge::handleBindError() {
 void TmTcUnixUdpBridge::handleSendError() {
 	switch(errno) {
 	default:
-		sif::error << "Error: " << strerror(errno) << std::endl;
+		sif::error << "TmTcUnixBridge::handleSendError: "
+		        << strerror(errno) << std::endl;
 	}
 }
 

From 50ae50d28679e620d0a60392f5b557ae4875995d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 14:01:41 +0200
Subject: [PATCH 0732/1774] removed pool raw access helper

---
 datapool/PoolRawAccessHelper.cpp | 181 -------------------------------
 datapool/PoolRawAccessHelper.h   | 105 ------------------
 2 files changed, 286 deletions(-)
 delete mode 100644 datapool/PoolRawAccessHelper.cpp
 delete mode 100644 datapool/PoolRawAccessHelper.h

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
deleted file mode 100644
index 5a6827b66..000000000
--- a/datapool/PoolRawAccessHelper.cpp
+++ /dev/null
@@ -1,181 +0,0 @@
-#include "PoolRawAccessHelper.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-#include <cmath>
-#include <cstring>
-
-PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
-		uint8_t  numberOfParameters_):
-		poolIdBuffer(reinterpret_cast<uint8_t * >(poolIdBuffer_)),
-		numberOfParameters(numberOfParameters_), validBufferIndex(0),
-		validBufferIndexBit(1) {
-}
-
-PoolRawAccessHelper::~PoolRawAccessHelper() {
-}
-
-ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
-		const size_t max_size, SerializeIF::Endianness streamEndianness) {
-	SerializationArgs serializationArgs = {buffer, size, max_size,
-	        streamEndianness};
-	ReturnValue_t result = RETURN_OK;
-	size_t remainingParametersSize = numberOfParameters * 4;
-	for(uint8_t count=0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
-				&remainingParametersSize, false);
-		if(result != RETURN_OK) {
-			return result;
-		}
-	}
-	if(remainingParametersSize != 0) {
-		sif::debug << "PoolRawAccessHelper: "
-				"Remaining parameters size not 0 !" << std::endl;
-		result = RETURN_FAILED;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
-		size_t * size, const size_t max_size,
-		SerializeIF::Endianness streamEndianness) {
-	ReturnValue_t result = RETURN_OK;
-	SerializationArgs argStruct = {buffer, size, max_size, streamEndianness};
-	size_t remainingParametersSize = numberOfParameters * 4;
-	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
-	uint8_t validityMask[validityMaskSize];
-	memset(validityMask,0, validityMaskSize);
-	for(uint8_t count = 0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(argStruct,
-				&remainingParametersSize,true,validityMask);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	if(remainingParametersSize != 0) {
-		sif::debug << "PoolRawAccessHelper: Remaining "
-				"parameters size not 0 !" << std::endl;
-		result = RETURN_FAILED;
-	}
-
-	memcpy(*argStruct.buffer, validityMask, validityMaskSize);
-	*size += validityMaskSize;
-	validBufferIndex = 1;
-	validBufferIndexBit = 0;
-	return result;
-}
-
-ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
-		SerializationArgs argStruct, size_t * remainingParameters,
-		bool withValidMask, uint8_t * validityMask) {
-	uint32_t currentPoolId;
-	// Deserialize current pool ID from pool ID buffer
-	ReturnValue_t result = SerializeAdapter::deSerialize(&currentPoolId,
-			&poolIdBuffer,remainingParameters, SerializeIF::Endianness::MACHINE);
-	if(result != RETURN_OK) {
-		sif::debug << std::hex << "PoolRawAccessHelper: Error deSeralizing "
-				"pool IDs" << std::dec << std::endl;
-		return result;
-	}
-	result = handlePoolEntrySerialization(currentPoolId, argStruct,
-			withValidMask, validityMask);
-	return result;
-}
-
-ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
-		uint32_t currentPoolId,SerializationArgs argStruct, bool withValidMask,
-		uint8_t * validityMask) {
-	ReturnValue_t result = RETURN_FAILED;
-	uint8_t arrayPosition = 0;
-	uint8_t counter = 0;
-	bool poolEntrySerialized = false;
-	//debug << "Pool Raw Access Helper: Handling Pool ID: "
-	//      << std::hex <<  currentPoolId << std::endl;
-	while(not poolEntrySerialized) {
-
-		if(counter > GlobDataSet::DATA_SET_MAX_SIZE) {
-			sif::error << "PoolRawAccessHelper: Config error, "
-					 "max. number of possible data set variables exceeded"
-				  << std::endl;
-			return result;
-		}
-		counter ++;
-
-		GlobDataSet currentDataSet;
-		//debug << "Current array position: " << (int)arrayPosition << std::endl;
-		PoolRawAccess currentPoolRawAccess(currentPoolId, arrayPosition,
-				&currentDataSet, PoolVariableIF::VAR_READ);
-
-		result = currentDataSet.read();
-		if (result != RETURN_OK) {
-			sif::debug << std::hex << "PoolRawAccessHelper: Error reading raw "
-					"dataset with returncode 0x" << result << std::dec << std::endl;
-			return result;
-		}
-
-		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized,
-				&arrayPosition);
-		if(result != RETURN_OK) {
-			sif::error << "Pool Raw Access Helper: Configuration Error at pool ID "
-				  << std::hex << currentPoolId
-				  << ". Size till end smaller than 0" << std::dec << std::endl;
-			return result;
-		}
-
-		// set valid mask bit if necessary
-		if(withValidMask) {
-			if(currentPoolRawAccess.isValid()) {
-				handleMaskModification(validityMask);
-			}
-			validBufferIndexBit ++;
-		}
-
-		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
-				argStruct.max_size, argStruct.streamEndianness);
-		if (result != RETURN_OK) {
-			sif::debug << "Pool Raw Access Helper: Error serializing pool data with "
-					 "ID 0x" << std::hex << currentPoolId << " into send buffer "
-					 "with return code " << result << std::dec << std::endl;
-			return result;
-		}
-
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess*
-		currentPoolRawAccess, bool * isSerialized, uint8_t * arrayPosition) {
-	int8_t remainingSize = currentPoolRawAccess->getSizeTillEnd() -
-			currentPoolRawAccess->getSizeOfType();
-	if(remainingSize == 0) {
-		*isSerialized = true;
-	}
-	else if(remainingSize > 0) {
-		*arrayPosition += 1;
-	}
-	else {
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
-	validityMask[validBufferIndex] =
-			bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
-	if(validBufferIndexBit == 8) {
-		validBufferIndex ++;
-		validBufferIndexBit = 1;
-	}
-}
-
-uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position,
-		bool value) {
-	if(position < 1 or position > 8) {
-		sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
-		return byte;
-	}
-	uint8_t shiftNumber = position + (6 - 2 * (position - 1));
-	byte |= 1UL << shiftNumber;
-	return byte;
-}
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
deleted file mode 100644
index 6ff3e955a..000000000
--- a/datapool/PoolRawAccessHelper.h
+++ /dev/null
@@ -1,105 +0,0 @@
-#ifndef FSFW_DATAPOOL_POOLRAWACCESSHELPER_H_
-#define FSFW_DATAPOOL_POOLRAWACCESSHELPER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/PoolRawAccess.h"
-
-/**
- * @brief 	This helper function simplifies accessing data pool entries
- *  	  	via PoolRawAccess
- * @details Can be used for a Housekeeping Service
- * 			like  ECSS PUS Service 3 if the type of the datapool entries is unknown.
- * 			The provided dataset can be serialized into a provided buffer automatically by
- * 			providing a buffer of pool IDs
- * @ingroup data_pool
- */
-class PoolRawAccessHelper: public HasReturnvaluesIF {
-public:
-	/**
-	 * Call this constructor if a dataset needs to be serialized via
-	 * Pool Raw Access
-	 * @param dataSet_ This dataset will be used to perform thread-safe reading
-	 * @param poolIdBuffer_ A buffer of uint32_t pool IDs
-	 * @param numberOfParameters_ The number of parameters / pool IDs
-	 */
-	PoolRawAccessHelper(uint32_t * poolIdBuffer_, uint8_t numberOfParameters_);
-	virtual ~PoolRawAccessHelper();
-
-	/**
-	 * Serialize the datapool entries derived from the pool ID buffer
-	 * directly into a provided buffer
-	 * @param [out] buffer
-	 * @param [out] size Size of the serialized buffer
-	 * @param max_size
-	 * @param bigEndian
-	 * @return 	@c RETURN_OK On success
-	 * 			@c RETURN_FAILED on failure
-	 */
-	ReturnValue_t serialize(uint8_t ** buffer, size_t * size,
-			const size_t max_size, SerializeIF::Endianness streamEndianness);
-
-	/**
-	 * Serializes data pool entries into provided buffer with the validity mask buffer
-	 * at the end of the buffer. Every bit of the validity mask denotes
-	 * the validity of a corresponding data pool entry from left to right.
-	 * @param [out] buffer
-	 * @param [out] size Size of the serialized buffer plus size
-	 *                   of the validity mask
-	 * @return 	@c RETURN_OK On success
-	 * 			@c RETURN_FAILED on failure
-	 */
-	ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, size_t * size,
-			const size_t max_size, SerializeIF::Endianness streamEndianness);
-
-
-private:
-	// DataSet * dataSet;
-	const uint8_t * poolIdBuffer;
-	uint8_t numberOfParameters;
-
-	uint8_t validBufferIndex;
-	uint8_t validBufferIndexBit;
-
-	struct SerializationArgs {
-		uint8_t ** buffer;
-		size_t * size;
-		const size_t max_size;
-		SerializeIF::Endianness streamEndianness;
-	};
-	/**
-	 * Helper function to serialize single pool entries
-	 * @param pPoolIdBuffer
-	 * @param buffer
-	 * @param remainingParameters
-	 * @param hkDataSize
-	 * @param max_size
-	 * @param bigEndian
-	 * @param withValidMask Can be set optionally to set a
-	 *        provided validity mask
-	 * @param validityMask Can be supplied and will be set if
-	 *  	  @c withValidMask is set to true
-	 * @return
-	 */
-	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(
-			SerializationArgs argStruct, size_t * remainingParameters,
-			bool withValidMask = false, uint8_t * validityMask = nullptr);
-
-	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,
-			SerializationArgs argStruct, bool withValidMask = false,
-			uint8_t * validityMask = nullptr);
-
-	ReturnValue_t checkRemainingSize(PoolRawAccess * currentPoolRawAccess,
-			bool * isSerialized, uint8_t * arrayPosition);
-	void handleMaskModification(uint8_t * validityMask);
-	/**
-	 * Sets specific bit of a byte
-	 * @param byte
-	 * @param position Position of byte to set from 1 to 8
-	 * @param value Binary value to set
-	 * @return
-	 */
-	uint8_t bitSetter(uint8_t byte, uint8_t position, bool value);
-};
-
-#endif /* FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_ */

From 673af264724261873f78079e72e5fc109fbf2f63 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 14:57:05 +0200
Subject: [PATCH 0733/1774] rework/restructuring

---
 datapool/DataSetIF.h                         | 7 +++----
 datapool/PoolDataSetIF.h                     | 4 ++++
 datapool/PoolVarList.h                       | 9 +++++----
 datapool/PoolVariableIF.h                    | 6 +++---
 {datapool => datapoolglob}/ControllerSet.cpp | 2 +-
 {datapool => datapoolglob}/ControllerSet.h   | 6 +++---
 datapoollocal/LocalDataPoolManager.cpp       | 6 +++---
 datapoollocal/LocalDataPoolManager.h         | 8 ++++----
 housekeeping/HousekeepingPacketDownlink.h    | 5 +++--
 9 files changed, 29 insertions(+), 24 deletions(-)
 rename {datapool => datapoolglob}/ControllerSet.cpp (79%)
 rename {datapool => datapoolglob}/ControllerSet.h (59%)

diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index b51da3a47..a6634a5c7 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -1,5 +1,5 @@
-#ifndef DATASETIF_H_
-#define DATASETIF_H_
+#ifndef FSFW_DATAPOOL_DATASETIF_H_
+#define FSFW_DATAPOOL_DATASETIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../timemanager/Clock.h"
@@ -34,7 +34,6 @@ public:
 	 */
 	virtual ~DataSetIF() {}
 
-
 	/**
 	 * @brief	This operation provides a method to register local data pool
 	 * 			variables to register in a data set by passing itself
@@ -45,4 +44,4 @@ public:
 	virtual uint16_t getFillCount() const = 0;
 };
 
-#endif /* FRAMEWORK_DATAPOOL_DATASETIF_H_ */
+#endif /* FSFW_DATAPOOL_DATASETIF_H_ */
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index 78c05d433..aa45fa548 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -3,6 +3,10 @@
 
 #include "DataSetIF.h"
 
+/**
+ * @brief   Extendes the DataSetIF by adding abstract functions to lock
+ *          and unlock a data pool and read/commit semantics.
+ */
 class PoolDataSetIF: public DataSetIF {
 public:
     virtual~ PoolDataSetIF() {};
diff --git a/datapool/PoolVarList.h b/datapool/PoolVarList.h
index 1c8a7be48..0b2b0f064 100644
--- a/datapool/PoolVarList.h
+++ b/datapool/PoolVarList.h
@@ -1,5 +1,5 @@
-#ifndef POOLVARLIST_H_
-#define POOLVARLIST_H_
+#ifndef FSFW_DATAPOOL_POOLVARLIST_H_
+#define FSFW_DATAPOOL_POOLVARLIST_H_
 
 #include "../datapool/PoolVariableIF.h"
 #include "../datapoolglob/GlobalPoolVariable.h"
@@ -8,7 +8,8 @@ class PoolVarList {
 private:
 	GlobPoolVar<T> variables[n_var];
 public:
-	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
+	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet,
+	        PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
 		//I really should have a look at the new init list c++ syntax.
 		if (dataSet == NULL) {
 			return;
@@ -25,4 +26,4 @@ public:
 
 
 
-#endif /* POOLVARLIST_H_ */
+#endif /* FSFW_DATAPOOL_POOLVARLIST_H_ */
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 2aa269dd4..cd15f7445 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
-#define FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
+#ifndef FSFW_DATAPOOL_POOLVARIABLEIF_H_
+#define FSFW_DATAPOOL_POOLVARIABLEIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
@@ -96,4 +96,4 @@ protected:
 
 using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
 
-#endif /* POOLVARIABLEIF_H_ */
+#endif /* FSFW_DATAPOOL_POOLVARIABLEIF_H_ */
diff --git a/datapool/ControllerSet.cpp b/datapoolglob/ControllerSet.cpp
similarity index 79%
rename from datapool/ControllerSet.cpp
rename to datapoolglob/ControllerSet.cpp
index 4055158bc..54fc6e8c9 100644
--- a/datapool/ControllerSet.cpp
+++ b/datapoolglob/ControllerSet.cpp
@@ -1,4 +1,4 @@
-#include "../datapool/ControllerSet.h"
+#include <fsfw/datapoolglob/ControllerSet.h>
 
 ControllerSet::ControllerSet() {
 
diff --git a/datapool/ControllerSet.h b/datapoolglob/ControllerSet.h
similarity index 59%
rename from datapool/ControllerSet.h
rename to datapoolglob/ControllerSet.h
index 43e1cbf21..5da113973 100644
--- a/datapool/ControllerSet.h
+++ b/datapoolglob/ControllerSet.h
@@ -1,5 +1,5 @@
-#ifndef CONTROLLERSET_H_
-#define CONTROLLERSET_H_
+#ifndef FSFW_DATAPOOLGLOB_CONTROLLERSET_H_
+#define FSFW_DATAPOOLGLOB_CONTROLLERSET_H_
 
 #include "../datapoolglob/GlobalDataSet.h"
 
@@ -12,4 +12,4 @@ public:
 	void setInvalid();
 };
 
-#endif /* CONTROLLERSET_H_ */
+#endif /*  FSFW_DATAPOOLGLOB_CONTROLLERSET_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 87a0a3cb8..c84b2c697 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,5 +1,5 @@
-#include "../datapoollocal/LocalDataPoolManager.h"
-#include "../datapoollocal/LocalDataSet.h"
+#include "LocalDataPoolManager.h"
+#include "LocalPoolDataSetBase.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
@@ -185,7 +185,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 				" Set ID not found or dataset not assigned!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	sif::info << "hk gen called" << std::endl;
+
 	store_address_t storeId;
 	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
 	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c851978c4..c6567c804 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,14 +1,14 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 
+#include "HasLocalDataPoolIF.h"
+
 #include "../housekeeping/HousekeepingPacketDownlink.h"
+#include "../housekeeping/HousekeepingMessage.h"
 #include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../ipc/MutexIF.h"
-
-#include "../housekeeping/HousekeepingMessage.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapoollocal/HasLocalDataPoolIF.h"
 #include "../ipc/CommandMessage.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MutexHelper.h"
diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
index bee0bac10..ee531bae7 100644
--- a/housekeeping/HousekeepingPacketDownlink.h
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -1,7 +1,8 @@
-#ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
-#define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
 
 #include "../datapoollocal/LocalPoolDataSetBase.h"
+
 #include "../housekeeping/HousekeepingMessage.h"
 #include "../serialize/SerialLinkedListAdapter.h"
 #include "../storagemanager/StorageManagerIF.h"

From 26cbcdbff058a542a30055ba4104b18cb16353a7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 15:21:02 +0200
Subject: [PATCH 0734/1774] removed comment

---
 datapoollocal/SharedLocalDataSet.h | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index b1f9aa3d3..2e5a76fa9 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -6,13 +6,6 @@
 #include "../objectmanager/SystemObject.h"
 #include <vector>
 
-/**
- * Baseline question: If this dataset is shared, is there once instance
- * shared among many objects or multiple instances? Maybe be flexible
- * and provide both ways? Sharing one instance requires a mutex lock.
- * If there are multiple instances, it is not shared anymore, to be fair..
- * Then a regular local data set is sufficient.
- */
 class SharedLocalDataSet: public SystemObject,
         public LocalPoolDataSetBase,
         public SharedDataSetIF {
@@ -28,5 +21,4 @@ private:
 };
 
 
-
 #endif /* FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_ */

From e9b86e51df95c5880ace312ed978933f98abde68 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 15:23:38 +0200
Subject: [PATCH 0735/1774] init commit

---
 datapool/ControllerSet.h                      |  15 -
 datapool/DataPool.cpp                         | 131 --------
 datapool/DataPool.h                           | 135 --------
 datapool/DataSet.cpp                          | 150 ---------
 datapool/DataSet.h                            | 159 ----------
 datapool/DataSetIF.h                          |  56 ++--
 datapool/HkSwitchHelper.cpp                   |  13 +-
 datapool/PoolDataSetBase.cpp                  | 169 ++++++++++
 datapool/PoolDataSetBase.h                    | 152 +++++++++
 datapool/PoolDataSetIF.h                      |  33 ++
 datapool/PoolEntry.cpp                        |   1 +
 datapool/PoolEntry.h                          |   6 +-
 datapool/PoolEntryIF.h                        |   6 +-
 datapool/PoolRawAccess.cpp                    | 187 -----------
 datapool/PoolRawAccess.h                      | 152 ---------
 datapool/PoolVarList.h                        |  17 +-
 datapool/PoolVariable.h                       | 295 ------------------
 datapool/PoolVariableIF.h                     | 114 ++++---
 datapool/PoolVector.h                         | 233 --------------
 datapool/SharedDataSetIF.h                    |  14 +
 {datapool => datapoolglob}/ControllerSet.cpp  |   2 +-
 datapoolglob/ControllerSet.h                  |  15 +
 {datapool => datapoolglob}/DataPoolAdmin.cpp  |  25 +-
 {datapool => datapoolglob}/DataPoolAdmin.h    |  18 +-
 .../DataPoolParameterWrapper.cpp              |  14 +-
 .../DataPoolParameterWrapper.h                |   0
 datapoolglob/GlobalDataPool.cpp               | 133 ++++++++
 datapoolglob/GlobalDataPool.h                 | 149 +++++++++
 datapoolglob/GlobalDataSet.cpp                |  48 +++
 datapoolglob/GlobalDataSet.h                  |  98 ++++++
 datapoolglob/GlobalPoolVariable.h             | 213 +++++++++++++
 datapoolglob/GlobalPoolVariable.tpp           | 117 +++++++
 datapoolglob/GlobalPoolVector.h               | 185 +++++++++++
 datapoolglob/GlobalPoolVector.tpp             | 117 +++++++
 {datapool => datapoolglob}/PIDReader.h        |  39 ++-
 {datapool => datapoolglob}/PIDReaderList.h    |  10 +-
 datapoolglob/PoolRawAccess.cpp                | 239 ++++++++++++++
 datapoolglob/PoolRawAccess.h                  | 220 +++++++++++++
 38 files changed, 2090 insertions(+), 1590 deletions(-)
 delete mode 100644 datapool/ControllerSet.h
 delete mode 100644 datapool/DataPool.cpp
 delete mode 100644 datapool/DataPool.h
 delete mode 100644 datapool/DataSet.cpp
 delete mode 100644 datapool/DataSet.h
 create mode 100644 datapool/PoolDataSetBase.cpp
 create mode 100644 datapool/PoolDataSetBase.h
 create mode 100644 datapool/PoolDataSetIF.h
 delete mode 100644 datapool/PoolRawAccess.cpp
 delete mode 100644 datapool/PoolRawAccess.h
 delete mode 100644 datapool/PoolVariable.h
 delete mode 100644 datapool/PoolVector.h
 create mode 100644 datapool/SharedDataSetIF.h
 rename {datapool => datapoolglob}/ControllerSet.cpp (79%)
 create mode 100644 datapoolglob/ControllerSet.h
 rename {datapool => datapoolglob}/DataPoolAdmin.cpp (94%)
 rename {datapool => datapoolglob}/DataPoolAdmin.h (92%)
 rename {datapool => datapoolglob}/DataPoolParameterWrapper.cpp (95%)
 rename {datapool => datapoolglob}/DataPoolParameterWrapper.h (100%)
 create mode 100644 datapoolglob/GlobalDataPool.cpp
 create mode 100644 datapoolglob/GlobalDataPool.h
 create mode 100644 datapoolglob/GlobalDataSet.cpp
 create mode 100644 datapoolglob/GlobalDataSet.h
 create mode 100644 datapoolglob/GlobalPoolVariable.h
 create mode 100644 datapoolglob/GlobalPoolVariable.tpp
 create mode 100644 datapoolglob/GlobalPoolVector.h
 create mode 100644 datapoolglob/GlobalPoolVector.tpp
 rename {datapool => datapoolglob}/PIDReader.h (77%)
 rename {datapool => datapoolglob}/PIDReaderList.h (68%)
 create mode 100644 datapoolglob/PoolRawAccess.cpp
 create mode 100644 datapoolglob/PoolRawAccess.h

diff --git a/datapool/ControllerSet.h b/datapool/ControllerSet.h
deleted file mode 100644
index e27debff0..000000000
--- a/datapool/ControllerSet.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef CONTROLLERSET_H_
-#define CONTROLLERSET_H_
-
-#include "DataSet.h"
-
-class ControllerSet :public DataSet {
-public:
-	ControllerSet();
-	virtual ~ControllerSet();
-
-	virtual void setToDefault() = 0;
-	void setInvalid();
-};
-
-#endif /* CONTROLLERSET_H_ */
diff --git a/datapool/DataPool.cpp b/datapool/DataPool.cpp
deleted file mode 100644
index 1b6cb7a19..000000000
--- a/datapool/DataPool.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-#include "DataPool.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../ipc/MutexFactory.h"
-
-DataPool::DataPool( void ( *initFunction )( std::map<uint32_t, PoolEntryIF*>* pool_map ) ) {
-	mutex = MutexFactory::instance()->createMutex();
-	if (initFunction != NULL ) {
-		initFunction( &this->data_pool );
-	}
-}
-
-DataPool::~DataPool() {
-	MutexFactory::instance()->deleteMutex(mutex);
-	for ( std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.begin(); it != this->data_pool.end(); ++it ) {
-		delete it->second;
-	}
-}
-
-//The function checks PID, type and array length before returning a copy of the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
-template <typename T> PoolEntry<T>* DataPool::getData( uint32_t data_pool_id,  uint8_t sizeOrPosition ) {
-	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
-	if ( it != this->data_pool.end() ) {
-		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
-		if (entry != NULL ) {
-			if ( sizeOrPosition <= entry->length ) {
-				return entry;
-			}
-		}
-	}
-	return NULL;
-}
-
-PoolEntryIF* DataPool::getRawData( uint32_t data_pool_id ) {
-	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
-	if ( it != this->data_pool.end() ) {
-		return it->second;
-	} else {
-		return NULL;
-	}
-}
-
-//uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t maxSize ) {
-//	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
-//	if ( it != this->data_pool.end() ) {
-//		if ( it->second->getByteSize() <= maxSize ) {
-//			*size = it->second->getByteSize();
-//			memcpy( address, it->second->getRawData(), *size );
-//			return DP_SUCCESSFUL;
-//		}
-//	}
-//	*size = 0;
-//	return DP_FAILURE;
-//}
-
-ReturnValue_t DataPool::freeDataPoolLock() {
-	ReturnValue_t status = mutex->unlockMutex();
-	if ( status != RETURN_OK ) {
-		sif::error << "DataPool::DataPool: unlock of mutex failed with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-ReturnValue_t DataPool::lockDataPool() {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::BLOCKING);
-	if ( status != RETURN_OK ) {
-		sif::error << "DataPool::DataPool: lock of mutex failed with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-void DataPool::print() {
-	sif::debug << "DataPool contains: " << std::endl;
-	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
-	dataPoolIt = this->data_pool.begin();
-	while( dataPoolIt != this->data_pool.end() ) {
-		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
-		dataPoolIt->second->print();
-		dataPoolIt++;
-	}
-}
-
-template PoolEntry<uint8_t>* DataPool::getData<uint8_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<uint16_t>* DataPool::getData<uint16_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<uint32_t>* DataPool::getData<uint32_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<uint64_t>* DataPool::getData<uint64_t>(uint32_t data_pool_id,
-		uint8_t size);
-template PoolEntry<int8_t>* DataPool::getData<int8_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<int16_t>* DataPool::getData<int16_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<int32_t>* DataPool::getData<int32_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<float>* DataPool::getData<float>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<double>* DataPool::getData<double>(uint32_t data_pool_id,
-		uint8_t size);
-
-
-uint32_t DataPool::PIDToDataPoolId(uint32_t parameter_id) {
-	return (parameter_id >> 8) & 0x00FFFFFF;
-}
-
-uint8_t DataPool::PIDToArrayIndex(uint32_t parameter_id) {
-	return (parameter_id & 0x000000FF);
-}
-
-uint32_t DataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
-	return (poolId << 8) + index;
-}
-
-
-//SHOULDDO: Do we need a mutex lock here... I don't think so, as we only check static const values of elements in a list that do not change.
-//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
-ReturnValue_t DataPool::getType(uint32_t parameter_id, Type* type) {
-	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( PIDToDataPoolId(parameter_id));
-	if ( it != this->data_pool.end() ) {
-		*type = it->second->getType();
-		return RETURN_OK;
-	} else {
-		*type = Type::UNKNOWN_TYPE;
-		return RETURN_FAILED;
-	}
-}
-
-bool DataPool::exists(uint32_t parameterId) {
-	uint32_t poolId = PIDToDataPoolId(parameterId);
-	uint32_t index = PIDToArrayIndex(parameterId);
-	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( poolId );
-	if (it != data_pool.end()) {
-		if (it->second->getSize() >= index) {
-			return true;
-		}
-	}
-	return false;
-}
diff --git a/datapool/DataPool.h b/datapool/DataPool.h
deleted file mode 100644
index 7abf28980..000000000
--- a/datapool/DataPool.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- *	\file	DataPool.h
- *
- *  \date	10/17/2012
- *	\author	Bastian Baetz
- *
- *	\brief	This file contains the definition of the DataPool class and (temporarily)
- *			the "extern" definition of the global dataPool instance.
- */
-
-#ifndef DATAPOOL_H_
-#define DATAPOOL_H_
-
-#include "PoolEntry.h"
-#include "../globalfunctions/Type.h"
-#include "../ipc/MutexIF.h"
-#include <map>
-
-/**
- * \defgroup data_pool Data Pool
- * This is the group, where all classes associated with Data Pool Handling belong to.
- * This includes classes to access Data Pool variables.
- */
-
-#define DP_SUCCESSFUL	0
-#define DP_FAILURE		1
-
-/**
- *	\brief		This class represents the OBSW global data-pool.
- *
- *	\details	All variables are registered and space is allocated in an initialization
- *				function, which is passed do the constructor.
- *				Space for the variables is allocated on the heap (with a new call).
- *				The data is found by a data pool id, which uniquely represents a variable.
- *				Data pool variables should be used with a blackboard logic in mind,
- *				which means read data is valid (if flagged so), but not necessarily up-to-date.
- *				Variables are either single values or arrays.
- *	\ingroup data_pool
- */
-class DataPool : public HasReturnvaluesIF {
-private:
-	/**
-	 * \brief	This is the actual data pool itself.
-	 * \details	It is represented by a map
-	 * 			with the data pool id as index and a pointer to a single PoolEntry as value.
-	 */
-	std::map<uint32_t, PoolEntryIF*> data_pool;
-public:
-	/**
-	 * \brief	The mutex is created in the constructor and makes access mutual exclusive.
-	 * \details	Locking and unlocking the pool is only done by the DataSet class.
-	 */
-	MutexIF*	mutex;
-	/**
-	 * \brief	In the classes constructor, the passed initialization function is called.
-	 * \details	To enable filling the pool,
-	 * 			a pointer to the map is passed, allowing direct access to the pool's content.
-	 * 			On runtime, adding or removing variables is forbidden.
-	 */
-	DataPool( void ( *initFunction )( std::map<uint32_t, PoolEntryIF*>* pool_map ) );
-	/**
-	 * 	\brief	The destructor iterates through the data_pool map and calls all Entries destructors to clean up the heap.
-	 */
-	~DataPool();
-	/**
-	 * \brief	This is the default call to access the pool.
-	 * \details	A pointer to the PoolEntry object is returned.
-	 *  		The call checks data pool id, type and array size. Returns NULL in case of failure.
-	 * \param data_pool_id	The data pool id to search.
-	 * \param sizeOrPosition The array size (not byte size!) of the pool entry, or the position the user wants to read.
-	 * 			If smaller than the entry size, everything's ok.
-	 */
-	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id, uint8_t sizeOrPosition );
-	/**
-	 * \brief	An alternative call to get a data pool entry in case the type is not implicitly known
-	 * 			(i.e. in Housekeeping Telemetry).
-	 * \details	It returns a basic interface and does NOT perform
-	 * 			a size check. The caller has to assure he does not copy too much data.
-	 * 			Returns NULL in case the entry is not found.
-	 * \param data_pool_id	The data pool id to search.
-	 */
-	PoolEntryIF* getRawData( uint32_t data_pool_id );
-	/**
-	 * \brief	This is a small helper function to facilitate locking the global data pool.
-	 * \details	It fetches the pool's mutex id and tries to acquire the mutex.
-	 */
-	ReturnValue_t lockDataPool();
-	/**
-	 * \brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * \details	It fetches the pool's mutex id and tries to free the mutex.
-	 */
-	ReturnValue_t freeDataPoolLock();
-	/**
-	 * \brief	The print call is a simple debug method.
-	 * \details	It prints the current content of the data pool.
-	 *  		It iterates through the data_pool map and calls each entry's print() method.
-	 */
-	void print();
-	/**
-	 * Extracts the data pool id from a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The data pool id as used within the OBSW.
-	 */
-	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
-	/**
-	 * Extracts an array index out of a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The index of the corresponding data pool entry.
-	 */
-	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
-	/**
-	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
-	 */
-	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
-
-	/**
-	 * Method to return the type of a pool variable.
-	 * @param parameter_id A parameterID (not pool id) of a DP member.
-	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
-	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
-	 */
-	ReturnValue_t getType( uint32_t parameter_id, Type* type );
-
-	/**
-	 * Method to check if a PID exists.
-	 * Does not lock, as there's no possibility to alter the list that is checked during run-time.
-	 * @param parameterId The PID (not pool id!) of a parameter.
-	 * @return	true if exists, false else.
-	 */
-	bool exists(uint32_t parameterId);
-};
-
-//We assume someone globally instantiates a DataPool.
-extern DataPool dataPool;
-#endif /* DATAPOOL_H_ */
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
deleted file mode 100644
index e41489bd9..000000000
--- a/datapool/DataSet.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-#include "DataSet.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-DataSet::DataSet() :
-		fill_count(0), state(DATA_SET_UNINITIALISED) {
-	for (unsigned count = 0; count < DATA_SET_MAX_SIZE; count++) {
-		registeredVariables[count] = NULL;
-	}
-}
-
-DataSet::~DataSet() {
-	//Don't do anything with your variables, they are dead already! (Destructor is already called)
-}
-
-ReturnValue_t DataSet::read() {
-	ReturnValue_t result = RETURN_OK;
-	if (state == DATA_SET_UNINITIALISED) {
-		lockDataPool();
-		for (uint16_t count = 0; count < fill_count; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					!= PoolVariableIF::VAR_WRITE
-					&& registeredVariables[count]->getDataPoolId()
-							!= PoolVariableIF::NO_PARAMETER) {
-				ReturnValue_t status = registeredVariables[count]->read();
-				if (status != RETURN_OK) {
-					result = INVALID_PARAMETER_DEFINITION;
-					break;
-				}
-			}
-		}
-		state = DATA_SET_WAS_READ;
-		freeDataPoolLock();
-	} else {
-		sif::error << "DataSet::read(): Call made in wrong position." << std::endl;
-		result = SET_WAS_ALREADY_READ;
-	}
-	return result;
-}
-
-ReturnValue_t DataSet::commit(uint8_t valid) {
-	setValid(valid);
-	return commit();
-}
-
-ReturnValue_t DataSet::commit() {
-	if (state == DATA_SET_WAS_READ) {
-		lockDataPool();
-		for (uint16_t count = 0; count < fill_count; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					!= PoolVariableIF::VAR_READ
-					&& registeredVariables[count]->getDataPoolId()
-							!= PoolVariableIF::NO_PARAMETER) {
-				registeredVariables[count]->commit();
-			}
-		}
-		state = DATA_SET_UNINITIALISED;
-		freeDataPoolLock();
-		return RETURN_OK;
-	} else {
-		ReturnValue_t result = RETURN_OK;
-		lockDataPool();
-		for (uint16_t count = 0; count < fill_count; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					== PoolVariableIF::VAR_WRITE
-					&& registeredVariables[count]->getDataPoolId()
-							!= PoolVariableIF::NO_PARAMETER) {
-				registeredVariables[count]->commit();
-			} else if (registeredVariables[count]->getDataPoolId()
-					!= PoolVariableIF::NO_PARAMETER) {
-				if (result != COMMITING_WITHOUT_READING) {
-					sif::error <<
-					        "DataSet::commit(): commit-without-read "
-					        "call made with non write-only variable." << std::endl;
-					result = COMMITING_WITHOUT_READING;
-				}
-			}
-		}
-		state = DATA_SET_UNINITIALISED;
-		freeDataPoolLock();
-		return result;
-	}
-
-}
-
-void DataSet::registerVariable(PoolVariableIF* variable) {
-	if (state == DATA_SET_UNINITIALISED) {
-		if (variable != NULL) {
-			if (fill_count < DATA_SET_MAX_SIZE) {
-				registeredVariables[fill_count] = variable;
-				fill_count++;
-				return;
-			}
-		}
-	}
-	sif::error
-			<< "DataSet::registerVariable: failed. Either NULL, or set is full, or call made in wrong position."
-			<< std::endl;
-	return;
-}
-
-uint8_t DataSet::freeDataPoolLock() {
-	return ::dataPool.freeDataPoolLock();
-}
-
-uint8_t DataSet::lockDataPool() {
-	return ::dataPool.lockDataPool();
-}
-
-ReturnValue_t DataSet::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->serialize(buffer, size, maxSize,
-				streamEndianness);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-size_t DataSet::getSerializedSize() const {
-	size_t size = 0;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		size += registeredVariables[count]->getSerializedSize();
-	}
-	return size;
-}
-
-void DataSet::setValid(uint8_t valid) {
-	for (uint16_t count = 0; count < fill_count; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ) {
-			registeredVariables[count]->setValid(valid);
-		}
-	}
-}
-
-ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, size_t* size,
-		Endianness streamEndianness) {
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->deSerialize(buffer, size,
-				streamEndianness);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
deleted file mode 100644
index 04044bfe5..000000000
--- a/datapool/DataSet.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * \file	DataSet.h
- *
- * \brief	This file contains the DataSet class and a small structure called DataSetContent.
- *
- * \date	10/17/2012
- *
- * \author	Bastian Baetz
- *
- */
-
-#ifndef DATASET_H_
-#define DATASET_H_
-
-#include "DataPool.h"
-#include "DataSetIF.h"
-#include "PoolRawAccess.h"
-#include "PoolVariable.h"
-#include "PoolVarList.h"
-#include "PoolVector.h"
-#include "../serialize/SerializeAdapter.h"
-/**
- * \brief	The DataSet class manages a set of locally checked out variables.
- *
- * \details	This class manages a list, where a set of local variables (or pool variables) are
- * 			registered. They are checked-out (i.e. their values are looked up and copied)
- * 			with the read call. After the user finishes working with the pool variables,
- * 			he can write back all variable values to the pool with the commit call.
- * 			The data set manages locking and freeing the data pool, to ensure that all values
- * 			are read and written back at once.
- * 			An internal state manages usage of this class. Variables may only be registered before
- * 			the read call is made, and the commit call only after the read call.
- * 			If pool variables are writable and not committed until destruction of the set, the
- * 			DataSet class automatically sets the valid flag in the data pool to invalid (without)
- * 			changing the variable's value.
- *
- *	\ingroup data_pool
- */
-class DataSet: public DataSetIF, public HasReturnvaluesIF, public SerializeIF {
-private:
-	//SHOULDDO we could use a linked list of datapool variables
-	static const uint8_t DATA_SET_MAX_SIZE = 63; //!< This definition sets the maximum number of variables to register in one DataSet.
-
-	/**
-	 * \brief	This array represents all pool variables registered in this set.
-	 * \details	It has a maximum size of DATA_SET_MAX_SIZE.
-	 */
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-	/**
-	 * \brief	The fill_count attribute ensures that the variables register in the correct array
-	 * 			position and that the maximum number of variables is not exceeded.
-	 */
-	uint16_t fill_count;
-	/**
-	 * States of the seet.
-	 */
-	enum States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
-	};
-	/**
-	 * \brief	state manages the internal state of the data set, which is important e.g. for the
-	 * 			behavior on destruction.
-	 */
-	States state;
-	/**
-	 * \brief	This is a small helper function to facilitate locking the global data pool.
-	 * \details	It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	uint8_t lockDataPool();
-	/**
-	 * \brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * \details	It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	uint8_t freeDataPoolLock();
-
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
-	static const ReturnValue_t INVALID_PARAMETER_DEFINITION =
-			MAKE_RETURN_CODE( 0x01 );
-	static const ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
-	static const ReturnValue_t COMMITING_WITHOUT_READING =
-			MAKE_RETURN_CODE(0x03);
-
-	/**
-	 * \brief	The constructor simply sets the fill_count to zero and sets the state to "uninitialized".
-	 */
-	DataSet();
-	/**
-	 * \brief	The destructor automatically manages writing the valid information of variables.
-	 * \details	In case the data set was read out, but not committed (indicated by state),
-	 * 			the destructor parses all variables that are still registered to the set.
-	 * 			For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~DataSet();
-	/**
-	 * \brief	The read call initializes reading out all registered variables.
-	 * \details	It iterates through the list of registered variables and calls all read()
-	 * 			functions of the registered pool variables (which read out their values from the
-	 * 			data pool) which are not write-only. In case of an error (e.g. a wrong data type,
-	 * 			or an invalid data pool id), the operation is aborted and
-	 * 			\c INVALID_PARAMETER_DEFINITION returned.
-	 * 			The data pool is locked during the whole read operation and freed afterwards.
-	 * 			The state changes to "was written" after this operation.
-	 * \return	- \c RETURN_OK if all variables were read successfully.
-	 * 			- \c INVALID_PARAMETER_DEFINITION if PID, size or type of the
-	 * 					requested variable is invalid.
-	 * 			- \c SET_WAS_ALREADY_READ if read() is called twice without calling
-	 * 					commit() in between
-	 */
-	ReturnValue_t read();
-	/**
-	 * \brief	The commit call initializes writing back the registered variables.
-	 * \details	It iterates through the list of registered variables and calls
-	 * 			the commit() method of the remaining registered variables (which write back
-	 * 			their values to the pool).
-	 * 			The data pool is locked during the whole commit operation and freed afterwards.
-	 * 			The state changes to "was committed" after this operation.
-	 * 			If the set does contain at least one variable which is not write-only commit()
-	 * 			can only be called after read(). If the set only contains variables which are
-	 * 			write only, commit() can be called without a preceding read() call.
-	 * \return	- \c RETURN_OK if all variables were read successfully.
-	 * 			- \c COMMITING_WITHOUT_READING if set was not read yet and contains non write-only
-	 * 				variables
-	 */
-	ReturnValue_t commit(void);
-	/**
-	 * Variant of method above which sets validity of all elements of the set.
-	 * @param valid Validity information from PoolVariableIF.
-	 * \return	- \c RETURN_OK if all variables were read successfully.
-	 * 			- \c COMMITING_WITHOUT_READING if set was not read yet and contains non write-only
-	 * 				variables
-	 */
-	ReturnValue_t commit(uint8_t valid);
-	/**
-	 * \brief	This operation is used to register the local variables in the set.
-	 * \details	It copies all required information to the currently
-	 * 			free space in the registeredVariables list.
-	 */
-	void registerVariable(PoolVariableIF* variable);
-
-	/**
-	 * Set the valid information of all variables contained in the set which are not readonly
-	 *
-	 * @param valid Validity information from PoolVariableIF.
-	 */
-	void setValid(uint8_t valid);
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	size_t getSerializedSize() const override;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-
-};
-
-#endif /* DATASET_H_ */
diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index 7741477db..a6634a5c7 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -1,39 +1,47 @@
-/**
- * \file	DataSetIF.h
- *
- * \brief	This file contains the small interface to access the DataSet class.
- *
- * \date	10/23/2012
- *
- * \author	Bastian Baetz
- *
- */
-
-#ifndef DATASETIF_H_
-#define DATASETIF_H_
+#ifndef FSFW_DATAPOOL_DATASETIF_H_
+#define FSFW_DATAPOOL_DATASETIF_H_
 
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Clock.h"
 class PoolVariableIF;
 
 /**
- * \brief	This class defines a small interface to register on a DataSet.
+ * @brief	This class defines a small interface to register on a DataSet.
  *
- * \details	Currently, the only purpose of this interface is to provide a method for locally
- * 			checked-out variables to register on a data set. Still, it may become useful for
- * 			other purposes as well.
- *
- *	\ingroup data_pool
+ * @details
+ * Currently, the only purpose of this interface is to provide a
+ * method for locally checked-out variables to register on a data set.
+ * Still, it may become useful for other purposes as well.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
  */
 class DataSetIF {
 public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
+	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION =
+			MAKE_RETURN_CODE( 0x01 );
+	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
+	static constexpr ReturnValue_t COMMITING_WITHOUT_READING =
+			MAKE_RETURN_CODE(0x03);
+
+	static constexpr ReturnValue_t DATA_SET_UNINITIALISED = MAKE_RETURN_CODE( 0x04 );
+	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE( 0x05 );
+	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE( 0x06 );
+
 	/**
-	 * \brief	This is an empty virtual destructor, as it is proposed for C++ interfaces.
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is proposed for C++ interfaces.
 	 */
 	virtual ~DataSetIF() {}
+
 	/**
-	 * \brief	This operation provides a method to register local data pool variables
-	 * 			to register in a data set by passing itself to this DataSet operation.
+	 * @brief	This operation provides a method to register local data pool
+	 * 			variables to register in a data set by passing itself
+	 * 			to this DataSet operation.
 	 */
-	virtual void registerVariable( PoolVariableIF* variable ) = 0;
+	virtual ReturnValue_t registerVariable(PoolVariableIF* variable) = 0;
+
+	virtual uint16_t getFillCount() const = 0;
 };
 
-#endif /* DATASETIF_H_ */
+#endif /* FSFW_DATAPOOL_DATASETIF_H_ */
diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp
index 04096acaf..1a2a25eb9 100644
--- a/datapool/HkSwitchHelper.cpp
+++ b/datapool/HkSwitchHelper.cpp
@@ -1,5 +1,4 @@
-#include "HkSwitchHelper.h"
-//#include <mission/tmtcservices/HKService_03.h>
+#include "../datapool/HkSwitchHelper.h"
 #include "../ipc/QueueFactory.h"
 
 HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
@@ -22,14 +21,14 @@ ReturnValue_t HkSwitchHelper::initialize() {
 }
 
 ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
-	CommandMessage message;
-	while (actionQueue->receiveMessage(&message) == HasReturnvaluesIF::RETURN_OK) {
-		ReturnValue_t result = commandActionHelper.handleReply(&message);
+	CommandMessage command;
+	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
+		ReturnValue_t result = commandActionHelper.handleReply(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			continue;
 		}
-		message.setToUnknownCommand();
-		actionQueue->reply(&message);
+		command.setToUnknownCommand();
+		actionQueue->reply(&command);
 	}
 
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
new file mode 100644
index 000000000..1acd3fd3b
--- /dev/null
+++ b/datapool/PoolDataSetBase.cpp
@@ -0,0 +1,169 @@
+#include "PoolDataSetBase.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
+        const size_t maxFillCount):
+        registeredVariables(registeredVariablesArray),
+        maxFillCount(maxFillCount) {
+}
+
+PoolDataSetBase::~PoolDataSetBase() {}
+
+ReturnValue_t PoolDataSetBase::registerVariable(
+		PoolVariableIF *variable) {
+	if (state != States::DATA_SET_UNINITIALISED) {
+		sif::error << "DataSet::registerVariable: "
+				"Call made in wrong position." << std::endl;
+		return DataSetIF::DATA_SET_UNINITIALISED;
+	}
+	if (variable == nullptr) {
+		sif::error << "DataSet::registerVariable: "
+				"Pool variable is nullptr." << std::endl;
+		return DataSetIF::POOL_VAR_NULL;
+	}
+	if (fillCount >= maxFillCount) {
+		sif::error << "DataSet::registerVariable: "
+				"DataSet is full." << std::endl;
+		return DataSetIF::DATA_SET_FULL;
+	}
+	registeredVariables[fillCount] = variable;
+	fillCount++;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	if (state == States::DATA_SET_UNINITIALISED) {
+		lockDataPool(lockTimeout);
+		for (uint16_t count = 0; count < fillCount; count++) {
+			result = readVariable(count);
+			if(result != RETURN_OK) {
+				break;
+			}
+		}
+		state = States::DATA_SET_WAS_READ;
+		unlockDataPool();
+	}
+	else {
+		sif::error << "DataSet::read(): "
+				"Call made in wrong position. Don't forget to commit"
+				" member datasets!" << std::endl;
+		result = SET_WAS_ALREADY_READ;
+	}
+	return result;
+}
+
+uint16_t PoolDataSetBase::getFillCount() const {
+    return fillCount;
+}
+
+ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	// These checks are often performed by the respective
+	// variable implementation too, but I guess a double check does not hurt.
+	if (registeredVariables[count]->getReadWriteMode() !=
+				PoolVariableIF::VAR_WRITE and
+		registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER)
+	{
+		result = registeredVariables[count]->readWithoutLock();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			result = INVALID_PARAMETER_DEFINITION;
+		}
+	}
+	return result;
+}
+
+ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
+	if (state == States::DATA_SET_WAS_READ) {
+		handleAlreadyReadDatasetCommit(lockTimeout);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return handleUnreadDatasetCommit(lockTimeout);
+	}
+}
+
+void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
+	lockDataPool(lockTimeout);
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				!= PoolVariableIF::VAR_READ
+				&& registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			registeredVariables[count]->commitWithoutLock();
+		}
+	}
+	state = States::DATA_SET_UNINITIALISED;
+	unlockDataPool();
+}
+
+ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	lockDataPool(lockTimeout);
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				== PoolVariableIF::VAR_WRITE
+				&& registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			registeredVariables[count]->commitWithoutLock();
+		} else if (registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			if (result != COMMITING_WITHOUT_READING) {
+				sif::error << "DataSet::commit(): commit-without-read call made "
+						"with non write-only variable." << std::endl;
+				result = COMMITING_WITHOUT_READING;
+			}
+		}
+	}
+	state = States::DATA_SET_UNINITIALISED;
+	unlockDataPool();
+	return result;
+}
+
+
+ReturnValue_t PoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PoolDataSetBase::unlockDataPool() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PoolDataSetBase::serialize(uint8_t** buffer, size_t* size,
+		const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		result = registeredVariables[count]->serialize(buffer, size, maxSize,
+		        streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+ReturnValue_t PoolDataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
+        SerializeIF::Endianness streamEndianness) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		result = registeredVariables[count]->deSerialize(buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+size_t PoolDataSetBase::getSerializedSize() const {
+	uint32_t size = 0;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		size += registeredVariables[count]->getSerializedSize();
+	}
+	return size;
+}
+
+void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
+    this->registeredVariables = variablesContainer;
+}
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
new file mode 100644
index 000000000..a8931d628
--- /dev/null
+++ b/datapool/PoolDataSetBase.h
@@ -0,0 +1,152 @@
+#ifndef FSFW_DATAPOOL_POOLDATASETBASE_H_
+#define FSFW_DATAPOOL_POOLDATASETBASE_H_
+
+#include "PoolDataSetIF.h"
+#include "PoolVariableIF.h"
+#include "../ipc/MutexIF.h"
+
+/**
+ * @brief	The DataSetBase class manages a set of locally checked out variables.
+ * @details
+ * This class manages a list, where a set of local variables (or pool variables)
+ * are registered. They are checked-out (i.e. their values are looked
+ * up and copied) with the read call. After the user finishes working with the
+ * pool variables, he can write back all variable values to the pool with
+ * the commit call. The data set manages locking and freeing the data pool,
+ * to ensure that all values are read and written back at once.
+ *
+ * An internal state manages usage of this class. Variables may only be
+ * registered before the read call is made, and the commit call only
+ * after the read call.
+ *
+ * If pool variables are writable and not committed until destruction
+ * of the set, the DataSet class automatically sets the valid flag in the
+ * data pool to invalid (without) changing the variable's value.
+ *
+ * The base class lockDataPool und unlockDataPool implementation are empty
+ * and should be implemented to protect the underlying pool type.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class PoolDataSetBase: public PoolDataSetIF,
+		public SerializeIF,
+		public HasReturnvaluesIF {
+public:
+
+	/**
+	 * @brief	Creates an empty dataset. Use registerVariable or
+	 * 			supply a pointer to this dataset to PoolVariable
+	 * 			initializations to register pool variables.
+	 */
+	PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
+	        const size_t maxFillCount);
+	virtual~ PoolDataSetBase();
+
+	/**
+	 * @brief	The read call initializes reading out all registered variables.
+	 * @details
+	 * It iterates through the list of registered variables and calls all read()
+	 * functions of the registered pool variables (which read out their values
+	 * from the data pool) which are not write-only.
+	 * In case of an error (e.g. a wrong data type, or an invalid data pool id),
+	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
+	 *
+	 * The data pool is locked during the whole read operation and
+	 * freed afterwards.The state changes to "was written" after this operation.
+	 * @return
+	 * - @c RETURN_OK if all variables were read successfully.
+	 * - @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
+	 * requested variable is invalid.
+	 * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
+	 * commit() in between
+	 */
+	virtual ReturnValue_t read(uint32_t lockTimeout =
+			MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call initializes writing back the registered variables.
+	 * @details
+	 * It iterates through the list of registered variables and calls the
+	 * commit() method of the remaining registered variables (which write back
+	 * their values to the pool).
+	 *
+	 * The data pool is locked during the whole commit operation and
+	 * freed afterwards. The state changes to "was committed" after this operation.
+	 *
+	 * If the set does contain at least one variable which is not write-only
+	 * commit() can only be called after read(). If the set only contains
+	 * variables which are write only, commit() can be called without a
+	 * preceding read() call.
+	 * @return	- @c RETURN_OK if all variables were read successfully.
+	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
+	 * 			  contains non write-only variables
+	 */
+	virtual ReturnValue_t commit(uint32_t lockTimeout =
+			MutexIF::BLOCKING) override;
+
+	/**
+	 * Register the passed pool variable instance into the data set.
+	 * @param variable
+	 * @return
+	 */
+	virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override;
+	/**
+	 * Provides the means to lock the underlying data structure to ensure
+	 * thread-safety. Default implementation is empty
+	 * @return Always returns -@c RETURN_OK
+	 */
+	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs =
+			MutexIF::BLOCKING) override;
+	/**
+	 * Provides the means to unlock the underlying data structure to ensure
+	 * thread-safety. Default implementation is empty
+	 * @return Always returns -@c RETURN_OK
+	 */
+	virtual ReturnValue_t unlockDataPool() override;
+
+	virtual uint16_t getFillCount() const;
+
+	/* SerializeIF implementations */
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				const size_t maxSize,
+				SerializeIF::Endianness streamEndianness) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override;
+
+protected:
+	/**
+	 * @brief	The fill_count attribute ensures that the variables
+	 * 			register in the correct array position and that the maximum
+	 * 			number of variables is not exceeded.
+	 */
+	uint16_t fillCount = 0;
+	/**
+	 * States of the seet.
+	 */
+	enum class States {
+		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
+		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
+	};
+	/**
+	 * @brief	state manages the internal state of the data set,
+	 *          which is important e.g. for the behavior on destruction.
+	 */
+	States state = States::DATA_SET_UNINITIALISED;
+
+	/**
+	 * @brief	This array represents all pool variables registered in this set.
+	 * Child classes can use a static or dynamic container to create
+	 * an array of registered variables and assign the first entry here.
+	 */
+	PoolVariableIF** registeredVariables = nullptr;
+	const size_t maxFillCount = 0;
+
+	void setContainer(PoolVariableIF** variablesContainer);
+
+private:
+	ReturnValue_t readVariable(uint16_t count);
+	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
+	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
+};
+
+#endif /* FSFW_DATAPOOL_POOLDATASETBASE_H_ */
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
new file mode 100644
index 000000000..aa45fa548
--- /dev/null
+++ b/datapool/PoolDataSetIF.h
@@ -0,0 +1,33 @@
+#ifndef FSFW_DATAPOOL_POOLDATASETIF_H_
+#define FSFW_DATAPOOL_POOLDATASETIF_H_
+
+#include "DataSetIF.h"
+
+/**
+ * @brief   Extendes the DataSetIF by adding abstract functions to lock
+ *          and unlock a data pool and read/commit semantics.
+ */
+class PoolDataSetIF: public DataSetIF {
+public:
+    virtual~ PoolDataSetIF() {};
+
+    virtual ReturnValue_t read(dur_millis_t lockTimeout) = 0;
+    virtual ReturnValue_t commit(dur_millis_t lockTimeout) = 0;
+
+    /**
+     * @brief   Most underlying data structures will have a pool like structure
+     *          and will require a lock and unlock mechanism to ensure
+     *          thread-safety
+     * @return Lock operation result
+     */
+    virtual ReturnValue_t lockDataPool(dur_millis_t timeoutMs) = 0;
+    /**
+     * @brief   Unlock call corresponding to the lock call.
+     * @return Unlock operation result
+     */
+    virtual ReturnValue_t unlockDataPool() = 0;
+
+    virtual bool isValid() const = 0;
+};
+
+#endif /* FSFW_DATAPOOL_POOLDATASETIF_H_ */
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 56e489a5e..fb73328ca 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,4 +1,5 @@
 #include "PoolEntry.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../globalfunctions/arrayprinter.h"
 #include <cstring>
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 7b47c6739..033db40d0 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
+#ifndef FSFW_DATAPOOL_POOLENTRY_H_
+#define FSFW_DATAPOOL_POOLENTRY_H_
 
 #include "PoolEntryIF.h"
 
@@ -127,4 +127,4 @@ public:
 	Type getType();
 };
 
-#endif /* POOLENTRY_H_ */
+#endif /* FSFW_DATAPOOL_POOLENTRY_H_ */
diff --git a/datapool/PoolEntryIF.h b/datapool/PoolEntryIF.h
index 462de18b8..d9db52375 100644
--- a/datapool/PoolEntryIF.h
+++ b/datapool/PoolEntryIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+#ifndef FSFW_DATAPOOL_POOLENTRYIF_H_
+#define FSFW_DATAPOOL_POOLENTRYIF_H_
 
 #include "../globalfunctions/Type.h"
 #include <cstdint>
@@ -60,4 +60,4 @@ public:
 	virtual Type getType() = 0;
 };
 
-#endif /* POOLENTRYIF_H_ */
+#endif /* FSFW_DATAPOOL_POOLENTRYIF_H_ */
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
deleted file mode 100644
index f92640813..000000000
--- a/datapool/PoolRawAccess.cpp
+++ /dev/null
@@ -1,187 +0,0 @@
-#include "DataPool.h"
-#include "PoolEntryIF.h"
-#include "PoolRawAccess.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serialize/EndianConverter.h"
-
-#include <cstring>
-
-PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF *data_set, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false), type(
-				Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0), readWriteMode(
-				setReadWriteMode) {
-	memset(value, 0, sizeof(value));
-	if (data_set != NULL) {
-		data_set->registerVariable(this);
-	}
-}
-
-PoolRawAccess::~PoolRawAccess() {
-
-}
-
-ReturnValue_t PoolRawAccess::read() {
-	PoolEntryIF *read_out = ::dataPool.getRawData(dataPoolId);
-	if (read_out != NULL) {
-		valid = read_out->getValid();
-		if (read_out->getSize() > arrayEntry) {
-			arraySize = read_out->getSize();
-			typeSize = read_out->getByteSize() / read_out->getSize();
-			type = read_out->getType();
-			if (typeSize <= sizeof(value)) {
-				uint16_t arrayPosition = arrayEntry * typeSize;
-				sizeTillEnd = read_out->getByteSize() - arrayPosition;
-				uint8_t *ptr =
-						&((uint8_t*) read_out->getRawData())[arrayPosition];
-				memcpy(value, ptr, typeSize);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				//Error value type too large.
-			}
-		} else {
-			//Error index requested too large
-		}
-	} else {
-		//Error entry does not exist.
-	}
-	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex
-			<< dataPoolId << std::dec << " failed." << std::endl;
-	valid = INVALID;
-	typeSize = 0;
-	sizeTillEnd = 0;
-	memset(value, 0, sizeof(value));
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t PoolRawAccess::commit() {
-	PoolEntryIF *write_back = ::dataPool.getRawData(dataPoolId);
-	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-		write_back->setValid(valid);
-		uint8_t array_position = arrayEntry * typeSize;
-		uint8_t *ptr = &((uint8_t*) write_back->getRawData())[array_position];
-		memcpy(ptr, value, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t* PoolRawAccess::getEntry() {
-	return value;
-}
-
-ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t *buffer,
-		size_t *writtenBytes, size_t maxSize) {
-	uint8_t *data_ptr = getEntry();
-//	debug << "PoolRawAccess::getEntry: Array position: " << index * size_of_type << " Size of T: " << (int)size_of_type << " ByteSize: " << byte_size << " Position: " << *size << std::endl;
-	if (typeSize == 0) {
-		return DATA_POOL_ACCESS_FAILED;
-	}
-	if (typeSize > maxSize) {
-		return INCORRECT_SIZE;
-	}
-	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
-	*writtenBytes = typeSize;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-Type PoolRawAccess::getType() {
-	return type;
-}
-
-size_t PoolRawAccess::getSizeOfType() {
-	return typeSize;
-}
-
-size_t PoolRawAccess::getArraySize() {
-	return arraySize;
-}
-
-uint32_t PoolRawAccess::getDataPoolId() const {
-	return dataPoolId;
-}
-
-PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
-	return readWriteMode;
-}
-
-ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
-		size_t setSize) {
-	if (typeSize == setSize) {
-		EndianConverter::convertBigEndian(value, buffer, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		sif::error
-				<< "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: Internal"
-				<< (uint32_t) typeSize << ", Requested: " << setSize
-				<< std::endl;
-		return INCORRECT_SIZE;
-	}
-}
-
-bool PoolRawAccess::isValid() const {
-	if (valid != INVALID)
-		return true;
-	else
-		return false;
-}
-
-void PoolRawAccess::setValid(uint8_t valid) {
-	this->valid = valid;
-}
-
-size_t PoolRawAccess::getSizeTillEnd() const {
-	return sizeTillEnd;
-}
-
-ReturnValue_t PoolRawAccess::serialize(uint8_t **buffer, size_t *size,
-		size_t maxSize, Endianness streamEndianness) const {
-	if (typeSize + *size <= maxSize) {
-		switch (streamEndianness) {
-		case (Endianness::BIG):
-			EndianConverter::convertBigEndian(*buffer, value, typeSize);
-			break;
-		case (Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
-			break;
-		default:
-		case (Endianness::MACHINE):
-			memcpy(*buffer, value, typeSize);
-			break;
-		}
-		*size += typeSize;
-		(*buffer) += typeSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SerializeIF::BUFFER_TOO_SHORT;
-	}
-}
-
-size_t PoolRawAccess::getSerializedSize() const {
-	return typeSize;
-}
-
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
-		Endianness streamEndianness) {
-
-	if (*size >= typeSize) {
-		switch (streamEndianness) {
-		case (Endianness::BIG):
-			EndianConverter::convertBigEndian(value, *buffer, typeSize);
-			break;
-		case (Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
-			break;
-		default:
-		case (Endianness::MACHINE):
-			memcpy(value, *buffer, typeSize);
-			break;
-		}
-		*size -= typeSize;
-		*buffer += typeSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SerializeIF::STREAM_TOO_SHORT;
-	}
-}
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
deleted file mode 100644
index 0c7a06bf6..000000000
--- a/datapool/PoolRawAccess.h
+++ /dev/null
@@ -1,152 +0,0 @@
-#ifndef POOLRAWACCESS_H_
-#define POOLRAWACCESS_H_
-
-#include "DataSetIF.h"
-#include "PoolVariableIF.h"
-
-/**
- * This class allows accessing Data Pool variables as raw bytes.
- * This is necessary to have an access method for HK data, as the PID's alone do not
- * provide a type information.
- *	\ingroup data_pool
- */
-class PoolRawAccess: public PoolVariableIF {
-private:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The array entry that is fetched from the data pool.
-	 */
-	uint8_t arrayEntry;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 *  \brief	This value contains the type of the data pool entry.
-	 */
-	Type type;
-	/**
-	 * \brief	This value contains the size of the data pool entry in bytes.
-	 */
-	size_t typeSize;
-	/**
-	 * The size of the DP array (single values return 1)
-	 */
-	size_t arraySize;
-	/**
-	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
-	 */
-	size_t sizeTillEnd;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
-protected:
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read();
-	/**
-	 * \brief	The commit call writes back the variable's value to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit();
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
-	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
-	uint8_t value[RAW_MAX_SIZE];
-	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
-			DataSetIF *data_set, ReadWriteMode_t setReadWriteMode =
-					PoolVariableIF::VAR_READ);
-	/**
-	 * \brief	The classes destructor is empty. If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolRawAccess();
-	/**
-	 * \brief	This operation returns a pointer to the entry fetched.
-	 * \details	This means, it does not return a pointer to byte "index", but to the start byte of
-	 * 			array entry "index". Example: If the original data pool array consists of an double
-	 * 			array of size four, getEntry(1) returns &(this->value[8]).
-	 */
-	uint8_t* getEntry();
-	/**
-	 * \brief 	This operation returns the fetched entry from the data pool and
-	 * 			flips the bytes, if necessary.
-	 * \details	It makes use of the getEntry call of this function, but additionally flips the
-	 * 			bytes to big endian, which is the default for external communication (as House-
-	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given maxSize.
-	 * \param buffer	A pointer to a buffer to write to
-	 * \param writtenBytes	The number of bytes written is returned with this value.
-	 * \param maxSize	The maximum size that the function may write to buffer.
-	 * \return	- \c RETURN_OK if entry could be acquired
-	 * 			- \c RETURN_FAILED else.
-	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
-			size_t maxSize);
-	/**
-	 * With this method, the content can be set from a big endian buffer safely.
-	 * @param buffer	Pointer to the data to set
-	 * @param size		Size of the data to write. Must fit this->size.
-	 * @return	- \c RETURN_OK on success
-	 * 			- \c RETURN_FAILED on failure
-	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t *buffer,
-			size_t setSize);
-	/**
-	 *  \brief This operation returns the type of the entry currently stored.
-	 */
-	Type getType();
-	/**
-	 *  \brief This operation returns the size of the entry currently stored.
-	 */
-	size_t getSizeOfType();
-	/**
-	 *
-	 * @return the size of the datapool array
-	 */
-	size_t getArraySize();
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const;
-	/**
-	 * This method returns if the variable is read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const;
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const;
-
-	void setValid(uint8_t valid);
-	/**
-	 * Getter for the remaining size.
-	 */
-	size_t getSizeTillEnd() const;
-
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			 Endianness streamEndianness) const override;
-
-	size_t getSerializedSize() const override;
-
-	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			 Endianness streamEndianness) override;
-};
-
-#endif /* POOLRAWACCESS_H_ */
diff --git a/datapool/PoolVarList.h b/datapool/PoolVarList.h
index 035ff2ac8..0b2b0f064 100644
--- a/datapool/PoolVarList.h
+++ b/datapool/PoolVarList.h
@@ -1,14 +1,15 @@
-#ifndef POOLVARLIST_H_
-#define POOLVARLIST_H_
+#ifndef FSFW_DATAPOOL_POOLVARLIST_H_
+#define FSFW_DATAPOOL_POOLVARLIST_H_
 
-#include "PoolVariable.h"
-#include "PoolVariableIF.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
 template <class T, uint8_t n_var>
 class PoolVarList {
 private:
-	PoolVariable<T> variables[n_var];
+	GlobPoolVar<T> variables[n_var];
 public:
-	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
+	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet,
+	        PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
 		//I really should have a look at the new init list c++ syntax.
 		if (dataSet == NULL) {
 			return;
@@ -20,9 +21,9 @@ public:
 		}
 	}
 
-	PoolVariable<T> &operator [](int i) { return variables[i]; }
+	GlobPoolVar<T> &operator [](int i) { return variables[i]; }
 };
 
 
 
-#endif /* POOLVARLIST_H_ */
+#endif /* FSFW_DATAPOOL_POOLVARLIST_H_ */
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
deleted file mode 100644
index a9d3407d0..000000000
--- a/datapool/PoolVariable.h
+++ /dev/null
@@ -1,295 +0,0 @@
-/*
- * \file	PoolVariable.h
- *
- * \brief	This file contains the PoolVariable class, which locally represents a non-array data pool variable.
- *
- * \date	10/17/2012
- *
- * \author	Bastian Baetz
- */
-
-#ifndef POOLVARIABLE_H_
-#define POOLVARIABLE_H_
-
-#include "DataSetIF.h"
-#include "PoolEntry.h"
-#include "PoolVariableIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-template<typename T, uint8_t n_var> class PoolVarList;
-
-/**
- * \brief	This is the access class for non-array data pool entries.
- *
- * \details	To ensure safe usage of the data pool, operation is not done directly on the data pool
- * 			entries, but on local copies. This class provides simple type-safe access to single
- * 			data pool entries (i.e. entries with length = 1).
- * 			The class can be instantiated as read-write and read only.
- * 			It provides a commit-and-roll-back semantic, which means that the variable's value in
- * 			the data pool is not changed until the commit call is executed.
- * 	\tparam	T The template parameter sets the type of the variable. Currently, all plain data types
- * 			are supported, but in principle any type is possible.
- *	\ingroup data_pool
- */
-template<typename T>
-class PoolVariable: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PoolVarList;
-protected:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read() {
-		PoolEntry<T> *read_out = ::dataPool.getData < T > (dataPoolId, 1);
-		if (read_out != NULL) {
-			valid = read_out->valid;
-			value = *(read_out->address);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			value = 0;
-			valid = false;
-			sif::error << "PoolVariable: read of DP Variable 0x" << std::hex
-					<< dataPoolId << std::dec << " failed." << std::endl;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * \brief	The commit call writes back the variable's value to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit() {
-		PoolEntry<T> *write_back = ::dataPool.getData < T > (dataPoolId, 1);
-		if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-			write_back->valid = valid;
-			*(write_back->address) = value;
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * Empty ctor for List initialization
-	 */
-	PoolVariable() :
-			dataPoolId(PoolVariableIF::NO_PARAMETER), valid(
-					PoolVariableIF::INVALID), readWriteMode(VAR_READ), value(0) {
-
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 * \details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value;
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
-	 */
-	PoolVariable(uint32_t set_id, DataSetIF *dataSet,
-			ReadWriteMode_t setReadWriteMode) :
-			dataPoolId(set_id), valid(PoolVariableIF::INVALID), readWriteMode(
-					setReadWriteMode), value(0) {
-		if (dataSet != NULL) {
-			dataSet->registerVariable(this);
-		}
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-	PoolVariable(const PoolVariable &rhs) :
-			dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode(
-					rhs.readWriteMode), value(rhs.value) {
-	}
-
-	/**
-	 * \brief	The classes destructor is empty.
-	 * \details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolVariable() {
-
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid)
-			return true;
-		else
-			return false;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	void setValid(uint8_t valid) {
-		this->valid = valid;
-	}
-
-	operator T() {
-		return value;
-	}
-
-	operator T() const {
-		return value;
-	}
-
-	PoolVariable<T>& operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	PoolVariable<T>& operator=(PoolVariable<T> newPoolVariable) {
-		value = newPoolVariable.value;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize<T>(&value, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
-	}
-};
-
-typedef PoolVariable<uint8_t> db_uint8_t;
-typedef PoolVariable<uint16_t> db_uint16_t;
-typedef PoolVariable<uint32_t> db_uint32_t;
-typedef PoolVariable<int8_t> db_int8_t;
-typedef PoolVariable<int16_t> db_int16_t;
-typedef PoolVariable<int32_t> db_int32_t;
-typedef PoolVariable<uint8_t> db_bool_t;
-typedef PoolVariable<float> db_float_t;
-typedef PoolVariable<double> db_double_t;
-//Alternative (but I thing this is not as useful: code duplication, differences too small):
-
-//template <typename T>
-//class PoolReader : public PoolVariableIF {
-//private:
-//	uint32_t parameter_id;
-//	uint8_t valid;
-//public:
-//	T value;
-//	PoolReader( uint32_t set_id, DataSetIF* set ) : parameter_id(set_id), valid(false), value(0) {
-//		set->registerVariable( this );
-//	}
-//
-//	~PoolReader() {};
-//
-//	uint8_t commit() {
-//			return HasReturnvaluesIF::RETURN_OK;
-//	}
-//
-//	uint8_t read() {
-//		PoolEntry<T>* read_out = ::dataPool.getData<T>( parameter_id, 1 );
-//		if ( read_out != NULL ) {
-//			valid = read_out->valid;
-//			value = *(read_out->address);
-//			return HasReturnvaluesIF::RETURN_OK;
-//		} else {
-//			value = 0;
-//			valid = false;
-//			return CHECKOUT_FAILED;
-//		}
-//	}
-//	uint32_t getParameterId() { return parameter_id; }
-//	bool isWritable() { return false; };
-//	bool isValid() { if (valid) return true; else return false; }
-//};
-//
-//template <typename T>
-//class PoolWriter : public PoolVariableIF {
-//private:
-//	uint32_t parameter_id;
-//public:
-//	T value;
-//	PoolWriter( uint32_t set_id, DataSetIF* set ) : parameter_id(set_id), value(0) {
-//		set->registerVariable( this );
-//	}
-//
-//	~PoolWriter() {};
-//
-//	uint8_t commit() {
-//		PoolEntry<T>* write_back = ::dataPool.getData<T>( parameter_id, 1 );
-//		if ( write_back != NULL ) {
-//			write_back->valid = true;
-//			*(write_back->address) = value;
-//			return HasReturnvaluesIF::RETURN_OK;
-//		} else {
-//			return CHECKOUT_FAILED;
-//		}
-//	}
-//	uint8_t read() {
-//		PoolEntry<T>* read_out = ::dataPool.getData<T>( parameter_id, 1 );
-//		if ( read_out != NULL ) {
-//			value = *(read_out->address);
-//			return HasReturnvaluesIF::RETURN_OK;
-//		} else {
-//			value = 0;
-//			return CHECKOUT_FAILED;
-//		}
-//	}
-//	uint32_t getParameterId() { return parameter_id; }
-//	bool isWritable() { return true; };
-//	bool isValid() { return false; }
-//};
-
-#endif /* POOLVARIABLE_H_ */
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index f47173df3..cd15f7445 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -1,71 +1,99 @@
-/*
- * \file	PoolVariableIF.h
- *
- * \brief	This file contains the interface definition for pool variables.
- *
- * \date	10/17/2012
- *
- * \author	Bastian Baetz
- */
-
-#ifndef POOLVARIABLEIF_H_
-#define POOLVARIABLEIF_H_
+#ifndef FSFW_DATAPOOL_POOLVARIABLEIF_H_
+#define FSFW_DATAPOOL_POOLVARIABLEIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
 
 /**
- * \brief	This interface is used to control local data pool variable representations.
- *
- * \details	To securely handle data pool variables, all pool entries are locally managed by
- * 			data pool variable access classes, which are called pool variables. To ensure a
- * 			common state of a set of variables needed in a function, these local pool variables
- * 			again are managed by other classes, e.g. the DataSet. This interface provides unified
- * 			access to local pool variables for such manager classes.
- *	\ingroup data_pool
+ * @brief	This interface is used to control data pool
+ * 			variable representations.
+ * @details
+ * To securely handle data pool variables, all pool entries are locally
+ * managed by data pool variable access classes, which are called pool
+ * variables. To ensure a common state of a set of variables needed in a
+ * function, these local pool variables again are managed by other classes,
+ * like the DataSet classes. This interface provides unified access to
+ * local pool variables for such manager classes.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
  */
 class PoolVariableIF : public SerializeIF {
-	friend class DataSet;
-protected:
-	/**
-	 * \brief	The commit call shall write back a newly calculated local value to the data pool.
-	 */
-	virtual ReturnValue_t commit() = 0;
-	/**
-	 * \brief	The read call shall read the value of this parameter from the data pool and store
-	 * 			the content locally.
-	 */
-	virtual ReturnValue_t read() = 0;
+	friend class PoolDataSetBase;
+	friend class GlobDataSet;
+	friend class LocalPoolDataSetBase;
 public:
-	static const uint8_t VALID = 1;
-	static const uint8_t INVALID = 0;
-	static const uint32_t NO_PARAMETER = 0;
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
+	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
+
+	static constexpr bool VALID = 1;
+	static constexpr bool INVALID = 0;
+	static constexpr uint32_t NO_PARAMETER = 0xffffffff;
+
 	enum ReadWriteMode_t {
 		VAR_READ, VAR_WRITE, VAR_READ_WRITE
 	};
 
 	/**
-	 * \brief	This is an empty virtual destructor, as it is proposed for C++ interfaces.
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is proposed for C++ interfaces.
 	 */
-	virtual ~PoolVariableIF() {
-	}
+	virtual ~PoolVariableIF() {}
 	/**
-	 * \brief	This method returns if the variable is write-only, read-write or read-only.
+	 * @brief	This method returns if the variable is write-only,
+	 * 			read-write or read-only.
 	 */
 	virtual ReadWriteMode_t getReadWriteMode() const = 0;
 	/**
-	 * \brief	This operation shall return the data pool id of the variable.
+	 * @brief	This operation shall return the data pool id of the variable.
 	 */
 	virtual uint32_t getDataPoolId() const = 0;
 	/**
-	 * \brief	With this call, the valid information of the variable is returned.
+	 * @brief	With this call, the valid information of the
+	 * 			variable is returned.
 	 */
 	virtual bool isValid() const = 0;
 	/**
-	 * \brief	With this call, the valid information of the variable is set.
+	 * @brief	With this call, the valid information of the variable is set.
 	 */
-	virtual void setValid(uint8_t validity) = 0;
+	virtual void setValid(bool validity) = 0;
 
+	/**
+	 * @brief	The commit call shall write back a newly calculated local
+	 * 			value to the data pool.
+	 * @details
+	 * It is assumed that these calls are implemented in a thread-safe manner!
+	 */
+	virtual ReturnValue_t commit(uint32_t lockTimeout) = 0;
+	/**
+	 * @brief	The read call shall read the value of this parameter from
+	 * 			the data pool and store the content locally.
+	 * @details
+	 * It is assumbed that these calls are implemented in a thread-safe manner!
+	 */
+	virtual ReturnValue_t read(uint32_t lockTimeout) = 0;
+
+protected:
+
+	/**
+	 * @brief 	Same as commit with the difference that comitting will be
+	 * 			performed without a lock
+	 * @return
+	 * This can be used if the lock protection is handled externally
+	 * to avoid the overhead of locking and unlocking consecutively.
+	 * Declared protected to avoid free public usage.
+	 */
+	virtual ReturnValue_t readWithoutLock() = 0;
+	/**
+	 * @brief 	Same as commit with the difference that comitting will be
+	 * 			performed without a lock
+	 * @return
+	 * This can be used if the lock protection is handled externally
+	 * to avoid the overhead of locking and unlocking consecutively.
+	 * Declared protected to avoid free public usage.
+	 */
+	virtual ReturnValue_t commitWithoutLock() = 0;
 };
 
-#endif /* POOLVARIABLEIF_H_ */
+using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
+
+#endif /* FSFW_DATAPOOL_POOLVARIABLEIF_H_ */
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
deleted file mode 100644
index d4ca08426..000000000
--- a/datapool/PoolVector.h
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
- * \file	PoolVector.h
- *
- * \brief	This file contains the PoolVector class, the header only class to handle data pool vectors.
- *
- * \date	10/23/2012
- *
- * \author	Bastian Baetz
- */
-
-#ifndef POOLVECTOR_H_
-#define POOLVECTOR_H_
-
-#include "DataSetIF.h"
-#include "PoolEntry.h"
-#include "PoolVariableIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-/**
- * \brief	This is the access class for array-type data pool entries.
- *
- * \details	To ensure safe usage of the data pool, operation is not done directly on the data pool
- * 			entries, but on local copies. This class provides simple type- and length-safe access
- * 			to vector-style data pool entries (i.e. entries with length > 1).
- * 			The class can be instantiated as read-write and read only.
- * 			It provides a commit-and-roll-back semantic, which means that no array entry in
- * 			the data pool is changed until the commit call is executed.
- * 			There are two template parameters:
- * 	\tparam	T This template parameter specifies the data type of an array entry. Currently, all
- * 			plain data types are supported, but in principle any type is possible.
- * 	\tparam vector_size	This template parameter specifies the vector size of this entry.
- * 			Using a template parameter for this is not perfect, but avoids dynamic memory allocation.
- *	\ingroup data_pool
- */
-template<typename T, uint16_t vector_size>
-class PoolVector: public PoolVariableIF {
-private:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-
-protected:
-	/**
-	 * \brief	This is a call to read the array's values from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies all array values and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type, size or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read() {
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(this->dataPoolId,
-				vector_size);
-		if (read_out != NULL) {
-			this->valid = read_out->valid;
-			memcpy(this->value, read_out->address, read_out->getByteSize());
-
-			return HasReturnvaluesIF::RETURN_OK;
-
-		} else {
-			memset(this->value, 0, vector_size * sizeof(T));
-			sif::error << "PoolVector: read of DP Variable 0x" << std::hex
-					<< dataPoolId << std::dec << " failed." << std::endl;
-			this->valid = INVALID;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * \brief	The commit call copies the array values back to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit() {
-		PoolEntry<T>* write_back = ::dataPool.getData<T>(this->dataPoolId,
-				vector_size);
-		if ((write_back != NULL) && (this->readWriteMode != VAR_READ)) {
-			write_back->valid = valid;
-			memcpy(write_back->address, this->value, write_back->getByteSize());
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 * \detials	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
-	 */
-	T value[vector_size];
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
-	 */
-	PoolVector(uint32_t set_id, DataSetIF* set,
-			ReadWriteMode_t setReadWriteMode) :
-			dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
-		memset(this->value, 0, vector_size * sizeof(T));
-		if (set != NULL) {
-			set->registerVariable(this);
-		}
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-//	PoolVector(const PoolVector& rhs) {
-//		PoolVector<T, vector_size> temp(rhs.dataPoolId, rhs.)
-//		memcpy(value, rhs.value, sizeof(T)*vector_size);
-//	}
-	/**
-	 * \brief	The classes destructor is empty.
-	 * \details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolVector() {
-	}
-	;
-	/**
-	 * \brief	The operation returns the number of array entries in this variable.
-	 */
-	uint8_t getSize() {
-		return vector_size;
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-	;
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid != INVALID)
-			return true;
-		else
-			return false;
-	}
-
-	void setValid(uint8_t valid) {
-		this->valid = valid;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	T &operator [](int i) {
-		return value[i];
-	}
-
-	const T &operator [](int i) const {
-		return value[i];
-	}
-
-	PoolVector<T, vector_size> &operator=(
-			PoolVector<T, vector_size> newPoolVector) {
-
-		for (uint16_t i = 0; i < vector_size; i++) {
-			this->value[i] = newPoolVector.value[i];
-		}
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		uint16_t i;
-		ReturnValue_t result;
-		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-					maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const {
-		return vector_size * SerializeAdapter::getSerializedSize(value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		uint16_t i;
-		ReturnValue_t result;
-		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
-					streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-};
-
-#endif /* POOLVECTOR_H_ */
diff --git a/datapool/SharedDataSetIF.h b/datapool/SharedDataSetIF.h
new file mode 100644
index 000000000..b8d98794d
--- /dev/null
+++ b/datapool/SharedDataSetIF.h
@@ -0,0 +1,14 @@
+#ifndef FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_
+#define FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_
+#include "PoolDataSetIF.h"
+
+class SharedDataSetIF: public PoolDataSetIF {
+public:
+    virtual ~SharedDataSetIF() {};
+
+private:
+    virtual ReturnValue_t lockDataset(dur_millis_t mutexTimeout) = 0;
+    virtual ReturnValue_t unlockDataset() = 0;
+};
+
+#endif /* FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_ */
diff --git a/datapool/ControllerSet.cpp b/datapoolglob/ControllerSet.cpp
similarity index 79%
rename from datapool/ControllerSet.cpp
rename to datapoolglob/ControllerSet.cpp
index 6339034c1..54fc6e8c9 100644
--- a/datapool/ControllerSet.cpp
+++ b/datapoolglob/ControllerSet.cpp
@@ -1,4 +1,4 @@
-#include "ControllerSet.h"
+#include <fsfw/datapoolglob/ControllerSet.h>
 
 ControllerSet::ControllerSet() {
 
diff --git a/datapoolglob/ControllerSet.h b/datapoolglob/ControllerSet.h
new file mode 100644
index 000000000..5da113973
--- /dev/null
+++ b/datapoolglob/ControllerSet.h
@@ -0,0 +1,15 @@
+#ifndef FSFW_DATAPOOLGLOB_CONTROLLERSET_H_
+#define FSFW_DATAPOOLGLOB_CONTROLLERSET_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+
+class ControllerSet :public GlobDataSet {
+public:
+	ControllerSet();
+	virtual ~ControllerSet();
+
+	virtual void setToDefault() = 0;
+	void setInvalid();
+};
+
+#endif /*  FSFW_DATAPOOLGLOB_CONTROLLERSET_H_ */
diff --git a/datapool/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
similarity index 94%
rename from datapool/DataPoolAdmin.cpp
rename to datapoolglob/DataPoolAdmin.cpp
index f298d530d..6ede0841e 100644
--- a/datapool/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,7 +1,8 @@
-#include "DataPool.h"
 #include "DataPoolAdmin.h"
-#include "DataSet.h"
+#include "GlobalDataSet.h"
+#include "GlobalDataPool.h"
 #include "PoolRawAccess.h"
+
 #include "../ipc/CommandMessage.h"
 #include "../ipc/QueueFactory.h"
 #include "../parameters/ParameterMessage.h"
@@ -40,9 +41,9 @@ ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
 
 	uint8_t valid = data[4];
 
-	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
 
-	DataSet mySet;
+	GlobDataSet mySet;
 	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
 	ReturnValue_t status = mySet.read();
 	if (status != RETURN_OK) {
@@ -92,9 +93,9 @@ void DataPoolAdmin::handleCommand() {
 
 ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 		const uint8_t* data, size_t size, uint8_t** dataPointer) {
-	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
-	DataSet testSet;
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
+	GlobDataSet testSet;
 	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
 			PoolVariableIF::VAR_READ);
 	ReturnValue_t status = testSet.read();
@@ -113,7 +114,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 	const uint8_t* readPosition = data;
 
 	for (; size > 0; size -= typeSize) {
-		DataSet rawSet;
+		GlobDataSet rawSet;
 		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
 				PoolVariableIF::VAR_READ_WRITE);
 		status = rawSet.read();
@@ -131,9 +132,9 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 
 ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
 		uint8_t** dataPointer, uint8_t* copyHere) {
-	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
-	DataSet testSet;
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
+	GlobDataSet testSet;
 	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
 			PoolVariableIF::VAR_READ);
 	ReturnValue_t status = testSet.read();
@@ -146,7 +147,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
 	}
 	uint8_t* ptrToCopy = copyHere;
 	for (; size > 0; size -= typeSize) {
-		DataSet rawSet;
+		GlobDataSet rawSet;
 		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
 				PoolVariableIF::VAR_READ);
 		status = rawSet.read();
diff --git a/datapool/DataPoolAdmin.h b/datapoolglob/DataPoolAdmin.h
similarity index 92%
rename from datapool/DataPoolAdmin.h
rename to datapoolglob/DataPoolAdmin.h
index e2d1e9e18..d8871b651 100644
--- a/datapool/DataPoolAdmin.h
+++ b/datapoolglob/DataPoolAdmin.h
@@ -1,15 +1,17 @@
-#ifndef DATAPOOLADMIN_H_
-#define DATAPOOLADMIN_H_
+#ifndef FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_
+#define FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_
+
+#include "DataPoolParameterWrapper.h"
 
-#include "../memory/MemoryHelper.h"
-#include "../action/HasActionsIF.h"
-#include "../action/SimpleActionHelper.h"
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../tasks/ExecutableObjectIF.h"
-#include "../parameters/ReceivesParameterMessagesIF.h"
-#include "DataPoolParameterWrapper.h"
+#include "../action/HasActionsIF.h"
 #include "../ipc/MessageQueueIF.h"
+#include "../parameters/ReceivesParameterMessagesIF.h"
+#include "../action/SimpleActionHelper.h"
+#include "../memory/MemoryHelper.h"
+
 
 class DataPoolAdmin: public HasActionsIF,
 		public ExecutableObjectIF,
@@ -55,4 +57,4 @@ private:
 			Command_t initialCommand);
 };
 
-#endif /* DATAPOOLADMIN_H_ */
+#endif /* FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_ */
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapoolglob/DataPoolParameterWrapper.cpp
similarity index 95%
rename from datapool/DataPoolParameterWrapper.cpp
rename to datapoolglob/DataPoolParameterWrapper.cpp
index 79367405a..3a57d90df 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapoolglob/DataPoolParameterWrapper.cpp
@@ -1,10 +1,8 @@
-#include "DataPoolParameterWrapper.h"
-
-//for returncodes
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/DataPoolParameterWrapper.h"
+#include "../datapoolglob/PoolRawAccess.h"
 #include "../parameters/HasParametersIF.h"
 
-#include "DataSet.h"
-#include "PoolRawAccess.h"
 
 DataPoolParameterWrapper::DataPoolParameterWrapper() :
 		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
@@ -20,7 +18,7 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 		uint16_t parameterId) {
 	poolId = (domainId << 16) + parameterId;
 
-	DataSet mySet;
+	GlobDataSet mySet;
 	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
 	ReturnValue_t status = mySet.read();
 	if (status != HasReturnvaluesIF::RETURN_OK) {
@@ -57,7 +55,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 	}
 
 	for (uint8_t index = 0; index < rows; index++){
-		DataSet mySet;
+		GlobDataSet mySet;
 		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
 		mySet.read();
 		result = raw.serialize(buffer,size,maxSize,streamEndianness);
@@ -94,7 +92,7 @@ ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
 
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
-		DataSet mySet;
+		GlobDataSet mySet;
 		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
 				PoolVariableIF::VAR_READ_WRITE);
 		mySet.read();
diff --git a/datapool/DataPoolParameterWrapper.h b/datapoolglob/DataPoolParameterWrapper.h
similarity index 100%
rename from datapool/DataPoolParameterWrapper.h
rename to datapoolglob/DataPoolParameterWrapper.h
diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
new file mode 100644
index 000000000..afb27b772
--- /dev/null
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -0,0 +1,133 @@
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../ipc/MutexFactory.h"
+
+GlobalDataPool::GlobalDataPool(
+		void(*initFunction)(GlobPoolMap* pool_map)) {
+	mutex = MutexFactory::instance()->createMutex();
+	if (initFunction != NULL ) {
+		initFunction( &this->globDataPool );
+	}
+}
+
+GlobalDataPool::~GlobalDataPool() {
+	MutexFactory::instance()->deleteMutex(mutex);
+	for(GlobPoolMapIter it = this->globDataPool.begin();
+	    it != this->globDataPool.end(); ++it )
+	{
+		delete it->second;
+	}
+}
+
+// The function checks PID, type and array length before returning a copy of
+// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
+template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
+		uint8_t sizeOrPosition ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
+		if (entry != nullptr ) {
+			if ( sizeOrPosition <= entry->length ) {
+				return entry;
+			}
+		}
+	}
+	return nullptr;
+}
+
+PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		return it->second;
+	} else {
+		return nullptr;
+	}
+}
+
+ReturnValue_t GlobalDataPool::unlockDataPool() {
+	ReturnValue_t status = mutex->unlockMutex();
+	if(status != RETURN_OK) {
+		sif::error << "DataPool::DataPool: unlock of mutex failed with"
+				" error code: " << status << std::endl;
+	}
+	return status;
+}
+
+ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
+	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
+	        timeoutMs);
+	if(status != RETURN_OK) {
+		sif::error << "DataPool::DataPool: lock of mutex failed "
+				"with error code: " << status << std::endl;
+	}
+	return status;
+}
+
+void GlobalDataPool::print() {
+	sif::debug << "DataPool contains: " << std::endl;
+	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
+	dataPoolIt = this->globDataPool.begin();
+	while( dataPoolIt != this->globDataPool.end() ) {
+		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
+		dataPoolIt->second->print();
+		dataPoolIt++;
+	}
+}
+
+uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
+	return (parameter_id >> 8) & 0x00FFFFFF;
+}
+
+uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
+	return (parameter_id & 0x000000FF);
+}
+
+uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
+	return (poolId << 8) + index;
+}
+
+
+//SHOULDDO: Do we need a mutex lock here... I don't think so,
+//as we only check static const values of elements in a list that do not change.
+//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
+ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
+	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
+	if ( it != this->globDataPool.end() ) {
+		*type = it->second->getType();
+		return RETURN_OK;
+	} else {
+		*type = Type::UNKNOWN_TYPE;
+		return RETURN_FAILED;
+	}
+}
+
+bool GlobalDataPool::exists(uint32_t parameterId) {
+	uint32_t poolId = PIDToDataPoolId(parameterId);
+	uint32_t index = PIDToArrayIndex(parameterId);
+	GlobPoolMapIter it = this->globDataPool.find( poolId );
+	if (it != globDataPool.end()) {
+		if (it->second->getSize() >= index) {
+			return true;
+		}
+	}
+	return false;
+}
+
+template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
+		uint32_t data_pool_id, uint8_t size);
+template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<float>* GlobalDataPool::getData<float>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<double>* GlobalDataPool::getData<double>(
+		uint32_t data_pool_id, uint8_t size);
diff --git a/datapoolglob/GlobalDataPool.h b/datapoolglob/GlobalDataPool.h
new file mode 100644
index 000000000..ce5b132c0
--- /dev/null
+++ b/datapoolglob/GlobalDataPool.h
@@ -0,0 +1,149 @@
+#ifndef GLOBALDATAPOOL_H_
+#define GLOBALDATAPOOL_H_
+
+#include "../datapool/PoolEntry.h"
+#include "../globalfunctions/Type.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+/**
+ * @defgroup data_pool Global data pool
+ * This is the group, where all classes associated with global
+ * data pool handling belong to.
+ * This includes classes to access Data Pool variables.
+ */
+
+/**
+ * Typedefs for the global pool representations
+ */
+using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
+using GlobPoolMapIter = GlobPoolMap::iterator;
+
+/**
+ * @brief		This class represents the OBSW global data-pool.
+ *
+ * @details
+ * All variables are registered and space is allocated in an initialization
+ * function, which is passed do the constructor. Space for the variables is
+ * allocated on the heap (with a new call).
+ *
+ * The data is found by a data pool id, which uniquely represents a variable.
+ * Data pool variables should be used with a blackboard logic in mind,
+ * which means read data is valid (if flagged so),
+ * but not necessarily up-to-date.
+ *
+ * Variables are either single values or arrays.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class GlobalDataPool : public HasReturnvaluesIF {
+private:
+	/**
+	 * @brief	This is the actual data pool itself.
+	 * @details	It is represented by a map with the data pool id as index
+	 * 			and a pointer to a single PoolEntry as value.
+	 */
+	GlobPoolMap globDataPool;
+
+	/**
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking the pool is only done by the DataSet class.
+	 */
+	MutexIF*	mutex;
+public:
+	/**
+	 * @brief	In the classes constructor,
+	 * 			the passed initialization function is called.
+	 * @details
+	 * To enable filling the pool, a pointer to the map is passed,
+	 * allowing direct access to the pool's content.
+	 * On runtime, adding or removing variables is forbidden.
+	 */
+	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
+
+	/**
+	 * 	@brief	The destructor iterates through the data_pool map and
+	 * 			calls all entries destructors to clean up the heap.
+	 */
+	~GlobalDataPool();
+
+	/**
+	 * @brief	This is the default call to access the pool.
+	 * @details
+	 * A pointer to the PoolEntry object is returned.
+	 * The call checks data pool id, type and array size.
+	 * Returns NULL in case of failure.
+	 * @param data_pool_id	The data pool id to search.
+	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
+	 * or the position the user wants to read.
+	 * 			If smaller than the entry size, everything's ok.
+	 */
+	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
+			uint8_t sizeOrPosition );
+
+	/**
+	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
+	 * 			(i.e. in Housekeeping Telemetry).
+	 * @details	It returns a basic interface and does NOT perform
+	 * 			a size check. The caller has to assure he does not copy too much data.
+	 * 			Returns NULL in case the entry is not found.
+	 * @param data_pool_id	The data pool id to search.
+	 */
+	PoolEntryIF* getRawData( uint32_t data_pool_id );
+	/**
+	 * @brief	This is a small helper function to facilitate locking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
+	/**
+	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to free the mutex.
+	 */
+	ReturnValue_t unlockDataPool();
+	/**
+	 * @brief	The print call is a simple debug method.
+	 * @details	It prints the current content of the data pool.
+	 *  		It iterates through the data_pool map and calls each entry's print() method.
+	 */
+	void print();
+	/**
+	 * Extracts the data pool id from a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The data pool id as used within the OBSW.
+	 */
+	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
+	/**
+	 * Extracts an array index out of a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The index of the corresponding data pool entry.
+	 */
+	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
+	/**
+	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
+	 */
+	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
+
+	/**
+	 * Method to return the type of a pool variable.
+	 * @param parameter_id A parameterID (not pool id) of a DP member.
+	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
+	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
+	 */
+	ReturnValue_t getType( uint32_t parameter_id, Type* type );
+
+	/**
+	 * Method to check if a PID exists. Does not lock, as there's no
+	 * possibility to alter the list that is checked during run-time.
+	 * @param parameterId The PID (not pool id!) of a parameter.
+	 * @return	true if exists, false else.
+	 */
+	bool exists(uint32_t parameterId);
+};
+
+//We assume someone globally instantiates a DataPool.
+namespace glob {
+extern GlobalDataPool dataPool;
+}
+
+#endif /* DATAPOOL_H_ */
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
new file mode 100644
index 000000000..1e99f8051
--- /dev/null
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -0,0 +1,48 @@
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+GlobDataSet::GlobDataSet(): PoolDataSetBase(
+        reinterpret_cast<PoolVariableIF**>(&registeredVariables),
+        DATA_SET_MAX_SIZE) {}
+
+// Don't do anything with your variables, they are dead already!
+// (Destructor is already called)
+GlobDataSet::~GlobDataSet() {}
+
+ReturnValue_t GlobDataSet::commit(bool valid, uint32_t lockTimeout) {
+	setEntriesValid(valid);
+	setSetValid(valid);
+	return commit(lockTimeout);
+}
+
+ReturnValue_t GlobDataSet::commit(uint32_t lockTimeout) {
+	return PoolDataSetBase::commit(lockTimeout);
+}
+
+bool GlobDataSet::isValid() const {
+    return this->valid;
+}
+
+ReturnValue_t GlobDataSet::unlockDataPool() {
+	return glob::dataPool.unlockDataPool();
+}
+
+ReturnValue_t GlobDataSet::lockDataPool(uint32_t timeoutMs) {
+	return glob::dataPool.lockDataPool(timeoutMs);
+}
+
+void GlobDataSet::setEntriesValid(bool valid) {
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				!= PoolVariableIF::VAR_READ) {
+			registeredVariables[count]->setValid(valid);
+		}
+	}
+}
+
+void GlobDataSet::setSetValid(bool valid) {
+	this->valid = valid;
+}
+
+
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
new file mode 100644
index 000000000..2f0edbd5c
--- /dev/null
+++ b/datapoolglob/GlobalDataSet.h
@@ -0,0 +1,98 @@
+#ifndef FRAMEWORK_DATAPOOLGLOB_DATASET_H_
+#define FRAMEWORK_DATAPOOLGLOB_DATASET_H_
+
+#include "../datapool/PoolDataSetBase.h"
+
+/**
+ * @brief	The DataSet class manages a set of locally checked out variables
+ * 			for the global data pool.
+ * @details
+ * This class uses the read-commit() semantic provided by the DataSetBase class.
+ * It extends the base class by using the global data pool,
+ * having a valid state and implementing lock und unlock calls for the global
+ * datapool.
+ *
+ * For more information on how this class works, see the DataSetBase
+ * documentation.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class GlobDataSet: public PoolDataSetBase {
+public:
+
+	/**
+	 * @brief	Creates an empty GlobDataSet. Use registerVariable or
+	 * 			supply a pointer to this dataset to PoolVariable
+	 * 			initializations to register pool variables.
+	 */
+	GlobDataSet();
+
+	/**
+	 * @brief	The destructor automatically manages writing the valid
+	 * 			information of variables.
+	 * @details
+	 * In case the data set was read out, but not committed(indicated by state),
+	 * the destructor parses all variables that are still registered to the set.
+	 * For each, the valid flag in the data pool is set to "invalid".
+	 */
+	~GlobDataSet();
+
+	/**
+	 * Variant of method above which sets validity of all elements of the set.
+	 * @param valid Validity information from PoolVariableIF.
+	 * @return	- @c RETURN_OK if all variables were read successfully.
+	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
+	 * 			     contains non write-only variables
+	 */
+	ReturnValue_t commit(bool valid, uint32_t lockTimeout = MutexIF::BLOCKING);
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+	/**
+	 * Set all entries
+	 * @param valid
+	 */
+	void setSetValid(bool valid);
+
+	bool isValid() const override;
+
+	/**
+	 * Set the valid information of all variables contained in the set which
+	 * are not read-only
+	 *
+	 * @param valid Validity information from PoolVariableIF.
+	 */
+	void setEntriesValid(bool valid);
+
+	//!< This definition sets the maximum number of variables to
+	//! register in one DataSet.
+	static const uint8_t DATA_SET_MAX_SIZE = 63;
+
+private:
+	/**
+	 * If the valid state of a dataset is always relevant to the whole
+	 * data set we can use this flag.
+	 */
+	bool valid = false;
+
+	/**
+	 * @brief	This is a small helper function to facilitate locking
+	 * 			the global data pool.
+	 * @details
+	 * It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
+	/**
+	 * @brief	This is a small helper function to facilitate
+	 * 			unlocking the global data pool
+	 * @details
+	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	ReturnValue_t unlockDataPool() override;
+
+	void handleAlreadyReadDatasetCommit();
+	ReturnValue_t handleUnreadDatasetCommit();
+
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
+};
+
+#endif /* FRAMEWORK_DATAPOOLGLOB_DATASET_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
new file mode 100644
index 000000000..a995bfaf2
--- /dev/null
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -0,0 +1,213 @@
+#ifndef GLOBALPOOLVARIABLE_H_
+#define GLOBALPOOLVARIABLE_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+template<typename T, uint8_t n_var> class PoolVarList;
+
+
+/**
+ * @brief	This is the access class for non-array data pool entries.
+ *
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly
+ * on the data pool entries, but on local copies. This class provides simple
+ * type-safe access to single data pool entries (i.e. entries with length = 1).
+ * The class can be instantiated as read-write and read only.
+ * It provides a commit-and-roll-back semantic, which means that the
+ * variable's value in the data pool is not changed until the
+ * commit call is executed.
+ * 	@tparam	T The template parameter sets the type of the variable.
+ * 	Currently, all plain data types are supported, but in principle
+ * 	any type is possible.
+ *	@ingroup data_pool
+ */
+template<typename T>
+class GlobPoolVar: public PoolVariableIF {
+	template<typename U, uint8_t n_var> friend class PoolVarList;
+	static_assert(not std::is_same<T, bool>::value,
+			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
+			"There is no boolean type in CCSDS.");
+public:
+	/**
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if nullptr is not passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but
+	 * sets the value attribute to default (0).
+	 * The value is fetched within the read() operation.
+	 * @param set_id	This is the id in the global data pool
+	 * 					this instance of the access class corresponds to.
+	 * @param dataSet	The data set in which the variable shall register
+	 * 					itself. If NULL, the variable is not registered.
+	 * @param setWritable If this flag is set to true, changes in the value
+	 * 			attribute can be written back to the data pool, otherwise not.
+	 */
+	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
+			ReadWriteMode_t setReadWriteMode);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a simple local variable.
+	 */
+	T value = 0;
+
+	/**
+	 * @brief 	Copy ctor to copy classes containing Pool Variables.
+	 * 			(Robin): This only copies member variables, which is done
+	 * 			by the default copy ctor. maybe we can ommit this ctor?
+	 */
+	GlobPoolVar(const GlobPoolVar& rhs);
+
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVar() {}
+
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout) override;
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * The commit call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool is stored.
+	 */
+	uint32_t dataPoolId;
+
+	/**
+	 * @brief	The valid information as it was stored in the data pool is
+	 * 			copied to this attribute.
+	 */
+	uint8_t valid;
+
+	/**
+	 * @brief	The information whether the class is read-write or read-only
+	 * 			is stored here.
+	 */
+	pool_rwm_t readWriteMode;
+
+	/**
+	 * Empty ctor for List initialization
+	 */
+	GlobPoolVar();
+public:
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const override;
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const override;
+	/**
+	 * This operation sets the data pool id of the variable.
+	 * The method is necessary to set id's of data pool member variables with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+
+	uint8_t getValid();
+
+	void setValid(bool valid) override;
+
+	operator T() {
+		return value;
+	}
+
+	operator T() const {
+		return value;
+	}
+
+	GlobPoolVar<T> &operator=(T newValue) {
+		value = newValue;
+		return *this;
+	}
+
+	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
+		value = newPoolVariable.value;
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size,
+			SerializeIF::Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, max_size,
+				streamEndianness);
+	}
+
+	virtual size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+		        streamEndianness);
+	}
+};
+
+#include "../datapoolglob/GlobalPoolVariable.tpp"
+
+typedef GlobPoolVar<uint8_t> gp_bool_t;
+typedef GlobPoolVar<uint8_t> gp_uint8_t;
+typedef GlobPoolVar<uint16_t> gp_uint16_t;
+typedef GlobPoolVar<uint32_t> gp_uint32_t;
+typedef GlobPoolVar<int8_t> gp_int8_t;
+typedef GlobPoolVar<int16_t> gp_int16_t;
+typedef GlobPoolVar<int32_t> gp_int32_t;
+typedef GlobPoolVar<float> gp_float_t;
+typedef GlobPoolVar<double> gp_double_t;
+
+#endif /* POOLVARIABLE_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.tpp b/datapoolglob/GlobalPoolVariable.tpp
new file mode 100644
index 000000000..d61d605d7
--- /dev/null
+++ b/datapoolglob/GlobalPoolVariable.tpp
@@ -0,0 +1,117 @@
+#ifndef GLOBALPOOLVARIABLE_TPP_
+#define GLOBALPOOLVARIABLE_TPP_
+
+template <class T>
+inline GlobPoolVar<T>::GlobPoolVar(uint32_t set_id,
+		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode):
+		dataPoolId(set_id), valid(PoolVariableIF::INVALID),
+		readWriteMode(setReadWriteMode)
+{
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template<typename T>
+inline ReturnValue_t GlobPoolVar<T>::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+template<typename T>
+inline ReturnValue_t GlobPoolVar<T>::commit(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+template <class T>
+inline ReturnValue_t GlobPoolVar<T>::readWithoutLock() {
+	PoolEntry<T>* read_out = glob::dataPool.getData<T>(dataPoolId, 1);
+	if (read_out != NULL) {
+		valid = read_out->valid;
+		value = *(read_out->address);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		value = 0;
+		valid = false;
+		sif::error << "PoolVariable: read of DP Variable 0x" << std::hex
+				<< dataPoolId << std::dec << " failed." << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template <class T>
+inline ReturnValue_t GlobPoolVar<T>::commitWithoutLock() {
+	PoolEntry<T>* write_back = glob::dataPool.getData<T>(dataPoolId, 1);
+	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
+		write_back->valid = valid;
+		*(write_back->address) = value;
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template <class T>
+inline GlobPoolVar<T>::GlobPoolVar():
+		dataPoolId(PoolVariableIF::NO_PARAMETER),
+		valid(PoolVariableIF::INVALID),
+		readWriteMode(VAR_READ), value(0) {}
+
+template <class T>
+inline GlobPoolVar<T>::GlobPoolVar(const GlobPoolVar& rhs) :
+		dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode(
+		rhs.readWriteMode), value(rhs.value) {}
+
+template <class T>
+inline pool_rwm_t GlobPoolVar<T>::getReadWriteMode() const  {
+	return readWriteMode;
+}
+
+template <class T>
+inline uint32_t GlobPoolVar<T>::getDataPoolId() const {
+	return dataPoolId;
+}
+
+template <class T>
+inline void GlobPoolVar<T>::setDataPoolId(uint32_t poolId) {
+	dataPoolId = poolId;
+}
+
+template <class T>
+inline bool GlobPoolVar<T>::isValid() const {
+	if (valid)
+		return true;
+	else
+		return false;
+}
+
+template <class T>
+inline uint8_t GlobPoolVar<T>::getValid() {
+	return valid;
+}
+
+template <class T>
+inline void GlobPoolVar<T>::setValid(bool valid) {
+	this->valid = valid;
+}
+
+#endif
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
new file mode 100644
index 000000000..0f5daacd8
--- /dev/null
+++ b/datapoolglob/GlobalPoolVector.h
@@ -0,0 +1,185 @@
+#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_
+#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ *
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class GlobPoolVector: public PoolVariableIF {
+public:
+	/**
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if no nullptr is passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but sets the
+	 * value attribute to default (0). The value is fetched within the
+	 * read() operation.
+	 * @param set_id
+	 * This is the id in the global data pool this instance of the access
+	 * class corresponds to.
+	 * @param dataSet
+	 * The data set in which the variable shall register itself. If nullptr,
+	 * the variable is not registered.
+	 * @param setWritable
+	 * If this flag is set to true, changes in the value attribute can be
+	 * written back to the data pool, otherwise not.
+	 */
+	GlobPoolVector(uint32_t set_id, DataSetIF* set,
+			ReadWriteMode_t setReadWriteMode);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a local array of this type.
+	 */
+	T value[vectorSize];
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVector() {};
+	/**
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
+	 */
+	uint8_t getSize() {
+		return vectorSize;
+	}
+	/**
+	 * @brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const {
+		return dataPoolId;
+	}
+	/**
+	 * @brief This operation sets the data pool id of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId) {
+		dataPoolId = poolId;
+	}
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const {
+		return readWriteMode;
+	}
+
+
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const {
+		if (valid != INVALID)
+			return true;
+		else
+			return false;
+	}
+	void setValid(bool valid) {this->valid = valid;}
+	uint8_t getValid() {return valid;}
+
+	T &operator [](int i) {return value[i];}
+	const T &operator [](int i) const {return value[i];}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t max_size, Endianness streamEndianness) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies all array values
+	 * and the valid information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The commit call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+};
+
+#include "../datapoolglob/GlobalPoolVector.tpp"
+
+template<typename T, uint16_t vectorSize>
+using gp_vec_t = GlobPoolVector<T, vectorSize>;
+
+#endif /* FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_ */
diff --git a/datapoolglob/GlobalPoolVector.tpp b/datapoolglob/GlobalPoolVector.tpp
new file mode 100644
index 000000000..013a682a4
--- /dev/null
+++ b/datapoolglob/GlobalPoolVector.tpp
@@ -0,0 +1,117 @@
+#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
+#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
+
+
+template<typename T, uint16_t vectorSize>
+inline GlobPoolVector<T, vectorSize>::GlobPoolVector(uint32_t set_id,
+		DataSetIF* set, ReadWriteMode_t setReadWriteMode) :
+		dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
+	memset(this->value, 0, vectorSize * sizeof(T));
+	if (set != nullptr) {
+		set->registerVariable(this);
+	}
+}
+
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::commit(
+		uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::readWithoutLock() {
+	PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
+			vectorSize);
+	if (read_out != nullptr) {
+		this->valid = read_out->valid;
+		memcpy(this->value, read_out->address, read_out->getByteSize());
+
+		return HasReturnvaluesIF::RETURN_OK;
+
+	} else {
+		memset(this->value, 0, vectorSize * sizeof(T));
+		sif::error << "PoolVector: Read of DP Variable 0x" << std::hex
+				<< std::setw(8) << std::setfill('0') << dataPoolId <<
+				std::dec << " failed." << std::endl;
+		this->valid = INVALID;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::commitWithoutLock() {
+	PoolEntry<T>* writeBack = glob::dataPool.getData<T>(this->dataPoolId,
+			vectorSize);
+	if ((writeBack != nullptr) && (this->readWriteMode != VAR_READ)) {
+		writeBack->valid = valid;
+		memcpy(writeBack->address, this->value, writeBack->getByteSize());
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
+		size_t* size, size_t max_size,
+		SerializeIF::Endianness streamEndianness) const {
+	uint16_t i;
+	ReturnValue_t result;
+	for (i = 0; i < vectorSize; i++) {
+		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
+				max_size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline size_t GlobPoolVector<T, vectorSize>::getSerializedSize() const {
+	return vectorSize * SerializeAdapter::getSerializedSize(value);
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::deSerialize(
+		const uint8_t** buffer, size_t* size,
+		SerializeIF::Endianness streamEndianness) {
+	uint16_t i;
+	ReturnValue_t result;
+	for (i = 0; i < vectorSize; i++) {
+		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+		        streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+#endif
diff --git a/datapool/PIDReader.h b/datapoolglob/PIDReader.h
similarity index 77%
rename from datapool/PIDReader.h
rename to datapoolglob/PIDReader.h
index 3b38b51d1..9431e1d40 100644
--- a/datapool/PIDReader.h
+++ b/datapoolglob/PIDReader.h
@@ -1,9 +1,9 @@
 #ifndef PIDREADER_H_
 #define PIDREADER_H_
-#include "DataPool.h"
-#include "DataSetIF.h"
-#include "PoolEntry.h"
-#include "PoolVariableIF.h"
+#include "../datapool/DataSetIF.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
 #include "../serialize/SerializeAdapter.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
@@ -15,10 +15,10 @@ class PIDReader: public PoolVariableIF {
 protected:
 	uint32_t parameterId;
 	uint8_t valid;
-	ReturnValue_t read() {
-		uint8_t arrayIndex = DataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T> *read_out = ::dataPool.getData<T>(
-				DataPool::PIDToDataPoolId(parameterId), arrayIndex);
+	ReturnValue_t readWithoutLock() {
+		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
+		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
+				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
 		if (read_out != NULL) {
 			valid = read_out->valid;
 			value = read_out->address[arrayIndex];
@@ -36,9 +36,13 @@ protected:
 	 * Reason is the possibility to access a single DP vector element, but if we commit,
 	 * we set validity of the whole vector.
 	 */
-	ReturnValue_t commit() {
+	ReturnValue_t commit(uint32_t lockTimeout) override {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	ReturnValue_t commitWithoutLock() override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	/**
 	 * Empty ctor for List initialization
 	 */
@@ -72,6 +76,19 @@ public:
 		}
 	}
 
+	ReturnValue_t read(uint32_t lockTimeout) override {
+		ReturnValue_t result = glob::dataPool.lockDataPool();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = readWithoutLock();
+		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "PIDReader::read: Could not unlock data pool!"
+					<< std::endl;
+		}
+		return result;
+	}
 	/**
 	 * Copy ctor to copy classes containing Pool Variables.
 	 */
@@ -89,7 +106,7 @@ public:
 	 * \brief	This operation returns the data pool id of the variable.
 	 */
 	uint32_t getDataPoolId() const {
-		return DataPool::PIDToDataPoolId(parameterId);
+		return GlobalDataPool::PIDToDataPoolId(parameterId);
 	}
 	uint32_t getParameterId() const {
 		return parameterId;
@@ -114,7 +131,7 @@ public:
 		return valid;
 	}
 
-	void setValid(uint8_t valid) {
+	void setValid(bool valid) {
 		this->valid = valid;
 	}
 
diff --git a/datapool/PIDReaderList.h b/datapoolglob/PIDReaderList.h
similarity index 68%
rename from datapool/PIDReaderList.h
rename to datapoolglob/PIDReaderList.h
index 1f6aa99cd..ae99f3aa2 100644
--- a/datapool/PIDReaderList.h
+++ b/datapoolglob/PIDReaderList.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_DATAPOOL_PIDREADERLIST_H_
-#define FRAMEWORK_DATAPOOL_PIDREADERLIST_H_
+#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
+#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
 
-#include "PIDReader.h"
-#include "PoolVariableIF.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoolglob/PIDReader.h"
 template <class T, uint8_t n_var>
 class PIDReaderList {
 private:
@@ -24,4 +24,4 @@ public:
 
 
 
-#endif /* FRAMEWORK_DATAPOOL_PIDREADERLIST_H_ */
+#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
new file mode 100644
index 000000000..53706c6d3
--- /dev/null
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -0,0 +1,239 @@
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serialize/EndianConverter.h"
+
+#include <cstring>
+
+PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
+		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
+		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
+		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
+		readWriteMode(setReadWriteMode) {
+	memset(value, 0, sizeof(value));
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+PoolRawAccess::~PoolRawAccess() {}
+
+ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::readWithoutLock() {
+	ReturnValue_t result = RETURN_FAILED;
+	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
+	if (readOut != nullptr) {
+		result = handleReadOut(readOut);
+		if(result == RETURN_OK) {
+			return result;
+		}
+	} else {
+		result = READ_ENTRY_NON_EXISTENT;
+	}
+	handleReadError(result);
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
+	ReturnValue_t result = RETURN_FAILED;
+	valid = readOut->getValid();
+	if (readOut->getSize() > arrayEntry) {
+		arraySize = readOut->getSize();
+		typeSize = readOut->getByteSize() / readOut->getSize();
+		type = readOut->getType();
+		if (typeSize <= sizeof(value)) {
+			uint16_t arrayPosition = arrayEntry * typeSize;
+			sizeTillEnd = readOut->getByteSize() - arrayPosition;
+			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
+			memcpy(value, ptr, typeSize);
+			return RETURN_OK;
+		} else {
+			result = READ_TYPE_TOO_LARGE;
+		}
+	} else {
+		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
+		result = READ_INDEX_TOO_LARGE;
+	}
+	return result;
+}
+
+void PoolRawAccess::handleReadError(ReturnValue_t result) {
+	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
+			<< std::dec << " failed, ";
+	if(result == READ_TYPE_TOO_LARGE) {
+		sif::error << "type too large." << std::endl;
+	}
+	else if(result == READ_INDEX_TOO_LARGE) {
+		sif::error << "index too large." << std::endl;
+	}
+	else if(result == READ_ENTRY_NON_EXISTENT) {
+		sif::error << "entry does not exist." << std::endl;
+	}
+
+	valid = INVALID;
+	typeSize = 0;
+	sizeTillEnd = 0;
+	memset(value, 0, sizeof(value));
+}
+
+ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::commitWithoutLock() {
+	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
+	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
+		write_back->setValid(valid);
+		uint8_t array_position = arrayEntry * typeSize;
+		uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position];
+		memcpy(ptr, value, typeSize);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t* PoolRawAccess::getEntry() {
+	return value;
+}
+
+ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
+		size_t* writtenBytes, size_t max_size) {
+	uint8_t* data_ptr = getEntry();
+	// debug << "PoolRawAccess::getEntry: Array position: " <<
+	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
+	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
+	if (typeSize == 0)
+		return DATA_POOL_ACCESS_FAILED;
+	if (typeSize > max_size)
+		return INCORRECT_SIZE;
+	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
+	*writtenBytes = typeSize;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+        size_t maxSize, Endianness streamEndianness) const {
+    if (typeSize + *size <= maxSize) {
+    	switch(streamEndianness) {
+    	case(Endianness::BIG):
+    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::MACHINE):
+    	default:
+            memcpy(*buffer, value, typeSize);
+            break;
+        }
+        *size += typeSize;
+        (*buffer) += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return SerializeIF::BUFFER_TOO_SHORT;
+    }
+}
+
+
+Type PoolRawAccess::getType() {
+	return type;
+}
+
+size_t PoolRawAccess::getSizeOfType() {
+	return typeSize;
+}
+
+size_t PoolRawAccess::getArraySize(){
+	return arraySize;
+}
+
+uint32_t PoolRawAccess::getDataPoolId() const {
+	return dataPoolId;
+}
+
+PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
+	return readWriteMode;
+}
+
+ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
+		size_t setSize) {
+	if (typeSize == setSize) {
+		EndianConverter::convertBigEndian(value, buffer, typeSize);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
+				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
+				<< std::endl;
+		return INCORRECT_SIZE;
+	}
+}
+
+bool PoolRawAccess::isValid() const {
+	if (valid != INVALID)
+		return true;
+	else
+		return false;
+}
+
+void PoolRawAccess::setValid(bool valid) {
+	this->valid = valid;
+}
+
+size_t PoolRawAccess::getSizeTillEnd() const {
+	return sizeTillEnd;
+}
+
+
+size_t PoolRawAccess::getSerializedSize() const {
+	return typeSize;
+}
+
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
+        Endianness streamEndianness) {
+
+    if (*size >= typeSize) {
+        switch(streamEndianness) {
+        case(Endianness::BIG):
+			EndianConverter::convertBigEndian(value, *buffer, typeSize);
+		    break;
+        case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
+		   	break;
+        case(Endianness::MACHINE):
+        default:
+            memcpy(value, *buffer, typeSize);
+            break;
+        }
+    	*size -= typeSize;
+        *buffer += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+    	return SerializeIF::STREAM_TOO_SHORT;
+    }
+}
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
new file mode 100644
index 000000000..15643a41c
--- /dev/null
+++ b/datapoolglob/PoolRawAccess.h
@@ -0,0 +1,220 @@
+#ifndef POOLRAWACCESS_H_
+#define POOLRAWACCESS_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntryIF.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../globalfunctions/Type.h"
+
+/**
+ * @brief This class allows accessing Data Pool variables as raw bytes.
+ * @details
+ * This is necessary to have an access method for HK data, as the PID's alone
+ * do not provide type information. Please note that the the raw pool access
+ * read() and commit() calls are not thread-safe.
+ *
+ * Please supply a data set and use the data set read(), commit() calls for
+ * thread-safe data pool access.
+ * @ingroup data_pool
+ */
+class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
+public:
+	/**
+	 * This constructor is used to access a data pool entry with a
+	 * given ID if the target type is not known. A DataSet object is supplied
+	 * and the data pool entry with the given ID is registered to that data set.
+	 * Please note that a pool raw access buffer only has a buffer
+	 * with a size of double. As such, for vector entries which have
+	 * @param data_pool_id Target data pool entry ID
+	 * @param arrayEntry
+	 * @param data_set Dataset to register data pool entry to
+	 * @param setReadWriteMode
+	 * @param registerVectors If set to true, the constructor checks if
+	 *                        there are multiple vector entries to registers
+	 *                        and registers all of them recursively into the data_set
+	 *
+	 */
+	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
+			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
+					PoolVariableIF::VAR_READ);
+
+	/**
+	 * @brief	This operation returns a pointer to the entry fetched.
+	 * @details	Return pointer to the buffer containing the raw data
+	 *          Size and number of data can be retrieved by other means.
+	 */
+	uint8_t* getEntry();
+	/**
+	 * @brief 	This operation returns the fetched entry from the data pool and
+	 * 			flips the bytes, if necessary.
+	 * @details	It makes use of the getEntry call of this function, but additionally flips the
+	 * 			bytes to big endian, which is the default for external communication (as House-
+	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
+	 * 			buffer, if it fits in the given max_size.
+	 * @param buffer	A pointer to a buffer to write to
+	 * @param writtenBytes	The number of bytes written is returned with this value.
+	 * @param max_size	The maximum size that the function may write to buffer.
+	 * @return	- @c RETURN_OK if entry could be acquired
+	 * 			- @c RETURN_FAILED else.
+	 */
+	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
+			size_t maxSize);
+
+	/**
+	 * @brief 	Serialize raw pool entry into provided buffer directly
+	 * @param buffer Provided buffer. Raw pool data will be copied here
+	 * @param size [out] Increment provided size value by serialized size
+	 * @param max_size Maximum allowed serialization size
+	 * @param bigEndian Specify endianess
+	 * @return - @c RETURN_OK if serialization was successfull
+	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
+	 */
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+	        size_t maxSize, Endianness streamEndianness) const override;
+
+    size_t getSerializedSize() const override;
+
+    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+            Endianness streamEndianness) override;
+
+	/**
+	 * With this method, the content can be set from a big endian buffer safely.
+	 * @param buffer	Pointer to the data to set
+	 * @param size		Size of the data to write. Must fit this->size.
+	 * @return	- @c RETURN_OK on success
+	 * 			- @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
+			size_t setSize);
+	/**
+	 *  @brief This operation returns the type of the entry currently stored.
+	 */
+	Type getType();
+	/**
+	 *  @brief This operation returns the size of the entry currently stored.
+	 */
+	size_t getSizeOfType();
+	/**
+	 *
+	 * @return the size of the datapool array
+	 */
+	size_t getArraySize();
+	/**
+	 * @brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
+	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
+	static const uint8_t RAW_MAX_SIZE = sizeof(double);
+	uint8_t value[RAW_MAX_SIZE];
+
+
+	/**
+	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~PoolRawAccess();
+
+	/**
+	 * This method returns if the variable is read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const;
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const;
+
+	void setValid(bool valid);
+	/**
+	 * Getter for the remaining size.
+	 */
+	size_t getSizeTillEnd() const;
+
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The call is protected by a lock of the global data pool.
+	 * @return -@c RETURN_OK Read successfull
+	 * 		   -@c READ_TYPE_TOO_LARGE
+	 * 		   -@c READ_INDEX_TOO_LARGE
+	 * 		   -@c READ_ENTRY_NON_EXISTENT
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The call is protected by a lock of the global data pool.
+	 *
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
+	void handleReadError(ReturnValue_t result);
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * 			is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * @brief	The array entry that is fetched from the data pool.
+	 */
+	uint8_t arrayEntry;
+	/**
+	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	This value contains the type of the data pool entry.
+	 */
+	Type type;
+	/**
+	 * @brief	This value contains the size of the data pool entry type in bytes.
+	 */
+	size_t typeSize;
+	/**
+	 * The size of the DP array (single values return 1)
+	 */
+	size_t arraySize;
+	/**
+	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
+	 */
+	size_t sizeTillEnd;
+	/**
+	 * @brief	The information whether the class is read-write or read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+};
+
+#endif /* POOLRAWACCESS_H_ */

From 790d3f14654cf1b7f937c36f9b1d02289dc596ce Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 15:25:56 +0200
Subject: [PATCH 0736/1774] taken over all changes

---
 fsfw.mk                                 | 16 ++++++++++++++
 internalError/InternalErrorReporter.cpp | 19 ++++++++---------
 monitoring/MonitorBase.h                | 14 ++++++-------
 power/Fuse.cpp                          |  6 +++---
 power/Fuse.h                            | 15 ++++++-------
 power/PowerSensor.h                     | 10 ++++-----
 thermal/CoreComponent.cpp               | 12 +++++------
 thermal/CoreComponent.h                 | 23 ++++++++++----------
 thermal/ThermalComponent.cpp            | 18 +++++++---------
 thermal/ThermalComponent.h              | 28 +++++++++++++++++++++++--
 thermal/ThermalModule.cpp               |  8 +++----
 thermal/ThermalModule.h                 | 17 ++++++++-------
 12 files changed, 114 insertions(+), 72 deletions(-)

diff --git a/fsfw.mk b/fsfw.mk
index c2c6e7475..c58475540 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -9,6 +9,9 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/controller/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoolglob/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/eventmatching/*.cpp)
@@ -28,12 +31,25 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/*.cpp)
 # select the OS
 ifeq ($(OS_FSFW),rtems)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/rtems/*.cpp)
+
 else ifeq ($(OS_FSFW),linux)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/linux/*.cpp)
+
 else ifeq ($(OS_FSFW),freeRTOS)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
+
 else ifeq ($(OS_FSFW),host)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
+ifeq ($(OS),Windows_NT)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/windows/*.cpp)
+else
+# For now, the linux UDP bridge sources needs to be included manually by upper makefile
+# for host OS because we can't be sure the OS is linux.
+# Following lines can be used to do this:
+# CXXSRC += $(FRAMEWORK_PATH)/osal/linux/TcUnixUdpPollingTask.cpp
+# CXXSRC += $(FRAMEWORK_PATH)/osal/linux/TmTcUnixUdpBridge.cpp
+endif
+
 else
 $(error invalid OS_FSFW specified, valid OS_FSFW are rtems, linux, freeRTOS, host)
 endif
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 861e1595e..3424266bd 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,17 +1,16 @@
+#include "../datapoolglob/GlobalDataSet.h"
 #include "InternalErrorReporter.h"
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PoolVariable.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../ipc/MutexFactory.h"
 
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
 		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
-		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId), tmPoolId(
-				tmPoolId), storePoolId(
-				storePoolId), queueHits(0), tmHits(0), storeHits(
-				0) {
+		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
+		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
+		storeHits(0) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
@@ -21,13 +20,13 @@ InternalErrorReporter::~InternalErrorReporter() {
 
 ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 
-	DataSet mySet;
-	PoolVariable<uint32_t> queueHitsInPool(queuePoolId, &mySet,
+	GlobDataSet mySet;
+	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
 			PoolVariableIF::VAR_READ_WRITE);
-	PoolVariable<uint32_t> tmHitsInPool(tmPoolId, &mySet,
+	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
 			PoolVariableIF::VAR_READ_WRITE);
 
-	PoolVariable<uint32_t> storeHitsInPool(storePoolId, &mySet,
+	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
 			PoolVariableIF::VAR_READ_WRITE);
 	mySet.read();
 
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index b2d0e6cbb..5173c4798 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,12 +1,12 @@
 #ifndef MONITORBASE_H_
 #define MONITORBASE_H_
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PIDReader.h"
-#include "LimitViolationReporter.h"
-#include "MonitoringIF.h"
-#include "MonitoringMessageContent.h"
-#include "MonitorReporter.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../monitoring/MonitorReporter.h"
 
 /**
  * Base class for monitoring of parameters.
@@ -48,7 +48,7 @@ public:
 
 protected:
 	virtual ReturnValue_t fetchSample(T* sample) {
-		DataSet mySet;
+		GlobDataSet mySet;
 		PIDReader<T> parameter(this->parameterId, &mySet);
 		mySet.read();
 		if (!parameter.isValid()) {
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 9986ab6bb..3ea0b18cc 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -1,7 +1,7 @@
 #include "../monitoring/LimitViolationReporter.h"
 #include "../monitoring/MonitoringMessageContent.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "Fuse.h"
+#include "../power/Fuse.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../ipc/QueueFactory.h"
 
@@ -12,7 +12,7 @@ Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
 		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
 		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
 				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
-				DataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
+				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
 				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
 				ids.pidCurrent, &set), state(ids.pidState, &set), power(
 				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
@@ -109,7 +109,7 @@ size_t Fuse::getSerializedSize() const {
 }
 
 ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
-Endianness streamEndianness) {
+        Endianness streamEndianness) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
 			iter++) {
diff --git a/power/Fuse.h b/power/Fuse.h
index 279642be6..dd8759f47 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -1,12 +1,13 @@
 #ifndef FUSE_H_
 #define FUSE_H_
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PIDReader.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoolglob/PIDReader.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../monitoring/AbsLimitMonitor.h"
-#include "PowerComponentIF.h"
-#include "PowerSwitchIF.h"
+#include "../power/PowerComponentIF.h"
+#include "../power/PowerSwitchIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../parameters/ParameterHelper.h"
 #include <list>
@@ -84,12 +85,12 @@ private:
 
 	};
 	PowerMonitor powerMonitor;
-	DataSet set;
+	GlobDataSet set;
 	PIDReader<float> voltage;
 	PIDReader<float> current;
 	PIDReader<uint8_t> state;
-	db_float_t power;
-	MessageQueueIF *commandQueue;
+	gp_float_t power;
+	MessageQueueIF* commandQueue;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
 	static object_id_t powerSwitchId;
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index 0f973e455..da0bd8c73 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -1,9 +1,9 @@
 #ifndef POWERSENSOR_H_
 #define POWERSENSOR_H_
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PIDReader.h"
-#include "../datapool/PoolVariable.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoolglob/PIDReader.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../monitoring/LimitMonitor.h"
 #include "../parameters/ParameterHelper.h"
@@ -53,12 +53,12 @@ private:
 	MessageQueueIF* commandQueue;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
-	DataSet set;
+	GlobDataSet set;
 	//Variables in
 	PIDReader<float> current;
 	PIDReader<float> voltage;
 	//Variables out
-	db_float_t power;
+	gp_float_t power;
 
 	static const uint8_t MODULE_ID_CURRENT = 1;
 	static const uint8_t MODULE_ID_VOLTAGE = 2;
diff --git a/thermal/CoreComponent.cpp b/thermal/CoreComponent.cpp
index 304712ef8..657e79cb0 100644
--- a/thermal/CoreComponent.cpp
+++ b/thermal/CoreComponent.cpp
@@ -2,7 +2,7 @@
 
 CoreComponent::CoreComponent(object_id_t reportingObjectId, uint8_t domainId,
 		uint32_t temperaturePoolId, uint32_t targetStatePoolId,
-		uint32_t currentStatePoolId, uint32_t requestPoolId, DataSet* dataSet,
+		uint32_t currentStatePoolId, uint32_t requestPoolId, GlobDataSet* dataSet,
 		AbstractTemperatureSensor* sensor,
 		AbstractTemperatureSensor* firstRedundantSensor,
 		AbstractTemperatureSensor* secondRedundantSensor,
@@ -18,14 +18,14 @@ CoreComponent::CoreComponent(object_id_t reportingObjectId, uint8_t domainId,
 				AbstractTemperatureSensor::ZERO_KELVIN_C), parameters(
 				parameters), temperatureMonitor(reportingObjectId,
 				domainId + 1,
-				DataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
+				GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
 				COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
 	if (thermalModule != NULL) {
 		thermalModule->registerComponent(this, priority);
 	}
 	//Set thermal state once, then leave to operator.
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetStatePoolId, &mySet,
+	GlobDataSet mySet;
+	gp_uint8_t writableTargetState(targetStatePoolId, &mySet,
 			PoolVariableIF::VAR_WRITE);
 	writableTargetState = initialTargetState;
 	mySet.commit(PoolVariableIF::VALID);
@@ -70,8 +70,8 @@ float CoreComponent::getLowerOpLimit() {
 }
 
 ReturnValue_t CoreComponent::setTargetState(int8_t newState) {
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
+	GlobDataSet mySet;
+	gp_uint8_t writableTargetState(targetState.getDataPoolId(),
 			&mySet, PoolVariableIF::VAR_READ_WRITE);
 	mySet.read();
 	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index 48a49f7d0..8093711d6 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -1,13 +1,14 @@
 #ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
 #define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PoolVariable.h"
-#include "ThermalComponentIF.h"
-#include "AbstractTemperatureSensor.h"
-#include "ThermalModule.h"
-#include "ThermalMonitor.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../thermal/ThermalComponentIF.h"
+#include "../thermal/AbstractTemperatureSensor.h"
+#include "../thermal/ThermalModule.h"
+#include "../thermal/ThermalMonitor.h"
 
+// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
 class CoreComponent: public ThermalComponentIF {
 public:
 	struct Parameters {
@@ -22,7 +23,7 @@ public:
 
 	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
 			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-			uint32_t requestPoolId, DataSet *dataSet,
+			uint32_t requestPoolId, GlobDataSet *dataSet,
 			AbstractTemperatureSensor *sensor,
 			AbstractTemperatureSensor *firstRedundantSensor,
 			AbstractTemperatureSensor *secondRedundantSensor,
@@ -57,10 +58,10 @@ protected:
 	AbstractTemperatureSensor *secondRedundantSensor;
 	ThermalModuleIF *thermalModule;
 
-	db_float_t temperature;
-	db_int8_t targetState;
-	db_int8_t currentState;
-	db_uint8_t heaterRequest;
+	gp_float_t temperature;
+	gp_int8_t targetState;
+	gp_int8_t currentState;
+	gp_uint8_t heaterRequest;
 
 	bool isHeating;
 
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 5dcd0bc64..50786654b 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -3,7 +3,7 @@
 ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
 		uint8_t domainId, uint32_t temperaturePoolId,
 		uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-		uint32_t requestPoolId, DataSet* dataSet,
+		uint32_t requestPoolId, GlobDataSet* dataSet,
 		AbstractTemperatureSensor* sensor,
 		AbstractTemperatureSensor* firstRedundantSensor,
 		AbstractTemperatureSensor* secondRedundantSensor,
@@ -12,20 +12,18 @@ ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
 		CoreComponent(reportingObjectId, domainId, temperaturePoolId,
 				targetStatePoolId, currentStatePoolId, requestPoolId, dataSet,
 				sensor, firstRedundantSensor, secondRedundantSensor,
-				thermalModule,
-				{ parameters.lowerOpLimit, parameters.upperOpLimit,
-						parameters.heaterOn, parameters.hysteresis,
-						parameters.heaterSwitchoff }, priority,
-				ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL), nopParameters(
-				{ parameters.lowerNopLimit, parameters.upperNopLimit }) {
+				thermalModule,{ parameters.lowerOpLimit, parameters.upperOpLimit,
+				parameters.heaterOn, parameters.hysteresis, parameters.heaterSwitchoff },
+				priority, ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL),
+		nopParameters({ parameters.lowerNopLimit, parameters.upperNopLimit }) {
 }
 
 ThermalComponent::~ThermalComponent() {
 }
 
 ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
+	GlobDataSet mySet;
+	gp_int8_t writableTargetState(targetState.getDataPoolId(),
 			&mySet, PoolVariableIF::VAR_READ_WRITE);
 	mySet.read();
 	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
@@ -42,7 +40,7 @@ ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
 	}
 }
 
-ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
+ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
 	if (size != 4 * sizeof(parameters.lowerOpLimit)) {
 		return MonitoringIF::INVALID_SIZE;
 	}
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 932438684..195f03b10 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -3,6 +3,9 @@
 
 #include "CoreComponent.h"
 
+/**
+ * What is it. How to use
+ */
 class ThermalComponent: public CoreComponent {
 public:
 	struct Parameters {
@@ -14,13 +17,34 @@ public:
 		float hysteresis;
 		float heaterSwitchoff;
 	};
+
+	/**
+	 * Non-Operational Temperatures
+	 */
 	struct NopParameters {
 		float lowerNopLimit;
 		float upperNopLimit;
 	};
+
+	/**
+	 * How to use.
+	 * @param reportingObjectId
+	 * @param domainId
+	 * @param temperaturePoolId
+	 * @param targetStatePoolId
+	 * @param currentStatePoolId
+	 * @param requestPoolId
+	 * @param dataSet
+	 * @param sensor
+	 * @param firstRedundantSensor
+	 * @param secondRedundantSensor
+	 * @param thermalModule
+	 * @param parameters
+	 * @param priority
+	 */
 	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
 			uint32_t targetStatePoolId, uint32_t currentStatePoolId, uint32_t requestPoolId,
-			DataSet *dataSet, AbstractTemperatureSensor *sensor,
+			GlobDataSet *dataSet, AbstractTemperatureSensor *sensor,
 			AbstractTemperatureSensor *firstRedundantSensor,
 			AbstractTemperatureSensor *secondRedundantSensor,
 			ThermalModuleIF *thermalModule, Parameters parameters,
@@ -29,7 +53,7 @@ public:
 
 	ReturnValue_t setTargetState(int8_t newState);
 
-	virtual ReturnValue_t setLimits( const uint8_t* data, uint32_t size);
+	virtual ReturnValue_t setLimits( const uint8_t* data, size_t size);
 
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index c573008e6..fbd6939e7 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -6,7 +6,7 @@
 
 ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
 		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
-		DataSet *dataSet, Parameters parameters,
+		GlobDataSet *dataSet, Parameters parameters,
 		RedundantHeater::Parameters heaterParameters) :
 		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
 				false), parameters(parameters), moduleTemperature(
@@ -16,7 +16,7 @@ ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
 	heater = new RedundantHeater(heaterParameters);
 }
 
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, DataSet* dataSet) :
+ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
 		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
 				false), parameters( { 0, 0 }), moduleTemperature(
 				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
@@ -250,8 +250,8 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 }
 
 void ThermalModule::setHeating(bool on) {
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
+	GlobDataSet mySet;
+	gp_int8_t writableTargetState(targetState.getDataPoolId(),
 			&mySet, PoolVariableIF::VAR_WRITE);
 	if (on) {
 		writableTargetState = STATE_REQUEST_HEATING;
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index 19ab9a549..41be6baae 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -1,8 +1,8 @@
 #ifndef THERMALMODULE_H_
 #define THERMALMODULE_H_
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PoolVariable.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../events/EventReportingProxyIF.h"
 #include "ThermalModuleIF.h"
@@ -11,6 +11,9 @@
 #include "RedundantHeater.h"
 class PowerSwitchIF;
 
+/**
+ * @brief Allows creation of different thermal control domains within a system.
+ */
 class ThermalModule: public ThermalModuleIF {
 	friend class ThermalController;
 public:
@@ -20,10 +23,10 @@ public:
 	};
 
 	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
-			uint32_t targetStatePoolId, DataSet *dataSet, Parameters parameters,
+			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
 			RedundantHeater::Parameters heaterParameters);
 
-	ThermalModule(uint32_t moduleTemperaturePoolId, DataSet *dataSet);
+	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
 
 	virtual ~ThermalModule();
 
@@ -67,12 +70,12 @@ protected:
 
 	Parameters parameters;
 
-	db_float_t moduleTemperature;
+	gp_float_t moduleTemperature;
 
 	RedundantHeater *heater;
 
-	db_int8_t currentState;
-	db_int8_t targetState;
+	gp_int8_t currentState;
+	gp_int8_t targetState;
 
 	std::list<AbstractTemperatureSensor *> sensors;
 	std::list<ComponentData> components;

From f61056eeb7213cf111c35dde65827e55b2cd8d0a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 15:30:56 +0200
Subject: [PATCH 0737/1774] adapted DHB to renaming

---
 devicehandlers/DeviceHandlerBase.cpp | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 017ea8d26..6fcba64bc 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -5,8 +5,8 @@
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
-#include "../datapool/DataSet.h"
-#include "../datapool/PoolVariable.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../globalfunctions/CRC.h"
 #include "../subsystem/SubsystemBase.h"
 #include "../ipc/QueueFactory.h"
@@ -186,8 +186,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	fillCommandAndReplyMap();
 
 	//Set temperature target state to NON_OP.
-	DataSet mySet;
-	db_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+	GlobDataSet mySet;
+	gp_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 			PoolVariableIF::VAR_WRITE);
 	mySet.read();
 	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
@@ -469,8 +469,8 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	Clock::getUptime(&timeoutStart);
 
 	if (mode == MODE_OFF) {
-		DataSet mySet;
-		db_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+		GlobDataSet mySet;
+		gp_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ_WRITE);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -926,10 +926,10 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
 
 	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
 			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)) {
-		DataSet mySet;
-		db_int8_t thermalState(deviceThermalStatePoolId, &mySet,
+		GlobDataSet mySet;
+		gp_int8_t thermalState(deviceThermalStatePoolId, &mySet,
 				PoolVariableIF::VAR_READ);
-		db_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+		gp_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -956,8 +956,8 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 			childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
 					MODE_ON);
 			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-			DataSet mySet;
-			db_int8_t thermalRequest(deviceThermalRequestPoolId,
+			GlobDataSet mySet;
+			gp_int8_t thermalRequest(deviceThermalRequestPoolId,
 					&mySet, PoolVariableIF::VAR_READ_WRITE);
 			mySet.read();
 			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -1185,7 +1185,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 	}
 	//Try to cast to GlobDataSet and commit data.
 	if (!neverInDataPool) {
-		DataSet* dataSet = dynamic_cast<DataSet*>(data);
+		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
 		if (dataSet != NULL) {
 			dataSet->commit(PoolVariableIF::VALID);
 		}

From d99b100ace281a6a371e42ba15c8d260a27159ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 18:46:56 +0200
Subject: [PATCH 0738/1774] debug output removed

---
 storagemanager/ConstStorageAccessor.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 4ada7f801..6235ac400 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -14,7 +14,6 @@ ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
 
 ConstStorageAccessor::~ConstStorageAccessor() {
 	if(deleteData and store != nullptr) {
-		sif::debug << "deleting store data" << std::endl;
 		store->deleteData(storeId);
 	}
 }

From e085deb2355e68e4456143988964a152ff96134b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 7 Sep 2020 15:23:27 +0200
Subject: [PATCH 0739/1774] fifo fix

---
 container/FIFO.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/container/FIFO.h b/container/FIFO.h
index 19f763fc8..5a66a334c 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -25,6 +25,7 @@ public:
 	 * @param other
 	 */
 	FIFO(const FIFO& other): FIFOBase<T>(other) {
+		this->fifoArray = other.fifoArray;
 		this->setContainer(fifoArray.data());
 	}
 

From d43ef479b6191923a60b308fa9a3efa7fd1bd249 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:02:58 +0200
Subject: [PATCH 0740/1774] assignment operator added

---
 container/DynamicFIFO.h | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index abb533308..86d43f7d7 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -27,14 +27,27 @@ public:
 
 	/**
 	 * @brief	Custom copy constructor which prevents setting the
-	 * 	        underlying pointer wrong.
+	 * 	        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;
 };

From cefac2db0b9f2672039e83bce27d38a92cdb7933 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:03:28 +0200
Subject: [PATCH 0741/1774] assignment operator added

---
 container/FIFO.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/container/FIFO.h b/container/FIFO.h
index 5a66a334c..701138520 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -29,6 +29,17 @@ public:
 		this->setContainer(fifoArray.data());
 	}
 
+	/**
+	 * @brief Custom assignment operator
+	 * @param other
+	 */
+	FIFO& operator=(const FIFO& other){
+		FIFOBase<T>::operator=(other);
+		this->fifoArray = other.fifoArray;
+		this->setContainer(fifoArray.data());
+		return *this;
+	}
+
 private:
 	std::array<T, capacity> fifoArray;
 };

From 18e6de7d6ba75326262918d4bd0dde93e5c6fa0a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:04:43 +0200
Subject: [PATCH 0742/1774] added compile time check

---
 container/FixedMap.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 3da65784b..3b09fa3bc 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -14,6 +14,10 @@
  */
 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);

From db3e32655d70fc4b56c69325faee75449190bf01 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:05:26 +0200
Subject: [PATCH 0743/1774] changes taken over from master

---
 tmtcservices/CommandingServiceBase.h | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 29ab967a1..23b08acf1 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -5,9 +5,9 @@
 #include "../storagemanager/StorageManagerIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "AcceptsTelecommandsIF.h"
 
-#include "../tmtcservices/VerificationReporter.h"
+#include "VerificationReporter.h"
 #include "../ipc/CommandMessage.h"
 #include "../container/FixedMap.h"
 #include "../container/FIFO.h"
@@ -211,8 +211,7 @@ protected:
 
 	virtual void doPeriodicOperation();
 
-
-	struct CommandInfo {
+	struct CommandInfo: public SerializeIF{
 		struct tcInfo {
 			uint8_t ackFlags;
 			uint16_t tcPacketId;
@@ -225,6 +224,20 @@ protected:
 		Command_t command;
 		object_id_t objectId;
 		FIFO<store_address_t, 3> fifo;
+
+		virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+					size_t maxSize, Endianness streamEndianness) const override{
+			return HasReturnvaluesIF::RETURN_FAILED;
+		};
+
+		virtual size_t getSerializedSize() const override {
+			return 0;
+		};
+
+		virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+				Endianness streamEndianness) override{
+			return HasReturnvaluesIF::RETURN_FAILED;
+		};
 	};
 
 	using CommandMapIter = FixedMap<MessageQueueId_t,

From 224ea3914a08710227f057703b64c8a0aaf4d240 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:15:13 +0200
Subject: [PATCH 0744/1774] deleted file not needed anymore

---
 container/IsDerivedFrom.h | 50 ---------------------------------------
 1 file changed, 50 deletions(-)
 delete mode 100644 container/IsDerivedFrom.h

diff --git a/container/IsDerivedFrom.h b/container/IsDerivedFrom.h
deleted file mode 100644
index 8142a3781..000000000
--- a/container/IsDerivedFrom.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef ISDERIVEDFROM_H_
-#define ISDERIVEDFROM_H_
-
-/**
- * These template type checks are based on SFINAE
- * (https://en.cppreference.com/w/cpp/language/sfinae)
- *
- * @tparam D Derived Type
- * @tparam B Base Type
- */
-template<typename D, typename B>
-class IsDerivedFrom {
-	class No {
-	};
-	class Yes {
-		No no[3];
-	};
-
-	// This will be chosen if B is the base type
-	static Yes Test(B*); // declared, but not defined
-	// This will be chosen for anything else
-	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_ */

From f663de2418ae1be1064ab4acbf132651c0e5b509 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:17:38 +0200
Subject: [PATCH 0745/1774] taken over changes from master

---
 serialize/SerializeAdapter.h | 116 +++++++++++++++++++++++++----------
 1 file changed, 83 insertions(+), 33 deletions(-)

diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 24f6111ef..a05b17916 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -1,47 +1,92 @@
-#ifndef FSFW_SERIALIZE_SERIALIZEADAPTER_H_
-#define FSFW_SERIALIZE_SERIALIZEADAPTER_H_
+#ifndef _FSFW_SERIALIZE_SERIALIZEADAPTER_H_
+#define _FSFW_SERIALIZE_SERIALIZEADAPTER_H_
 
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include "EndianConverter.h"
 #include "SerializeIF.h"
+#include <cstddef>
+#include <type_traits>
 
-#include "../container/IsDerivedFrom.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstring>
-
- /**
- * @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
+/**
+ * \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,
@@ -50,8 +95,9 @@ private:
 			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:
@@ -65,7 +111,7 @@ private:
 					tmp = *object;
 					break;
 				}
-				std::memcpy(*buffer, &tmp, sizeof(T));
+				memcpy(*buffer, &tmp, sizeof(T));
 				*size += sizeof(T);
 				(*buffer) += sizeof(T);
 				return HasReturnvaluesIF::RETURN_OK;
@@ -79,7 +125,7 @@ private:
 			T tmp;
 			if (*size >= sizeof(T)) {
 				*size -= sizeof(T);
-				std::memcpy(&tmp, *buffer, sizeof(T));
+				memcpy(&tmp, *buffer, sizeof(T));
 				switch (streamEndianness) {
 				case SerializeIF::Endianness::BIG:
 					*object = EndianConverter::convertBigEndian<T>(tmp);
@@ -103,14 +149,18 @@ 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 == nullptr) {
@@ -118,7 +168,7 @@ private:
 			}
 			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();
 		}
 
@@ -129,4 +179,4 @@ private:
 	};
 };
 
-#endif /* SERIALIZEADAPTER_H_ */
+#endif /* _FSFW_SERIALIZE_SERIALIZEADAPTER_H_ */

From fd09774fc3577eb3993759d2473112796c87a0cb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:18:45 +0200
Subject: [PATCH 0746/1774] serialize if update

---
 serialize/SerializeIF.h | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 3c0540f92..a701fe53f 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -2,7 +2,7 @@
 #define FSFW_SERIALIZE_SERIALIZEIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
+#include <stddef.h>
 
 /**
  * @defgroup serialize Serialization
@@ -10,10 +10,7 @@
  */
 
 /**
- * @brief 	Translation of objects into data streams and from data streams.
- * @details
- * Also provides options to convert from/to data with different endianness.
- * variables.
+ * Translation of objects into data streams and from data streams.
  * @ingroup serialize
  */
 class SerializeIF {
@@ -46,7 +43,7 @@ public:
 	 * @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
-	 * 		- @¢ BUFFER_TOO_SHORT The given buffer in is too short
+	 * 		- @c BUFFER_TOO_SHORT The given buffer in is too short
 	 * 		- @c RETURN_FAILED Generic error
 	 * 		- @c RETURN_OK Successful serialization
 	 */

From bbc73a6aaf5d607aca25c04b2bc59a1f7d4b031c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:25:29 +0200
Subject: [PATCH 0747/1774] taken over serialize adapter changes

---
 serialize/SerializeAdapter.h | 31 +++++++++++++++++++++----------
 1 file changed, 21 insertions(+), 10 deletions(-)

diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index a05b17916..e6cd247e1 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -7,17 +7,26 @@
 #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.
+	 * 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.
+	 * 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.
@@ -86,7 +95,8 @@ private:
 	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");
+				"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,
@@ -95,7 +105,8 @@ private:
 			if (size == nullptr) {
 				size = &ignoredSize;
 			}
-			//Check remaining size is large enough and check integer overflow of *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;
@@ -111,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;
@@ -125,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);

From 96e471add600b1829d08958e87b505d37e45a8e3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:51:11 +0200
Subject: [PATCH 0748/1774] merged fixed map changes

---
 container/FixedMap.h | 76 +++++++++++++++++---------------------------
 1 file changed, 29 insertions(+), 47 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 3b09fa3bc..475d4091f 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -1,23 +1,27 @@
-#ifndef FIXEDMAP_H_
-#define FIXEDMAP_H_
+#ifndef FSFW_CONTAINER_FIXEDMAP_H_
+#define FSFW_CONTAINER_FIXEDMAP_H_
 
-#include "../container/ArrayList.h"
+#include "ArrayList.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <utility>
+#include <type_traits>
 
 /**
- * @brief 	Map implementation for maps with a pre-defined size.
- * @details Can be initialized with desired maximum size.
- * 	        Iterator is used to access <key,value> pair and
- * 	        iterate through map entries. Complexity O(n).
+ * @brief    Map implementation for maps with a pre-defined size.
+ * @details
+ * Can be initialized with desired maximum size.
+ * Iterator is used to access <key,value> pair and iterate through map entries.
+ * Complexity O(n).
+ * @warning Iterators return a non-const key_t in the pair.
+ * @warning A User is not allowed to change the key, otherwise the map is corrupted.
  * @ingroup container
  */
 template<typename key_t, typename T>
 class FixedMap: public SerializeIF {
-    static_assert (std::is_trivially_copyable<T>::value or
-            std::is_base_of<SerializeIF, T>::value,
-            "Types used in FixedMap must either be trivial copy-able or a "
-            "derived class from SerializeIF to be serialize-able");
+	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);
@@ -55,29 +59,8 @@ 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;
-		}
-
-		// -> operator overloaded, can be used to access value
-		T *operator->() {
-			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		// Can be used to access the key of the iterator
-		key_t first() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->first;
-		}
-
-		// Alternative to access value, similar to std::map implementation
-		T second() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
 	};
 
-
-
 	Iterator begin() const {
 		return Iterator(&theMap[0]);
 	}
@@ -90,16 +73,16 @@ 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 FixedMap::KEY_ALREADY_EXISTS;
+			return KEY_ALREADY_EXISTS;
 		}
 		if (_size == theMap.maxSize()) {
-			return FixedMap::MAP_FULL;
+			return MAP_FULL;
 		}
 		theMap[_size].first = key;
 		theMap[_size].second = value;
-		if (storedValue != NULL) {
+		if (storedValue != nullptr) {
 			*storedValue = Iterator(&theMap[_size]);
 		}
 		++_size;
@@ -160,6 +143,15 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+    bool full() {
+        if(_size >= theMap.maxSize()) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
 	void clear() {
 		_size = 0;
 	}
@@ -168,16 +160,6 @@ public:
 		return theMap.maxSize();
 	}
 
-
-	bool full() {
-		if(_size == theMap.maxSize()) {
-			return true;
-		}
-		else {
-			return false;
-		}
-	}
-
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			size_t maxSize, Endianness streamEndianness) const {
 		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
@@ -226,4 +208,4 @@ public:
 
 };
 
-#endif /* FIXEDMAP_H_ */
+#endif /* FSFW_CONTAINER_FIXEDMAP_H_ */

From f35efa3cbe3926b1e47e8a62faeb81a6dae9a1ef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:52:00 +0200
Subject: [PATCH 0749/1774] taken over CSB changes

---
 tmtcservices/CommandingServiceBase.cpp | 76 +++++++++++++-------------
 1 file changed, 38 insertions(+), 38 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index e5a87f180..4cead0e97 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -1,9 +1,9 @@
 #include "../tcdistribution/PUSDistributorIF.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "AcceptsTelemetryIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
-#include "../tmtcservices/CommandingServiceBase.h"
-#include "../tmtcservices/TmTcMessage.h"
+#include "CommandingServiceBase.h"
+#include "TmTcMessage.h"
 #include "../ipc/QueueFactory.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcpacket/pus/TmPacketStored.h"
@@ -122,8 +122,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 
 
 	// Implemented by child class, specifies what to do with reply.
-	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
-			&nextCommand, iter->objectId, &isStep);
+	ReturnValue_t result = handleReply(reply, iter->second.command, &iter->second.state,
+			&nextCommand, iter->second.objectId, &isStep);
 
 	/* If the child implementation does not implement special handling for
 	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
@@ -132,7 +132,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
 			(result == RETURN_FAILED or result == INVALID_REPLY)) {
 	    result = reply->getReplyRejectedReason();
-	    failureParameter1 = iter->command;
+	    failureParameter1 = iter->second.command;
 	}
 
 	switch (result) {
@@ -149,14 +149,14 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	default:
 		if (isStep) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					result, ++iter->step, failureParameter1,
+					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
+					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
+					result, ++iter->second.step, failureParameter1,
 					failureParameter2);
 		} else {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
+					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					result, 0, failureParameter1, failureParameter2);
 		}
 		failureParameter1 = 0;
@@ -170,7 +170,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		CommandMapIter iter, CommandMessage* nextCommand,
 		CommandMessage* reply, bool& isStep) {
-	iter->command = nextCommand->getCommand();
+	iter->second.command = nextCommand->getCommand();
 
 	// In case a new command is to be sent immediately, this is performed here.
 	// If no new command is sent, only analyse reply result by initializing
@@ -185,14 +185,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		if (isStep and result != NO_STEP_MESSAGE) {
 			verificationReporter.sendSuccessReport(
 					TC_VERIFY::PROGRESS_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, ++iter->step);
+					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
+					iter->second.tcInfo.tcSequenceControl, ++iter->second.step);
 		}
 		else {
 			verificationReporter.sendSuccessReport(
 					TC_VERIFY::COMPLETION_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, 0);
+					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
+					iter->second.tcInfo.tcSequenceControl, 0);
 			checkAndExecuteFifo(iter);
 		}
 	}
@@ -200,16 +200,16 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		if (isStep) {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult,
-					++iter->step, failureParameter1, failureParameter2);
+					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
+					iter->second.tcInfo.tcPacketId,
+					iter->second.tcInfo.tcSequenceControl, sendResult,
+					++iter->second.step, failureParameter1, failureParameter2);
 		} else {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult, 0,
+					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
+					iter->second.tcInfo.tcSequenceControl, sendResult, 0,
 					failureParameter1, failureParameter2);
 		}
 		failureParameter1 = 0;
@@ -248,7 +248,7 @@ void CommandingServiceBase::handleRequestQueue() {
 		iter = commandMap.find(queue);
 
 		if (iter != commandMap.end()) {
-			result = iter->fifo.insert(address);
+			result = iter->second.fifo.insert(address);
 			if (result != RETURN_OK) {
 				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
 			}
@@ -316,11 +316,11 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
         CommandMapIter iter) {
     ReturnValue_t result = RETURN_OK;
     CommandMessage command;
-    iter->subservice = storedPacket->getSubService();
-    result = prepareCommand(&command, iter->subservice,
+    iter->second.subservice = storedPacket->getSubService();
+    result = prepareCommand(&command, iter->second.subservice,
             storedPacket->getApplicationData(),
-            storedPacket->getApplicationDataSize(), &iter->state,
-            iter->objectId);
+            storedPacket->getApplicationDataSize(), &iter->second.state,
+            iter->second.objectId);
 
     ReturnValue_t sendResult = RETURN_OK;
 	switch (result) {
@@ -330,13 +330,13 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 					&command);
 		}
 		if (sendResult == RETURN_OK) {
-			Clock::getUptime(&iter->uptimeOfStart);
-			iter->step = 0;
-			iter->subservice = storedPacket->getSubService();
-			iter->command = command.getCommand();
-			iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
-			iter->tcInfo.tcPacketId = storedPacket->getPacketId();
-			iter->tcInfo.tcSequenceControl =
+			Clock::getUptime(&iter->second.uptimeOfStart);
+			iter->second.step = 0;
+			iter->second.subservice = storedPacket->getSubService();
+			iter->second.command = command.getCommand();
+			iter->second.tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
+			iter->second.tcInfo.tcPacketId = storedPacket->getPacketId();
+			iter->second.tcInfo.tcSequenceControl =
 					storedPacket->getPacketSequenceControl();
 			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
 		} else {
@@ -386,7 +386,7 @@ void CommandingServiceBase::acceptPacket(uint8_t reportId,
 
 void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
 	store_address_t address;
-	if (iter->fifo.retrieve(&address) != RETURN_OK) {
+	if (iter->second.fifo.retrieve(&address) != RETURN_OK) {
 		commandMap.erase(&iter);
 	} else {
 		TcPacketStored newPacket(address);
@@ -412,10 +412,10 @@ void CommandingServiceBase::checkTimeout() {
 	Clock::getUptime(&uptime);
 	CommandMapIter iter;
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
-		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
+		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
+					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					TIMEOUT);
 			checkAndExecuteFifo(iter);
 		}

From d9dcee3692aa548a94fc614529c954ffcd36b9fe Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:55:56 +0200
Subject: [PATCH 0750/1774] array list changes taken over

---
 container/ArrayList.h | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 9f5e76dee..bda604332 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -116,7 +116,11 @@ public:
             return tmp;
         }
 
-        T operator*() {
+        T& operator*() {
+            return *value;
+        }
+
+        const T& operator*() const {
             return *value;
         }
 
@@ -124,12 +128,13 @@ public:
             return value;
         }
 
-        const T *operator->() const{
+        const T *operator->() const {
             return value;
         }
 
+
         //SHOULDDO this should be implemented as non-member
-        bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const{
+        bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const {
             return (value == other.value);
         }
 

From e57d4a11ae1db3b965a24e3de5efcae1ffc29781 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 16:01:05 +0200
Subject: [PATCH 0751/1774] fixed ordered multi map changes integrated

---
 container/FixedOrderedMultimap.h   | 13 +++++--------
 container/FixedOrderedMultimap.tpp | 15 +++------------
 2 files changed, 8 insertions(+), 20 deletions(-)

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 41465c335..99825dc4b 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
-#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+#ifndef FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+#define FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
 
 #include "../container/ArrayList.h"
 #include <cstring>
@@ -39,10 +39,6 @@ public:
         Iterator();
         /** Initializes iterator to given entry */
         Iterator(std::pair<key_t, T> *pair);
-        /** Dereference operator can be used to get value */
-        T operator*();
-        /** Arrow operator can be used to get pointer to value */
-        T *operator->();
     };
 
     /** Iterator to start of map */
@@ -160,7 +156,8 @@ private:
 		if (_size <= position) {
 			return;
 		}
-		memmove(&theMap[position], &theMap[position + 1],
+		std::memmove(static_cast<void*>(&theMap[position]),
+		        static_cast<void*>(&theMap[position + 1]),
 				(_size - position - 1) * sizeof(std::pair<key_t,T>));
 		--_size;
 	}
@@ -168,4 +165,4 @@ private:
 
 #include "FixedOrderedMultimap.tpp"
 
-#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
+#endif /* FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
index 74edbf9ae..5b7b9ead9 100644
--- a/container/FixedOrderedMultimap.tpp
+++ b/container/FixedOrderedMultimap.tpp
@@ -10,11 +10,6 @@ inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator(
         std::pair<key_t, T> *pair):
         ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair){}
 
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline T FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::operator*() {
-    return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-}
-
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
 FixedOrderedMultimap<key_t, T, KEY_COMPARE>::begin() const {
@@ -33,11 +28,6 @@ inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::size() const {
     return _size;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline T* FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::operator->() {
-    return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-}
-
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::FixedOrderedMultimap(
         size_t maxSize): theMap(maxSize), _size(0) {}
@@ -52,8 +42,9 @@ inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(
     uint32_t position = findNicePlace(key);
     // Compiler might emitt warning because std::pair is not a POD type (yet..)
     // See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm#std::pair-example
-    // Should still work without issues.
-    std::memmove(&theMap[position + 1], &theMap[position],
+    // Circumvent warning by casting to void*
+    std::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;

From e4d95a4e0991e766725ddcb4158f26341c7d213e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 16:07:09 +0200
Subject: [PATCH 0752/1774] subsystem changes taken over

---
 subsystem/Subsystem.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 400ecc830..ba1f463c9 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -545,7 +545,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;
@@ -554,7 +554,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;
 		}
 	}

From d7bbd4b652ff2e2e4fe63485fe57e5622ec3d82a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 19:51:17 +0200
Subject: [PATCH 0753/1774] severla bugfixes, new periodic op divider added

---
 datapoollocal/LocalDataPoolManager.cpp       | 32 ++++++----
 datapoollocal/LocalDataPoolManager.h         |  5 +-
 globalfunctions/PeriodicOperationDivider.cpp | 34 +++++++++++
 globalfunctions/PeriodicOperationDivider.h   | 55 +++++++++++++++++
 housekeeping/HousekeepingPacketDownlink.h    | 64 +++++---------------
 5 files changed, 127 insertions(+), 63 deletions(-)
 create mode 100644 globalfunctions/PeriodicOperationDivider.cpp
 create mode 100644 globalfunctions/PeriodicOperationDivider.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index c84b2c697..39434b5a7 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -177,7 +177,8 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        float collectionInterval, MessageQueueId_t destination) {
+        /*float collectionInterval, bool reportingEnabled, */
+		bool forDownlink, MessageQueueId_t destination) {
 	LocalPoolDataSetBase* dataSetToSerialize =
 			dynamic_cast<LocalPoolDataSetBase*>(owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
@@ -187,10 +188,13 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	}
 
 	store_address_t storeId;
-	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
-	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
-	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
+	HousekeepingPacketDownlink hkPacket(sid,/* reportingEnabled,
+			collectionInterval, dataSetToSerialize->getFillCount(), */
+			dataSetToSerialize);
+	size_t serializedSize = 0;
+	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
+			forDownlink, &serializedSize);
+	if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
 	    return result;
 	}
 
@@ -213,17 +217,21 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
         HousekeepingPacketDownlink& hkPacket,
-        store_address_t *storeId) {
+        store_address_t& storeId, bool forDownlink,
+		size_t* serializedSize) {
     uint8_t* dataPtr = nullptr;
-    size_t serializedSize = 0;
     const size_t maxSize = hkPacket.getSerializedSize();
-    ReturnValue_t  result = ipcStore->getFreeElement(storeId,
-            serializedSize, &dataPtr);
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            maxSize, &dataPtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
         return result;
     }
 
-    return hkPacket.serialize(&dataPtr, &serializedSize, maxSize,
+    if(forDownlink) {
+    	return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+    	            SerializeIF::Endianness::BIG);
+    }
+    return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
             SerializeIF::Endianness::MACHINE);
 }
 
@@ -265,7 +273,9 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
     if(receiver->intervalCounter >=
             receiver->hkParameter.collectionIntervalTicks) {
         ReturnValue_t result = generateHousekeepingPacket(
-                receiver->dataId.dataSetSid);
+                receiver->dataId.dataSetSid, true
+				/*intervalToIntervalSeconds(receiver->isDiagnostics,
+				receiver->hkParameter.collectionIntervalTicks), true */);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             // configuration error
             sif::debug << "LocalDataPoolManager::performHkOperation:"
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c6567c804..552aaff70 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -110,7 +110,8 @@ public:
 	 * @return
 	 */
 	ReturnValue_t generateHousekeepingPacket(sid_t sid,
-	        float collectionInterval = 0,
+			bool forDownlink,
+	        /*float collectionInterval, bool reportingEnabled, */
 	        MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
@@ -248,7 +249,7 @@ private:
 	void setMinimalSamplingFrequency(float frequencySeconds);
 	ReturnValue_t serializeHkPacketIntoStore(
 	        HousekeepingPacketDownlink& hkPacket,
-	        store_address_t *storeId);
+	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
 
 	uint32_t intervalSecondsToInterval(bool isDiagnostics,
 	        float collectionIntervalSeconds);
diff --git a/globalfunctions/PeriodicOperationDivider.cpp b/globalfunctions/PeriodicOperationDivider.cpp
new file mode 100644
index 000000000..ad3b8bbd5
--- /dev/null
+++ b/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;
+}
diff --git a/globalfunctions/PeriodicOperationDivider.h b/globalfunctions/PeriodicOperationDivider.h
new file mode 100644
index 000000000..dd970fb8a
--- /dev/null
+++ b/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_ */
diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
index ee531bae7..0be1551d5 100644
--- a/housekeeping/HousekeepingPacketDownlink.h
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -2,8 +2,6 @@
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
 
 #include "../datapoollocal/LocalPoolDataSetBase.h"
-
-#include "../housekeeping/HousekeepingMessage.h"
 #include "../serialize/SerialLinkedListAdapter.h"
 #include "../storagemanager/StorageManagerIF.h"
 
@@ -16,67 +14,33 @@
  */
 class HousekeepingPacketDownlink: public SerialLinkedListAdapter<SerializeIF> {
 public:
-    HousekeepingPacketDownlink(sid_t sid, float collectionInterval, uint8_t
-            numberOfParameters, LocalPoolDataSetBase* dataSetPtr):
+    HousekeepingPacketDownlink(sid_t sid, /*bool reportingStatus,
+    		float collectionInterval, uint8_t numberOfParameters, */
+			LocalPoolDataSetBase* dataSetPtr):
             sourceId(sid.objectId), setId(sid.ownerSetId),
-            collectionInterval(collectionInterval),
-            numberOfParameters(numberOfParameters), hkData(dataSetPtr) {
+			/*reportingStatus(reportingStatus),
+			collectionInterval(collectionInterval),
+            numberOfParameters(numberOfParameters), */hkData(dataSetPtr) {
         setLinks();
     }
 
-    /**
-     * Helper functions which can be used to move HK data from the IPC store
-     * to the telemetry store. TODO: maybe not needed.
-     * @param formerStore
-     * @param storeId
-     * @param newStore
-     * @param newStoreId [out]
-     * @return
-     */
-    virtual ReturnValue_t moveToOtherStore(StorageManagerIF* formerStore,
-            store_address_t storeId, StorageManagerIF* newStore,
-            store_address_t* newStoreId) {
-        const uint8_t* dataPtr = nullptr;
-        size_t hkDataSize = 0;
-        ReturnValue_t result = formerStore->getData(storeId, &dataPtr,
-                &hkDataSize);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-
-        return newStore->addData(newStoreId, dataPtr, hkDataSize);
-    }
-
 private:
     void setLinks() {
         setStart(&sourceId);
         sourceId.setNext(&setId);
-        setId.setNext(&collectionInterval);
-        collectionInterval.setNext(&numberOfParameters);
-        numberOfParameters.setNext(&hkData);
+        setId.setNext(&hkData);
+        //setId.setNext(&reportingStatus);
+		//reportingStatus.setNext(&collectionInterval);
+        //collectionInterval.setNext(&numberOfParameters);
+        //numberOfParameters.setNext(&hkData);
     }
 
     SerializeElement<object_id_t> sourceId;
     SerializeElement<uint32_t> setId;
-    SerializeElement<float> collectionInterval;
-    SerializeElement<uint8_t> numberOfParameters;
+    //SerializeElement<uint8_t> reportingStatus;
+    //SerializeElement<float> collectionInterval;
+    //SerializeElement<uint8_t> numberOfParameters;
     LinkedElement<SerializeIF> hkData;
 };
 
 #endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_ */
-
-
-
-//    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-//                size_t maxSize, Endianness streamEndianness) const override {
-//        ReturnValue_t result = SerialLinkedListAdapter::serialize(buffer, size,
-//                maxSize, streamEndianness);
-//        if(result != HasReturnvaluesIF::RETURN_OK) {
-//            return result;
-//        }
-//        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
-//   }
-//
-//   virtual size_t getSerializedSize() const override {
-//
-//   }

From 2d2d0de35cefdc627e556d33e9537cee4dca36a5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 20:24:49 +0200
Subject: [PATCH 0754/1774] local data pool manager bugfixes

---
 datapoollocal/LocalDataPoolManager.cpp | 19 ++++++++++---------
 datapoollocal/LocalDataPoolManager.h   |  3 +--
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 39434b5a7..f33cd8ab3 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -177,8 +177,7 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        /*float collectionInterval, bool reportingEnabled, */
-		bool forDownlink, MessageQueueId_t destination) {
+        bool isDiagnostics, bool forDownlink, MessageQueueId_t destination) {
 	LocalPoolDataSetBase* dataSetToSerialize =
 			dynamic_cast<LocalPoolDataSetBase*>(owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
@@ -188,9 +187,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	}
 
 	store_address_t storeId;
-	HousekeepingPacketDownlink hkPacket(sid,/* reportingEnabled,
-			collectionInterval, dataSetToSerialize->getFillCount(), */
-			dataSetToSerialize);
+	HousekeepingPacketDownlink hkPacket(sid, dataSetToSerialize);
 	size_t serializedSize = 0;
 	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
 			forDownlink, &serializedSize);
@@ -200,7 +197,13 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
 	// and now we set a HK message and send it the HK packet destination.
 	CommandMessage hkMessage;
-	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+	if(isDiagnostics) {
+		HousekeepingMessage::setHkDiagnosticsMessage(&hkMessage, sid, storeId);
+	}
+	else {
+		HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+	}
+
 	if(hkQueue == nullptr) {
 	    return QUEUE_OR_DESTINATION_NOT_SET;
 	}
@@ -273,9 +276,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
     if(receiver->intervalCounter >=
             receiver->hkParameter.collectionIntervalTicks) {
         ReturnValue_t result = generateHousekeepingPacket(
-                receiver->dataId.dataSetSid, true
-				/*intervalToIntervalSeconds(receiver->isDiagnostics,
-				receiver->hkParameter.collectionIntervalTicks), true */);
+                receiver->dataId.dataSetSid, receiver->isDiagnostics, true);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             // configuration error
             sif::debug << "LocalDataPoolManager::performHkOperation:"
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 552aaff70..1ab08903f 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -110,8 +110,7 @@ public:
 	 * @return
 	 */
 	ReturnValue_t generateHousekeepingPacket(sid_t sid,
-			bool forDownlink,
-	        /*float collectionInterval, bool reportingEnabled, */
+			bool isDiagnostics, bool forDownlink,
 	        MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 

From 71125c075a267e5f0b8cc6229095827b1e9285da Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 21:05:50 +0200
Subject: [PATCH 0755/1774] added new setter function

---
 datapoollocal/LocalPoolDataSetBase.cpp | 9 ++++++++-
 datapoollocal/LocalPoolDataSetBase.h   | 8 ++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 8abdc0e35..859f1f2c6 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -190,4 +190,11 @@ bool LocalPoolDataSetBase::isValid() const {
     return this->valid;
 }
 
-
+void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
+	if(setEntriesRecursively) {
+		for(size_t idx = 0; idx < this->getFillCount(); idx++) {
+			registeredVariables[idx] -> setValid(valid);
+		}
+	}
+	this->valid = valid;
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 77c1df1ba..17c20d4f6 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -91,6 +91,13 @@ public:
 	        size_t* size, size_t maxSize,
 	        SerializeIF::Endianness streamEndianness) const;
 
+	/**
+	 * Set the dataset valid or invalid
+	 * @param setEntriesRecursively
+	 * If this is true, all contained datasets will also be set recursively.
+	 */
+	void setValidity(bool valid, bool setEntriesRecursively);
+
 	bool isValid() const override;
 
 protected:
@@ -131,4 +138,5 @@ private:
 
 };
 
+
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ */

From f9612afe06248d38db5b8b4bb875bd7c66a12598 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 11 Sep 2020 14:06:08 +0200
Subject: [PATCH 0756/1774] added report status toggler

---
 datapoollocal/LocalDataPoolManager.cpp |  5 -----
 housekeeping/HousekeepingMessage.cpp   | 24 +++++++++++++++++++++++-
 housekeeping/HousekeepingMessage.h     | 16 +++++++---------
 3 files changed, 30 insertions(+), 15 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f33cd8ab3..c97bbfd25 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -140,11 +140,6 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		CommandMessage* message) {
     Command_t command = message->getCommand();
     switch(command) {
-    // I think those are the only commands which can be handled here..
-    case(HousekeepingMessage::ADD_HK_REPORT_STRUCT):
-    case(HousekeepingMessage::ADD_DIAGNOSTICS_REPORT_STRUCT):
-        // We should use OwnsLocalPoolDataIF to specify those functions..
-        return HasReturnvaluesIF::RETURN_OK;
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
         //return generateSetStructurePacket(message->getSid());
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index e354f8ffa..f96f4d341 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -27,6 +27,29 @@ sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
 	return getSid(message);
 }
 
+void HousekeepingMessage::setToggleReportingMessage(CommandMessage *message,
+		sid_t sid, bool enableReporting, bool isDiagnostics) {
+	if(isDiagnostics) {
+		if(enableReporting) {
+			message->setCommand(ENABLE_PERIODIC_DIAGNOSTICS_GENERATION);
+		}
+		else {
+			message->setCommand(DISABLE_PERIODIC_DIAGNOSTICS_GENERATION);
+		}
+	}
+	else {
+		if(enableReporting) {
+			message->setCommand(ENABLE_PERIODIC_HK_GENERATION);
+		}
+		else {
+			message->setCommand(DISABLE_PERIODIC_HK_REPORT_GENERATION);
+		}
+	}
+
+	setSid(message, sid);
+}
+
+
 sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 	sid_t sid;
 	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
@@ -36,4 +59,3 @@ sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
 	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
 }
-
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 75b315053..ab8fd7ac1 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -58,15 +58,6 @@ public:
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
 
-	static constexpr Command_t ADD_HK_REPORT_STRUCT =
-			MAKE_COMMAND_ID(1);
-	static constexpr Command_t ADD_DIAGNOSTICS_REPORT_STRUCT =
-			MAKE_COMMAND_ID(2);
-
-	static constexpr Command_t DELETE_HK_REPORT_STRUCT = MAKE_COMMAND_ID(3);
-	static constexpr Command_t DELETE_DIAGNOSTICS_REPORT_STRUCT =
-			MAKE_COMMAND_ID(4);
-
 	static constexpr Command_t ENABLE_PERIODIC_HK_GENERATION =
 			MAKE_COMMAND_ID(5);
 	static constexpr Command_t DISABLE_PERIODIC_HK_REPORT_GENERATION =
@@ -77,6 +68,11 @@ public:
 	static constexpr Command_t DISABLE_PERIODIC_DIAGNOSTICS_GENERATION =
 			MAKE_COMMAND_ID(8);
 
+	static constexpr Command_t REPORTING_TOGGLE_SUCCESS =
+			MAKE_COMMAND_ID(128);
+	static constexpr Command_t REPORTING_TOGGLE_FAILURE =
+			MAKE_COMMAND_ID(129);
+
 	static constexpr Command_t REPORT_HK_REPORT_STRUCTURES = MAKE_COMMAND_ID(9);
 	static constexpr Command_t REPORT_DIAGNOSTICS_REPORT_STRUCTURES =
 			MAKE_COMMAND_ID(11);
@@ -104,6 +100,8 @@ public:
 
 	static sid_t getSid(const CommandMessage* message);
 
+	static void setToggleReportingMessage(CommandMessage* message, sid_t sid,
+			bool enableReporting, bool isDiagnostics);
 	static void setHkReportMessage(CommandMessage* message, sid_t sid,
 			store_address_t storeId);
 	static void setHkDiagnosticsMessage(CommandMessage* message, sid_t sid,

From 2d2316a0c7824defdd1f079f7fd5d23c29f5d27c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Sep 2020 18:01:48 +0200
Subject: [PATCH 0757/1774] hk message continued

---
 datapoollocal/LocalDataPoolManager.cpp |  4 +-
 housekeeping/HousekeepingMessage.cpp   | 54 ++++++++++++++++++++++++--
 housekeeping/HousekeepingMessage.h     | 53 ++++++++++++++-----------
 3 files changed, 83 insertions(+), 28 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index c97bbfd25..619d8365a 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -193,10 +193,10 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	// and now we set a HK message and send it the HK packet destination.
 	CommandMessage hkMessage;
 	if(isDiagnostics) {
-		HousekeepingMessage::setHkDiagnosticsMessage(&hkMessage, sid, storeId);
+		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
 	}
 	else {
-		HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+		HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
 	}
 
 	if(hkQueue == nullptr) {
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index f96f4d341..65ba8c94b 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -3,7 +3,7 @@
 
 HousekeepingMessage::~HousekeepingMessage() {}
 
-void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
+void HousekeepingMessage::setHkReportReply(CommandMessage* message, sid_t sid,
 		store_address_t storeId) {
 	message->setCommand(HK_REPORT);
 	message->setMessageSize(HK_MESSAGE_SIZE);
@@ -11,7 +11,7 @@ void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
 	message->setParameter3(storeId.raw);
 }
 
-void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
+void HousekeepingMessage::setHkDiagnosticsReply(CommandMessage* message,
 		sid_t sid, store_address_t storeId) {
 	message->setCommand(DIAGNOSTICS_REPORT);
 	message->setMessageSize(HK_MESSAGE_SIZE);
@@ -19,7 +19,7 @@ void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
 	message->setParameter3(storeId.raw);
 }
 
-sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
+sid_t HousekeepingMessage::getHkDataReply(const CommandMessage *message,
 		store_address_t *storeIdToSet) {
 	if(storeIdToSet != nullptr) {
 	    *storeIdToSet = message->getParameter3();
@@ -27,7 +27,7 @@ sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
 	return getSid(message);
 }
 
-void HousekeepingMessage::setToggleReportingMessage(CommandMessage *message,
+void HousekeepingMessage::setToggleReportingCommand(CommandMessage *message,
 		sid_t sid, bool enableReporting, bool isDiagnostics) {
 	if(isDiagnostics) {
 		if(enableReporting) {
@@ -49,6 +49,52 @@ void HousekeepingMessage::setToggleReportingMessage(CommandMessage *message,
 	setSid(message, sid);
 }
 
+void HousekeepingMessage::setStructureReportingCommand(CommandMessage *command,
+		sid_t sid, bool isDiagnostics) {
+	if(isDiagnostics) {
+		command->setCommand(REPORT_DIAGNOSTICS_REPORT_STRUCTURES);
+	}
+	else {
+		command->setCommand(REPORT_HK_REPORT_STRUCTURES);
+	}
+
+	setSid(command, sid);
+}
+
+void HousekeepingMessage::setOneShotReportCommand(CommandMessage *command,
+		sid_t sid, bool isDiagnostics) {
+	if(isDiagnostics) {
+		command->setCommand(GENERATE_ONE_DIAGNOSTICS_REPORT);
+	}
+	else {
+		command->setCommand(GENERATE_ONE_PARAMETER_REPORT);
+	}
+
+	setSid(command, sid);
+}
+
+void HousekeepingMessage::setCollectionIntervalModificationCommand(
+		CommandMessage *command, sid_t sid, float collectionInterval,
+		bool isDiagnostics) {
+	if(isDiagnostics) {
+		command->setCommand(MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL);
+	}
+	else {
+		command->setCommand(MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL);
+	}
+	command->setParameter3(collectionInterval);
+
+	setSid(command, sid);
+}
+
+sid_t HousekeepingMessage::getCollectionIntervalModificationCommand(
+		const CommandMessage* command, float* newCollectionInterval) {
+	if(newCollectionInterval != nullptr) {
+		*newCollectionInterval = command->getParameter3();
+	}
+
+	return getSid(command);
+}
 
 sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 	sid_t sid;
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index ab8fd7ac1..81fa2f02d 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
-#define FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
@@ -49,9 +49,8 @@ public:
 	        sizeof(sid_t) + sizeof(uint32_t);
 
 	/**
-	 * The HK message is initialized with a pointer to a message which holds
-	 * the message data, see CommandMessageIF and getInternalMessage().
-	 * @param message
+	 * Concrete instance is not used, instead this class operates on
+	 * command message instances.
 	 */
 	HousekeepingMessage() = delete;
 	virtual ~HousekeepingMessage();
@@ -68,11 +67,6 @@ public:
 	static constexpr Command_t DISABLE_PERIODIC_DIAGNOSTICS_GENERATION =
 			MAKE_COMMAND_ID(8);
 
-	static constexpr Command_t REPORTING_TOGGLE_SUCCESS =
-			MAKE_COMMAND_ID(128);
-	static constexpr Command_t REPORTING_TOGGLE_FAILURE =
-			MAKE_COMMAND_ID(129);
-
 	static constexpr Command_t REPORT_HK_REPORT_STRUCTURES = MAKE_COMMAND_ID(9);
 	static constexpr Command_t REPORT_DIAGNOSTICS_REPORT_STRUCTURES =
 			MAKE_COMMAND_ID(11);
@@ -88,33 +82,48 @@ public:
 	static constexpr Command_t GENERATE_ONE_DIAGNOSTICS_REPORT =
 			MAKE_COMMAND_ID(28);
 
-	static constexpr Command_t APPEND_PARAMETERS_TO_PARAMETER_REPORT_STRUCTURE =
-			MAKE_COMMAND_ID(29);
-	static constexpr Command_t APPEND_PARAMETERS_TO_DIAGNOSTICS_REPORT_STRUCTURE =
-			MAKE_COMMAND_ID(30);
-
 	static constexpr Command_t MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(31);
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
+	static constexpr Command_t HK_REQUEST_SUCCESS =
+			MAKE_COMMAND_ID(128);
+	static constexpr Command_t HK_REQUEST_FAILURE =
+			MAKE_COMMAND_ID(129);
+
 	static sid_t getSid(const CommandMessage* message);
 
-	static void setToggleReportingMessage(CommandMessage* message, sid_t sid,
+	static void setToggleReportingCommand(CommandMessage* command, sid_t sid,
 			bool enableReporting, bool isDiagnostics);
-	static void setHkReportMessage(CommandMessage* message, sid_t sid,
+	static void setStructureReportingCommand(CommandMessage* command, sid_t sid,
+			bool isDiagnostics);
+	static void setOneShotReportCommand(CommandMessage* command, sid_t sid,
+			bool isDiagnostics);
+	static void setCollectionIntervalModificationCommand(
+			CommandMessage* command, sid_t sid, float collectionInterval,
+			bool isDiagnostics);
+
+	static void setHkReportReply(CommandMessage* reply, sid_t sid,
 			store_address_t storeId);
-	static void setHkDiagnosticsMessage(CommandMessage* message, sid_t sid,
+	static void setHkDiagnosticsReply(CommandMessage* reply, sid_t sid,
 			store_address_t storeId);
 
-	//! Get the respective SID and store ID. Command ID can be used beforehand
-	//! to distinguish between diagnostics and regular HK packets
-	static sid_t getHkReportMessage(const CommandMessage* message,
+	/**
+	 * @brief	Generic getter function for housekeeping data replies
+	 * @details
+	 * Command ID can be used beforehand to distinguish between diagnostics and
+	 * regular HK packets. This getter function should be used for the
+	 * command IDs 10, 12, 25 and 26.
+	 */
+	static sid_t getHkDataReply(const CommandMessage* message,
 			store_address_t * storeIdToSet);
+	static sid_t getCollectionIntervalModificationCommand(
+			const CommandMessage* command, float* newCollectionInterval);
 
 private:
 	static void setSid(CommandMessage* message, sid_t sid);
 };
 
 
-#endif /* FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_ */
+#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_ */

From e8de2fc47a1f1c6451ec5a7a6ec3767377289de7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Sep 2020 18:29:19 +0200
Subject: [PATCH 0758/1774] added srv3

---
 events/fwSubsystemIdRanges.h         |   1 +
 pus/Service17Test.h                  |   6 +-
 pus/Service3Housekeeping.cpp         | 262 +++++++++++++++++++++++++++
 pus/Service3Housekeeping.h           | 101 +++++++++++
 pus/servicepackets/Service3Packets.h |  21 +++
 5 files changed, 388 insertions(+), 3 deletions(-)
 create mode 100644 pus/Service3Housekeeping.cpp
 create mode 100644 pus/Service3Housekeeping.h
 create mode 100644 pus/servicepackets/Service3Packets.h

diff --git a/events/fwSubsystemIdRanges.h b/events/fwSubsystemIdRanges.h
index a05652c22..3c57c1606 100644
--- a/events/fwSubsystemIdRanges.h
+++ b/events/fwSubsystemIdRanges.h
@@ -19,6 +19,7 @@ enum {
 	SYSTEM_MANAGER_1 = 75,
 	SYSTEM_1 = 79,
 	PUS_SERVICE_1 = 80,
+	PUS_SERVICE_17 = 83,
 	FW_SUBSYSTEM_ID_RANGE
 };
 }
diff --git a/pus/Service17Test.h b/pus/Service17Test.h
index 8d6a43770..e26818659 100644
--- a/pus/Service17Test.h
+++ b/pus/Service17Test.h
@@ -1,5 +1,5 @@
-#ifndef MISSION_PUS_SERVICE17TEST_H_
-#define MISSION_PUS_SERVICE17TEST_H_
+#ifndef FSFW_PUS_SERVICE17TEST_H_
+#define FSFW_PUS_SERVICE17TEST_H_
 
 #include "../tmtcservices/PusServiceBase.h"
 #include "../objectmanager/SystemObject.h"
@@ -41,4 +41,4 @@ protected:
 	uint16_t packetSubCounter = 0;
 };
 
-#endif /* MISSION_PUS_SERVICE17TEST_H_ */
+#endif /* FSFW_PUS_SERVICE17TEST_H_ */
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
new file mode 100644
index 000000000..db77328ab
--- /dev/null
+++ b/pus/Service3Housekeeping.cpp
@@ -0,0 +1,262 @@
+#include "Service3Housekeeping.h"
+#include "servicepackets/Service3Packets.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+
+
+Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid,
+			uint8_t serviceId):
+		CommandingServiceBase(objectId, apid, serviceId,
+		NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {}
+
+Service3Housekeeping::~Service3Housekeeping() {}
+
+ReturnValue_t Service3Housekeeping::isValidSubservice(uint8_t subservice) {
+	switch(static_cast<Subservice>(subservice)) {
+	case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
+	case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
+	case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+	case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+	case Subservice::REPORT_HK_REPORT_STRUCTURES:
+	case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES :
+	case Subservice::GENERATE_ONE_PARAMETER_REPORT:
+	case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
+	case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
+	case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
+		return HasReturnvaluesIF::RETURN_OK;
+	// Telemetry or invalid subservice.
+	case Subservice::HK_DEFINITIONS_REPORT:
+	case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
+	case Subservice::HK_REPORT:
+	case Subservice::DIAGNOSTICS_REPORT:
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service3Housekeeping::getMessageQueueAndObject(uint8_t subservice,
+		const uint8_t *tcData, size_t tcDataLen,
+		MessageQueueId_t *id, object_id_t *objectId) {
+	return HasReturnvaluesIF::RETURN_OK;
+	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
+	if(result != RETURN_OK) {
+		return result;
+	}
+	return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t Service3Housekeeping::checkAndAcquireTargetID(
+		object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) {
+	if(SerializeAdapter::deSerialize(objectIdToSet, &tcData, &tcDataLen,
+	        SerializeIF::Endianness::BIG) != HasReturnvaluesIF::RETURN_OK) {
+		return CommandingServiceBase::INVALID_TC;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+	// check OwnsLocalDataPoolIF property of target
+	HasLocalDataPoolIF* possibleTarget =
+			objectManager->get<HasLocalDataPoolIF>(*objectId);
+	if(possibleTarget == nullptr){
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+	*messageQueueToSet = possibleTarget->getCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service3Housekeeping::prepareCommand(CommandMessage* message,
+		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+		uint32_t *state, object_id_t objectId) {
+	switch(static_cast<Subservice>(subservice)) {
+	case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
+		return prepareReportingTogglingCommand(message, true, false,
+				tcData, tcDataLen);
+	case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
+		return prepareReportingTogglingCommand(message, false, false,
+				tcData, tcDataLen);
+	case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+		return prepareReportingTogglingCommand(message, true, true,
+				tcData, tcDataLen);
+	case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+		return prepareReportingTogglingCommand(message, false, true,
+				tcData, tcDataLen);
+	case Subservice::REPORT_HK_REPORT_STRUCTURES:
+		return prepareStructureReportingCommand(message, false, tcData,
+				tcDataLen);
+	case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES:
+		return prepareStructureReportingCommand(message, true, tcData,
+				tcDataLen);
+	case Subservice::GENERATE_ONE_PARAMETER_REPORT:
+		return prepareOneShotReportCommand(message, false, tcData, tcDataLen);
+	case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
+		return prepareOneShotReportCommand(message, true, tcData, tcDataLen);
+	case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
+		return prepareCollectionIntervalModificationCommand(message, false,
+				tcData, tcDataLen);
+	case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
+		return prepareCollectionIntervalModificationCommand(message, true,
+				tcData, tcDataLen);
+	case Subservice::HK_DEFINITIONS_REPORT:
+	case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
+	case Subservice::HK_REPORT:
+	case Subservice::DIAGNOSTICS_REPORT:
+		// Those are telemetry packets.
+		return CommandingServiceBase::INVALID_TC;
+	default:
+		// should never happen, subservice was already checked.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
+		Command_t previousCommand, uint32_t *state,
+		CommandMessage* optionalNextCommand, object_id_t objectId,
+		bool *isStep) {
+	switch(reply->getCommand()) {
+	case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+	case(HousekeepingMessage::HK_REQUEST_FAILURE): {
+		failureParameter1 = objectId;
+		// also provide failure reason (returnvalue)
+		// will be most commonly invalid SID or the set already has the desired
+		// reporting status.
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+	default:
+		sif::error << "Service3Housekeeping::handleReply: Invalid reply!"
+				<< std::endl;
+		return CommandingServiceBase::INVALID_REPLY;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(
+		CommandMessage *command, bool enableReporting, bool isDiagnostics,
+		const uint8_t* tcData, size_t tcDataLen) {
+	if(tcDataLen < sizeof(sid_t)) {
+		// It is assumed the full SID is sent for now (even if that means
+		// 4 bytes are redundant)
+		return CommandingServiceBase::INVALID_TC;
+	}
+
+	sid_t targetSid;
+	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
+				SerializeIF::Endianness::BIG);
+
+	HousekeepingMessage::setToggleReportingCommand(command, targetSid,
+			enableReporting, isDiagnostics);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::prepareStructureReportingCommand(
+		CommandMessage *command, bool isDiagnostics, const uint8_t* tcData,
+		size_t tcDataLen) {
+	if(tcDataLen < sizeof(sid_t)) {
+		// It is assumed the full SID is sent for now (even if that means
+		// 4 bytes are redundant)
+		return CommandingServiceBase::INVALID_TC;
+	}
+
+	sid_t targetSid;
+	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+
+	HousekeepingMessage::setStructureReportingCommand(command, targetSid,
+			isDiagnostics);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::prepareOneShotReportCommand(
+		CommandMessage *command, bool isDiagnostics, const uint8_t *tcData,
+		size_t tcDataLen) {
+	if(tcDataLen < sizeof(sid_t)) {
+		// It is assumed the full SID is sent for now (even if that means
+		// 4 bytes are redundant)
+		return CommandingServiceBase::INVALID_TC;
+	}
+
+	sid_t targetSid;
+	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	HousekeepingMessage::setOneShotReportCommand(command, targetSid,
+			isDiagnostics);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand(
+		CommandMessage *command, bool isDiagnostics, const uint8_t *tcData,
+		size_t tcDataLen) {
+	if(tcDataLen < sizeof(sid_t) + sizeof(float)) {
+		// It is assumed the full SID and the new collection interval as a float
+		// is sent for now (even if that means 4 bytes are redundant)
+		return CommandingServiceBase::INVALID_TC;
+	}
+
+	sid_t targetSid;
+	float newCollectionInterval = 0;
+	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	HousekeepingMessage::setCollectionIntervalModificationCommand(command,
+			targetSid, newCollectionInterval, isDiagnostics);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Service3Housekeeping::handleUnrequestedReply(
+        CommandMessage* reply) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    switch(reply->getCommand()) {
+    case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
+    	result = generateHkReport(reply,
+    			static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
+    	break;
+    }
+    case(HousekeepingMessage::HK_REPORT): {
+        result = generateHkReport(reply,
+        		static_cast<uint8_t>(Subservice::HK_REPORT));
+        break;
+    }
+    default: {
+        sif::error << "Service3Housekeeping::handleUnrequestedReply: "
+                << "Invalid reply!" << std::endl;
+    }
+    }
+
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		// Configuration error
+		sif::debug << "Service3Housekeeping::handleUnrequestedReply:"
+				<< "Could not generate reply!" << std::endl;
+	}
+}
+
+MessageQueueId_t Service3Housekeeping::getHkQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t Service3Housekeeping::generateHkReport(
+		const CommandMessage* hkMessage, uint8_t subserviceId) {
+	store_address_t storeId;
+
+	sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId);
+	auto resultPair = IPCStore->getData(storeId);
+	if(resultPair.first != HasReturnvaluesIF::RETURN_OK) {
+		return resultPair.first;
+	}
+
+	HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size());
+	return sendTmPacket(static_cast<uint8_t>(subserviceId),
+			hkPacket.hkData, hkPacket.hkSize, nullptr, 0);
+}
diff --git a/pus/Service3Housekeeping.h b/pus/Service3Housekeeping.h
new file mode 100644
index 000000000..6c5d24699
--- /dev/null
+++ b/pus/Service3Housekeeping.h
@@ -0,0 +1,101 @@
+#ifndef FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_
+#define FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_
+
+#include "../housekeeping/AcceptsHkPacketsIF.h"
+#include "../housekeeping/HousekeepingMessage.h"
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief   Manges spacecraft housekeeping reports and
+ *          sends pool variables (temperature, GPS data ...) to ground.
+ *
+ * @details Full Documentation: ECSS-E70-41A or ECSS-E-ST-70-41C.
+ * Implementation based on PUS-C
+ *
+ * The housekeeping service type provides means to control and adapt the
+ * spacecraft reporting plan according to the mission phases.
+ * The housekeeping service type provides the visibility of any
+ * on-board parameters assembled in housekeeping parameter report structures
+ * or diagnostic parameter report structures as required for the mission.
+ * The parameter report structures used by the housekeeping service can
+ * be predefined on-board or created when needed.
+ *
+ * @author 	R. Mueller
+ * @ingroup pus_services
+ */
+class Service3Housekeeping: public CommandingServiceBase,
+		public AcceptsHkPacketsIF {
+public:
+	static constexpr uint8_t NUM_OF_PARALLEL_COMMANDS = 4;
+	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+
+	Service3Housekeeping(object_id_t objectId, uint16_t apid, uint8_t serviceId);
+	virtual~ Service3Housekeeping();
+protected:
+	/* CSB abstract functions implementation . See CSB documentation. */
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) override;
+
+	virtual MessageQueueId_t getHkQueue() const;
+private:
+	enum class Subservice {
+		ENABLE_PERIODIC_HK_REPORT_GENERATION = 5, //!< [EXPORT] : [TC]
+		DISABLE_PERIODIC_HK_REPORT_GENERATION = 6, //!< [EXPORT] : [TC]
+
+		ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION = 7, //!< [EXPORT] : [TC]
+		DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION = 8, //!< [EXPORT] : [TC]
+
+		//! [EXPORT] : [TC] Report HK structure by supplying SID
+		REPORT_HK_REPORT_STRUCTURES = 9,
+		//! [EXPORT] : [TC] Report Diagnostics structure by supplying SID
+		REPORT_DIAGNOSTICS_REPORT_STRUCTURES = 11,
+
+		//! [EXPORT] : [TM] Report corresponding to Subservice 9 TC
+		HK_DEFINITIONS_REPORT = 10,
+		//! [EXPORT] : [TM] Report corresponding to Subservice 11 TC
+		DIAGNOSTICS_DEFINITION_REPORT = 12,
+
+		//! [EXPORT] : [TM] Core packet. Contains Housekeeping data
+		HK_REPORT = 25,
+		//! [EXPORT] : [TM] Core packet. Contains diagnostics data
+		DIAGNOSTICS_REPORT = 26,
+
+		/* PUS-C */
+		GENERATE_ONE_PARAMETER_REPORT = 27, //!< [EXPORT] : [TC]
+		GENERATE_ONE_DIAGNOSTICS_REPORT = 28, //!< [EXPORT] : [TC]
+
+		MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL = 31, //!< [EXPORT] : [TC]
+		MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL = 32, //!< [EXPORT] : [TC]
+	};
+
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+			MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
+
+	ReturnValue_t generateHkReport(const CommandMessage* hkMessage,
+			uint8_t subserviceId);
+	ReturnValue_t prepareReportingTogglingCommand(CommandMessage* command,
+			bool enableReporting, bool isDiagnostics, const uint8_t* tcData,
+			size_t tcDataLen);
+	ReturnValue_t prepareStructureReportingCommand(CommandMessage* command,
+			bool isDiagnostics, const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t prepareOneShotReportCommand(CommandMessage* command,
+			bool isDiagnostics, const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t prepareCollectionIntervalModificationCommand(
+			CommandMessage* command, bool isDiagnostics, const uint8_t* tcData,
+			size_t tcDataLen);
+
+	void handleUnrequestedReply(CommandMessage* reply) override;
+};
+
+#endif /* FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_ */
diff --git a/pus/servicepackets/Service3Packets.h b/pus/servicepackets/Service3Packets.h
new file mode 100644
index 000000000..05732e11b
--- /dev/null
+++ b/pus/servicepackets/Service3Packets.h
@@ -0,0 +1,21 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE3PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE3PACKETS_H_
+
+#include <fsfw/housekeeping/HousekeepingMessage.h>
+#include <cstdint>
+
+/**
+ * @brief Subservices 25 and 26: TM packets
+ * @ingroup spacepackets
+ */
+class HkPacket { //!< [EXPORT] : [SUBSERVICE] 25, 26
+public:
+    sid_t sid; //!< [EXPORT] : [COMMENT] Structure ID (SID) of housekeeping data.
+    const uint8_t* hkData; //!< [EXPORT] : [MAXSIZE] Deduced size
+    size_t hkSize; //!< [EXPORT] : [IGNORE]
+
+    HkPacket(sid_t sid, const uint8_t* data, size_t size):
+            sid(sid), hkData(data), hkSize(size) {}
+};
+
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE3PACKETS_H_ */

From e707c5e05117b9734f50f4a144987ec51b4dfb65 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 15:58:12 +0200
Subject: [PATCH 0759/1774] fixes taken over

---
 ipc/CommandMessage.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index ca7b817f1..8f5daa044 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -8,7 +8,7 @@
 /**
  * @brief 	Default command message used to pass command messages between tasks.
  * 			Primary message type for IPC. Contains sender, 2-byte command ID
- * 			field, and 2 4-byte parameters.
+ * 			field, and 3 4-byte parameter
  * @details
  * It operates on an external memory which is contained inside a
  * class implementing MessageQueueMessageIF by taking its address.
@@ -23,10 +23,11 @@
 class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
 public:
     /**
-     * Default size can accomodate 2 4-byte parameters.
+     * Default size can accomodate 3 4-byte parameters.
      */
     static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
-            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
+            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE +
+			3 * sizeof(uint32_t);
 
 	/**
 	 * @brief   Default Constructor, does not initialize anything.

From ad98a63e87602790de874b7fa336a2d04d012a1a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 16:02:58 +0200
Subject: [PATCH 0760/1774] changes taken over from upstream master

---
 serialize/SerializeIF.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index a701fe53f..d72218f0a 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -2,7 +2,7 @@
 #define FSFW_SERIALIZE_SERIALIZEIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <stddef.h>
+#include <cstddef>
 
 /**
  * @defgroup serialize Serialization
@@ -10,7 +10,10 @@
  */
 
 /**
- * Translation of objects into data streams and from data streams.
+ * @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 {

From 15891b3cf08b585a9e177447d0d15a5ba7490705 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 16:42:17 +0200
Subject: [PATCH 0761/1774] fixed some message queue includes

---
 action/ActionHelper.cpp                 |  1 +
 action/SimpleActionHelper.cpp           |  1 +
 devicehandlers/CommunicationMessage.cpp |  4 ++--
 health/HealthHelper.cpp                 |  4 ++--
 ipc/MessageQueueIF.h                    | 14 ++++++++------
 ipc/MessageQueueMessage.h               |  1 -
 ipc/MessageQueueMessageIF.h             | 17 +++--------------
 ipc/MessageQueueSenderIF.h              |  3 ++-
 ipc/QueueFactory.h                      |  2 ++
 ipc/messageQueueDefintions.h            | 18 ++++++++++++++++++
 modes/ModeHelper.cpp                    |  9 +++++----
 osal/FreeRTOS/MessageQueue.cpp          |  8 ++++----
 osal/FreeRTOS/MessageQueue.h            |  5 +++--
 osal/FreeRTOS/QueueFactory.cpp          |  1 +
 14 files changed, 52 insertions(+), 36 deletions(-)
 create mode 100644 ipc/messageQueueDefintions.h

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index b43c676d0..70c3f0fca 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/ipc/MessageQueueSenderIF.h>
 #include "ActionHelper.h"
 #include "HasActionsIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index d79a3c977..51e3fa1c2 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -1,5 +1,6 @@
 #include "HasActionsIF.h"
 #include "SimpleActionHelper.h"
+
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
 		MessageQueueIF* useThisQueue) :
 		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index abdfd3a86..577742709 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -122,7 +122,7 @@ uint32_t CommunicationMessage::getUint32Data() const{
 }
 
 void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
-	if(0 <= position && position <= 3) {
+	if(position <= 3) {
 		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte));
 	}
 	else {
@@ -131,7 +131,7 @@ void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
 }
 
 uint8_t CommunicationMessage::getDataByte(uint8_t position) const {
-	if(0 <= position && position <= 3) {
+	if(position <= 3) {
 		uint8_t byte;
 		memcpy(&byte, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), sizeof(byte));
 		return byte;
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index cced11d9b..d574634d8 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -71,7 +71,7 @@ void HealthHelper::setHealth(HasHealthIF::HealthState health) {
 
 void HealthHelper::informParent(HasHealthIF::HealthState health,
 		HasHealthIF::HealthState oldHealth) {
-	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
+	if (parentQueue == MessageQueueIF::NO_QUEUE) {
 		return;
 	}
 	CommandMessage information;
@@ -86,7 +86,7 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 
 void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
 	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
-	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
+	if (command->getSender() == MessageQueueIF::NO_QUEUE) {
 		return;
 	}
 	CommandMessage reply;
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 96bd379f9..e9a4a00bf 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -1,21 +1,23 @@
 #ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
 #define FSFW_IPC_MESSAGEQUEUEIF_H_
 
+#include "MessageQueueMessageIF.h"
+#include "messageQueueDefintions.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+#include <cstdint>
+
+
 // COULDDO: We could support blocking calls
 // semaphores are being implemented, which makes this idea even more iteresting.
 
-
 /**
  * @defgroup message_queue Message Queue
  * @brief Message Queue related software components
  */
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../ipc/MessageQueueSenderIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
 class MessageQueueIF {
 public:
-	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
+	static const MessageQueueId_t NO_QUEUE = 0;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
 	//! No new messages on the queue
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index f68e9b9f9..5234f64ff 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -2,7 +2,6 @@
 #define FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
 
 #include "../ipc/MessageQueueMessageIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
 #include <cstddef>
 
 /**
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 91753ced9..daf7e8bb2 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -1,24 +1,13 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
+
+#include "messageQueueDefintions.h"
 #include <cstddef>
 #include <cstdint>
 
-/*
- * TODO: Actually, the definition of this ID to be a uint32_t is not  ideal and
- * breaks layering. However, it is difficult to keep layering, as the ID is
- * stored in many places and sent around in MessageQueueMessage.
- * Ideally, one would use the (current) object_id_t only, however, doing a
- * lookup of queueIDs for every call does not sound ideal.
- * In a first step, I'll circumvent the issue by not touching it,
- * maybe in a second step. This also influences Interface design
- * (getCommandQueue) and some other issues..
- */
-
-typedef uint32_t MessageQueueId_t;
-
 class MessageQueueMessageIF {
 public:
-	static const MessageQueueId_t NO_QUEUE = -1;
+
     /**
      * @brief   This constants defines the size of the header,
      *          which is added to every message.
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index b967bbdf5..beb27f507 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
 
+#include "../ipc/MessageQueueIF.h"
 #include "../ipc/MessageQueueMessageIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
@@ -15,7 +16,7 @@ public:
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
+			MessageQueueId_t sentFrom = MessageQueueIF::NO_QUEUE,
 			bool ignoreFault = false);
 private:
 	MessageQueueSenderIF() {}
diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index be5544061..5fbfdf2d1 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -2,7 +2,9 @@
 #define FRAMEWORK_IPC_QUEUEFACTORY_H_
 
 #include "MessageQueueIF.h"
+#include "MessageQueueMessage.h"
 #include <cstdint>
+
 /**
  * Creates message queues.
  * This class is a "singleton" interface, i.e. it provides an
diff --git a/ipc/messageQueueDefintions.h b/ipc/messageQueueDefintions.h
new file mode 100644
index 000000000..3d625de14
--- /dev/null
+++ b/ipc/messageQueueDefintions.h
@@ -0,0 +1,18 @@
+#ifndef FSFW_IPC_MESSAGEQUEUEDEFINTIONS_H_
+#define FSFW_IPC_MESSAGEQUEUEDEFINTIONS_H_
+
+#include <cstdint>
+
+/*
+ * TODO: Actually, the definition of this ID to be a uint32_t is not  ideal and
+ * breaks layering. However, it is difficult to keep layering, as the ID is
+ * stored in many places and sent around in MessageQueueMessage.
+ * Ideally, one would use the (current) object_id_t only, however, doing a
+ * lookup of queueIDs for every call does not sound ideal.
+ * In a first step, I'll circumvent the issue by not touching it,
+ * maybe in a second step. This also influences Interface design
+ * (getCommandQueue) and some other issues..
+ */
+using MessageQueueId_t = uint32_t;
+
+#endif /* FSFW_IPC_MESSAGEQUEUEDEFINTIONS_H_ */
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index e7fc0bcb4..68f009e7b 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,3 +1,4 @@
+#include "../ipc/MessageQueueSenderIF.h"
 #include "../modes/HasModesIF.h"
 #include "../modes/ModeHelper.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
@@ -35,7 +36,7 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 		commandedMode = mode;
 		commandedSubmode = submode;
 
-		if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
+		if ((parentQueueId != MessageQueueIF::NO_QUEUE)
 				&& (theOneWhoCommandedAMode != parentQueueId)) {
 			owner->setToExternalControl();
 		}
@@ -73,13 +74,13 @@ void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
 	forced = false;
 	sendModeReplyMessage(ownerMode, ownerSubmode);
 	sendModeInfoMessage(ownerMode, ownerSubmode);
-	theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
+	theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
 }
 
 void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 		Submode_t ownerSubmode) {
 	CommandMessage reply;
-	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
+	if (theOneWhoCommandedAMode != MessageQueueIF::NO_QUEUE)
 	{
 		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
 		{
@@ -101,7 +102,7 @@ void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
 		Submode_t ownerSubmode) {
 	CommandMessage reply;
 	if (theOneWhoCommandedAMode != parentQueueId
-			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
+			and parentQueueId != MessageQueueIF::NO_QUEUE)
 	{
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
 				ownerMode, ownerSubmode);
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index e3e0ef1c1..2dfe5ab65 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -1,5 +1,5 @@
 #include "MessageQueue.h"
-
+#include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 // TODO I guess we should have a way of checking if we are in an ISR and then
@@ -40,7 +40,7 @@ ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != MessageQueueMessageIF::NO_QUEUE) {
+	if (this->lastPartner != MessageQueueIF::NO_QUEUE) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
 		return NO_REPLY_PARTNER;
@@ -58,8 +58,8 @@ ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
 	if (result != pdPASS) {
 		if (not ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter =
-					objectManager->get<InternalErrorReporterIF>(
+			InternalErrorReporterIF* internalErrorReporter = objectManager->
+					get<InternalErrorReporterIF>(
 					objects::INTERNAL_ERROR_REPORTER);
 			if (internalErrorReporter != nullptr) {
 				internalErrorReporter->queueMessageNotSent();
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index e953ec34b..b99bf7c8d 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -8,6 +8,7 @@
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/queue.h>
+#include <fsfw/ipc/MessageQueueMessage.h>
 
 // TODO: this class assumes that MessageQueueId_t is the same size as void*
 // (the FreeRTOS handle type), compiler will catch this but it might be nice
@@ -139,8 +140,8 @@ protected:
 private:
 	bool defaultDestinationSet = false;
 	QueueHandle_t handle;
-	MessageQueueId_t defaultDestination = 0;
-	MessageQueueId_t lastPartner = 0;
+	MessageQueueId_t defaultDestination = MessageQueueIF::NO_QUEUE;
+	MessageQueueId_t lastPartner = MessageQueueIF::NO_QUEUE;
 	const size_t maxMessageSize;
 	//! Stores the current system context
 	CallContext callContext =  CallContext::TASK;
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index cd99afd98..5b3c73dca 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -1,3 +1,4 @@
+#include "../../ipc/MessageQueueSenderIF.h"
 #include "../../ipc/QueueFactory.h"
 
 #include "../../osal/FreeRTOS/MessageQueue.h"

From 850a4a3e3deddf8a13a9ee52e53262a8e0c7fe41 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 16:44:48 +0200
Subject: [PATCH 0762/1774] header file renamed

---
 ipc/MessageQueueIF.h                                        | 2 +-
 ipc/MessageQueueMessageIF.h                                 | 2 +-
 ipc/{messageQueueDefintions.h => messageQueueDefinitions.h} | 6 +++---
 3 files changed, 5 insertions(+), 5 deletions(-)
 rename ipc/{messageQueueDefintions.h => messageQueueDefinitions.h} (79%)

diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index e9a4a00bf..44b6f4c00 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
 #define FSFW_IPC_MESSAGEQUEUEIF_H_
 
+#include <fsfw/ipc/messageQueueDefinitions.h>
 #include "MessageQueueMessageIF.h"
-#include "messageQueueDefintions.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 
 #include <cstdint>
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index daf7e8bb2..b5a30c086 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 
-#include "messageQueueDefintions.h"
+#include <fsfw/ipc/messageQueueDefinitions.h>
 #include <cstddef>
 #include <cstdint>
 
diff --git a/ipc/messageQueueDefintions.h b/ipc/messageQueueDefinitions.h
similarity index 79%
rename from ipc/messageQueueDefintions.h
rename to ipc/messageQueueDefinitions.h
index 3d625de14..d30e69849 100644
--- a/ipc/messageQueueDefintions.h
+++ b/ipc/messageQueueDefinitions.h
@@ -1,5 +1,5 @@
-#ifndef FSFW_IPC_MESSAGEQUEUEDEFINTIONS_H_
-#define FSFW_IPC_MESSAGEQUEUEDEFINTIONS_H_
+#ifndef FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
+#define FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
 
 #include <cstdint>
 
@@ -15,4 +15,4 @@
  */
 using MessageQueueId_t = uint32_t;
 
-#endif /* FSFW_IPC_MESSAGEQUEUEDEFINTIONS_H_ */
+#endif /* FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ */

From b8ad17639ceb8b773175749608477d8ff970521c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 17:02:31 +0200
Subject: [PATCH 0763/1774] include guard fix

---
 ipc/MessageQueueSenderIF.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index beb27f507..d8ede535e 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
+#ifndef FSFW_IPC_MESSAGEQUEUESENDERIF_H_
+#define FSFWw_IPC_MESSAGEQUEUESENDERIF_H_
 
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MessageQueueMessageIF.h"
@@ -23,4 +23,4 @@ private:
 };
 
 
-#endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */
+#endif /* FSFW_IPC_MESSAGEQUEUESENDERIF_H_ */

From 7643af8607ad9b1ccb27f9bd120a324869807134 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 17:15:22 +0200
Subject: [PATCH 0764/1774] include guard fix

---
 ipc/MessageQueueSenderIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index d8ede535e..42d4078fe 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,5 +1,5 @@
 #ifndef FSFW_IPC_MESSAGEQUEUESENDERIF_H_
-#define FSFWw_IPC_MESSAGEQUEUESENDERIF_H_
+#define FSFW_IPC_MESSAGEQUEUESENDERIF_H_
 
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MessageQueueMessageIF.h"

From 347d591deff649540ff9dbeee1115c2803c060c3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 17:33:21 +0200
Subject: [PATCH 0765/1774] uses new define and config file now

---
 events/Event.h          | 2 +-
 events/EventManager.cpp | 4 ++--
 events/EventManager.h   | 6 ++++--
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/events/Event.h b/events/Event.h
index e22c9db16..f8410f328 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include "fwSubsystemIdRanges.h"
 //could be move to more suitable location
-#include <config/tmtc/subsystemIdRanges.h>
+#include <subsystemIdRanges.h>
 
 typedef uint16_t EventId_t;
 typedef uint8_t EventSeverity_t;
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index e71951e36..0971dadc8 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -109,13 +109,13 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 	return result;
 }
 
-#ifdef DEBUG
+#if FSFW_DEBUG_OUTPUT == 1
 
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
 	switch (message->getSeverity()) {
 	case SEVERITY::INFO:
-#ifdef DEBUG_INFO_EVENT
+#if DEBUG_INFO_EVENT == 1
 		string = translateObject(message->getReporter());
 		sif::info << "EVENT: ";
 		if (string != 0) {
diff --git a/events/EventManager.h b/events/EventManager.h
index 2602aeb23..f03c02415 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -8,9 +8,11 @@
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MutexIF.h"
+#include <FSFWConfig.h>
+
 #include <map>
 
-#ifdef DEBUG
+#if FSFW_DEBUG_OUTPUT == 1
 // forward declaration, should be implemented by mission
 extern const char* translateObject(object_id_t object);
 extern const char* translateEvents(Event event);
@@ -55,7 +57,7 @@ protected:
 
 	void notifyListeners(EventMessage *message);
 
-#ifdef DEBUG
+#if FSFW_DEBUG_OUTPUT == 1
 	void printEvent(EventMessage *message);
 #endif
 

From 0d5724e3d416f837348b764cde3f7f732c2c5af6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 17:34:07 +0200
Subject: [PATCH 0766/1774] include improvements taken over

---
 timemanager/CCSDSTime.cpp | 9 +++------
 timemanager/CCSDSTime.h   | 4 ++--
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 12ecf34af..f99f8fbb4 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,11 +1,8 @@
 #include "../timemanager/CCSDSTime.h"
-#include <stdio.h>
-#include <inttypes.h>
-#include <math.h>
+#include <cstdio>
+#include <cinttypes>
+#include <cmath>
 
-#ifndef SCNu8
-  #define SCNu8 "hhu"
-#endif
 
 CCSDSTime::CCSDSTime() {
 }
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index b9efa49cb..89fcff92f 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -3,9 +3,9 @@
 
 // COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
 
-#include "../timemanager/Clock.h"
+#include "Clock.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
+#include <cstdint>
 
 bool operator<(const timeval& lhs, const timeval& rhs);
 bool operator<=(const timeval& lhs, const timeval& rhs);

From e5dac30e98f694ad92ea82cc8c15ff7bfc7bd8b2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 17:37:43 +0200
Subject: [PATCH 0767/1774] new include used now

---
 timemanager/CCSDSTime.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index f99f8fbb4..80a4e27c4 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,4 +1,5 @@
 #include "../timemanager/CCSDSTime.h"
+#include <FSFWConfig.h>
 #include <cstdio>
 #include <cinttypes>
 #include <cmath>
@@ -158,7 +159,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	}
 // Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
 // Suggestion: use uint16 all the time. This should work on all systems.
-#ifdef NEWLIB_NANO_NO_C99_IO
+#if FSFW_NEWLIB_NANO_NO_C99_IO == 1
 	uint16_t year;
 	uint16_t month;
 	uint16_t day;

From 6ef5e3e5501e5d925160306f25e39c3e1cfbb312 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 16 Sep 2020 21:22:53 +0200
Subject: [PATCH 0768/1774] queue factory host OS fix

---
 osal/host/QueueFactory.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
index da3fea55a..7feb1ad67 100644
--- a/osal/host/QueueFactory.cpp
+++ b/osal/host/QueueFactory.cpp
@@ -1,5 +1,6 @@
+#include "MessageQueue.h"
 #include "../../ipc/QueueFactory.h"
-#include "../../osal/host/MessageQueue.h"
+#include "../../ipc/MessageQueueSenderIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include <cstring>
 

From 0c6514a682a03e4dc74e5b7878960b0af8bf34f3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 17 Sep 2020 22:31:28 +0200
Subject: [PATCH 0769/1774] clock uses getUptime again

---
 osal/linux/Clock.cpp      | 27 +++++++++------------------
 timemanager/Stopwatch.cpp | 11 +++++++----
 timemanager/Stopwatch.h   |  2 +-
 3 files changed, 17 insertions(+), 23 deletions(-)

diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 5f764a6fc..b3b09923b 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -75,24 +75,15 @@ timeval Clock::getUptime() {
 }
 
 ReturnValue_t Clock::getUptime(timeval* uptime) {
-	//TODO This is not posix compatible and delivers only seconds precision
-	struct sysinfo sysInfo;
-	int result = sysinfo(&sysInfo);
-	if(result != 0){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	uptime->tv_sec = sysInfo.uptime;
-	uptime->tv_usec = 0;
-
-
-	//Linux specific file read but more precise
-//	double uptimeSeconds;
-//	if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
-//		uptime->tv_sec = uptimeSeconds;
-//		uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
-//	}
-
-	return HasReturnvaluesIF::RETURN_OK;
+    //TODO This is not posix compatible and delivers only seconds precision
+    // is the OS not called Linux?
+    //Linux specific file read but more precise
+    double uptimeSeconds;
+    if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
+        uptime->tv_sec = uptimeSeconds;
+        uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 28ae45437..2cd31969b 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -6,15 +6,18 @@ Stopwatch::Stopwatch(bool displayOnDestruction,
         StopwatchDisplayMode displayMode): displayOnDestruction(
         displayOnDestruction), displayMode(displayMode) {
     // Measures start time on initialization.
-    Clock::getClock_timeval(&startTime);
+    Clock::getUptime(&startTime);
 }
 
 void Stopwatch::start() {
-    Clock::getClock_timeval(&startTime);
+    Clock::getUptime(&startTime);
 }
 
-dur_millis_t Stopwatch::stop() {
+dur_millis_t Stopwatch::stop(bool display) {
     stopInternal();
+    if(display) {
+        this->display();
+    }
     return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
 }
 
@@ -52,6 +55,6 @@ StopwatchDisplayMode Stopwatch::getDisplayMode() const {
 
 void Stopwatch::stopInternal() {
 	timeval endTime;
-	Clock::getClock_timeval(&endTime);
+	Clock::getUptime(&endTime);
     elapsedTime = endTime - startTime;
 }
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 49b686f9e..093f5c9ea 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -40,7 +40,7 @@ public:
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in milliseconds (rounded)
      */
-    dur_millis_t stop();
+    dur_millis_t stop(bool display = false);
     /**
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in seconds (double precision)

From 37f4cc46447906295f11e9e368e32e010eedecad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 12:28:29 +0200
Subject: [PATCH 0770/1774] taken over stopwatch changes

---
 timemanager/Stopwatch.h | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 093f5c9ea..ea72c66e0 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -1,6 +1,7 @@
-#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
-#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
-#include "../timemanager/Clock.h"
+#ifndef FSFW_TIMEMANAGER_STOPWATCH_H_
+#define FSFW_TIMEMANAGER_STOPWATCH_H_
+
+#include "Clock.h"
 
 enum class StopwatchDisplayMode {
     MILLIS,
@@ -66,6 +67,4 @@ private:
 };
 
 
-
-
-#endif /* FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ */
+#endif /* FSFW_TIMEMANAGER_STOPWATCH_H_ */

From e0b2e0b00a578f59ac692c57d1d3b2bc1ea4528c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 12:31:11 +0200
Subject: [PATCH 0771/1774] fxed linux message queues

---
 osal/linux/MessageQueue.cpp | 4 +++-
 osal/linux/MessageQueue.h   | 6 +++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 872517241..cfadb7931 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,5 +1,6 @@
+#include "MessageQueue.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/MessageQueue.h"
+#include "../../objectmanager/ObjectManagerIF.h"
 
 #include <fstream>
 
@@ -9,6 +10,7 @@
 #include <errno.h>
 
 
+
 MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
 		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
 		defaultDestination(MessageQueueIF::NO_QUEUE),
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index c0b770192..239bbbdb5 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -1,5 +1,5 @@
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
+#ifndef FSFW_OSAL_LINUX_MESSAGEQUEUE_H_
+#define FSFW_OSAL_LINUX_MESSAGEQUEUE_H_
 
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueIF.h"
@@ -184,4 +184,4 @@ private:
 	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
 };
 
-#endif /* MESSAGEQUEUE_H_ */
+#endif /* FSFW_OSAL_LINUX_MESSAGEQUEUE_H_ */

From 19632b8fb1cf4cdedf13795ee5ecaa6158f91f10 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 12:36:36 +0200
Subject: [PATCH 0772/1774] linux fixes

---
 ipc/QueueFactory.h          |  6 +++---
 osal/linux/Clock.cpp        |  2 +-
 osal/linux/QueueFactory.cpp | 10 ++++++++--
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index 5fbfdf2d1..9853d2562 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
-#define FRAMEWORK_IPC_QUEUEFACTORY_H_
+#ifndef FSFW_IPC_QUEUEFACTORY_H_
+#define FSFW_IPC_QUEUEFACTORY_H_
 
 #include "MessageQueueIF.h"
 #include "MessageQueueMessage.h"
@@ -32,4 +32,4 @@ private:
 	static QueueFactory* factoryInstance;
 };
 
-#endif /* FRAMEWORK_IPC_QUEUEFACTORY_H_ */
+#endif /* FSFW_IPC_QUEUEFACTORY_H_ */
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index b3b09923b..6f2faedb2 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -6,8 +6,8 @@
 #include <linux/sysinfo.h>
 #include <time.h>
 #include <unistd.h>
+#include <fstream>
 
-//#include <fstream>
 uint16_t Clock::leapSeconds = 0;
 MutexIF* Clock::timeMutex = NULL;
 
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index fb8f6df7d..44def48a5 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -1,8 +1,14 @@
 #include "../../ipc/QueueFactory.h"
+#include "MessageQueue.h"
+
+#include "../../ipc/messageQueueDefinitions.h"
+#include "../../ipc/MessageQueueSenderIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
 #include <mqueue.h>
 #include <errno.h>
-#include "../../osal/linux/MessageQueue.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+
 #include <cstring>
 
 QueueFactory* QueueFactory::factoryInstance = nullptr;

From e70e9e3f1f67e007245ab457c1e2f685d5450697 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 12:57:30 +0200
Subject: [PATCH 0773/1774] added uptime seconds functions

---
 osal/FreeRTOS/Clock.cpp |  7 +++++++
 osal/host/Clock.cpp     |  5 +++++
 osal/linux/Clock.cpp    | 14 ++++++++++++--
 timemanager/Clock.h     |  2 ++
 4 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index d556444c4..42f060b45 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -67,6 +67,13 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+uint32_t Clock::getUptimeSeconds() {
+	timeval uptime = getUptime();
+	return uptime.tv_sec;
+}
+
+
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 	timeval time_timeval;
 	ReturnValue_t result = getClock_timeval(&time_timeval);
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 41321eeb5..17d98ba88 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -106,6 +106,11 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+uint32_t Clock::getUptimeSeconds() {
+	timeval uptime = getUptime();
+	return uptime.tv_sec;
+}
+
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 	// do some magic with chrono (C++20!)
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 6f2faedb2..468fcb80f 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/timemanager/Stopwatch.h>
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../timemanager/Clock.h"
 
@@ -76,8 +77,7 @@ timeval Clock::getUptime() {
 
 ReturnValue_t Clock::getUptime(timeval* uptime) {
     //TODO This is not posix compatible and delivers only seconds precision
-    // is the OS not called Linux?
-    //Linux specific file read but more precise
+    // Linux specific file read but more precise.
     double uptimeSeconds;
     if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
         uptime->tv_sec = uptimeSeconds;
@@ -86,6 +86,16 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
     return HasReturnvaluesIF::RETURN_OK;
 }
 
+uint32_t Clock::getUptimeSeconds() {
+	//TODO This is not posix compatible and delivers only seconds precision
+	struct sysinfo sysInfo;
+	int result = sysinfo(&sysInfo);
+	if(result != 0){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return sysInfo.uptime;
+}
+
 ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 	timeval uptime;
 	ReturnValue_t result = getUptime(&uptime);
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index acb68e2ec..1ad883055 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -67,6 +67,8 @@ public:
 
 	static timeval getUptime();
 
+	static uint32_t getUptimeSeconds();
+
 	/**
 	 * Get the time since boot in milliseconds
 	 *

From 7b0ddb3941729647276cdfe0218d0727d2f6e343 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:09:23 +0200
Subject: [PATCH 0774/1774] quick fix DHB

---
 devicehandlers/DeviceHandlerBase.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 86fd01b1d..1f76fc4fe 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1275,10 +1275,14 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
+			//so we can track misconfigurations
 			sif::debug << std::hex << getObjectId()
 					<< ": DHB::buildInternalCommand: Command "
-					<< deviceCommandId << " isExecuting" << std::endl; //so we can track misconfigurations
-			return; //this is an internal command, no need to report a failure here, missed reply will track if a reply is too late, otherwise, it's ok
+					<< deviceCommandId << " isExecuting" << std::dec
+					<< std::endl;
+			// this is an internal command, no need to report a failure here,
+			// missed reply will track if a reply is too late, otherwise, it's ok
+			return;
 		} else {
 			iter->second.sendReplyTo = NO_COMMANDER;
 			iter->second.isExecuting = true;

From 57c88059e5be68191b25dac2f179df237b125df2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:12:07 +0200
Subject: [PATCH 0775/1774] DHB small improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 16 ++++++++--------
 devicehandlers/DeviceHandlerBase.h   | 15 ++++++++-------
 2 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1f76fc4fe..0a3aec6da 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,18 +1,18 @@
-#include "../devicehandlers/DeviceHandlerBase.h"
+#include "DeviceHandlerBase.h"
+#include "AcceptsDeviceResponsesIF.h"
+#include "DeviceTmReportingWrapper.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
-#include "../devicehandlers/AcceptsDeviceResponsesIF.h"
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../devicehandlers/DeviceTmReportingWrapper.h"
 #include "../globalfunctions/CRC.h"
 #include "../housekeeping/HousekeepingMessage.h"
 #include "../ipc/MessageQueueMessage.h"
-#include "../subsystem/SubsystemBase.h"
 #include "../ipc/QueueFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../subsystem/SubsystemBase.h"
 
 #include <iomanip>
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index c3748172d..752f73521 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,25 +1,26 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
-#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+
+#include "DeviceHandlerIF.h"
+#include "DeviceCommunicationIF.h"
+#include "DeviceHandlerFailureIsolation.h"
 
 #include "../objectmanager/SystemObject.h"
 #include "../tasks/ExecutableObjectIF.h"
-#include "../devicehandlers/DeviceHandlerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../action/HasActionsIF.h"
 #include "../datapool/PoolVariableIF.h"
-#include "../devicehandlers/DeviceCommunicationIF.h"
 #include "../modes/HasModesIF.h"
 #include "../power/PowerSwitchIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../tasks/PeriodicTaskIF.h"
-
 #include "../action/ActionHelper.h"
 #include "../health/HealthHelper.h"
 #include "../parameters/ParameterHelper.h"
 #include "../datapool/HkSwitchHelper.h"
 #include "../datapoollocal/HasLocalDataPoolIF.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
-#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+
 #include <map>
 
 namespace Factory{
@@ -1205,4 +1206,4 @@ private:
                 size_t receivedDataLen);
 };
 
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */

From b429359864f3a25eb33af17f52958fa102ffb8b9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:14:01 +0200
Subject: [PATCH 0776/1774] renormalize files

---
 ipc/messageQueueDefinitions.h     |  36 ++---
 serialize/SerialBufferAdapter.cpp | 258 +++++++++++++++---------------
 serialize/SerialBufferAdapter.h   | 156 +++++++++---------
 3 files changed, 225 insertions(+), 225 deletions(-)

diff --git a/ipc/messageQueueDefinitions.h b/ipc/messageQueueDefinitions.h
index d30e69849..d250da8a3 100644
--- a/ipc/messageQueueDefinitions.h
+++ b/ipc/messageQueueDefinitions.h
@@ -1,18 +1,18 @@
-#ifndef FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
-#define FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
-
-#include <cstdint>
-
-/*
- * TODO: Actually, the definition of this ID to be a uint32_t is not  ideal and
- * breaks layering. However, it is difficult to keep layering, as the ID is
- * stored in many places and sent around in MessageQueueMessage.
- * Ideally, one would use the (current) object_id_t only, however, doing a
- * lookup of queueIDs for every call does not sound ideal.
- * In a first step, I'll circumvent the issue by not touching it,
- * maybe in a second step. This also influences Interface design
- * (getCommandQueue) and some other issues..
- */
-using MessageQueueId_t = uint32_t;
-
-#endif /* FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ */
+#ifndef FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
+#define FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
+
+#include <cstdint>
+
+/*
+ * TODO: Actually, the definition of this ID to be a uint32_t is not  ideal and
+ * breaks layering. However, it is difficult to keep layering, as the ID is
+ * stored in many places and sent around in MessageQueueMessage.
+ * Ideally, one would use the (current) object_id_t only, however, doing a
+ * lookup of queueIDs for every call does not sound ideal.
+ * In a first step, I'll circumvent the issue by not touching it,
+ * maybe in a second step. This also influences Interface design
+ * (getCommandQueue) and some other issues..
+ */
+using MessageQueueId_t = uint32_t;
+
+#endif /* FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ */
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 812cd34b2..1c11afd4b 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,129 +1,129 @@
-#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>;
-
+#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>;
+
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index c3dfcd8fb..9a89e18ba 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -1,78 +1,78 @@
-#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_ */
+#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_ */

From 1b5c3786b61ceecdb4e7cf1b7b664e81399dbcf6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:24:06 +0200
Subject: [PATCH 0777/1774] taken over serviceinterface folder

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 2 +-
 serviceinterface/ServiceInterfaceStream.cpp | 2 +-
 serviceinterface/ServiceInterfaceStream.h   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 880f51e12..68fc4dec3 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,5 +1,5 @@
 #include "../timemanager/Clock.h"
-#include "../serviceinterface/ServiceInterfaceBuffer.h"
+#include "ServiceInterfaceBuffer.h"
 #include <cstring>
 #include <inttypes.h>
 
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 8a3589991..5b7b9f004 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,4 +1,4 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "ServiceInterfaceStream.h"
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
 		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 051500f5b..76fa1bf23 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
 
-#include "../serviceinterface/ServiceInterfaceBuffer.h"
+#include "ServiceInterfaceBuffer.h"
 #include <iostream>
 #include <cstdio>
 

From 4d4166071ca864ce4e60d0aa92ddcc6b74fa1644 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:28:20 +0200
Subject: [PATCH 0778/1774] added pus services to framework objects

---
 objectmanager/frameworkObjects.h | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 46d5feea2..4a30e70ae 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -1,10 +1,14 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
-#define FRAMEWORK_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
+#ifndef FSFW_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
+#define FSFW_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
 
 namespace objects {
 enum framework_objects {
 	// Default verification reporter.
-	PUS_SERVICE_1 = 0x53000000,
+	PUS_SERVICE_1 = 0x53000001,
+	PUS_SERVICE_2 = 0x53000002,
+	PUS_SERVICE_5 = 0x53000005,
+	PUS_SERVICE_8 = 0x53000008,
+	PUS_SERVICE_200 = 0x53000200,
 
 	//Generic IDs for IPC, modes, health, events
 	HEALTH_TABLE = 0x53010000,
@@ -22,4 +26,4 @@ enum framework_objects {
 
 
 
-#endif /* FRAMEWORK_OBJECTMANAGER_FRAMEWORKOBJECTS_H_ */
+#endif /* FSFW_OBJECTMANAGER_FRAMEWORKOBJECTS_H_ */

From f50a80fc3c61066d69117d033b59a85722212c09 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:29:42 +0200
Subject: [PATCH 0779/1774] minor tweaks

---
 objectmanager/ObjectManager.cpp |  2 +-
 objectmanager/ObjectManager.h   | 27 +++++++++++----------------
 2 files changed, 12 insertions(+), 17 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index a8c844159..5871bfcdf 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,4 +1,4 @@
-#include "../objectmanager/ObjectManager.h"
+#include "ObjectManager.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include <iomanip>
 #include <cstdlib>
diff --git a/objectmanager/ObjectManager.h b/objectmanager/ObjectManager.h
index e582584cd..69a74f73e 100644
--- a/objectmanager/ObjectManager.h
+++ b/objectmanager/ObjectManager.h
@@ -1,15 +1,8 @@
-/**
- * @file	ObjectManager.h
- * @brief	This file contains the implementation of the ObjectManager class
- * @date	18.09.2012
- * @author	Bastian Baetz
- */
+#ifndef FSFW_OBJECTMANAGER_OBJECTMANAGER_H_
+#define FSFW_OBJECTMANAGER_OBJECTMANAGER_H_
 
-#ifndef OBJECTMANAGER_H_
-#define OBJECTMANAGER_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../objectmanager/SystemObjectIF.h"
+#include "ObjectManagerIF.h"
+#include "SystemObjectIF.h"
 #include <map>
 
 /**
@@ -22,14 +15,15 @@
  * 			most of the system initialization.
  * 			As the system is static after initialization, no new objects are
  * 			created or inserted into the list after startup.
- * \ingroup system_objects
+ * @ingroup system_objects
+ * @author	Bastian Baetz
  */
 class ObjectManager : public ObjectManagerIF {
 private:
 	//comparison?
 	/**
-	 * \brief	This is the map of all initialized objects in the manager.
-	 * \details	Objects in the List must inherit the SystemObjectIF.
+	 * @brief	This is the map of all initialized objects in the manager.
+	 * @details	Objects in the List must inherit the SystemObjectIF.
 	 */
 	std::map<object_id_t, SystemObjectIF*> objectList;
 protected:
@@ -54,7 +48,8 @@ public:
 	/**
 	 *	@brief	In the class's destructor, all objects in the list are deleted.
 	 */
-	//SHOULDDO: If, for some reason, deleting an ObjectManager instance is required, check if this works.
+	// SHOULDDO: If, for some reason, deleting an ObjectManager instance is
+	// required, check if this works.
 	virtual ~ObjectManager( void );
 	ReturnValue_t insert( object_id_t id, SystemObjectIF* object );
 	ReturnValue_t remove( object_id_t id );
@@ -64,4 +59,4 @@ public:
 
 
 
-#endif /* OBJECTMANAGER_H_ */
+#endif /* FSFW_OBJECTMANAGER_OBJECTMANAGER_H_ */

From 3a043b5773de78516ac6efd0c3b483e79ebd729e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:31:51 +0200
Subject: [PATCH 0780/1774] object manager tweaks complete

---
 objectmanager/ObjectManagerIF.h |  9 +++++----
 objectmanager/SystemObject.cpp  |  4 ++--
 objectmanager/SystemObject.h    | 19 +++++++++++--------
 objectmanager/SystemObjectIF.h  |  6 +++---
 4 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 16619e23a..1f462509a 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
-#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+#ifndef FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_
+#define FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_
 
-#include "../objectmanager/frameworkObjects.h"
-#include "../objectmanager/SystemObjectIF.h"
+#include "frameworkObjects.h"
+#include "SystemObjectIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
@@ -79,6 +79,7 @@ public:
 /**
  * @brief	This is the forward declaration of the global objectManager instance.
  */
+// maybe but this in the glob namespace to explicitely mark it global?
 extern ObjectManagerIF *objectManager;
 
 /*Documentation can be found in the class method declaration above.*/
diff --git a/objectmanager/SystemObject.cpp b/objectmanager/SystemObject.cpp
index 61eaf90af..64330fbc9 100644
--- a/objectmanager/SystemObject.cpp
+++ b/objectmanager/SystemObject.cpp
@@ -1,6 +1,6 @@
+#include "ObjectManager.h"
+#include "SystemObject.h"
 #include "../events/EventManagerIF.h"
-#include "../objectmanager/ObjectManager.h"
-#include "../objectmanager/SystemObject.h"
 
 SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
 		objectId(setObjectId), registered(doRegister) {
diff --git a/objectmanager/SystemObject.h b/objectmanager/SystemObject.h
index ae4b13897..9188693ee 100644
--- a/objectmanager/SystemObject.h
+++ b/objectmanager/SystemObject.h
@@ -1,9 +1,9 @@
-#ifndef SYSTEMOBJECT_H_
-#define SYSTEMOBJECT_H_
+#ifndef FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_
+#define FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_
 
+#include "SystemObjectIF.h"
 #include "../events/Event.h"
 #include "../events/EventReportingProxyIF.h"
-#include "../objectmanager/SystemObjectIF.h"
 #include "../timemanager/Clock.h"
 
 /**
@@ -13,7 +13,7 @@
  * 			class that is announced to ObjectManager. It automatically includes
  * 			itself (and therefore the inheriting class) in the object manager's
  * 			list.
- * \ingroup system_objects
+ * @ingroup system_objects
  */
 class SystemObject: public SystemObjectIF {
 private:
@@ -30,14 +30,16 @@ public:
 	 * @param parameter1
 	 * @param parameter2
 	 */
-	virtual void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
 
 	/**
 	 * @brief	The class's constructor.
 	 * @details	In the constructor, the object id is set and the class is
 	 * 			inserted in the object manager.
 	 * @param setObjectId	The id the object shall have.
-	 * @param doRegister	Determines if the object is registered in the global object manager.
+	 * @param doRegister	Determines if the object is registered in
+	 * 						the global object manager.
 	 */
 	SystemObject(object_id_t setObjectId, bool doRegister = true);
 	/**
@@ -48,7 +50,8 @@ public:
 	virtual ReturnValue_t initialize() override;
 	virtual ReturnValue_t checkObjectConnections();
 
-	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;
+	virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0) const;
 };
 
-#endif /* SYSTEMOBJECT_H_ */
+#endif /* FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_ */
diff --git a/objectmanager/SystemObjectIF.h b/objectmanager/SystemObjectIF.h
index 108717af5..315fde9b3 100644
--- a/objectmanager/SystemObjectIF.h
+++ b/objectmanager/SystemObjectIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
-#define FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+#ifndef FSFW_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+#define FSFW_OBJECTMANAGER_SYSTEMOBJECTIF_H_
 
 #include "../events/EventReportingProxyIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -59,4 +59,4 @@ public:
 	virtual ReturnValue_t checkObjectConnections() = 0;
 };
 
-#endif /* FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */
+#endif /* #ifndef FSFW_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */

From 5e3f40a2c1c163eaa36705de597db37b36ec8635 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:40:48 +0200
Subject: [PATCH 0781/1774] changes taken over from pull request

---
 objectmanager/ObjectManagerIF.h | 4 ++--
 objectmanager/SystemObject.h    | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 1f462509a..4bd1d915a 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -21,7 +21,7 @@ public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
 	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
 	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
-	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
+	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 ); //!< Can be used if the initialization of a SystemObject failed.
 	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
 
 protected:
@@ -79,7 +79,7 @@ public:
 /**
  * @brief	This is the forward declaration of the global objectManager instance.
  */
-// maybe but this in the glob namespace to explicitely mark it global?
+// SHOULDDO: maybe put this in the glob namespace to explicitely mark it global?
 extern ObjectManagerIF *objectManager;
 
 /*Documentation can be found in the class method declaration above.*/
diff --git a/objectmanager/SystemObject.h b/objectmanager/SystemObject.h
index 9188693ee..d9c4236d0 100644
--- a/objectmanager/SystemObject.h
+++ b/objectmanager/SystemObject.h
@@ -13,6 +13,7 @@
  * 			class that is announced to ObjectManager. It automatically includes
  * 			itself (and therefore the inheriting class) in the object manager's
  * 			list.
+ * @author	Ulrich Mohr
  * @ingroup system_objects
  */
 class SystemObject: public SystemObjectIF {

From 33e7cca23c3175b7349654e790fadb9a2938546c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 15:01:35 +0200
Subject: [PATCH 0782/1774] several bugfixes amd improvements

---
 datapoollocal/LocalDataPoolManager.cpp |   5 +-
 pus/Service3Housekeeping.cpp           | 205 ++++++++++++++-----------
 pus/Service3Housekeeping.h             |  18 ++-
 3 files changed, 128 insertions(+), 100 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 619d8365a..778519048 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -144,8 +144,11 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
         //return generateSetStructurePacket(message->getSid());
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
+		return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+				false, true);
     case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
-        //return generateHousekeepingPacket(message->getSid());
+        return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+        		true, true);
     default:
         return CommandMessageIF::UNKNOWN_COMMAND;
     }
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index db77328ab..55e687cc4 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -36,7 +36,6 @@ ReturnValue_t Service3Housekeeping::isValidSubservice(uint8_t subservice) {
 ReturnValue_t Service3Housekeeping::getMessageQueueAndObject(uint8_t subservice,
 		const uint8_t *tcData, size_t tcDataLen,
 		MessageQueueId_t *id, object_id_t *objectId) {
-	return HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
 	if(result != RETURN_OK) {
 		return result;
@@ -55,7 +54,7 @@ ReturnValue_t Service3Housekeeping::checkAndAcquireTargetID(
 
 ReturnValue_t Service3Housekeeping::checkInterfaceAndAcquireMessageQueue(
 		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-	// check OwnsLocalDataPoolIF property of target
+	// check HasLocalDataPoolIF property of target
 	HasLocalDataPoolIF* possibleTarget =
 			objectManager->get<HasLocalDataPoolIF>(*objectId);
 	if(possibleTarget == nullptr){
@@ -71,33 +70,35 @@ ReturnValue_t Service3Housekeeping::prepareCommand(CommandMessage* message,
 		uint32_t *state, object_id_t objectId) {
 	switch(static_cast<Subservice>(subservice)) {
 	case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
-		return prepareReportingTogglingCommand(message, true, false,
+		return prepareReportingTogglingCommand(message, objectId, true, false,
 				tcData, tcDataLen);
 	case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
-		return prepareReportingTogglingCommand(message, false, false,
+		return prepareReportingTogglingCommand(message, objectId, false, false,
 				tcData, tcDataLen);
 	case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
-		return prepareReportingTogglingCommand(message, true, true,
+		return prepareReportingTogglingCommand(message, objectId, true, true,
 				tcData, tcDataLen);
 	case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
-		return prepareReportingTogglingCommand(message, false, true,
+		return prepareReportingTogglingCommand(message, objectId, false, true,
 				tcData, tcDataLen);
 	case Subservice::REPORT_HK_REPORT_STRUCTURES:
-		return prepareStructureReportingCommand(message, false, tcData,
+		return prepareStructureReportingCommand(message, objectId, false, tcData,
 				tcDataLen);
 	case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES:
-		return prepareStructureReportingCommand(message, true, tcData,
+		return prepareStructureReportingCommand(message, objectId, true, tcData,
 				tcDataLen);
 	case Subservice::GENERATE_ONE_PARAMETER_REPORT:
-		return prepareOneShotReportCommand(message, false, tcData, tcDataLen);
+		return prepareOneShotReportCommand(message, objectId, false,
+				tcData, tcDataLen);
 	case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
-		return prepareOneShotReportCommand(message, true, tcData, tcDataLen);
+		return prepareOneShotReportCommand(message, objectId, true,
+				tcData, tcDataLen);
 	case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
-		return prepareCollectionIntervalModificationCommand(message, false,
-				tcData, tcDataLen);
+		return prepareCollectionIntervalModificationCommand(message, objectId,
+				false, tcData, tcDataLen);
 	case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
-		return prepareCollectionIntervalModificationCommand(message, true,
-				tcData, tcDataLen);
+		return prepareCollectionIntervalModificationCommand(message, objectId,
+				true, tcData, tcDataLen);
 	case Subservice::HK_DEFINITIONS_REPORT:
 	case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
 	case Subservice::HK_REPORT:
@@ -111,103 +112,59 @@ ReturnValue_t Service3Housekeeping::prepareCommand(CommandMessage* message,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
-		Command_t previousCommand, uint32_t *state,
-		CommandMessage* optionalNextCommand, object_id_t objectId,
-		bool *isStep) {
-	switch(reply->getCommand()) {
-	case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
-		return CommandingServiceBase::EXECUTION_COMPLETE;
-	}
-	case(HousekeepingMessage::HK_REQUEST_FAILURE): {
-		failureParameter1 = objectId;
-		// also provide failure reason (returnvalue)
-		// will be most commonly invalid SID or the set already has the desired
-		// reporting status.
-		return CommandingServiceBase::EXECUTION_COMPLETE;
-	}
-	default:
-		sif::error << "Service3Housekeeping::handleReply: Invalid reply!"
-				<< std::endl;
-		return CommandingServiceBase::INVALID_REPLY;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
 ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(
-		CommandMessage *command, bool enableReporting, bool isDiagnostics,
+		CommandMessage *command, object_id_t objectId,
+		bool enableReporting, bool isDiagnostics,
 		const uint8_t* tcData, size_t tcDataLen) {
-	if(tcDataLen < sizeof(sid_t)) {
-		// It is assumed the full SID is sent for now (even if that means
-		// 4 bytes are redundant)
+	if(tcDataLen < sizeof(object_id_t)) {
+		// TC data should consist of object ID and set ID.
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid;
-	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
-	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
-				SerializeIF::Endianness::BIG);
-
+	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
 	HousekeepingMessage::setToggleReportingCommand(command, targetSid,
 			enableReporting, isDiagnostics);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Service3Housekeeping::prepareStructureReportingCommand(
-		CommandMessage *command, bool isDiagnostics, const uint8_t* tcData,
-		size_t tcDataLen) {
+		CommandMessage *command, object_id_t objectId, bool isDiagnostics,
+		const uint8_t* tcData, size_t tcDataLen) {
 	if(tcDataLen < sizeof(sid_t)) {
-		// It is assumed the full SID is sent for now (even if that means
-		// 4 bytes are redundant)
+		// TC data should consist of object ID and set ID.
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid;
-	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
-	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
-
+	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
 	HousekeepingMessage::setStructureReportingCommand(command, targetSid,
 			isDiagnostics);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Service3Housekeeping::prepareOneShotReportCommand(
-		CommandMessage *command, bool isDiagnostics, const uint8_t *tcData,
-		size_t tcDataLen) {
+		CommandMessage *command, object_id_t objectId, bool isDiagnostics,
+		const uint8_t *tcData, size_t tcDataLen) {
 	if(tcDataLen < sizeof(sid_t)) {
-		// It is assumed the full SID is sent for now (even if that means
-		// 4 bytes are redundant)
+		// TC data should consist of object ID and set ID.
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid;
-	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
-	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
+	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
 	HousekeepingMessage::setOneShotReportCommand(command, targetSid,
 			isDiagnostics);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand(
-		CommandMessage *command, bool isDiagnostics, const uint8_t *tcData,
-		size_t tcDataLen) {
+		CommandMessage *command, object_id_t objectId, bool isDiagnostics,
+		const uint8_t *tcData, size_t tcDataLen) {
 	if(tcDataLen < sizeof(sid_t) + sizeof(float)) {
-		// It is assumed the full SID and the new collection interval as a float
-		// is sent for now (even if that means 4 bytes are redundant)
+		// SID plus the size of the new collection intervL.
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid;
+	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
 	float newCollectionInterval = 0;
-	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
-	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
 	SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen,
 			SerializeIF::Endianness::BIG);
 	HousekeepingMessage::setCollectionIntervalModificationCommand(command,
@@ -215,25 +172,76 @@ ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
+		Command_t previousCommand, uint32_t *state,
+		CommandMessage* optionalNextCommand, object_id_t objectId,
+		bool *isStep) {
+	Command_t command = reply->getCommand();
+	switch(command) {
+
+	case(HousekeepingMessage::HK_REPORT): {
+		ReturnValue_t result = generateHkReport(reply,
+				static_cast<uint8_t>(Subservice::HK_REPORT));
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+
+	case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
+		ReturnValue_t result = generateHkReport(reply,
+				static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+
+	case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+
+	case(HousekeepingMessage::HK_REQUEST_FAILURE): {
+		failureParameter1 = objectId;
+		// also provide failure reason (returnvalue)
+		// will be most commonly invalid SID or the set already has the desired
+		// reporting status.
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+
+	default:
+		sif::error << "Service3Housekeeping::handleReply: Invalid reply with "
+				<< "reply command " << command << "!" << std::endl;
+		return CommandingServiceBase::INVALID_REPLY;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 void Service3Housekeeping::handleUnrequestedReply(
-        CommandMessage* reply) {
+		CommandMessage* reply) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    switch(reply->getCommand()) {
-    case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
-    	result = generateHkReport(reply,
-    			static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
-    	break;
-    }
-    case(HousekeepingMessage::HK_REPORT): {
-        result = generateHkReport(reply,
-        		static_cast<uint8_t>(Subservice::HK_REPORT));
-        break;
-    }
-    default: {
-        sif::error << "Service3Housekeeping::handleUnrequestedReply: "
-                << "Invalid reply!" << std::endl;
-    }
-    }
+	Command_t command = reply->getCommand();
+
+	switch(command) {
+
+	case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
+		result = generateHkReport(reply,
+				static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
+		break;
+	}
+
+	case(HousekeepingMessage::HK_REPORT): {
+		result = generateHkReport(reply,
+				static_cast<uint8_t>(Subservice::HK_REPORT));
+		break;
+	}
+
+	default:
+		sif::error << "Service3Housekeeping::handleReply: Invalid reply with "
+				<< "reply command " << command << "!" << std::endl;
+		return;
+	}
 
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		// Configuration error
@@ -260,3 +268,16 @@ ReturnValue_t Service3Housekeeping::generateHkReport(
 	return sendTmPacket(static_cast<uint8_t>(subserviceId),
 			hkPacket.hkData, hkPacket.hkSize, nullptr, 0);
 }
+
+sid_t Service3Housekeeping::buildSid(object_id_t objectId,
+		const uint8_t* tcData, size_t tcDataLen) {
+	sid_t targetSid;
+	targetSid.objectId = objectId;
+	// skip deserialization of object ID, was already done.
+	tcData += sizeof(object_id_t);
+	tcDataLen -= sizeof(object_id_t);
+	// size check is expected to be performed beforehand!
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	return targetSid;
+}
diff --git a/pus/Service3Housekeeping.h b/pus/Service3Housekeeping.h
index 6c5d24699..1dab31539 100644
--- a/pus/Service3Housekeeping.h
+++ b/pus/Service3Housekeeping.h
@@ -85,17 +85,21 @@ private:
 	ReturnValue_t generateHkReport(const CommandMessage* hkMessage,
 			uint8_t subserviceId);
 	ReturnValue_t prepareReportingTogglingCommand(CommandMessage* command,
-			bool enableReporting, bool isDiagnostics, const uint8_t* tcData,
-			size_t tcDataLen);
+			object_id_t objectId, bool enableReporting, bool isDiagnostics,
+			const uint8_t* tcData, size_t tcDataLen);
 	ReturnValue_t prepareStructureReportingCommand(CommandMessage* command,
-			bool isDiagnostics, const uint8_t* tcData, size_t tcDataLen);
-	ReturnValue_t prepareOneShotReportCommand(CommandMessage* command,
-			bool isDiagnostics, const uint8_t* tcData, size_t tcDataLen);
-	ReturnValue_t prepareCollectionIntervalModificationCommand(
-			CommandMessage* command, bool isDiagnostics, const uint8_t* tcData,
+			object_id_t objectId, bool isDiagnostics, const uint8_t* tcData,
 			size_t tcDataLen);
+	ReturnValue_t prepareOneShotReportCommand(CommandMessage* command,
+			object_id_t objectId, bool isDiagnostics, const uint8_t* tcData,
+			size_t tcDataLen);
+	ReturnValue_t prepareCollectionIntervalModificationCommand(
+			CommandMessage* command, object_id_t objectId, bool isDiagnostics,
+			const uint8_t* tcData, size_t tcDataLen);
 
 	void handleUnrequestedReply(CommandMessage* reply) override;
+	sid_t buildSid(object_id_t objectId, const uint8_t* tcData,
+			size_t tcDataLen);
 };
 
 #endif /* FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_ */

From 757d2275ea9f1f19e134e896459fa8a02c9bedcb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 15:06:14 +0200
Subject: [PATCH 0783/1774] internal bugfix

---
 pus/Service3Housekeeping.cpp | 16 ++++++++--------
 pus/Service3Housekeeping.h   |  4 ++--
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index 55e687cc4..d8e4466b5 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -121,7 +121,7 @@ ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
+	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
 	HousekeepingMessage::setToggleReportingCommand(command, targetSid,
 			enableReporting, isDiagnostics);
 	return HasReturnvaluesIF::RETURN_OK;
@@ -135,7 +135,7 @@ ReturnValue_t Service3Housekeeping::prepareStructureReportingCommand(
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
+	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
 	HousekeepingMessage::setStructureReportingCommand(command, targetSid,
 			isDiagnostics);
 	return HasReturnvaluesIF::RETURN_OK;
@@ -149,7 +149,7 @@ ReturnValue_t Service3Housekeeping::prepareOneShotReportCommand(
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
+	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
 	HousekeepingMessage::setOneShotReportCommand(command, targetSid,
 			isDiagnostics);
 	return HasReturnvaluesIF::RETURN_OK;
@@ -163,7 +163,7 @@ ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
+	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
 	float newCollectionInterval = 0;
 	SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen,
 			SerializeIF::Endianness::BIG);
@@ -270,14 +270,14 @@ ReturnValue_t Service3Housekeeping::generateHkReport(
 }
 
 sid_t Service3Housekeeping::buildSid(object_id_t objectId,
-		const uint8_t* tcData, size_t tcDataLen) {
+		const uint8_t** tcData, size_t* tcDataLen) {
 	sid_t targetSid;
 	targetSid.objectId = objectId;
 	// skip deserialization of object ID, was already done.
-	tcData += sizeof(object_id_t);
-	tcDataLen -= sizeof(object_id_t);
+	*tcData += sizeof(object_id_t);
+	*tcDataLen -= sizeof(object_id_t);
 	// size check is expected to be performed beforehand!
-	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, tcData, tcDataLen,
 			SerializeIF::Endianness::BIG);
 	return targetSid;
 }
diff --git a/pus/Service3Housekeeping.h b/pus/Service3Housekeeping.h
index 1dab31539..01964bab1 100644
--- a/pus/Service3Housekeeping.h
+++ b/pus/Service3Housekeeping.h
@@ -98,8 +98,8 @@ private:
 			const uint8_t* tcData, size_t tcDataLen);
 
 	void handleUnrequestedReply(CommandMessage* reply) override;
-	sid_t buildSid(object_id_t objectId, const uint8_t* tcData,
-			size_t tcDataLen);
+	sid_t buildSid(object_id_t objectId, const uint8_t** tcData,
+			size_t* tcDataLen);
 };
 
 #endif /* FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_ */

From ba56f48e8e87f0087b9c5e29846723505abe71cf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 01:17:43 +0200
Subject: [PATCH 0784/1774] huge progress on hk + testing

---
 datapoollocal/LocalDataPoolManager.cpp       | 127 ++++++++++++++++---
 datapoollocal/LocalDataPoolManager.h         |  29 +++--
 datapoollocal/LocalPoolDataSetBase.cpp       |  16 +++
 datapoollocal/LocalPoolDataSetBase.h         |  15 ++-
 datapoollocal/LocalPoolVariable.h            |  14 +-
 datapoollocal/LocalPoolVariable.tpp          |   6 +-
 datapoollocal/LocalPoolVector.h              |  10 +-
 datapoollocal/LocalPoolVector.tpp            |  27 ++--
 globalfunctions/PeriodicOperationDivider.cpp |  14 +-
 globalfunctions/PeriodicOperationDivider.h   |  12 +-
 housekeeping/HousekeepingMessage.cpp         |   2 +-
 housekeeping/HousekeepingMessage.h           |  10 +-
 housekeeping/HousekeepingPacketDownlink.h    |  16 +--
 housekeeping/HousekeepingPacketUpdate.h      |   6 +-
 housekeeping/HousekeepingSetPacket.h         |  13 ++
 pus/Service3Housekeeping.cpp                 |   2 +-
 16 files changed, 237 insertions(+), 82 deletions(-)
 create mode 100644 housekeeping/HousekeepingSetPacket.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 778519048..17c7ad1d3 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -35,7 +35,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
 	    AcceptsHkPacketsIF* hkPacketReceiver =
 	            objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
 	    if(hkPacketReceiver != nullptr) {
-	        defaultHkDestinationId = hkPacketReceiver->getHkQueue();
+	        hkDestinationId = hkPacketReceiver->getHkQueue();
 	    }
 	}
 }
@@ -78,9 +78,6 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
     for(auto& hkReceiversIter: hkReceiversMap) {
         HkReceiver* receiver = &hkReceiversIter.second;
-        if(not receiver->reportingEnabled) {
-            return HasReturnvaluesIF::RETURN_OK;
-        }
 
         switch(receiver->reportingType) {
         case(ReportingType::PERIODIC): {
@@ -118,7 +115,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	hkReceiver.dataId.dataSetSid = sid;
 	hkReceiver.reportingType = ReportingType::PERIODIC;
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
-	hkReceiver.reportingEnabled = enableReporting;
+
 	if(not isDiagnostics) {
 	    hkReceiver.hkParameter.collectionIntervalTicks =
 	            intervalSecondsToInterval(isDiagnostics, collectionInterval *
@@ -129,7 +126,13 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	            intervalSecondsToInterval(isDiagnostics, collectionInterval);
 	}
 
-	hkReceiver.isDiagnostics = isDiagnostics;
+	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+	            owner->getDataSetHandle(sid));
+	if(dataSet != nullptr) {
+		dataSet->setReportingEnabled(enableReporting);
+		dataSet->setIsDiagnostic(isDiagnostics);
+	}
+
 	hkReceiver.intervalCounter = 1;
 
 	hkReceiversMap.emplace(packetDestination, hkReceiver);
@@ -139,16 +142,51 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		CommandMessage* message) {
     Command_t command = message->getCommand();
+    sid_t sid = HousekeepingMessage::getSid(message);
     switch(command) {
+    case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION):
+    	return togglePeriodicGeneration(sid, true, true);
+    case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION):
+		return togglePeriodicGeneration(sid, false, true);
+    case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION):
+		return togglePeriodicGeneration(sid, true, false);
+    case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION):
+		return togglePeriodicGeneration(sid, false, false);
+
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-        //return generateSetStructurePacket(message->getSid());
+		return generateSetStructurePacket(sid);
+
+    case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
+    case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
+    	float newCollIntvl = 0;
+    	HousekeepingMessage::getCollectionIntervalModificationCommand(message,
+    			&newCollIntvl);
+    	if(command == HousekeepingMessage::
+    			MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
+    		return changeCollectionInterval(sid, newCollIntvl, true);
+    	}
+    	else {
+    		return changeCollectionInterval(sid, newCollIntvl, false);
+    	}
+    }
+
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
-		return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
-				false, true);
-    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
-        return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
-        		true, true);
+    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
+    	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+    			owner->getDataSetHandle(sid));
+    	if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
+    			and dataSet->getIsDiagnostics()) {
+    		return WRONG_HK_PACKET_TYPE;
+    	}
+    	else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
+    			and not dataSet->getIsDiagnostics()) {
+    		return WRONG_HK_PACKET_TYPE;
+    	}
+    	return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+    			dataSet, true);
+    }
+
     default:
         return CommandMessageIF::UNKNOWN_COMMAND;
     }
@@ -175,17 +213,17 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        bool isDiagnostics, bool forDownlink, MessageQueueId_t destination) {
-	LocalPoolDataSetBase* dataSetToSerialize =
-			dynamic_cast<LocalPoolDataSetBase*>(owner->getDataSetHandle(sid));
-	if(dataSetToSerialize == nullptr) {
+		LocalPoolDataSetBase* dataSet, bool forDownlink,
+		MessageQueueId_t destination) {
+	if(dataSet == nullptr) {
+		// Configuration error.
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
 				" Set ID not found or dataset not assigned!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
 	store_address_t storeId;
-	HousekeepingPacketDownlink hkPacket(sid, dataSetToSerialize);
+	HousekeepingPacketDownlink hkPacket(sid, dataSet);
 	size_t serializedSize = 0;
 	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
 			forDownlink, &serializedSize);
@@ -195,7 +233,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
 	// and now we set a HK message and send it the HK packet destination.
 	CommandMessage hkMessage;
-	if(isDiagnostics) {
+	if(dataSet->getIsDiagnostics()) {
 		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
 	}
 	else {
@@ -206,11 +244,11 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	    return QUEUE_OR_DESTINATION_NOT_SET;
 	}
 	if(destination == MessageQueueIF::NO_QUEUE) {
-	    if(defaultHkDestinationId == MessageQueueIF::NO_QUEUE) {
+	    if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
 	        // error, all destinations invalid
 	        return HasReturnvaluesIF::RETURN_FAILED;
 	    }
-	    destination = defaultHkDestinationId;
+	    destination = hkDestinationId;
 	}
 
 	return hkQueue->sendMessage(destination, &hkMessage);
@@ -273,8 +311,15 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
     if(receiver->intervalCounter >=
             receiver->hkParameter.collectionIntervalTicks) {
+    	sid_t sid = receiver->dataId.dataSetSid;
+    	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+    			owner->getDataSetHandle(sid));
+    	if(not dataSet->getReportingEnabled()) {
+    		return;
+    	}
+
         ReturnValue_t result = generateHousekeepingPacket(
-                receiver->dataId.dataSetSid, receiver->isDiagnostics, true);
+                sid, dataSet, true);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             // configuration error
             sif::debug << "LocalDataPoolManager::performHkOperation:"
@@ -312,3 +357,43 @@ float LocalDataPoolManager::intervalToIntervalSeconds(bool isDiagnostics,
                 regularMinimumInterval);
     }
 }
+
+ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
+		bool enable, bool isDiagnostics) {
+	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+			owner->getDataSetHandle(sid));
+	if((dataSet->getIsDiagnostics() and not isDiagnostics) or
+			(not dataSet->getIsDiagnostics() and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
+
+	if((dataSet->getReportingEnabled() and enable) or
+			(not dataSet->getReportingEnabled() and not enable)) {
+		return REPORTING_STATUS_UNCHANGED;
+	}
+
+	dataSet->setReportingEnabled(enable);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
+		float newCollectionInterval, bool isDiagnostics) {
+	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+				owner->getDataSetHandle(sid));
+	bool targetIsDiagnostics = dataSet->getIsDiagnostics();
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
+
+	for(auto& receiver: hkReceiversMap) {
+		if(receiver.second.reportingType != ReportingType::PERIODIC) {
+			continue;
+		}
+
+		uint32_t newInterval = intervalSecondsToInterval(isDiagnostics,
+				newCollectionInterval);
+		receiver.second.hkParameter.collectionIntervalTicks = newInterval;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 1ab08903f..559b8cc20 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -23,7 +23,7 @@ class LocalDataSetBase;
 
 
 /**
- * @brief 	This class is the managing instance for local data pool.
+ * @brief 		This class is the managing instance for the local data pool.
  * @details
  * The actual data pool structure is a member of this class. Any class which
  * has a local data pool shall have this class as a member and implement
@@ -37,7 +37,7 @@ class LocalDataSetBase;
  * value is stored. The helper classes offer a read() and commit() interface
  * through the PoolVariableIF which is used to read and update values.
  * Each pool entry has a valid state too.
- * @author R. Mueller
+ * @author 		R. Mueller
  */
 class LocalDataPoolManager {
 	template<typename T>
@@ -49,11 +49,13 @@ class LocalDataPoolManager {
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
-    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
+    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
+    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
 
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x02);
 
+    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x03);
+    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x04);
     /**
      * This constructor is used by a class which wants to implement
      * a personal local data pool. The queueToUse can be supplied if it
@@ -110,8 +112,8 @@ public:
 	 * @return
 	 */
 	ReturnValue_t generateHousekeepingPacket(sid_t sid,
-			bool isDiagnostics, bool forDownlink,
-	        MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
+			LocalPoolDataSetBase* dataSet, bool forDownlink,
+			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
@@ -169,7 +171,7 @@ private:
 
 	/** Default receiver for periodic HK packets */
 	static object_id_t defaultHkDestination;
-	MessageQueueId_t defaultHkDestinationId = MessageQueueIF::NO_QUEUE;
+	MessageQueueId_t hkDestinationId = MessageQueueIF::NO_QUEUE;
 
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
@@ -185,8 +187,11 @@ private:
         DataId dataId;
 
         ReportingType reportingType = ReportingType::PERIODIC;
+        // SHOULDDO: it would be nice to also have the object ID instead of
+        // a queue (or in addition).. but the FSFW is not ready  for that yet.
+        // Also, an object can have multiple queues.
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
-        bool reportingEnabled = true;
+
         /** Different members of this union will be used depending on reporting
         type */
         union HkParameter {
@@ -196,7 +201,6 @@ private:
             bool hkDataChanged;
         };
         HkParameter hkParameter;
-        bool isDiagnostics;
         /** General purpose counter which is used for periodic generation. */
         uint32_t intervalCounter;
     };
@@ -245,7 +249,6 @@ private:
 	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
 			PoolEntry<T> **poolEntry);
 
-	void setMinimalSamplingFrequency(float frequencySeconds);
 	ReturnValue_t serializeHkPacketIntoStore(
 	        HousekeepingPacketDownlink& hkPacket,
 	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
@@ -256,6 +259,10 @@ private:
 	        uint32_t collectionInterval);
 
 	void performPeriodicHkGeneration(HkReceiver* hkReceiver);
+	ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable,
+			bool isDiagnostics);
+	ReturnValue_t changeCollectionInterval(sid_t sid,
+			float newCollectionInterval, bool isDiagnostics);
 };
 
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 859f1f2c6..362e8981e 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -175,6 +175,22 @@ void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     *byte |= 1 << shiftNumber;
 }
 
+void LocalPoolDataSetBase::setIsDiagnostic(bool isDiagnostics) {
+	this->isDiagnostics = isDiagnostics;
+}
+
+bool LocalPoolDataSetBase::getIsDiagnostics() const {
+	return isDiagnostics;
+}
+
+void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
+	this->reportingEnabled = reportingEnabled;
+}
+
+bool LocalPoolDataSetBase::getReportingEnabled() const {
+	return reportingEnabled;
+}
+
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 		uint8_t position) const {
     if(position > 7) {
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 17c20d4f6..69c71d5a7 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -32,6 +32,7 @@ class LocalDataPoolManager;
  * @ingroup data_pool
  */
 class LocalPoolDataSetBase: public PoolDataSetBase {
+	friend class LocalDataPoolManager;
 public:
 	/**
 	 * @brief	Constructor for the creator of local pool data.
@@ -97,11 +98,23 @@ public:
 	 * If this is true, all contained datasets will also be set recursively.
 	 */
 	void setValidity(bool valid, bool setEntriesRecursively);
-
 	bool isValid() const override;
 
+	void setIsDiagnostic(bool diagnostics);
+	bool getIsDiagnostics() const;
+
 protected:
 	sid_t sid;
+
+	bool isDiagnostics = false;
+
+	void setReportingEnabled(bool enabled);
+	bool getReportingEnabled() const;
+	/**
+	 * Used for periodic generation.
+	 */
+    bool reportingEnabled = false;
+
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
 	 * data set we can use this flag.
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 7107bffe9..6047342e4 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -38,13 +38,14 @@ public:
 	 * @param poolId ID of the local pool entry.
 	 * @param hkOwner Pointer of the owner. This will generally be the calling
 	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+
 	 */
 	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	/**
 	 * This constructor is used by data users like controllers to have
@@ -58,13 +59,14 @@ public:
 	 * the pool variable in that dataset directly.
 	 * @param poolId ID of the local pool entry.
 	 * @param hkOwner object ID of the pool owner.
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 *
 	 */
 	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	virtual~ LocalPoolVar() {};
 
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 6e6f27aaa..09d10acc7 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -7,8 +7,8 @@
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
-		HasLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
-		DataSetIF* dataSet):
+		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+		pool_rwm_t setReadWriteMode):
 		localPoolId(poolId),readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
@@ -27,7 +27,7 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
-		pool_rwm_t setReadWriteMode, DataSetIF *dataSet):
+		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
 		readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 86705bb0d..69df192cc 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -47,8 +47,9 @@ public:
 	 * If nullptr, the variable is not registered.
 	 */
 	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE
+			);
 
 	/**
 	 * This constructor is used by data users like controllers to have
@@ -65,8 +66,9 @@ public:
 	 * If nullptr, the variable is not registered.
 	 */
 	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE
+			);
 
 	/**
 	 * @brief	This is the local copy of the data pool entry.
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 7c3d2c1ee..2aa6fbb5f 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -7,14 +7,14 @@
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		HasLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
-		DataSetIF* dataSet) :
+		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+		pool_rwm_t setReadWriteMode):
 		localPoolId(poolId), valid(false), readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
-				"NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVector: PoolVariableIF::NO_PARAMETER passed "
+				<< "as pool ID, which is the NO_PARAMETER value!" << std::endl;
 	}
-	memset(this->value, 0, vectorSize * sizeof(T));
+	std::memset(this->value, 0, vectorSize * sizeof(T));
 	hkManager = hkOwner->getHkManagerHandle();
 	if (dataSet != nullptr) {
 		dataSet->registerVariable(this);
@@ -23,17 +23,18 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		object_id_t poolOwner, pool_rwm_t setReadWriteMode, DataSetIF *dataSet):
-		readWriteMode(readWriteMode) {
+		object_id_t poolOwner, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+		readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
-				"NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVector: PoolVariableIF::NO_PARAMETER passed "
+				<< "as pool ID, which is the NO_PARAMETER value!" << std::endl;
 	}
 	HasLocalDataPoolIF* hkOwner =
 			objectManager->get<HasLocalDataPoolIF>(poolOwner);
 	if(hkOwner == nullptr) {
-		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
-				"the correct interface HasHkPoolParametersIF!" << std::endl;
+		sif::error << "LocalPoolVariable: The supplied pool owner did not "
+				<< "implement the correct interface HasHkPoolParametersIF!"
+				<< std::endl;
 		return;
 	}
 	hkManager = hkOwner->getHkManagerHandle();
@@ -67,7 +68,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 				std::dec << " failed." << std::endl;
 		return result;
 	}
-	memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
+	std::memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
 	this->valid = poolEntry->valid;
 	return RETURN_OK;
 }
@@ -96,7 +97,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 				std::dec << " failed.\n" << std::flush;
 		return result;
 	}
-	memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
+	std::memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
 	poolEntry->valid = this->valid;
 	return RETURN_OK;
 }
diff --git a/globalfunctions/PeriodicOperationDivider.cpp b/globalfunctions/PeriodicOperationDivider.cpp
index ad3b8bbd5..28e98feba 100644
--- a/globalfunctions/PeriodicOperationDivider.cpp
+++ b/globalfunctions/PeriodicOperationDivider.cpp
@@ -7,16 +7,26 @@ PeriodicOperationDivider::PeriodicOperationDivider(uint32_t divider,
 }
 
 bool PeriodicOperationDivider::checkAndIncrement() {
-	if(counter >= divider) {
+	bool opNecessary = check();
+	if(opNecessary) {
 		if(resetAutomatically) {
 			counter = 0;
 		}
-		return true;
+		return opNecessary;
 	}
 	counter ++;
+	return opNecessary;
+}
+
+bool PeriodicOperationDivider::check() {
+	if(counter >= divider) {
+		return true;
+	}
 	return false;
 }
 
+
+
 void PeriodicOperationDivider::resetCounter() {
 	counter = 0;
 }
diff --git a/globalfunctions/PeriodicOperationDivider.h b/globalfunctions/PeriodicOperationDivider.h
index dd970fb8a..7f7fb4697 100644
--- a/globalfunctions/PeriodicOperationDivider.h
+++ b/globalfunctions/PeriodicOperationDivider.h
@@ -21,17 +21,27 @@ public:
 	 */
 	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();
 
+	/**
+	 * Checks whether an operation is necessary.
+	 * This function will not increment the counter!
+	 * @return
+	 * -@c true if the counter is larger or equal to the divider
+	 * -@c false otherwise
+	 */
+	bool check();
+
 	/**
 	 * Can be used to reset the counter to 0 manually.
 	 */
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 65ba8c94b..a3aab03a4 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -39,7 +39,7 @@ void HousekeepingMessage::setToggleReportingCommand(CommandMessage *message,
 	}
 	else {
 		if(enableReporting) {
-			message->setCommand(ENABLE_PERIODIC_HK_GENERATION);
+			message->setCommand(ENABLE_PERIODIC_HK_REPORT_GENERATION);
 		}
 		else {
 			message->setCommand(DISABLE_PERIODIC_HK_REPORT_GENERATION);
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 81fa2f02d..6a3ca6167 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -33,6 +33,14 @@ union sid_t {
 	bool notSet() const {
 	    return raw == INVALID_ADDRESS;
 	}
+
+	bool operator==(const sid_t& other) const {
+		return raw == other.raw;
+	}
+
+	bool operator!=(const sid_t& other) const {
+		return not (raw == other.raw);
+	}
 };
 
 
@@ -57,7 +65,7 @@ public:
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
 
-	static constexpr Command_t ENABLE_PERIODIC_HK_GENERATION =
+	static constexpr Command_t ENABLE_PERIODIC_HK_REPORT_GENERATION =
 			MAKE_COMMAND_ID(5);
 	static constexpr Command_t DISABLE_PERIODIC_HK_REPORT_GENERATION =
 			MAKE_COMMAND_ID(6);
diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
index 0be1551d5..ae0cc988d 100644
--- a/housekeeping/HousekeepingPacketDownlink.h
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -14,13 +14,8 @@
  */
 class HousekeepingPacketDownlink: public SerialLinkedListAdapter<SerializeIF> {
 public:
-    HousekeepingPacketDownlink(sid_t sid, /*bool reportingStatus,
-    		float collectionInterval, uint8_t numberOfParameters, */
-			LocalPoolDataSetBase* dataSetPtr):
-            sourceId(sid.objectId), setId(sid.ownerSetId),
-			/*reportingStatus(reportingStatus),
-			collectionInterval(collectionInterval),
-            numberOfParameters(numberOfParameters), */hkData(dataSetPtr) {
+    HousekeepingPacketDownlink(sid_t sid, LocalPoolDataSetBase* dataSetPtr):
+            sourceId(sid.objectId), setId(sid.ownerSetId), hkData(dataSetPtr) {
         setLinks();
     }
 
@@ -29,17 +24,10 @@ private:
         setStart(&sourceId);
         sourceId.setNext(&setId);
         setId.setNext(&hkData);
-        //setId.setNext(&reportingStatus);
-		//reportingStatus.setNext(&collectionInterval);
-        //collectionInterval.setNext(&numberOfParameters);
-        //numberOfParameters.setNext(&hkData);
     }
 
     SerializeElement<object_id_t> sourceId;
     SerializeElement<uint32_t> setId;
-    //SerializeElement<uint8_t> reportingStatus;
-    //SerializeElement<float> collectionInterval;
-    //SerializeElement<uint8_t> numberOfParameters;
     LinkedElement<SerializeIF> hkData;
 };
 
diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index e7b644f58..eebdc11cc 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -1,9 +1,9 @@
 #ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
 #define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
 
-#include <framework/serialize/SerialBufferAdapter.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/datapoollocal/LocalPoolDataSetBase.h>
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../datapoollocal/LocalPoolDataSetBase.h"
 
 /**
  * @brief   This helper class will be used to serialize and deserialize
diff --git a/housekeeping/HousekeepingSetPacket.h b/housekeeping/HousekeepingSetPacket.h
new file mode 100644
index 000000000..9a717420f
--- /dev/null
+++ b/housekeeping/HousekeepingSetPacket.h
@@ -0,0 +1,13 @@
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_
+
+#include "../serialize/SerialLinkedListAdapter.h"
+
+class HousekeepingSetPacket: public SerialLinkedListAdapter<SerializeIF> {
+
+
+};
+
+
+
+#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_ */
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index d8e4466b5..0d63a4e23 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -116,7 +116,7 @@ ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(
 		CommandMessage *command, object_id_t objectId,
 		bool enableReporting, bool isDiagnostics,
 		const uint8_t* tcData, size_t tcDataLen) {
-	if(tcDataLen < sizeof(object_id_t)) {
+	if(tcDataLen < sizeof(sid_t)) {
 		// TC data should consist of object ID and set ID.
 		return CommandingServiceBase::INVALID_TC;
 	}

From 9ecbc8199e458e6c56a91c4de91b6217d30d9ea3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 02:46:29 +0200
Subject: [PATCH 0785/1774] added periodic helper

---
 datapoollocal/LocalDataPoolManager.cpp      | 92 ++++++++++++---------
 datapoollocal/LocalDataPoolManager.h        |  3 +-
 datapoollocal/LocalPoolDataSetBase.cpp      |  3 +
 datapoollocal/LocalPoolDataSetBase.h        | 15 ++--
 housekeeping/HousekeepingSetPacket.h        | 49 ++++++++++-
 housekeeping/PeriodicHousekeepingHelper.cpp | 47 +++++++++++
 housekeeping/PeriodicHousekeepingHelper.h   | 35 ++++++++
 7 files changed, 195 insertions(+), 49 deletions(-)
 create mode 100644 housekeeping/PeriodicHousekeepingHelper.cpp
 create mode 100644 housekeeping/PeriodicHousekeepingHelper.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 17c7ad1d3..48d57a914 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/housekeeping/HousekeepingSetPacket.h>
 #include "LocalDataPoolManager.h"
 #include "LocalPoolDataSetBase.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
@@ -155,8 +156,8 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-		return generateSetStructurePacket(sid);
-
+		//return generateSetStructurePacket(sid, );
+		return HasReturnvaluesIF::RETURN_OK;
     case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
     case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
     	float newCollIntvl = 0;
@@ -274,40 +275,11 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
             SerializeIF::Endianness::MACHINE);
 }
 
-ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
-    LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-            owner->getDataSetHandle(sid));
-    if(dataSet == nullptr) {
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                " Set ID not found" << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t);
-    uint8_t* storePtr = nullptr;
-    store_address_t storeId;
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            expectedSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                "Could not get free element from IPC store." << std::endl;
-        return result;
-    }
-    size_t size = 0;
-    result = dataSet->serializeLocalPoolIds(&storePtr, &size,
-            expectedSize, SerializeIF::Endianness::BIG);
-    if(expectedSize != size) {
-        sif::error << "HousekeepingManager::generateSetStructurePacket: "
-                "Expected size is not equal to serialized size" << std::endl;
-    }
-    return result;
-}
-
 void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
         uint8_t nonDiagInvlFactor) {
     this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
 }
 
-
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
     if(receiver->intervalCounter >=
             receiver->hkParameter.collectionIntervalTicks) {
@@ -386,14 +358,56 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 		return WRONG_HK_PACKET_TYPE;
 	}
 
-	for(auto& receiver: hkReceiversMap) {
-		if(receiver.second.reportingType != ReportingType::PERIODIC) {
-			continue;
-		}
-
-		uint32_t newInterval = intervalSecondsToInterval(isDiagnostics,
-				newCollectionInterval);
-		receiver.second.hkParameter.collectionIntervalTicks = newInterval;
+	if(dataSet->periodicHelper == nullptr) {
+		// config error
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+
+	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
+//	for(auto& receiver: hkReceiversMap) {
+//		if(receiver.second.reportingType != ReportingType::PERIODIC) {
+//			continue;
+//		}
+//
+//		uint32_t newInterval = intervalSecondsToInterval(isDiagnostics,
+//				newCollectionInterval);
+//		receiver.second.hkParameter.collectionIntervalTicks = newInterval;
+//	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
+ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
+		float collectionInterval, bool isDiagnostics) {
+    LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+            owner->getDataSetHandle(sid));
+    if(dataSet == nullptr) {
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+                " Set ID not found" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    bool valid = dataSet->isValid();
+    bool targetIsDiagnostics = dataSet->getIsDiagnostics();
+    bool reportingEnabled = dataSet->getReportingEnabled();
+
+    size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t);
+    uint8_t* storePtr = nullptr;
+    store_address_t storeId;
+    HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid, reportingEnabled,
+    		valid, collectionInterval, dataSet);
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            expectedSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+                "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
+    size_t size = 0;
+    result = dataSet->serializeLocalPoolIds(&storePtr, &size,
+            expectedSize, SerializeIF::Endianness::BIG);
+    if(expectedSize != size) {
+        sif::error << "HousekeepingManager::generateSetStructurePacket: "
+                "Expected size is not equal to serialized size" << std::endl;
+    }
+    return result;
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 559b8cc20..2a5c68b52 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -114,7 +114,6 @@ public:
 	ReturnValue_t generateHousekeepingPacket(sid_t sid,
 			LocalPoolDataSetBase* dataSet, bool forDownlink,
 			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
-	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
@@ -263,6 +262,8 @@ private:
 			bool isDiagnostics);
 	ReturnValue_t changeCollectionInterval(sid_t sid,
 			float newCollectionInterval, bool isDiagnostics);
+	ReturnValue_t generateSetStructurePacket(sid_t sid,
+			float collectionInterval, bool isDiagnostics);
 };
 
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 362e8981e..e0fc6b683 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -17,6 +17,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     hkManager = hkOwner->getHkManagerHandle();
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
+
+    // Data creators get a periodic helper for periodic HK data generation.
+    periodicHelper = new PeriodicHousekeepingHelper(this);
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 69c71d5a7..2f7db9fb4 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
+#include <fsfw/housekeeping/PeriodicHousekeepingHelper.h>
 #include "HasLocalDataPoolIF.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
@@ -33,6 +34,7 @@ class LocalDataPoolManager;
  */
 class LocalPoolDataSetBase: public PoolDataSetBase {
 	friend class LocalDataPoolManager;
+	friend class PeriodicHousekeepingHelper;
 public:
 	/**
 	 * @brief	Constructor for the creator of local pool data.
@@ -100,20 +102,19 @@ public:
 	void setValidity(bool valid, bool setEntriesRecursively);
 	bool isValid() const override;
 
-	void setIsDiagnostic(bool diagnostics);
-	bool getIsDiagnostics() const;
-
 protected:
 	sid_t sid;
 
 	bool isDiagnostics = false;
+	void setIsDiagnostic(bool diagnostics);
+	bool getIsDiagnostics() const;
 
-	void setReportingEnabled(bool enabled);
-	bool getReportingEnabled() const;
 	/**
 	 * Used for periodic generation.
 	 */
-    bool reportingEnabled = false;
+	bool reportingEnabled = false;
+	void setReportingEnabled(bool enabled);
+	bool getReportingEnabled() const;
 
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
@@ -147,7 +148,7 @@ protected:
 	void bitSetter(uint8_t* byte, uint8_t position) const;
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 private:
-
+	PeriodicHousekeepingHelper* periodicHelper = nullptr;
 
 };
 
diff --git a/housekeeping/HousekeepingSetPacket.h b/housekeeping/HousekeepingSetPacket.h
index 9a717420f..007b95be7 100644
--- a/housekeeping/HousekeepingSetPacket.h
+++ b/housekeeping/HousekeepingSetPacket.h
@@ -1,13 +1,58 @@
 #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_
 
+#include "../housekeeping/HousekeepingMessage.h"
 #include "../serialize/SerialLinkedListAdapter.h"
+#include "../datapoollocal/LocalPoolDataSetBase.h"
 
 class HousekeepingSetPacket: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	HousekeepingSetPacket(sid_t sid, bool reportingEnabled, bool valid,
+			float collectionInterval, LocalPoolDataSetBase* dataSetPtr):
+			objectId(sid.objectId), setId(sid.ownerSetId),
+			reportingEnabled(reportingEnabled), valid(valid),
+			collectionIntervalSeconds(collectionInterval), dataSet(dataSetPtr) {
+	}
 
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const override {
+		ReturnValue_t result = SerialLinkedListAdapter::serialize(buffer, size,
+				maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return dataSet->serializeLocalPoolIds(buffer, size ,maxSize,
+				streamEndianness);
+	}
 
+	size_t getSerializedSize() const override {
+		size_t linkedSize = SerialLinkedListAdapter::getSerializedSize();
+		linkedSize += dataSet->getFillCount() * sizeof(lp_id_t);
+		return linkedSize;
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+private:
+
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&setId);
+		setId.setNext(&reportingEnabled);
+		reportingEnabled.setNext(&valid);
+		valid.setNext(&collectionIntervalSeconds);
+		collectionIntervalSeconds.setEnd();
+	}
+
+	SerializeElement<object_id_t> objectId;
+	SerializeElement<uint32_t> setId;
+	SerializeElement<bool> reportingEnabled;
+	SerializeElement<bool> valid;
+	SerializeElement<float> collectionIntervalSeconds;
+	LocalPoolDataSetBase* dataSet;
 };
 
-
-
 #endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_ */
diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
new file mode 100644
index 000000000..c2ae8126f
--- /dev/null
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -0,0 +1,47 @@
+#include "../datapoollocal/LocalPoolDataSetBase.h"
+#include "PeriodicHousekeepingHelper.h"
+#include <cmath>
+
+PeriodicHousekeepingHelper::PeriodicHousekeepingHelper(
+		LocalPoolDataSetBase* owner): owner(owner) {}
+
+
+void PeriodicHousekeepingHelper::initialize(float collectionInterval,
+		dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
+		uint8_t nonDiagIntervalFactor) {
+	this->minimumPeriodicInterval = minimumPeriodicInterval;
+	if(not owner->getIsDiagnostics()) {
+		this->minimumPeriodicInterval = this->minimumPeriodicInterval *
+				nonDiagIntervalFactor;
+	}
+}
+
+float PeriodicHousekeepingHelper::getCollectionIntervalInSeconds() {
+	return intervalToIntervalSeconds(collectionIntervalTicks);
+}
+
+bool PeriodicHousekeepingHelper::checkOpNecessary() {
+	if(internalTickCounter >= collectionIntervalTicks) {
+		internalTickCounter = 1;
+		return true;
+	}
+	internalTickCounter++;
+	return false;
+}
+
+uint32_t PeriodicHousekeepingHelper::intervalSecondsToInterval(
+		float collectionIntervalSeconds) {
+        return std::ceil(collectionIntervalSeconds * 1000
+                / minimumPeriodicInterval);
+}
+
+float PeriodicHousekeepingHelper::intervalToIntervalSeconds(
+		uint32_t collectionInterval) {
+	return static_cast<float>(collectionInterval *
+			minimumPeriodicInterval);
+}
+
+void PeriodicHousekeepingHelper::changeCollectionInterval(
+		float newIntervalSeconds) {
+	collectionIntervalTicks = intervalSecondsToInterval(newIntervalSeconds);
+}
diff --git a/housekeeping/PeriodicHousekeepingHelper.h b/housekeeping/PeriodicHousekeepingHelper.h
new file mode 100644
index 000000000..982e8cf6c
--- /dev/null
+++ b/housekeeping/PeriodicHousekeepingHelper.h
@@ -0,0 +1,35 @@
+#ifndef FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_
+#define FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_
+
+#include "../timemanager/Clock.h"
+#include <cstdint>
+
+class LocalPoolDataSetBase;
+
+class PeriodicHousekeepingHelper {
+public:
+	PeriodicHousekeepingHelper(LocalPoolDataSetBase* owner);
+
+	void initialize(float collectionInterval,
+			dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
+			uint8_t nonDiagIntervalFactor);
+
+	void changeCollectionInterval(float newInterval);
+	float getCollectionIntervalInSeconds();
+	bool checkOpNecessary();
+private:
+	LocalPoolDataSetBase* owner = nullptr;
+
+
+	uint32_t intervalSecondsToInterval(float collectionIntervalSeconds);
+	float intervalToIntervalSeconds(uint32_t collectionInterval);
+
+	dur_millis_t minimumPeriodicInterval = 0;
+	uint32_t internalTickCounter = 1;
+	uint32_t collectionIntervalTicks = 0;
+
+};
+
+
+
+#endif /* FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_ */

From 32c0140cc24c2aee082abf777f9bcda65b6ba43c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 15:58:34 +0200
Subject: [PATCH 0786/1774] hk stuff continued

---
 container/ArrayList.h                       |   6 +-
 container/FixedMap.h                        |   9 +
 datapoollocal/HasLocalDataPoolIF.h          |   5 +-
 datapoollocal/LocalDataPoolManager.cpp      | 199 ++++++++------------
 datapoollocal/LocalDataPoolManager.h        |  72 +++----
 datapoollocal/LocalPoolDataSetBase.cpp      |  48 +++--
 datapoollocal/LocalPoolDataSetBase.h        |  32 +++-
 datapoollocal/StaticLocalDataSet.h          |  18 ++
 devicehandlers/DeviceHandlerBase.cpp        |   8 +-
 devicehandlers/DeviceHandlerBase.h          |  11 +-
 housekeeping/HousekeepingMessage.h          |  11 +-
 housekeeping/PeriodicHousekeepingHelper.cpp |   3 +-
 housekeeping/PeriodicHousekeepingHelper.h   |   3 -
 pus/Service3Housekeeping.cpp                |   2 +-
 tmtcservices/CommandingServiceBase.cpp      |   8 +-
 tmtcservices/VerificationReporter.cpp       |   8 +-
 16 files changed, 235 insertions(+), 208 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index bda604332..ae9831711 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -140,7 +140,11 @@ public:
 
         //SHOULDDO this should be implemented as non-member
         bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
-            return !(*this == other);
+        	// POSSIBLY BUGGY ! Also this is really confusing. Why does
+        	// the operator above use the value while this one
+        	// dereferences itself?
+        	//return not (value == other.value);
+        	return !(*this == other);
         }
     };
 
diff --git a/container/FixedMap.h b/container/FixedMap.h
index 475d4091f..e5fbb3be6 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -143,6 +143,15 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+	bool empty() {
+		if(_size == 0) {
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
     bool full() {
         if(_size >= theMap.maxSize()) {
             return true;
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 4b49ee119..e078f01e0 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -9,7 +9,8 @@
 #include <map>
 
 class LocalDataPoolManager;
-class DataSetIF;
+class LocalPoolDataSetBase;
+
 /**
  * @brief	Type definition for local pool entries.
  */
@@ -76,7 +77,7 @@ public:
 	 * @param sid Corresponding structure ID
 	 * @return
 	 */
-	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
 
 	/* These function can be implemented by pool owner, as they are required
 	 * by the housekeeping message interface */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 48d57a914..f9a64777a 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -56,9 +56,6 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
 ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
         uint8_t nonDiagInvlFactor) {
     setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
-    diagnosticMinimumInterval = owner->getPeriodicOperationFrequency();
-    regularMinimumInterval = diagnosticMinimumInterval *
-            nonDiagnosticIntervalFactor;
     return initializeHousekeepingPoolEntriesOnce();
 }
 
@@ -77,12 +74,12 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
-    for(auto& hkReceiversIter: hkReceiversMap) {
-        HkReceiver* receiver = &hkReceiversIter.second;
+    for(auto& receiver: hkReceiversMap) {
+        //HkReceiver* receiver = &hkReceiversIter.second;
 
-        switch(receiver->reportingType) {
+        switch(receiver.reportingType) {
         case(ReportingType::PERIODIC): {
-            if(receiver->dataId.dataSetSid.notSet()) {
+            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
                 // Periodic packets shall only be generated from datasets.
                 continue;
             }
@@ -113,30 +110,19 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	}
 
 	struct HkReceiver hkReceiver;
-	hkReceiver.dataId.dataSetSid = sid;
+	hkReceiver.dataId.sid = sid;
 	hkReceiver.reportingType = ReportingType::PERIODIC;
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-	if(not isDiagnostics) {
-	    hkReceiver.hkParameter.collectionIntervalTicks =
-	            intervalSecondsToInterval(isDiagnostics, collectionInterval *
-	            nonDiagnosticIntervalFactor);
-	}
-	else {
-	    hkReceiver.hkParameter.collectionIntervalTicks =
-	            intervalSecondsToInterval(isDiagnostics, collectionInterval);
-	}
-
-	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-	            owner->getDataSetHandle(sid));
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	if(dataSet != nullptr) {
 		dataSet->setReportingEnabled(enableReporting);
-		dataSet->setIsDiagnostic(isDiagnostics);
+		dataSet->setDiagnostic(isDiagnostics);
+		dataSet->initializePeriodicHelper(collectionInterval,
+				owner->getPeriodicOperationFrequency(), isDiagnostics);
 	}
 
-	hkReceiver.intervalCounter = 1;
-
-	hkReceiversMap.emplace(packetDestination, hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -153,7 +139,6 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		return togglePeriodicGeneration(sid, true, false);
     case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION):
 		return togglePeriodicGeneration(sid, false, false);
-
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
 		//return generateSetStructurePacket(sid, );
@@ -174,14 +159,13 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
     case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
-    	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-    			owner->getDataSetHandle(sid));
+    	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     	if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
-    			and dataSet->getIsDiagnostics()) {
+    			and dataSet->isDiagnostics()) {
     		return WRONG_HK_PACKET_TYPE;
     	}
     	else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
-    			and not dataSet->getIsDiagnostics()) {
+    			and not dataSet->isDiagnostics()) {
     		return WRONG_HK_PACKET_TYPE;
     	}
     	return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
@@ -234,7 +218,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
 	// and now we set a HK message and send it the HK packet destination.
 	CommandMessage hkMessage;
-	if(dataSet->getIsDiagnostics()) {
+	if(dataSet->isDiagnostics()) {
 		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
 	}
 	else {
@@ -280,62 +264,40 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
     this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
 }
 
-void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
-    if(receiver->intervalCounter >=
-            receiver->hkParameter.collectionIntervalTicks) {
-    	sid_t sid = receiver->dataId.dataSetSid;
-    	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-    			owner->getDataSetHandle(sid));
-    	if(not dataSet->getReportingEnabled()) {
-    		return;
-    	}
+void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
+	sid_t sid = receiver.dataId.sid;
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(not dataSet->getReportingEnabled()) {
+		return;
+	}
 
-        ReturnValue_t result = generateHousekeepingPacket(
-                sid, dataSet, true);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            // configuration error
-            sif::debug << "LocalDataPoolManager::performHkOperation:"
-                    << "0x" << std::setfill('0') << std::setw(8)
-                    << owner->getObjectId() << " Error generating "
-                    << "HK packet" << std::setfill(' ') << std::endl;
-        }
-        receiver->intervalCounter = 1;
-    }
-    else {
-        receiver->intervalCounter++;
-    }
+	if(dataSet->periodicHelper == nullptr) {
+		// Configuration error.
+		return;
+	}
+
+	if(not dataSet->periodicHelper->checkOpNecessary()) {
+		return;
+	}
+
+	ReturnValue_t result = generateHousekeepingPacket(
+			sid, dataSet, true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		// configuration error
+		sif::debug << "LocalDataPoolManager::performHkOperation:"
+				<< "0x" << std::setfill('0') << std::setw(8)
+		<< owner->getObjectId() << " Error generating "
+		<< "HK packet" << std::setfill(' ') << std::endl;
+	}
 }
 
-uint32_t LocalDataPoolManager::intervalSecondsToInterval(bool isDiagnostics,
-        float collectionIntervalSeconds) {
-    if(isDiagnostics) {
-        return std::ceil(collectionIntervalSeconds * 1000
-                /diagnosticMinimumInterval);
-    }
-    else {
-        return std::ceil(collectionIntervalSeconds * 1000
-                /regularMinimumInterval);
-    }
-}
-
-float LocalDataPoolManager::intervalToIntervalSeconds(bool isDiagnostics,
-        uint32_t collectionInterval) {
-    if(isDiagnostics) {
-        return static_cast<float>(collectionInterval *
-        		diagnosticMinimumInterval);
-    }
-    else {
-        return static_cast<float>(collectionInterval *
-                regularMinimumInterval);
-    }
-}
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
 		bool enable, bool isDiagnostics) {
 	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
 			owner->getDataSetHandle(sid));
-	if((dataSet->getIsDiagnostics() and not isDiagnostics) or
-			(not dataSet->getIsDiagnostics() and isDiagnostics)) {
+	if((dataSet->isDiagnostics() and not isDiagnostics) or
+			(not dataSet->isDiagnostics() and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
 	}
 
@@ -352,7 +314,7 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 		float newCollectionInterval, bool isDiagnostics) {
 	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
 				owner->getDataSetHandle(sid));
-	bool targetIsDiagnostics = dataSet->getIsDiagnostics();
+	bool targetIsDiagnostics = dataSet->isDiagnostics();
 	if((targetIsDiagnostics and not isDiagnostics) or
 			(not targetIsDiagnostics and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
@@ -364,50 +326,49 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 	}
 
 	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
-//	for(auto& receiver: hkReceiversMap) {
-//		if(receiver.second.reportingType != ReportingType::PERIODIC) {
-//			continue;
-//		}
-//
-//		uint32_t newInterval = intervalSecondsToInterval(isDiagnostics,
-//				newCollectionInterval);
-//		receiver.second.hkParameter.collectionIntervalTicks = newInterval;
-//	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
-		float collectionInterval, bool isDiagnostics) {
-    LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-            owner->getDataSetHandle(sid));
-    if(dataSet == nullptr) {
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                " Set ID not found" << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+		bool isDiagnostics) {
+	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+			owner->getDataSetHandle(sid));
+	if(dataSet == nullptr) {
+		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+				" Set ID not found" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
 
-    bool valid = dataSet->isValid();
-    bool targetIsDiagnostics = dataSet->getIsDiagnostics();
-    bool reportingEnabled = dataSet->getReportingEnabled();
+	bool targetIsDiagnostics = dataSet->isDiagnostics();
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t);
-    uint8_t* storePtr = nullptr;
-    store_address_t storeId;
-    HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid, reportingEnabled,
-    		valid, collectionInterval, dataSet);
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            expectedSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                "Could not get free element from IPC store." << std::endl;
-        return result;
-    }
-    size_t size = 0;
-    result = dataSet->serializeLocalPoolIds(&storePtr, &size,
-            expectedSize, SerializeIF::Endianness::BIG);
-    if(expectedSize != size) {
-        sif::error << "HousekeepingManager::generateSetStructurePacket: "
-                "Expected size is not equal to serialized size" << std::endl;
-    }
-    return result;
+	bool valid = dataSet->isValid();
+	bool reportingEnabled = dataSet->getReportingEnabled();
+	float collectionInterval =
+			dataSet->periodicHelper->getCollectionIntervalInSeconds();
+
+	HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid,
+			reportingEnabled, valid, collectionInterval, dataSet);
+	size_t expectedSize = setPacket.getSerializedSize();
+	uint8_t* storePtr = nullptr;
+	store_address_t storeId;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			expectedSize,&storePtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+				"Could not get free element from IPC store." << std::endl;
+		return result;
+	}
+
+	size_t size = 0;
+	result = setPacket.serialize(&storePtr, &size, expectedSize,
+			SerializeIF::Endianness::BIG);
+	if(expectedSize != size) {
+		sif::error << "HousekeepingManager::generateSetStructurePacket: "
+				"Expected size is not equal to serialized size" << std::endl;
+	}
+	return result;
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 2a5c68b52..505b9b1a0 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -5,6 +5,7 @@
 
 #include "../housekeeping/HousekeepingPacketDownlink.h"
 #include "../housekeeping/HousekeepingMessage.h"
+#include "../housekeeping/PeriodicHousekeepingHelper.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
 #include "../objectmanager/SystemObjectIF.h"
@@ -131,16 +132,15 @@ public:
 
     /**
      * Different types of housekeeping reporting are possible.
-     *  1. PERIODIC: HK packets are generated in fixed intervals and sent to
+     *  1. PERIODIC:
+     *     HK packets are generated in fixed intervals and sent to
      *     destination. Fromat will be raw.
-     *  2. UPDATED: Notification will be sent out if HK data has changed.
-     *     Question: Send Raw data directly or just the message?
-     *  3. REQUESTED: HK packets are only generated if explicitely requested.
+     *  2. UPDATE_NOTIFICATION:
+     *     Notification will be sent out if HK data has changed.
+     *  3. UPDATE_SNAPSHOT:
+     *     HK packets are only generated if explicitely requested.
      *     Propably not necessary, just use multiple local data sets or
      *     shared datasets.
-     *
-     *  Notifications should also be possible for single variables instead of
-     *  full dataset updates.
      */
     enum class ReportingType: uint8_t {
         //! Periodic generation of HK packets.
@@ -152,6 +152,17 @@ public:
         UPDATE_SNAPSHOT,
     };
 
+    /**
+     * Different data types are possible in the HK receiver map.
+     * For example, updates can be requested for full datasets or
+     * for single pool variables. Periodic reporting is only possible for
+     * data sets.
+     */
+    enum class DataType: uint8_t {
+    	LOCAL_POOL_VARIABLE,
+		DATA_SET
+    };
+
     /* Copying forbidden */
     LocalDataPoolManager(const LocalDataPoolManager &) = delete;
     LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
@@ -165,8 +176,6 @@ private:
     HasLocalDataPoolIF* owner = nullptr;
 
     uint8_t nonDiagnosticIntervalFactor = 0;
-    dur_millis_t regularMinimumInterval = 0;
-    dur_millis_t diagnosticMinimumInterval = 0;
 
 	/** Default receiver for periodic HK packets */
 	static object_id_t defaultHkDestination;
@@ -174,40 +183,25 @@ private:
 
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
-        /** Different member of this union will be used depending on the
-        type of data the receiver is interested in (full datasets or
-        single data variables. */
+		/** Object ID of receiver */
+		object_id_t objectId = objects::NO_OBJECT;
+
+		DataType dataType = DataType::DATA_SET;
         union DataId {
-        	DataId(): dataSetSid() {}
-            /** Will be initialized to INVALID_ADDRESS */
-            sid_t dataSetSid;
-            lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
+			DataId(): sid() {};
+            sid_t sid;
+            lp_id_t localPoolId;
         };
         DataId dataId;
 
         ReportingType reportingType = ReportingType::PERIODIC;
-        // SHOULDDO: it would be nice to also have the object ID instead of
-        // a queue (or in addition).. but the FSFW is not ready  for that yet.
-        // Also, an object can have multiple queues.
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
-
-        /** Different members of this union will be used depending on reporting
-        type */
-        union HkParameter {
-            /** This parameter will be used for the PERIODIC type */
-            uint32_t collectionIntervalTicks = 0;
-            /** This parameter will be used for the ON_UPDATE type */
-            bool hkDataChanged;
-        };
-        HkParameter hkParameter;
-        /** General purpose counter which is used for periodic generation. */
-        uint32_t intervalCounter;
     };
 
-    /** Using a multimap as the same object might request multiple datasets */
-    using HkReceiversMap = std::multimap<object_id_t, struct HkReceiver>;
+    /** This vector will contain the list of HK receivers. */
+    using HkReceivers = std::vector<struct HkReceiver>;
 
-    HkReceiversMap hkReceiversMap;
+    HkReceivers hkReceiversMap;
 
     /** This is the map holding the actual data. Should only be initialized
      * once ! */
@@ -252,18 +246,12 @@ private:
 	        HousekeepingPacketDownlink& hkPacket,
 	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
 
-	uint32_t intervalSecondsToInterval(bool isDiagnostics,
-	        float collectionIntervalSeconds);
-	float intervalToIntervalSeconds(bool isDiagnostics,
-	        uint32_t collectionInterval);
-
-	void performPeriodicHkGeneration(HkReceiver* hkReceiver);
+	void performPeriodicHkGeneration(HkReceiver& hkReceiver);
 	ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable,
 			bool isDiagnostics);
 	ReturnValue_t changeCollectionInterval(sid_t sid,
 			float newCollectionInterval, bool isDiagnostics);
-	ReturnValue_t generateSetStructurePacket(sid_t sid,
-			float collectionInterval, bool isDiagnostics);
+	ReturnValue_t generateSetStructurePacket(sid_t sid, bool isDiagnostics);
 };
 
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index e0fc6b683..6832005bf 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -1,5 +1,6 @@
 #include "LocalPoolDataSetBase.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
+#include "../housekeeping/PeriodicHousekeepingHelper.h"
 #include "../serialize/SerializeAdapter.h"
 
 #include <cmath>
@@ -7,13 +8,14 @@
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 		uint32_t setId, PoolVariableIF** registeredVariablesArray,
-        const size_t maxNumberOfVariables):
-        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
+		const size_t maxNumberOfVariables):
+		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+	if(hkOwner == nullptr) {
+		// Configuration error.
+		sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+				<< "invalid!" << std::endl;
+		return;
+	}
     hkManager = hkOwner->getHkManagerHandle();
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
@@ -29,8 +31,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
     if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
+    	// Configuration error.
+        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+        		<< "invalid!" << std::endl;
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
@@ -178,12 +181,12 @@ void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     *byte |= 1 << shiftNumber;
 }
 
-void LocalPoolDataSetBase::setIsDiagnostic(bool isDiagnostics) {
-	this->isDiagnostics = isDiagnostics;
+void LocalPoolDataSetBase::setDiagnostic(bool isDiagnostics) {
+	this->diagnostic = isDiagnostics;
 }
 
-bool LocalPoolDataSetBase::getIsDiagnostics() const {
-	return isDiagnostics;
+bool LocalPoolDataSetBase::isDiagnostics() const {
+	return diagnostic;
 }
 
 void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
@@ -194,6 +197,25 @@ bool LocalPoolDataSetBase::getReportingEnabled() const {
 	return reportingEnabled;
 }
 
+void LocalPoolDataSetBase::initializePeriodicHelper(
+		float collectionInterval, dur_millis_t minimumPeriodicInterval,
+		bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
+	periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
+			isDiagnostics, nonDiagIntervalFactor);
+}
+
+void LocalPoolDataSetBase::setChanged(bool changed) {
+	this->changed = changed;
+}
+
+bool LocalPoolDataSetBase::isChanged() const {
+	return changed;
+}
+
+sid_t LocalPoolDataSetBase::getSid() const {
+	return sid;
+}
+
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 		uint8_t position) const {
     if(position > 7) {
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 2f7db9fb4..1b58a211b 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
-#include <fsfw/housekeeping/PeriodicHousekeepingHelper.h>
+
 #include "HasLocalDataPoolIF.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
@@ -10,6 +10,7 @@
 #include <vector>
 
 class LocalDataPoolManager;
+class PeriodicHousekeepingHelper;
 
 /**
  * @brief	The LocalDataSet class manages a set of locally checked out
@@ -38,14 +39,16 @@ class LocalPoolDataSetBase: public PoolDataSetBase {
 public:
 	/**
 	 * @brief	Constructor for the creator of local pool data.
+	 * @details
+	 * This constructor also initializes the components required for
+	 * periodic handling.
 	 */
 	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 			uint32_t setId, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
 	/**
-	 * @brief	Constructor for users of local pool data. The passed pool
-	 * 			owner should implement the HasHkPoolParametersIF.
+	 * @brief	Constructor for users of local pool data.
 	 * @details
 	 * @param sid Unique identifier of dataset consisting of object ID and
 	 * set ID.
@@ -67,6 +70,8 @@ public:
 
 	void setValidityBufferGeneration(bool withValidityBuffer);
 
+	sid_t getSid() const;
+
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
 	            SerializeIF::Endianness streamEndianness) const override;
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
@@ -102,12 +107,15 @@ public:
 	void setValidity(bool valid, bool setEntriesRecursively);
 	bool isValid() const override;
 
+	void setChanged(bool changed);
+	bool isChanged() const;
+
 protected:
 	sid_t sid;
 
-	bool isDiagnostics = false;
-	void setIsDiagnostic(bool diagnostics);
-	bool getIsDiagnostics() const;
+	bool diagnostic = false;
+	void setDiagnostic(bool diagnostics);
+	bool isDiagnostics() const;
 
 	/**
 	 * Used for periodic generation.
@@ -116,12 +124,22 @@ protected:
 	void setReportingEnabled(bool enabled);
 	bool getReportingEnabled() const;
 
+	void initializePeriodicHelper(float collectionInterval,
+			dur_millis_t minimumPeriodicInterval,
+			bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5);
+
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
 	 * data set we can use this flag.
 	 */
 	bool valid = false;
 
+	/**
+	 * Can be used to mark the dataset as changed, which is used
+	 * by the LocalDataPoolManager to send out update messages.
+	 */
+	bool changed = false;
+
 	bool withValidityBuffer = true;
 
 	/**
@@ -147,7 +165,7 @@ protected:
 	 */
 	void bitSetter(uint8_t* byte, uint8_t position) const;
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
-private:
+
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
 
 };
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index 7c2f0039c..2f3068980 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -17,6 +17,24 @@
 template <uint8_t NUM_VARIABLES>
 class StaticLocalDataSet: public LocalPoolDataSetBase {
 public:
+	/**
+	 * Constructor used by data owner and creator like device handlers.
+	 * This constructor also initialized the components required for
+	 * periodic handling.
+	 * @param hkOwner
+	 * @param setId
+	 */
+    StaticLocalDataSet(HasLocalDataPoolIF* hkOwner,
+    		uint32_t setId): LocalPoolDataSetBase(hkOwner, setId, nullptr,
+            NUM_VARIABLES) {
+        this->setContainer(poolVarList.data());
+    }
+
+	/**
+	 * Constructor used by data users like controllers.
+	 * @param hkOwner
+	 * @param setId
+	 */
     StaticLocalDataSet(sid_t sid): LocalPoolDataSetBase(sid, nullptr,
             NUM_VARIABLES) {
         this->setContainer(poolVarList.data());
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 0a3aec6da..227d5b6dc 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -391,7 +391,7 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 
 ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
 		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-		PoolDataSetIF* replyDataSet, size_t replyLen, bool periodic,
+		LocalPoolDataSetBase* replyDataSet, size_t replyLen, bool periodic,
 		bool hasDifferentReplyId, DeviceCommandId_t replyId) {
 	//No need to check, as we may try to insert multiple times.
 	insertInCommandMap(deviceCommand);
@@ -405,7 +405,7 @@ ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, PoolDataSetIF* dataSet,
+		uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet,
 		size_t replyLen, bool periodic) {
 	DeviceReplyInfo info;
 	info.maxDelayCycles = maxDelayCycles;
@@ -455,7 +455,7 @@ ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceRep
 
 
 ReturnValue_t DeviceHandlerBase::setReplyDataset(DeviceCommandId_t replyId,
-        PoolDataSetIF *dataSet) {
+        LocalPoolDataSetBase *dataSet) {
     auto replyIter = deviceReplyMap.find(replyId);
     if(replyIter == deviceReplyMap.end()) {
         return HasReturnvaluesIF::RETURN_FAILED;
@@ -1396,7 +1396,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
+LocalPoolDataSetBase* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
 	auto iter = deviceReplyMap.find(sid.ownerSetId);
 	if(iter != deviceReplyMap.end()) {
 		return iter->second.dataSet;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 752f73521..8f1b135b5 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -389,7 +389,8 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, PoolDataSetIF* replyDataSet = nullptr,
+			uint16_t maxDelayCycles,
+			LocalPoolDataSetBase* replyDataSet = nullptr,
 			size_t replyLen = 0, bool periodic = false,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
@@ -404,7 +405,7 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, PoolDataSetIF* dataSet = nullptr,
+			uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet = nullptr,
 			size_t replyLen = 0, bool periodic = false);
 
 	/**
@@ -434,7 +435,7 @@ protected:
 			bool periodic = false);
 
 	ReturnValue_t setReplyDataset(DeviceCommandId_t replyId,
-	        PoolDataSetIF* dataset);
+	        LocalPoolDataSetBase* dataset);
 
 	/**
 	 * @brief   Can be implemented by child handler to
@@ -663,7 +664,7 @@ protected:
 		//! 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)
-		PoolDataSetIF* dataSet = nullptr;
+		LocalPoolDataSetBase* dataSet;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -1198,7 +1199,7 @@ private:
 
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
-	virtual DataSetIF* getDataSetHandle(sid_t sid) override;
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
 
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 6a3ca6167..e2e894b44 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -3,14 +3,15 @@
 
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
+#include "../objectmanager/frameworkObjects.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include <limits>
 
 union sid_t {
-	static constexpr uint64_t INVALID_ADDRESS =
-			std::numeric_limits<uint64_t>::max();
-	sid_t(): raw(INVALID_ADDRESS) {}
+	static constexpr uint64_t INVALID_SID = -1;
+	static constexpr uint32_t INVALID_SET_ID = -1;
+	static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+	sid_t(): raw(INVALID_SID) {}
 
 	sid_t(object_id_t objectId, uint32_t setId):
 			objectId(objectId),
@@ -31,7 +32,7 @@ union sid_t {
 	uint64_t raw;
 
 	bool notSet() const {
-	    return raw == INVALID_ADDRESS;
+	    return raw == INVALID_SID;
 	}
 
 	bool operator==(const sid_t& other) const {
diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
index c2ae8126f..d184489b5 100644
--- a/housekeeping/PeriodicHousekeepingHelper.cpp
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -10,10 +10,11 @@ void PeriodicHousekeepingHelper::initialize(float collectionInterval,
 		dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
 		uint8_t nonDiagIntervalFactor) {
 	this->minimumPeriodicInterval = minimumPeriodicInterval;
-	if(not owner->getIsDiagnostics()) {
+	if(isDiagnostics) {
 		this->minimumPeriodicInterval = this->minimumPeriodicInterval *
 				nonDiagIntervalFactor;
 	}
+	collectionIntervalTicks = intervalSecondsToInterval(collectionInterval);
 }
 
 float PeriodicHousekeepingHelper::getCollectionIntervalInSeconds() {
diff --git a/housekeeping/PeriodicHousekeepingHelper.h b/housekeeping/PeriodicHousekeepingHelper.h
index 982e8cf6c..d96eae1d4 100644
--- a/housekeeping/PeriodicHousekeepingHelper.h
+++ b/housekeeping/PeriodicHousekeepingHelper.h
@@ -20,7 +20,6 @@ public:
 private:
 	LocalPoolDataSetBase* owner = nullptr;
 
-
 	uint32_t intervalSecondsToInterval(float collectionIntervalSeconds);
 	float intervalToIntervalSeconds(uint32_t collectionInterval);
 
@@ -30,6 +29,4 @@ private:
 
 };
 
-
-
 #endif /* FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_ */
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index 0d63a4e23..ebfa4be99 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -6,7 +6,7 @@
 Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid,
 			uint8_t serviceId):
 		CommandingServiceBase(objectId, apid, serviceId,
-		NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {}
+		NUM_OF_PARALLEL_COMMANDS, 5) {}
 
 Service3Housekeeping::~Service3Housekeeping() {}
 
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 4cead0e97..3a2047037 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -387,7 +387,7 @@ void CommandingServiceBase::acceptPacket(uint8_t reportId,
 void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
 	store_address_t address;
 	if (iter->second.fifo.retrieve(&address) != RETURN_OK) {
-		commandMap.erase(&iter);
+		commandMap.erase(iter->first);
 	} else {
 		TcPacketStored newPacket(address);
 		startExecution(&newPacket, iter);
@@ -411,8 +411,14 @@ void CommandingServiceBase::checkTimeout() {
 	uint32_t uptime;
 	Clock::getUptime(&uptime);
 	CommandMapIter iter;
+	// TODO: BUG HERE! Problems with comparison operator of iterator.
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
+		if(commandMap.empty()) {
+			// intermediate solution.
+			break;
+		}
 		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
+			sif::info << "test" << std::endl;
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 4f9f4e54e..0c53e1a4d 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -63,8 +63,8 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendFailureReport Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
+		sif::error << "VerificationReporter::sendFailureReport: Error writing "
+				<< "to queue. Code: " << std::hex  << "0x" << status << std::dec
 				<< std::endl;
 	}
 }
@@ -81,8 +81,8 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendFailureReport Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
+		sif::error << "VerificationReporter::sendFailureReport: Error writing "
+				<< "to queue. Code: " << std::hex << "0x" << status << std::dec
 				<< std::endl;
 	}
 }

From 4ab7a0838702698e23590c636b93f375103688f8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 17:08:08 +0200
Subject: [PATCH 0787/1774] srv3 continued

---
 datapoollocal/LocalDataPoolManager.cpp | 45 +++++++++++++++++++-------
 housekeeping/HousekeepingMessage.cpp   | 21 ++++++++++++
 housekeeping/HousekeepingMessage.h     |  6 ++++
 pus/Service3Housekeeping.cpp           |  8 ++---
 tmtcservices/CommandingServiceBase.cpp |  3 +-
 5 files changed, 65 insertions(+), 18 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f9a64777a..20d6451d5 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -130,15 +130,28 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		CommandMessage* message) {
     Command_t command = message->getCommand();
     sid_t sid = HousekeepingMessage::getSid(message);
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     switch(command) {
-    case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION):
-    	return togglePeriodicGeneration(sid, true, true);
-    case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION):
-		return togglePeriodicGeneration(sid, false, true);
-    case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION):
-		return togglePeriodicGeneration(sid, true, false);
-    case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION):
-		return togglePeriodicGeneration(sid, false, false);
+    case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+    	result = togglePeriodicGeneration(sid, true, true);
+    	break;
+    }
+
+    case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+    	result = togglePeriodicGeneration(sid, false, true);
+    	break;
+    }
+
+    case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
+    	result = togglePeriodicGeneration(sid, true, false);
+    	break;
+    }
+
+    case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
+    	result = togglePeriodicGeneration(sid, false, false);
+    	break;
+    }
+
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
 		//return generateSetStructurePacket(sid, );
@@ -175,6 +188,16 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     default:
         return CommandMessageIF::UNKNOWN_COMMAND;
     }
+
+    CommandMessage reply;
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
+	}
+	else {
+		HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
+	}
+	hkQueue->sendMessage(hkDestinationId, &reply);
+	return result;
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
@@ -294,8 +317,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
 		bool enable, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-			owner->getDataSetHandle(sid));
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	if((dataSet->isDiagnostics() and not isDiagnostics) or
 			(not dataSet->isDiagnostics() and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
@@ -312,8 +334,7 @@ ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 		float newCollectionInterval, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-				owner->getDataSetHandle(sid));
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	bool targetIsDiagnostics = dataSet->isDiagnostics();
 	if((targetIsDiagnostics and not isDiagnostics) or
 			(not targetIsDiagnostics and isDiagnostics)) {
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index a3aab03a4..254750720 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -96,6 +96,27 @@ sid_t HousekeepingMessage::getCollectionIntervalModificationCommand(
 	return getSid(command);
 }
 
+void HousekeepingMessage::setHkRequestSuccessReply(CommandMessage *reply,
+		sid_t sid) {
+	setSid(reply, sid);
+	reply->setCommand(HK_REQUEST_SUCCESS);
+}
+
+void HousekeepingMessage::setHkRequestFailureReply(CommandMessage *reply,
+		sid_t sid, ReturnValue_t error) {
+	setSid(reply, sid);
+	reply->setCommand(HK_REQUEST_FAILURE);
+	reply->setParameter3(error);
+}
+
+sid_t HousekeepingMessage::getHkRequestFailureReply(const CommandMessage *reply,
+		ReturnValue_t *error) {
+	if(error != nullptr) {
+		*error = reply->getParameter3();
+	}
+	return getSid(reply);
+}
+
 sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 	sid_t sid;
 	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index e2e894b44..5c1b4e55c 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -118,6 +118,12 @@ public:
 	static void setHkDiagnosticsReply(CommandMessage* reply, sid_t sid,
 			store_address_t storeId);
 
+	static void setHkRequestSuccessReply(CommandMessage* reply, sid_t sid);
+	static void setHkRequestFailureReply(CommandMessage* reply, sid_t sid,
+			ReturnValue_t error);
+	static sid_t getHkRequestFailureReply(const CommandMessage* reply,
+			ReturnValue_t* error);
+
 	/**
 	 * @brief	Generic getter function for housekeeping data replies
 	 * @details
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index ebfa4be99..ad08c3280 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -6,7 +6,7 @@
 Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid,
 			uint8_t serviceId):
 		CommandingServiceBase(objectId, apid, serviceId,
-		NUM_OF_PARALLEL_COMMANDS, 5) {}
+		NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {}
 
 Service3Housekeeping::~Service3Housekeeping() {}
 
@@ -204,9 +204,9 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 
 	case(HousekeepingMessage::HK_REQUEST_FAILURE): {
 		failureParameter1 = objectId;
-		// also provide failure reason (returnvalue)
-		// will be most commonly invalid SID or the set already has the desired
-		// reporting status.
+		ReturnValue_t error = HasReturnvaluesIF::RETURN_FAILED;
+		HousekeepingMessage::getHkRequestFailureReply(reply,&error);
+		failureParameter2 = error;
 		return CommandingServiceBase::EXECUTION_COMPLETE;
 	}
 
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 3a2047037..3a124f5d4 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -414,11 +414,10 @@ void CommandingServiceBase::checkTimeout() {
 	// TODO: BUG HERE! Problems with comparison operator of iterator.
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
 		if(commandMap.empty()) {
-			// intermediate solution.
+			// intermediate solution!
 			break;
 		}
 		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
-			sif::info << "test" << std::endl;
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,

From 02f778ea1d4bbe07df38a7e58ca50ebf6ea81232 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 17:14:09 +0200
Subject: [PATCH 0788/1774] new error code added

---
 datapoollocal/LocalDataPoolManager.cpp | 7 ++++---
 datapoollocal/LocalDataPoolManager.h   | 1 +
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 20d6451d5..635fafce3 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -163,11 +163,12 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     			&newCollIntvl);
     	if(command == HousekeepingMessage::
     			MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
-    		return changeCollectionInterval(sid, newCollIntvl, true);
+    		result = changeCollectionInterval(sid, newCollIntvl, true);
     	}
     	else {
-    		return changeCollectionInterval(sid, newCollIntvl, false);
+    		result = changeCollectionInterval(sid, newCollIntvl, false);
     	}
+    	break;
     }
 
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
@@ -343,7 +344,7 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 
 	if(dataSet->periodicHelper == nullptr) {
 		// config error
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return PERIODIC_HELPER_INVALID;
 	}
 
 	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 505b9b1a0..44b15f59c 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -57,6 +57,7 @@ public:
 
     static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x03);
     static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x04);
+    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x05);
     /**
      * This constructor is used by a class which wants to implement
      * a personal local data pool. The queueToUse can be supplied if it

From 718502c04b35f2677c39d68da4c00f5052e01d33 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 17:15:33 +0200
Subject: [PATCH 0789/1774] added additional flag which casn be used to disable

periodic handling
---
 datapoollocal/LocalPoolDataSetBase.cpp | 6 ++++--
 datapoollocal/LocalPoolDataSetBase.h   | 2 +-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 6832005bf..c280e7c7e 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -8,7 +8,7 @@
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 		uint32_t setId, PoolVariableIF** registeredVariablesArray,
-		const size_t maxNumberOfVariables):
+		const size_t maxNumberOfVariables, bool noPeriodicHandling):
 		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
 	if(hkOwner == nullptr) {
 		// Configuration error.
@@ -21,7 +21,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     this->sid.ownerSetId = setId;
 
     // Data creators get a periodic helper for periodic HK data generation.
-    periodicHelper = new PeriodicHousekeepingHelper(this);
+    if(not noPeriodicHandling) {
+    	 periodicHelper = new PeriodicHousekeepingHelper(this);
+    }
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 1b58a211b..83e0425cd 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -45,7 +45,7 @@ public:
 	 */
 	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 			uint32_t setId, PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables);
+	        const size_t maxNumberOfVariables, bool noPeriodicHandling = false);
 
 	/**
 	 * @brief	Constructor for users of local pool data.

From 44989ada64c2fa5919e2ae6245d964eed009976f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 19:41:41 +0200
Subject: [PATCH 0790/1774] file system message taken over

---
 memory/FileSystemMessage.cpp | 54 ++++++++++++++++++++++++++++++------
 memory/FileSystemMessage.h   | 26 +++++++++++------
 2 files changed, 63 insertions(+), 17 deletions(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index 30437a623..fe1ff2b85 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -5,24 +5,60 @@
  *      Author: Jakob Meier
  */
 
-#include "FileSystemMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include <framework/memory/FileSystemMessage.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
 
-ReturnValue_t FileSystemMessage::setWriteToFileCommand(CommandMessage* message,
-		MessageQueueId_t replyQueueId, store_address_t storageID) {
-	message->setCommand(WRITE_TO_FILE);
-	message->setParameter(replyQueueId);
+
+ReturnValue_t FileSystemMessage::setDeleteFileCommand(
+		CommandMessage* message, store_address_t storageID) {
+	message->setCommand(DELETE_FILE);
 	message->setParameter2(storageID.raw);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-store_address_t FileSystemMessage::getStoreID(const CommandMessage* message) {
+ReturnValue_t FileSystemMessage::setCreateDirectoryCommand(
+		CommandMessage* message, store_address_t storageID) {
+	message->setCommand(CREATE_DIRECTORY);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemMessage::setDeleteDirectoryCommand(
+		CommandMessage* message, store_address_t storageID) {
+	message->setCommand(DELETE_DIRECTORY);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemMessage::setWriteCommand(CommandMessage* message,
+		store_address_t storageID) {
+	message->setCommand(WRITE);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemMessage::setReadCommand(CommandMessage* message,
+		store_address_t storageID) {
+	message->setCommand(READ);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemMessage::setReadReply(CommandMessage* message,
+		store_address_t storageID) {
+	message->setCommand(READ_REPLY);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+store_address_t FileSystemMessage::getStoreId(const CommandMessage* message) {
 	store_address_t temp;
 	temp.raw = message->getParameter2();
 	return temp;
 }
 
-MessageQueueId_t FileSystemMessage::getReplyQueueId(const CommandMessage* message){
-	return message->getParameter();
+void FileSystemMessage::setCompletionReply(CommandMessage* message,
+		Command_t completionStatus) {
+	message->setCommand(completionStatus);
 }
 
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index da5b3181e..cbc4f8bfc 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -8,9 +8,9 @@
 #ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
 #define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
 
-#include "../ipc/CommandMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../objectmanager/SystemObject.h"
+#include <framework/ipc/CommandMessage.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/objectmanager/SystemObject.h>
 
 class FileSystemMessage {
 private:
@@ -19,12 +19,22 @@ public:
 	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
 	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
 	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
-	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
-
-	static ReturnValue_t setWriteToFileCommand(CommandMessage* message, MessageQueueId_t replyToQueue, store_address_t storageID );
-	static store_address_t getStoreID( const CommandMessage* message );
-	static MessageQueueId_t getReplyQueueId(const CommandMessage* message);
+	static const Command_t CREATE_DIRECTORY = MAKE_COMMAND_ID( 0x09 );
+	static const Command_t DELETE_DIRECTORY = MAKE_COMMAND_ID( 0x0A );
+	static const Command_t WRITE = MAKE_COMMAND_ID( 0x80 );
+	static const Command_t READ = MAKE_COMMAND_ID( 0x81 );
+	static const Command_t READ_REPLY = MAKE_COMMAND_ID( 0x82 );
+	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
+	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
 
+	static ReturnValue_t setDeleteFileCommand(CommandMessage* message, store_address_t storageID);
+	static ReturnValue_t setCreateDirectoryCommand(CommandMessage* message, store_address_t storageID);
+	static ReturnValue_t setDeleteDirectoryCommand(CommandMessage* message, store_address_t storageID);
+	static ReturnValue_t setWriteCommand(CommandMessage* message, store_address_t storageID);
+	static ReturnValue_t setReadCommand(CommandMessage* message, store_address_t storageID);
+	static ReturnValue_t setReadReply(CommandMessage* message, store_address_t storageID);
+	static store_address_t getStoreId( const CommandMessage* message );
+	static void setCompletionReply(CommandMessage* message, Command_t completionStatus);
 };
 
 #endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */

From 9e9bde03951b143fec0e16078bcb0a02f0cd442e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 19:50:02 +0200
Subject: [PATCH 0791/1774] srv23 taken over

---
 memory/FileSystemMessage.cpp | 11 ++---------
 memory/FileSystemMessage.h   | 24 ++++++++++--------------
 pus/Service2DeviceAccess.cpp |  3 +--
 3 files changed, 13 insertions(+), 25 deletions(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index fe1ff2b85..0d1421fa2 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -1,12 +1,5 @@
-/*
- * FileSystemMessage.cpp
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#include <framework/memory/FileSystemMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
+#include "FileSystemMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
 
 
 ReturnValue_t FileSystemMessage::setDeleteFileCommand(
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index cbc4f8bfc..348c94091 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -1,17 +1,13 @@
-/*
- * FileSystemMessage.h
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
+#ifndef FSFW_MEMORY_FILESYSTEMMESSAGE_H_
+#define FSFW_MEMORY_FILESYSTEMMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+
+/**
+ * @author  Jakob Meier
  */
-
-#ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
-#define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
-
 class FileSystemMessage {
 private:
 	FileSystemMessage(); //A private ctor inhibits instantiation
@@ -37,4 +33,4 @@ public:
 	static void setCompletionReply(CommandMessage* message, Command_t completionStatus);
 };
 
-#endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */
+#endif /* FSFW_MEMORY_FILESYSTEMMESSAGE_H_ */
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 9529c675e..8780b22ce 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -39,8 +39,7 @@ ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
     SerializeAdapter::deSerialize(objectId, &tcData,
                 &tcDataLen, SerializeIF::Endianness::BIG);
 
-	ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
-	return result;
+    return checkInterfaceAndAcquireMessageQueue(id,objectId);
 }
 
 ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(

From e140d39944ba02407aa281cc6397bc75e69017ad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 20:08:25 +0200
Subject: [PATCH 0792/1774] some  fixes for sd card handler

---
 memory/HasFileSystemIF.h | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index b6d439811..6065ebfdf 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -1,15 +1,11 @@
-/*
- * HasFileSystemIF.h
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#ifndef FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
-#define FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+#ifndef FSFW_MEMORY_HASFILESYSTEMIF_H_
+#define FSFW_MEMORY_HASFILESYSTEMIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 
+/**
+ * @author  Jakob Meier
+ */
 class HasFileSystemIF {
 public:
 
@@ -19,18 +15,24 @@ public:
 	 * @return MessageQueueId_t of the object
 	 */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
+
 	/**
 	 * Function to write to a file
 	 * @param dirname Directory of the file
 	 * @param filename The filename of the file
 	 * @param data The data to write to the file
 	 * @param size The size of the data to write
-	 * @param packetNumber Counts the number of packets. For large files the write procedure must be split in multiple calls to writeToFile
+	 * @param packetNumber Counts the number of packets.
+	 * For large files the write procedure must be split in multiple calls
+	 * to writeToFile
 	 */
-	virtual ReturnValue_t writeToFile(const char* dirname, char* filename, const uint8_t* data, uint32_t size, uint16_t packetNumber) = 0;
-	virtual ReturnValue_t createFile(const char* dirname, const char* filename, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t deleteFile(const char* dirname, const char* filename) = 0;
+	virtual ReturnValue_t writeToFile(const char* dirname, const char* filename,
+	        const uint8_t* data, size_t size, uint16_t packetNumber) = 0;
+	virtual ReturnValue_t createFile(const char* dirname, const char* filename,
+	        const uint8_t* data, size_t size) = 0;
+	virtual ReturnValue_t deleteFile(const char* dirname,
+	        const char* filename) = 0;
 };
 
 
-#endif /* FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_ */
+#endif /* FSFW_MEMORY_HASFILESYSTEMIF_H_ */

From cad08e1ea9d722801b1e6675b88a8513bdc6078a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 20:54:27 +0200
Subject: [PATCH 0793/1774] error output for failed deletion

---
 storagemanager/ConstStorageAccessor.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 6235ac400..5c143adbe 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -14,7 +14,12 @@ ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
 
 ConstStorageAccessor::~ConstStorageAccessor() {
 	if(deleteData and store != nullptr) {
-		store->deleteData(storeId);
+		ReturnValue_t result = store->deleteData(storeId);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+		    // Configuration error.
+		    sif::error << "ConstStorageAccessor::~ConstStorageAccessor: "
+		            << "Could not delete entry!" << std::endl;
+		}
 	}
 }
 

From 40db85e73f54d77cd813afe7f57667ca7e3f56cc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 21:36:12 +0200
Subject: [PATCH 0794/1774] separate messages for success/failure

---
 memory/FileSystemMessage.cpp | 10 +++++++---
 memory/FileSystemMessage.h   |  3 ++-
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index 0d1421fa2..951836e9d 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -50,8 +50,12 @@ store_address_t FileSystemMessage::getStoreId(const CommandMessage* message) {
 	return temp;
 }
 
-void FileSystemMessage::setCompletionReply(CommandMessage* message,
-		Command_t completionStatus) {
-	message->setCommand(completionStatus);
+void FileSystemMessage::setSuccessReply(CommandMessage *message) {
+    message->setCommand(COMPLETION_SUCCESS);
 }
 
+void FileSystemMessage::setFailureReply(CommandMessage *message,
+        ReturnValue_t errorCode) {
+    message->setCommand(COMPLETION_SUCCESS);
+    message->setParameter(errorCode);
+}
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index 348c94091..6508f6be2 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -30,7 +30,8 @@ public:
 	static ReturnValue_t setReadCommand(CommandMessage* message, store_address_t storageID);
 	static ReturnValue_t setReadReply(CommandMessage* message, store_address_t storageID);
 	static store_address_t getStoreId( const CommandMessage* message );
-	static void setCompletionReply(CommandMessage* message, Command_t completionStatus);
+	static void setSuccessReply(CommandMessage* message);
+	static void setFailureReply(CommandMessage* message, ReturnValue_t errorCode);
 };
 
 #endif /* FSFW_MEMORY_FILESYSTEMMESSAGE_H_ */

From 763c52cfca0c173cf54924cb736ebb4262171489 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 21:57:23 +0200
Subject: [PATCH 0795/1774] CSB FIFO first steps to make configurable

---
 tmtcservices/CommandingServiceBase.h | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 23b08acf1..8237415af 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -39,7 +39,11 @@ class CommandingServiceBase: public SystemObject,
 		public HasReturnvaluesIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
+	// We could make this configurable via preprocessor and the FSFWConfig file.
+	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH = 3;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
+
 	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t NO_STEP_MESSAGE = MAKE_RETURN_CODE(2);
 	static const ReturnValue_t OBJECT_BUSY = MAKE_RETURN_CODE(3);
@@ -223,7 +227,7 @@ protected:
 		uint32_t state;
 		Command_t command;
 		object_id_t objectId;
-		FIFO<store_address_t, 3> fifo;
+		FIFO<store_address_t, COMMAND_INFO_FIFO_DEPTH> fifo;
 
 		virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
 					size_t maxSize, Endianness streamEndianness) const override{
@@ -235,7 +239,7 @@ protected:
 		};
 
 		virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-				Endianness streamEndianness) override{
+				Endianness streamEndianness) override {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		};
 	};

From f5d793a1cf63b9ebe87bef2e0d49e55947c11cf1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 20 Sep 2020 13:38:53 +0200
Subject: [PATCH 0796/1774] file system message getter func

---
 memory/FileSystemMessage.cpp | 5 +++++
 memory/FileSystemMessage.h   | 2 ++
 2 files changed, 7 insertions(+)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index 951836e9d..416f646c8 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -59,3 +59,8 @@ void FileSystemMessage::setFailureReply(CommandMessage *message,
     message->setCommand(COMPLETION_SUCCESS);
     message->setParameter(errorCode);
 }
+
+ReturnValue_t FileSystemMessage::getFailureReply(
+		const CommandMessage *message) {
+	return message->getParameter();
+}
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index 6508f6be2..d3dbd83c8 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -32,6 +32,8 @@ public:
 	static store_address_t getStoreId( const CommandMessage* message );
 	static void setSuccessReply(CommandMessage* message);
 	static void setFailureReply(CommandMessage* message, ReturnValue_t errorCode);
+
+	static ReturnValue_t getFailureReply(const CommandMessage* message);
 };
 
 #endif /* FSFW_MEMORY_FILESYSTEMMESSAGE_H_ */

From e3cbc4dfd5a854204130df4e0dd3434438b8d795 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Sep 2020 02:12:02 +0200
Subject: [PATCH 0797/1774] shared ring buffer extended

---
 container/SharedRingBuffer.cpp | 25 +++++++++++++++++++++++++
 container/SharedRingBuffer.h   | 16 ++++++++++++++++
 timemanager/Countdown.cpp      | 13 +++----------
 timemanager/Countdown.h        | 26 +++++++++++++-------------
 4 files changed, 57 insertions(+), 23 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 800e75d37..48bdb9dfd 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -9,6 +9,7 @@ SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
 	mutex = MutexFactory::instance()->createMutex();
 }
 
+
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
 		const size_t size, bool overwriteOld, size_t maxExcessBytes):
 		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
@@ -16,6 +17,11 @@ SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
 	mutex = MutexFactory::instance()->createMutex();
 }
 
+
+void SharedRingBuffer::setToUseReceiveSizeFIFO(uint32_t fifoDepth) {
+	this->fifoDepth = fifoDepth;
+}
+
 ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
         MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
     return mutex->lockMutex(timeoutType, timeout);
@@ -25,6 +31,25 @@ ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
     return mutex->unlockMutex();
 }
 
+
+
 MutexIF* SharedRingBuffer::getMutexHandle() const {
     return mutex;
 }
+
+ReturnValue_t SharedRingBuffer::initialize() {
+	if(fifoDepth > 0) {
+		receiveSizesFIFO = new DynamicFIFO<size_t>(fifoDepth);
+	}
+	return SystemObject::initialize();
+}
+
+DynamicFIFO<size_t>* SharedRingBuffer::getReceiveSizesFIFO() {
+	if(receiveSizesFIFO == nullptr) {
+		// Configuration error.
+		sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
+				<< " was not configured to have sizes FIFO, returning nullptr!"
+				<< std::endl;
+	}
+	return receiveSizesFIFO;
+}
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 80c068b3d..c9e0ae3fc 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_CONTAINER_SHAREDRINGBUFFER_H_
 #define FSFW_CONTAINER_SHAREDRINGBUFFER_H_
 
+#include <fsfw/container/DynamicFIFO.h>
 #include "SimpleRingBuffer.h"
 #include "../ipc/MutexIF.h"
 #include "../objectmanager/SystemObject.h"
@@ -26,6 +27,8 @@ public:
 	SharedRingBuffer(object_id_t objectId, const size_t size,
 			bool overwriteOld, size_t maxExcessBytes);
 
+	void setToUseReceiveSizeFIFO(uint32_t fifoDepth);
+
 	/**
 	 * This constructor takes an external buffer with the specified size.
 	 * @param buffer
@@ -59,8 +62,21 @@ public:
 	 * @return
 	 */
 	MutexIF* getMutexHandle() const;
+
+	ReturnValue_t initialize() override;
+
+	/**
+	 * If the shared ring buffer was configured to have a sizes FIFO, a handle
+	 * to that FIFO can be retrieved with this function.
+	 * Do not forget to protect access with a lock if required!
+	 * @return
+	 */
+	DynamicFIFO<size_t>* getReceiveSizesFIFO();
 private:
 	MutexIF* mutex = nullptr;
+
+	size_t fifoDepth = 0;
+	DynamicFIFO<size_t>* receiveSizesFIFO = nullptr;
 };
 
 
diff --git a/timemanager/Countdown.cpp b/timemanager/Countdown.cpp
index 95cce029a..dfe0e1ec1 100644
--- a/timemanager/Countdown.cpp
+++ b/timemanager/Countdown.cpp
@@ -1,14 +1,7 @@
-/**
- * @file	Countdown.cpp
- * @brief	This file defines the Countdown class.
- * @date	21.03.2013
- * @author	baetz
- */
+#include "Countdown.h"
 
-
-#include "../timemanager/Countdown.h"
-
-Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) {
+Countdown::Countdown(uint32_t initialTimeout): startTime(0),
+		timeout(initialTimeout) {
 }
 
 Countdown::~Countdown() {
diff --git a/timemanager/Countdown.h b/timemanager/Countdown.h
index 20380e715..f6a41e73d 100644
--- a/timemanager/Countdown.h
+++ b/timemanager/Countdown.h
@@ -1,18 +1,13 @@
+#ifndef FSFW_TIMEMANAGER_COUNTDOWN_H_
+#define FSFW_TIMEMANAGER_COUNTDOWN_H_
+
+#include "Clock.h"
+
 /**
- * @file	Countdown.h
  * @brief	This file defines the Countdown class.
- * @date	21.03.2013
  * @author	baetz
  */
-
-#ifndef COUNTDOWN_H_
-#define COUNTDOWN_H_
-
-#include "../timemanager/Clock.h"
-
 class Countdown {
-private:
-	uint32_t startTime;
 public:
 	uint32_t timeout;
 	Countdown(uint32_t initialTimeout = 0);
@@ -23,9 +18,14 @@ public:
 
 	bool isBusy() const;
 
-	ReturnValue_t resetTimer(); //!< Use last set timeout value and restart timer.
+	//!< Use last set timeout value and restart timer.
+	ReturnValue_t resetTimer();
 
-	void timeOut(); //!< Make hasTimedOut() return true
+	//!< Make hasTimedOut() return true
+	void timeOut();
+
+private:
+	uint32_t startTime = 0;
 };
 
-#endif /* COUNTDOWN_H_ */
+#endif /* FSFW_TIMEMANAGER_COUNTDOWN_H_ */

From 5072c09bc030e381df054b5b28ff979804030cff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Sep 2020 13:59:25 +0200
Subject: [PATCH 0798/1774] csb hotfix

---
 tmtcservices/CommandingServiceBase.cpp | 9 ++-------
 tmtcservices/CommandingServiceBase.h   | 2 +-
 2 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 3a124f5d4..0ebc3944f 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -384,10 +384,10 @@ void CommandingServiceBase::acceptPacket(uint8_t reportId,
 }
 
 
-void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
+void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter& iter) {
 	store_address_t address;
 	if (iter->second.fifo.retrieve(&address) != RETURN_OK) {
-		commandMap.erase(iter->first);
+		commandMap.erase(&iter);
 	} else {
 		TcPacketStored newPacket(address);
 		startExecution(&newPacket, iter);
@@ -411,12 +411,7 @@ void CommandingServiceBase::checkTimeout() {
 	uint32_t uptime;
 	Clock::getUptime(&uptime);
 	CommandMapIter iter;
-	// TODO: BUG HERE! Problems with comparison operator of iterator.
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
-		if(commandMap.empty()) {
-			// intermediate solution!
-			break;
-		}
 		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 8237415af..252b69435 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -316,7 +316,7 @@ protected:
 	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
 			SerializeIF* header = nullptr);
 
-	void checkAndExecuteFifo(CommandMapIter iter);
+	void checkAndExecuteFifo(CommandMapIter& iter);
 
 private:
 	/**

From 4074ca1b8970e3c3c115f77df15dc87e60f64f59 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Sep 2020 14:22:14 +0200
Subject: [PATCH 0799/1774] error code improved

---
 tmtcservices/TmTcBridge.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 8c2f15e5b..8abe37a2a 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -95,8 +95,9 @@ ReturnValue_t TmTcBridge::handleTm() {
     ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
-		sif::error << "TmTcBridge::handleTm: Error handling TM queue!"
-		        << std::endl;
+		sif::error << "TmTcBridge::handleTm: Error handling TM queue with "
+		       << "error code 0x" << std::hex << result  << std::dec
+			   << "!" << std::endl;
 		status = result;
 	}
 

From c7a6711eecddf89a5bad9ab193f166dfd8e93452 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Sep 2020 16:25:10 +0200
Subject: [PATCH 0800/1774] include fix

---
 container/SharedRingBuffer.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index c9e0ae3fc..fdc9d6267 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_CONTAINER_SHAREDRINGBUFFER_H_
 #define FSFW_CONTAINER_SHAREDRINGBUFFER_H_
 
-#include <fsfw/container/DynamicFIFO.h>
 #include "SimpleRingBuffer.h"
+#include "DynamicFIFO.h"
 #include "../ipc/MutexIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../timemanager/Clock.h"

From 320a5ac355728fd8b357d8bb3e0bca889e2e280e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 23 Sep 2020 17:44:22 +0200
Subject: [PATCH 0801/1774] has health IF improvements

---
 health/HasHealthIF.h     | 16 +++++++----
 health/HealthHelper.h    |  3 +-
 health/HealthMessage.cpp |  2 +-
 health/HealthMessage.h   | 17 +++++++-----
 health/HealthTable.cpp   | 59 ++++++++++++++++------------------------
 health/HealthTable.h     | 32 +++++++++++++---------
 health/HealthTableIF.h   | 20 ++++++--------
 health/ManagesHealthIF.h |  9 +++---
 8 files changed, 79 insertions(+), 79 deletions(-)

diff --git a/health/HasHealthIF.h b/health/HasHealthIF.h
index ac4043008..d5321a6d6 100644
--- a/health/HasHealthIF.h
+++ b/health/HasHealthIF.h
@@ -1,5 +1,5 @@
-#ifndef HASHEALTHIF_H_
-#define HASHEALTHIF_H_
+#ifndef FSFW_HEALTH_HASHEALTHIF_H_
+#define FSFW_HEALTH_HASHEALTHIF_H_
 
 #include "../events/Event.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -8,9 +8,13 @@
 class HasHealthIF {
 public:
 
-	typedef enum {
-		HEALTHY = 1, FAULTY = 0, EXTERNAL_CONTROL = 2, NEEDS_RECOVERY = 3, PERMANENT_FAULTY = 4
-	} HealthState;
+	enum HealthState: uint8_t {
+		HEALTHY = 1,
+		FAULTY = 0,
+		EXTERNAL_CONTROL = 2,
+		NEEDS_RECOVERY = 3,
+		PERMANENT_FAULTY = 4
+	};
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
 	static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
@@ -47,4 +51,4 @@ public:
 	virtual HasHealthIF::HealthState getHealth() = 0;
 };
 
-#endif /* HASHEALTHIF_H_ */
+#endif /* FSFW_HEALTH_HASHEALTHIF_H_ */
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index d1f1945c2..813123b29 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -114,7 +114,8 @@ private:
 	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
 	 * @param oldHealth information of the previous health state.
 	 */
-	void informParent(HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth);
+	void informParent(HasHealthIF::HealthState health,
+	        HasHealthIF::HealthState oldHealth);
 
 	void handleSetHealthCommand(CommandMessage *message);
 };
diff --git a/health/HealthMessage.cpp b/health/HealthMessage.cpp
index 39c53fb1c..1bb29526f 100644
--- a/health/HealthMessage.cpp
+++ b/health/HealthMessage.cpp
@@ -1,4 +1,4 @@
-#include "../health/HealthMessage.h"
+#include "HealthMessage.h"
 
 void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
 		HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth) {
diff --git a/health/HealthMessage.h b/health/HealthMessage.h
index fa773d421..de4923abc 100644
--- a/health/HealthMessage.h
+++ b/health/HealthMessage.h
@@ -1,19 +1,22 @@
-#ifndef HEALTHMESSAGE_H_
-#define HEALTHMESSAGE_H_
+#ifndef FSFW_HEALTH_HEALTHMESSAGE_H_
+#define FSFW_HEALTH_HEALTHMESSAGE_H_
 
-#include "../health/HasHealthIF.h"
+#include "HasHealthIF.h"
 #include "../ipc/CommandMessage.h"
 
 class HealthMessage {
 public:
 	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!
+	// REPLY_COMMAND_OK/REPLY_REJECTED
+	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);
+	// NO REPLY!
+	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(3);
 	static const Command_t HEALTH_INFO = MAKE_COMMAND_ID(5);
 	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
 
 	static void setHealthMessage(CommandMessage *message, Command_t command,
-			HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
+			HasHealthIF::HealthState health,
+			HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
 
 	static void setHealthMessage(CommandMessage *message, Command_t command);
 
@@ -27,4 +30,4 @@ private:
 	HealthMessage();
 };
 
-#endif /* HEALTHMESSAGE_H_ */
+#endif /* FSFW_HEALTH_HEALTHMESSAGE_H_ */
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 1aa5a3ae6..6d6fe0172 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -1,6 +1,7 @@
-#include "../health/HealthTable.h"
-#include "../serialize/SerializeAdapter.h"
+#include "HealthTable.h"
+#include "../ipc/MutexHelper.h"
 #include "../ipc/MutexFactory.h"
+#include "../serialize/SerializeAdapter.h"
 
 HealthTable::HealthTable(object_id_t objectid) :
 		SystemObject(objectid) {
@@ -18,74 +19,64 @@ ReturnValue_t HealthTable::registerObject(object_id_t object,
 	if (healthMap.count(object) != 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	healthMap.insert(
-			std::pair<object_id_t, HasHealthIF::HealthState>(object,
-					initilialState));
+	healthMap.emplace(object, initilialState);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void HealthTable::setHealth(object_id_t object,
 		HasHealthIF::HealthState newState) {
-	mutex->lockMutex(MutexIF::BLOCKING);
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		iter->second = newState;
 	}
-	mutex->unlockMutex();
 }
 
 HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		state = iter->second;
 	}
-	mutex->unlockMutex();
 	return state;
 }
 
-uint32_t HealthTable::getPrintSize() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	uint32_t size = healthMap.size() * 5 + 2;
-	mutex->unlockMutex();
-	return size;
-}
 
 bool HealthTable::hasHealth(object_id_t object) {
-	bool exits = false;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
-		exits = true;
+		return true;
 	}
-	mutex->unlockMutex();
-	return exits;
+	return false;
+}
+
+size_t HealthTable::getPrintSize() {
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    uint32_t size = healthMap.size() * sizeof(object_id_t) +
+            sizeof(HasHealthIF::HealthState) + sizeof(uint16_t);
+    return size;
 }
 
 void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
-	mutex->lockMutex(MutexIF::BLOCKING);
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
 	size_t size = 0;
 	uint16_t count = healthMap.size();
-	ReturnValue_t result = SerializeAdapter::serialize(&count,
+	SerializeAdapter::serialize(&count,
 			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-	HealthMap::iterator iter;
-	for (iter = healthMap.begin();
-			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
-			++iter) {
-		result = SerializeAdapter::serialize(&iter->first,
+	for (const auto& health: healthMap) {
+		SerializeAdapter::serialize(&health.first,
 				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-		uint8_t health = iter->second;
-		result = SerializeAdapter::serialize(&health, &pointer, &size,
+		uint8_t healthValue = health.second;
+		SerializeAdapter::serialize(&healthValue, &pointer, &size,
 				maxSize, SerializeIF::Endianness::BIG);
 	}
-	mutex->unlockMutex();
 }
 
-ReturnValue_t HealthTable::iterate(
-		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
+ReturnValue_t HealthTable::iterate(HealthEntry *value, bool reset) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
 	if (reset) {
 		mapIterator = healthMap.begin();
 	}
@@ -94,7 +85,5 @@ ReturnValue_t HealthTable::iterate(
 	}
 	*value = *mapIterator;
 	mapIterator++;
-	mutex->unlockMutex();
-
 	return result;
 }
diff --git a/health/HealthTable.h b/health/HealthTable.h
index 0f54a2641..c5ebb5d4c 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -1,27 +1,31 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHTABLE_H_
-#define FRAMEWORK_HEALTH_HEALTHTABLE_H_
+#ifndef FSFW_HEALTH_HEALTHTABLE_H_
+#define FSFW_HEALTH_HEALTHTABLE_H_
 
-#include "../health/HealthTableIF.h"
+#include "HealthTableIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../ipc/MutexIF.h"
 #include <map>
 
 typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
+using HealthEntry = std::pair<object_id_t, HasHealthIF::HealthState>;
 
 class HealthTable: public HealthTableIF, public SystemObject {
 public:
 	HealthTable(object_id_t objectid);
 	virtual ~HealthTable();
 
-	virtual ReturnValue_t registerObject(object_id_t object,
-			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY);
+    /** HealthTableIF overrides */
+    virtual ReturnValue_t registerObject(object_id_t object,
+            HasHealthIF::HealthState initilialState =
+            HasHealthIF::HEALTHY) override;
+    virtual size_t getPrintSize() override;
+    virtual void printAll(uint8_t *pointer, size_t maxSize) override;
 
-	virtual bool hasHealth(object_id_t object);
-	virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState);
-	virtual HasHealthIF::HealthState getHealth(object_id_t);
-
-	virtual uint32_t getPrintSize();
-	virtual void printAll(uint8_t *pointer, size_t maxSize);
+	/** ManagesHealthIF overrides */
+	virtual bool hasHealth(object_id_t object) override;
+	virtual void setHealth(object_id_t object,
+	        HasHealthIF::HealthState newState) override;
+	virtual HasHealthIF::HealthState getHealth(object_id_t) override;
 
 protected:
 	MutexIF* mutex;
@@ -29,7 +33,9 @@ protected:
 
 	HealthMap::iterator mapIterator;
 
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false);
+	virtual ReturnValue_t iterate(
+	        HealthEntry* value,
+	        bool reset = false) override;
 };
 
-#endif /* HEALTHTABLE_H_ */
+#endif /* FSFW_HEALTH_HEALTHTABLE_H_ */
diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h
index f18f03155..d61e67616 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -1,28 +1,24 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
-#define FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
+#ifndef FSFW_HEALTH_HEALTHTABLEIF_H_
+#define FSFW_HEALTH_HEALTHTABLEIF_H_
 
-#include "../health/ManagesHealthIF.h"
+#include "ManagesHealthIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <map>
-
 
 class HealthTableIF: public ManagesHealthIF {
-	// TODO: This is in the mission folder and not in the framework folder.
-	// delete it?
-	friend class HealthCommandingService;
 public:
-	virtual ~HealthTableIF() {
-	}
+	virtual ~HealthTableIF() {}
 
 	virtual ReturnValue_t registerObject(object_id_t object,
 			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
 
-	virtual uint32_t getPrintSize() = 0;
+	virtual size_t getPrintSize() = 0;
 	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
 
 protected:
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
+	virtual ReturnValue_t iterate(
+	        std::pair<object_id_t,HasHealthIF::HealthState> *value,
+	        bool reset = false) = 0;
 };
 
 #endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */
diff --git a/health/ManagesHealthIF.h b/health/ManagesHealthIF.h
index 8ca170125..2edfcecad 100644
--- a/health/ManagesHealthIF.h
+++ b/health/ManagesHealthIF.h
@@ -1,8 +1,9 @@
-#ifndef FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
-#define FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
+#ifndef FSFW_HEALTH_MANAGESHEALTHIF_H_
+#define FSFW_HEALTH_MANAGESHEALTHIF_H_
 
-#include "../health/HasHealthIF.h"
+#include "HasHealthIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
+
 class ManagesHealthIF {
 public:
 	virtual ~ManagesHealthIF() {
@@ -49,4 +50,4 @@ public:
 	}
 };
 
-#endif /* FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ */
+#endif /* FSFW_HEALTH_MANAGESHEALTHIF_H_ */

From 2f0b36de46938bf6dd58539f75f91f183e567d25 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 23 Sep 2020 19:54:22 +0200
Subject: [PATCH 0802/1774] updated framework object list

---
 objectmanager/frameworkObjects.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 4a30e70ae..87439c88b 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -8,6 +8,8 @@ enum framework_objects {
 	PUS_SERVICE_2 = 0x53000002,
 	PUS_SERVICE_5 = 0x53000005,
 	PUS_SERVICE_8 = 0x53000008,
+	PUS_SERVICE_9 = 0x53000009,
+	PUS_SERVICE_17 = 0x53000017,
 	PUS_SERVICE_200 = 0x53000200,
 
 	//Generic IDs for IPC, modes, health, events

From 43ab0ba2702f482f1f5e7d39493a90e66bb91336 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 23 Sep 2020 19:55:48 +0200
Subject: [PATCH 0803/1774] updated subsystemId ranged

---
 events/fwSubsystemIdRanges.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/events/fwSubsystemIdRanges.h b/events/fwSubsystemIdRanges.h
index 3c57c1606..8dc4def76 100644
--- a/events/fwSubsystemIdRanges.h
+++ b/events/fwSubsystemIdRanges.h
@@ -19,7 +19,8 @@ enum {
 	SYSTEM_MANAGER_1 = 75,
 	SYSTEM_1 = 79,
 	PUS_SERVICE_1 = 80,
-	PUS_SERVICE_17 = 83,
+	PUS_SERVICE_9 = 89,
+	PUS_SERVICE_17 = 97,
 	FW_SUBSYSTEM_ID_RANGE
 };
 }

From 5ca1c7bca2d7a5c431488afde034dbe6625807cb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 23 Sep 2020 19:58:51 +0200
Subject: [PATCH 0804/1774] coutndown update

---
 timemanager/Countdown.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/timemanager/Countdown.cpp b/timemanager/Countdown.cpp
index dfe0e1ec1..20b56189f 100644
--- a/timemanager/Countdown.cpp
+++ b/timemanager/Countdown.cpp
@@ -1,7 +1,6 @@
 #include "Countdown.h"
 
-Countdown::Countdown(uint32_t initialTimeout): startTime(0),
-		timeout(initialTimeout) {
+Countdown::Countdown(uint32_t initialTimeout): timeout(initialTimeout) {
 }
 
 Countdown::~Countdown() {

From a65745d037a2ef26e51302d5c585620681a0f56a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 25 Sep 2020 18:40:04 +0200
Subject: [PATCH 0805/1774] added explicit function to refresh task handle

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp |  8 ++++++--
 osal/FreeRTOS/BinSemaphUsingTask.h   | 28 +++++++++++++++++++++-------
 2 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index dd1e48ca9..9c29948e9 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -1,5 +1,5 @@
-#include "../../osal/FreeRTOS/BinSemaphUsingTask.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "BinSemaphUsingTask.h"
+#include "TaskManagement.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
@@ -16,6 +16,10 @@ BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
 }
 
+void BinarySemaphoreUsingTask::refreshTaskHandle() {
+	handle = TaskManagement::getCurrentTaskHandle();
+}
+
 ReturnValue_t BinarySemaphoreUsingTask::acquire(TimeoutType timeoutType,
         uint32_t timeoutMs) {
     TickType_t timeout = 0;
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 4317e0b23..65a091a3f 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+#ifndef FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+#define FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include "../../tasks/SemaphoreIF.h"
@@ -7,16 +7,20 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
+// todo: does not work for older FreeRTOS version, so we should
+// actually check whether tskKERNEL_VERSION_MAJOR is larger than.. 7 or 8 ?
+
 /**
  * @brief 	Binary Semaphore implementation using the task notification value.
  * 			The notification value should therefore not be used
- * 			for other purposes.
+ * 			for other purposes!
  * @details
  * Additional information: https://www.freertos.org/RTOS-task-notifications.html
  * and general semaphore documentation.
  * This semaphore is bound to the task it is created in!
- * Take care of calling this function with the correct executing task,
- * (for example in the initializeAfterTaskCreation() function).
+ * Take care of building this class with the correct executing task,
+ * (for example in the initializeAfterTaskCreation() function) or
+ * by calling refreshTaskHandle() with the correct executing task.
  */
 class BinarySemaphoreUsingTask: public SemaphoreIF,
 		public HasReturnvaluesIF {
@@ -28,6 +32,16 @@ public:
 	//! @brief Default dtor
 	virtual~ BinarySemaphoreUsingTask();
 
+	/**
+	 * This function can be used to get the correct task handle from the
+	 * currently executing task.
+	 *
+	 * This is required because the task notification value will be used
+	 * as a binary semaphore, and the semaphore might be created by another
+	 * task.
+	 */
+	void refreshTaskHandle();
+
 	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
 	        uint32_t timeoutMs = portMAX_DELAY) override;
 	ReturnValue_t release() override;
@@ -70,10 +84,10 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
-				BaseType_t * higherPriorityTaskWoken);
+				BaseType_t* higherPriorityTaskWoken);
 
 protected:
 	TaskHandle_t handle;
 };
 
-#endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
+#endif /* FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */

From cf28c9ff9d861b7ecd30a45b172635ed1766b882 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 25 Sep 2020 19:01:59 +0200
Subject: [PATCH 0806/1774] make event func changed

---
 events/Event.cpp | 6 ++++--
 events/Event.h   | 5 +++--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/events/Event.cpp b/events/Event.cpp
index ea3d46fe4..0f76b4386 100644
--- a/events/Event.cpp
+++ b/events/Event.cpp
@@ -1,4 +1,5 @@
 #include "Event.h"
+
 namespace EVENT {
 EventId_t getEventId(Event event) {
 	return (event & 0xFFFF);
@@ -8,7 +9,8 @@ EventSeverity_t getSeverity(Event event) {
 	return ((event >> 16) & 0xFF);
 }
 
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity) {
-	return (eventSeverity << 16) + (eventId & 0xFFFF);
+Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
+		EventSeverity_t eventSeverity) {
+	return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
 }
 }
diff --git a/events/Event.h b/events/Event.h
index f8410f328..f5434826b 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -18,9 +18,10 @@ EventId_t getEventId(Event event);
 
 EventSeverity_t getSeverity(Event event);
 
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
-
+Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
+		EventSeverity_t eventSeverity);
 }
+
 namespace SEVERITY {
 	static const EventSeverity_t INFO = 1;
 	static const EventSeverity_t LOW = 2;

From 4d1492f130e64a4e8ec803814ca6f4bf9bcaccbc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 14:13:20 +0200
Subject: [PATCH 0807/1774] event cfg file loc not explicit anymore

---
 events/Event.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/events/Event.h b/events/Event.h
index e22c9db16..f8410f328 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include "fwSubsystemIdRanges.h"
 //could be move to more suitable location
-#include <config/tmtc/subsystemIdRanges.h>
+#include <subsystemIdRanges.h>
 
 typedef uint16_t EventId_t;
 typedef uint8_t EventSeverity_t;

From 9aca5cb6f246d3db825bb447fa18d28468a59ec4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 14:59:40 +0200
Subject: [PATCH 0808/1774] taken over convergence changes

---
 memory/AcceptsMemoryMessagesIF.h | 17 ++++---------
 memory/MemoryHelper.cpp          | 15 +++++------
 memory/MemoryHelper.h            | 36 +++++++++++++++++---------
 memory/MemoryMessage.cpp         | 27 ++++++++------------
 memory/MemoryMessage.h           | 43 +++++++++++++++++++-------------
 modes/HasModesIF.h               | 24 +++++++-----------
 modes/ModeHelper.cpp             |  7 +++---
 modes/ModeHelper.h               | 14 +++++------
 modes/ModeMessage.cpp            | 10 ++++----
 modes/ModeMessage.h              | 20 ++++++---------
 10 files changed, 106 insertions(+), 107 deletions(-)

diff --git a/memory/AcceptsMemoryMessagesIF.h b/memory/AcceptsMemoryMessagesIF.h
index 4c222dece..cf8aa5ecb 100644
--- a/memory/AcceptsMemoryMessagesIF.h
+++ b/memory/AcceptsMemoryMessagesIF.h
@@ -1,15 +1,8 @@
-/**
- * @file	AcceptsMemoryMessagesIF.h
- * @brief	This file defines the AcceptsMemoryMessagesIF class.
- * @date	11.07.2013
- * @author	baetz
- */
+#ifndef FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_
+#define FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_
 
-#ifndef ACCEPTSMEMORYMESSAGESIF_H_
-#define ACCEPTSMEMORYMESSAGESIF_H_
-
-#include "../memory/HasMemoryIF.h"
-#include "../memory/MemoryMessage.h"
+#include "HasMemoryIF.h"
+#include "MemoryMessage.h"
 #include "../ipc/MessageQueueSenderIF.h"
 
 class AcceptsMemoryMessagesIF : public HasMemoryIF {
@@ -18,4 +11,4 @@ public:
 };
 
 
-#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */
+#endif /* AFSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_ */
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 2daddf634..6b11882f3 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -1,14 +1,15 @@
+#include "MemoryHelper.h"
+#include "MemoryMessage.h"
+
 #include "../globalfunctions/CRC.h"
-#include "../memory/MemoryHelper.h"
-#include "../memory/MemoryMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/EndianConverter.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
 		MessageQueueIF* useThisQueue):
-		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(nullptr),
-		ipcAddress(), lastCommand(CommandMessage::CMD_NONE), busy(false) {
+		workOnThis(workOnThis), queueToUse(useThisQueue), ipcAddress(),
+		lastCommand(CommandMessage::CMD_NONE), busy(false) {
 }
 
 ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
@@ -34,7 +35,7 @@ ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
 }
 
 void MemoryHelper::completeLoad(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
+		const uint8_t* dataToCopy, const size_t size, uint8_t* copyHere) {
 	busy = false;
 	switch (errorCode) {
 	case HasMemoryIF::DO_IT_MYSELF:
@@ -64,7 +65,7 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 }
 
 void MemoryHelper::completeDump(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size) {
+		const uint8_t* dataToCopy, const size_t size) {
 	busy = false;
 	CommandMessage reply;
 	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
@@ -121,7 +122,7 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
 }
 
 void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
-		uint32_t totalSize, uint8_t datatypeSize) {
+		size_t totalSize, uint8_t datatypeSize) {
 	if (totalSize % datatypeSize != 0){
 		return;
 	}
diff --git a/memory/MemoryHelper.h b/memory/MemoryHelper.h
index 418cf50d3..a651861cb 100644
--- a/memory/MemoryHelper.h
+++ b/memory/MemoryHelper.h
@@ -1,11 +1,16 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYHELPER_H_
-#define FRAMEWORK_MEMORY_MEMORYHELPER_H_
+#ifndef FSFW_MEMORY_MEMORYHELPER_H_
+#define FSFW_MEMORY_MEMORYHELPER_H_
+
+#include "AcceptsMemoryMessagesIF.h"
+
 #include "../ipc/CommandMessage.h"
-#include "../memory/AcceptsMemoryMessagesIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../ipc/MessageQueueIF.h"
 
+/**
+ * @brief   TODO: documentation.
+ */
 class MemoryHelper : public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER;
@@ -13,6 +18,20 @@ public:
 	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
 	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2);
 	static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3);
+
+    MemoryHelper(HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue);
+    ~MemoryHelper();
+
+    ReturnValue_t handleMemoryCommand(CommandMessage* message);
+    void completeLoad(ReturnValue_t errorCode,
+            const uint8_t* dataToCopy = nullptr, const size_t size = 0,
+            uint8_t* copyHere = nullptr);
+    void completeDump(ReturnValue_t errorCode,
+            const uint8_t* dataToCopy = nullptr, const size_t size = 0);
+    void swapMatrixCopy(uint8_t *out, const uint8_t *in, size_t totalSize,
+            uint8_t datatypeSize);
+    ReturnValue_t initialize(MessageQueueIF* queueToUse_);
+
 private:
 	HasMemoryIF* workOnThis;
 	MessageQueueIF* queueToUse;
@@ -25,13 +44,6 @@ private:
 	void handleMemoryLoad(CommandMessage* message);
 	void handleMemoryCheckOrDump(CommandMessage* message);
 	ReturnValue_t initialize();
-public:
-	ReturnValue_t handleMemoryCommand(CommandMessage* message);
-	void completeLoad( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0, uint8_t* copyHere = NULL );
-	void completeDump(  ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0);
-	void swapMatrixCopy( uint8_t *out, const uint8_t *in, uint32_t totalSize, uint8_t datatypeSize);
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
-	MemoryHelper( HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue );
-	~MemoryHelper();
+
 };
-#endif /* MEMORYHELPER_H_ */
+#endif /* FSFW_MEMORY_MEMORYHELPER_H_ */
diff --git a/memory/MemoryMessage.cpp b/memory/MemoryMessage.cpp
index 4e077dee8..94fa46917 100644
--- a/memory/MemoryMessage.cpp
+++ b/memory/MemoryMessage.cpp
@@ -1,7 +1,6 @@
-#include "../memory/MemoryMessage.h"
+#include "MemoryMessage.h"
+
 #include "../objectmanager/ObjectManagerIF.h"
-MemoryMessage::MemoryMessage() {
-}
 
 uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
 	return message->getParameter();
@@ -17,18 +16,17 @@ uint32_t MemoryMessage::getLength(const CommandMessage* message) {
 	return message->getParameter2();
 }
 
-ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
+void MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
 		uint32_t address, uint32_t length) {
 	message->setCommand(CMD_MEMORY_DUMP);
 	message->setParameter( address );
 	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_address_t storageID) {
+void MemoryMessage::setMemoryDumpReply(CommandMessage* message,
+        store_address_t storageID) {
 	message->setCommand(REPLY_MEMORY_DUMP);
 	message->setParameter2( storageID.raw );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
@@ -64,22 +62,21 @@ void MemoryMessage::clear(CommandMessage* message) {
 		}
 }
 
-ReturnValue_t MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
+void MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
 		uint32_t address, uint32_t length) {
 	message->setCommand(CMD_MEMORY_CHECK);
 	message->setParameter( address );
 	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message,
+void MemoryMessage::setMemoryCheckReply(CommandMessage* message,
 		uint16_t crc) {
 	message->setCommand(REPLY_MEMORY_CHECK);
 	message->setParameter( crc );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void MemoryMessage::setCrcReturnValue(CommandMessage* message, ReturnValue_t returnValue){
+void MemoryMessage::setCrcReturnValue(CommandMessage* message,
+        ReturnValue_t returnValue){
 	message->setParameter(returnValue<<16);
 };
 
@@ -95,18 +92,16 @@ Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
 	return message->getParameter2();
 }
 
-ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
+void MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
 		ReturnValue_t errorCode, Command_t initialCommand) {
 	message->setCommand(REPLY_MEMORY_FAILED);
 	message->setParameter(errorCode);
 	message->setParameter2(initialCommand);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
+void MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
 	message->setCommand(END_OF_MEMORY_COPY);
 	message->setParameter(0);
 	message->setParameter2(0);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/memory/MemoryMessage.h b/memory/MemoryMessage.h
index a366eb9a3..05b9926de 100644
--- a/memory/MemoryMessage.h
+++ b/memory/MemoryMessage.h
@@ -1,14 +1,15 @@
-#ifndef MEMORYMESSAGE_H_
-#define MEMORYMESSAGE_H_
+#ifndef FSFW_MEMORY_MEMORYMESSAGE_H_
+#define FSFW_MEMORY_MEMORYMESSAGE_H_
 
 #include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
 
 
 class MemoryMessage {
-private:
-	MemoryMessage(); //A private ctor inhibits instantiation
 public:
+    // Instantiation forbidden.
+	MemoryMessage() = delete;
+
 	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 );
@@ -19,21 +20,29 @@ public:
 	static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
 
 	static uint32_t getAddress( const CommandMessage* message );
-	static store_address_t getStoreID( const CommandMessage* message );
+	static store_address_t getStoreID(const CommandMessage* message);
 	static uint32_t getLength( const CommandMessage* message );
-	static ReturnValue_t getErrorCode( const CommandMessage* message );
-	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
-	static void setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
-	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
-	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
-	static ReturnValue_t setMemoryCopyEnd( CommandMessage* message);
+	static ReturnValue_t getErrorCode(const CommandMessage* message);
+    static uint16_t getCrc(const CommandMessage* message );
+    static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
+    static Command_t getInitialCommand(const CommandMessage* message);
+
+	static void setMemoryDumpCommand(CommandMessage* message,
+	        uint32_t address, uint32_t length );
+	static void setMemoryDumpReply(CommandMessage* message,
+	        store_address_t storageID);
+	static void setMemoryLoadCommand(CommandMessage* message,
+	        uint32_t address, store_address_t storageID );
+	static void setMemoryCheckCommand(CommandMessage* message,
+	        uint32_t address, uint32_t length);
+	static void setMemoryCheckReply(CommandMessage* message,
+	        uint16_t crc);
+	static void setMemoryReplyFailed(CommandMessage* message,
+	        ReturnValue_t errorCode, Command_t initialCommand);
+	static void setMemoryCopyEnd(CommandMessage* message);
 	static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue);
-	static uint16_t getCrc( const CommandMessage* message );
-	static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
-	static Command_t getInitialCommand( const CommandMessage* message );
+
 	static void clear(CommandMessage* message);
 };
 
-#endif /* MEMORYMESSAGE_H_ */
+#endif /* FSFW_MEMORY_MEMORYMESSAGE_H_ */
diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h
index 39a50c2a0..34a159375 100644
--- a/modes/HasModesIF.h
+++ b/modes/HasModesIF.h
@@ -1,18 +1,11 @@
-/**
- * @file	HasModesIF.h
- * @brief	This file defines the HasModesIF class.
- * @date	20.06.2013
- * @author	baetz
- */
-
-#ifndef HASMODESIF_H_
-#define HASMODESIF_H_
+#ifndef FSFW_MODES_HASMODESIF_H_
+#define FSFW_MODES_HASMODESIF_H_
 
+#include "ModeHelper.h"
+#include "ModeMessage.h"
 #include "../events/Event.h"
-#include "../modes/ModeHelper.h"
-#include "../modes/ModeMessage.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
+#include <cstdint>
 
 
 class HasModesIF {
@@ -37,10 +30,11 @@ public:
 	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
 	static const Submode_t SUBMODE_NONE = 0; //!< To avoid checks against magic number "0".
-	virtual ~HasModesIF() {
-	}
+
+	virtual ~HasModesIF() {}
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
+
 protected:
 	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
 			uint32_t *msToReachTheMode) {
@@ -54,4 +48,4 @@ protected:
 	virtual void announceMode(bool recursive) {}
 };
 
-#endif /* HASMODESIF_H_ */
+#endif /*FSFW_MODES_HASMODESIF_H_ */
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index 68f009e7b..6be4f776d 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,6 +1,7 @@
+#include "HasModesIF.h"
+#include "ModeHelper.h"
+
 #include "../ipc/MessageQueueSenderIF.h"
-#include "../modes/HasModesIF.h"
-#include "../modes/ModeHelper.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 ModeHelper::ModeHelper(HasModesIF *owner) :
@@ -26,7 +27,7 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 		uint32_t timeout;
 		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
-			ModeMessage::cantReachMode(&reply, result);
+			ModeMessage::setCantReachMode(&reply, result);
 			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
 			        owner->getCommandQueue());
 			break;
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index 02cf5799b..c2f089ec4 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -1,8 +1,8 @@
-#ifndef MODEHELPER_H_
-#define MODEHELPER_H_
+#ifndef FSFW_MODES_MODEHELPER_H_
+#define FSFW_MODES_MODEHELPER_H_
 
+#include "ModeMessage.h"
 #include "../ipc/MessageQueueIF.h"
-#include "../modes/ModeMessage.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../timemanager/Countdown.h"
 
@@ -20,14 +20,14 @@ public:
 	ReturnValue_t handleModeCommand(CommandMessage *message);
 
 	/**
-	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @param parentQueue the Queue id of the parent object.
+	 * Set to 0 if no parent present
 	 */
 	void setParentQueue(MessageQueueId_t parentQueueId);
 
 	ReturnValue_t initialize(MessageQueueId_t parentQueueId);
 
-	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
+	ReturnValue_t initialize(void);
 
 	void modeChanged(Mode_t mode, Submode_t submode);
 
@@ -50,4 +50,4 @@ private:
 	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
 };
 
-#endif /* MODEHELPER_H_ */
+#endif /* FSFW_MODES_MODEHELPER_H_ */
diff --git a/modes/ModeMessage.cpp b/modes/ModeMessage.cpp
index 7ad7d06fd..b33bba60b 100644
--- a/modes/ModeMessage.cpp
+++ b/modes/ModeMessage.cpp
@@ -1,4 +1,4 @@
-#include "../modes/ModeMessage.h"
+#include "ModeMessage.h"
 
 Mode_t ModeMessage::getMode(const CommandMessage* message) {
 	return message->getParameter();
@@ -8,12 +8,11 @@ Submode_t ModeMessage::getSubmode(const CommandMessage* message) {
 	return message->getParameter2();
 }
 
-ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t command,
-		Mode_t mode, Submode_t submode) {
+void ModeMessage::setModeMessage(CommandMessage* message,
+        Command_t command, Mode_t mode, Submode_t submode) {
 	message->setCommand( command );
 	message->setParameter( mode );
 	message->setParameter2( submode );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
@@ -24,7 +23,8 @@ void ModeMessage::clear(CommandMessage* message) {
 	message->setCommand(CommandMessage::CMD_NONE);
 }
 
-void ModeMessage::cantReachMode(CommandMessage* message, ReturnValue_t reason) {
+void ModeMessage::setCantReachMode(CommandMessage* message,
+        ReturnValue_t reason) {
 	message->setCommand(REPLY_CANT_REACH_MODE);
 	message->setParameter(reason);
 	message->setParameter2(0);
diff --git a/modes/ModeMessage.h b/modes/ModeMessage.h
index 925f3fc16..856996cf6 100644
--- a/modes/ModeMessage.h
+++ b/modes/ModeMessage.h
@@ -1,12 +1,5 @@
-/**
- * @file	ModeMessage.h
- * @brief	This file defines the ModeMessage class.
- * @date	17.07.2013
- * @author	baetz
- */
-
-#ifndef MODEMESSAGE_H_
-#define MODEMESSAGE_H_
+#ifndef FSFW_MODES_MODEMESSAGE_H_
+#define FSFW_MODES_MODEMESSAGE_H_
 
 #include "../ipc/CommandMessage.h"
 
@@ -30,11 +23,12 @@ public:
 
 	static Mode_t getMode(const CommandMessage* message);
 	static Submode_t getSubmode(const CommandMessage* message);
-	static ReturnValue_t setModeMessage(CommandMessage* message,
+    static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
+
+	static void setModeMessage(CommandMessage* message,
 			Command_t command, Mode_t mode, Submode_t submode);
-	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
-	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
+	static void setCantReachMode(CommandMessage* message, ReturnValue_t reason);
 	static void clear(CommandMessage* message);
 };
 
-#endif /* MODEMESSAGE_H_ */
+#endif /* FSFW_MODES_MODEMESSAGE_H_ */

From fab7eb8a5d40386237ee243cc98af78e22f5fffe Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:03:04 +0200
Subject: [PATCH 0809/1774] controller base update

---
 controller/ControllerBase.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index da84ed277..4f50fe1ff 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -1,5 +1,5 @@
-#include "../subsystem/SubsystemBase.h"
-#include "../controller/ControllerBase.h"
+#include "ControllerBase.h"
+
 #include "../subsystem/SubsystemBase.h"
 #include "../ipc/QueueFactory.h"
 #include "../action/HasActionsIF.h"
@@ -25,7 +25,7 @@ ReturnValue_t ControllerBase::initialize() {
 	MessageQueueId_t parentQueue = 0;
 	if (parentId != objects::NO_OBJECT) {
 		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
+		if (parent == nullptr) {
 			return RETURN_FAILED;
 		}
 		parentQueue = parent->getCommandQueue();

From 08d0e0949342c3620fb119c9d2e6dabde243e2aa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:16:13 +0200
Subject: [PATCH 0810/1774] power equalization

---
 power/Fuse.cpp           | 20 ++++++++++++--------
 power/Fuse.h             | 13 +++++++------
 power/PowerComponent.cpp | 24 +++++++++---------------
 power/PowerComponent.h   | 24 ++++++++++++++----------
 power/PowerComponentIF.h | 14 +++++++-------
 power/PowerSensor.cpp    | 14 ++++++++------
 power/PowerSensor.h      |  8 ++++----
 power/PowerSwitchIF.h    | 23 ++++++++---------------
 power/PowerSwitcher.cpp  | 25 ++++++++++++++++---------
 power/PowerSwitcher.h    | 19 ++++++++++++-------
 10 files changed, 97 insertions(+), 87 deletions(-)

diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 3ea0b18cc..ace625bfe 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -1,7 +1,8 @@
+#include "Fuse.h"
+
 #include "../monitoring/LimitViolationReporter.h"
 #include "../monitoring/MonitoringMessageContent.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../power/Fuse.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../ipc/QueueFactory.h"
 
@@ -10,13 +11,16 @@ object_id_t Fuse::powerSwitchId = 0;
 Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
 		float maxCurrent, uint16_t confirmationCount) :
 		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
-		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
-				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
-				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
-				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
-				ids.pidCurrent, &set), state(ids.pidState, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
-				NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
+		NULL),
+		currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
+				maxCurrent, FUSE_CURRENT_HIGH),
+		powerMonitor(fuseObjectId, 2,
+		        GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
+				confirmationCount),
+		set(), voltage(ids.pidVoltage, &set), current(ids.pidCurrent, &set),
+		state(ids.pidState, &set),
+		power(ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE),
+		parameterHelper(this), healthHelper(this, fuseObjectId) {
 	commandQueue = QueueFactory::instance()->createMessageQueue();
 }
 
diff --git a/power/Fuse.h b/power/Fuse.h
index dd8759f47..13a0eb7c3 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -1,13 +1,14 @@
-#ifndef FUSE_H_
-#define FUSE_H_
+#ifndef FSFW_POWER_FUSE_H_
+#define FSFW_POWER_FUSE_H_
+
+#include "PowerComponentIF.h"
+#include "PowerSwitchIF.h"
 
 #include "../datapoolglob/GlobalDataSet.h"
 #include "../datapoolglob/GlobalPoolVariable.h"
 #include "../datapoolglob/PIDReader.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../monitoring/AbsLimitMonitor.h"
-#include "../power/PowerComponentIF.h"
-#include "../power/PowerSwitchIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../parameters/ParameterHelper.h"
 #include <list>
@@ -90,7 +91,7 @@ private:
 	PIDReader<float> current;
 	PIDReader<uint8_t> state;
 	gp_float_t power;
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
 	static object_id_t powerSwitchId;
@@ -103,4 +104,4 @@ private:
 	bool areSwitchesOfComponentOn(DeviceList::iterator iter);
 };
 
-#endif /* FUSE_H_ */
+#endif /* FSFW_POWER_FUSE_H_ */
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index a37970553..4af7c96b5 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -1,20 +1,14 @@
-/**
- * @file	PowerComponent.cpp
- * @brief	This file defines the PowerComponent class.
- * @date	28.08.2014
- * @author	baetz
- */
+#include "PowerComponent.h"
 
-#include "../power/PowerComponent.h"
-
-PowerComponent::PowerComponent() :
-		deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
-		false), min(0.0), max(0.0), moduleId(0) {
+PowerComponent::PowerComponent(): switchId1(0xFF), switchId2(0xFF),
+        doIHaveTwoSwitches(false) {
 }
-PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
-		uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
-		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2), doIHaveTwoSwitches(
-				twoSwitches), min(min), max(max), moduleId(moduleId) {
+
+PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min,
+        float max, uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
+		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2),
+		doIHaveTwoSwitches(twoSwitches), min(min), max(max),
+		moduleId(moduleId) {
 }
 
 ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index dc5217be1..c1add3b91 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -1,13 +1,17 @@
-#ifndef POWERCOMPONENT_H_
-#define POWERCOMPONENT_H_
+#ifndef FSFW_POWER_POWERCOMPONENT_H_
+#define FSFW_POWER_POWERCOMPONENT_H_
 
+#include "PowerComponentIF.h"
+
+#include "../objectmanager/frameworkObjects.h"
 #include "../objectmanager/SystemObjectIF.h"
-#include "../power/PowerComponentIF.h"
+
 
 class PowerComponent: public PowerComponentIF {
 public:
-	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
-			bool twoSwitches = false, uint8_t switchId2 = 0xFF);
+	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
+	        uint8_t switchId1, bool twoSwitches = false,
+	        uint8_t switchId2 = 0xFF);
 
 	virtual object_id_t getDeviceObjectId();
 
@@ -31,18 +35,18 @@ public:
 				ParameterWrapper *parameterWrapper,
 				const ParameterWrapper *newValues, uint16_t startAtIndex);
 private:
-	const object_id_t deviceObjectId;
+	const object_id_t deviceObjectId = objects::NO_OBJECT;
 	const uint8_t switchId1;
 	const uint8_t switchId2;
 
 	const bool doIHaveTwoSwitches;
 
-	float min;
-	float max;
+	float min = 0.0;
+	float max = 0.0;
 
-	uint8_t moduleId;
+	uint8_t moduleId = 0;
 
 	PowerComponent();
 };
 
-#endif /* POWERCOMPONENT_H_ */
+#endif /* FSFW_POWER_POWERCOMPONENT_H_ */
diff --git a/power/PowerComponentIF.h b/power/PowerComponentIF.h
index c2e3a6a56..58f27b6c8 100644
--- a/power/PowerComponentIF.h
+++ b/power/PowerComponentIF.h
@@ -1,5 +1,5 @@
-#ifndef POWERCOMPONENTIF_H_
-#define POWERCOMPONENTIF_H_
+#ifndef FSFW_POWER_POWERCOMPONENTIF_H_
+#define FSFW_POWER_POWERCOMPONENTIF_H_
 
 #include "../serialize/SerializeIF.h"
 #include "../parameters/HasParametersIF.h"
@@ -10,15 +10,15 @@ public:
 
 	}
 
-	virtual object_id_t getDeviceObjectId()=0;
+	virtual object_id_t getDeviceObjectId() = 0;
 
-	virtual uint8_t getSwitchId1()=0;
-	virtual uint8_t getSwitchId2()=0;
-	virtual bool hasTwoSwitches()=0;
+	virtual uint8_t getSwitchId1() = 0;
+	virtual uint8_t getSwitchId2() = 0;
+	virtual bool hasTwoSwitches() = 0;
 
 	virtual float getMin() = 0;
 	virtual float getMax() = 0;
 
 };
 
-#endif /* POWERCOMPONENTIF_H_ */
+#endif /* FSFW_POWER_POWERCOMPONENTIF_H_ */
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index df26fb8e3..739d02f26 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -1,14 +1,16 @@
-#include "../power/PowerSensor.h"
+#include "PowerSensor.h"
+
 #include "../ipc/QueueFactory.h"
 
 PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
 		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
-		SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
-				ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
-				setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
+		SystemObject(setId), parameterHelper(this), healthHelper(this, setId),
+		set(), current(ids.pidCurrent, &set), voltage(ids.pidVoltage, &set),
+		power(ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE),
+		currentLimit(setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
 				limits.currentMin, limits.currentMax, events.currentLow,
-				events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
+				events.currentHigh),
+		voltageLimit(setId, MODULE_ID_VOLTAGE,
 				ids.pidVoltage, confirmationCount, limits.voltageMin,
 				limits.voltageMax, events.voltageLow, events.voltageHigh) {
 		commandQueue = QueueFactory::instance()->createMessageQueue();
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index da0bd8c73..20ebff397 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -1,5 +1,5 @@
-#ifndef POWERSENSOR_H_
-#define POWERSENSOR_H_
+#ifndef FSFW_POWER_POWERSENSOR_H_
+#define FSFW_POWER_POWERSENSOR_H_
 
 #include "../datapoolglob/GlobalDataSet.h"
 #include "../datapoolglob/GlobalPoolVariable.h"
@@ -50,7 +50,7 @@ public:
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex);
 private:
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
 	GlobDataSet set;
@@ -68,4 +68,4 @@ protected:
 	LimitMonitor<float> voltageLimit;
 };
 
-#endif /* POWERSENSOR_H_ */
+#endif /* FSFW_POWER_POWERSENSOR_H_ */
diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h
index 876a82c59..1422baebc 100644
--- a/power/PowerSwitchIF.h
+++ b/power/PowerSwitchIF.h
@@ -1,22 +1,15 @@
-/**
- * @file	PowerSwitchIF.h
- * @brief	This file defines the PowerSwitchIF class.
- * @date	20.03.2013
- * @author	baetz
- */
-
-#ifndef POWERSWITCHIF_H_
-#define POWERSWITCHIF_H_
+#ifndef FSFW_POWER_POWERSWITCHIF_H_
+#define FSFW_POWER_POWERSWITCHIF_H_
 
 #include "../events/Event.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 /**
  *
- * @brief   This interface defines a connection to a device that is capable of turning on and off
- *          switches of devices identified by a switch ID.
- * @details The virtual functions of this interface do not allow to make any assignments
- *          because they can be called asynchronosuly (const ending).
- *
+ * @brief   This interface defines a connection to a device that is capable of
+ *          turning on and off switches of devices identified by a switch ID.
+ * @details
+ * The virtual functions of this interface do not allow to make any assignments
+ * because they can be called asynchronosuly (const ending).
  * @ingroup interfaces
  */
 class PowerSwitchIF : public HasReturnvaluesIF {
@@ -77,4 +70,4 @@ public:
 };
 
 
-#endif /* POWERSWITCHIF_H_ */
+#endif /* FSFW_POWER_POWERSWITCHIF_H_ */
diff --git a/power/PowerSwitcher.cpp b/power/PowerSwitcher.cpp
index 1844a11af..a9ada4578 100644
--- a/power/PowerSwitcher.cpp
+++ b/power/PowerSwitcher.cpp
@@ -1,15 +1,17 @@
+#include "PowerSwitcher.h"
+
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../power/PowerSwitcher.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
-		PowerSwitcher::State_t setStartState) :
-		state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
+		PowerSwitcher::State_t setStartState):
+		state(setStartState), firstSwitch(setSwitch1),
+		secondSwitch(setSwitch2) {
 }
 
 ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
 	power = objectManager->get<PowerSwitchIF>(powerSwitchId);
-	if (power == NULL) {
+	if (power == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
@@ -17,17 +19,22 @@ ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
 
 ReturnValue_t PowerSwitcher::getStateOfSwitches() {
 	SwitchReturn_t result = howManySwitches();
+
 	switch (result) {
 	case ONE_SWITCH:
 		return power->getSwitchState(firstSwitch);
 	case TWO_SWITCHES:
-		if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
+	    ReturnValue_t firstSwitchState = power->getSwitchState(firstSwitch);
+	    ReturnValue_t secondSwitchState = power->getSwitchState(firstSwitch);
+		if ((firstSwitchState == PowerSwitchIF::SWITCH_ON)
+				&& (secondSwitchState == PowerSwitchIF::SWITCH_ON)) {
 			return PowerSwitchIF::SWITCH_ON;
-		} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
+		}
+		else if ((firstSwitchState == PowerSwitchIF::SWITCH_OFF)
+				&& (secondSwitchState  == PowerSwitchIF::SWITCH_OFF)) {
 			return PowerSwitchIF::SWITCH_OFF;
-		} else {
+		}
+		else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	default:
diff --git a/power/PowerSwitcher.h b/power/PowerSwitcher.h
index 515ce0428..f4e2138d4 100644
--- a/power/PowerSwitcher.h
+++ b/power/PowerSwitcher.h
@@ -1,10 +1,13 @@
-#ifndef POWERSWITCHER_H_
-#define POWERSWITCHER_H_
-#include "../power/PowerSwitchIF.h"
+#ifndef FSFW_POWER_POWERSWITCHER_H_
+#define FSFW_POWER_POWERSWITCHER_H_
+
+#include "PowerSwitchIF.h"
+
+#include "../objectmanager/SystemObjectIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../timemanager/Countdown.h"
 
-class PowerSwitcher : public HasReturnvaluesIF {
+class PowerSwitcher: public HasReturnvaluesIF {
 public:
 	enum State_t {
 		WAIT_OFF,
@@ -16,7 +19,8 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
 	static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
-	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
+	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH,
+	        State_t setStartState = SWITCH_IS_OFF );
 	ReturnValue_t initialize(object_id_t powerSwitchId);
 	void turnOn();
 	void turnOff();
@@ -29,7 +33,8 @@ public:
 private:
 	uint8_t firstSwitch;
 	uint8_t secondSwitch;
-	PowerSwitchIF* power;
+	PowerSwitchIF* power = nullptr;
+
 	static const uint8_t NO_SWITCH = 0xFF;
 	enum SwitchReturn_t {
 		ONE_SWITCH = 1,
@@ -42,4 +47,4 @@ private:
 
 
 
-#endif /* POWERSWITCHER_H_ */
+#endif /* FSFW_POWER_POWERSWITCHER_H_ */

From 6fd39dfac38da3c825f14b8171e05ef961dcb96c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:27:06 +0200
Subject: [PATCH 0811/1774] set struct reporting continued

---
 datapoollocal/LocalDataPoolManager.cpp | 12 ++++++++++++
 housekeeping/HousekeepingMessage.cpp   | 14 ++++++++++++++
 housekeeping/HousekeepingMessage.h     |  6 ++++++
 power/PowerComponentIF.h               |  5 ++---
 power/PowerSwitcher.cpp                |  3 ++-
 5 files changed, 36 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 635fafce3..553d2ec1f 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -392,5 +392,17 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		sif::error << "HousekeepingManager::generateSetStructurePacket: "
 				"Expected size is not equal to serialized size" << std::endl;
 	}
+
+	CommandMessage reply;
+	if(isDiagnostics) {
+	    HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
+	            sid, storeId);
+	}
+	else {
+	    HousekeepingMessage::setHkStuctureReportReply(&reply,
+	                    sid, storeId);
+	}
+
+	hkQueue->reply(&reply);
 	return result;
 }
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 254750720..706bd2730 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -126,3 +126,17 @@ sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
 	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
 }
+
+void HousekeepingMessage::setHkStuctureReportReply(CommandMessage *reply,
+        sid_t sid, store_address_t storeId) {
+    reply->setCommand(HK_DEFINITIONS_REPORT);
+    setSid(reply, sid);
+    reply->setParameter3(storeId.raw);
+}
+
+void HousekeepingMessage::setDiagnosticsStuctureReportReply(
+        CommandMessage *reply, sid_t sid, store_address_t storeId) {
+    reply->setCommand(DIAGNOSTICS_DEFINITION_REPORT);
+    setSid(reply, sid);
+    reply->setParameter3(storeId.raw);
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 5c1b4e55c..af89dadee 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -121,6 +121,12 @@ public:
 	static void setHkRequestSuccessReply(CommandMessage* reply, sid_t sid);
 	static void setHkRequestFailureReply(CommandMessage* reply, sid_t sid,
 			ReturnValue_t error);
+
+	static void setHkStuctureReportReply(CommandMessage* reply,
+	        sid_t sid, store_address_t storeId);
+	static void setDiagnosticsStuctureReportReply(CommandMessage* reply,
+	            sid_t sid, store_address_t storeId);
+
 	static sid_t getHkRequestFailureReply(const CommandMessage* reply,
 			ReturnValue_t* error);
 
diff --git a/power/PowerComponentIF.h b/power/PowerComponentIF.h
index 58f27b6c8..f35b4d1d3 100644
--- a/power/PowerComponentIF.h
+++ b/power/PowerComponentIF.h
@@ -3,12 +3,11 @@
 
 #include "../serialize/SerializeIF.h"
 #include "../parameters/HasParametersIF.h"
+#include "../objectmanager/SystemObjectIF.h"
 
 class PowerComponentIF : public SerializeIF, public HasParametersIF {
 public:
-	virtual ~PowerComponentIF() {
-
-	}
+	virtual ~PowerComponentIF() {}
 
 	virtual object_id_t getDeviceObjectId() = 0;
 
diff --git a/power/PowerSwitcher.cpp b/power/PowerSwitcher.cpp
index a9ada4578..ed37998ec 100644
--- a/power/PowerSwitcher.cpp
+++ b/power/PowerSwitcher.cpp
@@ -23,7 +23,7 @@ ReturnValue_t PowerSwitcher::getStateOfSwitches() {
 	switch (result) {
 	case ONE_SWITCH:
 		return power->getSwitchState(firstSwitch);
-	case TWO_SWITCHES:
+	case TWO_SWITCHES: {
 	    ReturnValue_t firstSwitchState = power->getSwitchState(firstSwitch);
 	    ReturnValue_t secondSwitchState = power->getSwitchState(firstSwitch);
 		if ((firstSwitchState == PowerSwitchIF::SWITCH_ON)
@@ -37,6 +37,7 @@ ReturnValue_t PowerSwitcher::getStateOfSwitches() {
 		else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
+	}
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}

From 55bdd2c2f5e8d656375912dc24a4d40515bca925 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:28:28 +0200
Subject: [PATCH 0812/1774] include fix

---
 datapoollocal/LocalDataPoolManager.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 553d2ec1f..7986a3edc 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,6 +1,7 @@
-#include <fsfw/housekeeping/HousekeepingSetPacket.h>
 #include "LocalDataPoolManager.h"
 #include "LocalPoolDataSetBase.h"
+
+#include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"

From 50621704073764a4673288442e54346af7bf4af2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:32:16 +0200
Subject: [PATCH 0813/1774] correct function used now

---
 datapoollocal/LocalDataPoolManager.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 7986a3edc..4299861e5 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -154,9 +154,9 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     }
 
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
+        return generateSetStructurePacket(sid, true);
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-		//return generateSetStructurePacket(sid, );
-		return HasReturnvaluesIF::RETURN_OK;
+        return generateSetStructurePacket(sid, false);
     case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
     case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
     	float newCollIntvl = 0;
@@ -354,6 +354,7 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		bool isDiagnostics) {
+    // Get and check dataset first.
 	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
 			owner->getDataSetHandle(sid));
 	if(dataSet == nullptr) {
@@ -373,6 +374,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 	float collectionInterval =
 			dataSet->periodicHelper->getCollectionIntervalInSeconds();
 
+	// Generate set packet which can be serialized.
 	HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid,
 			reportingEnabled, valid, collectionInterval, dataSet);
 	size_t expectedSize = setPacket.getSerializedSize();
@@ -386,6 +388,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		return result;
 	}
 
+	// Serialize set packet into store.
 	size_t size = 0;
 	result = setPacket.serialize(&storePtr, &size, expectedSize,
 			SerializeIF::Endianness::BIG);
@@ -394,6 +397,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 				"Expected size is not equal to serialized size" << std::endl;
 	}
 
+	// Send structure reporting reply.
 	CommandMessage reply;
 	if(isDiagnostics) {
 	    HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,

From de08bd6c8a9b8ec3f0627a028c319446d0a09bc7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:33:24 +0200
Subject: [PATCH 0814/1774] small include fix

---
 datapoollocal/LocalPoolVector.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 69df192cc..57c4b90b4 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -194,7 +194,7 @@ private:
 
 };
 
-#include "../datapoollocal/LocalPoolVector.tpp"
+#include "LocalPoolVector.tpp"
 
 template<typename T, uint16_t vectorSize>
 using lp_vec_t = LocalPoolVector<T, vectorSize>;

From 52d8c4f3a84c870e67f251be025ec27f657d2e17 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:35:10 +0200
Subject: [PATCH 0815/1774] include guard fix

---
 datapoollocal/LocalDataPoolManager.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 44b15f59c..55d971ceb 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 
 #include "HasLocalDataPoolIF.h"
 
@@ -276,4 +276,4 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 }
 
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */

From e67b1fce9a1f23d30a73d41142472adb7fb42b57 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 16:38:07 +0200
Subject: [PATCH 0816/1774] added additional include

---
 controller/ControllerBase.h          | 1 +
 datapoollocal/LocalDataPoolManager.h | 1 +
 2 files changed, 2 insertions(+)

diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 400c3bb6c..6c2ec1d66 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -7,6 +7,7 @@
 #include "../modes/ModeHelper.h"
 #include "../objectmanager/SystemObject.h"
 #include "../tasks/ExecutableObjectIF.h"
+#include "../tasks/PeriodicTaskIF.h"
 #include "../datapool/HkSwitchHelper.h"
 
 /**
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 55d971ceb..3b9b6cd92 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -173,6 +173,7 @@ private:
     //! Every housekeeping data manager has a mutex to protect access
     //! to it's data pool.
     MutexIF* mutex = nullptr;
+
     /** The class which actually owns the manager (and its datapool). */
     HasLocalDataPoolIF* owner = nullptr;
 

From 4a97596030f2dbebcdebdd00c2c524e74df00d36 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 17:21:32 +0200
Subject: [PATCH 0817/1774] internal error reporter uses new local datapool now

---
 internalError/InternalErrorDataset.h    |  31 +++++++
 internalError/InternalErrorReporter.cpp | 107 +++++++++++++++++-------
 internalError/InternalErrorReporter.h   |  63 ++++++++++----
 3 files changed, 158 insertions(+), 43 deletions(-)
 create mode 100644 internalError/InternalErrorDataset.h

diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
new file mode 100644
index 000000000..c5dc3d73f
--- /dev/null
+++ b/internalError/InternalErrorDataset.h
@@ -0,0 +1,31 @@
+#ifndef FSFW_INTERNALERROR_INTERNALERRORDATASET_H_
+#define FSFW_INTERNALERROR_INTERNALERRORDATASET_H_
+
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+
+enum errorPoolIds {
+    TM_HITS,
+    QUEUE_HITS,
+    STORE_HITS
+};
+
+
+class InternalErrorDataset: public StaticLocalDataSet<3 * sizeof(uint32_t)> {
+public:
+    static constexpr uint8_t ERROR_SET_ID = 0;
+
+    InternalErrorDataset(HasLocalDataPoolIF* owner):
+            StaticLocalDataSet(owner, ERROR_SET_ID) {}
+
+    InternalErrorDataset(sid_t sid):
+           StaticLocalDataSet(sid) {}
+
+    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(TM_HITS, sid.objectId, this);
+    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(QUEUE_HITS, sid.objectId, this);
+    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(STORE_HITS, sid.objectId, this);
+};
+
+
+
+#endif /* FSFW_INTERNALERROR_INTERNALERRORDATASET_H_ */
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 3424266bd..f22fd03ac 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,16 +1,18 @@
-#include "../datapoolglob/GlobalDataSet.h"
 #include "InternalErrorReporter.h"
 
+#include "../ipc/QueueFactory.h"
+#include "../datapoolglob/GlobalDataSet.h"
 #include "../datapoolglob/GlobalPoolVariable.h"
 #include "../ipc/MutexFactory.h"
-
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
-		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
-		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
-		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
-		storeHits(0) {
+        uint32_t messageQueueDepth) :
+		SystemObject(setObjectId),
+		commandQueue(QueueFactory::instance()->
+		        createMessageQueue(messageQueueDepth)),
+		poolManager(this, commandQueue),
+		internalErrorDataset(this) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
@@ -18,28 +20,40 @@ InternalErrorReporter::~InternalErrorReporter() {
 	MutexFactory::instance()->deleteMutex(mutex);
 }
 
+void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
+    this->diagnosticPrintout = enable;
+}
+
 ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
-
-	GlobDataSet mySet;
-	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-
-	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
+    internalErrorDataset.read(INTERNAL_ERROR_MUTEX_TIMEOUT);
 
 	uint32_t newQueueHits = getAndResetQueueHits();
 	uint32_t newTmHits = getAndResetTmHits();
 	uint32_t newStoreHits = getAndResetStoreHits();
 
-	queueHitsInPool.value += newQueueHits;
-	tmHitsInPool.value += newTmHits;
-	storeHitsInPool.value += newStoreHits;
+#ifdef DEBUG
+	if(diagnosticPrintout) {
+	    if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
+	        sif::debug << "InternalErrorReporter::performOperation: Errors "
+	                << "occured!" << std::endl;
+	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
+	        sif::debug << "TM errors: " << newQueueHits << std::endl;
+	        sif::debug << "Store errors: " << newQueueHits << std::endl;
+	    }
+	}
+#endif
 
-	mySet.commit(PoolVariableIF::VALID);
+	internalErrorDataset.queueHits.value += newQueueHits;
+	internalErrorDataset.storeHits.value += newTmHits;
+	internalErrorDataset.tmHits.value += newStoreHits;
 
+	internalErrorDataset.commit(INTERNAL_ERROR_MUTEX_TIMEOUT);
+
+	CommandMessage message;
+	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	if(result != MessageQueueIF::EMPTY) {
+	    poolManager.handleHousekeepingMessage(&message);
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -53,7 +67,7 @@ void InternalErrorReporter::lostTm() {
 
 uint32_t InternalErrorReporter::getAndResetQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = queueHits;
 	queueHits = 0;
 	mutex->unlockMutex();
@@ -62,21 +76,21 @@ uint32_t InternalErrorReporter::getAndResetQueueHits() {
 
 uint32_t InternalErrorReporter::getQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = queueHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	queueHits++;
 	mutex->unlockMutex();
 }
 
 uint32_t InternalErrorReporter::getAndResetTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = tmHits;
 	tmHits = 0;
 	mutex->unlockMutex();
@@ -85,14 +99,14 @@ uint32_t InternalErrorReporter::getAndResetTmHits() {
 
 uint32_t InternalErrorReporter::getTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = tmHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	tmHits++;
 	mutex->unlockMutex();
 }
@@ -103,7 +117,7 @@ void InternalErrorReporter::storeFull() {
 
 uint32_t InternalErrorReporter::getAndResetStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = storeHits;
 	storeHits = 0;
 	mutex->unlockMutex();
@@ -112,14 +126,49 @@ uint32_t InternalErrorReporter::getAndResetStoreHits() {
 
 uint32_t InternalErrorReporter::getStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = storeHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	storeHits++;
 	mutex->unlockMutex();
 }
+
+object_id_t InternalErrorReporter::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
+    return this->commandQueue->getId();
+}
+
+ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
+        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+    localDataPoolMap.emplace(errorPoolIds::TM_HITS,
+            new PoolEntry<uint32_t>());
+    localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS,
+            new PoolEntry<uint32_t>());
+    localDataPoolMap.emplace(errorPoolIds::STORE_HITS,
+            new PoolEntry<uint32_t>());
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() {
+    return &poolManager;
+}
+
+dur_millis_t InternalErrorReporter::getPeriodicOperationFrequency() const {
+    return this->executingTask->getPeriodMs();
+}
+
+LocalPoolDataSetBase* InternalErrorReporter::getDataSetHandle(sid_t sid) {
+    return &internalErrorDataset;
+}
+
+void InternalErrorReporter::setTaskIF(PeriodicTaskIF *task) {
+    this->executingTask = task;
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 9aa24a0fa..1deb14221 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -1,37 +1,72 @@
-#ifndef INTERNALERRORREPORTER_H_
-#define INTERNALERRORREPORTER_H_
+#ifndef FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_
+#define FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_
 
 #include "InternalErrorReporterIF.h"
 
+#include "../tasks/PeriodicTaskIF.h"
+#include "../internalError/InternalErrorDataset.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../ipc/MutexIF.h"
 
+/**
+ * @brief   This class is used to track internal errors like lost telemetry,
+ *          failed message sending or a full store.
+ * @details
+ * All functions were kept virtual so this class can be extended easily
+ * to store custom internal errors (e.g. communication interface errors).
+ */
 class InternalErrorReporter: public SystemObject,
 		public ExecutableObjectIF,
-		public InternalErrorReporterIF {
+		public InternalErrorReporterIF,
+		public HasLocalDataPoolIF {
 public:
-	InternalErrorReporter(object_id_t setObjectId, uint32_t queuePoolId,
-			uint32_t tmPoolId, uint32_t storePoolId);
+    static constexpr uint8_t INTERNAL_ERROR_MUTEX_TIMEOUT = 20;
+
+	InternalErrorReporter(object_id_t setObjectId,
+	        uint32_t messageQueueDepth = 5);
+
+	/**
+	 * Enable diagnostic printout. Please note that this feature will
+	 * only work if DEBUG has been supplied to the build defines.
+	 * @param enable
+	 */
+	void setDiagnosticPrintout(bool enable);
+
 	virtual ~InternalErrorReporter();
 
-	virtual ReturnValue_t performOperation(uint8_t opCode);
+    virtual object_id_t getObjectId() const override;
+    virtual MessageQueueId_t getCommandQueue() const override;
+    virtual ReturnValue_t initializeLocalDataPool(
+            LocalDataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override;
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
+    virtual dur_millis_t getPeriodicOperationFrequency() const override;
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
 	virtual void queueMessageNotSent();
 
 	virtual void lostTm();
 
 	virtual void storeFull();
+
+	virtual void setTaskIF(PeriodicTaskIF* task) override;
 protected:
-	MutexIF* mutex;
+	MessageQueueIF* commandQueue;
+	LocalDataPoolManager poolManager;
 
-	uint32_t queuePoolId;
-	uint32_t tmPoolId;
-	uint32_t storePoolId;
+	PeriodicTaskIF* executingTask = nullptr;
+	MutexIF* mutex = nullptr;
+	InternalErrorDataset internalErrorDataset;
 
-	uint32_t queueHits;
-	uint32_t tmHits;
-	uint32_t storeHits;
+	bool diagnosticPrintout = true;
+
+	uint32_t queueHits = 0;
+	uint32_t tmHits = 0;
+	uint32_t storeHits = 0;
 
 	uint32_t getAndResetQueueHits();
 	uint32_t getQueueHits();
@@ -47,4 +82,4 @@ protected:
 
 };
 
-#endif /* INTERNALERRORREPORTER_H_ */
+#endif /* FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_ */

From c3830da3d0a1f871bfca904b240f7cedfbb2a366 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 17:24:06 +0200
Subject: [PATCH 0818/1774] bugfixes

---
 internalError/InternalErrorReporter.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index f22fd03ac..3f7a06190 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -37,15 +37,15 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	        sif::debug << "InternalErrorReporter::performOperation: Errors "
 	                << "occured!" << std::endl;
 	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
-	        sif::debug << "TM errors: " << newQueueHits << std::endl;
-	        sif::debug << "Store errors: " << newQueueHits << std::endl;
+	        sif::debug << "TM errors: " << newTmHits << std::endl;
+	        sif::debug << "Store errors: " << newStoreHits << std::endl;
 	    }
 	}
 #endif
 
 	internalErrorDataset.queueHits.value += newQueueHits;
-	internalErrorDataset.storeHits.value += newTmHits;
-	internalErrorDataset.tmHits.value += newStoreHits;
+	internalErrorDataset.storeHits.value += newStoreHits;
+	internalErrorDataset.tmHits.value += newTmHits;
 
 	internalErrorDataset.commit(INTERNAL_ERROR_MUTEX_TIMEOUT);
 

From 6eaade239579ca814bb3aaded0f858b8f7bf47d7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 17:28:03 +0200
Subject: [PATCH 0819/1774] added new mode for local datapool manager

---
 datapoollocal/LocalDataPoolManager.h    | 2 ++
 internalError/InternalErrorReporter.cpp | 5 +++++
 internalError/InternalErrorReporter.h   | 1 +
 3 files changed, 8 insertions(+)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 3b9b6cd92..6fb51b3e3 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -146,6 +146,8 @@ public:
     enum class ReportingType: uint8_t {
         //! Periodic generation of HK packets.
         PERIODIC,
+        //! Housekeeping packet will be generated if values have changed.
+        UPDATE_HK,
 		//! Update notification will be sent out as message.
 		UPDATE_NOTIFICATION,
         //! Notification will be sent out as message and a snapshot of the
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 3f7a06190..767ece51b 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -12,6 +12,7 @@ InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
 		commandQueue(QueueFactory::instance()->
 		        createMessageQueue(messageQueueDepth)),
 		poolManager(this, commandQueue),
+		internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
 		internalErrorDataset(this) {
 	mutex = MutexFactory::instance()->createMutex();
 }
@@ -154,6 +155,10 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
             new PoolEntry<uint32_t>());
     localDataPoolMap.emplace(errorPoolIds::STORE_HITS,
             new PoolEntry<uint32_t>());
+    // todo: Only send HK if values have changed, will be supported by
+    // pool manager soon.
+    poolManager.subscribeForPeriodicPacket(internalErrorSid, false,
+            getPeriodicOperationFrequency(), false);
     return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 1deb14221..85ac0836d 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -60,6 +60,7 @@ protected:
 
 	PeriodicTaskIF* executingTask = nullptr;
 	MutexIF* mutex = nullptr;
+	sid_t internalErrorSid;
 	InternalErrorDataset internalErrorDataset;
 
 	bool diagnosticPrintout = true;

From c12110cbf16c71394aa939e67629fc3c11370472 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 22:23:17 +0200
Subject: [PATCH 0820/1774] has file system IF retvals

---
 memory/HasFileSystemIF.h  | 15 ++++++++++++++-
 returnvalues/FwClassIds.h |  6 +++---
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 6065ebfdf..916169ee6 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -2,12 +2,24 @@
 #define FSFW_MEMORY_HASFILESYSTEMIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
+#include "../returnvalues/FwClassIds.h"
+#include "../ipc/messageQueueDefinitions.h"
+
+#include <cstddef>
 
 /**
  * @author  Jakob Meier
  */
 class HasFileSystemIF {
 public:
+    static constexpr uint8_t INTERFACE_ID = CLASS_ID::FILE_SYSTEM;
+
+    static constexpr ReturnValue_t FILE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x00);
+    static constexpr ReturnValue_t FILE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+
+    static constexpr ReturnValue_t DIRECTORY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
+    static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x03);
+    static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(0x04);
 
 	virtual ~HasFileSystemIF() {}
 	/**
@@ -29,7 +41,8 @@ public:
 	virtual ReturnValue_t writeToFile(const char* dirname, const char* filename,
 	        const uint8_t* data, size_t size, uint16_t packetNumber) = 0;
 	virtual ReturnValue_t createFile(const char* dirname, const char* filename,
-	        const uint8_t* data, size_t size) = 0;
+	        const uint8_t* data = nullptr, size_t size = 0,
+	        size_t* bytesWritten = nullptr) = 0;
 	virtual ReturnValue_t deleteFile(const char* dirname,
 	        const char* filename) = 0;
 };
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 781320e3f..c8c0a3adc 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -65,9 +65,9 @@ enum {
 	POOL_VARIABLE_IF, //PVA 59
 	HOUSEKEEPING_MANAGER, //HKM 60
 	DLE_ENCODER, //DLEE 61
-	PUS_PARSER, //PUSP 62
-	SERIAL_ANALYZER, //SERA 63
-	PUS_SERVICE_9, // PUS9 64
+	SERIAL_ANALYZER, //SERA 62
+	PUS_SERVICE_9, // PUS9 63
+	FILE_SYSTEM, // FLSY 64
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 88c4b2a5390a927d1eda33e9ac410ddc757cfc45 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 16:56:42 +0200
Subject: [PATCH 0821/1774] bugfixes for srv3

---
 datapoollocal/LocalDataPoolManager.cpp  | 63 +++++++++++++++----------
 housekeeping/HousekeepingSetPacket.h    |  1 +
 internalError/InternalErrorReporter.cpp |  8 ++++
 internalError/InternalErrorReporter.h   |  1 +
 pus/Service3Housekeeping.cpp            | 21 +++++++--
 pus/Service3Housekeeping.h              |  2 +-
 6 files changed, 64 insertions(+), 32 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 4299861e5..f07f458ec 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -15,42 +15,53 @@ object_id_t LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
         appendValidityBuffer(appendValidityBuffer) {
-	if(owner == nullptr) {
-		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
-		return;
-	}
-	this->owner = owner;
-	mutex = MutexFactory::instance()->createMutex();
-	if(mutex == nullptr) {
-	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-	            "Could not create mutex." << std::endl;
-	}
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if(ipcStore == nullptr) {
-	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-	            "Could not set IPC store." << std::endl;
-	}
+    if(owner == nullptr) {
+        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+                << "Invalid supplied owner!" << std::endl;
+        return;
+    }
+    this->owner = owner;
+    mutex = MutexFactory::instance()->createMutex();
+    if(mutex == nullptr) {
+        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+                << "Could not create mutex." << std::endl;
+    }
 
-	hkQueue = queueToUse;
-
-	if(defaultHkDestination != objects::NO_OBJECT) {
-	    AcceptsHkPacketsIF* hkPacketReceiver =
-	            objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
-	    if(hkPacketReceiver != nullptr) {
-	        hkDestinationId = hkPacketReceiver->getHkQueue();
-	    }
-	}
+    hkQueue = queueToUse;
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
-        sif::error << "LocalDataPoolManager::initialize: Supplied queue "
-                "invalid!" << std::endl;
+        sif::error << "LocalDataPoolManager::initialize: "
+                << std::hex << "0x" << owner->getObjectId() << ". Supplied "
+                << "queue invalid!" << std::dec << std::endl;
     }
     hkQueue = queueToUse;
 
+    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if(ipcStore == nullptr) {
+        sif::error << "LocalDataPoolManager::initialize: "
+                << std::hex << "0x" << owner->getObjectId() << ": Could not "
+                << "set IPC store." <<std::dec << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+
+    if(defaultHkDestination != objects::NO_OBJECT) {
+        AcceptsHkPacketsIF* hkPacketReceiver =
+                objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
+        if(hkPacketReceiver != nullptr) {
+            hkDestinationId = hkPacketReceiver->getHkQueue();
+        }
+        else {
+            sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+                   << "Default HK destination object is invalid!" << std::endl;
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+
     return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/housekeeping/HousekeepingSetPacket.h b/housekeeping/HousekeepingSetPacket.h
index 007b95be7..051e4c614 100644
--- a/housekeeping/HousekeepingSetPacket.h
+++ b/housekeeping/HousekeepingSetPacket.h
@@ -12,6 +12,7 @@ public:
 			objectId(sid.objectId), setId(sid.ownerSetId),
 			reportingEnabled(reportingEnabled), valid(valid),
 			collectionIntervalSeconds(collectionInterval), dataSet(dataSetPtr) {
+	    setLinks();
 	}
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 767ece51b..4cdab9e73 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -177,3 +177,11 @@ LocalPoolDataSetBase* InternalErrorReporter::getDataSetHandle(sid_t sid) {
 void InternalErrorReporter::setTaskIF(PeriodicTaskIF *task) {
     this->executingTask = task;
 }
+
+ReturnValue_t InternalErrorReporter::initialize() {
+    ReturnValue_t result = poolManager.initialize(commandQueue);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return SystemObject::initialize();
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 85ac0836d..c715f7a07 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -45,6 +45,7 @@ public:
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 
+    virtual ReturnValue_t initialize() override;
 	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
 	virtual void queueMessageNotSent();
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index ad08c3280..c668ec8ed 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -181,7 +181,7 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 	switch(command) {
 
 	case(HousekeepingMessage::HK_REPORT): {
-		ReturnValue_t result = generateHkReport(reply,
+		ReturnValue_t result = generateHkReply(reply,
 				static_cast<uint8_t>(Subservice::HK_REPORT));
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
@@ -190,7 +190,7 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 	}
 
 	case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
-		ReturnValue_t result = generateHkReport(reply,
+		ReturnValue_t result = generateHkReply(reply,
 				static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
@@ -198,6 +198,17 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 		return CommandingServiceBase::EXECUTION_COMPLETE;
 	}
 
+    case(HousekeepingMessage::HK_DEFINITIONS_REPORT): {
+        return generateHkReply(reply, static_cast<uint8_t>(
+                Subservice::HK_DEFINITIONS_REPORT));
+        break;
+    }
+    case(HousekeepingMessage::DIAGNOSTICS_DEFINITION_REPORT): {
+        return generateHkReply(reply, static_cast<uint8_t>(
+                Subservice::DIAGNOSTICS_REPORT));
+        break;
+    }
+
 	case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
 		return CommandingServiceBase::EXECUTION_COMPLETE;
 	}
@@ -226,13 +237,13 @@ void Service3Housekeeping::handleUnrequestedReply(
 	switch(command) {
 
 	case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
-		result = generateHkReport(reply,
+		result = generateHkReply(reply,
 				static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
 		break;
 	}
 
 	case(HousekeepingMessage::HK_REPORT): {
-		result = generateHkReport(reply,
+		result = generateHkReply(reply,
 				static_cast<uint8_t>(Subservice::HK_REPORT));
 		break;
 	}
@@ -254,7 +265,7 @@ MessageQueueId_t Service3Housekeeping::getHkQueue() const {
 	return commandQueue->getId();
 }
 
-ReturnValue_t Service3Housekeeping::generateHkReport(
+ReturnValue_t Service3Housekeeping::generateHkReply(
 		const CommandMessage* hkMessage, uint8_t subserviceId) {
 	store_address_t storeId;
 
diff --git a/pus/Service3Housekeeping.h b/pus/Service3Housekeeping.h
index 01964bab1..269710ef3 100644
--- a/pus/Service3Housekeeping.h
+++ b/pus/Service3Housekeeping.h
@@ -82,7 +82,7 @@ private:
 	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
 			MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
 
-	ReturnValue_t generateHkReport(const CommandMessage* hkMessage,
+	ReturnValue_t generateHkReply(const CommandMessage* hkMessage,
 			uint8_t subserviceId);
 	ReturnValue_t prepareReportingTogglingCommand(CommandMessage* command,
 			object_id_t objectId, bool enableReporting, bool isDiagnostics,

From bf574c12e4ea8397062d17a3e047e7de7d223437 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 21:09:56 +0200
Subject: [PATCH 0822/1774] bugfixes, owner ptr not const anymore

---
 datapoollocal/LocalDataPoolManager.cpp |  3 ++-
 datapoollocal/LocalDataPoolManager.h   |  2 +-
 datapoollocal/LocalPoolDataSetBase.cpp | 20 ++++++++++++--
 datapoollocal/LocalPoolDataSetBase.h   |  4 ++-
 datapoollocal/LocalPoolVariable.tpp    | 37 +++++++++++++-------------
 housekeeping/HousekeepingSetPacket.h   |  2 +-
 6 files changed, 44 insertions(+), 24 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f07f458ec..1a8239ae9 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -229,7 +229,7 @@ MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
-const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
+HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
     return owner;
 }
 
@@ -374,6 +374,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
+
 	bool targetIsDiagnostics = dataSet->isDiagnostics();
 	if((targetIsDiagnostics and not isDiagnostics) or
 			(not targetIsDiagnostics and isDiagnostics)) {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 6fb51b3e3..e55efa9c5 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -127,7 +127,7 @@ public:
 	 */
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
-	const HasLocalDataPoolIF* getOwner() const;
+	HasLocalDataPoolIF* getOwner();
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index c280e7c7e..da0a86b2c 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -119,8 +119,14 @@ ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
+        size_t* size, size_t maxSize,SerializeIF::Endianness streamEndianness,
+        bool serializeFillCount) const {
+    // Serialize as uint8_t
+    uint8_t fillCount = this->fillCount;
+    if(serializeFillCount) {
+        SerializeAdapter::serialize(&fillCount, buffer, size, maxSize,
+                streamEndianness);
+    }
     for (uint16_t count = 0; count < fillCount; count++) {
         lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
         auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
@@ -135,6 +141,16 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
 }
 
 
+uint8_t LocalPoolDataSetBase::getLocalPoolIdsSerializedSize(
+        bool serializeFillCount) const {
+    if(serializeFillCount) {
+        return fillCount * sizeof(lp_id_t) + sizeof(uint8_t);
+    }
+    else {
+        return fillCount * sizeof(lp_id_t);
+    }
+}
+
 size_t LocalPoolDataSetBase::getSerializedSize() const {
     if(withValidityBuffer) {
         uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 83e0425cd..4f277123b 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -97,7 +97,9 @@ public:
 	        size_t *size, SerializeIF::Endianness streamEndianness);
 	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
 	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const;
+	        SerializeIF::Endianness streamEndianness,
+	        bool serializeFillCount = true) const;
+	uint8_t getLocalPoolIdsSerializedSize(bool serializeFillCount = true) const;
 
 	/**
 	 * Set the dataset valid or invalid
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 09d10acc7..b47e602ca 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -9,36 +9,37 @@ template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
 		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
 		pool_rwm_t setReadWriteMode):
-		localPoolId(poolId),readWriteMode(setReadWriteMode) {
+		localPoolId(poolId), readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
-				"NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+		        << "which is the NO_PARAMETER value!" << std::endl;
 	}
 	if(hkOwner == nullptr) {
-		sif::error << "LocalPoolVariable: The supplied pool owner is a nullptr!"
-				<< std::endl;
+		sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+		        << "owner is a invalid!" << std::endl;
 		return;
 	}
 	hkManager = hkOwner->getHkManagerHandle();
 	if(dataSet != nullptr) {
-		dataSet->registerVariable(this);
+	    dataSet->registerVariable(this);
 	}
 }
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
-		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
-				"NO_PARAMETER value!" << std::endl;
-	}
-	HasLocalDataPoolIF* hkOwner =
-			objectManager->get<HasLocalDataPoolIF>(poolOwner);
-	if(hkOwner == nullptr) {
-		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
-				"the correct interface HasHkPoolParametersIF!" << std::endl;
-		return;
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        localPoolId(poolId), readWriteMode(setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
+    }
+    HasLocalDataPoolIF* hkOwner =
+            objectManager->get<HasLocalDataPoolIF>(poolOwner);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalPoolVariable: The supplied pool owner did not "
+                << "implement  the correct interface "
+                << "HasLocalDataPoolIF!" << std::endl;
+        return;
 	}
 	hkManager = hkOwner->getHkManagerHandle();
 	if(dataSet != nullptr) {
diff --git a/housekeeping/HousekeepingSetPacket.h b/housekeeping/HousekeepingSetPacket.h
index 051e4c614..f94720d4c 100644
--- a/housekeeping/HousekeepingSetPacket.h
+++ b/housekeeping/HousekeepingSetPacket.h
@@ -28,7 +28,7 @@ public:
 
 	size_t getSerializedSize() const override {
 		size_t linkedSize = SerialLinkedListAdapter::getSerializedSize();
-		linkedSize += dataSet->getFillCount() * sizeof(lp_id_t);
+		linkedSize += dataSet->getLocalPoolIdsSerializedSize();
 		return linkedSize;
 	}
 

From ad2ca814b2e100c7da2b3371244f28c70baa1e32 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 21:28:03 +0200
Subject: [PATCH 0823/1774] improved doc

---
 datapoollocal/LocalPoolDataSetBase.h | 24 +++++++++++++++++++-----
 datapoollocal/LocalPoolVariable.h    | 13 ++++++-------
 datapoollocal/LocalPoolVariable.tpp  |  6 +++---
 datapoollocal/StaticLocalDataSet.h   | 13 ++++++++-----
 4 files changed, 36 insertions(+), 20 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 4f277123b..d00af9920 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,7 +1,6 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
-
 #include "HasLocalDataPoolIF.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
@@ -16,15 +15,22 @@ class PeriodicHousekeepingHelper;
  * @brief	The LocalDataSet class manages a set of locally checked out
  *          variables for local data pools
  * @details
+ * Extends the PoolDataSetBase class for local data pools by introducing
+ * a validity state, a flag to mark the set as changed, and various other
+ * functions to make it usable by the LocalDataPoolManager class.
+ *
  * This class manages a list, where a set of local variables (or pool variables)
  * are registered. They are checked-out (i.e. their values are looked
  * up and copied) with the read call. After the user finishes working with the
  * pool variables, he can write back all variable values to the pool with
- * the commit call. The data set manages locking and freeing the local data pools,
- * to ensure thread-safety.
+ * the commit call. The data set manages locking and freeing the local data
+ * pools, to ensure thread-safety.
+ *
+ * Pool variables can be added to the dataset by using the constructor
+ * argument of the pool variable or using the #registerVariable member function.
  *
  * An internal state manages usage of this class. Variables may only be
- * registered before the read call is made, and the commit call only
+ * registered before any read call is made, and the commit call can only happen
  * after the read call.
  *
  * If pool variables are writable and not committed until destruction
@@ -72,6 +78,7 @@ public:
 
 	sid_t getSid() const;
 
+	/** SerializeIF overrides */
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
 	            SerializeIF::Endianness streamEndianness) const override;
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
@@ -82,7 +89,7 @@ public:
 	 * Special version of the serilization function which appends a
 	 * validity buffer at the end. Each bit of this validity buffer
 	 * denotes whether the container data set entries are valid from left
-	 * to right, MSB first.
+	 * to right, MSB first. (length = ceil(N/8), N = number of pool variables)
 	 * @param buffer
 	 * @param size
 	 * @param maxSize
@@ -142,6 +149,13 @@ protected:
 	 */
 	bool changed = false;
 
+	/**
+	 * Specify whether the validity buffer is serialized too when serializing
+	 * or deserializing the packet. Each bit of the validity buffer will
+	 * contain the validity state of the pool variables from left to right.
+	 * The size of validity buffer thus will be ceil(N / 8) with N = number of
+	 * pool variables.
+	 */
 	bool withValidityBuffer = true;
 
 	/**
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 6047342e4..ec5c8cd19 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,12 +1,12 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+
+#include "HasLocalDataPoolIF.h"
+#include "LocalDataPoolManager.h"
 
 #include "../datapool/PoolVariableIF.h"
 #include "../datapool/DataSetIF.h"
-#include "../datapoollocal/HasLocalDataPoolIF.h"
-#include "../datapoollocal/LocalDataPoolManager.h"
 #include "../objectmanager/ObjectManagerIF.h"
-
 #include "../serialize/SerializeAdapter.h"
 
 /**
@@ -41,7 +41,6 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-
 	 */
 	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 			DataSetIF* dataSet = nullptr,
@@ -175,4 +174,4 @@ using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
 
-#endif
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index b47e602ca..b0bdd7b9e 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
 
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 #error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
 #endif
 
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index 2f3068980..a637e360f 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -8,11 +8,14 @@
 /**
  * @brief   This local dataset type is created on the stack.
  * @details
- * Size of data set specified as a constructor argument. It is recommended
- * to use the default LocalDataSet of the dataset is constructed on the heap
- * and the SharedLocalDataSet if it created on the heap and used by multiple
- * other software objects.
- * @tparam capacity
+ * This will is the primary data structure to organize pool variables into
+ * sets which can be accessed via the housekeeping service interface or
+ * which can be sent to other software objects.
+ *
+ * It is recommended to read the documentation of the LocalPoolDataSetBase
+ * class for more information on how this class works and how to use it.
+ * @tparam capacity Capacity of the static dataset, which is usually known
+ * beforehand.
  */
 template <uint8_t NUM_VARIABLES>
 class StaticLocalDataSet: public LocalPoolDataSetBase {

From 786dcdf88d915c701a0266768b06e6158cdd59e9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 22:13:17 +0200
Subject: [PATCH 0824/1774] removed clock include

---
 datapoollocal/HasLocalDataPoolIF.h | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index e078f01e0..f8f4ef4c4 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -4,7 +4,6 @@
 #include "../datapool/PoolEntryIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
-#include "../timemanager/Clock.h"
 
 #include <map>
 
@@ -65,11 +64,11 @@ public:
 	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 
 	/**
-	 * Returns the minimum sampling frequency, which will usually be the
-	 * period the pool owner performs its periodic operation-
+	 * Returns the minimum sampling frequency in milliseconds, which will
+	 * usually be the period the pool owner performs its periodic operation.
 	 * @return
 	 */
-	virtual dur_millis_t getPeriodicOperationFrequency() const = 0;
+	virtual uint32_t getPeriodicOperationFrequency() const = 0;
 
 	/**
 	 * This function is used by the pool manager to get a valid dataset

From e48dbb87973ccbce0fb5679b7bd0ad726c34161b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 22:17:18 +0200
Subject: [PATCH 0825/1774] small improvements

---
 datapoollocal/LocalDataPoolManager.cpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 1a8239ae9..d8b573773 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -81,7 +81,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 		return result;
 	}
 	sif::warning << "HousekeepingManager: The map should only be initialized "
-	        "once!" << std::endl;
+	        << "once!" << std::endl;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -117,7 +117,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
 	if(hkReceiverObject == nullptr) {
 		sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-				" Invalid receiver!"<< std::endl;
+				<< " Invalid receiver!"<< std::endl;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
@@ -218,7 +218,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
 		sif::debug << "HousekeepingManager::fechPoolEntry:"
-				" Pool entry not found." << std::endl;
+				<< " Pool entry not found." << std::endl;
 		return POOL_ENTRY_NOT_FOUND;
 	}
 	poolIter->second->print();
@@ -239,7 +239,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	if(dataSet == nullptr) {
 		// Configuration error.
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				" Set ID not found or dataset not assigned!" << std::endl;
+				<< " Set ID not found or dataset not assigned!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -321,9 +321,9 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		// configuration error
 		sif::debug << "LocalDataPoolManager::performHkOperation:"
-				<< "0x" << std::setfill('0') << std::setw(8)
-		<< owner->getObjectId() << " Error generating "
-		<< "HK packet" << std::setfill(' ') << std::endl;
+				<< "0x" << std::hex << std::setfill('0') << std::setw(8)
+				<< owner->getObjectId() << " Error generating "
+				<< "HK packet" << std::setfill(' ') << std::dec << std::endl;
 	}
 }
 
@@ -370,7 +370,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 			owner->getDataSetHandle(sid));
 	if(dataSet == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				" Set ID not found" << std::endl;
+				<< " Set ID not found" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -396,7 +396,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 			expectedSize,&storePtr);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-				"Could not get free element from IPC store." << std::endl;
+				<< "Could not get free element from IPC store." << std::endl;
 		return result;
 	}
 
@@ -406,7 +406,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 			SerializeIF::Endianness::BIG);
 	if(expectedSize != size) {
 		sif::error << "HousekeepingManager::generateSetStructurePacket: "
-				"Expected size is not equal to serialized size" << std::endl;
+				<< "Expected size is not equal to serialized size" << std::endl;
 	}
 
 	// Send structure reporting reply.

From 7e9d095ed16264786480e648465efa7d44abe8d8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 22:38:36 +0200
Subject: [PATCH 0826/1774] important bugfixes

---
 datapool/PoolDataSetBase.cpp            |  5 +++++
 datapoollocal/LocalDataPoolManager.h    | 11 +++++++++--
 internalError/InternalErrorReporter.cpp |  7 ++++++-
 internalError/InternalErrorReporter.h   |  1 +
 4 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 1acd3fd3b..cb2348f72 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -59,6 +59,11 @@ uint16_t PoolDataSetBase::getFillCount() const {
 
 ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	if(registeredVariables[count] == nullptr) {
+	    // configuration error.
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	// These checks are often performed by the respective
 	// variable implementation too, but I guess a double check does not hurt.
 	if (registeredVariables[count]->getReadWriteMode() !=
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index e55efa9c5..c3b385e81 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -58,6 +58,7 @@ public:
     static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x03);
     static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x04);
     static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x05);
+
     /**
      * This constructor is used by a class which wants to implement
      * a personal local data pool. The queueToUse can be supplied if it
@@ -73,14 +74,20 @@ public:
 	virtual~ LocalDataPoolManager();
 
 	/**
-	 * Initializes the map by calling the map initialization function of the
-	 * owner and assigns the queue to use.
+	 * Assigns the queue to use.
 	 * @param queueToUse
 	 * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
 	 * @return
 	 */
 	ReturnValue_t initialize(MessageQueueIF* queueToUse);
 
+	/**
+	 * Initializes the map by calling the map initialization function and
+	 * setting the periodic factor for non-diagnostic packets.
+	 * Don't forget to call this, otherwise the map will be invalid!
+	 * @param nonDiagInvlFactor
+	 * @return
+	 */
 	ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
 
 	/**
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 4cdab9e73..943ae8b30 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -158,7 +158,7 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
     // todo: Only send HK if values have changed, will be supported by
     // pool manager soon.
     poolManager.subscribeForPeriodicPacket(internalErrorSid, false,
-            getPeriodicOperationFrequency(), false);
+            getPeriodicOperationFrequency(), true);
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -185,3 +185,8 @@ ReturnValue_t InternalErrorReporter::initialize() {
     }
     return SystemObject::initialize();
 }
+
+ReturnValue_t InternalErrorReporter::initializeAfterTaskCreation() {
+    return poolManager.initializeAfterTaskCreation();
+}
+
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index c715f7a07..8d33c06e2 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -46,6 +46,7 @@ public:
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 
     virtual ReturnValue_t initialize() override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
 	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
 	virtual void queueMessageNotSent();

From 1d972fcbef9e935121ad5a168ec1f5f6f2c8619d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 22:46:18 +0200
Subject: [PATCH 0827/1774] hk messages are cleared properly now

---
 housekeeping/HousekeepingMessage.cpp | 19 +++++++++++++++++++
 housekeeping/HousekeepingMessage.h   |  1 +
 ipc/CommandMessageCleaner.cpp        |  6 +++++-
 3 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 706bd2730..7c3e04f78 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/objectmanager/ObjectManagerIF.h>
 #include "HousekeepingMessage.h"
 #include <cstring>
 
@@ -140,3 +141,21 @@ void HousekeepingMessage::setDiagnosticsStuctureReportReply(
     setSid(reply, sid);
     reply->setParameter3(storeId.raw);
 }
+
+void HousekeepingMessage::clear(CommandMessage* message) {
+    switch(message->getCommand()) {
+    case(HK_REPORT):
+    case(DIAGNOSTICS_REPORT):
+    case(HK_DEFINITIONS_REPORT):
+    case(DIAGNOSTICS_DEFINITION_REPORT): {
+        store_address_t storeId;
+        getHkDataReply(message, &storeId);
+        StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+                objects::IPC_STORE);
+        if (ipcStore != nullptr) {
+            ipcStore->deleteData(storeId);
+        }
+    }
+    }
+    message->setCommand(CommandMessage::CMD_NONE);
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index af89dadee..f276e2636 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -142,6 +142,7 @@ public:
 	static sid_t getCollectionIntervalModificationCommand(
 			const CommandMessage* command, float* newCollectionInterval);
 
+	static void clear(CommandMessage* message);
 private:
 	static void setSid(CommandMessage* message, sid_t sid);
 };
diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
index 6a99b4d2d..fa03a9a38 100644
--- a/ipc/CommandMessageCleaner.cpp
+++ b/ipc/CommandMessageCleaner.cpp
@@ -1,4 +1,4 @@
-#include "../ipc/CommandMessageCleaner.h"
+#include "CommandMessageCleaner.h"
 
 #include "../devicehandlers/DeviceHandlerMessage.h"
 #include "../health/HealthMessage.h"
@@ -7,6 +7,7 @@
 #include "../monitoring/MonitoringMessage.h"
 #include "../subsystem/modes/ModeSequenceMessage.h"
 #include "../tmstorage/TmStoreMessage.h"
+#include "../housekeeping/HousekeepingMessage.h"
 #include "../parameters/ParameterMessage.h"
 
 void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
@@ -38,6 +39,9 @@ void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
 	case messagetypes::PARAMETER:
 		ParameterMessage::clear(message);
 		break;
+	case messagetypes::HOUSEKEEPING:
+	    HousekeepingMessage::clear(message);
+	    break;
 	default:
 		messagetypes::clearMissionMessage(message);
 		break;

From 62ee1391bf195337af99bddb151cd65fcc95504e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 22:48:10 +0200
Subject: [PATCH 0828/1774] added two new commands

---
 housekeeping/HousekeepingMessage.cpp | 3 ++-
 housekeeping/HousekeepingMessage.h   | 3 +++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 7c3e04f78..b07368e61 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -147,7 +147,8 @@ void HousekeepingMessage::clear(CommandMessage* message) {
     case(HK_REPORT):
     case(DIAGNOSTICS_REPORT):
     case(HK_DEFINITIONS_REPORT):
-    case(DIAGNOSTICS_DEFINITION_REPORT): {
+    case(DIAGNOSTICS_DEFINITION_REPORT):
+    case(UPDATE_SNAPSHOT):{
         store_address_t storeId;
         getHkDataReply(message, &storeId);
         StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index f276e2636..041a5eaa9 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -101,6 +101,9 @@ public:
 	static constexpr Command_t HK_REQUEST_FAILURE =
 			MAKE_COMMAND_ID(129);
 
+	static constexpr Command_t UPDATE_NOTIFICATION = MAKE_COMMAND_ID(130);
+	static constexpr Command_t UPDATE_SNAPSHOT = MAKE_COMMAND_ID(131);
+
 	static sid_t getSid(const CommandMessage* message);
 
 	static void setToggleReportingCommand(CommandMessage* command, sid_t sid,

From 7ff9c29b62cbd3738377bcb6883ac42362db4731 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 22:51:02 +0200
Subject: [PATCH 0829/1774] added another command

---
 housekeeping/HousekeepingMessage.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 041a5eaa9..6dc95f542 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -104,8 +104,11 @@ public:
 	static constexpr Command_t UPDATE_NOTIFICATION = MAKE_COMMAND_ID(130);
 	static constexpr Command_t UPDATE_SNAPSHOT = MAKE_COMMAND_ID(131);
 
+	static constexpr Command_t UPDATE_HK_REPORT = MAKE_COMMAND_ID(132);
+
 	static sid_t getSid(const CommandMessage* message);
 
+	/** Setter functions */
 	static void setToggleReportingCommand(CommandMessage* command, sid_t sid,
 			bool enableReporting, bool isDiagnostics);
 	static void setStructureReportingCommand(CommandMessage* command, sid_t sid,

From 1f70b1159d39527d58cbcd2a0e85ca46c2d66695 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 23:21:21 +0200
Subject: [PATCH 0830/1774] another small bugfix

---
 datapoollocal/LocalDataPoolManager.h        | 14 ++++++++------
 housekeeping/HousekeepingMessage.cpp        |  2 +-
 housekeeping/PeriodicHousekeepingHelper.cpp |  2 +-
 internalError/InternalErrorDataset.h        |  9 ++++++---
 internalError/InternalErrorReporter.cpp     |  4 ++--
 5 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c3b385e81..779e30500 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -90,6 +90,14 @@ public:
 	 */
 	ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
 
+    /**
+     * This should be called in the periodic handler of the owner.
+     * It performs all the periodic functionalities of the data pool manager,
+     * for example generating periodic HK packets.
+     * @return
+     */
+    ReturnValue_t performHkOperation();
+
 	/**
 	 * @return
 	 */
@@ -108,12 +116,6 @@ public:
 	 */
 	void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
 
-	/**
-	 * This should be called in the periodic handler of the owner.
-	 * It performs all the periodic functionalities of the data pool manager.
-	 * @return
-	 */
-	ReturnValue_t performHkOperation();
 
 	/**
 	 * Generate a housekeeping packet with a given SID.
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index b07368e61..d2ab546b0 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -148,7 +148,7 @@ void HousekeepingMessage::clear(CommandMessage* message) {
     case(DIAGNOSTICS_REPORT):
     case(HK_DEFINITIONS_REPORT):
     case(DIAGNOSTICS_DEFINITION_REPORT):
-    case(UPDATE_SNAPSHOT):{
+    case(UPDATE_SNAPSHOT): {
         store_address_t storeId;
         getHkDataReply(message, &storeId);
         StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
index d184489b5..37349f815 100644
--- a/housekeeping/PeriodicHousekeepingHelper.cpp
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -10,7 +10,7 @@ void PeriodicHousekeepingHelper::initialize(float collectionInterval,
 		dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
 		uint8_t nonDiagIntervalFactor) {
 	this->minimumPeriodicInterval = minimumPeriodicInterval;
-	if(isDiagnostics) {
+	if(not isDiagnostics) {
 		this->minimumPeriodicInterval = this->minimumPeriodicInterval *
 				nonDiagIntervalFactor;
 	}
diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
index c5dc3d73f..6bba11719 100644
--- a/internalError/InternalErrorDataset.h
+++ b/internalError/InternalErrorDataset.h
@@ -21,9 +21,12 @@ public:
     InternalErrorDataset(sid_t sid):
            StaticLocalDataSet(sid) {}
 
-    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(TM_HITS, sid.objectId, this);
-    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(QUEUE_HITS, sid.objectId, this);
-    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(STORE_HITS, sid.objectId, this);
+    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(TM_HITS,
+            hkManager->getOwner(), this);
+    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(QUEUE_HITS,
+            hkManager->getOwner(), this);
+    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(STORE_HITS,
+            hkManager->getOwner(), this);
 };
 
 
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 943ae8b30..a41d45689 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -50,6 +50,8 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 
 	internalErrorDataset.commit(INTERNAL_ERROR_MUTEX_TIMEOUT);
 
+	poolManager.performHkOperation();
+
 	CommandMessage message;
 	ReturnValue_t result = commandQueue->receiveMessage(&message);
 	if(result != MessageQueueIF::EMPTY) {
@@ -155,8 +157,6 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
             new PoolEntry<uint32_t>());
     localDataPoolMap.emplace(errorPoolIds::STORE_HITS,
             new PoolEntry<uint32_t>());
-    // todo: Only send HK if values have changed, will be supported by
-    // pool manager soon.
     poolManager.subscribeForPeriodicPacket(internalErrorSid, false,
             getPeriodicOperationFrequency(), true);
     return HasReturnvaluesIF::RETURN_OK;

From 260fac43f73d638823c4dd1d887e2e8409c9a480 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 23:38:37 +0200
Subject: [PATCH 0831/1774] bugfix

---
 internalError/InternalErrorReporter.cpp | 1 +
 pus/Service3Housekeeping.cpp            | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index a41d45689..22e2c38ce 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -159,6 +159,7 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
             new PoolEntry<uint32_t>());
     poolManager.subscribeForPeriodicPacket(internalErrorSid, false,
             getPeriodicOperationFrequency(), true);
+    internalErrorDataset.setValidity(true, true);
     return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index c668ec8ed..3f41f541f 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -205,7 +205,7 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
     }
     case(HousekeepingMessage::DIAGNOSTICS_DEFINITION_REPORT): {
         return generateHkReply(reply, static_cast<uint8_t>(
-                Subservice::DIAGNOSTICS_REPORT));
+                Subservice::DIAGNOSTICS_DEFINITION_REPORT));
         break;
     }
 

From 53a62257906df8ca44d3a447dd4434e3d7b889ea Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 12:50:36 +0200
Subject: [PATCH 0832/1774] doc & tweaks

---
 devicehandlers/DeviceHandlerBase.h   | 6 ++++--
 internalError/InternalErrorDataset.h | 4 ++--
 osal/FreeRTOS/PeriodicTask.cpp       | 8 ++++----
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 8f1b135b5..eda318cb8 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -106,13 +106,15 @@ public:
 	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
 			uint32_t thermalRequestPoolId);
 	/**
-	 * @brief   Helper function to easy device handler development.
+	 * @brief   Helper function to ease device handler development.
 	 * This will instruct the transition to MODE_ON immediately
 	 * (leading to doStartUp() being called for the transition to the ON mode),
 	 * so external mode commanding is not necessary anymore.
 	 *
 	 * This has to be called before the task is started!
-	 * (e.g. in the task factory)
+	 * (e.g. in the task factory). This is only a helper function for
+	 * development. Regular mode commanding should be performed by commanding
+	 * the AssemblyBase or Subsystem objects resposible for the device handler.
 	 */
 	void setStartUpImmediately();
 
diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
index 6bba11719..52a4b6324 100644
--- a/internalError/InternalErrorDataset.h
+++ b/internalError/InternalErrorDataset.h
@@ -18,8 +18,8 @@ public:
     InternalErrorDataset(HasLocalDataPoolIF* owner):
             StaticLocalDataSet(owner, ERROR_SET_ID) {}
 
-    InternalErrorDataset(sid_t sid):
-           StaticLocalDataSet(sid) {}
+    InternalErrorDataset(object_id_t objectId):
+           StaticLocalDataSet(sid_t(objectId , ERROR_SET_ID)) {}
 
     lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(TM_HITS,
             hkManager->getOwner(), this);
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 990d38d67..c90587bdb 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -133,11 +133,11 @@ TaskHandle_t PeriodicTask::getTaskHandle() {
 }
 
 void PeriodicTask::handleMissedDeadline() {
-#ifdef DEBUG
-    sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
-            " missed deadline!\n" << std::flush;
-#endif
     if(deadlineMissedFunc != nullptr) {
         this->deadlineMissedFunc();
     }
+#ifdef DEBUG
+    sif::warning << "PeriodicTask::handleMissedDeadline " << pcTaskGetName(NULL)
+    		<< " missed deadline!\n" << std::flush;
+#endif
 }

From 7b1f72254f866666d251f097b6587fc1c92f67e2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 13:30:30 +0200
Subject: [PATCH 0833/1774] object id names improved

---
 objectmanager/frameworkObjects.h      | 14 +++++++-------
 tmtcservices/VerificationReporter.cpp |  2 +-
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 87439c88b..4d08f0847 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -4,13 +4,13 @@
 namespace objects {
 enum framework_objects {
 	// Default verification reporter.
-	PUS_SERVICE_1 = 0x53000001,
-	PUS_SERVICE_2 = 0x53000002,
-	PUS_SERVICE_5 = 0x53000005,
-	PUS_SERVICE_8 = 0x53000008,
-	PUS_SERVICE_9 = 0x53000009,
-	PUS_SERVICE_17 = 0x53000017,
-	PUS_SERVICE_200 = 0x53000200,
+	PUS_SERVICE_1_VERIFICATION = 0x53000001,
+	PUS_SERVICE_2_DEVICE_ACCESS = 0x53000002,
+	PUS_SERVICE_5_EVENT_REPORTING = 0x53000005,
+	PUS_SERVICE_8_FUNCTION_MGMT = 0x53000008,
+	PUS_SERVICE_9_TIME_MGMT = 0x53000009,
+	PUS_SERVICE_17_TEST = 0x53000017,
+	PUS_SERVICE_200_MODE_MGMT = 0x53000200,
 
 	//Generic IDs for IPC, modes, health, events
 	HEALTH_TABLE = 0x53010000,
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 0c53e1a4d..4255c5ae2 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -6,7 +6,7 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../objectmanager/frameworkObjects.h"
 
-object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1;
+object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
 
 VerificationReporter::VerificationReporter() :
 		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {

From 3663d7269ca37b8ac2a5af62e1f86557d9766462 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 13:37:21 +0200
Subject: [PATCH 0834/1774] changes taken over

---
 tmtcservices/VerificationReporter.cpp | 13 +++++++------
 tmtcservices/VerificationReporter.h   |  8 ++++----
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 4255c5ae2..7e40bd275 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -1,12 +1,13 @@
-#include "../tmtcservices/VerificationReporter.h"
+#include "VerificationReporter.h"
+#include "AcceptsVerifyMessageIF.h"
+#include "PusVerificationReport.h"
 
 #include "../ipc/MessageQueueIF.h"
-#include "../tmtcservices/AcceptsVerifyMessageIF.h"
-#include "../tmtcservices/PusVerificationReport.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../objectmanager/frameworkObjects.h"
 
-object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+object_id_t VerificationReporter::messageReceiver =
+		objects::PUS_SERVICE_1_VERIFICATION;
 
 VerificationReporter::VerificationReporter() :
 		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {
@@ -98,8 +99,8 @@ void VerificationReporter::initialize() {
 	if (temp == nullptr) {
 		sif::error << "VerificationReporter::initialize: Message "
 				<< "receiver invalid. Make sure it is set up properly and "
-				<<"implementsAcceptsVerifyMessageIF" << std::endl;
-
+				<< "implementsAcceptsVerifyMessageIF" << std::endl;
+		return;
 	}
 	this->acknowledgeQueue = temp->getVerificationQueue();
 }
diff --git a/tmtcservices/VerificationReporter.h b/tmtcservices/VerificationReporter.h
index 4d92f6b38..f26fa54f5 100644
--- a/tmtcservices/VerificationReporter.h
+++ b/tmtcservices/VerificationReporter.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
-#define FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
+#ifndef FSFW_TMTCSERVICES_VERIFICATIONREPORTER_H_
+#define FSFW_TMTCSERVICES_VERIFICATIONREPORTER_H_
 
+#include "PusVerificationReport.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../tmtcservices/PusVerificationReport.h"
 
 namespace Factory{
 void setStaticFrameworkObjectIds();
@@ -47,4 +47,4 @@ private:
 	MessageQueueId_t acknowledgeQueue;
 };
 
-#endif /* FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_ */
+#endif /* FSFW_TMTCSERVICES_VERIFICATIONREPORTER_H_ */

From 1691d63169c7bec77954873c476f1fa530f981ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 13:54:08 +0200
Subject: [PATCH 0835/1774] include fix

---
 datapoollocal/LocalDataPoolManager.cpp |  4 +++-
 objectmanager/frameworkObjects.h       |  1 +
 tmtcservices/PusVerificationReport.h   | 12 +++++++-----
 3 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index d8b573773..c23f183b1 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -6,11 +6,13 @@
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
 #include "../ipc/QueueFactory.h"
+#include "../objectmanager/frameworkObjects.h"
 
 #include <array>
 #include <cmath>
 
-object_id_t LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
+object_id_t LocalDataPoolManager::defaultHkDestination =
+		objects::PUS_SERVICE_3_HOUSEKEEPING;
 
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 4d08f0847..57783286a 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -6,6 +6,7 @@ enum framework_objects {
 	// Default verification reporter.
 	PUS_SERVICE_1_VERIFICATION = 0x53000001,
 	PUS_SERVICE_2_DEVICE_ACCESS = 0x53000002,
+	PUS_SERVICE_3_HOUSEKEEPING = 0x53000003,
 	PUS_SERVICE_5_EVENT_REPORTING = 0x53000005,
 	PUS_SERVICE_8_FUNCTION_MGMT = 0x53000008,
 	PUS_SERVICE_9_TIME_MGMT = 0x53000009,
diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h
index c0a467585..9dce95ac7 100644
--- a/tmtcservices/PusVerificationReport.h
+++ b/tmtcservices/PusVerificationReport.h
@@ -1,9 +1,11 @@
-#ifndef PUSVERIFICATIONREPORT_H_
-#define PUSVERIFICATIONREPORT_H_
+#ifndef FSFW_TMTCSERVICES_PUSVERIFICATIONREPORT_H_
+#define FSFW_TMTCSERVICES_PUSVERIFICATIONREPORT_H_
+
+#include "VerificationCodes.h"
 
 #include "../ipc/MessageQueueMessage.h"
 #include "../tmtcpacket/pus/TcPacketBase.h"
-#include "../tmtcservices/VerificationCodes.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 
 class PusVerificationMessage: public MessageQueueMessage {
 private:
@@ -30,7 +32,7 @@ private:
 public:
 	static const uint8_t VERIFICATION_MIN_SIZE = 6;
 	PusVerificationMessage();
-//	PusVerificationMessage( uint8_t set_report_id, TcPacketBase* current_packet, ReturnValue_t set_error_code = 0, uint8_t set_step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
+
 	PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags,
 			uint16_t tcPacketId, uint16_t tcSequenceControl,
 			ReturnValue_t set_error_code = 0, uint8_t set_step = 0,
@@ -74,4 +76,4 @@ public:
 	uint8_t* getReport();
 };
 
-#endif /* PUSVERIFICATIONREPORT_H_ */
+#endif /* FSFW_TMTCSERVICES_PUSVERIFICATIONREPORT_H_ */

From 224248dfa1e3ca25eaa4cd94910b8e1293679406 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 14:27:31 +0200
Subject: [PATCH 0836/1774] removed debug outpuzt for missed deadline

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 9 ---------
 osal/FreeRTOS/PeriodicTask.cpp      | 4 ----
 2 files changed, 13 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 309574eb7..062686e2b 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -150,15 +150,6 @@ void FixedTimeslotTask::handleMissedDeadline() {
     if(deadlineMissedFunc != nullptr) {
         this->deadlineMissedFunc();
     }
-
-#ifdef DEBUG
-    object_id_t handlerId = pst.current->handlerId;
-    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) << " with"
-            << " object ID 0x" << std::setfill('0') << std::setw(8) << std::hex
-            << handlerId <<  " missed deadline!" << std::setfill(' ')
-            << std::dec << std::endl;
-#endif
-
 }
 
 ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index c90587bdb..5c0a840da 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -136,8 +136,4 @@ void PeriodicTask::handleMissedDeadline() {
     if(deadlineMissedFunc != nullptr) {
         this->deadlineMissedFunc();
     }
-#ifdef DEBUG
-    sif::warning << "PeriodicTask::handleMissedDeadline " << pcTaskGetName(NULL)
-    		<< " missed deadline!\n" << std::flush;
-#endif
 }

From 485e96f12f74dc6dd891aed548b8915872dd540c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 14:49:57 +0200
Subject: [PATCH 0837/1774] merged changes

---
 storagemanager/ConstStorageAccessor.cpp | 15 ++++++---------
 storagemanager/ConstStorageAccessor.h   |  8 ++++----
 storagemanager/LocalPool.h              | 13 +++++++------
 storagemanager/LocalPool.tpp            | 17 +++++++++--------
 storagemanager/PoolManager.h            | 25 ++++++++++++++++---------
 storagemanager/PoolManager.tpp          | 19 +++++++++++--------
 storagemanager/StorageAccessor.cpp      |  4 ++--
 storagemanager/StorageAccessor.h        |  8 ++++----
 storagemanager/StorageManagerIF.h       | 12 +++++++-----
 9 files changed, 66 insertions(+), 55 deletions(-)

diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 5c143adbe..842f1ce88 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -1,6 +1,7 @@
+#include "ConstStorageAccessor.h"
+#include "StorageManagerIF.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../storagemanager/ConstStorageAccessor.h"
-#include "../storagemanager/StorageManagerIF.h"
 #include "../globalfunctions/arrayprinter.h"
 
 ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
@@ -14,12 +15,7 @@ ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
 
 ConstStorageAccessor::~ConstStorageAccessor() {
 	if(deleteData and store != nullptr) {
-		ReturnValue_t result = store->deleteData(storeId);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-		    // Configuration error.
-		    sif::error << "ConstStorageAccessor::~ConstStorageAccessor: "
-		            << "Could not delete entry!" << std::endl;
-		}
+		store->deleteData(storeId);
 	}
 }
 
@@ -62,7 +58,8 @@ ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		sif::error << "StorageAccessor: Supplied buffer not large enough"
+				<< std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(constDataPointer, constDataPointer + size_, pointer);
diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index 573892da5..96d2dca2c 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+#ifndef FSFW_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+#define FSFW_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
 
-#include "../storagemanager/storeAddress.h"
+#include "storeAddress.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
 
@@ -113,4 +113,4 @@ protected:
 };
 
 
-#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
+#endif /* FSFW_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 2a526b6a3..3a94c03db 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -1,14 +1,15 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_H_
+#define FSFW_STORAGEMANAGER_LOCALPOOL_H_
 
+#include "StorageManagerIF.h"
 #include "../objectmanager/SystemObject.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../storagemanager/StorageManagerIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../internalError/InternalErrorReporterIF.h"
 #include "../storagemanager/StorageAccessor.h"
 #include <cstring>
 
+
 /**
  * @brief	The LocalPool class provides an intermediate data storage with
  * 			a fixed pool size policy.
@@ -184,6 +185,6 @@ private:
 	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
 };
 
-#include "../storagemanager/LocalPool.tpp"
+#include "LocalPool.tpp"
 
-#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
+#endif /* FSFW_STORAGEMANAGER_LOCALPOOL_H_ */
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 764bd7be4..5e61efe45 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
-#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
+#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_TPP_
+#define FSFW_STORAGEMANAGER_LOCALPOOL_TPP_
 
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_H_
 #error Include LocalPool.h before LocalPool.tpp!
 #endif
 
@@ -125,9 +125,10 @@ inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
 	}
 }
 
-template<uint8_t NUMBER_OF_POOLS> inline
-ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(store_address_t* storageId,
-		const uint8_t* data, size_t size, bool ignoreFault) {
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(
+		store_address_t* storageId, const uint8_t* data, size_t size,
+		bool ignoreFault) {
 	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
 	if (status == RETURN_OK) {
 		write(*storageId, data, size);
@@ -171,7 +172,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(store_address_t storeId
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
 		store_address_t packet_id, const uint8_t** packet_ptr, size_t* size) {
-	uint8_t* tempData = NULL;
+	uint8_t* tempData = nullptr;
 	ReturnValue_t status = modifyData(packet_id, &tempData, size);
 	*packet_ptr = tempData;
 	return status;
@@ -301,4 +302,4 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
 	return RETURN_OK;
 }
 
-#endif
+#endif /* FSFW_STORAGEMANAGER_LOCALPOOL_TPP_ */
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 76bddb8ff..8cc6c0654 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,9 +1,10 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+#ifndef FSFW_STORAGEMANAGER_POOLMANAGER_H_
+#define FSFW_STORAGEMANAGER_POOLMANAGER_H_
 
-#include "../storagemanager/LocalPool.h"
+#include "LocalPool.h"
+#include "StorageAccessor.h"
 #include "../ipc/MutexHelper.h"
-#include "../storagemanager/StorageAccessor.h"
+
 
 /**
  * @brief	The PoolManager class provides an intermediate data storage with
@@ -19,18 +20,24 @@ public:
 			const uint16_t element_sizes[NUMBER_OF_POOLS],
 			const uint16_t n_elements[NUMBER_OF_POOLS]);
 
-	//! @brief	In the PoolManager's destructor all allocated memory is freed.
+	/**
+	 * @brief	In the PoolManager's destructor all allocated memory
+	 * 			is freed.
+	 */
 	virtual ~PoolManager();
 
-	//! @brief LocalPool overrides for thread-safety. Decorator function which
-	//! 	   wraps LocalPool calls with a mutex protection.
+	/**
+	 * @brief 	LocalPool overrides for thread-safety. Decorator function
+	 * 			which wraps LocalPool calls with a mutex protection.
+	 */
 	ReturnValue_t deleteData(store_address_t) override;
 	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = nullptr) override;
 
+	void setMutexTimeout(uint32_t mutexTimeoutMs);
 protected:
 	//! Default mutex timeout value to prevent permanent blocking.
-	static constexpr uint32_t mutexTimeout = 50;
+	uint32_t mutexTimeoutMs = 20;
 
 	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
 			bool ignoreFault) override;
@@ -46,4 +53,4 @@ protected:
 
 #include "PoolManager.tpp"
 
-#endif /* POOLMANAGER_H_ */
+#endif /* FSFW_STORAGEMANAGER_POOLMANAGER_H_ */
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 0656e9675..2be44ece2 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 #define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 
-#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+#ifndef FSFW_STORAGEMANAGER_POOLMANAGER_H_
 #error Include PoolManager.h before PoolManager.tpp!
 #endif
 
@@ -21,8 +21,7 @@ inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
 		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
-			mutexTimeout);
+	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
 			address,ignoreFault);
 	return status;
@@ -34,8 +33,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 	// debug << "PoolManager( " << translateObject(getObjectId()) <<
 	//       " )::deleteData from store " << packet_id.pool_index <<
 	//       ". id is "<< packet_id.packet_index << std::endl;
-	MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
-				mutexTimeout);
+	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
 	return status;
 }
@@ -43,11 +41,16 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 		size_t size, store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
-				mutexTimeout);
+	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
 			size, storeId);
 	return status;
 }
 
-#endif
+template<uint8_t NUMBER_OF_POOLS>
+inline void PoolManager<NUMBER_OF_POOLS>::setMutexTimeout(
+		uint32_t mutexTimeoutMs) {
+	this->mutexTimeout = mutexTimeoutMs;
+}
+
+#endif /* FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_ */
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index 60bd41304..9c2f936a5 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,5 +1,5 @@
-#include "../storagemanager/StorageAccessor.h"
-#include "../storagemanager/StorageManagerIF.h"
+#include "StorageAccessor.h"
+#include "StorageManagerIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 StorageAccessor::StorageAccessor(store_address_t storeId):
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index a65427b8b..5cf15d509 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+#ifndef FSFW_STORAGEMANAGER_STORAGEACCESSOR_H_
+#define FSFW_STORAGEMANAGER_STORAGEACCESSOR_H_
 
-#include "../storagemanager/ConstStorageAccessor.h"
+#include "ConstStorageAccessor.h"
 
 class StorageManagerIF;
 
@@ -42,4 +42,4 @@ private:
 	void assignConstPointer();
 };
 
-#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
+#endif /* FSFW_STORAGEMANAGER_STORAGEACCESSOR_H_ */
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 2229cdf89..834e75637 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -1,10 +1,12 @@
-#ifndef STORAGEMANAGERIF_H_H
-#define STORAGEMANAGERIF_H_H
+#ifndef FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_
+#define FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_
+
+#include "StorageAccessor.h"
+#include "storeAddress.h"
 
 #include "../events/Event.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../storagemanager/StorageAccessor.h"
-#include "../storagemanager/storeAddress.h"
+
 #include <utility>
 #include <cstddef>
 
@@ -164,4 +166,4 @@ public:
 	virtual void clearStore() = 0;
 };
 
-#endif /* STORAGEMANAGERIF_H_ */
+#endif /* FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_ */

From fd87a16661290a771e18287bd88ef9df42d60cb2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 14:51:25 +0200
Subject: [PATCH 0838/1774] changes taken over

---
 storagemanager/storeAddress.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/storagemanager/storeAddress.h b/storagemanager/storeAddress.h
index 5dd785a3e..044c07908 100644
--- a/storagemanager/storeAddress.h
+++ b/storagemanager/storeAddress.h
@@ -1,5 +1,6 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_STOREADDRESS_H_
-#define FRAMEWORK_STORAGEMANAGER_STOREADDRESS_H_
+#ifndef FSFW_STORAGEMANAGER_STOREADDRESS_H_
+#define FSFW_STORAGEMANAGER_STOREADDRESS_H_
+
 #include <cstdint>
 
 /**
@@ -51,4 +52,4 @@ union store_address_t {
 	}
 };
 
-#endif /* FRAMEWORK_STORAGEMANAGER_STOREADDRESS_H_ */
+#endif /* FSFW_STORAGEMANAGER_STOREADDRESS_H_ */

From bc23fd65a678fef98a3a7e701d6e40fdac8cf387 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 15:13:51 +0200
Subject: [PATCH 0839/1774] master taken over

---
 pus/Service8FunctionManagement.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 3c94071d0..2c2e590b5 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -1,5 +1,5 @@
-#include "../pus/Service8FunctionManagement.h"
-#include "../pus/servicepackets/Service8Packets.h"
+#include "Service8FunctionManagement.h"
+#include "servicepackets/Service8Packets.h"
 
 #include "../objectmanager/SystemObjectIF.h"
 #include "../action/HasActionsIF.h"

From 207d2cab9c6345c02b93f754344e0e34fc446a5f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 15:15:29 +0200
Subject: [PATCH 0840/1774] service 1 changes taken over

---
 pus/servicepackets/Service1Packets.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index 8c5cb005f..dbd31028c 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -1,9 +1,3 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcservices/VerificationCodes.h"
-
 /**
  * @defgroup spacepackets PUS Packet Definitions
  *  This group contains all implemented TM or TM packages that are sent to
@@ -11,12 +5,18 @@
  *  packet structures in Mission Information Base (MIB).
  */
 
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcservices/VerificationCodes.h"
+
 /**
  * @brief 	FailureReport class to serialize a failure report
  * @brief 	Subservice 1, 3, 5, 7
  * @ingroup spacepackets
  */
-class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
+class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
 public:
 	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
 			uint16_t packetSequenceControl_, uint8_t stepNumber_,
@@ -111,7 +111,7 @@ private:
  * @brief       Subservices 2, 4, 6, 8
  * @ingroup     spacepackets
  */
-class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
+class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
 public:
 	SuccessReport(uint8_t subtype_, uint16_t packetId_,
 			uint16_t packetSequenceControl_,uint8_t stepNumber_) :

From 1ea1c8c02fca9cc46536831280e3160b0c73b3f5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 15:16:20 +0200
Subject: [PATCH 0841/1774] srv9 fix

---
 pus/Service9TimeManagement.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/pus/Service9TimeManagement.h b/pus/Service9TimeManagement.h
index 4ad6be6e3..4802cdecc 100644
--- a/pus/Service9TimeManagement.h
+++ b/pus/Service9TimeManagement.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_
 #define FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_
 
-#include <fsfw/tmtcservices/PusServiceBase.h>
+#include "../tmtcservices/PusServiceBase.h"
 
 class Service9TimeManagement: public PusServiceBase {
 public:
@@ -34,7 +34,6 @@ private:
 		SET_TIME = 128 //!< [EXPORT] : [COMMAND] Time command in ASCII, CUC or CDS format
 	};
 
-	void setIsisClock(Clock::TimeOfDay_t& timeOfDay);
 };
 
 

From e1eb1a3be17fa8b417859ff5d3231dc32cf1535f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 15:48:42 +0200
Subject: [PATCH 0842/1774] small tweaks

---
 pus/CService201HealthCommanding.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index cc5dd640c..7e68533d9 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -7,8 +7,8 @@
 
 CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId,
         uint16_t apid, uint8_t serviceId):
-	CommandingServiceBase(objectId, apid, serviceId,
-			NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {
+		CommandingServiceBase(objectId, apid, serviceId,
+		NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {
 }
 
 CService201HealthCommanding::~CService201HealthCommanding() {
@@ -56,8 +56,8 @@ ReturnValue_t CService201HealthCommanding::prepareCommand
 	if (result != RETURN_OK) {
 		return result;
 	} else {
-		HealthMessage::setHealthMessage(dynamic_cast<CommandMessage*>(message),
-				HealthMessage::HEALTH_SET, healthCommand.getHealth());
+		HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_SET,
+				healthCommand.getHealth());
 		return result;
 	}
 }
@@ -79,6 +79,6 @@ void CService201HealthCommanding::prepareHealthSetReply(
 	uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
 	uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
 	HealthSetReply healthSetReply(health, oldHealth);
-	sendTmPacket(Subservice::REPLY_HEALTH_SET,&healthSetReply);
+	sendTmPacket(Subservice::REPLY_HEALTH_SET, &healthSetReply);
 }
 

From d85096d98b951890bf93d373c4a928bea822676f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 16:03:01 +0200
Subject: [PATCH 0843/1774] service 200 take over

---
 pus/CService200ModeCommanding.cpp | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index dda58e038..c63b47a69 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -1,5 +1,5 @@
-#include "../pus/CService200ModeCommanding.h"
-#include "../pus/servicepackets/Service200Packets.h"
+#include "CService200ModeCommanding.h"
+#include "servicepackets/Service200Packets.h"
 
 #include "../modes/HasModesIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
@@ -107,13 +107,23 @@ ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(
 		const CommandMessage *reply, object_id_t objectId) {
 	ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply),
 			ModeMessage::getSubmode(reply));
-	return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
+	ReturnValue_t result = sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
+	if(result == RETURN_OK){
+		// We want to produce an error here in any case because the mode was not correct
+		return RETURN_FAILED;
+	}
+	return result;
 }
 
 ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
 		const CommandMessage *reply, object_id_t objectId) {
 	CantReachModePacket cantReachModePacket(objectId,
 	        ModeMessage::getCantReachModeReason(reply));
-	return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
+	ReturnValue_t result = sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
 	        &cantReachModePacket);
+	if(result == RETURN_OK){
+		// We want to produce an error here in any case because the mode was not reached
+		return RETURN_FAILED;
+	}
+	return result;
 }

From 9013ac240ff9a9ef2f488c1e6bee22ec314b6a37 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 16:12:01 +0200
Subject: [PATCH 0844/1774] array list taken over

---
 container/ArrayList.h | 200 +++++++++++++++++++++---------------------
 1 file changed, 99 insertions(+), 101 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index ae9831711..426e02b38 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
-#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
+#ifndef FSFW_CONTAINER_ARRAYLIST_H_
+#define FSFW_CONTAINER_ARRAYLIST_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeAdapter.h"
@@ -20,11 +20,35 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
 	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
 
-    /**
-     * Copying is forbiden by declaring copy ctor and copy assignment deleted
-     * It is too ambigous in this case.
-     * (Allocate a new backend? Use the same? What to do in an modifying call?)
-     */
+	/**
+	 * This is the allocating constructor.
+	 * It allocates an array of the specified size.
+	 * @param maxSize
+	 */
+	ArrayList(count_t maxSize) :
+		size(0), maxSize_(maxSize), allocated(true) {
+		entries = new T[maxSize];
+	}
+
+	/**
+	 * This is the non-allocating constructor
+	 *
+	 * It expects a pointer to an array of a certain size and initializes
+	 * itself to it.
+	 *
+	 * @param storage the array to use as backend
+	 * @param maxSize size of storage
+	 * @param size size of data already present in storage
+	 */
+	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
+		size(size), entries(storage), maxSize_(maxSize), allocated(false) {
+	}
+
+	/**
+	 * Copying is forbiden by declaring copy ctor and copy assignment deleted
+	 * It is too ambigous in this case.
+	 * (Allocate a new backend? Use the same? What to do in an modifying call?)
+	 */
 	ArrayList(const ArrayList& other) = delete;
 	const ArrayList& operator=(const ArrayList& other) = delete;
 
@@ -33,30 +57,6 @@ public:
 	 */
 	count_t size;
 
-	/**
-	 * This is the allocating constructor;
-	 *
-	 * It allocates an array of the specified size.
-	 *
-	 * @param maxSize
-	 */
-	ArrayList(count_t maxSize) :
-			size(0), maxSize_(maxSize), allocated(true) {
-		entries = new T[maxSize];
-	}
-
-	/**
-	 * This is the non-allocating constructor
-	 *
-	 * It expects a pointer to an array of a certain size and initializes itself to it.
-	 *
-	 * @param storage the array to use as backend
-	 * @param maxSize size of storage
-	 * @param size size of data already present in storage
-	 */
-	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
-			size(size), entries(storage), maxSize_(maxSize), allocated(false) {
-	}
 
 	/**
 	 * Destructor, if the allocating constructor was used, it deletes the array.
@@ -67,86 +67,84 @@ public:
 		}
 	}
 
-    /**
-     * An Iterator to go trough an ArrayList
-     *
-     * It stores a pointer to an element and increments the
-     * pointer when incremented itself.
-     */
-    class Iterator {
-    public:
-        /**
-         * Empty ctor, points to NULL
-         */
-        Iterator(): value(0) {}
+	/**
+	 * An Iterator to go trough an ArrayList
+	 *
+	 * It stores a pointer to an element and increments the
+	 * pointer when incremented itself.
+	 */
+	class Iterator {
+	public:
+		/**
+		 * Empty ctor, points to NULL
+		 */
+		Iterator(): value(0) {}
 
-        /**
-         * Initializes the Iterator to point to an element
-         *
-         * @param initialize
-         */
-        Iterator(T *initialize) {
-            value = initialize;
-        }
+		/**
+		 * Initializes the Iterator to point to an element
+		 *
+		 * @param initialize
+		 */
+		Iterator(T *initialize) {
+			value = initialize;
+		}
 
-        /**
-         * The current element the iterator points to
-         */
-        T *value;
+		/**
+		 * The current element the iterator points to
+		 */
+		T *value;
 
-        Iterator& operator++() {
-            value++;
-            return *this;
-        }
+		Iterator& operator++() {
+			value++;
+			return *this;
+		}
 
-        Iterator operator++(int) {
-            Iterator tmp(*this);
-            operator++();
-            return tmp;
-        }
+		Iterator operator++(int) {
+			Iterator tmp(*this);
+			operator++();
+			return tmp;
+		}
 
-        Iterator& operator--() {
-            value--;
-            return *this;
-        }
+		Iterator& operator--() {
+			value--;
+			return *this;
+		}
 
-        Iterator operator--(int) {
-            Iterator tmp(*this);
-            operator--();
-            return tmp;
-        }
+		Iterator operator--(int) {
+			Iterator tmp(*this);
+			operator--();
+			return tmp;
+		}
 
-        T& operator*() {
-            return *value;
-        }
+		T& operator*() {
+			return *value;
+		}
 
-        const T& operator*() const {
-            return *value;
-        }
+		const T& operator*() const {
+			return *value;
+		}
 
-        T *operator->() {
-            return value;
-        }
+		T *operator->() {
+			return value;
+		}
 
-        const T *operator->() const {
-            return value;
-        }
+		const T *operator->() const {
+			return value;
+		}
 
 
-        //SHOULDDO this should be implemented as non-member
-        bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const {
-            return (value == other.value);
-        }
+		//SHOULDDO this should be implemented as non-member
+		bool operator==(const typename
+				ArrayList<T, count_t>::Iterator& other) const {
+			return (value == other.value);
+		}
 
-        //SHOULDDO this should be implemented as non-member
-        bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
-        	// POSSIBLY BUGGY ! Also this is really confusing. Why does
-        	// the operator above use the value while this one
-        	// dereferences itself?
-        	//return not (value == other.value);
-        	return !(*this == other);
-        }
-    };
+		//SHOULDDO this should be implemented as non-member
+		bool operator!=(const typename
+				ArrayList<T, count_t>::Iterator& other) const {
+			return !(*this == other);
+		}
+	};
 
 	/**
 	 * Iterator pointing to the first stored elmement
@@ -201,7 +199,7 @@ public:
 	 *
 	 * @return maximum number of elements
 	 */
-	uint32_t maxSize() const {
+	size_t maxSize() const {
 		return this->maxSize_;
 	}
 
@@ -245,7 +243,7 @@ protected:
 	/**
 	 * remembering the maximum size
 	 */
-	uint32_t maxSize_;
+	size_t maxSize_;
 
 	/**
 	 * true if the array was allocated and needs to be deleted in the destructor.
@@ -253,4 +251,4 @@ protected:
 	bool allocated;
 };
 
-#endif /* ARRAYLIST_H_ */
+#endif /* FSFW_CONTAINER_ARRAYLIST_H_ */

From 4f3cfdcaaf57a790ae7b8cf874c76252f20ceb6d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 16:41:14 +0200
Subject: [PATCH 0845/1774] fixed map and array list implemented as non -
 members

---
 container/ArrayList.h | 34 +++++++++++++++++++++++-----------
 container/FixedMap.h  | 10 ++++++++++
 2 files changed, 33 insertions(+), 11 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 426e02b38..163185698 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -133,19 +133,29 @@ public:
 		}
 
 
-		//SHOULDDO this should be implemented as non-member
-		bool operator==(const typename
-				ArrayList<T, count_t>::Iterator& other) const {
-			return (value == other.value);
-		}
-
-		//SHOULDDO this should be implemented as non-member
-		bool operator!=(const typename
-				ArrayList<T, count_t>::Iterator& other) const {
-			return !(*this == other);
-		}
+//		//SHOULDDO this should be implemented as non-member
+//		bool operator==(const typename
+//				ArrayList<T, count_t>::Iterator& other) const {
+//			return (value == other.value);
+//		}
+//
+//		//SHOULDDO this should be implemented as non-member
+//		bool operator!=(const typename
+//				ArrayList<T, count_t>::Iterator& other) const {
+//			return !(*this == other);
+//		}
 	};
 
+	friend bool operator==(const ArrayList::Iterator& lhs,
+			const ArrayList::Iterator& rhs) {
+		return (lhs.value == rhs.value);
+	}
+
+	friend bool operator!=(const ArrayList::Iterator& lhs,
+			const ArrayList::Iterator& rhs) {
+		return not (lhs.value == rhs.value);
+	}
+
 	/**
 	 * Iterator pointing to the first stored elmement
 	 *
@@ -251,4 +261,6 @@ protected:
 	bool allocated;
 };
 
+
+
 #endif /* FSFW_CONTAINER_ARRAYLIST_H_ */
diff --git a/container/FixedMap.h b/container/FixedMap.h
index e5fbb3be6..1e36b1bc2 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -61,6 +61,16 @@ public:
 		}
 	};
 
+	friend bool operator==(const typename FixedMap::Iterator& lhs,
+			const typename FixedMap::Iterator& rhs) {
+		return (lhs.value == rhs.value);
+	}
+
+	friend bool operator!=(const typename FixedMap::Iterator& lhs,
+			const typename FixedMap::Iterator& rhs) {
+		return not (lhs.value == rhs.value);
+	}
+
 	Iterator begin() const {
 		return Iterator(&theMap[0]);
 	}

From 3c814a5e6105390bbbee8ae7df825af45fa53df1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 18:01:55 +0200
Subject: [PATCH 0846/1774] include fixes

---
 monitoring/AbsLimitMonitor.h          |  2 +-
 monitoring/LimitMonitor.h             | 13 ++++++-------
 monitoring/LimitViolationReporter.cpp |  6 +++---
 monitoring/MonitorBase.h              | 12 ++++++------
 monitoring/MonitorReporter.h          |  6 +++---
 monitoring/MonitoringIF.h             |  2 +-
 monitoring/MonitoringMessage.cpp      |  2 +-
 monitoring/MonitoringMessageContent.h |  4 ++--
 monitoring/TwoValueLimitMonitor.h     |  2 +-
 9 files changed, 24 insertions(+), 25 deletions(-)

diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index c32c63ef0..2e60f6f8c 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
 #define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
 
-#include "../monitoring/MonitorBase.h"
+#include "MonitorBase.h"
 #include <cmath>
 
 template<typename T>
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index 4aec86695..66e6725e8 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_MONITORING_LIMITMONITOR_H_
 #define FRAMEWORK_MONITORING_LIMITMONITOR_H_
 
-#include "../monitoring/MonitorBase.h"
+#include "MonitorBase.h"
 
 /**
  * Variant of a limit checking class.
@@ -16,13 +16,12 @@ public:
 			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
 			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
 			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit),
-			lowerLimit(lowerLimit), upperLimit(upperLimit), belowLowEvent(belowLowEvent),
-			aboveHighEvent(aboveHighEvent) {
+			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), lowerLimit(
+					lowerLimit), upperLimit(upperLimit), belowLowEvent(
+					belowLowEvent), aboveHighEvent(aboveHighEvent) {
+	}
+	virtual ~LimitMonitor() {
 	}
-
-	virtual ~LimitMonitor() {}
-
 	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
 		*crossedLimit = 0.0;
 		if (sample > upperLimit) {
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 87278f4e1..c531a6e69 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -4,9 +4,9 @@
  * @date	17.07.2014
  * @author	baetz
  */
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../monitoring/ReceivesMonitoringReportsIF.h"
+#include "LimitViolationReporter.h"
+#include "MonitoringIF.h"
+#include "ReceivesMonitoringReportsIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerializeAdapter.h"
 
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 5173c4798..51677fc1a 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,12 +1,12 @@
 #ifndef MONITORBASE_H_
 #define MONITORBASE_H_
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/PIDReader.h"
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../monitoring/MonitoringMessageContent.h"
-#include "../monitoring/MonitorReporter.h"
+#include "../datapool/DataSet.h"
+#include "../datapool/PIDReader.h"
+#include "LimitViolationReporter.h"
+#include "MonitoringIF.h"
+#include "MonitoringMessageContent.h"
+#include "MonitorReporter.h"
 
 /**
  * Base class for monitoring of parameters.
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 9823cde01..ca2b534b9 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -2,9 +2,9 @@
 #define FRAMEWORK_MONITORING_MONITORREPORTER_H_
 
 #include "../events/EventManagerIF.h"
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../monitoring/MonitoringMessageContent.h"
+#include "LimitViolationReporter.h"
+#include "MonitoringIF.h"
+#include "MonitoringMessageContent.h"
 #include "../parameters/HasParametersIF.h"
 
 template<typename T>
diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h
index d9ea339f4..44218c36d 100644
--- a/monitoring/MonitoringIF.h
+++ b/monitoring/MonitoringIF.h
@@ -2,7 +2,7 @@
 #define MONITORINGIF_H_
 
 #include "../memory/HasMemoryIF.h"
-#include "../monitoring/MonitoringMessage.h"
+#include "MonitoringMessage.h"
 #include "../serialize/SerializeIF.h"
 
 class MonitoringIF : public SerializeIF {
diff --git a/monitoring/MonitoringMessage.cpp b/monitoring/MonitoringMessage.cpp
index 2cfe1ecee..8caa27aee 100644
--- a/monitoring/MonitoringMessage.cpp
+++ b/monitoring/MonitoringMessage.cpp
@@ -1,4 +1,4 @@
-#include "../monitoring/MonitoringMessage.h"
+#include "MonitoringMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
 MonitoringMessage::~MonitoringMessage() {
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index ea52962b2..c82506f3a 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -1,8 +1,8 @@
 #ifndef MONITORINGMESSAGECONTENT_H_
 #define MONITORINGMESSAGECONTENT_H_
 
-#include "../monitoring/HasMonitorsIF.h"
-#include "../monitoring/MonitoringIF.h"
+#include "HasMonitorsIF.h"
+#include "MonitoringIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
diff --git a/monitoring/TwoValueLimitMonitor.h b/monitoring/TwoValueLimitMonitor.h
index 74934828e..e690cdae2 100644
--- a/monitoring/TwoValueLimitMonitor.h
+++ b/monitoring/TwoValueLimitMonitor.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
 #define FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
 
-#include "../monitoring/LimitMonitor.h"
+#include "LimitMonitor.h"
 
 template<typename T>
 class TwoValueLimitMonitor: public LimitMonitor<T> {

From b59a4c5de62863afd9fa3a45912a4f4e7f862b4b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 18:02:41 +0200
Subject: [PATCH 0847/1774] equalization complete

---
 monitoring/MonitorBase.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 51677fc1a..964fd55ef 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,8 +1,8 @@
 #ifndef MONITORBASE_H_
 #define MONITORBASE_H_
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PIDReader.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/PIDReader.h"
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"

From d8392de058b1ecde643dabb5903f3534b68acefb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Sep 2020 20:28:33 +0200
Subject: [PATCH 0848/1774] made define more generic

---
 timemanager/CCSDSTime.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 80a4e27c4..8878a38a7 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -159,7 +159,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	}
 // Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
 // Suggestion: use uint16 all the time. This should work on all systems.
-#if FSFW_NEWLIB_NANO_NO_C99_IO == 1
+#if FSFW_NO_C99_IO == 1
 	uint16_t year;
 	uint16_t month;
 	uint16_t day;

From d44428f49c8d99de93632b20307d9ddbe4b77584 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Sep 2020 23:38:54 +0200
Subject: [PATCH 0849/1774] DH IF and DH message improved

---
 devicehandlers/DeviceHandlerIF.h      | 14 +++--
 devicehandlers/DeviceHandlerMessage.h | 75 ++++++++++-----------------
 2 files changed, 37 insertions(+), 52 deletions(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index e3fa3b882..b4cf736d7 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,8 +1,9 @@
-#ifndef DEVICEHANDLERIF_H_
-#define DEVICEHANDLERIF_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
+
+#include "DeviceHandlerMessage.h"
 
 #include "../action/HasActionsIF.h"
-#include "../devicehandlers/DeviceHandlerMessage.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
@@ -14,6 +15,11 @@
  */
 class DeviceHandlerIF {
 public:
+    /**
+     * This is used to uniquely identify commands that are sent to a device
+     * The values are defined in the device-specific implementations
+     */
+    typedef uint32_t DeviceCommandId_t;
 
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
@@ -152,4 +158,4 @@ public:
 
 };
 
-#endif /* DEVICEHANDLERIF_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_ */
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index 5f4583d2c..842dfee8d 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -1,69 +1,53 @@
-#ifndef DEVICEHANDLERMESSAGE_H_
-#define DEVICEHANDLERMESSAGE_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_
 
 #include "../action/ActionMessage.h"
 #include "../ipc/CommandMessage.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../storagemanager/StorageManagerIF.h"
-//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
+// SHOULDDO: rework the static constructors to name the type of command
+// they are building, maybe even hide setting the commandID.
+
 
 /**
- * This is used to uniquely identify commands that are sent to a device
- *
- * The values are defined in the device-specific implementations
- */
-typedef uint32_t DeviceCommandId_t;
-
-/**
- * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
+ * @brief   The DeviceHandlerMessage is used to send commands to classes
+ *          implementing DeviceHandlerIF
  */
 class DeviceHandlerMessage {
-private:
-	DeviceHandlerMessage();
 public:
+    // Instantiation forbidden.
+	DeviceHandlerMessage() = delete;
+	virtual ~DeviceHandlerMessage() {}
 
 	/**
 	 * These are the commands that can be sent to a DeviceHandlerBase
 	 */
 	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
-	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_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
-	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
+	//! Sends a raw command, setParameter is a storeId containing the
+	//! raw packet to send
+	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 );
+	//! Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 );
+	//! (De)Activates the monitoring of all raw traffic in DeviceHandlers,
+	//! setParameter is 0 to deactivate, 1 to activate
+	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 );
 
-	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
-	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
-	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
-
-	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
-
-	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
-	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
-	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
-	 */
-	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
-	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
-	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
+	//! Signals that a direct command was sent
+	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS;
+	//! Contains a raw command sent to the Device
+	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 );
+	//! Contains a raw reply from the Device, getParameter() is the ObjcetId
+	//! of the sender, getParameter2() is a ::store_id_t containing the
+	//! raw packet received
+	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12);
 	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
 
-	/**
-	 * Default Destructor
-	 */
-	virtual ~DeviceHandlerMessage() {
-	}
-
 	static store_address_t getStoreAddress(const CommandMessage* message);
 	static uint32_t getDeviceCommandId(const CommandMessage* message);
 	static object_id_t getDeviceObjectId(const CommandMessage *message);
 	static object_id_t getIoBoardObjectId(const CommandMessage* message);
 	static uint8_t getWiretappingMode(const CommandMessage* message);
 
-//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
-//			DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-
 	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
 			object_id_t deviceObjectid,
 			store_address_t commandParametersStoreId);
@@ -75,11 +59,6 @@ public:
 			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
 			bool isCommand);
 
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, store_address_t rawPacketStoreId);
 	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
 			uint8_t wiretappingMode);
 	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
@@ -88,4 +67,4 @@ public:
 	static void clear(CommandMessage* message);
 };
 
-#endif /* DEVICEHANDLERMESSAGE_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_ */

From aed2d7fc9369e006cc7aa672a1cfeb7fb46e9f25 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Sep 2020 23:42:18 +0200
Subject: [PATCH 0850/1774] slight formatting

---
 devicehandlers/DeviceHandlerIF.h        | 12 +++++++-----
 devicehandlers/DeviceHandlerMessage.cpp | 17 ++---------------
 devicehandlers/DeviceHandlerMessage.h   | 15 +++++++++------
 3 files changed, 18 insertions(+), 26 deletions(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index b4cf736d7..9c8eb0983 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -8,6 +8,12 @@
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 
+/**
+ * This is used to uniquely identify commands that are sent to a device
+ * The values are defined in the device-specific implementations
+ */
+using DeviceCommandId_t = uint32_t;
+
 /**
  * @brief 	This is the Interface used to communicate with a device handler.
  * @details Includes all expected return values, events and modes.
@@ -15,11 +21,7 @@
  */
 class DeviceHandlerIF {
 public:
-    /**
-     * This is used to uniquely identify commands that are sent to a device
-     * The values are defined in the device-specific implementations
-     */
-    typedef uint32_t DeviceCommandId_t;
+
 
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
diff --git a/devicehandlers/DeviceHandlerMessage.cpp b/devicehandlers/DeviceHandlerMessage.cpp
index b4963dbf7..cb9043db8 100644
--- a/devicehandlers/DeviceHandlerMessage.cpp
+++ b/devicehandlers/DeviceHandlerMessage.cpp
@@ -1,9 +1,5 @@
+#include "DeviceHandlerMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../devicehandlers/DeviceHandlerMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-DeviceHandlerMessage::DeviceHandlerMessage() {
-}
 
 store_address_t DeviceHandlerMessage::getStoreAddress(
 		const CommandMessage* message) {
@@ -25,14 +21,6 @@ uint8_t DeviceHandlerMessage::getWiretappingMode(
 	return message->getParameter();
 }
 
-//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
-//		CommandMessage* message, DeviceCommandId_t deviceCommand,
-//		store_address_t commandParametersStoreId) {
-//	message->setCommand(CMD_DIRECT);
-//	message->setParameter(deviceCommand);
-//	message->setParameter2(commandParametersStoreId.raw);
-//}
-
 void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
 		CommandMessage* message, store_address_t rawPacketStoreId) {
 	message->setCommand(CMD_RAW);
@@ -79,13 +67,12 @@ void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
 void DeviceHandlerMessage::clear(CommandMessage* message) {
 	switch (message->getCommand()) {
 	case CMD_RAW:
-//	case CMD_DIRECT:
 	case REPLY_RAW_COMMAND:
 	case REPLY_RAW_REPLY:
 	case REPLY_DIRECT_COMMAND_DATA: {
 		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
 				objects::IPC_STORE);
-		if (ipcStore != NULL) {
+		if (ipcStore != nullptr) {
 			ipcStore->deleteData(getStoreAddress(message));
 		}
 	}
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index 842dfee8d..e5da01c8f 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -15,7 +15,10 @@
  */
 class DeviceHandlerMessage {
 public:
-    // Instantiation forbidden.
+    /**
+     * Instantiation forbidden. Instead, use static functions to operate
+     * on messages.
+     */
 	DeviceHandlerMessage() = delete;
 	virtual ~DeviceHandlerMessage() {}
 
@@ -25,21 +28,21 @@ public:
 	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
 	//! Sends a raw command, setParameter is a storeId containing the
 	//! raw packet to send
-	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 );
+	static const Command_t CMD_RAW = MAKE_COMMAND_ID(1);
 	//! Requests a IO-Board switch, setParameter() is the IO-Board identifier
-	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 );
+	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID(3);
 	//! (De)Activates the monitoring of all raw traffic in DeviceHandlers,
 	//! setParameter is 0 to deactivate, 1 to activate
-	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 );
+	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID(4);
 
 	//! Signals that a direct command was sent
 	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS;
 	//! Contains a raw command sent to the Device
-	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 );
+	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11);
 	//! Contains a raw reply from the Device, getParameter() is the ObjcetId
 	//! of the sender, getParameter2() is a ::store_id_t containing the
 	//! raw packet received
-	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12);
+	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID(0x12);
 	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
 
 	static store_address_t getStoreAddress(const CommandMessage* message);

From 43b44c57b6754c82e3813444568b8fc275469f92 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 11:07:20 +0200
Subject: [PATCH 0851/1774] placement fact update

---
 container/PlacementFactory.h | 42 +++++++++++++++++++++++++++++++++---
 1 file changed, 39 insertions(+), 3 deletions(-)

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

From 32ebca48b864039cd5ee334b6f69ff6010d1d700 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 11:07:46 +0200
Subject: [PATCH 0852/1774] FIFO updates

---
 container/FIFOBase.h   | 30 ++++++++++++++++++++++--------
 container/FIFOBase.tpp |  6 ++++++
 2 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index b744706d4..edd66d37a 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -19,32 +19,46 @@ public:
 	/**
 	 * Insert value into FIFO
 	 * @param value
-	 * @return
+	 * @return RETURN_OK on success, FULL if full
 	 */
 	ReturnValue_t insert(T value);
 	/**
 	 * Retrieve item from FIFO. This removes the item from the FIFO.
-	 * @param value
-	 * @return
+	 * @param value Must point to a valid T
+	 * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
 	 */
 	ReturnValue_t retrieve(T *value);
 	/**
 	 * Retrieve item from FIFO without removing it from FIFO.
-	 * @param value
-	 * @return
+	 * @param value Must point to a valid T
+	 * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
 	 */
 	ReturnValue_t peek(T * value);
 	/**
 	 * Remove item from FIFO.
-	 * @return
+	 * @return RETURN_OK on success, EMPTY if empty
 	 */
 	ReturnValue_t pop();
 
+	/***
+	 * Check if FIFO is empty
+	 * @return True if empty, False if not
+	 */
 	bool empty();
+	/***
+	 * Check if FIFO is Full
+	 * @return True if full, False if not
+	 */
 	bool full();
+	/***
+	 *  Current used size (elements) used
+	 * @return size_t in elements
+	 */
 	size_t size();
-
-
+	/***
+	 * Get maximal capacity of fifo
+	 * @return size_t with max capacity of this fifo
+	 */
 	size_t getMaxCapacity() const;
 
 protected:
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index d54b3f8f9..763004b6f 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -26,6 +26,9 @@ inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
 	if (empty()) {
 		return EMPTY;
 	} else {
+		if (value == nullptr){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
 		*value = values[readIndex];
 		readIndex = next(readIndex);
 		--currentSize;
@@ -38,6 +41,9 @@ inline ReturnValue_t FIFOBase<T>::peek(T* value) {
 	if(empty()) {
 		return EMPTY;
 	} else {
+		if (value == nullptr){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
 		*value = values[readIndex];
 		return HasReturnvaluesIF::RETURN_OK;
 	}

From b313043e4312af0f54a24a2b8e560ba22ce287c5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 12:05:24 +0200
Subject: [PATCH 0853/1774] added new local data pool files

---
 datapoollocal/HasLocalDataPoolIF.h          |  95 +++++
 datapoollocal/LocalDataPoolManager.cpp      | 427 ++++++++++++++++++++
 datapoollocal/LocalDataPoolManager.h        | 291 +++++++++++++
 datapoollocal/LocalDataSet.cpp              |  22 +
 datapoollocal/LocalDataSet.h                |  21 +
 datapoollocal/LocalPoolDataSetBase.cpp      | 259 ++++++++++++
 datapoollocal/LocalPoolDataSetBase.h        | 190 +++++++++
 datapoollocal/LocalPoolVariable.h           | 177 ++++++++
 datapoollocal/LocalPoolVariable.tpp         | 169 ++++++++
 datapoollocal/LocalPoolVector.h             | 202 +++++++++
 datapoollocal/LocalPoolVector.tpp           | 209 ++++++++++
 datapoollocal/SharedLocalDataSet.cpp        |  16 +
 datapoollocal/SharedLocalDataSet.h          |  24 ++
 datapoollocal/StaticLocalDataSet.h          |  50 +++
 housekeeping/AcceptsHkPacketsIF.h           |  11 +
 housekeeping/HousekeepingMessage.cpp        | 162 ++++++++
 housekeeping/HousekeepingMessage.h          | 157 +++++++
 housekeeping/HousekeepingPacketDownlink.h   |  34 ++
 housekeeping/HousekeepingPacketUpdate.h     |  73 ++++
 housekeeping/HousekeepingSetPacket.h        |  59 +++
 housekeeping/PeriodicHousekeepingHelper.cpp |  48 +++
 housekeeping/PeriodicHousekeepingHelper.h   |  32 ++
 22 files changed, 2728 insertions(+)
 create mode 100644 datapoollocal/HasLocalDataPoolIF.h
 create mode 100644 datapoollocal/LocalDataPoolManager.cpp
 create mode 100644 datapoollocal/LocalDataPoolManager.h
 create mode 100644 datapoollocal/LocalDataSet.cpp
 create mode 100644 datapoollocal/LocalDataSet.h
 create mode 100644 datapoollocal/LocalPoolDataSetBase.cpp
 create mode 100644 datapoollocal/LocalPoolDataSetBase.h
 create mode 100644 datapoollocal/LocalPoolVariable.h
 create mode 100644 datapoollocal/LocalPoolVariable.tpp
 create mode 100644 datapoollocal/LocalPoolVector.h
 create mode 100644 datapoollocal/LocalPoolVector.tpp
 create mode 100644 datapoollocal/SharedLocalDataSet.cpp
 create mode 100644 datapoollocal/SharedLocalDataSet.h
 create mode 100644 datapoollocal/StaticLocalDataSet.h
 create mode 100644 housekeeping/AcceptsHkPacketsIF.h
 create mode 100644 housekeeping/HousekeepingMessage.cpp
 create mode 100644 housekeeping/HousekeepingMessage.h
 create mode 100644 housekeeping/HousekeepingPacketDownlink.h
 create mode 100644 housekeeping/HousekeepingPacketUpdate.h
 create mode 100644 housekeeping/HousekeepingSetPacket.h
 create mode 100644 housekeeping/PeriodicHousekeepingHelper.cpp
 create mode 100644 housekeeping/PeriodicHousekeepingHelper.h

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
new file mode 100644
index 000000000..f8f4ef4c4
--- /dev/null
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -0,0 +1,95 @@
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
+
+#include "../datapool/PoolEntryIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include "../housekeeping/HousekeepingMessage.h"
+
+#include <map>
+
+class LocalDataPoolManager;
+class LocalPoolDataSetBase;
+
+/**
+ * @brief	Type definition for local pool entries.
+ */
+using lp_id_t = uint32_t;
+using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
+using LocalDataPoolMapIter = LocalDataPool::iterator;
+
+/**
+ * @brief 		This interface is implemented by classes which posses a local
+ * 				data pool (not the managing class). It defines the relationship
+ * 				between the local data pool owner and the LocalDataPoolManager.
+ * @details
+ * Any class implementing this interface shall also have a LocalDataPoolManager
+ * member class which contains the actual pool data structure
+ * and exposes the public interface for it.
+ * This is required because the pool entries are templates, which makes
+ * specifying an interface rather difficult. The local data pool can be
+ * accessed by using the LocalPoolVariable, LocalPoolVector or LocalDataSet
+ * classes.
+ *
+ * Architectural Note:
+ * This could be circumvented by using a wrapper/accessor function or
+ * implementing the templated function in this interface..
+ * The first solution sounds better than the second but
+ * the LocalPoolVariable classes are templates as well, so this just shifts
+ * the problem somewhere else. Interfaces are nice, but the most
+ * pragmatic solution I found was to offer the client the full interface
+ * of the LocalDataPoolManager.
+ */
+class HasLocalDataPoolIF {
+public:
+	virtual~ HasLocalDataPoolIF() {};
+
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
+	static constexpr lp_id_t NO_POOL_ID = 0xffffffff;
+
+	virtual object_id_t getObjectId() const = 0;
+
+	/** Command queue for housekeeping messages. */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+	/**
+	 * Is used by pool owner to initialize the pool map once
+	 * The manager instance shall also be passed to this function.
+	 * It can be used to subscribe for periodic packets for for updates.
+	 */
+	virtual ReturnValue_t initializeLocalDataPool(
+	        LocalDataPool& localDataPoolMap,
+	        LocalDataPoolManager& poolManager) = 0;
+
+	/** Can be used to get a handle to the local data pool manager. */
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+	/**
+	 * Returns the minimum sampling frequency in milliseconds, which will
+	 * usually be the period the pool owner performs its periodic operation.
+	 * @return
+	 */
+	virtual uint32_t getPeriodicOperationFrequency() const = 0;
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
+
+	/* These function can be implemented by pool owner, as they are required
+	 * by the housekeeping message interface */
+	virtual ReturnValue_t addDataSet(sid_t sid) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+	virtual ReturnValue_t removeDataSet(sid_t sid) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
+	        float newIntervalSeconds) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
new file mode 100644
index 000000000..c23f183b1
--- /dev/null
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -0,0 +1,427 @@
+#include "LocalDataPoolManager.h"
+#include "LocalPoolDataSetBase.h"
+
+#include "../housekeeping/HousekeepingSetPacket.h"
+#include "../housekeeping/AcceptsHkPacketsIF.h"
+#include "../ipc/MutexFactory.h"
+#include "../ipc/MutexHelper.h"
+#include "../ipc/QueueFactory.h"
+#include "../objectmanager/frameworkObjects.h"
+
+#include <array>
+#include <cmath>
+
+object_id_t LocalDataPoolManager::defaultHkDestination =
+		objects::PUS_SERVICE_3_HOUSEKEEPING;
+
+LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
+        MessageQueueIF* queueToUse, bool appendValidityBuffer):
+        appendValidityBuffer(appendValidityBuffer) {
+    if(owner == nullptr) {
+        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+                << "Invalid supplied owner!" << std::endl;
+        return;
+    }
+    this->owner = owner;
+    mutex = MutexFactory::instance()->createMutex();
+    if(mutex == nullptr) {
+        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+                << "Could not create mutex." << std::endl;
+    }
+
+    hkQueue = queueToUse;
+}
+
+LocalDataPoolManager::~LocalDataPoolManager() {}
+
+ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
+    if(queueToUse == nullptr) {
+        sif::error << "LocalDataPoolManager::initialize: "
+                << std::hex << "0x" << owner->getObjectId() << ". Supplied "
+                << "queue invalid!" << std::dec << std::endl;
+    }
+    hkQueue = queueToUse;
+
+    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if(ipcStore == nullptr) {
+        sif::error << "LocalDataPoolManager::initialize: "
+                << std::hex << "0x" << owner->getObjectId() << ": Could not "
+                << "set IPC store." <<std::dec << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+
+    if(defaultHkDestination != objects::NO_OBJECT) {
+        AcceptsHkPacketsIF* hkPacketReceiver =
+                objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
+        if(hkPacketReceiver != nullptr) {
+            hkDestinationId = hkPacketReceiver->getHkQueue();
+        }
+        else {
+            sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+                   << "Default HK destination object is invalid!" << std::endl;
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
+        uint8_t nonDiagInvlFactor) {
+    setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
+    return initializeHousekeepingPoolEntriesOnce();
+}
+
+ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
+	if(not mapInitialized) {
+		ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
+		        *this);
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			mapInitialized = true;
+		}
+		return result;
+	}
+	sif::warning << "HousekeepingManager: The map should only be initialized "
+	        << "once!" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::performHkOperation() {
+    for(auto& receiver: hkReceiversMap) {
+        //HkReceiver* receiver = &hkReceiversIter.second;
+
+        switch(receiver.reportingType) {
+        case(ReportingType::PERIODIC): {
+            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+                // Periodic packets shall only be generated from datasets.
+                continue;
+            }
+            performPeriodicHkGeneration(receiver);
+            break;
+        }
+        case(ReportingType::UPDATE_SNAPSHOT): {
+            // check whether data has changed and send messages in case it has.
+            break;
+        }
+        default:
+            // This should never happen.
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
+		bool enableReporting, float collectionInterval, bool isDiagnostics,
+		object_id_t packetDestination) {
+	AcceptsHkPacketsIF* hkReceiverObject =
+			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	if(hkReceiverObject == nullptr) {
+		sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
+				<< " Invalid receiver!"<< std::endl;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataId.sid = sid;
+	hkReceiver.reportingType = ReportingType::PERIODIC;
+	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet != nullptr) {
+		dataSet->setReportingEnabled(enableReporting);
+		dataSet->setDiagnostic(isDiagnostics);
+		dataSet->initializePeriodicHelper(collectionInterval,
+				owner->getPeriodicOperationFrequency(), isDiagnostics);
+	}
+
+	hkReceiversMap.push_back(hkReceiver);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
+		CommandMessage* message) {
+    Command_t command = message->getCommand();
+    sid_t sid = HousekeepingMessage::getSid(message);
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    switch(command) {
+    case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+    	result = togglePeriodicGeneration(sid, true, true);
+    	break;
+    }
+
+    case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+    	result = togglePeriodicGeneration(sid, false, true);
+    	break;
+    }
+
+    case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
+    	result = togglePeriodicGeneration(sid, true, false);
+    	break;
+    }
+
+    case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
+    	result = togglePeriodicGeneration(sid, false, false);
+    	break;
+    }
+
+    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
+        return generateSetStructurePacket(sid, true);
+    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
+        return generateSetStructurePacket(sid, false);
+    case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
+    case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
+    	float newCollIntvl = 0;
+    	HousekeepingMessage::getCollectionIntervalModificationCommand(message,
+    			&newCollIntvl);
+    	if(command == HousekeepingMessage::
+    			MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
+    		result = changeCollectionInterval(sid, newCollIntvl, true);
+    	}
+    	else {
+    		result = changeCollectionInterval(sid, newCollIntvl, false);
+    	}
+    	break;
+    }
+
+    case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
+    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
+    	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    	if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
+    			and dataSet->isDiagnostics()) {
+    		return WRONG_HK_PACKET_TYPE;
+    	}
+    	else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
+    			and not dataSet->isDiagnostics()) {
+    		return WRONG_HK_PACKET_TYPE;
+    	}
+    	return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+    			dataSet, true);
+    }
+
+    default:
+        return CommandMessageIF::UNKNOWN_COMMAND;
+    }
+
+    CommandMessage reply;
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
+	}
+	else {
+		HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
+	}
+	hkQueue->sendMessage(hkDestinationId, &reply);
+	return result;
+}
+
+ReturnValue_t LocalDataPoolManager::printPoolEntry(
+		lp_id_t localPoolId) {
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
+		sif::debug << "HousekeepingManager::fechPoolEntry:"
+				<< " Pool entry not found." << std::endl;
+		return POOL_ENTRY_NOT_FOUND;
+	}
+	poolIter->second->print();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MutexIF* LocalDataPoolManager::getMutexHandle() {
+	return mutex;
+}
+
+HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
+    return owner;
+}
+
+ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
+		LocalPoolDataSetBase* dataSet, bool forDownlink,
+		MessageQueueId_t destination) {
+	if(dataSet == nullptr) {
+		// Configuration error.
+		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+				<< " Set ID not found or dataset not assigned!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	store_address_t storeId;
+	HousekeepingPacketDownlink hkPacket(sid, dataSet);
+	size_t serializedSize = 0;
+	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
+			forDownlink, &serializedSize);
+	if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
+	    return result;
+	}
+
+	// and now we set a HK message and send it the HK packet destination.
+	CommandMessage hkMessage;
+	if(dataSet->isDiagnostics()) {
+		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
+	}
+	else {
+		HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
+	}
+
+	if(hkQueue == nullptr) {
+	    return QUEUE_OR_DESTINATION_NOT_SET;
+	}
+	if(destination == MessageQueueIF::NO_QUEUE) {
+	    if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
+	        // error, all destinations invalid
+	        return HasReturnvaluesIF::RETURN_FAILED;
+	    }
+	    destination = hkDestinationId;
+	}
+
+	return hkQueue->sendMessage(destination, &hkMessage);
+}
+
+ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
+        HousekeepingPacketDownlink& hkPacket,
+        store_address_t& storeId, bool forDownlink,
+		size_t* serializedSize) {
+    uint8_t* dataPtr = nullptr;
+    const size_t maxSize = hkPacket.getSerializedSize();
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            maxSize, &dataPtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    if(forDownlink) {
+    	return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+    	            SerializeIF::Endianness::BIG);
+    }
+    return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+            SerializeIF::Endianness::MACHINE);
+}
+
+void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
+        uint8_t nonDiagInvlFactor) {
+    this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
+}
+
+void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
+	sid_t sid = receiver.dataId.sid;
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(not dataSet->getReportingEnabled()) {
+		return;
+	}
+
+	if(dataSet->periodicHelper == nullptr) {
+		// Configuration error.
+		return;
+	}
+
+	if(not dataSet->periodicHelper->checkOpNecessary()) {
+		return;
+	}
+
+	ReturnValue_t result = generateHousekeepingPacket(
+			sid, dataSet, true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		// configuration error
+		sif::debug << "LocalDataPoolManager::performHkOperation:"
+				<< "0x" << std::hex << std::setfill('0') << std::setw(8)
+				<< owner->getObjectId() << " Error generating "
+				<< "HK packet" << std::setfill(' ') << std::dec << std::endl;
+	}
+}
+
+
+ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
+		bool enable, bool isDiagnostics) {
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if((dataSet->isDiagnostics() and not isDiagnostics) or
+			(not dataSet->isDiagnostics() and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
+
+	if((dataSet->getReportingEnabled() and enable) or
+			(not dataSet->getReportingEnabled() and not enable)) {
+		return REPORTING_STATUS_UNCHANGED;
+	}
+
+	dataSet->setReportingEnabled(enable);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
+		float newCollectionInterval, bool isDiagnostics) {
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	bool targetIsDiagnostics = dataSet->isDiagnostics();
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
+
+	if(dataSet->periodicHelper == nullptr) {
+		// config error
+		return PERIODIC_HELPER_INVALID;
+	}
+
+	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
+		bool isDiagnostics) {
+    // Get and check dataset first.
+	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+			owner->getDataSetHandle(sid));
+	if(dataSet == nullptr) {
+		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+				<< " Set ID not found" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+
+	bool targetIsDiagnostics = dataSet->isDiagnostics();
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
+
+	bool valid = dataSet->isValid();
+	bool reportingEnabled = dataSet->getReportingEnabled();
+	float collectionInterval =
+			dataSet->periodicHelper->getCollectionIntervalInSeconds();
+
+	// Generate set packet which can be serialized.
+	HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid,
+			reportingEnabled, valid, collectionInterval, dataSet);
+	size_t expectedSize = setPacket.getSerializedSize();
+	uint8_t* storePtr = nullptr;
+	store_address_t storeId;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			expectedSize,&storePtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+				<< "Could not get free element from IPC store." << std::endl;
+		return result;
+	}
+
+	// Serialize set packet into store.
+	size_t size = 0;
+	result = setPacket.serialize(&storePtr, &size, expectedSize,
+			SerializeIF::Endianness::BIG);
+	if(expectedSize != size) {
+		sif::error << "HousekeepingManager::generateSetStructurePacket: "
+				<< "Expected size is not equal to serialized size" << std::endl;
+	}
+
+	// Send structure reporting reply.
+	CommandMessage reply;
+	if(isDiagnostics) {
+	    HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
+	            sid, storeId);
+	}
+	else {
+	    HousekeepingMessage::setHkStuctureReportReply(&reply,
+	                    sid, storeId);
+	}
+
+	hkQueue->reply(&reply);
+	return result;
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
new file mode 100644
index 000000000..779e30500
--- /dev/null
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -0,0 +1,291 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+
+#include "HasLocalDataPoolIF.h"
+
+#include "../housekeeping/HousekeepingPacketDownlink.h"
+#include "../housekeeping/HousekeepingMessage.h"
+#include "../housekeeping/PeriodicHousekeepingHelper.h"
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../ipc/MutexIF.h"
+#include "../ipc/CommandMessage.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../ipc/MutexHelper.h"
+
+#include <map>
+
+namespace Factory {
+void setStaticFrameworkObjectIds();
+}
+
+class LocalDataSetBase;
+
+
+/**
+ * @brief 		This class is the managing instance for the local data pool.
+ * @details
+ * The actual data pool structure is a member of this class. Any class which
+ * has a local data pool shall have this class as a member and implement
+ * the HasLocalDataPoolIF.
+ *
+ * Users of the data pool use the helper classes LocalDataSet,
+ * LocalPoolVariable and LocalPoolVector to access pool entries in
+ * a thread-safe and efficient way.
+ *
+ * The local data pools employ a blackboard logic: Only the most recent
+ * value is stored. The helper classes offer a read() and commit() interface
+ * through the PoolVariableIF which is used to read and update values.
+ * Each pool entry has a valid state too.
+ * @author 		R. Mueller
+ */
+class LocalDataPoolManager {
+	template<typename T>
+	friend class LocalPoolVar;
+	template<typename T, uint16_t vecSize>
+	friend class LocalPoolVector;
+	friend class LocalPoolDataSetBase;
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
+
+    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
+    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x02);
+
+    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x03);
+    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x04);
+    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x05);
+
+    /**
+     * This constructor is used by a class which wants to implement
+     * a personal local data pool. The queueToUse can be supplied if it
+     * is already known.
+     *
+     * initialize() has to be called in any case before using the object!
+     * @param owner
+     * @param queueToUse
+     * @param appendValidityBuffer
+     */
+	LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+	        bool appendValidityBuffer = true);
+	virtual~ LocalDataPoolManager();
+
+	/**
+	 * Assigns the queue to use.
+	 * @param queueToUse
+	 * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
+	 * @return
+	 */
+	ReturnValue_t initialize(MessageQueueIF* queueToUse);
+
+	/**
+	 * Initializes the map by calling the map initialization function and
+	 * setting the periodic factor for non-diagnostic packets.
+	 * Don't forget to call this, otherwise the map will be invalid!
+	 * @param nonDiagInvlFactor
+	 * @return
+	 */
+	ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
+
+    /**
+     * This should be called in the periodic handler of the owner.
+     * It performs all the periodic functionalities of the data pool manager,
+     * for example generating periodic HK packets.
+     * @return
+     */
+    ReturnValue_t performHkOperation();
+
+	/**
+	 * @return
+	 */
+	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
+			float collectionInterval, bool isDiagnostics,
+			object_id_t packetDestination = defaultHkDestination);
+
+	/**
+	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
+	 * than diagnostic packets.
+	 * A factor can be specified to determine the minimum sampling frequency
+	 * for non-diagnostic packets. The minimum sampling frequency of the
+	 * diagnostics packets,which is usually jusst the period of the
+	 * performOperation calls, is multiplied with that factor.
+	 * @param factor
+	 */
+	void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
+
+
+	/**
+	 * Generate a housekeeping packet with a given SID.
+	 * @param sid
+	 * @return
+	 */
+	ReturnValue_t generateHousekeepingPacket(sid_t sid,
+			LocalPoolDataSetBase* dataSet, bool forDownlink,
+			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
+
+	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
+
+	/**
+	 * This function is used to fill the local data pool map with pool
+	 * entries. It should only be called once by the pool owner.
+	 * @param localDataPoolMap
+	 * @return
+	 */
+	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
+
+	HasLocalDataPoolIF* getOwner();
+
+	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
+
+    /**
+     * Different types of housekeeping reporting are possible.
+     *  1. PERIODIC:
+     *     HK packets are generated in fixed intervals and sent to
+     *     destination. Fromat will be raw.
+     *  2. UPDATE_NOTIFICATION:
+     *     Notification will be sent out if HK data has changed.
+     *  3. UPDATE_SNAPSHOT:
+     *     HK packets are only generated if explicitely requested.
+     *     Propably not necessary, just use multiple local data sets or
+     *     shared datasets.
+     */
+    enum class ReportingType: uint8_t {
+        //! Periodic generation of HK packets.
+        PERIODIC,
+        //! Housekeeping packet will be generated if values have changed.
+        UPDATE_HK,
+		//! Update notification will be sent out as message.
+		UPDATE_NOTIFICATION,
+        //! Notification will be sent out as message and a snapshot of the
+        //! current data will be generated.
+        UPDATE_SNAPSHOT,
+    };
+
+    /**
+     * Different data types are possible in the HK receiver map.
+     * For example, updates can be requested for full datasets or
+     * for single pool variables. Periodic reporting is only possible for
+     * data sets.
+     */
+    enum class DataType: uint8_t {
+    	LOCAL_POOL_VARIABLE,
+		DATA_SET
+    };
+
+    /* Copying forbidden */
+    LocalDataPoolManager(const LocalDataPoolManager &) = delete;
+    LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
+
+private:
+    LocalDataPool localPoolMap;
+    //! Every housekeeping data manager has a mutex to protect access
+    //! to it's data pool.
+    MutexIF* mutex = nullptr;
+
+    /** The class which actually owns the manager (and its datapool). */
+    HasLocalDataPoolIF* owner = nullptr;
+
+    uint8_t nonDiagnosticIntervalFactor = 0;
+
+	/** Default receiver for periodic HK packets */
+	static object_id_t defaultHkDestination;
+	MessageQueueId_t hkDestinationId = MessageQueueIF::NO_QUEUE;
+
+    /** The data pool manager will keep an internal map of HK receivers. */
+    struct HkReceiver {
+		/** Object ID of receiver */
+		object_id_t objectId = objects::NO_OBJECT;
+
+		DataType dataType = DataType::DATA_SET;
+        union DataId {
+			DataId(): sid() {};
+            sid_t sid;
+            lp_id_t localPoolId;
+        };
+        DataId dataId;
+
+        ReportingType reportingType = ReportingType::PERIODIC;
+        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
+    };
+
+    /** This vector will contain the list of HK receivers. */
+    using HkReceivers = std::vector<struct HkReceiver>;
+
+    HkReceivers hkReceiversMap;
+
+    /** This is the map holding the actual data. Should only be initialized
+     * once ! */
+    bool mapInitialized = false;
+    /** This specifies whether a validity buffer is appended at the end
+     * of generated housekeeping packets. */
+    bool appendValidityBuffer = true;
+
+	/**
+	 * @brief Queue used for communication, for example commands.
+	 * Is also used to send messages. Can be set either in the constructor
+     * or in the initialize() function.
+	 */
+	MessageQueueIF* hkQueue = nullptr;
+
+	/** Global IPC store is used to store all packets. */
+	StorageManagerIF* ipcStore = nullptr;
+	/**
+	 * Get the pointer to the mutex. Can be used to lock the data pool
+	 * eternally. Use with care and don't forget to unlock locked mutexes!
+	 * For now, only friend classes can accss this function.
+	 * @return
+	 */
+	MutexIF* getMutexHandle();
+
+	/**
+	 * Read a variable by supplying its local pool ID and assign the pool
+	 * entry to the supplied PoolEntry pointer. The type of the pool entry
+	 * is deduced automatically. This call is not thread-safe!
+	 * For now, only friend classes like LocalPoolVar may access this
+	 * function.
+	 * @tparam T Type of the pool entry
+	 * @param localPoolId Pool ID of the variable to read
+	 * @param poolVar [out] Corresponding pool entry will be assigned to the
+	 * 						supplied pointer.
+	 * @return
+	 */
+	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
+			PoolEntry<T> **poolEntry);
+
+	ReturnValue_t serializeHkPacketIntoStore(
+	        HousekeepingPacketDownlink& hkPacket,
+	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
+
+	void performPeriodicHkGeneration(HkReceiver& hkReceiver);
+	ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable,
+			bool isDiagnostics);
+	ReturnValue_t changeCollectionInterval(sid_t sid,
+			float newCollectionInterval, bool isDiagnostics);
+	ReturnValue_t generateSetStructurePacket(sid_t sid, bool isDiagnostics);
+};
+
+
+template<class T> inline
+ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
+		PoolEntry<T> **poolEntry) {
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
+		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
+		        "not found." << std::endl;
+		return POOL_ENTRY_NOT_FOUND;
+	}
+
+	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
+	if(*poolEntry == nullptr) {
+		sif::debug << "HousekeepingManager::fetchPoolEntry:"
+				" Pool entry not found." << std::endl;
+		return POOL_ENTRY_TYPE_CONFLICT;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
new file mode 100644
index 000000000..394a9abe9
--- /dev/null
+++ b/datapoollocal/LocalDataSet.cpp
@@ -0,0 +1,22 @@
+#include "LocalDataSet.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../serialize/SerializeAdapter.h"
+
+#include <cmath>
+#include <cstring>
+
+LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner, uint32_t setId,
+        const size_t maxNumberOfVariables):
+        LocalPoolDataSetBase(hkOwner, setId, nullptr, maxNumberOfVariables),
+        poolVarList(maxNumberOfVariables) {
+	this->setContainer(poolVarList.data());
+}
+
+LocalDataSet::LocalDataSet(sid_t sid, const size_t maxNumberOfVariables):
+        LocalPoolDataSetBase(sid, nullptr, maxNumberOfVariables),
+		poolVarList(maxNumberOfVariables) {
+	this->setContainer(poolVarList.data());
+}
+
+LocalDataSet::~LocalDataSet() {}
+
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
new file mode 100644
index 000000000..0368f26d1
--- /dev/null
+++ b/datapoollocal/LocalDataSet.h
@@ -0,0 +1,21 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDATASET_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDATASET_H_
+
+#include "LocalPoolDataSetBase.h"
+#include <vector>
+
+class LocalDataSet: public LocalPoolDataSetBase {
+public:
+    LocalDataSet(HasLocalDataPoolIF* hkOwner, uint32_t setId,
+    		const size_t maxSize);
+    LocalDataSet(sid_t sid, const size_t maxSize);
+    virtual~ LocalDataSet();
+
+    //! Copying forbidden for now.
+    LocalDataSet(const LocalDataSet&) = delete;
+    LocalDataSet& operator=(const LocalDataSet&) = delete;
+private:
+    std::vector<PoolVariableIF*> poolVarList;
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
new file mode 100644
index 000000000..da0a86b2c
--- /dev/null
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -0,0 +1,259 @@
+#include "LocalPoolDataSetBase.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../housekeeping/PeriodicHousekeepingHelper.h"
+#include "../serialize/SerializeAdapter.h"
+
+#include <cmath>
+#include <cstring>
+
+LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
+		uint32_t setId, PoolVariableIF** registeredVariablesArray,
+		const size_t maxNumberOfVariables, bool noPeriodicHandling):
+		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+	if(hkOwner == nullptr) {
+		// Configuration error.
+		sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+				<< "invalid!" << std::endl;
+		return;
+	}
+    hkManager = hkOwner->getHkManagerHandle();
+    this->sid.objectId = hkOwner->getObjectId();
+    this->sid.ownerSetId = setId;
+
+    // Data creators get a periodic helper for periodic HK data generation.
+    if(not noPeriodicHandling) {
+    	 periodicHelper = new PeriodicHousekeepingHelper(this);
+    }
+}
+
+LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
+        PoolVariableIF** registeredVariablesArray,
+        const size_t maxNumberOfVariables):
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
+    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+            sid.objectId);
+    if(hkOwner == nullptr) {
+    	// Configuration error.
+        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+        		<< "invalid!" << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+    this->sid = sid;
+}
+
+LocalPoolDataSetBase::~LocalPoolDataSetBase() {
+}
+
+ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+}
+
+ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
+        size_t *size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+    uint8_t validityMask[validityMaskSize];
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if(registeredVariables[count]->isValid()) {
+            // set validity buffer here.
+            this->bitSetter(validityMask + validBufferIndex,
+                    validBufferIndexBit);
+            if(validBufferIndexBit == 7) {
+                validBufferIndex ++;
+                validBufferIndexBit = 0;
+            }
+            else {
+                validBufferIndexBit ++;
+            }
+        }
+        result = registeredVariables[count]->serialize(buffer, size, maxSize,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    // copy validity buffer to end
+    std::memcpy(*buffer, validityMask, validityMaskSize);
+    *size += validityMaskSize;
+    return result;
+}
+
+ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
+        const uint8_t **buffer, size_t *size,
+        SerializeIF::Endianness streamEndianness) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        result = registeredVariables[count]->deSerialize(buffer, size,
+                        streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    // could be made more efficient but make it work first
+    for (uint16_t count = 0; count < fillCount; count++) {
+        // set validity buffer here.
+        bool nextVarValid = this->bitGetter(*buffer +
+                validBufferIndex, validBufferIndexBit);
+        registeredVariables[count]->setValid(nextVarValid);
+
+        if(validBufferIndexBit == 7) {
+            validBufferIndex ++;
+            validBufferIndexBit = 0;
+        }
+        else {
+            validBufferIndexBit ++;
+        }
+    }
+    return result;
+}
+ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->unlockMutex();
+}
+
+ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
+        size_t* size, size_t maxSize,SerializeIF::Endianness streamEndianness,
+        bool serializeFillCount) const {
+    // Serialize as uint8_t
+    uint8_t fillCount = this->fillCount;
+    if(serializeFillCount) {
+        SerializeAdapter::serialize(&fillCount, buffer, size, maxSize,
+                streamEndianness);
+    }
+    for (uint16_t count = 0; count < fillCount; count++) {
+        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
+        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
+                size, maxSize, streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
+                    " error!" << std::endl;
+            return result;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+uint8_t LocalPoolDataSetBase::getLocalPoolIdsSerializedSize(
+        bool serializeFillCount) const {
+    if(serializeFillCount) {
+        return fillCount * sizeof(lp_id_t) + sizeof(uint8_t);
+    }
+    else {
+        return fillCount * sizeof(lp_id_t);
+    }
+}
+
+size_t LocalPoolDataSetBase::getSerializedSize() const {
+    if(withValidityBuffer) {
+        uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+        return validityMaskSize + PoolDataSetBase::getSerializedSize();
+    }
+    else {
+        return PoolDataSetBase::getSerializedSize();
+    }
+}
+
+void LocalPoolDataSetBase::setValidityBufferGeneration(
+        bool withValidityBuffer) {
+    this->withValidityBuffer = withValidityBuffer;
+}
+
+ReturnValue_t LocalPoolDataSetBase::deSerialize(const uint8_t **buffer,
+        size_t *size, SerializeIF::Endianness streamEndianness) {
+    if(withValidityBuffer) {
+        return this->deSerializeWithValidityBuffer(buffer, size,
+                streamEndianness);
+    }
+    else {
+        return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
+    }
+}
+
+ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
+        size_t maxSize, SerializeIF::Endianness streamEndianness) const {
+    if(withValidityBuffer) {
+        return this->serializeWithValidityBuffer(buffer, size,
+                maxSize, streamEndianness);
+    }
+    else {
+        return PoolDataSetBase::serialize(buffer, size, maxSize,
+                streamEndianness);
+    }
+}
+
+void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position"
+        		<< std::endl;
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1 << shiftNumber;
+}
+
+void LocalPoolDataSetBase::setDiagnostic(bool isDiagnostics) {
+	this->diagnostic = isDiagnostics;
+}
+
+bool LocalPoolDataSetBase::isDiagnostics() const {
+	return diagnostic;
+}
+
+void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
+	this->reportingEnabled = reportingEnabled;
+}
+
+bool LocalPoolDataSetBase::getReportingEnabled() const {
+	return reportingEnabled;
+}
+
+void LocalPoolDataSetBase::initializePeriodicHelper(
+		float collectionInterval, dur_millis_t minimumPeriodicInterval,
+		bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
+	periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
+			isDiagnostics, nonDiagIntervalFactor);
+}
+
+void LocalPoolDataSetBase::setChanged(bool changed) {
+	this->changed = changed;
+}
+
+bool LocalPoolDataSetBase::isChanged() const {
+	return changed;
+}
+
+sid_t LocalPoolDataSetBase::getSid() const {
+	return sid;
+}
+
+bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
+		uint8_t position) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position"
+        		<< std::endl;
+        return false;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    return *byte & (1 << shiftNumber);
+}
+
+bool LocalPoolDataSetBase::isValid() const {
+    return this->valid;
+}
+
+void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
+	if(setEntriesRecursively) {
+		for(size_t idx = 0; idx < this->getFillCount(); idx++) {
+			registeredVariables[idx] -> setValid(valid);
+		}
+	}
+	this->valid = valid;
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
new file mode 100644
index 000000000..d00af9920
--- /dev/null
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -0,0 +1,190 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+
+#include "HasLocalDataPoolIF.h"
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolDataSetBase.h"
+#include "../serialize/SerializeIF.h"
+
+#include <vector>
+
+class LocalDataPoolManager;
+class PeriodicHousekeepingHelper;
+
+/**
+ * @brief	The LocalDataSet class manages a set of locally checked out
+ *          variables for local data pools
+ * @details
+ * Extends the PoolDataSetBase class for local data pools by introducing
+ * a validity state, a flag to mark the set as changed, and various other
+ * functions to make it usable by the LocalDataPoolManager class.
+ *
+ * This class manages a list, where a set of local variables (or pool variables)
+ * are registered. They are checked-out (i.e. their values are looked
+ * up and copied) with the read call. After the user finishes working with the
+ * pool variables, he can write back all variable values to the pool with
+ * the commit call. The data set manages locking and freeing the local data
+ * pools, to ensure thread-safety.
+ *
+ * Pool variables can be added to the dataset by using the constructor
+ * argument of the pool variable or using the #registerVariable member function.
+ *
+ * An internal state manages usage of this class. Variables may only be
+ * registered before any read call is made, and the commit call can only happen
+ * after the read call.
+ *
+ * If pool variables are writable and not committed until destruction
+ * of the set, the DataSet class automatically sets the valid flag in the
+ * data pool to invalid (without) changing the variable's value.
+ *
+ * @ingroup data_pool
+ */
+class LocalPoolDataSetBase: public PoolDataSetBase {
+	friend class LocalDataPoolManager;
+	friend class PeriodicHousekeepingHelper;
+public:
+	/**
+	 * @brief	Constructor for the creator of local pool data.
+	 * @details
+	 * This constructor also initializes the components required for
+	 * periodic handling.
+	 */
+	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
+			uint32_t setId, PoolVariableIF** registeredVariablesArray,
+	        const size_t maxNumberOfVariables, bool noPeriodicHandling = false);
+
+	/**
+	 * @brief	Constructor for users of local pool data.
+	 * @details
+	 * @param sid Unique identifier of dataset consisting of object ID and
+	 * set ID.
+	 * @param registeredVariablesArray
+	 * @param maxNumberOfVariables
+	 */
+	LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
+	        const size_t maxNumberOfVariables);
+
+	/**
+	 * @brief	The destructor automatically manages writing the valid
+	 * 			information of variables.
+	 * @details
+	 * In case the data set was read out, but not committed(indicated by state),
+	 * the destructor parses all variables that are still registered to the set.
+	 * For each, the valid flag in the data pool is set to "invalid".
+	 */
+	~LocalPoolDataSetBase();
+
+	void setValidityBufferGeneration(bool withValidityBuffer);
+
+	sid_t getSid() const;
+
+	/** SerializeIF overrides */
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+	            SerializeIF::Endianness streamEndianness) const override;
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
+	        SerializeIF::Endianness streamEndianness) override;
+	size_t getSerializedSize() const override;
+
+	/**
+	 * Special version of the serilization function which appends a
+	 * validity buffer at the end. Each bit of this validity buffer
+	 * denotes whether the container data set entries are valid from left
+	 * to right, MSB first. (length = ceil(N/8), N = number of pool variables)
+	 * @param buffer
+	 * @param size
+	 * @param maxSize
+	 * @param bigEndian
+	 * @param withValidityBuffer
+	 * @return
+	 */
+	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
+	ReturnValue_t deSerializeWithValidityBuffer(const uint8_t** buffer,
+	        size_t *size, SerializeIF::Endianness streamEndianness);
+	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness,
+	        bool serializeFillCount = true) const;
+	uint8_t getLocalPoolIdsSerializedSize(bool serializeFillCount = true) const;
+
+	/**
+	 * Set the dataset valid or invalid
+	 * @param setEntriesRecursively
+	 * If this is true, all contained datasets will also be set recursively.
+	 */
+	void setValidity(bool valid, bool setEntriesRecursively);
+	bool isValid() const override;
+
+	void setChanged(bool changed);
+	bool isChanged() const;
+
+protected:
+	sid_t sid;
+
+	bool diagnostic = false;
+	void setDiagnostic(bool diagnostics);
+	bool isDiagnostics() const;
+
+	/**
+	 * Used for periodic generation.
+	 */
+	bool reportingEnabled = false;
+	void setReportingEnabled(bool enabled);
+	bool getReportingEnabled() const;
+
+	void initializePeriodicHelper(float collectionInterval,
+			dur_millis_t minimumPeriodicInterval,
+			bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5);
+
+	/**
+	 * If the valid state of a dataset is always relevant to the whole
+	 * data set we can use this flag.
+	 */
+	bool valid = false;
+
+	/**
+	 * Can be used to mark the dataset as changed, which is used
+	 * by the LocalDataPoolManager to send out update messages.
+	 */
+	bool changed = false;
+
+	/**
+	 * Specify whether the validity buffer is serialized too when serializing
+	 * or deserializing the packet. Each bit of the validity buffer will
+	 * contain the validity state of the pool variables from left to right.
+	 * The size of validity buffer thus will be ceil(N / 8) with N = number of
+	 * pool variables.
+	 */
+	bool withValidityBuffer = true;
+
+	/**
+	 * @brief	This is a small helper function to facilitate locking
+	 * 			the global data pool.
+	 * @details
+	 * It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
+	/**
+	 * @brief	This is a small helper function to facilitate
+	 * 			unlocking the global data pool
+	 * @details
+	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	ReturnValue_t unlockDataPool() override;
+
+	LocalDataPoolManager* hkManager;
+
+	/**
+	 * Set n-th bit of a byte, with n being the position from 0
+	 * (most significant bit) to 7 (least significant bit)
+	 */
+	void bitSetter(uint8_t* byte, uint8_t position) const;
+	bool bitGetter(const uint8_t* byte, uint8_t position) const;
+
+	PeriodicHousekeepingHelper* periodicHelper = nullptr;
+
+};
+
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
new file mode 100644
index 000000000..ec5c8cd19
--- /dev/null
+++ b/datapoollocal/LocalPoolVariable.h
@@ -0,0 +1,177 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+
+#include "HasLocalDataPoolIF.h"
+#include "LocalDataPoolManager.h"
+
+#include "../datapool/PoolVariableIF.h"
+#include "../datapool/DataSetIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerializeAdapter.h"
+
+/**
+ * @brief 	Local Pool Variable class which is used to access the local pools.
+ * @details
+ * This class is not stored in the map. Instead, it is used to access
+ * the pool entries by using a pointer to the map storing the pool
+ * entries. It can also be used to organize these pool entries into data sets.
+ *
+ * @tparam T The template parameter sets the type of the variable. Currently,
+ * all plain data types are supported, but in principle  any type is possible.
+ * @ingroup data_pool
+ */
+template<typename T>
+class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
+public:
+	//! Default ctor is forbidden.
+	LocalPoolVar() = delete;
+
+	/**
+	 * This constructor is used by the data creators to have pool variable
+	 * instances which can also be stored in datasets.
+	 *
+	 * It does not fetch the current value from the data pool, which
+	 * has to be done by calling the read() operation.
+	 * Datasets can be used to access multiple local pool entries in an
+	 * efficient way. A pointer to a dataset can be passed to register
+	 * the pool variable in that dataset directly.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 */
+	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+	/**
+	 * This constructor is used by data users like controllers to have
+	 * access to the local pool variables of data creators by supplying
+	 * the respective creator object ID.
+	 *
+	 * It does not fetch the current value from the data pool, which
+	 * has to be done by calling the read() operation.
+	 * Datasets can be used to access multiple local pool entries in an
+	 * efficient way. A pointer to a dataset can be passed to register
+	 * the pool variable in that dataset directly.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner object ID of the pool owner.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 *
+	 */
+	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+	virtual~ LocalPoolVar() {};
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a simple local variable.
+	 */
+	T value = 0;
+
+	pool_rwm_t getReadWriteMode() const override;
+
+	lp_id_t getDataPoolId() const override;
+	void setDataPoolId(lp_id_t poolId);
+
+	bool isValid() const override;
+	void setValid(bool validity) override;
+	uint8_t getValid() const;
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the data pool and copies all array values and the valid
+	 * information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 *
+	 */
+	ReturnValue_t read(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the local valid flag is written back as well.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+
+
+	LocalPoolVar<T> &operator=(T newValue);
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+	// std::ostream is the type for object std::cout
+	template <typename U>
+	friend std::ostream& operator<< (std::ostream &out,
+			const LocalPoolVar<U> &var);
+
+private:
+	//! @brief 	Pool ID of pool entry inside the used local pool.
+	lp_id_t localPoolId = PoolVariableIF::NO_PARAMETER;
+	//! @brief 	Read-write mode of the pool variable
+	pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
+	//! @brief 	Specifies whether the entry is valid or invalid.
+	bool valid = false;
+
+	//! Pointer to the class which manages the HK pool.
+	LocalDataPoolManager* hkManager;
+};
+
+#include "LocalPoolVariable.tpp"
+
+template<class T>
+using lp_var_t = LocalPoolVar<T>;
+
+using lp_bool_t = LocalPoolVar<uint8_t>;
+using lp_uint8_t = LocalPoolVar<uint8_t>;
+using lp_uint16_t = LocalPoolVar<uint16_t>;
+using lp_uint32_t = LocalPoolVar<uint32_t>;
+using lp_uint64_t = LocalPoolVar<uint64_t>;
+using lp_int8_t = LocalPoolVar<int8_t>;
+using lp_int16_t = LocalPoolVar<int16_t>;
+using lp_int32_t = LocalPoolVar<int32_t>;
+using lp_int64_t = LocalPoolVar<int64_t>;
+using lp_float_t = LocalPoolVar<float>;
+using lp_double_t = LocalPoolVar<double>;
+
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
new file mode 100644
index 000000000..b0bdd7b9e
--- /dev/null
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -0,0 +1,169 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
+
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
+#endif
+
+template<typename T>
+inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
+		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+		pool_rwm_t setReadWriteMode):
+		localPoolId(poolId), readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
+		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+		        << "which is the NO_PARAMETER value!" << std::endl;
+	}
+	if(hkOwner == nullptr) {
+		sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+		        << "owner is a invalid!" << std::endl;
+		return;
+	}
+	hkManager = hkOwner->getHkManagerHandle();
+	if(dataSet != nullptr) {
+	    dataSet->registerVariable(this);
+	}
+}
+
+template<typename T>
+inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        localPoolId(poolId), readWriteMode(setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
+    }
+    HasLocalDataPoolIF* hkOwner =
+            objectManager->get<HasLocalDataPoolIF>(poolOwner);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalPoolVariable: The supplied pool owner did not "
+                << "implement  the correct interface "
+                << "HasLocalDataPoolIF!" << std::endl;
+        return;
+	}
+	hkManager = hkOwner->getHkManagerHandle();
+	if(dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
+			lockTimeout);
+	return readWithoutLock();
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
+	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+		sif::debug << "LocalPoolVar: Invalid read write "
+				"mode for read() call." << std::endl;
+		return PoolVariableIF::INVALID_READ_WRITE_MODE;
+	}
+
+	PoolEntry<T>* poolEntry = nullptr;
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	if(result != RETURN_OK and poolEntry != nullptr) {
+		sif::error << "PoolVector: Read of local pool variable of object "
+				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
+				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
+				std::dec << " failed.\n" << std::flush;
+		return result;
+	}
+	this->value = *(poolEntry->address);
+	this->valid = poolEntry->valid;
+	return RETURN_OK;
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::commit(dur_millis_t lockTimeout) {
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
+			lockTimeout);
+	return commitWithoutLock();
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
+	if(readWriteMode == pool_rwm_t::VAR_READ) {
+		sif::debug << "LocalPoolVar: Invalid read write "
+				 "mode for commit() call." << std::endl;
+		return PoolVariableIF::INVALID_READ_WRITE_MODE;
+	}
+	PoolEntry<T>* poolEntry = nullptr;
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	if(result != RETURN_OK) {
+		sif::error << "PoolVector: Read of local pool variable of object "
+				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
+				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
+				std::dec << " failed.\n" << std::flush;
+		return result;
+	}
+	*(poolEntry->address) = this->value;
+	poolEntry->valid = this->valid;
+	return RETURN_OK;
+}
+
+template<typename T>
+inline LocalPoolVar<T> & LocalPoolVar<T>::operator =(T newValue) {
+    value = newValue;
+    return *this;
+}
+
+
+template<typename T>
+inline pool_rwm_t LocalPoolVar<T>::getReadWriteMode() const {
+	return readWriteMode;
+}
+
+template<typename T>
+inline lp_id_t LocalPoolVar<T>::getDataPoolId() const {
+	return localPoolId;
+}
+
+template<typename T>
+inline void LocalPoolVar<T>::setDataPoolId(lp_id_t poolId) {
+	this->localPoolId = poolId;
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::isValid() const {
+	return valid;
+}
+
+template<typename T>
+inline void LocalPoolVar<T>::setValid(bool validity) {
+	this->valid = validity;
+}
+
+template<typename T>
+inline uint8_t LocalPoolVar<T>::getValid() const {
+	return valid;
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
+	return SerializeAdapter::serialize(&value,
+			buffer, size ,max_size, streamEndianness);
+}
+
+template<typename T>
+inline size_t LocalPoolVar<T>::getSerializedSize() const {
+	return SerializeAdapter::getSerializedSize(&value);
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
+		size_t* size, SerializeIF::Endianness streamEndianness) {
+	return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+}
+
+template<typename T>
+inline std::ostream& operator<< (std::ostream &out,
+		const LocalPoolVar<T> &var) {
+    out << var.value;
+    return out;
+}
+
+#endif
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
new file mode 100644
index 000000000..57c4b90b4
--- /dev/null
+++ b/datapoollocal/LocalPoolVector.h
@@ -0,0 +1,202 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
+public:
+	LocalPoolVector() = delete;
+	/**
+	 * This constructor is used by the data creators to have pool variable
+	 * instances which can also be stored in datasets.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE
+			);
+
+	/**
+	 * This constructor is used by data users like controllers to have
+	 * access to the local pool variables of data creators by supplying
+	 * the respective creator object ID.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE
+			);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details
+	 * The user can work on this attribute just like he would on a local
+	 * array of this type.
+	 */
+	T value[vectorSize];
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~LocalPoolVector() {};
+	/**
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
+	 */
+	uint8_t getSize() {
+		return vectorSize;
+	}
+
+	uint32_t getDataPoolId() const override;
+	/**
+	 * @brief This operation sets the data pool ID of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	pool_rwm_t getReadWriteMode() const;
+
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+	void setValid(bool valid) override;
+	uint8_t getValid() const;
+
+	T& operator [](int i);
+	const T &operator [](int i) const;
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t maxSize,
+			SerializeIF::Endianness streamEndiannes) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the data pool and copies all array values and the valid
+	 * information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the local valid flag is written back as well.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t localPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	bool valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+	//! @brief	Pointer to the class which manages the HK pool.
+	LocalDataPoolManager* hkManager;
+
+	// std::ostream is the type for object std::cout
+	template <typename U, uint16_t otherSize>
+	friend std::ostream& operator<< (std::ostream &out,
+	        const LocalPoolVector<U, otherSize> &var);
+
+
+};
+
+#include "LocalPoolVector.tpp"
+
+template<typename T, uint16_t vectorSize>
+using lp_vec_t = LocalPoolVector<T, vectorSize>;
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
new file mode 100644
index 000000000..2aa6fbb5f
--- /dev/null
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -0,0 +1,209 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#error Include LocalPoolVector.h before LocalPoolVector.tpp!
+#endif
+
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
+		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+		pool_rwm_t setReadWriteMode):
+		localPoolId(poolId), valid(false), readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
+		sif::warning << "LocalPoolVector: PoolVariableIF::NO_PARAMETER passed "
+				<< "as pool ID, which is the NO_PARAMETER value!" << std::endl;
+	}
+	std::memset(this->value, 0, vectorSize * sizeof(T));
+	hkManager = hkOwner->getHkManagerHandle();
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
+		object_id_t poolOwner, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+		readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
+		sif::warning << "LocalPoolVector: PoolVariableIF::NO_PARAMETER passed "
+				<< "as pool ID, which is the NO_PARAMETER value!" << std::endl;
+	}
+	HasLocalDataPoolIF* hkOwner =
+			objectManager->get<HasLocalDataPoolIF>(poolOwner);
+	if(hkOwner == nullptr) {
+		sif::error << "LocalPoolVariable: The supplied pool owner did not "
+				<< "implement the correct interface HasHkPoolParametersIF!"
+				<< std::endl;
+		return;
+	}
+	hkManager = hkOwner->getHkManagerHandle();
+	if(dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
+			lockTimeout);
+	return readWithoutLock();
+}
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
+	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+		sif::debug << "LocalPoolVar: Invalid read write "
+				"mode for read() call." << std::endl;
+		return PoolVariableIF::INVALID_READ_WRITE_MODE;
+	}
+
+	PoolEntry<T>* poolEntry = nullptr;
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	memset(this->value, 0, vectorSize * sizeof(T));
+
+	if(result != RETURN_OK) {
+		sif::error << "PoolVector: Read of local pool variable of object "
+				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
+				hkManager->getOwner() << "and lp ID 0x" << localPoolId <<
+				std::dec << " failed." << std::endl;
+		return result;
+	}
+	std::memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
+	this->valid = poolEntry->valid;
+	return RETURN_OK;
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
+		uint32_t lockTimeout) {
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
+			lockTimeout);
+	return commitWithoutLock();
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
+	if(readWriteMode == pool_rwm_t::VAR_READ) {
+		sif::debug << "LocalPoolVar: Invalid read write "
+				"mode for commit() call." << std::endl;
+		return PoolVariableIF::INVALID_READ_WRITE_MODE;
+	}
+	PoolEntry<T>* poolEntry = nullptr;
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	if(result != RETURN_OK) {
+		sif::error << "PoolVector: Read of local pool variable of object "
+				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
+				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
+				std::dec << " failed.\n" << std::flush;
+		return result;
+	}
+	std::memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
+	poolEntry->valid = this->valid;
+	return RETURN_OK;
+}
+
+template<typename T, uint16_t vectorSize>
+inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
+	if(i <= vectorSize) {
+		return value[i];
+	}
+	// If this happens, I have to set some value. I consider this
+	// a configuration error, but I wont exit here.
+	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+			" last value!" << std::endl;
+	return value[i];
+}
+
+template<typename T, uint16_t vectorSize>
+inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
+	if(i <= vectorSize) {
+		return value[i];
+	}
+	// If this happens, I have to set some value. I consider this
+	// a configuration error, but I wont exit here.
+	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+			" last value!" << std::endl;
+	return value[i];
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize,
+		SerializeIF::Endianness streamEndianness) const {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t i = 0; i < vectorSize; i++) {
+		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
+	return vectorSize * SerializeAdapter::getSerializedSize(value);
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
+		const uint8_t** buffer, size_t* size,
+		SerializeIF::Endianness streamEndianness) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t i = 0; i < vectorSize; i++) {
+		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline pool_rwm_t LocalPoolVector<T, vectorSize>::getReadWriteMode() const {
+	return this->readWriteMode;
+}
+
+
+template<typename T, uint16_t vectorSize>
+inline uint32_t LocalPoolVector<T, vectorSize>::getDataPoolId() const {
+	return localPoolId;
+}
+
+template<typename T, uint16_t vectorSize>
+inline void LocalPoolVector<T, vectorSize>::setDataPoolId(uint32_t poolId) {
+	this->localPoolId = poolId;
+}
+
+template<typename T, uint16_t vectorSize>
+inline void LocalPoolVector<T, vectorSize>::setValid(bool valid) {
+	this->valid = valid;
+}
+
+template<typename T, uint16_t vectorSize>
+inline uint8_t LocalPoolVector<T, vectorSize>::getValid() const {
+	return valid;
+}
+
+template<typename T, uint16_t vectorSize>
+inline bool LocalPoolVector<T, vectorSize>::isValid() const {
+	return valid;
+}
+
+template<typename T, uint16_t vectorSize>
+inline std::ostream& operator<< (std::ostream &out,
+        const LocalPoolVector<T, vectorSize> &var) {
+    out << "Vector: [";
+    for(int i = 0;i < vectorSize; i++) {
+        out << var.value[i];
+        if(i < vectorSize - 1) {
+            out << ", ";
+        }
+    }
+    out << "]";
+    return out;
+}
+
+#endif
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
new file mode 100644
index 000000000..dd1bdcc40
--- /dev/null
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -0,0 +1,16 @@
+#include "SharedLocalDataSet.h"
+
+SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
+        const size_t maxSize): SystemObject(objectId),
+        LocalPoolDataSetBase(sid, nullptr, maxSize) {
+    this->setContainer(poolVarVector.data());
+    datasetLock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
+    return datasetLock->lockMutex(MutexIF::TimeoutType::WAITING, mutexTimeout);
+}
+
+ReturnValue_t SharedLocalDataSet::unlockDataset() {
+    return datasetLock->unlockMutex();
+}
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
new file mode 100644
index 000000000..2e5a76fa9
--- /dev/null
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -0,0 +1,24 @@
+#ifndef FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+#define FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+
+#include "LocalPoolDataSetBase.h"
+#include "../datapool/SharedDataSetIF.h"
+#include "../objectmanager/SystemObject.h"
+#include <vector>
+
+class SharedLocalDataSet: public SystemObject,
+        public LocalPoolDataSetBase,
+        public SharedDataSetIF {
+public:
+    SharedLocalDataSet(object_id_t objectId, sid_t sid,
+            const size_t maxSize);
+    ReturnValue_t lockDataset(dur_millis_t mutexTimeout) override;
+    ReturnValue_t unlockDataset() override;
+private:
+
+    MutexIF* datasetLock = nullptr;
+    std::vector<PoolVariableIF*> poolVarVector;
+};
+
+
+#endif /* FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_ */
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
new file mode 100644
index 000000000..a637e360f
--- /dev/null
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -0,0 +1,50 @@
+#ifndef FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#define FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+
+#include "LocalPoolDataSetBase.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include <array>
+
+/**
+ * @brief   This local dataset type is created on the stack.
+ * @details
+ * This will is the primary data structure to organize pool variables into
+ * sets which can be accessed via the housekeeping service interface or
+ * which can be sent to other software objects.
+ *
+ * It is recommended to read the documentation of the LocalPoolDataSetBase
+ * class for more information on how this class works and how to use it.
+ * @tparam capacity Capacity of the static dataset, which is usually known
+ * beforehand.
+ */
+template <uint8_t NUM_VARIABLES>
+class StaticLocalDataSet: public LocalPoolDataSetBase {
+public:
+	/**
+	 * Constructor used by data owner and creator like device handlers.
+	 * This constructor also initialized the components required for
+	 * periodic handling.
+	 * @param hkOwner
+	 * @param setId
+	 */
+    StaticLocalDataSet(HasLocalDataPoolIF* hkOwner,
+    		uint32_t setId): LocalPoolDataSetBase(hkOwner, setId, nullptr,
+            NUM_VARIABLES) {
+        this->setContainer(poolVarList.data());
+    }
+
+	/**
+	 * Constructor used by data users like controllers.
+	 * @param hkOwner
+	 * @param setId
+	 */
+    StaticLocalDataSet(sid_t sid): LocalPoolDataSetBase(sid, nullptr,
+            NUM_VARIABLES) {
+        this->setContainer(poolVarList.data());
+    }
+
+private:
+    std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList;
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */
diff --git a/housekeeping/AcceptsHkPacketsIF.h b/housekeeping/AcceptsHkPacketsIF.h
new file mode 100644
index 000000000..b3ba6e7c0
--- /dev/null
+++ b/housekeeping/AcceptsHkPacketsIF.h
@@ -0,0 +1,11 @@
+#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#include "../ipc/MessageQueueMessageIF.h"
+
+class AcceptsHkPacketsIF {
+public:
+    virtual~ AcceptsHkPacketsIF() {};
+    virtual MessageQueueId_t getHkQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
new file mode 100644
index 000000000..d2ab546b0
--- /dev/null
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -0,0 +1,162 @@
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include "HousekeepingMessage.h"
+#include <cstring>
+
+HousekeepingMessage::~HousekeepingMessage() {}
+
+void HousekeepingMessage::setHkReportReply(CommandMessage* message, sid_t sid,
+		store_address_t storeId) {
+	message->setCommand(HK_REPORT);
+	message->setMessageSize(HK_MESSAGE_SIZE);
+	setSid(message, sid);
+	message->setParameter3(storeId.raw);
+}
+
+void HousekeepingMessage::setHkDiagnosticsReply(CommandMessage* message,
+		sid_t sid, store_address_t storeId) {
+	message->setCommand(DIAGNOSTICS_REPORT);
+	message->setMessageSize(HK_MESSAGE_SIZE);
+	setSid(message, sid);
+	message->setParameter3(storeId.raw);
+}
+
+sid_t HousekeepingMessage::getHkDataReply(const CommandMessage *message,
+		store_address_t *storeIdToSet) {
+	if(storeIdToSet != nullptr) {
+	    *storeIdToSet = message->getParameter3();
+	}
+	return getSid(message);
+}
+
+void HousekeepingMessage::setToggleReportingCommand(CommandMessage *message,
+		sid_t sid, bool enableReporting, bool isDiagnostics) {
+	if(isDiagnostics) {
+		if(enableReporting) {
+			message->setCommand(ENABLE_PERIODIC_DIAGNOSTICS_GENERATION);
+		}
+		else {
+			message->setCommand(DISABLE_PERIODIC_DIAGNOSTICS_GENERATION);
+		}
+	}
+	else {
+		if(enableReporting) {
+			message->setCommand(ENABLE_PERIODIC_HK_REPORT_GENERATION);
+		}
+		else {
+			message->setCommand(DISABLE_PERIODIC_HK_REPORT_GENERATION);
+		}
+	}
+
+	setSid(message, sid);
+}
+
+void HousekeepingMessage::setStructureReportingCommand(CommandMessage *command,
+		sid_t sid, bool isDiagnostics) {
+	if(isDiagnostics) {
+		command->setCommand(REPORT_DIAGNOSTICS_REPORT_STRUCTURES);
+	}
+	else {
+		command->setCommand(REPORT_HK_REPORT_STRUCTURES);
+	}
+
+	setSid(command, sid);
+}
+
+void HousekeepingMessage::setOneShotReportCommand(CommandMessage *command,
+		sid_t sid, bool isDiagnostics) {
+	if(isDiagnostics) {
+		command->setCommand(GENERATE_ONE_DIAGNOSTICS_REPORT);
+	}
+	else {
+		command->setCommand(GENERATE_ONE_PARAMETER_REPORT);
+	}
+
+	setSid(command, sid);
+}
+
+void HousekeepingMessage::setCollectionIntervalModificationCommand(
+		CommandMessage *command, sid_t sid, float collectionInterval,
+		bool isDiagnostics) {
+	if(isDiagnostics) {
+		command->setCommand(MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL);
+	}
+	else {
+		command->setCommand(MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL);
+	}
+	command->setParameter3(collectionInterval);
+
+	setSid(command, sid);
+}
+
+sid_t HousekeepingMessage::getCollectionIntervalModificationCommand(
+		const CommandMessage* command, float* newCollectionInterval) {
+	if(newCollectionInterval != nullptr) {
+		*newCollectionInterval = command->getParameter3();
+	}
+
+	return getSid(command);
+}
+
+void HousekeepingMessage::setHkRequestSuccessReply(CommandMessage *reply,
+		sid_t sid) {
+	setSid(reply, sid);
+	reply->setCommand(HK_REQUEST_SUCCESS);
+}
+
+void HousekeepingMessage::setHkRequestFailureReply(CommandMessage *reply,
+		sid_t sid, ReturnValue_t error) {
+	setSid(reply, sid);
+	reply->setCommand(HK_REQUEST_FAILURE);
+	reply->setParameter3(error);
+}
+
+sid_t HousekeepingMessage::getHkRequestFailureReply(const CommandMessage *reply,
+		ReturnValue_t *error) {
+	if(error != nullptr) {
+		*error = reply->getParameter3();
+	}
+	return getSid(reply);
+}
+
+sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
+	sid_t sid;
+	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
+	return sid;
+}
+
+void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
+	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
+}
+
+void HousekeepingMessage::setHkStuctureReportReply(CommandMessage *reply,
+        sid_t sid, store_address_t storeId) {
+    reply->setCommand(HK_DEFINITIONS_REPORT);
+    setSid(reply, sid);
+    reply->setParameter3(storeId.raw);
+}
+
+void HousekeepingMessage::setDiagnosticsStuctureReportReply(
+        CommandMessage *reply, sid_t sid, store_address_t storeId) {
+    reply->setCommand(DIAGNOSTICS_DEFINITION_REPORT);
+    setSid(reply, sid);
+    reply->setParameter3(storeId.raw);
+}
+
+void HousekeepingMessage::clear(CommandMessage* message) {
+    switch(message->getCommand()) {
+    case(HK_REPORT):
+    case(DIAGNOSTICS_REPORT):
+    case(HK_DEFINITIONS_REPORT):
+    case(DIAGNOSTICS_DEFINITION_REPORT):
+    case(UPDATE_SNAPSHOT): {
+        store_address_t storeId;
+        getHkDataReply(message, &storeId);
+        StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+                objects::IPC_STORE);
+        if (ipcStore != nullptr) {
+            ipcStore->deleteData(storeId);
+        }
+    }
+    }
+    message->setCommand(CommandMessage::CMD_NONE);
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
new file mode 100644
index 000000000..6dc95f542
--- /dev/null
+++ b/housekeeping/HousekeepingMessage.h
@@ -0,0 +1,157 @@
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../ipc/FwMessageTypes.h"
+#include "../objectmanager/frameworkObjects.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+union sid_t {
+	static constexpr uint64_t INVALID_SID = -1;
+	static constexpr uint32_t INVALID_SET_ID = -1;
+	static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+	sid_t(): raw(INVALID_SID) {}
+
+	sid_t(object_id_t objectId, uint32_t setId):
+			objectId(objectId),
+			ownerSetId(setId) {}
+
+	struct {
+		object_id_t objectId ;
+		/**
+		 * A generic 32 bit ID to identify unique HK packets for a single
+		 * object. For example, the DeviceCommandId_t is used for
+		 * DeviceHandlers
+		 */
+		uint32_t ownerSetId;
+	};
+	/**
+	 * Alternative access to the raw value. This is also the size of the type.
+	 */
+	uint64_t raw;
+
+	bool notSet() const {
+	    return raw == INVALID_SID;
+	}
+
+	bool operator==(const sid_t& other) const {
+		return raw == other.raw;
+	}
+
+	bool operator!=(const sid_t& other) const {
+		return not (raw == other.raw);
+	}
+};
+
+
+/**
+ * @brief	Special command message type for housekeeping messages
+ * @details
+ * This message is slightly larger than regular command messages to accomodate
+ * the uint64_t structure ID (SID).
+ */
+class HousekeepingMessage {
+public:
+
+	static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
+	        sizeof(sid_t) + sizeof(uint32_t);
+
+	/**
+	 * Concrete instance is not used, instead this class operates on
+	 * command message instances.
+	 */
+	HousekeepingMessage() = delete;
+	virtual ~HousekeepingMessage();
+
+	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
+
+	static constexpr Command_t ENABLE_PERIODIC_HK_REPORT_GENERATION =
+			MAKE_COMMAND_ID(5);
+	static constexpr Command_t DISABLE_PERIODIC_HK_REPORT_GENERATION =
+			MAKE_COMMAND_ID(6);
+
+	static constexpr Command_t ENABLE_PERIODIC_DIAGNOSTICS_GENERATION =
+			MAKE_COMMAND_ID(7);
+	static constexpr Command_t DISABLE_PERIODIC_DIAGNOSTICS_GENERATION =
+			MAKE_COMMAND_ID(8);
+
+	static constexpr Command_t REPORT_HK_REPORT_STRUCTURES = MAKE_COMMAND_ID(9);
+	static constexpr Command_t REPORT_DIAGNOSTICS_REPORT_STRUCTURES =
+			MAKE_COMMAND_ID(11);
+
+	static constexpr Command_t HK_DEFINITIONS_REPORT = MAKE_COMMAND_ID(10);
+	static constexpr Command_t DIAGNOSTICS_DEFINITION_REPORT = MAKE_COMMAND_ID(12);
+
+	static constexpr Command_t HK_REPORT = MAKE_COMMAND_ID(25);
+	static constexpr Command_t DIAGNOSTICS_REPORT = MAKE_COMMAND_ID(26);
+
+	static constexpr Command_t GENERATE_ONE_PARAMETER_REPORT  =
+			MAKE_COMMAND_ID(27);
+	static constexpr Command_t GENERATE_ONE_DIAGNOSTICS_REPORT =
+			MAKE_COMMAND_ID(28);
+
+	static constexpr Command_t MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL =
+			MAKE_COMMAND_ID(31);
+	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
+			MAKE_COMMAND_ID(32);
+
+	static constexpr Command_t HK_REQUEST_SUCCESS =
+			MAKE_COMMAND_ID(128);
+	static constexpr Command_t HK_REQUEST_FAILURE =
+			MAKE_COMMAND_ID(129);
+
+	static constexpr Command_t UPDATE_NOTIFICATION = MAKE_COMMAND_ID(130);
+	static constexpr Command_t UPDATE_SNAPSHOT = MAKE_COMMAND_ID(131);
+
+	static constexpr Command_t UPDATE_HK_REPORT = MAKE_COMMAND_ID(132);
+
+	static sid_t getSid(const CommandMessage* message);
+
+	/** Setter functions */
+	static void setToggleReportingCommand(CommandMessage* command, sid_t sid,
+			bool enableReporting, bool isDiagnostics);
+	static void setStructureReportingCommand(CommandMessage* command, sid_t sid,
+			bool isDiagnostics);
+	static void setOneShotReportCommand(CommandMessage* command, sid_t sid,
+			bool isDiagnostics);
+	static void setCollectionIntervalModificationCommand(
+			CommandMessage* command, sid_t sid, float collectionInterval,
+			bool isDiagnostics);
+
+	static void setHkReportReply(CommandMessage* reply, sid_t sid,
+			store_address_t storeId);
+	static void setHkDiagnosticsReply(CommandMessage* reply, sid_t sid,
+			store_address_t storeId);
+
+	static void setHkRequestSuccessReply(CommandMessage* reply, sid_t sid);
+	static void setHkRequestFailureReply(CommandMessage* reply, sid_t sid,
+			ReturnValue_t error);
+
+	static void setHkStuctureReportReply(CommandMessage* reply,
+	        sid_t sid, store_address_t storeId);
+	static void setDiagnosticsStuctureReportReply(CommandMessage* reply,
+	            sid_t sid, store_address_t storeId);
+
+	static sid_t getHkRequestFailureReply(const CommandMessage* reply,
+			ReturnValue_t* error);
+
+	/**
+	 * @brief	Generic getter function for housekeeping data replies
+	 * @details
+	 * Command ID can be used beforehand to distinguish between diagnostics and
+	 * regular HK packets. This getter function should be used for the
+	 * command IDs 10, 12, 25 and 26.
+	 */
+	static sid_t getHkDataReply(const CommandMessage* message,
+			store_address_t * storeIdToSet);
+	static sid_t getCollectionIntervalModificationCommand(
+			const CommandMessage* command, float* newCollectionInterval);
+
+	static void clear(CommandMessage* message);
+private:
+	static void setSid(CommandMessage* message, sid_t sid);
+};
+
+
+#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_ */
diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
new file mode 100644
index 000000000..ae0cc988d
--- /dev/null
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -0,0 +1,34 @@
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+
+#include "../datapoollocal/LocalPoolDataSetBase.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+/**
+ * @brief   This class will be used to serialize general housekeeping packets
+ *          which are destined to be downlinked into the store.
+ * @details
+ * The housekeeping packets are stored into the IPC store and forwarded
+ * to the designated housekeeping handler.
+ */
+class HousekeepingPacketDownlink: public SerialLinkedListAdapter<SerializeIF> {
+public:
+    HousekeepingPacketDownlink(sid_t sid, LocalPoolDataSetBase* dataSetPtr):
+            sourceId(sid.objectId), setId(sid.ownerSetId), hkData(dataSetPtr) {
+        setLinks();
+    }
+
+private:
+    void setLinks() {
+        setStart(&sourceId);
+        sourceId.setNext(&setId);
+        setId.setNext(&hkData);
+    }
+
+    SerializeElement<object_id_t> sourceId;
+    SerializeElement<uint32_t> setId;
+    LinkedElement<SerializeIF> hkData;
+};
+
+#endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_ */
diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
new file mode 100644
index 000000000..eebdc11cc
--- /dev/null
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -0,0 +1,73 @@
+#ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
+#define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
+
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../datapoollocal/LocalPoolDataSetBase.h"
+
+/**
+ * @brief   This helper class will be used to serialize and deserialize
+ *          update housekeeping packets into the store.
+ */
+class HousekeepingPacketUpdate: public SerializeIF {
+public:
+    /**
+     * @param timeStamp
+     * @param timeStampSize
+     * @param hkData
+     * @param hkDataSize
+     */
+    HousekeepingPacketUpdate(uint8_t* timeStamp, size_t timeStampSize,
+            LocalPoolDataSetBase* dataSetPtr):
+            timeStamp(timeStamp), timeStampSize(timeStampSize),
+            dataSetPtr(dataSetPtr) {};
+
+    virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+            size_t maxSize, Endianness streamEndianness) const {
+        if(timeStamp != nullptr) {
+            /* Endianness will always be MACHINE, so we can simply use memcpy
+            here. */
+            std::memcpy(*buffer, timeStamp, timeStampSize);
+            *size += timeStampSize;
+            *buffer += timeStampSize;
+        }
+        if(dataSetPtr == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+
+        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
+    }
+
+    virtual size_t getSerializedSize() const {
+        if(dataSetPtr == nullptr) {
+            return 0;
+        }
+        return timeStampSize + dataSetPtr->getSerializedSize();
+    }
+
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            SerializeIF::Endianness streamEndianness) override {
+        if(timeStamp != nullptr) {
+            /* Endianness will always be MACHINE, so we can simply use memcpy
+            here. */
+            std::memcpy(timeStamp, *buffer, timeStampSize);
+            *size += timeStampSize;
+            *buffer += timeStampSize;
+        }
+
+        if(dataSetPtr == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        return dataSetPtr->deSerialize(buffer, size, streamEndianness);
+    }
+
+private:
+   uint8_t* timeStamp;
+   size_t timeStampSize;
+
+   LocalPoolDataSetBase* dataSetPtr = nullptr;
+};
+
+
+
+#endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_ */
diff --git a/housekeeping/HousekeepingSetPacket.h b/housekeeping/HousekeepingSetPacket.h
new file mode 100644
index 000000000..f94720d4c
--- /dev/null
+++ b/housekeeping/HousekeepingSetPacket.h
@@ -0,0 +1,59 @@
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_
+
+#include "../housekeeping/HousekeepingMessage.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../datapoollocal/LocalPoolDataSetBase.h"
+
+class HousekeepingSetPacket: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	HousekeepingSetPacket(sid_t sid, bool reportingEnabled, bool valid,
+			float collectionInterval, LocalPoolDataSetBase* dataSetPtr):
+			objectId(sid.objectId), setId(sid.ownerSetId),
+			reportingEnabled(reportingEnabled), valid(valid),
+			collectionIntervalSeconds(collectionInterval), dataSet(dataSetPtr) {
+	    setLinks();
+	}
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const override {
+		ReturnValue_t result = SerialLinkedListAdapter::serialize(buffer, size,
+				maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return dataSet->serializeLocalPoolIds(buffer, size ,maxSize,
+				streamEndianness);
+	}
+
+	size_t getSerializedSize() const override {
+		size_t linkedSize = SerialLinkedListAdapter::getSerializedSize();
+		linkedSize += dataSet->getLocalPoolIdsSerializedSize();
+		return linkedSize;
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+private:
+
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&setId);
+		setId.setNext(&reportingEnabled);
+		reportingEnabled.setNext(&valid);
+		valid.setNext(&collectionIntervalSeconds);
+		collectionIntervalSeconds.setEnd();
+	}
+
+	SerializeElement<object_id_t> objectId;
+	SerializeElement<uint32_t> setId;
+	SerializeElement<bool> reportingEnabled;
+	SerializeElement<bool> valid;
+	SerializeElement<float> collectionIntervalSeconds;
+	LocalPoolDataSetBase* dataSet;
+};
+
+#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_ */
diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
new file mode 100644
index 000000000..37349f815
--- /dev/null
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -0,0 +1,48 @@
+#include "../datapoollocal/LocalPoolDataSetBase.h"
+#include "PeriodicHousekeepingHelper.h"
+#include <cmath>
+
+PeriodicHousekeepingHelper::PeriodicHousekeepingHelper(
+		LocalPoolDataSetBase* owner): owner(owner) {}
+
+
+void PeriodicHousekeepingHelper::initialize(float collectionInterval,
+		dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
+		uint8_t nonDiagIntervalFactor) {
+	this->minimumPeriodicInterval = minimumPeriodicInterval;
+	if(not isDiagnostics) {
+		this->minimumPeriodicInterval = this->minimumPeriodicInterval *
+				nonDiagIntervalFactor;
+	}
+	collectionIntervalTicks = intervalSecondsToInterval(collectionInterval);
+}
+
+float PeriodicHousekeepingHelper::getCollectionIntervalInSeconds() {
+	return intervalToIntervalSeconds(collectionIntervalTicks);
+}
+
+bool PeriodicHousekeepingHelper::checkOpNecessary() {
+	if(internalTickCounter >= collectionIntervalTicks) {
+		internalTickCounter = 1;
+		return true;
+	}
+	internalTickCounter++;
+	return false;
+}
+
+uint32_t PeriodicHousekeepingHelper::intervalSecondsToInterval(
+		float collectionIntervalSeconds) {
+        return std::ceil(collectionIntervalSeconds * 1000
+                / minimumPeriodicInterval);
+}
+
+float PeriodicHousekeepingHelper::intervalToIntervalSeconds(
+		uint32_t collectionInterval) {
+	return static_cast<float>(collectionInterval *
+			minimumPeriodicInterval);
+}
+
+void PeriodicHousekeepingHelper::changeCollectionInterval(
+		float newIntervalSeconds) {
+	collectionIntervalTicks = intervalSecondsToInterval(newIntervalSeconds);
+}
diff --git a/housekeeping/PeriodicHousekeepingHelper.h b/housekeeping/PeriodicHousekeepingHelper.h
new file mode 100644
index 000000000..d96eae1d4
--- /dev/null
+++ b/housekeeping/PeriodicHousekeepingHelper.h
@@ -0,0 +1,32 @@
+#ifndef FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_
+#define FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_
+
+#include "../timemanager/Clock.h"
+#include <cstdint>
+
+class LocalPoolDataSetBase;
+
+class PeriodicHousekeepingHelper {
+public:
+	PeriodicHousekeepingHelper(LocalPoolDataSetBase* owner);
+
+	void initialize(float collectionInterval,
+			dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
+			uint8_t nonDiagIntervalFactor);
+
+	void changeCollectionInterval(float newInterval);
+	float getCollectionIntervalInSeconds();
+	bool checkOpNecessary();
+private:
+	LocalPoolDataSetBase* owner = nullptr;
+
+	uint32_t intervalSecondsToInterval(float collectionIntervalSeconds);
+	float intervalToIntervalSeconds(uint32_t collectionInterval);
+
+	dur_millis_t minimumPeriodicInterval = 0;
+	uint32_t internalTickCounter = 1;
+	uint32_t collectionIntervalTicks = 0;
+
+};
+
+#endif /* FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_ */

From a43e8ea60333627ca085b54c127f0b0acdddd601 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 12:27:28 +0200
Subject: [PATCH 0854/1774] added srv3 object ID

---
 objectmanager/frameworkObjects.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 4d08f0847..57783286a 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -6,6 +6,7 @@ enum framework_objects {
 	// Default verification reporter.
 	PUS_SERVICE_1_VERIFICATION = 0x53000001,
 	PUS_SERVICE_2_DEVICE_ACCESS = 0x53000002,
+	PUS_SERVICE_3_HOUSEKEEPING = 0x53000003,
 	PUS_SERVICE_5_EVENT_REPORTING = 0x53000005,
 	PUS_SERVICE_8_FUNCTION_MGMT = 0x53000008,
 	PUS_SERVICE_9_TIME_MGMT = 0x53000009,

From 322ff54f58d1ce3c214e1b240f418d543e93a320 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 12:28:25 +0200
Subject: [PATCH 0855/1774] added new message types

---
 ipc/FwMessageTypes.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/ipc/FwMessageTypes.h b/ipc/FwMessageTypes.h
index e820b1dfc..8b49c1222 100644
--- a/ipc/FwMessageTypes.h
+++ b/ipc/FwMessageTypes.h
@@ -3,7 +3,7 @@
 
 namespace messagetypes {
 //Remember to add new Message Types to the clearCommandMessage function!
-enum FW_MESSAGE_TYPE {
+enum FsfwMessageTypes {
 	COMMAND = 0,
 	MODE_COMMAND,
 	HEALTH_COMMAND,
@@ -14,7 +14,10 @@ enum FW_MESSAGE_TYPE {
 	MONITORING,
 	MEMORY,
 	PARAMETER,
-	FW_MESSAGES_COUNT
+	FILE_SYSTEM_MESSAGE,
+	HOUSEKEEPING,
+
+	FW_MESSAGES_COUNT,
 };
 }
 

From 196cde4075e92bd1053c136720acb3a3c6cd62f2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 12:30:53 +0200
Subject: [PATCH 0856/1774] DHB update

---
 devicehandlers/DeviceHandlerBase.cpp | 171 +++++++++++++++++++--------
 devicehandlers/DeviceHandlerBase.h   | 170 ++++++++++++++------------
 2 files changed, 214 insertions(+), 127 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 6fcba64bc..227d5b6dc 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -2,15 +2,17 @@
 #include "AcceptsDeviceResponsesIF.h"
 #include "DeviceTmReportingWrapper.h"
 
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../globalfunctions/CRC.h"
-#include "../subsystem/SubsystemBase.h"
+#include "../housekeeping/HousekeepingMessage.h"
+#include "../ipc/MessageQueueMessage.h"
 #include "../ipc/QueueFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../subsystem/SubsystemBase.h"
 
 #include <iomanip>
 
@@ -25,10 +27,11 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		actionHelper(this, nullptr), childTransitionFailure(RETURN_OK),
-		fdirInstance(fdirInstance), hkSwitcher(this),
-		defaultFDIRUsed(fdirInstance == nullptr), switchOffWasReported(false),
-		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		actionHelper(this, nullptr), hkManager(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,
 			MessageQueueMessage::MAX_MESSAGE_SIZE);
@@ -48,6 +51,10 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 	}
 }
 
+void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
+	this->hkDestination = hkDestination;
+}
+
 void DeviceHandlerBase::setThermalStateRequestPoolIds(
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId) {
 	this->deviceThermalRequestPoolId = thermalStatePoolId;
@@ -74,6 +81,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		decrementDeviceReplyMap();
 		fdirInstance->checkForFailures();
 		hkSwitcher.performOperation();
+		hkManager.performHkOperation();
 		performOperationHook();
 	}
 	if (mode == MODE_OFF) {
@@ -120,7 +128,9 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
-		return result;
+	    sif::error << "DeviceHandlerBase::initialize: Initializing "
+	            "communication interface failed!" << std::endl;
+	    return result;
 	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
@@ -183,11 +193,16 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
+	result = hkManager.initialize(commandQueue);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
 	fillCommandAndReplyMap();
 
 	//Set temperature target state to NON_OP.
 	GlobDataSet mySet;
-	gp_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+	gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 			PoolVariableIF::VAR_WRITE);
 	mySet.read();
 	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
@@ -245,10 +260,10 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-//	result = hkManager.handleHousekeepingMessage(&command);
-//	if (result == RETURN_OK) {
-//		return;
-//	}
+	result = hkManager.handleHousekeepingMessage(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
 
 	result = handleDeviceHandlerMessage(&command);
 	if (result == RETURN_OK) {
@@ -376,24 +391,28 @@ 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) {
+		LocalPoolDataSetBase* replyDataSet, 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) {
-		return insertInReplyMap(replyId, maxDelayCycles, replyLen, periodic);
+		return insertInReplyMap(replyId, maxDelayCycles,
+		        replyDataSet, replyLen, periodic);
 	} else {
-		return insertInReplyMap(deviceCommand, maxDelayCycles, replyLen, periodic);
+		return insertInReplyMap(deviceCommand, maxDelayCycles,
+		        replyDataSet, replyLen, periodic);
 	}
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, size_t replyLen, bool periodic) {
+		uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet,
+		size_t replyLen, bool periodic) {
 	DeviceReplyInfo info;
 	info.maxDelayCycles = maxDelayCycles;
 	info.periodic = periodic;
 	info.delayCycles = 0;
 	info.replyLen = replyLen;
+	info.dataSet = dataSet;
 	info.command = deviceCommandMap.end();
 	auto resultPair = deviceReplyMap.emplace(replyId, info);
 	if (resultPair.second) {
@@ -419,13 +438,12 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(
 
 ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
 		uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
-	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
-			deviceReplyMap.find(deviceReply);
-	if (iter == deviceReplyMap.end()) {
+	auto replyIter = deviceReplyMap.find(deviceReply);
+	if (replyIter == deviceReplyMap.end()) {
 		triggerEvent(INVALID_DEVICE_COMMAND, deviceReply);
 		return RETURN_FAILED;
 	} else {
-		DeviceReplyInfo *info = &(iter->second);
+		DeviceReplyInfo *info = &(replyIter->second);
 		if (maxDelayCycles != 0) {
 			info->maxDelayCycles = maxDelayCycles;
 		}
@@ -435,6 +453,17 @@ ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceRep
 	}
 }
 
+
+ReturnValue_t DeviceHandlerBase::setReplyDataset(DeviceCommandId_t replyId,
+        LocalPoolDataSetBase *dataSet) {
+    auto replyIter = deviceReplyMap.find(replyId);
+    if(replyIter == deviceReplyMap.end()) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    replyIter->second.dataSet = dataSet;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 void DeviceHandlerBase::callChildStatemachine() {
 	if (mode == _MODE_START_UP) {
 		doStartUp();
@@ -470,7 +499,7 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 
 	if (mode == MODE_OFF) {
 		GlobDataSet mySet;
-		gp_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ_WRITE);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -649,7 +678,7 @@ void DeviceHandlerBase::doGetRead() {
 void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		size_t receivedDataLen) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	DeviceCommandId_t foundId = 0xFFFFFFFF;
+	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
@@ -661,18 +690,26 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		switch (result) {
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
+			if(foundLen == 0) {
+			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+			            " Packet parsing will be stuck." << std::endl;
+			}
 			break;
 		case APERIODIC_REPLY: {
 			result = interpretDeviceReply(foundId, receivedData);
 			if (result != RETURN_OK) {
-				replyRawReplyIfnotWiretapped(receivedData, foundLen);
-				triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
-						foundId);
+			    replyRawReplyIfnotWiretapped(receivedData, foundLen);
+			    triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
+			            foundId);
+			}
+			if(foundLen == 0) {
+			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+			            " Packet parsing will be stuck." << std::endl;
 			}
-		}
-		break;
-		case IGNORE_REPLY_DATA:
 			break;
+		}
+		case IGNORE_REPLY_DATA:
+			continue;
 		case IGNORE_FULL_PACKET:
 			return;
 		default:
@@ -704,16 +741,19 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 	DeviceReplyInfo *info = &(iter->second);
 
 	if (info->delayCycles != 0) {
+	    result = interpretDeviceReply(foundId, receivedData);
 
-		if (info->periodic != false) {
+	    if(result == IGNORE_REPLY_DATA) {
+	        return;
+	    }
+
+		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);
@@ -927,9 +967,9 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
 	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
 			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)) {
 		GlobDataSet mySet;
-		gp_int8_t thermalState(deviceThermalStatePoolId, &mySet,
+		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
 				PoolVariableIF::VAR_READ);
-		gp_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -1089,19 +1129,6 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
-//		if (mode != MODE_OFF) {
-//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-//		} else {
-//			result = switchCookieChannel(
-//					DeviceHandlerMessage::getIoBoardObjectId(message));
-//			if (result == RETURN_OK) {
-//				replyReturnvalueToCommand(RETURN_OK);
-//			} else {
-//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
-//			}
-//		}
-//		return RETURN_OK;
 	case DeviceHandlerMessage::CMD_RAW:
 		if ((mode != MODE_RAW)) {
 			DeviceHandlerMessage::clear(message);
@@ -1248,10 +1275,14 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
+			//so we can track misconfigurations
 			sif::debug << std::hex << getObjectId()
 					<< ": DHB::buildInternalCommand: Command "
-					<< deviceCommandId << " isExecuting" << std::endl; //so we can track misconfigurations
-			return; //this is an internal command, no need to report a failure here, missed reply will track if a reply is too late, otherwise, it's ok
+					<< deviceCommandId << " isExecuting" << std::dec
+					<< std::endl;
+			// this is an internal command, no need to report a failure here,
+			// missed reply will track if a reply is too late, otherwise, it's ok
+			return;
 		} else {
 			iter->second.sendReplyTo = NO_COMMANDER;
 			iter->second.isExecuting = true;
@@ -1340,12 +1371,50 @@ void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
 void DeviceHandlerBase::performOperationHook() {
 }
 
+ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
+		LocalDataPool &localDataPoolMap,
+        LocalDataPoolManager& poolManager) {
+	return RETURN_OK;
+}
+
+LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
+	return &hkManager;
+}
+
+
 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();
     }
+    this->hkManager.initializeAfterTaskCreation();
+
+    if(setStartupImmediately) {
+        startTransition(MODE_ON, SUBMODE_NONE);
+    }
     return HasReturnvaluesIF::RETURN_OK;
 }
 
+LocalPoolDataSetBase* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
+	auto iter = deviceReplyMap.find(sid.ownerSetId);
+	if(iter != deviceReplyMap.end()) {
+		return iter->second.dataSet;
+	}
+	else {
+		return nullptr;
+	}
+}
+
+object_id_t DeviceHandlerBase::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+void DeviceHandlerBase::setStartUpImmediately() {
+    this->setStartupImmediately = true;
+}
+
+dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
+    return pstIntervalMs;
+}
+
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 5666f35ea..eda318cb8 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,12 +1,11 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
-#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#define FSFW_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 "../returnvalues/HasReturnvaluesIF.h"
 #include "../action/HasActionsIF.h"
@@ -14,10 +13,13 @@
 #include "../modes/HasModesIF.h"
 #include "../power/PowerSwitchIF.h"
 #include "../ipc/MessageQueueIF.h"
+#include "../tasks/PeriodicTaskIF.h"
 #include "../action/ActionHelper.h"
 #include "../health/HealthHelper.h"
 #include "../parameters/ParameterHelper.h"
 #include "../datapool/HkSwitchHelper.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
 
 #include <map>
 
@@ -38,17 +40,16 @@ class StorageManagerIF;
  * Documentation: Dissertation Baetz p.138,139, p.141-149
  *
  * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink,
- * communication with physical devices, using the @link DeviceCommunicationIF @endlink,
- * and communication with commanding objects.
- * It inherits SystemObject and thus can be created by the ObjectManagerIF.
+ * communication with physical devices, using the
+ * @link DeviceCommunicationIF @endlink, and communication with commanding
+ * objects. It inherits SystemObject and thus can be created by the
+ * ObjectManagerIF.
  *
- * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
- * For each step an RMAP action is selected and executed.
- * 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.
+ * This class uses the opcode of ExecutableObjectIF to perform a
+ * step-wise execution. For each step a different action is selected and
+ * executed. Currently, the device handler base performs a 4-step
+ * execution related to 4 communication steps (based on RMAP).
+ * NOTE: RMAP is a standard which is used for Flying Laptop.
  * 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.
@@ -69,9 +70,6 @@ class StorageManagerIF;
  *
  * Other important virtual methods with a default implementation
  * are the getTransitionDelayMs() function and the getSwitches() function.
- * Please ensure that getSwitches() returns DeviceHandlerIF::NO_SWITCHES if
- * power switches are not implemented yet. Otherwise, the device handler will
- * not transition to MODE_ON, even if setMode(MODE_ON) is called.
  * If a transition to MODE_ON is desired without commanding, override the
  * intialize() function and call setMode(_MODE_START_UP) before calling
  * DeviceHandlerBase::initialize().
@@ -85,20 +83,18 @@ class DeviceHandlerBase: public DeviceHandlerIF,
 		public HasModesIF,
 		public HasHealthIF,
 		public HasActionsIF,
-		public ReceivesParameterMessagesIF {
+		public ReceivesParameterMessagesIF,
+		public HasLocalDataPoolIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	/**
 	 * The constructor passes the objectId to the SystemObject().
 	 *
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
-	 * @param setDeviceSwitch the switch the device is connected to,
-	 * for devices using two switches, overwrite getSwitches()
 	 * @param deviceCommuncation Communcation Interface object which is used
 	 * to implement communication functions
-	 * @param thermalStatePoolId
-	 * @param thermalRequestPoolId
+	 * @param comCookie This object will be passed to the communication inter-
+	 * face and can contain user-defined information about the communication.
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
@@ -106,8 +102,21 @@ public:
 			CookieIF * comCookie, FailureIsolationBase* fdirInstance = nullptr,
 			size_t cmdQueueSize = 20);
 
+	void setHkDestination(object_id_t hkDestination);
 	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
 			uint32_t thermalRequestPoolId);
+	/**
+	 * @brief   Helper function to ease device handler development.
+	 * This will instruct the transition to MODE_ON immediately
+	 * (leading to doStartUp() being called for the transition to the ON mode),
+	 * so external mode commanding is not necessary anymore.
+	 *
+	 * This has to be called before the task is started!
+	 * (e.g. in the task factory). This is only a helper function for
+	 * development. Regular mode commanding should be performed by commanding
+	 * the AssemblyBase or Subsystem objects resposible for the device handler.
+	 */
+	void setStartUpImmediately();
 
 	/**
 	 * @brief 	This function is the device handler base core component and is
@@ -153,6 +162,14 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t initialize();
+
+	/**
+	 * @brief   Intialization steps performed after all tasks have been created.
+	 *          This function will be called by the executing task.
+	 * @return
+	 */
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+
 	/** Destructor. */
 	virtual ~DeviceHandlerBase();
 
@@ -320,6 +337,8 @@ protected:
 	 * @param packet
 	 * @return
 	 *     - @c RETURN_OK when the reply was interpreted.
+	 *     - @c IGNORE_REPLY_DATA Ignore the reply and don't reset reply cycle
+	 *          counter.
 	 *     - @c RETURN_FAILED when the reply could not be interpreted,
 	 *     e.g. logical errors or range violations occurred
 	 */
@@ -347,22 +366,10 @@ protected:
 	 *    set to the maximum expected number of PST cycles between two replies
 	 *    (also a tolerance should be added, as an FDIR message will be
 	 *    generated if it is missed).
-	 *
-	 *    (Robin) This part confuses me. "must do as soon as" implies that
-	 *    the developer must do something somewhere else in the code. Is
-	 *    that really the case? If I understood correctly, DHB performs
-	 *    almost everything (e.g. in erirm function) as long as the commands
-	 *    are inserted correctly.
-	 *
-	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must
-	 *    be set to true, DeviceCommandInfo.delayCycles to
-	 *    DeviceCommandInfo.maxDelayCycles.
 	 *    From then on, the base class handles the reception.
 	 *    Then, scanForReply returns the id of the reply or the placeholder id
 	 *    and the base class will take care of checking that all replies are
 	 *    received and the interval is correct.
-	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set
-	 *    to 0, DeviceCommandInfo.delayCycles to 0;
 	 *
 	 *  - Aperiodic, unrequested replies. These are replies that are sent
 	 *    by the device without any preceding command and not in a defined
@@ -376,13 +383,17 @@ protected:
 	 * @param deviceCommand	Identifier of the command to add.
 	 * @param maxDelayCycles The maximum number of delay cycles the command
 	 * waits until it times out.
+	 * @param replyLen Will be supplied to the requestReceiveMessage call of
+	 * the communication interface.
 	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
 	 * by the device repeatedly without request) or not. Default is aperiodic (0)
 	 * @return	- @c RETURN_OK when the command was successfully inserted,
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false,
+			uint16_t maxDelayCycles,
+			LocalPoolDataSetBase* replyDataSet = nullptr,
+			size_t replyLen = 0, bool periodic = false,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
 	/**
@@ -396,7 +407,8 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false);
+			uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet = nullptr,
+			size_t replyLen = 0, bool periodic = false);
 
 	/**
 	 * @brief 	A simple command to add a command to the commandList.
@@ -424,6 +436,9 @@ protected:
 			uint16_t delayCycles, uint16_t maxDelayCycles,
 			bool periodic = false);
 
+	ReturnValue_t setReplyDataset(DeviceCommandId_t replyId,
+	        LocalPoolDataSetBase* dataset);
+
 	/**
 	 * @brief   Can be implemented by child handler to
 	 *          perform debugging
@@ -477,18 +492,22 @@ protected:
 	 * @param localDataPoolMap
 	 * @return
 	 */
-	//virtual ReturnValue_t initializePoolEntries(
-	//			LocalDataPool& localDataPoolMap) override;
+	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
+				LocalDataPoolManager& poolManager) override;
 
 	/** Get the HK manager object handle */
-	//virtual LocalDataPoolManager* getHkManagerHandle() override;
+	virtual LocalDataPoolManager* getHkManagerHandle() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
 	 * 			performOperation(). Default implementation is empty.
 	 */
 	virtual void performOperationHook();
+
 public:
+	/** Explicit interface implementation of getObjectId */
+	virtual object_id_t getObjectId() const override;
+
 	/**
 	 * @param parentQueueId
 	 */
@@ -608,7 +627,7 @@ protected:
 	/** Action helper for HasActionsIF */
 	ActionHelper actionHelper;
 	/** Housekeeping Manager */
-	//LocalDataPoolManager hkManager;
+	LocalDataPoolManager hkManager;
 
 	/**
 	 *  @brief Information about commands
@@ -647,7 +666,7 @@ protected:
 		//! 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;
+		LocalPoolDataSetBase* dataSet;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -689,14 +708,18 @@ protected:
 	uint32_t deviceThermalRequestPoolId = PoolVariableIF::NO_PARAMETER;
 
 	/**
-	 * Optional Error code
-	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
+	 * Optional Error code. Can be set in doStartUp(), doShutDown() and
+	 * doTransition() to signal cause for Transition failure.
 	 */
 	ReturnValue_t childTransitionFailure;
 
-	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
+	/** Counts if communication channel lost a reply, so some missed
+	 * replys can be ignored. */
+	uint32_t ignoreMissedRepliesCount = 0;
 
-	FailureIsolationBase* fdirInstance; //!< Pointer to the used FDIR instance. If not provided by child, default class is instantiated.
+	/** Pointer to the used FDIR instance. If not provided by child,
+	 * default class is instantiated. */
+	FailureIsolationBase* fdirInstance;
 
 	HkSwitchHelper hkSwitcher;
 
@@ -944,14 +967,17 @@ protected:
 
 	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
 			uint32_t *msToReachTheMode);
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-	virtual void setToExternalControl();
-	virtual void announceMode(bool recursive);
+
+	/* HasModesIF overrides */
+	virtual void startTransition(Mode_t mode, Submode_t submode) override;
+	virtual void setToExternalControl() override;
+	virtual void announceMode(bool recursive) override;
 
 	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
 	/**
-	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper" faster about executed events.
+	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper"
+	 * faster about executed events.
 	 * This is a bit sneaky, but improves responsiveness of the device FDIR.
 	 * @param event	The event to be thrown
 	 * @param parameter1	Optional parameter 1
@@ -1034,12 +1060,17 @@ private:
 	/** the object used to set power switches */
 	PowerSwitchIF *powerSwitcher = nullptr;
 
+	/** HK destination can also be set individually */
+	object_id_t hkDestination = objects::NO_OBJECT;
+
 	/**
 	 * @brief   Used for timing out mode transitions.
 	 * Set when setMode() is called.
 	 */
 	uint32_t timeoutStart = 0;
 
+	bool setStartupImmediately = false;
+
 	/**
 	 * Delay for the current mode transition, used for time out
 	 */
@@ -1080,11 +1111,6 @@ private:
 	void buildRawDeviceCommand(CommandMessage* message);
 	void buildInternalCommand(void);
 
-//	/**
-//	 * Send a reply with the current mode and submode.
-//	 */
-//	void announceMode(void);
-
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
@@ -1111,10 +1137,14 @@ private:
 	/**
 	 * Build and send a command to the device.
 	 *
-	 * This routine checks whether a raw or direct command has been received, checks the content of the received command and
-	 * calls buildCommandFromCommand() for direct commands or sets #rawpacket to the received raw packet.
-	 * If no external command is received or the received command is invalid and the current mode is @c MODE_NORMAL or a transitional mode,
-	 * it asks the child class to build a command (via getNormalDeviceCommand() or getTransitionalDeviceCommand() and buildCommand()) and
+	 * This routine checks whether a raw or direct command has been received,
+	 * checks the content of the received command and calls
+	 * buildCommandFromCommand() for direct commands or sets #rawpacket
+	 * to the received raw packet.
+	 * If no external command is received or the received command is invalid and
+	 * the current mode is @c MODE_NORMAL or a transitional mode, it asks the
+	 * child class to build a command (via getNormalDeviceCommand() or
+	 * getTransitionalDeviceCommand() and buildCommand()) and
 	 * sends the command via RMAP.
 	 */
 	void doSendWrite(void);
@@ -1159,7 +1189,6 @@ private:
 	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
 			uint32_t *len);
 
-
 	/**
 	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
 	 */
@@ -1170,25 +1199,14 @@ private:
 	 */
 	void callChildStatemachine();
 
-	/**
-	 * Switches the channel of the cookie used for the communication
-	 *
-	 *
-	 * @param newChannel the object Id of the channel to switch to
-	 * @return
-	 *     - @c RETURN_OK when cookie was changed
-	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
-	 *     - @c returnvalues of RMAPChannelIF::isActive()
-	 */
-	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
-
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 
-	void parseReply(const uint8_t* receivedData,
-	            size_t receivedDataLen);
+    virtual dur_millis_t getPeriodicOperationFrequency() const override;
+
+    void parseReply(const uint8_t* receivedData,
+                size_t receivedDataLen);
 };
 
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
-
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */

From 315777d265a57b50aff944bc795a15a24e64ac72 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 13:21:23 +0200
Subject: [PATCH 0857/1774] tc distribution equalization

---
 tcdistribution/CCSDSDistributor.cpp | 22 ++++---
 tcdistribution/CCSDSDistributor.h   | 14 +++--
 tcdistribution/CCSDSDistributorIF.h | 36 ++++++-----
 tcdistribution/PUSDistributor.cpp   | 94 +++++++++++++++++------------
 tcdistribution/PUSDistributor.h     | 18 +++---
 tcdistribution/PUSDistributorIF.h   | 13 ++--
 tcdistribution/TcDistributor.cpp    | 25 ++++----
 tcdistribution/TcDistributor.h      | 34 ++++++-----
 tcdistribution/TcPacketCheck.cpp    | 24 ++++----
 tcdistribution/TcPacketCheck.h      | 25 ++++----
 10 files changed, 170 insertions(+), 135 deletions(-)

diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index dda26d7f9..ddd633083 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -1,5 +1,6 @@
+#include "CCSDSDistributor.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/CCSDSDistributor.h"
 #include "../tmtcpacket/SpacePacketBase.h"
 
 CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
@@ -19,7 +20,7 @@ TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
 			&packet, &size );
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
-				"store failed!" << std::endl;
+				" store failed!" << std::endl;
 	}
 	SpacePacketBase currentPacket(packet);
 
@@ -42,9 +43,9 @@ MessageQueueId_t CCSDSDistributor::getRequestQueue() {
 ReturnValue_t CCSDSDistributor::registerApplication(
 		AcceptsTelecommandsIF* application) {
 	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( application->getIdentifier(), application->getRequestQueue() ) ).second;
-	if(  errorCode == false ) {
+	auto insertPair = this->queueMap.emplace(application->getIdentifier(),
+	        application->getRequestQueue());
+	if(not insertPair.second) {
 		returnValue = RETURN_FAILED;
 	}
 	return returnValue;
@@ -53,9 +54,8 @@ ReturnValue_t CCSDSDistributor::registerApplication(
 ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
 		MessageQueueId_t id) {
 	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( apid, id ) ).second;
-	if(  errorCode == false ) {
+	auto insertPair = this->queueMap.emplace(apid, id);
+	if(not insertPair.second) {
 		returnValue = RETURN_FAILED;
 	}
 	return returnValue;
@@ -69,7 +69,11 @@ uint16_t CCSDSDistributor::getIdentifier() {
 ReturnValue_t CCSDSDistributor::initialize() {
 	ReturnValue_t status = this->TcDistributor::initialize();
 	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
-	if (this->tcStore == NULL) status = RETURN_FAILED;
+	if (this->tcStore == nullptr) {
+	    sif::error << "CCSDSDistributor::initialize: Could not initialize"
+	            " TC store!" << std::endl;
+	    status = RETURN_FAILED;
+	}
 	return status;
 }
 
diff --git a/tcdistribution/CCSDSDistributor.h b/tcdistribution/CCSDSDistributor.h
index 6abd952b4..e8d54c9c9 100644
--- a/tcdistribution/CCSDSDistributor.h
+++ b/tcdistribution/CCSDSDistributor.h
@@ -38,7 +38,7 @@ public:
 			MessageQueueId_t id) override;
 	ReturnValue_t registerApplication(
 			AcceptsTelecommandsIF* application) override;
-	uint16_t getIdentifier();
+	uint16_t getIdentifier() override;
 	ReturnValue_t initialize() override;
 
 protected:
@@ -50,6 +50,12 @@ protected:
 	 * @return Iterator to map entry of found APID or iterator to default APID.
 	 */
 	TcMqMapIter selectDestination() override;
+    /**
+     * The callback here handles the generation of acceptance
+     * success/failure messages.
+     */
+    ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus ) override;
+
 	/**
 	 * The default APID, where packets with unknown APID are sent to.
 	 */
@@ -59,11 +65,7 @@ protected:
 	 * pure Space Packets and there exists no SpacePacketStored class.
 	 */
 	StorageManagerIF* tcStore = nullptr;
-	/**
-	 * The callback here handles the generation of acceptance
-	 * success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+
 };
 
 #endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/CCSDSDistributorIF.h b/tcdistribution/CCSDSDistributorIF.h
index be3c28114..6334a35ad 100644
--- a/tcdistribution/CCSDSDistributorIF.h
+++ b/tcdistribution/CCSDSDistributorIF.h
@@ -1,34 +1,38 @@
-#ifndef CCSDSDISTRIBUTORIF_H_
-#define CCSDSDISTRIBUTORIF_H_
+#ifndef FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_
+#define FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_
 
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 /**
  * This is the Interface to a CCSDS Distributor.
- * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves,
- * either by passing a pointer to themselves (and implementing the CCSDSApplicationIF,
- * or by explicitly passing an APID and a MessageQueueId to route the TC's to.
- * \ingroup tc_distribution
+ * On a CCSDS Distributor, Applications (in terms of CCSDS) may register
+ * themselves, either by passing a pointer to themselves (and implementing the
+ * CCSDSApplicationIF),  or by explicitly passing an APID and a MessageQueueId
+ * to route the TC's to.
+ * @ingroup tc_distribution
  */
 class CCSDSDistributorIF {
 public:
 	/**
-	 * With this call, a class implementing the CCSDSApplicationIF can register at the
-	 * distributor.
+	 * With this call, a class implementing the CCSDSApplicationIF can register
+	 * at the distributor.
 	 * @param application A pointer to the Application to register.
-	 * @return	- \c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
+	 * @return	- @c RETURN_OK on success,
+	 * 			- @c RETURN_FAILED on failure.
 	 */
-	virtual ReturnValue_t registerApplication( AcceptsTelecommandsIF* application ) = 0;
+	virtual ReturnValue_t registerApplication(
+	        AcceptsTelecommandsIF* application) = 0;
 	/**
 	 * With this call, other Applications can register to the CCSDS distributor.
 	 * This is done by passing an APID and a MessageQueueId to the method.
 	 * @param apid	The APID to register.
-	 * @param id	The MessageQueueId of the message queue to send the TC Packets to.
-	 * @return	- \c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
+	 * @param id	The MessageQueueId of the message queue to send the
+	 *              TC Packets to.
+	 * @return	- @c RETURN_OK on success,
+	 * 			- @c RETURN_FAILED on failure.
 	 */
-	virtual ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id ) = 0;
+	virtual ReturnValue_t registerApplication( uint16_t apid,
+	        MessageQueueId_t id) = 0;
 	/**
 	 * The empty virtual destructor.
 	 */
@@ -37,4 +41,4 @@ public:
 };
 
 
-#endif /* CCSDSDISTRIBUTORIF_H_ */
+#endif /* FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_ */
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 0c710ef28..3baef7d10 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -1,57 +1,66 @@
+#include "CCSDSDistributorIF.h"
+#include "PUSDistributor.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/CCSDSDistributorIF.h"
-#include "../tcdistribution/PUSDistributor.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcservices/PusVerificationReport.h"
 
 PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
 		object_id_t setPacketSource) :
 		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
-		currentPacket(), tcStatus(RETURN_FAILED),
-		packetSource(setPacketSource) {}
+		tcStatus(RETURN_FAILED), packetSource(setPacketSource) {}
 
 PUSDistributor::~PUSDistributor() {}
 
-TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
-	TcMqMapIter queueMapIt = this->queueMap.end();
-	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
-	if (currentPacket.getWholeData() != NULL) {
-		tcStatus = checker.checkPacket(&currentPacket);
-//		sif::debug << "PUSDistributor::handlePacket: packetCheck returned with "
-//				<< (int)tcStatus << std::endl;
-		uint32_t queue_id = currentPacket.getService();
-		queueMapIt = this->queueMap.find(queue_id);
-	} else {
-		tcStatus = PACKET_LOST;
-	}
-	if (queueMapIt == this->queueMap.end()) {
-		tcStatus = DESTINATION_NOT_FOUND;
-	}
+PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
+    // sif:: debug << "PUSDistributor::handlePacket received: "
+    //          << this->current_packet_id.store_index << ", "
+    //          << this->current_packet_id.packet_index << std::endl;
+    TcMqMapIter queueMapIt = this->queueMap.end();
+    this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
+    if (currentPacket->getWholeData() != NULL) {
+        tcStatus = checker.checkPacket(currentPacket);
+#ifdef DEBUG
+        if(tcStatus != HasReturnvaluesIF::RETURN_OK) {
+            sif::debug << "PUSDistributor::handlePacket: Packet format "
+                    << "invalid, code "<< static_cast<int>(tcStatus)
+                    << std::endl;
+        }
+#endif
+        uint32_t queue_id = currentPacket->getService();
+        queueMapIt = this->queueMap.find(queue_id);
+    }
+    else {
+        tcStatus = PACKET_LOST;
+    }
 
-	if (tcStatus != RETURN_OK) {
-		sif::debug << "PUSDistributor::handlePacket: Error with " << tcStatus
-				<< ", 0x"<< std::hex << tcStatus << std::dec << std::endl;
-		return this->queueMap.end();
-	} else {
-		return queueMapIt;
-	}
+    if (queueMapIt == this->queueMap.end()) {
+        tcStatus = DESTINATION_NOT_FOUND;
+#ifdef DEBUG
+        sif::debug << "PUSDistributor::handlePacket: Destination not found, "
+                << "code "<< static_cast<int>(tcStatus) << std::endl;
+#endif
+    }
+
+    if (tcStatus != RETURN_OK) {
+        return this->queueMap.end();
+    }
+    else {
+        return queueMapIt;
+    }
 
 }
 
-//uint16_t PUSDistributor::createDestination( uint8_t service_id, uint8_t subservice_id ) {
-//	return ( service_id << 8 ) + subservice_id;
-//}
 
 ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
 	uint16_t serviceId = service->getIdentifier();
-	//info << "Service ID: " << (int)serviceId << std::endl;
+	// sif::info << "Service ID: " << (int)serviceId << std::endl;
 	MessageQueueId_t queue = service->getRequestQueue();
 	auto returnPair = queueMap.emplace(serviceId, queue);
 	if (not returnPair.second) {
-		//TODO Return Code
 		sif::error << "PUSDistributor::registerService: Service ID already"
 				" exists in map." << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return SERVICE_ID_ALREADY_EXISTS;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -66,13 +75,14 @@ ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
 	}
 	if (tcStatus != RETURN_OK) {
 		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
-				&currentPacket, tcStatus);
-		//A failed packet is deleted immediately after reporting, otherwise it will block memory.
-		currentPacket.deletePacket();
+				currentPacket, tcStatus);
+		// A failed packet is deleted immediately after reporting,
+		// otherwise it will block memory.
+		currentPacket->deletePacket();
 		return RETURN_FAILED;
 	} else {
 		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
-				&currentPacket);
+				currentPacket);
 		return RETURN_OK;
 	}
 }
@@ -84,9 +94,15 @@ uint16_t PUSDistributor::getIdentifier() {
 ReturnValue_t PUSDistributor::initialize() {
 	CCSDSDistributorIF* ccsdsDistributor =
 			objectManager->get<CCSDSDistributorIF>(packetSource);
-	if (ccsdsDistributor == NULL) {
-		return RETURN_FAILED;
-	} else {
+	if (ccsdsDistributor == nullptr) {
+		sif::error << "PUSDistributor::initialize: Packet source invalid."
+		        << " Make sure it exists and implements CCSDSDistributorIF!"
+		        << std::endl;
+	    return RETURN_FAILED;
+	}
+	else {
 		return ccsdsDistributor->registerApplication(this);
 	}
+
+	currentPacket = new TcPacketStored();
 }
diff --git a/tcdistribution/PUSDistributor.h b/tcdistribution/PUSDistributor.h
index b8cff1f44..be3804ef2 100644
--- a/tcdistribution/PUSDistributor.h
+++ b/tcdistribution/PUSDistributor.h
@@ -1,10 +1,11 @@
-#ifndef FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
-#define FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+#ifndef FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+#define FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+
+#include "PUSDistributorIF.h"
+#include "TcDistributor.h"
+#include "TcPacketCheck.h"
 
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tcdistribution/PUSDistributorIF.h"
-#include "../tcdistribution/TcDistributor.h"
-#include "../tcdistribution/TcPacketCheck.h"
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../tmtcservices/VerificationReporter.h"
 
@@ -50,7 +51,7 @@ protected:
 	/**
 	 * The currently handled packet is stored here.
 	 */
-	TcPacketStored currentPacket;
+	TcPacketStored* currentPacket = nullptr;
 	/**
 	 * With this variable, the current check status is stored to generate
 	 * acceptance messages later.
@@ -58,6 +59,7 @@ protected:
 	ReturnValue_t tcStatus;
 
 	const object_id_t packetSource;
+
 	/**
 	 * This method reads the packet service, checks if such a service is
 	 * registered and forwards the packet to the destination.
@@ -71,7 +73,7 @@ protected:
 	 * The callback here handles the generation of acceptance
 	 * success/failure messages.
 	 */
-	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
+	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus) override;
 };
 
-#endif /* FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
+#endif /* FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/PUSDistributorIF.h b/tcdistribution/PUSDistributorIF.h
index 5e27b35c5..0125c08f3 100644
--- a/tcdistribution/PUSDistributorIF.h
+++ b/tcdistribution/PUSDistributorIF.h
@@ -1,11 +1,12 @@
-#ifndef PUSDISTRIBUTORIF_H_
-#define PUSDISTRIBUTORIF_H_
+#ifndef FSFW_TCDISTRIBUTION_PUSDISTRIBUTORIF_H_
+#define FSFW_TCDISTRIBUTION_PUSDISTRIBUTORIF_H_
 
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
+
 /**
  * This interface allows PUS Services to register themselves at a PUS Distributor.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
 class PUSDistributorIF {
 public:
@@ -17,10 +18,10 @@ public:
 /**
  * With this method, Services can register themselves at the PUS Distributor.
  * @param service A pointer to the registering Service.
- * @return	- \c RETURN_OK on success,
- * 			- \c RETURN_FAILED on failure.
+ * @return	- @c RETURN_OK on success,
+ * 			- @c RETURN_FAILED on failure.
  */
 	virtual ReturnValue_t registerService( AcceptsTelecommandsIF* service ) = 0;
 };
 
-#endif /* PUSDISTRIBUTORIF_H_ */
+#endif /* FSFW_TCDISTRIBUTION_PUSDISTRIBUTORIF_H_ */
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index b03545581..06e1817f8 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -1,12 +1,13 @@
+#include "TcDistributor.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/TcDistributor.h"
 #include "../tmtcservices/TmTcMessage.h"
 #include "../ipc/QueueFactory.h"
 
-TcDistributor::TcDistributor(object_id_t set_object_id) :
-		SystemObject(set_object_id), tcQueue(NULL) {
-	tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
+TcDistributor::TcDistributor(object_id_t objectId) :
+		SystemObject(objectId) {
+	tcQueue = QueueFactory::instance()->
+	        createMessageQueue(DISTRIBUTER_MAX_PACKETS);
 }
 
 TcDistributor::~TcDistributor() {
@@ -38,14 +39,14 @@ ReturnValue_t TcDistributor::handlePacket() {
 }
 
 void TcDistributor::print() {
-	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
-			<< std::endl;
-	for (TcMqMapIter it = this->queueMap.begin(); it != this->queueMap.end();
-			it++) {
-		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
-				<< std::endl;
+	sif::debug << "Distributor content is: " << std::endl
+	        << "ID\t| Message Queue ID" << std::endl;
+	sif::debug << std::setfill('0') << std::setw(8) << std::hex;
+	for (const auto& queueMapIter: queueMap) {
+		sif::debug << queueMapIter.first << "\t| 0x"   << queueMapIter.second
+		         << std::endl;
 	}
-	sif::debug << std::dec;
+	sif::debug << std::setfill(' ') << std::dec;
 
 }
 
diff --git a/tcdistribution/TcDistributor.h b/tcdistribution/TcDistributor.h
index 95b7d25b8..5d0ca45d2 100644
--- a/tcdistribution/TcDistributor.h
+++ b/tcdistribution/TcDistributor.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
-#define FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+#ifndef FSFW_TMTCSERVICES_TCDISTRIBUTOR_H_
+#define FSFW_TMTCSERVICES_TCDISTRIBUTOR_H_
 
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../objectmanager/SystemObject.h"
@@ -34,9 +34,10 @@ public:
 	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
 	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
 
-	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
-	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
+	static constexpr ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t SERVICE_ID_ALREADY_EXISTS = MAKE_RETURN_CODE(3);
 	/**
 	 * Within the default constructor, the SystemObject id is set and the
 	 * message queue is initialized.
@@ -44,7 +45,7 @@ public:
 	 * @param set_object_id	This id is assigned to the distributor
 	 * 		implementation.
 	 */
-	TcDistributor( object_id_t set_object_id );
+	TcDistributor(object_id_t objectId);
 	/**
 	 * The destructor is empty, the message queues are not in the vicinity of
 	 * this class.
@@ -69,7 +70,7 @@ protected:
 	 * This is the receiving queue for incoming Telecommands.
 	 * The child classes must make its queue id public.
 	 */
-	MessageQueueIF* tcQueue;
+	MessageQueueIF* tcQueue = nullptr;
 	/**
 	 * The last received incoming packet information is stored in this
 	 * member.
@@ -94,18 +95,19 @@ protected:
 	/**
 	 * The handlePacket method calls the child class's selectDestination method
 	 * and forwards the packet to its destination, if found.
-	 * @return The message queue return value or \c RETURN_FAILED, in case no
+	 * @return The message queue return value or @c RETURN_FAILED, in case no
 	 * 		destination was found.
 	 */
 	ReturnValue_t handlePacket();
 	/**
-	 * This method gives the child class a chance to perform some kind of operation
-	 * after the parent tried to forward the message.
+	 * This method gives the child class a chance to perform some kind of
+	 * operation after the parent tried to forward the message.
 	 * A typically application would be sending success/failure messages.
-	 * The default implementation just returns \c RETURN_OK.
-	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
-	 * @return	- \c RETURN_OK on success
-	 * 			- \c RETURN_FAILED on failure
+	 * The default implementation just returns @c RETURN_OK.
+	 * @param queueStatus	The status of the message queue after an attempt
+	 *                      to send the TC.
+	 * @return	- @c RETURN_OK on success
+	 * 			- @c RETURN_FAILED on failure
 	 */
 	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
 
@@ -113,8 +115,8 @@ private:
 	/**
 	 * This constant sets the maximum number of packets distributed per call.
 	 */
-	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
+	static constexpr uint8_t DISTRIBUTER_MAX_PACKETS = 128;
 };
 
 
-#endif /* TCDISTRIBUTOR_H_ */
+#endif /* FSFW_TMTCSERVICES_TCDISTRIBUTOR_H_ */
diff --git a/tcdistribution/TcPacketCheck.cpp b/tcdistribution/TcPacketCheck.cpp
index 4701ce238..38ed04aaf 100644
--- a/tcdistribution/TcPacketCheck.cpp
+++ b/tcdistribution/TcPacketCheck.cpp
@@ -1,31 +1,33 @@
+#include "TcPacketCheck.h"
+
 #include "../globalfunctions/CRC.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "../tcdistribution/TcPacketCheck.h"
 #include "../tmtcservices/VerificationCodes.h"
 
-TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) {
+TcPacketCheck::TcPacketCheck( uint16_t setApid ) : apid(setApid) {
 }
 
-ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* current_packet ) {
-	uint16_t calculated_crc = CRC::crc16ccitt( current_packet->getWholeData(), current_packet->getFullSize() );
+ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* currentPacket ) {
+	uint16_t calculated_crc = CRC::crc16ccitt( currentPacket->getWholeData(),
+	        currentPacket->getFullSize() );
 	if ( calculated_crc != 0 ) {
 		return INCORRECT_CHECKSUM;
 	}
-	bool condition = !(current_packet->hasSecondaryHeader()) ||
-			current_packet->getPacketVersionNumber() != CCSDS_VERSION_NUMBER ||
-			!(current_packet->isTelecommand());
+	bool condition = (not currentPacket->hasSecondaryHeader()) or
+			(currentPacket->getPacketVersionNumber() != CCSDS_VERSION_NUMBER) or
+			(not currentPacket->isTelecommand());
 	if ( condition ) {
 		return INCORRECT_PRIMARY_HEADER;
 	}
-	if ( current_packet->getAPID() != this->apid )
+	if ( currentPacket->getAPID() != this->apid )
 		return ILLEGAL_APID;
 
-	if ( !current_packet->isSizeCorrect() ) {
+	if ( not currentPacket->isSizeCorrect() ) {
 		return INCOMPLETE_PACKET;
 	}
-	condition = (current_packet->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
-			(current_packet->getPusVersionNumber() != PUS_VERSION_NUMBER);
+	condition = (currentPacket->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
+			(currentPacket->getPusVersionNumber() != PUS_VERSION_NUMBER);
 	if ( condition ) {
 		return INCORRECT_SECONDARY_HEADER;
 	}
diff --git a/tcdistribution/TcPacketCheck.h b/tcdistribution/TcPacketCheck.h
index 4ba269f5e..703bb1bb5 100644
--- a/tcdistribution/TcPacketCheck.h
+++ b/tcdistribution/TcPacketCheck.h
@@ -1,28 +1,29 @@
-#ifndef TCPACKETCHECK_H_
-#define TCPACKETCHECK_H_
+#ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECK_H_
+#define FSFW_TCDISTRIBUTION_TCPACKETCHECK_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcservices/PusVerificationReport.h"
+
 /**
  * This class performs a formal packet check for incoming PUS Telecommand Packets.
  * Currently, it only checks if the APID and CRC are correct.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
 class TcPacketCheck : public HasReturnvaluesIF {
 protected:
 	/**
 	 * Describes the version number a packet must have to pass.
 	 */
-	static const uint8_t CCSDS_VERSION_NUMBER = 0;
+	static constexpr uint8_t CCSDS_VERSION_NUMBER = 0;
 	/**
 	 * Describes the secondary header a packet must have to pass.
 	 */
-	static const uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
+	static constexpr uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
 	/**
 	 * Describes the TC Packet PUS Version Number a packet must have to pass.
 	 */
-	static const uint8_t PUS_VERSION_NUMBER = 1;
+	static constexpr uint8_t PUS_VERSION_NUMBER = 1;
 	/**
 	 * The packet id each correct packet should have.
 	 * It is composed of the APID and some static fields.
@@ -41,19 +42,19 @@ public:
 	 * The constructor only sets the APID attribute.
 	 * @param set_apid The APID to set.
 	 */
-	TcPacketCheck( uint16_t set_apid );
+	TcPacketCheck( uint16_t setApid );
 	/**
 	 * This is the actual method to formally check a certain Telecommand Packet.
 	 * The packet's Application Data can not be checked here.
 	 * @param current_packet The packt to check
-	 * @return	- \c RETURN_OK on success.
-	 * 			- \c INCORRECT_CHECKSUM if checksum is invalid.
-	 * 			- \c ILLEGAL_APID if APID does not match.
+	 * @return	- @c RETURN_OK on success.
+	 * 			- @c INCORRECT_CHECKSUM if checksum is invalid.
+	 * 			- @c ILLEGAL_APID if APID does not match.
 	 */
-	ReturnValue_t checkPacket( TcPacketStored* current_packet );
+	ReturnValue_t checkPacket( TcPacketStored* currentPacket );
 
 	uint16_t getApid() const;
 };
 
 
-#endif /* TCPACKETCHECK_H_ */
+#endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECK_H_ */

From 26454356f8958bf077e8756471869dc0bb8e0af8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 13:57:34 +0200
Subject: [PATCH 0858/1774] tpp extraction

---
 container/FixedOrderedMultimap.h   | 56 +++---------------------
 container/FixedOrderedMultimap.tpp | 69 ++++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+), 49 deletions(-)

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 99825dc4b..cb8ab10fb 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -1,9 +1,8 @@
 #ifndef FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
 #define FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
 
-#include "../container/ArrayList.h"
+#include "ArrayList.h"
 #include <cstring>
-#include <set>
 
 /**
  * @brief   Map implementation which allows entries with identical keys
@@ -72,56 +71,15 @@ public:
      */
     ReturnValue_t exists(key_t key) const;
 
-    ReturnValue_t erase(Iterator *iter) {
-        uint32_t i;
-        if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-            return KEY_DOES_NOT_EXIST;
-        }
-        removeFromPosition(i);
-        if (*iter != begin()) {
-            (*iter)--;
-        } else {
-            *iter = begin();
-        }
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+    ReturnValue_t erase(Iterator *iter);
+    ReturnValue_t erase(key_t key);
 
-    ReturnValue_t erase(key_t key) {
-        uint32_t i;
-        if ((i = findFirstIndex(key)) >= _size) {
-            return KEY_DOES_NOT_EXIST;
-        }
-        do {
-            removeFromPosition(i);
-            i = findFirstIndex(key, i);
-        } while (i < _size);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+    Iterator find(key_t key) const;
+    ReturnValue_t find(key_t key, T **value) const;
 
-    Iterator find(key_t key) const {
-        ReturnValue_t result = exists(key);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return end();
-        }
-        return Iterator(&theMap[findFirstIndex(key)]);
-    }
+    void clear();
 
-    ReturnValue_t find(key_t key, T **value) const {
-        ReturnValue_t result = exists(key);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-        *value = &theMap[findFirstIndex(key)].second;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-    void clear() {
-        _size = 0;
-    }
-
-    size_t maxSize() const {
-        return theMap.maxSize();
-    }
+    size_t maxSize() const;
 
 private:
 	typedef KEY_COMPARE compare;
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
index 5b7b9ead9..bc76c5949 100644
--- a/container/FixedOrderedMultimap.tpp
+++ b/container/FixedOrderedMultimap.tpp
@@ -71,4 +71,73 @@ inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(
     return result;
 }
 
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(
+        Iterator *iter)
+{
+    uint32_t i;
+    if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    removeFromPosition(i);
+    if (*iter != begin()) {
+        (*iter)--;
+    } else {
+        *iter = begin();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(
+        key_t key)
+{
+    uint32_t i;
+    if ((i = findFirstIndex(key)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    do {
+        removeFromPosition(i);
+        i = findFirstIndex(key, i);
+    } while (i < _size);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(
+        key_t key, T **value) const
+{
+    ReturnValue_t result = exists(key);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    *value = &theMap[findFirstIndex(key)].second;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
+FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(
+        key_t key) const
+{
+    ReturnValue_t result = exists(key);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return end();
+    }
+    return Iterator(&theMap[findFirstIndex(key)]);
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::clear()
+{
+    _size = 0;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::maxSize() const
+{
+    return theMap.maxSize();
+}
+
+
 #endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */

From 0714dc6e06d7bbd30b12775d1f7f39bac189b216 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:31:30 +0200
Subject: [PATCH 0859/1774] taken over container

---
 container/FixedOrderedMultimap.h   | 250 +++++++++++++++++++----------
 container/FixedOrderedMultimap.tpp | 190 +++++++++-------------
 2 files changed, 243 insertions(+), 197 deletions(-)

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index cb8ab10fb..96bc00735 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -5,120 +5,200 @@
 #include <cstring>
 
 /**
- * @brief   Map implementation which allows entries with identical keys
+ * @brief  An associative container which allows multiple entries of the same key.
  * @details
- * Performs no dynamic memory allocation except on initialization.
- * Uses an ArrayList as the underlying container and thus has a linear
+ * Same keys are ordered by KEY_COMPARE function which is std::less<key_t> > by default.
+ *
+ * It uses the ArrayList, so technically this is not a real map, it is an array of pairs
+ * of type key_t, T. It is ordered by key_t as FixedMap but allows same keys. Thus it has a linear
  * complexity O(n). As long as the number of entries remains low, this
  * should not be an issue.
  * The number of insertion and deletion operation should be minimized
- * as those incur exensive memory move operations (the underlying container
+ * as those incur extensive memory move operations (the underlying container
  * is not node based).
- * @ingroup container
+ *
+ * Its of fixed size so no allocations are performed after the construction.
+ *
+ * The maximum size is given as first parameter of the constructor.
+ *
+ * It provides an iterator to do list iterations.
+ *
+ * The type T must have a copy constructor if it is not trivial copy-able.
+ *
+ * @warning Iterators return a non-const key_t in the pair.
+ * @warning A User is not allowed to change the key, otherwise the map is corrupted.
+ *
+ * \ingroup container
  */
 template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
 class FixedOrderedMultimap {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
+
+	/***
+	 * Constructor which needs a size_t for the maximum allowed size
+	 *
+	 * Can not be resized during runtime
+	 *
+	 * Allocates memory at construction
+	 * @param maxSize size_t of Maximum allowed size
+	 */
+    FixedOrderedMultimap(size_t maxSize):theMap(maxSize), _size(0){
+    }
+
+	/***
+	 * Virtual destructor frees Memory by deleting its member
+	 */
+	virtual ~FixedOrderedMultimap() {
+	}
+
+	/***
+	 * Special iterator for FixedOrderedMultimap
+	 */
+	class Iterator: public ArrayList<std::pair<key_t, T>, size_t>::Iterator {
+	public:
+		Iterator() :
+			ArrayList<std::pair<key_t, T>, size_t>::Iterator() {
+		}
+
+		Iterator(std::pair<key_t, T> *pair) :
+			ArrayList<std::pair<key_t, T>, size_t>::Iterator(pair) {
+		}
+	};
+
+	/***
+	 * Returns an iterator pointing to the first element
+	 * @return Iterator pointing to first element
+	 */
+	Iterator begin() const {
+		return Iterator(&theMap[0]);
+	}
 
 	/**
-	 * Initializes the ordered multimap with a fixed maximum size.
-	 * @param maxSize
+	 * Returns an iterator pointing to one element past the end
+	 * @return Iterator pointing to one element past the end
 	 */
-    FixedOrderedMultimap(size_t maxSize);
+	Iterator end() const {
+		return Iterator(&theMap[_size]);
+	}
 
-    virtual ~FixedOrderedMultimap() {}
+	/***
+	 * Returns the current size of the map (not maximum size!)
+	 * @return Current size
+	 */
+	size_t size() const{
+		return _size;
+	}
 
-    class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-    public:
-        /** Returns an iterator to nullptr */
-        Iterator();
-        /** Initializes iterator to given entry */
-        Iterator(std::pair<key_t, T> *pair);
-    };
+	/**
+	 * Clears the map, does not deallocate any memory
+	 */
+	void clear(){
+		_size = 0;
+	}
 
-    /** Iterator to start of map */
-    Iterator begin() const;
-    /** Iterator to end of map */
-    Iterator end() const;
-    /** Current (variable) size of the map */
-    size_t size() const;
+	/**
+	 * Returns the maximum size of the map
+	 * @return Maximum size of the map
+	 */
+	size_t maxSize() const{
+		return theMap.maxSize();
+	}
 
-    /**
-     * Insert a key/value pair inside the map. An iterator to the stored
-     * value might be returned optionally.
-     * @param key
-     * @param value
-     * @param storedValue
-     * @return
-     */
-    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
-    /**
-     * Insert a given std::pair<key, value>
-     * @param pair
-     * @return
-     */
-    ReturnValue_t insert(std::pair<key_t, T> pair);
-    /**
-     * Checks existence of key in map.
-     * @param key
-     * @return
-     * - @c KEY_DOES_NOT_EXIST if key does not exists.
-     * - @c RETURN_OK otherwise.
-     */
-    ReturnValue_t exists(key_t key) const;
+	/***
+	 * Used to insert a key and value separately.
+	 *
+	 * @param[in] key Key of the new element
+	 * @param[in] value Value of the new element
+	 * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a nullptr
+	 * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+	 */
+	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
 
-    ReturnValue_t erase(Iterator *iter);
-    ReturnValue_t erase(key_t key);
+	/***
+	 * Used to insert new pair instead of single values
+	 *
+	 * @param pair Pair to be inserted
+	 * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+	 */
+	ReturnValue_t insert(std::pair<key_t, T> pair);
 
-    Iterator find(key_t key) const;
-    ReturnValue_t find(key_t key, T **value) const;
+	/***
+	 * Can be used to check if a certain key is in the map
+	 * @param key Key to be checked
+	 * @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
+	 */
+	ReturnValue_t exists(key_t key) const;
 
-    void clear();
+	/***
+	 * Used to delete the element in the iterator
+	 *
+	 * The iterator will point to the element before or begin(),
+	 *  but never to one element in front of the map.
+	 *
+	 * @warning The iterator needs to be valid and dereferenceable
+	 * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
+	 * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+	 */
+	ReturnValue_t erase(Iterator *iter);
 
-    size_t maxSize() const;
+	/***
+	 * Used to erase by key
+	 * @param key Key to be erased
+	 * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+	 */
+	ReturnValue_t erase(key_t key);
+
+	/***
+	 * Find returns the first appearance of the key
+	 *
+	 * If the key does not exist, it points to end()
+	 *
+	 * @param key Key to search for
+	 * @return Iterator pointing to the first entry of key
+	 */
+	Iterator find(key_t key) const{
+		ReturnValue_t result = exists(key);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return end();
+		}
+		return Iterator(&theMap[findFirstIndex(key)]);
+	};
+
+	/***
+	 * Finds first entry of the given key and returns a
+	 * pointer to the value
+	 *
+	 * @param key Key to search for
+	 * @param value Found value
+	 * @return RETURN_OK if it points to the value,
+	 * KEY_DOES_NOT_EXIST if the key is not in the map
+	 */
+	ReturnValue_t find(key_t key, T **value) const;
+
+	friend bool operator==(const typename FixedOrderedMultimap::Iterator& lhs,
+			const typename FixedOrderedMultimap::Iterator& rhs) {
+		return (lhs.value == rhs.value);
+	}
+
+	friend bool operator!=(const typename FixedOrderedMultimap::Iterator& lhs,
+			const typename FixedOrderedMultimap::Iterator& rhs) {
+		return not (lhs.value == rhs.value);
+	}
 
 private:
 	typedef KEY_COMPARE compare;
 	compare myComp;
-	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
+	ArrayList<std::pair<key_t, T>, size_t> theMap;
 	size_t _size;
 
-	uint32_t findFirstIndex(key_t key, uint32_t startAt = 0) const {
-		if (startAt >= _size) {
-			return startAt + 1;
-		}
-		uint32_t i = startAt;
-		for (i = startAt; i < _size; ++i) {
-			if (theMap[i].first == key) {
-				return i;
-			}
-		}
-		return i;
-	}
+	size_t findFirstIndex(key_t key, size_t startAt = 0) const;
 
-	uint32_t findNicePlace(key_t key) const {
-		uint32_t i = 0;
-		for (i = 0; i < _size; ++i) {
-			if (myComp(key, theMap[i].first)) {
-				return i;
-			}
-		}
-		return i;
-	}
+	size_t findNicePlace(key_t key) const;
 
-	void removeFromPosition(uint32_t position) {
-		if (_size <= position) {
-			return;
-		}
-		std::memmove(static_cast<void*>(&theMap[position]),
-		        static_cast<void*>(&theMap[position + 1]),
-				(_size - position - 1) * sizeof(std::pair<key_t,T>));
-		--_size;
-	}
+	void removeFromPosition(size_t position);
 };
 
 #include "FixedOrderedMultimap.tpp"
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
index bc76c5949..4aa85e974 100644
--- a/container/FixedOrderedMultimap.tpp
+++ b/container/FixedOrderedMultimap.tpp
@@ -1,142 +1,108 @@
 #ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
 #define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
 
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator():
-        ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(){}
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator(
-        std::pair<key_t, T> *pair):
-        ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair){}
-
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
+	if (_size == theMap.maxSize()) {
+		return MAP_FULL;
+	}
+	size_t position = findNicePlace(key);
+	memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
+			(_size - position) * sizeof(std::pair<key_t,T>));
+	theMap[position].first = key;
+	theMap[position].second = value;
+	++_size;
+	if (storedValue != nullptr) {
+		*storedValue = Iterator(&theMap[position]);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
 template<typename key_t, typename T, typename KEY_COMPARE>
-inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
-FixedOrderedMultimap<key_t, T, KEY_COMPARE>::begin() const {
-    return Iterator(&theMap[0]);
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
+	return insert(pair.first, pair.second);
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
-FixedOrderedMultimap<key_t, T, KEY_COMPARE>::end() const {
-    return Iterator(&theMap[_size]);
-}
-
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::size() const {
-    return _size;
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
+	ReturnValue_t result = KEY_DOES_NOT_EXIST;
+	if (findFirstIndex(key) < _size) {
+		result = HasReturnvaluesIF::RETURN_OK;
+	}
+	return result;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::FixedOrderedMultimap(
-        size_t maxSize): theMap(maxSize), _size(0) {}
-
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(
-        key_t key, T value, Iterator *storedValue) {
-    if (_size == theMap.maxSize()) {
-        return MAP_FULL;
-    }
-    uint32_t position = findNicePlace(key);
-    // Compiler might emitt warning because std::pair is not a POD type (yet..)
-    // See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm#std::pair-example
-    // Circumvent warning by casting to void*
-    std::memmove(static_cast<void*>(&theMap[position + 1]),
-            static_cast<void*>(&theMap[position]),
-            (_size - position) * sizeof(std::pair<key_t,T>));
-    theMap[position].first = key;
-    theMap[position].second = value;
-    ++_size;
-    if (storedValue != nullptr) {
-        *storedValue = Iterator(&theMap[position]);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
+	size_t i;
+	if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+		return KEY_DOES_NOT_EXIST;
+	}
+	removeFromPosition(i);
+	if (*iter != begin()) {
+		(*iter)--;
+	} else {
+		*iter = begin();
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(
-        std::pair<key_t, T> pair) {
-    return insert(pair.fist, pair.second);
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
+	size_t i;
+	if ((i = findFirstIndex(key)) >= _size) {
+		return KEY_DOES_NOT_EXIST;
+	}
+	do {
+		removeFromPosition(i);
+		i = findFirstIndex(key, i);
+	} while (i < _size);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(
-        key_t key) const {
-    ReturnValue_t result = KEY_DOES_NOT_EXIST;
-    if (findFirstIndex(key) < _size) {
-        result = HasReturnvaluesIF::RETURN_OK;
-    }
-    return result;
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
+	ReturnValue_t result = exists(key);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	*value = &theMap[findFirstIndex(key)].second;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(
-        Iterator *iter)
-{
-    uint32_t i;
-    if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-        return KEY_DOES_NOT_EXIST;
-    }
-    removeFromPosition(i);
-    if (*iter != begin()) {
-        (*iter)--;
-    } else {
-        *iter = begin();
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
+	if (startAt >= _size) {
+		return startAt + 1;
+	}
+	size_t i = startAt;
+	for (i = startAt; i < _size; ++i) {
+		if (theMap[i].first == key) {
+			return i;
+		}
+	}
+	return i;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(
-        key_t key)
-{
-    uint32_t i;
-    if ((i = findFirstIndex(key)) >= _size) {
-        return KEY_DOES_NOT_EXIST;
-    }
-    do {
-        removeFromPosition(i);
-        i = findFirstIndex(key, i);
-    } while (i < _size);
-    return HasReturnvaluesIF::RETURN_OK;
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
+	size_t i = 0;
+	for (i = 0; i < _size; ++i) {
+		if (myComp(key, theMap[i].first)) {
+			return i;
+		}
+	}
+	return i;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(
-        key_t key, T **value) const
-{
-    ReturnValue_t result = exists(key);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    *value = &theMap[findFirstIndex(key)].second;
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
-FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(
-        key_t key) const
-{
-    ReturnValue_t result = exists(key);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return end();
-    }
-    return Iterator(&theMap[findFirstIndex(key)]);
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::clear()
-{
-    _size = 0;
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::maxSize() const
-{
-    return theMap.maxSize();
+inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
+	if (_size <= position) {
+		return;
+	}
+	memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
+			(_size - position - 1) * sizeof(std::pair<key_t,T>));
+	--_size;
 }
 
 

From 1ecca4b3d882fcbc704f21a0ed9f32c0e2d2524e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:33:50 +0200
Subject: [PATCH 0860/1774] taken over array list

---
 container/ArrayList.h | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 163185698..6bd5c1d5a 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -131,19 +131,6 @@ public:
 		const T *operator->() const {
 			return value;
 		}
-
-
-//		//SHOULDDO this should be implemented as non-member
-//		bool operator==(const typename
-//				ArrayList<T, count_t>::Iterator& other) const {
-//			return (value == other.value);
-//		}
-//
-//		//SHOULDDO this should be implemented as non-member
-//		bool operator!=(const typename
-//				ArrayList<T, count_t>::Iterator& other) const {
-//			return !(*this == other);
-//		}
 	};
 
 	friend bool operator==(const ArrayList::Iterator& lhs,

From 5fbb8f8ef02747e8c95c74f4301b369982a7b2f7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:35:13 +0200
Subject: [PATCH 0861/1774] taken over fixed array list from master

---
 container/FixedArrayList.h | 33 +++++++--------------------------
 1 file changed, 7 insertions(+), 26 deletions(-)

diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index da85c6233..e9e127cf0 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -1,51 +1,32 @@
 #ifndef FIXEDARRAYLIST_H_
 #define FIXEDARRAYLIST_H_
 
-#include "../container/ArrayList.h"
-
+#include "ArrayList.h"
+#include <cmath>
 /**
- * @brief 	Array List with a fixed maximum size
- * @ingroup container
+ * \ingroup container
  */
-template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
+template<typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList: public ArrayList<T, count_t> {
+	static_assert(MAX_SIZE <= (pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
 private:
 	T data[MAX_SIZE];
 public:
-	/**
-	 * (Robin) Maybe we should also implement move assignment and move ctor.
-	 * Or at least delete them.
-	 */
 	FixedArrayList() :
 			ArrayList<T, count_t>(data, MAX_SIZE) {
 	}
 
-	// (Robin): We could create a constructor to initialize the fixed array list
-	// with data and the known size field
-	// so it can be used for serialization too (with SerialFixedArrrayListAdapter)
-	// is this feasible?
-	/**
-	 * Initialize a fixed array list with data and number of data fields.
-	 * Endianness of entries can be swapped optionally.
-	 * @param data_
-	 * @param count
-	 * @param swapArrayListEndianess
-	 */
-	FixedArrayList(T * data_, count_t count):
-		ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, data_, count * sizeof(T));
-		this->size = count;
-	}
-
 	FixedArrayList(const FixedArrayList& other) :
 			ArrayList<T, count_t>(data, MAX_SIZE) {
 		memcpy(this->data, other.data, sizeof(this->data));
 		this->entries = data;
+		this->size = other.size;
 	}
 
 	FixedArrayList& operator=(FixedArrayList other) {
 		memcpy(this->data, other.data, sizeof(this->data));
 		this->entries = data;
+		this->size = other.size;
 		return *this;
 	}
 

From f2c07ee9c6268f255eca9f8cbb374f393cf1ef72 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:35:56 +0200
Subject: [PATCH 0862/1774] removed tests

---
 container/RingBufferTest.cpp.ignore |  79 ------
 container/listTest.cpp.ignore       | 365 ----------------------------
 2 files changed, 444 deletions(-)
 delete mode 100644 container/RingBufferTest.cpp.ignore
 delete mode 100644 container/listTest.cpp.ignore

diff --git a/container/RingBufferTest.cpp.ignore b/container/RingBufferTest.cpp.ignore
deleted file mode 100644
index d660e29c9..000000000
--- a/container/RingBufferTest.cpp.ignore
+++ /dev/null
@@ -1,79 +0,0 @@
-
-#include <iostream>
-#include "SimpleRingBuffer.h"
-
-
-int main() {
-	using namespace std;
-	SimpleRingBuffer buffer(64, false);
-	uint8_t data[8] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
-	ReturnValue_t result = buffer.writeData(data, 8);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	result = buffer.writeData(data, 8);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	uint8_t buffer2[47] = {0};
-	for (uint8_t count = 0; count<sizeof(buffer2); count++) {
-		buffer2[count] = count;
-	}
-	result = buffer.writeData(buffer2, sizeof(buffer2));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	result = buffer.writeData(buffer2, sizeof(buffer2));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	uint8_t readBuffer[64] = {0};
-	uint32_t writtenData = 0;
-	result = buffer.readData(readBuffer, 12, true, &writtenData);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "readData failed." << endl;
-	} else {
-		cout << "Read data: " << writtenData << endl;
-		for (uint32_t count = 0; count < writtenData; count++) {
-			cout << hex << (uint16_t)readBuffer[count] << " ";
-		}
-		cout << dec << endl;
-	}
-
-	result = buffer.readData(readBuffer, 60, true, &writtenData);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "readData failed." << endl;
-	} else {
-		cout << "Read data: " << writtenData << endl;
-		for (uint32_t count = 0; count < writtenData; count++) {
-			cout << hex << (uint16_t)readBuffer[count] << " ";
-		}
-		cout << dec << endl;
-	}
-	result = buffer.writeData(data, sizeof(data));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	result = buffer.readData(readBuffer, 60, true, &writtenData);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "readData failed." << endl;
-	} else {
-		cout << "Read data: " << writtenData << endl;
-		for (uint32_t count = 0; count < writtenData; count++) {
-			cout << hex << (uint16_t)readBuffer[count] << " ";
-		}
-		cout << dec << endl;
-	}
-	result = buffer.writeData(readBuffer, sizeof(readBuffer));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	}
-	result = buffer.writeData(readBuffer, sizeof(readBuffer)-1);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		cout << "writeData failed." << endl;
-	} else {
-		cout << "write done." << endl;
-	}
-}
-
-
diff --git a/container/listTest.cpp.ignore b/container/listTest.cpp.ignore
deleted file mode 100644
index 257b733f5..000000000
--- a/container/listTest.cpp.ignore
+++ /dev/null
@@ -1,365 +0,0 @@
-#include "FixedArrayList.h"
-#include "SinglyLinkedList.h"
-#include "HybridIterator.h"
-
-#include "FixedMap.h"
-
-#include <stdio.h>
-
-/*
-
-class Packet: public SinglyLinkedList {
-public:
-	SinglyLinkedList::Element<uint32_t> element1;
-	SinglyLinkedList::Element<uint32_t> element2;
-
-	Packet() {
-		this->start = &element1;
-		element1.next = &element2;
-	}
-};
-
-class Packet2: public SinglyLinkedList {
-public:
-	SinglyLinkedList::Element<uint32_t> element1;
-	SinglyLinkedList::Element<FixedArrayList<FixedArrayList<uint8_t, 5>, 2>> element2;
-	SinglyLinkedList::Element<uint32_t> element3;
-
-	Packet2() {
-		this->start = &element1;
-		element1.next = &element2;
-		element2.next = &element3;
-	}
-};
-
-class Packet3: public SinglyLinkedList {
-public:
-	SinglyLinkedList::TypedElement<uint32_t> element1;
-	SinglyLinkedList::TypedElement<uint32_t> element2;
-
-	Packet3() {
-		this->start = &element1;
-		element1.next = &element2;
-	}
-};
-
-void arrayList() {
-	puts("** Array List **");
-	FixedArrayList<uint32_t, 10, uint32_t> list;
-	FixedArrayList<uint32_t, 10, uint32_t> list2;
-
-	list.size = 2;
-
-	list[0] = 0xcafecafe;
-
-	list[1] = 0x12345678;
-
-	uint8_t buffer[100];
-	uint8_t *pointer = buffer;
-	uint32_t size = 0;
-	uint32_t maxSize = 100;
-	uint32_t i;
-	int32_t size2;
-
-	printf("printsize: %i\n", list.getPrintSize());
-
-	list.print(&pointer, &size, 100, true);
-
-	printf("buffer(%i):", size);
-	for (i = 0; i < size; ++i) {
-		printf("%02x", buffer[i]);
-	}
-	printf("\n");
-
-	pointer = buffer;
-
-	size2 = size;
-
-	printf("list2 read: %x\n", list2.read(&pointer, &size2, true));
-
-	printf("list2(%i):", list2.size);
-	for (ArrayList<uint32_t, uint32_t>::Iterator iter = list2.begin();
-			iter != list2.end(); iter++) {
-		printf("0x%04x ", *iter);
-	}
-	printf("\n");
-
-	HybridIterator<uint32_t, uint32_t> hiter(list.begin(),list.end());
-
-	printf("hybrid1: 0x%04x\n", *(hiter++));
-	printf("hybrid2: 0x%04x\n", *hiter);
-
-}
-
-void allocatingList() {
-	puts("** Allocating List **");
-	ArrayList<uint8_t> myList(3), myList2(2);
-	myList[0] = 0xab;
-	myList[1] = 0xcd;
-	myList.size = 2;
-
-	uint8_t buffer[100];
-	uint8_t *pointer = buffer;
-	uint32_t size = 0;
-	uint32_t maxSize = 100;
-	uint32_t i;
-	int32_t size2;
-
-	myList.print(&pointer, &size, 100, true);
-
-	pointer = buffer;
-	size2 = size;
-
-	printf("Read %x\n", myList2.read(&pointer, &size2, true));
-
-	printf("%x,%x\n", myList2[0], myList2[1]);
-
-}
-
-void linkedList() {
-	puts("** Linked List **");
-	uint8_t buffer[100];
-	uint8_t *pointer = buffer;
-	uint32_t size = 0;
-	uint32_t maxSize = 100;
-	uint32_t i;
-	int32_t size2;
-
-	Packet myPacket;
-	myPacket.element1.entry = 0x12345678;
-	myPacket.element2.entry = 0x9abcdef0;
-
-	pointer = buffer;
-	size = 0;
-	ReturnValue_t result = myPacket.print(&pointer, &size, 100, true);
-
-	printf("result %02x\n", result);
-
-	printf("printsize: %i\n", myPacket.getPrintSize());
-
-	printf("buffer(%i):", size);
-	for (i = 0; i < size; ++i) {
-		printf("%02x", buffer[i]);
-	}
-	printf("\n");
-
-	Packet3 myPacket3;
-
-	myPacket3.element1.entry = 0x12345678;
-	myPacket3.element2.entry = 0xabcdeff;
-
-	SinglyLinkedList::TypedIterator<uint32_t> titer(&myPacket3.element1);
-
-	printf("0x%04x\n", *titer);
-
-	HybridIterator<uint32_t, uint32_t> hiter(&myPacket3.element1);
-
-	printf("hybrid1: 0x%04x\n", *hiter);
-	hiter++;
-	printf("hybrid2: 0x%04x\n", *hiter);
-}
-
-void complex() {
-	puts("** complex **");
-	uint8_t buffer[100];
-	uint8_t *pointer = buffer;
-	uint32_t size = 0;
-	uint32_t maxSize = 100;
-	uint32_t i;
-	int32_t size2 = size;
-
-	Packet myPacket2;
-
-	size2 = size;
-	pointer = buffer;
-
-	myPacket2.read(&pointer, &size2, true);
-
-	printf("packet: 0x%04x, 0x%04x\n", myPacket2.element1.entry,
-			myPacket2.element2.entry);
-
-	buffer[0] = 0x12;
-	buffer[1] = 0x34;
-	buffer[2] = 0x56;
-	buffer[3] = 0x78;
-	buffer[4] = 0x2;
-	buffer[5] = 0x3;
-	buffer[6] = 0xab;
-	buffer[7] = 0xcd;
-	buffer[8] = 0xef;
-	buffer[9] = 0x2;
-	buffer[10] = 0x11;
-	buffer[11] = 0x22;
-	buffer[12] = 0xca;
-	buffer[13] = 0xfe;
-	buffer[14] = 0x5a;
-	buffer[15] = 0xfe;
-
-	pointer = buffer;
-	size2 = 23;
-
-	Packet2 p2;
-
-	ReturnValue_t result = p2.read(&pointer, &size2, true);
-	printf("result is %02x\n", result);
-
-	printf("%04x; %i: %i: %x %x %x; %i: %x %x;; %04x\n", p2.element1.entry,
-			p2.element2.entry.size, p2.element2.entry[0].size,
-			p2.element2.entry[0][0], p2.element2.entry[0][1],
-			p2.element2.entry[0][2], p2.element2.entry[1].size,
-			p2.element2.entry[1][0], p2.element2.entry[1][1],
-			p2.element3.entry);
-
-}
-*/
-struct Test {
-	uint32_t a;
-	uint32_t b;
-};
-
-template<typename key_t, typename T>
-void printMap(FixedMap<key_t, T> *map) {
-	typename FixedMap<key_t, T>::Iterator iter;
-	printf("Map (%i): ", map->getSize());
-	for (iter = map->begin(); iter != map->end(); ++iter) {
-		printf("%x:%08x,%08x ", iter.value->first, (*iter).a, (*iter).b);
-	}
-	printf("\n");
-}
-
-template<typename T>
-void map() {
-	puts("** Map **");
-	typename FixedMap<T, Test>::Iterator iter;
-	ReturnValue_t result;
-	FixedMap<T, Test> myMap(5);
-
-	printMap<T, Test>(&myMap);
-
-	Test a;
-	a.a = 0x01234567;
-	a.b = 0xabcdef89;
-
-	myMap.insert(1, a);
-	printMap<T, Test>(&myMap);
-
-	a.a = 0;
-
-	myMap.insert(2, a);
-	printMap<T, Test>(&myMap);
-
-	printf("2 exists: %x\n", myMap.exists(0x02));
-
-	printf("ff exists: %x\n", myMap.exists(0xff));
-
-	a.a = 1;
-	printf("insert 0x2: %x\n", myMap.insert(2, a));
-
-	result = myMap.insert(0xff, a);
-	a.a = 0x44;
-	result = myMap.insert(0xab, a);
-	result = myMap.insert(0xa, a);
-
-	printMap<T, Test>(&myMap);
-
-	printf("insert 0x5: %x\n", myMap.insert(5, a));
-
-	printf("erase 0xfe: %x\n", myMap.erase(0xfe));
-
-	printf("erase 0x2: %x\n", myMap.erase(0x2));
-
-	printMap<T, Test>(&myMap);
-
-	printf("erase 0xab: %x\n", myMap.erase(0xab));
-	printMap<T, Test>(&myMap);
-
-	printf("insert 0x5: %x\n", myMap.insert(5, a));
-	printMap<T, Test>(&myMap);
-
-	iter = myMap.begin();
-	++iter;
-	++iter;
-	++iter;
-
-	printf("iter: %i: %x,%x\n",iter.value->first, iter->a, iter->b);
-
-	myMap.erase(&iter);
-
-	printf("iter: %i: %x,%x\n",iter.value->first, iter->a, iter->b);
-	printMap<T, Test>(&myMap);
-
-}
-
-/*
-void mapPrint() {
-	puts("** Map Print **");
-	FixedMap<uint16_t, Packet2> myMap(5);
-	Packet2 myPacket;
-	myPacket.element1.entry = 0x12345678;
-
-	myPacket.element2.entry[0][0] = 0xab;
-	myPacket.element2.entry[0][1] = 0xcd;
-	myPacket.element2.entry[0].size = 2;
-	myPacket.element2.entry.size = 1;
-
-	myPacket.element3.entry = 0xabcdef90;
-
-	myMap.insert(0x1234, myPacket);
-
-	uint8_t buffer[100];
-	uint32_t size = 0, i;
-	uint8_t *pointer = buffer;
-
-	printf("printsize: %i\n", myMap.getPrintSize());
-
-	SerializeAdapter<FixedMap<uint16_t, Packet2>>::print(&myMap, &pointer,
-			&size, 100, false);
-
-	printf("buffer(%i):", size);
-	for (i = 0; i < size; ++i) {
-		printf("%02x", buffer[i]);
-	}
-	printf("\n");
-
-	int32_t size2 = size;
-	pointer = buffer;
-
-	FixedMap<uint16_t, Packet2> myMap2(5);
-
-	ReturnValue_t result = SerializeAdapter<FixedMap<uint16_t, Packet2>>::read(
-			&myMap2, &pointer, &size2, false);
-
-	Packet2 *myPacket2 = myMap2.find(0x1234);
-
-	printf("Map (%i): Packet2: %x, Array (%i): Array (%i): %x, %x; %x\n",
-			myMap2.getSize(), myPacket2->element1.entry,
-			myPacket2->element2.entry.size, myPacket2->element2.entry[0].size,
-			myPacket2->element2.entry[0][0], myPacket2->element2.entry[0][1],
-			myPacket2->element3.entry);
-
-}
-
-void empty() {
-	puts("** Empty **");
-	ArrayList<uint32_t> list(0);
-	printf("%p %p\n", list.front(), list.back());
-}
-*/
-
-int main(void) {
-
-//	arrayList();
-//	linkedList();
-//	allocatingList();
-//	complex();
-
-	map<uint32_t>();
-//
-//	mapPrint();
-
-//	empty();
-
-
-
-	return 0;
-}

From 148bbb4be4ef309ac023631782064140fa8d5966 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:36:43 +0200
Subject: [PATCH 0863/1774] master taken over

---
 container/FixedMap.h | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 1e36b1bc2..7a5220faa 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -154,22 +154,22 @@ public:
 	}
 
 	bool empty() {
-		if(_size == 0) {
-			return true;
-		}
-		else {
-			return false;
-		}
+	    if(_size == 0) {
+	        return true;
+	    }
+	    else {
+	        return false;
+	    }
 	}
 
-    bool full() {
-        if(_size >= theMap.maxSize()) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
+	bool full() {
+	    if(_size >= theMap.maxSize()) {
+	        return true;
+	    }
+	    else {
+	        return false;
+	    }
+	}
 
 	void clear() {
 		_size = 0;

From bf3276cbb2545c1773b1478569703dda9bb402d1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:40:02 +0200
Subject: [PATCH 0864/1774] taken over master

---
 container/RingBufferBase.h     | 8 ++++----
 container/SimpleRingBuffer.cpp | 6 +-----
 container/SimpleRingBuffer.h   | 9 +++++----
 container/SinglyLinkedList.h   | 2 +-
 4 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 243a2915e..886b9fab9 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
-#define FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
+#ifndef FSFW_CONTAINER_RINGBUFFERBASE_H_
+#define FSFW_CONTAINER_RINGBUFFERBASE_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
@@ -65,6 +65,7 @@ protected:
 	size_t read[N_READ_PTRS];
 	const size_t size;
 	const bool overwriteOld;
+
 	void incrementWrite(uint32_t amount) {
 		write = ((write + amount - start) % size) + start;
 	}
@@ -90,7 +91,6 @@ protected:
 		}
 	}
 
-
 	size_t getRead(uint8_t n = 0) const {
 		return read[n];
 	}
@@ -110,4 +110,4 @@ protected:
 	}
 };
 
-#endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
+#endif /* FSFW_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index d6b6f5aff..88c9290ef 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -1,4 +1,4 @@
-#include "../container/SimpleRingBuffer.h"
+#include "SimpleRingBuffer.h"
 #include <cstring>
 
 SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
@@ -25,12 +25,10 @@ SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
 	}
 }
 
-
 SimpleRingBuffer::~SimpleRingBuffer() {
 	delete[] buffer;
 }
 
-
 ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
         size_t amount) {
     if (availableWriteSpace() >= amount or overwriteOld) {
@@ -131,5 +129,3 @@ ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
 	incrementRead(amount, READ_PTR);
 	return HasReturnvaluesIF::RETURN_OK;
 }
-
-
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index dcf2684bd..37ad5679f 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
+#ifndef FSFW_CONTAINER_SIMPLERINGBUFFER_H_
+#define FSFW_CONTAINER_SIMPLERINGBUFFER_H_
 
-#include "../container/RingBufferBase.h"
+#include "RingBufferBase.h"
 #include <cstddef>
 
 /**
@@ -117,6 +117,7 @@ public:
 	 */
 	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
 	        size_t* trueAmount = nullptr);
+
 private:
 	static const uint8_t READ_PTR = 0;
 	uint8_t* buffer = nullptr;
@@ -124,5 +125,5 @@ private:
 	size_t excessBytes = 0;
 };
 
-#endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */
+#endif /* FSFW_CONTAINER_SIMPLERINGBUFFER_H_ */
 
diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 7d5fc4a9d..eb6ae276a 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -100,7 +100,7 @@ public:
 	 */
 	ElementIterator back() const {
 	    LinkedElement<T> *element = start;
-	    while (element != nullptr) {
+	    while (element->getNext() != nullptr) {
 	        element = element->getNext();
 	    }
 	    return ElementIterator::Iterator(element);

From 0b1b159582b7b3234fdb926f4a1cb4fb875ad69d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:40:45 +0200
Subject: [PATCH 0865/1774] taken over master

---
 action/ActionHelper.cpp       | 2 +-
 action/SimpleActionHelper.cpp | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 70c3f0fca..361f7dc34 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -1,6 +1,6 @@
-#include <fsfw/ipc/MessageQueueSenderIF.h>
 #include "ActionHelper.h"
 #include "HasActionsIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
 ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index 51e3fa1c2..d79a3c977 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -1,6 +1,5 @@
 #include "HasActionsIF.h"
 #include "SimpleActionHelper.h"
-
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
 		MessageQueueIF* useThisQueue) :
 		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(

From f9e6b9facac4e9f8c4c7a261f4bccf04337c1f07 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:42:28 +0200
Subject: [PATCH 0866/1774] taken over master

---
 fdir/ConfirmsFailuresIF.h     | 1 -
 fdir/EventCorrelation.cpp     | 2 +-
 fdir/FailureIsolationBase.cpp | 2 +-
 fdir/FailureIsolationBase.h   | 4 ++--
 fdir/FaultCounter.cpp         | 2 +-
 5 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/fdir/ConfirmsFailuresIF.h b/fdir/ConfirmsFailuresIF.h
index 6cb2c47de..144114612 100644
--- a/fdir/ConfirmsFailuresIF.h
+++ b/fdir/ConfirmsFailuresIF.h
@@ -4,7 +4,6 @@
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 
-// TODO: Documentation.
 class ConfirmsFailuresIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::HANDLES_FAILURES_IF;
diff --git a/fdir/EventCorrelation.cpp b/fdir/EventCorrelation.cpp
index f98d22236..d60fc6ca3 100644
--- a/fdir/EventCorrelation.cpp
+++ b/fdir/EventCorrelation.cpp
@@ -1,4 +1,4 @@
-#include "../fdir/EventCorrelation.h"
+#include "EventCorrelation.h"
 
 EventCorrelation::EventCorrelation(uint32_t timeout) :
 		eventPending(false) {
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index ab462a97d..f3b34f0fb 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -1,5 +1,5 @@
 #include "../events/EventManagerIF.h"
-#include "../fdir/FailureIsolationBase.h"
+#include "FailureIsolationBase.h"
 #include "../health/HasHealthIF.h"
 #include "../health/HealthMessage.h"
 #include "../ipc/QueueFactory.h"
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index f8a307b33..5b2c099ae 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -2,8 +2,8 @@
 #define FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
 
 #include "../events/EventMessage.h"
-#include "../fdir/ConfirmsFailuresIF.h"
-#include "../fdir/FaultCounter.h"
+#include "ConfirmsFailuresIF.h"
+#include "FaultCounter.h"
 #include "../health/HealthMessage.h"
 #include "../parameters/HasParametersIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
diff --git a/fdir/FaultCounter.cpp b/fdir/FaultCounter.cpp
index b75bd48fd..443adb52e 100644
--- a/fdir/FaultCounter.cpp
+++ b/fdir/FaultCounter.cpp
@@ -1,4 +1,4 @@
-#include "../fdir/FaultCounter.h"
+#include "FaultCounter.h"
 
 FaultCounter::FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
 		uint8_t setParameterDomain) :

From af038d0a2f04c30cd4bfbe6ff3811afdc2740ddc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:44:27 +0200
Subject: [PATCH 0867/1774] master taken over

---
 globalfunctions/AsciiConverter.cpp                | 2 +-
 globalfunctions/CRC.cpp                           | 2 +-
 globalfunctions/DleEncoder.cpp                    | 2 +-
 globalfunctions/DleEncoder.h                      | 8 ++++----
 globalfunctions/arrayprinter.cpp                  | 4 ++--
 globalfunctions/matching/BinaryMatcher.h          | 2 +-
 globalfunctions/matching/DecimalMatcher.h         | 2 +-
 globalfunctions/matching/MatchTree.h              | 2 +-
 globalfunctions/matching/RangeMatcher.h           | 2 +-
 globalfunctions/matching/SerializeableMatcherIF.h | 2 +-
 globalfunctions/math/QuaternionOperations.cpp     | 2 +-
 11 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/globalfunctions/AsciiConverter.cpp b/globalfunctions/AsciiConverter.cpp
index c57125e26..9eb3698fb 100644
--- a/globalfunctions/AsciiConverter.cpp
+++ b/globalfunctions/AsciiConverter.cpp
@@ -1,4 +1,4 @@
-#include "../globalfunctions/AsciiConverter.h"
+#include "AsciiConverter.h"
 #include <limits>
 #include <cmath>
 
diff --git a/globalfunctions/CRC.cpp b/globalfunctions/CRC.cpp
index 1258b6989..7bb568066 100644
--- a/globalfunctions/CRC.cpp
+++ b/globalfunctions/CRC.cpp
@@ -1,4 +1,4 @@
-#include "../globalfunctions/CRC.h"
+#include "CRC.h"
 #include <math.h>
 
 const uint16_t CRC::crc16ccitt_table[256] = {
diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index 6bd402d7e..8520389d2 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -92,7 +92,7 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 			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 preven having control chars,
+				 * 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;
diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index 3c535d1f3..6d073f9a2 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -15,12 +15,12 @@
  * 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 occurences in the source stream are
+ * 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 enoded with DLE,
+ * 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.
  */
@@ -38,7 +38,7 @@ public:
 	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 occurences
+	//! 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;
@@ -47,7 +47,7 @@ public:
      * 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 decoing process).
+     * 0x40 (which is reverted in the decoding process).
      * @param sourceStream
      * @param sourceLen
      * @param destStream
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index fa89c0dcd..b1e888c55 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -1,4 +1,4 @@
-#include "../globalfunctions/arrayprinter.h"
+#include "arrayprinter.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include <bitset>
 
@@ -27,7 +27,7 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 		if(i < size - 1){
 			sif::info << " , ";
 			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << "\r\n" << std::flush;
+				sif::info << std::endl;
 			}
 		}
 
diff --git a/globalfunctions/matching/BinaryMatcher.h b/globalfunctions/matching/BinaryMatcher.h
index 550439ab6..4f6db85d8 100644
--- a/globalfunctions/matching/BinaryMatcher.h
+++ b/globalfunctions/matching/BinaryMatcher.h
@@ -1,7 +1,7 @@
 #ifndef BINARYMATCHER_H_
 #define BINARYMATCHER_H_
 
-#include "../../globalfunctions/matching/MatcherIF.h"
+#include "MatcherIF.h"
 
 template<typename T>
 class BinaryMatcher: public MatcherIF<T> {
diff --git a/globalfunctions/matching/DecimalMatcher.h b/globalfunctions/matching/DecimalMatcher.h
index 3c765cd7c..535050205 100644
--- a/globalfunctions/matching/DecimalMatcher.h
+++ b/globalfunctions/matching/DecimalMatcher.h
@@ -1,7 +1,7 @@
 #ifndef DECIMALMATCHER_H_
 #define DECIMALMATCHER_H_
 
-#include "../../globalfunctions/matching/MatcherIF.h"
+#include "MatcherIF.h"
 
 template<typename T>
 class DecimalMatcher: public MatcherIF<T> {
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 46245c25c..755687b28 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
 
 #include "../../container/BinaryTree.h"
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "SerializeableMatcherIF.h"
 #include "../../serialize/SerializeAdapter.h"
 
 template<typename T>
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index 04c9c3fac..b64b9e30b 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -1,7 +1,7 @@
 #ifndef RANGEMATCHER_H_
 #define RANGEMATCHER_H_
 
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "SerializeableMatcherIF.h"
 #include "../../serialize/SerializeAdapter.h"
 
 template<typename T>
diff --git a/globalfunctions/matching/SerializeableMatcherIF.h b/globalfunctions/matching/SerializeableMatcherIF.h
index f99c69642..067b0251a 100644
--- a/globalfunctions/matching/SerializeableMatcherIF.h
+++ b/globalfunctions/matching/SerializeableMatcherIF.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
 #define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
 
-#include "../../globalfunctions/matching/MatcherIF.h"
+#include "MatcherIF.h"
 #include "../../serialize/SerializeIF.h"
 
 template<typename T>
diff --git a/globalfunctions/math/QuaternionOperations.cpp b/globalfunctions/math/QuaternionOperations.cpp
index c6778de4a..c09426daa 100644
--- a/globalfunctions/math/QuaternionOperations.cpp
+++ b/globalfunctions/math/QuaternionOperations.cpp
@@ -1,5 +1,5 @@
 #include "QuaternionOperations.h"
-#include "../../globalfunctions/math/VectorOperations.h"
+#include "VectorOperations.h"
 
 #include <cmath>
 #include <cstring>

From 55a4c0423db264b8a1d16bd7bc8abb527d9a9597 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:45:28 +0200
Subject: [PATCH 0868/1774] typo

---
 memory/AcceptsMemoryMessagesIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/memory/AcceptsMemoryMessagesIF.h b/memory/AcceptsMemoryMessagesIF.h
index cf8aa5ecb..7491f47d4 100644
--- a/memory/AcceptsMemoryMessagesIF.h
+++ b/memory/AcceptsMemoryMessagesIF.h
@@ -11,4 +11,4 @@ public:
 };
 
 
-#endif /* AFSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_ */
+#endif /* FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_ */

From 0c1c61558ba2d2c831260d4a6be51cc9b90a1ee4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 3 Oct 2020 03:45:29 +0200
Subject: [PATCH 0869/1774] very important bugfix

---
 tcdistribution/PUSDistributor.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 3baef7d10..63d1dcde5 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -17,8 +17,11 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
     //          << this->current_packet_id.store_index << ", "
     //          << this->current_packet_id.packet_index << std::endl;
     TcMqMapIter queueMapIt = this->queueMap.end();
+    if(this->currentPacket == nullptr) {
+        return queueMapIt;
+    }
     this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
-    if (currentPacket->getWholeData() != NULL) {
+    if (currentPacket->getWholeData() != nullptr) {
         tcStatus = checker.checkPacket(currentPacket);
 #ifdef DEBUG
         if(tcStatus != HasReturnvaluesIF::RETURN_OK) {
@@ -94,6 +97,7 @@ uint16_t PUSDistributor::getIdentifier() {
 ReturnValue_t PUSDistributor::initialize() {
 	CCSDSDistributorIF* ccsdsDistributor =
 			objectManager->get<CCSDSDistributorIF>(packetSource);
+	currentPacket = new TcPacketStored();
 	if (ccsdsDistributor == nullptr) {
 		sif::error << "PUSDistributor::initialize: Packet source invalid."
 		        << " Make sure it exists and implements CCSDSDistributorIF!"
@@ -103,6 +107,4 @@ ReturnValue_t PUSDistributor::initialize() {
 	else {
 		return ccsdsDistributor->registerApplication(this);
 	}
-
-	currentPacket = new TcPacketStored();
 }

From 20c261514b672d3919c036c85702d71fe107723e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 4 Oct 2020 14:31:06 +0200
Subject: [PATCH 0870/1774] made message interface more readable (dec instead
 hex)

---
 memory/FileSystemMessage.cpp | 18 ++++++-----------
 memory/FileSystemMessage.h   | 38 +++++++++++++++++++++---------------
 2 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index 416f646c8..b01e1fc68 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -2,46 +2,40 @@
 #include "../objectmanager/ObjectManagerIF.h"
 
 
-ReturnValue_t FileSystemMessage::setDeleteFileCommand(
+void FileSystemMessage::setDeleteFileCommand(
 		CommandMessage* message, store_address_t storageID) {
 	message->setCommand(DELETE_FILE);
 	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t FileSystemMessage::setCreateDirectoryCommand(
+void FileSystemMessage::setCreateDirectoryCommand(
 		CommandMessage* message, store_address_t storageID) {
 	message->setCommand(CREATE_DIRECTORY);
 	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t FileSystemMessage::setDeleteDirectoryCommand(
+void FileSystemMessage::setDeleteDirectoryCommand(
 		CommandMessage* message, store_address_t storageID) {
 	message->setCommand(DELETE_DIRECTORY);
 	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t FileSystemMessage::setWriteCommand(CommandMessage* message,
+void FileSystemMessage::setWriteCommand(CommandMessage* message,
 		store_address_t storageID) {
 	message->setCommand(WRITE);
 	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t FileSystemMessage::setReadCommand(CommandMessage* message,
+void FileSystemMessage::setReadCommand(CommandMessage* message,
 		store_address_t storageID) {
 	message->setCommand(READ);
 	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t FileSystemMessage::setReadReply(CommandMessage* message,
+void FileSystemMessage::setReadReply(CommandMessage* message,
 		store_address_t storageID) {
 	message->setCommand(READ_REPLY);
 	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
 store_address_t FileSystemMessage::getStoreId(const CommandMessage* message) {
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index d3dbd83c8..a56abb9c2 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -13,26 +13,32 @@ private:
 	FileSystemMessage(); //A private ctor inhibits instantiation
 public:
 	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
-	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
-	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
-	static const Command_t CREATE_DIRECTORY = MAKE_COMMAND_ID( 0x09 );
-	static const Command_t DELETE_DIRECTORY = MAKE_COMMAND_ID( 0x0A );
-	static const Command_t WRITE = MAKE_COMMAND_ID( 0x80 );
-	static const Command_t READ = MAKE_COMMAND_ID( 0x81 );
-	static const Command_t READ_REPLY = MAKE_COMMAND_ID( 0x82 );
+	static const Command_t CREATE_FILE = MAKE_COMMAND_ID(1);
+	static const Command_t DELETE_FILE = MAKE_COMMAND_ID(2);
+	static const Command_t CREATE_DIRECTORY = MAKE_COMMAND_ID(9);
+	static const Command_t DELETE_DIRECTORY = MAKE_COMMAND_ID(10);
+	static const Command_t WRITE = MAKE_COMMAND_ID(128);
+	static const Command_t READ = MAKE_COMMAND_ID(129);
+	static const Command_t READ_REPLY = MAKE_COMMAND_ID(130);
 	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
 	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
 
-	static ReturnValue_t setDeleteFileCommand(CommandMessage* message, store_address_t storageID);
-	static ReturnValue_t setCreateDirectoryCommand(CommandMessage* message, store_address_t storageID);
-	static ReturnValue_t setDeleteDirectoryCommand(CommandMessage* message, store_address_t storageID);
-	static ReturnValue_t setWriteCommand(CommandMessage* message, store_address_t storageID);
-	static ReturnValue_t setReadCommand(CommandMessage* message, store_address_t storageID);
-	static ReturnValue_t setReadReply(CommandMessage* message, store_address_t storageID);
-	static store_address_t getStoreId( const CommandMessage* message );
-	static void setSuccessReply(CommandMessage* message);
-	static void setFailureReply(CommandMessage* message, ReturnValue_t errorCode);
+	static void setDeleteFileCommand(CommandMessage* message,
+	        store_address_t storeId);
+	static void setCreateDirectoryCommand(CommandMessage* message,
+	        store_address_t storeId);
+	static void setDeleteDirectoryCommand(CommandMessage* message,
+	        store_address_t storeId);
+	static void setWriteCommand(CommandMessage* message,
+	        store_address_t storeId);
+	static void setReadCommand(CommandMessage* message,
+	        store_address_t storeId);
+	static void setReadReply(CommandMessage* message, store_address_t storeId);
+    static void setSuccessReply(CommandMessage* message);
+    static void setFailureReply(CommandMessage* message,
+            ReturnValue_t errorCode);
 
+	static store_address_t getStoreId(const CommandMessage* message);
 	static ReturnValue_t getFailureReply(const CommandMessage* message);
 };
 

From 2b1029916bab936cd7553d8c93f5300abeefe495 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 4 Oct 2020 15:55:39 +0200
Subject: [PATCH 0871/1774] using deletei nstead

---
 memory/FileSystemMessage.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index a56abb9c2..c098d4073 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -9,9 +9,10 @@
  * @author  Jakob Meier
  */
 class FileSystemMessage {
-private:
-	FileSystemMessage(); //A private ctor inhibits instantiation
 public:
+    // Instantiation forbidden
+	FileSystemMessage() = delete;
+
 	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
 	static const Command_t CREATE_FILE = MAKE_COMMAND_ID(1);
 	static const Command_t DELETE_FILE = MAKE_COMMAND_ID(2);

From a8a6d448ecc601fc74cefbc7b80736985b8ca06b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 4 Oct 2020 23:24:36 +0200
Subject: [PATCH 0872/1774] added subservices

---
 memory/FileSystemMessage.cpp | 11 ++++++++--
 memory/FileSystemMessage.h   | 41 ++++++++++++++++++++++++++++++------
 2 files changed, 44 insertions(+), 8 deletions(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index b01e1fc68..b9c426a85 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -22,13 +22,13 @@ void FileSystemMessage::setDeleteDirectoryCommand(
 
 void FileSystemMessage::setWriteCommand(CommandMessage* message,
 		store_address_t storageID) {
-	message->setCommand(WRITE);
+	message->setCommand(APPEND_TO_FILE);
 	message->setParameter2(storageID.raw);
 }
 
 void FileSystemMessage::setReadCommand(CommandMessage* message,
 		store_address_t storageID) {
-	message->setCommand(READ);
+	message->setCommand(READ_FROM_FILE);
 	message->setParameter2(storageID.raw);
 }
 
@@ -38,6 +38,12 @@ void FileSystemMessage::setReadReply(CommandMessage* message,
 	message->setParameter2(storageID.raw);
 }
 
+void FileSystemMessage::setCreateFileCommand(CommandMessage *message,
+        store_address_t storeId) {
+    message->setCommand(CREATE_FILE);
+    message->setParameter2(storeId.raw);
+}
+
 store_address_t FileSystemMessage::getStoreId(const CommandMessage* message) {
 	store_address_t temp;
 	temp.raw = message->getParameter2();
@@ -58,3 +64,4 @@ ReturnValue_t FileSystemMessage::getFailureReply(
 		const CommandMessage *message) {
 	return message->getParameter();
 }
+
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index c098d4073..4d77fd167 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -14,16 +14,45 @@ public:
 	FileSystemMessage() = delete;
 
 	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
+	/* PUS standard  (ECSS-E-ST-70-41C15 2016 p.654) */
 	static const Command_t CREATE_FILE = MAKE_COMMAND_ID(1);
 	static const Command_t DELETE_FILE = MAKE_COMMAND_ID(2);
+	/** Report file attributes */
+	static const Command_t REPORT_FILE_ATTRIBUTES = MAKE_COMMAND_ID(3);
+	static const Command_t FILE_ATTRIBUTES_REPLY = MAKE_COMMAND_ID(4);
+	/** Command to lock a file, setting it read-only */
+	static const Command_t LOCK_FILE = MAKE_COMMAND_ID(5);
+	/** Command to unlock a file, enabling further operations on it */
+	static const Command_t UNLOCK_FILE = MAKE_COMMAND_ID(6);
+	/**
+	 * Find file in repository, using a search pattern.
+	 * Please note that * is the wildcard character.
+	 * For example, when looking for all files which start with have the
+	 * structure tm<something>.bin, tm*.bin can be used.
+	 */
+	static const Command_t FIND_FILE = MAKE_COMMAND_ID(7);
 	static const Command_t CREATE_DIRECTORY = MAKE_COMMAND_ID(9);
-	static const Command_t DELETE_DIRECTORY = MAKE_COMMAND_ID(10);
-	static const Command_t WRITE = MAKE_COMMAND_ID(128);
-	static const Command_t READ = MAKE_COMMAND_ID(129);
-	static const Command_t READ_REPLY = MAKE_COMMAND_ID(130);
-	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
-	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
+    static const Command_t DELETE_DIRECTORY = MAKE_COMMAND_ID(10);
+	static const Command_t RENAME_DIRECTORY = MAKE_COMMAND_ID(11);
 
+	/** Dump contents of a repository */
+	static const Command_t DUMP_REPOSITORY = MAKE_COMMAND_ID(12);
+	/** Repository dump reply */
+	static const Command_t DUMY_REPOSITORY_REPLY = MAKE_COMMAND_ID(13);
+
+    static const Command_t APPEND_TO_FILE = MAKE_COMMAND_ID(128);
+    static const Command_t READ_FROM_FILE = MAKE_COMMAND_ID(129);
+    static const Command_t READ_REPLY = MAKE_COMMAND_ID(130);
+
+    /** Dump the structure of the whole SD card as an ASCII file */
+    static const Command_t DUMP_FILE_STRUCTURE = MAKE_COMMAND_ID(131);
+
+
+	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(150);
+	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(151);
+
+	static void setCreateFileCommand(CommandMessage* message,
+	        store_address_t storeId);
 	static void setDeleteFileCommand(CommandMessage* message,
 	        store_address_t storeId);
 	static void setCreateDirectoryCommand(CommandMessage* message,

From f955cd9eee41ad52eb854f8fb8cca4b040dba181 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 4 Oct 2020 23:37:22 +0200
Subject: [PATCH 0873/1774] made interface more generic

---
 memory/HasFileSystemIF.h | 40 +++++++++++++++++++++++++++++++---------
 1 file changed, 31 insertions(+), 9 deletions(-)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 916169ee6..e270f256a 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -29,22 +29,44 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
 	/**
-	 * Function to write to a file
+	 * Generic function to append to file.
 	 * @param dirname Directory of the file
 	 * @param filename The filename of the file
 	 * @param data The data to write to the file
 	 * @param size The size of the data to write
-	 * @param packetNumber Counts the number of packets.
+	 * @param packetNumber Current packet number. Can be used to verify that
+	 * there are no missing packets.
+	 * @param args Any other arguments which an implementation might require.
+	 * @param bytesWritten Actual bytes written to file
 	 * For large files the write procedure must be split in multiple calls
 	 * to writeToFile
 	 */
-	virtual ReturnValue_t writeToFile(const char* dirname, const char* filename,
-	        const uint8_t* data, size_t size, uint16_t packetNumber) = 0;
-	virtual ReturnValue_t createFile(const char* dirname, const char* filename,
-	        const uint8_t* data = nullptr, size_t size = 0,
-	        size_t* bytesWritten = nullptr) = 0;
-	virtual ReturnValue_t deleteFile(const char* dirname,
-	        const char* filename) = 0;
+	virtual ReturnValue_t appendToFile(const char* repositoryPath,
+	        const char* filename, const uint8_t* data, size_t size,
+	        uint16_t packetNumber, void* args = nullptr) = 0;
+
+	/**
+	 * Generic function to create a new file.
+	 * @param repositoryPath
+	 * @param filename
+	 * @param data
+	 * @param size
+	 * @param args Any other arguments which an implementation might require.
+	 * @return
+	 */
+	virtual ReturnValue_t createFile(const char* repositoryPath,
+	        const char* filename, const uint8_t* data = nullptr,
+	        size_t size = 0, void* args = nullptr) = 0;
+
+	/**
+	 * Generic function to delete a file.
+	 * @param repositoryPath
+	 * @param filename
+	 * @param args
+	 * @return
+	 */
+	virtual ReturnValue_t deleteFile(const char* repositoryPath,
+	        const char* filename, void* args = nullptr) = 0;
 };
 
 

From a7fe23c3004d8c933b36d3c5a23f0b8322eaa022 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 5 Oct 2020 00:12:52 +0200
Subject: [PATCH 0874/1774] small stuff

---
 memory/FileSystemMessage.cpp | 33 ++++++++++++++++-----------------
 1 file changed, 16 insertions(+), 17 deletions(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index b9c426a85..839268a0c 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -1,35 +1,40 @@
 #include "FileSystemMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
+void FileSystemMessage::setCreateFileCommand(CommandMessage* message,
+        store_address_t storeId) {
+    message->setCommand(CREATE_FILE);
+    message->setParameter2(storeId.raw);
+}
 
 void FileSystemMessage::setDeleteFileCommand(
-		CommandMessage* message, store_address_t storageID) {
-	message->setCommand(DELETE_FILE);
-	message->setParameter2(storageID.raw);
+        CommandMessage* message, store_address_t storeId) {
+    message->setCommand(DELETE_FILE);
+    message->setParameter2(storeId.raw);
 }
 
 void FileSystemMessage::setCreateDirectoryCommand(
-		CommandMessage* message, store_address_t storageID) {
+		CommandMessage* message, store_address_t storeId) {
 	message->setCommand(CREATE_DIRECTORY);
-	message->setParameter2(storageID.raw);
+	message->setParameter2(storeId.raw);
 }
 
 void FileSystemMessage::setDeleteDirectoryCommand(
-		CommandMessage* message, store_address_t storageID) {
+		CommandMessage* message, store_address_t storeId) {
 	message->setCommand(DELETE_DIRECTORY);
-	message->setParameter2(storageID.raw);
+	message->setParameter2(storeId.raw);
 }
 
 void FileSystemMessage::setWriteCommand(CommandMessage* message,
-		store_address_t storageID) {
+		store_address_t storeId) {
 	message->setCommand(APPEND_TO_FILE);
-	message->setParameter2(storageID.raw);
+	message->setParameter2(storeId.raw);
 }
 
 void FileSystemMessage::setReadCommand(CommandMessage* message,
-		store_address_t storageID) {
+		store_address_t storeId) {
 	message->setCommand(READ_FROM_FILE);
-	message->setParameter2(storageID.raw);
+	message->setParameter2(storeId.raw);
 }
 
 void FileSystemMessage::setReadReply(CommandMessage* message,
@@ -38,12 +43,6 @@ void FileSystemMessage::setReadReply(CommandMessage* message,
 	message->setParameter2(storageID.raw);
 }
 
-void FileSystemMessage::setCreateFileCommand(CommandMessage *message,
-        store_address_t storeId) {
-    message->setCommand(CREATE_FILE);
-    message->setParameter2(storeId.raw);
-}
-
 store_address_t FileSystemMessage::getStoreId(const CommandMessage* message) {
 	store_address_t temp;
 	temp.raw = message->getParameter2();

From 1431116417672389bfef1ea1a77bf832cbbe309e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 5 Oct 2020 12:11:11 +0200
Subject: [PATCH 0875/1774] NULL exception somewhere

---
 memory/FileSystemMessage.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index 839268a0c..21f22f5d9 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -55,7 +55,7 @@ void FileSystemMessage::setSuccessReply(CommandMessage *message) {
 
 void FileSystemMessage::setFailureReply(CommandMessage *message,
         ReturnValue_t errorCode) {
-    message->setCommand(COMPLETION_SUCCESS);
+    message->setCommand(COMPLETION_FAILED);
     message->setParameter(errorCode);
 }
 

From c17d50bd1e16031be3861723d68b9269c4623cbf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 5 Oct 2020 19:46:25 +0200
Subject: [PATCH 0876/1774] file syste mmessage moved to mission code for now

---
 memory/FileSystemMessage.cpp | 66 -------------------------------
 memory/FileSystemMessage.h   | 75 ------------------------------------
 2 files changed, 141 deletions(-)
 delete mode 100644 memory/FileSystemMessage.cpp
 delete mode 100644 memory/FileSystemMessage.h

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
deleted file mode 100644
index 21f22f5d9..000000000
--- a/memory/FileSystemMessage.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "FileSystemMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-void FileSystemMessage::setCreateFileCommand(CommandMessage* message,
-        store_address_t storeId) {
-    message->setCommand(CREATE_FILE);
-    message->setParameter2(storeId.raw);
-}
-
-void FileSystemMessage::setDeleteFileCommand(
-        CommandMessage* message, store_address_t storeId) {
-    message->setCommand(DELETE_FILE);
-    message->setParameter2(storeId.raw);
-}
-
-void FileSystemMessage::setCreateDirectoryCommand(
-		CommandMessage* message, store_address_t storeId) {
-	message->setCommand(CREATE_DIRECTORY);
-	message->setParameter2(storeId.raw);
-}
-
-void FileSystemMessage::setDeleteDirectoryCommand(
-		CommandMessage* message, store_address_t storeId) {
-	message->setCommand(DELETE_DIRECTORY);
-	message->setParameter2(storeId.raw);
-}
-
-void FileSystemMessage::setWriteCommand(CommandMessage* message,
-		store_address_t storeId) {
-	message->setCommand(APPEND_TO_FILE);
-	message->setParameter2(storeId.raw);
-}
-
-void FileSystemMessage::setReadCommand(CommandMessage* message,
-		store_address_t storeId) {
-	message->setCommand(READ_FROM_FILE);
-	message->setParameter2(storeId.raw);
-}
-
-void FileSystemMessage::setReadReply(CommandMessage* message,
-		store_address_t storageID) {
-	message->setCommand(READ_REPLY);
-	message->setParameter2(storageID.raw);
-}
-
-store_address_t FileSystemMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-void FileSystemMessage::setSuccessReply(CommandMessage *message) {
-    message->setCommand(COMPLETION_SUCCESS);
-}
-
-void FileSystemMessage::setFailureReply(CommandMessage *message,
-        ReturnValue_t errorCode) {
-    message->setCommand(COMPLETION_FAILED);
-    message->setParameter(errorCode);
-}
-
-ReturnValue_t FileSystemMessage::getFailureReply(
-		const CommandMessage *message) {
-	return message->getParameter();
-}
-
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
deleted file mode 100644
index 4d77fd167..000000000
--- a/memory/FileSystemMessage.h
+++ /dev/null
@@ -1,75 +0,0 @@
-#ifndef FSFW_MEMORY_FILESYSTEMMESSAGE_H_
-#define FSFW_MEMORY_FILESYSTEMMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../objectmanager/SystemObject.h"
-
-/**
- * @author  Jakob Meier
- */
-class FileSystemMessage {
-public:
-    // Instantiation forbidden
-	FileSystemMessage() = delete;
-
-	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
-	/* PUS standard  (ECSS-E-ST-70-41C15 2016 p.654) */
-	static const Command_t CREATE_FILE = MAKE_COMMAND_ID(1);
-	static const Command_t DELETE_FILE = MAKE_COMMAND_ID(2);
-	/** Report file attributes */
-	static const Command_t REPORT_FILE_ATTRIBUTES = MAKE_COMMAND_ID(3);
-	static const Command_t FILE_ATTRIBUTES_REPLY = MAKE_COMMAND_ID(4);
-	/** Command to lock a file, setting it read-only */
-	static const Command_t LOCK_FILE = MAKE_COMMAND_ID(5);
-	/** Command to unlock a file, enabling further operations on it */
-	static const Command_t UNLOCK_FILE = MAKE_COMMAND_ID(6);
-	/**
-	 * Find file in repository, using a search pattern.
-	 * Please note that * is the wildcard character.
-	 * For example, when looking for all files which start with have the
-	 * structure tm<something>.bin, tm*.bin can be used.
-	 */
-	static const Command_t FIND_FILE = MAKE_COMMAND_ID(7);
-	static const Command_t CREATE_DIRECTORY = MAKE_COMMAND_ID(9);
-    static const Command_t DELETE_DIRECTORY = MAKE_COMMAND_ID(10);
-	static const Command_t RENAME_DIRECTORY = MAKE_COMMAND_ID(11);
-
-	/** Dump contents of a repository */
-	static const Command_t DUMP_REPOSITORY = MAKE_COMMAND_ID(12);
-	/** Repository dump reply */
-	static const Command_t DUMY_REPOSITORY_REPLY = MAKE_COMMAND_ID(13);
-
-    static const Command_t APPEND_TO_FILE = MAKE_COMMAND_ID(128);
-    static const Command_t READ_FROM_FILE = MAKE_COMMAND_ID(129);
-    static const Command_t READ_REPLY = MAKE_COMMAND_ID(130);
-
-    /** Dump the structure of the whole SD card as an ASCII file */
-    static const Command_t DUMP_FILE_STRUCTURE = MAKE_COMMAND_ID(131);
-
-
-	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(150);
-	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(151);
-
-	static void setCreateFileCommand(CommandMessage* message,
-	        store_address_t storeId);
-	static void setDeleteFileCommand(CommandMessage* message,
-	        store_address_t storeId);
-	static void setCreateDirectoryCommand(CommandMessage* message,
-	        store_address_t storeId);
-	static void setDeleteDirectoryCommand(CommandMessage* message,
-	        store_address_t storeId);
-	static void setWriteCommand(CommandMessage* message,
-	        store_address_t storeId);
-	static void setReadCommand(CommandMessage* message,
-	        store_address_t storeId);
-	static void setReadReply(CommandMessage* message, store_address_t storeId);
-    static void setSuccessReply(CommandMessage* message);
-    static void setFailureReply(CommandMessage* message,
-            ReturnValue_t errorCode);
-
-	static store_address_t getStoreId(const CommandMessage* message);
-	static ReturnValue_t getFailureReply(const CommandMessage* message);
-};
-
-#endif /* FSFW_MEMORY_FILESYSTEMMESSAGE_H_ */

From 8c43c6993eca053fdf8dc633ea049ceed6564a43 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 5 Oct 2020 22:47:32 +0200
Subject: [PATCH 0877/1774] CSB fifo depth configurable

---
 pus/Service1TelecommandVerification.cpp | 5 ++---
 pus/Service1TelecommandVerification.h   | 3 ++-
 returnvalues/FwClassIds.h               | 4 ++--
 tmtcservices/CommandingServiceBase.h    | 4 +++-
 4 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index 9b17eba58..6d081fe29 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -8,13 +8,12 @@
 #include "../tmtcservices/AcceptsTelemetryIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
-
 Service1TelecommandVerification::Service1TelecommandVerification(
         object_id_t objectId, uint16_t apid, uint8_t serviceId,
-        object_id_t targetDestination):
+        object_id_t targetDestination, uint16_t messageQueueDepth):
         SystemObject(objectId), apid(apid), serviceId(serviceId),
         targetDestination(targetDestination) {
-	tmQueue = QueueFactory::instance()->createMessageQueue();
+	tmQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }
 
 Service1TelecommandVerification::~Service1TelecommandVerification() {}
diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h
index 37562d1c9..6fff03322 100644
--- a/pus/Service1TelecommandVerification.h
+++ b/pus/Service1TelecommandVerification.h
@@ -44,7 +44,8 @@ public:
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
 
 	Service1TelecommandVerification(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
+	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination,
+			uint16_t messageQueueDepth);
 	virtual ~Service1TelecommandVerification();
 
 	/**
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index c8c0a3adc..120d1e2e7 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -66,8 +66,8 @@ enum {
 	HOUSEKEEPING_MANAGER, //HKM 60
 	DLE_ENCODER, //DLEE 61
 	SERIAL_ANALYZER, //SERA 62
-	PUS_SERVICE_9, // PUS9 63
-	FILE_SYSTEM, // FLSY 64
+	PUS_SERVICE_9, //PUS9 63
+	FILE_SYSTEM, //FLSY 64
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 252b69435..9f1d4c4f9 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -13,6 +13,8 @@
 #include "../container/FIFO.h"
 #include "../serialize/SerializeIF.h"
 
+#include <FSFWConfig.h>
+
 class TcPacketStored;
 
 namespace Factory{
@@ -40,7 +42,7 @@ class CommandingServiceBase: public SystemObject,
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	// We could make this configurable via preprocessor and the FSFWConfig file.
-	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH = 3;
+	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH = FSFW_CSB_FIFO_DEPTH;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
 

From 6a077c583dd2063ad9b71d9298967c78e59d967b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 6 Oct 2020 14:00:18 +0200
Subject: [PATCH 0878/1774] action helper some formatting stuff

---
 action/ActionHelper.h | 74 +++++++++++++++++++++++++++----------------
 1 file changed, 47 insertions(+), 27 deletions(-)

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

From df1a730cdff36835424057e64f89f3817fda24bb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 6 Oct 2020 16:01:35 +0200
Subject: [PATCH 0879/1774] some form stuff

---
 action/ActionHelper.cpp            | 15 +++++++++------
 action/ActionHelper.h              |  2 +-
 pus/Service8FunctionManagement.cpp |  4 ++--
 tmtcservices/TmTcMessage.cpp       |  8 ++++----
 tmtcservices/TmTcMessage.h         | 16 ++++++++--------
 5 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 361f7dc34..ab986c6c4 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -3,8 +3,9 @@
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
-ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
+ActionHelper::ActionHelper(HasActionsIF* setOwner,
+        MessageQueueIF* useThisQueue) :
+		owner(setOwner), queueToUse(useThisQueue) {
 }
 
 ActionHelper::~ActionHelper() {
@@ -33,13 +34,15 @@ ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo,
+        ActionId_t commandId, ReturnValue_t result) {
 	CommandMessage reply;
 	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
 	queueToUse->sendMessage(reportTo, &reply);
 }
 
-void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId,
+        ReturnValue_t result) {
 	CommandMessage reply;
 	ActionMessage::setCompletionReply(&reply, commandId, result);
 	queueToUse->sendMessage(reportTo, &reply);
@@ -49,8 +52,8 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
 	queueToUse = queue;
 }
 
-void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-		store_address_t dataAddress) {
+void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
+        ActionId_t actionId, store_address_t dataAddress) {
 	const uint8_t* dataPtr = NULL;
 	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index 0334543c0..a20f286a1 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -94,7 +94,7 @@ protected:
 	//! setQueueToUse
 	MessageQueueIF* queueToUse;
 	//! Pointer to an IPC Store, initialized during construction or
-	StorageManagerIF* ipcStore;
+	StorageManagerIF* ipcStore = nullptr;
 
 	/**
 	 * Internal function called by handleActionMessage
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 2c2e590b5..c1c88a50c 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -7,10 +7,10 @@
 #include "../serialize/SerializeAdapter.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
-Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
+Service8FunctionManagement::Service8FunctionManagement(object_id_t objectId,
 		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
 		uint16_t commandTimeoutSeconds):
-		CommandingServiceBase(object_id, apid, serviceId, numParallelCommands,
+		CommandingServiceBase(objectId, apid, serviceId, numParallelCommands,
 		commandTimeoutSeconds) {}
 
 Service8FunctionManagement::~Service8FunctionManagement() {}
diff --git a/tmtcservices/TmTcMessage.cpp b/tmtcservices/TmTcMessage.cpp
index a715225b4..f81eba62e 100644
--- a/tmtcservices/TmTcMessage.cpp
+++ b/tmtcservices/TmTcMessage.cpp
@@ -15,15 +15,15 @@ store_address_t TmTcMessage::getStorageId() {
 	return temp_id;
 }
 
-TmTcMessage::TmTcMessage(store_address_t store_id) {
+TmTcMessage::TmTcMessage(store_address_t storeId) {
 	this->messageSize += sizeof(store_address_t);
-	this->setStorageId(store_id);
+	this->setStorageId(storeId);
 }
 
 size_t TmTcMessage::getMinimumMessageSize() {
 	return this->HEADER_SIZE + sizeof(store_address_t);
 }
 
-void TmTcMessage::setStorageId(store_address_t store_id) {
-	memcpy(this->getData(), &store_id, sizeof(store_address_t) );
+void TmTcMessage::setStorageId(store_address_t storeId) {
+	memcpy(this->getData(), &storeId, sizeof(store_address_t) );
 }
diff --git a/tmtcservices/TmTcMessage.h b/tmtcservices/TmTcMessage.h
index b5e1ff8d4..41fe198a9 100644
--- a/tmtcservices/TmTcMessage.h
+++ b/tmtcservices/TmTcMessage.h
@@ -1,5 +1,5 @@
-#ifndef TMTCMESSAGE_H_
-#define TMTCMESSAGE_H_
+#ifndef FSFW_TMTCSERVICES_TMTCMESSAGE_H_
+#define FSFW_TMTCSERVICES_TMTCMESSAGE_H_
 
 #include "../ipc/MessageQueueMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
@@ -10,13 +10,13 @@
  * 			a packet stored in one of the IPC stores (typically a special TM and
  * 			a special TC store). This makes passing commands very simple and
  * 			efficient.
- *	\ingroup message_queue
+ * @ingroup message_queue
  */
 class TmTcMessage : public MessageQueueMessage {
 protected:
 	/**
 	 * @brief	This call always returns the same fixed size of the message.
-	 * @return	Returns HEADER_SIZE + \c sizeof(store_address_t).
+	 * @return	Returns HEADER_SIZE + @c sizeof(store_address_t).
 	 */
 	size_t getMinimumMessageSize();
 public:
@@ -29,7 +29,7 @@ public:
 	 * 			into the message.
 	 * @param packet_id	The packet id to put into the message.
 	 */
-	TmTcMessage( store_address_t packet_id );
+	TmTcMessage( store_address_t packetId );
 	/**
 	 * @brief	The class's destructor is empty.
 	 */
@@ -42,9 +42,9 @@ public:
 	/**
 	 * @brief	In some cases it might be useful to have a setter for packet id
 	 * 			as well.
-	 * @param packet_id	The packet id to put into the message.
+	 * @param packetId	The packet id to put into the message.
 	 */
-	void setStorageId( store_address_t packet_id );
+	void setStorageId( store_address_t packetId );
 };
 
-#endif /* TMTCMESSAGE_H_ */
+#endif /* FSFW_TMTCSERVICES_TMTCMESSAGE_H_ */

From 9fb38e9b7c168e514706b3b757e70b2d1b163c3f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 6 Oct 2020 19:58:29 +0200
Subject: [PATCH 0880/1774] better error output

---
 osal/FreeRTOS/MessageQueue.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 2dfe5ab65..fdadf8b7d 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -11,7 +11,12 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		maxMessageSize(maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
 	if (handle == nullptr) {
-		sif::error << "MessageQueue::MessageQueue Creation failed" << std::endl;
+		sif::error << "MessageQueue::MessageQueue:"
+		        << " Creation failed." << std::endl;
+		sif::error << "Specified Message Depth: " << messageDepth
+		        << std::endl;
+		sif::error << "Specified Maximum Message Size: "
+		        << maxMessageSize << std::endl;
 	}
 }
 

From 6e9db0d67533b8b3fa25def2b185691749c2b6f6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 7 Oct 2020 18:43:56 +0200
Subject: [PATCH 0881/1774] retval added

---
 memory/HasFileSystemIF.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index e270f256a..7ab4cc4ef 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -21,6 +21,8 @@ public:
     static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x03);
     static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(0x04);
 
+    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING = MAKE_RETURN_CODE(0x05);
+
 	virtual ~HasFileSystemIF() {}
 	/**
 	 * Function to get the MessageQueueId_t of the implementing object

From 2364c4f9a4d1aa551557e0d2a4b616652da8d2db Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 7 Oct 2020 20:47:46 +0200
Subject: [PATCH 0882/1774] form improvements

---
 tmtcpacket/pus/TmPacketStored.cpp |  7 +++--
 tmtcpacket/pus/TmPacketStored.h   | 47 +++++++++++++++++++------------
 2 files changed, 33 insertions(+), 21 deletions(-)

diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 17b49f43a..4cf76589b 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -1,8 +1,9 @@
+#include "TmPacketStored.h"
+
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TmPacketStored.h"
 #include "../../tmtcservices/TmTcMessage.h"
-#include <string.h>
+#include <cstring>
 
 TmPacketStored::TmPacketStored(store_address_t setAddress) :
 		TmPacketBase(NULL), storeAddress(setAddress) {
@@ -11,7 +12,7 @@ TmPacketStored::TmPacketStored(store_address_t setAddress) :
 
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
-		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
+		size_t size, const uint8_t *headerData, size_t headerSize) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	if (!checkAndSetStore()) {
diff --git a/tmtcpacket/pus/TmPacketStored.h b/tmtcpacket/pus/TmPacketStored.h
index 98e37ed53..81a6f6e5d 100644
--- a/tmtcpacket/pus/TmPacketStored.h
+++ b/tmtcpacket/pus/TmPacketStored.h
@@ -1,9 +1,9 @@
-#ifndef TMPACKETSTORED_H_
-#define TMPACKETSTORED_H_
+#ifndef FSFW_TMTCPACKET_TMPACKETSTORED_H_
+#define FSFW_TMTCPACKET_TMPACKETSTORED_H_
 
+#include "TmPacketBase.h"
 #include "../../serialize/SerializeIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../tmtcpacket/pus/TmPacketBase.h"
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueSenderIF.h"
 
@@ -21,7 +21,7 @@ class TmPacketStored : public TmPacketBase {
 private:
 	/**
 	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
+	 * If the store is not yet set (i.e. @c store is NULL), every constructor
 	 * call tries to set it and throws an error message in case of failures.
 	 * The default store is objects::TM_STORE.
 	 */
@@ -37,8 +37,8 @@ private:
 	 * A helper method to check if a store is assigned to the class.
 	 * If not, the method tries to retrieve the store from the global
 	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
+	 * @return	@li	@c true if the store is linked or could be created.
+	 * 			@li @c false otherwise.
 	 */
 	bool checkAndSetStore();
 
@@ -52,8 +52,9 @@ public:
 	/**
 	 * With this constructor, new space is allocated in the packet store and
 	 * a new PUS Telemetry Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet. The Application data is
-	 * passed in two parts, first a header, then a data field. This allows building a Telemetry
+	 * Packet Application Data passed in data is copied into the packet.
+	 * The Application data is passed in two parts, first a header, then a
+	 * data field. This allows building a Telemetry
 	 * Packet from two separate data sources.
 	 * @param apid			Sets the packet's APID field.
 	 * @param service		Sets the packet's Service ID field.
@@ -61,20 +62,29 @@ public:
 	 * @param subservice	Sets the packet's Service Subtype field.
 	 * 		This specifies the source sub-service.
 	 * @param packet_counter	Sets the Packet counter field of this packet
-	 * @param data			The payload data to be copied to the Application Data Field
+	 * @param data			The payload data to be copied to the Application
+	 * 						Data Field
 	 * @param size			The amount of data to be copied.
-	 * @param headerData 	The header Data of the Application field; will be copied in front of data
+	 * @param headerData 	The header Data of the Application field; will be
+	 * 						copied in front of data
 	 * @param headerSize	The size of the headerDataF
 	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter = 0, const uint8_t* data = NULL, uint32_t size = 0, const uint8_t* headerData = NULL, uint32_t headerSize = 0);
+	TmPacketStored(uint16_t apid, uint8_t service,	uint8_t subservice,
+			uint8_t packet_counter = 0, const uint8_t* data = nullptr,
+			size_t size = 0, const uint8_t* headerData = nullptr,
+			size_t headerSize = 0);
 	/**
-	 * Another ctor to directly pass structured content and header data to the packet to avoid additional buffers.
+	 * Another ctor to directly pass structured content and header data to the
+	 * packet to avoid additional buffers.
 	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter, SerializeIF* content, SerializeIF* header = NULL);
+	TmPacketStored(uint16_t apid, uint8_t service,	uint8_t subservice,
+			uint8_t packet_counter, SerializeIF* content,
+			SerializeIF* header = nullptr);
 	/**
 	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
+	 * @return
+	 * The current store address. The (raw) value is
+	 * @c StorageManagerIF::INVALID_ADDRESS if the packet is not linked.
 	 */
 	store_address_t getStoreAddress();
 	/**
@@ -87,10 +97,11 @@ public:
 	 * if the packet is a class member and used for more than one packet.
 	 * @param setAddress	The new packet id to link to.
 	 */
-	void setStoreAddress( store_address_t setAddress );
+	void setStoreAddress(store_address_t setAddress);
 
-	ReturnValue_t sendPacket( MessageQueueId_t destination, MessageQueueId_t sentFrom, bool doErrorReporting = true );
+	ReturnValue_t sendPacket(MessageQueueId_t destination,
+			MessageQueueId_t sentFrom, bool doErrorReporting = true);
 };
 
 
-#endif /* TMPACKETSTORED_H_ */
+#endif /* FSFW_TMTCPACKET_TMPACKETSTORED_H_ */

From e338b4662d8682f391cdf950ed4a47e80eaf37da Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 9 Oct 2020 02:49:18 +0200
Subject: [PATCH 0883/1774] fix for c++11 comformity

---
 datapoollocal/LocalDataPoolManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index c23f183b1..4f124e7fe 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -389,7 +389,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 			dataSet->periodicHelper->getCollectionIntervalInSeconds();
 
 	// Generate set packet which can be serialized.
-	HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid,
+	HousekeepingSetPacket setPacket(sid,
 			reportingEnabled, valid, collectionInterval, dataSet);
 	size_t expectedSize = setPacket.getSerializedSize();
 	uint8_t* storePtr = nullptr;

From 94884c2402e3c5077bfe5b88c3255cd554a4ad5b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 17:11:11 +0200
Subject: [PATCH 0884/1774] service 1 small improvements

---
 pus/Service1TelecommandVerification.cpp | 5 ++---
 pus/Service1TelecommandVerification.h   | 8 ++++----
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index 6d081fe29..86b0dcded 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -1,12 +1,11 @@
-#include "../pus/Service1TelecommandVerification.h"
-#include "../pus/servicepackets/Service1Packets.h"
+#include "Service1TelecommandVerification.h"
+#include "servicepackets/Service1Packets.h"
 
 #include "../ipc/QueueFactory.h"
 #include "../tmtcservices/PusVerificationReport.h"
 #include "../tmtcpacket/pus/TmPacketStored.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
 
 Service1TelecommandVerification::Service1TelecommandVerification(
         object_id_t objectId, uint16_t apid, uint8_t serviceId,
diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h
index 6fff03322..3d68a4e06 100644
--- a/pus/Service1TelecommandVerification.h
+++ b/pus/Service1TelecommandVerification.h
@@ -1,5 +1,5 @@
-#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+#ifndef FSFW_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+#define FSFW_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
 
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -52,7 +52,7 @@ public:
 	 *
 	 * @return ID of Verification Queue
 	 */
-	virtual MessageQueueId_t getVerificationQueue();
+	virtual MessageQueueId_t getVerificationQueue() override;
 
 	/**
 	 * Performs the service periodically as specified in init_mission().
@@ -92,4 +92,4 @@ private:
 	};
 };
 
-#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
+#endif /* FSFW_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */

From 3aa666633e4d561847e2cf12972c2fb916d41ee8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 17:14:52 +0200
Subject: [PATCH 0885/1774] include guard replacements

---
 pus/CService200ModeCommanding.h        | 6 +++---
 pus/Service2DeviceAccess.cpp           | 4 ++--
 pus/Service2DeviceAccess.h             | 6 +++---
 pus/Service5EventReporting.cpp         | 4 ++--
 pus/Service5EventReporting.h           | 6 +++---
 pus/Service8FunctionManagement.h       | 6 +++---
 pus/servicepackets/Service1Packets.h   | 6 +++---
 pus/servicepackets/Service200Packets.h | 6 +++---
 pus/servicepackets/Service2Packets.h   | 6 +++---
 pus/servicepackets/Service5Packets.h   | 6 +++---
 pus/servicepackets/Service8Packets.h   | 6 +++---
 11 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h
index 89347dbd8..c86d7b841 100644
--- a/pus/CService200ModeCommanding.h
+++ b/pus/CService200ModeCommanding.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
-#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
+#ifndef FSFW_PUS_CSERVICE200MODECOMMANDING_H_
+#define FSFW_PUS_CSERVICE200MODECOMMANDING_H_
 
 #include "../tmtcservices/CommandingServiceBase.h"
 
@@ -82,4 +82,4 @@ private:
 	};
 };
 
-#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */
+#endif /* FSFW_PUS_CSERVICE200MODECOMMANDING_H_ */
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 8780b22ce..878a13b0c 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -1,5 +1,5 @@
-#include "../pus/Service2DeviceAccess.h"
-#include "../pus/servicepackets/Service2Packets.h"
+#include "Service2DeviceAccess.h"
+#include "servicepackets/Service2Packets.h"
 
 #include "../devicehandlers/DeviceHandlerIF.h"
 #include "../storagemanager/StorageManagerIF.h"
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index f6aa8b521..fa2ea75c7 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
-#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
+#ifndef FSFW_PUS_SERVICE2DEVICEACCESS_H_
+#define FSFW_PUS_SERVICE2DEVICEACCESS_H_
 
 #include "../objectmanager/SystemObjectIF.h"
 #include "../devicehandlers/AcceptsDeviceResponsesIF.h"
@@ -89,4 +89,4 @@ private:
 };
 
 
-#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */
+#endif /* FSFW_PUS_DEVICE2DEVICECOMMANDING_H_ */
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index 02031df4b..829d04bde 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -1,5 +1,5 @@
-#include "../pus/Service5EventReporting.h"
-#include "../pus/servicepackets/Service5Packets.h"
+#include "Service5EventReporting.h"
+#include "servicepackets/Service5Packets.h"
 
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../events/EventManagerIF.h"
diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h
index 0b6ee9a8c..78c18bf30 100644
--- a/pus/Service5EventReporting.h
+++ b/pus/Service5EventReporting.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+#ifndef FSFW_PUS_SERVICE5EVENTREPORTING_H_
+#define FSFW_PUS_SERVICE5EVENTREPORTING_H_
 
 #include "../tmtcservices/PusServiceBase.h"
 #include "../events/EventMessage.h"
@@ -83,4 +83,4 @@ private:
 	ReturnValue_t generateEventReport(EventMessage message);
 };
 
-#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
+#endif /* FSFW_PUS_SERVICE5EVENTREPORTING_H_ */
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index b5ebcda8b..292a5e36c 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
-#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
+#ifndef FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
+#define FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 
 #include "../action/ActionMessage.h"
 #include "../tmtcservices/CommandingServiceBase.h"
@@ -64,4 +64,4 @@ private:
 	        object_id_t objectId, ActionId_t actionId);
 };
 
-#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
+#endif /* FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index dbd31028c..ecb62693c 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -1,3 +1,6 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
 /**
  * @defgroup spacepackets PUS Packet Definitions
  *  This group contains all implemented TM or TM packages that are sent to
@@ -5,9 +8,6 @@
  *  packet structures in Mission Information Base (MIB).
  */
 
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-
 #include "../../serialize/SerializeAdapter.h"
 #include "../../tmtcservices/VerificationCodes.h"
 
diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h
index efcf65fcf..cb9ad4a70 100644
--- a/pus/servicepackets/Service200Packets.h
+++ b/pus/servicepackets/Service200Packets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
 
 #include "../../serialize/SerialLinkedListAdapter.h"
 #include "../../modes/ModeMessage.h"
@@ -60,4 +60,4 @@ public:
 	SerializeElement<ReturnValue_t> reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached
 };
 
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
diff --git a/pus/servicepackets/Service2Packets.h b/pus/servicepackets/Service2Packets.h
index d4f3fb170..285a8f9f1 100644
--- a/pus/servicepackets/Service2Packets.h
+++ b/pus/servicepackets/Service2Packets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
 
 #include "../../action/ActionMessage.h"
 #include "../../objectmanager/SystemObjectIF.h"
@@ -73,4 +73,4 @@ public:
 	}
 };
 
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h
index 9655608aa..f903d6a26 100644
--- a/pus/servicepackets/Service5Packets.h
+++ b/pus/servicepackets/Service5Packets.h
@@ -1,5 +1,5 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
 
 #include "../../serialize/SerializeAdapter.h"
 #include "../../tmtcservices/VerificationCodes.h"
@@ -73,4 +73,4 @@ private:
 };
 
 
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
index 14f8b6e6e..b026edf52 100644
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 
 #include "../../action/ActionMessage.h"
 #include "../../objectmanager/SystemObjectIF.h"
@@ -118,4 +118,4 @@ private:
 
 };
 
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */

From 837a18135e2d643f52213ff1c1995af3d1cd9f2d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 17:41:51 +0200
Subject: [PATCH 0886/1774] subsystem folder update

---
 subsystem/Subsystem.cpp                 | 28 +++++++++++++------------
 subsystem/Subsystem.h                   | 24 +++++++++++----------
 subsystem/SubsystemBase.cpp             | 18 +++++++---------
 subsystem/SubsystemBase.h               | 23 ++++++++++----------
 subsystem/modes/HasModeSequenceIF.h     |  6 +++---
 subsystem/modes/ModeDefinitions.h       | 21 ++++++++-----------
 subsystem/modes/ModeSequenceMessage.cpp | 25 ++++++----------------
 subsystem/modes/ModeSequenceMessage.h   |  9 ++++----
 subsystem/modes/ModeStore.cpp           |  2 ++
 9 files changed, 73 insertions(+), 83 deletions(-)

diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index ba1f463c9..9712d7d42 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -12,13 +12,10 @@ Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
 		uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) :
 		SubsystemBase(setObjectId, parent, 0), isInTransition(false),
 		childrenChangedHealth(false), currentTargetTable(),
-		targetMode(0), targetSubmode(SUBMODE_NONE), initialMode(0),
-		currentSequenceIterator(), modeTables(maxNumberOfTables),
-		modeSequences(maxNumberOfSequences) {}
+		targetSubmode(SUBMODE_NONE), currentSequenceIterator(),
+		modeTables(maxNumberOfTables), modeSequences(maxNumberOfSequences) {}
 
-Subsystem::~Subsystem() {
-	//Auto-generated destructor stub
-}
+Subsystem::~Subsystem() {}
 
 ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
 		Mode_t fallbackSequence) {
@@ -344,7 +341,8 @@ ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
 
 	ReturnValue_t result;
 
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
+	//Before initialize() is called, tables must not be checked as the
+	//children are not added yet.
 	//Sequences added before are checked by initialize()
 	if (!preInit) {
 		result = checkSequence(
@@ -390,8 +388,8 @@ ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
 
 	ReturnValue_t result;
 
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
-	//Tables added before are checked by initialize()
+	//Before initialize() is called, tables must not be checked as the children
+	//are not added yet. Tables added before are checked by initialize()
 	if (!preInit) {
 		result = checkTable(
 				HybridIterator<ModeListEntry>(table->front(), table->back()));
@@ -582,12 +580,14 @@ void Subsystem::transitionFailed(ReturnValue_t failureCode,
 	triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter);
 	if (mode == targetMode) {
 		//already tried going back to the current mode
-		//go into fallback mode, also set current mode to fallback mode, so we come here at the next fail
+		//go into fallback mode, also set current mode to fallback mode,
+	    //so we come here at the next fail
 		modeHelper.setForced(true);
 		ReturnValue_t result;
 		if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
 			triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
-			isInTransition = false; //keep still and allow arbitrary mode commands to recover
+			//keep still and allow arbitrary mode commands to recover
+			isInTransition = false;
 			return;
 		}
 		mode = getFallbackSequence(mode);
@@ -651,8 +651,10 @@ void Subsystem::cantKeepMode() {
 
 	modeHelper.setForced(true);
 
-	//already set the mode, so that we do not try to go back in our old mode when the transition fails
+	//already set the mode, so that we do not try to go back in our old mode
+	//when the transition fails
 	mode = getFallbackSequence(mode);
-	//SHOULDDO: We should store submodes for fallback sequence as well, otherwise we should get rid of submodes completely.
+	//SHOULDDO: We should store submodes for fallback sequence as well,
+	//otherwise we should get rid of submodes completely.
 	startTransition(mode, SUBMODE_NONE);
 }
diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index 2b501574f..9a3fcdfe6 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -1,13 +1,14 @@
-#ifndef SUBSYSTEM_H_
-#define SUBSYSTEM_H_
+#ifndef FSFW_SUBSYSTEM_SUBSYSTEM_H_
+#define FSFW_SUBSYSTEM_SUBSYSTEM_H_
+
+#include "SubsystemBase.h"
+#include "modes/ModeDefinitions.h"
 
 #include "../container/FixedArrayList.h"
 #include "../container/FixedMap.h"
 #include "../container/HybridIterator.h"
 #include "../container/SinglyLinkedList.h"
 #include "../serialize/SerialArrayListAdapter.h"
-#include "../subsystem/modes/ModeDefinitions.h"
-#include "../subsystem/SubsystemBase.h"
 
 class Subsystem: public SubsystemBase, public HasModeSequenceIF {
 public:
@@ -44,11 +45,11 @@ public:
 
 	void setInitialMode(Mode_t mode);
 
-	virtual ReturnValue_t initialize();
+	virtual ReturnValue_t initialize() override;
 
-	virtual ReturnValue_t checkObjectConnections();
+	virtual ReturnValue_t checkObjectConnections() override;
 
-	virtual MessageQueueId_t getSequenceCommandQueue() const;
+	virtual MessageQueueId_t getSequenceCommandQueue() const override;
 
 	/**
 	 *
@@ -96,11 +97,11 @@ protected:
 
 	HybridIterator<ModeListEntry> currentTargetTable;
 
-	Mode_t targetMode;
+	Mode_t targetMode = 0;
 
 	Submode_t targetSubmode;
 
-	Mode_t initialMode;
+	Mode_t initialMode = 0;
 
 	HybridIterator<ModeListEntry> currentSequenceIterator;
 
@@ -153,7 +154,8 @@ protected:
 
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 
-	void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);
+	void sendSerializablesAsCommandMessage(Command_t command,
+	        SerializeIF **elements, uint8_t count);
 
 	void transitionFailed(ReturnValue_t failureCode, uint32_t parameter);
 
@@ -161,4 +163,4 @@ protected:
 
 };
 
-#endif /* SUBSYSTEM_H_ */
+#endif /* FSFW_SUBSYSTEM_SUBSYSTEM_H_ */
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 17599808f..f60c88478 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -6,10 +6,10 @@
 SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
 		Mode_t initialMode, uint16_t commandQueueDepth) :
 		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
-		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
+		childrenChangedMode(false),
+		commandQueue(QueueFactory::instance()->createMessageQueue(
+		        commandQueueDepth, CommandMessage::MAX_MESSAGE_SIZE)),
 		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
-			MessageQueueMessage::MAX_MESSAGE_SIZE);
 }
 
 SubsystemBase::~SubsystemBase() {
@@ -21,7 +21,8 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
 	ChildInfo info;
 
 	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
-	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
+	// This is a rather ugly hack to have the changedHealth info for all
+	// children available.
 	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
 	if (child == nullptr) {
 		if (healthChild == nullptr) {
@@ -38,14 +39,11 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
 	info.submode = SUBMODE_NONE;
 	info.healthChanged = false;
 
-	std::pair<std::map<object_id_t, ChildInfo>::iterator, bool> returnValue =
-			childrenMap.insert(
-					std::pair<object_id_t, ChildInfo>(objectId, info));
-	if (!(returnValue.second)) {
+	auto resultPair = childrenMap.emplace(objectId, info);
+	if (not resultPair.second) {
 		return COULD_NOT_INSERT_CHILD;
-	} else {
-		return RETURN_OK;
 	}
+	return RETURN_OK;
 }
 
 ReturnValue_t SubsystemBase::checkStateAgainstTable(
diff --git a/subsystem/SubsystemBase.h b/subsystem/SubsystemBase.h
index 2d949b56c..b8e4f9029 100644
--- a/subsystem/SubsystemBase.h
+++ b/subsystem/SubsystemBase.h
@@ -1,5 +1,7 @@
-#ifndef SUBSYSTEMBASE_H_
-#define SUBSYSTEMBASE_H_
+#ifndef FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_
+#define FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_
+
+#include "modes/HasModeSequenceIF.h"
 
 #include "../container/HybridIterator.h"
 #include "../health/HasHealthIF.h"
@@ -7,7 +9,6 @@
 #include "../modes/HasModesIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../subsystem/modes/HasModeSequenceIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include <map>
@@ -34,17 +35,17 @@ public:
 			Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
 	virtual ~SubsystemBase();
 
-	virtual MessageQueueId_t getCommandQueue() const;
+	virtual MessageQueueId_t getCommandQueue() const override;
 
 	ReturnValue_t registerChild(object_id_t objectId);
 
-	virtual ReturnValue_t initialize();
+	virtual ReturnValue_t initialize() override;
 
-	virtual ReturnValue_t performOperation(uint8_t opCode);
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
-	virtual ReturnValue_t setHealth(HealthState health);
+	virtual ReturnValue_t setHealth(HealthState health) override;
 
-	virtual HasHealthIF::HealthState getHealth();
+	virtual HasHealthIF::HealthState getHealth() override;
 
 protected:
 	struct ChildInfo {
@@ -62,9 +63,9 @@ protected:
 	/**
 	 * Always check this against <=0, so you are robust against too many replies
 	 */
-	int32_t commandsOutstanding;
+	int32_t commandsOutstanding = 0;
 
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 
 	HealthHelper healthHelper;
 
@@ -126,4 +127,4 @@ protected:
 	virtual void modeChanged();
 };
 
-#endif /* SUBSYSTEMBASE_H_ */
+#endif /* FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_ */
diff --git a/subsystem/modes/HasModeSequenceIF.h b/subsystem/modes/HasModeSequenceIF.h
index 06bde2aae..70b1667e9 100644
--- a/subsystem/modes/HasModeSequenceIF.h
+++ b/subsystem/modes/HasModeSequenceIF.h
@@ -1,9 +1,9 @@
 #ifndef HASMODESEQUENCEIF_H_
 #define HASMODESEQUENCEIF_H_
 
-#include "../../subsystem/modes/ModeDefinitions.h"
-#include "../../subsystem/modes/ModeSequenceMessage.h"
-#include "../../subsystem/modes/ModeStoreIF.h"
+#include "ModeDefinitions.h"
+#include "ModeSequenceMessage.h"
+#include "ModeStoreIF.h"
 
 
 class HasModeSequenceIF {
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index a865ab0cf..13a780ee0 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -1,22 +1,19 @@
-#ifndef MODEDEFINITIONS_H_
-#define MODEDEFINITIONS_H_
+#ifndef FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_
+#define FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_
 
 #include "../../modes/HasModesIF.h"
 #include "../../objectmanager/SystemObjectIF.h"
 #include "../../serialize/SerializeIF.h"
 #include "../../serialize/SerialLinkedListAdapter.h"
+
 class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
 public:
-	ModeListEntry() :
-			LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0), value4(
-					0) {
+	ModeListEntry(): LinkedElement<ModeListEntry>(this) {}
 
-	}
-
-	uint32_t value1;
-	uint32_t value2;
-	uint8_t value3;
-	uint8_t value4;
+	uint32_t value1 = 0;
+	uint32_t value2 = 0;
+	uint8_t value3 = 0;
+	uint8_t value4 = 0;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			size_t maxSize, Endianness streamEndianness) const {
@@ -149,4 +146,4 @@ public:
 	}
 };
 
-#endif //MODEDEFINITIONS_H_
+#endif /* FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_ */
diff --git a/subsystem/modes/ModeSequenceMessage.cpp b/subsystem/modes/ModeSequenceMessage.cpp
index e092380ef..7733098e3 100644
--- a/subsystem/modes/ModeSequenceMessage.cpp
+++ b/subsystem/modes/ModeSequenceMessage.cpp
@@ -1,8 +1,7 @@
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
+#include "ModeSequenceMessage.h"
+
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../subsystem/modes/ModeSequenceMessage.h"
 
 void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
 		Command_t command, Mode_t sequence, store_address_t storeAddress) {
@@ -11,25 +10,12 @@ void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
 	message->setParameter2(sequence);
 }
 
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table, store_address_t storeAddress) {
-//	message->setCommand(command);
-//	message->setParameter(storeAddress.raw);
-//	message->setParameter2(table);
-//}
-
 void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
 		Command_t command, Mode_t sequence) {
 	message->setCommand(command);
 	message->setParameter2(sequence);
 }
 
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table) {
-//	message->setCommand(command);
-//	message->setParameter2(table);
-//}
-
 void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
 		Command_t command, store_address_t storeAddress) {
 	message->setCommand(command);
@@ -63,9 +49,10 @@ void ModeSequenceMessage::clear(CommandMessage *message) {
 	case SEQUENCE_LIST:
 	case TABLE_LIST:
 	case TABLE:
-	case SEQUENCE:{
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore != NULL){
+	case SEQUENCE: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+		        objects::IPC_STORE);
+		if (ipcStore != nullptr){
 			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
 		}
 	}
diff --git a/subsystem/modes/ModeSequenceMessage.h b/subsystem/modes/ModeSequenceMessage.h
index 61ba30f31..9be4586e2 100644
--- a/subsystem/modes/ModeSequenceMessage.h
+++ b/subsystem/modes/ModeSequenceMessage.h
@@ -1,9 +1,10 @@
-#ifndef MODESEQUENCEMESSAGE_H_
-#define MODESEQUENCEMESSAGE_H_
+#ifndef FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_
+#define FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_
 
+#include "ModeDefinitions.h"
 #include "../../ipc/CommandMessage.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../subsystem/modes/ModeDefinitions.h"
+
 
 class ModeSequenceMessage {
 public:
@@ -45,4 +46,4 @@ private:
 	ModeSequenceMessage();
 };
 
-#endif /* MODESEQUENCEMESSAGE_H_ */
+#endif /* FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_ */
diff --git a/subsystem/modes/ModeStore.cpp b/subsystem/modes/ModeStore.cpp
index dce2931c1..260e5ab21 100644
--- a/subsystem/modes/ModeStore.cpp
+++ b/subsystem/modes/ModeStore.cpp
@@ -1,5 +1,7 @@
 #include "../../subsystem/modes/ModeStore.h"
 
+// todo: I think some parts are deprecated. If this is used,  the define
+// USE_MODESTORE could be part of the new FSFWConfig.h file.
 #ifdef USE_MODESTORE
 
 ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :

From bc0402faf7c819d5b63630bc209444b3c2df89bb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 17:49:50 +0200
Subject: [PATCH 0887/1774] health update

---
 health/HasHealthIF.h  |  9 +++------
 health/HealthHelper.h | 42 +++++++++++++++++++++++++-----------------
 health/HealthTable.h  |  5 +++--
 3 files changed, 31 insertions(+), 25 deletions(-)

diff --git a/health/HasHealthIF.h b/health/HasHealthIF.h
index d5321a6d6..86863ea8b 100644
--- a/health/HasHealthIF.h
+++ b/health/HasHealthIF.h
@@ -35,18 +35,15 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
 	/**
-	 * set the Health State
-	 *
+	 * @brief   Set the Health State
 	 * The parent will be informed, if the Health changes
-	 *
 	 * @param health
 	 */
 	virtual ReturnValue_t setHealth(HealthState health) = 0;
 
 	/**
-	 * get Health State
-	 *
-	 * @return Health State of the object
+	 * @brief   Get Health State
+	 * @return  Health State of the object
 	 */
 	virtual HasHealthIF::HealthState getHealth() = 0;
 };
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index 813123b29..08889fba5 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -12,13 +12,15 @@
 #include "../returnvalues/HasReturnvaluesIF.h"
 
 /**
- * Helper class for Objects that implement HasHealthIF
+ * @brief   Helper class for Objects that implement HasHealthIF
+ * @details
+ * It takes care of registering with the Health Table as well as handling
+ * health commands (including replying to the sender) and updating
+ * the Health Table.
  *
- * It takes care of registering with the Health Table as well as handling health commands
- * (including replying to the sender) and updating the Health Table.
- *
- * If a parent is set in the ctor, the parent will be informed with a @c HEALTH_INFO message
- * about changes in the health state. Note that a @c HEALTH_INFO is only generated if the Health
+ * If a parent is set in the ctor, the parent will be informed with a
+ * @c HEALTH_INFO message about changes in the health state.
+ * Note that a @c HEALTH_INFO is only generated if the Health
  * changes, not for all @c HEALTH_SET commands received.
  *
  * It does NOT handle @c HEALTH_INFO messages
@@ -27,10 +29,9 @@ class HealthHelper {
 public:
 
 	/**
-	 * ctor
-	 *
 	 * @param owner
-	 * @param objectId the object Id to use when communication with the HealthTable
+	 * @param objectId      The object Id to use when communication with
+	 *                      the HealthTable
 	 */
 	HealthHelper(HasHealthIF* owner, object_id_t objectId);
 
@@ -56,8 +57,9 @@ public:
 	 *
 	 * @param message
 	 * @return
-	 * 			-@c RETURN_OK if the message was handled
-	 * 			-@c RETURN_FAILED if the message could not be handled (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
+	 * -@c RETURN_OK if the message was handled
+	 * -@c RETURN_FAILED if the message could not be handled
+	 *     (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
 	 */
 	ReturnValue_t handleHealthCommand(CommandMessage *message);
 
@@ -78,16 +80,19 @@ public:
 	HasHealthIF::HealthState getHealth();
 
 	/**
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @param parentQueue   The queue ID of the parent object.
+	 *                      Set to 0 if no parent present
 	 */
 	void setParentQueue(MessageQueueId_t parentQueue);
 
 	/**
 	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @param parentQueue   The queue ID of the parent object.
+	 *                      Set to 0 if no parent present
 	 * @return
-	 * 			-@c RETURN_OK if the Health Table was found and the object could be registered
-	 * 			-@c RETURN_FAILED else
+	 * -@c RETURN_OK if the Health Table was found and the object
+	 * could be registered
+	 * -@c RETURN_FAILED else
 	 */
 	ReturnValue_t initialize(MessageQueueId_t parentQueue );
 
@@ -110,8 +115,11 @@ private:
 	HasHealthIF* owner;
 
 	/**
-	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message will be sent to this queue
-	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
+	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message
+	 * will be sent to this queue
+	 * @param health
+	 * The health is passed as parameter so that the number of
+	 * calls to the health table can be minimized
 	 * @param oldHealth information of the previous health state.
 	 */
 	void informParent(HasHealthIF::HealthState health,
diff --git a/health/HealthTable.h b/health/HealthTable.h
index c5ebb5d4c..945fb2e67 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -6,8 +6,6 @@
 #include "../ipc/MutexIF.h"
 #include <map>
 
-typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
-using HealthEntry = std::pair<object_id_t, HasHealthIF::HealthState>;
 
 class HealthTable: public HealthTableIF, public SystemObject {
 public:
@@ -28,6 +26,9 @@ public:
 	virtual HasHealthIF::HealthState getHealth(object_id_t) override;
 
 protected:
+	using HealthMap = std::map<object_id_t, HasHealthIF::HealthState>;
+	using HealthEntry = std::pair<object_id_t, HasHealthIF::HealthState>;
+
 	MutexIF* mutex;
 	HealthMap healthMap;
 

From 01e7a98425f8fd09b08d8f0e8edbbe9bed695de6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 17:55:38 +0200
Subject: [PATCH 0888/1774] added announce all subservice

---
 health/HealthMessage.cpp |  6 ++++--
 health/HealthMessage.h   | 11 +++++++----
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/health/HealthMessage.cpp b/health/HealthMessage.cpp
index 1bb29526f..52479c263 100644
--- a/health/HealthMessage.cpp
+++ b/health/HealthMessage.cpp
@@ -7,11 +7,13 @@ void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
 	message->setParameter2(oldHealth);
 }
 
-void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command) {
+void HealthMessage::setHealthMessage(CommandMessage* message,
+        Command_t command) {
 	message->setCommand(command);
 }
 
-HasHealthIF::HealthState HealthMessage::getHealth(const CommandMessage* message) {
+HasHealthIF::HealthState HealthMessage::getHealth(
+        const CommandMessage* message) {
 	return (HasHealthIF::HealthState) message->getParameter();
 }
 
diff --git a/health/HealthMessage.h b/health/HealthMessage.h
index de4923abc..fb979c663 100644
--- a/health/HealthMessage.h
+++ b/health/HealthMessage.h
@@ -7,17 +7,20 @@
 class HealthMessage {
 public:
 	static const uint8_t MESSAGE_ID = messagetypes::HEALTH_COMMAND;
-	// REPLY_COMMAND_OK/REPLY_REJECTED
+
 	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);
-	// NO REPLY!
-	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(3);
+	// No reply expected, health will be announced as event!
+	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(2);
+	// Same as before, but all objects in health table will
+	// announce their health as events.
+	static const Command_t HEALTH_ANNOUNCE_ALL = MAKE_COMMAND_ID(3);
+
 	static const Command_t HEALTH_INFO = MAKE_COMMAND_ID(5);
 	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
 
 	static void setHealthMessage(CommandMessage *message, Command_t command,
 			HasHealthIF::HealthState health,
 			HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
-
 	static void setHealthMessage(CommandMessage *message, Command_t command);
 
 	static HasHealthIF::HealthState getHealth(const CommandMessage *message);

From b9c7d1bd3f77f8d2da1e7376ef55df99ea26ec92 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 18:09:04 +0200
Subject: [PATCH 0889/1774] added health subservices

---
 pus/CService200ModeCommanding.cpp      |  5 ++-
 pus/CService200ModeCommanding.h        |  5 +--
 pus/CService201HealthCommanding.cpp    | 54 +++++++++++++++++---------
 pus/CService201HealthCommanding.h      | 17 +++++---
 pus/servicepackets/Service201Packets.h |  4 +-
 5 files changed, 54 insertions(+), 31 deletions(-)

diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index c63b47a69..c4e99359b 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -7,9 +7,10 @@
 #include "../modes/ModeMessage.h"
 
 CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId):
+        uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
+        uint16_t commandTimeoutSeconds):
         CommandingServiceBase(objectId, apid, serviceId,
-	    NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {}
+                numParallelCommands, commandTimeoutSeconds) {}
 
 CService200ModeCommanding::~CService200ModeCommanding() {}
 
diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h
index c86d7b841..840402120 100644
--- a/pus/CService200ModeCommanding.h
+++ b/pus/CService200ModeCommanding.h
@@ -15,11 +15,10 @@
  */
 class CService200ModeCommanding: public CommandingServiceBase {
 public:
-	static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
-	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
 
 	CService200ModeCommanding(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId);
+	        uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands = 4,
+            uint16_t commandTimeoutSeconds = 60);
 	virtual~ CService200ModeCommanding();
 
 protected:
diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index 7e68533d9..db43db898 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -6,9 +6,10 @@
 #include "servicepackets/Service201Packets.h"
 
 CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId):
+        uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
+        uint16_t commandTimeoutSeconds):
 		CommandingServiceBase(objectId, apid, serviceId,
-		NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {
+		        numParallelCommands, commandTimeoutSeconds) {
 }
 
 CService201HealthCommanding::~CService201HealthCommanding() {
@@ -17,6 +18,8 @@ CService201HealthCommanding::~CService201HealthCommanding() {
 ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
 	switch(subservice) {
 	case(Subservice::COMMAND_SET_HEALTH):
+	case(Subservice::COMMAND_ANNOUNCE_HEALTH):
+	case(Subservice::COMMAND_ANNOUNCE_HEALTH_ALL):
 		return RETURN_OK;
 	default:
 		sif::error << "Invalid Subservice" << std::endl;
@@ -47,19 +50,34 @@ ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t CService201HealthCommanding::prepareCommand
-		(CommandMessage* message, uint8_t subservice, const uint8_t *tcData,
+ReturnValue_t CService201HealthCommanding::prepareCommand(
+        CommandMessage* message, uint8_t subservice, const uint8_t *tcData,
 		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
-	HealthCommand healthCommand;
-	ReturnValue_t result = healthCommand.deSerialize(&tcData, &tcDataLen,
-	        SerializeIF::Endianness::BIG);
-	if (result != RETURN_OK) {
-		return result;
-	} else {
-		HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_SET,
-				healthCommand.getHealth());
-		return result;
-	}
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    switch(subservice) {
+    case(Subservice::COMMAND_SET_HEALTH): {
+        HealthSetCommand healthCommand;
+        result = healthCommand.deSerialize(&tcData, &tcDataLen,
+                SerializeIF::Endianness::BIG);
+        if (result != RETURN_OK) {
+            break;
+        }
+        HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_SET,
+                healthCommand.getHealth());
+        break;
+    }
+    case(Subservice::COMMAND_ANNOUNCE_HEALTH): {
+        HealthMessage::setHealthMessage(message,
+                HealthMessage::HEALTH_ANNOUNCE);
+        break;
+    }
+    case(Subservice::COMMAND_ANNOUNCE_HEALTH_ALL): {
+        HealthMessage::setHealthMessage(message,
+                HealthMessage::HEALTH_ANNOUNCE_ALL);
+        break;
+    }
+    }
+    return result;
 }
 
 ReturnValue_t CService201HealthCommanding::handleReply
@@ -68,17 +86,17 @@ ReturnValue_t CService201HealthCommanding::handleReply
 		object_id_t objectId, bool *isStep) {
 	Command_t replyId = reply->getCommand();
 	if (replyId == HealthMessage::REPLY_HEALTH_SET) {
-		prepareHealthSetReply(reply);
+		return prepareHealthSetReply(reply);
 	}
-	return RETURN_OK;
+	return CommandingServiceBase::INVALID_REPLY;
 }
 
-void CService201HealthCommanding::prepareHealthSetReply(
+ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(
         const CommandMessage* reply) {
 	prepareHealthSetReply(reply);
 	uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
 	uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
 	HealthSetReply healthSetReply(health, oldHealth);
-	sendTmPacket(Subservice::REPLY_HEALTH_SET, &healthSetReply);
+	return sendTmPacket(Subservice::REPLY_HEALTH_SET, &healthSetReply);
 }
 
diff --git a/pus/CService201HealthCommanding.h b/pus/CService201HealthCommanding.h
index 100f675e2..124e2ac79 100644
--- a/pus/CService201HealthCommanding.h
+++ b/pus/CService201HealthCommanding.h
@@ -19,11 +19,10 @@
  */
 class CService201HealthCommanding: public CommandingServiceBase {
 public:
-    static const uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
-    static const uint16_t COMMAND_TIMEOUT_SECONDS = 60;
 
 	CService201HealthCommanding(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId);
+	        uint8_t serviceId, uint8_t numParallelCommands = 4,
+	        uint16_t commandTimeoutSeconds = 60);
 	virtual~ CService201HealthCommanding();
 protected:
 	/* CSB abstract function implementations */
@@ -47,11 +46,17 @@ private:
 	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
 			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
 
-	void prepareHealthSetReply(const CommandMessage *reply);
+	ReturnValue_t prepareHealthSetReply(const CommandMessage *reply);
 
 	enum Subservice {
-		COMMAND_SET_HEALTH = 1, //!< [EXPORT] : [TC] Set health of target object
-		REPLY_HEALTH_SET = 2 //!< [EXPORT] : [TM] Reply to health set command which also provides old health
+	    //! [EXPORT] : [TC] Set health of target object
+		COMMAND_SET_HEALTH = 1,
+		//! [EXPORT] : [TM] Reply to health set command which also provides old health
+		REPLY_HEALTH_SET = 2,
+		//! [EXPORT] : [TC] Commands object to announce their health as an event
+		COMMAND_ANNOUNCE_HEALTH = 3,
+		//! [EXPORT] : [TC] Commands all objects in the health map to announce their health
+		COMMAND_ANNOUNCE_HEALTH_ALL = 4
 	};
 };
 
diff --git a/pus/servicepackets/Service201Packets.h b/pus/servicepackets/Service201Packets.h
index 8dce88e5b..aed821f98 100644
--- a/pus/servicepackets/Service201Packets.h
+++ b/pus/servicepackets/Service201Packets.h
@@ -5,10 +5,10 @@
 #include "../../serialize/SerializeIF.h"
 #include "../../health/HasHealthIF.h"
 
-class HealthCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1
+class HealthSetCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1
 public:
 
-	HealthCommand() {
+	HealthSetCommand() {
 		setLinks();
 	}
 

From 670e9bfa0f4fa55fddfd3cbcd7669987e65aa3f5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 18:12:22 +0200
Subject: [PATCH 0890/1774] CMD/REPLY prefixes added

---
 pus/Service2DeviceAccess.cpp       | 12 ++++++------
 pus/Service2DeviceAccess.h         | 12 ++++++++----
 pus/Service8FunctionManagement.cpp |  4 ++--
 pus/Service8FunctionManagement.h   |  6 ++++--
 4 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 878a13b0c..3648b7eb6 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -21,8 +21,8 @@ Service2DeviceAccess::~Service2DeviceAccess() {}
 
 ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
 	switch(static_cast<Subservice>(subservice)){
-	case Subservice::RAW_COMMANDING:
-	case Subservice::TOGGLE_WIRETAPPING:
+	case Subservice::COMMAND_RAW_COMMANDING:
+	case Subservice::COMMAND_TOGGLE_WIRETAPPING:
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
 		sif::error << "Invalid Subservice" << std::endl;
@@ -58,11 +58,11 @@ ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
 		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
 		uint32_t* state, object_id_t objectId) {
 	switch(static_cast<Subservice>(subservice)){
-	case Subservice::RAW_COMMANDING: {
+	case Subservice::COMMAND_RAW_COMMANDING: {
 		return prepareRawCommand(message, tcData, tcDataLen);
 	}
 	break;
-	case Subservice::TOGGLE_WIRETAPPING: {
+	case Subservice::COMMAND_TOGGLE_WIRETAPPING: {
 		return prepareWiretappingCommand(message, tcData, tcDataLen);
 	}
 	break;
@@ -118,11 +118,11 @@ void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
 	switch(reply->getCommand()) {
 	case DeviceHandlerMessage::REPLY_RAW_COMMAND:
 		sendWiretappingTm(reply,
-				static_cast<uint8_t>(Subservice::WIRETAPPING_RAW_TC));
+				static_cast<uint8_t>(Subservice::REPLY_WIRETAPPING_RAW_TC));
 		break;
 	case DeviceHandlerMessage::REPLY_RAW_REPLY:
 		sendWiretappingTm(reply,
-				static_cast<uint8_t>(Subservice::RAW_REPLY));
+				static_cast<uint8_t>(Subservice::REPLY_RAW));
 		break;
 	default:
 		sif::error << "Unknown message in Service2DeviceAccess::"
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index fa2ea75c7..b62e6854a 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -81,10 +81,14 @@ private:
 	        const uint8_t* tcData, size_t tcDataLen);
 
 	enum class Subservice {
-		RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol
-		TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
-		RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
-		WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
+	    //!< [EXPORT] : [COMMAND] Command in device native protocol
+		COMMAND_RAW_COMMANDING = 128,
+		//!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
+		COMMAND_TOGGLE_WIRETAPPING = 129,
+		//!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
+		REPLY_RAW = 130,
+		//!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
+		REPLY_WIRETAPPING_RAW_TC = 131
 	};
 };
 
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index c1c88a50c..d710c56e1 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -19,7 +19,7 @@ Service8FunctionManagement::~Service8FunctionManagement() {}
 ReturnValue_t Service8FunctionManagement::isValidSubservice(
 		uint8_t subservice) {
 	switch(static_cast<Subservice>(subservice)) {
-	case Subservice::DIRECT_COMMANDING:
+	case Subservice::COMMAND_DIRECT_COMMANDING:
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
 		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
@@ -131,7 +131,7 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(
     }
     DataReply dataReply(objectId, actionId, buffer, size);
     result = sendTmPacket(static_cast<uint8_t>(
-            Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
+            Subservice::REPLY_DIRECT_COMMANDING_DATA), &dataReply);
 
     auto deletionResult = IPCStore->deleteData(storeId);
     if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index 292a5e36c..00153cfb0 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -52,8 +52,10 @@ protected:
 
 private:
 	enum class Subservice {
-		DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding
-		DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply
+	    //!< [EXPORT] : [COMMAND] Functional commanding
+		COMMAND_DIRECT_COMMANDING = 128,
+		//!< [EXPORT] : [REPLY] Data reply
+		REPLY_DIRECT_COMMANDING_DATA = 130,
 	};
 
 	ReturnValue_t checkInterfaceAndAcquireMessageQueue(

From 3e79d2e73ad239b5f1c4838178f35348ac5ca6b8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 20:04:01 +0200
Subject: [PATCH 0891/1774] added extended controller base

---
 controller/ControllerBase.cpp         |   8 +-
 controller/ControllerBase.h           |  30 +++----
 controller/ExtendedControllerBase.cpp | 110 ++++++++++++++++++++++++++
 controller/ExtendedControllerBase.h   |  70 ++++++++++++++++
 4 files changed, 201 insertions(+), 17 deletions(-)
 create mode 100644 controller/ExtendedControllerBase.cpp
 create mode 100644 controller/ExtendedControllerBase.h

diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 4f50fe1ff..45e678eb4 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -9,7 +9,8 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
 		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
 		submode(SUBMODE_NONE), modeHelper(this),
 		healthHelper(this, setObjectId), hkSwitcher(this) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
+	commandQueue = QueueFactory::instance()->createMessageQueue(
+	        commandQueueDepth);
 }
 
 ControllerBase::~ControllerBase() {
@@ -56,8 +57,9 @@ MessageQueueId_t ControllerBase::getCommandQueue() const {
 
 void ControllerBase::handleQueue() {
 	CommandMessage command;
-	ReturnValue_t result;
-	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	for (result = commandQueue->receiveMessage(&command);
+	        result == RETURN_OK;
 			result = commandQueue->receiveMessage(&command)) {
 
 		result = modeHelper.handleModeCommand(&command);
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 6c2ec1d66..25d3ab1f3 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -11,9 +11,10 @@
 #include "../datapool/HkSwitchHelper.h"
 
 /**
- * @brief  Generic base class for controller classes
+ * @brief   Generic base class for controller classes
  * @details
- * Implements common interfaces for controllers.
+ * Implements common interfaces for controllers, which generally have
+ * a mode and a health state. This avoids boilerplate code.
  */
 class ControllerBase: public HasModesIF,
 		public HasHealthIF,
@@ -27,24 +28,18 @@ public:
 			size_t commandQueueDepth = 3);
 	virtual ~ControllerBase();
 
+	/** SystemObject override */
 	virtual ReturnValue_t initialize() override;
 
 	virtual MessageQueueId_t getCommandQueue() const override;
 
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-
+	/** HasHealthIF overrides */
 	virtual ReturnValue_t setHealth(HealthState health) override;
-
 	virtual HasHealthIF::HealthState getHealth() override;
 
-	/**
-	 * Implementation of ExecutableObjectIF function
-	 *
-	 * Used to setup the reference of the task, that executes this component
-	 * @param task_ Pointer to the taskIF of this task
-	 */
-	virtual  void setTaskIF(PeriodicTaskIF* task_) override;
-
+	/** ExecutableObjectIF overrides */
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual void setTaskIF(PeriodicTaskIF* task) override;
 	virtual ReturnValue_t initializeAfterTaskCreation() override;
 
 protected:
@@ -57,6 +52,9 @@ protected:
 	 */
     virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
 
+    /**
+     * Periodic helper, implemented by child class.
+     */
     virtual void performControlOperation() = 0;
 
     virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
@@ -74,6 +72,7 @@ protected:
 
 	HealthHelper healthHelper;
 
+	// Is this still needed?
 	HkSwitchHelper hkSwitcher;
 
 	/**
@@ -82,13 +81,16 @@ protected:
 	 */
 	PeriodicTaskIF* executingTask = nullptr;
 
-	void handleQueue();
+	/** Handle mode and health messages */
+	virtual void handleQueue();
 
+	/** Mode helpers */
 	virtual void modeChanged(Mode_t mode, Submode_t submode);
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
 	virtual void setToExternalControl();
 	virtual void announceMode(bool recursive);
+	/** HK helpers */
 	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 };
 
diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
new file mode 100644
index 000000000..f3336e438
--- /dev/null
+++ b/controller/ExtendedControllerBase.cpp
@@ -0,0 +1,110 @@
+#include "ExtendedControllerBase.h"
+
+
+ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId,
+        object_id_t parentId, size_t commandQueueDepth):
+        ControllerBase(objectId, parentId, commandQueueDepth),
+        localPoolManager(this, commandQueue),
+        actionHelper(this, commandQueue) {
+}
+
+ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
+        MessageQueueId_t commandedBy, const uint8_t *data, size_t size) {
+    // needs to be overriden and implemented by child class.
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+
+ReturnValue_t ExtendedControllerBase::initializeLocalDataPool(
+        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+    // needs to be overriden and implemented by child class.
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+object_id_t ExtendedControllerBase::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() {
+    return &localPoolManager;
+}
+
+uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const {
+    return this->executingTask->getPeriodMs();
+}
+
+ReturnValue_t ExtendedControllerBase::handleCommandMessage(
+        CommandMessage *message) {
+    ReturnValue_t result = actionHelper.handleActionMessage(message);
+    if(result == HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return localPoolManager.handleHousekeepingMessage(message);
+}
+
+void ExtendedControllerBase::handleQueue() {
+    CommandMessage command;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    for (result = commandQueue->receiveMessage(&command);
+            result == RETURN_OK;
+            result = commandQueue->receiveMessage(&command)) {
+        result = actionHelper.handleActionMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = modeHelper.handleModeCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = healthHelper.handleHealthCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = localPoolManager.handleHousekeepingMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = handleCommandMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+        command.setToUnknownCommand();
+        commandQueue->reply(&command);
+    }
+}
+
+ReturnValue_t ExtendedControllerBase::initialize() {
+    ReturnValue_t result = ControllerBase::initialize();
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = actionHelper.initialize(commandQueue);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    return localPoolManager.initialize(commandQueue);
+}
+
+ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
+    return localPoolManager.initializeAfterTaskCreation();
+}
+
+ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
+    handleQueue();
+    hkSwitcher.performOperation();
+    localPoolManager.performHkOperation();
+    performControlOperation();
+    return RETURN_OK;
+}
+
+LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
+    sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
+            << " implementation provided, returning nullptr!" << std::endl;
+    return nullptr;
+}
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
new file mode 100644
index 000000000..fa47950ac
--- /dev/null
+++ b/controller/ExtendedControllerBase.h
@@ -0,0 +1,70 @@
+#ifndef FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_
+#define FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_
+
+#include "ControllerBase.h"
+
+#include "../action/HasActionsIF.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../action/ActionHelper.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+
+/**
+ * @brief   Extendes the basic ControllerBase with the common components
+ *          HasActionsIF for commandability and HasLocalDataPoolIF to keep
+ *          a pool of local data pool variables.
+ * @details
+ * Default implementations required for the interfaces will be empty and have
+ * to be implemented by child class.
+ */
+class ExtendedControllerBase: public ControllerBase,
+        public HasActionsIF,
+        public HasLocalDataPoolIF {
+public:
+    ExtendedControllerBase(object_id_t objectId, object_id_t parentId,
+            size_t commandQueueDepth = 3);
+
+    /** SystemObjectIF overrides */
+    virtual ReturnValue_t initialize() override;
+
+    /** ExecutableObjectIF overrides */
+    virtual ReturnValue_t performOperation(uint8_t opCode) override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+    LocalDataPoolManager localPoolManager;
+    ActionHelper actionHelper;
+
+    /**
+     * Implemented by child class. Handle all command messages which are
+     * not health, mode, action or housekeeping messages.
+     * @param message
+     * @return
+     */
+    virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+    /**
+     * Periodic helper from ControllerBase, implemented by child class.
+     */
+    virtual void performControlOperation() = 0;
+
+    /** Handle the four messages mentioned above */
+    void handleQueue() override;
+
+    /** HasActionsIF overrides */
+    virtual ReturnValue_t executeAction(ActionId_t actionId,
+            MessageQueueId_t commandedBy, const uint8_t* data,
+            size_t size) override;
+
+    /** HasLocalDatapoolIF overrides */
+    virtual object_id_t getObjectId() const override;
+    virtual ReturnValue_t initializeLocalDataPool(
+            LocalDataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override;
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
+    virtual uint32_t getPeriodicOperationFrequency() const override;
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+};
+
+
+
+#endif /* FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_ */

From ed71a3700435aa8532abd2764ddfa9d5be882235 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 20:11:20 +0200
Subject: [PATCH 0892/1774] get command queue override

---
 controller/ExtendedControllerBase.cpp | 4 ++++
 controller/ExtendedControllerBase.h   | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index f3336e438..f69d2ea1a 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -103,6 +103,10 @@ ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
     return RETURN_OK;
 }
 
+MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
+    return commandQueue->getId();
+}
+
 LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
     sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
             << " implementation provided, returning nullptr!" << std::endl;
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index fa47950ac..02c5728e1 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -26,6 +26,8 @@ public:
     /** SystemObjectIF overrides */
     virtual ReturnValue_t initialize() override;
 
+    virtual MessageQueueId_t getCommandQueue() const override;
+
     /** ExecutableObjectIF overrides */
     virtual ReturnValue_t performOperation(uint8_t opCode) override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;

From 18671a0db7357a0e209cc547d64271f84f8893af Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 13:40:24 +0200
Subject: [PATCH 0893/1774] doc wrong

---
 action/HasActionsIF.h | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 886d08377..a26ed5883 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -47,10 +47,9 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	/**
 	 * Execute or initialize the execution of a certain function.
-	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to
-	 * be done. When needing more steps, return RETURN_OK and issue steps and
-	 * completion manually.
-	 * One "step failed" or completion report must be issued!
+	 * When used in conjunction with the ActionHelper class, returning
+	 * a return code which is not equal to RETURN_OK will trigger a step reply
+	 * with step 0.
 	 */
 	virtual ReturnValue_t executeAction(ActionId_t actionId,
 			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;

From b6a23727f2dcbe498276b3c86306d24a8e1462f8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 15:40:27 +0200
Subject: [PATCH 0894/1774] added extended controller base

---
 controller/ExtendedControllerBase.cpp | 114 ++++++++++++++++++++++++++
 controller/ExtendedControllerBase.h   |  72 ++++++++++++++++
 2 files changed, 186 insertions(+)
 create mode 100644 controller/ExtendedControllerBase.cpp
 create mode 100644 controller/ExtendedControllerBase.h

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
new file mode 100644
index 000000000..f69d2ea1a
--- /dev/null
+++ b/controller/ExtendedControllerBase.cpp
@@ -0,0 +1,114 @@
+#include "ExtendedControllerBase.h"
+
+
+ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId,
+        object_id_t parentId, size_t commandQueueDepth):
+        ControllerBase(objectId, parentId, commandQueueDepth),
+        localPoolManager(this, commandQueue),
+        actionHelper(this, commandQueue) {
+}
+
+ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
+        MessageQueueId_t commandedBy, const uint8_t *data, size_t size) {
+    // needs to be overriden and implemented by child class.
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+
+ReturnValue_t ExtendedControllerBase::initializeLocalDataPool(
+        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+    // needs to be overriden and implemented by child class.
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+object_id_t ExtendedControllerBase::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() {
+    return &localPoolManager;
+}
+
+uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const {
+    return this->executingTask->getPeriodMs();
+}
+
+ReturnValue_t ExtendedControllerBase::handleCommandMessage(
+        CommandMessage *message) {
+    ReturnValue_t result = actionHelper.handleActionMessage(message);
+    if(result == HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return localPoolManager.handleHousekeepingMessage(message);
+}
+
+void ExtendedControllerBase::handleQueue() {
+    CommandMessage command;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    for (result = commandQueue->receiveMessage(&command);
+            result == RETURN_OK;
+            result = commandQueue->receiveMessage(&command)) {
+        result = actionHelper.handleActionMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = modeHelper.handleModeCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = healthHelper.handleHealthCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = localPoolManager.handleHousekeepingMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+
+        result = handleCommandMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+        command.setToUnknownCommand();
+        commandQueue->reply(&command);
+    }
+}
+
+ReturnValue_t ExtendedControllerBase::initialize() {
+    ReturnValue_t result = ControllerBase::initialize();
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = actionHelper.initialize(commandQueue);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    return localPoolManager.initialize(commandQueue);
+}
+
+ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
+    return localPoolManager.initializeAfterTaskCreation();
+}
+
+ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
+    handleQueue();
+    hkSwitcher.performOperation();
+    localPoolManager.performHkOperation();
+    performControlOperation();
+    return RETURN_OK;
+}
+
+MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
+    return commandQueue->getId();
+}
+
+LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
+    sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
+            << " implementation provided, returning nullptr!" << std::endl;
+    return nullptr;
+}
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
new file mode 100644
index 000000000..02c5728e1
--- /dev/null
+++ b/controller/ExtendedControllerBase.h
@@ -0,0 +1,72 @@
+#ifndef FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_
+#define FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_
+
+#include "ControllerBase.h"
+
+#include "../action/HasActionsIF.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../action/ActionHelper.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+
+/**
+ * @brief   Extendes the basic ControllerBase with the common components
+ *          HasActionsIF for commandability and HasLocalDataPoolIF to keep
+ *          a pool of local data pool variables.
+ * @details
+ * Default implementations required for the interfaces will be empty and have
+ * to be implemented by child class.
+ */
+class ExtendedControllerBase: public ControllerBase,
+        public HasActionsIF,
+        public HasLocalDataPoolIF {
+public:
+    ExtendedControllerBase(object_id_t objectId, object_id_t parentId,
+            size_t commandQueueDepth = 3);
+
+    /** SystemObjectIF overrides */
+    virtual ReturnValue_t initialize() override;
+
+    virtual MessageQueueId_t getCommandQueue() const override;
+
+    /** ExecutableObjectIF overrides */
+    virtual ReturnValue_t performOperation(uint8_t opCode) override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+    LocalDataPoolManager localPoolManager;
+    ActionHelper actionHelper;
+
+    /**
+     * Implemented by child class. Handle all command messages which are
+     * not health, mode, action or housekeeping messages.
+     * @param message
+     * @return
+     */
+    virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+    /**
+     * Periodic helper from ControllerBase, implemented by child class.
+     */
+    virtual void performControlOperation() = 0;
+
+    /** Handle the four messages mentioned above */
+    void handleQueue() override;
+
+    /** HasActionsIF overrides */
+    virtual ReturnValue_t executeAction(ActionId_t actionId,
+            MessageQueueId_t commandedBy, const uint8_t* data,
+            size_t size) override;
+
+    /** HasLocalDatapoolIF overrides */
+    virtual object_id_t getObjectId() const override;
+    virtual ReturnValue_t initializeLocalDataPool(
+            LocalDataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override;
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
+    virtual uint32_t getPeriodicOperationFrequency() const override;
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+};
+
+
+
+#endif /* FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_ */

From b9ebd153a2d6e897b76c41d09f2f2f8d40c1d517 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 16:55:40 +0200
Subject: [PATCH 0895/1774] added action helper function

---
 action/ActionHelper.cpp | 56 ++++++++++++++++++++++++++++++++++++-----
 action/ActionHelper.h   | 15 +++++++++--
 2 files changed, 63 insertions(+), 8 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index ab986c6c4..9fd117f39 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -89,22 +89,28 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
+	result = data->serialize(&dataPtr, &size, maxSize,
+	        SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		ipcStore->deleteData(storeAddress);
 		return result;
 	}
-	//We don't need to report the objectId, as we receive REQUESTED data before the completion success message.
-	//True aperiodic replies need to be reported with another dedicated message.
+	// We don't need to report the objectId, as we receive REQUESTED data
+	// before the completion success message.
+	// True aperiodic replies need to be reported with
+	// another dedicated message.
 	ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
 	//TODO Service Implementation sucks at the moment
-	if (hideSender){
+	// why does it suck and why would someone need to hide the sender?
+	if (hideSender) {
 		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
-	} else {
+	}
+	else {
 		result = queueToUse->sendMessage(reportTo, &reply);
 	}
-	if ( result != HasReturnvaluesIF::RETURN_OK){
+
+	if (result != HasReturnvaluesIF::RETURN_OK){
 		ipcStore->deleteData(storeAddress);
 	}
 	return result;
@@ -112,3 +118,41 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 
 void ActionHelper::resetHelper() {
 }
+
+ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
+        ActionId_t replyId, const uint8_t *data, size_t dataSize,
+        bool hideSender) {
+    CommandMessage reply;
+    store_address_t storeAddress;
+    uint8_t *dataPtr = nullptr;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeAddress);
+        return result;
+    }
+
+    // We don't need to report the objectId, as we receive REQUESTED data
+    // before the completion success message.
+    // True aperiodic replies need to be reported with
+    // another dedicated message.
+    ActionMessage::setDataReply(&reply, replyId, storeAddress);
+
+    //TODO Service Implementation sucks at the moment
+    // why does it suck and why would someone need to hide the sender?
+    if (hideSender) {
+        result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+    }
+    else {
+        result = queueToUse->sendMessage(reportTo, &reply);
+    }
+
+    if (result != HasReturnvaluesIF::RETURN_OK){
+        ipcStore->deleteData(storeAddress);
+    }
+    return result;
+}
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index a20f286a1..17ca3ebdc 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -69,8 +69,8 @@ public:
 	void finish(MessageQueueId_t reportTo, ActionId_t commandId,
 	        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
 	/**
-	 * Function to be called by the owner if an action does report data
-	 *
+	 * Function to be called by the owner if an action does report data.
+	 * Takes a SerializeIF* pointer and serializes it into the IPC store.
 	 * @param reportTo  MessageQueueId_t to report the action completion
 	 *                  message to
 	 * @param replyId ID of the executed command
@@ -79,6 +79,17 @@ public:
 	 */
 	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
 	        SerializeIF* data, bool hideSender = false);
+    /**
+     * Function to be called by the owner if an action does report data.
+     * Takes the raw data and writes it into the IPC store.
+     * @param reportTo  MessageQueueId_t to report the action completion
+     *                  message to
+     * @param replyId ID of the executed command
+     * @param data Pointer to the data
+     * @return Returns RETURN_OK if successful, otherwise failure code
+     */
+    ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
+            const uint8_t* data, size_t dataSize, bool hideSender = false);
 	/**
 	 * Function to setup the MessageQueueIF* of the helper. Can be used to
 	 * set the MessageQueueIF* if message queue is unavailable at construction

From e4c74ec060df2beb86eb34f1b2a9a8b1193adbd8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 16:57:37 +0200
Subject: [PATCH 0896/1774] added todos

---
 action/ActionHelper.cpp | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 9fd117f39..8122885bb 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -101,8 +101,8 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 	// another dedicated message.
 	ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
-	//TODO Service Implementation sucks at the moment
-	// why does it suck and why would someone need to hide the sender?
+	// TODO: Service Implementation sucks at the moment
+	// TODO: why does it suck and why would someone need to hide the sender?
 	if (hideSender) {
 		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
 	}
@@ -124,8 +124,6 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
         bool hideSender) {
     CommandMessage reply;
     store_address_t storeAddress;
-    uint8_t *dataPtr = nullptr;
-    size_t size = 0;
     ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
     if (result != HasReturnvaluesIF::RETURN_OK) {
         return result;
@@ -142,8 +140,8 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
     // another dedicated message.
     ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
-    //TODO Service Implementation sucks at the moment
-    // why does it suck and why would someone need to hide the sender?
+    // TODO: Service Implementation sucks at the moment
+    // TODO: why does it suck and why would someone need to hide the sender?
     if (hideSender) {
         result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
     }

From 06c7919daa1f30e93452d2fe284d7ff0ccae4a41 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 17:39:13 +0200
Subject: [PATCH 0897/1774] monitoring form improvements

---
 monitoring/AbsLimitMonitor.h | 23 +++++++++++++++--------
 monitoring/HasMonitorsIF.h   | 12 +++---------
 monitoring/MonitoringIF.h    |  8 ++++----
 3 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index 2e60f6f8c..c9c33c74b 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
+#ifndef FSFW_MONITORING_ABSLIMITMONITOR_H_
+#define FSFW_MONITORING_ABSLIMITMONITOR_H_
 
 #include "MonitorBase.h"
 #include <cmath>
@@ -7,9 +7,14 @@
 template<typename T>
 class AbsLimitMonitor: public MonitorBase<T> {
 public:
-	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
-			uint16_t confirmationLimit, T limit, Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE, bool aboveIsViolation = true) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), limit(limit), violationEvent(violationEvent), aboveIsViolation(aboveIsViolation) {
+	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId,
+	        uint32_t parameterId, uint16_t confirmationLimit, T limit,
+	        Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE,
+	        bool aboveIsViolation = true) :
+			MonitorBase<T>(reporterId, monitorId, parameterId,
+			        confirmationLimit),
+			limit(limit), violationEvent(violationEvent),
+			aboveIsViolation(aboveIsViolation) {
 	}
 	virtual ~AbsLimitMonitor() {
 	}
@@ -32,7 +37,8 @@ public:
 			const ParameterWrapper *newValues, uint16_t startAtIndex) {
 		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
 				parameterId, parameterWrapper, newValues, startAtIndex);
-		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
+		// We'll reuse the DOMAIN_ID of MonitorReporter,
+		// as we know the parameterIds used there.
 		if (result != this->INVALID_MATRIX_ID) {
 			return result;
 		}
@@ -59,7 +65,8 @@ protected:
 	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
 		switch (state) {
 		case MonitoringIF::OUT_OF_RANGE:
-			EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->parameterId);
+			EventManagerIF::triggerEvent(this->reportingId,
+			        violationEvent, this->parameterId);
 			break;
 		default:
 			break;
@@ -70,4 +77,4 @@ protected:
 	const bool aboveIsViolation;
 };
 
-#endif /* FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ */
+#endif /* FSFW_MONITORING_ABSLIMITMONITOR_H_ */
diff --git a/monitoring/HasMonitorsIF.h b/monitoring/HasMonitorsIF.h
index 85d92b6b9..04f634374 100644
--- a/monitoring/HasMonitorsIF.h
+++ b/monitoring/HasMonitorsIF.h
@@ -1,11 +1,5 @@
-/**
- * @file	HasMonitorsIF.h
- * @brief	This file defines the HasMonitorsIF class.
- * @date	28.07.2014
- * @author	baetz
- */
-#ifndef HASMONITORSIF_H_
-#define HASMONITORSIF_H_
+#ifndef FSFW_MONITORING_HASMONITORSIF_H_
+#define FSFW_MONITORING_HASMONITORSIF_H_
 
 #include "../events/EventReportingProxyIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
@@ -27,4 +21,4 @@ public:
 	}
 };
 
-#endif /* HASMONITORSIF_H_ */
+#endif /* FSFW_MONITORING_HASMONITORSIF_H_ */
diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h
index 44218c36d..aa266f337 100644
--- a/monitoring/MonitoringIF.h
+++ b/monitoring/MonitoringIF.h
@@ -1,8 +1,8 @@
-#ifndef MONITORINGIF_H_
-#define MONITORINGIF_H_
+#ifndef FSFW_MONITORING_MONITORINGIF_H_
+#define FSFW_MONITORING_MONITORINGIF_H_
 
-#include "../memory/HasMemoryIF.h"
 #include "MonitoringMessage.h"
+#include "../memory/HasMemoryIF.h"
 #include "../serialize/SerializeIF.h"
 
 class MonitoringIF : public SerializeIF {
@@ -64,4 +64,4 @@ public:
 
 
 
-#endif /* MONITORINGIF_H_ */
+#endif /* FSFW_MONITORING_MONITORINGIF_H_ */

From 736ce2d5fd199ed5c18eb2d59718ce4faa3b5cff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 17:42:30 +0200
Subject: [PATCH 0898/1774] some more form improvements

---
 monitoring/MonitorBase.h     | 36 ++++++++++++++++++++++--------------
 monitoring/MonitorReporter.h | 26 +++++++++++++++-----------
 2 files changed, 37 insertions(+), 25 deletions(-)

diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 964fd55ef..5f9a2cafa 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,35 +1,42 @@
-#ifndef MONITORBASE_H_
-#define MONITORBASE_H_
+#ifndef FSFW_MONITORING_MONITORBASE_H_
+#define FSFW_MONITORING_MONITORBASE_H_
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/PIDReader.h"
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
 #include "MonitorReporter.h"
 
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/PIDReader.h"
+
 /**
- * Base class for monitoring of parameters.
- * Can be used anywhere, specializations need to implement checkSample and should override sendTransitionEvent.
- * Manages state handling, enabling and disabling of events/reports and forwarding of transition
- * reports via MonitorReporter. In addition, it provides default implementations for fetching the parameter sample from
- * the data pool and a simple confirmation counter.
+ * @brief   Base class for monitoring of parameters.
+ * @details
+ * Can be used anywhere, specializations need to implement checkSample and
+ * should override sendTransitionEvent.
+ * Manages state handling, enabling and disabling of events/reports and
+ * forwarding of transition reports via MonitorReporter.
+ *
+ * In addition, it provides default implementations for fetching the
+ * parameter sample from the data pool and a simple confirmation counter.
  */
 template<typename T>
 class MonitorBase: public MonitorReporter<T> {
 public:
 	MonitorBase(object_id_t reporterId, uint8_t monitorId,
 			uint32_t parameterId, uint16_t confirmationLimit) :
-			MonitorReporter<T>(reporterId, monitorId, parameterId, confirmationLimit) {
+			MonitorReporter<T>(reporterId, monitorId, parameterId,
+			        confirmationLimit) {
 	}
 	virtual ~MonitorBase() {
 	}
 	virtual ReturnValue_t check() {
-		//1. Fetch sample of type T, return validity.
+		// 1. Fetch sample of type T, return validity.
 		T sample = 0;
 		ReturnValue_t validity = fetchSample(&sample);
 
-		//2. If returning from fetch != OK, parameter is invalid. Report (if oldState is != invalidity).
+		// 2. If returning from fetch != OK, parameter is invalid.
+		// Report (if oldState is != invalidity).
 		if (validity != HasReturnvaluesIF::RETURN_OK) {
 			this->monitorStateIs(validity, sample, 0);
 			//3. Otherwise, check sample.
@@ -43,7 +50,8 @@ public:
 		ReturnValue_t currentState = checkSample(sample, &crossedLimit);
 		return this->monitorStateIs(currentState,sample, crossedLimit);
 	}
-	//Abstract or default.
+
+	// Abstract or default.
 	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
 
 protected:
@@ -59,4 +67,4 @@ protected:
 	}
 };
 
-#endif /* MONITORBASE_H_ */
+#endif /* FSFW_MONITORING_MONITORBASE_H_ */
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index ca2b534b9..88fa6ede5 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -1,10 +1,11 @@
-#ifndef FRAMEWORK_MONITORING_MONITORREPORTER_H_
-#define FRAMEWORK_MONITORING_MONITORREPORTER_H_
+#ifndef FSFW_MONITORING_MONITORREPORTER_H_
+#define FSFW_MONITORING_MONITORREPORTER_H_
 
-#include "../events/EventManagerIF.h"
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
+
+#include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 
 template<typename T>
@@ -14,11 +15,12 @@ public:
 	static const uint8_t ENABLED = 1;
 	static const uint8_t DISABLED = 0;
 
-	MonitorReporter(object_id_t reportingId, uint8_t monitorId, uint32_t parameterId, uint16_t confirmationLimit) :
-			monitorId(monitorId), parameterId(parameterId), reportingId(
-					reportingId), oldState(MonitoringIF::UNCHECKED), reportingEnabled(
-			ENABLED), eventEnabled(ENABLED), currentCounter(0), confirmationLimit(
-					confirmationLimit) {
+	MonitorReporter(object_id_t reportingId, uint8_t monitorId,
+	        uint32_t parameterId, uint16_t confirmationLimit) :
+			monitorId(monitorId), parameterId(parameterId),
+			reportingId(reportingId), oldState(MonitoringIF::UNCHECKED),
+			reportingEnabled(ENABLED), eventEnabled(ENABLED), currentCounter(0),
+			confirmationLimit(confirmationLimit) {
 	}
 
 	virtual ~MonitorReporter() {
@@ -148,7 +150,8 @@ protected:
 		case HasReturnvaluesIF::RETURN_OK:
 			break;
 		default:
-			EventManagerIF::triggerEvent(reportingId, MonitoringIF::MONITOR_CHANGED_STATE, state);
+			EventManagerIF::triggerEvent(reportingId,
+			        MonitoringIF::MONITOR_CHANGED_STATE, state);
 			break;
 		}
 	}
@@ -159,7 +162,8 @@ protected:
 	 * @param crossedLimit The limit crossed (if applicable).
 	 * @param state Current state the monitor is in.
 	 */
-	virtual void sendTransitionReport(T parameterValue, T crossedLimit, ReturnValue_t state) {
+	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
+	        ReturnValue_t state) {
 		MonitoringReportContent<T> report(parameterId,
 				parameterValue, crossedLimit, oldState, state);
 		LimitViolationReporter::sendLimitViolationReport(&report);
@@ -175,4 +179,4 @@ protected:
 	}
 };
 
-#endif /* FRAMEWORK_MONITORING_MONITORREPORTER_H_ */
+#endif /* FSFW_MONITORING_MONITORREPORTER_H_ */

From afe5a627895f40bb05d314aaa98eb9ee898424ca Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 18:12:26 +0200
Subject: [PATCH 0899/1774] imrpoved form, removed comm msg for now

---
 devicehandlers/AcceptsDeviceResponsesIF.h   |   6 +-
 devicehandlers/AssemblyBase.cpp             |   2 +-
 devicehandlers/AssemblyBase.h               |  11 +-
 devicehandlers/ChildHandlerBase.cpp         |   2 +-
 devicehandlers/ChildHandlerBase.h           |  14 +-
 devicehandlers/ChildHandlerFDIR.cpp         |   5 +-
 devicehandlers/ChildHandlerFDIR.h           |   6 +-
 devicehandlers/CommunicationMessage.cpp     | 201 --------------------
 devicehandlers/CommunicationMessage.h       | 173 -----------------
 devicehandlers/CookieIF.h                   |   9 +-
 devicehandlers/DeviceCommunicationIF.h      |  11 +-
 devicehandlers/DeviceTmReportingWrapper.cpp |   3 +-
 devicehandlers/DeviceTmReportingWrapper.h   |   6 +-
 devicehandlers/HealthDevice.cpp             |   5 +-
 devicehandlers/HealthDevice.h               |   6 +-
 15 files changed, 46 insertions(+), 414 deletions(-)
 delete mode 100644 devicehandlers/CommunicationMessage.cpp
 delete mode 100644 devicehandlers/CommunicationMessage.h

diff --git a/devicehandlers/AcceptsDeviceResponsesIF.h b/devicehandlers/AcceptsDeviceResponsesIF.h
index eb7780dbe..8e13ba0c0 100644
--- a/devicehandlers/AcceptsDeviceResponsesIF.h
+++ b/devicehandlers/AcceptsDeviceResponsesIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
-#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+#ifndef FSFW_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+#define FSFW_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
 
 #include "../ipc/MessageQueueSenderIF.h"
 
@@ -16,4 +16,4 @@ public:
 	virtual MessageQueueId_t getDeviceQueue() = 0;
 };
 
-#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
+#endif /* FSFW_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index 3bcb8a112..46b2211ae 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -1,4 +1,4 @@
-#include "../devicehandlers/AssemblyBase.h"
+#include "AssemblyBase.h"
 
 AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
 		uint16_t commandQueueDepth) :
diff --git a/devicehandlers/AssemblyBase.h b/devicehandlers/AssemblyBase.h
index b67c551e5..353d5f899 100644
--- a/devicehandlers/AssemblyBase.h
+++ b/devicehandlers/AssemblyBase.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
-#define FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
+#ifndef FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_
+#define FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_
 
+#include "DeviceHandlerBase.h"
 #include "../container/FixedArrayList.h"
-#include "../devicehandlers/DeviceHandlerBase.h"
 #include "../subsystem/SubsystemBase.h"
 
 /**
@@ -156,8 +156,9 @@ protected:
 	 * Also sets state to STATE_OVERWRITE_HEATH.
 	 * @param objectId Must be a registered child.
 	 */
-	void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
+	void overwriteDeviceHealth(object_id_t objectId,
+	        HasHealthIF::HealthState oldHealth);
 
 };
 
-#endif /* FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
+#endif /* FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 976c252ad..d4ef67ad8 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -1,5 +1,5 @@
+#include "ChildHandlerBase.h"
 #include "../subsystem/SubsystemBase.h"
-#include "../devicehandlers/ChildHandlerBase.h"
 #include "../subsystem/SubsystemBase.h"
 
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 19e0fc80e..eed4c95e2 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -1,8 +1,8 @@
-#ifndef PAYLOADHANDLERBASE_H_
-#define PAYLOADHANDLERBASE_H_
+#ifndef FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_
+#define FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_
 
-#include "../devicehandlers/ChildHandlerFDIR.h"
-#include "../devicehandlers/DeviceHandlerBase.h"
+#include "DeviceHandlerBase.h"
+#include "ChildHandlerFDIR.h"
 
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
@@ -10,7 +10,9 @@ public:
 			CookieIF * cookie, object_id_t hkDestination,
 			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 			object_id_t parent = objects::NO_OBJECT,
-			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
+			FailureIsolationBase* customFdir = nullptr,
+			size_t cmdQueueSize = 20);
+
 	virtual ~ChildHandlerBase();
 
 	virtual ReturnValue_t initialize();
@@ -21,4 +23,4 @@ protected:
 
 };
 
-#endif /* PAYLOADHANDLERBASE_H_ */
+#endif /* FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_ */
diff --git a/devicehandlers/ChildHandlerFDIR.cpp b/devicehandlers/ChildHandlerFDIR.cpp
index 9589b44fc..cb4c75eaf 100644
--- a/devicehandlers/ChildHandlerFDIR.cpp
+++ b/devicehandlers/ChildHandlerFDIR.cpp
@@ -1,6 +1,7 @@
-#include "../devicehandlers/ChildHandlerFDIR.h"
+#include "ChildHandlerFDIR.h"
 
-ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent, uint32_t recoveryCount) :
+ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner,
+        object_id_t faultTreeParent, uint32_t recoveryCount) :
 		DeviceHandlerFailureIsolation(owner, faultTreeParent) {
 	recoveryCounter.setFailureThreshold(recoveryCount);
 }
diff --git a/devicehandlers/ChildHandlerFDIR.h b/devicehandlers/ChildHandlerFDIR.h
index 203fc9443..13d1345c1 100644
--- a/devicehandlers/ChildHandlerFDIR.h
+++ b/devicehandlers/ChildHandlerFDIR.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
-#define FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+#ifndef FSFW_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+#define FSFW_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
 
-#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+#include "DeviceHandlerFailureIsolation.h"
 
 /**
  * Very simple extension to normal FDIR.
diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
deleted file mode 100644
index 577742709..000000000
--- a/devicehandlers/CommunicationMessage.cpp
+++ /dev/null
@@ -1,201 +0,0 @@
-/**
- * @file CommunicationMessage.cpp
- *
- * @date 28.02.2020
- */
-
-#include "../devicehandlers/CommunicationMessage.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <cstring>
-
-CommunicationMessage::CommunicationMessage(): uninitialized(true) {
-}
-
-CommunicationMessage::~CommunicationMessage() {}
-
-void CommunicationMessage::setSendRequestFromPointer(uint32_t address,
-		uint32_t dataLen, const uint8_t * data) {
-	setMessageType(SEND_DATA_FROM_POINTER);
-	setAddress(address);
-	setDataLen(dataLen);
-	setDataPointer(data);
-}
-
-void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_address_t storeId) {
-	setMessageType(SEND_DATA_FROM_IPC_STORE);
-	setAddress(address);
-	setStoreId(storeId.raw);
-}
-
-void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length,
-		uint16_t sendBufferPosition) {
-	setMessageType(SEND_DATA_RAW);
-	setAddress(address);
-	setDataLen(length);
-	if(sendBufferPosition != 0) {
-		setBufferPosition(sendBufferPosition);
-	}
-}
-
-void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) {
-	setMessageType(REPLY_DATA_IPC_STORE);
-	setAddress(address);
-	setStoreId(storeId.raw);
-}
-void CommunicationMessage::setDataReplyFromPointer(uint32_t address,
-		uint32_t dataLen, uint8_t *data) {
-	setMessageType(REPLY_DATA_FROM_POINTER);
-	setAddress(address);
-	setDataLen(dataLen);
-	setDataPointer(data);
-}
-
-void CommunicationMessage::setDataReplyRaw(uint32_t address,
-		uint32_t length, uint16_t receiveBufferPosition) {
-	setMessageType(REPLY_DATA_RAW);
-	setAddress(address);
-	setDataLen(length);
-	if(receiveBufferPosition != 0) {
-		setBufferPosition(receiveBufferPosition);
-	}
-}
-
-void CommunicationMessage::setMessageType(messageType status) {
-	uint8_t status_uint8 = status;
-	memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8));
-}
-
-void CommunicationMessage::setAddress(address_t address) {
-	memcpy(getData(),&address,sizeof(address));
-}
-
-address_t CommunicationMessage::getAddress() const {
-	address_t address;
-	memcpy(&address,getData(),sizeof(address));
-	return address;
-}
-
-void CommunicationMessage::setBufferPosition(uint16_t bufferPosition) {
-	memcpy(getData() + sizeof(uint32_t) + sizeof(uint16_t),
-			&bufferPosition, sizeof(bufferPosition));
-}
-
-uint16_t CommunicationMessage::getBufferPosition() const {
-	uint16_t bufferPosition;
-	memcpy(&bufferPosition,
-			getData() + sizeof(uint32_t) + sizeof(uint16_t), sizeof(bufferPosition));
-	return bufferPosition;
-}
-
-void CommunicationMessage::setDataPointer(const void * data) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(uint32_t));
-}
-
-void CommunicationMessage::setStoreId(store_address_t storeId) {
-	memcpy(getData() + 2 * sizeof(uint32_t), &storeId.raw, sizeof(uint32_t));
-}
-
-store_address_t CommunicationMessage::getStoreId() const{
-	store_address_t temp;
-	memcpy(&temp.raw,getData() + 2 * sizeof(uint32_t), sizeof(uint32_t));
-	return temp;
-}
-
-void CommunicationMessage::setDataLen(uint32_t length) {
-	memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length));
-}
-
-uint32_t CommunicationMessage::getDataLen() const {
-	uint32_t len;
-	memcpy(&len, getData() + 2 * sizeof(uint32_t), sizeof(len));
-	return len;
-}
-
-void CommunicationMessage::setUint32Data(uint32_t data) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(data));
-}
-
-uint32_t CommunicationMessage::getUint32Data() const{
-	uint32_t data;
-	memcpy(&data,getData() + 3 * sizeof(uint32_t),  sizeof(data));
-	return data;
-}
-
-void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
-	if(position <= 3) {
-		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte));
-	}
-	else {
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-}
-
-uint8_t CommunicationMessage::getDataByte(uint8_t position) const {
-	if(position <= 3) {
-		uint8_t byte;
-		memcpy(&byte, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), sizeof(byte));
-		return byte;
-	}
-	else {
-		return 0;
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-}
-
-void CommunicationMessage::setDataUint16(uint16_t data, uint8_t position) {
-	if(position == 0 || position == 1) {
-		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), &data, sizeof(data));
-	}
-	else {
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-
-}
-
-uint16_t CommunicationMessage::getDataUint16(uint8_t position) const{
-	if(position == 0 || position == 1) {
-		uint16_t data;
-		memcpy(&data, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), sizeof(data));
-		return data;
-	}
-	else {
-		return 0;
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-}
-
-CommunicationMessage::messageType CommunicationMessage::getMessageType() const{
-	messageType messageType;
-	memcpy(&messageType, getData() + sizeof(uint32_t),sizeof(uint8_t));
-	return messageType;
-}
-
-void CommunicationMessage::setMessageId(uint8_t messageId) {
-	memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t), &messageId, sizeof(messageId));
-}
-
-uint8_t CommunicationMessage::getMessageId() const {
-	uint8_t messageId;
-	memcpy(&messageId, getData() + sizeof(uint32_t) + sizeof(uint8_t), sizeof(messageId));
-	return messageId;
-}
-
-void CommunicationMessage::clearCommunicationMessage() {
-	messageType messageType = getMessageType();
-	switch(messageType) {
-	case(messageType::REPLY_DATA_IPC_STORE):
-	case(messageType::SEND_DATA_FROM_IPC_STORE): {
-		store_address_t storeId = getStoreId();
-		StorageManagerIF *ipcStore = objectManager->
-				get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(storeId);
-		}
-	}
-	/* NO BREAK falls through*/
-	default:
-		memset(getData(),0,4*sizeof(uint32_t));
-		break;
-	}
-}
-
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
deleted file mode 100644
index 5b429d9ae..000000000
--- a/devicehandlers/CommunicationMessage.h
+++ /dev/null
@@ -1,173 +0,0 @@
-/**
- * @file CommunicationMessage.h
- *
- * @date 28.02.2020
- */
-
-#ifndef FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
-#define FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
-#include "../devicehandlers/CommunicationMessage.h"
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../devicehandlers/DeviceHandlerBase.h"
-
-/**
- * @brief Message type to send larger messages
- *
- * @details
- * Can be used to pass information like data pointers and
- * data sizes between communication tasks.
- *
- */
-class CommunicationMessage: public MessageQueueMessage {
-public:
-	enum messageType {
-		NONE,
-		SEND_DATA_FROM_POINTER,
-		SEND_DATA_FROM_IPC_STORE,
-		SEND_DATA_RAW,
-		REPLY_DATA_FROM_POINTER,
-		REPLY_DATA_IPC_STORE,
-		REPLY_DATA_RAW,
-		FAULTY,
-	};
-
-	//Add other messageIDs here if necessary.
-	static const uint8_t COMMUNICATION_MESSAGE_SIZE = HEADER_SIZE + 4 * sizeof(uint32_t);
-
-	CommunicationMessage();
-	virtual ~CommunicationMessage();
-
-	/**
-	 * Message Type is stored as the fifth byte of the message data
-	 * @param status
-	 */
-	void setMessageType(messageType status);
-	messageType getMessageType() const;
-
-	/**
-	 * This is a unique ID which can be used to handle different kinds of messages.
-	 * For example, the same interface (e.g. SPI) could be used to exchange raw data
-	 * (e.g. sensor values) and data stored in the IPC store.
-	 * The ID can be used to distinguish the messages in child implementations.
-	 * The message ID is stored as the sixth byte of the message data.
-	 * @param messageId
-	 */
-	void setMessageId(uint8_t messageId);
-	uint8_t getMessageId() const;
-
-	/**
-	 * Send requests with pointer to the data to be sent and send data length
-	 * @param address Target Address, first four bytes
-	 * @param dataLen Length of data to send, next four bytes
-	 * @param data Pointer to data to send
-	 *
-	 */
-	void setSendRequestFromPointer(uint32_t address, uint32_t dataLen, const uint8_t * data);
-
-	/**
-	 * Send requests with a store ID, using the IPC store
-	 * @param address Target Address, first four bytes
-	 * @param storeId Store ID in the IPC store
-	 *
-	 */
-	void setSendRequestFromIpcStore(uint32_t address, store_address_t storeId);
-
-	/**
-	 * Send requests with data length and data in message (max. 4 bytes)
-	 * @param address Target Address, first four bytes
-	 * @param dataLen Length of data to send, next four bytes
-	 * @param data Pointer to data to send
-	 *
-	 */
-	void setSendRequestRaw(uint32_t address, uint32_t length,
-			uint16_t sendBufferPosition = 0);
-
-	/**
-	 * Data message with data stored in IPC store
-	 * @param address Target Address, first four bytes
-	 * @param length
-	 * @param storeId
-	 */
-	void setDataReplyFromIpcStore(uint32_t address, store_address_t storeId);
-
-	/**
-	 * Data reply with data stored in buffer, passing the pointer to
-	 * the buffer and the data size
-	 * @param address Target Address, first four bytes
-	 * @param dataLen Length of data to send, next four bytes
-	 * @param data Pointer to the data
-	 */
-	void setDataReplyFromPointer(uint32_t address, uint32_t dataLen, uint8_t * data);
-
-	/**
-	 * Data message with data stored in actual message.
-	 * 4 byte datafield is intialized with 0.
-	 * Set data with specific setter functions below.
-	 * Can also be used to supply information at which position the raw data should be stored
-	 * in a receive buffer.
-	 */
-	void setDataReplyRaw(uint32_t address, uint32_t length, uint16_t receiveBufferPosition = 0);
-
-	/**
-	 * First four bytes of message data
-	 * @param address
-	 */
-	void setAddress(address_t address);
-
-	address_t getAddress() const;
-	/**
-	 * Set byte as position of 4 byte data field
-	 * @param byte
-	 * @param position Position, 0 to 3 possible
-	 */
-	void setDataByte(uint8_t byte, uint8_t position);
-	uint8_t getDataByte(uint8_t position) const;
-
-	/**
-	 * Set 2 byte value at position 1 or 2 of data field
-	 * @param data
-	 * @param position 0 or 1 possible
-	 */
-	void setDataUint16(uint16_t data, uint8_t position);
-	uint16_t getDataUint16(uint8_t position) const;
-
-	void setUint32Data(uint32_t data);
-	uint32_t getUint32Data() const;
-
-	/**
-	 * Stored in Bytes 13-16 of message data
-	 * @param length
-	 */
-	void setDataLen(uint32_t length);
-
-	uint32_t getDataLen() const;
-
-	/**
-	 * Stored in last four bytes (Bytes 17-20) of message data
-	 * @param sendData
-	 */
-	void setDataPointer(const void * data);
-
-	/**
-	 * In case the send request data or reply data is to be stored in a buffer,
-	 * a buffer Position can be stored here as the seventh and eigth byte of
-	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now.
-	 * @param bufferPosition In case the data is stored in a buffer, the position can be supplied here
-	 */
-	void setBufferPosition(uint16_t bufferPosition);
-	uint16_t getBufferPosition() const;
-	void setStoreId(store_address_t storeId);
-	store_address_t getStoreId() const;
-
-	/**
-	 * Clear the message. Deletes IPC Store data
-	 * and sets all data to 0. Also sets message type to NONE
-	 */
-	void clearCommunicationMessage();
-private:
-	bool uninitialized; //!< Could be used to warn if data has not been set.
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_ */
diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index 5fbcd1980..5911bfdb0 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -1,11 +1,12 @@
-#ifndef COOKIE_H_
-#define COOKIE_H_
+#ifndef FSFW_DEVICEHANDLER_COOKIE_H_
+#define FSFW_DEVICEHANDLER_COOKIE_H_
+
 #include <cstdint>
 
 /**
  * @brief Physical address type
  */
-typedef std::uint32_t address_t;
+using address_t = uint32_t;
 
 /**
  * @brief 	This datatype is used to identify different connection over a
@@ -30,4 +31,4 @@ public:
 	virtual ~CookieIF() {};
 };
 
-#endif /* COOKIE_H_ */
+#endif /* FSFW_DEVICEHANDLER_COOKIE_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index db37eade2..e0b473d36 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -1,8 +1,9 @@
-#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
-#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+#ifndef FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_
+#define FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_
+
+#include "CookieIF.h"
+#include "DeviceHandlerIF.h"
 
-#include "../devicehandlers/CookieIF.h"
-#include "../devicehandlers/DeviceHandlerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 /**
  * @defgroup interfaces Interfaces
@@ -124,4 +125,4 @@ public:
 	        uint8_t **buffer, size_t *size) = 0;
 };
 
-#endif /* DEVICECOMMUNICATIONIF_H_ */
+#endif /* FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_ */
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 25d8932ff..c70f57d6d 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -1,5 +1,4 @@
-#include "../serialize/SerializeAdapter.h"
-#include "../devicehandlers/DeviceTmReportingWrapper.h"
+#include "DeviceTmReportingWrapper.h"
 #include "../serialize/SerializeAdapter.h"
 
 DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId,
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index a14c4261d..447e95f2c 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -1,5 +1,5 @@
-#ifndef DEVICETMREPORTINGWRAPPER_H_
-#define DEVICETMREPORTINGWRAPPER_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
+#define FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
 
 #include "../action/HasActionsIF.h"
 #include "../objectmanager/SystemObjectIF.h"
@@ -24,4 +24,4 @@ private:
 	SerializeIF *data;
 };
 
-#endif /* DEVICETMREPORTINGWRAPPER_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_ */
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 666f86bbd..8b7d7f23b 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -1,11 +1,12 @@
-#include "../devicehandlers/HealthDevice.h"
+#include "HealthDevice.h"
 #include "../ipc/QueueFactory.h"
 
 HealthDevice::HealthDevice(object_id_t setObjectId,
 		MessageQueueId_t parentQueue) :
 		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
 				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
+	commandQueue = QueueFactory::instance()->createMessageQueue(3,
+	        CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
 }
 
 HealthDevice::~HealthDevice() {
diff --git a/devicehandlers/HealthDevice.h b/devicehandlers/HealthDevice.h
index 53b0ab097..738f0c7ea 100644
--- a/devicehandlers/HealthDevice.h
+++ b/devicehandlers/HealthDevice.h
@@ -1,5 +1,5 @@
-#ifndef HEALTHDEVICE_H_
-#define HEALTHDEVICE_H_
+#ifndef FSFW_DEVICEHANDLERS_HEALTHDEVICE_H_
+#define FSFW_DEVICEHANDLERS_HEALTHDEVICE_H_
 
 #include "../health/HasHealthIF.h"
 #include "../health/HealthHelper.h"
@@ -37,4 +37,4 @@ public:
 	HealthHelper healthHelper;
 };
 
-#endif /* HEALTHDEVICE_H_ */
+#endif /* FSFW_DEVICEHANDLERS_HEALTHDEVICE_H_ */

From 140aa3ab422cc220dbbcf16f1d24242a73b3c933 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 18:18:41 +0200
Subject: [PATCH 0900/1774] form improvements DHB

---
 devicehandlers/AcceptsDeviceResponsesIF.h     |  22 +--
 devicehandlers/AssemblyBase.cpp               |  13 +-
 devicehandlers/AssemblyBase.h                 |  90 ++++++---
 devicehandlers/ChildHandlerBase.cpp           |  10 +-
 devicehandlers/ChildHandlerBase.h             |  14 +-
 devicehandlers/ChildHandlerFDIR.cpp           |   3 +-
 devicehandlers/ChildHandlerFDIR.h             |   4 +-
 devicehandlers/CookieIF.h                     |  10 +-
 devicehandlers/DeviceCommunicationIF.h        |  43 ++--
 devicehandlers/DeviceHandlerBase.cpp          | 183 ++++++++++++------
 devicehandlers/DeviceHandlerBase.h            | 170 ++++++++--------
 .../DeviceHandlerFailureIsolation.cpp         |   8 +
 devicehandlers/DeviceHandlerIF.h              |  20 +-
 devicehandlers/DeviceHandlerMessage.cpp       |  19 +-
 devicehandlers/DeviceHandlerMessage.h         |  78 +++-----
 devicehandlers/DeviceTmReportingWrapper.cpp   |   1 -
 devicehandlers/DeviceTmReportingWrapper.h     |   6 +-
 devicehandlers/HealthDevice.cpp               |   6 +-
 devicehandlers/HealthDevice.h                 |   6 +-
 19 files changed, 403 insertions(+), 303 deletions(-)

diff --git a/devicehandlers/AcceptsDeviceResponsesIF.h b/devicehandlers/AcceptsDeviceResponsesIF.h
index 8dc69de4f..8e13ba0c0 100644
--- a/devicehandlers/AcceptsDeviceResponsesIF.h
+++ b/devicehandlers/AcceptsDeviceResponsesIF.h
@@ -1,23 +1,19 @@
-/**
- * @file	AcceptsDeviceResponsesIF.h
- * @brief	This file defines the AcceptsDeviceResponsesIF class.
- * @date	15.05.2013
- * @author	baetz
- */
-
-#ifndef ACCEPTSDEVICERESPONSESIF_H_
-#define ACCEPTSDEVICERESPONSESIF_H_
+#ifndef FSFW_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+#define FSFW_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
 
 #include "../ipc/MessageQueueSenderIF.h"
 
+/**
+ * This interface is used by the device handler to send a device response
+ * to the queue ID, which is returned in the implemented abstract method.
+ */
 class AcceptsDeviceResponsesIF {
 public:
 	/**
 	 * Default empty virtual destructor.
 	 */
-	virtual ~AcceptsDeviceResponsesIF() {
-}
-virtual MessageQueueId_t getDeviceQueue() = 0;
+	virtual ~AcceptsDeviceResponsesIF() {}
+	virtual MessageQueueId_t getDeviceQueue() = 0;
 };
 
-#endif /* ACCEPTSDEVICERESPONSESIF_H_ */
+#endif /* FSFW_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index 8b3f7f4dc..46b2211ae 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -2,10 +2,10 @@
 
 AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
 		uint16_t commandQueueDepth) :
-		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth), internalState(
-				STATE_NONE), recoveryState(RECOVERY_IDLE), recoveringDevice(
-				childrenMap.end()), targetMode(MODE_OFF), targetSubmode(
-				SUBMODE_NONE) {
+		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
+		internalState(STATE_NONE), recoveryState(RECOVERY_IDLE),
+		recoveringDevice(childrenMap.end()), targetMode(MODE_OFF),
+		targetSubmode(SUBMODE_NONE) {
 	recoveryOffTimer.setTimeout(POWER_OFF_TIME_MS);
 }
 
@@ -165,9 +165,8 @@ ReturnValue_t AssemblyBase::checkChildrenState() {
 }
 
 ReturnValue_t AssemblyBase::checkChildrenStateOff() {
-	for (std::map<object_id_t, ChildInfo>::iterator iter = childrenMap.begin();
-			iter != childrenMap.end(); iter++) {
-		if (checkChildOff(iter->first) != RETURN_OK) {
+	for (const auto& childIter: childrenMap) {
+		if (checkChildOff(childIter.first) != RETURN_OK) {
 			return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
 		}
 	}
diff --git a/devicehandlers/AssemblyBase.h b/devicehandlers/AssemblyBase.h
index bd2e8fada..353d5f899 100644
--- a/devicehandlers/AssemblyBase.h
+++ b/devicehandlers/AssemblyBase.h
@@ -1,10 +1,30 @@
-#ifndef ASSEMBLYBASE_H_
-#define ASSEMBLYBASE_H_
+#ifndef FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_
+#define FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_
 
-#include "../container/FixedArrayList.h"
 #include "DeviceHandlerBase.h"
+#include "../container/FixedArrayList.h"
 #include "../subsystem/SubsystemBase.h"
 
+/**
+ * @brief   Base class to implement reconfiguration and failure handling for
+ *          redundant devices by monitoring their modes health states.
+ * @details
+ * Documentation: Dissertation Baetz p.156, 157.
+ *
+ * This class reduces the complexity of controller components which would
+ * otherwise be needed for the handling of redundant devices.
+ *
+ * The template class monitors mode and health state of its children
+ * and checks availability of devices on every detected change.
+ * AssemblyBase does not implement any redundancy logic by itself, but provides
+ * adaptation points for implementations to do so. Since most monitoring
+ * activities rely on mode and health state only and are therefore
+ * generic, it is sufficient for subclasses to provide:
+ *
+ * 1. check logic when active-> checkChildrenStateOn
+ * 2. transition logic to change the mode -> commandChildren
+ *
+ */
 class AssemblyBase: public SubsystemBase {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ASSEMBLY_BASE;
@@ -16,10 +36,41 @@ public:
 	static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE =
 			MAKE_RETURN_CODE(0xa1);
 
-	AssemblyBase(object_id_t objectId, object_id_t parentId, uint16_t commandQueueDepth = 8);
+	AssemblyBase(object_id_t objectId, object_id_t parentId,
+	        uint16_t commandQueueDepth = 8);
 	virtual ~AssemblyBase();
 
 protected:
+
+    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
+    // (or return internalState directly?)
+    /**
+     * Command children to reach [mode,submode] combination
+     * Can be done by setting #commandsOutstanding correctly,
+     * or using executeTable()
+     * @param mode
+     * @param submode
+     * @return
+     *    - @c RETURN_OK if ok
+     *    - @c NEED_SECOND_STEP if children need to be commanded again
+     */
+    virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
+
+    /**
+     * Check whether desired assembly mode was achieved by checking the modes
+     * or/and health states of child device handlers.
+     * The assembly template class will also call this function if a health
+     * or mode change of a child device handler was detected.
+     * @param wantedMode
+     * @param wantedSubmode
+     * @return
+     */
+    virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
+            Submode_t wantedSubmode) = 0;
+
+    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+            Submode_t submode) = 0;
+
 	enum InternalState {
 		STATE_NONE,
 		STATE_OVERWRITE_HEALTH,
@@ -36,6 +87,7 @@ protected:
 		RECOVERY_WAIT
 	} recoveryState; //!< Indicates if one of the children requested a recovery.
 	ChildrenMap::iterator recoveringDevice;
+
 	/**
 	 * the mode the current transition is trying to achieve.
 	 * Can be different from the modehelper.commandedMode!
@@ -61,8 +113,8 @@ protected:
 	bool handleChildrenChanged();
 
 	/**
-	 * This method is called if the children changed its mode in a way that the current
-	 * mode can't be kept.
+	 * This method is called if the children changed its mode in a way that
+	 * the current mode can't be kept.
 	 * Default behavior is to go to MODE_OFF.
 	 * @param result The failure code which was returned by checkChildrenState.
 	 */
@@ -75,9 +127,6 @@ protected:
 	ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
 			uint32_t *msToReachTheMode);
 
-	virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
-			Submode_t submode) = 0;
-
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 
 	virtual void doStartTransition(Mode_t mode, Submode_t submode);
@@ -90,24 +139,6 @@ protected:
 
 	void sendHealthCommand(MessageQueueId_t sendTo, HealthState health);
 
-	//SHOULDDO: Change that OVERWRITE_HEALTH may be returned (or return internalState directly?)
-	/**
-	 * command children to reach mode,submode
-	 *
-	 * set #commandsOutstanding correctly, or use executeTable()
-	 *
-	 * @param mode
-	 * @param submode
-	 * @return
-	 *    - @c RETURN_OK if ok
-	 *    - @c NEED_SECOND_STEP if children need to be commanded again
-	 */
-	virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
-
-	//SHOULDDO: Remove wantedMode, wantedSubmode, as targetMode/submode is available?
-	virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
-			Submode_t wantedSubmode) = 0;
-
 	virtual ReturnValue_t checkChildrenStateOff();
 
 	ReturnValue_t checkChildrenState();
@@ -125,8 +156,9 @@ protected:
 	 * Also sets state to STATE_OVERWRITE_HEATH.
 	 * @param objectId Must be a registered child.
 	 */
-	void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
+	void overwriteDeviceHealth(object_id_t objectId,
+	        HasHealthIF::HealthState oldHealth);
 
 };
 
-#endif /* ASSEMBLYBASE_H_ */
+#endif /* FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index e800cd569..d4ef67ad8 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -1,16 +1,18 @@
+#include "ChildHandlerBase.h"
 #include "../subsystem/SubsystemBase.h"
-#include "../devicehandlers/ChildHandlerBase.h"
 #include "../subsystem/SubsystemBase.h"
 
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * cookie,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		object_id_t parent, FailureIsolationBase* customFdir,
-		size_t cmdQueueSize) :
+		object_id_t hkDestination, 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->setHkDestination(hkDestination);
 	this->setThermalStateRequestPoolIds(thermalStatePoolId,
 			thermalRequestPoolId);
 
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index f6bf318a0..eed4c95e2 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -1,17 +1,18 @@
-#ifndef FSFW_DEVICES_CHILDHANDLERBASE_H_
-#define FSFW_DEVICES_CHILDHANDLERBASE_H_
+#ifndef FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_
+#define FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_
 
-#include "ChildHandlerFDIR.h"
 #include "DeviceHandlerBase.h"
+#include "ChildHandlerFDIR.h"
 
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
 	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * cookie, uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId,
+			CookieIF * cookie, object_id_t hkDestination,
+			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 			object_id_t parent = objects::NO_OBJECT,
 			FailureIsolationBase* customFdir = nullptr,
 			size_t cmdQueueSize = 20);
+
 	virtual ~ChildHandlerBase();
 
 	virtual ReturnValue_t initialize();
@@ -22,5 +23,4 @@ protected:
 
 };
 
-#endif /* FSFW_DEVICES_CHILDHANDLERBASE_H_ */
-
+#endif /* FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_ */
diff --git a/devicehandlers/ChildHandlerFDIR.cpp b/devicehandlers/ChildHandlerFDIR.cpp
index 14043a779..cb4c75eaf 100644
--- a/devicehandlers/ChildHandlerFDIR.cpp
+++ b/devicehandlers/ChildHandlerFDIR.cpp
@@ -1,6 +1,7 @@
 #include "ChildHandlerFDIR.h"
 
-ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent, uint32_t recoveryCount) :
+ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner,
+        object_id_t faultTreeParent, uint32_t recoveryCount) :
 		DeviceHandlerFailureIsolation(owner, faultTreeParent) {
 	recoveryCounter.setFailureThreshold(recoveryCount);
 }
diff --git a/devicehandlers/ChildHandlerFDIR.h b/devicehandlers/ChildHandlerFDIR.h
index ce8445183..13d1345c1 100644
--- a/devicehandlers/ChildHandlerFDIR.h
+++ b/devicehandlers/ChildHandlerFDIR.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
-#define FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+#ifndef FSFW_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+#define FSFW_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
 
 #include "DeviceHandlerFailureIsolation.h"
 
diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index 496cf0d2f..5911bfdb0 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -1,11 +1,12 @@
-#ifndef COOKIE_H_
-#define COOKIE_H_
+#ifndef FSFW_DEVICEHANDLER_COOKIE_H_
+#define FSFW_DEVICEHANDLER_COOKIE_H_
+
 #include <cstdint>
 
 /**
  * @brief Physical address type
  */
-typedef std::uint32_t address_t;
+using address_t = uint32_t;
 
 /**
  * @brief 	This datatype is used to identify different connection over a
@@ -16,7 +17,6 @@ typedef std::uint32_t address_t;
  * calling @code{.cpp} CookieIF* childCookie = new ChildCookie(...)
  * @endcode .
  *
- * [not implemented yet]
  * This cookie is then passed to the child device handlers, which stores the
  * pointer and passes it to the communication interface functions.
  *
@@ -31,4 +31,4 @@ public:
 	virtual ~CookieIF() {};
 };
 
-#endif /* COOKIE_H_ */
+#endif /* FSFW_DEVICEHANDLER_COOKIE_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 11960d8e3..e0b473d36 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -1,9 +1,10 @@
-#ifndef DEVICECOMMUNICATIONIF_H_
-#define DEVICECOMMUNICATIONIF_H_
+#ifndef FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_
+#define FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_
 
 #include "CookieIF.h"
+#include "DeviceHandlerIF.h"
+
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
 /**
  * @defgroup interfaces Interfaces
  * @brief Interfaces for flight software objects
@@ -19,8 +20,8 @@
  * the device handler to allow reuse of these components.
  * @details
  * Documentation: Dissertation Baetz p.138.
- * It works with the assumption that received data
- * is polled by a component. There are four generic steps of device communication:
+ * It works with the assumption that received data  is polled by a component.
+ * There are four generic steps of device communication:
  *
  *   1. Send data to a device
  *   2. Get acknowledgement for sending
@@ -38,24 +39,20 @@ class DeviceCommunicationIF: public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
 
-	//! Standard Error Codes
+	//! This is returned in readReceivedMessage() if no reply was reived.
+	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0x01);
+
 	//! General protocol error. Define more concrete errors in child handler
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
 	//! If cookie is a null pointer
-	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x04);
 	// is this needed if there is no open/close call?
 	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0x06);
-	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x07);
-	static const ReturnValue_t CANT_CHANGE_REPLY_LEN = MAKE_RETURN_CODE(0x08);
-
-	//! Can be used in readReceivedMessage() if no reply was received.
-	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0xA1);
+	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
 
 	virtual ~DeviceCommunicationIF() {}
 
-
 	/**
 	 * @brief Device specific initialization, using the cookie.
 	 * @details
@@ -76,13 +73,13 @@ public:
 	 * by implementing and calling related drivers or wrapper functions.
 	 * @param cookie
 	 * @param data
-	 * @param len
+	 * @param len If this is 0, nothing shall be sent.
 	 * @return
 	 *  - @c RETURN_OK for successfull send
 	 *  - Everything else triggers failure event with returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
-			size_t sendLen) = 0;
+	virtual ReturnValue_t sendMessage(CookieIF *cookie,
+	        const uint8_t * sendData, size_t sendLen) = 0;
 
 	/**
 	 * Called by DHB in the GET_WRITE doGetWrite().
@@ -108,7 +105,7 @@ public:
 	 *           returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-			size_t requestLen) = 0;
+	        size_t requestLen) = 0;
 
 	/**
 	 * Called by DHB in the GET_WRITE doGetRead().
@@ -124,8 +121,8 @@ public:
 	 *         - Everything else triggers failure event with
 	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
-			size_t *size) = 0;
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
+	        uint8_t **buffer, size_t *size) = 0;
 };
 
-#endif /* DEVICECOMMUNICATIONIF_H_ */
+#endif /* FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 017ea8d26..227d5b6dc 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -2,15 +2,17 @@
 #include "AcceptsDeviceResponsesIF.h"
 #include "DeviceTmReportingWrapper.h"
 
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
-#include "../datapool/DataSet.h"
-#include "../datapool/PoolVariable.h"
 #include "../globalfunctions/CRC.h"
-#include "../subsystem/SubsystemBase.h"
+#include "../housekeeping/HousekeepingMessage.h"
+#include "../ipc/MessageQueueMessage.h"
 #include "../ipc/QueueFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../subsystem/SubsystemBase.h"
 
 #include <iomanip>
 
@@ -25,10 +27,11 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		actionHelper(this, nullptr), childTransitionFailure(RETURN_OK),
-		fdirInstance(fdirInstance), hkSwitcher(this),
-		defaultFDIRUsed(fdirInstance == nullptr), switchOffWasReported(false),
-		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		actionHelper(this, nullptr), hkManager(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,
 			MessageQueueMessage::MAX_MESSAGE_SIZE);
@@ -48,6 +51,10 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 	}
 }
 
+void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
+	this->hkDestination = hkDestination;
+}
+
 void DeviceHandlerBase::setThermalStateRequestPoolIds(
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId) {
 	this->deviceThermalRequestPoolId = thermalStatePoolId;
@@ -74,6 +81,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		decrementDeviceReplyMap();
 		fdirInstance->checkForFailures();
 		hkSwitcher.performOperation();
+		hkManager.performHkOperation();
 		performOperationHook();
 	}
 	if (mode == MODE_OFF) {
@@ -120,7 +128,9 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
-		return result;
+	    sif::error << "DeviceHandlerBase::initialize: Initializing "
+	            "communication interface failed!" << std::endl;
+	    return result;
 	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
@@ -183,11 +193,16 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
+	result = hkManager.initialize(commandQueue);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
 	fillCommandAndReplyMap();
 
 	//Set temperature target state to NON_OP.
-	DataSet mySet;
-	db_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+	GlobDataSet mySet;
+	gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 			PoolVariableIF::VAR_WRITE);
 	mySet.read();
 	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
@@ -245,10 +260,10 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-//	result = hkManager.handleHousekeepingMessage(&command);
-//	if (result == RETURN_OK) {
-//		return;
-//	}
+	result = hkManager.handleHousekeepingMessage(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
 
 	result = handleDeviceHandlerMessage(&command);
 	if (result == RETURN_OK) {
@@ -376,24 +391,28 @@ 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) {
+		LocalPoolDataSetBase* replyDataSet, 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) {
-		return insertInReplyMap(replyId, maxDelayCycles, replyLen, periodic);
+		return insertInReplyMap(replyId, maxDelayCycles,
+		        replyDataSet, replyLen, periodic);
 	} else {
-		return insertInReplyMap(deviceCommand, maxDelayCycles, replyLen, periodic);
+		return insertInReplyMap(deviceCommand, maxDelayCycles,
+		        replyDataSet, replyLen, periodic);
 	}
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, size_t replyLen, bool periodic) {
+		uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet,
+		size_t replyLen, bool periodic) {
 	DeviceReplyInfo info;
 	info.maxDelayCycles = maxDelayCycles;
 	info.periodic = periodic;
 	info.delayCycles = 0;
 	info.replyLen = replyLen;
+	info.dataSet = dataSet;
 	info.command = deviceCommandMap.end();
 	auto resultPair = deviceReplyMap.emplace(replyId, info);
 	if (resultPair.second) {
@@ -419,13 +438,12 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(
 
 ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
 		uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
-	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
-			deviceReplyMap.find(deviceReply);
-	if (iter == deviceReplyMap.end()) {
+	auto replyIter = deviceReplyMap.find(deviceReply);
+	if (replyIter == deviceReplyMap.end()) {
 		triggerEvent(INVALID_DEVICE_COMMAND, deviceReply);
 		return RETURN_FAILED;
 	} else {
-		DeviceReplyInfo *info = &(iter->second);
+		DeviceReplyInfo *info = &(replyIter->second);
 		if (maxDelayCycles != 0) {
 			info->maxDelayCycles = maxDelayCycles;
 		}
@@ -435,6 +453,17 @@ ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceRep
 	}
 }
 
+
+ReturnValue_t DeviceHandlerBase::setReplyDataset(DeviceCommandId_t replyId,
+        LocalPoolDataSetBase *dataSet) {
+    auto replyIter = deviceReplyMap.find(replyId);
+    if(replyIter == deviceReplyMap.end()) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    replyIter->second.dataSet = dataSet;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 void DeviceHandlerBase::callChildStatemachine() {
 	if (mode == _MODE_START_UP) {
 		doStartUp();
@@ -469,8 +498,8 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	Clock::getUptime(&timeoutStart);
 
 	if (mode == MODE_OFF) {
-		DataSet mySet;
-		db_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+		GlobDataSet mySet;
+		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ_WRITE);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -649,7 +678,7 @@ void DeviceHandlerBase::doGetRead() {
 void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		size_t receivedDataLen) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	DeviceCommandId_t foundId = 0xFFFFFFFF;
+	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
@@ -661,18 +690,26 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		switch (result) {
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
+			if(foundLen == 0) {
+			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+			            " Packet parsing will be stuck." << std::endl;
+			}
 			break;
 		case APERIODIC_REPLY: {
 			result = interpretDeviceReply(foundId, receivedData);
 			if (result != RETURN_OK) {
-				replyRawReplyIfnotWiretapped(receivedData, foundLen);
-				triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
-						foundId);
+			    replyRawReplyIfnotWiretapped(receivedData, foundLen);
+			    triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
+			            foundId);
+			}
+			if(foundLen == 0) {
+			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+			            " Packet parsing will be stuck." << std::endl;
 			}
-		}
-		break;
-		case IGNORE_REPLY_DATA:
 			break;
+		}
+		case IGNORE_REPLY_DATA:
+			continue;
 		case IGNORE_FULL_PACKET:
 			return;
 		default:
@@ -704,16 +741,19 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 	DeviceReplyInfo *info = &(iter->second);
 
 	if (info->delayCycles != 0) {
+	    result = interpretDeviceReply(foundId, receivedData);
 
-		if (info->periodic != false) {
+	    if(result == IGNORE_REPLY_DATA) {
+	        return;
+	    }
+
+		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);
@@ -926,10 +966,10 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
 
 	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
 			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)) {
-		DataSet mySet;
-		db_int8_t thermalState(deviceThermalStatePoolId, &mySet,
+		GlobDataSet mySet;
+		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
 				PoolVariableIF::VAR_READ);
-		db_int8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -956,8 +996,8 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 			childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
 					MODE_ON);
 			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-			DataSet mySet;
-			db_int8_t thermalRequest(deviceThermalRequestPoolId,
+			GlobDataSet mySet;
+			gp_int8_t thermalRequest(deviceThermalRequestPoolId,
 					&mySet, PoolVariableIF::VAR_READ_WRITE);
 			mySet.read();
 			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -1089,19 +1129,6 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
-//		if (mode != MODE_OFF) {
-//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-//		} else {
-//			result = switchCookieChannel(
-//					DeviceHandlerMessage::getIoBoardObjectId(message));
-//			if (result == RETURN_OK) {
-//				replyReturnvalueToCommand(RETURN_OK);
-//			} else {
-//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
-//			}
-//		}
-//		return RETURN_OK;
 	case DeviceHandlerMessage::CMD_RAW:
 		if ((mode != MODE_RAW)) {
 			DeviceHandlerMessage::clear(message);
@@ -1185,7 +1212,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 	}
 	//Try to cast to GlobDataSet and commit data.
 	if (!neverInDataPool) {
-		DataSet* dataSet = dynamic_cast<DataSet*>(data);
+		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
 		if (dataSet != NULL) {
 			dataSet->commit(PoolVariableIF::VALID);
 		}
@@ -1248,10 +1275,14 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
+			//so we can track misconfigurations
 			sif::debug << std::hex << getObjectId()
 					<< ": DHB::buildInternalCommand: Command "
-					<< deviceCommandId << " isExecuting" << std::endl; //so we can track misconfigurations
-			return; //this is an internal command, no need to report a failure here, missed reply will track if a reply is too late, otherwise, it's ok
+					<< deviceCommandId << " isExecuting" << std::dec
+					<< std::endl;
+			// this is an internal command, no need to report a failure here,
+			// missed reply will track if a reply is too late, otherwise, it's ok
+			return;
 		} else {
 			iter->second.sendReplyTo = NO_COMMANDER;
 			iter->second.isExecuting = true;
@@ -1340,12 +1371,50 @@ void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
 void DeviceHandlerBase::performOperationHook() {
 }
 
+ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
+		LocalDataPool &localDataPoolMap,
+        LocalDataPoolManager& poolManager) {
+	return RETURN_OK;
+}
+
+LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
+	return &hkManager;
+}
+
+
 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();
     }
+    this->hkManager.initializeAfterTaskCreation();
+
+    if(setStartupImmediately) {
+        startTransition(MODE_ON, SUBMODE_NONE);
+    }
     return HasReturnvaluesIF::RETURN_OK;
 }
 
+LocalPoolDataSetBase* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
+	auto iter = deviceReplyMap.find(sid.ownerSetId);
+	if(iter != deviceReplyMap.end()) {
+		return iter->second.dataSet;
+	}
+	else {
+		return nullptr;
+	}
+}
+
+object_id_t DeviceHandlerBase::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+void DeviceHandlerBase::setStartUpImmediately() {
+    this->setStartupImmediately = true;
+}
+
+dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
+    return pstIntervalMs;
+}
+
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 5666f35ea..eda318cb8 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,12 +1,11 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
-#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#define FSFW_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 "../returnvalues/HasReturnvaluesIF.h"
 #include "../action/HasActionsIF.h"
@@ -14,10 +13,13 @@
 #include "../modes/HasModesIF.h"
 #include "../power/PowerSwitchIF.h"
 #include "../ipc/MessageQueueIF.h"
+#include "../tasks/PeriodicTaskIF.h"
 #include "../action/ActionHelper.h"
 #include "../health/HealthHelper.h"
 #include "../parameters/ParameterHelper.h"
 #include "../datapool/HkSwitchHelper.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
 
 #include <map>
 
@@ -38,17 +40,16 @@ class StorageManagerIF;
  * Documentation: Dissertation Baetz p.138,139, p.141-149
  *
  * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink,
- * communication with physical devices, using the @link DeviceCommunicationIF @endlink,
- * and communication with commanding objects.
- * It inherits SystemObject and thus can be created by the ObjectManagerIF.
+ * communication with physical devices, using the
+ * @link DeviceCommunicationIF @endlink, and communication with commanding
+ * objects. It inherits SystemObject and thus can be created by the
+ * ObjectManagerIF.
  *
- * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
- * For each step an RMAP action is selected and executed.
- * 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.
+ * This class uses the opcode of ExecutableObjectIF to perform a
+ * step-wise execution. For each step a different action is selected and
+ * executed. Currently, the device handler base performs a 4-step
+ * execution related to 4 communication steps (based on RMAP).
+ * NOTE: RMAP is a standard which is used for Flying Laptop.
  * 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.
@@ -69,9 +70,6 @@ class StorageManagerIF;
  *
  * Other important virtual methods with a default implementation
  * are the getTransitionDelayMs() function and the getSwitches() function.
- * Please ensure that getSwitches() returns DeviceHandlerIF::NO_SWITCHES if
- * power switches are not implemented yet. Otherwise, the device handler will
- * not transition to MODE_ON, even if setMode(MODE_ON) is called.
  * If a transition to MODE_ON is desired without commanding, override the
  * intialize() function and call setMode(_MODE_START_UP) before calling
  * DeviceHandlerBase::initialize().
@@ -85,20 +83,18 @@ class DeviceHandlerBase: public DeviceHandlerIF,
 		public HasModesIF,
 		public HasHealthIF,
 		public HasActionsIF,
-		public ReceivesParameterMessagesIF {
+		public ReceivesParameterMessagesIF,
+		public HasLocalDataPoolIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	/**
 	 * The constructor passes the objectId to the SystemObject().
 	 *
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
-	 * @param setDeviceSwitch the switch the device is connected to,
-	 * for devices using two switches, overwrite getSwitches()
 	 * @param deviceCommuncation Communcation Interface object which is used
 	 * to implement communication functions
-	 * @param thermalStatePoolId
-	 * @param thermalRequestPoolId
+	 * @param comCookie This object will be passed to the communication inter-
+	 * face and can contain user-defined information about the communication.
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
@@ -106,8 +102,21 @@ public:
 			CookieIF * comCookie, FailureIsolationBase* fdirInstance = nullptr,
 			size_t cmdQueueSize = 20);
 
+	void setHkDestination(object_id_t hkDestination);
 	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
 			uint32_t thermalRequestPoolId);
+	/**
+	 * @brief   Helper function to ease device handler development.
+	 * This will instruct the transition to MODE_ON immediately
+	 * (leading to doStartUp() being called for the transition to the ON mode),
+	 * so external mode commanding is not necessary anymore.
+	 *
+	 * This has to be called before the task is started!
+	 * (e.g. in the task factory). This is only a helper function for
+	 * development. Regular mode commanding should be performed by commanding
+	 * the AssemblyBase or Subsystem objects resposible for the device handler.
+	 */
+	void setStartUpImmediately();
 
 	/**
 	 * @brief 	This function is the device handler base core component and is
@@ -153,6 +162,14 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t initialize();
+
+	/**
+	 * @brief   Intialization steps performed after all tasks have been created.
+	 *          This function will be called by the executing task.
+	 * @return
+	 */
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+
 	/** Destructor. */
 	virtual ~DeviceHandlerBase();
 
@@ -320,6 +337,8 @@ protected:
 	 * @param packet
 	 * @return
 	 *     - @c RETURN_OK when the reply was interpreted.
+	 *     - @c IGNORE_REPLY_DATA Ignore the reply and don't reset reply cycle
+	 *          counter.
 	 *     - @c RETURN_FAILED when the reply could not be interpreted,
 	 *     e.g. logical errors or range violations occurred
 	 */
@@ -347,22 +366,10 @@ protected:
 	 *    set to the maximum expected number of PST cycles between two replies
 	 *    (also a tolerance should be added, as an FDIR message will be
 	 *    generated if it is missed).
-	 *
-	 *    (Robin) This part confuses me. "must do as soon as" implies that
-	 *    the developer must do something somewhere else in the code. Is
-	 *    that really the case? If I understood correctly, DHB performs
-	 *    almost everything (e.g. in erirm function) as long as the commands
-	 *    are inserted correctly.
-	 *
-	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must
-	 *    be set to true, DeviceCommandInfo.delayCycles to
-	 *    DeviceCommandInfo.maxDelayCycles.
 	 *    From then on, the base class handles the reception.
 	 *    Then, scanForReply returns the id of the reply or the placeholder id
 	 *    and the base class will take care of checking that all replies are
 	 *    received and the interval is correct.
-	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set
-	 *    to 0, DeviceCommandInfo.delayCycles to 0;
 	 *
 	 *  - Aperiodic, unrequested replies. These are replies that are sent
 	 *    by the device without any preceding command and not in a defined
@@ -376,13 +383,17 @@ protected:
 	 * @param deviceCommand	Identifier of the command to add.
 	 * @param maxDelayCycles The maximum number of delay cycles the command
 	 * waits until it times out.
+	 * @param replyLen Will be supplied to the requestReceiveMessage call of
+	 * the communication interface.
 	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
 	 * by the device repeatedly without request) or not. Default is aperiodic (0)
 	 * @return	- @c RETURN_OK when the command was successfully inserted,
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false,
+			uint16_t maxDelayCycles,
+			LocalPoolDataSetBase* replyDataSet = nullptr,
+			size_t replyLen = 0, bool periodic = false,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
 	/**
@@ -396,7 +407,8 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false);
+			uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet = nullptr,
+			size_t replyLen = 0, bool periodic = false);
 
 	/**
 	 * @brief 	A simple command to add a command to the commandList.
@@ -424,6 +436,9 @@ protected:
 			uint16_t delayCycles, uint16_t maxDelayCycles,
 			bool periodic = false);
 
+	ReturnValue_t setReplyDataset(DeviceCommandId_t replyId,
+	        LocalPoolDataSetBase* dataset);
+
 	/**
 	 * @brief   Can be implemented by child handler to
 	 *          perform debugging
@@ -477,18 +492,22 @@ protected:
 	 * @param localDataPoolMap
 	 * @return
 	 */
-	//virtual ReturnValue_t initializePoolEntries(
-	//			LocalDataPool& localDataPoolMap) override;
+	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
+				LocalDataPoolManager& poolManager) override;
 
 	/** Get the HK manager object handle */
-	//virtual LocalDataPoolManager* getHkManagerHandle() override;
+	virtual LocalDataPoolManager* getHkManagerHandle() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
 	 * 			performOperation(). Default implementation is empty.
 	 */
 	virtual void performOperationHook();
+
 public:
+	/** Explicit interface implementation of getObjectId */
+	virtual object_id_t getObjectId() const override;
+
 	/**
 	 * @param parentQueueId
 	 */
@@ -608,7 +627,7 @@ protected:
 	/** Action helper for HasActionsIF */
 	ActionHelper actionHelper;
 	/** Housekeeping Manager */
-	//LocalDataPoolManager hkManager;
+	LocalDataPoolManager hkManager;
 
 	/**
 	 *  @brief Information about commands
@@ -647,7 +666,7 @@ protected:
 		//! 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;
+		LocalPoolDataSetBase* dataSet;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -689,14 +708,18 @@ protected:
 	uint32_t deviceThermalRequestPoolId = PoolVariableIF::NO_PARAMETER;
 
 	/**
-	 * Optional Error code
-	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
+	 * Optional Error code. Can be set in doStartUp(), doShutDown() and
+	 * doTransition() to signal cause for Transition failure.
 	 */
 	ReturnValue_t childTransitionFailure;
 
-	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
+	/** Counts if communication channel lost a reply, so some missed
+	 * replys can be ignored. */
+	uint32_t ignoreMissedRepliesCount = 0;
 
-	FailureIsolationBase* fdirInstance; //!< Pointer to the used FDIR instance. If not provided by child, default class is instantiated.
+	/** Pointer to the used FDIR instance. If not provided by child,
+	 * default class is instantiated. */
+	FailureIsolationBase* fdirInstance;
 
 	HkSwitchHelper hkSwitcher;
 
@@ -944,14 +967,17 @@ protected:
 
 	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
 			uint32_t *msToReachTheMode);
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-	virtual void setToExternalControl();
-	virtual void announceMode(bool recursive);
+
+	/* HasModesIF overrides */
+	virtual void startTransition(Mode_t mode, Submode_t submode) override;
+	virtual void setToExternalControl() override;
+	virtual void announceMode(bool recursive) override;
 
 	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
 	/**
-	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper" faster about executed events.
+	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper"
+	 * faster about executed events.
 	 * This is a bit sneaky, but improves responsiveness of the device FDIR.
 	 * @param event	The event to be thrown
 	 * @param parameter1	Optional parameter 1
@@ -1034,12 +1060,17 @@ private:
 	/** the object used to set power switches */
 	PowerSwitchIF *powerSwitcher = nullptr;
 
+	/** HK destination can also be set individually */
+	object_id_t hkDestination = objects::NO_OBJECT;
+
 	/**
 	 * @brief   Used for timing out mode transitions.
 	 * Set when setMode() is called.
 	 */
 	uint32_t timeoutStart = 0;
 
+	bool setStartupImmediately = false;
+
 	/**
 	 * Delay for the current mode transition, used for time out
 	 */
@@ -1080,11 +1111,6 @@ private:
 	void buildRawDeviceCommand(CommandMessage* message);
 	void buildInternalCommand(void);
 
-//	/**
-//	 * Send a reply with the current mode and submode.
-//	 */
-//	void announceMode(void);
-
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
@@ -1111,10 +1137,14 @@ private:
 	/**
 	 * Build and send a command to the device.
 	 *
-	 * This routine checks whether a raw or direct command has been received, checks the content of the received command and
-	 * calls buildCommandFromCommand() for direct commands or sets #rawpacket to the received raw packet.
-	 * If no external command is received or the received command is invalid and the current mode is @c MODE_NORMAL or a transitional mode,
-	 * it asks the child class to build a command (via getNormalDeviceCommand() or getTransitionalDeviceCommand() and buildCommand()) and
+	 * This routine checks whether a raw or direct command has been received,
+	 * checks the content of the received command and calls
+	 * buildCommandFromCommand() for direct commands or sets #rawpacket
+	 * to the received raw packet.
+	 * If no external command is received or the received command is invalid and
+	 * the current mode is @c MODE_NORMAL or a transitional mode, it asks the
+	 * child class to build a command (via getNormalDeviceCommand() or
+	 * getTransitionalDeviceCommand() and buildCommand()) and
 	 * sends the command via RMAP.
 	 */
 	void doSendWrite(void);
@@ -1159,7 +1189,6 @@ private:
 	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
 			uint32_t *len);
 
-
 	/**
 	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
 	 */
@@ -1170,25 +1199,14 @@ private:
 	 */
 	void callChildStatemachine();
 
-	/**
-	 * Switches the channel of the cookie used for the communication
-	 *
-	 *
-	 * @param newChannel the object Id of the channel to switch to
-	 * @return
-	 *     - @c RETURN_OK when cookie was changed
-	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
-	 *     - @c returnvalues of RMAPChannelIF::isActive()
-	 */
-	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
-
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 
-	void parseReply(const uint8_t* receivedData,
-	            size_t receivedDataLen);
+    virtual dur_millis_t getPeriodicOperationFrequency() const override;
+
+    void parseReply(const uint8_t* receivedData,
+                size_t receivedDataLen);
 };
 
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
-
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 9fbe71d85..24fe15a03 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -247,6 +247,14 @@ bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
 		}
 		return true;
 	}
+
+	if (owner == nullptr) {
+	    // Configuration error.
+	    sif::error << "DeviceHandlerFailureIsolation::"
+	            << "isFdirInActionOrAreWeFaulty: Owner not set!" << std::endl;
+	    return false;
+	}
+
 	if (owner->getHealth() == HasHealthIF::FAULTY
 			|| owner->getHealth() == HasHealthIF::PERMANENT_FAULTY) {
 		//Ignore all events in case device is already faulty.
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 52a3be4d0..9c8eb0983 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,12 +1,19 @@
-#ifndef DEVICEHANDLERIF_H_
-#define DEVICEHANDLERIF_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
+
+#include "DeviceHandlerMessage.h"
 
 #include "../action/HasActionsIF.h"
-#include "DeviceHandlerMessage.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 
+/**
+ * This is used to uniquely identify commands that are sent to a device
+ * The values are defined in the device-specific implementations
+ */
+using DeviceCommandId_t = uint32_t;
+
 /**
  * @brief 	This is the Interface used to communicate with a device handler.
  * @details Includes all expected return values, events and modes.
@@ -15,6 +22,7 @@
 class DeviceHandlerIF {
 public:
 
+
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
 
@@ -47,6 +55,8 @@ public:
 	//! This is a transitional state which can not be commanded.
 	//! The device handler performs all actions and commands to get the device
 	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
+	//! transition if available.
 	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
 	//! It is possible to set the mode to _MODE_TO_ON to use the to on
 	//! transition if available.
@@ -96,7 +106,7 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 
 	// Standard codes used when building commands.
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If the command size is 0. Checked in DHB
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
 	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
 	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
 	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
@@ -150,4 +160,4 @@ public:
 
 };
 
-#endif /* DEVICEHANDLERIF_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_ */
diff --git a/devicehandlers/DeviceHandlerMessage.cpp b/devicehandlers/DeviceHandlerMessage.cpp
index 564fae213..cb9043db8 100644
--- a/devicehandlers/DeviceHandlerMessage.cpp
+++ b/devicehandlers/DeviceHandlerMessage.cpp
@@ -1,10 +1,6 @@
-#include "../objectmanager/ObjectManagerIF.h"
 #include "DeviceHandlerMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
-DeviceHandlerMessage::DeviceHandlerMessage() {
-}
-
 store_address_t DeviceHandlerMessage::getStoreAddress(
 		const CommandMessage* message) {
 	return store_address_t(message->getParameter2());
@@ -25,14 +21,6 @@ uint8_t DeviceHandlerMessage::getWiretappingMode(
 	return message->getParameter();
 }
 
-//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
-//		CommandMessage* message, DeviceCommandId_t deviceCommand,
-//		store_address_t commandParametersStoreId) {
-//	message->setCommand(CMD_DIRECT);
-//	message->setParameter(deviceCommand);
-//	message->setParameter2(commandParametersStoreId.raw);
-//}
-
 void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
 		CommandMessage* message, store_address_t rawPacketStoreId) {
 	message->setCommand(CMD_RAW);
@@ -47,7 +35,7 @@ void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
 
 void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
 		CommandMessage* message, uint32_t ioBoardIdentifier) {
-	message->setCommand(CMD_SWITCH_IOBOARD);
+	message->setCommand(CMD_SWITCH_ADDRESS);
 	message->setParameter(ioBoardIdentifier);
 }
 
@@ -79,18 +67,17 @@ void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
 void DeviceHandlerMessage::clear(CommandMessage* message) {
 	switch (message->getCommand()) {
 	case CMD_RAW:
-//	case CMD_DIRECT:
 	case REPLY_RAW_COMMAND:
 	case REPLY_RAW_REPLY:
 	case REPLY_DIRECT_COMMAND_DATA: {
 		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
 				objects::IPC_STORE);
-		if (ipcStore != NULL) {
+		if (ipcStore != nullptr) {
 			ipcStore->deleteData(getStoreAddress(message));
 		}
 	}
 		/* NO BREAK falls through*/
-	case CMD_SWITCH_IOBOARD:
+	case CMD_SWITCH_ADDRESS:
 	case CMD_WIRETAPPING:
 		message->setCommand(CommandMessage::CMD_NONE);
 		message->setParameter(0);
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index 8d1c94f41..e5da01c8f 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -1,69 +1,56 @@
-#ifndef DEVICEHANDLERMESSAGE_H_
-#define DEVICEHANDLERMESSAGE_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_
 
 #include "../action/ActionMessage.h"
 #include "../ipc/CommandMessage.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../storagemanager/StorageManagerIF.h"
-//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
+// SHOULDDO: rework the static constructors to name the type of command
+// they are building, maybe even hide setting the commandID.
+
 
 /**
- * This is used to uniquely identify commands that are sent to a device
- *
- * The values are defined in the device-specific implementations
- */
-typedef uint32_t DeviceCommandId_t;
-
-/**
- * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
+ * @brief   The DeviceHandlerMessage is used to send commands to classes
+ *          implementing DeviceHandlerIF
  */
 class DeviceHandlerMessage {
-private:
-	DeviceHandlerMessage();
 public:
+    /**
+     * Instantiation forbidden. Instead, use static functions to operate
+     * on messages.
+     */
+	DeviceHandlerMessage() = delete;
+	virtual ~DeviceHandlerMessage() {}
 
 	/**
 	 * These are the commands that can be sent to a DeviceHandlerBase
 	 */
 	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
-	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
-	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
+	//! Sends a raw command, setParameter is a storeId containing the
+	//! raw packet to send
+	static const Command_t CMD_RAW = MAKE_COMMAND_ID(1);
+	//! Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID(3);
+	//! (De)Activates the monitoring of all raw traffic in DeviceHandlers,
+	//! setParameter is 0 to deactivate, 1 to activate
+	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID(4);
 
-	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
-	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
-	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
-
-	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
-
-	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
-	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
-	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
-	 */
-	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
-	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
-	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
+	//! Signals that a direct command was sent
+	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS;
+	//! Contains a raw command sent to the Device
+	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11);
+	//! Contains a raw reply from the Device, getParameter() is the ObjcetId
+	//! of the sender, getParameter2() is a ::store_id_t containing the
+	//! raw packet received
+	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID(0x12);
 	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
 
-	/**
-	 * Default Destructor
-	 */
-	virtual ~DeviceHandlerMessage() {
-	}
-
 	static store_address_t getStoreAddress(const CommandMessage* message);
 	static uint32_t getDeviceCommandId(const CommandMessage* message);
 	static object_id_t getDeviceObjectId(const CommandMessage *message);
 	static object_id_t getIoBoardObjectId(const CommandMessage* message);
 	static uint8_t getWiretappingMode(const CommandMessage* message);
 
-//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
-//			DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-
 	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
 			object_id_t deviceObjectid,
 			store_address_t commandParametersStoreId);
@@ -75,11 +62,6 @@ public:
 			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
 			bool isCommand);
 
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, store_address_t rawPacketStoreId);
 	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
 			uint8_t wiretappingMode);
 	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
@@ -88,4 +70,4 @@ public:
 	static void clear(CommandMessage* message);
 };
 
-#endif /* DEVICEHANDLERMESSAGE_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_ */
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 84f926f06..c70f57d6d 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -1,4 +1,3 @@
-#include "../serialize/SerializeAdapter.h"
 #include "DeviceTmReportingWrapper.h"
 #include "../serialize/SerializeAdapter.h"
 
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index a14c4261d..447e95f2c 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -1,5 +1,5 @@
-#ifndef DEVICETMREPORTINGWRAPPER_H_
-#define DEVICETMREPORTINGWRAPPER_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
+#define FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
 
 #include "../action/HasActionsIF.h"
 #include "../objectmanager/SystemObjectIF.h"
@@ -24,4 +24,4 @@ private:
 	SerializeIF *data;
 };
 
-#endif /* DEVICETMREPORTINGWRAPPER_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_ */
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index b15e5d2ba..418ed2576 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -13,10 +13,10 @@ HealthDevice::~HealthDevice() {
 }
 
 ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		healthHelper.handleHealthCommand(&message);
+		healthHelper.handleHealthCommand(&command);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/devicehandlers/HealthDevice.h b/devicehandlers/HealthDevice.h
index 53b0ab097..738f0c7ea 100644
--- a/devicehandlers/HealthDevice.h
+++ b/devicehandlers/HealthDevice.h
@@ -1,5 +1,5 @@
-#ifndef HEALTHDEVICE_H_
-#define HEALTHDEVICE_H_
+#ifndef FSFW_DEVICEHANDLERS_HEALTHDEVICE_H_
+#define FSFW_DEVICEHANDLERS_HEALTHDEVICE_H_
 
 #include "../health/HasHealthIF.h"
 #include "../health/HealthHelper.h"
@@ -37,4 +37,4 @@ public:
 	HealthHelper healthHelper;
 };
 
-#endif /* HEALTHDEVICE_H_ */
+#endif /* FSFW_DEVICEHANDLERS_HEALTHDEVICE_H_ */

From 3af79e572ef34c8508b9d6f6315893952cfacda5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 18:19:11 +0200
Subject: [PATCH 0901/1774] default msg size for health device

---
 devicehandlers/HealthDevice.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 8b7d7f23b..418ed2576 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -5,8 +5,7 @@ HealthDevice::HealthDevice(object_id_t setObjectId,
 		MessageQueueId_t parentQueue) :
 		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
 				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(3,
-	        CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
+	commandQueue = QueueFactory::instance()->createMessageQueue(3);
 }
 
 HealthDevice::~HealthDevice() {

From dbcd06527ef728c2620c4141eab58bbf40994339 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 18:28:07 +0200
Subject: [PATCH 0902/1774] separate step for performOp now

---
 devicehandlers/DeviceHandlerBase.cpp | 39 ++++++++++++++++++----------
 devicehandlers/DeviceHandlerBase.h   |  3 ++-
 devicehandlers/DeviceHandlerIF.h     |  3 ++-
 3 files changed, 29 insertions(+), 16 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 227d5b6dc..d67e47d8a 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -72,8 +72,13 @@ DeviceHandlerBase::~DeviceHandlerBase() {
 
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	this->pstStep = counter;
+	this->lastStep = this->pstStep;
 
-	if (getComAction() == SEND_WRITE) {
+	if (getComAction() == CommunicationAction::NOTHING) {
+	    return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	if (getComAction() == CommunicationAction::PERFORM_OPERATION) {
 		cookieInfo.state = COOKIE_UNUSED;
 		readCommandQueue();
 		doStateMachine();
@@ -83,26 +88,29 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		hkSwitcher.performOperation();
 		hkManager.performHkOperation();
 		performOperationHook();
+		return RETURN_OK;
 	}
+
 	if (mode == MODE_OFF) {
 		return RETURN_OK;
 	}
+
 	switch (getComAction()) {
-	case SEND_WRITE:
-		if ((cookieInfo.state == COOKIE_UNUSED)) {
+	case CommunicationAction::SEND_WRITE:
+		if (cookieInfo.state == COOKIE_UNUSED) {
+		    // if no external command was specified, build internal command.
 			buildInternalCommand();
 		}
 		doSendWrite();
 		break;
-	case GET_WRITE:
+	case CommunicationAction::GET_WRITE:
 		doGetWrite();
 		break;
-	case SEND_READ:
+	case CommunicationAction::SEND_READ:
 		doSendRead();
 		break;
-	case GET_READ:
+	case CommunicationAction::GET_READ:
 		doGetRead();
-		cookieInfo.state = COOKIE_UNUSED;
 		break;
 	default:
 		break;
@@ -821,24 +829,27 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 }
 
 //Default child implementations
-DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
+DeviceHandlerIF::CommunicationAction DeviceHandlerBase::getComAction() {
 	switch (pstStep) {
 	case 0:
-		return SEND_WRITE;
+		return CommunicationAction::PERFORM_OPERATION;
 		break;
 	case 1:
-		return GET_WRITE;
-		break;
+	    return CommunicationAction::SEND_WRITE;
+	    break;
 	case 2:
-		return SEND_READ;
+		return CommunicationAction::GET_WRITE;
 		break;
 	case 3:
-		return GET_READ;
+		return CommunicationAction::SEND_READ;
+		break;
+	case 4:
+		return CommunicationAction::GET_READ;
 		break;
 	default:
 		break;
 	}
-	return NOTHING;
+	return CommunicationAction::NOTHING;
 }
 
 MessageQueueId_t DeviceHandlerBase::getCommandQueue() const {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index eda318cb8..627a64238 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -577,6 +577,7 @@ protected:
 
 	/** This is the counter value from performOperation(). */
 	uint8_t pstStep = 0;
+	uint8_t lastStep = 0;
 	uint32_t pstIntervalMs = 0;
 
 	/**
@@ -841,7 +842,7 @@ protected:
 	 * @return The Rmap action to execute in this step
 	 */
 
-	virtual CommunicationAction_t getComAction();
+	virtual CommunicationAction getComAction();
 
 	/**
 	 * Build the device command to send for raw mode.
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 9c8eb0983..088c1b457 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -139,7 +139,8 @@ public:
 	 *
 	 * This is used by the child class to tell the base class what to do.
 	 */
-	enum CommunicationAction_t: uint8_t {
+	enum CommunicationAction: uint8_t {
+	    PERFORM_OPERATION,
 		SEND_WRITE,//!< Send write
 		GET_WRITE, //!< Get write
 		SEND_READ, //!< Send read

From 72ca2bfa43e56a98a7462f9a372fe290c7e67e5e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 00:50:24 +0200
Subject: [PATCH 0903/1774] added new messages

---
 datapoollocal/HasLocalDataPoolIF.h          | 28 ++++++--
 datapoollocal/LocalDataPoolManager.h        | 69 ++++++++++++++++---
 datapoollocal/locPoolDefinitions.h          | 51 ++++++++++++++
 housekeeping/AcceptsHkPacketsIF.h           |  1 +
 housekeeping/HousekeepingMessage.cpp        | 57 +++++++++++++++-
 housekeeping/HousekeepingMessage.h          | 75 +++++++++------------
 housekeeping/PeriodicHousekeepingHelper.cpp |  3 +-
 7 files changed, 224 insertions(+), 60 deletions(-)
 create mode 100644 datapoollocal/locPoolDefinitions.h

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index f8f4ef4c4..acb3d773c 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,6 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
+#include "locPoolDefinitions.h"
+
 #include "../datapool/PoolEntryIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
@@ -10,10 +12,6 @@
 class LocalDataPoolManager;
 class LocalPoolDataSetBase;
 
-/**
- * @brief	Type definition for local pool entries.
- */
-using lp_id_t = uint32_t;
 using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
 using LocalDataPoolMapIter = LocalDataPool::iterator;
 
@@ -78,6 +76,28 @@ public:
 	 */
 	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
 
+    /**
+     * @brief   This function will be called by the manager if an update
+     *          notification is received.
+     * @details
+     * Can be overriden by the child class to handle changed datasets.
+     * @param sid
+     */
+    virtual void handleChangedDatasetOrVariable(sid_t sid) {
+        return;
+    }
+
+    /**
+     * @brief   This function will be called by the manager if an update
+     *          notification is received.
+     * @details
+     * Can be overriden by the child class to handle changed pool IDs.
+     * @param sid
+     */
+    virtual void handleChangedPoolVariable(lp_id_t poolId) {
+        return;
+    }
+
 	/* These function can be implemented by pool owner, as they are required
 	 * by the housekeeping message interface */
 	virtual ReturnValue_t addDataSet(sid_t sid) {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 779e30500..84a0d31e9 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -91,7 +91,8 @@ public:
 	ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
 
     /**
-     * This should be called in the periodic handler of the owner.
+     * @brief   This should be called in the periodic handler of the owner.
+     * @details
      * It performs all the periodic functionalities of the data pool manager,
      * for example generating periodic HK packets.
      * @return
@@ -99,12 +100,47 @@ public:
     ReturnValue_t performHkOperation();
 
 	/**
+	 * @brief   Subscribe for the generation of periodic packets.
+	 * @details
+	 * This will most commonly be used to generate housekeeping packets
+	 * which are downlinked directly.
 	 * @return
 	 */
 	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
 			float collectionInterval, bool isDiagnostics,
 			object_id_t packetDestination = defaultHkDestination);
 
+	/**
+	 * @brief   Subscribe for the  generation of packets if the dataset
+	 *          is marked as changed.
+	 * @param sid
+	 * @param isDiagnostics
+	 * @param packetDestination
+	 * @return
+	 */
+    ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool isDiagnostics,
+            object_id_t packetDestination = defaultHkDestination);
+
+	/**
+	 * @brief   Subscribe for a notification message which will be sent
+	 *          if a dataset has changed.
+	 * @param sid
+	 * @param targetQueueId
+	 * @return
+	 */
+	ReturnValue_t subscribeForUpdateMessages(sid_t sid,
+	        MessageQueueId_t targetQueueId);
+
+    /**
+     * @brief   Subscribe for an notification message which will be sent if a
+     *          pool variable has changed.
+     * @param sid
+     * @param targetQueueId
+     * @return
+     */
+    ReturnValue_t subscribeForUpdateMessages(lp_id_t localPoolId,
+            MessageQueueId_t targetQueueId);
+
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
 	 * than diagnostic packets.
@@ -116,6 +152,19 @@ public:
 	 */
 	void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
 
+    /**
+     * @brief   The manager is also able to handle housekeeping messages.
+     * @details
+     * This most commonly is used to handle messages for the housekeeping
+     * interface, but the manager is also able to handle update notifications
+     * and calls a special function which can be overriden by a child class
+     * to handle data set or pool variable updates. This is relevant
+     * for classes like controllers which have their own local datapool
+     * but pull their data from other local datapools.
+     * @param message
+     * @return
+     */
+    ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
 	/**
 	 * Generate a housekeeping packet with a given SID.
@@ -126,16 +175,6 @@ public:
 			LocalPoolDataSetBase* dataSet, bool forDownlink,
 			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 
-	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
-
-	/**
-	 * This function is used to fill the local data pool map with pool
-	 * entries. It should only be called once by the pool owner.
-	 * @param localDataPoolMap
-	 * @return
-	 */
-	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
-
 	HasLocalDataPoolIF* getOwner();
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
@@ -255,6 +294,14 @@ private:
 	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
 			PoolEntry<T> **poolEntry);
 
+    /**
+     * This function is used to fill the local data pool map with pool
+     * entries. It should only be called once by the pool owner.
+     * @param localDataPoolMap
+     * @return
+     */
+    ReturnValue_t initializeHousekeepingPoolEntriesOnce();
+
 	ReturnValue_t serializeHkPacketIntoStore(
 	        HousekeepingPacketDownlink& hkPacket,
 	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
diff --git a/datapoollocal/locPoolDefinitions.h b/datapoollocal/locPoolDefinitions.h
new file mode 100644
index 000000000..d14930595
--- /dev/null
+++ b/datapoollocal/locPoolDefinitions.h
@@ -0,0 +1,51 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
+#define FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
+
+#include <cstdint>
+#include "../objectmanager/SystemObjectIF.h"
+#include "../objectmanager/frameworkObjects.h"
+
+/**
+ * @brief   Type definition for local pool entries.
+ */
+using lp_id_t = uint32_t;
+
+
+union sid_t {
+    static constexpr uint64_t INVALID_SID = -1;
+    static constexpr uint32_t INVALID_SET_ID = -1;
+    static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+    sid_t(): raw(INVALID_SID) {}
+
+    sid_t(object_id_t objectId, uint32_t setId):
+            objectId(objectId),
+            ownerSetId(setId) {}
+
+    struct {
+        object_id_t objectId ;
+        /**
+         * A generic 32 bit ID to identify unique HK packets for a single
+         * object. For example, the DeviceCommandId_t is used for
+         * DeviceHandlers
+         */
+        uint32_t ownerSetId;
+    };
+    /**
+     * Alternative access to the raw value. This is also the size of the type.
+     */
+    uint64_t raw;
+
+    bool notSet() const {
+        return raw == INVALID_SID;
+    }
+
+    bool operator==(const sid_t& other) const {
+        return raw == other.raw;
+    }
+
+    bool operator!=(const sid_t& other) const {
+        return not (raw == other.raw);
+    }
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_ */
diff --git a/housekeeping/AcceptsHkPacketsIF.h b/housekeeping/AcceptsHkPacketsIF.h
index b3ba6e7c0..6fa151b19 100644
--- a/housekeeping/AcceptsHkPacketsIF.h
+++ b/housekeeping/AcceptsHkPacketsIF.h
@@ -1,5 +1,6 @@
 #ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
 #define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+
 #include "../ipc/MessageQueueMessageIF.h"
 
 class AcceptsHkPacketsIF {
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index d2ab546b0..221f0a6f8 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,5 +1,6 @@
-#include <fsfw/objectmanager/ObjectManagerIF.h>
 #include "HousekeepingMessage.h"
+
+#include "../objectmanager/ObjectManagerIF.h"
 #include <cstring>
 
 HousekeepingMessage::~HousekeepingMessage() {}
@@ -148,7 +149,7 @@ void HousekeepingMessage::clear(CommandMessage* message) {
     case(DIAGNOSTICS_REPORT):
     case(HK_DEFINITIONS_REPORT):
     case(DIAGNOSTICS_DEFINITION_REPORT):
-    case(UPDATE_SNAPSHOT): {
+    case(UPDATE_SNAPSHOT_SET): {
         store_address_t storeId;
         getHkDataReply(message, &storeId);
         StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
@@ -160,3 +161,55 @@ void HousekeepingMessage::clear(CommandMessage* message) {
     }
     message->setCommand(CommandMessage::CMD_NONE);
 }
+
+void HousekeepingMessage::setUpdateNotificationSetCommand(
+        CommandMessage *command, sid_t sid) {
+    command->setCommand(UPDATE_NOTIFICATION_SET);
+    setSid(command, sid);
+}
+
+void HousekeepingMessage::setUpdateNotificationVariableCommand(
+        CommandMessage *command, lp_id_t localPoolId) {
+    command->setCommand(UPDATE_NOTIFICATION_VARIABLE);
+    command->setParameter(localPoolId);
+}
+
+void HousekeepingMessage::setUpdateSnapshotSetCommand(CommandMessage *command,
+        sid_t sid, store_address_t storeId) {
+    command->setCommand(UPDATE_SNAPSHOT_VARIABLE);
+    setSid(command, sid);
+    command->setParameter3(storeId.raw);
+}
+
+void HousekeepingMessage::setUpdateSnapshotVariableCommand(
+        CommandMessage *command, lp_id_t localPoolId, store_address_t storeId) {
+    command->setCommand(UPDATE_SNAPSHOT_VARIABLE);
+    command->setParameter(localPoolId);
+    command->setParameter3(storeId.raw);
+}
+
+sid_t HousekeepingMessage::getUpdateNotificationSetCommand(
+        const CommandMessage *command) {
+    return getSid(command);
+}
+
+lp_id_t HousekeepingMessage::getUpdateNotificationVariableCommand(
+        const CommandMessage *command) {
+    return command->getParameter();
+}
+
+sid_t HousekeepingMessage::getUpdateSnapshotSetCommand(
+        const CommandMessage *command, store_address_t *storeId) {
+    if(storeId != nullptr) {
+        *storeId = command->getParameter3();
+    }
+    return getSid(command);
+}
+
+lp_id_t HousekeepingMessage::getUpdateSnapshotVariableCommand(
+        const CommandMessage *command, store_address_t *storeId) {
+    if(storeId != nullptr) {
+        *storeId = command->getParameter3();
+    }
+    return command->getParameter();
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 6dc95f542..70711be91 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,49 +1,12 @@
 #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
 #include "../objectmanager/frameworkObjects.h"
-#include "../objectmanager/SystemObjectIF.h"
 #include "../storagemanager/StorageManagerIF.h"
 
-union sid_t {
-	static constexpr uint64_t INVALID_SID = -1;
-	static constexpr uint32_t INVALID_SET_ID = -1;
-	static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
-	sid_t(): raw(INVALID_SID) {}
-
-	sid_t(object_id_t objectId, uint32_t setId):
-			objectId(objectId),
-			ownerSetId(setId) {}
-
-	struct {
-		object_id_t objectId ;
-		/**
-		 * A generic 32 bit ID to identify unique HK packets for a single
-		 * object. For example, the DeviceCommandId_t is used for
-		 * DeviceHandlers
-		 */
-		uint32_t ownerSetId;
-	};
-	/**
-	 * Alternative access to the raw value. This is also the size of the type.
-	 */
-	uint64_t raw;
-
-	bool notSet() const {
-	    return raw == INVALID_SID;
-	}
-
-	bool operator==(const sid_t& other) const {
-		return raw == other.raw;
-	}
-
-	bool operator!=(const sid_t& other) const {
-		return not (raw == other.raw);
-	}
-};
-
 
 /**
  * @brief	Special command message type for housekeeping messages
@@ -101,14 +64,20 @@ public:
 	static constexpr Command_t HK_REQUEST_FAILURE =
 			MAKE_COMMAND_ID(129);
 
-	static constexpr Command_t UPDATE_NOTIFICATION = MAKE_COMMAND_ID(130);
-	static constexpr Command_t UPDATE_SNAPSHOT = MAKE_COMMAND_ID(131);
+	static constexpr Command_t UPDATE_NOTIFICATION_SET =
+	        MAKE_COMMAND_ID(130);
+	static constexpr Command_t UPDATE_NOTIFICATION_VARIABLE =
+	        MAKE_COMMAND_ID(131);
 
-	static constexpr Command_t UPDATE_HK_REPORT = MAKE_COMMAND_ID(132);
+	static constexpr Command_t UPDATE_SNAPSHOT_SET = MAKE_COMMAND_ID(132);
+	static constexpr Command_t UPDATE_SNAPSHOT_VARIABLE = MAKE_COMMAND_ID(133);
+
+	//static constexpr Command_t UPDATE_HK_REPORT = MAKE_COMMAND_ID(134);
 
 	static sid_t getSid(const CommandMessage* message);
 
-	/** Setter functions */
+	/* Housekeeping Interface Messages */
+
 	static void setToggleReportingCommand(CommandMessage* command, sid_t sid,
 			bool enableReporting, bool isDiagnostics);
 	static void setStructureReportingCommand(CommandMessage* command, sid_t sid,
@@ -148,6 +117,28 @@ public:
 	static sid_t getCollectionIntervalModificationCommand(
 			const CommandMessage* command, float* newCollectionInterval);
 
+
+    /* Update Notification Messages */
+
+    static void setUpdateNotificationSetCommand(CommandMessage* command,
+            sid_t sid);
+    static void setUpdateNotificationVariableCommand(CommandMessage* command,
+            lp_id_t localPoolId);
+
+    static void setUpdateSnapshotSetCommand(CommandMessage* command, sid_t sid,
+            store_address_t storeId);
+    static void setUpdateSnapshotVariableCommand(CommandMessage* command,
+            lp_id_t localPoolId, store_address_t storeId);
+
+    sid_t getUpdateNotificationSetCommand(const CommandMessage* command);
+    lp_id_t getUpdateNotificationVariableCommand(const CommandMessage* command);
+
+    sid_t getUpdateSnapshotSetCommand(const CommandMessage* command,
+            store_address_t* storeId);
+    lp_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command,
+            store_address_t* storeId);
+
+    /** Utility */
 	static void clear(CommandMessage* message);
 private:
 	static void setSid(CommandMessage* message, sid_t sid);
diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
index 37349f815..365f00048 100644
--- a/housekeeping/PeriodicHousekeepingHelper.cpp
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -1,5 +1,6 @@
-#include "../datapoollocal/LocalPoolDataSetBase.h"
 #include "PeriodicHousekeepingHelper.h"
+
+#include "../datapoollocal/LocalPoolDataSetBase.h"
 #include <cmath>
 
 PeriodicHousekeepingHelper::PeriodicHousekeepingHelper(

From 9ca086e0269c5a09bea5dc992c9050fcd24e0dad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 01:25:15 +0200
Subject: [PATCH 0904/1774] base class extraction complete

---
 datapoollocal/LocalDataPoolManager.cpp | 46 ++++++++++++++++--
 datapoollocal/LocalPoolDataSetBase.cpp |  2 +-
 datapoollocal/LocalPoolDataSetBase.h   |  2 +-
 datapoollocal/LocalPoolObjectBase.cpp  | 67 ++++++++++++++++++++++++++
 datapoollocal/LocalPoolObjectBase.h    | 58 ++++++++++++++++++++++
 datapoollocal/LocalPoolVariable.h      | 21 +-------
 datapoollocal/LocalPoolVariable.tpp    | 65 +------------------------
 datapoollocal/LocalPoolVector.h        | 48 ++----------------
 datapoollocal/LocalPoolVector.tpp      | 62 +-----------------------
 9 files changed, 179 insertions(+), 192 deletions(-)
 create mode 100644 datapoollocal/LocalPoolObjectBase.cpp
 create mode 100644 datapoollocal/LocalPoolObjectBase.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 4f124e7fe..45ad7647e 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -88,9 +88,8 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
+    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
     for(auto& receiver: hkReceiversMap) {
-        //HkReceiver* receiver = &hkReceiversIter.second;
-
         switch(receiver.reportingType) {
         case(ReportingType::PERIODIC): {
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
@@ -100,8 +99,46 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
             performPeriodicHkGeneration(receiver);
             break;
         }
+        case(ReportingType::UPDATE_HK): {
+            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+                // Periodic packets shall only be generated from datasets.
+                continue;
+            }
+            LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                    receiver.dataId.sid);
+            if(dataSet->hasChanged()) {
+                // prepare and send update notification
+                ReturnValue_t result = generateHousekeepingPacket(
+                            receiver.dataId.sid, dataSet, true);
+                if(result != HasReturnvaluesIF::RETURN_OK) {
+                    status = result;
+                }
+            }
+            break;
+        }
+        case(ReportingType::UPDATE_NOTIFICATION): {
+            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+            }
+            else {
+                LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                        receiver.dataId.sid);
+                if(dataSet->hasChanged()) {
+                    // prepare and send update notification
+                }
+            }
+            break;
+        }
         case(ReportingType::UPDATE_SNAPSHOT): {
             // check whether data has changed and send messages in case it has.
+            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+            }
+            else {
+                LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                        receiver.dataId.sid);
+                if(dataSet->hasChanged()) {
+                    // prepare and send update snapshot.
+                }
+            }
             break;
         }
         default:
@@ -109,7 +146,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
     }
-    return HasReturnvaluesIF::RETURN_OK;
+    return status;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
@@ -368,8 +405,7 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		bool isDiagnostics) {
     // Get and check dataset first.
-	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-			owner->getDataSetHandle(sid));
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	if(dataSet == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
 				<< " Set ID not found" << std::endl;
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index da0a86b2c..e9adaa5a5 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -226,7 +226,7 @@ void LocalPoolDataSetBase::setChanged(bool changed) {
 	this->changed = changed;
 }
 
-bool LocalPoolDataSetBase::isChanged() const {
+bool LocalPoolDataSetBase::hasChanged() const {
 	return changed;
 }
 
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index d00af9920..2774f5073 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -117,7 +117,7 @@ public:
 	bool isValid() const override;
 
 	void setChanged(bool changed);
-	bool isChanged() const;
+	bool hasChanged() const;
 
 protected:
 	sid_t sid;
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
new file mode 100644
index 000000000..b6302e7e6
--- /dev/null
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -0,0 +1,67 @@
+#include "LocalPoolObjectBase.h"
+
+LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
+        HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+        pool_rwm_t setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
+    }
+    if(hkOwner == nullptr) {
+        sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+                << "owner is a invalid!" << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+    if (dataSet != nullptr) {
+        dataSet->registerVariable(this);
+    }
+}
+
+LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, object_id_t poolOwner,
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
+    }
+    HasLocalDataPoolIF* hkOwner =
+            objectManager->get<HasLocalDataPoolIF>(poolOwner);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalPoolVariable: The supplied pool owner did not "
+                << "implement the correct interface"
+                << " HasLocalDataPoolIF!" << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+    if(dataSet != nullptr) {
+        dataSet->registerVariable(this);
+    }
+}
+
+pool_rwm_t LocalPoolObjectBase::getReadWriteMode() const {
+    return readWriteMode;
+}
+
+bool LocalPoolObjectBase::isValid() const {
+    return valid;
+}
+
+void LocalPoolObjectBase::setValid(bool valid) {
+    this->valid = valid;
+}
+
+lp_id_t LocalPoolObjectBase::getDataPoolId() const {
+    return localPoolId;
+}
+
+void LocalPoolObjectBase::setDataPoolId(lp_id_t poolId) {
+    this->localPoolId = poolId;
+}
+
+void LocalPoolObjectBase::setChanged(bool changed) {
+    this->changed = changed;
+}
+
+bool LocalPoolObjectBase::hasChanged() const {
+    return changed;
+}
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
new file mode 100644
index 000000000..8445b7645
--- /dev/null
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -0,0 +1,58 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
+
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../datapool/PoolVariableIF.h"
+
+class LocalPoolObjectBase: public PoolVariableIF, HasReturnvaluesIF {
+public:
+    LocalPoolObjectBase(lp_id_t poolId,
+            HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+            pool_rwm_t setReadWriteMode);
+
+    LocalPoolObjectBase(lp_id_t poolId, object_id_t poolOwner,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+    pool_rwm_t getReadWriteMode() const;
+
+    bool isValid() const override;
+    void setValid(bool valid) override;
+
+    void setChanged(bool changed);
+    bool hasChanged() const;
+
+    lp_id_t getDataPoolId() const override;
+    void setDataPoolId(lp_id_t poolId);
+
+protected:
+    /**
+     * @brief   To access the correct data pool entry on read and commit calls,
+     *          the data pool id is stored.
+     */
+    uint32_t localPoolId = PoolVariableIF::NO_PARAMETER;
+    /**
+     * @brief   The valid information as it was stored in the data pool
+     *          is copied to this attribute.
+     */
+    bool valid = false;
+
+    /**
+     * @brief   A local pool variable can be marked as changed.
+     */
+    bool changed = false;
+
+    /**
+     * @brief   The information whether the class is read-write or
+     *          read-only is stored here.
+     */
+    ReadWriteMode_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
+
+    //! @brief  Pointer to the class which manages the HK pool.
+    LocalDataPoolManager* hkManager;
+
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index ec5c8cd19..e9d94178a 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 
+#include "LocalPoolObjectBase.h"
 #include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
 
@@ -21,7 +22,7 @@
  * @ingroup data_pool
  */
 template<typename T>
-class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
+class LocalPoolVar: public LocalPoolObjectBase {
 public:
 	//! Default ctor is forbidden.
 	LocalPoolVar() = delete;
@@ -76,15 +77,6 @@ public:
 	 */
 	T value = 0;
 
-	pool_rwm_t getReadWriteMode() const override;
-
-	lp_id_t getDataPoolId() const override;
-	void setDataPoolId(lp_id_t poolId);
-
-	bool isValid() const override;
-	void setValid(bool validity) override;
-	uint8_t getValid() const;
-
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
 	        SerializeIF::Endianness streamEndianness) const override;
 	virtual size_t getSerializedSize() const override;
@@ -145,15 +137,6 @@ protected:
 			const LocalPoolVar<U> &var);
 
 private:
-	//! @brief 	Pool ID of pool entry inside the used local pool.
-	lp_id_t localPoolId = PoolVariableIF::NO_PARAMETER;
-	//! @brief 	Read-write mode of the pool variable
-	pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
-	//! @brief 	Specifies whether the entry is valid or invalid.
-	bool valid = false;
-
-	//! Pointer to the class which manages the HK pool.
-	LocalDataPoolManager* hkManager;
 };
 
 #include "LocalPoolVariable.tpp"
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index b0bdd7b9e..3320aa5a4 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -9,43 +9,12 @@ template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
 		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
 		pool_rwm_t setReadWriteMode):
-		localPoolId(poolId), readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-		        << "which is the NO_PARAMETER value!" << std::endl;
-	}
-	if(hkOwner == nullptr) {
-		sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
-		        << "owner is a invalid!" << std::endl;
-		return;
-	}
-	hkManager = hkOwner->getHkManagerHandle();
-	if(dataSet != nullptr) {
-	    dataSet->registerVariable(this);
-	}
-}
+		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-        localPoolId(poolId), readWriteMode(setReadWriteMode) {
-    if(poolId == PoolVariableIF::NO_PARAMETER) {
-        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
-    }
-    HasLocalDataPoolIF* hkOwner =
-            objectManager->get<HasLocalDataPoolIF>(poolOwner);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalPoolVariable: The supplied pool owner did not "
-                << "implement  the correct interface "
-                << "HasLocalDataPoolIF!" << std::endl;
-        return;
-	}
-	hkManager = hkOwner->getHkManagerHandle();
-	if(dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
+        LocalPoolObjectBase(poolId, poolOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
@@ -111,36 +80,6 @@ inline LocalPoolVar<T> & LocalPoolVar<T>::operator =(T newValue) {
 }
 
 
-template<typename T>
-inline pool_rwm_t LocalPoolVar<T>::getReadWriteMode() const {
-	return readWriteMode;
-}
-
-template<typename T>
-inline lp_id_t LocalPoolVar<T>::getDataPoolId() const {
-	return localPoolId;
-}
-
-template<typename T>
-inline void LocalPoolVar<T>::setDataPoolId(lp_id_t poolId) {
-	this->localPoolId = poolId;
-}
-
-template<typename T>
-inline bool LocalPoolVar<T>::isValid() const {
-	return valid;
-}
-
-template<typename T>
-inline void LocalPoolVar<T>::setValid(bool validity) {
-	this->valid = validity;
-}
-
-template<typename T>
-inline uint8_t LocalPoolVar<T>::getValid() const {
-	return valid;
-}
-
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 57c4b90b4..a7ebd3fe6 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 
+#include "LocalPoolObjectBase.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
 #include "../datapool/PoolVariableIF.h"
@@ -30,7 +31,7 @@
  * @ingroup data_pool
  */
 template<typename T, uint16_t vectorSize>
-class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
+class LocalPoolVector: public LocalPoolObjectBase {
 public:
 	LocalPoolVector() = delete;
 	/**
@@ -48,8 +49,7 @@ public:
 	 */
 	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE
-			);
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	/**
 	 * This constructor is used by data users like controllers to have
@@ -67,8 +67,7 @@ public:
 	 */
 	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
 			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE
-			);
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	/**
 	 * @brief	This is the local copy of the data pool entry.
@@ -91,27 +90,6 @@ public:
 		return vectorSize;
 	}
 
-	uint32_t getDataPoolId() const override;
-	/**
-	 * @brief This operation sets the data pool ID of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	pool_rwm_t getReadWriteMode() const;
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-	void setValid(bool valid) override;
-	uint8_t getValid() const;
-
 	T& operator [](int i);
 	const T &operator [](int i) const;
 
@@ -168,23 +146,7 @@ protected:
 	ReturnValue_t commitWithoutLock() override;
 
 private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t localPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	bool valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	//! @brief	Pointer to the class which manages the HK pool.
-	LocalDataPoolManager* hkManager;
+
 
 	// std::ostream is the type for object std::cout
 	template <typename U, uint16_t otherSize>
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 2aa6fbb5f..34720b970 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -9,39 +9,12 @@ template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
 		pool_rwm_t setReadWriteMode):
-		localPoolId(poolId), valid(false), readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: PoolVariableIF::NO_PARAMETER passed "
-				<< "as pool ID, which is the NO_PARAMETER value!" << std::endl;
-	}
-	std::memset(this->value, 0, vectorSize * sizeof(T));
-	hkManager = hkOwner->getHkManagerHandle();
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
+		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 		object_id_t poolOwner, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: PoolVariableIF::NO_PARAMETER passed "
-				<< "as pool ID, which is the NO_PARAMETER value!" << std::endl;
-	}
-	HasLocalDataPoolIF* hkOwner =
-			objectManager->get<HasLocalDataPoolIF>(poolOwner);
-	if(hkOwner == nullptr) {
-		sif::error << "LocalPoolVariable: The supplied pool owner did not "
-				<< "implement the correct interface HasHkPoolParametersIF!"
-				<< std::endl;
-		return;
-	}
-	hkManager = hkOwner->getHkManagerHandle();
-	if(dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
+		LocalPoolObjectBase(poolId, poolOwner, dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
@@ -161,37 +134,6 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
 	return result;
 }
 
-template<typename T, uint16_t vectorSize>
-inline pool_rwm_t LocalPoolVector<T, vectorSize>::getReadWriteMode() const {
-	return this->readWriteMode;
-}
-
-
-template<typename T, uint16_t vectorSize>
-inline uint32_t LocalPoolVector<T, vectorSize>::getDataPoolId() const {
-	return localPoolId;
-}
-
-template<typename T, uint16_t vectorSize>
-inline void LocalPoolVector<T, vectorSize>::setDataPoolId(uint32_t poolId) {
-	this->localPoolId = poolId;
-}
-
-template<typename T, uint16_t vectorSize>
-inline void LocalPoolVector<T, vectorSize>::setValid(bool valid) {
-	this->valid = valid;
-}
-
-template<typename T, uint16_t vectorSize>
-inline uint8_t LocalPoolVector<T, vectorSize>::getValid() const {
-	return valid;
-}
-
-template<typename T, uint16_t vectorSize>
-inline bool LocalPoolVector<T, vectorSize>::isValid() const {
-	return valid;
-}
-
 template<typename T, uint16_t vectorSize>
 inline std::ostream& operator<< (std::ostream &out,
         const LocalPoolVector<T, vectorSize> &var) {

From 45c0acec5f4744862a411c3b1852d6a7785f6b3c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 01:38:27 +0200
Subject: [PATCH 0905/1774] its all falling into places

---
 datapoollocal/HasLocalDataPoolIF.h     | 14 ++++++++++++++
 datapoollocal/LocalDataPoolManager.cpp | 25 ++++++++++++++++++++++++-
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index acb3d773c..d7950b49c 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -11,6 +11,7 @@
 
 class LocalDataPoolManager;
 class LocalPoolDataSetBase;
+class LocalPoolObjectBase;
 
 using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
 using LocalDataPoolMapIter = LocalDataPool::iterator;
@@ -76,6 +77,19 @@ public:
 	 */
 	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
 
+	/**
+	 * Similar to the function above, but used to get a local pool variable
+	 * handle. This is only needed for update notifications, so it is not
+	 * defined as abstract.
+	 * @param localPoolId
+	 * @return
+	 */
+	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
+	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
+	            << ". Returning nullptr!" << std::endl;
+	    return nullptr;
+	}
+
     /**
      * @brief   This function will be called by the manager if an update
      *          notification is received.
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 45ad7647e..a33f19e54 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,4 +1,5 @@
 #include "LocalDataPoolManager.h"
+#include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
 
 #include "../housekeeping/HousekeepingSetPacket.h"
@@ -101,7 +102,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
         }
         case(ReportingType::UPDATE_HK): {
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-                // Periodic packets shall only be generated from datasets.
+                // Update packets shall only be generated from datasets.
                 continue;
             }
             LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
@@ -118,10 +119,21 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
         }
         case(ReportingType::UPDATE_NOTIFICATION): {
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+                LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+                        receiver.dataId.localPoolId);
+                if(poolObj == nullptr) {
+                    continue;
+                }
+                if(poolObj->hasChanged()) {
+                    // prepare and send update notification.
+                }
             }
             else {
                 LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                         receiver.dataId.sid);
+                if(dataSet == nullptr) {
+                    continue;
+                }
                 if(dataSet->hasChanged()) {
                     // prepare and send update notification
                 }
@@ -131,10 +143,21 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
         case(ReportingType::UPDATE_SNAPSHOT): {
             // check whether data has changed and send messages in case it has.
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+                LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+                        receiver.dataId.localPoolId);
+                if(poolObj == nullptr) {
+                    continue;
+                }
+                if(poolObj->hasChanged()) {
+                    // prepare and send update snapshot.
+                }
             }
             else {
                 LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                         receiver.dataId.sid);
+                if(dataSet == nullptr) {
+                    continue;
+                }
                 if(dataSet->hasChanged()) {
                     // prepare and send update snapshot.
                 }

From 088bc35301dc87ebb7b4d30e789deda7264b973e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 12:42:30 +0200
Subject: [PATCH 0906/1774] update handler continued

---
 datapoollocal/LocalDataPoolManager.cpp | 154 +++++++++++++++++++++++++
 datapoollocal/LocalDataPoolManager.h   |  34 ++++--
 datapoollocal/LocalPoolDataSetBase.cpp |   8 ++
 datapoollocal/LocalPoolDataSetBase.h   |  16 ++-
 datapoollocal/LocalPoolObjectBase.h    |  10 +-
 datapoollocal/MarkChangedIF.h          |  17 +++
 6 files changed, 224 insertions(+), 15 deletions(-)
 create mode 100644 datapoollocal/MarkChangedIF.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index a33f19e54..a2a087e86 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -115,9 +115,12 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                     status = result;
                 }
             }
+            handleChangeResetLogic(receiver.dataType, receiver.dataId,
+                    dataSet);
             break;
         }
         case(ReportingType::UPDATE_NOTIFICATION): {
+            MarkChangedIF* toReset = nullptr;
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
                 LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                         receiver.dataId.localPoolId);
@@ -125,8 +128,10 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                     continue;
                 }
                 if(poolObj->hasChanged()) {
+
                     // prepare and send update notification.
                 }
+                toReset = poolObj;
             }
             else {
                 LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
@@ -135,12 +140,16 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                     continue;
                 }
                 if(dataSet->hasChanged()) {
+
                     // prepare and send update notification
                 }
+                toReset = dataSet;
             }
+            handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
             break;
         }
         case(ReportingType::UPDATE_SNAPSHOT): {
+            MarkChangedIF* toReset = nullptr;
             // check whether data has changed and send messages in case it has.
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
                 LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
@@ -151,6 +160,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 if(poolObj->hasChanged()) {
                     // prepare and send update snapshot.
                 }
+                toReset = poolObj;
             }
             else {
                 LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
@@ -161,7 +171,9 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 if(dataSet->hasChanged()) {
                     // prepare and send update snapshot.
                 }
+                toReset = dataSet;
             }
+            handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
             break;
         }
         default:
@@ -169,9 +181,53 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
     }
+    resetHkUpdateResetHelper();
     return status;
 }
 
+void LocalDataPoolManager::handleChangeResetLogic(
+        DataType type, DataId dataId, MarkChangedIF* toReset) {
+    if(hkUpdateResetList == nullptr) {
+        // config error!
+        return;
+    }
+
+    for(auto& changeInfo: *hkUpdateResetList) {
+        if(changeInfo.dataType != type) {
+            continue;
+        }
+        if((changeInfo.dataType == DataType::DATA_SET) and
+                (changeInfo.dataId.sid != dataId.sid)) {
+            continue;
+        }
+        if((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
+                (changeInfo.dataId.localPoolId != dataId.localPoolId)) {
+            continue;
+        }
+
+        if(changeInfo.updateCounter <= 1) {
+            toReset->setChanged(false);
+        }
+        if(changeInfo.currentUpdateCounter == 0) {
+            toReset->setChanged(false);
+        }
+        else {
+            changeInfo.currentUpdateCounter--;
+        }
+        return;
+    }
+}
+
+void LocalDataPoolManager::resetHkUpdateResetHelper() {
+    if(hkUpdateResetList == nullptr) {
+        return;
+    }
+
+    for(auto& changeInfo: *hkUpdateResetList) {
+        changeInfo.currentUpdateCounter = changeInfo.updateCounter;
+    }
+}
+
 ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 		bool enableReporting, float collectionInterval, bool isDiagnostics,
 		object_id_t packetDestination) {
@@ -186,6 +242,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	struct HkReceiver hkReceiver;
 	hkReceiver.dataId.sid = sid;
 	hkReceiver.reportingType = ReportingType::PERIODIC;
+	hkReceiver.dataType = DataType::DATA_SET;
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
 	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
@@ -200,6 +257,103 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
+        bool isDiagnostics, bool reportingEnabled,
+        object_id_t packetDestination) {
+    AcceptsHkPacketsIF* hkReceiverObject =
+                objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+    if(hkReceiverObject == nullptr) {
+        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
+                << " Invalid receiver!"<< std::endl;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    struct HkReceiver hkReceiver;
+    hkReceiver.dataId.sid = sid;
+    hkReceiver.reportingType = ReportingType::UPDATE_HK;
+    hkReceiver.dataType = DataType::DATA_SET;
+    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(dataSet != nullptr) {
+        dataSet->setReportingEnabled(true);
+        dataSet->setDiagnostic(isDiagnostics);
+    }
+
+    hkReceiversMap.push_back(hkReceiver);
+
+    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::subscribeForUpdateMessages(sid_t sid,
+        object_id_t destinationObject, MessageQueueId_t targetQueueId) {
+    struct HkReceiver hkReceiver;
+    hkReceiver.dataType = DataType::DATA_SET;
+    hkReceiver.dataId.sid = sid;
+    hkReceiver.destinationQueue = targetQueueId;
+    hkReceiver.objectId = destinationObject;
+    hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+
+    hkReceiversMap.push_back(hkReceiver);
+
+    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::subscribeForUpdateMessages(
+        lp_id_t localPoolId, object_id_t destinationObject,
+        MessageQueueId_t targetQueueId) {
+    struct HkReceiver hkReceiver;
+    hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
+    hkReceiver.dataId.localPoolId = localPoolId;
+    hkReceiver.destinationQueue = targetQueueId;
+    hkReceiver.objectId = destinationObject;
+    hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+
+    hkReceiversMap.push_back(hkReceiver);
+
+    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType,
+        DataId dataId) {
+    if(hkUpdateResetList == nullptr) {
+        hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
+    }
+
+    for(auto& updateResetStruct: *hkUpdateResetList) {
+        if(dataType == DataType::DATA_SET) {
+            if(updateResetStruct.dataId.sid == dataId.sid) {
+                updateResetStruct.updateCounter++;
+                updateResetStruct.currentUpdateCounter++;
+                return;
+            }
+        }
+        else {
+            if(updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
+                updateResetStruct.updateCounter++;
+                updateResetStruct.currentUpdateCounter++;
+                return;
+            }
+        }
+
+    }
+    HkUpdateResetHelper hkUpdateResetHelper;
+    hkUpdateResetHelper.currentUpdateCounter = 1;
+    hkUpdateResetHelper.updateCounter = 1;
+    hkUpdateResetHelper.dataType = dataType;
+    if(dataType == DataType::DATA_SET) {
+        hkUpdateResetHelper.dataId.sid = dataId.sid;
+    }
+    else {
+        hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
+    }
+    hkUpdateResetList->push_back(hkUpdateResetHelper);
+}
+
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		CommandMessage* message) {
     Command_t command = message->getCommand();
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 84a0d31e9..cc9364e78 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -118,7 +118,8 @@ public:
 	 * @param packetDestination
 	 * @return
 	 */
-    ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool isDiagnostics,
+    ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool reportingEnabled,
+            bool isDiagnostics,
             object_id_t packetDestination = defaultHkDestination);
 
 	/**
@@ -129,7 +130,7 @@ public:
 	 * @return
 	 */
 	ReturnValue_t subscribeForUpdateMessages(sid_t sid,
-	        MessageQueueId_t targetQueueId);
+	        object_id_t destinationObject, MessageQueueId_t targetQueueId);
 
     /**
      * @brief   Subscribe for an notification message which will be sent if a
@@ -139,7 +140,7 @@ public:
      * @return
      */
     ReturnValue_t subscribeForUpdateMessages(lp_id_t localPoolId,
-            MessageQueueId_t targetQueueId);
+            object_id_t destinationObject, MessageQueueId_t targetQueueId);
 
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
@@ -233,17 +234,18 @@ private:
 	static object_id_t defaultHkDestination;
 	MessageQueueId_t hkDestinationId = MessageQueueIF::NO_QUEUE;
 
+    union DataId {
+        DataId(): sid() {};
+        sid_t sid;
+        lp_id_t localPoolId;
+    };
+
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
 		/** Object ID of receiver */
 		object_id_t objectId = objects::NO_OBJECT;
 
 		DataType dataType = DataType::DATA_SET;
-        union DataId {
-			DataId(): sid() {};
-            sid_t sid;
-            lp_id_t localPoolId;
-        };
         DataId dataId;
 
         ReportingType reportingType = ReportingType::PERIODIC;
@@ -255,6 +257,17 @@ private:
 
     HkReceivers hkReceiversMap;
 
+    struct HkUpdateResetHelper {
+        DataType dataType = DataType::DATA_SET;
+        DataId dataId;
+        uint8_t updateCounter;
+        uint8_t currentUpdateCounter;
+    };
+
+    using HkUpdateResetList = std::vector<struct HkUpdateResetHelper>;
+    // Will only be created when needed.
+    HkUpdateResetList* hkUpdateResetList = nullptr;
+
     /** This is the map holding the actual data. Should only be initialized
      * once ! */
     bool mapInitialized = false;
@@ -312,6 +325,11 @@ private:
 	ReturnValue_t changeCollectionInterval(sid_t sid,
 			float newCollectionInterval, bool isDiagnostics);
 	ReturnValue_t generateSetStructurePacket(sid_t sid, bool isDiagnostics);
+
+	void handleHkUpdateResetListInsertion(DataType dataType, DataId dataId);
+	void handleChangeResetLogic(DataType type,
+	        DataId dataId, MarkChangedIF* toReset);
+	void resetHkUpdateResetHelper();
 };
 
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index e9adaa5a5..5bb71cb64 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -20,6 +20,8 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
 
+    mutex = MutexFactory::instance()->createMutex();
+
     // Data creators get a periodic helper for periodic HK data generation.
     if(not noPeriodicHandling) {
     	 periodicHelper = new PeriodicHousekeepingHelper(this);
@@ -40,6 +42,8 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
     }
     hkManager = hkOwner->getHkManagerHandle();
     this->sid = sid;
+
+    mutex = MutexFactory::instance()->createMutex();
 }
 
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
@@ -223,10 +227,12 @@ void LocalPoolDataSetBase::initializePeriodicHelper(
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
 	this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
 	return changed;
 }
 
@@ -246,10 +252,12 @@ bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 }
 
 bool LocalPoolDataSetBase::isValid() const {
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
     return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
 	if(setEntriesRecursively) {
 		for(size_t idx = 0; idx < this->getFillCount(); idx++) {
 			registeredVariables[idx] -> setValid(valid);
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 2774f5073..aa155bf1b 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -2,6 +2,8 @@
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
 #include "HasLocalDataPoolIF.h"
+#include "MarkChangedIF.h"
+
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
 #include "../serialize/SerializeIF.h"
@@ -39,7 +41,8 @@ class PeriodicHousekeepingHelper;
  *
  * @ingroup data_pool
  */
-class LocalPoolDataSetBase: public PoolDataSetBase {
+class LocalPoolDataSetBase: public PoolDataSetBase,
+        public MarkChangedIF {
 	friend class LocalDataPoolManager;
 	friend class PeriodicHousekeepingHelper;
 public:
@@ -109,18 +112,23 @@ public:
 	uint8_t getLocalPoolIdsSerializedSize(bool serializeFillCount = true) const;
 
 	/**
-	 * Set the dataset valid or invalid
+	 * Set the dataset valid or invalid. These calls are mutex protected.
 	 * @param setEntriesRecursively
 	 * If this is true, all contained datasets will also be set recursively.
 	 */
 	void setValidity(bool valid, bool setEntriesRecursively);
 	bool isValid() const override;
 
-	void setChanged(bool changed);
-	bool hasChanged() const;
+	/**
+	 * These calls are mutex protected.
+	 * @param changed
+	 */
+	void setChanged(bool changed) override;
+	bool hasChanged() const override;
 
 protected:
 	sid_t sid;
+	MutexIF* mutex = nullptr;
 
 	bool diagnostic = false;
 	void setDiagnostic(bool diagnostics);
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 8445b7645..4d25b88a6 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -1,10 +1,14 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 
+#include "MarkChangedIF.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../datapool/PoolVariableIF.h"
 
-class LocalPoolObjectBase: public PoolVariableIF, HasReturnvaluesIF {
+
+class LocalPoolObjectBase: public PoolVariableIF,
+        public HasReturnvaluesIF,
+        public MarkChangedIF {
 public:
     LocalPoolObjectBase(lp_id_t poolId,
             HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
@@ -19,8 +23,8 @@ public:
     bool isValid() const override;
     void setValid(bool valid) override;
 
-    void setChanged(bool changed);
-    bool hasChanged() const;
+    void setChanged(bool changed) override;
+    bool hasChanged() const override;
 
     lp_id_t getDataPoolId() const override;
     void setDataPoolId(lp_id_t poolId);
diff --git a/datapoollocal/MarkChangedIF.h b/datapoollocal/MarkChangedIF.h
new file mode 100644
index 000000000..e575d1d3e
--- /dev/null
+++ b/datapoollocal/MarkChangedIF.h
@@ -0,0 +1,17 @@
+#ifndef FSFW_DATAPOOLLOCAL_MARKCHANGEDIF_H_
+#define FSFW_DATAPOOLLOCAL_MARKCHANGEDIF_H_
+
+/**
+ * Common interface for local pool entities which can be marked as changed.
+ */
+class MarkChangedIF {
+public:
+    virtual~ MarkChangedIF() {};
+
+    virtual bool hasChanged() const = 0;
+    virtual void setChanged(bool changed) = 0;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_MARKCHANGEDIF_H_ */

From 5b96161331519c43d9ea8903d0ad7d7029d8f410 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 16:46:00 +0200
Subject: [PATCH 0907/1774] optimization and printout improvements

---
 datapoollocal/LocalDataPoolManager.cpp | 27 +++++++++++++------
 datapoollocal/LocalDataPoolManager.h   | 36 ++++++++++++++++++++------
 2 files changed, 47 insertions(+), 16 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index a2a087e86..13225e78a 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -287,14 +287,20 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t LocalDataPoolManager::subscribeForUpdateMessages(sid_t sid,
-        object_id_t destinationObject, MessageQueueId_t targetQueueId) {
+ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
+        const uint32_t setId, object_id_t destinationObject,
+        MessageQueueId_t targetQueueId, bool generateSnapshot) {
     struct HkReceiver hkReceiver;
     hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.dataId.sid = sid;
+    hkReceiver.dataId.sid = sid_t(this->getOwner()->getObjectId(), setId);
     hkReceiver.destinationQueue = targetQueueId;
     hkReceiver.objectId = destinationObject;
-    hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+    if(generateSnapshot) {
+        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+    }
+    else {
+        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+    }
 
     hkReceiversMap.push_back(hkReceiver);
 
@@ -302,15 +308,20 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdateMessages(sid_t sid,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t LocalDataPoolManager::subscribeForUpdateMessages(
-        lp_id_t localPoolId, object_id_t destinationObject,
-        MessageQueueId_t targetQueueId) {
+ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessages(
+        const lp_id_t localPoolId, object_id_t destinationObject,
+        MessageQueueId_t targetQueueId, bool generateSnapshot) {
     struct HkReceiver hkReceiver;
     hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
     hkReceiver.dataId.localPoolId = localPoolId;
     hkReceiver.destinationQueue = targetQueueId;
     hkReceiver.objectId = destinationObject;
-    hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+    if(generateSnapshot) {
+        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+    }
+    else {
+        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+    }
 
     hkReceiversMap.push_back(hkReceiver);
 
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index cc9364e78..afe827605 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -102,8 +102,8 @@ public:
 	/**
 	 * @brief   Subscribe for the generation of periodic packets.
 	 * @details
-	 * This will most commonly be used to generate housekeeping packets
-	 * which are downlinked directly.
+     * This subscription mechanism will generally be used by the data creator
+     * to generate housekeeping packets which are downlinked directly.
 	 * @return
 	 */
 	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
@@ -113,6 +113,8 @@ public:
 	/**
 	 * @brief   Subscribe for the  generation of packets if the dataset
 	 *          is marked as changed.
+	 * @details
+	 * This subscription mechanism will generally be used by the data creator.
 	 * @param sid
 	 * @param isDiagnostics
 	 * @param packetDestination
@@ -125,22 +127,40 @@ public:
 	/**
 	 * @brief   Subscribe for a notification message which will be sent
 	 *          if a dataset has changed.
-	 * @param sid
+	 * @details
+	 * This subscription mechanism will generally be used internally by
+	 * other software components.
+	 * @param setId     Set ID of the set to receive update messages from.
+	 * @param destinationObject
 	 * @param targetQueueId
+	 * @param generateSnapshot If this is set to true, a copy of the current
+	 * data with a timestamp will be generated and sent via message.
+	 * Otherwise, only an notification message is sent.
 	 * @return
 	 */
-	ReturnValue_t subscribeForUpdateMessages(sid_t sid,
-	        object_id_t destinationObject, MessageQueueId_t targetQueueId);
+	ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
+	        object_id_t destinationObject,
+	        MessageQueueId_t targetQueueId,
+	        bool generateSnapshot);
 
     /**
      * @brief   Subscribe for an notification message which will be sent if a
      *          pool variable has changed.
-     * @param sid
+     * @details
+     * This subscription mechanism will generally be used internally by
+     * other software components.
+     * @param localPoolId Pool ID of the pool variable
+     * @param destinationObject
      * @param targetQueueId
+     * @param generateSnapshot If this is set to true, a copy of the current
+     * data with a timestamp will be generated and sent via message.
+     * Otherwise, only an notification message is sent.
      * @return
      */
-    ReturnValue_t subscribeForUpdateMessages(lp_id_t localPoolId,
-            object_id_t destinationObject, MessageQueueId_t targetQueueId);
+    ReturnValue_t subscribeForVariableUpdateMessages(const lp_id_t localPoolId,
+            object_id_t destinationObject,
+            MessageQueueId_t targetQueueId,
+            bool generateSnapshot);
 
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency

From a9a31308ae40618e49db5c6e98f131bfdebddcb7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 19:52:06 +0200
Subject: [PATCH 0908/1774] update notifications working

---
 datapoollocal/LocalDataPoolManager.cpp | 34 ++++++++++++++++++++------
 housekeeping/HousekeepingMessage.h     |  9 ++++---
 ipc/CommandMessageCleaner.cpp          |  2 +-
 pus/Service3Housekeeping.cpp           |  5 ++--
 4 files changed, 35 insertions(+), 15 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 13225e78a..848ade5e8 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -128,10 +128,10 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                     continue;
                 }
                 if(poolObj->hasChanged()) {
-
                     // prepare and send update notification.
+                    toReset = poolObj;
                 }
-                toReset = poolObj;
+
             }
             else {
                 LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
@@ -140,12 +140,22 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                     continue;
                 }
                 if(dataSet->hasChanged()) {
-
                     // prepare and send update notification
+                    CommandMessage notification;
+                    HousekeepingMessage::setUpdateNotificationSetCommand(
+                            &notification, receiver.dataId.sid);
+                    ReturnValue_t result = hkQueue->sendMessage(
+                            receiver.destinationQueue, &notification);
+                    if(result != HasReturnvaluesIF::RETURN_OK) {
+                        status = result;
+                    }
+                    toReset = dataSet;
                 }
-                toReset = dataSet;
             }
-            handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
+            if(toReset != nullptr) {
+                handleChangeResetLogic(receiver.dataType,
+                        receiver.dataId, toReset);
+            }
             break;
         }
         case(ReportingType::UPDATE_SNAPSHOT): {
@@ -159,8 +169,8 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 }
                 if(poolObj->hasChanged()) {
                     // prepare and send update snapshot.
+                    toReset = poolObj;
                 }
-                toReset = poolObj;
             }
             else {
                 LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
@@ -170,10 +180,13 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 }
                 if(dataSet->hasChanged()) {
                     // prepare and send update snapshot.
+                    toReset = dataSet;
                 }
-                toReset = dataSet;
             }
-            handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
+            if(toReset != nullptr) {
+                handleChangeResetLogic(receiver.dataType,
+                        receiver.dataId, toReset);
+            }
             break;
         }
         default:
@@ -425,6 +438,11 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     			dataSet, true);
     }
 
+    case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
+        owner->handleChangedDatasetOrVariable(sid);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
     default:
         return CommandMessageIF::UNKNOWN_COMMAND;
     }
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 70711be91..90bbe594a 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -130,12 +130,13 @@ public:
     static void setUpdateSnapshotVariableCommand(CommandMessage* command,
             lp_id_t localPoolId, store_address_t storeId);
 
-    sid_t getUpdateNotificationSetCommand(const CommandMessage* command);
-    lp_id_t getUpdateNotificationVariableCommand(const CommandMessage* command);
+    static sid_t getUpdateNotificationSetCommand(const CommandMessage* command);
+    static lp_id_t getUpdateNotificationVariableCommand(
+            const CommandMessage* command);
 
-    sid_t getUpdateSnapshotSetCommand(const CommandMessage* command,
+    static sid_t getUpdateSnapshotSetCommand(const CommandMessage* command,
             store_address_t* storeId);
-    lp_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command,
+    static lp_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command,
             store_address_t* storeId);
 
     /** Utility */
diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
index fa03a9a38..6a3640699 100644
--- a/ipc/CommandMessageCleaner.cpp
+++ b/ipc/CommandMessageCleaner.cpp
@@ -12,7 +12,7 @@
 
 void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
 	switch(message->getMessageType()){
-	case  messagetypes::MODE_COMMAND:
+	case messagetypes::MODE_COMMAND:
 		ModeMessage::clear(message);
 		break;
 	case messagetypes::HEALTH_COMMAND:
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index 3f41f541f..175af026b 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -249,8 +249,9 @@ void Service3Housekeeping::handleUnrequestedReply(
 	}
 
 	default:
-		sif::error << "Service3Housekeeping::handleReply: Invalid reply with "
-				<< "reply command " << command << "!" << std::endl;
+		sif::error << "Service3Housekeeping::handleUnrequestedReply: Invalid "
+		        << "reply with " << "reply command " << command << "!"
+		        << std::endl;
 		return;
 	}
 

From ab603abada422d906a6cedb9d204ca2fe5e200ad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 20:05:39 +0200
Subject: [PATCH 0909/1774] subscription mechanism almost complete

---
 datapoollocal/HasLocalDataPoolIF.h     | 10 ++++-
 datapoollocal/LocalDataPoolManager.cpp | 51 +++++++++++++++++++++++++-
 storagemanager/storeAddress.h          |  7 +++-
 3 files changed, 64 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index d7950b49c..9d4f2605a 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -96,8 +96,11 @@ public:
      * @details
      * Can be overriden by the child class to handle changed datasets.
      * @param sid
+     * @param storeId If a snapshot was requested, data will be located inside
+     * the IPC store with this store ID.
      */
-    virtual void handleChangedDatasetOrVariable(sid_t sid) {
+    virtual void handleChangedDataset(sid_t sid,
+            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
         return;
     }
 
@@ -107,8 +110,11 @@ public:
      * @details
      * Can be overriden by the child class to handle changed pool IDs.
      * @param sid
+     * @param storeId If a snapshot was requested, data will be located inside
+     * the IPC store with this store ID.
      */
-    virtual void handleChangedPoolVariable(lp_id_t poolId) {
+    virtual void handleChangedPoolVariable(lp_id_t poolId,
+            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
         return;
     }
 
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 848ade5e8..d89f597e4 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -129,6 +129,14 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 }
                 if(poolObj->hasChanged()) {
                     // prepare and send update notification.
+                    CommandMessage notification;
+                    HousekeepingMessage::setUpdateNotificationVariableCommand(
+                            &notification, receiver.dataId.localPoolId);
+                    ReturnValue_t result = hkQueue->sendMessage(
+                            receiver.destinationQueue, &notification);
+                    if(result != HasReturnvaluesIF::RETURN_OK) {
+                        status = result;
+                    }
                     toReset = poolObj;
                 }
 
@@ -169,6 +177,16 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 }
                 if(poolObj->hasChanged()) {
                     // prepare and send update snapshot.
+                    CommandMessage notification;
+                    // todo: serialize into store with timestamp.
+                    store_address_t storeId;
+                    HousekeepingMessage::setUpdateSnapshotSetCommand(
+                            &notification, receiver.dataId.sid, storeId);
+                    ReturnValue_t result = hkQueue->sendMessage(
+                            receiver.destinationQueue, &notification);
+                    if(result != HasReturnvaluesIF::RETURN_OK) {
+                        status = result;
+                    }
                     toReset = poolObj;
                 }
             }
@@ -180,6 +198,16 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 }
                 if(dataSet->hasChanged()) {
                     // prepare and send update snapshot.
+                    CommandMessage notification;
+                    // todo: serialize into store with timestamp.
+                    store_address_t storeId;
+                    HousekeepingMessage::setUpdateSnapshotVariableCommand(
+                            &notification, receiver.dataId.localPoolId, storeId);
+                    ReturnValue_t result = hkQueue->sendMessage(
+                            receiver.destinationQueue, &notification);
+                    if(result != HasReturnvaluesIF::RETURN_OK) {
+                        status = result;
+                    }
                     toReset = dataSet;
                 }
             }
@@ -384,6 +412,7 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     sid_t sid = HousekeepingMessage::getSid(message);
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     switch(command) {
+    // Houskeeping interface handling.
     case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
     	result = togglePeriodicGeneration(sid, true, true);
     	break;
@@ -438,8 +467,28 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     			dataSet, true);
     }
 
+    // Notification handling.
     case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
-        owner->handleChangedDatasetOrVariable(sid);
+        owner->handleChangedDataset(sid);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
+        lp_id_t locPoolId = HousekeepingMessage::
+                getUpdateNotificationVariableCommand(message);
+        owner->handleChangedPoolVariable(locPoolId);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
+        store_address_t storeId;
+        HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
+        owner->handleChangedDataset(sid, storeId);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
+        store_address_t storeId;
+        lp_id_t localPoolId = HousekeepingMessage::
+                getUpdateSnapshotVariableCommand(message, &storeId);
+        owner->handleChangedPoolVariable(localPoolId, storeId);
         return HasReturnvaluesIF::RETURN_OK;
     }
 
diff --git a/storagemanager/storeAddress.h b/storagemanager/storeAddress.h
index 044c07908..994998a66 100644
--- a/storagemanager/storeAddress.h
+++ b/storagemanager/storeAddress.h
@@ -3,16 +3,21 @@
 
 #include <cstdint>
 
+namespace storeId {
+static constexpr uint32_t INVALID_STORE_ADDRESS = 0xffffffff;
+}
+
 /**
  * This union defines the type that identifies where a data packet is
  * stored in the store. It comprises of a raw part to read it as raw value and
  * a structured part to use it in pool-like stores.
  */
 union store_address_t {
+
 	/**
 	 * Default Constructor, initializing to INVALID_ADDRESS
 	 */
-	store_address_t():raw(0xFFFFFFFF){}
+	store_address_t(): raw(storeId::INVALID_STORE_ADDRESS){}
 	/**
 	 * Constructor to create an address object using the raw address
 	 *

From 7bd536e76395a38a3a0cdecba436b7efccdc596e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 23:20:53 +0200
Subject: [PATCH 0910/1774] new templateless pool prototype

---
 events/EventManager.cpp                      |   9 +-
 events/EventManager.h                        |   4 +-
 storagemanager/ConstStorageAccessor.h        |   2 -
 storagemanager/LocalPool.cpp                 | 288 +++++++++++++++++++
 storagemanager/LocalPool.h                   | 167 ++++++-----
 storagemanager/PoolManager.cpp               |  51 ++++
 storagemanager/PoolManager.h                 |  11 +-
 storagemanager/StorageAccessor.h             |   2 -
 storagemanager/{ => archive}/LocalPool.tpp   |   0
 storagemanager/{ => archive}/PoolManager.tpp |   0
 storagemanager/storeAddress.h                |   6 +-
 tmtcpacket/packetmatcher/PacketMatchTree.cpp |  41 ++-
 tmtcpacket/packetmatcher/PacketMatchTree.h   |   3 +-
 13 files changed, 472 insertions(+), 112 deletions(-)
 create mode 100644 storagemanager/LocalPool.cpp
 create mode 100644 storagemanager/PoolManager.cpp
 rename storagemanager/{ => archive}/LocalPool.tpp (100%)
 rename storagemanager/{ => archive}/PoolManager.tpp (100%)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 0971dadc8..289cb0294 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,5 +1,4 @@
 #include "EventManager.h"
-#include "EventMessage.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
@@ -15,9 +14,15 @@ const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
 // SHOULDDO: Shouldn't this be in the config folder and passed via ctor?
 const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
 
+const LocalPool::LocalPoolConfig EventManager::poolConfig = {
+        LocalPool::LocalPoolCfgPair(sizeof(EventMatchTree::Node), 240),
+        LocalPool::LocalPoolCfgPair(sizeof(EventIdRangeMatcher), 120),
+        LocalPool::LocalPoolCfgPair(sizeof(ReporterRangeMatcher), 120)
+};
+
 EventManager::EventManager(object_id_t setObjectId) :
 		SystemObject(setObjectId),
-		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
+		factoryBackend(0, poolConfig, false, true) {
 	mutex = MutexFactory::instance()->createMutex();
 	eventReportQueue = QueueFactory::instance()->createMessageQueue(
 			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
diff --git a/events/EventManager.h b/events/EventManager.h
index f03c02415..fe35d9d3e 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -51,7 +51,9 @@ protected:
 	MutexIF* mutex = nullptr;
 
 	static const uint8_t N_POOLS = 3;
-	LocalPool<N_POOLS> factoryBackend;
+	LocalPool factoryBackend;
+	static const LocalPool::LocalPoolConfig poolConfig;
+
 	static const uint16_t POOL_SIZES[N_POOLS];
 	static const uint16_t N_ELEMENTS[N_POOLS];
 
diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index 96d2dca2c..570c20ce5 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -20,9 +20,7 @@ class StorageManagerIF;
  */
 class ConstStorageAccessor {
 	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
 	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
 	friend class LocalPool;
 public:
 	/**
diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
new file mode 100644
index 000000000..67cdf447a
--- /dev/null
+++ b/storagemanager/LocalPool.cpp
@@ -0,0 +1,288 @@
+#include "LocalPool.h"
+#include <FSFWConfig.h>
+#include <cstring>
+
+LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
+            bool registered, bool spillsToHigherPools):
+            SystemObject(setObjectId), NUMBER_OF_POOLS(poolConfig.size()) {
+    uint16_t index = 0;
+    for (const auto& currentPoolConfig: poolConfig) {
+        this->elementSizes[index] = currentPoolConfig.first;
+        this->numberOfElements[index] = currentPoolConfig.second;
+        store[index] = std::vector<uint8_t>(
+                numberOfElements[index] * elementSizes[index]);
+        sizeLists[index] = std::vector<size_type>(numberOfElements[index]);
+        //TODO checkme
+        for(auto& size: sizeLists[index]) {
+            size = STORAGE_FREE;
+        }
+//        std::memset(sizeLists[index], 0xff,
+//                numberOfElements[index] * sizeof(size_type));
+        index++;
+    }
+}
+
+LocalPool::~LocalPool(void) {}
+
+
+ReturnValue_t LocalPool::addData(store_address_t* storageId,
+        const uint8_t* data, size_t size, bool ignoreFault) {
+    ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+    if (status == RETURN_OK) {
+        write(*storageId, data, size);
+    }
+    return status;
+}
+
+ReturnValue_t LocalPool::getData(store_address_t packetId,
+        const uint8_t **packetPtr, size_t *size) {
+    uint8_t* tempData = nullptr;
+    ReturnValue_t status = modifyData(packetId, &tempData, size);
+    *packetPtr = tempData;
+    return status;
+}
+
+ReturnValue_t LocalPool::getData(store_address_t storeId,
+        ConstStorageAccessor& storeAccessor) {
+    uint8_t* tempData = nullptr;
+    ReturnValue_t status = modifyData(storeId, &tempData,
+            &storeAccessor.size_);
+    storeAccessor.assignStore(this);
+    storeAccessor.constDataPointer = tempData;
+    return status;
+}
+
+ConstAccessorPair LocalPool::getData(store_address_t storeId) {
+    uint8_t* tempData = nullptr;
+    ConstStorageAccessor constAccessor(storeId, this);
+    ReturnValue_t status = modifyData(storeId, &tempData, &constAccessor.size_);
+    constAccessor.constDataPointer = tempData;
+    return ConstAccessorPair(status, std::move(constAccessor));
+}
+
+ReturnValue_t LocalPool::getFreeElement(store_address_t *storageId,
+        const size_t size, uint8_t **pData, bool ignoreFault) {
+    ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+    if (status == RETURN_OK) {
+        *pData = &store[storageId->poolIndex][getRawPosition(*storageId)];
+    }
+    else {
+        *pData = nullptr;
+    }
+    return status;
+}
+
+
+AccessorPair LocalPool::modifyData(store_address_t storeId) {
+    StorageAccessor accessor(storeId, this);
+    ReturnValue_t status = modifyData(storeId, &accessor.dataPointer,
+            &accessor.size_);
+    accessor.assignConstPointer();
+    return AccessorPair(status, std::move(accessor));
+}
+
+ReturnValue_t LocalPool::modifyData(store_address_t storeId,
+        StorageAccessor& storeAccessor) {
+    storeAccessor.assignStore(this);
+    ReturnValue_t status = modifyData(storeId, &storeAccessor.dataPointer,
+            &storeAccessor.size_);
+    storeAccessor.assignConstPointer();
+    return status;
+}
+
+ReturnValue_t LocalPool::modifyData(store_address_t storeId,
+        uint8_t **packetPtr, size_t *size) {
+    ReturnValue_t status = RETURN_FAILED;
+    if (storeId.poolIndex >= NUMBER_OF_POOLS) {
+        return ILLEGAL_STORAGE_ID;
+    }
+    if ((storeId.packetIndex >= numberOfElements[storeId.poolIndex])) {
+        return ILLEGAL_STORAGE_ID;
+    }
+
+    if (sizeLists[storeId.poolIndex][storeId.packetIndex]
+            != STORAGE_FREE) {
+        uint32_t packetPosition = getRawPosition(storeId);
+        *packetPtr = &store[storeId.poolIndex][packetPosition];
+        *size = sizeLists[storeId.poolIndex][storeId.packetIndex];
+        status = RETURN_OK;
+    }
+    else {
+        status = DATA_DOES_NOT_EXIST;
+    }
+    return status;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
+#if FSFW_DEBUGGING == 1
+      sif::debug << "Delete: Pool: " << std::dec << storeId.poolIndex
+              << " Index: " << storeId.packetIndex << std::endl;
+
+#endif
+    ReturnValue_t status = RETURN_OK;
+    size_type pageSize = getPageSize(storeId.poolIndex);
+    if ((pageSize != 0) and
+            (storeId.packetIndex < numberOfElements[storeId.poolIndex])) {
+        uint16_t packetPosition = getRawPosition(storeId);
+        uint8_t* ptr = &store[storeId.poolIndex][packetPosition];
+        std::memset(ptr, 0, pageSize);
+        //Set free list
+        sizeLists[storeId.poolIndex][storeId.packetIndex] = STORAGE_FREE;
+    }
+    else {
+        //pool_index or packet_index is too large
+        sif::error << "LocalPool:deleteData failed." << std::endl;
+        status = ILLEGAL_STORAGE_ID;
+    }
+    return status;
+}
+
+ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
+        store_address_t *storeId) {
+    store_address_t localId;
+    ReturnValue_t result = ILLEGAL_ADDRESS;
+    for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+        //Not sure if new allocates all stores in order. so better be careful.
+        if ((store[n].data() <= ptr) && (&store[n][numberOfElements[n]*elementSizes[n]]) > ptr) {
+            localId.poolIndex = n;
+            uint32_t deltaAddress = ptr - store[n].data();
+            // Getting any data from the right "block" is ok.
+            // This is necessary, as IF's sometimes don't point to the first
+            // element of an object.
+            localId.packetIndex = deltaAddress / elementSizes[n];
+            result = deleteData(localId);
+#if FSFW_DEBUGGING == 1
+            if (deltaAddress % elementSizes[n] != 0) {
+                sif::error << "LocalPool::deleteData: Address not aligned!"
+                        << std::endl;
+            }
+#endif
+            break;
+        }
+    }
+    if (storeId != nullptr) {
+        *storeId = localId;
+    }
+    return result;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+
+ReturnValue_t LocalPool::initialize() {
+    ReturnValue_t result = SystemObject::initialize();
+    if (result != RETURN_OK) {
+        return result;
+    }
+    internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+            objects::INTERNAL_ERROR_REPORTER);
+    if (internalErrorReporter == nullptr){
+        return ObjectManagerIF::INTERNAL_ERR_REPORTER_UNINIT;
+    }
+
+    //Check if any pool size is large than the maximum allowed.
+    for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
+        if (elementSizes[count] >= STORAGE_FREE) {
+            sif::error << "LocalPool::initialize: Pool is too large! "
+                    "Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
+            return StorageManagerIF::POOL_TOO_LARGE;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void LocalPool::clearStore() {
+    for(auto& sizeList: sizeLists) {
+        for(auto& size: sizeList) {
+            size = STORAGE_FREE;
+        }
+//        std::memset(sizeList[index], 0xff,
+//                numberOfElements[index] * sizeof(size_type));
+    }
+
+}
+
+ReturnValue_t LocalPool::reserveSpace(const size_t size,
+        store_address_t *storeId, bool ignoreFault) {
+    ReturnValue_t status = getPoolIndex(size, &storeId->poolIndex);
+    if (status != RETURN_OK) {
+        sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
+                << " )::reserveSpace: Packet too large." << std::endl;
+        return status;
+    }
+    status = findEmpty(storeId->poolIndex, &storeId->packetIndex);
+    while (status != RETURN_OK && spillsToHigherPools) {
+        status = getPoolIndex(size, &storeId->poolIndex, storeId->poolIndex + 1);
+        if (status != RETURN_OK) {
+            //We don't find any fitting pool anymore.
+            break;
+        }
+        status = findEmpty(storeId->poolIndex, &storeId->packetIndex);
+    }
+    if (status == RETURN_OK) {
+#if FSFW_DEBUGGING == 1
+        sif::debug << "Reserve: Pool: " << std::dec
+                << storeId->poolIndex << " Index: " << storeId->packetIndex
+                << std::endl;
+#endif
+        sizeLists[storeId->poolIndex][storeId->packetIndex] = size;
+    }
+    else {
+        if ((not ignoreFault) and (internalErrorReporter != nullptr)) {
+            internalErrorReporter->storeFull();
+        }
+    }
+    return status;
+}
+
+void LocalPool::write(store_address_t storeId, const uint8_t *data,
+        size_t size) {
+    uint8_t* ptr = nullptr;
+    size_type packetPosition = getRawPosition(storeId);
+
+    // Size was checked before calling this function.
+    ptr = &store[storeId.poolIndex][packetPosition];
+    std::memcpy(ptr, data, size);
+    sizeLists[storeId.poolIndex][storeId.packetIndex] = size;
+}
+LocalPool::size_type LocalPool::getPageSize(uint16_t poolIndex) {
+    if (poolIndex < NUMBER_OF_POOLS) {
+        return elementSizes[poolIndex];
+    }
+    else {
+        return 0;
+    }
+}
+
+ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
+        uint16_t startAtIndex) {
+    for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
+#if FSFW_DEBUGGING == 1
+        sif::debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: "
+             << n << ", Element Size: " << elementSizes[n] << std::endl;
+#endif
+        if (elementSizes[n] >= packetSize) {
+            *poolIndex = n;
+            return RETURN_OK;
+        }
+    }
+    return DATA_TOO_LARGE;
+}
+
+LocalPool::size_type LocalPool::getRawPosition(store_address_t storeId) {
+    return storeId.packetIndex * elementSizes[storeId.poolIndex];
+}
+
+ReturnValue_t LocalPool::findEmpty(uint16_t poolIndex, uint16_t *element) {
+    ReturnValue_t status = DATA_STORAGE_FULL;
+    for (uint16_t foundElement = 0; foundElement < numberOfElements[poolIndex];
+            foundElement++) {
+        if (sizeLists[poolIndex][foundElement] == STORAGE_FREE) {
+            *element = foundElement;
+            status = RETURN_OK;
+            break;
+        }
+    }
+    return status;
+}
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 3a94c03db..f4318212a 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -7,57 +7,61 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../internalError/InternalErrorReporterIF.h"
 #include "../storagemanager/StorageAccessor.h"
-#include <cstring>
 
+#include <vector>
+#include <set>
+#include <utility>
+#include <limits>
 
 /**
- * @brief	The LocalPool class provides an intermediate data storage with
- * 			a fixed pool size policy.
- * @details	The class implements the StorageManagerIF interface. While the
- * 			total number of pools is fixed, the element sizes in one pool and
- * 			the number of pool elements per pool are set on construction.
- * 			The full amount of memory is allocated on construction.
- * 			The overhead is 4 byte per pool element to store the size
- * 			information of each stored element.
- * 			To maintain an "empty" information, the pool size is limited to
- * 			0xFFFF-1 bytes.
- * 			It is possible to store empty packets in the pool.
- * 			The local pool is NOT thread-safe.
- * @author 	Bastian Baetz
+ * @brief   The LocalPool class provides an intermediate data storage with
+ *          a fixed pool size policy.
+ * @details The class implements the StorageManagerIF interface. While the
+ *          total number of pools is fixed, the element sizes in one pool and
+ *          the number of pool elements per pool are set on construction.
+ *          The full amount of memory is allocated on construction.
+ *          The overhead is 4 byte per pool element to store the size
+ *          information of each stored element.
+ *          To maintain an "empty" information, the pool size is limited to
+ *          0xFFFF-1 bytes.
+ *          It is possible to store empty packets in the pool.
+ *          The local pool is NOT thread-safe.
  */
-template<uint8_t NUMBER_OF_POOLS = 5>
 class LocalPool: public SystemObject, public StorageManagerIF {
 public:
-	/**
-	 * @brief	This definition generally sets the number of different sized pools.
-	 * @details This must be less than the maximum number of pools (currently 0xff).
-	 */
-	//	static const uint32_t NUMBER_OF_POOLS;
-	/**
-	 * @brief	This is the default constructor for a pool manager instance.
-	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
-	 * 			allocates memory (with @c new) for store and size_list. These
-	 * 			regions are all set to zero on start up.
-	 * @param setObjectId	The object identifier to be set. This allows for
-	 * 						multiple instances of LocalPool in the system.
-	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
-	 * 						of a single element in each pool is determined.
-	 * 						<b>The sizes must be provided in ascending order.
-	 * 						</b>
-	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
-	 * 						number of elements for each pool is determined.
-	 * 						The position of these values correspond to those in
-	 * 						element_sizes.
-	 * @param registered	Register the pool in object manager or not.
-	 * Default is false (local pool).
-	 * @param spillsToHigherPools A variable to determine whether
-	 * higher n pools are used if the store is full.
-	 */
-	LocalPool(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS],
-			bool registered = false,
-			bool spillsToHigherPools = false);
+    using size_type = size_t;
+
+    using poolElementSize = size_type;
+    using numberPoolElements = uint16_t;
+    using LocalPoolCfgPair = std::pair<poolElementSize, numberPoolElements>;
+    using LocalPoolConfig = std::multiset<LocalPoolCfgPair>;
+    /**
+     * @brief   This definition generally sets the number of different sized pools.
+     * @details This must be less than the maximum number of pools (currently 0xff).
+     */
+    const uint8_t NUMBER_OF_POOLS;
+    /**
+     * @brief   This is the default constructor for a pool manager instance.
+     * @details By passing two arrays of size NUMBER_OF_POOLS, the constructor
+     *          allocates memory (with @c new) for store and size_list. These
+     *          regions are all set to zero on start up.
+     * @param setObjectId   The object identifier to be set. This allows for
+     *                      multiple instances of LocalPool in the system.
+     * @param element_sizes An array of size NUMBER_OF_POOLS in which the size
+     *                      of a single element in each pool is determined.
+     *                      <b>The sizes must be provided in ascending order.
+     *                      </b>
+     * @param n_elements    An array of size NUMBER_OF_POOLS in which the
+     *                      number of elements for each pool is determined.
+     *                      The position of these values correspond to those in
+     *                      element_sizes.
+     * @param registered    Register the pool in object manager or not.
+     * Default is false (local pool).
+     * @param spillsToHigherPools A variable to determine whether
+     * higher n pools are used if the store is full.
+     */
+    LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
+            bool registered = false, bool spillsToHigherPools = false);
 	/**
 	 * @brief	In the LocalPool's destructor all allocated memory is freed.
 	 */
@@ -66,24 +70,26 @@ public:
 	/**
 	 * Documentation: See StorageManagerIF.h
 	 */
-	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
+	ReturnValue_t addData(store_address_t* storeId, const uint8_t * data,
 			size_t size, bool ignoreFault = false) override;
-	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
-			uint8_t** p_data, bool ignoreFault = false) override;
+	ReturnValue_t getFreeElement(store_address_t* storeId,const size_t size,
+			uint8_t** pData, bool ignoreFault = false) override;
 
-	ConstAccessorPair getData(store_address_t packet_id) override;
-	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
-	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
+	ConstAccessorPair getData(store_address_t storeId) override;
+	ReturnValue_t getData(store_address_t storeId,
+	        ConstStorageAccessor& constAccessor) override;
+	ReturnValue_t getData(store_address_t storeId,
+	        const uint8_t** packet_ptr, size_t * size) override;
+
+	AccessorPair modifyData(store_address_t storeId) override;
+	ReturnValue_t modifyData(store_address_t storeId,
+	        StorageAccessor& storeAccessor) override;
+	ReturnValue_t modifyData(store_address_t storeId, uint8_t** packet_ptr,
 			size_t * size) override;
 
-	AccessorPair modifyData(store_address_t packet_id) override;
-	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
-	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			size_t * size) override;
-
-	virtual ReturnValue_t deleteData(store_address_t) override;
+	virtual ReturnValue_t deleteData(store_address_t storeId) override;
 	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
-			store_address_t* storeId = NULL) override;
+			store_address_t* storeId = nullptr) override;
 	void clearStore() override;
 	ReturnValue_t initialize() override;
 protected:
@@ -94,43 +100,48 @@ protected:
 	 * @return	- #RETURN_OK on success,
 	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
 	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size,
+	virtual ReturnValue_t reserveSpace(const size_t size,
 			store_address_t* address, bool ignoreFault);
 
-	InternalErrorReporterIF *internalErrorReporter;
 private:
-	/**
-	 * Indicates that this element is free.
-	 * This value limits the maximum size of a pool. Change to larger data type
-	 * if increase is required.
-	 */
-	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
+    /**
+     * Indicates that this element is free.
+     * This value limits the maximum size of a pool.
+     * Change to larger data type if increase is required.
+     */
+    static const size_type STORAGE_FREE = std::numeric_limits<size_type>::max();
 	/**
 	 * @brief	In this array, the element sizes of each pool is stored.
 	 * @details	The sizes are maintained for internal pool management. The sizes
 	 * 			must be set in ascending order on construction.
 	 */
-	uint32_t element_sizes[NUMBER_OF_POOLS];
+    std::vector<size_type> elementSizes =
+            std::vector<size_type>(NUMBER_OF_POOLS);
 	/**
 	 * @brief	n_elements stores the number of elements per pool.
 	 * @details	These numbers are maintained for internal pool management.
 	 */
-	uint16_t n_elements[NUMBER_OF_POOLS];
+	std::vector<uint16_t> numberOfElements =
+	        std::vector<uint16_t>(NUMBER_OF_POOLS);
 	/**
 	 * @brief	store represents the actual memory pool.
 	 * @details	It is an array of pointers to memory, which was allocated with
 	 * 			a @c new call on construction.
 	 */
-	uint8_t* store[NUMBER_OF_POOLS];
+	std::vector<std::vector<uint8_t>> store =
+	        std::vector<std::vector<uint8_t>>(NUMBER_OF_POOLS);
+
 	/**
 	 * @brief	The size_list attribute stores the size values of every pool element.
 	 * @details	As the number of elements is determined on construction, the size list
 	 * 			is also dynamically allocated there.
 	 */
-	uint32_t* size_list[NUMBER_OF_POOLS];
+	std::vector<std::vector<size_type>> sizeLists =
+	        std::vector<std::vector<size_type>>(NUMBER_OF_POOLS);
+
 	//! A variable to determine whether higher n pools are used if
 	//! the store is full.
-	bool spillsToHigherPools;
+	bool spillsToHigherPools = false;
 	/**
 	 * @brief	This method safely stores the given data in the given packet_id.
 	 * @details	It also sets the size in size_list. The method does not perform
@@ -139,13 +150,13 @@ private:
 	 * @param data		The data to be stored.
 	 * @param size		The size of the data to be stored.
 	 */
-	void write(store_address_t packet_id, const uint8_t* data, size_t size);
+	void write(store_address_t packetId, const uint8_t* data, size_t size);
 	/**
 	 * @brief	A helper method to read the element size of a certain pool.
 	 * @param pool_index	The pool in which to look.
 	 * @return	Returns the size of an element or 0.
 	 */
-	uint32_t getPageSize(uint16_t pool_index);
+	size_type getPageSize(uint16_t poolIndex);
 	/**
 	 * @brief	This helper method looks up a fitting pool for a given size.
 	 * @details	The pools are looked up in ascending order, so the first that
@@ -162,7 +173,7 @@ private:
 	 * @return	- #RETURN_OK on success,
 	 * 			- #DATA_TOO_LARGE otherwise.
 	 */
-	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
+	ReturnValue_t getPoolIndex(size_t packetSize, uint16_t* poolIndex,
 			uint16_t startAtIndex = 0);
 	/**
 	 * @brief	This helper method calculates the true array position in store
@@ -172,7 +183,7 @@ private:
 	 * @param packet_id	The packet id to look up.
 	 * @return	Returns the position of the data in store.
 	 */
-	uint32_t getRawPosition(store_address_t packet_id);
+	size_type getRawPosition(store_address_t storeId);
 	/**
 	 * @brief	This is a helper method to find an empty element in a given pool.
 	 * @details	The method searches size_list for the first empty element, so
@@ -182,9 +193,9 @@ private:
 	 * @return	- #RETURN_OK on success,
 	 * 			- #DATA_STORAGE_FULL if the store is full
 	 */
-	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
+	ReturnValue_t findEmpty(uint16_t poolIndex, uint16_t* element);
+
+    InternalErrorReporterIF *internalErrorReporter = nullptr;
 };
 
-#include "LocalPool.tpp"
-
 #endif /* FSFW_STORAGEMANAGER_LOCALPOOL_H_ */
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
new file mode 100644
index 000000000..e7a7d9cff
--- /dev/null
+++ b/storagemanager/PoolManager.cpp
@@ -0,0 +1,51 @@
+#include "PoolManager.h"
+#include <FSFWConfig.h>
+
+PoolManager::PoolManager(object_id_t setObjectId,
+        const LocalPoolConfig localPoolConfig):
+        LocalPool(setObjectId, localPoolConfig, true) {
+    mutex = MutexFactory::instance()->createMutex();
+}
+
+
+PoolManager::~PoolManager(void) {
+    MutexFactory::instance()->deleteMutex(mutex);
+}
+
+
+ReturnValue_t PoolManager::reserveSpace(const size_t size,
+        store_address_t* address, bool ignoreFault) {
+    MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+            mutexTimeoutMs);
+    ReturnValue_t status = LocalPool::reserveSpace(size,
+            address,ignoreFault);
+    return status;
+}
+
+
+ReturnValue_t PoolManager::deleteData(
+        store_address_t storeId) {
+#if FSFW_DEBUGGING == 1
+     sif::debug << "PoolManager( " << translateObject(getObjectId()) <<
+           " )::deleteData from store " << storeId.poolIndex <<
+           ". id is "<< storeId.packetIndex << std::endl;
+#endif
+    MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+            mutexTimeoutMs);
+    return LocalPool::deleteData(storeId);
+}
+
+
+ReturnValue_t PoolManager::deleteData(uint8_t* buffer,
+        size_t size, store_address_t* storeId) {
+    MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    ReturnValue_t status = LocalPool::deleteData(buffer,
+            size, storeId);
+    return status;
+}
+
+
+void PoolManager::setMutexTimeout(
+        uint32_t mutexTimeoutMs) {
+    this->mutexTimeoutMs = mutexTimeoutMs;
+}
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 8cc6c0654..b1781b9be 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -13,12 +13,9 @@
  * 			with a lock.
  * @author 	Bastian Baetz
  */
-template <uint8_t NUMBER_OF_POOLS = 5>
-class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
+class PoolManager: public LocalPool {
 public:
-	PoolManager(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS]);
+	PoolManager(object_id_t setObjectId, const LocalPoolConfig poolConfig);
 
 	/**
 	 * @brief	In the PoolManager's destructor all allocated memory
@@ -39,7 +36,7 @@ protected:
 	//! Default mutex timeout value to prevent permanent blocking.
 	uint32_t mutexTimeoutMs = 20;
 
-	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
+	ReturnValue_t reserveSpace(const size_t size, store_address_t* address,
 			bool ignoreFault) override;
 
 	/**
@@ -51,6 +48,4 @@ protected:
 	MutexIF* mutex;
 };
 
-#include "PoolManager.tpp"
-
 #endif /* FSFW_STORAGEMANAGER_POOLMANAGER_H_ */
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 5cf15d509..d5b383eb6 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -10,9 +10,7 @@ class StorageManagerIF;
  */
 class StorageAccessor: public ConstStorageAccessor {
 	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
 	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
 	friend class LocalPool;
 public:
 	StorageAccessor(store_address_t storeId);
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/archive/LocalPool.tpp
similarity index 100%
rename from storagemanager/LocalPool.tpp
rename to storagemanager/archive/LocalPool.tpp
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/archive/PoolManager.tpp
similarity index 100%
rename from storagemanager/PoolManager.tpp
rename to storagemanager/archive/PoolManager.tpp
diff --git a/storagemanager/storeAddress.h b/storagemanager/storeAddress.h
index 994998a66..ea72f6f89 100644
--- a/storagemanager/storeAddress.h
+++ b/storagemanager/storeAddress.h
@@ -33,7 +33,7 @@ union store_address_t {
 	 * @param packetIndex
 	 */
 	store_address_t(uint16_t poolIndex, uint16_t packetIndex):
-		pool_index(poolIndex),packet_index(packetIndex){}
+		poolIndex(poolIndex), packetIndex(packetIndex){}
 	/**
 	 * A structure with two elements to access the store address pool-like.
 	 */
@@ -41,11 +41,11 @@ union store_address_t {
 		/**
 		 * The index in which pool the packet lies.
 		 */
-		uint16_t pool_index;
+		uint16_t poolIndex;
 		/**
 		 * The position in the chosen pool.
 		 */
-		uint16_t packet_index;
+		uint16_t packetIndex;
 	};
 	/**
 	 * Alternative access to the raw value.
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.cpp b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
index 610829e5f..80ec67e68 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.cpp
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
@@ -1,21 +1,37 @@
-#include "../../tmtcpacket/packetmatcher/ApidMatcher.h"
-#include "../../tmtcpacket/packetmatcher/PacketMatchTree.h"
-#include "../../tmtcpacket/packetmatcher/ServiceMatcher.h"
-#include "../../tmtcpacket/packetmatcher/SubserviceMatcher.h"
+#include "ApidMatcher.h"
+#include "PacketMatchTree.h"
+#include "ServiceMatcher.h"
+#include "SubserviceMatcher.h"
+
+const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
+        sizeof(SubServiceMatcher), sizeof(ApidMatcher),
+        sizeof(PacketMatchTree::Node) };
+//Maximum number of types and subtypes to filter should be more than sufficient.
+const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
+
+const LocalPool::LocalPoolConfig PacketMatchTree::poolConfig = {
+        LocalPool::LocalPoolCfgPair(sizeof(ServiceMatcher), 10),
+        LocalPool::LocalPoolCfgPair(sizeof(SubServiceMatcher), 20),
+        LocalPool::LocalPoolCfgPair(sizeof(ApidMatcher), 2),
+        LocalPool::LocalPoolCfgPair(sizeof(PacketMatchTree::Node), 40)
+};
 
 PacketMatchTree::PacketMatchTree(Node* root) :
-		MatchTree<TmPacketMinimal*>(root, 2), factoryBackend(0, POOL_SIZES,
-				N_ELEMENTS, false, true), factory(&factoryBackend) {
+		MatchTree<TmPacketMinimal*>(root, 2),
+		factoryBackend(0, poolConfig, false, true),
+		factory(&factoryBackend) {
 }
 
 PacketMatchTree::PacketMatchTree(iterator root) :
-		MatchTree<TmPacketMinimal*>(root.element, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+		MatchTree<TmPacketMinimal*>(root.element, 2),
+		factoryBackend(0, poolConfig, false, true),
+		factory(&factoryBackend) {
 }
 
 PacketMatchTree::PacketMatchTree() :
-		MatchTree<TmPacketMinimal*>((Node*) NULL, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+		MatchTree<TmPacketMinimal*>((Node*) NULL, 2),
+		factoryBackend(0, poolConfig, false, true),
+		factory(&factoryBackend) {
 }
 
 PacketMatchTree::~PacketMatchTree() {
@@ -172,11 +188,6 @@ ReturnValue_t PacketMatchTree::initialize() {
 	return factoryBackend.initialize();
 }
 
-const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
-		sizeof(SubServiceMatcher), sizeof(ApidMatcher),
-		sizeof(PacketMatchTree::Node) };
-//Maximum number of types and subtypes to filter should be more than sufficient.
-const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
 
 ReturnValue_t PacketMatchTree::changeMatch(bool addToMatch, uint16_t apid,
 		uint8_t type, uint8_t subtype) {
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.h b/tmtcpacket/packetmatcher/PacketMatchTree.h
index 86fb087ed..54fc856c7 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.h
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.h
@@ -23,8 +23,9 @@ protected:
 	ReturnValue_t cleanUpElement(iterator position);
 private:
 	static const uint8_t N_POOLS = 4;
-	LocalPool<N_POOLS> factoryBackend;
+	LocalPool factoryBackend;
 	PlacementFactory factory;
+	static const LocalPool::LocalPoolConfig poolConfig;
 	static const uint16_t POOL_SIZES[N_POOLS];
 	static const uint16_t N_ELEMENTS[N_POOLS];
 	template<typename VALUE_T, typename INSERTION_T>

From 57c9775d7d9863072aa9d06e782c10184185bce3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 23:41:16 +0200
Subject: [PATCH 0911/1774] add fill count func added

---
 storagemanager/LocalPool.cpp      | 13 ++++++
 storagemanager/LocalPool.h        | 66 ++++++++++++++++++++-----------
 storagemanager/StorageManagerIF.h | 10 +++++
 3 files changed, 66 insertions(+), 23 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 67cdf447a..86b678063 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -286,3 +286,16 @@ ReturnValue_t LocalPool::findEmpty(uint16_t poolIndex, uint16_t *element) {
     }
     return status;
 }
+
+size_t LocalPool::getTotalSize(size_t* additionalSize) {
+    size_t totalSize = 0;
+    size_t sizesSize = 0;
+    for(uint8_t idx = 0; idx < NUMBER_OF_POOLS; idx ++) {
+        totalSize += elementSizes[idx] * numberOfElements[idx];
+        sizesSize += numberOfElements[idx] * sizeof(size_type);
+    }
+    if(additionalSize != nullptr) {
+        *additionalSize = sizesSize;
+    }
+    return totalSize;
+}
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index f4318212a..a3ccd3a39 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -16,16 +16,16 @@
 /**
  * @brief   The LocalPool class provides an intermediate data storage with
  *          a fixed pool size policy.
- * @details The class implements the StorageManagerIF interface. While the
- *          total number of pools is fixed, the element sizes in one pool and
- *          the number of pool elements per pool are set on construction.
- *          The full amount of memory is allocated on construction.
- *          The overhead is 4 byte per pool element to store the size
- *          information of each stored element.
- *          To maintain an "empty" information, the pool size is limited to
- *          0xFFFF-1 bytes.
- *          It is possible to store empty packets in the pool.
- *          The local pool is NOT thread-safe.
+ * @details
+ * The class implements the StorageManagerIF interface. While the total number
+ * of pools is fixed, the element sizes in one pool and the number of pool
+ * elements per pool are set on construction. The full amount of memory is
+ * allocated on construction.
+ * The overhead is 4 byte per pool element to store the size information of
+ * each stored element. To maintain an "empty" information, the pool size is
+ * limited to 0xFFFF-1 bytes.
+ * It is possible to store empty packets in the pool.
+ * The local pool is NOT thread-safe.
  */
 class LocalPool: public SystemObject, public StorageManagerIF {
 public:
@@ -42,21 +42,21 @@ public:
     const uint8_t NUMBER_OF_POOLS;
     /**
      * @brief   This is the default constructor for a pool manager instance.
-     * @details By passing two arrays of size NUMBER_OF_POOLS, the constructor
-     *          allocates memory (with @c new) for store and size_list. These
-     *          regions are all set to zero on start up.
+     * @details
+     * The pool is configured by passing a set of pairs into the constructor.
+     * The first value of that pair determines the number of one element on
+     * the respective page of the pool while the second value determines how
+     * many elements with that size are created on that page.
+     * All regions are to zero on start up.
      * @param setObjectId   The object identifier to be set. This allows for
      *                      multiple instances of LocalPool in the system.
-     * @param element_sizes An array of size NUMBER_OF_POOLS in which the size
-     *                      of a single element in each pool is determined.
-     *                      <b>The sizes must be provided in ascending order.
-     *                      </b>
-     * @param n_elements    An array of size NUMBER_OF_POOLS in which the
-     *                      number of elements for each pool is determined.
-     *                      The position of these values correspond to those in
-     *                      element_sizes.
-     * @param registered    Register the pool in object manager or not.
-     * Default is false (local pool).
+     * @param poolConfig
+     * This is a set of pairs to configure the number of pages in the pool,
+     * the size of an element on a page, the number of elements on a page
+     * and the total size of the pool at once while also implicitely
+     * sorting the pairs in the right order.
+     * @param registered
+     * Determines whether the pool is registered in the object manager or not.
      * @param spillsToHigherPools A variable to determine whether
      * higher n pools are used if the store is full.
      */
@@ -90,6 +90,26 @@ public:
 	virtual ReturnValue_t deleteData(store_address_t storeId) override;
 	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
 			store_address_t* storeId = nullptr) override;
+
+	/**
+	 * Get the total size of allocated memory for pool data.
+	 * There is an additional overhead of the sizes of elements which will
+	 * be assigned to additionalSize
+	 * @return
+	 */
+	size_t getTotalSize(size_t* additionalSize) override;
+
+	/**
+	 * Get the fill count of the pool. Each character inside the provided
+	 * buffer will be assigned to a rounded percentage fill count for each
+	 * page. The last written byte (at the index number of pools + 1)
+	 * will contain the total fill count of the pool as a mean of the
+	 * percentages.
+	 * @param buffer
+	 * @param maxSize
+	 */
+	void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) override;
+
 	void clearStore() override;
 	ReturnValue_t initialize() override;
 protected:
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 834e75637..d22ed6612 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -164,6 +164,16 @@ public:
 	 * Use with care!
 	 */
 	virtual void clearStore() = 0;
+
+	/**
+	 * Get the fill count of the pool. The exact form will be implementation
+	 * dependant.
+	 * @param buffer
+	 * @param bytesWritten
+	 */
+	virtual void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) = 0;
+
+	virtual size_t getTotalSize(size_t* additionalSize) = 0;
 };
 
 #endif /* FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_ */

From b3e5946291a7c6a5365c79b68e3ea52aa3aca497 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 23:42:49 +0200
Subject: [PATCH 0912/1774] implementation added

---
 storagemanager/LocalPool.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 86b678063..90975a912 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -299,3 +299,6 @@ size_t LocalPool::getTotalSize(size_t* additionalSize) {
     }
     return totalSize;
 }
+
+void LocalPool::getFillCount(uint8_t *buffer, uint8_t *bytesWritten) {
+}

From bdfea9ea38331a5c36f72100834d0fb524100b4b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 23:53:50 +0200
Subject: [PATCH 0913/1774] includes reordered

---
 tmtcservices/CommandingServiceBase.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 9f1d4c4f9..3611d7c62 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -1,13 +1,13 @@
 #ifndef FSFW_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
 #define FSFW_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
 
+#include "AcceptsTelecommandsIF.h"
+#include "VerificationReporter.h"
+
 #include "../objectmanager/SystemObject.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
-#include "AcceptsTelecommandsIF.h"
-
-#include "VerificationReporter.h"
 #include "../ipc/CommandMessage.h"
 #include "../container/FixedMap.h"
 #include "../container/FIFO.h"

From d1498366122e861703ee808fdf10eae4560d802b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 00:34:20 +0200
Subject: [PATCH 0914/1774] better  form

---
 events/EventManager.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 289cb0294..3988210fb 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -15,9 +15,9 @@ const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
 const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
 
 const LocalPool::LocalPoolConfig EventManager::poolConfig = {
-        LocalPool::LocalPoolCfgPair(sizeof(EventMatchTree::Node), 240),
-        LocalPool::LocalPoolCfgPair(sizeof(EventIdRangeMatcher), 120),
-        LocalPool::LocalPoolCfgPair(sizeof(ReporterRangeMatcher), 120)
+        {sizeof(EventMatchTree::Node), 240},
+        {sizeof(EventIdRangeMatcher), 120},
+        {sizeof(ReporterRangeMatcher), 120}
 };
 
 EventManager::EventManager(object_id_t setObjectId) :

From 64bed475fe8976c7d84a82540b2b7e0dfa915561 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 00:43:23 +0200
Subject: [PATCH 0915/1774] important bugfix

---
 storagemanager/LocalPool.cpp | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 90975a912..f61ef2b83 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -3,23 +3,23 @@
 #include <cstring>
 
 LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
-            bool registered, bool spillsToHigherPools):
-            SystemObject(setObjectId), NUMBER_OF_POOLS(poolConfig.size()) {
-    uint16_t index = 0;
-    for (const auto& currentPoolConfig: poolConfig) {
-        this->elementSizes[index] = currentPoolConfig.first;
-        this->numberOfElements[index] = currentPoolConfig.second;
-        store[index] = std::vector<uint8_t>(
-                numberOfElements[index] * elementSizes[index]);
-        sizeLists[index] = std::vector<size_type>(numberOfElements[index]);
-        //TODO checkme
-        for(auto& size: sizeLists[index]) {
-            size = STORAGE_FREE;
-        }
-//        std::memset(sizeLists[index], 0xff,
-//                numberOfElements[index] * sizeof(size_type));
-        index++;
-    }
+		bool registered, bool spillsToHigherPools):
+		SystemObject(setObjectId, registered),
+		NUMBER_OF_POOLS(poolConfig.size()),
+		spillsToHigherPools(spillsToHigherPools) {
+	uint16_t index = 0;
+	for (const auto& currentPoolConfig: poolConfig) {
+		this->elementSizes[index] = currentPoolConfig.first;
+		this->numberOfElements[index] = currentPoolConfig.second;
+		store[index] = std::vector<uint8_t>(
+				numberOfElements[index] * elementSizes[index]);
+		sizeLists[index] = std::vector<size_type>(numberOfElements[index]);
+		//TODO checkme
+		for(auto& size: sizeLists[index]) {
+			size = STORAGE_FREE;
+		}
+		index++;
+	}
 }
 
 LocalPool::~LocalPool(void) {}

From 1ee01ffcdb3a8e65a6f6e227aada9a109ec8680b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 00:54:00 +0200
Subject: [PATCH 0916/1774] important bugfixes

---
 events/EventManager.cpp                      | 13 ++++---------
 storagemanager/LocalPool.cpp                 |  4 ++--
 storagemanager/LocalPool.h                   |  4 ++--
 tmtcpacket/packetmatcher/PacketMatchTree.cpp | 15 +++++----------
 4 files changed, 13 insertions(+), 23 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 3988210fb..57bda13fb 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -4,20 +4,15 @@
 #include "../ipc/MutexFactory.h"
 
 
-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.
-// SHOULDDO: Shouldn't this be in the config folder and passed via ctor?
-const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
-
+// This should be configurable..
 const LocalPool::LocalPoolConfig EventManager::poolConfig = {
-        {sizeof(EventMatchTree::Node), 240},
-        {sizeof(EventIdRangeMatcher), 120},
-        {sizeof(ReporterRangeMatcher), 120}
+        {240, sizeof(EventMatchTree::Node)},
+        {120, sizeof(EventIdRangeMatcher)},
+        {120, sizeof(ReporterRangeMatcher)}
 };
 
 EventManager::EventManager(object_id_t setObjectId) :
diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index f61ef2b83..4a6f332c2 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -9,8 +9,8 @@ LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
 		spillsToHigherPools(spillsToHigherPools) {
 	uint16_t index = 0;
 	for (const auto& currentPoolConfig: poolConfig) {
-		this->elementSizes[index] = currentPoolConfig.first;
-		this->numberOfElements[index] = currentPoolConfig.second;
+		this->numberOfElements[index] = currentPoolConfig.first;
+		this->elementSizes[index] = currentPoolConfig.second;
 		store[index] = std::vector<uint8_t>(
 				numberOfElements[index] * elementSizes[index]);
 		sizeLists[index] = std::vector<size_type>(numberOfElements[index]);
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index a3ccd3a39..494e2cbb7 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -33,7 +33,7 @@ public:
 
     using poolElementSize = size_type;
     using numberPoolElements = uint16_t;
-    using LocalPoolCfgPair = std::pair<poolElementSize, numberPoolElements>;
+    using LocalPoolCfgPair = std::pair<numberPoolElements, poolElementSize>;
     using LocalPoolConfig = std::multiset<LocalPoolCfgPair>;
     /**
      * @brief   This definition generally sets the number of different sized pools.
@@ -44,7 +44,7 @@ public:
      * @brief   This is the default constructor for a pool manager instance.
      * @details
      * The pool is configured by passing a set of pairs into the constructor.
-     * The first value of that pair determines the number of one element on
+     * The first value of that pair determines the number of one elements on
      * the respective page of the pool while the second value determines how
      * many elements with that size are created on that page.
      * All regions are to zero on start up.
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.cpp b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
index 80ec67e68..ac72b3e77 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.cpp
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
@@ -3,17 +3,12 @@
 #include "ServiceMatcher.h"
 #include "SubserviceMatcher.h"
 
-const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
-        sizeof(SubServiceMatcher), sizeof(ApidMatcher),
-        sizeof(PacketMatchTree::Node) };
-//Maximum number of types and subtypes to filter should be more than sufficient.
-const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
-
+// This should be configurable..
 const LocalPool::LocalPoolConfig PacketMatchTree::poolConfig = {
-        LocalPool::LocalPoolCfgPair(sizeof(ServiceMatcher), 10),
-        LocalPool::LocalPoolCfgPair(sizeof(SubServiceMatcher), 20),
-        LocalPool::LocalPoolCfgPair(sizeof(ApidMatcher), 2),
-        LocalPool::LocalPoolCfgPair(sizeof(PacketMatchTree::Node), 40)
+		{10, sizeof(ServiceMatcher)},
+		{20, sizeof(SubServiceMatcher)},
+		{2, sizeof(ApidMatcher)},
+		{40, sizeof(PacketMatchTree::Node)}
 };
 
 PacketMatchTree::PacketMatchTree(Node* root) :

From 364bce90ddc44aa7e71852c458c6eff5c7aefc93 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 01:07:20 +0200
Subject: [PATCH 0917/1774] small fixes

---
 storagemanager/LocalPool.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 4a6f332c2..3c099c6d8 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -132,7 +132,8 @@ ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
     }
     else {
         //pool_index or packet_index is too large
-        sif::error << "LocalPool:deleteData failed." << std::endl;
+        sif::error << "LocalPool::deleteData: Illegal store ID, no deletion!"
+        		<< std::endl;
         status = ILLEGAL_STORAGE_ID;
     }
     return status;
@@ -165,7 +166,6 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
         *storeId = localId;
     }
     return result;
-    return HasReturnvaluesIF::RETURN_OK;
 }
 
 

From e5000abbb786f01a8664012fe52059ade71c0e61 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 01:31:11 +0200
Subject: [PATCH 0918/1774] custom cmp operator

---
 storagemanager/LocalPool.h | 54 +++++++++++++++++++++++++++-----------
 1 file changed, 39 insertions(+), 15 deletions(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 494e2cbb7..5c30c58f6 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -13,6 +13,7 @@
 #include <utility>
 #include <limits>
 
+
 /**
  * @brief   The LocalPool class provides an intermediate data storage with
  *          a fixed pool size policy.
@@ -29,17 +30,46 @@
  */
 class LocalPool: public SystemObject, public StorageManagerIF {
 public:
-    using size_type = size_t;
-
+	using size_type = size_t;
     using poolElementSize = size_type;
     using numberPoolElements = uint16_t;
-    using LocalPoolCfgPair = std::pair<numberPoolElements, poolElementSize>;
-    using LocalPoolConfig = std::multiset<LocalPoolCfgPair>;
+	using LocalPoolCfgPair = std::pair<numberPoolElements, poolElementSize>;
+
+	// The configuration needs to be provided with the pool sizes ascending
+	// but the number of pool elements as the first value is more intuitive.
+	// Therefore, a custom comparator was provided.
+	struct LocalPoolConfigCmp
+	{
+		bool operator ()(const LocalPoolCfgPair &a,
+				const LocalPoolCfgPair &b) const
+		{
+			if(a.second < b.second) {
+				return true;
+			}
+			else if(a.second > b.second) {
+				return false;
+			}
+			else {
+				if(a.first < b.first) {
+					return true;
+				}
+				else {
+					return false;
+				}
+			}
+		}
+	};
+    using LocalPoolConfig = std::multiset<LocalPoolCfgPair, LocalPoolConfigCmp>;
+
     /**
-     * @brief   This definition generally sets the number of different sized pools.
-     * @details This must be less than the maximum number of pools (currently 0xff).
+     * @brief   This definition generally sets the number of
+     * 			different sized pools. It is derived from the number of pairs
+     * 			inside the LocalPoolConfig set on object creation.
+     * @details
+     * This must be less than the maximum number of pools (currently 0xff).
      */
     const uint8_t NUMBER_OF_POOLS;
+
     /**
      * @brief   This is the default constructor for a pool manager instance.
      * @details
@@ -177,21 +207,15 @@ private:
 	 * @return	Returns the size of an element or 0.
 	 */
 	size_type getPageSize(uint16_t poolIndex);
-	/**
-	 * @brief	This helper method looks up a fitting pool for a given size.
-	 * @details	The pools are looked up in ascending order, so the first that
-	 * 			fits is used.
-	 * @param packet_size	The size of the data to be stored.
-	 * @return	Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
-	 */
+
 	/**
 	 * @brief	This helper method looks up a fitting pool for a given size.
 	 * @details	The pools are looked up in ascending order, so the first that
 	 * 			fits is used.
 	 * @param packet_size		The size of the data to be stored.
 	 * @param[out] poolIndex	The fitting pool index found.
-	 * @return	- #RETURN_OK on success,
-	 * 			- #DATA_TOO_LARGE otherwise.
+	 * @return	- @c RETURN_OK on success,
+	 * 			- @c DATA_TOO_LARGE otherwise.
 	 */
 	ReturnValue_t getPoolIndex(size_t packetSize, uint16_t* poolIndex,
 			uint16_t startAtIndex = 0);

From 56dc06e0ed1a0c0956793409aec24e5821385c42 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 01:51:12 +0200
Subject: [PATCH 0919/1774] some little formatting stuff

---
 storagemanager/LocalPool.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 3c099c6d8..ef9750294 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -14,7 +14,6 @@ LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
 		store[index] = std::vector<uint8_t>(
 				numberOfElements[index] * elementSizes[index]);
 		sizeLists[index] = std::vector<size_type>(numberOfElements[index]);
-		//TODO checkme
 		for(auto& size: sizeLists[index]) {
 			size = STORAGE_FREE;
 		}
@@ -102,7 +101,7 @@ ReturnValue_t LocalPool::modifyData(store_address_t storeId,
 
     if (sizeLists[storeId.poolIndex][storeId.packetIndex]
             != STORAGE_FREE) {
-        uint32_t packetPosition = getRawPosition(storeId);
+        size_type packetPosition = getRawPosition(storeId);
         *packetPtr = &store[storeId.poolIndex][packetPosition];
         *size = sizeLists[storeId.poolIndex][storeId.packetIndex];
         status = RETURN_OK;
@@ -111,7 +110,6 @@ ReturnValue_t LocalPool::modifyData(store_address_t storeId,
         status = DATA_DOES_NOT_EXIST;
     }
     return status;
-    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
@@ -145,7 +143,8 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
     ReturnValue_t result = ILLEGAL_ADDRESS;
     for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
         //Not sure if new allocates all stores in order. so better be careful.
-        if ((store[n].data() <= ptr) && (&store[n][numberOfElements[n]*elementSizes[n]]) > ptr) {
+        if ((store[n].data() <= ptr) and
+        		(&store[n][numberOfElements[n]*elementSizes[n]] > ptr)) {
             localId.poolIndex = n;
             uint32_t deltaAddress = ptr - store[n].data();
             // Getting any data from the right "block" is ok.

From 48ff5dea0831610897c9aec52bea2734c68f0720 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 01:57:30 +0200
Subject: [PATCH 0920/1774] line break added

---
 storagemanager/LocalPool.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index ef9750294..8bb684d78 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -245,6 +245,7 @@ void LocalPool::write(store_address_t storeId, const uint8_t *data,
     std::memcpy(ptr, data, size);
     sizeLists[storeId.poolIndex][storeId.packetIndex] = size;
 }
+
 LocalPool::size_type LocalPool::getPageSize(uint16_t poolIndex) {
     if (poolIndex < NUMBER_OF_POOLS) {
         return elementSizes[poolIndex];

From 6e5f029a641ba7c77f85ea9e1d1f1a58d1a58b9a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 12:47:21 +0200
Subject: [PATCH 0921/1774] type usage improved, getFillCoutn implemented

---
 storagemanager/LocalPool.cpp      | 48 ++++++++++++++++++++++++++++---
 storagemanager/LocalPool.h        | 24 +++++++++-------
 storagemanager/PoolManager.cpp    | 11 ++++++-
 storagemanager/PoolManager.h      | 32 ++++++++++++++++++---
 storagemanager/StorageManagerIF.h | 13 ++++++++-
 5 files changed, 108 insertions(+), 20 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 8bb684d78..bffde3678 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -2,12 +2,12 @@
 #include <FSFWConfig.h>
 #include <cstring>
 
-LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
+LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
 		bool registered, bool spillsToHigherPools):
 		SystemObject(setObjectId, registered),
 		NUMBER_OF_POOLS(poolConfig.size()),
 		spillsToHigherPools(spillsToHigherPools) {
-	uint16_t index = 0;
+	max_pools_t index = 0;
 	for (const auto& currentPoolConfig: poolConfig) {
 		this->numberOfElements[index] = currentPoolConfig.first;
 		this->elementSizes[index] = currentPoolConfig.second;
@@ -246,7 +246,7 @@ void LocalPool::write(store_address_t storeId, const uint8_t *data,
     sizeLists[storeId.poolIndex][storeId.packetIndex] = size;
 }
 
-LocalPool::size_type LocalPool::getPageSize(uint16_t poolIndex) {
+LocalPool::size_type LocalPool::getPageSize(max_pools_t poolIndex) {
     if (poolIndex < NUMBER_OF_POOLS) {
         return elementSizes[poolIndex];
     }
@@ -255,6 +255,10 @@ LocalPool::size_type LocalPool::getPageSize(uint16_t poolIndex) {
     }
 }
 
+void LocalPool::setToSpillToHigherPools(bool enable) {
+	this->spillsToHigherPools = enable;
+}
+
 ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
         uint16_t startAtIndex) {
     for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
@@ -274,7 +278,7 @@ LocalPool::size_type LocalPool::getRawPosition(store_address_t storeId) {
     return storeId.packetIndex * elementSizes[storeId.poolIndex];
 }
 
-ReturnValue_t LocalPool::findEmpty(uint16_t poolIndex, uint16_t *element) {
+ReturnValue_t LocalPool::findEmpty(n_pool_elem_t poolIndex, uint16_t *element) {
     ReturnValue_t status = DATA_STORAGE_FULL;
     for (uint16_t foundElement = 0; foundElement < numberOfElements[poolIndex];
             foundElement++) {
@@ -301,4 +305,40 @@ size_t LocalPool::getTotalSize(size_t* additionalSize) {
 }
 
 void LocalPool::getFillCount(uint8_t *buffer, uint8_t *bytesWritten) {
+	if(bytesWritten == nullptr or buffer == nullptr) {
+		return;
+	}
+
+	uint16_t reservedHits = 0;
+	uint8_t idx = 0;
+	uint16_t sum = 0;
+	for(; idx < NUMBER_OF_POOLS; idx ++) {
+		for(const auto& size: sizeLists[idx]) {
+			if(size != STORAGE_FREE) {
+				reservedHits++;
+			}
+			buffer[idx] = static_cast<float>(reservedHits) /
+					numberOfElements[idx] * 100;
+			*bytesWritten += 1;
+			sum += buffer[idx];
+		}
+	}
+	idx++;
+	buffer[idx] = sum / NUMBER_OF_POOLS;
+	*bytesWritten += 1;
+}
+
+
+void LocalPool::clearPage(max_pools_t  pageIndex) {
+	if(pageIndex >= NUMBER_OF_POOLS) {
+		return;
+	}
+
+	// Mark the storage as free
+	for(auto& size: sizeLists[pageIndex]) {
+		size = STORAGE_FREE;
+	}
+
+	// Set all the page content to 0.
+	std::memset(store[pageIndex].data(), 0, elementSizes[pageIndex]);
 }
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 5c30c58f6..db7711520 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -30,10 +30,9 @@
  */
 class LocalPool: public SystemObject, public StorageManagerIF {
 public:
-	using size_type = size_t;
-    using poolElementSize = size_type;
-    using numberPoolElements = uint16_t;
-	using LocalPoolCfgPair = std::pair<numberPoolElements, poolElementSize>;
+    using pool_elem_size_t = size_type;
+    using n_pool_elem_t = uint16_t;
+	using LocalPoolCfgPair = std::pair<n_pool_elem_t, pool_elem_size_t>;
 
 	// The configuration needs to be provided with the pool sizes ascending
 	// but the number of pool elements as the first value is more intuitive.
@@ -68,7 +67,7 @@ public:
      * @details
      * This must be less than the maximum number of pools (currently 0xff).
      */
-    const uint8_t NUMBER_OF_POOLS;
+    const max_pools_t NUMBER_OF_POOLS;
 
     /**
      * @brief   This is the default constructor for a pool manager instance.
@@ -90,8 +89,11 @@ public:
      * @param spillsToHigherPools A variable to determine whether
      * higher n pools are used if the store is full.
      */
-    LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
+    LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
             bool registered = false, bool spillsToHigherPools = false);
+
+    void setToSpillToHigherPools(bool enable);
+
 	/**
 	 * @brief	In the LocalPool's destructor all allocated memory is freed.
 	 */
@@ -132,15 +134,17 @@ public:
 	/**
 	 * Get the fill count of the pool. Each character inside the provided
 	 * buffer will be assigned to a rounded percentage fill count for each
-	 * page. The last written byte (at the index number of pools + 1)
+	 * page. The last written byte (at the index bytesWritten - 1)
 	 * will contain the total fill count of the pool as a mean of the
-	 * percentages.
+	 * percentages of single pages.
 	 * @param buffer
 	 * @param maxSize
 	 */
 	void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) override;
 
 	void clearStore() override;
+	void clearPage(max_pools_t pageIndex) override;
+
 	ReturnValue_t initialize() override;
 protected:
 	/**
@@ -206,7 +210,7 @@ private:
 	 * @param pool_index	The pool in which to look.
 	 * @return	Returns the size of an element or 0.
 	 */
-	size_type getPageSize(uint16_t poolIndex);
+	size_type getPageSize(max_pools_t poolIndex);
 
 	/**
 	 * @brief	This helper method looks up a fitting pool for a given size.
@@ -237,7 +241,7 @@ private:
 	 * @return	- #RETURN_OK on success,
 	 * 			- #DATA_STORAGE_FULL if the store is full
 	 */
-	ReturnValue_t findEmpty(uint16_t poolIndex, uint16_t* element);
+	ReturnValue_t findEmpty(n_pool_elem_t poolIndex, uint16_t* element);
 
     InternalErrorReporterIF *internalErrorReporter = nullptr;
 };
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index e7a7d9cff..85376b282 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -2,7 +2,7 @@
 #include <FSFWConfig.h>
 
 PoolManager::PoolManager(object_id_t setObjectId,
-        const LocalPoolConfig localPoolConfig):
+        const LocalPoolConfig& localPoolConfig):
         LocalPool(setObjectId, localPoolConfig, true) {
     mutex = MutexFactory::instance()->createMutex();
 }
@@ -49,3 +49,12 @@ void PoolManager::setMutexTimeout(
         uint32_t mutexTimeoutMs) {
     this->mutexTimeoutMs = mutexTimeoutMs;
 }
+
+ReturnValue_t PoolManager::lockMutex(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	return mutex->lockMutex(timeoutType, timeoutMs);
+}
+
+ReturnValue_t PoolManager::unlockMutex() {
+	return mutex->unlockMutex();
+}
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index b1781b9be..5786a2252 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -9,13 +9,20 @@
 /**
  * @brief	The PoolManager class provides an intermediate data storage with
  * 			a fixed pool size policy for inter-process communication.
- * @details	Uses local pool calls but is thread safe by protecting the call
- * 			with a lock.
+ * @details
+ * Uses local pool calls but is thread safe by protecting most calls
+ * with a lock. The developer can lock the pool with the provided API
+ * if the lock needs to persists beyond the function call.
+ *
+ * Other than that, the class provides the same interface as the LocalPool
+ * class. The class is always registered as a system object as it is assumed
+ * it will always be used concurrently (if this is not the case, it is
+ * recommended to use the LocalPool class instead).
  * @author 	Bastian Baetz
  */
 class PoolManager: public LocalPool {
 public:
-	PoolManager(object_id_t setObjectId, const LocalPoolConfig poolConfig);
+	PoolManager(object_id_t setObjectId, const LocalPoolConfig& poolConfig);
 
 	/**
 	 * @brief	In the PoolManager's destructor all allocated memory
@@ -23,6 +30,12 @@ public:
 	 */
 	virtual ~PoolManager();
 
+	/**
+	 * Set the default mutex timeout for internal calls.
+	 * @param mutexTimeoutMs
+	 */
+	void setMutexTimeout(uint32_t mutexTimeoutMs);
+
 	/**
 	 * @brief 	LocalPool overrides for thread-safety. Decorator function
 	 * 			which wraps LocalPool calls with a mutex protection.
@@ -31,7 +44,18 @@ public:
 	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = nullptr) override;
 
-	void setMutexTimeout(uint32_t mutexTimeoutMs);
+	/**
+	 * The developer is allowed to lock the mutex in case the lock needs
+	 * to persist beyond the function calls which are not protected by the
+	 * class.
+	 * @param timeoutType
+	 * @param timeoutMs
+	 * @return
+	 */
+	ReturnValue_t lockMutex(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs);
+	ReturnValue_t unlockMutex();
+
 protected:
 	//! Default mutex timeout value to prevent permanent blocking.
 	uint32_t mutexTimeoutMs = 20;
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index d22ed6612..769616d78 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -28,6 +28,9 @@ using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
  */
 class StorageManagerIF : public HasReturnvaluesIF {
 public:
+	using size_type = size_t;
+	using max_pools_t = uint8_t;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
 	static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
 	static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
@@ -40,7 +43,9 @@ public:
 	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
 	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
 
-	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
+	//!< Indicates an invalid (i.e unused) storage address.
+	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF;
+
 	/**
 	 * @brief This is the empty virtual destructor as required for C++ interfaces.
 	 */
@@ -165,6 +170,12 @@ public:
 	 */
 	virtual void clearStore() = 0;
 
+	/**
+	 * Clears a page in the store. Use with care!
+	 * @param pageIndex
+	 */
+	virtual void clearPage(uint8_t pageIndex) = 0;
+
 	/**
 	 * Get the fill count of the pool. The exact form will be implementation
 	 * dependant.

From b6ae82ec2ceb33936f25a2f4c5b5a9ec483fe810 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 13:21:46 +0200
Subject: [PATCH 0922/1774] bugfixes

---
 storagemanager/LocalPool.cpp | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index bffde3678..48934a0c8 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -7,6 +7,10 @@ LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
 		SystemObject(setObjectId, registered),
 		NUMBER_OF_POOLS(poolConfig.size()),
 		spillsToHigherPools(spillsToHigherPools) {
+	if(NUMBER_OF_POOLS == 0) {
+		sif::error << "LocalPool::LocalPool: Passed pool configuration is "
+				<< " invalid!" << std::endl;
+	}
 	max_pools_t index = 0;
 	for (const auto& currentPoolConfig: poolConfig) {
 		this->numberOfElements[index] = currentPoolConfig.first;
@@ -168,7 +172,6 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
 }
 
 
-
 ReturnValue_t LocalPool::initialize() {
     ReturnValue_t result = SystemObject::initialize();
     if (result != RETURN_OK) {
@@ -317,13 +320,13 @@ void LocalPool::getFillCount(uint8_t *buffer, uint8_t *bytesWritten) {
 			if(size != STORAGE_FREE) {
 				reservedHits++;
 			}
-			buffer[idx] = static_cast<float>(reservedHits) /
-					numberOfElements[idx] * 100;
-			*bytesWritten += 1;
-			sum += buffer[idx];
 		}
+		buffer[idx] = static_cast<float>(reservedHits) /
+				numberOfElements[idx] * 100;
+		*bytesWritten += 1;
+		sum += buffer[idx];
+		reservedHits = 0;
 	}
-	idx++;
 	buffer[idx] = sum / NUMBER_OF_POOLS;
 	*bytesWritten += 1;
 }

From ba02becfc9fa228ab156efeb1c39e7a15cae73ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 13:38:41 +0200
Subject: [PATCH 0923/1774] deleted old files

---
 storagemanager/archive/LocalPool.tpp   | 305 -------------------------
 storagemanager/archive/PoolManager.tpp |  56 -----
 2 files changed, 361 deletions(-)
 delete mode 100644 storagemanager/archive/LocalPool.tpp
 delete mode 100644 storagemanager/archive/PoolManager.tpp

diff --git a/storagemanager/archive/LocalPool.tpp b/storagemanager/archive/LocalPool.tpp
deleted file mode 100644
index 5e61efe45..000000000
--- a/storagemanager/archive/LocalPool.tpp
+++ /dev/null
@@ -1,305 +0,0 @@
-#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_TPP_
-#define FSFW_STORAGEMANAGER_LOCALPOOL_TPP_
-
-#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_H_
-#error Include LocalPool.h before LocalPool.tpp!
-#endif
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
-		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS], bool registered,
-		bool spillsToHigherPools) :
-		SystemObject(setObjectId, registered),  internalErrorReporter(nullptr),
-		spillsToHigherPools(spillsToHigherPools)
-{
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		this->element_sizes[n] = element_sizes[n];
-		this->n_elements[n] = n_elements[n];
-		store[n] = new uint8_t[n_elements[n] * element_sizes[n]];
-		size_list[n] = new uint32_t[n_elements[n]];
-		memset(store[n], 0x00, (n_elements[n] * element_sizes[n]));
-		//TODO checkme
-		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
-	}
-}
-
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
-		uint16_t* element) {
-	ReturnValue_t status = DATA_STORAGE_FULL;
-	for (uint16_t foundElement = 0; foundElement < n_elements[pool_index];
-			foundElement++) {
-		if (size_list[pool_index][foundElement] == STORAGE_FREE) {
-			*element = foundElement;
-			status = RETURN_OK;
-			break;
-		}
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::write(store_address_t packet_id,
-		const uint8_t* data, size_t size) {
-	uint8_t* ptr;
-	uint32_t packet_position = getRawPosition(packet_id);
-
-	//check size? -> Not necessary, because size is checked before calling this function.
-	ptr = &store[packet_id.pool_index][packet_position];
-	memcpy(ptr, data, size);
-	size_list[packet_id.pool_index][packet_id.packet_index] = size;
-}
-
-//Returns page size of 0 in case store_index is illegal
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getPageSize(uint16_t pool_index) {
-	if (pool_index < NUMBER_OF_POOLS) {
-		return element_sizes[pool_index];
-	} else {
-		return 0;
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getPoolIndex(
-		size_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex) {
-	for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
-		//debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: " <<
-		//		n << ", Element Size: " << element_sizes[n] << std::endl;
-		if (element_sizes[n] >= packet_size) {
-			*poolIndex = n;
-			return RETURN_OK;
-		}
-	}
-	return DATA_TOO_LARGE;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getRawPosition(
-		store_address_t packet_id) {
-	return packet_id.packet_index * element_sizes[packet_id.pool_index];
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
-		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	ReturnValue_t status = getPoolIndex(size, &address->pool_index);
-	if (status != RETURN_OK) {
-		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
-				<< " )::reserveSpace: Packet too large." << std::endl;
-		return status;
-	}
-	status = findEmpty(address->pool_index, &address->packet_index);
-	while (status != RETURN_OK && spillsToHigherPools) {
-		status = getPoolIndex(size, &address->pool_index, address->pool_index + 1);
-		if (status != RETURN_OK) {
-			//We don't find any fitting pool anymore.
-			break;
-		}
-		status = findEmpty(address->pool_index, &address->packet_index);
-	}
-	if (status == RETURN_OK) {
-		// if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
-		//	   debug << "Reserve: Pool: " << std::dec << address->pool_index <<
-		//				" Index: " << address->packet_index << std::endl;
-		// }
-
-		size_list[address->pool_index][address->packet_index] = size;
-	} else {
-		if (!ignoreFault and internalErrorReporter != nullptr) {
-			internalErrorReporter->storeFull();
-		}
-		// error << "LocalPool( " << std::hex << getObjectId() << std::dec
-		// 			<< " )::reserveSpace: Packet store is full." << std::endl;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		delete[] store[n];
-		delete[] size_list[n];
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(
-		store_address_t* storageId, const uint8_t* data, size_t size,
-		bool ignoreFault) {
-	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
-	if (status == RETURN_OK) {
-		write(*storageId, data, size);
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
-		store_address_t* storageId, const size_t size,
-		uint8_t** p_data, bool ignoreFault) {
-	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
-	if (status == RETURN_OK) {
-		*p_data = &store[storageId->pool_index][getRawPosition(*storageId)];
-	} else {
-		*p_data = NULL;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ConstAccessorPair LocalPool<NUMBER_OF_POOLS>::getData(
-		store_address_t storeId) {
-	uint8_t* tempData = nullptr;
-	ConstStorageAccessor constAccessor(storeId, this);
-	ReturnValue_t status = modifyData(storeId, &tempData, &constAccessor.size_);
-	constAccessor.constDataPointer = tempData;
-	return ConstAccessorPair(status, std::move(constAccessor));
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(store_address_t storeId,
-		ConstStorageAccessor& storeAccessor) {
-	uint8_t* tempData = nullptr;
-	ReturnValue_t status = modifyData(storeId, &tempData, &storeAccessor.size_);
-	storeAccessor.assignStore(this);
-	storeAccessor.constDataPointer = tempData;
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
-		store_address_t packet_id, const uint8_t** packet_ptr, size_t* size) {
-	uint8_t* tempData = nullptr;
-	ReturnValue_t status = modifyData(packet_id, &tempData, size);
-	*packet_ptr = tempData;
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline AccessorPair LocalPool<NUMBER_OF_POOLS>::modifyData(
-		store_address_t storeId) {
-	StorageAccessor accessor(storeId, this);
-	ReturnValue_t status = modifyData(storeId, &accessor.dataPointer,
-			&accessor.size_);
-	accessor.assignConstPointer();
-	return AccessorPair(status, std::move(accessor));
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
-		store_address_t storeId, StorageAccessor& storeAccessor) {
-	storeAccessor.assignStore(this);
-	ReturnValue_t status = modifyData(storeId, &storeAccessor.dataPointer,
-			&storeAccessor.size_);
-	storeAccessor.assignConstPointer();
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
-		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
-	ReturnValue_t status = RETURN_FAILED;
-	if (packet_id.pool_index >= NUMBER_OF_POOLS) {
-		return ILLEGAL_STORAGE_ID;
-	}
-	if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
-		return ILLEGAL_STORAGE_ID;
-	}
-	if (size_list[packet_id.pool_index][packet_id.packet_index]
-			!= STORAGE_FREE) {
-		uint32_t packet_position = getRawPosition(packet_id);
-		*packet_ptr = &store[packet_id.pool_index][packet_position];
-		*size = size_list[packet_id.pool_index][packet_id.packet_index];
-		status = RETURN_OK;
-	} else {
-		status = DATA_DOES_NOT_EXIST;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
-		store_address_t packet_id) {
-	//if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
-	//	debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: "
-	//	         << packet_id.packet_index << std::endl;
-	//}
-	ReturnValue_t status = RETURN_OK;
-	uint32_t page_size = getPageSize(packet_id.pool_index);
-	if ((page_size != 0)
-			&& (packet_id.packet_index < n_elements[packet_id.pool_index])) {
-		uint16_t packet_position = getRawPosition(packet_id);
-		uint8_t* ptr = &store[packet_id.pool_index][packet_position];
-		memset(ptr, 0, page_size);
-		//Set free list
-		size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
-	} else {
-		//pool_index or packet_index is too large
-		sif::error << "LocalPool:deleteData failed." << std::endl;
-		status = ILLEGAL_STORAGE_ID;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::clearStore() {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		//TODO checkme
-		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
-		size_t size, store_address_t* storeId) {
-	store_address_t localId;
-	ReturnValue_t result = ILLEGAL_ADDRESS;
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		//Not sure if new allocates all stores in order. so better be careful.
-		if ((store[n] <= ptr) && (&store[n][n_elements[n]*element_sizes[n]]) > ptr) {
-			localId.pool_index = n;
-			uint32_t deltaAddress = ptr - store[n];
-			// Getting any data from the right "block" is ok.
-			// This is necessary, as IF's sometimes don't point to the first
-			// element of an object.
-			localId.packet_index = deltaAddress / element_sizes[n];
-			result = deleteData(localId);
-			//if (deltaAddress % element_sizes[n] != 0) {
-			//	error << "Pool::deleteData: address not aligned!" << std::endl;
-			//}
-			break;
-		}
-	}
-	if (storeId != NULL) {
-		*storeId = localId;
-	}
-	return result;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-			objects::INTERNAL_ERROR_REPORTER);
-	if (internalErrorReporter == nullptr){
-		return ObjectManagerIF::INTERNAL_ERR_REPORTER_UNINIT;
-	}
-
-	//Check if any pool size is large than the maximum allowed.
-	for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
-		if (element_sizes[count] >= STORAGE_FREE) {
-			sif::error << "LocalPool::initialize: Pool is too large! "
-					"Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
-			return StorageManagerIF::POOL_TOO_LARGE;
-		}
-	}
-	return RETURN_OK;
-}
-
-#endif /* FSFW_STORAGEMANAGER_LOCALPOOL_TPP_ */
diff --git a/storagemanager/archive/PoolManager.tpp b/storagemanager/archive/PoolManager.tpp
deleted file mode 100644
index 2be44ece2..000000000
--- a/storagemanager/archive/PoolManager.tpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
-#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
-
-#ifndef FSFW_STORAGEMANAGER_POOLMANAGER_H_
-#error Include PoolManager.h before PoolManager.tpp!
-#endif
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
-		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS]) :
-		LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
-		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
-			address,ignoreFault);
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
-		store_address_t packet_id) {
-	// debug << "PoolManager( " << translateObject(getObjectId()) <<
-	//       " )::deleteData from store " << packet_id.pool_index <<
-	//       ". id is "<< packet_id.packet_index << std::endl;
-	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
-		size_t size, store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
-			size, storeId);
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void PoolManager<NUMBER_OF_POOLS>::setMutexTimeout(
-		uint32_t mutexTimeoutMs) {
-	this->mutexTimeout = mutexTimeoutMs;
-}
-
-#endif /* FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_ */

From 6baa859628857c5ac0acbb115095eeac667c652f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 13:42:35 +0200
Subject: [PATCH 0924/1774] fsfw config removed for now

---
 storagemanager/LocalPool.cpp   | 1 -
 storagemanager/PoolManager.cpp | 1 -
 2 files changed, 2 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 48934a0c8..8e5f4d488 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -1,5 +1,4 @@
 #include "LocalPool.h"
-#include <FSFWConfig.h>
 #include <cstring>
 
 LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index 85376b282..9c801a3da 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -1,5 +1,4 @@
 #include "PoolManager.h"
-#include <FSFWConfig.h>
 
 PoolManager::PoolManager(object_id_t setObjectId,
         const LocalPoolConfig& localPoolConfig):

From 73215baf118066c2eb5278416f302216a243cd9d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 13:43:23 +0200
Subject: [PATCH 0925/1774] init commit

---
 storagemanager/ConstStorageAccessor.h |   2 -
 storagemanager/LocalPool.cpp          | 346 ++++++++++++++++++++++++++
 storagemanager/LocalPool.h            | 233 ++++++++++-------
 storagemanager/PoolManager.cpp        |  59 +++++
 storagemanager/PoolManager.h          |  41 ++-
 storagemanager/StorageAccessor.h      |   2 -
 storagemanager/StorageManagerIF.h     |  23 +-
 storagemanager/storeAddress.h         |  13 +-
 8 files changed, 612 insertions(+), 107 deletions(-)
 create mode 100644 storagemanager/LocalPool.cpp
 create mode 100644 storagemanager/PoolManager.cpp

diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index 96d2dca2c..570c20ce5 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -20,9 +20,7 @@ class StorageManagerIF;
  */
 class ConstStorageAccessor {
 	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
 	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
 	friend class LocalPool;
 public:
 	/**
diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
new file mode 100644
index 000000000..8e5f4d488
--- /dev/null
+++ b/storagemanager/LocalPool.cpp
@@ -0,0 +1,346 @@
+#include "LocalPool.h"
+#include <cstring>
+
+LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
+		bool registered, bool spillsToHigherPools):
+		SystemObject(setObjectId, registered),
+		NUMBER_OF_POOLS(poolConfig.size()),
+		spillsToHigherPools(spillsToHigherPools) {
+	if(NUMBER_OF_POOLS == 0) {
+		sif::error << "LocalPool::LocalPool: Passed pool configuration is "
+				<< " invalid!" << std::endl;
+	}
+	max_pools_t index = 0;
+	for (const auto& currentPoolConfig: poolConfig) {
+		this->numberOfElements[index] = currentPoolConfig.first;
+		this->elementSizes[index] = currentPoolConfig.second;
+		store[index] = std::vector<uint8_t>(
+				numberOfElements[index] * elementSizes[index]);
+		sizeLists[index] = std::vector<size_type>(numberOfElements[index]);
+		for(auto& size: sizeLists[index]) {
+			size = STORAGE_FREE;
+		}
+		index++;
+	}
+}
+
+LocalPool::~LocalPool(void) {}
+
+
+ReturnValue_t LocalPool::addData(store_address_t* storageId,
+        const uint8_t* data, size_t size, bool ignoreFault) {
+    ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+    if (status == RETURN_OK) {
+        write(*storageId, data, size);
+    }
+    return status;
+}
+
+ReturnValue_t LocalPool::getData(store_address_t packetId,
+        const uint8_t **packetPtr, size_t *size) {
+    uint8_t* tempData = nullptr;
+    ReturnValue_t status = modifyData(packetId, &tempData, size);
+    *packetPtr = tempData;
+    return status;
+}
+
+ReturnValue_t LocalPool::getData(store_address_t storeId,
+        ConstStorageAccessor& storeAccessor) {
+    uint8_t* tempData = nullptr;
+    ReturnValue_t status = modifyData(storeId, &tempData,
+            &storeAccessor.size_);
+    storeAccessor.assignStore(this);
+    storeAccessor.constDataPointer = tempData;
+    return status;
+}
+
+ConstAccessorPair LocalPool::getData(store_address_t storeId) {
+    uint8_t* tempData = nullptr;
+    ConstStorageAccessor constAccessor(storeId, this);
+    ReturnValue_t status = modifyData(storeId, &tempData, &constAccessor.size_);
+    constAccessor.constDataPointer = tempData;
+    return ConstAccessorPair(status, std::move(constAccessor));
+}
+
+ReturnValue_t LocalPool::getFreeElement(store_address_t *storageId,
+        const size_t size, uint8_t **pData, bool ignoreFault) {
+    ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+    if (status == RETURN_OK) {
+        *pData = &store[storageId->poolIndex][getRawPosition(*storageId)];
+    }
+    else {
+        *pData = nullptr;
+    }
+    return status;
+}
+
+
+AccessorPair LocalPool::modifyData(store_address_t storeId) {
+    StorageAccessor accessor(storeId, this);
+    ReturnValue_t status = modifyData(storeId, &accessor.dataPointer,
+            &accessor.size_);
+    accessor.assignConstPointer();
+    return AccessorPair(status, std::move(accessor));
+}
+
+ReturnValue_t LocalPool::modifyData(store_address_t storeId,
+        StorageAccessor& storeAccessor) {
+    storeAccessor.assignStore(this);
+    ReturnValue_t status = modifyData(storeId, &storeAccessor.dataPointer,
+            &storeAccessor.size_);
+    storeAccessor.assignConstPointer();
+    return status;
+}
+
+ReturnValue_t LocalPool::modifyData(store_address_t storeId,
+        uint8_t **packetPtr, size_t *size) {
+    ReturnValue_t status = RETURN_FAILED;
+    if (storeId.poolIndex >= NUMBER_OF_POOLS) {
+        return ILLEGAL_STORAGE_ID;
+    }
+    if ((storeId.packetIndex >= numberOfElements[storeId.poolIndex])) {
+        return ILLEGAL_STORAGE_ID;
+    }
+
+    if (sizeLists[storeId.poolIndex][storeId.packetIndex]
+            != STORAGE_FREE) {
+        size_type packetPosition = getRawPosition(storeId);
+        *packetPtr = &store[storeId.poolIndex][packetPosition];
+        *size = sizeLists[storeId.poolIndex][storeId.packetIndex];
+        status = RETURN_OK;
+    }
+    else {
+        status = DATA_DOES_NOT_EXIST;
+    }
+    return status;
+}
+
+ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
+#if FSFW_DEBUGGING == 1
+      sif::debug << "Delete: Pool: " << std::dec << storeId.poolIndex
+              << " Index: " << storeId.packetIndex << std::endl;
+
+#endif
+    ReturnValue_t status = RETURN_OK;
+    size_type pageSize = getPageSize(storeId.poolIndex);
+    if ((pageSize != 0) and
+            (storeId.packetIndex < numberOfElements[storeId.poolIndex])) {
+        uint16_t packetPosition = getRawPosition(storeId);
+        uint8_t* ptr = &store[storeId.poolIndex][packetPosition];
+        std::memset(ptr, 0, pageSize);
+        //Set free list
+        sizeLists[storeId.poolIndex][storeId.packetIndex] = STORAGE_FREE;
+    }
+    else {
+        //pool_index or packet_index is too large
+        sif::error << "LocalPool::deleteData: Illegal store ID, no deletion!"
+        		<< std::endl;
+        status = ILLEGAL_STORAGE_ID;
+    }
+    return status;
+}
+
+ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
+        store_address_t *storeId) {
+    store_address_t localId;
+    ReturnValue_t result = ILLEGAL_ADDRESS;
+    for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+        //Not sure if new allocates all stores in order. so better be careful.
+        if ((store[n].data() <= ptr) and
+        		(&store[n][numberOfElements[n]*elementSizes[n]] > ptr)) {
+            localId.poolIndex = n;
+            uint32_t deltaAddress = ptr - store[n].data();
+            // Getting any data from the right "block" is ok.
+            // This is necessary, as IF's sometimes don't point to the first
+            // element of an object.
+            localId.packetIndex = deltaAddress / elementSizes[n];
+            result = deleteData(localId);
+#if FSFW_DEBUGGING == 1
+            if (deltaAddress % elementSizes[n] != 0) {
+                sif::error << "LocalPool::deleteData: Address not aligned!"
+                        << std::endl;
+            }
+#endif
+            break;
+        }
+    }
+    if (storeId != nullptr) {
+        *storeId = localId;
+    }
+    return result;
+}
+
+
+ReturnValue_t LocalPool::initialize() {
+    ReturnValue_t result = SystemObject::initialize();
+    if (result != RETURN_OK) {
+        return result;
+    }
+    internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+            objects::INTERNAL_ERROR_REPORTER);
+    if (internalErrorReporter == nullptr){
+        return ObjectManagerIF::INTERNAL_ERR_REPORTER_UNINIT;
+    }
+
+    //Check if any pool size is large than the maximum allowed.
+    for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
+        if (elementSizes[count] >= STORAGE_FREE) {
+            sif::error << "LocalPool::initialize: Pool is too large! "
+                    "Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
+            return StorageManagerIF::POOL_TOO_LARGE;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void LocalPool::clearStore() {
+    for(auto& sizeList: sizeLists) {
+        for(auto& size: sizeList) {
+            size = STORAGE_FREE;
+        }
+//        std::memset(sizeList[index], 0xff,
+//                numberOfElements[index] * sizeof(size_type));
+    }
+
+}
+
+ReturnValue_t LocalPool::reserveSpace(const size_t size,
+        store_address_t *storeId, bool ignoreFault) {
+    ReturnValue_t status = getPoolIndex(size, &storeId->poolIndex);
+    if (status != RETURN_OK) {
+        sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
+                << " )::reserveSpace: Packet too large." << std::endl;
+        return status;
+    }
+    status = findEmpty(storeId->poolIndex, &storeId->packetIndex);
+    while (status != RETURN_OK && spillsToHigherPools) {
+        status = getPoolIndex(size, &storeId->poolIndex, storeId->poolIndex + 1);
+        if (status != RETURN_OK) {
+            //We don't find any fitting pool anymore.
+            break;
+        }
+        status = findEmpty(storeId->poolIndex, &storeId->packetIndex);
+    }
+    if (status == RETURN_OK) {
+#if FSFW_DEBUGGING == 1
+        sif::debug << "Reserve: Pool: " << std::dec
+                << storeId->poolIndex << " Index: " << storeId->packetIndex
+                << std::endl;
+#endif
+        sizeLists[storeId->poolIndex][storeId->packetIndex] = size;
+    }
+    else {
+        if ((not ignoreFault) and (internalErrorReporter != nullptr)) {
+            internalErrorReporter->storeFull();
+        }
+    }
+    return status;
+}
+
+void LocalPool::write(store_address_t storeId, const uint8_t *data,
+        size_t size) {
+    uint8_t* ptr = nullptr;
+    size_type packetPosition = getRawPosition(storeId);
+
+    // Size was checked before calling this function.
+    ptr = &store[storeId.poolIndex][packetPosition];
+    std::memcpy(ptr, data, size);
+    sizeLists[storeId.poolIndex][storeId.packetIndex] = size;
+}
+
+LocalPool::size_type LocalPool::getPageSize(max_pools_t poolIndex) {
+    if (poolIndex < NUMBER_OF_POOLS) {
+        return elementSizes[poolIndex];
+    }
+    else {
+        return 0;
+    }
+}
+
+void LocalPool::setToSpillToHigherPools(bool enable) {
+	this->spillsToHigherPools = enable;
+}
+
+ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
+        uint16_t startAtIndex) {
+    for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
+#if FSFW_DEBUGGING == 1
+        sif::debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: "
+             << n << ", Element Size: " << elementSizes[n] << std::endl;
+#endif
+        if (elementSizes[n] >= packetSize) {
+            *poolIndex = n;
+            return RETURN_OK;
+        }
+    }
+    return DATA_TOO_LARGE;
+}
+
+LocalPool::size_type LocalPool::getRawPosition(store_address_t storeId) {
+    return storeId.packetIndex * elementSizes[storeId.poolIndex];
+}
+
+ReturnValue_t LocalPool::findEmpty(n_pool_elem_t poolIndex, uint16_t *element) {
+    ReturnValue_t status = DATA_STORAGE_FULL;
+    for (uint16_t foundElement = 0; foundElement < numberOfElements[poolIndex];
+            foundElement++) {
+        if (sizeLists[poolIndex][foundElement] == STORAGE_FREE) {
+            *element = foundElement;
+            status = RETURN_OK;
+            break;
+        }
+    }
+    return status;
+}
+
+size_t LocalPool::getTotalSize(size_t* additionalSize) {
+    size_t totalSize = 0;
+    size_t sizesSize = 0;
+    for(uint8_t idx = 0; idx < NUMBER_OF_POOLS; idx ++) {
+        totalSize += elementSizes[idx] * numberOfElements[idx];
+        sizesSize += numberOfElements[idx] * sizeof(size_type);
+    }
+    if(additionalSize != nullptr) {
+        *additionalSize = sizesSize;
+    }
+    return totalSize;
+}
+
+void LocalPool::getFillCount(uint8_t *buffer, uint8_t *bytesWritten) {
+	if(bytesWritten == nullptr or buffer == nullptr) {
+		return;
+	}
+
+	uint16_t reservedHits = 0;
+	uint8_t idx = 0;
+	uint16_t sum = 0;
+	for(; idx < NUMBER_OF_POOLS; idx ++) {
+		for(const auto& size: sizeLists[idx]) {
+			if(size != STORAGE_FREE) {
+				reservedHits++;
+			}
+		}
+		buffer[idx] = static_cast<float>(reservedHits) /
+				numberOfElements[idx] * 100;
+		*bytesWritten += 1;
+		sum += buffer[idx];
+		reservedHits = 0;
+	}
+	buffer[idx] = sum / NUMBER_OF_POOLS;
+	*bytesWritten += 1;
+}
+
+
+void LocalPool::clearPage(max_pools_t  pageIndex) {
+	if(pageIndex >= NUMBER_OF_POOLS) {
+		return;
+	}
+
+	// Mark the storage as free
+	for(auto& size: sizeLists[pageIndex]) {
+		size = STORAGE_FREE;
+	}
+
+	// Set all the page content to 0.
+	std::memset(store[pageIndex].data(), 0, elementSizes[pageIndex]);
+}
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 3a94c03db..db7711520 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -7,57 +7,93 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../internalError/InternalErrorReporterIF.h"
 #include "../storagemanager/StorageAccessor.h"
-#include <cstring>
+
+#include <vector>
+#include <set>
+#include <utility>
+#include <limits>
 
 
 /**
- * @brief	The LocalPool class provides an intermediate data storage with
- * 			a fixed pool size policy.
- * @details	The class implements the StorageManagerIF interface. While the
- * 			total number of pools is fixed, the element sizes in one pool and
- * 			the number of pool elements per pool are set on construction.
- * 			The full amount of memory is allocated on construction.
- * 			The overhead is 4 byte per pool element to store the size
- * 			information of each stored element.
- * 			To maintain an "empty" information, the pool size is limited to
- * 			0xFFFF-1 bytes.
- * 			It is possible to store empty packets in the pool.
- * 			The local pool is NOT thread-safe.
- * @author 	Bastian Baetz
+ * @brief   The LocalPool class provides an intermediate data storage with
+ *          a fixed pool size policy.
+ * @details
+ * The class implements the StorageManagerIF interface. While the total number
+ * of pools is fixed, the element sizes in one pool and the number of pool
+ * elements per pool are set on construction. The full amount of memory is
+ * allocated on construction.
+ * The overhead is 4 byte per pool element to store the size information of
+ * each stored element. To maintain an "empty" information, the pool size is
+ * limited to 0xFFFF-1 bytes.
+ * It is possible to store empty packets in the pool.
+ * The local pool is NOT thread-safe.
  */
-template<uint8_t NUMBER_OF_POOLS = 5>
 class LocalPool: public SystemObject, public StorageManagerIF {
 public:
-	/**
-	 * @brief	This definition generally sets the number of different sized pools.
-	 * @details This must be less than the maximum number of pools (currently 0xff).
-	 */
-	//	static const uint32_t NUMBER_OF_POOLS;
-	/**
-	 * @brief	This is the default constructor for a pool manager instance.
-	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
-	 * 			allocates memory (with @c new) for store and size_list. These
-	 * 			regions are all set to zero on start up.
-	 * @param setObjectId	The object identifier to be set. This allows for
-	 * 						multiple instances of LocalPool in the system.
-	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
-	 * 						of a single element in each pool is determined.
-	 * 						<b>The sizes must be provided in ascending order.
-	 * 						</b>
-	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
-	 * 						number of elements for each pool is determined.
-	 * 						The position of these values correspond to those in
-	 * 						element_sizes.
-	 * @param registered	Register the pool in object manager or not.
-	 * Default is false (local pool).
-	 * @param spillsToHigherPools A variable to determine whether
-	 * higher n pools are used if the store is full.
-	 */
-	LocalPool(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS],
-			bool registered = false,
-			bool spillsToHigherPools = false);
+    using pool_elem_size_t = size_type;
+    using n_pool_elem_t = uint16_t;
+	using LocalPoolCfgPair = std::pair<n_pool_elem_t, pool_elem_size_t>;
+
+	// The configuration needs to be provided with the pool sizes ascending
+	// but the number of pool elements as the first value is more intuitive.
+	// Therefore, a custom comparator was provided.
+	struct LocalPoolConfigCmp
+	{
+		bool operator ()(const LocalPoolCfgPair &a,
+				const LocalPoolCfgPair &b) const
+		{
+			if(a.second < b.second) {
+				return true;
+			}
+			else if(a.second > b.second) {
+				return false;
+			}
+			else {
+				if(a.first < b.first) {
+					return true;
+				}
+				else {
+					return false;
+				}
+			}
+		}
+	};
+    using LocalPoolConfig = std::multiset<LocalPoolCfgPair, LocalPoolConfigCmp>;
+
+    /**
+     * @brief   This definition generally sets the number of
+     * 			different sized pools. It is derived from the number of pairs
+     * 			inside the LocalPoolConfig set on object creation.
+     * @details
+     * This must be less than the maximum number of pools (currently 0xff).
+     */
+    const max_pools_t NUMBER_OF_POOLS;
+
+    /**
+     * @brief   This is the default constructor for a pool manager instance.
+     * @details
+     * The pool is configured by passing a set of pairs into the constructor.
+     * The first value of that pair determines the number of one elements on
+     * the respective page of the pool while the second value determines how
+     * many elements with that size are created on that page.
+     * All regions are to zero on start up.
+     * @param setObjectId   The object identifier to be set. This allows for
+     *                      multiple instances of LocalPool in the system.
+     * @param poolConfig
+     * This is a set of pairs to configure the number of pages in the pool,
+     * the size of an element on a page, the number of elements on a page
+     * and the total size of the pool at once while also implicitely
+     * sorting the pairs in the right order.
+     * @param registered
+     * Determines whether the pool is registered in the object manager or not.
+     * @param spillsToHigherPools A variable to determine whether
+     * higher n pools are used if the store is full.
+     */
+    LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
+            bool registered = false, bool spillsToHigherPools = false);
+
+    void setToSpillToHigherPools(bool enable);
+
 	/**
 	 * @brief	In the LocalPool's destructor all allocated memory is freed.
 	 */
@@ -66,25 +102,49 @@ public:
 	/**
 	 * Documentation: See StorageManagerIF.h
 	 */
-	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
+	ReturnValue_t addData(store_address_t* storeId, const uint8_t * data,
 			size_t size, bool ignoreFault = false) override;
-	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
-			uint8_t** p_data, bool ignoreFault = false) override;
+	ReturnValue_t getFreeElement(store_address_t* storeId,const size_t size,
+			uint8_t** pData, bool ignoreFault = false) override;
 
-	ConstAccessorPair getData(store_address_t packet_id) override;
-	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
-	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
+	ConstAccessorPair getData(store_address_t storeId) override;
+	ReturnValue_t getData(store_address_t storeId,
+	        ConstStorageAccessor& constAccessor) override;
+	ReturnValue_t getData(store_address_t storeId,
+	        const uint8_t** packet_ptr, size_t * size) override;
+
+	AccessorPair modifyData(store_address_t storeId) override;
+	ReturnValue_t modifyData(store_address_t storeId,
+	        StorageAccessor& storeAccessor) override;
+	ReturnValue_t modifyData(store_address_t storeId, uint8_t** packet_ptr,
 			size_t * size) override;
 
-	AccessorPair modifyData(store_address_t packet_id) override;
-	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
-	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			size_t * size) override;
-
-	virtual ReturnValue_t deleteData(store_address_t) override;
+	virtual ReturnValue_t deleteData(store_address_t storeId) override;
 	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
-			store_address_t* storeId = NULL) override;
+			store_address_t* storeId = nullptr) override;
+
+	/**
+	 * Get the total size of allocated memory for pool data.
+	 * There is an additional overhead of the sizes of elements which will
+	 * be assigned to additionalSize
+	 * @return
+	 */
+	size_t getTotalSize(size_t* additionalSize) override;
+
+	/**
+	 * Get the fill count of the pool. Each character inside the provided
+	 * buffer will be assigned to a rounded percentage fill count for each
+	 * page. The last written byte (at the index bytesWritten - 1)
+	 * will contain the total fill count of the pool as a mean of the
+	 * percentages of single pages.
+	 * @param buffer
+	 * @param maxSize
+	 */
+	void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) override;
+
 	void clearStore() override;
+	void clearPage(max_pools_t pageIndex) override;
+
 	ReturnValue_t initialize() override;
 protected:
 	/**
@@ -94,43 +154,48 @@ protected:
 	 * @return	- #RETURN_OK on success,
 	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
 	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size,
+	virtual ReturnValue_t reserveSpace(const size_t size,
 			store_address_t* address, bool ignoreFault);
 
-	InternalErrorReporterIF *internalErrorReporter;
 private:
-	/**
-	 * Indicates that this element is free.
-	 * This value limits the maximum size of a pool. Change to larger data type
-	 * if increase is required.
-	 */
-	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
+    /**
+     * Indicates that this element is free.
+     * This value limits the maximum size of a pool.
+     * Change to larger data type if increase is required.
+     */
+    static const size_type STORAGE_FREE = std::numeric_limits<size_type>::max();
 	/**
 	 * @brief	In this array, the element sizes of each pool is stored.
 	 * @details	The sizes are maintained for internal pool management. The sizes
 	 * 			must be set in ascending order on construction.
 	 */
-	uint32_t element_sizes[NUMBER_OF_POOLS];
+    std::vector<size_type> elementSizes =
+            std::vector<size_type>(NUMBER_OF_POOLS);
 	/**
 	 * @brief	n_elements stores the number of elements per pool.
 	 * @details	These numbers are maintained for internal pool management.
 	 */
-	uint16_t n_elements[NUMBER_OF_POOLS];
+	std::vector<uint16_t> numberOfElements =
+	        std::vector<uint16_t>(NUMBER_OF_POOLS);
 	/**
 	 * @brief	store represents the actual memory pool.
 	 * @details	It is an array of pointers to memory, which was allocated with
 	 * 			a @c new call on construction.
 	 */
-	uint8_t* store[NUMBER_OF_POOLS];
+	std::vector<std::vector<uint8_t>> store =
+	        std::vector<std::vector<uint8_t>>(NUMBER_OF_POOLS);
+
 	/**
 	 * @brief	The size_list attribute stores the size values of every pool element.
 	 * @details	As the number of elements is determined on construction, the size list
 	 * 			is also dynamically allocated there.
 	 */
-	uint32_t* size_list[NUMBER_OF_POOLS];
+	std::vector<std::vector<size_type>> sizeLists =
+	        std::vector<std::vector<size_type>>(NUMBER_OF_POOLS);
+
 	//! A variable to determine whether higher n pools are used if
 	//! the store is full.
-	bool spillsToHigherPools;
+	bool spillsToHigherPools = false;
 	/**
 	 * @brief	This method safely stores the given data in the given packet_id.
 	 * @details	It also sets the size in size_list. The method does not perform
@@ -139,30 +204,24 @@ private:
 	 * @param data		The data to be stored.
 	 * @param size		The size of the data to be stored.
 	 */
-	void write(store_address_t packet_id, const uint8_t* data, size_t size);
+	void write(store_address_t packetId, const uint8_t* data, size_t size);
 	/**
 	 * @brief	A helper method to read the element size of a certain pool.
 	 * @param pool_index	The pool in which to look.
 	 * @return	Returns the size of an element or 0.
 	 */
-	uint32_t getPageSize(uint16_t pool_index);
-	/**
-	 * @brief	This helper method looks up a fitting pool for a given size.
-	 * @details	The pools are looked up in ascending order, so the first that
-	 * 			fits is used.
-	 * @param packet_size	The size of the data to be stored.
-	 * @return	Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
-	 */
+	size_type getPageSize(max_pools_t poolIndex);
+
 	/**
 	 * @brief	This helper method looks up a fitting pool for a given size.
 	 * @details	The pools are looked up in ascending order, so the first that
 	 * 			fits is used.
 	 * @param packet_size		The size of the data to be stored.
 	 * @param[out] poolIndex	The fitting pool index found.
-	 * @return	- #RETURN_OK on success,
-	 * 			- #DATA_TOO_LARGE otherwise.
+	 * @return	- @c RETURN_OK on success,
+	 * 			- @c DATA_TOO_LARGE otherwise.
 	 */
-	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
+	ReturnValue_t getPoolIndex(size_t packetSize, uint16_t* poolIndex,
 			uint16_t startAtIndex = 0);
 	/**
 	 * @brief	This helper method calculates the true array position in store
@@ -172,7 +231,7 @@ private:
 	 * @param packet_id	The packet id to look up.
 	 * @return	Returns the position of the data in store.
 	 */
-	uint32_t getRawPosition(store_address_t packet_id);
+	size_type getRawPosition(store_address_t storeId);
 	/**
 	 * @brief	This is a helper method to find an empty element in a given pool.
 	 * @details	The method searches size_list for the first empty element, so
@@ -182,9 +241,9 @@ private:
 	 * @return	- #RETURN_OK on success,
 	 * 			- #DATA_STORAGE_FULL if the store is full
 	 */
-	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
+	ReturnValue_t findEmpty(n_pool_elem_t poolIndex, uint16_t* element);
+
+    InternalErrorReporterIF *internalErrorReporter = nullptr;
 };
 
-#include "LocalPool.tpp"
-
 #endif /* FSFW_STORAGEMANAGER_LOCALPOOL_H_ */
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
new file mode 100644
index 000000000..9c801a3da
--- /dev/null
+++ b/storagemanager/PoolManager.cpp
@@ -0,0 +1,59 @@
+#include "PoolManager.h"
+
+PoolManager::PoolManager(object_id_t setObjectId,
+        const LocalPoolConfig& localPoolConfig):
+        LocalPool(setObjectId, localPoolConfig, true) {
+    mutex = MutexFactory::instance()->createMutex();
+}
+
+
+PoolManager::~PoolManager(void) {
+    MutexFactory::instance()->deleteMutex(mutex);
+}
+
+
+ReturnValue_t PoolManager::reserveSpace(const size_t size,
+        store_address_t* address, bool ignoreFault) {
+    MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+            mutexTimeoutMs);
+    ReturnValue_t status = LocalPool::reserveSpace(size,
+            address,ignoreFault);
+    return status;
+}
+
+
+ReturnValue_t PoolManager::deleteData(
+        store_address_t storeId) {
+#if FSFW_DEBUGGING == 1
+     sif::debug << "PoolManager( " << translateObject(getObjectId()) <<
+           " )::deleteData from store " << storeId.poolIndex <<
+           ". id is "<< storeId.packetIndex << std::endl;
+#endif
+    MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+            mutexTimeoutMs);
+    return LocalPool::deleteData(storeId);
+}
+
+
+ReturnValue_t PoolManager::deleteData(uint8_t* buffer,
+        size_t size, store_address_t* storeId) {
+    MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    ReturnValue_t status = LocalPool::deleteData(buffer,
+            size, storeId);
+    return status;
+}
+
+
+void PoolManager::setMutexTimeout(
+        uint32_t mutexTimeoutMs) {
+    this->mutexTimeoutMs = mutexTimeoutMs;
+}
+
+ReturnValue_t PoolManager::lockMutex(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	return mutex->lockMutex(timeoutType, timeoutMs);
+}
+
+ReturnValue_t PoolManager::unlockMutex() {
+	return mutex->unlockMutex();
+}
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 8cc6c0654..5786a2252 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -9,16 +9,20 @@
 /**
  * @brief	The PoolManager class provides an intermediate data storage with
  * 			a fixed pool size policy for inter-process communication.
- * @details	Uses local pool calls but is thread safe by protecting the call
- * 			with a lock.
+ * @details
+ * Uses local pool calls but is thread safe by protecting most calls
+ * with a lock. The developer can lock the pool with the provided API
+ * if the lock needs to persists beyond the function call.
+ *
+ * Other than that, the class provides the same interface as the LocalPool
+ * class. The class is always registered as a system object as it is assumed
+ * it will always be used concurrently (if this is not the case, it is
+ * recommended to use the LocalPool class instead).
  * @author 	Bastian Baetz
  */
-template <uint8_t NUMBER_OF_POOLS = 5>
-class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
+class PoolManager: public LocalPool {
 public:
-	PoolManager(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS]);
+	PoolManager(object_id_t setObjectId, const LocalPoolConfig& poolConfig);
 
 	/**
 	 * @brief	In the PoolManager's destructor all allocated memory
@@ -26,6 +30,12 @@ public:
 	 */
 	virtual ~PoolManager();
 
+	/**
+	 * Set the default mutex timeout for internal calls.
+	 * @param mutexTimeoutMs
+	 */
+	void setMutexTimeout(uint32_t mutexTimeoutMs);
+
 	/**
 	 * @brief 	LocalPool overrides for thread-safety. Decorator function
 	 * 			which wraps LocalPool calls with a mutex protection.
@@ -34,12 +44,23 @@ public:
 	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = nullptr) override;
 
-	void setMutexTimeout(uint32_t mutexTimeoutMs);
+	/**
+	 * The developer is allowed to lock the mutex in case the lock needs
+	 * to persist beyond the function calls which are not protected by the
+	 * class.
+	 * @param timeoutType
+	 * @param timeoutMs
+	 * @return
+	 */
+	ReturnValue_t lockMutex(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs);
+	ReturnValue_t unlockMutex();
+
 protected:
 	//! Default mutex timeout value to prevent permanent blocking.
 	uint32_t mutexTimeoutMs = 20;
 
-	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
+	ReturnValue_t reserveSpace(const size_t size, store_address_t* address,
 			bool ignoreFault) override;
 
 	/**
@@ -51,6 +72,4 @@ protected:
 	MutexIF* mutex;
 };
 
-#include "PoolManager.tpp"
-
 #endif /* FSFW_STORAGEMANAGER_POOLMANAGER_H_ */
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 5cf15d509..d5b383eb6 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -10,9 +10,7 @@ class StorageManagerIF;
  */
 class StorageAccessor: public ConstStorageAccessor {
 	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
 	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
 	friend class LocalPool;
 public:
 	StorageAccessor(store_address_t storeId);
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 834e75637..769616d78 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -28,6 +28,9 @@ using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
  */
 class StorageManagerIF : public HasReturnvaluesIF {
 public:
+	using size_type = size_t;
+	using max_pools_t = uint8_t;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
 	static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
 	static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
@@ -40,7 +43,9 @@ public:
 	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
 	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
 
-	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
+	//!< Indicates an invalid (i.e unused) storage address.
+	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF;
+
 	/**
 	 * @brief This is the empty virtual destructor as required for C++ interfaces.
 	 */
@@ -164,6 +169,22 @@ public:
 	 * Use with care!
 	 */
 	virtual void clearStore() = 0;
+
+	/**
+	 * Clears a page in the store. Use with care!
+	 * @param pageIndex
+	 */
+	virtual void clearPage(uint8_t pageIndex) = 0;
+
+	/**
+	 * Get the fill count of the pool. The exact form will be implementation
+	 * dependant.
+	 * @param buffer
+	 * @param bytesWritten
+	 */
+	virtual void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) = 0;
+
+	virtual size_t getTotalSize(size_t* additionalSize) = 0;
 };
 
 #endif /* FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_ */
diff --git a/storagemanager/storeAddress.h b/storagemanager/storeAddress.h
index 044c07908..ea72f6f89 100644
--- a/storagemanager/storeAddress.h
+++ b/storagemanager/storeAddress.h
@@ -3,16 +3,21 @@
 
 #include <cstdint>
 
+namespace storeId {
+static constexpr uint32_t INVALID_STORE_ADDRESS = 0xffffffff;
+}
+
 /**
  * This union defines the type that identifies where a data packet is
  * stored in the store. It comprises of a raw part to read it as raw value and
  * a structured part to use it in pool-like stores.
  */
 union store_address_t {
+
 	/**
 	 * Default Constructor, initializing to INVALID_ADDRESS
 	 */
-	store_address_t():raw(0xFFFFFFFF){}
+	store_address_t(): raw(storeId::INVALID_STORE_ADDRESS){}
 	/**
 	 * Constructor to create an address object using the raw address
 	 *
@@ -28,7 +33,7 @@ union store_address_t {
 	 * @param packetIndex
 	 */
 	store_address_t(uint16_t poolIndex, uint16_t packetIndex):
-		pool_index(poolIndex),packet_index(packetIndex){}
+		poolIndex(poolIndex), packetIndex(packetIndex){}
 	/**
 	 * A structure with two elements to access the store address pool-like.
 	 */
@@ -36,11 +41,11 @@ union store_address_t {
 		/**
 		 * The index in which pool the packet lies.
 		 */
-		uint16_t pool_index;
+		uint16_t poolIndex;
 		/**
 		 * The position in the chosen pool.
 		 */
-		uint16_t packet_index;
+		uint16_t packetIndex;
 	};
 	/**
 	 * Alternative access to the raw value.

From 67e33918e0fb07fe3dd6afbfda9eb5bbfcd044fe Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 13:44:09 +0200
Subject: [PATCH 0926/1774] event manager uses refactored pool now

---
 events/EventManager.cpp | 18 +++++++++---------
 events/EventManager.h   | 10 +++++++---
 2 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index e71951e36..57bda13fb 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,23 +1,23 @@
 #include "EventManager.h"
-#include "EventMessage.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
 
 
-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.
-// SHOULDDO: Shouldn't this be in the config folder and passed via ctor?
-const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
+// This should be configurable..
+const LocalPool::LocalPoolConfig EventManager::poolConfig = {
+        {240, sizeof(EventMatchTree::Node)},
+        {120, sizeof(EventIdRangeMatcher)},
+        {120, sizeof(ReporterRangeMatcher)}
+};
 
 EventManager::EventManager(object_id_t setObjectId) :
 		SystemObject(setObjectId),
-		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
+		factoryBackend(0, poolConfig, false, true) {
 	mutex = MutexFactory::instance()->createMutex();
 	eventReportQueue = QueueFactory::instance()->createMessageQueue(
 			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
@@ -109,13 +109,13 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 	return result;
 }
 
-#ifdef DEBUG
+#if FSFW_DEBUG_OUTPUT == 1
 
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
 	switch (message->getSeverity()) {
 	case SEVERITY::INFO:
-#ifdef DEBUG_INFO_EVENT
+#if DEBUG_INFO_EVENT == 1
 		string = translateObject(message->getReporter());
 		sif::info << "EVENT: ";
 		if (string != 0) {
diff --git a/events/EventManager.h b/events/EventManager.h
index 2602aeb23..fe35d9d3e 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -8,9 +8,11 @@
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MutexIF.h"
+#include <FSFWConfig.h>
+
 #include <map>
 
-#ifdef DEBUG
+#if FSFW_DEBUG_OUTPUT == 1
 // forward declaration, should be implemented by mission
 extern const char* translateObject(object_id_t object);
 extern const char* translateEvents(Event event);
@@ -49,13 +51,15 @@ protected:
 	MutexIF* mutex = nullptr;
 
 	static const uint8_t N_POOLS = 3;
-	LocalPool<N_POOLS> factoryBackend;
+	LocalPool factoryBackend;
+	static const LocalPool::LocalPoolConfig poolConfig;
+
 	static const uint16_t POOL_SIZES[N_POOLS];
 	static const uint16_t N_ELEMENTS[N_POOLS];
 
 	void notifyListeners(EventMessage *message);
 
-#ifdef DEBUG
+#if FSFW_DEBUG_OUTPUT == 1
 	void printEvent(EventMessage *message);
 #endif
 

From 7d358483dd1f684609d52f144e64aa02e1e82425 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 13:44:59 +0200
Subject: [PATCH 0927/1774] added back config includes

---
 storagemanager/LocalPool.cpp   | 1 +
 storagemanager/PoolManager.cpp | 1 +
 2 files changed, 2 insertions(+)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 8e5f4d488..48934a0c8 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -1,4 +1,5 @@
 #include "LocalPool.h"
+#include <FSFWConfig.h>
 #include <cstring>
 
 LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index 9c801a3da..85376b282 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -1,4 +1,5 @@
 #include "PoolManager.h"
+#include <FSFWConfig.h>
 
 PoolManager::PoolManager(object_id_t setObjectId,
         const LocalPoolConfig& localPoolConfig):

From bd2f8b3e8ce09c6328519a9047d7144ff7932d37 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 13:45:47 +0200
Subject: [PATCH 0928/1774] packet matcher uses refactored pool now

---
 tmtcpacket/packetmatcher/PacketMatchTree.cpp | 28 ++++++++++++--------
 tmtcpacket/packetmatcher/PacketMatchTree.h   |  3 ++-
 2 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.cpp b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
index a45796576..ac72b3e77 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.cpp
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
@@ -3,19 +3,30 @@
 #include "ServiceMatcher.h"
 #include "SubserviceMatcher.h"
 
+// This should be configurable..
+const LocalPool::LocalPoolConfig PacketMatchTree::poolConfig = {
+		{10, sizeof(ServiceMatcher)},
+		{20, sizeof(SubServiceMatcher)},
+		{2, sizeof(ApidMatcher)},
+		{40, sizeof(PacketMatchTree::Node)}
+};
+
 PacketMatchTree::PacketMatchTree(Node* root) :
-		MatchTree<TmPacketMinimal*>(root, 2), factoryBackend(0, POOL_SIZES,
-				N_ELEMENTS, false, true), factory(&factoryBackend) {
+		MatchTree<TmPacketMinimal*>(root, 2),
+		factoryBackend(0, poolConfig, false, true),
+		factory(&factoryBackend) {
 }
 
 PacketMatchTree::PacketMatchTree(iterator root) :
-		MatchTree<TmPacketMinimal*>(root.element, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+		MatchTree<TmPacketMinimal*>(root.element, 2),
+		factoryBackend(0, poolConfig, false, true),
+		factory(&factoryBackend) {
 }
 
 PacketMatchTree::PacketMatchTree() :
-		MatchTree<TmPacketMinimal*>((Node*) NULL, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+		MatchTree<TmPacketMinimal*>((Node*) NULL, 2),
+		factoryBackend(0, poolConfig, false, true),
+		factory(&factoryBackend) {
 }
 
 PacketMatchTree::~PacketMatchTree() {
@@ -172,11 +183,6 @@ ReturnValue_t PacketMatchTree::initialize() {
 	return factoryBackend.initialize();
 }
 
-const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
-		sizeof(SubServiceMatcher), sizeof(ApidMatcher),
-		sizeof(PacketMatchTree::Node) };
-//Maximum number of types and subtypes to filter should be more than sufficient.
-const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
 
 ReturnValue_t PacketMatchTree::changeMatch(bool addToMatch, uint16_t apid,
 		uint8_t type, uint8_t subtype) {
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.h b/tmtcpacket/packetmatcher/PacketMatchTree.h
index 86fb087ed..54fc856c7 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.h
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.h
@@ -23,8 +23,9 @@ protected:
 	ReturnValue_t cleanUpElement(iterator position);
 private:
 	static const uint8_t N_POOLS = 4;
-	LocalPool<N_POOLS> factoryBackend;
+	LocalPool factoryBackend;
 	PlacementFactory factory;
+	static const LocalPool::LocalPoolConfig poolConfig;
 	static const uint16_t POOL_SIZES[N_POOLS];
 	static const uint16_t N_ELEMENTS[N_POOLS];
 	template<typename VALUE_T, typename INSERTION_T>

From 91cf33127a1a869a7a0b959f609dea09ec735e57 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 16 Oct 2020 00:41:50 +0200
Subject: [PATCH 0929/1774] bugfix

---
 datapoollocal/LocalPoolObjectBase.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index b6302e7e6..6494a2228 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -2,7 +2,7 @@
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
         HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
-        pool_rwm_t setReadWriteMode) {
+        pool_rwm_t setReadWriteMode): localPoolId(poolId) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;
@@ -19,7 +19,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
 }
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, object_id_t poolOwner,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode) {
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;

From 6f955ed8bad01074039de13e54b7534b248706c0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 16 Oct 2020 00:42:49 +0200
Subject: [PATCH 0930/1774] another bugfix

---
 datapoollocal/LocalPoolObjectBase.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 6494a2228..880271695 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -2,7 +2,8 @@
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
         HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
-        pool_rwm_t setReadWriteMode): localPoolId(poolId) {
+        pool_rwm_t setReadWriteMode): localPoolId(poolId),
+        readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;
@@ -19,7 +20,8 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
 }
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, object_id_t poolOwner,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId) {
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
+        readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;

From 9a70f75a4bf043292f213b4791364a8183267fef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 16 Oct 2020 01:45:07 +0200
Subject: [PATCH 0931/1774] returnvalues added

---
 memory/HasFileSystemIF.h | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 7ab4cc4ef..20ef727eb 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -16,12 +16,15 @@ public:
 
     static constexpr ReturnValue_t FILE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x00);
     static constexpr ReturnValue_t FILE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+    static constexpr ReturnValue_t FILE_LOCKED = MAKE_RETURN_CODE(0x02);
 
-    static constexpr ReturnValue_t DIRECTORY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
-    static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x03);
-    static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(0x04);
+    static constexpr ReturnValue_t DIRECTORY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+    static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x04);
+    static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(0x05);
 
-    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING = MAKE_RETURN_CODE(0x05);
+
+    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_WRITE = MAKE_RETURN_CODE(0x06); //! P1: Sequence number missing
+    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_READ = MAKE_RETURN_CODE(0x07); //! P1: Sequence number missing
 
 	virtual ~HasFileSystemIF() {}
 	/**

From 02b7c51318f096447703d6845365aa568d280e03 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 18 Oct 2020 16:54:55 +0200
Subject: [PATCH 0932/1774] HasParametersIF less confusing

---
 datapoolglob/DataPoolAdmin.cpp  |  4 ++--
 parameters/HasParametersIF.h    | 40 +++++++++++++++++++++------------
 parameters/ParameterHelper.cpp  | 17 +++++++-------
 parameters/ParameterWrapper.cpp | 24 ++++++++++++++++----
 parameters/ParameterWrapper.h   |  7 ++++++
 power/PowerComponent.cpp        |  1 +
 6 files changed, 64 insertions(+), 29 deletions(-)

diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 6ede0841e..65ecdb16e 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -194,7 +194,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 	case ParameterMessage::CMD_PARAMETER_DUMP: {
 		uint8_t domain = HasParametersIF::getDomain(
 				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
+		uint16_t parameterId = HasParametersIF::getUniqueIdentifierId(
 				ParameterMessage::getParameterId(command));
 
 		DataPoolParameterWrapper wrapper;
@@ -210,7 +210,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 
 		uint8_t domain = HasParametersIF::getDomain(
 				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
+		uint16_t parameterId = HasParametersIF::getUniqueIdentifierId(
 				ParameterMessage::getParameterId(command));
 		uint8_t index = HasParametersIF::getIndex(
 				ParameterMessage::getParameterId(command));
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 005403fa5..286dcbc66 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -1,12 +1,16 @@
 #ifndef FSFW_PARAMETERS_HASPARAMETERSIF_H_
 #define FSFW_PARAMETERS_HASPARAMETERSIF_H_
 
-#include "../parameters/ParameterWrapper.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
+#include "ParameterWrapper.h"
+#include <cstdint>
 
-/** Each parameter is identified with a unique parameter ID */
-typedef uint32_t ParameterId_t;
+/**
+ * Each parameter is identified with a unique parameter ID
+ * The first byte of the parameter ID will denote the domain ID.
+ * The second and third byte will be the unique identifier number.
+ */
+using ParameterId_t = uint32_t;
 
 /**
  * @brief	This interface is used by components which have modifiable
@@ -19,7 +23,7 @@ typedef uint32_t ParameterId_t;
  * 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
+ * Yeah, is it matrix ID or parameter ID now and is index a 16 bit number
  * of a 8 bit number now?
  */
 class HasParametersIF {
@@ -34,17 +38,24 @@ public:
 		return id >> 24;
 	}
 
-	static uint16_t getMatrixId(ParameterId_t id) {
-		return id >> 8;
+	static uint8_t getUniqueIdentifierId(ParameterId_t id) {
+		return id >> 16;
 	}
 
-	static uint8_t getIndex(ParameterId_t id) {
+	/**
+	 * Get the index of a parameter. Please note that the index is always a
+	 * linear index. For a vector, this is straightforward.
+	 * For a matrix, the linear indexing run from left to right, top to bottom.
+	 * @param id
+	 * @return
+	 */
+	static uint16_t getIndex(ParameterId_t id) {
 		return id;
 	}
 
-	static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
-			uint8_t index) {
-		return (domainId << 24) + (parameterId << 8) + index;
+	static uint32_t getFullParameterId(uint8_t domainId,
+	        uint8_t uniqueIdentifier, uint16_t linearIndex) {
+		return (domainId << 24) + (uniqueIdentifier << 16) + linearIndex;
 	}
 
 	virtual ~HasParametersIF() {}
@@ -56,11 +67,12 @@ public:
 	 * @param parameterId
 	 * @param parameterWrapper
 	 * @param newValues
-	 * @param startAtIndex
+	 * @param startAtIndex Linear index, runs left to right, top to bottom for
+	 * matrix indexes.
 	 * @return
 	 */
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
+	virtual ReturnValue_t getParameter(uint8_t domainId,
+	        uint16_t uniqueIdentifier, ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
 };
 
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 659b00def..109ef5562 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -15,9 +15,9 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 		ParameterWrapper description;
 		uint8_t domain = HasParametersIF::getDomain(
 				ParameterMessage::getParameterId(message));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
+		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
 				ParameterMessage::getParameterId(message));
-		result = owner->getParameter(domain, parameterId,
+		result = owner->getParameter(domain, uniqueIdentifier,
 				&description, &description, 0);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			result = sendParameter(message->getSender(),
@@ -26,12 +26,11 @@ 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(
-				ParameterMessage::getParameterId(message));
-		uint8_t index = HasParametersIF::getIndex(
-				ParameterMessage::getParameterId(message));
+	    ParameterId_t parameterId = ParameterMessage::getParameterId(message);
+		uint8_t domain = HasParametersIF::getDomain(parameterId);
+		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
+		        parameterId);
+		uint16_t index = HasParametersIF::getIndex(parameterId);
 
 		const uint8_t *storedStream = nullptr;
 		size_t storedStreamSize = 0;
@@ -52,7 +51,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 		}
 
 		ParameterWrapper ownerWrapper;
-		result = owner->getParameter(domain, parameterId, &ownerWrapper,
+		result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
 				&streamWrapper, index);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			storage->deleteData(ParameterMessage::getStoreId(message));
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 6adc6857c..76c80887e 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -202,11 +202,11 @@ ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
 
 ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		uint16_t startWritingAtIndex) {
-	if (data == NULL) {
+	if (data == nullptr) {
 		return READONLY;
 	}
 
-	if (from->readonlyData == NULL) {
+	if (from->readonlyData == nullptr) {
 		return SOURCE_NOT_SET;
 	}
 
@@ -215,8 +215,10 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 	}
 
 	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
+	uint8_t startingRow = 0;
+	uint8_t startingColumn = 0;
+	ParameterWrapper::convertLinearIndexToRowAndColumn(startWritingAtIndex,
+	        &startingRow, &startingColumn);
 
 	if ((from->rows > (rows - startingRow))
 			|| (from->columns > (columns - startingColumn))) {
@@ -279,3 +281,17 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 
 	return result;
 }
+
+void ParameterWrapper::convertLinearIndexToRowAndColumn(uint16_t index, uint8_t *row,
+        uint8_t *column) {
+    if(row == nullptr or column == nullptr) {
+        return;
+    }
+    *row = index / columns;
+    *column = index % columns;
+}
+
+uint16_t ParameterWrapper::convertRowAndColumnToLinearIndex(uint8_t row,
+        uint8_t column) {
+    return row * columns + column;
+}
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index f07205d4b..7a9145b4e 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -113,6 +113,13 @@ public:
 			uint16_t startWritingAtIndex);
 
 private:
+
+    void convertLinearIndexToRowAndColumn(uint16_t index,
+            uint8_t *row, uint8_t *column);
+
+    uint16_t convertRowAndColumnToLinearIndex(uint8_t row,
+            uint8_t column);
+
 	bool pointsToStream = false;
 
 	Type type;
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 4af7c96b5..f42c3153a 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -1,4 +1,5 @@
 #include "PowerComponent.h"
+#include "../serialize/SerializeAdapter.h"
 
 PowerComponent::PowerComponent(): switchId1(0xFF), switchId2(0xFF),
         doIHaveTwoSwitches(false) {

From 3b0b474ab6e5586cd81c4950d9af1b61f7c07518 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 18 Oct 2020 17:01:49 +0200
Subject: [PATCH 0933/1774] better naming

---
 parameters/ParameterHelper.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 109ef5562..a3b615f88 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -30,7 +30,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 		uint8_t domain = HasParametersIF::getDomain(parameterId);
 		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
 		        parameterId);
-		uint16_t index = HasParametersIF::getIndex(parameterId);
+		uint16_t linearIndex = HasParametersIF::getIndex(parameterId);
 
 		const uint8_t *storedStream = nullptr;
 		size_t storedStreamSize = 0;
@@ -52,13 +52,13 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 
 		ParameterWrapper ownerWrapper;
 		result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
-				&streamWrapper, index);
+				&streamWrapper, linearIndex);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			storage->deleteData(ParameterMessage::getStoreId(message));
 			break;
 		}
 
-		result = ownerWrapper.copyFrom(&streamWrapper, index);
+		result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
 
 		storage->deleteData(ParameterMessage::getStoreId(message));
 

From 8e498060571c89c06574f1a9aec381fb3290f886 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 18 Oct 2020 17:23:47 +0200
Subject: [PATCH 0934/1774] some adaptions

---
 parameters/ParameterMessage.cpp | 8 ++++++--
 parameters/ParameterMessage.h   | 3 ++-
 parameters/ParameterWrapper.h   | 6 ++++--
 3 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp
index e9f3191fc..81bed8718 100644
--- a/parameters/ParameterMessage.cpp
+++ b/parameters/ParameterMessage.cpp
@@ -25,10 +25,14 @@ void ParameterMessage::setParameterDumpReply(CommandMessage* message,
 }
 
 void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
-		ParameterId_t id, store_address_t storageID) {
+		ParameterId_t id, store_address_t storeId, uint8_t ptc, uint8_t pfc,
+		uint8_t row, uint8_t column) {
 	message->setCommand(CMD_PARAMETER_LOAD);
 	message->setParameter(id);
-	message->setParameter2(storageID.raw);
+	message->setParameter2(storeId.raw);
+	uint32_t packedParameterSettings = (ptc << 24) | (pfc << 16) |
+	        (row << 8) | column;
+	message->setParameter3(packedParameterSettings);
 }
 
 void ParameterMessage::clear(CommandMessage* message) {
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 31d7fe0bc..6eb9ed8e7 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -21,7 +21,8 @@ public:
 	static void setParameterDumpReply(CommandMessage* message,
 			ParameterId_t id,  store_address_t storageID);
 	static void setParameterLoadCommand(CommandMessage* message,
-			ParameterId_t id, store_address_t storageID);
+	        ParameterId_t id, store_address_t storeId, uint8_t ptc,
+	        uint8_t pfc, uint8_t row, uint8_t column);
 	static void clear(CommandMessage* message);
 
 };
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 7a9145b4e..75f7af9bc 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -97,12 +97,14 @@ public:
 	}
 	template<typename T>
 	void setMatrix(T& member) {
-		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+		this->set(member[0], sizeof(member)/sizeof(member[0]),
+		        sizeof(member[0])/sizeof(member[0][0]));
 	}
 
 	template<typename T>
 	void setMatrix(const T& member) {
-		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+		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,

From 88a89d6797a22c108d2841a1f7c835edf55afcec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 18 Oct 2020 17:32:10 +0200
Subject: [PATCH 0935/1774] added basic documentation

---
 parameters/ParameterMessage.h | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 6eb9ed8e7..8e6e3f8e9 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -20,6 +20,19 @@ public:
 			ParameterId_t id);
 	static void setParameterDumpReply(CommandMessage* message,
 			ParameterId_t id,  store_address_t storageID);
+
+	/**
+	 * Command to set a load parameter message. The CCSDS / ECSS type in
+	 * form of a PTC and a PFC is expected. See ECSS-E-ST-70-41C15 p.428
+	 * for all types or the Type class in globalfunctions.
+	 * @param message
+	 * @param id
+	 * @param storeId
+	 * @param ptc
+	 * @param pfc
+	 * @param row
+	 * @param column
+	 */
 	static void setParameterLoadCommand(CommandMessage* message,
 	        ParameterId_t id, store_address_t storeId, uint8_t ptc,
 	        uint8_t pfc, uint8_t row, uint8_t column);

From 8b8324f21c1b0d30ba1c5ef7919846bfeb283e62 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 18 Oct 2020 23:50:02 +0200
Subject: [PATCH 0936/1774] some stuff renamed

---
 datapoolglob/DataPoolParameterWrapper.cpp | 2 +-
 fdir/FaultCounter.cpp                     | 2 +-
 monitoring/AbsLimitMonitor.h              | 4 ++--
 monitoring/LimitMonitor.h                 | 4 ++--
 monitoring/MonitorReporter.h              | 2 +-
 monitoring/TriplexMonitor.h               | 2 +-
 parameters/HasParametersIF.h              | 2 +-
 power/PowerComponent.cpp                  | 2 +-
 thermal/CoreComponent.cpp                 | 2 +-
 thermal/Heater.cpp                        | 2 +-
 thermal/TemperatureSensor.h               | 2 +-
 thermal/ThermalComponent.cpp              | 4 ++--
 12 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/datapoolglob/DataPoolParameterWrapper.cpp b/datapoolglob/DataPoolParameterWrapper.cpp
index 3a57d90df..e5d55006d 100644
--- a/datapoolglob/DataPoolParameterWrapper.cpp
+++ b/datapoolglob/DataPoolParameterWrapper.cpp
@@ -23,7 +23,7 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 	ReturnValue_t status = mySet.read();
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		//should only fail for invalid pool id
-		return HasParametersIF::INVALID_MATRIX_ID;
+		return HasParametersIF::INVALID_IDENTIFIER_ID;
 	}
 
 	type = raw.getType();
diff --git a/fdir/FaultCounter.cpp b/fdir/FaultCounter.cpp
index 443adb52e..6519a3a88 100644
--- a/fdir/FaultCounter.cpp
+++ b/fdir/FaultCounter.cpp
@@ -76,7 +76,7 @@ ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
 		parameterWrapper->set(timer.timeout);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index c9c33c74b..5891c36af 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -39,7 +39,7 @@ public:
 				parameterId, parameterWrapper, newValues, startAtIndex);
 		// We'll reuse the DOMAIN_ID of MonitorReporter,
 		// as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
+		if (result != this->INVALID_IDENTIFIER_ID) {
 			return result;
 		}
 		switch (parameterId) {
@@ -47,7 +47,7 @@ public:
 			parameterWrapper->set(this->limit);
 			break;
 		default:
-			return this->INVALID_MATRIX_ID;
+			return this->INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index 66e6725e8..abcbe8e8b 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -41,7 +41,7 @@ public:
 		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
 				parameterId, parameterWrapper, newValues, startAtIndex);
 		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
+		if (result != this->INVALID_IDENTIFIER_ID) {
 			return result;
 		}
 		switch (parameterId) {
@@ -52,7 +52,7 @@ public:
 			parameterWrapper->set(this->upperLimit);
 			break;
 		default:
-			return this->INVALID_MATRIX_ID;
+			return this->INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 88fa6ede5..286d82cfe 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -65,7 +65,7 @@ public:
 			parameterWrapper->set(this->eventEnabled);
 			break;
 		default:
-			return INVALID_MATRIX_ID;
+			return INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/monitoring/TriplexMonitor.h b/monitoring/TriplexMonitor.h
index 9b60aeb63..c4b3c5375 100644
--- a/monitoring/TriplexMonitor.h
+++ b/monitoring/TriplexMonitor.h
@@ -82,7 +82,7 @@ public:
 			parameterWrapper->set(limit);
 			break;
 		default:
-			return INVALID_MATRIX_ID;
+			return INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 286dcbc66..c4fd81b34 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -29,7 +29,7 @@ using ParameterId_t = uint32_t;
 class HasParametersIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_PARAMETERS_IF;
-	static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t INVALID_IDENTIFIER_ID = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
 	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
 	static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index f42c3153a..c31b9a85e 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -75,7 +75,7 @@ ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
 		parameterWrapper->set<>(max);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/thermal/CoreComponent.cpp b/thermal/CoreComponent.cpp
index 657e79cb0..90d10eda0 100644
--- a/thermal/CoreComponent.cpp
+++ b/thermal/CoreComponent.cpp
@@ -251,7 +251,7 @@ ReturnValue_t CoreComponent::getParameter(uint8_t domainId,
 		parameterWrapper->set(parameters.upperOpLimit);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index 2bee47f1c..ce965d5ea 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -301,7 +301,7 @@ ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
 		parameterWrapper->set(heaterOnCountdown.timeout);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 9b4f0e605..f41b3761b 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -208,7 +208,7 @@ public:
 			parameterWrapper->set(parameters.gradient);
 			break;
 		default:
-			return INVALID_MATRIX_ID;
+			return INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 50786654b..6bc09e557 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -151,7 +151,7 @@ ReturnValue_t ThermalComponent::getParameter(uint8_t domainId,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
 	ReturnValue_t result = CoreComponent::getParameter(domainId, parameterId,
 			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_MATRIX_ID) {
+	if (result != INVALID_IDENTIFIER_ID) {
 		return result;
 	}
 	switch (parameterId) {
@@ -162,7 +162,7 @@ ReturnValue_t ThermalComponent::getParameter(uint8_t domainId,
 		parameterWrapper->set(nopParameters.upperNopLimit);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }

From ad9ac7537e150150679a4104b915836f8cc0f248 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 19 Oct 2020 00:25:03 +0200
Subject: [PATCH 0937/1774] bool is mapped to uint8 now for pod type conversion

---
 globalfunctions/Type.h         |  4 ++++
 parameters/ParameterHelper.cpp | 18 ++++++++++--------
 parameters/ParameterWrapper.h  |  2 +-
 3 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 6910f9091..8d03c4677 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -59,6 +59,10 @@ struct PodTypeConversion {
 	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
 };
 template<>
+struct PodTypeConversion<bool> {
+    static const Type::ActualType_t type = Type::UINT8_T;
+};
+template<>
 struct PodTypeConversion<uint8_t> {
 	static const Type::ActualType_t type = Type::UINT8_T;
 };
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index a3b615f88..e2ea4eb64 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -9,6 +9,10 @@ ParameterHelper::~ParameterHelper() {
 }
 
 ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
+    if(storage == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	switch (message->getCommand()) {
 	case ParameterMessage::CMD_PARAMETER_DUMP: {
@@ -112,15 +116,13 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 }
 
 ReturnValue_t ParameterHelper::initialize() {
-	ownerQueueId = owner->getCommandQueue();
+    ownerQueueId = owner->getCommandQueue();
 
-
-	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (storage == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	} else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if (storage == nullptr) {
+        return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 75f7af9bc..e0a2d27e1 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -68,7 +68,7 @@ public:
 
 	template<typename T>
 	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
-		this->data = NULL;
+		this->data = nullptr;
 		this->readonlyData = readonlyData;
 		this->type = PodTypeConversion<T>::type;
 		this->rows = rows;

From 75e67ce5f8e1383796de2c0c9f7754456d011625 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 19 Oct 2020 00:37:26 +0200
Subject: [PATCH 0938/1774] small form improvements

---
 parameters/ParameterWrapper.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 76c80887e..e78c52bed 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -115,7 +115,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 		uint8_t fromColumns) {
 
 	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t*) from;
+	const uint8_t *fromAsStream = reinterpret_cast<const uint8_t*>(from);
 	size_t streamSize = fromRows * fromColumns * sizeof(T);
 
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
@@ -123,8 +123,8 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
 		//get the start element of this row in data
-		T *dataWithDataType = ((T*) data)
-				+ (((startingRow + fromRow) * columns) + startingColumn);
+	    uint16_t offset = (((startingRow + fromRow) * columns) + startingColumn);
+		T *dataWithDataType = static_cast<T*>(data) + offset;
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
 			result = SerializeAdapter::deSerialize(

From 22e4e464c79fe2924c3a2a88948b0b17c31dab9a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 19 Oct 2020 00:43:10 +0200
Subject: [PATCH 0939/1774] doc improved, new returnvalue

---
 parameters/ParameterMessage.cpp |  4 ++--
 parameters/ParameterMessage.h   | 10 +++++-----
 parameters/ParameterWrapper.cpp |  7 +++++++
 parameters/ParameterWrapper.h   |  1 +
 4 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp
index 81bed8718..4a8545ebd 100644
--- a/parameters/ParameterMessage.cpp
+++ b/parameters/ParameterMessage.cpp
@@ -26,12 +26,12 @@ void ParameterMessage::setParameterDumpReply(CommandMessage* message,
 
 void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
 		ParameterId_t id, store_address_t storeId, uint8_t ptc, uint8_t pfc,
-		uint8_t row, uint8_t column) {
+		uint8_t rows = 1, uint8_t columns = 1) {
 	message->setCommand(CMD_PARAMETER_LOAD);
 	message->setParameter(id);
 	message->setParameter2(storeId.raw);
 	uint32_t packedParameterSettings = (ptc << 24) | (pfc << 16) |
-	        (row << 8) | column;
+	        (rows << 8) | columns;
 	message->setParameter3(packedParameterSettings);
 }
 
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 8e6e3f8e9..c87c508cd 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -28,14 +28,14 @@ public:
 	 * @param message
 	 * @param id
 	 * @param storeId
-	 * @param ptc
-	 * @param pfc
-	 * @param row
-	 * @param column
+	 * @param ptc Type information according to CCSDS/ECSS standards
+	 * @param pfc Type information according to CCSDS/ECSS standards
+	 * @param rows Set number of rows in parameter set, minimum one.
+	 * @param columns Set number of columns in parameter set, minimum one
 	 */
 	static void setParameterLoadCommand(CommandMessage* message,
 	        ParameterId_t id, store_address_t storeId, uint8_t ptc,
-	        uint8_t pfc, uint8_t row, uint8_t column);
+	        uint8_t pfc, uint8_t rows, uint8_t columns);
 	static void clear(CommandMessage* message);
 
 };
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index e78c52bed..17fb3153c 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -202,6 +202,8 @@ ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
 
 ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		uint16_t startWritingAtIndex) {
+    // TODO: Optional diagnostic output (which can be disabled in FSFWConfig)
+    // to determined faulty implementations and configuration errors quickly.
 	if (data == nullptr) {
 		return READONLY;
 	}
@@ -214,6 +216,11 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		return DATATYPE_MISSMATCH;
 	}
 
+	// The smallest allowed value for rows and columns is one.
+	if(rows == 0 or columns == 0) {
+	    return COLUMN_OR_ROWS_ZERO;
+	}
+
 	//check if from fits into this
 	uint8_t startingRow = 0;
 	uint8_t startingColumn = 0;
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index e0a2d27e1..46044f25e 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -22,6 +22,7 @@ public:
 	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
 	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
 	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
+	static const ReturnValue_t COLUMN_OR_ROWS_ZERO = MAKE_RETURN_CODE(0x08);
 
 	ParameterWrapper();
 	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);

From 95924dd55bf9d6f1f8231fd16b8b3a54871caf32 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 19 Oct 2020 15:38:22 +0200
Subject: [PATCH 0940/1774] some more bugfixes

---
 datapoolglob/DataPoolAdmin.cpp  |  4 +--
 parameters/ParameterHelper.cpp  | 45 +++++++++++++++++----------------
 parameters/ParameterMessage.cpp | 12 +++++++++
 parameters/ParameterMessage.h   | 19 ++++++++++++++
 parameters/ParameterWrapper.cpp | 22 ++++++++++++++--
 parameters/ParameterWrapper.h   |  7 +++--
 6 files changed, 81 insertions(+), 28 deletions(-)

diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 65ecdb16e..2bae75f09 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -210,9 +210,9 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 
 		uint8_t domain = HasParametersIF::getDomain(
 				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getUniqueIdentifierId(
+		uint8_t parameterId = HasParametersIF::getUniqueIdentifierId(
 				ParameterMessage::getParameterId(command));
-		uint8_t index = HasParametersIF::getIndex(
+		uint16_t index = HasParametersIF::getIndex(
 				ParameterMessage::getParameterId(command));
 
 		const uint8_t *storedStream;
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index e2ea4eb64..d2193b289 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -10,6 +10,7 @@ ParameterHelper::~ParameterHelper() {
 
 ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
     if(storage == nullptr) {
+        // ParameterHelper was not initialized
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
@@ -30,48 +31,48 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 	}
 		break;
 	case ParameterMessage::CMD_PARAMETER_LOAD: {
-	    ParameterId_t parameterId = ParameterMessage::getParameterId(message);
+	    ParameterId_t parameterId = 0;
+	    uint8_t ptc = 0;
+	    uint8_t pfc = 0;
+	    uint8_t rows = 0;
+	    uint8_t columns = 0;
+	    store_address_t storeId = ParameterMessage::getParameterLoadCommand(
+	            message, &parameterId, &ptc, &pfc, &rows, &columns);
+	    Type type(Type::getActualType(ptc, pfc));
+
 		uint8_t domain = HasParametersIF::getDomain(parameterId);
 		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
 		        parameterId);
 		uint16_t linearIndex = HasParametersIF::getIndex(parameterId);
 
-		const uint8_t *storedStream = nullptr;
-		size_t storedStreamSize = 0;
-		result = storage->getData(
-				ParameterMessage::getStoreId(message), &storedStream,
-				&storedStreamSize);
+		ConstStorageAccessor accessor(storeId);
+		result = storage->getData(storeId, accessor);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			sif::error << "ParameterHelper::handleParameterMessage: Getting"
-					" store data failed for load command." << std::endl;
+					<< " store data failed for load command." << std::endl;
 			break;
 		}
 
 		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(storedStream, storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
+		result = streamWrapper.set(type, rows, columns, accessor.data(),
+		        accessor.size());
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+		    return result;
 		}
 
 		ParameterWrapper ownerWrapper;
 		result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
 				&streamWrapper, linearIndex);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
-		}
 
 		result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
-
-		storage->deleteData(ParameterMessage::getStoreId(message));
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &ownerWrapper);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+		    return result;
 		}
-	}
+
+        result = sendParameter(message->getSender(),
+                ParameterMessage::getParameterId(message), &ownerWrapper);
 		break;
+	}
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp
index 4a8545ebd..af1f9ce83 100644
--- a/parameters/ParameterMessage.cpp
+++ b/parameters/ParameterMessage.cpp
@@ -35,6 +35,18 @@ void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
 	message->setParameter3(packedParameterSettings);
 }
 
+store_address_t ParameterMessage::getParameterLoadCommand(
+        const CommandMessage *message, ParameterId_t* parameterId, uint8_t *ptc,
+        uint8_t *pfc, uint8_t *rows, uint8_t *columns) {
+    *parameterId = message->getParameter2();
+    uint32_t packedParamSettings = message->getParameter3();
+    *ptc = packedParamSettings >> 24 & 0xff;
+    *pfc = packedParamSettings >> 16 & 0xff;
+    *rows = packedParamSettings >> 8 & 0xff;
+    *columns = packedParamSettings & 0xff;
+    return message->getParameter2();
+}
+
 void ParameterMessage::clear(CommandMessage* message) {
 	switch (message->getCommand()) {
 	case CMD_PARAMETER_LOAD:
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index c87c508cd..fd4481eec 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -5,6 +5,20 @@
 #include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
 
+/**
+ * @brief   ParameterMessage interface
+ * @details
+ * General structure of a parameter message:
+ *  1. 4-byte Object ID
+ *  2. 4-byte Parameter ID, first byte is Domain ID, second byte is unique
+ *     identifier, third and fourth byte is linear index to start from
+ *  3. 4-byte Parameter Settings. First byte and second byte are the PTC and PFC
+ *     ECSS type identifiers (see ECSS-E-ST-70-41C15 p.428 or Type class in
+ *     globalfunctions). Third byte is the number of rows and fourth byte
+ *     is the number of columns. For single variable parameters, this will
+ *     be [1, 1].
+ *
+ */
 class ParameterMessage {
 private:
 	ParameterMessage();
@@ -36,6 +50,11 @@ public:
 	static void setParameterLoadCommand(CommandMessage* message,
 	        ParameterId_t id, store_address_t storeId, uint8_t ptc,
 	        uint8_t pfc, uint8_t rows, uint8_t columns);
+
+	static store_address_t getParameterLoadCommand(
+	        const CommandMessage* message, ParameterId_t* parameterId,
+	        uint8_t* ptc, uint8_t* pfc, uint8_t* rows, uint8_t* columns) ;
+
 	static void clear(CommandMessage* message);
 
 };
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 17fb3153c..239555162 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -159,6 +159,23 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
 	return copyFrom(&streamDescription, startWritingAtIndex);
 }
 
+ReturnValue_t ParameterWrapper::set(Type type, uint8_t rows, uint8_t columns,
+        const void *data, size_t dataSize) {
+    this->type = type;
+    this->rows = rows;
+    this->columns = columns;
+
+    size_t expectedSize = type.getSize() * rows * columns;
+    if (expectedSize < dataSize) {
+        return SerializeIF::STREAM_TOO_SHORT;
+    }
+
+    this->data = nullptr;
+    this->readonlyData = data;
+    pointsToStream = true;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
 		const uint8_t **remainingStream, size_t *remainingSize) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
@@ -289,11 +306,12 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 	return result;
 }
 
-void ParameterWrapper::convertLinearIndexToRowAndColumn(uint16_t index, uint8_t *row,
-        uint8_t *column) {
+void ParameterWrapper::convertLinearIndexToRowAndColumn(uint16_t index,
+        uint8_t *row, uint8_t *column) {
     if(row == nullptr or column == nullptr) {
         return;
     }
+    // Integer division.
     *row = index / columns;
     *column = index % columns;
 }
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 46044f25e..168a535f2 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -108,6 +108,9 @@ public:
 		        sizeof(member[0])/sizeof(member[0][0]));
 	}
 
+	ReturnValue_t set(Type type, uint8_t rows, uint8_t columns,
+	        const void *data, size_t dataSize);
+
 	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
 			const uint8_t **remainingStream = nullptr,
 			size_t *remainingSize = nullptr);
@@ -158,9 +161,9 @@ inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
 	if (pointsToStream) {
 		const uint8_t *streamWithType = static_cast<const uint8_t*>(readonlyData);
 		streamWithType += (row * columns + column) * type.getSize();
-		int32_t size = type.getSize();
+		size_t size = type.getSize();
 		return SerializeAdapter::deSerialize(value, &streamWithType,
-				&size, true);
+				&size, SerializeIF::Endianness::BIG);
 	}
 	else {
 		const T *dataWithType = static_cast<const T*>(readonlyData);

From 7033328962e8997e1757b5ca0999a89a9d04c7fc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 20 Oct 2020 17:12:56 +0200
Subject: [PATCH 0941/1774] unittest folder added

---
 unittest/Makefile-FSFW-Tests                  |   415 +
 unittest/README.md                            |   121 +
 unittest/catch2/LICENSE.txt                   |    23 +
 unittest/catch2/catch.hpp                     | 17618 ++++++++++++++++
 unittest/catch2/catch_reporter_automake.hpp   |    62 +
 unittest/catch2/catch_reporter_sonarqube.hpp  |   181 +
 unittest/catch2/catch_reporter_tap.hpp        |   253 +
 unittest/catch2/catch_reporter_teamcity.hpp   |   219 +
 unittest/config/FSFWConfig.h                  |    32 +
 unittest/config/TestsConfig.h                 |     8 +
 unittest/config/cdatapool/dataPoolInit.cpp    |    48 +
 unittest/config/cdatapool/dataPoolInit.h      |    29 +
 unittest/config/config.mk                     |    15 +
 unittest/config/devices/logicalAddresses.cpp  |    11 +
 unittest/config/devices/logicalAddresses.h    |    15 +
 unittest/config/devices/powerSwitcherList.cpp |    10 +
 unittest/config/devices/powerSwitcherList.h   |    22 +
 unittest/config/events/translateEvents.cpp    |    20 +
 unittest/config/events/translateEvents.h      |    16 +
 unittest/config/ipc/MissionMessageTypes.cpp   |    11 +
 unittest/config/ipc/MissionMessageTypes.h     |    22 +
 unittest/config/objects/Factory.cpp           |    37 +
 unittest/config/objects/Factory.h             |    16 +
 unittest/config/objects/systemObjectList.h    |    30 +
 unittest/config/objects/translateObjects.cpp  |   242 +
 unittest/config/objects/translateObjects.h    |    16 +
 .../PollingSequenceFactory.cpp                |    31 +
 .../pollingsequence/PollingSequenceFactory.h  |    31 +
 unittest/config/returnvalues/classIds.h       |    28 +
 unittest/config/tmtc/PusIds.hpp               |    29 +
 unittest/config/tmtc/apid.h                   |    19 +
 unittest/config/tmtc/pusIds.h                 |    23 +
 unittest/config/tmtc/subsystemIdRanges.h      |    34 +
 unittest/config/tmtc/tmTcSize.h               |    10 +
 unittest/config/version.h                     |     7 +
 unittest/core/CatchDefinitions.cpp            |    11 +
 unittest/core/CatchDefinitions.h              |    19 +
 unittest/core/CatchRunner.cpp                 |    27 +
 unittest/core/CatchSetup.cpp                  |    41 +
 unittest/core/core.mk                         |     3 +
 unittest/core/printChar.cpp                   |    10 +
 unittest/core/printChar.h                     |     8 +
 unittest/internal/InternalUnitTester.cpp      |    26 +
 unittest/internal/InternalUnitTester.h        |    29 +
 unittest/internal/UnittDefinitions.cpp        |     7 +
 unittest/internal/UnittDefinitions.h          |    33 +
 unittest/internal/osal/IntTestMq.cpp          |    52 +
 unittest/internal/osal/IntTestMq.h            |     9 +
 unittest/internal/osal/IntTestMutex.cpp       |    41 +
 unittest/internal/osal/IntTestMutex.h         |    10 +
 unittest/internal/osal/IntTestSemaphore.cpp   |   159 +
 unittest/internal/osal/IntTestSemaphore.h     |    15 +
 .../serialize/IntTestSerialization.cpp        |   230 +
 .../internal/serialize/IntTestSerialization.h |    15 +
 unittest/lcov.sh                              |     3 +
 unittest/tests/action/TestActionHelper.cpp    |   105 +
 unittest/tests/action/TestActionHelper.h      |   131 +
 unittest/tests/container/RingBufferTest.cpp   |   327 +
 unittest/tests/container/TestArrayList.cpp    |    90 +
 unittest/tests/container/TestDynamicFifo.cpp  |   149 +
 unittest/tests/container/TestFifo.cpp         |   138 +
 .../tests/container/TestFixedArrayList.cpp    |    41 +
 unittest/tests/container/TestFixedMap.cpp     |   172 +
 .../container/TestFixedOrderedMultimap.cpp    |   203 +
 .../tests/container/TestPlacementFactory.cpp  |    45 +
 unittest/tests/osal/TestMessageQueue.cpp      |    40 +
 unittest/tests/osal/TestSemaphore.cpp         |    46 +
 .../serialize/TestSerialBufferAdapter.cpp     |   143 +
 .../serialize/TestSerialLinkedPacket.cpp      |    73 +
 .../tests/serialize/TestSerialLinkedPacket.h  |    61 +
 .../tests/serialize/TestSerialization.cpp     |   129 +
 .../tests/storagemanager/TestNewAccessor.cpp  |   161 +
 unittest/tests/storagemanager/TestPool.cpp    |   105 +
 unittest/tests/tests.mk                       |     8 +
 unittest/testtemplate/TestTemplate.cpp        |    31 +
 unittest/unlockRealtime.sh                    |    34 +
 76 files changed, 22684 insertions(+)
 create mode 100644 unittest/Makefile-FSFW-Tests
 create mode 100644 unittest/README.md
 create mode 100644 unittest/catch2/LICENSE.txt
 create mode 100644 unittest/catch2/catch.hpp
 create mode 100644 unittest/catch2/catch_reporter_automake.hpp
 create mode 100644 unittest/catch2/catch_reporter_sonarqube.hpp
 create mode 100644 unittest/catch2/catch_reporter_tap.hpp
 create mode 100644 unittest/catch2/catch_reporter_teamcity.hpp
 create mode 100644 unittest/config/FSFWConfig.h
 create mode 100644 unittest/config/TestsConfig.h
 create mode 100644 unittest/config/cdatapool/dataPoolInit.cpp
 create mode 100644 unittest/config/cdatapool/dataPoolInit.h
 create mode 100644 unittest/config/config.mk
 create mode 100644 unittest/config/devices/logicalAddresses.cpp
 create mode 100644 unittest/config/devices/logicalAddresses.h
 create mode 100644 unittest/config/devices/powerSwitcherList.cpp
 create mode 100644 unittest/config/devices/powerSwitcherList.h
 create mode 100644 unittest/config/events/translateEvents.cpp
 create mode 100644 unittest/config/events/translateEvents.h
 create mode 100644 unittest/config/ipc/MissionMessageTypes.cpp
 create mode 100644 unittest/config/ipc/MissionMessageTypes.h
 create mode 100644 unittest/config/objects/Factory.cpp
 create mode 100644 unittest/config/objects/Factory.h
 create mode 100644 unittest/config/objects/systemObjectList.h
 create mode 100644 unittest/config/objects/translateObjects.cpp
 create mode 100644 unittest/config/objects/translateObjects.h
 create mode 100644 unittest/config/pollingsequence/PollingSequenceFactory.cpp
 create mode 100644 unittest/config/pollingsequence/PollingSequenceFactory.h
 create mode 100644 unittest/config/returnvalues/classIds.h
 create mode 100644 unittest/config/tmtc/PusIds.hpp
 create mode 100644 unittest/config/tmtc/apid.h
 create mode 100644 unittest/config/tmtc/pusIds.h
 create mode 100644 unittest/config/tmtc/subsystemIdRanges.h
 create mode 100644 unittest/config/tmtc/tmTcSize.h
 create mode 100644 unittest/config/version.h
 create mode 100644 unittest/core/CatchDefinitions.cpp
 create mode 100644 unittest/core/CatchDefinitions.h
 create mode 100644 unittest/core/CatchRunner.cpp
 create mode 100644 unittest/core/CatchSetup.cpp
 create mode 100644 unittest/core/core.mk
 create mode 100644 unittest/core/printChar.cpp
 create mode 100644 unittest/core/printChar.h
 create mode 100644 unittest/internal/InternalUnitTester.cpp
 create mode 100644 unittest/internal/InternalUnitTester.h
 create mode 100644 unittest/internal/UnittDefinitions.cpp
 create mode 100644 unittest/internal/UnittDefinitions.h
 create mode 100644 unittest/internal/osal/IntTestMq.cpp
 create mode 100644 unittest/internal/osal/IntTestMq.h
 create mode 100644 unittest/internal/osal/IntTestMutex.cpp
 create mode 100644 unittest/internal/osal/IntTestMutex.h
 create mode 100644 unittest/internal/osal/IntTestSemaphore.cpp
 create mode 100644 unittest/internal/osal/IntTestSemaphore.h
 create mode 100644 unittest/internal/serialize/IntTestSerialization.cpp
 create mode 100644 unittest/internal/serialize/IntTestSerialization.h
 create mode 100644 unittest/lcov.sh
 create mode 100644 unittest/tests/action/TestActionHelper.cpp
 create mode 100644 unittest/tests/action/TestActionHelper.h
 create mode 100644 unittest/tests/container/RingBufferTest.cpp
 create mode 100644 unittest/tests/container/TestArrayList.cpp
 create mode 100644 unittest/tests/container/TestDynamicFifo.cpp
 create mode 100644 unittest/tests/container/TestFifo.cpp
 create mode 100644 unittest/tests/container/TestFixedArrayList.cpp
 create mode 100644 unittest/tests/container/TestFixedMap.cpp
 create mode 100644 unittest/tests/container/TestFixedOrderedMultimap.cpp
 create mode 100644 unittest/tests/container/TestPlacementFactory.cpp
 create mode 100644 unittest/tests/osal/TestMessageQueue.cpp
 create mode 100644 unittest/tests/osal/TestSemaphore.cpp
 create mode 100644 unittest/tests/serialize/TestSerialBufferAdapter.cpp
 create mode 100644 unittest/tests/serialize/TestSerialLinkedPacket.cpp
 create mode 100644 unittest/tests/serialize/TestSerialLinkedPacket.h
 create mode 100644 unittest/tests/serialize/TestSerialization.cpp
 create mode 100644 unittest/tests/storagemanager/TestNewAccessor.cpp
 create mode 100644 unittest/tests/storagemanager/TestPool.cpp
 create mode 100644 unittest/tests/tests.mk
 create mode 100644 unittest/testtemplate/TestTemplate.cpp
 create mode 100644 unittest/unlockRealtime.sh

diff --git a/unittest/Makefile-FSFW-Tests b/unittest/Makefile-FSFW-Tests
new file mode 100644
index 000000000..d43a6edcd
--- /dev/null
+++ b/unittest/Makefile-FSFW-Tests
@@ -0,0 +1,415 @@
+#-------------------------------------------------------------------------------
+# Makefile  for FSFW Test
+#-------------------------------------------------------------------------------
+#		User-modifiable options
+#-------------------------------------------------------------------------------
+# Fundamentals on the build process of C/C++ Software:
+# https://www3.ntu.edu.sg/home/ehchua/programming/cpp/gcc_make.html
+
+# Make documentation: https://www.gnu.org/software/make/manual/make.pdf
+# Online: https://www.gnu.org/software/make/manual/make.html
+# General rules: http://make.mad-scientist.net/papers/rules-of-makefiles/#rule3
+SHELL = /bin/sh
+
+# Chip & board used for compilation
+# (can be overriden by adding CHIP=chip and BOARD=board to the command-line)
+# Unit Test can only be run on host machine for now (Linux)
+FRAMEWORK_PATH = fsfw
+FILE_ROOT = $(FRAMEWORK_PATH)/unittest
+BOARD = unittest
+LINUX = 1
+OS_FSFW = linux
+CUSTOM_DEFINES += -D$(OS_FSFW)
+
+# Copied from stackoverflow, can be used to differentiate between Windows
+# and Linux
+ifeq ($(OS),Windows_NT)
+    CUSTOM_DEFINES += -DWIN32
+    ifeq ($(PROCESSOR_ARCHITEW6432),AMD64)
+        CUSTOM_DEFINES += -DAMD64
+    else
+        ifeq ($(PROCESSOR_ARCHITECTURE),AMD64)
+            CUSTOM_DEFINES += -DAMD64
+        endif
+        ifeq ($(PROCESSOR_ARCHITECTURE),x86)
+            CUSTOM_DEFINES += -DIA32
+        endif
+    endif
+else
+    UNAME_S := $(shell uname -s)
+    ifeq ($(UNAME_S),Linux)
+    	DETECTED_OS = LINUX
+        CUSTOM_DEFINES += -DLINUX
+    endif
+    ifeq ($(UNAME_S),Darwin)
+        CUSTOM_DEFINES += -DOSX
+    endif
+    UNAME_P := $(shell uname -p)
+    ifeq ($(UNAME_P),x86_64)
+        CUSTOM_DEFINES += -DAMD64
+    endif
+    ifneq ($(filter %86,$(UNAME_P)),)
+        CUSTOM_DEFINES += -DIA32
+    endif
+    ifneq ($(filter arm%,$(UNAME_P)),)
+        CUSTOM_DEFINES += -DARM
+    endif
+endif
+
+UNIT_TEST = 1
+# General folder paths
+CONFIG_PATH = $(FILE_ROOT)/config
+UNIT_TEST_PATH = $(FILE_ROOT)/tests
+CORE_PATH = $(FILE_ROOT)/core
+
+# Output file basename
+BASENAME = fsfw
+BINARY_NAME := $(BASENAME)-$(BOARD)
+# Output files will be put in this directory inside
+OUTPUT_FOLDER = $(OS)
+
+# Optimization level. Optimized for debugging.
+OPTIMIZATION = -O0
+
+# Default debug output. Optimized for debugging.
+DEBUG_LEVEL = -g3
+
+ifdef GCOV
+CUSTOM_DEFINES += -DGCOV
+endif
+
+
+# Output directories
+BUILDPATH = _bin
+DEPENDPATH = _dep
+OBJECTPATH = _obj
+
+ifeq ($(MAKECMDGOALS),mission)
+BUILD_FOLDER = mission
+else 
+BUILD_FOLDER = devel
+endif
+
+DEPENDDIR = $(DEPENDPATH)/$(OUTPUT_FOLDER)/$(BUILD_FOLDER)
+OBJDIR = $(OBJECTPATH)/$(OUTPUT_FOLDER)/$(BUILD_FOLDER)
+BINDIR = $(BUILDPATH)
+
+CLEANDEP = $(DEPENDPATH)/$(OUTPUT_FOLDER)
+CLEANOBJ = $(OBJECTPATH)/$(OUTPUT_FOLDER)
+CLEANBIN = $(BUILDPATH)
+#-------------------------------------------------------------------------------
+#		Tools and Includes
+#-------------------------------------------------------------------------------
+
+# Tool suffix when cross-compiling
+CROSS_COMPILE =
+
+# C Compiler
+CC = $(CROSS_COMPILE)gcc
+
+# C++ compiler
+CXX = $(CROSS_COMPILE)g++
+
+# Additional Tools
+SIZE = $(CROSS_COMPILE)size
+STRIP = $(CROSS_COMPILE)strip
+CP = $(CROSS_COMPILE)objcopy
+
+HEXCOPY = $(CP) -O ihex
+BINCOPY = $(CP) -O binary
+# files to be compiled, will be filled in by include makefiles
+# := assignment is neccessary so we get all paths right
+# https://www.gnu.org/software/make/manual/html_node/Flavors.html
+CSRC := 
+CXXSRC := 
+ASRC := 
+INCLUDES := 
+
+# Directories where $(directoryname).mk files should be included from
+SUBDIRS :=  $(FRAMEWORK_PATH) $(TEST_PATH) $(UNIT_TEST_PATH) $(CONFIG_PATH) \
+		$(CORE_PATH)
+
+
+I_INCLUDES += $(addprefix -I, $(INCLUDES))
+
+# This is a hack from http://make.mad-scientist.net/the-eval-function/
+#
+# The problem is, that included makefiles should be aware of their relative path
+# but not need to guess or hardcode it. So we set $(CURRENTPATH) for them. If
+# we do this globally and the included makefiles want to include other makefiles as
+# well, they would overwrite $(CURRENTPATH), screwing the include after them.
+#
+# By using a for-loop with an eval'd macro, we can generate the code to include all
+# sub-makefiles (with the correct $(CURRENTPATH) set) before actually evaluating
+# (and by this possibly changing $(CURRENTPATH)) them.
+#
+# This works recursively, if an included makefile wants to include, it can safely set 
+# $(SUBDIRS) (which has already been evaluated here) and do
+# "$(foreach S,$(SUBDIRS),$(eval $(INCLUDE_FILE)))"
+# $(SUBDIRS) must be relative to the project root, so to include subdir foo, set
+# $(SUBDIRS) = $(CURRENTPATH)/foo.
+define INCLUDE_FILE
+CURRENTPATH := $S
+include $(S)/$(notdir $S).mk
+endef
+$(foreach S,$(SUBDIRS),$(eval $(INCLUDE_FILE)))
+
+INCLUDES += $(FILE_ROOT)
+INCLUDES += $(FILE_ROOT)/catch2/
+
+#-------------------------------------------------------------------------------
+#		Source Files
+#-------------------------------------------------------------------------------
+
+# All source files which are not includes by the .mk files are added here
+# Please ensure that no files are included by both .mk file and here !
+
+# if a target is not listed in the current directory, 
+# make searches in the directories specified with VPATH
+
+# All C Sources included by .mk files are assigned here
+# Add the objects to sources so dependency handling works
+C_OBJECTS += $(CSRC:.c=.o)
+
+# Objects built from Assembly source files
+ASM_OBJECTS = $(ASRC:.S=.o)
+
+# Objects built from C++ source files
+CXX_OBJECTS +=  $(CXXSRC:.cpp=.o)
+
+#-------------------------------------------------------------------------------
+#		Build Configuration + Output
+#-------------------------------------------------------------------------------
+
+TARGET = Debug build.
+DEBUG_MESSAGE = Off
+OPTIMIZATION_MESSAGE = Off
+
+# Define Messages
+MSG_INFO = Software: Hosted unittest \(Catch2\) for the FSFW.
+MSG_OPTIMIZATION = Optimization: $(OPTIMIZATION), $(OPTIMIZATION_MESSAGE)
+MSG_TARGET = Target Build: $(TARGET)
+MSG_DEBUG = Debug level: $(DEBUG_LEVEL), FSFW Debugging: $(DEBUG_MESSAGE)
+
+MSG_LINKING = Linking:
+MSG_COMPILING = Compiling:
+MSG_ASSEMBLING = Assembling:
+MSG_DEPENDENCY = Collecting dependencies for:
+MSG_BINARY = Generate binary: 
+
+# See https://stackoverflow.com/questions/6687630/how-to-remove-unused-c-c-symbols-with-gcc-and-ld
+# Used to throw away unused code. Reduces code size significantly !
+# -Wl,--gc-sections: needs to be passed to the linker to throw aways unused code
+ifdef KEEP_UNUSED_CODE
+PROTOTYPE_OPTIMIZATION = 
+UNUSED_CODE_REMOVAL = 
+else
+PROTOTYPE_OPTIMIZATION = -ffunction-sections -fdata-sections
+UNUSED_CODE_REMOVAL = -Wl,--gc-sections
+# Link time optimization
+# See https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html for reference
+# Link time is larger and size of object files can not be retrieved
+# but resulting binary is smaller. Could be used in mission/deployment build
+# Requires -ffunction-section in linker call
+LINK_TIME_OPTIMIZATION = -flto
+OPTIMIZATION += $(PROTOTYPE_OPTIMIZATION) 
+endif 
+
+# Dependency Flags
+# These flags tell the compiler to build dependencies
+# See: https://www.gnu.org/software/make/manual/html_node/Automatic-Prerequisites.html
+# Using following guide: http://make.mad-scientist.net/papers/advanced-auto-dependency-generation/#combine
+DEPFLAGS = -MT $@ -MMD -MP -MF $(DEPENDDIR)/$*.d
+
+# Flags for the compiler call
+# - std: Which C++ version to use. Common versions: c++11, c++14 and c++17
+# - Wall: enable all warnings
+# - Wextra: enable extra warnings
+# - g: defines debug level
+# - fmessage-length: to control the formatting algorithm for diagnostic messages;
+#    =0 means  no line-wrapping is done; each error message appears on a single line
+# - fno-exceptions: stops generating extra code needed to propagate exceptions, 
+#    which can produce significant data size overhead
+CUSTOM_DEFINES += -DUNIT_TEST
+WARNING_FLAGS = -Wall -Wshadow=local -Wextra -Wimplicit-fallthrough=1 \
+		-Wno-unused-parameter 
+		
+CXXDEFINES := $(CUSTOM_DEFINES)
+CFLAGS += 
+CXXFLAGS += -I. $(DEBUG_LEVEL) $(WARNING_FLAGS) $(DEPFLAGS) -fmessage-length=0 $(OPTIMIZATION)\
+		 $(I_INCLUDES) $(CXXDEFINES)
+CPPFLAGS += -std=c++11  
+
+# Flags for the linker call
+# LINK_INCLUDES specify the path to used libraries and the linker script
+# LINK_LIBRARIES: Link real time support
+LDFLAGS := $(DEBUG_LEVEL) $(UNUSED_CODE_REMOVAL) $(OPTIMIZATION) -pthread 
+LINK_INCLUDES := 
+LINK_LIBRARIES :=
+
+ifdef LINUX
+LINK_LIBRARIES += -lrt
+endif
+
+ifeq ($(OS),Windows_NT)
+LINK_LIBRARIES += -lwsock32 -lws2_32
+LDFLASGS += -fuse-ld=lld
+endif
+
+# Gnu Coverage Tools Flags
+ifdef GCOV
+GCOV_CXXFLAGS = -fprofile-arcs -ftest-coverage --coverage -fno-inline \
+		-fno-inline-small-functions -fno-default-inline
+CXXFLAGS += $(GCOV_CXXFLAGS)
+GCOV_LINKER_LIBS = -lgcov -fprofile-arcs -ftest-coverage
+LINK_LIBRARIES += $(GCOV_LINKER_LIBS)
+endif
+
+# $(info $${CXXFLAGS} is [${CXXFLAGS}])
+
+#-------------------------------------------------------------------------------
+#		Rules
+#-------------------------------------------------------------------------------
+# the call function assigns parameters to temporary variables
+# https://www.gnu.org/software/make/manual/make.html#Call-Function
+# $(1) = Memory names
+# Rules are called for each memory type
+# Two Expansion Symbols $$ are to escape the dollar sign for eval.
+# See: http://make.mad-scientist.net/the-eval-function/
+
+default: all
+
+# Cleans all files 
+hardclean: 
+	-rm -rf $(BUILDPATH)
+	-rm -rf $(OBJECTPATH)
+	-rm -rf $(DEPENDPATH)
+
+# Only clean files for current build
+clean:
+	-rm -rf $(CLEANOBJ)
+	-rm -rf $(CLEANBIN)
+	-rm -rf $(CLEANDEP)
+
+# Only clean binaries. Useful for changing the binary type when object files 
+# are already compiled so complete rebuild is not necessary
+cleanbin:
+	-rm -rf $(CLEANBIN)
+
+# In this section, the binaries are built for all selected memories
+# notestfw: all
+all: executable 
+
+# Build target configuration
+release: OPTIMIZATION = -Os $(PROTOTYPE_OPTIMIZATION) $(LINK_TIME_OPTIMIZATION)
+release: LINK_TIME_OPTIMIZATION = -flto
+release: TARGET = Mission build.
+release: OPTIMIZATION_MESSAGE = On with Link Time Optimization
+
+debug: CXXDEFINES += -DDEBUG
+debug: TARGET = Debug
+debug: DEBUG_MESSAGE = On
+
+ifndef KEEP_UNUSED_CODE
+debug release: OPTIMIZATION_MESSAGE += , no unused code removal
+endif
+
+debug release notestfw: executable
+	
+executable: $(BINDIR)/$(BINARY_NAME).elf	
+	@echo
+	@echo $(MSG_INFO)
+	@echo $(MSG_TARGET)
+	@echo $(MSG_OPTIMIZATION)
+	@echo $(MSG_DEBUG)
+
+C_OBJECTS_PREFIXED = $(addprefix $(OBJDIR)/, $(C_OBJECTS))
+CXX_OBJECTS_PREFIXED = $(addprefix $(OBJDIR)/, $(CXX_OBJECTS))
+ASM_OBJECTS_PREFIXED = $(addprefix $(OBJDIR)/, $(ASM_OBJECTS))
+ALL_OBJECTS = $(ASM_OBJECTS_PREFIXED) $(C_OBJECTS_PREFIXED) \
+		$(CXX_OBJECTS_PREFIXED) 
+
+# Useful for debugging the Makefile
+# Also see: https://www.oreilly.com/openbook/make3/book/ch12.pdf
+# $(info $${ALL_OBJECTS} is [${ALL_OBJECTS}])
+# $(info $${CXXSRC} is [${CXXSRC}])
+
+# Automatic variables are used here extensively. Some of them
+# are escaped($$) to suppress immediate evaluation. The most important ones are:
+# $@: Name of Target (left side of rule)
+# $<: Name of the first prerequisite (right side of rule)
+# @^: List of all prerequisite, omitting duplicates
+# @D: Directory and file-within-directory part of $@
+
+# Generates binary and displays all build properties
+# -p with mkdir ignores error and creates directory when needed.
+
+# SHOW_DETAILS = 1
+
+
+# Link with required libraries: HAL (Hardware Abstraction Layer) and 
+# HCC (File System Library)
+$(BINDIR)/$(BINARY_NAME).elf: $(ALL_OBJECTS)
+	@echo
+	@echo $(MSG_LINKING) Target $@
+	@mkdir -p $(@D)
+ifdef SHOW_DETAILS
+	$(CXX) $(LDFLAGS) $(LINK_INCLUDES) -o $@ $^ $(LINK_LIBRARIES)
+else
+	@$(CXX) $(LDFLAGS) $(LINK_INCLUDES) -o $@ $^ $(LINK_LIBRARIES)
+endif	
+ifeq ($(BUILD_FOLDER), mission)
+# With Link Time Optimization, section size is not available
+	$(SIZE) $@
+else
+	$(SIZE) $^ $@
+endif
+
+$(BINDIR)/$(BINARY_NAME).hex: $(BINDIR)/$(BINARY_NAME).elf
+	@echo
+	@echo $(MSG_BINARY)
+	@mkdir -p $(@D)
+	$(HEXCOPY) $< $@
+	
+# Build new objects for changed dependencies. 
+$(OBJDIR)/%.o: %.cpp
+$(OBJDIR)/%.o: %.cpp $(DEPENDDIR)/%.d | $(DEPENDDIR)
+	@echo 
+	@echo $(MSG_COMPILING) $<
+	@mkdir -p $(@D)
+ifdef SHOW_DETAILS
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -o $@ $<
+else
+	@$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -o $@ $<
+endif
+
+$(OBJDIR)/%.o: %.c 
+$(OBJDIR)/%.o: %.c $(DEPENDDIR)/%.d | $(DEPENDDIR) 
+	@echo 
+	@echo $(MSG_COMPILING) $<
+	@mkdir -p $(@D)
+ifdef SHOW_DETAILS
+	$(CC)  $(CXXFLAGS) $(CFLAGS) -c -o $@ $<
+else
+	@$(CC)  $(CXXFLAGS) $(CFLAGS) -c -o $@ $<
+endif
+
+#-------------------------------------------------------------------------------
+#		Dependency Handling
+#-------------------------------------------------------------------------------
+
+# Dependency Handling according to following guide:
+# http://make.mad-scientist.net/papers/advanced-auto-dependency-generation/
+$(DEPENDDIR):
+	@mkdir -p $(@D)
+DEPENDENCY_RELATIVE = $(CSRC:.c=.d) $(CXXSRC:.cpp=.d)
+# This is the list of all dependencies
+DEPFILES = $(addprefix $(DEPENDDIR)/, $(DEPENDENCY_RELATIVE))
+# Create subdirectories for dependencies
+$(DEPFILES):
+	@mkdir -p $(@D)
+# Include all dependencies
+include $(wildcard $(DEPFILES))
+	
+# .PHONY tells make that these targets aren't files
+.PHONY: clean release debug all hardclean cleanbin
diff --git a/unittest/README.md b/unittest/README.md
new file mode 100644
index 000000000..091dd3cb2
--- /dev/null
+++ b/unittest/README.md
@@ -0,0 +1,121 @@
+## FSFW Testing
+This repository contains testing and unit testing components.
+
+[Catch2](https://github.com/catchorg/Catch2) has been used as a framework,
+and these unit tests can only be run on a linux host machine.
+The makefile with default settings creates the unit test binary which can be
+run in the terminal or in eclipse.
+
+### Instructions
+Basic steps:
+
+1. Clone this branch
+   ```sh
+   git clone https://egit.irs.uni-stuttgart.de/fsfw/fsfw_tests.git
+   ```
+
+2. Inititate the framework submodule (need to only be done once)
+   ```sh
+   git submodule init
+   git submodule sync
+   git submodule update
+   ```
+   
+2. Run the makefile With
+
+   ```sh
+   make all -j<Number Of Processors>
+   ```
+   This will build the debug version of the unit tests.
+   The release version can be built with the target `release`
+
+4. Run the binary located in the \_bin folder in the terminal or in eclipse.
+
+   ```sh
+   _bin/<binaryName>.elf [--success]
+   ```
+   The success parameter is optional. Leaving it out ommits the success messages.
+
+5. To clear the binary, object and dependency folder, run
+
+   ```sh
+   make clean
+   ```
+
+Please note that on most UNIX environments (e.g. Ubuntu), the real time functionalities used by the UNIX pthread module are restricted, which will lead to permission errors when creating these tasks.
+
+To solve this issues, try following steps:
+
+1. Edit the /etc/security/limits.conf 
+   file and add following lines at the end (worked on Ubuntu 19.10):
+   ```sh
+   <username>   hard   rtprio  99
+   <username>   soft   rtprio  99
+   ```
+   Then restart the computer. <br>
+   The soft limit can also be set in the console with `ulimit -Sr` if the hard
+   limit has been increased,
+   but it is recommended to add it to the file as well for convenience.
+   If adding the second line is not desired for security reasons,
+   the soft limit needs to be set for each session. If using an IDE like eclipse 
+   in that case, the IDE needs to be started from the console after setting
+   the soft limit higher there.
+2. Run the shell script inside the linux folder (worked on Ubuntu 18.04)
+   ```sh
+   ./unlockRealtime
+   ```
+   This script executes the `setcap` command on bash and on the binaries.
+   It also increases the soft real time limit of the current shell instance
+   to the maximum. If running the script before executing the binary does
+   not help, try the following step.
+   
+### Eclipse CDT settings
+
+The default eclipse terminal has issues displaying the colors used
+when running the unit test binary by catch2. To fix this issue,
+install the ANSI Escape In Console package from the eclipse marketplace.
+
+### GCOV integration
+
+GCOV has been integrated as a code coverage tool.
+It can be enabled by adding `GCOV=1` to the build process as an additional argument.
+Coverage data will be provided in form of .gcno and .gcda files.
+These can be displayed in eclipse by looking
+for a .gcno or .gcda file in the \_obj folder, double-clicking it
+and picking the right source-binary. This will generate 
+information about which lines of a file have run, provided it is open in 
+eclipse.
+
+### LCOV integration
+
+The files generated by GCOV can also be processed by the tool LCOV.
+On ubuntu, the tool can be installed with the following command:
+
+```sh 
+sudo apt-get install lcov
+```` 
+
+After that, the tool can be run by building the unit tests with `GCOV=1`,
+running them at least one time and then executing the `lcov.sh` script.
+
+### Adding unit tests
+
+The catch unit tests are located in unittest/testfw. To add new unit tests,
+add them to the UnitTestCatch.cpp file or add a new source file which
+includes catch.hpp.
+
+For writing basics tests, the [assertion documentation](https://github.com/catchorg/Catch2/blob/master/docs/assertions.md#top)
+or the existing examples are a good guideliens.
+For more advanced tests, refer to the [catch2 documentation](https://github.com/catchorg/Catch2/blob/master/docs/Readme.md#top).
+
+### Compile without test framework
+Alternatively, the unit tests can also be run internally without
+a framework. This can be used to perform unit tests on the real hardware.
+To do this, run
+```sh
+make -j<Number Of Processors> notestfw
+```
+This will instruct the makefile to exclude the test framework main.cpp
+and include our own. This will also create a binary which can be used
+outside the host machine (a Makefile adaptions might be neccessary
+if another OS than linux is required)
diff --git a/unittest/catch2/LICENSE.txt b/unittest/catch2/LICENSE.txt
new file mode 100644
index 000000000..36b7cd93c
--- /dev/null
+++ b/unittest/catch2/LICENSE.txt
@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/unittest/catch2/catch.hpp b/unittest/catch2/catch.hpp
new file mode 100644
index 000000000..51618b38e
--- /dev/null
+++ b/unittest/catch2/catch.hpp
@@ -0,0 +1,17618 @@
+/*
+ *  Catch v2.11.3
+ *  Generated: 2020-03-19 13:44:21.042491
+ *  ----------------------------------------------------------
+ *  This file has been merged from multiple headers. Please don't edit it directly
+ *  Copyright (c) 2020 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+// start catch.hpp
+
+
+#define CATCH_VERSION_MAJOR 2
+#define CATCH_VERSION_MINOR 11
+#define CATCH_VERSION_PATCH 3
+
+#ifdef __clang__
+#    pragma clang system_header
+#elif defined __GNUC__
+#    pragma GCC system_header
+#endif
+
+// start catch_suppress_warnings.h
+
+#ifdef __clang__
+#   ifdef __ICC // icpc defines the __clang__ macro
+#       pragma warning(push)
+#       pragma warning(disable: 161 1682)
+#   else // __ICC
+#       pragma clang diagnostic push
+#       pragma clang diagnostic ignored "-Wpadded"
+#       pragma clang diagnostic ignored "-Wswitch-enum"
+#       pragma clang diagnostic ignored "-Wcovered-switch-default"
+#    endif
+#elif defined __GNUC__
+     // Because REQUIREs trigger GCC's -Wparentheses, and because still
+     // supported version of g++ have only buggy support for _Pragmas,
+     // Wparentheses have to be suppressed globally.
+#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
+
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wunused-variable"
+#    pragma GCC diagnostic ignored "-Wpadded"
+#endif
+// end catch_suppress_warnings.h
+#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
+#  define CATCH_IMPL
+#  define CATCH_CONFIG_ALL_PARTS
+#endif
+
+// In the impl file, we want to have access to all parts of the headers
+// Can also be used to sanely support PCHs
+#if defined(CATCH_CONFIG_ALL_PARTS)
+#  define CATCH_CONFIG_EXTERNAL_INTERFACES
+#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#    undef CATCH_CONFIG_DISABLE_MATCHERS
+#  endif
+#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  endif
+#endif
+
+#if !defined(CATCH_CONFIG_IMPL_ONLY)
+// start catch_platform.h
+
+#ifdef __APPLE__
+# include <TargetConditionals.h>
+# if TARGET_OS_OSX == 1
+#  define CATCH_PLATFORM_MAC
+# elif TARGET_OS_IPHONE == 1
+#  define CATCH_PLATFORM_IPHONE
+# endif
+
+#elif defined(linux) || defined(__linux) || defined(__linux__)
+#  define CATCH_PLATFORM_LINUX
+
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
+#  define CATCH_PLATFORM_WINDOWS
+#endif
+
+// end catch_platform.h
+
+#ifdef CATCH_IMPL
+#  ifndef CLARA_CONFIG_MAIN
+#    define CLARA_CONFIG_MAIN_NOT_DEFINED
+#    define CLARA_CONFIG_MAIN
+#  endif
+#endif
+
+// start catch_user_interfaces.h
+
+namespace Catch {
+    unsigned int rngSeed();
+}
+
+// end catch_user_interfaces.h
+// start catch_tag_alias_autoregistrar.h
+
+// start catch_common.h
+
+// start catch_compiler_capabilities.h
+
+// Detect a number of compiler features - by compiler
+// The following features are defined:
+//
+// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
+// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
+// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
+// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
+// ****************
+// Note to maintainers: if new toggles are added please document them
+// in configuration.md, too
+// ****************
+
+// In general each macro has a _NO_<feature name> form
+// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
+// Many features, at point of detection, define an _INTERNAL_ macro, so they
+// can be combined, en-mass, with the _NO_ forms later.
+
+#ifdef __cplusplus
+
+#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
+#    define CATCH_CPP14_OR_GREATER
+#  endif
+
+#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#    define CATCH_CPP17_OR_GREATER
+#  endif
+
+#endif
+
+#if defined(CATCH_CPP17_OR_GREATER)
+#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+// We have to avoid both ICC and Clang, because they try to mask themselves
+// as gcc, and we want only GCC in this block
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
+
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+#endif
+
+#if defined(__clang__)
+
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
+
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+
+#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
+
+#endif // __clang__
+
+////////////////////////////////////////////////////////////////////////////////
+// Assume that non-Windows platforms support posix signals by default
+#if !defined(CATCH_PLATFORM_WINDOWS)
+    #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// We know some environments not to support full POSIX signals
+#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
+    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#endif
+
+#ifdef __OS400__
+#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#       define CATCH_CONFIG_COLOUR_NONE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Android somehow still does not support std::to_string
+#if defined(__ANDROID__)
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Not all Windows environments support SEH properly
+#if defined(__MINGW32__)
+#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// PS4
+#if defined(__ORBIS__)
+#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Cygwin
+#ifdef __CYGWIN__
+
+// Required for some versions of Cygwin to declare gettimeofday
+// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
+#   define _BSD_SOURCE
+// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
+// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
+# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
+           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+
+# endif
+#endif // __CYGWIN__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#if defined(_MSC_VER)
+
+#  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
+#  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
+
+#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
+#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#  endif
+
+// Universal Windows platform does not support SEH
+// Or console colours (or console at all...)
+#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#    define CATCH_CONFIG_COLOUR_NONE
+#  else
+#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+#  endif
+
+// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
+// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
+// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
+#  if !defined(__clang__) // Handle Clang masquerading for msvc
+#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#    endif // MSVC_TRADITIONAL
+#  endif // __clang__
+
+#endif // _MSC_VER
+
+#if defined(_REENTRANT) || defined(_MSC_VER)
+// Enable async processing, as -pthread is specified or no additional linking is required
+# define CATCH_INTERNAL_CONFIG_USE_ASYNC
+#endif // _MSC_VER
+
+////////////////////////////////////////////////////////////////////////////////
+// Check if we are compiled with -fno-exceptions or equivalent
+#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
+#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// DJGPP
+#ifdef __DJGPP__
+#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
+#endif // __DJGPP__
+
+////////////////////////////////////////////////////////////////////////////////
+// Embarcadero C++Build
+#if defined(__BORLANDC__)
+    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Use of __COUNTER__ is suppressed during code analysis in
+// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
+// handled by it.
+// Otherwise all supported compilers support COUNTER macro,
+// but user still might want to turn it off
+#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
+    #define CATCH_INTERNAL_CONFIG_COUNTER
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// RTX is a special version of Windows that is real time.
+// This means that it is detected as Windows, but does not provide
+// the same set of capabilities as real Windows does.
+#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
+    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
+    #define CATCH_CONFIG_COLOUR_NONE
+#endif
+
+#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
+#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Various stdlib support checks that require __has_include
+#if defined(__has_include)
+  // Check if string_view is available and usable
+  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
+  #endif
+
+  // Check if optional is available and usable
+  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if byte is available and usable
+  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if variant is available and usable
+  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+  #    if defined(__clang__) && (__clang_major__ < 8)
+         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+         // fix should be in clang 8, workaround in libstdc++ 8.2
+  #      include <ciso646>
+  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #        define CATCH_CONFIG_NO_CPP17_VARIANT
+  #      else
+  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #    else
+  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #    endif // defined(__clang__) && (__clang_major__ < 8)
+  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // defined(__has_include)
+
+#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
+#   define CATCH_CONFIG_COUNTER
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
+#   define CATCH_CONFIG_WINDOWS_SEH
+#endif
+// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
+#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#   define CATCH_CONFIG_POSIX_SIGNALS
+#endif
+// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
+#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
+#   define CATCH_CONFIG_WCHAR
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
+#    define CATCH_CONFIG_CPP11_TO_STRING
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#  define CATCH_CONFIG_CPP17_OPTIONAL
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
+#  define CATCH_CONFIG_CPP17_STRING_VIEW
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
+#  define CATCH_CONFIG_CPP17_VARIANT
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
+#  define CATCH_CONFIG_CPP17_BYTE
+#endif
+
+#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
+#  define CATCH_CONFIG_NEW_CAPTURE
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+#  define CATCH_CONFIG_POLYFILL_ISNAN
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+#  define CATCH_CONFIG_USE_ASYNC
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#  define CATCH_CONFIG_ANDROID_LOGWRITE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Even if we do not think the compiler has that warning, we still have
+// to provide a macro that can be used by the code.
+#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
+#endif
+
+// The goal of this macro is to avoid evaluation of the arguments, but
+// still have the compiler warn on problems inside...
+#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
+#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
+#endif
+
+#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#elif defined(__clang__) && (__clang_major__ < 5)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#define CATCH_TRY if ((true))
+#define CATCH_CATCH_ALL if ((false))
+#define CATCH_CATCH_ANON(type) if ((false))
+#else
+#define CATCH_TRY try
+#define CATCH_CATCH_ALL catch (...)
+#define CATCH_CATCH_ANON(type) catch (type)
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
+#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#endif
+
+// end catch_compiler_capabilities.h
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+#ifdef CATCH_CONFIG_COUNTER
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
+#else
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+#endif
+
+#include <iosfwd>
+#include <string>
+#include <cstdint>
+
+// We need a dummy global operator<< so we can bring it into Catch namespace later
+struct Catch_global_namespace_dummy {};
+std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
+
+namespace Catch {
+
+    struct CaseSensitive { enum Choice {
+        Yes,
+        No
+    }; };
+
+    class NonCopyable {
+        NonCopyable( NonCopyable const& )              = delete;
+        NonCopyable( NonCopyable && )                  = delete;
+        NonCopyable& operator = ( NonCopyable const& ) = delete;
+        NonCopyable& operator = ( NonCopyable && )     = delete;
+
+    protected:
+        NonCopyable();
+        virtual ~NonCopyable();
+    };
+
+    struct SourceLineInfo {
+
+        SourceLineInfo() = delete;
+        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
+        :   file( _file ),
+            line( _line )
+        {}
+
+        SourceLineInfo( SourceLineInfo const& other )            = default;
+        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
+        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
+        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
+
+        bool empty() const noexcept { return file[0] == '\0'; }
+        bool operator == ( SourceLineInfo const& other ) const noexcept;
+        bool operator < ( SourceLineInfo const& other ) const noexcept;
+
+        char const* file;
+        std::size_t line;
+    };
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
+
+    // Bring in operator<< from global namespace into Catch namespace
+    // This is necessary because the overload of operator<< above makes
+    // lookup stop at namespace Catch
+    using ::operator<<;
+
+    // Use this in variadic streaming macros to allow
+    //    >> +StreamEndStop
+    // as well as
+    //    >> stuff +StreamEndStop
+    struct StreamEndStop {
+        std::string operator+() const;
+    };
+    template<typename T>
+    T const& operator + ( T const& value, StreamEndStop ) {
+        return value;
+    }
+}
+
+#define CATCH_INTERNAL_LINEINFO \
+    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+
+// end catch_common.h
+namespace Catch {
+
+    struct RegistrarForTagAliases {
+        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+    };
+
+} // end namespace Catch
+
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+// end catch_tag_alias_autoregistrar.h
+// start catch_test_registry.h
+
+// start catch_interfaces_testcase.h
+
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec;
+
+    struct ITestInvoker {
+        virtual void invoke () const = 0;
+        virtual ~ITestInvoker();
+    };
+
+    class TestCase;
+    struct IConfig;
+
+    struct ITestCaseRegistry {
+        virtual ~ITestCaseRegistry();
+        virtual std::vector<TestCase> const& getAllTests() const = 0;
+        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
+    };
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+
+}
+
+// end catch_interfaces_testcase.h
+// start catch_stringref.h
+
+#include <cstddef>
+#include <string>
+#include <iosfwd>
+#include <cassert>
+
+namespace Catch {
+
+    /// A non-owning string class (similar to the forthcoming std::string_view)
+    /// Note that, because a StringRef may be a substring of another string,
+    /// it may not be null terminated.
+    class StringRef {
+    public:
+        using size_type = std::size_t;
+        using const_iterator = const char*;
+
+    private:
+        static constexpr char const* const s_empty = "";
+
+        char const* m_start = s_empty;
+        size_type m_size = 0;
+
+    public: // construction
+        constexpr StringRef() noexcept = default;
+
+        StringRef( char const* rawChars ) noexcept;
+
+        constexpr StringRef( char const* rawChars, size_type size ) noexcept
+        :   m_start( rawChars ),
+            m_size( size )
+        {}
+
+        StringRef( std::string const& stdString ) noexcept
+        :   m_start( stdString.c_str() ),
+            m_size( stdString.size() )
+        {}
+
+        explicit operator std::string() const {
+            return std::string(m_start, m_size);
+        }
+
+    public: // operators
+        auto operator == ( StringRef const& other ) const noexcept -> bool;
+        auto operator != (StringRef const& other) const noexcept -> bool {
+            return !(*this == other);
+        }
+
+        auto operator[] ( size_type index ) const noexcept -> char {
+            assert(index < m_size);
+            return m_start[index];
+        }
+
+    public: // named queries
+        constexpr auto empty() const noexcept -> bool {
+            return m_size == 0;
+        }
+        constexpr auto size() const noexcept -> size_type {
+            return m_size;
+        }
+
+        // Returns the current start pointer. If the StringRef is not
+        // null-terminated, throws std::domain_exception
+        auto c_str() const -> char const*;
+
+    public: // substrings and searches
+        // Returns a substring of [start, start + length).
+        // If start + length > size(), then the substring is [start, size()).
+        // If start > size(), then the substring is empty.
+        auto substr( size_type start, size_type length ) const noexcept -> StringRef;
+
+        // Returns the current start pointer. May not be null-terminated.
+        auto data() const noexcept -> char const*;
+
+        constexpr auto isNullTerminated() const noexcept -> bool {
+            return m_start[m_size] == '\0';
+        }
+
+    public: // iterators
+        constexpr const_iterator begin() const { return m_start; }
+        constexpr const_iterator end() const { return m_start + m_size; }
+    };
+
+    auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
+    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
+
+    constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
+        return StringRef( rawChars, size );
+    }
+} // namespace Catch
+
+constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
+    return Catch::StringRef( rawChars, size );
+}
+
+// end catch_stringref.h
+// start catch_preprocessor.hpp
+
+
+#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
+#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
+
+#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
+// MSVC needs more evaluations
+#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
+#else
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
+#endif
+
+#define CATCH_REC_END(...)
+#define CATCH_REC_OUT
+
+#define CATCH_EMPTY()
+#define CATCH_DEFER(id) id CATCH_EMPTY()
+
+#define CATCH_REC_GET_END2() 0, CATCH_REC_END
+#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
+#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
+#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
+#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
+#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
+
+#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+
+#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+
+// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
+// and passes userdata as the first parameter to each invocation,
+// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
+#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
+#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
+#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
+#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
+#else
+// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
+#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
+#endif
+
+#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
+#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
+
+#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#else
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#endif
+
+#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
+    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
+
+#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
+#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
+#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
+#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
+#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
+#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
+#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6)
+#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
+#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
+#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
+#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
+
+#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
+
+#define INTERNAL_CATCH_TYPE_GEN\
+    template<typename...> struct TypeList {};\
+    template<typename...Ts>\
+    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
+    template<template<typename...> class...> struct TemplateTypeList{};\
+    template<template<typename...> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
+    template<typename...>\
+    struct append;\
+    template<typename...>\
+    struct rewrap;\
+    template<template<typename...> class, typename...>\
+    struct create;\
+    template<template<typename...> class, typename>\
+    struct convert;\
+    \
+    template<typename T> \
+    struct append<T> { using type = T; };\
+    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
+    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
+    template< template<typename...> class L1, typename...E1, typename...Rest>\
+    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
+    \
+    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
+    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
+    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
+    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
+    \
+    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
+    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
+    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
+    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
+
+#define INTERNAL_CATCH_NTTP_1(signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
+    \
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
+    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
+    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
+    template<typename TestType> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
+    template<typename TestType> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_NTTP_0
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
+#else
+#define INTERNAL_CATCH_NTTP_0(signature)
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
+#endif
+
+// end catch_preprocessor.hpp
+// start catch_meta.hpp
+
+
+#include <type_traits>
+
+namespace Catch {
+    template<typename T>
+    struct always_false : std::false_type {};
+
+    template <typename> struct true_given : std::true_type {};
+    struct is_callable_tester {
+        template <typename Fun, typename... Args>
+        true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
+        template <typename...>
+        std::false_type static test(...);
+    };
+
+    template <typename T>
+    struct is_callable;
+
+    template <typename Fun, typename... Args>
+    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
+
+#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
+    // replaced with std::invoke_result here. Also *_t format is preferred over
+    // typename *::type format.
+    template <typename Func, typename U>
+    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
+#else
+    template <typename Func, typename U>
+    using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
+#endif
+
+} // namespace Catch
+
+namespace mpl_{
+    struct na;
+}
+
+// end catch_meta.hpp
+namespace Catch {
+
+template<typename C>
+class TestInvokerAsMethod : public ITestInvoker {
+    void (C::*m_testAsMethod)();
+public:
+    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
+
+    void invoke() const override {
+        C obj;
+        (obj.*m_testAsMethod)();
+    }
+};
+
+auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
+
+template<typename C>
+auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
+    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
+}
+
+struct NameAndTags {
+    NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
+    StringRef name;
+    StringRef tags;
+};
+
+struct AutoReg : NonCopyable {
+    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
+    ~AutoReg();
+};
+
+} // end namespace Catch
+
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
+        namespace{                        \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+                void test();              \
+            };                            \
+        }                                 \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
+        namespace{                                                                                  \
+            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        }                                                                                           \
+        }                                                                                           \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+#endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
+        static void TestName(); \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE( ... ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+        } \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
+        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestName{\
+                TestName(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+            return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS              \
+        template<typename TestType> static void TestFuncName();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
+            INTERNAL_CATCH_TYPE_GEN                                                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
+            template<typename... Types>                               \
+            struct TestName {                                         \
+                void reg_tests() {                                          \
+                    int index = 0;                                    \
+                    using expander = int[];                           \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */\
+                }                                                     \
+            };                                                        \
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }                                                             \
+        }                                                             \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFuncName()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> static void TestFunc();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+        INTERNAL_CATCH_TYPE_GEN\
+        template<typename... Types>                               \
+        struct TestName {                                         \
+            void reg_tests() {                                          \
+                int index = 0;                                    \
+                using expander = int[];                           \
+                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */\
+            }                                                     \
+        };\
+        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename convert<TestName, TmplList>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFunc()
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
+
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestNameClass{\
+                TestNameClass(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+                return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+                void test();\
+            };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
+            INTERNAL_CATCH_TYPE_GEN                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> \
+        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+            void test();\
+        };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename convert<TestNameClass, TmplList>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
+
+// end catch_test_registry.h
+// start catch_capture.hpp
+
+// start catch_assertionhandler.h
+
+// start catch_assertioninfo.h
+
+// start catch_result_type.h
+
+namespace Catch {
+
+    // ResultWas::OfType enum
+    struct ResultWas { enum OfType {
+        Unknown = -1,
+        Ok = 0,
+        Info = 1,
+        Warning = 2,
+
+        FailureBit = 0x10,
+
+        ExpressionFailed = FailureBit | 1,
+        ExplicitFailure = FailureBit | 2,
+
+        Exception = 0x100 | FailureBit,
+
+        ThrewException = Exception | 1,
+        DidntThrowException = Exception | 2,
+
+        FatalErrorCondition = 0x200 | FailureBit
+
+    }; };
+
+    bool isOk( ResultWas::OfType resultType );
+    bool isJustInfo( int flags );
+
+    // ResultDisposition::Flags enum
+    struct ResultDisposition { enum Flags {
+        Normal = 0x01,
+
+        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
+        FalseTest = 0x04,           // Prefix expression with !
+        SuppressFail = 0x08         // Failures are reported but do not fail the test
+    }; };
+
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
+
+    bool shouldContinueOnFailure( int flags );
+    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
+    bool shouldSuppressFailure( int flags );
+
+} // end namespace Catch
+
+// end catch_result_type.h
+namespace Catch {
+
+    struct AssertionInfo
+    {
+        StringRef macroName;
+        SourceLineInfo lineInfo;
+        StringRef capturedExpression;
+        ResultDisposition::Flags resultDisposition;
+
+        // We want to delete this constructor but a compiler bug in 4.8 means
+        // the struct is then treated as non-aggregate
+        //AssertionInfo() = delete;
+    };
+
+} // end namespace Catch
+
+// end catch_assertioninfo.h
+// start catch_decomposer.h
+
+// start catch_tostring.h
+
+#include <vector>
+#include <cstddef>
+#include <type_traits>
+#include <string>
+// start catch_stream.h
+
+#include <iosfwd>
+#include <cstddef>
+#include <ostream>
+
+namespace Catch {
+
+    std::ostream& cout();
+    std::ostream& cerr();
+    std::ostream& clog();
+
+    class StringRef;
+
+    struct IStream {
+        virtual ~IStream();
+        virtual std::ostream& stream() const = 0;
+    };
+
+    auto makeStream( StringRef const &filename ) -> IStream const*;
+
+    class ReusableStringStream : NonCopyable {
+        std::size_t m_index;
+        std::ostream* m_oss;
+    public:
+        ReusableStringStream();
+        ~ReusableStringStream();
+
+        auto str() const -> std::string;
+
+        template<typename T>
+        auto operator << ( T const& value ) -> ReusableStringStream& {
+            *m_oss << value;
+            return *this;
+        }
+        auto get() -> std::ostream& { return *m_oss; }
+    };
+}
+
+// end catch_stream.h
+// start catch_interfaces_enum_values_registry.h
+
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+        struct EnumInfo {
+            StringRef m_name;
+            std::vector<std::pair<int, StringRef>> m_values;
+
+            ~EnumInfo();
+
+            StringRef lookup( int value ) const;
+        };
+    } // namespace Detail
+
+    struct IMutableEnumValuesRegistry {
+        virtual ~IMutableEnumValuesRegistry();
+
+        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+
+        template<typename E>
+        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
+            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
+            std::vector<int> intValues;
+            intValues.reserve( values.size() );
+            for( auto enumValue : values )
+                intValues.push_back( static_cast<int>( enumValue ) );
+            return registerEnum( enumName, allEnums, intValues );
+        }
+    };
+
+} // Catch
+
+// end catch_interfaces_enum_values_registry.h
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+#include <string_view>
+#endif
+
+#ifdef __OBJC__
+// start catch_objc_arc.hpp
+
+#import <Foundation/Foundation.h>
+
+#ifdef __has_feature
+#define CATCH_ARC_ENABLED __has_feature(objc_arc)
+#else
+#define CATCH_ARC_ENABLED 0
+#endif
+
+void arcSafeRelease( NSObject* obj );
+id performOptionalSelector( id obj, SEL sel );
+
+#if !CATCH_ARC_ENABLED
+inline void arcSafeRelease( NSObject* obj ) {
+    [obj release];
+}
+inline id performOptionalSelector( id obj, SEL sel ) {
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED
+#define CATCH_ARC_STRONG
+#else
+inline void arcSafeRelease( NSObject* ){}
+inline id performOptionalSelector( id obj, SEL sel ) {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+#endif
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
+#define CATCH_ARC_STRONG __strong
+#endif
+
+// end catch_objc_arc.hpp
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
+#endif
+
+namespace Catch {
+    namespace Detail {
+
+        extern const std::string unprintableString;
+
+        std::string rawMemoryToString( const void *object, std::size_t size );
+
+        template<typename T>
+        std::string rawMemoryToString( const T& object ) {
+          return rawMemoryToString( &object, sizeof(object) );
+        }
+
+        template<typename T>
+        class IsStreamInsertable {
+            template<typename Stream, typename U>
+            static auto test(int)
+                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
+
+            template<typename, typename>
+            static auto test(...)->std::false_type;
+
+        public:
+            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
+        };
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e );
+
+        template<typename T>
+        typename std::enable_if<
+            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
+        std::string>::type convertUnstreamable( T const& ) {
+            return Detail::unprintableString;
+        }
+        template<typename T>
+        typename std::enable_if<
+            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
+         std::string>::type convertUnstreamable(T const& ex) {
+            return ex.what();
+        }
+
+        template<typename T>
+        typename std::enable_if<
+            std::is_enum<T>::value
+        , std::string>::type convertUnstreamable( T const& value ) {
+            return convertUnknownEnumToString( value );
+        }
+
+#if defined(_MANAGED)
+        //! Convert a CLR string to a utf8 std::string
+        template<typename T>
+        std::string clrReferenceToString( T^ ref ) {
+            if (ref == nullptr)
+                return std::string("null");
+            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
+            cli::pin_ptr<System::Byte> p = &bytes[0];
+            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
+        }
+#endif
+
+    } // namespace Detail
+
+    // If we decide for C++14, change these to enable_if_ts
+    template <typename T, typename = void>
+    struct StringMaker {
+        template <typename Fake = T>
+        static
+        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+            convert(const Fake& value) {
+                ReusableStringStream rss;
+                // NB: call using the function-like syntax to avoid ambiguity with
+                // user-defined templated operator<< under clang.
+                rss.operator<<(value);
+                return rss.str();
+        }
+
+        template <typename Fake = T>
+        static
+        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+            convert( const Fake& value ) {
+#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
+            return Detail::convertUnstreamable(value);
+#else
+            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
+#endif
+        }
+    };
+
+    namespace Detail {
+
+        // This function dispatches all stringification requests inside of Catch.
+        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
+        template <typename T>
+        std::string stringify(const T& e) {
+            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
+        }
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e ) {
+            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
+        }
+
+#if defined(_MANAGED)
+        template <typename T>
+        std::string stringify( T^ e ) {
+            return ::Catch::StringMaker<T^>::convert(e);
+        }
+#endif
+
+    } // namespace Detail
+
+    // Some predefined specializations
+
+    template<>
+    struct StringMaker<std::string> {
+        static std::string convert(const std::string& str);
+    };
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::string_view> {
+        static std::string convert(std::string_view str);
+    };
+#endif
+
+    template<>
+    struct StringMaker<char const *> {
+        static std::string convert(char const * str);
+    };
+    template<>
+    struct StringMaker<char *> {
+        static std::string convert(char * str);
+    };
+
+#ifdef CATCH_CONFIG_WCHAR
+    template<>
+    struct StringMaker<std::wstring> {
+        static std::string convert(const std::wstring& wstr);
+    };
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::wstring_view> {
+        static std::string convert(std::wstring_view str);
+    };
+# endif
+
+    template<>
+    struct StringMaker<wchar_t const *> {
+        static std::string convert(wchar_t const * str);
+    };
+    template<>
+    struct StringMaker<wchar_t *> {
+        static std::string convert(wchar_t * str);
+    };
+#endif
+
+    // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
+    //      while keeping string semantics?
+    template<int SZ>
+    struct StringMaker<char[SZ]> {
+        static std::string convert(char const* str) {
+            return ::Catch::Detail::stringify(std::string{ str });
+        }
+    };
+    template<int SZ>
+    struct StringMaker<signed char[SZ]> {
+        static std::string convert(signed char const* str) {
+            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
+        }
+    };
+    template<int SZ>
+    struct StringMaker<unsigned char[SZ]> {
+        static std::string convert(unsigned char const* str) {
+            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
+        }
+    };
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<std::byte> {
+        static std::string convert(std::byte value);
+    };
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<int> {
+        static std::string convert(int value);
+    };
+    template<>
+    struct StringMaker<long> {
+        static std::string convert(long value);
+    };
+    template<>
+    struct StringMaker<long long> {
+        static std::string convert(long long value);
+    };
+    template<>
+    struct StringMaker<unsigned int> {
+        static std::string convert(unsigned int value);
+    };
+    template<>
+    struct StringMaker<unsigned long> {
+        static std::string convert(unsigned long value);
+    };
+    template<>
+    struct StringMaker<unsigned long long> {
+        static std::string convert(unsigned long long value);
+    };
+
+    template<>
+    struct StringMaker<bool> {
+        static std::string convert(bool b);
+    };
+
+    template<>
+    struct StringMaker<char> {
+        static std::string convert(char c);
+    };
+    template<>
+    struct StringMaker<signed char> {
+        static std::string convert(signed char c);
+    };
+    template<>
+    struct StringMaker<unsigned char> {
+        static std::string convert(unsigned char c);
+    };
+
+    template<>
+    struct StringMaker<std::nullptr_t> {
+        static std::string convert(std::nullptr_t);
+    };
+
+    template<>
+    struct StringMaker<float> {
+        static std::string convert(float value);
+        static int precision;
+    };
+
+    template<>
+    struct StringMaker<double> {
+        static std::string convert(double value);
+        static int precision;
+    };
+
+    template <typename T>
+    struct StringMaker<T*> {
+        template <typename U>
+        static std::string convert(U* p) {
+            if (p) {
+                return ::Catch::Detail::rawMemoryToString(p);
+            } else {
+                return "nullptr";
+            }
+        }
+    };
+
+    template <typename R, typename C>
+    struct StringMaker<R C::*> {
+        static std::string convert(R C::* p) {
+            if (p) {
+                return ::Catch::Detail::rawMemoryToString(p);
+            } else {
+                return "nullptr";
+            }
+        }
+    };
+
+#if defined(_MANAGED)
+    template <typename T>
+    struct StringMaker<T^> {
+        static std::string convert( T^ ref ) {
+            return ::Catch::Detail::clrReferenceToString(ref);
+        }
+    };
+#endif
+
+    namespace Detail {
+        template<typename InputIterator>
+        std::string rangeToString(InputIterator first, InputIterator last) {
+            ReusableStringStream rss;
+            rss << "{ ";
+            if (first != last) {
+                rss << ::Catch::Detail::stringify(*first);
+                for (++first; first != last; ++first)
+                    rss << ", " << ::Catch::Detail::stringify(*first);
+            }
+            rss << " }";
+            return rss.str();
+        }
+    }
+
+#ifdef __OBJC__
+    template<>
+    struct StringMaker<NSString*> {
+        static std::string convert(NSString * nsstring) {
+            if (!nsstring)
+                return "nil";
+            return std::string("@") + [nsstring UTF8String];
+        }
+    };
+    template<>
+    struct StringMaker<NSObject*> {
+        static std::string convert(NSObject* nsObject) {
+            return ::Catch::Detail::stringify([nsObject description]);
+        }
+
+    };
+    namespace Detail {
+        inline std::string stringify( NSString* nsstring ) {
+            return StringMaker<NSString*>::convert( nsstring );
+        }
+
+    } // namespace Detail
+#endif // __OBJC__
+
+} // namespace Catch
+
+//////////////////////////////////////////////////////
+// Separate std-lib types stringification, so it can be selectively enabled
+// This means that we do not bring in
+
+#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
+#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+#endif
+
+// Separate std::pair specialization
+#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
+#include <utility>
+namespace Catch {
+    template<typename T1, typename T2>
+    struct StringMaker<std::pair<T1, T2> > {
+        static std::string convert(const std::pair<T1, T2>& pair) {
+            ReusableStringStream rss;
+            rss << "{ "
+                << ::Catch::Detail::stringify(pair.first)
+                << ", "
+                << ::Catch::Detail::stringify(pair.second)
+                << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#include <optional>
+namespace Catch {
+    template<typename T>
+    struct StringMaker<std::optional<T> > {
+        static std::string convert(const std::optional<T>& optional) {
+            ReusableStringStream rss;
+            if (optional.has_value()) {
+                rss << ::Catch::Detail::stringify(*optional);
+            } else {
+                rss << "{ }";
+            }
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+
+// Separate std::tuple specialization
+#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
+#include <tuple>
+namespace Catch {
+    namespace Detail {
+        template<
+            typename Tuple,
+            std::size_t N = 0,
+            bool = (N < std::tuple_size<Tuple>::value)
+            >
+            struct TupleElementPrinter {
+            static void print(const Tuple& tuple, std::ostream& os) {
+                os << (N ? ", " : " ")
+                    << ::Catch::Detail::stringify(std::get<N>(tuple));
+                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
+            }
+        };
+
+        template<
+            typename Tuple,
+            std::size_t N
+        >
+            struct TupleElementPrinter<Tuple, N, false> {
+            static void print(const Tuple&, std::ostream&) {}
+        };
+
+    }
+
+    template<typename ...Types>
+    struct StringMaker<std::tuple<Types...>> {
+        static std::string convert(const std::tuple<Types...>& tuple) {
+            ReusableStringStream rss;
+            rss << '{';
+            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
+            rss << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
+#include <variant>
+namespace Catch {
+    template<>
+    struct StringMaker<std::monostate> {
+        static std::string convert(const std::monostate&) {
+            return "{ }";
+        }
+    };
+
+    template<typename... Elements>
+    struct StringMaker<std::variant<Elements...>> {
+        static std::string convert(const std::variant<Elements...>& variant) {
+            if (variant.valueless_by_exception()) {
+                return "{valueless variant}";
+            } else {
+                return std::visit(
+                    [](const auto& value) {
+                        return ::Catch::Detail::stringify(value);
+                    },
+                    variant
+                );
+            }
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+
+namespace Catch {
+    struct not_this_one {}; // Tag type for detecting which begin/ end are being selected
+
+    // Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
+    using std::begin;
+    using std::end;
+
+    not_this_one begin( ... );
+    not_this_one end( ... );
+
+    template <typename T>
+    struct is_range {
+        static const bool value =
+            !std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
+            !std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
+    };
+
+#if defined(_MANAGED) // Managed types are never ranges
+    template <typename T>
+    struct is_range<T^> {
+        static const bool value = false;
+    };
+#endif
+
+    template<typename Range>
+    std::string rangeToString( Range const& range ) {
+        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
+    }
+
+    // Handle vector<bool> specially
+    template<typename Allocator>
+    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
+        ReusableStringStream rss;
+        rss << "{ ";
+        bool first = true;
+        for( bool b : v ) {
+            if( first )
+                first = false;
+            else
+                rss << ", ";
+            rss << ::Catch::Detail::stringify( b );
+        }
+        rss << " }";
+        return rss.str();
+    }
+
+    template<typename R>
+    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
+        static std::string convert( R const& range ) {
+            return rangeToString( range );
+        }
+    };
+
+    template <typename T, int SZ>
+    struct StringMaker<T[SZ]> {
+        static std::string convert(T const(&arr)[SZ]) {
+            return rangeToString(arr);
+        }
+    };
+
+} // namespace Catch
+
+// Separate std::chrono::duration specialization
+#if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#include <ctime>
+#include <ratio>
+#include <chrono>
+
+namespace Catch {
+
+template <class Ratio>
+struct ratio_string {
+    static std::string symbol();
+};
+
+template <class Ratio>
+std::string ratio_string<Ratio>::symbol() {
+    Catch::ReusableStringStream rss;
+    rss << '[' << Ratio::num << '/'
+        << Ratio::den << ']';
+    return rss.str();
+}
+template <>
+struct ratio_string<std::atto> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::femto> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::pico> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::nano> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::micro> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::milli> {
+    static std::string symbol();
+};
+
+    ////////////
+    // std::chrono::duration specializations
+    template<typename Value, typename Ratio>
+    struct StringMaker<std::chrono::duration<Value, Ratio>> {
+        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " s";
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " m";
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " h";
+            return rss.str();
+        }
+    };
+
+    ////////////
+    // std::chrono::time_point specialization
+    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
+    template<typename Clock, typename Duration>
+    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
+        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
+            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
+        }
+    };
+    // std::chrono::time_point<system_clock> specialization
+    template<typename Duration>
+    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
+        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
+            auto converted = std::chrono::system_clock::to_time_t(time_point);
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &converted);
+#else
+            std::tm* timeInfo = std::gmtime(&converted);
+#endif
+
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp);
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+
+#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
+namespace Catch { \
+    template<> struct StringMaker<enumName> { \
+        static std::string convert( enumName value ) { \
+            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
+            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
+        } \
+    }; \
+}
+
+#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// end catch_tostring.h
+#include <iosfwd>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#pragma warning(disable:4018) // more "signed/unsigned mismatch"
+#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
+#pragma warning(disable:4180) // qualifier applied to function type has no meaning
+#pragma warning(disable:4800) // Forcing result to true or false
+#endif
+
+namespace Catch {
+
+    struct ITransientExpression {
+        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
+        auto getResult() const -> bool { return m_result; }
+        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
+
+        ITransientExpression( bool isBinaryExpression, bool result )
+        :   m_isBinaryExpression( isBinaryExpression ),
+            m_result( result )
+        {}
+
+        // We don't actually need a virtual destructor, but many static analysers
+        // complain if it's not here :-(
+        virtual ~ITransientExpression();
+
+        bool m_isBinaryExpression;
+        bool m_result;
+
+    };
+
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
+
+    template<typename LhsT, typename RhsT>
+    class BinaryExpr  : public ITransientExpression {
+        LhsT m_lhs;
+        StringRef m_op;
+        RhsT m_rhs;
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            formatReconstructedExpression
+                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
+        }
+
+    public:
+        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
+        :   ITransientExpression{ true, comparisonResult },
+            m_lhs( lhs ),
+            m_op( op ),
+            m_rhs( rhs )
+        {}
+
+        template<typename T>
+        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+    };
+
+    template<typename LhsT>
+    class UnaryExpr : public ITransientExpression {
+        LhsT m_lhs;
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            os << Catch::Detail::stringify( m_lhs );
+        }
+
+    public:
+        explicit UnaryExpr( LhsT lhs )
+        :   ITransientExpression{ false, static_cast<bool>(lhs) },
+            m_lhs( lhs )
+        {}
+    };
+
+    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
+    template<typename LhsT, typename RhsT>
+    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
+    template<typename T>
+    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
+    template<typename T>
+    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
+
+    template<typename LhsT, typename RhsT>
+    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
+    template<typename T>
+    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
+    template<typename T>
+    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
+
+    template<typename LhsT>
+    class ExprLhs {
+        LhsT m_lhs;
+    public:
+        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
+
+        template<typename RhsT>
+        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
+        }
+        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
+            return { m_lhs == rhs, m_lhs, "==", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
+        }
+        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
+            return { m_lhs != rhs, m_lhs, "!=", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
+        }
+        template<typename RhsT>
+        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
+        }
+        template<typename RhsT>
+        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
+        }
+        template<typename RhsT>
+        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator&& is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename RhsT>
+        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator|| is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
+            return UnaryExpr<LhsT>{ m_lhs };
+        }
+    };
+
+    void handleExpression( ITransientExpression const& expr );
+
+    template<typename T>
+    void handleExpression( ExprLhs<T> const& expr ) {
+        handleExpression( expr.makeUnaryExpr() );
+    }
+
+    struct Decomposer {
+        template<typename T>
+        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
+            return ExprLhs<T const&>{ lhs };
+        }
+
+        auto operator <=( bool value ) -> ExprLhs<bool> {
+            return ExprLhs<bool>{ value };
+        }
+    };
+
+} // end namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// end catch_decomposer.h
+// start catch_interfaces_capture.h
+
+#include <string>
+#include <chrono>
+
+namespace Catch {
+
+    class AssertionResult;
+    struct AssertionInfo;
+    struct SectionInfo;
+    struct SectionEndInfo;
+    struct MessageInfo;
+    struct MessageBuilder;
+    struct Counts;
+    struct AssertionReaction;
+    struct SourceLineInfo;
+
+    struct ITransientExpression;
+    struct IGeneratorTracker;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo;
+    template <typename Duration = std::chrono::duration<double, std::nano>>
+    struct BenchmarkStats;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    struct IResultCapture {
+
+        virtual ~IResultCapture();
+
+        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
+                                        Counts& assertions ) = 0;
+        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
+        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
+
+        virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& name ) = 0;
+        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
+        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
+        virtual void benchmarkFailed( std::string const& error ) = 0;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
+
+        virtual void handleFatalErrorCondition( StringRef message ) = 0;
+
+        virtual void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    StringRef const& message,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleUnexpectedExceptionNotThrown
+                (   AssertionInfo const& info,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleUnexpectedInflightException
+                (   AssertionInfo const& info,
+                    std::string const& message,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleIncomplete
+                (   AssertionInfo const& info ) = 0;
+        virtual void handleNonExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    AssertionReaction &reaction ) = 0;
+
+        virtual bool lastAssertionPassed() = 0;
+        virtual void assertionPassed() = 0;
+
+        // Deprecated, do not use:
+        virtual std::string getCurrentTestName() const = 0;
+        virtual const AssertionResult* getLastResult() const = 0;
+        virtual void exceptionEarlyReported() = 0;
+    };
+
+    IResultCapture& getResultCapture();
+}
+
+// end catch_interfaces_capture.h
+namespace Catch {
+
+    struct TestFailureException{};
+    struct AssertionResultData;
+    struct IResultCapture;
+    class RunContext;
+
+    class LazyExpression {
+        friend class AssertionHandler;
+        friend struct AssertionStats;
+        friend class RunContext;
+
+        ITransientExpression const* m_transientExpression = nullptr;
+        bool m_isNegated;
+    public:
+        LazyExpression( bool isNegated );
+        LazyExpression( LazyExpression const& other );
+        LazyExpression& operator = ( LazyExpression const& ) = delete;
+
+        explicit operator bool() const;
+
+        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
+    };
+
+    struct AssertionReaction {
+        bool shouldDebugBreak = false;
+        bool shouldThrow = false;
+    };
+
+    class AssertionHandler {
+        AssertionInfo m_assertionInfo;
+        AssertionReaction m_reaction;
+        bool m_completed = false;
+        IResultCapture& m_resultCapture;
+
+    public:
+        AssertionHandler
+            (   StringRef const& macroName,
+                SourceLineInfo const& lineInfo,
+                StringRef capturedExpression,
+                ResultDisposition::Flags resultDisposition );
+        ~AssertionHandler() {
+            if ( !m_completed ) {
+                m_resultCapture.handleIncomplete( m_assertionInfo );
+            }
+        }
+
+        template<typename T>
+        void handleExpr( ExprLhs<T> const& expr ) {
+            handleExpr( expr.makeUnaryExpr() );
+        }
+        void handleExpr( ITransientExpression const& expr );
+
+        void handleMessage(ResultWas::OfType resultType, StringRef const& message);
+
+        void handleExceptionThrownAsExpected();
+        void handleUnexpectedExceptionNotThrown();
+        void handleExceptionNotThrownAsExpected();
+        void handleThrowingCallSkipped();
+        void handleUnexpectedInflightException();
+
+        void complete();
+        void setCompleted();
+
+        // query
+        auto allowThrows() const -> bool;
+    };
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
+
+} // namespace Catch
+
+// end catch_assertionhandler.h
+// start catch_message.h
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    struct MessageInfo {
+        MessageInfo(    StringRef const& _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        ResultWas::OfType _type );
+
+        StringRef macroName;
+        std::string message;
+        SourceLineInfo lineInfo;
+        ResultWas::OfType type;
+        unsigned int sequence;
+
+        bool operator == ( MessageInfo const& other ) const;
+        bool operator < ( MessageInfo const& other ) const;
+    private:
+        static unsigned int globalCount;
+    };
+
+    struct MessageStream {
+
+        template<typename T>
+        MessageStream& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        ReusableStringStream m_stream;
+    };
+
+    struct MessageBuilder : MessageStream {
+        MessageBuilder( StringRef const& macroName,
+                        SourceLineInfo const& lineInfo,
+                        ResultWas::OfType type );
+
+        template<typename T>
+        MessageBuilder& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        MessageInfo m_info;
+    };
+
+    class ScopedMessage {
+    public:
+        explicit ScopedMessage( MessageBuilder const& builder );
+        ScopedMessage( ScopedMessage& duplicate ) = delete;
+        ScopedMessage( ScopedMessage&& old );
+        ~ScopedMessage();
+
+        MessageInfo m_info;
+        bool m_moved;
+    };
+
+    class Capturer {
+        std::vector<MessageInfo> m_messages;
+        IResultCapture& m_resultCapture = getResultCapture();
+        size_t m_captured = 0;
+    public:
+        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
+        ~Capturer();
+
+        void captureValue( size_t index, std::string const& value );
+
+        template<typename T>
+        void captureValues( size_t index, T const& value ) {
+            captureValue( index, Catch::Detail::stringify( value ) );
+        }
+
+        template<typename T, typename... Ts>
+        void captureValues( size_t index, T const& value, Ts const&... values ) {
+            captureValue( index, Catch::Detail::stringify(value) );
+            captureValues( index+1, values... );
+        }
+    };
+
+} // end namespace Catch
+
+// end catch_message.h
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
+  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
+#else
+  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+#endif
+
+#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+
+///////////////////////////////////////////////////////////////////////////////
+// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
+// macros.
+#define INTERNAL_CATCH_TRY
+#define INTERNAL_CATCH_CATCH( capturer )
+
+#else // CATCH_CONFIG_FAST_COMPILE
+
+#define INTERNAL_CATCH_TRY try
+#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
+
+#endif
+
+#define INTERNAL_CATCH_REACT( handler ) handler.complete();
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
+    do { \
+        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+    if( Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+    if( !Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        try { \
+            static_cast<void>(__VA_ARGS__); \
+            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
+        } \
+        catch( ... ) { \
+            catchAssertionHandler.handleUnexpectedInflightException(); \
+        } \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(expr); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
+        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
+    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
+    varName.captureValues( 0, __VA_ARGS__ )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_INFO( macroName, log ) \
+    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
+    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+
+///////////////////////////////////////////////////////////////////////////////
+// Although this is matcher-based, it can be used with just a string
+#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+#endif // CATCH_CONFIG_DISABLE
+
+// end catch_capture.hpp
+// start catch_section.h
+
+// start catch_section_info.h
+
+// start catch_totals.h
+
+#include <cstddef>
+
+namespace Catch {
+
+    struct Counts {
+        Counts operator - ( Counts const& other ) const;
+        Counts& operator += ( Counts const& other );
+
+        std::size_t total() const;
+        bool allPassed() const;
+        bool allOk() const;
+
+        std::size_t passed = 0;
+        std::size_t failed = 0;
+        std::size_t failedButOk = 0;
+    };
+
+    struct Totals {
+
+        Totals operator - ( Totals const& other ) const;
+        Totals& operator += ( Totals const& other );
+
+        Totals delta( Totals const& prevTotals ) const;
+
+        int error = 0;
+        Counts assertions;
+        Counts testCases;
+    };
+}
+
+// end catch_totals.h
+#include <string>
+
+namespace Catch {
+
+    struct SectionInfo {
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name );
+
+        // Deprecated
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name,
+                std::string const& ) : SectionInfo( _lineInfo, _name ) {}
+
+        std::string name;
+        std::string description; // !Deprecated: this will always be empty
+        SourceLineInfo lineInfo;
+    };
+
+    struct SectionEndInfo {
+        SectionInfo sectionInfo;
+        Counts prevAssertions;
+        double durationInSeconds;
+    };
+
+} // end namespace Catch
+
+// end catch_section_info.h
+// start catch_timer.h
+
+#include <cstdint>
+
+namespace Catch {
+
+    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
+    auto getEstimatedClockResolution() -> uint64_t;
+
+    class Timer {
+        uint64_t m_nanoseconds = 0;
+    public:
+        void start();
+        auto getElapsedNanoseconds() const -> uint64_t;
+        auto getElapsedMicroseconds() const -> uint64_t;
+        auto getElapsedMilliseconds() const -> unsigned int;
+        auto getElapsedSeconds() const -> double;
+    };
+
+} // namespace Catch
+
+// end catch_timer.h
+#include <string>
+
+namespace Catch {
+
+    class Section : NonCopyable {
+    public:
+        Section( SectionInfo const& info );
+        ~Section();
+
+        // This indicates whether the section should be executed or not
+        explicit operator bool() const;
+
+    private:
+        SectionInfo m_info;
+
+        std::string m_name;
+        Counts m_assertions;
+        bool m_sectionIncluded;
+        Timer m_timer;
+    };
+
+} // end namespace Catch
+
+#define INTERNAL_CATCH_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+// end catch_section.h
+// start catch_interfaces_exception.h
+
+// start catch_interfaces_registry_hub.h
+
+#include <string>
+#include <memory>
+
+namespace Catch {
+
+    class TestCase;
+    struct ITestCaseRegistry;
+    struct IExceptionTranslatorRegistry;
+    struct IExceptionTranslator;
+    struct IReporterRegistry;
+    struct IReporterFactory;
+    struct ITagAliasRegistry;
+    struct IMutableEnumValuesRegistry;
+
+    class StartupExceptionRegistry;
+
+    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+    struct IRegistryHub {
+        virtual ~IRegistryHub();
+
+        virtual IReporterRegistry const& getReporterRegistry() const = 0;
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
+
+        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
+    };
+
+    struct IMutableRegistryHub {
+        virtual ~IMutableRegistryHub();
+        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
+        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
+        virtual void registerTest( TestCase const& testInfo ) = 0;
+        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
+        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
+        virtual void registerStartupException() noexcept = 0;
+        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
+    };
+
+    IRegistryHub const& getRegistryHub();
+    IMutableRegistryHub& getMutableRegistryHub();
+    void cleanUp();
+    std::string translateActiveException();
+
+}
+
+// end catch_interfaces_registry_hub.h
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
+        static std::string translatorName( signature )
+#endif
+
+#include <exception>
+#include <string>
+#include <vector>
+
+namespace Catch {
+    using exceptionTranslateFunction = std::string(*)();
+
+    struct IExceptionTranslator;
+    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
+
+    struct IExceptionTranslator {
+        virtual ~IExceptionTranslator();
+        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
+    };
+
+    struct IExceptionTranslatorRegistry {
+        virtual ~IExceptionTranslatorRegistry();
+
+        virtual std::string translateActiveException() const = 0;
+    };
+
+    class ExceptionTranslatorRegistrar {
+        template<typename T>
+        class ExceptionTranslator : public IExceptionTranslator {
+        public:
+
+            ExceptionTranslator( std::string(*translateFunction)( T& ) )
+            : m_translateFunction( translateFunction )
+            {}
+
+            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
+                try {
+                    if( it == itEnd )
+                        std::rethrow_exception(std::current_exception());
+                    else
+                        return (*it)->translate( it+1, itEnd );
+                }
+                catch( T& ex ) {
+                    return m_translateFunction( ex );
+                }
+            }
+
+        protected:
+            std::string(*m_translateFunction)( T& );
+        };
+
+    public:
+        template<typename T>
+        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
+            getMutableRegistryHub().registerTranslator
+                ( new ExceptionTranslator<T>( translateFunction ) );
+        }
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
+    static std::string translatorName( signature ); \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+    static std::string translatorName( signature )
+
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+// end catch_interfaces_exception.h
+// start catch_approx.h
+
+#include <type_traits>
+
+namespace Catch {
+namespace Detail {
+
+    class Approx {
+    private:
+        bool equalityComparisonImpl(double other) const;
+        // Validates the new margin (margin >= 0)
+        // out-of-line to avoid including stdexcept in the header
+        void setMargin(double margin);
+        // Validates the new epsilon (0 < epsilon < 1)
+        // out-of-line to avoid including stdexcept in the header
+        void setEpsilon(double epsilon);
+
+    public:
+        explicit Approx ( double value );
+
+        static Approx custom();
+
+        Approx operator-() const;
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx operator()( T const& value ) {
+            Approx approx( static_cast<double>(value) );
+            approx.m_epsilon = m_epsilon;
+            approx.m_margin = m_margin;
+            approx.m_scale = m_scale;
+            return approx;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        explicit Approx( T const& value ): Approx(static_cast<double>(value))
+        {}
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( const T& lhs, Approx const& rhs ) {
+            auto lhs_v = static_cast<double>(lhs);
+            return rhs.equalityComparisonImpl(lhs_v);
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( Approx const& lhs, const T& rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( T const& lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( Approx const& lhs, T const& rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& epsilon( T const& newEpsilon ) {
+            double epsilonAsDouble = static_cast<double>(newEpsilon);
+            setEpsilon(epsilonAsDouble);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& margin( T const& newMargin ) {
+            double marginAsDouble = static_cast<double>(newMargin);
+            setMargin(marginAsDouble);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& scale( T const& newScale ) {
+            m_scale = static_cast<double>(newScale);
+            return *this;
+        }
+
+        std::string toString() const;
+
+    private:
+        double m_epsilon;
+        double m_margin;
+        double m_scale;
+        double m_value;
+    };
+} // end namespace Detail
+
+namespace literals {
+    Detail::Approx operator "" _a(long double val);
+    Detail::Approx operator "" _a(unsigned long long val);
+} // end namespace literals
+
+template<>
+struct StringMaker<Catch::Detail::Approx> {
+    static std::string convert(Catch::Detail::Approx const& value);
+};
+
+} // end namespace Catch
+
+// end catch_approx.h
+// start catch_string_manip.h
+
+#include <string>
+#include <iosfwd>
+#include <vector>
+
+namespace Catch {
+
+    bool startsWith( std::string const& s, std::string const& prefix );
+    bool startsWith( std::string const& s, char prefix );
+    bool endsWith( std::string const& s, std::string const& suffix );
+    bool endsWith( std::string const& s, char suffix );
+    bool contains( std::string const& s, std::string const& infix );
+    void toLowerInPlace( std::string& s );
+    std::string toLower( std::string const& s );
+    //! Returns a new string without whitespace at the start/end
+    std::string trim( std::string const& str );
+    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
+    StringRef trim(StringRef ref);
+
+    // !!! Be aware, returns refs into original string - make sure original string outlives them
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+
+    struct pluralise {
+        pluralise( std::size_t count, std::string const& label );
+
+        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+
+        std::size_t m_count;
+        std::string m_label;
+    };
+}
+
+// end catch_string_manip.h
+#ifndef CATCH_CONFIG_DISABLE_MATCHERS
+// start catch_capture_matchers.h
+
+// start catch_matchers.h
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+        template<typename ArgT> struct MatchAllOf;
+        template<typename ArgT> struct MatchAnyOf;
+        template<typename ArgT> struct MatchNotOf;
+
+        class MatcherUntypedBase {
+        public:
+            MatcherUntypedBase() = default;
+            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
+            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
+            std::string toString() const;
+
+        protected:
+            virtual ~MatcherUntypedBase();
+            virtual std::string describe() const = 0;
+            mutable std::string m_cachedToString;
+        };
+
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+        template<typename ObjectT>
+        struct MatcherMethod {
+            virtual bool match( ObjectT const& arg ) const = 0;
+        };
+
+#if defined(__OBJC__)
+        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
+        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
+        template<>
+        struct MatcherMethod<NSString*> {
+            virtual bool match( NSString* arg ) const = 0;
+        };
+#endif
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
+        template<typename T>
+        struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
+
+            MatchAllOf<T> operator && ( MatcherBase const& other ) const;
+            MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
+            MatchNotOf<T> operator ! () const;
+        };
+
+        template<typename ArgT>
+        struct MatchAllOf : MatcherBase<ArgT> {
+            bool match( ArgT const& arg ) const override {
+                for( auto matcher : m_matchers ) {
+                    if (!matcher->match(arg))
+                        return false;
+                }
+                return true;
+            }
+            std::string describe() const override {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                bool first = true;
+                for( auto matcher : m_matchers ) {
+                    if( first )
+                        first = false;
+                    else
+                        description += " and ";
+                    description += matcher->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+        template<typename ArgT>
+        struct MatchAnyOf : MatcherBase<ArgT> {
+
+            bool match( ArgT const& arg ) const override {
+                for( auto matcher : m_matchers ) {
+                    if (matcher->match(arg))
+                        return true;
+                }
+                return false;
+            }
+            std::string describe() const override {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                bool first = true;
+                for( auto matcher : m_matchers ) {
+                    if( first )
+                        first = false;
+                    else
+                        description += " or ";
+                    description += matcher->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+
+        template<typename ArgT>
+        struct MatchNotOf : MatcherBase<ArgT> {
+
+            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
+
+            bool match( ArgT const& arg ) const override {
+                return !m_underlyingMatcher.match( arg );
+            }
+
+            std::string describe() const override {
+                return "not " + m_underlyingMatcher.toString();
+            }
+            MatcherBase<ArgT> const& m_underlyingMatcher;
+        };
+
+        template<typename T>
+        MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
+            return MatchAllOf<T>() && *this && other;
+        }
+        template<typename T>
+        MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
+            return MatchAnyOf<T>() || *this || other;
+        }
+        template<typename T>
+        MatchNotOf<T> MatcherBase<T>::operator ! () const {
+            return MatchNotOf<T>( *this );
+        }
+
+    } // namespace Impl
+
+} // namespace Matchers
+
+using namespace Matchers;
+using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+
+// end catch_matchers.h
+// start catch_matchers_exception.hpp
+
+namespace Catch {
+namespace Matchers {
+namespace Exception {
+
+class ExceptionMessageMatcher : public MatcherBase<std::exception> {
+    std::string m_message;
+public:
+
+    ExceptionMessageMatcher(std::string const& message):
+        m_message(message)
+    {}
+
+    bool match(std::exception const& ex) const override;
+
+    std::string describe() const override;
+};
+
+} // namespace Exception
+
+Exception::ExceptionMessageMatcher Message(std::string const& message);
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_exception.hpp
+// start catch_matchers_floating.h
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Floating {
+
+        enum class FloatingPointKind : uint8_t;
+
+        struct WithinAbsMatcher : MatcherBase<double> {
+            WithinAbsMatcher(double target, double margin);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            double m_margin;
+        };
+
+        struct WithinUlpsMatcher : MatcherBase<double> {
+            WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            uint64_t m_ulps;
+            FloatingPointKind m_type;
+        };
+
+        // Given IEEE-754 format for floats and doubles, we can assume
+        // that float -> double promotion is lossless. Given this, we can
+        // assume that if we do the standard relative comparison of
+        // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
+        // the same result if we do this for floats, as if we do this for
+        // doubles that were promoted from floats.
+        struct WithinRelMatcher : MatcherBase<double> {
+            WithinRelMatcher(double target, double epsilon);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            double m_epsilon;
+        };
+
+    } // namespace Floating
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
+    Floating::WithinAbsMatcher WithinAbs(double target, double margin);
+    Floating::WithinRelMatcher WithinRel(double target, double eps);
+    // defaults epsilon to 100*numeric_limits<double>::epsilon()
+    Floating::WithinRelMatcher WithinRel(double target);
+    Floating::WithinRelMatcher WithinRel(float target, float eps);
+    // defaults epsilon to 100*numeric_limits<float>::epsilon()
+    Floating::WithinRelMatcher WithinRel(float target);
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_floating.h
+// start catch_matchers_generic.hpp
+
+#include <functional>
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+namespace Generic {
+
+namespace Detail {
+    std::string finalizeDescription(const std::string& desc);
+}
+
+template <typename T>
+class PredicateMatcher : public MatcherBase<T> {
+    std::function<bool(T const&)> m_predicate;
+    std::string m_description;
+public:
+
+    PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
+        :m_predicate(std::move(elem)),
+        m_description(Detail::finalizeDescription(descr))
+    {}
+
+    bool match( T const& item ) const override {
+        return m_predicate(item);
+    }
+
+    std::string describe() const override {
+        return m_description;
+    }
+};
+
+} // namespace Generic
+
+    // The following functions create the actual matcher objects.
+    // The user has to explicitly specify type to the function, because
+    // inferring std::function<bool(T const&)> is hard (but possible) and
+    // requires a lot of TMP.
+    template<typename T>
+    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
+        return Generic::PredicateMatcher<T>(predicate, description);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_generic.hpp
+// start catch_matchers_string.h
+
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        struct CasedString
+        {
+            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
+            std::string adjustString( std::string const& str ) const;
+            std::string caseSensitivitySuffix() const;
+
+            CaseSensitive::Choice m_caseSensitivity;
+            std::string m_str;
+        };
+
+        struct StringMatcherBase : MatcherBase<std::string> {
+            StringMatcherBase( std::string const& operation, CasedString const& comparator );
+            std::string describe() const override;
+
+            CasedString m_comparator;
+            std::string m_operation;
+        };
+
+        struct EqualsMatcher : StringMatcherBase {
+            EqualsMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+        struct ContainsMatcher : StringMatcherBase {
+            ContainsMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+        struct StartsWithMatcher : StringMatcherBase {
+            StartsWithMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+        struct EndsWithMatcher : StringMatcherBase {
+            EndsWithMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+
+        struct RegexMatcher : MatcherBase<std::string> {
+            RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
+            bool match( std::string const& matchee ) const override;
+            std::string describe() const override;
+
+        private:
+            std::string m_regex;
+            CaseSensitive::Choice m_caseSensitivity;
+        };
+
+    } // namespace StdString
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_string.h
+// start catch_matchers_vector.h
+
+#include <algorithm>
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Vector {
+        template<typename T>
+        struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
+
+            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
+
+            bool match(std::vector<T> const &v) const override {
+                for (auto const& el : v) {
+                    if (el == m_comparator) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            std::string describe() const override {
+                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+            }
+
+            T const& m_comparator;
+        };
+
+        template<typename T>
+        struct ContainsMatcher : MatcherBase<std::vector<T>> {
+
+            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                // !TBD: see note in EqualsMatcher
+                if (m_comparator.size() > v.size())
+                    return false;
+                for (auto const& comparator : m_comparator) {
+                    auto present = false;
+                    for (const auto& el : v) {
+                        if (el == comparator) {
+                            present = true;
+                            break;
+                        }
+                    }
+                    if (!present) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            std::string describe() const override {
+                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+            }
+
+            std::vector<T> const& m_comparator;
+        };
+
+        template<typename T>
+        struct EqualsMatcher : MatcherBase<std::vector<T>> {
+
+            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                // !TBD: This currently works if all elements can be compared using !=
+                // - a more general approach would be via a compare template that defaults
+                // to using !=. but could be specialised for, e.g. std::vector<T> etc
+                // - then just call that directly
+                if (m_comparator.size() != v.size())
+                    return false;
+                for (std::size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != v[i])
+                        return false;
+                return true;
+            }
+            std::string describe() const override {
+                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
+            }
+            std::vector<T> const& m_comparator;
+        };
+
+        template<typename T>
+        struct ApproxMatcher : MatcherBase<std::vector<T>> {
+
+            ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                if (m_comparator.size() != v.size())
+                    return false;
+                for (std::size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != approx(v[i]))
+                        return false;
+                return true;
+            }
+            std::string describe() const override {
+                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& epsilon( T const& newEpsilon ) {
+                approx.epsilon(newEpsilon);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& margin( T const& newMargin ) {
+                approx.margin(newMargin);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& scale( T const& newScale ) {
+                approx.scale(newScale);
+                return *this;
+            }
+
+            std::vector<T> const& m_comparator;
+            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
+        };
+
+        template<typename T>
+        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
+            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
+            bool match(std::vector<T> const& vec) const override {
+                // Note: This is a reimplementation of std::is_permutation,
+                //       because I don't want to include <algorithm> inside the common path
+                if (m_target.size() != vec.size()) {
+                    return false;
+                }
+                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
+            }
+
+            std::string describe() const override {
+                return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
+            }
+        private:
+            std::vector<T> const& m_target;
+        };
+
+    } // namespace Vector
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    template<typename T>
+    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
+        return Vector::ContainsMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
+        return Vector::ContainsElementMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
+        return Vector::EqualsMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::ApproxMatcher<T> Approx( std::vector<T> const& comparator ) {
+        return Vector::ApproxMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
+        return Vector::UnorderedEqualsMatcher<T>(target);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_vector.h
+namespace Catch {
+
+    template<typename ArgT, typename MatcherT>
+    class MatchExpr : public ITransientExpression {
+        ArgT const& m_arg;
+        MatcherT m_matcher;
+        StringRef m_matcherString;
+    public:
+        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
+        :   ITransientExpression{ true, matcher.match( arg ) },
+            m_arg( arg ),
+            m_matcher( matcher ),
+            m_matcherString( matcherString )
+        {}
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            auto matcherAsString = m_matcher.toString();
+            os << Catch::Detail::stringify( m_arg ) << ' ';
+            if( matcherAsString == Detail::unprintableString )
+                os << m_matcherString;
+            else
+                os << matcherAsString;
+        }
+    };
+
+    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
+
+    template<typename ArgT, typename MatcherT>
+    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
+        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
+    }
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__ ); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ex ) { \
+                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+// end catch_capture_matchers.h
+#endif
+// start catch_generators.hpp
+
+// start catch_interfaces_generatortracker.h
+
+
+#include <memory>
+
+namespace Catch {
+
+    namespace Generators {
+        class GeneratorUntypedBase {
+        public:
+            GeneratorUntypedBase() = default;
+            virtual ~GeneratorUntypedBase();
+            // Attempts to move the generator to the next element
+             //
+             // Returns true iff the move succeeded (and a valid element
+             // can be retrieved).
+            virtual bool next() = 0;
+        };
+        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
+
+    } // namespace Generators
+
+    struct IGeneratorTracker {
+        virtual ~IGeneratorTracker();
+        virtual auto hasGenerator() const -> bool = 0;
+        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
+        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
+    };
+
+} // namespace Catch
+
+// end catch_interfaces_generatortracker.h
+// start catch_enforce.h
+
+#include <exception>
+
+namespace Catch {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    template <typename Ex>
+    [[noreturn]]
+    void throw_exception(Ex const& e) {
+        throw e;
+    }
+#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
+    [[noreturn]]
+    void throw_exception(std::exception const& e);
+#endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg);
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg);
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg);
+
+} // namespace Catch;
+
+#define CATCH_MAKE_MSG(...) \
+    (Catch::ReusableStringStream() << __VA_ARGS__).str()
+
+#define CATCH_INTERNAL_ERROR(...) \
+    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
+
+#define CATCH_ERROR(...) \
+    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_RUNTIME_ERROR(...) \
+    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_ENFORCE( condition, ... ) \
+    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
+
+// end catch_enforce.h
+#include <memory>
+#include <vector>
+#include <cassert>
+
+#include <utility>
+#include <exception>
+
+namespace Catch {
+
+class GeneratorException : public std::exception {
+    const char* const m_msg = "";
+
+public:
+    GeneratorException(const char* msg):
+        m_msg(msg)
+    {}
+
+    const char* what() const noexcept override final;
+};
+
+namespace Generators {
+
+    // !TBD move this into its own location?
+    namespace pf{
+        template<typename T, typename... Args>
+        std::unique_ptr<T> make_unique( Args&&... args ) {
+            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+        }
+    }
+
+    template<typename T>
+    struct IGenerator : GeneratorUntypedBase {
+        virtual ~IGenerator() = default;
+
+        // Returns the current element of the generator
+        //
+        // \Precondition The generator is either freshly constructed,
+        // or the last call to `next()` returned true
+        virtual T const& get() const = 0;
+        using type = T;
+    };
+
+    template<typename T>
+    class SingleValueGenerator final : public IGenerator<T> {
+        T m_value;
+    public:
+        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
+
+        T const& get() const override {
+            return m_value;
+        }
+        bool next() override {
+            return false;
+        }
+    };
+
+    template<typename T>
+    class FixedValuesGenerator final : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "FixedValuesGenerator does not support bools because of std::vector<bool>"
+            "specialization, use SingleValue Generator instead.");
+        std::vector<T> m_values;
+        size_t m_idx = 0;
+    public:
+        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
+
+        T const& get() const override {
+            return m_values[m_idx];
+        }
+        bool next() override {
+            ++m_idx;
+            return m_idx < m_values.size();
+        }
+    };
+
+    template <typename T>
+    class GeneratorWrapper final {
+        std::unique_ptr<IGenerator<T>> m_generator;
+    public:
+        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
+            m_generator(std::move(generator))
+        {}
+        T const& get() const {
+            return m_generator->get();
+        }
+        bool next() {
+            return m_generator->next();
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> value(T&& value) {
+        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
+    }
+    template <typename T>
+    GeneratorWrapper<T> values(std::initializer_list<T> values) {
+        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
+    }
+
+    template<typename T>
+    class Generators : public IGenerator<T> {
+        std::vector<GeneratorWrapper<T>> m_generators;
+        size_t m_current = 0;
+
+        void populate(GeneratorWrapper<T>&& generator) {
+            m_generators.emplace_back(std::move(generator));
+        }
+        void populate(T&& val) {
+            m_generators.emplace_back(value(std::forward<T>(val)));
+        }
+        template<typename U>
+        void populate(U&& val) {
+            populate(T(std::forward<U>(val)));
+        }
+        template<typename U, typename... Gs>
+        void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
+            populate(std::forward<U>(valueOrGenerator));
+            populate(std::forward<Gs>(moreGenerators)...);
+        }
+
+    public:
+        template <typename... Gs>
+        Generators(Gs &&... moreGenerators) {
+            m_generators.reserve(sizeof...(Gs));
+            populate(std::forward<Gs>(moreGenerators)...);
+        }
+
+        T const& get() const override {
+            return m_generators[m_current].get();
+        }
+
+        bool next() override {
+            if (m_current >= m_generators.size()) {
+                return false;
+            }
+            const bool current_status = m_generators[m_current].next();
+            if (!current_status) {
+                ++m_current;
+            }
+            return m_current < m_generators.size();
+        }
+    };
+
+    template<typename... Ts>
+    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
+        return values<std::tuple<Ts...>>( tuples );
+    }
+
+    // Tag type to signal that a generator sequence should convert arguments to a specific type
+    template <typename T>
+    struct as {};
+
+    template<typename T, typename... Gs>
+    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
+        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
+    }
+    template<typename T>
+    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
+        return Generators<T>(std::move(generator));
+    }
+    template<typename T, typename... Gs>
+    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
+    }
+    template<typename T, typename U, typename... Gs>
+    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
+    }
+
+    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
+
+    template<typename L>
+    // Note: The type after -> is weird, because VS2015 cannot parse
+    //       the expression used in the typedef inside, when it is in
+    //       return type. Yeah.
+    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
+        using UnderlyingType = typename decltype(generatorExpression())::type;
+
+        IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
+        if (!tracker.hasGenerator()) {
+            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
+        }
+
+        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
+        return generator.get();
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+#define GENERATE( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_COPY( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_REF( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+
+// end catch_generators.hpp
+// start catch_generators_generic.hpp
+
+namespace Catch {
+namespace Generators {
+
+    template <typename T>
+    class TakeGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        size_t m_returned = 0;
+        size_t m_target;
+    public:
+        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target(target)
+        {
+            assert(target != 0 && "Empty generators are not allowed");
+        }
+        T const& get() const override {
+            return m_generator.get();
+        }
+        bool next() override {
+            ++m_returned;
+            if (m_returned >= m_target) {
+                return false;
+            }
+
+            const auto success = m_generator.next();
+            // If the underlying generator does not contain enough values
+            // then we cut short as well
+            if (!success) {
+                m_returned = m_target;
+            }
+            return success;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
+    }
+
+    template <typename T, typename Predicate>
+    class FilterGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        Predicate m_predicate;
+    public:
+        template <typename P = Predicate>
+        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_predicate(std::forward<P>(pred))
+        {
+            if (!m_predicate(m_generator.get())) {
+                // It might happen that there are no values that pass the
+                // filter. In that case we throw an exception.
+                auto has_initial_value = next();
+                if (!has_initial_value) {
+                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
+                }
+            }
+        }
+
+        T const& get() const override {
+            return m_generator.get();
+        }
+
+        bool next() override {
+            bool success = m_generator.next();
+            if (!success) {
+                return false;
+            }
+            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
+            return success;
+        }
+    };
+
+    template <typename T, typename Predicate>
+    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
+    }
+
+    template <typename T>
+    class RepeatGenerator : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "RepeatGenerator currently does not support bools"
+            "because of std::vector<bool> specialization");
+        GeneratorWrapper<T> m_generator;
+        mutable std::vector<T> m_returned;
+        size_t m_target_repeats;
+        size_t m_current_repeat = 0;
+        size_t m_repeat_index = 0;
+    public:
+        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target_repeats(repeats)
+        {
+            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
+        }
+
+        T const& get() const override {
+            if (m_current_repeat == 0) {
+                m_returned.push_back(m_generator.get());
+                return m_returned.back();
+            }
+            return m_returned[m_repeat_index];
+        }
+
+        bool next() override {
+            // There are 2 basic cases:
+            // 1) We are still reading the generator
+            // 2) We are reading our own cache
+
+            // In the first case, we need to poke the underlying generator.
+            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
+            if (m_current_repeat == 0) {
+                const auto success = m_generator.next();
+                if (!success) {
+                    ++m_current_repeat;
+                }
+                return m_current_repeat < m_target_repeats;
+            }
+
+            // In the second case, we need to move indices forward and check that we haven't run up against the end
+            ++m_repeat_index;
+            if (m_repeat_index == m_returned.size()) {
+                m_repeat_index = 0;
+                ++m_current_repeat;
+            }
+            return m_current_repeat < m_target_repeats;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
+    }
+
+    template <typename T, typename U, typename Func>
+    class MapGenerator : public IGenerator<T> {
+        // TBD: provide static assert for mapping function, for friendly error message
+        GeneratorWrapper<U> m_generator;
+        Func m_function;
+        // To avoid returning dangling reference, we have to save the values
+        T m_cache;
+    public:
+        template <typename F2 = Func>
+        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
+            m_generator(std::move(generator)),
+            m_function(std::forward<F2>(function)),
+            m_cache(m_function(m_generator.get()))
+        {}
+
+        T const& get() const override {
+            return m_cache;
+        }
+        bool next() override {
+            const auto success = m_generator.next();
+            if (success) {
+                m_cache = m_function(m_generator.get());
+            }
+            return success;
+        }
+    };
+
+    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
+
+    template <typename T, typename U, typename Func>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
+
+    template <typename T>
+    class ChunkGenerator final : public IGenerator<std::vector<T>> {
+        std::vector<T> m_chunk;
+        size_t m_chunk_size;
+        GeneratorWrapper<T> m_generator;
+        bool m_used_up = false;
+    public:
+        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
+            m_chunk_size(size), m_generator(std::move(generator))
+        {
+            m_chunk.reserve(m_chunk_size);
+            if (m_chunk_size != 0) {
+                m_chunk.push_back(m_generator.get());
+                for (size_t i = 1; i < m_chunk_size; ++i) {
+                    if (!m_generator.next()) {
+                        Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
+                    }
+                    m_chunk.push_back(m_generator.get());
+                }
+            }
+        }
+        std::vector<T> const& get() const override {
+            return m_chunk;
+        }
+        bool next() override {
+            m_chunk.clear();
+            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
+                if (!m_generator.next()) {
+                    return false;
+                }
+                m_chunk.push_back(m_generator.get());
+            }
+            return true;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<std::vector<T>>(
+            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
+        );
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+// end catch_generators_generic.hpp
+// start catch_generators_specific.hpp
+
+// start catch_context.h
+
+#include <memory>
+
+namespace Catch {
+
+    struct IResultCapture;
+    struct IRunner;
+    struct IConfig;
+    struct IMutableContext;
+
+    using IConfigPtr = std::shared_ptr<IConfig const>;
+
+    struct IContext
+    {
+        virtual ~IContext();
+
+        virtual IResultCapture* getResultCapture() = 0;
+        virtual IRunner* getRunner() = 0;
+        virtual IConfigPtr const& getConfig() const = 0;
+    };
+
+    struct IMutableContext : IContext
+    {
+        virtual ~IMutableContext();
+        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+        virtual void setRunner( IRunner* runner ) = 0;
+        virtual void setConfig( IConfigPtr const& config ) = 0;
+
+    private:
+        static IMutableContext *currentContext;
+        friend IMutableContext& getCurrentMutableContext();
+        friend void cleanUpContext();
+        static void createContext();
+    };
+
+    inline IMutableContext& getCurrentMutableContext()
+    {
+        if( !IMutableContext::currentContext )
+            IMutableContext::createContext();
+        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+        return *IMutableContext::currentContext;
+    }
+
+    inline IContext& getCurrentContext()
+    {
+        return getCurrentMutableContext();
+    }
+
+    void cleanUpContext();
+
+    class SimplePcg32;
+    SimplePcg32& rng();
+}
+
+// end catch_context.h
+// start catch_interfaces_config.h
+
+// start catch_option.hpp
+
+namespace Catch {
+
+    // An optional type
+    template<typename T>
+    class Option {
+    public:
+        Option() : nullableValue( nullptr ) {}
+        Option( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Option( Option const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
+        {}
+
+        ~Option() {
+            reset();
+        }
+
+        Option& operator= ( Option const& _other ) {
+            if( &_other != this ) {
+                reset();
+                if( _other )
+                    nullableValue = new( storage ) T( *_other );
+            }
+            return *this;
+        }
+        Option& operator = ( T const& _value ) {
+            reset();
+            nullableValue = new( storage ) T( _value );
+            return *this;
+        }
+
+        void reset() {
+            if( nullableValue )
+                nullableValue->~T();
+            nullableValue = nullptr;
+        }
+
+        T& operator*() { return *nullableValue; }
+        T const& operator*() const { return *nullableValue; }
+        T* operator->() { return nullableValue; }
+        const T* operator->() const { return nullableValue; }
+
+        T valueOr( T const& defaultValue ) const {
+            return nullableValue ? *nullableValue : defaultValue;
+        }
+
+        bool some() const { return nullableValue != nullptr; }
+        bool none() const { return nullableValue == nullptr; }
+
+        bool operator !() const { return nullableValue == nullptr; }
+        explicit operator bool() const {
+            return some();
+        }
+
+    private:
+        T *nullableValue;
+        alignas(alignof(T)) char storage[sizeof(T)];
+    };
+
+} // end namespace Catch
+
+// end catch_option.hpp
+#include <chrono>
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    enum class Verbosity {
+        Quiet = 0,
+        Normal,
+        High
+    };
+
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        NoAssertions = 0x01,
+        NoTests = 0x02
+    }; };
+
+    struct ShowDurations { enum OrNot {
+        DefaultForReporter,
+        Always,
+        Never
+    }; };
+    struct RunTests { enum InWhatOrder {
+        InDeclarationOrder,
+        InLexicographicalOrder,
+        InRandomOrder
+    }; };
+    struct UseColour { enum YesOrNo {
+        Auto,
+        Yes,
+        No
+    }; };
+    struct WaitForKeypress { enum When {
+        Never,
+        BeforeStart = 1,
+        BeforeExit = 2,
+        BeforeStartAndExit = BeforeStart | BeforeExit
+    }; };
+
+    class TestSpec;
+
+    struct IConfig : NonCopyable {
+
+        virtual ~IConfig();
+
+        virtual bool allowThrows() const = 0;
+        virtual std::ostream& stream() const = 0;
+        virtual std::string name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual bool warnAboutNoTests() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations::OrNot showDurations() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+        virtual bool hasTestFilters() const = 0;
+        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
+        virtual RunTests::InWhatOrder runOrder() const = 0;
+        virtual unsigned int rngSeed() const = 0;
+        virtual UseColour::YesOrNo useColour() const = 0;
+        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+        virtual Verbosity verbosity() const = 0;
+
+        virtual bool benchmarkNoAnalysis() const = 0;
+        virtual int benchmarkSamples() const = 0;
+        virtual double benchmarkConfidenceInterval() const = 0;
+        virtual unsigned int benchmarkResamples() const = 0;
+        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
+    };
+
+    using IConfigPtr = std::shared_ptr<IConfig const>;
+}
+
+// end catch_interfaces_config.h
+// start catch_random_number_generator.h
+
+#include <cstdint>
+
+namespace Catch {
+
+    // This is a simple implementation of C++11 Uniform Random Number
+    // Generator. It does not provide all operators, because Catch2
+    // does not use it, but it should behave as expected inside stdlib's
+    // distributions.
+    // The implementation is based on the PCG family (http://pcg-random.org)
+    class SimplePcg32 {
+        using state_type = std::uint64_t;
+    public:
+        using result_type = std::uint32_t;
+        static constexpr result_type (min)() {
+            return 0;
+        }
+        static constexpr result_type (max)() {
+            return static_cast<result_type>(-1);
+        }
+
+        // Provide some default initial state for the default constructor
+        SimplePcg32():SimplePcg32(0xed743cc4U) {}
+
+        explicit SimplePcg32(result_type seed_);
+
+        void seed(result_type seed_);
+        void discard(uint64_t skip);
+
+        result_type operator()();
+
+    private:
+        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+
+        // In theory we also need operator<< and operator>>
+        // In practice we do not use them, so we will skip them for now
+
+        std::uint64_t m_state;
+        // This part of the state determines which "stream" of the numbers
+        // is chosen -- we take it as a constant for Catch2, so we only
+        // need to deal with seeding the main state.
+        // Picked by reading 8 bytes from `/dev/random` :-)
+        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
+    };
+
+} // end namespace Catch
+
+// end catch_random_number_generator.h
+#include <random>
+
+namespace Catch {
+namespace Generators {
+
+template <typename Float>
+class RandomFloatingGenerator final : public IGenerator<Float> {
+    Catch::SimplePcg32& m_rng;
+    std::uniform_real_distribution<Float> m_dist;
+    Float m_current_number;
+public:
+
+    RandomFloatingGenerator(Float a, Float b):
+        m_rng(rng()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Float const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+template <typename Integer>
+class RandomIntegerGenerator final : public IGenerator<Integer> {
+    Catch::SimplePcg32& m_rng;
+    std::uniform_int_distribution<Integer> m_dist;
+    Integer m_current_number;
+public:
+
+    RandomIntegerGenerator(Integer a, Integer b):
+        m_rng(rng()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Integer const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+// TODO: Ideally this would be also constrained against the various char types,
+//       but I don't expect users to run into that in practice.
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
+    );
+}
+
+template <typename T>
+typename std::enable_if<std::is_floating_point<T>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
+    );
+}
+
+template <typename T>
+class RangeGenerator final : public IGenerator<T> {
+    T m_current;
+    T m_end;
+    T m_step;
+    bool m_positive;
+
+public:
+    RangeGenerator(T const& start, T const& end, T const& step):
+        m_current(start),
+        m_end(end),
+        m_step(step),
+        m_positive(m_step > T(0))
+    {
+        assert(m_current != m_end && "Range start and end cannot be equal");
+        assert(m_step != T(0) && "Step size cannot be zero");
+        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
+    }
+
+    RangeGenerator(T const& start, T const& end):
+        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
+    {}
+
+    T const& get() const override {
+        return m_current;
+    }
+
+    bool next() override {
+        m_current += m_step;
+        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
+    }
+};
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
+    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
+}
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end) {
+    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
+}
+
+template <typename T>
+class IteratorGenerator final : public IGenerator<T> {
+    static_assert(!std::is_same<T, bool>::value,
+        "IteratorGenerator currently does not support bools"
+        "because of std::vector<bool> specialization");
+
+    std::vector<T> m_elems;
+    size_t m_current = 0;
+public:
+    template <typename InputIterator, typename InputSentinel>
+    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
+        if (m_elems.empty()) {
+            Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
+        }
+    }
+
+    T const& get() const override {
+        return m_elems[m_current];
+    }
+
+    bool next() override {
+        ++m_current;
+        return m_current != m_elems.size();
+    }
+};
+
+template <typename InputIterator,
+          typename InputSentinel,
+          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
+GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
+    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
+}
+
+template <typename Container,
+          typename ResultType = typename Container::value_type>
+GeneratorWrapper<ResultType> from_range(Container const& cnt) {
+    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
+}
+
+} // namespace Generators
+} // namespace Catch
+
+// end catch_generators_specific.hpp
+
+// These files are included here so the single_include script doesn't put them
+// in the conditionally compiled sections
+// start catch_test_case_info.h
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct ITestInvoker;
+
+    struct TestCaseInfo {
+        enum SpecialProperties{
+            None = 0,
+            IsHidden = 1 << 1,
+            ShouldFail = 1 << 2,
+            MayFail = 1 << 3,
+            Throws = 1 << 4,
+            NonPortable = 1 << 5,
+            Benchmark = 1 << 6
+        };
+
+        TestCaseInfo(   std::string const& _name,
+                        std::string const& _className,
+                        std::string const& _description,
+                        std::vector<std::string> const& _tags,
+                        SourceLineInfo const& _lineInfo );
+
+        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
+
+        bool isHidden() const;
+        bool throws() const;
+        bool okToFail() const;
+        bool expectedToFail() const;
+
+        std::string tagsAsString() const;
+
+        std::string name;
+        std::string className;
+        std::string description;
+        std::vector<std::string> tags;
+        std::vector<std::string> lcaseTags;
+        SourceLineInfo lineInfo;
+        SpecialProperties properties;
+    };
+
+    class TestCase : public TestCaseInfo {
+    public:
+
+        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
+
+        TestCase withName( std::string const& _newName ) const;
+
+        void invoke() const;
+
+        TestCaseInfo const& getTestCaseInfo() const;
+
+        bool operator == ( TestCase const& other ) const;
+        bool operator < ( TestCase const& other ) const;
+
+    private:
+        std::shared_ptr<ITestInvoker> test;
+    };
+
+    TestCase makeTestCase(  ITestInvoker* testCase,
+                            std::string const& className,
+                            NameAndTags const& nameAndTags,
+                            SourceLineInfo const& lineInfo );
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_case_info.h
+// start catch_interfaces_runner.h
+
+namespace Catch {
+
+    struct IRunner {
+        virtual ~IRunner();
+        virtual bool aborting() const = 0;
+    };
+}
+
+// end catch_interfaces_runner.h
+
+#ifdef __OBJC__
+// start catch_objc.hpp
+
+#import <objc/runtime.h>
+
+#include <string>
+
+// NB. Any general catch headers included here must be included
+// in catch.hpp first to make sure they are included by the single
+// header for non obj-usage
+
+///////////////////////////////////////////////////////////////////////////////
+// This protocol is really only here for (self) documenting purposes, since
+// all its methods are optional.
+@protocol OcFixture
+
+@optional
+
+-(void) setUp;
+-(void) tearDown;
+
+@end
+
+namespace Catch {
+
+    class OcMethod : public ITestInvoker {
+
+    public:
+        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+
+        virtual void invoke() const {
+            id obj = [[m_cls alloc] init];
+
+            performOptionalSelector( obj, @selector(setUp)  );
+            performOptionalSelector( obj, m_sel );
+            performOptionalSelector( obj, @selector(tearDown)  );
+
+            arcSafeRelease( obj );
+        }
+    private:
+        virtual ~OcMethod() {}
+
+        Class m_cls;
+        SEL m_sel;
+    };
+
+    namespace Detail{
+
+        inline std::string getAnnotation(   Class cls,
+                                            std::string const& annotationName,
+                                            std::string const& testCaseName ) {
+            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+            SEL sel = NSSelectorFromString( selStr );
+            arcSafeRelease( selStr );
+            id value = performOptionalSelector( cls, sel );
+            if( value )
+                return [(NSString*)value UTF8String];
+            return "";
+        }
+    }
+
+    inline std::size_t registerTestMethods() {
+        std::size_t noTestMethods = 0;
+        int noClasses = objc_getClassList( nullptr, 0 );
+
+        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
+        objc_getClassList( classes, noClasses );
+
+        for( int c = 0; c < noClasses; c++ ) {
+            Class cls = classes[c];
+            {
+                u_int count;
+                Method* methods = class_copyMethodList( cls, &count );
+                for( u_int m = 0; m < count ; m++ ) {
+                    SEL selector = method_getName(methods[m]);
+                    std::string methodName = sel_getName(selector);
+                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
+                        std::string testCaseName = methodName.substr( 15 );
+                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
+                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
+                        const char* className = class_getName( cls );
+
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
+                        noTestMethods++;
+                    }
+                }
+                free(methods);
+            }
+        }
+        return noTestMethods;
+    }
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+
+    namespace Matchers {
+        namespace Impl {
+        namespace NSStringMatchers {
+
+            struct StringHolder : MatcherBase<NSString*>{
+                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
+                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
+                StringHolder() {
+                    arcSafeRelease( m_substr );
+                }
+
+                bool match( NSString* str ) const override {
+                    return false;
+                }
+
+                NSString* CATCH_ARC_STRONG m_substr;
+            };
+
+            struct Equals : StringHolder {
+                Equals( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str isEqualToString:m_substr];
+                }
+
+                std::string describe() const override {
+                    return "equals string: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+            struct Contains : StringHolder {
+                Contains( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location != NSNotFound;
+                }
+
+                std::string describe() const override {
+                    return "contains string: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+            struct StartsWith : StringHolder {
+                StartsWith( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == 0;
+                }
+
+                std::string describe() const override {
+                    return "starts with: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+            struct EndsWith : StringHolder {
+                EndsWith( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
+                }
+
+                std::string describe() const override {
+                    return "ends with: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+        } // namespace NSStringMatchers
+        } // namespace Impl
+
+        inline Impl::NSStringMatchers::Equals
+            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+
+        inline Impl::NSStringMatchers::Contains
+            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+
+        inline Impl::NSStringMatchers::StartsWith
+            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+
+        inline Impl::NSStringMatchers::EndsWith
+            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+
+    } // namespace Matchers
+
+    using namespace Matchers;
+
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
+#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
+{ \
+return @ name; \
+} \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
+{ \
+return @ desc; \
+} \
+-(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
+
+#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
+
+// end catch_objc.hpp
+#endif
+
+// Benchmarking needs the externally-facing parts of reporters to work
+#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_external_interfaces.h
+
+// start catch_reporter_bases.hpp
+
+// start catch_interfaces_reporter.h
+
+// start catch_config.hpp
+
+// start catch_test_spec_parser.h
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// start catch_test_spec.h
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// start catch_wildcard_pattern.h
+
+namespace Catch
+{
+    class WildcardPattern {
+        enum WildcardPosition {
+            NoWildcard = 0,
+            WildcardAtStart = 1,
+            WildcardAtEnd = 2,
+            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+        };
+
+    public:
+
+        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
+        virtual ~WildcardPattern() = default;
+        virtual bool matches( std::string const& str ) const;
+
+    private:
+        std::string normaliseString( std::string const& str ) const;
+        CaseSensitive::Choice m_caseSensitivity;
+        WildcardPosition m_wildcard = NoWildcard;
+        std::string m_pattern;
+    };
+}
+
+// end catch_wildcard_pattern.h
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    struct IConfig;
+
+    class TestSpec {
+        class Pattern {
+        public:
+            explicit Pattern( std::string const& name );
+            virtual ~Pattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+            std::string const& name() const;
+        private:
+            std::string const m_name;
+        };
+        using PatternPtr = std::shared_ptr<Pattern>;
+
+        class NamePattern : public Pattern {
+        public:
+            explicit NamePattern( std::string const& name, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            WildcardPattern m_wildcardPattern;
+        };
+
+        class TagPattern : public Pattern {
+        public:
+            explicit TagPattern( std::string const& tag, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            std::string m_tag;
+        };
+
+        class ExcludedPattern : public Pattern {
+        public:
+            explicit ExcludedPattern( PatternPtr const& underlyingPattern );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            PatternPtr m_underlyingPattern;
+        };
+
+        struct Filter {
+            std::vector<PatternPtr> m_patterns;
+
+            bool matches( TestCaseInfo const& testCase ) const;
+            std::string name() const;
+        };
+
+    public:
+        struct FilterMatch {
+            std::string name;
+            std::vector<TestCase const*> tests;
+        };
+        using Matches = std::vector<FilterMatch>;
+        using vectorStrings = std::vector<std::string>;
+
+        bool hasFilters() const;
+        bool matches( TestCaseInfo const& testCase ) const;
+        Matches matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const;
+        const vectorStrings & getInvalidArgs() const;
+
+    private:
+        std::vector<Filter> m_filters;
+        std::vector<std::string> m_invalidArgs;
+        friend class TestSpecParser;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_spec.h
+// start catch_interfaces_tag_alias_registry.h
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias;
+
+    struct ITagAliasRegistry {
+        virtual ~ITagAliasRegistry();
+        // Nullptr if not present
+        virtual TagAlias const* find( std::string const& alias ) const = 0;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+        static ITagAliasRegistry const& get();
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_tag_alias_registry.h
+namespace Catch {
+
+    class TestSpecParser {
+        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+        Mode m_mode = None;
+        Mode lastMode = None;
+        bool m_exclusion = false;
+        std::size_t m_pos = 0;
+        std::size_t m_realPatternPos = 0;
+        std::string m_arg;
+        std::string m_substring;
+        std::string m_patternName;
+        std::vector<std::size_t> m_escapeChars;
+        TestSpec::Filter m_currentFilter;
+        TestSpec m_testSpec;
+        ITagAliasRegistry const* m_tagAliases = nullptr;
+
+    public:
+        TestSpecParser( ITagAliasRegistry const& tagAliases );
+
+        TestSpecParser& parse( std::string const& arg );
+        TestSpec testSpec();
+
+    private:
+        bool visitChar( char c );
+        void startNewMode( Mode mode );
+        bool processNoneChar( char c );
+        void processNameChar( char c );
+        bool processOtherChar( char c );
+        void endMode();
+        void escape();
+        bool isControlChar( char c ) const;
+        void saveLastMode();
+        void revertBackToLastMode();
+        void addFilter();
+        bool separate();
+
+        // Handles common preprocessing of the pattern for name/tag patterns
+        std::string preprocessPattern();
+        // Adds the current pattern as a test name
+        void addNamePattern();
+        // Adds the current pattern as a tag
+        void addTagPattern();
+
+        inline void addCharToPattern(char c) {
+            m_substring += c;
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+
+    };
+    TestSpec parseTestSpec( std::string const& arg );
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_spec_parser.h
+// Libstdc++ doesn't like incomplete classes for unique_ptr
+
+#include <memory>
+#include <vector>
+#include <string>
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+
+    struct IStream;
+
+    struct ConfigData {
+        bool listTests = false;
+        bool listTags = false;
+        bool listReporters = false;
+        bool listTestNamesOnly = false;
+
+        bool showSuccessfulTests = false;
+        bool shouldDebugBreak = false;
+        bool noThrow = false;
+        bool showHelp = false;
+        bool showInvisibles = false;
+        bool filenamesAsTags = false;
+        bool libIdentify = false;
+
+        int abortAfter = -1;
+        unsigned int rngSeed = 0;
+
+        bool benchmarkNoAnalysis = false;
+        unsigned int benchmarkSamples = 100;
+        double benchmarkConfidenceInterval = 0.95;
+        unsigned int benchmarkResamples = 100000;
+        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
+
+        Verbosity verbosity = Verbosity::Normal;
+        WarnAbout::What warnings = WarnAbout::Nothing;
+        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
+        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
+        UseColour::YesOrNo useColour = UseColour::Auto;
+        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+
+        std::string outputFilename;
+        std::string name;
+        std::string processName;
+#ifndef CATCH_CONFIG_DEFAULT_REPORTER
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
+#undef CATCH_CONFIG_DEFAULT_REPORTER
+
+        std::vector<std::string> testsOrTags;
+        std::vector<std::string> sectionsToRun;
+    };
+
+    class Config : public IConfig {
+    public:
+
+        Config() = default;
+        Config( ConfigData const& data );
+        virtual ~Config() = default;
+
+        std::string const& getFilename() const;
+
+        bool listTests() const;
+        bool listTestNamesOnly() const;
+        bool listTags() const;
+        bool listReporters() const;
+
+        std::string getProcessName() const;
+        std::string const& getReporterName() const;
+
+        std::vector<std::string> const& getTestsOrTags() const override;
+        std::vector<std::string> const& getSectionsToRun() const override;
+
+        TestSpec const& testSpec() const override;
+        bool hasTestFilters() const override;
+
+        bool showHelp() const;
+
+        // IConfig interface
+        bool allowThrows() const override;
+        std::ostream& stream() const override;
+        std::string name() const override;
+        bool includeSuccessfulResults() const override;
+        bool warnAboutMissingAssertions() const override;
+        bool warnAboutNoTests() const override;
+        ShowDurations::OrNot showDurations() const override;
+        RunTests::InWhatOrder runOrder() const override;
+        unsigned int rngSeed() const override;
+        UseColour::YesOrNo useColour() const override;
+        bool shouldDebugBreak() const override;
+        int abortAfter() const override;
+        bool showInvisibles() const override;
+        Verbosity verbosity() const override;
+        bool benchmarkNoAnalysis() const override;
+        int benchmarkSamples() const override;
+        double benchmarkConfidenceInterval() const override;
+        unsigned int benchmarkResamples() const override;
+        std::chrono::milliseconds benchmarkWarmupTime() const override;
+
+    private:
+
+        IStream const* openStream();
+        ConfigData m_data;
+
+        std::unique_ptr<IStream const> m_stream;
+        TestSpec m_testSpec;
+        bool m_hasTestFilters = false;
+    };
+
+} // end namespace Catch
+
+// end catch_config.hpp
+// start catch_assertionresult.h
+
+#include <string>
+
+namespace Catch {
+
+    struct AssertionResultData
+    {
+        AssertionResultData() = delete;
+
+        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+
+        std::string message;
+        mutable std::string reconstructedExpression;
+        LazyExpression lazyExpression;
+        ResultWas::OfType resultType;
+
+        std::string reconstructExpression() const;
+    };
+
+    class AssertionResult {
+    public:
+        AssertionResult() = delete;
+        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+
+        bool isOk() const;
+        bool succeeded() const;
+        ResultWas::OfType getResultType() const;
+        bool hasExpression() const;
+        bool hasMessage() const;
+        std::string getExpression() const;
+        std::string getExpressionInMacro() const;
+        bool hasExpandedExpression() const;
+        std::string getExpandedExpression() const;
+        std::string getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        StringRef getTestMacroName() const;
+
+    //protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+// end catch_assertionresult.h
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_estimate.hpp
+
+ // Statistics estimates
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct Estimate {
+            Duration point;
+            Duration lower_bound;
+            Duration upper_bound;
+            double confidence_interval;
+
+            template <typename Duration2>
+            operator Estimate<Duration2>() const {
+                return { point, lower_bound, upper_bound, confidence_interval };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_estimate.hpp
+// start catch_outlier_classification.hpp
+
+// Outlier information
+
+namespace Catch {
+    namespace Benchmark {
+        struct OutlierClassification {
+            int samples_seen = 0;
+            int low_severe = 0;     // more than 3 times IQR below Q1
+            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
+            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
+            int high_severe = 0;    // more than 3 times IQR above Q3
+
+            int total() const {
+                return low_severe + low_mild + high_mild + high_severe;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_outlier_classification.hpp
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+#include <string>
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <memory>
+#include <algorithm>
+
+namespace Catch {
+
+    struct ReporterConfig {
+        explicit ReporterConfig( IConfigPtr const& _fullConfig );
+
+        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
+
+        std::ostream& stream() const;
+        IConfigPtr fullConfig() const;
+
+    private:
+        std::ostream* m_stream;
+        IConfigPtr m_fullConfig;
+    };
+
+    struct ReporterPreferences {
+        bool shouldRedirectStdOut = false;
+        bool shouldReportAllAssertions = false;
+    };
+
+    template<typename T>
+    struct LazyStat : Option<T> {
+        LazyStat& operator=( T const& _value ) {
+            Option<T>::operator=( _value );
+            used = false;
+            return *this;
+        }
+        void reset() {
+            Option<T>::reset();
+            used = false;
+        }
+        bool used = false;
+    };
+
+    struct TestRunInfo {
+        TestRunInfo( std::string const& _name );
+        std::string name;
+    };
+    struct GroupInfo {
+        GroupInfo(  std::string const& _name,
+                    std::size_t _groupIndex,
+                    std::size_t _groupsCount );
+
+        std::string name;
+        std::size_t groupIndex;
+        std::size_t groupsCounts;
+    };
+
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals );
+
+        AssertionStats( AssertionStats const& )              = default;
+        AssertionStats( AssertionStats && )                  = default;
+        AssertionStats& operator = ( AssertionStats const& ) = delete;
+        AssertionStats& operator = ( AssertionStats && )     = delete;
+        virtual ~AssertionStats();
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions );
+        SectionStats( SectionStats const& )              = default;
+        SectionStats( SectionStats && )                  = default;
+        SectionStats& operator = ( SectionStats const& ) = default;
+        SectionStats& operator = ( SectionStats && )     = default;
+        virtual ~SectionStats();
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        double durationInSeconds;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string const& _stdOut,
+                        std::string const& _stdErr,
+                        bool _aborting );
+
+        TestCaseStats( TestCaseStats const& )              = default;
+        TestCaseStats( TestCaseStats && )                  = default;
+        TestCaseStats& operator = ( TestCaseStats const& ) = default;
+        TestCaseStats& operator = ( TestCaseStats && )     = default;
+        virtual ~TestCaseStats();
+
+        TestCaseInfo testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestGroupStats {
+        TestGroupStats( GroupInfo const& _groupInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+        TestGroupStats( GroupInfo const& _groupInfo );
+
+        TestGroupStats( TestGroupStats const& )              = default;
+        TestGroupStats( TestGroupStats && )                  = default;
+        TestGroupStats& operator = ( TestGroupStats const& ) = default;
+        TestGroupStats& operator = ( TestGroupStats && )     = default;
+        virtual ~TestGroupStats();
+
+        GroupInfo groupInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+
+        TestRunStats( TestRunStats const& )              = default;
+        TestRunStats( TestRunStats && )                  = default;
+        TestRunStats& operator = ( TestRunStats const& ) = default;
+        TestRunStats& operator = ( TestRunStats && )     = default;
+        virtual ~TestRunStats();
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo {
+        std::string name;
+        double estimatedDuration;
+        int iterations;
+        int samples;
+        unsigned int resamples;
+        double clockResolution;
+        double clockCost;
+    };
+
+    template <class Duration>
+    struct BenchmarkStats {
+        BenchmarkInfo info;
+
+        std::vector<Duration> samples;
+        Benchmark::Estimate<Duration> mean;
+        Benchmark::Estimate<Duration> standardDeviation;
+        Benchmark::OutlierClassification outliers;
+        double outlierVariance;
+
+        template <typename Duration2>
+        operator BenchmarkStats<Duration2>() const {
+            std::vector<Duration2> samples2;
+            samples2.reserve(samples.size());
+            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+            return {
+                info,
+                std::move(samples2),
+                mean,
+                standardDeviation,
+                outliers,
+                outlierVariance,
+            };
+        }
+    };
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    struct IStreamingReporter {
+        virtual ~IStreamingReporter() = default;
+
+        // Implementing class must also provide the following static methods:
+        // static std::string getDescription();
+        // static std::set<Verbosity> getSupportedVerbosities()
+
+        virtual ReporterPreferences getPreferences() const = 0;
+
+        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+
+        virtual void reportInvalidArguments(std::string const&) {}
+
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& ) {}
+        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
+        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
+        virtual void benchmarkFailed( std::string const& ) {}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        // The return value indicates if the messages buffer should be cleared:
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+
+        // Default empty implementation provided
+        virtual void fatalErrorEncountered( StringRef name );
+
+        virtual bool isMulti() const;
+    };
+    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
+
+    struct IReporterFactory {
+        virtual ~IReporterFactory();
+        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+    struct IReporterRegistry {
+        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
+        using Listeners = std::vector<IReporterFactoryPtr>;
+
+        virtual ~IReporterRegistry();
+        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
+        virtual FactoryMap const& getFactories() const = 0;
+        virtual Listeners const& getListeners() const = 0;
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_reporter.h
+#include <algorithm>
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <cassert>
+#include <memory>
+#include <ostream>
+
+namespace Catch {
+    void prepareExpandedExpression(AssertionResult& result);
+
+    // Returns double formatted as %.3f (format expected on output)
+    std::string getFormattedDuration( double duration );
+
+    std::string serializeFilters( std::vector<std::string> const& container );
+
+    template<typename DerivedT>
+    struct StreamingReporterBase : IStreamingReporter {
+
+        StreamingReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        ~StreamingReporterBase() override = default;
+
+        void noMatchingTestCases(std::string const&) override {}
+
+        void reportInvalidArguments(std::string const&) override {}
+
+        void testRunStarting(TestRunInfo const& _testRunInfo) override {
+            currentTestRunInfo = _testRunInfo;
+        }
+
+        void testGroupStarting(GroupInfo const& _groupInfo) override {
+            currentGroupInfo = _groupInfo;
+        }
+
+        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
+            currentTestCaseInfo = _testInfo;
+        }
+        void sectionStarting(SectionInfo const& _sectionInfo) override {
+            m_sectionStack.push_back(_sectionInfo);
+        }
+
+        void sectionEnded(SectionStats const& /* _sectionStats */) override {
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+            currentTestCaseInfo.reset();
+        }
+        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
+            currentGroupInfo.reset();
+        }
+        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
+            currentTestCaseInfo.reset();
+            currentGroupInfo.reset();
+            currentTestRunInfo.reset();
+        }
+
+        void skipTest(TestCaseInfo const&) override {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+
+        LazyStat<TestRunInfo> currentTestRunInfo;
+        LazyStat<GroupInfo> currentGroupInfo;
+        LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+        std::vector<SectionInfo> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<typename DerivedT>
+    struct CumulativeReporterBase : IStreamingReporter {
+        template<typename T, typename ChildNodeT>
+        struct Node {
+            explicit Node( T const& _value ) : value( _value ) {}
+            virtual ~Node() {}
+
+            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode {
+            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+            virtual ~SectionNode() = default;
+
+            bool operator == (SectionNode const& other) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+            bool operator == (std::shared_ptr<SectionNode> const& other) const {
+                return operator==(*other);
+            }
+
+            SectionStats stats;
+            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
+            using Assertions = std::vector<AssertionStats>;
+            ChildSections childSections;
+            Assertions assertions;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
+            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
+            bool operator() (std::shared_ptr<SectionNode> const& node) const {
+                return ((node->stats.sectionInfo.name == m_other.name) &&
+                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
+            }
+            void operator=(BySectionInfo const&) = delete;
+
+        private:
+            SectionInfo const& m_other;
+        };
+
+        using TestCaseNode = Node<TestCaseStats, SectionNode>;
+        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
+        using TestRunNode = Node<TestRunStats, TestGroupNode>;
+
+        CumulativeReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+        ~CumulativeReporterBase() override = default;
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void testRunStarting( TestRunInfo const& ) override {}
+        void testGroupStarting( GroupInfo const& ) override {}
+
+        void testCaseStarting( TestCaseInfo const& ) override {}
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
+            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+            std::shared_ptr<SectionNode> node;
+            if( m_sectionStack.empty() ) {
+                if( !m_rootSection )
+                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
+                node = m_rootSection;
+            }
+            else {
+                SectionNode& parentNode = *m_sectionStack.back();
+                auto it =
+                    std::find_if(   parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+                if( it == parentNode.childSections.end() ) {
+                    node = std::make_shared<SectionNode>( incompleteStats );
+                    parentNode.childSections.push_back( node );
+                }
+                else
+                    node = *it;
+            }
+            m_sectionStack.push_back( node );
+            m_deepestSection = std::move(node);
+        }
+
+        void assertionStarting(AssertionInfo const&) override {}
+
+        bool assertionEnded(AssertionStats const& assertionStats) override {
+            assert(!m_sectionStack.empty());
+            // AssertionResult holds a pointer to a temporary DecomposedExpression,
+            // which getExpandedExpression() calls to build the expression string.
+            // Our section stack copy of the assertionResult will likely outlive the
+            // temporary, so it must be expanded or discarded now to avoid calling
+            // a destroyed object later.
+            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
+            SectionNode& sectionNode = *m_sectionStack.back();
+            sectionNode.assertions.push_back(assertionStats);
+            return true;
+        }
+        void sectionEnded(SectionStats const& sectionStats) override {
+            assert(!m_sectionStack.empty());
+            SectionNode& node = *m_sectionStack.back();
+            node.stats = sectionStats;
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& testCaseStats) override {
+            auto node = std::make_shared<TestCaseNode>(testCaseStats);
+            assert(m_sectionStack.size() == 0);
+            node->children.push_back(m_rootSection);
+            m_testCases.push_back(node);
+            m_rootSection.reset();
+
+            assert(m_deepestSection);
+            m_deepestSection->stdOut = testCaseStats.stdOut;
+            m_deepestSection->stdErr = testCaseStats.stdErr;
+        }
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            auto node = std::make_shared<TestGroupNode>(testGroupStats);
+            node->children.swap(m_testCases);
+            m_testGroups.push_back(node);
+        }
+        void testRunEnded(TestRunStats const& testRunStats) override {
+            auto node = std::make_shared<TestRunNode>(testRunStats);
+            node->children.swap(m_testGroups);
+            m_testRuns.push_back(node);
+            testRunEndedCumulative();
+        }
+        virtual void testRunEndedCumulative() = 0;
+
+        void skipTest(TestCaseInfo const&) override {}
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+        std::vector<AssertionStats> m_assertions;
+        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
+        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
+        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
+
+        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
+
+        std::shared_ptr<SectionNode> m_rootSection;
+        std::shared_ptr<SectionNode> m_deepestSection;
+        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<char C>
+    char const* getLineOfChars() {
+        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+        if( !*line ) {
+            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+        }
+        return line;
+    }
+
+    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
+        TestEventListenerBase( ReporterConfig const& _config );
+
+        static std::set<Verbosity> getSupportedVerbosities();
+
+        void assertionStarting(AssertionInfo const&) override;
+        bool assertionEnded(AssertionStats const&) override;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_bases.hpp
+// start catch_console_colour.h
+
+namespace Catch {
+
+    struct Colour {
+        enum Code {
+            None = 0,
+
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
+
+            Bright = 0x10,
+
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
+            BrightYellow = Bright | Yellow,
+
+            // By intention
+            FileName = LightGrey,
+            Warning = BrightYellow,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            ResultExpectedFailure = Warning,
+
+            Error = BrightRed,
+            Success = Green,
+
+            OriginalExpression = Cyan,
+            ReconstructedExpression = BrightYellow,
+
+            SecondaryText = LightGrey,
+            Headers = White
+        };
+
+        // Use constructed object for RAII guard
+        Colour( Code _colourCode );
+        Colour( Colour&& other ) noexcept;
+        Colour& operator=( Colour&& other ) noexcept;
+        ~Colour();
+
+        // Use static method for one-shot changes
+        static void use( Code _colourCode );
+
+    private:
+        bool m_moved = false;
+    };
+
+    std::ostream& operator << ( std::ostream& os, Colour const& );
+
+} // end namespace Catch
+
+// end catch_console_colour.h
+// start catch_reporter_registrars.hpp
+
+
+namespace Catch {
+
+    template<typename T>
+    class ReporterRegistrar {
+
+        class ReporterFactory : public IReporterFactory {
+
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
+            }
+
+            std::string getDescription() const override {
+                return T::getDescription();
+            }
+        };
+
+    public:
+
+        explicit ReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
+        }
+    };
+
+    template<typename T>
+    class ListenerRegistrar {
+
+        class ListenerFactory : public IReporterFactory {
+
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
+            }
+            std::string getDescription() const override {
+                return std::string();
+            }
+        };
+
+    public:
+
+        ListenerRegistrar() {
+            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
+        }
+    };
+}
+
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#define CATCH_REGISTER_REPORTER( name, reporterType ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION         \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
+    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#define CATCH_REGISTER_LISTENER( listenerType ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION   \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS    \
+    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#else // CATCH_CONFIG_DISABLE
+
+#define CATCH_REGISTER_REPORTER(name, reporterType)
+#define CATCH_REGISTER_LISTENER(listenerType)
+
+#endif // CATCH_CONFIG_DISABLE
+
+// end catch_reporter_registrars.hpp
+// Allow users to base their work off existing reporters
+// start catch_reporter_compact.h
+
+namespace Catch {
+
+    struct CompactReporter : StreamingReporterBase<CompactReporter> {
+
+        using StreamingReporterBase::StreamingReporterBase;
+
+        ~CompactReporter() override;
+
+        static std::string getDescription();
+
+        ReporterPreferences getPreferences() const override;
+
+        void noMatchingTestCases(std::string const& spec) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_compact.h
+// start catch_reporter_console.h
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
+
+namespace Catch {
+    // Fwd decls
+    struct SummaryColumn;
+    class TablePrinter;
+
+    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
+        std::unique_ptr<TablePrinter> m_tablePrinter;
+
+        ConsoleReporter(ReporterConfig const& config);
+        ~ConsoleReporter() override;
+        static std::string getDescription();
+
+        void noMatchingTestCases(std::string const& spec) override;
+
+        void reportInvalidArguments(std::string const&arg) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionStarting(SectionInfo const& _sectionInfo) override;
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const& info) override;
+        void benchmarkEnded(BenchmarkStats<> const& stats) override;
+        void benchmarkFailed(std::string const& error) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+        void testRunStarting(TestRunInfo const& _testRunInfo) override;
+    private:
+
+        void lazyPrint();
+
+        void lazyPrintWithoutClosingBenchmarkTable();
+        void lazyPrintRunInfo();
+        void lazyPrintGroupInfo();
+        void printTestCaseAndSectionHeader();
+
+        void printClosedHeader(std::string const& _name);
+        void printOpenHeader(std::string const& _name);
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString(std::string const& _string, std::size_t indent = 0);
+
+        void printTotals(Totals const& totals);
+        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
+
+        void printTotalsDivider(Totals const& totals);
+        void printSummaryDivider();
+        void printTestFilters();
+
+    private:
+        bool m_headerPrinted = false;
+    };
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+// end catch_reporter_console.h
+// start catch_reporter_junit.h
+
+// start catch_xmlwriter.h
+
+#include <vector>
+
+namespace Catch {
+    enum class XmlFormatting {
+        None = 0x00,
+        Indent = 0x01,
+        Newline = 0x02,
+    };
+
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
+
+    class XmlEncode {
+    public:
+        enum ForWhat { ForTextNodes, ForAttributes };
+
+        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
+
+        void encodeTo( std::ostream& os ) const;
+
+        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+
+    private:
+        std::string m_str;
+        ForWhat m_forWhat;
+    };
+
+    class XmlWriter {
+    public:
+
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
+
+            ScopedElement( ScopedElement&& other ) noexcept;
+            ScopedElement& operator=( ScopedElement&& other ) noexcept;
+
+            ~ScopedElement();
+
+            ScopedElement& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent );
+
+            template<typename T>
+            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
+
+        private:
+            mutable XmlWriter* m_writer = nullptr;
+            XmlFormatting m_fmt;
+        };
+
+        XmlWriter( std::ostream& os = Catch::cout() );
+        ~XmlWriter();
+
+        XmlWriter( XmlWriter const& ) = delete;
+        XmlWriter& operator=( XmlWriter const& ) = delete;
+
+        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
+
+        XmlWriter& writeAttribute( std::string const& name, bool attribute );
+
+        template<typename T>
+        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+            ReusableStringStream rss;
+            rss << attribute;
+            return writeAttribute( name, rss.str() );
+        }
+
+        XmlWriter& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& writeComment(std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        void writeStylesheetRef( std::string const& url );
+
+        XmlWriter& writeBlankLine();
+
+        void ensureTagClosed();
+
+    private:
+
+        void applyFormatting(XmlFormatting fmt);
+
+        void writeDeclaration();
+
+        void newlineIfNecessary();
+
+        bool m_tagIsOpen = false;
+        bool m_needsNewline = false;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream& m_os;
+    };
+
+}
+
+// end catch_xmlwriter.h
+namespace Catch {
+
+    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
+    public:
+        JunitReporter(ReporterConfig const& _config);
+
+        ~JunitReporter() override;
+
+        static std::string getDescription();
+
+        void noMatchingTestCases(std::string const& /*spec*/) override;
+
+        void testRunStarting(TestRunInfo const& runInfo) override;
+
+        void testGroupStarting(GroupInfo const& groupInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
+        bool assertionEnded(AssertionStats const& assertionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+
+        void testRunEndedCumulative() override;
+
+        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
+
+        void writeTestCase(TestCaseNode const& testCaseNode);
+
+        void writeSection(std::string const& className,
+                          std::string const& rootName,
+                          SectionNode const& sectionNode);
+
+        void writeAssertions(SectionNode const& sectionNode);
+        void writeAssertion(AssertionStats const& stats);
+
+        XmlWriter xml;
+        Timer suiteTimer;
+        std::string stdOutForSuite;
+        std::string stdErrForSuite;
+        unsigned int unexpectedExceptions = 0;
+        bool m_okToFail = false;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_junit.h
+// start catch_reporter_xml.h
+
+namespace Catch {
+    class XmlReporter : public StreamingReporterBase<XmlReporter> {
+    public:
+        XmlReporter(ReporterConfig const& _config);
+
+        ~XmlReporter() override;
+
+        static std::string getDescription();
+
+        virtual std::string getStylesheetRef() const;
+
+        void writeSourceInfo(SourceLineInfo const& sourceInfo);
+
+    public: // StreamingReporterBase
+
+        void noMatchingTestCases(std::string const& s) override;
+
+        void testRunStarting(TestRunInfo const& testInfo) override;
+
+        void testGroupStarting(GroupInfo const& groupInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testInfo) override;
+
+        void sectionStarting(SectionInfo const& sectionInfo) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& assertionStats) override;
+
+        void sectionEnded(SectionStats const& sectionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+
+        void testRunEnded(TestRunStats const& testRunStats) override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const&) override;
+        void benchmarkEnded(BenchmarkStats<> const&) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    private:
+        Timer m_testCaseTimer;
+        XmlWriter m_xml;
+        int m_sectionDepth = 0;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_xml.h
+
+// end catch_external_interfaces.h
+#endif
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_benchmarking_all.hpp
+
+// A proxy header that includes all of the benchmarking headers to allow
+// concise include of the benchmarking features. You should prefer the
+// individual includes in standard use.
+
+// start catch_benchmark.hpp
+
+ // Benchmark
+
+// start catch_chronometer.hpp
+
+// User-facing chronometer
+
+
+// start catch_clock.hpp
+
+// Clocks
+
+
+#include <chrono>
+#include <ratio>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Clock>
+        using ClockDuration = typename Clock::duration;
+        template <typename Clock>
+        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
+
+        template <typename Clock>
+        using TimePoint = typename Clock::time_point;
+
+        using default_clock = std::chrono::steady_clock;
+
+        template <typename Clock>
+        struct now {
+            TimePoint<Clock> operator()() const {
+                return Clock::now();
+            }
+        };
+
+        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_clock.hpp
+// start catch_optimizer.hpp
+
+ // Hinting the optimizer
+
+
+#if defined(_MSC_VER)
+#   include <atomic> // atomic_thread_fence
+#endif
+
+namespace Catch {
+    namespace Benchmark {
+#if defined(__GNUC__) || defined(__clang__)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            asm volatile("" : : "g"(p) : "memory");
+        }
+        inline void keep_memory() {
+            asm volatile("" : : : "memory");
+        }
+
+        namespace Detail {
+            inline void optimizer_barrier() { keep_memory(); }
+        } // namespace Detail
+#elif defined(_MSC_VER)
+
+#pragma optimize("", off)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            // thanks @milleniumbug
+            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
+        }
+        // TODO equivalent keep_memory()
+#pragma optimize("", on)
+
+        namespace Detail {
+            inline void optimizer_barrier() {
+                std::atomic_thread_fence(std::memory_order_seq_cst);
+            }
+        } // namespace Detail
+
+#endif
+
+        template <typename T>
+        inline void deoptimize_value(T&& x) {
+            keep_memory(&x);
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
+            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
+            std::forward<Fn>(fn) (std::forward<Args...>(args...));
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_optimizer.hpp
+// start catch_complete_invoke.hpp
+
+// Invoke with a special case for void
+
+
+#include <type_traits>
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            struct CompleteType { using type = T; };
+            template <>
+            struct CompleteType<void> { struct type {}; };
+
+            template <typename T>
+            using CompleteType_t = typename CompleteType<T>::type;
+
+            template <typename Result>
+            struct CompleteInvoker {
+                template <typename Fun, typename... Args>
+                static Result invoke(Fun&& fun, Args&&... args) {
+                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                }
+            };
+            template <>
+            struct CompleteInvoker<void> {
+                template <typename Fun, typename... Args>
+                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
+                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                    return {};
+                }
+            };
+            template <typename Sig>
+            using ResultOf_t = typename std::result_of<Sig>::type;
+
+            // invoke and not return void :(
+            template <typename Fun, typename... Args>
+            CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun&& fun, Args&&... args) {
+                return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
+            }
+
+            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
+        } // namespace Detail
+
+        template <typename Fun>
+        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
+            CATCH_TRY{
+                return Detail::complete_invoke(std::forward<Fun>(fun));
+            } CATCH_CATCH_ALL{
+                getResultCapture().benchmarkFailed(translateActiveException());
+                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
+            }
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_complete_invoke.hpp
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct ChronometerConcept {
+                virtual void start() = 0;
+                virtual void finish() = 0;
+                virtual ~ChronometerConcept() = default;
+            };
+            template <typename Clock>
+            struct ChronometerModel final : public ChronometerConcept {
+                void start() override { started = Clock::now(); }
+                void finish() override { finished = Clock::now(); }
+
+                ClockDuration<Clock> elapsed() const { return finished - started; }
+
+                TimePoint<Clock> started;
+                TimePoint<Clock> finished;
+            };
+        } // namespace Detail
+
+        struct Chronometer {
+        public:
+            template <typename Fun>
+            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
+
+            int runs() const { return k; }
+
+            Chronometer(Detail::ChronometerConcept& meter, int k)
+                : impl(&meter)
+                , k(k) {}
+
+        private:
+            template <typename Fun>
+            void measure(Fun&& fun, std::false_type) {
+                measure([&fun](int) { return fun(); }, std::true_type());
+            }
+
+            template <typename Fun>
+            void measure(Fun&& fun, std::true_type) {
+                Detail::optimizer_barrier();
+                impl->start();
+                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
+                impl->finish();
+                Detail::optimizer_barrier();
+            }
+
+            Detail::ChronometerConcept* impl;
+            int k;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_chronometer.hpp
+// start catch_environment.hpp
+
+// Environment information
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct EnvironmentEstimate {
+            Duration mean;
+            OutlierClassification outliers;
+
+            template <typename Duration2>
+            operator EnvironmentEstimate<Duration2>() const {
+                return { mean, outliers };
+            }
+        };
+        template <typename Clock>
+        struct Environment {
+            using clock_type = Clock;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_environment.hpp
+// start catch_execution_plan.hpp
+
+ // Execution plan
+
+
+// start catch_benchmark_function.hpp
+
+ // Dumb std::function implementation for consistent call overhead
+
+
+#include <cassert>
+#include <type_traits>
+#include <utility>
+#include <memory>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            using Decay = typename std::decay<T>::type;
+            template <typename T, typename U>
+            struct is_related
+                : std::is_same<Decay<T>, Decay<U>> {};
+
+            /// We need to reinvent std::function because every piece of code that might add overhead
+            /// in a measurement context needs to have consistent performance characteristics so that we
+            /// can account for it in the measurement.
+            /// Implementations of std::function with optimizations that aren't always applicable, like
+            /// small buffer optimizations, are not uncommon.
+            /// This is effectively an implementation of std::function without any such optimizations;
+            /// it may be slow, but it is consistently slow.
+            struct BenchmarkFunction {
+            private:
+                struct callable {
+                    virtual void call(Chronometer meter) const = 0;
+                    virtual callable* clone() const = 0;
+                    virtual ~callable() = default;
+                };
+                template <typename Fun>
+                struct model : public callable {
+                    model(Fun&& fun) : fun(std::move(fun)) {}
+                    model(Fun const& fun) : fun(fun) {}
+
+                    model<Fun>* clone() const override { return new model<Fun>(*this); }
+
+                    void call(Chronometer meter) const override {
+                        call(meter, is_callable<Fun(Chronometer)>());
+                    }
+                    void call(Chronometer meter, std::true_type) const {
+                        fun(meter);
+                    }
+                    void call(Chronometer meter, std::false_type) const {
+                        meter.measure(fun);
+                    }
+
+                    Fun fun;
+                };
+
+                struct do_nothing { void operator()() const {} };
+
+                template <typename T>
+                BenchmarkFunction(model<T>* c) : f(c) {}
+
+            public:
+                BenchmarkFunction()
+                    : f(new model<do_nothing>{ {} }) {}
+
+                template <typename Fun,
+                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
+                    BenchmarkFunction(Fun&& fun)
+                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
+
+                BenchmarkFunction(BenchmarkFunction&& that)
+                    : f(std::move(that.f)) {}
+
+                BenchmarkFunction(BenchmarkFunction const& that)
+                    : f(that.f->clone()) {}
+
+                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
+                    f = std::move(that.f);
+                    return *this;
+                }
+
+                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
+                    f.reset(that.f->clone());
+                    return *this;
+                }
+
+                void operator()(Chronometer meter) const { f->call(meter); }
+
+            private:
+                std::unique_ptr<callable> f;
+            };
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_benchmark_function.hpp
+// start catch_repeat.hpp
+
+// repeat algorithm
+
+
+#include <type_traits>
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Fun>
+            struct repeater {
+                void operator()(int k) const {
+                    for (int i = 0; i < k; ++i) {
+                        fun();
+                    }
+                }
+                Fun fun;
+            };
+            template <typename Fun>
+            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
+                return { std::forward<Fun>(fun) };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_repeat.hpp
+// start catch_run_for_at_least.hpp
+
+// Run a function for a minimum amount of time
+
+
+// start catch_measure.hpp
+
+// Measure
+
+
+// start catch_timing.hpp
+
+// Timing
+
+
+#include <tuple>
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration, typename Result>
+        struct Timing {
+            Duration elapsed;
+            Result result;
+            int iterations;
+        };
+        template <typename Clock, typename Sig>
+        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_timing.hpp
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun, typename... Args>
+            TimingOf<Clock, Fun(Args...)> measure(Fun&& fun, Args&&... args) {
+                auto start = Clock::now();
+                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
+                auto end = Clock::now();
+                auto delta = end - start;
+                return { delta, std::forward<decltype(r)>(r), 1 };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_measure.hpp
+#include <utility>
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(int)> measure_one(Fun&& fun, int iters, std::false_type) {
+                return Detail::measure<Clock>(fun, iters);
+            }
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(Chronometer)> measure_one(Fun&& fun, int iters, std::true_type) {
+                Detail::ChronometerModel<Clock> meter;
+                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
+
+                return { meter.elapsed(), std::move(result), iters };
+            }
+
+            template <typename Clock, typename Fun>
+            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
+
+            struct optimized_away_error : std::exception {
+                const char* what() const noexcept override {
+                    return "could not measure benchmark, maybe it was optimized away";
+                }
+            };
+
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
+                auto iters = seed;
+                while (iters < (1 << 30)) {
+                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
+
+                    if (Timing.elapsed >= how_long) {
+                        return { Timing.elapsed, std::move(Timing.result), iters };
+                    }
+                    iters *= 2;
+                }
+                throw optimized_away_error{};
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_run_for_at_least.hpp
+#include <algorithm>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct ExecutionPlan {
+            int iterations_per_sample;
+            Duration estimated_duration;
+            Detail::BenchmarkFunction benchmark;
+            Duration warmup_time;
+            int warmup_iterations;
+
+            template <typename Duration2>
+            operator ExecutionPlan<Duration2>() const {
+                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
+            }
+
+            template <typename Clock>
+            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                // warmup a bit
+                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
+
+                std::vector<FloatDuration<Clock>> times;
+                times.reserve(cfg.benchmarkSamples());
+                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
+                    Detail::ChronometerModel<Clock> model;
+                    this->benchmark(Chronometer(model, iterations_per_sample));
+                    auto sample_time = model.elapsed() - env.clock_cost.mean;
+                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
+                    return sample_time / iterations_per_sample;
+                });
+                return times;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_execution_plan.hpp
+// start catch_estimate_clock.hpp
+
+ // Environment measurement
+
+
+// start catch_stats.hpp
+
+// Statistical analysis tools
+
+
+#include <algorithm>
+#include <functional>
+#include <vector>
+#include <iterator>
+#include <numeric>
+#include <tuple>
+#include <cmath>
+#include <utility>
+#include <cstddef>
+#include <random>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            using sample = std::vector<double>;
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
+
+            template <typename Iterator>
+            OutlierClassification classify_outliers(Iterator first, Iterator last) {
+                std::vector<double> copy(first, last);
+
+                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
+                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
+                auto iqr = q3 - q1;
+                auto los = q1 - (iqr * 3.);
+                auto lom = q1 - (iqr * 1.5);
+                auto him = q3 + (iqr * 1.5);
+                auto his = q3 + (iqr * 3.);
+
+                OutlierClassification o;
+                for (; first != last; ++first) {
+                    auto&& t = *first;
+                    if (t < los) ++o.low_severe;
+                    else if (t < lom) ++o.low_mild;
+                    else if (t > his) ++o.high_severe;
+                    else if (t > him) ++o.high_mild;
+                    ++o.samples_seen;
+                }
+                return o;
+            }
+
+            template <typename Iterator>
+            double mean(Iterator first, Iterator last) {
+                auto count = last - first;
+                double sum = std::accumulate(first, last, 0.);
+                return sum / count;
+            }
+
+            template <typename URng, typename Iterator, typename Estimator>
+            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
+                auto n = last - first;
+                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
+
+                sample out;
+                out.reserve(resamples);
+                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
+                    std::vector<double> resampled;
+                    resampled.reserve(n);
+                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
+                    return estimator(resampled.begin(), resampled.end());
+                });
+                std::sort(out.begin(), out.end());
+                return out;
+            }
+
+            template <typename Estimator, typename Iterator>
+            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
+                auto n = last - first;
+                auto second = std::next(first);
+                sample results;
+                results.reserve(n);
+
+                for (auto it = first; it != last; ++it) {
+                    std::iter_swap(it, first);
+                    results.push_back(estimator(second, last));
+                }
+
+                return results;
+            }
+
+            inline double normal_cdf(double x) {
+                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
+            }
+
+            double erfc_inv(double x);
+
+            double normal_quantile(double p);
+
+            template <typename Iterator, typename Estimator>
+            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
+                auto n_samples = last - first;
+
+                double point = estimator(first, last);
+                // Degenerate case with a single sample
+                if (n_samples == 1) return { point, point, point, confidence_level };
+
+                sample jack = jackknife(estimator, first, last);
+                double jack_mean = mean(jack.begin(), jack.end());
+                double sum_squares, sum_cubes;
+                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
+                    auto d = jack_mean - x;
+                    auto d2 = d * d;
+                    auto d3 = d2 * d;
+                    return { sqcb.first + d2, sqcb.second + d3 };
+                });
+
+                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
+                int n = static_cast<int>(resample.size());
+                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
+                // degenerate case with uniform samples
+                if (prob_n == 0) return { point, point, point, confidence_level };
+
+                double bias = normal_quantile(prob_n);
+                double z1 = normal_quantile((1. - confidence_level) / 2.);
+
+                auto cumn = [n](double x) -> int {
+                    return std::lround(normal_cdf(x) * n); };
+                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
+                double b1 = bias + z1;
+                double b2 = bias - z1;
+                double a1 = a(b1);
+                double a2 = a(b2);
+                auto lo = std::max(cumn(a1), 0);
+                auto hi = std::min(cumn(a2), n - 1);
+
+                return { point, resample[lo], resample[hi], confidence_level };
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
+
+            struct bootstrap_analysis {
+                Estimate<double> mean;
+                Estimate<double> standard_deviation;
+                double outlier_variance;
+            };
+
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_stats.hpp
+#include <algorithm>
+#include <iterator>
+#include <tuple>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock>
+            std::vector<double> resolution(int k) {
+                std::vector<TimePoint<Clock>> times;
+                times.reserve(k + 1);
+                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
+
+                std::vector<double> deltas;
+                deltas.reserve(k);
+                std::transform(std::next(times.begin()), times.end(), times.begin(),
+                    std::back_inserter(deltas),
+                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
+
+                return deltas;
+            }
+
+            const auto warmup_iterations = 10000;
+            const auto warmup_time = std::chrono::milliseconds(100);
+            const auto minimum_ticks = 1000;
+            const auto warmup_seed = 10000;
+            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+            const auto clock_cost_estimation_tick_limit = 100000;
+            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+            const auto clock_cost_estimation_iterations = 10000;
+
+            template <typename Clock>
+            int warmup() {
+                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
+                    .iterations;
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
+                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
+                    .result;
+                return {
+                    FloatDuration<Clock>(mean(r.begin(), r.end())),
+                    classify_outliers(r.begin(), r.end()),
+                };
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
+                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));
+                auto time_clock = [](int k) {
+                    return Detail::measure<Clock>([k] {
+                        for (int i = 0; i < k; ++i) {
+                            volatile auto ignored = Clock::now();
+                            (void)ignored;
+                        }
+                    }).elapsed;
+                };
+                time_clock(1);
+                int iters = clock_cost_estimation_iterations;
+                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
+                std::vector<double> times;
+                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
+                times.reserve(nsamples);
+                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
+                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
+                });
+                return {
+                    FloatDuration<Clock>(mean(times.begin(), times.end())),
+                    classify_outliers(times.begin(), times.end()),
+                };
+            }
+
+            template <typename Clock>
+            Environment<FloatDuration<Clock>> measure_environment() {
+                static Environment<FloatDuration<Clock>>* env = nullptr;
+                if (env) {
+                    return *env;
+                }
+
+                auto iters = Detail::warmup<Clock>();
+                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
+                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
+
+                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
+                return *env;
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_estimate_clock.hpp
+// start catch_analyse.hpp
+
+ // Run and analyse one benchmark
+
+
+// start catch_sample_analysis.hpp
+
+// Benchmark results
+
+
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <iterator>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct SampleAnalysis {
+            std::vector<Duration> samples;
+            Estimate<Duration> mean;
+            Estimate<Duration> standard_deviation;
+            OutlierClassification outliers;
+            double outlier_variance;
+
+            template <typename Duration2>
+            operator SampleAnalysis<Duration2>() const {
+                std::vector<Duration2> samples2;
+                samples2.reserve(samples.size());
+                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+                return {
+                    std::move(samples2),
+                    mean,
+                    standard_deviation,
+                    outliers,
+                    outlier_variance,
+                };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_sample_analysis.hpp
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Duration, typename Iterator>
+            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
+                if (!cfg.benchmarkNoAnalysis()) {
+                    std::vector<double> samples;
+                    samples.reserve(last - first);
+                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
+
+                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
+                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
+
+                    auto wrap_estimate = [](Estimate<double> e) {
+                        return Estimate<Duration> {
+                            Duration(e.point),
+                                Duration(e.lower_bound),
+                                Duration(e.upper_bound),
+                                e.confidence_interval,
+                        };
+                    };
+                    std::vector<Duration> samples2;
+                    samples2.reserve(samples.size());
+                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
+                    return {
+                        std::move(samples2),
+                        wrap_estimate(analysis.mean),
+                        wrap_estimate(analysis.standard_deviation),
+                        outliers,
+                        analysis.outlier_variance,
+                    };
+                } else {
+                    std::vector<Duration> samples;
+                    samples.reserve(last - first);
+
+                    Duration mean = Duration(0);
+                    int i = 0;
+                    for (auto it = first; it < last; ++it, ++i) {
+                        samples.push_back(Duration(*it));
+                        mean += Duration(*it);
+                    }
+                    mean /= i;
+
+                    return {
+                        std::move(samples),
+                        Estimate<Duration>{mean, mean, mean, 0.0},
+                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
+                        OutlierClassification{},
+                        0.0
+                    };
+                }
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_analyse.hpp
+#include <algorithm>
+#include <functional>
+#include <string>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        struct Benchmark {
+            Benchmark(std::string &&name)
+                : name(std::move(name)) {}
+
+            template <class FUN>
+            Benchmark(std::string &&name, FUN &&func)
+                : fun(std::move(func)), name(std::move(name)) {}
+
+            template <typename Clock>
+            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
+                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
+                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
+                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+            }
+
+            template <typename Clock = default_clock>
+            void run() {
+                IConfigPtr cfg = getCurrentContext().getConfig();
+
+                auto env = Detail::measure_environment<Clock>();
+
+                getResultCapture().benchmarkPreparing(name);
+                CATCH_TRY{
+                    auto plan = user_code([&] {
+                        return prepare<Clock>(*cfg, env);
+                    });
+
+                    BenchmarkInfo info {
+                        name,
+                        plan.estimated_duration.count(),
+                        plan.iterations_per_sample,
+                        cfg->benchmarkSamples(),
+                        cfg->benchmarkResamples(),
+                        env.clock_resolution.mean.count(),
+                        env.clock_cost.mean.count()
+                    };
+
+                    getResultCapture().benchmarkStarting(info);
+
+                    auto samples = user_code([&] {
+                        return plan.template run<Clock>(*cfg, env);
+                    });
+
+                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
+                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    getResultCapture().benchmarkEnded(stats);
+
+                } CATCH_CATCH_ALL{
+                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
+                        std::rethrow_exception(std::current_exception());
+                }
+            }
+
+            // sets lambda to be used in fun *and* executes benchmark!
+            template <typename Fun,
+                typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
+                Benchmark & operator=(Fun func) {
+                fun = Detail::BenchmarkFunction(func);
+                run();
+                return *this;
+            }
+
+            explicit operator bool() {
+                return true;
+            }
+
+        private:
+            Detail::BenchmarkFunction fun;
+            std::string name;
+        };
+    }
+} // namespace Catch
+
+#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
+#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
+
+#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&](int benchmarkIndex)
+
+#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&]
+
+// end catch_benchmark.hpp
+// start catch_constructor.hpp
+
+// Constructor and destructor helpers
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T, bool Destruct>
+            struct ObjectStorage
+            {
+                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
+
+                ObjectStorage() : data() {}
+
+                ObjectStorage(const ObjectStorage& other)
+                {
+                    new(&data) T(other.stored_object());
+                }
+
+                ObjectStorage(ObjectStorage&& other)
+                {
+                    new(&data) T(std::move(other.stored_object()));
+                }
+
+                ~ObjectStorage() { destruct_on_exit<T>(); }
+
+                template <typename... Args>
+                void construct(Args&&... args)
+                {
+                    new (&data) T(std::forward<Args>(args)...);
+                }
+
+                template <bool AllowManualDestruction = !Destruct>
+                typename std::enable_if<AllowManualDestruction>::type destruct()
+                {
+                    stored_object().~T();
+                }
+
+            private:
+                // If this is a constructor benchmark, destruct the underlying object
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
+                // Otherwise, don't
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
+
+                T& stored_object() {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
+
+                T const& stored_object() const {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
+
+                TStorage data;
+            };
+        }
+
+        template <typename T>
+        using storage_for = Detail::ObjectStorage<T, true>;
+
+        template <typename T>
+        using destructable_object = Detail::ObjectStorage<T, false>;
+    }
+}
+
+// end catch_constructor.hpp
+// end catch_benchmarking_all.hpp
+#endif
+
+#endif // ! CATCH_CONFIG_IMPL_ONLY
+
+#ifdef CATCH_IMPL
+// start catch_impl.hpp
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+// Keep these here for external reporters
+// start catch_test_case_tracker.h
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    struct NameAndLocation {
+        std::string name;
+        SourceLineInfo location;
+
+        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
+    };
+
+    struct ITracker;
+
+    using ITrackerPtr = std::shared_ptr<ITracker>;
+
+    struct ITracker {
+        virtual ~ITracker();
+
+        // static queries
+        virtual NameAndLocation const& nameAndLocation() const = 0;
+
+        // dynamic queries
+        virtual bool isComplete() const = 0; // Successfully completed or failed
+        virtual bool isSuccessfullyCompleted() const = 0;
+        virtual bool isOpen() const = 0; // Started but not complete
+        virtual bool hasChildren() const = 0;
+
+        virtual ITracker& parent() = 0;
+
+        // actions
+        virtual void close() = 0; // Successfully complete
+        virtual void fail() = 0;
+        virtual void markAsNeedingAnotherRun() = 0;
+
+        virtual void addChild( ITrackerPtr const& child ) = 0;
+        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
+        virtual void openChild() = 0;
+
+        // Debug/ checking
+        virtual bool isSectionTracker() const = 0;
+        virtual bool isGeneratorTracker() const = 0;
+    };
+
+    class TrackerContext {
+
+        enum RunState {
+            NotStarted,
+            Executing,
+            CompletedCycle
+        };
+
+        ITrackerPtr m_rootTracker;
+        ITracker* m_currentTracker = nullptr;
+        RunState m_runState = NotStarted;
+
+    public:
+
+        ITracker& startRun();
+        void endRun();
+
+        void startCycle();
+        void completeCycle();
+
+        bool completedCycle() const;
+        ITracker& currentTracker();
+        void setCurrentTracker( ITracker* tracker );
+    };
+
+    class TrackerBase : public ITracker {
+    protected:
+        enum CycleState {
+            NotStarted,
+            Executing,
+            ExecutingChildren,
+            NeedsAnotherRun,
+            CompletedSuccessfully,
+            Failed
+        };
+
+        using Children = std::vector<ITrackerPtr>;
+        NameAndLocation m_nameAndLocation;
+        TrackerContext& m_ctx;
+        ITracker* m_parent;
+        Children m_children;
+        CycleState m_runState = NotStarted;
+
+    public:
+        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+        NameAndLocation const& nameAndLocation() const override;
+        bool isComplete() const override;
+        bool isSuccessfullyCompleted() const override;
+        bool isOpen() const override;
+        bool hasChildren() const override;
+
+        void addChild( ITrackerPtr const& child ) override;
+
+        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
+        ITracker& parent() override;
+
+        void openChild() override;
+
+        bool isSectionTracker() const override;
+        bool isGeneratorTracker() const override;
+
+        void open();
+
+        void close() override;
+        void fail() override;
+        void markAsNeedingAnotherRun() override;
+
+    private:
+        void moveToParent();
+        void moveToThis();
+    };
+
+    class SectionTracker : public TrackerBase {
+        std::vector<std::string> m_filters;
+        std::string m_trimmed_name;
+    public:
+        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+        bool isSectionTracker() const override;
+
+        bool isComplete() const override;
+
+        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
+
+        void tryOpen();
+
+        void addInitialFilters( std::vector<std::string> const& filters );
+        void addNextFilters( std::vector<std::string> const& filters );
+    };
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+
+} // namespace Catch
+
+// end catch_test_case_tracker.h
+
+// start catch_leak_detector.h
+
+namespace Catch {
+
+    struct LeakDetector {
+        LeakDetector();
+        ~LeakDetector();
+    };
+
+}
+// end catch_leak_detector.h
+// Cpp files will be included in the single-header file here
+// start catch_stats.cpp
+
+// Statistical analysis tools
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+
+#include <cassert>
+#include <random>
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <future>
+#endif
+
+namespace {
+    double erf_inv(double x) {
+        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
+        double w, p;
+
+        w = -log((1.0 - x) * (1.0 + x));
+
+        if (w < 6.250000) {
+            w = w - 3.125000;
+            p = -3.6444120640178196996e-21;
+            p = -1.685059138182016589e-19 + p * w;
+            p = 1.2858480715256400167e-18 + p * w;
+            p = 1.115787767802518096e-17 + p * w;
+            p = -1.333171662854620906e-16 + p * w;
+            p = 2.0972767875968561637e-17 + p * w;
+            p = 6.6376381343583238325e-15 + p * w;
+            p = -4.0545662729752068639e-14 + p * w;
+            p = -8.1519341976054721522e-14 + p * w;
+            p = 2.6335093153082322977e-12 + p * w;
+            p = -1.2975133253453532498e-11 + p * w;
+            p = -5.4154120542946279317e-11 + p * w;
+            p = 1.051212273321532285e-09 + p * w;
+            p = -4.1126339803469836976e-09 + p * w;
+            p = -2.9070369957882005086e-08 + p * w;
+            p = 4.2347877827932403518e-07 + p * w;
+            p = -1.3654692000834678645e-06 + p * w;
+            p = -1.3882523362786468719e-05 + p * w;
+            p = 0.0001867342080340571352 + p * w;
+            p = -0.00074070253416626697512 + p * w;
+            p = -0.0060336708714301490533 + p * w;
+            p = 0.24015818242558961693 + p * w;
+            p = 1.6536545626831027356 + p * w;
+        } else if (w < 16.000000) {
+            w = sqrt(w) - 3.250000;
+            p = 2.2137376921775787049e-09;
+            p = 9.0756561938885390979e-08 + p * w;
+            p = -2.7517406297064545428e-07 + p * w;
+            p = 1.8239629214389227755e-08 + p * w;
+            p = 1.5027403968909827627e-06 + p * w;
+            p = -4.013867526981545969e-06 + p * w;
+            p = 2.9234449089955446044e-06 + p * w;
+            p = 1.2475304481671778723e-05 + p * w;
+            p = -4.7318229009055733981e-05 + p * w;
+            p = 6.8284851459573175448e-05 + p * w;
+            p = 2.4031110387097893999e-05 + p * w;
+            p = -0.0003550375203628474796 + p * w;
+            p = 0.00095328937973738049703 + p * w;
+            p = -0.0016882755560235047313 + p * w;
+            p = 0.0024914420961078508066 + p * w;
+            p = -0.0037512085075692412107 + p * w;
+            p = 0.005370914553590063617 + p * w;
+            p = 1.0052589676941592334 + p * w;
+            p = 3.0838856104922207635 + p * w;
+        } else {
+            w = sqrt(w) - 5.000000;
+            p = -2.7109920616438573243e-11;
+            p = -2.5556418169965252055e-10 + p * w;
+            p = 1.5076572693500548083e-09 + p * w;
+            p = -3.7894654401267369937e-09 + p * w;
+            p = 7.6157012080783393804e-09 + p * w;
+            p = -1.4960026627149240478e-08 + p * w;
+            p = 2.9147953450901080826e-08 + p * w;
+            p = -6.7711997758452339498e-08 + p * w;
+            p = 2.2900482228026654717e-07 + p * w;
+            p = -9.9298272942317002539e-07 + p * w;
+            p = 4.5260625972231537039e-06 + p * w;
+            p = -1.9681778105531670567e-05 + p * w;
+            p = 7.5995277030017761139e-05 + p * w;
+            p = -0.00021503011930044477347 + p * w;
+            p = -0.00013871931833623122026 + p * w;
+            p = 1.0103004648645343977 + p * w;
+            p = 4.8499064014085844221 + p * w;
+        }
+        return p * x;
+    }
+
+    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
+        auto m = Catch::Benchmark::Detail::mean(first, last);
+        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
+            double diff = b - m;
+            return a + diff * diff;
+            }) / (last - first);
+            return std::sqrt(variance);
+    }
+
+}
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                auto count = last - first;
+                double idx = (count - 1) * k / static_cast<double>(q);
+                int j = static_cast<int>(idx);
+                double g = idx - j;
+                std::nth_element(first, first + j, last);
+                auto xj = first[j];
+                if (g == 0) return xj;
+
+                auto xj1 = *std::min_element(first + (j + 1), last);
+                return xj + g * (xj1 - xj);
+            }
+
+            double erfc_inv(double x) {
+                return erf_inv(1.0 - x);
+            }
+
+            double normal_quantile(double p) {
+                static const double ROOT_TWO = std::sqrt(2.0);
+
+                double result = 0.0;
+                assert(p >= 0 && p <= 1);
+                if (p < 0 || p > 1) {
+                    return result;
+                }
+
+                result = -erfc_inv(2.0 * p);
+                // result *= normal distribution standard deviation (1.0) * sqrt(2)
+                result *= /*sd * */ ROOT_TWO;
+                // result += normal disttribution mean (0)
+                return result;
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
+                double sb = stddev.point;
+                double mn = mean.point / n;
+                double mg_min = mn / 2.;
+                double sg = std::min(mg_min / 4., sb / std::sqrt(n));
+                double sg2 = sg * sg;
+                double sb2 = sb * sb;
+
+                auto c_max = [n, mn, sb2, sg2](double x) -> double {
+                    double k = mn - x;
+                    double d = k * k;
+                    double nd = n * d;
+                    double k0 = -n * nd;
+                    double k1 = sb2 - n * sg2 + nd;
+                    double det = k1 * k1 - 4 * sg2 * k0;
+                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
+                };
+
+                auto var_out = [n, sb2, sg2](double c) {
+                    double nc = n - c;
+                    return (nc / n) * (sb2 - nc * sg2);
+                };
+
+                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
+            }
+
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+                static std::random_device entropy;
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
+
+                auto mean = &Detail::mean<std::vector<double>::iterator>;
+                auto stddev = &standard_deviation;
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    return std::async(std::launch::async, [=] {
+                        std::mt19937 rng(seed);
+                        auto resampled = resample(rng, n_resamples, first, last, f);
+                        return bootstrap(confidence_level, first, last, resampled, f);
+                    });
+                };
+
+                auto mean_future = Estimate(mean);
+                auto stddev_future = Estimate(stddev);
+
+                auto mean_estimate = mean_future.get();
+                auto stddev_estimate = stddev_future.get();
+#else
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    std::mt19937 rng(seed);
+                    auto resampled = resample(rng, n_resamples, first, last, f);
+                    return bootstrap(confidence_level, first, last, resampled, f);
+                };
+
+                auto mean_estimate = Estimate(mean);
+                auto stddev_estimate = Estimate(stddev);
+#endif // CATCH_USE_ASYNC
+
+                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
+
+                return { mean_estimate, stddev_estimate, outlier_variance };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+// end catch_stats.cpp
+// start catch_approx.cpp
+
+#include <cmath>
+#include <limits>
+
+namespace {
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+}
+
+namespace Catch {
+namespace Detail {
+
+    Approx::Approx ( double value )
+    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
+        m_margin( 0.0 ),
+        m_scale( 0.0 ),
+        m_value( value )
+    {}
+
+    Approx Approx::custom() {
+        return Approx( 0 );
+    }
+
+    Approx Approx::operator-() const {
+        auto temp(*this);
+        temp.m_value = -temp.m_value;
+        return temp;
+    }
+
+    std::string Approx::toString() const {
+        ReusableStringStream rss;
+        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
+        return rss.str();
+    }
+
+    bool Approx::equalityComparisonImpl(const double other) const {
+        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
+        // Thanks to Richard Harris for his help refining the scaled margin value
+        return marginComparison(m_value, other, m_margin)
+            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
+    }
+
+    void Approx::setMargin(double newMargin) {
+        CATCH_ENFORCE(newMargin >= 0,
+            "Invalid Approx::margin: " << newMargin << '.'
+            << " Approx::Margin has to be non-negative.");
+        m_margin = newMargin;
+    }
+
+    void Approx::setEpsilon(double newEpsilon) {
+        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+            "Invalid Approx::epsilon: " << newEpsilon << '.'
+            << " Approx::epsilon has to be in [0, 1]");
+        m_epsilon = newEpsilon;
+    }
+
+} // end namespace Detail
+
+namespace literals {
+    Detail::Approx operator "" _a(long double val) {
+        return Detail::Approx(val);
+    }
+    Detail::Approx operator "" _a(unsigned long long val) {
+        return Detail::Approx(val);
+    }
+} // end namespace literals
+
+std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
+    return value.toString();
+}
+
+} // end namespace Catch
+// end catch_approx.cpp
+// start catch_assertionhandler.cpp
+
+// start catch_debugger.h
+
+namespace Catch {
+    bool isDebuggerActive();
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
+
+#elif defined(CATCH_PLATFORM_IPHONE)
+
+    // use inline assembler
+    #if defined(__i386__) || defined(__x86_64__)
+        #define CATCH_TRAP()  __asm__("int $3")
+    #elif defined(__aarch64__)
+        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
+    #elif defined(__arm__) && !defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
+    #elif defined(__arm__) &&  defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xde01")
+    #endif
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    // If we can use inline assembler, do it because this allows us to break
+    // directly at the location of the failing check instead of breaking inside
+    // raise() called from it, i.e. one stack frame below.
+    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
+    #else // Fall back to the generic way.
+        #include <signal.h>
+
+        #define CATCH_TRAP() raise(SIGTRAP)
+    #endif
+#elif defined(_MSC_VER)
+    #define CATCH_TRAP() __debugbreak()
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+    #define CATCH_TRAP() DebugBreak()
+#endif
+
+#ifndef CATCH_BREAK_INTO_DEBUGGER
+    #ifdef CATCH_TRAP
+        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
+    #else
+        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
+    #endif
+#endif
+
+// end catch_debugger.h
+// start catch_run_context.h
+
+// start catch_fatal_condition.h
+
+// start catch_windows_h_proxy.h
+
+
+#if defined(CATCH_PLATFORM_WINDOWS)
+
+#if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
+#  define CATCH_DEFINED_NOMINMAX
+#  define NOMINMAX
+#endif
+#if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
+#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+#endif
+
+#ifdef __AFXDLL
+#include <AfxWin.h>
+#else
+#include <windows.h>
+#endif
+
+#ifdef CATCH_DEFINED_NOMINMAX
+#  undef NOMINMAX
+#endif
+#ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN
+#  undef WIN32_LEAN_AND_MEAN
+#endif
+
+#endif // defined(CATCH_PLATFORM_WINDOWS)
+
+// end catch_windows_h_proxy.h
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+
+    struct FatalConditionHandler {
+
+        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
+        FatalConditionHandler();
+        static void reset();
+        ~FatalConditionHandler();
+
+    private:
+        static bool isSet;
+        static ULONG guaranteeSize;
+        static PVOID exceptionHandlerHandle;
+    };
+
+} // namespace Catch
+
+#elif defined ( CATCH_CONFIG_POSIX_SIGNALS )
+
+#include <signal.h>
+
+namespace Catch {
+
+    struct FatalConditionHandler {
+
+        static bool isSet;
+        static struct sigaction oldSigActions[];
+        static stack_t oldSigStack;
+        static char altStackMem[];
+
+        static void handleSignal( int sig );
+
+        FatalConditionHandler();
+        ~FatalConditionHandler();
+        static void reset();
+    };
+
+} // namespace Catch
+
+#else
+
+namespace Catch {
+    struct FatalConditionHandler {
+        void reset();
+    };
+}
+
+#endif
+
+// end catch_fatal_condition.h
+#include <string>
+
+namespace Catch {
+
+    struct IMutableContext;
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class RunContext : public IResultCapture, public IRunner {
+
+    public:
+        RunContext( RunContext const& ) = delete;
+        RunContext& operator =( RunContext const& ) = delete;
+
+        explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
+
+        ~RunContext() override;
+
+        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
+        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
+
+        Totals runTest(TestCase const& testCase);
+
+        IConfigPtr config() const;
+        IStreamingReporter& reporter() const;
+
+    public: // IResultCapture
+
+        // Assertion handlers
+        void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) override;
+        void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    StringRef const& message,
+                    AssertionReaction& reaction ) override;
+        void handleUnexpectedExceptionNotThrown
+                (   AssertionInfo const& info,
+                    AssertionReaction& reaction ) override;
+        void handleUnexpectedInflightException
+                (   AssertionInfo const& info,
+                    std::string const& message,
+                    AssertionReaction& reaction ) override;
+        void handleIncomplete
+                (   AssertionInfo const& info ) override;
+        void handleNonExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    AssertionReaction &reaction ) override;
+
+        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
+
+        void sectionEnded( SectionEndInfo const& endInfo ) override;
+        void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
+
+        auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing( std::string const& name ) override;
+        void benchmarkStarting( BenchmarkInfo const& info ) override;
+        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
+        void benchmarkFailed( std::string const& error ) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void pushScopedMessage( MessageInfo const& message ) override;
+        void popScopedMessage( MessageInfo const& message ) override;
+
+        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
+
+        std::string getCurrentTestName() const override;
+
+        const AssertionResult* getLastResult() const override;
+
+        void exceptionEarlyReported() override;
+
+        void handleFatalErrorCondition( StringRef message ) override;
+
+        bool lastAssertionPassed() override;
+
+        void assertionPassed() override;
+
+    public:
+        // !TBD We need to do this another way!
+        bool aborting() const final;
+
+    private:
+
+        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
+        void invokeActiveTestCase();
+
+        void resetAssertionInfo();
+        bool testForMissingAssertions( Counts& assertions );
+
+        void assertionEnded( AssertionResult const& result );
+        void reportExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    ITransientExpression const *expr,
+                    bool negated );
+
+        void populateReaction( AssertionReaction& reaction );
+
+    private:
+
+        void handleUnfinishedSections();
+
+        TestRunInfo m_runInfo;
+        IMutableContext& m_context;
+        TestCase const* m_activeTestCase = nullptr;
+        ITracker* m_testCaseTracker = nullptr;
+        Option<AssertionResult> m_lastResult;
+
+        IConfigPtr m_config;
+        Totals m_totals;
+        IStreamingReporterPtr m_reporter;
+        std::vector<MessageInfo> m_messages;
+        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
+        AssertionInfo m_lastAssertionInfo;
+        std::vector<SectionEndInfo> m_unfinishedSections;
+        std::vector<ITracker*> m_activeSections;
+        TrackerContext m_trackerContext;
+        bool m_lastAssertionPassed = false;
+        bool m_shouldReportUnexpected = true;
+        bool m_includeSuccessfulResults;
+    };
+
+    void seedRng(IConfig const& config);
+    unsigned int rngSeed();
+} // end namespace Catch
+
+// end catch_run_context.h
+namespace Catch {
+
+    namespace {
+        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
+            expr.streamReconstructedExpression( os );
+            return os;
+        }
+    }
+
+    LazyExpression::LazyExpression( bool isNegated )
+    :   m_isNegated( isNegated )
+    {}
+
+    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
+
+    LazyExpression::operator bool() const {
+        return m_transientExpression != nullptr;
+    }
+
+    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
+        if( lazyExpr.m_isNegated )
+            os << "!";
+
+        if( lazyExpr ) {
+            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
+                os << "(" << *lazyExpr.m_transientExpression << ")";
+            else
+                os << *lazyExpr.m_transientExpression;
+        }
+        else {
+            os << "{** error - unchecked empty expression requested **}";
+        }
+        return os;
+    }
+
+    AssertionHandler::AssertionHandler
+        (   StringRef const& macroName,
+            SourceLineInfo const& lineInfo,
+            StringRef capturedExpression,
+            ResultDisposition::Flags resultDisposition )
+    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
+        m_resultCapture( getResultCapture() )
+    {}
+
+    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
+        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
+    }
+    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
+        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
+    }
+
+    auto AssertionHandler::allowThrows() const -> bool {
+        return getCurrentContext().getConfig()->allowThrows();
+    }
+
+    void AssertionHandler::complete() {
+        setCompleted();
+        if( m_reaction.shouldDebugBreak ) {
+
+            // If you find your debugger stopping you here then go one level up on the
+            // call-stack for the code that caused it (typically a failed assertion)
+
+            // (To go back to the test and change execution, jump over the throw, next)
+            CATCH_BREAK_INTO_DEBUGGER();
+        }
+        if (m_reaction.shouldThrow) {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+            throw Catch::TestFailureException();
+#else
+            CATCH_ERROR( "Test failure requires aborting test!" );
+#endif
+        }
+    }
+    void AssertionHandler::setCompleted() {
+        m_completed = true;
+    }
+
+    void AssertionHandler::handleUnexpectedInflightException() {
+        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
+    }
+
+    void AssertionHandler::handleExceptionThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+    void AssertionHandler::handleExceptionNotThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
+        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
+    }
+
+    void AssertionHandler::handleThrowingCallSkipped() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    // This is the overload that takes a string and infers the Equals matcher from it
+    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
+        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
+    }
+
+} // namespace Catch
+// end catch_assertionhandler.cpp
+// start catch_assertionresult.cpp
+
+namespace Catch {
+    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
+        lazyExpression(_lazyExpression),
+        resultType(_resultType) {}
+
+    std::string AssertionResultData::reconstructExpression() const {
+
+        if( reconstructedExpression.empty() ) {
+            if( lazyExpression ) {
+                ReusableStringStream rss;
+                rss << lazyExpression;
+                reconstructedExpression = rss.str();
+            }
+        }
+        return reconstructedExpression;
+    }
+
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+    :   m_info( info ),
+        m_resultData( data )
+    {}
+
+    // Result was a success
+    bool AssertionResult::succeeded() const {
+        return Catch::isOk( m_resultData.resultType );
+    }
+
+    // Result was a success, or failure is suppressed
+    bool AssertionResult::isOk() const {
+        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+    }
+
+    ResultWas::OfType AssertionResult::getResultType() const {
+        return m_resultData.resultType;
+    }
+
+    bool AssertionResult::hasExpression() const {
+        return !m_info.capturedExpression.empty();
+    }
+
+    bool AssertionResult::hasMessage() const {
+        return !m_resultData.message.empty();
+    }
+
+    std::string AssertionResult::getExpression() const {
+        // Possibly overallocating by 3 characters should be basically free
+        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += "!(";
+        }
+        expr += m_info.capturedExpression;
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += ')';
+        }
+        return expr;
+    }
+
+    std::string AssertionResult::getExpressionInMacro() const {
+        std::string expr;
+        if( m_info.macroName.empty() )
+            expr = static_cast<std::string>(m_info.capturedExpression);
+        else {
+            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
+            expr += m_info.macroName;
+            expr += "( ";
+            expr += m_info.capturedExpression;
+            expr += " )";
+        }
+        return expr;
+    }
+
+    bool AssertionResult::hasExpandedExpression() const {
+        return hasExpression() && getExpandedExpression() != getExpression();
+    }
+
+    std::string AssertionResult::getExpandedExpression() const {
+        std::string expr = m_resultData.reconstructExpression();
+        return expr.empty()
+                ? getExpression()
+                : expr;
+    }
+
+    std::string AssertionResult::getMessage() const {
+        return m_resultData.message;
+    }
+    SourceLineInfo AssertionResult::getSourceInfo() const {
+        return m_info.lineInfo;
+    }
+
+    StringRef AssertionResult::getTestMacroName() const {
+        return m_info.macroName;
+    }
+
+} // end namespace Catch
+// end catch_assertionresult.cpp
+// start catch_capture_matchers.cpp
+
+namespace Catch {
+
+    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+    // This is the general overload that takes a any string matcher
+    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
+    // the Equals matcher (so the header does not mention matchers)
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
+        std::string exceptionMessage = Catch::translateActiveException();
+        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
+        handler.handleExpr( expr );
+    }
+
+} // namespace Catch
+// end catch_capture_matchers.cpp
+// start catch_commandline.cpp
+
+// start catch_commandline.h
+
+// start catch_clara.h
+
+// Use Catch's value for console width (store Clara's off to the side, if present)
+#ifdef CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#endif
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic ignored "-Wshadow"
+#endif
+
+// start clara.hpp
+// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See https://github.com/philsquared/Clara for more details
+
+// Clara v1.1.5
+
+
+#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+#ifndef CLARA_CONFIG_OPTIONAL_TYPE
+#ifdef __has_include
+#if __has_include(<optional>) && __cplusplus >= 201703L
+#include <optional>
+#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
+#endif
+#endif
+#endif
+
+// ----------- #included from clara_textflow.hpp -----------
+
+// TextFlowCpp
+//
+// A single-header library for wrapping and laying out basic text, by Phil Nash
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// This project is hosted at https://github.com/philsquared/textflowcpp
+
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+#include <vector>
+
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+namespace clara {
+namespace TextFlow {
+
+inline auto isWhitespace(char c) -> bool {
+	static std::string chars = " \t\n\r";
+	return chars.find(c) != std::string::npos;
+}
+inline auto isBreakableBefore(char c) -> bool {
+	static std::string chars = "[({<|";
+	return chars.find(c) != std::string::npos;
+}
+inline auto isBreakableAfter(char c) -> bool {
+	static std::string chars = "])}>.,:;*+-=&/\\";
+	return chars.find(c) != std::string::npos;
+}
+
+class Columns;
+
+class Column {
+	std::vector<std::string> m_strings;
+	size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
+	size_t m_indent = 0;
+	size_t m_initialIndent = std::string::npos;
+
+public:
+	class iterator {
+		friend Column;
+
+		Column const& m_column;
+		size_t m_stringIndex = 0;
+		size_t m_pos = 0;
+
+		size_t m_len = 0;
+		size_t m_end = 0;
+		bool m_suffix = false;
+
+		iterator(Column const& column, size_t stringIndex)
+			: m_column(column),
+			m_stringIndex(stringIndex) {}
+
+		auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
+
+		auto isBoundary(size_t at) const -> bool {
+			assert(at > 0);
+			assert(at <= line().size());
+
+			return at == line().size() ||
+				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
+				isBreakableBefore(line()[at]) ||
+				isBreakableAfter(line()[at - 1]);
+		}
+
+		void calcLength() {
+			assert(m_stringIndex < m_column.m_strings.size());
+
+			m_suffix = false;
+			auto width = m_column.m_width - indent();
+			m_end = m_pos;
+			if (line()[m_pos] == '\n') {
+				++m_end;
+			}
+			while (m_end < line().size() && line()[m_end] != '\n')
+				++m_end;
+
+			if (m_end < m_pos + width) {
+				m_len = m_end - m_pos;
+			} else {
+				size_t len = width;
+				while (len > 0 && !isBoundary(m_pos + len))
+					--len;
+				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
+					--len;
+
+				if (len > 0) {
+					m_len = len;
+				} else {
+					m_suffix = true;
+					m_len = width - 1;
+				}
+			}
+		}
+
+		auto indent() const -> size_t {
+			auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
+			return initial == std::string::npos ? m_column.m_indent : initial;
+		}
+
+		auto addIndentAndSuffix(std::string const &plain) const -> std::string {
+			return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
+		}
+
+	public:
+		using difference_type = std::ptrdiff_t;
+		using value_type = std::string;
+		using pointer = value_type * ;
+		using reference = value_type & ;
+		using iterator_category = std::forward_iterator_tag;
+
+		explicit iterator(Column const& column) : m_column(column) {
+			assert(m_column.m_width > m_column.m_indent);
+			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
+			calcLength();
+			if (m_len == 0)
+				m_stringIndex++; // Empty string
+		}
+
+		auto operator *() const -> std::string {
+			assert(m_stringIndex < m_column.m_strings.size());
+			assert(m_pos <= m_end);
+			return addIndentAndSuffix(line().substr(m_pos, m_len));
+		}
+
+		auto operator ++() -> iterator& {
+			m_pos += m_len;
+			if (m_pos < line().size() && line()[m_pos] == '\n')
+				m_pos += 1;
+			else
+				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
+					++m_pos;
+
+			if (m_pos == line().size()) {
+				m_pos = 0;
+				++m_stringIndex;
+			}
+			if (m_stringIndex < m_column.m_strings.size())
+				calcLength();
+			return *this;
+		}
+		auto operator ++(int) -> iterator {
+			iterator prev(*this);
+			operator++();
+			return prev;
+		}
+
+		auto operator ==(iterator const& other) const -> bool {
+			return
+				m_pos == other.m_pos &&
+				m_stringIndex == other.m_stringIndex &&
+				&m_column == &other.m_column;
+		}
+		auto operator !=(iterator const& other) const -> bool {
+			return !operator==(other);
+		}
+	};
+	using const_iterator = iterator;
+
+	explicit Column(std::string const& text) { m_strings.push_back(text); }
+
+	auto width(size_t newWidth) -> Column& {
+		assert(newWidth > 0);
+		m_width = newWidth;
+		return *this;
+	}
+	auto indent(size_t newIndent) -> Column& {
+		m_indent = newIndent;
+		return *this;
+	}
+	auto initialIndent(size_t newIndent) -> Column& {
+		m_initialIndent = newIndent;
+		return *this;
+	}
+
+	auto width() const -> size_t { return m_width; }
+	auto begin() const -> iterator { return iterator(*this); }
+	auto end() const -> iterator { return { *this, m_strings.size() }; }
+
+	inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
+		bool first = true;
+		for (auto line : col) {
+			if (first)
+				first = false;
+			else
+				os << "\n";
+			os << line;
+		}
+		return os;
+	}
+
+	auto operator + (Column const& other)->Columns;
+
+	auto toString() const -> std::string {
+		std::ostringstream oss;
+		oss << *this;
+		return oss.str();
+	}
+};
+
+class Spacer : public Column {
+
+public:
+	explicit Spacer(size_t spaceWidth) : Column("") {
+		width(spaceWidth);
+	}
+};
+
+class Columns {
+	std::vector<Column> m_columns;
+
+public:
+
+	class iterator {
+		friend Columns;
+		struct EndTag {};
+
+		std::vector<Column> const& m_columns;
+		std::vector<Column::iterator> m_iterators;
+		size_t m_activeIterators;
+
+		iterator(Columns const& columns, EndTag)
+			: m_columns(columns.m_columns),
+			m_activeIterators(0) {
+			m_iterators.reserve(m_columns.size());
+
+			for (auto const& col : m_columns)
+				m_iterators.push_back(col.end());
+		}
+
+	public:
+		using difference_type = std::ptrdiff_t;
+		using value_type = std::string;
+		using pointer = value_type * ;
+		using reference = value_type & ;
+		using iterator_category = std::forward_iterator_tag;
+
+		explicit iterator(Columns const& columns)
+			: m_columns(columns.m_columns),
+			m_activeIterators(m_columns.size()) {
+			m_iterators.reserve(m_columns.size());
+
+			for (auto const& col : m_columns)
+				m_iterators.push_back(col.begin());
+		}
+
+		auto operator ==(iterator const& other) const -> bool {
+			return m_iterators == other.m_iterators;
+		}
+		auto operator !=(iterator const& other) const -> bool {
+			return m_iterators != other.m_iterators;
+		}
+		auto operator *() const -> std::string {
+			std::string row, padding;
+
+			for (size_t i = 0; i < m_columns.size(); ++i) {
+				auto width = m_columns[i].width();
+				if (m_iterators[i] != m_columns[i].end()) {
+					std::string col = *m_iterators[i];
+					row += padding + col;
+					if (col.size() < width)
+						padding = std::string(width - col.size(), ' ');
+					else
+						padding = "";
+				} else {
+					padding += std::string(width, ' ');
+				}
+			}
+			return row;
+		}
+		auto operator ++() -> iterator& {
+			for (size_t i = 0; i < m_columns.size(); ++i) {
+				if (m_iterators[i] != m_columns[i].end())
+					++m_iterators[i];
+			}
+			return *this;
+		}
+		auto operator ++(int) -> iterator {
+			iterator prev(*this);
+			operator++();
+			return prev;
+		}
+	};
+	using const_iterator = iterator;
+
+	auto begin() const -> iterator { return iterator(*this); }
+	auto end() const -> iterator { return { *this, iterator::EndTag() }; }
+
+	auto operator += (Column const& col) -> Columns& {
+		m_columns.push_back(col);
+		return *this;
+	}
+	auto operator + (Column const& col) -> Columns {
+		Columns combined = *this;
+		combined += col;
+		return combined;
+	}
+
+	inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
+
+		bool first = true;
+		for (auto line : cols) {
+			if (first)
+				first = false;
+			else
+				os << "\n";
+			os << line;
+		}
+		return os;
+	}
+
+	auto toString() const -> std::string {
+		std::ostringstream oss;
+		oss << *this;
+		return oss.str();
+	}
+};
+
+inline auto Column::operator + (Column const& other) -> Columns {
+	Columns cols;
+	cols += *this;
+	cols += other;
+	return cols;
+}
+}
+
+}
+}
+
+// ----------- end of #include from clara_textflow.hpp -----------
+// ........... back in clara.hpp
+
+#include <cctype>
+#include <string>
+#include <memory>
+#include <set>
+#include <algorithm>
+
+#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
+#define CATCH_PLATFORM_WINDOWS
+#endif
+
+namespace Catch { namespace clara {
+namespace detail {
+
+    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
+    template<typename L>
+    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
+
+    template<typename ClassT, typename ReturnT, typename... Args>
+    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
+        static const bool isValid = false;
+    };
+
+    template<typename ClassT, typename ReturnT, typename ArgT>
+    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
+        static const bool isValid = true;
+        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
+        using ReturnType = ReturnT;
+    };
+
+    class TokenStream;
+
+    // Transport for raw args (copied from main args, or supplied via init list for testing)
+    class Args {
+        friend TokenStream;
+        std::string m_exeName;
+        std::vector<std::string> m_args;
+
+    public:
+        Args( int argc, char const* const* argv )
+            : m_exeName(argv[0]),
+              m_args(argv + 1, argv + argc) {}
+
+        Args( std::initializer_list<std::string> args )
+        :   m_exeName( *args.begin() ),
+            m_args( args.begin()+1, args.end() )
+        {}
+
+        auto exeName() const -> std::string {
+            return m_exeName;
+        }
+    };
+
+    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
+    // may encode an option + its argument if the : or = form is used
+    enum class TokenType {
+        Option, Argument
+    };
+    struct Token {
+        TokenType type;
+        std::string token;
+    };
+
+    inline auto isOptPrefix( char c ) -> bool {
+        return c == '-'
+#ifdef CATCH_PLATFORM_WINDOWS
+            || c == '/'
+#endif
+        ;
+    }
+
+    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
+    class TokenStream {
+        using Iterator = std::vector<std::string>::const_iterator;
+        Iterator it;
+        Iterator itEnd;
+        std::vector<Token> m_tokenBuffer;
+
+        void loadBuffer() {
+            m_tokenBuffer.resize( 0 );
+
+            // Skip any empty strings
+            while( it != itEnd && it->empty() )
+                ++it;
+
+            if( it != itEnd ) {
+                auto const &next = *it;
+                if( isOptPrefix( next[0] ) ) {
+                    auto delimiterPos = next.find_first_of( " :=" );
+                    if( delimiterPos != std::string::npos ) {
+                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
+                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
+                    } else {
+                        if( next[1] != '-' && next.size() > 2 ) {
+                            std::string opt = "- ";
+                            for( size_t i = 1; i < next.size(); ++i ) {
+                                opt[1] = next[i];
+                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
+                            }
+                        } else {
+                            m_tokenBuffer.push_back( { TokenType::Option, next } );
+                        }
+                    }
+                } else {
+                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
+                }
+            }
+        }
+
+    public:
+        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
+
+        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
+            loadBuffer();
+        }
+
+        explicit operator bool() const {
+            return !m_tokenBuffer.empty() || it != itEnd;
+        }
+
+        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
+
+        auto operator*() const -> Token {
+            assert( !m_tokenBuffer.empty() );
+            return m_tokenBuffer.front();
+        }
+
+        auto operator->() const -> Token const * {
+            assert( !m_tokenBuffer.empty() );
+            return &m_tokenBuffer.front();
+        }
+
+        auto operator++() -> TokenStream & {
+            if( m_tokenBuffer.size() >= 2 ) {
+                m_tokenBuffer.erase( m_tokenBuffer.begin() );
+            } else {
+                if( it != itEnd )
+                    ++it;
+                loadBuffer();
+            }
+            return *this;
+        }
+    };
+
+    class ResultBase {
+    public:
+        enum Type {
+            Ok, LogicError, RuntimeError
+        };
+
+    protected:
+        ResultBase( Type type ) : m_type( type ) {}
+        virtual ~ResultBase() = default;
+
+        virtual void enforceOk() const = 0;
+
+        Type m_type;
+    };
+
+    template<typename T>
+    class ResultValueBase : public ResultBase {
+    public:
+        auto value() const -> T const & {
+            enforceOk();
+            return m_value;
+        }
+
+    protected:
+        ResultValueBase( Type type ) : ResultBase( type ) {}
+
+        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
+            if( m_type == ResultBase::Ok )
+                new( &m_value ) T( other.m_value );
+        }
+
+        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
+            new( &m_value ) T( value );
+        }
+
+        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
+            if( m_type == ResultBase::Ok )
+                m_value.~T();
+            ResultBase::operator=(other);
+            if( m_type == ResultBase::Ok )
+                new( &m_value ) T( other.m_value );
+            return *this;
+        }
+
+        ~ResultValueBase() override {
+            if( m_type == Ok )
+                m_value.~T();
+        }
+
+        union {
+            T m_value;
+        };
+    };
+
+    template<>
+    class ResultValueBase<void> : public ResultBase {
+    protected:
+        using ResultBase::ResultBase;
+    };
+
+    template<typename T = void>
+    class BasicResult : public ResultValueBase<T> {
+    public:
+        template<typename U>
+        explicit BasicResult( BasicResult<U> const &other )
+        :   ResultValueBase<T>( other.type() ),
+            m_errorMessage( other.errorMessage() )
+        {
+            assert( type() != ResultBase::Ok );
+        }
+
+        template<typename U>
+        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
+        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
+        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
+        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
+
+        explicit operator bool() const { return m_type == ResultBase::Ok; }
+        auto type() const -> ResultBase::Type { return m_type; }
+        auto errorMessage() const -> std::string { return m_errorMessage; }
+
+    protected:
+        void enforceOk() const override {
+
+            // Errors shouldn't reach this point, but if they do
+            // the actual error message will be in m_errorMessage
+            assert( m_type != ResultBase::LogicError );
+            assert( m_type != ResultBase::RuntimeError );
+            if( m_type != ResultBase::Ok )
+                std::abort();
+        }
+
+        std::string m_errorMessage; // Only populated if resultType is an error
+
+        BasicResult( ResultBase::Type type, std::string const &message )
+        :   ResultValueBase<T>(type),
+            m_errorMessage(message)
+        {
+            assert( m_type != ResultBase::Ok );
+        }
+
+        using ResultValueBase<T>::ResultValueBase;
+        using ResultBase::m_type;
+    };
+
+    enum class ParseResultType {
+        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
+    };
+
+    class ParseState {
+    public:
+
+        ParseState( ParseResultType type, TokenStream const &remainingTokens )
+        : m_type(type),
+          m_remainingTokens( remainingTokens )
+        {}
+
+        auto type() const -> ParseResultType { return m_type; }
+        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
+
+    private:
+        ParseResultType m_type;
+        TokenStream m_remainingTokens;
+    };
+
+    using Result = BasicResult<void>;
+    using ParserResult = BasicResult<ParseResultType>;
+    using InternalParseResult = BasicResult<ParseState>;
+
+    struct HelpColumns {
+        std::string left;
+        std::string right;
+    };
+
+    template<typename T>
+    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
+        std::stringstream ss;
+        ss << source;
+        ss >> target;
+        if( ss.fail() )
+            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
+        else
+            return ParserResult::ok( ParseResultType::Matched );
+    }
+    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
+        target = source;
+        return ParserResult::ok( ParseResultType::Matched );
+    }
+    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
+        std::string srcLC = source;
+        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
+        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
+            target = true;
+        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
+            target = false;
+        else
+            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
+        return ParserResult::ok( ParseResultType::Matched );
+    }
+#ifdef CLARA_CONFIG_OPTIONAL_TYPE
+    template<typename T>
+    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
+        T temp;
+        auto result = convertInto( source, temp );
+        if( result )
+            target = std::move(temp);
+        return result;
+    }
+#endif // CLARA_CONFIG_OPTIONAL_TYPE
+
+    struct NonCopyable {
+        NonCopyable() = default;
+        NonCopyable( NonCopyable const & ) = delete;
+        NonCopyable( NonCopyable && ) = delete;
+        NonCopyable &operator=( NonCopyable const & ) = delete;
+        NonCopyable &operator=( NonCopyable && ) = delete;
+    };
+
+    struct BoundRef : NonCopyable {
+        virtual ~BoundRef() = default;
+        virtual auto isContainer() const -> bool { return false; }
+        virtual auto isFlag() const -> bool { return false; }
+    };
+    struct BoundValueRefBase : BoundRef {
+        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
+    };
+    struct BoundFlagRefBase : BoundRef {
+        virtual auto setFlag( bool flag ) -> ParserResult = 0;
+        virtual auto isFlag() const -> bool { return true; }
+    };
+
+    template<typename T>
+    struct BoundValueRef : BoundValueRefBase {
+        T &m_ref;
+
+        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            return convertInto( arg, m_ref );
+        }
+    };
+
+    template<typename T>
+    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
+        std::vector<T> &m_ref;
+
+        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
+
+        auto isContainer() const -> bool override { return true; }
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            T temp;
+            auto result = convertInto( arg, temp );
+            if( result )
+                m_ref.push_back( temp );
+            return result;
+        }
+    };
+
+    struct BoundFlagRef : BoundFlagRefBase {
+        bool &m_ref;
+
+        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
+
+        auto setFlag( bool flag ) -> ParserResult override {
+            m_ref = flag;
+            return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    template<typename ReturnType>
+    struct LambdaInvoker {
+        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
+
+        template<typename L, typename ArgType>
+        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+            return lambda( arg );
+        }
+    };
+
+    template<>
+    struct LambdaInvoker<void> {
+        template<typename L, typename ArgType>
+        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+            lambda( arg );
+            return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    template<typename ArgType, typename L>
+    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
+        ArgType temp{};
+        auto result = convertInto( arg, temp );
+        return !result
+           ? result
+           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
+    }
+
+    template<typename L>
+    struct BoundLambda : BoundValueRefBase {
+        L m_lambda;
+
+        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
+        }
+    };
+
+    template<typename L>
+    struct BoundFlagLambda : BoundFlagRefBase {
+        L m_lambda;
+
+        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
+
+        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+        auto setFlag( bool flag ) -> ParserResult override {
+            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
+        }
+    };
+
+    enum class Optionality { Optional, Required };
+
+    struct Parser;
+
+    class ParserBase {
+    public:
+        virtual ~ParserBase() = default;
+        virtual auto validate() const -> Result { return Result::ok(); }
+        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
+        virtual auto cardinality() const -> size_t { return 1; }
+
+        auto parse( Args const &args ) const -> InternalParseResult {
+            return parse( args.exeName(), TokenStream( args ) );
+        }
+    };
+
+    template<typename DerivedT>
+    class ComposableParserImpl : public ParserBase {
+    public:
+        template<typename T>
+        auto operator|( T const &other ) const -> Parser;
+
+		template<typename T>
+        auto operator+( T const &other ) const -> Parser;
+    };
+
+    // Common code and state for Args and Opts
+    template<typename DerivedT>
+    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
+    protected:
+        Optionality m_optionality = Optionality::Optional;
+        std::shared_ptr<BoundRef> m_ref;
+        std::string m_hint;
+        std::string m_description;
+
+        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
+
+    public:
+        template<typename T>
+        ParserRefImpl( T &ref, std::string const &hint )
+        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
+            m_hint( hint )
+        {}
+
+        template<typename LambdaT>
+        ParserRefImpl( LambdaT const &ref, std::string const &hint )
+        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
+            m_hint(hint)
+        {}
+
+        auto operator()( std::string const &description ) -> DerivedT & {
+            m_description = description;
+            return static_cast<DerivedT &>( *this );
+        }
+
+        auto optional() -> DerivedT & {
+            m_optionality = Optionality::Optional;
+            return static_cast<DerivedT &>( *this );
+        };
+
+        auto required() -> DerivedT & {
+            m_optionality = Optionality::Required;
+            return static_cast<DerivedT &>( *this );
+        };
+
+        auto isOptional() const -> bool {
+            return m_optionality == Optionality::Optional;
+        }
+
+        auto cardinality() const -> size_t override {
+            if( m_ref->isContainer() )
+                return 0;
+            else
+                return 1;
+        }
+
+        auto hint() const -> std::string { return m_hint; }
+    };
+
+    class ExeName : public ComposableParserImpl<ExeName> {
+        std::shared_ptr<std::string> m_name;
+        std::shared_ptr<BoundValueRefBase> m_ref;
+
+        template<typename LambdaT>
+        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
+            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
+        }
+
+    public:
+        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
+
+        explicit ExeName( std::string &ref ) : ExeName() {
+            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
+        }
+
+        template<typename LambdaT>
+        explicit ExeName( LambdaT const& lambda ) : ExeName() {
+            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
+        }
+
+        // The exe name is not parsed out of the normal tokens, but is handled specially
+        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+        }
+
+        auto name() const -> std::string { return *m_name; }
+        auto set( std::string const& newName ) -> ParserResult {
+
+            auto lastSlash = newName.find_last_of( "\\/" );
+            auto filename = ( lastSlash == std::string::npos )
+                    ? newName
+                    : newName.substr( lastSlash+1 );
+
+            *m_name = filename;
+            if( m_ref )
+                return m_ref->setValue( filename );
+            else
+                return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    class Arg : public ParserRefImpl<Arg> {
+    public:
+        using ParserRefImpl::ParserRefImpl;
+
+        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
+            auto validationResult = validate();
+            if( !validationResult )
+                return InternalParseResult( validationResult );
+
+            auto remainingTokens = tokens;
+            auto const &token = *remainingTokens;
+            if( token.type != TokenType::Argument )
+                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+
+            assert( !m_ref->isFlag() );
+            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+
+            auto result = valueRef->setValue( remainingTokens->token );
+            if( !result )
+                return InternalParseResult( result );
+            else
+                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+        }
+    };
+
+    inline auto normaliseOpt( std::string const &optName ) -> std::string {
+#ifdef CATCH_PLATFORM_WINDOWS
+        if( optName[0] == '/' )
+            return "-" + optName.substr( 1 );
+        else
+#endif
+            return optName;
+    }
+
+    class Opt : public ParserRefImpl<Opt> {
+    protected:
+        std::vector<std::string> m_optNames;
+
+    public:
+        template<typename LambdaT>
+        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
+
+        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
+
+        template<typename LambdaT>
+        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+        template<typename T>
+        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+        auto operator[]( std::string const &optName ) -> Opt & {
+            m_optNames.push_back( optName );
+            return *this;
+        }
+
+        auto getHelpColumns() const -> std::vector<HelpColumns> {
+            std::ostringstream oss;
+            bool first = true;
+            for( auto const &opt : m_optNames ) {
+                if (first)
+                    first = false;
+                else
+                    oss << ", ";
+                oss << opt;
+            }
+            if( !m_hint.empty() )
+                oss << " <" << m_hint << ">";
+            return { { oss.str(), m_description } };
+        }
+
+        auto isMatch( std::string const &optToken ) const -> bool {
+            auto normalisedToken = normaliseOpt( optToken );
+            for( auto const &name : m_optNames ) {
+                if( normaliseOpt( name ) == normalisedToken )
+                    return true;
+            }
+            return false;
+        }
+
+        using ParserBase::parse;
+
+        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+            auto validationResult = validate();
+            if( !validationResult )
+                return InternalParseResult( validationResult );
+
+            auto remainingTokens = tokens;
+            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
+                auto const &token = *remainingTokens;
+                if( isMatch(token.token ) ) {
+                    if( m_ref->isFlag() ) {
+                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
+                        auto result = flagRef->setFlag( true );
+                        if( !result )
+                            return InternalParseResult( result );
+                        if( result.value() == ParseResultType::ShortCircuitAll )
+                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+                    } else {
+                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+                        ++remainingTokens;
+                        if( !remainingTokens )
+                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+                        auto const &argToken = *remainingTokens;
+                        if( argToken.type != TokenType::Argument )
+                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+                        auto result = valueRef->setValue( argToken.token );
+                        if( !result )
+                            return InternalParseResult( result );
+                        if( result.value() == ParseResultType::ShortCircuitAll )
+                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+                    }
+                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+                }
+            }
+            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+        }
+
+        auto validate() const -> Result override {
+            if( m_optNames.empty() )
+                return Result::logicError( "No options supplied to Opt" );
+            for( auto const &name : m_optNames ) {
+                if( name.empty() )
+                    return Result::logicError( "Option name cannot be empty" );
+#ifdef CATCH_PLATFORM_WINDOWS
+                if( name[0] != '-' && name[0] != '/' )
+                    return Result::logicError( "Option name must begin with '-' or '/'" );
+#else
+                if( name[0] != '-' )
+                    return Result::logicError( "Option name must begin with '-'" );
+#endif
+            }
+            return ParserRefImpl::validate();
+        }
+    };
+
+    struct Help : Opt {
+        Help( bool &showHelpFlag )
+        :   Opt([&]( bool flag ) {
+                showHelpFlag = flag;
+                return ParserResult::ok( ParseResultType::ShortCircuitAll );
+            })
+        {
+            static_cast<Opt &>( *this )
+                    ("display usage information")
+                    ["-?"]["-h"]["--help"]
+                    .optional();
+        }
+    };
+
+    struct Parser : ParserBase {
+
+        mutable ExeName m_exeName;
+        std::vector<Opt> m_options;
+        std::vector<Arg> m_args;
+
+        auto operator|=( ExeName const &exeName ) -> Parser & {
+            m_exeName = exeName;
+            return *this;
+        }
+
+        auto operator|=( Arg const &arg ) -> Parser & {
+            m_args.push_back(arg);
+            return *this;
+        }
+
+        auto operator|=( Opt const &opt ) -> Parser & {
+            m_options.push_back(opt);
+            return *this;
+        }
+
+        auto operator|=( Parser const &other ) -> Parser & {
+            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
+            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
+            return *this;
+        }
+
+        template<typename T>
+        auto operator|( T const &other ) const -> Parser {
+            return Parser( *this ) |= other;
+        }
+
+        // Forward deprecated interface with '+' instead of '|'
+        template<typename T>
+        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
+        template<typename T>
+        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
+
+        auto getHelpColumns() const -> std::vector<HelpColumns> {
+            std::vector<HelpColumns> cols;
+            for (auto const &o : m_options) {
+                auto childCols = o.getHelpColumns();
+                cols.insert( cols.end(), childCols.begin(), childCols.end() );
+            }
+            return cols;
+        }
+
+        void writeToStream( std::ostream &os ) const {
+            if (!m_exeName.name().empty()) {
+                os << "usage:\n" << "  " << m_exeName.name() << " ";
+                bool required = true, first = true;
+                for( auto const &arg : m_args ) {
+                    if (first)
+                        first = false;
+                    else
+                        os << " ";
+                    if( arg.isOptional() && required ) {
+                        os << "[";
+                        required = false;
+                    }
+                    os << "<" << arg.hint() << ">";
+                    if( arg.cardinality() == 0 )
+                        os << " ... ";
+                }
+                if( !required )
+                    os << "]";
+                if( !m_options.empty() )
+                    os << " options";
+                os << "\n\nwhere options are:" << std::endl;
+            }
+
+            auto rows = getHelpColumns();
+            size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
+            size_t optWidth = 0;
+            for( auto const &cols : rows )
+                optWidth = (std::max)(optWidth, cols.left.size() + 2);
+
+            optWidth = (std::min)(optWidth, consoleWidth/2);
+
+            for( auto const &cols : rows ) {
+                auto row =
+                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
+                        TextFlow::Spacer(4) +
+                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
+                os << row << std::endl;
+            }
+        }
+
+        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
+            parser.writeToStream( os );
+            return os;
+        }
+
+        auto validate() const -> Result override {
+            for( auto const &opt : m_options ) {
+                auto result = opt.validate();
+                if( !result )
+                    return result;
+            }
+            for( auto const &arg : m_args ) {
+                auto result = arg.validate();
+                if( !result )
+                    return result;
+            }
+            return Result::ok();
+        }
+
+        using ParserBase::parse;
+
+        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
+
+            struct ParserInfo {
+                ParserBase const* parser = nullptr;
+                size_t count = 0;
+            };
+            const size_t totalParsers = m_options.size() + m_args.size();
+            assert( totalParsers < 512 );
+            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
+            ParserInfo parseInfos[512];
+
+            {
+                size_t i = 0;
+                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
+                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
+            }
+
+            m_exeName.set( exeName );
+
+            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+            while( result.value().remainingTokens() ) {
+                bool tokenParsed = false;
+
+                for( size_t i = 0; i < totalParsers; ++i ) {
+                    auto&  parseInfo = parseInfos[i];
+                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
+                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
+                        if (!result)
+                            return result;
+                        if (result.value().type() != ParseResultType::NoMatch) {
+                            tokenParsed = true;
+                            ++parseInfo.count;
+                            break;
+                        }
+                    }
+                }
+
+                if( result.value().type() == ParseResultType::ShortCircuitAll )
+                    return result;
+                if( !tokenParsed )
+                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
+            }
+            // !TBD Check missing required options
+            return result;
+        }
+    };
+
+    template<typename DerivedT>
+    template<typename T>
+    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
+        return Parser() | static_cast<DerivedT const &>( *this ) | other;
+    }
+} // namespace detail
+
+// A Combined parser
+using detail::Parser;
+
+// A parser for options
+using detail::Opt;
+
+// A parser for arguments
+using detail::Arg;
+
+// Wrapper for argc, argv from main()
+using detail::Args;
+
+// Specifies the name of the executable
+using detail::ExeName;
+
+// Convenience wrapper for option parser that specifies the help option
+using detail::Help;
+
+// enum of result types from a parse
+using detail::ParseResultType;
+
+// Result type for parser operation
+using detail::ParserResult;
+
+}} // namespace Catch::clara
+
+// end clara.hpp
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// Restore Clara's value for console width, if present
+#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+// end catch_clara.h
+namespace Catch {
+
+    clara::Parser makeCommandLineParser( ConfigData& config );
+
+} // end namespace Catch
+
+// end catch_commandline.h
+#include <fstream>
+#include <ctime>
+
+namespace Catch {
+
+    clara::Parser makeCommandLineParser( ConfigData& config ) {
+
+        using namespace clara;
+
+        auto const setWarning = [&]( std::string const& warning ) {
+                auto warningSet = [&]() {
+                    if( warning == "NoAssertions" )
+                        return WarnAbout::NoAssertions;
+
+                    if ( warning == "NoTests" )
+                        return WarnAbout::NoTests;
+
+                    return WarnAbout::Nothing;
+                }();
+
+                if (warningSet == WarnAbout::Nothing)
+                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
+                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
+                std::ifstream f( filename.c_str() );
+                if( !f.is_open() )
+                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
+
+                std::string line;
+                while( std::getline( f, line ) ) {
+                    line = trim(line);
+                    if( !line.empty() && !startsWith( line, '#' ) ) {
+                        if( !startsWith( line, '"' ) )
+                            line = '"' + line + '"';
+                        config.testsOrTags.push_back( line );
+                        config.testsOrTags.emplace_back( "," );
+                    }
+                }
+                //Remove comma in the end
+                if(!config.testsOrTags.empty())
+                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
+
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setTestOrder = [&]( std::string const& order ) {
+                if( startsWith( "declared", order ) )
+                    config.runOrder = RunTests::InDeclarationOrder;
+                else if( startsWith( "lexical", order ) )
+                    config.runOrder = RunTests::InLexicographicalOrder;
+                else if( startsWith( "random", order ) )
+                    config.runOrder = RunTests::InRandomOrder;
+                else
+                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setRngSeed = [&]( std::string const& seed ) {
+                if( seed != "time" )
+                    return clara::detail::convertInto( seed, config.rngSeed );
+                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setColourUsage = [&]( std::string const& useColour ) {
+                    auto mode = toLower( useColour );
+
+                    if( mode == "yes" )
+                        config.useColour = UseColour::Yes;
+                    else if( mode == "no" )
+                        config.useColour = UseColour::No;
+                    else if( mode == "auto" )
+                        config.useColour = UseColour::Auto;
+                    else
+                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
+                auto keypressLc = toLower( keypress );
+                if (keypressLc == "never")
+                    config.waitForKeypress = WaitForKeypress::Never;
+                else if( keypressLc == "start" )
+                    config.waitForKeypress = WaitForKeypress::BeforeStart;
+                else if( keypressLc == "exit" )
+                    config.waitForKeypress = WaitForKeypress::BeforeExit;
+                else if( keypressLc == "both" )
+                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+                else
+                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
+            return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setVerbosity = [&]( std::string const& verbosity ) {
+            auto lcVerbosity = toLower( verbosity );
+            if( lcVerbosity == "quiet" )
+                config.verbosity = Verbosity::Quiet;
+            else if( lcVerbosity == "normal" )
+                config.verbosity = Verbosity::Normal;
+            else if( lcVerbosity == "high" )
+                config.verbosity = Verbosity::High;
+            else
+                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+        auto const setReporter = [&]( std::string const& reporter ) {
+            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+
+            auto lcReporter = toLower( reporter );
+            auto result = factories.find( lcReporter );
+
+            if( factories.end() != result )
+                config.reporterName = lcReporter;
+            else
+                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+
+        auto cli
+            = ExeName( config.processName )
+            | Help( config.showHelp )
+            | Opt( config.listTests )
+                ["-l"]["--list-tests"]
+                ( "list all/matching test cases" )
+            | Opt( config.listTags )
+                ["-t"]["--list-tags"]
+                ( "list all/matching tags" )
+            | Opt( config.showSuccessfulTests )
+                ["-s"]["--success"]
+                ( "include successful tests in output" )
+            | Opt( config.shouldDebugBreak )
+                ["-b"]["--break"]
+                ( "break into debugger on failure" )
+            | Opt( config.noThrow )
+                ["-e"]["--nothrow"]
+                ( "skip exception tests" )
+            | Opt( config.showInvisibles )
+                ["-i"]["--invisibles"]
+                ( "show invisibles (tabs, newlines)" )
+            | Opt( config.outputFilename, "filename" )
+                ["-o"]["--out"]
+                ( "output filename" )
+            | Opt( setReporter, "name" )
+                ["-r"]["--reporter"]
+                ( "reporter to use (defaults to console)" )
+            | Opt( config.name, "name" )
+                ["-n"]["--name"]
+                ( "suite name" )
+            | Opt( [&]( bool ){ config.abortAfter = 1; } )
+                ["-a"]["--abort"]
+                ( "abort at first failure" )
+            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
+                ["-x"]["--abortx"]
+                ( "abort after x failures" )
+            | Opt( setWarning, "warning name" )
+                ["-w"]["--warn"]
+                ( "enable warnings" )
+            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
+                ["-d"]["--durations"]
+                ( "show test durations" )
+            | Opt( loadTestNamesFromFile, "filename" )
+                ["-f"]["--input-file"]
+                ( "load test names to run from a file" )
+            | Opt( config.filenamesAsTags )
+                ["-#"]["--filenames-as-tags"]
+                ( "adds a tag for the filename" )
+            | Opt( config.sectionsToRun, "section name" )
+                ["-c"]["--section"]
+                ( "specify section to run" )
+            | Opt( setVerbosity, "quiet|normal|high" )
+                ["-v"]["--verbosity"]
+                ( "set output verbosity" )
+            | Opt( config.listTestNamesOnly )
+                ["--list-test-names-only"]
+                ( "list all/matching test cases names only" )
+            | Opt( config.listReporters )
+                ["--list-reporters"]
+                ( "list all reporters" )
+            | Opt( setTestOrder, "decl|lex|rand" )
+                ["--order"]
+                ( "test case order (defaults to decl)" )
+            | Opt( setRngSeed, "'time'|number" )
+                ["--rng-seed"]
+                ( "set a specific seed for random numbers" )
+            | Opt( setColourUsage, "yes|no" )
+                ["--use-colour"]
+                ( "should output be colourised" )
+            | Opt( config.libIdentify )
+                ["--libidentify"]
+                ( "report name and version according to libidentify standard" )
+            | Opt( setWaitForKeypress, "never|start|exit|both" )
+                ["--wait-for-keypress"]
+                ( "waits for a keypress before exiting" )
+            | Opt( config.benchmarkSamples, "samples" )
+                ["--benchmark-samples"]
+                ( "number of samples to collect (default: 100)" )
+            | Opt( config.benchmarkResamples, "resamples" )
+                ["--benchmark-resamples"]
+                ( "number of resamples for the bootstrap (default: 100000)" )
+            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
+                ["--benchmark-confidence-interval"]
+                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
+            | Opt( config.benchmarkNoAnalysis )
+                ["--benchmark-no-analysis"]
+                ( "perform only measurements; do not perform any analysis" )
+            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
+                ["--benchmark-warmup-time"]
+                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
+            | Arg( config.testsOrTags, "test name|pattern|tags" )
+                ( "which test or tests to use" );
+
+        return cli;
+    }
+
+} // end namespace Catch
+// end catch_commandline.cpp
+// start catch_common.cpp
+
+#include <cstring>
+#include <ostream>
+
+namespace Catch {
+
+    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
+        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
+    }
+    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
+        // We can assume that the same file will usually have the same pointer.
+        // Thus, if the pointers are the same, there is no point in calling the strcmp
+        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
+    }
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+#ifndef __GNUG__
+        os << info.file << '(' << info.line << ')';
+#else
+        os << info.file << ':' << info.line;
+#endif
+        return os;
+    }
+
+    std::string StreamEndStop::operator+() const {
+        return std::string();
+    }
+
+    NonCopyable::NonCopyable() = default;
+    NonCopyable::~NonCopyable() = default;
+
+}
+// end catch_common.cpp
+// start catch_config.cpp
+
+namespace Catch {
+
+    Config::Config( ConfigData const& data )
+    :   m_data( data ),
+        m_stream( openStream() )
+    {
+        // We need to trim filter specs to avoid trouble with superfluous
+        // whitespace (esp. important for bdd macros, as those are manually
+        // aligned with whitespace).
+
+        for (auto& elem : m_data.testsOrTags) {
+            elem = trim(elem);
+        }
+        for (auto& elem : m_data.sectionsToRun) {
+            elem = trim(elem);
+        }
+
+        TestSpecParser parser(ITagAliasRegistry::get());
+        if (!m_data.testsOrTags.empty()) {
+            m_hasTestFilters = true;
+            for (auto const& testOrTags : m_data.testsOrTags) {
+                parser.parse(testOrTags);
+            }
+        }
+        m_testSpec = parser.testSpec();
+    }
+
+    std::string const& Config::getFilename() const {
+        return m_data.outputFilename ;
+    }
+
+    bool Config::listTests() const          { return m_data.listTests; }
+    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
+    bool Config::listTags() const           { return m_data.listTags; }
+    bool Config::listReporters() const      { return m_data.listReporters; }
+
+    std::string Config::getProcessName() const { return m_data.processName; }
+    std::string const& Config::getReporterName() const { return m_data.reporterName; }
+
+    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
+    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
+
+    TestSpec const& Config::testSpec() const { return m_testSpec; }
+    bool Config::hasTestFilters() const { return m_hasTestFilters; }
+
+    bool Config::showHelp() const { return m_data.showHelp; }
+
+    // IConfig interface
+    bool Config::allowThrows() const                   { return !m_data.noThrow; }
+    std::ostream& Config::stream() const               { return m_stream->stream(); }
+    std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
+    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
+    bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
+    bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
+    ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
+    RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
+    unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
+    UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
+    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
+    int Config::abortAfter() const                     { return m_data.abortAfter; }
+    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
+    Verbosity Config::verbosity() const                { return m_data.verbosity; }
+
+    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
+    int Config::benchmarkSamples() const                          { return m_data.benchmarkSamples; }
+    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
+    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
+    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+
+    IStream const* Config::openStream() {
+        return Catch::makeStream(m_data.outputFilename);
+    }
+
+} // end namespace Catch
+// end catch_config.cpp
+// start catch_console_colour.cpp
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+// start catch_errno_guard.h
+
+namespace Catch {
+
+    class ErrnoGuard {
+    public:
+        ErrnoGuard();
+        ~ErrnoGuard();
+    private:
+        int m_oldErrno;
+    };
+
+}
+
+// end catch_errno_guard.h
+#include <sstream>
+
+namespace Catch {
+    namespace {
+
+        struct IColourImpl {
+            virtual ~IColourImpl() = default;
+            virtual void use( Colour::Code _colourCode ) = 0;
+        };
+
+        struct NoColourImpl : IColourImpl {
+            void use( Colour::Code ) override {}
+
+            static IColourImpl* instance() {
+                static NoColourImpl s_instance;
+                return &s_instance;
+            }
+        };
+
+    } // anon namespace
+} // namespace Catch
+
+#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
+#   ifdef CATCH_PLATFORM_WINDOWS
+#       define CATCH_CONFIG_COLOUR_WINDOWS
+#   else
+#       define CATCH_CONFIG_COLOUR_ANSI
+#   endif
+#endif
+
+#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
+
+namespace Catch {
+namespace {
+
+    class Win32ColourImpl : public IColourImpl {
+    public:
+        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
+        {
+            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
+            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
+            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
+        }
+
+        void use( Colour::Code _colourCode ) override {
+            switch( _colourCode ) {
+                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
+                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
+                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
+                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
+                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+                case Colour::Grey:      return setTextAttribute( 0 );
+
+                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
+                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
+
+                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+
+                default:
+                    CATCH_ERROR( "Unknown colour requested" );
+            }
+        }
+
+    private:
+        void setTextAttribute( WORD _textAttribute ) {
+            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
+        }
+        HANDLE stdoutHandle;
+        WORD originalForegroundAttributes;
+        WORD originalBackgroundAttributes;
+    };
+
+    IColourImpl* platformColourInstance() {
+        static Win32ColourImpl s_instance;
+
+        IConfigPtr config = getCurrentContext().getConfig();
+        UseColour::YesOrNo colourMode = config
+            ? config->useColour()
+            : UseColour::Auto;
+        if( colourMode == UseColour::Auto )
+            colourMode = UseColour::Yes;
+        return colourMode == UseColour::Yes
+            ? &s_instance
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
+
+#include <unistd.h>
+
+namespace Catch {
+namespace {
+
+    // use POSIX/ ANSI console terminal codes
+    // Thanks to Adam Strzelecki for original contribution
+    // (http://github.com/nanoant)
+    // https://github.com/philsquared/Catch/pull/131
+    class PosixColourImpl : public IColourImpl {
+    public:
+        void use( Colour::Code _colourCode ) override {
+            switch( _colourCode ) {
+                case Colour::None:
+                case Colour::White:     return setColour( "[0m" );
+                case Colour::Red:       return setColour( "[0;31m" );
+                case Colour::Green:     return setColour( "[0;32m" );
+                case Colour::Blue:      return setColour( "[0;34m" );
+                case Colour::Cyan:      return setColour( "[0;36m" );
+                case Colour::Yellow:    return setColour( "[0;33m" );
+                case Colour::Grey:      return setColour( "[1;30m" );
+
+                case Colour::LightGrey:     return setColour( "[0;37m" );
+                case Colour::BrightRed:     return setColour( "[1;31m" );
+                case Colour::BrightGreen:   return setColour( "[1;32m" );
+                case Colour::BrightWhite:   return setColour( "[1;37m" );
+                case Colour::BrightYellow:  return setColour( "[1;33m" );
+
+                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
+            }
+        }
+        static IColourImpl* instance() {
+            static PosixColourImpl s_instance;
+            return &s_instance;
+        }
+
+    private:
+        void setColour( const char* _escapeCode ) {
+            getCurrentContext().getConfig()->stream()
+                << '\033' << _escapeCode;
+        }
+    };
+
+    bool useColourOnPlatform() {
+        return
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+            !isDebuggerActive() &&
+#endif
+#if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
+            isatty(STDOUT_FILENO)
+#else
+            false
+#endif
+            ;
+    }
+    IColourImpl* platformColourInstance() {
+        ErrnoGuard guard;
+        IConfigPtr config = getCurrentContext().getConfig();
+        UseColour::YesOrNo colourMode = config
+            ? config->useColour()
+            : UseColour::Auto;
+        if( colourMode == UseColour::Auto )
+            colourMode = useColourOnPlatform()
+                ? UseColour::Yes
+                : UseColour::No;
+        return colourMode == UseColour::Yes
+            ? PosixColourImpl::instance()
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#else  // not Windows or ANSI ///////////////////////////////////////////////
+
+namespace Catch {
+
+    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
+
+} // end namespace Catch
+
+#endif // Windows/ ANSI/ None
+
+namespace Catch {
+
+    Colour::Colour( Code _colourCode ) { use( _colourCode ); }
+    Colour::Colour( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.m_moved = true;
+    }
+    Colour& Colour::operator=( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.m_moved  = true;
+        return *this;
+    }
+
+    Colour::~Colour(){ if( !m_moved ) use( None ); }
+
+    void Colour::use( Code _colourCode ) {
+        static IColourImpl* impl = platformColourInstance();
+        // Strictly speaking, this cannot possibly happen.
+        // However, under some conditions it does happen (see #1626),
+        // and this change is small enough that we can let practicality
+        // triumph over purity in this case.
+        if (impl != nullptr) {
+            impl->use( _colourCode );
+        }
+    }
+
+    std::ostream& operator << ( std::ostream& os, Colour const& ) {
+        return os;
+    }
+
+} // end namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+// end catch_console_colour.cpp
+// start catch_context.cpp
+
+namespace Catch {
+
+    class Context : public IMutableContext, NonCopyable {
+
+    public: // IContext
+        IResultCapture* getResultCapture() override {
+            return m_resultCapture;
+        }
+        IRunner* getRunner() override {
+            return m_runner;
+        }
+
+        IConfigPtr const& getConfig() const override {
+            return m_config;
+        }
+
+        ~Context() override;
+
+    public: // IMutableContext
+        void setResultCapture( IResultCapture* resultCapture ) override {
+            m_resultCapture = resultCapture;
+        }
+        void setRunner( IRunner* runner ) override {
+            m_runner = runner;
+        }
+        void setConfig( IConfigPtr const& config ) override {
+            m_config = config;
+        }
+
+        friend IMutableContext& getCurrentMutableContext();
+
+    private:
+        IConfigPtr m_config;
+        IRunner* m_runner = nullptr;
+        IResultCapture* m_resultCapture = nullptr;
+    };
+
+    IMutableContext *IMutableContext::currentContext = nullptr;
+
+    void IMutableContext::createContext()
+    {
+        currentContext = new Context();
+    }
+
+    void cleanUpContext() {
+        delete IMutableContext::currentContext;
+        IMutableContext::currentContext = nullptr;
+    }
+    IContext::~IContext() = default;
+    IMutableContext::~IMutableContext() = default;
+    Context::~Context() = default;
+
+    SimplePcg32& rng() {
+        static SimplePcg32 s_rng;
+        return s_rng;
+    }
+
+}
+// end catch_context.cpp
+// start catch_debug_console.cpp
+
+// start catch_debug_console.h
+
+#include <string>
+
+namespace Catch {
+    void writeToDebugConsole( std::string const& text );
+}
+
+// end catch_debug_console.h
+#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#include <android/log.h>
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
+        }
+    }
+
+#elif defined(CATCH_PLATFORM_WINDOWS)
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            ::OutputDebugStringA( text.c_str() );
+        }
+    }
+
+#else
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            // !TBD: Need a version for Mac/ XCode and other IDEs
+            Catch::cout() << text;
+        }
+    }
+
+#endif // Platform
+// end catch_debug_console.cpp
+// start catch_debugger.cpp
+
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+
+#  include <assert.h>
+#  include <stdbool.h>
+#  include <sys/types.h>
+#  include <unistd.h>
+#  include <cstddef>
+#  include <ostream>
+
+#ifdef __apple_build_version__
+    // These headers will only compile with AppleClang (XCode)
+    // For other compilers (Clang, GCC, ... ) we need to exclude them
+#  include <sys/sysctl.h>
+#endif
+
+    namespace Catch {
+        #ifdef __apple_build_version__
+        // The following function is taken directly from the following technical note:
+        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
+
+        // Returns true if the current process is being debugged (either
+        // running under the debugger or has a debugger attached post facto).
+        bool isDebuggerActive(){
+            int                 mib[4];
+            struct kinfo_proc   info;
+            std::size_t         size;
+
+            // Initialize the flags so that, if sysctl fails for some bizarre
+            // reason, we get a predictable result.
+
+            info.kp_proc.p_flag = 0;
+
+            // Initialize mib, which tells sysctl the info we want, in this case
+            // we're looking for information about a specific process ID.
+
+            mib[0] = CTL_KERN;
+            mib[1] = KERN_PROC;
+            mib[2] = KERN_PROC_PID;
+            mib[3] = getpid();
+
+            // Call sysctl.
+
+            size = sizeof(info);
+            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
+                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
+                return false;
+            }
+
+            // We're being debugged if the P_TRACED flag is set.
+
+            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+        }
+        #else
+        bool isDebuggerActive() {
+            // We need to find another way to determine this for non-appleclang compilers on macOS
+            return false;
+        }
+        #endif
+    } // namespace Catch
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    #include <fstream>
+    #include <string>
+
+    namespace Catch{
+        // The standard POSIX way of detecting a debugger is to attempt to
+        // ptrace() the process, but this needs to be done from a child and not
+        // this process itself to still allow attaching to this process later
+        // if wanted, so is rather heavy. Under Linux we have the PID of the
+        // "debugger" (which doesn't need to be gdb, of course, it could also
+        // be strace, for example) in /proc/$PID/status, so just get it from
+        // there instead.
+        bool isDebuggerActive(){
+            // Libstdc++ has a bug, where std::ifstream sets errno to 0
+            // This way our users can properly assert over errno values
+            ErrnoGuard guard;
+            std::ifstream in("/proc/self/status");
+            for( std::string line; std::getline(in, line); ) {
+                static const int PREFIX_LEN = 11;
+                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
+                    // We're traced if the PID is not 0 and no other PID starts
+                    // with 0 digit, so it's enough to check for just a single
+                    // character.
+                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
+                }
+            }
+
+            return false;
+        }
+    } // namespace Catch
+#elif defined(_MSC_VER)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#else
+    namespace Catch {
+       bool isDebuggerActive() { return false; }
+    }
+#endif // Platform
+// end catch_debugger.cpp
+// start catch_decomposer.cpp
+
+namespace Catch {
+
+    ITransientExpression::~ITransientExpression() = default;
+
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
+        if( lhs.size() + rhs.size() < 40 &&
+                lhs.find('\n') == std::string::npos &&
+                rhs.find('\n') == std::string::npos )
+            os << lhs << " " << op << " " << rhs;
+        else
+            os << lhs << "\n" << op << "\n" << rhs;
+    }
+}
+// end catch_decomposer.cpp
+// start catch_enforce.cpp
+
+#include <stdexcept>
+
+namespace Catch {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
+    [[noreturn]]
+    void throw_exception(std::exception const& e) {
+        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
+                      << "The message was: " << e.what() << '\n';
+        std::terminate();
+    }
+#endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg) {
+        throw_exception(std::logic_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg) {
+        throw_exception(std::domain_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg) {
+        throw_exception(std::runtime_error(msg));
+    }
+
+} // namespace Catch;
+// end catch_enforce.cpp
+// start catch_enum_values_registry.cpp
+// start catch_enum_values_registry.h
+
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    namespace Detail {
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+
+        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
+
+            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
+
+            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
+        };
+
+        std::vector<StringRef> parseEnums( StringRef enums );
+
+    } // Detail
+
+} // Catch
+
+// end catch_enum_values_registry.h
+
+#include <map>
+#include <cassert>
+
+namespace Catch {
+
+    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
+
+    namespace Detail {
+
+        namespace {
+            // Extracts the actual name part of an enum instance
+            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
+            StringRef extractInstanceName(StringRef enumInstance) {
+                // Find last occurence of ":"
+                size_t name_start = enumInstance.size();
+                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
+                    --name_start;
+                }
+                return enumInstance.substr(name_start, enumInstance.size() - name_start);
+            }
+        }
+
+        std::vector<StringRef> parseEnums( StringRef enums ) {
+            auto enumValues = splitStringRef( enums, ',' );
+            std::vector<StringRef> parsed;
+            parsed.reserve( enumValues.size() );
+            for( auto const& enumValue : enumValues ) {
+                parsed.push_back(trim(extractInstanceName(enumValue)));
+            }
+            return parsed;
+        }
+
+        EnumInfo::~EnumInfo() {}
+
+        StringRef EnumInfo::lookup( int value ) const {
+            for( auto const& valueToName : m_values ) {
+                if( valueToName.first == value )
+                    return valueToName.second;
+            }
+            return "{** unexpected enum value **}"_sr;
+        }
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
+            enumInfo->m_name = enumName;
+            enumInfo->m_values.reserve( values.size() );
+
+            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
+            assert( valueNames.size() == values.size() );
+            std::size_t i = 0;
+            for( auto value : values )
+                enumInfo->m_values.emplace_back(value, valueNames[i++]);
+
+            return enumInfo;
+        }
+
+        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
+            return *m_enumInfos.back();
+        }
+
+    } // Detail
+} // Catch
+
+// end catch_enum_values_registry.cpp
+// start catch_errno_guard.cpp
+
+#include <cerrno>
+
+namespace Catch {
+        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
+        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
+}
+// end catch_errno_guard.cpp
+// start catch_exception_translator_registry.cpp
+
+// start catch_exception_translator_registry.h
+
+#include <vector>
+#include <string>
+#include <memory>
+
+namespace Catch {
+
+    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+    public:
+        ~ExceptionTranslatorRegistry();
+        virtual void registerTranslator( const IExceptionTranslator* translator );
+        std::string translateActiveException() const override;
+        std::string tryTranslators() const;
+
+    private:
+        std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
+    };
+}
+
+// end catch_exception_translator_registry.h
+#ifdef __OBJC__
+#import "Foundation/Foundation.h"
+#endif
+
+namespace Catch {
+
+    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
+    }
+
+    void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
+        m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
+    }
+
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        try {
+#ifdef __OBJC__
+            // In Objective-C try objective-c exceptions first
+            @try {
+                return tryTranslators();
+            }
+            @catch (NSException *exception) {
+                return Catch::Detail::stringify( [exception description] );
+            }
+#else
+            // Compiling a mixed mode project with MSVC means that CLR
+            // exceptions will be caught in (...) as well. However, these
+            // do not fill-in std::current_exception and thus lead to crash
+            // when attempting rethrow.
+            // /EHa switch also causes structured exceptions to be caught
+            // here, but they fill-in current_exception properly, so
+            // at worst the output should be a little weird, instead of
+            // causing a crash.
+            if (std::current_exception() == nullptr) {
+                return "Non C++ exception. Possibly a CLR exception.";
+            }
+            return tryTranslators();
+#endif
+        }
+        catch( TestFailureException& ) {
+            std::rethrow_exception(std::current_exception());
+        }
+        catch( std::exception& ex ) {
+            return ex.what();
+        }
+        catch( std::string& msg ) {
+            return msg;
+        }
+        catch( const char* msg ) {
+            return msg;
+        }
+        catch(...) {
+            return "Unknown exception";
+        }
+    }
+
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        if (m_translators.empty()) {
+            std::rethrow_exception(std::current_exception());
+        } else {
+            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
+        }
+    }
+
+#else // ^^ Exceptions are enabled // Exceptions are disabled vv
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+    }
+
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+    }
+#endif
+
+}
+// end catch_exception_translator_registry.cpp
+// start catch_fatal_condition.cpp
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace {
+    // Report the error condition
+    void reportFatal( char const * const message ) {
+        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
+    }
+}
+
+#endif // signals/SEH handling
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+    struct SignalDefs { DWORD id; const char* name; };
+
+    // There is no 1-1 mapping between signals and windows exceptions.
+    // Windows can easily distinguish between SO and SigSegV,
+    // but SigInt, SigTerm, etc are handled differently.
+    static SignalDefs signalDefs[] = {
+        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
+        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
+        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
+        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
+    };
+
+    LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
+        for (auto const& def : signalDefs) {
+            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
+                reportFatal(def.name);
+            }
+        }
+        // If its not an exception we care about, pass it along.
+        // This stops us from eating debugger breaks etc.
+        return EXCEPTION_CONTINUE_SEARCH;
+    }
+
+    FatalConditionHandler::FatalConditionHandler() {
+        isSet = true;
+        // 32k seems enough for Catch to handle stack overflow,
+        // but the value was found experimentally, so there is no strong guarantee
+        guaranteeSize = 32 * 1024;
+        exceptionHandlerHandle = nullptr;
+        // Register as first handler in current chain
+        exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+        // Pass in guarantee size to be filled
+        SetThreadStackGuarantee(&guaranteeSize);
+    }
+
+    void FatalConditionHandler::reset() {
+        if (isSet) {
+            RemoveVectoredExceptionHandler(exceptionHandlerHandle);
+            SetThreadStackGuarantee(&guaranteeSize);
+            exceptionHandlerHandle = nullptr;
+            isSet = false;
+        }
+    }
+
+    FatalConditionHandler::~FatalConditionHandler() {
+        reset();
+    }
+
+bool FatalConditionHandler::isSet = false;
+ULONG FatalConditionHandler::guaranteeSize = 0;
+PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
+
+} // namespace Catch
+
+#elif defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace Catch {
+
+    struct SignalDefs {
+        int id;
+        const char* name;
+    };
+
+    // 32kb for the alternate stack seems to be sufficient. However, this value
+    // is experimentally determined, so that's not guaranteed.
+    static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
+
+    static SignalDefs signalDefs[] = {
+        { SIGINT,  "SIGINT - Terminal interrupt signal" },
+        { SIGILL,  "SIGILL - Illegal instruction signal" },
+        { SIGFPE,  "SIGFPE - Floating point error signal" },
+        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+        { SIGTERM, "SIGTERM - Termination request signal" },
+        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+    };
+
+    void FatalConditionHandler::handleSignal( int sig ) {
+        char const * name = "<unknown signal>";
+        for (auto const& def : signalDefs) {
+            if (sig == def.id) {
+                name = def.name;
+                break;
+            }
+        }
+        reset();
+        reportFatal(name);
+        raise( sig );
+    }
+
+    FatalConditionHandler::FatalConditionHandler() {
+        isSet = true;
+        stack_t sigStack;
+        sigStack.ss_sp = altStackMem;
+        sigStack.ss_size = sigStackSize;
+        sigStack.ss_flags = 0;
+        sigaltstack(&sigStack, &oldSigStack);
+        struct sigaction sa = { };
+
+        sa.sa_handler = handleSignal;
+        sa.sa_flags = SA_ONSTACK;
+        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
+            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
+        }
+    }
+
+    FatalConditionHandler::~FatalConditionHandler() {
+        reset();
+    }
+
+    void FatalConditionHandler::reset() {
+        if( isSet ) {
+            // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
+            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
+                sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
+            }
+            // Return the old stack
+            sigaltstack(&oldSigStack, nullptr);
+            isSet = false;
+        }
+    }
+
+    bool FatalConditionHandler::isSet = false;
+    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
+    stack_t FatalConditionHandler::oldSigStack = {};
+    char FatalConditionHandler::altStackMem[sigStackSize] = {};
+
+} // namespace Catch
+
+#else
+
+namespace Catch {
+    void FatalConditionHandler::reset() {}
+}
+
+#endif // signals/SEH handling
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+// end catch_fatal_condition.cpp
+// start catch_generators.cpp
+
+#include <limits>
+#include <set>
+
+namespace Catch {
+
+IGeneratorTracker::~IGeneratorTracker() {}
+
+const char* GeneratorException::what() const noexcept {
+    return m_msg;
+}
+
+namespace Generators {
+
+    GeneratorUntypedBase::~GeneratorUntypedBase() {}
+
+    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        return getResultCapture().acquireGeneratorTracker( lineInfo );
+    }
+
+} // namespace Generators
+} // namespace Catch
+// end catch_generators.cpp
+// start catch_interfaces_capture.cpp
+
+namespace Catch {
+    IResultCapture::~IResultCapture() = default;
+}
+// end catch_interfaces_capture.cpp
+// start catch_interfaces_config.cpp
+
+namespace Catch {
+    IConfig::~IConfig() = default;
+}
+// end catch_interfaces_config.cpp
+// start catch_interfaces_exception.cpp
+
+namespace Catch {
+    IExceptionTranslator::~IExceptionTranslator() = default;
+    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
+}
+// end catch_interfaces_exception.cpp
+// start catch_interfaces_registry_hub.cpp
+
+namespace Catch {
+    IRegistryHub::~IRegistryHub() = default;
+    IMutableRegistryHub::~IMutableRegistryHub() = default;
+}
+// end catch_interfaces_registry_hub.cpp
+// start catch_interfaces_reporter.cpp
+
+// start catch_reporter_listening.h
+
+namespace Catch {
+
+    class ListeningReporter : public IStreamingReporter {
+        using Reporters = std::vector<IStreamingReporterPtr>;
+        Reporters m_listeners;
+        IStreamingReporterPtr m_reporter = nullptr;
+        ReporterPreferences m_preferences;
+
+    public:
+        ListeningReporter();
+
+        void addListener( IStreamingReporterPtr&& listener );
+        void addReporter( IStreamingReporterPtr&& reporter );
+
+    public: // IStreamingReporter
+
+        ReporterPreferences getPreferences() const override;
+
+        void noMatchingTestCases( std::string const& spec ) override;
+
+        void reportInvalidArguments(std::string const&arg) override;
+
+        static std::set<Verbosity> getSupportedVerbosities();
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void testRunStarting( TestRunInfo const& testRunInfo ) override;
+        void testGroupStarting( GroupInfo const& groupInfo ) override;
+        void testCaseStarting( TestCaseInfo const& testInfo ) override;
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+        void assertionStarting( AssertionInfo const& assertionInfo ) override;
+
+        // The return value indicates if the messages buffer should be cleared:
+        bool assertionEnded( AssertionStats const& assertionStats ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
+        void testRunEnded( TestRunStats const& testRunStats ) override;
+
+        void skipTest( TestCaseInfo const& testInfo ) override;
+        bool isMulti() const override;
+
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_listening.h
+namespace Catch {
+
+    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
+    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
+
+    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
+    :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
+
+    std::ostream& ReporterConfig::stream() const { return *m_stream; }
+    IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
+
+    TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
+
+    GroupInfo::GroupInfo(  std::string const& _name,
+                           std::size_t _groupIndex,
+                           std::size_t _groupsCount )
+    :   name( _name ),
+        groupIndex( _groupIndex ),
+        groupsCounts( _groupsCount )
+    {}
+
+     AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
+                                     std::vector<MessageInfo> const& _infoMessages,
+                                     Totals const& _totals )
+    :   assertionResult( _assertionResult ),
+        infoMessages( _infoMessages ),
+        totals( _totals )
+    {
+        assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
+
+        if( assertionResult.hasMessage() ) {
+            // Copy message into messages list.
+            // !TBD This should have been done earlier, somewhere
+            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+            builder << assertionResult.getMessage();
+            builder.m_info.message = builder.m_stream.str();
+
+            infoMessages.push_back( builder.m_info );
+        }
+    }
+
+     AssertionStats::~AssertionStats() = default;
+
+    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
+                                 Counts const& _assertions,
+                                 double _durationInSeconds,
+                                 bool _missingAssertions )
+    :   sectionInfo( _sectionInfo ),
+        assertions( _assertions ),
+        durationInSeconds( _durationInSeconds ),
+        missingAssertions( _missingAssertions )
+    {}
+
+    SectionStats::~SectionStats() = default;
+
+    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
+                                   Totals const& _totals,
+                                   std::string const& _stdOut,
+                                   std::string const& _stdErr,
+                                   bool _aborting )
+    : testInfo( _testInfo ),
+        totals( _totals ),
+        stdOut( _stdOut ),
+        stdErr( _stdErr ),
+        aborting( _aborting )
+    {}
+
+    TestCaseStats::~TestCaseStats() = default;
+
+    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
+                                    Totals const& _totals,
+                                    bool _aborting )
+    :   groupInfo( _groupInfo ),
+        totals( _totals ),
+        aborting( _aborting )
+    {}
+
+    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
+    :   groupInfo( _groupInfo ),
+        aborting( false )
+    {}
+
+    TestGroupStats::~TestGroupStats() = default;
+
+    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
+                    Totals const& _totals,
+                    bool _aborting )
+    :   runInfo( _runInfo ),
+        totals( _totals ),
+        aborting( _aborting )
+    {}
+
+    TestRunStats::~TestRunStats() = default;
+
+    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
+    bool IStreamingReporter::isMulti() const { return false; }
+
+    IReporterFactory::~IReporterFactory() = default;
+    IReporterRegistry::~IReporterRegistry() = default;
+
+} // end namespace Catch
+// end catch_interfaces_reporter.cpp
+// start catch_interfaces_runner.cpp
+
+namespace Catch {
+    IRunner::~IRunner() = default;
+}
+// end catch_interfaces_runner.cpp
+// start catch_interfaces_testcase.cpp
+
+namespace Catch {
+    ITestInvoker::~ITestInvoker() = default;
+    ITestCaseRegistry::~ITestCaseRegistry() = default;
+}
+// end catch_interfaces_testcase.cpp
+// start catch_leak_detector.cpp
+
+#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+#include <crtdbg.h>
+
+namespace Catch {
+
+    LeakDetector::LeakDetector() {
+        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flag |= _CRTDBG_LEAK_CHECK_DF;
+        flag |= _CRTDBG_ALLOC_MEM_DF;
+        _CrtSetDbgFlag(flag);
+        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+        // Change this to leaking allocation's number to break there
+        _CrtSetBreakAlloc(-1);
+    }
+}
+
+#else
+
+    Catch::LeakDetector::LeakDetector() {}
+
+#endif
+
+Catch::LeakDetector::~LeakDetector() {
+    Catch::cleanUp();
+}
+// end catch_leak_detector.cpp
+// start catch_list.cpp
+
+// start catch_list.h
+
+#include <set>
+
+namespace Catch {
+
+    std::size_t listTests( Config const& config );
+
+    std::size_t listTestsNamesOnly( Config const& config );
+
+    struct TagInfo {
+        void add( std::string const& spelling );
+        std::string all() const;
+
+        std::set<std::string> spellings;
+        std::size_t count = 0;
+    };
+
+    std::size_t listTags( Config const& config );
+
+    std::size_t listReporters();
+
+    Option<std::size_t> list( std::shared_ptr<Config> const& config );
+
+} // end namespace Catch
+
+// end catch_list.h
+// start catch_text.h
+
+namespace Catch {
+    using namespace clara::TextFlow;
+}
+
+// end catch_text.h
+#include <limits>
+#include <algorithm>
+#include <iomanip>
+
+namespace Catch {
+
+    std::size_t listTests( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        if( config.hasTestFilters() )
+            Catch::cout() << "Matching test cases:\n";
+        else {
+            Catch::cout() << "All available test cases:\n";
+        }
+
+        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCaseInfo : matchedTestCases ) {
+            Colour::Code colour = testCaseInfo.isHidden()
+                ? Colour::SecondaryText
+                : Colour::None;
+            Colour colourGuard( colour );
+
+            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
+            if( config.verbosity() >= Verbosity::High ) {
+                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
+                std::string description = testCaseInfo.description;
+                if( description.empty() )
+                    description = "(NO DESCRIPTION)";
+                Catch::cout() << Column( description ).indent(4) << std::endl;
+            }
+            if( !testCaseInfo.tags.empty() )
+                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
+        }
+
+        if( !config.hasTestFilters() )
+            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
+        else
+            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
+        return matchedTestCases.size();
+    }
+
+    std::size_t listTestsNamesOnly( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        std::size_t matchedTests = 0;
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCaseInfo : matchedTestCases ) {
+            matchedTests++;
+            if( startsWith( testCaseInfo.name, '#' ) )
+               Catch::cout() << '"' << testCaseInfo.name << '"';
+            else
+               Catch::cout() << testCaseInfo.name;
+            if ( config.verbosity() >= Verbosity::High )
+                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
+            Catch::cout() << std::endl;
+        }
+        return matchedTests;
+    }
+
+    void TagInfo::add( std::string const& spelling ) {
+        ++count;
+        spellings.insert( spelling );
+    }
+
+    std::string TagInfo::all() const {
+        size_t size = 0;
+        for (auto const& spelling : spellings) {
+            // Add 2 for the brackes
+            size += spelling.size() + 2;
+        }
+
+        std::string out; out.reserve(size);
+        for (auto const& spelling : spellings) {
+            out += '[';
+            out += spelling;
+            out += ']';
+        }
+        return out;
+    }
+
+    std::size_t listTags( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        if( config.hasTestFilters() )
+            Catch::cout() << "Tags for matching test cases:\n";
+        else {
+            Catch::cout() << "All available tags:\n";
+        }
+
+        std::map<std::string, TagInfo> tagCounts;
+
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCase : matchedTestCases ) {
+            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
+                std::string lcaseTagName = toLower( tagName );
+                auto countIt = tagCounts.find( lcaseTagName );
+                if( countIt == tagCounts.end() )
+                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
+                countIt->second.add( tagName );
+            }
+        }
+
+        for( auto const& tagCount : tagCounts ) {
+            ReusableStringStream rss;
+            rss << "  " << std::setw(2) << tagCount.second.count << "  ";
+            auto str = rss.str();
+            auto wrapper = Column( tagCount.second.all() )
+                                                    .initialIndent( 0 )
+                                                    .indent( str.size() )
+                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
+            Catch::cout() << str << wrapper << '\n';
+        }
+        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
+        return tagCounts.size();
+    }
+
+    std::size_t listReporters() {
+        Catch::cout() << "Available reporters:\n";
+        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+        std::size_t maxNameLen = 0;
+        for( auto const& factoryKvp : factories )
+            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
+
+        for( auto const& factoryKvp : factories ) {
+            Catch::cout()
+                    << Column( factoryKvp.first + ":" )
+                            .indent(2)
+                            .width( 5+maxNameLen )
+                    +  Column( factoryKvp.second->getDescription() )
+                            .initialIndent(0)
+                            .indent(2)
+                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
+                    << "\n";
+        }
+        Catch::cout() << std::endl;
+        return factories.size();
+    }
+
+    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
+        Option<std::size_t> listedCount;
+        getCurrentMutableContext().setConfig( config );
+        if( config->listTests() )
+            listedCount = listedCount.valueOr(0) + listTests( *config );
+        if( config->listTestNamesOnly() )
+            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
+        if( config->listTags() )
+            listedCount = listedCount.valueOr(0) + listTags( *config );
+        if( config->listReporters() )
+            listedCount = listedCount.valueOr(0) + listReporters();
+        return listedCount;
+    }
+
+} // end namespace Catch
+// end catch_list.cpp
+// start catch_matchers.cpp
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+        std::string MatcherUntypedBase::toString() const {
+            if( m_cachedToString.empty() )
+                m_cachedToString = describe();
+            return m_cachedToString;
+        }
+
+        MatcherUntypedBase::~MatcherUntypedBase() = default;
+
+    } // namespace Impl
+} // namespace Matchers
+
+using namespace Matchers;
+using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+// end catch_matchers.cpp
+// start catch_matchers_exception.cpp
+
+namespace Catch {
+namespace Matchers {
+namespace Exception {
+
+bool ExceptionMessageMatcher::match(std::exception const& ex) const {
+    return ex.what() == m_message;
+}
+
+std::string ExceptionMessageMatcher::describe() const {
+    return "exception message matches \"" + m_message + "\"";
+}
+
+}
+Exception::ExceptionMessageMatcher Message(std::string const& message) {
+    return Exception::ExceptionMessageMatcher(message);
+}
+
+// namespace Exception
+} // namespace Matchers
+} // namespace Catch
+// end catch_matchers_exception.cpp
+// start catch_matchers_floating.cpp
+
+// start catch_polyfills.hpp
+
+namespace Catch {
+    bool isnan(float f);
+    bool isnan(double d);
+}
+
+// end catch_polyfills.hpp
+// start catch_to_string.hpp
+
+#include <string>
+
+namespace Catch {
+    template <typename T>
+    std::string to_string(T const& t) {
+#if defined(CATCH_CONFIG_CPP11_TO_STRING)
+        return std::to_string(t);
+#else
+        ReusableStringStream rss;
+        rss << t;
+        return rss.str();
+#endif
+    }
+} // end namespace Catch
+
+// end catch_to_string.hpp
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstdint>
+#include <cstring>
+#include <sstream>
+#include <type_traits>
+#include <iomanip>
+#include <limits>
+
+namespace Catch {
+namespace {
+
+    int32_t convert(float f) {
+        static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
+        int32_t i;
+        std::memcpy(&i, &f, sizeof(f));
+        return i;
+    }
+
+    int64_t convert(double d) {
+        static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
+        int64_t i;
+        std::memcpy(&i, &d, sizeof(d));
+        return i;
+    }
+
+    template <typename FP>
+    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
+        // Comparison with NaN should always be false.
+        // This way we can rule it out before getting into the ugly details
+        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
+            return false;
+        }
+
+        auto lc = convert(lhs);
+        auto rc = convert(rhs);
+
+        if ((lc < 0) != (rc < 0)) {
+            // Potentially we can have +0 and -0
+            return lhs == rhs;
+        }
+
+        auto ulpDiff = std::abs(lc - rc);
+        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
+    }
+
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+
+    float nextafter(float x, float y) {
+        return ::nextafterf(x, y);
+    }
+
+    double nextafter(double x, double y) {
+        return ::nextafter(x, y);
+    }
+
+#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
+
+template <typename FP>
+FP step(FP start, FP direction, uint64_t steps) {
+    for (uint64_t i = 0; i < steps; ++i) {
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+        start = Catch::nextafter(start, direction);
+#else
+        start = std::nextafter(start, direction);
+#endif
+    }
+    return start;
+}
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+template <typename FloatingPoint>
+void write(std::ostream& out, FloatingPoint num) {
+    out << std::scientific
+        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
+        << num;
+}
+
+} // end anonymous namespace
+
+namespace Matchers {
+namespace Floating {
+
+    enum class FloatingPointKind : uint8_t {
+        Float,
+        Double
+    };
+
+    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
+        :m_target{ target }, m_margin{ margin } {
+        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
+            << " Margin has to be non-negative.");
+    }
+
+    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
+    // But without the subtraction to allow for INFINITY in comparison
+    bool WithinAbsMatcher::match(double const& matchee) const {
+        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
+    }
+
+    std::string WithinAbsMatcher::describe() const {
+        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
+    }
+
+    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
+        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
+        CATCH_ENFORCE(m_type == FloatingPointKind::Double
+                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
+            "Provided ULP is impossibly large for a float comparison.");
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Clang <3.5 reports on the default branch in the switch below
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+
+    bool WithinUlpsMatcher::match(double const& matchee) const {
+        switch (m_type) {
+        case FloatingPointKind::Float:
+            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
+        case FloatingPointKind::Double:
+            return almostEqualUlps<double>(matchee, m_target, m_ulps);
+        default:
+            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
+        }
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+    std::string WithinUlpsMatcher::describe() const {
+        std::stringstream ret;
+
+        ret << "is within " << m_ulps << " ULPs of ";
+
+        if (m_type == FloatingPointKind::Float) {
+            write(ret, static_cast<float>(m_target));
+            ret << 'f';
+        } else {
+            write(ret, m_target);
+        }
+
+        ret << " ([";
+        if (m_type == FloatingPointKind::Double) {
+            write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
+            ret << ", ";
+            write(ret, step(m_target, static_cast<double>( INFINITY), m_ulps));
+        } else {
+            // We have to cast INFINITY to float because of MinGW, see #1782
+            write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
+            ret << ", ";
+            write(ret, step(static_cast<float>(m_target), static_cast<float>( INFINITY), m_ulps));
+        }
+        ret << "])";
+
+        return ret.str();
+    }
+
+    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
+        m_target(target),
+        m_epsilon(epsilon){
+        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
+        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
+    }
+
+    bool WithinRelMatcher::match(double const& matchee) const {
+        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
+        return marginComparison(matchee, m_target,
+                                std::isinf(relMargin)? 0 : relMargin);
+    }
+
+    std::string WithinRelMatcher::describe() const {
+        Catch::ReusableStringStream sstr;
+        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
+        return sstr.str();
+    }
+
+}// namespace Floating
+
+Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
+    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
+}
+
+Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
+    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
+}
+
+Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
+    return Floating::WithinAbsMatcher(target, margin);
+}
+
+Floating::WithinRelMatcher WithinRel(double target, double eps) {
+    return Floating::WithinRelMatcher(target, eps);
+}
+
+Floating::WithinRelMatcher WithinRel(double target) {
+    return Floating::WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
+}
+
+Floating::WithinRelMatcher WithinRel(float target, float eps) {
+    return Floating::WithinRelMatcher(target, eps);
+}
+
+Floating::WithinRelMatcher WithinRel(float target) {
+    return Floating::WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
+}
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_floating.cpp
+// start catch_matchers_generic.cpp
+
+std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
+    if (desc.empty()) {
+        return "matches undescribed predicate";
+    } else {
+        return "matches predicate: \"" + desc + '"';
+    }
+}
+// end catch_matchers_generic.cpp
+// start catch_matchers_string.cpp
+
+#include <regex>
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
+        :   m_caseSensitivity( caseSensitivity ),
+            m_str( adjustString( str ) )
+        {}
+        std::string CasedString::adjustString( std::string const& str ) const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? toLower( str )
+                   : str;
+        }
+        std::string CasedString::caseSensitivitySuffix() const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? " (case insensitive)"
+                   : std::string();
+        }
+
+        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
+        : m_comparator( comparator ),
+          m_operation( operation ) {
+        }
+
+        std::string StringMatcherBase::describe() const {
+            std::string description;
+            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
+                                        m_comparator.caseSensitivitySuffix().size());
+            description += m_operation;
+            description += ": \"";
+            description += m_comparator.m_str;
+            description += "\"";
+            description += m_comparator.caseSensitivitySuffix();
+            return description;
+        }
+
+        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
+
+        bool EqualsMatcher::match( std::string const& source ) const {
+            return m_comparator.adjustString( source ) == m_comparator.m_str;
+        }
+
+        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
+
+        bool ContainsMatcher::match( std::string const& source ) const {
+            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
+
+        bool StartsWithMatcher::match( std::string const& source ) const {
+            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
+
+        bool EndsWithMatcher::match( std::string const& source ) const {
+            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
+
+        bool RegexMatcher::match(std::string const& matchee) const {
+            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
+            if (m_caseSensitivity == CaseSensitive::Choice::No) {
+                flags |= std::regex::icase;
+            }
+            auto reg = std::regex(m_regex, flags);
+            return std::regex_match(matchee, reg);
+        }
+
+        std::string RegexMatcher::describe() const {
+            return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
+        }
+
+    } // namespace StdString
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+
+    StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
+        return StdString::RegexMatcher(regex, caseSensitivity);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+// end catch_matchers_string.cpp
+// start catch_message.cpp
+
+// start catch_uncaught_exceptions.h
+
+namespace Catch {
+    bool uncaught_exceptions();
+} // end namespace Catch
+
+// end catch_uncaught_exceptions.h
+#include <cassert>
+#include <stack>
+
+namespace Catch {
+
+    MessageInfo::MessageInfo(   StringRef const& _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        type( _type ),
+        sequence( ++globalCount )
+    {}
+
+    bool MessageInfo::operator==( MessageInfo const& other ) const {
+        return sequence == other.sequence;
+    }
+
+    bool MessageInfo::operator<( MessageInfo const& other ) const {
+        return sequence < other.sequence;
+    }
+
+    // This may need protecting if threading support is added
+    unsigned int MessageInfo::globalCount = 0;
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
+                                           SourceLineInfo const& lineInfo,
+                                           ResultWas::OfType type )
+        :m_info(macroName, lineInfo, type) {}
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
+    : m_info( builder.m_info ), m_moved()
+    {
+        m_info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( m_info );
+    }
+
+    ScopedMessage::ScopedMessage( ScopedMessage&& old )
+    : m_info( old.m_info ), m_moved()
+    {
+        old.m_moved = true;
+    }
+
+    ScopedMessage::~ScopedMessage() {
+        if ( !uncaught_exceptions() && !m_moved ){
+            getResultCapture().popScopedMessage(m_info);
+        }
+    }
+
+    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
+        auto trimmed = [&] (size_t start, size_t end) {
+            while (names[start] == ',' || isspace(names[start])) {
+                ++start;
+            }
+            while (names[end] == ',' || isspace(names[end])) {
+                --end;
+            }
+            return names.substr(start, end - start + 1);
+        };
+        auto skipq = [&] (size_t start, char quote) {
+            for (auto i = start + 1; i < names.size() ; ++i) {
+                if (names[i] == quote)
+                    return i;
+                if (names[i] == '\\')
+                    ++i;
+            }
+            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
+        };
+
+        size_t start = 0;
+        std::stack<char> openings;
+        for (size_t pos = 0; pos < names.size(); ++pos) {
+            char c = names[pos];
+            switch (c) {
+            case '[':
+            case '{':
+            case '(':
+            // It is basically impossible to disambiguate between
+            // comparison and start of template args in this context
+//            case '<':
+                openings.push(c);
+                break;
+            case ']':
+            case '}':
+            case ')':
+//           case '>':
+                openings.pop();
+                break;
+            case '"':
+            case '\'':
+                pos = skipq(pos, c);
+                break;
+            case ',':
+                if (start != pos && openings.empty()) {
+                    m_messages.emplace_back(macroName, lineInfo, resultType);
+                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
+                    m_messages.back().message += " := ";
+                    start = pos;
+                }
+            }
+        }
+        assert(openings.empty() && "Mismatched openings");
+        m_messages.emplace_back(macroName, lineInfo, resultType);
+        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
+        m_messages.back().message += " := ";
+    }
+    Capturer::~Capturer() {
+        if ( !uncaught_exceptions() ){
+            assert( m_captured == m_messages.size() );
+            for( size_t i = 0; i < m_captured; ++i  )
+                m_resultCapture.popScopedMessage( m_messages[i] );
+        }
+    }
+
+    void Capturer::captureValue( size_t index, std::string const& value ) {
+        assert( index < m_messages.size() );
+        m_messages[index].message += value;
+        m_resultCapture.pushScopedMessage( m_messages[index] );
+        m_captured++;
+    }
+
+} // end namespace Catch
+// end catch_message.cpp
+// start catch_output_redirect.cpp
+
+// start catch_output_redirect.h
+#ifndef TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+#define TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+
+#include <cstdio>
+#include <iosfwd>
+#include <string>
+
+namespace Catch {
+
+    class RedirectedStream {
+        std::ostream& m_originalStream;
+        std::ostream& m_redirectionStream;
+        std::streambuf* m_prevBuf;
+
+    public:
+        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
+        ~RedirectedStream();
+    };
+
+    class RedirectedStdOut {
+        ReusableStringStream m_rss;
+        RedirectedStream m_cout;
+    public:
+        RedirectedStdOut();
+        auto str() const -> std::string;
+    };
+
+    // StdErr has two constituent streams in C++, std::cerr and std::clog
+    // This means that we need to redirect 2 streams into 1 to keep proper
+    // order of writes
+    class RedirectedStdErr {
+        ReusableStringStream m_rss;
+        RedirectedStream m_cerr;
+        RedirectedStream m_clog;
+    public:
+        RedirectedStdErr();
+        auto str() const -> std::string;
+    };
+
+    class RedirectedStreams {
+    public:
+        RedirectedStreams(RedirectedStreams const&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
+        RedirectedStreams(RedirectedStreams&&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
+
+        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
+        ~RedirectedStreams();
+    private:
+        std::string& m_redirectedCout;
+        std::string& m_redirectedCerr;
+        RedirectedStdOut m_redirectedStdOut;
+        RedirectedStdErr m_redirectedStdErr;
+    };
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+    // Windows's implementation of std::tmpfile is terrible (it tries
+    // to create a file inside system folder, thus requiring elevated
+    // privileges for the binary), so we have to use tmpnam(_s) and
+    // create the file ourselves there.
+    class TempFile {
+    public:
+        TempFile(TempFile const&) = delete;
+        TempFile& operator=(TempFile const&) = delete;
+        TempFile(TempFile&&) = delete;
+        TempFile& operator=(TempFile&&) = delete;
+
+        TempFile();
+        ~TempFile();
+
+        std::FILE* getFile();
+        std::string getContents();
+
+    private:
+        std::FILE* m_file = nullptr;
+    #if defined(_MSC_VER)
+        char m_buffer[L_tmpnam] = { 0 };
+    #endif
+    };
+
+    class OutputRedirect {
+    public:
+        OutputRedirect(OutputRedirect const&) = delete;
+        OutputRedirect& operator=(OutputRedirect const&) = delete;
+        OutputRedirect(OutputRedirect&&) = delete;
+        OutputRedirect& operator=(OutputRedirect&&) = delete;
+
+        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
+        ~OutputRedirect();
+
+    private:
+        int m_originalStdout = -1;
+        int m_originalStderr = -1;
+        TempFile m_stdoutFile;
+        TempFile m_stderrFile;
+        std::string& m_stdoutDest;
+        std::string& m_stderrDest;
+    };
+
+#endif
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+// end catch_output_redirect.h
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #include <io.h>      //_dup and _dup2
+    #define dup _dup
+    #define dup2 _dup2
+    #define fileno _fileno
+    #else
+    #include <unistd.h>  // dup and dup2
+    #endif
+#endif
+
+namespace Catch {
+
+    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
+    :   m_originalStream( originalStream ),
+        m_redirectionStream( redirectionStream ),
+        m_prevBuf( m_originalStream.rdbuf() )
+    {
+        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
+    }
+
+    RedirectedStream::~RedirectedStream() {
+        m_originalStream.rdbuf( m_prevBuf );
+    }
+
+    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
+    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
+
+    RedirectedStdErr::RedirectedStdErr()
+    :   m_cerr( Catch::cerr(), m_rss.get() ),
+        m_clog( Catch::clog(), m_rss.get() )
+    {}
+    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
+
+    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
+    :   m_redirectedCout(redirectedCout),
+        m_redirectedCerr(redirectedCerr)
+    {}
+
+    RedirectedStreams::~RedirectedStreams() {
+        m_redirectedCout += m_redirectedStdOut.str();
+        m_redirectedCerr += m_redirectedStdErr.str();
+    }
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+#if defined(_MSC_VER)
+    TempFile::TempFile() {
+        if (tmpnam_s(m_buffer)) {
+            CATCH_RUNTIME_ERROR("Could not get a temp filename");
+        }
+        if (fopen_s(&m_file, m_buffer, "w")) {
+            char buffer[100];
+            if (strerror_s(buffer, errno)) {
+                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
+            }
+            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
+        }
+    }
+#else
+    TempFile::TempFile() {
+        m_file = std::tmpfile();
+        if (!m_file) {
+            CATCH_RUNTIME_ERROR("Could not create a temp file.");
+        }
+    }
+
+#endif
+
+    TempFile::~TempFile() {
+         // TBD: What to do about errors here?
+         std::fclose(m_file);
+         // We manually create the file on Windows only, on Linux
+         // it will be autodeleted
+#if defined(_MSC_VER)
+         std::remove(m_buffer);
+#endif
+    }
+
+    FILE* TempFile::getFile() {
+        return m_file;
+    }
+
+    std::string TempFile::getContents() {
+        std::stringstream sstr;
+        char buffer[100] = {};
+        std::rewind(m_file);
+        while (std::fgets(buffer, sizeof(buffer), m_file)) {
+            sstr << buffer;
+        }
+        return sstr.str();
+    }
+
+    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
+        m_originalStdout(dup(1)),
+        m_originalStderr(dup(2)),
+        m_stdoutDest(stdout_dest),
+        m_stderrDest(stderr_dest) {
+        dup2(fileno(m_stdoutFile.getFile()), 1);
+        dup2(fileno(m_stderrFile.getFile()), 2);
+    }
+
+    OutputRedirect::~OutputRedirect() {
+        Catch::cout() << std::flush;
+        fflush(stdout);
+        // Since we support overriding these streams, we flush cerr
+        // even though std::cerr is unbuffered
+        Catch::cerr() << std::flush;
+        Catch::clog() << std::flush;
+        fflush(stderr);
+
+        dup2(m_originalStdout, 1);
+        dup2(m_originalStderr, 2);
+
+        m_stdoutDest += m_stdoutFile.getContents();
+        m_stderrDest += m_stderrFile.getContents();
+    }
+
+#endif // CATCH_CONFIG_NEW_CAPTURE
+
+} // namespace Catch
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #undef dup
+    #undef dup2
+    #undef fileno
+    #endif
+#endif
+// end catch_output_redirect.cpp
+// start catch_polyfills.cpp
+
+#include <cmath>
+
+namespace Catch {
+
+#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+    bool isnan(float f) {
+        return std::isnan(f);
+    }
+    bool isnan(double d) {
+        return std::isnan(d);
+    }
+#else
+    // For now we only use this for embarcadero
+    bool isnan(float f) {
+        return std::_isnan(f);
+    }
+    bool isnan(double d) {
+        return std::_isnan(d);
+    }
+#endif
+
+} // end namespace Catch
+// end catch_polyfills.cpp
+// start catch_random_number_generator.cpp
+
+namespace Catch {
+
+namespace {
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4146) // we negate uint32 during the rotate
+#endif
+        // Safe rotr implementation thanks to John Regehr
+        uint32_t rotate_right(uint32_t val, uint32_t count) {
+            const uint32_t mask = 31;
+            count &= mask;
+            return (val >> count) | (val << (-count & mask));
+        }
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}
+
+    SimplePcg32::SimplePcg32(result_type seed_) {
+        seed(seed_);
+    }
+
+    void SimplePcg32::seed(result_type seed_) {
+        m_state = 0;
+        (*this)();
+        m_state += seed_;
+        (*this)();
+    }
+
+    void SimplePcg32::discard(uint64_t skip) {
+        // We could implement this to run in O(log n) steps, but this
+        // should suffice for our use case.
+        for (uint64_t s = 0; s < skip; ++s) {
+            static_cast<void>((*this)());
+        }
+    }
+
+    SimplePcg32::result_type SimplePcg32::operator()() {
+        // prepare the output value
+        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
+        const auto output = rotate_right(xorshifted, m_state >> 59u);
+
+        // advance state
+        m_state = m_state * 6364136223846793005ULL + s_inc;
+
+        return output;
+    }
+
+    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state == rhs.m_state;
+    }
+
+    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state != rhs.m_state;
+    }
+}
+// end catch_random_number_generator.cpp
+// start catch_registry_hub.cpp
+
+// start catch_test_case_registry_impl.h
+
+#include <vector>
+#include <set>
+#include <algorithm>
+#include <ios>
+
+namespace Catch {
+
+    class TestCase;
+    struct IConfig;
+
+    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+
+    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
+
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+
+    class TestRegistry : public ITestCaseRegistry {
+    public:
+        virtual ~TestRegistry() = default;
+
+        virtual void registerTest( TestCase const& testCase );
+
+        std::vector<TestCase> const& getAllTests() const override;
+        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
+
+    private:
+        std::vector<TestCase> m_functions;
+        mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
+        mutable std::vector<TestCase> m_sortedFunctions;
+        std::size_t m_unnamedCount = 0;
+        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class TestInvokerAsFunction : public ITestInvoker {
+        void(*m_testAsFunction)();
+    public:
+        TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
+
+        void invoke() const override;
+    };
+
+    std::string extractClassName( StringRef const& classOrQualifiedMethodName );
+
+    ///////////////////////////////////////////////////////////////////////////
+
+} // end namespace Catch
+
+// end catch_test_case_registry_impl.h
+// start catch_reporter_registry.h
+
+#include <map>
+
+namespace Catch {
+
+    class ReporterRegistry : public IReporterRegistry {
+
+    public:
+
+        ~ReporterRegistry() override;
+
+        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
+
+        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
+        void registerListener( IReporterFactoryPtr const& factory );
+
+        FactoryMap const& getFactories() const override;
+        Listeners const& getListeners() const override;
+
+    private:
+        FactoryMap m_factories;
+        Listeners m_listeners;
+    };
+}
+
+// end catch_reporter_registry.h
+// start catch_tag_alias_registry.h
+
+// start catch_tag_alias.h
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias {
+        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
+
+        std::string tag;
+        SourceLineInfo lineInfo;
+    };
+
+} // end namespace Catch
+
+// end catch_tag_alias.h
+#include <map>
+
+namespace Catch {
+
+    class TagAliasRegistry : public ITagAliasRegistry {
+    public:
+        ~TagAliasRegistry() override;
+        TagAlias const* find( std::string const& alias ) const override;
+        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
+        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
+
+    private:
+        std::map<std::string, TagAlias> m_registry;
+    };
+
+} // end namespace Catch
+
+// end catch_tag_alias_registry.h
+// start catch_startup_exception_registry.h
+
+#include <vector>
+#include <exception>
+
+namespace Catch {
+
+    class StartupExceptionRegistry {
+    public:
+        void add(std::exception_ptr const& exception) noexcept;
+        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
+    private:
+        std::vector<std::exception_ptr> m_exceptions;
+    };
+
+} // end namespace Catch
+
+// end catch_startup_exception_registry.h
+// start catch_singletons.hpp
+
+namespace Catch {
+
+    struct ISingleton {
+        virtual ~ISingleton();
+    };
+
+    void addSingleton( ISingleton* singleton );
+    void cleanupSingletons();
+
+    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
+    class Singleton : SingletonImplT, public ISingleton {
+
+        static auto getInternal() -> Singleton* {
+            static Singleton* s_instance = nullptr;
+            if( !s_instance ) {
+                s_instance = new Singleton;
+                addSingleton( s_instance );
+            }
+            return s_instance;
+        }
+
+    public:
+        static auto get() -> InterfaceT const& {
+            return *getInternal();
+        }
+        static auto getMutable() -> MutableInterfaceT& {
+            return *getInternal();
+        }
+    };
+
+} // namespace Catch
+
+// end catch_singletons.hpp
+namespace Catch {
+
+    namespace {
+
+        class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
+                            private NonCopyable {
+
+        public: // IRegistryHub
+            RegistryHub() = default;
+            IReporterRegistry const& getReporterRegistry() const override {
+                return m_reporterRegistry;
+            }
+            ITestCaseRegistry const& getTestCaseRegistry() const override {
+                return m_testCaseRegistry;
+            }
+            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
+                return m_exceptionTranslatorRegistry;
+            }
+            ITagAliasRegistry const& getTagAliasRegistry() const override {
+                return m_tagAliasRegistry;
+            }
+            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
+                return m_exceptionRegistry;
+            }
+
+        public: // IMutableRegistryHub
+            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
+                m_reporterRegistry.registerReporter( name, factory );
+            }
+            void registerListener( IReporterFactoryPtr const& factory ) override {
+                m_reporterRegistry.registerListener( factory );
+            }
+            void registerTest( TestCase const& testInfo ) override {
+                m_testCaseRegistry.registerTest( testInfo );
+            }
+            void registerTranslator( const IExceptionTranslator* translator ) override {
+                m_exceptionTranslatorRegistry.registerTranslator( translator );
+            }
+            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
+                m_tagAliasRegistry.add( alias, tag, lineInfo );
+            }
+            void registerStartupException() noexcept override {
+                m_exceptionRegistry.add(std::current_exception());
+            }
+            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
+                return m_enumValuesRegistry;
+            }
+
+        private:
+            TestRegistry m_testCaseRegistry;
+            ReporterRegistry m_reporterRegistry;
+            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+            TagAliasRegistry m_tagAliasRegistry;
+            StartupExceptionRegistry m_exceptionRegistry;
+            Detail::EnumValuesRegistry m_enumValuesRegistry;
+        };
+    }
+
+    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
+
+    IRegistryHub const& getRegistryHub() {
+        return RegistryHubSingleton::get();
+    }
+    IMutableRegistryHub& getMutableRegistryHub() {
+        return RegistryHubSingleton::getMutable();
+    }
+    void cleanUp() {
+        cleanupSingletons();
+        cleanUpContext();
+    }
+    std::string translateActiveException() {
+        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+} // end namespace Catch
+// end catch_registry_hub.cpp
+// start catch_reporter_registry.cpp
+
+namespace Catch {
+
+    ReporterRegistry::~ReporterRegistry() = default;
+
+    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
+        auto it =  m_factories.find( name );
+        if( it == m_factories.end() )
+            return nullptr;
+        return it->second->create( ReporterConfig( config ) );
+    }
+
+    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
+        m_factories.emplace(name, factory);
+    }
+    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
+        m_listeners.push_back( factory );
+    }
+
+    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
+        return m_factories;
+    }
+    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
+        return m_listeners;
+    }
+
+}
+// end catch_reporter_registry.cpp
+// start catch_result_type.cpp
+
+namespace Catch {
+
+    bool isOk( ResultWas::OfType resultType ) {
+        return ( resultType & ResultWas::FailureBit ) == 0;
+    }
+    bool isJustInfo( int flags ) {
+        return flags == ResultWas::Info;
+    }
+
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+    }
+
+    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+
+} // end namespace Catch
+// end catch_result_type.cpp
+// start catch_run_context.cpp
+
+#include <cassert>
+#include <algorithm>
+#include <sstream>
+
+namespace Catch {
+
+    namespace Generators {
+        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
+            GeneratorBasePtr m_generator;
+
+            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+            :   TrackerBase( nameAndLocation, ctx, parent )
+            {}
+            ~GeneratorTracker();
+
+            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
+                std::shared_ptr<GeneratorTracker> tracker;
+
+                ITracker& currentTracker = ctx.currentTracker();
+                if( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+                    assert( childTracker );
+                    assert( childTracker->isGeneratorTracker() );
+                    tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
+                }
+                else {
+                    tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
+                    currentTracker.addChild( tracker );
+                }
+
+                if( !ctx.completedCycle() && !tracker->isComplete() ) {
+                    tracker->open();
+                }
+
+                return *tracker;
+            }
+
+            // TrackerBase interface
+            bool isGeneratorTracker() const override { return true; }
+            auto hasGenerator() const -> bool override {
+                return !!m_generator;
+            }
+            void close() override {
+                TrackerBase::close();
+                // Generator interface only finds out if it has another item on atual move
+                if (m_runState == CompletedSuccessfully && m_generator->next()) {
+                    m_children.clear();
+                    m_runState = Executing;
+                }
+            }
+
+            // IGeneratorTracker interface
+            auto getGenerator() const -> GeneratorBasePtr const& override {
+                return m_generator;
+            }
+            void setGenerator( GeneratorBasePtr&& generator ) override {
+                m_generator = std::move( generator );
+            }
+        };
+        GeneratorTracker::~GeneratorTracker() {}
+    }
+
+    RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
+    :   m_runInfo(_config->name()),
+        m_context(getCurrentMutableContext()),
+        m_config(_config),
+        m_reporter(std::move(reporter)),
+        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
+        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
+    {
+        m_context.setRunner(this);
+        m_context.setConfig(m_config);
+        m_context.setResultCapture(this);
+        m_reporter->testRunStarting(m_runInfo);
+    }
+
+    RunContext::~RunContext() {
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+    }
+
+    void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
+        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
+    }
+
+    void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
+        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
+    }
+
+    Totals RunContext::runTest(TestCase const& testCase) {
+        Totals prevTotals = m_totals;
+
+        std::string redirectedCout;
+        std::string redirectedCerr;
+
+        auto const& testInfo = testCase.getTestCaseInfo();
+
+        m_reporter->testCaseStarting(testInfo);
+
+        m_activeTestCase = &testCase;
+
+        ITracker& rootTracker = m_trackerContext.startRun();
+        assert(rootTracker.isSectionTracker());
+        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
+        do {
+            m_trackerContext.startCycle();
+            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
+            runCurrentTest(redirectedCout, redirectedCerr);
+        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
+
+        Totals deltaTotals = m_totals.delta(prevTotals);
+        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
+            deltaTotals.assertions.failed++;
+            deltaTotals.testCases.passed--;
+            deltaTotals.testCases.failed++;
+        }
+        m_totals.testCases += deltaTotals.testCases;
+        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+                                  deltaTotals,
+                                  redirectedCout,
+                                  redirectedCerr,
+                                  aborting()));
+
+        m_activeTestCase = nullptr;
+        m_testCaseTracker = nullptr;
+
+        return deltaTotals;
+    }
+
+    IConfigPtr RunContext::config() const {
+        return m_config;
+    }
+
+    IStreamingReporter& RunContext::reporter() const {
+        return *m_reporter;
+    }
+
+    void RunContext::assertionEnded(AssertionResult const & result) {
+        if (result.getResultType() == ResultWas::Ok) {
+            m_totals.assertions.passed++;
+            m_lastAssertionPassed = true;
+        } else if (!result.isOk()) {
+            m_lastAssertionPassed = false;
+            if( m_activeTestCase->getTestCaseInfo().okToFail() )
+                m_totals.assertions.failedButOk++;
+            else
+                m_totals.assertions.failed++;
+        }
+        else {
+            m_lastAssertionPassed = true;
+        }
+
+        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
+        // and should be let to clear themselves out.
+        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
+
+        if (result.getResultType() != ResultWas::Warning)
+            m_messageScopes.clear();
+
+        // Reset working state
+        resetAssertionInfo();
+        m_lastResult = result;
+    }
+    void RunContext::resetAssertionInfo() {
+        m_lastAssertionInfo.macroName = StringRef();
+        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
+    }
+
+    bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
+        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
+        if (!sectionTracker.isOpen())
+            return false;
+        m_activeSections.push_back(&sectionTracker);
+
+        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+        m_reporter->sectionStarting(sectionInfo);
+
+        assertions = m_totals.assertions;
+
+        return true;
+    }
+    auto RunContext::acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        using namespace Generators;
+        GeneratorTracker& tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( "generator", lineInfo ) );
+        assert( tracker.isOpen() );
+        m_lastAssertionInfo.lineInfo = lineInfo;
+        return tracker;
+    }
+
+    bool RunContext::testForMissingAssertions(Counts& assertions) {
+        if (assertions.total() != 0)
+            return false;
+        if (!m_config->warnAboutMissingAssertions())
+            return false;
+        if (m_trackerContext.currentTracker().hasChildren())
+            return false;
+        m_totals.assertions.failed++;
+        assertions.failed++;
+        return true;
+    }
+
+    void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
+        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
+        bool missingAssertions = testForMissingAssertions(assertions);
+
+        if (!m_activeSections.empty()) {
+            m_activeSections.back()->close();
+            m_activeSections.pop_back();
+        }
+
+        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
+        m_messages.clear();
+        m_messageScopes.clear();
+    }
+
+    void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
+        if (m_unfinishedSections.empty())
+            m_activeSections.back()->fail();
+        else
+            m_activeSections.back()->close();
+        m_activeSections.pop_back();
+
+        m_unfinishedSections.push_back(endInfo);
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void RunContext::benchmarkPreparing(std::string const& name) {
+		m_reporter->benchmarkPreparing(name);
+	}
+    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
+        m_reporter->benchmarkStarting( info );
+    }
+    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
+        m_reporter->benchmarkEnded( stats );
+    }
+	void RunContext::benchmarkFailed(std::string const & error) {
+		m_reporter->benchmarkFailed(error);
+	}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    void RunContext::pushScopedMessage(MessageInfo const & message) {
+        m_messages.push_back(message);
+    }
+
+    void RunContext::popScopedMessage(MessageInfo const & message) {
+        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
+    }
+
+    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
+        m_messageScopes.emplace_back( builder );
+    }
+
+    std::string RunContext::getCurrentTestName() const {
+        return m_activeTestCase
+            ? m_activeTestCase->getTestCaseInfo().name
+            : std::string();
+    }
+
+    const AssertionResult * RunContext::getLastResult() const {
+        return &(*m_lastResult);
+    }
+
+    void RunContext::exceptionEarlyReported() {
+        m_shouldReportUnexpected = false;
+    }
+
+    void RunContext::handleFatalErrorCondition( StringRef message ) {
+        // First notify reporter that bad things happened
+        m_reporter->fatalErrorEncountered(message);
+
+        // Don't rebuild the result -- the stringification itself can cause more fatal errors
+        // Instead, fake a result data.
+        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
+        tempResult.message = static_cast<std::string>(message);
+        AssertionResult result(m_lastAssertionInfo, tempResult);
+
+        assertionEnded(result);
+
+        handleUnfinishedSections();
+
+        // Recreate section for test case (as we will lose the one that was in scope)
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+
+        Counts assertions;
+        assertions.failed = 1;
+        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
+        m_reporter->sectionEnded(testCaseSectionStats);
+
+        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
+
+        Totals deltaTotals;
+        deltaTotals.testCases.failed = 1;
+        deltaTotals.assertions.failed = 1;
+        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+                                  deltaTotals,
+                                  std::string(),
+                                  std::string(),
+                                  false));
+        m_totals.testCases.failed++;
+        testGroupEnded(std::string(), m_totals, 1, 1);
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
+    }
+
+    bool RunContext::lastAssertionPassed() {
+         return m_lastAssertionPassed;
+    }
+
+    void RunContext::assertionPassed() {
+        m_lastAssertionPassed = true;
+        ++m_totals.assertions.passed;
+        resetAssertionInfo();
+        m_messageScopes.clear();
+    }
+
+    bool RunContext::aborting() const {
+        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
+    }
+
+    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+        m_reporter->sectionStarting(testCaseSection);
+        Counts prevAssertions = m_totals.assertions;
+        double duration = 0;
+        m_shouldReportUnexpected = true;
+        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
+
+        seedRng(*m_config);
+
+        Timer timer;
+        CATCH_TRY {
+            if (m_reporter->getPreferences().shouldRedirectStdOut) {
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
+
+                timer.start();
+                invokeActiveTestCase();
+#else
+                OutputRedirect r(redirectedCout, redirectedCerr);
+                timer.start();
+                invokeActiveTestCase();
+#endif
+            } else {
+                timer.start();
+                invokeActiveTestCase();
+            }
+            duration = timer.getElapsedSeconds();
+        } CATCH_CATCH_ANON (TestFailureException&) {
+            // This just means the test was aborted due to failure
+        } CATCH_CATCH_ALL {
+            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
+            // are reported without translation at the point of origin.
+            if( m_shouldReportUnexpected ) {
+                AssertionReaction dummyReaction;
+                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
+            }
+        }
+        Counts assertions = m_totals.assertions - prevAssertions;
+        bool missingAssertions = testForMissingAssertions(assertions);
+
+        m_testCaseTracker->close();
+        handleUnfinishedSections();
+        m_messages.clear();
+        m_messageScopes.clear();
+
+        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
+        m_reporter->sectionEnded(testCaseSectionStats);
+    }
+
+    void RunContext::invokeActiveTestCase() {
+        FatalConditionHandler fatalConditionHandler; // Handle signals
+        m_activeTestCase->invoke();
+        fatalConditionHandler.reset();
+    }
+
+    void RunContext::handleUnfinishedSections() {
+        // If sections ended prematurely due to an exception we stored their
+        // infos here so we can tear them down outside the unwind process.
+        for (auto it = m_unfinishedSections.rbegin(),
+             itEnd = m_unfinishedSections.rend();
+             it != itEnd;
+             ++it)
+            sectionEnded(*it);
+        m_unfinishedSections.clear();
+    }
+
+    void RunContext::handleExpr(
+        AssertionInfo const& info,
+        ITransientExpression const& expr,
+        AssertionReaction& reaction
+    ) {
+        m_reporter->assertionStarting( info );
+
+        bool negated = isFalseTest( info.resultDisposition );
+        bool result = expr.getResult() != negated;
+
+        if( result ) {
+            if (!m_includeSuccessfulResults) {
+                assertionPassed();
+            }
+            else {
+                reportExpr(info, ResultWas::Ok, &expr, negated);
+            }
+        }
+        else {
+            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
+            populateReaction( reaction );
+        }
+    }
+    void RunContext::reportExpr(
+            AssertionInfo const &info,
+            ResultWas::OfType resultType,
+            ITransientExpression const *expr,
+            bool negated ) {
+
+        m_lastAssertionInfo = info;
+        AssertionResultData data( resultType, LazyExpression( negated ) );
+
+        AssertionResult assertionResult{ info, data };
+        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
+
+        assertionEnded( assertionResult );
+    }
+
+    void RunContext::handleMessage(
+            AssertionInfo const& info,
+            ResultWas::OfType resultType,
+            StringRef const& message,
+            AssertionReaction& reaction
+    ) {
+        m_reporter->assertionStarting( info );
+
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        data.message = static_cast<std::string>(message);
+        AssertionResult assertionResult{ m_lastAssertionInfo, data };
+        assertionEnded( assertionResult );
+        if( !assertionResult.isOk() )
+            populateReaction( reaction );
+    }
+    void RunContext::handleUnexpectedExceptionNotThrown(
+            AssertionInfo const& info,
+            AssertionReaction& reaction
+    ) {
+        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
+    }
+
+    void RunContext::handleUnexpectedInflightException(
+            AssertionInfo const& info,
+            std::string const& message,
+            AssertionReaction& reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+        data.message = message;
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+        populateReaction( reaction );
+    }
+
+    void RunContext::populateReaction( AssertionReaction& reaction ) {
+        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
+        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
+    }
+
+    void RunContext::handleIncomplete(
+            AssertionInfo const& info
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+    }
+    void RunContext::handleNonExpr(
+            AssertionInfo const &info,
+            ResultWas::OfType resultType,
+            AssertionReaction &reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+
+        if( !assertionResult.isOk() )
+            populateReaction( reaction );
+    }
+
+    IResultCapture& getResultCapture() {
+        if (auto* capture = getCurrentContext().getResultCapture())
+            return *capture;
+        else
+            CATCH_INTERNAL_ERROR("No result capture instance");
+    }
+
+    void seedRng(IConfig const& config) {
+        if (config.rngSeed() != 0) {
+            std::srand(config.rngSeed());
+            rng().seed(config.rngSeed());
+        }
+    }
+
+    unsigned int rngSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+
+}
+// end catch_run_context.cpp
+// start catch_section.cpp
+
+namespace Catch {
+
+    Section::Section( SectionInfo const& info )
+    :   m_info( info ),
+        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
+    {
+        m_timer.start();
+    }
+
+    Section::~Section() {
+        if( m_sectionIncluded ) {
+            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
+            if( uncaught_exceptions() )
+                getResultCapture().sectionEndedEarly( endInfo );
+            else
+                getResultCapture().sectionEnded( endInfo );
+        }
+    }
+
+    // This indicates whether the section should be executed or not
+    Section::operator bool() const {
+        return m_sectionIncluded;
+    }
+
+} // end namespace Catch
+// end catch_section.cpp
+// start catch_section_info.cpp
+
+namespace Catch {
+
+    SectionInfo::SectionInfo
+        (   SourceLineInfo const& _lineInfo,
+            std::string const& _name )
+    :   name( _name ),
+        lineInfo( _lineInfo )
+    {}
+
+} // end namespace Catch
+// end catch_section_info.cpp
+// start catch_session.cpp
+
+// start catch_session.h
+
+#include <memory>
+
+namespace Catch {
+
+    class Session : NonCopyable {
+    public:
+
+        Session();
+        ~Session() override;
+
+        void showHelp() const;
+        void libIdentify();
+
+        int applyCommandLine( int argc, char const * const * argv );
+    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+        int applyCommandLine( int argc, wchar_t const * const * argv );
+    #endif
+
+        void useConfigData( ConfigData const& configData );
+
+        template<typename CharT>
+        int run(int argc, CharT const * const argv[]) {
+            if (m_startupExceptions)
+                return 1;
+            int returnCode = applyCommandLine(argc, argv);
+            if (returnCode == 0)
+                returnCode = run();
+            return returnCode;
+        }
+
+        int run();
+
+        clara::Parser const& cli() const;
+        void cli( clara::Parser const& newParser );
+        ConfigData& configData();
+        Config& config();
+    private:
+        int runInternal();
+
+        clara::Parser m_cli;
+        ConfigData m_configData;
+        std::shared_ptr<Config> m_config;
+        bool m_startupExceptions = false;
+    };
+
+} // end namespace Catch
+
+// end catch_session.h
+// start catch_version.h
+
+#include <iosfwd>
+
+namespace Catch {
+
+    // Versioning information
+    struct Version {
+        Version( Version const& ) = delete;
+        Version& operator=( Version const& ) = delete;
+        Version(    unsigned int _majorVersion,
+                    unsigned int _minorVersion,
+                    unsigned int _patchNumber,
+                    char const * const _branchName,
+                    unsigned int _buildNumber );
+
+        unsigned int const majorVersion;
+        unsigned int const minorVersion;
+        unsigned int const patchNumber;
+
+        // buildNumber is only used if branchName is not null
+        char const * const branchName;
+        unsigned int const buildNumber;
+
+        friend std::ostream& operator << ( std::ostream& os, Version const& version );
+    };
+
+    Version const& libraryVersion();
+}
+
+// end catch_version.h
+#include <cstdlib>
+#include <iomanip>
+#include <set>
+#include <iterator>
+
+namespace Catch {
+
+    namespace {
+        const int MaxExitCode = 255;
+
+        IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
+            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
+            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
+
+            return reporter;
+        }
+
+        IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
+            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
+                return createReporter(config->getReporterName(), config);
+            }
+
+            // On older platforms, returning std::unique_ptr<ListeningReporter>
+            // when the return type is std::unique_ptr<IStreamingReporter>
+            // doesn't compile without a std::move call. However, this causes
+            // a warning on newer platforms. Thus, we have to work around
+            // it a bit and downcast the pointer manually.
+            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
+            auto& multi = static_cast<ListeningReporter&>(*ret);
+            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
+            for (auto const& listener : listeners) {
+                multi.addListener(listener->create(Catch::ReporterConfig(config)));
+            }
+            multi.addReporter(createReporter(config->getReporterName(), config));
+            return ret;
+        }
+
+        class TestGroup {
+        public:
+            explicit TestGroup(std::shared_ptr<Config> const& config)
+            : m_config{config}
+            , m_context{config, makeReporter(config)}
+            {
+                auto const& allTestCases = getAllTestCasesSorted(*m_config);
+                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
+                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
+
+                if (m_matches.empty() && invalidArgs.empty()) {
+                    for (auto const& test : allTestCases)
+                        if (!test.isHidden())
+                            m_tests.emplace(&test);
+                } else {
+                    for (auto const& match : m_matches)
+                        m_tests.insert(match.tests.begin(), match.tests.end());
+                }
+            }
+
+            Totals execute() {
+                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
+                Totals totals;
+                m_context.testGroupStarting(m_config->name(), 1, 1);
+                for (auto const& testCase : m_tests) {
+                    if (!m_context.aborting())
+                        totals += m_context.runTest(*testCase);
+                    else
+                        m_context.reporter().skipTest(*testCase);
+                }
+
+                for (auto const& match : m_matches) {
+                    if (match.tests.empty()) {
+                        m_context.reporter().noMatchingTestCases(match.name);
+                        totals.error = -1;
+                    }
+                }
+
+                if (!invalidArgs.empty()) {
+                    for (auto const& invalidArg: invalidArgs)
+                         m_context.reporter().reportInvalidArguments(invalidArg);
+                }
+
+                m_context.testGroupEnded(m_config->name(), totals, 1, 1);
+                return totals;
+            }
+
+        private:
+            using Tests = std::set<TestCase const*>;
+
+            std::shared_ptr<Config> m_config;
+            RunContext m_context;
+            Tests m_tests;
+            TestSpec::Matches m_matches;
+        };
+
+        void applyFilenamesAsTags(Catch::IConfig const& config) {
+            auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
+            for (auto& testCase : tests) {
+                auto tags = testCase.tags;
+
+                std::string filename = testCase.lineInfo.file;
+                auto lastSlash = filename.find_last_of("\\/");
+                if (lastSlash != std::string::npos) {
+                    filename.erase(0, lastSlash);
+                    filename[0] = '#';
+                }
+
+                auto lastDot = filename.find_last_of('.');
+                if (lastDot != std::string::npos) {
+                    filename.erase(lastDot);
+                }
+
+                tags.push_back(std::move(filename));
+                setTags(testCase, tags);
+            }
+        }
+
+    } // anon namespace
+
+    Session::Session() {
+        static bool alreadyInstantiated = false;
+        if( alreadyInstantiated ) {
+            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
+            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
+        }
+
+        // There cannot be exceptions at startup in no-exception mode.
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
+        if ( !exceptions.empty() ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
+
+            m_startupExceptions = true;
+            Colour colourGuard( Colour::Red );
+            Catch::cerr() << "Errors occurred during startup!" << '\n';
+            // iterate over all exceptions and notify user
+            for ( const auto& ex_ptr : exceptions ) {
+                try {
+                    std::rethrow_exception(ex_ptr);
+                } catch ( std::exception const& ex ) {
+                    Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
+                }
+            }
+        }
+#endif
+
+        alreadyInstantiated = true;
+        m_cli = makeCommandLineParser( m_configData );
+    }
+    Session::~Session() {
+        Catch::cleanUp();
+    }
+
+    void Session::showHelp() const {
+        Catch::cout()
+                << "\nCatch v" << libraryVersion() << "\n"
+                << m_cli << std::endl
+                << "For more detailed usage please see the project docs\n" << std::endl;
+    }
+    void Session::libIdentify() {
+        Catch::cout()
+                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
+                << std::left << std::setw(16) << "category: " << "testframework\n"
+                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
+                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
+    }
+
+    int Session::applyCommandLine( int argc, char const * const * argv ) {
+        if( m_startupExceptions )
+            return 1;
+
+        auto result = m_cli.parse( clara::Args( argc, argv ) );
+        if( !result ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
+            Catch::cerr()
+                << Colour( Colour::Red )
+                << "\nError(s) in input:\n"
+                << Column( result.errorMessage() ).indent( 2 )
+                << "\n\n";
+            Catch::cerr() << "Run with -? for usage\n" << std::endl;
+            return MaxExitCode;
+        }
+
+        if( m_configData.showHelp )
+            showHelp();
+        if( m_configData.libIdentify )
+            libIdentify();
+        m_config.reset();
+        return 0;
+    }
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
+
+        char **utf8Argv = new char *[ argc ];
+
+        for ( int i = 0; i < argc; ++i ) {
+            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
+
+            utf8Argv[ i ] = new char[ bufSize ];
+
+            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
+        }
+
+        int returnCode = applyCommandLine( argc, utf8Argv );
+
+        for ( int i = 0; i < argc; ++i )
+            delete [] utf8Argv[ i ];
+
+        delete [] utf8Argv;
+
+        return returnCode;
+    }
+#endif
+
+    void Session::useConfigData( ConfigData const& configData ) {
+        m_configData = configData;
+        m_config.reset();
+    }
+
+    int Session::run() {
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
+            static_cast<void>(std::getchar());
+        }
+        int exitCode = runInternal();
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
+            static_cast<void>(std::getchar());
+        }
+        return exitCode;
+    }
+
+    clara::Parser const& Session::cli() const {
+        return m_cli;
+    }
+    void Session::cli( clara::Parser const& newParser ) {
+        m_cli = newParser;
+    }
+    ConfigData& Session::configData() {
+        return m_configData;
+    }
+    Config& Session::config() {
+        if( !m_config )
+            m_config = std::make_shared<Config>( m_configData );
+        return *m_config;
+    }
+
+    int Session::runInternal() {
+        if( m_startupExceptions )
+            return 1;
+
+        if (m_configData.showHelp || m_configData.libIdentify) {
+            return 0;
+        }
+
+        CATCH_TRY {
+            config(); // Force config to be constructed
+
+            seedRng( *m_config );
+
+            if( m_configData.filenamesAsTags )
+                applyFilenamesAsTags( *m_config );
+
+            // Handle list request
+            if( Option<std::size_t> listed = list( m_config ) )
+                return static_cast<int>( *listed );
+
+            TestGroup tests { m_config };
+            auto const totals = tests.execute();
+
+            if( m_config->warnAboutNoTests() && totals.error == -1 )
+                return 2;
+
+            // Note that on unices only the lower 8 bits are usually used, clamping
+            // the return value to 255 prevents false negative when some multiple
+            // of 256 tests has failed
+            return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
+        }
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        catch( std::exception& ex ) {
+            Catch::cerr() << ex.what() << std::endl;
+            return MaxExitCode;
+        }
+#endif
+    }
+
+} // end namespace Catch
+// end catch_session.cpp
+// start catch_singletons.cpp
+
+#include <vector>
+
+namespace Catch {
+
+    namespace {
+        static auto getSingletons() -> std::vector<ISingleton*>*& {
+            static std::vector<ISingleton*>* g_singletons = nullptr;
+            if( !g_singletons )
+                g_singletons = new std::vector<ISingleton*>();
+            return g_singletons;
+        }
+    }
+
+    ISingleton::~ISingleton() {}
+
+    void addSingleton(ISingleton* singleton ) {
+        getSingletons()->push_back( singleton );
+    }
+    void cleanupSingletons() {
+        auto& singletons = getSingletons();
+        for( auto singleton : *singletons )
+            delete singleton;
+        delete singletons;
+        singletons = nullptr;
+    }
+
+} // namespace Catch
+// end catch_singletons.cpp
+// start catch_startup_exception_registry.cpp
+
+namespace Catch {
+void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
+        CATCH_TRY {
+            m_exceptions.push_back(exception);
+        } CATCH_CATCH_ALL {
+            // If we run out of memory during start-up there's really not a lot more we can do about it
+            std::terminate();
+        }
+    }
+
+    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
+        return m_exceptions;
+    }
+
+} // end namespace Catch
+// end catch_startup_exception_registry.cpp
+// start catch_stream.cpp
+
+#include <cstdio>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    Catch::IStream::~IStream() = default;
+
+    namespace Detail { namespace {
+        template<typename WriterF, std::size_t bufferSize=256>
+        class StreamBufImpl : public std::streambuf {
+            char data[bufferSize];
+            WriterF m_writer;
+
+        public:
+            StreamBufImpl() {
+                setp( data, data + sizeof(data) );
+            }
+
+            ~StreamBufImpl() noexcept {
+                StreamBufImpl::sync();
+            }
+
+        private:
+            int overflow( int c ) override {
+                sync();
+
+                if( c != EOF ) {
+                    if( pbase() == epptr() )
+                        m_writer( std::string( 1, static_cast<char>( c ) ) );
+                    else
+                        sputc( static_cast<char>( c ) );
+                }
+                return 0;
+            }
+
+            int sync() override {
+                if( pbase() != pptr() ) {
+                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+                    setp( pbase(), epptr() );
+                }
+                return 0;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        struct OutputDebugWriter {
+
+            void operator()( std::string const&str ) {
+                writeToDebugConsole( str );
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class FileStream : public IStream {
+            mutable std::ofstream m_ofs;
+        public:
+            FileStream( StringRef filename ) {
+                m_ofs.open( filename.c_str() );
+                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
+            }
+            ~FileStream() override = default;
+        public: // IStream
+            std::ostream& stream() const override {
+                return m_ofs;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class CoutStream : public IStream {
+            mutable std::ostream m_os;
+        public:
+            // Store the streambuf from cout up-front because
+            // cout may get redirected when running tests
+            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
+            ~CoutStream() override = default;
+
+        public: // IStream
+            std::ostream& stream() const override { return m_os; }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class DebugOutStream : public IStream {
+            std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
+            mutable std::ostream m_os;
+        public:
+            DebugOutStream()
+            :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
+                m_os( m_streamBuf.get() )
+            {}
+
+            ~DebugOutStream() override = default;
+
+        public: // IStream
+            std::ostream& stream() const override { return m_os; }
+        };
+
+    }} // namespace anon::detail
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    auto makeStream( StringRef const &filename ) -> IStream const* {
+        if( filename.empty() )
+            return new Detail::CoutStream();
+        else if( filename[0] == '%' ) {
+            if( filename == "%debug" )
+                return new Detail::DebugOutStream();
+            else
+                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
+        }
+        else
+            return new Detail::FileStream( filename );
+    }
+
+    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
+    struct StringStreams {
+        std::vector<std::unique_ptr<std::ostringstream>> m_streams;
+        std::vector<std::size_t> m_unused;
+        std::ostringstream m_referenceStream; // Used for copy state/ flags from
+
+        auto add() -> std::size_t {
+            if( m_unused.empty() ) {
+                m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
+                return m_streams.size()-1;
+            }
+            else {
+                auto index = m_unused.back();
+                m_unused.pop_back();
+                return index;
+            }
+        }
+
+        void release( std::size_t index ) {
+            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
+            m_unused.push_back(index);
+        }
+    };
+
+    ReusableStringStream::ReusableStringStream()
+    :   m_index( Singleton<StringStreams>::getMutable().add() ),
+        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
+    {}
+
+    ReusableStringStream::~ReusableStringStream() {
+        static_cast<std::ostringstream*>( m_oss )->str("");
+        m_oss->clear();
+        Singleton<StringStreams>::getMutable().release( m_index );
+    }
+
+    auto ReusableStringStream::str() const -> std::string {
+        return static_cast<std::ostringstream*>( m_oss )->str();
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
+    std::ostream& cout() { return std::cout; }
+    std::ostream& cerr() { return std::cerr; }
+    std::ostream& clog() { return std::clog; }
+#endif
+}
+// end catch_stream.cpp
+// start catch_string_manip.cpp
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cctype>
+#include <vector>
+
+namespace Catch {
+
+    namespace {
+        char toLowerCh(char c) {
+            return static_cast<char>( std::tolower( c ) );
+        }
+    }
+
+    bool startsWith( std::string const& s, std::string const& prefix ) {
+        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
+    }
+    bool startsWith( std::string const& s, char prefix ) {
+        return !s.empty() && s[0] == prefix;
+    }
+    bool endsWith( std::string const& s, std::string const& suffix ) {
+        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
+    }
+    bool endsWith( std::string const& s, char suffix ) {
+        return !s.empty() && s[s.size()-1] == suffix;
+    }
+    bool contains( std::string const& s, std::string const& infix ) {
+        return s.find( infix ) != std::string::npos;
+    }
+    void toLowerInPlace( std::string& s ) {
+        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
+    }
+    std::string toLower( std::string const& s ) {
+        std::string lc = s;
+        toLowerInPlace( lc );
+        return lc;
+    }
+    std::string trim( std::string const& str ) {
+        static char const* whitespaceChars = "\n\r\t ";
+        std::string::size_type start = str.find_first_not_of( whitespaceChars );
+        std::string::size_type end = str.find_last_not_of( whitespaceChars );
+
+        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
+    }
+
+    StringRef trim(StringRef ref) {
+        const auto is_ws = [](char c) {
+            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+        };
+        size_t real_begin = 0;
+        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
+        size_t real_end = ref.size();
+        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
+
+        return ref.substr(real_begin, real_end - real_begin);
+    }
+
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+        bool replaced = false;
+        std::size_t i = str.find( replaceThis );
+        while( i != std::string::npos ) {
+            replaced = true;
+            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
+            if( i < str.size()-withThis.size() )
+                i = str.find( replaceThis, i+withThis.size() );
+            else
+                i = std::string::npos;
+        }
+        return replaced;
+    }
+
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
+        std::vector<StringRef> subStrings;
+        std::size_t start = 0;
+        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
+            if( str[pos] == delimiter ) {
+                if( pos - start > 1 )
+                    subStrings.push_back( str.substr( start, pos-start ) );
+                start = pos+1;
+            }
+        }
+        if( start < str.size() )
+            subStrings.push_back( str.substr( start, str.size()-start ) );
+        return subStrings;
+    }
+
+    pluralise::pluralise( std::size_t count, std::string const& label )
+    :   m_count( count ),
+        m_label( label )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+        os << pluraliser.m_count << ' ' << pluraliser.m_label;
+        if( pluraliser.m_count != 1 )
+            os << 's';
+        return os;
+    }
+
+}
+// end catch_string_manip.cpp
+// start catch_stringref.cpp
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cstdint>
+
+namespace Catch {
+    StringRef::StringRef( char const* rawChars ) noexcept
+    : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
+    {}
+
+    auto StringRef::c_str() const -> char const* {
+        CATCH_ENFORCE(isNullTerminated(), "Called StringRef::c_str() on a non-null-terminated instance");
+        return m_start;
+    }
+    auto StringRef::data() const noexcept -> char const* {
+        return m_start;
+    }
+
+    auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
+        if (start < m_size) {
+            return StringRef(m_start + start, (std::min)(m_size - start, size));
+        } else {
+            return StringRef();
+        }
+    }
+    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
+        return m_size == other.m_size
+            && (std::memcmp( m_start, other.m_start, m_size ) == 0);
+    }
+
+    auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
+        return os.write(str.data(), str.size());
+    }
+
+    auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
+        lhs.append(rhs.data(), rhs.size());
+        return lhs;
+    }
+
+} // namespace Catch
+// end catch_stringref.cpp
+// start catch_tag_alias.cpp
+
+namespace Catch {
+    TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
+}
+// end catch_tag_alias.cpp
+// start catch_tag_alias_autoregistrar.cpp
+
+namespace Catch {
+
+    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
+        CATCH_TRY {
+            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+
+}
+// end catch_tag_alias_autoregistrar.cpp
+// start catch_tag_alias_registry.cpp
+
+#include <sstream>
+
+namespace Catch {
+
+    TagAliasRegistry::~TagAliasRegistry() {}
+
+    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
+        auto it = m_registry.find( alias );
+        if( it != m_registry.end() )
+            return &(it->second);
+        else
+            return nullptr;
+    }
+
+    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+        std::string expandedTestSpec = unexpandedTestSpec;
+        for( auto const& registryKvp : m_registry ) {
+            std::size_t pos = expandedTestSpec.find( registryKvp.first );
+            if( pos != std::string::npos ) {
+                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
+                                    registryKvp.second.tag +
+                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
+            }
+        }
+        return expandedTestSpec;
+    }
+
+    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
+        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
+                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
+
+        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
+                      "error: tag alias, '" << alias << "' already registered.\n"
+                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
+                      << "\tRedefined at: " << lineInfo );
+    }
+
+    ITagAliasRegistry::~ITagAliasRegistry() {}
+
+    ITagAliasRegistry const& ITagAliasRegistry::get() {
+        return getRegistryHub().getTagAliasRegistry();
+    }
+
+} // end namespace Catch
+// end catch_tag_alias_registry.cpp
+// start catch_test_case_info.cpp
+
+#include <cctype>
+#include <exception>
+#include <algorithm>
+#include <sstream>
+
+namespace Catch {
+
+    namespace {
+        TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
+            if( startsWith( tag, '.' ) ||
+                tag == "!hide" )
+                return TestCaseInfo::IsHidden;
+            else if( tag == "!throws" )
+                return TestCaseInfo::Throws;
+            else if( tag == "!shouldfail" )
+                return TestCaseInfo::ShouldFail;
+            else if( tag == "!mayfail" )
+                return TestCaseInfo::MayFail;
+            else if( tag == "!nonportable" )
+                return TestCaseInfo::NonPortable;
+            else if( tag == "!benchmark" )
+                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
+            else
+                return TestCaseInfo::None;
+        }
+        bool isReservedTag( std::string const& tag ) {
+            return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
+        }
+        void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
+            CATCH_ENFORCE( !isReservedTag(tag),
+                          "Tag name: [" << tag << "] is not allowed.\n"
+                          << "Tag names starting with non alphanumeric characters are reserved\n"
+                          << _lineInfo );
+        }
+    }
+
+    TestCase makeTestCase(  ITestInvoker* _testCase,
+                            std::string const& _className,
+                            NameAndTags const& nameAndTags,
+                            SourceLineInfo const& _lineInfo )
+    {
+        bool isHidden = false;
+
+        // Parse out tags
+        std::vector<std::string> tags;
+        std::string desc, tag;
+        bool inTag = false;
+        for (char c : nameAndTags.tags) {
+            if( !inTag ) {
+                if( c == '[' )
+                    inTag = true;
+                else
+                    desc += c;
+            }
+            else {
+                if( c == ']' ) {
+                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
+                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
+                        isHidden = true;
+                    else if( prop == TestCaseInfo::None )
+                        enforceNotReservedTag( tag, _lineInfo );
+
+                    // Merged hide tags like `[.approvals]` should be added as
+                    // `[.][approvals]`. The `[.]` is added at later point, so
+                    // we only strip the prefix
+                    if (startsWith(tag, '.') && tag.size() > 1) {
+                        tag.erase(0, 1);
+                    }
+                    tags.push_back( tag );
+                    tag.clear();
+                    inTag = false;
+                }
+                else
+                    tag += c;
+            }
+        }
+        if( isHidden ) {
+            // Add all "hidden" tags to make them behave identically
+            tags.insert( tags.end(), { ".", "!hide" } );
+        }
+
+        TestCaseInfo info( static_cast<std::string>(nameAndTags.name), _className, desc, tags, _lineInfo );
+        return TestCase( _testCase, std::move(info) );
+    }
+
+    void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
+        std::sort(begin(tags), end(tags));
+        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
+        testCaseInfo.lcaseTags.clear();
+
+        for( auto const& tag : tags ) {
+            std::string lcaseTag = toLower( tag );
+            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
+            testCaseInfo.lcaseTags.push_back( lcaseTag );
+        }
+        testCaseInfo.tags = std::move(tags);
+    }
+
+    TestCaseInfo::TestCaseInfo( std::string const& _name,
+                                std::string const& _className,
+                                std::string const& _description,
+                                std::vector<std::string> const& _tags,
+                                SourceLineInfo const& _lineInfo )
+    :   name( _name ),
+        className( _className ),
+        description( _description ),
+        lineInfo( _lineInfo ),
+        properties( None )
+    {
+        setTags( *this, _tags );
+    }
+
+    bool TestCaseInfo::isHidden() const {
+        return ( properties & IsHidden ) != 0;
+    }
+    bool TestCaseInfo::throws() const {
+        return ( properties & Throws ) != 0;
+    }
+    bool TestCaseInfo::okToFail() const {
+        return ( properties & (ShouldFail | MayFail ) ) != 0;
+    }
+    bool TestCaseInfo::expectedToFail() const {
+        return ( properties & (ShouldFail ) ) != 0;
+    }
+
+    std::string TestCaseInfo::tagsAsString() const {
+        std::string ret;
+        // '[' and ']' per tag
+        std::size_t full_size = 2 * tags.size();
+        for (const auto& tag : tags) {
+            full_size += tag.size();
+        }
+        ret.reserve(full_size);
+        for (const auto& tag : tags) {
+            ret.push_back('[');
+            ret.append(tag);
+            ret.push_back(']');
+        }
+
+        return ret;
+    }
+
+    TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
+
+    TestCase TestCase::withName( std::string const& _newName ) const {
+        TestCase other( *this );
+        other.name = _newName;
+        return other;
+    }
+
+    void TestCase::invoke() const {
+        test->invoke();
+    }
+
+    bool TestCase::operator == ( TestCase const& other ) const {
+        return  test.get() == other.test.get() &&
+                name == other.name &&
+                className == other.className;
+    }
+
+    bool TestCase::operator < ( TestCase const& other ) const {
+        return name < other.name;
+    }
+
+    TestCaseInfo const& TestCase::getTestCaseInfo() const
+    {
+        return *this;
+    }
+
+} // end namespace Catch
+// end catch_test_case_info.cpp
+// start catch_test_case_registry_impl.cpp
+
+#include <sstream>
+
+namespace Catch {
+
+    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
+
+        std::vector<TestCase> sorted = unsortedTestCases;
+
+        switch( config.runOrder() ) {
+            case RunTests::InLexicographicalOrder:
+                std::sort( sorted.begin(), sorted.end() );
+                break;
+            case RunTests::InRandomOrder:
+                seedRng( config );
+                std::shuffle( sorted.begin(), sorted.end(), rng() );
+                break;
+            case RunTests::InDeclarationOrder:
+                // already in declaration order
+                break;
+        }
+        return sorted;
+    }
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config ) {
+        return !testCase.throws() || config.allowThrows();
+    }
+
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
+        return testSpec.matches( testCase ) && isThrowSafe( testCase, config );
+    }
+
+    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
+        std::set<TestCase> seenFunctions;
+        for( auto const& function : functions ) {
+            auto prev = seenFunctions.insert( function );
+            CATCH_ENFORCE( prev.second,
+                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
+                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
+                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
+        }
+    }
+
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
+        std::vector<TestCase> filtered;
+        filtered.reserve( testCases.size() );
+        for (auto const& testCase : testCases) {
+            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
+                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
+                filtered.push_back(testCase);
+            }
+        }
+        return filtered;
+    }
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
+        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
+    }
+
+    void TestRegistry::registerTest( TestCase const& testCase ) {
+        std::string name = testCase.getTestCaseInfo().name;
+        if( name.empty() ) {
+            ReusableStringStream rss;
+            rss << "Anonymous test case " << ++m_unnamedCount;
+            return registerTest( testCase.withName( rss.str() ) );
+        }
+        m_functions.push_back( testCase );
+    }
+
+    std::vector<TestCase> const& TestRegistry::getAllTests() const {
+        return m_functions;
+    }
+    std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
+        if( m_sortedFunctions.empty() )
+            enforceNoDuplicateTestCases( m_functions );
+
+        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
+            m_sortedFunctions = sortTests( config, m_functions );
+            m_currentSortOrder = config.runOrder();
+        }
+        return m_sortedFunctions;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
+
+    void TestInvokerAsFunction::invoke() const {
+        m_testAsFunction();
+    }
+
+    std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
+        std::string className(classOrQualifiedMethodName);
+        if( startsWith( className, '&' ) )
+        {
+            std::size_t lastColons = className.rfind( "::" );
+            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
+            if( penultimateColons == std::string::npos )
+                penultimateColons = 1;
+            className = className.substr( penultimateColons, lastColons-penultimateColons );
+        }
+        return className;
+    }
+
+} // end namespace Catch
+// end catch_test_case_registry_impl.cpp
+// start catch_test_case_tracker.cpp
+
+#include <algorithm>
+#include <cassert>
+#include <stdexcept>
+#include <memory>
+#include <sstream>
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
+    :   name( _name ),
+        location( _location )
+    {}
+
+    ITracker::~ITracker() = default;
+
+    ITracker& TrackerContext::startRun() {
+        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
+        m_currentTracker = nullptr;
+        m_runState = Executing;
+        return *m_rootTracker;
+    }
+
+    void TrackerContext::endRun() {
+        m_rootTracker.reset();
+        m_currentTracker = nullptr;
+        m_runState = NotStarted;
+    }
+
+    void TrackerContext::startCycle() {
+        m_currentTracker = m_rootTracker.get();
+        m_runState = Executing;
+    }
+    void TrackerContext::completeCycle() {
+        m_runState = CompletedCycle;
+    }
+
+    bool TrackerContext::completedCycle() const {
+        return m_runState == CompletedCycle;
+    }
+    ITracker& TrackerContext::currentTracker() {
+        return *m_currentTracker;
+    }
+    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
+        m_currentTracker = tracker;
+    }
+
+    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+    :   m_nameAndLocation( nameAndLocation ),
+        m_ctx( ctx ),
+        m_parent( parent )
+    {}
+
+    NameAndLocation const& TrackerBase::nameAndLocation() const {
+        return m_nameAndLocation;
+    }
+    bool TrackerBase::isComplete() const {
+        return m_runState == CompletedSuccessfully || m_runState == Failed;
+    }
+    bool TrackerBase::isSuccessfullyCompleted() const {
+        return m_runState == CompletedSuccessfully;
+    }
+    bool TrackerBase::isOpen() const {
+        return m_runState != NotStarted && !isComplete();
+    }
+    bool TrackerBase::hasChildren() const {
+        return !m_children.empty();
+    }
+
+    void TrackerBase::addChild( ITrackerPtr const& child ) {
+        m_children.push_back( child );
+    }
+
+    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
+        auto it = std::find_if( m_children.begin(), m_children.end(),
+            [&nameAndLocation]( ITrackerPtr const& tracker ){
+                return
+                    tracker->nameAndLocation().location == nameAndLocation.location &&
+                    tracker->nameAndLocation().name == nameAndLocation.name;
+            } );
+        return( it != m_children.end() )
+            ? *it
+            : nullptr;
+    }
+    ITracker& TrackerBase::parent() {
+        assert( m_parent ); // Should always be non-null except for root
+        return *m_parent;
+    }
+
+    void TrackerBase::openChild() {
+        if( m_runState != ExecutingChildren ) {
+            m_runState = ExecutingChildren;
+            if( m_parent )
+                m_parent->openChild();
+        }
+    }
+
+    bool TrackerBase::isSectionTracker() const { return false; }
+    bool TrackerBase::isGeneratorTracker() const { return false; }
+
+    void TrackerBase::open() {
+        m_runState = Executing;
+        moveToThis();
+        if( m_parent )
+            m_parent->openChild();
+    }
+
+    void TrackerBase::close() {
+
+        // Close any still open children (e.g. generators)
+        while( &m_ctx.currentTracker() != this )
+            m_ctx.currentTracker().close();
+
+        switch( m_runState ) {
+            case NeedsAnotherRun:
+                break;
+
+            case Executing:
+                m_runState = CompletedSuccessfully;
+                break;
+            case ExecutingChildren:
+                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
+                    m_runState = CompletedSuccessfully;
+                break;
+
+            case NotStarted:
+            case CompletedSuccessfully:
+            case Failed:
+                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
+
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
+        }
+        moveToParent();
+        m_ctx.completeCycle();
+    }
+    void TrackerBase::fail() {
+        m_runState = Failed;
+        if( m_parent )
+            m_parent->markAsNeedingAnotherRun();
+        moveToParent();
+        m_ctx.completeCycle();
+    }
+    void TrackerBase::markAsNeedingAnotherRun() {
+        m_runState = NeedsAnotherRun;
+    }
+
+    void TrackerBase::moveToParent() {
+        assert( m_parent );
+        m_ctx.setCurrentTracker( m_parent );
+    }
+    void TrackerBase::moveToThis() {
+        m_ctx.setCurrentTracker( this );
+    }
+
+    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+    :   TrackerBase( nameAndLocation, ctx, parent ),
+        m_trimmed_name(trim(nameAndLocation.name))
+    {
+        if( parent ) {
+            while( !parent->isSectionTracker() )
+                parent = &parent->parent();
+
+            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
+            addNextFilters( parentSection.m_filters );
+        }
+    }
+
+    bool SectionTracker::isComplete() const {
+        bool complete = true;
+
+        if ((m_filters.empty() || m_filters[0] == "")
+            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
+            complete = TrackerBase::isComplete();
+        }
+        return complete;
+    }
+
+    bool SectionTracker::isSectionTracker() const { return true; }
+
+    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
+        std::shared_ptr<SectionTracker> section;
+
+        ITracker& currentTracker = ctx.currentTracker();
+        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+            assert( childTracker );
+            assert( childTracker->isSectionTracker() );
+            section = std::static_pointer_cast<SectionTracker>( childTracker );
+        }
+        else {
+            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
+            currentTracker.addChild( section );
+        }
+        if( !ctx.completedCycle() )
+            section->tryOpen();
+        return *section;
+    }
+
+    void SectionTracker::tryOpen() {
+        if( !isComplete() )
+            open();
+    }
+
+    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
+        if( !filters.empty() ) {
+            m_filters.reserve( m_filters.size() + filters.size() + 2 );
+            m_filters.emplace_back(""); // Root - should never be consulted
+            m_filters.emplace_back(""); // Test Case - not a section filter
+            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
+        }
+    }
+    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
+        if( filters.size() > 1 )
+            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
+    }
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+
+} // namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+// end catch_test_case_tracker.cpp
+// start catch_test_registry.cpp
+
+namespace Catch {
+
+    auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
+        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
+    }
+
+    NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
+
+    AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
+        CATCH_TRY {
+            getMutableRegistryHub()
+                    .registerTest(
+                        makeTestCase(
+                            invoker,
+                            extractClassName( classOrMethod ),
+                            nameAndTags,
+                            lineInfo));
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+
+    AutoReg::~AutoReg() = default;
+}
+// end catch_test_registry.cpp
+// start catch_test_spec.cpp
+
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    TestSpec::Pattern::Pattern( std::string const& name )
+    : m_name( name )
+    {}
+
+    TestSpec::Pattern::~Pattern() = default;
+
+    std::string const& TestSpec::Pattern::name() const {
+        return m_name;
+    }
+
+    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
+    : Pattern( filterString )
+    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
+    {}
+
+    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
+        return m_wildcardPattern.matches( testCase.name );
+    }
+
+    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
+    : Pattern( filterString )
+    , m_tag( toLower( tag ) )
+    {}
+
+    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
+        return std::find(begin(testCase.lcaseTags),
+                         end(testCase.lcaseTags),
+                         m_tag) != end(testCase.lcaseTags);
+    }
+
+    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern )
+    : Pattern( underlyingPattern->name() )
+    , m_underlyingPattern( underlyingPattern )
+    {}
+
+    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const {
+        return !m_underlyingPattern->matches( testCase );
+    }
+
+    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
+        return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
+    }
+
+    std::string TestSpec::Filter::name() const {
+        std::string name;
+        for( auto const& p : m_patterns )
+            name += p->name();
+        return name;
+    }
+
+    bool TestSpec::hasFilters() const {
+        return !m_filters.empty();
+    }
+
+    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
+        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
+    }
+
+    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
+    {
+        Matches matches( m_filters.size() );
+        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
+            std::vector<TestCase const*> currentMatches;
+            for( auto const& test : testCases )
+                if( isThrowSafe( test, config ) && filter.matches( test ) )
+                    currentMatches.emplace_back( &test );
+            return FilterMatch{ filter.name(), currentMatches };
+        } );
+        return matches;
+    }
+
+    const TestSpec::vectorStrings& TestSpec::getInvalidArgs() const{
+        return  (m_invalidArgs);
+    }
+
+}
+// end catch_test_spec.cpp
+// start catch_test_spec_parser.cpp
+
+namespace Catch {
+
+    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+
+    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
+        m_mode = None;
+        m_exclusion = false;
+        m_arg = m_tagAliases->expandAliases( arg );
+        m_escapeChars.clear();
+        m_substring.reserve(m_arg.size());
+        m_patternName.reserve(m_arg.size());
+        m_realPatternPos = 0;
+
+        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+          //if visitChar fails
+           if( !visitChar( m_arg[m_pos] ) ){
+               m_testSpec.m_invalidArgs.push_back(arg);
+               break;
+           }
+        endMode();
+        return *this;
+    }
+    TestSpec TestSpecParser::testSpec() {
+        addFilter();
+        return m_testSpec;
+    }
+    bool TestSpecParser::visitChar( char c ) {
+        if( (m_mode != EscapedName) && (c == '\\') ) {
+            escape();
+            addCharToPattern(c);
+            return true;
+        }else if((m_mode != EscapedName) && (c == ',') )  {
+            return separate();
+        }
+
+        switch( m_mode ) {
+        case None:
+            if( processNoneChar( c ) )
+                return true;
+            break;
+        case Name:
+            processNameChar( c );
+            break;
+        case EscapedName:
+            endMode();
+            addCharToPattern(c);
+            return true;
+        default:
+        case Tag:
+        case QuotedName:
+            if( processOtherChar( c ) )
+                return true;
+            break;
+        }
+
+        m_substring += c;
+        if( !isControlChar( c ) ) {
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+        return true;
+    }
+    // Two of the processing methods return true to signal the caller to return
+    // without adding the given character to the current pattern strings
+    bool TestSpecParser::processNoneChar( char c ) {
+        switch( c ) {
+        case ' ':
+            return true;
+        case '~':
+            m_exclusion = true;
+            return false;
+        case '[':
+            startNewMode( Tag );
+            return false;
+        case '"':
+            startNewMode( QuotedName );
+            return false;
+        default:
+            startNewMode( Name );
+            return false;
+        }
+    }
+    void TestSpecParser::processNameChar( char c ) {
+        if( c == '[' ) {
+            if( m_substring == "exclude:" )
+                m_exclusion = true;
+            else
+                endMode();
+            startNewMode( Tag );
+        }
+    }
+    bool TestSpecParser::processOtherChar( char c ) {
+        if( !isControlChar( c ) )
+            return false;
+        m_substring += c;
+        endMode();
+        return true;
+    }
+    void TestSpecParser::startNewMode( Mode mode ) {
+        m_mode = mode;
+    }
+    void TestSpecParser::endMode() {
+        switch( m_mode ) {
+        case Name:
+        case QuotedName:
+            return addNamePattern();
+        case Tag:
+            return addTagPattern();
+        case EscapedName:
+            revertBackToLastMode();
+            return;
+        case None:
+        default:
+            return startNewMode( None );
+        }
+    }
+    void TestSpecParser::escape() {
+        saveLastMode();
+        m_mode = EscapedName;
+        m_escapeChars.push_back(m_realPatternPos);
+    }
+    bool TestSpecParser::isControlChar( char c ) const {
+        switch( m_mode ) {
+            default:
+                return false;
+            case None:
+                return c == '~';
+            case Name:
+                return c == '[';
+            case EscapedName:
+                return true;
+            case QuotedName:
+                return c == '"';
+            case Tag:
+                return c == '[' || c == ']';
+        }
+    }
+
+    void TestSpecParser::addFilter() {
+        if( !m_currentFilter.m_patterns.empty() ) {
+            m_testSpec.m_filters.push_back( m_currentFilter );
+            m_currentFilter = TestSpec::Filter();
+        }
+    }
+
+    void TestSpecParser::saveLastMode() {
+      lastMode = m_mode;
+    }
+
+    void TestSpecParser::revertBackToLastMode() {
+      m_mode = lastMode;
+    }
+
+    bool TestSpecParser::separate() {
+      if( (m_mode==QuotedName) || (m_mode==Tag) ){
+         //invalid argument, signal failure to previous scope.
+         m_mode = None;
+         m_pos = m_arg.size();
+         m_substring.clear();
+         m_patternName.clear();
+         return false;
+      }
+      endMode();
+      addFilter();
+      return true; //success
+    }
+
+    std::string TestSpecParser::preprocessPattern() {
+        std::string token = m_patternName;
+        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
+            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
+        m_escapeChars.clear();
+        if (startsWith(token, "exclude:")) {
+            m_exclusion = true;
+            token = token.substr(8);
+        }
+
+        m_patternName.clear();
+
+        return token;
+    }
+
+    void TestSpecParser::addNamePattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
+            if (m_exclusion)
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    void TestSpecParser::addTagPattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
+            // we have to create a separate hide tag and shorten the real one
+            if (token.size() > 1 && token[0] == '.') {
+                token.erase(token.begin());
+                TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
+                if (m_exclusion) {
+                    pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+                }
+                m_currentFilter.m_patterns.push_back(pattern);
+            }
+
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);
+
+            if (m_exclusion) {
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            }
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    TestSpec parseTestSpec( std::string const& arg ) {
+        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
+    }
+
+} // namespace Catch
+// end catch_test_spec_parser.cpp
+// start catch_timer.cpp
+
+#include <chrono>
+
+static const uint64_t nanosecondsInSecond = 1000000000;
+
+namespace Catch {
+
+    auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
+        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
+    }
+
+    namespace {
+        auto estimateClockResolution() -> uint64_t {
+            uint64_t sum = 0;
+            static const uint64_t iterations = 1000000;
+
+            auto startTime = getCurrentNanosecondsSinceEpoch();
+
+            for( std::size_t i = 0; i < iterations; ++i ) {
+
+                uint64_t ticks;
+                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
+                do {
+                    ticks = getCurrentNanosecondsSinceEpoch();
+                } while( ticks == baseTicks );
+
+                auto delta = ticks - baseTicks;
+                sum += delta;
+
+                // If we have been calibrating for over 3 seconds -- the clock
+                // is terrible and we should move on.
+                // TBD: How to signal that the measured resolution is probably wrong?
+                if (ticks > startTime + 3 * nanosecondsInSecond) {
+                    return sum / ( i + 1u );
+                }
+            }
+
+            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
+            // - and potentially do more iterations if there's a high variance.
+            return sum/iterations;
+        }
+    }
+    auto getEstimatedClockResolution() -> uint64_t {
+        static auto s_resolution = estimateClockResolution();
+        return s_resolution;
+    }
+
+    void Timer::start() {
+       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
+    }
+    auto Timer::getElapsedNanoseconds() const -> uint64_t {
+        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
+    }
+    auto Timer::getElapsedMicroseconds() const -> uint64_t {
+        return getElapsedNanoseconds()/1000;
+    }
+    auto Timer::getElapsedMilliseconds() const -> unsigned int {
+        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
+    }
+    auto Timer::getElapsedSeconds() const -> double {
+        return getElapsedMicroseconds()/1000000.0;
+    }
+
+} // namespace Catch
+// end catch_timer.cpp
+// start catch_tostring.cpp
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#    pragma clang diagnostic ignored "-Wglobal-constructors"
+#endif
+
+// Enable specific decls locally
+#if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#endif
+
+#include <cmath>
+#include <iomanip>
+
+namespace Catch {
+
+namespace Detail {
+
+    const std::string unprintableString = "{?}";
+
+    namespace {
+        const int hexThreshold = 255;
+
+        struct Endianness {
+            enum Arch { Big, Little };
+
+            static Arch which() {
+                int one = 1;
+                // If the lowest byte we read is non-zero, we can assume
+                // that little endian format is used.
+                auto value = *reinterpret_cast<char*>(&one);
+                return value ? Little : Big;
+            }
+        };
+    }
+
+    std::string rawMemoryToString( const void *object, std::size_t size ) {
+        // Reverse order for little endian architectures
+        int i = 0, end = static_cast<int>( size ), inc = 1;
+        if( Endianness::which() == Endianness::Little ) {
+            i = end-1;
+            end = inc = -1;
+        }
+
+        unsigned char const *bytes = static_cast<unsigned char const *>(object);
+        ReusableStringStream rss;
+        rss << "0x" << std::setfill('0') << std::hex;
+        for( ; i != end; i += inc )
+             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
+       return rss.str();
+    }
+}
+
+template<typename T>
+std::string fpToString( T value, int precision ) {
+    if (Catch::isnan(value)) {
+        return "nan";
+    }
+
+    ReusableStringStream rss;
+    rss << std::setprecision( precision )
+        << std::fixed
+        << value;
+    std::string d = rss.str();
+    std::size_t i = d.find_last_not_of( '0' );
+    if( i != std::string::npos && i != d.size()-1 ) {
+        if( d[i] == '.' )
+            i++;
+        d = d.substr( 0, i+1 );
+    }
+    return d;
+}
+
+//// ======================================================= ////
+//
+//   Out-of-line defs for full specialization of StringMaker
+//
+//// ======================================================= ////
+
+std::string StringMaker<std::string>::convert(const std::string& str) {
+    if (!getCurrentContext().getConfig()->showInvisibles()) {
+        return '"' + str + '"';
+    }
+
+    std::string s("\"");
+    for (char c : str) {
+        switch (c) {
+        case '\n':
+            s.append("\\n");
+            break;
+        case '\t':
+            s.append("\\t");
+            break;
+        default:
+            s.push_back(c);
+            break;
+        }
+    }
+    s.append("\"");
+    return s;
+}
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::string_view>::convert(std::string_view str) {
+    return ::Catch::Detail::stringify(std::string{ str });
+}
+#endif
+
+std::string StringMaker<char const*>::convert(char const* str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::string{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<char*>::convert(char* str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::string{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+
+#ifdef CATCH_CONFIG_WCHAR
+std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
+    std::string s;
+    s.reserve(wstr.size());
+    for (auto c : wstr) {
+        s += (c <= 0xff) ? static_cast<char>(c) : '?';
+    }
+    return ::Catch::Detail::stringify(s);
+}
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
+    return StringMaker<std::wstring>::convert(std::wstring(str));
+}
+# endif
+
+std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::wstring{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::wstring{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+#endif
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+#include <cstddef>
+std::string StringMaker<std::byte>::convert(std::byte value) {
+    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
+}
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+
+std::string StringMaker<int>::convert(int value) {
+    return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long>::convert(long value) {
+    return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long long>::convert(long long value) {
+    ReusableStringStream rss;
+    rss << value;
+    if (value > Detail::hexThreshold) {
+        rss << " (0x" << std::hex << value << ')';
+    }
+    return rss.str();
+}
+
+std::string StringMaker<unsigned int>::convert(unsigned int value) {
+    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long>::convert(unsigned long value) {
+    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
+    ReusableStringStream rss;
+    rss << value;
+    if (value > Detail::hexThreshold) {
+        rss << " (0x" << std::hex << value << ')';
+    }
+    return rss.str();
+}
+
+std::string StringMaker<bool>::convert(bool b) {
+    return b ? "true" : "false";
+}
+
+std::string StringMaker<signed char>::convert(signed char value) {
+    if (value == '\r') {
+        return "'\\r'";
+    } else if (value == '\f') {
+        return "'\\f'";
+    } else if (value == '\n') {
+        return "'\\n'";
+    } else if (value == '\t') {
+        return "'\\t'";
+    } else if ('\0' <= value && value < ' ') {
+        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
+    } else {
+        char chstr[] = "' '";
+        chstr[1] = value;
+        return chstr;
+    }
+}
+std::string StringMaker<char>::convert(char c) {
+    return ::Catch::Detail::stringify(static_cast<signed char>(c));
+}
+std::string StringMaker<unsigned char>::convert(unsigned char c) {
+    return ::Catch::Detail::stringify(static_cast<char>(c));
+}
+
+std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
+    return "nullptr";
+}
+
+int StringMaker<float>::precision = 5;
+
+std::string StringMaker<float>::convert(float value) {
+    return fpToString(value, precision) + 'f';
+}
+
+int StringMaker<double>::precision = 10;
+
+std::string StringMaker<double>::convert(double value) {
+    return fpToString(value, precision);
+}
+
+std::string ratio_string<std::atto>::symbol() { return "a"; }
+std::string ratio_string<std::femto>::symbol() { return "f"; }
+std::string ratio_string<std::pico>::symbol() { return "p"; }
+std::string ratio_string<std::nano>::symbol() { return "n"; }
+std::string ratio_string<std::micro>::symbol() { return "u"; }
+std::string ratio_string<std::milli>::symbol() { return "m"; }
+
+} // end namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+// end catch_tostring.cpp
+// start catch_totals.cpp
+
+namespace Catch {
+
+    Counts Counts::operator - ( Counts const& other ) const {
+        Counts diff;
+        diff.passed = passed - other.passed;
+        diff.failed = failed - other.failed;
+        diff.failedButOk = failedButOk - other.failedButOk;
+        return diff;
+    }
+
+    Counts& Counts::operator += ( Counts const& other ) {
+        passed += other.passed;
+        failed += other.failed;
+        failedButOk += other.failedButOk;
+        return *this;
+    }
+
+    std::size_t Counts::total() const {
+        return passed + failed + failedButOk;
+    }
+    bool Counts::allPassed() const {
+        return failed == 0 && failedButOk == 0;
+    }
+    bool Counts::allOk() const {
+        return failed == 0;
+    }
+
+    Totals Totals::operator - ( Totals const& other ) const {
+        Totals diff;
+        diff.assertions = assertions - other.assertions;
+        diff.testCases = testCases - other.testCases;
+        return diff;
+    }
+
+    Totals& Totals::operator += ( Totals const& other ) {
+        assertions += other.assertions;
+        testCases += other.testCases;
+        return *this;
+    }
+
+    Totals Totals::delta( Totals const& prevTotals ) const {
+        Totals diff = *this - prevTotals;
+        if( diff.assertions.failed > 0 )
+            ++diff.testCases.failed;
+        else if( diff.assertions.failedButOk > 0 )
+            ++diff.testCases.failedButOk;
+        else
+            ++diff.testCases.passed;
+        return diff;
+    }
+
+}
+// end catch_totals.cpp
+// start catch_uncaught_exceptions.cpp
+
+#include <exception>
+
+namespace Catch {
+    bool uncaught_exceptions() {
+#if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+        return std::uncaught_exceptions() > 0;
+#else
+        return std::uncaught_exception();
+#endif
+  }
+} // end namespace Catch
+// end catch_uncaught_exceptions.cpp
+// start catch_version.cpp
+
+#include <ostream>
+
+namespace Catch {
+
+    Version::Version
+        (   unsigned int _majorVersion,
+            unsigned int _minorVersion,
+            unsigned int _patchNumber,
+            char const * const _branchName,
+            unsigned int _buildNumber )
+    :   majorVersion( _majorVersion ),
+        minorVersion( _minorVersion ),
+        patchNumber( _patchNumber ),
+        branchName( _branchName ),
+        buildNumber( _buildNumber )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, Version const& version ) {
+        os  << version.majorVersion << '.'
+            << version.minorVersion << '.'
+            << version.patchNumber;
+        // branchName is never null -> 0th char is \0 if it is empty
+        if (version.branchName[0]) {
+            os << '-' << version.branchName
+               << '.' << version.buildNumber;
+        }
+        return os;
+    }
+
+    Version const& libraryVersion() {
+        static Version version( 2, 11, 3, "", 0 );
+        return version;
+    }
+
+}
+// end catch_version.cpp
+// start catch_wildcard_pattern.cpp
+
+namespace Catch {
+
+    WildcardPattern::WildcardPattern( std::string const& pattern,
+                                      CaseSensitive::Choice caseSensitivity )
+    :   m_caseSensitivity( caseSensitivity ),
+        m_pattern( normaliseString( pattern ) )
+    {
+        if( startsWith( m_pattern, '*' ) ) {
+            m_pattern = m_pattern.substr( 1 );
+            m_wildcard = WildcardAtStart;
+        }
+        if( endsWith( m_pattern, '*' ) ) {
+            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
+            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+        }
+    }
+
+    bool WildcardPattern::matches( std::string const& str ) const {
+        switch( m_wildcard ) {
+            case NoWildcard:
+                return m_pattern == normaliseString( str );
+            case WildcardAtStart:
+                return endsWith( normaliseString( str ), m_pattern );
+            case WildcardAtEnd:
+                return startsWith( normaliseString( str ), m_pattern );
+            case WildcardAtBothEnds:
+                return contains( normaliseString( str ), m_pattern );
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown enum" );
+        }
+    }
+
+    std::string WildcardPattern::normaliseString( std::string const& str ) const {
+        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
+    }
+}
+// end catch_wildcard_pattern.cpp
+// start catch_xmlwriter.cpp
+
+#include <iomanip>
+#include <type_traits>
+
+namespace Catch {
+
+namespace {
+
+    size_t trailingBytes(unsigned char c) {
+        if ((c & 0xE0) == 0xC0) {
+            return 2;
+        }
+        if ((c & 0xF0) == 0xE0) {
+            return 3;
+        }
+        if ((c & 0xF8) == 0xF0) {
+            return 4;
+        }
+        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    uint32_t headerValue(unsigned char c) {
+        if ((c & 0xE0) == 0xC0) {
+            return c & 0x1F;
+        }
+        if ((c & 0xF0) == 0xE0) {
+            return c & 0x0F;
+        }
+        if ((c & 0xF8) == 0xF0) {
+            return c & 0x07;
+        }
+        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    void hexEscapeChar(std::ostream& os, unsigned char c) {
+        std::ios_base::fmtflags f(os.flags());
+        os << "\\x"
+            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+            << static_cast<int>(c);
+        os.flags(f);
+    }
+
+    bool shouldNewline(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Newline));
+    }
+
+    bool shouldIndent(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Indent));
+    }
+
+} // anonymous namespace
+
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) |
+            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+        );
+    }
+
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) &
+            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+        );
+    }
+
+    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
+    :   m_str( str ),
+        m_forWhat( forWhat )
+    {}
+
+    void XmlEncode::encodeTo( std::ostream& os ) const {
+        // Apostrophe escaping not necessary if we always use " to write attributes
+        // (see: http://www.w3.org/TR/xml/#syntax)
+
+        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
+            unsigned char c = m_str[idx];
+            switch (c) {
+            case '<':   os << "&lt;"; break;
+            case '&':   os << "&amp;"; break;
+
+            case '>':
+                // See: http://www.w3.org/TR/xml/#syntax
+                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
+                    os << "&gt;";
+                else
+                    os << c;
+                break;
+
+            case '\"':
+                if (m_forWhat == ForAttributes)
+                    os << "&quot;";
+                else
+                    os << c;
+                break;
+
+            default:
+                // Check for control characters and invalid utf-8
+
+                // Escape control characters in standard ascii
+                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                // Plain ASCII: Write it to stream
+                if (c < 0x7F) {
+                    os << c;
+                    break;
+                }
+
+                // UTF-8 territory
+                // Check if the encoding is valid and if it is not, hex escape bytes.
+                // Important: We do not check the exact decoded values for validity, only the encoding format
+                // First check that this bytes is a valid lead byte:
+                // This means that it is not encoded as 1111 1XXX
+                // Or as 10XX XXXX
+                if (c <  0xC0 ||
+                    c >= 0xF8) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                auto encBytes = trailingBytes(c);
+                // Are there enough bytes left to avoid accessing out-of-bounds memory?
+                if (idx + encBytes - 1 >= m_str.size()) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+                // The header is valid, check data
+                // The next encBytes bytes must together be a valid utf-8
+                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
+                bool valid = true;
+                uint32_t value = headerValue(c);
+                for (std::size_t n = 1; n < encBytes; ++n) {
+                    unsigned char nc = m_str[idx + n];
+                    valid &= ((nc & 0xC0) == 0x80);
+                    value = (value << 6) | (nc & 0x3F);
+                }
+
+                if (
+                    // Wrong bit pattern of following bytes
+                    (!valid) ||
+                    // Overlong encodings
+                    (value < 0x80) ||
+                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
+                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
+                    // Encoded value out of range
+                    (value >= 0x110000)
+                    ) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                // If we got here, this is in fact a valid(ish) utf-8 sequence
+                for (std::size_t n = 0; n < encBytes; ++n) {
+                    os << m_str[idx + n];
+                }
+                idx += encBytes - 1;
+                break;
+            }
+        }
+    }
+
+    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
+        xmlEncode.encodeTo( os );
+        return os;
+    }
+
+    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
+    :   m_writer( writer ),
+        m_fmt(fmt)
+    {}
+
+    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
+    :   m_writer( other.m_writer ),
+        m_fmt(other.m_fmt)
+    {
+        other.m_writer = nullptr;
+        other.m_fmt = XmlFormatting::None;
+    }
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
+        if ( m_writer ) {
+            m_writer->endElement();
+        }
+        m_writer = other.m_writer;
+        other.m_writer = nullptr;
+        m_fmt = other.m_fmt;
+        other.m_fmt = XmlFormatting::None;
+        return *this;
+    }
+
+    XmlWriter::ScopedElement::~ScopedElement() {
+        if (m_writer) {
+            m_writer->endElement(m_fmt);
+        }
+    }
+
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, XmlFormatting fmt ) {
+        m_writer->writeText( text, fmt );
+        return *this;
+    }
+
+    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
+    {
+        writeDeclaration();
+    }
+
+    XmlWriter::~XmlWriter() {
+        while (!m_tags.empty()) {
+            endElement();
+        }
+        newlineIfNecessary();
+    }
+
+    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
+        ensureTagClosed();
+        newlineIfNecessary();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+            m_indent += "  ";
+        }
+        m_os << '<' << name;
+        m_tags.push_back( name );
+        m_tagIsOpen = true;
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
+        ScopedElement scoped( this, fmt );
+        startElement( name, fmt );
+        return scoped;
+    }
+
+    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
+        m_indent = m_indent.substr(0, m_indent.size() - 2);
+
+        if( m_tagIsOpen ) {
+            m_os << "/>";
+            m_tagIsOpen = false;
+        } else {
+            newlineIfNecessary();
+            if (shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << "</" << m_tags.back() << ">";
+        }
+        m_os << std::flush;
+        applyFormatting(fmt);
+        m_tags.pop_back();
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
+        if( !name.empty() && !attribute.empty() )
+            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
+        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
+        if( !text.empty() ){
+            bool tagWasOpen = m_tagIsOpen;
+            ensureTagClosed();
+            if (tagWasOpen && shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << XmlEncode( text );
+            applyFormatting(fmt);
+        }
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
+        ensureTagClosed();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+        }
+        m_os << "<!--" << text << "-->";
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    void XmlWriter::writeStylesheetRef( std::string const& url ) {
+        m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
+    }
+
+    XmlWriter& XmlWriter::writeBlankLine() {
+        ensureTagClosed();
+        m_os << '\n';
+        return *this;
+    }
+
+    void XmlWriter::ensureTagClosed() {
+        if( m_tagIsOpen ) {
+            m_os << '>' << std::flush;
+            newlineIfNecessary();
+            m_tagIsOpen = false;
+        }
+    }
+
+    void XmlWriter::applyFormatting(XmlFormatting fmt) {
+        m_needsNewline = shouldNewline(fmt);
+    }
+
+    void XmlWriter::writeDeclaration() {
+        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+    }
+
+    void XmlWriter::newlineIfNecessary() {
+        if( m_needsNewline ) {
+            m_os << std::endl;
+            m_needsNewline = false;
+        }
+    }
+}
+// end catch_xmlwriter.cpp
+// start catch_reporter_bases.cpp
+
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <cassert>
+#include <memory>
+
+namespace Catch {
+    void prepareExpandedExpression(AssertionResult& result) {
+        result.getExpandedExpression();
+    }
+
+    // Because formatting using c++ streams is stateful, drop down to C is required
+    // Alternatively we could use stringstream, but its performance is... not good.
+    std::string getFormattedDuration( double duration ) {
+        // Max exponent + 1 is required to represent the whole part
+        // + 1 for decimal point
+        // + 3 for the 3 decimal places
+        // + 1 for null terminator
+        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
+        char buffer[maxDoubleSize];
+
+        // Save previous errno, to prevent sprintf from overwriting it
+        ErrnoGuard guard;
+#ifdef _MSC_VER
+        sprintf_s(buffer, "%.3f", duration);
+#else
+        std::sprintf(buffer, "%.3f", duration);
+#endif
+        return std::string(buffer);
+    }
+
+    std::string serializeFilters( std::vector<std::string> const& container ) {
+        ReusableStringStream oss;
+        bool first = true;
+        for (auto&& filter : container)
+        {
+            if (!first)
+                oss << ' ';
+            else
+                first = false;
+
+            oss << filter;
+        }
+        return oss.str();
+    }
+
+    TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
+        :StreamingReporterBase(_config) {}
+
+    std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
+        return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
+    }
+
+    void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
+
+    bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
+        return false;
+    }
+
+} // end namespace Catch
+// end catch_reporter_bases.cpp
+// start catch_reporter_compact.cpp
+
+namespace {
+
+#ifdef CATCH_PLATFORM_MAC
+    const char* failedString() { return "FAILED"; }
+    const char* passedString() { return "PASSED"; }
+#else
+    const char* failedString() { return "failed"; }
+    const char* passedString() { return "passed"; }
+#endif
+
+    // Colour::LightGrey
+    Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
+
+    std::string bothOrAll( std::size_t count ) {
+        return count == 1 ? std::string() :
+               count == 2 ? "both " : "all " ;
+    }
+
+} // anon namespace
+
+namespace Catch {
+namespace {
+// Colour, message variants:
+// - white: No tests ran.
+// -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
+// - white: Passed [both/all] N test cases (no assertions).
+// -   red: Failed N tests cases, failed M assertions.
+// - green: Passed [both/all] N tests cases with M assertions.
+void printTotals(std::ostream& out, const Totals& totals) {
+    if (totals.testCases.total() == 0) {
+        out << "No tests ran.";
+    } else if (totals.testCases.failed == totals.testCases.total()) {
+        Colour colour(Colour::ResultError);
+        const std::string qualify_assertions_failed =
+            totals.assertions.failed == totals.assertions.total() ?
+            bothOrAll(totals.assertions.failed) : std::string();
+        out <<
+            "Failed " << bothOrAll(totals.testCases.failed)
+            << pluralise(totals.testCases.failed, "test case") << ", "
+            "failed " << qualify_assertions_failed <<
+            pluralise(totals.assertions.failed, "assertion") << '.';
+    } else if (totals.assertions.total() == 0) {
+        out <<
+            "Passed " << bothOrAll(totals.testCases.total())
+            << pluralise(totals.testCases.total(), "test case")
+            << " (no assertions).";
+    } else if (totals.assertions.failed) {
+        Colour colour(Colour::ResultError);
+        out <<
+            "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
+            "failed " << pluralise(totals.assertions.failed, "assertion") << '.';
+    } else {
+        Colour colour(Colour::ResultSuccess);
+        out <<
+            "Passed " << bothOrAll(totals.testCases.passed)
+            << pluralise(totals.testCases.passed, "test case") <<
+            " with " << pluralise(totals.assertions.passed, "assertion") << '.';
+    }
+}
+
+// Implementation of CompactReporter formatting
+class AssertionPrinter {
+public:
+    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
+    AssertionPrinter(AssertionPrinter const&) = delete;
+    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+        : stream(_stream)
+        , result(_stats.assertionResult)
+        , messages(_stats.infoMessages)
+        , itMessage(_stats.infoMessages.begin())
+        , printInfoMessages(_printInfoMessages) {}
+
+    void print() {
+        printSourceInfo();
+
+        itMessage = messages.begin();
+
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            printResultType(Colour::ResultSuccess, passedString());
+            printOriginalExpression();
+            printReconstructedExpression();
+            if (!result.hasExpression())
+                printRemainingMessages(Colour::None);
+            else
+                printRemainingMessages();
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk())
+                printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
+            else
+                printResultType(Colour::Error, failedString());
+            printOriginalExpression();
+            printReconstructedExpression();
+            printRemainingMessages();
+            break;
+        case ResultWas::ThrewException:
+            printResultType(Colour::Error, failedString());
+            printIssue("unexpected exception with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::FatalErrorCondition:
+            printResultType(Colour::Error, failedString());
+            printIssue("fatal error condition with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::DidntThrowException:
+            printResultType(Colour::Error, failedString());
+            printIssue("expected exception, got none");
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::Info:
+            printResultType(Colour::None, "info");
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::Warning:
+            printResultType(Colour::None, "warning");
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::ExplicitFailure:
+            printResultType(Colour::Error, failedString());
+            printIssue("explicitly");
+            printRemainingMessages(Colour::None);
+            break;
+            // These cases are here to prevent compiler warnings
+        case ResultWas::Unknown:
+        case ResultWas::FailureBit:
+        case ResultWas::Exception:
+            printResultType(Colour::Error, "** internal error **");
+            break;
+        }
+    }
+
+private:
+    void printSourceInfo() const {
+        Colour colourGuard(Colour::FileName);
+        stream << result.getSourceInfo() << ':';
+    }
+
+    void printResultType(Colour::Code colour, std::string const& passOrFail) const {
+        if (!passOrFail.empty()) {
+            {
+                Colour colourGuard(colour);
+                stream << ' ' << passOrFail;
+            }
+            stream << ':';
+        }
+    }
+
+    void printIssue(std::string const& issue) const {
+        stream << ' ' << issue;
+    }
+
+    void printExpressionWas() {
+        if (result.hasExpression()) {
+            stream << ';';
+            {
+                Colour colour(dimColour());
+                stream << " expression was:";
+            }
+            printOriginalExpression();
+        }
+    }
+
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            stream << ' ' << result.getExpression();
+        }
+    }
+
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            {
+                Colour colour(dimColour());
+                stream << " for: ";
+            }
+            stream << result.getExpandedExpression();
+        }
+    }
+
+    void printMessage() {
+        if (itMessage != messages.end()) {
+            stream << " '" << itMessage->message << '\'';
+            ++itMessage;
+        }
+    }
+
+    void printRemainingMessages(Colour::Code colour = dimColour()) {
+        if (itMessage == messages.end())
+            return;
+
+        const auto itEnd = messages.cend();
+        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+
+        {
+            Colour colourGuard(colour);
+            stream << " with " << pluralise(N, "message") << ':';
+        }
+
+        while (itMessage != itEnd) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || itMessage->type != ResultWas::Info) {
+                printMessage();
+                if (itMessage != itEnd) {
+                    Colour colourGuard(dimColour());
+                    stream << " and";
+                }
+                continue;
+            }
+            ++itMessage;
+        }
+    }
+
+private:
+    std::ostream& stream;
+    AssertionResult const& result;
+    std::vector<MessageInfo> messages;
+    std::vector<MessageInfo>::const_iterator itMessage;
+    bool printInfoMessages;
+};
+
+} // anon namespace
+
+        std::string CompactReporter::getDescription() {
+            return "Reports test results on a single line, suitable for IDEs";
+        }
+
+        ReporterPreferences CompactReporter::getPreferences() const {
+            return m_reporterPrefs;
+        }
+
+        void CompactReporter::noMatchingTestCases( std::string const& spec ) {
+            stream << "No test cases matched '" << spec << '\'' << std::endl;
+        }
+
+        void CompactReporter::assertionStarting( AssertionInfo const& ) {}
+
+        bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool printInfoMessages = true;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+                if( result.getResultType() != ResultWas::Warning )
+                    return false;
+                printInfoMessages = false;
+            }
+
+            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
+            if (m_config->showDurations() == ShowDurations::Always) {
+                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+            }
+        }
+
+        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
+            printTotals( stream, _testRunStats.totals );
+            stream << '\n' << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+        CompactReporter::~CompactReporter() {}
+
+    CATCH_REGISTER_REPORTER( "compact", CompactReporter )
+
+} // end namespace Catch
+// end catch_reporter_compact.cpp
+// start catch_reporter_console.cpp
+
+#include <cfloat>
+#include <cstdio>
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+ // Note that 4062 (not all labels are handled and default is missing) is enabled
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic push
+// For simplicity, benchmarking-only helpers are always enabled
+#  pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+namespace Catch {
+
+namespace {
+
+// Formatter impl for ConsoleReporter
+class ConsoleAssertionPrinter {
+public:
+    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+        : stream(_stream),
+        stats(_stats),
+        result(_stats.assertionResult),
+        colour(Colour::None),
+        message(result.getMessage()),
+        messages(_stats.infoMessages),
+        printInfoMessages(_printInfoMessages) {
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            colour = Colour::Success;
+            passOrFail = "PASSED";
+            //if( result.hasMessage() )
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "with messages";
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk()) {
+                colour = Colour::Success;
+                passOrFail = "FAILED - but was ok";
+            } else {
+                colour = Colour::Error;
+                passOrFail = "FAILED";
+            }
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "with messages";
+            break;
+        case ResultWas::ThrewException:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "due to unexpected exception with ";
+            if (_stats.infoMessages.size() == 1)
+                messageLabel += "message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel += "messages";
+            break;
+        case ResultWas::FatalErrorCondition:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "due to a fatal error condition";
+            break;
+        case ResultWas::DidntThrowException:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "because no exception was thrown where one was expected";
+            break;
+        case ResultWas::Info:
+            messageLabel = "info";
+            break;
+        case ResultWas::Warning:
+            messageLabel = "warning";
+            break;
+        case ResultWas::ExplicitFailure:
+            passOrFail = "FAILED";
+            colour = Colour::Error;
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "explicitly with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "explicitly with messages";
+            break;
+            // These cases are here to prevent compiler warnings
+        case ResultWas::Unknown:
+        case ResultWas::FailureBit:
+        case ResultWas::Exception:
+            passOrFail = "** internal error **";
+            colour = Colour::Error;
+            break;
+        }
+    }
+
+    void print() const {
+        printSourceInfo();
+        if (stats.totals.assertions.total() > 0) {
+            printResultType();
+            printOriginalExpression();
+            printReconstructedExpression();
+        } else {
+            stream << '\n';
+        }
+        printMessage();
+    }
+
+private:
+    void printResultType() const {
+        if (!passOrFail.empty()) {
+            Colour colourGuard(colour);
+            stream << passOrFail << ":\n";
+        }
+    }
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            Colour colourGuard(Colour::OriginalExpression);
+            stream << "  ";
+            stream << result.getExpressionInMacro();
+            stream << '\n';
+        }
+    }
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            stream << "with expansion:\n";
+            Colour colourGuard(Colour::ReconstructedExpression);
+            stream << Column(result.getExpandedExpression()).indent(2) << '\n';
+        }
+    }
+    void printMessage() const {
+        if (!messageLabel.empty())
+            stream << messageLabel << ':' << '\n';
+        for (auto const& msg : messages) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || msg.type != ResultWas::Info)
+                stream << Column(msg.message).indent(2) << '\n';
+        }
+    }
+    void printSourceInfo() const {
+        Colour colourGuard(Colour::FileName);
+        stream << result.getSourceInfo() << ": ";
+    }
+
+    std::ostream& stream;
+    AssertionStats const& stats;
+    AssertionResult const& result;
+    Colour::Code colour;
+    std::string passOrFail;
+    std::string messageLabel;
+    std::string message;
+    std::vector<MessageInfo> messages;
+    bool printInfoMessages;
+};
+
+std::size_t makeRatio(std::size_t number, std::size_t total) {
+    std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
+    return (ratio == 0 && number > 0) ? 1 : ratio;
+}
+
+std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
+    if (i > j && i > k)
+        return i;
+    else if (j > k)
+        return j;
+    else
+        return k;
+}
+
+struct ColumnInfo {
+    enum Justification { Left, Right };
+    std::string name;
+    int width;
+    Justification justification;
+};
+struct ColumnBreak {};
+struct RowBreak {};
+
+class Duration {
+    enum class Unit {
+        Auto,
+        Nanoseconds,
+        Microseconds,
+        Milliseconds,
+        Seconds,
+        Minutes
+    };
+    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
+    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
+    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
+    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
+
+    double m_inNanoseconds;
+    Unit m_units;
+
+public:
+    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
+        : m_inNanoseconds(inNanoseconds),
+        m_units(units) {
+        if (m_units == Unit::Auto) {
+            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
+                m_units = Unit::Nanoseconds;
+            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
+                m_units = Unit::Microseconds;
+            else if (m_inNanoseconds < s_nanosecondsInASecond)
+                m_units = Unit::Milliseconds;
+            else if (m_inNanoseconds < s_nanosecondsInAMinute)
+                m_units = Unit::Seconds;
+            else
+                m_units = Unit::Minutes;
+        }
+
+    }
+
+    auto value() const -> double {
+        switch (m_units) {
+        case Unit::Microseconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
+        case Unit::Milliseconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
+        case Unit::Seconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
+        case Unit::Minutes:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
+        default:
+            return m_inNanoseconds;
+        }
+    }
+    auto unitsAsString() const -> std::string {
+        switch (m_units) {
+        case Unit::Nanoseconds:
+            return "ns";
+        case Unit::Microseconds:
+            return "us";
+        case Unit::Milliseconds:
+            return "ms";
+        case Unit::Seconds:
+            return "s";
+        case Unit::Minutes:
+            return "m";
+        default:
+            return "** internal error **";
+        }
+
+    }
+    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
+        return os << duration.value() << ' ' << duration.unitsAsString();
+    }
+};
+} // end anon namespace
+
+class TablePrinter {
+    std::ostream& m_os;
+    std::vector<ColumnInfo> m_columnInfos;
+    std::ostringstream m_oss;
+    int m_currentColumn = -1;
+    bool m_isOpen = false;
+
+public:
+    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
+    :   m_os( os ),
+        m_columnInfos( std::move( columnInfos ) ) {}
+
+    auto columnInfos() const -> std::vector<ColumnInfo> const& {
+        return m_columnInfos;
+    }
+
+    void open() {
+        if (!m_isOpen) {
+            m_isOpen = true;
+            *this << RowBreak();
+
+			Columns headerCols;
+			Spacer spacer(2);
+			for (auto const& info : m_columnInfos) {
+				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
+				headerCols += spacer;
+			}
+			m_os << headerCols << '\n';
+
+            m_os << Catch::getLineOfChars<'-'>() << '\n';
+        }
+    }
+    void close() {
+        if (m_isOpen) {
+            *this << RowBreak();
+            m_os << std::endl;
+            m_isOpen = false;
+        }
+    }
+
+    template<typename T>
+    friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
+        tp.m_oss << value;
+        return tp;
+    }
+
+    friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
+        auto colStr = tp.m_oss.str();
+        const auto strSize = colStr.size();
+        tp.m_oss.str("");
+        tp.open();
+        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
+            tp.m_currentColumn = -1;
+            tp.m_os << '\n';
+        }
+        tp.m_currentColumn++;
+
+        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
+        auto padding = (strSize + 1 < static_cast<std::size_t>(colInfo.width))
+            ? std::string(colInfo.width - (strSize + 1), ' ')
+            : std::string();
+        if (colInfo.justification == ColumnInfo::Left)
+            tp.m_os << colStr << padding << ' ';
+        else
+            tp.m_os << padding << colStr << ' ';
+        return tp;
+    }
+
+    friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
+        if (tp.m_currentColumn > 0) {
+            tp.m_os << '\n';
+            tp.m_currentColumn = -1;
+        }
+        return tp;
+    }
+};
+
+ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
+    : StreamingReporterBase(config),
+    m_tablePrinter(new TablePrinter(config.stream(),
+        [&config]() -> std::vector<ColumnInfo> {
+        if (config.fullConfig()->benchmarkNoAnalysis())
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
+                { "     samples", 14, ColumnInfo::Right },
+                { "  iterations", 14, ColumnInfo::Right },
+                { "        mean", 14, ColumnInfo::Right }
+            };
+        }
+        else
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
+                { "samples      mean       std dev", 14, ColumnInfo::Right },
+                { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
+                { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
+            };
+        }
+    }())) {}
+ConsoleReporter::~ConsoleReporter() = default;
+
+std::string ConsoleReporter::getDescription() {
+    return "Reports test results as plain lines of text";
+}
+
+void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
+    stream << "No test cases matched '" << spec << '\'' << std::endl;
+}
+
+void ConsoleReporter::reportInvalidArguments(std::string const&arg){
+    stream << "Invalid Filter: " << arg << std::endl;
+}
+
+void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
+
+bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
+    AssertionResult const& result = _assertionStats.assertionResult;
+
+    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+    // Drop out if result was successful but we're not printing them.
+    if (!includeResults && result.getResultType() != ResultWas::Warning)
+        return false;
+
+    lazyPrint();
+
+    ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
+    printer.print();
+    stream << std::endl;
+    return true;
+}
+
+void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+    m_tablePrinter->close();
+    m_headerPrinted = false;
+    StreamingReporterBase::sectionStarting(_sectionInfo);
+}
+void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
+    m_tablePrinter->close();
+    if (_sectionStats.missingAssertions) {
+        lazyPrint();
+        Colour colour(Colour::ResultError);
+        if (m_sectionStack.size() > 1)
+            stream << "\nNo assertions in section";
+        else
+            stream << "\nNo assertions in test case";
+        stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+    }
+    if (m_config->showDurations() == ShowDurations::Always) {
+        stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+    }
+    if (m_headerPrinted) {
+        m_headerPrinted = false;
+    }
+    StreamingReporterBase::sectionEnded(_sectionStats);
+}
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+void ConsoleReporter::benchmarkPreparing(std::string const& name) {
+	lazyPrintWithoutClosingBenchmarkTable();
+
+	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
+
+	bool firstLine = true;
+	for (auto line : nameCol) {
+		if (!firstLine)
+			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
+		else
+			firstLine = false;
+
+		(*m_tablePrinter) << line << ColumnBreak();
+	}
+}
+
+void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
+    (*m_tablePrinter) << info.samples << ColumnBreak()
+        << info.iterations << ColumnBreak();
+    if (!m_config->benchmarkNoAnalysis())
+        (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
+}
+void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
+    if (m_config->benchmarkNoAnalysis())
+    {
+        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
+    }
+    else
+    {
+        (*m_tablePrinter) << ColumnBreak()
+            << Duration(stats.mean.point.count()) << ColumnBreak()
+            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
+            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
+    }
+}
+
+void ConsoleReporter::benchmarkFailed(std::string const& error) {
+	Colour colour(Colour::Red);
+    (*m_tablePrinter)
+        << "Benchmark failed (" << error << ')'
+        << ColumnBreak() << RowBreak();
+}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+    m_tablePrinter->close();
+    StreamingReporterBase::testCaseEnded(_testCaseStats);
+    m_headerPrinted = false;
+}
+void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
+    if (currentGroupInfo.used) {
+        printSummaryDivider();
+        stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+        printTotals(_testGroupStats.totals);
+        stream << '\n' << std::endl;
+    }
+    StreamingReporterBase::testGroupEnded(_testGroupStats);
+}
+void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
+    printTotalsDivider(_testRunStats.totals);
+    printTotals(_testRunStats.totals);
+    stream << std::endl;
+    StreamingReporterBase::testRunEnded(_testRunStats);
+}
+void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
+    StreamingReporterBase::testRunStarting(_testInfo);
+    printTestFilters();
+}
+
+void ConsoleReporter::lazyPrint() {
+
+    m_tablePrinter->close();
+    lazyPrintWithoutClosingBenchmarkTable();
+}
+
+void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
+
+    if (!currentTestRunInfo.used)
+        lazyPrintRunInfo();
+    if (!currentGroupInfo.used)
+        lazyPrintGroupInfo();
+
+    if (!m_headerPrinted) {
+        printTestCaseAndSectionHeader();
+        m_headerPrinted = true;
+    }
+}
+void ConsoleReporter::lazyPrintRunInfo() {
+    stream << '\n' << getLineOfChars<'~'>() << '\n';
+    Colour colour(Colour::SecondaryText);
+    stream << currentTestRunInfo->name
+        << " is a Catch v" << libraryVersion() << " host application.\n"
+        << "Run with -? for options\n\n";
+
+    if (m_config->rngSeed() != 0)
+        stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
+
+    currentTestRunInfo.used = true;
+}
+void ConsoleReporter::lazyPrintGroupInfo() {
+    if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
+        printClosedHeader("Group: " + currentGroupInfo->name);
+        currentGroupInfo.used = true;
+    }
+}
+void ConsoleReporter::printTestCaseAndSectionHeader() {
+    assert(!m_sectionStack.empty());
+    printOpenHeader(currentTestCaseInfo->name);
+
+    if (m_sectionStack.size() > 1) {
+        Colour colourGuard(Colour::Headers);
+
+        auto
+            it = m_sectionStack.begin() + 1, // Skip first section (test case)
+            itEnd = m_sectionStack.end();
+        for (; it != itEnd; ++it)
+            printHeaderString(it->name, 2);
+    }
+
+    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
+
+    stream << getLineOfChars<'-'>() << '\n';
+    Colour colourGuard(Colour::FileName);
+    stream << lineInfo << '\n';
+    stream << getLineOfChars<'.'>() << '\n' << std::endl;
+}
+
+void ConsoleReporter::printClosedHeader(std::string const& _name) {
+    printOpenHeader(_name);
+    stream << getLineOfChars<'.'>() << '\n';
+}
+void ConsoleReporter::printOpenHeader(std::string const& _name) {
+    stream << getLineOfChars<'-'>() << '\n';
+    {
+        Colour colourGuard(Colour::Headers);
+        printHeaderString(_name);
+    }
+}
+
+// if string has a : in first line will set indent to follow it on
+// subsequent lines
+void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
+    std::size_t i = _string.find(": ");
+    if (i != std::string::npos)
+        i += 2;
+    else
+        i = 0;
+    stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
+}
+
+struct SummaryColumn {
+
+    SummaryColumn( std::string _label, Colour::Code _colour )
+    :   label( std::move( _label ) ),
+        colour( _colour ) {}
+    SummaryColumn addRow( std::size_t count ) {
+        ReusableStringStream rss;
+        rss << count;
+        std::string row = rss.str();
+        for (auto& oldRow : rows) {
+            while (oldRow.size() < row.size())
+                oldRow = ' ' + oldRow;
+            while (oldRow.size() > row.size())
+                row = ' ' + row;
+        }
+        rows.push_back(row);
+        return *this;
+    }
+
+    std::string label;
+    Colour::Code colour;
+    std::vector<std::string> rows;
+
+};
+
+void ConsoleReporter::printTotals( Totals const& totals ) {
+    if (totals.testCases.total() == 0) {
+        stream << Colour(Colour::Warning) << "No tests ran\n";
+    } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
+        stream << Colour(Colour::ResultSuccess) << "All tests passed";
+        stream << " ("
+            << pluralise(totals.assertions.passed, "assertion") << " in "
+            << pluralise(totals.testCases.passed, "test case") << ')'
+            << '\n';
+    } else {
+
+        std::vector<SummaryColumn> columns;
+        columns.push_back(SummaryColumn("", Colour::None)
+                          .addRow(totals.testCases.total())
+                          .addRow(totals.assertions.total()));
+        columns.push_back(SummaryColumn("passed", Colour::Success)
+                          .addRow(totals.testCases.passed)
+                          .addRow(totals.assertions.passed));
+        columns.push_back(SummaryColumn("failed", Colour::ResultError)
+                          .addRow(totals.testCases.failed)
+                          .addRow(totals.assertions.failed));
+        columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
+                          .addRow(totals.testCases.failedButOk)
+                          .addRow(totals.assertions.failedButOk));
+
+        printSummaryRow("test cases", columns, 0);
+        printSummaryRow("assertions", columns, 1);
+    }
+}
+void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
+    for (auto col : cols) {
+        std::string value = col.rows[row];
+        if (col.label.empty()) {
+            stream << label << ": ";
+            if (value != "0")
+                stream << value;
+            else
+                stream << Colour(Colour::Warning) << "- none -";
+        } else if (value != "0") {
+            stream << Colour(Colour::LightGrey) << " | ";
+            stream << Colour(col.colour)
+                << value << ' ' << col.label;
+        }
+    }
+    stream << '\n';
+}
+
+void ConsoleReporter::printTotalsDivider(Totals const& totals) {
+    if (totals.testCases.total() > 0) {
+        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
+        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
+        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
+        while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+            findMax(failedRatio, failedButOkRatio, passedRatio)++;
+        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
+            findMax(failedRatio, failedButOkRatio, passedRatio)--;
+
+        stream << Colour(Colour::Error) << std::string(failedRatio, '=');
+        stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
+        if (totals.testCases.allPassed())
+            stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
+        else
+            stream << Colour(Colour::Success) << std::string(passedRatio, '=');
+    } else {
+        stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
+    }
+    stream << '\n';
+}
+void ConsoleReporter::printSummaryDivider() {
+    stream << getLineOfChars<'-'>() << '\n';
+}
+
+void ConsoleReporter::printTestFilters() {
+    if (m_config->testSpec().hasFilters()) {
+        Colour guard(Colour::BrightYellow);
+        stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
+    }
+}
+
+CATCH_REGISTER_REPORTER("console", ConsoleReporter)
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic pop
+#endif
+// end catch_reporter_console.cpp
+// start catch_reporter_junit.cpp
+
+#include <cassert>
+#include <sstream>
+#include <ctime>
+#include <algorithm>
+
+namespace Catch {
+
+    namespace {
+        std::string getCurrentTimestamp() {
+            // Beware, this is not reentrant because of backward compatibility issues
+            // Also, UTC only, again because of backward compatibility (%z is C++11)
+            time_t rawtime;
+            std::time(&rawtime);
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &rawtime);
+#else
+            std::tm* timeInfo;
+            timeInfo = std::gmtime(&rawtime);
+#endif
+
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp);
+        }
+
+        std::string fileNameTag(const std::vector<std::string> &tags) {
+            auto it = std::find_if(begin(tags),
+                                   end(tags),
+                                   [] (std::string const& tag) {return tag.front() == '#'; });
+            if (it != tags.end())
+                return it->substr(1);
+            return std::string();
+        }
+    } // anonymous namespace
+
+    JunitReporter::JunitReporter( ReporterConfig const& _config )
+        :   CumulativeReporterBase( _config ),
+            xml( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+            m_reporterPrefs.shouldReportAllAssertions = true;
+        }
+
+    JunitReporter::~JunitReporter() {}
+
+    std::string JunitReporter::getDescription() {
+        return "Reports test results in an XML format that looks like Ant's junitreport target";
+    }
+
+    void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
+
+    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
+        CumulativeReporterBase::testRunStarting( runInfo );
+        xml.startElement( "testsuites" );
+    }
+
+    void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        suiteTimer.start();
+        stdOutForSuite.clear();
+        stdErrForSuite.clear();
+        unexpectedExceptions = 0;
+        CumulativeReporterBase::testGroupStarting( groupInfo );
+    }
+
+    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
+        m_okToFail = testCaseInfo.okToFail();
+    }
+
+    bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
+            unexpectedExceptions++;
+        return CumulativeReporterBase::assertionEnded( assertionStats );
+    }
+
+    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        stdOutForSuite += testCaseStats.stdOut;
+        stdErrForSuite += testCaseStats.stdErr;
+        CumulativeReporterBase::testCaseEnded( testCaseStats );
+    }
+
+    void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        double suiteTime = suiteTimer.getElapsedSeconds();
+        CumulativeReporterBase::testGroupEnded( testGroupStats );
+        writeGroup( *m_testGroups.back(), suiteTime );
+    }
+
+    void JunitReporter::testRunEndedCumulative() {
+        xml.endElement();
+    }
+
+    void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
+        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+
+        TestGroupStats const& stats = groupNode.value;
+        xml.writeAttribute( "name", stats.groupInfo.name );
+        xml.writeAttribute( "errors", unexpectedExceptions );
+        xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
+        xml.writeAttribute( "tests", stats.totals.assertions.total() );
+        xml.writeAttribute( "hostname", "tbd" ); // !TBD
+        if( m_config->showDurations() == ShowDurations::Never )
+            xml.writeAttribute( "time", "" );
+        else
+            xml.writeAttribute( "time", suiteTime );
+        xml.writeAttribute( "timestamp", getCurrentTimestamp() );
+
+        // Write properties if there are any
+        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
+            auto properties = xml.scopedElement("properties");
+            if (m_config->hasTestFilters()) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "filters")
+                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
+            }
+            if (m_config->rngSeed() != 0) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "random-seed")
+                    .writeAttribute("value", m_config->rngSeed());
+            }
+        }
+
+        // Write test cases
+        for( auto const& child : groupNode.children )
+            writeTestCase( *child );
+
+        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
+        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
+    }
+
+    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
+        TestCaseStats const& stats = testCaseNode.value;
+
+        // All test cases have exactly one section - which represents the
+        // test case itself. That section may have 0-n nested sections
+        assert( testCaseNode.children.size() == 1 );
+        SectionNode const& rootSection = *testCaseNode.children.front();
+
+        std::string className = stats.testInfo.className;
+
+        if( className.empty() ) {
+            className = fileNameTag(stats.testInfo.tags);
+            if ( className.empty() )
+                className = "global";
+        }
+
+        if ( !m_config->name().empty() )
+            className = m_config->name() + "." + className;
+
+        writeSection( className, "", rootSection );
+    }
+
+    void JunitReporter::writeSection(  std::string const& className,
+                        std::string const& rootName,
+                        SectionNode const& sectionNode ) {
+        std::string name = trim( sectionNode.stats.sectionInfo.name );
+        if( !rootName.empty() )
+            name = rootName + '/' + name;
+
+        if( !sectionNode.assertions.empty() ||
+            !sectionNode.stdOut.empty() ||
+            !sectionNode.stdErr.empty() ) {
+            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+            if( className.empty() ) {
+                xml.writeAttribute( "classname", name );
+                xml.writeAttribute( "name", "root" );
+            }
+            else {
+                xml.writeAttribute( "classname", className );
+                xml.writeAttribute( "name", name );
+            }
+            xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
+
+            writeAssertions( sectionNode );
+
+            if( !sectionNode.stdOut.empty() )
+                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
+            if( !sectionNode.stdErr.empty() )
+                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
+        }
+        for( auto const& childNode : sectionNode.childSections )
+            if( className.empty() )
+                writeSection( name, "", *childNode );
+            else
+                writeSection( className, name, *childNode );
+    }
+
+    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
+        for( auto const& assertion : sectionNode.assertions )
+            writeAssertion( assertion );
+    }
+
+    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
+        AssertionResult const& result = stats.assertionResult;
+        if( !result.isOk() ) {
+            std::string elementName;
+            switch( result.getResultType() ) {
+                case ResultWas::ThrewException:
+                case ResultWas::FatalErrorCondition:
+                    elementName = "error";
+                    break;
+                case ResultWas::ExplicitFailure:
+                case ResultWas::ExpressionFailed:
+                case ResultWas::DidntThrowException:
+                    elementName = "failure";
+                    break;
+
+                // We should never see these here:
+                case ResultWas::Info:
+                case ResultWas::Warning:
+                case ResultWas::Ok:
+                case ResultWas::Unknown:
+                case ResultWas::FailureBit:
+                case ResultWas::Exception:
+                    elementName = "internalError";
+                    break;
+            }
+
+            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+
+            xml.writeAttribute( "message", result.getExpression() );
+            xml.writeAttribute( "type", result.getTestMacroName() );
+
+            ReusableStringStream rss;
+            if (stats.totals.assertions.total() > 0) {
+                rss << "FAILED" << ":\n";
+                if (result.hasExpression()) {
+                    rss << "  ";
+                    rss << result.getExpressionInMacro();
+                    rss << '\n';
+                }
+                if (result.hasExpandedExpression()) {
+                    rss << "with expansion:\n";
+                    rss << Column(result.getExpandedExpression()).indent(2) << '\n';
+                }
+            } else {
+                rss << '\n';
+            }
+
+            if( !result.getMessage().empty() )
+                rss << result.getMessage() << '\n';
+            for( auto const& msg : stats.infoMessages )
+                if( msg.type == ResultWas::Info )
+                    rss << msg.message << '\n';
+
+            rss << "at " << result.getSourceInfo();
+            xml.writeText( rss.str(), XmlFormatting::Newline );
+        }
+    }
+
+    CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+
+} // end namespace Catch
+// end catch_reporter_junit.cpp
+// start catch_reporter_listening.cpp
+
+#include <cassert>
+
+namespace Catch {
+
+    ListeningReporter::ListeningReporter() {
+        // We will assume that listeners will always want all assertions
+        m_preferences.shouldReportAllAssertions = true;
+    }
+
+    void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
+        m_listeners.push_back( std::move( listener ) );
+    }
+
+    void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
+        assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
+        m_reporter = std::move( reporter );
+        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
+    }
+
+    ReporterPreferences ListeningReporter::getPreferences() const {
+        return m_preferences;
+    }
+
+    std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
+        return std::set<Verbosity>{ };
+    }
+
+    void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->noMatchingTestCases( spec );
+        }
+        m_reporter->noMatchingTestCases( spec );
+    }
+
+    void ListeningReporter::reportInvalidArguments(std::string const&arg){
+        for ( auto const& listener : m_listeners ) {
+            listener->reportInvalidArguments( arg );
+        }
+        m_reporter->reportInvalidArguments( arg );
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkPreparing(name);
+		}
+		m_reporter->benchmarkPreparing(name);
+	}
+    void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->benchmarkStarting( benchmarkInfo );
+        }
+        m_reporter->benchmarkStarting( benchmarkInfo );
+    }
+    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->benchmarkEnded( benchmarkStats );
+        }
+        m_reporter->benchmarkEnded( benchmarkStats );
+    }
+
+	void ListeningReporter::benchmarkFailed( std::string const& error ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkFailed(error);
+		}
+		m_reporter->benchmarkFailed(error);
+	}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testRunStarting( testRunInfo );
+        }
+        m_reporter->testRunStarting( testRunInfo );
+    }
+
+    void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testGroupStarting( groupInfo );
+        }
+        m_reporter->testGroupStarting( groupInfo );
+    }
+
+    void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testCaseStarting( testInfo );
+        }
+        m_reporter->testCaseStarting( testInfo );
+    }
+
+    void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->sectionStarting( sectionInfo );
+        }
+        m_reporter->sectionStarting( sectionInfo );
+    }
+
+    void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->assertionStarting( assertionInfo );
+        }
+        m_reporter->assertionStarting( assertionInfo );
+    }
+
+    // The return value indicates if the messages buffer should be cleared:
+    bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        for( auto const& listener : m_listeners ) {
+            static_cast<void>( listener->assertionEnded( assertionStats ) );
+        }
+        return m_reporter->assertionEnded( assertionStats );
+    }
+
+    void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->sectionEnded( sectionStats );
+        }
+        m_reporter->sectionEnded( sectionStats );
+    }
+
+    void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testCaseEnded( testCaseStats );
+        }
+        m_reporter->testCaseEnded( testCaseStats );
+    }
+
+    void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testGroupEnded( testGroupStats );
+        }
+        m_reporter->testGroupEnded( testGroupStats );
+    }
+
+    void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testRunEnded( testRunStats );
+        }
+        m_reporter->testRunEnded( testRunStats );
+    }
+
+    void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->skipTest( testInfo );
+        }
+        m_reporter->skipTest( testInfo );
+    }
+
+    bool ListeningReporter::isMulti() const {
+        return true;
+    }
+
+} // end namespace Catch
+// end catch_reporter_listening.cpp
+// start catch_reporter_xml.cpp
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
+
+namespace Catch {
+    XmlReporter::XmlReporter( ReporterConfig const& _config )
+    :   StreamingReporterBase( _config ),
+        m_xml(_config.stream())
+    {
+        m_reporterPrefs.shouldRedirectStdOut = true;
+        m_reporterPrefs.shouldReportAllAssertions = true;
+    }
+
+    XmlReporter::~XmlReporter() = default;
+
+    std::string XmlReporter::getDescription() {
+        return "Reports test results as an XML document";
+    }
+
+    std::string XmlReporter::getStylesheetRef() const {
+        return std::string();
+    }
+
+    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
+        m_xml
+            .writeAttribute( "filename", sourceInfo.file )
+            .writeAttribute( "line", sourceInfo.line );
+    }
+
+    void XmlReporter::noMatchingTestCases( std::string const& s ) {
+        StreamingReporterBase::noMatchingTestCases( s );
+    }
+
+    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
+        StreamingReporterBase::testRunStarting( testInfo );
+        std::string stylesheetRef = getStylesheetRef();
+        if( !stylesheetRef.empty() )
+            m_xml.writeStylesheetRef( stylesheetRef );
+        m_xml.startElement( "Catch" );
+        if( !m_config->name().empty() )
+            m_xml.writeAttribute( "name", m_config->name() );
+        if (m_config->testSpec().hasFilters())
+            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
+        if( m_config->rngSeed() != 0 )
+            m_xml.scopedElement( "Randomness" )
+                .writeAttribute( "seed", m_config->rngSeed() );
+    }
+
+    void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        StreamingReporterBase::testGroupStarting( groupInfo );
+        m_xml.startElement( "Group" )
+            .writeAttribute( "name", groupInfo.name );
+    }
+
+    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        StreamingReporterBase::testCaseStarting(testInfo);
+        m_xml.startElement( "TestCase" )
+            .writeAttribute( "name", trim( testInfo.name ) )
+            .writeAttribute( "description", testInfo.description )
+            .writeAttribute( "tags", testInfo.tagsAsString() );
+
+        writeSourceInfo( testInfo.lineInfo );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            m_testCaseTimer.start();
+        m_xml.ensureTagClosed();
+    }
+
+    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        StreamingReporterBase::sectionStarting( sectionInfo );
+        if( m_sectionDepth++ > 0 ) {
+            m_xml.startElement( "Section" )
+                .writeAttribute( "name", trim( sectionInfo.name ) );
+            writeSourceInfo( sectionInfo.lineInfo );
+            m_xml.ensureTagClosed();
+        }
+    }
+
+    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
+
+    bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
+
+        AssertionResult const& result = assertionStats.assertionResult;
+
+        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+        if( includeResults || result.getResultType() == ResultWas::Warning ) {
+            // Print any info messages in <Info> tags.
+            for( auto const& msg : assertionStats.infoMessages ) {
+                if( msg.type == ResultWas::Info && includeResults ) {
+                    m_xml.scopedElement( "Info" )
+                            .writeText( msg.message );
+                } else if ( msg.type == ResultWas::Warning ) {
+                    m_xml.scopedElement( "Warning" )
+                            .writeText( msg.message );
+                }
+            }
+        }
+
+        // Drop out if result was successful but we're not printing them.
+        if( !includeResults && result.getResultType() != ResultWas::Warning )
+            return true;
+
+        // Print the expression if there is one.
+        if( result.hasExpression() ) {
+            m_xml.startElement( "Expression" )
+                .writeAttribute( "success", result.succeeded() )
+                .writeAttribute( "type", result.getTestMacroName() );
+
+            writeSourceInfo( result.getSourceInfo() );
+
+            m_xml.scopedElement( "Original" )
+                .writeText( result.getExpression() );
+            m_xml.scopedElement( "Expanded" )
+                .writeText( result.getExpandedExpression() );
+        }
+
+        // And... Print a result applicable to each result type.
+        switch( result.getResultType() ) {
+            case ResultWas::ThrewException:
+                m_xml.startElement( "Exception" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::FatalErrorCondition:
+                m_xml.startElement( "FatalErrorCondition" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::Info:
+                m_xml.scopedElement( "Info" )
+                    .writeText( result.getMessage() );
+                break;
+            case ResultWas::Warning:
+                // Warning will already have been written
+                break;
+            case ResultWas::ExplicitFailure:
+                m_xml.startElement( "Failure" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            default:
+                break;
+        }
+
+        if( result.hasExpression() )
+            m_xml.endElement();
+
+        return true;
+    }
+
+    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
+        StreamingReporterBase::sectionEnded( sectionStats );
+        if( --m_sectionDepth > 0 ) {
+            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+            e.writeAttribute( "successes", sectionStats.assertions.passed );
+            e.writeAttribute( "failures", sectionStats.assertions.failed );
+            e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
+
+            m_xml.endElement();
+        }
+    }
+
+    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        StreamingReporterBase::testCaseEnded( testCaseStats );
+        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+        e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
+
+        if( !testCaseStats.stdOut.empty() )
+            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
+        if( !testCaseStats.stdErr.empty() )
+            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
+
+        m_xml.endElement();
+    }
+
+    void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        StreamingReporterBase::testGroupEnded( testGroupStats );
+        // TODO: Check testGroupStats.aborting and act accordingly.
+        m_xml.scopedElement( "OverallResults" )
+            .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
+            .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
+            .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
+        m_xml.endElement();
+    }
+
+    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        StreamingReporterBase::testRunEnded( testRunStats );
+        m_xml.scopedElement( "OverallResults" )
+            .writeAttribute( "successes", testRunStats.totals.assertions.passed )
+            .writeAttribute( "failures", testRunStats.totals.assertions.failed )
+            .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
+        m_xml.endElement();
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void XmlReporter::benchmarkPreparing(std::string const& name) {
+        m_xml.startElement("BenchmarkResults")
+            .writeAttribute("name", name);
+    }
+
+    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
+        m_xml.writeAttribute("samples", info.samples)
+            .writeAttribute("resamples", info.resamples)
+            .writeAttribute("iterations", info.iterations)
+            .writeAttribute("clockResolution", info.clockResolution)
+            .writeAttribute("estimatedDuration", info.estimatedDuration)
+            .writeComment("All values in nano seconds");
+    }
+
+    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+        m_xml.startElement("mean")
+            .writeAttribute("value", benchmarkStats.mean.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.mean.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.mean.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("standardDeviation")
+            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("outliers")
+            .writeAttribute("variance", benchmarkStats.outlierVariance)
+            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
+            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
+            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
+            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
+        m_xml.endElement();
+        m_xml.endElement();
+    }
+
+    void XmlReporter::benchmarkFailed(std::string const &error) {
+        m_xml.scopedElement("failed").
+            writeAttribute("message", error);
+        m_xml.endElement();
+    }
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    CATCH_REGISTER_REPORTER( "xml", XmlReporter )
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+// end catch_reporter_xml.cpp
+
+namespace Catch {
+    LeakDetector leakDetector;
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_impl.hpp
+#endif
+
+#ifdef CATCH_CONFIG_MAIN
+// start catch_default_main.hpp
+
+#ifndef __OBJC__
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+// Standard C/C++ Win32 Unicode wmain entry point
+extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
+#else
+// Standard C/C++ main entry point
+int main (int argc, char * argv[]) {
+#endif
+
+    return Catch::Session().run( argc, argv );
+}
+
+#else // __OBJC__
+
+// Objective-C entry point
+int main (int argc, char * const argv[]) {
+#if !CATCH_ARC_ENABLED
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+#endif
+
+    Catch::registerTestMethods();
+    int result = Catch::Session().run( argc, (char**)argv );
+
+#if !CATCH_ARC_ENABLED
+    [pool drain];
+#endif
+
+    return result;
+}
+
+#endif // __OBJC__
+
+// end catch_default_main.hpp
+#endif
+
+#if !defined(CATCH_CONFIG_IMPL_ONLY)
+
+#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
+#  undef CLARA_CONFIG_MAIN
+#endif
+
+#if !defined(CATCH_CONFIG_DISABLE)
+//////
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+#endif// CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
+#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
+
+#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#endif
+
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+#else
+#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
+#endif
+
+// "BDD-style" convenience wrappers
+#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define CATCH_BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define CATCH_BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
+#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
+#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
+
+#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#endif
+
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+#else
+#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
+#endif
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+
+// "BDD-style" convenience wrappers
+#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+
+#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+using Catch::Detail::Approx;
+
+#else // CATCH_CONFIG_DISABLE
+
+//////
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#define CATCH_REQUIRE( ... )        (void)(0)
+#define CATCH_REQUIRE_FALSE( ... )  (void)(0)
+
+#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher )     (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif// CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
+
+#define CATCH_CHECK( ... )         (void)(0)
+#define CATCH_CHECK_FALSE( ... )   (void)(0)
+#define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
+#define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
+#define CATCH_CHECK_NOFAIL( ... )  (void)(0)
+
+#define CATCH_CHECK_THROWS( ... )  (void)(0)
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CATCH_CHECK_THROWS_WITH( expr, matcher )     (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
+
+#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define CATCH_INFO( msg )          (void)(0)
+#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
+#define CATCH_WARN( msg )          (void)(0)
+#define CATCH_CAPTURE( msg )       (void)(0)
+
+#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_METHOD_AS_TEST_CASE( method, ... )
+#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
+#define CATCH_SECTION( ... )
+#define CATCH_DYNAMIC_SECTION( ... )
+#define CATCH_FAIL( ... ) (void)(0)
+#define CATCH_FAIL_CHECK( ... ) (void)(0)
+#define CATCH_SUCCEED( ... ) (void)(0)
+
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#endif
+
+// "BDD-style" convenience wrappers
+#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
+#define CATCH_GIVEN( desc )
+#define CATCH_AND_GIVEN( desc )
+#define CATCH_WHEN( desc )
+#define CATCH_AND_WHEN( desc )
+#define CATCH_THEN( desc )
+#define CATCH_AND_THEN( desc )
+
+#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE( ... )       (void)(0)
+#define REQUIRE_FALSE( ... ) (void)(0)
+
+#define REQUIRE_THROWS( ... ) (void)(0)
+#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define REQUIRE_NOTHROW( ... ) (void)(0)
+
+#define CHECK( ... ) (void)(0)
+#define CHECK_FALSE( ... ) (void)(0)
+#define CHECKED_IF( ... ) if (__VA_ARGS__)
+#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
+#define CHECK_NOFAIL( ... ) (void)(0)
+
+#define CHECK_THROWS( ... )  (void)(0)
+#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CHECK_NOTHROW( ... ) (void)(0)
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THAT( arg, matcher ) (void)(0)
+
+#define REQUIRE_THAT( arg, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define INFO( msg ) (void)(0)
+#define UNSCOPED_INFO( msg ) (void)(0)
+#define WARN( msg ) (void)(0)
+#define CAPTURE( msg ) (void)(0)
+
+#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define METHOD_AS_TEST_CASE( method, ... )
+#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
+#define SECTION( ... )
+#define DYNAMIC_SECTION( ... )
+#define FAIL( ... ) (void)(0)
+#define FAIL_CHECK( ... ) (void)(0)
+#define SUCCEED( ... ) (void)(0)
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#endif
+
+#define STATIC_REQUIRE( ... )       (void)(0)
+#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+// "BDD-style" convenience wrappers
+#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
+
+#define GIVEN( desc )
+#define AND_GIVEN( desc )
+#define WHEN( desc )
+#define AND_WHEN( desc )
+#define THEN( desc )
+#define AND_THEN( desc )
+
+using Catch::Detail::Approx;
+
+#endif
+
+#endif // ! CATCH_CONFIG_IMPL_ONLY
+
+// start catch_reenable_warnings.h
+
+
+#ifdef __clang__
+#    ifdef __ICC // icpc defines the __clang__ macro
+#        pragma warning(pop)
+#    else
+#        pragma clang diagnostic pop
+#    endif
+#elif defined __GNUC__
+#    pragma GCC diagnostic pop
+#endif
+
+// end catch_reenable_warnings.h
+// end catch.hpp
+#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
diff --git a/unittest/catch2/catch_reporter_automake.hpp b/unittest/catch2/catch_reporter_automake.hpp
new file mode 100644
index 000000000..dbebe9751
--- /dev/null
+++ b/unittest/catch2/catch_reporter_automake.hpp
@@ -0,0 +1,62 @@
+/*
+ *  Created by Justin R. Wilson on 2/19/2017.
+ *  Copyright 2017 Justin R. Wilson. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+namespace Catch {
+
+    struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
+        AutomakeReporter( ReporterConfig const& _config )
+          :   StreamingReporterBase( _config )
+        {}
+
+        ~AutomakeReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in the format of Automake .trs files";
+        }
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
+
+        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
+            // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
+            stream << ":test-result: ";
+            if (_testCaseStats.totals.assertions.allPassed()) {
+                stream << "PASS";
+            } else if (_testCaseStats.totals.assertions.allOk()) {
+                stream << "XFAIL";
+            } else {
+                stream << "FAIL";
+            }
+            stream << ' ' << _testCaseStats.testInfo.name << '\n';
+            StreamingReporterBase::testCaseEnded( _testCaseStats );
+        }
+
+        void skipTest( TestCaseInfo const& testInfo ) override {
+            stream << ":test-result: SKIP " << testInfo.name << '\n';
+        }
+
+    };
+
+#ifdef CATCH_IMPL
+    AutomakeReporter::~AutomakeReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
diff --git a/unittest/catch2/catch_reporter_sonarqube.hpp b/unittest/catch2/catch_reporter_sonarqube.hpp
new file mode 100644
index 000000000..bf7d9299a
--- /dev/null
+++ b/unittest/catch2/catch_reporter_sonarqube.hpp
@@ -0,0 +1,181 @@
+/*
+ *  Created by Daniel Garcia on 2018-12-04.
+ *  Copyright Social Point SL. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <map>
+
+namespace Catch {
+
+    struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
+
+        SonarQubeReporter(ReporterConfig const& config)
+        : CumulativeReporterBase(config)
+        , xml(config.stream()) {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+            m_reporterPrefs.shouldReportAllAssertions = true;
+        }
+
+        ~SonarQubeReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in the Generic Test Data SonarQube XML format";
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void noMatchingTestCases(std::string const& /*spec*/) override {}
+
+        void testRunStarting(TestRunInfo const& testRunInfo) override {
+            CumulativeReporterBase::testRunStarting(testRunInfo);
+            xml.startElement("testExecutions");
+            xml.writeAttribute("version", "1");
+        }
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            CumulativeReporterBase::testGroupEnded(testGroupStats);
+            writeGroup(*m_testGroups.back());
+        }
+
+        void testRunEndedCumulative() override {
+            xml.endElement();
+        }
+
+        void writeGroup(TestGroupNode const& groupNode) {
+            std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
+            for(auto const& child : groupNode.children)
+                testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
+
+            for(auto const& kv : testsPerFile)
+                writeTestFile(kv.first.c_str(), kv.second);
+        }
+
+        void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
+            XmlWriter::ScopedElement e = xml.scopedElement("file");
+            xml.writeAttribute("path", filename);
+
+            for(auto const& child : testCaseNodes)
+                writeTestCase(*child);
+        }
+
+        void writeTestCase(TestCaseNode const& testCaseNode) {
+            // All test cases have exactly one section - which represents the
+            // test case itself. That section may have 0-n nested sections
+            assert(testCaseNode.children.size() == 1);
+            SectionNode const& rootSection = *testCaseNode.children.front();
+            writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
+        }
+
+        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
+            std::string name = trim(sectionNode.stats.sectionInfo.name);
+            if(!rootName.empty())
+                name = rootName + '/' + name;
+
+            if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
+                XmlWriter::ScopedElement e = xml.scopedElement("testCase");
+                xml.writeAttribute("name", name);
+                xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
+
+                writeAssertions(sectionNode, okToFail);
+            }
+
+            for(auto const& childNode : sectionNode.childSections)
+                writeSection(name, *childNode, okToFail);
+        }
+
+        void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
+            for(auto const& assertion : sectionNode.assertions)
+                writeAssertion( assertion, okToFail);
+        }
+
+        void writeAssertion(AssertionStats const& stats, bool okToFail) {
+            AssertionResult const& result = stats.assertionResult;
+            if(!result.isOk()) {
+                std::string elementName;
+                if(okToFail) {
+                    elementName = "skipped";
+                }
+                else {
+                    switch(result.getResultType()) {
+                        case ResultWas::ThrewException:
+                        case ResultWas::FatalErrorCondition:
+                            elementName = "error";
+                            break;
+                        case ResultWas::ExplicitFailure:
+                            elementName = "failure";
+                            break;
+                        case ResultWas::ExpressionFailed:
+                            elementName = "failure";
+                            break;
+                        case ResultWas::DidntThrowException:
+                            elementName = "failure";
+                            break;
+
+                            // We should never see these here:
+                        case ResultWas::Info:
+                        case ResultWas::Warning:
+                        case ResultWas::Ok:
+                        case ResultWas::Unknown:
+                        case ResultWas::FailureBit:
+                        case ResultWas::Exception:
+                            elementName = "internalError";
+                            break;
+                    }
+                }
+
+                XmlWriter::ScopedElement e = xml.scopedElement(elementName);
+
+                ReusableStringStream messageRss;
+                messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
+                xml.writeAttribute("message", messageRss.str());
+
+                ReusableStringStream textRss;
+                if (stats.totals.assertions.total() > 0) {
+                    textRss << "FAILED:\n";
+                    if (result.hasExpression()) {
+                        textRss << "\t" << result.getExpressionInMacro() << "\n";
+                    }
+                    if (result.hasExpandedExpression()) {
+                        textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
+                    }
+                }
+
+                if(!result.getMessage().empty())
+                    textRss << result.getMessage() << "\n";
+
+                for(auto const& msg : stats.infoMessages)
+                    if(msg.type == ResultWas::Info)
+                        textRss << msg.message << "\n";
+
+                textRss << "at " << result.getSourceInfo();
+                xml.writeText(textRss.str(), XmlFormatting::Newline);
+            }
+        }
+
+    private:
+        XmlWriter xml;
+    };
+
+#ifdef CATCH_IMPL
+    SonarQubeReporter::~SonarQubeReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
\ No newline at end of file
diff --git a/unittest/catch2/catch_reporter_tap.hpp b/unittest/catch2/catch_reporter_tap.hpp
new file mode 100644
index 000000000..1bfe4f5e1
--- /dev/null
+++ b/unittest/catch2/catch_reporter_tap.hpp
@@ -0,0 +1,253 @@
+/*
+ *  Created by Colton Wolkins on 2015-08-15.
+ *  Copyright 2015 Martin Moene. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
+
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <algorithm>
+
+namespace Catch {
+
+    struct TAPReporter : StreamingReporterBase<TAPReporter> {
+
+        using StreamingReporterBase::StreamingReporterBase;
+
+        ~TAPReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in TAP format, suitable for test harnesses";
+        }
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        void noMatchingTestCases( std::string const& spec ) override {
+            stream << "# No test cases matched '" << spec << "'" << std::endl;
+        }
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& _assertionStats ) override {
+            ++counter;
+
+            stream << "# " << currentTestCaseInfo->name << std::endl;
+            AssertionPrinter printer( stream, _assertionStats, counter );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        void testRunEnded( TestRunStats const& _testRunStats ) override {
+            printTotals( _testRunStats.totals );
+            stream << "\n" << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+        std::size_t counter = 0;
+        class AssertionPrinter {
+        public:
+            AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
+            AssertionPrinter( AssertionPrinter const& ) = delete;
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
+            : stream( _stream )
+            , result( _stats.assertionResult )
+            , messages( _stats.infoMessages )
+            , itMessage( _stats.infoMessages.begin() )
+            , printInfoMessages( true )
+            , counter(_counter)
+            {}
+
+            void print() {
+                itMessage = messages.begin();
+
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        printResultType( passedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if ( ! result.hasExpression() )
+                            printRemainingMessages( Colour::None );
+                        else
+                            printRemainingMessages();
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if (result.isOk()) {
+                            printResultType(passedString());
+                        } else {
+                            printResultType(failedString());
+                        }
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if (result.isOk()) {
+                            printIssue(" # TODO");
+                        }
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ThrewException:
+                        printResultType( failedString() );
+                        printIssue( "unexpected exception with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        printResultType( failedString() );
+                        printIssue( "fatal error condition with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::DidntThrowException:
+                        printResultType( failedString() );
+                        printIssue( "expected exception, got none" );
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Info:
+                        printResultType( "info" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Warning:
+                        printResultType( "warning" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        printResultType( failedString() );
+                        printIssue( "explicitly" );
+                        printRemainingMessages( Colour::None );
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        printResultType( "** internal error **" );
+                        break;
+                }
+            }
+
+        private:
+            static Colour::Code dimColour() { return Colour::FileName; }
+
+            static const char* failedString() { return "not ok"; }
+            static const char* passedString() { return "ok"; }
+
+            void printSourceInfo() const {
+                Colour colourGuard( dimColour() );
+                stream << result.getSourceInfo() << ":";
+            }
+
+            void printResultType( std::string const& passOrFail ) const {
+                if( !passOrFail.empty() ) {
+                    stream << passOrFail << ' ' << counter << " -";
+                }
+            }
+
+            void printIssue( std::string const& issue ) const {
+                stream << " " << issue;
+            }
+
+            void printExpressionWas() {
+                if( result.hasExpression() ) {
+                    stream << ";";
+                    {
+                        Colour colour( dimColour() );
+                        stream << " expression was:";
+                    }
+                    printOriginalExpression();
+                }
+            }
+
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    stream << " " << result.getExpression();
+                }
+            }
+
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    {
+                        Colour colour( dimColour() );
+                        stream << " for: ";
+                    }
+                    std::string expr = result.getExpandedExpression();
+                    std::replace( expr.begin(), expr.end(), '\n', ' ');
+                    stream << expr;
+                }
+            }
+
+            void printMessage() {
+                if ( itMessage != messages.end() ) {
+                    stream << " '" << itMessage->message << "'";
+                    ++itMessage;
+                }
+            }
+
+            void printRemainingMessages( Colour::Code colour = dimColour() ) {
+                if (itMessage == messages.end()) {
+                    return;
+                }
+
+                // using messages.end() directly (or auto) yields compilation error:
+                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
+
+                {
+                    Colour colourGuard( colour );
+                    stream << " with " << pluralise( N, "message" ) << ":";
+                }
+
+                for(; itMessage != itEnd; ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
+                        stream << " '" << itMessage->message << "'";
+                        if ( ++itMessage != itEnd ) {
+                            Colour colourGuard( dimColour() );
+                            stream << " and";
+                        }
+                    }
+                }
+            }
+
+        private:
+            std::ostream& stream;
+            AssertionResult const& result;
+            std::vector<MessageInfo> messages;
+            std::vector<MessageInfo>::const_iterator itMessage;
+            bool printInfoMessages;
+            std::size_t counter;
+        };
+
+        void printTotals( const Totals& totals ) const {
+            if( totals.testCases.total() == 0 ) {
+                stream << "1..0 # Skipped: No tests ran.";
+            } else {
+                stream << "1.." << counter;
+            }
+        }
+    };
+
+#ifdef CATCH_IMPL
+    TAPReporter::~TAPReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "tap", TAPReporter )
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
diff --git a/unittest/catch2/catch_reporter_teamcity.hpp b/unittest/catch2/catch_reporter_teamcity.hpp
new file mode 100644
index 000000000..47b7e4aac
--- /dev/null
+++ b/unittest/catch2/catch_reporter_teamcity.hpp
@@ -0,0 +1,219 @@
+/*
+ *  Created by Phil Nash on 19th December 2014
+ *  Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <cstring>
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
+        TeamCityReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+        }
+
+        static std::string escape( std::string const& str ) {
+            std::string escaped = str;
+            replaceInPlace( escaped, "|", "||" );
+            replaceInPlace( escaped, "'", "|'" );
+            replaceInPlace( escaped, "\n", "|n" );
+            replaceInPlace( escaped, "\r", "|r" );
+            replaceInPlace( escaped, "[", "|[" );
+            replaceInPlace( escaped, "]", "|]" );
+            return escaped;
+        }
+        ~TeamCityReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results as TeamCity service messages";
+        }
+
+        void skipTest( TestCaseInfo const& /* testInfo */ ) override {
+        }
+
+        void noMatchingTestCases( std::string const& /* spec */ ) override {}
+
+        void testGroupStarting( GroupInfo const& groupInfo ) override {
+            StreamingReporterBase::testGroupStarting( groupInfo );
+            stream << "##teamcity[testSuiteStarted name='"
+                << escape( groupInfo.name ) << "']\n";
+        }
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
+            StreamingReporterBase::testGroupEnded( testGroupStats );
+            stream << "##teamcity[testSuiteFinished name='"
+                << escape( testGroupStats.groupInfo.name ) << "']\n";
+        }
+
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& assertionStats ) override {
+            AssertionResult const& result = assertionStats.assertionResult;
+            if( !result.isOk() ) {
+
+                ReusableStringStream msg;
+                if( !m_headerPrintedForThisSection )
+                    printSectionHeader( msg.get() );
+                m_headerPrintedForThisSection = true;
+
+                msg << result.getSourceInfo() << "\n";
+
+                switch( result.getResultType() ) {
+                    case ResultWas::ExpressionFailed:
+                        msg << "expression failed";
+                        break;
+                    case ResultWas::ThrewException:
+                        msg << "unexpected exception";
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        msg << "fatal error condition";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        msg << "no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        msg << "explicit failure";
+                        break;
+
+                    // We shouldn't get here because of the isOk() test
+                    case ResultWas::Ok:
+                    case ResultWas::Info:
+                    case ResultWas::Warning:
+                        CATCH_ERROR( "Internal error in TeamCity reporter" );
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        CATCH_ERROR( "Not implemented" );
+                }
+                if( assertionStats.infoMessages.size() == 1 )
+                    msg << " with message:";
+                if( assertionStats.infoMessages.size() > 1 )
+                    msg << " with messages:";
+                for( auto const& messageInfo : assertionStats.infoMessages )
+                    msg << "\n  \"" << messageInfo.message << "\"";
+
+
+                if( result.hasExpression() ) {
+                    msg <<
+                        "\n  " << result.getExpressionInMacro() << "\n"
+                        "with expansion:\n" <<
+                        "  " << result.getExpandedExpression() << "\n";
+                }
+
+                if( currentTestCaseInfo->okToFail() ) {
+                    msg << "- failure ignore as test marked as 'ok to fail'\n";
+                    stream << "##teamcity[testIgnored"
+                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
+                           << " message='" << escape( msg.str() ) << "'"
+                           << "]\n";
+                }
+                else {
+                    stream << "##teamcity[testFailed"
+                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
+                           << " message='" << escape( msg.str() ) << "'"
+                           << "]\n";
+                }
+            }
+            stream.flush();
+            return true;
+        }
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
+            m_headerPrintedForThisSection = false;
+            StreamingReporterBase::sectionStarting( sectionInfo );
+        }
+
+        void testCaseStarting( TestCaseInfo const& testInfo ) override {
+            m_testTimer.start();
+            StreamingReporterBase::testCaseStarting( testInfo );
+            stream << "##teamcity[testStarted name='"
+                << escape( testInfo.name ) << "']\n";
+            stream.flush();
+        }
+
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
+            StreamingReporterBase::testCaseEnded( testCaseStats );
+            if( !testCaseStats.stdOut.empty() )
+                stream << "##teamcity[testStdOut name='"
+                    << escape( testCaseStats.testInfo.name )
+                    << "' out='" << escape( testCaseStats.stdOut ) << "']\n";
+            if( !testCaseStats.stdErr.empty() )
+                stream << "##teamcity[testStdErr name='"
+                    << escape( testCaseStats.testInfo.name )
+                    << "' out='" << escape( testCaseStats.stdErr ) << "']\n";
+            stream << "##teamcity[testFinished name='"
+                    << escape( testCaseStats.testInfo.name ) << "' duration='"
+                    << m_testTimer.getElapsedMilliseconds() << "']\n";
+            stream.flush();
+        }
+
+    private:
+        void printSectionHeader( std::ostream& os ) {
+            assert( !m_sectionStack.empty() );
+
+            if( m_sectionStack.size() > 1 ) {
+                os << getLineOfChars<'-'>() << "\n";
+
+                std::vector<SectionInfo>::const_iterator
+                it = m_sectionStack.begin()+1, // Skip first section (test case)
+                itEnd = m_sectionStack.end();
+                for( ; it != itEnd; ++it )
+                    printHeaderString( os, it->name );
+                os << getLineOfChars<'-'>() << "\n";
+            }
+
+            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+            os << lineInfo << "\n";
+            os << getLineOfChars<'.'>() << "\n\n";
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        static void printHeaderString( std::ostream& os, std::string const& _string, std::size_t indent = 0 ) {
+            std::size_t i = _string.find( ": " );
+            if( i != std::string::npos )
+                i+=2;
+            else
+                i = 0;
+            os << Column( _string )
+                           .indent( indent+i)
+                           .initialIndent( indent ) << "\n";
+        }
+    private:
+        bool m_headerPrintedForThisSection = false;
+        Timer m_testTimer;
+    };
+
+#ifdef CATCH_IMPL
+    TeamCityReporter::~TeamCityReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
+
+} // end namespace Catch
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
diff --git a/unittest/config/FSFWConfig.h b/unittest/config/FSFWConfig.h
new file mode 100644
index 000000000..665c939f7
--- /dev/null
+++ b/unittest/config/FSFWConfig.h
@@ -0,0 +1,32 @@
+#ifndef CONFIG_FSFWCONFIG_H_
+#define CONFIG_FSFWCONFIG_H_
+
+#include <fsfw/unittest/config/version.h>
+
+//! Used to determine whether C++ ostreams are used
+//! Those can lead to code bloat.
+#define FSFW_CPP_OSTREAM_ENABLED 	1
+
+//! Reduced printout to further decrese code size
+//! Be careful, this also turns off most diagnostic prinouts!
+#define FSFW_REDUCED_PRINTOUT		0
+
+//! If -DDEBUG is supplied in the build defines, there will be
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiles source files)
+#ifdef DEBUG
+#define FSFW_DEBUG_OUTPUT 			1
+//! Specify whether info events are printed too.
+#define FSFW_DEBUG_INFO				1
+#include <translateObjects.h>
+#include <translateEvents.h>
+#else
+#define FSFW_DEBUG_OUTPUT			0
+#endif
+
+//! When using the newlib nano library, C99 support for stdio facilities
+//! will not be provided. This define should be set to 1 if this is the case.
+#define FSFW_NEWLIB_NANO_NO_C99_IO 	1
+
+
+#endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/unittest/config/TestsConfig.h b/unittest/config/TestsConfig.h
new file mode 100644
index 000000000..7bf667f7d
--- /dev/null
+++ b/unittest/config/TestsConfig.h
@@ -0,0 +1,8 @@
+#ifndef FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_
+#define FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_
+
+
+
+
+
+#endif /* FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_ */
diff --git a/unittest/config/cdatapool/dataPoolInit.cpp b/unittest/config/cdatapool/dataPoolInit.cpp
new file mode 100644
index 000000000..6c2278abf
--- /dev/null
+++ b/unittest/config/cdatapool/dataPoolInit.cpp
@@ -0,0 +1,48 @@
+#include <fsfw/unittest/config/cdatapool/dataPoolInit.h>
+
+void datapool::dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap) {
+	uint8_t UINT8T_INIT[1] = {0};
+	uint16_t UINT16T_INIT[1] = {0};
+	uint32_t UINT32T_INIT[1] = {0};
+	float FLOAT_INIT[2] = {0.0, 0.0};
+	/* FSFW */
+	poolMap->emplace(datapool::INTERNAL_ERROR_STORE_FULL,
+			new PoolEntry<uint32_t>(UINT32T_INIT,1));
+	poolMap->emplace(datapool::INTERNAL_ERROR_MISSED_LIVE_TM,
+			new PoolEntry<uint32_t>(UINT32T_INIT,1));
+	poolMap->emplace(datapool::INTERNAL_ERROR_FULL_MSG_QUEUES,
+			new PoolEntry<uint32_t>(UINT32T_INIT,1));
+
+	/* TEST */
+	poolMap->emplace(datapool::TEST_UINT8,
+			new PoolEntry<uint8_t>(UINT8T_INIT,1));
+	poolMap->emplace(datapool::TEST_UINT16,
+			new PoolEntry<uint16_t>(UINT16T_INIT,1));
+	poolMap->emplace(datapool::TEST_UINT32,
+			new PoolEntry<uint32_t>(UINT32T_INIT,1));
+	poolMap->emplace(datapool::TEST_FLOAT_VECTOR,
+			new PoolEntry<float>(FLOAT_INIT,2));
+
+	// With new initializer list feature and boolean entries.
+
+//	/* FSFW */
+//	poolMap->emplace(datapool::INTERNAL_ERROR_STORE_FULL,
+//			new PoolEntry<uint32_t>({0},1));
+//	poolMap->emplace(datapool::INTERNAL_ERROR_MISSED_LIVE_TM,
+//			new PoolEntry<uint32_t>({0},1));
+//	poolMap->emplace(datapool::INTERNAL_ERROR_FULL_MSG_QUEUES,
+//			new PoolEntry<uint32_t>({0},1));
+//
+//	/* TEST */
+//	poolMap->emplace(datapool::TEST_BOOLEAN,
+//			new PoolEntry<bool>({0},1));
+//	poolMap->emplace(datapool::TEST_UINT8,
+//			new PoolEntry<uint8_t>({0},1));
+//	poolMap->emplace(datapool::TEST_UINT16,
+//			new PoolEntry<uint16_t>({0},1));
+//	poolMap->emplace(datapool::TEST_UINT32,
+//			new PoolEntry<uint32_t>({0},1));
+//	poolMap->emplace(datapool::TEST_FLOAT_VECTOR,
+//			new PoolEntry<float>({0, 0},2));
+
+}
diff --git a/unittest/config/cdatapool/dataPoolInit.h b/unittest/config/cdatapool/dataPoolInit.h
new file mode 100644
index 000000000..d482cc358
--- /dev/null
+++ b/unittest/config/cdatapool/dataPoolInit.h
@@ -0,0 +1,29 @@
+#ifndef HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
+#define HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
+
+#include <fsfw/datapool/DataPool.h>
+#include <fsfw/datapool/PoolEntryIF.h>
+#include <map>
+#include <cstdint>
+
+
+namespace datapool {
+	void dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap);
+
+	enum datapoolvariables {
+		NO_PARAMETER = 0,
+
+		/** [EXPORT] : [GROUP] FSFW */
+		INTERNAL_ERROR_STORE_FULL = 0xEE000001, 	 //!< [EXPORT] : [NAME] Internal Error Store Entry [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
+		INTERNAL_ERROR_MISSED_LIVE_TM = 0xEE000001,  //!< [EXPORT] : [NAME] Internal Error Missed Live Tm [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
+		INTERNAL_ERROR_FULL_MSG_QUEUES = 0xEE000001, //!< [EXPORT] : [NAME] Internal Error Full Msg Queue [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
+
+		/** [EXPORT] : [GROUP] TEST */
+		TEST_BOOLEAN = 0x01010102, 				//!< [EXPORT] : [NAME] Test Boolean [UNIT] (-) [SIZE] 1 [TYPE] bool
+		TEST_UINT8 = 0x02020204,				//!< [EXPORT] : [NAME] Test Byte [UNIT] (-) [SIZE] 1 [TYPE] uint8_t
+		TEST_UINT16 = 0x03030306,				//!< [EXPORT] : [NAME] Test UINT16 [UNIT] (-) [SIZE] 1 [TYPE] uint16_t
+		TEST_UINT32 = 0x04040408,				//!< [EXPORT] : [NAME] Test UINT32 [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
+		TEST_FLOAT_VECTOR = 0x05050510,			//!< [EXPORT] : [NAME] Test Float [UNIT] (-) [SIZE] 2 [TYPE] float
+	};
+}
+#endif /* CONFIG_CDATAPOOL_DATAPOOLINIT_H_ */
diff --git a/unittest/config/config.mk b/unittest/config/config.mk
new file mode 100644
index 000000000..64fa87f65
--- /dev/null
+++ b/unittest/config/config.mk
@@ -0,0 +1,15 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/cdatapool/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
+
+INCLUDES += $(CURRENTPATH)
+INCLUDES += $(CURRENTPATH)/objects
+INCLUDES += $(CURRENTPATH)/ipc
+INCLUDES += $(CURRENTPATH)/pollingsequence
+INCLUDES += $(CURRENTPATH)/returnvalues
+INCLUDES += $(CURRENTPATH)/tmtc
+INCLUDES += $(CURRENTPATH)/events
+INCLUDES += $(CURRENTPATH)/devices
+INCLUDES += $(CURRENTPATH)/cdatapool
diff --git a/unittest/config/devices/logicalAddresses.cpp b/unittest/config/devices/logicalAddresses.cpp
new file mode 100644
index 000000000..157762756
--- /dev/null
+++ b/unittest/config/devices/logicalAddresses.cpp
@@ -0,0 +1,11 @@
+/**
+ * \file logicalAddresses.cpp
+ *
+ * \date 06.11.2019
+ */
+
+#include <fsfw/unittest/config/devices/logicalAddresses.h>
+
+
+
+
diff --git a/unittest/config/devices/logicalAddresses.h b/unittest/config/devices/logicalAddresses.h
new file mode 100644
index 000000000..cdf870252
--- /dev/null
+++ b/unittest/config/devices/logicalAddresses.h
@@ -0,0 +1,15 @@
+#ifndef CONFIG_DEVICES_LOGICALADDRESSES_H_
+#define CONFIG_DEVICES_LOGICALADDRESSES_H_
+
+#include <fsfw/devicehandlers/CookieIF.h>
+#include <fsfw/unittest/config/objects/systemObjectList.h>
+#include <cstdint>
+
+namespace addresses {
+	/* Logical addresses have uint32_t datatype */
+	enum logicalAddresses: address_t {
+	};
+}
+
+
+#endif /* CONFIG_DEVICES_LOGICALADDRESSES_H_ */
diff --git a/unittest/config/devices/powerSwitcherList.cpp b/unittest/config/devices/powerSwitcherList.cpp
new file mode 100644
index 000000000..cb5685229
--- /dev/null
+++ b/unittest/config/devices/powerSwitcherList.cpp
@@ -0,0 +1,10 @@
+/**
+ * @file switcherList.cpp
+ *
+ * @date 28.11.2019
+ */
+
+#include <fsfw/unittest/config/devices/powerSwitcherList.h>
+
+
+
diff --git a/unittest/config/devices/powerSwitcherList.h b/unittest/config/devices/powerSwitcherList.h
new file mode 100644
index 000000000..f5b0eb112
--- /dev/null
+++ b/unittest/config/devices/powerSwitcherList.h
@@ -0,0 +1,22 @@
+/**
+ * @file switcherList.h
+ *
+ * @date 28.11.2019
+ */
+
+#ifndef CONFIG_DEVICES_POWERSWITCHERLIST_H_
+#define CONFIG_DEVICES_POWERSWITCHERLIST_H_
+
+namespace switches {
+	/* Switches are uint8_t datatype and go from 0 to 255 */
+	enum switcherList {
+		PCDU,
+		GPS0,
+		GPS1,
+		DUMMY = 129
+	};
+
+}
+
+
+#endif /* CONFIG_DEVICES_POWERSWITCHERLIST_H_ */
diff --git a/unittest/config/events/translateEvents.cpp b/unittest/config/events/translateEvents.cpp
new file mode 100644
index 000000000..bfcbe2bc8
--- /dev/null
+++ b/unittest/config/events/translateEvents.cpp
@@ -0,0 +1,20 @@
+/**
+ * @brief    Auto-generated event translation file. Contains 80 translations.
+ * Generated on: 2020-05-02 20:13:41 
+ */
+#include <fsfw/unittest/config/events/translateEvents.h>
+
+const char *TEST_EVENT_SERVICE_1_STRING = "TEST_EVENT_SERVICE_1";
+const char *TEST2_STRING = "TEST2";
+
+const char * translateEvents(Event event){
+	switch((event&0xFFFF)){
+		case 8000:
+			return TEST_EVENT_SERVICE_1_STRING;
+		case 9100:
+			return TEST2_STRING;
+		default:
+			return "UNKNOWN_EVENT";
+	}
+	return 0;
+}
diff --git a/unittest/config/events/translateEvents.h b/unittest/config/events/translateEvents.h
new file mode 100644
index 000000000..0e40ef8ba
--- /dev/null
+++ b/unittest/config/events/translateEvents.h
@@ -0,0 +1,16 @@
+/*
+ * translateEvent.h
+ *
+ *  Created on: 28 May 2019
+ *      Author: Robin
+ */
+
+#ifndef CONFIG_EVENTS_TRANSLATEEVENTS_H_
+#define CONFIG_EVENTS_TRANSLATEEVENTS_H_
+
+#include <fsfw/events/Event.h>
+
+const char * translateEvents(Event event);
+
+
+#endif /* CONFIG_EVENTS_TRANSLATEEVENTS_H_ */
diff --git a/unittest/config/ipc/MissionMessageTypes.cpp b/unittest/config/ipc/MissionMessageTypes.cpp
new file mode 100644
index 000000000..304ca439d
--- /dev/null
+++ b/unittest/config/ipc/MissionMessageTypes.cpp
@@ -0,0 +1,11 @@
+#include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/unittest/config/ipc/MissionMessageTypes.h>
+
+void messagetypes::clearMissionMessage(CommandMessage* message) {
+	switch((message->getCommand()>>8) & 0xff) {
+	default:
+		break;
+	}
+}
+
+
diff --git a/unittest/config/ipc/MissionMessageTypes.h b/unittest/config/ipc/MissionMessageTypes.h
new file mode 100644
index 000000000..832d8e583
--- /dev/null
+++ b/unittest/config/ipc/MissionMessageTypes.h
@@ -0,0 +1,22 @@
+#ifndef CONFIG_IPC_MISSIONMESSAGETYPES_H_
+#define CONFIG_IPC_MISSIONMESSAGETYPES_H_
+
+#include <fsfw/ipc/FwMessageTypes.h>
+
+class CommandMessage;
+
+/**
+ * Custom command messages are specified here.
+ * Most messages needed to use FSFW are already located in
+ * <fsfw/ipc/FwMessageTypes.h>
+ * @param message Generic Command Message
+ */
+namespace messagetypes{
+enum MESSAGE_TYPE {
+	MISSION_MESSAGE_TYPE_START = FW_MESSAGES_COUNT,
+};
+
+void clearMissionMessage(CommandMessage* message);
+}
+
+#endif /* CONFIG_IPC_MISSIONMESSAGETYPES_H_ */
diff --git a/unittest/config/objects/Factory.cpp b/unittest/config/objects/Factory.cpp
new file mode 100644
index 000000000..e325b891b
--- /dev/null
+++ b/unittest/config/objects/Factory.cpp
@@ -0,0 +1,37 @@
+#include <fsfw/events/EventManager.h>
+#include <fsfw/health/HealthTable.h>
+
+#include <fsfw/internalError/InternalErrorReporter.h>
+#include <fsfw/objectmanager/frameworkObjects.h>
+#include <fsfw/unittest/config/cdatapool/dataPoolInit.h>
+#include <fsfw/unittest/config/objects/Factory.h>
+
+/**
+ * @brief Produces system objects.
+ * @details
+ * Build tasks by using SystemObject Interface (Interface).
+ * Header files of all tasks must be included
+ * Please note that an object has to implement the system object interface
+ * if the interface validity is checked or retrieved later by using the
+ * get<TargetInterface>(object_id) function from the ObjectManagerIF.
+ *
+ * Framework objects are created first.
+ *
+ * @ingroup init
+ */
+void Factory::produce(void) {
+	setStaticFrameworkObjectIds();
+	new EventManager(objects::EVENT_MANAGER);
+	new HealthTable(objects::HEALTH_TABLE);
+	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER,
+				datapool::INTERNAL_ERROR_FULL_MSG_QUEUES,
+				datapool::INTERNAL_ERROR_MISSED_LIVE_TM,
+				datapool::INTERNAL_ERROR_STORE_FULL);
+
+}
+
+void Factory::setStaticFrameworkObjectIds() {
+
+}
+
+
diff --git a/unittest/config/objects/Factory.h b/unittest/config/objects/Factory.h
new file mode 100644
index 000000000..84f9207e2
--- /dev/null
+++ b/unittest/config/objects/Factory.h
@@ -0,0 +1,16 @@
+#ifndef FACTORY_H_
+#define FACTORY_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+
+namespace Factory {
+	/**
+	 * @brief 	Creates all SystemObject elements which are persistent
+	 * 			during execution.
+	 */
+	void produce();
+	void setStaticFrameworkObjectIds();
+
+}
+
+#endif /* FACTORY_H_ */
diff --git a/unittest/config/objects/systemObjectList.h b/unittest/config/objects/systemObjectList.h
new file mode 100644
index 000000000..9793305ee
--- /dev/null
+++ b/unittest/config/objects/systemObjectList.h
@@ -0,0 +1,30 @@
+#ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+#define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+
+#include <cstdint>
+
+// The objects will be instantiated in the ID order
+namespace objects {
+	enum sourceObjects: uint32_t {
+		/* First Byte 0x50-0x52 reserved for PUS Services **/
+		CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
+		PUS_PACKET_DISTRIBUTOR = 0x50000200,
+		UDP_BRIDGE = 0x50000300,
+		UDP_POLLING_TASK = 0x50000400,
+
+		PUS_SERVICE_3 = 0x51000300,
+		PUS_SERVICE_6_MEM_MGMT = 0x51000500,
+		PUS_SERVICE_23 = 0x51002300,
+		PUS_SERVICE_201_HEALTH = 0x51020100,
+
+		PUS_TIME = 0x52000001,
+		PUS_FUNNEL = 0x52000002,
+
+		/* Test Task */
+		TEST_TASK = 0x42694269,
+		DUMMY_INTERFACE = 0xCAFECAFE,
+		DUMMY_HANDLER = 0x4400AFFE,
+	};
+}
+
+#endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
diff --git a/unittest/config/objects/translateObjects.cpp b/unittest/config/objects/translateObjects.cpp
new file mode 100644
index 000000000..abcb1b402
--- /dev/null
+++ b/unittest/config/objects/translateObjects.cpp
@@ -0,0 +1,242 @@
+/* Auto-generated event translation file. Contains 77 translations. */
+#include <fsfw/unittest/config/objects/translateObjects.h>
+
+const char *AT91_UART2_TEST_TASK_STRING = "AT91_UART2_TEST_TASK";
+const char *ARDUINO_0_STRING = "ARDUINO_0";
+const char *ARDUINO_1_STRING = "ARDUINO_1";
+const char *ARDUINO_2_STRING = "ARDUINO_2";
+const char *ARDUINO_3_STRING = "ARDUINO_3";
+const char *ARDUINO_4_STRING = "ARDUINO_4";
+const char *AT91_I2C_TEST_TASK_STRING = "AT91_I2C_TEST_TASK";
+const char *TEST_TASK_STRING = "TEST_TASK";
+const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
+const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
+const char *S_ADC1_DEC2_STRING = "S_ADC1_DEC2";
+const char *GPS0_HANDLER_STRING = "GPS0_HANDLER";
+const char *DLR_PVCH_STRING = "DLR_PVCH";
+const char *GYRO1_STRING = "GYRO1";
+const char *DLR_IRAS_STRING = "DLR_IRAS";
+const char *_DEC1_O1_STRING = "_DEC1_O1";
+const char *_DEC1_O2_STRING = "_DEC1_O2";
+const char *S1_DEC1_O3_STRING = "S1_DEC1_O3";
+const char *S2_DEC1_O4_STRING = "S2_DEC1_O4";
+const char *S3_DEC1_O5_STRING = "S3_DEC1_O5";
+const char *PT1000_PVHC_DEC1_O6_STRING = "PT1000_PVHC_DEC1_O6";
+const char *PT1000_CCSDS1_DEC2_STRING = "PT1000_CCSDS1_DEC2";
+const char *PT1000_MGT1_DEC2_STRING = "PT1000_MGT1_DEC2";
+const char *S4_DEC2_STRING = "S4_DEC2";
+const char *S5_DEC2_STRING = "S5_DEC2";
+const char *S6_DEC2_STRING = "S6_DEC2";
+const char *PT1000_PVCH_DEC2_STRING = "PT1000_PVCH_DEC2";
+const char *_DEC3_STRING = "_DEC3";
+const char *PT1000_CCSDS2_DEC3_STRING = "PT1000_CCSDS2_DEC3";
+const char *S7_DEC3_STRING = "S7_DEC3";
+const char *S8_DEC3_STRING = "S8_DEC3";
+const char *PT1000_PVCH_DEC3_STRING = "PT1000_PVCH_DEC3";
+const char *GYRO2_STRING = "GYRO2";
+const char *PT1000_PLOC_DEC4_STRING = "PT1000_PLOC_DEC4";
+const char *S9_DEC4_STRING = "S9_DEC4";
+const char *S10_DEC4_STRING = "S10_DEC4";
+const char *PT1000_PVHC_DEC4_STRING = "PT1000_PVHC_DEC4";
+const char *S_ADC_DEC4_STRING = "S_ADC_DEC4";
+const char *GPS1_HANDLER_STRING = "GPS1_HANDLER";
+const char *DUMMY_GPS_COM_IF_STRING = "DUMMY_GPS_COM_IF";
+const char *RS232_DEVICE_COM_IF_STRING = "RS232_DEVICE_COM_IF";
+const char *I2C_DEVICE_COM_IF_STRING = "I2C_DEVICE_COM_IF";
+const char *GPIO_DEVICE_COM_IF_STRING = "GPIO_DEVICE_COM_IF";
+const char *SPI_POLLING_TASK_STRING = "SPI_POLLING_TASK";
+const char *SPI_DEVICE_COM_IF_STRING = "SPI_DEVICE_COM_IF";
+const char *DUMMY_ECHO_COM_IF_STRING = "DUMMY_ECHO_COM_IF";
+const char *SD_CARD_HANDLER_STRING = "SD_CARD_HANDLER";
+const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
+const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
+const char *UDP_TMTC_BRIDGE_STRING = "UDP_TMTC_BRIDGE";
+const char *EMAC_POLLING_TASK_STRING = "EMAC_POLLING_TASK";
+const char *SERIAL_POLLING_TASK_STRING = "SERIAL_POLLING_TASK";
+const char *UART_TMTC_BRIDGE_STRING = "UART_TMTC_BRIDGE";
+const char *PUS_SERVICE_1_STRING = "PUS_SERVICE_1";
+const char *PUS_SERVICE_2_STRING = "PUS_SERVICE_2";
+const char *PUS_SERVICE_3_STRING = "PUS_SERVICE_3";
+const char *PUS_SERVICE_5_STRING = "PUS_SERVICE_5";
+const char *PUS_SERVICE_6_STRING = "PUS_SERVICE_6";
+const char *PUS_SERVICE_8_STRING = "PUS_SERVICE_8";
+const char *PUS_SERVICE_9_STRING = "PUS_SERVICE_9";
+const char *PUS_SERVICE_17_STRING = "PUS_SERVICE_17";
+const char *PUS_SERVICE_23_STRING = "PUS_SERVICE_23";
+const char *PUS_SERVICE_200_STRING = "PUS_SERVICE_200";
+const char *PUS_SERVICE_201_STRING = "PUS_SERVICE_201";
+const char *PUS_TIME_STRING = "PUS_TIME";
+const char *PUS_FUNNEL_STRING = "PUS_FUNNEL";
+const char *HEALTH_TABLE_STRING = "HEALTH_TABLE";
+const char *MODE_STORE_STRING = "MODE_STORE";
+const char *EVENT_MANAGER_STRING = "EVENT_MANAGER";
+const char *INTERNAL_ERROR_REPORTER_STRING = "INTERNAL_ERROR_REPORTER";
+const char *TC_STORE_STRING = "TC_STORE";
+const char *TM_STORE_STRING = "TM_STORE";
+const char *IPC_STORE_STRING = "IPC_STORE";
+const char *AT91_SPI_TEST_TASK_STRING = "AT91_SPI_TEST_TASK";
+const char *STM32_TEST_TASK_STRING = "STM32_TEST_TASK";
+const char *AT91_UART0_TEST_TASK_STRING = "AT91_UART0_TEST_TASK";
+const char *NO_OBJECT_STRING = "NO_OBJECT";
+
+const char* translateObject(object_id_t object){
+	switch((object&0xFFFFFFFF)){
+		case 0x000123336:
+			return AT91_UART2_TEST_TASK_STRING;
+		case 0x01010100:
+			return ARDUINO_0_STRING;
+		case 0x01010101:
+			return ARDUINO_1_STRING;
+		case 0x01010102:
+			return ARDUINO_2_STRING;
+		case 0x01010103:
+			return ARDUINO_3_STRING;
+		case 0x01010104:
+			return ARDUINO_4_STRING;
+		case 0x12345678:
+			return AT91_I2C_TEST_TASK_STRING;
+		case 0x42694269:
+			return TEST_TASK_STRING;
+		case 0x44003200:
+			return PCDU_HANDLER_STRING;
+		case 0x4400AFFE:
+			return DUMMY_HANDLER_STRING;
+		case 0x44020108:
+			return S_ADC1_DEC2_STRING;
+		case 0x44101F00:
+			return GPS0_HANDLER_STRING;
+		case 0x44104000:
+			return DLR_PVCH_STRING;
+		case 0x44105000:
+			return GYRO1_STRING;
+		case 0x44106000:
+			return DLR_IRAS_STRING;
+		case 0x44115401:
+			return _DEC1_O1_STRING;
+		case 0x44115402:
+			return _DEC1_O2_STRING;
+		case 0x44115404:
+			return S1_DEC1_O3_STRING;
+		case 0x44115405:
+			return S2_DEC1_O4_STRING;
+		case 0x44115406:
+			return S3_DEC1_O5_STRING;
+		case 0x44115407:
+			return PT1000_PVHC_DEC1_O6_STRING;
+		case 0x44125401:
+			return PT1000_CCSDS1_DEC2_STRING;
+		case 0x44125403:
+			return PT1000_MGT1_DEC2_STRING;
+		case 0x44125404:
+			return S4_DEC2_STRING;
+		case 0x44125405:
+			return S5_DEC2_STRING;
+		case 0x44125406:
+			return S6_DEC2_STRING;
+		case 0x44125407:
+			return PT1000_PVCH_DEC2_STRING;
+		case 0x44130301:
+			return _DEC3_STRING;
+		case 0x44130302:
+			return PT1000_CCSDS2_DEC3_STRING;
+		case 0x44130305:
+			return S7_DEC3_STRING;
+		case 0x44130306:
+			return S8_DEC3_STRING;
+		case 0x44130307:
+			return PT1000_PVCH_DEC3_STRING;
+		case 0x44130308:
+			return GYRO2_STRING;
+		case 0x44145401:
+			return PT1000_PLOC_DEC4_STRING;
+		case 0x44145404:
+			return S9_DEC4_STRING;
+		case 0x44145405:
+			return S10_DEC4_STRING;
+		case 0x44145406:
+			return PT1000_PVHC_DEC4_STRING;
+		case 0x44145407:
+			return S_ADC_DEC4_STRING;
+		case 0x44202000:
+			return GPS1_HANDLER_STRING;
+		case 0x49001F00:
+			return DUMMY_GPS_COM_IF_STRING;
+		case 0x49005200:
+			return RS232_DEVICE_COM_IF_STRING;
+		case 0x49005300:
+			return I2C_DEVICE_COM_IF_STRING;
+		case 0x49005400:
+			return GPIO_DEVICE_COM_IF_STRING;
+		case 0x49005410:
+			return SPI_POLLING_TASK_STRING;
+		case 0x49005600:
+			return SPI_DEVICE_COM_IF_STRING;
+		case 0x4900AFFE:
+			return DUMMY_ECHO_COM_IF_STRING;
+		case 0x4D0073AD:
+			return SD_CARD_HANDLER_STRING;
+		case 0x50000100:
+			return CCSDS_PACKET_DISTRIBUTOR_STRING;
+		case 0x50000200:
+			return PUS_PACKET_DISTRIBUTOR_STRING;
+		case 0x50000300:
+			return UDP_TMTC_BRIDGE_STRING;
+		case 0x50000400:
+			return EMAC_POLLING_TASK_STRING;
+		case 0x50000600:
+			return SERIAL_POLLING_TASK_STRING;
+		case 0x5000500:
+			return UART_TMTC_BRIDGE_STRING;
+		case 0x51000100:
+			return PUS_SERVICE_1_STRING;
+		case 0x51000200:
+			return PUS_SERVICE_2_STRING;
+		case 0x51000300:
+			return PUS_SERVICE_3_STRING;
+		case 0x51000400:
+			return PUS_SERVICE_5_STRING;
+		case 0x51000500:
+			return PUS_SERVICE_6_STRING;
+		case 0x51000800:
+			return PUS_SERVICE_8_STRING;
+		case 0x51000900:
+			return PUS_SERVICE_9_STRING;
+		case 0x51001700:
+			return PUS_SERVICE_17_STRING;
+		case 0x51002300:
+			return PUS_SERVICE_23_STRING;
+		case 0x51020000:
+			return PUS_SERVICE_200_STRING;
+		case 0x51020100:
+			return PUS_SERVICE_201_STRING;
+		case 0x52000001:
+			return PUS_TIME_STRING;
+		case 0x52000002:
+			return PUS_FUNNEL_STRING;
+		case 0x53010000:
+			return HEALTH_TABLE_STRING;
+		case 0x53010100:
+			return MODE_STORE_STRING;
+		case 0x53030000:
+			return EVENT_MANAGER_STRING;
+		case 0x53040000:
+			return INTERNAL_ERROR_REPORTER_STRING;
+		case 0x534f0100:
+			return TC_STORE_STRING;
+		case 0x534f0200:
+			return TM_STORE_STRING;
+		case 0x534f0300:
+			return IPC_STORE_STRING;
+		case 0x66666666:
+			return AT91_SPI_TEST_TASK_STRING;
+		case 0x77777777:
+			return STM32_TEST_TASK_STRING;
+		case 0x87654321:
+			return AT91_UART0_TEST_TASK_STRING;
+		case 0xFFFFFFFF:
+			return NO_OBJECT_STRING;
+		default:
+			return "UNKNOWN_OBJECT";
+	}
+	return 0;
+}
diff --git a/unittest/config/objects/translateObjects.h b/unittest/config/objects/translateObjects.h
new file mode 100644
index 000000000..18c237eb6
--- /dev/null
+++ b/unittest/config/objects/translateObjects.h
@@ -0,0 +1,16 @@
+/*
+ * translateObjects.h
+ *
+ *  Created on: 28 May 2019
+ *      Author: Robin
+ */
+
+#ifndef CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
+#define CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
+
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+
+const char* translateObject(object_id_t object);
+
+
+#endif /* CONFIG_OBJECTS_TRANSLATEOBJECTS_H_ */
diff --git a/unittest/config/pollingsequence/PollingSequenceFactory.cpp b/unittest/config/pollingsequence/PollingSequenceFactory.cpp
new file mode 100644
index 000000000..dbe13add5
--- /dev/null
+++ b/unittest/config/pollingsequence/PollingSequenceFactory.cpp
@@ -0,0 +1,31 @@
+#include <PollingSequenceFactory.h>
+#include <systemObjectList.h>
+
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+
+ReturnValue_t pst::pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence)
+{
+	/* Length of a communication cycle */
+	uint32_t length = thisSequence->getPeriodMs();
+
+    thisSequence->addSlot(objects::DUMMY_HANDLER,
+            length * 0,  DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::DUMMY_HANDLER,
+            length * 0.25, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::DUMMY_HANDLER,
+            length * 0.5,  DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::DUMMY_HANDLER,
+            length * 0.75, DeviceHandlerIF::GET_READ);
+
+	if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		sif::error << "PollingSequence::initialize has errors!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
diff --git a/unittest/config/pollingsequence/PollingSequenceFactory.h b/unittest/config/pollingsequence/PollingSequenceFactory.h
new file mode 100644
index 000000000..b6cc2f1ee
--- /dev/null
+++ b/unittest/config/pollingsequence/PollingSequenceFactory.h
@@ -0,0 +1,31 @@
+#ifndef POLLINGSEQUENCEFACTORY_H_
+#define POLLINGSEQUENCEFACTORY_H_
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+class FixedTimeslotTaskIF;
+
+/**
+ * All device handlers are scheduled by adding them into
+ * Polling Sequence Tables (PST) to satisfy stricter timing requirements of
+ * device communication, a device handler has four different communication steps:
+ *   1. DeviceHandlerIF::SEND_WRITE -> Send write via interface
+ *   2. DeviceHandlerIF::GET_WRITE -> Get confirmation for write
+ *   3. DeviceHandlerIF::SEND_READ -> Send read request
+ *   4. DeviceHandlerIF::GET_READ -> Read from interface
+ * The PST specifies precisely when the respective ComIF functions are called
+ * during the communication cycle time.
+ * The task is created using the FixedTimeslotTaskIF,
+ * which utilises the underlying Operating System Abstraction Layer (OSAL)
+ *
+ * @param thisSequence FixedTimeslotTaskIF * object is passed inside the
+ * 					   Factory class when creating the PST
+ * @return
+ */
+namespace pst {
+
+/* 0.4 second period init*/
+ReturnValue_t pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence);
+
+}
+
+#endif /* POLLINGSEQUENCEINIT_H_ */
diff --git a/unittest/config/returnvalues/classIds.h b/unittest/config/returnvalues/classIds.h
new file mode 100644
index 000000000..a024e3d74
--- /dev/null
+++ b/unittest/config/returnvalues/classIds.h
@@ -0,0 +1,28 @@
+/*
+ * classIds.h
+ *
+ *  Created on: 16.07.2018
+ *      Author: mohr
+ */
+
+#ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
+#define CONFIG_RETURNVALUES_CLASSIDS_H_
+
+/**
+ * Source IDs starts at 73 for now
+ * Framework IDs for ReturnValues run from 0 to 56
+ * and are located inside <fsfw/returnvalues/FwClassIds.h>
+ */
+namespace CLASS_ID {
+enum {
+	MISSION_CLASS_ID_START = FW_CLASS_ID_COUNT,
+	RS232_CHANNEL, //!< RS232
+	I2C_CHANNEL, //!< I2C
+	SPI_CHANNEL, //!< SPI
+	GPS_HANDLER,  //!< GPS
+	PUS_SERVICE_3 //!< HKS
+};
+}
+
+
+#endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */
diff --git a/unittest/config/tmtc/PusIds.hpp b/unittest/config/tmtc/PusIds.hpp
new file mode 100644
index 000000000..fd37c7f49
--- /dev/null
+++ b/unittest/config/tmtc/PusIds.hpp
@@ -0,0 +1,29 @@
+/*
+ * PusIds.hpp
+ *
+ *  Created on: 27.02.2019
+ *      Author: jakob
+ */
+
+#ifndef CONFIG_TMTC_PUSIDS_HPP_
+#define CONFIG_TMTC_PUSIDS_HPP_
+
+namespace PUS{
+enum Ids{
+	PUS_SERVICE_1 = 1,
+	PUS_SERVICE_2 = 2,
+	PUS_SERVICE_3 = 3,
+	PUS_SERVICE_5 = 5,
+	PUS_SERVICE_6 = 6,
+	PUS_SERVICE_8 = 8,
+	PUS_SERVICE_9 = 9,
+	PUS_SERVICE_17 = 17,
+	PUS_SERVICE_23 = 23,
+	PUS_SERVICE_200 = 200,
+	PUS_SERVICE_201 = 201,
+};
+};
+
+
+
+#endif /* CONFIG_TMTC_PUSIDS_HPP_ */
diff --git a/unittest/config/tmtc/apid.h b/unittest/config/tmtc/apid.h
new file mode 100644
index 000000000..77e55952e
--- /dev/null
+++ b/unittest/config/tmtc/apid.h
@@ -0,0 +1,19 @@
+#ifndef CONFIG_TMTC_APID_H_
+#define CONFIG_TMTC_APID_H_
+
+#include <stdint.h>
+
+/**
+ * Application Process Definition: entity, uniquely identified by an
+ * application process ID (APID), capable of generating telemetry source
+ * packets and receiving telecommand packets
+ *
+ * SOURCE APID: 0x73 / 115 / s
+ * APID is a 11 bit number
+ */
+namespace apid {
+	static const uint16_t SOURCE_OBSW = 0x73;
+}
+
+
+#endif /* CONFIG_TMTC_APID_H_ */
diff --git a/unittest/config/tmtc/pusIds.h b/unittest/config/tmtc/pusIds.h
new file mode 100644
index 000000000..a2dd75759
--- /dev/null
+++ b/unittest/config/tmtc/pusIds.h
@@ -0,0 +1,23 @@
+#ifndef CONFIG_TMTC_PUSIDS_HPP_
+#define CONFIG_TMTC_PUSIDS_HPP_
+
+namespace pus {
+enum Ids{
+	PUS_SERVICE_1 = 1,
+	PUS_SERVICE_2 = 2,
+	PUS_SERVICE_3 = 3,
+	PUS_SERVICE_3_PSB = 3,
+	PUS_SERVICE_5 = 5,
+	PUS_SERVICE_6 = 6,
+	PUS_SERVICE_8 = 8,
+	PUS_SERVICE_9 = 9,
+	PUS_SERVICE_17 = 17,
+	PUS_SERVICE_19 = 19,
+	PUS_SERVICE_20 = 20,
+	PUS_SERVICE_23 = 23,
+	PUS_SERVICE_200 = 200,
+	PUS_SERVICE_201 = 201,
+};
+};
+
+#endif /* CONFIG_TMTC_PUSIDS_HPP_ */
diff --git a/unittest/config/tmtc/subsystemIdRanges.h b/unittest/config/tmtc/subsystemIdRanges.h
new file mode 100644
index 000000000..e32de74c5
--- /dev/null
+++ b/unittest/config/tmtc/subsystemIdRanges.h
@@ -0,0 +1,34 @@
+#ifndef CONFIG_TMTC_SUBSYSTEMIDRANGES_H_
+#define CONFIG_TMTC_SUBSYSTEMIDRANGES_H_
+
+#include <fsfw/events/fwSubsystemIdRanges.h>
+#include <cstdint>
+
+/**
+ * These IDs are part of the ID for an event thrown by a subsystem.
+ * Numbers 0-80 are reserved for FSFW Subsystem IDs (framework/events/)
+ */
+namespace SUBSYSTEM_ID {
+enum: uint8_t {
+	SUBSYSTE_ID_START = FW_SUBSYSTEM_ID_RANGE,
+	/**
+	 * 80-105: PUS Services
+	 */
+	PUS_SERVICE_2 = 82,
+	PUS_SERVICE_3 = 83,
+	PUS_SERVICE_5 = 85,
+	PUS_SERVICE_6 = 86,
+	PUS_SERVICE_8 = 88,
+	PUS_SERVICE_23 = 91,
+	DUMMY_DEVICE = 100,
+	/**
+	 * 105-115: AOCS
+	 */
+	GPS_DEVICE = 105,
+
+	SPI_COM_IF = 128,
+	I2C_COM_IF = 138
+};
+}
+
+#endif /* CONFIG_TMTC_SUBSYSTEMIDRANGES_H_ */
diff --git a/unittest/config/tmtc/tmTcSize.h b/unittest/config/tmtc/tmTcSize.h
new file mode 100644
index 000000000..de7f4adca
--- /dev/null
+++ b/unittest/config/tmtc/tmTcSize.h
@@ -0,0 +1,10 @@
+#ifndef CONFIG_TMTC_TMTCSIZE_H_
+#define CONFIG_TMTC_TMTCSIZE_H_
+
+#include <cstdint>
+
+namespace tmtcsize {
+static const uint32_t MAX_TM_PACKET = 50;
+}
+
+#endif /* CONFIG_TMTC_TMTCSIZE_H_ */
diff --git a/unittest/config/version.h b/unittest/config/version.h
new file mode 100644
index 000000000..f53345c1e
--- /dev/null
+++ b/unittest/config/version.h
@@ -0,0 +1,7 @@
+#ifndef CONFIG_VERSION_H_
+#define CONFIG_VERSION_H_
+
+#define SW_VERSION      1
+#define SW_SUBVERSION   6
+
+#endif /* CONFIG_VERSION_H_ */
diff --git a/unittest/core/CatchDefinitions.cpp b/unittest/core/CatchDefinitions.cpp
new file mode 100644
index 000000000..3f4614e81
--- /dev/null
+++ b/unittest/core/CatchDefinitions.cpp
@@ -0,0 +1,11 @@
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+StorageManagerIF* tglob::getIpcStoreHandle() {
+	if(objectManager != nullptr) {
+		return objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	} else {
+		sif::error << "Global object manager uninitialized" << std::endl;
+		return nullptr;
+	}
+}
diff --git a/unittest/core/CatchDefinitions.h b/unittest/core/CatchDefinitions.h
new file mode 100644
index 000000000..cdc025fa1
--- /dev/null
+++ b/unittest/core/CatchDefinitions.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <fsfw/ipc/messageQueueDefinitions.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/storagemanager/StorageManagerIF.h>
+
+namespace retval {
+static constexpr int CATCH_OK = static_cast<int>(HasReturnvaluesIF::RETURN_OK);
+static constexpr int CATCH_FAILED = static_cast<int>(HasReturnvaluesIF::RETURN_FAILED);
+}
+
+namespace tconst {
+	static constexpr MessageQueueId_t testQueueId = 42;
+}
+
+namespace tglob {
+	StorageManagerIF* getIpcStoreHandle();
+}
+
diff --git a/unittest/core/CatchRunner.cpp b/unittest/core/CatchRunner.cpp
new file mode 100644
index 000000000..566db692c
--- /dev/null
+++ b/unittest/core/CatchRunner.cpp
@@ -0,0 +1,27 @@
+/**
+ * @file 	CatchSource.cpp
+ * @brief 	Source file to compile catch framework.
+ * @details	All tests should be written in other files.
+ * For eclipse console output, install ANSI Escape in Console
+ * from the eclipse market place to get colored characters.
+ */
+
+#ifndef NO_UNIT_TEST_FRAMEWORK
+
+#define CATCH_CONFIG_RUNNER
+#include <fsfw/unittest/catch2/catch.hpp>
+
+extern int customSetup();
+
+int main( int argc, char* argv[] ) {
+    customSetup();
+
+    // Catch internal function call
+    int result = Catch::Session().run( argc, argv );
+
+    // global clean-up
+    return result;
+}
+
+
+#endif
diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
new file mode 100644
index 000000000..5436fd5df
--- /dev/null
+++ b/unittest/core/CatchSetup.cpp
@@ -0,0 +1,41 @@
+#include "../config/cdatapool/dataPoolInit.h"
+#include <fsfw/unittest/config/cdatapool/dataPoolInit.h>
+#include <fsfw/unittest/config/objects/Factory.h>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+#ifdef GCOV
+#include <gcov.h>
+#endif
+
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/storagemanager/StorageManagerIF.h>
+#include <fsfw/datapool/DataPool.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+
+
+/* Global instantiations normally done in main.cpp */
+/* Initialize Data Pool */
+//namespace glob {
+DataPool dataPool(datapool::dataPoolInit);
+//}
+
+
+namespace sif {
+/* Set up output streams */
+ServiceInterfaceStream debug("DEBUG");
+ServiceInterfaceStream info("INFO");
+ServiceInterfaceStream error("ERROR");
+ServiceInterfaceStream warning("WARNING");
+}
+
+/* Global object manager */
+ObjectManagerIF *objectManager;
+
+int customSetup() {
+    // global setup
+    objectManager = new ObjectManager(Factory::produce);
+    objectManager -> initialize();
+    return 0;
+}
+
diff --git a/unittest/core/core.mk b/unittest/core/core.mk
new file mode 100644
index 000000000..3e5626d33
--- /dev/null
+++ b/unittest/core/core.mk
@@ -0,0 +1,3 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
+
+INCLUDES += $(CURRENTPATH)
\ No newline at end of file
diff --git a/unittest/core/printChar.cpp b/unittest/core/printChar.cpp
new file mode 100644
index 000000000..755a13b22
--- /dev/null
+++ b/unittest/core/printChar.cpp
@@ -0,0 +1,10 @@
+#include <fsfw/unittest/core/printChar.h>
+#include <cstdio>
+
+void printChar(const char* character, bool errStream) {
+	if(errStream) {
+		std::putc(*character, stderr);
+		return;
+	}
+	std::putc(*character, stdout);
+}
diff --git a/unittest/core/printChar.h b/unittest/core/printChar.h
new file mode 100644
index 000000000..80e867f67
--- /dev/null
+++ b/unittest/core/printChar.h
@@ -0,0 +1,8 @@
+#ifndef FSFW_UNITTEST_CORE_PRINTCHAR_H_
+#define FSFW_UNITTEST_CORE_PRINTCHAR_H_
+
+
+extern "C" void printChar(const char*, bool errStream);
+
+
+#endif /* FSFW_UNITTEST_CORE_PRINTCHAR_H_ */
diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
new file mode 100644
index 000000000..9b219f09b
--- /dev/null
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -0,0 +1,26 @@
+#include <unittest/internal/InternalUnitTester.h>
+#include <unittest/internal/IntTestMq.h>
+#include <unittest/internal/IntTestSemaphore.h>
+#include <unittest/internal/IntTestSerialization.h>
+#include <unittest/internal/UnittDefinitions.h>
+#include <unittest/internal/IntTestMutex.h>
+
+#include <cstdlib>
+
+InternalUnitTester::InternalUnitTester() {}
+
+InternalUnitTester::~InternalUnitTester() {}
+
+ReturnValue_t InternalUnitTester::performTests() {
+	sif::info << "Running internal unit tests..\r\n" << std::flush;
+	testserialize::test_serialization();
+	testmq::testMq();
+	testsemaph::testBinSemaph();
+	testsemaph::testCountingSemaph();
+	testmutex::testMutex();
+	sif::info << "Internal unit tests finished.\r\n" << std::flush;
+	return RETURN_OK;
+}
+
+
+
diff --git a/unittest/internal/InternalUnitTester.h b/unittest/internal/InternalUnitTester.h
new file mode 100644
index 000000000..b61c8bfe4
--- /dev/null
+++ b/unittest/internal/InternalUnitTester.h
@@ -0,0 +1,29 @@
+#ifndef FRAMEWORK_TEST_UNITTESTCLASS_H_
+#define FRAMEWORK_TEST_UNITTESTCLASS_H_
+
+#include <unittest/internal/UnittDefinitions.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+/**
+ * @brief	Can be used for internal testing, for example for hardware specific
+ * 			tests which can not be run on a host-machine.
+ *
+ * TODO: A lot of ways to improve this class. A way for tests to subscribe
+ * 		 in this central class would be nice. Right now, this is the class
+ * 		 which simply calls all other tests from other files manually.
+ * 		 Maybe there is a better way..
+ */
+class InternalUnitTester: public HasReturnvaluesIF {
+public:
+	InternalUnitTester();
+	virtual~ InternalUnitTester();
+
+	/**
+	 * Some function which calls all other tests
+	 * @return
+	 */
+	ReturnValue_t performTests();
+};
+
+
+#endif /* FRAMEWORK_TEST_UNITTESTCLASS_H_ */
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
new file mode 100644
index 000000000..0bdbfcc72
--- /dev/null
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -0,0 +1,7 @@
+#include <fsfw/unittest/internal/UnittDefinitions.h>
+
+ ReturnValue_t unitt::put_error(std::string errorId) {
+	sif::error << "Unit Tester error: Failed at test ID "
+			<< errorId << "\n" << std::flush;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
diff --git a/unittest/internal/UnittDefinitions.h b/unittest/internal/UnittDefinitions.h
new file mode 100644
index 000000000..ea36fea40
--- /dev/null
+++ b/unittest/internal/UnittDefinitions.h
@@ -0,0 +1,33 @@
+#ifndef UNITTEST_INTERNAL_UNITTDEFINITIONS_H_
+#define UNITTEST_INTERNAL_UNITTDEFINITIONS_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <cstdint>
+#include <cstddef>
+
+namespace tv {
+// POD test values
+static const bool tv_bool = true;
+static const uint8_t tv_uint8   {5};
+static const uint16_t tv_uint16 {283};
+static const uint32_t tv_uint32 {929221};
+static const uint64_t tv_uint64 {2929329429};
+
+static const int8_t tv_int8 {-16};
+static const int16_t tv_int16 {-829};
+static const int32_t tv_int32 {-2312};
+
+static const float tv_float {8.2149214};
+static const float tv_sfloat = {-922.2321321};
+static const double tv_double {9.2132142141e8};
+static const double tv_sdouble {-2.2421e19};
+}
+
+namespace unitt {
+ReturnValue_t put_error(std::string errorId);
+}
+
+
+
+#endif /* UNITTEST_INTERNAL_UNITTDEFINITIONS_H_ */
diff --git a/unittest/internal/osal/IntTestMq.cpp b/unittest/internal/osal/IntTestMq.cpp
new file mode 100644
index 000000000..265aa62a9
--- /dev/null
+++ b/unittest/internal/osal/IntTestMq.cpp
@@ -0,0 +1,52 @@
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <unittest/internal/IntTestMq.h>
+#include <unittest/internal/UnittDefinitions.h>
+
+#include <array>
+
+using retval = HasReturnvaluesIF;
+
+void testmq::testMq() {
+	std::string id = "[testMq]";
+	MessageQueueIF* testSenderMq =
+			QueueFactory::instance()->createMessageQueue(1);
+	MessageQueueId_t testSenderMqId = testSenderMq->getId();
+
+	MessageQueueIF* testReceiverMq =
+			QueueFactory::instance()->createMessageQueue(1);
+	MessageQueueId_t testReceiverMqId = testReceiverMq->getId();
+	std::array<uint8_t, 20> testData { 0 };
+	testData[0] = 42;
+	MessageQueueMessage testMessage(testData.data(), 1);
+	testSenderMq->setDefaultDestination(testReceiverMqId);
+
+
+	auto result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+	if(result != retval::RETURN_OK) {
+		unitt::put_error(id);
+	}
+	MessageQueueMessage recvMessage;
+	result = testReceiverMq->receiveMessage(&recvMessage);
+	if(result != retval::RETURN_OK or recvMessage.getData()[0] != 42) {
+		unitt::put_error(id);
+	}
+
+	result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+	if(result != retval::RETURN_OK) {
+		unitt::put_error(id);
+	}
+	MessageQueueId_t senderId = 0;
+	result = testReceiverMq->receiveMessage(&recvMessage,&senderId);
+	if(result != retval::RETURN_OK or recvMessage.getData()[0] != 42) {
+		unitt::put_error(id);
+	}
+	if(senderId != testSenderMqId) {
+		unitt::put_error(id);
+	}
+	senderId = testReceiverMq->getLastPartner();
+	if(senderId != testSenderMqId) {
+		unitt::put_error(id);
+	}
+
+}
diff --git a/unittest/internal/osal/IntTestMq.h b/unittest/internal/osal/IntTestMq.h
new file mode 100644
index 000000000..bc12a9b08
--- /dev/null
+++ b/unittest/internal/osal/IntTestMq.h
@@ -0,0 +1,9 @@
+#ifndef UNITTEST_INTERNAL_INTESTMQ_H_
+#define UNITTEST_INTERNAL_INTESTMQ_H_
+
+namespace testmq {
+void testMq();
+}
+
+
+#endif /* UNITTEST_INTERNAL_INTESTMQ_H_ */
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
new file mode 100644
index 000000000..bf0b827d9
--- /dev/null
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -0,0 +1,41 @@
+#include <unittest/internal/IntTestMutex.h>
+#include <fsfw/ipc/MutexFactory.h>
+#include <unittest/internal/UnittDefinitions.h>
+
+#if defined(hosted)
+#include <fsfw/osal/hosted/Mutex.h>
+#include <thread>
+#include <future>
+#endif
+
+
+void testmutex::testMutex() {
+	std::string id = "[testMutex]";
+	MutexIF* mutex = MutexFactory::instance()->createMutex();
+	auto result = mutex->lockMutex(MutexIF::POLLING);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		unitt::put_error(id);
+	}
+	// timed_mutex from the C++ library specifies undefined behaviour if
+	// the timed mutex is locked twice from the same thread.
+#if defined(hosted)
+	// hold on, this actually worked ? :-D This calls the function from
+	// another thread and stores the returnvalue in a future.
+	auto future = std::async(&MutexIF::lockMutex, mutex, 1);
+	result = future.get();
+#else
+	result = mutex->lockMutex(MutexIF::TimeoutType::WAITING, 1);
+#endif
+	if(result != MutexIF::MUTEX_TIMEOUT) {
+		unitt::put_error(id);
+	}
+
+	result = mutex->unlockMutex();
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		unitt::put_error(id);
+	}
+	result = mutex->unlockMutex();
+	if(result != MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX) {
+		unitt::put_error(id);
+	}
+}
diff --git a/unittest/internal/osal/IntTestMutex.h b/unittest/internal/osal/IntTestMutex.h
new file mode 100644
index 000000000..b467ea636
--- /dev/null
+++ b/unittest/internal/osal/IntTestMutex.h
@@ -0,0 +1,10 @@
+#ifndef UNITTEST_INTERNAL_INTTESTMUTEX_H_
+#define UNITTEST_INTERNAL_INTTESTMUTEX_H_
+
+namespace testmutex {
+void testMutex();
+}
+
+
+
+#endif /* UNITTEST_INTERNAL_INTTESTMUTEX_H_ */
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
new file mode 100644
index 000000000..176db4de6
--- /dev/null
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -0,0 +1,159 @@
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <unittest/internal/UnittDefinitions.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/timemanager/Stopwatch.h>
+#include <unittest/internal/IntTestSemaphore.h>
+
+void testsemaph::testBinSemaph() {
+	std::string id = "[BinSemaphore]";
+	SemaphoreIF* binSemaph =
+			SemaphoreFactory::instance()->createBinarySemaphore();
+	if(binSemaph == nullptr) {
+		return;
+	}
+	testBinSemaphoreImplementation(binSemaph, id);
+	SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
+#if defined(freeRTOS)
+	SemaphoreIF* binSemaphUsingTask =
+			SemaphoreFactory::instance()->createBinarySemaphore(1);
+	testBinSemaphoreImplementation(binSemaphUsingTask, id);
+	SemaphoreFactory::instance()->deleteSemaphore(binSemaphUsingTask);
+#endif
+}
+
+
+void testsemaph::testCountingSemaph() {
+	std::string id = "[CountingSemaph]";
+	{
+		// First test: create a binary semaphore by using a counting semaphore.
+		SemaphoreIF* countingSemaph = SemaphoreFactory::instance()->
+				createCountingSemaphore(1,1);
+		if(countingSemaph == nullptr) {
+			return;
+		}
+		testBinSemaphoreImplementation(countingSemaph, id);
+		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#if defined(freeRTOS)
+		countingSemaph = SemaphoreFactory::instance()->
+				createCountingSemaphore(1, 1, 1);
+		testBinSemaphoreImplementation(countingSemaph, id);
+		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#endif
+	}
+
+	{
+		// Second test: counting semaphore with count 3 and init count of 3.
+		SemaphoreIF* countingSemaph = SemaphoreFactory::instance()->
+				createCountingSemaphore(3,3);
+		testCountingSemaphImplementation(countingSemaph, id);
+		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#if defined(freeRTOS)
+		countingSemaph = SemaphoreFactory::instance()->
+				createCountingSemaphore(3, 0, 1);
+		uint8_t semaphCount = countingSemaph->getSemaphoreCounter();
+		if(semaphCount != 0) {
+			unitt::put_error(id);
+		}
+		// release 3 times in a row
+		for(int i = 0; i < 3; i++) {
+			auto result = countingSemaph->release();
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				unitt::put_error(id);
+			}
+		}
+		testCountingSemaphImplementation(countingSemaph, id);
+		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#endif
+	}
+}
+
+
+void testsemaph::testBinSemaphoreImplementation(SemaphoreIF* binSemaph,
+		std::string id) {
+	uint8_t semaphCount = binSemaph->getSemaphoreCounter();
+	if(semaphCount != 1) {
+		unitt::put_error(id);
+	}
+
+	ReturnValue_t result = binSemaph->release();
+	if(result != SemaphoreIF::SEMAPHORE_NOT_OWNED) {
+		unitt::put_error(id);
+	}
+	result = binSemaph->acquire(SemaphoreIF::BLOCKING);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		unitt::put_error(id);
+	}
+
+	// There is not really a point in testing time related, the task
+	// might get interrupted..
+	{
+		//Stopwatch stopwatch(false);
+		result = binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
+		//dur_millis_t time = stopwatch.stop();
+//		if(abs(time - 10) > 2) {
+//		    sif::error << "UnitTester: Semaphore timeout measured incorrect."
+//		            << std::endl;
+//			unitt::put_error(id);
+//		}
+	}
+
+	if(result != SemaphoreIF::SEMAPHORE_TIMEOUT) {
+		unitt::put_error(id);
+	}
+
+	semaphCount = binSemaph->getSemaphoreCounter();
+	if(semaphCount != 0) {
+		unitt::put_error(id);
+	}
+
+	result = binSemaph->release();
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		unitt::put_error(id);
+	}
+}
+
+void testsemaph::testCountingSemaphImplementation(SemaphoreIF* countingSemaph,
+		std::string id) {
+	// check count getter function
+	uint8_t semaphCount = countingSemaph->getSemaphoreCounter();
+	if(semaphCount != 3) {
+		unitt::put_error(id);
+	}
+	ReturnValue_t result = countingSemaph->release();
+	if(result != SemaphoreIF::SEMAPHORE_NOT_OWNED) {
+		unitt::put_error(id);
+	}
+	// acquire 3 times in a row
+	for(int i = 0; i < 3; i++) {
+		result = countingSemaph->acquire(SemaphoreIF::BLOCKING);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			unitt::put_error(id);
+		}
+	}
+
+	{
+		Stopwatch stopwatch(false);
+		// attempt to take when count is 0, measure time
+		result = countingSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
+		dur_millis_t time = stopwatch.stop();
+		if(abs(time - 10) > 1) {
+			unitt::put_error(id);
+		}
+	}
+
+	if(result != SemaphoreIF::SEMAPHORE_TIMEOUT) {
+		unitt::put_error(id);
+	}
+
+	// release 3 times in a row
+	for(int i = 0; i < 3; i++) {
+		result = countingSemaph->release();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			unitt::put_error(id);
+		}
+	}
+	// assert correct full count
+	if(countingSemaph->getSemaphoreCounter() != 3) {
+		unitt::put_error(id);
+	}
+}
diff --git a/unittest/internal/osal/IntTestSemaphore.h b/unittest/internal/osal/IntTestSemaphore.h
new file mode 100644
index 000000000..af26c131f
--- /dev/null
+++ b/unittest/internal/osal/IntTestSemaphore.h
@@ -0,0 +1,15 @@
+#ifndef UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_
+#define UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_
+class SemaphoreIF;
+#include <string>
+
+namespace testsemaph {
+void testBinSemaph();
+void testBinSemaphoreImplementation(SemaphoreIF* binSemaph, std::string id);
+void testCountingSemaph();
+void testCountingSemaphImplementation(SemaphoreIF* countingSemaph,
+		std::string id);
+}
+
+
+#endif /* UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_ */
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
new file mode 100644
index 000000000..2452ac6db
--- /dev/null
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -0,0 +1,230 @@
+#include <unittest/internal/IntTestSerialization.h>
+#include <fsfw/serialize/SerializeElement.h>
+#include <fsfw/serialize/SerialBufferAdapter.h>
+#include <unittest/internal/UnittDefinitions.h>
+#include <fsfw/serialize/SerializeIF.h>
+#include <array>
+
+using retval = HasReturnvaluesIF;
+std::array<uint8_t, 512> testserialize::test_array = { 0 };
+
+ReturnValue_t testserialize::test_serialization() {
+	// Here, we test all serialization tools. First test basic cases.
+	ReturnValue_t result = test_endianness_tools();
+	if(result != retval::RETURN_OK) {
+		return result;
+	}
+	result = test_autoserialization();
+	if(result != retval::RETURN_OK) {
+		return result;
+	}
+	result = test_serial_buffer_adapter();
+	if(result != retval::RETURN_OK) {
+		return result;
+	}
+	return retval::RETURN_OK;
+}
+
+ReturnValue_t testserialize::test_endianness_tools() {
+	std::string id = "[test_endianness_tools]";
+	test_array[0] = 0;
+	test_array[1] = 0;
+	uint16_t two_byte_value = 1;
+	size_t size = 0;
+	uint8_t* p_array = test_array.data();
+	SerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2,
+	        SerializeIF::Endianness::MACHINE);
+	// Little endian: Value one on first byte
+	if(test_array[0] != 1 and test_array[1] != 0) {
+		return unitt::put_error(id);
+
+	}
+
+	p_array = test_array.data();
+	size = 0;
+	SerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2,
+	        SerializeIF::Endianness::BIG);
+	// Big endian: Value one on second byte
+	if(test_array[0] != 0 and test_array[1] != 1) {
+		return unitt::put_error(id);
+	}
+	return retval::RETURN_OK;
+}
+
+ReturnValue_t testserialize::test_autoserialization() {
+	std::string id = "[test_autoserialization]";
+	// Unit Test getSerializedSize
+	if(SerializeAdapter::
+			getSerializedSize(&tv::tv_bool) != sizeof(tv::tv_bool) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_uint8) != sizeof(tv::tv_uint8) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_uint16) != sizeof(tv::tv_uint16) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_uint32) != sizeof(tv::tv_uint32) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_uint64) != sizeof(tv::tv_uint64) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_int8) != sizeof(tv::tv_int8) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_double) != sizeof(tv::tv_double) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_int16) != sizeof(tv::tv_int16) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_int32) != sizeof(tv::tv_int32) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_float) != sizeof(tv::tv_float))
+	{
+		return unitt::put_error(id);
+	}
+
+	size_t serialized_size = 0;
+	uint8_t * p_array = test_array.data();
+
+	SerializeAdapter::serialize(&tv::tv_bool, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_uint8, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_uint16, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_uint32, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_int8, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_int16, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_int32, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_uint64, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_float, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_double, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_sfloat, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_sdouble, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	// expected size is 1 + 1 + 2 + 4 + 1 + 2 + 4 + 8 + 4 + 8 + 4 + 8
+	if(serialized_size != 47) {
+		return unitt::put_error(id);
+	}
+
+	p_array = test_array.data();
+	size_t remaining_size = serialized_size;
+	bool tv_bool;
+	uint8_t tv_uint8;
+	uint16_t tv_uint16;
+	uint32_t tv_uint32;
+	int8_t tv_int8;
+	int16_t tv_int16;
+	int32_t tv_int32;
+	uint64_t tv_uint64;
+	float tv_float;
+	double tv_double;
+	float tv_sfloat;
+	double tv_sdouble;
+
+	SerializeAdapter::deSerialize(&tv_bool,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_uint8,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_uint16,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_uint32,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_int8,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_int16,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_int32,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_uint64,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_float,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_double,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_sfloat,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_sdouble,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+
+	if(tv_bool != tv::tv_bool or tv_uint8 != tv::tv_uint8 or
+			tv_uint16 != tv::tv_uint16 or tv_uint32 != tv::tv_uint32 or
+			tv_uint64 != tv::tv_uint64 or tv_int8 != tv::tv_int8 or
+			tv_int16 != tv::tv_int16 or tv_int32 != tv::tv_int32)
+	{
+		return unitt::put_error(id);
+	}
+
+	// These epsilon values were just guessed.. It appears to work though.
+	if(abs(tv_float - tv::tv_float) > 0.0001 or
+			abs(tv_double - tv::tv_double) > 0.01 or
+			abs(tv_sfloat - tv::tv_sfloat) > 0.0001 or
+			abs(tv_sdouble - tv::tv_sdouble) > 0.01) {
+		return unitt::put_error(id);
+	}
+
+	// Check overflow
+	return retval::RETURN_OK;
+}
+
+// TODO: Also test for constant buffers.
+ReturnValue_t testserialize::test_serial_buffer_adapter() {
+	std::string id = "[test_serial_buffer_adapter]";
+
+	// I will skip endian swapper testing, its going to be changed anyway..
+	// uint8_t tv::tv_uint8_swapped = EndianSwapper::swap(tv::tv_uint8);
+
+	size_t serialized_size = 0;
+	uint8_t * p_array = test_array.data();
+	std::array<uint8_t, 5> test_serial_buffer {5, 4, 3, 2, 1};
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter =
+			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+					test_serial_buffer.size(), false);
+	uint16_t testUint16 = 16;
+
+	SerializeAdapter::serialize(&tv::tv_bool, &p_array,&serialized_size,
+			test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv_serial_buffer_adapter, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&testUint16, &p_array, &serialized_size,
+			test_array.size(), SerializeIF::Endianness::MACHINE);
+
+	if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
+			or test_array[5] != 1)
+	{
+		return unitt::put_error(id);
+	}
+	memcpy(&testUint16, test_array.data() + 6, sizeof(testUint16));
+	if(testUint16 != 16) {
+		return unitt::put_error(id);
+	}
+
+	// Serialize with size field
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter2 =
+			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+					test_serial_buffer.size(), true);
+	serialized_size = 0;
+	p_array = test_array.data();
+	SerializeAdapter::serialize(&tv::tv_bool, &p_array,&serialized_size,
+			test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv_serial_buffer_adapter2, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&testUint16, &p_array, &serialized_size,
+			test_array.size(), SerializeIF::Endianness::MACHINE);
+
+	if(serialized_size != 9 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 5 or test_array[3] != 4 or test_array[4] != 3
+			or test_array[5] != 2 or test_array[6] != 1)
+	{
+		return unitt::put_error(id);
+	}
+	memcpy(&testUint16, test_array.data() + 7, sizeof(testUint16));
+	if(testUint16 != 16) {
+		return unitt::put_error(id);
+	}
+	return retval::RETURN_OK;
+}
diff --git a/unittest/internal/serialize/IntTestSerialization.h b/unittest/internal/serialize/IntTestSerialization.h
new file mode 100644
index 000000000..f8841b820
--- /dev/null
+++ b/unittest/internal/serialize/IntTestSerialization.h
@@ -0,0 +1,15 @@
+#ifndef UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
+#define UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <array>
+
+namespace testserialize {
+ReturnValue_t test_serialization();
+ReturnValue_t test_endianness_tools();
+ReturnValue_t test_autoserialization();
+ReturnValue_t test_serial_buffer_adapter();
+
+extern std::array<uint8_t, 512> test_array;
+}
+
+#endif /* UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_ */
diff --git a/unittest/lcov.sh b/unittest/lcov.sh
new file mode 100644
index 000000000..4db16e5fb
--- /dev/null
+++ b/unittest/lcov.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+lcov --capture --directory . --output-file coverage.info
+genhtml coverage.info --output-directory _coverage
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
new file mode 100644
index 000000000..33c6b4251
--- /dev/null
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -0,0 +1,105 @@
+#include <fsfw/action/ActionHelper.h>
+#include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <fsfw/unittest/tests/action/TestActionHelper.h>
+
+TEST_CASE( "Action Helper" , "[ActionHelper]") {
+	ActionHelperOwnerMockBase testDhMock;
+	MessageQueueMockBase testMqMock;
+	ActionHelper actionHelper = ActionHelper(
+			&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
+	CommandMessage actionMessage;
+	ActionId_t testActionId = 777;
+	std::array <uint8_t, 3> testParams {1, 2, 3};
+	store_address_t paramAddress;
+	StorageManagerIF *ipcStore = tglob::getIpcStoreHandle();
+	ipcStore->addData(&paramAddress, testParams.data(), 3);
+	REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
+
+	SECTION ("Simple tests") {
+		 ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
+		 CHECK(not testDhMock.executeActionCalled);
+		 REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		 CHECK(testDhMock.executeActionCalled);
+		 // No message is sent if everything is alright.
+		 CHECK(not testMqMock.wasMessageSent());
+		 store_address_t invalidAddress;
+		 ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
+		 actionHelper.handleActionMessage(&actionMessage);
+		 CHECK(testMqMock.wasMessageSent());
+		 const uint8_t* ptr = nullptr;
+		 size_t size = 0;
+		 REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+		 REQUIRE(ptr == nullptr);
+		 REQUIRE(size == 0);
+		 testDhMock.getBuffer(&ptr, &size);
+		 REQUIRE(size == 3);
+		 for(uint8_t i = 0; i<3;i++){
+			 REQUIRE(ptr[i] == (i+1));
+		 }
+		 testDhMock.clearBuffer();
+	}
+
+	SECTION("Handle failures"){
+		actionMessage.setCommand(1234);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
+		CHECK(not testMqMock.wasMessageSent());
+		uint16_t step = 5;
+		ReturnValue_t status = 0x1234;
+		actionHelper.step(step, testMqMock.getId(), testActionId, status);
+		step += 1;
+		CHECK(testMqMock.wasMessageSent());
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
+		uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
+		REQUIRE(testMessage.getParameter2() == parameter2);
+		REQUIRE(ActionMessage::getStep(&testMessage) == step);
+	}
+
+	SECTION("Handle finish"){
+		CHECK(not testMqMock.wasMessageSent());
+		ReturnValue_t status = 0x9876;
+		actionHelper.finish(testMqMock.getId(), testActionId, status);
+		CHECK(testMqMock.wasMessageSent());
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
+		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
+	}
+
+	SECTION("Handle failed"){
+		store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
+		std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
+		REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
+		ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
+		CHECK(not testDhMock.executeActionCalled);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		REQUIRE(ipcStore->getData(toLongParamAddress).first == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
+		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+	}
+
+	SECTION("Missing IPC Data"){
+		ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
+		CHECK(not testDhMock.executeActionCalled);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
+		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+	}
+
+
+	SECTION("Data Reply"){
+
+	}
+}
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
new file mode 100644
index 000000000..fcc20f90b
--- /dev/null
+++ b/unittest/tests/action/TestActionHelper.h
@@ -0,0 +1,131 @@
+#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
+#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
+
+#include <fsfw/action/HasActionsIF.h>
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <cstring>
+
+
+class ActionHelperOwnerMockBase: public HasActionsIF {
+public:
+	bool getCommandQueueCalled = false;
+	bool executeActionCalled = false;
+	static const size_t MAX_SIZE = 3;
+	uint8_t buffer[MAX_SIZE] = {0, 0, 0};
+	size_t size = 0;
+
+	MessageQueueId_t getCommandQueue() const override {
+		return tconst::testQueueId;
+	}
+
+	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+			const uint8_t* data, size_t size) override {
+		executeActionCalled = true;
+		if(size > MAX_SIZE){
+			return 0xAFFE;
+		}
+		this->size = size;
+		memcpy(buffer, data, size);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	void clearBuffer(){
+		this->size = 0;
+		for(size_t i = 0; i<MAX_SIZE; i++){
+			buffer[i] = 0;
+		}
+	}
+
+	void getBuffer(const uint8_t** ptr, size_t* size){
+		if(size != nullptr){
+			*size = this->size;
+		}
+		if(ptr != nullptr){
+			*ptr = buffer;
+		}
+	}
+};
+
+
+class MessageQueueMockBase: public MessageQueueIF {
+public:
+	MessageQueueId_t myQueueId = 0;
+	bool defaultDestSet = false;
+	bool messageSent = false;
+
+
+
+	bool wasMessageSent() {
+		bool tempMessageSent = messageSent;
+		messageSent = false;
+		return tempMessageSent;
+	}
+
+	virtual ReturnValue_t reply( MessageQueueMessage* message ) {
+		messageSent = true;
+		lastMessage = (*message);
+		return HasReturnvaluesIF::RETURN_OK;
+	};
+	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message,
+			MessageQueueId_t *receivedFrom) {
+		(*message) = lastMessage;
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) {
+		(*message) = lastMessage;
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t flush(uint32_t* count) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual MessageQueueId_t getLastPartner() const {
+		return tconst::testQueueId;
+	}
+	virtual MessageQueueId_t getId() const {
+		return tconst::testQueueId;
+	}
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = (*message);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessage* message, bool ignoreFault = false ) override {
+		messageSent = true;
+		lastMessage = (*message);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = (*message);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message ) {
+		messageSent = true;
+		lastMessage = (*message);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+		myQueueId = defaultDestination;
+		defaultDestSet = true;
+	}
+
+	virtual MessageQueueId_t getDefaultDestination() const {
+		return myQueueId;
+	}
+	virtual bool isDefaultDestinationSet() const {
+		return defaultDestSet;
+	}
+private:
+	MessageQueueMessage lastMessage;
+
+};
+
+
+#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
diff --git a/unittest/tests/container/RingBufferTest.cpp b/unittest/tests/container/RingBufferTest.cpp
new file mode 100644
index 000000000..07d6bc1f1
--- /dev/null
+++ b/unittest/tests/container/RingBufferTest.cpp
@@ -0,0 +1,327 @@
+#include <fsfw/container/SimpleRingBuffer.h>
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+#include <cstring>
+
+TEST_CASE("Ring Buffer Test" , "[RingBufferTest]") {
+	uint8_t testData[13]= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+	uint8_t readBuffer[10] = {13, 13, 13, 13, 13, 13, 13, 13, 13, 13};
+	SimpleRingBuffer ringBuffer(10, false, 5);
+
+	SECTION("Simple Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_FAILED);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.availableWriteSpace() == 5);
+		ringBuffer.clear();
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 4) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 4, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 4; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 9, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 9; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+
+	}
+
+	SECTION("Get Free Element Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 8) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 1);
+		REQUIRE(ringBuffer.readData(readBuffer, 8, true) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		uint8_t *testPtr = nullptr;
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) ==  retval::CATCH_FAILED);
+
+
+		REQUIRE(ringBuffer.writeTillWrap() == 2);
+		// too many excess bytes.
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) ==  retval::CATCH_FAILED);
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) ==  retval::CATCH_OK);
+		REQUIRE(ringBuffer.getExcessBytes() == 3);
+		std::memcpy(testPtr, testData, 5);
+		ringBuffer.confirmBytesWritten(5);
+		REQUIRE(ringBuffer.getAvailableReadData() == 5);
+		ringBuffer.readData(readBuffer, 5, true);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+	}
+
+	SECTION("Read Remaining Test") {
+		REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.getAvailableReadData() == 3);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) ==  retval::CATCH_FAILED);
+		size_t trueSize = 0;
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) ==  retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+		for(uint8_t i = 0; i< 3; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		trueSize = 0;
+		REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == retval::CATCH_FAILED);
+		REQUIRE(trueSize == 0);
+		REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+	}
+}
+
+TEST_CASE("Ring Buffer Test2" , "[RingBufferTest2]") {
+	uint8_t testData[13]= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+	uint8_t readBuffer[10] = {13, 13, 13, 13, 13, 13, 13, 13, 13, 13};
+	uint8_t* newBuffer = new uint8_t[10];
+	SimpleRingBuffer ringBuffer(newBuffer, 10, true, 5);
+
+	SECTION("Simple Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.availableWriteSpace() == 5);
+		ringBuffer.clear();
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 4) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 4, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 4; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 9, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 9; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+
+	}
+
+	SECTION("Get Free Element Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 8) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 1);
+		REQUIRE(ringBuffer.readData(readBuffer, 8, true) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		uint8_t *testPtr = nullptr;
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) ==  retval::CATCH_FAILED);
+
+
+		REQUIRE(ringBuffer.writeTillWrap() == 2);
+		// too many excess bytes.
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) ==  retval::CATCH_FAILED);
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) ==  retval::CATCH_OK);
+		REQUIRE(ringBuffer.getExcessBytes() == 3);
+		std::memcpy(testPtr, testData, 5);
+		ringBuffer.confirmBytesWritten(5);
+		REQUIRE(ringBuffer.getAvailableReadData() == 5);
+		ringBuffer.readData(readBuffer, 5, true);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+	}
+
+	SECTION("Read Remaining Test") {
+		REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.getAvailableReadData() == 3);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) ==  retval::CATCH_FAILED);
+		size_t trueSize = 0;
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) ==  retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+		for(uint8_t i = 0; i< 3; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		trueSize = 0;
+		REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == retval::CATCH_FAILED);
+		REQUIRE(trueSize == 0);
+		REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+	}
+
+	SECTION("Overflow"){
+		REQUIRE(ringBuffer.availableWriteSpace()==9);
+		//Writing more than the buffer is large, technically thats allowed
+		//But it is senseless and has undesired impact on read call
+		REQUIRE(ringBuffer.writeData(testData, 13) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.getAvailableReadData()==3);
+		ringBuffer.clear();
+		uint8_t * ptr = nullptr;
+		REQUIRE(ringBuffer.getFreeElement(&ptr, 13) == retval::CATCH_OK);
+		REQUIRE(ptr != nullptr);
+		memcpy(ptr, testData, 13);
+		ringBuffer.confirmBytesWritten(13);
+		REQUIRE(ringBuffer.getAvailableReadData()==3);
+		REQUIRE(ringBuffer.readData(readBuffer, 3, true)== retval::CATCH_OK);
+		for(auto i =0;i<3;i++){
+			REQUIRE(readBuffer[i] == testData[i+10]);
+		}
+	}
+}
+
+TEST_CASE("Ring Buffer Test3" , "[RingBufferTest3]") {
+	uint8_t testData[13]= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+	uint8_t readBuffer[10] = {13, 13, 13, 13, 13, 13, 13, 13, 13, 13};
+	uint8_t* newBuffer = new uint8_t[10];
+	SimpleRingBuffer ringBuffer(newBuffer, 10, true, 15);
+
+	SECTION("Simple Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.availableWriteSpace() == 5);
+		ringBuffer.clear();
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 4) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 4, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 4; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 9, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 9; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+
+	}
+
+	SECTION("Get Free Element Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 8) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 1);
+		REQUIRE(ringBuffer.readData(readBuffer, 8, true) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		uint8_t *testPtr = nullptr;
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) ==  retval::CATCH_OK);
+		REQUIRE(ringBuffer.getExcessBytes() == 8);
+
+		REQUIRE(ringBuffer.writeTillWrap() == 2);
+		// too many excess bytes.
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) ==  retval::CATCH_FAILED);
+		// Less Execss bytes overwrites before
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 3) ==  retval::CATCH_OK);
+		REQUIRE(ringBuffer.getExcessBytes() == 1);
+		std::memcpy(testPtr, testData, 3);
+		ringBuffer.confirmBytesWritten(3);
+		REQUIRE(ringBuffer.getAvailableReadData() == 3);
+		ringBuffer.readData(readBuffer, 3, true);
+		for(uint8_t i = 0; i< 3; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+	}
+
+	SECTION("Read Remaining Test") {
+		REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.getAvailableReadData() == 3);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) ==  retval::CATCH_FAILED);
+		size_t trueSize = 0;
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) ==  retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+		for(uint8_t i = 0; i< 3; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		trueSize = 0;
+		REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == retval::CATCH_FAILED);
+		REQUIRE(trueSize == 0);
+		REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+	}
+
+	SECTION("Overflow"){
+		REQUIRE(ringBuffer.availableWriteSpace()==9);
+		//Writing more than the buffer is large, technically thats allowed
+		//But it is senseless and has undesired impact on read call
+		REQUIRE(ringBuffer.writeData(testData, 13) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.getAvailableReadData()==3);
+		ringBuffer.clear();
+		uint8_t * ptr = nullptr;
+		REQUIRE(ringBuffer.getFreeElement(&ptr, 13) == retval::CATCH_OK);
+		REQUIRE(ptr != nullptr);
+		memcpy(ptr, testData, 13);
+		ringBuffer.confirmBytesWritten(13);
+		REQUIRE(ringBuffer.getAvailableReadData()==3);
+		REQUIRE(ringBuffer.readData(readBuffer, 3, true)== retval::CATCH_OK);
+		for(auto i =0;i<3;i++){
+			REQUIRE(readBuffer[i] == testData[i+10]);
+		}
+	}
+}
+
+TEST_CASE("Ring Buffer Test4" , "[RingBufferTest4]") {
+	uint8_t testData[13]= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+	uint8_t readBuffer[10] = {13, 13, 13, 13, 13, 13, 13, 13, 13, 13};
+	SimpleRingBuffer ringBuffer(10, false, 15);
+
+	SECTION("Simple Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_FAILED);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.availableWriteSpace() == 5);
+		ringBuffer.clear();
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 4) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 4, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 4; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 9, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 9; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+
+	}
+
+	SECTION("Get Free Element Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 8) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 1);
+		REQUIRE(ringBuffer.readData(readBuffer, 8, true) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		uint8_t *testPtr = nullptr;
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) ==  retval::CATCH_FAILED);
+
+
+		REQUIRE(ringBuffer.writeTillWrap() == 2);
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) ==  retval::CATCH_OK);
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) ==  retval::CATCH_OK);
+		REQUIRE(ringBuffer.getExcessBytes() == 3);
+		std::memcpy(testPtr, testData, 5);
+		ringBuffer.confirmBytesWritten(5);
+		REQUIRE(ringBuffer.getAvailableReadData() == 5);
+		ringBuffer.readData(readBuffer, 5, true);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+	}
+
+	SECTION("Read Remaining Test") {
+		REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.getAvailableReadData() == 3);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) ==  retval::CATCH_FAILED);
+		size_t trueSize = 0;
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) ==  retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+		for(uint8_t i = 0; i< 3; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		trueSize = 0;
+		REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == retval::CATCH_FAILED);
+		REQUIRE(trueSize == 0);
+		REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+	}
+}
diff --git a/unittest/tests/container/TestArrayList.cpp b/unittest/tests/container/TestArrayList.cpp
new file mode 100644
index 000000000..b0ec0abbd
--- /dev/null
+++ b/unittest/tests/container/TestArrayList.cpp
@@ -0,0 +1,90 @@
+#include <fsfw/container/ArrayList.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+/**
+ * @brief 	Array List test
+ */
+TEST_CASE("Array List" , "[ArrayListTest]") {
+	//perform set-up here
+	ArrayList<uint16_t> list(20);
+	struct TestClass{
+	public:
+		TestClass(){};
+		TestClass(uint32_t number1,	uint64_t number2):
+			number1(number1), number2(number2){};
+		uint32_t number1 = -1;
+		uint64_t number2 = -1;
+		bool operator==(const TestClass& other){
+			return ((this->number1 == other.number1) and (this->number2 == other.number2));
+		};
+	};
+	ArrayList<TestClass> complexList(20);
+	SECTION("SimpleTest") {
+		REQUIRE(list.maxSize()==20);
+		REQUIRE(list.size == 0);
+		REQUIRE(list.insert(10) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(list[0] == 10);
+		REQUIRE(list.front() != nullptr);
+		REQUIRE((*list.front()) == 10);
+		REQUIRE(list.back() != nullptr);
+		REQUIRE((*list.back()) == 10);
+		// Need to test the const version of back as well
+		const uint16_t* number = const_cast<const ArrayList<uint16_t>*>(&list)->back();
+		REQUIRE(*number == 10);
+		list.clear();
+		REQUIRE(list.size == 0);
+	}
+	SECTION("Fill and check"){
+		//This is an invalid element but its not a nullptr
+		REQUIRE(list.back() != nullptr);
+		for (auto i =0; i < 20; i++){
+			REQUIRE(list.insert(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		}
+		REQUIRE(list.insert(20) == static_cast<int>(ArrayList<uint16_t>::FULL));
+		ArrayList<uint16_t>::Iterator it = list.begin();
+		REQUIRE((*it) == 0);
+		it++;
+		REQUIRE((*it) == 1);
+		it--;
+		REQUIRE((*it) == 0);
+		it++;
+		for(auto it2 = list.begin(); it2!=list.end(); it2++){
+			if (it == it2){
+				REQUIRE((*it) == (*it2));
+				break;
+			}else{
+				REQUIRE((*it2) == 0);
+				REQUIRE(it2 != it);
+			}
+		}
+	}
+	SECTION("Const Iterator"){
+		ArrayList<uint16_t>::Iterator it = list.begin();
+		for (auto i =0; i < 10; i++){
+			REQUIRE(list.insert(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		}
+		it++;
+		const uint16_t* number = it.value;
+		REQUIRE(*number == 1);
+	}
+
+	SECTION("Const Iterator"){
+		ArrayList<TestClass>::Iterator it = complexList.begin();
+		for (auto i =0; i < 10; i++){
+			REQUIRE(complexList.insert(TestClass(i, i+1)) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		}
+		it++;
+		const TestClass* secondTest = it.value;
+		bool compare = TestClass(1, 2) == *secondTest;
+		REQUIRE(compare);
+		it++;
+		REQUIRE(it->number1 == 2);
+		REQUIRE(it->number2 == 3);
+		const ArrayList<TestClass>::Iterator it4(&(complexList[2]));
+		REQUIRE(it4->number1 == 2);
+		REQUIRE((*it4).number2 == 3);
+		REQUIRE(complexList.remaining()==10);
+	}
+}
diff --git a/unittest/tests/container/TestDynamicFifo.cpp b/unittest/tests/container/TestDynamicFifo.cpp
new file mode 100644
index 000000000..6c9b7415d
--- /dev/null
+++ b/unittest/tests/container/TestDynamicFifo.cpp
@@ -0,0 +1,149 @@
+
+#include <fsfw/container/DynamicFIFO.h>
+#include <fsfw/container/FIFO.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <catch.hpp>
+#include <CatchDefinitions.h>
+
+TEST_CASE( "Dynamic Fifo Tests", "[TestDynamicFifo]") {
+	INFO("Dynamic Fifo Tests");
+	struct Test{
+		uint64_t number1;
+		uint32_t number2;
+		uint8_t number3;
+		bool operator==(struct Test& other){
+			if ((other.number1 == this->number1) and
+					(other.number1 == this->number1) and
+					(other.number1 == this->number1)){
+				return true;
+			}
+			return false;
+		}
+	};
+	DynamicFIFO<Test> fifo(3);
+	std::vector<Test> list;
+
+	struct Test structOne({UINT64_MAX, UINT32_MAX, UINT8_MAX});
+	struct Test structTwo({0, 1, 2});
+	struct Test structThree({42, 43, 44});
+	list.push_back(structThree);
+	list.push_back(structTwo);
+	list.push_back(structOne);
+	SECTION("Insert, retrieval test"){
+		REQUIRE(fifo.getMaxCapacity()==3);
+		REQUIRE(fifo.size()==0);
+		REQUIRE(fifo.empty());
+		REQUIRE(not fifo.full());
+
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(FIFOBase<Test>::FULL));
+
+		struct Test testptr;
+		REQUIRE(fifo.peek(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		bool equal = testptr == structOne;
+		REQUIRE(equal);
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		for(size_t i=2;i<3;i--){
+			testptr.number1 = 0;
+			testptr.number2 = 0;
+			testptr.number3 = 0;
+			REQUIRE(fifo.retrieve(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			equal = testptr == list[i];
+			REQUIRE(equal);
+			REQUIRE(fifo.size()==i);
+		}
+		testptr.number1 = 0;
+		testptr.number2 = 0;
+		testptr.number3 = 0;
+		REQUIRE(fifo.retrieve(&testptr)==static_cast<int>(FIFOBase<Test>::EMPTY));
+		REQUIRE(fifo.peek(&testptr)==static_cast<int>(FIFOBase<Test>::EMPTY));
+		REQUIRE(not fifo.full());
+		REQUIRE(fifo.empty());
+		REQUIRE(fifo.pop()==static_cast<int>(FIFOBase<Test>::EMPTY));
+
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==1);
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==2);
+		REQUIRE(fifo.pop()==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==1);
+		testptr.number1 = 0;
+		testptr.number2 = 0;
+		testptr.number3 = 0;
+		REQUIRE(fifo.peek(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		equal = testptr == structTwo;
+		REQUIRE(equal);
+		REQUIRE(fifo.pop()==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==0);
+		REQUIRE(fifo.empty());
+		//struct Test* ptr = nullptr;
+		//REQUIRE(fifo.retrieve(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+		//REQUIRE(fifo.peek(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+	};
+	SECTION("Copy Test"){
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		DynamicFIFO<Test> fifo2(fifo);
+		REQUIRE(fifo2.size()==3);
+		REQUIRE(fifo2.full());
+		REQUIRE(not fifo2.empty());
+
+	};
+
+	SECTION("Assignment Test"){
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		DynamicFIFO<Test> fifo2(6);
+		fifo2 = fifo;
+		REQUIRE(fifo2.size()==3);
+		REQUIRE(fifo2.full());
+		REQUIRE(not fifo2.empty());
+		for(size_t i=2;i<3;i--){
+			struct Test testptr = {0, 0, 0};
+			REQUIRE(fifo2.retrieve(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			bool equal = testptr == list[i];
+			REQUIRE(equal);
+			REQUIRE(fifo2.size()==i);
+		}
+
+	};
+
+	SECTION("Assignment Test Smaller"){
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		DynamicFIFO<Test> fifo2(2);
+		fifo2 = fifo;
+		REQUIRE(fifo2.size()==3);
+		REQUIRE(fifo2.full());
+		REQUIRE(not fifo2.empty());
+		for(size_t i=2;i<3;i--){
+			struct Test testptr = {0, 0, 0};
+			REQUIRE(fifo2.retrieve(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			bool equal = testptr == list[i];
+			REQUIRE(equal);
+			REQUIRE(fifo2.size()==i);
+		}
+	};
+
+};
diff --git a/unittest/tests/container/TestFifo.cpp b/unittest/tests/container/TestFifo.cpp
new file mode 100644
index 000000000..ac0900c87
--- /dev/null
+++ b/unittest/tests/container/TestFifo.cpp
@@ -0,0 +1,138 @@
+
+#include <fsfw/container/DynamicFIFO.h>
+#include <fsfw/container/FIFO.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+TEST_CASE( "Static Fifo Tests", "[TestFifo]") {
+	INFO("Fifo Tests");
+	struct Test{
+		uint64_t number1;
+		uint32_t number2;
+		uint8_t number3;
+		bool operator==(struct Test& other){
+			if ((other.number1 == this->number1) and
+					(other.number1 == this->number1) and
+					(other.number1 == this->number1)){
+				return true;
+			}
+			return false;
+		}
+	};
+	FIFO<Test, 3> fifo;
+	std::vector<Test> list;
+
+	struct Test structOne({UINT64_MAX, UINT32_MAX, UINT8_MAX});
+	struct Test structTwo({0, 1, 2});
+	struct Test structThree({42, 43, 44});
+	list.push_back(structThree);
+	list.push_back(structTwo);
+	list.push_back(structOne);
+	SECTION("Insert, retrieval test"){
+		REQUIRE(fifo.getMaxCapacity()==3);
+		REQUIRE(fifo.size()==0);
+		REQUIRE(fifo.empty());
+		REQUIRE(not fifo.full());
+
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(FIFOBase<Test>::FULL));
+
+		struct Test testptr;
+		REQUIRE(fifo.peek(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		bool equal = testptr == structOne;
+		REQUIRE(equal);
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		for(size_t i=2;i<3;i--){
+			testptr.number1 = 0;
+			testptr.number2 = 0;
+			testptr.number3 = 0;
+			REQUIRE(fifo.retrieve(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			equal = testptr == list[i];
+			REQUIRE(equal);
+			REQUIRE(fifo.size()==i);
+		}
+		testptr.number1 = 0;
+		testptr.number2 = 0;
+		testptr.number3 = 0;
+		REQUIRE(fifo.retrieve(&testptr)==static_cast<int>(FIFOBase<Test>::EMPTY));
+		REQUIRE(fifo.peek(&testptr)==static_cast<int>(FIFOBase<Test>::EMPTY));
+		REQUIRE(not fifo.full());
+		REQUIRE(fifo.empty());
+		REQUIRE(fifo.pop()==static_cast<int>(FIFOBase<Test>::EMPTY));
+
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==1);
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==2);
+		REQUIRE(fifo.pop()==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==1);
+		testptr.number1 = 0;
+		testptr.number2 = 0;
+		testptr.number3 = 0;
+
+		// Test that retrieve and peek will not cause a nullptr dereference
+		struct Test* ptr = nullptr;
+		REQUIRE(fifo.retrieve(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+		REQUIRE(fifo.peek(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+
+
+		REQUIRE(fifo.peek(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		equal = testptr == structTwo;
+		REQUIRE(equal);
+		REQUIRE(fifo.pop()==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==0);
+		REQUIRE(fifo.empty());
+
+
+	};
+	SECTION("Copy Test"){
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		FIFO<Test, 3> fifo2(fifo);
+		REQUIRE(fifo2.size()==3);
+		REQUIRE(fifo2.full());
+		REQUIRE(not fifo2.empty());
+		for(size_t i=2;i<3;i--){
+			struct Test testptr = {0, 0, 0};
+			REQUIRE(fifo2.retrieve(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			bool equal = testptr == list[i];
+			REQUIRE(equal);
+			REQUIRE(fifo2.size()==i);
+		}
+
+	};
+
+	SECTION("Assignment Test"){
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		FIFO<Test, 3> fifo2;
+		fifo2 = fifo;
+		REQUIRE(fifo2.size()==3);
+		REQUIRE(fifo2.full());
+		REQUIRE(not fifo2.empty());
+		for(size_t i=2;i<3;i--){
+			struct Test testptr = {0, 0, 0};
+			REQUIRE(fifo2.retrieve(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			bool equal = testptr == list[i];
+			REQUIRE(equal);
+			REQUIRE(fifo2.size()==i);
+		}
+	};
+};
diff --git a/unittest/tests/container/TestFixedArrayList.cpp b/unittest/tests/container/TestFixedArrayList.cpp
new file mode 100644
index 000000000..5d1d5817b
--- /dev/null
+++ b/unittest/tests/container/TestFixedArrayList.cpp
@@ -0,0 +1,41 @@
+#include <fsfw/container/FixedArrayList.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+
+TEST_CASE( "FixedArrayList Tests", "[TestFixedArrayList]") {
+	INFO("FixedArrayList Tests");
+	using testList = FixedArrayList<uint32_t, 260, uint16_t>;
+	testList list;
+	REQUIRE(list.size==0);
+	REQUIRE(list.insert(10) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+	REQUIRE(list.size==1);
+	REQUIRE(list.maxSize()==260);
+	SECTION("Copy Constructor"){
+		testList list2(list);
+		REQUIRE(list2.size==1);
+		REQUIRE(list2[0] == 10);
+		REQUIRE(list.maxSize()==260);
+	};
+	SECTION("Assignment copy"){
+		testList list2;
+		REQUIRE(list2.size==0);
+		list2 = list;
+		REQUIRE(list2.size==1);
+		REQUIRE(list2[0] == 10);
+		REQUIRE(list.maxSize()==260);
+	};
+	SECTION("Fill"){
+		for(auto i=1;i<260;i++){
+			REQUIRE(list.insert(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		}
+		REQUIRE(list.insert(260) == static_cast<int>(ArrayList<uint32_t, uint16_t>::FULL));
+		list.clear();
+		REQUIRE(list.size == 0);
+	}
+}
+
+
+
diff --git a/unittest/tests/container/TestFixedMap.cpp b/unittest/tests/container/TestFixedMap.cpp
new file mode 100644
index 000000000..04656525b
--- /dev/null
+++ b/unittest/tests/container/TestFixedMap.cpp
@@ -0,0 +1,172 @@
+#include <fsfw/container/FixedMap.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+template class FixedMap<unsigned int, unsigned short>;
+
+TEST_CASE( "FixedMap Tests", "[TestFixedMap]") {
+	INFO("FixedMap Tests");
+
+	FixedMap<unsigned int, unsigned short> map(30);
+	REQUIRE(map.size() == 0);
+	REQUIRE(map.maxSize() == 30);
+	REQUIRE(map.getSerializedSize() == sizeof(uint32_t));
+	REQUIRE(map.empty());
+	REQUIRE(not map.full());
+
+	SECTION("Fill and erase"){
+		for (uint16_t i=0;i<30;i++){
+			REQUIRE(map.insert(std::make_pair(i, i+1))== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(map.exists(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(map.find(i)->second==i+1);
+			REQUIRE(not map.empty());
+		}
+		REQUIRE(map.insert(0, 0) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_ALREADY_EXISTS));
+		REQUIRE(map.insert(31, 0) == static_cast<int>(FixedMap<uint32_t, uint16_t>::MAP_FULL));
+		REQUIRE(map.exists(31) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.size() == 30);
+		REQUIRE(map.full());
+		{
+			uint16_t* ptr;
+			REQUIRE(map.find(5,&ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(*ptr == 6);
+			REQUIRE(*(map.findValue(6)) == 7);
+			REQUIRE(map.find(31,&ptr) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		}
+
+		REQUIRE(map.getSerializedSize() == (sizeof(uint32_t)+ 30*(sizeof(uint32_t) + sizeof(uint16_t))));
+		REQUIRE(map.erase(2) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.erase(31) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.exists(2) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.size() == 29);
+
+		for (auto element: map){
+			if (element.first == 5){
+				REQUIRE(element.second == 6);
+			}
+		}
+
+		for (FixedMap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++){
+			REQUIRE(it->second == it->first + 1);
+			REQUIRE((*it).second == (*it).first + 1);
+			it->second = it->second + 1;
+			REQUIRE(it->second == it->first + 2);
+		}
+
+		for (FixedMap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++){
+			REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		}
+
+		REQUIRE(map.size() == 0);
+
+		for (FixedMap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++){
+			// This line should never executed if begin and end is correct
+			FAIL("Should never be reached, Iterators invalid");
+		}
+	};
+
+	SECTION("Insert variants"){
+		FixedMap<uint32_t, uint16_t>::Iterator it = map.end();
+		REQUIRE(map.insert(36, 37, &it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(it->first == 36);
+		REQUIRE(it->second == 37);
+		REQUIRE(map.size() == 1);
+		REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.find(37)->second == 38);
+		REQUIRE(map.size() == 2);
+		REQUIRE(map.insert(37, 24, nullptr) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_ALREADY_EXISTS));
+		REQUIRE(map.find(37)->second != 24);
+		REQUIRE(map.size() == 2);
+	};
+	SECTION("Serialize and DeSerialize") {
+		REQUIRE(map.insert(36, 37, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		uint8_t buffer[sizeof(uint32_t)
+				+ 2 * (sizeof(uint32_t) + sizeof(uint16_t))];
+		REQUIRE(
+				map.getSerializedSize()
+						== (sizeof(uint32_t)
+								+ 2 * (sizeof(uint32_t) + sizeof(uint16_t))));
+		uint8_t *loc_ptr = buffer;
+		size_t size = 0;
+		REQUIRE(
+				map.serialize(&loc_ptr, &size, 10, SerializeIF::Endianness::BIG)
+						== static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+		loc_ptr = buffer;
+		size = 0;
+		REQUIRE(
+				map.serialize(&loc_ptr, &size,
+						sizeof(uint32_t)
+								+ 2 * (sizeof(uint32_t) + sizeof(uint16_t)),
+						SerializeIF::Endianness::BIG)
+						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(size == 16);
+
+		uint32_t internal_size = 0;
+		const uint8_t *ptr2 = buffer;
+		REQUIRE(
+				SerializeAdapter::deSerialize(&internal_size, &ptr2, &size,
+						SerializeIF::Endianness::BIG)
+						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(internal_size == 2);
+		for (uint8_t i = 36; i < 38; i++) {
+			uint32_t first_element = 0;
+			REQUIRE(
+					SerializeAdapter::deSerialize(&first_element, &ptr2, &size,
+							SerializeIF::Endianness::BIG)
+							== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(first_element == i);
+			uint16_t second_element = 0;
+			REQUIRE(
+					SerializeAdapter::deSerialize(&second_element, &ptr2, &size,
+							SerializeIF::Endianness::BIG)
+							== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(second_element == i + 1);
+		}
+		REQUIRE(size == 0);
+		map.clear();
+		const uint8_t* constPtr = buffer;
+		size = 16;
+		REQUIRE(map.size() == 0);
+		REQUIRE(map.deSerialize(&constPtr, &size,
+				SerializeIF::Endianness::BIG) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.size() == 2);
+		REQUIRE(map.find(36)->second == 37);
+		for(auto& element: map){
+			REQUIRE((element.first+1) == element.second);
+		}
+	};
+
+
+	SECTION("Failed erase and deSerialize"){
+		FixedMap<uint32_t, uint16_t>::Iterator it;
+		std::pair<uint32_t, uint16_t> pair = std::make_pair(44, 43);
+		it = FixedMap<uint32_t, uint16_t>::Iterator(&pair);
+		REQUIRE(map.erase(&it) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.find(45) == map.end());
+		size_t toLargeMap = 100;
+		const uint8_t* ptr = reinterpret_cast<uint8_t*>(&toLargeMap);
+		size_t size = sizeof(size_t);
+		REQUIRE(map.deSerialize(&ptr, &size, SerializeIF::Endianness::BIG) ==
+				static_cast<int>(SerializeIF::TOO_MANY_ELEMENTS));
+	};
+	SECTION("Little Endianess"){
+		map.clear();
+		map.insert(10,20, nullptr);
+		uint8_t newBuffer[sizeof(uint32_t)+ 1*(sizeof(uint32_t) + sizeof(uint16_t))];
+		uint8_t* ptr = newBuffer;
+		size_t size =  0;
+		size_t max_size = sizeof(uint32_t)+ 1*(sizeof(uint32_t) + sizeof(uint16_t));
+		REQUIRE(map.serialize(&ptr, &size, max_size,
+				SerializeIF::Endianness::LITTLE) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		map.clear();
+		REQUIRE(map.size()==0);
+		const uint8_t* ptr2 = newBuffer;
+		REQUIRE(map.deSerialize(&ptr2, &size,
+				SerializeIF::Endianness::LITTLE) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.size()==1);
+		REQUIRE(map.find(10)->second == 20);
+	};
+}
diff --git a/unittest/tests/container/TestFixedOrderedMultimap.cpp b/unittest/tests/container/TestFixedOrderedMultimap.cpp
new file mode 100644
index 000000000..953cb5a89
--- /dev/null
+++ b/unittest/tests/container/TestFixedOrderedMultimap.cpp
@@ -0,0 +1,203 @@
+#include <fsfw/container/FixedOrderedMultimap.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+TEST_CASE( "FixedOrderedMultimap Tests", "[TestFixedOrderedMultimap]") {
+	INFO("FixedOrderedMultimap Tests");
+
+	FixedOrderedMultimap<unsigned int, unsigned short> map(30);
+	REQUIRE(map.size() == 0);
+	REQUIRE(map.maxSize() == 30);
+
+	SECTION("Test insert, find, exists"){
+		for (uint16_t i=0;i<30;i++){
+			REQUIRE(map.insert(std::make_pair(i, i+1))== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(map.exists(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(map.find(i)->second==i+1);
+		}
+		REQUIRE(map.insert(0, 0) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::MAP_FULL));
+		REQUIRE(map.exists(31) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.size() == 30);
+		{
+			uint16_t* ptr;
+			REQUIRE(map.find(5,&ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(*ptr == 6);
+			REQUIRE(map.find(31,&ptr) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		}
+		REQUIRE(map.erase(2) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.erase(31) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.exists(2) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.size() == 29);
+
+		for (auto element: map){
+			if (element.first == 5){
+				REQUIRE(element.second == 6);
+			}
+		}
+
+		for (FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++){
+			REQUIRE(it->second == it->first + 1);
+			REQUIRE((*it).second == (*it).first + 1);
+			it->second = it->second + 1;
+			REQUIRE(it->second == it->first + 2);
+		}
+
+		{
+			FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.begin();
+			while(it != map.end()){
+				REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			}
+			REQUIRE(map.size() == 0);
+		}
+
+		for (FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++){
+			// This line should never executed if begin and end is correct
+			FAIL("Should never be reached, Iterators invalid");
+		}
+	};
+
+	SECTION("Test different insert variants")
+	{
+		FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.end();
+		REQUIRE(map.insert(36, 37, &it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(it->first == 36);
+		REQUIRE(it->second == 37);
+		REQUIRE(map.size() == 1);
+		REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.find(37)->second == 38);
+		REQUIRE(map.size() == 2);
+		REQUIRE(map.insert(37, 24, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.find(37)->second == 38);
+		REQUIRE(map.insert(0, 1, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.find(0)->second == 1);
+		REQUIRE(map.size() == 4);
+		map.clear();
+		REQUIRE(map.size() == 0);
+	}
+	SECTION("Test different erase and find with no entries"){
+		FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it;
+		it = map.end();
+		REQUIRE(map.erase(&it) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.find(1)== map.end());
+	}
+}
+
+TEST_CASE( "FixedOrderedMultimap Non Trivial Type", "[TestFixedOrderedMultimapNonTrivial]") {
+	INFO("FixedOrderedMultimap Non Trivial Type");
+
+	class TestClass{
+	public:
+		TestClass(){};
+		TestClass(uint32_t number1,	uint64_t number2):
+		number1(number1),number2(number2){};
+		~TestClass(){};
+
+		bool operator==(const TestClass& lhs){
+			return ((this->number1 == lhs.number1) and (this->number2 == lhs.number2));
+		}
+		bool operator!=(const TestClass& lhs){
+			return not(this->operator ==(lhs));
+		}
+
+		TestClass(const TestClass& other){
+			this->number1 = other.number1;
+			this->number2 = other.number2;
+		};
+		TestClass& operator=(const TestClass& other){
+			this->number1 = other.number1;
+			this->number2 = other.number2;
+			return *this;
+		};
+
+	private:
+		uint32_t number1 = 0;
+		uint64_t number2 = 5;
+	};
+	FixedOrderedMultimap<unsigned int, TestClass> map(30);
+	REQUIRE(map.size() == 0);
+	REQUIRE(map.maxSize() == 30);
+
+	SECTION("Test insert, find, exists"){
+		for (uint16_t i=0;i<30;i++){
+			REQUIRE(map.insert(std::make_pair(i, TestClass(i+1,i)))== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(map.exists(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			bool compare = map.find(i)->second == TestClass(i+1,i);
+			REQUIRE(compare);
+		}
+		REQUIRE(map.insert(0, TestClass()) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::MAP_FULL));
+		REQUIRE(map.exists(31) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.size() == 30);
+		{
+			TestClass* ptr = nullptr;
+			REQUIRE(map.find(5,&ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			bool compare = *ptr == TestClass(6, 5);
+			REQUIRE(compare);
+			REQUIRE(map.find(31,&ptr) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		}
+		REQUIRE(map.erase(2) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.erase(31) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.exists(2) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.size() == 29);
+
+		for (auto element: map){
+			if (element.first == 5){
+				bool compare = element.second == TestClass(6, 5);
+				REQUIRE(compare);
+			}
+		}
+
+		for (FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin(); it != map.end(); it++){
+			bool compare = it->second == TestClass(it->first + 1, it->first);
+			REQUIRE(compare);
+			compare = (*it).second == TestClass((*it).first + 1, (*it).first);
+			REQUIRE(compare);
+			it->second = TestClass(it->first + 2, it->first);
+			compare = it->second == TestClass(it->first + 2, it->first);
+			REQUIRE(compare);
+		}
+
+		{
+			FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin();
+			while(it != map.end()){
+				REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			}
+			REQUIRE(map.size() == 0);
+		}
+
+		for (FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin(); it != map.end(); it++){
+			// This line should never executed if begin and end is correct
+			FAIL("Should never be reached, Iterators invalid");
+		}
+	};
+
+	SECTION("Test different insert variants")
+	{
+		FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.end();
+		REQUIRE(map.insert(36, TestClass(37, 36), &it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(it->first == 36);
+		bool compare = it->second == TestClass(37, 36);
+		REQUIRE(compare);
+		REQUIRE(map.size() == 1);
+		REQUIRE(map.insert(37, TestClass(38, 37), nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		compare = map.find(37)->second == TestClass(38, 37);
+		REQUIRE(compare);
+		REQUIRE(map.size() == 2);
+		REQUIRE(map.insert(37, TestClass(24, 37), nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		compare = map.find(37)->second == TestClass(38, 37);
+		REQUIRE(compare);
+		REQUIRE(map.insert(0, TestClass(1, 0), nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		compare = map.find(0)->second == TestClass(1, 0);
+		REQUIRE(compare);
+		REQUIRE(map.size() == 4);
+		map.clear();
+		REQUIRE(map.size() == 0);
+	}
+	SECTION("Test different erase and find with no entries"){
+		FixedOrderedMultimap<uint32_t, TestClass>::Iterator it;
+		it = map.end();
+		REQUIRE(map.erase(&it) == static_cast<int>(FixedOrderedMultimap<uint32_t, TestClass>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.find(1)== map.end());
+	}
+}
diff --git a/unittest/tests/container/TestPlacementFactory.cpp b/unittest/tests/container/TestPlacementFactory.cpp
new file mode 100644
index 000000000..aa8e7375d
--- /dev/null
+++ b/unittest/tests/container/TestPlacementFactory.cpp
@@ -0,0 +1,45 @@
+#include <fsfw/container/PlacementFactory.h>
+#include <fsfw/storagemanager/LocalPool.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/container/ArrayList.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
+	INFO("PlacementFactory Tests");
+
+	const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
+	const uint16_t n_elements[3] = {1, 1, 1};
+	LocalPool<3> storagePool(0x1, element_sizes, n_elements, false, true);
+	PlacementFactory factory(&storagePool);
+
+	SECTION("Pool overload"){
+		store_address_t address;
+		uint8_t* ptr = nullptr;
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
+				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
+		REQUIRE(list2 == nullptr);
+	}
+
+	SECTION("Test generate and destroy"){
+		uint64_t* number = factory.generate<uint64_t>(32000);
+		REQUIRE(number != nullptr);
+		REQUIRE(*number == 32000);
+		store_address_t address;
+		uint8_t* ptr = nullptr;
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+		uint64_t* number2 = factory.generate<uint64_t>(12345);
+		REQUIRE(number2 == nullptr);
+		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+
+		//Check that PlacementFactory checks for nullptr
+		ptr = nullptr;
+		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+	}
+}
diff --git a/unittest/tests/osal/TestMessageQueue.cpp b/unittest/tests/osal/TestMessageQueue.cpp
new file mode 100644
index 000000000..8e59fa084
--- /dev/null
+++ b/unittest/tests/osal/TestMessageQueue.cpp
@@ -0,0 +1,40 @@
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include "catch.hpp"
+#include <array>
+#include "core/CatchDefinitions.h"
+
+TEST_CASE("MessageQueue Basic Test","[TestMq]") {
+	MessageQueueIF* testSenderMq =
+			QueueFactory::instance()->createMessageQueue(1);
+	MessageQueueId_t testSenderMqId = testSenderMq->getId();
+
+	MessageQueueIF* testReceiverMq =
+				QueueFactory::instance()->createMessageQueue(1);
+	MessageQueueId_t testReceiverMqId = testReceiverMq->getId();
+	std::array<uint8_t, 20> testData { 0 };
+	testData[0] = 42;
+	MessageQueueMessage testMessage(testData.data(), 1);
+	testSenderMq->setDefaultDestination(testReceiverMqId);
+
+	SECTION("Simple Tests") {
+		auto result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+		REQUIRE(result == retval::CATCH_OK);
+		MessageQueueMessage recvMessage;
+		result = testReceiverMq->receiveMessage(&recvMessage);
+		REQUIRE(result == retval::CATCH_OK);
+		CHECK(recvMessage.getData()[0] == 42);
+
+		result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+		REQUIRE(result == retval::CATCH_OK);
+		MessageQueueId_t senderId = 0;
+		result = testReceiverMq->receiveMessage(&recvMessage,&senderId);
+		REQUIRE(result == retval::CATCH_OK);
+		CHECK(recvMessage.getData()[0] == 42);
+		CHECK(senderId == testSenderMqId);
+		senderId = testReceiverMq->getLastPartner();
+		CHECK(senderId == testSenderMqId);
+	}
+
+
+}
diff --git a/unittest/tests/osal/TestSemaphore.cpp b/unittest/tests/osal/TestSemaphore.cpp
new file mode 100644
index 000000000..f7b255346
--- /dev/null
+++ b/unittest/tests/osal/TestSemaphore.cpp
@@ -0,0 +1,46 @@
+
+#ifdef LINUX
+
+/*
+#include "core/CatchDefinitions.h"
+#include "catch.hpp"
+
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+
+TEST_CASE("Binary Semaphore Test" , "[BinSemaphore]") {
+	//perform set-up here
+	SemaphoreIF* binSemaph = SemaphoreFactory::instance()->
+			createBinarySemaphore();
+	REQUIRE(binSemaph != nullptr);
+	SECTION("Simple Test") {
+		// set-up is run for each section
+		REQUIRE(binSemaph->getSemaphoreCounter() == 1);
+		REQUIRE(binSemaph->release() ==
+				static_cast<int>(SemaphoreIF::SEMAPHORE_NOT_OWNED));
+		REQUIRE(binSemaph->acquire(SemaphoreIF::POLLING) ==
+				retval::CATCH_OK);
+		{
+			// not precise enough on linux.. should use clock instead..
+			//Stopwatch stopwatch(false);
+			//REQUIRE(binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 5) ==
+			//		SemaphoreIF::SEMAPHORE_TIMEOUT);
+			//dur_millis_t time = stopwatch.stop();
+			//CHECK(time == 5);
+		}
+		REQUIRE(binSemaph->getSemaphoreCounter() == 0);
+		REQUIRE(binSemaph->release() == retval::CATCH_OK);
+	}
+	SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
+	// perform tear-down here
+}
+
+
+TEST_CASE("Counting Semaphore Test" , "[CountingSemaph]") {
+	SECTION("Simple Test") {
+
+	}
+}
+*/
+
+#endif
diff --git a/unittest/tests/serialize/TestSerialBufferAdapter.cpp b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
new file mode 100644
index 000000000..39c1ba61a
--- /dev/null
+++ b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
@@ -0,0 +1,143 @@
+#include <fsfw/serialize/SerialBufferAdapter.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+
+static bool test_value_bool = true;
+static uint16_t tv_uint16 {283};
+static std::array<uint8_t, 512> testArray;
+
+TEST_CASE("Serial Buffer Adapter", "[single-file]") {
+	size_t serialized_size = 0;
+	test_value_bool = true;
+	uint8_t * arrayPtr = testArray.data();
+	std::array<uint8_t, 5> test_serial_buffer {5, 4, 3, 2, 1};
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter =
+			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+					test_serial_buffer.size(), false);
+	tv_uint16 = 16;
+
+	SECTION("Serialize without size field") {
+		SerializeAdapter::serialize(&test_value_bool, &arrayPtr,
+				&serialized_size, testArray.size(),
+				SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_serial_buffer_adapter, &arrayPtr,
+				&serialized_size, testArray.size(),
+				SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint16, &arrayPtr, &serialized_size,
+				testArray.size(), SerializeIF::Endianness::MACHINE);
+
+		REQUIRE(serialized_size == 8);
+		REQUIRE(testArray[0] == true);
+		REQUIRE(testArray[1] == 5);
+		REQUIRE(testArray[2] == 4);
+		REQUIRE(testArray[3] == 3);
+		REQUIRE(testArray[4] == 2);
+		REQUIRE(testArray[5] == 1);
+		memcpy(&tv_uint16, testArray.data() + 6, sizeof(tv_uint16));
+		REQUIRE(tv_uint16 == 16);
+	}
+
+	SECTION("Serialize with size field") {
+		SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter_loc =
+				SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+						test_serial_buffer.size(), true);
+		serialized_size = 0;
+		arrayPtr = testArray.data();
+		SerializeAdapter::serialize(&test_value_bool, &arrayPtr,&serialized_size,
+				testArray.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_serial_buffer_adapter_loc, &arrayPtr,
+				&serialized_size, testArray.size(),
+				SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint16, &arrayPtr, &serialized_size,
+				testArray.size(), SerializeIF::Endianness::MACHINE);
+
+		REQUIRE(serialized_size == 9);
+		REQUIRE(testArray[0] == true);
+		REQUIRE(testArray[1] == 5);
+		REQUIRE(testArray[2] == 5);
+		REQUIRE(testArray[3] == 4);
+		REQUIRE(testArray[4] == 3);
+		REQUIRE(testArray[5] == 2);
+		REQUIRE(testArray[6] == 1);
+		memcpy(&tv_uint16, testArray.data() + 7, sizeof(tv_uint16));
+		REQUIRE(tv_uint16 == 16);
+	}
+
+	SECTION("Test set buffer function") {
+		SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter_loc =
+					SerialBufferAdapter<uint8_t>((uint8_t*)nullptr,
+					0, true);
+		tv_serial_buffer_adapter_loc.setBuffer(test_serial_buffer.data(),
+				test_serial_buffer.size());
+		serialized_size = 0;
+		arrayPtr = testArray.data();
+		SerializeAdapter::serialize(&test_value_bool, &arrayPtr,&serialized_size,
+				testArray.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_serial_buffer_adapter_loc, &arrayPtr,
+				&serialized_size, testArray.size(),
+				SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint16, &arrayPtr, &serialized_size,
+				testArray.size(), SerializeIF::Endianness::MACHINE);
+		REQUIRE(serialized_size == 9);
+		REQUIRE(testArray[0] == true);
+		REQUIRE(testArray[1] == 5);
+		REQUIRE(testArray[2] == 5);
+		REQUIRE(testArray[3] == 4);
+		REQUIRE(testArray[4] == 3);
+		REQUIRE(testArray[5] == 2);
+		REQUIRE(testArray[6] == 1);
+		memcpy(&tv_uint16, testArray.data() + 7, sizeof(tv_uint16));
+		REQUIRE(tv_uint16 == 16);
+	}
+
+	SECTION("Deserialization with size field") {
+		size_t buffer_size = 4;
+		memcpy(testArray.data(), &buffer_size, sizeof(uint16_t));
+		testArray[2] = 1;
+		testArray[3] = 1;
+		testArray[4] = 1;
+		testArray[5] = 0;
+		std::array<uint8_t, 4> test_recv_array;
+		arrayPtr = testArray.data();
+		// copy testArray[1] to testArray[4] into receive buffer, skip
+		// size field (testArray[0]) for deSerialization.
+		SerialBufferAdapter<uint16_t> tv_serial_buffer_adapter3 =
+				SerialBufferAdapter<uint16_t>(test_recv_array.data(), 4, true);
+		// Deserialization
+		size_t size = 6;
+		auto result = tv_serial_buffer_adapter3.deSerialize(
+				const_cast<const uint8_t**>(&arrayPtr), &size,
+				SerializeIF::Endianness::MACHINE);
+		REQUIRE(result == retval::CATCH_OK);
+		CHECK(test_recv_array[0] == 1);
+		CHECK(test_recv_array[1] == 1);
+		CHECK(test_recv_array[2] == 1);
+		CHECK(test_recv_array[3] == 0);
+	}
+
+	SECTION("Deserialization without size field") {
+		size_t buffer_size = 4;
+		memcpy(testArray.data(), &buffer_size, sizeof(uint16_t));
+		testArray[2] = 1;
+		testArray[3] = 1;
+		testArray[4] = 1;
+		testArray[5] = 0;
+		std::array<uint8_t, 4> test_recv_array;
+		arrayPtr = testArray.data() + 2;
+		// copy testArray[1] to testArray[4] into receive buffer, skip
+		// size field (testArray[0])
+		SerialBufferAdapter<uint16_t> tv_serial_buffer_adapter3 =
+				SerialBufferAdapter<uint16_t>(test_recv_array.data(), 4, false);
+		// Deserialization
+		size_t size = 4;
+		tv_serial_buffer_adapter3.deSerialize(
+				const_cast<const uint8_t**>(&arrayPtr), &size,
+				SerializeIF::Endianness::MACHINE);
+		CHECK(test_recv_array[0] == 1);
+		CHECK(test_recv_array[1] == 1);
+		CHECK(test_recv_array[2] == 1);
+		CHECK(test_recv_array[3] == 0);
+	}
+}
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.cpp b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
new file mode 100644
index 000000000..932b62abe
--- /dev/null
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
@@ -0,0 +1,73 @@
+#include <fsfw/globalfunctions/arrayprinter.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <fsfw/unittest/tests/serialize/TestSerialLinkedPacket.h>
+
+
+TEST_CASE("Serial Linked Packet" , "[SerLinkPacket]") {
+	// perform set-up here
+	uint32_t header = 42;
+	std::array<uint8_t, 3> testArray {1,2,3};
+	uint32_t tail = 96;
+	size_t packetMaxSize = 256;
+	uint8_t packet [packetMaxSize] = {};
+	size_t packetLen = 0;
+
+	SECTION("Test Deserialization with Serial Buffer Adapter.") {
+		// This is a serialization of a packet, made "manually".
+		// We generate a packet which store data big-endian by swapping some
+		// values. (like coming from ground).
+		header = EndianConverter::convertBigEndian(header);
+		std::memcpy(packet, &header, sizeof(header));
+		packetLen += sizeof(header);
+
+		std::copy(testArray.data(), testArray.data() + testArray.size(),
+				packet + packetLen);
+		packetLen += testArray.size();
+
+		tail = EndianConverter::convertBigEndian(tail);
+		std::memcpy(packet + packetLen, &tail, sizeof(tail));
+		packetLen += sizeof(tail);
+
+		//arrayprinter::print(packet, packetLen, OutputType::DEC);
+
+		// This is the buffer which will be filled when testClass.deSerialize
+		// is called.
+		std::array<uint8_t, 3> bufferAdaptee = {};
+		TestPacket testClass(packet, packetLen, bufferAdaptee.data(),
+					bufferAdaptee.size());
+		const uint8_t* readOnlyPointer = packet;
+		// Deserialize big endian packet by setting bigEndian to true.
+		ReturnValue_t result = testClass.deSerialize(&readOnlyPointer,
+				&packetLen, SerializeIF::Endianness::BIG);
+		REQUIRE(result == retval::CATCH_OK);
+		CHECK(testClass.getHeader() == 42);
+		// Equivalent check.
+		// CHECK(testClass.getBuffer()[0] == 1);
+		CHECK(bufferAdaptee[0] == 1);
+		CHECK(bufferAdaptee[1] == 2);
+		CHECK(bufferAdaptee[2] == 3);
+		CHECK(testClass.getTail() == 96);
+	}
+
+	SECTION("Test Serialization") {
+		// Same process as performed in setup, this time using the class
+		// instead of doing it manually.
+		TestPacket testClass(header, tail, testArray.data(), testArray.size());
+		size_t serializedSize = 0;
+		uint8_t* packetPointer = packet;
+		// serialize for ground: bigEndian = true.
+		ReturnValue_t result = testClass.serialize(&packetPointer,
+				&serializedSize, packetMaxSize, SerializeIF::Endianness::BIG);
+		REQUIRE(result == retval::CATCH_OK);
+		// Result should be big endian now.
+		CHECK(packet[3] == 42);
+		CHECK(packet[4] == 1);
+		CHECK(packet[5] == 2);
+		CHECK(packet[6] == 3);
+		CHECK(packet[10] == 96);
+	}
+
+	// perform tear-down here
+}
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.h b/unittest/tests/serialize/TestSerialLinkedPacket.h
new file mode 100644
index 000000000..6c720577b
--- /dev/null
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.h
@@ -0,0 +1,61 @@
+#ifndef UNITTEST_HOSTED_TESTSERIALLINKEDPACKET_H_
+#define UNITTEST_HOSTED_TESTSERIALLINKEDPACKET_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+#include <fsfw/parameters/HasParametersIF.h>
+#include <fsfw/serialize/SerialBufferAdapter.h>
+#include <fsfw/serialize/SerialLinkedListAdapter.h>
+#include <cstdint>
+
+class TestPacket: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	/**
+	 * For Deserialization
+	 */
+	TestPacket(const uint8_t *somePacket, size_t size, uint8_t * storePointer,
+			size_t storeSize):
+			buffer(storePointer, storeSize)
+	{
+		setLinks();
+	}
+
+	/**
+	 * For Serialization
+	 */
+	TestPacket(uint32_t header, uint32_t tail,
+			const uint8_t* parameters, size_t paramSize):
+			header(header), buffer(parameters, paramSize),
+			tail(tail) {
+		setLinks();
+	}
+
+	uint32_t getHeader() const {
+		return header.entry;
+	}
+
+	const uint8_t * getBuffer() {
+		return buffer.entry.getConstBuffer();
+	}
+
+	const size_t getBufferLength() {
+		return buffer.getSerializedSize();
+	}
+
+
+	uint16_t getTail() const {
+		return tail.entry;
+	}
+private:
+	void setLinks() {
+		setStart(&header);
+		header.setNext(&buffer);
+		buffer.setNext(&tail);
+		tail.setEnd();
+	}
+
+	SerializeElement<uint32_t> header = 0;
+	SerializeElement<SerialBufferAdapter<uint8_t>> buffer;
+	SerializeElement<uint32_t> tail = 0;
+};
+
+#endif /* UNITTEST_TESTFW_NEWTESTS_TESTTEMPLATE_H_ */
diff --git a/unittest/tests/serialize/TestSerialization.cpp b/unittest/tests/serialize/TestSerialization.cpp
new file mode 100644
index 000000000..7ac7b7963
--- /dev/null
+++ b/unittest/tests/serialize/TestSerialization.cpp
@@ -0,0 +1,129 @@
+#include <fsfw/serialize/SerializeAdapter.h>
+
+#include "catch.hpp"
+#include <array>
+#include "core/CatchDefinitions.h"
+
+static bool test_value_bool = true;
+static uint8_t tv_uint8   {5};
+static uint16_t tv_uint16 {283};
+static uint32_t tv_uint32 {929221};
+static uint64_t tv_uint64 {2929329429};
+
+static int8_t tv_int8 {-16};
+static int16_t tv_int16 {-829};
+static int32_t tv_int32 {-2312};
+
+static float tv_float {8.2149214};
+static float tv_sfloat = {-922.2321321};
+static double tv_double {9.2132142141e8};
+static double tv_sdouble {-2.2421e19};
+
+static std::array<uint8_t, 512> test_array;
+
+TEST_CASE( "Serialization size tests", "[TestSerialization]") {
+	//REQUIRE(unitTestClass.test_autoserialization() == 0);
+	REQUIRE(SerializeAdapter::getSerializedSize(&test_value_bool) ==
+			sizeof(test_value_bool));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_uint8) ==
+			sizeof(tv_uint8));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_uint16) ==
+			sizeof(tv_uint16));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_uint32 ) ==
+			sizeof(tv_uint32));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_uint64) ==
+			sizeof(tv_uint64));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_int8) ==
+			sizeof(tv_int8));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_int16) ==
+			sizeof(tv_int16));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_int32) ==
+			sizeof(tv_int32));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_float) ==
+			sizeof(tv_float));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_sfloat) ==
+			sizeof(tv_sfloat ));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_double) ==
+			sizeof(tv_double));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_sdouble) ==
+			sizeof(tv_sdouble));
+}
+
+
+TEST_CASE("Auto Serialize Adapter testing", "[single-file]") {
+	size_t serialized_size = 0;
+	uint8_t * p_array = test_array.data();
+
+	SECTION("Serializing...") {
+		SerializeAdapter::serialize(&test_value_bool, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint8, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint16, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint32, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_int8, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_int16, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_int32, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint64, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_float, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_double, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_sfloat, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_sdouble, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		REQUIRE (serialized_size == 47);
+	}
+
+	SECTION("Deserializing") {
+		p_array = test_array.data();
+		size_t remaining_size = serialized_size;
+		SerializeAdapter::deSerialize(&test_value_bool,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_uint8,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_uint16,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_uint32,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_int8,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_int16,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_int32,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_uint64,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_float,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_double,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_sfloat,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_sdouble,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+
+		REQUIRE(test_value_bool == true);
+		REQUIRE(tv_uint8 == 5);
+		REQUIRE(tv_uint16 == 283);
+		REQUIRE(tv_uint32 == 929221);
+		REQUIRE(tv_uint64 == 2929329429);
+		REQUIRE(tv_int8 == -16);
+		REQUIRE(tv_int16 == -829);
+		REQUIRE(tv_int32 == -2312);
+
+		REQUIRE(tv_float == Approx(8.214921));
+		REQUIRE(tv_double == Approx(9.2132142141e8));
+		REQUIRE(tv_sfloat == Approx(-922.2321321));
+		REQUIRE(tv_sdouble == Approx(-2.2421e19));
+	}
+}
+
+
diff --git a/unittest/tests/storagemanager/TestNewAccessor.cpp b/unittest/tests/storagemanager/TestNewAccessor.cpp
new file mode 100644
index 000000000..7685afb3d
--- /dev/null
+++ b/unittest/tests/storagemanager/TestNewAccessor.cpp
@@ -0,0 +1,161 @@
+#include <fsfw/storagemanager/LocalPool.h>
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <array>
+
+TEST_CASE( "New Accessor" , "[NewAccessor]") {
+	uint16_t numberOfElements[1] = {1};
+	uint16_t sizeofElements[1] = {10};
+	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
+	std::array<uint8_t, 20> testDataArray;
+	std::array<uint8_t, 20> receptionArray;
+	store_address_t testStoreId;
+	ReturnValue_t result = retval::CATCH_FAILED;
+
+	for(size_t i = 0; i < testDataArray.size(); i++) {
+		testDataArray[i] = i;
+	}
+	size_t size = 10;
+
+	SECTION ("Simple tests getter functions") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		auto resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		CHECK(resultPair.second.getId() == testStoreId);
+		CHECK(resultPair.second.size() == 10);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		std::copy(resultPair.second.data(), resultPair.second.data() +
+				resultPair.second.size(), receptionArray.data());
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		{
+			auto resultPairLoc = SimplePool.getData(testStoreId);
+			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+			// data should be deleted when accessor goes out of scope.
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			ConstStorageAccessor constAccessor(testStoreId);
+			result = SimplePool.getData(testStoreId, constAccessor);
+			REQUIRE(result == retval::CATCH_OK);
+			constAccessor.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			// likewise, data should be deleted when accessor gets out of scope.
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		{
+			resultPair = SimplePool.getData(testStoreId);
+			REQUIRE(resultPair.first == retval::CATCH_OK);
+			resultPair.second.release();
+			// now data should not be deleted anymore
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+	}
+
+
+	SECTION("Simple tests modify functions") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			StorageAccessor accessor(testStoreId);
+			result = SimplePool.modifyData(testStoreId, accessor);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(accessor.getId() == testStoreId);
+			CHECK(accessor.size() == 10);
+			accessor.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			std::copy(accessor.data(), accessor.data() +
+					accessor.size(), receptionArray.data());
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			// data should be deleted when accessor goes out of scope
+		}
+		auto resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			auto resultPairLoc = SimplePool.modifyData(testStoreId);
+			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+			CHECK(resultPairLoc.second.getId() == testStoreId);
+			CHECK(resultPairLoc.second.size() == 10);
+			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
+					resultPairLoc.second.size(), receptionArray.data());
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			resultPairLoc.second.release();
+			// data should not be deleted when accessor goes out of scope
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+	}
+
+
+	SECTION("Write tests") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			auto resultPair = SimplePool.modifyData(testStoreId);
+			REQUIRE(resultPair.first == retval::CATCH_OK);
+			testDataArray[9] = 42;
+			resultPair.second.write(testDataArray.data(), 10, 0);
+			// now data should not be deleted
+			resultPair.second.release();
+		}
+		auto resultConstPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultConstPair.first == retval::CATCH_OK);
+
+		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
+		for(size_t i = 0; i < size-1; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+		CHECK(receptionArray[9] == 42 );
+
+		auto resultPair = SimplePool.modifyData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		result = resultPair.second.write(testDataArray.data(), 20, 0);
+		REQUIRE(result == retval::CATCH_FAILED);
+		result = resultPair.second.write(testDataArray.data(), 10, 5);
+		REQUIRE(result == retval::CATCH_FAILED);
+
+		memset(testDataArray.data(), 42, 5);
+		result = resultPair.second.write(testDataArray.data(), 5, 5);
+		REQUIRE(result == retval::CATCH_OK);
+		resultConstPair = SimplePool.getData(testStoreId);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		for(size_t i = 5; i < 10; i++) {
+			CHECK(receptionArray[i] == 42 );
+		}
+
+	}
+}
diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
new file mode 100644
index 000000000..5b22118e4
--- /dev/null
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -0,0 +1,105 @@
+#include <config/objects/Factory.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/storagemanager/LocalPool.h>
+#include <catch2/catch.hpp>
+#include "core/CatchDefinitions.h"
+
+TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
+	uint16_t numberOfElements[1] = {1};
+	uint16_t sizeofElements[1] = {10};
+	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
+	std::array<uint8_t, 20> testDataArray;
+	std::array<uint8_t, 20> receptionArray;
+	store_address_t testStoreId;
+	ReturnValue_t result = retval::CATCH_FAILED;
+	uint8_t *pointer = nullptr;
+	const uint8_t * constPointer = nullptr;
+	uint8_t test = 0;
+
+	for(size_t i = 0; i < testDataArray.size(); i++) {
+		testDataArray[i] = i;
+	}
+	size_t size = 10;
+
+	SECTION ( "Basic tests") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		REQUIRE(result == retval::CATCH_OK);
+		memcpy(receptionArray.data(), constPointer, size);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+		memset(receptionArray.data(), 0, size);
+		result = SimplePool.modifyData(testStoreId, &pointer, &size);
+		memcpy(receptionArray.data(), pointer, size);
+		REQUIRE(result == retval::CATCH_OK);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+		result = SimplePool.deleteData(testStoreId);
+		REQUIRE(result == retval::CATCH_OK);
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), 15);
+		CHECK (result == (int) StorageManagerIF::DATA_TOO_LARGE);
+	}
+
+	SECTION ( "Reservation Tests ") {
+		pointer = nullptr;
+		result = SimplePool.getFreeElement(&testStoreId, size, &pointer);
+		REQUIRE (result == retval::CATCH_OK);
+		memcpy(pointer, testDataArray.data(), size);
+		constPointer = nullptr;
+		result = SimplePool.getData(testStoreId, &constPointer, &size);
+
+		REQUIRE (result == retval::CATCH_OK);
+		memcpy(receptionArray.data(), constPointer, size);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+	}
+
+	SECTION ( "Add, delete, add, add when full") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		REQUIRE( result == retval::CATCH_OK);
+		memcpy(receptionArray.data(), constPointer, size);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		result = SimplePool.deleteData(testStoreId);
+		REQUIRE(result == retval::CATCH_OK);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		REQUIRE( result == retval::CATCH_OK);
+		memcpy(receptionArray.data(), constPointer, size);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		store_address_t newAddress;
+		result = SimplePool.addData(&newAddress, testDataArray.data(), size);
+		REQUIRE(result == (int) StorageManagerIF::DATA_STORAGE_FULL);
+	}
+
+	SECTION ( "Initialize and clear store, delete with pointer") {
+		result = SimplePool.initialize();
+		REQUIRE(result == retval::CATCH_OK);
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		SimplePool.clearStore();
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		result = SimplePool.modifyData(testStoreId, &pointer, &size);
+		REQUIRE(result == retval::CATCH_OK);
+		store_address_t newId;
+		result = SimplePool.deleteData(pointer, size, &testStoreId);
+		REQUIRE(result == retval::CATCH_OK);
+		REQUIRE(testStoreId.raw != (uint32_t) StorageManagerIF::INVALID_ADDRESS);
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+	}
+}
diff --git a/unittest/tests/tests.mk b/unittest/tests/tests.mk
new file mode 100644
index 000000000..47e634a26
--- /dev/null
+++ b/unittest/tests/tests.mk
@@ -0,0 +1,8 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/container/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/action/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/serialize/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/storagemanager/*.cpp)
+
+# OSAL not included for now.
+
+INCLUDES += $(CURRENTPATH)
\ No newline at end of file
diff --git a/unittest/testtemplate/TestTemplate.cpp b/unittest/testtemplate/TestTemplate.cpp
new file mode 100644
index 000000000..6b5fc3d2a
--- /dev/null
+++ b/unittest/testtemplate/TestTemplate.cpp
@@ -0,0 +1,31 @@
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+
+/**
+ * @brief 	Template test file
+ * @details
+ * In each test case, the code outside the sections is executed
+ * for EACH section.
+ * The most common macros to perform tests are:
+ *  - CHECK(...): assert expression and continues even if it fails
+ *  - REQUIRE(...): test case fails if assertion fails
+ *
+ *  Tests are generally sturctured in test cases and sections, see example
+ *  below.
+ *
+ *  More Documentation:
+ *  - https://github.com/catchorg/Catch2
+ *  - https://github.com/catchorg/Catch2/blob/master/docs/assertions.md
+ *  - https://github.com/catchorg/Catch2/blob/master/docs/test-cases-and-sections.md
+ */
+TEST_CASE("Dummy Test" , "[DummyTest]") {
+	uint8_t testVariable = 1;
+	//perform set-up here
+	CHECK(testVariable == 1);
+	SECTION("TestSection") {
+		// set-up is run for each section
+		REQUIRE(testVariable == 1);
+	}
+	// perform tear-down here
+}
diff --git a/unittest/unlockRealtime.sh b/unittest/unlockRealtime.sh
new file mode 100644
index 000000000..b28d54904
--- /dev/null
+++ b/unittest/unlockRealtime.sh
@@ -0,0 +1,34 @@
+#!/bin/bash
+# Run this script to unlock all permissions to run the linux binaries
+# and create threads
+
+binaries=$(find $directory -type f -name "*.elf")
+
+echo Unlocking real time permissions for binaries and bash console...
+
+# Set up the soft realtime limit to maximum (99)
+# Please note that the hard limit needs to be set to 99 too 
+# for this to work (check with ulimit -Hr).
+# If that has not been done yet, add
+# <username>	hard     rtprio          99
+# to /etc/security/limits.conf
+# It is also necessary and recommended to add
+# <username>    soft     rtprio         99
+# as well. This can also be done in the command line
+# but would need to be done for each session.
+ulimit -Sr 99
+
+for binary in ${binaries}; do
+	sudo setcap 'cap_sys_nice=eip' ${binary}
+	result=$?
+	if [ ${result} = 0 ];then
+		echo ${binary} was unlocked
+	fi
+done
+
+# sudo setcap 'cap_sys_nice=eip' /bin/bash
+# result=$?
+# if [ ${result} = 0 ];then
+# 	echo /bin/bash was unlocked
+# fi
+

From bb53c71f70132beae2dcf7f39201df769be697d8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 20 Oct 2020 17:21:20 +0200
Subject: [PATCH 0942/1774] fsfs config update

---
 unittest/config/FSFWConfig.h | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/unittest/config/FSFWConfig.h b/unittest/config/FSFWConfig.h
index 665c939f7..bb285472a 100644
--- a/unittest/config/FSFWConfig.h
+++ b/unittest/config/FSFWConfig.h
@@ -11,6 +11,12 @@
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_REDUCED_PRINTOUT		0
 
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+#define FSFW_CSB_FIFO_DEPTH			6
+
 //! If -DDEBUG is supplied in the build defines, there will be
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiles source files)

From 9309562716da79a49e9d04a4f9081eb730216581 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 20 Oct 2020 17:24:53 +0200
Subject: [PATCH 0943/1774] defaultcfg folder added

---
 defaultcfg/FSFWConfig.h | 41 +++++++++++++++++++++++++++++++++++++++++
 defaultcfg/version.h    | 11 +++++++++++
 2 files changed, 52 insertions(+)
 create mode 100644 defaultcfg/FSFWConfig.h
 create mode 100644 defaultcfg/version.h

diff --git a/defaultcfg/FSFWConfig.h b/defaultcfg/FSFWConfig.h
new file mode 100644
index 000000000..2001f3062
--- /dev/null
+++ b/defaultcfg/FSFWConfig.h
@@ -0,0 +1,41 @@
+#ifndef CONFIG_FSFWCONFIG_H_
+#define CONFIG_FSFWCONFIG_H_
+
+#include "version.h"
+
+//! Used to determine whether C++ ostreams are used
+//! Those can lead to code bloat.
+#define FSFW_CPP_OSTREAM_ENABLED 	1
+
+//! Reduced printout to further decrese code size
+//! Be careful, this also turns off most diagnostic prinouts!
+#define FSFW_REDUCED_PRINTOUT		0
+
+//! Can be used to enable debugging printouts for developing the FSFW
+#define FSFW_DEBUGGING              0
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+#define FSFW_CSB_FIFO_DEPTH			6
+
+//! If -DDEBUG is supplied in the build defines, there will be
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiles source files)
+#ifdef DEBUG
+#define FSFW_DEBUG_OUTPUT 			1
+//! Specify whether info events are printed too.
+#define FSFW_DEBUG_INFO				1
+#include <translateObjects.h>
+#include <translateEvents.h>
+#else
+#define FSFW_DEBUG_OUTPUT			0
+#endif
+
+//! When using the newlib nano library, C99 support for stdio facilities
+//! will not be provided. This define should be set to 1 if this is the case.
+#define FSFW_NO_C99_IO 	1
+
+
+#endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/defaultcfg/version.h b/defaultcfg/version.h
new file mode 100644
index 000000000..b3ef83189
--- /dev/null
+++ b/defaultcfg/version.h
@@ -0,0 +1,11 @@
+#ifndef FSFW_DEFAULTCFG_VERSION_H_
+#define FSFW_DEFAULTCFG_VERSION_H_
+
+static const char* FSFW_VERSION_NAME = "fsfw";
+
+#define FSFW_VERSION 		0
+#define	FSFW_SUBVERSION 	0
+
+
+
+#endif /* FSFW_DEFAULTCFG_VERSION_H_ */

From 057f3b859e9857d7139be783c9fb89987fc8fa15 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 20 Oct 2020 17:39:48 +0200
Subject: [PATCH 0944/1774] added readme and efaultcfg

---
 README.md                                     |   4 +
 defaultcfg/README.md                          |   6 +
 defaultcfg/config.mk                          |  17 ++
 defaultcfg/config/FSFWConfig.h                |  41 +++
 defaultcfg/config/OBSWConfig.h                |  14 +
 .../config/devices/logicalAddresses.cpp       |   5 +
 defaultcfg/config/devices/logicalAddresses.h  |  18 ++
 .../config/devices/powerSwitcherList.cpp      |   4 +
 defaultcfg/config/devices/powerSwitcherList.h |  12 +
 defaultcfg/config/events/subsystemIdRanges.h  |  18 ++
 defaultcfg/config/ipc/missionMessageTypes.cpp |  11 +
 defaultcfg/config/ipc/missionMessageTypes.h   |  21 ++
 defaultcfg/config/objects/Factory.cpp         |  57 ++++
 defaultcfg/config/objects/Factory.h           |  20 ++
 defaultcfg/config/objects/systemObjectList.h  | 138 +++++++++
 .../config/objects/translateObjects.cpp       | 271 ++++++++++++++++++
 defaultcfg/config/objects/translateObjects.h  |   9 +
 .../PollingSequenceFactory.cpp                |  23 ++
 .../pollingsequence/PollingSequenceFactory.h  |  32 +++
 defaultcfg/config/returnvalues/classIds.h     |  16 ++
 defaultcfg/config/tmtc/apid.h                 |  18 ++
 defaultcfg/config/tmtc/pusIds.h               |  23 ++
 defaultcfg/config/version.h                   |   9 +
 23 files changed, 787 insertions(+)
 create mode 100644 README.md
 create mode 100644 defaultcfg/README.md
 create mode 100644 defaultcfg/config.mk
 create mode 100644 defaultcfg/config/FSFWConfig.h
 create mode 100644 defaultcfg/config/OBSWConfig.h
 create mode 100644 defaultcfg/config/devices/logicalAddresses.cpp
 create mode 100644 defaultcfg/config/devices/logicalAddresses.h
 create mode 100644 defaultcfg/config/devices/powerSwitcherList.cpp
 create mode 100644 defaultcfg/config/devices/powerSwitcherList.h
 create mode 100644 defaultcfg/config/events/subsystemIdRanges.h
 create mode 100644 defaultcfg/config/ipc/missionMessageTypes.cpp
 create mode 100644 defaultcfg/config/ipc/missionMessageTypes.h
 create mode 100644 defaultcfg/config/objects/Factory.cpp
 create mode 100644 defaultcfg/config/objects/Factory.h
 create mode 100644 defaultcfg/config/objects/systemObjectList.h
 create mode 100644 defaultcfg/config/objects/translateObjects.cpp
 create mode 100644 defaultcfg/config/objects/translateObjects.h
 create mode 100644 defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp
 create mode 100644 defaultcfg/config/pollingsequence/PollingSequenceFactory.h
 create mode 100644 defaultcfg/config/returnvalues/classIds.h
 create mode 100644 defaultcfg/config/tmtc/apid.h
 create mode 100644 defaultcfg/config/tmtc/pusIds.h
 create mode 100644 defaultcfg/config/version.h

diff --git a/README.md b/README.md
new file mode 100644
index 000000000..fc86fca7c
--- /dev/null
+++ b/README.md
@@ -0,0 +1,4 @@
+Flight Software Framework (FSFW)
+======
+
+I want to be written!
diff --git a/defaultcfg/README.md b/defaultcfg/README.md
new file mode 100644
index 000000000..8446cda44
--- /dev/null
+++ b/defaultcfg/README.md
@@ -0,0 +1,6 @@
+# How to setup configuration folder for FSFW
+
+It is recommended to copy the content of the defaultcfg folder
+into a config folder which is in the same directory as the Flight
+Software Framework submodule. After that, the config.mk folder should be
+included by the primary Makefile with CURRENTPATH set correctly.
diff --git a/defaultcfg/config.mk b/defaultcfg/config.mk
new file mode 100644
index 000000000..fcf3b7992
--- /dev/null
+++ b/defaultcfg/config.mk
@@ -0,0 +1,17 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/config/ipc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/config/objects/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/config/pollingsequence/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/config/events/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/config/tmtc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/config/devices/*.cpp)
+
+INCLUDES += $(CURRENTPATH)
+INCLUDES += $(CURRENTPATH)/config/
+INCLUDES += $(CURRENTPATH)/config/objects
+INCLUDES += $(CURRENTPATH)/config/returnvalues
+INCLUDES += $(CURRENTPATH)/config/tmtc
+INCLUDES += $(CURRENTPATH)/config/events
+INCLUDES += $(CURRENTPATH)/config/devices
+INCLUDES += $(CURRENTPATH)/config/pollingsequence
+INCLUDES += $(CURRENTPATH)/config/ipc
+INCLUDES += $(CURRENTPATH)/config/
diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
new file mode 100644
index 000000000..2001f3062
--- /dev/null
+++ b/defaultcfg/config/FSFWConfig.h
@@ -0,0 +1,41 @@
+#ifndef CONFIG_FSFWCONFIG_H_
+#define CONFIG_FSFWCONFIG_H_
+
+#include "version.h"
+
+//! Used to determine whether C++ ostreams are used
+//! Those can lead to code bloat.
+#define FSFW_CPP_OSTREAM_ENABLED 	1
+
+//! Reduced printout to further decrese code size
+//! Be careful, this also turns off most diagnostic prinouts!
+#define FSFW_REDUCED_PRINTOUT		0
+
+//! Can be used to enable debugging printouts for developing the FSFW
+#define FSFW_DEBUGGING              0
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+#define FSFW_CSB_FIFO_DEPTH			6
+
+//! If -DDEBUG is supplied in the build defines, there will be
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiles source files)
+#ifdef DEBUG
+#define FSFW_DEBUG_OUTPUT 			1
+//! Specify whether info events are printed too.
+#define FSFW_DEBUG_INFO				1
+#include <translateObjects.h>
+#include <translateEvents.h>
+#else
+#define FSFW_DEBUG_OUTPUT			0
+#endif
+
+//! When using the newlib nano library, C99 support for stdio facilities
+//! will not be provided. This define should be set to 1 if this is the case.
+#define FSFW_NO_C99_IO 	1
+
+
+#endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/defaultcfg/config/OBSWConfig.h b/defaultcfg/config/OBSWConfig.h
new file mode 100644
index 000000000..d186da7da
--- /dev/null
+++ b/defaultcfg/config/OBSWConfig.h
@@ -0,0 +1,14 @@
+#ifndef CONFIG_OBSWCONFIG_H_
+#define CONFIG_OBSWCONFIG_H_
+
+#ifdef __cplusplus
+namespace config {
+#endif
+
+/* Add mission configuration flags here */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CONFIG_OBSWCONFIG_H_ */
diff --git a/defaultcfg/config/devices/logicalAddresses.cpp b/defaultcfg/config/devices/logicalAddresses.cpp
new file mode 100644
index 000000000..c7ce314d1
--- /dev/null
+++ b/defaultcfg/config/devices/logicalAddresses.cpp
@@ -0,0 +1,5 @@
+#include "logicalAddresses.h"
+
+
+
+
diff --git a/defaultcfg/config/devices/logicalAddresses.h b/defaultcfg/config/devices/logicalAddresses.h
new file mode 100644
index 000000000..174fa788b
--- /dev/null
+++ b/defaultcfg/config/devices/logicalAddresses.h
@@ -0,0 +1,18 @@
+#ifndef CONFIG_DEVICES_LOGICALADDRESSES_H_
+#define CONFIG_DEVICES_LOGICALADDRESSES_H_
+
+#include <config/objects/systemObjectList.h>
+#include <fsfw/devicehandlers/CookieIF.h>
+#include <cstdint>
+
+/**
+ * Can be used for addresses for physical devices like I2C adresses.
+ */
+namespace addresses {
+	/* Logical addresses have uint32_t datatype */
+	enum logicalAddresses: address_t {
+	};
+}
+
+
+#endif /* CONFIG_DEVICES_LOGICALADDRESSES_H_ */
diff --git a/defaultcfg/config/devices/powerSwitcherList.cpp b/defaultcfg/config/devices/powerSwitcherList.cpp
new file mode 100644
index 000000000..343f78d04
--- /dev/null
+++ b/defaultcfg/config/devices/powerSwitcherList.cpp
@@ -0,0 +1,4 @@
+#include "powerSwitcherList.h"
+
+
+
diff --git a/defaultcfg/config/devices/powerSwitcherList.h b/defaultcfg/config/devices/powerSwitcherList.h
new file mode 100644
index 000000000..86ddea570
--- /dev/null
+++ b/defaultcfg/config/devices/powerSwitcherList.h
@@ -0,0 +1,12 @@
+#ifndef CONFIG_DEVICES_POWERSWITCHERLIST_H_
+#define CONFIG_DEVICES_POWERSWITCHERLIST_H_
+
+namespace switches {
+	/* Switches are uint8_t datatype and go from 0 to 255 */
+	enum switcherList {
+	};
+
+}
+
+
+#endif /* CONFIG_DEVICES_POWERSWITCHERLIST_H_ */
diff --git a/defaultcfg/config/events/subsystemIdRanges.h b/defaultcfg/config/events/subsystemIdRanges.h
new file mode 100644
index 000000000..24eee819f
--- /dev/null
+++ b/defaultcfg/config/events/subsystemIdRanges.h
@@ -0,0 +1,18 @@
+#ifndef CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
+#define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
+
+#include <cstdint>
+#include <fsfw/events/fwSubsystemIdRanges.h>
+
+/**
+ * @brief	Custom subsystem IDs can be added here
+ * @details
+ * Subsystem IDs are used to create unique events.
+ */
+namespace SUBSYSTEM_ID {
+enum: uint8_t {
+	SUBSYSTEM_ID_START = FW_SUBSYSTEM_ID_RANGE,
+};
+}
+
+#endif /* CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_ */
diff --git a/defaultcfg/config/ipc/missionMessageTypes.cpp b/defaultcfg/config/ipc/missionMessageTypes.cpp
new file mode 100644
index 000000000..e2edbf9c5
--- /dev/null
+++ b/defaultcfg/config/ipc/missionMessageTypes.cpp
@@ -0,0 +1,11 @@
+#include <config/ipc/MissionMessageTypes.h>
+#include <fsfw/ipc/CommandMessageIF.h>
+
+void messagetypes::clearMissionMessage(CommandMessage* message) {
+	switch(message->getMessageType()) {
+	default:
+		break;
+	}
+}
+
+
diff --git a/defaultcfg/config/ipc/missionMessageTypes.h b/defaultcfg/config/ipc/missionMessageTypes.h
new file mode 100644
index 000000000..8b2e2fcce
--- /dev/null
+++ b/defaultcfg/config/ipc/missionMessageTypes.h
@@ -0,0 +1,21 @@
+#ifndef CONFIG_IPC_MISSIONMESSAGETYPES_H_
+#define CONFIG_IPC_MISSIONMESSAGETYPES_H_
+
+#include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/ipc/FwMessageTypes.h>
+
+/**
+ * Custom command messages are specified here.
+ * Most messages needed to use FSFW are already located in
+ * <fsfw/ipc/FwMessageTypes.h>
+ * @param message Generic Command Message
+ */
+namespace messagetypes {
+enum CustomMessageTypes {
+	MISSION_MESSAGE_TYPE_START = FW_MESSAGES_COUNT
+};
+
+void clearMissionMessage(CommandMessage* message);
+}
+
+#endif /* CONFIG_IPC_MISSIONMESSAGETYPES_H_ */
diff --git a/defaultcfg/config/objects/Factory.cpp b/defaultcfg/config/objects/Factory.cpp
new file mode 100644
index 000000000..ea187a5ea
--- /dev/null
+++ b/defaultcfg/config/objects/Factory.cpp
@@ -0,0 +1,57 @@
+#include "Factory.h"
+
+/* Config */
+#include <tmtc/apid.h>
+#include <objects/systemObjectList.h>
+#include <devices/logicalAddresses.h>
+#include <devices/powerSwitcherList.h>
+#include <tmtc/pusIds.h>
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <fsfw/events/EventManager.h>
+#include <fsfw/health/HealthTable.h>
+#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
+#include <mission/utility/TmFunnel.h>
+
+
+#include <cstdint>
+
+
+/**
+ * Build tasks by using SystemObject Interface (Interface).
+ * Header files of all tasks must be included
+ * Please note that an object has to implement the system object interface
+ * if the nterface validity is checked or retrieved later by using the
+ * get<TargetInterface>(object_id) function from the ObjectManagerIF.
+ *
+ * Framework objects are created first.
+ *
+ * @ingroup init
+ */
+void Factory::produce(void) {
+	setStaticFrameworkObjectIds();
+	new EventManager(objects::EVENT_MANAGER);
+	new HealthTable(objects::HEALTH_TABLE);
+	//new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+}
+
+void Factory::setStaticFrameworkObjectIds() {
+	PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
+	PusServiceBase::packetDestination = objects::TM_FUNNEL;
+
+	CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
+	CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+
+	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+
+	DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+	DeviceHandlerBase::rawDataReceiverId = objects::PUS_SERVICE_2_DEVICE_ACCESS;
+
+	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
+
+	TmPacketStored::timeStamperId = objects::PUS_TIME;
+	TmFunnel::downlinkDestination = objects::NO_OBJECT;
+}
+
diff --git a/defaultcfg/config/objects/Factory.h b/defaultcfg/config/objects/Factory.h
new file mode 100644
index 000000000..8b99ae996
--- /dev/null
+++ b/defaultcfg/config/objects/Factory.h
@@ -0,0 +1,20 @@
+#ifndef FACTORY_H_
+#define FACTORY_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+#include <cstddef>
+
+namespace Factory {
+    size_t calculateStorage(uint8_t numberOfPools, uint16_t* numberOfElements,
+            uint16_t* sizeOfElements);
+	/**
+	 * @brief   Creates all SystemObject elements which are persistent
+	 *          during execution.
+	 */
+	void produce();
+	void setStaticFrameworkObjectIds();
+
+}
+
+
+#endif /* FACTORY_H_ */
diff --git a/defaultcfg/config/objects/systemObjectList.h b/defaultcfg/config/objects/systemObjectList.h
new file mode 100644
index 000000000..2448efbd1
--- /dev/null
+++ b/defaultcfg/config/objects/systemObjectList.h
@@ -0,0 +1,138 @@
+#ifndef CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+#define CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+
+#include <cstdint>
+
+// The objects will be instantiated in the ID order
+namespace objects {
+	enum sourceObjects: uint32_t {
+		/* First Byte 0x50-0x52 reserved for PUS Services **/
+		CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
+		PUS_PACKET_DISTRIBUTOR = 0x50000200,
+		/* UDP ID must come after CCSDS Distributor  **/
+		UDP_TMTC_BRIDGE = 0x50000300,
+		EMAC_POLLING_TASK = 0x50000400,
+		SERIAL_TMTC_BRIDGE = 0x50000500,
+		SERIAL_RING_BUFFER = 0x50000550,
+		SERIAL_POLLING_TASK = 0x50000600,
+
+		PUS_SERVICE_6_MEM_MGMT = 0x51000500,
+		PUS_SERVICE_20_PARAM_MGMT = 0x51002000,
+		PUS_SERVICE_23_FILE_MGMT = 0x51002300,
+		PUS_SERVICE_201_HEALTH = 0x51020100,
+
+		PUS_TIME = 0x52000001,
+		TM_FUNNEL = 0x52000002,
+		FREERTOS_TASK_MONITOR = 0x53000003,
+
+		CORE_CONTROLLER = 0x40001000,
+        SYSTEM_STATE_TASK = 0x40001005,
+        THERMAL_CONTROLLER = 0x40002000,
+		RS485_CONTROLLER = 0x40005000,
+
+        /* 0x44 ('D') for Device Handlers **/
+        /* Second Byte: ComIF -> 0x00: UART,0x10 SPI,0x20: I2C,30: GPIO,40: PWM */
+        /* Third Byte: Device ID */
+		PCDU_HANDLER = 0x44003200,
+		GPS0_HANDLER = 0x44101F00,
+		GPS1_HANDLER = 0x44202000,
+
+		DLR_PVCH = 0x44104000,
+		GYRO1 = 0x44105000,
+		DLR_IRAS = 0x44106000,
+
+		/* fourth byte decoder output ID */
+
+		// Devices connected to decoder 1
+		SPI_Test_PT1000 = 0x44115400,
+		SPI_Test_Gyro = 0x44115500,
+		PT1000_Syrlinks_DEC1_O1 = 0x44115401,
+		PT1000_Camera_DEC1_O2 = 0x44115402,
+		PT1000_SuS1_DEC1_O3 = 0x44115404,
+		PT1000_SuS2_DEC1_O4 = 0x44115405,
+		PT1000_SuS3_DEC1_O5 = 0x44115406,
+		PT1000_PVHC_DEC1_O6 = 0x44115407,
+
+		// Devices connected to decoder 2
+		PT1000_CCSDS1_DEC2 = 0x44125401,
+		PT1000_MGT1_DEC2 = 0x44125403,
+		PT1000_SuS4_DEC2 = 0x44125404,
+		PT1000_SuS5_DEC2 = 0x44125405,
+		PT1000_SuS6_DEC2 = 0x44125406,
+		PT1000_PVCH_DEC2 = 0x44125407,
+		SuS_ADC1_DEC2 = 0x44020108,
+
+		// Devices connected to decoder 3
+		PT1000_Iridium_DEC3 = 0x44130301,
+		PT1000_CCSDS2_DEC3 = 0x44130302,
+		PT1000_SuS7_DEC3 = 0x44130305,
+		PT1000_SuS8_DEC3 = 0x44130306,
+		PT1000_PVCH_DEC3 = 0x44130307,
+		GYRO2 = 0x44130308,
+
+		// Devices connected to decoder 4
+		PT1000_PLOC_DEC4 = 0x44145401,
+		PT1000_SuS9_DEC4 = 0x44145404,
+		PT1000_SuS10_DEC4 = 0x44145405,
+		PT1000_PVHC_DEC4 = 0x44145406,
+		SuS_ADC_DEC4 = 0x44145407,
+
+		/* 0x49 ('I') for Communication Interfaces **/
+		DUMMY_ECHO_COM_IF = 0x4900AFFE,
+		DUMMY_GPS_COM_IF = 0x49001F00,
+		RS232_DEVICE_COM_IF = 0x49005200,
+		I2C_DEVICE_COM_IF = 0x49005300,
+		GPIO_DEVICE_COM_IF = 0x49005400,
+		SPI_DEVICE_COM_IF = 0x49005600,
+		//SPI_POLLING_TASK = 0x49005410,
+
+		/* 0x4d ('M') for Memory Handlers **/
+		SD_CARD_HANDLER = 0x4D0073AD,
+		FRAM_HANDLER = 0x4D008000,
+		SOFTWARE_IMAGE_HANDLER = 0x4D009000,
+
+		/* Board Specific */
+		AT91_I2C_TEST_TASK = 0x12345678,
+		AT91_UART0_TEST_TASK = 0x87654321,
+		AT91_UART2_TEST_TASK = 0x000123336,
+		AT91_SPI_TEST_TASK = 0x66666666,
+		STM32_TEST_TASK = 0x77777777,
+		LED_TASK = 0x12345777,
+
+		/* Test Task */
+		ARDUINO_0 = 0x01010100,
+		ARDUINO_1 = 0x01010101,
+		ARDUINO_2 = 0x01010102,
+		ARDUINO_3 = 0x01010103,
+		ARDUINO_4 = 0x01010104,
+		TEST_TASK = 0x42694269,
+		DUMMY_HANDLER = 0x4400AFFE,
+		TC_INJECTOR	= 0x99000001
+	};
+}
+
+#endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
+
+
+/**
+                   â–„              â–„
+                  ▌▒█           ▄▀▒▌
+                  ▌▒▒█        ▄▀▒▒▒�
+                 �▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒�
+               ▄▄▀▒░▒▒▒▒▒▒▒▒▒█▒▒▄█▒�
+             ▄▀▒▒▒░░░▒▒▒░░░▒▒▒▀██▀▒▌
+            �▒▒▒▄▄▒▒▒▒░░░▒▒▒▒▒▒▒▀▄▒▒▌
+            ▌░░▌█▀▒▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒�
+           �░░░▒▒▒▒▒▒▒▒▌██▀▒▒░░░▒▒▒▀▄▌
+           ▌░▒▄██▄▒▒▒▒▒▒▒▒▒░░░░░░▒▒▒▒▌
+          ▌▒▀�▄█▄█▌▄░▀▒▒░░░░░░░░░░▒▒▒�
+          �▒▒�▀�▀▒░▄▄▒▄▒▒▒▒▒▒░▒░▒░▒▒▒▒▌
+          �▒▒▒▀▀▄▄▒▒▒▄▒▒▒▒▒▒▒▒░▒░▒░▒▒�
+           ▌▒▒▒▒▒▒▀▀▀▒▒▒▒▒▒░▒░▒░▒░▒▒▒▌
+           �▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▒▄▒▒�
+            ▀▄▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▄▒▒▒▒▌
+              ▀▄▒▒▒▒▒▒▒▒▒▒▄▄▄▀▒▒▒▒▄▀
+                ▀▄▄▄▄▄▄▀▀▀▒▒▒▒▒▄▄▀
+                   ▒▒▒▒▒▒▒▒▒▒▀▀
+*/
+
diff --git a/defaultcfg/config/objects/translateObjects.cpp b/defaultcfg/config/objects/translateObjects.cpp
new file mode 100644
index 000000000..73cd02bfe
--- /dev/null
+++ b/defaultcfg/config/objects/translateObjects.cpp
@@ -0,0 +1,271 @@
+/** 
+ * @brief	Auto-generated object translation file. Contains 86 translations. 
+ * Generated on: 2020-08-25 00:57:14
+ **/ 
+#include "translateObjects.h"
+
+const char *AT91_UART2_TEST_TASK_STRING = "AT91_UART2_TEST_TASK";
+const char *ARDUINO_0_STRING = "ARDUINO_0";
+const char *ARDUINO_1_STRING = "ARDUINO_1";
+const char *ARDUINO_2_STRING = "ARDUINO_2";
+const char *ARDUINO_3_STRING = "ARDUINO_3";
+const char *ARDUINO_4_STRING = "ARDUINO_4";
+const char *AT91_I2C_TEST_TASK_STRING = "AT91_I2C_TEST_TASK";
+const char *LED_TASK_STRING = "LED_TASK";
+const char *TEST_TASK_STRING = "TEST_TASK";
+const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
+const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
+const char *SuS_ADC1_DEC2_STRING = "SuS_ADC1_DEC2";
+const char *GPS0_HANDLER_STRING = "GPS0_HANDLER";
+const char *DLR_PVCH_STRING = "DLR_PVCH";
+const char *GYRO1_STRING = "GYRO1";
+const char *DLR_IRAS_STRING = "DLR_IRAS";
+const char *SPI_Test_PT1000_STRING = "SPI_Test_PT1000";
+const char *PT1000_Syrlinks_DEC1_O1_STRING = "PT1000_Syrlinks_DEC1_O1";
+const char *PT1000_Camera_DEC1_O2_STRING = "PT1000_Camera_DEC1_O2";
+const char *PT1000_SuS1_DEC1_O3_STRING = "PT1000_SuS1_DEC1_O3";
+const char *PT1000_SuS2_DEC1_O4_STRING = "PT1000_SuS2_DEC1_O4";
+const char *PT1000_SuS3_DEC1_O5_STRING = "PT1000_SuS3_DEC1_O5";
+const char *PT1000_PVHC_DEC1_O6_STRING = "PT1000_PVHC_DEC1_O6";
+const char *SPI_Test_Gyro_STRING = "SPI_Test_Gyro";
+const char *PT1000_CCSDS1_DEC2_STRING = "PT1000_CCSDS1_DEC2";
+const char *PT1000_MGT1_DEC2_STRING = "PT1000_MGT1_DEC2";
+const char *PT1000_SuS4_DEC2_STRING = "PT1000_SuS4_DEC2";
+const char *PT1000_SuS5_DEC2_STRING = "PT1000_SuS5_DEC2";
+const char *PT1000_SuS6_DEC2_STRING = "PT1000_SuS6_DEC2";
+const char *PT1000_PVCH_DEC2_STRING = "PT1000_PVCH_DEC2";
+const char *PT1000_Iridium_DEC3_STRING = "PT1000_Iridium_DEC3";
+const char *PT1000_CCSDS2_DEC3_STRING = "PT1000_CCSDS2_DEC3";
+const char *PT1000_SuS7_DEC3_STRING = "PT1000_SuS7_DEC3";
+const char *PT1000_SuS8_DEC3_STRING = "PT1000_SuS8_DEC3";
+const char *PT1000_PVCH_DEC3_STRING = "PT1000_PVCH_DEC3";
+const char *GYRO2_STRING = "GYRO2";
+const char *PT1000_PLOC_DEC4_STRING = "PT1000_PLOC_DEC4";
+const char *PT1000_SuS9_DEC4_STRING = "PT1000_SuS9_DEC4";
+const char *PT1000_SuS10_DEC4_STRING = "PT1000_SuS10_DEC4";
+const char *PT1000_PVHC_DEC4_STRING = "PT1000_PVHC_DEC4";
+const char *SuS_ADC_DEC4_STRING = "SuS_ADC_DEC4";
+const char *GPS1_HANDLER_STRING = "GPS1_HANDLER";
+const char *DUMMY_GPS_COM_IF_STRING = "DUMMY_GPS_COM_IF";
+const char *RS232_DEVICE_COM_IF_STRING = "RS232_DEVICE_COM_IF";
+const char *I2C_DEVICE_COM_IF_STRING = "I2C_DEVICE_COM_IF";
+const char *GPIO_DEVICE_COM_IF_STRING = "GPIO_DEVICE_COM_IF";
+const char *SPI_POLLING_TASK_STRING = "SPI_POLLING_TASK";
+const char *SPI_DEVICE_COM_IF_STRING = "SPI_DEVICE_COM_IF";
+const char *DUMMY_ECHO_COM_IF_STRING = "DUMMY_ECHO_COM_IF";
+const char *SD_CARD_HANDLER_STRING = "SD_CARD_HANDLER";
+const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
+const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
+const char *UDP_TMTC_BRIDGE_STRING = "UDP_TMTC_BRIDGE";
+const char *EMAC_POLLING_TASK_STRING = "EMAC_POLLING_TASK";
+const char *SERIAL_TMTC_BRIDGE_STRING = "SERIAL_TMTC_BRIDGE";
+const char *SERIAL_RING_BUFFER_STRING = "SERIAL_RING_BUFFER";
+const char *SERIAL_POLLING_TASK_STRING = "SERIAL_POLLING_TASK";
+const char *PUS_SERVICE_1_STRING = "PUS_SERVICE_1";
+const char *PUS_SERVICE_2_STRING = "PUS_SERVICE_2";
+const char *PUS_SERVICE_3_STRING = "PUS_SERVICE_3";
+const char *PUS_SERVICE_3_PSB_STRING = "PUS_SERVICE_3_PSB";
+const char *PUS_SERVICE_5_STRING = "PUS_SERVICE_5";
+const char *PUS_SERVICE_6_STRING = "PUS_SERVICE_6";
+const char *PUS_SERVICE_8_STRING = "PUS_SERVICE_8";
+const char *PUS_SERVICE_9_STRING = "PUS_SERVICE_9";
+const char *PUS_SERVICE_17_STRING = "PUS_SERVICE_17";
+const char *PUS_SERVICE_20_STRING = "PUS_SERVICE_20";
+const char *PUS_SERVICE_23_STRING = "PUS_SERVICE_23";
+const char *PUS_SERVICE_200_STRING = "PUS_SERVICE_200";
+const char *PUS_SERVICE_201_STRING = "PUS_SERVICE_201";
+const char *PUS_TIME_STRING = "PUS_TIME";
+const char *PUS_FUNNEL_STRING = "PUS_FUNNEL";
+const char *FREERTOS_TASK_MONITOR_STRING = "FREERTOS_TASK_MONITOR";
+const char *HEALTH_TABLE_STRING = "HEALTH_TABLE";
+const char *MODE_STORE_STRING = "MODE_STORE";
+const char *EVENT_MANAGER_STRING = "EVENT_MANAGER";
+const char *INTERNAL_ERROR_REPORTER_STRING = "INTERNAL_ERROR_REPORTER";
+const char *TC_STORE_STRING = "TC_STORE";
+const char *TM_STORE_STRING = "TM_STORE";
+const char *IPC_STORE_STRING = "IPC_STORE";
+const char *AT91_SPI_TEST_TASK_STRING = "AT91_SPI_TEST_TASK";
+const char *STM32_TEST_TASK_STRING = "STM32_TEST_TASK";
+const char *AT91_UART0_TEST_TASK_STRING = "AT91_UART0_TEST_TASK";
+const char *TC_INJECTOR_STRING = "TC_INJECTOR";
+const char *NO_OBJECT_STRING = "NO_OBJECT";
+
+const char* translateObject(object_id_t object){
+	switch((object&0xFFFFFFFF)){
+		case 0x000123336:
+			return AT91_UART2_TEST_TASK_STRING;
+		case 0x01010100:
+			return ARDUINO_0_STRING;
+		case 0x01010101:
+			return ARDUINO_1_STRING;
+		case 0x01010102:
+			return ARDUINO_2_STRING;
+		case 0x01010103:
+			return ARDUINO_3_STRING;
+		case 0x01010104:
+			return ARDUINO_4_STRING;
+		case 0x12345678:
+			return AT91_I2C_TEST_TASK_STRING;
+		case 0x12345777:
+			return LED_TASK_STRING;
+		case 0x42694269:
+			return TEST_TASK_STRING;
+		case 0x44003200:
+			return PCDU_HANDLER_STRING;
+		case 0x4400AFFE:
+			return DUMMY_HANDLER_STRING;
+		case 0x44020108:
+			return SuS_ADC1_DEC2_STRING;
+		case 0x44101F00:
+			return GPS0_HANDLER_STRING;
+		case 0x44104000:
+			return DLR_PVCH_STRING;
+		case 0x44105000:
+			return GYRO1_STRING;
+		case 0x44106000:
+			return DLR_IRAS_STRING;
+		case 0x44115400:
+			return SPI_Test_PT1000_STRING;
+		case 0x44115401:
+			return PT1000_Syrlinks_DEC1_O1_STRING;
+		case 0x44115402:
+			return PT1000_Camera_DEC1_O2_STRING;
+		case 0x44115404:
+			return PT1000_SuS1_DEC1_O3_STRING;
+		case 0x44115405:
+			return PT1000_SuS2_DEC1_O4_STRING;
+		case 0x44115406:
+			return PT1000_SuS3_DEC1_O5_STRING;
+		case 0x44115407:
+			return PT1000_PVHC_DEC1_O6_STRING;
+		case 0x44115500:
+			return SPI_Test_Gyro_STRING;
+		case 0x44125401:
+			return PT1000_CCSDS1_DEC2_STRING;
+		case 0x44125403:
+			return PT1000_MGT1_DEC2_STRING;
+		case 0x44125404:
+			return PT1000_SuS4_DEC2_STRING;
+		case 0x44125405:
+			return PT1000_SuS5_DEC2_STRING;
+		case 0x44125406:
+			return PT1000_SuS6_DEC2_STRING;
+		case 0x44125407:
+			return PT1000_PVCH_DEC2_STRING;
+		case 0x44130301:
+			return PT1000_Iridium_DEC3_STRING;
+		case 0x44130302:
+			return PT1000_CCSDS2_DEC3_STRING;
+		case 0x44130305:
+			return PT1000_SuS7_DEC3_STRING;
+		case 0x44130306:
+			return PT1000_SuS8_DEC3_STRING;
+		case 0x44130307:
+			return PT1000_PVCH_DEC3_STRING;
+		case 0x44130308:
+			return GYRO2_STRING;
+		case 0x44145401:
+			return PT1000_PLOC_DEC4_STRING;
+		case 0x44145404:
+			return PT1000_SuS9_DEC4_STRING;
+		case 0x44145405:
+			return PT1000_SuS10_DEC4_STRING;
+		case 0x44145406:
+			return PT1000_PVHC_DEC4_STRING;
+		case 0x44145407:
+			return SuS_ADC_DEC4_STRING;
+		case 0x44202000:
+			return GPS1_HANDLER_STRING;
+		case 0x49001F00:
+			return DUMMY_GPS_COM_IF_STRING;
+		case 0x49005200:
+			return RS232_DEVICE_COM_IF_STRING;
+		case 0x49005300:
+			return I2C_DEVICE_COM_IF_STRING;
+		case 0x49005400:
+			return GPIO_DEVICE_COM_IF_STRING;
+		case 0x49005410:
+			return SPI_POLLING_TASK_STRING;
+		case 0x49005600:
+			return SPI_DEVICE_COM_IF_STRING;
+		case 0x4900AFFE:
+			return DUMMY_ECHO_COM_IF_STRING;
+		case 0x4D0073AD:
+			return SD_CARD_HANDLER_STRING;
+		case 0x50000100:
+			return CCSDS_PACKET_DISTRIBUTOR_STRING;
+		case 0x50000200:
+			return PUS_PACKET_DISTRIBUTOR_STRING;
+		case 0x50000300:
+			return UDP_TMTC_BRIDGE_STRING;
+		case 0x50000400:
+			return EMAC_POLLING_TASK_STRING;
+		case 0x50000500:
+			return SERIAL_TMTC_BRIDGE_STRING;
+		case 0x50000550:
+			return SERIAL_RING_BUFFER_STRING;
+		case 0x50000600:
+			return SERIAL_POLLING_TASK_STRING;
+		case 0x51000100:
+			return PUS_SERVICE_1_STRING;
+		case 0x51000200:
+			return PUS_SERVICE_2_STRING;
+		case 0x51000300:
+			return PUS_SERVICE_3_STRING;
+		case 0x51000310:
+			return PUS_SERVICE_3_PSB_STRING;
+		case 0x51000400:
+			return PUS_SERVICE_5_STRING;
+		case 0x51000500:
+			return PUS_SERVICE_6_STRING;
+		case 0x51000800:
+			return PUS_SERVICE_8_STRING;
+		case 0x51000900:
+			return PUS_SERVICE_9_STRING;
+		case 0x51001700:
+			return PUS_SERVICE_17_STRING;
+		case 0x51002000:
+			return PUS_SERVICE_20_STRING;
+		case 0x51002300:
+			return PUS_SERVICE_23_STRING;
+		case 0x51020000:
+			return PUS_SERVICE_200_STRING;
+		case 0x51020100:
+			return PUS_SERVICE_201_STRING;
+		case 0x52000001:
+			return PUS_TIME_STRING;
+		case 0x52000002:
+			return PUS_FUNNEL_STRING;
+		case 0x53000000:
+			return PUS_SERVICE_1_STRING;
+		case 0x53000003:
+			return FREERTOS_TASK_MONITOR_STRING;
+		case 0x53010000:
+			return HEALTH_TABLE_STRING;
+		case 0x53010100:
+			return MODE_STORE_STRING;
+		case 0x53030000:
+			return EVENT_MANAGER_STRING;
+		case 0x53040000:
+			return INTERNAL_ERROR_REPORTER_STRING;
+		case 0x534f0100:
+			return TC_STORE_STRING;
+		case 0x534f0200:
+			return TM_STORE_STRING;
+		case 0x534f0300:
+			return IPC_STORE_STRING;
+		case 0x66666666:
+			return AT91_SPI_TEST_TASK_STRING;
+		case 0x77777777:
+			return STM32_TEST_TASK_STRING;
+		case 0x87654321:
+			return AT91_UART0_TEST_TASK_STRING;
+		case 0x99000001:
+			return TC_INJECTOR_STRING;
+		case 0xFFFFFFFF:
+			return NO_OBJECT_STRING;
+		default:
+			return "UNKNOWN_OBJECT";
+	}
+	return 0;
+}
diff --git a/defaultcfg/config/objects/translateObjects.h b/defaultcfg/config/objects/translateObjects.h
new file mode 100644
index 000000000..5b6569408
--- /dev/null
+++ b/defaultcfg/config/objects/translateObjects.h
@@ -0,0 +1,9 @@
+#ifndef CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
+#define CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
+
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+
+const char* translateObject(object_id_t object);
+
+
+#endif /* CONFIG_OBJECTS_TRANSLATEOBJECTS_H_ */
diff --git a/defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp b/defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp
new file mode 100644
index 000000000..f836a7462
--- /dev/null
+++ b/defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp
@@ -0,0 +1,23 @@
+#include "PollingSequenceFactory.h"
+
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+
+ReturnValue_t pst::pollingSequenceInitDefault(
+        FixedTimeslotTaskIF *thisSequence) {
+	/* Length of a communication cycle */
+	uint32_t length = thisSequence->getPeriodMs();
+
+	/* Add polling sequence table here */
+
+	if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
+		        << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
diff --git a/defaultcfg/config/pollingsequence/PollingSequenceFactory.h b/defaultcfg/config/pollingsequence/PollingSequenceFactory.h
new file mode 100644
index 000000000..c5d41b7d8
--- /dev/null
+++ b/defaultcfg/config/pollingsequence/PollingSequenceFactory.h
@@ -0,0 +1,32 @@
+#ifndef POLLINGSEQUENCEFACTORY_H_
+#define POLLINGSEQUENCEFACTORY_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+class FixedTimeslotTaskIF;
+
+/**
+ * All device handlers are scheduled by adding them into  Polling Sequence Tables (PST)
+ * to satisfy stricter timing requirements of device communication,
+ * A device handler has four different communication steps:
+ *   1. DeviceHandlerIF::SEND_WRITE -> Send write via interface
+ *   2. DeviceHandlerIF::GET_WRITE -> Get confirmation for write
+ *   3. DeviceHandlerIF::SEND_READ -> Send read request
+ *   4. DeviceHandlerIF::GET_READ -> Read from interface
+ * The PST specifies precisely when the respective ComIF functions are called
+ * during the communication cycle time.
+ * The task is created using the FixedTimeslotTaskIF,
+ * which utilises the underlying Operating System Abstraction Layer (OSAL)
+ *
+ * @param thisSequence FixedTimeslotTaskIF * object is passed inside the Factory class when creating the PST
+ * @return
+ */
+namespace pst {
+
+/* Default PST */
+ReturnValue_t pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence);
+
+
+}
+
+#endif /* POLLINGSEQUENCEINIT_H_ */
diff --git a/defaultcfg/config/returnvalues/classIds.h b/defaultcfg/config/returnvalues/classIds.h
new file mode 100644
index 000000000..606cc60b2
--- /dev/null
+++ b/defaultcfg/config/returnvalues/classIds.h
@@ -0,0 +1,16 @@
+#ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
+#define CONFIG_RETURNVALUES_CLASSIDS_H_
+
+#include <fsfw/returnvalues/FwClassIds.h>
+
+/**
+ * @brief   CLASS_ID defintions which are required for custom returnvalues.
+ */
+namespace CLASS_ID {
+enum {
+	MISSION_CLASS_ID_START = FW_CLASS_ID_COUNT,
+};
+}
+
+
+#endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */
diff --git a/defaultcfg/config/tmtc/apid.h b/defaultcfg/config/tmtc/apid.h
new file mode 100644
index 000000000..c0231bca8
--- /dev/null
+++ b/defaultcfg/config/tmtc/apid.h
@@ -0,0 +1,18 @@
+#ifndef CONFIG_TMTC_APID_H_
+#define CONFIG_TMTC_APID_H_
+
+#include <cstdint>
+
+/**
+ * Application Process Definition: entity, uniquely identified by an
+ * application process ID (APID), capable of generating telemetry source
+ * packets and receiving telecommand packets.
+ *
+ * Chose APID(s) for mission and define it here.
+ */
+namespace apid {
+	static const uint16_t DEFAULT_APID = 0x00;
+}
+
+
+#endif /* CONFIG_TMTC_APID_H_ */
diff --git a/defaultcfg/config/tmtc/pusIds.h b/defaultcfg/config/tmtc/pusIds.h
new file mode 100644
index 000000000..cc0db9f02
--- /dev/null
+++ b/defaultcfg/config/tmtc/pusIds.h
@@ -0,0 +1,23 @@
+#ifndef CONFIG_TMTC_PUSIDS_HPP_
+#define CONFIG_TMTC_PUSIDS_HPP_
+
+namespace pus {
+enum Ids: uint8_t {
+	PUS_SERVICE_1 = 1,
+	PUS_SERVICE_2 = 2,
+	PUS_SERVICE_3 = 3,
+	PUS_SERVICE_5 = 5,
+	PUS_SERVICE_6 = 6,
+	PUS_SERVICE_8 = 8,
+	PUS_SERVICE_9 = 9,
+	PUS_SERVICE_11 = 11,
+	PUS_SERVICE_17 = 17,
+	PUS_SERVICE_19 = 19,
+	PUS_SERVICE_20 = 20,
+	PUS_SERVICE_23 = 23,
+	PUS_SERVICE_200 = 200,
+	PUS_SERVICE_201 = 201,
+};
+};
+
+#endif /* CONFIG_TMTC_PUSIDS_HPP_ */
diff --git a/defaultcfg/config/version.h b/defaultcfg/config/version.h
new file mode 100644
index 000000000..3c60317c4
--- /dev/null
+++ b/defaultcfg/config/version.h
@@ -0,0 +1,9 @@
+#ifndef CONFIG_VERSION_H_
+#define CONFIG_VERSION_H_
+
+/* OBSW versioning can be specified in this file */
+
+#define OBSW_VERSION      0
+#define OBSW_SUBVERSION   0
+
+#endif /* CONFIG_VERSION_H_ */

From b9f3c1ee84e331e0c5d52f88c313643d43dbf3c4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 20 Oct 2020 17:53:47 +0200
Subject: [PATCH 0945/1774] takne over defaultcfg

---
 FSFWVersion.h                                |  11 ++
 defaultcfg/config/FSFWConfig.h               |   2 +-
 defaultcfg/config/OBSWConfig.h               |   2 +
 defaultcfg/config/OBSWVersion.h              |   9 ++
 defaultcfg/config/objects/Factory.cpp        |  31 ++---
 defaultcfg/config/objects/Factory.h          |   3 -
 defaultcfg/config/objects/systemObjectList.h | 130 +------------------
 7 files changed, 41 insertions(+), 147 deletions(-)
 create mode 100644 FSFWVersion.h
 create mode 100644 defaultcfg/config/OBSWVersion.h

diff --git a/FSFWVersion.h b/FSFWVersion.h
new file mode 100644
index 000000000..b3ef83189
--- /dev/null
+++ b/FSFWVersion.h
@@ -0,0 +1,11 @@
+#ifndef FSFW_DEFAULTCFG_VERSION_H_
+#define FSFW_DEFAULTCFG_VERSION_H_
+
+static const char* FSFW_VERSION_NAME = "fsfw";
+
+#define FSFW_VERSION 		0
+#define	FSFW_SUBVERSION 	0
+
+
+
+#endif /* FSFW_DEFAULTCFG_VERSION_H_ */
diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index 2001f3062..cfe898642 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -1,7 +1,7 @@
 #ifndef CONFIG_FSFWCONFIG_H_
 #define CONFIG_FSFWCONFIG_H_
 
-#include "version.h"
+#include <FSFWVersion.h>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.
diff --git a/defaultcfg/config/OBSWConfig.h b/defaultcfg/config/OBSWConfig.h
index d186da7da..a9f576386 100644
--- a/defaultcfg/config/OBSWConfig.h
+++ b/defaultcfg/config/OBSWConfig.h
@@ -1,6 +1,8 @@
 #ifndef CONFIG_OBSWCONFIG_H_
 #define CONFIG_OBSWCONFIG_H_
 
+#include "OBSWVersion.h"
+
 #ifdef __cplusplus
 namespace config {
 #endif
diff --git a/defaultcfg/config/OBSWVersion.h b/defaultcfg/config/OBSWVersion.h
new file mode 100644
index 000000000..3c60317c4
--- /dev/null
+++ b/defaultcfg/config/OBSWVersion.h
@@ -0,0 +1,9 @@
+#ifndef CONFIG_VERSION_H_
+#define CONFIG_VERSION_H_
+
+/* OBSW versioning can be specified in this file */
+
+#define OBSW_VERSION      0
+#define OBSW_SUBVERSION   0
+
+#endif /* CONFIG_VERSION_H_ */
diff --git a/defaultcfg/config/objects/Factory.cpp b/defaultcfg/config/objects/Factory.cpp
index ea187a5ea..51dd61304 100644
--- a/defaultcfg/config/objects/Factory.cpp
+++ b/defaultcfg/config/objects/Factory.cpp
@@ -1,11 +1,9 @@
 #include "Factory.h"
-
-/* Config */
-#include <tmtc/apid.h>
-#include <objects/systemObjectList.h>
-#include <devices/logicalAddresses.h>
-#include <devices/powerSwitcherList.h>
-#include <tmtc/pusIds.h>
+#include "../tmtc/apid.h"
+#include "../tmtc/pusIds.h"
+#include "../objects/systemObjectList.h"
+#include "../devices/logicalAddresses.h"
+#include "../devices/powerSwitcherList.h"
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <fsfw/events/EventManager.h>
@@ -13,21 +11,20 @@
 #include <fsfw/tmtcpacket/pus/TmPacketStored.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
-#include <mission/utility/TmFunnel.h>
-
 
 #include <cstdint>
 
-
 /**
- * Build tasks by using SystemObject Interface (Interface).
- * Header files of all tasks must be included
- * Please note that an object has to implement the system object interface
- * if the nterface validity is checked or retrieved later by using the
- * get<TargetInterface>(object_id) function from the ObjectManagerIF.
+ * This class should be used to create all system objects required for
+ * the on-board software, using the object ID list from the configuration
+ * folder.
+ *
+ * The objects are registered in the internal object manager automatically.
+ * This is used later to add objects to tasks.
+ *
+ * This file also sets static framework IDs.
  *
  * Framework objects are created first.
- *
  * @ingroup init
  */
 void Factory::produce(void) {
@@ -52,6 +49,6 @@ void Factory::setStaticFrameworkObjectIds() {
 	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
 
 	TmPacketStored::timeStamperId = objects::PUS_TIME;
-	TmFunnel::downlinkDestination = objects::NO_OBJECT;
+	//TmFunnel::downlinkDestination = objects::NO_OBJECT;
 }
 
diff --git a/defaultcfg/config/objects/Factory.h b/defaultcfg/config/objects/Factory.h
index 8b99ae996..fe55defff 100644
--- a/defaultcfg/config/objects/Factory.h
+++ b/defaultcfg/config/objects/Factory.h
@@ -5,15 +5,12 @@
 #include <cstddef>
 
 namespace Factory {
-    size_t calculateStorage(uint8_t numberOfPools, uint16_t* numberOfElements,
-            uint16_t* sizeOfElements);
 	/**
 	 * @brief   Creates all SystemObject elements which are persistent
 	 *          during execution.
 	 */
 	void produce();
 	void setStaticFrameworkObjectIds();
-
 }
 
 
diff --git a/defaultcfg/config/objects/systemObjectList.h b/defaultcfg/config/objects/systemObjectList.h
index 2448efbd1..f4292f6d6 100644
--- a/defaultcfg/config/objects/systemObjectList.h
+++ b/defaultcfg/config/objects/systemObjectList.h
@@ -2,137 +2,15 @@
 #define CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
 
 #include <cstdint>
+#include <fsfw/objectmanager/frameworkObjects.h>
 
 // The objects will be instantiated in the ID order
 namespace objects {
 	enum sourceObjects: uint32_t {
-		/* First Byte 0x50-0x52 reserved for PUS Services **/
-		CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
-		PUS_PACKET_DISTRIBUTOR = 0x50000200,
-		/* UDP ID must come after CCSDS Distributor  **/
-		UDP_TMTC_BRIDGE = 0x50000300,
-		EMAC_POLLING_TASK = 0x50000400,
-		SERIAL_TMTC_BRIDGE = 0x50000500,
-		SERIAL_RING_BUFFER = 0x50000550,
-		SERIAL_POLLING_TASK = 0x50000600,
-
-		PUS_SERVICE_6_MEM_MGMT = 0x51000500,
-		PUS_SERVICE_20_PARAM_MGMT = 0x51002000,
-		PUS_SERVICE_23_FILE_MGMT = 0x51002300,
-		PUS_SERVICE_201_HEALTH = 0x51020100,
-
-		PUS_TIME = 0x52000001,
-		TM_FUNNEL = 0x52000002,
-		FREERTOS_TASK_MONITOR = 0x53000003,
-
-		CORE_CONTROLLER = 0x40001000,
-        SYSTEM_STATE_TASK = 0x40001005,
-        THERMAL_CONTROLLER = 0x40002000,
-		RS485_CONTROLLER = 0x40005000,
-
-        /* 0x44 ('D') for Device Handlers **/
-        /* Second Byte: ComIF -> 0x00: UART,0x10 SPI,0x20: I2C,30: GPIO,40: PWM */
-        /* Third Byte: Device ID */
-		PCDU_HANDLER = 0x44003200,
-		GPS0_HANDLER = 0x44101F00,
-		GPS1_HANDLER = 0x44202000,
-
-		DLR_PVCH = 0x44104000,
-		GYRO1 = 0x44105000,
-		DLR_IRAS = 0x44106000,
-
-		/* fourth byte decoder output ID */
-
-		// Devices connected to decoder 1
-		SPI_Test_PT1000 = 0x44115400,
-		SPI_Test_Gyro = 0x44115500,
-		PT1000_Syrlinks_DEC1_O1 = 0x44115401,
-		PT1000_Camera_DEC1_O2 = 0x44115402,
-		PT1000_SuS1_DEC1_O3 = 0x44115404,
-		PT1000_SuS2_DEC1_O4 = 0x44115405,
-		PT1000_SuS3_DEC1_O5 = 0x44115406,
-		PT1000_PVHC_DEC1_O6 = 0x44115407,
-
-		// Devices connected to decoder 2
-		PT1000_CCSDS1_DEC2 = 0x44125401,
-		PT1000_MGT1_DEC2 = 0x44125403,
-		PT1000_SuS4_DEC2 = 0x44125404,
-		PT1000_SuS5_DEC2 = 0x44125405,
-		PT1000_SuS6_DEC2 = 0x44125406,
-		PT1000_PVCH_DEC2 = 0x44125407,
-		SuS_ADC1_DEC2 = 0x44020108,
-
-		// Devices connected to decoder 3
-		PT1000_Iridium_DEC3 = 0x44130301,
-		PT1000_CCSDS2_DEC3 = 0x44130302,
-		PT1000_SuS7_DEC3 = 0x44130305,
-		PT1000_SuS8_DEC3 = 0x44130306,
-		PT1000_PVCH_DEC3 = 0x44130307,
-		GYRO2 = 0x44130308,
-
-		// Devices connected to decoder 4
-		PT1000_PLOC_DEC4 = 0x44145401,
-		PT1000_SuS9_DEC4 = 0x44145404,
-		PT1000_SuS10_DEC4 = 0x44145405,
-		PT1000_PVHC_DEC4 = 0x44145406,
-		SuS_ADC_DEC4 = 0x44145407,
-
-		/* 0x49 ('I') for Communication Interfaces **/
-		DUMMY_ECHO_COM_IF = 0x4900AFFE,
-		DUMMY_GPS_COM_IF = 0x49001F00,
-		RS232_DEVICE_COM_IF = 0x49005200,
-		I2C_DEVICE_COM_IF = 0x49005300,
-		GPIO_DEVICE_COM_IF = 0x49005400,
-		SPI_DEVICE_COM_IF = 0x49005600,
-		//SPI_POLLING_TASK = 0x49005410,
-
-		/* 0x4d ('M') for Memory Handlers **/
-		SD_CARD_HANDLER = 0x4D0073AD,
-		FRAM_HANDLER = 0x4D008000,
-		SOFTWARE_IMAGE_HANDLER = 0x4D009000,
-
-		/* Board Specific */
-		AT91_I2C_TEST_TASK = 0x12345678,
-		AT91_UART0_TEST_TASK = 0x87654321,
-		AT91_UART2_TEST_TASK = 0x000123336,
-		AT91_SPI_TEST_TASK = 0x66666666,
-		STM32_TEST_TASK = 0x77777777,
-		LED_TASK = 0x12345777,
-
-		/* Test Task */
-		ARDUINO_0 = 0x01010100,
-		ARDUINO_1 = 0x01010101,
-		ARDUINO_2 = 0x01010102,
-		ARDUINO_3 = 0x01010103,
-		ARDUINO_4 = 0x01010104,
-		TEST_TASK = 0x42694269,
-		DUMMY_HANDLER = 0x4400AFFE,
-		TC_INJECTOR	= 0x99000001
+		/* All addresses between start and end are reserved for the FSFW */
+		FSFW_CONFIG_RESERVED_START = PUS_SERVICE_1_VERIFICATION,
+		FSFW_CONFIG_RESERVED_END = TM_STORE
 	};
 }
 
 #endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
-
-
-/**
-                   â–„              â–„
-                  ▌▒█           ▄▀▒▌
-                  ▌▒▒█        ▄▀▒▒▒�
-                 �▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒�
-               ▄▄▀▒░▒▒▒▒▒▒▒▒▒█▒▒▄█▒�
-             ▄▀▒▒▒░░░▒▒▒░░░▒▒▒▀██▀▒▌
-            �▒▒▒▄▄▒▒▒▒░░░▒▒▒▒▒▒▒▀▄▒▒▌
-            ▌░░▌█▀▒▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒�
-           �░░░▒▒▒▒▒▒▒▒▌██▀▒▒░░░▒▒▒▀▄▌
-           ▌░▒▄██▄▒▒▒▒▒▒▒▒▒░░░░░░▒▒▒▒▌
-          ▌▒▀�▄█▄█▌▄░▀▒▒░░░░░░░░░░▒▒▒�
-          �▒▒�▀�▀▒░▄▄▒▄▒▒▒▒▒▒░▒░▒░▒▒▒▒▌
-          �▒▒▒▀▀▄▄▒▒▒▄▒▒▒▒▒▒▒▒░▒░▒░▒▒�
-           ▌▒▒▒▒▒▒▀▀▀▒▒▒▒▒▒░▒░▒░▒░▒▒▒▌
-           �▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▒▄▒▒�
-            ▀▄▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▄▒▒▒▒▌
-              ▀▄▒▒▒▒▒▒▒▒▒▒▄▄▄▀▒▒▒▒▄▀
-                ▀▄▄▄▄▄▄▀▀▀▒▒▒▒▒▄▄▀
-                   ▒▒▒▒▒▒▒▒▒▒▀▀
-*/
-

From 742cc6eb7660adbff54e498b29afe73bfca4bbdd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 21 Oct 2020 18:19:51 +0200
Subject: [PATCH 0946/1774] no command added

---
 devicehandlers/DeviceHandlerIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 088c1b457..f64e1589c 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -21,7 +21,7 @@ using DeviceCommandId_t = uint32_t;
  */
 class DeviceHandlerIF {
 public:
-
+    static const DeviceCommandId_t NO_COMMAND = 0xffffffff;
 
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;

From e7210a34f95cfa2ef4a980c18e37629f54aa0bd6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 22 Oct 2020 14:34:52 +0200
Subject: [PATCH 0947/1774] output tweaked

---
 unittest/internal/InternalUnitTester.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
index 9b219f09b..7b72d6458 100644
--- a/unittest/internal/InternalUnitTester.cpp
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -12,13 +12,13 @@ InternalUnitTester::InternalUnitTester() {}
 InternalUnitTester::~InternalUnitTester() {}
 
 ReturnValue_t InternalUnitTester::performTests() {
-	sif::info << "Running internal unit tests..\r\n" << std::flush;
+	sif::info << "Running internal unit tests.." << std::endl;
 	testserialize::test_serialization();
 	testmq::testMq();
 	testsemaph::testBinSemaph();
 	testsemaph::testCountingSemaph();
 	testmutex::testMutex();
-	sif::info << "Internal unit tests finished.\r\n" << std::flush;
+	sif::info << "Internal unit tests finished." << std::endl;
 	return RETURN_OK;
 }
 

From 90bdb844e703951ef783f0a025799efefcf6fc98 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 19:27:00 +0100
Subject: [PATCH 0948/1774] taken over some changes

---
 tmtcpacket/pus/PacketTimestampInterpreterIF.h |   3 +-
 tmtcpacket/pus/TcPacketBase.cpp               |  37 ++---
 tmtcpacket/pus/TcPacketBase.h                 | 131 ++++++++----------
 tmtcpacket/pus/TcPacketStored.cpp             |  47 +++----
 tmtcpacket/pus/TcPacketStored.h               |  75 +++++-----
 tmtcpacket/pus/TmPacketBase.cpp               |  78 +++++------
 tmtcpacket/pus/TmPacketBase.h                 | 120 ++++++++--------
 tmtcpacket/pus/TmPacketMinimal.cpp            |   4 +-
 8 files changed, 243 insertions(+), 252 deletions(-)

diff --git a/tmtcpacket/pus/PacketTimestampInterpreterIF.h b/tmtcpacket/pus/PacketTimestampInterpreterIF.h
index dd0c03285..40e7a2eaa 100644
--- a/tmtcpacket/pus/PacketTimestampInterpreterIF.h
+++ b/tmtcpacket/pus/PacketTimestampInterpreterIF.h
@@ -7,7 +7,8 @@ class TmPacketMinimal;
 class PacketTimestampInterpreterIF {
 public:
 	virtual ~PacketTimestampInterpreterIF() {}
-	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet, timeval* timestamp) const = 0;
+	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet,
+	        timeval* timestamp) const = 0;
 	virtual ReturnValue_t getPacketTimeRaw(TmPacketMinimal* packet, const uint8_t** timePtr, uint32_t* size) const = 0;
 };
 
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index b62db535e..eaa8416a9 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -1,11 +1,14 @@
-#include "../../globalfunctions/CRC.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TcPacketBase.h"
-#include <string.h>
+#include "TcPacketBase.h"
 
-TcPacketBase::TcPacketBase(const uint8_t* set_data) :
-		SpacePacketBase(set_data) {
-	tcData = (TcPacketPointer*) set_data;
+#include "../../globalfunctions/CRC.h"
+#include "../../globalfunctions/arrayprinter.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+#include <cstring>
+
+TcPacketBase::TcPacketBase(const uint8_t* setData) :
+		SpacePacketBase(setData) {
+	tcData = reinterpret_cast<TcPacketPointer*>(const_cast<uint8_t*>(setData));
 }
 
 TcPacketBase::~TcPacketBase() {
@@ -51,12 +54,6 @@ void TcPacketBase::setData(const uint8_t* pData) {
 	tcData = (TcPacketPointer*) pData;
 }
 
-void TcPacketBase::setAppData(uint8_t * appData, uint16_t dataLen) {
-	memcpy(&tcData->appData, appData, dataLen);
-	SpacePacketBase::setPacketDataLength(dataLen +
-				sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
-}
-
 uint8_t TcPacketBase::getSecondaryHeaderFlag() {
 	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
 }
@@ -66,21 +63,17 @@ uint8_t TcPacketBase::getPusVersionNumber() {
 }
 
 void TcPacketBase::print() {
-	uint8_t * wholeData = getWholeData();
-	sif::debug << "TcPacket contains: " << std::endl;
-	for (uint8_t count = 0; count < getFullSize(); ++count) {
-		sif::debug << std::hex << (uint16_t) wholeData[count] << " ";
-	}
-	sif::debug << std::dec << std::endl;
+    sif::debug << "TcPacketBase::print: " << std::endl;
+	arrayprinter::print(getWholeData(), getFullSize());
 }
 
 void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
-		uint8_t ack, uint8_t service, uint8_t subservice) {
+        uint8_t ack, uint8_t service, uint8_t subservice) {
 	initSpacePacketHeader(true, true, apid, sequenceCount);
-	memset(&tcData->dataField, 0, sizeof(tcData->dataField));
+	std::memset(&tcData->dataField, 0, sizeof(tcData->dataField));
 	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
 	//Data Field Header:
-	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
+	//Set CCSDS_secondary_header_flag to 0 and version number to 001
 	tcData->dataField.version_type_ack = 0b00010000;
 	tcData->dataField.version_type_ack |= (ack & 0x0F);
 	tcData->dataField.service_type = service;
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index b3ef5fe7b..582a22140 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -1,9 +1,10 @@
-#ifndef TCPACKETBASE_H_
-#define TCPACKETBASE_H_
+#ifndef TMTCPACKET_PUS_TCPACKETBASE_H_
+#define TMTCPACKET_PUS_TCPACKETBASE_H_
 
 #include "../../tmtcpacket/SpacePacketBase.h"
 #include <cstddef>
 
+
 /**
  * This struct defines a byte-wise structured PUS TC Data Field Header.
  * Any optional fields in the header must be added or removed here.
@@ -31,7 +32,7 @@ struct TcPacketPointer {
 /**
  * This class is the basic data handler for any ECSS PUS Telecommand packet.
  *
- * In addition to \SpacePacketBase, the class provides methods to handle
+ * In addition to #SpacePacketBase, the class provides methods to handle
  * the standardized entries of the PUS TC Packet Data Field Header.
  * It does not contain the packet data itself but a pointer to the
  * data must be set on instantiation. An invalid pointer may cause
@@ -40,68 +41,38 @@ struct TcPacketPointer {
  * @ingroup tmtcpackets
  */
 class TcPacketBase : public SpacePacketBase {
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TcPacketPointer* tcData;
 public:
-	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) + 2);
-	/**
-	 * With this constant for the acknowledge field responses on all levels are expected.
-	 */
-	static const uint8_t ACK_ALL = 0b1111;
-	/**
-	 * With this constant for the acknowledge field a response on acceptance is expected.
-	 */
-	static const uint8_t ACK_ACCEPTANCE = 0b0001;
-	/**
-	 * With this constant for the acknowledge field a response on start of execution is expected.
-	 */
-	static const uint8_t ACK_START = 0b0010;
-	/**
-	 * With this constant for the acknowledge field responses on execution steps are expected.
-	 */
-	static const uint8_t ACK_STEP = 0b0100;
-	/**
-	 * With this constant for the acknowledge field a response on completion is expected.
-	 */
-	static const uint8_t ACK_COMPLETION = 0b1000;
-	/**
-	 * With this constant for the acknowledge field no responses are expected.
-	 */
-	static const uint8_t ACK_NONE = 0b000;
+	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) +
+	        sizeof(PUSTcDataFieldHeader) + 2);
+
+	enum AckField {
+		//! No acknowledgements are expected.
+		ACK_NONE = 0b0000,
+		//! Acknowledgements on acceptance are expected.
+		ACK_ACCEPTANCE = 0b0001,
+		//! Acknowledgements on start are expected.
+		ACK_START = 0b0010,
+		//! Acknowledgements on step are expected.
+		ACK_STEP = 0b0100,
+		//! Acknowledfgement on completion are expected.
+		ACK_COMPLETION = 0b1000
+	};
+
+	static constexpr uint8_t ACK_ALL = ACK_ACCEPTANCE | ACK_START | ACK_STEP |
+			ACK_COMPLETION;
+
 	/**
 	 * This is the default constructor.
 	 * It sets its internal data pointer to the address passed and also
 	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
+	 * @param setData	The position where the packet data lies.
 	 */
-	TcPacketBase( const uint8_t* set_data );
+	TcPacketBase( const uint8_t* setData );
 	/**
 	 * This is the empty default destructor.
 	 */
 	virtual ~TcPacketBase();
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param sequenceCount Sequence Count in the primary header.
-	 * @param ack Which acknowledeges are expected from the receiver.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 */
-	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
-			uint8_t service, uint8_t subservice);
+
 	/**
 	 * This command returns the CCSDS Secondary Header Flag.
 	 * It shall always be zero for PUS Packets. This is the
@@ -169,24 +140,6 @@ public:
 	 */
 	void setErrorControl();
 
-	/**
-	 * Copies the supplied data to the internal TC application data field.
-	 * @param pData
-	 * @param dataLen
-	 */
-	void setAppData(uint8_t * appData, uint16_t dataLen);
-
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telecommand Packet.
-	 */
-	void setData( const uint8_t* pData );
-
 	/**
 	 * This is a debugging helper method that prints the whole packet content
 	 * to the screen.
@@ -198,7 +151,37 @@ public:
 	 * @return
 	 */
 	static size_t calculateFullPacketLength(size_t appDataLen);
+
+protected:
+    /**
+     * A pointer to a structure which defines the data structure of
+     * the packet's data.
+     *
+     * To be hardware-safe, all elements are of byte size.
+     */
+    TcPacketPointer* tcData;
+
+    /**
+     * Initializes the Tc Packet header.
+     * @param apid APID used.
+     * @param sequenceCount Sequence Count in the primary header.
+     * @param ack Which acknowledeges are expected from the receiver.
+     * @param service   PUS Service
+     * @param subservice PUS Subservice
+     */
+    void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
+            uint8_t service, uint8_t subservice);
+
+    /**
+     * With this method, the packet data pointer can be redirected to another
+     * location.
+     * This call overwrites the parent's setData method to set both its
+     * @c tc_data pointer and the parent's @c data pointer.
+     *
+     * @param p_data    A pointer to another PUS Telecommand Packet.
+     */
+    void setData( const uint8_t* pData );
 };
 
 
-#endif /* TCPACKETBASE_H_ */
+#endif /* TMTCPACKET_PUS_TCPACKETBASE_H_ */
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index d34745691..fffc86ae9 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -1,32 +1,34 @@
+#include "TcPacketStored.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TcPacketStored.h"
 
 #include <cstring>
 
+StorageManagerIF* TcPacketStored::store = nullptr;
+
 TcPacketStored::TcPacketStored(store_address_t setAddress) :
 		TcPacketBase(nullptr), storeAddress(setAddress) {
-	this->setStoreAddress(this->storeAddress);
+	setStoreAddress(storeAddress);
 }
 
-TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
-		uint16_t apid, uint8_t sequence_count, const uint8_t* data,
-		size_t size, uint8_t ack ) :
+TcPacketStored::TcPacketStored(uint16_t apid,  uint8_t service,
+        uint8_t subservice, uint8_t sequenceCount, const uint8_t* data,
+		size_t size, uint8_t ack) :
 		TcPacketBase(nullptr) {
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!this->checkAndSetStore()) {
+	if (not this->checkAndSetStore()) {
 		return;
 	}
-	uint8_t* p_data = nullptr;
+	uint8_t* pData = nullptr;
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
-			(TC_PACKET_MIN_SIZE + size), &p_data);
-	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
-		sif::warning << "TcPacketStored::TcPacketStored: Could not get "
-				"free element from store!" << std::endl;
+			(TC_PACKET_MIN_SIZE + size), &pData);
+	if (returnValue != this->store->RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get free element from store!"
+				<< std::endl;
 		return;
 	}
-	this->setData(p_data);
-	initializeTcPacket(apid, sequence_count, ack, service, subservice);
+	this->setData(pData);
+	initializeTcPacket(apid, sequenceCount, ack, service, subservice);
 	memcpy(&tcData->appData, data, size);
 	this->setPacketDataLength(
 			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
@@ -42,8 +44,7 @@ ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
 	return result;
 }
 
-TcPacketStored::TcPacketStored() :
-		TcPacketBase(NULL) {
+TcPacketStored::TcPacketStored(): TcPacketBase(nullptr) {
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	this->checkAndSetStore();
 
@@ -52,7 +53,7 @@ TcPacketStored::TcPacketStored() :
 ReturnValue_t TcPacketStored::deletePacket() {
 	ReturnValue_t result = this->store->deleteData(this->storeAddress);
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	this->setData( NULL);
+	this->setData(nullptr);
 	return result;
 }
 
@@ -70,17 +71,17 @@ bool TcPacketStored::checkAndSetStore() {
 
 void TcPacketStored::setStoreAddress(store_address_t setAddress) {
 	this->storeAddress = setAddress;
-	const uint8_t* temp_data = NULL;
+	const uint8_t* tempData = nullptr;
 	size_t temp_size;
 	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
 	if (this->checkAndSetStore()) {
-		status = this->store->getData(this->storeAddress, &temp_data,
+		status = this->store->getData(this->storeAddress, &tempData,
 				&temp_size);
 	}
 	if (status == StorageManagerIF::RETURN_OK) {
-		this->setData(temp_data);
+		this->setData(tempData);
 	} else {
-		this->setData(NULL);
+		this->setData(nullptr);
 		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	}
 }
@@ -90,7 +91,7 @@ store_address_t TcPacketStored::getStoreAddress() {
 }
 
 bool TcPacketStored::isSizeCorrect() {
-	const uint8_t* temp_data = NULL;
+	const uint8_t* temp_data = nullptr;
 	size_t temp_size;
 	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
 			&temp_size);
@@ -102,8 +103,6 @@ bool TcPacketStored::isSizeCorrect() {
 	return false;
 }
 
-StorageManagerIF* TcPacketStored::store = NULL;
-
 TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
 		TcPacketBase(data) {
 	if (getFullSize() != size) {
@@ -112,7 +111,7 @@ TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
 	if (this->checkAndSetStore()) {
 		ReturnValue_t status = store->addData(&storeAddress, data, size);
 		if (status != HasReturnvaluesIF::RETURN_OK) {
-			this->setData(NULL);
+			this->setData(nullptr);
 		}
 	}
 }
diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h
index c81b71b77..1666107b7 100644
--- a/tmtcpacket/pus/TcPacketStored.h
+++ b/tmtcpacket/pus/TcPacketStored.h
@@ -1,8 +1,8 @@
-#ifndef TCPACKETSTORED_H_
-#define TCPACKETSTORED_H_
+#ifndef TMTCPACKET_PUS_TCPACKETSTORED_H_
+#define TMTCPACKET_PUS_TCPACKETSTORED_H_
 
+#include "TcPacketBase.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../tmtcpacket/pus/TcPacketBase.h"
 
 /**
  *	This class generates a ECSS PUS Telecommand packet within a given
@@ -15,26 +15,6 @@
  *	@ingroup tmtcpackets
  */
 class TcPacketStored : public TcPacketBase {
-private:
-	/**
-	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
-	 * call tries to set it and throws an error message in case of failures.
-	 * The default store is objects::TC_STORE.
-	 */
-	static StorageManagerIF* store;
-	/**
-	 * The address where the packet data of the object instance is stored.
-	 */
-	store_address_t storeAddress;
-	/**
-	 * A helper method to check if a store is assigned to the class.
-	 * If not, the method tries to retrieve the store from the global
-	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
-	 */
-	bool checkAndSetStore();
 public:
 	/**
 	 * This is a default constructor which does not set the data pointer.
@@ -53,20 +33,20 @@ public:
 	 * a new PUS Telecommand Packet is created there.
 	 * Packet Application Data passed in data is copied into the packet.
 	 * @param apid			Sets the packet's APID field.
-	 * @param ack			Set's the packet's Ack field,
-	 * 		which specifies number and size of verification packets returned
-	 * 		for this command.
 	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the destination service.
+	 *                      This specifies the destination service.
 	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the destination sub-service.
-	 * @param sequence_count	Sets the packet's Source Sequence Count field.
+	 * 		                This specifies the destination sub-service.
+	 * @param sequence_count Sets the packet's Source Sequence Count field.
 	 * @param data		The data to be copied to the Application Data Field.
 	 * @param size		The amount of data to be copied.
+	 * @param ack           Set's the packet's Ack field, which specifies
+	 *                      number of verification packets returned
+     *                      for this command.
 	 */
-	TcPacketStored( uint8_t service, uint8_t subservice, uint16_t apid,
+	TcPacketStored(uint16_t apid, uint8_t service, uint8_t subservice,
 			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
-			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL );
+			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL);
 	/**
 	 * Another constructor to create a TcPacket from a raw packet stream.
 	 * Takes the data and adds it unchecked to the TcStore.
@@ -75,12 +55,18 @@ public:
 	 */
 	TcPacketStored( const uint8_t* data, uint32_t size);
 
+	/**
+	 * Getter function for the raw data.
+	 * @param dataPtr [out] Pointer to the data pointer to set
+	 * @param dataSize [out] Address of size to set.
+	 * @return -@c RETURN_OK if data was retrieved successfully.
+	 */
 	ReturnValue_t getData(const uint8_t ** dataPtr,
 			size_t* dataSize);
 	/**
 	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
+	 * @return	The current store address. The (raw) value is
+	 * 			@c StorageManagerIF::INVALID_ADDRESS if the packet is not linked.
 	 */
 	store_address_t getStoreAddress();
 	/**
@@ -104,7 +90,28 @@ public:
 	 * 			store or size is incorrect.
 	 */
 	bool isSizeCorrect();
+
+private:
+    /**
+     * This is a pointer to the store all instances of the class use.
+     * If the store is not yet set (i.e. @c store is NULL), every constructor
+     * call tries to set it and throws an error message in case of failures.
+     * The default store is objects::TC_STORE.
+     */
+    static StorageManagerIF* store;
+    /**
+     * The address where the packet data of the object instance is stored.
+     */
+    store_address_t storeAddress;
+    /**
+     * A helper method to check if a store is assigned to the class.
+     * If not, the method tries to retrieve the store from the global
+     * ObjectManager.
+     * @return  @li @c true if the store is linked or could be created.
+     *          @li @c false otherwise.
+     */
+    bool checkAndSetStore();
 };
 
 
-#endif /* TCPACKETSTORED_H_ */
+#endif /* TMTCPACKET_PUS_TCPACKETSTORED_H_ */
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index 66d67600b..f3bc3f001 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -1,13 +1,19 @@
+#include "TmPacketBase.h"
+
 #include "../../globalfunctions/CRC.h"
+#include "../../globalfunctions/arrayprinter.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TmPacketBase.h"
 #include "../../timemanager/CCSDSTime.h"
-#include <string.h>
 
-TmPacketBase::TmPacketBase(uint8_t* set_data) :
-		SpacePacketBase(set_data) {
-	tm_data = (TmPacketPointer*) set_data;
+#include <cstring>
+
+TimeStamperIF* TmPacketBase::timeStamper = nullptr;
+object_id_t TmPacketBase::timeStamperId = 0;
+
+TmPacketBase::TmPacketBase(uint8_t* setData) :
+		SpacePacketBase(setData) {
+	tmData = reinterpret_cast<TmPacketPointer*>(setData);
 }
 
 TmPacketBase::~TmPacketBase() {
@@ -15,25 +21,25 @@ TmPacketBase::~TmPacketBase() {
 }
 
 uint8_t TmPacketBase::getService() {
-	return tm_data->data_field.service_type;
+	return tmData->data_field.service_type;
 }
 
 uint8_t TmPacketBase::getSubService() {
-	return tm_data->data_field.service_subtype;
+	return tmData->data_field.service_subtype;
 }
 
 uint8_t* TmPacketBase::getSourceData() {
-	return &tm_data->data;
+	return &tmData->data;
 }
 
 uint16_t TmPacketBase::getSourceDataSize() {
-	return getPacketDataLength() - sizeof(tm_data->data_field)
+	return getPacketDataLength() - sizeof(tmData->data_field)
 			- CRC_SIZE + 1;
 }
 
 uint16_t TmPacketBase::getErrorControl() {
 	uint32_t size = getSourceDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tm_data->data;
+	uint8_t* p_to_buffer = &tmData->data;
 	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
 }
 
@@ -47,16 +53,12 @@ void TmPacketBase::setErrorControl() {
 
 void TmPacketBase::setData(const uint8_t* p_Data) {
 	SpacePacketBase::setData(p_Data);
-	tm_data = (TmPacketPointer*) p_Data;
+	tmData = (TmPacketPointer*) p_Data;
 }
 
 void TmPacketBase::print() {
-	/*uint8_t * wholeData = getWholeData();
-	 debug << "TmPacket contains: " << std::endl;
-	 for (uint8_t count = 0; count < getFullSize(); ++count ) {
-	 debug << std::hex << (uint16_t)wholeData[count] << " ";
-	 }
-	 debug << std::dec << std::endl;*/
+	 sif::debug << "TmPacketBase::print: " << std::endl;
+	 arrayprinter::print(getWholeData(), getFullSize());
 }
 
 bool TmPacketBase::checkAndSetStamper() {
@@ -73,47 +75,43 @@ bool TmPacketBase::checkAndSetStamper() {
 
 ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
 	uint32_t tempSize = 0;
-	return CCSDSTime::convertFromCcsds(timestamp, tm_data->data_field.time,
-			&tempSize, sizeof(tm_data->data_field.time));
+	return CCSDSTime::convertFromCcsds(timestamp, tmData->data_field.time,
+			&tempSize, sizeof(tmData->data_field.time));
 }
 
 uint8_t* TmPacketBase::getPacketTimeRaw() const{
-	return tm_data->data_field.time;
+	return tmData->data_field.time;
 
 }
 
-void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter) {
+void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service,
+        uint8_t subservice, uint8_t packetSubcounter) {
 	//Set primary header:
 	initSpacePacketHeader(false, true, apid);
 	//Set data Field Header:
 	//First, set to zero.
-	memset(&tm_data->data_field, 0, sizeof(tm_data->data_field));
-	//Set CCSDS_secondary header flag to 0, version number to 001 and ack to 0000
+	memset(&tmData->data_field, 0, sizeof(tmData->data_field));
+
 	// NOTE: In PUS-C, the PUS Version is 2 and specified for the first 4 bits.
-	// The other 4 bits of the first byte are the spacecraft time reference status
-	// To change to PUS-C, set 0b00100000
-	tm_data->data_field.version_type_ack = 0b00010000;
-	tm_data->data_field.service_type = service;
-	tm_data->data_field.service_subtype = subservice;
-	tm_data->data_field.subcounter = packetSubcounter;
+	// The other 4 bits of the first byte are the spacecraft time reference
+	// status. To change to PUS-C, set 0b00100000.
+    // Set CCSDS_secondary header flag to 0, version number to 001 and ack
+    // to 0000
+	tmData->data_field.version_type_ack = 0b00010000;
+	tmData->data_field.service_type = service;
+	tmData->data_field.service_subtype = subservice;
+	tmData->data_field.subcounter = packetSubcounter;
 	//Timestamp packet
 	if (checkAndSetStamper()) {
-		timeStamper->addTimeStamp(tm_data->data_field.time, sizeof(tm_data->data_field.time));
+		timeStamper->addTimeStamp(tmData->data_field.time,
+		        sizeof(tmData->data_field.time));
 	}
 }
 
-void TmPacketBase::setSourceData(uint8_t* sourceData, size_t sourceSize) {
-	memcpy(getSourceData(), sourceData, sourceSize);
-	setSourceDataSize(sourceSize);
-}
-
 void TmPacketBase::setSourceDataSize(uint16_t size) {
 	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
 }
 
-uint32_t TmPacketBase::getTimestampSize() const {
-	return sizeof(tm_data->data_field.time);
+size_t TmPacketBase::getTimestampSize() const {
+	return sizeof(tmData->data_field.time);
 }
-
-TimeStamperIF* TmPacketBase::timeStamper = NULL;
-object_id_t TmPacketBase::timeStamperId = 0;
diff --git a/tmtcpacket/pus/TmPacketBase.h b/tmtcpacket/pus/TmPacketBase.h
index 96dbd5c63..6efc01658 100644
--- a/tmtcpacket/pus/TmPacketBase.h
+++ b/tmtcpacket/pus/TmPacketBase.h
@@ -1,8 +1,8 @@
-#ifndef TMPACKETBASE_H_
-#define TMPACKETBASE_H_
+#ifndef TMTCPACKET_PUS_TMPACKETBASE_H_
+#define TMTCPACKET_PUS_TMPACKETBASE_H_
 
+#include "../SpacePacketBase.h"
 #include "../../timemanager/TimeStamperIF.h"
-#include "../../tmtcpacket/SpacePacketBase.h"
 #include "../../timemanager/Clock.h"
 #include "../../objectmanager/SystemObjectIF.h"
 
@@ -14,7 +14,7 @@ void setStaticFrameworkObjectIds();
  * This struct defines a byte-wise structured PUS TM Data Field Header.
  * Any optional fields in the header must be added or removed here.
  * Currently, no Destination field is present, but an eigth-byte representation
- * for a time tag [TBD].
+ * for a time tag.
  * @ingroup tmtcpackets
  */
 struct PUSTmDataFieldHeader {
@@ -40,7 +40,7 @@ struct TmPacketPointer {
 /**
  * This class is the basic data handler for any ECSS PUS Telemetry packet.
  *
- * In addition to \SpacePacketBase, the class provides methods to handle
+ * In addition to #SpacePacketBase, the class provides methods to handle
  * the standardized entries of the PUS TM Packet Data Field Header.
  * It does not contain the packet data itself but a pointer to the
  * data must be set on instantiation. An invalid pointer may cause
@@ -54,29 +54,27 @@ public:
 	/**
 	 * This constant defines the minimum size of a valid PUS Telemetry Packet.
 	 */
-	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTmDataFieldHeader) + 2); //!< Minimum size of a valid PUS Telemetry Packet.
-	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048; //!< Maximum size of a TM Packet in this mission.
-	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000; //!< First byte of secondary header for PUS-A packets.
+	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) +
+	        sizeof(PUSTmDataFieldHeader) + 2);
+	//! Maximum size of a TM Packet in this mission.
+	//! TODO: Make this dependant on a config variable.
+	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048;
+	//! First byte of secondary header for PUS-A packets.
+	//! TODO: Maybe also support PUS-C via config?
+	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000;
+
 	/**
 	 * This is the default constructor.
 	 * It sets its internal data pointer to the address passed and also
 	 * forwards the data pointer to the parent SpacePacketBase class.
 	 * @param set_address	The position where the packet data lies.
 	 */
-	TmPacketBase( uint8_t* set_data );
+	TmPacketBase( uint8_t* setData );
 	/**
 	 * This is the empty default destructor.
 	 */
 	virtual ~TmPacketBase();
-	/**
-	 * Initializes the Tm Packet header.
-	 * Does set the timestamp (to now), but not the error control field.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter);
+
 	/**
 	 * This is a getter for the packet's PUS Service ID, which is the second
 	 * byte of the Data Field Header.
@@ -106,11 +104,14 @@ public:
 	 */
 	uint16_t getSourceDataSize();
 
-	/**
-	 * In case data was filled manually (almost never the case).
-	 * @param size Size of source data (without CRC and data filed header!).
-	 */
-	void setSourceDataSize(uint16_t size);
+    /**
+     * With this method, the Error Control Field is updated to match the
+     * current content of the packet. This method is not protected because
+     * a recalculation by the user might be necessary when manipulating fields
+     * like the sequence count.
+     */
+    void setErrorControl();
+
 	/**
 	 * This getter returns the Error Control Field of the packet.
 	 *
@@ -120,35 +121,15 @@ public:
 	 * @return	The PUS Error Control
 	 */
 	uint16_t getErrorControl();
-	/**
-	 * With this method, the Error Control Field is updated to match the
-	 * current content of the packet.
-	 */
-	void setErrorControl();
-	/**
-	 * This sets the source data. It copies the provided data to
-	 * the internal TmPacketPointer source data location.
-	 * @param sourceData
-	 * @param sourceSize
-	 */
-	void setSourceData(uint8_t* sourceData, size_t sourceSize);
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telemetry Packet.
-	 */
-	void setData( const uint8_t* p_Data );
+
 	/**
 	 * This is a debugging helper method that prints the whole packet content
 	 * to the screen.
 	 */
 	void print();
 	/**
-	 * Interprets the "time"-field in the secondary header and returns it in timeval format.
+	 * Interprets the "time"-field in the secondary header and returns it in
+	 * timeval format.
 	 * @return Converted timestamp of packet.
 	 */
 	ReturnValue_t getPacketTime(timeval* timestamp) const;
@@ -158,7 +139,7 @@ public:
 	 */
 	uint8_t* getPacketTimeRaw() const;
 
-	uint32_t getTimestampSize() const;
+	size_t getTimestampSize() const;
 
 protected:
 	/**
@@ -167,20 +148,49 @@ protected:
 	 *
 	 * To be hardware-safe, all elements are of byte size.
 	 */
-	TmPacketPointer* tm_data;
+	TmPacketPointer* tmData;
 	/**
 	 * The timeStamper is responsible for adding a timestamp to the packet.
 	 * It is initialized lazy.
 	 */
 	static TimeStamperIF* timeStamper;
+	//! The ID to use when looking for a time stamper.
+	static object_id_t timeStamperId;
 
-	static object_id_t timeStamperId; //!< The ID to use when looking for a time stamper.
-	/**
-	 * Checks if a time stamper is available and tries to set it if not.
-	 * @return Returns false if setting failed.
-	 */
-	bool checkAndSetStamper();
+    /**
+     * Initializes the Tm Packet header.
+     * Does set the timestamp (to now), but not the error control field.
+     * @param apid APID used.
+     * @param service   PUS Service
+     * @param subservice PUS Subservice
+     * @param packetSubcounter Additional subcounter used.
+     */
+    void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice,
+            uint8_t packetSubcounter);
+
+    /**
+     * With this method, the packet data pointer can be redirected to another
+     * location.
+     *
+     * This call overwrites the parent's setData method to set both its
+     * @c tc_data pointer and the parent's @c data pointer.
+     *
+     * @param p_data    A pointer to another PUS Telemetry Packet.
+     */
+    void setData( const uint8_t* pData );
+
+    /**
+     * In case data was filled manually (almost never the case).
+     * @param size Size of source data (without CRC and data filed header!).
+     */
+    void setSourceDataSize(uint16_t size);
+
+    /**
+     * Checks if a time stamper is available and tries to set it if not.
+     * @return Returns false if setting failed.
+     */
+    bool checkAndSetStamper();
 };
 
 
-#endif /* TMPACKETBASE_H_ */
+#endif /* TMTCPACKET_PUS_TMPACKETBASE_H_ */
diff --git a/tmtcpacket/pus/TmPacketMinimal.cpp b/tmtcpacket/pus/TmPacketMinimal.cpp
index c7c495ae3..18e9dda1e 100644
--- a/tmtcpacket/pus/TmPacketMinimal.cpp
+++ b/tmtcpacket/pus/TmPacketMinimal.cpp
@@ -1,7 +1,7 @@
-#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+#include "TmPacketMinimal.h"
 #include <stddef.h>
 #include <time.h>
-#include "../../tmtcpacket/pus/PacketTimestampInterpreterIF.h"
+#include "PacketTimestampInterpreterIF.h"
 
 TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketBase( set_data ) {
 	this->tm_data = (TmPacketMinimalPointer*)set_data;

From d1a399a1a8c55a83a932cd326fea87141ddf9d44 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 19:46:27 +0100
Subject: [PATCH 0949/1774] tm packet store update

---
 tmtcpacket/pus/TmPacketStored.cpp |  46 ++++++-----
 tmtcpacket/pus/TmPacketStored.h   | 123 +++++++++++++++---------------
 2 files changed, 84 insertions(+), 85 deletions(-)

diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 4cf76589b..0fb789aa3 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -3,28 +3,30 @@
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../tmtcservices/TmTcMessage.h"
+
 #include <cstring>
 
+StorageManagerIF *TmPacketStored::store = nullptr;
+InternalErrorReporterIF *TmPacketStored::internalErrorReporter = nullptr;
+
 TmPacketStored::TmPacketStored(store_address_t setAddress) :
-		TmPacketBase(NULL), storeAddress(setAddress) {
+		TmPacketBase(nullptr), storeAddress(setAddress) {
 	setStoreAddress(storeAddress);
 }
 
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
-		size_t size, const uint8_t *headerData, size_t headerSize) :
+		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
+	if (not checkAndSetStore()) {
 		return;
 	}
-	uint8_t *pData = NULL;
+	uint8_t *pData = nullptr;
 	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
 
-	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "TmPacketStored::TmPacketStored: "
-				"Issue getting free storage" << std::endl;
+	if (returnValue != store->RETURN_OK) {
 		checkAndReportLostTm();
 		return;
 	}
@@ -36,13 +38,12 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
 }
 
-// todo: Endianness flags as optional parameter?
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
 		SerializeIF *header) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
+	if (not checkAndSetStore()) {
 		return;
 	}
 	size_t sourceDataSize = 0;
@@ -81,29 +82,29 @@ store_address_t TmPacketStored::getStoreAddress() {
 void TmPacketStored::deletePacket() {
 	store->deleteData(storeAddress);
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	setData(NULL);
+	setData(nullptr);
 }
 
 void TmPacketStored::setStoreAddress(store_address_t setAddress) {
 	storeAddress = setAddress;
-	const uint8_t *temp_data = NULL;
-	size_t temp_size;
-	if (!checkAndSetStore()) {
+	const uint8_t* tempData = nullptr;
+	size_t tempSize;
+	if (not checkAndSetStore()) {
 		return;
 	}
-	ReturnValue_t status = store->getData(storeAddress, &temp_data, &temp_size);
+	ReturnValue_t status = store->getData(storeAddress, &tempData, &tempSize);
 	if (status == StorageManagerIF::RETURN_OK) {
-		setData(temp_data);
+		setData(tempData);
 	} else {
-		setData(NULL);
+		setData(nullptr);
 		storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	}
 }
 
 bool TmPacketStored::checkAndSetStore() {
-	if (store == NULL) {
+	if (store == nullptr) {
 		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
-		if (store == NULL) {
+		if (store == nullptr) {
 			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
 					<< std::endl;
 			return false;
@@ -112,12 +113,9 @@ bool TmPacketStored::checkAndSetStore() {
 	return true;
 }
 
-StorageManagerIF *TmPacketStored::store = NULL;
-InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
-
 ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 		MessageQueueId_t sentFrom, bool doErrorReporting) {
-	if (getWholeData() == NULL) {
+	if (getWholeData() == nullptr) {
 		//SHOULDDO: More decent code.
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -137,11 +135,11 @@ ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 }
 
 void TmPacketStored::checkAndReportLostTm() {
-	if (internalErrorReporter == NULL) {
+	if (internalErrorReporter == nullptr) {
 		internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
 				objects::INTERNAL_ERROR_REPORTER);
 	}
-	if (internalErrorReporter != NULL) {
+	if (internalErrorReporter != nullptr) {
 		internalErrorReporter->lostTm();
 	}
 }
diff --git a/tmtcpacket/pus/TmPacketStored.h b/tmtcpacket/pus/TmPacketStored.h
index 81a6f6e5d..b231407d0 100644
--- a/tmtcpacket/pus/TmPacketStored.h
+++ b/tmtcpacket/pus/TmPacketStored.h
@@ -1,7 +1,8 @@
-#ifndef FSFW_TMTCPACKET_TMPACKETSTORED_H_
-#define FSFW_TMTCPACKET_TMPACKETSTORED_H_
+#ifndef FSFW_TMTCPACKET_PUS_TMPACKETSTORED_H_
+#define FSFW_TMTCPACKET_PUS_TMPACKETSTORED_H_
 
 #include "TmPacketBase.h"
+
 #include "../../serialize/SerializeIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
 #include "../../internalError/InternalErrorReporterIF.h"
@@ -18,6 +19,64 @@
  *	@ingroup tmtcpackets
  */
 class TmPacketStored : public TmPacketBase {
+public:
+	/**
+	 * This is a default constructor which does not set the data pointer.
+	 * However, it does try to set the packet store.
+	 */
+	TmPacketStored( store_address_t setAddress );
+	/**
+	 * With this constructor, new space is allocated in the packet store and
+	 * a new PUS Telemetry Packet is created there.
+	 * Packet Application Data passed in data is copied into the packet.
+	 * The Application data is passed in two parts, first a header, then a
+	 * data field. This allows building a Telemetry Packet from two separate
+	 * data sources.
+	 * @param apid			Sets the packet's APID field.
+	 * @param service		Sets the packet's Service ID field.
+	 * 		This specifies the source service.
+	 * @param subservice	Sets the packet's Service Subtype field.
+	 * 		This specifies the source sub-service.
+	 * @param packet_counter	Sets the Packet counter field of this packet
+	 * @param data			The payload data to be copied to the
+	 * 						Application Data Field
+	 * @param size			The amount of data to be copied.
+	 * @param headerData 	The header Data of the Application field,
+	 * 						 will be copied in front of data
+	 * @param headerSize	The size of the headerDataF
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice,
+			uint8_t packet_counter = 0, const uint8_t* data = nullptr,
+			uint32_t size = 0, const uint8_t* headerData = nullptr,
+			uint32_t headerSize = 0);
+	/**
+	 * Another ctor to directly pass structured content and header data to the
+	 * packet to avoid additional buffers.
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice,
+			uint8_t packet_counter, SerializeIF* content,
+			SerializeIF* header = nullptr);
+	/**
+	 * This is a getter for the current store address of the packet.
+	 * @return	The current store address. The (raw) value is
+	 * 			@c StorageManagerIF::INVALID_ADDRESS if
+	 * 			the packet is not linked.
+	 */
+	store_address_t getStoreAddress();
+	/**
+	 * With this call, the packet is deleted.
+	 * It removes itself from the store and sets its data pointer to NULL.
+	 */
+	void deletePacket();
+	/**
+	 * With this call, a packet can be linked to another store. This is useful
+	 * if the packet is a class member and used for more than one packet.
+	 * @param setAddress	The new packet id to link to.
+	 */
+	void setStoreAddress( store_address_t setAddress );
+
+	ReturnValue_t sendPacket( MessageQueueId_t destination,
+			MessageQueueId_t sentFrom, bool doErrorReporting = true );
 private:
 	/**
 	 * This is a pointer to the store all instances of the class use.
@@ -43,65 +102,7 @@ private:
 	bool checkAndSetStore();
 
 	void checkAndReportLostTm();
-public:
-	/**
-	 * This is a default constructor which does not set the data pointer.
-	 * However, it does try to set the packet store.
-	 */
-	TmPacketStored( store_address_t setAddress );
-	/**
-	 * With this constructor, new space is allocated in the packet store and
-	 * a new PUS Telemetry Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet.
-	 * The Application data is passed in two parts, first a header, then a
-	 * data field. This allows building a Telemetry
-	 * Packet from two separate data sources.
-	 * @param apid			Sets the packet's APID field.
-	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the source service.
-	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the source sub-service.
-	 * @param packet_counter	Sets the Packet counter field of this packet
-	 * @param data			The payload data to be copied to the Application
-	 * 						Data Field
-	 * @param size			The amount of data to be copied.
-	 * @param headerData 	The header Data of the Application field; will be
-	 * 						copied in front of data
-	 * @param headerSize	The size of the headerDataF
-	 */
-	TmPacketStored(uint16_t apid, uint8_t service,	uint8_t subservice,
-			uint8_t packet_counter = 0, const uint8_t* data = nullptr,
-			size_t size = 0, const uint8_t* headerData = nullptr,
-			size_t headerSize = 0);
-	/**
-	 * Another ctor to directly pass structured content and header data to the
-	 * packet to avoid additional buffers.
-	 */
-	TmPacketStored(uint16_t apid, uint8_t service,	uint8_t subservice,
-			uint8_t packet_counter, SerializeIF* content,
-			SerializeIF* header = nullptr);
-	/**
-	 * This is a getter for the current store address of the packet.
-	 * @return
-	 * The current store address. The (raw) value is
-	 * @c StorageManagerIF::INVALID_ADDRESS if the packet is not linked.
-	 */
-	store_address_t getStoreAddress();
-	/**
-	 * With this call, the packet is deleted.
-	 * It removes itself from the store and sets its data pointer to NULL.
-	 */
-	void deletePacket();
-	/**
-	 * With this call, a packet can be linked to another store. This is useful
-	 * if the packet is a class member and used for more than one packet.
-	 * @param setAddress	The new packet id to link to.
-	 */
-	void setStoreAddress(store_address_t setAddress);
-
-	ReturnValue_t sendPacket(MessageQueueId_t destination,
-			MessageQueueId_t sentFrom, bool doErrorReporting = true);
 };
 
 
-#endif /* FSFW_TMTCPACKET_TMPACKETSTORED_H_ */
+#endif /* FSFW_TMTCPACKET_PUS_TMPACKETSTORED_H_ */

From dcb24360d85b94a8124e697c3b5640c8dc220dd1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 20:17:50 +0100
Subject: [PATCH 0950/1774] form improvements taken over

---
 tmtcpacket/SpacePacketBase.cpp |  4 ++--
 tmtcpacket/SpacePacketBase.h   | 11 ++++++-----
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/tmtcpacket/SpacePacketBase.cpp b/tmtcpacket/SpacePacketBase.cpp
index 044ce510d..e13af8d06 100644
--- a/tmtcpacket/SpacePacketBase.cpp
+++ b/tmtcpacket/SpacePacketBase.cpp
@@ -1,6 +1,6 @@
+#include "SpacePacketBase.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tmtcpacket/SpacePacketBase.h"
-#include <string.h>
+#include <cstring>
 
 SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) {
 	this->data = (SpacePacketPointer*) set_address;
diff --git a/tmtcpacket/SpacePacketBase.h b/tmtcpacket/SpacePacketBase.h
index c7a63ae68..19cbd0741 100644
--- a/tmtcpacket/SpacePacketBase.h
+++ b/tmtcpacket/SpacePacketBase.h
@@ -1,7 +1,7 @@
-#ifndef SPACEPACKETBASE_H_
-#define SPACEPACKETBASE_H_
+#ifndef FSFW_TMTCPACKET_SPACEPACKETBASE_H_
+#define FSFW_TMTCPACKET_SPACEPACKETBASE_H_
 
-#include "../tmtcpacket/ccsds_header.h"
+#include "ccsds_header.h"
 #include <cstddef>
 
 /**
@@ -82,7 +82,8 @@ public:
 	 */
 	bool isTelecommand( void );
 
-	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount = 0);
+	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader,
+	        uint16_t apid, uint16_t sequenceCount = 0);
 	/**
 	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
 	 *  which is checked with this method.
@@ -174,4 +175,4 @@ public:
 
 };
 
-#endif /* SPACEPACKETBASE_H_ */
+#endif /* FSFW_TMTCPACKET_SPACEPACKETBASE_H_ */

From 3244487eaec76a8cf014d35df062daacc24edf41 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 20:18:58 +0100
Subject: [PATCH 0951/1774] slight improvements

---
 tmtcpacket/SpacePacket.cpp | 4 ++--
 tmtcpacket/SpacePacket.h   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tmtcpacket/SpacePacket.cpp b/tmtcpacket/SpacePacket.cpp
index 2bf6e3dcd..b8ba27e9a 100644
--- a/tmtcpacket/SpacePacket.cpp
+++ b/tmtcpacket/SpacePacket.cpp
@@ -1,6 +1,6 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tmtcpacket/ccsds_header.h"
-#include "../tmtcpacket/SpacePacket.h"
+#include "ccsds_header.h"
+#include "SpacePacket.h"
 #include <string.h>
 
 SpacePacket::SpacePacket( uint16_t packetDataLength, bool isTelecommand, uint16_t apid, uint16_t sequenceCount ):
diff --git a/tmtcpacket/SpacePacket.h b/tmtcpacket/SpacePacket.h
index ea1d0468a..49dd5ae52 100644
--- a/tmtcpacket/SpacePacket.h
+++ b/tmtcpacket/SpacePacket.h
@@ -1,7 +1,7 @@
 #ifndef SPACEPACKET_H_
 #define SPACEPACKET_H_
 
-#include "../tmtcpacket/SpacePacketBase.h"
+#include "SpacePacketBase.h"
 
 /**
  * The SpacePacket class is a representation of a simple CCSDS Space Packet

From ea04e7d4d644c7c50faf862902fceafb8490d994 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 21:13:00 +0100
Subject: [PATCH 0952/1774] removed catch2

---
 unittest/catch2/LICENSE.txt                  |    23 -
 unittest/catch2/catch.hpp                    | 17618 -----------------
 unittest/catch2/catch_reporter_automake.hpp  |    62 -
 unittest/catch2/catch_reporter_sonarqube.hpp |   181 -
 unittest/catch2/catch_reporter_tap.hpp       |   253 -
 unittest/catch2/catch_reporter_teamcity.hpp  |   219 -
 6 files changed, 18356 deletions(-)
 delete mode 100644 unittest/catch2/LICENSE.txt
 delete mode 100644 unittest/catch2/catch.hpp
 delete mode 100644 unittest/catch2/catch_reporter_automake.hpp
 delete mode 100644 unittest/catch2/catch_reporter_sonarqube.hpp
 delete mode 100644 unittest/catch2/catch_reporter_tap.hpp
 delete mode 100644 unittest/catch2/catch_reporter_teamcity.hpp

diff --git a/unittest/catch2/LICENSE.txt b/unittest/catch2/LICENSE.txt
deleted file mode 100644
index 36b7cd93c..000000000
--- a/unittest/catch2/LICENSE.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/unittest/catch2/catch.hpp b/unittest/catch2/catch.hpp
deleted file mode 100644
index 51618b38e..000000000
--- a/unittest/catch2/catch.hpp
+++ /dev/null
@@ -1,17618 +0,0 @@
-/*
- *  Catch v2.11.3
- *  Generated: 2020-03-19 13:44:21.042491
- *  ----------------------------------------------------------
- *  This file has been merged from multiple headers. Please don't edit it directly
- *  Copyright (c) 2020 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-// start catch.hpp
-
-
-#define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 11
-#define CATCH_VERSION_PATCH 3
-
-#ifdef __clang__
-#    pragma clang system_header
-#elif defined __GNUC__
-#    pragma GCC system_header
-#endif
-
-// start catch_suppress_warnings.h
-
-#ifdef __clang__
-#   ifdef __ICC // icpc defines the __clang__ macro
-#       pragma warning(push)
-#       pragma warning(disable: 161 1682)
-#   else // __ICC
-#       pragma clang diagnostic push
-#       pragma clang diagnostic ignored "-Wpadded"
-#       pragma clang diagnostic ignored "-Wswitch-enum"
-#       pragma clang diagnostic ignored "-Wcovered-switch-default"
-#    endif
-#elif defined __GNUC__
-     // Because REQUIREs trigger GCC's -Wparentheses, and because still
-     // supported version of g++ have only buggy support for _Pragmas,
-     // Wparentheses have to be suppressed globally.
-#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
-
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wunused-variable"
-#    pragma GCC diagnostic ignored "-Wpadded"
-#endif
-// end catch_suppress_warnings.h
-#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
-#  define CATCH_IMPL
-#  define CATCH_CONFIG_ALL_PARTS
-#endif
-
-// In the impl file, we want to have access to all parts of the headers
-// Can also be used to sanely support PCHs
-#if defined(CATCH_CONFIG_ALL_PARTS)
-#  define CATCH_CONFIG_EXTERNAL_INTERFACES
-#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#    undef CATCH_CONFIG_DISABLE_MATCHERS
-#  endif
-#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  endif
-#endif
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-// start catch_platform.h
-
-#ifdef __APPLE__
-# include <TargetConditionals.h>
-# if TARGET_OS_OSX == 1
-#  define CATCH_PLATFORM_MAC
-# elif TARGET_OS_IPHONE == 1
-#  define CATCH_PLATFORM_IPHONE
-# endif
-
-#elif defined(linux) || defined(__linux) || defined(__linux__)
-#  define CATCH_PLATFORM_LINUX
-
-#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
-#  define CATCH_PLATFORM_WINDOWS
-#endif
-
-// end catch_platform.h
-
-#ifdef CATCH_IMPL
-#  ifndef CLARA_CONFIG_MAIN
-#    define CLARA_CONFIG_MAIN_NOT_DEFINED
-#    define CLARA_CONFIG_MAIN
-#  endif
-#endif
-
-// start catch_user_interfaces.h
-
-namespace Catch {
-    unsigned int rngSeed();
-}
-
-// end catch_user_interfaces.h
-// start catch_tag_alias_autoregistrar.h
-
-// start catch_common.h
-
-// start catch_compiler_capabilities.h
-
-// Detect a number of compiler features - by compiler
-// The following features are defined:
-//
-// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
-// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
-// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
-// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
-// ****************
-// Note to maintainers: if new toggles are added please document them
-// in configuration.md, too
-// ****************
-
-// In general each macro has a _NO_<feature name> form
-// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
-// Many features, at point of detection, define an _INTERNAL_ macro, so they
-// can be combined, en-mass, with the _NO_ forms later.
-
-#ifdef __cplusplus
-
-#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
-#    define CATCH_CPP14_OR_GREATER
-#  endif
-
-#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-#    define CATCH_CPP17_OR_GREATER
-#  endif
-
-#endif
-
-#if defined(CATCH_CPP17_OR_GREATER)
-#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif
-
-// We have to avoid both ICC and Clang, because they try to mask themselves
-// as gcc, and we want only GCC in this block
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
-
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
-
-#endif
-
-#if defined(__clang__)
-
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
-
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
-
-#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
-         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
-
-#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
-
-#endif // __clang__
-
-////////////////////////////////////////////////////////////////////////////////
-// Assume that non-Windows platforms support posix signals by default
-#if !defined(CATCH_PLATFORM_WINDOWS)
-    #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// We know some environments not to support full POSIX signals
-#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
-    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#endif
-
-#ifdef __OS400__
-#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#       define CATCH_CONFIG_COLOUR_NONE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Android somehow still does not support std::to_string
-#if defined(__ANDROID__)
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Not all Windows environments support SEH properly
-#if defined(__MINGW32__)
-#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// PS4
-#if defined(__ORBIS__)
-#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Cygwin
-#ifdef __CYGWIN__
-
-// Required for some versions of Cygwin to declare gettimeofday
-// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
-#   define _BSD_SOURCE
-// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
-// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
-# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
-           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
-
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-
-# endif
-#endif // __CYGWIN__
-
-////////////////////////////////////////////////////////////////////////////////
-// Visual C++
-#if defined(_MSC_VER)
-
-#  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
-#  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
-
-#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
-#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#  endif
-
-// Universal Windows platform does not support SEH
-// Or console colours (or console at all...)
-#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
-#    define CATCH_CONFIG_COLOUR_NONE
-#  else
-#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
-#  endif
-
-// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
-// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
-// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
-#  if !defined(__clang__) // Handle Clang masquerading for msvc
-#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
-#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#    endif // MSVC_TRADITIONAL
-#  endif // __clang__
-
-#endif // _MSC_VER
-
-#if defined(_REENTRANT) || defined(_MSC_VER)
-// Enable async processing, as -pthread is specified or no additional linking is required
-# define CATCH_INTERNAL_CONFIG_USE_ASYNC
-#endif // _MSC_VER
-
-////////////////////////////////////////////////////////////////////////////////
-// Check if we are compiled with -fno-exceptions or equivalent
-#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
-#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// DJGPP
-#ifdef __DJGPP__
-#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
-#endif // __DJGPP__
-
-////////////////////////////////////////////////////////////////////////////////
-// Embarcadero C++Build
-#if defined(__BORLANDC__)
-    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Use of __COUNTER__ is suppressed during code analysis in
-// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
-// handled by it.
-// Otherwise all supported compilers support COUNTER macro,
-// but user still might want to turn it off
-#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
-    #define CATCH_INTERNAL_CONFIG_COUNTER
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-// RTX is a special version of Windows that is real time.
-// This means that it is detected as Windows, but does not provide
-// the same set of capabilities as real Windows does.
-#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
-    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
-    #define CATCH_CONFIG_COLOUR_NONE
-#endif
-
-#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
-#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-// Various stdlib support checks that require __has_include
-#if defined(__has_include)
-  // Check if string_view is available and usable
-  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
-  #endif
-
-  // Check if optional is available and usable
-  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
-  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if byte is available and usable
-  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
-  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if variant is available and usable
-  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-  #    if defined(__clang__) && (__clang_major__ < 8)
-         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
-         // fix should be in clang 8, workaround in libstdc++ 8.2
-  #      include <ciso646>
-  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #        define CATCH_CONFIG_NO_CPP17_VARIANT
-  #      else
-  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #    else
-  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #    endif // defined(__clang__) && (__clang_major__ < 8)
-  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // defined(__has_include)
-
-#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
-#   define CATCH_CONFIG_COUNTER
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
-#   define CATCH_CONFIG_WINDOWS_SEH
-#endif
-// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
-#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
-#   define CATCH_CONFIG_POSIX_SIGNALS
-#endif
-// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
-#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
-#   define CATCH_CONFIG_WCHAR
-#endif
-
-#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
-#    define CATCH_CONFIG_CPP11_TO_STRING
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#  define CATCH_CONFIG_CPP17_OPTIONAL
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
-#  define CATCH_CONFIG_CPP17_STRING_VIEW
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
-#  define CATCH_CONFIG_CPP17_VARIANT
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
-#  define CATCH_CONFIG_CPP17_BYTE
-#endif
-
-#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
-#  define CATCH_CONFIG_NEW_CAPTURE
-#endif
-
-#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-#  define CATCH_CONFIG_POLYFILL_ISNAN
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
-#  define CATCH_CONFIG_USE_ASYNC
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#  define CATCH_CONFIG_ANDROID_LOGWRITE
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-// Even if we do not think the compiler has that warning, we still have
-// to provide a macro that can be used by the code.
-#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-#endif
-#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
-#endif
-
-// The goal of this macro is to avoid evaluation of the arguments, but
-// still have the compiler warn on problems inside...
-#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
-#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
-#endif
-
-#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#elif defined(__clang__) && (__clang_major__ < 5)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-#define CATCH_TRY if ((true))
-#define CATCH_CATCH_ALL if ((false))
-#define CATCH_CATCH_ANON(type) if ((false))
-#else
-#define CATCH_TRY try
-#define CATCH_CATCH_ALL catch (...)
-#define CATCH_CATCH_ANON(type) catch (type)
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
-#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#endif
-
-// end catch_compiler_capabilities.h
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
-#ifdef CATCH_CONFIG_COUNTER
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
-#else
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
-#endif
-
-#include <iosfwd>
-#include <string>
-#include <cstdint>
-
-// We need a dummy global operator<< so we can bring it into Catch namespace later
-struct Catch_global_namespace_dummy {};
-std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
-
-namespace Catch {
-
-    struct CaseSensitive { enum Choice {
-        Yes,
-        No
-    }; };
-
-    class NonCopyable {
-        NonCopyable( NonCopyable const& )              = delete;
-        NonCopyable( NonCopyable && )                  = delete;
-        NonCopyable& operator = ( NonCopyable const& ) = delete;
-        NonCopyable& operator = ( NonCopyable && )     = delete;
-
-    protected:
-        NonCopyable();
-        virtual ~NonCopyable();
-    };
-
-    struct SourceLineInfo {
-
-        SourceLineInfo() = delete;
-        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
-        :   file( _file ),
-            line( _line )
-        {}
-
-        SourceLineInfo( SourceLineInfo const& other )            = default;
-        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
-        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
-        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
-
-        bool empty() const noexcept { return file[0] == '\0'; }
-        bool operator == ( SourceLineInfo const& other ) const noexcept;
-        bool operator < ( SourceLineInfo const& other ) const noexcept;
-
-        char const* file;
-        std::size_t line;
-    };
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
-
-    // Bring in operator<< from global namespace into Catch namespace
-    // This is necessary because the overload of operator<< above makes
-    // lookup stop at namespace Catch
-    using ::operator<<;
-
-    // Use this in variadic streaming macros to allow
-    //    >> +StreamEndStop
-    // as well as
-    //    >> stuff +StreamEndStop
-    struct StreamEndStop {
-        std::string operator+() const;
-    };
-    template<typename T>
-    T const& operator + ( T const& value, StreamEndStop ) {
-        return value;
-    }
-}
-
-#define CATCH_INTERNAL_LINEINFO \
-    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
-
-// end catch_common.h
-namespace Catch {
-
-    struct RegistrarForTagAliases {
-        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
-    };
-
-} // end namespace Catch
-
-#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-// end catch_tag_alias_autoregistrar.h
-// start catch_test_registry.h
-
-// start catch_interfaces_testcase.h
-
-#include <vector>
-
-namespace Catch {
-
-    class TestSpec;
-
-    struct ITestInvoker {
-        virtual void invoke () const = 0;
-        virtual ~ITestInvoker();
-    };
-
-    class TestCase;
-    struct IConfig;
-
-    struct ITestCaseRegistry {
-        virtual ~ITestCaseRegistry();
-        virtual std::vector<TestCase> const& getAllTests() const = 0;
-        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
-    };
-
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
-
-}
-
-// end catch_interfaces_testcase.h
-// start catch_stringref.h
-
-#include <cstddef>
-#include <string>
-#include <iosfwd>
-#include <cassert>
-
-namespace Catch {
-
-    /// A non-owning string class (similar to the forthcoming std::string_view)
-    /// Note that, because a StringRef may be a substring of another string,
-    /// it may not be null terminated.
-    class StringRef {
-    public:
-        using size_type = std::size_t;
-        using const_iterator = const char*;
-
-    private:
-        static constexpr char const* const s_empty = "";
-
-        char const* m_start = s_empty;
-        size_type m_size = 0;
-
-    public: // construction
-        constexpr StringRef() noexcept = default;
-
-        StringRef( char const* rawChars ) noexcept;
-
-        constexpr StringRef( char const* rawChars, size_type size ) noexcept
-        :   m_start( rawChars ),
-            m_size( size )
-        {}
-
-        StringRef( std::string const& stdString ) noexcept
-        :   m_start( stdString.c_str() ),
-            m_size( stdString.size() )
-        {}
-
-        explicit operator std::string() const {
-            return std::string(m_start, m_size);
-        }
-
-    public: // operators
-        auto operator == ( StringRef const& other ) const noexcept -> bool;
-        auto operator != (StringRef const& other) const noexcept -> bool {
-            return !(*this == other);
-        }
-
-        auto operator[] ( size_type index ) const noexcept -> char {
-            assert(index < m_size);
-            return m_start[index];
-        }
-
-    public: // named queries
-        constexpr auto empty() const noexcept -> bool {
-            return m_size == 0;
-        }
-        constexpr auto size() const noexcept -> size_type {
-            return m_size;
-        }
-
-        // Returns the current start pointer. If the StringRef is not
-        // null-terminated, throws std::domain_exception
-        auto c_str() const -> char const*;
-
-    public: // substrings and searches
-        // Returns a substring of [start, start + length).
-        // If start + length > size(), then the substring is [start, size()).
-        // If start > size(), then the substring is empty.
-        auto substr( size_type start, size_type length ) const noexcept -> StringRef;
-
-        // Returns the current start pointer. May not be null-terminated.
-        auto data() const noexcept -> char const*;
-
-        constexpr auto isNullTerminated() const noexcept -> bool {
-            return m_start[m_size] == '\0';
-        }
-
-    public: // iterators
-        constexpr const_iterator begin() const { return m_start; }
-        constexpr const_iterator end() const { return m_start + m_size; }
-    };
-
-    auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
-    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
-
-    constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
-        return StringRef( rawChars, size );
-    }
-} // namespace Catch
-
-constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
-    return Catch::StringRef( rawChars, size );
-}
-
-// end catch_stringref.h
-// start catch_preprocessor.hpp
-
-
-#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
-#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
-
-#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
-// MSVC needs more evaluations
-#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
-#else
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
-#endif
-
-#define CATCH_REC_END(...)
-#define CATCH_REC_OUT
-
-#define CATCH_EMPTY()
-#define CATCH_DEFER(id) id CATCH_EMPTY()
-
-#define CATCH_REC_GET_END2() 0, CATCH_REC_END
-#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
-#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
-#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
-#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
-#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
-
-#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-
-#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-
-// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
-// and passes userdata as the first parameter to each invocation,
-// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
-#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
-#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
-#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
-#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
-#else
-// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
-#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
-#endif
-
-#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
-#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
-
-#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
-#else
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
-#endif
-
-#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
-    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
-
-#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
-#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
-#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
-#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
-#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
-#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
-#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6)
-#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
-#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
-#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
-#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
-
-#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
-
-#define INTERNAL_CATCH_TYPE_GEN\
-    template<typename...> struct TypeList {};\
-    template<typename...Ts>\
-    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
-    template<template<typename...> class...> struct TemplateTypeList{};\
-    template<template<typename...> class...Cs>\
-    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
-    template<typename...>\
-    struct append;\
-    template<typename...>\
-    struct rewrap;\
-    template<template<typename...> class, typename...>\
-    struct create;\
-    template<template<typename...> class, typename>\
-    struct convert;\
-    \
-    template<typename T> \
-    struct append<T> { using type = T; };\
-    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
-    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
-    template< template<typename...> class L1, typename...E1, typename...Rest>\
-    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
-    \
-    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
-    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
-    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
-    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
-    \
-    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
-    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
-    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
-    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
-
-#define INTERNAL_CATCH_NTTP_1(signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
-    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
-    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
-    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
-    \
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
-    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
-    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
-    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
-    template<typename TestType> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
-        void test();\
-    }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
-        void test();\
-    }
-
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
-    template<typename TestType> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_NTTP_0
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
-#else
-#define INTERNAL_CATCH_NTTP_0(signature)
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
-#endif
-
-// end catch_preprocessor.hpp
-// start catch_meta.hpp
-
-
-#include <type_traits>
-
-namespace Catch {
-    template<typename T>
-    struct always_false : std::false_type {};
-
-    template <typename> struct true_given : std::true_type {};
-    struct is_callable_tester {
-        template <typename Fun, typename... Args>
-        true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
-        template <typename...>
-        std::false_type static test(...);
-    };
-
-    template <typename T>
-    struct is_callable;
-
-    template <typename Fun, typename... Args>
-    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
-
-#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
-    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
-    // replaced with std::invoke_result here. Also *_t format is preferred over
-    // typename *::type format.
-    template <typename Func, typename U>
-    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
-#else
-    template <typename Func, typename U>
-    using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
-#endif
-
-} // namespace Catch
-
-namespace mpl_{
-    struct na;
-}
-
-// end catch_meta.hpp
-namespace Catch {
-
-template<typename C>
-class TestInvokerAsMethod : public ITestInvoker {
-    void (C::*m_testAsMethod)();
-public:
-    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
-
-    void invoke() const override {
-        C obj;
-        (obj.*m_testAsMethod)();
-    }
-};
-
-auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
-
-template<typename C>
-auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
-    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
-}
-
-struct NameAndTags {
-    NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
-    StringRef name;
-    StringRef tags;
-};
-
-struct AutoReg : NonCopyable {
-    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
-    ~AutoReg();
-};
-
-} // end namespace Catch
-
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
-        namespace{                        \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test();              \
-            };                            \
-        }                                 \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
-        namespace{                                                                                  \
-            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        }                                                                                           \
-        }                                                                                           \
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-#endif
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
-        static void TestName(); \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE( ... ) \
-        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test(); \
-            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        } \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
-        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestName{\
-                TestName(){\
-                    int index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = int[];\
-                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-            return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS              \
-        template<typename TestType> static void TestFuncName();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
-            INTERNAL_CATCH_TYPE_GEN                                                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
-            template<typename... Types>                               \
-            struct TestName {                                         \
-                void reg_tests() {                                          \
-                    int index = 0;                                    \
-                    using expander = int[];                           \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */\
-                }                                                     \
-            };                                                        \
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                      \
-        }                                                             \
-        }                                                             \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
-        template<typename TestType>                                   \
-        static void TestFuncName()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        template<typename TestType> static void TestFunc();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-        INTERNAL_CATCH_TYPE_GEN\
-        template<typename... Types>                               \
-        struct TestName {                                         \
-            void reg_tests() {                                          \
-                int index = 0;                                    \
-                using expander = int[];                           \
-                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */\
-            }                                                     \
-        };\
-        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = typename convert<TestName, TmplList>::type; \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                      \
-        }}\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
-        template<typename TestType>                                   \
-        static void TestFunc()
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
-
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestNameClass{\
-                TestNameClass(){\
-                    int index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = int[];\
-                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-                return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        template<typename TestType> \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-                void test();\
-            };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
-            INTERNAL_CATCH_TYPE_GEN                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    int index = 0;\
-                    using expander = int[];\
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        template<typename TestType> \
-        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-            void test();\
-        };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    int index = 0;\
-                    using expander = int[];\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = typename convert<TestNameClass, TmplList>::type;\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }}\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
-
-// end catch_test_registry.h
-// start catch_capture.hpp
-
-// start catch_assertionhandler.h
-
-// start catch_assertioninfo.h
-
-// start catch_result_type.h
-
-namespace Catch {
-
-    // ResultWas::OfType enum
-    struct ResultWas { enum OfType {
-        Unknown = -1,
-        Ok = 0,
-        Info = 1,
-        Warning = 2,
-
-        FailureBit = 0x10,
-
-        ExpressionFailed = FailureBit | 1,
-        ExplicitFailure = FailureBit | 2,
-
-        Exception = 0x100 | FailureBit,
-
-        ThrewException = Exception | 1,
-        DidntThrowException = Exception | 2,
-
-        FatalErrorCondition = 0x200 | FailureBit
-
-    }; };
-
-    bool isOk( ResultWas::OfType resultType );
-    bool isJustInfo( int flags );
-
-    // ResultDisposition::Flags enum
-    struct ResultDisposition { enum Flags {
-        Normal = 0x01,
-
-        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
-        FalseTest = 0x04,           // Prefix expression with !
-        SuppressFail = 0x08         // Failures are reported but do not fail the test
-    }; };
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
-
-    bool shouldContinueOnFailure( int flags );
-    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
-    bool shouldSuppressFailure( int flags );
-
-} // end namespace Catch
-
-// end catch_result_type.h
-namespace Catch {
-
-    struct AssertionInfo
-    {
-        StringRef macroName;
-        SourceLineInfo lineInfo;
-        StringRef capturedExpression;
-        ResultDisposition::Flags resultDisposition;
-
-        // We want to delete this constructor but a compiler bug in 4.8 means
-        // the struct is then treated as non-aggregate
-        //AssertionInfo() = delete;
-    };
-
-} // end namespace Catch
-
-// end catch_assertioninfo.h
-// start catch_decomposer.h
-
-// start catch_tostring.h
-
-#include <vector>
-#include <cstddef>
-#include <type_traits>
-#include <string>
-// start catch_stream.h
-
-#include <iosfwd>
-#include <cstddef>
-#include <ostream>
-
-namespace Catch {
-
-    std::ostream& cout();
-    std::ostream& cerr();
-    std::ostream& clog();
-
-    class StringRef;
-
-    struct IStream {
-        virtual ~IStream();
-        virtual std::ostream& stream() const = 0;
-    };
-
-    auto makeStream( StringRef const &filename ) -> IStream const*;
-
-    class ReusableStringStream : NonCopyable {
-        std::size_t m_index;
-        std::ostream* m_oss;
-    public:
-        ReusableStringStream();
-        ~ReusableStringStream();
-
-        auto str() const -> std::string;
-
-        template<typename T>
-        auto operator << ( T const& value ) -> ReusableStringStream& {
-            *m_oss << value;
-            return *this;
-        }
-        auto get() -> std::ostream& { return *m_oss; }
-    };
-}
-
-// end catch_stream.h
-// start catch_interfaces_enum_values_registry.h
-
-#include <vector>
-
-namespace Catch {
-
-    namespace Detail {
-        struct EnumInfo {
-            StringRef m_name;
-            std::vector<std::pair<int, StringRef>> m_values;
-
-            ~EnumInfo();
-
-            StringRef lookup( int value ) const;
-        };
-    } // namespace Detail
-
-    struct IMutableEnumValuesRegistry {
-        virtual ~IMutableEnumValuesRegistry();
-
-        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
-
-        template<typename E>
-        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
-            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
-            std::vector<int> intValues;
-            intValues.reserve( values.size() );
-            for( auto enumValue : values )
-                intValues.push_back( static_cast<int>( enumValue ) );
-            return registerEnum( enumName, allEnums, intValues );
-        }
-    };
-
-} // Catch
-
-// end catch_interfaces_enum_values_registry.h
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-#include <string_view>
-#endif
-
-#ifdef __OBJC__
-// start catch_objc_arc.hpp
-
-#import <Foundation/Foundation.h>
-
-#ifdef __has_feature
-#define CATCH_ARC_ENABLED __has_feature(objc_arc)
-#else
-#define CATCH_ARC_ENABLED 0
-#endif
-
-void arcSafeRelease( NSObject* obj );
-id performOptionalSelector( id obj, SEL sel );
-
-#if !CATCH_ARC_ENABLED
-inline void arcSafeRelease( NSObject* obj ) {
-    [obj release];
-}
-inline id performOptionalSelector( id obj, SEL sel ) {
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED
-#define CATCH_ARC_STRONG
-#else
-inline void arcSafeRelease( NSObject* ){}
-inline id performOptionalSelector( id obj, SEL sel ) {
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
-#endif
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
-#define CATCH_ARC_STRONG __strong
-#endif
-
-// end catch_objc_arc.hpp
-#endif
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
-#endif
-
-namespace Catch {
-    namespace Detail {
-
-        extern const std::string unprintableString;
-
-        std::string rawMemoryToString( const void *object, std::size_t size );
-
-        template<typename T>
-        std::string rawMemoryToString( const T& object ) {
-          return rawMemoryToString( &object, sizeof(object) );
-        }
-
-        template<typename T>
-        class IsStreamInsertable {
-            template<typename Stream, typename U>
-            static auto test(int)
-                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
-
-            template<typename, typename>
-            static auto test(...)->std::false_type;
-
-        public:
-            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
-        };
-
-        template<typename E>
-        std::string convertUnknownEnumToString( E e );
-
-        template<typename T>
-        typename std::enable_if<
-            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
-        std::string>::type convertUnstreamable( T const& ) {
-            return Detail::unprintableString;
-        }
-        template<typename T>
-        typename std::enable_if<
-            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
-         std::string>::type convertUnstreamable(T const& ex) {
-            return ex.what();
-        }
-
-        template<typename T>
-        typename std::enable_if<
-            std::is_enum<T>::value
-        , std::string>::type convertUnstreamable( T const& value ) {
-            return convertUnknownEnumToString( value );
-        }
-
-#if defined(_MANAGED)
-        //! Convert a CLR string to a utf8 std::string
-        template<typename T>
-        std::string clrReferenceToString( T^ ref ) {
-            if (ref == nullptr)
-                return std::string("null");
-            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
-            cli::pin_ptr<System::Byte> p = &bytes[0];
-            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
-        }
-#endif
-
-    } // namespace Detail
-
-    // If we decide for C++14, change these to enable_if_ts
-    template <typename T, typename = void>
-    struct StringMaker {
-        template <typename Fake = T>
-        static
-        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert(const Fake& value) {
-                ReusableStringStream rss;
-                // NB: call using the function-like syntax to avoid ambiguity with
-                // user-defined templated operator<< under clang.
-                rss.operator<<(value);
-                return rss.str();
-        }
-
-        template <typename Fake = T>
-        static
-        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert( const Fake& value ) {
-#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
-            return Detail::convertUnstreamable(value);
-#else
-            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
-#endif
-        }
-    };
-
-    namespace Detail {
-
-        // This function dispatches all stringification requests inside of Catch.
-        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
-        template <typename T>
-        std::string stringify(const T& e) {
-            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
-        }
-
-        template<typename E>
-        std::string convertUnknownEnumToString( E e ) {
-            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
-        }
-
-#if defined(_MANAGED)
-        template <typename T>
-        std::string stringify( T^ e ) {
-            return ::Catch::StringMaker<T^>::convert(e);
-        }
-#endif
-
-    } // namespace Detail
-
-    // Some predefined specializations
-
-    template<>
-    struct StringMaker<std::string> {
-        static std::string convert(const std::string& str);
-    };
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::string_view> {
-        static std::string convert(std::string_view str);
-    };
-#endif
-
-    template<>
-    struct StringMaker<char const *> {
-        static std::string convert(char const * str);
-    };
-    template<>
-    struct StringMaker<char *> {
-        static std::string convert(char * str);
-    };
-
-#ifdef CATCH_CONFIG_WCHAR
-    template<>
-    struct StringMaker<std::wstring> {
-        static std::string convert(const std::wstring& wstr);
-    };
-
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::wstring_view> {
-        static std::string convert(std::wstring_view str);
-    };
-# endif
-
-    template<>
-    struct StringMaker<wchar_t const *> {
-        static std::string convert(wchar_t const * str);
-    };
-    template<>
-    struct StringMaker<wchar_t *> {
-        static std::string convert(wchar_t * str);
-    };
-#endif
-
-    // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
-    //      while keeping string semantics?
-    template<int SZ>
-    struct StringMaker<char[SZ]> {
-        static std::string convert(char const* str) {
-            return ::Catch::Detail::stringify(std::string{ str });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<signed char[SZ]> {
-        static std::string convert(signed char const* str) {
-            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<unsigned char[SZ]> {
-        static std::string convert(unsigned char const* str) {
-            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
-        }
-    };
-
-#if defined(CATCH_CONFIG_CPP17_BYTE)
-    template<>
-    struct StringMaker<std::byte> {
-        static std::string convert(std::byte value);
-    };
-#endif // defined(CATCH_CONFIG_CPP17_BYTE)
-    template<>
-    struct StringMaker<int> {
-        static std::string convert(int value);
-    };
-    template<>
-    struct StringMaker<long> {
-        static std::string convert(long value);
-    };
-    template<>
-    struct StringMaker<long long> {
-        static std::string convert(long long value);
-    };
-    template<>
-    struct StringMaker<unsigned int> {
-        static std::string convert(unsigned int value);
-    };
-    template<>
-    struct StringMaker<unsigned long> {
-        static std::string convert(unsigned long value);
-    };
-    template<>
-    struct StringMaker<unsigned long long> {
-        static std::string convert(unsigned long long value);
-    };
-
-    template<>
-    struct StringMaker<bool> {
-        static std::string convert(bool b);
-    };
-
-    template<>
-    struct StringMaker<char> {
-        static std::string convert(char c);
-    };
-    template<>
-    struct StringMaker<signed char> {
-        static std::string convert(signed char c);
-    };
-    template<>
-    struct StringMaker<unsigned char> {
-        static std::string convert(unsigned char c);
-    };
-
-    template<>
-    struct StringMaker<std::nullptr_t> {
-        static std::string convert(std::nullptr_t);
-    };
-
-    template<>
-    struct StringMaker<float> {
-        static std::string convert(float value);
-        static int precision;
-    };
-
-    template<>
-    struct StringMaker<double> {
-        static std::string convert(double value);
-        static int precision;
-    };
-
-    template <typename T>
-    struct StringMaker<T*> {
-        template <typename U>
-        static std::string convert(U* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-    template <typename R, typename C>
-    struct StringMaker<R C::*> {
-        static std::string convert(R C::* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-#if defined(_MANAGED)
-    template <typename T>
-    struct StringMaker<T^> {
-        static std::string convert( T^ ref ) {
-            return ::Catch::Detail::clrReferenceToString(ref);
-        }
-    };
-#endif
-
-    namespace Detail {
-        template<typename InputIterator>
-        std::string rangeToString(InputIterator first, InputIterator last) {
-            ReusableStringStream rss;
-            rss << "{ ";
-            if (first != last) {
-                rss << ::Catch::Detail::stringify(*first);
-                for (++first; first != last; ++first)
-                    rss << ", " << ::Catch::Detail::stringify(*first);
-            }
-            rss << " }";
-            return rss.str();
-        }
-    }
-
-#ifdef __OBJC__
-    template<>
-    struct StringMaker<NSString*> {
-        static std::string convert(NSString * nsstring) {
-            if (!nsstring)
-                return "nil";
-            return std::string("@") + [nsstring UTF8String];
-        }
-    };
-    template<>
-    struct StringMaker<NSObject*> {
-        static std::string convert(NSObject* nsObject) {
-            return ::Catch::Detail::stringify([nsObject description]);
-        }
-
-    };
-    namespace Detail {
-        inline std::string stringify( NSString* nsstring ) {
-            return StringMaker<NSString*>::convert( nsstring );
-        }
-
-    } // namespace Detail
-#endif // __OBJC__
-
-} // namespace Catch
-
-//////////////////////////////////////////////////////
-// Separate std-lib types stringification, so it can be selectively enabled
-// This means that we do not bring in
-
-#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
-#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
-#endif
-
-// Separate std::pair specialization
-#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
-#include <utility>
-namespace Catch {
-    template<typename T1, typename T2>
-    struct StringMaker<std::pair<T1, T2> > {
-        static std::string convert(const std::pair<T1, T2>& pair) {
-            ReusableStringStream rss;
-            rss << "{ "
-                << ::Catch::Detail::stringify(pair.first)
-                << ", "
-                << ::Catch::Detail::stringify(pair.second)
-                << " }";
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-
-#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#include <optional>
-namespace Catch {
-    template<typename T>
-    struct StringMaker<std::optional<T> > {
-        static std::string convert(const std::optional<T>& optional) {
-            ReusableStringStream rss;
-            if (optional.has_value()) {
-                rss << ::Catch::Detail::stringify(*optional);
-            } else {
-                rss << "{ }";
-            }
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
-
-// Separate std::tuple specialization
-#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
-#include <tuple>
-namespace Catch {
-    namespace Detail {
-        template<
-            typename Tuple,
-            std::size_t N = 0,
-            bool = (N < std::tuple_size<Tuple>::value)
-            >
-            struct TupleElementPrinter {
-            static void print(const Tuple& tuple, std::ostream& os) {
-                os << (N ? ", " : " ")
-                    << ::Catch::Detail::stringify(std::get<N>(tuple));
-                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
-            }
-        };
-
-        template<
-            typename Tuple,
-            std::size_t N
-        >
-            struct TupleElementPrinter<Tuple, N, false> {
-            static void print(const Tuple&, std::ostream&) {}
-        };
-
-    }
-
-    template<typename ...Types>
-    struct StringMaker<std::tuple<Types...>> {
-        static std::string convert(const std::tuple<Types...>& tuple) {
-            ReusableStringStream rss;
-            rss << '{';
-            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
-            rss << " }";
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-
-#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
-#include <variant>
-namespace Catch {
-    template<>
-    struct StringMaker<std::monostate> {
-        static std::string convert(const std::monostate&) {
-            return "{ }";
-        }
-    };
-
-    template<typename... Elements>
-    struct StringMaker<std::variant<Elements...>> {
-        static std::string convert(const std::variant<Elements...>& variant) {
-            if (variant.valueless_by_exception()) {
-                return "{valueless variant}";
-            } else {
-                return std::visit(
-                    [](const auto& value) {
-                        return ::Catch::Detail::stringify(value);
-                    },
-                    variant
-                );
-            }
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-
-namespace Catch {
-    struct not_this_one {}; // Tag type for detecting which begin/ end are being selected
-
-    // Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
-    using std::begin;
-    using std::end;
-
-    not_this_one begin( ... );
-    not_this_one end( ... );
-
-    template <typename T>
-    struct is_range {
-        static const bool value =
-            !std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
-            !std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
-    };
-
-#if defined(_MANAGED) // Managed types are never ranges
-    template <typename T>
-    struct is_range<T^> {
-        static const bool value = false;
-    };
-#endif
-
-    template<typename Range>
-    std::string rangeToString( Range const& range ) {
-        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
-    }
-
-    // Handle vector<bool> specially
-    template<typename Allocator>
-    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
-        ReusableStringStream rss;
-        rss << "{ ";
-        bool first = true;
-        for( bool b : v ) {
-            if( first )
-                first = false;
-            else
-                rss << ", ";
-            rss << ::Catch::Detail::stringify( b );
-        }
-        rss << " }";
-        return rss.str();
-    }
-
-    template<typename R>
-    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
-        static std::string convert( R const& range ) {
-            return rangeToString( range );
-        }
-    };
-
-    template <typename T, int SZ>
-    struct StringMaker<T[SZ]> {
-        static std::string convert(T const(&arr)[SZ]) {
-            return rangeToString(arr);
-        }
-    };
-
-} // namespace Catch
-
-// Separate std::chrono::duration specialization
-#if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#include <ctime>
-#include <ratio>
-#include <chrono>
-
-namespace Catch {
-
-template <class Ratio>
-struct ratio_string {
-    static std::string symbol();
-};
-
-template <class Ratio>
-std::string ratio_string<Ratio>::symbol() {
-    Catch::ReusableStringStream rss;
-    rss << '[' << Ratio::num << '/'
-        << Ratio::den << ']';
-    return rss.str();
-}
-template <>
-struct ratio_string<std::atto> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::femto> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::pico> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::nano> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::micro> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::milli> {
-    static std::string symbol();
-};
-
-    ////////////
-    // std::chrono::duration specializations
-    template<typename Value, typename Ratio>
-    struct StringMaker<std::chrono::duration<Value, Ratio>> {
-        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " s";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " m";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " h";
-            return rss.str();
-        }
-    };
-
-    ////////////
-    // std::chrono::time_point specialization
-    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
-    template<typename Clock, typename Duration>
-    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
-        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
-            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
-        }
-    };
-    // std::chrono::time_point<system_clock> specialization
-    template<typename Duration>
-    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
-        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
-            auto converted = std::chrono::system_clock::to_time_t(time_point);
-
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &converted);
-#else
-            std::tm* timeInfo = std::gmtime(&converted);
-#endif
-
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-
-#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
-namespace Catch { \
-    template<> struct StringMaker<enumName> { \
-        static std::string convert( enumName value ) { \
-            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
-            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
-        } \
-    }; \
-}
-
-#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// end catch_tostring.h
-#include <iosfwd>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
-#pragma warning(disable:4018) // more "signed/unsigned mismatch"
-#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
-#pragma warning(disable:4180) // qualifier applied to function type has no meaning
-#pragma warning(disable:4800) // Forcing result to true or false
-#endif
-
-namespace Catch {
-
-    struct ITransientExpression {
-        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
-        auto getResult() const -> bool { return m_result; }
-        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
-
-        ITransientExpression( bool isBinaryExpression, bool result )
-        :   m_isBinaryExpression( isBinaryExpression ),
-            m_result( result )
-        {}
-
-        // We don't actually need a virtual destructor, but many static analysers
-        // complain if it's not here :-(
-        virtual ~ITransientExpression();
-
-        bool m_isBinaryExpression;
-        bool m_result;
-
-    };
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
-
-    template<typename LhsT, typename RhsT>
-    class BinaryExpr  : public ITransientExpression {
-        LhsT m_lhs;
-        StringRef m_op;
-        RhsT m_rhs;
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            formatReconstructedExpression
-                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
-        }
-
-    public:
-        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
-        :   ITransientExpression{ true, comparisonResult },
-            m_lhs( lhs ),
-            m_op( op ),
-            m_rhs( rhs )
-        {}
-
-        template<typename T>
-        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-    };
-
-    template<typename LhsT>
-    class UnaryExpr : public ITransientExpression {
-        LhsT m_lhs;
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            os << Catch::Detail::stringify( m_lhs );
-        }
-
-    public:
-        explicit UnaryExpr( LhsT lhs )
-        :   ITransientExpression{ false, static_cast<bool>(lhs) },
-            m_lhs( lhs )
-        {}
-    };
-
-    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
-    template<typename LhsT, typename RhsT>
-    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-    template<typename T>
-    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-
-    template<typename LhsT, typename RhsT>
-    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-    template<typename T>
-    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-
-    template<typename LhsT>
-    class ExprLhs {
-        LhsT m_lhs;
-    public:
-        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
-
-        template<typename RhsT>
-        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
-        }
-        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs == rhs, m_lhs, "==", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
-        }
-        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs != rhs, m_lhs, "!=", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
-        }
-        template<typename RhsT>
-        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
-        }
-        template<typename RhsT>
-        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
-        }
-        template<typename RhsT>
-        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<RhsT>::value,
-            "operator&& is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename RhsT>
-        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<RhsT>::value,
-            "operator|| is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
-            return UnaryExpr<LhsT>{ m_lhs };
-        }
-    };
-
-    void handleExpression( ITransientExpression const& expr );
-
-    template<typename T>
-    void handleExpression( ExprLhs<T> const& expr ) {
-        handleExpression( expr.makeUnaryExpr() );
-    }
-
-    struct Decomposer {
-        template<typename T>
-        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
-            return ExprLhs<T const&>{ lhs };
-        }
-
-        auto operator <=( bool value ) -> ExprLhs<bool> {
-            return ExprLhs<bool>{ value };
-        }
-    };
-
-} // end namespace Catch
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// end catch_decomposer.h
-// start catch_interfaces_capture.h
-
-#include <string>
-#include <chrono>
-
-namespace Catch {
-
-    class AssertionResult;
-    struct AssertionInfo;
-    struct SectionInfo;
-    struct SectionEndInfo;
-    struct MessageInfo;
-    struct MessageBuilder;
-    struct Counts;
-    struct AssertionReaction;
-    struct SourceLineInfo;
-
-    struct ITransientExpression;
-    struct IGeneratorTracker;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    struct BenchmarkInfo;
-    template <typename Duration = std::chrono::duration<double, std::nano>>
-    struct BenchmarkStats;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    struct IResultCapture {
-
-        virtual ~IResultCapture();
-
-        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
-                                        Counts& assertions ) = 0;
-        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
-        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
-
-        virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        virtual void benchmarkPreparing( std::string const& name ) = 0;
-        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
-        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
-        virtual void benchmarkFailed( std::string const& error ) = 0;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
-
-        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
-
-        virtual void handleFatalErrorCondition( StringRef message ) = 0;
-
-        virtual void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef const& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string const& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleIncomplete
-                (   AssertionInfo const& info ) = 0;
-        virtual void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) = 0;
-
-        virtual bool lastAssertionPassed() = 0;
-        virtual void assertionPassed() = 0;
-
-        // Deprecated, do not use:
-        virtual std::string getCurrentTestName() const = 0;
-        virtual const AssertionResult* getLastResult() const = 0;
-        virtual void exceptionEarlyReported() = 0;
-    };
-
-    IResultCapture& getResultCapture();
-}
-
-// end catch_interfaces_capture.h
-namespace Catch {
-
-    struct TestFailureException{};
-    struct AssertionResultData;
-    struct IResultCapture;
-    class RunContext;
-
-    class LazyExpression {
-        friend class AssertionHandler;
-        friend struct AssertionStats;
-        friend class RunContext;
-
-        ITransientExpression const* m_transientExpression = nullptr;
-        bool m_isNegated;
-    public:
-        LazyExpression( bool isNegated );
-        LazyExpression( LazyExpression const& other );
-        LazyExpression& operator = ( LazyExpression const& ) = delete;
-
-        explicit operator bool() const;
-
-        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
-    };
-
-    struct AssertionReaction {
-        bool shouldDebugBreak = false;
-        bool shouldThrow = false;
-    };
-
-    class AssertionHandler {
-        AssertionInfo m_assertionInfo;
-        AssertionReaction m_reaction;
-        bool m_completed = false;
-        IResultCapture& m_resultCapture;
-
-    public:
-        AssertionHandler
-            (   StringRef const& macroName,
-                SourceLineInfo const& lineInfo,
-                StringRef capturedExpression,
-                ResultDisposition::Flags resultDisposition );
-        ~AssertionHandler() {
-            if ( !m_completed ) {
-                m_resultCapture.handleIncomplete( m_assertionInfo );
-            }
-        }
-
-        template<typename T>
-        void handleExpr( ExprLhs<T> const& expr ) {
-            handleExpr( expr.makeUnaryExpr() );
-        }
-        void handleExpr( ITransientExpression const& expr );
-
-        void handleMessage(ResultWas::OfType resultType, StringRef const& message);
-
-        void handleExceptionThrownAsExpected();
-        void handleUnexpectedExceptionNotThrown();
-        void handleExceptionNotThrownAsExpected();
-        void handleThrowingCallSkipped();
-        void handleUnexpectedInflightException();
-
-        void complete();
-        void setCompleted();
-
-        // query
-        auto allowThrows() const -> bool;
-    };
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
-
-} // namespace Catch
-
-// end catch_assertionhandler.h
-// start catch_message.h
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    struct MessageInfo {
-        MessageInfo(    StringRef const& _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        ResultWas::OfType _type );
-
-        StringRef macroName;
-        std::string message;
-        SourceLineInfo lineInfo;
-        ResultWas::OfType type;
-        unsigned int sequence;
-
-        bool operator == ( MessageInfo const& other ) const;
-        bool operator < ( MessageInfo const& other ) const;
-    private:
-        static unsigned int globalCount;
-    };
-
-    struct MessageStream {
-
-        template<typename T>
-        MessageStream& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        ReusableStringStream m_stream;
-    };
-
-    struct MessageBuilder : MessageStream {
-        MessageBuilder( StringRef const& macroName,
-                        SourceLineInfo const& lineInfo,
-                        ResultWas::OfType type );
-
-        template<typename T>
-        MessageBuilder& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        MessageInfo m_info;
-    };
-
-    class ScopedMessage {
-    public:
-        explicit ScopedMessage( MessageBuilder const& builder );
-        ScopedMessage( ScopedMessage& duplicate ) = delete;
-        ScopedMessage( ScopedMessage&& old );
-        ~ScopedMessage();
-
-        MessageInfo m_info;
-        bool m_moved;
-    };
-
-    class Capturer {
-        std::vector<MessageInfo> m_messages;
-        IResultCapture& m_resultCapture = getResultCapture();
-        size_t m_captured = 0;
-    public:
-        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
-        ~Capturer();
-
-        void captureValue( size_t index, std::string const& value );
-
-        template<typename T>
-        void captureValues( size_t index, T const& value ) {
-            captureValue( index, Catch::Detail::stringify( value ) );
-        }
-
-        template<typename T, typename... Ts>
-        void captureValues( size_t index, T const& value, Ts const&... values ) {
-            captureValue( index, Catch::Detail::stringify(value) );
-            captureValues( index+1, values... );
-        }
-    };
-
-} // end namespace Catch
-
-// end catch_message.h
-#if !defined(CATCH_CONFIG_DISABLE)
-
-#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
-#else
-  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
-#endif
-
-#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-
-///////////////////////////////////////////////////////////////////////////////
-// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
-// macros.
-#define INTERNAL_CATCH_TRY
-#define INTERNAL_CATCH_CATCH( capturer )
-
-#else // CATCH_CONFIG_FAST_COMPILE
-
-#define INTERNAL_CATCH_TRY try
-#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
-
-#endif
-
-#define INTERNAL_CATCH_REACT( handler ) handler.complete();
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
-    do { \
-        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
-            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( !Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        try { \
-            static_cast<void>(__VA_ARGS__); \
-            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
-        } \
-        catch( ... ) { \
-            catchAssertionHandler.handleUnexpectedInflightException(); \
-        } \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(expr); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
-        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
-    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
-    varName.captureValues( 0, __VA_ARGS__ )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_INFO( macroName, log ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
-    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
-
-///////////////////////////////////////////////////////////////////////////////
-// Although this is matcher-based, it can be used with just a string
-#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-#endif // CATCH_CONFIG_DISABLE
-
-// end catch_capture.hpp
-// start catch_section.h
-
-// start catch_section_info.h
-
-// start catch_totals.h
-
-#include <cstddef>
-
-namespace Catch {
-
-    struct Counts {
-        Counts operator - ( Counts const& other ) const;
-        Counts& operator += ( Counts const& other );
-
-        std::size_t total() const;
-        bool allPassed() const;
-        bool allOk() const;
-
-        std::size_t passed = 0;
-        std::size_t failed = 0;
-        std::size_t failedButOk = 0;
-    };
-
-    struct Totals {
-
-        Totals operator - ( Totals const& other ) const;
-        Totals& operator += ( Totals const& other );
-
-        Totals delta( Totals const& prevTotals ) const;
-
-        int error = 0;
-        Counts assertions;
-        Counts testCases;
-    };
-}
-
-// end catch_totals.h
-#include <string>
-
-namespace Catch {
-
-    struct SectionInfo {
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name );
-
-        // Deprecated
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name,
-                std::string const& ) : SectionInfo( _lineInfo, _name ) {}
-
-        std::string name;
-        std::string description; // !Deprecated: this will always be empty
-        SourceLineInfo lineInfo;
-    };
-
-    struct SectionEndInfo {
-        SectionInfo sectionInfo;
-        Counts prevAssertions;
-        double durationInSeconds;
-    };
-
-} // end namespace Catch
-
-// end catch_section_info.h
-// start catch_timer.h
-
-#include <cstdint>
-
-namespace Catch {
-
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
-    auto getEstimatedClockResolution() -> uint64_t;
-
-    class Timer {
-        uint64_t m_nanoseconds = 0;
-    public:
-        void start();
-        auto getElapsedNanoseconds() const -> uint64_t;
-        auto getElapsedMicroseconds() const -> uint64_t;
-        auto getElapsedMilliseconds() const -> unsigned int;
-        auto getElapsedSeconds() const -> double;
-    };
-
-} // namespace Catch
-
-// end catch_timer.h
-#include <string>
-
-namespace Catch {
-
-    class Section : NonCopyable {
-    public:
-        Section( SectionInfo const& info );
-        ~Section();
-
-        // This indicates whether the section should be executed or not
-        explicit operator bool() const;
-
-    private:
-        SectionInfo m_info;
-
-        std::string m_name;
-        Counts m_assertions;
-        bool m_sectionIncluded;
-        Timer m_timer;
-    };
-
-} // end namespace Catch
-
-#define INTERNAL_CATCH_SECTION( ... ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-// end catch_section.h
-// start catch_interfaces_exception.h
-
-// start catch_interfaces_registry_hub.h
-
-#include <string>
-#include <memory>
-
-namespace Catch {
-
-    class TestCase;
-    struct ITestCaseRegistry;
-    struct IExceptionTranslatorRegistry;
-    struct IExceptionTranslator;
-    struct IReporterRegistry;
-    struct IReporterFactory;
-    struct ITagAliasRegistry;
-    struct IMutableEnumValuesRegistry;
-
-    class StartupExceptionRegistry;
-
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
-
-    struct IRegistryHub {
-        virtual ~IRegistryHub();
-
-        virtual IReporterRegistry const& getReporterRegistry() const = 0;
-        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
-        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
-        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
-
-        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
-    };
-
-    struct IMutableRegistryHub {
-        virtual ~IMutableRegistryHub();
-        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerTest( TestCase const& testInfo ) = 0;
-        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
-        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
-        virtual void registerStartupException() noexcept = 0;
-        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
-    };
-
-    IRegistryHub const& getRegistryHub();
-    IMutableRegistryHub& getMutableRegistryHub();
-    void cleanUp();
-    std::string translateActiveException();
-
-}
-
-// end catch_interfaces_registry_hub.h
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
-        static std::string translatorName( signature )
-#endif
-
-#include <exception>
-#include <string>
-#include <vector>
-
-namespace Catch {
-    using exceptionTranslateFunction = std::string(*)();
-
-    struct IExceptionTranslator;
-    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
-
-    struct IExceptionTranslator {
-        virtual ~IExceptionTranslator();
-        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
-    };
-
-    struct IExceptionTranslatorRegistry {
-        virtual ~IExceptionTranslatorRegistry();
-
-        virtual std::string translateActiveException() const = 0;
-    };
-
-    class ExceptionTranslatorRegistrar {
-        template<typename T>
-        class ExceptionTranslator : public IExceptionTranslator {
-        public:
-
-            ExceptionTranslator( std::string(*translateFunction)( T& ) )
-            : m_translateFunction( translateFunction )
-            {}
-
-            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
-                try {
-                    if( it == itEnd )
-                        std::rethrow_exception(std::current_exception());
-                    else
-                        return (*it)->translate( it+1, itEnd );
-                }
-                catch( T& ex ) {
-                    return m_translateFunction( ex );
-                }
-            }
-
-        protected:
-            std::string(*m_translateFunction)( T& );
-        };
-
-    public:
-        template<typename T>
-        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
-            getMutableRegistryHub().registerTranslator
-                ( new ExceptionTranslator<T>( translateFunction ) );
-        }
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
-    static std::string translatorName( signature ); \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-    static std::string translatorName( signature )
-
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// end catch_interfaces_exception.h
-// start catch_approx.h
-
-#include <type_traits>
-
-namespace Catch {
-namespace Detail {
-
-    class Approx {
-    private:
-        bool equalityComparisonImpl(double other) const;
-        // Validates the new margin (margin >= 0)
-        // out-of-line to avoid including stdexcept in the header
-        void setMargin(double margin);
-        // Validates the new epsilon (0 < epsilon < 1)
-        // out-of-line to avoid including stdexcept in the header
-        void setEpsilon(double epsilon);
-
-    public:
-        explicit Approx ( double value );
-
-        static Approx custom();
-
-        Approx operator-() const;
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx operator()( T const& value ) {
-            Approx approx( static_cast<double>(value) );
-            approx.m_epsilon = m_epsilon;
-            approx.m_margin = m_margin;
-            approx.m_scale = m_scale;
-            return approx;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        explicit Approx( T const& value ): Approx(static_cast<double>(value))
-        {}
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( const T& lhs, Approx const& rhs ) {
-            auto lhs_v = static_cast<double>(lhs);
-            return rhs.equalityComparisonImpl(lhs_v);
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( Approx const& lhs, const T& rhs ) {
-            return operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( T const& lhs, Approx const& rhs ) {
-            return !operator==( lhs, rhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( Approx const& lhs, T const& rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& epsilon( T const& newEpsilon ) {
-            double epsilonAsDouble = static_cast<double>(newEpsilon);
-            setEpsilon(epsilonAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& margin( T const& newMargin ) {
-            double marginAsDouble = static_cast<double>(newMargin);
-            setMargin(marginAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& scale( T const& newScale ) {
-            m_scale = static_cast<double>(newScale);
-            return *this;
-        }
-
-        std::string toString() const;
-
-    private:
-        double m_epsilon;
-        double m_margin;
-        double m_scale;
-        double m_value;
-    };
-} // end namespace Detail
-
-namespace literals {
-    Detail::Approx operator "" _a(long double val);
-    Detail::Approx operator "" _a(unsigned long long val);
-} // end namespace literals
-
-template<>
-struct StringMaker<Catch::Detail::Approx> {
-    static std::string convert(Catch::Detail::Approx const& value);
-};
-
-} // end namespace Catch
-
-// end catch_approx.h
-// start catch_string_manip.h
-
-#include <string>
-#include <iosfwd>
-#include <vector>
-
-namespace Catch {
-
-    bool startsWith( std::string const& s, std::string const& prefix );
-    bool startsWith( std::string const& s, char prefix );
-    bool endsWith( std::string const& s, std::string const& suffix );
-    bool endsWith( std::string const& s, char suffix );
-    bool contains( std::string const& s, std::string const& infix );
-    void toLowerInPlace( std::string& s );
-    std::string toLower( std::string const& s );
-    //! Returns a new string without whitespace at the start/end
-    std::string trim( std::string const& str );
-    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
-    StringRef trim(StringRef ref);
-
-    // !!! Be aware, returns refs into original string - make sure original string outlives them
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
-
-    struct pluralise {
-        pluralise( std::size_t count, std::string const& label );
-
-        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
-
-        std::size_t m_count;
-        std::string m_label;
-    };
-}
-
-// end catch_string_manip.h
-#ifndef CATCH_CONFIG_DISABLE_MATCHERS
-// start catch_capture_matchers.h
-
-// start catch_matchers.h
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-        template<typename ArgT> struct MatchAllOf;
-        template<typename ArgT> struct MatchAnyOf;
-        template<typename ArgT> struct MatchNotOf;
-
-        class MatcherUntypedBase {
-        public:
-            MatcherUntypedBase() = default;
-            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
-            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
-            std::string toString() const;
-
-        protected:
-            virtual ~MatcherUntypedBase();
-            virtual std::string describe() const = 0;
-            mutable std::string m_cachedToString;
-        };
-
-#ifdef __clang__
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
-#endif
-
-        template<typename ObjectT>
-        struct MatcherMethod {
-            virtual bool match( ObjectT const& arg ) const = 0;
-        };
-
-#if defined(__OBJC__)
-        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
-        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
-        template<>
-        struct MatcherMethod<NSString*> {
-            virtual bool match( NSString* arg ) const = 0;
-        };
-#endif
-
-#ifdef __clang__
-#    pragma clang diagnostic pop
-#endif
-
-        template<typename T>
-        struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
-
-            MatchAllOf<T> operator && ( MatcherBase const& other ) const;
-            MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
-            MatchNotOf<T> operator ! () const;
-        };
-
-        template<typename ArgT>
-        struct MatchAllOf : MatcherBase<ArgT> {
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (!matcher->match(arg))
-                        return false;
-                }
-                return true;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " and ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
-                auto copy(*this);
-                copy.m_matchers.push_back( &other );
-                return copy;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-        template<typename ArgT>
-        struct MatchAnyOf : MatcherBase<ArgT> {
-
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (matcher->match(arg))
-                        return true;
-                }
-                return false;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " or ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
-                auto copy(*this);
-                copy.m_matchers.push_back( &other );
-                return copy;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-
-        template<typename ArgT>
-        struct MatchNotOf : MatcherBase<ArgT> {
-
-            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
-
-            bool match( ArgT const& arg ) const override {
-                return !m_underlyingMatcher.match( arg );
-            }
-
-            std::string describe() const override {
-                return "not " + m_underlyingMatcher.toString();
-            }
-            MatcherBase<ArgT> const& m_underlyingMatcher;
-        };
-
-        template<typename T>
-        MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
-            return MatchAllOf<T>() && *this && other;
-        }
-        template<typename T>
-        MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
-            return MatchAnyOf<T>() || *this || other;
-        }
-        template<typename T>
-        MatchNotOf<T> MatcherBase<T>::operator ! () const {
-            return MatchNotOf<T>( *this );
-        }
-
-    } // namespace Impl
-
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
-
-} // namespace Catch
-
-// end catch_matchers.h
-// start catch_matchers_exception.hpp
-
-namespace Catch {
-namespace Matchers {
-namespace Exception {
-
-class ExceptionMessageMatcher : public MatcherBase<std::exception> {
-    std::string m_message;
-public:
-
-    ExceptionMessageMatcher(std::string const& message):
-        m_message(message)
-    {}
-
-    bool match(std::exception const& ex) const override;
-
-    std::string describe() const override;
-};
-
-} // namespace Exception
-
-Exception::ExceptionMessageMatcher Message(std::string const& message);
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_exception.hpp
-// start catch_matchers_floating.h
-
-namespace Catch {
-namespace Matchers {
-
-    namespace Floating {
-
-        enum class FloatingPointKind : uint8_t;
-
-        struct WithinAbsMatcher : MatcherBase<double> {
-            WithinAbsMatcher(double target, double margin);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            double m_margin;
-        };
-
-        struct WithinUlpsMatcher : MatcherBase<double> {
-            WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            uint64_t m_ulps;
-            FloatingPointKind m_type;
-        };
-
-        // Given IEEE-754 format for floats and doubles, we can assume
-        // that float -> double promotion is lossless. Given this, we can
-        // assume that if we do the standard relative comparison of
-        // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
-        // the same result if we do this for floats, as if we do this for
-        // doubles that were promoted from floats.
-        struct WithinRelMatcher : MatcherBase<double> {
-            WithinRelMatcher(double target, double epsilon);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            double m_epsilon;
-        };
-
-    } // namespace Floating
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
-    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
-    Floating::WithinAbsMatcher WithinAbs(double target, double margin);
-    Floating::WithinRelMatcher WithinRel(double target, double eps);
-    // defaults epsilon to 100*numeric_limits<double>::epsilon()
-    Floating::WithinRelMatcher WithinRel(double target);
-    Floating::WithinRelMatcher WithinRel(float target, float eps);
-    // defaults epsilon to 100*numeric_limits<float>::epsilon()
-    Floating::WithinRelMatcher WithinRel(float target);
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_floating.h
-// start catch_matchers_generic.hpp
-
-#include <functional>
-#include <string>
-
-namespace Catch {
-namespace Matchers {
-namespace Generic {
-
-namespace Detail {
-    std::string finalizeDescription(const std::string& desc);
-}
-
-template <typename T>
-class PredicateMatcher : public MatcherBase<T> {
-    std::function<bool(T const&)> m_predicate;
-    std::string m_description;
-public:
-
-    PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
-        :m_predicate(std::move(elem)),
-        m_description(Detail::finalizeDescription(descr))
-    {}
-
-    bool match( T const& item ) const override {
-        return m_predicate(item);
-    }
-
-    std::string describe() const override {
-        return m_description;
-    }
-};
-
-} // namespace Generic
-
-    // The following functions create the actual matcher objects.
-    // The user has to explicitly specify type to the function, because
-    // inferring std::function<bool(T const&)> is hard (but possible) and
-    // requires a lot of TMP.
-    template<typename T>
-    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
-        return Generic::PredicateMatcher<T>(predicate, description);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_generic.hpp
-// start catch_matchers_string.h
-
-#include <string>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace StdString {
-
-        struct CasedString
-        {
-            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
-            std::string adjustString( std::string const& str ) const;
-            std::string caseSensitivitySuffix() const;
-
-            CaseSensitive::Choice m_caseSensitivity;
-            std::string m_str;
-        };
-
-        struct StringMatcherBase : MatcherBase<std::string> {
-            StringMatcherBase( std::string const& operation, CasedString const& comparator );
-            std::string describe() const override;
-
-            CasedString m_comparator;
-            std::string m_operation;
-        };
-
-        struct EqualsMatcher : StringMatcherBase {
-            EqualsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct ContainsMatcher : StringMatcherBase {
-            ContainsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct StartsWithMatcher : StringMatcherBase {
-            StartsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct EndsWithMatcher : StringMatcherBase {
-            EndsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-
-        struct RegexMatcher : MatcherBase<std::string> {
-            RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
-            bool match( std::string const& matchee ) const override;
-            std::string describe() const override;
-
-        private:
-            std::string m_regex;
-            CaseSensitive::Choice m_caseSensitivity;
-        };
-
-    } // namespace StdString
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_string.h
-// start catch_matchers_vector.h
-
-#include <algorithm>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace Vector {
-        template<typename T>
-        struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
-
-            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
-
-            bool match(std::vector<T> const &v) const override {
-                for (auto const& el : v) {
-                    if (el == m_comparator) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
-
-            T const& m_comparator;
-        };
-
-        template<typename T>
-        struct ContainsMatcher : MatcherBase<std::vector<T>> {
-
-            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: see note in EqualsMatcher
-                if (m_comparator.size() > v.size())
-                    return false;
-                for (auto const& comparator : m_comparator) {
-                    auto present = false;
-                    for (const auto& el : v) {
-                        if (el == comparator) {
-                            present = true;
-                            break;
-                        }
-                    }
-                    if (!present) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
-
-            std::vector<T> const& m_comparator;
-        };
-
-        template<typename T>
-        struct EqualsMatcher : MatcherBase<std::vector<T>> {
-
-            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: This currently works if all elements can be compared using !=
-                // - a more general approach would be via a compare template that defaults
-                // to using !=. but could be specialised for, e.g. std::vector<T> etc
-                // - then just call that directly
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != v[i])
-                        return false;
-                return true;
-            }
-            std::string describe() const override {
-                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
-            }
-            std::vector<T> const& m_comparator;
-        };
-
-        template<typename T>
-        struct ApproxMatcher : MatcherBase<std::vector<T>> {
-
-            ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != approx(v[i]))
-                        return false;
-                return true;
-            }
-            std::string describe() const override {
-                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& epsilon( T const& newEpsilon ) {
-                approx.epsilon(newEpsilon);
-                return *this;
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& margin( T const& newMargin ) {
-                approx.margin(newMargin);
-                return *this;
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& scale( T const& newScale ) {
-                approx.scale(newScale);
-                return *this;
-            }
-
-            std::vector<T> const& m_comparator;
-            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
-        };
-
-        template<typename T>
-        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
-            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
-            bool match(std::vector<T> const& vec) const override {
-                // Note: This is a reimplementation of std::is_permutation,
-                //       because I don't want to include <algorithm> inside the common path
-                if (m_target.size() != vec.size()) {
-                    return false;
-                }
-                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
-            }
-
-            std::string describe() const override {
-                return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
-            }
-        private:
-            std::vector<T> const& m_target;
-        };
-
-    } // namespace Vector
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    template<typename T>
-    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
-        return Vector::ContainsMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
-        return Vector::ContainsElementMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
-        return Vector::EqualsMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::ApproxMatcher<T> Approx( std::vector<T> const& comparator ) {
-        return Vector::ApproxMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
-        return Vector::UnorderedEqualsMatcher<T>(target);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_vector.h
-namespace Catch {
-
-    template<typename ArgT, typename MatcherT>
-    class MatchExpr : public ITransientExpression {
-        ArgT const& m_arg;
-        MatcherT m_matcher;
-        StringRef m_matcherString;
-    public:
-        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
-        :   ITransientExpression{ true, matcher.match( arg ) },
-            m_arg( arg ),
-            m_matcher( matcher ),
-            m_matcherString( matcherString )
-        {}
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            auto matcherAsString = m_matcher.toString();
-            os << Catch::Detail::stringify( m_arg ) << ' ';
-            if( matcherAsString == Detail::unprintableString )
-                os << m_matcherString;
-            else
-                os << matcherAsString;
-        }
-    };
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
-
-    template<typename ArgT, typename MatcherT>
-    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
-        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
-    }
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__ ); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ex ) { \
-                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-// end catch_capture_matchers.h
-#endif
-// start catch_generators.hpp
-
-// start catch_interfaces_generatortracker.h
-
-
-#include <memory>
-
-namespace Catch {
-
-    namespace Generators {
-        class GeneratorUntypedBase {
-        public:
-            GeneratorUntypedBase() = default;
-            virtual ~GeneratorUntypedBase();
-            // Attempts to move the generator to the next element
-             //
-             // Returns true iff the move succeeded (and a valid element
-             // can be retrieved).
-            virtual bool next() = 0;
-        };
-        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
-
-    } // namespace Generators
-
-    struct IGeneratorTracker {
-        virtual ~IGeneratorTracker();
-        virtual auto hasGenerator() const -> bool = 0;
-        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
-        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
-    };
-
-} // namespace Catch
-
-// end catch_interfaces_generatortracker.h
-// start catch_enforce.h
-
-#include <exception>
-
-namespace Catch {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    template <typename Ex>
-    [[noreturn]]
-    void throw_exception(Ex const& e) {
-        throw e;
-    }
-#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
-    [[noreturn]]
-    void throw_exception(std::exception const& e);
-#endif
-
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg);
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg);
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg);
-
-} // namespace Catch;
-
-#define CATCH_MAKE_MSG(...) \
-    (Catch::ReusableStringStream() << __VA_ARGS__).str()
-
-#define CATCH_INTERNAL_ERROR(...) \
-    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
-
-#define CATCH_ERROR(...) \
-    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
-
-#define CATCH_RUNTIME_ERROR(...) \
-    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
-
-#define CATCH_ENFORCE( condition, ... ) \
-    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
-
-// end catch_enforce.h
-#include <memory>
-#include <vector>
-#include <cassert>
-
-#include <utility>
-#include <exception>
-
-namespace Catch {
-
-class GeneratorException : public std::exception {
-    const char* const m_msg = "";
-
-public:
-    GeneratorException(const char* msg):
-        m_msg(msg)
-    {}
-
-    const char* what() const noexcept override final;
-};
-
-namespace Generators {
-
-    // !TBD move this into its own location?
-    namespace pf{
-        template<typename T, typename... Args>
-        std::unique_ptr<T> make_unique( Args&&... args ) {
-            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-        }
-    }
-
-    template<typename T>
-    struct IGenerator : GeneratorUntypedBase {
-        virtual ~IGenerator() = default;
-
-        // Returns the current element of the generator
-        //
-        // \Precondition The generator is either freshly constructed,
-        // or the last call to `next()` returned true
-        virtual T const& get() const = 0;
-        using type = T;
-    };
-
-    template<typename T>
-    class SingleValueGenerator final : public IGenerator<T> {
-        T m_value;
-    public:
-        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
-
-        T const& get() const override {
-            return m_value;
-        }
-        bool next() override {
-            return false;
-        }
-    };
-
-    template<typename T>
-    class FixedValuesGenerator final : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
-            "FixedValuesGenerator does not support bools because of std::vector<bool>"
-            "specialization, use SingleValue Generator instead.");
-        std::vector<T> m_values;
-        size_t m_idx = 0;
-    public:
-        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
-
-        T const& get() const override {
-            return m_values[m_idx];
-        }
-        bool next() override {
-            ++m_idx;
-            return m_idx < m_values.size();
-        }
-    };
-
-    template <typename T>
-    class GeneratorWrapper final {
-        std::unique_ptr<IGenerator<T>> m_generator;
-    public:
-        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
-            m_generator(std::move(generator))
-        {}
-        T const& get() const {
-            return m_generator->get();
-        }
-        bool next() {
-            return m_generator->next();
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> value(T&& value) {
-        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
-    }
-    template <typename T>
-    GeneratorWrapper<T> values(std::initializer_list<T> values) {
-        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
-    }
-
-    template<typename T>
-    class Generators : public IGenerator<T> {
-        std::vector<GeneratorWrapper<T>> m_generators;
-        size_t m_current = 0;
-
-        void populate(GeneratorWrapper<T>&& generator) {
-            m_generators.emplace_back(std::move(generator));
-        }
-        void populate(T&& val) {
-            m_generators.emplace_back(value(std::forward<T>(val)));
-        }
-        template<typename U>
-        void populate(U&& val) {
-            populate(T(std::forward<U>(val)));
-        }
-        template<typename U, typename... Gs>
-        void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
-            populate(std::forward<U>(valueOrGenerator));
-            populate(std::forward<Gs>(moreGenerators)...);
-        }
-
-    public:
-        template <typename... Gs>
-        Generators(Gs &&... moreGenerators) {
-            m_generators.reserve(sizeof...(Gs));
-            populate(std::forward<Gs>(moreGenerators)...);
-        }
-
-        T const& get() const override {
-            return m_generators[m_current].get();
-        }
-
-        bool next() override {
-            if (m_current >= m_generators.size()) {
-                return false;
-            }
-            const bool current_status = m_generators[m_current].next();
-            if (!current_status) {
-                ++m_current;
-            }
-            return m_current < m_generators.size();
-        }
-    };
-
-    template<typename... Ts>
-    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
-        return values<std::tuple<Ts...>>( tuples );
-    }
-
-    // Tag type to signal that a generator sequence should convert arguments to a specific type
-    template <typename T>
-    struct as {};
-
-    template<typename T, typename... Gs>
-    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
-        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
-    }
-    template<typename T>
-    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
-        return Generators<T>(std::move(generator));
-    }
-    template<typename T, typename... Gs>
-    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
-    }
-    template<typename T, typename U, typename... Gs>
-    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
-    }
-
-    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
-
-    template<typename L>
-    // Note: The type after -> is weird, because VS2015 cannot parse
-    //       the expression used in the typedef inside, when it is in
-    //       return type. Yeah.
-    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
-        using UnderlyingType = typename decltype(generatorExpression())::type;
-
-        IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
-        if (!tracker.hasGenerator()) {
-            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
-        }
-
-        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
-        return generator.get();
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-#define GENERATE( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-#define GENERATE_COPY( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-#define GENERATE_REF( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-
-// end catch_generators.hpp
-// start catch_generators_generic.hpp
-
-namespace Catch {
-namespace Generators {
-
-    template <typename T>
-    class TakeGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        size_t m_returned = 0;
-        size_t m_target;
-    public:
-        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_target(target)
-        {
-            assert(target != 0 && "Empty generators are not allowed");
-        }
-        T const& get() const override {
-            return m_generator.get();
-        }
-        bool next() override {
-            ++m_returned;
-            if (m_returned >= m_target) {
-                return false;
-            }
-
-            const auto success = m_generator.next();
-            // If the underlying generator does not contain enough values
-            // then we cut short as well
-            if (!success) {
-                m_returned = m_target;
-            }
-            return success;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
-    }
-
-    template <typename T, typename Predicate>
-    class FilterGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        Predicate m_predicate;
-    public:
-        template <typename P = Predicate>
-        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_predicate(std::forward<P>(pred))
-        {
-            if (!m_predicate(m_generator.get())) {
-                // It might happen that there are no values that pass the
-                // filter. In that case we throw an exception.
-                auto has_initial_value = next();
-                if (!has_initial_value) {
-                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
-                }
-            }
-        }
-
-        T const& get() const override {
-            return m_generator.get();
-        }
-
-        bool next() override {
-            bool success = m_generator.next();
-            if (!success) {
-                return false;
-            }
-            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
-            return success;
-        }
-    };
-
-    template <typename T, typename Predicate>
-    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
-    }
-
-    template <typename T>
-    class RepeatGenerator : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
-            "RepeatGenerator currently does not support bools"
-            "because of std::vector<bool> specialization");
-        GeneratorWrapper<T> m_generator;
-        mutable std::vector<T> m_returned;
-        size_t m_target_repeats;
-        size_t m_current_repeat = 0;
-        size_t m_repeat_index = 0;
-    public:
-        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_target_repeats(repeats)
-        {
-            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
-        }
-
-        T const& get() const override {
-            if (m_current_repeat == 0) {
-                m_returned.push_back(m_generator.get());
-                return m_returned.back();
-            }
-            return m_returned[m_repeat_index];
-        }
-
-        bool next() override {
-            // There are 2 basic cases:
-            // 1) We are still reading the generator
-            // 2) We are reading our own cache
-
-            // In the first case, we need to poke the underlying generator.
-            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
-            if (m_current_repeat == 0) {
-                const auto success = m_generator.next();
-                if (!success) {
-                    ++m_current_repeat;
-                }
-                return m_current_repeat < m_target_repeats;
-            }
-
-            // In the second case, we need to move indices forward and check that we haven't run up against the end
-            ++m_repeat_index;
-            if (m_repeat_index == m_returned.size()) {
-                m_repeat_index = 0;
-                ++m_current_repeat;
-            }
-            return m_current_repeat < m_target_repeats;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
-    }
-
-    template <typename T, typename U, typename Func>
-    class MapGenerator : public IGenerator<T> {
-        // TBD: provide static assert for mapping function, for friendly error message
-        GeneratorWrapper<U> m_generator;
-        Func m_function;
-        // To avoid returning dangling reference, we have to save the values
-        T m_cache;
-    public:
-        template <typename F2 = Func>
-        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
-            m_generator(std::move(generator)),
-            m_function(std::forward<F2>(function)),
-            m_cache(m_function(m_generator.get()))
-        {}
-
-        T const& get() const override {
-            return m_cache;
-        }
-        bool next() override {
-            const auto success = m_generator.next();
-            if (success) {
-                m_cache = m_function(m_generator.get());
-            }
-            return success;
-        }
-    };
-
-    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
-        );
-    }
-
-    template <typename T, typename U, typename Func>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
-        );
-    }
-
-    template <typename T>
-    class ChunkGenerator final : public IGenerator<std::vector<T>> {
-        std::vector<T> m_chunk;
-        size_t m_chunk_size;
-        GeneratorWrapper<T> m_generator;
-        bool m_used_up = false;
-    public:
-        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
-            m_chunk_size(size), m_generator(std::move(generator))
-        {
-            m_chunk.reserve(m_chunk_size);
-            if (m_chunk_size != 0) {
-                m_chunk.push_back(m_generator.get());
-                for (size_t i = 1; i < m_chunk_size; ++i) {
-                    if (!m_generator.next()) {
-                        Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
-                    }
-                    m_chunk.push_back(m_generator.get());
-                }
-            }
-        }
-        std::vector<T> const& get() const override {
-            return m_chunk;
-        }
-        bool next() override {
-            m_chunk.clear();
-            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
-                if (!m_generator.next()) {
-                    return false;
-                }
-                m_chunk.push_back(m_generator.get());
-            }
-            return true;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<std::vector<T>>(
-            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
-        );
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-// end catch_generators_generic.hpp
-// start catch_generators_specific.hpp
-
-// start catch_context.h
-
-#include <memory>
-
-namespace Catch {
-
-    struct IResultCapture;
-    struct IRunner;
-    struct IConfig;
-    struct IMutableContext;
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-
-    struct IContext
-    {
-        virtual ~IContext();
-
-        virtual IResultCapture* getResultCapture() = 0;
-        virtual IRunner* getRunner() = 0;
-        virtual IConfigPtr const& getConfig() const = 0;
-    };
-
-    struct IMutableContext : IContext
-    {
-        virtual ~IMutableContext();
-        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
-        virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( IConfigPtr const& config ) = 0;
-
-    private:
-        static IMutableContext *currentContext;
-        friend IMutableContext& getCurrentMutableContext();
-        friend void cleanUpContext();
-        static void createContext();
-    };
-
-    inline IMutableContext& getCurrentMutableContext()
-    {
-        if( !IMutableContext::currentContext )
-            IMutableContext::createContext();
-        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
-        return *IMutableContext::currentContext;
-    }
-
-    inline IContext& getCurrentContext()
-    {
-        return getCurrentMutableContext();
-    }
-
-    void cleanUpContext();
-
-    class SimplePcg32;
-    SimplePcg32& rng();
-}
-
-// end catch_context.h
-// start catch_interfaces_config.h
-
-// start catch_option.hpp
-
-namespace Catch {
-
-    // An optional type
-    template<typename T>
-    class Option {
-    public:
-        Option() : nullableValue( nullptr ) {}
-        Option( T const& _value )
-        : nullableValue( new( storage ) T( _value ) )
-        {}
-        Option( Option const& _other )
-        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
-        {}
-
-        ~Option() {
-            reset();
-        }
-
-        Option& operator= ( Option const& _other ) {
-            if( &_other != this ) {
-                reset();
-                if( _other )
-                    nullableValue = new( storage ) T( *_other );
-            }
-            return *this;
-        }
-        Option& operator = ( T const& _value ) {
-            reset();
-            nullableValue = new( storage ) T( _value );
-            return *this;
-        }
-
-        void reset() {
-            if( nullableValue )
-                nullableValue->~T();
-            nullableValue = nullptr;
-        }
-
-        T& operator*() { return *nullableValue; }
-        T const& operator*() const { return *nullableValue; }
-        T* operator->() { return nullableValue; }
-        const T* operator->() const { return nullableValue; }
-
-        T valueOr( T const& defaultValue ) const {
-            return nullableValue ? *nullableValue : defaultValue;
-        }
-
-        bool some() const { return nullableValue != nullptr; }
-        bool none() const { return nullableValue == nullptr; }
-
-        bool operator !() const { return nullableValue == nullptr; }
-        explicit operator bool() const {
-            return some();
-        }
-
-    private:
-        T *nullableValue;
-        alignas(alignof(T)) char storage[sizeof(T)];
-    };
-
-} // end namespace Catch
-
-// end catch_option.hpp
-#include <chrono>
-#include <iosfwd>
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    enum class Verbosity {
-        Quiet = 0,
-        Normal,
-        High
-    };
-
-    struct WarnAbout { enum What {
-        Nothing = 0x00,
-        NoAssertions = 0x01,
-        NoTests = 0x02
-    }; };
-
-    struct ShowDurations { enum OrNot {
-        DefaultForReporter,
-        Always,
-        Never
-    }; };
-    struct RunTests { enum InWhatOrder {
-        InDeclarationOrder,
-        InLexicographicalOrder,
-        InRandomOrder
-    }; };
-    struct UseColour { enum YesOrNo {
-        Auto,
-        Yes,
-        No
-    }; };
-    struct WaitForKeypress { enum When {
-        Never,
-        BeforeStart = 1,
-        BeforeExit = 2,
-        BeforeStartAndExit = BeforeStart | BeforeExit
-    }; };
-
-    class TestSpec;
-
-    struct IConfig : NonCopyable {
-
-        virtual ~IConfig();
-
-        virtual bool allowThrows() const = 0;
-        virtual std::ostream& stream() const = 0;
-        virtual std::string name() const = 0;
-        virtual bool includeSuccessfulResults() const = 0;
-        virtual bool shouldDebugBreak() const = 0;
-        virtual bool warnAboutMissingAssertions() const = 0;
-        virtual bool warnAboutNoTests() const = 0;
-        virtual int abortAfter() const = 0;
-        virtual bool showInvisibles() const = 0;
-        virtual ShowDurations::OrNot showDurations() const = 0;
-        virtual TestSpec const& testSpec() const = 0;
-        virtual bool hasTestFilters() const = 0;
-        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
-        virtual RunTests::InWhatOrder runOrder() const = 0;
-        virtual unsigned int rngSeed() const = 0;
-        virtual UseColour::YesOrNo useColour() const = 0;
-        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
-        virtual Verbosity verbosity() const = 0;
-
-        virtual bool benchmarkNoAnalysis() const = 0;
-        virtual int benchmarkSamples() const = 0;
-        virtual double benchmarkConfidenceInterval() const = 0;
-        virtual unsigned int benchmarkResamples() const = 0;
-        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
-    };
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-}
-
-// end catch_interfaces_config.h
-// start catch_random_number_generator.h
-
-#include <cstdint>
-
-namespace Catch {
-
-    // This is a simple implementation of C++11 Uniform Random Number
-    // Generator. It does not provide all operators, because Catch2
-    // does not use it, but it should behave as expected inside stdlib's
-    // distributions.
-    // The implementation is based on the PCG family (http://pcg-random.org)
-    class SimplePcg32 {
-        using state_type = std::uint64_t;
-    public:
-        using result_type = std::uint32_t;
-        static constexpr result_type (min)() {
-            return 0;
-        }
-        static constexpr result_type (max)() {
-            return static_cast<result_type>(-1);
-        }
-
-        // Provide some default initial state for the default constructor
-        SimplePcg32():SimplePcg32(0xed743cc4U) {}
-
-        explicit SimplePcg32(result_type seed_);
-
-        void seed(result_type seed_);
-        void discard(uint64_t skip);
-
-        result_type operator()();
-
-    private:
-        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
-        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
-
-        // In theory we also need operator<< and operator>>
-        // In practice we do not use them, so we will skip them for now
-
-        std::uint64_t m_state;
-        // This part of the state determines which "stream" of the numbers
-        // is chosen -- we take it as a constant for Catch2, so we only
-        // need to deal with seeding the main state.
-        // Picked by reading 8 bytes from `/dev/random` :-)
-        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
-    };
-
-} // end namespace Catch
-
-// end catch_random_number_generator.h
-#include <random>
-
-namespace Catch {
-namespace Generators {
-
-template <typename Float>
-class RandomFloatingGenerator final : public IGenerator<Float> {
-    Catch::SimplePcg32& m_rng;
-    std::uniform_real_distribution<Float> m_dist;
-    Float m_current_number;
-public:
-
-    RandomFloatingGenerator(Float a, Float b):
-        m_rng(rng()),
-        m_dist(a, b) {
-        static_cast<void>(next());
-    }
-
-    Float const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rng);
-        return true;
-    }
-};
-
-template <typename Integer>
-class RandomIntegerGenerator final : public IGenerator<Integer> {
-    Catch::SimplePcg32& m_rng;
-    std::uniform_int_distribution<Integer> m_dist;
-    Integer m_current_number;
-public:
-
-    RandomIntegerGenerator(Integer a, Integer b):
-        m_rng(rng()),
-        m_dist(a, b) {
-        static_cast<void>(next());
-    }
-
-    Integer const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rng);
-        return true;
-    }
-};
-
-// TODO: Ideally this would be also constrained against the various char types,
-//       but I don't expect users to run into that in practice.
-template <typename T>
-typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
-GeneratorWrapper<T>>::type
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
-    );
-}
-
-template <typename T>
-typename std::enable_if<std::is_floating_point<T>::value,
-GeneratorWrapper<T>>::type
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
-    );
-}
-
-template <typename T>
-class RangeGenerator final : public IGenerator<T> {
-    T m_current;
-    T m_end;
-    T m_step;
-    bool m_positive;
-
-public:
-    RangeGenerator(T const& start, T const& end, T const& step):
-        m_current(start),
-        m_end(end),
-        m_step(step),
-        m_positive(m_step > T(0))
-    {
-        assert(m_current != m_end && "Range start and end cannot be equal");
-        assert(m_step != T(0) && "Step size cannot be zero");
-        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
-    }
-
-    RangeGenerator(T const& start, T const& end):
-        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
-    {}
-
-    T const& get() const override {
-        return m_current;
-    }
-
-    bool next() override {
-        m_current += m_step;
-        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
-    }
-};
-
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
-    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
-}
-
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end) {
-    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
-}
-
-template <typename T>
-class IteratorGenerator final : public IGenerator<T> {
-    static_assert(!std::is_same<T, bool>::value,
-        "IteratorGenerator currently does not support bools"
-        "because of std::vector<bool> specialization");
-
-    std::vector<T> m_elems;
-    size_t m_current = 0;
-public:
-    template <typename InputIterator, typename InputSentinel>
-    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
-        if (m_elems.empty()) {
-            Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
-        }
-    }
-
-    T const& get() const override {
-        return m_elems[m_current];
-    }
-
-    bool next() override {
-        ++m_current;
-        return m_current != m_elems.size();
-    }
-};
-
-template <typename InputIterator,
-          typename InputSentinel,
-          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
-GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
-    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
-}
-
-template <typename Container,
-          typename ResultType = typename Container::value_type>
-GeneratorWrapper<ResultType> from_range(Container const& cnt) {
-    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
-}
-
-} // namespace Generators
-} // namespace Catch
-
-// end catch_generators_specific.hpp
-
-// These files are included here so the single_include script doesn't put them
-// in the conditionally compiled sections
-// start catch_test_case_info.h
-
-#include <string>
-#include <vector>
-#include <memory>
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    struct ITestInvoker;
-
-    struct TestCaseInfo {
-        enum SpecialProperties{
-            None = 0,
-            IsHidden = 1 << 1,
-            ShouldFail = 1 << 2,
-            MayFail = 1 << 3,
-            Throws = 1 << 4,
-            NonPortable = 1 << 5,
-            Benchmark = 1 << 6
-        };
-
-        TestCaseInfo(   std::string const& _name,
-                        std::string const& _className,
-                        std::string const& _description,
-                        std::vector<std::string> const& _tags,
-                        SourceLineInfo const& _lineInfo );
-
-        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
-
-        bool isHidden() const;
-        bool throws() const;
-        bool okToFail() const;
-        bool expectedToFail() const;
-
-        std::string tagsAsString() const;
-
-        std::string name;
-        std::string className;
-        std::string description;
-        std::vector<std::string> tags;
-        std::vector<std::string> lcaseTags;
-        SourceLineInfo lineInfo;
-        SpecialProperties properties;
-    };
-
-    class TestCase : public TestCaseInfo {
-    public:
-
-        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
-
-        TestCase withName( std::string const& _newName ) const;
-
-        void invoke() const;
-
-        TestCaseInfo const& getTestCaseInfo() const;
-
-        bool operator == ( TestCase const& other ) const;
-        bool operator < ( TestCase const& other ) const;
-
-    private:
-        std::shared_ptr<ITestInvoker> test;
-    };
-
-    TestCase makeTestCase(  ITestInvoker* testCase,
-                            std::string const& className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& lineInfo );
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_case_info.h
-// start catch_interfaces_runner.h
-
-namespace Catch {
-
-    struct IRunner {
-        virtual ~IRunner();
-        virtual bool aborting() const = 0;
-    };
-}
-
-// end catch_interfaces_runner.h
-
-#ifdef __OBJC__
-// start catch_objc.hpp
-
-#import <objc/runtime.h>
-
-#include <string>
-
-// NB. Any general catch headers included here must be included
-// in catch.hpp first to make sure they are included by the single
-// header for non obj-usage
-
-///////////////////////////////////////////////////////////////////////////////
-// This protocol is really only here for (self) documenting purposes, since
-// all its methods are optional.
-@protocol OcFixture
-
-@optional
-
--(void) setUp;
--(void) tearDown;
-
-@end
-
-namespace Catch {
-
-    class OcMethod : public ITestInvoker {
-
-    public:
-        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
-
-        virtual void invoke() const {
-            id obj = [[m_cls alloc] init];
-
-            performOptionalSelector( obj, @selector(setUp)  );
-            performOptionalSelector( obj, m_sel );
-            performOptionalSelector( obj, @selector(tearDown)  );
-
-            arcSafeRelease( obj );
-        }
-    private:
-        virtual ~OcMethod() {}
-
-        Class m_cls;
-        SEL m_sel;
-    };
-
-    namespace Detail{
-
-        inline std::string getAnnotation(   Class cls,
-                                            std::string const& annotationName,
-                                            std::string const& testCaseName ) {
-            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
-            SEL sel = NSSelectorFromString( selStr );
-            arcSafeRelease( selStr );
-            id value = performOptionalSelector( cls, sel );
-            if( value )
-                return [(NSString*)value UTF8String];
-            return "";
-        }
-    }
-
-    inline std::size_t registerTestMethods() {
-        std::size_t noTestMethods = 0;
-        int noClasses = objc_getClassList( nullptr, 0 );
-
-        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
-        objc_getClassList( classes, noClasses );
-
-        for( int c = 0; c < noClasses; c++ ) {
-            Class cls = classes[c];
-            {
-                u_int count;
-                Method* methods = class_copyMethodList( cls, &count );
-                for( u_int m = 0; m < count ; m++ ) {
-                    SEL selector = method_getName(methods[m]);
-                    std::string methodName = sel_getName(selector);
-                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
-                        std::string testCaseName = methodName.substr( 15 );
-                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
-                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
-                        const char* className = class_getName( cls );
-
-                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
-                        noTestMethods++;
-                    }
-                }
-                free(methods);
-            }
-        }
-        return noTestMethods;
-    }
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-
-    namespace Matchers {
-        namespace Impl {
-        namespace NSStringMatchers {
-
-            struct StringHolder : MatcherBase<NSString*>{
-                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
-                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
-                StringHolder() {
-                    arcSafeRelease( m_substr );
-                }
-
-                bool match( NSString* str ) const override {
-                    return false;
-                }
-
-                NSString* CATCH_ARC_STRONG m_substr;
-            };
-
-            struct Equals : StringHolder {
-                Equals( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str isEqualToString:m_substr];
-                }
-
-                std::string describe() const override {
-                    return "equals string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-            struct Contains : StringHolder {
-                Contains( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location != NSNotFound;
-                }
-
-                std::string describe() const override {
-                    return "contains string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-            struct StartsWith : StringHolder {
-                StartsWith( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == 0;
-                }
-
-                std::string describe() const override {
-                    return "starts with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-            struct EndsWith : StringHolder {
-                EndsWith( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
-                }
-
-                std::string describe() const override {
-                    return "ends with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-        } // namespace NSStringMatchers
-        } // namespace Impl
-
-        inline Impl::NSStringMatchers::Equals
-            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
-
-        inline Impl::NSStringMatchers::Contains
-            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
-
-        inline Impl::NSStringMatchers::StartsWith
-            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
-
-        inline Impl::NSStringMatchers::EndsWith
-            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
-
-    } // namespace Matchers
-
-    using namespace Matchers;
-
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
-#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
-{ \
-return @ name; \
-} \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
-{ \
-return @ desc; \
-} \
--(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
-
-#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
-
-// end catch_objc.hpp
-#endif
-
-// Benchmarking needs the externally-facing parts of reporters to work
-#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_external_interfaces.h
-
-// start catch_reporter_bases.hpp
-
-// start catch_interfaces_reporter.h
-
-// start catch_config.hpp
-
-// start catch_test_spec_parser.h
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// start catch_test_spec.h
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// start catch_wildcard_pattern.h
-
-namespace Catch
-{
-    class WildcardPattern {
-        enum WildcardPosition {
-            NoWildcard = 0,
-            WildcardAtStart = 1,
-            WildcardAtEnd = 2,
-            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
-        };
-
-    public:
-
-        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
-        virtual ~WildcardPattern() = default;
-        virtual bool matches( std::string const& str ) const;
-
-    private:
-        std::string normaliseString( std::string const& str ) const;
-        CaseSensitive::Choice m_caseSensitivity;
-        WildcardPosition m_wildcard = NoWildcard;
-        std::string m_pattern;
-    };
-}
-
-// end catch_wildcard_pattern.h
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    struct IConfig;
-
-    class TestSpec {
-        class Pattern {
-        public:
-            explicit Pattern( std::string const& name );
-            virtual ~Pattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
-            std::string const& name() const;
-        private:
-            std::string const m_name;
-        };
-        using PatternPtr = std::shared_ptr<Pattern>;
-
-        class NamePattern : public Pattern {
-        public:
-            explicit NamePattern( std::string const& name, std::string const& filterString );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            WildcardPattern m_wildcardPattern;
-        };
-
-        class TagPattern : public Pattern {
-        public:
-            explicit TagPattern( std::string const& tag, std::string const& filterString );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            std::string m_tag;
-        };
-
-        class ExcludedPattern : public Pattern {
-        public:
-            explicit ExcludedPattern( PatternPtr const& underlyingPattern );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            PatternPtr m_underlyingPattern;
-        };
-
-        struct Filter {
-            std::vector<PatternPtr> m_patterns;
-
-            bool matches( TestCaseInfo const& testCase ) const;
-            std::string name() const;
-        };
-
-    public:
-        struct FilterMatch {
-            std::string name;
-            std::vector<TestCase const*> tests;
-        };
-        using Matches = std::vector<FilterMatch>;
-        using vectorStrings = std::vector<std::string>;
-
-        bool hasFilters() const;
-        bool matches( TestCaseInfo const& testCase ) const;
-        Matches matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const;
-        const vectorStrings & getInvalidArgs() const;
-
-    private:
-        std::vector<Filter> m_filters;
-        std::vector<std::string> m_invalidArgs;
-        friend class TestSpecParser;
-    };
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_spec.h
-// start catch_interfaces_tag_alias_registry.h
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias;
-
-    struct ITagAliasRegistry {
-        virtual ~ITagAliasRegistry();
-        // Nullptr if not present
-        virtual TagAlias const* find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
-
-        static ITagAliasRegistry const& get();
-    };
-
-} // end namespace Catch
-
-// end catch_interfaces_tag_alias_registry.h
-namespace Catch {
-
-    class TestSpecParser {
-        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
-        Mode m_mode = None;
-        Mode lastMode = None;
-        bool m_exclusion = false;
-        std::size_t m_pos = 0;
-        std::size_t m_realPatternPos = 0;
-        std::string m_arg;
-        std::string m_substring;
-        std::string m_patternName;
-        std::vector<std::size_t> m_escapeChars;
-        TestSpec::Filter m_currentFilter;
-        TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases = nullptr;
-
-    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases );
-
-        TestSpecParser& parse( std::string const& arg );
-        TestSpec testSpec();
-
-    private:
-        bool visitChar( char c );
-        void startNewMode( Mode mode );
-        bool processNoneChar( char c );
-        void processNameChar( char c );
-        bool processOtherChar( char c );
-        void endMode();
-        void escape();
-        bool isControlChar( char c ) const;
-        void saveLastMode();
-        void revertBackToLastMode();
-        void addFilter();
-        bool separate();
-
-        // Handles common preprocessing of the pattern for name/tag patterns
-        std::string preprocessPattern();
-        // Adds the current pattern as a test name
-        void addNamePattern();
-        // Adds the current pattern as a tag
-        void addTagPattern();
-
-        inline void addCharToPattern(char c) {
-            m_substring += c;
-            m_patternName += c;
-            m_realPatternPos++;
-        }
-
-    };
-    TestSpec parseTestSpec( std::string const& arg );
-
-} // namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_spec_parser.h
-// Libstdc++ doesn't like incomplete classes for unique_ptr
-
-#include <memory>
-#include <vector>
-#include <string>
-
-#ifndef CATCH_CONFIG_CONSOLE_WIDTH
-#define CATCH_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch {
-
-    struct IStream;
-
-    struct ConfigData {
-        bool listTests = false;
-        bool listTags = false;
-        bool listReporters = false;
-        bool listTestNamesOnly = false;
-
-        bool showSuccessfulTests = false;
-        bool shouldDebugBreak = false;
-        bool noThrow = false;
-        bool showHelp = false;
-        bool showInvisibles = false;
-        bool filenamesAsTags = false;
-        bool libIdentify = false;
-
-        int abortAfter = -1;
-        unsigned int rngSeed = 0;
-
-        bool benchmarkNoAnalysis = false;
-        unsigned int benchmarkSamples = 100;
-        double benchmarkConfidenceInterval = 0.95;
-        unsigned int benchmarkResamples = 100000;
-        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
-
-        Verbosity verbosity = Verbosity::Normal;
-        WarnAbout::What warnings = WarnAbout::Nothing;
-        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
-        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
-        UseColour::YesOrNo useColour = UseColour::Auto;
-        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
-
-        std::string outputFilename;
-        std::string name;
-        std::string processName;
-#ifndef CATCH_CONFIG_DEFAULT_REPORTER
-#define CATCH_CONFIG_DEFAULT_REPORTER "console"
-#endif
-        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
-#undef CATCH_CONFIG_DEFAULT_REPORTER
-
-        std::vector<std::string> testsOrTags;
-        std::vector<std::string> sectionsToRun;
-    };
-
-    class Config : public IConfig {
-    public:
-
-        Config() = default;
-        Config( ConfigData const& data );
-        virtual ~Config() = default;
-
-        std::string const& getFilename() const;
-
-        bool listTests() const;
-        bool listTestNamesOnly() const;
-        bool listTags() const;
-        bool listReporters() const;
-
-        std::string getProcessName() const;
-        std::string const& getReporterName() const;
-
-        std::vector<std::string> const& getTestsOrTags() const override;
-        std::vector<std::string> const& getSectionsToRun() const override;
-
-        TestSpec const& testSpec() const override;
-        bool hasTestFilters() const override;
-
-        bool showHelp() const;
-
-        // IConfig interface
-        bool allowThrows() const override;
-        std::ostream& stream() const override;
-        std::string name() const override;
-        bool includeSuccessfulResults() const override;
-        bool warnAboutMissingAssertions() const override;
-        bool warnAboutNoTests() const override;
-        ShowDurations::OrNot showDurations() const override;
-        RunTests::InWhatOrder runOrder() const override;
-        unsigned int rngSeed() const override;
-        UseColour::YesOrNo useColour() const override;
-        bool shouldDebugBreak() const override;
-        int abortAfter() const override;
-        bool showInvisibles() const override;
-        Verbosity verbosity() const override;
-        bool benchmarkNoAnalysis() const override;
-        int benchmarkSamples() const override;
-        double benchmarkConfidenceInterval() const override;
-        unsigned int benchmarkResamples() const override;
-        std::chrono::milliseconds benchmarkWarmupTime() const override;
-
-    private:
-
-        IStream const* openStream();
-        ConfigData m_data;
-
-        std::unique_ptr<IStream const> m_stream;
-        TestSpec m_testSpec;
-        bool m_hasTestFilters = false;
-    };
-
-} // end namespace Catch
-
-// end catch_config.hpp
-// start catch_assertionresult.h
-
-#include <string>
-
-namespace Catch {
-
-    struct AssertionResultData
-    {
-        AssertionResultData() = delete;
-
-        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
-
-        std::string message;
-        mutable std::string reconstructedExpression;
-        LazyExpression lazyExpression;
-        ResultWas::OfType resultType;
-
-        std::string reconstructExpression() const;
-    };
-
-    class AssertionResult {
-    public:
-        AssertionResult() = delete;
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
-
-        bool isOk() const;
-        bool succeeded() const;
-        ResultWas::OfType getResultType() const;
-        bool hasExpression() const;
-        bool hasMessage() const;
-        std::string getExpression() const;
-        std::string getExpressionInMacro() const;
-        bool hasExpandedExpression() const;
-        std::string getExpandedExpression() const;
-        std::string getMessage() const;
-        SourceLineInfo getSourceInfo() const;
-        StringRef getTestMacroName() const;
-
-    //protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
-    };
-
-} // end namespace Catch
-
-// end catch_assertionresult.h
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_estimate.hpp
-
- // Statistics estimates
-
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct Estimate {
-            Duration point;
-            Duration lower_bound;
-            Duration upper_bound;
-            double confidence_interval;
-
-            template <typename Duration2>
-            operator Estimate<Duration2>() const {
-                return { point, lower_bound, upper_bound, confidence_interval };
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_estimate.hpp
-// start catch_outlier_classification.hpp
-
-// Outlier information
-
-namespace Catch {
-    namespace Benchmark {
-        struct OutlierClassification {
-            int samples_seen = 0;
-            int low_severe = 0;     // more than 3 times IQR below Q1
-            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
-            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
-            int high_severe = 0;    // more than 3 times IQR above Q3
-
-            int total() const {
-                return low_severe + low_mild + high_mild + high_severe;
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_outlier_classification.hpp
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-#include <string>
-#include <iosfwd>
-#include <map>
-#include <set>
-#include <memory>
-#include <algorithm>
-
-namespace Catch {
-
-    struct ReporterConfig {
-        explicit ReporterConfig( IConfigPtr const& _fullConfig );
-
-        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
-
-        std::ostream& stream() const;
-        IConfigPtr fullConfig() const;
-
-    private:
-        std::ostream* m_stream;
-        IConfigPtr m_fullConfig;
-    };
-
-    struct ReporterPreferences {
-        bool shouldRedirectStdOut = false;
-        bool shouldReportAllAssertions = false;
-    };
-
-    template<typename T>
-    struct LazyStat : Option<T> {
-        LazyStat& operator=( T const& _value ) {
-            Option<T>::operator=( _value );
-            used = false;
-            return *this;
-        }
-        void reset() {
-            Option<T>::reset();
-            used = false;
-        }
-        bool used = false;
-    };
-
-    struct TestRunInfo {
-        TestRunInfo( std::string const& _name );
-        std::string name;
-    };
-    struct GroupInfo {
-        GroupInfo(  std::string const& _name,
-                    std::size_t _groupIndex,
-                    std::size_t _groupsCount );
-
-        std::string name;
-        std::size_t groupIndex;
-        std::size_t groupsCounts;
-    };
-
-    struct AssertionStats {
-        AssertionStats( AssertionResult const& _assertionResult,
-                        std::vector<MessageInfo> const& _infoMessages,
-                        Totals const& _totals );
-
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = delete;
-        AssertionStats& operator = ( AssertionStats && )     = delete;
-        virtual ~AssertionStats();
-
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
-
-    struct SectionStats {
-        SectionStats(   SectionInfo const& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions );
-        SectionStats( SectionStats const& )              = default;
-        SectionStats( SectionStats && )                  = default;
-        SectionStats& operator = ( SectionStats const& ) = default;
-        SectionStats& operator = ( SectionStats && )     = default;
-        virtual ~SectionStats();
-
-        SectionInfo sectionInfo;
-        Counts assertions;
-        double durationInSeconds;
-        bool missingAssertions;
-    };
-
-    struct TestCaseStats {
-        TestCaseStats(  TestCaseInfo const& _testInfo,
-                        Totals const& _totals,
-                        std::string const& _stdOut,
-                        std::string const& _stdErr,
-                        bool _aborting );
-
-        TestCaseStats( TestCaseStats const& )              = default;
-        TestCaseStats( TestCaseStats && )                  = default;
-        TestCaseStats& operator = ( TestCaseStats const& ) = default;
-        TestCaseStats& operator = ( TestCaseStats && )     = default;
-        virtual ~TestCaseStats();
-
-        TestCaseInfo testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
-    };
-
-    struct TestGroupStats {
-        TestGroupStats( GroupInfo const& _groupInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-        TestGroupStats( GroupInfo const& _groupInfo );
-
-        TestGroupStats( TestGroupStats const& )              = default;
-        TestGroupStats( TestGroupStats && )                  = default;
-        TestGroupStats& operator = ( TestGroupStats const& ) = default;
-        TestGroupStats& operator = ( TestGroupStats && )     = default;
-        virtual ~TestGroupStats();
-
-        GroupInfo groupInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-
-        TestRunStats( TestRunStats const& )              = default;
-        TestRunStats( TestRunStats && )                  = default;
-        TestRunStats& operator = ( TestRunStats const& ) = default;
-        TestRunStats& operator = ( TestRunStats && )     = default;
-        virtual ~TestRunStats();
-
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    struct BenchmarkInfo {
-        std::string name;
-        double estimatedDuration;
-        int iterations;
-        int samples;
-        unsigned int resamples;
-        double clockResolution;
-        double clockCost;
-    };
-
-    template <class Duration>
-    struct BenchmarkStats {
-        BenchmarkInfo info;
-
-        std::vector<Duration> samples;
-        Benchmark::Estimate<Duration> mean;
-        Benchmark::Estimate<Duration> standardDeviation;
-        Benchmark::OutlierClassification outliers;
-        double outlierVariance;
-
-        template <typename Duration2>
-        operator BenchmarkStats<Duration2>() const {
-            std::vector<Duration2> samples2;
-            samples2.reserve(samples.size());
-            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
-            return {
-                info,
-                std::move(samples2),
-                mean,
-                standardDeviation,
-                outliers,
-                outlierVariance,
-            };
-        }
-    };
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    struct IStreamingReporter {
-        virtual ~IStreamingReporter() = default;
-
-        // Implementing class must also provide the following static methods:
-        // static std::string getDescription();
-        // static std::set<Verbosity> getSupportedVerbosities()
-
-        virtual ReporterPreferences getPreferences() const = 0;
-
-        virtual void noMatchingTestCases( std::string const& spec ) = 0;
-
-        virtual void reportInvalidArguments(std::string const&) {}
-
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
-
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        virtual void benchmarkPreparing( std::string const& ) {}
-        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
-        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
-        virtual void benchmarkFailed( std::string const& ) {}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
-
-        // The return value indicates if the messages buffer should be cleared:
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
-
-        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
-        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
-
-        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
-
-        // Default empty implementation provided
-        virtual void fatalErrorEncountered( StringRef name );
-
-        virtual bool isMulti() const;
-    };
-    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
-
-    struct IReporterFactory {
-        virtual ~IReporterFactory();
-        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
-
-    struct IReporterRegistry {
-        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
-        using Listeners = std::vector<IReporterFactoryPtr>;
-
-        virtual ~IReporterRegistry();
-        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
-        virtual FactoryMap const& getFactories() const = 0;
-        virtual Listeners const& getListeners() const = 0;
-    };
-
-} // end namespace Catch
-
-// end catch_interfaces_reporter.h
-#include <algorithm>
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <cassert>
-#include <memory>
-#include <ostream>
-
-namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result);
-
-    // Returns double formatted as %.3f (format expected on output)
-    std::string getFormattedDuration( double duration );
-
-    std::string serializeFilters( std::vector<std::string> const& container );
-
-    template<typename DerivedT>
-    struct StreamingReporterBase : IStreamingReporter {
-
-        StreamingReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        ~StreamingReporterBase() override = default;
-
-        void noMatchingTestCases(std::string const&) override {}
-
-        void reportInvalidArguments(std::string const&) override {}
-
-        void testRunStarting(TestRunInfo const& _testRunInfo) override {
-            currentTestRunInfo = _testRunInfo;
-        }
-
-        void testGroupStarting(GroupInfo const& _groupInfo) override {
-            currentGroupInfo = _groupInfo;
-        }
-
-        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
-            currentTestCaseInfo = _testInfo;
-        }
-        void sectionStarting(SectionInfo const& _sectionInfo) override {
-            m_sectionStack.push_back(_sectionInfo);
-        }
-
-        void sectionEnded(SectionStats const& /* _sectionStats */) override {
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
-            currentTestCaseInfo.reset();
-        }
-        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
-            currentGroupInfo.reset();
-        }
-        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
-            currentTestCaseInfo.reset();
-            currentGroupInfo.reset();
-            currentTestRunInfo.reset();
-        }
-
-        void skipTest(TestCaseInfo const&) override {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-
-        LazyStat<TestRunInfo> currentTestRunInfo;
-        LazyStat<GroupInfo> currentGroupInfo;
-        LazyStat<TestCaseInfo> currentTestCaseInfo;
-
-        std::vector<SectionInfo> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    template<typename DerivedT>
-    struct CumulativeReporterBase : IStreamingReporter {
-        template<typename T, typename ChildNodeT>
-        struct Node {
-            explicit Node( T const& _value ) : value( _value ) {}
-            virtual ~Node() {}
-
-            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode {
-            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
-            virtual ~SectionNode() = default;
-
-            bool operator == (SectionNode const& other) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-            bool operator == (std::shared_ptr<SectionNode> const& other) const {
-                return operator==(*other);
-            }
-
-            SectionStats stats;
-            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
-            using Assertions = std::vector<AssertionStats>;
-            ChildSections childSections;
-            Assertions assertions;
-            std::string stdOut;
-            std::string stdErr;
-        };
-
-        struct BySectionInfo {
-            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
-            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
-            bool operator() (std::shared_ptr<SectionNode> const& node) const {
-                return ((node->stats.sectionInfo.name == m_other.name) &&
-                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
-            }
-            void operator=(BySectionInfo const&) = delete;
-
-        private:
-            SectionInfo const& m_other;
-        };
-
-        using TestCaseNode = Node<TestCaseStats, SectionNode>;
-        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
-        using TestRunNode = Node<TestRunStats, TestGroupNode>;
-
-        CumulativeReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-        ~CumulativeReporterBase() override = default;
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        void testRunStarting( TestRunInfo const& ) override {}
-        void testGroupStarting( GroupInfo const& ) override {}
-
-        void testCaseStarting( TestCaseInfo const& ) override {}
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
-            std::shared_ptr<SectionNode> node;
-            if( m_sectionStack.empty() ) {
-                if( !m_rootSection )
-                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
-                node = m_rootSection;
-            }
-            else {
-                SectionNode& parentNode = *m_sectionStack.back();
-                auto it =
-                    std::find_if(   parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-                if( it == parentNode.childSections.end() ) {
-                    node = std::make_shared<SectionNode>( incompleteStats );
-                    parentNode.childSections.push_back( node );
-                }
-                else
-                    node = *it;
-            }
-            m_sectionStack.push_back( node );
-            m_deepestSection = std::move(node);
-        }
-
-        void assertionStarting(AssertionInfo const&) override {}
-
-        bool assertionEnded(AssertionStats const& assertionStats) override {
-            assert(!m_sectionStack.empty());
-            // AssertionResult holds a pointer to a temporary DecomposedExpression,
-            // which getExpandedExpression() calls to build the expression string.
-            // Our section stack copy of the assertionResult will likely outlive the
-            // temporary, so it must be expanded or discarded now to avoid calling
-            // a destroyed object later.
-            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
-            SectionNode& sectionNode = *m_sectionStack.back();
-            sectionNode.assertions.push_back(assertionStats);
-            return true;
-        }
-        void sectionEnded(SectionStats const& sectionStats) override {
-            assert(!m_sectionStack.empty());
-            SectionNode& node = *m_sectionStack.back();
-            node.stats = sectionStats;
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& testCaseStats) override {
-            auto node = std::make_shared<TestCaseNode>(testCaseStats);
-            assert(m_sectionStack.size() == 0);
-            node->children.push_back(m_rootSection);
-            m_testCases.push_back(node);
-            m_rootSection.reset();
-
-            assert(m_deepestSection);
-            m_deepestSection->stdOut = testCaseStats.stdOut;
-            m_deepestSection->stdErr = testCaseStats.stdErr;
-        }
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            auto node = std::make_shared<TestGroupNode>(testGroupStats);
-            node->children.swap(m_testCases);
-            m_testGroups.push_back(node);
-        }
-        void testRunEnded(TestRunStats const& testRunStats) override {
-            auto node = std::make_shared<TestRunNode>(testRunStats);
-            node->children.swap(m_testGroups);
-            m_testRuns.push_back(node);
-            testRunEndedCumulative();
-        }
-        virtual void testRunEndedCumulative() = 0;
-
-        void skipTest(TestCaseInfo const&) override {}
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-        std::vector<AssertionStats> m_assertions;
-        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
-        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
-        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
-
-        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
-
-        std::shared_ptr<SectionNode> m_rootSection;
-        std::shared_ptr<SectionNode> m_deepestSection;
-        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    template<char C>
-    char const* getLineOfChars() {
-        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
-        if( !*line ) {
-            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
-            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
-        }
-        return line;
-    }
-
-    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
-        TestEventListenerBase( ReporterConfig const& _config );
-
-        static std::set<Verbosity> getSupportedVerbosities();
-
-        void assertionStarting(AssertionInfo const&) override;
-        bool assertionEnded(AssertionStats const&) override;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_bases.hpp
-// start catch_console_colour.h
-
-namespace Catch {
-
-    struct Colour {
-        enum Code {
-            None = 0,
-
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
-
-            Bright = 0x10,
-
-            BrightRed = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey = Bright | Grey,
-            BrightWhite = Bright | White,
-            BrightYellow = Bright | Yellow,
-
-            // By intention
-            FileName = LightGrey,
-            Warning = BrightYellow,
-            ResultError = BrightRed,
-            ResultSuccess = BrightGreen,
-            ResultExpectedFailure = Warning,
-
-            Error = BrightRed,
-            Success = Green,
-
-            OriginalExpression = Cyan,
-            ReconstructedExpression = BrightYellow,
-
-            SecondaryText = LightGrey,
-            Headers = White
-        };
-
-        // Use constructed object for RAII guard
-        Colour( Code _colourCode );
-        Colour( Colour&& other ) noexcept;
-        Colour& operator=( Colour&& other ) noexcept;
-        ~Colour();
-
-        // Use static method for one-shot changes
-        static void use( Code _colourCode );
-
-    private:
-        bool m_moved = false;
-    };
-
-    std::ostream& operator << ( std::ostream& os, Colour const& );
-
-} // end namespace Catch
-
-// end catch_console_colour.h
-// start catch_reporter_registrars.hpp
-
-
-namespace Catch {
-
-    template<typename T>
-    class ReporterRegistrar {
-
-        class ReporterFactory : public IReporterFactory {
-
-            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-
-            std::string getDescription() const override {
-                return T::getDescription();
-            }
-        };
-
-    public:
-
-        explicit ReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
-        }
-    };
-
-    template<typename T>
-    class ListenerRegistrar {
-
-        class ListenerFactory : public IReporterFactory {
-
-            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-            std::string getDescription() const override {
-                return std::string();
-            }
-        };
-
-    public:
-
-        ListenerRegistrar() {
-            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
-        }
-    };
-}
-
-#if !defined(CATCH_CONFIG_DISABLE)
-
-#define CATCH_REGISTER_REPORTER( name, reporterType ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION         \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
-    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#define CATCH_REGISTER_LISTENER( listenerType ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION   \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS    \
-    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-#else // CATCH_CONFIG_DISABLE
-
-#define CATCH_REGISTER_REPORTER(name, reporterType)
-#define CATCH_REGISTER_LISTENER(listenerType)
-
-#endif // CATCH_CONFIG_DISABLE
-
-// end catch_reporter_registrars.hpp
-// Allow users to base their work off existing reporters
-// start catch_reporter_compact.h
-
-namespace Catch {
-
-    struct CompactReporter : StreamingReporterBase<CompactReporter> {
-
-        using StreamingReporterBase::StreamingReporterBase;
-
-        ~CompactReporter() override;
-
-        static std::string getDescription();
-
-        ReporterPreferences getPreferences() const override;
-
-        void noMatchingTestCases(std::string const& spec) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void sectionEnded(SectionStats const& _sectionStats) override;
-
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_compact.h
-// start catch_reporter_console.h
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-    // Fwd decls
-    struct SummaryColumn;
-    class TablePrinter;
-
-    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
-        std::unique_ptr<TablePrinter> m_tablePrinter;
-
-        ConsoleReporter(ReporterConfig const& config);
-        ~ConsoleReporter() override;
-        static std::string getDescription();
-
-        void noMatchingTestCases(std::string const& spec) override;
-
-        void reportInvalidArguments(std::string const&arg) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void sectionStarting(SectionInfo const& _sectionInfo) override;
-        void sectionEnded(SectionStats const& _sectionStats) override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting(BenchmarkInfo const& info) override;
-        void benchmarkEnded(BenchmarkStats<> const& stats) override;
-        void benchmarkFailed(std::string const& error) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
-        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-        void testRunStarting(TestRunInfo const& _testRunInfo) override;
-    private:
-
-        void lazyPrint();
-
-        void lazyPrintWithoutClosingBenchmarkTable();
-        void lazyPrintRunInfo();
-        void lazyPrintGroupInfo();
-        void printTestCaseAndSectionHeader();
-
-        void printClosedHeader(std::string const& _name);
-        void printOpenHeader(std::string const& _name);
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString(std::string const& _string, std::size_t indent = 0);
-
-        void printTotals(Totals const& totals);
-        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
-
-        void printTotalsDivider(Totals const& totals);
-        void printSummaryDivider();
-        void printTestFilters();
-
-    private:
-        bool m_headerPrinted = false;
-    };
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-// end catch_reporter_console.h
-// start catch_reporter_junit.h
-
-// start catch_xmlwriter.h
-
-#include <vector>
-
-namespace Catch {
-    enum class XmlFormatting {
-        None = 0x00,
-        Indent = 0x01,
-        Newline = 0x02,
-    };
-
-    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
-    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
-
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
-
-        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
-
-        void encodeTo( std::ostream& os ) const;
-
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
-
-    private:
-        std::string m_str;
-        ForWhat m_forWhat;
-    };
-
-    class XmlWriter {
-    public:
-
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
-
-            ScopedElement( ScopedElement&& other ) noexcept;
-            ScopedElement& operator=( ScopedElement&& other ) noexcept;
-
-            ~ScopedElement();
-
-            ScopedElement& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent );
-
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
-            }
-
-        private:
-            mutable XmlWriter* m_writer = nullptr;
-            XmlFormatting m_fmt;
-        };
-
-        XmlWriter( std::ostream& os = Catch::cout() );
-        ~XmlWriter();
-
-        XmlWriter( XmlWriter const& ) = delete;
-        XmlWriter& operator=( XmlWriter const& ) = delete;
-
-        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
-
-        XmlWriter& writeAttribute( std::string const& name, bool attribute );
-
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-            ReusableStringStream rss;
-            rss << attribute;
-            return writeAttribute( name, rss.str() );
-        }
-
-        XmlWriter& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& writeComment(std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        void writeStylesheetRef( std::string const& url );
-
-        XmlWriter& writeBlankLine();
-
-        void ensureTagClosed();
-
-    private:
-
-        void applyFormatting(XmlFormatting fmt);
-
-        void writeDeclaration();
-
-        void newlineIfNecessary();
-
-        bool m_tagIsOpen = false;
-        bool m_needsNewline = false;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-    };
-
-}
-
-// end catch_xmlwriter.h
-namespace Catch {
-
-    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
-    public:
-        JunitReporter(ReporterConfig const& _config);
-
-        ~JunitReporter() override;
-
-        static std::string getDescription();
-
-        void noMatchingTestCases(std::string const& /*spec*/) override;
-
-        void testRunStarting(TestRunInfo const& runInfo) override;
-
-        void testGroupStarting(GroupInfo const& groupInfo) override;
-
-        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
-        bool assertionEnded(AssertionStats const& assertionStats) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
-
-        void testRunEndedCumulative() override;
-
-        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
-
-        void writeTestCase(TestCaseNode const& testCaseNode);
-
-        void writeSection(std::string const& className,
-                          std::string const& rootName,
-                          SectionNode const& sectionNode);
-
-        void writeAssertions(SectionNode const& sectionNode);
-        void writeAssertion(AssertionStats const& stats);
-
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::string stdOutForSuite;
-        std::string stdErrForSuite;
-        unsigned int unexpectedExceptions = 0;
-        bool m_okToFail = false;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_junit.h
-// start catch_reporter_xml.h
-
-namespace Catch {
-    class XmlReporter : public StreamingReporterBase<XmlReporter> {
-    public:
-        XmlReporter(ReporterConfig const& _config);
-
-        ~XmlReporter() override;
-
-        static std::string getDescription();
-
-        virtual std::string getStylesheetRef() const;
-
-        void writeSourceInfo(SourceLineInfo const& sourceInfo);
-
-    public: // StreamingReporterBase
-
-        void noMatchingTestCases(std::string const& s) override;
-
-        void testRunStarting(TestRunInfo const& testInfo) override;
-
-        void testGroupStarting(GroupInfo const& groupInfo) override;
-
-        void testCaseStarting(TestCaseInfo const& testInfo) override;
-
-        void sectionStarting(SectionInfo const& sectionInfo) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& assertionStats) override;
-
-        void sectionEnded(SectionStats const& sectionStats) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
-
-        void testRunEnded(TestRunStats const& testRunStats) override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting(BenchmarkInfo const&) override;
-        void benchmarkEnded(BenchmarkStats<> const&) override;
-        void benchmarkFailed(std::string const&) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    private:
-        Timer m_testCaseTimer;
-        XmlWriter m_xml;
-        int m_sectionDepth = 0;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_xml.h
-
-// end catch_external_interfaces.h
-#endif
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_benchmarking_all.hpp
-
-// A proxy header that includes all of the benchmarking headers to allow
-// concise include of the benchmarking features. You should prefer the
-// individual includes in standard use.
-
-// start catch_benchmark.hpp
-
- // Benchmark
-
-// start catch_chronometer.hpp
-
-// User-facing chronometer
-
-
-// start catch_clock.hpp
-
-// Clocks
-
-
-#include <chrono>
-#include <ratio>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Clock>
-        using ClockDuration = typename Clock::duration;
-        template <typename Clock>
-        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
-
-        template <typename Clock>
-        using TimePoint = typename Clock::time_point;
-
-        using default_clock = std::chrono::steady_clock;
-
-        template <typename Clock>
-        struct now {
-            TimePoint<Clock> operator()() const {
-                return Clock::now();
-            }
-        };
-
-        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_clock.hpp
-// start catch_optimizer.hpp
-
- // Hinting the optimizer
-
-
-#if defined(_MSC_VER)
-#   include <atomic> // atomic_thread_fence
-#endif
-
-namespace Catch {
-    namespace Benchmark {
-#if defined(__GNUC__) || defined(__clang__)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            asm volatile("" : : "g"(p) : "memory");
-        }
-        inline void keep_memory() {
-            asm volatile("" : : : "memory");
-        }
-
-        namespace Detail {
-            inline void optimizer_barrier() { keep_memory(); }
-        } // namespace Detail
-#elif defined(_MSC_VER)
-
-#pragma optimize("", off)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            // thanks @milleniumbug
-            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
-        }
-        // TODO equivalent keep_memory()
-#pragma optimize("", on)
-
-        namespace Detail {
-            inline void optimizer_barrier() {
-                std::atomic_thread_fence(std::memory_order_seq_cst);
-            }
-        } // namespace Detail
-
-#endif
-
-        template <typename T>
-        inline void deoptimize_value(T&& x) {
-            keep_memory(&x);
-        }
-
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
-            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
-        }
-
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
-            std::forward<Fn>(fn) (std::forward<Args...>(args...));
-        }
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_optimizer.hpp
-// start catch_complete_invoke.hpp
-
-// Invoke with a special case for void
-
-
-#include <type_traits>
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            struct CompleteType { using type = T; };
-            template <>
-            struct CompleteType<void> { struct type {}; };
-
-            template <typename T>
-            using CompleteType_t = typename CompleteType<T>::type;
-
-            template <typename Result>
-            struct CompleteInvoker {
-                template <typename Fun, typename... Args>
-                static Result invoke(Fun&& fun, Args&&... args) {
-                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
-                }
-            };
-            template <>
-            struct CompleteInvoker<void> {
-                template <typename Fun, typename... Args>
-                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
-                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
-                    return {};
-                }
-            };
-            template <typename Sig>
-            using ResultOf_t = typename std::result_of<Sig>::type;
-
-            // invoke and not return void :(
-            template <typename Fun, typename... Args>
-            CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun&& fun, Args&&... args) {
-                return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
-            }
-
-            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
-        } // namespace Detail
-
-        template <typename Fun>
-        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
-            CATCH_TRY{
-                return Detail::complete_invoke(std::forward<Fun>(fun));
-            } CATCH_CATCH_ALL{
-                getResultCapture().benchmarkFailed(translateActiveException());
-                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
-            }
-        }
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_complete_invoke.hpp
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            struct ChronometerConcept {
-                virtual void start() = 0;
-                virtual void finish() = 0;
-                virtual ~ChronometerConcept() = default;
-            };
-            template <typename Clock>
-            struct ChronometerModel final : public ChronometerConcept {
-                void start() override { started = Clock::now(); }
-                void finish() override { finished = Clock::now(); }
-
-                ClockDuration<Clock> elapsed() const { return finished - started; }
-
-                TimePoint<Clock> started;
-                TimePoint<Clock> finished;
-            };
-        } // namespace Detail
-
-        struct Chronometer {
-        public:
-            template <typename Fun>
-            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
-
-            int runs() const { return k; }
-
-            Chronometer(Detail::ChronometerConcept& meter, int k)
-                : impl(&meter)
-                , k(k) {}
-
-        private:
-            template <typename Fun>
-            void measure(Fun&& fun, std::false_type) {
-                measure([&fun](int) { return fun(); }, std::true_type());
-            }
-
-            template <typename Fun>
-            void measure(Fun&& fun, std::true_type) {
-                Detail::optimizer_barrier();
-                impl->start();
-                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
-                impl->finish();
-                Detail::optimizer_barrier();
-            }
-
-            Detail::ChronometerConcept* impl;
-            int k;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_chronometer.hpp
-// start catch_environment.hpp
-
-// Environment information
-
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct EnvironmentEstimate {
-            Duration mean;
-            OutlierClassification outliers;
-
-            template <typename Duration2>
-            operator EnvironmentEstimate<Duration2>() const {
-                return { mean, outliers };
-            }
-        };
-        template <typename Clock>
-        struct Environment {
-            using clock_type = Clock;
-            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
-            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_environment.hpp
-// start catch_execution_plan.hpp
-
- // Execution plan
-
-
-// start catch_benchmark_function.hpp
-
- // Dumb std::function implementation for consistent call overhead
-
-
-#include <cassert>
-#include <type_traits>
-#include <utility>
-#include <memory>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            using Decay = typename std::decay<T>::type;
-            template <typename T, typename U>
-            struct is_related
-                : std::is_same<Decay<T>, Decay<U>> {};
-
-            /// We need to reinvent std::function because every piece of code that might add overhead
-            /// in a measurement context needs to have consistent performance characteristics so that we
-            /// can account for it in the measurement.
-            /// Implementations of std::function with optimizations that aren't always applicable, like
-            /// small buffer optimizations, are not uncommon.
-            /// This is effectively an implementation of std::function without any such optimizations;
-            /// it may be slow, but it is consistently slow.
-            struct BenchmarkFunction {
-            private:
-                struct callable {
-                    virtual void call(Chronometer meter) const = 0;
-                    virtual callable* clone() const = 0;
-                    virtual ~callable() = default;
-                };
-                template <typename Fun>
-                struct model : public callable {
-                    model(Fun&& fun) : fun(std::move(fun)) {}
-                    model(Fun const& fun) : fun(fun) {}
-
-                    model<Fun>* clone() const override { return new model<Fun>(*this); }
-
-                    void call(Chronometer meter) const override {
-                        call(meter, is_callable<Fun(Chronometer)>());
-                    }
-                    void call(Chronometer meter, std::true_type) const {
-                        fun(meter);
-                    }
-                    void call(Chronometer meter, std::false_type) const {
-                        meter.measure(fun);
-                    }
-
-                    Fun fun;
-                };
-
-                struct do_nothing { void operator()() const {} };
-
-                template <typename T>
-                BenchmarkFunction(model<T>* c) : f(c) {}
-
-            public:
-                BenchmarkFunction()
-                    : f(new model<do_nothing>{ {} }) {}
-
-                template <typename Fun,
-                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
-                    BenchmarkFunction(Fun&& fun)
-                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
-
-                BenchmarkFunction(BenchmarkFunction&& that)
-                    : f(std::move(that.f)) {}
-
-                BenchmarkFunction(BenchmarkFunction const& that)
-                    : f(that.f->clone()) {}
-
-                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
-                    f = std::move(that.f);
-                    return *this;
-                }
-
-                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
-                    f.reset(that.f->clone());
-                    return *this;
-                }
-
-                void operator()(Chronometer meter) const { f->call(meter); }
-
-            private:
-                std::unique_ptr<callable> f;
-            };
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_benchmark_function.hpp
-// start catch_repeat.hpp
-
-// repeat algorithm
-
-
-#include <type_traits>
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Fun>
-            struct repeater {
-                void operator()(int k) const {
-                    for (int i = 0; i < k; ++i) {
-                        fun();
-                    }
-                }
-                Fun fun;
-            };
-            template <typename Fun>
-            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
-                return { std::forward<Fun>(fun) };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_repeat.hpp
-// start catch_run_for_at_least.hpp
-
-// Run a function for a minimum amount of time
-
-
-// start catch_measure.hpp
-
-// Measure
-
-
-// start catch_timing.hpp
-
-// Timing
-
-
-#include <tuple>
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration, typename Result>
-        struct Timing {
-            Duration elapsed;
-            Result result;
-            int iterations;
-        };
-        template <typename Clock, typename Sig>
-        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_timing.hpp
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun, typename... Args>
-            TimingOf<Clock, Fun(Args...)> measure(Fun&& fun, Args&&... args) {
-                auto start = Clock::now();
-                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
-                auto end = Clock::now();
-                auto delta = end - start;
-                return { delta, std::forward<decltype(r)>(r), 1 };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_measure.hpp
-#include <utility>
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(int)> measure_one(Fun&& fun, int iters, std::false_type) {
-                return Detail::measure<Clock>(fun, iters);
-            }
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(Chronometer)> measure_one(Fun&& fun, int iters, std::true_type) {
-                Detail::ChronometerModel<Clock> meter;
-                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
-
-                return { meter.elapsed(), std::move(result), iters };
-            }
-
-            template <typename Clock, typename Fun>
-            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
-
-            struct optimized_away_error : std::exception {
-                const char* what() const noexcept override {
-                    return "could not measure benchmark, maybe it was optimized away";
-                }
-            };
-
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
-                auto iters = seed;
-                while (iters < (1 << 30)) {
-                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
-
-                    if (Timing.elapsed >= how_long) {
-                        return { Timing.elapsed, std::move(Timing.result), iters };
-                    }
-                    iters *= 2;
-                }
-                throw optimized_away_error{};
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_run_for_at_least.hpp
-#include <algorithm>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct ExecutionPlan {
-            int iterations_per_sample;
-            Duration estimated_duration;
-            Detail::BenchmarkFunction benchmark;
-            Duration warmup_time;
-            int warmup_iterations;
-
-            template <typename Duration2>
-            operator ExecutionPlan<Duration2>() const {
-                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
-            }
-
-            template <typename Clock>
-            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
-                // warmup a bit
-                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
-
-                std::vector<FloatDuration<Clock>> times;
-                times.reserve(cfg.benchmarkSamples());
-                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
-                    Detail::ChronometerModel<Clock> model;
-                    this->benchmark(Chronometer(model, iterations_per_sample));
-                    auto sample_time = model.elapsed() - env.clock_cost.mean;
-                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
-                    return sample_time / iterations_per_sample;
-                });
-                return times;
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_execution_plan.hpp
-// start catch_estimate_clock.hpp
-
- // Environment measurement
-
-
-// start catch_stats.hpp
-
-// Statistical analysis tools
-
-
-#include <algorithm>
-#include <functional>
-#include <vector>
-#include <iterator>
-#include <numeric>
-#include <tuple>
-#include <cmath>
-#include <utility>
-#include <cstddef>
-#include <random>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            using sample = std::vector<double>;
-
-            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
-
-            template <typename Iterator>
-            OutlierClassification classify_outliers(Iterator first, Iterator last) {
-                std::vector<double> copy(first, last);
-
-                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
-                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
-                auto iqr = q3 - q1;
-                auto los = q1 - (iqr * 3.);
-                auto lom = q1 - (iqr * 1.5);
-                auto him = q3 + (iqr * 1.5);
-                auto his = q3 + (iqr * 3.);
-
-                OutlierClassification o;
-                for (; first != last; ++first) {
-                    auto&& t = *first;
-                    if (t < los) ++o.low_severe;
-                    else if (t < lom) ++o.low_mild;
-                    else if (t > his) ++o.high_severe;
-                    else if (t > him) ++o.high_mild;
-                    ++o.samples_seen;
-                }
-                return o;
-            }
-
-            template <typename Iterator>
-            double mean(Iterator first, Iterator last) {
-                auto count = last - first;
-                double sum = std::accumulate(first, last, 0.);
-                return sum / count;
-            }
-
-            template <typename URng, typename Iterator, typename Estimator>
-            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
-                auto n = last - first;
-                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
-
-                sample out;
-                out.reserve(resamples);
-                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
-                    std::vector<double> resampled;
-                    resampled.reserve(n);
-                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
-                    return estimator(resampled.begin(), resampled.end());
-                });
-                std::sort(out.begin(), out.end());
-                return out;
-            }
-
-            template <typename Estimator, typename Iterator>
-            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
-                auto n = last - first;
-                auto second = std::next(first);
-                sample results;
-                results.reserve(n);
-
-                for (auto it = first; it != last; ++it) {
-                    std::iter_swap(it, first);
-                    results.push_back(estimator(second, last));
-                }
-
-                return results;
-            }
-
-            inline double normal_cdf(double x) {
-                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
-            }
-
-            double erfc_inv(double x);
-
-            double normal_quantile(double p);
-
-            template <typename Iterator, typename Estimator>
-            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
-                auto n_samples = last - first;
-
-                double point = estimator(first, last);
-                // Degenerate case with a single sample
-                if (n_samples == 1) return { point, point, point, confidence_level };
-
-                sample jack = jackknife(estimator, first, last);
-                double jack_mean = mean(jack.begin(), jack.end());
-                double sum_squares, sum_cubes;
-                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
-                    auto d = jack_mean - x;
-                    auto d2 = d * d;
-                    auto d3 = d2 * d;
-                    return { sqcb.first + d2, sqcb.second + d3 };
-                });
-
-                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
-                int n = static_cast<int>(resample.size());
-                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
-                // degenerate case with uniform samples
-                if (prob_n == 0) return { point, point, point, confidence_level };
-
-                double bias = normal_quantile(prob_n);
-                double z1 = normal_quantile((1. - confidence_level) / 2.);
-
-                auto cumn = [n](double x) -> int {
-                    return std::lround(normal_cdf(x) * n); };
-                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
-                double b1 = bias + z1;
-                double b2 = bias - z1;
-                double a1 = a(b1);
-                double a2 = a(b2);
-                auto lo = std::max(cumn(a1), 0);
-                auto hi = std::min(cumn(a2), n - 1);
-
-                return { point, resample[lo], resample[hi], confidence_level };
-            }
-
-            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
-
-            struct bootstrap_analysis {
-                Estimate<double> mean;
-                Estimate<double> standard_deviation;
-                double outlier_variance;
-            };
-
-            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_stats.hpp
-#include <algorithm>
-#include <iterator>
-#include <tuple>
-#include <vector>
-#include <cmath>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock>
-            std::vector<double> resolution(int k) {
-                std::vector<TimePoint<Clock>> times;
-                times.reserve(k + 1);
-                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
-
-                std::vector<double> deltas;
-                deltas.reserve(k);
-                std::transform(std::next(times.begin()), times.end(), times.begin(),
-                    std::back_inserter(deltas),
-                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
-
-                return deltas;
-            }
-
-            const auto warmup_iterations = 10000;
-            const auto warmup_time = std::chrono::milliseconds(100);
-            const auto minimum_ticks = 1000;
-            const auto warmup_seed = 10000;
-            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
-            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
-            const auto clock_cost_estimation_tick_limit = 100000;
-            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
-            const auto clock_cost_estimation_iterations = 10000;
-
-            template <typename Clock>
-            int warmup() {
-                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
-                    .iterations;
-            }
-            template <typename Clock>
-            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
-                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
-                    .result;
-                return {
-                    FloatDuration<Clock>(mean(r.begin(), r.end())),
-                    classify_outliers(r.begin(), r.end()),
-                };
-            }
-            template <typename Clock>
-            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
-                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));
-                auto time_clock = [](int k) {
-                    return Detail::measure<Clock>([k] {
-                        for (int i = 0; i < k; ++i) {
-                            volatile auto ignored = Clock::now();
-                            (void)ignored;
-                        }
-                    }).elapsed;
-                };
-                time_clock(1);
-                int iters = clock_cost_estimation_iterations;
-                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
-                std::vector<double> times;
-                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
-                times.reserve(nsamples);
-                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
-                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
-                });
-                return {
-                    FloatDuration<Clock>(mean(times.begin(), times.end())),
-                    classify_outliers(times.begin(), times.end()),
-                };
-            }
-
-            template <typename Clock>
-            Environment<FloatDuration<Clock>> measure_environment() {
-                static Environment<FloatDuration<Clock>>* env = nullptr;
-                if (env) {
-                    return *env;
-                }
-
-                auto iters = Detail::warmup<Clock>();
-                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
-                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
-
-                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
-                return *env;
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_estimate_clock.hpp
-// start catch_analyse.hpp
-
- // Run and analyse one benchmark
-
-
-// start catch_sample_analysis.hpp
-
-// Benchmark results
-
-
-#include <algorithm>
-#include <vector>
-#include <string>
-#include <iterator>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct SampleAnalysis {
-            std::vector<Duration> samples;
-            Estimate<Duration> mean;
-            Estimate<Duration> standard_deviation;
-            OutlierClassification outliers;
-            double outlier_variance;
-
-            template <typename Duration2>
-            operator SampleAnalysis<Duration2>() const {
-                std::vector<Duration2> samples2;
-                samples2.reserve(samples.size());
-                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
-                return {
-                    std::move(samples2),
-                    mean,
-                    standard_deviation,
-                    outliers,
-                    outlier_variance,
-                };
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_sample_analysis.hpp
-#include <algorithm>
-#include <iterator>
-#include <vector>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Duration, typename Iterator>
-            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
-                if (!cfg.benchmarkNoAnalysis()) {
-                    std::vector<double> samples;
-                    samples.reserve(last - first);
-                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
-
-                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
-                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
-
-                    auto wrap_estimate = [](Estimate<double> e) {
-                        return Estimate<Duration> {
-                            Duration(e.point),
-                                Duration(e.lower_bound),
-                                Duration(e.upper_bound),
-                                e.confidence_interval,
-                        };
-                    };
-                    std::vector<Duration> samples2;
-                    samples2.reserve(samples.size());
-                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
-                    return {
-                        std::move(samples2),
-                        wrap_estimate(analysis.mean),
-                        wrap_estimate(analysis.standard_deviation),
-                        outliers,
-                        analysis.outlier_variance,
-                    };
-                } else {
-                    std::vector<Duration> samples;
-                    samples.reserve(last - first);
-
-                    Duration mean = Duration(0);
-                    int i = 0;
-                    for (auto it = first; it < last; ++it, ++i) {
-                        samples.push_back(Duration(*it));
-                        mean += Duration(*it);
-                    }
-                    mean /= i;
-
-                    return {
-                        std::move(samples),
-                        Estimate<Duration>{mean, mean, mean, 0.0},
-                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
-                        OutlierClassification{},
-                        0.0
-                    };
-                }
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_analyse.hpp
-#include <algorithm>
-#include <functional>
-#include <string>
-#include <vector>
-#include <cmath>
-
-namespace Catch {
-    namespace Benchmark {
-        struct Benchmark {
-            Benchmark(std::string &&name)
-                : name(std::move(name)) {}
-
-            template <class FUN>
-            Benchmark(std::string &&name, FUN &&func)
-                : fun(std::move(func)), name(std::move(name)) {}
-
-            template <typename Clock>
-            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
-                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
-                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
-                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
-                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
-                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
-            }
-
-            template <typename Clock = default_clock>
-            void run() {
-                IConfigPtr cfg = getCurrentContext().getConfig();
-
-                auto env = Detail::measure_environment<Clock>();
-
-                getResultCapture().benchmarkPreparing(name);
-                CATCH_TRY{
-                    auto plan = user_code([&] {
-                        return prepare<Clock>(*cfg, env);
-                    });
-
-                    BenchmarkInfo info {
-                        name,
-                        plan.estimated_duration.count(),
-                        plan.iterations_per_sample,
-                        cfg->benchmarkSamples(),
-                        cfg->benchmarkResamples(),
-                        env.clock_resolution.mean.count(),
-                        env.clock_cost.mean.count()
-                    };
-
-                    getResultCapture().benchmarkStarting(info);
-
-                    auto samples = user_code([&] {
-                        return plan.template run<Clock>(*cfg, env);
-                    });
-
-                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
-                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
-                    getResultCapture().benchmarkEnded(stats);
-
-                } CATCH_CATCH_ALL{
-                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
-                        std::rethrow_exception(std::current_exception());
-                }
-            }
-
-            // sets lambda to be used in fun *and* executes benchmark!
-            template <typename Fun,
-                typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
-                Benchmark & operator=(Fun func) {
-                fun = Detail::BenchmarkFunction(func);
-                run();
-                return *this;
-            }
-
-            explicit operator bool() {
-                return true;
-            }
-
-        private:
-            Detail::BenchmarkFunction fun;
-            std::string name;
-        };
-    }
-} // namespace Catch
-
-#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
-#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
-
-#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&](int benchmarkIndex)
-
-#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&]
-
-// end catch_benchmark.hpp
-// start catch_constructor.hpp
-
-// Constructor and destructor helpers
-
-
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T, bool Destruct>
-            struct ObjectStorage
-            {
-                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
-
-                ObjectStorage() : data() {}
-
-                ObjectStorage(const ObjectStorage& other)
-                {
-                    new(&data) T(other.stored_object());
-                }
-
-                ObjectStorage(ObjectStorage&& other)
-                {
-                    new(&data) T(std::move(other.stored_object()));
-                }
-
-                ~ObjectStorage() { destruct_on_exit<T>(); }
-
-                template <typename... Args>
-                void construct(Args&&... args)
-                {
-                    new (&data) T(std::forward<Args>(args)...);
-                }
-
-                template <bool AllowManualDestruction = !Destruct>
-                typename std::enable_if<AllowManualDestruction>::type destruct()
-                {
-                    stored_object().~T();
-                }
-
-            private:
-                // If this is a constructor benchmark, destruct the underlying object
-                template <typename U>
-                void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
-                // Otherwise, don't
-                template <typename U>
-                void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
-
-                T& stored_object() {
-                    return *static_cast<T*>(static_cast<void*>(&data));
-                }
-
-                T const& stored_object() const {
-                    return *static_cast<T*>(static_cast<void*>(&data));
-                }
-
-                TStorage data;
-            };
-        }
-
-        template <typename T>
-        using storage_for = Detail::ObjectStorage<T, true>;
-
-        template <typename T>
-        using destructable_object = Detail::ObjectStorage<T, false>;
-    }
-}
-
-// end catch_constructor.hpp
-// end catch_benchmarking_all.hpp
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
-#ifdef CATCH_IMPL
-// start catch_impl.hpp
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
-// Keep these here for external reporters
-// start catch_test_case_tracker.h
-
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    struct NameAndLocation {
-        std::string name;
-        SourceLineInfo location;
-
-        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
-    };
-
-    struct ITracker;
-
-    using ITrackerPtr = std::shared_ptr<ITracker>;
-
-    struct ITracker {
-        virtual ~ITracker();
-
-        // static queries
-        virtual NameAndLocation const& nameAndLocation() const = 0;
-
-        // dynamic queries
-        virtual bool isComplete() const = 0; // Successfully completed or failed
-        virtual bool isSuccessfullyCompleted() const = 0;
-        virtual bool isOpen() const = 0; // Started but not complete
-        virtual bool hasChildren() const = 0;
-
-        virtual ITracker& parent() = 0;
-
-        // actions
-        virtual void close() = 0; // Successfully complete
-        virtual void fail() = 0;
-        virtual void markAsNeedingAnotherRun() = 0;
-
-        virtual void addChild( ITrackerPtr const& child ) = 0;
-        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
-        virtual void openChild() = 0;
-
-        // Debug/ checking
-        virtual bool isSectionTracker() const = 0;
-        virtual bool isGeneratorTracker() const = 0;
-    };
-
-    class TrackerContext {
-
-        enum RunState {
-            NotStarted,
-            Executing,
-            CompletedCycle
-        };
-
-        ITrackerPtr m_rootTracker;
-        ITracker* m_currentTracker = nullptr;
-        RunState m_runState = NotStarted;
-
-    public:
-
-        ITracker& startRun();
-        void endRun();
-
-        void startCycle();
-        void completeCycle();
-
-        bool completedCycle() const;
-        ITracker& currentTracker();
-        void setCurrentTracker( ITracker* tracker );
-    };
-
-    class TrackerBase : public ITracker {
-    protected:
-        enum CycleState {
-            NotStarted,
-            Executing,
-            ExecutingChildren,
-            NeedsAnotherRun,
-            CompletedSuccessfully,
-            Failed
-        };
-
-        using Children = std::vector<ITrackerPtr>;
-        NameAndLocation m_nameAndLocation;
-        TrackerContext& m_ctx;
-        ITracker* m_parent;
-        Children m_children;
-        CycleState m_runState = NotStarted;
-
-    public:
-        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-
-        NameAndLocation const& nameAndLocation() const override;
-        bool isComplete() const override;
-        bool isSuccessfullyCompleted() const override;
-        bool isOpen() const override;
-        bool hasChildren() const override;
-
-        void addChild( ITrackerPtr const& child ) override;
-
-        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
-        ITracker& parent() override;
-
-        void openChild() override;
-
-        bool isSectionTracker() const override;
-        bool isGeneratorTracker() const override;
-
-        void open();
-
-        void close() override;
-        void fail() override;
-        void markAsNeedingAnotherRun() override;
-
-    private:
-        void moveToParent();
-        void moveToThis();
-    };
-
-    class SectionTracker : public TrackerBase {
-        std::vector<std::string> m_filters;
-        std::string m_trimmed_name;
-    public:
-        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-
-        bool isSectionTracker() const override;
-
-        bool isComplete() const override;
-
-        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
-
-        void tryOpen();
-
-        void addInitialFilters( std::vector<std::string> const& filters );
-        void addNextFilters( std::vector<std::string> const& filters );
-    };
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-
-} // namespace Catch
-
-// end catch_test_case_tracker.h
-
-// start catch_leak_detector.h
-
-namespace Catch {
-
-    struct LeakDetector {
-        LeakDetector();
-        ~LeakDetector();
-    };
-
-}
-// end catch_leak_detector.h
-// Cpp files will be included in the single-header file here
-// start catch_stats.cpp
-
-// Statistical analysis tools
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-
-#include <cassert>
-#include <random>
-
-#if defined(CATCH_CONFIG_USE_ASYNC)
-#include <future>
-#endif
-
-namespace {
-    double erf_inv(double x) {
-        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
-        double w, p;
-
-        w = -log((1.0 - x) * (1.0 + x));
-
-        if (w < 6.250000) {
-            w = w - 3.125000;
-            p = -3.6444120640178196996e-21;
-            p = -1.685059138182016589e-19 + p * w;
-            p = 1.2858480715256400167e-18 + p * w;
-            p = 1.115787767802518096e-17 + p * w;
-            p = -1.333171662854620906e-16 + p * w;
-            p = 2.0972767875968561637e-17 + p * w;
-            p = 6.6376381343583238325e-15 + p * w;
-            p = -4.0545662729752068639e-14 + p * w;
-            p = -8.1519341976054721522e-14 + p * w;
-            p = 2.6335093153082322977e-12 + p * w;
-            p = -1.2975133253453532498e-11 + p * w;
-            p = -5.4154120542946279317e-11 + p * w;
-            p = 1.051212273321532285e-09 + p * w;
-            p = -4.1126339803469836976e-09 + p * w;
-            p = -2.9070369957882005086e-08 + p * w;
-            p = 4.2347877827932403518e-07 + p * w;
-            p = -1.3654692000834678645e-06 + p * w;
-            p = -1.3882523362786468719e-05 + p * w;
-            p = 0.0001867342080340571352 + p * w;
-            p = -0.00074070253416626697512 + p * w;
-            p = -0.0060336708714301490533 + p * w;
-            p = 0.24015818242558961693 + p * w;
-            p = 1.6536545626831027356 + p * w;
-        } else if (w < 16.000000) {
-            w = sqrt(w) - 3.250000;
-            p = 2.2137376921775787049e-09;
-            p = 9.0756561938885390979e-08 + p * w;
-            p = -2.7517406297064545428e-07 + p * w;
-            p = 1.8239629214389227755e-08 + p * w;
-            p = 1.5027403968909827627e-06 + p * w;
-            p = -4.013867526981545969e-06 + p * w;
-            p = 2.9234449089955446044e-06 + p * w;
-            p = 1.2475304481671778723e-05 + p * w;
-            p = -4.7318229009055733981e-05 + p * w;
-            p = 6.8284851459573175448e-05 + p * w;
-            p = 2.4031110387097893999e-05 + p * w;
-            p = -0.0003550375203628474796 + p * w;
-            p = 0.00095328937973738049703 + p * w;
-            p = -0.0016882755560235047313 + p * w;
-            p = 0.0024914420961078508066 + p * w;
-            p = -0.0037512085075692412107 + p * w;
-            p = 0.005370914553590063617 + p * w;
-            p = 1.0052589676941592334 + p * w;
-            p = 3.0838856104922207635 + p * w;
-        } else {
-            w = sqrt(w) - 5.000000;
-            p = -2.7109920616438573243e-11;
-            p = -2.5556418169965252055e-10 + p * w;
-            p = 1.5076572693500548083e-09 + p * w;
-            p = -3.7894654401267369937e-09 + p * w;
-            p = 7.6157012080783393804e-09 + p * w;
-            p = -1.4960026627149240478e-08 + p * w;
-            p = 2.9147953450901080826e-08 + p * w;
-            p = -6.7711997758452339498e-08 + p * w;
-            p = 2.2900482228026654717e-07 + p * w;
-            p = -9.9298272942317002539e-07 + p * w;
-            p = 4.5260625972231537039e-06 + p * w;
-            p = -1.9681778105531670567e-05 + p * w;
-            p = 7.5995277030017761139e-05 + p * w;
-            p = -0.00021503011930044477347 + p * w;
-            p = -0.00013871931833623122026 + p * w;
-            p = 1.0103004648645343977 + p * w;
-            p = 4.8499064014085844221 + p * w;
-        }
-        return p * x;
-    }
-
-    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
-        auto m = Catch::Benchmark::Detail::mean(first, last);
-        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
-            double diff = b - m;
-            return a + diff * diff;
-            }) / (last - first);
-            return std::sqrt(variance);
-    }
-
-}
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-
-            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                auto count = last - first;
-                double idx = (count - 1) * k / static_cast<double>(q);
-                int j = static_cast<int>(idx);
-                double g = idx - j;
-                std::nth_element(first, first + j, last);
-                auto xj = first[j];
-                if (g == 0) return xj;
-
-                auto xj1 = *std::min_element(first + (j + 1), last);
-                return xj + g * (xj1 - xj);
-            }
-
-            double erfc_inv(double x) {
-                return erf_inv(1.0 - x);
-            }
-
-            double normal_quantile(double p) {
-                static const double ROOT_TWO = std::sqrt(2.0);
-
-                double result = 0.0;
-                assert(p >= 0 && p <= 1);
-                if (p < 0 || p > 1) {
-                    return result;
-                }
-
-                result = -erfc_inv(2.0 * p);
-                // result *= normal distribution standard deviation (1.0) * sqrt(2)
-                result *= /*sd * */ ROOT_TWO;
-                // result += normal disttribution mean (0)
-                return result;
-            }
-
-            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
-                double sb = stddev.point;
-                double mn = mean.point / n;
-                double mg_min = mn / 2.;
-                double sg = std::min(mg_min / 4., sb / std::sqrt(n));
-                double sg2 = sg * sg;
-                double sb2 = sb * sb;
-
-                auto c_max = [n, mn, sb2, sg2](double x) -> double {
-                    double k = mn - x;
-                    double d = k * k;
-                    double nd = n * d;
-                    double k0 = -n * nd;
-                    double k1 = sb2 - n * sg2 + nd;
-                    double det = k1 * k1 - 4 * sg2 * k0;
-                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
-                };
-
-                auto var_out = [n, sb2, sg2](double c) {
-                    double nc = n - c;
-                    return (nc / n) * (sb2 - nc * sg2);
-                };
-
-                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
-            }
-
-            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-                static std::random_device entropy;
-                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
-
-                auto mean = &Detail::mean<std::vector<double>::iterator>;
-                auto stddev = &standard_deviation;
-
-#if defined(CATCH_CONFIG_USE_ASYNC)
-                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
-                    auto seed = entropy();
-                    return std::async(std::launch::async, [=] {
-                        std::mt19937 rng(seed);
-                        auto resampled = resample(rng, n_resamples, first, last, f);
-                        return bootstrap(confidence_level, first, last, resampled, f);
-                    });
-                };
-
-                auto mean_future = Estimate(mean);
-                auto stddev_future = Estimate(stddev);
-
-                auto mean_estimate = mean_future.get();
-                auto stddev_estimate = stddev_future.get();
-#else
-                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
-                    auto seed = entropy();
-                    std::mt19937 rng(seed);
-                    auto resampled = resample(rng, n_resamples, first, last, f);
-                    return bootstrap(confidence_level, first, last, resampled, f);
-                };
-
-                auto mean_estimate = Estimate(mean);
-                auto stddev_estimate = Estimate(stddev);
-#endif // CATCH_USE_ASYNC
-
-                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
-
-                return { mean_estimate, stddev_estimate, outlier_variance };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-// end catch_stats.cpp
-// start catch_approx.cpp
-
-#include <cmath>
-#include <limits>
-
-namespace {
-
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
-
-}
-
-namespace Catch {
-namespace Detail {
-
-    Approx::Approx ( double value )
-    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
-        m_margin( 0.0 ),
-        m_scale( 0.0 ),
-        m_value( value )
-    {}
-
-    Approx Approx::custom() {
-        return Approx( 0 );
-    }
-
-    Approx Approx::operator-() const {
-        auto temp(*this);
-        temp.m_value = -temp.m_value;
-        return temp;
-    }
-
-    std::string Approx::toString() const {
-        ReusableStringStream rss;
-        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
-        return rss.str();
-    }
-
-    bool Approx::equalityComparisonImpl(const double other) const {
-        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
-        // Thanks to Richard Harris for his help refining the scaled margin value
-        return marginComparison(m_value, other, m_margin)
-            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
-    }
-
-    void Approx::setMargin(double newMargin) {
-        CATCH_ENFORCE(newMargin >= 0,
-            "Invalid Approx::margin: " << newMargin << '.'
-            << " Approx::Margin has to be non-negative.");
-        m_margin = newMargin;
-    }
-
-    void Approx::setEpsilon(double newEpsilon) {
-        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
-            "Invalid Approx::epsilon: " << newEpsilon << '.'
-            << " Approx::epsilon has to be in [0, 1]");
-        m_epsilon = newEpsilon;
-    }
-
-} // end namespace Detail
-
-namespace literals {
-    Detail::Approx operator "" _a(long double val) {
-        return Detail::Approx(val);
-    }
-    Detail::Approx operator "" _a(unsigned long long val) {
-        return Detail::Approx(val);
-    }
-} // end namespace literals
-
-std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
-    return value.toString();
-}
-
-} // end namespace Catch
-// end catch_approx.cpp
-// start catch_assertionhandler.cpp
-
-// start catch_debugger.h
-
-namespace Catch {
-    bool isDebuggerActive();
-}
-
-#ifdef CATCH_PLATFORM_MAC
-
-    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
-
-#elif defined(CATCH_PLATFORM_IPHONE)
-
-    // use inline assembler
-    #if defined(__i386__) || defined(__x86_64__)
-        #define CATCH_TRAP()  __asm__("int $3")
-    #elif defined(__aarch64__)
-        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
-    #elif defined(__arm__) && !defined(__thumb__)
-        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
-    #elif defined(__arm__) &&  defined(__thumb__)
-        #define CATCH_TRAP()  __asm__(".inst 0xde01")
-    #endif
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    // If we can use inline assembler, do it because this allows us to break
-    // directly at the location of the failing check instead of breaking inside
-    // raise() called from it, i.e. one stack frame below.
-    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
-        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
-    #else // Fall back to the generic way.
-        #include <signal.h>
-
-        #define CATCH_TRAP() raise(SIGTRAP)
-    #endif
-#elif defined(_MSC_VER)
-    #define CATCH_TRAP() __debugbreak()
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
-    #define CATCH_TRAP() DebugBreak()
-#endif
-
-#ifndef CATCH_BREAK_INTO_DEBUGGER
-    #ifdef CATCH_TRAP
-        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
-    #else
-        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
-    #endif
-#endif
-
-// end catch_debugger.h
-// start catch_run_context.h
-
-// start catch_fatal_condition.h
-
-// start catch_windows_h_proxy.h
-
-
-#if defined(CATCH_PLATFORM_WINDOWS)
-
-#if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
-#  define CATCH_DEFINED_NOMINMAX
-#  define NOMINMAX
-#endif
-#if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
-#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
-#endif
-
-#ifdef __AFXDLL
-#include <AfxWin.h>
-#else
-#include <windows.h>
-#endif
-
-#ifdef CATCH_DEFINED_NOMINMAX
-#  undef NOMINMAX
-#endif
-#ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN
-#  undef WIN32_LEAN_AND_MEAN
-#endif
-
-#endif // defined(CATCH_PLATFORM_WINDOWS)
-
-// end catch_windows_h_proxy.h
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-
-    struct FatalConditionHandler {
-
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
-        FatalConditionHandler();
-        static void reset();
-        ~FatalConditionHandler();
-
-    private:
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
-    };
-
-} // namespace Catch
-
-#elif defined ( CATCH_CONFIG_POSIX_SIGNALS )
-
-#include <signal.h>
-
-namespace Catch {
-
-    struct FatalConditionHandler {
-
-        static bool isSet;
-        static struct sigaction oldSigActions[];
-        static stack_t oldSigStack;
-        static char altStackMem[];
-
-        static void handleSignal( int sig );
-
-        FatalConditionHandler();
-        ~FatalConditionHandler();
-        static void reset();
-    };
-
-} // namespace Catch
-
-#else
-
-namespace Catch {
-    struct FatalConditionHandler {
-        void reset();
-    };
-}
-
-#endif
-
-// end catch_fatal_condition.h
-#include <string>
-
-namespace Catch {
-
-    struct IMutableContext;
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class RunContext : public IResultCapture, public IRunner {
-
-    public:
-        RunContext( RunContext const& ) = delete;
-        RunContext& operator =( RunContext const& ) = delete;
-
-        explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
-
-        ~RunContext() override;
-
-        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
-        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
-
-        Totals runTest(TestCase const& testCase);
-
-        IConfigPtr config() const;
-        IStreamingReporter& reporter() const;
-
-    public: // IResultCapture
-
-        // Assertion handlers
-        void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) override;
-        void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef const& message,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string const& message,
-                    AssertionReaction& reaction ) override;
-        void handleIncomplete
-                (   AssertionInfo const& info ) override;
-        void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) override;
-
-        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
-
-        void sectionEnded( SectionEndInfo const& endInfo ) override;
-        void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
-
-        auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing( std::string const& name ) override;
-        void benchmarkStarting( BenchmarkInfo const& info ) override;
-        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
-        void benchmarkFailed( std::string const& error ) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void pushScopedMessage( MessageInfo const& message ) override;
-        void popScopedMessage( MessageInfo const& message ) override;
-
-        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
-
-        std::string getCurrentTestName() const override;
-
-        const AssertionResult* getLastResult() const override;
-
-        void exceptionEarlyReported() override;
-
-        void handleFatalErrorCondition( StringRef message ) override;
-
-        bool lastAssertionPassed() override;
-
-        void assertionPassed() override;
-
-    public:
-        // !TBD We need to do this another way!
-        bool aborting() const final;
-
-    private:
-
-        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
-        void invokeActiveTestCase();
-
-        void resetAssertionInfo();
-        bool testForMissingAssertions( Counts& assertions );
-
-        void assertionEnded( AssertionResult const& result );
-        void reportExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    ITransientExpression const *expr,
-                    bool negated );
-
-        void populateReaction( AssertionReaction& reaction );
-
-    private:
-
-        void handleUnfinishedSections();
-
-        TestRunInfo m_runInfo;
-        IMutableContext& m_context;
-        TestCase const* m_activeTestCase = nullptr;
-        ITracker* m_testCaseTracker = nullptr;
-        Option<AssertionResult> m_lastResult;
-
-        IConfigPtr m_config;
-        Totals m_totals;
-        IStreamingReporterPtr m_reporter;
-        std::vector<MessageInfo> m_messages;
-        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
-        AssertionInfo m_lastAssertionInfo;
-        std::vector<SectionEndInfo> m_unfinishedSections;
-        std::vector<ITracker*> m_activeSections;
-        TrackerContext m_trackerContext;
-        bool m_lastAssertionPassed = false;
-        bool m_shouldReportUnexpected = true;
-        bool m_includeSuccessfulResults;
-    };
-
-    void seedRng(IConfig const& config);
-    unsigned int rngSeed();
-} // end namespace Catch
-
-// end catch_run_context.h
-namespace Catch {
-
-    namespace {
-        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
-            expr.streamReconstructedExpression( os );
-            return os;
-        }
-    }
-
-    LazyExpression::LazyExpression( bool isNegated )
-    :   m_isNegated( isNegated )
-    {}
-
-    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
-
-    LazyExpression::operator bool() const {
-        return m_transientExpression != nullptr;
-    }
-
-    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
-        if( lazyExpr.m_isNegated )
-            os << "!";
-
-        if( lazyExpr ) {
-            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
-                os << "(" << *lazyExpr.m_transientExpression << ")";
-            else
-                os << *lazyExpr.m_transientExpression;
-        }
-        else {
-            os << "{** error - unchecked empty expression requested **}";
-        }
-        return os;
-    }
-
-    AssertionHandler::AssertionHandler
-        (   StringRef const& macroName,
-            SourceLineInfo const& lineInfo,
-            StringRef capturedExpression,
-            ResultDisposition::Flags resultDisposition )
-    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
-        m_resultCapture( getResultCapture() )
-    {}
-
-    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
-        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
-    }
-    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
-    }
-
-    auto AssertionHandler::allowThrows() const -> bool {
-        return getCurrentContext().getConfig()->allowThrows();
-    }
-
-    void AssertionHandler::complete() {
-        setCompleted();
-        if( m_reaction.shouldDebugBreak ) {
-
-            // If you find your debugger stopping you here then go one level up on the
-            // call-stack for the code that caused it (typically a failed assertion)
-
-            // (To go back to the test and change execution, jump over the throw, next)
-            CATCH_BREAK_INTO_DEBUGGER();
-        }
-        if (m_reaction.shouldThrow) {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-            throw Catch::TestFailureException();
-#else
-            CATCH_ERROR( "Test failure requires aborting test!" );
-#endif
-        }
-    }
-    void AssertionHandler::setCompleted() {
-        m_completed = true;
-    }
-
-    void AssertionHandler::handleUnexpectedInflightException() {
-        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
-    }
-
-    void AssertionHandler::handleExceptionThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-    void AssertionHandler::handleExceptionNotThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
-        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
-    }
-
-    void AssertionHandler::handleThrowingCallSkipped() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    // This is the overload that takes a string and infers the Equals matcher from it
-    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
-        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
-    }
-
-} // namespace Catch
-// end catch_assertionhandler.cpp
-// start catch_assertionresult.cpp
-
-namespace Catch {
-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
-        lazyExpression(_lazyExpression),
-        resultType(_resultType) {}
-
-    std::string AssertionResultData::reconstructExpression() const {
-
-        if( reconstructedExpression.empty() ) {
-            if( lazyExpression ) {
-                ReusableStringStream rss;
-                rss << lazyExpression;
-                reconstructedExpression = rss.str();
-            }
-        }
-        return reconstructedExpression;
-    }
-
-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
-    :   m_info( info ),
-        m_resultData( data )
-    {}
-
-    // Result was a success
-    bool AssertionResult::succeeded() const {
-        return Catch::isOk( m_resultData.resultType );
-    }
-
-    // Result was a success, or failure is suppressed
-    bool AssertionResult::isOk() const {
-        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
-    }
-
-    ResultWas::OfType AssertionResult::getResultType() const {
-        return m_resultData.resultType;
-    }
-
-    bool AssertionResult::hasExpression() const {
-        return !m_info.capturedExpression.empty();
-    }
-
-    bool AssertionResult::hasMessage() const {
-        return !m_resultData.message.empty();
-    }
-
-    std::string AssertionResult::getExpression() const {
-        // Possibly overallocating by 3 characters should be basically free
-        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += "!(";
-        }
-        expr += m_info.capturedExpression;
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += ')';
-        }
-        return expr;
-    }
-
-    std::string AssertionResult::getExpressionInMacro() const {
-        std::string expr;
-        if( m_info.macroName.empty() )
-            expr = static_cast<std::string>(m_info.capturedExpression);
-        else {
-            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
-            expr += m_info.macroName;
-            expr += "( ";
-            expr += m_info.capturedExpression;
-            expr += " )";
-        }
-        return expr;
-    }
-
-    bool AssertionResult::hasExpandedExpression() const {
-        return hasExpression() && getExpandedExpression() != getExpression();
-    }
-
-    std::string AssertionResult::getExpandedExpression() const {
-        std::string expr = m_resultData.reconstructExpression();
-        return expr.empty()
-                ? getExpression()
-                : expr;
-    }
-
-    std::string AssertionResult::getMessage() const {
-        return m_resultData.message;
-    }
-    SourceLineInfo AssertionResult::getSourceInfo() const {
-        return m_info.lineInfo;
-    }
-
-    StringRef AssertionResult::getTestMacroName() const {
-        return m_info.macroName;
-    }
-
-} // end namespace Catch
-// end catch_assertionresult.cpp
-// start catch_capture_matchers.cpp
-
-namespace Catch {
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    // This is the general overload that takes a any string matcher
-    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
-    // the Equals matcher (so the header does not mention matchers)
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
-        std::string exceptionMessage = Catch::translateActiveException();
-        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
-        handler.handleExpr( expr );
-    }
-
-} // namespace Catch
-// end catch_capture_matchers.cpp
-// start catch_commandline.cpp
-
-// start catch_commandline.h
-
-// start catch_clara.h
-
-// Use Catch's value for console width (store Clara's off to the side, if present)
-#ifdef CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#endif
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#pragma clang diagnostic ignored "-Wexit-time-destructors"
-#pragma clang diagnostic ignored "-Wshadow"
-#endif
-
-// start clara.hpp
-// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See https://github.com/philsquared/Clara for more details
-
-// Clara v1.1.5
-
-
-#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-#ifndef CLARA_CONFIG_OPTIONAL_TYPE
-#ifdef __has_include
-#if __has_include(<optional>) && __cplusplus >= 201703L
-#include <optional>
-#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
-#endif
-#endif
-#endif
-
-// ----------- #included from clara_textflow.hpp -----------
-
-// TextFlowCpp
-//
-// A single-header library for wrapping and laying out basic text, by Phil Nash
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// This project is hosted at https://github.com/philsquared/textflowcpp
-
-
-#include <cassert>
-#include <ostream>
-#include <sstream>
-#include <vector>
-
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch {
-namespace clara {
-namespace TextFlow {
-
-inline auto isWhitespace(char c) -> bool {
-	static std::string chars = " \t\n\r";
-	return chars.find(c) != std::string::npos;
-}
-inline auto isBreakableBefore(char c) -> bool {
-	static std::string chars = "[({<|";
-	return chars.find(c) != std::string::npos;
-}
-inline auto isBreakableAfter(char c) -> bool {
-	static std::string chars = "])}>.,:;*+-=&/\\";
-	return chars.find(c) != std::string::npos;
-}
-
-class Columns;
-
-class Column {
-	std::vector<std::string> m_strings;
-	size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
-	size_t m_indent = 0;
-	size_t m_initialIndent = std::string::npos;
-
-public:
-	class iterator {
-		friend Column;
-
-		Column const& m_column;
-		size_t m_stringIndex = 0;
-		size_t m_pos = 0;
-
-		size_t m_len = 0;
-		size_t m_end = 0;
-		bool m_suffix = false;
-
-		iterator(Column const& column, size_t stringIndex)
-			: m_column(column),
-			m_stringIndex(stringIndex) {}
-
-		auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
-
-		auto isBoundary(size_t at) const -> bool {
-			assert(at > 0);
-			assert(at <= line().size());
-
-			return at == line().size() ||
-				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
-				isBreakableBefore(line()[at]) ||
-				isBreakableAfter(line()[at - 1]);
-		}
-
-		void calcLength() {
-			assert(m_stringIndex < m_column.m_strings.size());
-
-			m_suffix = false;
-			auto width = m_column.m_width - indent();
-			m_end = m_pos;
-			if (line()[m_pos] == '\n') {
-				++m_end;
-			}
-			while (m_end < line().size() && line()[m_end] != '\n')
-				++m_end;
-
-			if (m_end < m_pos + width) {
-				m_len = m_end - m_pos;
-			} else {
-				size_t len = width;
-				while (len > 0 && !isBoundary(m_pos + len))
-					--len;
-				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
-					--len;
-
-				if (len > 0) {
-					m_len = len;
-				} else {
-					m_suffix = true;
-					m_len = width - 1;
-				}
-			}
-		}
-
-		auto indent() const -> size_t {
-			auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
-			return initial == std::string::npos ? m_column.m_indent : initial;
-		}
-
-		auto addIndentAndSuffix(std::string const &plain) const -> std::string {
-			return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
-		}
-
-	public:
-		using difference_type = std::ptrdiff_t;
-		using value_type = std::string;
-		using pointer = value_type * ;
-		using reference = value_type & ;
-		using iterator_category = std::forward_iterator_tag;
-
-		explicit iterator(Column const& column) : m_column(column) {
-			assert(m_column.m_width > m_column.m_indent);
-			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
-			calcLength();
-			if (m_len == 0)
-				m_stringIndex++; // Empty string
-		}
-
-		auto operator *() const -> std::string {
-			assert(m_stringIndex < m_column.m_strings.size());
-			assert(m_pos <= m_end);
-			return addIndentAndSuffix(line().substr(m_pos, m_len));
-		}
-
-		auto operator ++() -> iterator& {
-			m_pos += m_len;
-			if (m_pos < line().size() && line()[m_pos] == '\n')
-				m_pos += 1;
-			else
-				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
-					++m_pos;
-
-			if (m_pos == line().size()) {
-				m_pos = 0;
-				++m_stringIndex;
-			}
-			if (m_stringIndex < m_column.m_strings.size())
-				calcLength();
-			return *this;
-		}
-		auto operator ++(int) -> iterator {
-			iterator prev(*this);
-			operator++();
-			return prev;
-		}
-
-		auto operator ==(iterator const& other) const -> bool {
-			return
-				m_pos == other.m_pos &&
-				m_stringIndex == other.m_stringIndex &&
-				&m_column == &other.m_column;
-		}
-		auto operator !=(iterator const& other) const -> bool {
-			return !operator==(other);
-		}
-	};
-	using const_iterator = iterator;
-
-	explicit Column(std::string const& text) { m_strings.push_back(text); }
-
-	auto width(size_t newWidth) -> Column& {
-		assert(newWidth > 0);
-		m_width = newWidth;
-		return *this;
-	}
-	auto indent(size_t newIndent) -> Column& {
-		m_indent = newIndent;
-		return *this;
-	}
-	auto initialIndent(size_t newIndent) -> Column& {
-		m_initialIndent = newIndent;
-		return *this;
-	}
-
-	auto width() const -> size_t { return m_width; }
-	auto begin() const -> iterator { return iterator(*this); }
-	auto end() const -> iterator { return { *this, m_strings.size() }; }
-
-	inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
-		bool first = true;
-		for (auto line : col) {
-			if (first)
-				first = false;
-			else
-				os << "\n";
-			os << line;
-		}
-		return os;
-	}
-
-	auto operator + (Column const& other)->Columns;
-
-	auto toString() const -> std::string {
-		std::ostringstream oss;
-		oss << *this;
-		return oss.str();
-	}
-};
-
-class Spacer : public Column {
-
-public:
-	explicit Spacer(size_t spaceWidth) : Column("") {
-		width(spaceWidth);
-	}
-};
-
-class Columns {
-	std::vector<Column> m_columns;
-
-public:
-
-	class iterator {
-		friend Columns;
-		struct EndTag {};
-
-		std::vector<Column> const& m_columns;
-		std::vector<Column::iterator> m_iterators;
-		size_t m_activeIterators;
-
-		iterator(Columns const& columns, EndTag)
-			: m_columns(columns.m_columns),
-			m_activeIterators(0) {
-			m_iterators.reserve(m_columns.size());
-
-			for (auto const& col : m_columns)
-				m_iterators.push_back(col.end());
-		}
-
-	public:
-		using difference_type = std::ptrdiff_t;
-		using value_type = std::string;
-		using pointer = value_type * ;
-		using reference = value_type & ;
-		using iterator_category = std::forward_iterator_tag;
-
-		explicit iterator(Columns const& columns)
-			: m_columns(columns.m_columns),
-			m_activeIterators(m_columns.size()) {
-			m_iterators.reserve(m_columns.size());
-
-			for (auto const& col : m_columns)
-				m_iterators.push_back(col.begin());
-		}
-
-		auto operator ==(iterator const& other) const -> bool {
-			return m_iterators == other.m_iterators;
-		}
-		auto operator !=(iterator const& other) const -> bool {
-			return m_iterators != other.m_iterators;
-		}
-		auto operator *() const -> std::string {
-			std::string row, padding;
-
-			for (size_t i = 0; i < m_columns.size(); ++i) {
-				auto width = m_columns[i].width();
-				if (m_iterators[i] != m_columns[i].end()) {
-					std::string col = *m_iterators[i];
-					row += padding + col;
-					if (col.size() < width)
-						padding = std::string(width - col.size(), ' ');
-					else
-						padding = "";
-				} else {
-					padding += std::string(width, ' ');
-				}
-			}
-			return row;
-		}
-		auto operator ++() -> iterator& {
-			for (size_t i = 0; i < m_columns.size(); ++i) {
-				if (m_iterators[i] != m_columns[i].end())
-					++m_iterators[i];
-			}
-			return *this;
-		}
-		auto operator ++(int) -> iterator {
-			iterator prev(*this);
-			operator++();
-			return prev;
-		}
-	};
-	using const_iterator = iterator;
-
-	auto begin() const -> iterator { return iterator(*this); }
-	auto end() const -> iterator { return { *this, iterator::EndTag() }; }
-
-	auto operator += (Column const& col) -> Columns& {
-		m_columns.push_back(col);
-		return *this;
-	}
-	auto operator + (Column const& col) -> Columns {
-		Columns combined = *this;
-		combined += col;
-		return combined;
-	}
-
-	inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
-
-		bool first = true;
-		for (auto line : cols) {
-			if (first)
-				first = false;
-			else
-				os << "\n";
-			os << line;
-		}
-		return os;
-	}
-
-	auto toString() const -> std::string {
-		std::ostringstream oss;
-		oss << *this;
-		return oss.str();
-	}
-};
-
-inline auto Column::operator + (Column const& other) -> Columns {
-	Columns cols;
-	cols += *this;
-	cols += other;
-	return cols;
-}
-}
-
-}
-}
-
-// ----------- end of #include from clara_textflow.hpp -----------
-// ........... back in clara.hpp
-
-#include <cctype>
-#include <string>
-#include <memory>
-#include <set>
-#include <algorithm>
-
-#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
-#define CATCH_PLATFORM_WINDOWS
-#endif
-
-namespace Catch { namespace clara {
-namespace detail {
-
-    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
-    template<typename L>
-    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
-
-    template<typename ClassT, typename ReturnT, typename... Args>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
-        static const bool isValid = false;
-    };
-
-    template<typename ClassT, typename ReturnT, typename ArgT>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
-        static const bool isValid = true;
-        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
-        using ReturnType = ReturnT;
-    };
-
-    class TokenStream;
-
-    // Transport for raw args (copied from main args, or supplied via init list for testing)
-    class Args {
-        friend TokenStream;
-        std::string m_exeName;
-        std::vector<std::string> m_args;
-
-    public:
-        Args( int argc, char const* const* argv )
-            : m_exeName(argv[0]),
-              m_args(argv + 1, argv + argc) {}
-
-        Args( std::initializer_list<std::string> args )
-        :   m_exeName( *args.begin() ),
-            m_args( args.begin()+1, args.end() )
-        {}
-
-        auto exeName() const -> std::string {
-            return m_exeName;
-        }
-    };
-
-    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
-    // may encode an option + its argument if the : or = form is used
-    enum class TokenType {
-        Option, Argument
-    };
-    struct Token {
-        TokenType type;
-        std::string token;
-    };
-
-    inline auto isOptPrefix( char c ) -> bool {
-        return c == '-'
-#ifdef CATCH_PLATFORM_WINDOWS
-            || c == '/'
-#endif
-        ;
-    }
-
-    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
-    class TokenStream {
-        using Iterator = std::vector<std::string>::const_iterator;
-        Iterator it;
-        Iterator itEnd;
-        std::vector<Token> m_tokenBuffer;
-
-        void loadBuffer() {
-            m_tokenBuffer.resize( 0 );
-
-            // Skip any empty strings
-            while( it != itEnd && it->empty() )
-                ++it;
-
-            if( it != itEnd ) {
-                auto const &next = *it;
-                if( isOptPrefix( next[0] ) ) {
-                    auto delimiterPos = next.find_first_of( " :=" );
-                    if( delimiterPos != std::string::npos ) {
-                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
-                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
-                    } else {
-                        if( next[1] != '-' && next.size() > 2 ) {
-                            std::string opt = "- ";
-                            for( size_t i = 1; i < next.size(); ++i ) {
-                                opt[1] = next[i];
-                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
-                            }
-                        } else {
-                            m_tokenBuffer.push_back( { TokenType::Option, next } );
-                        }
-                    }
-                } else {
-                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
-                }
-            }
-        }
-
-    public:
-        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
-
-        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
-            loadBuffer();
-        }
-
-        explicit operator bool() const {
-            return !m_tokenBuffer.empty() || it != itEnd;
-        }
-
-        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
-
-        auto operator*() const -> Token {
-            assert( !m_tokenBuffer.empty() );
-            return m_tokenBuffer.front();
-        }
-
-        auto operator->() const -> Token const * {
-            assert( !m_tokenBuffer.empty() );
-            return &m_tokenBuffer.front();
-        }
-
-        auto operator++() -> TokenStream & {
-            if( m_tokenBuffer.size() >= 2 ) {
-                m_tokenBuffer.erase( m_tokenBuffer.begin() );
-            } else {
-                if( it != itEnd )
-                    ++it;
-                loadBuffer();
-            }
-            return *this;
-        }
-    };
-
-    class ResultBase {
-    public:
-        enum Type {
-            Ok, LogicError, RuntimeError
-        };
-
-    protected:
-        ResultBase( Type type ) : m_type( type ) {}
-        virtual ~ResultBase() = default;
-
-        virtual void enforceOk() const = 0;
-
-        Type m_type;
-    };
-
-    template<typename T>
-    class ResultValueBase : public ResultBase {
-    public:
-        auto value() const -> T const & {
-            enforceOk();
-            return m_value;
-        }
-
-    protected:
-        ResultValueBase( Type type ) : ResultBase( type ) {}
-
-        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-        }
-
-        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
-            new( &m_value ) T( value );
-        }
-
-        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
-            if( m_type == ResultBase::Ok )
-                m_value.~T();
-            ResultBase::operator=(other);
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-            return *this;
-        }
-
-        ~ResultValueBase() override {
-            if( m_type == Ok )
-                m_value.~T();
-        }
-
-        union {
-            T m_value;
-        };
-    };
-
-    template<>
-    class ResultValueBase<void> : public ResultBase {
-    protected:
-        using ResultBase::ResultBase;
-    };
-
-    template<typename T = void>
-    class BasicResult : public ResultValueBase<T> {
-    public:
-        template<typename U>
-        explicit BasicResult( BasicResult<U> const &other )
-        :   ResultValueBase<T>( other.type() ),
-            m_errorMessage( other.errorMessage() )
-        {
-            assert( type() != ResultBase::Ok );
-        }
-
-        template<typename U>
-        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
-        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
-        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
-        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
-
-        explicit operator bool() const { return m_type == ResultBase::Ok; }
-        auto type() const -> ResultBase::Type { return m_type; }
-        auto errorMessage() const -> std::string { return m_errorMessage; }
-
-    protected:
-        void enforceOk() const override {
-
-            // Errors shouldn't reach this point, but if they do
-            // the actual error message will be in m_errorMessage
-            assert( m_type != ResultBase::LogicError );
-            assert( m_type != ResultBase::RuntimeError );
-            if( m_type != ResultBase::Ok )
-                std::abort();
-        }
-
-        std::string m_errorMessage; // Only populated if resultType is an error
-
-        BasicResult( ResultBase::Type type, std::string const &message )
-        :   ResultValueBase<T>(type),
-            m_errorMessage(message)
-        {
-            assert( m_type != ResultBase::Ok );
-        }
-
-        using ResultValueBase<T>::ResultValueBase;
-        using ResultBase::m_type;
-    };
-
-    enum class ParseResultType {
-        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
-    };
-
-    class ParseState {
-    public:
-
-        ParseState( ParseResultType type, TokenStream const &remainingTokens )
-        : m_type(type),
-          m_remainingTokens( remainingTokens )
-        {}
-
-        auto type() const -> ParseResultType { return m_type; }
-        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
-
-    private:
-        ParseResultType m_type;
-        TokenStream m_remainingTokens;
-    };
-
-    using Result = BasicResult<void>;
-    using ParserResult = BasicResult<ParseResultType>;
-    using InternalParseResult = BasicResult<ParseState>;
-
-    struct HelpColumns {
-        std::string left;
-        std::string right;
-    };
-
-    template<typename T>
-    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
-        std::stringstream ss;
-        ss << source;
-        ss >> target;
-        if( ss.fail() )
-            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
-        else
-            return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
-        target = source;
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
-        std::string srcLC = source;
-        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
-        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
-            target = true;
-        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
-            target = false;
-        else
-            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-#ifdef CLARA_CONFIG_OPTIONAL_TYPE
-    template<typename T>
-    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
-        T temp;
-        auto result = convertInto( source, temp );
-        if( result )
-            target = std::move(temp);
-        return result;
-    }
-#endif // CLARA_CONFIG_OPTIONAL_TYPE
-
-    struct NonCopyable {
-        NonCopyable() = default;
-        NonCopyable( NonCopyable const & ) = delete;
-        NonCopyable( NonCopyable && ) = delete;
-        NonCopyable &operator=( NonCopyable const & ) = delete;
-        NonCopyable &operator=( NonCopyable && ) = delete;
-    };
-
-    struct BoundRef : NonCopyable {
-        virtual ~BoundRef() = default;
-        virtual auto isContainer() const -> bool { return false; }
-        virtual auto isFlag() const -> bool { return false; }
-    };
-    struct BoundValueRefBase : BoundRef {
-        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
-    };
-    struct BoundFlagRefBase : BoundRef {
-        virtual auto setFlag( bool flag ) -> ParserResult = 0;
-        virtual auto isFlag() const -> bool { return true; }
-    };
-
-    template<typename T>
-    struct BoundValueRef : BoundValueRefBase {
-        T &m_ref;
-
-        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return convertInto( arg, m_ref );
-        }
-    };
-
-    template<typename T>
-    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
-        std::vector<T> &m_ref;
-
-        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
-
-        auto isContainer() const -> bool override { return true; }
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            T temp;
-            auto result = convertInto( arg, temp );
-            if( result )
-                m_ref.push_back( temp );
-            return result;
-        }
-    };
-
-    struct BoundFlagRef : BoundFlagRefBase {
-        bool &m_ref;
-
-        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
-
-        auto setFlag( bool flag ) -> ParserResult override {
-            m_ref = flag;
-            return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    template<typename ReturnType>
-    struct LambdaInvoker {
-        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
-
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            return lambda( arg );
-        }
-    };
-
-    template<>
-    struct LambdaInvoker<void> {
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            lambda( arg );
-            return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    template<typename ArgType, typename L>
-    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
-        ArgType temp{};
-        auto result = convertInto( arg, temp );
-        return !result
-           ? result
-           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
-    }
-
-    template<typename L>
-    struct BoundLambda : BoundValueRefBase {
-        L m_lambda;
-
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
-        }
-    };
-
-    template<typename L>
-    struct BoundFlagLambda : BoundFlagRefBase {
-        L m_lambda;
-
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
-
-        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
-
-        auto setFlag( bool flag ) -> ParserResult override {
-            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
-        }
-    };
-
-    enum class Optionality { Optional, Required };
-
-    struct Parser;
-
-    class ParserBase {
-    public:
-        virtual ~ParserBase() = default;
-        virtual auto validate() const -> Result { return Result::ok(); }
-        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
-        virtual auto cardinality() const -> size_t { return 1; }
-
-        auto parse( Args const &args ) const -> InternalParseResult {
-            return parse( args.exeName(), TokenStream( args ) );
-        }
-    };
-
-    template<typename DerivedT>
-    class ComposableParserImpl : public ParserBase {
-    public:
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser;
-
-		template<typename T>
-        auto operator+( T const &other ) const -> Parser;
-    };
-
-    // Common code and state for Args and Opts
-    template<typename DerivedT>
-    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
-    protected:
-        Optionality m_optionality = Optionality::Optional;
-        std::shared_ptr<BoundRef> m_ref;
-        std::string m_hint;
-        std::string m_description;
-
-        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
-
-    public:
-        template<typename T>
-        ParserRefImpl( T &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
-            m_hint( hint )
-        {}
-
-        template<typename LambdaT>
-        ParserRefImpl( LambdaT const &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
-            m_hint(hint)
-        {}
-
-        auto operator()( std::string const &description ) -> DerivedT & {
-            m_description = description;
-            return static_cast<DerivedT &>( *this );
-        }
-
-        auto optional() -> DerivedT & {
-            m_optionality = Optionality::Optional;
-            return static_cast<DerivedT &>( *this );
-        };
-
-        auto required() -> DerivedT & {
-            m_optionality = Optionality::Required;
-            return static_cast<DerivedT &>( *this );
-        };
-
-        auto isOptional() const -> bool {
-            return m_optionality == Optionality::Optional;
-        }
-
-        auto cardinality() const -> size_t override {
-            if( m_ref->isContainer() )
-                return 0;
-            else
-                return 1;
-        }
-
-        auto hint() const -> std::string { return m_hint; }
-    };
-
-    class ExeName : public ComposableParserImpl<ExeName> {
-        std::shared_ptr<std::string> m_name;
-        std::shared_ptr<BoundValueRefBase> m_ref;
-
-        template<typename LambdaT>
-        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
-            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
-        }
-
-    public:
-        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
-
-        explicit ExeName( std::string &ref ) : ExeName() {
-            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
-        }
-
-        template<typename LambdaT>
-        explicit ExeName( LambdaT const& lambda ) : ExeName() {
-            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
-        }
-
-        // The exe name is not parsed out of the normal tokens, but is handled specially
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-        }
-
-        auto name() const -> std::string { return *m_name; }
-        auto set( std::string const& newName ) -> ParserResult {
-
-            auto lastSlash = newName.find_last_of( "\\/" );
-            auto filename = ( lastSlash == std::string::npos )
-                    ? newName
-                    : newName.substr( lastSlash+1 );
-
-            *m_name = filename;
-            if( m_ref )
-                return m_ref->setValue( filename );
-            else
-                return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    class Arg : public ParserRefImpl<Arg> {
-    public:
-        using ParserRefImpl::ParserRefImpl;
-
-        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            auto const &token = *remainingTokens;
-            if( token.type != TokenType::Argument )
-                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
-
-            assert( !m_ref->isFlag() );
-            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
-
-            auto result = valueRef->setValue( remainingTokens->token );
-            if( !result )
-                return InternalParseResult( result );
-            else
-                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-        }
-    };
-
-    inline auto normaliseOpt( std::string const &optName ) -> std::string {
-#ifdef CATCH_PLATFORM_WINDOWS
-        if( optName[0] == '/' )
-            return "-" + optName.substr( 1 );
-        else
-#endif
-            return optName;
-    }
-
-    class Opt : public ParserRefImpl<Opt> {
-    protected:
-        std::vector<std::string> m_optNames;
-
-    public:
-        template<typename LambdaT>
-        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
-
-        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
-
-        template<typename LambdaT>
-        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
-
-        template<typename T>
-        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
-
-        auto operator[]( std::string const &optName ) -> Opt & {
-            m_optNames.push_back( optName );
-            return *this;
-        }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::ostringstream oss;
-            bool first = true;
-            for( auto const &opt : m_optNames ) {
-                if (first)
-                    first = false;
-                else
-                    oss << ", ";
-                oss << opt;
-            }
-            if( !m_hint.empty() )
-                oss << " <" << m_hint << ">";
-            return { { oss.str(), m_description } };
-        }
-
-        auto isMatch( std::string const &optToken ) const -> bool {
-            auto normalisedToken = normaliseOpt( optToken );
-            for( auto const &name : m_optNames ) {
-                if( normaliseOpt( name ) == normalisedToken )
-                    return true;
-            }
-            return false;
-        }
-
-        using ParserBase::parse;
-
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
-                auto const &token = *remainingTokens;
-                if( isMatch(token.token ) ) {
-                    if( m_ref->isFlag() ) {
-                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
-                        auto result = flagRef->setFlag( true );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    } else {
-                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
-                        ++remainingTokens;
-                        if( !remainingTokens )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto const &argToken = *remainingTokens;
-                        if( argToken.type != TokenType::Argument )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto result = valueRef->setValue( argToken.token );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    }
-                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-                }
-            }
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
-        }
-
-        auto validate() const -> Result override {
-            if( m_optNames.empty() )
-                return Result::logicError( "No options supplied to Opt" );
-            for( auto const &name : m_optNames ) {
-                if( name.empty() )
-                    return Result::logicError( "Option name cannot be empty" );
-#ifdef CATCH_PLATFORM_WINDOWS
-                if( name[0] != '-' && name[0] != '/' )
-                    return Result::logicError( "Option name must begin with '-' or '/'" );
-#else
-                if( name[0] != '-' )
-                    return Result::logicError( "Option name must begin with '-'" );
-#endif
-            }
-            return ParserRefImpl::validate();
-        }
-    };
-
-    struct Help : Opt {
-        Help( bool &showHelpFlag )
-        :   Opt([&]( bool flag ) {
-                showHelpFlag = flag;
-                return ParserResult::ok( ParseResultType::ShortCircuitAll );
-            })
-        {
-            static_cast<Opt &>( *this )
-                    ("display usage information")
-                    ["-?"]["-h"]["--help"]
-                    .optional();
-        }
-    };
-
-    struct Parser : ParserBase {
-
-        mutable ExeName m_exeName;
-        std::vector<Opt> m_options;
-        std::vector<Arg> m_args;
-
-        auto operator|=( ExeName const &exeName ) -> Parser & {
-            m_exeName = exeName;
-            return *this;
-        }
-
-        auto operator|=( Arg const &arg ) -> Parser & {
-            m_args.push_back(arg);
-            return *this;
-        }
-
-        auto operator|=( Opt const &opt ) -> Parser & {
-            m_options.push_back(opt);
-            return *this;
-        }
-
-        auto operator|=( Parser const &other ) -> Parser & {
-            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
-            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
-            return *this;
-        }
-
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser {
-            return Parser( *this ) |= other;
-        }
-
-        // Forward deprecated interface with '+' instead of '|'
-        template<typename T>
-        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
-        template<typename T>
-        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::vector<HelpColumns> cols;
-            for (auto const &o : m_options) {
-                auto childCols = o.getHelpColumns();
-                cols.insert( cols.end(), childCols.begin(), childCols.end() );
-            }
-            return cols;
-        }
-
-        void writeToStream( std::ostream &os ) const {
-            if (!m_exeName.name().empty()) {
-                os << "usage:\n" << "  " << m_exeName.name() << " ";
-                bool required = true, first = true;
-                for( auto const &arg : m_args ) {
-                    if (first)
-                        first = false;
-                    else
-                        os << " ";
-                    if( arg.isOptional() && required ) {
-                        os << "[";
-                        required = false;
-                    }
-                    os << "<" << arg.hint() << ">";
-                    if( arg.cardinality() == 0 )
-                        os << " ... ";
-                }
-                if( !required )
-                    os << "]";
-                if( !m_options.empty() )
-                    os << " options";
-                os << "\n\nwhere options are:" << std::endl;
-            }
-
-            auto rows = getHelpColumns();
-            size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
-            size_t optWidth = 0;
-            for( auto const &cols : rows )
-                optWidth = (std::max)(optWidth, cols.left.size() + 2);
-
-            optWidth = (std::min)(optWidth, consoleWidth/2);
-
-            for( auto const &cols : rows ) {
-                auto row =
-                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
-                        TextFlow::Spacer(4) +
-                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
-                os << row << std::endl;
-            }
-        }
-
-        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
-            parser.writeToStream( os );
-            return os;
-        }
-
-        auto validate() const -> Result override {
-            for( auto const &opt : m_options ) {
-                auto result = opt.validate();
-                if( !result )
-                    return result;
-            }
-            for( auto const &arg : m_args ) {
-                auto result = arg.validate();
-                if( !result )
-                    return result;
-            }
-            return Result::ok();
-        }
-
-        using ParserBase::parse;
-
-        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
-
-            struct ParserInfo {
-                ParserBase const* parser = nullptr;
-                size_t count = 0;
-            };
-            const size_t totalParsers = m_options.size() + m_args.size();
-            assert( totalParsers < 512 );
-            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
-            ParserInfo parseInfos[512];
-
-            {
-                size_t i = 0;
-                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
-                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
-            }
-
-            m_exeName.set( exeName );
-
-            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-            while( result.value().remainingTokens() ) {
-                bool tokenParsed = false;
-
-                for( size_t i = 0; i < totalParsers; ++i ) {
-                    auto&  parseInfo = parseInfos[i];
-                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
-                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
-                        if (!result)
-                            return result;
-                        if (result.value().type() != ParseResultType::NoMatch) {
-                            tokenParsed = true;
-                            ++parseInfo.count;
-                            break;
-                        }
-                    }
-                }
-
-                if( result.value().type() == ParseResultType::ShortCircuitAll )
-                    return result;
-                if( !tokenParsed )
-                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
-            }
-            // !TBD Check missing required options
-            return result;
-        }
-    };
-
-    template<typename DerivedT>
-    template<typename T>
-    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
-        return Parser() | static_cast<DerivedT const &>( *this ) | other;
-    }
-} // namespace detail
-
-// A Combined parser
-using detail::Parser;
-
-// A parser for options
-using detail::Opt;
-
-// A parser for arguments
-using detail::Arg;
-
-// Wrapper for argc, argv from main()
-using detail::Args;
-
-// Specifies the name of the executable
-using detail::ExeName;
-
-// Convenience wrapper for option parser that specifies the help option
-using detail::Help;
-
-// enum of result types from a parse
-using detail::ParseResultType;
-
-// Result type for parser operation
-using detail::ParserResult;
-
-}} // namespace Catch::clara
-
-// end clara.hpp
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// Restore Clara's value for console width, if present
-#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-// end catch_clara.h
-namespace Catch {
-
-    clara::Parser makeCommandLineParser( ConfigData& config );
-
-} // end namespace Catch
-
-// end catch_commandline.h
-#include <fstream>
-#include <ctime>
-
-namespace Catch {
-
-    clara::Parser makeCommandLineParser( ConfigData& config ) {
-
-        using namespace clara;
-
-        auto const setWarning = [&]( std::string const& warning ) {
-                auto warningSet = [&]() {
-                    if( warning == "NoAssertions" )
-                        return WarnAbout::NoAssertions;
-
-                    if ( warning == "NoTests" )
-                        return WarnAbout::NoTests;
-
-                    return WarnAbout::Nothing;
-                }();
-
-                if (warningSet == WarnAbout::Nothing)
-                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
-                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
-                std::ifstream f( filename.c_str() );
-                if( !f.is_open() )
-                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
-
-                std::string line;
-                while( std::getline( f, line ) ) {
-                    line = trim(line);
-                    if( !line.empty() && !startsWith( line, '#' ) ) {
-                        if( !startsWith( line, '"' ) )
-                            line = '"' + line + '"';
-                        config.testsOrTags.push_back( line );
-                        config.testsOrTags.emplace_back( "," );
-                    }
-                }
-                //Remove comma in the end
-                if(!config.testsOrTags.empty())
-                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
-
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setTestOrder = [&]( std::string const& order ) {
-                if( startsWith( "declared", order ) )
-                    config.runOrder = RunTests::InDeclarationOrder;
-                else if( startsWith( "lexical", order ) )
-                    config.runOrder = RunTests::InLexicographicalOrder;
-                else if( startsWith( "random", order ) )
-                    config.runOrder = RunTests::InRandomOrder;
-                else
-                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setRngSeed = [&]( std::string const& seed ) {
-                if( seed != "time" )
-                    return clara::detail::convertInto( seed, config.rngSeed );
-                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setColourUsage = [&]( std::string const& useColour ) {
-                    auto mode = toLower( useColour );
-
-                    if( mode == "yes" )
-                        config.useColour = UseColour::Yes;
-                    else if( mode == "no" )
-                        config.useColour = UseColour::No;
-                    else if( mode == "auto" )
-                        config.useColour = UseColour::Auto;
-                    else
-                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
-                auto keypressLc = toLower( keypress );
-                if (keypressLc == "never")
-                    config.waitForKeypress = WaitForKeypress::Never;
-                else if( keypressLc == "start" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStart;
-                else if( keypressLc == "exit" )
-                    config.waitForKeypress = WaitForKeypress::BeforeExit;
-                else if( keypressLc == "both" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
-                else
-                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
-            return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setVerbosity = [&]( std::string const& verbosity ) {
-            auto lcVerbosity = toLower( verbosity );
-            if( lcVerbosity == "quiet" )
-                config.verbosity = Verbosity::Quiet;
-            else if( lcVerbosity == "normal" )
-                config.verbosity = Verbosity::Normal;
-            else if( lcVerbosity == "high" )
-                config.verbosity = Verbosity::High;
-            else
-                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-        auto const setReporter = [&]( std::string const& reporter ) {
-            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-
-            auto lcReporter = toLower( reporter );
-            auto result = factories.find( lcReporter );
-
-            if( factories.end() != result )
-                config.reporterName = lcReporter;
-            else
-                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-
-        auto cli
-            = ExeName( config.processName )
-            | Help( config.showHelp )
-            | Opt( config.listTests )
-                ["-l"]["--list-tests"]
-                ( "list all/matching test cases" )
-            | Opt( config.listTags )
-                ["-t"]["--list-tags"]
-                ( "list all/matching tags" )
-            | Opt( config.showSuccessfulTests )
-                ["-s"]["--success"]
-                ( "include successful tests in output" )
-            | Opt( config.shouldDebugBreak )
-                ["-b"]["--break"]
-                ( "break into debugger on failure" )
-            | Opt( config.noThrow )
-                ["-e"]["--nothrow"]
-                ( "skip exception tests" )
-            | Opt( config.showInvisibles )
-                ["-i"]["--invisibles"]
-                ( "show invisibles (tabs, newlines)" )
-            | Opt( config.outputFilename, "filename" )
-                ["-o"]["--out"]
-                ( "output filename" )
-            | Opt( setReporter, "name" )
-                ["-r"]["--reporter"]
-                ( "reporter to use (defaults to console)" )
-            | Opt( config.name, "name" )
-                ["-n"]["--name"]
-                ( "suite name" )
-            | Opt( [&]( bool ){ config.abortAfter = 1; } )
-                ["-a"]["--abort"]
-                ( "abort at first failure" )
-            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
-                ["-x"]["--abortx"]
-                ( "abort after x failures" )
-            | Opt( setWarning, "warning name" )
-                ["-w"]["--warn"]
-                ( "enable warnings" )
-            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
-                ["-d"]["--durations"]
-                ( "show test durations" )
-            | Opt( loadTestNamesFromFile, "filename" )
-                ["-f"]["--input-file"]
-                ( "load test names to run from a file" )
-            | Opt( config.filenamesAsTags )
-                ["-#"]["--filenames-as-tags"]
-                ( "adds a tag for the filename" )
-            | Opt( config.sectionsToRun, "section name" )
-                ["-c"]["--section"]
-                ( "specify section to run" )
-            | Opt( setVerbosity, "quiet|normal|high" )
-                ["-v"]["--verbosity"]
-                ( "set output verbosity" )
-            | Opt( config.listTestNamesOnly )
-                ["--list-test-names-only"]
-                ( "list all/matching test cases names only" )
-            | Opt( config.listReporters )
-                ["--list-reporters"]
-                ( "list all reporters" )
-            | Opt( setTestOrder, "decl|lex|rand" )
-                ["--order"]
-                ( "test case order (defaults to decl)" )
-            | Opt( setRngSeed, "'time'|number" )
-                ["--rng-seed"]
-                ( "set a specific seed for random numbers" )
-            | Opt( setColourUsage, "yes|no" )
-                ["--use-colour"]
-                ( "should output be colourised" )
-            | Opt( config.libIdentify )
-                ["--libidentify"]
-                ( "report name and version according to libidentify standard" )
-            | Opt( setWaitForKeypress, "never|start|exit|both" )
-                ["--wait-for-keypress"]
-                ( "waits for a keypress before exiting" )
-            | Opt( config.benchmarkSamples, "samples" )
-                ["--benchmark-samples"]
-                ( "number of samples to collect (default: 100)" )
-            | Opt( config.benchmarkResamples, "resamples" )
-                ["--benchmark-resamples"]
-                ( "number of resamples for the bootstrap (default: 100000)" )
-            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
-                ["--benchmark-confidence-interval"]
-                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
-            | Opt( config.benchmarkNoAnalysis )
-                ["--benchmark-no-analysis"]
-                ( "perform only measurements; do not perform any analysis" )
-            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
-                ["--benchmark-warmup-time"]
-                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
-            | Arg( config.testsOrTags, "test name|pattern|tags" )
-                ( "which test or tests to use" );
-
-        return cli;
-    }
-
-} // end namespace Catch
-// end catch_commandline.cpp
-// start catch_common.cpp
-
-#include <cstring>
-#include <ostream>
-
-namespace Catch {
-
-    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
-        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
-    }
-    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
-        // We can assume that the same file will usually have the same pointer.
-        // Thus, if the pointers are the same, there is no point in calling the strcmp
-        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
-    }
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
-#ifndef __GNUG__
-        os << info.file << '(' << info.line << ')';
-#else
-        os << info.file << ':' << info.line;
-#endif
-        return os;
-    }
-
-    std::string StreamEndStop::operator+() const {
-        return std::string();
-    }
-
-    NonCopyable::NonCopyable() = default;
-    NonCopyable::~NonCopyable() = default;
-
-}
-// end catch_common.cpp
-// start catch_config.cpp
-
-namespace Catch {
-
-    Config::Config( ConfigData const& data )
-    :   m_data( data ),
-        m_stream( openStream() )
-    {
-        // We need to trim filter specs to avoid trouble with superfluous
-        // whitespace (esp. important for bdd macros, as those are manually
-        // aligned with whitespace).
-
-        for (auto& elem : m_data.testsOrTags) {
-            elem = trim(elem);
-        }
-        for (auto& elem : m_data.sectionsToRun) {
-            elem = trim(elem);
-        }
-
-        TestSpecParser parser(ITagAliasRegistry::get());
-        if (!m_data.testsOrTags.empty()) {
-            m_hasTestFilters = true;
-            for (auto const& testOrTags : m_data.testsOrTags) {
-                parser.parse(testOrTags);
-            }
-        }
-        m_testSpec = parser.testSpec();
-    }
-
-    std::string const& Config::getFilename() const {
-        return m_data.outputFilename ;
-    }
-
-    bool Config::listTests() const          { return m_data.listTests; }
-    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
-    bool Config::listTags() const           { return m_data.listTags; }
-    bool Config::listReporters() const      { return m_data.listReporters; }
-
-    std::string Config::getProcessName() const { return m_data.processName; }
-    std::string const& Config::getReporterName() const { return m_data.reporterName; }
-
-    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
-    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
-
-    TestSpec const& Config::testSpec() const { return m_testSpec; }
-    bool Config::hasTestFilters() const { return m_hasTestFilters; }
-
-    bool Config::showHelp() const { return m_data.showHelp; }
-
-    // IConfig interface
-    bool Config::allowThrows() const                   { return !m_data.noThrow; }
-    std::ostream& Config::stream() const               { return m_stream->stream(); }
-    std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
-    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
-    bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
-    bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
-    ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
-    RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
-    unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
-    UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
-    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
-    int Config::abortAfter() const                     { return m_data.abortAfter; }
-    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
-    Verbosity Config::verbosity() const                { return m_data.verbosity; }
-
-    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
-    int Config::benchmarkSamples() const                          { return m_data.benchmarkSamples; }
-    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
-    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
-    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
-
-    IStream const* Config::openStream() {
-        return Catch::makeStream(m_data.outputFilename);
-    }
-
-} // end namespace Catch
-// end catch_config.cpp
-// start catch_console_colour.cpp
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-// start catch_errno_guard.h
-
-namespace Catch {
-
-    class ErrnoGuard {
-    public:
-        ErrnoGuard();
-        ~ErrnoGuard();
-    private:
-        int m_oldErrno;
-    };
-
-}
-
-// end catch_errno_guard.h
-#include <sstream>
-
-namespace Catch {
-    namespace {
-
-        struct IColourImpl {
-            virtual ~IColourImpl() = default;
-            virtual void use( Colour::Code _colourCode ) = 0;
-        };
-
-        struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) override {}
-
-            static IColourImpl* instance() {
-                static NoColourImpl s_instance;
-                return &s_instance;
-            }
-        };
-
-    } // anon namespace
-} // namespace Catch
-
-#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
-#   ifdef CATCH_PLATFORM_WINDOWS
-#       define CATCH_CONFIG_COLOUR_WINDOWS
-#   else
-#       define CATCH_CONFIG_COLOUR_ANSI
-#   endif
-#endif
-
-#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
-
-namespace Catch {
-namespace {
-
-    class Win32ColourImpl : public IColourImpl {
-    public:
-        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
-        {
-            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
-            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
-            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
-            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
-        }
-
-        void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
-                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
-                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
-                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
-                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
-                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
-                case Colour::Grey:      return setTextAttribute( 0 );
-
-                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
-                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
-                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
-                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-
-                default:
-                    CATCH_ERROR( "Unknown colour requested" );
-            }
-        }
-
-    private:
-        void setTextAttribute( WORD _textAttribute ) {
-            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
-        }
-        HANDLE stdoutHandle;
-        WORD originalForegroundAttributes;
-        WORD originalBackgroundAttributes;
-    };
-
-    IColourImpl* platformColourInstance() {
-        static Win32ColourImpl s_instance;
-
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = UseColour::Yes;
-        return colourMode == UseColour::Yes
-            ? &s_instance
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
-
-#include <unistd.h>
-
-namespace Catch {
-namespace {
-
-    // use POSIX/ ANSI console terminal codes
-    // Thanks to Adam Strzelecki for original contribution
-    // (http://github.com/nanoant)
-    // https://github.com/philsquared/Catch/pull/131
-    class PosixColourImpl : public IColourImpl {
-    public:
-        void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:
-                case Colour::White:     return setColour( "[0m" );
-                case Colour::Red:       return setColour( "[0;31m" );
-                case Colour::Green:     return setColour( "[0;32m" );
-                case Colour::Blue:      return setColour( "[0;34m" );
-                case Colour::Cyan:      return setColour( "[0;36m" );
-                case Colour::Yellow:    return setColour( "[0;33m" );
-                case Colour::Grey:      return setColour( "[1;30m" );
-
-                case Colour::LightGrey:     return setColour( "[0;37m" );
-                case Colour::BrightRed:     return setColour( "[1;31m" );
-                case Colour::BrightGreen:   return setColour( "[1;32m" );
-                case Colour::BrightWhite:   return setColour( "[1;37m" );
-                case Colour::BrightYellow:  return setColour( "[1;33m" );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
-            }
-        }
-        static IColourImpl* instance() {
-            static PosixColourImpl s_instance;
-            return &s_instance;
-        }
-
-    private:
-        void setColour( const char* _escapeCode ) {
-            getCurrentContext().getConfig()->stream()
-                << '\033' << _escapeCode;
-        }
-    };
-
-    bool useColourOnPlatform() {
-        return
-#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
-            !isDebuggerActive() &&
-#endif
-#if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
-            isatty(STDOUT_FILENO)
-#else
-            false
-#endif
-            ;
-    }
-    IColourImpl* platformColourInstance() {
-        ErrnoGuard guard;
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = useColourOnPlatform()
-                ? UseColour::Yes
-                : UseColour::No;
-        return colourMode == UseColour::Yes
-            ? PosixColourImpl::instance()
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#else  // not Windows or ANSI ///////////////////////////////////////////////
-
-namespace Catch {
-
-    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
-
-} // end namespace Catch
-
-#endif // Windows/ ANSI/ None
-
-namespace Catch {
-
-    Colour::Colour( Code _colourCode ) { use( _colourCode ); }
-    Colour::Colour( Colour&& other ) noexcept {
-        m_moved = other.m_moved;
-        other.m_moved = true;
-    }
-    Colour& Colour::operator=( Colour&& other ) noexcept {
-        m_moved = other.m_moved;
-        other.m_moved  = true;
-        return *this;
-    }
-
-    Colour::~Colour(){ if( !m_moved ) use( None ); }
-
-    void Colour::use( Code _colourCode ) {
-        static IColourImpl* impl = platformColourInstance();
-        // Strictly speaking, this cannot possibly happen.
-        // However, under some conditions it does happen (see #1626),
-        // and this change is small enough that we can let practicality
-        // triumph over purity in this case.
-        if (impl != nullptr) {
-            impl->use( _colourCode );
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, Colour const& ) {
-        return os;
-    }
-
-} // end namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-
-// end catch_console_colour.cpp
-// start catch_context.cpp
-
-namespace Catch {
-
-    class Context : public IMutableContext, NonCopyable {
-
-    public: // IContext
-        IResultCapture* getResultCapture() override {
-            return m_resultCapture;
-        }
-        IRunner* getRunner() override {
-            return m_runner;
-        }
-
-        IConfigPtr const& getConfig() const override {
-            return m_config;
-        }
-
-        ~Context() override;
-
-    public: // IMutableContext
-        void setResultCapture( IResultCapture* resultCapture ) override {
-            m_resultCapture = resultCapture;
-        }
-        void setRunner( IRunner* runner ) override {
-            m_runner = runner;
-        }
-        void setConfig( IConfigPtr const& config ) override {
-            m_config = config;
-        }
-
-        friend IMutableContext& getCurrentMutableContext();
-
-    private:
-        IConfigPtr m_config;
-        IRunner* m_runner = nullptr;
-        IResultCapture* m_resultCapture = nullptr;
-    };
-
-    IMutableContext *IMutableContext::currentContext = nullptr;
-
-    void IMutableContext::createContext()
-    {
-        currentContext = new Context();
-    }
-
-    void cleanUpContext() {
-        delete IMutableContext::currentContext;
-        IMutableContext::currentContext = nullptr;
-    }
-    IContext::~IContext() = default;
-    IMutableContext::~IMutableContext() = default;
-    Context::~Context() = default;
-
-    SimplePcg32& rng() {
-        static SimplePcg32 s_rng;
-        return s_rng;
-    }
-
-}
-// end catch_context.cpp
-// start catch_debug_console.cpp
-
-// start catch_debug_console.h
-
-#include <string>
-
-namespace Catch {
-    void writeToDebugConsole( std::string const& text );
-}
-
-// end catch_debug_console.h
-#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#include <android/log.h>
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
-        }
-    }
-
-#elif defined(CATCH_PLATFORM_WINDOWS)
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            ::OutputDebugStringA( text.c_str() );
-        }
-    }
-
-#else
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            // !TBD: Need a version for Mac/ XCode and other IDEs
-            Catch::cout() << text;
-        }
-    }
-
-#endif // Platform
-// end catch_debug_console.cpp
-// start catch_debugger.cpp
-
-#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
-
-#  include <assert.h>
-#  include <stdbool.h>
-#  include <sys/types.h>
-#  include <unistd.h>
-#  include <cstddef>
-#  include <ostream>
-
-#ifdef __apple_build_version__
-    // These headers will only compile with AppleClang (XCode)
-    // For other compilers (Clang, GCC, ... ) we need to exclude them
-#  include <sys/sysctl.h>
-#endif
-
-    namespace Catch {
-        #ifdef __apple_build_version__
-        // The following function is taken directly from the following technical note:
-        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
-
-        // Returns true if the current process is being debugged (either
-        // running under the debugger or has a debugger attached post facto).
-        bool isDebuggerActive(){
-            int                 mib[4];
-            struct kinfo_proc   info;
-            std::size_t         size;
-
-            // Initialize the flags so that, if sysctl fails for some bizarre
-            // reason, we get a predictable result.
-
-            info.kp_proc.p_flag = 0;
-
-            // Initialize mib, which tells sysctl the info we want, in this case
-            // we're looking for information about a specific process ID.
-
-            mib[0] = CTL_KERN;
-            mib[1] = KERN_PROC;
-            mib[2] = KERN_PROC_PID;
-            mib[3] = getpid();
-
-            // Call sysctl.
-
-            size = sizeof(info);
-            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
-                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
-                return false;
-            }
-
-            // We're being debugged if the P_TRACED flag is set.
-
-            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
-        }
-        #else
-        bool isDebuggerActive() {
-            // We need to find another way to determine this for non-appleclang compilers on macOS
-            return false;
-        }
-        #endif
-    } // namespace Catch
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    #include <fstream>
-    #include <string>
-
-    namespace Catch{
-        // The standard POSIX way of detecting a debugger is to attempt to
-        // ptrace() the process, but this needs to be done from a child and not
-        // this process itself to still allow attaching to this process later
-        // if wanted, so is rather heavy. Under Linux we have the PID of the
-        // "debugger" (which doesn't need to be gdb, of course, it could also
-        // be strace, for example) in /proc/$PID/status, so just get it from
-        // there instead.
-        bool isDebuggerActive(){
-            // Libstdc++ has a bug, where std::ifstream sets errno to 0
-            // This way our users can properly assert over errno values
-            ErrnoGuard guard;
-            std::ifstream in("/proc/self/status");
-            for( std::string line; std::getline(in, line); ) {
-                static const int PREFIX_LEN = 11;
-                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
-                    // We're traced if the PID is not 0 and no other PID starts
-                    // with 0 digit, so it's enough to check for just a single
-                    // character.
-                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
-                }
-            }
-
-            return false;
-        }
-    } // namespace Catch
-#elif defined(_MSC_VER)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#else
-    namespace Catch {
-       bool isDebuggerActive() { return false; }
-    }
-#endif // Platform
-// end catch_debugger.cpp
-// start catch_decomposer.cpp
-
-namespace Catch {
-
-    ITransientExpression::~ITransientExpression() = default;
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
-        if( lhs.size() + rhs.size() < 40 &&
-                lhs.find('\n') == std::string::npos &&
-                rhs.find('\n') == std::string::npos )
-            os << lhs << " " << op << " " << rhs;
-        else
-            os << lhs << "\n" << op << "\n" << rhs;
-    }
-}
-// end catch_decomposer.cpp
-// start catch_enforce.cpp
-
-#include <stdexcept>
-
-namespace Catch {
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
-    [[noreturn]]
-    void throw_exception(std::exception const& e) {
-        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
-                      << "The message was: " << e.what() << '\n';
-        std::terminate();
-    }
-#endif
-
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg) {
-        throw_exception(std::logic_error(msg));
-    }
-
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg) {
-        throw_exception(std::domain_error(msg));
-    }
-
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg) {
-        throw_exception(std::runtime_error(msg));
-    }
-
-} // namespace Catch;
-// end catch_enforce.cpp
-// start catch_enum_values_registry.cpp
-// start catch_enum_values_registry.h
-
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    namespace Detail {
-
-        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
-
-        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
-
-            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
-
-            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
-        };
-
-        std::vector<StringRef> parseEnums( StringRef enums );
-
-    } // Detail
-
-} // Catch
-
-// end catch_enum_values_registry.h
-
-#include <map>
-#include <cassert>
-
-namespace Catch {
-
-    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
-
-    namespace Detail {
-
-        namespace {
-            // Extracts the actual name part of an enum instance
-            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
-            StringRef extractInstanceName(StringRef enumInstance) {
-                // Find last occurence of ":"
-                size_t name_start = enumInstance.size();
-                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
-                    --name_start;
-                }
-                return enumInstance.substr(name_start, enumInstance.size() - name_start);
-            }
-        }
-
-        std::vector<StringRef> parseEnums( StringRef enums ) {
-            auto enumValues = splitStringRef( enums, ',' );
-            std::vector<StringRef> parsed;
-            parsed.reserve( enumValues.size() );
-            for( auto const& enumValue : enumValues ) {
-                parsed.push_back(trim(extractInstanceName(enumValue)));
-            }
-            return parsed;
-        }
-
-        EnumInfo::~EnumInfo() {}
-
-        StringRef EnumInfo::lookup( int value ) const {
-            for( auto const& valueToName : m_values ) {
-                if( valueToName.first == value )
-                    return valueToName.second;
-            }
-            return "{** unexpected enum value **}"_sr;
-        }
-
-        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
-            enumInfo->m_name = enumName;
-            enumInfo->m_values.reserve( values.size() );
-
-            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
-            assert( valueNames.size() == values.size() );
-            std::size_t i = 0;
-            for( auto value : values )
-                enumInfo->m_values.emplace_back(value, valueNames[i++]);
-
-            return enumInfo;
-        }
-
-        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
-            return *m_enumInfos.back();
-        }
-
-    } // Detail
-} // Catch
-
-// end catch_enum_values_registry.cpp
-// start catch_errno_guard.cpp
-
-#include <cerrno>
-
-namespace Catch {
-        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
-        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
-}
-// end catch_errno_guard.cpp
-// start catch_exception_translator_registry.cpp
-
-// start catch_exception_translator_registry.h
-
-#include <vector>
-#include <string>
-#include <memory>
-
-namespace Catch {
-
-    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
-    public:
-        ~ExceptionTranslatorRegistry();
-        virtual void registerTranslator( const IExceptionTranslator* translator );
-        std::string translateActiveException() const override;
-        std::string tryTranslators() const;
-
-    private:
-        std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
-    };
-}
-
-// end catch_exception_translator_registry.h
-#ifdef __OBJC__
-#import "Foundation/Foundation.h"
-#endif
-
-namespace Catch {
-
-    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
-    }
-
-    void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
-        m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
-    }
-
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        try {
-#ifdef __OBJC__
-            // In Objective-C try objective-c exceptions first
-            @try {
-                return tryTranslators();
-            }
-            @catch (NSException *exception) {
-                return Catch::Detail::stringify( [exception description] );
-            }
-#else
-            // Compiling a mixed mode project with MSVC means that CLR
-            // exceptions will be caught in (...) as well. However, these
-            // do not fill-in std::current_exception and thus lead to crash
-            // when attempting rethrow.
-            // /EHa switch also causes structured exceptions to be caught
-            // here, but they fill-in current_exception properly, so
-            // at worst the output should be a little weird, instead of
-            // causing a crash.
-            if (std::current_exception() == nullptr) {
-                return "Non C++ exception. Possibly a CLR exception.";
-            }
-            return tryTranslators();
-#endif
-        }
-        catch( TestFailureException& ) {
-            std::rethrow_exception(std::current_exception());
-        }
-        catch( std::exception& ex ) {
-            return ex.what();
-        }
-        catch( std::string& msg ) {
-            return msg;
-        }
-        catch( const char* msg ) {
-            return msg;
-        }
-        catch(...) {
-            return "Unknown exception";
-        }
-    }
-
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        if (m_translators.empty()) {
-            std::rethrow_exception(std::current_exception());
-        } else {
-            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
-        }
-    }
-
-#else // ^^ Exceptions are enabled // Exceptions are disabled vv
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
-
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
-#endif
-
-}
-// end catch_exception_translator_registry.cpp
-// start catch_fatal_condition.cpp
-
-#if defined(__GNUC__)
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#endif
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-namespace {
-    // Report the error condition
-    void reportFatal( char const * const message ) {
-        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
-    }
-}
-
-#endif // signals/SEH handling
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-    struct SignalDefs { DWORD id; const char* name; };
-
-    // There is no 1-1 mapping between signals and windows exceptions.
-    // Windows can easily distinguish between SO and SigSegV,
-    // but SigInt, SigTerm, etc are handled differently.
-    static SignalDefs signalDefs[] = {
-        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
-        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
-        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
-        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
-    };
-
-    LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
-        for (auto const& def : signalDefs) {
-            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
-                reportFatal(def.name);
-            }
-        }
-        // If its not an exception we care about, pass it along.
-        // This stops us from eating debugger breaks etc.
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        // 32k seems enough for Catch to handle stack overflow,
-        // but the value was found experimentally, so there is no strong guarantee
-        guaranteeSize = 32 * 1024;
-        exceptionHandlerHandle = nullptr;
-        // Register as first handler in current chain
-        exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
-        // Pass in guarantee size to be filled
-        SetThreadStackGuarantee(&guaranteeSize);
-    }
-
-    void FatalConditionHandler::reset() {
-        if (isSet) {
-            RemoveVectoredExceptionHandler(exceptionHandlerHandle);
-            SetThreadStackGuarantee(&guaranteeSize);
-            exceptionHandlerHandle = nullptr;
-            isSet = false;
-        }
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
-
-bool FatalConditionHandler::isSet = false;
-ULONG FatalConditionHandler::guaranteeSize = 0;
-PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
-
-} // namespace Catch
-
-#elif defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-namespace Catch {
-
-    struct SignalDefs {
-        int id;
-        const char* name;
-    };
-
-    // 32kb for the alternate stack seems to be sufficient. However, this value
-    // is experimentally determined, so that's not guaranteed.
-    static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
-
-    static SignalDefs signalDefs[] = {
-        { SIGINT,  "SIGINT - Terminal interrupt signal" },
-        { SIGILL,  "SIGILL - Illegal instruction signal" },
-        { SIGFPE,  "SIGFPE - Floating point error signal" },
-        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
-        { SIGTERM, "SIGTERM - Termination request signal" },
-        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
-    };
-
-    void FatalConditionHandler::handleSignal( int sig ) {
-        char const * name = "<unknown signal>";
-        for (auto const& def : signalDefs) {
-            if (sig == def.id) {
-                name = def.name;
-                break;
-            }
-        }
-        reset();
-        reportFatal(name);
-        raise( sig );
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        stack_t sigStack;
-        sigStack.ss_sp = altStackMem;
-        sigStack.ss_size = sigStackSize;
-        sigStack.ss_flags = 0;
-        sigaltstack(&sigStack, &oldSigStack);
-        struct sigaction sa = { };
-
-        sa.sa_handler = handleSignal;
-        sa.sa_flags = SA_ONSTACK;
-        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
-            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
-        }
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
-
-    void FatalConditionHandler::reset() {
-        if( isSet ) {
-            // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
-            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
-                sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
-            }
-            // Return the old stack
-            sigaltstack(&oldSigStack, nullptr);
-            isSet = false;
-        }
-    }
-
-    bool FatalConditionHandler::isSet = false;
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
-    stack_t FatalConditionHandler::oldSigStack = {};
-    char FatalConditionHandler::altStackMem[sigStackSize] = {};
-
-} // namespace Catch
-
-#else
-
-namespace Catch {
-    void FatalConditionHandler::reset() {}
-}
-
-#endif // signals/SEH handling
-
-#if defined(__GNUC__)
-#    pragma GCC diagnostic pop
-#endif
-// end catch_fatal_condition.cpp
-// start catch_generators.cpp
-
-#include <limits>
-#include <set>
-
-namespace Catch {
-
-IGeneratorTracker::~IGeneratorTracker() {}
-
-const char* GeneratorException::what() const noexcept {
-    return m_msg;
-}
-
-namespace Generators {
-
-    GeneratorUntypedBase::~GeneratorUntypedBase() {}
-
-    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        return getResultCapture().acquireGeneratorTracker( lineInfo );
-    }
-
-} // namespace Generators
-} // namespace Catch
-// end catch_generators.cpp
-// start catch_interfaces_capture.cpp
-
-namespace Catch {
-    IResultCapture::~IResultCapture() = default;
-}
-// end catch_interfaces_capture.cpp
-// start catch_interfaces_config.cpp
-
-namespace Catch {
-    IConfig::~IConfig() = default;
-}
-// end catch_interfaces_config.cpp
-// start catch_interfaces_exception.cpp
-
-namespace Catch {
-    IExceptionTranslator::~IExceptionTranslator() = default;
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
-}
-// end catch_interfaces_exception.cpp
-// start catch_interfaces_registry_hub.cpp
-
-namespace Catch {
-    IRegistryHub::~IRegistryHub() = default;
-    IMutableRegistryHub::~IMutableRegistryHub() = default;
-}
-// end catch_interfaces_registry_hub.cpp
-// start catch_interfaces_reporter.cpp
-
-// start catch_reporter_listening.h
-
-namespace Catch {
-
-    class ListeningReporter : public IStreamingReporter {
-        using Reporters = std::vector<IStreamingReporterPtr>;
-        Reporters m_listeners;
-        IStreamingReporterPtr m_reporter = nullptr;
-        ReporterPreferences m_preferences;
-
-    public:
-        ListeningReporter();
-
-        void addListener( IStreamingReporterPtr&& listener );
-        void addReporter( IStreamingReporterPtr&& reporter );
-
-    public: // IStreamingReporter
-
-        ReporterPreferences getPreferences() const override;
-
-        void noMatchingTestCases( std::string const& spec ) override;
-
-        void reportInvalidArguments(std::string const&arg) override;
-
-        static std::set<Verbosity> getSupportedVerbosities();
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
-        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
-        void benchmarkFailed(std::string const&) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void testRunStarting( TestRunInfo const& testRunInfo ) override;
-        void testGroupStarting( GroupInfo const& groupInfo ) override;
-        void testCaseStarting( TestCaseInfo const& testInfo ) override;
-        void sectionStarting( SectionInfo const& sectionInfo ) override;
-        void assertionStarting( AssertionInfo const& assertionInfo ) override;
-
-        // The return value indicates if the messages buffer should be cleared:
-        bool assertionEnded( AssertionStats const& assertionStats ) override;
-        void sectionEnded( SectionStats const& sectionStats ) override;
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
-        void testRunEnded( TestRunStats const& testRunStats ) override;
-
-        void skipTest( TestCaseInfo const& testInfo ) override;
-        bool isMulti() const override;
-
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_listening.h
-namespace Catch {
-
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
-    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
-
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
-    :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
-
-    std::ostream& ReporterConfig::stream() const { return *m_stream; }
-    IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
-
-    TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
-
-    GroupInfo::GroupInfo(  std::string const& _name,
-                           std::size_t _groupIndex,
-                           std::size_t _groupsCount )
-    :   name( _name ),
-        groupIndex( _groupIndex ),
-        groupsCounts( _groupsCount )
-    {}
-
-     AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
-                                     std::vector<MessageInfo> const& _infoMessages,
-                                     Totals const& _totals )
-    :   assertionResult( _assertionResult ),
-        infoMessages( _infoMessages ),
-        totals( _totals )
-    {
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
-
-        if( assertionResult.hasMessage() ) {
-            // Copy message into messages list.
-            // !TBD This should have been done earlier, somewhere
-            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
-            builder << assertionResult.getMessage();
-            builder.m_info.message = builder.m_stream.str();
-
-            infoMessages.push_back( builder.m_info );
-        }
-    }
-
-     AssertionStats::~AssertionStats() = default;
-
-    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
-                                 Counts const& _assertions,
-                                 double _durationInSeconds,
-                                 bool _missingAssertions )
-    :   sectionInfo( _sectionInfo ),
-        assertions( _assertions ),
-        durationInSeconds( _durationInSeconds ),
-        missingAssertions( _missingAssertions )
-    {}
-
-    SectionStats::~SectionStats() = default;
-
-    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
-                                   Totals const& _totals,
-                                   std::string const& _stdOut,
-                                   std::string const& _stdErr,
-                                   bool _aborting )
-    : testInfo( _testInfo ),
-        totals( _totals ),
-        stdOut( _stdOut ),
-        stdErr( _stdErr ),
-        aborting( _aborting )
-    {}
-
-    TestCaseStats::~TestCaseStats() = default;
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
-                                    Totals const& _totals,
-                                    bool _aborting )
-    :   groupInfo( _groupInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
-    :   groupInfo( _groupInfo ),
-        aborting( false )
-    {}
-
-    TestGroupStats::~TestGroupStats() = default;
-
-    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
-                    Totals const& _totals,
-                    bool _aborting )
-    :   runInfo( _runInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestRunStats::~TestRunStats() = default;
-
-    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
-    bool IStreamingReporter::isMulti() const { return false; }
-
-    IReporterFactory::~IReporterFactory() = default;
-    IReporterRegistry::~IReporterRegistry() = default;
-
-} // end namespace Catch
-// end catch_interfaces_reporter.cpp
-// start catch_interfaces_runner.cpp
-
-namespace Catch {
-    IRunner::~IRunner() = default;
-}
-// end catch_interfaces_runner.cpp
-// start catch_interfaces_testcase.cpp
-
-namespace Catch {
-    ITestInvoker::~ITestInvoker() = default;
-    ITestCaseRegistry::~ITestCaseRegistry() = default;
-}
-// end catch_interfaces_testcase.cpp
-// start catch_leak_detector.cpp
-
-#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
-#include <crtdbg.h>
-
-namespace Catch {
-
-    LeakDetector::LeakDetector() {
-        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-        flag |= _CRTDBG_LEAK_CHECK_DF;
-        flag |= _CRTDBG_ALLOC_MEM_DF;
-        _CrtSetDbgFlag(flag);
-        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-        // Change this to leaking allocation's number to break there
-        _CrtSetBreakAlloc(-1);
-    }
-}
-
-#else
-
-    Catch::LeakDetector::LeakDetector() {}
-
-#endif
-
-Catch::LeakDetector::~LeakDetector() {
-    Catch::cleanUp();
-}
-// end catch_leak_detector.cpp
-// start catch_list.cpp
-
-// start catch_list.h
-
-#include <set>
-
-namespace Catch {
-
-    std::size_t listTests( Config const& config );
-
-    std::size_t listTestsNamesOnly( Config const& config );
-
-    struct TagInfo {
-        void add( std::string const& spelling );
-        std::string all() const;
-
-        std::set<std::string> spellings;
-        std::size_t count = 0;
-    };
-
-    std::size_t listTags( Config const& config );
-
-    std::size_t listReporters();
-
-    Option<std::size_t> list( std::shared_ptr<Config> const& config );
-
-} // end namespace Catch
-
-// end catch_list.h
-// start catch_text.h
-
-namespace Catch {
-    using namespace clara::TextFlow;
-}
-
-// end catch_text.h
-#include <limits>
-#include <algorithm>
-#include <iomanip>
-
-namespace Catch {
-
-    std::size_t listTests( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
-        if( config.hasTestFilters() )
-            Catch::cout() << "Matching test cases:\n";
-        else {
-            Catch::cout() << "All available test cases:\n";
-        }
-
-        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            Colour::Code colour = testCaseInfo.isHidden()
-                ? Colour::SecondaryText
-                : Colour::None;
-            Colour colourGuard( colour );
-
-            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
-            if( config.verbosity() >= Verbosity::High ) {
-                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
-                std::string description = testCaseInfo.description;
-                if( description.empty() )
-                    description = "(NO DESCRIPTION)";
-                Catch::cout() << Column( description ).indent(4) << std::endl;
-            }
-            if( !testCaseInfo.tags.empty() )
-                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
-        }
-
-        if( !config.hasTestFilters() )
-            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
-        else
-            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
-        return matchedTestCases.size();
-    }
-
-    std::size_t listTestsNamesOnly( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
-        std::size_t matchedTests = 0;
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            matchedTests++;
-            if( startsWith( testCaseInfo.name, '#' ) )
-               Catch::cout() << '"' << testCaseInfo.name << '"';
-            else
-               Catch::cout() << testCaseInfo.name;
-            if ( config.verbosity() >= Verbosity::High )
-                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
-            Catch::cout() << std::endl;
-        }
-        return matchedTests;
-    }
-
-    void TagInfo::add( std::string const& spelling ) {
-        ++count;
-        spellings.insert( spelling );
-    }
-
-    std::string TagInfo::all() const {
-        size_t size = 0;
-        for (auto const& spelling : spellings) {
-            // Add 2 for the brackes
-            size += spelling.size() + 2;
-        }
-
-        std::string out; out.reserve(size);
-        for (auto const& spelling : spellings) {
-            out += '[';
-            out += spelling;
-            out += ']';
-        }
-        return out;
-    }
-
-    std::size_t listTags( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
-        if( config.hasTestFilters() )
-            Catch::cout() << "Tags for matching test cases:\n";
-        else {
-            Catch::cout() << "All available tags:\n";
-        }
-
-        std::map<std::string, TagInfo> tagCounts;
-
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCase : matchedTestCases ) {
-            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
-                std::string lcaseTagName = toLower( tagName );
-                auto countIt = tagCounts.find( lcaseTagName );
-                if( countIt == tagCounts.end() )
-                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
-                countIt->second.add( tagName );
-            }
-        }
-
-        for( auto const& tagCount : tagCounts ) {
-            ReusableStringStream rss;
-            rss << "  " << std::setw(2) << tagCount.second.count << "  ";
-            auto str = rss.str();
-            auto wrapper = Column( tagCount.second.all() )
-                                                    .initialIndent( 0 )
-                                                    .indent( str.size() )
-                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
-            Catch::cout() << str << wrapper << '\n';
-        }
-        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
-        return tagCounts.size();
-    }
-
-    std::size_t listReporters() {
-        Catch::cout() << "Available reporters:\n";
-        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-        std::size_t maxNameLen = 0;
-        for( auto const& factoryKvp : factories )
-            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
-
-        for( auto const& factoryKvp : factories ) {
-            Catch::cout()
-                    << Column( factoryKvp.first + ":" )
-                            .indent(2)
-                            .width( 5+maxNameLen )
-                    +  Column( factoryKvp.second->getDescription() )
-                            .initialIndent(0)
-                            .indent(2)
-                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
-                    << "\n";
-        }
-        Catch::cout() << std::endl;
-        return factories.size();
-    }
-
-    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
-        Option<std::size_t> listedCount;
-        getCurrentMutableContext().setConfig( config );
-        if( config->listTests() )
-            listedCount = listedCount.valueOr(0) + listTests( *config );
-        if( config->listTestNamesOnly() )
-            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
-        if( config->listTags() )
-            listedCount = listedCount.valueOr(0) + listTags( *config );
-        if( config->listReporters() )
-            listedCount = listedCount.valueOr(0) + listReporters();
-        return listedCount;
-    }
-
-} // end namespace Catch
-// end catch_list.cpp
-// start catch_matchers.cpp
-
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-        std::string MatcherUntypedBase::toString() const {
-            if( m_cachedToString.empty() )
-                m_cachedToString = describe();
-            return m_cachedToString;
-        }
-
-        MatcherUntypedBase::~MatcherUntypedBase() = default;
-
-    } // namespace Impl
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
-
-} // namespace Catch
-// end catch_matchers.cpp
-// start catch_matchers_exception.cpp
-
-namespace Catch {
-namespace Matchers {
-namespace Exception {
-
-bool ExceptionMessageMatcher::match(std::exception const& ex) const {
-    return ex.what() == m_message;
-}
-
-std::string ExceptionMessageMatcher::describe() const {
-    return "exception message matches \"" + m_message + "\"";
-}
-
-}
-Exception::ExceptionMessageMatcher Message(std::string const& message) {
-    return Exception::ExceptionMessageMatcher(message);
-}
-
-// namespace Exception
-} // namespace Matchers
-} // namespace Catch
-// end catch_matchers_exception.cpp
-// start catch_matchers_floating.cpp
-
-// start catch_polyfills.hpp
-
-namespace Catch {
-    bool isnan(float f);
-    bool isnan(double d);
-}
-
-// end catch_polyfills.hpp
-// start catch_to_string.hpp
-
-#include <string>
-
-namespace Catch {
-    template <typename T>
-    std::string to_string(T const& t) {
-#if defined(CATCH_CONFIG_CPP11_TO_STRING)
-        return std::to_string(t);
-#else
-        ReusableStringStream rss;
-        rss << t;
-        return rss.str();
-#endif
-    }
-} // end namespace Catch
-
-// end catch_to_string.hpp
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
-#include <cstdint>
-#include <cstring>
-#include <sstream>
-#include <type_traits>
-#include <iomanip>
-#include <limits>
-
-namespace Catch {
-namespace {
-
-    int32_t convert(float f) {
-        static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
-        int32_t i;
-        std::memcpy(&i, &f, sizeof(f));
-        return i;
-    }
-
-    int64_t convert(double d) {
-        static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
-        int64_t i;
-        std::memcpy(&i, &d, sizeof(d));
-        return i;
-    }
-
-    template <typename FP>
-    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
-        // Comparison with NaN should always be false.
-        // This way we can rule it out before getting into the ugly details
-        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
-            return false;
-        }
-
-        auto lc = convert(lhs);
-        auto rc = convert(rhs);
-
-        if ((lc < 0) != (rc < 0)) {
-            // Potentially we can have +0 and -0
-            return lhs == rhs;
-        }
-
-        auto ulpDiff = std::abs(lc - rc);
-        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
-    }
-
-#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-
-    float nextafter(float x, float y) {
-        return ::nextafterf(x, y);
-    }
-
-    double nextafter(double x, double y) {
-        return ::nextafter(x, y);
-    }
-
-#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
-
-template <typename FP>
-FP step(FP start, FP direction, uint64_t steps) {
-    for (uint64_t i = 0; i < steps; ++i) {
-#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-        start = Catch::nextafter(start, direction);
-#else
-        start = std::nextafter(start, direction);
-#endif
-    }
-    return start;
-}
-
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
-
-template <typename FloatingPoint>
-void write(std::ostream& out, FloatingPoint num) {
-    out << std::scientific
-        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
-        << num;
-}
-
-} // end anonymous namespace
-
-namespace Matchers {
-namespace Floating {
-
-    enum class FloatingPointKind : uint8_t {
-        Float,
-        Double
-    };
-
-    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
-        :m_target{ target }, m_margin{ margin } {
-        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
-            << " Margin has to be non-negative.");
-    }
-
-    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
-    // But without the subtraction to allow for INFINITY in comparison
-    bool WithinAbsMatcher::match(double const& matchee) const {
-        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
-    }
-
-    std::string WithinAbsMatcher::describe() const {
-        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
-    }
-
-    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
-        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
-        CATCH_ENFORCE(m_type == FloatingPointKind::Double
-                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
-            "Provided ULP is impossibly large for a float comparison.");
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-// Clang <3.5 reports on the default branch in the switch below
-#pragma clang diagnostic ignored "-Wunreachable-code"
-#endif
-
-    bool WithinUlpsMatcher::match(double const& matchee) const {
-        switch (m_type) {
-        case FloatingPointKind::Float:
-            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
-        case FloatingPointKind::Double:
-            return almostEqualUlps<double>(matchee, m_target, m_ulps);
-        default:
-            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
-        }
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-    std::string WithinUlpsMatcher::describe() const {
-        std::stringstream ret;
-
-        ret << "is within " << m_ulps << " ULPs of ";
-
-        if (m_type == FloatingPointKind::Float) {
-            write(ret, static_cast<float>(m_target));
-            ret << 'f';
-        } else {
-            write(ret, m_target);
-        }
-
-        ret << " ([";
-        if (m_type == FloatingPointKind::Double) {
-            write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
-            ret << ", ";
-            write(ret, step(m_target, static_cast<double>( INFINITY), m_ulps));
-        } else {
-            // We have to cast INFINITY to float because of MinGW, see #1782
-            write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
-            ret << ", ";
-            write(ret, step(static_cast<float>(m_target), static_cast<float>( INFINITY), m_ulps));
-        }
-        ret << "])";
-
-        return ret.str();
-    }
-
-    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
-        m_target(target),
-        m_epsilon(epsilon){
-        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
-        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
-    }
-
-    bool WithinRelMatcher::match(double const& matchee) const {
-        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
-        return marginComparison(matchee, m_target,
-                                std::isinf(relMargin)? 0 : relMargin);
-    }
-
-    std::string WithinRelMatcher::describe() const {
-        Catch::ReusableStringStream sstr;
-        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
-        return sstr.str();
-    }
-
-}// namespace Floating
-
-Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
-    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
-}
-
-Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
-    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
-}
-
-Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
-    return Floating::WithinAbsMatcher(target, margin);
-}
-
-Floating::WithinRelMatcher WithinRel(double target, double eps) {
-    return Floating::WithinRelMatcher(target, eps);
-}
-
-Floating::WithinRelMatcher WithinRel(double target) {
-    return Floating::WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
-}
-
-Floating::WithinRelMatcher WithinRel(float target, float eps) {
-    return Floating::WithinRelMatcher(target, eps);
-}
-
-Floating::WithinRelMatcher WithinRel(float target) {
-    return Floating::WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
-}
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_floating.cpp
-// start catch_matchers_generic.cpp
-
-std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
-    if (desc.empty()) {
-        return "matches undescribed predicate";
-    } else {
-        return "matches predicate: \"" + desc + '"';
-    }
-}
-// end catch_matchers_generic.cpp
-// start catch_matchers_string.cpp
-
-#include <regex>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace StdString {
-
-        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
-        :   m_caseSensitivity( caseSensitivity ),
-            m_str( adjustString( str ) )
-        {}
-        std::string CasedString::adjustString( std::string const& str ) const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? toLower( str )
-                   : str;
-        }
-        std::string CasedString::caseSensitivitySuffix() const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? " (case insensitive)"
-                   : std::string();
-        }
-
-        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
-        : m_comparator( comparator ),
-          m_operation( operation ) {
-        }
-
-        std::string StringMatcherBase::describe() const {
-            std::string description;
-            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
-                                        m_comparator.caseSensitivitySuffix().size());
-            description += m_operation;
-            description += ": \"";
-            description += m_comparator.m_str;
-            description += "\"";
-            description += m_comparator.caseSensitivitySuffix();
-            return description;
-        }
-
-        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
-
-        bool EqualsMatcher::match( std::string const& source ) const {
-            return m_comparator.adjustString( source ) == m_comparator.m_str;
-        }
-
-        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
-
-        bool ContainsMatcher::match( std::string const& source ) const {
-            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
-
-        bool StartsWithMatcher::match( std::string const& source ) const {
-            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
-
-        bool EndsWithMatcher::match( std::string const& source ) const {
-            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
-
-        bool RegexMatcher::match(std::string const& matchee) const {
-            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
-            if (m_caseSensitivity == CaseSensitive::Choice::No) {
-                flags |= std::regex::icase;
-            }
-            auto reg = std::regex(m_regex, flags);
-            return std::regex_match(matchee, reg);
-        }
-
-        std::string RegexMatcher::describe() const {
-            return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
-        }
-
-    } // namespace StdString
-
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-
-    StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
-        return StdString::RegexMatcher(regex, caseSensitivity);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-// end catch_matchers_string.cpp
-// start catch_message.cpp
-
-// start catch_uncaught_exceptions.h
-
-namespace Catch {
-    bool uncaught_exceptions();
-} // end namespace Catch
-
-// end catch_uncaught_exceptions.h
-#include <cassert>
-#include <stack>
-
-namespace Catch {
-
-    MessageInfo::MessageInfo(   StringRef const& _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        type( _type ),
-        sequence( ++globalCount )
-    {}
-
-    bool MessageInfo::operator==( MessageInfo const& other ) const {
-        return sequence == other.sequence;
-    }
-
-    bool MessageInfo::operator<( MessageInfo const& other ) const {
-        return sequence < other.sequence;
-    }
-
-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
-                                           SourceLineInfo const& lineInfo,
-                                           ResultWas::OfType type )
-        :m_info(macroName, lineInfo, type) {}
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
-    : m_info( builder.m_info ), m_moved()
-    {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
-    }
-
-    ScopedMessage::ScopedMessage( ScopedMessage&& old )
-    : m_info( old.m_info ), m_moved()
-    {
-        old.m_moved = true;
-    }
-
-    ScopedMessage::~ScopedMessage() {
-        if ( !uncaught_exceptions() && !m_moved ){
-            getResultCapture().popScopedMessage(m_info);
-        }
-    }
-
-    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
-        auto trimmed = [&] (size_t start, size_t end) {
-            while (names[start] == ',' || isspace(names[start])) {
-                ++start;
-            }
-            while (names[end] == ',' || isspace(names[end])) {
-                --end;
-            }
-            return names.substr(start, end - start + 1);
-        };
-        auto skipq = [&] (size_t start, char quote) {
-            for (auto i = start + 1; i < names.size() ; ++i) {
-                if (names[i] == quote)
-                    return i;
-                if (names[i] == '\\')
-                    ++i;
-            }
-            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
-        };
-
-        size_t start = 0;
-        std::stack<char> openings;
-        for (size_t pos = 0; pos < names.size(); ++pos) {
-            char c = names[pos];
-            switch (c) {
-            case '[':
-            case '{':
-            case '(':
-            // It is basically impossible to disambiguate between
-            // comparison and start of template args in this context
-//            case '<':
-                openings.push(c);
-                break;
-            case ']':
-            case '}':
-            case ')':
-//           case '>':
-                openings.pop();
-                break;
-            case '"':
-            case '\'':
-                pos = skipq(pos, c);
-                break;
-            case ',':
-                if (start != pos && openings.empty()) {
-                    m_messages.emplace_back(macroName, lineInfo, resultType);
-                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
-                    m_messages.back().message += " := ";
-                    start = pos;
-                }
-            }
-        }
-        assert(openings.empty() && "Mismatched openings");
-        m_messages.emplace_back(macroName, lineInfo, resultType);
-        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
-        m_messages.back().message += " := ";
-    }
-    Capturer::~Capturer() {
-        if ( !uncaught_exceptions() ){
-            assert( m_captured == m_messages.size() );
-            for( size_t i = 0; i < m_captured; ++i  )
-                m_resultCapture.popScopedMessage( m_messages[i] );
-        }
-    }
-
-    void Capturer::captureValue( size_t index, std::string const& value ) {
-        assert( index < m_messages.size() );
-        m_messages[index].message += value;
-        m_resultCapture.pushScopedMessage( m_messages[index] );
-        m_captured++;
-    }
-
-} // end namespace Catch
-// end catch_message.cpp
-// start catch_output_redirect.cpp
-
-// start catch_output_redirect.h
-#ifndef TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-#define TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-
-#include <cstdio>
-#include <iosfwd>
-#include <string>
-
-namespace Catch {
-
-    class RedirectedStream {
-        std::ostream& m_originalStream;
-        std::ostream& m_redirectionStream;
-        std::streambuf* m_prevBuf;
-
-    public:
-        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
-        ~RedirectedStream();
-    };
-
-    class RedirectedStdOut {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cout;
-    public:
-        RedirectedStdOut();
-        auto str() const -> std::string;
-    };
-
-    // StdErr has two constituent streams in C++, std::cerr and std::clog
-    // This means that we need to redirect 2 streams into 1 to keep proper
-    // order of writes
-    class RedirectedStdErr {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cerr;
-        RedirectedStream m_clog;
-    public:
-        RedirectedStdErr();
-        auto str() const -> std::string;
-    };
-
-    class RedirectedStreams {
-    public:
-        RedirectedStreams(RedirectedStreams const&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
-        RedirectedStreams(RedirectedStreams&&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
-
-        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
-        ~RedirectedStreams();
-    private:
-        std::string& m_redirectedCout;
-        std::string& m_redirectedCerr;
-        RedirectedStdOut m_redirectedStdOut;
-        RedirectedStdErr m_redirectedStdErr;
-    };
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-    // Windows's implementation of std::tmpfile is terrible (it tries
-    // to create a file inside system folder, thus requiring elevated
-    // privileges for the binary), so we have to use tmpnam(_s) and
-    // create the file ourselves there.
-    class TempFile {
-    public:
-        TempFile(TempFile const&) = delete;
-        TempFile& operator=(TempFile const&) = delete;
-        TempFile(TempFile&&) = delete;
-        TempFile& operator=(TempFile&&) = delete;
-
-        TempFile();
-        ~TempFile();
-
-        std::FILE* getFile();
-        std::string getContents();
-
-    private:
-        std::FILE* m_file = nullptr;
-    #if defined(_MSC_VER)
-        char m_buffer[L_tmpnam] = { 0 };
-    #endif
-    };
-
-    class OutputRedirect {
-    public:
-        OutputRedirect(OutputRedirect const&) = delete;
-        OutputRedirect& operator=(OutputRedirect const&) = delete;
-        OutputRedirect(OutputRedirect&&) = delete;
-        OutputRedirect& operator=(OutputRedirect&&) = delete;
-
-        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
-        ~OutputRedirect();
-
-    private:
-        int m_originalStdout = -1;
-        int m_originalStderr = -1;
-        TempFile m_stdoutFile;
-        TempFile m_stderrFile;
-        std::string& m_stdoutDest;
-        std::string& m_stderrDest;
-    };
-
-#endif
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-// end catch_output_redirect.h
-#include <cstdio>
-#include <cstring>
-#include <fstream>
-#include <sstream>
-#include <stdexcept>
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #include <io.h>      //_dup and _dup2
-    #define dup _dup
-    #define dup2 _dup2
-    #define fileno _fileno
-    #else
-    #include <unistd.h>  // dup and dup2
-    #endif
-#endif
-
-namespace Catch {
-
-    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
-    :   m_originalStream( originalStream ),
-        m_redirectionStream( redirectionStream ),
-        m_prevBuf( m_originalStream.rdbuf() )
-    {
-        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
-    }
-
-    RedirectedStream::~RedirectedStream() {
-        m_originalStream.rdbuf( m_prevBuf );
-    }
-
-    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
-    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStdErr::RedirectedStdErr()
-    :   m_cerr( Catch::cerr(), m_rss.get() ),
-        m_clog( Catch::clog(), m_rss.get() )
-    {}
-    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
-    :   m_redirectedCout(redirectedCout),
-        m_redirectedCerr(redirectedCerr)
-    {}
-
-    RedirectedStreams::~RedirectedStreams() {
-        m_redirectedCout += m_redirectedStdOut.str();
-        m_redirectedCerr += m_redirectedStdErr.str();
-    }
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-#if defined(_MSC_VER)
-    TempFile::TempFile() {
-        if (tmpnam_s(m_buffer)) {
-            CATCH_RUNTIME_ERROR("Could not get a temp filename");
-        }
-        if (fopen_s(&m_file, m_buffer, "w")) {
-            char buffer[100];
-            if (strerror_s(buffer, errno)) {
-                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
-            }
-            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
-        }
-    }
-#else
-    TempFile::TempFile() {
-        m_file = std::tmpfile();
-        if (!m_file) {
-            CATCH_RUNTIME_ERROR("Could not create a temp file.");
-        }
-    }
-
-#endif
-
-    TempFile::~TempFile() {
-         // TBD: What to do about errors here?
-         std::fclose(m_file);
-         // We manually create the file on Windows only, on Linux
-         // it will be autodeleted
-#if defined(_MSC_VER)
-         std::remove(m_buffer);
-#endif
-    }
-
-    FILE* TempFile::getFile() {
-        return m_file;
-    }
-
-    std::string TempFile::getContents() {
-        std::stringstream sstr;
-        char buffer[100] = {};
-        std::rewind(m_file);
-        while (std::fgets(buffer, sizeof(buffer), m_file)) {
-            sstr << buffer;
-        }
-        return sstr.str();
-    }
-
-    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
-        m_originalStdout(dup(1)),
-        m_originalStderr(dup(2)),
-        m_stdoutDest(stdout_dest),
-        m_stderrDest(stderr_dest) {
-        dup2(fileno(m_stdoutFile.getFile()), 1);
-        dup2(fileno(m_stderrFile.getFile()), 2);
-    }
-
-    OutputRedirect::~OutputRedirect() {
-        Catch::cout() << std::flush;
-        fflush(stdout);
-        // Since we support overriding these streams, we flush cerr
-        // even though std::cerr is unbuffered
-        Catch::cerr() << std::flush;
-        Catch::clog() << std::flush;
-        fflush(stderr);
-
-        dup2(m_originalStdout, 1);
-        dup2(m_originalStderr, 2);
-
-        m_stdoutDest += m_stdoutFile.getContents();
-        m_stderrDest += m_stderrFile.getContents();
-    }
-
-#endif // CATCH_CONFIG_NEW_CAPTURE
-
-} // namespace Catch
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #undef dup
-    #undef dup2
-    #undef fileno
-    #endif
-#endif
-// end catch_output_redirect.cpp
-// start catch_polyfills.cpp
-
-#include <cmath>
-
-namespace Catch {
-
-#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-    bool isnan(float f) {
-        return std::isnan(f);
-    }
-    bool isnan(double d) {
-        return std::isnan(d);
-    }
-#else
-    // For now we only use this for embarcadero
-    bool isnan(float f) {
-        return std::_isnan(f);
-    }
-    bool isnan(double d) {
-        return std::_isnan(d);
-    }
-#endif
-
-} // end namespace Catch
-// end catch_polyfills.cpp
-// start catch_random_number_generator.cpp
-
-namespace Catch {
-
-namespace {
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4146) // we negate uint32 during the rotate
-#endif
-        // Safe rotr implementation thanks to John Regehr
-        uint32_t rotate_right(uint32_t val, uint32_t count) {
-            const uint32_t mask = 31;
-            count &= mask;
-            return (val >> count) | (val << (-count & mask));
-        }
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-}
-
-    SimplePcg32::SimplePcg32(result_type seed_) {
-        seed(seed_);
-    }
-
-    void SimplePcg32::seed(result_type seed_) {
-        m_state = 0;
-        (*this)();
-        m_state += seed_;
-        (*this)();
-    }
-
-    void SimplePcg32::discard(uint64_t skip) {
-        // We could implement this to run in O(log n) steps, but this
-        // should suffice for our use case.
-        for (uint64_t s = 0; s < skip; ++s) {
-            static_cast<void>((*this)());
-        }
-    }
-
-    SimplePcg32::result_type SimplePcg32::operator()() {
-        // prepare the output value
-        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
-        const auto output = rotate_right(xorshifted, m_state >> 59u);
-
-        // advance state
-        m_state = m_state * 6364136223846793005ULL + s_inc;
-
-        return output;
-    }
-
-    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
-        return lhs.m_state == rhs.m_state;
-    }
-
-    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
-        return lhs.m_state != rhs.m_state;
-    }
-}
-// end catch_random_number_generator.cpp
-// start catch_registry_hub.cpp
-
-// start catch_test_case_registry_impl.h
-
-#include <vector>
-#include <set>
-#include <algorithm>
-#include <ios>
-
-namespace Catch {
-
-    class TestCase;
-    struct IConfig;
-
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
-
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
-
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
-
-    class TestRegistry : public ITestCaseRegistry {
-    public:
-        virtual ~TestRegistry() = default;
-
-        virtual void registerTest( TestCase const& testCase );
-
-        std::vector<TestCase> const& getAllTests() const override;
-        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
-
-    private:
-        std::vector<TestCase> m_functions;
-        mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
-        mutable std::vector<TestCase> m_sortedFunctions;
-        std::size_t m_unnamedCount = 0;
-        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class TestInvokerAsFunction : public ITestInvoker {
-        void(*m_testAsFunction)();
-    public:
-        TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
-
-        void invoke() const override;
-    };
-
-    std::string extractClassName( StringRef const& classOrQualifiedMethodName );
-
-    ///////////////////////////////////////////////////////////////////////////
-
-} // end namespace Catch
-
-// end catch_test_case_registry_impl.h
-// start catch_reporter_registry.h
-
-#include <map>
-
-namespace Catch {
-
-    class ReporterRegistry : public IReporterRegistry {
-
-    public:
-
-        ~ReporterRegistry() override;
-
-        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
-
-        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
-        void registerListener( IReporterFactoryPtr const& factory );
-
-        FactoryMap const& getFactories() const override;
-        Listeners const& getListeners() const override;
-
-    private:
-        FactoryMap m_factories;
-        Listeners m_listeners;
-    };
-}
-
-// end catch_reporter_registry.h
-// start catch_tag_alias_registry.h
-
-// start catch_tag_alias.h
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias {
-        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
-
-        std::string tag;
-        SourceLineInfo lineInfo;
-    };
-
-} // end namespace Catch
-
-// end catch_tag_alias.h
-#include <map>
-
-namespace Catch {
-
-    class TagAliasRegistry : public ITagAliasRegistry {
-    public:
-        ~TagAliasRegistry() override;
-        TagAlias const* find( std::string const& alias ) const override;
-        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
-        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
-
-    private:
-        std::map<std::string, TagAlias> m_registry;
-    };
-
-} // end namespace Catch
-
-// end catch_tag_alias_registry.h
-// start catch_startup_exception_registry.h
-
-#include <vector>
-#include <exception>
-
-namespace Catch {
-
-    class StartupExceptionRegistry {
-    public:
-        void add(std::exception_ptr const& exception) noexcept;
-        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
-    private:
-        std::vector<std::exception_ptr> m_exceptions;
-    };
-
-} // end namespace Catch
-
-// end catch_startup_exception_registry.h
-// start catch_singletons.hpp
-
-namespace Catch {
-
-    struct ISingleton {
-        virtual ~ISingleton();
-    };
-
-    void addSingleton( ISingleton* singleton );
-    void cleanupSingletons();
-
-    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
-    class Singleton : SingletonImplT, public ISingleton {
-
-        static auto getInternal() -> Singleton* {
-            static Singleton* s_instance = nullptr;
-            if( !s_instance ) {
-                s_instance = new Singleton;
-                addSingleton( s_instance );
-            }
-            return s_instance;
-        }
-
-    public:
-        static auto get() -> InterfaceT const& {
-            return *getInternal();
-        }
-        static auto getMutable() -> MutableInterfaceT& {
-            return *getInternal();
-        }
-    };
-
-} // namespace Catch
-
-// end catch_singletons.hpp
-namespace Catch {
-
-    namespace {
-
-        class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
-                            private NonCopyable {
-
-        public: // IRegistryHub
-            RegistryHub() = default;
-            IReporterRegistry const& getReporterRegistry() const override {
-                return m_reporterRegistry;
-            }
-            ITestCaseRegistry const& getTestCaseRegistry() const override {
-                return m_testCaseRegistry;
-            }
-            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
-                return m_exceptionTranslatorRegistry;
-            }
-            ITagAliasRegistry const& getTagAliasRegistry() const override {
-                return m_tagAliasRegistry;
-            }
-            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
-                return m_exceptionRegistry;
-            }
-
-        public: // IMutableRegistryHub
-            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerReporter( name, factory );
-            }
-            void registerListener( IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerListener( factory );
-            }
-            void registerTest( TestCase const& testInfo ) override {
-                m_testCaseRegistry.registerTest( testInfo );
-            }
-            void registerTranslator( const IExceptionTranslator* translator ) override {
-                m_exceptionTranslatorRegistry.registerTranslator( translator );
-            }
-            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
-                m_tagAliasRegistry.add( alias, tag, lineInfo );
-            }
-            void registerStartupException() noexcept override {
-                m_exceptionRegistry.add(std::current_exception());
-            }
-            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
-                return m_enumValuesRegistry;
-            }
-
-        private:
-            TestRegistry m_testCaseRegistry;
-            ReporterRegistry m_reporterRegistry;
-            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
-            TagAliasRegistry m_tagAliasRegistry;
-            StartupExceptionRegistry m_exceptionRegistry;
-            Detail::EnumValuesRegistry m_enumValuesRegistry;
-        };
-    }
-
-    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
-
-    IRegistryHub const& getRegistryHub() {
-        return RegistryHubSingleton::get();
-    }
-    IMutableRegistryHub& getMutableRegistryHub() {
-        return RegistryHubSingleton::getMutable();
-    }
-    void cleanUp() {
-        cleanupSingletons();
-        cleanUpContext();
-    }
-    std::string translateActiveException() {
-        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
-    }
-
-} // end namespace Catch
-// end catch_registry_hub.cpp
-// start catch_reporter_registry.cpp
-
-namespace Catch {
-
-    ReporterRegistry::~ReporterRegistry() = default;
-
-    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
-        auto it =  m_factories.find( name );
-        if( it == m_factories.end() )
-            return nullptr;
-        return it->second->create( ReporterConfig( config ) );
-    }
-
-    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
-        m_factories.emplace(name, factory);
-    }
-    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
-        m_listeners.push_back( factory );
-    }
-
-    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
-        return m_factories;
-    }
-    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
-        return m_listeners;
-    }
-
-}
-// end catch_reporter_registry.cpp
-// start catch_result_type.cpp
-
-namespace Catch {
-
-    bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    bool isJustInfo( int flags ) {
-        return flags == ResultWas::Info;
-    }
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
-    }
-
-    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
-    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
-
-} // end namespace Catch
-// end catch_result_type.cpp
-// start catch_run_context.cpp
-
-#include <cassert>
-#include <algorithm>
-#include <sstream>
-
-namespace Catch {
-
-    namespace Generators {
-        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
-            GeneratorBasePtr m_generator;
-
-            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-            :   TrackerBase( nameAndLocation, ctx, parent )
-            {}
-            ~GeneratorTracker();
-
-            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
-                std::shared_ptr<GeneratorTracker> tracker;
-
-                ITracker& currentTracker = ctx.currentTracker();
-                if( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-                    assert( childTracker );
-                    assert( childTracker->isGeneratorTracker() );
-                    tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
-                }
-                else {
-                    tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
-                    currentTracker.addChild( tracker );
-                }
-
-                if( !ctx.completedCycle() && !tracker->isComplete() ) {
-                    tracker->open();
-                }
-
-                return *tracker;
-            }
-
-            // TrackerBase interface
-            bool isGeneratorTracker() const override { return true; }
-            auto hasGenerator() const -> bool override {
-                return !!m_generator;
-            }
-            void close() override {
-                TrackerBase::close();
-                // Generator interface only finds out if it has another item on atual move
-                if (m_runState == CompletedSuccessfully && m_generator->next()) {
-                    m_children.clear();
-                    m_runState = Executing;
-                }
-            }
-
-            // IGeneratorTracker interface
-            auto getGenerator() const -> GeneratorBasePtr const& override {
-                return m_generator;
-            }
-            void setGenerator( GeneratorBasePtr&& generator ) override {
-                m_generator = std::move( generator );
-            }
-        };
-        GeneratorTracker::~GeneratorTracker() {}
-    }
-
-    RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
-    :   m_runInfo(_config->name()),
-        m_context(getCurrentMutableContext()),
-        m_config(_config),
-        m_reporter(std::move(reporter)),
-        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
-        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
-    {
-        m_context.setRunner(this);
-        m_context.setConfig(m_config);
-        m_context.setResultCapture(this);
-        m_reporter->testRunStarting(m_runInfo);
-    }
-
-    RunContext::~RunContext() {
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
-    }
-
-    void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
-    }
-
-    void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
-    }
-
-    Totals RunContext::runTest(TestCase const& testCase) {
-        Totals prevTotals = m_totals;
-
-        std::string redirectedCout;
-        std::string redirectedCerr;
-
-        auto const& testInfo = testCase.getTestCaseInfo();
-
-        m_reporter->testCaseStarting(testInfo);
-
-        m_activeTestCase = &testCase;
-
-        ITracker& rootTracker = m_trackerContext.startRun();
-        assert(rootTracker.isSectionTracker());
-        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
-        do {
-            m_trackerContext.startCycle();
-            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
-            runCurrentTest(redirectedCout, redirectedCerr);
-        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
-
-        Totals deltaTotals = m_totals.delta(prevTotals);
-        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
-            deltaTotals.assertions.failed++;
-            deltaTotals.testCases.passed--;
-            deltaTotals.testCases.failed++;
-        }
-        m_totals.testCases += deltaTotals.testCases;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  redirectedCout,
-                                  redirectedCerr,
-                                  aborting()));
-
-        m_activeTestCase = nullptr;
-        m_testCaseTracker = nullptr;
-
-        return deltaTotals;
-    }
-
-    IConfigPtr RunContext::config() const {
-        return m_config;
-    }
-
-    IStreamingReporter& RunContext::reporter() const {
-        return *m_reporter;
-    }
-
-    void RunContext::assertionEnded(AssertionResult const & result) {
-        if (result.getResultType() == ResultWas::Ok) {
-            m_totals.assertions.passed++;
-            m_lastAssertionPassed = true;
-        } else if (!result.isOk()) {
-            m_lastAssertionPassed = false;
-            if( m_activeTestCase->getTestCaseInfo().okToFail() )
-                m_totals.assertions.failedButOk++;
-            else
-                m_totals.assertions.failed++;
-        }
-        else {
-            m_lastAssertionPassed = true;
-        }
-
-        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
-        // and should be let to clear themselves out.
-        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
-
-        if (result.getResultType() != ResultWas::Warning)
-            m_messageScopes.clear();
-
-        // Reset working state
-        resetAssertionInfo();
-        m_lastResult = result;
-    }
-    void RunContext::resetAssertionInfo() {
-        m_lastAssertionInfo.macroName = StringRef();
-        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
-    }
-
-    bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
-        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
-        if (!sectionTracker.isOpen())
-            return false;
-        m_activeSections.push_back(&sectionTracker);
-
-        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
-
-        m_reporter->sectionStarting(sectionInfo);
-
-        assertions = m_totals.assertions;
-
-        return true;
-    }
-    auto RunContext::acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        using namespace Generators;
-        GeneratorTracker& tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( "generator", lineInfo ) );
-        assert( tracker.isOpen() );
-        m_lastAssertionInfo.lineInfo = lineInfo;
-        return tracker;
-    }
-
-    bool RunContext::testForMissingAssertions(Counts& assertions) {
-        if (assertions.total() != 0)
-            return false;
-        if (!m_config->warnAboutMissingAssertions())
-            return false;
-        if (m_trackerContext.currentTracker().hasChildren())
-            return false;
-        m_totals.assertions.failed++;
-        assertions.failed++;
-        return true;
-    }
-
-    void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
-        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        if (!m_activeSections.empty()) {
-            m_activeSections.back()->close();
-            m_activeSections.pop_back();
-        }
-
-        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
-        m_messages.clear();
-        m_messageScopes.clear();
-    }
-
-    void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
-        if (m_unfinishedSections.empty())
-            m_activeSections.back()->fail();
-        else
-            m_activeSections.back()->close();
-        m_activeSections.pop_back();
-
-        m_unfinishedSections.push_back(endInfo);
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void RunContext::benchmarkPreparing(std::string const& name) {
-		m_reporter->benchmarkPreparing(name);
-	}
-    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
-        m_reporter->benchmarkStarting( info );
-    }
-    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
-        m_reporter->benchmarkEnded( stats );
-    }
-	void RunContext::benchmarkFailed(std::string const & error) {
-		m_reporter->benchmarkFailed(error);
-	}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    void RunContext::pushScopedMessage(MessageInfo const & message) {
-        m_messages.push_back(message);
-    }
-
-    void RunContext::popScopedMessage(MessageInfo const & message) {
-        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
-    }
-
-    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
-        m_messageScopes.emplace_back( builder );
-    }
-
-    std::string RunContext::getCurrentTestName() const {
-        return m_activeTestCase
-            ? m_activeTestCase->getTestCaseInfo().name
-            : std::string();
-    }
-
-    const AssertionResult * RunContext::getLastResult() const {
-        return &(*m_lastResult);
-    }
-
-    void RunContext::exceptionEarlyReported() {
-        m_shouldReportUnexpected = false;
-    }
-
-    void RunContext::handleFatalErrorCondition( StringRef message ) {
-        // First notify reporter that bad things happened
-        m_reporter->fatalErrorEncountered(message);
-
-        // Don't rebuild the result -- the stringification itself can cause more fatal errors
-        // Instead, fake a result data.
-        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
-        tempResult.message = static_cast<std::string>(message);
-        AssertionResult result(m_lastAssertionInfo, tempResult);
-
-        assertionEnded(result);
-
-        handleUnfinishedSections();
-
-        // Recreate section for test case (as we will lose the one that was in scope)
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-
-        Counts assertions;
-        assertions.failed = 1;
-        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
-        m_reporter->sectionEnded(testCaseSectionStats);
-
-        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
-
-        Totals deltaTotals;
-        deltaTotals.testCases.failed = 1;
-        deltaTotals.assertions.failed = 1;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  std::string(),
-                                  std::string(),
-                                  false));
-        m_totals.testCases.failed++;
-        testGroupEnded(std::string(), m_totals, 1, 1);
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
-    }
-
-    bool RunContext::lastAssertionPassed() {
-         return m_lastAssertionPassed;
-    }
-
-    void RunContext::assertionPassed() {
-        m_lastAssertionPassed = true;
-        ++m_totals.assertions.passed;
-        resetAssertionInfo();
-        m_messageScopes.clear();
-    }
-
-    bool RunContext::aborting() const {
-        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
-    }
-
-    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-        m_reporter->sectionStarting(testCaseSection);
-        Counts prevAssertions = m_totals.assertions;
-        double duration = 0;
-        m_shouldReportUnexpected = true;
-        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
-
-        seedRng(*m_config);
-
-        Timer timer;
-        CATCH_TRY {
-            if (m_reporter->getPreferences().shouldRedirectStdOut) {
-#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
-
-                timer.start();
-                invokeActiveTestCase();
-#else
-                OutputRedirect r(redirectedCout, redirectedCerr);
-                timer.start();
-                invokeActiveTestCase();
-#endif
-            } else {
-                timer.start();
-                invokeActiveTestCase();
-            }
-            duration = timer.getElapsedSeconds();
-        } CATCH_CATCH_ANON (TestFailureException&) {
-            // This just means the test was aborted due to failure
-        } CATCH_CATCH_ALL {
-            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
-            // are reported without translation at the point of origin.
-            if( m_shouldReportUnexpected ) {
-                AssertionReaction dummyReaction;
-                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
-            }
-        }
-        Counts assertions = m_totals.assertions - prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        m_testCaseTracker->close();
-        handleUnfinishedSections();
-        m_messages.clear();
-        m_messageScopes.clear();
-
-        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
-        m_reporter->sectionEnded(testCaseSectionStats);
-    }
-
-    void RunContext::invokeActiveTestCase() {
-        FatalConditionHandler fatalConditionHandler; // Handle signals
-        m_activeTestCase->invoke();
-        fatalConditionHandler.reset();
-    }
-
-    void RunContext::handleUnfinishedSections() {
-        // If sections ended prematurely due to an exception we stored their
-        // infos here so we can tear them down outside the unwind process.
-        for (auto it = m_unfinishedSections.rbegin(),
-             itEnd = m_unfinishedSections.rend();
-             it != itEnd;
-             ++it)
-            sectionEnded(*it);
-        m_unfinishedSections.clear();
-    }
-
-    void RunContext::handleExpr(
-        AssertionInfo const& info,
-        ITransientExpression const& expr,
-        AssertionReaction& reaction
-    ) {
-        m_reporter->assertionStarting( info );
-
-        bool negated = isFalseTest( info.resultDisposition );
-        bool result = expr.getResult() != negated;
-
-        if( result ) {
-            if (!m_includeSuccessfulResults) {
-                assertionPassed();
-            }
-            else {
-                reportExpr(info, ResultWas::Ok, &expr, negated);
-            }
-        }
-        else {
-            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
-            populateReaction( reaction );
-        }
-    }
-    void RunContext::reportExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            ITransientExpression const *expr,
-            bool negated ) {
-
-        m_lastAssertionInfo = info;
-        AssertionResultData data( resultType, LazyExpression( negated ) );
-
-        AssertionResult assertionResult{ info, data };
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
-
-        assertionEnded( assertionResult );
-    }
-
-    void RunContext::handleMessage(
-            AssertionInfo const& info,
-            ResultWas::OfType resultType,
-            StringRef const& message,
-            AssertionReaction& reaction
-    ) {
-        m_reporter->assertionStarting( info );
-
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        data.message = static_cast<std::string>(message);
-        AssertionResult assertionResult{ m_lastAssertionInfo, data };
-        assertionEnded( assertionResult );
-        if( !assertionResult.isOk() )
-            populateReaction( reaction );
-    }
-    void RunContext::handleUnexpectedExceptionNotThrown(
-            AssertionInfo const& info,
-            AssertionReaction& reaction
-    ) {
-        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
-    }
-
-    void RunContext::handleUnexpectedInflightException(
-            AssertionInfo const& info,
-            std::string const& message,
-            AssertionReaction& reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = message;
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-        populateReaction( reaction );
-    }
-
-    void RunContext::populateReaction( AssertionReaction& reaction ) {
-        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
-        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
-    }
-
-    void RunContext::handleIncomplete(
-            AssertionInfo const& info
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-    }
-    void RunContext::handleNonExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            AssertionReaction &reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-
-        if( !assertionResult.isOk() )
-            populateReaction( reaction );
-    }
-
-    IResultCapture& getResultCapture() {
-        if (auto* capture = getCurrentContext().getResultCapture())
-            return *capture;
-        else
-            CATCH_INTERNAL_ERROR("No result capture instance");
-    }
-
-    void seedRng(IConfig const& config) {
-        if (config.rngSeed() != 0) {
-            std::srand(config.rngSeed());
-            rng().seed(config.rngSeed());
-        }
-    }
-
-    unsigned int rngSeed() {
-        return getCurrentContext().getConfig()->rngSeed();
-    }
-
-}
-// end catch_run_context.cpp
-// start catch_section.cpp
-
-namespace Catch {
-
-    Section::Section( SectionInfo const& info )
-    :   m_info( info ),
-        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
-    {
-        m_timer.start();
-    }
-
-    Section::~Section() {
-        if( m_sectionIncluded ) {
-            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
-            if( uncaught_exceptions() )
-                getResultCapture().sectionEndedEarly( endInfo );
-            else
-                getResultCapture().sectionEnded( endInfo );
-        }
-    }
-
-    // This indicates whether the section should be executed or not
-    Section::operator bool() const {
-        return m_sectionIncluded;
-    }
-
-} // end namespace Catch
-// end catch_section.cpp
-// start catch_section_info.cpp
-
-namespace Catch {
-
-    SectionInfo::SectionInfo
-        (   SourceLineInfo const& _lineInfo,
-            std::string const& _name )
-    :   name( _name ),
-        lineInfo( _lineInfo )
-    {}
-
-} // end namespace Catch
-// end catch_section_info.cpp
-// start catch_session.cpp
-
-// start catch_session.h
-
-#include <memory>
-
-namespace Catch {
-
-    class Session : NonCopyable {
-    public:
-
-        Session();
-        ~Session() override;
-
-        void showHelp() const;
-        void libIdentify();
-
-        int applyCommandLine( int argc, char const * const * argv );
-    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
-        int applyCommandLine( int argc, wchar_t const * const * argv );
-    #endif
-
-        void useConfigData( ConfigData const& configData );
-
-        template<typename CharT>
-        int run(int argc, CharT const * const argv[]) {
-            if (m_startupExceptions)
-                return 1;
-            int returnCode = applyCommandLine(argc, argv);
-            if (returnCode == 0)
-                returnCode = run();
-            return returnCode;
-        }
-
-        int run();
-
-        clara::Parser const& cli() const;
-        void cli( clara::Parser const& newParser );
-        ConfigData& configData();
-        Config& config();
-    private:
-        int runInternal();
-
-        clara::Parser m_cli;
-        ConfigData m_configData;
-        std::shared_ptr<Config> m_config;
-        bool m_startupExceptions = false;
-    };
-
-} // end namespace Catch
-
-// end catch_session.h
-// start catch_version.h
-
-#include <iosfwd>
-
-namespace Catch {
-
-    // Versioning information
-    struct Version {
-        Version( Version const& ) = delete;
-        Version& operator=( Version const& ) = delete;
-        Version(    unsigned int _majorVersion,
-                    unsigned int _minorVersion,
-                    unsigned int _patchNumber,
-                    char const * const _branchName,
-                    unsigned int _buildNumber );
-
-        unsigned int const majorVersion;
-        unsigned int const minorVersion;
-        unsigned int const patchNumber;
-
-        // buildNumber is only used if branchName is not null
-        char const * const branchName;
-        unsigned int const buildNumber;
-
-        friend std::ostream& operator << ( std::ostream& os, Version const& version );
-    };
-
-    Version const& libraryVersion();
-}
-
-// end catch_version.h
-#include <cstdlib>
-#include <iomanip>
-#include <set>
-#include <iterator>
-
-namespace Catch {
-
-    namespace {
-        const int MaxExitCode = 255;
-
-        IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
-            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
-            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
-
-            return reporter;
-        }
-
-        IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
-            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
-                return createReporter(config->getReporterName(), config);
-            }
-
-            // On older platforms, returning std::unique_ptr<ListeningReporter>
-            // when the return type is std::unique_ptr<IStreamingReporter>
-            // doesn't compile without a std::move call. However, this causes
-            // a warning on newer platforms. Thus, we have to work around
-            // it a bit and downcast the pointer manually.
-            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
-            auto& multi = static_cast<ListeningReporter&>(*ret);
-            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
-            for (auto const& listener : listeners) {
-                multi.addListener(listener->create(Catch::ReporterConfig(config)));
-            }
-            multi.addReporter(createReporter(config->getReporterName(), config));
-            return ret;
-        }
-
-        class TestGroup {
-        public:
-            explicit TestGroup(std::shared_ptr<Config> const& config)
-            : m_config{config}
-            , m_context{config, makeReporter(config)}
-            {
-                auto const& allTestCases = getAllTestCasesSorted(*m_config);
-                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
-                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
-
-                if (m_matches.empty() && invalidArgs.empty()) {
-                    for (auto const& test : allTestCases)
-                        if (!test.isHidden())
-                            m_tests.emplace(&test);
-                } else {
-                    for (auto const& match : m_matches)
-                        m_tests.insert(match.tests.begin(), match.tests.end());
-                }
-            }
-
-            Totals execute() {
-                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
-                Totals totals;
-                m_context.testGroupStarting(m_config->name(), 1, 1);
-                for (auto const& testCase : m_tests) {
-                    if (!m_context.aborting())
-                        totals += m_context.runTest(*testCase);
-                    else
-                        m_context.reporter().skipTest(*testCase);
-                }
-
-                for (auto const& match : m_matches) {
-                    if (match.tests.empty()) {
-                        m_context.reporter().noMatchingTestCases(match.name);
-                        totals.error = -1;
-                    }
-                }
-
-                if (!invalidArgs.empty()) {
-                    for (auto const& invalidArg: invalidArgs)
-                         m_context.reporter().reportInvalidArguments(invalidArg);
-                }
-
-                m_context.testGroupEnded(m_config->name(), totals, 1, 1);
-                return totals;
-            }
-
-        private:
-            using Tests = std::set<TestCase const*>;
-
-            std::shared_ptr<Config> m_config;
-            RunContext m_context;
-            Tests m_tests;
-            TestSpec::Matches m_matches;
-        };
-
-        void applyFilenamesAsTags(Catch::IConfig const& config) {
-            auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
-            for (auto& testCase : tests) {
-                auto tags = testCase.tags;
-
-                std::string filename = testCase.lineInfo.file;
-                auto lastSlash = filename.find_last_of("\\/");
-                if (lastSlash != std::string::npos) {
-                    filename.erase(0, lastSlash);
-                    filename[0] = '#';
-                }
-
-                auto lastDot = filename.find_last_of('.');
-                if (lastDot != std::string::npos) {
-                    filename.erase(lastDot);
-                }
-
-                tags.push_back(std::move(filename));
-                setTags(testCase, tags);
-            }
-        }
-
-    } // anon namespace
-
-    Session::Session() {
-        static bool alreadyInstantiated = false;
-        if( alreadyInstantiated ) {
-            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
-            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
-        }
-
-        // There cannot be exceptions at startup in no-exception mode.
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
-        if ( !exceptions.empty() ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config);
-
-            m_startupExceptions = true;
-            Colour colourGuard( Colour::Red );
-            Catch::cerr() << "Errors occurred during startup!" << '\n';
-            // iterate over all exceptions and notify user
-            for ( const auto& ex_ptr : exceptions ) {
-                try {
-                    std::rethrow_exception(ex_ptr);
-                } catch ( std::exception const& ex ) {
-                    Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
-                }
-            }
-        }
-#endif
-
-        alreadyInstantiated = true;
-        m_cli = makeCommandLineParser( m_configData );
-    }
-    Session::~Session() {
-        Catch::cleanUp();
-    }
-
-    void Session::showHelp() const {
-        Catch::cout()
-                << "\nCatch v" << libraryVersion() << "\n"
-                << m_cli << std::endl
-                << "For more detailed usage please see the project docs\n" << std::endl;
-    }
-    void Session::libIdentify() {
-        Catch::cout()
-                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
-                << std::left << std::setw(16) << "category: " << "testframework\n"
-                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
-                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
-    }
-
-    int Session::applyCommandLine( int argc, char const * const * argv ) {
-        if( m_startupExceptions )
-            return 1;
-
-        auto result = m_cli.parse( clara::Args( argc, argv ) );
-        if( !result ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config);
-            Catch::cerr()
-                << Colour( Colour::Red )
-                << "\nError(s) in input:\n"
-                << Column( result.errorMessage() ).indent( 2 )
-                << "\n\n";
-            Catch::cerr() << "Run with -? for usage\n" << std::endl;
-            return MaxExitCode;
-        }
-
-        if( m_configData.showHelp )
-            showHelp();
-        if( m_configData.libIdentify )
-            libIdentify();
-        m_config.reset();
-        return 0;
-    }
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
-    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
-
-        char **utf8Argv = new char *[ argc ];
-
-        for ( int i = 0; i < argc; ++i ) {
-            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
-
-            utf8Argv[ i ] = new char[ bufSize ];
-
-            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
-        }
-
-        int returnCode = applyCommandLine( argc, utf8Argv );
-
-        for ( int i = 0; i < argc; ++i )
-            delete [] utf8Argv[ i ];
-
-        delete [] utf8Argv;
-
-        return returnCode;
-    }
-#endif
-
-    void Session::useConfigData( ConfigData const& configData ) {
-        m_configData = configData;
-        m_config.reset();
-    }
-
-    int Session::run() {
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        int exitCode = runInternal();
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        return exitCode;
-    }
-
-    clara::Parser const& Session::cli() const {
-        return m_cli;
-    }
-    void Session::cli( clara::Parser const& newParser ) {
-        m_cli = newParser;
-    }
-    ConfigData& Session::configData() {
-        return m_configData;
-    }
-    Config& Session::config() {
-        if( !m_config )
-            m_config = std::make_shared<Config>( m_configData );
-        return *m_config;
-    }
-
-    int Session::runInternal() {
-        if( m_startupExceptions )
-            return 1;
-
-        if (m_configData.showHelp || m_configData.libIdentify) {
-            return 0;
-        }
-
-        CATCH_TRY {
-            config(); // Force config to be constructed
-
-            seedRng( *m_config );
-
-            if( m_configData.filenamesAsTags )
-                applyFilenamesAsTags( *m_config );
-
-            // Handle list request
-            if( Option<std::size_t> listed = list( m_config ) )
-                return static_cast<int>( *listed );
-
-            TestGroup tests { m_config };
-            auto const totals = tests.execute();
-
-            if( m_config->warnAboutNoTests() && totals.error == -1 )
-                return 2;
-
-            // Note that on unices only the lower 8 bits are usually used, clamping
-            // the return value to 255 prevents false negative when some multiple
-            // of 256 tests has failed
-            return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
-        }
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        catch( std::exception& ex ) {
-            Catch::cerr() << ex.what() << std::endl;
-            return MaxExitCode;
-        }
-#endif
-    }
-
-} // end namespace Catch
-// end catch_session.cpp
-// start catch_singletons.cpp
-
-#include <vector>
-
-namespace Catch {
-
-    namespace {
-        static auto getSingletons() -> std::vector<ISingleton*>*& {
-            static std::vector<ISingleton*>* g_singletons = nullptr;
-            if( !g_singletons )
-                g_singletons = new std::vector<ISingleton*>();
-            return g_singletons;
-        }
-    }
-
-    ISingleton::~ISingleton() {}
-
-    void addSingleton(ISingleton* singleton ) {
-        getSingletons()->push_back( singleton );
-    }
-    void cleanupSingletons() {
-        auto& singletons = getSingletons();
-        for( auto singleton : *singletons )
-            delete singleton;
-        delete singletons;
-        singletons = nullptr;
-    }
-
-} // namespace Catch
-// end catch_singletons.cpp
-// start catch_startup_exception_registry.cpp
-
-namespace Catch {
-void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
-        CATCH_TRY {
-            m_exceptions.push_back(exception);
-        } CATCH_CATCH_ALL {
-            // If we run out of memory during start-up there's really not a lot more we can do about it
-            std::terminate();
-        }
-    }
-
-    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
-        return m_exceptions;
-    }
-
-} // end namespace Catch
-// end catch_startup_exception_registry.cpp
-// start catch_stream.cpp
-
-#include <cstdio>
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    Catch::IStream::~IStream() = default;
-
-    namespace Detail { namespace {
-        template<typename WriterF, std::size_t bufferSize=256>
-        class StreamBufImpl : public std::streambuf {
-            char data[bufferSize];
-            WriterF m_writer;
-
-        public:
-            StreamBufImpl() {
-                setp( data, data + sizeof(data) );
-            }
-
-            ~StreamBufImpl() noexcept {
-                StreamBufImpl::sync();
-            }
-
-        private:
-            int overflow( int c ) override {
-                sync();
-
-                if( c != EOF ) {
-                    if( pbase() == epptr() )
-                        m_writer( std::string( 1, static_cast<char>( c ) ) );
-                    else
-                        sputc( static_cast<char>( c ) );
-                }
-                return 0;
-            }
-
-            int sync() override {
-                if( pbase() != pptr() ) {
-                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
-                    setp( pbase(), epptr() );
-                }
-                return 0;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        struct OutputDebugWriter {
-
-            void operator()( std::string const&str ) {
-                writeToDebugConsole( str );
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class FileStream : public IStream {
-            mutable std::ofstream m_ofs;
-        public:
-            FileStream( StringRef filename ) {
-                m_ofs.open( filename.c_str() );
-                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
-            }
-            ~FileStream() override = default;
-        public: // IStream
-            std::ostream& stream() const override {
-                return m_ofs;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class CoutStream : public IStream {
-            mutable std::ostream m_os;
-        public:
-            // Store the streambuf from cout up-front because
-            // cout may get redirected when running tests
-            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
-            ~CoutStream() override = default;
-
-        public: // IStream
-            std::ostream& stream() const override { return m_os; }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class DebugOutStream : public IStream {
-            std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
-            mutable std::ostream m_os;
-        public:
-            DebugOutStream()
-            :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
-                m_os( m_streamBuf.get() )
-            {}
-
-            ~DebugOutStream() override = default;
-
-        public: // IStream
-            std::ostream& stream() const override { return m_os; }
-        };
-
-    }} // namespace anon::detail
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    auto makeStream( StringRef const &filename ) -> IStream const* {
-        if( filename.empty() )
-            return new Detail::CoutStream();
-        else if( filename[0] == '%' ) {
-            if( filename == "%debug" )
-                return new Detail::DebugOutStream();
-            else
-                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
-        }
-        else
-            return new Detail::FileStream( filename );
-    }
-
-    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
-    struct StringStreams {
-        std::vector<std::unique_ptr<std::ostringstream>> m_streams;
-        std::vector<std::size_t> m_unused;
-        std::ostringstream m_referenceStream; // Used for copy state/ flags from
-
-        auto add() -> std::size_t {
-            if( m_unused.empty() ) {
-                m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
-                return m_streams.size()-1;
-            }
-            else {
-                auto index = m_unused.back();
-                m_unused.pop_back();
-                return index;
-            }
-        }
-
-        void release( std::size_t index ) {
-            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
-            m_unused.push_back(index);
-        }
-    };
-
-    ReusableStringStream::ReusableStringStream()
-    :   m_index( Singleton<StringStreams>::getMutable().add() ),
-        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
-    {}
-
-    ReusableStringStream::~ReusableStringStream() {
-        static_cast<std::ostringstream*>( m_oss )->str("");
-        m_oss->clear();
-        Singleton<StringStreams>::getMutable().release( m_index );
-    }
-
-    auto ReusableStringStream::str() const -> std::string {
-        return static_cast<std::ostringstream*>( m_oss )->str();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
-    std::ostream& cout() { return std::cout; }
-    std::ostream& cerr() { return std::cerr; }
-    std::ostream& clog() { return std::clog; }
-#endif
-}
-// end catch_stream.cpp
-// start catch_string_manip.cpp
-
-#include <algorithm>
-#include <ostream>
-#include <cstring>
-#include <cctype>
-#include <vector>
-
-namespace Catch {
-
-    namespace {
-        char toLowerCh(char c) {
-            return static_cast<char>( std::tolower( c ) );
-        }
-    }
-
-    bool startsWith( std::string const& s, std::string const& prefix ) {
-        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
-    }
-    bool startsWith( std::string const& s, char prefix ) {
-        return !s.empty() && s[0] == prefix;
-    }
-    bool endsWith( std::string const& s, std::string const& suffix ) {
-        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
-    }
-    bool endsWith( std::string const& s, char suffix ) {
-        return !s.empty() && s[s.size()-1] == suffix;
-    }
-    bool contains( std::string const& s, std::string const& infix ) {
-        return s.find( infix ) != std::string::npos;
-    }
-    void toLowerInPlace( std::string& s ) {
-        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
-    }
-    std::string toLower( std::string const& s ) {
-        std::string lc = s;
-        toLowerInPlace( lc );
-        return lc;
-    }
-    std::string trim( std::string const& str ) {
-        static char const* whitespaceChars = "\n\r\t ";
-        std::string::size_type start = str.find_first_not_of( whitespaceChars );
-        std::string::size_type end = str.find_last_not_of( whitespaceChars );
-
-        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
-    }
-
-    StringRef trim(StringRef ref) {
-        const auto is_ws = [](char c) {
-            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
-        };
-        size_t real_begin = 0;
-        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
-        size_t real_end = ref.size();
-        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
-
-        return ref.substr(real_begin, real_end - real_begin);
-    }
-
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
-        bool replaced = false;
-        std::size_t i = str.find( replaceThis );
-        while( i != std::string::npos ) {
-            replaced = true;
-            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
-            if( i < str.size()-withThis.size() )
-                i = str.find( replaceThis, i+withThis.size() );
-            else
-                i = std::string::npos;
-        }
-        return replaced;
-    }
-
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
-        std::vector<StringRef> subStrings;
-        std::size_t start = 0;
-        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
-            if( str[pos] == delimiter ) {
-                if( pos - start > 1 )
-                    subStrings.push_back( str.substr( start, pos-start ) );
-                start = pos+1;
-            }
-        }
-        if( start < str.size() )
-            subStrings.push_back( str.substr( start, str.size()-start ) );
-        return subStrings;
-    }
-
-    pluralise::pluralise( std::size_t count, std::string const& label )
-    :   m_count( count ),
-        m_label( label )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
-        os << pluraliser.m_count << ' ' << pluraliser.m_label;
-        if( pluraliser.m_count != 1 )
-            os << 's';
-        return os;
-    }
-
-}
-// end catch_string_manip.cpp
-// start catch_stringref.cpp
-
-#include <algorithm>
-#include <ostream>
-#include <cstring>
-#include <cstdint>
-
-namespace Catch {
-    StringRef::StringRef( char const* rawChars ) noexcept
-    : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
-    {}
-
-    auto StringRef::c_str() const -> char const* {
-        CATCH_ENFORCE(isNullTerminated(), "Called StringRef::c_str() on a non-null-terminated instance");
-        return m_start;
-    }
-    auto StringRef::data() const noexcept -> char const* {
-        return m_start;
-    }
-
-    auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
-        if (start < m_size) {
-            return StringRef(m_start + start, (std::min)(m_size - start, size));
-        } else {
-            return StringRef();
-        }
-    }
-    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
-        return m_size == other.m_size
-            && (std::memcmp( m_start, other.m_start, m_size ) == 0);
-    }
-
-    auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
-        return os.write(str.data(), str.size());
-    }
-
-    auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
-        lhs.append(rhs.data(), rhs.size());
-        return lhs;
-    }
-
-} // namespace Catch
-// end catch_stringref.cpp
-// start catch_tag_alias.cpp
-
-namespace Catch {
-    TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
-}
-// end catch_tag_alias.cpp
-// start catch_tag_alias_autoregistrar.cpp
-
-namespace Catch {
-
-    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
-        CATCH_TRY {
-            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
-
-}
-// end catch_tag_alias_autoregistrar.cpp
-// start catch_tag_alias_registry.cpp
-
-#include <sstream>
-
-namespace Catch {
-
-    TagAliasRegistry::~TagAliasRegistry() {}
-
-    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
-        auto it = m_registry.find( alias );
-        if( it != m_registry.end() )
-            return &(it->second);
-        else
-            return nullptr;
-    }
-
-    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
-        std::string expandedTestSpec = unexpandedTestSpec;
-        for( auto const& registryKvp : m_registry ) {
-            std::size_t pos = expandedTestSpec.find( registryKvp.first );
-            if( pos != std::string::npos ) {
-                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
-                                    registryKvp.second.tag +
-                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
-            }
-        }
-        return expandedTestSpec;
-    }
-
-    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
-        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
-                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
-
-        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
-                      "error: tag alias, '" << alias << "' already registered.\n"
-                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
-                      << "\tRedefined at: " << lineInfo );
-    }
-
-    ITagAliasRegistry::~ITagAliasRegistry() {}
-
-    ITagAliasRegistry const& ITagAliasRegistry::get() {
-        return getRegistryHub().getTagAliasRegistry();
-    }
-
-} // end namespace Catch
-// end catch_tag_alias_registry.cpp
-// start catch_test_case_info.cpp
-
-#include <cctype>
-#include <exception>
-#include <algorithm>
-#include <sstream>
-
-namespace Catch {
-
-    namespace {
-        TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
-            if( startsWith( tag, '.' ) ||
-                tag == "!hide" )
-                return TestCaseInfo::IsHidden;
-            else if( tag == "!throws" )
-                return TestCaseInfo::Throws;
-            else if( tag == "!shouldfail" )
-                return TestCaseInfo::ShouldFail;
-            else if( tag == "!mayfail" )
-                return TestCaseInfo::MayFail;
-            else if( tag == "!nonportable" )
-                return TestCaseInfo::NonPortable;
-            else if( tag == "!benchmark" )
-                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
-            else
-                return TestCaseInfo::None;
-        }
-        bool isReservedTag( std::string const& tag ) {
-            return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
-        }
-        void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
-            CATCH_ENFORCE( !isReservedTag(tag),
-                          "Tag name: [" << tag << "] is not allowed.\n"
-                          << "Tag names starting with non alphanumeric characters are reserved\n"
-                          << _lineInfo );
-        }
-    }
-
-    TestCase makeTestCase(  ITestInvoker* _testCase,
-                            std::string const& _className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& _lineInfo )
-    {
-        bool isHidden = false;
-
-        // Parse out tags
-        std::vector<std::string> tags;
-        std::string desc, tag;
-        bool inTag = false;
-        for (char c : nameAndTags.tags) {
-            if( !inTag ) {
-                if( c == '[' )
-                    inTag = true;
-                else
-                    desc += c;
-            }
-            else {
-                if( c == ']' ) {
-                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
-                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
-                        isHidden = true;
-                    else if( prop == TestCaseInfo::None )
-                        enforceNotReservedTag( tag, _lineInfo );
-
-                    // Merged hide tags like `[.approvals]` should be added as
-                    // `[.][approvals]`. The `[.]` is added at later point, so
-                    // we only strip the prefix
-                    if (startsWith(tag, '.') && tag.size() > 1) {
-                        tag.erase(0, 1);
-                    }
-                    tags.push_back( tag );
-                    tag.clear();
-                    inTag = false;
-                }
-                else
-                    tag += c;
-            }
-        }
-        if( isHidden ) {
-            // Add all "hidden" tags to make them behave identically
-            tags.insert( tags.end(), { ".", "!hide" } );
-        }
-
-        TestCaseInfo info( static_cast<std::string>(nameAndTags.name), _className, desc, tags, _lineInfo );
-        return TestCase( _testCase, std::move(info) );
-    }
-
-    void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
-        std::sort(begin(tags), end(tags));
-        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
-        testCaseInfo.lcaseTags.clear();
-
-        for( auto const& tag : tags ) {
-            std::string lcaseTag = toLower( tag );
-            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
-            testCaseInfo.lcaseTags.push_back( lcaseTag );
-        }
-        testCaseInfo.tags = std::move(tags);
-    }
-
-    TestCaseInfo::TestCaseInfo( std::string const& _name,
-                                std::string const& _className,
-                                std::string const& _description,
-                                std::vector<std::string> const& _tags,
-                                SourceLineInfo const& _lineInfo )
-    :   name( _name ),
-        className( _className ),
-        description( _description ),
-        lineInfo( _lineInfo ),
-        properties( None )
-    {
-        setTags( *this, _tags );
-    }
-
-    bool TestCaseInfo::isHidden() const {
-        return ( properties & IsHidden ) != 0;
-    }
-    bool TestCaseInfo::throws() const {
-        return ( properties & Throws ) != 0;
-    }
-    bool TestCaseInfo::okToFail() const {
-        return ( properties & (ShouldFail | MayFail ) ) != 0;
-    }
-    bool TestCaseInfo::expectedToFail() const {
-        return ( properties & (ShouldFail ) ) != 0;
-    }
-
-    std::string TestCaseInfo::tagsAsString() const {
-        std::string ret;
-        // '[' and ']' per tag
-        std::size_t full_size = 2 * tags.size();
-        for (const auto& tag : tags) {
-            full_size += tag.size();
-        }
-        ret.reserve(full_size);
-        for (const auto& tag : tags) {
-            ret.push_back('[');
-            ret.append(tag);
-            ret.push_back(']');
-        }
-
-        return ret;
-    }
-
-    TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
-
-    TestCase TestCase::withName( std::string const& _newName ) const {
-        TestCase other( *this );
-        other.name = _newName;
-        return other;
-    }
-
-    void TestCase::invoke() const {
-        test->invoke();
-    }
-
-    bool TestCase::operator == ( TestCase const& other ) const {
-        return  test.get() == other.test.get() &&
-                name == other.name &&
-                className == other.className;
-    }
-
-    bool TestCase::operator < ( TestCase const& other ) const {
-        return name < other.name;
-    }
-
-    TestCaseInfo const& TestCase::getTestCaseInfo() const
-    {
-        return *this;
-    }
-
-} // end namespace Catch
-// end catch_test_case_info.cpp
-// start catch_test_case_registry_impl.cpp
-
-#include <sstream>
-
-namespace Catch {
-
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
-
-        std::vector<TestCase> sorted = unsortedTestCases;
-
-        switch( config.runOrder() ) {
-            case RunTests::InLexicographicalOrder:
-                std::sort( sorted.begin(), sorted.end() );
-                break;
-            case RunTests::InRandomOrder:
-                seedRng( config );
-                std::shuffle( sorted.begin(), sorted.end(), rng() );
-                break;
-            case RunTests::InDeclarationOrder:
-                // already in declaration order
-                break;
-        }
-        return sorted;
-    }
-
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config ) {
-        return !testCase.throws() || config.allowThrows();
-    }
-
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
-        return testSpec.matches( testCase ) && isThrowSafe( testCase, config );
-    }
-
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
-        std::set<TestCase> seenFunctions;
-        for( auto const& function : functions ) {
-            auto prev = seenFunctions.insert( function );
-            CATCH_ENFORCE( prev.second,
-                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
-                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
-                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
-        }
-    }
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
-        std::vector<TestCase> filtered;
-        filtered.reserve( testCases.size() );
-        for (auto const& testCase : testCases) {
-            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
-                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
-                filtered.push_back(testCase);
-            }
-        }
-        return filtered;
-    }
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
-        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
-    }
-
-    void TestRegistry::registerTest( TestCase const& testCase ) {
-        std::string name = testCase.getTestCaseInfo().name;
-        if( name.empty() ) {
-            ReusableStringStream rss;
-            rss << "Anonymous test case " << ++m_unnamedCount;
-            return registerTest( testCase.withName( rss.str() ) );
-        }
-        m_functions.push_back( testCase );
-    }
-
-    std::vector<TestCase> const& TestRegistry::getAllTests() const {
-        return m_functions;
-    }
-    std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
-        if( m_sortedFunctions.empty() )
-            enforceNoDuplicateTestCases( m_functions );
-
-        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
-            m_sortedFunctions = sortTests( config, m_functions );
-            m_currentSortOrder = config.runOrder();
-        }
-        return m_sortedFunctions;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
-
-    void TestInvokerAsFunction::invoke() const {
-        m_testAsFunction();
-    }
-
-    std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
-        std::string className(classOrQualifiedMethodName);
-        if( startsWith( className, '&' ) )
-        {
-            std::size_t lastColons = className.rfind( "::" );
-            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
-            if( penultimateColons == std::string::npos )
-                penultimateColons = 1;
-            className = className.substr( penultimateColons, lastColons-penultimateColons );
-        }
-        return className;
-    }
-
-} // end namespace Catch
-// end catch_test_case_registry_impl.cpp
-// start catch_test_case_tracker.cpp
-
-#include <algorithm>
-#include <cassert>
-#include <stdexcept>
-#include <memory>
-#include <sstream>
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
-    :   name( _name ),
-        location( _location )
-    {}
-
-    ITracker::~ITracker() = default;
-
-    ITracker& TrackerContext::startRun() {
-        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
-        m_currentTracker = nullptr;
-        m_runState = Executing;
-        return *m_rootTracker;
-    }
-
-    void TrackerContext::endRun() {
-        m_rootTracker.reset();
-        m_currentTracker = nullptr;
-        m_runState = NotStarted;
-    }
-
-    void TrackerContext::startCycle() {
-        m_currentTracker = m_rootTracker.get();
-        m_runState = Executing;
-    }
-    void TrackerContext::completeCycle() {
-        m_runState = CompletedCycle;
-    }
-
-    bool TrackerContext::completedCycle() const {
-        return m_runState == CompletedCycle;
-    }
-    ITracker& TrackerContext::currentTracker() {
-        return *m_currentTracker;
-    }
-    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
-        m_currentTracker = tracker;
-    }
-
-    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   m_nameAndLocation( nameAndLocation ),
-        m_ctx( ctx ),
-        m_parent( parent )
-    {}
-
-    NameAndLocation const& TrackerBase::nameAndLocation() const {
-        return m_nameAndLocation;
-    }
-    bool TrackerBase::isComplete() const {
-        return m_runState == CompletedSuccessfully || m_runState == Failed;
-    }
-    bool TrackerBase::isSuccessfullyCompleted() const {
-        return m_runState == CompletedSuccessfully;
-    }
-    bool TrackerBase::isOpen() const {
-        return m_runState != NotStarted && !isComplete();
-    }
-    bool TrackerBase::hasChildren() const {
-        return !m_children.empty();
-    }
-
-    void TrackerBase::addChild( ITrackerPtr const& child ) {
-        m_children.push_back( child );
-    }
-
-    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
-        auto it = std::find_if( m_children.begin(), m_children.end(),
-            [&nameAndLocation]( ITrackerPtr const& tracker ){
-                return
-                    tracker->nameAndLocation().location == nameAndLocation.location &&
-                    tracker->nameAndLocation().name == nameAndLocation.name;
-            } );
-        return( it != m_children.end() )
-            ? *it
-            : nullptr;
-    }
-    ITracker& TrackerBase::parent() {
-        assert( m_parent ); // Should always be non-null except for root
-        return *m_parent;
-    }
-
-    void TrackerBase::openChild() {
-        if( m_runState != ExecutingChildren ) {
-            m_runState = ExecutingChildren;
-            if( m_parent )
-                m_parent->openChild();
-        }
-    }
-
-    bool TrackerBase::isSectionTracker() const { return false; }
-    bool TrackerBase::isGeneratorTracker() const { return false; }
-
-    void TrackerBase::open() {
-        m_runState = Executing;
-        moveToThis();
-        if( m_parent )
-            m_parent->openChild();
-    }
-
-    void TrackerBase::close() {
-
-        // Close any still open children (e.g. generators)
-        while( &m_ctx.currentTracker() != this )
-            m_ctx.currentTracker().close();
-
-        switch( m_runState ) {
-            case NeedsAnotherRun:
-                break;
-
-            case Executing:
-                m_runState = CompletedSuccessfully;
-                break;
-            case ExecutingChildren:
-                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
-                    m_runState = CompletedSuccessfully;
-                break;
-
-            case NotStarted:
-            case CompletedSuccessfully:
-            case Failed:
-                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
-
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
-        }
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::fail() {
-        m_runState = Failed;
-        if( m_parent )
-            m_parent->markAsNeedingAnotherRun();
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::markAsNeedingAnotherRun() {
-        m_runState = NeedsAnotherRun;
-    }
-
-    void TrackerBase::moveToParent() {
-        assert( m_parent );
-        m_ctx.setCurrentTracker( m_parent );
-    }
-    void TrackerBase::moveToThis() {
-        m_ctx.setCurrentTracker( this );
-    }
-
-    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   TrackerBase( nameAndLocation, ctx, parent ),
-        m_trimmed_name(trim(nameAndLocation.name))
-    {
-        if( parent ) {
-            while( !parent->isSectionTracker() )
-                parent = &parent->parent();
-
-            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
-            addNextFilters( parentSection.m_filters );
-        }
-    }
-
-    bool SectionTracker::isComplete() const {
-        bool complete = true;
-
-        if ((m_filters.empty() || m_filters[0] == "")
-            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
-            complete = TrackerBase::isComplete();
-        }
-        return complete;
-    }
-
-    bool SectionTracker::isSectionTracker() const { return true; }
-
-    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
-        std::shared_ptr<SectionTracker> section;
-
-        ITracker& currentTracker = ctx.currentTracker();
-        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-            assert( childTracker );
-            assert( childTracker->isSectionTracker() );
-            section = std::static_pointer_cast<SectionTracker>( childTracker );
-        }
-        else {
-            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
-            currentTracker.addChild( section );
-        }
-        if( !ctx.completedCycle() )
-            section->tryOpen();
-        return *section;
-    }
-
-    void SectionTracker::tryOpen() {
-        if( !isComplete() )
-            open();
-    }
-
-    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
-        if( !filters.empty() ) {
-            m_filters.reserve( m_filters.size() + filters.size() + 2 );
-            m_filters.emplace_back(""); // Root - should never be consulted
-            m_filters.emplace_back(""); // Test Case - not a section filter
-            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
-        }
-    }
-    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
-        if( filters.size() > 1 )
-            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
-    }
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-
-} // namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-// end catch_test_case_tracker.cpp
-// start catch_test_registry.cpp
-
-namespace Catch {
-
-    auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
-        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
-    }
-
-    NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
-
-    AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
-        CATCH_TRY {
-            getMutableRegistryHub()
-                    .registerTest(
-                        makeTestCase(
-                            invoker,
-                            extractClassName( classOrMethod ),
-                            nameAndTags,
-                            lineInfo));
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
-
-    AutoReg::~AutoReg() = default;
-}
-// end catch_test_registry.cpp
-// start catch_test_spec.cpp
-
-#include <algorithm>
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    TestSpec::Pattern::Pattern( std::string const& name )
-    : m_name( name )
-    {}
-
-    TestSpec::Pattern::~Pattern() = default;
-
-    std::string const& TestSpec::Pattern::name() const {
-        return m_name;
-    }
-
-    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
-    : Pattern( filterString )
-    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
-    {}
-
-    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
-        return m_wildcardPattern.matches( testCase.name );
-    }
-
-    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
-    : Pattern( filterString )
-    , m_tag( toLower( tag ) )
-    {}
-
-    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
-        return std::find(begin(testCase.lcaseTags),
-                         end(testCase.lcaseTags),
-                         m_tag) != end(testCase.lcaseTags);
-    }
-
-    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern )
-    : Pattern( underlyingPattern->name() )
-    , m_underlyingPattern( underlyingPattern )
-    {}
-
-    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const {
-        return !m_underlyingPattern->matches( testCase );
-    }
-
-    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
-        return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
-    }
-
-    std::string TestSpec::Filter::name() const {
-        std::string name;
-        for( auto const& p : m_patterns )
-            name += p->name();
-        return name;
-    }
-
-    bool TestSpec::hasFilters() const {
-        return !m_filters.empty();
-    }
-
-    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
-        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
-    }
-
-    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
-    {
-        Matches matches( m_filters.size() );
-        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
-            std::vector<TestCase const*> currentMatches;
-            for( auto const& test : testCases )
-                if( isThrowSafe( test, config ) && filter.matches( test ) )
-                    currentMatches.emplace_back( &test );
-            return FilterMatch{ filter.name(), currentMatches };
-        } );
-        return matches;
-    }
-
-    const TestSpec::vectorStrings& TestSpec::getInvalidArgs() const{
-        return  (m_invalidArgs);
-    }
-
-}
-// end catch_test_spec.cpp
-// start catch_test_spec_parser.cpp
-
-namespace Catch {
-
-    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
-
-    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
-        m_mode = None;
-        m_exclusion = false;
-        m_arg = m_tagAliases->expandAliases( arg );
-        m_escapeChars.clear();
-        m_substring.reserve(m_arg.size());
-        m_patternName.reserve(m_arg.size());
-        m_realPatternPos = 0;
-
-        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
-          //if visitChar fails
-           if( !visitChar( m_arg[m_pos] ) ){
-               m_testSpec.m_invalidArgs.push_back(arg);
-               break;
-           }
-        endMode();
-        return *this;
-    }
-    TestSpec TestSpecParser::testSpec() {
-        addFilter();
-        return m_testSpec;
-    }
-    bool TestSpecParser::visitChar( char c ) {
-        if( (m_mode != EscapedName) && (c == '\\') ) {
-            escape();
-            addCharToPattern(c);
-            return true;
-        }else if((m_mode != EscapedName) && (c == ',') )  {
-            return separate();
-        }
-
-        switch( m_mode ) {
-        case None:
-            if( processNoneChar( c ) )
-                return true;
-            break;
-        case Name:
-            processNameChar( c );
-            break;
-        case EscapedName:
-            endMode();
-            addCharToPattern(c);
-            return true;
-        default:
-        case Tag:
-        case QuotedName:
-            if( processOtherChar( c ) )
-                return true;
-            break;
-        }
-
-        m_substring += c;
-        if( !isControlChar( c ) ) {
-            m_patternName += c;
-            m_realPatternPos++;
-        }
-        return true;
-    }
-    // Two of the processing methods return true to signal the caller to return
-    // without adding the given character to the current pattern strings
-    bool TestSpecParser::processNoneChar( char c ) {
-        switch( c ) {
-        case ' ':
-            return true;
-        case '~':
-            m_exclusion = true;
-            return false;
-        case '[':
-            startNewMode( Tag );
-            return false;
-        case '"':
-            startNewMode( QuotedName );
-            return false;
-        default:
-            startNewMode( Name );
-            return false;
-        }
-    }
-    void TestSpecParser::processNameChar( char c ) {
-        if( c == '[' ) {
-            if( m_substring == "exclude:" )
-                m_exclusion = true;
-            else
-                endMode();
-            startNewMode( Tag );
-        }
-    }
-    bool TestSpecParser::processOtherChar( char c ) {
-        if( !isControlChar( c ) )
-            return false;
-        m_substring += c;
-        endMode();
-        return true;
-    }
-    void TestSpecParser::startNewMode( Mode mode ) {
-        m_mode = mode;
-    }
-    void TestSpecParser::endMode() {
-        switch( m_mode ) {
-        case Name:
-        case QuotedName:
-            return addNamePattern();
-        case Tag:
-            return addTagPattern();
-        case EscapedName:
-            revertBackToLastMode();
-            return;
-        case None:
-        default:
-            return startNewMode( None );
-        }
-    }
-    void TestSpecParser::escape() {
-        saveLastMode();
-        m_mode = EscapedName;
-        m_escapeChars.push_back(m_realPatternPos);
-    }
-    bool TestSpecParser::isControlChar( char c ) const {
-        switch( m_mode ) {
-            default:
-                return false;
-            case None:
-                return c == '~';
-            case Name:
-                return c == '[';
-            case EscapedName:
-                return true;
-            case QuotedName:
-                return c == '"';
-            case Tag:
-                return c == '[' || c == ']';
-        }
-    }
-
-    void TestSpecParser::addFilter() {
-        if( !m_currentFilter.m_patterns.empty() ) {
-            m_testSpec.m_filters.push_back( m_currentFilter );
-            m_currentFilter = TestSpec::Filter();
-        }
-    }
-
-    void TestSpecParser::saveLastMode() {
-      lastMode = m_mode;
-    }
-
-    void TestSpecParser::revertBackToLastMode() {
-      m_mode = lastMode;
-    }
-
-    bool TestSpecParser::separate() {
-      if( (m_mode==QuotedName) || (m_mode==Tag) ){
-         //invalid argument, signal failure to previous scope.
-         m_mode = None;
-         m_pos = m_arg.size();
-         m_substring.clear();
-         m_patternName.clear();
-         return false;
-      }
-      endMode();
-      addFilter();
-      return true; //success
-    }
-
-    std::string TestSpecParser::preprocessPattern() {
-        std::string token = m_patternName;
-        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
-            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
-        m_escapeChars.clear();
-        if (startsWith(token, "exclude:")) {
-            m_exclusion = true;
-            token = token.substr(8);
-        }
-
-        m_patternName.clear();
-
-        return token;
-    }
-
-    void TestSpecParser::addNamePattern() {
-        auto token = preprocessPattern();
-
-        if (!token.empty()) {
-            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
-            if (m_exclusion)
-                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
-            m_currentFilter.m_patterns.push_back(pattern);
-        }
-        m_substring.clear();
-        m_exclusion = false;
-        m_mode = None;
-    }
-
-    void TestSpecParser::addTagPattern() {
-        auto token = preprocessPattern();
-
-        if (!token.empty()) {
-            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
-            // we have to create a separate hide tag and shorten the real one
-            if (token.size() > 1 && token[0] == '.') {
-                token.erase(token.begin());
-                TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
-                if (m_exclusion) {
-                    pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
-                }
-                m_currentFilter.m_patterns.push_back(pattern);
-            }
-
-            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);
-
-            if (m_exclusion) {
-                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
-            }
-            m_currentFilter.m_patterns.push_back(pattern);
-        }
-        m_substring.clear();
-        m_exclusion = false;
-        m_mode = None;
-    }
-
-    TestSpec parseTestSpec( std::string const& arg ) {
-        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
-    }
-
-} // namespace Catch
-// end catch_test_spec_parser.cpp
-// start catch_timer.cpp
-
-#include <chrono>
-
-static const uint64_t nanosecondsInSecond = 1000000000;
-
-namespace Catch {
-
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
-        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
-    }
-
-    namespace {
-        auto estimateClockResolution() -> uint64_t {
-            uint64_t sum = 0;
-            static const uint64_t iterations = 1000000;
-
-            auto startTime = getCurrentNanosecondsSinceEpoch();
-
-            for( std::size_t i = 0; i < iterations; ++i ) {
-
-                uint64_t ticks;
-                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
-                do {
-                    ticks = getCurrentNanosecondsSinceEpoch();
-                } while( ticks == baseTicks );
-
-                auto delta = ticks - baseTicks;
-                sum += delta;
-
-                // If we have been calibrating for over 3 seconds -- the clock
-                // is terrible and we should move on.
-                // TBD: How to signal that the measured resolution is probably wrong?
-                if (ticks > startTime + 3 * nanosecondsInSecond) {
-                    return sum / ( i + 1u );
-                }
-            }
-
-            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
-            // - and potentially do more iterations if there's a high variance.
-            return sum/iterations;
-        }
-    }
-    auto getEstimatedClockResolution() -> uint64_t {
-        static auto s_resolution = estimateClockResolution();
-        return s_resolution;
-    }
-
-    void Timer::start() {
-       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
-    }
-    auto Timer::getElapsedNanoseconds() const -> uint64_t {
-        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
-    }
-    auto Timer::getElapsedMicroseconds() const -> uint64_t {
-        return getElapsedNanoseconds()/1000;
-    }
-    auto Timer::getElapsedMilliseconds() const -> unsigned int {
-        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
-    }
-    auto Timer::getElapsedSeconds() const -> double {
-        return getElapsedMicroseconds()/1000000.0;
-    }
-
-} // namespace Catch
-// end catch_timer.cpp
-// start catch_tostring.cpp
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#    pragma clang diagnostic ignored "-Wglobal-constructors"
-#endif
-
-// Enable specific decls locally
-#if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#endif
-
-#include <cmath>
-#include <iomanip>
-
-namespace Catch {
-
-namespace Detail {
-
-    const std::string unprintableString = "{?}";
-
-    namespace {
-        const int hexThreshold = 255;
-
-        struct Endianness {
-            enum Arch { Big, Little };
-
-            static Arch which() {
-                int one = 1;
-                // If the lowest byte we read is non-zero, we can assume
-                // that little endian format is used.
-                auto value = *reinterpret_cast<char*>(&one);
-                return value ? Little : Big;
-            }
-        };
-    }
-
-    std::string rawMemoryToString( const void *object, std::size_t size ) {
-        // Reverse order for little endian architectures
-        int i = 0, end = static_cast<int>( size ), inc = 1;
-        if( Endianness::which() == Endianness::Little ) {
-            i = end-1;
-            end = inc = -1;
-        }
-
-        unsigned char const *bytes = static_cast<unsigned char const *>(object);
-        ReusableStringStream rss;
-        rss << "0x" << std::setfill('0') << std::hex;
-        for( ; i != end; i += inc )
-             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
-       return rss.str();
-    }
-}
-
-template<typename T>
-std::string fpToString( T value, int precision ) {
-    if (Catch::isnan(value)) {
-        return "nan";
-    }
-
-    ReusableStringStream rss;
-    rss << std::setprecision( precision )
-        << std::fixed
-        << value;
-    std::string d = rss.str();
-    std::size_t i = d.find_last_not_of( '0' );
-    if( i != std::string::npos && i != d.size()-1 ) {
-        if( d[i] == '.' )
-            i++;
-        d = d.substr( 0, i+1 );
-    }
-    return d;
-}
-
-//// ======================================================= ////
-//
-//   Out-of-line defs for full specialization of StringMaker
-//
-//// ======================================================= ////
-
-std::string StringMaker<std::string>::convert(const std::string& str) {
-    if (!getCurrentContext().getConfig()->showInvisibles()) {
-        return '"' + str + '"';
-    }
-
-    std::string s("\"");
-    for (char c : str) {
-        switch (c) {
-        case '\n':
-            s.append("\\n");
-            break;
-        case '\t':
-            s.append("\\t");
-            break;
-        default:
-            s.push_back(c);
-            break;
-        }
-    }
-    s.append("\"");
-    return s;
-}
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::string_view>::convert(std::string_view str) {
-    return ::Catch::Detail::stringify(std::string{ str });
-}
-#endif
-
-std::string StringMaker<char const*>::convert(char const* str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<char*>::convert(char* str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-
-#ifdef CATCH_CONFIG_WCHAR
-std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
-    std::string s;
-    s.reserve(wstr.size());
-    for (auto c : wstr) {
-        s += (c <= 0xff) ? static_cast<char>(c) : '?';
-    }
-    return ::Catch::Detail::stringify(s);
-}
-
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
-    return StringMaker<std::wstring>::convert(std::wstring(str));
-}
-# endif
-
-std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-#endif
-
-#if defined(CATCH_CONFIG_CPP17_BYTE)
-#include <cstddef>
-std::string StringMaker<std::byte>::convert(std::byte value) {
-    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
-}
-#endif // defined(CATCH_CONFIG_CPP17_BYTE)
-
-std::string StringMaker<int>::convert(int value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long>::convert(long value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long long>::convert(long long value) {
-    ReusableStringStream rss;
-    rss << value;
-    if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
-    }
-    return rss.str();
-}
-
-std::string StringMaker<unsigned int>::convert(unsigned int value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long>::convert(unsigned long value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
-    ReusableStringStream rss;
-    rss << value;
-    if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
-    }
-    return rss.str();
-}
-
-std::string StringMaker<bool>::convert(bool b) {
-    return b ? "true" : "false";
-}
-
-std::string StringMaker<signed char>::convert(signed char value) {
-    if (value == '\r') {
-        return "'\\r'";
-    } else if (value == '\f') {
-        return "'\\f'";
-    } else if (value == '\n') {
-        return "'\\n'";
-    } else if (value == '\t') {
-        return "'\\t'";
-    } else if ('\0' <= value && value < ' ') {
-        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
-    } else {
-        char chstr[] = "' '";
-        chstr[1] = value;
-        return chstr;
-    }
-}
-std::string StringMaker<char>::convert(char c) {
-    return ::Catch::Detail::stringify(static_cast<signed char>(c));
-}
-std::string StringMaker<unsigned char>::convert(unsigned char c) {
-    return ::Catch::Detail::stringify(static_cast<char>(c));
-}
-
-std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
-    return "nullptr";
-}
-
-int StringMaker<float>::precision = 5;
-
-std::string StringMaker<float>::convert(float value) {
-    return fpToString(value, precision) + 'f';
-}
-
-int StringMaker<double>::precision = 10;
-
-std::string StringMaker<double>::convert(double value) {
-    return fpToString(value, precision);
-}
-
-std::string ratio_string<std::atto>::symbol() { return "a"; }
-std::string ratio_string<std::femto>::symbol() { return "f"; }
-std::string ratio_string<std::pico>::symbol() { return "p"; }
-std::string ratio_string<std::nano>::symbol() { return "n"; }
-std::string ratio_string<std::micro>::symbol() { return "u"; }
-std::string ratio_string<std::milli>::symbol() { return "m"; }
-
-} // end namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-
-// end catch_tostring.cpp
-// start catch_totals.cpp
-
-namespace Catch {
-
-    Counts Counts::operator - ( Counts const& other ) const {
-        Counts diff;
-        diff.passed = passed - other.passed;
-        diff.failed = failed - other.failed;
-        diff.failedButOk = failedButOk - other.failedButOk;
-        return diff;
-    }
-
-    Counts& Counts::operator += ( Counts const& other ) {
-        passed += other.passed;
-        failed += other.failed;
-        failedButOk += other.failedButOk;
-        return *this;
-    }
-
-    std::size_t Counts::total() const {
-        return passed + failed + failedButOk;
-    }
-    bool Counts::allPassed() const {
-        return failed == 0 && failedButOk == 0;
-    }
-    bool Counts::allOk() const {
-        return failed == 0;
-    }
-
-    Totals Totals::operator - ( Totals const& other ) const {
-        Totals diff;
-        diff.assertions = assertions - other.assertions;
-        diff.testCases = testCases - other.testCases;
-        return diff;
-    }
-
-    Totals& Totals::operator += ( Totals const& other ) {
-        assertions += other.assertions;
-        testCases += other.testCases;
-        return *this;
-    }
-
-    Totals Totals::delta( Totals const& prevTotals ) const {
-        Totals diff = *this - prevTotals;
-        if( diff.assertions.failed > 0 )
-            ++diff.testCases.failed;
-        else if( diff.assertions.failedButOk > 0 )
-            ++diff.testCases.failedButOk;
-        else
-            ++diff.testCases.passed;
-        return diff;
-    }
-
-}
-// end catch_totals.cpp
-// start catch_uncaught_exceptions.cpp
-
-#include <exception>
-
-namespace Catch {
-    bool uncaught_exceptions() {
-#if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-        return std::uncaught_exceptions() > 0;
-#else
-        return std::uncaught_exception();
-#endif
-  }
-} // end namespace Catch
-// end catch_uncaught_exceptions.cpp
-// start catch_version.cpp
-
-#include <ostream>
-
-namespace Catch {
-
-    Version::Version
-        (   unsigned int _majorVersion,
-            unsigned int _minorVersion,
-            unsigned int _patchNumber,
-            char const * const _branchName,
-            unsigned int _buildNumber )
-    :   majorVersion( _majorVersion ),
-        minorVersion( _minorVersion ),
-        patchNumber( _patchNumber ),
-        branchName( _branchName ),
-        buildNumber( _buildNumber )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, Version const& version ) {
-        os  << version.majorVersion << '.'
-            << version.minorVersion << '.'
-            << version.patchNumber;
-        // branchName is never null -> 0th char is \0 if it is empty
-        if (version.branchName[0]) {
-            os << '-' << version.branchName
-               << '.' << version.buildNumber;
-        }
-        return os;
-    }
-
-    Version const& libraryVersion() {
-        static Version version( 2, 11, 3, "", 0 );
-        return version;
-    }
-
-}
-// end catch_version.cpp
-// start catch_wildcard_pattern.cpp
-
-namespace Catch {
-
-    WildcardPattern::WildcardPattern( std::string const& pattern,
-                                      CaseSensitive::Choice caseSensitivity )
-    :   m_caseSensitivity( caseSensitivity ),
-        m_pattern( normaliseString( pattern ) )
-    {
-        if( startsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 1 );
-            m_wildcard = WildcardAtStart;
-        }
-        if( endsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
-            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
-        }
-    }
-
-    bool WildcardPattern::matches( std::string const& str ) const {
-        switch( m_wildcard ) {
-            case NoWildcard:
-                return m_pattern == normaliseString( str );
-            case WildcardAtStart:
-                return endsWith( normaliseString( str ), m_pattern );
-            case WildcardAtEnd:
-                return startsWith( normaliseString( str ), m_pattern );
-            case WildcardAtBothEnds:
-                return contains( normaliseString( str ), m_pattern );
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown enum" );
-        }
-    }
-
-    std::string WildcardPattern::normaliseString( std::string const& str ) const {
-        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
-    }
-}
-// end catch_wildcard_pattern.cpp
-// start catch_xmlwriter.cpp
-
-#include <iomanip>
-#include <type_traits>
-
-namespace Catch {
-
-namespace {
-
-    size_t trailingBytes(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return 2;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return 3;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return 4;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    uint32_t headerValue(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return c & 0x1F;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return c & 0x0F;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return c & 0x07;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    void hexEscapeChar(std::ostream& os, unsigned char c) {
-        std::ios_base::fmtflags f(os.flags());
-        os << "\\x"
-            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
-            << static_cast<int>(c);
-        os.flags(f);
-    }
-
-    bool shouldNewline(XmlFormatting fmt) {
-        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Newline));
-    }
-
-    bool shouldIndent(XmlFormatting fmt) {
-        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Indent));
-    }
-
-} // anonymous namespace
-
-    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
-        return static_cast<XmlFormatting>(
-            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) |
-            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
-        );
-    }
-
-    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
-        return static_cast<XmlFormatting>(
-            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) &
-            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
-        );
-    }
-
-    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
-    :   m_str( str ),
-        m_forWhat( forWhat )
-    {}
-
-    void XmlEncode::encodeTo( std::ostream& os ) const {
-        // Apostrophe escaping not necessary if we always use " to write attributes
-        // (see: http://www.w3.org/TR/xml/#syntax)
-
-        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
-            unsigned char c = m_str[idx];
-            switch (c) {
-            case '<':   os << "&lt;"; break;
-            case '&':   os << "&amp;"; break;
-
-            case '>':
-                // See: http://www.w3.org/TR/xml/#syntax
-                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
-                    os << "&gt;";
-                else
-                    os << c;
-                break;
-
-            case '\"':
-                if (m_forWhat == ForAttributes)
-                    os << "&quot;";
-                else
-                    os << c;
-                break;
-
-            default:
-                // Check for control characters and invalid utf-8
-
-                // Escape control characters in standard ascii
-                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
-                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // Plain ASCII: Write it to stream
-                if (c < 0x7F) {
-                    os << c;
-                    break;
-                }
-
-                // UTF-8 territory
-                // Check if the encoding is valid and if it is not, hex escape bytes.
-                // Important: We do not check the exact decoded values for validity, only the encoding format
-                // First check that this bytes is a valid lead byte:
-                // This means that it is not encoded as 1111 1XXX
-                // Or as 10XX XXXX
-                if (c <  0xC0 ||
-                    c >= 0xF8) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                auto encBytes = trailingBytes(c);
-                // Are there enough bytes left to avoid accessing out-of-bounds memory?
-                if (idx + encBytes - 1 >= m_str.size()) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-                // The header is valid, check data
-                // The next encBytes bytes must together be a valid utf-8
-                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
-                bool valid = true;
-                uint32_t value = headerValue(c);
-                for (std::size_t n = 1; n < encBytes; ++n) {
-                    unsigned char nc = m_str[idx + n];
-                    valid &= ((nc & 0xC0) == 0x80);
-                    value = (value << 6) | (nc & 0x3F);
-                }
-
-                if (
-                    // Wrong bit pattern of following bytes
-                    (!valid) ||
-                    // Overlong encodings
-                    (value < 0x80) ||
-                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
-                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
-                    // Encoded value out of range
-                    (value >= 0x110000)
-                    ) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // If we got here, this is in fact a valid(ish) utf-8 sequence
-                for (std::size_t n = 0; n < encBytes; ++n) {
-                    os << m_str[idx + n];
-                }
-                idx += encBytes - 1;
-                break;
-            }
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
-        xmlEncode.encodeTo( os );
-        return os;
-    }
-
-    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
-    :   m_writer( writer ),
-        m_fmt(fmt)
-    {}
-
-    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
-    :   m_writer( other.m_writer ),
-        m_fmt(other.m_fmt)
-    {
-        other.m_writer = nullptr;
-        other.m_fmt = XmlFormatting::None;
-    }
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
-        if ( m_writer ) {
-            m_writer->endElement();
-        }
-        m_writer = other.m_writer;
-        other.m_writer = nullptr;
-        m_fmt = other.m_fmt;
-        other.m_fmt = XmlFormatting::None;
-        return *this;
-    }
-
-    XmlWriter::ScopedElement::~ScopedElement() {
-        if (m_writer) {
-            m_writer->endElement(m_fmt);
-        }
-    }
-
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, XmlFormatting fmt ) {
-        m_writer->writeText( text, fmt );
-        return *this;
-    }
-
-    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
-    {
-        writeDeclaration();
-    }
-
-    XmlWriter::~XmlWriter() {
-        while (!m_tags.empty()) {
-            endElement();
-        }
-        newlineIfNecessary();
-    }
-
-    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
-        ensureTagClosed();
-        newlineIfNecessary();
-        if (shouldIndent(fmt)) {
-            m_os << m_indent;
-            m_indent += "  ";
-        }
-        m_os << '<' << name;
-        m_tags.push_back( name );
-        m_tagIsOpen = true;
-        applyFormatting(fmt);
-        return *this;
-    }
-
-    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
-        ScopedElement scoped( this, fmt );
-        startElement( name, fmt );
-        return scoped;
-    }
-
-    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
-        m_indent = m_indent.substr(0, m_indent.size() - 2);
-
-        if( m_tagIsOpen ) {
-            m_os << "/>";
-            m_tagIsOpen = false;
-        } else {
-            newlineIfNecessary();
-            if (shouldIndent(fmt)) {
-                m_os << m_indent;
-            }
-            m_os << "</" << m_tags.back() << ">";
-        }
-        m_os << std::flush;
-        applyFormatting(fmt);
-        m_tags.pop_back();
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
-        if( !name.empty() && !attribute.empty() )
-            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
-        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
-        if( !text.empty() ){
-            bool tagWasOpen = m_tagIsOpen;
-            ensureTagClosed();
-            if (tagWasOpen && shouldIndent(fmt)) {
-                m_os << m_indent;
-            }
-            m_os << XmlEncode( text );
-            applyFormatting(fmt);
-        }
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
-        ensureTagClosed();
-        if (shouldIndent(fmt)) {
-            m_os << m_indent;
-        }
-        m_os << "<!--" << text << "-->";
-        applyFormatting(fmt);
-        return *this;
-    }
-
-    void XmlWriter::writeStylesheetRef( std::string const& url ) {
-        m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
-    }
-
-    XmlWriter& XmlWriter::writeBlankLine() {
-        ensureTagClosed();
-        m_os << '\n';
-        return *this;
-    }
-
-    void XmlWriter::ensureTagClosed() {
-        if( m_tagIsOpen ) {
-            m_os << '>' << std::flush;
-            newlineIfNecessary();
-            m_tagIsOpen = false;
-        }
-    }
-
-    void XmlWriter::applyFormatting(XmlFormatting fmt) {
-        m_needsNewline = shouldNewline(fmt);
-    }
-
-    void XmlWriter::writeDeclaration() {
-        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-    }
-
-    void XmlWriter::newlineIfNecessary() {
-        if( m_needsNewline ) {
-            m_os << std::endl;
-            m_needsNewline = false;
-        }
-    }
-}
-// end catch_xmlwriter.cpp
-// start catch_reporter_bases.cpp
-
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <cassert>
-#include <memory>
-
-namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result) {
-        result.getExpandedExpression();
-    }
-
-    // Because formatting using c++ streams is stateful, drop down to C is required
-    // Alternatively we could use stringstream, but its performance is... not good.
-    std::string getFormattedDuration( double duration ) {
-        // Max exponent + 1 is required to represent the whole part
-        // + 1 for decimal point
-        // + 3 for the 3 decimal places
-        // + 1 for null terminator
-        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
-        char buffer[maxDoubleSize];
-
-        // Save previous errno, to prevent sprintf from overwriting it
-        ErrnoGuard guard;
-#ifdef _MSC_VER
-        sprintf_s(buffer, "%.3f", duration);
-#else
-        std::sprintf(buffer, "%.3f", duration);
-#endif
-        return std::string(buffer);
-    }
-
-    std::string serializeFilters( std::vector<std::string> const& container ) {
-        ReusableStringStream oss;
-        bool first = true;
-        for (auto&& filter : container)
-        {
-            if (!first)
-                oss << ' ';
-            else
-                first = false;
-
-            oss << filter;
-        }
-        return oss.str();
-    }
-
-    TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
-        :StreamingReporterBase(_config) {}
-
-    std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
-        return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
-    }
-
-    void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
-
-    bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
-        return false;
-    }
-
-} // end namespace Catch
-// end catch_reporter_bases.cpp
-// start catch_reporter_compact.cpp
-
-namespace {
-
-#ifdef CATCH_PLATFORM_MAC
-    const char* failedString() { return "FAILED"; }
-    const char* passedString() { return "PASSED"; }
-#else
-    const char* failedString() { return "failed"; }
-    const char* passedString() { return "passed"; }
-#endif
-
-    // Colour::LightGrey
-    Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
-
-    std::string bothOrAll( std::size_t count ) {
-        return count == 1 ? std::string() :
-               count == 2 ? "both " : "all " ;
-    }
-
-} // anon namespace
-
-namespace Catch {
-namespace {
-// Colour, message variants:
-// - white: No tests ran.
-// -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
-// - white: Passed [both/all] N test cases (no assertions).
-// -   red: Failed N tests cases, failed M assertions.
-// - green: Passed [both/all] N tests cases with M assertions.
-void printTotals(std::ostream& out, const Totals& totals) {
-    if (totals.testCases.total() == 0) {
-        out << "No tests ran.";
-    } else if (totals.testCases.failed == totals.testCases.total()) {
-        Colour colour(Colour::ResultError);
-        const std::string qualify_assertions_failed =
-            totals.assertions.failed == totals.assertions.total() ?
-            bothOrAll(totals.assertions.failed) : std::string();
-        out <<
-            "Failed " << bothOrAll(totals.testCases.failed)
-            << pluralise(totals.testCases.failed, "test case") << ", "
-            "failed " << qualify_assertions_failed <<
-            pluralise(totals.assertions.failed, "assertion") << '.';
-    } else if (totals.assertions.total() == 0) {
-        out <<
-            "Passed " << bothOrAll(totals.testCases.total())
-            << pluralise(totals.testCases.total(), "test case")
-            << " (no assertions).";
-    } else if (totals.assertions.failed) {
-        Colour colour(Colour::ResultError);
-        out <<
-            "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
-            "failed " << pluralise(totals.assertions.failed, "assertion") << '.';
-    } else {
-        Colour colour(Colour::ResultSuccess);
-        out <<
-            "Passed " << bothOrAll(totals.testCases.passed)
-            << pluralise(totals.testCases.passed, "test case") <<
-            " with " << pluralise(totals.assertions.passed, "assertion") << '.';
-    }
-}
-
-// Implementation of CompactReporter formatting
-class AssertionPrinter {
-public:
-    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
-    AssertionPrinter(AssertionPrinter const&) = delete;
-    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
-        : stream(_stream)
-        , result(_stats.assertionResult)
-        , messages(_stats.infoMessages)
-        , itMessage(_stats.infoMessages.begin())
-        , printInfoMessages(_printInfoMessages) {}
-
-    void print() {
-        printSourceInfo();
-
-        itMessage = messages.begin();
-
-        switch (result.getResultType()) {
-        case ResultWas::Ok:
-            printResultType(Colour::ResultSuccess, passedString());
-            printOriginalExpression();
-            printReconstructedExpression();
-            if (!result.hasExpression())
-                printRemainingMessages(Colour::None);
-            else
-                printRemainingMessages();
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk())
-                printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
-            else
-                printResultType(Colour::Error, failedString());
-            printOriginalExpression();
-            printReconstructedExpression();
-            printRemainingMessages();
-            break;
-        case ResultWas::ThrewException:
-            printResultType(Colour::Error, failedString());
-            printIssue("unexpected exception with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::FatalErrorCondition:
-            printResultType(Colour::Error, failedString());
-            printIssue("fatal error condition with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::DidntThrowException:
-            printResultType(Colour::Error, failedString());
-            printIssue("expected exception, got none");
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::Info:
-            printResultType(Colour::None, "info");
-            printMessage();
-            printRemainingMessages();
-            break;
-        case ResultWas::Warning:
-            printResultType(Colour::None, "warning");
-            printMessage();
-            printRemainingMessages();
-            break;
-        case ResultWas::ExplicitFailure:
-            printResultType(Colour::Error, failedString());
-            printIssue("explicitly");
-            printRemainingMessages(Colour::None);
-            break;
-            // These cases are here to prevent compiler warnings
-        case ResultWas::Unknown:
-        case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            printResultType(Colour::Error, "** internal error **");
-            break;
-        }
-    }
-
-private:
-    void printSourceInfo() const {
-        Colour colourGuard(Colour::FileName);
-        stream << result.getSourceInfo() << ':';
-    }
-
-    void printResultType(Colour::Code colour, std::string const& passOrFail) const {
-        if (!passOrFail.empty()) {
-            {
-                Colour colourGuard(colour);
-                stream << ' ' << passOrFail;
-            }
-            stream << ':';
-        }
-    }
-
-    void printIssue(std::string const& issue) const {
-        stream << ' ' << issue;
-    }
-
-    void printExpressionWas() {
-        if (result.hasExpression()) {
-            stream << ';';
-            {
-                Colour colour(dimColour());
-                stream << " expression was:";
-            }
-            printOriginalExpression();
-        }
-    }
-
-    void printOriginalExpression() const {
-        if (result.hasExpression()) {
-            stream << ' ' << result.getExpression();
-        }
-    }
-
-    void printReconstructedExpression() const {
-        if (result.hasExpandedExpression()) {
-            {
-                Colour colour(dimColour());
-                stream << " for: ";
-            }
-            stream << result.getExpandedExpression();
-        }
-    }
-
-    void printMessage() {
-        if (itMessage != messages.end()) {
-            stream << " '" << itMessage->message << '\'';
-            ++itMessage;
-        }
-    }
-
-    void printRemainingMessages(Colour::Code colour = dimColour()) {
-        if (itMessage == messages.end())
-            return;
-
-        const auto itEnd = messages.cend();
-        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
-
-        {
-            Colour colourGuard(colour);
-            stream << " with " << pluralise(N, "message") << ':';
-        }
-
-        while (itMessage != itEnd) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || itMessage->type != ResultWas::Info) {
-                printMessage();
-                if (itMessage != itEnd) {
-                    Colour colourGuard(dimColour());
-                    stream << " and";
-                }
-                continue;
-            }
-            ++itMessage;
-        }
-    }
-
-private:
-    std::ostream& stream;
-    AssertionResult const& result;
-    std::vector<MessageInfo> messages;
-    std::vector<MessageInfo>::const_iterator itMessage;
-    bool printInfoMessages;
-};
-
-} // anon namespace
-
-        std::string CompactReporter::getDescription() {
-            return "Reports test results on a single line, suitable for IDEs";
-        }
-
-        ReporterPreferences CompactReporter::getPreferences() const {
-            return m_reporterPrefs;
-        }
-
-        void CompactReporter::noMatchingTestCases( std::string const& spec ) {
-            stream << "No test cases matched '" << spec << '\'' << std::endl;
-        }
-
-        void CompactReporter::assertionStarting( AssertionInfo const& ) {}
-
-        bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
-            AssertionResult const& result = _assertionStats.assertionResult;
-
-            bool printInfoMessages = true;
-
-            // Drop out if result was successful and we're not printing those
-            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
-                if( result.getResultType() != ResultWas::Warning )
-                    return false;
-                printInfoMessages = false;
-            }
-
-            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
-            printer.print();
-
-            stream << std::endl;
-            return true;
-        }
-
-        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
-            if (m_config->showDurations() == ShowDurations::Always) {
-                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-            }
-        }
-
-        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
-            printTotals( stream, _testRunStats.totals );
-            stream << '\n' << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-        CompactReporter::~CompactReporter() {}
-
-    CATCH_REGISTER_REPORTER( "compact", CompactReporter )
-
-} // end namespace Catch
-// end catch_reporter_compact.cpp
-// start catch_reporter_console.cpp
-
-#include <cfloat>
-#include <cstdio>
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
- // Note that 4062 (not all labels are handled and default is missing) is enabled
-#endif
-
-#if defined(__clang__)
-#  pragma clang diagnostic push
-// For simplicity, benchmarking-only helpers are always enabled
-#  pragma clang diagnostic ignored "-Wunused-function"
-#endif
-
-namespace Catch {
-
-namespace {
-
-// Formatter impl for ConsoleReporter
-class ConsoleAssertionPrinter {
-public:
-    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
-        : stream(_stream),
-        stats(_stats),
-        result(_stats.assertionResult),
-        colour(Colour::None),
-        message(result.getMessage()),
-        messages(_stats.infoMessages),
-        printInfoMessages(_printInfoMessages) {
-        switch (result.getResultType()) {
-        case ResultWas::Ok:
-            colour = Colour::Success;
-            passOrFail = "PASSED";
-            //if( result.hasMessage() )
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "with messages";
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk()) {
-                colour = Colour::Success;
-                passOrFail = "FAILED - but was ok";
-            } else {
-                colour = Colour::Error;
-                passOrFail = "FAILED";
-            }
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "with messages";
-            break;
-        case ResultWas::ThrewException:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "due to unexpected exception with ";
-            if (_stats.infoMessages.size() == 1)
-                messageLabel += "message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel += "messages";
-            break;
-        case ResultWas::FatalErrorCondition:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "due to a fatal error condition";
-            break;
-        case ResultWas::DidntThrowException:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "because no exception was thrown where one was expected";
-            break;
-        case ResultWas::Info:
-            messageLabel = "info";
-            break;
-        case ResultWas::Warning:
-            messageLabel = "warning";
-            break;
-        case ResultWas::ExplicitFailure:
-            passOrFail = "FAILED";
-            colour = Colour::Error;
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "explicitly with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "explicitly with messages";
-            break;
-            // These cases are here to prevent compiler warnings
-        case ResultWas::Unknown:
-        case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            passOrFail = "** internal error **";
-            colour = Colour::Error;
-            break;
-        }
-    }
-
-    void print() const {
-        printSourceInfo();
-        if (stats.totals.assertions.total() > 0) {
-            printResultType();
-            printOriginalExpression();
-            printReconstructedExpression();
-        } else {
-            stream << '\n';
-        }
-        printMessage();
-    }
-
-private:
-    void printResultType() const {
-        if (!passOrFail.empty()) {
-            Colour colourGuard(colour);
-            stream << passOrFail << ":\n";
-        }
-    }
-    void printOriginalExpression() const {
-        if (result.hasExpression()) {
-            Colour colourGuard(Colour::OriginalExpression);
-            stream << "  ";
-            stream << result.getExpressionInMacro();
-            stream << '\n';
-        }
-    }
-    void printReconstructedExpression() const {
-        if (result.hasExpandedExpression()) {
-            stream << "with expansion:\n";
-            Colour colourGuard(Colour::ReconstructedExpression);
-            stream << Column(result.getExpandedExpression()).indent(2) << '\n';
-        }
-    }
-    void printMessage() const {
-        if (!messageLabel.empty())
-            stream << messageLabel << ':' << '\n';
-        for (auto const& msg : messages) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || msg.type != ResultWas::Info)
-                stream << Column(msg.message).indent(2) << '\n';
-        }
-    }
-    void printSourceInfo() const {
-        Colour colourGuard(Colour::FileName);
-        stream << result.getSourceInfo() << ": ";
-    }
-
-    std::ostream& stream;
-    AssertionStats const& stats;
-    AssertionResult const& result;
-    Colour::Code colour;
-    std::string passOrFail;
-    std::string messageLabel;
-    std::string message;
-    std::vector<MessageInfo> messages;
-    bool printInfoMessages;
-};
-
-std::size_t makeRatio(std::size_t number, std::size_t total) {
-    std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
-    return (ratio == 0 && number > 0) ? 1 : ratio;
-}
-
-std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
-    if (i > j && i > k)
-        return i;
-    else if (j > k)
-        return j;
-    else
-        return k;
-}
-
-struct ColumnInfo {
-    enum Justification { Left, Right };
-    std::string name;
-    int width;
-    Justification justification;
-};
-struct ColumnBreak {};
-struct RowBreak {};
-
-class Duration {
-    enum class Unit {
-        Auto,
-        Nanoseconds,
-        Microseconds,
-        Milliseconds,
-        Seconds,
-        Minutes
-    };
-    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
-    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
-    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
-    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
-
-    double m_inNanoseconds;
-    Unit m_units;
-
-public:
-    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
-        : m_inNanoseconds(inNanoseconds),
-        m_units(units) {
-        if (m_units == Unit::Auto) {
-            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
-                m_units = Unit::Nanoseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
-                m_units = Unit::Microseconds;
-            else if (m_inNanoseconds < s_nanosecondsInASecond)
-                m_units = Unit::Milliseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMinute)
-                m_units = Unit::Seconds;
-            else
-                m_units = Unit::Minutes;
-        }
-
-    }
-
-    auto value() const -> double {
-        switch (m_units) {
-        case Unit::Microseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
-        case Unit::Milliseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
-        case Unit::Seconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
-        case Unit::Minutes:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
-        default:
-            return m_inNanoseconds;
-        }
-    }
-    auto unitsAsString() const -> std::string {
-        switch (m_units) {
-        case Unit::Nanoseconds:
-            return "ns";
-        case Unit::Microseconds:
-            return "us";
-        case Unit::Milliseconds:
-            return "ms";
-        case Unit::Seconds:
-            return "s";
-        case Unit::Minutes:
-            return "m";
-        default:
-            return "** internal error **";
-        }
-
-    }
-    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
-        return os << duration.value() << ' ' << duration.unitsAsString();
-    }
-};
-} // end anon namespace
-
-class TablePrinter {
-    std::ostream& m_os;
-    std::vector<ColumnInfo> m_columnInfos;
-    std::ostringstream m_oss;
-    int m_currentColumn = -1;
-    bool m_isOpen = false;
-
-public:
-    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
-    :   m_os( os ),
-        m_columnInfos( std::move( columnInfos ) ) {}
-
-    auto columnInfos() const -> std::vector<ColumnInfo> const& {
-        return m_columnInfos;
-    }
-
-    void open() {
-        if (!m_isOpen) {
-            m_isOpen = true;
-            *this << RowBreak();
-
-			Columns headerCols;
-			Spacer spacer(2);
-			for (auto const& info : m_columnInfos) {
-				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
-				headerCols += spacer;
-			}
-			m_os << headerCols << '\n';
-
-            m_os << Catch::getLineOfChars<'-'>() << '\n';
-        }
-    }
-    void close() {
-        if (m_isOpen) {
-            *this << RowBreak();
-            m_os << std::endl;
-            m_isOpen = false;
-        }
-    }
-
-    template<typename T>
-    friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
-        tp.m_oss << value;
-        return tp;
-    }
-
-    friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
-        auto colStr = tp.m_oss.str();
-        const auto strSize = colStr.size();
-        tp.m_oss.str("");
-        tp.open();
-        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
-            tp.m_currentColumn = -1;
-            tp.m_os << '\n';
-        }
-        tp.m_currentColumn++;
-
-        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
-        auto padding = (strSize + 1 < static_cast<std::size_t>(colInfo.width))
-            ? std::string(colInfo.width - (strSize + 1), ' ')
-            : std::string();
-        if (colInfo.justification == ColumnInfo::Left)
-            tp.m_os << colStr << padding << ' ';
-        else
-            tp.m_os << padding << colStr << ' ';
-        return tp;
-    }
-
-    friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
-        if (tp.m_currentColumn > 0) {
-            tp.m_os << '\n';
-            tp.m_currentColumn = -1;
-        }
-        return tp;
-    }
-};
-
-ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
-    : StreamingReporterBase(config),
-    m_tablePrinter(new TablePrinter(config.stream(),
-        [&config]() -> std::vector<ColumnInfo> {
-        if (config.fullConfig()->benchmarkNoAnalysis())
-        {
-            return{
-                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
-                { "     samples", 14, ColumnInfo::Right },
-                { "  iterations", 14, ColumnInfo::Right },
-                { "        mean", 14, ColumnInfo::Right }
-            };
-        }
-        else
-        {
-            return{
-                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
-                { "samples      mean       std dev", 14, ColumnInfo::Right },
-                { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
-                { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
-            };
-        }
-    }())) {}
-ConsoleReporter::~ConsoleReporter() = default;
-
-std::string ConsoleReporter::getDescription() {
-    return "Reports test results as plain lines of text";
-}
-
-void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
-    stream << "No test cases matched '" << spec << '\'' << std::endl;
-}
-
-void ConsoleReporter::reportInvalidArguments(std::string const&arg){
-    stream << "Invalid Filter: " << arg << std::endl;
-}
-
-void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
-
-bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
-    AssertionResult const& result = _assertionStats.assertionResult;
-
-    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-    // Drop out if result was successful but we're not printing them.
-    if (!includeResults && result.getResultType() != ResultWas::Warning)
-        return false;
-
-    lazyPrint();
-
-    ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
-    printer.print();
-    stream << std::endl;
-    return true;
-}
-
-void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
-    m_tablePrinter->close();
-    m_headerPrinted = false;
-    StreamingReporterBase::sectionStarting(_sectionInfo);
-}
-void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
-    m_tablePrinter->close();
-    if (_sectionStats.missingAssertions) {
-        lazyPrint();
-        Colour colour(Colour::ResultError);
-        if (m_sectionStack.size() > 1)
-            stream << "\nNo assertions in section";
-        else
-            stream << "\nNo assertions in test case";
-        stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
-    }
-    if (m_config->showDurations() == ShowDurations::Always) {
-        stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-    }
-    if (m_headerPrinted) {
-        m_headerPrinted = false;
-    }
-    StreamingReporterBase::sectionEnded(_sectionStats);
-}
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-void ConsoleReporter::benchmarkPreparing(std::string const& name) {
-	lazyPrintWithoutClosingBenchmarkTable();
-
-	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
-
-	bool firstLine = true;
-	for (auto line : nameCol) {
-		if (!firstLine)
-			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
-		else
-			firstLine = false;
-
-		(*m_tablePrinter) << line << ColumnBreak();
-	}
-}
-
-void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
-    (*m_tablePrinter) << info.samples << ColumnBreak()
-        << info.iterations << ColumnBreak();
-    if (!m_config->benchmarkNoAnalysis())
-        (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
-}
-void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
-    if (m_config->benchmarkNoAnalysis())
-    {
-        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
-    }
-    else
-    {
-        (*m_tablePrinter) << ColumnBreak()
-            << Duration(stats.mean.point.count()) << ColumnBreak()
-            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
-            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
-            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
-            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
-            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
-    }
-}
-
-void ConsoleReporter::benchmarkFailed(std::string const& error) {
-	Colour colour(Colour::Red);
-    (*m_tablePrinter)
-        << "Benchmark failed (" << error << ')'
-        << ColumnBreak() << RowBreak();
-}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
-    m_tablePrinter->close();
-    StreamingReporterBase::testCaseEnded(_testCaseStats);
-    m_headerPrinted = false;
-}
-void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
-    if (currentGroupInfo.used) {
-        printSummaryDivider();
-        stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
-        printTotals(_testGroupStats.totals);
-        stream << '\n' << std::endl;
-    }
-    StreamingReporterBase::testGroupEnded(_testGroupStats);
-}
-void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
-    printTotalsDivider(_testRunStats.totals);
-    printTotals(_testRunStats.totals);
-    stream << std::endl;
-    StreamingReporterBase::testRunEnded(_testRunStats);
-}
-void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
-    StreamingReporterBase::testRunStarting(_testInfo);
-    printTestFilters();
-}
-
-void ConsoleReporter::lazyPrint() {
-
-    m_tablePrinter->close();
-    lazyPrintWithoutClosingBenchmarkTable();
-}
-
-void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
-
-    if (!currentTestRunInfo.used)
-        lazyPrintRunInfo();
-    if (!currentGroupInfo.used)
-        lazyPrintGroupInfo();
-
-    if (!m_headerPrinted) {
-        printTestCaseAndSectionHeader();
-        m_headerPrinted = true;
-    }
-}
-void ConsoleReporter::lazyPrintRunInfo() {
-    stream << '\n' << getLineOfChars<'~'>() << '\n';
-    Colour colour(Colour::SecondaryText);
-    stream << currentTestRunInfo->name
-        << " is a Catch v" << libraryVersion() << " host application.\n"
-        << "Run with -? for options\n\n";
-
-    if (m_config->rngSeed() != 0)
-        stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
-
-    currentTestRunInfo.used = true;
-}
-void ConsoleReporter::lazyPrintGroupInfo() {
-    if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
-        printClosedHeader("Group: " + currentGroupInfo->name);
-        currentGroupInfo.used = true;
-    }
-}
-void ConsoleReporter::printTestCaseAndSectionHeader() {
-    assert(!m_sectionStack.empty());
-    printOpenHeader(currentTestCaseInfo->name);
-
-    if (m_sectionStack.size() > 1) {
-        Colour colourGuard(Colour::Headers);
-
-        auto
-            it = m_sectionStack.begin() + 1, // Skip first section (test case)
-            itEnd = m_sectionStack.end();
-        for (; it != itEnd; ++it)
-            printHeaderString(it->name, 2);
-    }
-
-    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
-
-    stream << getLineOfChars<'-'>() << '\n';
-    Colour colourGuard(Colour::FileName);
-    stream << lineInfo << '\n';
-    stream << getLineOfChars<'.'>() << '\n' << std::endl;
-}
-
-void ConsoleReporter::printClosedHeader(std::string const& _name) {
-    printOpenHeader(_name);
-    stream << getLineOfChars<'.'>() << '\n';
-}
-void ConsoleReporter::printOpenHeader(std::string const& _name) {
-    stream << getLineOfChars<'-'>() << '\n';
-    {
-        Colour colourGuard(Colour::Headers);
-        printHeaderString(_name);
-    }
-}
-
-// if string has a : in first line will set indent to follow it on
-// subsequent lines
-void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
-    std::size_t i = _string.find(": ");
-    if (i != std::string::npos)
-        i += 2;
-    else
-        i = 0;
-    stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
-}
-
-struct SummaryColumn {
-
-    SummaryColumn( std::string _label, Colour::Code _colour )
-    :   label( std::move( _label ) ),
-        colour( _colour ) {}
-    SummaryColumn addRow( std::size_t count ) {
-        ReusableStringStream rss;
-        rss << count;
-        std::string row = rss.str();
-        for (auto& oldRow : rows) {
-            while (oldRow.size() < row.size())
-                oldRow = ' ' + oldRow;
-            while (oldRow.size() > row.size())
-                row = ' ' + row;
-        }
-        rows.push_back(row);
-        return *this;
-    }
-
-    std::string label;
-    Colour::Code colour;
-    std::vector<std::string> rows;
-
-};
-
-void ConsoleReporter::printTotals( Totals const& totals ) {
-    if (totals.testCases.total() == 0) {
-        stream << Colour(Colour::Warning) << "No tests ran\n";
-    } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
-        stream << Colour(Colour::ResultSuccess) << "All tests passed";
-        stream << " ("
-            << pluralise(totals.assertions.passed, "assertion") << " in "
-            << pluralise(totals.testCases.passed, "test case") << ')'
-            << '\n';
-    } else {
-
-        std::vector<SummaryColumn> columns;
-        columns.push_back(SummaryColumn("", Colour::None)
-                          .addRow(totals.testCases.total())
-                          .addRow(totals.assertions.total()));
-        columns.push_back(SummaryColumn("passed", Colour::Success)
-                          .addRow(totals.testCases.passed)
-                          .addRow(totals.assertions.passed));
-        columns.push_back(SummaryColumn("failed", Colour::ResultError)
-                          .addRow(totals.testCases.failed)
-                          .addRow(totals.assertions.failed));
-        columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
-                          .addRow(totals.testCases.failedButOk)
-                          .addRow(totals.assertions.failedButOk));
-
-        printSummaryRow("test cases", columns, 0);
-        printSummaryRow("assertions", columns, 1);
-    }
-}
-void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
-    for (auto col : cols) {
-        std::string value = col.rows[row];
-        if (col.label.empty()) {
-            stream << label << ": ";
-            if (value != "0")
-                stream << value;
-            else
-                stream << Colour(Colour::Warning) << "- none -";
-        } else if (value != "0") {
-            stream << Colour(Colour::LightGrey) << " | ";
-            stream << Colour(col.colour)
-                << value << ' ' << col.label;
-        }
-    }
-    stream << '\n';
-}
-
-void ConsoleReporter::printTotalsDivider(Totals const& totals) {
-    if (totals.testCases.total() > 0) {
-        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
-        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
-        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
-        while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio)++;
-        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio)--;
-
-        stream << Colour(Colour::Error) << std::string(failedRatio, '=');
-        stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
-        if (totals.testCases.allPassed())
-            stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
-        else
-            stream << Colour(Colour::Success) << std::string(passedRatio, '=');
-    } else {
-        stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
-    }
-    stream << '\n';
-}
-void ConsoleReporter::printSummaryDivider() {
-    stream << getLineOfChars<'-'>() << '\n';
-}
-
-void ConsoleReporter::printTestFilters() {
-    if (m_config->testSpec().hasFilters()) {
-        Colour guard(Colour::BrightYellow);
-        stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
-    }
-}
-
-CATCH_REGISTER_REPORTER("console", ConsoleReporter)
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-#if defined(__clang__)
-#  pragma clang diagnostic pop
-#endif
-// end catch_reporter_console.cpp
-// start catch_reporter_junit.cpp
-
-#include <cassert>
-#include <sstream>
-#include <ctime>
-#include <algorithm>
-
-namespace Catch {
-
-    namespace {
-        std::string getCurrentTimestamp() {
-            // Beware, this is not reentrant because of backward compatibility issues
-            // Also, UTC only, again because of backward compatibility (%z is C++11)
-            time_t rawtime;
-            std::time(&rawtime);
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &rawtime);
-#else
-            std::tm* timeInfo;
-            timeInfo = std::gmtime(&rawtime);
-#endif
-
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
-
-        std::string fileNameTag(const std::vector<std::string> &tags) {
-            auto it = std::find_if(begin(tags),
-                                   end(tags),
-                                   [] (std::string const& tag) {return tag.front() == '#'; });
-            if (it != tags.end())
-                return it->substr(1);
-            return std::string();
-        }
-    } // anonymous namespace
-
-    JunitReporter::JunitReporter( ReporterConfig const& _config )
-        :   CumulativeReporterBase( _config ),
-            xml( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-            m_reporterPrefs.shouldReportAllAssertions = true;
-        }
-
-    JunitReporter::~JunitReporter() {}
-
-    std::string JunitReporter::getDescription() {
-        return "Reports test results in an XML format that looks like Ant's junitreport target";
-    }
-
-    void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
-
-    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
-        CumulativeReporterBase::testRunStarting( runInfo );
-        xml.startElement( "testsuites" );
-    }
-
-    void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        suiteTimer.start();
-        stdOutForSuite.clear();
-        stdErrForSuite.clear();
-        unexpectedExceptions = 0;
-        CumulativeReporterBase::testGroupStarting( groupInfo );
-    }
-
-    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
-        m_okToFail = testCaseInfo.okToFail();
-    }
-
-    bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
-            unexpectedExceptions++;
-        return CumulativeReporterBase::assertionEnded( assertionStats );
-    }
-
-    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        stdOutForSuite += testCaseStats.stdOut;
-        stdErrForSuite += testCaseStats.stdErr;
-        CumulativeReporterBase::testCaseEnded( testCaseStats );
-    }
-
-    void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        double suiteTime = suiteTimer.getElapsedSeconds();
-        CumulativeReporterBase::testGroupEnded( testGroupStats );
-        writeGroup( *m_testGroups.back(), suiteTime );
-    }
-
-    void JunitReporter::testRunEndedCumulative() {
-        xml.endElement();
-    }
-
-    void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
-        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
-
-        TestGroupStats const& stats = groupNode.value;
-        xml.writeAttribute( "name", stats.groupInfo.name );
-        xml.writeAttribute( "errors", unexpectedExceptions );
-        xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
-        xml.writeAttribute( "tests", stats.totals.assertions.total() );
-        xml.writeAttribute( "hostname", "tbd" ); // !TBD
-        if( m_config->showDurations() == ShowDurations::Never )
-            xml.writeAttribute( "time", "" );
-        else
-            xml.writeAttribute( "time", suiteTime );
-        xml.writeAttribute( "timestamp", getCurrentTimestamp() );
-
-        // Write properties if there are any
-        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
-            auto properties = xml.scopedElement("properties");
-            if (m_config->hasTestFilters()) {
-                xml.scopedElement("property")
-                    .writeAttribute("name", "filters")
-                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
-            }
-            if (m_config->rngSeed() != 0) {
-                xml.scopedElement("property")
-                    .writeAttribute("name", "random-seed")
-                    .writeAttribute("value", m_config->rngSeed());
-            }
-        }
-
-        // Write test cases
-        for( auto const& child : groupNode.children )
-            writeTestCase( *child );
-
-        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
-        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
-    }
-
-    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
-        TestCaseStats const& stats = testCaseNode.value;
-
-        // All test cases have exactly one section - which represents the
-        // test case itself. That section may have 0-n nested sections
-        assert( testCaseNode.children.size() == 1 );
-        SectionNode const& rootSection = *testCaseNode.children.front();
-
-        std::string className = stats.testInfo.className;
-
-        if( className.empty() ) {
-            className = fileNameTag(stats.testInfo.tags);
-            if ( className.empty() )
-                className = "global";
-        }
-
-        if ( !m_config->name().empty() )
-            className = m_config->name() + "." + className;
-
-        writeSection( className, "", rootSection );
-    }
-
-    void JunitReporter::writeSection(  std::string const& className,
-                        std::string const& rootName,
-                        SectionNode const& sectionNode ) {
-        std::string name = trim( sectionNode.stats.sectionInfo.name );
-        if( !rootName.empty() )
-            name = rootName + '/' + name;
-
-        if( !sectionNode.assertions.empty() ||
-            !sectionNode.stdOut.empty() ||
-            !sectionNode.stdErr.empty() ) {
-            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
-            if( className.empty() ) {
-                xml.writeAttribute( "classname", name );
-                xml.writeAttribute( "name", "root" );
-            }
-            else {
-                xml.writeAttribute( "classname", className );
-                xml.writeAttribute( "name", name );
-            }
-            xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
-
-            writeAssertions( sectionNode );
-
-            if( !sectionNode.stdOut.empty() )
-                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
-            if( !sectionNode.stdErr.empty() )
-                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
-        }
-        for( auto const& childNode : sectionNode.childSections )
-            if( className.empty() )
-                writeSection( name, "", *childNode );
-            else
-                writeSection( className, name, *childNode );
-    }
-
-    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
-        for( auto const& assertion : sectionNode.assertions )
-            writeAssertion( assertion );
-    }
-
-    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
-        AssertionResult const& result = stats.assertionResult;
-        if( !result.isOk() ) {
-            std::string elementName;
-            switch( result.getResultType() ) {
-                case ResultWas::ThrewException:
-                case ResultWas::FatalErrorCondition:
-                    elementName = "error";
-                    break;
-                case ResultWas::ExplicitFailure:
-                case ResultWas::ExpressionFailed:
-                case ResultWas::DidntThrowException:
-                    elementName = "failure";
-                    break;
-
-                // We should never see these here:
-                case ResultWas::Info:
-                case ResultWas::Warning:
-                case ResultWas::Ok:
-                case ResultWas::Unknown:
-                case ResultWas::FailureBit:
-                case ResultWas::Exception:
-                    elementName = "internalError";
-                    break;
-            }
-
-            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
-
-            xml.writeAttribute( "message", result.getExpression() );
-            xml.writeAttribute( "type", result.getTestMacroName() );
-
-            ReusableStringStream rss;
-            if (stats.totals.assertions.total() > 0) {
-                rss << "FAILED" << ":\n";
-                if (result.hasExpression()) {
-                    rss << "  ";
-                    rss << result.getExpressionInMacro();
-                    rss << '\n';
-                }
-                if (result.hasExpandedExpression()) {
-                    rss << "with expansion:\n";
-                    rss << Column(result.getExpandedExpression()).indent(2) << '\n';
-                }
-            } else {
-                rss << '\n';
-            }
-
-            if( !result.getMessage().empty() )
-                rss << result.getMessage() << '\n';
-            for( auto const& msg : stats.infoMessages )
-                if( msg.type == ResultWas::Info )
-                    rss << msg.message << '\n';
-
-            rss << "at " << result.getSourceInfo();
-            xml.writeText( rss.str(), XmlFormatting::Newline );
-        }
-    }
-
-    CATCH_REGISTER_REPORTER( "junit", JunitReporter )
-
-} // end namespace Catch
-// end catch_reporter_junit.cpp
-// start catch_reporter_listening.cpp
-
-#include <cassert>
-
-namespace Catch {
-
-    ListeningReporter::ListeningReporter() {
-        // We will assume that listeners will always want all assertions
-        m_preferences.shouldReportAllAssertions = true;
-    }
-
-    void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
-        m_listeners.push_back( std::move( listener ) );
-    }
-
-    void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
-        assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
-        m_reporter = std::move( reporter );
-        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
-    }
-
-    ReporterPreferences ListeningReporter::getPreferences() const {
-        return m_preferences;
-    }
-
-    std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
-        return std::set<Verbosity>{ };
-    }
-
-    void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->noMatchingTestCases( spec );
-        }
-        m_reporter->noMatchingTestCases( spec );
-    }
-
-    void ListeningReporter::reportInvalidArguments(std::string const&arg){
-        for ( auto const& listener : m_listeners ) {
-            listener->reportInvalidArguments( arg );
-        }
-        m_reporter->reportInvalidArguments( arg );
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
-		for (auto const& listener : m_listeners) {
-			listener->benchmarkPreparing(name);
-		}
-		m_reporter->benchmarkPreparing(name);
-	}
-    void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->benchmarkStarting( benchmarkInfo );
-        }
-        m_reporter->benchmarkStarting( benchmarkInfo );
-    }
-    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->benchmarkEnded( benchmarkStats );
-        }
-        m_reporter->benchmarkEnded( benchmarkStats );
-    }
-
-	void ListeningReporter::benchmarkFailed( std::string const& error ) {
-		for (auto const& listener : m_listeners) {
-			listener->benchmarkFailed(error);
-		}
-		m_reporter->benchmarkFailed(error);
-	}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testRunStarting( testRunInfo );
-        }
-        m_reporter->testRunStarting( testRunInfo );
-    }
-
-    void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testGroupStarting( groupInfo );
-        }
-        m_reporter->testGroupStarting( groupInfo );
-    }
-
-    void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testCaseStarting( testInfo );
-        }
-        m_reporter->testCaseStarting( testInfo );
-    }
-
-    void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->sectionStarting( sectionInfo );
-        }
-        m_reporter->sectionStarting( sectionInfo );
-    }
-
-    void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->assertionStarting( assertionInfo );
-        }
-        m_reporter->assertionStarting( assertionInfo );
-    }
-
-    // The return value indicates if the messages buffer should be cleared:
-    bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        for( auto const& listener : m_listeners ) {
-            static_cast<void>( listener->assertionEnded( assertionStats ) );
-        }
-        return m_reporter->assertionEnded( assertionStats );
-    }
-
-    void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->sectionEnded( sectionStats );
-        }
-        m_reporter->sectionEnded( sectionStats );
-    }
-
-    void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testCaseEnded( testCaseStats );
-        }
-        m_reporter->testCaseEnded( testCaseStats );
-    }
-
-    void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testGroupEnded( testGroupStats );
-        }
-        m_reporter->testGroupEnded( testGroupStats );
-    }
-
-    void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testRunEnded( testRunStats );
-        }
-        m_reporter->testRunEnded( testRunStats );
-    }
-
-    void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->skipTest( testInfo );
-        }
-        m_reporter->skipTest( testInfo );
-    }
-
-    bool ListeningReporter::isMulti() const {
-        return true;
-    }
-
-} // end namespace Catch
-// end catch_reporter_listening.cpp
-// start catch_reporter_xml.cpp
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-    XmlReporter::XmlReporter( ReporterConfig const& _config )
-    :   StreamingReporterBase( _config ),
-        m_xml(_config.stream())
-    {
-        m_reporterPrefs.shouldRedirectStdOut = true;
-        m_reporterPrefs.shouldReportAllAssertions = true;
-    }
-
-    XmlReporter::~XmlReporter() = default;
-
-    std::string XmlReporter::getDescription() {
-        return "Reports test results as an XML document";
-    }
-
-    std::string XmlReporter::getStylesheetRef() const {
-        return std::string();
-    }
-
-    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
-        m_xml
-            .writeAttribute( "filename", sourceInfo.file )
-            .writeAttribute( "line", sourceInfo.line );
-    }
-
-    void XmlReporter::noMatchingTestCases( std::string const& s ) {
-        StreamingReporterBase::noMatchingTestCases( s );
-    }
-
-    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
-        StreamingReporterBase::testRunStarting( testInfo );
-        std::string stylesheetRef = getStylesheetRef();
-        if( !stylesheetRef.empty() )
-            m_xml.writeStylesheetRef( stylesheetRef );
-        m_xml.startElement( "Catch" );
-        if( !m_config->name().empty() )
-            m_xml.writeAttribute( "name", m_config->name() );
-        if (m_config->testSpec().hasFilters())
-            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
-        if( m_config->rngSeed() != 0 )
-            m_xml.scopedElement( "Randomness" )
-                .writeAttribute( "seed", m_config->rngSeed() );
-    }
-
-    void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        StreamingReporterBase::testGroupStarting( groupInfo );
-        m_xml.startElement( "Group" )
-            .writeAttribute( "name", groupInfo.name );
-    }
-
-    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        StreamingReporterBase::testCaseStarting(testInfo);
-        m_xml.startElement( "TestCase" )
-            .writeAttribute( "name", trim( testInfo.name ) )
-            .writeAttribute( "description", testInfo.description )
-            .writeAttribute( "tags", testInfo.tagsAsString() );
-
-        writeSourceInfo( testInfo.lineInfo );
-
-        if ( m_config->showDurations() == ShowDurations::Always )
-            m_testCaseTimer.start();
-        m_xml.ensureTagClosed();
-    }
-
-    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        StreamingReporterBase::sectionStarting( sectionInfo );
-        if( m_sectionDepth++ > 0 ) {
-            m_xml.startElement( "Section" )
-                .writeAttribute( "name", trim( sectionInfo.name ) );
-            writeSourceInfo( sectionInfo.lineInfo );
-            m_xml.ensureTagClosed();
-        }
-    }
-
-    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
-
-    bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
-
-        AssertionResult const& result = assertionStats.assertionResult;
-
-        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-        if( includeResults || result.getResultType() == ResultWas::Warning ) {
-            // Print any info messages in <Info> tags.
-            for( auto const& msg : assertionStats.infoMessages ) {
-                if( msg.type == ResultWas::Info && includeResults ) {
-                    m_xml.scopedElement( "Info" )
-                            .writeText( msg.message );
-                } else if ( msg.type == ResultWas::Warning ) {
-                    m_xml.scopedElement( "Warning" )
-                            .writeText( msg.message );
-                }
-            }
-        }
-
-        // Drop out if result was successful but we're not printing them.
-        if( !includeResults && result.getResultType() != ResultWas::Warning )
-            return true;
-
-        // Print the expression if there is one.
-        if( result.hasExpression() ) {
-            m_xml.startElement( "Expression" )
-                .writeAttribute( "success", result.succeeded() )
-                .writeAttribute( "type", result.getTestMacroName() );
-
-            writeSourceInfo( result.getSourceInfo() );
-
-            m_xml.scopedElement( "Original" )
-                .writeText( result.getExpression() );
-            m_xml.scopedElement( "Expanded" )
-                .writeText( result.getExpandedExpression() );
-        }
-
-        // And... Print a result applicable to each result type.
-        switch( result.getResultType() ) {
-            case ResultWas::ThrewException:
-                m_xml.startElement( "Exception" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::FatalErrorCondition:
-                m_xml.startElement( "FatalErrorCondition" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::Info:
-                m_xml.scopedElement( "Info" )
-                    .writeText( result.getMessage() );
-                break;
-            case ResultWas::Warning:
-                // Warning will already have been written
-                break;
-            case ResultWas::ExplicitFailure:
-                m_xml.startElement( "Failure" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            default:
-                break;
-        }
-
-        if( result.hasExpression() )
-            m_xml.endElement();
-
-        return true;
-    }
-
-    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
-        StreamingReporterBase::sectionEnded( sectionStats );
-        if( --m_sectionDepth > 0 ) {
-            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
-            e.writeAttribute( "successes", sectionStats.assertions.passed );
-            e.writeAttribute( "failures", sectionStats.assertions.failed );
-            e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
-
-            if ( m_config->showDurations() == ShowDurations::Always )
-                e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
-
-            m_xml.endElement();
-        }
-    }
-
-    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        StreamingReporterBase::testCaseEnded( testCaseStats );
-        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
-        e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
-
-        if ( m_config->showDurations() == ShowDurations::Always )
-            e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
-
-        if( !testCaseStats.stdOut.empty() )
-            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
-        if( !testCaseStats.stdErr.empty() )
-            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
-
-        m_xml.endElement();
-    }
-
-    void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        StreamingReporterBase::testGroupEnded( testGroupStats );
-        // TODO: Check testGroupStats.aborting and act accordingly.
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
-            .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
-        m_xml.endElement();
-    }
-
-    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        StreamingReporterBase::testRunEnded( testRunStats );
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes", testRunStats.totals.assertions.passed )
-            .writeAttribute( "failures", testRunStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
-        m_xml.endElement();
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void XmlReporter::benchmarkPreparing(std::string const& name) {
-        m_xml.startElement("BenchmarkResults")
-            .writeAttribute("name", name);
-    }
-
-    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
-        m_xml.writeAttribute("samples", info.samples)
-            .writeAttribute("resamples", info.resamples)
-            .writeAttribute("iterations", info.iterations)
-            .writeAttribute("clockResolution", info.clockResolution)
-            .writeAttribute("estimatedDuration", info.estimatedDuration)
-            .writeComment("All values in nano seconds");
-    }
-
-    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
-        m_xml.startElement("mean")
-            .writeAttribute("value", benchmarkStats.mean.point.count())
-            .writeAttribute("lowerBound", benchmarkStats.mean.lower_bound.count())
-            .writeAttribute("upperBound", benchmarkStats.mean.upper_bound.count())
-            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
-        m_xml.endElement();
-        m_xml.startElement("standardDeviation")
-            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
-            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
-            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
-            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
-        m_xml.endElement();
-        m_xml.startElement("outliers")
-            .writeAttribute("variance", benchmarkStats.outlierVariance)
-            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
-            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
-            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
-            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
-        m_xml.endElement();
-        m_xml.endElement();
-    }
-
-    void XmlReporter::benchmarkFailed(std::string const &error) {
-        m_xml.scopedElement("failed").
-            writeAttribute("message", error);
-        m_xml.endElement();
-    }
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    CATCH_REGISTER_REPORTER( "xml", XmlReporter )
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-// end catch_reporter_xml.cpp
-
-namespace Catch {
-    LeakDetector leakDetector;
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_impl.hpp
-#endif
-
-#ifdef CATCH_CONFIG_MAIN
-// start catch_default_main.hpp
-
-#ifndef __OBJC__
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
-// Standard C/C++ Win32 Unicode wmain entry point
-extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
-#else
-// Standard C/C++ main entry point
-int main (int argc, char * argv[]) {
-#endif
-
-    return Catch::Session().run( argc, argv );
-}
-
-#else // __OBJC__
-
-// Objective-C entry point
-int main (int argc, char * const argv[]) {
-#if !CATCH_ARC_ENABLED
-    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
-#endif
-
-    Catch::registerTestMethods();
-    int result = Catch::Session().run( argc, (char**)argv );
-
-#if !CATCH_ARC_ENABLED
-    [pool drain];
-#endif
-
-    return result;
-}
-
-#endif // __OBJC__
-
-// end catch_default_main.hpp
-#endif
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-
-#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
-#  undef CLARA_CONFIG_MAIN
-#endif
-
-#if !defined(CATCH_CONFIG_DISABLE)
-//////
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
-#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
-#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#endif
-
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
-#else
-#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define CATCH_BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define CATCH_BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
-#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
-#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
-#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
-
-#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#endif
-
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
-#else
-#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
-
-// "BDD-style" convenience wrappers
-#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-
-#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-using Catch::Detail::Approx;
-
-#else // CATCH_CONFIG_DISABLE
-
-//////
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( ... )        (void)(0)
-#define CATCH_REQUIRE_FALSE( ... )  (void)(0)
-
-#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CATCH_CHECK( ... )         (void)(0)
-#define CATCH_CHECK_FALSE( ... )   (void)(0)
-#define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
-#define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
-#define CATCH_CHECK_NOFAIL( ... )  (void)(0)
-
-#define CATCH_CHECK_THROWS( ... )  (void)(0)
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_CHECK_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
-
-#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define CATCH_INFO( msg )          (void)(0)
-#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
-#define CATCH_WARN( msg )          (void)(0)
-#define CATCH_CAPTURE( msg )       (void)(0)
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_METHOD_AS_TEST_CASE( method, ... )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define CATCH_SECTION( ... )
-#define CATCH_DYNAMIC_SECTION( ... )
-#define CATCH_FAIL( ... ) (void)(0)
-#define CATCH_FAIL_CHECK( ... ) (void)(0)
-#define CATCH_SUCCEED( ... ) (void)(0)
-
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-#define CATCH_GIVEN( desc )
-#define CATCH_AND_GIVEN( desc )
-#define CATCH_WHEN( desc )
-#define CATCH_AND_WHEN( desc )
-#define CATCH_THEN( desc )
-#define CATCH_AND_THEN( desc )
-
-#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( ... )       (void)(0)
-#define REQUIRE_FALSE( ... ) (void)(0)
-
-#define REQUIRE_THROWS( ... ) (void)(0)
-#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CHECK( ... ) (void)(0)
-#define CHECK_FALSE( ... ) (void)(0)
-#define CHECKED_IF( ... ) if (__VA_ARGS__)
-#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
-#define CHECK_NOFAIL( ... ) (void)(0)
-
-#define CHECK_THROWS( ... )  (void)(0)
-#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) (void)(0)
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) (void)(0)
-
-#define REQUIRE_THAT( arg, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define INFO( msg ) (void)(0)
-#define UNSCOPED_INFO( msg ) (void)(0)
-#define WARN( msg ) (void)(0)
-#define CAPTURE( msg ) (void)(0)
-
-#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define METHOD_AS_TEST_CASE( method, ... )
-#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define SECTION( ... )
-#define DYNAMIC_SECTION( ... )
-#define FAIL( ... ) (void)(0)
-#define FAIL_CHECK( ... ) (void)(0)
-#define SUCCEED( ... ) (void)(0)
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-#define STATIC_REQUIRE( ... )       (void)(0)
-#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// "BDD-style" convenience wrappers
-#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-
-#define GIVEN( desc )
-#define AND_GIVEN( desc )
-#define WHEN( desc )
-#define AND_WHEN( desc )
-#define THEN( desc )
-#define AND_THEN( desc )
-
-using Catch::Detail::Approx;
-
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
-// start catch_reenable_warnings.h
-
-
-#ifdef __clang__
-#    ifdef __ICC // icpc defines the __clang__ macro
-#        pragma warning(pop)
-#    else
-#        pragma clang diagnostic pop
-#    endif
-#elif defined __GNUC__
-#    pragma GCC diagnostic pop
-#endif
-
-// end catch_reenable_warnings.h
-// end catch.hpp
-#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-
diff --git a/unittest/catch2/catch_reporter_automake.hpp b/unittest/catch2/catch_reporter_automake.hpp
deleted file mode 100644
index dbebe9751..000000000
--- a/unittest/catch2/catch_reporter_automake.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- *  Created by Justin R. Wilson on 2/19/2017.
- *  Copyright 2017 Justin R. Wilson. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-namespace Catch {
-
-    struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
-        AutomakeReporter( ReporterConfig const& _config )
-          :   StreamingReporterBase( _config )
-        {}
-
-        ~AutomakeReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in the format of Automake .trs files";
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
-
-        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
-            // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
-            stream << ":test-result: ";
-            if (_testCaseStats.totals.assertions.allPassed()) {
-                stream << "PASS";
-            } else if (_testCaseStats.totals.assertions.allOk()) {
-                stream << "XFAIL";
-            } else {
-                stream << "FAIL";
-            }
-            stream << ' ' << _testCaseStats.testInfo.name << '\n';
-            StreamingReporterBase::testCaseEnded( _testCaseStats );
-        }
-
-        void skipTest( TestCaseInfo const& testInfo ) override {
-            stream << ":test-result: SKIP " << testInfo.name << '\n';
-        }
-
-    };
-
-#ifdef CATCH_IMPL
-    AutomakeReporter::~AutomakeReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
diff --git a/unittest/catch2/catch_reporter_sonarqube.hpp b/unittest/catch2/catch_reporter_sonarqube.hpp
deleted file mode 100644
index bf7d9299a..000000000
--- a/unittest/catch2/catch_reporter_sonarqube.hpp
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- *  Created by Daniel Garcia on 2018-12-04.
- *  Copyright Social Point SL. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
-#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
-
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <map>
-
-namespace Catch {
-
-    struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
-
-        SonarQubeReporter(ReporterConfig const& config)
-        : CumulativeReporterBase(config)
-        , xml(config.stream()) {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-            m_reporterPrefs.shouldReportAllAssertions = true;
-        }
-
-        ~SonarQubeReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in the Generic Test Data SonarQube XML format";
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        void noMatchingTestCases(std::string const& /*spec*/) override {}
-
-        void testRunStarting(TestRunInfo const& testRunInfo) override {
-            CumulativeReporterBase::testRunStarting(testRunInfo);
-            xml.startElement("testExecutions");
-            xml.writeAttribute("version", "1");
-        }
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            CumulativeReporterBase::testGroupEnded(testGroupStats);
-            writeGroup(*m_testGroups.back());
-        }
-
-        void testRunEndedCumulative() override {
-            xml.endElement();
-        }
-
-        void writeGroup(TestGroupNode const& groupNode) {
-            std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
-            for(auto const& child : groupNode.children)
-                testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
-
-            for(auto const& kv : testsPerFile)
-                writeTestFile(kv.first.c_str(), kv.second);
-        }
-
-        void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
-            XmlWriter::ScopedElement e = xml.scopedElement("file");
-            xml.writeAttribute("path", filename);
-
-            for(auto const& child : testCaseNodes)
-                writeTestCase(*child);
-        }
-
-        void writeTestCase(TestCaseNode const& testCaseNode) {
-            // All test cases have exactly one section - which represents the
-            // test case itself. That section may have 0-n nested sections
-            assert(testCaseNode.children.size() == 1);
-            SectionNode const& rootSection = *testCaseNode.children.front();
-            writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
-        }
-
-        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
-            std::string name = trim(sectionNode.stats.sectionInfo.name);
-            if(!rootName.empty())
-                name = rootName + '/' + name;
-
-            if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
-                XmlWriter::ScopedElement e = xml.scopedElement("testCase");
-                xml.writeAttribute("name", name);
-                xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
-
-                writeAssertions(sectionNode, okToFail);
-            }
-
-            for(auto const& childNode : sectionNode.childSections)
-                writeSection(name, *childNode, okToFail);
-        }
-
-        void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
-            for(auto const& assertion : sectionNode.assertions)
-                writeAssertion( assertion, okToFail);
-        }
-
-        void writeAssertion(AssertionStats const& stats, bool okToFail) {
-            AssertionResult const& result = stats.assertionResult;
-            if(!result.isOk()) {
-                std::string elementName;
-                if(okToFail) {
-                    elementName = "skipped";
-                }
-                else {
-                    switch(result.getResultType()) {
-                        case ResultWas::ThrewException:
-                        case ResultWas::FatalErrorCondition:
-                            elementName = "error";
-                            break;
-                        case ResultWas::ExplicitFailure:
-                            elementName = "failure";
-                            break;
-                        case ResultWas::ExpressionFailed:
-                            elementName = "failure";
-                            break;
-                        case ResultWas::DidntThrowException:
-                            elementName = "failure";
-                            break;
-
-                            // We should never see these here:
-                        case ResultWas::Info:
-                        case ResultWas::Warning:
-                        case ResultWas::Ok:
-                        case ResultWas::Unknown:
-                        case ResultWas::FailureBit:
-                        case ResultWas::Exception:
-                            elementName = "internalError";
-                            break;
-                    }
-                }
-
-                XmlWriter::ScopedElement e = xml.scopedElement(elementName);
-
-                ReusableStringStream messageRss;
-                messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
-                xml.writeAttribute("message", messageRss.str());
-
-                ReusableStringStream textRss;
-                if (stats.totals.assertions.total() > 0) {
-                    textRss << "FAILED:\n";
-                    if (result.hasExpression()) {
-                        textRss << "\t" << result.getExpressionInMacro() << "\n";
-                    }
-                    if (result.hasExpandedExpression()) {
-                        textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
-                    }
-                }
-
-                if(!result.getMessage().empty())
-                    textRss << result.getMessage() << "\n";
-
-                for(auto const& msg : stats.infoMessages)
-                    if(msg.type == ResultWas::Info)
-                        textRss << msg.message << "\n";
-
-                textRss << "at " << result.getSourceInfo();
-                xml.writeText(textRss.str(), XmlFormatting::Newline);
-            }
-        }
-
-    private:
-        XmlWriter xml;
-    };
-
-#ifdef CATCH_IMPL
-    SonarQubeReporter::~SonarQubeReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
\ No newline at end of file
diff --git a/unittest/catch2/catch_reporter_tap.hpp b/unittest/catch2/catch_reporter_tap.hpp
deleted file mode 100644
index 1bfe4f5e1..000000000
--- a/unittest/catch2/catch_reporter_tap.hpp
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- *  Created by Colton Wolkins on 2015-08-15.
- *  Copyright 2015 Martin Moene. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
-
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <algorithm>
-
-namespace Catch {
-
-    struct TAPReporter : StreamingReporterBase<TAPReporter> {
-
-        using StreamingReporterBase::StreamingReporterBase;
-
-        ~TAPReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in TAP format, suitable for test harnesses";
-        }
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        void noMatchingTestCases( std::string const& spec ) override {
-            stream << "# No test cases matched '" << spec << "'" << std::endl;
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& _assertionStats ) override {
-            ++counter;
-
-            stream << "# " << currentTestCaseInfo->name << std::endl;
-            AssertionPrinter printer( stream, _assertionStats, counter );
-            printer.print();
-
-            stream << std::endl;
-            return true;
-        }
-
-        void testRunEnded( TestRunStats const& _testRunStats ) override {
-            printTotals( _testRunStats.totals );
-            stream << "\n" << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-    private:
-        std::size_t counter = 0;
-        class AssertionPrinter {
-        public:
-            AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
-            AssertionPrinter( AssertionPrinter const& ) = delete;
-            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
-            : stream( _stream )
-            , result( _stats.assertionResult )
-            , messages( _stats.infoMessages )
-            , itMessage( _stats.infoMessages.begin() )
-            , printInfoMessages( true )
-            , counter(_counter)
-            {}
-
-            void print() {
-                itMessage = messages.begin();
-
-                switch( result.getResultType() ) {
-                    case ResultWas::Ok:
-                        printResultType( passedString() );
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if ( ! result.hasExpression() )
-                            printRemainingMessages( Colour::None );
-                        else
-                            printRemainingMessages();
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        if (result.isOk()) {
-                            printResultType(passedString());
-                        } else {
-                            printResultType(failedString());
-                        }
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if (result.isOk()) {
-                            printIssue(" # TODO");
-                        }
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ThrewException:
-                        printResultType( failedString() );
-                        printIssue( "unexpected exception with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        printResultType( failedString() );
-                        printIssue( "fatal error condition with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::DidntThrowException:
-                        printResultType( failedString() );
-                        printIssue( "expected exception, got none" );
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Info:
-                        printResultType( "info" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Warning:
-                        printResultType( "warning" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        printResultType( failedString() );
-                        printIssue( "explicitly" );
-                        printRemainingMessages( Colour::None );
-                        break;
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        printResultType( "** internal error **" );
-                        break;
-                }
-            }
-
-        private:
-            static Colour::Code dimColour() { return Colour::FileName; }
-
-            static const char* failedString() { return "not ok"; }
-            static const char* passedString() { return "ok"; }
-
-            void printSourceInfo() const {
-                Colour colourGuard( dimColour() );
-                stream << result.getSourceInfo() << ":";
-            }
-
-            void printResultType( std::string const& passOrFail ) const {
-                if( !passOrFail.empty() ) {
-                    stream << passOrFail << ' ' << counter << " -";
-                }
-            }
-
-            void printIssue( std::string const& issue ) const {
-                stream << " " << issue;
-            }
-
-            void printExpressionWas() {
-                if( result.hasExpression() ) {
-                    stream << ";";
-                    {
-                        Colour colour( dimColour() );
-                        stream << " expression was:";
-                    }
-                    printOriginalExpression();
-                }
-            }
-
-            void printOriginalExpression() const {
-                if( result.hasExpression() ) {
-                    stream << " " << result.getExpression();
-                }
-            }
-
-            void printReconstructedExpression() const {
-                if( result.hasExpandedExpression() ) {
-                    {
-                        Colour colour( dimColour() );
-                        stream << " for: ";
-                    }
-                    std::string expr = result.getExpandedExpression();
-                    std::replace( expr.begin(), expr.end(), '\n', ' ');
-                    stream << expr;
-                }
-            }
-
-            void printMessage() {
-                if ( itMessage != messages.end() ) {
-                    stream << " '" << itMessage->message << "'";
-                    ++itMessage;
-                }
-            }
-
-            void printRemainingMessages( Colour::Code colour = dimColour() ) {
-                if (itMessage == messages.end()) {
-                    return;
-                }
-
-                // using messages.end() directly (or auto) yields compilation error:
-                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
-                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
-
-                {
-                    Colour colourGuard( colour );
-                    stream << " with " << pluralise( N, "message" ) << ":";
-                }
-
-                for(; itMessage != itEnd; ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
-                        stream << " '" << itMessage->message << "'";
-                        if ( ++itMessage != itEnd ) {
-                            Colour colourGuard( dimColour() );
-                            stream << " and";
-                        }
-                    }
-                }
-            }
-
-        private:
-            std::ostream& stream;
-            AssertionResult const& result;
-            std::vector<MessageInfo> messages;
-            std::vector<MessageInfo>::const_iterator itMessage;
-            bool printInfoMessages;
-            std::size_t counter;
-        };
-
-        void printTotals( const Totals& totals ) const {
-            if( totals.testCases.total() == 0 ) {
-                stream << "1..0 # Skipped: No tests ran.";
-            } else {
-                stream << "1.." << counter;
-            }
-        }
-    };
-
-#ifdef CATCH_IMPL
-    TAPReporter::~TAPReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "tap", TAPReporter )
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
diff --git a/unittest/catch2/catch_reporter_teamcity.hpp b/unittest/catch2/catch_reporter_teamcity.hpp
deleted file mode 100644
index 47b7e4aac..000000000
--- a/unittest/catch2/catch_reporter_teamcity.hpp
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
- *  Created by Phil Nash on 19th December 2014
- *  Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <cstring>
-
-#ifdef __clang__
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
-        TeamCityReporter( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-        }
-
-        static std::string escape( std::string const& str ) {
-            std::string escaped = str;
-            replaceInPlace( escaped, "|", "||" );
-            replaceInPlace( escaped, "'", "|'" );
-            replaceInPlace( escaped, "\n", "|n" );
-            replaceInPlace( escaped, "\r", "|r" );
-            replaceInPlace( escaped, "[", "|[" );
-            replaceInPlace( escaped, "]", "|]" );
-            return escaped;
-        }
-        ~TeamCityReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results as TeamCity service messages";
-        }
-
-        void skipTest( TestCaseInfo const& /* testInfo */ ) override {
-        }
-
-        void noMatchingTestCases( std::string const& /* spec */ ) override {}
-
-        void testGroupStarting( GroupInfo const& groupInfo ) override {
-            StreamingReporterBase::testGroupStarting( groupInfo );
-            stream << "##teamcity[testSuiteStarted name='"
-                << escape( groupInfo.name ) << "']\n";
-        }
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
-            StreamingReporterBase::testGroupEnded( testGroupStats );
-            stream << "##teamcity[testSuiteFinished name='"
-                << escape( testGroupStats.groupInfo.name ) << "']\n";
-        }
-
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& assertionStats ) override {
-            AssertionResult const& result = assertionStats.assertionResult;
-            if( !result.isOk() ) {
-
-                ReusableStringStream msg;
-                if( !m_headerPrintedForThisSection )
-                    printSectionHeader( msg.get() );
-                m_headerPrintedForThisSection = true;
-
-                msg << result.getSourceInfo() << "\n";
-
-                switch( result.getResultType() ) {
-                    case ResultWas::ExpressionFailed:
-                        msg << "expression failed";
-                        break;
-                    case ResultWas::ThrewException:
-                        msg << "unexpected exception";
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        msg << "fatal error condition";
-                        break;
-                    case ResultWas::DidntThrowException:
-                        msg << "no exception was thrown where one was expected";
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        msg << "explicit failure";
-                        break;
-
-                    // We shouldn't get here because of the isOk() test
-                    case ResultWas::Ok:
-                    case ResultWas::Info:
-                    case ResultWas::Warning:
-                        CATCH_ERROR( "Internal error in TeamCity reporter" );
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        CATCH_ERROR( "Not implemented" );
-                }
-                if( assertionStats.infoMessages.size() == 1 )
-                    msg << " with message:";
-                if( assertionStats.infoMessages.size() > 1 )
-                    msg << " with messages:";
-                for( auto const& messageInfo : assertionStats.infoMessages )
-                    msg << "\n  \"" << messageInfo.message << "\"";
-
-
-                if( result.hasExpression() ) {
-                    msg <<
-                        "\n  " << result.getExpressionInMacro() << "\n"
-                        "with expansion:\n" <<
-                        "  " << result.getExpandedExpression() << "\n";
-                }
-
-                if( currentTestCaseInfo->okToFail() ) {
-                    msg << "- failure ignore as test marked as 'ok to fail'\n";
-                    stream << "##teamcity[testIgnored"
-                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
-                           << " message='" << escape( msg.str() ) << "'"
-                           << "]\n";
-                }
-                else {
-                    stream << "##teamcity[testFailed"
-                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
-                           << " message='" << escape( msg.str() ) << "'"
-                           << "]\n";
-                }
-            }
-            stream.flush();
-            return true;
-        }
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            m_headerPrintedForThisSection = false;
-            StreamingReporterBase::sectionStarting( sectionInfo );
-        }
-
-        void testCaseStarting( TestCaseInfo const& testInfo ) override {
-            m_testTimer.start();
-            StreamingReporterBase::testCaseStarting( testInfo );
-            stream << "##teamcity[testStarted name='"
-                << escape( testInfo.name ) << "']\n";
-            stream.flush();
-        }
-
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
-            StreamingReporterBase::testCaseEnded( testCaseStats );
-            if( !testCaseStats.stdOut.empty() )
-                stream << "##teamcity[testStdOut name='"
-                    << escape( testCaseStats.testInfo.name )
-                    << "' out='" << escape( testCaseStats.stdOut ) << "']\n";
-            if( !testCaseStats.stdErr.empty() )
-                stream << "##teamcity[testStdErr name='"
-                    << escape( testCaseStats.testInfo.name )
-                    << "' out='" << escape( testCaseStats.stdErr ) << "']\n";
-            stream << "##teamcity[testFinished name='"
-                    << escape( testCaseStats.testInfo.name ) << "' duration='"
-                    << m_testTimer.getElapsedMilliseconds() << "']\n";
-            stream.flush();
-        }
-
-    private:
-        void printSectionHeader( std::ostream& os ) {
-            assert( !m_sectionStack.empty() );
-
-            if( m_sectionStack.size() > 1 ) {
-                os << getLineOfChars<'-'>() << "\n";
-
-                std::vector<SectionInfo>::const_iterator
-                it = m_sectionStack.begin()+1, // Skip first section (test case)
-                itEnd = m_sectionStack.end();
-                for( ; it != itEnd; ++it )
-                    printHeaderString( os, it->name );
-                os << getLineOfChars<'-'>() << "\n";
-            }
-
-            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
-
-            os << lineInfo << "\n";
-            os << getLineOfChars<'.'>() << "\n\n";
-        }
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        static void printHeaderString( std::ostream& os, std::string const& _string, std::size_t indent = 0 ) {
-            std::size_t i = _string.find( ": " );
-            if( i != std::string::npos )
-                i+=2;
-            else
-                i = 0;
-            os << Column( _string )
-                           .indent( indent+i)
-                           .initialIndent( indent ) << "\n";
-        }
-    private:
-        bool m_headerPrintedForThisSection = false;
-        Timer m_testTimer;
-    };
-
-#ifdef CATCH_IMPL
-    TeamCityReporter::~TeamCityReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
-
-} // end namespace Catch
-
-#ifdef __clang__
-#   pragma clang diagnostic pop
-#endif
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED

From 82ccd146927f80e154e430ab5ce13b966a596263 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 21:25:11 +0100
Subject: [PATCH 0953/1774] added new tests

---
 unittest/tests/storagemanager/TestPool.cpp | 243 ++++++++++++++++++---
 1 file changed, 217 insertions(+), 26 deletions(-)

diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
index 5b22118e4..3f5341e99 100644
--- a/unittest/tests/storagemanager/TestPool.cpp
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -1,20 +1,26 @@
+#include "CatchDefinitions.h"
+
 #include <config/objects/Factory.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/storagemanager/LocalPool.h>
-#include <catch2/catch.hpp>
-#include "core/CatchDefinitions.h"
+
+#include <catch.hpp>
+#include <CatchDefinitions.h>
+
+#include <cstring>
+
 
 TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
-	uint16_t numberOfElements[1] = {1};
-	uint16_t sizeofElements[1] = {10};
-	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
+//	uint16_t numberOfElements[1] = {1};
+//	uint16_t sizeofElements[1] = {10};
+	LocalPool::LocalPoolConfig config = {{1, 10}};
+	LocalPool simplePool(0, config);
 	std::array<uint8_t, 20> testDataArray;
 	std::array<uint8_t, 20> receptionArray;
 	store_address_t testStoreId;
 	ReturnValue_t result = retval::CATCH_FAILED;
 	uint8_t *pointer = nullptr;
 	const uint8_t * constPointer = nullptr;
-	uint8_t test = 0;
 
 	for(size_t i = 0; i < testDataArray.size(); i++) {
 		testDataArray[i] = i;
@@ -22,34 +28,34 @@ TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
 	size_t size = 10;
 
 	SECTION ( "Basic tests") {
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
 		REQUIRE(result == retval::CATCH_OK);
-		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		result = simplePool.getData(testStoreId, &constPointer, &size);
 		REQUIRE(result == retval::CATCH_OK);
 		memcpy(receptionArray.data(), constPointer, size);
 		for(size_t i = 0; i < size; i++) {
 			CHECK(receptionArray[i] == i );
 		}
 		memset(receptionArray.data(), 0, size);
-		result = SimplePool.modifyData(testStoreId, &pointer, &size);
+		result = simplePool.modifyData(testStoreId, &pointer, &size);
 		memcpy(receptionArray.data(), pointer, size);
 		REQUIRE(result == retval::CATCH_OK);
 		for(size_t i = 0; i < size; i++) {
 			CHECK(receptionArray[i] == i );
 		}
-		result = SimplePool.deleteData(testStoreId);
+		result = simplePool.deleteData(testStoreId);
 		REQUIRE(result == retval::CATCH_OK);
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), 15);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), 15);
 		CHECK (result == (int) StorageManagerIF::DATA_TOO_LARGE);
 	}
 
 	SECTION ( "Reservation Tests ") {
 		pointer = nullptr;
-		result = SimplePool.getFreeElement(&testStoreId, size, &pointer);
+		result = simplePool.getFreeElement(&testStoreId, size, &pointer);
 		REQUIRE (result == retval::CATCH_OK);
 		memcpy(pointer, testDataArray.data(), size);
 		constPointer = nullptr;
-		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		result = simplePool.getData(testStoreId, &constPointer, &size);
 
 		REQUIRE (result == retval::CATCH_OK);
 		memcpy(receptionArray.data(), constPointer, size);
@@ -59,21 +65,21 @@ TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
 	}
 
 	SECTION ( "Add, delete, add, add when full") {
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
 		REQUIRE(result == retval::CATCH_OK);
-		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		result = simplePool.getData(testStoreId, &constPointer, &size);
 		REQUIRE( result == retval::CATCH_OK);
 		memcpy(receptionArray.data(), constPointer, size);
 		for(size_t i = 0; i < size; i++) {
 			CHECK(receptionArray[i] == i );
 		}
 
-		result = SimplePool.deleteData(testStoreId);
+		result = simplePool.deleteData(testStoreId);
 		REQUIRE(result == retval::CATCH_OK);
 
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
 		REQUIRE(result == retval::CATCH_OK);
-		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		result = simplePool.getData(testStoreId, &constPointer, &size);
 		REQUIRE( result == retval::CATCH_OK);
 		memcpy(receptionArray.data(), constPointer, size);
 		for(size_t i = 0; i < size; i++) {
@@ -81,25 +87,210 @@ TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
 		}
 
 		store_address_t newAddress;
-		result = SimplePool.addData(&newAddress, testDataArray.data(), size);
+		result = simplePool.addData(&newAddress, testDataArray.data(), size);
 		REQUIRE(result == (int) StorageManagerIF::DATA_STORAGE_FULL);
+
+		// Packet Index to high intentionally
+		newAddress.packetIndex = 2;
+		pointer = testDataArray.data();
+		result = simplePool.modifyData(newAddress, &pointer, &size);
+		REQUIRE(result == (int) StorageManagerIF::ILLEGAL_STORAGE_ID);
+
+		result = simplePool.deleteData(newAddress);
+		REQUIRE(result == (int) StorageManagerIF::ILLEGAL_STORAGE_ID);
+
+		newAddress.packetIndex = 0;
+		newAddress.poolIndex = 2;
+		result = simplePool.deleteData(newAddress);
+		REQUIRE(result == (int) StorageManagerIF::ILLEGAL_STORAGE_ID);
 	}
 
 	SECTION ( "Initialize and clear store, delete with pointer") {
-		result = SimplePool.initialize();
+		result = simplePool.initialize();
 		REQUIRE(result == retval::CATCH_OK);
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
 		REQUIRE(result == retval::CATCH_OK);
-		SimplePool.clearStore();
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		simplePool.clearStore();
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
 		REQUIRE(result == retval::CATCH_OK);
-		result = SimplePool.modifyData(testStoreId, &pointer, &size);
+		result = simplePool.modifyData(testStoreId, &pointer, &size);
 		REQUIRE(result == retval::CATCH_OK);
 		store_address_t newId;
-		result = SimplePool.deleteData(pointer, size, &testStoreId);
+		result = simplePool.deleteData(pointer, size, &testStoreId);
 		REQUIRE(result == retval::CATCH_OK);
 		REQUIRE(testStoreId.raw != (uint32_t) StorageManagerIF::INVALID_ADDRESS);
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
 		REQUIRE(result == retval::CATCH_OK);
 	}
 }
+
+int runIdx = 0;
+
+TEST_CASE( "Local Pool Extended Tests [3 Pools]" , "[TestPool2]") {
+	LocalPool::LocalPoolConfig* config;
+	if(runIdx == 0) {
+		config = new LocalPool::LocalPoolConfig{{10, 5}, {5, 10}, {2, 20}};
+	}
+	else {
+		// shufle the order, they should be sort implictely so that the
+		// order is ascending for the page sizes.
+		config = new LocalPool::LocalPoolConfig{{5, 10}, {2, 20}, {10, 5}};
+		size_t lastSize = 0;
+		for(const auto& pair: *config) {
+			CHECK(pair.second > lastSize);
+			lastSize = pair.second;
+		}
+	}
+	runIdx++;
+
+	LocalPool simplePool(0, *config);
+	std::array<uint8_t, 20> testDataArray;
+	std::array<uint8_t, 20> receptionArray;
+	store_address_t testStoreId;
+	ReturnValue_t result = retval::CATCH_FAILED;
+	for(size_t i = 0; i < testDataArray.size(); i++) {
+		testDataArray[i] = i;
+	}
+	size_t size = 0;
+
+	SECTION ("Basic tests") {
+		size = 8;
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		// Should be on second page of the pool now for 8 bytes
+		CHECK(testStoreId.poolIndex == 1);
+		CHECK(testStoreId.packetIndex == 0);
+
+		size = 15;
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		// Should be on third page of the pool now for 15 bytes
+		CHECK(testStoreId.poolIndex == 2);
+		CHECK(testStoreId.packetIndex == 0);
+
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		// Should be on third page of the pool now for 15 bytes
+		CHECK(testStoreId.poolIndex == 2);
+		CHECK(testStoreId.packetIndex == 1);
+
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		// Should be on third page of the pool now for 15 bytes
+		REQUIRE(result == (int) LocalPool::DATA_STORAGE_FULL);
+
+		size = 8;
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		// Should still work
+		CHECK(testStoreId.poolIndex == 1);
+		CHECK(testStoreId.packetIndex == 1);
+
+		// fill the rest of the pool
+		for(uint8_t idx = 2; idx < 5; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 1);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+	}
+
+	SECTION ("Fill Count and Clearing") {
+		//SECTION("Basic tests");
+		uint8_t bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// fill count should be all zeros now.
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 0);
+		CHECK(receptionArray[1] == 0);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 0);
+
+		// now fill the store completely.
+		size = 5;
+		for(uint8_t idx = 0; idx < 10; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 0);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		size = 10;
+		for(uint8_t idx = 0; idx < 5; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 1);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		size = 20;
+		for(uint8_t idx = 0; idx < 2; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 2);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// fill count should be all 100 now.
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 100);
+		CHECK(receptionArray[1] == 100);
+		CHECK(receptionArray[2] == 100);
+		CHECK(receptionArray[3] == 100);
+
+		// now clear the store
+		simplePool.clearStore();
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 0);
+		CHECK(receptionArray[1] == 0);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 0);
+
+		// now fill one page
+		size = 5;
+		for(uint8_t idx = 0; idx < 10; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 0);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// First page full, median fill count is 33 %
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 100);
+		CHECK(receptionArray[1] == 0);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 33);
+
+		// now fill second page
+		size = 10;
+		for(uint8_t idx = 0; idx < 5; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 1);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// First and second page full, median fill count is 66 %
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 100);
+		CHECK(receptionArray[1] == 100);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 66);
+
+		// now clear first page
+		simplePool.clearPage(0);
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// Second page full, median fill count is 33 %
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 0);
+		CHECK(receptionArray[1] == 100);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 33);
+	}
+
+	delete(config);
+}

From 24cb83498ae4c8a50db33ce6f235913fbe2695bc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 21:28:59 +0100
Subject: [PATCH 0954/1774] include fix

---
 unittest/core/CatchRunner.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/unittest/core/CatchRunner.cpp b/unittest/core/CatchRunner.cpp
index 566db692c..e15c8b2a8 100644
--- a/unittest/core/CatchRunner.cpp
+++ b/unittest/core/CatchRunner.cpp
@@ -9,7 +9,7 @@
 #ifndef NO_UNIT_TEST_FRAMEWORK
 
 #define CATCH_CONFIG_RUNNER
-#include <fsfw/unittest/catch2/catch.hpp>
+#include <catch2/catch.hpp>
 
 extern int customSetup();
 

From 6325eb764717af8470715cb34934c2e7e0953f0d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 22:11:13 +0100
Subject: [PATCH 0955/1774] include fixes

---
 unittest/core/CatchSetup.cpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index 5436fd5df..ca5c456da 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,24 +1,24 @@
+#include "CatchDefinitions.h"
 #include "../config/cdatapool/dataPoolInit.h"
-#include <fsfw/unittest/config/cdatapool/dataPoolInit.h>
-#include <fsfw/unittest/config/objects/Factory.h>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include "../config/objects/Factory.h"
+
 
 #ifdef GCOV
 #include <gcov.h>
 #endif
 
-#include <fsfw/objectmanager/ObjectManager.h>
-#include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/storagemanager/StorageManagerIF.h>
-#include <fsfw/datapool/DataPool.h>
-#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include "../../objectmanager/ObjectManager.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../datapoolglob/GlobalDataPool.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
 
 
 /* Global instantiations normally done in main.cpp */
 /* Initialize Data Pool */
-//namespace glob {
-DataPool dataPool(datapool::dataPoolInit);
-//}
+namespace glob {
+GlobalDataPool dataPool(datapool::dataPoolInit);
+}
 
 
 namespace sif {

From b860d8bce788c3f530282721d63fea3995e7a376 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 22:34:41 +0100
Subject: [PATCH 0956/1774] include fixes

---
 unittest/config/cdatapool/dataPoolInit.cpp    |   2 +-
 unittest/config/cdatapool/dataPoolInit.h      |   2 +-
 unittest/config/objects/Factory.cpp           |   5 +-
 unittest/tests/action/TestActionHelper.cpp    | 211 ++++++------
 unittest/tests/action/TestActionHelper.h      | 262 +++++++-------
 unittest/tests/container/RingBufferTest.cpp   |   4 +-
 unittest/tests/container/TestArrayList.cpp    |   4 +-
 unittest/tests/container/TestFifo.cpp         |   4 +-
 .../tests/container/TestFixedArrayList.cpp    |   5 +-
 unittest/tests/container/TestFixedMap.cpp     |   4 +-
 .../container/TestFixedOrderedMultimap.cpp    |   4 +-
 .../tests/container/TestPlacementFactory.cpp  |  90 ++---
 .../serialize/TestSerialBufferAdapter.cpp     |   4 +-
 .../serialize/TestSerialLinkedPacket.cpp      |   6 +-
 .../tests/serialize/TestSerialization.cpp     |   2 +-
 .../tests/storagemanager/TestNewAccessor.cpp  | 322 +++++++++---------
 16 files changed, 465 insertions(+), 466 deletions(-)

diff --git a/unittest/config/cdatapool/dataPoolInit.cpp b/unittest/config/cdatapool/dataPoolInit.cpp
index 6c2278abf..f24d6cc54 100644
--- a/unittest/config/cdatapool/dataPoolInit.cpp
+++ b/unittest/config/cdatapool/dataPoolInit.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/unittest/config/cdatapool/dataPoolInit.h>
+#include "dataPoolInit.h"
 
 void datapool::dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap) {
 	uint8_t UINT8T_INIT[1] = {0};
diff --git a/unittest/config/cdatapool/dataPoolInit.h b/unittest/config/cdatapool/dataPoolInit.h
index d482cc358..6fd32371a 100644
--- a/unittest/config/cdatapool/dataPoolInit.h
+++ b/unittest/config/cdatapool/dataPoolInit.h
@@ -1,7 +1,7 @@
 #ifndef HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
 #define HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
 
-#include <fsfw/datapool/DataPool.h>
+#include <fsfw/datapoolglob/GlobalDataPool.h>
 #include <fsfw/datapool/PoolEntryIF.h>
 #include <map>
 #include <cstdint>
diff --git a/unittest/config/objects/Factory.cpp b/unittest/config/objects/Factory.cpp
index e325b891b..612527c97 100644
--- a/unittest/config/objects/Factory.cpp
+++ b/unittest/config/objects/Factory.cpp
@@ -23,10 +23,7 @@ void Factory::produce(void) {
 	setStaticFrameworkObjectIds();
 	new EventManager(objects::EVENT_MANAGER);
 	new HealthTable(objects::HEALTH_TABLE);
-	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER,
-				datapool::INTERNAL_ERROR_FULL_MSG_QUEUES,
-				datapool::INTERNAL_ERROR_MISSED_LIVE_TM,
-				datapool::INTERNAL_ERROR_STORE_FULL);
+	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
 
 }
 
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index 33c6b4251..d5b2e467b 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -1,105 +1,106 @@
-#include <fsfw/action/ActionHelper.h>
-#include <fsfw/ipc/CommandMessage.h>
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
-#include <fsfw/unittest/tests/action/TestActionHelper.h>
-
-TEST_CASE( "Action Helper" , "[ActionHelper]") {
-	ActionHelperOwnerMockBase testDhMock;
-	MessageQueueMockBase testMqMock;
-	ActionHelper actionHelper = ActionHelper(
-			&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
-	CommandMessage actionMessage;
-	ActionId_t testActionId = 777;
-	std::array <uint8_t, 3> testParams {1, 2, 3};
-	store_address_t paramAddress;
-	StorageManagerIF *ipcStore = tglob::getIpcStoreHandle();
-	ipcStore->addData(&paramAddress, testParams.data(), 3);
-	REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
-
-	SECTION ("Simple tests") {
-		 ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
-		 CHECK(not testDhMock.executeActionCalled);
-		 REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-		 CHECK(testDhMock.executeActionCalled);
-		 // No message is sent if everything is alright.
-		 CHECK(not testMqMock.wasMessageSent());
-		 store_address_t invalidAddress;
-		 ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
-		 actionHelper.handleActionMessage(&actionMessage);
-		 CHECK(testMqMock.wasMessageSent());
-		 const uint8_t* ptr = nullptr;
-		 size_t size = 0;
-		 REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
-		 REQUIRE(ptr == nullptr);
-		 REQUIRE(size == 0);
-		 testDhMock.getBuffer(&ptr, &size);
-		 REQUIRE(size == 3);
-		 for(uint8_t i = 0; i<3;i++){
-			 REQUIRE(ptr[i] == (i+1));
-		 }
-		 testDhMock.clearBuffer();
-	}
-
-	SECTION("Handle failures"){
-		actionMessage.setCommand(1234);
-		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
-		CHECK(not testMqMock.wasMessageSent());
-		uint16_t step = 5;
-		ReturnValue_t status = 0x1234;
-		actionHelper.step(step, testMqMock.getId(), testActionId, status);
-		step += 1;
-		CHECK(testMqMock.wasMessageSent());
-		CommandMessage testMessage;
-		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-		REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
-		uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
-		REQUIRE(testMessage.getParameter2() == parameter2);
-		REQUIRE(ActionMessage::getStep(&testMessage) == step);
-	}
-
-	SECTION("Handle finish"){
-		CHECK(not testMqMock.wasMessageSent());
-		ReturnValue_t status = 0x9876;
-		actionHelper.finish(testMqMock.getId(), testActionId, status);
-		CHECK(testMqMock.wasMessageSent());
-		CommandMessage testMessage;
-		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
-		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
-		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
-	}
-
-	SECTION("Handle failed"){
-		store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
-		std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
-		REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
-		ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
-		CHECK(not testDhMock.executeActionCalled);
-		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-		REQUIRE(ipcStore->getData(toLongParamAddress).first == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
-		CommandMessage testMessage;
-		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-		REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
-		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
-		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
-	}
-
-	SECTION("Missing IPC Data"){
-		ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
-		CHECK(not testDhMock.executeActionCalled);
-		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-		CommandMessage testMessage;
-		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
-		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
-	}
-
-
-	SECTION("Data Reply"){
-
-	}
-}
+//#include "TestActionHelper.h"
+//#include <fsfw/action/ActionHelper.h>
+//#include <fsfw/ipc/CommandMessage.h>
+//#include <catch2/catch.hpp>
+//#include "../../core/CatchDefinitions.h"
+//
+//
+//TEST_CASE( "Action Helper" , "[ActionHelper]") {
+//	ActionHelperOwnerMockBase testDhMock;
+//	MessageQueueMockBase testMqMock;
+//	ActionHelper actionHelper = ActionHelper(
+//			&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
+//	CommandMessage actionMessage;
+//	ActionId_t testActionId = 777;
+//	std::array <uint8_t, 3> testParams {1, 2, 3};
+//	store_address_t paramAddress;
+//	StorageManagerIF *ipcStore = tglob::getIpcStoreHandle();
+//	ipcStore->addData(&paramAddress, testParams.data(), 3);
+//	REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
+//
+//	SECTION ("Simple tests") {
+//		 ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
+//		 CHECK(not testDhMock.executeActionCalled);
+//		 REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+//		 CHECK(testDhMock.executeActionCalled);
+//		 // No message is sent if everything is alright.
+//		 CHECK(not testMqMock.wasMessageSent());
+//		 store_address_t invalidAddress;
+//		 ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
+//		 actionHelper.handleActionMessage(&actionMessage);
+//		 CHECK(testMqMock.wasMessageSent());
+//		 const uint8_t* ptr = nullptr;
+//		 size_t size = 0;
+//		 REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+//		 REQUIRE(ptr == nullptr);
+//		 REQUIRE(size == 0);
+//		 testDhMock.getBuffer(&ptr, &size);
+//		 REQUIRE(size == 3);
+//		 for(uint8_t i = 0; i<3;i++){
+//			 REQUIRE(ptr[i] == (i+1));
+//		 }
+//		 testDhMock.clearBuffer();
+//	}
+//
+//	SECTION("Handle failures"){
+//		actionMessage.setCommand(1234);
+//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
+//		CHECK(not testMqMock.wasMessageSent());
+//		uint16_t step = 5;
+//		ReturnValue_t status = 0x1234;
+//		actionHelper.step(step, testMqMock.getId(), testActionId, status);
+//		step += 1;
+//		CHECK(testMqMock.wasMessageSent());
+//		CommandMessage testMessage;
+//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+//		REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
+//		uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
+//		REQUIRE(testMessage.getParameter2() == parameter2);
+//		REQUIRE(ActionMessage::getStep(&testMessage) == step);
+//	}
+//
+//	SECTION("Handle finish"){
+//		CHECK(not testMqMock.wasMessageSent());
+//		ReturnValue_t status = 0x9876;
+//		actionHelper.finish(testMqMock.getId(), testActionId, status);
+//		CHECK(testMqMock.wasMessageSent());
+//		CommandMessage testMessage;
+//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
+//		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
+//	}
+//
+//	SECTION("Handle failed"){
+//		store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
+//		std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
+//		REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
+//		ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
+//		CHECK(not testDhMock.executeActionCalled);
+//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+//		REQUIRE(ipcStore->getData(toLongParamAddress).first == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+//		CommandMessage testMessage;
+//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
+//		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+//		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+//	}
+//
+//	SECTION("Missing IPC Data"){
+//		ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
+//		CHECK(not testDhMock.executeActionCalled);
+//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+//		CommandMessage testMessage;
+//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
+//		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+//	}
+//
+//
+//	SECTION("Data Reply"){
+//
+//	}
+//}
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
index fcc20f90b..9bc93d3e1 100644
--- a/unittest/tests/action/TestActionHelper.h
+++ b/unittest/tests/action/TestActionHelper.h
@@ -1,131 +1,131 @@
-#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
-#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
-
-#include <fsfw/action/HasActionsIF.h>
-#include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/unittest/core/CatchDefinitions.h>
-#include <cstring>
-
-
-class ActionHelperOwnerMockBase: public HasActionsIF {
-public:
-	bool getCommandQueueCalled = false;
-	bool executeActionCalled = false;
-	static const size_t MAX_SIZE = 3;
-	uint8_t buffer[MAX_SIZE] = {0, 0, 0};
-	size_t size = 0;
-
-	MessageQueueId_t getCommandQueue() const override {
-		return tconst::testQueueId;
-	}
-
-	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-			const uint8_t* data, size_t size) override {
-		executeActionCalled = true;
-		if(size > MAX_SIZE){
-			return 0xAFFE;
-		}
-		this->size = size;
-		memcpy(buffer, data, size);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	void clearBuffer(){
-		this->size = 0;
-		for(size_t i = 0; i<MAX_SIZE; i++){
-			buffer[i] = 0;
-		}
-	}
-
-	void getBuffer(const uint8_t** ptr, size_t* size){
-		if(size != nullptr){
-			*size = this->size;
-		}
-		if(ptr != nullptr){
-			*ptr = buffer;
-		}
-	}
-};
-
-
-class MessageQueueMockBase: public MessageQueueIF {
-public:
-	MessageQueueId_t myQueueId = 0;
-	bool defaultDestSet = false;
-	bool messageSent = false;
-
-
-
-	bool wasMessageSent() {
-		bool tempMessageSent = messageSent;
-		messageSent = false;
-		return tempMessageSent;
-	}
-
-	virtual ReturnValue_t reply( MessageQueueMessage* message ) {
-		messageSent = true;
-		lastMessage = (*message);
-		return HasReturnvaluesIF::RETURN_OK;
-	};
-	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message,
-			MessageQueueId_t *receivedFrom) {
-		(*message) = lastMessage;
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) {
-		(*message) = lastMessage;
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t flush(uint32_t* count) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual MessageQueueId_t getLastPartner() const {
-		return tconst::testQueueId;
-	}
-	virtual MessageQueueId_t getId() const {
-		return tconst::testQueueId;
-	}
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = (*message);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false ) override {
-		messageSent = true;
-		lastMessage = (*message);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = (*message);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message ) {
-		messageSent = true;
-		lastMessage = (*message);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
-		myQueueId = defaultDestination;
-		defaultDestSet = true;
-	}
-
-	virtual MessageQueueId_t getDefaultDestination() const {
-		return myQueueId;
-	}
-	virtual bool isDefaultDestinationSet() const {
-		return defaultDestSet;
-	}
-private:
-	MessageQueueMessage lastMessage;
-
-};
-
-
-#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
+//#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
+//#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
+//
+//#include <fsfw/action/HasActionsIF.h>
+//#include <fsfw/ipc/MessageQueueIF.h>
+//#include <fsfw/unittest/core/CatchDefinitions.h>
+//#include <cstring>
+//
+//
+//class ActionHelperOwnerMockBase: public HasActionsIF {
+//public:
+//	bool getCommandQueueCalled = false;
+//	bool executeActionCalled = false;
+//	static const size_t MAX_SIZE = 3;
+//	uint8_t buffer[MAX_SIZE] = {0, 0, 0};
+//	size_t size = 0;
+//
+//	MessageQueueId_t getCommandQueue() const override {
+//		return tconst::testQueueId;
+//	}
+//
+//	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+//			const uint8_t* data, size_t size) override {
+//		executeActionCalled = true;
+//		if(size > MAX_SIZE){
+//			return 0xAFFE;
+//		}
+//		this->size = size;
+//		memcpy(buffer, data, size);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//
+//	void clearBuffer(){
+//		this->size = 0;
+//		for(size_t i = 0; i<MAX_SIZE; i++){
+//			buffer[i] = 0;
+//		}
+//	}
+//
+//	void getBuffer(const uint8_t** ptr, size_t* size){
+//		if(size != nullptr){
+//			*size = this->size;
+//		}
+//		if(ptr != nullptr){
+//			*ptr = buffer;
+//		}
+//	}
+//};
+//
+//
+//class MessageQueueMockBase: public MessageQueueIF {
+//public:
+//	MessageQueueId_t myQueueId = 0;
+//	bool defaultDestSet = false;
+//	bool messageSent = false;
+//
+//
+//
+//	bool wasMessageSent() {
+//		bool tempMessageSent = messageSent;
+//		messageSent = false;
+//		return tempMessageSent;
+//	}
+//
+//	virtual ReturnValue_t reply( MessageQueueMessage* message ) {
+//		messageSent = true;
+//		lastMessage = (*message);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	};
+//	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message,
+//			MessageQueueId_t *receivedFrom) {
+//		(*message) = lastMessage;
+//		lastMessage.clear();
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) {
+//		(*message) = lastMessage;
+//		lastMessage.clear();
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual ReturnValue_t flush(uint32_t* count) {
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual MessageQueueId_t getLastPartner() const {
+//		return tconst::testQueueId;
+//	}
+//	virtual MessageQueueId_t getId() const {
+//		return tconst::testQueueId;
+//	}
+//	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+//			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+//			bool ignoreFault = false ) {
+//		messageSent = true;
+//		lastMessage = (*message);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+//			MessageQueueMessage* message, bool ignoreFault = false ) override {
+//		messageSent = true;
+//		lastMessage = (*message);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+//			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+//		messageSent = true;
+//		lastMessage = (*message);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message ) {
+//		messageSent = true;
+//		lastMessage = (*message);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+//		myQueueId = defaultDestination;
+//		defaultDestSet = true;
+//	}
+//
+//	virtual MessageQueueId_t getDefaultDestination() const {
+//		return myQueueId;
+//	}
+//	virtual bool isDefaultDestinationSet() const {
+//		return defaultDestSet;
+//	}
+//private:
+//	MessageQueueMessage lastMessage;
+//
+//};
+//
+//
+//#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
diff --git a/unittest/tests/container/RingBufferTest.cpp b/unittest/tests/container/RingBufferTest.cpp
index 07d6bc1f1..8b82d407f 100644
--- a/unittest/tests/container/RingBufferTest.cpp
+++ b/unittest/tests/container/RingBufferTest.cpp
@@ -1,6 +1,6 @@
 #include <fsfw/container/SimpleRingBuffer.h>
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
 
 #include <cstring>
 
diff --git a/unittest/tests/container/TestArrayList.cpp b/unittest/tests/container/TestArrayList.cpp
index b0ec0abbd..914188cb7 100644
--- a/unittest/tests/container/TestArrayList.cpp
+++ b/unittest/tests/container/TestArrayList.cpp
@@ -1,7 +1,7 @@
 #include <fsfw/container/ArrayList.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
 
 /**
  * @brief 	Array List test
diff --git a/unittest/tests/container/TestFifo.cpp b/unittest/tests/container/TestFifo.cpp
index ac0900c87..3775f4242 100644
--- a/unittest/tests/container/TestFifo.cpp
+++ b/unittest/tests/container/TestFifo.cpp
@@ -3,8 +3,8 @@
 #include <fsfw/container/FIFO.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
 
 TEST_CASE( "Static Fifo Tests", "[TestFifo]") {
 	INFO("Fifo Tests");
diff --git a/unittest/tests/container/TestFixedArrayList.cpp b/unittest/tests/container/TestFixedArrayList.cpp
index 5d1d5817b..737932e36 100644
--- a/unittest/tests/container/TestFixedArrayList.cpp
+++ b/unittest/tests/container/TestFixedArrayList.cpp
@@ -1,8 +1,9 @@
+#include "../../core/CatchDefinitions.h"
+
 #include <fsfw/container/FixedArrayList.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
 
 
 TEST_CASE( "FixedArrayList Tests", "[TestFixedArrayList]") {
diff --git a/unittest/tests/container/TestFixedMap.cpp b/unittest/tests/container/TestFixedMap.cpp
index 04656525b..079062f00 100644
--- a/unittest/tests/container/TestFixedMap.cpp
+++ b/unittest/tests/container/TestFixedMap.cpp
@@ -1,8 +1,8 @@
 #include <fsfw/container/FixedMap.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
 
 template class FixedMap<unsigned int, unsigned short>;
 
diff --git a/unittest/tests/container/TestFixedOrderedMultimap.cpp b/unittest/tests/container/TestFixedOrderedMultimap.cpp
index 953cb5a89..95194cb5a 100644
--- a/unittest/tests/container/TestFixedOrderedMultimap.cpp
+++ b/unittest/tests/container/TestFixedOrderedMultimap.cpp
@@ -1,8 +1,8 @@
 #include <fsfw/container/FixedOrderedMultimap.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
 
 TEST_CASE( "FixedOrderedMultimap Tests", "[TestFixedOrderedMultimap]") {
 	INFO("FixedOrderedMultimap Tests");
diff --git a/unittest/tests/container/TestPlacementFactory.cpp b/unittest/tests/container/TestPlacementFactory.cpp
index aa8e7375d..5edbb9d22 100644
--- a/unittest/tests/container/TestPlacementFactory.cpp
+++ b/unittest/tests/container/TestPlacementFactory.cpp
@@ -1,45 +1,45 @@
-#include <fsfw/container/PlacementFactory.h>
-#include <fsfw/storagemanager/LocalPool.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-#include <fsfw/container/ArrayList.h>
-
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
-
-TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
-	INFO("PlacementFactory Tests");
-
-	const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
-	const uint16_t n_elements[3] = {1, 1, 1};
-	LocalPool<3> storagePool(0x1, element_sizes, n_elements, false, true);
-	PlacementFactory factory(&storagePool);
-
-	SECTION("Pool overload"){
-		store_address_t address;
-		uint8_t* ptr = nullptr;
-		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
-				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
-		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
-		REQUIRE(list2 == nullptr);
-	}
-
-	SECTION("Test generate and destroy"){
-		uint64_t* number = factory.generate<uint64_t>(32000);
-		REQUIRE(number != nullptr);
-		REQUIRE(*number == 32000);
-		store_address_t address;
-		uint8_t* ptr = nullptr;
-		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
-						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
-		uint64_t* number2 = factory.generate<uint64_t>(12345);
-		REQUIRE(number2 == nullptr);
-		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
-						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-
-		//Check that PlacementFactory checks for nullptr
-		ptr = nullptr;
-		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
-	}
-}
+//#include <fsfw/container/PlacementFactory.h>
+//#include <fsfw/storagemanager/LocalPool.h>
+//#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+//#include <fsfw/container/ArrayList.h>
+//
+//#include <catch2/catch.hpp>
+//#include "../../core/CatchDefinitions.h"
+//
+//TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
+//	INFO("PlacementFactory Tests");
+//
+//	const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
+//	const uint16_t n_elements[3] = {1, 1, 1};
+//	LocalPool<3> storagePool(0x1, element_sizes, n_elements, false, true);
+//	PlacementFactory factory(&storagePool);
+//
+//	SECTION("Pool overload"){
+//		store_address_t address;
+//		uint8_t* ptr = nullptr;
+//		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
+//				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+//		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
+//		REQUIRE(list2 == nullptr);
+//	}
+//
+//	SECTION("Test generate and destroy"){
+//		uint64_t* number = factory.generate<uint64_t>(32000);
+//		REQUIRE(number != nullptr);
+//		REQUIRE(*number == 32000);
+//		store_address_t address;
+//		uint8_t* ptr = nullptr;
+//		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+//						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+//		uint64_t* number2 = factory.generate<uint64_t>(12345);
+//		REQUIRE(number2 == nullptr);
+//		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+//		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+//						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+//		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+//
+//		//Check that PlacementFactory checks for nullptr
+//		ptr = nullptr;
+//		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+//	}
+//}
diff --git a/unittest/tests/serialize/TestSerialBufferAdapter.cpp b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
index 39c1ba61a..9919ed844 100644
--- a/unittest/tests/serialize/TestSerialBufferAdapter.cpp
+++ b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
@@ -1,7 +1,7 @@
 #include <fsfw/serialize/SerialBufferAdapter.h>
 
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
 
 
 static bool test_value_bool = true;
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.cpp b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
index 932b62abe..0a09e430c 100644
--- a/unittest/tests/serialize/TestSerialLinkedPacket.cpp
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
@@ -1,8 +1,8 @@
 #include <fsfw/globalfunctions/arrayprinter.h>
 
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
-#include <fsfw/unittest/tests/serialize/TestSerialLinkedPacket.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
+#include "TestSerialLinkedPacket.h"
 
 
 TEST_CASE("Serial Linked Packet" , "[SerLinkPacket]") {
diff --git a/unittest/tests/serialize/TestSerialization.cpp b/unittest/tests/serialize/TestSerialization.cpp
index 7ac7b7963..4c9ba1818 100644
--- a/unittest/tests/serialize/TestSerialization.cpp
+++ b/unittest/tests/serialize/TestSerialization.cpp
@@ -2,7 +2,7 @@
 
 #include "catch.hpp"
 #include <array>
-#include "core/CatchDefinitions.h"
+#include "../../core/CatchDefinitions.h"
 
 static bool test_value_bool = true;
 static uint8_t tv_uint8   {5};
diff --git a/unittest/tests/storagemanager/TestNewAccessor.cpp b/unittest/tests/storagemanager/TestNewAccessor.cpp
index 7685afb3d..7bd0dee2f 100644
--- a/unittest/tests/storagemanager/TestNewAccessor.cpp
+++ b/unittest/tests/storagemanager/TestNewAccessor.cpp
@@ -1,161 +1,161 @@
-#include <fsfw/storagemanager/LocalPool.h>
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
-#include <array>
-
-TEST_CASE( "New Accessor" , "[NewAccessor]") {
-	uint16_t numberOfElements[1] = {1};
-	uint16_t sizeofElements[1] = {10};
-	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
-	std::array<uint8_t, 20> testDataArray;
-	std::array<uint8_t, 20> receptionArray;
-	store_address_t testStoreId;
-	ReturnValue_t result = retval::CATCH_FAILED;
-
-	for(size_t i = 0; i < testDataArray.size(); i++) {
-		testDataArray[i] = i;
-	}
-	size_t size = 10;
-
-	SECTION ("Simple tests getter functions") {
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-		REQUIRE(result == retval::CATCH_OK);
-		auto resultPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultPair.first == retval::CATCH_OK);
-		resultPair.second.getDataCopy(receptionArray.data(), 20);
-		CHECK(resultPair.second.getId() == testStoreId);
-		CHECK(resultPair.second.size() == 10);
-		for(size_t i = 0; i < size; i++) {
-			CHECK(receptionArray[i] == i );
-		}
-
-		std::copy(resultPair.second.data(), resultPair.second.data() +
-				resultPair.second.size(), receptionArray.data());
-		for(size_t i = 0; i < size; i++) {
-			CHECK(receptionArray[i] == i );
-		}
-
-		{
-			auto resultPairLoc = SimplePool.getData(testStoreId);
-			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
-			// data should be deleted when accessor goes out of scope.
-		}
-		resultPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-		REQUIRE(result == retval::CATCH_OK);
-		{
-			ConstStorageAccessor constAccessor(testStoreId);
-			result = SimplePool.getData(testStoreId, constAccessor);
-			REQUIRE(result == retval::CATCH_OK);
-			constAccessor.getDataCopy(receptionArray.data(), 20);
-			for(size_t i = 0; i < size; i++) {
-				CHECK(receptionArray[i] == i );
-			}
-			// likewise, data should be deleted when accessor gets out of scope.
-		}
-		resultPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-		{
-			resultPair = SimplePool.getData(testStoreId);
-			REQUIRE(resultPair.first == retval::CATCH_OK);
-			resultPair.second.release();
-			// now data should not be deleted anymore
-		}
-		resultPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultPair.first == retval::CATCH_OK);
-		resultPair.second.getDataCopy(receptionArray.data(), 20);
-		for(size_t i = 0; i < size; i++) {
-			CHECK(receptionArray[i] == i );
-		}
-	}
-
-
-	SECTION("Simple tests modify functions") {
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-		REQUIRE(result == retval::CATCH_OK);
-		{
-			StorageAccessor accessor(testStoreId);
-			result = SimplePool.modifyData(testStoreId, accessor);
-			REQUIRE(result == retval::CATCH_OK);
-			CHECK(accessor.getId() == testStoreId);
-			CHECK(accessor.size() == 10);
-			accessor.getDataCopy(receptionArray.data(), 20);
-			for(size_t i = 0; i < size; i++) {
-				CHECK(receptionArray[i] == i );
-			}
-			std::copy(accessor.data(), accessor.data() +
-					accessor.size(), receptionArray.data());
-			for(size_t i = 0; i < size; i++) {
-				CHECK(receptionArray[i] == i );
-			}
-			// data should be deleted when accessor goes out of scope
-		}
-		auto resultPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-		REQUIRE(result == retval::CATCH_OK);
-		{
-			auto resultPairLoc = SimplePool.modifyData(testStoreId);
-			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
-			CHECK(resultPairLoc.second.getId() == testStoreId);
-			CHECK(resultPairLoc.second.size() == 10);
-			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
-			for(size_t i = 0; i < size; i++) {
-				CHECK(receptionArray[i] == i );
-			}
-			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
-					resultPairLoc.second.size(), receptionArray.data());
-			for(size_t i = 0; i < size; i++) {
-				CHECK(receptionArray[i] == i );
-			}
-			resultPairLoc.second.release();
-			// data should not be deleted when accessor goes out of scope
-		}
-		resultPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultPair.first == retval::CATCH_OK);
-	}
-
-
-	SECTION("Write tests") {
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-		REQUIRE(result == retval::CATCH_OK);
-		{
-			auto resultPair = SimplePool.modifyData(testStoreId);
-			REQUIRE(resultPair.first == retval::CATCH_OK);
-			testDataArray[9] = 42;
-			resultPair.second.write(testDataArray.data(), 10, 0);
-			// now data should not be deleted
-			resultPair.second.release();
-		}
-		auto resultConstPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultConstPair.first == retval::CATCH_OK);
-
-		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
-		for(size_t i = 0; i < size-1; i++) {
-			CHECK(receptionArray[i] == i );
-		}
-		CHECK(receptionArray[9] == 42 );
-
-		auto resultPair = SimplePool.modifyData(testStoreId);
-		REQUIRE(resultPair.first == retval::CATCH_OK);
-		result = resultPair.second.write(testDataArray.data(), 20, 0);
-		REQUIRE(result == retval::CATCH_FAILED);
-		result = resultPair.second.write(testDataArray.data(), 10, 5);
-		REQUIRE(result == retval::CATCH_FAILED);
-
-		memset(testDataArray.data(), 42, 5);
-		result = resultPair.second.write(testDataArray.data(), 5, 5);
-		REQUIRE(result == retval::CATCH_OK);
-		resultConstPair = SimplePool.getData(testStoreId);
-		resultPair.second.getDataCopy(receptionArray.data(), 20);
-		for(size_t i = 5; i < 10; i++) {
-			CHECK(receptionArray[i] == 42 );
-		}
-
-	}
-}
+//#include <fsfw/storagemanager/LocalPool.h>
+//#include <catch2/catch.hpp>
+//#include "../../core/CatchDefinitions.h"
+//#include <array>
+//
+//TEST_CASE( "New Accessor" , "[NewAccessor]") {
+//	uint16_t numberOfElements[1] = {1};
+//	uint16_t sizeofElements[1] = {10};
+//	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
+//	std::array<uint8_t, 20> testDataArray;
+//	std::array<uint8_t, 20> receptionArray;
+//	store_address_t testStoreId;
+//	ReturnValue_t result = retval::CATCH_FAILED;
+//
+//	for(size_t i = 0; i < testDataArray.size(); i++) {
+//		testDataArray[i] = i;
+//	}
+//	size_t size = 10;
+//
+//	SECTION ("Simple tests getter functions") {
+//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+//		REQUIRE(result == retval::CATCH_OK);
+//		auto resultPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultPair.first == retval::CATCH_OK);
+//		resultPair.second.getDataCopy(receptionArray.data(), 20);
+//		CHECK(resultPair.second.getId() == testStoreId);
+//		CHECK(resultPair.second.size() == 10);
+//		for(size_t i = 0; i < size; i++) {
+//			CHECK(receptionArray[i] == i );
+//		}
+//
+//		std::copy(resultPair.second.data(), resultPair.second.data() +
+//				resultPair.second.size(), receptionArray.data());
+//		for(size_t i = 0; i < size; i++) {
+//			CHECK(receptionArray[i] == i );
+//		}
+//
+//		{
+//			auto resultPairLoc = SimplePool.getData(testStoreId);
+//			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+//			// data should be deleted when accessor goes out of scope.
+//		}
+//		resultPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+//
+//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+//		REQUIRE(result == retval::CATCH_OK);
+//		{
+//			ConstStorageAccessor constAccessor(testStoreId);
+//			result = SimplePool.getData(testStoreId, constAccessor);
+//			REQUIRE(result == retval::CATCH_OK);
+//			constAccessor.getDataCopy(receptionArray.data(), 20);
+//			for(size_t i = 0; i < size; i++) {
+//				CHECK(receptionArray[i] == i );
+//			}
+//			// likewise, data should be deleted when accessor gets out of scope.
+//		}
+//		resultPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+//
+//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+//		{
+//			resultPair = SimplePool.getData(testStoreId);
+//			REQUIRE(resultPair.first == retval::CATCH_OK);
+//			resultPair.second.release();
+//			// now data should not be deleted anymore
+//		}
+//		resultPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultPair.first == retval::CATCH_OK);
+//		resultPair.second.getDataCopy(receptionArray.data(), 20);
+//		for(size_t i = 0; i < size; i++) {
+//			CHECK(receptionArray[i] == i );
+//		}
+//	}
+//
+//
+//	SECTION("Simple tests modify functions") {
+//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+//		REQUIRE(result == retval::CATCH_OK);
+//		{
+//			StorageAccessor accessor(testStoreId);
+//			result = SimplePool.modifyData(testStoreId, accessor);
+//			REQUIRE(result == retval::CATCH_OK);
+//			CHECK(accessor.getId() == testStoreId);
+//			CHECK(accessor.size() == 10);
+//			accessor.getDataCopy(receptionArray.data(), 20);
+//			for(size_t i = 0; i < size; i++) {
+//				CHECK(receptionArray[i] == i );
+//			}
+//			std::copy(accessor.data(), accessor.data() +
+//					accessor.size(), receptionArray.data());
+//			for(size_t i = 0; i < size; i++) {
+//				CHECK(receptionArray[i] == i );
+//			}
+//			// data should be deleted when accessor goes out of scope
+//		}
+//		auto resultPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+//
+//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+//		REQUIRE(result == retval::CATCH_OK);
+//		{
+//			auto resultPairLoc = SimplePool.modifyData(testStoreId);
+//			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+//			CHECK(resultPairLoc.second.getId() == testStoreId);
+//			CHECK(resultPairLoc.second.size() == 10);
+//			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
+//			for(size_t i = 0; i < size; i++) {
+//				CHECK(receptionArray[i] == i );
+//			}
+//			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
+//					resultPairLoc.second.size(), receptionArray.data());
+//			for(size_t i = 0; i < size; i++) {
+//				CHECK(receptionArray[i] == i );
+//			}
+//			resultPairLoc.second.release();
+//			// data should not be deleted when accessor goes out of scope
+//		}
+//		resultPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultPair.first == retval::CATCH_OK);
+//	}
+//
+//
+//	SECTION("Write tests") {
+//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+//		REQUIRE(result == retval::CATCH_OK);
+//		{
+//			auto resultPair = SimplePool.modifyData(testStoreId);
+//			REQUIRE(resultPair.first == retval::CATCH_OK);
+//			testDataArray[9] = 42;
+//			resultPair.second.write(testDataArray.data(), 10, 0);
+//			// now data should not be deleted
+//			resultPair.second.release();
+//		}
+//		auto resultConstPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultConstPair.first == retval::CATCH_OK);
+//
+//		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
+//		for(size_t i = 0; i < size-1; i++) {
+//			CHECK(receptionArray[i] == i );
+//		}
+//		CHECK(receptionArray[9] == 42 );
+//
+//		auto resultPair = SimplePool.modifyData(testStoreId);
+//		REQUIRE(resultPair.first == retval::CATCH_OK);
+//		result = resultPair.second.write(testDataArray.data(), 20, 0);
+//		REQUIRE(result == retval::CATCH_FAILED);
+//		result = resultPair.second.write(testDataArray.data(), 10, 5);
+//		REQUIRE(result == retval::CATCH_FAILED);
+//
+//		memset(testDataArray.data(), 42, 5);
+//		result = resultPair.second.write(testDataArray.data(), 5, 5);
+//		REQUIRE(result == retval::CATCH_OK);
+//		resultConstPair = SimplePool.getData(testStoreId);
+//		resultPair.second.getDataCopy(receptionArray.data(), 20);
+//		for(size_t i = 5; i < 10; i++) {
+//			CHECK(receptionArray[i] == 42 );
+//		}
+//
+//	}
+//}

From a9b48749048c128e128ee77c4fc59e0deb68d871 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 22:49:19 +0100
Subject: [PATCH 0957/1774] new defines added

---
 unittest/config/TestsConfig.h | 2 +-
 unittest/core/CatchRunner.cpp | 4 ++++
 unittest/core/CatchSetup.cpp  | 1 +
 3 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/unittest/config/TestsConfig.h b/unittest/config/TestsConfig.h
index 7bf667f7d..cd967fa73 100644
--- a/unittest/config/TestsConfig.h
+++ b/unittest/config/TestsConfig.h
@@ -2,7 +2,7 @@
 #define FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_
 
 
-
+#define CUSTOM_UNITTEST_RUNNER 0
 
 
 #endif /* FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_ */
diff --git a/unittest/core/CatchRunner.cpp b/unittest/core/CatchRunner.cpp
index e15c8b2a8..35c53cd47 100644
--- a/unittest/core/CatchRunner.cpp
+++ b/unittest/core/CatchRunner.cpp
@@ -11,6 +11,8 @@
 #define CATCH_CONFIG_RUNNER
 #include <catch2/catch.hpp>
 
+#if CUSTOM_UNITTEST_RUNNER == 0
+
 extern int customSetup();
 
 int main( int argc, char* argv[] ) {
@@ -23,5 +25,7 @@ int main( int argc, char* argv[] ) {
     return result;
 }
 
+#endif
+
 
 #endif
diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index ca5c456da..a623fb776 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,4 +1,5 @@
 #include "CatchDefinitions.h"
+
 #include "../config/cdatapool/dataPoolInit.h"
 #include "../config/objects/Factory.h"
 

From a38c3e5005eb96ea7dd3be1e50896f9e1fd5329f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 11:47:03 +0100
Subject: [PATCH 0958/1774] config folder renamed

---
 unittest/config/cdatapool/dataPoolInit.cpp    | 48 -------------------
 unittest/config/cdatapool/dataPoolInit.h      | 29 -----------
 unittest/config/events/translateEvents.cpp    | 20 --------
 unittest/config/events/translateEvents.h      | 16 -------
 unittest/config/objects/systemObjectList.h    | 30 ------------
 .../PollingSequenceFactory.cpp                | 31 ------------
 unittest/config/returnvalues/classIds.h       | 28 -----------
 unittest/config/tmtc/PusIds.hpp               | 29 -----------
 unittest/config/tmtc/subsystemIdRanges.h      | 34 -------------
 unittest/config/tmtc/tmTcSize.h               | 10 ----
 unittest/{config => testcfg}/FSFWConfig.h     |  0
 unittest/{config => testcfg}/TestsConfig.h    |  0
 unittest/testcfg/cdatapool/dataPoolInit.cpp   |  5 ++
 unittest/testcfg/cdatapool/dataPoolInit.h     | 17 +++++++
 .../devices/logicalAddresses.cpp              |  0
 .../devices/logicalAddresses.h                |  0
 .../devices/powerSwitcherList.cpp             |  0
 .../devices/powerSwitcherList.h               |  0
 unittest/testcfg/events/subsystemIdRanges.h   | 18 +++++++
 .../ipc/MissionMessageTypes.cpp               |  2 +-
 .../ipc/MissionMessageTypes.h                 |  0
 .../{config => testcfg}/objects/Factory.cpp   |  0
 .../{config => testcfg}/objects/Factory.h     |  0
 unittest/testcfg/objects/systemObjectList.h   | 16 +++++++
 .../objects/translateObjects.cpp              |  0
 .../objects/translateObjects.h                |  0
 .../PollingSequenceFactory.cpp                | 23 +++++++++
 .../pollingsequence/PollingSequenceFactory.h  | 13 ++---
 unittest/testcfg/returnvalues/classIds.h      | 16 +++++++
 .../{config/config.mk => testcfg/testcfg.mk}  |  0
 unittest/{config => testcfg}/tmtc/apid.h      |  9 ++--
 unittest/{config => testcfg}/tmtc/pusIds.h    |  6 ++-
 unittest/{config => testcfg}/version.h        |  0
 33 files changed, 111 insertions(+), 289 deletions(-)
 delete mode 100644 unittest/config/cdatapool/dataPoolInit.cpp
 delete mode 100644 unittest/config/cdatapool/dataPoolInit.h
 delete mode 100644 unittest/config/events/translateEvents.cpp
 delete mode 100644 unittest/config/events/translateEvents.h
 delete mode 100644 unittest/config/objects/systemObjectList.h
 delete mode 100644 unittest/config/pollingsequence/PollingSequenceFactory.cpp
 delete mode 100644 unittest/config/returnvalues/classIds.h
 delete mode 100644 unittest/config/tmtc/PusIds.hpp
 delete mode 100644 unittest/config/tmtc/subsystemIdRanges.h
 delete mode 100644 unittest/config/tmtc/tmTcSize.h
 rename unittest/{config => testcfg}/FSFWConfig.h (100%)
 rename unittest/{config => testcfg}/TestsConfig.h (100%)
 create mode 100644 unittest/testcfg/cdatapool/dataPoolInit.cpp
 create mode 100644 unittest/testcfg/cdatapool/dataPoolInit.h
 rename unittest/{config => testcfg}/devices/logicalAddresses.cpp (100%)
 rename unittest/{config => testcfg}/devices/logicalAddresses.h (100%)
 rename unittest/{config => testcfg}/devices/powerSwitcherList.cpp (100%)
 rename unittest/{config => testcfg}/devices/powerSwitcherList.h (100%)
 create mode 100644 unittest/testcfg/events/subsystemIdRanges.h
 rename unittest/{config => testcfg}/ipc/MissionMessageTypes.cpp (80%)
 rename unittest/{config => testcfg}/ipc/MissionMessageTypes.h (100%)
 rename unittest/{config => testcfg}/objects/Factory.cpp (100%)
 rename unittest/{config => testcfg}/objects/Factory.h (100%)
 create mode 100644 unittest/testcfg/objects/systemObjectList.h
 rename unittest/{config => testcfg}/objects/translateObjects.cpp (100%)
 rename unittest/{config => testcfg}/objects/translateObjects.h (100%)
 create mode 100644 unittest/testcfg/pollingsequence/PollingSequenceFactory.cpp
 rename unittest/{config => testcfg}/pollingsequence/PollingSequenceFactory.h (74%)
 create mode 100644 unittest/testcfg/returnvalues/classIds.h
 rename unittest/{config/config.mk => testcfg/testcfg.mk} (100%)
 rename unittest/{config => testcfg}/tmtc/apid.h (61%)
 rename unittest/{config => testcfg}/tmtc/pusIds.h (86%)
 rename unittest/{config => testcfg}/version.h (100%)

diff --git a/unittest/config/cdatapool/dataPoolInit.cpp b/unittest/config/cdatapool/dataPoolInit.cpp
deleted file mode 100644
index f24d6cc54..000000000
--- a/unittest/config/cdatapool/dataPoolInit.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "dataPoolInit.h"
-
-void datapool::dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap) {
-	uint8_t UINT8T_INIT[1] = {0};
-	uint16_t UINT16T_INIT[1] = {0};
-	uint32_t UINT32T_INIT[1] = {0};
-	float FLOAT_INIT[2] = {0.0, 0.0};
-	/* FSFW */
-	poolMap->emplace(datapool::INTERNAL_ERROR_STORE_FULL,
-			new PoolEntry<uint32_t>(UINT32T_INIT,1));
-	poolMap->emplace(datapool::INTERNAL_ERROR_MISSED_LIVE_TM,
-			new PoolEntry<uint32_t>(UINT32T_INIT,1));
-	poolMap->emplace(datapool::INTERNAL_ERROR_FULL_MSG_QUEUES,
-			new PoolEntry<uint32_t>(UINT32T_INIT,1));
-
-	/* TEST */
-	poolMap->emplace(datapool::TEST_UINT8,
-			new PoolEntry<uint8_t>(UINT8T_INIT,1));
-	poolMap->emplace(datapool::TEST_UINT16,
-			new PoolEntry<uint16_t>(UINT16T_INIT,1));
-	poolMap->emplace(datapool::TEST_UINT32,
-			new PoolEntry<uint32_t>(UINT32T_INIT,1));
-	poolMap->emplace(datapool::TEST_FLOAT_VECTOR,
-			new PoolEntry<float>(FLOAT_INIT,2));
-
-	// With new initializer list feature and boolean entries.
-
-//	/* FSFW */
-//	poolMap->emplace(datapool::INTERNAL_ERROR_STORE_FULL,
-//			new PoolEntry<uint32_t>({0},1));
-//	poolMap->emplace(datapool::INTERNAL_ERROR_MISSED_LIVE_TM,
-//			new PoolEntry<uint32_t>({0},1));
-//	poolMap->emplace(datapool::INTERNAL_ERROR_FULL_MSG_QUEUES,
-//			new PoolEntry<uint32_t>({0},1));
-//
-//	/* TEST */
-//	poolMap->emplace(datapool::TEST_BOOLEAN,
-//			new PoolEntry<bool>({0},1));
-//	poolMap->emplace(datapool::TEST_UINT8,
-//			new PoolEntry<uint8_t>({0},1));
-//	poolMap->emplace(datapool::TEST_UINT16,
-//			new PoolEntry<uint16_t>({0},1));
-//	poolMap->emplace(datapool::TEST_UINT32,
-//			new PoolEntry<uint32_t>({0},1));
-//	poolMap->emplace(datapool::TEST_FLOAT_VECTOR,
-//			new PoolEntry<float>({0, 0},2));
-
-}
diff --git a/unittest/config/cdatapool/dataPoolInit.h b/unittest/config/cdatapool/dataPoolInit.h
deleted file mode 100644
index 6fd32371a..000000000
--- a/unittest/config/cdatapool/dataPoolInit.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
-#define HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
-
-#include <fsfw/datapoolglob/GlobalDataPool.h>
-#include <fsfw/datapool/PoolEntryIF.h>
-#include <map>
-#include <cstdint>
-
-
-namespace datapool {
-	void dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap);
-
-	enum datapoolvariables {
-		NO_PARAMETER = 0,
-
-		/** [EXPORT] : [GROUP] FSFW */
-		INTERNAL_ERROR_STORE_FULL = 0xEE000001, 	 //!< [EXPORT] : [NAME] Internal Error Store Entry [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
-		INTERNAL_ERROR_MISSED_LIVE_TM = 0xEE000001,  //!< [EXPORT] : [NAME] Internal Error Missed Live Tm [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
-		INTERNAL_ERROR_FULL_MSG_QUEUES = 0xEE000001, //!< [EXPORT] : [NAME] Internal Error Full Msg Queue [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
-
-		/** [EXPORT] : [GROUP] TEST */
-		TEST_BOOLEAN = 0x01010102, 				//!< [EXPORT] : [NAME] Test Boolean [UNIT] (-) [SIZE] 1 [TYPE] bool
-		TEST_UINT8 = 0x02020204,				//!< [EXPORT] : [NAME] Test Byte [UNIT] (-) [SIZE] 1 [TYPE] uint8_t
-		TEST_UINT16 = 0x03030306,				//!< [EXPORT] : [NAME] Test UINT16 [UNIT] (-) [SIZE] 1 [TYPE] uint16_t
-		TEST_UINT32 = 0x04040408,				//!< [EXPORT] : [NAME] Test UINT32 [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
-		TEST_FLOAT_VECTOR = 0x05050510,			//!< [EXPORT] : [NAME] Test Float [UNIT] (-) [SIZE] 2 [TYPE] float
-	};
-}
-#endif /* CONFIG_CDATAPOOL_DATAPOOLINIT_H_ */
diff --git a/unittest/config/events/translateEvents.cpp b/unittest/config/events/translateEvents.cpp
deleted file mode 100644
index bfcbe2bc8..000000000
--- a/unittest/config/events/translateEvents.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-/**
- * @brief    Auto-generated event translation file. Contains 80 translations.
- * Generated on: 2020-05-02 20:13:41 
- */
-#include <fsfw/unittest/config/events/translateEvents.h>
-
-const char *TEST_EVENT_SERVICE_1_STRING = "TEST_EVENT_SERVICE_1";
-const char *TEST2_STRING = "TEST2";
-
-const char * translateEvents(Event event){
-	switch((event&0xFFFF)){
-		case 8000:
-			return TEST_EVENT_SERVICE_1_STRING;
-		case 9100:
-			return TEST2_STRING;
-		default:
-			return "UNKNOWN_EVENT";
-	}
-	return 0;
-}
diff --git a/unittest/config/events/translateEvents.h b/unittest/config/events/translateEvents.h
deleted file mode 100644
index 0e40ef8ba..000000000
--- a/unittest/config/events/translateEvents.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * translateEvent.h
- *
- *  Created on: 28 May 2019
- *      Author: Robin
- */
-
-#ifndef CONFIG_EVENTS_TRANSLATEEVENTS_H_
-#define CONFIG_EVENTS_TRANSLATEEVENTS_H_
-
-#include <fsfw/events/Event.h>
-
-const char * translateEvents(Event event);
-
-
-#endif /* CONFIG_EVENTS_TRANSLATEEVENTS_H_ */
diff --git a/unittest/config/objects/systemObjectList.h b/unittest/config/objects/systemObjectList.h
deleted file mode 100644
index 9793305ee..000000000
--- a/unittest/config/objects/systemObjectList.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
-#define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
-
-#include <cstdint>
-
-// The objects will be instantiated in the ID order
-namespace objects {
-	enum sourceObjects: uint32_t {
-		/* First Byte 0x50-0x52 reserved for PUS Services **/
-		CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
-		PUS_PACKET_DISTRIBUTOR = 0x50000200,
-		UDP_BRIDGE = 0x50000300,
-		UDP_POLLING_TASK = 0x50000400,
-
-		PUS_SERVICE_3 = 0x51000300,
-		PUS_SERVICE_6_MEM_MGMT = 0x51000500,
-		PUS_SERVICE_23 = 0x51002300,
-		PUS_SERVICE_201_HEALTH = 0x51020100,
-
-		PUS_TIME = 0x52000001,
-		PUS_FUNNEL = 0x52000002,
-
-		/* Test Task */
-		TEST_TASK = 0x42694269,
-		DUMMY_INTERFACE = 0xCAFECAFE,
-		DUMMY_HANDLER = 0x4400AFFE,
-	};
-}
-
-#endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
diff --git a/unittest/config/pollingsequence/PollingSequenceFactory.cpp b/unittest/config/pollingsequence/PollingSequenceFactory.cpp
deleted file mode 100644
index dbe13add5..000000000
--- a/unittest/config/pollingsequence/PollingSequenceFactory.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <PollingSequenceFactory.h>
-#include <systemObjectList.h>
-
-#include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
-#include <fsfw/devicehandlers/DeviceHandlerIF.h>
-#include <fsfw/tasks/FixedTimeslotTaskIF.h>
-
-ReturnValue_t pst::pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence)
-{
-	/* Length of a communication cycle */
-	uint32_t length = thisSequence->getPeriodMs();
-
-    thisSequence->addSlot(objects::DUMMY_HANDLER,
-            length * 0,  DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::DUMMY_HANDLER,
-            length * 0.25, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::DUMMY_HANDLER,
-            length * 0.5,  DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::DUMMY_HANDLER,
-            length * 0.75, DeviceHandlerIF::GET_READ);
-
-	if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		sif::error << "PollingSequence::initialize has errors!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
diff --git a/unittest/config/returnvalues/classIds.h b/unittest/config/returnvalues/classIds.h
deleted file mode 100644
index a024e3d74..000000000
--- a/unittest/config/returnvalues/classIds.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * classIds.h
- *
- *  Created on: 16.07.2018
- *      Author: mohr
- */
-
-#ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
-#define CONFIG_RETURNVALUES_CLASSIDS_H_
-
-/**
- * Source IDs starts at 73 for now
- * Framework IDs for ReturnValues run from 0 to 56
- * and are located inside <fsfw/returnvalues/FwClassIds.h>
- */
-namespace CLASS_ID {
-enum {
-	MISSION_CLASS_ID_START = FW_CLASS_ID_COUNT,
-	RS232_CHANNEL, //!< RS232
-	I2C_CHANNEL, //!< I2C
-	SPI_CHANNEL, //!< SPI
-	GPS_HANDLER,  //!< GPS
-	PUS_SERVICE_3 //!< HKS
-};
-}
-
-
-#endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */
diff --git a/unittest/config/tmtc/PusIds.hpp b/unittest/config/tmtc/PusIds.hpp
deleted file mode 100644
index fd37c7f49..000000000
--- a/unittest/config/tmtc/PusIds.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * PusIds.hpp
- *
- *  Created on: 27.02.2019
- *      Author: jakob
- */
-
-#ifndef CONFIG_TMTC_PUSIDS_HPP_
-#define CONFIG_TMTC_PUSIDS_HPP_
-
-namespace PUS{
-enum Ids{
-	PUS_SERVICE_1 = 1,
-	PUS_SERVICE_2 = 2,
-	PUS_SERVICE_3 = 3,
-	PUS_SERVICE_5 = 5,
-	PUS_SERVICE_6 = 6,
-	PUS_SERVICE_8 = 8,
-	PUS_SERVICE_9 = 9,
-	PUS_SERVICE_17 = 17,
-	PUS_SERVICE_23 = 23,
-	PUS_SERVICE_200 = 200,
-	PUS_SERVICE_201 = 201,
-};
-};
-
-
-
-#endif /* CONFIG_TMTC_PUSIDS_HPP_ */
diff --git a/unittest/config/tmtc/subsystemIdRanges.h b/unittest/config/tmtc/subsystemIdRanges.h
deleted file mode 100644
index e32de74c5..000000000
--- a/unittest/config/tmtc/subsystemIdRanges.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef CONFIG_TMTC_SUBSYSTEMIDRANGES_H_
-#define CONFIG_TMTC_SUBSYSTEMIDRANGES_H_
-
-#include <fsfw/events/fwSubsystemIdRanges.h>
-#include <cstdint>
-
-/**
- * These IDs are part of the ID for an event thrown by a subsystem.
- * Numbers 0-80 are reserved for FSFW Subsystem IDs (framework/events/)
- */
-namespace SUBSYSTEM_ID {
-enum: uint8_t {
-	SUBSYSTE_ID_START = FW_SUBSYSTEM_ID_RANGE,
-	/**
-	 * 80-105: PUS Services
-	 */
-	PUS_SERVICE_2 = 82,
-	PUS_SERVICE_3 = 83,
-	PUS_SERVICE_5 = 85,
-	PUS_SERVICE_6 = 86,
-	PUS_SERVICE_8 = 88,
-	PUS_SERVICE_23 = 91,
-	DUMMY_DEVICE = 100,
-	/**
-	 * 105-115: AOCS
-	 */
-	GPS_DEVICE = 105,
-
-	SPI_COM_IF = 128,
-	I2C_COM_IF = 138
-};
-}
-
-#endif /* CONFIG_TMTC_SUBSYSTEMIDRANGES_H_ */
diff --git a/unittest/config/tmtc/tmTcSize.h b/unittest/config/tmtc/tmTcSize.h
deleted file mode 100644
index de7f4adca..000000000
--- a/unittest/config/tmtc/tmTcSize.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef CONFIG_TMTC_TMTCSIZE_H_
-#define CONFIG_TMTC_TMTCSIZE_H_
-
-#include <cstdint>
-
-namespace tmtcsize {
-static const uint32_t MAX_TM_PACKET = 50;
-}
-
-#endif /* CONFIG_TMTC_TMTCSIZE_H_ */
diff --git a/unittest/config/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
similarity index 100%
rename from unittest/config/FSFWConfig.h
rename to unittest/testcfg/FSFWConfig.h
diff --git a/unittest/config/TestsConfig.h b/unittest/testcfg/TestsConfig.h
similarity index 100%
rename from unittest/config/TestsConfig.h
rename to unittest/testcfg/TestsConfig.h
diff --git a/unittest/testcfg/cdatapool/dataPoolInit.cpp b/unittest/testcfg/cdatapool/dataPoolInit.cpp
new file mode 100644
index 000000000..ad2dc4ef5
--- /dev/null
+++ b/unittest/testcfg/cdatapool/dataPoolInit.cpp
@@ -0,0 +1,5 @@
+#include "dataPoolInit.h"
+
+void datapool::dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap) {
+
+}
diff --git a/unittest/testcfg/cdatapool/dataPoolInit.h b/unittest/testcfg/cdatapool/dataPoolInit.h
new file mode 100644
index 000000000..23a3d01f0
--- /dev/null
+++ b/unittest/testcfg/cdatapool/dataPoolInit.h
@@ -0,0 +1,17 @@
+#ifndef HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
+#define HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
+
+#include <fsfw/datapoolglob/GlobalDataPool.h>
+#include <fsfw/datapool/PoolEntryIF.h>
+#include <map>
+#include <cstdint>
+
+
+namespace datapool {
+	void dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap);
+
+	enum datapoolvariables {
+		NO_PARAMETER = 0,
+	};
+}
+#endif /* CONFIG_CDATAPOOL_DATAPOOLINIT_H_ */
diff --git a/unittest/config/devices/logicalAddresses.cpp b/unittest/testcfg/devices/logicalAddresses.cpp
similarity index 100%
rename from unittest/config/devices/logicalAddresses.cpp
rename to unittest/testcfg/devices/logicalAddresses.cpp
diff --git a/unittest/config/devices/logicalAddresses.h b/unittest/testcfg/devices/logicalAddresses.h
similarity index 100%
rename from unittest/config/devices/logicalAddresses.h
rename to unittest/testcfg/devices/logicalAddresses.h
diff --git a/unittest/config/devices/powerSwitcherList.cpp b/unittest/testcfg/devices/powerSwitcherList.cpp
similarity index 100%
rename from unittest/config/devices/powerSwitcherList.cpp
rename to unittest/testcfg/devices/powerSwitcherList.cpp
diff --git a/unittest/config/devices/powerSwitcherList.h b/unittest/testcfg/devices/powerSwitcherList.h
similarity index 100%
rename from unittest/config/devices/powerSwitcherList.h
rename to unittest/testcfg/devices/powerSwitcherList.h
diff --git a/unittest/testcfg/events/subsystemIdRanges.h b/unittest/testcfg/events/subsystemIdRanges.h
new file mode 100644
index 000000000..24eee819f
--- /dev/null
+++ b/unittest/testcfg/events/subsystemIdRanges.h
@@ -0,0 +1,18 @@
+#ifndef CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
+#define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
+
+#include <cstdint>
+#include <fsfw/events/fwSubsystemIdRanges.h>
+
+/**
+ * @brief	Custom subsystem IDs can be added here
+ * @details
+ * Subsystem IDs are used to create unique events.
+ */
+namespace SUBSYSTEM_ID {
+enum: uint8_t {
+	SUBSYSTEM_ID_START = FW_SUBSYSTEM_ID_RANGE,
+};
+}
+
+#endif /* CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_ */
diff --git a/unittest/config/ipc/MissionMessageTypes.cpp b/unittest/testcfg/ipc/MissionMessageTypes.cpp
similarity index 80%
rename from unittest/config/ipc/MissionMessageTypes.cpp
rename to unittest/testcfg/ipc/MissionMessageTypes.cpp
index 304ca439d..0ac8debea 100644
--- a/unittest/config/ipc/MissionMessageTypes.cpp
+++ b/unittest/testcfg/ipc/MissionMessageTypes.cpp
@@ -2,7 +2,7 @@
 #include <fsfw/unittest/config/ipc/MissionMessageTypes.h>
 
 void messagetypes::clearMissionMessage(CommandMessage* message) {
-	switch((message->getCommand()>>8) & 0xff) {
+	switch(message->getMessageType()) {
 	default:
 		break;
 	}
diff --git a/unittest/config/ipc/MissionMessageTypes.h b/unittest/testcfg/ipc/MissionMessageTypes.h
similarity index 100%
rename from unittest/config/ipc/MissionMessageTypes.h
rename to unittest/testcfg/ipc/MissionMessageTypes.h
diff --git a/unittest/config/objects/Factory.cpp b/unittest/testcfg/objects/Factory.cpp
similarity index 100%
rename from unittest/config/objects/Factory.cpp
rename to unittest/testcfg/objects/Factory.cpp
diff --git a/unittest/config/objects/Factory.h b/unittest/testcfg/objects/Factory.h
similarity index 100%
rename from unittest/config/objects/Factory.h
rename to unittest/testcfg/objects/Factory.h
diff --git a/unittest/testcfg/objects/systemObjectList.h b/unittest/testcfg/objects/systemObjectList.h
new file mode 100644
index 000000000..0e034aff8
--- /dev/null
+++ b/unittest/testcfg/objects/systemObjectList.h
@@ -0,0 +1,16 @@
+#ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+#define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+
+#include <cstdint>
+#include <fsfw/objectmanager/frameworkObjects.h>
+
+// The objects will be instantiated in the ID order
+namespace objects {
+	enum sourceObjects: uint32_t {
+		/* All addresses between start and end are reserved for the FSFW */
+		FSFW_CONFIG_RESERVED_START = PUS_SERVICE_1_VERIFICATION,
+		FSFW_CONFIG_RESERVED_END = TM_STORE
+	};
+}
+
+#endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
diff --git a/unittest/config/objects/translateObjects.cpp b/unittest/testcfg/objects/translateObjects.cpp
similarity index 100%
rename from unittest/config/objects/translateObjects.cpp
rename to unittest/testcfg/objects/translateObjects.cpp
diff --git a/unittest/config/objects/translateObjects.h b/unittest/testcfg/objects/translateObjects.h
similarity index 100%
rename from unittest/config/objects/translateObjects.h
rename to unittest/testcfg/objects/translateObjects.h
diff --git a/unittest/testcfg/pollingsequence/PollingSequenceFactory.cpp b/unittest/testcfg/pollingsequence/PollingSequenceFactory.cpp
new file mode 100644
index 000000000..f836a7462
--- /dev/null
+++ b/unittest/testcfg/pollingsequence/PollingSequenceFactory.cpp
@@ -0,0 +1,23 @@
+#include "PollingSequenceFactory.h"
+
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+
+ReturnValue_t pst::pollingSequenceInitDefault(
+        FixedTimeslotTaskIF *thisSequence) {
+	/* Length of a communication cycle */
+	uint32_t length = thisSequence->getPeriodMs();
+
+	/* Add polling sequence table here */
+
+	if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
+		        << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
diff --git a/unittest/config/pollingsequence/PollingSequenceFactory.h b/unittest/testcfg/pollingsequence/PollingSequenceFactory.h
similarity index 74%
rename from unittest/config/pollingsequence/PollingSequenceFactory.h
rename to unittest/testcfg/pollingsequence/PollingSequenceFactory.h
index b6cc2f1ee..c5d41b7d8 100644
--- a/unittest/config/pollingsequence/PollingSequenceFactory.h
+++ b/unittest/testcfg/pollingsequence/PollingSequenceFactory.h
@@ -1,13 +1,14 @@
 #ifndef POLLINGSEQUENCEFACTORY_H_
 #define POLLINGSEQUENCEFACTORY_H_
+
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 class FixedTimeslotTaskIF;
 
 /**
- * All device handlers are scheduled by adding them into
- * Polling Sequence Tables (PST) to satisfy stricter timing requirements of
- * device communication, a device handler has four different communication steps:
+ * All device handlers are scheduled by adding them into  Polling Sequence Tables (PST)
+ * to satisfy stricter timing requirements of device communication,
+ * A device handler has four different communication steps:
  *   1. DeviceHandlerIF::SEND_WRITE -> Send write via interface
  *   2. DeviceHandlerIF::GET_WRITE -> Get confirmation for write
  *   3. DeviceHandlerIF::SEND_READ -> Send read request
@@ -17,15 +18,15 @@ class FixedTimeslotTaskIF;
  * The task is created using the FixedTimeslotTaskIF,
  * which utilises the underlying Operating System Abstraction Layer (OSAL)
  *
- * @param thisSequence FixedTimeslotTaskIF * object is passed inside the
- * 					   Factory class when creating the PST
+ * @param thisSequence FixedTimeslotTaskIF * object is passed inside the Factory class when creating the PST
  * @return
  */
 namespace pst {
 
-/* 0.4 second period init*/
+/* Default PST */
 ReturnValue_t pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence);
 
+
 }
 
 #endif /* POLLINGSEQUENCEINIT_H_ */
diff --git a/unittest/testcfg/returnvalues/classIds.h b/unittest/testcfg/returnvalues/classIds.h
new file mode 100644
index 000000000..606cc60b2
--- /dev/null
+++ b/unittest/testcfg/returnvalues/classIds.h
@@ -0,0 +1,16 @@
+#ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
+#define CONFIG_RETURNVALUES_CLASSIDS_H_
+
+#include <fsfw/returnvalues/FwClassIds.h>
+
+/**
+ * @brief   CLASS_ID defintions which are required for custom returnvalues.
+ */
+namespace CLASS_ID {
+enum {
+	MISSION_CLASS_ID_START = FW_CLASS_ID_COUNT,
+};
+}
+
+
+#endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */
diff --git a/unittest/config/config.mk b/unittest/testcfg/testcfg.mk
similarity index 100%
rename from unittest/config/config.mk
rename to unittest/testcfg/testcfg.mk
diff --git a/unittest/config/tmtc/apid.h b/unittest/testcfg/tmtc/apid.h
similarity index 61%
rename from unittest/config/tmtc/apid.h
rename to unittest/testcfg/tmtc/apid.h
index 77e55952e..c0231bca8 100644
--- a/unittest/config/tmtc/apid.h
+++ b/unittest/testcfg/tmtc/apid.h
@@ -1,18 +1,17 @@
 #ifndef CONFIG_TMTC_APID_H_
 #define CONFIG_TMTC_APID_H_
 
-#include <stdint.h>
+#include <cstdint>
 
 /**
  * Application Process Definition: entity, uniquely identified by an
  * application process ID (APID), capable of generating telemetry source
- * packets and receiving telecommand packets
+ * packets and receiving telecommand packets.
  *
- * SOURCE APID: 0x73 / 115 / s
- * APID is a 11 bit number
+ * Chose APID(s) for mission and define it here.
  */
 namespace apid {
-	static const uint16_t SOURCE_OBSW = 0x73;
+	static const uint16_t DEFAULT_APID = 0x00;
 }
 
 
diff --git a/unittest/config/tmtc/pusIds.h b/unittest/testcfg/tmtc/pusIds.h
similarity index 86%
rename from unittest/config/tmtc/pusIds.h
rename to unittest/testcfg/tmtc/pusIds.h
index a2dd75759..821a9982a 100644
--- a/unittest/config/tmtc/pusIds.h
+++ b/unittest/testcfg/tmtc/pusIds.h
@@ -1,16 +1,18 @@
 #ifndef CONFIG_TMTC_PUSIDS_HPP_
 #define CONFIG_TMTC_PUSIDS_HPP_
 
+#include <cstdint>
+
 namespace pus {
-enum Ids{
+enum Ids: uint8_t {
 	PUS_SERVICE_1 = 1,
 	PUS_SERVICE_2 = 2,
 	PUS_SERVICE_3 = 3,
-	PUS_SERVICE_3_PSB = 3,
 	PUS_SERVICE_5 = 5,
 	PUS_SERVICE_6 = 6,
 	PUS_SERVICE_8 = 8,
 	PUS_SERVICE_9 = 9,
+	PUS_SERVICE_11 = 11,
 	PUS_SERVICE_17 = 17,
 	PUS_SERVICE_19 = 19,
 	PUS_SERVICE_20 = 20,
diff --git a/unittest/config/version.h b/unittest/testcfg/version.h
similarity index 100%
rename from unittest/config/version.h
rename to unittest/testcfg/version.h

From 29187fbc4badd33e7533c53b2aaa8032b73353e0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 11:59:50 +0100
Subject: [PATCH 0959/1774] some config adaptions

---
 defaultcfg/FSFWConfig.h        | 41 ----------------------------------
 defaultcfg/config/FSFWConfig.h |  8 ++++---
 defaultcfg/config/version.h    |  9 --------
 defaultcfg/version.h           | 11 ---------
 events/EventManager.cpp        |  3 ++-
 fsfw.mk                        |  2 ++
 unittest/testcfg/FSFWConfig.h  | 11 ++++++---
 unittest/testcfg/version.h     |  7 ------
 8 files changed, 17 insertions(+), 75 deletions(-)
 delete mode 100644 defaultcfg/FSFWConfig.h
 delete mode 100644 defaultcfg/config/version.h
 delete mode 100644 defaultcfg/version.h
 delete mode 100644 unittest/testcfg/version.h

diff --git a/defaultcfg/FSFWConfig.h b/defaultcfg/FSFWConfig.h
deleted file mode 100644
index 2001f3062..000000000
--- a/defaultcfg/FSFWConfig.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef CONFIG_FSFWCONFIG_H_
-#define CONFIG_FSFWCONFIG_H_
-
-#include "version.h"
-
-//! Used to determine whether C++ ostreams are used
-//! Those can lead to code bloat.
-#define FSFW_CPP_OSTREAM_ENABLED 	1
-
-//! Reduced printout to further decrese code size
-//! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_REDUCED_PRINTOUT		0
-
-//! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_DEBUGGING              0
-
-//! Defines the FIFO depth of each commanding service base which
-//! also determines how many commands a CSB service can handle in one cycle
-//! simulataneously. This will increase the required RAM for
-//! each CSB service !
-#define FSFW_CSB_FIFO_DEPTH			6
-
-//! If -DDEBUG is supplied in the build defines, there will be
-//! additional output which requires the translation files translateObjects
-//! and translateEvents (and their compiles source files)
-#ifdef DEBUG
-#define FSFW_DEBUG_OUTPUT 			1
-//! Specify whether info events are printed too.
-#define FSFW_DEBUG_INFO				1
-#include <translateObjects.h>
-#include <translateEvents.h>
-#else
-#define FSFW_DEBUG_OUTPUT			0
-#endif
-
-//! When using the newlib nano library, C99 support for stdio facilities
-//! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NO_C99_IO 	1
-
-
-#endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index cfe898642..f723f9d80 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -20,10 +20,12 @@
 //! each CSB service !
 #define FSFW_CSB_FIFO_DEPTH			6
 
-//! If -DDEBUG is supplied in the build defines, there will be
+#define FSFW_OBJ_EVENT_TRANSLATION	0
+
+//! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
-//! and translateEvents (and their compiles source files)
-#ifdef DEBUG
+//! and translateEvents (and their compiled source files)
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 #define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
diff --git a/defaultcfg/config/version.h b/defaultcfg/config/version.h
deleted file mode 100644
index 3c60317c4..000000000
--- a/defaultcfg/config/version.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef CONFIG_VERSION_H_
-#define CONFIG_VERSION_H_
-
-/* OBSW versioning can be specified in this file */
-
-#define OBSW_VERSION      0
-#define OBSW_SUBVERSION   0
-
-#endif /* CONFIG_VERSION_H_ */
diff --git a/defaultcfg/version.h b/defaultcfg/version.h
deleted file mode 100644
index b3ef83189..000000000
--- a/defaultcfg/version.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef FSFW_DEFAULTCFG_VERSION_H_
-#define FSFW_DEFAULTCFG_VERSION_H_
-
-static const char* FSFW_VERSION_NAME = "fsfw";
-
-#define FSFW_VERSION 		0
-#define	FSFW_SUBVERSION 	0
-
-
-
-#endif /* FSFW_DEFAULTCFG_VERSION_H_ */
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 57bda13fb..16ac289d4 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,4 +1,5 @@
 #include "EventManager.h"
+#include <FSFWConfig.h>
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
@@ -38,7 +39,7 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {
 		EventMessage message;
 		result = eventReportQueue->receiveMessage(&message);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
-#ifdef DEBUG
+#ifdef FSFW_OBJECTMANAGER_
 			printEvent(&message);
 #endif
 			notifyListeners(&message);
diff --git a/fsfw.mk b/fsfw.mk
index c58475540..1dd4f1665 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -73,3 +73,5 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)
+
+INCLUDES += $(CURRENTPATH)
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index bb285472a..b1177b744 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -1,7 +1,7 @@
 #ifndef CONFIG_FSFWCONFIG_H_
 #define CONFIG_FSFWCONFIG_H_
 
-#include <fsfw/unittest/config/version.h>
+#include <FSFWVersion.h>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.
@@ -11,16 +11,21 @@
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_REDUCED_PRINTOUT		0
 
+//! Can be used to enable debugging printouts for developing the FSFW
+#define FSFW_DEBUGGING              0
+
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle
 //! simulataneously. This will increase the required RAM for
 //! each CSB service !
 #define FSFW_CSB_FIFO_DEPTH			6
 
+#define FSFW_OBJ_EVENT_TRANSLATION	0
+
 //! If -DDEBUG is supplied in the build defines, there will be
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiles source files)
-#ifdef DEBUG
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 #define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
@@ -32,7 +37,7 @@
 
 //! When using the newlib nano library, C99 support for stdio facilities
 //! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NEWLIB_NANO_NO_C99_IO 	1
+#define FSFW_NO_C99_IO 	1
 
 
 #endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/unittest/testcfg/version.h b/unittest/testcfg/version.h
deleted file mode 100644
index f53345c1e..000000000
--- a/unittest/testcfg/version.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#ifndef CONFIG_VERSION_H_
-#define CONFIG_VERSION_H_
-
-#define SW_VERSION      1
-#define SW_SUBVERSION   6
-
-#endif /* CONFIG_VERSION_H_ */

From 565fd63d0855e10fc29e46a7ab0f31a45e253ba8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 12:07:48 +0100
Subject: [PATCH 0960/1774] makefile moved

---
 defaultcfg/config/FSFWConfig.h             | 4 ++--
 unittest/testcfg/FSFWConfig.h              | 3 +++
 unittest/{ => testcfg}/Makefile-FSFW-Tests | 0
 3 files changed, 5 insertions(+), 2 deletions(-)
 rename unittest/{ => testcfg}/Makefile-FSFW-Tests (100%)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index f723f9d80..d72f23743 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -20,11 +20,11 @@
 //! each CSB service !
 #define FSFW_CSB_FIFO_DEPTH			6
 
-#define FSFW_OBJ_EVENT_TRANSLATION	0
-
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
+#define FSFW_OBJ_EVENT_TRANSLATION	0
+
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 #define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index b1177b744..4fb224c15 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -20,6 +20,9 @@
 //! each CSB service !
 #define FSFW_CSB_FIFO_DEPTH			6
 
+//! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiled source files)
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
 //! If -DDEBUG is supplied in the build defines, there will be
diff --git a/unittest/Makefile-FSFW-Tests b/unittest/testcfg/Makefile-FSFW-Tests
similarity index 100%
rename from unittest/Makefile-FSFW-Tests
rename to unittest/testcfg/Makefile-FSFW-Tests

From 176ca56e355405d4e9d81e503187e2f87d87f84f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 15:12:05 +0100
Subject: [PATCH 0961/1774] core changes taken over

---
 unittest/core/CatchDefinitions.cpp | 2 +-
 unittest/core/CatchDefinitions.h   | 4 +++-
 unittest/core/CatchSetup.cpp       | 4 ++--
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/unittest/core/CatchDefinitions.cpp b/unittest/core/CatchDefinitions.cpp
index 3f4614e81..0b66558ac 100644
--- a/unittest/core/CatchDefinitions.cpp
+++ b/unittest/core/CatchDefinitions.cpp
@@ -1,5 +1,5 @@
+#include "CatchDefinitions.h"
 #include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/unittest/core/CatchDefinitions.h>
 
 StorageManagerIF* tglob::getIpcStoreHandle() {
 	if(objectManager != nullptr) {
diff --git a/unittest/core/CatchDefinitions.h b/unittest/core/CatchDefinitions.h
index cdc025fa1..366cda7e5 100644
--- a/unittest/core/CatchDefinitions.h
+++ b/unittest/core/CatchDefinitions.h
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_
+#define FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_
 
 #include <fsfw/ipc/messageQueueDefinitions.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
@@ -17,3 +18,4 @@ namespace tglob {
 	StorageManagerIF* getIpcStoreHandle();
 }
 
+#endif /* FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_ */
diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index a623fb776..5749ecd11 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,7 +1,7 @@
 #include "CatchDefinitions.h"
 
-#include "../config/cdatapool/dataPoolInit.h"
-#include "../config/objects/Factory.h"
+#include <testcfg/cdatapool/dataPoolInit.h>
+#include <testcfg/objects/Factory.h>
 
 
 #ifdef GCOV

From 7970043cb5a138afe4259b9442034c501b327380 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 15:12:36 +0100
Subject: [PATCH 0962/1774] deleted some sutff

---
 unittest/README.md | 72 ----------------------------------------------
 1 file changed, 72 deletions(-)

diff --git a/unittest/README.md b/unittest/README.md
index 091dd3cb2..e628d43e8 100644
--- a/unittest/README.md
+++ b/unittest/README.md
@@ -7,67 +7,6 @@ The makefile with default settings creates the unit test binary which can be
 run in the terminal or in eclipse.
 
 ### Instructions
-Basic steps:
-
-1. Clone this branch
-   ```sh
-   git clone https://egit.irs.uni-stuttgart.de/fsfw/fsfw_tests.git
-   ```
-
-2. Inititate the framework submodule (need to only be done once)
-   ```sh
-   git submodule init
-   git submodule sync
-   git submodule update
-   ```
-   
-2. Run the makefile With
-
-   ```sh
-   make all -j<Number Of Processors>
-   ```
-   This will build the debug version of the unit tests.
-   The release version can be built with the target `release`
-
-4. Run the binary located in the \_bin folder in the terminal or in eclipse.
-
-   ```sh
-   _bin/<binaryName>.elf [--success]
-   ```
-   The success parameter is optional. Leaving it out ommits the success messages.
-
-5. To clear the binary, object and dependency folder, run
-
-   ```sh
-   make clean
-   ```
-
-Please note that on most UNIX environments (e.g. Ubuntu), the real time functionalities used by the UNIX pthread module are restricted, which will lead to permission errors when creating these tasks.
-
-To solve this issues, try following steps:
-
-1. Edit the /etc/security/limits.conf 
-   file and add following lines at the end (worked on Ubuntu 19.10):
-   ```sh
-   <username>   hard   rtprio  99
-   <username>   soft   rtprio  99
-   ```
-   Then restart the computer. <br>
-   The soft limit can also be set in the console with `ulimit -Sr` if the hard
-   limit has been increased,
-   but it is recommended to add it to the file as well for convenience.
-   If adding the second line is not desired for security reasons,
-   the soft limit needs to be set for each session. If using an IDE like eclipse 
-   in that case, the IDE needs to be started from the console after setting
-   the soft limit higher there.
-2. Run the shell script inside the linux folder (worked on Ubuntu 18.04)
-   ```sh
-   ./unlockRealtime
-   ```
-   This script executes the `setcap` command on bash and on the binaries.
-   It also increases the soft real time limit of the current shell instance
-   to the maximum. If running the script before executing the binary does
-   not help, try the following step.
    
 ### Eclipse CDT settings
 
@@ -108,14 +47,3 @@ For writing basics tests, the [assertion documentation](https://github.com/catch
 or the existing examples are a good guideliens.
 For more advanced tests, refer to the [catch2 documentation](https://github.com/catchorg/Catch2/blob/master/docs/Readme.md#top).
 
-### Compile without test framework
-Alternatively, the unit tests can also be run internally without
-a framework. This can be used to perform unit tests on the real hardware.
-To do this, run
-```sh
-make -j<Number Of Processors> notestfw
-```
-This will instruct the makefile to exclude the test framework main.cpp
-and include our own. This will also create a binary which can be used
-outside the host machine (a Makefile adaptions might be neccessary
-if another OS than linux is required)

From 172fbd7e4840bcc2001fcf425684a552f2488ad1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 15:13:03 +0100
Subject: [PATCH 0963/1774] some changes taken over

---
 unittest/testcfg/devices/logicalAddresses.cpp  |  8 +-------
 unittest/testcfg/devices/powerSwitcherList.cpp |  8 +-------
 unittest/testcfg/devices/powerSwitcherList.h   | 10 ----------
 unittest/testcfg/ipc/MissionMessageTypes.cpp   |  3 ++-
 unittest/testcfg/objects/Factory.cpp           |  4 ++--
 5 files changed, 6 insertions(+), 27 deletions(-)

diff --git a/unittest/testcfg/devices/logicalAddresses.cpp b/unittest/testcfg/devices/logicalAddresses.cpp
index 157762756..c7ce314d1 100644
--- a/unittest/testcfg/devices/logicalAddresses.cpp
+++ b/unittest/testcfg/devices/logicalAddresses.cpp
@@ -1,10 +1,4 @@
-/**
- * \file logicalAddresses.cpp
- *
- * \date 06.11.2019
- */
-
-#include <fsfw/unittest/config/devices/logicalAddresses.h>
+#include "logicalAddresses.h"
 
 
 
diff --git a/unittest/testcfg/devices/powerSwitcherList.cpp b/unittest/testcfg/devices/powerSwitcherList.cpp
index cb5685229..343f78d04 100644
--- a/unittest/testcfg/devices/powerSwitcherList.cpp
+++ b/unittest/testcfg/devices/powerSwitcherList.cpp
@@ -1,10 +1,4 @@
-/**
- * @file switcherList.cpp
- *
- * @date 28.11.2019
- */
-
-#include <fsfw/unittest/config/devices/powerSwitcherList.h>
+#include "powerSwitcherList.h"
 
 
 
diff --git a/unittest/testcfg/devices/powerSwitcherList.h b/unittest/testcfg/devices/powerSwitcherList.h
index f5b0eb112..86ddea570 100644
--- a/unittest/testcfg/devices/powerSwitcherList.h
+++ b/unittest/testcfg/devices/powerSwitcherList.h
@@ -1,19 +1,9 @@
-/**
- * @file switcherList.h
- *
- * @date 28.11.2019
- */
-
 #ifndef CONFIG_DEVICES_POWERSWITCHERLIST_H_
 #define CONFIG_DEVICES_POWERSWITCHERLIST_H_
 
 namespace switches {
 	/* Switches are uint8_t datatype and go from 0 to 255 */
 	enum switcherList {
-		PCDU,
-		GPS0,
-		GPS1,
-		DUMMY = 129
 	};
 
 }
diff --git a/unittest/testcfg/ipc/MissionMessageTypes.cpp b/unittest/testcfg/ipc/MissionMessageTypes.cpp
index 0ac8debea..d68cb58cc 100644
--- a/unittest/testcfg/ipc/MissionMessageTypes.cpp
+++ b/unittest/testcfg/ipc/MissionMessageTypes.cpp
@@ -1,5 +1,6 @@
+#include "MissionMessageTypes.h"
+
 #include <fsfw/ipc/CommandMessage.h>
-#include <fsfw/unittest/config/ipc/MissionMessageTypes.h>
 
 void messagetypes::clearMissionMessage(CommandMessage* message) {
 	switch(message->getMessageType()) {
diff --git a/unittest/testcfg/objects/Factory.cpp b/unittest/testcfg/objects/Factory.cpp
index 612527c97..e05b7942e 100644
--- a/unittest/testcfg/objects/Factory.cpp
+++ b/unittest/testcfg/objects/Factory.cpp
@@ -1,10 +1,10 @@
+#include "Factory.h"
+
 #include <fsfw/events/EventManager.h>
 #include <fsfw/health/HealthTable.h>
 
 #include <fsfw/internalError/InternalErrorReporter.h>
 #include <fsfw/objectmanager/frameworkObjects.h>
-#include <fsfw/unittest/config/cdatapool/dataPoolInit.h>
-#include <fsfw/unittest/config/objects/Factory.h>
 
 /**
  * @brief Produces system objects.

From 4b2af9eaa6ce2c418cfb280d633772d870f0dc86 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 15:15:08 +0100
Subject: [PATCH 0964/1774] static keyword removed

---
 FSFWVersion.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/FSFWVersion.h b/FSFWVersion.h
index b3ef83189..dcb592dc9 100644
--- a/FSFWVersion.h
+++ b/FSFWVersion.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DEFAULTCFG_VERSION_H_
 #define FSFW_DEFAULTCFG_VERSION_H_
 
-static const char* FSFW_VERSION_NAME = "fsfw";
+const char* const FSFW_VERSION_NAME = "fsfw";
 
 #define FSFW_VERSION 		0
 #define	FSFW_SUBVERSION 	0

From fb12045f23151e60c30359ee00c09bcef2b0b700 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 15:25:03 +0100
Subject: [PATCH 0965/1774] changes from master taken over

---
 devicehandlers/DeviceHandlerBase.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d67e47d8a..38821054b 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1262,7 +1262,8 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (result == BUSY) {
 		    //so we can track misconfigurations
 			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Busy" << std::endl;
+					<< ": DHB::buildInternalCommand: Busy" << std::dec
+					<< std::endl;
 			result = NOTHING_TO_SEND; //no need to report this
 		}
 	}

From 42e611899befd5992d639ab3a46b08f7c5785069 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 16:43:03 +0100
Subject: [PATCH 0966/1774] added timestamp size

---
 defaultcfg/config/FSFWConfig.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index d72f23743..b6255a2fd 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -11,6 +11,10 @@
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_REDUCED_PRINTOUT		0
 
+//! Default timestamp size. The default timestamp will be a seven byte CDC short
+//! timestamp.
+#define FSFW_MISSION_TIMESTAMP_SIZE 8
+
 //! Can be used to enable debugging printouts for developing the FSFW
 #define FSFW_DEBUGGING              0
 

From 3d2778fdf79eeb315ace8944fd8b555b35d550d3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 16:45:47 +0100
Subject: [PATCH 0967/1774] doc update

---
 action/HasActionsIF.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index a26ed5883..886d08377 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -47,9 +47,10 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	/**
 	 * Execute or initialize the execution of a certain function.
-	 * When used in conjunction with the ActionHelper class, returning
-	 * a return code which is not equal to RETURN_OK will trigger a step reply
-	 * with step 0.
+	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to
+	 * be done. When needing more steps, return RETURN_OK and issue steps and
+	 * completion manually.
+	 * One "step failed" or completion report must be issued!
 	 */
 	virtual ReturnValue_t executeAction(ActionId_t actionId,
 			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;

From 0919d2c53231934748bcb581915993ed670f2e87 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 16:52:06 +0100
Subject: [PATCH 0968/1774] updates taken over

---
 action/ActionHelper.cpp       | 14 ++++++++++----
 action/ActionHelper.h         |  5 +++--
 action/ActionMessage.h        | 18 +++++++++++-------
 action/CommandsActionsIF.h    | 15 +++++++++------
 action/HasActionsIF.h         | 17 ++++++++++-------
 action/SimpleActionHelper.cpp |  7 ++++---
 action/SimpleActionHelper.h   | 20 +++++++++++++-------
 7 files changed, 60 insertions(+), 36 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 8122885bb..285579160 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -1,5 +1,6 @@
 #include "ActionHelper.h"
 #include "HasActionsIF.h"
+
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
@@ -65,6 +66,11 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
 	}
 	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
 	ipcStore->deleteData(dataAddress);
+	if(result == HasActionsIF::EXECUTION_FINISHED) {
+		CommandMessage reply;
+		ActionMessage::setCompletionReply(&reply, actionId, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+	}
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		CommandMessage reply;
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
@@ -101,8 +107,8 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 	// another dedicated message.
 	ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
-	// TODO: Service Implementation sucks at the moment
-	// TODO: why does it suck and why would someone need to hide the sender?
+    // If the sender needs to be hidden, for example to handle packet
+    // as unrequested reply, this will be done here.
 	if (hideSender) {
 		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
 	}
@@ -140,8 +146,8 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
     // another dedicated message.
     ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
-    // TODO: Service Implementation sucks at the moment
-    // TODO: why does it suck and why would someone need to hide the sender?
+    // If the sender needs to be hidden, for example to handle packet
+    // as unrequested reply, this will be done here.
     if (hideSender) {
         result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
     }
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index 17ca3ebdc..a91722f39 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -57,8 +57,9 @@ public:
 	 * @param commandId ID of the executed command
 	 * @param result Result of the execution
 	 */
-	void step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId,
-	        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	void step(uint8_t step, MessageQueueId_t reportTo,
+			ActionId_t commandId,
+			ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
 	/**
 	 * Function to be called by the owner to send a action completion message
 	 *
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index 0a718aab6..7a859de0d 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -1,5 +1,5 @@
-#ifndef ACTIONMESSAGE_H_
-#define ACTIONMESSAGE_H_
+#ifndef FSFW_ACTION_ACTIONMESSAGE_H_
+#define FSFW_ACTION_ACTIONMESSAGE_H_
 
 #include "../ipc/CommandMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
@@ -18,15 +18,19 @@ public:
 	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
 	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
 	virtual ~ActionMessage();
-	static void setCommand(CommandMessage* message, ActionId_t fid, store_address_t parameters);
+	static void setCommand(CommandMessage* message, ActionId_t fid,
+			store_address_t parameters);
 	static ActionId_t getActionId(const CommandMessage* message );
 	static store_address_t getStoreId(const CommandMessage* message );
-	static void setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	static void setStepReply(CommandMessage* message, ActionId_t fid,
+			uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
 	static uint8_t getStep(const CommandMessage* message );
 	static ReturnValue_t getReturnCode(const CommandMessage* message );
-	static void setDataReply(CommandMessage* message, ActionId_t actionId, store_address_t data);
-	static void setCompletionReply(CommandMessage* message, ActionId_t fid, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+	static void setDataReply(CommandMessage* message, ActionId_t actionId,
+			store_address_t data);
+	static void setCompletionReply(CommandMessage* message, ActionId_t fid,
+			ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
 	static void clear(CommandMessage* message);
 };
 
-#endif /* ACTIONMESSAGE_H_ */
+#endif /* FSFW_ACTION_ACTIONMESSAGE_H_ */
diff --git a/action/CommandsActionsIF.h b/action/CommandsActionsIF.h
index 3d04015d1..491bfc703 100644
--- a/action/CommandsActionsIF.h
+++ b/action/CommandsActionsIF.h
@@ -1,5 +1,5 @@
-#ifndef COMMANDSACTIONSIF_H_
-#define COMMANDSACTIONSIF_H_
+#ifndef FSFW_ACTION_COMMANDSACTIONSIF_H_
+#define FSFW_ACTION_COMMANDSACTIONSIF_H_
 
 #include "CommandActionHelper.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -24,11 +24,14 @@ public:
 	virtual MessageQueueIF* getCommandQueuePtr() = 0;
 protected:
 	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
-	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) = 0;
-	virtual void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) = 0;
+	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
+			ReturnValue_t returnCode) = 0;
+	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
+			uint32_t size) = 0;
 	virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
-	virtual void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) = 0;
+	virtual void completionFailedReceived(ActionId_t actionId,
+			ReturnValue_t returnCode) = 0;
 };
 
 
-#endif /* COMMANDSACTIONSIF_H_ */
+#endif /* FSFW_ACTION_COMMANDSACTIONSIF_H_ */
diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 886d08377..690f03698 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -1,11 +1,12 @@
-#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
-#define FRAMEWORK_ACTION_HASACTIONSIF_H_
+#ifndef FSFW_ACTION_HASACTIONSIF_H_
+#define FSFW_ACTION_HASACTIONSIF_H_
 
 #include "ActionHelper.h"
 #include "ActionMessage.h"
 #include "SimpleActionHelper.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../ipc/MessageQueueIF.h"
+
 /**
  * @brief
  * Interface for component which uses actions
@@ -47,14 +48,16 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	/**
 	 * Execute or initialize the execution of a certain function.
-	 * Returning #EXECUTION_FINISHED or a failure code, nothing else needs to
-	 * be done. When needing more steps, return RETURN_OK and issue steps and
-	 * completion manually.
-	 * One "step failed" or completion report must be issued!
+	 * The ActionHelpers will execute this function and behave differently
+	 * depending on the returnvalue.
+	 *
+	 * @return
+	 * -@c EXECUTION_FINISHED Finish reply will be generated
+	 * -@c Not RETURN_OK Step failure reply will be generated
 	 */
 	virtual ReturnValue_t executeAction(ActionId_t actionId,
 			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
 };
 
 
-#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */
+#endif /* FSFW_ACTION_HASACTIONSIF_H_ */
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index d79a3c977..af57736c8 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -1,16 +1,17 @@
 #include "HasActionsIF.h"
 #include "SimpleActionHelper.h"
+
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
 		MessageQueueIF* useThisQueue) :
-		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
-				0), lastAction(0), stepCount(0) {
+		ActionHelper(setOwner, useThisQueue), isExecuting(false) {
 }
 
 SimpleActionHelper::~SimpleActionHelper() {
 }
 
 void SimpleActionHelper::step(ReturnValue_t result) {
-	//STEP_OFFESET is subtracted to compensate for adding offset in base method, which is not necessary here.
+	// STEP_OFFESET is subtracted to compensate for adding offset in base
+	// method, which is not necessary here.
 	ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
 			result);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/action/SimpleActionHelper.h b/action/SimpleActionHelper.h
index 1329b5fb5..1f35d9fdf 100644
--- a/action/SimpleActionHelper.h
+++ b/action/SimpleActionHelper.h
@@ -1,8 +1,13 @@
-#ifndef SIMPLEACTIONHELPER_H_
-#define SIMPLEACTIONHELPER_H_
+#ifndef FSFW_ACTION_SIMPLEACTIONHELPER_H_
+#define FSFW_ACTION_SIMPLEACTIONHELPER_H_
 
 #include "ActionHelper.h"
 
+/**
+ * @brief	This is an action helper which is only able to service one action
+ * 			at a time but remembers last commander and last action which
+ * 			simplifies usage
+ */
 class SimpleActionHelper: public ActionHelper {
 public:
 	SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
@@ -12,13 +17,14 @@ public:
 	ReturnValue_t reportData(SerializeIF* data);
 
 protected:
-	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId, store_address_t dataAddress);
-	virtual  void resetHelper();
+	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
+			store_address_t dataAddress);
+	virtual void resetHelper();
 private:
 	bool isExecuting;
-	MessageQueueId_t lastCommander;
-	ActionId_t lastAction;
-	uint8_t stepCount;
+	MessageQueueId_t lastCommander = MessageQueueIF::NO_QUEUE;
+	ActionId_t lastAction = 0;
+	uint8_t stepCount = 0;
 };
 
 #endif /* SIMPLEACTIONHELPER_H_ */

From 3fc206801153370773adbabd7b9260b8b13d1c23 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 17:09:16 +0100
Subject: [PATCH 0969/1774] fsfwconfig update

---
 defaultcfg/config/FSFWConfig.h | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index b6255a2fd..ea724a64c 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -2,6 +2,7 @@
 #define CONFIG_FSFWCONFIG_H_
 
 #include <FSFWVersion.h>
+#include <cstddef>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.
@@ -11,8 +12,8 @@
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_REDUCED_PRINTOUT		0
 
-//! Default timestamp size. The default timestamp will be a seven byte CDC short
-//! timestamp.
+//! Default timestamp size. The default timestamp will be an eight byte CDC
+//! short timestamp.
 #define FSFW_MISSION_TIMESTAMP_SIZE 8
 
 //! Can be used to enable debugging printouts for developing the FSFW
@@ -43,5 +44,11 @@
 //! will not be provided. This define should be set to 1 if this is the case.
 #define FSFW_NO_C99_IO 	1
 
+namespace fsfwconfig {
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+}
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

From 777457482b8ea3bb5c78e9b86c5c4e06ed1d08ee Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 17:21:51 +0100
Subject: [PATCH 0970/1774] fixes for internal unittest

---
 events/EventManager.cpp                             |  9 ++++++---
 unittest/internal/InternalUnitTester.cpp            | 13 +++++++------
 unittest/internal/InternalUnitTester.h              |  4 ++--
 unittest/internal/internal.mk                       |  3 +++
 unittest/internal/osal/IntTestMq.cpp                |  4 ++--
 unittest/internal/osal/IntTestMutex.cpp             |  3 ++-
 unittest/internal/osal/IntTestSemaphore.cpp         |  3 ++-
 .../internal/serialize/IntTestSerialization.cpp     |  2 +-
 8 files changed, 25 insertions(+), 16 deletions(-)
 create mode 100644 unittest/internal/internal.mk

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 16ac289d4..acc17b03f 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -11,9 +11,12 @@
 // So a good guess is 75 to a max of 100 pools required for each, which fits well.
 // This should be configurable..
 const LocalPool::LocalPoolConfig EventManager::poolConfig = {
-        {240, sizeof(EventMatchTree::Node)},
-        {120, sizeof(EventIdRangeMatcher)},
-        {120, sizeof(ReporterRangeMatcher)}
+        {fsfwconfig::FSFW_EVENTMGMR_MATCHTREE_NODES,
+        		sizeof(EventMatchTree::Node)},
+        {fsfwconfig::FSFW_EVENTMGMT_EVENTIDMATCHERS,
+        		sizeof(EventIdRangeMatcher)},
+        {fsfwconfig::FSFW_EVENTMGMR_RANGEMATCHERS,
+        		sizeof(ReporterRangeMatcher)}
 };
 
 EventManager::EventManager(object_id_t setObjectId) :
diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
index 7b72d6458..503a71ec3 100644
--- a/unittest/internal/InternalUnitTester.cpp
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -1,9 +1,10 @@
-#include <unittest/internal/InternalUnitTester.h>
-#include <unittest/internal/IntTestMq.h>
-#include <unittest/internal/IntTestSemaphore.h>
-#include <unittest/internal/IntTestSerialization.h>
-#include <unittest/internal/UnittDefinitions.h>
-#include <unittest/internal/IntTestMutex.h>
+#include "InternalUnitTester.h"
+#include "UnittDefinitions.h"
+
+#include "osal/IntTestMq.h"
+#include "osal/IntTestSemaphore.h"
+#include "osal/IntTestMutex.h"
+#include "serialize/IntTestSerialization.h"
 
 #include <cstdlib>
 
diff --git a/unittest/internal/InternalUnitTester.h b/unittest/internal/InternalUnitTester.h
index b61c8bfe4..b301b9232 100644
--- a/unittest/internal/InternalUnitTester.h
+++ b/unittest/internal/InternalUnitTester.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_TEST_UNITTESTCLASS_H_
 #define FRAMEWORK_TEST_UNITTESTCLASS_H_
 
-#include <unittest/internal/UnittDefinitions.h>
+#include "UnittDefinitions.h"
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 /**
@@ -22,7 +22,7 @@ public:
 	 * Some function which calls all other tests
 	 * @return
 	 */
-	ReturnValue_t performTests();
+	virtual ReturnValue_t performTests();
 };
 
 
diff --git a/unittest/internal/internal.mk b/unittest/internal/internal.mk
new file mode 100644
index 000000000..799fd7960
--- /dev/null
+++ b/unittest/internal/internal.mk
@@ -0,0 +1,3 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/osal/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/serialize/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
\ No newline at end of file
diff --git a/unittest/internal/osal/IntTestMq.cpp b/unittest/internal/osal/IntTestMq.cpp
index 265aa62a9..630163743 100644
--- a/unittest/internal/osal/IntTestMq.cpp
+++ b/unittest/internal/osal/IntTestMq.cpp
@@ -1,7 +1,7 @@
 #include <fsfw/ipc/MessageQueueIF.h>
 #include <fsfw/ipc/QueueFactory.h>
-#include <unittest/internal/IntTestMq.h>
-#include <unittest/internal/UnittDefinitions.h>
+#include <fsfw/unittest/internal/osal/IntTestMq.h>
+#include <fsfw/unittest/internal/UnittDefinitions.h>
 
 #include <array>
 
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index bf0b827d9..3fd668dfd 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -1,4 +1,5 @@
-#include <unittest/internal/IntTestMutex.h>
+#include "IntTestMutex.h"
+
 #include <fsfw/ipc/MutexFactory.h>
 #include <unittest/internal/UnittDefinitions.h>
 
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index 176db4de6..534a6a6d5 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -1,8 +1,9 @@
+#include "IntTestSemaphore.h"
 #include <fsfw/tasks/SemaphoreFactory.h>
 #include <unittest/internal/UnittDefinitions.h>
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 #include <fsfw/timemanager/Stopwatch.h>
-#include <unittest/internal/IntTestSemaphore.h>
+
 
 void testsemaph::testBinSemaph() {
 	std::string id = "[BinSemaphore]";
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
index 2452ac6db..3f231a417 100644
--- a/unittest/internal/serialize/IntTestSerialization.cpp
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -1,4 +1,4 @@
-#include <unittest/internal/IntTestSerialization.h>
+#include "IntTestSerialization.h"
 #include <fsfw/serialize/SerializeElement.h>
 #include <fsfw/serialize/SerialBufferAdapter.h>
 #include <unittest/internal/UnittDefinitions.h>

From 641da2aa2184edeab2b3f282615c8ac27b6eae4b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 17:33:22 +0100
Subject: [PATCH 0971/1774] config make update

---
 defaultcfg/config.mk        | 17 -----------------
 defaultcfg/config/config.mk | 15 +++++++++++++++
 2 files changed, 15 insertions(+), 17 deletions(-)
 delete mode 100644 defaultcfg/config.mk
 create mode 100644 defaultcfg/config/config.mk

diff --git a/defaultcfg/config.mk b/defaultcfg/config.mk
deleted file mode 100644
index fcf3b7992..000000000
--- a/defaultcfg/config.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-CXXSRC += $(wildcard $(CURRENTPATH)/config/ipc/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/config/objects/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/config/pollingsequence/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/config/events/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/config/tmtc/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/config/devices/*.cpp)
-
-INCLUDES += $(CURRENTPATH)
-INCLUDES += $(CURRENTPATH)/config/
-INCLUDES += $(CURRENTPATH)/config/objects
-INCLUDES += $(CURRENTPATH)/config/returnvalues
-INCLUDES += $(CURRENTPATH)/config/tmtc
-INCLUDES += $(CURRENTPATH)/config/events
-INCLUDES += $(CURRENTPATH)/config/devices
-INCLUDES += $(CURRENTPATH)/config/pollingsequence
-INCLUDES += $(CURRENTPATH)/config/ipc
-INCLUDES += $(CURRENTPATH)/config/
diff --git a/defaultcfg/config/config.mk b/defaultcfg/config/config.mk
new file mode 100644
index 000000000..51543eba8
--- /dev/null
+++ b/defaultcfg/config/config.mk
@@ -0,0 +1,15 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/tmtc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/devices/*.cpp)
+
+INCLUDES += $(CURRENTPATH)
+INCLUDES += $(CURRENTPATH)/objects
+INCLUDES += $(CURRENTPATH)/returnvalues
+INCLUDES += $(CURRENTPATH)/tmtc
+INCLUDES += $(CURRENTPATH)/events
+INCLUDES += $(CURRENTPATH)/devices
+INCLUDES += $(CURRENTPATH)/pollingsequence
+INCLUDES += $(CURRENTPATH)/ipc

From 6edc2ef1d67f074b57d252ca67650646ae50b202 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 17:42:05 +0100
Subject: [PATCH 0972/1774] class IDs moved

---
 returnvalues/FwClassIds.h | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 120d1e2e7..916c573a3 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -65,9 +65,7 @@ enum {
 	POOL_VARIABLE_IF, //PVA 59
 	HOUSEKEEPING_MANAGER, //HKM 60
 	DLE_ENCODER, //DLEE 61
-	SERIAL_ANALYZER, //SERA 62
-	PUS_SERVICE_9, //PUS9 63
-	FILE_SYSTEM, //FLSY 64
+	PUS_SERVICE_9, //PUS9 62
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From e0a11f3a6edb5a3493e9bc5214a655caf2eea208 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 17:46:44 +0100
Subject: [PATCH 0973/1774] include guard update

---
 returnvalues/FwClassIds.h        |  7 +++----
 returnvalues/HasReturnvaluesIF.h | 10 +++++-----
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 916c573a3..53add6a0a 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_RETURNVALUES_FWCLASSIDS_H_
-#define FRAMEWORK_RETURNVALUES_FWCLASSIDS_H_
+#ifndef FSFW_RETURNVALUES_FWCLASSIDS_H_
+#define FSFW_RETURNVALUES_FWCLASSIDS_H_
 
 namespace CLASS_ID {
 enum {
@@ -56,7 +56,6 @@ enum {
 	DEVICE_COMMUNICATION_IF, //DC
 	BSP, //BSP
 	TIME_STAMPER_IF, //TSI 53
-	//TODO This will shift all IDs for FLP
 	SGP4PROPAGATOR_CLASS, //SGP4 54
 	MUTEX_IF, //MUX 55
 	MESSAGE_QUEUE_IF,//MQI 56
@@ -71,4 +70,4 @@ enum {
 };
 }
 
-#endif /* FRAMEWORK_RETURNVALUES_FWCLASSIDS_H_ */
+#endif /* FSFW_RETURNVALUES_FWCLASSIDS_H_ */
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 9000b23c4..a39ac7423 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
-#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+#ifndef FSFW_RETURNVALUES_HASRETURNVALUESIF_H_
+#define FSFW_RETURNVALUES_HASRETURNVALUESIF_H_
 
-#include "../returnvalues/FwClassIds.h"
-#include <config/returnvalues/classIds.h>
+#include "FwClassIds.h"
+#include <returnvalues/classIds.h>
 #include <cstdint>
 
 #define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
@@ -28,4 +28,4 @@ public:
 	}
 };
 
-#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
+#endif /* FSFW_RETURNVALUES_HASRETURNVALUESIF_H_ */

From 6ea933492368e31217851717f9d880c033cfce17 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 17:57:27 +0100
Subject: [PATCH 0974/1774] parameter updates

---
 parameters/HasParametersIF.h    | 42 ++++++++++-------
 parameters/ParameterHelper.cpp  | 80 +++++++++++++++++----------------
 parameters/ParameterMessage.cpp | 20 ++++++++-
 parameters/ParameterMessage.h   | 35 ++++++++++++++-
 parameters/ParameterWrapper.cpp | 55 ++++++++++++++++++++---
 parameters/ParameterWrapper.h   | 23 +++++++---
 6 files changed, 186 insertions(+), 69 deletions(-)

diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 005403fa5..c4fd81b34 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -1,12 +1,16 @@
 #ifndef FSFW_PARAMETERS_HASPARAMETERSIF_H_
 #define FSFW_PARAMETERS_HASPARAMETERSIF_H_
 
-#include "../parameters/ParameterWrapper.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
+#include "ParameterWrapper.h"
+#include <cstdint>
 
-/** Each parameter is identified with a unique parameter ID */
-typedef uint32_t ParameterId_t;
+/**
+ * Each parameter is identified with a unique parameter ID
+ * The first byte of the parameter ID will denote the domain ID.
+ * The second and third byte will be the unique identifier number.
+ */
+using ParameterId_t = uint32_t;
 
 /**
  * @brief	This interface is used by components which have modifiable
@@ -19,13 +23,13 @@ typedef uint32_t ParameterId_t;
  * 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
+ * Yeah, is it matrix ID or 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;
-	static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t INVALID_IDENTIFIER_ID = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
 	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
 	static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
@@ -34,17 +38,24 @@ public:
 		return id >> 24;
 	}
 
-	static uint16_t getMatrixId(ParameterId_t id) {
-		return id >> 8;
+	static uint8_t getUniqueIdentifierId(ParameterId_t id) {
+		return id >> 16;
 	}
 
-	static uint8_t getIndex(ParameterId_t id) {
+	/**
+	 * Get the index of a parameter. Please note that the index is always a
+	 * linear index. For a vector, this is straightforward.
+	 * For a matrix, the linear indexing run from left to right, top to bottom.
+	 * @param id
+	 * @return
+	 */
+	static uint16_t getIndex(ParameterId_t id) {
 		return id;
 	}
 
-	static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
-			uint8_t index) {
-		return (domainId << 24) + (parameterId << 8) + index;
+	static uint32_t getFullParameterId(uint8_t domainId,
+	        uint8_t uniqueIdentifier, uint16_t linearIndex) {
+		return (domainId << 24) + (uniqueIdentifier << 16) + linearIndex;
 	}
 
 	virtual ~HasParametersIF() {}
@@ -56,11 +67,12 @@ public:
 	 * @param parameterId
 	 * @param parameterWrapper
 	 * @param newValues
-	 * @param startAtIndex
+	 * @param startAtIndex Linear index, runs left to right, top to bottom for
+	 * matrix indexes.
 	 * @return
 	 */
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
+	virtual ReturnValue_t getParameter(uint8_t domainId,
+	        uint16_t uniqueIdentifier, ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
 };
 
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 659b00def..d2193b289 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -9,15 +9,20 @@ ParameterHelper::~ParameterHelper() {
 }
 
 ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
+    if(storage == nullptr) {
+        // ParameterHelper was not initialized
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	switch (message->getCommand()) {
 	case ParameterMessage::CMD_PARAMETER_DUMP: {
 		ParameterWrapper description;
 		uint8_t domain = HasParametersIF::getDomain(
 				ParameterMessage::getParameterId(message));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
+		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
 				ParameterMessage::getParameterId(message));
-		result = owner->getParameter(domain, parameterId,
+		result = owner->getParameter(domain, uniqueIdentifier,
 				&description, &description, 0);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			result = sendParameter(message->getSender(),
@@ -26,49 +31,48 @@ 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(
-				ParameterMessage::getParameterId(message));
-		uint8_t index = HasParametersIF::getIndex(
-				ParameterMessage::getParameterId(message));
+	    ParameterId_t parameterId = 0;
+	    uint8_t ptc = 0;
+	    uint8_t pfc = 0;
+	    uint8_t rows = 0;
+	    uint8_t columns = 0;
+	    store_address_t storeId = ParameterMessage::getParameterLoadCommand(
+	            message, &parameterId, &ptc, &pfc, &rows, &columns);
+	    Type type(Type::getActualType(ptc, pfc));
 
-		const uint8_t *storedStream = nullptr;
-		size_t storedStreamSize = 0;
-		result = storage->getData(
-				ParameterMessage::getStoreId(message), &storedStream,
-				&storedStreamSize);
+		uint8_t domain = HasParametersIF::getDomain(parameterId);
+		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
+		        parameterId);
+		uint16_t linearIndex = HasParametersIF::getIndex(parameterId);
+
+		ConstStorageAccessor accessor(storeId);
+		result = storage->getData(storeId, accessor);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			sif::error << "ParameterHelper::handleParameterMessage: Getting"
-					" store data failed for load command." << std::endl;
+					<< " store data failed for load command." << std::endl;
 			break;
 		}
 
 		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(storedStream, storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
+		result = streamWrapper.set(type, rows, columns, accessor.data(),
+		        accessor.size());
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+		    return result;
 		}
 
 		ParameterWrapper ownerWrapper;
-		result = owner->getParameter(domain, parameterId, &ownerWrapper,
-				&streamWrapper, index);
+		result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
+				&streamWrapper, linearIndex);
+
+		result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
+		    return result;
 		}
 
-		result = ownerWrapper.copyFrom(&streamWrapper, index);
-
-		storage->deleteData(ParameterMessage::getStoreId(message));
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &ownerWrapper);
-		}
-	}
+        result = sendParameter(message->getSender(),
+                ParameterMessage::getParameterId(message), &ownerWrapper);
 		break;
+	}
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -113,15 +117,13 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 }
 
 ReturnValue_t ParameterHelper::initialize() {
-	ownerQueueId = owner->getCommandQueue();
+    ownerQueueId = owner->getCommandQueue();
 
-
-	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (storage == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	} else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if (storage == nullptr) {
+        return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp
index e9f3191fc..af1f9ce83 100644
--- a/parameters/ParameterMessage.cpp
+++ b/parameters/ParameterMessage.cpp
@@ -25,10 +25,26 @@ void ParameterMessage::setParameterDumpReply(CommandMessage* message,
 }
 
 void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
-		ParameterId_t id, store_address_t storageID) {
+		ParameterId_t id, store_address_t storeId, uint8_t ptc, uint8_t pfc,
+		uint8_t rows = 1, uint8_t columns = 1) {
 	message->setCommand(CMD_PARAMETER_LOAD);
 	message->setParameter(id);
-	message->setParameter2(storageID.raw);
+	message->setParameter2(storeId.raw);
+	uint32_t packedParameterSettings = (ptc << 24) | (pfc << 16) |
+	        (rows << 8) | columns;
+	message->setParameter3(packedParameterSettings);
+}
+
+store_address_t ParameterMessage::getParameterLoadCommand(
+        const CommandMessage *message, ParameterId_t* parameterId, uint8_t *ptc,
+        uint8_t *pfc, uint8_t *rows, uint8_t *columns) {
+    *parameterId = message->getParameter2();
+    uint32_t packedParamSettings = message->getParameter3();
+    *ptc = packedParamSettings >> 24 & 0xff;
+    *pfc = packedParamSettings >> 16 & 0xff;
+    *rows = packedParamSettings >> 8 & 0xff;
+    *columns = packedParamSettings & 0xff;
+    return message->getParameter2();
 }
 
 void ParameterMessage::clear(CommandMessage* message) {
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 31d7fe0bc..fd4481eec 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -5,6 +5,20 @@
 #include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
 
+/**
+ * @brief   ParameterMessage interface
+ * @details
+ * General structure of a parameter message:
+ *  1. 4-byte Object ID
+ *  2. 4-byte Parameter ID, first byte is Domain ID, second byte is unique
+ *     identifier, third and fourth byte is linear index to start from
+ *  3. 4-byte Parameter Settings. First byte and second byte are the PTC and PFC
+ *     ECSS type identifiers (see ECSS-E-ST-70-41C15 p.428 or Type class in
+ *     globalfunctions). Third byte is the number of rows and fourth byte
+ *     is the number of columns. For single variable parameters, this will
+ *     be [1, 1].
+ *
+ */
 class ParameterMessage {
 private:
 	ParameterMessage();
@@ -20,8 +34,27 @@ public:
 			ParameterId_t id);
 	static void setParameterDumpReply(CommandMessage* message,
 			ParameterId_t id,  store_address_t storageID);
+
+	/**
+	 * Command to set a load parameter message. The CCSDS / ECSS type in
+	 * form of a PTC and a PFC is expected. See ECSS-E-ST-70-41C15 p.428
+	 * for all types or the Type class in globalfunctions.
+	 * @param message
+	 * @param id
+	 * @param storeId
+	 * @param ptc Type information according to CCSDS/ECSS standards
+	 * @param pfc Type information according to CCSDS/ECSS standards
+	 * @param rows Set number of rows in parameter set, minimum one.
+	 * @param columns Set number of columns in parameter set, minimum one
+	 */
 	static void setParameterLoadCommand(CommandMessage* message,
-			ParameterId_t id, store_address_t storageID);
+	        ParameterId_t id, store_address_t storeId, uint8_t ptc,
+	        uint8_t pfc, uint8_t rows, uint8_t columns);
+
+	static store_address_t getParameterLoadCommand(
+	        const CommandMessage* message, ParameterId_t* parameterId,
+	        uint8_t* ptc, uint8_t* pfc, uint8_t* rows, uint8_t* columns) ;
+
 	static void clear(CommandMessage* message);
 
 };
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 6adc6857c..239555162 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -115,7 +115,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 		uint8_t fromColumns) {
 
 	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t*) from;
+	const uint8_t *fromAsStream = reinterpret_cast<const uint8_t*>(from);
 	size_t streamSize = fromRows * fromColumns * sizeof(T);
 
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
@@ -123,8 +123,8 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
 		//get the start element of this row in data
-		T *dataWithDataType = ((T*) data)
-				+ (((startingRow + fromRow) * columns) + startingColumn);
+	    uint16_t offset = (((startingRow + fromRow) * columns) + startingColumn);
+		T *dataWithDataType = static_cast<T*>(data) + offset;
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
 			result = SerializeAdapter::deSerialize(
@@ -159,6 +159,23 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
 	return copyFrom(&streamDescription, startWritingAtIndex);
 }
 
+ReturnValue_t ParameterWrapper::set(Type type, uint8_t rows, uint8_t columns,
+        const void *data, size_t dataSize) {
+    this->type = type;
+    this->rows = rows;
+    this->columns = columns;
+
+    size_t expectedSize = type.getSize() * rows * columns;
+    if (expectedSize < dataSize) {
+        return SerializeIF::STREAM_TOO_SHORT;
+    }
+
+    this->data = nullptr;
+    this->readonlyData = data;
+    pointsToStream = true;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
 		const uint8_t **remainingStream, size_t *remainingSize) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
@@ -202,11 +219,13 @@ ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
 
 ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		uint16_t startWritingAtIndex) {
-	if (data == NULL) {
+    // TODO: Optional diagnostic output (which can be disabled in FSFWConfig)
+    // to determined faulty implementations and configuration errors quickly.
+	if (data == nullptr) {
 		return READONLY;
 	}
 
-	if (from->readonlyData == NULL) {
+	if (from->readonlyData == nullptr) {
 		return SOURCE_NOT_SET;
 	}
 
@@ -214,9 +233,16 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		return DATATYPE_MISSMATCH;
 	}
 
+	// The smallest allowed value for rows and columns is one.
+	if(rows == 0 or columns == 0) {
+	    return COLUMN_OR_ROWS_ZERO;
+	}
+
 	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
+	uint8_t startingRow = 0;
+	uint8_t startingColumn = 0;
+	ParameterWrapper::convertLinearIndexToRowAndColumn(startWritingAtIndex,
+	        &startingRow, &startingColumn);
 
 	if ((from->rows > (rows - startingRow))
 			|| (from->columns > (columns - startingColumn))) {
@@ -279,3 +305,18 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 
 	return result;
 }
+
+void ParameterWrapper::convertLinearIndexToRowAndColumn(uint16_t index,
+        uint8_t *row, uint8_t *column) {
+    if(row == nullptr or column == nullptr) {
+        return;
+    }
+    // Integer division.
+    *row = index / columns;
+    *column = index % columns;
+}
+
+uint16_t ParameterWrapper::convertRowAndColumnToLinearIndex(uint8_t row,
+        uint8_t column) {
+    return row * columns + column;
+}
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index f07205d4b..168a535f2 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -22,6 +22,7 @@ public:
 	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
 	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
 	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
+	static const ReturnValue_t COLUMN_OR_ROWS_ZERO = MAKE_RETURN_CODE(0x08);
 
 	ParameterWrapper();
 	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
@@ -68,7 +69,7 @@ public:
 
 	template<typename T>
 	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
-		this->data = NULL;
+		this->data = nullptr;
 		this->readonlyData = readonlyData;
 		this->type = PodTypeConversion<T>::type;
 		this->rows = rows;
@@ -97,14 +98,19 @@ public:
 	}
 	template<typename T>
 	void setMatrix(T& member) {
-		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+		this->set(member[0], sizeof(member)/sizeof(member[0]),
+		        sizeof(member[0])/sizeof(member[0][0]));
 	}
 
 	template<typename T>
 	void setMatrix(const T& member) {
-		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+		this->set(member[0], sizeof(member)/sizeof(member[0]),
+		        sizeof(member[0])/sizeof(member[0][0]));
 	}
 
+	ReturnValue_t set(Type type, uint8_t rows, uint8_t columns,
+	        const void *data, size_t dataSize);
+
 	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
 			const uint8_t **remainingStream = nullptr,
 			size_t *remainingSize = nullptr);
@@ -113,6 +119,13 @@ public:
 			uint16_t startWritingAtIndex);
 
 private:
+
+    void convertLinearIndexToRowAndColumn(uint16_t index,
+            uint8_t *row, uint8_t *column);
+
+    uint16_t convertRowAndColumnToLinearIndex(uint8_t row,
+            uint8_t column);
+
 	bool pointsToStream = false;
 
 	Type type;
@@ -148,9 +161,9 @@ inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
 	if (pointsToStream) {
 		const uint8_t *streamWithType = static_cast<const uint8_t*>(readonlyData);
 		streamWithType += (row * columns + column) * type.getSize();
-		int32_t size = type.getSize();
+		size_t size = type.getSize();
 		return SerializeAdapter::deSerialize(value, &streamWithType,
-				&size, true);
+				&size, SerializeIF::Endianness::BIG);
 	}
 	else {
 		const T *dataWithType = static_cast<const T*>(readonlyData);

From aed7f31f24cfd2a0b83117de8925a250c16e2917 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 2 Nov 2020 15:47:09 +0100
Subject: [PATCH 0975/1774] health changes taken over

---
 health/HealthTable.cpp | 19 ++++++++++++-------
 health/HealthTable.h   |  5 +++++
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 6d6fe0172..2b8b67127 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -10,6 +10,12 @@ HealthTable::HealthTable(object_id_t objectid) :
 	mapIterator = healthMap.begin();
 }
 
+void HealthTable::setMutexTimeout(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	this->timeoutType = timeoutType;
+	this->mutexTimeoutMs = timeoutMs;
+}
+
 HealthTable::~HealthTable() {
 	MutexFactory::instance()->deleteMutex(mutex);
 }
@@ -25,7 +31,7 @@ ReturnValue_t HealthTable::registerObject(object_id_t object,
 
 void HealthTable::setHealth(object_id_t object,
 		HasHealthIF::HealthState newState) {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		iter->second = newState;
@@ -34,7 +40,7 @@ void HealthTable::setHealth(object_id_t object,
 
 HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+	MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		state = iter->second;
@@ -42,9 +48,8 @@ HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 	return state;
 }
 
-
 bool HealthTable::hasHealth(object_id_t object) {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+	MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		return true;
@@ -53,14 +58,14 @@ bool HealthTable::hasHealth(object_id_t object) {
 }
 
 size_t HealthTable::getPrintSize() {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    MutexHelper(mutex, timeoutType, mutexTimeoutMs);
     uint32_t size = healthMap.size() * sizeof(object_id_t) +
             sizeof(HasHealthIF::HealthState) + sizeof(uint16_t);
     return size;
 }
 
 void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	size_t size = 0;
 	uint16_t count = healthMap.size();
 	SerializeAdapter::serialize(&count,
@@ -76,7 +81,7 @@ void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
 
 ReturnValue_t HealthTable::iterate(HealthEntry *value, bool reset) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+	MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	if (reset) {
 		mapIterator = healthMap.begin();
 	}
diff --git a/health/HealthTable.h b/health/HealthTable.h
index 945fb2e67..cea34f684 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -12,6 +12,8 @@ public:
 	HealthTable(object_id_t objectid);
 	virtual ~HealthTable();
 
+	void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
+
     /** HealthTableIF overrides */
     virtual ReturnValue_t registerObject(object_id_t object,
             HasHealthIF::HealthState initilialState =
@@ -30,6 +32,9 @@ protected:
 	using HealthEntry = std::pair<object_id_t, HasHealthIF::HealthState>;
 
 	MutexIF* mutex;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	uint32_t mutexTimeoutMs = 20;
+
 	HealthMap healthMap;
 
 	HealthMap::iterator mapIterator;

From 41bf5622f313c205a931d5bc439b4302ccdc0af9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 2 Nov 2020 15:50:14 +0100
Subject: [PATCH 0976/1774] master taken over

---
 unittest/README.md                   | 10 ++++++++++
 unittest/testcfg/Makefile-FSFW-Tests |  2 +-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/unittest/README.md b/unittest/README.md
index e628d43e8..8a787c07a 100644
--- a/unittest/README.md
+++ b/unittest/README.md
@@ -7,6 +7,16 @@ The makefile with default settings creates the unit test binary which can be
 run in the terminal or in eclipse.
 
 ### Instructions
+
+To run the fsfw unittests in the project, perform following steps:
+
+1. Copy the testcfg folder  the project root (folder containing the FSFW).
+2. There is a makefile inside the testcfg folder which can be used to have 
+   a starting point to compile the unit tests. Copy that Makefile to the project
+   root
+3. Create a folder named catch2 (can have other name which requires Makefile 
+   adaption) and copy the Catch2 header files there (NOTE: CMake support
+   not enabled yet!)
    
 ### Eclipse CDT settings
 
diff --git a/unittest/testcfg/Makefile-FSFW-Tests b/unittest/testcfg/Makefile-FSFW-Tests
index d43a6edcd..2017d2bd8 100644
--- a/unittest/testcfg/Makefile-FSFW-Tests
+++ b/unittest/testcfg/Makefile-FSFW-Tests
@@ -1,5 +1,5 @@
 #-------------------------------------------------------------------------------
-# Makefile  for FSFW Test
+# Makefile for FSFW Test
 #-------------------------------------------------------------------------------
 #		User-modifiable options
 #-------------------------------------------------------------------------------

From cd71a9cc12fc799905f781a0e2453e28590bffe7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 2 Nov 2020 15:53:08 +0100
Subject: [PATCH 0977/1774] fsfw container taken over

---
 container/IndexedRingMemoryArray.h | 93 ++++++++++++------------------
 container/SharedRingBuffer.cpp     |  2 +-
 container/SharedRingBuffer.h       | 10 +++-
 container/group.h                  |  8 ++-
 4 files changed, 51 insertions(+), 62 deletions(-)

diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 0968abfa7..0d85b49bc 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -1,34 +1,27 @@
 #ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
 #define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
 
-#include "../container/ArrayList.h"
+#include "ArrayList.h"
 #include "../globalfunctions/CRC.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerialArrayListAdapter.h"
 #include <cmath>
 
-/**
- * Index is the Type used for the list of indices.
- *
- * @tparam T Type which destribes the index. Needs to be a child of SerializeIF
- * 			 to be able to make it persistent
- */
 template<typename T>
 class Index: public SerializeIF{
 	/**
-	 *
+	 * Index is the Type used for the list of indices. The template parameter is the type which describes the index, it needs to be a child of SerializeIF to be able to make it persistent
 	 */
-	static_assert(std::is_base_of<SerializeIF,T>::value,
-			"Wrong Type for Index, Type must implement SerializeIF");
+	static_assert(std::is_base_of<SerializeIF,T>::value,"Wrong Type for Index, Type must implement SerializeIF");
 public:
 	Index():blockStartAddress(0),size(0),storedPackets(0){}
 
-	Index(uint32_t startAddress):blockStartAddress(startAddress),
-			size(0),storedPackets(0) {
+	Index(uint32_t startAddress):blockStartAddress(startAddress),size(0),storedPackets(0){
+
 	}
 
-	void setBlockStartAddress(uint32_t newAddress) {
+	void setBlockStartAddress(uint32_t newAddress){
 		this->blockStartAddress = newAddress;
 	}
 
@@ -40,7 +33,7 @@ public:
 		return &indexType;
 	}
 
-	T* modifyIndexType() {
+	T* modifyIndexType(){
 		return &indexType;
 	}
 	/**
@@ -135,35 +128,26 @@ private:
 };
 
 
-/**
- * @brief Indexed Ring Memory Array is a class for a ring memory with indices.
- * @details
- * It assumes that the newest data comes in last
- * It uses the currentWriteBlock as pointer to the current writing position
- * The currentReadBlock must be set manually
- * @tparam T
- */
+
 template<typename T>
 class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
 	/**
-	 *
+	 * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest data comes in last
+	 * It uses the currentWriteBlock as pointer to the current writing position
+	 * The currentReadBlock must be set manually
 	 */
 public:
-	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
-			SerializeIF* additionalInfo, bool overwriteOld):
-			ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),
-			indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),
-			lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld)
-	{
+	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock, SerializeIF* additionalInfo,
+			bool overwriteOld) :ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld){
+
 		//Calculate the maximum number of indices needed for this blocksize
 		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
 
 		//Calculate the Size needeed for the index itself
-		size_t serializedSize = 0;
-		if(additionalInfo!=NULL) {
+		uint32_t serializedSize = 0;
+		if(additionalInfo!=NULL){
 			serializedSize += additionalInfo->getSerializedSize();
 		}
-
 		//Size of current iterator type
 		Index<T> tempIndex;
 		serializedSize += tempIndex.getSerializedSize();
@@ -178,7 +162,6 @@ public:
 			error << "IndexedRingMemory: Store is too small for index" << std::endl;
 		}
 		uint32_t useableSize = totalSize - serializedSize;
-
 		//Update the totalSize for calculations
 		totalSize = useableSize;
 
@@ -195,10 +178,12 @@ public:
 		this->allocated = true;
 
 		//Check trueNumberOfBlocks
-		if(trueNumberOfBlocks<1) {
+		if(trueNumberOfBlocks<1){
 			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
 		}
 
+
+
 		//Fill address into index
 		uint32_t address = trueStartAddress;
 		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
@@ -208,6 +193,7 @@ public:
 			address += bytesPerBlock;
 		}
 
+
 		//Initialize iterators
 		currentWriteBlock = this->begin();
 		currentReadBlock = this->begin();
@@ -246,10 +232,10 @@ public:
 		(*typeResetFnc)(it->modifyIndexType());
 	}
 
-	/**
+	/*
 	 * Reading
-	 * @param it
 	 */
+
 	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
 		currentReadBlock = it;
 		currentReadBlockSizeCached = it->getSize();
@@ -262,7 +248,6 @@ public:
 		lastBlockToRead = currentWriteBlock;
 		lastBlockToReadSize = currentWriteBlock->getSize();
 	}
-
 	/**
 	 * Sets the last block to read to this iterator.
 	 * Can be used to dump until block x
@@ -307,39 +292,33 @@ public:
 	uint32_t getCurrentReadAddress() const {
 		return getAddressOfCurrentReadBlock() + currentReadSize;
 	}
-
 	/**
-	 * Adds readSize to the current size and checks if the read has no more data
-	 * left and advances the read block.
+	 * Adds readSize to the current size and checks if the read has no more data left and advances the read block
 	 * @param readSize The size that was read
 	 * @return Returns true if the read can go on
 	 */
 	bool addReadSize(uint32_t readSize) {
-		if(currentReadBlock == lastBlockToRead) {
+		if(currentReadBlock == lastBlockToRead){
 			//The current read block is the last to read
-			if((currentReadSize+readSize)<lastBlockToReadSize) {
+			if((currentReadSize+readSize)<lastBlockToReadSize){
 				//the block has more data -> return true
 				currentReadSize += readSize;
 				return true;
-			}
-			else {
+			}else{
 				//Reached end of read -> return false
 				currentReadSize = lastBlockToReadSize;
 				return false;
 			}
-		}
-		else {
+		}else{
 			//We are not in the last Block
-			if((currentReadSize + readSize)<currentReadBlockSizeCached) {
+			if((currentReadSize + readSize)<currentReadBlockSizeCached){
 				//The current Block has more data
 				currentReadSize += readSize;
 				return true;
-			}
-			// TODO: Maybe some logic blocks should be extracted
-			else {
+			}else{
 				//The current block is written completely
 				readNext();
-				if(currentReadBlockSizeCached==0) {
+				if(currentReadBlockSizeCached==0){
 					//Next block is empty
 					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
 					//Search if any block between this and the last block is not empty
@@ -442,13 +421,13 @@ public:
 	T* modifyCurrentWriteBlockIndexType(){
 		return currentWriteBlock->modifyIndexType();
 	}
-
 	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
 		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
 		it->addSize(size);
 		it->addStoredPackets(storedPackets);
 	}
 
+
 	/**
 	 * Checks if the block has enough space for sizeToWrite
 	 * @param sizeToWrite The data to be written in the Block
@@ -457,10 +436,7 @@ public:
 	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
 		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
 		uint32_t addressOfNextBlock = next->getBlockStartAddress();
-		uint32_t availableSize =
-				( ( addressOfNextBlock + totalSize ) -
-				(getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock()))
-				% totalSize;
+		uint32_t availableSize = ((addressOfNextBlock+totalSize) - (getAddressOfCurrentWriteBlock()+getSizeOfCurrentWriteBlock()))%totalSize;
 		return (sizeToWrite < availableSize);
 	}
 
@@ -550,7 +526,7 @@ public:
 	 */
 	size_t getSerializedSize() const {
 
-		size_t size = 0;
+		uint32_t size = 0;
 		if(additionalInfo!=NULL){
 			size += additionalInfo->getSerializedSize();
 		}
@@ -718,4 +694,7 @@ private:
 
 };
 
+
+
+
 #endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 48bdb9dfd..6ddb3d3ee 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -18,7 +18,7 @@ SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
 }
 
 
-void SharedRingBuffer::setToUseReceiveSizeFIFO(uint32_t fifoDepth) {
+void SharedRingBuffer::setToUseReceiveSizeFIFO(size_t fifoDepth) {
 	this->fifoDepth = fifoDepth;
 }
 
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index fdc9d6267..64d7ee291 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -27,7 +27,15 @@ public:
 	SharedRingBuffer(object_id_t objectId, const size_t size,
 			bool overwriteOld, size_t maxExcessBytes);
 
-	void setToUseReceiveSizeFIFO(uint32_t fifoDepth);
+	/**
+	 * @brief	This function can be used to add an optional FIFO to the class
+	 * @details 
+	 * This FIFO will be allocated in the initialize function (and will
+	 * have a fixed maximum size after that). It can be used to store
+	 * values like packet sizes, for example for a shared ring buffer
+	 * used by producer/consumer tasks.
+	 */
+	void setToUseReceiveSizeFIFO(size_t fifoDepth);
 
 	/**
 	 * This constructor takes an external buffer with the specified size.
diff --git a/container/group.h b/container/group.h
index 9c70d5236..5a39d34ec 100644
--- a/container/group.h
+++ b/container/group.h
@@ -4,9 +4,11 @@
 /**
  * @defgroup container Container
  *
- * General Purpose Containers to store various elements.
- * As opposed to the STL library implementation, these implementations
- * don't  allocate memory dynamically.
+ * General Purpose Container to store various elements.
+ *
+ * Also contains Adapter classes to print elements to a
+ * bytestream and to read them from a bytestream, as well
+ * as an Adapter to swap the endianness.
  */
 
 

From b71ccf8dd8274b6dc00dcec74e412bad25c812cd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 15:28:55 +0100
Subject: [PATCH 0978/1774] some refactoring

---
 datapoollocal/LocalDataPoolManager.cpp | 234 +++++++++++++------------
 datapoollocal/LocalDataPoolManager.h   |   7 +
 2 files changed, 133 insertions(+), 108 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index d89f597e4..65a40298b 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -101,120 +101,15 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
             break;
         }
         case(ReportingType::UPDATE_HK): {
-            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-                // Update packets shall only be generated from datasets.
-                continue;
-            }
-            LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                    receiver.dataId.sid);
-            if(dataSet->hasChanged()) {
-                // prepare and send update notification
-                ReturnValue_t result = generateHousekeepingPacket(
-                            receiver.dataId.sid, dataSet, true);
-                if(result != HasReturnvaluesIF::RETURN_OK) {
-                    status = result;
-                }
-            }
-            handleChangeResetLogic(receiver.dataType, receiver.dataId,
-                    dataSet);
+            handleHkUpdate(receiver, status);
             break;
         }
         case(ReportingType::UPDATE_NOTIFICATION): {
-            MarkChangedIF* toReset = nullptr;
-            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-                LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                        receiver.dataId.localPoolId);
-                if(poolObj == nullptr) {
-                    continue;
-                }
-                if(poolObj->hasChanged()) {
-                    // prepare and send update notification.
-                    CommandMessage notification;
-                    HousekeepingMessage::setUpdateNotificationVariableCommand(
-                            &notification, receiver.dataId.localPoolId);
-                    ReturnValue_t result = hkQueue->sendMessage(
-                            receiver.destinationQueue, &notification);
-                    if(result != HasReturnvaluesIF::RETURN_OK) {
-                        status = result;
-                    }
-                    toReset = poolObj;
-                }
-
-            }
-            else {
-                LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                        receiver.dataId.sid);
-                if(dataSet == nullptr) {
-                    continue;
-                }
-                if(dataSet->hasChanged()) {
-                    // prepare and send update notification
-                    CommandMessage notification;
-                    HousekeepingMessage::setUpdateNotificationSetCommand(
-                            &notification, receiver.dataId.sid);
-                    ReturnValue_t result = hkQueue->sendMessage(
-                            receiver.destinationQueue, &notification);
-                    if(result != HasReturnvaluesIF::RETURN_OK) {
-                        status = result;
-                    }
-                    toReset = dataSet;
-                }
-            }
-            if(toReset != nullptr) {
-                handleChangeResetLogic(receiver.dataType,
-                        receiver.dataId, toReset);
-            }
+            handleNotificationUpdate(receiver, status);
             break;
         }
         case(ReportingType::UPDATE_SNAPSHOT): {
-            MarkChangedIF* toReset = nullptr;
-            // check whether data has changed and send messages in case it has.
-            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-                LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                        receiver.dataId.localPoolId);
-                if(poolObj == nullptr) {
-                    continue;
-                }
-                if(poolObj->hasChanged()) {
-                    // prepare and send update snapshot.
-                    CommandMessage notification;
-                    // todo: serialize into store with timestamp.
-                    store_address_t storeId;
-                    HousekeepingMessage::setUpdateSnapshotSetCommand(
-                            &notification, receiver.dataId.sid, storeId);
-                    ReturnValue_t result = hkQueue->sendMessage(
-                            receiver.destinationQueue, &notification);
-                    if(result != HasReturnvaluesIF::RETURN_OK) {
-                        status = result;
-                    }
-                    toReset = poolObj;
-                }
-            }
-            else {
-                LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                        receiver.dataId.sid);
-                if(dataSet == nullptr) {
-                    continue;
-                }
-                if(dataSet->hasChanged()) {
-                    // prepare and send update snapshot.
-                    CommandMessage notification;
-                    // todo: serialize into store with timestamp.
-                    store_address_t storeId;
-                    HousekeepingMessage::setUpdateSnapshotVariableCommand(
-                            &notification, receiver.dataId.localPoolId, storeId);
-                    ReturnValue_t result = hkQueue->sendMessage(
-                            receiver.destinationQueue, &notification);
-                    if(result != HasReturnvaluesIF::RETURN_OK) {
-                        status = result;
-                    }
-                    toReset = dataSet;
-                }
-            }
-            if(toReset != nullptr) {
-                handleChangeResetLogic(receiver.dataType,
-                        receiver.dataId, toReset);
-            }
+            handleNotificationSnapshot(receiver, status);
             break;
         }
         default:
@@ -226,6 +121,129 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
     return status;
 }
 
+ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
+            ReturnValue_t& status) {
+    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+        // Update packets shall only be generated from datasets.
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+            receiver.dataId.sid);
+    if(dataSet->hasChanged()) {
+        // prepare and send update notification
+        ReturnValue_t result = generateHousekeepingPacket(
+                    receiver.dataId.sid, dataSet, true);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            status = result;
+        }
+    }
+    handleChangeResetLogic(receiver.dataType, receiver.dataId,
+            dataSet);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
+        HkReceiver& receiver, ReturnValue_t& status) {
+    MarkChangedIF* toReset = nullptr;
+    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+                receiver.dataId.localPoolId);
+        if(poolObj == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        if(poolObj->hasChanged()) {
+            // prepare and send update notification.
+            CommandMessage notification;
+            HousekeepingMessage::setUpdateNotificationVariableCommand(
+                    &notification, receiver.dataId.localPoolId);
+            ReturnValue_t result = hkQueue->sendMessage(
+                    receiver.destinationQueue, &notification);
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                status = result;
+            }
+            toReset = poolObj;
+        }
+
+    }
+    else {
+        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                receiver.dataId.sid);
+        if(dataSet == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        if(dataSet->hasChanged()) {
+            // prepare and send update notification
+            CommandMessage notification;
+            HousekeepingMessage::setUpdateNotificationSetCommand(
+                    &notification, receiver.dataId.sid);
+            ReturnValue_t result = hkQueue->sendMessage(
+                    receiver.destinationQueue, &notification);
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                status = result;
+            }
+            toReset = dataSet;
+        }
+    }
+    if(toReset != nullptr) {
+        handleChangeResetLogic(receiver.dataType,
+                receiver.dataId, toReset);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
+        HkReceiver& receiver, ReturnValue_t& status) {
+    MarkChangedIF* toReset = nullptr;
+     // check whether data has changed and send messages in case it has.
+     if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+                 receiver.dataId.localPoolId);
+         if(poolObj == nullptr) {
+             return HasReturnvaluesIF::RETURN_FAILED;
+         }
+         if(poolObj->hasChanged()) {
+             // prepare and send update snapshot.
+             CommandMessage notification;
+             // todo: serialize into store with timestamp.
+             store_address_t storeId;
+             HousekeepingMessage::setUpdateSnapshotSetCommand(
+                     &notification, receiver.dataId.sid, storeId);
+             ReturnValue_t result = hkQueue->sendMessage(
+                     receiver.destinationQueue, &notification);
+             if(result != HasReturnvaluesIF::RETURN_OK) {
+                 status = result;
+             }
+             toReset = poolObj;
+         }
+     }
+     else {
+         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                 receiver.dataId.sid);
+         if(dataSet == nullptr) {
+             return HasReturnvaluesIF::RETURN_FAILED;
+         }
+         if(dataSet->hasChanged()) {
+             // prepare and send update snapshot.
+             CommandMessage notification;
+             // todo: serialize into store with timestamp.
+             store_address_t storeId;
+             HousekeepingMessage::setUpdateSnapshotVariableCommand(
+                     &notification, receiver.dataId.localPoolId, storeId);
+             ReturnValue_t result = hkQueue->sendMessage(
+                     receiver.destinationQueue, &notification);
+             if(result != HasReturnvaluesIF::RETURN_OK) {
+                 status = result;
+             }
+             toReset = dataSet;
+         }
+     }
+     if(toReset != nullptr) {
+         handleChangeResetLogic(receiver.dataType,
+                 receiver.dataId, toReset);
+     }
+     return HasReturnvaluesIF::RETURN_OK;
+}
+
 void LocalDataPoolManager::handleChangeResetLogic(
         DataType type, DataId dataId, MarkChangedIF* toReset) {
     if(hkUpdateResetList == nullptr) {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index afe827605..a5cd0f98c 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -350,6 +350,13 @@ private:
 	void handleChangeResetLogic(DataType type,
 	        DataId dataId, MarkChangedIF* toReset);
 	void resetHkUpdateResetHelper();
+
+	ReturnValue_t handleHkUpdate(HkReceiver& hkReceiver,
+            ReturnValue_t& status);
+	ReturnValue_t handleNotificationUpdate(HkReceiver& hkReceiver,
+	        ReturnValue_t& status);
+	ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver,
+            ReturnValue_t& status);
 };
 
 

From 38b5695a1008af28ecd783b437770b08775bd2ab Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 15:45:04 +0100
Subject: [PATCH 0979/1774] size check + include guard

---
 datapoollocal/LocalPoolDataSetBase.cpp  | 11 ++++++++++-
 housekeeping/HousekeepingPacketUpdate.h |  6 +++---
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 5bb71cb64..5cd4b62b6 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -81,6 +81,10 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
             return result;
         }
     }
+
+    if(*size + validityMaskSize > maxSize) {
+        return SerializeIF::BUFFER_TOO_SHORT;
+    }
     // copy validity buffer to end
     std::memcpy(*buffer, validityMask, validityMaskSize);
     *size += validityMaskSize;
@@ -98,9 +102,13 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
             return result;
         }
     }
+
+    if(*size < std::ceil(static_cast<float>(fillCount) / 8.0)) {
+        return SerializeIF::STREAM_TOO_SHORT;
+    }
+
     uint8_t validBufferIndex = 0;
     uint8_t validBufferIndexBit = 0;
-    // could be made more efficient but make it work first
     for (uint16_t count = 0; count < fillCount; count++) {
         // set validity buffer here.
         bool nextVarValid = this->bitGetter(*buffer +
@@ -117,6 +125,7 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
     }
     return result;
 }
+
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
 	MutexIF* mutex = hkManager->getMutexHandle();
 	return mutex->unlockMutex();
diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index eebdc11cc..37d38be75 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
-#define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
 
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialLinkedListAdapter.h"
@@ -70,4 +70,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_ */
+#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_ */

From 633203eb5406adbf3d4f48e1cbcc6397352fe19d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 15:50:55 +0100
Subject: [PATCH 0980/1774] upstream time stamper taken over

---
 datapoollocal/LocalDataPoolManager.cpp | 3 +++
 timemanager/TimeStamperIF.h            | 8 ++++++--
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 65a40298b..7706db31a 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -2,8 +2,10 @@
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
 
+#include "../housekeeping/HousekeepingPacketUpdate.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
+
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
 #include "../ipc/QueueFactory.h"
@@ -205,6 +207,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
              // prepare and send update snapshot.
              CommandMessage notification;
              // todo: serialize into store with timestamp.
+             HousekeepingPacketUpdate updatePacket()
              store_address_t storeId;
              HousekeepingMessage::setUpdateSnapshotSetCommand(
                      &notification, receiver.dataId.sid, storeId);
diff --git a/timemanager/TimeStamperIF.h b/timemanager/TimeStamperIF.h
index bdc5e7e37..96011088d 100644
--- a/timemanager/TimeStamperIF.h
+++ b/timemanager/TimeStamperIF.h
@@ -14,8 +14,12 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::TIME_STAMPER_IF;
 	static const ReturnValue_t BAD_TIMESTAMP = MAKE_RETURN_CODE(1);
 
-	static const uint8_t MISSION_TIMESTAMP_SIZE = 8; //!< This is a mission-specific constant and determines the total size reserved for timestamps.
-	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize) = 0;
+	//! This is a mission-specific constant and determines the total
+	//! size reserved for timestamps.
+	//! TODO: Default define in FSFWConfig ?
+	static const uint8_t MISSION_TIMESTAMP_SIZE = 8;
+	virtual ReturnValue_t addTimeStamp(uint8_t* buffer,
+	        const uint8_t maxSize) = 0;
 	virtual ~TimeStamperIF() {}
 };
 

From 83f0b4bffc25dd4f8619220401a0f5ed2f1c1e15 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 15:51:56 +0100
Subject: [PATCH 0981/1774] defaultcfg changes taken over

---
 defaultcfg/config/FSFWConfig.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index ea724a64c..ea86152cb 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -12,10 +12,6 @@
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_REDUCED_PRINTOUT		0
 
-//! Default timestamp size. The default timestamp will be an eight byte CDC
-//! short timestamp.
-#define FSFW_MISSION_TIMESTAMP_SIZE 8
-
 //! Can be used to enable debugging printouts for developing the FSFW
 #define FSFW_DEBUGGING              0
 
@@ -45,6 +41,10 @@
 #define FSFW_NO_C99_IO 	1
 
 namespace fsfwconfig {
+//! Default timestamp size. The default timestamp will be an eight byte CDC
+//! short timestamp.
+static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 8;
+
 //! Configure the allocated pool sizes for the event manager.
 static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
 static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;

From dcf36d4ceebc8c70f4d17f14fd1cdf78fa4969ea Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 15:54:27 +0100
Subject: [PATCH 0982/1774] cstdint include added

---
 defaultcfg/config/FSFWConfig.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index ea86152cb..be3717b40 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -3,6 +3,7 @@
 
 #include <FSFWVersion.h>
 #include <cstddef>
+#include <cstdint>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.

From 81f5783d371bdf3b3521d8c37a59592bf7d45b79 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 16:06:30 +0100
Subject: [PATCH 0983/1774] clock update, definitions file

---
 datapoollocal/LocalDataPoolManager.cpp      |  4 +-
 pus/Service9TimeManagement.cpp              |  2 +-
 serviceinterface/ServiceInterfaceBuffer.cpp |  2 +-
 timemanager/CCSDSTime.cpp                   | 22 ++++-----
 timemanager/CCSDSTime.h                     | 25 +++++-----
 timemanager/Clock.h                         | 55 ++++++++++++---------
 timemanager/ReceivesTimeInfoIF.h            | 12 ++---
 timemanager/TimeMessage.h                   | 15 ++----
 timemanager/TimeStamperIF.h                 |  6 +--
 timemanager/clockDefinitions.h              | 22 +++++++++
 10 files changed, 92 insertions(+), 73 deletions(-)
 create mode 100644 timemanager/clockDefinitions.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 7706db31a..5e45dec1a 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -207,7 +207,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
              // prepare and send update snapshot.
              CommandMessage notification;
              // todo: serialize into store with timestamp.
-             HousekeepingPacketUpdate updatePacket()
+
+             // HousekeepingPacketUpdate updatePacket(timeStamp, timeStampSize,
+             //        owner->getDataSetHandle(receiver.dataId.sid));
              store_address_t storeId;
              HousekeepingMessage::setUpdateSnapshotSetCommand(
                      &notification, receiver.dataId.sid, storeId);
diff --git a/pus/Service9TimeManagement.cpp b/pus/Service9TimeManagement.cpp
index 5625bdd8f..8c90ae407 100644
--- a/pus/Service9TimeManagement.cpp
+++ b/pus/Service9TimeManagement.cpp
@@ -28,7 +28,7 @@ ReturnValue_t Service9TimeManagement::handleRequest(uint8_t subservice) {
 }
 
 ReturnValue_t Service9TimeManagement::setTime() {
-	Clock::TimeOfDay_t timeToSet;
+	TimeOfDay_t timeToSet;
 	TimePacket timePacket(currentPacket.getApplicationData(),
 			currentPacket.getApplicationDataSize());
 	ReturnValue_t result = CCSDSTime::convertFromCcsds(&timeToSet,
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 68fc4dec3..cede344c4 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -93,7 +93,7 @@ bool ServiceInterfaceBuffer::isBuffered() const {
 }
 
 std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
-	Clock::TimeOfDay_t loggerTime;
+	TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
 	size_t currentSize = 0;
 	char* parsePosition = &preamble[0];
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 8878a38a7..30f9768ba 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,4 +1,4 @@
-#include "../timemanager/CCSDSTime.h"
+#include "CCSDSTime.h"
 #include <FSFWConfig.h>
 #include <cstdio>
 #include <cinttypes>
@@ -12,7 +12,7 @@ CCSDSTime::~CCSDSTime() {
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
-		const Clock::TimeOfDay_t* from) {
+		const TimeOfDay_t* from) {
 	ReturnValue_t result = checkTimeOfDay(from);
 	if (result != RETURN_OK) {
 		return result;
@@ -32,7 +32,7 @@ ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
-		const Clock::TimeOfDay_t* from) {
+		const TimeOfDay_t* from) {
 	ReturnValue_t result = checkTimeOfDay(from);
 	if (result != RETURN_OK) {
 		return result;
@@ -53,7 +53,7 @@ ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
 	return RETURN_OK;
 }
 
-ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t* from,
+ReturnValue_t CCSDSTime::convertFromCcsds(TimeOfDay_t* to, const uint8_t* from,
 		uint32_t length) {
 	ReturnValue_t result;
 	if (length > 0xFF) {
@@ -81,12 +81,12 @@ ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t*
 	}
 }
 
-ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to, const uint8_t* from,
+ReturnValue_t CCSDSTime::convertFromCUC(TimeOfDay_t* to, const uint8_t* from,
 		uint8_t length) {
 	return UNSUPPORTED_TIME_FORMAT;
 }
 
-ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* from,
+ReturnValue_t CCSDSTime::convertFromCDS(TimeOfDay_t* to, const uint8_t* from,
 		uint8_t length) {
 	timeval time;
 	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
@@ -96,7 +96,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* f
 	return convertTimevalToTimeOfDay(to, &time);
 }
 
-ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
+ReturnValue_t CCSDSTime::convertFromCCS(TimeOfDay_t* to, const uint8_t* from,
 		uint32_t* foundLength, uint32_t maxLength) {
 	uint8_t subsecondsLength = *from & 0b111;
 	uint32_t totalLength = subsecondsLength + 8;
@@ -152,7 +152,7 @@ ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* f
 
 }
 
-ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t* from,
+ReturnValue_t CCSDSTime::convertFromASCII(TimeOfDay_t* to, const uint8_t* from,
 		uint8_t length) {
 	if (length < 19) {
 		return RETURN_FAILED;
@@ -427,7 +427,7 @@ ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
 	return result;
 }
 
-ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
+ReturnValue_t CCSDSTime::checkTimeOfDay(const TimeOfDay_t* time) {
 	if ((time->month > 12) || (time->month == 0)) {
 		return INVALID_TIME_FORMAT;
 	}
@@ -482,7 +482,7 @@ ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
 
 }
 
-ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(TimeOfDay_t* to,
 		timeval* from) {
 //This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
 	return UNSUPPORTED_TIME_FORMAT;
@@ -592,7 +592,7 @@ uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
 
 ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
 		uint32_t* foundLength, uint32_t maxLength) {
-	Clock::TimeOfDay_t tempTime;
+	TimeOfDay_t tempTime;
 	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
 			maxLength);
 	if (result != RETURN_OK) {
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index 89fcff92f..ac8bb2669 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -1,9 +1,10 @@
-#ifndef CCSDSTIME_H_
-#define CCSDSTIME_H_
+#ifndef FSFW_TIMEMANAGER_CCSDSTIME_H_
+#define FSFW_TIMEMANAGER_CCSDSTIME_H_
 
 // COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
 
 #include "Clock.h"
+#include "clockDefinitions.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstdint>
 
@@ -111,7 +112,7 @@ public:
 	 * 		- @c INVALID_TIMECODE if not OK
 	 */
 	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
-			Clock::TimeOfDay_t const *from);
+			TimeOfDay_t const *from);
 
 	/**
 	 * Converts to CDS format from timeval.
@@ -136,7 +137,7 @@ public:
 	 * 		- @c INVALID_TIMECODE if not OK
 	 */
 	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
-			Clock::TimeOfDay_t const *from);
+			TimeOfDay_t const *from);
 
 	/**
 	 * SHOULDDO: can this be modified to recognize padding?
@@ -154,7 +155,7 @@ public:
 	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
 	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
 	 */
-	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to, uint8_t const *from,
+	static ReturnValue_t convertFromCcsds(TimeOfDay_t *to, uint8_t const *from,
 			uint32_t length);
 
 	/**
@@ -167,7 +168,7 @@ public:
 	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
 			uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to, uint8_t const *from,
+	static ReturnValue_t convertFromCUC(TimeOfDay_t *to, uint8_t const *from,
 			uint8_t length);
 
 	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
@@ -182,16 +183,16 @@ public:
 	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
 			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to, uint8_t const *from,
+	static ReturnValue_t convertFromCDS(TimeOfDay_t *to, uint8_t const *from,
 			uint8_t length);
 
 	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
 			uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to, uint8_t const *from,
+	static ReturnValue_t convertFromCCS(TimeOfDay_t *to, uint8_t const *from,
 			uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to, uint8_t const *from,
+	static ReturnValue_t convertFromASCII(TimeOfDay_t *to, uint8_t const *from,
 			uint8_t length);
 
 	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
@@ -209,7 +210,7 @@ private:
 	 */
 	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
 
-	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
+	static ReturnValue_t checkTimeOfDay(const TimeOfDay_t *time);
 
 	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
 	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
@@ -226,8 +227,8 @@ private:
 			uint8_t *month, uint8_t *day);
 
 	static bool isLeapYear(uint32_t year);
-	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+	static ReturnValue_t convertTimevalToTimeOfDay(TimeOfDay_t* to,
 			timeval* from);
 };
 
-#endif /* CCSDSTIME_H_ */
+#endif /* FSFW_TIMEMANAGER_CCSDSTIME_H_ */
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 1ad883055..d97eecbe6 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -1,6 +1,7 @@
-#ifndef FRAMEWORK_TIMEMANAGER_CLOCK_H_
-#define FRAMEWORK_TIMEMANAGER_CLOCK_H_
+#ifndef FSFW_TIMEMANAGER_CLOCK_H_
+#define FSFW_TIMEMANAGER_CLOCK_H_
 
+#include "clockDefinitions.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../ipc/MutexFactory.h"
 #include "../globalfunctions/timevalOperations.h"
@@ -8,20 +9,11 @@
 #include <cstdint>
 #include <sys/time.h>
 
-//! Don't use these for time points, type is not large enough for UNIX epoch.
-using dur_millis_t = uint32_t;
-
+// TODO: Maybe a namespace would be better/more fitting for this?
+// After all, right now it is just a collection of static functions.
+// The mutex and leap seconds can be put in an anonymous namespace.
 class Clock {
 public:
-	typedef struct {
-	  uint32_t year; //!< Year, A.D.
-	  uint32_t month; //!< Month, 1 .. 12.
-	  uint32_t day; //!< Day, 1 .. 31.
-	  uint32_t hour; //!< Hour, 0 .. 23.
-	  uint32_t minute; //!< Minute, 0 .. 59.
-	  uint32_t second; //!< Second, 0 .. 59.
-	  uint32_t usecond; //!< Microseconds, 0 .. 999999
-	}   TimeOfDay_t;
 
 	/**
 	 * This method returns the number of clock ticks per second.
@@ -84,13 +76,17 @@ public:
 	 * Returns the time in microseconds since an OS-defined epoch.
 	 * The time is returned in a 64 bit unsigned integer.
 	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t getClock_usecs(uint64_t* time);
 	/**
 	 * Returns the time in a TimeOfDay_t struct.
 	 * @param time A pointer to a TimeOfDay_t struct.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
 
@@ -98,17 +94,20 @@ public:
 	 * Converts a time of day struct to POSIX seconds.
 	 * @param time The time of day as input
 	 * @param timeval The corresponding seconds since the epoch.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
 			timeval* to);
 
 	/**
-	 * Converts a time represented as seconds and subseconds since unix epoch to days since J2000
+	 * Converts a time represented as seconds and subseconds since unix
+	 * epoch to days since J2000
 	 *
 	 * @param time seconds since unix epoch
 	 * @param[out] JD2000 days since J2000
-	 * @return \c RETURN_OK
+	 * @return @c RETURN_OK
 	 */
 	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
 
@@ -119,7 +118,9 @@ public:
 	 *
 	 * @param utc timeval, corresponding to UTC time
 	 * @param[out] tt timeval, corresponding to Terrestial Time
-	 * @return \c RETURN_OK on success, \c RETURN_FAILED if leapSeconds are not set
+	 * @return
+	 *  - @c RETURN_OK on success
+	 *  - @c RETURN_FAILED if leapSeconds are not set
 	 */
 	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
 
@@ -127,7 +128,9 @@ public:
 	 * Set the Leap Seconds since 1972
 	 *
 	 * @param leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
 
@@ -137,13 +140,17 @@ public:
 	 * Must be set before!
 	 *
 	 * @param[out] leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
 
 	/**
 	 * Function to check and create the Mutex for the clock
-	 * @return \c RETURN_OK on success. Otherwise \c RETURN_FAILED if not able to create one
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise @c RETURN_FAILED if not able to create one
 	 */
 	static ReturnValue_t checkOrCreateClockMutex();
 
@@ -153,4 +160,4 @@ private:
 };
 
 
-#endif /* FRAMEWORK_TIMEMANAGER_CLOCK_H_ */
+#endif /* FSFW_TIMEMANAGER_CLOCK_H_ */
diff --git a/timemanager/ReceivesTimeInfoIF.h b/timemanager/ReceivesTimeInfoIF.h
index 680e94f2d..c1247a42f 100644
--- a/timemanager/ReceivesTimeInfoIF.h
+++ b/timemanager/ReceivesTimeInfoIF.h
@@ -1,12 +1,6 @@
-/**
- * @file	ReceivesTimeInfoIF.h
- * @brief	This file defines the ReceivesTimeInfoIF class.
- * @date	26.02.2013
- * @author	baetz
- */
+#ifndef FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_
+#define FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_
 
-#ifndef RECEIVESTIMEINFOIF_H_
-#define RECEIVESTIMEINFOIF_H_
 #include "../ipc/MessageQueueSenderIF.h"
 
 /**
@@ -29,4 +23,4 @@ public:
 };
 
 
-#endif /* RECEIVESTIMEINFOIF_H_ */
+#endif /* FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_ */
diff --git a/timemanager/TimeMessage.h b/timemanager/TimeMessage.h
index bb83708cd..f5ac3e14d 100644
--- a/timemanager/TimeMessage.h
+++ b/timemanager/TimeMessage.h
@@ -1,15 +1,8 @@
-/**
- * @file	TimeMessage.h
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#ifndef TIMEMESSAGE_H_
-#define TIMEMESSAGE_H_
+#ifndef FSFW_TIMEMANAGER_TIMEMESSAGE_H_
+#define FSFW_TIMEMANAGER_TIMEMESSAGE_H_
 
+#include "Clock.h"
 #include "../ipc/MessageQueueMessage.h"
-#include "../timemanager/Clock.h"
 #include <cstring>
 
 class TimeMessage : public MessageQueueMessage {
@@ -53,4 +46,4 @@ public:
 	uint32_t getCounterValue();
 };
 
-#endif /* TIMEMESSAGE_H_ */
+#endif /* FSFW_TIMEMANAGER_TIMEMESSAGE_H_ */
diff --git a/timemanager/TimeStamperIF.h b/timemanager/TimeStamperIF.h
index 96011088d..57b7f0149 100644
--- a/timemanager/TimeStamperIF.h
+++ b/timemanager/TimeStamperIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
-#define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+#ifndef FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
+#define FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 
@@ -25,4 +25,4 @@ public:
 
 
 
-#endif /* FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ */
+#endif /* FSFW_TIMEMANAGER_TIMESTAMPERIF_H_ */
diff --git a/timemanager/clockDefinitions.h b/timemanager/clockDefinitions.h
new file mode 100644
index 000000000..1cfbe8040
--- /dev/null
+++ b/timemanager/clockDefinitions.h
@@ -0,0 +1,22 @@
+#ifndef FSFW_TIMEMANAGER_CLOCKDEFINITIONS_H_
+#define FSFW_TIMEMANAGER_CLOCKDEFINITIONS_H_
+
+#include <cstdint>
+
+// It would be better to put this in a clock namespace, but then we
+// have a nameclash with the class Clock (which propably also should be put
+// in a namespace)
+typedef struct {
+    uint32_t year; //!< Year, A.D.
+    uint32_t month; //!< Month, 1 .. 12.
+    uint32_t day; //!< Day, 1 .. 31.
+    uint32_t hour; //!< Hour, 0 .. 23.
+    uint32_t minute; //!< Minute, 0 .. 59.
+    uint32_t second; //!< Second, 0 .. 59.
+    uint32_t usecond; //!< Microseconds, 0 .. 999999
+} TimeOfDay_t;
+
+//! Don't use these for time points, type is not large enough for UNIX epoch.
+using dur_millis_t = uint32_t;
+
+#endif /* FSFW_TIMEMANAGER_CLOCKDEFINITIONS_H_ */

From f69f9bb31e505537a1093ed2c5af26d672e03b19 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 16:31:25 +0100
Subject: [PATCH 0984/1774] comments removed

---
 timemanager/Clock.h            | 3 ---
 timemanager/clockDefinitions.h | 4 +---
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index d97eecbe6..801e94541 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -9,9 +9,6 @@
 #include <cstdint>
 #include <sys/time.h>
 
-// TODO: Maybe a namespace would be better/more fitting for this?
-// After all, right now it is just a collection of static functions.
-// The mutex and leap seconds can be put in an anonymous namespace.
 class Clock {
 public:
 
diff --git a/timemanager/clockDefinitions.h b/timemanager/clockDefinitions.h
index 1cfbe8040..5804d331c 100644
--- a/timemanager/clockDefinitions.h
+++ b/timemanager/clockDefinitions.h
@@ -3,9 +3,7 @@
 
 #include <cstdint>
 
-// It would be better to put this in a clock namespace, but then we
-// have a nameclash with the class Clock (which propably also should be put
-// in a namespace)
+
 typedef struct {
     uint32_t year; //!< Year, A.D.
     uint32_t month; //!< Month, 1 .. 12.

From 9e97357b8caa13883e59ed16d5fd60362697a55b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 16:46:43 +0100
Subject: [PATCH 0985/1774] taken over changes from master

---
 timemanager/CCSDSTime.cpp      | 42 ++++++++++++++++++----------------
 timemanager/CCSDSTime.h        | 28 +++++++++++------------
 timemanager/Clock.h            | 11 +++++++--
 timemanager/Stopwatch.cpp      |  2 +-
 timemanager/TimeMessage.cpp    |  9 +-------
 timemanager/TimeStamper.cpp    | 23 +++++++++++++++++++
 timemanager/TimeStamper.h      | 36 +++++++++++++++++++++++++++++
 timemanager/clockDefinitions.h | 13 +++--------
 8 files changed, 109 insertions(+), 55 deletions(-)
 create mode 100644 timemanager/TimeStamper.cpp
 create mode 100644 timemanager/TimeStamper.h

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 30f9768ba..6acd55394 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -12,7 +12,7 @@ CCSDSTime::~CCSDSTime() {
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
-		const TimeOfDay_t* from) {
+		const Clock::TimeOfDay_t* from) {
 	ReturnValue_t result = checkTimeOfDay(from);
 	if (result != RETURN_OK) {
 		return result;
@@ -32,7 +32,7 @@ ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
-		const TimeOfDay_t* from) {
+		const Clock::TimeOfDay_t* from) {
 	ReturnValue_t result = checkTimeOfDay(from);
 	if (result != RETURN_OK) {
 		return result;
@@ -53,8 +53,8 @@ ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
 	return RETURN_OK;
 }
 
-ReturnValue_t CCSDSTime::convertFromCcsds(TimeOfDay_t* to, const uint8_t* from,
-		uint32_t length) {
+ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint32_t length) {
 	ReturnValue_t result;
 	if (length > 0xFF) {
 		return LENGTH_MISMATCH;
@@ -81,13 +81,13 @@ ReturnValue_t CCSDSTime::convertFromCcsds(TimeOfDay_t* to, const uint8_t* from,
 	}
 }
 
-ReturnValue_t CCSDSTime::convertFromCUC(TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
+ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint8_t length) {
 	return UNSUPPORTED_TIME_FORMAT;
 }
 
-ReturnValue_t CCSDSTime::convertFromCDS(TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
+ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint8_t length) {
 	timeval time;
 	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -96,8 +96,8 @@ ReturnValue_t CCSDSTime::convertFromCDS(TimeOfDay_t* to, const uint8_t* from,
 	return convertTimevalToTimeOfDay(to, &time);
 }
 
-ReturnValue_t CCSDSTime::convertFromCCS(TimeOfDay_t* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
 	uint8_t subsecondsLength = *from & 0b111;
 	uint32_t totalLength = subsecondsLength + 8;
 	if (maxLength < totalLength) {
@@ -152,8 +152,8 @@ ReturnValue_t CCSDSTime::convertFromCCS(TimeOfDay_t* to, const uint8_t* from,
 
 }
 
-ReturnValue_t CCSDSTime::convertFromASCII(TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
+ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint8_t length) {
 	if (length < 19) {
 		return RETURN_FAILED;
 	}
@@ -166,8 +166,9 @@ ReturnValue_t CCSDSTime::convertFromASCII(TimeOfDay_t* to, const uint8_t* from,
 	uint16_t hour;
 	uint16_t minute;
 	float second;
-	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
-				&month, &day, &hour, &minute, &second);
+	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%"
+	        "2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &month, &day, &hour,
+	        &minute, &second);
 	if (count == 6) {
 		to->year = year;
 		to->month = month;
@@ -180,12 +181,13 @@ ReturnValue_t CCSDSTime::convertFromASCII(TimeOfDay_t* to, const uint8_t* from,
 	}
 
 	// try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
-			&hour, &minute, &second);
+	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%"
+	        "2" SCNu16 ":%fZ", &year, &day, &hour, &minute, &second);
 	if (count == 5) {
 		uint8_t tempDay;
 		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
-				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
+				reinterpret_cast<uint8_t *>(&month),
+				reinterpret_cast<uint8_t *>(&tempDay));
 		if (result != RETURN_OK) {
 			return RETURN_FAILED;
 		}
@@ -427,7 +429,7 @@ ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
 	return result;
 }
 
-ReturnValue_t CCSDSTime::checkTimeOfDay(const TimeOfDay_t* time) {
+ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
 	if ((time->month > 12) || (time->month == 0)) {
 		return INVALID_TIME_FORMAT;
 	}
@@ -482,7 +484,7 @@ ReturnValue_t CCSDSTime::checkTimeOfDay(const TimeOfDay_t* time) {
 
 }
 
-ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(TimeOfDay_t* to,
+ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
 		timeval* from) {
 //This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
 	return UNSUPPORTED_TIME_FORMAT;
@@ -592,7 +594,7 @@ uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
 
 ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
 		uint32_t* foundLength, uint32_t maxLength) {
-	TimeOfDay_t tempTime;
+	Clock::TimeOfDay_t tempTime;
 	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
 			maxLength);
 	if (result != RETURN_OK) {
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index ac8bb2669..29c9f8f58 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -112,7 +112,7 @@ public:
 	 * 		- @c INVALID_TIMECODE if not OK
 	 */
 	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
-			TimeOfDay_t const *from);
+			Clock::TimeOfDay_t const *from);
 
 	/**
 	 * Converts to CDS format from timeval.
@@ -137,7 +137,7 @@ public:
 	 * 		- @c INVALID_TIMECODE if not OK
 	 */
 	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
-			TimeOfDay_t const *from);
+			Clock::TimeOfDay_t const *from);
 
 	/**
 	 * SHOULDDO: can this be modified to recognize padding?
@@ -155,8 +155,8 @@ public:
 	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
 	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
 	 */
-	static ReturnValue_t convertFromCcsds(TimeOfDay_t *to, uint8_t const *from,
-			uint32_t length);
+	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint32_t length);
 
 	/**
 	 * not implemented yet
@@ -168,8 +168,8 @@ public:
 	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
 			uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromCUC(TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
+	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint8_t length);
 
 	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
 			uint32_t* foundLength, uint32_t maxLength);
@@ -183,17 +183,17 @@ public:
 	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
 			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromCDS(TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
+	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint8_t length);
 
 	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
 			uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromCCS(TimeOfDay_t *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromASCII(TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
+	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint8_t length);
 
 	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
 private:
@@ -210,7 +210,7 @@ private:
 	 */
 	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
 
-	static ReturnValue_t checkTimeOfDay(const TimeOfDay_t *time);
+	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
 
 	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
 	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
@@ -227,7 +227,7 @@ private:
 			uint8_t *month, uint8_t *day);
 
 	static bool isLeapYear(uint32_t year);
-	static ReturnValue_t convertTimevalToTimeOfDay(TimeOfDay_t* to,
+	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
 			timeval* from);
 };
 
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 801e94541..820077959 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -11,6 +11,15 @@
 
 class Clock {
 public:
+    typedef struct {
+        uint32_t year; //!< Year, A.D.
+        uint32_t month; //!< Month, 1 .. 12.
+        uint32_t day; //!< Day, 1 .. 31.
+        uint32_t hour; //!< Hour, 0 .. 23.
+        uint32_t minute; //!< Minute, 0 .. 59.
+        uint32_t second; //!< Second, 0 .. 59.
+        uint32_t usecond; //!< Microseconds, 0 .. 999999
+    } TimeOfDay_t;
 
 	/**
 	 * This method returns the number of clock ticks per second.
@@ -56,8 +65,6 @@ public:
 
 	static timeval getUptime();
 
-	static uint32_t getUptimeSeconds();
-
 	/**
 	 * Get the time since boot in milliseconds
 	 *
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 2cd31969b..302e2ac07 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -1,4 +1,4 @@
-#include "../timemanager/Stopwatch.h"
+#include "Stopwatch.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include <iomanip>
 
diff --git a/timemanager/TimeMessage.cpp b/timemanager/TimeMessage.cpp
index 6e8dcd609..a1042efe5 100644
--- a/timemanager/TimeMessage.cpp
+++ b/timemanager/TimeMessage.cpp
@@ -1,11 +1,4 @@
-/**
- * @file	TimeMessage.cpp
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#include "../timemanager/TimeMessage.h"
+#include "TimeMessage.h"
 
 TimeMessage::TimeMessage() {
 	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
diff --git a/timemanager/TimeStamper.cpp b/timemanager/TimeStamper.cpp
new file mode 100644
index 000000000..d9f0f2f3e
--- /dev/null
+++ b/timemanager/TimeStamper.cpp
@@ -0,0 +1,23 @@
+#include "TimeStamper.h"
+#include "Clock.h"
+#include <cstring>
+
+TimeStamper::TimeStamper(object_id_t objectId): SystemObject(objectId) {}
+
+
+ReturnValue_t TimeStamper::addTimeStamp(uint8_t* buffer,
+		const uint8_t maxSize) {
+	if(maxSize < TimeStamperIF::MISSION_TIMESTAMP_SIZE){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	timeval now;
+	Clock::getClock_timeval(&now);
+	CCSDSTime::CDS_short cds;
+	ReturnValue_t result = CCSDSTime::convertToCcsds(&cds,&now);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+	std::memcpy(buffer,&cds,sizeof(cds));
+	return result;
+}
diff --git a/timemanager/TimeStamper.h b/timemanager/TimeStamper.h
new file mode 100644
index 000000000..6895c14b5
--- /dev/null
+++ b/timemanager/TimeStamper.h
@@ -0,0 +1,36 @@
+#ifndef FSFW_TIMEMANAGER_TIMESTAMPER_H_
+#define FSFW_TIMEMANAGER_TIMESTAMPER_H_
+
+#include "TimeStamperIF.h"
+#include "CCSDSTime.h"
+#include "../objectmanager/SystemObject.h"
+
+/**
+ * @brief   Time stamper which can be used to add any timestamp to a
+ *          given buffer.
+ * @details
+ * This time stamper uses the CCSDS CDC short timestamp as a fault timestamp.
+ * This timestamp has a size of 8 bytes. A custom timestamp can be used by
+ * overriding the #addTimeStamp function.
+ * @ingroup utility
+ */
+class TimeStamper: public TimeStamperIF, public SystemObject {
+public:
+    /**
+     * @brief   Default constructor which also registers the time stamper as a
+     *          system object so it can be found with the #objectManager.
+     * @param objectId
+     */
+	TimeStamper(object_id_t objectId);
+
+	/**
+	 * Adds a CCSDS CDC short 8 byte timestamp to the given buffer.
+	 * This function can be overriden to use a custom timestamp.
+	 * @param buffer
+	 * @param maxSize
+	 * @return
+	 */
+	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize);
+};
+
+#endif /* FSFW_TIMEMANAGER_TIMESTAMPER_H_ */
diff --git a/timemanager/clockDefinitions.h b/timemanager/clockDefinitions.h
index 5804d331c..bba6e3ca2 100644
--- a/timemanager/clockDefinitions.h
+++ b/timemanager/clockDefinitions.h
@@ -3,16 +3,9 @@
 
 #include <cstdint>
 
-
-typedef struct {
-    uint32_t year; //!< Year, A.D.
-    uint32_t month; //!< Month, 1 .. 12.
-    uint32_t day; //!< Day, 1 .. 31.
-    uint32_t hour; //!< Hour, 0 .. 23.
-    uint32_t minute; //!< Minute, 0 .. 59.
-    uint32_t second; //!< Second, 0 .. 59.
-    uint32_t usecond; //!< Microseconds, 0 .. 999999
-} TimeOfDay_t;
+// I'd also like to include the TimeOfDay_t struct here, but that would
+// break code which uses Clock::TimeOfDay_t. Solution would be to use
+// a Clock namespace instead of class with static functions.
 
 //! Don't use these for time points, type is not large enough for UNIX epoch.
 using dur_millis_t = uint32_t;

From 695b161934052c7d18f1db7dbb04c71e66e6f3de Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 16:54:56 +0100
Subject: [PATCH 0986/1774] some bugfixes

---
 osal/FreeRTOS/Clock.cpp                     | 8 ++++----
 pus/Service9TimeManagement.cpp              | 2 +-
 serviceinterface/ServiceInterfaceBuffer.cpp | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index 42f060b45..f3d8516a3 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -68,10 +68,10 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 }
 
 
-uint32_t Clock::getUptimeSeconds() {
-	timeval uptime = getUptime();
-	return uptime.tv_sec;
-}
+//uint32_t Clock::getUptimeSeconds() {
+//	timeval uptime = getUptime();
+//	return uptime.tv_sec;
+//}
 
 
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
diff --git a/pus/Service9TimeManagement.cpp b/pus/Service9TimeManagement.cpp
index 8c90ae407..5625bdd8f 100644
--- a/pus/Service9TimeManagement.cpp
+++ b/pus/Service9TimeManagement.cpp
@@ -28,7 +28,7 @@ ReturnValue_t Service9TimeManagement::handleRequest(uint8_t subservice) {
 }
 
 ReturnValue_t Service9TimeManagement::setTime() {
-	TimeOfDay_t timeToSet;
+	Clock::TimeOfDay_t timeToSet;
 	TimePacket timePacket(currentPacket.getApplicationData(),
 			currentPacket.getApplicationDataSize());
 	ReturnValue_t result = CCSDSTime::convertFromCcsds(&timeToSet,
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index cede344c4..68fc4dec3 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -93,7 +93,7 @@ bool ServiceInterfaceBuffer::isBuffered() const {
 }
 
 std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
-	TimeOfDay_t loggerTime;
+	Clock::TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
 	size_t currentSize = 0;
 	char* parsePosition = &preamble[0];

From d424d85f6d0699a7f9da63f28e973a2855873243 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 17:07:48 +0100
Subject: [PATCH 0987/1774] sizet changes and indentation

---
 timemanager/CCSDSTime.cpp |  18 +--
 timemanager/CCSDSTime.h   |  16 +--
 timemanager/Clock.h       | 256 +++++++++++++++++++-------------------
 3 files changed, 145 insertions(+), 145 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 6acd55394..aefcac2eb 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -54,7 +54,7 @@ ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
 }
 
 ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to,
-        const uint8_t* from, uint32_t length) {
+        const uint8_t* from, size_t length) {
 	ReturnValue_t result;
 	if (length > 0xFF) {
 		return LENGTH_MISMATCH;
@@ -72,7 +72,7 @@ ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to,
 	case CDS:
 		return convertFromCDS(to, from, length);
 	case CCS: {
-		uint32_t temp = 0;
+		size_t temp = 0;
 		return convertFromCCS(to, from, &temp, length);
 	}
 
@@ -97,7 +97,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to,
 }
 
 ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to,
-        const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
+        const uint8_t* from, size_t* foundLength, size_t maxLength) {
 	uint8_t subsecondsLength = *from & 0b111;
 	uint32_t totalLength = subsecondsLength + 8;
 	if (maxLength < totalLength) {
@@ -395,7 +395,7 @@ ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
 }
 
 ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+		size_t* foundLength, size_t maxLength) {
 	//We don't expect ascii here. SHOULDDO
 	uint8_t codeIdentification = (*from >> 4);
 	switch (codeIdentification) {
@@ -413,7 +413,7 @@ ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+		size_t* foundLength, size_t maxLength) {
 	if (maxLength < 1) {
 		return INVALID_TIME_FORMAT;
 	}
@@ -491,7 +491,7 @@ ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
 }
 
 ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+		size_t* foundLength, size_t maxLength) {
 	uint8_t pField = *from;
 	from++;
 //Check epoch
@@ -556,12 +556,12 @@ ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
-		const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
+		const uint8_t* from, size_t* foundLength, size_t maxLength) {
 	uint32_t secs = 0;
 	uint32_t subSeconds = 0;
 	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
 	uint8_t nFine = (pField & 0b11);
-	uint32_t totalLength = nCoarse + nFine;
+	size_t totalLength = nCoarse + nFine;
 	if (foundLength != NULL) {
 		*foundLength = totalLength;
 	}
@@ -593,7 +593,7 @@ uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
 }
 
 ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+		size_t* foundLength, size_t maxLength) {
 	Clock::TimeOfDay_t tempTime;
 	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
 			maxLength);
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index 29c9f8f58..e9e6957f2 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -156,7 +156,7 @@ public:
 	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
 	 */
 	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, uint32_t length);
+	        uint8_t const *from, size_t length);
 
 	/**
 	 * not implemented yet
@@ -166,31 +166,31 @@ public:
 	 * @return
 	 */
 	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+			size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to,
 	        uint8_t const *from, uint8_t length);
 
 	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+			size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+			uint8_t const *from, size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+			size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+			uint8_t const *from, size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to,
 	        uint8_t const *from, uint8_t length);
 
 	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+			size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+	        uint8_t const *from, size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to,
 	        uint8_t const *from, uint8_t length);
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 820077959..f4ed847ac 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -21,146 +21,146 @@ public:
         uint32_t usecond; //!< Microseconds, 0 .. 999999
     } TimeOfDay_t;
 
-	/**
-	 * This method returns the number of clock ticks per second.
-	 * In RTEMS, this is typically 1000.
-	 * @return	The number of ticks.
-	 *
-	 * @deprecated, we should not worry about ticks, but only time
-	 */
-	static uint32_t getTicksPerSecond(void);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a TimeOfDay_t struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
-	 * 				is returned.
-	 */
-	static ReturnValue_t setClock(const TimeOfDay_t* time);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a timeval struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setClock(const timeval* time);
-	/**
-	 * This system call returns the current system clock in timeval format.
-	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
-	 * microseconds since an OS-defined epoch.
-	 * @param time	A pointer to a timeval struct where the current time is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_timeval(timeval* time);
+    /**
+     * This method returns the number of clock ticks per second.
+     * In RTEMS, this is typically 1000.
+     * @return	The number of ticks.
+     *
+     * @deprecated, we should not worry about ticks, but only time
+     */
+    static uint32_t getTicksPerSecond(void);
+    /**
+     * This system call sets the system time.
+     * To set the time, it uses a TimeOfDay_t struct.
+     * @param time The struct with the time settings to set.
+     * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
+     * 				is returned.
+     */
+    static ReturnValue_t setClock(const TimeOfDay_t* time);
+    /**
+     * This system call sets the system time.
+     * To set the time, it uses a timeval struct.
+     * @param time The struct with the time settings to set.
+     * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t setClock(const timeval* time);
+    /**
+     * This system call returns the current system clock in timeval format.
+     * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
+     * microseconds since an OS-defined epoch.
+     * @param time	A pointer to a timeval struct where the current time is stored.
+     * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getClock_timeval(timeval* time);
 
-	/**
-	 * Get the time since boot in a timeval struct
-	 *
-	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 *
-	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
-	 */
-	static ReturnValue_t getUptime(timeval* uptime);
+    /**
+     * Get the time since boot in a timeval struct
+     *
+     * @param[out] time A pointer to a timeval struct where the uptime is stored.
+     * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+     *
+     * @deprecated, I do not think this should be able to fail, use timeval getUptime()
+     */
+    static ReturnValue_t getUptime(timeval* uptime);
 
-	static timeval getUptime();
+    static timeval getUptime();
 
-	/**
-	 * Get the time since boot in milliseconds
-	 *
-	 * This value can overflow! Still, it can be used to calculate time intervalls
-	 * between two calls up to 49 days by always using uint32_t in the calculation
-	 *
-	 * @param ms uptime in ms
-	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getUptime(uint32_t* uptimeMs);
+    /**
+     * Get the time since boot in milliseconds
+     *
+     * This value can overflow! Still, it can be used to calculate time intervalls
+     * between two calls up to 49 days by always using uint32_t in the calculation
+     *
+     * @param ms uptime in ms
+     * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getUptime(uint32_t* uptimeMs);
 
-	/**
-	 * Returns the time in microseconds since an OS-defined epoch.
-	 * The time is returned in a 64 bit unsigned integer.
-	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
-	 * @return
-	 *  - @c RETURN_OK on success.
-	 *  - Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_usecs(uint64_t* time);
-	/**
-	 * Returns the time in a TimeOfDay_t struct.
-	 * @param time A pointer to a TimeOfDay_t struct.
-	 * @return
-	 *  - @c RETURN_OK on success.
-	 *  - Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
+    /**
+     * Returns the time in microseconds since an OS-defined epoch.
+     * The time is returned in a 64 bit unsigned integer.
+     * @param time A pointer to a 64 bit unisigned integer where the data is stored.
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getClock_usecs(uint64_t* time);
+    /**
+     * Returns the time in a TimeOfDay_t struct.
+     * @param time A pointer to a TimeOfDay_t struct.
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
 
-	/**
-	 * Converts a time of day struct to POSIX seconds.
-	 * @param time The time of day as input
-	 * @param timeval The corresponding seconds since the epoch.
-	 * @return
-	 *  - @c RETURN_OK on success.
-	 *  - Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-			timeval* to);
+    /**
+     * Converts a time of day struct to POSIX seconds.
+     * @param time The time of day as input
+     * @param timeval The corresponding seconds since the epoch.
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+            timeval* to);
 
-	/**
-	 * Converts a time represented as seconds and subseconds since unix
-	 * epoch to days since J2000
-	 *
-	 * @param time seconds since unix epoch
-	 * @param[out] JD2000 days since J2000
-	 * @return @c RETURN_OK
-	 */
-	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
+    /**
+     * Converts a time represented as seconds and subseconds since unix
+     * epoch to days since J2000
+     *
+     * @param time seconds since unix epoch
+     * @param[out] JD2000 days since J2000
+     * @return @c RETURN_OK
+     */
+    static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
 
-	/**
-	 * Calculates and adds the offset between UTC and TT
-	 *
-	 * Depends on the leap seconds to be set correctly.
-	 *
-	 * @param utc timeval, corresponding to UTC time
-	 * @param[out] tt timeval, corresponding to Terrestial Time
-	 * @return
-	 *  - @c RETURN_OK on success
-	 *  - @c RETURN_FAILED if leapSeconds are not set
-	 */
-	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
+    /**
+     * Calculates and adds the offset between UTC and TT
+     *
+     * Depends on the leap seconds to be set correctly.
+     *
+     * @param utc timeval, corresponding to UTC time
+     * @param[out] tt timeval, corresponding to Terrestial Time
+     * @return
+     *  - @c RETURN_OK on success
+     *  - @c RETURN_FAILED if leapSeconds are not set
+     */
+    static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
 
-	/**
-	 * Set the Leap Seconds since 1972
-	 *
-	 * @param leapSeconds_
-	 * @return
-	 *  - @c RETURN_OK on success.
-	 *  - Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
+    /**
+     * Set the Leap Seconds since 1972
+     *
+     * @param leapSeconds_
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
 
-	/**
-	 * Get the Leap Seconds since 1972
-	 *
-	 * Must be set before!
-	 *
-	 * @param[out] leapSeconds_
-	 * @return
-	 *  - @c RETURN_OK on success.
-	 *  - Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
+    /**
+     * Get the Leap Seconds since 1972
+     *
+     * Must be set before!
+     *
+     * @param[out] leapSeconds_
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
 
-	/**
-	 * Function to check and create the Mutex for the clock
-	 * @return
-	 *  - @c RETURN_OK on success.
-	 *  - Otherwise @c RETURN_FAILED if not able to create one
-	 */
-	static ReturnValue_t checkOrCreateClockMutex();
+    /**
+     * Function to check and create the Mutex for the clock
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise @c RETURN_FAILED if not able to create one
+     */
+    static ReturnValue_t checkOrCreateClockMutex();
 
 private:
-	static MutexIF* timeMutex;
-	static uint16_t leapSeconds;
+    static MutexIF* timeMutex;
+    static uint16_t leapSeconds;
 };
 
 

From 30947d3901ef412f860b4758e66e9c77cd79afdb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 17:08:40 +0100
Subject: [PATCH 0988/1774] size_t changes

---
 tmstorage/TmStorePackets.h | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 4ce64fe64..0312a9989 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -49,7 +49,7 @@ public:
 	}
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) {
+	Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
 				buffer, size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -139,8 +139,9 @@ public:
 	static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime){
 		if(packet->isValid()){
 			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			size_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],
+			        &foundlen,sizeof(rawTimestamp));
 			if(packetTime <= *cmpTime){
 				return true;
 			}
@@ -151,8 +152,9 @@ public:
 	static bool isNewerThan(const TmPacketInformation* packet, const timeval* cmpTime){
 		if(packet->isValid()){
 			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			size_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],
+			        &foundlen,sizeof(rawTimestamp));
 			if(packetTime >= *cmpTime){
 				return true;
 			}
@@ -204,8 +206,9 @@ public:
 
 	timeval getTime() const {
 		timeval packetTime = {0,0};
-		uint32_t foundlen = 0;
-		CCSDSTime::convertFromCcsds(&packetTime,&this->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+		size_t foundlen = 0;
+		CCSDSTime::convertFromCcsds(&packetTime, &this->rawTimestamp[0],
+		        &foundlen, sizeof(rawTimestamp));
 		return packetTime;
 	}
 
@@ -258,7 +261,7 @@ public:
 	};
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) {
+	Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
 				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {

From 5908f99f0b352ef41db992708888c6c2e64bcde8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 17:09:33 +0100
Subject: [PATCH 0989/1774] size t changes

---
 tmtcpacket/pus/TmPacketBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index f3bc3f001..2c8bfd632 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -74,7 +74,7 @@ bool TmPacketBase::checkAndSetStamper() {
 }
 
 ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
-	uint32_t tempSize = 0;
+	size_t tempSize = 0;
 	return CCSDSTime::convertFromCcsds(timestamp, tmData->data_field.time,
 			&tempSize, sizeof(tmData->data_field.time));
 }

From c69681b402ea3523cc16cb45799715045d14b13a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 22:22:26 +0100
Subject: [PATCH 0990/1774] time stamper

---
 datapoollocal/LocalDataPoolManager.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 5e45dec1a..b32177dc1 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/timemanager/TimeStamperIF.h>
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
@@ -207,8 +208,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
              // prepare and send update snapshot.
              CommandMessage notification;
              // todo: serialize into store with timestamp.
-
-             // HousekeepingPacketUpdate updatePacket(timeStamp, timeStampSize,
+             //TimeStamperIF* timeStamper = objectManager->
+             //        get<TimeStamperIF>(objects::TIME_STAMPER)
+             //HousekeepingPacketUpdate updatePacket(timeStamp, timeStampSize,
              //        owner->getDataSetHandle(receiver.dataId.sid));
              store_address_t storeId;
              HousekeepingMessage::setUpdateSnapshotSetCommand(

From d87f78f5c3576d4d3f27f206690047c1783da1b5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 22:25:14 +0100
Subject: [PATCH 0991/1774] timer stamper in fsfw now

---
 objectmanager/frameworkObjects.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 57783286a..8f8e93af7 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -22,6 +22,7 @@ enum framework_objects {
 	//IDs for PUS Packet Communication
 	TC_STORE = 0x534f0100,
 	TM_STORE = 0x534f0200,
+	TIME_STAMPER = 0x53500010,
 
 	NO_OBJECT = 0xFFFFFFFF
 };

From e9aecdac26b83e8548ca03b04ff4d1660e33de78 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 22:58:09 +0100
Subject: [PATCH 0992/1774] sth with eclipse indentiation

---
 datapoollocal/LocalDataPoolManager.cpp | 575 +++++++++++++------------
 datapoollocal/LocalPoolDataSetBase.cpp |  82 ++--
 2 files changed, 341 insertions(+), 316 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index b32177dc1..440afa238 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/timemanager/CCSDSTime.h>
 #include <fsfw/timemanager/TimeStamperIF.h>
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
@@ -16,11 +17,11 @@
 #include <cmath>
 
 object_id_t LocalDataPoolManager::defaultHkDestination =
-		objects::PUS_SERVICE_3_HOUSEKEEPING;
+        objects::PUS_SERVICE_3_HOUSEKEEPING;
 
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
-        appendValidityBuffer(appendValidityBuffer) {
+                        appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
         sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                 << "Invalid supplied owner!" << std::endl;
@@ -63,7 +64,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
         }
         else {
             sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                   << "Default HK destination object is invalid!" << std::endl;
+                    << "Default HK destination object is invalid!" << std::endl;
             return HasReturnvaluesIF::RETURN_FAILED;
         }
     }
@@ -78,17 +79,17 @@ ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
 }
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
-	if(not mapInitialized) {
-		ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
-		        *this);
-		if(result == HasReturnvaluesIF::RETURN_OK) {
-			mapInitialized = true;
-		}
-		return result;
-	}
-	sif::warning << "HousekeepingManager: The map should only be initialized "
-	        << "once!" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
+    if(not mapInitialized) {
+        ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
+                *this);
+        if(result == HasReturnvaluesIF::RETURN_OK) {
+            mapInitialized = true;
+        }
+        return result;
+    }
+    sif::warning << "HousekeepingManager: The map should only be initialized "
+            << "once!" << std::endl;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
@@ -125,7 +126,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
 }
 
 ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
-            ReturnValue_t& status) {
+        ReturnValue_t& status) {
     if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
         // Update packets shall only be generated from datasets.
         return HasReturnvaluesIF::RETURN_FAILED;
@@ -135,7 +136,7 @@ ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
     if(dataSet->hasChanged()) {
         // prepare and send update notification
         ReturnValue_t result = generateHousekeepingPacket(
-                    receiver.dataId.sid, dataSet, true);
+                receiver.dataId.sid, dataSet, true);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             status = result;
         }
@@ -197,58 +198,80 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
 ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         HkReceiver& receiver, ReturnValue_t& status) {
     MarkChangedIF* toReset = nullptr;
-     // check whether data has changed and send messages in case it has.
-     if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                 receiver.dataId.localPoolId);
-         if(poolObj == nullptr) {
-             return HasReturnvaluesIF::RETURN_FAILED;
-         }
-         if(poolObj->hasChanged()) {
-             // prepare and send update snapshot.
-             CommandMessage notification;
-             // todo: serialize into store with timestamp.
-             //TimeStamperIF* timeStamper = objectManager->
-             //        get<TimeStamperIF>(objects::TIME_STAMPER)
-             //HousekeepingPacketUpdate updatePacket(timeStamp, timeStampSize,
-             //        owner->getDataSetHandle(receiver.dataId.sid));
-             store_address_t storeId;
-             HousekeepingMessage::setUpdateSnapshotSetCommand(
-                     &notification, receiver.dataId.sid, storeId);
-             ReturnValue_t result = hkQueue->sendMessage(
-                     receiver.destinationQueue, &notification);
-             if(result != HasReturnvaluesIF::RETURN_OK) {
-                 status = result;
-             }
-             toReset = poolObj;
-         }
-     }
-     else {
-         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                 receiver.dataId.sid);
-         if(dataSet == nullptr) {
-             return HasReturnvaluesIF::RETURN_FAILED;
-         }
-         if(dataSet->hasChanged()) {
-             // prepare and send update snapshot.
-             CommandMessage notification;
-             // todo: serialize into store with timestamp.
-             store_address_t storeId;
-             HousekeepingMessage::setUpdateSnapshotVariableCommand(
-                     &notification, receiver.dataId.localPoolId, storeId);
-             ReturnValue_t result = hkQueue->sendMessage(
-                     receiver.destinationQueue, &notification);
-             if(result != HasReturnvaluesIF::RETURN_OK) {
-                 status = result;
-             }
-             toReset = dataSet;
-         }
-     }
-     if(toReset != nullptr) {
-         handleChangeResetLogic(receiver.dataType,
-                 receiver.dataId, toReset);
-     }
-     return HasReturnvaluesIF::RETURN_OK;
+    // check whether data has changed and send messages in case it has.
+    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+                receiver.dataId.localPoolId);
+        if(poolObj == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+
+        if (not poolObj->hasChanged()) {
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+
+        // prepare and send update snapshot.
+        CommandMessage notification;
+        timeval now;
+        Clock::getClock_timeval(&now);
+        CCSDSTime::CDS_short cds;
+        CCSDSTime::convertToCcsds(&cds, &now);
+        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+                sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+        size_t updatePacketSize = updatePacket.getSerializedSize();
+
+        store_address_t storeId;
+        uint8_t *storePtr = nullptr;
+        ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+                updatePacket.getSerializedSize(), &storePtr);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        size_t serializedSize = 0;
+        result = updatePacket.serialize(&storePtr, &serializedSize,
+                updatePacketSize, SerializeIF::Endianness::MACHINE);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        HousekeepingMessage::setUpdateSnapshotSetCommand(&notification,
+                receiver.dataId.sid, storeId);
+        result = hkQueue->sendMessage(receiver.destinationQueue,
+                &notification);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            status = result;
+        }
+        toReset = poolObj;
+    }
+    else {
+        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                receiver.dataId.sid);
+        if(dataSet == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+
+        if(not dataSet->hasChanged()) {
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+
+        // prepare and send update snapshot.
+        CommandMessage notification;
+        // todo: serialize into store with timestamp.
+        store_address_t storeId;
+        HousekeepingMessage::setUpdateSnapshotVariableCommand(
+                &notification, receiver.dataId.localPoolId, storeId);
+        ReturnValue_t result = hkQueue->sendMessage(
+                receiver.destinationQueue, &notification);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            status = result;
+        }
+        toReset = dataSet;
+
+    }
+    if(toReset != nullptr) {
+        handleChangeResetLogic(receiver.dataType,
+                receiver.dataId, toReset);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void LocalDataPoolManager::handleChangeResetLogic(
@@ -295,32 +318,32 @@ void LocalDataPoolManager::resetHkUpdateResetHelper() {
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
-		bool enableReporting, float collectionInterval, bool isDiagnostics,
-		object_id_t packetDestination) {
-	AcceptsHkPacketsIF* hkReceiverObject =
-			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-	if(hkReceiverObject == nullptr) {
-		sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-				<< " Invalid receiver!"<< std::endl;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+        bool enableReporting, float collectionInterval, bool isDiagnostics,
+        object_id_t packetDestination) {
+    AcceptsHkPacketsIF* hkReceiverObject =
+            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+    if(hkReceiverObject == nullptr) {
+        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
+                << " Invalid receiver!"<< std::endl;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	struct HkReceiver hkReceiver;
-	hkReceiver.dataId.sid = sid;
-	hkReceiver.reportingType = ReportingType::PERIODIC;
-	hkReceiver.dataType = DataType::DATA_SET;
-	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+    struct HkReceiver hkReceiver;
+    hkReceiver.dataId.sid = sid;
+    hkReceiver.reportingType = ReportingType::PERIODIC;
+    hkReceiver.dataType = DataType::DATA_SET;
+    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if(dataSet != nullptr) {
-		dataSet->setReportingEnabled(enableReporting);
-		dataSet->setDiagnostic(isDiagnostics);
-		dataSet->initializePeriodicHelper(collectionInterval,
-				owner->getPeriodicOperationFrequency(), isDiagnostics);
-	}
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(dataSet != nullptr) {
+        dataSet->setReportingEnabled(enableReporting);
+        dataSet->setDiagnostic(isDiagnostics);
+        dataSet->initializePeriodicHelper(collectionInterval,
+                owner->getPeriodicOperationFrequency(), isDiagnostics);
+    }
 
-	hkReceiversMap.push_back(hkReceiver);
-	return HasReturnvaluesIF::RETURN_OK;
+    hkReceiversMap.push_back(hkReceiver);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 
@@ -328,7 +351,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
         bool isDiagnostics, bool reportingEnabled,
         object_id_t packetDestination) {
     AcceptsHkPacketsIF* hkReceiverObject =
-                objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
         sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
                 << " Invalid receiver!"<< std::endl;
@@ -432,64 +455,64 @@ void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType,
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-		CommandMessage* message) {
+        CommandMessage* message) {
     Command_t command = message->getCommand();
     sid_t sid = HousekeepingMessage::getSid(message);
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     switch(command) {
     // Houskeeping interface handling.
     case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-    	result = togglePeriodicGeneration(sid, true, true);
-    	break;
+        result = togglePeriodicGeneration(sid, true, true);
+        break;
     }
 
     case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-    	result = togglePeriodicGeneration(sid, false, true);
-    	break;
+        result = togglePeriodicGeneration(sid, false, true);
+        break;
     }
 
     case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
-    	result = togglePeriodicGeneration(sid, true, false);
-    	break;
+        result = togglePeriodicGeneration(sid, true, false);
+        break;
     }
 
     case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
-    	result = togglePeriodicGeneration(sid, false, false);
-    	break;
+        result = togglePeriodicGeneration(sid, false, false);
+        break;
     }
 
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
-        return generateSetStructurePacket(sid, true);
+                        return generateSetStructurePacket(sid, true);
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-        return generateSetStructurePacket(sid, false);
+                        return generateSetStructurePacket(sid, false);
     case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
     case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
-    	float newCollIntvl = 0;
-    	HousekeepingMessage::getCollectionIntervalModificationCommand(message,
-    			&newCollIntvl);
-    	if(command == HousekeepingMessage::
-    			MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
-    		result = changeCollectionInterval(sid, newCollIntvl, true);
-    	}
-    	else {
-    		result = changeCollectionInterval(sid, newCollIntvl, false);
-    	}
-    	break;
+        float newCollIntvl = 0;
+        HousekeepingMessage::getCollectionIntervalModificationCommand(message,
+                &newCollIntvl);
+        if(command == HousekeepingMessage::
+                MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
+            result = changeCollectionInterval(sid, newCollIntvl, true);
+        }
+        else {
+            result = changeCollectionInterval(sid, newCollIntvl, false);
+        }
+        break;
     }
 
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
     case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
-    	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    	if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
-    			and dataSet->isDiagnostics()) {
-    		return WRONG_HK_PACKET_TYPE;
-    	}
-    	else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
-    			and not dataSet->isDiagnostics()) {
-    		return WRONG_HK_PACKET_TYPE;
-    	}
-    	return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
-    			dataSet, true);
+        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+        if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
+                and dataSet->isDiagnostics()) {
+            return WRONG_HK_PACKET_TYPE;
+        }
+        else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
+                and not dataSet->isDiagnostics()) {
+            return WRONG_HK_PACKET_TYPE;
+        }
+        return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+                dataSet, true);
     }
 
     // Notification handling.
@@ -522,30 +545,30 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     }
 
     CommandMessage reply;
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
-	}
-	else {
-		HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
-	}
-	hkQueue->sendMessage(hkDestinationId, &reply);
-	return result;
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
+    }
+    else {
+        HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
+    }
+    hkQueue->sendMessage(hkDestinationId, &reply);
+    return result;
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
-		lp_id_t localPoolId) {
-	auto poolIter = localPoolMap.find(localPoolId);
-	if (poolIter == localPoolMap.end()) {
-		sif::debug << "HousekeepingManager::fechPoolEntry:"
-				<< " Pool entry not found." << std::endl;
-		return POOL_ENTRY_NOT_FOUND;
-	}
-	poolIter->second->print();
-	return HasReturnvaluesIF::RETURN_OK;
+        lp_id_t localPoolId) {
+    auto poolIter = localPoolMap.find(localPoolId);
+    if (poolIter == localPoolMap.end()) {
+        sif::debug << "HousekeepingManager::fechPoolEntry:"
+                << " Pool entry not found." << std::endl;
+        return POOL_ENTRY_NOT_FOUND;
+    }
+    poolIter->second->print();
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 MutexIF* LocalDataPoolManager::getMutexHandle() {
-	return mutex;
+    return mutex;
 }
 
 HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
@@ -553,51 +576,51 @@ HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-		LocalPoolDataSetBase* dataSet, bool forDownlink,
-		MessageQueueId_t destination) {
-	if(dataSet == nullptr) {
-		// Configuration error.
-		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				<< " Set ID not found or dataset not assigned!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        LocalPoolDataSetBase* dataSet, bool forDownlink,
+        MessageQueueId_t destination) {
+    if(dataSet == nullptr) {
+        // Configuration error.
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+                << " Set ID not found or dataset not assigned!" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	store_address_t storeId;
-	HousekeepingPacketDownlink hkPacket(sid, dataSet);
-	size_t serializedSize = 0;
-	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
-			forDownlink, &serializedSize);
-	if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
-	    return result;
-	}
+    store_address_t storeId;
+    HousekeepingPacketDownlink hkPacket(sid, dataSet);
+    size_t serializedSize = 0;
+    ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
+            forDownlink, &serializedSize);
+    if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
+        return result;
+    }
 
-	// and now we set a HK message and send it the HK packet destination.
-	CommandMessage hkMessage;
-	if(dataSet->isDiagnostics()) {
-		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
-	}
-	else {
-		HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
-	}
+    // and now we set a HK message and send it the HK packet destination.
+    CommandMessage hkMessage;
+    if(dataSet->isDiagnostics()) {
+        HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
+    }
+    else {
+        HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
+    }
 
-	if(hkQueue == nullptr) {
-	    return QUEUE_OR_DESTINATION_NOT_SET;
-	}
-	if(destination == MessageQueueIF::NO_QUEUE) {
-	    if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
-	        // error, all destinations invalid
-	        return HasReturnvaluesIF::RETURN_FAILED;
-	    }
-	    destination = hkDestinationId;
-	}
+    if(hkQueue == nullptr) {
+        return QUEUE_OR_DESTINATION_NOT_SET;
+    }
+    if(destination == MessageQueueIF::NO_QUEUE) {
+        if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
+            // error, all destinations invalid
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        destination = hkDestinationId;
+    }
 
-	return hkQueue->sendMessage(destination, &hkMessage);
+    return hkQueue->sendMessage(destination, &hkMessage);
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
         HousekeepingPacketDownlink& hkPacket,
         store_address_t& storeId, bool forDownlink,
-		size_t* serializedSize) {
+        size_t* serializedSize) {
     uint8_t* dataPtr = nullptr;
     const size_t maxSize = hkPacket.getSerializedSize();
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
@@ -607,8 +630,8 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
     }
 
     if(forDownlink) {
-    	return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-    	            SerializeIF::Endianness::BIG);
+        return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+                SerializeIF::Endianness::BIG);
     }
     return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
             SerializeIF::Endianness::MACHINE);
@@ -620,124 +643,124 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 }
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
-	sid_t sid = receiver.dataId.sid;
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if(not dataSet->getReportingEnabled()) {
-		return;
-	}
+    sid_t sid = receiver.dataId.sid;
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(not dataSet->getReportingEnabled()) {
+        return;
+    }
 
-	if(dataSet->periodicHelper == nullptr) {
-		// Configuration error.
-		return;
-	}
+    if(dataSet->periodicHelper == nullptr) {
+        // Configuration error.
+        return;
+    }
 
-	if(not dataSet->periodicHelper->checkOpNecessary()) {
-		return;
-	}
+    if(not dataSet->periodicHelper->checkOpNecessary()) {
+        return;
+    }
 
-	ReturnValue_t result = generateHousekeepingPacket(
-			sid, dataSet, true);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		// configuration error
-		sif::debug << "LocalDataPoolManager::performHkOperation:"
-				<< "0x" << std::hex << std::setfill('0') << std::setw(8)
-				<< owner->getObjectId() << " Error generating "
-				<< "HK packet" << std::setfill(' ') << std::dec << std::endl;
-	}
+    ReturnValue_t result = generateHousekeepingPacket(
+            sid, dataSet, true);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        // configuration error
+        sif::debug << "LocalDataPoolManager::performHkOperation:"
+                << "0x" << std::hex << std::setfill('0') << std::setw(8)
+                << owner->getObjectId() << " Error generating "
+                << "HK packet" << std::setfill(' ') << std::dec << std::endl;
+    }
 }
 
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
-		bool enable, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if((dataSet->isDiagnostics() and not isDiagnostics) or
-			(not dataSet->isDiagnostics() and isDiagnostics)) {
-		return WRONG_HK_PACKET_TYPE;
-	}
+        bool enable, bool isDiagnostics) {
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if((dataSet->isDiagnostics() and not isDiagnostics) or
+            (not dataSet->isDiagnostics() and isDiagnostics)) {
+        return WRONG_HK_PACKET_TYPE;
+    }
 
-	if((dataSet->getReportingEnabled() and enable) or
-			(not dataSet->getReportingEnabled() and not enable)) {
-		return REPORTING_STATUS_UNCHANGED;
-	}
+    if((dataSet->getReportingEnabled() and enable) or
+            (not dataSet->getReportingEnabled() and not enable)) {
+        return REPORTING_STATUS_UNCHANGED;
+    }
 
-	dataSet->setReportingEnabled(enable);
-	return HasReturnvaluesIF::RETURN_OK;
+    dataSet->setReportingEnabled(enable);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
-		float newCollectionInterval, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	bool targetIsDiagnostics = dataSet->isDiagnostics();
-	if((targetIsDiagnostics and not isDiagnostics) or
-			(not targetIsDiagnostics and isDiagnostics)) {
-		return WRONG_HK_PACKET_TYPE;
-	}
+        float newCollectionInterval, bool isDiagnostics) {
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    bool targetIsDiagnostics = dataSet->isDiagnostics();
+    if((targetIsDiagnostics and not isDiagnostics) or
+            (not targetIsDiagnostics and isDiagnostics)) {
+        return WRONG_HK_PACKET_TYPE;
+    }
 
-	if(dataSet->periodicHelper == nullptr) {
-		// config error
-		return PERIODIC_HELPER_INVALID;
-	}
+    if(dataSet->periodicHelper == nullptr) {
+        // config error
+        return PERIODIC_HELPER_INVALID;
+    }
 
-	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
-	return HasReturnvaluesIF::RETURN_OK;
+    dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
-		bool isDiagnostics) {
+        bool isDiagnostics) {
     // Get and check dataset first.
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if(dataSet == nullptr) {
-		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				<< " Set ID not found" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(dataSet == nullptr) {
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+                << " Set ID not found" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
 
-	bool targetIsDiagnostics = dataSet->isDiagnostics();
-	if((targetIsDiagnostics and not isDiagnostics) or
-			(not targetIsDiagnostics and isDiagnostics)) {
-		return WRONG_HK_PACKET_TYPE;
-	}
+    bool targetIsDiagnostics = dataSet->isDiagnostics();
+    if((targetIsDiagnostics and not isDiagnostics) or
+            (not targetIsDiagnostics and isDiagnostics)) {
+        return WRONG_HK_PACKET_TYPE;
+    }
 
-	bool valid = dataSet->isValid();
-	bool reportingEnabled = dataSet->getReportingEnabled();
-	float collectionInterval =
-			dataSet->periodicHelper->getCollectionIntervalInSeconds();
+    bool valid = dataSet->isValid();
+    bool reportingEnabled = dataSet->getReportingEnabled();
+    float collectionInterval =
+            dataSet->periodicHelper->getCollectionIntervalInSeconds();
 
-	// Generate set packet which can be serialized.
-	HousekeepingSetPacket setPacket(sid,
-			reportingEnabled, valid, collectionInterval, dataSet);
-	size_t expectedSize = setPacket.getSerializedSize();
-	uint8_t* storePtr = nullptr;
-	store_address_t storeId;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-			expectedSize,&storePtr);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-				<< "Could not get free element from IPC store." << std::endl;
-		return result;
-	}
+    // Generate set packet which can be serialized.
+    HousekeepingSetPacket setPacket(sid,
+            reportingEnabled, valid, collectionInterval, dataSet);
+    size_t expectedSize = setPacket.getSerializedSize();
+    uint8_t* storePtr = nullptr;
+    store_address_t storeId;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            expectedSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+                << "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
 
-	// Serialize set packet into store.
-	size_t size = 0;
-	result = setPacket.serialize(&storePtr, &size, expectedSize,
-			SerializeIF::Endianness::BIG);
-	if(expectedSize != size) {
-		sif::error << "HousekeepingManager::generateSetStructurePacket: "
-				<< "Expected size is not equal to serialized size" << std::endl;
-	}
+    // Serialize set packet into store.
+    size_t size = 0;
+    result = setPacket.serialize(&storePtr, &size, expectedSize,
+            SerializeIF::Endianness::BIG);
+    if(expectedSize != size) {
+        sif::error << "HousekeepingManager::generateSetStructurePacket: "
+                << "Expected size is not equal to serialized size" << std::endl;
+    }
 
-	// Send structure reporting reply.
-	CommandMessage reply;
-	if(isDiagnostics) {
-	    HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
-	            sid, storeId);
-	}
-	else {
-	    HousekeepingMessage::setHkStuctureReportReply(&reply,
-	                    sid, storeId);
-	}
+    // Send structure reporting reply.
+    CommandMessage reply;
+    if(isDiagnostics) {
+        HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
+                sid, storeId);
+    }
+    else {
+        HousekeepingMessage::setHkStuctureReportReply(&reply,
+                sid, storeId);
+    }
 
-	hkQueue->reply(&reply);
-	return result;
+    hkQueue->reply(&reply);
+    return result;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 5cd4b62b6..6e237c48e 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -7,15 +7,15 @@
 #include <cstring>
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-		uint32_t setId, PoolVariableIF** registeredVariablesArray,
-		const size_t maxNumberOfVariables, bool noPeriodicHandling):
-		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-	if(hkOwner == nullptr) {
-		// Configuration error.
-		sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-				<< "invalid!" << std::endl;
-		return;
-	}
+        uint32_t setId, PoolVariableIF** registeredVariablesArray,
+        const size_t maxNumberOfVariables, bool noPeriodicHandling):
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+    if(hkOwner == nullptr) {
+        // Configuration error.
+        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+                << "invalid!" << std::endl;
+        return;
+    }
     hkManager = hkOwner->getHkManagerHandle();
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
@@ -24,20 +24,20 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 
     // Data creators get a periodic helper for periodic HK data generation.
     if(not noPeriodicHandling) {
-    	 periodicHelper = new PeriodicHousekeepingHelper(this);
+        periodicHelper = new PeriodicHousekeepingHelper(this);
     }
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
-        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
+                PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
     if(hkOwner == nullptr) {
-    	// Configuration error.
+        // Configuration error.
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-        		<< "invalid!" << std::endl;
+                << "invalid!" << std::endl;
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
@@ -50,8 +50,8 @@ LocalPoolDataSetBase::~LocalPoolDataSetBase() {
 }
 
 ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+    MutexIF* mutex = hkManager->getMutexHandle();
+    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
@@ -97,7 +97,7 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
     ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
     for (uint16_t count = 0; count < fillCount; count++) {
         result = registeredVariables[count]->deSerialize(buffer, size,
-                        streamEndianness);
+                streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             return result;
         }
@@ -127,8 +127,8 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->unlockMutex();
+    MutexIF* mutex = hkManager->getMutexHandle();
+    return mutex->unlockMutex();
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
@@ -205,7 +205,7 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
         sif::debug << "Pool Raw Access: Bit setting invalid position"
-        		<< std::endl;
+                << std::endl;
         return;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
@@ -213,47 +213,49 @@ void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
 }
 
 void LocalPoolDataSetBase::setDiagnostic(bool isDiagnostics) {
-	this->diagnostic = isDiagnostics;
+    this->diagnostic = isDiagnostics;
 }
 
 bool LocalPoolDataSetBase::isDiagnostics() const {
-	return diagnostic;
+    return diagnostic;
 }
 
 void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
-	this->reportingEnabled = reportingEnabled;
+    this->reportingEnabled = reportingEnabled;
 }
 
 bool LocalPoolDataSetBase::getReportingEnabled() const {
-	return reportingEnabled;
+    return reportingEnabled;
 }
 
 void LocalPoolDataSetBase::initializePeriodicHelper(
-		float collectionInterval, dur_millis_t minimumPeriodicInterval,
-		bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
-	periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
-			isDiagnostics, nonDiagIntervalFactor);
+        float collectionInterval, dur_millis_t minimumPeriodicInterval,
+        bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
+    periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
+            isDiagnostics, nonDiagIntervalFactor);
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
-	this->changed = changed;
+    // TODO: Make this configurable?
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
-	return changed;
+    // TODO: Make this configurable?
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    return changed;
 }
 
 sid_t LocalPoolDataSetBase::getSid() const {
-	return sid;
+    return sid;
 }
 
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
-		uint8_t position) const {
+        uint8_t position) const {
     if(position > 7) {
         sif::debug << "Pool Raw Access: Bit setting invalid position"
-        		<< std::endl;
+                << std::endl;
         return false;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
@@ -267,10 +269,10 @@ bool LocalPoolDataSetBase::isValid() const {
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
-	if(setEntriesRecursively) {
-		for(size_t idx = 0; idx < this->getFillCount(); idx++) {
-			registeredVariables[idx] -> setValid(valid);
-		}
-	}
-	this->valid = valid;
+    if(setEntriesRecursively) {
+        for(size_t idx = 0; idx < this->getFillCount(); idx++) {
+            registeredVariables[idx] -> setValid(valid);
+        }
+    }
+    this->valid = valid;
 }

From 65aecc356590778da5f66939d8bfe0c10226f8bb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 23:23:05 +0100
Subject: [PATCH 0993/1774] IT IS DONE

---
 datapoollocal/LocalDataPoolManager.cpp  | 59 ++++++++++++++++---------
 datapoollocal/LocalDataPoolManager.h    |  4 +-
 housekeeping/HousekeepingPacketUpdate.h | 35 ++++++++++-----
 3 files changed, 65 insertions(+), 33 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 440afa238..132dc3971 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -211,30 +211,24 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         }
 
         // prepare and send update snapshot.
-        CommandMessage notification;
         timeval now;
         Clock::getClock_timeval(&now);
         CCSDSTime::CDS_short cds;
         CCSDSTime::convertToCcsds(&cds, &now);
         HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-                sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+                sizeof(cds), owner->getPoolObjectHandle(
+                receiver.dataId.localPoolId));
         size_t updatePacketSize = updatePacket.getSerializedSize();
 
         store_address_t storeId;
-        uint8_t *storePtr = nullptr;
-        ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-                updatePacket.getSerializedSize(), &storePtr);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
+        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
             return result;
         }
-        size_t serializedSize = 0;
-        result = updatePacket.serialize(&storePtr, &serializedSize,
-                updatePacketSize, SerializeIF::Endianness::MACHINE);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-        HousekeepingMessage::setUpdateSnapshotSetCommand(&notification,
-                receiver.dataId.sid, storeId);
+
+        CommandMessage notification;
+        HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
+                receiver.dataId.localPoolId, storeId);
         result = hkQueue->sendMessage(receiver.destinationQueue,
                 &notification);
         if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -254,13 +248,23 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         }
 
         // prepare and send update snapshot.
-        CommandMessage notification;
-        // todo: serialize into store with timestamp.
+        timeval now;
+        Clock::getClock_timeval(&now);
+        CCSDSTime::CDS_short cds;
+        CCSDSTime::convertToCcsds(&cds, &now);
+        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+                sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+
         store_address_t storeId;
-        HousekeepingMessage::setUpdateSnapshotVariableCommand(
-                &notification, receiver.dataId.localPoolId, storeId);
-        ReturnValue_t result = hkQueue->sendMessage(
-                receiver.destinationQueue, &notification);
+        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+
+        CommandMessage notification;
+        HousekeepingMessage::setUpdateSnapshotSetCommand(
+                &notification, receiver.dataId.sid, storeId);
+        result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             status = result;
         }
@@ -274,6 +278,21 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
     return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t LocalDataPoolManager::addUpdateToStore(
+        HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
+    size_t updatePacketSize = updatePacket.getSerializedSize();
+    uint8_t *storePtr = nullptr;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            updatePacket.getSerializedSize(), &storePtr);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    size_t serializedSize = 0;
+    result = updatePacket.serialize(&storePtr, &serializedSize,
+            updatePacketSize, SerializeIF::Endianness::MACHINE);
+    return result;;
+}
+
 void LocalDataPoolManager::handleChangeResetLogic(
         DataType type, DataId dataId, MarkChangedIF* toReset) {
     if(hkUpdateResetList == nullptr) {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index a5cd0f98c..f48b14ceb 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -21,7 +21,7 @@ void setStaticFrameworkObjectIds();
 }
 
 class LocalDataSetBase;
-
+class HousekeepingPacketUpdate;
 
 /**
  * @brief 		This class is the managing instance for the local data pool.
@@ -357,6 +357,8 @@ private:
 	        ReturnValue_t& status);
 	ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver,
             ReturnValue_t& status);
+	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
+	        store_address_t& storeId);
 };
 
 
diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index 37d38be75..702db55ee 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -12,6 +12,7 @@
 class HousekeepingPacketUpdate: public SerializeIF {
 public:
     /**
+     * Update packet constructor for datasets
      * @param timeStamp
      * @param timeStampSize
      * @param hkData
@@ -19,8 +20,19 @@ public:
      */
     HousekeepingPacketUpdate(uint8_t* timeStamp, size_t timeStampSize,
             LocalPoolDataSetBase* dataSetPtr):
-            timeStamp(timeStamp), timeStampSize(timeStampSize),
-            dataSetPtr(dataSetPtr) {};
+                timeStamp(timeStamp), timeStampSize(timeStampSize),
+                updateData(dataSetPtr) {};
+
+    /**
+     * Update packet constructor for pool variables.
+     * @param timeStamp
+     * @param timeStampSize
+     * @param dataSetPtr
+     */
+    HousekeepingPacketUpdate(uint8_t* timeStamp, size_t timeStampSize,
+            LocalPoolObjectBase* dataSetPtr):
+                timeStamp(timeStamp), timeStampSize(timeStampSize),
+                updateData(dataSetPtr) {};
 
     virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
             size_t maxSize, Endianness streamEndianness) const {
@@ -31,18 +43,18 @@ public:
             *size += timeStampSize;
             *buffer += timeStampSize;
         }
-        if(dataSetPtr == nullptr) {
+        if(updateData == nullptr) {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
 
-        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
+        return updateData->serialize(buffer, size, maxSize, streamEndianness);
     }
 
     virtual size_t getSerializedSize() const {
-        if(dataSetPtr == nullptr) {
+        if(updateData == nullptr) {
             return 0;
         }
-        return timeStampSize + dataSetPtr->getSerializedSize();
+        return timeStampSize + updateData->getSerializedSize();
     }
 
     virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
@@ -55,19 +67,18 @@ public:
             *buffer += timeStampSize;
         }
 
-        if(dataSetPtr == nullptr) {
+        if(updateData == nullptr) {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
-        return dataSetPtr->deSerialize(buffer, size, streamEndianness);
+        return updateData->deSerialize(buffer, size, streamEndianness);
     }
 
 private:
-   uint8_t* timeStamp;
-   size_t timeStampSize;
+   uint8_t* timeStamp = nullptr;
+   size_t timeStampSize = 0;
 
-   LocalPoolDataSetBase* dataSetPtr = nullptr;
+   SerializeIF* updateData = nullptr;
 };
 
 
-
 #endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_ */

From f72ee0b7acb70dc0e91f7a50884a491ece57a334 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 23:26:28 +0100
Subject: [PATCH 0994/1774] small bugfix

---
 housekeeping/HousekeepingPacketUpdate.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index 702db55ee..48fe1bfdc 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -63,7 +63,7 @@ public:
             /* Endianness will always be MACHINE, so we can simply use memcpy
             here. */
             std::memcpy(timeStamp, *buffer, timeStampSize);
-            *size += timeStampSize;
+            *size -= timeStampSize;
             *buffer += timeStampSize;
         }
 

From e99cf32bddf33f7c44c14a355ae2c167f2a8a78e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 23:29:03 +0100
Subject: [PATCH 0995/1774] amazing size checks

---
 housekeeping/HousekeepingPacketUpdate.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index 48fe1bfdc..43ec0619c 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -59,6 +59,10 @@ public:
 
     virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
             SerializeIF::Endianness streamEndianness) override {
+        if(*size < timeStampSize) {
+            return SerializeIF::STREAM_TOO_SHORT;
+        }
+
         if(timeStamp != nullptr) {
             /* Endianness will always be MACHINE, so we can simply use memcpy
             here. */
@@ -70,6 +74,10 @@ public:
         if(updateData == nullptr) {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
+        if(*size < updateData->getSerializedSize()) {
+            return SerializeIF::STREAM_TOO_SHORT;
+        }
+
         return updateData->deSerialize(buffer, size, streamEndianness);
     }
 

From cf7385d64ec3f541d69b7fe23ad38ec8b6b0e9bf Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 23:32:34 +0100
Subject: [PATCH 0996/1774] include fixes

---
 datapoollocal/LocalDataPoolManager.cpp | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 132dc3971..f649a3623 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,5 +1,3 @@
-#include <fsfw/timemanager/CCSDSTime.h>
-#include <fsfw/timemanager/TimeStamperIF.h>
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
@@ -8,10 +6,10 @@
 #include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
 
+#include "../timemanager/CCSDSTime.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
 #include "../ipc/QueueFactory.h"
-#include "../objectmanager/frameworkObjects.h"
 
 #include <array>
 #include <cmath>
@@ -218,7 +216,6 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
                 sizeof(cds), owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId));
-        size_t updatePacketSize = updatePacket.getSerializedSize();
 
         store_address_t storeId;
         ReturnValue_t result = addUpdateToStore(updatePacket, storeId);

From 5efbc7496a57ff5549ca381dad521b277c0798ed Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 23:39:56 +0100
Subject: [PATCH 0997/1774] doc improved, some functions virtual now

---
 datapoollocal/LocalDataPoolManager.h | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index f48b14ceb..187ae5d58 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -27,9 +27,16 @@ class HousekeepingPacketUpdate;
  * @brief 		This class is the managing instance for the local data pool.
  * @details
  * The actual data pool structure is a member of this class. Any class which
- * has a local data pool shall have this class as a member and implement
+ * has a local data pool shall have this manager class as a member and implement
  * the HasLocalDataPoolIF.
  *
+ * The manager offers some adaption points and functions which can be used
+ * by the owning class to simplify data handling significantly.
+ *
+ * Please ensure that both initialize and initializeAfterTaskCreation are
+ * called at some point by the owning class in the respective functions of the
+ * same name!
+ *
  * Users of the data pool use the helper classes LocalDataSet,
  * LocalPoolVariable and LocalPoolVector to access pool entries in
  * a thread-safe and efficient way.
@@ -67,14 +74,16 @@ public:
      * initialize() has to be called in any case before using the object!
      * @param owner
      * @param queueToUse
-     * @param appendValidityBuffer
+     * @param appendValidityBuffer Specify whether a buffer containing the
+     * validity state is generated  when serializing or deserializing packets.
      */
 	LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
 	        bool appendValidityBuffer = true);
 	virtual~ LocalDataPoolManager();
 
 	/**
-	 * Assigns the queue to use.
+	 * Assigns the queue to use. Make sure to call this in the #initialize
+	 * function of the owner.
 	 * @param queueToUse
 	 * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
 	 * @return
@@ -84,20 +93,24 @@ public:
 	/**
 	 * Initializes the map by calling the map initialization function and
 	 * setting the periodic factor for non-diagnostic packets.
-	 * Don't forget to call this, otherwise the map will be invalid!
+	 * Don't forget to call this in the #initializeAfterTaskCreation call of
+	 * the owner, otherwise the map will be invalid!
 	 * @param nonDiagInvlFactor
 	 * @return
 	 */
-	ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
+	ReturnValue_t initializeAfterTaskCreation(
+	        uint8_t nonDiagInvlFactor = 5);
 
     /**
      * @brief   This should be called in the periodic handler of the owner.
      * @details
+     * This in generally called in the #performOperation function of the owner.
      * It performs all the periodic functionalities of the data pool manager,
      * for example generating periodic HK packets.
+     * Marked virtual as an adaption point for custom data pool managers.
      * @return
      */
-    ReturnValue_t performHkOperation();
+    virtual ReturnValue_t performHkOperation();
 
 	/**
 	 * @brief   Subscribe for the generation of periodic packets.
@@ -185,7 +198,7 @@ public:
      * @param message
      * @return
      */
-    ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
+    virtual ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
 	/**
 	 * Generate a housekeeping packet with a given SID.

From 8d109b7cd0a4955a1289a54cd7d6e9e148ae6650 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 5 Nov 2020 11:57:05 +0100
Subject: [PATCH 0998/1774] preproc define correction

---
 events/EventManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index acc17b03f..182fb72be 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -42,7 +42,7 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {
 		EventMessage message;
 		result = eventReportQueue->receiveMessage(&message);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
-#ifdef FSFW_OBJECTMANAGER_
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 			printEvent(&message);
 #endif
 			notifyListeners(&message);

From 1b2af5285d6269b482f8717902fc811d5781f99e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 5 Nov 2020 13:12:42 +0100
Subject: [PATCH 0999/1774] message queue depth configurable

---
 pus/Service5EventReporting.cpp | 5 +++--
 pus/Service5EventReporting.h   | 3 ++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index 829d04bde..e0b34a5b4 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -8,10 +8,11 @@
 
 
 Service5EventReporting::Service5EventReporting(object_id_t objectId,
-            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
+            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle,
+            uint32_t messageQueueDepth):
 		PusServiceBase(objectId, apid, serviceId),
 		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
+	eventQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }
 
 Service5EventReporting::~Service5EventReporting(){}
diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h
index 78c18bf30..69242801f 100644
--- a/pus/Service5EventReporting.h
+++ b/pus/Service5EventReporting.h
@@ -42,7 +42,8 @@ class Service5EventReporting: public PusServiceBase {
 public:
 
 	Service5EventReporting(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
+	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10,
+	        uint32_t messageQueueDepth = 10);
 	virtual ~Service5EventReporting();
 
 	/***

From 7ffce219d5f86df29fe3348cdeb703419ba32acd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 7 Nov 2020 14:32:28 +0100
Subject: [PATCH 1000/1774] hosted build fix

---
 events/EventManager.cpp | 4 ++--
 events/EventManager.h   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index f60a8a66d..d171b5913 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -42,7 +42,7 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {
 		EventMessage message;
 		result = eventReportQueue->receiveMessage(&message);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
-#ifdef DEBUG
+#if FSFW_DEBUG_OUTPUT == 1
 			printEvent(&message);
 #endif
 			notifyListeners(&message);
@@ -113,7 +113,7 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 	return result;
 }
 
-#ifdef DEBUG
+#if FSFW_DEBUG_OUTPUT == 1
 
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
diff --git a/events/EventManager.h b/events/EventManager.h
index 2602aeb23..5e1a8153a 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -55,7 +55,7 @@ protected:
 
 	void notifyListeners(EventMessage *message);
 
-#ifdef DEBUG
+#if FSFW_DEBUG_OUTPUT == 1
 	void printEvent(EventMessage *message);
 #endif
 

From aa45d34b4a682c1240f5c4ad8d86bff99f858bae Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 8 Nov 2020 15:20:51 +0100
Subject: [PATCH 1001/1774] include improvements /factory improvement

---
 defaultcfg/config/objects/Factory.cpp | 14 +++++++-------
 events/Event.h                        |  2 +-
 ipc/MessageQueueIF.h                  |  2 +-
 ipc/MessageQueueMessageIF.h           |  2 +-
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/defaultcfg/config/objects/Factory.cpp b/defaultcfg/config/objects/Factory.cpp
index 51dd61304..41333b1c3 100644
--- a/defaultcfg/config/objects/Factory.cpp
+++ b/defaultcfg/config/objects/Factory.cpp
@@ -11,6 +11,7 @@
 #include <fsfw/tmtcpacket/pus/TmPacketStored.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
+#include <internalError/InternalErrorReporter.h>
 
 #include <cstdint>
 
@@ -31,15 +32,15 @@ void Factory::produce(void) {
 	setStaticFrameworkObjectIds();
 	new EventManager(objects::EVENT_MANAGER);
 	new HealthTable(objects::HEALTH_TABLE);
-	//new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
 }
 
 void Factory::setStaticFrameworkObjectIds() {
-	PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
-	PusServiceBase::packetDestination = objects::TM_FUNNEL;
+	PusServiceBase::packetSource = objects::NO_OBJECT;
+	PusServiceBase::packetDestination = objects::NO_OBJECT;
 
-	CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
-	CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+	CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+	CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
 
 	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
 
@@ -48,7 +49,6 @@ void Factory::setStaticFrameworkObjectIds() {
 
 	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
 
-	TmPacketStored::timeStamperId = objects::PUS_TIME;
-	//TmFunnel::downlinkDestination = objects::NO_OBJECT;
+	TmPacketStored::timeStamperId = objects::NO_OBJECT;
 }
 
diff --git a/events/Event.h b/events/Event.h
index f5434826b..90ff1a901 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include "fwSubsystemIdRanges.h"
 //could be move to more suitable location
-#include <subsystemIdRanges.h>
+#include <events/subsystemIdRanges.h>
 
 typedef uint16_t EventId_t;
 typedef uint8_t EventSeverity_t;
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 44b6f4c00..1c06521ca 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
 #define FSFW_IPC_MESSAGEQUEUEIF_H_
 
-#include <fsfw/ipc/messageQueueDefinitions.h>
+#include "messageQueueDefinitions.h"
 #include "MessageQueueMessageIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index b5a30c086..33e01e7d0 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 
-#include <fsfw/ipc/messageQueueDefinitions.h>
+#include "messageQueueDefinitions.h"
 #include <cstddef>
 #include <cstdint>
 

From 319ae724785807329a8bf9304e3228604a64fbe9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 8 Nov 2020 15:29:06 +0100
Subject: [PATCH 1002/1774] folder config renamed to fsfwconfig

---
 defaultcfg/{config => fsfwconfig}/FSFWConfig.h                    | 0
 defaultcfg/{config => fsfwconfig}/OBSWConfig.h                    | 0
 defaultcfg/{config => fsfwconfig}/OBSWVersion.h                   | 0
 defaultcfg/{config => fsfwconfig}/config.mk                       | 0
 defaultcfg/{config => fsfwconfig}/devices/logicalAddresses.cpp    | 0
 defaultcfg/{config => fsfwconfig}/devices/logicalAddresses.h      | 0
 defaultcfg/{config => fsfwconfig}/devices/powerSwitcherList.cpp   | 0
 defaultcfg/{config => fsfwconfig}/devices/powerSwitcherList.h     | 0
 defaultcfg/{config => fsfwconfig}/events/subsystemIdRanges.h      | 0
 defaultcfg/{config => fsfwconfig}/ipc/missionMessageTypes.cpp     | 0
 defaultcfg/{config => fsfwconfig}/ipc/missionMessageTypes.h       | 0
 defaultcfg/{config => fsfwconfig}/objects/Factory.cpp             | 0
 defaultcfg/{config => fsfwconfig}/objects/Factory.h               | 0
 defaultcfg/{config => fsfwconfig}/objects/systemObjectList.h      | 0
 defaultcfg/{config => fsfwconfig}/objects/translateObjects.cpp    | 0
 defaultcfg/{config => fsfwconfig}/objects/translateObjects.h      | 0
 .../pollingsequence/PollingSequenceFactory.cpp                    | 0
 .../pollingsequence/PollingSequenceFactory.h                      | 0
 defaultcfg/{config => fsfwconfig}/returnvalues/classIds.h         | 0
 defaultcfg/{config => fsfwconfig}/tmtc/apid.h                     | 0
 defaultcfg/{config => fsfwconfig}/tmtc/pusIds.h                   | 0
 21 files changed, 0 insertions(+), 0 deletions(-)
 rename defaultcfg/{config => fsfwconfig}/FSFWConfig.h (100%)
 rename defaultcfg/{config => fsfwconfig}/OBSWConfig.h (100%)
 rename defaultcfg/{config => fsfwconfig}/OBSWVersion.h (100%)
 rename defaultcfg/{config => fsfwconfig}/config.mk (100%)
 rename defaultcfg/{config => fsfwconfig}/devices/logicalAddresses.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/devices/logicalAddresses.h (100%)
 rename defaultcfg/{config => fsfwconfig}/devices/powerSwitcherList.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/devices/powerSwitcherList.h (100%)
 rename defaultcfg/{config => fsfwconfig}/events/subsystemIdRanges.h (100%)
 rename defaultcfg/{config => fsfwconfig}/ipc/missionMessageTypes.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/ipc/missionMessageTypes.h (100%)
 rename defaultcfg/{config => fsfwconfig}/objects/Factory.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/objects/Factory.h (100%)
 rename defaultcfg/{config => fsfwconfig}/objects/systemObjectList.h (100%)
 rename defaultcfg/{config => fsfwconfig}/objects/translateObjects.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/objects/translateObjects.h (100%)
 rename defaultcfg/{config => fsfwconfig}/pollingsequence/PollingSequenceFactory.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/pollingsequence/PollingSequenceFactory.h (100%)
 rename defaultcfg/{config => fsfwconfig}/returnvalues/classIds.h (100%)
 rename defaultcfg/{config => fsfwconfig}/tmtc/apid.h (100%)
 rename defaultcfg/{config => fsfwconfig}/tmtc/pusIds.h (100%)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
similarity index 100%
rename from defaultcfg/config/FSFWConfig.h
rename to defaultcfg/fsfwconfig/FSFWConfig.h
diff --git a/defaultcfg/config/OBSWConfig.h b/defaultcfg/fsfwconfig/OBSWConfig.h
similarity index 100%
rename from defaultcfg/config/OBSWConfig.h
rename to defaultcfg/fsfwconfig/OBSWConfig.h
diff --git a/defaultcfg/config/OBSWVersion.h b/defaultcfg/fsfwconfig/OBSWVersion.h
similarity index 100%
rename from defaultcfg/config/OBSWVersion.h
rename to defaultcfg/fsfwconfig/OBSWVersion.h
diff --git a/defaultcfg/config/config.mk b/defaultcfg/fsfwconfig/config.mk
similarity index 100%
rename from defaultcfg/config/config.mk
rename to defaultcfg/fsfwconfig/config.mk
diff --git a/defaultcfg/config/devices/logicalAddresses.cpp b/defaultcfg/fsfwconfig/devices/logicalAddresses.cpp
similarity index 100%
rename from defaultcfg/config/devices/logicalAddresses.cpp
rename to defaultcfg/fsfwconfig/devices/logicalAddresses.cpp
diff --git a/defaultcfg/config/devices/logicalAddresses.h b/defaultcfg/fsfwconfig/devices/logicalAddresses.h
similarity index 100%
rename from defaultcfg/config/devices/logicalAddresses.h
rename to defaultcfg/fsfwconfig/devices/logicalAddresses.h
diff --git a/defaultcfg/config/devices/powerSwitcherList.cpp b/defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp
similarity index 100%
rename from defaultcfg/config/devices/powerSwitcherList.cpp
rename to defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp
diff --git a/defaultcfg/config/devices/powerSwitcherList.h b/defaultcfg/fsfwconfig/devices/powerSwitcherList.h
similarity index 100%
rename from defaultcfg/config/devices/powerSwitcherList.h
rename to defaultcfg/fsfwconfig/devices/powerSwitcherList.h
diff --git a/defaultcfg/config/events/subsystemIdRanges.h b/defaultcfg/fsfwconfig/events/subsystemIdRanges.h
similarity index 100%
rename from defaultcfg/config/events/subsystemIdRanges.h
rename to defaultcfg/fsfwconfig/events/subsystemIdRanges.h
diff --git a/defaultcfg/config/ipc/missionMessageTypes.cpp b/defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
similarity index 100%
rename from defaultcfg/config/ipc/missionMessageTypes.cpp
rename to defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
diff --git a/defaultcfg/config/ipc/missionMessageTypes.h b/defaultcfg/fsfwconfig/ipc/missionMessageTypes.h
similarity index 100%
rename from defaultcfg/config/ipc/missionMessageTypes.h
rename to defaultcfg/fsfwconfig/ipc/missionMessageTypes.h
diff --git a/defaultcfg/config/objects/Factory.cpp b/defaultcfg/fsfwconfig/objects/Factory.cpp
similarity index 100%
rename from defaultcfg/config/objects/Factory.cpp
rename to defaultcfg/fsfwconfig/objects/Factory.cpp
diff --git a/defaultcfg/config/objects/Factory.h b/defaultcfg/fsfwconfig/objects/Factory.h
similarity index 100%
rename from defaultcfg/config/objects/Factory.h
rename to defaultcfg/fsfwconfig/objects/Factory.h
diff --git a/defaultcfg/config/objects/systemObjectList.h b/defaultcfg/fsfwconfig/objects/systemObjectList.h
similarity index 100%
rename from defaultcfg/config/objects/systemObjectList.h
rename to defaultcfg/fsfwconfig/objects/systemObjectList.h
diff --git a/defaultcfg/config/objects/translateObjects.cpp b/defaultcfg/fsfwconfig/objects/translateObjects.cpp
similarity index 100%
rename from defaultcfg/config/objects/translateObjects.cpp
rename to defaultcfg/fsfwconfig/objects/translateObjects.cpp
diff --git a/defaultcfg/config/objects/translateObjects.h b/defaultcfg/fsfwconfig/objects/translateObjects.h
similarity index 100%
rename from defaultcfg/config/objects/translateObjects.h
rename to defaultcfg/fsfwconfig/objects/translateObjects.h
diff --git a/defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
similarity index 100%
rename from defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp
rename to defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
diff --git a/defaultcfg/config/pollingsequence/PollingSequenceFactory.h b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.h
similarity index 100%
rename from defaultcfg/config/pollingsequence/PollingSequenceFactory.h
rename to defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.h
diff --git a/defaultcfg/config/returnvalues/classIds.h b/defaultcfg/fsfwconfig/returnvalues/classIds.h
similarity index 100%
rename from defaultcfg/config/returnvalues/classIds.h
rename to defaultcfg/fsfwconfig/returnvalues/classIds.h
diff --git a/defaultcfg/config/tmtc/apid.h b/defaultcfg/fsfwconfig/tmtc/apid.h
similarity index 100%
rename from defaultcfg/config/tmtc/apid.h
rename to defaultcfg/fsfwconfig/tmtc/apid.h
diff --git a/defaultcfg/config/tmtc/pusIds.h b/defaultcfg/fsfwconfig/tmtc/pusIds.h
similarity index 100%
rename from defaultcfg/config/tmtc/pusIds.h
rename to defaultcfg/fsfwconfig/tmtc/pusIds.h

From 225e65628db70873cc6267cef55e915f65088ad8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 9 Nov 2020 00:12:39 +0100
Subject: [PATCH 1003/1774] include corrections

---
 defaultcfg/fsfwconfig/devices/logicalAddresses.h   | 2 +-
 defaultcfg/fsfwconfig/{config.mk => fsfwconfig.mk} | 0
 defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp  | 3 ++-
 unittest/tests/storagemanager/TestPool.cpp         | 1 -
 4 files changed, 3 insertions(+), 3 deletions(-)
 rename defaultcfg/fsfwconfig/{config.mk => fsfwconfig.mk} (100%)

diff --git a/defaultcfg/fsfwconfig/devices/logicalAddresses.h b/defaultcfg/fsfwconfig/devices/logicalAddresses.h
index 174fa788b..e0827ba33 100644
--- a/defaultcfg/fsfwconfig/devices/logicalAddresses.h
+++ b/defaultcfg/fsfwconfig/devices/logicalAddresses.h
@@ -1,8 +1,8 @@
 #ifndef CONFIG_DEVICES_LOGICALADDRESSES_H_
 #define CONFIG_DEVICES_LOGICALADDRESSES_H_
 
-#include <config/objects/systemObjectList.h>
 #include <fsfw/devicehandlers/CookieIF.h>
+#include "../objects/systemObjectList.h"
 #include <cstdint>
 
 /**
diff --git a/defaultcfg/fsfwconfig/config.mk b/defaultcfg/fsfwconfig/fsfwconfig.mk
similarity index 100%
rename from defaultcfg/fsfwconfig/config.mk
rename to defaultcfg/fsfwconfig/fsfwconfig.mk
diff --git a/defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp b/defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
index e2edbf9c5..b41b87ba1 100644
--- a/defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
+++ b/defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
@@ -1,4 +1,5 @@
-#include <config/ipc/MissionMessageTypes.h>
+#include "missionMessageTypes.h"
+
 #include <fsfw/ipc/CommandMessageIF.h>
 
 void messagetypes::clearMissionMessage(CommandMessage* message) {
diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
index 3f5341e99..daeb6bb52 100644
--- a/unittest/tests/storagemanager/TestPool.cpp
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -1,6 +1,5 @@
 #include "CatchDefinitions.h"
 
-#include <config/objects/Factory.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/storagemanager/LocalPool.h>
 

From 72f7a1b1b786d97624632d8291a7fb2eaeb26882 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 9 Nov 2020 21:24:23 +0100
Subject: [PATCH 1004/1774] translation files removed

---
 .../fsfwconfig/objects/translateObjects.cpp   | 271 ------------------
 .../fsfwconfig/objects/translateObjects.h     |   9 -
 2 files changed, 280 deletions(-)
 delete mode 100644 defaultcfg/fsfwconfig/objects/translateObjects.cpp
 delete mode 100644 defaultcfg/fsfwconfig/objects/translateObjects.h

diff --git a/defaultcfg/fsfwconfig/objects/translateObjects.cpp b/defaultcfg/fsfwconfig/objects/translateObjects.cpp
deleted file mode 100644
index 73cd02bfe..000000000
--- a/defaultcfg/fsfwconfig/objects/translateObjects.cpp
+++ /dev/null
@@ -1,271 +0,0 @@
-/** 
- * @brief	Auto-generated object translation file. Contains 86 translations. 
- * Generated on: 2020-08-25 00:57:14
- **/ 
-#include "translateObjects.h"
-
-const char *AT91_UART2_TEST_TASK_STRING = "AT91_UART2_TEST_TASK";
-const char *ARDUINO_0_STRING = "ARDUINO_0";
-const char *ARDUINO_1_STRING = "ARDUINO_1";
-const char *ARDUINO_2_STRING = "ARDUINO_2";
-const char *ARDUINO_3_STRING = "ARDUINO_3";
-const char *ARDUINO_4_STRING = "ARDUINO_4";
-const char *AT91_I2C_TEST_TASK_STRING = "AT91_I2C_TEST_TASK";
-const char *LED_TASK_STRING = "LED_TASK";
-const char *TEST_TASK_STRING = "TEST_TASK";
-const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
-const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
-const char *SuS_ADC1_DEC2_STRING = "SuS_ADC1_DEC2";
-const char *GPS0_HANDLER_STRING = "GPS0_HANDLER";
-const char *DLR_PVCH_STRING = "DLR_PVCH";
-const char *GYRO1_STRING = "GYRO1";
-const char *DLR_IRAS_STRING = "DLR_IRAS";
-const char *SPI_Test_PT1000_STRING = "SPI_Test_PT1000";
-const char *PT1000_Syrlinks_DEC1_O1_STRING = "PT1000_Syrlinks_DEC1_O1";
-const char *PT1000_Camera_DEC1_O2_STRING = "PT1000_Camera_DEC1_O2";
-const char *PT1000_SuS1_DEC1_O3_STRING = "PT1000_SuS1_DEC1_O3";
-const char *PT1000_SuS2_DEC1_O4_STRING = "PT1000_SuS2_DEC1_O4";
-const char *PT1000_SuS3_DEC1_O5_STRING = "PT1000_SuS3_DEC1_O5";
-const char *PT1000_PVHC_DEC1_O6_STRING = "PT1000_PVHC_DEC1_O6";
-const char *SPI_Test_Gyro_STRING = "SPI_Test_Gyro";
-const char *PT1000_CCSDS1_DEC2_STRING = "PT1000_CCSDS1_DEC2";
-const char *PT1000_MGT1_DEC2_STRING = "PT1000_MGT1_DEC2";
-const char *PT1000_SuS4_DEC2_STRING = "PT1000_SuS4_DEC2";
-const char *PT1000_SuS5_DEC2_STRING = "PT1000_SuS5_DEC2";
-const char *PT1000_SuS6_DEC2_STRING = "PT1000_SuS6_DEC2";
-const char *PT1000_PVCH_DEC2_STRING = "PT1000_PVCH_DEC2";
-const char *PT1000_Iridium_DEC3_STRING = "PT1000_Iridium_DEC3";
-const char *PT1000_CCSDS2_DEC3_STRING = "PT1000_CCSDS2_DEC3";
-const char *PT1000_SuS7_DEC3_STRING = "PT1000_SuS7_DEC3";
-const char *PT1000_SuS8_DEC3_STRING = "PT1000_SuS8_DEC3";
-const char *PT1000_PVCH_DEC3_STRING = "PT1000_PVCH_DEC3";
-const char *GYRO2_STRING = "GYRO2";
-const char *PT1000_PLOC_DEC4_STRING = "PT1000_PLOC_DEC4";
-const char *PT1000_SuS9_DEC4_STRING = "PT1000_SuS9_DEC4";
-const char *PT1000_SuS10_DEC4_STRING = "PT1000_SuS10_DEC4";
-const char *PT1000_PVHC_DEC4_STRING = "PT1000_PVHC_DEC4";
-const char *SuS_ADC_DEC4_STRING = "SuS_ADC_DEC4";
-const char *GPS1_HANDLER_STRING = "GPS1_HANDLER";
-const char *DUMMY_GPS_COM_IF_STRING = "DUMMY_GPS_COM_IF";
-const char *RS232_DEVICE_COM_IF_STRING = "RS232_DEVICE_COM_IF";
-const char *I2C_DEVICE_COM_IF_STRING = "I2C_DEVICE_COM_IF";
-const char *GPIO_DEVICE_COM_IF_STRING = "GPIO_DEVICE_COM_IF";
-const char *SPI_POLLING_TASK_STRING = "SPI_POLLING_TASK";
-const char *SPI_DEVICE_COM_IF_STRING = "SPI_DEVICE_COM_IF";
-const char *DUMMY_ECHO_COM_IF_STRING = "DUMMY_ECHO_COM_IF";
-const char *SD_CARD_HANDLER_STRING = "SD_CARD_HANDLER";
-const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
-const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
-const char *UDP_TMTC_BRIDGE_STRING = "UDP_TMTC_BRIDGE";
-const char *EMAC_POLLING_TASK_STRING = "EMAC_POLLING_TASK";
-const char *SERIAL_TMTC_BRIDGE_STRING = "SERIAL_TMTC_BRIDGE";
-const char *SERIAL_RING_BUFFER_STRING = "SERIAL_RING_BUFFER";
-const char *SERIAL_POLLING_TASK_STRING = "SERIAL_POLLING_TASK";
-const char *PUS_SERVICE_1_STRING = "PUS_SERVICE_1";
-const char *PUS_SERVICE_2_STRING = "PUS_SERVICE_2";
-const char *PUS_SERVICE_3_STRING = "PUS_SERVICE_3";
-const char *PUS_SERVICE_3_PSB_STRING = "PUS_SERVICE_3_PSB";
-const char *PUS_SERVICE_5_STRING = "PUS_SERVICE_5";
-const char *PUS_SERVICE_6_STRING = "PUS_SERVICE_6";
-const char *PUS_SERVICE_8_STRING = "PUS_SERVICE_8";
-const char *PUS_SERVICE_9_STRING = "PUS_SERVICE_9";
-const char *PUS_SERVICE_17_STRING = "PUS_SERVICE_17";
-const char *PUS_SERVICE_20_STRING = "PUS_SERVICE_20";
-const char *PUS_SERVICE_23_STRING = "PUS_SERVICE_23";
-const char *PUS_SERVICE_200_STRING = "PUS_SERVICE_200";
-const char *PUS_SERVICE_201_STRING = "PUS_SERVICE_201";
-const char *PUS_TIME_STRING = "PUS_TIME";
-const char *PUS_FUNNEL_STRING = "PUS_FUNNEL";
-const char *FREERTOS_TASK_MONITOR_STRING = "FREERTOS_TASK_MONITOR";
-const char *HEALTH_TABLE_STRING = "HEALTH_TABLE";
-const char *MODE_STORE_STRING = "MODE_STORE";
-const char *EVENT_MANAGER_STRING = "EVENT_MANAGER";
-const char *INTERNAL_ERROR_REPORTER_STRING = "INTERNAL_ERROR_REPORTER";
-const char *TC_STORE_STRING = "TC_STORE";
-const char *TM_STORE_STRING = "TM_STORE";
-const char *IPC_STORE_STRING = "IPC_STORE";
-const char *AT91_SPI_TEST_TASK_STRING = "AT91_SPI_TEST_TASK";
-const char *STM32_TEST_TASK_STRING = "STM32_TEST_TASK";
-const char *AT91_UART0_TEST_TASK_STRING = "AT91_UART0_TEST_TASK";
-const char *TC_INJECTOR_STRING = "TC_INJECTOR";
-const char *NO_OBJECT_STRING = "NO_OBJECT";
-
-const char* translateObject(object_id_t object){
-	switch((object&0xFFFFFFFF)){
-		case 0x000123336:
-			return AT91_UART2_TEST_TASK_STRING;
-		case 0x01010100:
-			return ARDUINO_0_STRING;
-		case 0x01010101:
-			return ARDUINO_1_STRING;
-		case 0x01010102:
-			return ARDUINO_2_STRING;
-		case 0x01010103:
-			return ARDUINO_3_STRING;
-		case 0x01010104:
-			return ARDUINO_4_STRING;
-		case 0x12345678:
-			return AT91_I2C_TEST_TASK_STRING;
-		case 0x12345777:
-			return LED_TASK_STRING;
-		case 0x42694269:
-			return TEST_TASK_STRING;
-		case 0x44003200:
-			return PCDU_HANDLER_STRING;
-		case 0x4400AFFE:
-			return DUMMY_HANDLER_STRING;
-		case 0x44020108:
-			return SuS_ADC1_DEC2_STRING;
-		case 0x44101F00:
-			return GPS0_HANDLER_STRING;
-		case 0x44104000:
-			return DLR_PVCH_STRING;
-		case 0x44105000:
-			return GYRO1_STRING;
-		case 0x44106000:
-			return DLR_IRAS_STRING;
-		case 0x44115400:
-			return SPI_Test_PT1000_STRING;
-		case 0x44115401:
-			return PT1000_Syrlinks_DEC1_O1_STRING;
-		case 0x44115402:
-			return PT1000_Camera_DEC1_O2_STRING;
-		case 0x44115404:
-			return PT1000_SuS1_DEC1_O3_STRING;
-		case 0x44115405:
-			return PT1000_SuS2_DEC1_O4_STRING;
-		case 0x44115406:
-			return PT1000_SuS3_DEC1_O5_STRING;
-		case 0x44115407:
-			return PT1000_PVHC_DEC1_O6_STRING;
-		case 0x44115500:
-			return SPI_Test_Gyro_STRING;
-		case 0x44125401:
-			return PT1000_CCSDS1_DEC2_STRING;
-		case 0x44125403:
-			return PT1000_MGT1_DEC2_STRING;
-		case 0x44125404:
-			return PT1000_SuS4_DEC2_STRING;
-		case 0x44125405:
-			return PT1000_SuS5_DEC2_STRING;
-		case 0x44125406:
-			return PT1000_SuS6_DEC2_STRING;
-		case 0x44125407:
-			return PT1000_PVCH_DEC2_STRING;
-		case 0x44130301:
-			return PT1000_Iridium_DEC3_STRING;
-		case 0x44130302:
-			return PT1000_CCSDS2_DEC3_STRING;
-		case 0x44130305:
-			return PT1000_SuS7_DEC3_STRING;
-		case 0x44130306:
-			return PT1000_SuS8_DEC3_STRING;
-		case 0x44130307:
-			return PT1000_PVCH_DEC3_STRING;
-		case 0x44130308:
-			return GYRO2_STRING;
-		case 0x44145401:
-			return PT1000_PLOC_DEC4_STRING;
-		case 0x44145404:
-			return PT1000_SuS9_DEC4_STRING;
-		case 0x44145405:
-			return PT1000_SuS10_DEC4_STRING;
-		case 0x44145406:
-			return PT1000_PVHC_DEC4_STRING;
-		case 0x44145407:
-			return SuS_ADC_DEC4_STRING;
-		case 0x44202000:
-			return GPS1_HANDLER_STRING;
-		case 0x49001F00:
-			return DUMMY_GPS_COM_IF_STRING;
-		case 0x49005200:
-			return RS232_DEVICE_COM_IF_STRING;
-		case 0x49005300:
-			return I2C_DEVICE_COM_IF_STRING;
-		case 0x49005400:
-			return GPIO_DEVICE_COM_IF_STRING;
-		case 0x49005410:
-			return SPI_POLLING_TASK_STRING;
-		case 0x49005600:
-			return SPI_DEVICE_COM_IF_STRING;
-		case 0x4900AFFE:
-			return DUMMY_ECHO_COM_IF_STRING;
-		case 0x4D0073AD:
-			return SD_CARD_HANDLER_STRING;
-		case 0x50000100:
-			return CCSDS_PACKET_DISTRIBUTOR_STRING;
-		case 0x50000200:
-			return PUS_PACKET_DISTRIBUTOR_STRING;
-		case 0x50000300:
-			return UDP_TMTC_BRIDGE_STRING;
-		case 0x50000400:
-			return EMAC_POLLING_TASK_STRING;
-		case 0x50000500:
-			return SERIAL_TMTC_BRIDGE_STRING;
-		case 0x50000550:
-			return SERIAL_RING_BUFFER_STRING;
-		case 0x50000600:
-			return SERIAL_POLLING_TASK_STRING;
-		case 0x51000100:
-			return PUS_SERVICE_1_STRING;
-		case 0x51000200:
-			return PUS_SERVICE_2_STRING;
-		case 0x51000300:
-			return PUS_SERVICE_3_STRING;
-		case 0x51000310:
-			return PUS_SERVICE_3_PSB_STRING;
-		case 0x51000400:
-			return PUS_SERVICE_5_STRING;
-		case 0x51000500:
-			return PUS_SERVICE_6_STRING;
-		case 0x51000800:
-			return PUS_SERVICE_8_STRING;
-		case 0x51000900:
-			return PUS_SERVICE_9_STRING;
-		case 0x51001700:
-			return PUS_SERVICE_17_STRING;
-		case 0x51002000:
-			return PUS_SERVICE_20_STRING;
-		case 0x51002300:
-			return PUS_SERVICE_23_STRING;
-		case 0x51020000:
-			return PUS_SERVICE_200_STRING;
-		case 0x51020100:
-			return PUS_SERVICE_201_STRING;
-		case 0x52000001:
-			return PUS_TIME_STRING;
-		case 0x52000002:
-			return PUS_FUNNEL_STRING;
-		case 0x53000000:
-			return PUS_SERVICE_1_STRING;
-		case 0x53000003:
-			return FREERTOS_TASK_MONITOR_STRING;
-		case 0x53010000:
-			return HEALTH_TABLE_STRING;
-		case 0x53010100:
-			return MODE_STORE_STRING;
-		case 0x53030000:
-			return EVENT_MANAGER_STRING;
-		case 0x53040000:
-			return INTERNAL_ERROR_REPORTER_STRING;
-		case 0x534f0100:
-			return TC_STORE_STRING;
-		case 0x534f0200:
-			return TM_STORE_STRING;
-		case 0x534f0300:
-			return IPC_STORE_STRING;
-		case 0x66666666:
-			return AT91_SPI_TEST_TASK_STRING;
-		case 0x77777777:
-			return STM32_TEST_TASK_STRING;
-		case 0x87654321:
-			return AT91_UART0_TEST_TASK_STRING;
-		case 0x99000001:
-			return TC_INJECTOR_STRING;
-		case 0xFFFFFFFF:
-			return NO_OBJECT_STRING;
-		default:
-			return "UNKNOWN_OBJECT";
-	}
-	return 0;
-}
diff --git a/defaultcfg/fsfwconfig/objects/translateObjects.h b/defaultcfg/fsfwconfig/objects/translateObjects.h
deleted file mode 100644
index 5b6569408..000000000
--- a/defaultcfg/fsfwconfig/objects/translateObjects.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
-#define CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
-
-#include <fsfw/objectmanager/ObjectManagerIF.h>
-
-const char* translateObject(object_id_t object);
-
-
-#endif /* CONFIG_OBJECTS_TRANSLATEOBJECTS_H_ */

From 6c22fab2082deb5f0e781694a3265cabb2b3d5f8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 9 Nov 2020 21:33:09 +0100
Subject: [PATCH 1005/1774] pus service improvements

---
 pus/CService200ModeCommanding.cpp       |  5 +++--
 pus/CService200ModeCommanding.h         | 11 +++++------
 pus/Service1TelecommandVerification.cpp |  8 +++-----
 pus/Service1TelecommandVerification.h   | 11 ++++++-----
 pus/Service2DeviceAccess.cpp            | 21 +++++++++------------
 pus/Service2DeviceAccess.h              | 18 +++++++++++-------
 pus/Service5EventReporting.cpp          |  5 +++--
 pus/Service5EventReporting.h            |  9 +++++----
 pus/Service8FunctionManagement.cpp      |  8 ++++----
 pus/Service8FunctionManagement.h        | 12 +++++++-----
 pus/servicepackets/Service1Packets.h    |  6 +++---
 pus/servicepackets/Service200Packets.h  |  6 +++---
 pus/servicepackets/Service2Packets.h    |  6 +++---
 pus/servicepackets/Service5Packets.h    |  6 +++---
 pus/servicepackets/Service8Packets.h    |  6 +++---
 15 files changed, 71 insertions(+), 67 deletions(-)

diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index c63b47a69..c4e99359b 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -7,9 +7,10 @@
 #include "../modes/ModeMessage.h"
 
 CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId):
+        uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
+        uint16_t commandTimeoutSeconds):
         CommandingServiceBase(objectId, apid, serviceId,
-	    NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {}
+                numParallelCommands, commandTimeoutSeconds) {}
 
 CService200ModeCommanding::~CService200ModeCommanding() {}
 
diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h
index 89347dbd8..840402120 100644
--- a/pus/CService200ModeCommanding.h
+++ b/pus/CService200ModeCommanding.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
-#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
+#ifndef FSFW_PUS_CSERVICE200MODECOMMANDING_H_
+#define FSFW_PUS_CSERVICE200MODECOMMANDING_H_
 
 #include "../tmtcservices/CommandingServiceBase.h"
 
@@ -15,11 +15,10 @@
  */
 class CService200ModeCommanding: public CommandingServiceBase {
 public:
-	static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
-	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
 
 	CService200ModeCommanding(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId);
+	        uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands = 4,
+            uint16_t commandTimeoutSeconds = 60);
 	virtual~ CService200ModeCommanding();
 
 protected:
@@ -82,4 +81,4 @@ private:
 	};
 };
 
-#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */
+#endif /* FSFW_PUS_CSERVICE200MODECOMMANDING_H_ */
diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index 578eb02d4..86b0dcded 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -6,15 +6,13 @@
 #include "../tmtcpacket/pus/TmPacketStored.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
 
 Service1TelecommandVerification::Service1TelecommandVerification(
         object_id_t objectId, uint16_t apid, uint8_t serviceId,
-        object_id_t targetDestination):
+        object_id_t targetDestination, uint16_t messageQueueDepth):
         SystemObject(objectId), apid(apid), serviceId(serviceId),
         targetDestination(targetDestination) {
-	tmQueue = QueueFactory::instance()->createMessageQueue();
+	tmQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }
 
 Service1TelecommandVerification::~Service1TelecommandVerification() {}
@@ -53,7 +51,7 @@ ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
 		result = generateSuccessReport(message);
 	}
 	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Service1TelecommandVerification::initialize: "
+		sif::error << "Service1TelecommandVerification::sendVerificationReport: "
 		        "Sending verification packet failed !" << std::endl;
 	}
 	return result;
diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h
index 37562d1c9..3d68a4e06 100644
--- a/pus/Service1TelecommandVerification.h
+++ b/pus/Service1TelecommandVerification.h
@@ -1,5 +1,5 @@
-#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+#ifndef FSFW_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+#define FSFW_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
 
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -44,14 +44,15 @@ public:
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
 
 	Service1TelecommandVerification(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
+	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination,
+			uint16_t messageQueueDepth);
 	virtual ~Service1TelecommandVerification();
 
 	/**
 	 *
 	 * @return ID of Verification Queue
 	 */
-	virtual MessageQueueId_t getVerificationQueue();
+	virtual MessageQueueId_t getVerificationQueue() override;
 
 	/**
 	 * Performs the service periodically as specified in init_mission().
@@ -91,4 +92,4 @@ private:
 	};
 };
 
-#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
+#endif /* FSFW_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 2093a617d..3648b7eb6 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -21,8 +21,8 @@ Service2DeviceAccess::~Service2DeviceAccess() {}
 
 ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
 	switch(static_cast<Subservice>(subservice)){
-	case Subservice::RAW_COMMANDING:
-	case Subservice::TOGGLE_WIRETAPPING:
+	case Subservice::COMMAND_RAW_COMMANDING:
+	case Subservice::COMMAND_TOGGLE_WIRETAPPING:
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
 		sif::error << "Invalid Subservice" << std::endl;
@@ -39,8 +39,7 @@ ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
     SerializeAdapter::deSerialize(objectId, &tcData,
                 &tcDataLen, SerializeIF::Endianness::BIG);
 
-	ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
-	return result;
+    return checkInterfaceAndAcquireMessageQueue(id,objectId);
 }
 
 ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
@@ -59,14 +58,12 @@ ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
 		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
 		uint32_t* state, object_id_t objectId) {
 	switch(static_cast<Subservice>(subservice)){
-	case Subservice::RAW_COMMANDING: {
-		return prepareRawCommand(dynamic_cast<CommandMessage*>(message),
-				tcData, tcDataLen);
+	case Subservice::COMMAND_RAW_COMMANDING: {
+		return prepareRawCommand(message, tcData, tcDataLen);
 	}
 	break;
-	case Subservice::TOGGLE_WIRETAPPING: {
-		return prepareWiretappingCommand(dynamic_cast<CommandMessage*>(message),
-				tcData, tcDataLen);
+	case Subservice::COMMAND_TOGGLE_WIRETAPPING: {
+		return prepareWiretappingCommand(message, tcData, tcDataLen);
 	}
 	break;
 	default:
@@ -121,11 +118,11 @@ void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
 	switch(reply->getCommand()) {
 	case DeviceHandlerMessage::REPLY_RAW_COMMAND:
 		sendWiretappingTm(reply,
-				static_cast<uint8_t>(Subservice::WIRETAPPING_RAW_TC));
+				static_cast<uint8_t>(Subservice::REPLY_WIRETAPPING_RAW_TC));
 		break;
 	case DeviceHandlerMessage::REPLY_RAW_REPLY:
 		sendWiretappingTm(reply,
-				static_cast<uint8_t>(Subservice::RAW_REPLY));
+				static_cast<uint8_t>(Subservice::REPLY_RAW));
 		break;
 	default:
 		sif::error << "Unknown message in Service2DeviceAccess::"
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index f6aa8b521..b62e6854a 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
-#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
+#ifndef FSFW_PUS_SERVICE2DEVICEACCESS_H_
+#define FSFW_PUS_SERVICE2DEVICEACCESS_H_
 
 #include "../objectmanager/SystemObjectIF.h"
 #include "../devicehandlers/AcceptsDeviceResponsesIF.h"
@@ -81,12 +81,16 @@ private:
 	        const uint8_t* tcData, size_t tcDataLen);
 
 	enum class Subservice {
-		RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol
-		TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
-		RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
-		WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
+	    //!< [EXPORT] : [COMMAND] Command in device native protocol
+		COMMAND_RAW_COMMANDING = 128,
+		//!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
+		COMMAND_TOGGLE_WIRETAPPING = 129,
+		//!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
+		REPLY_RAW = 130,
+		//!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
+		REPLY_WIRETAPPING_RAW_TC = 131
 	};
 };
 
 
-#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */
+#endif /* FSFW_PUS_DEVICE2DEVICECOMMANDING_H_ */
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index 829d04bde..e0b34a5b4 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -8,10 +8,11 @@
 
 
 Service5EventReporting::Service5EventReporting(object_id_t objectId,
-            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
+            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle,
+            uint32_t messageQueueDepth):
 		PusServiceBase(objectId, apid, serviceId),
 		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
+	eventQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }
 
 Service5EventReporting::~Service5EventReporting(){}
diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h
index 0b6ee9a8c..69242801f 100644
--- a/pus/Service5EventReporting.h
+++ b/pus/Service5EventReporting.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+#ifndef FSFW_PUS_SERVICE5EVENTREPORTING_H_
+#define FSFW_PUS_SERVICE5EVENTREPORTING_H_
 
 #include "../tmtcservices/PusServiceBase.h"
 #include "../events/EventMessage.h"
@@ -42,7 +42,8 @@ class Service5EventReporting: public PusServiceBase {
 public:
 
 	Service5EventReporting(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
+	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10,
+	        uint32_t messageQueueDepth = 10);
 	virtual ~Service5EventReporting();
 
 	/***
@@ -83,4 +84,4 @@ private:
 	ReturnValue_t generateEventReport(EventMessage message);
 };
 
-#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
+#endif /* FSFW_PUS_SERVICE5EVENTREPORTING_H_ */
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 2c2e590b5..d710c56e1 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -7,10 +7,10 @@
 #include "../serialize/SerializeAdapter.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
-Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
+Service8FunctionManagement::Service8FunctionManagement(object_id_t objectId,
 		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
 		uint16_t commandTimeoutSeconds):
-		CommandingServiceBase(object_id, apid, serviceId, numParallelCommands,
+		CommandingServiceBase(objectId, apid, serviceId, numParallelCommands,
 		commandTimeoutSeconds) {}
 
 Service8FunctionManagement::~Service8FunctionManagement() {}
@@ -19,7 +19,7 @@ Service8FunctionManagement::~Service8FunctionManagement() {}
 ReturnValue_t Service8FunctionManagement::isValidSubservice(
 		uint8_t subservice) {
 	switch(static_cast<Subservice>(subservice)) {
-	case Subservice::DIRECT_COMMANDING:
+	case Subservice::COMMAND_DIRECT_COMMANDING:
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
 		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
@@ -131,7 +131,7 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(
     }
     DataReply dataReply(objectId, actionId, buffer, size);
     result = sendTmPacket(static_cast<uint8_t>(
-            Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
+            Subservice::REPLY_DIRECT_COMMANDING_DATA), &dataReply);
 
     auto deletionResult = IPCStore->deleteData(storeId);
     if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index b5ebcda8b..00153cfb0 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
-#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
+#ifndef FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
+#define FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 
 #include "../action/ActionMessage.h"
 #include "../tmtcservices/CommandingServiceBase.h"
@@ -52,8 +52,10 @@ protected:
 
 private:
 	enum class Subservice {
-		DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding
-		DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply
+	    //!< [EXPORT] : [COMMAND] Functional commanding
+		COMMAND_DIRECT_COMMANDING = 128,
+		//!< [EXPORT] : [REPLY] Data reply
+		REPLY_DIRECT_COMMANDING_DATA = 130,
 	};
 
 	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
@@ -64,4 +66,4 @@ private:
 	        object_id_t objectId, ActionId_t actionId);
 };
 
-#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
+#endif /* FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index dbd31028c..ecb62693c 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -1,3 +1,6 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
 /**
  * @defgroup spacepackets PUS Packet Definitions
  *  This group contains all implemented TM or TM packages that are sent to
@@ -5,9 +8,6 @@
  *  packet structures in Mission Information Base (MIB).
  */
 
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-
 #include "../../serialize/SerializeAdapter.h"
 #include "../../tmtcservices/VerificationCodes.h"
 
diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h
index efcf65fcf..cb9ad4a70 100644
--- a/pus/servicepackets/Service200Packets.h
+++ b/pus/servicepackets/Service200Packets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
 
 #include "../../serialize/SerialLinkedListAdapter.h"
 #include "../../modes/ModeMessage.h"
@@ -60,4 +60,4 @@ public:
 	SerializeElement<ReturnValue_t> reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached
 };
 
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
diff --git a/pus/servicepackets/Service2Packets.h b/pus/servicepackets/Service2Packets.h
index d4f3fb170..285a8f9f1 100644
--- a/pus/servicepackets/Service2Packets.h
+++ b/pus/servicepackets/Service2Packets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
 
 #include "../../action/ActionMessage.h"
 #include "../../objectmanager/SystemObjectIF.h"
@@ -73,4 +73,4 @@ public:
 	}
 };
 
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h
index 9655608aa..f903d6a26 100644
--- a/pus/servicepackets/Service5Packets.h
+++ b/pus/servicepackets/Service5Packets.h
@@ -1,5 +1,5 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
 
 #include "../../serialize/SerializeAdapter.h"
 #include "../../tmtcservices/VerificationCodes.h"
@@ -73,4 +73,4 @@ private:
 };
 
 
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
index 14f8b6e6e..b026edf52 100644
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 
 #include "../../action/ActionMessage.h"
 #include "../../objectmanager/SystemObjectIF.h"
@@ -118,4 +118,4 @@ private:
 
 };
 
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */

From 0304f61bdeb3035137bea029b145bacd34b5dd75 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 10 Nov 2020 11:00:13 +0100
Subject: [PATCH 1006/1774] has parametersIF doc improved

---
 parameters/HasParametersIF.h | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index c4fd81b34..19c12d81f 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_PARAMETERS_HASPARAMETERSIF_H_
 #define FSFW_PARAMETERS_HASPARAMETERSIF_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "ParameterWrapper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstdint>
 
 /**
@@ -20,11 +20,10 @@ using ParameterId_t = uint32_t;
  * 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...
+ * The second byte is a unique identfier ID.
  *
- * Yeah, is it matrix ID or parameter ID now and is index a 16 bit number
- * of a 8 bit number now?
+ * The third and  fourth byte can be used as a linear index for matrix or array
+ * parameter entries.
  */
 class HasParametersIF {
 public:
@@ -61,6 +60,10 @@ public:
 	virtual ~HasParametersIF() {}
 
 	/**
+	 * This is the generic function overriden by child classes to set
+	 * parameters. To set a parameter, the parameter wrapper is used with
+	 * a variety of set functions. The provided values can be checked with
+	 * newValues.
 	 * Always set parameter before checking newValues!
 	 *
 	 * @param domainId

From 7c75c6e8cc22a4b8540f8866a5425f101bcfea6e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 10 Nov 2020 11:14:07 +0100
Subject: [PATCH 1007/1774] parameter helper update

---
 parameters/ParameterHelper.cpp | 166 ++++++++++++++++-----------------
 1 file changed, 83 insertions(+), 83 deletions(-)

diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index d2193b289..22465ca33 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -3,7 +3,7 @@
 #include "../objectmanager/ObjectManagerIF.h"
 
 ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-		owner(owner) {}
+owner(owner) {}
 
 ParameterHelper::~ParameterHelper() {
 }
@@ -14,106 +14,106 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch (message->getCommand()) {
-	case ParameterMessage::CMD_PARAMETER_DUMP: {
-		ParameterWrapper description;
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(message));
-		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
-				ParameterMessage::getParameterId(message));
-		result = owner->getParameter(domain, uniqueIdentifier,
-				&description, &description, 0);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &description);
-		}
-	}
-		break;
-	case ParameterMessage::CMD_PARAMETER_LOAD: {
-	    ParameterId_t parameterId = 0;
-	    uint8_t ptc = 0;
-	    uint8_t pfc = 0;
-	    uint8_t rows = 0;
-	    uint8_t columns = 0;
-	    store_address_t storeId = ParameterMessage::getParameterLoadCommand(
-	            message, &parameterId, &ptc, &pfc, &rows, &columns);
-	    Type type(Type::getActualType(ptc, pfc));
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    switch (message->getCommand()) {
+    case ParameterMessage::CMD_PARAMETER_DUMP: {
+        ParameterWrapper description;
+        uint8_t domain = HasParametersIF::getDomain(
+                ParameterMessage::getParameterId(message));
+        uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
+                ParameterMessage::getParameterId(message));
+        result = owner->getParameter(domain, uniqueIdentifier,
+                &description, &description, 0);
+        if (result == HasReturnvaluesIF::RETURN_OK) {
+            result = sendParameter(message->getSender(),
+                    ParameterMessage::getParameterId(message), &description);
+        }
+    }
+    break;
+    case ParameterMessage::CMD_PARAMETER_LOAD: {
+        ParameterId_t parameterId = 0;
+        uint8_t ptc = 0;
+        uint8_t pfc = 0;
+        uint8_t rows = 0;
+        uint8_t columns = 0;
+        store_address_t storeId = ParameterMessage::getParameterLoadCommand(
+                message, &parameterId, &ptc, &pfc, &rows, &columns);
+        Type type(Type::getActualType(ptc, pfc));
 
-		uint8_t domain = HasParametersIF::getDomain(parameterId);
-		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
-		        parameterId);
-		uint16_t linearIndex = HasParametersIF::getIndex(parameterId);
+        uint8_t domain = HasParametersIF::getDomain(parameterId);
+        uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
+                parameterId);
+        uint16_t linearIndex = HasParametersIF::getIndex(parameterId);
 
-		ConstStorageAccessor accessor(storeId);
-		result = storage->getData(storeId, accessor);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "ParameterHelper::handleParameterMessage: Getting"
-					<< " store data failed for load command." << std::endl;
-			break;
-		}
+        ConstStorageAccessor accessor(storeId);
+        result = storage->getData(storeId, accessor);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            sif::error << "ParameterHelper::handleParameterMessage: Getting"
+                    << " store data failed for load command." << std::endl;
+            break;
+        }
 
-		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(type, rows, columns, accessor.data(),
-		        accessor.size());
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-		    return result;
-		}
+        ParameterWrapper streamWrapper;
+        result = streamWrapper.set(type, rows, columns, accessor.data(),
+                accessor.size());
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
 
-		ParameterWrapper ownerWrapper;
-		result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
-				&streamWrapper, linearIndex);
+        ParameterWrapper ownerWrapper;
+        result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
+                &streamWrapper, linearIndex);
 
-		result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-		    return result;
-		}
+        result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
 
         result = sendParameter(message->getSender(),
                 ParameterMessage::getParameterId(message), &ownerWrapper);
-		break;
-	}
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        break;
+    }
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		rejectCommand(message->getSender(), result, message->getCommand());
-	}
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        rejectCommand(message->getSender(), result, message->getCommand());
+    }
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
-		const ParameterWrapper* description) {
-	size_t serializedSize = description->getSerializedSize();
+        const ParameterWrapper* description) {
+    size_t serializedSize = description->getSerializedSize();
 
-	uint8_t *storeElement;
-	store_address_t address;
+    uint8_t *storeElement;
+    store_address_t address;
 
-	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
-			&storeElement);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
+            &storeElement);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	size_t storeElementSize = 0;
+    size_t storeElementSize = 0;
 
-	result = description->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
+    result = description->serialize(&storeElement, &storeElementSize,
+            serializedSize, SerializeIF::Endianness::BIG);
 
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		storage->deleteData(address);
-		return result;
-	}
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        storage->deleteData(address);
+        return result;
+    }
 
-	CommandMessage reply;
+    CommandMessage reply;
 
-	ParameterMessage::setParameterDumpReply(&reply, id, address);
+    ParameterMessage::setParameterDumpReply(&reply, id, address);
 
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+    MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t ParameterHelper::initialize() {
@@ -127,8 +127,8 @@ ReturnValue_t ParameterHelper::initialize() {
 }
 
 void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-		Command_t initialCommand) {
-	CommandMessage reply;
-	reply.setReplyRejected(reason, initialCommand);
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+        Command_t initialCommand) {
+    CommandMessage reply;
+    reply.setReplyRejected(reason, initialCommand);
+    MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 }

From 5865e56c54209ffe3076fda86cf94e02a706df25 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 10 Nov 2020 11:15:42 +0100
Subject: [PATCH 1008/1774] indentation fixed

---
 parameters/ParameterHelper.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 22465ca33..23d1a1f35 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -2,8 +2,8 @@
 #include "ParameterMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
-ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-owner(owner) {}
+ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner):
+        owner(owner) {}
 
 ParameterHelper::~ParameterHelper() {
 }

From 434709ca9693a68a27b1595d9a86c9472f52a610 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 10 Nov 2020 11:16:56 +0100
Subject: [PATCH 1009/1774] parameter small stuff

---
 parameters/HasParametersIF.h   |  13 ++-
 parameters/ParameterHelper.cpp | 168 ++++++++++++++++-----------------
 2 files changed, 92 insertions(+), 89 deletions(-)

diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index c4fd81b34..19c12d81f 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_PARAMETERS_HASPARAMETERSIF_H_
 #define FSFW_PARAMETERS_HASPARAMETERSIF_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "ParameterWrapper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstdint>
 
 /**
@@ -20,11 +20,10 @@ using ParameterId_t = uint32_t;
  * 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...
+ * The second byte is a unique identfier ID.
  *
- * Yeah, is it matrix ID or parameter ID now and is index a 16 bit number
- * of a 8 bit number now?
+ * The third and  fourth byte can be used as a linear index for matrix or array
+ * parameter entries.
  */
 class HasParametersIF {
 public:
@@ -61,6 +60,10 @@ public:
 	virtual ~HasParametersIF() {}
 
 	/**
+	 * This is the generic function overriden by child classes to set
+	 * parameters. To set a parameter, the parameter wrapper is used with
+	 * a variety of set functions. The provided values can be checked with
+	 * newValues.
 	 * Always set parameter before checking newValues!
 	 *
 	 * @param domainId
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index d2193b289..23d1a1f35 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -2,8 +2,8 @@
 #include "ParameterMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
-ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-		owner(owner) {}
+ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner):
+        owner(owner) {}
 
 ParameterHelper::~ParameterHelper() {
 }
@@ -14,106 +14,106 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch (message->getCommand()) {
-	case ParameterMessage::CMD_PARAMETER_DUMP: {
-		ParameterWrapper description;
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(message));
-		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
-				ParameterMessage::getParameterId(message));
-		result = owner->getParameter(domain, uniqueIdentifier,
-				&description, &description, 0);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &description);
-		}
-	}
-		break;
-	case ParameterMessage::CMD_PARAMETER_LOAD: {
-	    ParameterId_t parameterId = 0;
-	    uint8_t ptc = 0;
-	    uint8_t pfc = 0;
-	    uint8_t rows = 0;
-	    uint8_t columns = 0;
-	    store_address_t storeId = ParameterMessage::getParameterLoadCommand(
-	            message, &parameterId, &ptc, &pfc, &rows, &columns);
-	    Type type(Type::getActualType(ptc, pfc));
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    switch (message->getCommand()) {
+    case ParameterMessage::CMD_PARAMETER_DUMP: {
+        ParameterWrapper description;
+        uint8_t domain = HasParametersIF::getDomain(
+                ParameterMessage::getParameterId(message));
+        uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
+                ParameterMessage::getParameterId(message));
+        result = owner->getParameter(domain, uniqueIdentifier,
+                &description, &description, 0);
+        if (result == HasReturnvaluesIF::RETURN_OK) {
+            result = sendParameter(message->getSender(),
+                    ParameterMessage::getParameterId(message), &description);
+        }
+    }
+    break;
+    case ParameterMessage::CMD_PARAMETER_LOAD: {
+        ParameterId_t parameterId = 0;
+        uint8_t ptc = 0;
+        uint8_t pfc = 0;
+        uint8_t rows = 0;
+        uint8_t columns = 0;
+        store_address_t storeId = ParameterMessage::getParameterLoadCommand(
+                message, &parameterId, &ptc, &pfc, &rows, &columns);
+        Type type(Type::getActualType(ptc, pfc));
 
-		uint8_t domain = HasParametersIF::getDomain(parameterId);
-		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
-		        parameterId);
-		uint16_t linearIndex = HasParametersIF::getIndex(parameterId);
+        uint8_t domain = HasParametersIF::getDomain(parameterId);
+        uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
+                parameterId);
+        uint16_t linearIndex = HasParametersIF::getIndex(parameterId);
 
-		ConstStorageAccessor accessor(storeId);
-		result = storage->getData(storeId, accessor);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "ParameterHelper::handleParameterMessage: Getting"
-					<< " store data failed for load command." << std::endl;
-			break;
-		}
+        ConstStorageAccessor accessor(storeId);
+        result = storage->getData(storeId, accessor);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            sif::error << "ParameterHelper::handleParameterMessage: Getting"
+                    << " store data failed for load command." << std::endl;
+            break;
+        }
 
-		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(type, rows, columns, accessor.data(),
-		        accessor.size());
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-		    return result;
-		}
+        ParameterWrapper streamWrapper;
+        result = streamWrapper.set(type, rows, columns, accessor.data(),
+                accessor.size());
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
 
-		ParameterWrapper ownerWrapper;
-		result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
-				&streamWrapper, linearIndex);
+        ParameterWrapper ownerWrapper;
+        result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
+                &streamWrapper, linearIndex);
 
-		result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-		    return result;
-		}
+        result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
 
         result = sendParameter(message->getSender(),
                 ParameterMessage::getParameterId(message), &ownerWrapper);
-		break;
-	}
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        break;
+    }
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		rejectCommand(message->getSender(), result, message->getCommand());
-	}
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        rejectCommand(message->getSender(), result, message->getCommand());
+    }
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
-		const ParameterWrapper* description) {
-	size_t serializedSize = description->getSerializedSize();
+        const ParameterWrapper* description) {
+    size_t serializedSize = description->getSerializedSize();
 
-	uint8_t *storeElement;
-	store_address_t address;
+    uint8_t *storeElement;
+    store_address_t address;
 
-	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
-			&storeElement);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
+            &storeElement);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	size_t storeElementSize = 0;
+    size_t storeElementSize = 0;
 
-	result = description->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
+    result = description->serialize(&storeElement, &storeElementSize,
+            serializedSize, SerializeIF::Endianness::BIG);
 
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		storage->deleteData(address);
-		return result;
-	}
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        storage->deleteData(address);
+        return result;
+    }
 
-	CommandMessage reply;
+    CommandMessage reply;
 
-	ParameterMessage::setParameterDumpReply(&reply, id, address);
+    ParameterMessage::setParameterDumpReply(&reply, id, address);
 
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+    MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t ParameterHelper::initialize() {
@@ -127,8 +127,8 @@ ReturnValue_t ParameterHelper::initialize() {
 }
 
 void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-		Command_t initialCommand) {
-	CommandMessage reply;
-	reply.setReplyRejected(reason, initialCommand);
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+        Command_t initialCommand) {
+    CommandMessage reply;
+    reply.setReplyRejected(reason, initialCommand);
+    MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 }

From cb5fa4a2175bc684e21fb885c94a420b97e680a8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 18 Nov 2020 21:15:14 +0100
Subject: [PATCH 1010/1774] monitoring changes

---
 datapoollocal/LocalDataPoolManager.h | 10 +++-----
 monitoring/AbsLimitMonitor.h         |  5 ++--
 monitoring/LimitMonitor.h            | 19 ++++++++------
 monitoring/MonitorBase.h             | 37 +++++++++++++++++-----------
 monitoring/MonitorReporter.h         |  2 ++
 5 files changed, 44 insertions(+), 29 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 187ae5d58..38714cc9f 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -48,11 +48,9 @@ class HousekeepingPacketUpdate;
  * @author 		R. Mueller
  */
 class LocalDataPoolManager {
-	template<typename T>
-	friend class LocalPoolVar;
-	template<typename T, uint16_t vecSize>
-	friend class LocalPoolVector;
-	friend class LocalPoolDataSetBase;
+	template<typename T> friend class LocalPoolVar;
+	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
+    friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
@@ -319,7 +317,7 @@ private:
 	StorageManagerIF* ipcStore = nullptr;
 	/**
 	 * Get the pointer to the mutex. Can be used to lock the data pool
-	 * eternally. Use with care and don't forget to unlock locked mutexes!
+	 * externally. Use with care and don't forget to unlock locked mutexes!
 	 * For now, only friend classes can accss this function.
 	 * @return
 	 */
diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index 5891c36af..d85d5b618 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -8,10 +8,11 @@ template<typename T>
 class AbsLimitMonitor: public MonitorBase<T> {
 public:
 	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId,
-	        uint32_t parameterId, uint16_t confirmationLimit, T limit,
+	        object_id_t dataCreatorId, lp_id_t localPoolId,
+	        uint16_t confirmationLimit, T limit,
 	        Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE,
 	        bool aboveIsViolation = true) :
-			MonitorBase<T>(reporterId, monitorId, parameterId,
+			MonitorBase<T>(reporterId, monitorId, dataCreatorId, localPoolId,
 			        confirmationLimit),
 			limit(limit), violationEvent(violationEvent),
 			aboveIsViolation(aboveIsViolation) {
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index abcbe8e8b..fdb05018c 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -12,13 +12,15 @@
 template<typename T>
 class LimitMonitor: public MonitorBase<T> {
 public:
-	LimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
+	LimitMonitor(object_id_t reporterId, uint8_t monitorId,
+	        object_id_t creatorId, lp_id_t localPoolId,
 			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
 			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
 			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), lowerLimit(
-					lowerLimit), upperLimit(upperLimit), belowLowEvent(
-					belowLowEvent), aboveHighEvent(aboveHighEvent) {
+			MonitorBase<T>(reporterId, monitorId, creatorId, localPoolId,
+			        confirmationLimit),
+			lowerLimit(lowerLimit), upperLimit(upperLimit),
+			belowLowEvent(belowLowEvent), aboveHighEvent(aboveHighEvent) {
 	}
 	virtual ~LimitMonitor() {
 	}
@@ -57,7 +59,8 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	bool isOutOfLimits() {
-		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT || this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
+		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT or
+		        this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
 			return true;
 		} else {
 			return false;
@@ -76,10 +79,12 @@ protected:
 	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
 		switch (state) {
 		case MonitoringIF::BELOW_LOW_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent, this->parameterId);
+			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent,
+			        this->parameterId);
 			break;
 		case MonitoringIF::ABOVE_HIGH_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent, this->parameterId);
+			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent,
+			        this->parameterId);
 			break;
 		default:
 			break;
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 5f9a2cafa..df6f1af8c 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -6,8 +6,8 @@
 #include "MonitoringMessageContent.h"
 #include "MonitorReporter.h"
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/PIDReader.h"
+#include "../datapoollocal/LocalPoolVariable.h"
+
 
 /**
  * @brief   Base class for monitoring of parameters.
@@ -23,13 +23,18 @@
 template<typename T>
 class MonitorBase: public MonitorReporter<T> {
 public:
+
 	MonitorBase(object_id_t reporterId, uint8_t monitorId,
-			uint32_t parameterId, uint16_t confirmationLimit) :
-			MonitorReporter<T>(reporterId, monitorId, parameterId,
-			        confirmationLimit) {
+	        object_id_t dataCreatorId, lp_id_t localPoolId,
+	        uint16_t confirmationLimit):
+	        MonitorReporter<T>(reporterId, monitorId, dataCreatorId,
+	                confirmationLimit),
+	        poolVariable(dataCreatorId, localPoolId) {
 	}
+
 	virtual ~MonitorBase() {
 	}
+
 	virtual ReturnValue_t check() {
 		// 1. Fetch sample of type T, return validity.
 		T sample = 0;
@@ -39,8 +44,8 @@ public:
 		// Report (if oldState is != invalidity).
 		if (validity != HasReturnvaluesIF::RETURN_OK) {
 			this->monitorStateIs(validity, sample, 0);
-			//3. Otherwise, check sample.
 		} else {
+            //3. Otherwise, check sample.
 			this->oldState = doCheck(sample);
 		}
 		return this->oldState;
@@ -55,16 +60,20 @@ public:
 	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
 
 protected:
+
 	virtual ReturnValue_t fetchSample(T* sample) {
-		GlobDataSet mySet;
-		PIDReader<T> parameter(this->parameterId, &mySet);
-		mySet.read();
-		if (!parameter.isValid()) {
-			return MonitoringIF::INVALID;
-		}
-		*sample = parameter.value;
-		return HasReturnvaluesIF::RETURN_OK;
+	    ReturnValue_t result = poolVariable.read();
+	    if(result != HasReturnvaluesIF::RETURN_OK) {
+	        return result;
+	    }
+	    if (not poolVariable.isValid()) {
+	        return MonitoringIF::INVALID;
+	    }
+	    *sample = poolVariable.value;
+	    return HasReturnvaluesIF::RETURN_OK;
 	}
+
+	LocalPoolVar<T> poolVariable;
 };
 
 #endif /* FSFW_MONITORING_MONITORBASE_H_ */
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 286d82cfe..d33f34d52 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -15,6 +15,8 @@ public:
 	static const uint8_t ENABLED = 1;
 	static const uint8_t DISABLED = 0;
 
+	// TODO: Adapt to use SID instead of parameter ID.
+
 	MonitorReporter(object_id_t reportingId, uint8_t monitorId,
 	        uint32_t parameterId, uint16_t confirmationLimit) :
 			monitorId(monitorId), parameterId(parameterId),

From 0d79d4ab030c3b40cf53203a74ff7d7425b24ade Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 18 Nov 2020 21:15:48 +0100
Subject: [PATCH 1011/1774] replaced spaces with tab

---
 datapoollocal/LocalDataPoolManager.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 38714cc9f..aca0d4f60 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -50,7 +50,7 @@ class HousekeepingPacketUpdate;
 class LocalDataPoolManager {
 	template<typename T> friend class LocalPoolVar;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
-    friend class LocalPoolDataSetBase;
+	friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;

From 03fad1cfcd91fad4456188ff18b2bee0d1e0de03 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 19 Nov 2020 00:10:59 +0100
Subject: [PATCH 1012/1774] better naming.. hopefully..

---
 thermal/CoreComponent.h                       |  96 --------------
 thermal/ThermalComponent.cpp                  |  24 ++--
 thermal/ThermalComponent.h                    |  23 ++--
 ...Component.cpp => ThermalComponentCore.cpp} | 110 +++++++++-------
 thermal/ThermalComponentCore.h                | 118 ++++++++++++++++++
 thermal/ThermalComponentIF.h                  |  12 +-
 thermal/ThermalMonitor.h                      |  26 ----
 ...Monitor.cpp => ThermalMonitorReporter.cpp} |  14 ++-
 thermal/ThermalMonitorReporter.h              |  28 +++++
 9 files changed, 252 insertions(+), 199 deletions(-)
 delete mode 100644 thermal/CoreComponent.h
 rename thermal/{CoreComponent.cpp => ThermalComponentCore.cpp} (64%)
 create mode 100644 thermal/ThermalComponentCore.h
 delete mode 100644 thermal/ThermalMonitor.h
 rename thermal/{ThermalMonitor.cpp => ThermalMonitorReporter.cpp} (84%)
 create mode 100644 thermal/ThermalMonitorReporter.h

diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
deleted file mode 100644
index 8093711d6..000000000
--- a/thermal/CoreComponent.h
+++ /dev/null
@@ -1,96 +0,0 @@
-#ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-#define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../thermal/ThermalComponentIF.h"
-#include "../thermal/AbstractTemperatureSensor.h"
-#include "../thermal/ThermalModule.h"
-#include "../thermal/ThermalMonitor.h"
-
-// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
-class CoreComponent: public ThermalComponentIF {
-public:
-	struct Parameters {
-		float lowerOpLimit;
-		float upperOpLimit;
-		float heaterOn;
-		float hysteresis;
-		float heaterSwitchoff;
-	};
-
-	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
-
-	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
-			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-			uint32_t requestPoolId, GlobDataSet *dataSet,
-			AbstractTemperatureSensor *sensor,
-			AbstractTemperatureSensor *firstRedundantSensor,
-			AbstractTemperatureSensor *secondRedundantSensor,
-			ThermalModuleIF *thermalModule, Parameters parameters,
-			Priority priority, StateRequest initialTargetState =
-					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
-
-	virtual ~CoreComponent();
-
-	virtual HeaterRequest performOperation(uint8_t opCode);
-
-	void markStateIgnored();
-
-	object_id_t getObjectId();
-
-	uint8_t getDomainId() const;
-
-	virtual float getLowerOpLimit();
-
-	ReturnValue_t setTargetState(int8_t newState);
-
-	virtual void setOutputInvalid();
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-protected:
-
-	AbstractTemperatureSensor *sensor;
-	AbstractTemperatureSensor *firstRedundantSensor;
-	AbstractTemperatureSensor *secondRedundantSensor;
-	ThermalModuleIF *thermalModule;
-
-	gp_float_t temperature;
-	gp_int8_t targetState;
-	gp_int8_t currentState;
-	gp_uint8_t heaterRequest;
-
-	bool isHeating;
-
-	bool isSafeComponent;
-
-	float minTemp;
-
-	float maxTemp;
-
-	Parameters parameters;
-
-	ThermalMonitor temperatureMonitor;
-
-	const uint8_t domainId;
-
-	virtual float getTemperature();
-	virtual State getState(float temperature, Parameters parameters,
-			int8_t targetState);
-
-	virtual void checkLimits(State state);
-
-	virtual HeaterRequest getHeaterRequest(int8_t targetState,
-			float temperature, Parameters parameters);
-
-	virtual State getIgnoredState(int8_t state);
-
-	void updateMinMaxTemp();
-
-	virtual Parameters getParameters();
-};
-
-#endif /* MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ */
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 6bc09e557..78b14efd8 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -9,12 +9,12 @@ ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
 		AbstractTemperatureSensor* secondRedundantSensor,
 		ThermalModuleIF* thermalModule, Parameters parameters,
 		Priority priority) :
-		CoreComponent(reportingObjectId, domainId, temperaturePoolId,
+		ThermalComponentCore(reportingObjectId, domainId, temperaturePoolId,
 				targetStatePoolId, currentStatePoolId, requestPoolId, dataSet,
-				sensor, firstRedundantSensor, secondRedundantSensor,
-				thermalModule,{ parameters.lowerOpLimit, parameters.upperOpLimit,
-				parameters.heaterOn, parameters.hysteresis, parameters.heaterSwitchoff },
-				priority, ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL),
+				{ parameters.lowerOpLimit, parameters.upperOpLimit,
+				parameters.heaterOn, parameters.hysteresis,
+				parameters.heaterSwitchoff },
+				ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL),
 		nopParameters({ parameters.lowerNopLimit, parameters.upperNopLimit }) {
 }
 
@@ -36,7 +36,7 @@ ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
 		mySet.commit(PoolVariableIF::VALID);
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
-		return CoreComponent::setTargetState(newState);
+		return ThermalComponentCore::setTargetState(newState);
 	}
 }
 
@@ -57,11 +57,11 @@ ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
 }
 
 ThermalComponentIF::State ThermalComponent::getState(float temperature,
-		CoreComponent::Parameters parameters, int8_t targetState) {
+		ThermalComponentCore::Parameters parameters, int8_t targetState) {
 	if (temperature < nopParameters.lowerNopLimit) {
 		return OUT_OF_RANGE_LOW;
 	} else {
-		State state = CoreComponent::getState(temperature, parameters,
+		State state = ThermalComponentCore::getState(temperature, parameters,
 				targetState);
 		if (state != NON_OPERATIONAL_HIGH
 				&& state != NON_OPERATIONAL_HIGH_IGNORED) {
@@ -79,7 +79,7 @@ ThermalComponentIF::State ThermalComponent::getState(float temperature,
 
 void ThermalComponent::checkLimits(ThermalComponentIF::State state) {
 	if (targetState == STATE_REQUEST_OPERATIONAL || targetState == STATE_REQUEST_IGNORE) {
-		CoreComponent::checkLimits(state);
+		ThermalComponentCore::checkLimits(state);
 		return;
 	}
 	//If component is not operational, it checks the NOP limits.
@@ -89,7 +89,7 @@ void ThermalComponent::checkLimits(ThermalComponentIF::State state) {
 
 ThermalComponentIF::HeaterRequest ThermalComponent::getHeaterRequest(
 		int8_t targetState, float temperature,
-		CoreComponent::Parameters parameters) {
+		ThermalComponentCore::Parameters parameters) {
 	if (targetState == STATE_REQUEST_IGNORE) {
 		isHeating = false;
 		return HEATER_DONT_CARE;
@@ -142,14 +142,14 @@ ThermalComponentIF::State ThermalComponent::getIgnoredState(int8_t state) {
 	case OUT_OF_RANGE_HIGH_IGNORED:
 		return OUT_OF_RANGE_HIGH_IGNORED;
 	default:
-		return CoreComponent::getIgnoredState(state);
+		return ThermalComponentCore::getIgnoredState(state);
 	}
 }
 
 ReturnValue_t ThermalComponent::getParameter(uint8_t domainId,
 		uint16_t parameterId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = CoreComponent::getParameter(domainId, parameterId,
+	ReturnValue_t result = ThermalComponentCore::getParameter(domainId, parameterId,
 			parameterWrapper, newValues, startAtIndex);
 	if (result != INVALID_IDENTIFIER_ID) {
 		return result;
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 195f03b10..d61ff01e1 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -1,12 +1,14 @@
-#ifndef THERMALCOMPONENT_H_
-#define THERMALCOMPONENT_H_
+#ifndef FSFW_THERMAL_THERMALCOMPONENT_H_
+#define FSFW_THERMAL_THERMALCOMPONENT_H_
 
-#include "CoreComponent.h"
+#include "ThermalComponentCore.h"
 
 /**
- * What is it. How to use
+ * @brief
+ * @details
+ * Some more documentation.
  */
-class ThermalComponent: public CoreComponent {
+class ThermalComponent: public ThermalComponentCore {
 public:
 	struct Parameters {
 		float lowerNopLimit;
@@ -42,8 +44,9 @@ public:
 	 * @param parameters
 	 * @param priority
 	 */
-	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
-			uint32_t targetStatePoolId, uint32_t currentStatePoolId, uint32_t requestPoolId,
+	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId,
+	        uint32_t temperaturePoolId, uint32_t targetStatePoolId,
+	        uint32_t currentStatePoolId, uint32_t requestPoolId,
 			GlobDataSet *dataSet, AbstractTemperatureSensor *sensor,
 			AbstractTemperatureSensor *firstRedundantSensor,
 			AbstractTemperatureSensor *secondRedundantSensor,
@@ -63,15 +66,15 @@ protected:
 
 	NopParameters nopParameters;
 
-	State getState(float temperature, CoreComponent::Parameters parameters,
+	State getState(float temperature, ThermalComponentCore::Parameters parameters,
 			int8_t targetState);
 
 	virtual void checkLimits(State state);
 
 	virtual HeaterRequest getHeaterRequest(int8_t targetState, float temperature,
-			CoreComponent::Parameters parameters);
+			ThermalComponentCore::Parameters parameters);
 
 	State getIgnoredState(int8_t state);
 };
 
-#endif /* THERMALCOMPONENT_H_ */
+#endif /* FSFW_THERMAL_THERMALCOMPONENT_H_ */
diff --git a/thermal/CoreComponent.cpp b/thermal/ThermalComponentCore.cpp
similarity index 64%
rename from thermal/CoreComponent.cpp
rename to thermal/ThermalComponentCore.cpp
index 90d10eda0..bf28f307f 100644
--- a/thermal/CoreComponent.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -1,28 +1,19 @@
-#include "CoreComponent.h"
+#include "ThermalComponentCore.h"
 
-CoreComponent::CoreComponent(object_id_t reportingObjectId, uint8_t domainId,
-		uint32_t temperaturePoolId, uint32_t targetStatePoolId,
-		uint32_t currentStatePoolId, uint32_t requestPoolId, GlobDataSet* dataSet,
-		AbstractTemperatureSensor* sensor,
-		AbstractTemperatureSensor* firstRedundantSensor,
-		AbstractTemperatureSensor* secondRedundantSensor,
-		ThermalModuleIF* thermalModule, Parameters parameters,
-		Priority priority, StateRequest initialTargetState) :
-		sensor(sensor), firstRedundantSensor(firstRedundantSensor), secondRedundantSensor(
-				secondRedundantSensor), thermalModule(thermalModule), temperature(
-				temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
-				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ), currentState(
-				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), heaterRequest(
-				requestPoolId, dataSet, PoolVariableIF::VAR_WRITE), isHeating(
-		false), isSafeComponent(priority == SAFE), minTemp(999), maxTemp(
-				AbstractTemperatureSensor::ZERO_KELVIN_C), parameters(
-				parameters), temperatureMonitor(reportingObjectId,
-				domainId + 1,
-				GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
+ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
+        uint8_t domainId, uint32_t temperaturePoolId,
+        uint32_t targetStatePoolId,
+		uint32_t currentStatePoolId, uint32_t requestPoolId,
+		GlobDataSet* dataSet, Parameters parameters,
+		StateRequest initialTargetState) :
+		temperature(temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ),
+		currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		heaterRequest(requestPoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		parameters(parameters),
+		temperatureMonitor(reportingObjectId, domainId + 1,
+		        GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
 				COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
-	if (thermalModule != NULL) {
-		thermalModule->registerComponent(this, priority);
-	}
 	//Set thermal state once, then leave to operator.
 	GlobDataSet mySet;
 	gp_uint8_t writableTargetState(targetStatePoolId, &mySet,
@@ -31,10 +22,39 @@ CoreComponent::CoreComponent(object_id_t reportingObjectId, uint8_t domainId,
 	mySet.commit(PoolVariableIF::VALID);
 }
 
-CoreComponent::~CoreComponent() {
+void ThermalComponentCore::addSensor(AbstractTemperatureSensor* sensor) {
+    this->sensor = sensor;
 }
 
-ThermalComponentIF::HeaterRequest CoreComponent::performOperation(uint8_t opCode) {
+void ThermalComponentCore::addFirstRedundantSensor(
+        AbstractTemperatureSensor *firstRedundantSensor) {
+    this->firstRedundantSensor = firstRedundantSensor;
+}
+
+void ThermalComponentCore::addSecondRedundantSensor(
+        AbstractTemperatureSensor *secondRedundantSensor) {
+    this->secondRedundantSensor = secondRedundantSensor;
+}
+
+void ThermalComponentCore::addThermalModule(ThermalModule *thermalModule,
+        Priority priority) {
+    this->thermalModule = thermalModule;
+    if(thermalModule != nullptr) {
+        thermalModule->registerComponent(this, priority);
+    }
+}
+
+void ThermalComponentCore::setPriority(Priority priority) {
+    if(priority == SAFE) {
+        this->isSafeComponent = true;
+    }
+}
+
+ThermalComponentCore::~ThermalComponentCore() {
+}
+
+ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
+        uint8_t opCode) {
 	HeaterRequest request = HEATER_DONT_CARE;
 	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
 	temperature = getTemperature();
@@ -57,19 +77,21 @@ ThermalComponentIF::HeaterRequest CoreComponent::performOperation(uint8_t opCode
 	return request;
 }
 
-void CoreComponent::markStateIgnored() {
+void ThermalComponentCore::markStateIgnored() {
 	currentState = getIgnoredState(currentState);
 }
 
-object_id_t CoreComponent::getObjectId() {
+object_id_t ThermalComponentCore::getObjectId() {
 	return temperatureMonitor.getReporterId();
 }
 
-float CoreComponent::getLowerOpLimit() {
+float ThermalComponentCore::getLowerOpLimit() {
 	return parameters.lowerOpLimit;
 }
 
-ReturnValue_t CoreComponent::setTargetState(int8_t newState) {
+
+
+ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
 	GlobDataSet mySet;
 	gp_uint8_t writableTargetState(targetState.getDataPoolId(),
 			&mySet, PoolVariableIF::VAR_READ_WRITE);
@@ -92,7 +114,7 @@ ReturnValue_t CoreComponent::setTargetState(int8_t newState) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void CoreComponent::setOutputInvalid() {
+void ThermalComponentCore::setOutputInvalid() {
 	temperature = INVALID_TEMPERATURE;
 	temperature.setValid(PoolVariableIF::INVALID);
 	currentState.setValid(PoolVariableIF::INVALID);
@@ -101,20 +123,22 @@ void CoreComponent::setOutputInvalid() {
 	temperatureMonitor.setToUnchecked();
 }
 
-float CoreComponent::getTemperature() {
-	if ((sensor != NULL) && (sensor->isValid())) {
+float ThermalComponentCore::getTemperature() {
+	if ((sensor != nullptr) && (sensor->isValid())) {
 		return sensor->getTemperature();
 	}
 
-	if ((firstRedundantSensor != NULL) && (firstRedundantSensor->isValid())) {
+	if ((firstRedundantSensor != nullptr) &&
+	        (firstRedundantSensor->isValid())) {
 		return firstRedundantSensor->getTemperature();
 	}
 
-	if ((secondRedundantSensor != NULL) && (secondRedundantSensor->isValid())) {
+	if ((secondRedundantSensor != nullptr) &&
+	        (secondRedundantSensor->isValid())) {
 		return secondRedundantSensor->getTemperature();
 	}
 
-	if (thermalModule != NULL) {
+	if (thermalModule != nullptr) {
 		float temperature = thermalModule->getTemperature();
 		if (temperature != ThermalModuleIF::INVALID_TEMPERATURE) {
 			return temperature;
@@ -126,7 +150,7 @@ float CoreComponent::getTemperature() {
 	}
 }
 
-ThermalComponentIF::State CoreComponent::getState(float temperature,
+ThermalComponentIF::State ThermalComponentCore::getState(float temperature,
 		Parameters parameters, int8_t targetState) {
 	ThermalComponentIF::State state;
 
@@ -144,14 +168,14 @@ ThermalComponentIF::State CoreComponent::getState(float temperature,
 	return state;
 }
 
-void CoreComponent::checkLimits(ThermalComponentIF::State state) {
+void ThermalComponentCore::checkLimits(ThermalComponentIF::State state) {
 	//Checks operational limits only.
 	temperatureMonitor.translateState(state, temperature.value,
 			getParameters().lowerOpLimit, getParameters().upperOpLimit);
 
 }
 
-ThermalComponentIF::HeaterRequest CoreComponent::getHeaterRequest(
+ThermalComponentIF::HeaterRequest ThermalComponentCore::getHeaterRequest(
 		int8_t targetState, float temperature, Parameters parameters) {
 	if (targetState == STATE_REQUEST_IGNORE) {
 		isHeating = false;
@@ -177,7 +201,7 @@ ThermalComponentIF::HeaterRequest CoreComponent::getHeaterRequest(
 	return HEATER_DONT_CARE;
 }
 
-ThermalComponentIF::State CoreComponent::getIgnoredState(int8_t state) {
+ThermalComponentIF::State ThermalComponentCore::getIgnoredState(int8_t state) {
 	switch (state) {
 	case NON_OPERATIONAL_LOW:
 		return NON_OPERATIONAL_LOW_IGNORED;
@@ -197,7 +221,7 @@ ThermalComponentIF::State CoreComponent::getIgnoredState(int8_t state) {
 	}
 }
 
-void CoreComponent::updateMinMaxTemp() {
+void ThermalComponentCore::updateMinMaxTemp() {
 	if (temperature == INVALID_TEMPERATURE) {
 		return;
 	}
@@ -209,15 +233,15 @@ void CoreComponent::updateMinMaxTemp() {
 	}
 }
 
-uint8_t CoreComponent::getDomainId() const {
+uint8_t ThermalComponentCore::getDomainId() const {
 	return domainId;
 }
 
-CoreComponent::Parameters CoreComponent::getParameters() {
+ThermalComponentCore::Parameters ThermalComponentCore::getParameters() {
 	return parameters;
 }
 
-ReturnValue_t CoreComponent::getParameter(uint8_t domainId,
+ReturnValue_t ThermalComponentCore::getParameter(uint8_t domainId,
 		uint16_t parameterId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
 	ReturnValue_t result = temperatureMonitor.getParameter(domainId,
diff --git a/thermal/ThermalComponentCore.h b/thermal/ThermalComponentCore.h
new file mode 100644
index 000000000..2d08ed1d2
--- /dev/null
+++ b/thermal/ThermalComponentCore.h
@@ -0,0 +1,118 @@
+#ifndef FSFW_THERMAL_THERMALCOMPONENTCORE_H_
+#define FSFW_THERMAL_THERMALCOMPONENTCORE_H_
+
+#include "ThermalMonitorReporter.h"
+#include "ThermalComponentIF.h"
+#include "AbstractTemperatureSensor.h"
+#include "ThermalModule.h"
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+
+/**
+ * @brief
+ * @details
+ */
+class ThermalComponentCore: public ThermalComponentIF {
+public:
+	struct Parameters {
+		float lowerOpLimit;
+		float upperOpLimit;
+		float heaterOn;
+		float hysteresis;
+		float heaterSwitchoff;
+	};
+
+	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
+
+	/**
+	 * Some documentation
+	 * @param reportingObjectId
+	 * @param domainId
+	 * @param temperaturePoolId
+	 * @param targetStatePoolId
+	 * @param currentStatePoolId
+	 * @param requestPoolId
+	 * @param dataSet
+	 * @param parameters
+	 * @param initialTargetState
+	 */
+	ThermalComponentCore(object_id_t reportingObjectId, uint8_t domainId,
+	        uint32_t temperaturePoolId, uint32_t targetStatePoolId,
+	        uint32_t currentStatePoolId, uint32_t requestPoolId,
+	        GlobDataSet *dataSet, Parameters parameters,
+			StateRequest initialTargetState =
+					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
+
+	void addSensor(AbstractTemperatureSensor* firstRedundantSensor);
+	void addFirstRedundantSensor(
+	        AbstractTemperatureSensor* firstRedundantSensor);
+    void addSecondRedundantSensor(
+            AbstractTemperatureSensor* secondRedundantSensor);
+    void addThermalModule(ThermalModule* thermalModule, Priority priority);
+
+    void setPriority(Priority priority);
+
+	virtual ~ThermalComponentCore();
+
+	virtual HeaterRequest performOperation(uint8_t opCode);
+
+	void markStateIgnored();
+
+	object_id_t getObjectId();
+
+	uint8_t getDomainId() const;
+
+	virtual float getLowerOpLimit();
+
+	ReturnValue_t setTargetState(int8_t newState);
+
+	virtual void setOutputInvalid();
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+protected:
+
+	AbstractTemperatureSensor *sensor = nullptr;
+	AbstractTemperatureSensor *firstRedundantSensor = nullptr;
+	AbstractTemperatureSensor *secondRedundantSensor = nullptr;
+	ThermalModuleIF *thermalModule = nullptr;
+
+	gp_float_t temperature;
+	gp_int8_t targetState;
+	gp_int8_t currentState;
+	gp_uint8_t heaterRequest;
+
+	bool isHeating = false;
+
+	bool isSafeComponent = false;
+
+	float minTemp = 999;
+
+	float maxTemp = AbstractTemperatureSensor::ZERO_KELVIN_C;
+
+	Parameters parameters;
+
+	ThermalMonitorReporter temperatureMonitor;
+
+	const uint8_t domainId;
+
+	virtual float getTemperature();
+	virtual State getState(float temperature, Parameters parameters,
+			int8_t targetState);
+
+	virtual void checkLimits(State state);
+
+	virtual HeaterRequest getHeaterRequest(int8_t targetState,
+			float temperature, Parameters parameters);
+
+	virtual State getIgnoredState(int8_t state);
+
+	void updateMinMaxTemp();
+
+	virtual Parameters getParameters();
+};
+
+#endif /* FSFW_THERMAL_THERMALCOMPONENT_CORE_H_ */
diff --git a/thermal/ThermalComponentIF.h b/thermal/ThermalComponentIF.h
index 522d4e443..16739e362 100644
--- a/thermal/ThermalComponentIF.h
+++ b/thermal/ThermalComponentIF.h
@@ -49,18 +49,18 @@ public:
 		SAFE = 0,             //!< SAFE
 		IDLE,                 //!< IDLE
 		PAYLOAD,              //!< PAYLOAD
-		NUMBER_OF_PRIORITIES          //!< MAX_PRIORITY
+		NUMBER_OF_PRIORITIES  //!< MAX_PRIORITY
 	};
 
 	/**
 	 * The elements are ordered by priority, lowest have highest priority
 	 */
 	enum HeaterRequest {
-		HEATER_REQUEST_EMERGENCY_OFF = 0,          //!< REQUEST_EMERGENCY_OFF
-		HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
-		HEATER_REQUEST_OFF,          //!< REQUEST_OFF
-		HEATER_REQUEST_ON,           //!< REQUEST_ON
-		HEATER_DONT_CARE             //!< DONT_CARE
+		HEATER_REQUEST_EMERGENCY_OFF = 0,   //!< REQUEST_EMERGENCY_OFF
+		HEATER_REQUEST_EMERGENCY_ON,        //!< REQUEST_EMERGENCY_ON
+		HEATER_REQUEST_OFF,                 //!< REQUEST_OFF
+		HEATER_REQUEST_ON,                  //!< REQUEST_ON
+		HEATER_DONT_CARE                    //!< DONT_CARE
 	};
 
 	virtual ~ThermalComponentIF() {
diff --git a/thermal/ThermalMonitor.h b/thermal/ThermalMonitor.h
deleted file mode 100644
index 680c0cb05..000000000
--- a/thermal/ThermalMonitor.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_
-#define FRAMEWORK_THERMAL_THERMALMONITOR_H_
-
-#include "../monitoring/MonitorReporter.h"
-#include "../thermal/ThermalComponentIF.h"
-
-/**
- * What does it do. How to use it.
- */
-class ThermalMonitor: public MonitorReporter<float> {
-public:
-	template<typename ... Args>
-	ThermalMonitor(Args ... args) :
-			MonitorReporter<float>(std::forward<Args>(args)...) {
-	}
-	~ThermalMonitor();
-	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
-			float lowerLimit, float upperLimit, bool componentIsOperational = true);
-
-	bool isAboveHighLimit();
-protected:
-	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
-
-};
-
-#endif /* FRAMEWORK_THERMAL_THERMALMONITOR_H_ */
diff --git a/thermal/ThermalMonitor.cpp b/thermal/ThermalMonitorReporter.cpp
similarity index 84%
rename from thermal/ThermalMonitor.cpp
rename to thermal/ThermalMonitorReporter.cpp
index fc0823c3c..766ea1cb6 100644
--- a/thermal/ThermalMonitor.cpp
+++ b/thermal/ThermalMonitorReporter.cpp
@@ -1,10 +1,12 @@
-#include "../thermal/ThermalMonitor.h"
-#include "../thermal/ThermalComponentIF.h"
+#include "ThermalMonitorReporter.h"
+#include "ThermalComponentIF.h"
+
 #include "../monitoring/MonitoringIF.h"
-ThermalMonitor::~ThermalMonitor() {
+
+ThermalMonitorReporter::~ThermalMonitorReporter() {
 }
 
-void ThermalMonitor::sendTransitionEvent(float currentValue,
+void ThermalMonitorReporter::sendTransitionEvent(float currentValue,
 		ReturnValue_t state) {
 	switch (state) {
 	case MonitoringIF::BELOW_LOW_LIMIT:
@@ -28,7 +30,7 @@ void ThermalMonitor::sendTransitionEvent(float currentValue,
 	}
 }
 
-bool ThermalMonitor::isAboveHighLimit() {
+bool ThermalMonitorReporter::isAboveHighLimit() {
 	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
 		return true;
 	} else {
@@ -36,7 +38,7 @@ bool ThermalMonitor::isAboveHighLimit() {
 	}
 }
 
-ReturnValue_t ThermalMonitor::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
+ReturnValue_t ThermalMonitorReporter::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
 		float upperLimit, bool componentIsOperational) {
 	if (ThermalComponentIF::isIgnoredState(state)) {
 		setToUnchecked();
diff --git a/thermal/ThermalMonitorReporter.h b/thermal/ThermalMonitorReporter.h
new file mode 100644
index 000000000..4fb68a991
--- /dev/null
+++ b/thermal/ThermalMonitorReporter.h
@@ -0,0 +1,28 @@
+#ifndef FSFW_THERMAL_THERMALMONITORREPORTER_H_
+#define FSFW_THERMAL_THERMALMONITORREPORTER_H_
+
+#include "ThermalComponentIF.h"
+#include "../monitoring/MonitorReporter.h"
+
+
+/**
+ * @brief   Monitor Reporter implementation for thermal components.
+ */
+class ThermalMonitorReporter: public MonitorReporter<float> {
+public:
+	template<typename ... Args>
+	ThermalMonitorReporter(Args ... args) :
+			MonitorReporter<float>(std::forward<Args>(args)...) {
+	}
+	~ThermalMonitorReporter();
+	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
+			float lowerLimit, float upperLimit,
+			bool componentIsOperational = true);
+
+	bool isAboveHighLimit();
+protected:
+	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
+
+};
+
+#endif /* FSFW_THERMAL_THERMALMONITORREPORTERREPORTER_H_ */

From 1cc0847bb512bc5df7a79097da726bf7f45739db Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 21 Nov 2020 00:15:31 +0100
Subject: [PATCH 1013/1774] small bugfix

---
 devicehandlers/DeviceHandlerIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 10907a891..35bbe3764 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -18,7 +18,7 @@ public:
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
 
-	static constexpr Command_t NO_COMMAND = 0xffffffff;
+	static constexpr Command_t NO_COMMAND = -1;
 
 	/**
 	 * @brief This is the mode the <strong>device handler</strong> is in.

From 8c294729d0dce83c95f34b849ec8bbe8ef369133 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 22 Nov 2020 12:34:16 +0100
Subject: [PATCH 1014/1774] extern c definition added

---
 osal/FreeRTOS/TaskManagement.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 4b7fe3eb3..eb7351859 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -13,7 +13,7 @@ extern "C" {
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
  */
-extern void vRequestContextSwitchFromISR();
+extern "C" void vRequestContextSwitchFromISR();
 
 /*!
  * Used by functions to tell if they are being called from

From 767f1057628f96019ba1836a83a43c94383cb0f4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 24 Nov 2020 13:45:34 +0100
Subject: [PATCH 1015/1774] added changelog

---
 CHANGELOG | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 CHANGELOG

diff --git a/CHANGELOG b/CHANGELOG
new file mode 100644
index 000000000..96f5703c5
--- /dev/null
+++ b/CHANGELOG
@@ -0,0 +1,7 @@
+## Changes from ASTP 0.0.1 to 0.0.2
+
+
+### FreeRTOS OSAL
+
+- vRequestContextSwitchFromISR is declared extern "C" so it can be defined in
+a C file without issues

From b7fb1b42e660795325c66f7fcf5e1a9d2388bb12 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 29 Nov 2020 12:43:19 +0100
Subject: [PATCH 1016/1774] added new cfg option

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index be3717b40..fa769bad0 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -39,7 +39,10 @@
 
 //! When using the newlib nano library, C99 support for stdio facilities
 //! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NO_C99_IO 	1
+#define FSFW_NO_C99_IO 	            1
+
+//! Specify whether a special mode store is used for Subsystem components.
+#define FSFW_USE_MODESTORE          0
 
 namespace fsfwconfig {
 //! Default timestamp size. The default timestamp will be an eight byte CDC

From 279df93cdf84eb99b3d1609b97c422be6e07d512 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 29 Nov 2020 13:01:37 +0100
Subject: [PATCH 1017/1774] form and doc comments

---
 subsystem/Subsystem.h | 29 ++++++++++++++++-------------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index 9a3fcdfe6..09d7850ab 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -10,6 +10,10 @@
 #include "../container/SinglyLinkedList.h"
 #include "../serialize/SerialArrayListAdapter.h"
 
+/**
+ * @brief   TODO: documentation missing
+ * @details
+ */
 class Subsystem: public SubsystemBase, public HasModeSequenceIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM;
@@ -31,8 +35,13 @@ public:
 	static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1);
 	static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2);
 
-
-
+	/**
+	 * TODO: Doc for constructor
+	 * @param setObjectId
+	 * @param parent
+	 * @param maxNumberOfSequences
+	 * @param maxNumberOfTables
+	 */
 	Subsystem(object_id_t setObjectId, object_id_t parent,
 			uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
 	virtual ~Subsystem();
@@ -52,24 +61,20 @@ public:
 	virtual MessageQueueId_t getSequenceCommandQueue() const override;
 
 	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
+	 * @brief    Checks whether a sequence, identified by a mode.
 	 * @param sequence
 	 * @return
 	 */
 	ReturnValue_t checkSequence(Mode_t sequence);
 
 	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
+	 * @brief   Checks whether a sequence, identified by a mode list iterator
+	 *          and a fallback sequence.
 	 * @param iter
 	 * @return
 	 */
-	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter, Mode_t fallbackSequence);
+	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter,
+	        Mode_t fallbackSequence);
 protected:
 
 	struct EntryPointer {
@@ -125,8 +130,6 @@ protected:
 
 	HybridIterator<ModeListEntry> getCurrentTable();
 
-//	void startSequence(Mode_t sequence);
-
 	/**
 	 * DO NOT USE ON NON EXISTING SEQUENCE
 	 *

From 952978f999936c515de731e796f95076373c5528 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 29 Nov 2020 13:04:38 +0100
Subject: [PATCH 1018/1774] moved perform hk op call

---
 devicehandlers/DeviceHandlerBase.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 38821054b..ccd5bebb3 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -86,7 +86,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		decrementDeviceReplyMap();
 		fdirInstance->checkForFailures();
 		hkSwitcher.performOperation();
-		hkManager.performHkOperation();
 		performOperationHook();
 		return RETURN_OK;
 	}
@@ -111,6 +110,9 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		break;
 	case CommunicationAction::GET_READ:
 		doGetRead();
+		// This will be performed after datasets have been updated by the
+		// custom device implementation.
+        hkManager.performHkOperation();
 		break;
 	default:
 		break;

From c182171b096d1beaa25edda4ff365b5f2fdd64d9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 12:32:38 +0100
Subject: [PATCH 1019/1774] updated make file

---
 fsfw.mk | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/fsfw.mk b/fsfw.mk
index 3639717b6..f2cdd7ab6 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -70,3 +70,5 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)
+
+INCLUDES += $(CURRENTPATH)

From 49479faa1a4e2b8e43fc1ff55fb4fce7cff75bbb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 12:37:22 +0100
Subject: [PATCH 1020/1774] better solution

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 1 -
 fsfw.mk                            | 2 --
 2 files changed, 3 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index be3717b40..8c6c754ae 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -1,7 +1,6 @@
 #ifndef CONFIG_FSFWCONFIG_H_
 #define CONFIG_FSFWCONFIG_H_
 
-#include <FSFWVersion.h>
 #include <cstddef>
 #include <cstdint>
 
diff --git a/fsfw.mk b/fsfw.mk
index f2cdd7ab6..3639717b6 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -70,5 +70,3 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)
-
-INCLUDES += $(CURRENTPATH)

From f0ca4be71eec5e3883d270e98b5b53ceab4fe1e2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 13:09:03 +0100
Subject: [PATCH 1021/1774] fsfw version include removed

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index fa769bad0..f475e3fa8 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -1,7 +1,6 @@
 #ifndef CONFIG_FSFWCONFIG_H_
 #define CONFIG_FSFWCONFIG_H_
 
-#include <FSFWVersion.h>
 #include <cstddef>
 #include <cstdint>
 

From fa4597782ec20090f45d390c9cee6542561de7f6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 13:09:56 +0100
Subject: [PATCH 1022/1774] some improvements taken over from master

---
 osal/linux/TcUnixUdpPollingTask.cpp |  2 +-
 osal/linux/TmTcUnixUdpBridge.cpp    | 16 ++++++++++++----
 osal/linux/TmTcUnixUdpBridge.h      |  5 ++++-
 3 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 670ba8044..af99ec91f 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -33,7 +33,7 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 	while(1) {
 		//! Sender Address is cached here.
 		struct sockaddr_in senderAddress;
-		socklen_t senderSockLen = 0;
+		socklen_t senderSockLen = sizeof(senderAddress);
 		ssize_t bytesReceived = recvfrom(serverUdpSocket,
 				receptionBuffer.data(), frameSize, receptionFlags,
 				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index b55291b3d..ab28623ef 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -65,9 +65,13 @@ 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);
+	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+
+	if(ipAddrAnySet){
+		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,
@@ -85,7 +89,7 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
 	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //	char ipAddress [15];
@@ -168,3 +172,7 @@ void TmTcUnixUdpBridge::handleSendError() {
 	}
 }
 
+void TmTcUnixUdpBridge::setClientAddressToAny(bool ipAddrAnySet){
+	this->ipAddrAnySet = ipAddrAnySet;
+}
+
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index 5245c44cb..ae6f6adca 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -20,8 +20,9 @@ public:
 			uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
 	virtual~ TmTcUnixUdpBridge();
 
-	void checkAndSetClientAddress(sockaddr_in clientAddress);
+	void checkAndSetClientAddress(sockaddr_in& clientAddress);
 
+	void setClientAddressToAny(bool ipAddrAnySet);
 protected:
 	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
 
@@ -36,6 +37,8 @@ private:
 	struct sockaddr_in serverAddress;
 	socklen_t serverAddressLen = 0;
 
+	bool ipAddrAnySet = false;
+
 	//! Access to the client address is mutex protected as it is set
 	//! by another task.
 	MutexIF* mutex;

From b7945dfe606e2b2edd1a618aa089f893876ed75c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 13:45:08 +0100
Subject: [PATCH 1023/1774] added gp_id_t

---
 datapoollocal/HasLocalDataPoolIF.h |  3 +-
 datapoollocal/locPoolDefinitions.h | 44 +++++++++++++++++++++++++++++-
 2 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 9d4f2605a..7f1f202e7 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -43,7 +43,8 @@ public:
 	virtual~ HasLocalDataPoolIF() {};
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
-	static constexpr lp_id_t NO_POOL_ID = 0xffffffff;
+
+	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
 	virtual object_id_t getObjectId() const = 0;
 
diff --git a/datapoollocal/locPoolDefinitions.h b/datapoollocal/locPoolDefinitions.h
index d14930595..1115a336a 100644
--- a/datapoollocal/locPoolDefinitions.h
+++ b/datapoollocal/locPoolDefinitions.h
@@ -10,11 +10,19 @@
  */
 using lp_id_t = uint32_t;
 
+namespace localpool {
+static constexpr uint32_t INVALID_LPID = -1;
+}
 
+/**
+ * Used as a unique identifier for data sets.
+ */
 union sid_t {
     static constexpr uint64_t INVALID_SID = -1;
-    static constexpr uint32_t INVALID_SET_ID = -1;
     static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+    static constexpr uint32_t INVALID_SET_ID = -1;
+
+
     sid_t(): raw(INVALID_SID) {}
 
     sid_t(object_id_t objectId, uint32_t setId):
@@ -48,4 +56,38 @@ union sid_t {
     }
 };
 
+/**
+ * Used as a global unique identifier for local pool variables.
+ */
+union gp_id_t {
+	static constexpr uint64_t INVALID_GPID = -1;
+    static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
+
+	gp_id_t(): raw(INVALID_GPID) {}
+
+	gp_id_t(object_id_t objectID, lp_id_t localPoolId):
+			objectId(objectId),
+			localPoolId(localPoolId) {}
+
+	struct {
+		object_id_t objectId;
+		lp_id_t localPoolId;
+	};
+
+	uint64_t raw;
+
+	bool notSet() const {
+		return raw == INVALID_GPID;
+	}
+
+    bool operator==(const sid_t& other) const {
+        return raw == other.raw;
+    }
+
+    bool operator!=(const sid_t& other) const {
+        return not (raw == other.raw);
+    }
+};
+
 #endif /* FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_ */

From 25f08b8c1f8143bbcabfab7f40541351eb2adc50 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 13:59:54 +0100
Subject: [PATCH 1024/1774] started replacing local pool vars

---
 datapoollocal/LocalPoolObjectBase.cpp |  2 +-
 datapoollocal/LocalPoolObjectBase.h   |  2 +-
 datapoollocal/LocalPoolVariable.h     | 11 +++++++++--
 datapoollocal/LocalPoolVariable.tpp   | 12 ++++++++++--
 datapoollocal/LocalPoolVector.h       | 18 ++++++++++++++----
 datapoollocal/LocalPoolVector.tpp     | 21 ++++++++++++++-------
 thermal/ThermalComponentCore.cpp      |  7 +++----
 thermal/ThermalComponentCore.h        | 19 ++++++++++---------
 8 files changed, 62 insertions(+), 30 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 880271695..c25df25a0 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -19,7 +19,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
     }
 }
 
-LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, object_id_t poolOwner,
+LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
         readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 4d25b88a6..8d1ab45e4 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -14,7 +14,7 @@ public:
             HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
             pool_rwm_t setReadWriteMode);
 
-    LocalPoolObjectBase(lp_id_t poolId, object_id_t poolOwner,
+    LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
             DataSetIF* dataSet = nullptr,
             pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index e9d94178a..85d864206 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -64,9 +64,17 @@ public:
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 *
 	 */
-	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+	LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+	/**
+	 * Variation which takes the global unique identifier of a pool variable.
+	 * @param globalPoolId
+	 * @param dataSet
+	 * @param setReadWriteMode
+	 */
+	LocalPoolVar(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	virtual~ LocalPoolVar() {};
 
@@ -156,5 +164,4 @@ using lp_int64_t = LocalPoolVar<int64_t>;
 using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
-
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 3320aa5a4..7025e4622 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -12,9 +12,17 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+inline LocalPoolVar<T>::LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-        LocalPoolObjectBase(poolId, poolOwner, dataSet, setReadWriteMode) {}
+        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+
+
+template<typename T>
+inline LocalPoolVar<T>::LocalPoolVar(gp_id_t globalPoolId, DataSetIF *dataSet,
+		pool_rwm_t setReadWriteMode):
+		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+				dataSet, setReadWriteMode){}
+
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index a7ebd3fe6..4644b7482 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 
 #include "LocalPoolObjectBase.h"
 #include "../datapool/DataSetIF.h"
@@ -65,7 +65,17 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
+	LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+	/**
+	 * Variation which takes the unique global identifier of a local pool
+	 * vector.
+	 * @param globalPoolId
+	 * @param dataSet
+	 * @param setReadWriteMode
+	 */
+	LocalPoolVector(gp_id_t globalPoolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
@@ -161,4 +171,4 @@ private:
 template<typename T, uint16_t vectorSize>
 using lp_vec_t = LocalPoolVector<T, vectorSize>;
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 34720b970..fc3c0a2e7 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
 
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 #error Include LocalPoolVector.h before LocalPoolVector.tpp!
 #endif
 
@@ -12,9 +12,16 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		object_id_t poolOwner, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		LocalPoolObjectBase(poolId, poolOwner, dataSet, setReadWriteMode) {}
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
+		lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+		LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+
+
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
+		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+				dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
@@ -148,4 +155,4 @@ inline std::ostream& operator<< (std::ostream &out,
     return out;
 }
 
-#endif
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_ */
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index bf28f307f..07649bf30 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -1,10 +1,9 @@
 #include "ThermalComponentCore.h"
 
 ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
-        uint8_t domainId, uint32_t temperaturePoolId,
-        uint32_t targetStatePoolId,
-		uint32_t currentStatePoolId, uint32_t requestPoolId,
-		GlobDataSet* dataSet, Parameters parameters,
+        uint8_t domainId, gp_id_t temperaturePoolId,
+        gp_id_t targetStatePoolId, gp_id_t currentStatePoolId,
+		gp_id_t requestPoolId, LocalDataSetBase* dataSet, Parameters parameters,
 		StateRequest initialTargetState) :
 		temperature(temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE),
 		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ),
diff --git a/thermal/ThermalComponentCore.h b/thermal/ThermalComponentCore.h
index 2d08ed1d2..49ca098ef 100644
--- a/thermal/ThermalComponentCore.h
+++ b/thermal/ThermalComponentCore.h
@@ -6,8 +6,9 @@
 #include "AbstractTemperatureSensor.h"
 #include "ThermalModule.h"
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
+//#include "../datapoolglob/GlobalDataSet.h"
+//#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoollocal/LocalPoolVariable.h"
 
 /**
  * @brief
@@ -38,9 +39,9 @@ public:
 	 * @param initialTargetState
 	 */
 	ThermalComponentCore(object_id_t reportingObjectId, uint8_t domainId,
-	        uint32_t temperaturePoolId, uint32_t targetStatePoolId,
-	        uint32_t currentStatePoolId, uint32_t requestPoolId,
-	        GlobDataSet *dataSet, Parameters parameters,
+	        gp_id_t temperaturePoolId, gp_id_t targetStatePoolId,
+	        gp_id_t currentStatePoolId, gp_id_t requestPoolId,
+			LocalDataSetBase* dataSet, Parameters parameters,
 			StateRequest initialTargetState =
 					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
 
@@ -80,10 +81,10 @@ protected:
 	AbstractTemperatureSensor *secondRedundantSensor = nullptr;
 	ThermalModuleIF *thermalModule = nullptr;
 
-	gp_float_t temperature;
-	gp_int8_t targetState;
-	gp_int8_t currentState;
-	gp_uint8_t heaterRequest;
+	lp_var_t<float> temperature;
+	lp_var_t<int8_t> targetState;
+	lp_var_t<int8_t> currentState;
+	lp_var_t<uint8_t> heaterRequest;
 
 	bool isHeating = false;
 

From e7a96d5ad8dd7169818e624943bcf15b651c0af1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 14:13:52 +0100
Subject: [PATCH 1025/1774] it doesnt work? comment it !

---
 datapoollocal/LocalDataPoolManager.h |   2 +-
 datapoollocal/LocalPoolVariable.h    |   2 +-
 datapoollocal/LocalPoolVariable.tpp  |   5 +-
 internalError/InternalErrorDataset.h |  12 +--
 thermal/ThermalComponent.cpp         |  18 ++--
 thermal/ThermalComponent.h           |   6 +-
 thermal/ThermalComponentCore.cpp     | 147 ++++++++++++++-------------
 thermal/ThermalComponentCore.h       |   6 +-
 8 files changed, 99 insertions(+), 99 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index aca0d4f60..95d483032 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -20,7 +20,7 @@ namespace Factory {
 void setStaticFrameworkObjectIds();
 }
 
-class LocalDataSetBase;
+class LocalPoolDataSetBase;
 class HousekeepingPacketUpdate;
 
 /**
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 85d864206..75cf570ed 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -43,7 +43,7 @@ public:
 	 * If nullptr, the variable is not registered.
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 */
-	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+	LocalPoolVar(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 7025e4622..26500e3b6 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -6,9 +6,8 @@
 #endif
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
-		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
-		pool_rwm_t setReadWriteMode):
+inline LocalPoolVar<T>::LocalPoolVar(HasLocalDataPoolIF* hkOwner,
+		lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
index 52a4b6324..fa91116d4 100644
--- a/internalError/InternalErrorDataset.h
+++ b/internalError/InternalErrorDataset.h
@@ -21,12 +21,12 @@ public:
     InternalErrorDataset(object_id_t objectId):
            StaticLocalDataSet(sid_t(objectId , ERROR_SET_ID)) {}
 
-    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(TM_HITS,
-            hkManager->getOwner(), this);
-    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(QUEUE_HITS,
-            hkManager->getOwner(), this);
-    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(STORE_HITS,
-            hkManager->getOwner(), this);
+    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    		TM_HITS, this);
+    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    		QUEUE_HITS, this);
+    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    		STORE_HITS, this);
 };
 
 
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 78b14efd8..54bd67bdb 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -1,9 +1,9 @@
 #include "ThermalComponent.h"
 
 ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
-		uint8_t domainId, uint32_t temperaturePoolId,
-		uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-		uint32_t requestPoolId, GlobDataSet* dataSet,
+		uint8_t domainId, gp_id_t temperaturePoolId,
+		gp_id_t targetStatePoolId, gp_id_t currentStatePoolId,
+		gp_id_t requestPoolId, LocalPoolDataSetBase* dataSet,
 		AbstractTemperatureSensor* sensor,
 		AbstractTemperatureSensor* firstRedundantSensor,
 		AbstractTemperatureSensor* secondRedundantSensor,
@@ -78,13 +78,13 @@ ThermalComponentIF::State ThermalComponent::getState(float temperature,
 }
 
 void ThermalComponent::checkLimits(ThermalComponentIF::State state) {
-	if (targetState == STATE_REQUEST_OPERATIONAL || targetState == STATE_REQUEST_IGNORE) {
-		ThermalComponentCore::checkLimits(state);
-		return;
-	}
+	//if (targetState == STATE_REQUEST_OPERATIONAL || targetState == STATE_REQUEST_IGNORE) {
+	//	ThermalComponentCore::checkLimits(state);
+	//	return;
+	//}
 	//If component is not operational, it checks the NOP limits.
-	temperatureMonitor.translateState(state, temperature.value,
-			nopParameters.lowerNopLimit, nopParameters.upperNopLimit, false);
+	//temperatureMonitor.translateState(state, temperature.value,
+	//		nopParameters.lowerNopLimit, nopParameters.upperNopLimit, false);
 }
 
 ThermalComponentIF::HeaterRequest ThermalComponent::getHeaterRequest(
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index d61ff01e1..0785a9141 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -45,9 +45,9 @@ public:
 	 * @param priority
 	 */
 	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId,
-	        uint32_t temperaturePoolId, uint32_t targetStatePoolId,
-	        uint32_t currentStatePoolId, uint32_t requestPoolId,
-			GlobDataSet *dataSet, AbstractTemperatureSensor *sensor,
+	        gp_id_t temperaturePoolId, gp_id_t targetStatePoolId,
+	        gp_id_t currentStatePoolId, gp_id_t requestPoolId,
+			LocalPoolDataSetBase *dataSet, AbstractTemperatureSensor *sensor,
 			AbstractTemperatureSensor *firstRedundantSensor,
 			AbstractTemperatureSensor *secondRedundantSensor,
 			ThermalModuleIF *thermalModule, Parameters parameters,
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index 07649bf30..53eeb58fd 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -3,22 +3,22 @@
 ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
         uint8_t domainId, gp_id_t temperaturePoolId,
         gp_id_t targetStatePoolId, gp_id_t currentStatePoolId,
-		gp_id_t requestPoolId, LocalDataSetBase* dataSet, Parameters parameters,
-		StateRequest initialTargetState) :
+		gp_id_t requestPoolId, LocalPoolDataSetBase* dataSet,
+		Parameters parameters, StateRequest initialTargetState) :
 		temperature(temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE),
 		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ),
 		currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
 		heaterRequest(requestPoolId, dataSet, PoolVariableIF::VAR_WRITE),
-		parameters(parameters),
-		temperatureMonitor(reportingObjectId, domainId + 1,
-		        GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
-				COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
+		parameters(parameters), domainId(domainId) {
+		//temperatureMonitor(reportingObjectId, domainId + 1,
+		//        GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
+		//		COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
 	//Set thermal state once, then leave to operator.
-	GlobDataSet mySet;
-	gp_uint8_t writableTargetState(targetStatePoolId, &mySet,
-			PoolVariableIF::VAR_WRITE);
-	writableTargetState = initialTargetState;
-	mySet.commit(PoolVariableIF::VALID);
+	//GlobDataSet mySet;
+	//gp_uint8_t writableTargetState(targetStatePoolId, &mySet,
+	//		PoolVariableIF::VAR_WRITE);
+	//writableTargetState = initialTargetState;
+	//mySet.commit(PoolVariableIF::VALID);
 }
 
 void ThermalComponentCore::addSensor(AbstractTemperatureSensor* sensor) {
@@ -57,19 +57,19 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 	HeaterRequest request = HEATER_DONT_CARE;
 	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
 	temperature = getTemperature();
-	updateMinMaxTemp();
-	if ((temperature != INVALID_TEMPERATURE)) {
-		temperature.setValid(PoolVariableIF::VALID);
-		State state = getState(temperature, getParameters(), targetState);
-		currentState = state;
-		checkLimits(state);
-		request = getHeaterRequest(targetState, temperature, getParameters());
-	} else {
-		temperatureMonitor.setToInvalid();
-		temperature.setValid(PoolVariableIF::INVALID);
-		currentState = UNKNOWN;
-		request = HEATER_DONT_CARE;
-	}
+	//updateMinMaxTemp();
+	//if ((temperature != INVALID_TEMPERATURE)) {
+		//temperature.setValid(PoolVariableIF::VALID);
+		//State state = getState(temperature, getParameters(), targetState);
+		//currentState = state;
+		//checkLimits(state);
+		//request = getHeaterRequest(targetState, temperature, getParameters());
+	//} else {
+	//	temperatureMonitor.setToInvalid();
+	//	temperature.setValid(PoolVariableIF::INVALID);
+	//	currentState = UNKNOWN;
+	//	request = HEATER_DONT_CARE;
+	//}
 	currentState.setValid(PoolVariableIF::VALID);
 	heaterRequest = request;
 	heaterRequest.setValid(PoolVariableIF::VALID);
@@ -77,11 +77,12 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 }
 
 void ThermalComponentCore::markStateIgnored() {
-	currentState = getIgnoredState(currentState);
+	//currentState = getIgnoredState(currentState);
 }
 
 object_id_t ThermalComponentCore::getObjectId() {
-	return temperatureMonitor.getReporterId();
+	//return temperatureMonitor.getReporterId();
+	return 0;
 }
 
 float ThermalComponentCore::getLowerOpLimit() {
@@ -119,7 +120,7 @@ void ThermalComponentCore::setOutputInvalid() {
 	currentState.setValid(PoolVariableIF::INVALID);
 	heaterRequest = HEATER_DONT_CARE;
 	heaterRequest.setValid(PoolVariableIF::INVALID);
-	temperatureMonitor.setToUnchecked();
+	//temperatureMonitor.setToUnchecked();
 }
 
 float ThermalComponentCore::getTemperature() {
@@ -169,8 +170,8 @@ ThermalComponentIF::State ThermalComponentCore::getState(float temperature,
 
 void ThermalComponentCore::checkLimits(ThermalComponentIF::State state) {
 	//Checks operational limits only.
-	temperatureMonitor.translateState(state, temperature.value,
-			getParameters().lowerOpLimit, getParameters().upperOpLimit);
+	//temperatureMonitor.translateState(state, temperature.value,
+	//		getParameters().lowerOpLimit, getParameters().upperOpLimit);
 
 }
 
@@ -220,17 +221,17 @@ ThermalComponentIF::State ThermalComponentCore::getIgnoredState(int8_t state) {
 	}
 }
 
-void ThermalComponentCore::updateMinMaxTemp() {
-	if (temperature == INVALID_TEMPERATURE) {
-		return;
-	}
-	if (temperature < minTemp) {
-		minTemp = temperature;
-	}
-	if (temperature > maxTemp) {
-		maxTemp = temperature;
-	}
-}
+//void ThermalComponentCore::updateMinMaxTemp() {
+//	if (temperature == INVALID_TEMPERATURE) {
+//		return;
+//	}
+//	if (temperature < minTemp) {
+//		minTemp = temperature;
+//	}
+//	if (temperature > maxTemp) {
+//		maxTemp = temperature;
+//	}
+//}
 
 uint8_t ThermalComponentCore::getDomainId() const {
 	return domainId;
@@ -243,38 +244,38 @@ ThermalComponentCore::Parameters ThermalComponentCore::getParameters() {
 ReturnValue_t ThermalComponentCore::getParameter(uint8_t domainId,
 		uint16_t parameterId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = temperatureMonitor.getParameter(domainId,
-			parameterId, parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	if (domainId != this->domainId) {
-		return INVALID_DOMAIN_ID;
-	}
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set(parameters.heaterOn);
-		break;
-	case 1:
-		parameterWrapper->set(parameters.hysteresis);
-		break;
-	case 2:
-		parameterWrapper->set(parameters.heaterSwitchoff);
-		break;
-	case 3:
-		parameterWrapper->set(minTemp);
-		break;
-	case 4:
-		parameterWrapper->set(maxTemp);
-		break;
-	case 10:
-		parameterWrapper->set(parameters.lowerOpLimit);
-		break;
-	case 11:
-		parameterWrapper->set(parameters.upperOpLimit);
-		break;
-	default:
-		return INVALID_IDENTIFIER_ID;
-	}
+	//ReturnValue_t result = temperatureMonitor.getParameter(domainId,
+	//		parameterId, parameterWrapper, newValues, startAtIndex);
+//	if (result != INVALID_DOMAIN_ID) {
+//		return result;
+//	}
+//	if (domainId != this->domainId) {
+//		return INVALID_DOMAIN_ID;
+//	}
+//	switch (parameterId) {
+//	case 0:
+//		parameterWrapper->set(parameters.heaterOn);
+//		break;
+//	case 1:
+//		parameterWrapper->set(parameters.hysteresis);
+//		break;
+//	case 2:
+//		parameterWrapper->set(parameters.heaterSwitchoff);
+//		break;
+//	case 3:
+//		parameterWrapper->set(minTemp);
+//		break;
+//	case 4:
+//		parameterWrapper->set(maxTemp);
+//		break;
+//	case 10:
+//		parameterWrapper->set(parameters.lowerOpLimit);
+//		break;
+//	case 11:
+//		parameterWrapper->set(parameters.upperOpLimit);
+//		break;
+//	default:
+//		return INVALID_IDENTIFIER_ID;
+//	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/thermal/ThermalComponentCore.h b/thermal/ThermalComponentCore.h
index 49ca098ef..6ef59058a 100644
--- a/thermal/ThermalComponentCore.h
+++ b/thermal/ThermalComponentCore.h
@@ -41,7 +41,7 @@ public:
 	ThermalComponentCore(object_id_t reportingObjectId, uint8_t domainId,
 	        gp_id_t temperaturePoolId, gp_id_t targetStatePoolId,
 	        gp_id_t currentStatePoolId, gp_id_t requestPoolId,
-			LocalDataSetBase* dataSet, Parameters parameters,
+			LocalPoolDataSetBase* dataSet, Parameters parameters,
 			StateRequest initialTargetState =
 					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
 
@@ -96,7 +96,7 @@ protected:
 
 	Parameters parameters;
 
-	ThermalMonitorReporter temperatureMonitor;
+	//ThermalMonitorReporter temperatureMonitor;
 
 	const uint8_t domainId;
 
@@ -111,7 +111,7 @@ protected:
 
 	virtual State getIgnoredState(int8_t state);
 
-	void updateMinMaxTemp();
+	//void updateMinMaxTemp();
 
 	virtual Parameters getParameters();
 };

From f70ee7696a82f96268d5cc06b6182a6c30780515 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 15:30:56 +0100
Subject: [PATCH 1026/1774] it compiles again

---
 datapoollocal/LocalPoolDataSetBase.cpp |  2 +-
 datapoollocal/LocalPoolVariable.h      |  2 +
 datapoollocal/LocalPoolVariable.tpp    |  9 +++-
 datapoollocal/LocalPoolVector.h        |  2 +-
 datapoollocal/LocalPoolVector.tpp      |  4 +-
 datapoollocal/locPoolDefinitions.h     |  2 +-
 monitoring/AbsLimitMonitor.h           | 10 ++--
 monitoring/LimitMonitor.h              | 12 ++---
 monitoring/MonitorBase.h               |  7 ++-
 monitoring/MonitorReporter.h           |  5 +-
 monitoring/MonitoringMessageContent.h  | 37 +++++++++------
 power/Fuse.cpp                         | 63 +++++++++++++-------------
 power/Fuse.h                           | 32 +++++++------
 power/PowerSensor.cpp                  | 56 ++++++++++++-----------
 power/PowerSensor.h                    | 27 +++++++----
 thermal/ThermalMonitorReporter.cpp     | 15 ++++--
 16 files changed, 162 insertions(+), 123 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 6e237c48e..640956dba 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -31,7 +31,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
-                PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
     if(hkOwner == nullptr) {
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 75cf570ed..173c2035f 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -119,6 +119,7 @@ public:
 
 
 	LocalPoolVar<T> &operator=(T newValue);
+	LocalPoolVar<T> &operator=(LocalPoolVar<T> newPoolVariable);
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
@@ -164,4 +165,5 @@ using lp_int64_t = LocalPoolVar<int64_t>;
 using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
+
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 26500e3b6..8aa164d15 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -81,11 +81,18 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 }
 
 template<typename T>
-inline LocalPoolVar<T> & LocalPoolVar<T>::operator =(T newValue) {
+inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(T newValue) {
     value = newValue;
     return *this;
 }
 
+template<typename T>
+inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
+		LocalPoolVar<T> newPoolVariable) {
+	value = newPoolVariable.value;
+	return *this;
+}
+
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 4644b7482..58face3cb 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -47,7 +47,7 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+	LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index fc3c0a2e7..46123ccc1 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -6,8 +6,8 @@
 #endif
 
 template<typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
+		HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
 		pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
diff --git a/datapoollocal/locPoolDefinitions.h b/datapoollocal/locPoolDefinitions.h
index 1115a336a..6e74d349a 100644
--- a/datapoollocal/locPoolDefinitions.h
+++ b/datapoollocal/locPoolDefinitions.h
@@ -66,7 +66,7 @@ union gp_id_t {
 
 	gp_id_t(): raw(INVALID_GPID) {}
 
-	gp_id_t(object_id_t objectID, lp_id_t localPoolId):
+	gp_id_t(object_id_t objectId, lp_id_t localPoolId):
 			objectId(objectId),
 			localPoolId(localPoolId) {}
 
diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index d85d5b618..1206dbf60 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -8,12 +8,11 @@ template<typename T>
 class AbsLimitMonitor: public MonitorBase<T> {
 public:
 	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId,
-	        object_id_t dataCreatorId, lp_id_t localPoolId,
-	        uint16_t confirmationLimit, T limit,
+	        gp_id_t globalPoolId, uint16_t confirmationLimit, T limit,
 	        Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE,
 	        bool aboveIsViolation = true) :
-			MonitorBase<T>(reporterId, monitorId, dataCreatorId, localPoolId,
-			        confirmationLimit),
+			MonitorBase<T>(reporterId, monitorId, globalPoolId,
+					confirmationLimit),
 			limit(limit), violationEvent(violationEvent),
 			aboveIsViolation(aboveIsViolation) {
 	}
@@ -67,7 +66,8 @@ protected:
 		switch (state) {
 		case MonitoringIF::OUT_OF_RANGE:
 			EventManagerIF::triggerEvent(this->reportingId,
-			        violationEvent, this->parameterId);
+			        violationEvent, this->parameterId.objectId,
+					this->parameterId.localPoolId);
 			break;
 		default:
 			break;
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index fdb05018c..27e35aa77 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -13,11 +13,11 @@ template<typename T>
 class LimitMonitor: public MonitorBase<T> {
 public:
 	LimitMonitor(object_id_t reporterId, uint8_t monitorId,
-	        object_id_t creatorId, lp_id_t localPoolId,
-			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
-			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
+	        gp_id_t globalPoolId, uint16_t confirmationLimit, T lowerLimit,
+			T upperLimit, Event belowLowEvent =
+					MonitoringIF::VALUE_BELOW_LOW_LIMIT,
 			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, creatorId, localPoolId,
+			MonitorBase<T>(reporterId, monitorId, globalPoolId,
 			        confirmationLimit),
 			lowerLimit(lowerLimit), upperLimit(upperLimit),
 			belowLowEvent(belowLowEvent), aboveHighEvent(aboveHighEvent) {
@@ -80,11 +80,11 @@ protected:
 		switch (state) {
 		case MonitoringIF::BELOW_LOW_LIMIT:
 			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent,
-			        this->parameterId);
+			        this->parameterId.objectId, this->parameterId.localPoolId);
 			break;
 		case MonitoringIF::ABOVE_HIGH_LIMIT:
 			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent,
-			        this->parameterId);
+			        this->parameterId.objectId, this->parameterId.localPoolId);
 			break;
 		default:
 			break;
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index df6f1af8c..530a38409 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -25,11 +25,10 @@ class MonitorBase: public MonitorReporter<T> {
 public:
 
 	MonitorBase(object_id_t reporterId, uint8_t monitorId,
-	        object_id_t dataCreatorId, lp_id_t localPoolId,
-	        uint16_t confirmationLimit):
-	        MonitorReporter<T>(reporterId, monitorId, dataCreatorId,
+	        gp_id_t globalPoolId, uint16_t confirmationLimit):
+	        MonitorReporter<T>(reporterId, monitorId, globalPoolId,
 	                confirmationLimit),
-	        poolVariable(dataCreatorId, localPoolId) {
+	        poolVariable(globalPoolId) {
 	}
 
 	virtual ~MonitorBase() {
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index d33f34d52..d6d8c8ed7 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -5,6 +5,7 @@
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
 
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 
@@ -18,7 +19,7 @@ public:
 	// TODO: Adapt to use SID instead of parameter ID.
 
 	MonitorReporter(object_id_t reportingId, uint8_t monitorId,
-	        uint32_t parameterId, uint16_t confirmationLimit) :
+	        gp_id_t globalPoolId, uint16_t confirmationLimit) :
 			monitorId(monitorId), parameterId(parameterId),
 			reportingId(reportingId), oldState(MonitoringIF::UNCHECKED),
 			reportingEnabled(ENABLED), eventEnabled(ENABLED), currentCounter(0),
@@ -95,7 +96,7 @@ public:
 
 protected:
 	const uint8_t monitorId;
-	const uint32_t parameterId;
+	const gp_id_t parameterId;
 	object_id_t reportingId;
 	ReturnValue_t oldState;
 
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index c82506f3a..44d326565 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -3,6 +3,7 @@
 
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
@@ -16,12 +17,17 @@ void setStaticFrameworkObjectIds();
 }
 
 //PID(uint32_t), TYPE, LIMIT_ID, value,limitValue, previous, later, timestamp
+/**
+ * @brief	Does magic.
+ * @tparam T
+ */
 template<typename T>
 class MonitoringReportContent: public SerialLinkedListAdapter<SerializeIF> {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	SerializeElement<uint8_t> monitorId;
-	SerializeElement<uint32_t> parameterId;
+	SerializeElement<uint32_t> parameterObjectId;
+	SerializeElement<lp_id_t> localPoolId;
 	SerializeElement<T> parameterValue;
 	SerializeElement<T> limitValue;
 	SerializeElement<ReturnValue_t> oldState;
@@ -30,20 +36,23 @@ public:
 	SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
 	TimeStamperIF* timeStamper;
 	MonitoringReportContent() :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					0), parameterValue(0), limitValue(0), oldState(0), newState(
-					0), rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
+			SerialLinkedListAdapter<SerializeIF>(&parameterObjectId),
+					monitorId(0), parameterObjectId(0),
+					localPoolId(0), parameterValue(0),
+					limitValue(0), oldState(0), newState(0),
+					rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
 					sizeof(rawTimestamp)), timeStamper(NULL) {
 		setAllNext();
 	}
-	MonitoringReportContent(uint32_t setPID, T value, T limitValue,
+	MonitoringReportContent(gp_id_t globalPoolId, T value, T limitValue,
 			ReturnValue_t oldState, ReturnValue_t newState) :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					setPID), parameterValue(value), limitValue(limitValue), oldState(
-					oldState), newState(newState), timestampSerializer(rawTimestamp,
-							sizeof(rawTimestamp)), timeStamper(NULL) {
+			SerialLinkedListAdapter<SerializeIF>(&parameterObjectId),
+					monitorId(0), parameterObjectId(globalPoolId.objectId),
+					localPoolId(globalPoolId.localPoolId),
+					parameterValue(value), limitValue(limitValue),
+					oldState(oldState), newState(newState),
+					timestampSerializer(rawTimestamp, sizeof(rawTimestamp)),
+					timeStamper(NULL) {
 		setAllNext();
 		if (checkAndSetStamper()) {
 			timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
@@ -53,16 +62,16 @@ private:
 
 	static object_id_t timeStamperId;
 	void setAllNext() {
-		parameterId.setNext(&parameterValue);
+		parameterObjectId.setNext(&parameterValue);
 		parameterValue.setNext(&limitValue);
 		limitValue.setNext(&oldState);
 		oldState.setNext(&newState);
 		newState.setNext(&timestampSerializer);
 	}
 	bool checkAndSetStamper() {
-		if (timeStamper == NULL) {
+		if (timeStamper == nullptr) {
 			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
-			if ( timeStamper == NULL ) {
+			if ( timeStamper == nullptr ) {
 				sif::error << "MonitoringReportContent::checkAndSetStamper: "
 				        "Stamper not found!" << std::endl;
 				return false;
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index ace625bfe..ff9c7b3c6 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -8,17 +8,16 @@
 
 object_id_t Fuse::powerSwitchId = 0;
 
-Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
+Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId,
+		sid_t variableSet, VariableIds ids,
 		float maxCurrent, uint16_t confirmationCount) :
-		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
-		NULL),
+		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId),
 		currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
 				maxCurrent, FUSE_CURRENT_HIGH),
-		powerMonitor(fuseObjectId, 2,
-		        GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
+		powerMonitor(fuseObjectId, 2, ids.poolIdPower,
 				confirmationCount),
-		set(), voltage(ids.pidVoltage, &set), current(ids.pidCurrent, &set),
-		state(ids.pidState, &set),
+		set(variableSet), voltage(ids.pidVoltage, &set),
+		current(ids.pidCurrent, &set), state(ids.pidState, &set),
 		power(ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE),
 		parameterHelper(this), healthHelper(this, fuseObjectId) {
 	commandQueue = QueueFactory::instance()->createMessageQueue();
@@ -73,19 +72,19 @@ ReturnValue_t Fuse::check() {
 	checkFuseState();
 	calculateFusePower();
 	//Check if power is valid and if fuse state is off or invalid.
-	if (!power.isValid() || (state == 0) || !state.isValid()) {
-		result = powerMonitor.setToInvalid();
-	} else {
-		float lowLimit = 0.0;
-		float highLimit = RESIDUAL_POWER;
-		calculatePowerLimits(&lowLimit, &highLimit);
-		result = powerMonitor.checkPower(power, lowLimit, highLimit);
-		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
-			reportEvents(POWER_BELOW_LOW_LIMIT);
-		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
-			reportEvents(POWER_ABOVE_HIGH_LIMIT);
-		}
-	}
+//	if (!power.isValid() || (state == 0) || !state.isValid()) {
+//		result = powerMonitor.setToInvalid();
+//	} else {
+//		float lowLimit = 0.0;
+//		float highLimit = RESIDUAL_POWER;
+//		calculatePowerLimits(&lowLimit, &highLimit);
+//		result = powerMonitor.checkPower(power, lowLimit, highLimit);
+//		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
+//			reportEvents(POWER_BELOW_LOW_LIMIT);
+//		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
+//			reportEvents(POWER_ABOVE_HIGH_LIMIT);
+//		}
+//	}
 	set.commit();
 	return result;
 }
@@ -136,7 +135,7 @@ void Fuse::calculateFusePower() {
 		return;
 	}
 	//Calculate fuse power.
-	power = current * voltage;
+	//power = current * voltage;
 	power.setValid(PoolVariableIF::VALID);
 }
 
@@ -189,20 +188,20 @@ void Fuse::checkFuseState() {
 		oldFuseState = 0;
 		return;
 	}
-	if (state == 0) {
-		if (oldFuseState != 0) {
-			reportEvents(FUSE_WENT_OFF);
-		}
-	}
-	oldFuseState = state;
+//	if (state == 0) {
+//		if (oldFuseState != 0) {
+//			reportEvents(FUSE_WENT_OFF);
+//		}
+//	}
+//	oldFuseState = state;
 }
 
 float Fuse::getPower() {
-	if (power.isValid()) {
-		return power;
-	} else {
-		return 0.0;
-	}
+//	if (power.isValid()) {
+//		return power;
+//	} else {
+//		return 0.0;
+//	}
 }
 
 void Fuse::setDataPoolEntriesInvalid() {
diff --git a/power/Fuse.h b/power/Fuse.h
index 13a0eb7c3..5e54d2940 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -13,6 +13,7 @@
 #include "../parameters/ParameterHelper.h"
 #include <list>
 
+#include "../datapoollocal/StaticLocalDataSet.h"
 namespace Factory {
 void setStaticFrameworkObjectIds();
 }
@@ -27,10 +28,10 @@ private:
 	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
 public:
 	struct VariableIds {
-		uint32_t pidVoltage;
-		uint32_t pidCurrent;
-		uint32_t pidState;
-		uint32_t poolIdPower;
+		gp_id_t pidVoltage;
+		gp_id_t pidCurrent;
+		gp_id_t pidState;
+		gp_id_t poolIdPower;
 	};
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
@@ -40,8 +41,8 @@ public:
 	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
 
 	typedef std::list<PowerComponentIF*> DeviceList;
-	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
-			float maxCurrent, uint16_t confirmationCount = 2);
+	Fuse(object_id_t fuseObjectId, uint8_t fuseId, sid_t variableSet,
+			VariableIds ids, float maxCurrent, uint16_t confirmationCount = 2);
 	virtual ~Fuse();
 	void addDevice(PowerComponentIF *set);
 	float getPower();
@@ -71,12 +72,12 @@ public:
 private:
 	uint8_t oldFuseState;
 	uint8_t fuseId;
-	PowerSwitchIF *powerIF; //could be static in our case.
+	PowerSwitchIF *powerIF = nullptr; //could be static in our case.
 	AbsLimitMonitor<float> currentLimit;
 	class PowerMonitor: public MonitorReporter<float> {
 	public:
 		template<typename ... Args>
-		PowerMonitor(Args ... args) :
+		PowerMonitor(Args ... args):
 				MonitorReporter<float>(std::forward<Args>(args)...) {
 		}
 		ReturnValue_t checkPower(float sample, float lowerLimit,
@@ -86,11 +87,16 @@ private:
 
 	};
 	PowerMonitor powerMonitor;
-	GlobDataSet set;
-	PIDReader<float> voltage;
-	PIDReader<float> current;
-	PIDReader<uint8_t> state;
-	gp_float_t power;
+	StaticLocalDataSet<3> set;
+	//LocalPoolDataSetBase* set = nullptr;
+	//PIDReader<float> voltage;
+	//PIDReader<float> current;
+	//PIDReader<uint8_t> state;
+	lp_var_t<float> voltage;
+	lp_var_t<float> current;
+	lp_var_t<uint8_t> state;
+
+	lp_var_t<float> power;
 	MessageQueueIF* commandQueue = nullptr;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 739d02f26..8fe3cf3a8 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -2,15 +2,17 @@
 
 #include "../ipc/QueueFactory.h"
 
-PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
+PowerSensor::PowerSensor(object_id_t objectId, sid_t setId,  VariableIds ids,
 		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
-		SystemObject(setId), parameterHelper(this), healthHelper(this, setId),
-		set(), current(ids.pidCurrent, &set), voltage(ids.pidVoltage, &set),
-		power(ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE),
-		currentLimit(setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
+		SystemObject(objectId), parameterHelper(this),
+		healthHelper(this, objectId),
+		powerSensorSet(setId), current(ids.pidCurrent, &powerSensorSet),
+		voltage(ids.pidVoltage, &powerSensorSet),
+		power(ids.poolIdPower, &powerSensorSet, PoolVariableIF::VAR_WRITE),
+		currentLimit(objectId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
 				limits.currentMin, limits.currentMax, events.currentLow,
 				events.currentHigh),
-		voltageLimit(setId, MODULE_ID_VOLTAGE,
+		voltageLimit(objectId, MODULE_ID_VOLTAGE,
 				ids.pidVoltage, confirmationCount, limits.voltageMin,
 				limits.voltageMax, events.voltageLow, events.voltageHigh) {
 		commandQueue = QueueFactory::instance()->createMessageQueue();
@@ -21,27 +23,27 @@ PowerSensor::~PowerSensor() {
 }
 
 ReturnValue_t PowerSensor::calculatePower() {
-	set.read();
+	powerSensorSet.read();
 	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
 	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
-	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
-			&& current.isValid()) {
-		result1 = voltageLimit.doCheck(voltage);
-		result2 = currentLimit.doCheck(current);
-	} else {
-		voltageLimit.setToInvalid();
-		currentLimit.setToInvalid();
-		result1 = OBJECT_NOT_HEALTHY;
-	}
-	if (result1 != HasReturnvaluesIF::RETURN_OK
-			|| result2 != HasReturnvaluesIF::RETURN_OK) {
-		result1 = MonitoringIF::INVALID;
-		power.setValid(PoolVariableIF::INVALID);
-	} else {
-		power.setValid(PoolVariableIF::VALID);
-		power = current * voltage;
-	}
-	set.commit();
+//	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
+//			&& current.isValid()) {
+//		result1 = voltageLimit.doCheck(voltage);
+//		result2 = currentLimit.doCheck(current);
+//	} else {
+//		voltageLimit.setToInvalid();
+//		currentLimit.setToInvalid();
+//		result1 = OBJECT_NOT_HEALTHY;
+//	}
+//	if (result1 != HasReturnvaluesIF::RETURN_OK
+//			|| result2 != HasReturnvaluesIF::RETURN_OK) {
+//		result1 = MonitoringIF::INVALID;
+//		power.setValid(PoolVariableIF::INVALID);
+//	} else {
+//		power.setValid(PoolVariableIF::VALID);
+//		power = current * voltage;
+//	}
+//	powerSensorSet.commit();
 	return result1;
 }
 
@@ -94,8 +96,8 @@ void PowerSensor::checkCommandQueue() {
 }
 
 void PowerSensor::setDataPoolEntriesInvalid() {
-	set.read();
-	set.commit(PoolVariableIF::INVALID);
+	powerSensorSet.read();
+	powerSensorSet.commit(PoolVariableIF::INVALID);
 }
 
 float PowerSensor::getPower() {
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index 20ebff397..bb409f3e0 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -4,6 +4,7 @@
 #include "../datapoolglob/GlobalDataSet.h"
 #include "../datapoolglob/GlobalPoolVariable.h"
 #include "../datapoolglob/PIDReader.h"
+#include "../datapoollocal/StaticLocalDataSet.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../monitoring/LimitMonitor.h"
 #include "../parameters/ParameterHelper.h"
@@ -12,15 +13,18 @@
 
 class PowerController;
 
+/**
+ * @brief	Does magic.
+ */
 class PowerSensor: public SystemObject,
 		public ReceivesParameterMessagesIF,
 		public HasHealthIF {
 	friend class PowerController;
 public:
 	struct VariableIds {
-		uint32_t pidCurrent;
-		uint32_t pidVoltage;
-		uint32_t poolIdPower;
+		gp_id_t pidCurrent;
+		gp_id_t pidVoltage;
+		gp_id_t poolIdPower;
 	};
 	struct DefaultLimits {
 		float currentMin;
@@ -34,8 +38,9 @@ public:
 		Event voltageLow;
 		Event voltageHigh;
 	};
-	PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
-			SensorEvents events, uint16_t confirmationCount = 0);
+	PowerSensor(object_id_t objectId, sid_t sid, VariableIds setIds,
+			DefaultLimits limits, SensorEvents events,
+			uint16_t confirmationCount = 0);
 	virtual ~PowerSensor();
 	ReturnValue_t calculatePower();
 	ReturnValue_t performOperation(uint8_t opCode);
@@ -53,12 +58,16 @@ private:
 	MessageQueueIF* commandQueue = nullptr;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
-	GlobDataSet set;
+	//GlobDataSet set;
+	StaticLocalDataSet<3> powerSensorSet;
 	//Variables in
-	PIDReader<float> current;
-	PIDReader<float> voltage;
+	lp_var_t<float> current;
+	lp_var_t<float> voltage;
+	//PIDReader<float> current;
+	//PIDReader<float> voltage;
 	//Variables out
-	gp_float_t power;
+	lp_var_t<float> power;
+	//gp_float_t power;
 
 	static const uint8_t MODULE_ID_CURRENT = 1;
 	static const uint8_t MODULE_ID_VOLTAGE = 2;
diff --git a/thermal/ThermalMonitorReporter.cpp b/thermal/ThermalMonitorReporter.cpp
index 766ea1cb6..cefc61107 100644
--- a/thermal/ThermalMonitorReporter.cpp
+++ b/thermal/ThermalMonitorReporter.cpp
@@ -38,7 +38,8 @@ bool ThermalMonitorReporter::isAboveHighLimit() {
 	}
 }
 
-ReturnValue_t ThermalMonitorReporter::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
+ReturnValue_t ThermalMonitorReporter::translateState(
+		ThermalComponentIF::State state, float sample, float lowerLimit,
 		float upperLimit, bool componentIsOperational) {
 	if (ThermalComponentIF::isIgnoredState(state)) {
 		setToUnchecked();
@@ -46,10 +47,12 @@ ReturnValue_t ThermalMonitorReporter::translateState(ThermalComponentIF::State s
 	}
 	switch (state) {
 	case ThermalComponentIF::OUT_OF_RANGE_LOW:
-		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample, lowerLimit);
+		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
+				lowerLimit);
 	case ThermalComponentIF::NON_OPERATIONAL_LOW:
 		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT, sample, lowerLimit);
+			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT,
+					sample, lowerLimit);
 		} else {
 			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
 		}
@@ -57,12 +60,14 @@ ReturnValue_t ThermalMonitorReporter::translateState(ThermalComponentIF::State s
 		return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
 	case ThermalComponentIF::NON_OPERATIONAL_HIGH:
 		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT, sample, upperLimit);
+			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT,
+					sample, upperLimit);
 		} else {
 			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
 		}
 	case ThermalComponentIF::OUT_OF_RANGE_HIGH:
-		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample, upperLimit);
+		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
+				upperLimit);
 	default:
 		//Never reached, all states covered.
 		return HasReturnvaluesIF::RETURN_FAILED;

From 4bb9dd816ec910870cd8183951efbdae9cb74d0d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 16:06:59 +0100
Subject: [PATCH 1027/1774] compiling again

---
 datapoollocal/LocalPoolObjectBase.cpp |   4 +
 datapoollocal/LocalPoolObjectBase.h   |   1 +
 datapoollocal/LocalPoolVariable.h     |  18 +++-
 datapoollocal/LocalPoolVariable.tpp   |  49 ++++++++-
 monitoring/AbsLimitMonitor.h          |   4 +-
 monitoring/LimitMonitor.h             |   4 +-
 monitoring/MonitorReporter.h          |   8 +-
 power/Fuse.cpp                        |  50 ++++-----
 power/PowerSensor.cpp                 |  36 +++----
 thermal/ThermalComponentCore.cpp      | 146 +++++++++++++-------------
 thermal/ThermalComponentCore.h        |   6 +-
 thermal/tcsDefinitions.h              |   2 +-
 12 files changed, 196 insertions(+), 132 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index c25df25a0..b4d0e3062 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -67,3 +67,7 @@ void LocalPoolObjectBase::setChanged(bool changed) {
 bool LocalPoolObjectBase::hasChanged() const {
     return changed;
 }
+
+void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
+	this->readWriteMode = newReadWriteMode;
+}
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 8d1ab45e4..7165fc242 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -18,6 +18,7 @@ public:
             DataSetIF* dataSet = nullptr,
             pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
+    void setReadWriteMode(pool_rwm_t newReadWriteMode);
     pool_rwm_t getReadWriteMode() const;
 
     bool isValid() const override;
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 173c2035f..bb36089dc 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -118,8 +118,21 @@ public:
 	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
 
 
-	LocalPoolVar<T> &operator=(T newValue);
-	LocalPoolVar<T> &operator=(LocalPoolVar<T> newPoolVariable);
+	LocalPoolVar<T> &operator=(const T& newValue);
+	LocalPoolVar<T> &operator=(const LocalPoolVar<T>& newPoolVariable);
+
+	bool operator==(const LocalPoolVar<T>& other) const;
+	bool operator==(const T& other) const;
+
+	bool operator!=(const LocalPoolVar<T>& other) const;
+	bool operator!=(const T& other) const;
+
+	bool operator<(const LocalPoolVar<T>& other) const;
+	bool operator<(const T& other) const;
+
+	bool operator>(const LocalPoolVar<T>& other) const;
+	bool operator>(const T& other) const;
+
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
@@ -165,5 +178,4 @@ using lp_int64_t = LocalPoolVar<int64_t>;
 using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
-
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 8aa164d15..a63e550d2 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -81,14 +81,14 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 }
 
 template<typename T>
-inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(T newValue) {
+inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(const T& newValue) {
     value = newValue;
     return *this;
 }
 
 template<typename T>
 inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
-		LocalPoolVar<T> newPoolVariable) {
+		const LocalPoolVar<T>& newPoolVariable) {
 	value = newPoolVariable.value;
 	return *this;
 }
@@ -119,4 +119,47 @@ inline std::ostream& operator<< (std::ostream &out,
     return out;
 }
 
-#endif
+template<typename T>
+inline bool LocalPoolVar<T>::operator ==(const LocalPoolVar<T> &other) const {
+	return this->value == other.value;
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator ==(const T &other) const {
+	return this->value == other;
+}
+
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator !=(const LocalPoolVar<T> &other) const {
+	return not (*this == other);
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator !=(const T &other) const {
+	return not (*this == other);
+}
+
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator <(const LocalPoolVar<T> &other) const {
+	return this->value < other.value;
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator <(const T &other) const {
+	return this->value < other;
+}
+
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator >(const LocalPoolVar<T> &other) const {
+	return not (*this < other);
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator >(const T &other) const {
+	return not (*this < other);
+}
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */
diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index 1206dbf60..5feb369c0 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -66,8 +66,8 @@ protected:
 		switch (state) {
 		case MonitoringIF::OUT_OF_RANGE:
 			EventManagerIF::triggerEvent(this->reportingId,
-			        violationEvent, this->parameterId.objectId,
-					this->parameterId.localPoolId);
+			        violationEvent, this->globalPoolId.objectId,
+					this->globalPoolId.localPoolId);
 			break;
 		default:
 			break;
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index 27e35aa77..c4448ceda 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -80,11 +80,11 @@ protected:
 		switch (state) {
 		case MonitoringIF::BELOW_LOW_LIMIT:
 			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent,
-			        this->parameterId.objectId, this->parameterId.localPoolId);
+			        this->globalPoolId.objectId, this->globalPoolId.localPoolId);
 			break;
 		case MonitoringIF::ABOVE_HIGH_LIMIT:
 			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent,
-			        this->parameterId.objectId, this->parameterId.localPoolId);
+			        this->globalPoolId.objectId, this->globalPoolId.localPoolId);
 			break;
 		default:
 			break;
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index d6d8c8ed7..9028e7e4a 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -20,7 +20,7 @@ public:
 
 	MonitorReporter(object_id_t reportingId, uint8_t monitorId,
 	        gp_id_t globalPoolId, uint16_t confirmationLimit) :
-			monitorId(monitorId), parameterId(parameterId),
+			monitorId(monitorId), globalPoolId(globalPoolId),
 			reportingId(reportingId), oldState(MonitoringIF::UNCHECKED),
 			reportingEnabled(ENABLED), eventEnabled(ENABLED), currentCounter(0),
 			confirmationLimit(confirmationLimit) {
@@ -96,7 +96,7 @@ public:
 
 protected:
 	const uint8_t monitorId;
-	const gp_id_t parameterId;
+	const gp_id_t globalPoolId;
 	object_id_t reportingId;
 	ReturnValue_t oldState;
 
@@ -167,13 +167,13 @@ protected:
 	 */
 	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
 	        ReturnValue_t state) {
-		MonitoringReportContent<T> report(parameterId,
+		MonitoringReportContent<T> report(globalPoolId,
 				parameterValue, crossedLimit, oldState, state);
 		LimitViolationReporter::sendLimitViolationReport(&report);
 	}
 	ReturnValue_t setToState(ReturnValue_t state) {
 		if (oldState != state && reportingEnabled) {
-			MonitoringReportContent<T> report(parameterId, 0, 0, oldState,
+			MonitoringReportContent<T> report(globalPoolId, 0, 0, oldState,
 					state);
 			LimitViolationReporter::sendLimitViolationReport(&report);
 			oldState = state;
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index ff9c7b3c6..1c30d83f3 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -72,19 +72,19 @@ ReturnValue_t Fuse::check() {
 	checkFuseState();
 	calculateFusePower();
 	//Check if power is valid and if fuse state is off or invalid.
-//	if (!power.isValid() || (state == 0) || !state.isValid()) {
-//		result = powerMonitor.setToInvalid();
-//	} else {
-//		float lowLimit = 0.0;
-//		float highLimit = RESIDUAL_POWER;
-//		calculatePowerLimits(&lowLimit, &highLimit);
-//		result = powerMonitor.checkPower(power, lowLimit, highLimit);
-//		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
-//			reportEvents(POWER_BELOW_LOW_LIMIT);
-//		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
-//			reportEvents(POWER_ABOVE_HIGH_LIMIT);
-//		}
-//	}
+	if (!power.isValid() || (state == 0) || !state.isValid()) {
+		result = powerMonitor.setToInvalid();
+	} else {
+		float lowLimit = 0.0;
+		float highLimit = RESIDUAL_POWER;
+		calculatePowerLimits(&lowLimit, &highLimit);
+		result = powerMonitor.checkPower(power.value, lowLimit, highLimit);
+		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
+			reportEvents(POWER_BELOW_LOW_LIMIT);
+		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
+			reportEvents(POWER_ABOVE_HIGH_LIMIT);
+		}
+	}
 	set.commit();
 	return result;
 }
@@ -135,7 +135,7 @@ void Fuse::calculateFusePower() {
 		return;
 	}
 	//Calculate fuse power.
-	//power = current * voltage;
+	power.value = current.value * voltage.value;
 	power.setValid(PoolVariableIF::VALID);
 }
 
@@ -188,20 +188,20 @@ void Fuse::checkFuseState() {
 		oldFuseState = 0;
 		return;
 	}
-//	if (state == 0) {
-//		if (oldFuseState != 0) {
-//			reportEvents(FUSE_WENT_OFF);
-//		}
-//	}
-//	oldFuseState = state;
+	if (state == 0) {
+		if (oldFuseState != 0) {
+			reportEvents(FUSE_WENT_OFF);
+		}
+	}
+	oldFuseState = state.value;
 }
 
 float Fuse::getPower() {
-//	if (power.isValid()) {
-//		return power;
-//	} else {
-//		return 0.0;
-//	}
+	if (power.isValid()) {
+		return power.value;
+	} else {
+		return 0.0;
+	}
 }
 
 void Fuse::setDataPoolEntriesInvalid() {
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 8fe3cf3a8..1ef041e30 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -26,24 +26,24 @@ ReturnValue_t PowerSensor::calculatePower() {
 	powerSensorSet.read();
 	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
 	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
-//	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
-//			&& current.isValid()) {
-//		result1 = voltageLimit.doCheck(voltage);
-//		result2 = currentLimit.doCheck(current);
-//	} else {
-//		voltageLimit.setToInvalid();
-//		currentLimit.setToInvalid();
-//		result1 = OBJECT_NOT_HEALTHY;
-//	}
-//	if (result1 != HasReturnvaluesIF::RETURN_OK
-//			|| result2 != HasReturnvaluesIF::RETURN_OK) {
-//		result1 = MonitoringIF::INVALID;
-//		power.setValid(PoolVariableIF::INVALID);
-//	} else {
-//		power.setValid(PoolVariableIF::VALID);
-//		power = current * voltage;
-//	}
-//	powerSensorSet.commit();
+	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
+			&& current.isValid()) {
+		result1 = voltageLimit.doCheck(voltage.value);
+		result2 = currentLimit.doCheck(current.value);
+	} else {
+		voltageLimit.setToInvalid();
+		currentLimit.setToInvalid();
+		result1 = OBJECT_NOT_HEALTHY;
+	}
+	if (result1 != HasReturnvaluesIF::RETURN_OK
+			|| result2 != HasReturnvaluesIF::RETURN_OK) {
+		result1 = MonitoringIF::INVALID;
+		power.setValid(PoolVariableIF::INVALID);
+	} else {
+		power.setValid(PoolVariableIF::VALID);
+		power.value = current.value * voltage.value;
+	}
+	powerSensorSet.commit();
 	return result1;
 }
 
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index 53eeb58fd..a64491c01 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -9,16 +9,18 @@ ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
 		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ),
 		currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
 		heaterRequest(requestPoolId, dataSet, PoolVariableIF::VAR_WRITE),
-		parameters(parameters), domainId(domainId) {
-		//temperatureMonitor(reportingObjectId, domainId + 1,
-		//        GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
-		//		COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
+		parameters(parameters), domainId(domainId),
+		temperatureMonitor(reportingObjectId, domainId + 1,temperaturePoolId,
+				COMPONENT_TEMP_CONFIRMATION) {
 	//Set thermal state once, then leave to operator.
-	//GlobDataSet mySet;
-	//gp_uint8_t writableTargetState(targetStatePoolId, &mySet,
-	//		PoolVariableIF::VAR_WRITE);
-	//writableTargetState = initialTargetState;
-	//mySet.commit(PoolVariableIF::VALID);
+	targetState.setReadWriteMode(PoolVariableIF::VAR_WRITE);
+	ReturnValue_t result = targetState.read();
+	if(result == HasReturnvaluesIF::RETURN_OK) {
+		targetState = initialTargetState;
+		targetState.setValid(true);
+		targetState.commit();
+	}
+	targetState.setReadWriteMode(PoolVariableIF::VAR_READ);
 }
 
 void ThermalComponentCore::addSensor(AbstractTemperatureSensor* sensor) {
@@ -57,19 +59,21 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 	HeaterRequest request = HEATER_DONT_CARE;
 	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
 	temperature = getTemperature();
-	//updateMinMaxTemp();
-	//if ((temperature != INVALID_TEMPERATURE)) {
-		//temperature.setValid(PoolVariableIF::VALID);
-		//State state = getState(temperature, getParameters(), targetState);
-		//currentState = state;
-		//checkLimits(state);
-		//request = getHeaterRequest(targetState, temperature, getParameters());
-	//} else {
-	//	temperatureMonitor.setToInvalid();
-	//	temperature.setValid(PoolVariableIF::INVALID);
-	//	currentState = UNKNOWN;
-	//	request = HEATER_DONT_CARE;
-	//}
+	updateMinMaxTemp();
+	if ((temperature != INVALID_TEMPERATURE)) {
+		temperature.setValid(PoolVariableIF::VALID);
+		State state = getState(temperature.value, getParameters(),
+				targetState.value);
+		currentState = state;
+		checkLimits(state);
+		request = getHeaterRequest(targetState.value, temperature.value,
+				getParameters());
+	} else {
+		temperatureMonitor.setToInvalid();
+		temperature.setValid(PoolVariableIF::INVALID);
+		currentState = UNKNOWN;
+		request = HEATER_DONT_CARE;
+	}
 	currentState.setValid(PoolVariableIF::VALID);
 	heaterRequest = request;
 	heaterRequest.setValid(PoolVariableIF::VALID);
@@ -77,11 +81,11 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 }
 
 void ThermalComponentCore::markStateIgnored() {
-	//currentState = getIgnoredState(currentState);
+	currentState = getIgnoredState(currentState.value);
 }
 
 object_id_t ThermalComponentCore::getObjectId() {
-	//return temperatureMonitor.getReporterId();
+	return temperatureMonitor.getReporterId();
 	return 0;
 }
 
@@ -120,7 +124,7 @@ void ThermalComponentCore::setOutputInvalid() {
 	currentState.setValid(PoolVariableIF::INVALID);
 	heaterRequest = HEATER_DONT_CARE;
 	heaterRequest.setValid(PoolVariableIF::INVALID);
-	//temperatureMonitor.setToUnchecked();
+	temperatureMonitor.setToUnchecked();
 }
 
 float ThermalComponentCore::getTemperature() {
@@ -170,8 +174,8 @@ ThermalComponentIF::State ThermalComponentCore::getState(float temperature,
 
 void ThermalComponentCore::checkLimits(ThermalComponentIF::State state) {
 	//Checks operational limits only.
-	//temperatureMonitor.translateState(state, temperature.value,
-	//		getParameters().lowerOpLimit, getParameters().upperOpLimit);
+	temperatureMonitor.translateState(state, temperature.value,
+			getParameters().lowerOpLimit, getParameters().upperOpLimit);
 
 }
 
@@ -221,17 +225,17 @@ ThermalComponentIF::State ThermalComponentCore::getIgnoredState(int8_t state) {
 	}
 }
 
-//void ThermalComponentCore::updateMinMaxTemp() {
-//	if (temperature == INVALID_TEMPERATURE) {
-//		return;
-//	}
-//	if (temperature < minTemp) {
-//		minTemp = temperature;
-//	}
-//	if (temperature > maxTemp) {
-//		maxTemp = temperature;
-//	}
-//}
+void ThermalComponentCore::updateMinMaxTemp() {
+	if (temperature == INVALID_TEMPERATURE) {
+		return;
+	}
+	if (temperature < minTemp) {
+		minTemp = temperature.value;
+	}
+	if (temperature > maxTemp) {
+		maxTemp = temperature.value;
+	}
+}
 
 uint8_t ThermalComponentCore::getDomainId() const {
 	return domainId;
@@ -244,38 +248,38 @@ ThermalComponentCore::Parameters ThermalComponentCore::getParameters() {
 ReturnValue_t ThermalComponentCore::getParameter(uint8_t domainId,
 		uint16_t parameterId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	//ReturnValue_t result = temperatureMonitor.getParameter(domainId,
-	//		parameterId, parameterWrapper, newValues, startAtIndex);
-//	if (result != INVALID_DOMAIN_ID) {
-//		return result;
-//	}
-//	if (domainId != this->domainId) {
-//		return INVALID_DOMAIN_ID;
-//	}
-//	switch (parameterId) {
-//	case 0:
-//		parameterWrapper->set(parameters.heaterOn);
-//		break;
-//	case 1:
-//		parameterWrapper->set(parameters.hysteresis);
-//		break;
-//	case 2:
-//		parameterWrapper->set(parameters.heaterSwitchoff);
-//		break;
-//	case 3:
-//		parameterWrapper->set(minTemp);
-//		break;
-//	case 4:
-//		parameterWrapper->set(maxTemp);
-//		break;
-//	case 10:
-//		parameterWrapper->set(parameters.lowerOpLimit);
-//		break;
-//	case 11:
-//		parameterWrapper->set(parameters.upperOpLimit);
-//		break;
-//	default:
-//		return INVALID_IDENTIFIER_ID;
-//	}
+	ReturnValue_t result = temperatureMonitor.getParameter(domainId,
+			parameterId, parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	if (domainId != this->domainId) {
+		return INVALID_DOMAIN_ID;
+	}
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set(parameters.heaterOn);
+		break;
+	case 1:
+		parameterWrapper->set(parameters.hysteresis);
+		break;
+	case 2:
+		parameterWrapper->set(parameters.heaterSwitchoff);
+		break;
+	case 3:
+		parameterWrapper->set(minTemp);
+		break;
+	case 4:
+		parameterWrapper->set(maxTemp);
+		break;
+	case 10:
+		parameterWrapper->set(parameters.lowerOpLimit);
+		break;
+	case 11:
+		parameterWrapper->set(parameters.upperOpLimit);
+		break;
+	default:
+		return INVALID_IDENTIFIER_ID;
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/thermal/ThermalComponentCore.h b/thermal/ThermalComponentCore.h
index 6ef59058a..19d723593 100644
--- a/thermal/ThermalComponentCore.h
+++ b/thermal/ThermalComponentCore.h
@@ -96,10 +96,10 @@ protected:
 
 	Parameters parameters;
 
-	//ThermalMonitorReporter temperatureMonitor;
-
 	const uint8_t domainId;
 
+	ThermalMonitorReporter temperatureMonitor;
+
 	virtual float getTemperature();
 	virtual State getState(float temperature, Parameters parameters,
 			int8_t targetState);
@@ -111,7 +111,7 @@ protected:
 
 	virtual State getIgnoredState(int8_t state);
 
-	//void updateMinMaxTemp();
+	void updateMinMaxTemp();
 
 	virtual Parameters getParameters();
 };
diff --git a/thermal/tcsDefinitions.h b/thermal/tcsDefinitions.h
index ad258ced7..37e5b849d 100644
--- a/thermal/tcsDefinitions.h
+++ b/thermal/tcsDefinitions.h
@@ -2,7 +2,7 @@
 #define TCSDEFINITIONS_H_
 
 
-static const uint32_t INVALID_TEMPERATURE = 999;
+static const float INVALID_TEMPERATURE = 999;
 
 
 #endif /* TCSDEFINITIONS_H_ */

From f581b37fcf51415fe9f24ff22bb61aaf367739f8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 16:25:09 +0100
Subject: [PATCH 1028/1774] thermal module replacements

---
 power/Fuse.h                     |  3 --
 power/PowerSensor.h              |  3 --
 thermal/ThermalComponent.cpp     | 33 +++++++------
 thermal/ThermalComponentCore.cpp | 39 +++++++--------
 thermal/ThermalComponentCore.h   |  2 -
 thermal/ThermalModule.cpp        | 84 +++++++++++++++++---------------
 thermal/ThermalModule.h          | 46 +++++++++--------
 7 files changed, 109 insertions(+), 101 deletions(-)

diff --git a/power/Fuse.h b/power/Fuse.h
index 5e54d2940..e9e9290b4 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -4,9 +4,6 @@
 #include "PowerComponentIF.h"
 #include "PowerSwitchIF.h"
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../datapoolglob/PIDReader.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../monitoring/AbsLimitMonitor.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index bb409f3e0..a0ccb1ca7 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -1,9 +1,6 @@
 #ifndef FSFW_POWER_POWERSENSOR_H_
 #define FSFW_POWER_POWERSENSOR_H_
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../datapoolglob/PIDReader.h"
 #include "../datapoollocal/StaticLocalDataSet.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../monitoring/LimitMonitor.h"
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 54bd67bdb..4805fc9df 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -22,22 +22,23 @@ ThermalComponent::~ThermalComponent() {
 }
 
 ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
-	GlobDataSet mySet;
-	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
-	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
-			&& (newState != STATE_REQUEST_IGNORE)) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	switch (newState) {
-	case STATE_REQUEST_NON_OPERATIONAL:
-		writableTargetState = newState;
-		mySet.commit(PoolVariableIF::VALID);
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return ThermalComponentCore::setTargetState(newState);
-	}
+//	GlobDataSet mySet;
+//	gp_int8_t writableTargetState(targetState.getDataPoolId(),
+//			&mySet, PoolVariableIF::VAR_READ_WRITE);
+//	mySet.read();
+//	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
+//			&& (newState != STATE_REQUEST_IGNORE)) {
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//	switch (newState) {
+//	case STATE_REQUEST_NON_OPERATIONAL:
+//		writableTargetState = newState;
+//		mySet.commit(PoolVariableIF::VALID);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	default:
+//		return ThermalComponentCore::setTargetState(newState);
+//	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index a64491c01..81d9326f7 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -96,25 +96,26 @@ float ThermalComponentCore::getLowerOpLimit() {
 
 
 ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
-	GlobDataSet mySet;
-	gp_uint8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
-	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
-			&& (newState != STATE_REQUEST_IGNORE)) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	switch (newState) {
-	case STATE_REQUEST_HEATING:
-	case STATE_REQUEST_IGNORE:
-	case STATE_REQUEST_OPERATIONAL:
-		writableTargetState = newState;
-		break;
-	case STATE_REQUEST_NON_OPERATIONAL:
-	default:
-		return INVALID_TARGET_STATE;
-	}
-	mySet.commit(PoolVariableIF::VALID);
+//	GlobDataSet mySet;
+//	gp_uint8_t writableTargetState(targetState.getDataPoolId(),
+//			&mySet, PoolVariableIF::VAR_READ_WRITE);
+//	mySet.read();
+//	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
+//			&& (newState != STATE_REQUEST_IGNORE)) {
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//	switch (newState) {
+//	case STATE_REQUEST_HEATING:
+//	case STATE_REQUEST_IGNORE:
+//	case STATE_REQUEST_OPERATIONAL:
+//		writableTargetState = newState;
+//		break;
+//	case STATE_REQUEST_NON_OPERATIONAL:
+//	default:
+//		return INVALID_TARGET_STATE;
+//	}
+//	mySet.commit(PoolVariableIF::VALID);
+//	return HasReturnvaluesIF::RETURN_OK;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/thermal/ThermalComponentCore.h b/thermal/ThermalComponentCore.h
index 19d723593..da9424e68 100644
--- a/thermal/ThermalComponentCore.h
+++ b/thermal/ThermalComponentCore.h
@@ -6,8 +6,6 @@
 #include "AbstractTemperatureSensor.h"
 #include "ThermalModule.h"
 
-//#include "../datapoolglob/GlobalDataSet.h"
-//#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../datapoollocal/LocalPoolVariable.h"
 
 /**
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index fbd6939e7..2bc1741f6 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -1,28 +1,31 @@
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringMessageContent.h"
 #include "ThermalModule.h"
-
 #include "AbstractTemperatureSensor.h"
 
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
-		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
-		GlobDataSet *dataSet, Parameters parameters,
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringMessageContent.h"
+
+
+ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
+		gp_id_t currentStatePoolId, gp_id_t targetStatePoolId,
+		LocalPoolDataSetBase *dataSet, Parameters parameters,
 		RedundantHeater::Parameters heaterParameters) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters(parameters), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
-				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
-				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
+		oldStrategy(ACTIVE_SINGLE), parameters(parameters),
+		moduleTemperature(moduleTemperaturePoolId, dataSet,
+				PoolVariableIF::VAR_WRITE),
+		currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
 	heater = new RedundantHeater(heaterParameters);
 }
 
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters( { 0, 0 }), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
-				NULL), currentState(PoolVariableIF::INVALID, dataSet,
-				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
-				dataSet, PoolVariableIF::VAR_READ) {
+ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
+		LocalPoolDataSetBase* dataSet) :
+		oldStrategy(ACTIVE_SINGLE), parameters( { 0, 0 }),
+		moduleTemperature(moduleTemperaturePoolId, dataSet,
+				PoolVariableIF::VAR_WRITE),
+		currentState(gp_id_t(), dataSet,
+				PoolVariableIF::VAR_WRITE),
+		targetState(gp_id_t(), dataSet,
+				PoolVariableIF::VAR_READ) {
 }
 
 ThermalModule::~ThermalModule() {
@@ -30,7 +33,7 @@ ThermalModule::~ThermalModule() {
 }
 
 void ThermalModule::performOperation(uint8_t opCode) {
-	if (heater != NULL) {
+	if (heater != nullptr) {
 		heater->performOperation(0);
 	}
 }
@@ -42,7 +45,7 @@ void ThermalModule::performMode(Strategy strategy) {
 	ThermalComponentIF::HeaterRequest componentHeaterRequest =
 			letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
 
-	if (heater == NULL) {
+	if (heater == nullptr) {
 		informComponentsAboutHeaterState(false, NONE);
 		return;
 	}
@@ -53,8 +56,8 @@ void ThermalModule::performMode(Strategy strategy) {
 		//Components overwrite the module request.
 		heating = ((componentHeaterRequest
 				== ThermalComponentIF::HEATER_REQUEST_ON)
-				|| (componentHeaterRequest
-						== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
+				or (componentHeaterRequest
+				== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
 	}
 
 	bool dual = (strategy == ACTIVE_DUAL);
@@ -76,7 +79,7 @@ void ThermalModule::performMode(Strategy strategy) {
 }
 
 float ThermalModule::getTemperature() {
-	return moduleTemperature;
+	return moduleTemperature.value;
 }
 
 void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
@@ -85,7 +88,8 @@ void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
 
 void ThermalModule::registerComponent(ThermalComponentIF* component,
 		ThermalComponentIF::Priority priority) {
-	components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
+	components.push_back(ComponentData( { component, priority,
+		ThermalComponentIF::HEATER_DONT_CARE }));
 }
 
 void ThermalModule::calculateTemperature() {
@@ -94,12 +98,13 @@ void ThermalModule::calculateTemperature() {
 	std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
 	for (; iter != sensors.end(); iter++) {
 		if ((*iter)->isValid()) {
-			moduleTemperature = moduleTemperature + (*iter)->getTemperature();
+			moduleTemperature = moduleTemperature.value +
+					(*iter)->getTemperature();
 			numberOfValidSensors++;
 		}
 	}
 	if (numberOfValidSensors != 0) {
-		moduleTemperature = moduleTemperature / numberOfValidSensors;
+		moduleTemperature = moduleTemperature.value / numberOfValidSensors;
 		moduleTemperature.setValid(PoolVariableIF::VALID);
 	} else {
 		moduleTemperature = INVALID_TEMPERATURE;
@@ -117,9 +122,10 @@ ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
 	return NULL;
 }
 
-ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
-		bool safeOnly) {
-	ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
+ThermalComponentIF::HeaterRequest
+ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly) {
+	ThermalComponentIF::HeaterRequest
+	heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
 
 	survivalTargetTemp = -999;
 	targetTemp = -999;
@@ -224,7 +230,7 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 		limit = survivalTargetTemp;
 	}
 
-	if (moduleTemperature >= limit) {
+	if (moduleTemperature.value >= limit) {
 		currentState = OPERATIONAL;
 	} else {
 		currentState = NON_OPERATIONAL;
@@ -250,15 +256,15 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 }
 
 void ThermalModule::setHeating(bool on) {
-	GlobDataSet mySet;
-	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_WRITE);
-	if (on) {
-		writableTargetState = STATE_REQUEST_HEATING;
-	} else {
-		writableTargetState = STATE_REQUEST_PASSIVE;
-	}
-	mySet.commit(PoolVariableIF::VALID);
+//	GlobDataSet mySet;
+//	gp_int8_t writableTargetState(targetState.getDataPoolId(),
+//			&mySet, PoolVariableIF::VAR_WRITE);
+//	if (on) {
+//		writableTargetState = STATE_REQUEST_HEATING;
+//	} else {
+//		writableTargetState = STATE_REQUEST_PASSIVE;
+//	}
+//	mySet.commit(PoolVariableIF::VALID);
 }
 
 void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index 41be6baae..d1e4fccbf 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -1,14 +1,20 @@
-#ifndef THERMALMODULE_H_
-#define THERMALMODULE_H_
+#ifndef FSFW_THERMAL_THERMALMODULE_H_
+#define FSFW_THERMAL_THERMALMODULE_H_
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../devicehandlers/HealthDevice.h"
-#include "../events/EventReportingProxyIF.h"
 #include "ThermalModuleIF.h"
-#include <list>
 #include "tcsDefinitions.h"
 #include "RedundantHeater.h"
+
+//#include "../datapoolglob/GlobalDataSet.h"
+//#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoollocal/LocalPoolDataSetBase.h"
+#include "../datapoollocal/LocalPoolVariable.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../events/EventReportingProxyIF.h"
+
+#include <list>
+
+
 class PowerSwitchIF;
 
 /**
@@ -22,11 +28,12 @@ public:
 		float hysteresis;
 	};
 
-	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
-			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
-			RedundantHeater::Parameters heaterParameters);
+	ThermalModule(gp_id_t moduleTemperaturePoolId, gp_id_t currentStatePoolId,
+			gp_id_t targetStatePoolId, LocalPoolDataSetBase *dataSet,
+			Parameters parameters, RedundantHeater::Parameters heaterParameters);
 
-	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
+	ThermalModule(gp_id_t moduleTemperaturePoolId,
+			LocalPoolDataSetBase *dataSet);
 
 	virtual ~ThermalModule();
 
@@ -62,20 +69,21 @@ protected:
 
 	Strategy oldStrategy;
 
-	float survivalTargetTemp;
+	float survivalTargetTemp = 0.0;
 
-	float targetTemp;
+	float targetTemp = 0.0;
 
-	bool heating;
+	bool heating = false;
 
 	Parameters parameters;
 
-	gp_float_t moduleTemperature;
+	lp_var_t<float> moduleTemperature;
+	//gp_float_t moduleTemperature;
 
-	RedundantHeater *heater;
+	RedundantHeater *heater = nullptr;
 
-	gp_int8_t currentState;
-	gp_int8_t targetState;
+	lp_var_t<int8_t> currentState;
+	lp_var_t<int8_t> targetState;
 
 	std::list<AbstractTemperatureSensor *> sensors;
 	std::list<ComponentData> components;
@@ -92,4 +100,4 @@ protected:
 	void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
 };
 
-#endif /* THERMALMODULE_H_ */
+#endif /* FSFW_THERMAL_THERMALMODULE_H_ */

From f108ae883c1a19eaa74f1c67cd4278815c98538a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 16:28:16 +0100
Subject: [PATCH 1029/1774] local pool replacement

---
 thermal/ThermalComponentCore.cpp | 39 ++++++++++++++++----------------
 1 file changed, 19 insertions(+), 20 deletions(-)

diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index 81d9326f7..29f9e25d9 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -96,26 +96,25 @@ float ThermalComponentCore::getLowerOpLimit() {
 
 
 ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
-//	GlobDataSet mySet;
-//	gp_uint8_t writableTargetState(targetState.getDataPoolId(),
-//			&mySet, PoolVariableIF::VAR_READ_WRITE);
-//	mySet.read();
-//	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
-//			&& (newState != STATE_REQUEST_IGNORE)) {
-//		return HasReturnvaluesIF::RETURN_FAILED;
-//	}
-//	switch (newState) {
-//	case STATE_REQUEST_HEATING:
-//	case STATE_REQUEST_IGNORE:
-//	case STATE_REQUEST_OPERATIONAL:
-//		writableTargetState = newState;
-//		break;
-//	case STATE_REQUEST_NON_OPERATIONAL:
-//	default:
-//		return INVALID_TARGET_STATE;
-//	}
-//	mySet.commit(PoolVariableIF::VALID);
-//	return HasReturnvaluesIF::RETURN_OK;
+	targetState.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
+	targetState.read();
+	if((targetState == STATE_REQUEST_OPERATIONAL) and
+			(newState != STATE_REQUEST_IGNORE)) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	switch (newState) {
+	case STATE_REQUEST_HEATING:
+	case STATE_REQUEST_IGNORE:
+	case STATE_REQUEST_OPERATIONAL:
+		targetState = newState;
+		break;
+	case STATE_REQUEST_NON_OPERATIONAL:
+	default:
+		return INVALID_TARGET_STATE;
+	}
+	targetState.setValid(true);
+	targetState.commit();
 	return HasReturnvaluesIF::RETURN_OK;
 }
 

From d1beb96c6030c82bf20d65eea0196cb4d904c8a2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 16:30:20 +0100
Subject: [PATCH 1030/1774] some more replacements

---
 thermal/ThermalComponent.cpp | 46 ++++++++++++++++++------------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 4805fc9df..084201dd4 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -22,22 +22,21 @@ ThermalComponent::~ThermalComponent() {
 }
 
 ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
-//	GlobDataSet mySet;
-//	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-//			&mySet, PoolVariableIF::VAR_READ_WRITE);
-//	mySet.read();
-//	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
-//			&& (newState != STATE_REQUEST_IGNORE)) {
-//		return HasReturnvaluesIF::RETURN_FAILED;
-//	}
-//	switch (newState) {
-//	case STATE_REQUEST_NON_OPERATIONAL:
-//		writableTargetState = newState;
-//		mySet.commit(PoolVariableIF::VALID);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	default:
-//		return ThermalComponentCore::setTargetState(newState);
-//	}
+	targetState.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
+	targetState.read();
+	if ((targetState == STATE_REQUEST_OPERATIONAL)
+			and (newState != STATE_REQUEST_IGNORE)) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	switch (newState) {
+	case STATE_REQUEST_NON_OPERATIONAL:
+		targetState = newState;
+		targetState.setValid(true);
+		targetState.commit(PoolVariableIF::VALID);
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return ThermalComponentCore::setTargetState(newState);
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -79,13 +78,14 @@ ThermalComponentIF::State ThermalComponent::getState(float temperature,
 }
 
 void ThermalComponent::checkLimits(ThermalComponentIF::State state) {
-	//if (targetState == STATE_REQUEST_OPERATIONAL || targetState == STATE_REQUEST_IGNORE) {
-	//	ThermalComponentCore::checkLimits(state);
-	//	return;
-	//}
-	//If component is not operational, it checks the NOP limits.
-	//temperatureMonitor.translateState(state, temperature.value,
-	//		nopParameters.lowerNopLimit, nopParameters.upperNopLimit, false);
+	if ((targetState == STATE_REQUEST_OPERATIONAL) or
+			(targetState == STATE_REQUEST_IGNORE)) {
+		ThermalComponentCore::checkLimits(state);
+		return;
+	}
+	// If component is not operational, it checks the NOP limits.
+	temperatureMonitor.translateState(state, temperature.value,
+			nopParameters.lowerNopLimit, nopParameters.upperNopLimit, false);
 }
 
 ThermalComponentIF::HeaterRequest ThermalComponent::getHeaterRequest(

From ef2e07b3891a3c2a2429d973d5db68208db7e526 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 17:03:14 +0100
Subject: [PATCH 1031/1774] added explicit type conversion operator

---
 datapoollocal/LocalPoolVariable.h   |  4 ++++
 datapoollocal/LocalPoolVariable.tpp | 32 ++++++++++++++++-------------
 thermal/ThermalComponentCore.cpp    |  6 +++---
 3 files changed, 25 insertions(+), 17 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index bb36089dc..c18d54433 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -121,6 +121,10 @@ public:
 	LocalPoolVar<T> &operator=(const T& newValue);
 	LocalPoolVar<T> &operator=(const LocalPoolVar<T>& newPoolVariable);
 
+	//! Explicit type conversion operator. Allows casting the class to
+	//! its template type to perform operations on value.
+	explicit operator T() const;
+
 	bool operator==(const LocalPoolVar<T>& other) const;
 	bool operator==(const T& other) const;
 
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index a63e550d2..b9f7b906e 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -80,20 +80,6 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 	return RETURN_OK;
 }
 
-template<typename T>
-inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(const T& newValue) {
-    value = newValue;
-    return *this;
-}
-
-template<typename T>
-inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
-		const LocalPoolVar<T>& newPoolVariable) {
-	value = newPoolVariable.value;
-	return *this;
-}
-
-
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
@@ -119,6 +105,24 @@ inline std::ostream& operator<< (std::ostream &out,
     return out;
 }
 
+template<typename T>
+inline LocalPoolVar<T>::operator T() const {
+	return value;
+}
+
+template<typename T>
+inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(const T& newValue) {
+    value = newValue;
+    return *this;
+}
+
+template<typename T>
+inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
+		const LocalPoolVar<T>& newPoolVariable) {
+	value = newPoolVariable.value;
+	return *this;
+}
+
 template<typename T>
 inline bool LocalPoolVar<T>::operator ==(const LocalPoolVar<T> &other) const {
 	return this->value == other.value;
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index 29f9e25d9..7b594d0c9 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -60,7 +60,7 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
 	temperature = getTemperature();
 	updateMinMaxTemp();
-	if ((temperature != INVALID_TEMPERATURE)) {
+	if (temperature != INVALID_TEMPERATURE) {
 		temperature.setValid(PoolVariableIF::VALID);
 		State state = getState(temperature.value, getParameters(),
 				targetState.value);
@@ -230,10 +230,10 @@ void ThermalComponentCore::updateMinMaxTemp() {
 		return;
 	}
 	if (temperature < minTemp) {
-		minTemp = temperature.value;
+		minTemp = static_cast<float>(temperature);
 	}
 	if (temperature > maxTemp) {
-		maxTemp = temperature.value;
+		maxTemp = static_cast<float>(temperature);
 	}
 }
 

From f357de21c9b37a5ca384590be0d511c0c503aa16 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 13:23:51 +0100
Subject: [PATCH 1032/1774] updated testcfg

---
 unittest/testcfg/objects/translateObjects.cpp | 242 ------------------
 unittest/testcfg/objects/translateObjects.h   |  16 --
 2 files changed, 258 deletions(-)
 delete mode 100644 unittest/testcfg/objects/translateObjects.cpp
 delete mode 100644 unittest/testcfg/objects/translateObjects.h

diff --git a/unittest/testcfg/objects/translateObjects.cpp b/unittest/testcfg/objects/translateObjects.cpp
deleted file mode 100644
index abcb1b402..000000000
--- a/unittest/testcfg/objects/translateObjects.cpp
+++ /dev/null
@@ -1,242 +0,0 @@
-/* Auto-generated event translation file. Contains 77 translations. */
-#include <fsfw/unittest/config/objects/translateObjects.h>
-
-const char *AT91_UART2_TEST_TASK_STRING = "AT91_UART2_TEST_TASK";
-const char *ARDUINO_0_STRING = "ARDUINO_0";
-const char *ARDUINO_1_STRING = "ARDUINO_1";
-const char *ARDUINO_2_STRING = "ARDUINO_2";
-const char *ARDUINO_3_STRING = "ARDUINO_3";
-const char *ARDUINO_4_STRING = "ARDUINO_4";
-const char *AT91_I2C_TEST_TASK_STRING = "AT91_I2C_TEST_TASK";
-const char *TEST_TASK_STRING = "TEST_TASK";
-const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
-const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
-const char *S_ADC1_DEC2_STRING = "S_ADC1_DEC2";
-const char *GPS0_HANDLER_STRING = "GPS0_HANDLER";
-const char *DLR_PVCH_STRING = "DLR_PVCH";
-const char *GYRO1_STRING = "GYRO1";
-const char *DLR_IRAS_STRING = "DLR_IRAS";
-const char *_DEC1_O1_STRING = "_DEC1_O1";
-const char *_DEC1_O2_STRING = "_DEC1_O2";
-const char *S1_DEC1_O3_STRING = "S1_DEC1_O3";
-const char *S2_DEC1_O4_STRING = "S2_DEC1_O4";
-const char *S3_DEC1_O5_STRING = "S3_DEC1_O5";
-const char *PT1000_PVHC_DEC1_O6_STRING = "PT1000_PVHC_DEC1_O6";
-const char *PT1000_CCSDS1_DEC2_STRING = "PT1000_CCSDS1_DEC2";
-const char *PT1000_MGT1_DEC2_STRING = "PT1000_MGT1_DEC2";
-const char *S4_DEC2_STRING = "S4_DEC2";
-const char *S5_DEC2_STRING = "S5_DEC2";
-const char *S6_DEC2_STRING = "S6_DEC2";
-const char *PT1000_PVCH_DEC2_STRING = "PT1000_PVCH_DEC2";
-const char *_DEC3_STRING = "_DEC3";
-const char *PT1000_CCSDS2_DEC3_STRING = "PT1000_CCSDS2_DEC3";
-const char *S7_DEC3_STRING = "S7_DEC3";
-const char *S8_DEC3_STRING = "S8_DEC3";
-const char *PT1000_PVCH_DEC3_STRING = "PT1000_PVCH_DEC3";
-const char *GYRO2_STRING = "GYRO2";
-const char *PT1000_PLOC_DEC4_STRING = "PT1000_PLOC_DEC4";
-const char *S9_DEC4_STRING = "S9_DEC4";
-const char *S10_DEC4_STRING = "S10_DEC4";
-const char *PT1000_PVHC_DEC4_STRING = "PT1000_PVHC_DEC4";
-const char *S_ADC_DEC4_STRING = "S_ADC_DEC4";
-const char *GPS1_HANDLER_STRING = "GPS1_HANDLER";
-const char *DUMMY_GPS_COM_IF_STRING = "DUMMY_GPS_COM_IF";
-const char *RS232_DEVICE_COM_IF_STRING = "RS232_DEVICE_COM_IF";
-const char *I2C_DEVICE_COM_IF_STRING = "I2C_DEVICE_COM_IF";
-const char *GPIO_DEVICE_COM_IF_STRING = "GPIO_DEVICE_COM_IF";
-const char *SPI_POLLING_TASK_STRING = "SPI_POLLING_TASK";
-const char *SPI_DEVICE_COM_IF_STRING = "SPI_DEVICE_COM_IF";
-const char *DUMMY_ECHO_COM_IF_STRING = "DUMMY_ECHO_COM_IF";
-const char *SD_CARD_HANDLER_STRING = "SD_CARD_HANDLER";
-const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
-const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
-const char *UDP_TMTC_BRIDGE_STRING = "UDP_TMTC_BRIDGE";
-const char *EMAC_POLLING_TASK_STRING = "EMAC_POLLING_TASK";
-const char *SERIAL_POLLING_TASK_STRING = "SERIAL_POLLING_TASK";
-const char *UART_TMTC_BRIDGE_STRING = "UART_TMTC_BRIDGE";
-const char *PUS_SERVICE_1_STRING = "PUS_SERVICE_1";
-const char *PUS_SERVICE_2_STRING = "PUS_SERVICE_2";
-const char *PUS_SERVICE_3_STRING = "PUS_SERVICE_3";
-const char *PUS_SERVICE_5_STRING = "PUS_SERVICE_5";
-const char *PUS_SERVICE_6_STRING = "PUS_SERVICE_6";
-const char *PUS_SERVICE_8_STRING = "PUS_SERVICE_8";
-const char *PUS_SERVICE_9_STRING = "PUS_SERVICE_9";
-const char *PUS_SERVICE_17_STRING = "PUS_SERVICE_17";
-const char *PUS_SERVICE_23_STRING = "PUS_SERVICE_23";
-const char *PUS_SERVICE_200_STRING = "PUS_SERVICE_200";
-const char *PUS_SERVICE_201_STRING = "PUS_SERVICE_201";
-const char *PUS_TIME_STRING = "PUS_TIME";
-const char *PUS_FUNNEL_STRING = "PUS_FUNNEL";
-const char *HEALTH_TABLE_STRING = "HEALTH_TABLE";
-const char *MODE_STORE_STRING = "MODE_STORE";
-const char *EVENT_MANAGER_STRING = "EVENT_MANAGER";
-const char *INTERNAL_ERROR_REPORTER_STRING = "INTERNAL_ERROR_REPORTER";
-const char *TC_STORE_STRING = "TC_STORE";
-const char *TM_STORE_STRING = "TM_STORE";
-const char *IPC_STORE_STRING = "IPC_STORE";
-const char *AT91_SPI_TEST_TASK_STRING = "AT91_SPI_TEST_TASK";
-const char *STM32_TEST_TASK_STRING = "STM32_TEST_TASK";
-const char *AT91_UART0_TEST_TASK_STRING = "AT91_UART0_TEST_TASK";
-const char *NO_OBJECT_STRING = "NO_OBJECT";
-
-const char* translateObject(object_id_t object){
-	switch((object&0xFFFFFFFF)){
-		case 0x000123336:
-			return AT91_UART2_TEST_TASK_STRING;
-		case 0x01010100:
-			return ARDUINO_0_STRING;
-		case 0x01010101:
-			return ARDUINO_1_STRING;
-		case 0x01010102:
-			return ARDUINO_2_STRING;
-		case 0x01010103:
-			return ARDUINO_3_STRING;
-		case 0x01010104:
-			return ARDUINO_4_STRING;
-		case 0x12345678:
-			return AT91_I2C_TEST_TASK_STRING;
-		case 0x42694269:
-			return TEST_TASK_STRING;
-		case 0x44003200:
-			return PCDU_HANDLER_STRING;
-		case 0x4400AFFE:
-			return DUMMY_HANDLER_STRING;
-		case 0x44020108:
-			return S_ADC1_DEC2_STRING;
-		case 0x44101F00:
-			return GPS0_HANDLER_STRING;
-		case 0x44104000:
-			return DLR_PVCH_STRING;
-		case 0x44105000:
-			return GYRO1_STRING;
-		case 0x44106000:
-			return DLR_IRAS_STRING;
-		case 0x44115401:
-			return _DEC1_O1_STRING;
-		case 0x44115402:
-			return _DEC1_O2_STRING;
-		case 0x44115404:
-			return S1_DEC1_O3_STRING;
-		case 0x44115405:
-			return S2_DEC1_O4_STRING;
-		case 0x44115406:
-			return S3_DEC1_O5_STRING;
-		case 0x44115407:
-			return PT1000_PVHC_DEC1_O6_STRING;
-		case 0x44125401:
-			return PT1000_CCSDS1_DEC2_STRING;
-		case 0x44125403:
-			return PT1000_MGT1_DEC2_STRING;
-		case 0x44125404:
-			return S4_DEC2_STRING;
-		case 0x44125405:
-			return S5_DEC2_STRING;
-		case 0x44125406:
-			return S6_DEC2_STRING;
-		case 0x44125407:
-			return PT1000_PVCH_DEC2_STRING;
-		case 0x44130301:
-			return _DEC3_STRING;
-		case 0x44130302:
-			return PT1000_CCSDS2_DEC3_STRING;
-		case 0x44130305:
-			return S7_DEC3_STRING;
-		case 0x44130306:
-			return S8_DEC3_STRING;
-		case 0x44130307:
-			return PT1000_PVCH_DEC3_STRING;
-		case 0x44130308:
-			return GYRO2_STRING;
-		case 0x44145401:
-			return PT1000_PLOC_DEC4_STRING;
-		case 0x44145404:
-			return S9_DEC4_STRING;
-		case 0x44145405:
-			return S10_DEC4_STRING;
-		case 0x44145406:
-			return PT1000_PVHC_DEC4_STRING;
-		case 0x44145407:
-			return S_ADC_DEC4_STRING;
-		case 0x44202000:
-			return GPS1_HANDLER_STRING;
-		case 0x49001F00:
-			return DUMMY_GPS_COM_IF_STRING;
-		case 0x49005200:
-			return RS232_DEVICE_COM_IF_STRING;
-		case 0x49005300:
-			return I2C_DEVICE_COM_IF_STRING;
-		case 0x49005400:
-			return GPIO_DEVICE_COM_IF_STRING;
-		case 0x49005410:
-			return SPI_POLLING_TASK_STRING;
-		case 0x49005600:
-			return SPI_DEVICE_COM_IF_STRING;
-		case 0x4900AFFE:
-			return DUMMY_ECHO_COM_IF_STRING;
-		case 0x4D0073AD:
-			return SD_CARD_HANDLER_STRING;
-		case 0x50000100:
-			return CCSDS_PACKET_DISTRIBUTOR_STRING;
-		case 0x50000200:
-			return PUS_PACKET_DISTRIBUTOR_STRING;
-		case 0x50000300:
-			return UDP_TMTC_BRIDGE_STRING;
-		case 0x50000400:
-			return EMAC_POLLING_TASK_STRING;
-		case 0x50000600:
-			return SERIAL_POLLING_TASK_STRING;
-		case 0x5000500:
-			return UART_TMTC_BRIDGE_STRING;
-		case 0x51000100:
-			return PUS_SERVICE_1_STRING;
-		case 0x51000200:
-			return PUS_SERVICE_2_STRING;
-		case 0x51000300:
-			return PUS_SERVICE_3_STRING;
-		case 0x51000400:
-			return PUS_SERVICE_5_STRING;
-		case 0x51000500:
-			return PUS_SERVICE_6_STRING;
-		case 0x51000800:
-			return PUS_SERVICE_8_STRING;
-		case 0x51000900:
-			return PUS_SERVICE_9_STRING;
-		case 0x51001700:
-			return PUS_SERVICE_17_STRING;
-		case 0x51002300:
-			return PUS_SERVICE_23_STRING;
-		case 0x51020000:
-			return PUS_SERVICE_200_STRING;
-		case 0x51020100:
-			return PUS_SERVICE_201_STRING;
-		case 0x52000001:
-			return PUS_TIME_STRING;
-		case 0x52000002:
-			return PUS_FUNNEL_STRING;
-		case 0x53010000:
-			return HEALTH_TABLE_STRING;
-		case 0x53010100:
-			return MODE_STORE_STRING;
-		case 0x53030000:
-			return EVENT_MANAGER_STRING;
-		case 0x53040000:
-			return INTERNAL_ERROR_REPORTER_STRING;
-		case 0x534f0100:
-			return TC_STORE_STRING;
-		case 0x534f0200:
-			return TM_STORE_STRING;
-		case 0x534f0300:
-			return IPC_STORE_STRING;
-		case 0x66666666:
-			return AT91_SPI_TEST_TASK_STRING;
-		case 0x77777777:
-			return STM32_TEST_TASK_STRING;
-		case 0x87654321:
-			return AT91_UART0_TEST_TASK_STRING;
-		case 0xFFFFFFFF:
-			return NO_OBJECT_STRING;
-		default:
-			return "UNKNOWN_OBJECT";
-	}
-	return 0;
-}
diff --git a/unittest/testcfg/objects/translateObjects.h b/unittest/testcfg/objects/translateObjects.h
deleted file mode 100644
index 18c237eb6..000000000
--- a/unittest/testcfg/objects/translateObjects.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * translateObjects.h
- *
- *  Created on: 28 May 2019
- *      Author: Robin
- */
-
-#ifndef CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
-#define CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
-
-#include <fsfw/objectmanager/ObjectManagerIF.h>
-
-const char* translateObject(object_id_t object);
-
-
-#endif /* CONFIG_OBJECTS_TRANSLATEOBJECTS_H_ */

From 9086ee2ffed94f5bd2343105ad6ccd81bc7de3ab Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 13:24:29 +0100
Subject: [PATCH 1033/1774] added new tests

---
 unittest/tests/storagemanager/TestPool.cpp | 591 ++++++++++-----------
 1 file changed, 295 insertions(+), 296 deletions(-)

diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
index f278c40c7..daeb6bb52 100644
--- a/unittest/tests/storagemanager/TestPool.cpp
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -1,296 +1,295 @@
-//#include "CatchDefinitions.h"
-//
-//#include <config/objects/Factory.h>
-//#include <fsfw/objectmanager/ObjectManager.h>
-//#include <fsfw/storagemanager/LocalPool.h>
-//
-//#include <catch.hpp>
-//#include <CatchDefinitions.h>
-//
-//#include <cstring>
-//
-//
-//TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
-////	uint16_t numberOfElements[1] = {1};
-////	uint16_t sizeofElements[1] = {10};
-//	LocalPool::LocalPoolConfig config = {{1, 10}};
-//	LocalPool simplePool(0, config);
-//	std::array<uint8_t, 20> testDataArray;
-//	std::array<uint8_t, 20> receptionArray;
-//	store_address_t testStoreId;
-//	ReturnValue_t result = retval::CATCH_FAILED;
-//	uint8_t *pointer = nullptr;
-//	const uint8_t * constPointer = nullptr;
-//
-//	for(size_t i = 0; i < testDataArray.size(); i++) {
-//		testDataArray[i] = i;
-//	}
-//	size_t size = 10;
-//
-//	SECTION ( "Basic tests") {
-//		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		result = simplePool.getData(testStoreId, &constPointer, &size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		memcpy(receptionArray.data(), constPointer, size);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//		memset(receptionArray.data(), 0, size);
-//		result = simplePool.modifyData(testStoreId, &pointer, &size);
-//		memcpy(receptionArray.data(), pointer, size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//		result = simplePool.deleteData(testStoreId);
-//		REQUIRE(result == retval::CATCH_OK);
-//		result = simplePool.addData(&testStoreId, testDataArray.data(), 15);
-//		CHECK (result == (int) StorageManagerIF::DATA_TOO_LARGE);
-//	}
-//
-//	SECTION ( "Reservation Tests ") {
-//		pointer = nullptr;
-//		result = simplePool.getFreeElement(&testStoreId, size, &pointer);
-//		REQUIRE (result == retval::CATCH_OK);
-//		memcpy(pointer, testDataArray.data(), size);
-//		constPointer = nullptr;
-//		result = simplePool.getData(testStoreId, &constPointer, &size);
-//
-//		REQUIRE (result == retval::CATCH_OK);
-//		memcpy(receptionArray.data(), constPointer, size);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//	}
-//
-//	SECTION ( "Add, delete, add, add when full") {
-//		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		result = simplePool.getData(testStoreId, &constPointer, &size);
-//		REQUIRE( result == retval::CATCH_OK);
-//		memcpy(receptionArray.data(), constPointer, size);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//
-//		result = simplePool.deleteData(testStoreId);
-//		REQUIRE(result == retval::CATCH_OK);
-//
-//		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		result = simplePool.getData(testStoreId, &constPointer, &size);
-//		REQUIRE( result == retval::CATCH_OK);
-//		memcpy(receptionArray.data(), constPointer, size);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//
-//		store_address_t newAddress;
-//		result = simplePool.addData(&newAddress, testDataArray.data(), size);
-//		REQUIRE(result == (int) StorageManagerIF::DATA_STORAGE_FULL);
-//
-//		// Packet Index to high intentionally
-//		newAddress.packetIndex = 2;
-//		pointer = testDataArray.data();
-//		result = simplePool.modifyData(newAddress, &pointer, &size);
-//		REQUIRE(result == (int) StorageManagerIF::ILLEGAL_STORAGE_ID);
-//
-//		result = simplePool.deleteData(newAddress);
-//		REQUIRE(result == (int) StorageManagerIF::ILLEGAL_STORAGE_ID);
-//
-//		newAddress.packetIndex = 0;
-//		newAddress.poolIndex = 2;
-//		result = simplePool.deleteData(newAddress);
-//		REQUIRE(result == (int) StorageManagerIF::ILLEGAL_STORAGE_ID);
-//	}
-//
-//	SECTION ( "Initialize and clear store, delete with pointer") {
-//		result = simplePool.initialize();
-//		REQUIRE(result == retval::CATCH_OK);
-//		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		simplePool.clearStore();
-//		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		result = simplePool.modifyData(testStoreId, &pointer, &size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		store_address_t newId;
-//		result = simplePool.deleteData(pointer, size, &testStoreId);
-//		REQUIRE(result == retval::CATCH_OK);
-//		REQUIRE(testStoreId.raw != (uint32_t) StorageManagerIF::INVALID_ADDRESS);
-//		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//	}
-//}
-//
-//int runIdx = 0;
-//
-//TEST_CASE( "Local Pool Extended Tests [3 Pools]" , "[TestPool2]") {
-//	LocalPool::LocalPoolConfig* config;
-//	if(runIdx == 0) {
-//		config = new LocalPool::LocalPoolConfig{{10, 5}, {5, 10}, {2, 20}};
-//	}
-//	else {
-//		// shufle the order, they should be sort implictely so that the
-//		// order is ascending for the page sizes.
-//		config = new LocalPool::LocalPoolConfig{{5, 10}, {2, 20}, {10, 5}};
-//		size_t lastSize = 0;
-//		for(const auto& pair: *config) {
-//			CHECK(pair.second > lastSize);
-//			lastSize = pair.second;
-//		}
-//	}
-//	runIdx++;
-//
-//	LocalPool simplePool(0, *config);
-//	std::array<uint8_t, 20> testDataArray;
-//	std::array<uint8_t, 20> receptionArray;
-//	store_address_t testStoreId;
-//	ReturnValue_t result = retval::CATCH_FAILED;
-//	for(size_t i = 0; i < testDataArray.size(); i++) {
-//		testDataArray[i] = i;
-//	}
-//	size_t size = 0;
-//
-//	SECTION ("Basic tests") {
-//		size = 8;
-//		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		// Should be on second page of the pool now for 8 bytes
-//		CHECK(testStoreId.poolIndex == 1);
-//		CHECK(testStoreId.packetIndex == 0);
-//
-//		size = 15;
-//		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		// Should be on third page of the pool now for 15 bytes
-//		CHECK(testStoreId.poolIndex == 2);
-//		CHECK(testStoreId.packetIndex == 0);
-//
-//		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		// Should be on third page of the pool now for 15 bytes
-//		CHECK(testStoreId.poolIndex == 2);
-//		CHECK(testStoreId.packetIndex == 1);
-//
-//		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//		// Should be on third page of the pool now for 15 bytes
-//		REQUIRE(result == (int) LocalPool::DATA_STORAGE_FULL);
-//
-//		size = 8;
-//		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		// Should still work
-//		CHECK(testStoreId.poolIndex == 1);
-//		CHECK(testStoreId.packetIndex == 1);
-//
-//		// fill the rest of the pool
-//		for(uint8_t idx = 2; idx < 5; idx++) {
-//			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//			REQUIRE(result == retval::CATCH_OK);
-//			CHECK(testStoreId.poolIndex == 1);
-//			CHECK(testStoreId.packetIndex == idx);
-//		}
-//	}
-//
-//	SECTION ("Fill Count and Clearing") {
-//		//SECTION("Basic tests");
-//		uint8_t bytesWritten = 0;
-//		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
-//		// fill count should be all zeros now.
-//		CHECK(bytesWritten == 4);
-//		CHECK(receptionArray[0] == 0);
-//		CHECK(receptionArray[1] == 0);
-//		CHECK(receptionArray[2] == 0);
-//		CHECK(receptionArray[3] == 0);
-//
-//		// now fill the store completely.
-//		size = 5;
-//		for(uint8_t idx = 0; idx < 10; idx++) {
-//			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//			REQUIRE(result == retval::CATCH_OK);
-//			CHECK(testStoreId.poolIndex == 0);
-//			CHECK(testStoreId.packetIndex == idx);
-//		}
-//		size = 10;
-//		for(uint8_t idx = 0; idx < 5; idx++) {
-//			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//			REQUIRE(result == retval::CATCH_OK);
-//			CHECK(testStoreId.poolIndex == 1);
-//			CHECK(testStoreId.packetIndex == idx);
-//		}
-//		size = 20;
-//		for(uint8_t idx = 0; idx < 2; idx++) {
-//			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//			REQUIRE(result == retval::CATCH_OK);
-//			CHECK(testStoreId.poolIndex == 2);
-//			CHECK(testStoreId.packetIndex == idx);
-//		}
-//		bytesWritten = 0;
-//		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
-//		// fill count should be all 100 now.
-//		CHECK(bytesWritten == 4);
-//		CHECK(receptionArray[0] == 100);
-//		CHECK(receptionArray[1] == 100);
-//		CHECK(receptionArray[2] == 100);
-//		CHECK(receptionArray[3] == 100);
-//
-//		// now clear the store
-//		simplePool.clearStore();
-//		bytesWritten = 0;
-//		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
-//		CHECK(bytesWritten == 4);
-//		CHECK(receptionArray[0] == 0);
-//		CHECK(receptionArray[1] == 0);
-//		CHECK(receptionArray[2] == 0);
-//		CHECK(receptionArray[3] == 0);
-//
-//		// now fill one page
-//		size = 5;
-//		for(uint8_t idx = 0; idx < 10; idx++) {
-//			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//			REQUIRE(result == retval::CATCH_OK);
-//			CHECK(testStoreId.poolIndex == 0);
-//			CHECK(testStoreId.packetIndex == idx);
-//		}
-//		bytesWritten = 0;
-//		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
-//		// First page full, median fill count is 33 %
-//		CHECK(bytesWritten == 4);
-//		CHECK(receptionArray[0] == 100);
-//		CHECK(receptionArray[1] == 0);
-//		CHECK(receptionArray[2] == 0);
-//		CHECK(receptionArray[3] == 33);
-//
-//		// now fill second page
-//		size = 10;
-//		for(uint8_t idx = 0; idx < 5; idx++) {
-//			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
-//			REQUIRE(result == retval::CATCH_OK);
-//			CHECK(testStoreId.poolIndex == 1);
-//			CHECK(testStoreId.packetIndex == idx);
-//		}
-//		bytesWritten = 0;
-//		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
-//		// First and second page full, median fill count is 66 %
-//		CHECK(bytesWritten == 4);
-//		CHECK(receptionArray[0] == 100);
-//		CHECK(receptionArray[1] == 100);
-//		CHECK(receptionArray[2] == 0);
-//		CHECK(receptionArray[3] == 66);
-//
-//		// now clear first page
-//		simplePool.clearPage(0);
-//		bytesWritten = 0;
-//		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
-//		// Second page full, median fill count is 33 %
-//		CHECK(bytesWritten == 4);
-//		CHECK(receptionArray[0] == 0);
-//		CHECK(receptionArray[1] == 100);
-//		CHECK(receptionArray[2] == 0);
-//		CHECK(receptionArray[3] == 33);
-//	}
-//
-//	delete(config);
-//}
+#include "CatchDefinitions.h"
+
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/storagemanager/LocalPool.h>
+
+#include <catch.hpp>
+#include <CatchDefinitions.h>
+
+#include <cstring>
+
+
+TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
+//	uint16_t numberOfElements[1] = {1};
+//	uint16_t sizeofElements[1] = {10};
+	LocalPool::LocalPoolConfig config = {{1, 10}};
+	LocalPool simplePool(0, config);
+	std::array<uint8_t, 20> testDataArray;
+	std::array<uint8_t, 20> receptionArray;
+	store_address_t testStoreId;
+	ReturnValue_t result = retval::CATCH_FAILED;
+	uint8_t *pointer = nullptr;
+	const uint8_t * constPointer = nullptr;
+
+	for(size_t i = 0; i < testDataArray.size(); i++) {
+		testDataArray[i] = i;
+	}
+	size_t size = 10;
+
+	SECTION ( "Basic tests") {
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		result = simplePool.getData(testStoreId, &constPointer, &size);
+		REQUIRE(result == retval::CATCH_OK);
+		memcpy(receptionArray.data(), constPointer, size);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+		memset(receptionArray.data(), 0, size);
+		result = simplePool.modifyData(testStoreId, &pointer, &size);
+		memcpy(receptionArray.data(), pointer, size);
+		REQUIRE(result == retval::CATCH_OK);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+		result = simplePool.deleteData(testStoreId);
+		REQUIRE(result == retval::CATCH_OK);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), 15);
+		CHECK (result == (int) StorageManagerIF::DATA_TOO_LARGE);
+	}
+
+	SECTION ( "Reservation Tests ") {
+		pointer = nullptr;
+		result = simplePool.getFreeElement(&testStoreId, size, &pointer);
+		REQUIRE (result == retval::CATCH_OK);
+		memcpy(pointer, testDataArray.data(), size);
+		constPointer = nullptr;
+		result = simplePool.getData(testStoreId, &constPointer, &size);
+
+		REQUIRE (result == retval::CATCH_OK);
+		memcpy(receptionArray.data(), constPointer, size);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+	}
+
+	SECTION ( "Add, delete, add, add when full") {
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		result = simplePool.getData(testStoreId, &constPointer, &size);
+		REQUIRE( result == retval::CATCH_OK);
+		memcpy(receptionArray.data(), constPointer, size);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		result = simplePool.deleteData(testStoreId);
+		REQUIRE(result == retval::CATCH_OK);
+
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		result = simplePool.getData(testStoreId, &constPointer, &size);
+		REQUIRE( result == retval::CATCH_OK);
+		memcpy(receptionArray.data(), constPointer, size);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		store_address_t newAddress;
+		result = simplePool.addData(&newAddress, testDataArray.data(), size);
+		REQUIRE(result == (int) StorageManagerIF::DATA_STORAGE_FULL);
+
+		// Packet Index to high intentionally
+		newAddress.packetIndex = 2;
+		pointer = testDataArray.data();
+		result = simplePool.modifyData(newAddress, &pointer, &size);
+		REQUIRE(result == (int) StorageManagerIF::ILLEGAL_STORAGE_ID);
+
+		result = simplePool.deleteData(newAddress);
+		REQUIRE(result == (int) StorageManagerIF::ILLEGAL_STORAGE_ID);
+
+		newAddress.packetIndex = 0;
+		newAddress.poolIndex = 2;
+		result = simplePool.deleteData(newAddress);
+		REQUIRE(result == (int) StorageManagerIF::ILLEGAL_STORAGE_ID);
+	}
+
+	SECTION ( "Initialize and clear store, delete with pointer") {
+		result = simplePool.initialize();
+		REQUIRE(result == retval::CATCH_OK);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		simplePool.clearStore();
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		result = simplePool.modifyData(testStoreId, &pointer, &size);
+		REQUIRE(result == retval::CATCH_OK);
+		store_address_t newId;
+		result = simplePool.deleteData(pointer, size, &testStoreId);
+		REQUIRE(result == retval::CATCH_OK);
+		REQUIRE(testStoreId.raw != (uint32_t) StorageManagerIF::INVALID_ADDRESS);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+	}
+}
+
+int runIdx = 0;
+
+TEST_CASE( "Local Pool Extended Tests [3 Pools]" , "[TestPool2]") {
+	LocalPool::LocalPoolConfig* config;
+	if(runIdx == 0) {
+		config = new LocalPool::LocalPoolConfig{{10, 5}, {5, 10}, {2, 20}};
+	}
+	else {
+		// shufle the order, they should be sort implictely so that the
+		// order is ascending for the page sizes.
+		config = new LocalPool::LocalPoolConfig{{5, 10}, {2, 20}, {10, 5}};
+		size_t lastSize = 0;
+		for(const auto& pair: *config) {
+			CHECK(pair.second > lastSize);
+			lastSize = pair.second;
+		}
+	}
+	runIdx++;
+
+	LocalPool simplePool(0, *config);
+	std::array<uint8_t, 20> testDataArray;
+	std::array<uint8_t, 20> receptionArray;
+	store_address_t testStoreId;
+	ReturnValue_t result = retval::CATCH_FAILED;
+	for(size_t i = 0; i < testDataArray.size(); i++) {
+		testDataArray[i] = i;
+	}
+	size_t size = 0;
+
+	SECTION ("Basic tests") {
+		size = 8;
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		// Should be on second page of the pool now for 8 bytes
+		CHECK(testStoreId.poolIndex == 1);
+		CHECK(testStoreId.packetIndex == 0);
+
+		size = 15;
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		// Should be on third page of the pool now for 15 bytes
+		CHECK(testStoreId.poolIndex == 2);
+		CHECK(testStoreId.packetIndex == 0);
+
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		// Should be on third page of the pool now for 15 bytes
+		CHECK(testStoreId.poolIndex == 2);
+		CHECK(testStoreId.packetIndex == 1);
+
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		// Should be on third page of the pool now for 15 bytes
+		REQUIRE(result == (int) LocalPool::DATA_STORAGE_FULL);
+
+		size = 8;
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		// Should still work
+		CHECK(testStoreId.poolIndex == 1);
+		CHECK(testStoreId.packetIndex == 1);
+
+		// fill the rest of the pool
+		for(uint8_t idx = 2; idx < 5; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 1);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+	}
+
+	SECTION ("Fill Count and Clearing") {
+		//SECTION("Basic tests");
+		uint8_t bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// fill count should be all zeros now.
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 0);
+		CHECK(receptionArray[1] == 0);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 0);
+
+		// now fill the store completely.
+		size = 5;
+		for(uint8_t idx = 0; idx < 10; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 0);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		size = 10;
+		for(uint8_t idx = 0; idx < 5; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 1);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		size = 20;
+		for(uint8_t idx = 0; idx < 2; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 2);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// fill count should be all 100 now.
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 100);
+		CHECK(receptionArray[1] == 100);
+		CHECK(receptionArray[2] == 100);
+		CHECK(receptionArray[3] == 100);
+
+		// now clear the store
+		simplePool.clearStore();
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 0);
+		CHECK(receptionArray[1] == 0);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 0);
+
+		// now fill one page
+		size = 5;
+		for(uint8_t idx = 0; idx < 10; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 0);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// First page full, median fill count is 33 %
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 100);
+		CHECK(receptionArray[1] == 0);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 33);
+
+		// now fill second page
+		size = 10;
+		for(uint8_t idx = 0; idx < 5; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 1);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// First and second page full, median fill count is 66 %
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 100);
+		CHECK(receptionArray[1] == 100);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 66);
+
+		// now clear first page
+		simplePool.clearPage(0);
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// Second page full, median fill count is 33 %
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 0);
+		CHECK(receptionArray[1] == 100);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 33);
+	}
+
+	delete(config);
+}

From 378cbab64d0449c78aafc97922ea20118f842d57 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 13:25:00 +0100
Subject: [PATCH 1034/1774] removed config includes

---
 storagemanager/LocalPool.cpp   | 1 -
 storagemanager/PoolManager.cpp | 1 -
 2 files changed, 2 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 48934a0c8..8e5f4d488 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -1,5 +1,4 @@
 #include "LocalPool.h"
-#include <FSFWConfig.h>
 #include <cstring>
 
 LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index 85376b282..9c801a3da 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -1,5 +1,4 @@
 #include "PoolManager.h"
-#include <FSFWConfig.h>
 
 PoolManager::PoolManager(object_id_t setObjectId,
         const LocalPoolConfig& localPoolConfig):

From e323c69f20da5b2321fbecd5ef2ab84dc1b2060d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 13:36:30 +0100
Subject: [PATCH 1035/1774] better name for preproc define

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 8 ++++----
 storagemanager/LocalPool.cpp       | 9 +++++----
 storagemanager/PoolManager.cpp     | 3 ++-
 unittest/testcfg/FSFWConfig.h      | 2 +-
 4 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index f475e3fa8..1386bf66f 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -8,12 +8,12 @@
 //! Those can lead to code bloat.
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrese code size
+//! Reduced printout to further decrease code size
 //! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_REDUCED_PRINTOUT		0
+#define FSFW_ENHANCED_PRINTOUT		0
 
-//! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_DEBUGGING              0
+//! Can be used to enable additional debugging printouts for developing the FSFW
+#define FSFW_PRINT_VERBOSITY_LEVEL   0
 
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle
diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 8e5f4d488..74e362d49 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -1,4 +1,5 @@
 #include "LocalPool.h"
+#include <FSFWConfig.h>
 #include <cstring>
 
 LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
@@ -116,7 +117,7 @@ ReturnValue_t LocalPool::modifyData(store_address_t storeId,
 }
 
 ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
       sif::debug << "Delete: Pool: " << std::dec << storeId.poolIndex
               << " Index: " << storeId.packetIndex << std::endl;
 
@@ -155,7 +156,7 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
             // element of an object.
             localId.packetIndex = deltaAddress / elementSizes[n];
             result = deleteData(localId);
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
             if (deltaAddress % elementSizes[n] != 0) {
                 sif::error << "LocalPool::deleteData: Address not aligned!"
                         << std::endl;
@@ -222,7 +223,7 @@ ReturnValue_t LocalPool::reserveSpace(const size_t size,
         status = findEmpty(storeId->poolIndex, &storeId->packetIndex);
     }
     if (status == RETURN_OK) {
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
         sif::debug << "Reserve: Pool: " << std::dec
                 << storeId->poolIndex << " Index: " << storeId->packetIndex
                 << std::endl;
@@ -264,7 +265,7 @@ void LocalPool::setToSpillToHigherPools(bool enable) {
 ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
         uint16_t startAtIndex) {
     for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
         sif::debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: "
              << n << ", Element Size: " << elementSizes[n] << std::endl;
 #endif
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index 9c801a3da..3b7b549bd 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -1,4 +1,5 @@
 #include "PoolManager.h"
+#include <FSFWConfig.h>
 
 PoolManager::PoolManager(object_id_t setObjectId,
         const LocalPoolConfig& localPoolConfig):
@@ -24,7 +25,7 @@ ReturnValue_t PoolManager::reserveSpace(const size_t size,
 
 ReturnValue_t PoolManager::deleteData(
         store_address_t storeId) {
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
      sif::debug << "PoolManager( " << translateObject(getObjectId()) <<
            " )::deleteData from store " << storeId.poolIndex <<
            ". id is "<< storeId.packetIndex << std::endl;
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 4fb224c15..d3451985e 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -12,7 +12,7 @@
 #define FSFW_REDUCED_PRINTOUT		0
 
 //! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_DEBUGGING              0
+#define FSFW_VERBOSE_PRINTOUT       0
 
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle

From 98dae18430f6a19ee1047d5c0b47d16cf4ee6bc2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 13:46:29 +0100
Subject: [PATCH 1036/1774] update defaultcfg folder

---
 defaultcfg/{config => fsfwconfig}/FSFWConfig.h    | 15 +++++++++------
 defaultcfg/{config => fsfwconfig}/OBSWConfig.h    |  0
 defaultcfg/{config => fsfwconfig}/OBSWVersion.h   |  0
 .../devices/logicalAddresses.cpp                  |  0
 .../devices/logicalAddresses.h                    |  2 +-
 .../devices/powerSwitcherList.cpp                 |  0
 .../devices/powerSwitcherList.h                   |  0
 .../events/subsystemIdRanges.h                    |  0
 .../config.mk => fsfwconfig/fsfwconfig.mk}        |  0
 .../ipc/missionMessageTypes.cpp                   |  3 ++-
 .../ipc/missionMessageTypes.h                     |  0
 .../{config => fsfwconfig}/objects/Factory.cpp    | 14 +++++++-------
 .../{config => fsfwconfig}/objects/Factory.h      |  0
 .../objects/systemObjectList.h                    |  0
 .../pollingsequence/PollingSequenceFactory.cpp    |  0
 .../pollingsequence/PollingSequenceFactory.h      |  0
 .../returnvalues/classIds.h                       |  0
 defaultcfg/{config => fsfwconfig}/tmtc/apid.h     |  0
 defaultcfg/{config => fsfwconfig}/tmtc/pusIds.h   |  0
 19 files changed, 19 insertions(+), 15 deletions(-)
 rename defaultcfg/{config => fsfwconfig}/FSFWConfig.h (81%)
 rename defaultcfg/{config => fsfwconfig}/OBSWConfig.h (100%)
 rename defaultcfg/{config => fsfwconfig}/OBSWVersion.h (100%)
 rename defaultcfg/{config => fsfwconfig}/devices/logicalAddresses.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/devices/logicalAddresses.h (89%)
 rename defaultcfg/{config => fsfwconfig}/devices/powerSwitcherList.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/devices/powerSwitcherList.h (100%)
 rename defaultcfg/{config => fsfwconfig}/events/subsystemIdRanges.h (100%)
 rename defaultcfg/{config/config.mk => fsfwconfig/fsfwconfig.mk} (100%)
 rename defaultcfg/{config => fsfwconfig}/ipc/missionMessageTypes.cpp (79%)
 rename defaultcfg/{config => fsfwconfig}/ipc/missionMessageTypes.h (100%)
 rename defaultcfg/{config => fsfwconfig}/objects/Factory.cpp (75%)
 rename defaultcfg/{config => fsfwconfig}/objects/Factory.h (100%)
 rename defaultcfg/{config => fsfwconfig}/objects/systemObjectList.h (100%)
 rename defaultcfg/{config => fsfwconfig}/pollingsequence/PollingSequenceFactory.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/pollingsequence/PollingSequenceFactory.h (100%)
 rename defaultcfg/{config => fsfwconfig}/returnvalues/classIds.h (100%)
 rename defaultcfg/{config => fsfwconfig}/tmtc/apid.h (100%)
 rename defaultcfg/{config => fsfwconfig}/tmtc/pusIds.h (100%)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
similarity index 81%
rename from defaultcfg/config/FSFWConfig.h
rename to defaultcfg/fsfwconfig/FSFWConfig.h
index ea86152cb..1386bf66f 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -1,19 +1,19 @@
 #ifndef CONFIG_FSFWCONFIG_H_
 #define CONFIG_FSFWCONFIG_H_
 
-#include <FSFWVersion.h>
 #include <cstddef>
+#include <cstdint>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrese code size
+//! Reduced printout to further decrease code size
 //! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_REDUCED_PRINTOUT		0
+#define FSFW_ENHANCED_PRINTOUT		0
 
-//! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_DEBUGGING              0
+//! Can be used to enable additional debugging printouts for developing the FSFW
+#define FSFW_PRINT_VERBOSITY_LEVEL   0
 
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle
@@ -38,7 +38,10 @@
 
 //! When using the newlib nano library, C99 support for stdio facilities
 //! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NO_C99_IO 	1
+#define FSFW_NO_C99_IO 	            1
+
+//! Specify whether a special mode store is used for Subsystem components.
+#define FSFW_USE_MODESTORE          0
 
 namespace fsfwconfig {
 //! Default timestamp size. The default timestamp will be an eight byte CDC
diff --git a/defaultcfg/config/OBSWConfig.h b/defaultcfg/fsfwconfig/OBSWConfig.h
similarity index 100%
rename from defaultcfg/config/OBSWConfig.h
rename to defaultcfg/fsfwconfig/OBSWConfig.h
diff --git a/defaultcfg/config/OBSWVersion.h b/defaultcfg/fsfwconfig/OBSWVersion.h
similarity index 100%
rename from defaultcfg/config/OBSWVersion.h
rename to defaultcfg/fsfwconfig/OBSWVersion.h
diff --git a/defaultcfg/config/devices/logicalAddresses.cpp b/defaultcfg/fsfwconfig/devices/logicalAddresses.cpp
similarity index 100%
rename from defaultcfg/config/devices/logicalAddresses.cpp
rename to defaultcfg/fsfwconfig/devices/logicalAddresses.cpp
diff --git a/defaultcfg/config/devices/logicalAddresses.h b/defaultcfg/fsfwconfig/devices/logicalAddresses.h
similarity index 89%
rename from defaultcfg/config/devices/logicalAddresses.h
rename to defaultcfg/fsfwconfig/devices/logicalAddresses.h
index 174fa788b..e0827ba33 100644
--- a/defaultcfg/config/devices/logicalAddresses.h
+++ b/defaultcfg/fsfwconfig/devices/logicalAddresses.h
@@ -1,8 +1,8 @@
 #ifndef CONFIG_DEVICES_LOGICALADDRESSES_H_
 #define CONFIG_DEVICES_LOGICALADDRESSES_H_
 
-#include <config/objects/systemObjectList.h>
 #include <fsfw/devicehandlers/CookieIF.h>
+#include "../objects/systemObjectList.h"
 #include <cstdint>
 
 /**
diff --git a/defaultcfg/config/devices/powerSwitcherList.cpp b/defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp
similarity index 100%
rename from defaultcfg/config/devices/powerSwitcherList.cpp
rename to defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp
diff --git a/defaultcfg/config/devices/powerSwitcherList.h b/defaultcfg/fsfwconfig/devices/powerSwitcherList.h
similarity index 100%
rename from defaultcfg/config/devices/powerSwitcherList.h
rename to defaultcfg/fsfwconfig/devices/powerSwitcherList.h
diff --git a/defaultcfg/config/events/subsystemIdRanges.h b/defaultcfg/fsfwconfig/events/subsystemIdRanges.h
similarity index 100%
rename from defaultcfg/config/events/subsystemIdRanges.h
rename to defaultcfg/fsfwconfig/events/subsystemIdRanges.h
diff --git a/defaultcfg/config/config.mk b/defaultcfg/fsfwconfig/fsfwconfig.mk
similarity index 100%
rename from defaultcfg/config/config.mk
rename to defaultcfg/fsfwconfig/fsfwconfig.mk
diff --git a/defaultcfg/config/ipc/missionMessageTypes.cpp b/defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
similarity index 79%
rename from defaultcfg/config/ipc/missionMessageTypes.cpp
rename to defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
index e2edbf9c5..b41b87ba1 100644
--- a/defaultcfg/config/ipc/missionMessageTypes.cpp
+++ b/defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
@@ -1,4 +1,5 @@
-#include <config/ipc/MissionMessageTypes.h>
+#include "missionMessageTypes.h"
+
 #include <fsfw/ipc/CommandMessageIF.h>
 
 void messagetypes::clearMissionMessage(CommandMessage* message) {
diff --git a/defaultcfg/config/ipc/missionMessageTypes.h b/defaultcfg/fsfwconfig/ipc/missionMessageTypes.h
similarity index 100%
rename from defaultcfg/config/ipc/missionMessageTypes.h
rename to defaultcfg/fsfwconfig/ipc/missionMessageTypes.h
diff --git a/defaultcfg/config/objects/Factory.cpp b/defaultcfg/fsfwconfig/objects/Factory.cpp
similarity index 75%
rename from defaultcfg/config/objects/Factory.cpp
rename to defaultcfg/fsfwconfig/objects/Factory.cpp
index 51dd61304..41333b1c3 100644
--- a/defaultcfg/config/objects/Factory.cpp
+++ b/defaultcfg/fsfwconfig/objects/Factory.cpp
@@ -11,6 +11,7 @@
 #include <fsfw/tmtcpacket/pus/TmPacketStored.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
+#include <internalError/InternalErrorReporter.h>
 
 #include <cstdint>
 
@@ -31,15 +32,15 @@ void Factory::produce(void) {
 	setStaticFrameworkObjectIds();
 	new EventManager(objects::EVENT_MANAGER);
 	new HealthTable(objects::HEALTH_TABLE);
-	//new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
 }
 
 void Factory::setStaticFrameworkObjectIds() {
-	PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
-	PusServiceBase::packetDestination = objects::TM_FUNNEL;
+	PusServiceBase::packetSource = objects::NO_OBJECT;
+	PusServiceBase::packetDestination = objects::NO_OBJECT;
 
-	CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
-	CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+	CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+	CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
 
 	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
 
@@ -48,7 +49,6 @@ void Factory::setStaticFrameworkObjectIds() {
 
 	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
 
-	TmPacketStored::timeStamperId = objects::PUS_TIME;
-	//TmFunnel::downlinkDestination = objects::NO_OBJECT;
+	TmPacketStored::timeStamperId = objects::NO_OBJECT;
 }
 
diff --git a/defaultcfg/config/objects/Factory.h b/defaultcfg/fsfwconfig/objects/Factory.h
similarity index 100%
rename from defaultcfg/config/objects/Factory.h
rename to defaultcfg/fsfwconfig/objects/Factory.h
diff --git a/defaultcfg/config/objects/systemObjectList.h b/defaultcfg/fsfwconfig/objects/systemObjectList.h
similarity index 100%
rename from defaultcfg/config/objects/systemObjectList.h
rename to defaultcfg/fsfwconfig/objects/systemObjectList.h
diff --git a/defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
similarity index 100%
rename from defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp
rename to defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
diff --git a/defaultcfg/config/pollingsequence/PollingSequenceFactory.h b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.h
similarity index 100%
rename from defaultcfg/config/pollingsequence/PollingSequenceFactory.h
rename to defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.h
diff --git a/defaultcfg/config/returnvalues/classIds.h b/defaultcfg/fsfwconfig/returnvalues/classIds.h
similarity index 100%
rename from defaultcfg/config/returnvalues/classIds.h
rename to defaultcfg/fsfwconfig/returnvalues/classIds.h
diff --git a/defaultcfg/config/tmtc/apid.h b/defaultcfg/fsfwconfig/tmtc/apid.h
similarity index 100%
rename from defaultcfg/config/tmtc/apid.h
rename to defaultcfg/fsfwconfig/tmtc/apid.h
diff --git a/defaultcfg/config/tmtc/pusIds.h b/defaultcfg/fsfwconfig/tmtc/pusIds.h
similarity index 100%
rename from defaultcfg/config/tmtc/pusIds.h
rename to defaultcfg/fsfwconfig/tmtc/pusIds.h

From 9ebf259a9e0ac9c10e501182bd18916bfef41a56 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 13:50:33 +0100
Subject: [PATCH 1037/1774] added back config

---
 storagemanager/LocalPool.cpp   | 9 +++++----
 storagemanager/PoolManager.cpp | 3 ++-
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 8e5f4d488..74e362d49 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -1,4 +1,5 @@
 #include "LocalPool.h"
+#include <FSFWConfig.h>
 #include <cstring>
 
 LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
@@ -116,7 +117,7 @@ ReturnValue_t LocalPool::modifyData(store_address_t storeId,
 }
 
 ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
       sif::debug << "Delete: Pool: " << std::dec << storeId.poolIndex
               << " Index: " << storeId.packetIndex << std::endl;
 
@@ -155,7 +156,7 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
             // element of an object.
             localId.packetIndex = deltaAddress / elementSizes[n];
             result = deleteData(localId);
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
             if (deltaAddress % elementSizes[n] != 0) {
                 sif::error << "LocalPool::deleteData: Address not aligned!"
                         << std::endl;
@@ -222,7 +223,7 @@ ReturnValue_t LocalPool::reserveSpace(const size_t size,
         status = findEmpty(storeId->poolIndex, &storeId->packetIndex);
     }
     if (status == RETURN_OK) {
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
         sif::debug << "Reserve: Pool: " << std::dec
                 << storeId->poolIndex << " Index: " << storeId->packetIndex
                 << std::endl;
@@ -264,7 +265,7 @@ void LocalPool::setToSpillToHigherPools(bool enable) {
 ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
         uint16_t startAtIndex) {
     for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
         sif::debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: "
              << n << ", Element Size: " << elementSizes[n] << std::endl;
 #endif
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index 9c801a3da..3b7b549bd 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -1,4 +1,5 @@
 #include "PoolManager.h"
+#include <FSFWConfig.h>
 
 PoolManager::PoolManager(object_id_t setObjectId,
         const LocalPoolConfig& localPoolConfig):
@@ -24,7 +25,7 @@ ReturnValue_t PoolManager::reserveSpace(const size_t size,
 
 ReturnValue_t PoolManager::deleteData(
         store_address_t storeId) {
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
      sif::debug << "PoolManager( " << translateObject(getObjectId()) <<
            " )::deleteData from store " << storeId.poolIndex <<
            ". id is "<< storeId.packetIndex << std::endl;

From 2930b2dd5ac533188d3a8969ddf70f44a587f169 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 13:52:40 +0100
Subject: [PATCH 1038/1774] changelog update

---
 CHANGELOG | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index 96f5703c5..7637700c6 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -5,3 +5,7 @@
 
 - vRequestContextSwitchFromISR is declared extern "C" so it can be defined in
 a C file without issues
+
+### Local Pool
+
+- Interface of LocalPools has change. LocalPool is not a template anymore. Instead the size and bucket number of the pools per page and the number of pages are passed to the ctor instead of two ctor arguments and a template parameter

From 1f78496cd3512d2f8f1cd080a9ff9e161d2cc280 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 14:01:04 +0100
Subject: [PATCH 1039/1774] changelog update

---
 CHANGELOG | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index 96f5703c5..ed73248d8 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -5,3 +5,7 @@
 
 - vRequestContextSwitchFromISR is declared extern "C" so it can be defined in
 a C file without issues
+
+### EnhancedControllerBase
+
+- New base class for a controller which also implements HasActionsIF and HasLocalDataPoolIF

From 802e24e2933be81eb6f7a35af89692dfff5bc159 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 14:43:36 +0100
Subject: [PATCH 1040/1774] change log update

---
 CHANGELOG | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG b/CHANGELOG
index 96f5703c5..d5e083dcb 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,4 +1,4 @@
-## Changes from ASTP 0.0.1 to 0.0.2
+## Changes from ASTP 1.0.0 to 1.1.0
 
 
 ### FreeRTOS OSAL

From 45df446ab80e1303738889c21e15921c4b807fd6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 14:44:03 +0100
Subject: [PATCH 1041/1774] change log update

---
 CHANGELOG | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG b/CHANGELOG
index d5e083dcb..4937b5f8c 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,4 +1,4 @@
-## Changes from ASTP 1.0.0 to 1.1.0
+## Changes from ASTP 0.0.1 to 1.0.0
 
 
 ### FreeRTOS OSAL

From 3e74c18d88d0fadc82f7b60be926d2582d5ec7f0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 14:59:35 +0100
Subject: [PATCH 1042/1774] health servicd

---
 pus/CService201HealthCommanding.cpp | 102 ++++++++++++++++++++++++++++
 pus/CService201HealthCommanding.h   |  63 +++++++++++++++++
 2 files changed, 165 insertions(+)
 create mode 100644 pus/CService201HealthCommanding.cpp
 create mode 100644 pus/CService201HealthCommanding.h

diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
new file mode 100644
index 000000000..db43db898
--- /dev/null
+++ b/pus/CService201HealthCommanding.cpp
@@ -0,0 +1,102 @@
+#include "CService201HealthCommanding.h"
+
+#include "../health/HasHealthIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../health/HealthMessage.h"
+#include "servicepackets/Service201Packets.h"
+
+CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
+        uint16_t commandTimeoutSeconds):
+		CommandingServiceBase(objectId, apid, serviceId,
+		        numParallelCommands, commandTimeoutSeconds) {
+}
+
+CService201HealthCommanding::~CService201HealthCommanding() {
+}
+
+ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
+	switch(subservice) {
+	case(Subservice::COMMAND_SET_HEALTH):
+	case(Subservice::COMMAND_ANNOUNCE_HEALTH):
+	case(Subservice::COMMAND_ANNOUNCE_HEALTH_ALL):
+		return RETURN_OK;
+	default:
+		sif::error << "Invalid Subservice" << std::endl;
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t CService201HealthCommanding::getMessageQueueAndObject(
+        uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+        MessageQueueId_t *id, object_id_t *objectId) {
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG);
+
+    return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
+        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+    HasHealthIF * destination = objectManager->get<HasHealthIF>(*objectId);
+    if(destination == nullptr) {
+        return CommandingServiceBase::INVALID_OBJECT;
+    }
+
+    *messageQueueToSet = destination->getCommandQueue();
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CService201HealthCommanding::prepareCommand(
+        CommandMessage* message, uint8_t subservice, const uint8_t *tcData,
+		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    switch(subservice) {
+    case(Subservice::COMMAND_SET_HEALTH): {
+        HealthSetCommand healthCommand;
+        result = healthCommand.deSerialize(&tcData, &tcDataLen,
+                SerializeIF::Endianness::BIG);
+        if (result != RETURN_OK) {
+            break;
+        }
+        HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_SET,
+                healthCommand.getHealth());
+        break;
+    }
+    case(Subservice::COMMAND_ANNOUNCE_HEALTH): {
+        HealthMessage::setHealthMessage(message,
+                HealthMessage::HEALTH_ANNOUNCE);
+        break;
+    }
+    case(Subservice::COMMAND_ANNOUNCE_HEALTH_ALL): {
+        HealthMessage::setHealthMessage(message,
+                HealthMessage::HEALTH_ANNOUNCE_ALL);
+        break;
+    }
+    }
+    return result;
+}
+
+ReturnValue_t CService201HealthCommanding::handleReply
+		(const CommandMessage* reply, Command_t previousCommand,
+		uint32_t *state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool *isStep) {
+	Command_t replyId = reply->getCommand();
+	if (replyId == HealthMessage::REPLY_HEALTH_SET) {
+		return prepareHealthSetReply(reply);
+	}
+	return CommandingServiceBase::INVALID_REPLY;
+}
+
+ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(
+        const CommandMessage* reply) {
+	prepareHealthSetReply(reply);
+	uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
+	uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
+	HealthSetReply healthSetReply(health, oldHealth);
+	return sendTmPacket(Subservice::REPLY_HEALTH_SET, &healthSetReply);
+}
+
diff --git a/pus/CService201HealthCommanding.h b/pus/CService201HealthCommanding.h
new file mode 100644
index 000000000..124e2ac79
--- /dev/null
+++ b/pus/CService201HealthCommanding.h
@@ -0,0 +1,63 @@
+#ifndef FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
+#define FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
+
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief   Custom PUS service to set health of all objects
+ *          implementing hasHealthIF.
+ *
+ * Examples: Device Handlers, Assemblies or Subsystems.
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * This service is very closely tied to the Commanding Service Base template
+ * class. There is constant interaction between this Service Base und a
+ * child class like this service
+ *
+ */
+class CService201HealthCommanding: public CommandingServiceBase {
+public:
+
+	CService201HealthCommanding(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId, uint8_t numParallelCommands = 4,
+	        uint16_t commandTimeoutSeconds = 60);
+	virtual~ CService201HealthCommanding();
+protected:
+	/* CSB abstract function implementations */
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	/** Prepare health command */
+	ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) override;
+	/** Handle health reply */
+	ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) override;
+
+private:
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
+
+	ReturnValue_t prepareHealthSetReply(const CommandMessage *reply);
+
+	enum Subservice {
+	    //! [EXPORT] : [TC] Set health of target object
+		COMMAND_SET_HEALTH = 1,
+		//! [EXPORT] : [TM] Reply to health set command which also provides old health
+		REPLY_HEALTH_SET = 2,
+		//! [EXPORT] : [TC] Commands object to announce their health as an event
+		COMMAND_ANNOUNCE_HEALTH = 3,
+		//! [EXPORT] : [TC] Commands all objects in the health map to announce their health
+		COMMAND_ANNOUNCE_HEALTH_ALL = 4
+	};
+};
+
+#endif /* FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_ */

From 257e3e2db9297afc460b2590111033c3e3b25e32 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 15:03:49 +0100
Subject: [PATCH 1043/1774] change log update

---
 CHANGELOG | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index 4937b5f8c..a4951a41c 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -5,3 +5,5 @@
 
 - vRequestContextSwitchFromISR is declared extern "C" so it can be defined in
 a C file without issues
+
+- PUS Health Service added, which allows to command and retrieve health via PUS packets

From c72ba92247a2d1d13b5d12291a304c46ac56cfa5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 15:05:54 +0100
Subject: [PATCH 1044/1774] health service update

---
 pus/CService201HealthCommanding.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index db43db898..edacd73a5 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -86,11 +86,15 @@ ReturnValue_t CService201HealthCommanding::handleReply
 		object_id_t objectId, bool *isStep) {
 	Command_t replyId = reply->getCommand();
 	if (replyId == HealthMessage::REPLY_HEALTH_SET) {
-		return prepareHealthSetReply(reply);
+		return EXECUTION_COMPLETE;
+	}
+	else if(replyId == CommandMessageIF::REPLY_REJECTED) {
+		return reply->getReplyRejectedReason();
 	}
 	return CommandingServiceBase::INVALID_REPLY;
 }
 
+// Not used for now, health state already reported by event
 ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(
         const CommandMessage* reply) {
 	prepareHealthSetReply(reply);

From 0b32d3dac838aab62979031c5d33c51f0086b632 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 15:10:23 +0100
Subject: [PATCH 1045/1774] change log update

---
 CHANGELOG | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index 4937b5f8c..c877c1edc 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -5,3 +5,7 @@
 
 - vRequestContextSwitchFromISR is declared extern "C" so it can be defined in
 a C file without issues
+
+### PUS Services
+
+- It is now possible to change the message queue depth for the telecommand verification service (PUS1)

From c9bfc0bbfd87797d75b6d1049e066e649e1714dd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 15:22:18 +0100
Subject: [PATCH 1046/1774] change log update

---
 CHANGELOG | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index 4937b5f8c..c0c826a74 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -5,3 +5,8 @@
 
 - vRequestContextSwitchFromISR is declared extern "C" so it can be defined in
 a C file without issues
+
+### Device Handler Base
+
+- There is an additional `PERFORM_OPERATION` step for the device handler base. It is important
+that DHB users adapt their polling sequence tables to perform this step. This steps allows for aclear distinction between operation and communication steps

From 0a016f391a7d6ae6eb062e29e4dd494987a16799 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 15:26:06 +0100
Subject: [PATCH 1047/1774] changelog update

---
 CHANGELOG | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG b/CHANGELOG
index fc2fe7e58..a6686478c 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -9,4 +9,5 @@ a C file without issues
 ### PUS Services
 
 - It is now possible to change the message queue depth for the telecommand verification service (PUS1)
+- The same is possible for the event reporting service (PUS5)
 - PUS Health Service added, which allows to command and retrieve health via PUS packets

From 8c14cdfbd84654b6761f96769cdefdc98f542043 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 15:34:56 +0100
Subject: [PATCH 1048/1774] changelog update

---
 CHANGELOG | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG b/CHANGELOG
index 35547c2ce..16275d7aa 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -14,4 +14,4 @@ a C file without issues
 
 ### Local Pool
 
-- Interface of LocalPools has change. LocalPool is not a template anymore. Instead the size and bucket number of the pools per page and the number of pages are passed to the ctor instead of two ctor arguments and a template parameter
+- Interface of LocalPools has changed. LocalPool is not a template anymore. Instead the size and bucket number of the pools per page and the number of pages are passed to the ctor instead of two ctor arguments and a template parameter

From b198a6c13ca705dc4ab17f14b4503da6e92f2337 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 16:04:40 +0100
Subject: [PATCH 1049/1774] added packet

---
 pus/servicepackets/Service201Packets.h | 48 ++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 pus/servicepackets/Service201Packets.h

diff --git a/pus/servicepackets/Service201Packets.h b/pus/servicepackets/Service201Packets.h
new file mode 100644
index 000000000..aed821f98
--- /dev/null
+++ b/pus/servicepackets/Service201Packets.h
@@ -0,0 +1,48 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
+
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serialize/SerializeIF.h"
+#include "../../health/HasHealthIF.h"
+
+class HealthSetCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1
+public:
+
+	HealthSetCommand() {
+		setLinks();
+	}
+
+	HasHealthIF::HealthState getHealth() {
+		return static_cast<HasHealthIF::HealthState>(health.entry);
+	}
+private:
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&health);
+	}
+	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Target object Id
+	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] Health to set
+};
+
+
+class HealthSetReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 2
+public:
+	HealthSetReply(uint8_t health_, uint8_t oldHealth_):
+		health(health_), oldHealth(oldHealth_)
+	{
+		setLinks();
+	}
+
+private:
+	HealthSetReply(const HealthSetReply &reply);
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&health);
+		health.setNext(&oldHealth);
+	}
+	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Source object ID
+	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] New Health
+	SerializeElement<uint8_t> oldHealth; //!< [EXPORT] : [COMMENT] Old Health
+};
+
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_ */

From 29eb7200711c771182e14ea770a5f074f44d8093 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 16:22:59 +0100
Subject: [PATCH 1050/1774] introducing relative includes

---
 unittest/internal/osal/IntTestMutex.cpp              | 2 +-
 unittest/internal/osal/IntTestSemaphore.cpp          | 2 +-
 unittest/internal/serialize/IntTestSerialization.cpp | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index 3fd668dfd..2899535aa 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -1,7 +1,7 @@
 #include "IntTestMutex.h"
 
 #include <fsfw/ipc/MutexFactory.h>
-#include <unittest/internal/UnittDefinitions.h>
+#include "../UnittDefinitions.h"
 
 #if defined(hosted)
 #include <fsfw/osal/hosted/Mutex.h>
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index 534a6a6d5..130fc8aea 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -1,6 +1,6 @@
 #include "IntTestSemaphore.h"
 #include <fsfw/tasks/SemaphoreFactory.h>
-#include <unittest/internal/UnittDefinitions.h>
+#include "../UnittDefinitions.h"
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 #include <fsfw/timemanager/Stopwatch.h>
 
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
index 3f231a417..031fd6fe2 100644
--- a/unittest/internal/serialize/IntTestSerialization.cpp
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -1,7 +1,7 @@
 #include "IntTestSerialization.h"
 #include <fsfw/serialize/SerializeElement.h>
 #include <fsfw/serialize/SerialBufferAdapter.h>
-#include <unittest/internal/UnittDefinitions.h>
+#include "../UnittDefinitions.h"
 #include <fsfw/serialize/SerializeIF.h>
 #include <array>
 

From 8cddf8f509c62ebc0481fba1487efc658e0c95ee Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 16:24:38 +0100
Subject: [PATCH 1051/1774] more relative includes

---
 unittest/internal/InternalUnitTester.h               | 2 +-
 unittest/internal/serialize/IntTestSerialization.cpp | 7 ++++---
 unittest/internal/serialize/IntTestSerialization.h   | 9 +++++----
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/unittest/internal/InternalUnitTester.h b/unittest/internal/InternalUnitTester.h
index b301b9232..d0b1c106d 100644
--- a/unittest/internal/InternalUnitTester.h
+++ b/unittest/internal/InternalUnitTester.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_TEST_UNITTESTCLASS_H_
 
 #include "UnittDefinitions.h"
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 /**
  * @brief	Can be used for internal testing, for example for hardware specific
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
index 031fd6fe2..1e33ff335 100644
--- a/unittest/internal/serialize/IntTestSerialization.cpp
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -1,8 +1,9 @@
 #include "IntTestSerialization.h"
-#include <fsfw/serialize/SerializeElement.h>
-#include <fsfw/serialize/SerialBufferAdapter.h>
 #include "../UnittDefinitions.h"
-#include <fsfw/serialize/SerializeIF.h>
+#include "../../serialize/SerializeElement.h"
+#include "../../serialize/SerialBufferAdapter.h"
+#include "../../serialize/SerializeIF.h"
+
 #include <array>
 
 using retval = HasReturnvaluesIF;
diff --git a/unittest/internal/serialize/IntTestSerialization.h b/unittest/internal/serialize/IntTestSerialization.h
index f8841b820..e8dbd35a0 100644
--- a/unittest/internal/serialize/IntTestSerialization.h
+++ b/unittest/internal/serialize/IntTestSerialization.h
@@ -1,6 +1,7 @@
-#ifndef UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
-#define UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#ifndef FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
+#define FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
 #include <array>
 
 namespace testserialize {
@@ -12,4 +13,4 @@ ReturnValue_t test_serial_buffer_adapter();
 extern std::array<uint8_t, 512> test_array;
 }
 
-#endif /* UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_ */
+#endif /* FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_ */

From c741ef3945b1536f45a7cac4fd08c5029c536083 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 16:50:02 +0100
Subject: [PATCH 1052/1774] using relative includes now

---
 unittest/internal/UnittDefinitions.cpp      | 2 +-
 unittest/internal/osal/IntTestMq.cpp        | 9 +++++----
 unittest/internal/osal/IntTestMutex.cpp     | 6 +++---
 unittest/internal/osal/IntTestSemaphore.cpp | 7 ++++---
 4 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index 0bdbfcc72..6265e9fdb 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/unittest/internal/UnittDefinitions.h>
+#include "UnittDefinitions.h"
 
  ReturnValue_t unitt::put_error(std::string errorId) {
 	sif::error << "Unit Tester error: Failed at test ID "
diff --git a/unittest/internal/osal/IntTestMq.cpp b/unittest/internal/osal/IntTestMq.cpp
index 630163743..8d95f51ed 100644
--- a/unittest/internal/osal/IntTestMq.cpp
+++ b/unittest/internal/osal/IntTestMq.cpp
@@ -1,7 +1,8 @@
-#include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/ipc/QueueFactory.h>
-#include <fsfw/unittest/internal/osal/IntTestMq.h>
-#include <fsfw/unittest/internal/UnittDefinitions.h>
+#include "IntTestMq.h"
+#include "../UnittDefinitions.h"
+
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/QueueFactory.h"
 
 #include <array>
 
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index 2899535aa..015813470 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -1,10 +1,10 @@
 #include "IntTestMutex.h"
 
-#include <fsfw/ipc/MutexFactory.h>
+#include "../../ipc/MutexFactory.h"
 #include "../UnittDefinitions.h"
 
 #if defined(hosted)
-#include <fsfw/osal/hosted/Mutex.h>
+#include "../../osal/hosted/Mutex.h"
 #include <thread>
 #include <future>
 #endif
@@ -20,7 +20,7 @@ void testmutex::testMutex() {
 	// timed_mutex from the C++ library specifies undefined behaviour if
 	// the timed mutex is locked twice from the same thread.
 #if defined(hosted)
-	// hold on, this actually worked ? :-D This calls the function from
+	// This calls the function from
 	// another thread and stores the returnvalue in a future.
 	auto future = std::async(&MutexIF::lockMutex, mutex, 1);
 	result = future.get();
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index 130fc8aea..f260b6a51 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -1,8 +1,9 @@
 #include "IntTestSemaphore.h"
-#include <fsfw/tasks/SemaphoreFactory.h>
 #include "../UnittDefinitions.h"
-#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
-#include <fsfw/timemanager/Stopwatch.h>
+
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Stopwatch.h"
 
 
 void testsemaph::testBinSemaph() {

From a0689320d1e72cb41a1059a4c1254d3533cb7d8e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 16:55:24 +0100
Subject: [PATCH 1053/1774] more include fixes

---
 unittest/tests/container/RingBufferTest.cpp           | 4 ++--
 unittest/tests/container/TestArrayList.cpp            | 5 +++--
 unittest/tests/container/TestDynamicFifo.cpp          | 6 +++---
 unittest/tests/container/TestFifo.cpp                 | 6 +++---
 unittest/tests/container/TestFixedArrayList.cpp       | 4 ++--
 unittest/tests/container/TestFixedOrderedMultimap.cpp | 4 ++--
 unittest/tests/osal/TestMessageQueue.cpp              | 8 ++++----
 unittest/tests/serialize/TestSerialLinkedPacket.cpp   | 7 ++++---
 unittest/tests/serialize/TestSerialization.cpp        | 2 +-
 9 files changed, 24 insertions(+), 22 deletions(-)

diff --git a/unittest/tests/container/RingBufferTest.cpp b/unittest/tests/container/RingBufferTest.cpp
index 8b82d407f..9c1c8a23b 100644
--- a/unittest/tests/container/RingBufferTest.cpp
+++ b/unittest/tests/container/RingBufferTest.cpp
@@ -1,7 +1,7 @@
-#include <fsfw/container/SimpleRingBuffer.h>
-#include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
+#include "../../container/SimpleRingBuffer.h"
 
+#include <catch2/catch.hpp>
 #include <cstring>
 
 TEST_CASE("Ring Buffer Test" , "[RingBufferTest]") {
diff --git a/unittest/tests/container/TestArrayList.cpp b/unittest/tests/container/TestArrayList.cpp
index 914188cb7..2f8842764 100644
--- a/unittest/tests/container/TestArrayList.cpp
+++ b/unittest/tests/container/TestArrayList.cpp
@@ -1,5 +1,6 @@
-#include <fsfw/container/ArrayList.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/ArrayList.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
 
diff --git a/unittest/tests/container/TestDynamicFifo.cpp b/unittest/tests/container/TestDynamicFifo.cpp
index 6c9b7415d..bb19131eb 100644
--- a/unittest/tests/container/TestDynamicFifo.cpp
+++ b/unittest/tests/container/TestDynamicFifo.cpp
@@ -1,7 +1,7 @@
 
-#include <fsfw/container/DynamicFIFO.h>
-#include <fsfw/container/FIFO.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/DynamicFIFO.h"
+#include "../../container/FIFO.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch.hpp>
 #include <CatchDefinitions.h>
diff --git a/unittest/tests/container/TestFifo.cpp b/unittest/tests/container/TestFifo.cpp
index 3775f4242..bd727e00c 100644
--- a/unittest/tests/container/TestFifo.cpp
+++ b/unittest/tests/container/TestFifo.cpp
@@ -1,7 +1,7 @@
 
-#include <fsfw/container/DynamicFIFO.h>
-#include <fsfw/container/FIFO.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/DynamicFIFO.h"
+#include "../../container/FIFO.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
diff --git a/unittest/tests/container/TestFixedArrayList.cpp b/unittest/tests/container/TestFixedArrayList.cpp
index 737932e36..5a1bd280a 100644
--- a/unittest/tests/container/TestFixedArrayList.cpp
+++ b/unittest/tests/container/TestFixedArrayList.cpp
@@ -1,7 +1,7 @@
 #include "../../core/CatchDefinitions.h"
 
-#include <fsfw/container/FixedArrayList.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/FixedArrayList.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch2/catch.hpp>
 
diff --git a/unittest/tests/container/TestFixedOrderedMultimap.cpp b/unittest/tests/container/TestFixedOrderedMultimap.cpp
index 95194cb5a..e625b5599 100644
--- a/unittest/tests/container/TestFixedOrderedMultimap.cpp
+++ b/unittest/tests/container/TestFixedOrderedMultimap.cpp
@@ -1,5 +1,5 @@
-#include <fsfw/container/FixedOrderedMultimap.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/FixedOrderedMultimap.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
diff --git a/unittest/tests/osal/TestMessageQueue.cpp b/unittest/tests/osal/TestMessageQueue.cpp
index 8e59fa084..441d32e7d 100644
--- a/unittest/tests/osal/TestMessageQueue.cpp
+++ b/unittest/tests/osal/TestMessageQueue.cpp
@@ -1,8 +1,8 @@
-#include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/ipc/QueueFactory.h>
-#include "catch.hpp"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/QueueFactory.h"
+#include <catch.hpp>
 #include <array>
-#include "core/CatchDefinitions.h"
+#include "../../core/CatchDefinitions.h"
 
 TEST_CASE("MessageQueue Basic Test","[TestMq]") {
 	MessageQueueIF* testSenderMq =
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.cpp b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
index 0a09e430c..fbe488946 100644
--- a/unittest/tests/serialize/TestSerialLinkedPacket.cpp
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
@@ -1,8 +1,9 @@
-#include <fsfw/globalfunctions/arrayprinter.h>
+#include "TestSerialLinkedPacket.h"
+#include "../../core/CatchDefinitions.h"
+
+#include "../../globalfunctions/arrayprinter.h"
 
 #include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
-#include "TestSerialLinkedPacket.h"
 
 
 TEST_CASE("Serial Linked Packet" , "[SerLinkPacket]") {
diff --git a/unittest/tests/serialize/TestSerialization.cpp b/unittest/tests/serialize/TestSerialization.cpp
index 4c9ba1818..6e31170a1 100644
--- a/unittest/tests/serialize/TestSerialization.cpp
+++ b/unittest/tests/serialize/TestSerialization.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/serialize/SerializeAdapter.h>
+#include "../../serialize/SerializeAdapter.h"
 
 #include "catch.hpp"
 #include <array>

From 36b76fa07ca7aac38815a315d04cb6c0aa14ef10 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:04:33 +0100
Subject: [PATCH 1054/1774] testcfg update

---
 unittest/testcfg/FSFWConfig.h | 29 ++++++++++++++++++++---------
 1 file changed, 20 insertions(+), 9 deletions(-)

diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 4fb224c15..1386bf66f 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -1,18 +1,19 @@
 #ifndef CONFIG_FSFWCONFIG_H_
 #define CONFIG_FSFWCONFIG_H_
 
-#include <FSFWVersion.h>
+#include <cstddef>
+#include <cstdint>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrese code size
+//! Reduced printout to further decrease code size
 //! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_REDUCED_PRINTOUT		0
+#define FSFW_ENHANCED_PRINTOUT		0
 
-//! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_DEBUGGING              0
+//! Can be used to enable additional debugging printouts for developing the FSFW
+#define FSFW_PRINT_VERBOSITY_LEVEL   0
 
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle
@@ -25,9 +26,6 @@
 //! and translateEvents (and their compiled source files)
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
-//! If -DDEBUG is supplied in the build defines, there will be
-//! additional output which requires the translation files translateObjects
-//! and translateEvents (and their compiles source files)
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 #define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
@@ -40,7 +38,20 @@
 
 //! When using the newlib nano library, C99 support for stdio facilities
 //! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NO_C99_IO 	1
+#define FSFW_NO_C99_IO 	            1
 
+//! Specify whether a special mode store is used for Subsystem components.
+#define FSFW_USE_MODESTORE          0
+
+namespace fsfwconfig {
+//! Default timestamp size. The default timestamp will be an eight byte CDC
+//! short timestamp.
+static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 8;
+
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+}
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

From 51b9e0074b027b1982fc6354c8c6e8c13cb68458 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:06:05 +0100
Subject: [PATCH 1055/1774] Revert "testcfg update"

This reverts commit 36b76fa07ca7aac38815a315d04cb6c0aa14ef10.
---
 unittest/testcfg/FSFWConfig.h | 29 +++++++++--------------------
 1 file changed, 9 insertions(+), 20 deletions(-)

diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 1386bf66f..4fb224c15 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -1,19 +1,18 @@
 #ifndef CONFIG_FSFWCONFIG_H_
 #define CONFIG_FSFWCONFIG_H_
 
-#include <cstddef>
-#include <cstdint>
+#include <FSFWVersion.h>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrease code size
+//! Reduced printout to further decrese code size
 //! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_ENHANCED_PRINTOUT		0
+#define FSFW_REDUCED_PRINTOUT		0
 
-//! Can be used to enable additional debugging printouts for developing the FSFW
-#define FSFW_PRINT_VERBOSITY_LEVEL   0
+//! Can be used to enable debugging printouts for developing the FSFW
+#define FSFW_DEBUGGING              0
 
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle
@@ -26,6 +25,9 @@
 //! and translateEvents (and their compiled source files)
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
+//! If -DDEBUG is supplied in the build defines, there will be
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiles source files)
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 #define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
@@ -38,20 +40,7 @@
 
 //! When using the newlib nano library, C99 support for stdio facilities
 //! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NO_C99_IO 	            1
+#define FSFW_NO_C99_IO 	1
 
-//! Specify whether a special mode store is used for Subsystem components.
-#define FSFW_USE_MODESTORE          0
-
-namespace fsfwconfig {
-//! Default timestamp size. The default timestamp will be an eight byte CDC
-//! short timestamp.
-static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 8;
-
-//! Configure the allocated pool sizes for the event manager.
-static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
-static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
-static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
-}
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

From 5eb2cbde0eb117fff237d531d113f3a79b89f15a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:08:03 +0100
Subject: [PATCH 1056/1774] some additional ionclude fixes

---
 unittest/tests/container/TestFixedMap.cpp            | 4 ++--
 unittest/tests/serialize/TestSerialBufferAdapter.cpp | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/unittest/tests/container/TestFixedMap.cpp b/unittest/tests/container/TestFixedMap.cpp
index 079062f00..da0c84e3e 100644
--- a/unittest/tests/container/TestFixedMap.cpp
+++ b/unittest/tests/container/TestFixedMap.cpp
@@ -1,5 +1,5 @@
-#include <fsfw/container/FixedMap.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/FixedMap.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
diff --git a/unittest/tests/serialize/TestSerialBufferAdapter.cpp b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
index 9919ed844..07cd3f9c5 100644
--- a/unittest/tests/serialize/TestSerialBufferAdapter.cpp
+++ b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/serialize/SerialBufferAdapter.h>
+#include "../../serialize/SerialBufferAdapter.h"
 
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"

From 29e701d14df9ffe6e4d2c891a26facbc3a4e7af2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:08:46 +0100
Subject: [PATCH 1057/1774] op divider additional features

---
 globalfunctions/PeriodicOperationDivider.cpp | 14 ++++++++++++--
 globalfunctions/PeriodicOperationDivider.h   | 12 +++++++++++-
 2 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/globalfunctions/PeriodicOperationDivider.cpp b/globalfunctions/PeriodicOperationDivider.cpp
index ad3b8bbd5..28e98feba 100644
--- a/globalfunctions/PeriodicOperationDivider.cpp
+++ b/globalfunctions/PeriodicOperationDivider.cpp
@@ -7,16 +7,26 @@ PeriodicOperationDivider::PeriodicOperationDivider(uint32_t divider,
 }
 
 bool PeriodicOperationDivider::checkAndIncrement() {
-	if(counter >= divider) {
+	bool opNecessary = check();
+	if(opNecessary) {
 		if(resetAutomatically) {
 			counter = 0;
 		}
-		return true;
+		return opNecessary;
 	}
 	counter ++;
+	return opNecessary;
+}
+
+bool PeriodicOperationDivider::check() {
+	if(counter >= divider) {
+		return true;
+	}
 	return false;
 }
 
+
+
 void PeriodicOperationDivider::resetCounter() {
 	counter = 0;
 }
diff --git a/globalfunctions/PeriodicOperationDivider.h b/globalfunctions/PeriodicOperationDivider.h
index dd970fb8a..7f7fb4697 100644
--- a/globalfunctions/PeriodicOperationDivider.h
+++ b/globalfunctions/PeriodicOperationDivider.h
@@ -21,17 +21,27 @@ public:
 	 */
 	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();
 
+	/**
+	 * Checks whether an operation is necessary.
+	 * This function will not increment the counter!
+	 * @return
+	 * -@c true if the counter is larger or equal to the divider
+	 * -@c false otherwise
+	 */
+	bool check();
+
 	/**
 	 * Can be used to reset the counter to 0 manually.
 	 */

From e0f063f232f92931f17d874de122d9c30c795d73 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:14:44 +0100
Subject: [PATCH 1058/1774] comment added

---
 memory/HasFileSystemIF.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 20ef727eb..dcec6346e 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -8,7 +8,9 @@
 #include <cstddef>
 
 /**
- * @author  Jakob Meier
+ * @brief	Generic interface for objects which expose a file system to enable
+ * 			message based file handling.
+ * @author  J. Meier, R. Mueller
  */
 class HasFileSystemIF {
 public:

From 09caeffbc7a82ee262723ec13933fe65fc10be0f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:15:25 +0100
Subject: [PATCH 1059/1774] added new interface for file systems

---
 memory/HasFileSystemIF.h | 80 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 memory/HasFileSystemIF.h

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
new file mode 100644
index 000000000..dcec6346e
--- /dev/null
+++ b/memory/HasFileSystemIF.h
@@ -0,0 +1,80 @@
+#ifndef FSFW_MEMORY_HASFILESYSTEMIF_H_
+#define FSFW_MEMORY_HASFILESYSTEMIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../returnvalues/FwClassIds.h"
+#include "../ipc/messageQueueDefinitions.h"
+
+#include <cstddef>
+
+/**
+ * @brief	Generic interface for objects which expose a file system to enable
+ * 			message based file handling.
+ * @author  J. Meier, R. Mueller
+ */
+class HasFileSystemIF {
+public:
+    static constexpr uint8_t INTERFACE_ID = CLASS_ID::FILE_SYSTEM;
+
+    static constexpr ReturnValue_t FILE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x00);
+    static constexpr ReturnValue_t FILE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+    static constexpr ReturnValue_t FILE_LOCKED = MAKE_RETURN_CODE(0x02);
+
+    static constexpr ReturnValue_t DIRECTORY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+    static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x04);
+    static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(0x05);
+
+
+    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_WRITE = MAKE_RETURN_CODE(0x06); //! P1: Sequence number missing
+    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_READ = MAKE_RETURN_CODE(0x07); //! P1: Sequence number missing
+
+	virtual ~HasFileSystemIF() {}
+	/**
+	 * Function to get the MessageQueueId_t of the implementing object
+	 * @return MessageQueueId_t of the object
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+	/**
+	 * Generic function to append to file.
+	 * @param dirname Directory of the file
+	 * @param filename The filename of the file
+	 * @param data The data to write to the file
+	 * @param size The size of the data to write
+	 * @param packetNumber Current packet number. Can be used to verify that
+	 * there are no missing packets.
+	 * @param args Any other arguments which an implementation might require.
+	 * @param bytesWritten Actual bytes written to file
+	 * For large files the write procedure must be split in multiple calls
+	 * to writeToFile
+	 */
+	virtual ReturnValue_t appendToFile(const char* repositoryPath,
+	        const char* filename, const uint8_t* data, size_t size,
+	        uint16_t packetNumber, void* args = nullptr) = 0;
+
+	/**
+	 * Generic function to create a new file.
+	 * @param repositoryPath
+	 * @param filename
+	 * @param data
+	 * @param size
+	 * @param args Any other arguments which an implementation might require.
+	 * @return
+	 */
+	virtual ReturnValue_t createFile(const char* repositoryPath,
+	        const char* filename, const uint8_t* data = nullptr,
+	        size_t size = 0, void* args = nullptr) = 0;
+
+	/**
+	 * Generic function to delete a file.
+	 * @param repositoryPath
+	 * @param filename
+	 * @param args
+	 * @return
+	 */
+	virtual ReturnValue_t deleteFile(const char* repositoryPath,
+	        const char* filename, void* args = nullptr) = 0;
+};
+
+
+#endif /* FSFW_MEMORY_HASFILESYSTEMIF_H_ */

From f1c5f192134656c7bf2683cb2497cef81cbc747b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:17:53 +0100
Subject: [PATCH 1060/1774] changelog update

---
 CHANGELOG | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index a6686478c..2791c761b 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -11,3 +11,7 @@ a C file without issues
 - It is now possible to change the message queue depth for the telecommand verification service (PUS1)
 - The same is possible for the event reporting service (PUS5)
 - PUS Health Service added, which allows to command and retrieve health via PUS packets
+
+### File System Interface
+
+- A new interfaces specifies the functions for a software object which exposes the file system of a given hardware to use message based file handling (e.g. PUS commanding)

From 314dc577b547f734ef32b0552d109a9b5f88e7b4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:19:00 +0100
Subject: [PATCH 1061/1774] added changelog from upstream

---
 CHANGELOG | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 CHANGELOG

diff --git a/CHANGELOG b/CHANGELOG
new file mode 100644
index 000000000..a6686478c
--- /dev/null
+++ b/CHANGELOG
@@ -0,0 +1,13 @@
+## Changes from ASTP 0.0.1 to 1.0.0
+
+
+### FreeRTOS OSAL
+
+- vRequestContextSwitchFromISR is declared extern "C" so it can be defined in
+a C file without issues
+
+### PUS Services
+
+- It is now possible to change the message queue depth for the telecommand verification service (PUS1)
+- The same is possible for the event reporting service (PUS5)
+- PUS Health Service added, which allows to command and retrieve health via PUS packets

From 84ab5f83189481909f23dc7016082f51010fdfa0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:19:26 +0100
Subject: [PATCH 1062/1774] readme and logo update

---
 README.md                | 161 ++++++++-
 logo/FSFW_Logo_V3.png    | Bin 0 -> 137423 bytes
 logo/FSFW_Logo_V3.svg    | 711 +++++++++++++++++++++++++++++++++++++++
 logo/FSFW_Logo_V3_bw.png | Bin 0 -> 13369 bytes
 4 files changed, 869 insertions(+), 3 deletions(-)
 create mode 100644 logo/FSFW_Logo_V3.png
 create mode 100644 logo/FSFW_Logo_V3.svg
 create mode 100644 logo/FSFW_Logo_V3_bw.png

diff --git a/README.md b/README.md
index fc86fca7c..4aabe36a9 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,159 @@
-Flight Software Framework (FSFW)
-======
+![FSFW Logo](logo/FSFW_Logo_V3_bw.png)
+# Flight Software Framework (FSFW)
 
-I want to be written!
+The Flight Software Framework is a C++ Object Oriented Framework for unmanned,
+automated systems like Satellites. 
+
+The initial version of the Flight Software Framework was developed during
+the Flying Laptop Project by the University of Stuttgart in cooperation
+with Airbus Defence and Space GmbH.
+
+## Intended Use
+
+The framework is designed for systems, which communicate with external devices, perform control loops, receive telecommands and send telemetry, and need to maintain a high level of availability. 
+Therefore, a mode and health system provides control over the states of the software and the controlled devices. 
+In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 
+
+The recommended hardware is a microprocessor with more than 2 MB of RAM and 1 MB of non-volatile Memory. 
+For reference, current Applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC.
+
+
+## Structure
+
+The general structure is driven by the usage of interfaces provided by objects. The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
+The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
+This simplifies the instantiation of objects and allows the usage of some standard containers. 
+Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
+The fsfw uses Run-time type information.
+Exceptions are not allowed.
+
+### Failure Handling
+
+Functions should return a defined ReturnValue_t to signal to the caller that something is gone wrong. 
+Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
+The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
+
+### OSAL
+The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. A independent OSAL called "host" is currently not finished. This aims to be running on windows as well. 
+The OSAL provides periodic tasks, message queues, clocks and Semaphores as well as Mutexes.
+
+### Core Components 
+
+Clock:
+ * This is a class of static functions that can be used at anytime
+ * Leap Seconds must be set if any time conversions from UTC to other times is used
+
+ObjectManager (must be created): 
+
+* The component which handles all references. All SystemObjects register at this component. 
+* Any SystemObject needs to have a unique ObjectId. Those can be managed like objects::framework_objects.
+* A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
+A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
+
+``` c++
+	template <typename T> T* ObjectManagerIF::get( object_id_t id )
+
+```
+* A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
+By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.
+
+Event Manager:
+
+* Component which allows routing of events
+* Other objects can subscribe to specific events, ranges of events or all events of an object.
+* Subscriptions can be done during runtime but should be done during initialization
+* Amounts of allowed subscriptions must be configured by setting this parameters:
+
+``` c++
+namespace fsfwconfig {
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+}
+```
+
+
+Health Table:
+
+* A component which holds every health state 
+* Provides a thread safe way to access all health states without the need of message exchanges
+
+Stores
+
+* The message based communication can only exchange a few bytes of information inside the message itself. Therefore, additional information can be exchanged with Stores. With this, only the store address must be exchanged in the message.
+* Internally, the FSFW uses an IPC Store to exchange data between processes. For incoming TCs a TC Store is used. For outgoing TM a TM store is used.
+* All of them should use the Thread Safe Class storagemanager/PoolManager
+
+Tasks
+
+There are two different types of tasks:
+ * The PeriodicTask just executes objects that are of type ExecutableObjectIF in the order of the insertion to the Tasks.
+ * FixedTimeslotTask executes a list of calls in the order of the given list. This is intended for DeviceHandlers, where polling should be in a defined order. An example can be found in defaultcfg/fsfwconfig/pollingSequence
+
+
+### Static Ids in the framework
+
+Some parts of the framework use a static routing address for communication. 
+An example setup of ids can be found in the example config in "defaultcft/fsfwconfig/objects/Factory::setStaticFrameworkObjectIds()".
+
+### Events
+
+Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. This works analog to the returnvalues.
+Every object that needs own EventIds has to get a unique SUBSYSTEM_ID. 
+Every SystemObject can call triggerEvent from the parent class.
+Therefore, event messages contain the specific EventId and the objectId of the object that has triggered.
+
+### Internal Communication
+
+Components communicate mostly over Message through Queues. 
+Those queues are created by calling the singleton QueueFactory::instance()->create(). 
+
+### External Communication
+
+The external communication with the mission control system is mostly up to the user implementation.
+The FSFW provides PUS Services which can be used to but don't need to be used. 
+The services can be seen as a conversion from a TC to a message based communication and back.
+
+#### CCSDS Frames, CCSDS Space Packets and PUS
+
+If the communication is based on CCSDS Frames and Space Packets, several classes can be used to distributed the packets to the corresponding services. Those can be found in tcdistribution. 
+If Space Packets are used, a timestamper must be created. 
+An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
+
+#### DeviceHandling
+
+DeviceHandlers are a core component of the FSFW. 
+The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
+By separating the underlying Communication Interface with DeviceCommunicationIF, a DH can be tested on different hardware.
+The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
+A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
+
+#### Modes, Health
+
+The two interfaces HasModesIF and HasHealthIF provide access for commanding and monitoring of components.
+On-board Mode Management is implement in hierarchy system. 
+DeviceHandlers and Controllers are the lowest part of the hierarchy. 
+The next layer are Assemblies. Those assemblies act as a component which handle redundancies of handlers. 
+Assemblies share a common core with the next level which are the Subsystems. 
+
+Those Assemblies are intended to act as auto-generated components from a database which describes the subsystem modes. 
+The definitions contain transition and target tables which contain the DH, Assembly and Controller Modes to be commanded.
+Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a switch into any higher AOCS mode might first turn on the sensors, than the actuators and the controller as last component. 
+The target table is used to describe the state that is checked continuously by the subsystem. 
+All of this allows System Modes to be generated as Subsystem object as well from the same database. 
+This System contains list of subsystem modes in the transition and target tables. 
+Therefore, it allows a modular system to create system modes and easy commanding of those, because only the highest components must be commanded.
+
+The health state represents if the component is able to perform its tasks. 
+This can be used to signal the system to avoid using this component instead of a redundant one.
+The on-board FDIR uses the health state for isolation and recovery. 
+
+## Example config
+
+A example config can be found in defaultcfg/fsfwconfig.
+
+## Unit Tests
+
+Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. 
+See README.md in the unittest Folder.
\ No newline at end of file
diff --git a/logo/FSFW_Logo_V3.png b/logo/FSFW_Logo_V3.png
new file mode 100644
index 0000000000000000000000000000000000000000..2ac710dd2069446e8f10108716f4c0e97bc961b9
GIT binary patch
literal 137423
zcmYIv1yI!A_ckHYDcy}UOCzN;E1^qwcY}1N^s+Qk(t;pe(%mJ}-AKa%OY>j-&hLGh
zVRqSJKlj`d&wWnZs1GXg*cjv(2nYz+iV89y1cVn+2nZ;gXfNTPcqtGP!e3svNhzwM
z!GHYF%p>7{qdP0;xFH}Y&HVjE{BhAW0{@WgldSe9H7CnYo+hpq2%esvTsDq&Ze}LV
z7F<rQR+%Sa<Om3~2#PZA)V;EfRy?yP-5+nx=d7+z5))oXDTLzD1|uk9(Y}z0#`|bb
z%jWZo5T6c-Jo*zFN1oy<Iw`bwAHF!F8KI=)=F23je4s^QEyTxuAti-w<0*Q&M&sGo
zXkqCwY<1eunhPFaY81`&KE1arY2V}Hds&nWD$^X(ZbvU|_}GNSvV$WvO3M@a_9cTQ
zn%ql7_#3)$?5wJ>9r0{eMZUDyUYGtPQ?bn>1YWG3Su{O_wqRx+|6r^$lL76+cbcKK
z1m;X<I8|7Hm@Weu=`GWC(W7kYyO`uMN?2tUjvuxcNsnk#`TmVRlj-V9Z<0}r<$fVy
z+vybXtO^j2)xtnpmE~(P2*~8R6=Ha4M;<>Stlyt#O2}2f6B{ynjDU)YHw_4>d$wX^
ziA2;d5uL_y*v-!?ByY#sg?7H{#6!>@eB#Uw1n%X|KgnUtx3VWJ)O<JD)B7a>D#i}D
zS`$Evc}Gk)etP?KCOUk+_gZ60KdF0=2digaTdbz$5Gz=neffFy-k8|b9G^ahXPmwl
zzKb4u9Ga?cs5M$Z)*^ywdI$(udH`@6QV3fC_z~PNR#8+DWsG;@QuV#sBFTF*n!chi
zozR01rCK-ccC3tvmJLTnE{>VRCB?NAlbc1>WdvQZJL?P!k|G=hSD}(7#9NeeBEvdh
z#Bzo*qcO&YjMHba*J5yOXkgbV6vC~;TdxoeOFNDqI*I|@(;Xq(ll^#NK*_dLa{nEt
zYv{095Fl?nN*G2ZMOo_e3Jg<PM<_~8>y|CHb~!gFZjc$J>!hO+2Z!CS=^<Po^|uDu
zJ@w-wKdVK=roeY1^WPe-%MI3g%fGv5QK3)2LV4_010p1B*2nWdqL9Qm>iN8;$)E^6
zjuw6F<sc@CI6F2;=4k+3(f{7uTo^<U4Ozh7u#W9~Jgs;;YV?*mFAYj+wD$1GYhDgF
zrEI<|J>18{53h>~tle-?Zi#;^pf3Ml_&(mP@<XORwwqdx3emSlg4gVp7Ua-qBFu5>
zKY@e6)FSW#^GHG63(Q=UT=^mU0w_ox4LL<vGbvaae*B*E;)#YC>iY$CqBiLpTvtSK
z#8L3Y+&lh^L~PYj#cj0IHE%7hU9u}h4vb_qL>-bDh8H;Uy8WRRcECkokgn$*Rug-}
zE>o!Wl{KY@(~HW)1Wlvo%HcN}FMfKYu$IenSzz$P%d~qD*BFb9qz`b@Cr<q{{mB$P
z>#EV6hJHqv%{^s=`h&4Znwz>EYWmWe7*-yNHIR_ybeQ=4tAdhfOQ1&9ixKsQ_tOXq
zRP$7yzc)R%4d6TOga&t*CECQLhW&rRQ|89r3$g6vbRP7vgf0mBawMM(vrf>OLVwlq
zerevOXmX{QMEkUz!LyM6$HoGQT_ezsBs+aXz2^Ni<+>ZG#6XaSlgsmP<`Dl%zA8`+
z?mS#@M}xmm^X+1XM9{q3RbQkbQeM~bW{0VAMH)rH%yXLUNn(9*vr*{x2WuI0C{PNr
zoDBfq>qk;R;-jA8iN+|eD$}M?jk%a+e5hfSt*@q?1;&tx<)5A5<{Zxbr|$*#tq|ou
zGtSh5;NbQrZ2$3Ly%za+!UtW%wpd4>5*kYb%*mxjWydbGx-<wVrP~9yV6uQ%VDZH$
zE@bq4x$!{4nQJ2w5wj=ouMu}9{``3Xx8h7>o$zwaehYumE`uvqFbX|)B6N%IH6(;q
z(^T%a-SJGP3Zx(ZEmE;ErEH#$sp)Ht9Y2zh7bAAxKGw#O11_kPb_GrXPknSHNJ$@&
z|9ZLKKV_sWSHyUl&2R1n86istKZIrv4ge(>Sfc;DDum8;e<oiLG&>(RR*4i35VWY)
z;%EDkvmyXUE(5e57QbMx_)vgBt4v!$R{?Ey+5u-U`4k1gpFICBe%RW{Muav}!{@es
z*1ls7JHRG9^cu3-mH}Xzr8V<x3QNis=Cuu)(HWXdDVVATZKmrofUbbcA@ug67Q>z^
z$;L$*KEFA6mIp<@Te__ci*GUgfCv7n4Mc&pNL{RvgEXexmsl9PmD-AC6XCTBn05&;
zV!oRQq5bU9Hl;IP{UG9<R?J#t3gtMOk0rBxJDOg@9#PVK+V=f+I>hiCiM=SfOzWQx
zh*mDcS?I=N(6-(S;kfKB!!05M7}-Sia&&X^L9__u@Y6NHW#FV_B~o4W=>^X9o&4ml
zKxDA0wuF*2d(Lp36KKG_3Viv+0`3JHMOFelpL(x4!8NDu)FU!JZ#APJrhOa$*Zg$!
z!oJ|5HB8Bnpihisl3IwXFEmYW5C9Z-I>^5a%Uu7&0F<ee?@dRG(K3-T5i|Rr)QfBl
z9FP0A+abn%Ai`Sbx3TkykAak|Fr5=$Cti7b7rpX_zs^C#Nx)i^jIq~Xfo!vKMw^Z-
z{@FMChRfStO*m22gaxFu2H`U%My#acK)K~MeTorw+N|T;st`*197j16Y0<J(qfrN8
zJniscUUy3K#D~6?dx~{2Dhk~4`yyW+lVkr`bS?hI{7sRqOiuz$bwFPV{~NunFAh8>
z&OCZ%qk@q~SVwR7cIw01f}&F=Ui4+R;zenO(Ox2E4EdibcajNbSk?l3OyPiWAnTc{
z`d3?V#T|ebURY;M_H^CFj2D_Ly=be-tH@8-mN=W^h`Ut{e>BDwJ_twI^(SKT=)crn
zJs=M%aUNB_1K&`LF`M!I1Px1%)JT~7fO}F5f(>|LQ9Y0axozzVtO?)9%+FsCD!1Wm
zQDnBKiIKsLQm+sr17AHvIai1>t0QDVq{*aLIeH~z$`ngA#GAk+$NZOIrJ0h&a+uZb
zCJP=kqZO9u<iFPEOer~k0*+#UBVCJC-)m<H)T7T3<Y4>-lNDVK45DZEUcX?5M(tEF
z{J)FH{afT=EL|v4>42s)y%i?yAU>?i?}M5pi4<5YaHSg1s_e~0^q!3qN00LsZJseO
z2;EPon~l<wCZ0xsTgMexS_2OxQbsofQyjS)q+(+#V?U!_l8Uq`P*y|~Kd!d@UJpEW
zXE6TR`$Ev{mf3t(;^ooS67!{I?=X{1B_eqJOe?kH*7Mh^rEb(?x<(GlxUErKN5X1j
zM!%$2jlMh|4S}U6ZUdXEmj^KKSYI?#9OMYg&sX-`1>wRc0sOe$qPL&f;ITpUA6Rm5
z;)Ie&glvpJ2I`katOW-R_y?u4c<wqNZhveVxkM<p8>i$jILO8O(3g(Wc-V{7RWq2d
zTiZ4f6sY0{A)P__f-8$7gWgesIP2-05_Qmba6^=3OROlt!??Q3N#9VP7Q?#=v>9x%
z8s|ze?CKm4V|TKi4B-yHp9Jp2M+GFXP;=J;idj??S!djszX+~7b*?p;os;oji4&Ts
zyby^TM`>Hi`SNo8L=M?ADYX(J=y=%)U&Qvm^KYlc=1GVrOHJ%6^fkjKBCu(Smy{Zb
zFR4-fvBCpKbJY0-W;WuBuS71-3BpW8>K4L|+dk`v>xd@?&3yfj)ZOQuUt2w74=2+P
zO`p?0*FanL5Yq;5zx}0%`#YBKb$%-43T4GYF(QIxdlJQ!2b}8SIv<5g+0*%59b0LM
z?ECZALT}6Vs`ja3pT-IyEi9^V|F1srYvGP7eT9FE&eLk{>zh_=frqpCtxJ^=Js<w)
zI}!2hzfg(+A^sfeR$>*5wm2bnFQG2s{51`X=NLBnT4iygML>rZi3basEeK)B@SahD
z|9|w=iV2O|_WB{&S=Tjf2?9IP(q4r;eWki<5zq2?wi7Il;w@b74wL`RZ4YVUoRE!L
zrX|HL)tg`hiXc0M4E(H`p3<zk>F2~k{c}cG4SueT+D$_souh@0t2$64ha0@w`BB=b
zIG75r`Gq#gyo3`Kflm?0nlNr$quNaqzO`5X;2*=XwSkE~t)E=T9+zQ5bv=G(n`+$h
z*ELP=UHQTEQs9TqFeq1NMNLv7sLYlhSEpx6dRmy5dV@P}fW7QhI45~VQj^t=Av*8h
zNACRh$VKu>)CG?Ij6JR=mdZ7G;Z!w`8w{4yra@r)48vE2->mE9flqqhE38VA%W&ke
z3<js9+k*fs^yP6xJ#f~L@7@;5ASo?#s#lf_atHp6R*h3f!zv;Au|D@`?KE~mpA11}
z=V2VrMTPnUH05*Vyn#9)l~!cwBK2co*E1z0OKxMsBhsR|t9#eymNlg>WpI@r6#gZ1
zWu9Dfn^)Rd`I~aRwx2g}%TFI|n8AkD3}b9F$uKsLHszq$@K4Dgjni+OMnxt)5~SY4
zz}Eb$#2{xf&cqr5Be+#G{;{c<S{uxEj2fpQk11cW$M|;?xO=hqT|#;l-V$l{+J6e+
zYw3+KXhIfmyu)-Nx0l^s2R~f>im&_epm`w!2L}y`zu=%Q&ZiV5kTaLD_d{rJauR0!
zWxzq{i=hMBN9<oA5D;70F8-ml{mmO5)Ynb#>QUsz=X_tmzxDW^2;YrHMbVbgqf80c
z+-@248#5I3{ye&gh3`uhw#6ocOayQr5JopTza05y_vJ6=diA@VwiwkU6v5TO_K(|^
zY0+DeP$@BfS3-+8J>SaS)g7tcMG;#luZmhtRAAlN*{8$garH6I%+LS0?>q9y;~nxB
z7NY(#s50tDzY`T>38Tw^De=$w2`wTP1D_LFw4_aEmh0{lKy3L15i1c2@At2pS<piK
z!`E8t4MIlY$Djt;e>(?eD0+!cm8&(Fz27&KqoH&Cam;Tg7l|W{F8={IBRU|CqD|%9
zx^5_k<9Oipp6oB!A^iorQlG!D*jWu3z&x;E)b9s-8s>;KzsawsDN0tBcc>@Wxaf6>
zb`0WNo1xH#1Ks1lD4NLx3;7X|lKMVu8p=7H86HkJ6lv*6sfW}}CxC`ii&LiYR;viu
z^*Br^PIS&$*#UoTB=%3zHhdBK=ZlcA^VsHyI*AjBbS<XW#@%)s3amu((5ARZ-*;0?
z=8AK$c&Nj7@4sSd|0kyF%<@y@t?5&y2rBLrF72v?S#HY_qgJTYnlGFjafn#XBX<V2
zqW0^r#rUali>Luh@4o(XQkKlYytg!`!Bq0tknuN}dctPCZ(0;*(?5uZ)E&a5B`|wo
zR*WLVroX0UTVE>xE58Y=r~E4~$A6l28Pm#-!_($i44U?-4KF`<zfYb(9Fq(J2spN4
zdT~FXHOn&OGOL(ytN*`4SA$!ZF?<8_T<*H55oLEGi}%FgyU1+PWcKGe?ZV{fZ{EFc
zcsgQ*YE;3XcmE<1mE7kIBK+$s=6$Vg_zi>YDn6d*5Y$(4-;lHAwdhzHv^W(`kqB1f
zFny-L%6X-d2xNj2I7tm)YisM!S<ThcdJuP#y1+z=9#0lZy7?i*KF?ZGH}%Sf8;*R*
zWg7pfkk0kP9OkR$fRA5OBCx@Xs%3`Tnt}8xXXa~a#~JPR!YYTtu~2m9fsk6x!PL&w
z&bNyQ`e1yuN#?i6mm{5{Om;z@!9=8~v>cu3C<z(z!>!#e40E1qG)3xUexCEDCqDPG
z#vw&l3a=cneGyd|m6hSawe#yQ>ds)AJTH^nb`VpFB)>`E5$hjnDQ`&DIld6%VL#$3
zoXLGF#Jw1mEP|JgMv3Mi4T!k@Gk+UM3c9JGNe}2$2y0uCMqhtRQ8B82fpI1l!7{}E
z7_O*SQ3pk3or%N3rRSx)Upz##_^A2r#{%v@vnfxDtHF1U%4aE5(|&6E)#*=vKXlIT
zLYf(zVM13s3~+cV6{aLuetl5!uubb)V!E!`xXpYkVC>!cv4=k~O~mFiUylr13mN8s
znG#=jWAIdPv))1ys}7@k*XT>wNBtACUxUqp5*np7Er;1uw6$No-Y%O$ypzo$0z_<d
z;epMTcKt8Ds(w5>k_yQLqapc{xj%hTeCz>Pru3Ltg-xI|0K(G%eXXBH`DBKu<;+9_
zfCE=b-(?ugKsnVdBNM4tc}`27Zv(LW=p|Qz(5;HhG)=e*^7A3cH6-b6&Q0kVF-8b`
zj=Ie;NsTkq?q#n2R)ZAF^$!+2ExWj9+Qrd(zTCbHraW?|#g)k*0bs6UaWd$t)BHMG
z(sg{gelgHs$fn@1mPK|dw4X!FdsIkfXdtIA(uTENxsj7%FjiLW&(cpq^Ot8)&J1_k
zjytMs>4LIJ!$;_@$Z;3Ud?ag~mwii2k1|EW0}ma}#~8%a6B=Rm<Ni)gcANrmZzhue
z=iIoxx8@gL-VO{#upB;dxK0%uN{f$3n2t^&oAqDX&i|`jq=s8f&fdN3CJgI3|8;iD
zfVrmfX3g_yyW<Gek{8<&kuU8jI^%ie%}L2?4Z(gfGKUx7a2A+FW^LvU*56pg`)70m
zXHQ(Qpm?cmR$uR#$b2(4Orq#cJiwM7dluuT5eg%7jnlcH!?%Lm<T<Y=f*=(SkKw2j
zNK(l31N08ijOuOI0FlPPtU+K(_`(@sh+U=jf$iVS%QpQVM9;#r9E7b!qvR$TmfwhB
z(DI7kY|)3N^|qUO^VMY2QV%B_#E<qmG{xLM5l3@_jv1Itb`a*QKA0}t`153`7Q-kV
z4aofh*^7RTOfCI*X*kxdqR%MU!U(5EMe0TW#mUd79yvtiTPL}FhmWs!+6`01*xy-k
ze;udE49~XzhH-46?xpIu<fv1}-X_!@1{u0pHGCs;va@etUh!E&u(M(PDO@jYxtA)&
zcOb4fS^Oe-Z<NZeJuTbb5^nmkn*HgqvaX_uxZZTtAU-@3HRGf~fKMGI=|&HGjs1eM
zV#<!$aI&wepK5>kz!`q`ebWiSY{NK{xQPR<ImjQ2&U0TBjHfiY^!;Wk9ag@rfn5{W
zGEt{USi7A$wRIQo2zVBD)cwRmk83>7@54qXr*OF!{^fLwhn8h}_++_#{kvb_WlJ>!
zYfADUCMmQho<s!MbPTpMP0#v8xnDN`=xw7ji+UG3knVtAD?*<sHIO81b{cctsbW7N
zA<8dSLXX=U?Om)B+$;~TSeZd^J8#igpwue1Tt-K2by+af8TyY*KR25>t#|B5+Yv2|
zjBBssJWgy@BYi6%xr>x$mGhp-Xf!A8%%ZMv=^_dF%%2p&ZM_T%n_D8_Wd}+I;vb1h
zQ`|#D;RH3{J$K6exsjbkk@tXIGJS8#<pB}9xxQ<HZ*=`Dtc#vo^<#i+r#VONd|J@u
z`-|IEH{N@tdl^6|`6uZq>$~oxx5XcuGAVCWu>n%~LwkG<1OZH)t9618Nq=HG1{E37
zWXRQ6^(c3JV1yT}q$m@xwws${{7wS)X4aJNJ1gP|zc)xl2uYC(YwiP?FU81dH{X5S
z94m}+p(F;hSEM_3$p|zck@R2s;pgmKDz#U~OV~!qLE2%U+stdhAJb3bk0vVvVl~$q
z>!-pe9OQRTN!;mRX-2AO;wU!7yNqLJP|0+E6zR{OC0ZlFGW*H&yVN2nq^JatS-N1<
zNr2g1FBb<Tlc8#id=9a%+@~i~Gvsv<ap>x&&R7|9#)yK>V7tB6h%<z4gDmj?lUCdx
z@A~a?{gyJs+r%Wjr3AVgos+ACKIG+J`S;!gulX;iNY%G^Z@AD3x%-<&Ex)Qf6_<+?
zzeSRZC7-T(#riaSj44qe9<2_xUb-PKHDn@Bng6golVmOrr@{7$F+J%sMqPu1#uJ;z
zhJz`N<yZb;w-TR53C@dX74i*ShVCb9rxY%bJbRT%oAxif5^02P0>aVTTR+^7;cu}>
zh@{RnaaWO4k^FEIq?mJ9htz|Ey%Bt#Q>B&jzjLxx8EI1e+}&wc^51xq^&82U_ru*2
zO3qw7%TI_@)Rb92j<{~vO*M!W0P0rUYeTHU7ZOSsOK;vN+8VGN&7#pm_kB8+b&BnC
z2H;>e?WV{#dyMZT1v+En)uzDidv#KGnUqV4(Y0IBJ{pd83UTyug#N+A9T-%KzHS(4
zZpQ^k9d(G)!kht(B^4X*9Q8jOC>XHb$5Y%&aIxou_xapJV}V&oAcPKYPb9OoOzaDu
z?wk!djAnY(*7im+KHA6`2UmHXrTgoJGmH7)K}?(5rY`7M`uY2Kat4pWk4O|SBpk$B
zf%1E9aCuvz{45SQRf&X?;Hs{4!vBl=;WM)9OBWvxbZU5>mx*q6haKBgVB}hdc5YS#
zGA&FGG#rAw3Si24_eSe!c6KHk;1<9UK1MC<xfU0M-S3BggE=?uopJc&=2e4R?s1Zu
zhvVGiC*IG&E*+B6wc9i1W8U6~Kb@FKatt1HO86=YkhwYQJ@lafNXP2?=q%>0ma^vu
zd;w{u$G;yp9lMuh=##klfDuHj=(0A<?viDN4;?zXhwM%y@YU7dO8mN$@bO~@U~cXm
zFD*qXK0PVx#FM#hvM4Wleqm0ZWa=m(t!D6tF;O_;WMOh_LcoE2G;<CVTv1#;%{r=I
z?j8V<%h7qNb0qfFm_}1OFNnGB(OdmEcA4<<xLG2dhxE2btjkU!zV!u{_l;t&;s5Su
zvRO!{dj7jx&v)C6`l5T@`Y@&O)vMeg$*KeUjA!27I+)$&uxP4l*#|1oj}0elDX)lM
zPx$3xYq?sih+B?QgdMKNOrpssu=oFLZ}Vp7!A%d{Akv3QI?pBW(rjEv{J2G14&X1m
zqjQw({e#N;!klCCC<Jo;_Srm%n--Q2FWNd9c+s#pK1=;p{m6#jBNm1ny$Y_?B`A=k
zCt6!Mb%<{D6zZqct#R0PcN-*obG<7(d?(>}ltrrvI~5JFI6XIKu(aAAH+wk}T>IIE
z80HcJrr_x3pd<wZY@6-m_bVI6_oXm+n;&!5IW(nLIz0uXgJ<bKs%G3RFGT92z}s7H
zBvq|O`Rp7V%xz$Z)#%q?x-HcHSTe~^qiEF(16cTyAC+=%7K|JWla3(PzncDsh*oRM
zm;+*6^_8QH)1R34jvhX?;+FE#N91-0_F5Tt9pb^<TvpyR=SCAg9H*wTtlh5e3Oq4(
zfIl9I_44>{R0dVFeI{weabJ4_mW$BB4~W?k8{V~hR)%K^5Vx^_EK*A@^0-4k^zF>f
zfb+RA#HGX^?^vB33uHa!N~B9qn4S;s#5W#WV!gPxfGNK&W{qW@UdDo387ND=2m5Dd
zVTdq5G~pbJ!iIk=yj~e;;5C}?+R|}9WVvE>;M-Q*N%OPK<vf!-7+><%Z|#Lrao!xh
zSnIWU`_G}!A_-88jQB?4UI{I)K$Y@Fu#7l2T5v(%GC~-zNam=Q0s(xZDaeL$K2nW%
z_9m#oBeXTk=!oP!wljSxw$b{Rw2ld#771!e=als8e%i3&qeBG>VlX~siH9$N$c1Px
z$2qljlbCzF8hvs42<z3^Qa2Ub^X*fkv1Qs#Z&tcUx4u5th2^*TcaGj$dYxKQ+_ibL
z-rnpHYbM*|0m63~>0~~BIrzo_0~6TGKaD9fBA@`*7ujlDQ$H8nwhgrFFL~DU_R-mi
z(psklw)%w?6V{Y`2}<`*{Cv?Id$u}-X>VPm^UYr7_E*ornB<iFPMCXLr0cWn8v<O*
zMPuafx8x->aquOd{3KuWINkOvu66dS37dD?c2xURN%~~}++Nt~T+VqN5r=HGmd>=M
zM9OFKFj*iINp(2E0RZJI?(x;sS1wsr53>7ZXtFo7R5ob+EOy=HO8Z2~I9r_CCPBTd
z1^03>R?&v!%<|*DLi7q^-tV~6yAEOTBR}%lbmua+Zm0Imm%y$+&0L&jEeuf?ejJXy
z7_oo)_S~JW_~3l+EXzw#%)N-&QyH9%ywvyjD%|RJ<D2RLrC#ZNK-<G1EgeP@ouzFL
zu)SqweOs~gr_0|G;mNab#O9SDn3_+<n$kCkn8$R}Ku_H9b-d1HOyB=@a#q063#o*r
z1h}=nJc#?=qITCj5t0EBj{o$8w$nmacKR1c1*(YnTzk?3Eu$b9sPbR@{%bOHobApD
z0-3^vYHBqChO+mLM`15V`}FT~eQy`0{mZwtqx8vkZv(bZ4G?bMV#=(1b2d2Dyh%~C
z(_>+%F_>CtYhus1-sS4HDA&F&b>zfD%;G=rRyq|AT1&I=cbd=q6LVdYR1TsuH<t~&
z5)bC9s}ix9+Cn3WkIYkj78S>o!8=c<+m03lK@-j^{(|TqlFq#*x`ytpm(_TDLVjH?
zp(*LvlHmhb=$pO~ieApMwa~}wrd=CqoqPAn;GeFiTxpV`gxl0I<Q1F<*)@E@eGL8+
zJgLM#I)ecuKPIsmIP@D{De~U}DYF<iYd=;qTZNj6*gyHvh)&|0--!<^S6<g9Y85G3
zw8qGUcXQIyu&90;pU*jE*YMFqP9IvB%bSHUImm1;WwrJY!fUz&d!z$}6|=m~+Z&yy
zKUeFT+J$!Q&Xd&G^5q&IT{i|>^mF3WVguax^h!&~J)g^_gPp=1X>6(Enx3t!+Eq#U
zWbD6(XFJo7iMC&vy*wh0sR5k7{;xq2l8(NKDs+l^fe@(eX1{^JN#OoDHI=Yp8TAuY
zxyF?lGJ__+bRU+jF@t674a8KAlyzzwN+zQDgK1Om)IyzSVu_8CXdHUJdylL=cg-``
zx;!T(mm;h5JjfRrIE}rdP~DJX(_YCR+W16n2z!m5bp^yCgo>+>JuY1^QogGlGQOk4
zZv7%j+sms_76p+$Vk%Qdw-X|k^rC%l-3|TUEWj_1_OIu1RtY;;8l1K|%_L1){i}H#
zBH;dcbQRt;y{JDzi7#;DM;Y3W{qI{JDJcM=(j-Ts3usxeMiOei-q_Q7qW*MlhPW@z
zIj7`I;pt1>USlxVOgqRo(bo23vd-XO2Y3^(#zi#1o~u4s^sd2FH<HFD8LisvF@sKs
zt@?!$MJ9XTclfER1>|M`yux=A+Pu1nWMeLFoIs$TfJNM>CV)hStA3oiSc3M8;r83L
zR9Scu8iLlC|I)O>hx&J3IT4y>uo+r_t?qc?4C;XS`&_C$fsLqBgF<3l8FHZRWK8S>
zhAZ_~L~W7R+zW#qqmglDG}I`u=0#0gwN6eJjfJ(==6rB)cBN(~X{#dS`yKQG@T&KO
zyss<W=wfid=!CLRHsAHVWFrGToLiUZRgTr+zXFG|Tlzh-Sv}k^naMelmX<y%2%1Jj
z=AN;iV}a&JURQ^Bx0met_RKXojuVQ~7}E6~Q#lq8nBFxlCJmP9{xSIk?`(F7(_VNz
z)vmS_Hg#(H%>IqHu+QC8Sz+46Z%{MhS{C1fN)eKn>q46HGzCp8w_Z-K*#?wd`|+&v
z8pl3ABpdGuT>wIhZY5N<v;$3}ZlYkP;z-&emaoy&E81f1m0~BMZE@*&6gPdJ@J@Ci
zR|W8@&<+bPm4b)b@^G8X0E?yLYfQ|HW0XAeQEhCqLVS9dOwu?@z=9xxpy_VJY2K}&
zg4<XYGN+$zI8R$pWK6V^G$%ny%7B=Yoi|%avL8;~)F#f%n9|}CvM;*swllJ^iGS`$
zY<=2S5R>~QTAV*EWP17cD%0X{&b{UlM%Ibwvgh^tDo$3Bvbft-sjc}y)6Pf$ZWIzS
zWBecd4riKy#V7wRiR6^@X313MFst;iYK93|yWqfB9nX96It6tV5^-PQGo5?UI}yyZ
zovLF1C-V{6@UL#7j^O9ld0J0`W^$3aUMuRR1&NUpa(!PMGf%Mxu^ja$M=n^dutJ~L
z@b5$qtiPpYy4NmKmF0{x1vxtpJfnE`>!S-hbO3YIGqQvaSl7q$VXrC<>lF%r&iFjP
z!?)VTf>*kpdT&J%FxGMiP@7y_(fDk8Zy;YjFVn?8vP1|wDlo1$(E-3)FEj10d58N)
zv8`A=)~j8+Z&y7pgI-3gXxBQ{5JwH~3<Ms8yHt)FA=uN1Va|RprZQOybS2?>AD-R%
zA;*b1mh3mJ<+2w|4o?c+`73_`2?o8ppLWLWYmh6N``pJe=Kj+h8IkVsae8rRSgEb0
zyH%O#aVm^$;b#CBOPmfUg7TP0u5<K)irTxDIY_iu(+8NsX#ZLq9FYYHR~}9*C<}o7
z5T@Mj)ZV%q4?vHnkb*a~J>Xf-kOkXrE-8;`$j~lLubdM2Mq^>*8=qx&nDhh;eJjF-
z))ih)9=3oYS_P45h;^E6)Ra=f8qSs%8c7>3;b#(aES1mym_6Kwtd32N4^N73SJ~X&
z{OK#g<VaCjUfsz))!+eVmoC=2t$&#4Sg|rC^&T?RwV=-+q4$Rrb-<L9m<rVy`^2N@
zsn&OS93|h2l<HoTptSMqmK<|)INSiK*B4`T<~tAITz#uIoGKH5iL7w0r@7r*nYtB`
zZ?@w)2HO$S92eZ5!+U;}TnWvkiiWs_QbY|@ir{JhAN-iWQjqGiNoLj?CT{c58(HtW
z_6(llwa$cd=@LS^fO5&&UIoB&Yv)arnNKg*fS*xaw~(SKj!6=3X0Yh1o!?tZ+^3vU
zgXl@3x(?#73JM}(BTQy<0oA!b(1;|H+R5V>%bxu1%kFK(luVu9Pl3He1%YmDx0MGf
zWNUPJg0GsFTuS3cYEleNojjPUq@OZ30g`?5H@D*je@#&_%+L?6^F|{Ry>9n<>&Jc%
zW4d-R?YoRL@>(`FTPr<l>N==)9f)xh)r=?Y=(R6_!;<wT0poZ^S2wctTIim@Tf57%
zl`7h|Dn9_CWjgE%GErn^TOa^M5MK4GnPopY73~3N?5WTiCacn@MVa*%x!06r@%f7}
zGMm>IhH1%W@6<L3iR7w$6Tec_52Z#mFooCVotfnO{S0MicYc^<0N^lQCQ{8*glV&&
zzuAemjir|V<_F`Vd6BgxGWuO!<`Q`yYuld1Z*S^?`mLUb<G1vrF%$-3oOnNBt&_(Q
zc)36ajnb=}^34--f*W|sbrgnDa4@{mfSF4Xbx57&?@-`s>xDa7v0m3X;FOTl#QZTH
zs8NtBzVaFSv7xu=-gtY&7$;O1RqL1g2SeLiLa2?dE{I>~KG(a#i#ZUw+Ki7T)>%=^
zCR;I>aXoV>&~!O~FDeQ`=<i>M;dKMigi>7iVoVLH_X$<l0z<g+n``SL;afn8vkDG7
zrOIfGzBDkBK(TyD#uu}Jyk?m{b<a?C2Oazz>a4azml2BJ9s%&(#fBO9(Pxnk=COM&
zQF>x1B(<#)UkFoV#&1NUJLwFnlpeVEOB@EtQb~Hcjg3e<uS|Dl;q*3nelX!?sLY4h
z4<}A-1rK+q0@Zh#7}a#}oE0sZ0#H;2ia?2vCE2WZOyylsZfq?Lv#o01tGP7J><iUz
ziKw`HIY`lsm2OzHN*6s(qw{D>ddcVR39>b@tj><Rgz6>v-<H1d*e_-ePU*B?$DqF3
zM*!)EIKMR%omh$6zo*q@tohSzB_Dd9eN7@kv7%rVIVO4Y0cYb5{qTtKn>seU2IUz9
zZMGcuH|Oo>N;m`j5)qGeeL_~FQKe?{&iZ<9RoyEZyoLXQBKU~!@;XbPhE;xaWl)f~
zhOJT%DoLJ>H_!ZgGx3<SmCi*4D7(?p4%X*^7atGkvqJMKi?l-^TOy|W29zdD`Jnn8
zipSiy=JXxUH!QSi$ja^TV3G}mP1Grvs{y&BT8m2uSnm_(yrEnaHoJHJb#DvR6KeZA
zx>c=CL;1xJk1({`-{q*^K1%7+8+~v*4p77RcC5m<d0trfuo2$z0>(>#lP?S6&m3;+
zb-UQd?u-%7jsR&gHse<rIu^fKxjIQ*f12DBH*nk@%=2VYRVpQ)UF|v14S3%0>lKsv
zupzMtPuo^?w27L}G60d3WIw9C9tc}U&lrBp`^u8R8P#=`=mzp4=yOQ9%_%;kY>bv)
ze5P1e&Te&k6rT^aQq;*F-!Z(jLDZ8DW&kHWwuq+AJVfy%5IG$=aY`1c^GmdRLqtwS
z8fZh<SGx>2`DrLME)>znZ!bLI5e=Lv?-BGTZ4$olYXANT-a{0S`-N6|voyNwG$__n
z<SS{+DO7aO6~2{bvR(W`$ThW;QI?_cSinx?Iyq7FzU=-+30C$9RJuTAB_xiE6=iZ!
zDoPgDXbAwVY>w|NAxNUlG*nq{YX}pJ7kP&nD(0yZe!n;PJm|{K63%qZH>{DvstQJJ
z&+yOwWX9&Oce88)AAeH_pyDY%WbvD_rds0Gw+D3P?0NHQgAsh>Ix}u<Z-GjOzaFRp
zFahBc7ct&Ojd+Tz8VVfc`fUDfg+H~}+!33>d+}@?&X?Trl;teLDbWYQwbY~1xA)+4
z-ymDaAO?&8Z@{x#{$Ay&zv%vPTE!4JL)LhHd=}?MtkhxgJH2CaS-%-3SKU{TSxSv~
zNtg@oKrxL+v49N_xAk2uE3_}|irXY4TnLNQ0TVezz&_`R=#OXv3z^~OWfDV5rRiat
zTVK=fZ*&=fY>%TS#_h9La&POolmHVhzbuB-N`J09lK5wRrIvHe?AvBDf_F`Rt`X}T
z4QVk=uab6E!J9B$J1;(B%1Z@0KhaF@zLb<zVkOEg;u|lEM^}4G4xPL0&Gvul`zTG*
zkogtl-aDwUW+MCjX8o#-I4W_tDGkqS>50H@_@OJ1p$(SQ08%SEAr)b}4RG)Xzhzz;
z3*`3(X()k-j^6W&vsbg@(~7-nFqukn3UNRY>xzSRd{(Fs!&NCAE@}g65OxH3$|smb
zqY`F$VUDD{uOoqg0QCwq>vl{_I~PY9i%${oHPbJC=b#y(HzIMkc*r5Ra93yKfZTT$
z7eeuv5j|8QqV;uNrG05Owvaah6PaS@?j`w2RG<+Y6Z}ySj~!(uZ4NaWeP$7AZI{pI
zPXTQti*4!8uya_vXLAEg;w=xF`Jam1r;`X<?lW8`sh6qn2YlkKk}Y?MnY;b|o@1UZ
zVUWmpal(=K#~CmO%AqU$^zl@-P#vjayqWef29@-bD)Fm@y7q8{VdE08VnDHrd!fTX
z)ap|%9!1pP5(HzTK|FqXUT!E9MKU~`e(S37G-hkma`B;q;Y9gT7wXHbY#j&l29^#+
z&#LNjl-a@B1#r?B^1-jYpX>RI&7-gBL2SjTo_BPv9@q6lPp`lmy2pxyb114OsJm|M
zJp~S;D3gXVz&`ieBhKKYR@Bt}p$$%DpJh3UQjNm=+McreaA5``PNNB%Ev@y7^fvua
zAF`ofQYZq&eMe87Hw@r#0#FJxi>y%9EW6gx{SY3XQ&z^+tR!o10HIfPxtx?-iYij4
zvORJqpRDIjwx<bXvh3l9i;xCL+fnt(wKZs>#=>>^)6T6u^uE-`97GaiPp~{_Wx{dN
zRvm<Wy5_)MAI-85xM;)8&=N)}{$BZP9caER+T|D3t%u5#6X)kkhK<mUy}MLr5oQB5
zM18`!@FXYCSudnoRlFMl&M;26xBocRc;U&pMzwKxd}xJv=m){9*oKcX*y_}ib^pof
z!I*<3w4n{BIWv96eu9s5x#(YBk~ps*U#uNHAW4-|K{J0Ag48N@iq+e0{~S3u@1Vll
z&bp2}^zg(vu~?(NCW*28jWSA%80&ZEMVR3|?cqHa64}gEF}gb!)0gpl$WWY3Q1!9o
zuK6M_kHaecdL^1F1UR;tOqIHD^Qp*IW$#@Wag4h4E~tj@eb+VH-R@zfpVdf*9#E<D
zE(w^8j)k?-4n?G2?aObp)_23~Z4Z2#ZRf^)erim%vCDEyv3sv@`WT(knp`GNW`z-9
zICQd?NOh|*8(7l^G@SWyCL#CX?kE%^^<mXL#qL*_renG<nZkHmE5=15e1__@op^zy
zAm|k!EAqQ6LlN+oVG&zw%i7|rjrV=XaNT_1KlK^|#y1awEP*q*pCy)&%w5Y}Fmna%
z5L~$SCM#w`h@<jb)=PWdN)R2(HMPsXB;y?~`WM*xx0^VTluJ+ay-aV4aED701nb??
zQ2sQn4)q5F5Y2FuNtJuog;WF_a=pY7CF^-{`jQEUe%QrEcP=nowqP!(!)zOU@k`En
z-ADGsfS(|NKB&yQYZ{HpFm`nDSIJ@@&rsvZ?_&RM{QZeY<N{$;wQWGs>Z9YKU!Ks9
zco{5(#Xuf9-26A>7#+LA{=17q%B4R)0Ve04>>^QknucPsTJBHnnKX4=9bc6H)aj)_
z)f^csYb#`FfVj3Jmt#tT#%b&yolci$eO3@Mt2>7xn{(9<my|La6KtTC&ReaguG16@
z_Lh0-W0R=VzZ+XpPjM*;CEu>LGSK?8U>9xL>hNK0Bxn7U>ei^u7)~3D7}r`%dL50K
zWBbyBeSvG438jMnXBvERtMrZgA52j?N*ys;85mZj#qSR^U?Wa8LY)JPLSW>)!|SP?
zB=P+L(XpL~Ip)v|G6xyfoBAckpp~JHl8<E@r#=k!8hlbKN|G|M`4+$#3Ac=F>MEo&
zyaD@C+~bdIKhzIzja{i1)x5|844n>)yD98fpXZvLY#^`8o$3qUa-H}vbdyirGdngy
zRs%m?^d^_7vAU5ZV9YgbXA|b`F0ari=co$|H{(0k6Vltt^`cU%kHFjx=9g}64;gqE
zo91M?s46SgMq0N0)&dyp0W8z0_>NgZs5k7a-myxy#7Xi_XO!<tqtl==Wwtsc-*P<X
zF1YD0$R;wF@9q}*-2WoC%j45Zg*6`&^<t79KU+1}Nr7)_Tf7e5;Wmj|y|6Y`nxg;!
z{}>dMmsD?HuzSNtV~fYB!RbzfZ8Y~Ew|M)cG&RPz%Bxnty=jIIp4cAm%5>V8aqaH8
z`37et!QdIq_pG+qRv&4?V<j@I7KE1dFMK>Fs7jgl^1a@8qcru#g=MNk6dmj-stTS@
zi4)rm=Tz!E>q3;G>NJZ5>iQ0GB*^~VU_7sh{yFQV%l2--WsZzVmT(Jx(`(-fqZ8Gf
z&fw;;;-uC4jvWP!(w_;uX<PMA7|m$Jv1h8|OIt3Pe`aFG?@8Ss_xn&3Q<mdz1j?mK
zj{Uft=_kMVPYma3;Pu`WvSppdklVl9eH|+n>5>MGX%=#ZE*seU)quoHw*4v(W(-C;
zUiuCD8h6T#`F?oGdpAj4w0YMtvqa~|t&_0qD>&T8pQ&Vm$w?3n@LF-{yw2&7I^N#9
zB_;n+lkx@RzE=~dj3C0OzQltXAKyGFr+f8I@cPqB0akSv=^!@0vsD{2%gvwn!5n7~
z3>AbP7{s3r-RrYLcQ>1m@%b`hy)$f}IotgxpXtNFXCKSRZMqZ?>5IRUeB6heW!uOE
z^m#^1y#JC4avyQ$Li|#mMfqx%$Ex;o>q{HRx8%$3%8??K<}GL9vBfTZt9RcFiZ*#q
zh|HZp1bLXjT53H7@OYFQPPLPDhT=LW*(<?I4bdFkFDiq_rE|tfVPbJLqV$dM3edRl
zK<ZM@pa*wBE1#1g>cqY2^5@&W2dj+hyI@60<<jB2w%CK&?2$}-kGMu^&P7!_6#0KP
z#Px4t*reX^b>%qVJrLeY63nrptyfSV?uRi4+mm>UopK*YFBjYWI~{)7Uk7yVJyOVM
zi((|WOb;cM5lc`cDbUHBwh_D^MK^rkm#@}ev2p2=gjY*rYIs7v4wYZzI!eB2k~xpT
z{Q^U>BA(tA@4l*ZvVu-0mtj#s+sYg`6Or6prtV$lCgdzHR!m|X3X9bZT$hSLpHywY
z;ech{H<^{N=YqAjoCGL}69?F?Dw}E$g95{elw6+)+j!ti+WQ{P=sX{?M;elo+t%Y3
z>_%OmqJE7G3d3=wtTU$w-xN*5yIuz}Js{R|mJNHm?X^Dk0}*kgJZ1GQ`tE(zdCbX1
zA05B2Te{%$fDihYGSU#cMzrs?vp=7yka?M%Ezvsy48ag~POER~k6zX@ES-KM9l;X;
z$!ol}!Zc=nX}WO97SitkrV%8n^V+`Ur_;Z$-3~?AG`P94{dt^?SAFwr-{r&^fOZpI
z3w5%QaB|#AO0OBC2Ry0c_>t%0EtB9XYpm7D&F0}H)81U+*~S6KbwjS+Pw&Sr;kr0&
z_ut~WJ#Hcj=Ch^5+K=YKN=IfA*i8D5<eV{b9>`7Q&LwHvGRzugKVQEl((2cj+g^+t
zz%WD@P4YAAG<#<Tr_icCnv!9BF{?0r?uhxC=;r9lUf40yH}z~l82drk0e;UT+|Nds
zbY}p$Ig~!C^rA?6Q*Yh?Md1^=DpW#oFs<1B^nze3Ab6Y4zx*ot?6us2@irca!V(%Y
z=UGSiv9xJ+uj4X(s%QLu^EtsyW5);gULq1E?OP)?`ubQ|f;r{qqNXiyCOZ`dLuj{k
zFk;zC^|J;OM?Kg(s~|_*;K0P8o430_-evV-rIa%NwDvQNgf<4M`rBNpF$A@WJ?&Ec
zqszLtoip?hjbN*@!~M$uA5)5w_~x|f{*zD>v2==H0$i`N48fF@5o=%lJ(^`<r@49j
zWZ<}!_=#J;h;_SXVYL`*88!UQh+$+i?ZcbO-dNKnNI}Gbv~P0sSR17)m!4`}B|~7I
zH<Sff56?~0+^CnZM*lztpr;m}P_#~AknqvuGD-U4CX$b%4E5JjCz}uGZVrW-8s)#q
zmT@`E^Fw}niGM3p8+iIW-JdnAX%=C&?bfMuabmE|Vyrr3%Uw_iuy{SVwS2b7l4x0|
z&H?cWOHDsDC}}JzS7%zNJ7qMMS@ng?dW#&I^`P31?*EnSuuJ3K^hWAFCI|&^#A~~~
z$wRaB;in>%>zDBtWD3iMb+<;7dgV?{aI6Q;l#CcXFn2pH%z4A_4J}q}^DY5_T=hxX
z0)Mhp`hAfJJT$CgSG^=_vTSIq>h!NZnaI};Ap{=Y1Rol%;mhN6556;IMnZm+zt-WF
zF*FE+cP1qdoB^n&S(0v#hxe{`=}ay)AJ_!x`rCHIxa50+;1%QgVhbIb+2I8^adym<
z`LTz}pvg22r>!X)zcwv6j6XA5lMzwxX6lJi?3&fHe9X%oB@c79y~kuPq2b=S^PgqH
z&Q~|EwNczi9QWmRuI5-cy-3Sy+@pWLppn-r&beCuMa7^L#wCURXg=zvLL-_z-S3|S
z8^G#!zkcDyoc=jDrHjE+9+%<VkIa}Iw2SzwQjlrvZK;BOZP#M!=}%q8G6B16nouk-
zf9TDG>US5RRbv)F(ZOUWyX0pR(?1bR9ukYF=u+PdWxk3>MGFY;Av{7$Tn1w7AzYV#
z28u2hH`7vi)ykemX}k&L`h9TNy#>F28*Zmwh9^9l%3>-ndyi~3e*T4;d>h?UgD?&S
z3X=4db2lpb2%E~dE{i}O_^mmx$<iji^f*i;G(T#2#2N`Xn>{$U_m;nC(?zmswnfF4
zU?vrwkyLw_jo-cA!~!ipu*FmSM^j>_-En6o53M?OG^xLOufI1bu!g*z)2WRx5nk|Y
zB77v!7v{BO`{UwMpjEVKZKDVPW75aHs*^NJ??UnAe4nK?15pM#>G;Jb#;nce$S8WN
z*s{;Po8dNl;Z?C^^%7yOqk&288re!R!9Q3Pq|Sr=4JT#iS6#^4mz`O|anKX<3zfS%
z*%|Rzukryi5~X`aRRxV$uuzW5iL@`!5Pk*k+jL8vz=}N+chSMek+MpJ-0}AKHY0ij
zGG50w!vl7Z*ILpCelmhl{3_QTuTWswc*K+6k5%lNSv8z?9epX~JZu9YH&4d!y!q+3
zl;(`Q(waGHlL&*AQq+i#I)`l1n_d4{^|a}Mb`-J6b7Y~88W9S$d$Z9lG*sk*Hu=kp
z>t<1_sP@$S`_Ll1TQcVliQj<XR$|dIh=*BUXCOTDAW&J!O0^e4!t-R#hfMko_u}S|
zE!4xmu_fJm)>#&VOw#`Po+-jt#B}oTBWRNTV~JbN^2?zt_?&S!d~(_5UoQ}z8v#2O
zU(n<l>4%LG{ZTk3DTMimdYfvLI@K8Bi!d}^{Tdk?F5ND&(dCam-Zs!g#`S#objiO7
zHHHttP*!<Ap{>l144&yY`Z+i;gR$ND6pILa1_D3y-mX@q6lJNaCiU|H!VkN~O;9Su
z=e)h+Qm5y#P5!#-hmkTT<9WVI9C_zjEXUo8Z>;-q-)k4SUid6TF;)J$%(y@51(o55
z*r~pdvo!Kujp4k^7Me={8d$N{moZ#Iy|~AfeYKLP8~as2Y{_10Nf=v~)lM#p^P(aS
zN_={8WU+vIdRO!_tb}vw(paI+)DXTKU`h-+8-X`^)+s8VnMXlfojUH9YCpV)p}eKE
zMM3nmUt&^!*#o7G3y=P`IQ+npf8zBK9Shx)RhIT8K+F=g6Ad%N2S+)YX3_KS=Eqam
zu@&V5|DN7I_IM_M-a~Bn?pYnakE`zo1}#yXwmYzv*rl|M;ZutAzr0T~!dwtm%98(r
zld9)KVe``(GLQ0SV{5rllAsWlgz)yyT49wdl>M>cnE;!6+-{a1>R1lDRFsvzcBz}q
z)y~!wJXqg)?jL6o<Y4*<Pq$7HSpW<x%+E#k7hT7i7x20F<JLQcFoU3=KAuaQ0lD60
zUKR4iBs2uRl>F>Y9Qs?yBDCkt;faUbm51aq29-4$#2)E-B5>}5&}xZ^|D!~JfcSSI
z9**a+d~{;5ro%)@PJ%urLVNi--w(2)k4dL)i%l&e?#o&(Y6W<F*xEE=i4(3GrY<8>
zF;^5FiHr_KQh;qEpX0`H?$QDmX&|@AcT2uhdvw>tK&Ru#rSGxLVV3^ZU{H0P0tSOx
zO(g?oL{6Mjk$2~&aH%z9zcuhA(%F3fnkhzhmp+%`+v_4=GklD!Qzy!Fn@Dg}Agl5D
zpwLF6qIgX1qpLWL>B#hI%ntT@oznb};xcWkqf1E@8a^`lYXm9DH-hT;4fAPc=HJx$
z_3RsCL9!FCzcVu|F)J%xeeM5!`}SVi7ims4&oUaNwRy&XxK^#KeXz_dIQ!xAtD=Ms
z>P^YN$%x}FXj9)qYrf}OoAV`-*6}mT5-XdA(CiOMYzUn}8z%vt=C3A`FDb2MDeOz1
z*S;o;WtYp+FV!UJ`jTn14s99s*ep|QfT!AXf-K6KNVZo6K^klyYKMY2u-v2HjOrYX
zkI<`MHM`vkcB1F>_;uWWb^p?wUN`lZ?+jqs$TZRZmM~7I{u*I4DYhTzGF^H~KP93X
zi`s6(nUg7^>Wj}xG_7jo^fC+LpFKBCKW@sT<vJd4^?0MfP*Bq`@FiJ<A(A-iXZSU5
znLa!%qn+^*K9hN<WHEk6$QNz5hYd{32j!9O5_gc*XxW&&GSPzT@?<tOLu&r>b@Gu3
zW97xJCQNTcxzwk2!I$OJapS<e&4g2Xg!-X?;xD)`kU@(`;i!1&7O|n3+{es+RSAm4
z03@tYU+zjEb!kbTUQ?;waDqks!U}YS$Lcdw9uE`;$&LL=aCT&|4V~ni@n;6FzKt*o
zzDD}AZNaKFH5gGmiqinn7*1nHJcQzve1oDMTZ&6+1T=CkAqop#cm>pc?jii^M1Ym*
zCZPyuE2`Y`l(o~fTRVVbGl>H_;{@4X9)KZ;)IG|MhfSO$ymBa+aOdWDp97o;WzShc
z8ZA9em%shrEI{63M2pNG@2^+0x)Zf`e$2lXOrE*EJ2|g%UHLkdFurMIDf7q@@nDtv
z!RdWQS+bW?l^u?if?=6XaxR02$agh6I!Wz3Gtfo~=?_ae@t}X+Y|(ojH+6;6_tngt
zuqyW^|HwpaiB5j~T>hdvPJ-rLSESt2bk7XgGat2^Kz--}%MnwFdbZ6DrSbIq)}B#5
zlo?s@xhT80Y+hr+5xW^R3*Q4FCR4(S_4}I?y-9Te6NW}43I-yR9_Kg-R-ijFRCjem
z7-ei3f4NwkgAqOsUGcnvZx)Xr)_zagM{ibaeCa^}>~q~)@&~xapPnVgn12jCv|hE>
z_*HjMtMF-d>mJDnZBAH*yC6A}OF9)e^Z63mgD27l1jk(OxU#|hrV65~Vdo%5yG#}t
zRH3@}HI_K4{M=_hm>66(v9PuJGUwQbq1Sb1j<GQ#&uGC_vn)yHk@v&$lHjP=fk220
zF4y~<GBNUPUJRN=waaW0#{xgAh!PRUFo`<((k34PrI%#n&2xcMrmR7&^6WzM3hZ}k
zZMGrJ91AxhM)~P$E<09N2=F_>%g}wl2e#~R`d9N4+?^DIi$+Vs<z-Qnv3Yjx8m>OO
zG^M*P+bDM4tWJqg*}hCz%bdHL+<Nr0neLWzX3kbt_V+zYXhaFV#H;1k#{WmtRfe_I
zb<0wULvgp_4#6Eti$jqVcXxMpcXuhlDefum?(R_B-R<V>_uSw4bI!_=Su?Zu0bf~B
zdt;guDw#u^25hg<xPH*f8}K#L2pP%IUI-82**i+=Yc*B^l|&@&t*zeStLa_o24oC{
zM?Xi(#_ZTlUE0t+irdsY^A6}^@Ne>hM~|u{o$fY-V+Z}k`u@1_?*>f$$F-*TI4}s1
zb{tLp9t={K{E=}Z>iu#wk#p9g@p;5^;`meWIpvsTtG`cXn-LAGvc^`cZk`xLJPQ>2
z)%x`)`?ss;ba|)=n!z$p@aTjmaVgp{cR=X`$$A-$fLNm>mVI%vnWsU&-SvxNR_iu7
ze`#qgIyj3`H9>Oy{Cx*bQ#gl*rtnCa+K~^8dOB3;VTet?USxaxL*)uY!orQ|YN5w{
zVW!c1RL7zTVPyZz+Oba3D9x;n2)4C_oIDcBgex~WM~6aXCR^cJw3+J6j@)|yhaTID
zy|iv(_Fu5{x9OD^BB|dq-WTtkhwz6K1O-c#oZ0v2-u=-{O`v4ycdUt&Vjp)iG3|Ea
zn&AXVZt?^n^z*<G6y6o-@^*_^O6wi&CgSI{;pOk1N53JtSpMCwt!4e9xu5ICdC{m7
zTp*iHulzhcVFl;K@)Ra??}!doBkfog**P$S+b0p$hJM%MZFw@V)@}V;CfX+kl6zYi
z#%)*USqB`erzE$GU!Pt)qxVsSxAd#HNW(Y~=7`vRUvs3L9cA2rC>FJqZMgB5t>+3i
z)}#3^dYQh9a*CyYrheZN1wrNX1l*6b!7>i0yJn8v9F<5?!Zw$P62_9AH~F=IpZpd^
z;z}TQHAGJuQ6&r#J<NVrF;H$9$svWJ-jA}`$)9_fVuRq>`0>E^EE17<L<zy62i)-1
zAUYy^d}HnbHuf8&*WeIs<Y+T_@;O1dbr;UTlau4g+b<m<dmn7n0gYORWkEh*C*jU_
z*loo~af9i9BdWfY6K|9*z8`^^K>OP@{5hs7>zsW2!AS?{=UUSnbU~G*Zw!BREdF8E
zConO33@jrtAoIEbR}pSYAgF(u{~?cY7lhzgzEjBOmgQF>j{la)Bfho4QmgqlZA~gG
zU|??GpiOm<a|8oY8gBiM9i3b8p52Ai>X2g`foWy~Oxa=-=jofSFM6W4tHN@n(%VJj
z1CsBethJHF>H+Krs$A2<%A{f-r{%6>I(zw&rV+x&&y~Dpd25u(Wi)3>zsPLC5o<Hw
zbT<FCy{Q$6{vO$_Yx?A<b?01gR+fYLa&J7Wggy35xhQn&=lqI8@mE8t`S^T&;hV{t
z1l}q4mm6G-MaIMoQ*Nokk9Z`=bIdo4rz9iUEUGJQeHI%m8v=O$nLJE7u1|b2zG^NT
zxIp^wMr#W;b7BNi4eNa|GVY8Om&RDU2OWmDQ)hf9v)K8-Gc#8Ln=18x%xtpH5hnb`
zl`R^$xbG3~CraqtE{%iGB!4ps88gL!-i?pwTCpBn-gKncVf?Xw)79rM2{f%#3vV>y
zu^Tz$&k|?m=vIO&XE!F(<w=OAp(`vO+&Sl)*XwRf%1@tPgVgC(v>4aFE1&H@DE?#f
z9MZo*)(tQDzaeb7d77)13=LWhx|B~UGKkx92<4Mvbes4#Tg8~EYU99CJ_BZo**`Q&
z@{u%BzE4%gQgzE(mnUjLnBSUEwayVb-_5kyM^rrM5p&&zXX@15(=zYr->uluU7h$0
zjACk%wbWlv3b#5dA%;MCSXeHPY?Ghv8?|ND1|$))&lP4b0i>$atBqEA7m{TwtBp4b
zcK74Hn-V8x_(7%ra&NWHOEc<NTarZsB~+bdL`;^$dRMaHE>d*m^9xD!&$mn}>gIRX
z+87n^AAxXsWw;`N7P!hsi`IA~9BK5y=BEc`zj_{{EKL!QzOw*etNowoo8DS0w<GCp
zo!&<g`lz(xz);sWQ96S3?dHF?Oed6T;x<QW(x>0Wm<hnKD>4eDaX<&s0JmJmu(~TY
z=%wZ@0nNkGPol`=ByC|1NaFE`60Y{$F8|`nhJqW20NIN`b9U>5@A~VTaKmv_3ddp~
zOjGUvN0Gx2GOmErK;N!gxYr3FBuB`=QL6)0)cT{jV5eLfMoQ&ZV4b|!;zCP{ML9xt
zSHW3zd<MNj-ffOr)U#2+oftoF&eP1ShYP56__Rp%SwD@)y%o68W=Im5od_Yf?QSf;
zoWcxuj)@mo4;$Hd7{bZmmo@u5?s5CehgfRWs?A0O{u_R0?xq|U*`llts$KnU)mf;g
zrKjYI@2K)$jg0EE9X8l$EPvf<v>?zcOB4yzv52>)HCa&|Y{`i;H)b0sOaJH1)8@Cy
znPLAciu2YR+``h3WuASNey8GrcMCXtMMi6DQrAb#hirS@_*(bCLFi19Y7yoSA^mR{
zZ3~{qhjnkcDeTJhM65Fr8x(qX%)IB^`pwZd<*>iq%Pyw>emP4zpzyc>SiDEr?mw?E
z*Jc&~oke#rL<yGf-4pu%inR;gZ0-2J%-O`#LiPqpAJ+vn{_Ums%Kc@QRzoU?ULQ{<
z0KHrHHAGX6bZ=T-*p#ZuBIWJ=1JSi-=es!@mFtCI!6-7rBONN$-m?WgUUuEJgx-l3
zdGf|c2^6=puxfiPIC+sv`!(0wewPtRkO@)3J4_05o?1q(G)?8~0v=841N__w?F1Au
zalBkkR)q0Gri4F!u0Y&}TBzdNtDPE%xbdG%+S625buAay=b#UUV2~Cu5Gp$jw5I3h
z$aT*xZvuj<rnGF}?JlSo^<(;h;H0VljixwCfIXyb%E%xVpW5i{E1Y^Sc#7G!emf?K
zU6xgLM_5EtR%W394|I<yICeX~HRnrRqAe&*Zr4}&8e_!>d@ArO5M;W-zgO`Lr^i-Y
zZq_RbwK?ba#6?Eq&CSH^ZAHzCs1O4-p9RlDXbPLHXMV=I#4Mn*WLBx$oVI|ca;lzN
zM1IJN@CqGH*%<j$y6;)!)`{fYuT7JMtC?5TR0`$7Bhg-voZi#{)bw+^5oe19hihi8
z|8ue^YXo)Ohb+}`%Pi$M46%G^%C<Mug9E6<x_rYzGfFse0S$D)h)Pd$2`zRcyuT~d
zcBvG0n_6<D@2D*h1H0mRBmS53-V=m<ZcoBZ7n=;>ez^qtq`Ao0p6Z|WQ=fB{6@EFV
zCH*gbJzQNkkMovsaH3lgB`U-1@y(qY)F~5YOFI>E{ev{vT`ELX|K9wW(t+UN^vIki
z#O}AD&rWp|rh{>i1FN?XS9@t#de&OnV%Zn?ccbAP-&#yrC<G({<;m=WtZd<r;04cL
z$p%wz1v^xgZ};utAWHjF2Hox-g5lLacI=@$+D|$eM%JvgN)uu>9w~YYR&>?W&Ygl6
zKN^y3?>*)xz$oR_w=M^<?t7x%2tMw~8xaiH)~)_Wu4B?T(w)LwyItMgj_LAxTrkR{
z!<4l_)~i_Skc-6Wm8Q71sG#4?9v!iarlm^RXn|=jI-=o!gh$%6?hc>4U&_MBUSDn%
z>~Om3S}dZ7y+R>`X{mtd!Qv6=uW$Tr;8F&JR)1$m@eKy&TX#OfEwnoEFHEensn?=w
zT~>8zT@P1ulCrY#C{B%cgidulnys!4B`OaGknyiZTv+&=PY3lK-6@7r?9tg|bYvFF
zCg-9)<$Q=@TmvYv<Z~LaEhJO?C_L(3vpo$@V^I&M`fw(uVi2t0DF#xJgM&5El~}IC
z=1OT=bUGcIclcSh4$--}zuqBh!S}G_<7+kf*k&zGCm0+#vI876h8mZM+awt};lOrP
z#oII`t?KFb3@h#}j2|84>*L9BBZ+#6BrLZLDm@;#Dt+AV!_-6WXH=WEGI&*I7OOw-
zKy_j5r(cX56RrKoE=_eUi<q)v!<)ICO#KTo*&<X#hQ4<7VSSHVd@R*-Wju@S6<qpx
zvDSG0{Us{VW%9pWHxpd@8U&`?*vEXNkU;V7S1~D^ozJI}e>}$NgoyU7?N}Qzy2R1Z
z;DDRFr+W0lzmk#PSAOE^^WoNa2UqJsF@mEqR=`#r?(<i_sSlR|(=x$uJUmy;OLbku
zkOPPx7^J|(y+7oW6P(toK2~P-vu;oxNO|T6Ac|36#GVIlxox^Z-U~{c<Xe{Sq~~d(
z?D}($S?*e1Ayr={|2eD|?ACGI5^e{fEDrr2X~t<>SANszx@#w%LMvY58;Tc$w_HCK
z(~WET1e~#>yuH^kz~24pO}|)H>npZLdZ97l7~Pjg)YI@*rXe4y^O?Pu)qkA!KM8sE
zHe}~@VLV7%9A*bYvou&yQw*e&1ygH&z-chqo_#@0$UR#BpPEN=J&KN37wH>_Ceg3`
zgNuAT*#+Y_+u=U-*A-j)u|^d{IN(JjR8&?kjAvCfnszXT`T9MPmi_qi4u;Ru70ef5
z`K;e=FPH1A5)^wxagJ&m63tJ$h458|M(F*mkr$u4HKNRgmkhN6d7vR4R6vj4R_8b)
zCqHy%???k+u39%MU7pm@qI^QBY*lvqQu3Ig^WF5kb-RML67DVA8wRbHMCK#{qy{qh
zPIXl$S|dhLkS3ZRu8qZk6QNZ`toXIhOcqompcw^Y2>|s5h#Pi(w3uD2`AKr#*0O&;
zVA*tXw#Ihfra69p4Zb)#8wH!Xnwpr7XQkKW*k&vmlfpq#p6T)PLYpI7G34qHeXEPm
zSdTh~zQ=61<ul(^*Kk(VgF3~ePiYxL!P=n?G{auc{I1tCD7j6A8hG>rkliBi*uQ=(
z$aMV_zHRQ#3f9hujXk8Ywjdj%gxf=4@wLC<tOke5(1dEVbI^+V^s$k6cQ|NvRYT1h
zYmoAn(6JcCi8(sTmJ0Lwv7G0}WVeT;*U_0mq5bvd8Dx*w=g_bd6g3X3hSb+id~Rr~
z7=1?oZ&RK3-FW@bu%#{=CXEWG48{4IBt^6ER#bKh)w_ro-A7ZaOLTS}VG=`<FWmyJ
zaO%bz+|M<VGd`mlUeu;HGp-6il}et_@`FgBd*NBMA;v!QEd3wcVx?R*&ld`DT~q8P
zH?Dl|j;ylvMVgZIrt+ZWCsugxmwS}3$sU|HnOqhhTV-LfQtBsLFM)5qUpf#&%0krf
z38XSdBJ$0`*)G%9^cwcRGD9C-kJGGt;z?|ZdqPLxP)3X|Kf#r+GKgbi<~$^wAra?y
zL}^c!8DhE*ANEOEj1g>o`8H0Su)-|&K`QW>eSGCGct`jbt=LYv^}b#jF@vqj66(pP
za@5tX@;($<-w_)68erU#Z6#FHl@R`g+$BGi*09tor&%nhx6e8j3qQ3{dTE*FkzH8*
zeS>Q@;+rvE__(hTMO-3(JKWv*w;Q!+aN6tzwI?FIG`9U!0G}2<W*YT0o~#L*@#M4A
z96b_n;)d$>M7dc2saED8Dm`#z(#wCANZcZoCBLkc@=NV&-e{EA{^`?aJC4b{@XS14
zMdm(G4XuO~NYa0u4Q5Aad_}#DI_c_H;{>>~E_`=KIlmRUr$mOuWIiF>8Wxobv744H
z@D5AzWTmo!<PGhps;M{&q=et(^Wu%{sdgk(V81FglpG-kdGd@go?oi#mjRfyISA`|
z&inFx3O^Og0&FXusKgtQjpLY3jO(Ka9K{rG7^%iR!Q8mQj$GAvMpz1%nkqc<ktTp1
zNfa-pyK~y1uw8v6YOUsxm&UQenQS<AX0AFboUxI?5Lqh^d~g_V=Cw=vP=ZMW&`WN~
z45k3}`wk~V^4v;G<!c>Z^R}7GhQa(_Ebfj*k6O~-7$$GF#DM)?PXQeka`wVoFhc|e
zK05TFl1nb!c^OX3#&u%!pTa7gH*t_7=>{?ntI~1+s`v+2#!@n-A?%+?^pu=UG|l<f
z@}g$gb%}B`4f4Aox`OAs>sl`p@i#h`I3b7d8}u2)V$}UvqYr{4O|LQ$xacF^_)7sF
z!Fs7H=#E5_C%GkQI^tpgJmat!Ge!*<2crG+5>GGM-GTHK?+_k1vR2&u6S(cUGkkSI
zBY|knb5_eCPOba?6c?ZJZ>5^fLX%C~o*>uo){!z3P9p|sEt}VeP(7D%p#w#_p1CQL
zsC0v$ZL~=p@wC};{yXPO=s_J~=h#o<9U~x@2%vWTY<5Um^ed()pb$w{(Xg_yMEfw#
z!^E@y-4WJXr8QQc;GzQLsZl@dBr?A9SJ1~)1cZ?hHY0gynk5|>*?x^n<cOTszZnEJ
zCLLMOm1W7-LZuk`am^a@DD2aAoy+uE267UlczQ+Mf(KMgRdy%6mh5=qS3sS?2lYYT
z!h6)qkroAGW26xy{q_zP-t=kx`M~;+Qv7D-mtX`&C~RrhU|(0b1HG{xF=xkC^X*1$
zl^M@4|DUBWi6<yw>({??PhwG4CPs{<NtPn)Vx>akp3U6dFkgd?@ZuDj6J~!+FqtpB
zYVp`I9UXrj7z__PK@B>n-yP*MTJJsZPs{Mz#_ve|tkQx(X0(Lr_G{OQmhYYa-tkZd
z8vQLyzt}GQ3Ym$L@%i!U+NNV{(ByPoaS!S!)2DCHpOhN6l6Gx0%v#rEp742-4Q`R~
zSj%Q9w9zBumyUCU1KQ`%n=P-}2ggd!SEyca;Bpno-z0yioCsw<3S6k)4L%5$atLRc
zO#T!9YTkHPLby-A#Vj4tqNCIHWKL*tVz0O`cx69W)U7G8V}>n=2;%@we?2pr7tzj1
zc%P%!i_>3HJ2_+dO_cm@n~%_0ld|agQ;-=FfFH7@Co5VtAi!n=vTfNPa)?4Ud|7u)
zcx}gsR4^7^hGt@5ei{E(G`100q@xN|+=q$LauSM_OC}8A(^wt2_RqaE4WuG~(pfcQ
zzqQ)TY%MHFJ_H0ZNUjJ=MT;$!M_c-Y#OF>;yVBLIKM-EvjWzi0XE6yk-clHMMY(c!
zbG#1=iww%CntJm2|NOmrP(*8=&g7gH+b_m0_(0|d&dIfT>DY<rEB1;Or648nyXa}%
z&I!2zus5>7%JNPu&`aOPdla#ZG3^IS6OQ};WdnM8XDj@!q`6&%ZDxAb$BP2sHJQU9
z%Z2hweG46sBX`$mh1m;@+OQPK(giYNEW6VNq$+{|7L(GOPDSl6o>BZLc(X9Z!Z|Mw
zI^sXzxi>Sga8F;vfIqMbDe=Ltp;~v#uIgi8=p9d(8JPj$inLZ?&<wqew#GfBVEi8(
z{dqzp{|<`1bIB+7@uPQ<7gAbii%b^r<$$}O96vJ}mY(DCwqV#(#iZt&mkUw7-%)dD
zOQM!%DL)OF>p-d>hZiJw_!2eXbYU*)4|aci7aE&`6E^ravNSRryQ{>tj?%MtDJ(q4
zYeA|tc=HN9eq)W@)=TKD(14Q<UT{r?q?>gDgQgx`!{y&&e#Honoqj1!T&{aTwwe3N
zasCH@Ad@@AFDxT{m%rcP6Oo3{xz|VcEM;sGVT*ZW%cv1<M+k^Vaygq%7Zy9jU_N+9
zL2<w%?YOkm`-rwK!{un6!Nfw*^@0Bbzn;;jet-2U-%oomb~?Qm<jwCUYd+_I)dHk&
z2KP!|Pe(i7sY^kJmef>zE3s8vvBS@m+N;n#Y4a>FPfsMpR{#elVfBs`L5h(XNshl;
zYXC1{Ac^kxKYnR7T(iKWGD=R@9~nF=8)!&*9?aPx(WM2jDdG=vvyOyuHoO=QT-_#k
z?I>2rRw8_B6qfy89QGM8M|8wPZ0*MIWf!mKc`%Zgsc-74;)J}0n>$G*hpca2?)Ag?
zKk`&>d!4Wvc9Q6X?=+5#-Wsr-8#ae$?4@UM+nIkmi~#D?6JRs%F884tuC73CO&Phk
zVUt!<<nK*K@#_Jc=@SnKsjv2y_t`>4qT_528fc7?;!jnLQUfW2Q}vl0gui{z*~(`+
zZ_G;uDN$M83SsLfo&-W||Jo#*R-G-bf&h(=!!wdbX`c+1J9>+5$pnXQ0&^rQlR!#z
zV-2_;EMd7l@;sT(FXvRbHKrMPZDyGDOrS}QU`H|BiXeifBT;()DwKl|=KYf`7D|!<
zS#08MB?`V0$Ndt&A8T@h7idn+iPVntC(cR4_RFWy8p-jZW<7KDBJBJrIK4N-)gRk(
zjw_WSie;(juWx<z_prbg2YT^w%ArM&o6O8|sYHQr$Xi;Y<L7I?;7i|Mk>IT{pD<6Y
zyDoTt)T?JU!+PSMNogFd3z5ltFWvm}K^z45l_n3=ROt1^FHxctBqX1RmJgld?BHYu
zu;7)8X(L#01;HfU_&NKCDnD3KWz$Ea@{BQj8vJ}+LB=dX+$?H)k$A3@rQSJF*OAik
zcrDL)YZc$r0VbP~osnTL86&#u+4V%h`haTw$)0tSxYHn=j7DTPoGtUH^q%4DoEfNO
z&<?;NF}YK+sKW(1h8=;Tr+kp9f4W{4yxSb0YDDh7-2{)Dw1&*QnZ$IquO#z_PP$?0
z0J0(|)?>qLu1#?3PS;)$SpK0ZfV@D6l=?>Bw#;HWoZ*@2vdDzmw5(!T{8Z-=%+KH}
zHn#Udo6`;TsWKTlz>icn{PfV5lkYNqLp+{qWr3=NC#>Rr`^!Rc87ql7mM8u^o`E+5
z#-7M4A1$5s!mq!(%glUogL8x4;v~}P+f{G$*xo>f9PvDU!73cgnt6BD<6+lbBV5oz
zK(57Nt!8MAlFmI&J@Eq&(E=Xl<+{e?#hV(y5g^gRtwf=6D_+PjKf#7M#ouM~sp(6_
z;i&uOjvp>AR8PwMt_sl3NsX76u~1+k7YiRbpyB@HC|%x~BPYt1GwWB>>#<Z2JU%CK
z$sH7xOewloEK<2O_r5kp%onCipEMgMzB$w=PxBMUD$J0pn}_gAd1yQepgcS+2hW47
z2$sSd3N1z7Ox&!0kPX1#FK<5<iYL^UCSR)gW~2FuOH47rVbA4V)JWH)%>~b#{o~G8
zK>u0DmGwK^{VfBMKE`QVf<h{B+JU*;+LfYa8J+ap)S>|5Xp`53gk^?MA-J+2;4UdO
zevmVfqA)c}xRxXV9BB^sIuf7~0nCQq223+N>-EZM6wke)9BICpiTwVH?jG_b2ublq
zJ=9q5tkb@Viu0f_pcK0hh|hlUeY59G<+~ylsfM7^8Qj@^hS)1$JRP0}s%-_s=oL3}
zwcRIl6p@`kyUB=qv!r!9?+IP!6@BVINRg_!u7kOirGO1sjR=5T$hgj};#4R42m#k#
z4+?sA<oMaBL%}x%en}CaPpo@~V|Ft%yG_yd3o7aM1tIlnljX-@&ZRXeMHQlMM9qO2
z%C3n7wT$Hv5g^)#>C>#XSA$Kf%4gRIr&m_^fdHZpv&J3w(r)G&_w4BaT(lxvgHejC
zKew1TPQaw2-qL5zYL&O}xWK>@BhqOG!IcOd96C~pc#6^}v?Zy+*Lcg%udYC{2w+3=
z;pL}b-P?7?LHT9hl8t>i&9Wt${*bt#)S|Y}Y^a7LJA@>EEwo|tX(K>Myv64?Fm~*A
z><h1+Od3ZqA7fw~KTKj4c*g=-?y?N5{nnI6HQ3;H;>Mv_+ZtEuz-MlR7If0eR|BZ?
zg;L|SjVQrsQpg(xJ5P_h`jiB$`(}EvG3N<}g^?y4(t(85OBo>A?5I}>;prDfKy)$L
z+CXIg;NsPy9dGw?wb{sEh6s*-dgzu^*0OuS-2-jPzu*8r*Aqnfz`evkw#WHpJyW7O
zmTsXhaOB{+o4zYHdbq&&ohVI%v$z!tzn0jUrul#W6*coGmDqMrCwmWn`Q77~%1y28
zAz?U>E_C8Yb)P0V=UvBk#&=!$@>Gx#gE<WhM%(EidjS%jj^413Z(V^pE@n@U<O9p+
z2@1wu)<`s0bkcjTKteb!Tp1ZLMJzEobB)x@j>$W42yE$AqN;1Zb9<mZe-QE4#_x-x
ze^M1o*{{c-JBk0|v$h0IzM^-P;KqY`_vYViBsJu&1xcO7{0BdUq^eEka7k}S-Yn$^
z_f|U|+<<k&<IH(1sK>AvJm{o39lCx(e|gP^gxbSmN!clCLR`G?dlv$~@U7rkw7%n~
zz)4(H6}YF`w_%}zJ?7cA5G=@}!Qk0UcS2g_sK#RG-tsBn><+JvW^f9g(9N{`D|AA<
zSAL9bl@y{@ha*j~b%ls078Ubh2J4sK#-zw#b!VTeKC8y53Ky(8d2_<>5YAaW*(<<p
zc1S*9y8GZt_%5V46LP|wJ_XAYc-)y6efC)lQPGwTLg3F0%G6&(ejvdcb#QC>e=h(U
zG}Enl|F|y#g}mYDPmYC`Y?-^4QPBK<84p|@)lraeJoj%l0T|r%4aO8KAxpq7Owdl}
zh_CgHa)$=A=oSdPd1Iw=5Y$U3{=EuC<?3_xP4^|A9Alw<bPGvKKw18|EDl0ZdB^|e
z+bM3i5!ReaodTkr8$O_M?Mu$Di`j*^VK78`o3|Ow=LLgwB8lkrQ3h?`Tgcb~GH_CB
z<X<689nO&^5%zF2_rFI{55qHQt>JGD{bB-$K7qM`#o)u28UMXt^s0&j`H5-#f;<8e
zB-6VUUd!LA7{`UQa}f;NXdX^psB`=G6-`Kw=i<IK`D*sG+7wemNJnw<1J13Kd}r?c
zV=?nOIs;L8?{%O|kP=0uEJ&eZgp<HOck6()=uCJa#iEa@fBpOEg9%;QBvc({x7?R}
z{O22fytBS!{<PYO8LAFZc}U(VzN9tUec&7in6$bOb<bD8IqFy@T<gdhZ4MF3)FUt&
z=TA9DY6jjpIf)q9sH{m7O#fL60rl<{-8YKwJd_*e?fH3QgoB%B1MiY5<4b%FrSKX@
zh2vTEkc3?{V@lgrGi)M&)>;p}XPtR9S9{KO$eYx<;>)|eY8tri<{7qs$I!&}M&bL%
ze4*2QiK91Gdy_XbNp$f4tBFJEN)Ka9i=**Q$TjOf{5QS%9dv(%t28|iqP9d-{FVw2
zWE?-Eaff*y6xxj4!jU_#`j>qTCIa8IyPWdM3R?#e2-kX8tY}pPq-Xvkm;}Fy!_i>G
z3VW|g1zR@Xb;dH87t_v#rpW*hT7cO);;43qZ|}0@KUL!w!lPI-ap`1DpdP!qzRVmh
znSR{Pc@t!wfy9nKI9UM_xg_Sj3{}@2PE*4j2|PN1!C{Jp9{8*E$Z!uDDm*o_wmxA|
zuYkLqTN(%M-{Z&Z99u=j8nbeWWsw{2wuD-b_Q$Dl(LWSab&QCLZd5<<1SdK{|II?Q
z!l0laW`{l{?NOa|NLGHuD$IDe#eDWB+QjDt@O@<K3i-uc*d~Y|fPeWGH2yc!E?VWB
zJOyC#b{pkm@@j?%X}Yx1@y#An`m(;ax$sDUEB0T^XUA;0L}V&PDex%3K(w(HzT+oH
zo7ye$@uUBRtWp-%LIZMg+lue^?sZo6C6VVacI@;uCBf2UqzSKZI+9s`kE1cc0`lu>
z0EEuS=8-*nSQ$|;B3GVm0Xx0#V;;|HV>yx27p2DALTJjY2z%fD#bVQG%Ad_%8@7n=
z)sSKUsqG!9HulUy&<BcF7uB*sarQ?Y@xtb$ax_wwH{K#9GkK+}vr>+~VgI(5)vNUw
zc;SPGoTgRwL<JdP7J4`qa#}G8#h<z8cuTaF6L~Hm?z>#5nTi8Q)eHtZqKe=VrBN@~
z?bvcS*pG@bcqAjjY@oC1lGku`rmT0u%x31Yos}xeE;r>}pwdahs<y6X7Ae1WK606J
z^;VNf+V;+FO6q<H+O4me0C>fW0Fh-_Ym+i=;L0stNK4762&a`5lgL@G=bX*94C2@i
z(wy(R_hE3ao$+Zmo~G-`**!&wf3R_Rf&~1#4NUBpxz05wA<zypo=%TXRR`v70?B#Z
zn1sgas#$P1LdG0FTrPJ7uI_4eo`r;8SZuvsu2Qdmvg(u;a^qtdPwBx($+C9VHT_X;
z8sEbPPW=%d(KW2OD|P=3bR#TRzCw$7b+&XhluL=#m32@D;O>y3)S54GHjbs|Jq~hY
z)63>V3@^O>Jyacg^zX)xS*?Q1vNk-2Tx@V`2EPh%ES@;nA0J))oBW$PTchnazU?se
zpMif3sus{nyV~9U9++h8=&E+P8HHluVaQZA9nuZH5V{ZwaYbJ*u4#0-W3)cImN7$G
zP6T_6evQhk&LYVFS9;tX{Ai<F{^lQ__jys$;%ibkjxnT1B#l&JKF*H_9Za#0p+q9+
zSnn4Xc#hTPr-78n_9tG226JkzO+E1n<CmqvosTT2&#$TNR0i%7ac67BhnWD=sQRW+
zODLn2Uo!W1qfd;D^x0caf(E95O{9kV#1lKOIq)=ErEWkZmp*%6SY$Y^?pw8$Y{pp!
z;%=2rl?vU$+iZy2RDo39Tuf0qVF^jaP^{{=h#V}V8?^d0n+9wxe3mMjE7|8Ny)3b;
zx%WWYWhc6(*0n_AAL}BX1>3nQ-ER2!MUKn!xoXpp@<rX2z2)M2*j#bO@C)V9pP@OW
zo##x7i9g8loG%D=?56s>WlU*;xPYQ=BE>IO%GTQ{48-Z_dCM8OXL`T*&HdR5cHQh*
zVA5WI)7Ls<bq#F^a}+HK`J>0)E@~EbG_Ns1mi13SEc;z4R^mOAFh#aOXh;Zw&dNzB
z-u}nlwNgEg4TTYPxO_z%h6`*lgs~e{7X$D$4e|<Hk<1PX*7ArMUB5u^v5-_Wd+cq~
zD{jvZzHt^8!V%SMM3Zd=bN<S;`#qn&vOV(@j-N?K+k38eF!#TVMg&*hxc%a4e<`N|
z`NTncBptBx(gNF)9tY4z?d?<lk(l0E7ow&Qb3240T!t1!i;Cr<QYcSEZuO_^>G9W|
zQ!VbcTKn%`Kf|)ejq>A~|8Ug#X!}yf+bP;F)PUbGR(#~cs@z|&AG^zWj{(q>h*3CD
zFDgIb`b{g%>p0d8Z3l+yIjVsB*4lIexe^<0i@EoeVc+WA0c-_(JcP}1FFqO^e=W66
zT5&%+s2oM`>tDY0%UWd9Hcjr^KQho*UzMXY{7INTSj+a>_%l1#3UkVmiTrm=Agh10
z$40U&1+p$fWQ0Y7HdVjV0L%~$$ocv0>DP(sJdGu`J<`lC<E)(kJv4od#!f8OOq(9V
z+4(oWS)D(snuUoTJ~BkEINfB#16Ec+8Ii@b6M<t<E83}<bkbnQIbR<?)+WOPbSA@+
zL1CD<1;F^Z`IgQ2+F7(&hi><%+v~R=8Ai^rT(a?$sDt8jcd_uEv2zk+ffG-msvKAq
zEs;^?toqB5A?#xf>7K-raWFg!G<vW7Pw!CY)ORj0FalU;RkJQnXZ9taeE3jTp3r_5
zL$fTI>1X>hi5-d^ieb(=GPgHTf7VB<qfDCFX^xFgK5VE3;N5er>dg<#gb&IOQPS%1
zPy6wB_xJFYCd4eQqGWtIAjV-;tU{+|i!B5^ALv<eUzA`o+*acve_r?nyYai&)P{jL
z+&Y{)GNyb#xrtLFLTBAdSaLBbKmBi;815TXk0jWtqq@UWUq4lhp#4crBwa@1X}E>m
z_hF;8`vYwVEC}JomeCd~HIvg(fQyPuq00wKKZoA&c?hPWKIR%Tjbze2xAss476UuZ
zad?P=wtNCytmqc+g3a;j7Nh?t-zQ{bc9<pr*Te9D6IucGZ-~6GpmL|v+$g?Gr<pGk
z4g_E;`Uqf|tmXp}a?>Vf7g1?h=*c9~2wKr3C86W^odm$)d4PWW>!;2692u2Kk|CSS
zm1m``hp?x1_EUyZTIKE^=S2S1swMUAKh)R#Ic!FH$;~yK{%lAprIJ9G?|IjDu28?<
z7|b8KXEM!U6&@WtkA+*uhhvcYF%}o?*6!5OCnedZw{959E}g@Rx_mgJv{D6Bn<G!j
z;65_{XlP1EIP-<0bwOj5b#vkC*OJU~KWP0NgOYs`4#X-XOm8;>4BqC=NK`(n<E!|u
zO4i*N?%Wyj`gTevQYK@ocC=ALE?Aetn^vRT!+;0~!Psk9h0AEHc&6Xj@QvnYRvzZ|
zs;FnnRu0yox`*zq5npQUx<9giCN3WB`$P8|)Vos-=c$JWt>*9{&NAI&bHF9(w;eNn
zYgp+s3N$|aC_*-i-M7Y0s|wbE>6aT$saX~2FoX&15LOC|k)d0*TKz*s!+1~<%Z%<i
zj{Q604gC51hIoB@klqfC9+LQHo<dOc_tROfY}9gWp}^2k#eMHrzZ9L0n#z2T5)yZZ
zC*$8UgVK$esPF0$*k?KviWQEm-(nxwKdYzX)UMZ|;50zm4@hF-=T|NSj^2=chK$V0
z`g}EPR_BXI*)?0*w0CHnfdurikpo%riD&on4MpkDS@!QD<B`pbWJK;Zvk@RAlo_1L
zAAk0IC<o)v^Q<qp@tFFPp?OR@!=qN;dU(oGh*jI$naNG5F{fSF#lDV;id)xCNBjp!
z3wlMC8&?K3*+`*#Y<cx(xFO6ulT&W|!A)o*Y|I27&WLB8puGnXgvnR@E>=n+J`NF~
zU&f(@>Vmgu(5v>2zH_`-Xce9Dr#_`*cV>T>COW3Ve#l~z!!u#MBYnlND0jkz&>QeC
z{xMW0VD>Q_6p3^a@kYqUY9fFh&1^`Ee5;<qDXEGC`t-ULjhOpqfQ5wlU6E{l0)1zh
zu>;@7*2k0`X*%iT+RK&!{YBPewMtXxhoM?!1@^x71Z^2^4-CjjVGC$mmqpj;Ef^Ex
zH`U)qkPT09#SQ1;bW@ZJMdE_$#{pYWK|u%y+ieS-Rvq_+xGaMQ&D+xRm+^DSF{Ws<
zRB4WkOd6=;Pc&BmqNOiQ(1qd@Vx>ftFB7q>FN4=wW}XUqpu*-o1#uL-?-r5bg!HK>
zsw~5(|BZb{3wHVha?Y=TceK((1O>2=Xwr((=EtXxg>U#wfI`;3-Q$JJx!ZXTdR+!t
zp?fE$+vBr(V~d4%A38pN*zX@XQKSnVNfX)`DX^fk*7~!7G+TV%o6Nh^#JA-q(8A6a
zwwEz=8BDj<UEpg2xA)MEAXshAcoZiU6WQ3Ff?dc6K52*sh(;!0mkqnRRk!=uyX?1~
zl17*6yKnOt`s+N>cu{W#xCgQb{aO1bE_uC<v-nvX?v7>B8d5cA*~o*>@;#$OInO@*
zqJ9@0OusrYx=!cicoDCP02$55h?99Sq~}XZ^vkn4*D+d_6ohyU6$YaA41W4F<Rgc!
z{nCc^bri2($eOG+d)l}FKT?(Fh!)GxTtme^Y6nz7D@~`c@<JHbVA!UL*d8-l;nnv=
z+~$5`CnAN69oHJx0cZ!x%Ea3-HsbhCWG&Ly7sTUFEU56#!6)h%dREzSX4kf*<h%BV
zI7AWd+Yv4u9L9L~Bj}{D9mZEVS+lm?nR7<2m6$i~GkZPgNbvNJTz}%ped6N}%9)^>
z|J6#ekewy^y$}g}u;h&9808&GJR&pA)(dHuu(FzN@Bof?(FCcm7+dbE+dCSi+vySx
zTxda%>CFXO!287#m+K<%hhkYwm1l0$AWjPPP|DP*S29e6bU-CHM&Vj1aR;IK$5r+%
z0UNxhdvfzK+GP0(Pm)0m|71XG;xHTp+%;AeB=pU8b@c42{o*}tHuWS}8aW7!a(6&&
zL1YlilXx=yBKUobW1vutP>&%3m=T88n~m{u6n5A~KWeb!_fsnU2!+jY4CE8`=w9o>
zx7}X6X0Plmj7^0AL1vg+-Q&>V&jK?%*2nUU7K;^5r{aah0syp~>P`-Kn<OZNXnf1>
zOk$<d<Jm3D%@kMiZVeGd7v>a+%^q<fx~GWDgkCK9xi7rkr=Rej1#^}4C@j$&sQ^4R
zG1B(v?4#Ry<GH*n3LE$4Uy%Iw{kQ?Oc-yU!th$Ld>SD1eReZpTGFF8qlVjW_oCBos
zjI<kq3g1kj8Xs-Nq)NkO-w=wEBX{PDImKVsHlv(T1a@+(Yp4vc@mLC(_)%<;X4W@I
zS#@h|QT2KM0br&*<d1=OZuk*Vx`M9>)I}@63akSS3dLwyvEKVLkAz3NT3t!UH0OuJ
ze|W9Oo<&qmQ0wnq#KBM3VAq4!C0ob>6l8d`Da`&fbczmQ0%Lpe-4nyz8{YhcV|Cs*
zT2-hgYPMU~_zE9em4$2OZ;{nC(iuHlM5=cpbS^r1at&{eEk;KLbhJbV=FL3cO|Z)o
z_=PUH={IDC>MeIe=|QBW2af)&6|>H$KC?*@vG6`pp`)>~{_A|xq;aX{Q4jh(X}OIX
zB$?&pPuixGe6Q`^=)5JjGEnj`!j#A7NiY>yg?zmGLnu<*xhblrh$`PZ{xD!lqExL5
z!v2YTdIgqySg@GcYJLY!_6!OlDNrbuPS>4%5G8N#`0kG1=C99zd+y%!SqQ6eSj~Hl
zlx$i!WhAdkB8m}Ixo;PODo-<8`C^~;HD|wSBAP)!He+Jxm9(}n1EfUEKseF0rFjWs
z<c`nOr|w<>$>4~}mBc|~hi1XhZ+gw4gfVX8|5)GI`lzmIjrB{l;~isG?<`I0l0s2R
zW37zr+>fM`Dap4dWBL%?cBGdr`R|u2ZKQ95>F(}X*i6v)9ShnPUw}y#y@Cz5zDR_b
z4G|9!91?7xjRh%A2G2^JdWJMZL>lB8VagBxh!c~$OiMjHV|&yA$R%>VeK4no1Qb)H
z_r9oRr?WV#$CY{?Q|o1ELoy<O*jg6{MVoJIfFDVMbitPdJ`IFmhg^9(UP1m@w}2)c
zOBXnvwU~ei=iU=6*K;*geLqGh$0%`Xr6l^@;oz0+3~vlrp+WJ{Dqi0K?o)b=Mp;q7
zluh158}2oa>3y!HGGsZS&dP8UnLjJh9C`wh{+-vgRqsjoWf>((-C6SUf;h<$_<&Rw
z>jvhDfcQEl4f>%3$(=vECLkiId#~$8lvZK{jKFRn?IC>G#;1bFG`#V%0baK3g`ezP
zZ_4BB`T4rxfu4s}9Uvv9!xt&2iF=;|@jZlbLc2t3rjdlh_a$Py<x9akzj~&?%=vH!
zh>kG&UJ*FBv;=o;g`#+Lfb}2faTb*E`%4%u*YYkIBuKG)=}T*_m2M`&AXX|TKE6i4
zvo0(GA>uxyMM@PyMl#)IfyBqh3GymO(u@W(4WDL|IjqQnoFzOphWDU>Ym|kdM^w!F
z97D)vrZ^lu8!(6FgF$bt<N0^06HjH6r(@dqw{=*$^rX1_l+G9`n?+~qzbOpd@DiHj
z=27hYq{Ve!TMIUb-V)=&2sdwV8^{_O&+G#<Ic%d>sVgfgmLVjP#44yZONRjRkysq&
z;ykT>m-HGP#ijbKcunkk;00f@B>+5WX|+f9x{6;@Xx&KrFKAkhAh<x~rc{_fzQ^%{
z`|I_nx?6gG36zZ0Z}k+dIy>FXPKBJ6;1=zG-z(O%(pDyIZBTY5^|DYp;>?M7Q?|**
zOfn&V3Bu*tZ1MWNim$&06rxT>=_e5PVHG0c-!5`>#@59ISH|SzkJ$5))g+zu?*c&_
z)xm91pD8$-iXlPLEZ`1HS>JD4@u5Anz=EWPNe~6o5R^VIhqj@Z4%H^x(z{WfR7NZ1
zJ;1{6A3-zgfZlC!If{1bq%=%beRHpJL$4TNN=Y!U5GXUe;YMPwSh;0VDg06aIw+%^
z>oWS)e=Qp(RhiX0!D=1GtVqYn{C@WPtCQ-D7EAv4w@C=M9B5TmLRrwa1bFk3(V?=<
zD>}sf{R9b&5QNwb9qgL_NQ!4-x87OUILlyJ#3b;^9BCO-l6Jy6wf<jJv}}A_DK=G!
zHz+d5t^jAB<nR}*B*4=JZsH(kkGD@fE;;)Ga0UMPv*NNI7E?~jNz$e}`TPMdUx1c)
zN>tHc$+j?QY%m!(>@N0eBvH0njsfbni6;it(ZL`P_?_UCwun}G>C$=4r!#|i<CO-v
zyE>~V#k^6O(Gd8xSBfVWS^RAj%>S=L%E*kk#p$#svuX%>2XZ!+JQP0lv0|WDmWbeC
z(#7sWAM)^I9=E^e{D<fX>_@R`k33~(+$|g3wcI;5n9Pe7i}pQS$*!c>T$hofhzz6>
z44}WCE68AVUy3;dL&O42tr&QLTyqZk)#}xu18w1ke6@6T>n%kzw0as1{_G;EivQ9?
z>pzuz^V4~vKZ%#nfH5P438>MblCzHzJ-*>VU*u9*_hML=wpbgnE-j)}9vGB>{X4wX
z6|x8~h-28ltR!C}Yw;Cxkob#{HINCz6}u}W>U97or9sJn!rD_5yQF2yq;FQTfOalw
zt9sI$T`;P(H7W|c*63jz9tI^9e54wD7=ZuQ>CSKd-_VGpp!+4n6E9y(_kO|P)!e7u
z2W&{Hw*4<(V(k=P#C#xIC);%iY6224iC%2*a|eMMC(^8@{%2L<ivq#jB+%wn+<kaj
zKggs`-XI%`KkRVJF<=rpL9V?Pln8=Yl(1QRkq&VAeN$4=Nox;(AL%0lPKA4*Vt)ye
z4RYggQXKk?RYCZYoqp~n5guk8lh{8DY#~YZn8(Vni`*C$bK6EiOc<4xHm3ML8dR55
zAf+7QNV<k=*vd`v`G(_y-yA45tyB}vF$VMTF5~io4Y50nAY2-zYd~@~{R_n7(bpow
z5b^i>^4iLBtx>8lt5<U)4GIdUUOxmx9e~#|cBsYA3jVPcmFe)a;*f88g~rGt@fb%w
zR~)N>7CAAp0ZlY^dHdiPIE<}BJaB|&$kCGtByckI&L{qJKi`Ju;LIN895#o~nP@DM
z>Nbtd10nt!%7O6psqi&+$VLgYAJuupgta#wf>v>6P+ebn<I!uegM5Wl(UO9b>7VG~
z@R~sUH6%C<fV3h=5LlY?OVA}+)OjNd!HXa8W4>qbmTmaYxvqglWldQwNC}gIlo!wF
zeG$6nq>L_3Zb?a=jxB`ul6~Ku;PmTJdi!0{&+>#pGYDy@Os+%7;OUl*V?&+cZ+gn0
zW&){MIIR<R<{Lc@3jcUQyqfFx6NWNc<p9>i3*==?1%%fGyqvuxCQ`Z>P+_<r#nd5+
zH{j}6&Akm-q8nSwx7ntwl-AxpJ#KA~>aroJ18|Cl(xD+2CSW`Dd9xZ++JP-4{q388
zk~0wyiz+OM2fig(=0u-ocn=2R^>SFDPa)ozegA0md-5=F<!~1dJo`T(;-3f$*^m0g
zPD5wraO($h;!D5-yq!&qQkv3{qt%o$ie<6!sHFb-RWax7r@AGIMg**w)@8*`P;G7q
zcAESTl-ziDiWG`c=v#SZHIj-+vL5ZN#32vsdFlP+nD*w5R0$etvG&XsuLfP7geG?5
zF{CR%c?fN2$`%l=LoCQH&~2_Mpf6QZ+XdkacS1P7ii<D9bHevfz1)@9mO~6m%At5#
z>|O61B-<ljWd5x7-vsJ3R22i2fZtR6>#g0=FRfNmQAK_2Z7em#`f$j!Llbx~A;6v&
zuP!_JiRI&8AzKlk`wZj@Xz^op=jJD{uJ{c<W=`l!Xq9`*sR98GlJhl`BUjoTV+Ra`
z{Nm(I1K`eO_knHvNFmWILaUNOTIHdoSdvKn)X76Z!m*gZvDtail@|><DxE8#EOQR>
z9i*9(_!6wJSujMSx$HiLTQsMiHjy%L9!{TK5%fpmYlmB(0dQ+o8uV8FOFEz-HLfgX
z`{{pLsvC8lxUrN2#T344RbYG_^vsTR0Pc;F5h6E94S9`D1TeY)_&LPB=6YY=>otYp
zv)fF9i?k|5(4qwWOb_kgh-7MJGIAbG$(*yKA{MG>W8=0yVp_`4=c#qiC3QELQv@py
z@0C3ka}1Q_d|G>mw*(pu-(aXm1Fea^Evz#nzGMmf!Jypoj*Fm8CiW>4;~3JvhW9;*
zLkDA^6ruC05haS$W_}!c5QR^<PZ0AsA(J#xQ@KzW(BHvp@6PEJ&_*ory{q|64R(Ol
zhJ&Fy=wo7xJIjM1A3VaPw-(84`{2Nfd-}gJCl?ZjxCubxl&%gM9lq+bmF1H2Tf(pY
zC}`u=pm6x+Gf@*{ZDX+<kP;z;mjsx|4&0Z!0Oo&Pz!rI*3o`tnTl>E3r6&>hVLDLx
zdcKB2o{rA~4v5v4i>BD@0IRfaE$!@y&RHZ8&<okfz2#G<f!s6yz^vB&o<96@@bNpA
z?2bXn(J5B~et1TPI7MwnVfYZ0RqNh4rj$aG#omhL+sDBTZt4-Y^)s+)b$4Y!@JQsZ
z!s+DZL)7w09tTY;v1%oQZHz;aBMWvhMK&oWHIzkK4QgQ)ipSAEKD*t8Nb{Y>MwTrZ
z)p^)oN0pcl{;5fy$zdH@!@eoY<cfv}I}EE-VTsJtlC{Sl^m=lC^jUf;+?4$eFB>r%
zm$LXoE6tf`Q6gdFbZ|p_JKNMfuD92f(yEYTlW#i)movd_!_O20>9P@cs6Z6)2;kZc
zTP9hW(YIwn^q*~>VSKmyP?k_6))qS<ci*$B{&^R7|1`zGx}eHpuJ_PJ6B=9}Bhs|T
z584kvx7DIPof#{JiFtvKCTg4&lPvZl+aYI+M8{K)^=FSDo?i{{aBYaRYaBr>^24$#
zdr(PYZohUFtq1*<xhv%`c~MImK?GLe6WYvjjOHa<(ymJqJ$t2AHFL<zFTtE2_GyIH
z)a(|M!~fx(WI1V~C{O!?o8aF&Oj+%_$0|+?h8Bjqe78Ac=37B_;Z(=MY&0yg5($^9
ztOCR`xMHO)a%n4==6}#W$#xHkd|;hvzS@+B3`6OUTbNO*cK)l}`IkQGCOCAgM^Z}k
zSRN`m6RL_>eaX((nb5I!!di)n+2Z7-EgvAu;d0hF^?4`%?0xf6h(-i3*~{`Ww)2Dt
zWVrLgrIC7?>E|h}%6jiLrA0i#SMS!`(ab)d;Aq`H{5gzbifV>)_+KivRO|9#`nO~<
zGKw^(Wav<k$x@*oWPclxu!#$XOQ$OwpJ9uY+7QKl_ylF`t5-)hxBu#J3qtA2BH{Nv
z6XcXN5*7Yee`aw6y-{`Z_vkh|<!`o{ljSGjXHqx6TbjB!g@^cXECXs!{qgaC(C_xg
z|Dsi%a7Vo_QXik-&#|OMJk>X<+<fZce6gU~nhql~;6L3qrfk^p*ZY4jz?sJU4KPAt
z(<lQ=vV>Mz%y8BAu>;L(HT(qvLrU9~KQR5s?<${vqVf+d`jFPgsQCo<&skFIbUD#=
z14n-2eI?g86PDNxnGD8qPV(dnvXl$WSiS)cP#wHa{%X9~V*b?QBDAfaAYvoghN#S8
zjY9|oh$M7Q!c(rff=;(@s`HbkcS|VZL9~8NH1VWl0<youWpHgG(sYea_tOr<|EFaB
zhhEca{LMjbYDjfF)+_f+=Bjt1*OYvRXOLO!o*Pw{qb}~rIIfIEg-j#-2ev>$Y<wSb
z@e^GtY2lVCLu`M!tyE(fx@xqjBHrubQ?nqfW}+%|m{mf}8_S=lll=~K!@bAW879T1
zyS4&Y4redY*PG9Ht}WxAIJb-+sgtRx&m3(TU!~*iuU&g5h0g;hR?8G_O5B5x;CzhL
zEf(0#yY5+M)f4x5<N+QF@)bi2oTBrm5B#N}<_#6l0478KlY6~^z1dUqtGA2zzHcd~
zCI4W|nB@ybPfFf2?437^9&ZeIHO3%WWOmmi@$y#a>Y(1F3Ox4X4U3!f+N^g2A~a;@
z96I_pV2+q`5_n4*Uf+fr(@}-BB>cKHQ9MD3DT${=v{@U+Ys$Ng435rUfiucEo2l73
zkC;Sb_LO}k6xJm)8|JCS@8@vx8Ec{S4M-^3yQknZlVT*6i6(GF>5gkfin06sZ7NNO
zg!a6U`DgB0NWCX&!bOpjiLS_41PX?Q@=^KJrRqmd$2l;j_EpswE0Hchdq9xM&QTj*
zepo3p{fFX--N=fd`ji0Q9TIDk2SNI{`74K+JnU9#=Id3?njZxc%}qE%s^?<7-aP<f
zo#5TBaYp0icYj#^Tx7S6PR7lnGK@6SNM_=nmYb93={R%XP&a7AEQ2P4J%6o^?cru`
zBrc5>Qz%FRC2%Jg`DKN{94WN#XGw4Ke>C0Qh)|ki7kN18_srGri95^)8d-*#?+{bg
zdq2#xO0z^oXw3%jw$jWZJ6sfDIdSFAwCVlbq)+Z1>-!I}Qbd*dtdQ!O!p3)oqm1Gu
z<?0s%TS|xY06ox#?*#V*#mioruV^v^su6Pj*oXFphWosAeAE)=`BU*m=@03p<}{&!
zQk>_q<Y-BXG+Y-n9FoI|m^$7q_9)5sw`k~0|7S$g$X~w4uL9&*AF1TBiKJ**&Q}|S
zQ??E~3--iO^?=f0M8xA}1W!dTL+uGv65b`A`QrI<MeX${-LaS>hs~*nQ%7P2w5;I2
zyX#?EAA-!Dd%mb%jzHzEsMfb4KzO6WO7E}j3zve2NIlKlm^&&-M|(GLTwh1i*J&IH
z`t5F=FxW#Z9+ZOvqFW+8Ft7t#$D@Cw!=O?p;eT%*%)XpOlr+PWwK&VrFG%`7-oE)Q
z5;yEOZf&+U+it7Pn2gP~YqPD*c5T{h+xBGJ*v)oxX20)w&!2Gmajvd;=6P;^ZgIvE
z5(zmgtQ$P#RENwvPe1i6PyRyz2JCW<_fkMCnkJKBRVV6mc&H}+;ZQ1*!}$c%WXfL%
z-zXT5Jf~i#f^lHLgFEWitSul<y>liSP_a4jd?nU&O*Hz(NwX59(hod?_vIJfVlw@%
z<Y0)f0b_;3ZSa~^4*h5iz<vyZ<#%83v&w{xo;TX>>u>496)B9I+f_7tExtbY(t;Vi
zlilfC-sXoouumt{W||gv<y`iiW|7na7k0v>K_{UOb6m)ip{gv?ZBtorO`*~@l7$>M
zy>7*SlDMk~`kX`>H-nZkBif*<uKRLH6llWNZQ&Kzyj(+zCt>m*o@~6-FBtw4aZRQ6
z5}GuP1B^yJU^Dq6fMJx*Q(;4?<3K3;(4F}pli{!>1*PO4Q$D8P!1<cp8_3Sbo@e_U
zrYt}BcgH5TdE)wPLo-?D$xt*y5Qx`~FyQ-e&`iai{FunmGLk0@c9EBeJrzoLbS}Ps
z>6u}IpY5vVM<yit)MTw`{fYU0c3h21>nA_!pMc*2@n+FXv{5Bb_X=^V|G;IGmIr>r
zE=|wdHUCEn>sKH+^>c_moMf5*xC_sL3@(2mdOJEvGX{gp2=T;mGYnd}RRzl3Q*hg=
zk|nL>pI078134lvFc>B<M?Dm5p)tOoGXF{gKxOFv+2ErXL#1)I%($#`ZafYNb+~|6
z42@rMx+79nv`rQ_Zi&~fWgZobFg4wte{^)uwGeAc9BH)eCTx?_VhTU(Gh;!4!JK=_
z`lCm=)gl%BAK0P${_qQLs(J1Kp7dWXPAd4}3GK%}mK{KQXui9Vf-V~+ppTpz=XL%H
z$4lmLh4vYLf@om=0ZUaTEgrTAVFW@?^x_7Fft^FBEtKL5`#J!-?7L6b8QIS1%1u{8
zB|!GP+YRf?_+P5jgYo^QO{keTDjf1SKE162HAxU5@2fxb(+ZS*O@7SJuCz?6*W5TB
z6)7wezKV1I^jr72|0)#MiV@M4fPWtcFJFCxRcf|1m+OMyopL!_qc7iNvP3K;sBb0h
zz8x)=VqgKR3INKct{43DW>3vG*h`)lcHZN3hk&1H<tR93Ci9xfRB40*vH#>t!en?x
z4gOK`Y1Z&tl#3@b@A~g&VbX))b-_oP3lnsfebup~o`p)^9kgSKR<-&CBnY;In7YN$
z1^;ts!XM`^t{upLi0QNC<spaA<2D{&l7auyaEWf%5j|j^up<`IZJLkRrdVWdhMy`m
zG%~*zAN2<`;j!;riRh;#6?`#zHKvB*MfpCrZ>GWelffaz2`<p825slLgB-TR>>L0p
z7Xj7{t>4*^WZQ(;@(~z)hbK>%j!J8OEWke79JxagYdex1i0#|9!=9ZO)|$k%0)!UP
z@bBL-RB!8tjGRVbUtvM;QEZPlr`fqp6~FUU(dDBhGzD1YpSq|0pBtZ3^G~!yJpPq>
z!nLk!$pycqZlm}M<l9B&H<|#&MI}>jtg!e{nGA>X1i|CWhA_5DNxtS8X9Htnd}pbS
z%~Y4!;YMTWG1f}|OsMN}_W1L_%KS{`!Lzy#kh$~lVaFxjcrbe}7IE}%nsD?YLb*fA
z-kLAX2z0b>Db~@#%)3&1vDvHlCxSW4^<~}9FTjt6*+}O4mkI_Kd4=|t)!leK_)-F_
zg_E#1>GA9-W;>w$qH9%7)8IKgx5j=sY{*txR)8y{${sHRSQ+)hfCb9!Q<gJV6>734
z)B<^F;fc}JH|+J-KLnzr;oHi{VtRw~OkW5J_!Yi6nMzH{2H(xULVPhLl2v_&Vt*a0
zWIJp)0CLS1{1TaJvPcHGys+RjG5G#yeoy%u$2d%5iF&Y^37%(woYf<X?Nv?}No8$4
zl7Rorfs$<t`oj1wO!G-J{y*3!*k%~kBFdDrJs~r+CtFzZpGRqdaqh}>-Kv*kzVt}k
zRF<O*`IA{C<r_IIh85%5vQvyiYNbS5u=%>|Jc7}|l%~_|fd#S4gpC3DzK1y1ZL8<l
zn%^ams3kg2iOLOeS#SmV04?eelw0_Tsg9x&>9byOxn=*(O&SW^DuXt)L4gv%9Ol`7
zl>k6MW}vsS;X<#auAH@06wx7l=G!4dSN49OZ3D4zpYQuR<}uX|%It2=YNtr$`z$x`
zl4GlNlYtWQ7j+>PF!Fp)CXO<NQ6@*%jrVA?1M9%JrLu~lS#dv&ly`mL2YY}T&o`+3
zz1>330cNOu@o1*eiFbxC)yE$Dk($e04;<SMC$28SZ$I+QM#eO6vp9zZ5aHi$P|L0E
zck#@%N3$&Pq7|~tsDG?83;Ll~<s(;!p@ET_JeJSs14S(IjWY@@AV)sjv*Q0jn4H->
zMZDKQQEQKEpxp*Pcg^{#{;{tZ+58=`)WZiw<4r5ig7N(GTXG+)Z|~{tbdh`MV=fD=
zP}s8*^*PxG=;p*PKdB~@>+>CU;Zv&mhoJ$-H)PWg&{gC7{ujAyM`5dQL;G4Go|^1&
zvX7VgHJJ;&*wHzU5TjR9!E6ZH5BJM6s(e^aV(f?Q0bsWia+RD%X|K5l!WJqkRV?sJ
z!NHl6c<dN&{JjA~9vlkOf=n=W7k$F_bN>*}H2s?z5<?*K*eMpoB+s7!GaGRAyAwDS
z*gO4>dGO$i(Dcq8n_N~aQQ=|A!fm7ds?nPY>m1^IuPqVf43O)>0`T7U`38u+Vg4))
z&yYsi2Lrds*xfY)c!C`-)=VUkO^|ME4(s_@u7+k>vYw2*n2#qXX#{&8gB`v_T`Wps
zV#w)e(_AK6qG+Kbcn!-V;Lwf1c&SRpz%~^FZlE=2LSVqSHRKjN<LzI4muMDNUhspk
z#rh?$;{%k1opTM~kUmF&V)k>(op>v)G6P=c&kq7Sfg?;=FM65#-SI*PHMRwPoJTg3
z6OONoD&yh3d+7OZw1=|bI>lz`X?;|PiLNN)vwBZ>3xSn^>ii*66U-ycH0|1RRF-9j
z@6y{18r(!k_4-dpZDvBpdw>s1jXoy|k@fAI&O~Yyug*IYOVl;!?nmkkTbq8szx=$e
zIWu9vuH-fBLF2oXJEKJKgLodeLr7f+d0;rZ#25unyTK=9U!frntox`efV>cRP=kam
z7G@ZP_vFg#v@4wzb)`<%_^j?UWq}L<ygA1=k;W(Wt6__;XSv@S_7Z>faMcE1K8xG>
zGqMzHRW==UEBV(=#HTAw)|<NE$$mjEcURY1|M)>bVBH&o);Myk3TOTm_x#2{2VAnS
zm{6S&@FZ>&H{~;R0g9*6QWHC!1g(;I?T^ELT!xl%AUk1mqk=Y46C;&f!!zv{BDnt0
zK)AD;ob)hSm#AVSbVes9{>C5)N!XdBMD)V*+)QSbO=?fTc|7@kUvX9R(s;=R4hWMi
zlR4PJy_36&r7ozNmY2U$rZ6R}eaQT9Vb`p`|7_TdoJ%%3G0HjDZ>D~)l5D;A7tj$z
zIL})Ks5h6I`7OX^$%Vn&r2xHj$)kO>iI&{!6R0B8rHQ~GGvqw%D<<-QxJZt3F;L_v
zwW{{L%o3sbUFLCr){*{EQf2$q&(QPaE@v~o6IwDL`Nr*(IFmKZ=Xds4s?i$tGXjQa
zw~dUmLB8WH98{*;NlxpV#;Y<1D*59(!%uMKpW%=Go8;%VoVxA*dPZ<Z<VbB0|3<%1
z5uf|B`X8TtI7by&n(a5b{RWo7s^Ivb5q&0jI#=4(oCOyvqOgT0jq^&J=*#LWKXY(|
zGS`>>R!*fnnbBDB_+39*c6InxsSK?V;K`E^-FccO-?meh?W63@QdaU+bcKRPsTA%7
zLg7|-XX0dfn`6MO@CX~laBgv7!Gn=2O7Ek`@SG(vrOBG?Dks&(BxxYA3I+Bn*qARH
zngS=sQoum|;o9;e1PV(QtLZw6vLSxiUf96&7Ziw9dY9NB4&*-?RsZU*hs#ijKh<~m
z2T5^EGBu9EM6J;sMz*8@knm;xB=XHm<d1AJwK|1ihj7%aJIXqbX*KweIP?pY1jMF|
z3V<77AmW~>S)>#~8!^$;8Zy!7YDts|Z~WmXz{3M-Oxw^J-dRSzQXz#VA?oWU+t_bt
zjfg~I;Bse!OEGHC{lgntGVOJSto!=XO)y%Xv{omz#}>f}U2!A{<?C;c#CUdQ59m=<
zWhKen&-ys}a4C^w%jv>@g#POPc|})0`ofj;z5Es9`A0ut)wuyc&-OHQd)UMNEt`(x
zt%|XV%A(Ao8SX`L0_*z+kw)6DRrcXjzOps}^qL#}oe!ABvhJv*#)5yH>dVY)h>6Ue
z7p3Vz=}}CUYE3-w(BHna{ZxUi(u&P%e1!O(Ja=&S>JM?2>dNSn0+co_jA-Pjvuvk7
zjMB)!m=4}7%EJ&p7)iX9;}Gjl)qeWB5N{UV$P7Ksl&fU~q)3_G#ODC54}ItUTGnP0
zgoGluuR+DZvVNsGax}qJK@7~5h#}?9gvR6T(fG+g&s<GN)T1@d03zAB5SXqHJq(fc
z+bmyt=&_spfN%QvEUG%VF%Tm!M4Q?ksXW`t-qesQ+HXGg{^j_`s}Fi(B>|zKH|dUu
zxSuHB%`IQ(x`vt(eR>1&S)hYeX`@kjVfwbyKpv>6I9K`kr!^=gv3JdcZpgwqs31!u
z5Ynz&cq4T#a%EA~oANtJ2i!)+TTZM=85s#A%PSQltq`9Ui#p9p_+ruMY+&#W?a)g4
zx^#vzN1U5b&SN71lH?yKli#Fo?4y>&De(zvO5=fl5aVDt3U31xi;y%FVO2P~HOtiz
zQFgZDp9KS;m`d4tc5&U$f5~wH%E-0nk^-uX-G}QNDua&7z(s21=+pU{5y3y51`2#j
z3$HU5HsClVCX%kNJB5_3Wv8GXmOsC<&M*9Wb&7pv;f<o-PMOnm`U>vW3TXZ??R{l?
zvz;$8H@faDNm*Ed;1Tdu1avRN-n8+?bP-5RB42$6CvJjew{@X`!2ZwBFG3k%$nNaM
z>siv6RP-oDqEj#0E54JS75nX|j-q0JZ2iD9SBL5R`4Eg$KO)jOfTQ3JuMh8~JC*UQ
z#>`d~gE7o8Gud$bW+xy0w98lIE2*<LqGe_ma0N38Ws@P7ECF?aT3j%KPz4m~TzZMr
z`K|O)9j9}@5D4mX$Q)}W?~!G_C|S#Xf&Z0RmxOh0T4bI%U|&mp9YpJ1Qh65{gltyn
zwkVKA?0aecx8am>@w*cJFK`!?7w0?V3Z+l6FiQbvE8T>)Iu**5XJuB11>TYvFqqJP
z<et!ddDszKH97KVp$B;+T?m?Mm+wBX65<#`c8xA2Al=2Sq??clPR1zFOEVb_!+1=~
zQY&C4>c|XEGb!VzT1*&3m%ucvV8uq#g@C7Yst;@KhM?ZbaqhezUbE>L$9w+)BR%!#
zDSZ;!;kH8uRaLUn4~<R-IUU~!HZl#`G6$H2ZeTL5U%5UYa<9*<rfQ1d%iHIJ(F47O
zSm`_=4&z>On{VoDD8s(gO0pz81Eil0RITS_d3IyB9s7w!95!rylPaoc52NuEJPlb(
zww57|ScIE9oDcAiDq)r#H;qWJCGCqC*$M-*$W<;bs3U~}Ier{ouMD-}CJZaslOi_q
z6z$?;4xgZxzq^A{(=KCotyts267kJNMdvm<4j7vZ^?r)Xj#~>q+q3!CRT_C>*h72R
zk8dVes!f9T7XyBV);n~)d=1qpyL=^3F(90vVmS-7bRa1jZ@Zi1O7FhH`a91ONSNs^
z=x0y_YZ`=2gl&z^fx7$i>#5GC&ug_CaMmY*qu0IH3rhpn$g+WPy_Jz5il5(SBbYfP
zQun^^>|yj6`@m@Wx@M4%{urRkfKy99^J=2rXknY7n2Wi#rj*wYGFw>ECDs!u%177s
zi9PoJL#whD#-ydIO`=#Rc`zT4T%LDw<J+?vL_-|XOr_`<N{-nTPQaU(oV8Y!iIdy;
z8%3RPsrdVo&-3&jK(WuG?R4XCc5u28+o5@d*}?anweR(jBJIzwGdP~(1@J#5AwI?q
zx^Q)7E0p82g!ZB#qgBeQq<EA&e8vu7YasZb1=I9up>eW0x&Ek=CZSO~jz!6XH`<%*
zBz1Ng9fa`^$q9qnXy5P2M;X;gitv1Y^DE()rd>X@d>Z&9wg1WUToH#C7mRBB(&6>y
zvpr@~idxu2ova8T)<W$w^_6~L$gb`_uUvmgFs;8mJlesLF{F}xO0&YsfW7eF8`*ch
zMcA6h>q+3XGOpNk<#>56hG#+4`J^)1R+8x4Z~Tnw%*zq#M_}+<IRS4jF9wpxY}{Jx
zH&*aqT<OAQ1TcH2Ww+5(*Z<^8tsuh@GE9zawT|49z90-xyUGBAzZY0)-nP&T%xn9)
ze~6*v_h4h?uZ*Zp!Q}vOp|af}KCkdUShx5v70DYPc1HSs@=3N){zx{7&x#u(gjoX}
z!O(BcOZ(B_^Ga}0z?=BFe{ptax=FxSk-A~EkkRi8#T&+Vfj8n>cm}vw35IW9=yYJ7
ziA+*hBg8g9Z<GvDEzzho@yhUFI&sf1yVIT)k#(GX^Gx$Ws6KsXYzLC#80?N`vP|)G
zv*));<NYSrZ^-Df>>NX~4<nI4pkl{HA~Wc6cU<i{MTI{7ggCR!tf%2EEdkLW#jq-y
znN7XTpF(bR(iRkaAtKK$$?FW9eV(SDf==%6RV)hifiV?#m0ke-k)AIn3rWNcxy{uk
zdg>W{C%KfBn>QwiEVMGiXa^-Z0EFpwcpAoHO7Ys)#7_oX0U)7kyxvq@RFMqZ#->L#
zyH|T}B*QXLE)|DLR!AlxE%{M!wB82=C32BWI1*9G<Y87v!Kd>&DVwmKCApHBapP%G
z+rVB?TNQKB=Q>2!(ZagqIy#P@5ScMvBeDajK)Gui11v2ky4@R=W5<2;P0sa-WKQF=
z<ftX%)qzMxDl#%S@<ZSqnL&^zqt|eBpww2G9VbT7pa>8BY5H*k{SySP^VrUgJTKtr
z$s$ghr_lR>>hB*yg$qAl;Zmp^{}*uY-hCb5yc~5}gegGhBS*Zz{T-{7iB-OmO?cEa
zVePNx;dZP~g$cwu__1+~kal!FY{%{e&<u*3+=cNn5-^8VhcrICE1TaUX%mzC8wn!(
zxZkLvfhgG(`}j>7;)p5K8glw(a+;;kaQkeCt_KL1^(G|GfP*Bu-Sb;)!#@cYpC_`7
zYDKn?8V)4{wkP_7fO1NCBs)HKJpKBdq(${;?rlRiH4^!WWa6)eO;s14qP;ENfcob>
zs~L#Lc6PE|Qk+6<xV3qgp3@eGo-^A~r4*SQBOKo9`0&quY)DK`-b2Ea;;IcZhoCrc
zm4d&u@iDOd5GwtK8w0Y@0lk(}b#3O{`sXJebseI*cSZhBQu#KJt9o_gy`dW$HwNGc
z;{bJ9((WXQ&1^WC<kX2{0`=Hg#+@muTK8KT3XgyU^mRVDt5(sqK>By{LYR;S@p4Yc
zh>pD?bbM6E)U|p>BY>mq(0-ATw8LYHKW<us(^qtrWF%A1<J^de9&oPlSNOSqnIyIK
zK@GgT`nrGG0F!i7sEuf-ll{PL7d=`di4vczU^=P~v5eg=$!1U;XoETNLYnuqj~G6T
zl7Q32+`6#rV+-6!kQ08__|>u+Mv**Vp|>cU@0)rFhYJah2uR598C3z}Gs*MPFa$o7
z(<?}Q+*;!iggN?X14`OT7Di_?!!3A|R5`Yiuq#Pmh!QSIIB}Qsk7ykTq-IDIKx|^l
z(1$Y_N7XAe8As0M2?9#}#TqqjP<s59g%^jLU^_m<wI~}s+O**@7&R8cfE`uK|KwBn
zk7)J%)~Fq)8G;A0@gq8Xk1K6hChaz3s|gWQ;hob|uQ*#CuVA~hbM3%R=b#8%SY(ry
zb+7ksXz0qKX3P)jaa`@KNn}t{YHZs7`e_1tPa1~R?J+YTy018-ueIwZn;KpG*cu+`
z+O$NH-XL3mJWBye20lrq3|wp=<~Z_OA6O~KhdUEU(2PfkJWv<5yn7H=XK5@T2iV@-
z`NSlAK7=!We4kBkrv?*N8PQbc&4V9iu+uiMzGHl16s%X`?r%U}xnlMc8Ol^SW1p#2
z+Z_%KV#JGt+15bHfI{0btqZ<@*0g$|GK&}Og<95v+>Or(wu#;u-~5r!x#)orl;588
zHk%~K#cG$;lKn!^^{i7B{rHI8tzvaVB*;yEF8=Zlyb|4I6P7ZLgZwcXolZB)&`;CQ
zw5%ZfYJcdO3YNAw$Tc%<B52ca8QKoR>sr;1eTJQ+1v%pdx0;_CQW2tlg}>JQIib@(
ztyIyTKjB!*Iw6wC(as0GjmETZ7CvYAuxr~a*iPJ|naZ0NdrYt()@ps|pxruGf9VG1
zILQFW1t$~`j&2!2#9zkfHx<qvdXP%XI^d$i!kmwO2hu+N&cS9tZ7wx3+K7I4y;%dn
z<I#04RA#59@`@9jd(V{Z?KE4O3|VM`Q49)WREhfMAeL^g(O-5cV!peS7}ZaBbf6RS
zjA(*J3<^mT4~ABFZM=9IMJztgQn`qiMZw1rFHp~l3B-hxzz77+p%*wJ&%goedv(@b
z=R18zEl${ET8}V}?sLgw<Mg@fu9Mf+#`n-k(Q`gLMa@!yhLL2FZ?Z7Ybu1jDCjINj
z45W3ssLzXgW~NeLeW|#rBwl72?USl0VX<lu1@;>ewdv|UuSkt*XKIUrn*eZ0or5tC
zyP@H`KbQ@ij_N);o3E4Dv2;wADS{~O6!qB-D8%)rp6f`TKj7~dTH(Z}@q%r8-t`PO
zfh2K-{%&)88ElR9(Rk8UwmlR-bkAo&(>^eJpI9uIC5JDriAO*1QX$xeA;><bFeyE^
z6olWi1t4b#-c&t;oJVksrJ3=)Lajj*<3Oym*7wWdo6F2AhB+=F@TjE8UH|V9ku3@E
zJ4+-nux)rflFMfL5;%uAf?zEp`ke4rbM$A#mwQto60Lyq(9LqNr2sI3o(<~RfJVW%
zEOoE@GDCX{zUFmrd_D>KBfmJQsL=_Uj2r#+V$j&ewfY`FSIiu4`aJH=tbAcIUp7E(
zap3w0sUBM(q0KvqNxS)&R$-}mh=XgH7IW8MFDl$bHqGkY{ev5s_&V=SxXD*&&<#I{
zCJZLZ@Htg9?<e>Kx>@fbNk2BQa@h_{jRD{r-^P6VdiX+IOA6-2nKUNm;jG@8*B+vG
z$z<B6FA)%Suh*3E6c8YJ5IwWDD%602p#@|9+l&_ZXsl}nEIU=FZ#NXi*j+;IshMdo
zGin_jqT?5TIeN9fjuFYqMr}UkEpOa4_R<_wZ0H0#gSM{R%9-78;pU`}P-~zjExU*2
zib9epRC0@JYtSZ|(&WuSYxXOKryxiw#F#cbqEd`<5JECUgMoDyuJdEJGrvr`+Q+2Z
ztmXr8VbRx6Oj(-UZRWKw4LJxr)3AHLu)GG8ggqPlzqJ5yJyY3wkwHXtUog3biDl(}
zgd2;Y_X)Qr;CV+;E!hL9dsc#&erbLuL&wAvW(^`m*BY`rqpouYzz#B-SzJ87*D?Oc
zShdPs&B*o?B8gLSJKA!d?s6{K;K<$cA8VB>DKY$g2@1&ut>UuKX6z}C()ra+m%E9`
z%#N2bc;P3X5%BZ|Ubx(o@3}Ysde+KnKRkb?VR-)ADFx#&fqF6cgcARXB%`OqiEy1i
z=JAnw15h!1Q}(gMx_g;4D$3v9aDJMhl{rO?W`3H1M{nWnS(c(gH3UjcE|9l<;W$xQ
z18Qp>Jd>=i^*JYRnE6%*b!(}IMt$-PpT{$ANrkO#t!U3WoMER%JeKvUadF=|?P9+q
zJ2923ZzMU!pUy>oTFk1togyPS7U<-tHCh{S60Fk6F#xUCYi$)awTt&e=R!W~46dpP
zI_nPf4!!-=ku-EesHH7&y=ixtQtCeTXTA>Bg~mz~osx!q)wIDb#DX?V+j|vi9Cy^(
zK$AYc`^dF;tE|BF{4nv~S+HfEWTB%|eIQ5geYzBy=6iRC6#6pS<L^$_ekA-W>6<Cg
z#T}<LCTn{^Y=nu_Ps#qT7BTY^oeU=FL8ezbYX0vaAI(k?tjmFzur5qmx-$GDVVa(Y
zBkzw)Z49-bpzZ~ClOx-XEbI>1E!cgGY`zMii*1xEBFj(6e7+fv+L)5XtQTW8*(f7T
zi$r6}?z~aXETv|?9~7=!vJ>-I&pOP%#vWbo^-C-1w?OAE*mTXGE+)M<72>QCaQAsx
zG|O!Q2-V@$SEQXaW=U+$p<qF!Kh#(e2%FEj9Clh)FB#d*U*Vj??RERgbaJ#k$P;Te
zBE=ydQRJK^P?`G*hywn=+Ez_;6vOhAarhb0@5u}7|JA}B<ya=)!%db!VZeUBEBuUh
zLT8UzSfP!7c%+ngHtagE1)mVIP)HaV#hU{fZl@aij*ztcYEa8PQJq#lwlh|F32M7Y
zt%E%Vu64p>RL7SKB`*cT;C{T*fU3<WTC6zgS(5F#+**!6$*occ1Cbve`vKQbAp7Mz
zld*;Nl~*&r+II_x)ttyRIt)n8vp0gW?1#Sng5KNh$Ico^(LqL5zpcv(SRc^zD+TSq
zI910dc<dG`pI4gz2sR@vzbYXOD9S9i?I?cIkX#Vk#j)esQi;*hWOu8JeH(6s_M7Vg
zsP*s_&gfb&T}a*K)2123StX5Yf+M2A?@={`Csu?Exmxb~cs33gL;~>lrrvJ1MdaK=
z<MB0my}rx-@ni<%-!ZuHgZ3x;DXFLumfc(J?tD+{0}%t<8obTg@W!Z9XkBgcr*wu7
z)LE^AN^41uAQH#$e|qF+Qk*G>?OOvzWR5jZf57^5?Mom^2|V<KN|nhR&g!+^133QV
zL_Ug9E!uKw0-rlJq-t_9A(3~6Tw6}>uvo5w_`ys5_>GUV!KA^u@A@`y{rN$!OYd!G
z86q$WP}R@OLKuRO^Y9&xR?18Wgp2V?1|CHh5@Iiokm8?EI`l*`W&VchMuvS3DF+jI
z`nq|pgO82h@%|S-O3CvFMUC2xX6tXgNsOL=&52*CvuqrLEC7ar*kh1xc&OvROs)-r
z!RMW9LxW-Cb#hI0<pBPiQNv4r?0#G0P`J5`x$Q-TKat`Vn_cuzy;*6~Z|@}uQIAih
zJNy!;J|vGN(C_2ABZ-5*gPi}!&4t0fewbVf_0wolku%g%S^l~dYSN^%zMeSm-qGL#
zg)WSL*&z&mmDTe`Mk6=hLc~dzLAj3lsQmlaCIF31XNY;|{<3~%vo&Rwld*}ZXX9vU
z4<l6+Tc6U}@pKdpOkRpQOO7niz_WcVOMxDnwNJQ)*IE)^Z->g#BD9a?PtDdHy~$fK
ziW;$Wqr-8~j0fDKiq?j=^Dxrv$vZ~qbLIp{@9f$BBSu(DS_!HX1oy_gMwPWb>Y3V*
zwFPoN&eF08Rm8d?hJzMBFz7k-R@C*-XuvVIGUsKu%J1vq)SIf*tEi|vwjPEf*>#83
zXO@m#Bt0}heR!u~{ym}AWVQ0wd1~7eNvE@ps*WUJeUc~llV`!?=^Lsqa=heQkTTuj
zBS>K{?d-J&E`0S{XG=#&<hqj$cE`$&Rc-}2O5>~E;B`(`_avIa`p4#8Vv_L!Y!s*8
z!D%mSFYKFTf9hbFNcwpU8wC73e_PRaQ%DOVTi*-j%fEP}erw+W!}duwB8XURGQ`ig
zjTO9=2hYPmGQZlAu6wwIL(E%DLxQ8Er&6nLn3Bws?V(bF8~RgE#?zp;%aP9wO9zU<
zf=G#(2Q<_J(|nLZJ@kua(6|m>`|skOjWb%z=g+yMDLfGH+X7>F>Kn({5Nt|&xqxGg
z5_7}ZHY*YxzqNxWv);4bBh=Oa6S1tvoneo+$;t^=ugDf3p@o3OZ1%Ng7^Wjzih7Nx
zsS@pI!VD;LD2}$bye%K~9^4~ulQZNWaNWi~>Wyn4*{k(?zbFjpLLbCSDUmp8b%SsT
zx#d~yv1wOE94kbXMs0S?^7?cRwIgkIDiyatz0~NdFbeB`dxmI8$$m0mG(9XQfS^C%
zbYXiR?Kk6p`a(Z_L$}#o!u2@}+ApzD!`kE8C;FI`35=<p3q?Td@eSWw|A}4aIQmkY
zGmxKMll(fcYR2;+5?9vpY>;VqL=xx=bzQNe*znO%Gc$vR+rX8eP^8R~Wa%r~BDBhM
zu7|%m#}oh;d_ettde=sOBH!{Fz8BHj#DsC!<!$SyMJ#$kK3j%*Kb%HbYpeomz{%eq
z;*GPdz2EeV+F%6=;juB*9iD$n_{cZXo62brz{RvPv{Xc%J{_mIrOP2#kb_TFyXU>n
z+v@$q+XZ6j=x{E>4LVS>RakdLXEj+xuJ&r9Az|5oYGGpC#%ti})#%gy)P(x{p*x6s
zkktcyaBbH1+ogUG)gvNx+8hxTtG#r7ak&>jxPg*K_{%~X1mgoa>|fhn!ed+UPp!xl
zaRTxmK0boM!#M)|UB@28#Z5zC4Z5X4g0f>P?^KgD{MqmQICaqU7;3RuenuBAffpua
zip5*i#gmmrRm9W&xTu9jqNoH=%{ymx9zq-1?`TVZpN{WUJ+Ad8A*f^J93Qg0dnFH=
z^oP|YW)0yrDf>gQSLIr%mbG-B&QbdhR72G7YcO?wF?2&|YkffxFhEGxyZ`3dK-J4J
zVMk8BDVo+SgpQuTp3VcF%sazHDkgM;;yY#gcqJ_}I~R)_zYLXfi5e^j;ZJJv@qD>O
z@3Un;9e^LC6RI_-O_e$U1Fy76)aO+1A@LBxZs{yX6h06m>oOc{v)^s=;>dWzFSKcg
zoT|YklVCO%h%_SfzG**OJD)~1t|~4*E(ah-Pte}sPXf7W3`d35;w~zG+w7!HPW7zN
znyNoDWOfZ39hh`ln$d(KOnyZ;N0giZ`J_fYz%MIP{NZqT6h7{42}XX>%O#MJt*C9B
zR+*x?GTsCHI?GdOmi?Ia58Wquo$s5&Ku?G)AWsOFVsg-#UFa$e3WV-P8Igar4yY_7
z1;p~ro+C;`tOuyRj5w{dJw)+{4IIGw{DBT=LO=x<-XY8{Rt}v6UP3Fj&`Dr3i)@%|
zlX|vUSh@m2ow@cu`@n%!kaT=j`LdmG_@lo=4pMSbc(^Jlc7(XNwdlrm+P1NF#sc84
zlR7h5`w?T@JTez9Kk;9mJi^%N$gr<R(Zf~22S;BSrB0a;bt$cv$|tl=neAb*Vu4YY
zPHsz^6~@hq3KQlwW(U>P=Gj&rK2(OUUmvlZbEs7*G0@A*=`kY07eY%K^pOvo`_LK;
z(i;m&vzzNnA*TlWJEjVK8HLk0xUa-+)_!=|JB)2n;T<eBM9U^?)SU<ubhci`M-am$
zII_Mot`X12J-yxbkLZ@eUhnDko(6Y;Fe{`e$(4uxI|z1}@J{f`{FcPCseaUD)&X9U
z^MPKZII*U3zg5*}mo}0b%F(FfmmL*Dx0H*-eoFu{2Qg^FxvT0#ch1xHV?Y>11-Zn^
zY(Yr~XS>Bj>A4k^;pOdzzAuIbs=l%+^CGj|=1s%NBWT%b#n+B*4hubD{P#baou8Pl
zy%6f)H?h9Vxl7yW0SZq|J8LWIjc36$2`;*HQlF_F?zoy5c8!!RPr7!k*NbjxtD)4J
z)HdhsEcxv^?<U>Q2YWm>vx3<2u5sp%eq1v2*E&@`xj01Ui)R;T`g7txdNKY-uMlq<
zK>i_OQJa|uPb?~8R^HEKTf#IumYihg$BeU%FM+uFcMz<6oUfwziQ10KaGiBK3HdiC
zKDPk33G2=N@ct1h?c^1bll5;uZmWt8m8XtRboFye@&OhE#2*N3d^k(v%##BS{;db%
z;)NJx|6Z4Y|616nE1tdD1zu7}pM)JSM$PQAXnh)pvrb7m<vCLSP)}#9o8Mq=A98#D
z7H1n)XlJmrSHihrvEz~M-0OZ64Y$l}sdieqh)onFk%1`b&+zBE{FD5LUT;8_*RQ4&
z^AOra&2m+Mcp*D@trGaa7oiuDonSBzxzx4#6mgYhf@8Qc>Db8gUn=s|E5~}I@)eo<
zv5KdF?03ubc4d(^%5`i31m8$<ng1&Z!9rd9ZF>qu;e&H;aJBZ9mCz{T-d!$w^GL2-
z6T?2@C2_~@D4kLR#5LF%3E;Qo`R{E3Vq(#^HH~qH?})ecDfv$ahR@P=PWEO>&_2pE
zaYb#e?I$um?Kk?cMMg*yD*`l+CC8XvEVRB1$PH$CQ`%HZUckIg1*(ajiPgD52*aw*
zWt+OaH~&Dy#|1{6?B|}>uh84PB{W<m&RpwAp5)}p$p7&z)o^r>ww9^>(Rvo=z0OcE
z6+mWrJRgVhFZI!~FFklnq;Oip{N*a%lR0=&dJlY0QfPwg?Uvuxw~iV66kWTKI|vCm
zse`6x)$-eFbKZuYkO-AYjFOqTMI_qR6g@-}uk=nZEffEvrEDstIaFEaFCJ4J&aX|>
z<yc_%@o<~7(EItl*F8Wo4U~P$Y@vIF<{;Z4Lp{v8rW;-ol`F<T(J<%6Wplmu7S@O3
z*8TleUBYxNg$uk(f<JQ5&QNT<F-XU+`iSn(f7-u@!0F+=V*icvJ=n9Q9@+x(^0A%U
zAr*Yv!2h`|H&JbTx;LL-{6#+5NR&>?r6cf;NjA9-t6=hW;Um8@T%?vEBB^acYYM!u
z1#W5oZkXt1<D+)tuR}I<J>Fl7qoz$!F4Q}IhMttQ!;KeynM1aT)r`jrs2}lum{tgq
z8HiGG>|VVS&*x$>(kpDjxw_j+4c(d>)NJM@#mXg2<m87X|HQT`;*I2)i+QZwf#`Ej
z?Mh=|l$vx5ysW(D>;@HThJuak;nv~V-EdQYUc)djHT=2f>HQ-2u*1CXmjy54LN5^R
zxU*EtNN;itHww78SjmALR|Au^@`v4%i`}JmK`2sDPF%bl`ai~sS*QH%d6vZQMP#bw
zKuZH$p>Zgl)8A+h0kkERp`~4dzCQJ2f<~WB_4D58>kiqNm3(Nwr*WA-sJ0hZtRlEG
z)wCbv+IaIhTx7XA>$+KP&Fa_)KB`dqiYhsl>&@>q^e(eJam`#`bC<6BDzw6YCFy_2
zZBs4qL~(W3kR{^R!`$*G7R^9TELc#ZT@F0oz*^RMmtzwe>-+r^wZ+%sON_;wp+6Q}
z6D%oMj+{&*8~u0!SH8g9sdQDput`gq^IX?54uY29XRixsa~ISCxNZ_s1=nw<fib<)
znvRl?HG#1e8^XbAvg=~#=wqS=M*wl_1UBkZcF!hehhBH%kEs&e?979j0UqW<h0-X`
z`g2B$j1fYaM?-H3_KYsB*$mXXA=}HlYra*95y0g>I2Nn7W8rL3Z^$wu2%~=ABuY0U
zNgMU?$m}=IV@lI)_~lB!>))$Ywhs;4QZK7Kof~{eLr#vZ_@BjYe86-M>d{hd$!grh
zc!P@VF**KjC6l*?8&lqC?Q$4s524uDRx|I+H8FO^>%wcJ?SnSMa0|t&pRAMS&Sits
z#EemtWU^cOJoV1|a{Zz(;EESlsusTyB@tCu)Z(7wj?8x%cnKK>#oK9ctO?0UJzx8}
zp<Kv7PM#wD-w#-rK{N3ih~z_f)9Tr$zejryDJUs^rqUTNU(><Qu*f+?a^e}%5wJX)
z1mF9dQ{Qyp#(T9;ZzUoL1T;I}(a!|2*0T1b%waD;Sg5JLzpdkI@O4}>^t!bTJxs;^
zQDt6zOv;+CqB`E_;l0RiL7VidF4pROdjyzMgI%WRNO5xVrt!q(U7xM%z@QGQ#*J<f
z@^+jJ(IR>>HLKJ7QJVPE&zW5z0L5S3gvpNYNyU$Y?*SVo=5jmRlhF2QeS-;fSz003
z$n#CCksR*4&Lk)Y*M2kYAxfv}62BH1t2oT7k>oz9k6Ar$=-_Wog4XvV9^xXyrCe1K
zq{Iu=->sg)dhcQ1+p|(grX1&4XgRt5h?6NwGPSyZmIF%=w7EBjoED_h8eWKB6VHSA
zOM(*8N-DGvb(Rh*dqaOR@bvBgQClvp)untu>42zumxKxt<QUhxlXnYX3;o|1vdvq2
zT}?S_a`HKW{}kIq{)w_7I+`6)6!t{!z_kkKH~zHf#LT!T1U1eAMs-u_qA`m3;7{?;
z5U1S5N>?BX-OwSi!7=mNrBq(n^h&DArB=_t`|;G@xZCVKL?yYszkRX@`W*z>oLw}s
z1)q7g^&EAfvq28HJ?r~hXjb5xKIXGrfFJqnSMb)znIb+3OLI!X`WSHik9utGOi3>i
zRfXGr>w-()D77iG-BA_Em+CgzFz-x6NwKxzDGt9|`f2CY4;HLMO;)fhp?<g=*BCi%
z0t%S_t{ncb+WUUhJk%V7l4;Imv)>uERHB$W{I#m_8+hO|6*YFQj;bH{=C=Rc{4}-D
z57B4l5BpFfyOYEogFs*1d=EaonRLlw9gBJ7^~G7FNDZW7i4ZoTrO~eA2(!g$O*foE
z4=3U={x;2Vs`!|^{f7Yx6KunIzV|Q32p`Q7hGUnNAIvq=ne)$f3-QiJgfdw^7*7go
zBlChOo{cbEAN@nn2&e6IU{1^VkJIeVW~NC$<hM@Ey0$DEdXF^UXh-Bb(kTe|GQR5e
zTN!YcC-f(<)eZQ9!y)ex@&qOZFDw-v*jjPV5en;Bc4j4QPu!S?A|uhb!?;}6$8tPq
z=cx1Sjq?_EM^pM`y>e|ZVWxSV?O=-`Y>u1krb1Le@h=A%WOLZ)2^aqa4m}VxExOO6
zu@pgc3F_x^a4z6-I(Ij{ECa4B1*7}{0X<$ug;Iv5q?)%GyJV}$s$vBBZ05}vEHa*9
z6Q2Y#RC0<QhJz#nLfV+JT;X1C4hcG{G&?U0e@h+>IY(bQ+JcpW<=K$dV|L7P56s6q
zDcgLv0iU789IJy!ylr^6R7)Y)ri61UhS`2auyDL3f_0g+s=8g|rrA@7&0HJ(?CwT*
z3t(rsv9kI?i;|#p*k;|6)|Wf!`TV0Qn$hv<#!RuxThg$g-?-WM+O&4ObV;5tqdy~M
z+jDUYWw>gXD$-Ze=-4`Qg@x5CcbvA=wJCI1FpJ|DmoZkqzZKph<w$I<+|@9=-(EI+
z#lm6tVn1?92W)@1{@I_xRW3N8xaXP%_iQ@h7qv(7Sd!h=G7jF0SjZ6AYOZqxKCT(o
zQqmj~n|$DD%U|F5;t8!?m9~~xd@VB<E}LDT<)iy<2vJE}$__ZL{e(ixObyY3)2Qz5
zHkIX<<!b;PRlx1g1GU1sUr&UP3CoUywwi#g(g}8u>y^OTKwMq(xC}gja`dZ-Y&iL^
zhC=&*T9TD6LhgH|*vxN{U`?VsNW2iBJK|Vo6fyWSfQj*8r`4*0<<(nr7H<7HUeFa4
zD^1fd;)HqbT#Bs2x*NM>yMb*s?KQY&!>Gu|q<F9AxOVZc!;<g1!&H`ygFogISFQQf
zDYH<{xengp3McSgih1L<>n#ZfJptSlsUR#aP7idPSEqUK5B6s|t+x^aM1EL4W8L=b
z`w=Z8FCy_(W%ImW_CD6Lq#yBG`lmf}RugPE8Xj3Yjsq<MZBs#;=Ac`C$w~hJsvOE#
zgR>{iHSBK@Lz>|ENTY8UCr~AmUQi}sM?yC|f`4#aV+Y>&48xAQmDj>Z%<i_frvx(W
zPR?F6!aQKu!c4aKbCOa{PTO3cBqwq~afpxnJ)B?uv2}6v#%C~Ng|t2F#PM9@4n!32
z?o_z7|CoqdNWGu(sSH}5HI#JTSderik({$X9?m1dBB*^R^hD9-rY()g4fnxVi6mFb
ze4oB0jKL2o`YPSwvsDv_aB96oeuLl2#DH<==rhM;O$fC#=3%0xFnq{X^{wMq_RDvB
zFJ|Is@J0?5IEZ^&l;D<cf@Fvi6LB_~`$93q-kd+z!^6W}-2X*&Qj*IkzNsd~#PA!)
zrk5Wn)nMJ0$8^)V<LCyt9`dat)TBfZFvywsmdz%nKg#kwC48)*z#|MjNn=CrTyJjA
z14C(#+lu7Y4K%tmPFoM{xSl^Boci$Hz4g{vT^cw}SQrho*m2We=ezYlZqd7g=ymdL
zv*3{=gMFh&gWv4ON3E78_k?)rtG$EZ|C>4QwRQ3Ila`>0_Dn#5{)G%#y{KR%DqM=p
zdap$s9i485O(l%8Wpvbn;M7fKp6XnS{3Bw0a{&<Nc)vq6^yv&IHuuB*hn9Q8o={)O
z^$7ii-6w}}AP7R|ut}kqnRiGN-5N^cEKSV4j~$PVtS{6CIG{<<f*pC5nChB+Vkd#R
zQ4_$$AU5FdU2EB=&>Oe|2f2+z(DP(GE1P~k1@N9iO^5{t8>mg-us8u&O~RgHa>;}C
zxZdaVdf3r5*T}w>nr_?Y4^W{Wt5eDC^T9DkO_bUgSqv6pqFuhAG=WCano9q9tVKD#
zGF}=E-I<@MXy(QR4aP-={yYNveN8i8IWF9Y!P~r#t>0R7Q_Jya<PAbn)Yp(7H+vs;
zCOr9|yVjXatw37w4@}XdkNpX&72@)*j(vjkXkcQ({YTQ{YChAiBMSK9g!0fYuw9mR
znB_a=l0>x>c6@unS=!@uDkN|@kp7{xUa>=E$9Q~q4gHwaSlQ8s7{A>O7TI#c*K498
zXS*$7LU3YJ<K^U8=+l&)%^@h(H<y*xHkn&(wA%r=m_sQ#-}x*QggULhD9?Vy(}CuL
z*4fXo)F)MG5x0Mw4ggS$HaXl0DbIH6HcoFq=zw(z{eK$P)P1vdgy&`|Tbhz)f5Ke2
zUI78;`LD~>cIW;hgqv+Q{ve6~#c^v{4fJ$SPxv}tdKci}GTz!N>@;+mfgV&py8DDB
z5bDA0J_HFmJm|<7Ir}2A?}i7#Qv#WDS@wiu2Uau6bTsQIhn?%Nr~v{ovJdZ+uQEk@
z!x`>1vbrr~3AR#%_5lEcytdQ5uaqk9WC&O7)=l$8URBLlvA?1KsPkAP{btZOFk6ve
zTBHBdzm(kEM0eCB3M<*u-uhvV9_u6%U9EJ(Iw604x2j7pIU+w<-%h4(OCxCt5OTY+
zO=;<JAC$jAX+$!Plr-z$%lE%)*k0BPGjXrI7c?vfD77(}Xh#!236^ZWW7Uf3hh#5_
zHnOviFE5@&ul9@(DE6It8FJ!k0i|9E5FgsDxBE-=ev{Uykxb(n5UX+Qw}5Hgck_z^
z0ET}yuqkl=r3L0Ts16Ih#(7rgjQ(l(4<@w@*Eg)d!L3a^aPTSjb!)(Jv^E~$>w4Z3
z(tFG@HuXauTv%2_?5Io3n0@PkGBDw-Np<W~{DV0;>OT-DUMZmfeQz-;w4!5BAv`qn
zqyG#EyeG{8I~@EPxc~9l$1qa1)DJ%6jogRpL)-}_+&$as9K?CSXp7E<+SW|~*!S9b
za&h<PKjGbZj*e@|DwwbjY+iriLVFDcU*7NcXc4w|2b6r^@%O2UMx7a7a%5=S<1`mx
zPsLBUyH7CQf0}r|GEB|t8WY$DoevE`Gc&lHf}>FHe^F>c|AxotsjmMh1kfL$xpv+R
zyoNWW)*<<M>aXfd_0nja)#O?82Ckg}CxSy(yBIhvaOw93Kh-~_m;?bRkgEWwe`rlc
zGGCc$@~-Hpy!I=FrN=r`ba~lMP(c&Zo6G*cbI8-3-}AVW?rd2<WCYU$tq}PDGTxBt
zVt@pKwZ+as!Lri(C|k4Sy@&kf?G!Lpy1TJ?)LnV37D%HvvbeQBiF!F9^c@#|k$_ec
zh;*I3EcNX7=2uf-`Q&DXn#>Ficm8vJ=(bk!oZI|P;`(}^KOFQ=-PXoS;nmj1X-9lZ
zL-mjk|3c?L>eCATi`#jtZn69~K=*qsn;}5<xX%lJJk<;_v#_JK#|IP2eCClEWIq5s
z)pIbk?S~i;xx0SE@&e6AbAb&Ak)-70LI1oxjJb3%5;I_4$6hzfl}DdrssSx*rITq_
z>3Oviu!q2{32*A)>UF!^FxfGo^cCztD5a%KS4+~LvQ6&))=~YaHYYkzie{qs>#K_X
z<xpM1+=O57*d5Q{rl)EN4qnLrfokE&{m5Zc#z3;|eqSEDIBdcaUxos-l-TH=wX`-!
zF=nTByy@L19$2KA_06Fqb(gX0D?mduw4wJS0|pmr{ky9Esi`e;()rt+M(dADnj871
z(}S6f5(aI2CJWiVk^NcqXkrgWT$GpJ@l0SjZTyD_geQmdaua?F`GT?vn=g=xyrrW{
zRXjPQ+{^HGp~^Yt*<#c6=R2PUsvm+7JWSR9)&h8#4G~qvDoUfIh@I6qEPjAK<2Oxs
z@Kb1tG|$87M3Q~&zCuosjjf6n9d;M&Z%YO*0KR+_%$fz~lgtspw>|&o#FH0sn~y^4
z3c2t|f9-$&u@jST(rjmhWldOcL0O}Y7^rRJ>MjuqS*e2?4TTdEJqD1VrO2Eu=fVOI
zCF^SA<NLF)&ej?utSs__9UfnJqN|eYCrkAYA7}~GH>xyL558?$@KJ504DL{1))X5?
z$wt)e5C5E2ul??)c_+3JX1vsLva+>HVo3C%)HSE)VZL#$&4dF;A{FF&b;>!)twJ%c
zE=d~Mtf|n7au@RZd9U$`W-*Bpr=?G$<7F%QWTIPlDf<k2LJoUwjlyt<<4(pJk<ON~
ziLEFuULK+S&sSK^1luX(0drRK6UCE;Mj>K<)W;sE+hDsAEWP=0`e{MO#rpL;-6jxb
zZ$(H|mU&kC)TG(u2m(o5#Rgb10*i8~D(2b35R?O<)!p;2mW10F*>R5vz}<{yr_(20
zaY}(;SF=6wzq35`*qqQ=A=8D$#0L4+eK8wEdPxl-%<lpA1?AfKO+7O}GJotyb%!40
zGhl!2g97-o2&<O)nHfEacA4ot{8nF<{e3H)frHIE>f)RTPjhu+-tOW4Ms}GXflv-i
z6Y4Y+AI1R@EOhig82@RrL(A?`KjYPN42ASgYFW(Jpv#!msotfZFK5<mNT(0WCKK+3
zm0B)e>g37yfVE+^&pQ)Um#5ue40z!_U0Nk6X<A9fTbGY_<>K+`_5BDZ)lg$>-*l||
zM0w|PbeKa&uJ~X5e<8my2l&j-fPWEBnXW&<2ieu588^?%i<i&l<n@AG`g!bXY%dPh
zyl;EQVz~Bk=7VUK93p%#7u-iCW=YQ{A8f`eBOQIRr*tl%Y!%DoNH(vX*SEckl3w>w
z@6E;-$2r0u4LXR@Rs1)WL(83(7#_rD(&4#K{z2WYar3MWj$_K;^XU@*sew7)Xx`$_
zPnY%Uco4Da^#rcX$hCBz*O4q#H2oO-gwJGB?|(G~R9iI}u{%f%BPd;moud#)Ff&os
zMPiO{gj=dn(q9qE_?P1DyQVDf(I5BciQNht*#~z8Ju?h~Bet5vNCUFfyZ_MlaWFV6
zF8U8z5N~f0LVd++^<S;3+P~BdE0WJdU)2cw;CW}egj+(@gwy<@iFh)bLYF27PB;C*
zDK)xCV&$V42%Z4%JG``ZcRzaC^iXejAP0{a@SFfO2fW{9S?Tg#?e9US3@RH!PC=0$
z?S4h|fvkmSc*eU-j5Z)!y!(Y90u~$jyQKW^@X_$kpAA=|6|jE{{)DOU=K=x?PkoO#
z!C*+lA`#KM$2D}m1-to(DK?T@lW1A&q8DGWW$ie@hBx@%bz-g}CuGI{fBY4mYPDga
z{o_xuYJ(_ZfhF?T<)C&hwigj6+l{4uA0|e&nDyB7?-!iT;6Z2RY&yn2f*OdYyznX@
zD`wwTx8RNukwzle1R=X2a14PIeNewVGKo8<h#!=+9sz}kNIlmcwb_nGnAd{DlQfYy
z@pqo$@+7q~n@}J8){brS|F|Tj-H8TlGcX3pxbKU$xQ9-ALTR{%R<Po_KXud1kVv8N
zO>!k;@i2m_29c$@Rf~ZQuW2=sLB6b?Ao=QkP6mkI3dVoXkW5^qLyws~azi$}Q$#OE
zcoKOaAG=2TH^d2O1qq;+IW!a5g+Zf1^Asvi*5E4k(x40s`~6(6(0rpGW<cwT9;x|m
zQNwy|aXXRG1rDd`{xkm<hw+&&iH3aS>%<m(SvA472wS-xT9EKM>M%D`CTjJ(TXEFg
zl7n#$-HS(cwH;00rvBpbK};}*W<b1=o~VnLkNi!)glV3Se8jh5?k4_rfeAF|d(*n|
z7rV1xvi6E)8{tghHUlRuH~u9w$gzPjM%;FRi<b!3c0Aj|t4QI${0|Mfbu(@l0=2q%
z(Jd0dD?RQP8*RwdrhU{5B{$q)zQFc&z6>FeymBfy&(fxNW%0%O)OALHZB^lawn{ZM
z&xD(@-j{6~6?7{sRT<J!4zG4<>DACFgq~*j22Vrp{*4?Xd=~L|y|;xd^k-kKBZ;sN
zw>ozUPtMSJfgrQ{um5Liv%iGJY@%D>*@Z#q1i6DQjQ<Z$R~Zmh7j5Yd0qGvP8$nXK
zq@|IP?vh4Iy1PL-q@=q+TDm(%y1U*TzxUoxW|(u&*}3-Gd(JdFy)$!08-VY!s;?da
zZ9RAUMi%=<#u+ax6mxVY@Bx<d?SVRV4H=*onE%Q1g6}BUHVj9kd(bCkffsnR>ABx+
zVH`0>hwh2GM1c)<or_BCoi_&QEgtVp&PGD2(+=#eq9Oo5BmRXFSE-dI1O|c31q?bf
zfn3kl7*np3_NwZ$%aOm+;6F~qfC&2*kob^~sDq<?FfKE+rVjB=o+hPt6+Z&`B?q#G
zs%J>la==0i&CrBjl63?7%vP22J6bcm9PbWf16Ciu`uRKF2L-&i=!WiNxq}qF(X$M@
zz`s_sF%NFd2>>EIC}b-DR(aoRzk(C<60>m2;Kqo%&35`z)+VZJ0E(MsHS2ay<ijgZ
zr_|dDjkO(#0uW)l!z0#R3<0klhM8vdG4Zs8MQCjmGYAwfFqREScN3jhz|Ux#=)43=
z*}vp_tI=ds-P=%|zEaYA!?j{&ThBtlurQh1O|Px<x7lldErVkok<rl~gxNr#?!V$d
z#OvX=SusOv-6!v|ITISmQtWTueKz3`pguO?Ag<Zyb-mjfk#6N<!rG6HtZ;bcny|UD
z$7uC<bt<L;fo4BIk_5wA?4c&0x5<Jhe)h4Mr17SCO<3RQeNIJk;g>62<~s|F;1-}6
z!rDNmsA#^h@QuS|g?Cp`3W&4s{!vGKy#pAzl`qH}+>sAX#cDMNo>{0r(|Y3v;%U4t
z*4pU0MOa*QK&m`9lv|F$G3`N=^Hu66UjW1KQiVio6fR>i``}d<7Ixx=wv~PLI$dEs
zcs|}LSJiXH(X7VUqM~{Egv3yF@~U3`z?O&N`;#0VvdqxXosW>+53N@dcYK%zWBQZo
zpQyKdpNS`jVgk2kKWe7FZt8e9%cy;hkP+^XV$2>otC=tT1Yo!w@qZtjFxo~C-=d7P
z9m$ew#FCW8Ypa}2i4k7(|DH1n-L}CuK-VQrAdeDF30e)?B$3Q}`4GH%7Ue_-2yRte
z9}+p^PI{t@w#R91)}b^`Y*6-?5!MFW8}DCV@XSs{jTL1Z-T@ZscdGRz5iSDnc<51{
z+$gKQ0se4-v+E8DY`4)#z_!_@Aml7tovLrEGVnX9g9ytfOgky{Q%Nx!gD?Z9L7d%i
z<=~ci*WBPDR4uxrF8M7wyJwO>YXHHr*p?9nu^U`tR7?BHJ`lA`4?7GlfUXW|Gl%yP
zxr4xum9!no@0YY#6WcEa%n#&dO25X4Cjk87$`ulo<HfyD-@PSygKb?^&l%SDKwz*H
z*?o_Ad&!4hL^vrS*Avw{U@MlnfMC6Z5Yy1Vh<8UcXREU(-~g>A#p8#&#;5`~Rr){2
zY;Gqy&@$<*X?iYMDRmi6Q`*7Y{3>FGS&O1{308?1$->)S&wxWiC7RaiO1F+G>^PA_
zSVa6_5+QREtk;R{>beZw8hE_;^i6}oStE<<rKhJcdT%ZGOS2jf9ETwz520V?{=7LK
z4SpB+oC`eS%c;@%s=JE_7N+BJ3I1@FicVwOt*~OJ;dvy%Q}L5~dnbGZ1IQ>cH8yvD
z<Ty;#Yoh_*&da#Ns(D(@gfT+om5fVqj=&UvC&7>d#4lFYq`(#@3PfqVAPS>5B^<B$
zmdLk8;To^Bxt7Sc6LS|`3Sb!A&VMiom$3v^rMO>o>*_!yLHMb8lBkn5EN$<j$r29O
z^FJn)y4}cR0@hb|k6D$#P23n|XvgJ*&&e+Ba%f^*cp*jITeB<F{$dimzOgfQb=WE6
zHVvHZNV6lbI9QCE#5=*MIEW*8C_j3RKoZ!Y7{pZf|5iJS%iQm9V*Gv(8Kv`oO&b#V
zR;$4O_H?hg*!ZhuwL6FT<+Q6bVgwz?bZemc9QMaPeYLnhnd#`RU=fLj<9!1VFOno6
zYgryvJL<l9>~*=`C?EG8eGQl1ZuXg()^9mhZT2|9P0b=<&R#Ae=@>uk-U^esCw*_n
z6N%LowxR2Gf0LCevD&@z^=_1Py#XLDNFd(-<vVQEf$W4Zrisn`cU@qx3U;W7IL&i3
zMZalvs`b9Tldbg*b(6>U*NK_GahOcM_FBtd=IRgnt+u*;G;UumR8C!vzXE1EHIpO&
z4IoyEcFhi`(>$2COXfKJ@t$|~6-)kVV{`t7;y!{njIp8WAm<`>;?yytcgI1?_k4)1
zV+}qmf<&;su>*9#B#Et+ERamcf>#Bhl*SqF`6R}<s1L?V!z$4M8xb7e^Uu@oRhkoG
zP-e#3#|U0;q9fBsJDTDluFFs5w6dAE0gxA?N;3jAz^=+UZF~|s-{GNQeKQ6t5PrPA
zR7#5?0W~fMZNh?vCoj<wG9;4Io2b(I;p&pr1Ji-kw6Doku7eafgcbzwBV8RhBMjgb
zF8e9vMcbxvS}~)eJMK5AIeLCa-6j7XK?7P1;a7_$2${A0exHbKZ}lnu++Mx~9r(P(
zfgLSK75LtEHMHXveB>HU=nK5rAg9O7y4;)Ai>RDOEUi@St<mVM!NU?_piM1cbL3di
z^cGb+$c_rWgG()XhR*^7;*nti6lC>zMmZi3Ctl65MlC!Dsy4gZShBMFizJ-g<6^zU
zq%X~pZ!#1stBMWqU<b&?XMO>`?=LNaOg4Y~5&NiDL|O=6@T=Qa<%BjCvi$`XW_-0!
z*Ba9pf{jRU%yKh#4WyU6KT-~iCPi$o`_02g?cX3fT8RMbTYuON5B-hO80G1o3hN&u
zU+aIjGSvqWZV}+uG8OM_jx@W2;iC^ECgWDlFEwEXf%k4+_z(C&0(sOmtHBNnIgO06
zkgffb=?o)SA$>3#iO_{R;hWCVq8r2jm!&@TH+8_pMe(`nA#VX~H~4=IM!cvdM|9(!
zXvv)$KJxbG@>~u{3F_9OA})u|NaPE?qX6VYC)Wh@odk&j_4I_#+-Fxq(f!5F_Trp|
z3P5V<pE2nO`s+Y}%jaZpaE$10^8ah|J~LZzU!E)QU-<u9)~%8J9BywrV9-@S&>i^b
z|L!&&uu=>gLiVlV*coO%V5(s6x)Vkim3X>y?8kNoHg^%=MgPt0Oxy-aadid{4YuJ!
zUfr=D-n{f1ftBU~krVPk{*4~uY*s@+Wf2;T7y;(~;B8y&4uFwNwgcAQG;(gU(a_v;
zAO;!#H^UJhf#`ROiN|(<tRQ@lWe9nP@Adr?D##9rX!?#eWTo!&pH$%EasLJ`7>2|H
zg1I_D7J>jA_&il*Yqw7rse*ru&z}ANj}CJd?b3SPYseA7Wd>diavY3v=E%Y3EeUyi
z0#adk;Xj2E+@y?g@S@^PJT(~B07PD$2z=BYTHcQj^B5q|r^^5O6`HaqsCcZIbhII;
zwDBSN<W<GswlRttn(UP~Ca|hMqiTdDeApjgT$^qOe&ScZz0313eI+?ES;2pEk4S*(
z;1#v-nf5}n$<tv0`kUmi>F@;E&L2m6Bb&GMTL*%TFLPbB{#yW>01tr|1z(Q{nd2|1
z0R>qB0?Xpx9FLNf@QS<ePqmGiczv&kDFcn5Sl%$%VJu{Q`>rCHqsz9xcW>-f*yurQ
z1DV-3QsUW!S?2-CB$%0gEIKSPo}c$Cii2EJYS^kWWc{*#0_VzGoibp@$7a0J!pAjC
z#-ujR$mKBj23A?Y`C!cQ;4Q%FeX&DPGj-v{=QcQOK?)=^4*L{+**+=<0i=bX1<kiU
zFub9MU0SdU_<26Eg}KuDqhZtJh@Gfl))(%(n!WIN8Mlpu?jGDQ<8|~VUM)aVrF{Rq
zH30BdsiQ-Lh?HMmf&FD~vDRUuk%^pN0;o@Z2wS@`SvtbC;?vs$7h9!e7!GY~8B&FL
zi?<aBWKzZW+57vTZhHe)u<_&xyrP^NG+X^1*&SCbP+M+)elub7L<Z;idTTLH;RvxT
z%QJpp(DBW3V?e(X-ems7Hjp7Q*|!BU*?nO8*tWjDuQqB{8y@YHv*`pWwsnQMt&N3o
z-4t_{X@f|4xcjuc&8yw_h`El~tPy}j1;UjE@=;uR>=LC`N$6lIpA(SBR9h9Z8+hmx
zbE5BI2|_;PR(j|U+#uwPhq(#$54lCD*T^u&&#sd5k}V@dL6(599C12^H)DR2WM~BP
zR+F;RkB&W8hhaEMFpnt$SzGtKediUK?(=~pA||&^=2TMyQ-wzBwL<kie<0qY^3VJ|
z?fURe<l7f}yNzX!`Azq_n}h<-FHh#3=!w_A|32Nm6Bu+p(6>$$AjX0!BD;QXcM2ET
zq~E0lEMW9+fv;3{pD`~#1@=c^zarzwTMZI&Y3}vyo5&QtAg^_<>?f*!5&2^I#9TZo
z*tAj_3T1dM-fhgU3kT!?Kn%4RuK3gKbUs?&X*IgFDgZR+(hQe_eMu;PANhP7;Z!_b
zQLrGW#cYnH+kS(A6DXOea~9D$XR7j~6iEtz*A$L9nxqFhx-}1;ZzSG~sVM?9rKUIR
z?3~I!9dZ~z%}vXig^1;`#<;nf&C^)>#<Ir3`E=xQJ6s4lzh;Ql<4RO{9uWFS!fOPo
zg{lc<^QIKPF{^f~j=UIPj^1Fhzl2;0j#G8n+|;;@r0Sbq?#v@!?-{kph>MfZrp^T6
zoUR1ZcEVmp4QI)DEXZcEoA5k*<V#0DzhgDUrg@Rh9PZF#9n~~l7_;WuJ@YVv39p;l
z!1AgVU?(t<jy!gpqxiGWG{qt*iUaj=^hVPk?3hipCA@)!u(TDMp%zyX&+XoqO@fjc
zT+37xA1j0K?Dzl+%Mp!e*wBfz0{xWKew^k+tLYEKoFR99E#^{Rx|Mp^zS@AVZb#9P
zIn}vJY(zx9C7|*|NzQBIKObnB*U$jJ?Md6WR-0fT$WQhev@YUJ1y#(#>O$!nqUqi|
zXpIWJP+-00Mh_hUcPO-CMail&oSZ)|B!K;v{Z^4~YCC1d?%totZ&;c=ezUw%bMJZt
zZcss~`Ou{NBG#m(I;)u7Lbx~Wx5WCUf<557fPwM}b%E5g^Nc{3dG{8-0V-f2%jyPU
zUQfoJXN(SCGhpIEck=KDg!xQlE?8@Qu${d{IiLaVt5M1zYSEW#K*4YXsMl0!8v2^!
z3){wQUWKAM6q|7vnQHwEn)2TD^v9REZgtL4DUOysK$l(OE~jNWfiXw2f@eU^E1%Ku
zS#i$>5lgjiA4E0wv?C3+eyX3iNVEtQ)3HZV*IHf;T3nq@Zg|Xl&#eB;G`rvHTZul8
z0t#x?LJfG|FlWKrJM#S@_#?YbU)f{U%<F)DPFJ>AW?-OjW9VG#H=a#%b&Nyy_dB5t
zF3=-Egh-$TG6z;%RkSX-@hNNr?LcxDt$qeo>@Oz%uY1gu%LY|6`#LI5AUgs0@CM&p
zKGpJ*^Zd|zsunU_26S`j4STc=!ISISg%Puzma@-@yG}8uVH~(xg@E78_$6_S8#9Rf
zm{c;%UHyC#)S}gttUmr^SX1!6Vj3)%*)G?L712#TnCdSXvw8ll>7mQ*0>gRg>XXc3
z1GTqTW_Q<T(TP8c4YjncLrl>1^zp1__6TT2$r7rmd;X=s+}SV4Q{c>*GA&1MN~!s?
zpKa_KKB-ePhG=&n4seTZ7lyi2Tssu~`HSPfO=y8SoTWTO>OR6)?Xn9LMzhNg-S?-z
zDmyosb?V-8gi+KS910g#vi?27wUvNI@D|yxJa%~PoQmSMLS^rahTCp(IwO`0Y4toS
z?t&e$`?eFLZH>($1k<S2CBLBB(=mwbrazp6;r`2I`HkfS7@qiov%!Hyz3{8T8Jx8f
z?10ipR=5m0k(iK|Q%p|3@K<qj)H0cw*^_fpb~7kwwj~K_ws9mw&6D%ZBa@gUfvot0
zBoqNMHMKHNUF>5MO;}CDD37fxS}~tFB59}VjhYX}Npd6x(eRAn^+pk)s`znw_n3NI
zXP0N^DfiR4nEoSto(J_;k&0B&<GpRtmb`d52v1D_`kSimLv+s_x@I;+{ZvY7?No>&
z0W#hB8SY40>%-QuK_9%3vX3|2HLJgG&_OnETp~)Xiaa-%DxR<D;S8Q>fe!TPo-vv7
zO$~Lp&=;@4cHwgN3R-9Ymj$xXTl$yObBK5B90dAG@3d~+Xvj7gMQ+@s5hqhO$h_a9
z)D5V_Wlx?7SoGx_INwzimw>tx_Hp-n6g*ytWW;t&8f?#gPYe4XMz6~6xwRsbpQCvq
zAvb^x{q4A3sTXh?oIx;L%>IguT4#IHo}XsG;CTORU=Ap0h19(sZt^fRzE}Q@CUtvJ
zu4Eor<egfM-+4j$*bOv6O0obtmSz89^jl1a9Jf>ndC9!W3kH1H)<ocS+1`87+q?c<
z#eD8`4OIM*l%NQjPrC)J9q>ma+-656chmlZoWP)IuH&WaYOI^12*Dk-yG<iyw@LUH
z?04Tu)mUep$8ygL-jAL85^SHVx=7;1fhxpDZB8z2b=FHkDw?Ugk1)lME$jz5;?+La
zITd4NPBIyC<AzbU10Z-K6f^ed8>d#ORM+@K4u)sgZzW8!`Gu^6BI{(eeWD?nobTua
z0Bl*LX~rrJ!hsHzQOT?iOB-74P#Mu@#7<gLFh~nMMB>c~3QhcDVfMJ;M2D3qO<8>T
znTS1EJtBDE{b(>kWGZ#I61^8{-c2RZlX>+ZEN~mJMQay_<Wz>^lxl#YP^uP>9&@Q&
z)C<+dhEp*mNSp7ubo;B>127S<vOnvLbv6rml|Rf+S4VTIRS0t-{`W_gu!4Nd6mLW%
zx0=5%nw9VGM7p=&O)w^RH@Ax#(8$%ONu4PS&u2AJ@a4-C^Q++XR8F`hsHMlh&N!o&
z$fyIi#>rE-;CN#(RLsgc*fu914G8MVgQim@;)4et5u@FGHrzL7zBwVj`3mLMSP?LQ
zv%j)s7^hHsEk~ERzEvWhCv$sYa&ip|1mD6?5hz!PNnP-!E|UFvRN#ka#*PCDzp~Jf
z%tRxy=a=VGzw@3J;~h{Yzkj~foZ9|-G6$PxElJSOhVVMVHW>0@l#Qnkl6k6@SK|I3
z{{4L;u+sXfWlY(c@ttH?tSr<Pi#hR<0H_SB-3#BGEB|qiMyO0?eOtZk@D}*q!hT_s
zdTm;mi`w`+5QV-YuLY*ArvQ3q7@p()W!{`Xud}c?Cb9I;pE&CW1m=jRe#08M{)5jb
zB-Qo{0NOowz<I+*lpynd3Ul}0AYNfL9-Xm`1|YQpna}Va3j-Udu`SIlfw|-;Ff$ra
z)muT|cMe^`M%!U7xbv|nQ*+y&W1MB1r{BbF{T&mklR6D_{)!9|iMqs$oUgV!qtT&m
z6YjI|J0~?1F|3HUpIj*4S*91_xlNvurGD6gzrk?UmD{<LnPDlAeg<D1P4+SRh@fQ{
zGW6wyM43NyE4I+R)0dXf&2i+bw%jO*@Mqw=RT*s6>T;}?XbDUWrG5@ufFlSx&r)>*
z&t!O6jLV94`eA`#rE40WxeOKJPL5)LVE9ZRHQG$D&b-;c3rIc)`o<Hvk#fqX*>wtK
zU@tCoFCkR;hxtVR)rsZR=hEmkA<ya7`K6g#EpiiB!$1vaa#oM=ez}1N*^)}C0N<e4
zIa+tjjka8ltbINa^H`rZ+?6u7*RQF&&tZJ<+fAxb)+HbnnQ0%~jY!B=ys8^Ny%3;-
z^eqbt{bZZgrKqH#HDTK2e^pRtKmh=~pjPUXj5&-v*L>nF(`{L?TU8QZ{XCvG2TEV8
zVXeWq6Z;0~60ir0b+KP2oFO{Q2P&r)^`D@)pVhR|TQ(%@TP#OoSgDqCXmNAt5k+9m
z>8gTk$1dm}?|uLqX}^Q7mddq|H4Fv9ZkEN%7JIPNH$1Ri?pqTtiyOQ+g@%P0nZ*-;
z>}$}i)+%(`t&aJSpcZPV;?t}ai!%AQ-OoATV}R8tbhNs^Oaad0vLKN+lGhnx<hFRQ
zhS$FG$?dGaT3|mHkSe{nwFKj=c>j<=cgQpBS-kUvi(ydZ!8U+H2iuGrfGxKW0ZO!w
zpUC`~q9&3p^o|ggg^)U1hR3=(^^qUGN$86fZkU+%@P3z-e_s0tSnn-;vW)G*vKdT5
z;NZtIowHQXEGSLqt)N*Z%57i-&}^R*UnAa50WecO4_<)`84)vWH=7v7K_y59DXIf+
zU<jHjd*aO_r=einlA#_UpK-Y7XCxA}0#9me=U&9?9FCXOs*o69;JVvq=$!8mKFrix
z6ek5Sj7C)+VPTn1P3*f`96cO3MRZ+s@^gO^zcO>&(yyRb_$YJ1p-Q}t!XTM?E&Jof
zu8bapde2Z=E~CvdBY@A4QI1**p|@bllV4o#`D%h!iaUP!L#$Lr{ipUCIUl8#AQ<Ml
z8<#;@znV2?%y<AH%9em&>i=c|=u~YHbg;K8uqD<4Xd>vGMnY)PmOe>Hz&I$vJV18X
zg|CNC4af!MW*gvF`@{Jn9BRqi<@)YKYb2~<IQR_f*ut85fFmEgUB)Rywt3w6czX%P
z?9fQR1L~3LR-aFi(*ga?tg{ZpAb6*Dk+9;xDN6{Pz4bR1{II^2Ye<0LJy#BE{J7BG
z&;P3O!Dh~usdqYIGdin~?VDhKX*b|Hx&B<Z42+@e&}`xJS;K|jWb0ssz1<YXK<L1t
zPL5LrmXq~`zruJ6T<p*ZA5Np{CA@9kr3owf7(m^L`BuK5g{G;oPxmi+rjkz;nDBK?
z`^ol1hh`0+4P1&QHBsMNDve57Nm8p)xKR~RYPF^60>N!YsDtCI7T|C%XTxO*M1g{6
z+yk2G#sAs%bC)}4_Hgj<1+&&%zJt`9YC}x*h87@|f3uuECuXc0wC*eev{6GQ7v&$m
z*a2PU-2n<fR+Bazs5a#EIymE}2QcvELId}r6QYwZy*>(Pz!q<=_Ovq5fh`9W>fu4`
z@XTFs;V<iw4x1t0xC1DL@byKl&zD@NDMexek)S!a1?a0K4wIZp$8Q5=UbA0!12y0b
zI-K1&1f3WJj?95a0Q-yLm}4&$-U}=BBtpcDL7-IdRdA<Wdo&H2>hm~s13N@%DH~?0
zPegyG3zuC%XQW{Zan!|edhy0jk4ohh!1tO!vg6PX2;nyf<WA1HTA+IKkG?V`HKB$a
z$gD8RaV2jUh>+ZlvJENR;2>g8cHpf3oNGb;E0qbhAG?%PM9&_28~lQGbi`>M|5uCK
z^Hj1Lkt0VkX2(X#t^`yK%sIa79zp{|G5)2s)Y25d3t7qL&qIT^x<Q{OpuC9HsfX8X
z)=}<!yF$T6cqgT}r8H4MpZ5wdoC(86Ziu5za=8-9A4d1>Yo4g<$O7F!`!MIX@(1a<
zM9mYFzr6M*w|(omv9X3!NMEH(WW6F&WX^6O>QEWQBFI1l4E#g5yv~by9R0UWXfgD=
zX9}<7(SN4xOa#|Tkrm_k@!z?3f>8k#Om3(FWhEW3IHACnFQfd-l#B#5-R<1~L4H8J
zPAGql54UBE%m*M~M><qAn!NN;Jm&5y;f7r}#+*W-0sPmVX18(JOuCc-IvBruix8jv
zk1!^lQUTucmn?xMj}yL8sU(3U64$k<63a>0$fccaCprd@>eqpLJ|P%Mujt2S7D!O2
zrIm)w0Q`XeT5s(E16bbZ39njo(v0Ib5k&4n<81!3u#y?_N&^tJEPML62+C`$BiZCQ
z6|4F+utXhr7B*cpTY4{Efx`Nj4?5jLr-4bP6KY8y&R-S?iD2NdZE2?0Nf(Glt)cR9
zX_X6uoo?#xD^5{nZOb0UF0%Z)ySMr?$(fU7DlD(+{SpHDxqL?|i%>=4-bmTiCl+3Z
z7~MEDt1+Y-G0S4~@FnnFvn5~YbV(|$b@wZg^#3)VV|DWcf%HK;1wsQjXofnmfNjz5
zNn~CF9*|0=H~XT98|H-Th_$JMwK|l`cz409%1Y+)F#9fTq6yFr+{SO;oSL&*ABWER
zmD0B~H;rLFyBfDwFc>|@@8gHwHUE9Bbz49GGz*3u6q#s#M~Q@jGF%<4BYn75KP(rD
zDhd5vLxm9Irx&IKlK9GO3uFBo&2n_k71-bK>Pw6|()F$rWw<JFxba>Smyc8nWg_tL
zg5b)_HUl;TpZYE^NonxP>3#O;<rA#l{ZpKJp|^R1b0y#G0R~dws3&y3w?&NeSmIOz
zT(G!TV);I+f%omV8_7J^xG6io*#-}qFF#dAn(xx8^!*aXJjIe?4D_Yt#4GK)abvj}
zwEJuHqv6}%*0H}X%7)}Tongu`I3Q7eEBf^Ku6gU;x#ZyxLA&)GICCVrrexAwYSYql
z7>AYxyhXpG@U}c_G-onAqw^HeJI+F%9tX{Ox-`)o-D|vGK3(4LT0v)+xNDWRLhG!b
zdtL%GT%%8iErS^}@9ZP+aqf?Dqn(J#JMrf9UsG<WcTZZC-osYK`Of3Jiras(ea+f~
zFpnK87tJgMV0wQDIl!-e*}r}EW5cfaD2EB-Ni-`aHb7XP8Ihyi!tW5E&1T5GE9~o<
z6;?TX&C&$J(=@`xeA;$-peZ@;xJiTgv&??AAg8KMnn1E??NG1z?5&j*Hr8sI^SI=M
zr-c$`n)!?qt1otD#IHD&W0PdA{Se<j_+fKWrJO%k<qO-sEI6}%#*ReLA)NheM8+dk
z;jZjW7iZmpHPz*)Um4KHO0U*!!z%5fG3#c#SG5wv-W1o^@Isu@S)H*j#6OR%3iZ0y
z{Pc&f4op#-%|7sRS8ru>4x@|EOlX($VK|)p!N`DGCqYMu<gQtTC6IlsWLNL0z{T1y
zR9ngC$tnT4BLTQOtR|yv$Wh-{GFL>}Bj`z=Sx2s=qi|aMYv3qMrTd9`f`C(H;gb!2
zV<il&aeai0N2=3(x$H<YA4(Hc`46F<$DhW->1^PRoHD<C);t0Fly8JLnGq?m99mHZ
z-@zq@MJh~+z@cinnhu>w<_p<Ct&{G&TE5ShxCgBi2;{K^Z<B~q?^agT3x{>qoGT^0
zYt}1PZH_V231;73Bkqp#=*kIDWg5?^4NObV-I@EdVL!(<qrrUTDdTzLl=ja6E0(E9
zOy|^Cug}ZJw#ZpC+fCkgj@IZ0|LNMJ$A_xgeMp9qDemMx4kMA&ew6lxNgrX*zC;Wx
zQW0@3*P=n2Q2s=|w5=CGkDo6k?zQnTNMQaZ!8`8n<BWyzbtODgqY8sPF>oe)BWA<v
zvA-~$Bl%Jlsc}io9k7~x!EV}pfUb5ISeL1eVD%!-e8*4BO|xc=Dqi!K5;Q8vuJ_GZ
z&HEe%v$q7c!&T%k#rBP+u*J3+Cdd0nm{&<QC3?3OTnU%9BP7;~sRFTl&D6`qn^qv2
z8lBF1gOGYHCY4sdCDkk0+yRe|Gw9-xY|^UN#i8%3@Wv+aV5rNd3tzi6<l!oKGRT#@
zXO8Q6mMew$$0{i94x|$I%S)N;;SU*Dhq{}lWbzN$=BGX9)0QXo@=KxcK{1w1CMjaP
zZ_>@)77#<6QjmzmtNTt@nwTid6it1u4Y+dupAAKOSbNyUxGCz_mx*i(Eq~SM-xL14
zd-HF_h%{_1*PhqmJtxanqYNKh{xsLC_09+T(5alKRfQy&*(W5&La$5i=+zdw$OHE`
zo|7S$&AD2{oKinjRuLdP^_4Va#xh0ejQ1<a-AeHF{lp*CmoRobJDF#}%c#$^j&_oD
zRseT8+02KL%)5Tmab1f=6L@tijx(%XW<e97P=D+%wkIC{G_jmjzqit&ZI=>1_mw5Z
zxlC-p1%HxMUB)+)1FT1>TBa-)WyPj866yLp)RFKv!>aCW(?Yd7Y|;gJZ??0e$va<M
zvLB73@2qe!M(Em&{tATY`4UnSZY0fqTSe$1f33y+azll71G|d3&@r^?a)(^~eKX6q
zGji=W530H2TK3Cn@(3Pq@Yy|Fq!jW!P9)$~KOI<ES|UgsS!`h;z&Mt58frNKSv~Ea
ze0%T2SzV}d%yiH^@XsIXh=*UKcq9p}XBe6DY?bp}8z{~&f3dzkpI+CsLN%GIXmYPc
zp$UCp`q1#%nrbz+P}cVs<uxY)pOC=3a}6Ccr<d!8fEy{A6l<Pz(dL=zJ4DZ6fnXu<
z7L6f^hBZ%5tqVA=NPmq-&XUl<Ut6g;I&jCi7IJKUbn#SKdyj#in#z4vUueHD=ZFfV
z&`8@pVM)7{ZZ5DE1A;%E+ow2c2|miI2W9r*qQ0A0y4Gt8^R}8p*|(Z=YMzbjHhf<P
zM#)chK2Mkee!`snkfsSPj#h~5Ofs*Ep%^xUXtslT!xQp8moz365MO&1PCziq`QkoF
zNuwk!eFeLEtmr3Kyo0XoQ6{ZV@fukISbx{(@dL-9ZJ}~2g)_)~6D%C$@T$PZEY-Ty
zVy&v5c5`S@R>fF8piS7Q|8v}+Na?XT%j~?6QOg6i3$`OD23yoj^EtK30=*9ILw@{s
z#w{h6=8QX%y`TN#8l-+S{;*V{%pCCwr0(6QoN&}jDd%fAgsvNQq4^PrM7#&`PHHEP
z+f*-nLW05<`nY_Ige&K6dWm5sltOI4fyP6$M8z!Kyaeo=WcGjz$p<}REPd%DLIP@d
zv5Qu!Ub1e>402wz@(}1pf>}<a?MR*P=7t|(X3Rpq<l3jZWR92z@;+wfw<>Put%fK!
z7NF*d`!OqkCo$@lN~Evm9c$>2d$S}&b)J)I#co0yV5HKo#UKYo{n%w^F@dB0yKV1D
z%z#?X(rd$}Hk&if?$^vuuwG^fO6m!yCBf-F#i**9n|U4Wr<D0HF)t|?MdFhODgLqJ
zI}s0Ox_~nmL(@8Z1#&#wb$&yiHA!tS@;hr>I1Oo@COvu+xau@nc`Y&6P7X_ceChfY
zatA-7nzH6jAZ>|_!}4;M`6yV^{!5T=Vg2=^tk8pkLk#divNoo3s^?h}tl0?Y!w#F-
zjk!nY7rrj|C^u1+$17HinC0Ttk6<lV>DuIxO86zBP4C)lr*=pthEF^Xu1745?c}+|
zAM}c&FC@hpXFp`vUepBnPW{!3vm)u#F`dJqRb#NvxJFSO*o%aQLiUdP-M{>M)qp0h
z6z+v|4Bo}uw>H<6+ZNm*%VO|jrN4UjS84RLaz3(akMY4j7{hDeMP(-L_11FHyv&^q
zyZd|BgH*+>*60_As;2$(v3k$Tp>d*g;1%51<xM#|WOi2Iy*eb{pg~7%y}89c7-@*g
zJzQxF+vL|B9yeo25n`~7aEJ!nDOfnZzxO4JiIZ@8oA)GN@3Vz0MMs3hWj$*6>ThjR
z=D>nAh;n8uU^cO9vmKa(c42Ej|4`jGn>NC_#k^ft0z<K`@W5XT$}IKZ#kpiX(((vJ
z`UpHI>P%FFe|_L5<{??4S}}&;h`mEf`c8IBWI}8f1BdWakV<fz-x#^oFfrVU>68;|
z^m}%ag>fLJqG=M;qs(`^+544@;jH<YE4&}ajiSh#XLPx=Xc_kjq-Mbn!=}deWmTcH
zBw2DUGI9j%{u-?Y>v@-;5VF=Ep3`{_i|D3@fkBf%hT4^=%~qCdE*SG1@0X2A2I<+%
zso7nemy2eM`ik}x6mmaq2!O+<`deQ}??OD@^&;$j1b0}QZt+u?%;A)>TQ~pJ#yG|j
z&Wl`D03!XQ_e1`X=@d3+5bvOEpK~02H+^oB$}#Sqa}^|)?{~>|#Y9<+&~NJGYZ#$&
zwI3O834~=nvhMC9rN1miN37)!dVjwN*H+r0s7;R003hA;s3#%q9gyVGOXXn2ru8Le
z)rSx9N(&?latmDK6DfoHC)H&k2~Jp5C)g<tP+2nBuirm4tJVJ;P*oVuq_A>Z^-oB@
zT8j1;;RdUaB(DfMUwsM6h${C|qnsdomyh!|!t8b3_v0v;A%CM;o>JgKTl~)p)Q3-v
z=6ls_A3a&$Q{saF<PdawmuZ!d?CdxbXplzw!Zw4mK-!4anI$pImpfB(Be*-tZpDu;
zLRkzAiHZe@>qPY^%YH+v{wyDLhOGq!?@$voNJ^7MQ@QV%-fZKB;c44_Mnkp1kNRzV
zStND#c(8Jdj2$en$t^49xqPihy=RRNqsYq)$?xgqjusR2wb>V5K<w9Oc4xsJo3r)L
zM~g@S#fvC?&0?aC+SZ(S$NX8+?YtiiDj<JMwP)LmMN=>yi`gvkSDXizDvkVTLRc5(
zH`m1<`|w5W>__HH&NoB^mUnW8#G>44WLXh`(P$sWf^TMi=$X#IY&FOv8p3E)Eg(;*
zj_3ae+?m;lJ0A!OSH8?J+W62_gcx6!5ypD|uG|fm`i*jFmR>QM5ocv#yN;H!^e*d>
zY+A`3(|!JDF<R~`De0)^_#E?Urr-9M=Z}8?9nT7xeX81>t9^GpxSaqv&~%nEkX{(@
zA6Y@*bj#!halYkhcmCBr5j|*Xc_~AldI?ix;wtZ{g57X=zh}4)yXJdi^xv&IFJ;fT
zX7%v)6>1ZerD7WdFQ>Ip2)+|#dC<1?sLiC-Wk%%FWcuy?$wsK;uzJ??#tY+A=sGyn
zbdN_#Gl94jb|$J>RkHV}lO2y0Zo`jR(=L89A!PFHTPmVa&r0{1%LWg%h50r@8dKs+
zv-g&qNqx<(*a%;NgzzI%;nOE?VcoakiFQ#AnMRW#H+=JY3@qYkAvaz2{K~>SN6?Pi
z)N=dTq6W2}E!=-6Iy-Xd3P70?;nDrkJTmZMkdWu1@~bp!r#R2m9>Gm{HboA&?j92{
zO}4XJiHtomU7n5&o>;H5ecy;sXp85kb%OGQ%x354XEdRWM2Mc4S{DS~?|+7<N9LaA
zj4C0yI>@u~ou!YoAYNGF2vm6~d(5Qn9x(){_@VlvM_Qe#41NJT?@)6!TfxEK$Pu3K
z+IfB@z0Gt52m5Kbi7=|%z{aHWlEFQs?Be}$k+U_st1`kQqC!R)4xv^8yKT!}`Rp+g
zT4yCn{&N#LIDOyI*5rL1-Hr}M{KS~&y7E(m1dvn=@742%t9SL<3hKBV%8VRIe7+<Z
zRXNDI<BFO08l!WC_*gDD_e*)qwJ~JM$k`$&NH8Su!&D13>GT#Wc#T(}%C49%o8V6|
zF&o%AvHXaXuF<Z;!TTfsv>E3-mbBxNs7T9V#8J`IU2rWF{w)rPHZ>_RP5t*eU}gPL
zoY<oSRUKgt#VY01*PXR=za6H{exH8ys=TAW2}x(t#d3=Dn2#^>%d}hjILv$roRRCe
ziNDLbL8U#im$u4&+2tdzk{c+uQ(K9^cFu{_4pK{w^BjKH!v(Bp>oawF#UpHcq*eGG
z#8Quuk5MuW=Wxh7QM#br8vL(p7ur=(ha*-*R`B~))8Vn0v7wPPISt-L7uaqN<423R
zx-FM5qSMqjd<4&Zr_bxGwY8$dei3pWH%;{;!Z_ZiVSvP#w+?t#ymeq44TlJoLoeK0
zkV+R{uMRryMV`?_v%4%OLhC#iP*dIlnIIL#mdFm)*Ek)$N47{vGjn(sCnyC(?^fV1
z8zu1dV)WC5i&XQtFo|G4jes^8#nDQOytBYrlCApqPUwMe!^g&PqL3RB<2h6xd_cN4
z1$Lnh!9WxhJoq8h-zt+hCGPJNX+?+~$peXQ46E1#R$3(6+nWBsOl#oNR9z`Eh~*on
zZ3}QQH_IGKNCKy~{)*VAvPgwr2zB`$x=+`NDdLzUoo^>wBg@4~68MdWH3sw>Ss_{b
zK0h1P??$Q~Q>))rs)AfSGeV+F%%UaYuN{z}Aap<kCmubIRr{#7S!x~1qMyJ+zEi2k
zJFL&+u!GV!(X~vR$R{5{t-5bOdw+Ma>NAQMKS^1(ioiZD4w`bf8YniNzMqG)Y=<uF
zZd%HY^&&Qi_^O>SWhYvwt@Qk%*?ElD;GNW6J#bcLVsWo<=Qs;iX^JB=b!$;Vdq_Su
zJ8bBhG;8;Zt67(H>B~aIHaqFLAOS(``e^)YnyuRp*Hyari~T!Z`i3=E<8_qT7Jrdv
zZtqu$fXdtpR**Q=ez{^^SsQD7gY)5mKh7F;wQvTKpOD2edjb$-u<BNCYkZW26V@&w
z|EbiO!_YPMwUv1fBY%zvcO9gXgg~FHG++Ejca8IiAD=DCJa93x4llb9A2Xv4Wfp7J
z=XXId)xdV+k8}1j>50&%{U9bzXdJ4Jo;Yd`fByIETZd2IG+B?NV|~eHv$6Cy)ea7;
zqDzkTrhhULhg>v!Xch+0Y>Eq?Go$Vuydd!!R1vv_>9F!a9wqLj$a%={2`%2Uc8%yQ
zuoorZr<i%mW~uayAc9eCp)$Phwxb4FEif@Zmm|hc?jzkOeM!=kX=q<=I}A5y9)-^i
zzakpmL%NNhf*+lyDw&ihm~XxK?nEmrlEI#eu*CoC5NW$)Y4EPg5C|fh-3An!Nt1nr
znWAQn3p<sQSENusHr1PBONHwOoAG2gQ6N;rA>1PIlA2zG1W*VOnrgKrIeE+jsHTk`
zr~2{z<=b7(<&sZ^>VIEDP(QqeDjTn-a1VzmkS5mHw`$375{3FgYu@u)S}mlyrRC3a
z8F<C3W=Kvm<vbGN<PZ<-PISr;j7!nK+kbhJ^nHdU?CDGvoL->6MN5%Rde!rpI>7v|
z$UT1C)%LiPMNBN^{-7=2yp6L9YLJmxd+cPQ{L;@xJl-n5oroyH@LyRfwlu?^q=2wo
ztO5LN5*M=$D-?co;OUy*+-$<6q3D<S*fY5kkr(^8YyI;>%FB}3<?b`$JRX%6P^Mz~
zG?s=+`2<W=Zkt?JD}4l#wggiL)W&S1xUd1)o4FL=`|(`^)K}64_k=wdp-1AsX$OkE
zEB5UT31#_%<94+lgD09@ogS;-W8`oqimK*fc`N>5eKY#w+qLB=0dIc?xmuanFi=3R
zCO$%-#YciDBJ^YbZ)eogkvfM3?s#E9YBq2TGdh>@9O;C3Vbt#3>|klEhg3xmhvD#v
zMXwOOuJl**q|OAJ41@dueWPIqR#^<uMeg$XPdd=6es)N&%M)+AzM1o|Xx}h?X`s6s
z7#L7?YR-93U|l$l%G6(N=4t+R2ZNxH9XkBif;G3oZ<&C-ko=3H(L)%ylyeqA+6Wd<
zcMf*4IaD_9?el)&8~B;BF=c~!%#b}lmh6OmW|F_eNz^n4DX?b_e7pRE`#FLup61=A
zJke5}Xc)giM>+V1zE3m))So1NrWdztko?90M(m}%fxzrnt3y5QFpFN>;Bj*YI(Y8y
zB_^x*4qM!3asD9od+g_OCAhIA;f}m%zPdrX#(LF{g>ANT&a8Hv>PGMC!2F(Pxw7TR
z;U+*SV@i)th*z~OdOrg(!_a-Nqgyq~a}V6I*TigU`D}51w)BdZ*Frca&@HAHe~)!j
z(>{aJ8>bJI_S?Ed2O^S|DTm8YqSs^xZUS8MjhibvV-<2#o+Q<LQ-`4qu<c3Ev(8UH
z^UMwgCc7XB4|nJ{oyL33HY-=epbtP?QfVewQX`3w7-r~-iL^3M?Qw-z99>~j$)bN%
zI6;R=&cws3k@SPo3l}@$0`CLr0eunXqZ*_Foz|^Hya0>tnKFrtU$gwYp&)h9YG{lU
zn75e@?u-f!ff=FdOrFBoVR%sT2!K}m8uR4YpC^SwO<*~PnkJ!i-v!h>Pm$tLb6P>g
zz?o9((o4?p!^q}&4ew@Dn}Sa+zH3i3-w~QGq{}t887_>7geWa$za*TB26hILgst)`
zT004FMR$Tw=N%od35)X-#;<Lms%`G4^wweIc!<Bl64sdaE`9su?D1s}d4i%_CAPlw
zeY;BbkJm&?w5I$O194r{!yiI~mAsIo<m}?M;m~U=0q&{L-z3-5?@1G-%U?22bO?mh
z9Hq13%0C+-%w^sJ1ZG*8UrHlisPeZcr#CXdqH=kde>i-ck}LPNtYW_?lYU?^pv=sg
z_R{VEg$TH*`=3XynAn`0bT{Lr3tt&MtP7J|Vf?zJ5cl)7C?bC@H;^t;uPvLk6%<?`
z-||(9O3wRNKJ7r={{|$qg0x-zKvX*VLu@a-F8xO}ei#5HHuQip5q_2WR*58wNusPr
zZ@}<&?udL}`^&Z_qJ|r77GY0B7|sV`%%zDFuBqkwr$8))s*9RsR?n!@KRJUWJ~4hw
zno5)-9Z9Z-yE`qv>8Jy+^r{cVo0~hFgU!&Msh;iG;M;k&E-yN)brVMz^m*c;)ySm2
zFn-7wOnYx(ig!vWV%ry{g>lTV`3_<*=FumpBsO!?E5Iv9l6i1oC}P4{VKc%`u73$1
z0m_STb}C5EY-YH^-_1_({VFD3BDWBwjB!)^9NfEKBadL^PrKkBO-BbT?^Mg{k=*i+
zGOrJdxroi5)5~r@^fKt3U0Ps1yRv4Op;hdK3W$IbN<Y-uCRcR`4_7Ha<EHJ70HM{0
znxB-WKa%qN@s_#JwClUsx+4Ajq&OboY-R*GhoGIfN9u5Bv3#ZECM!_<V03Al37LX?
zOd)p0S2_i?d}~%-nmCW{wK!eXBIJJ*60|z>C&T4|7|~(R*imLG7oWrA&UN&6_ih$!
zNvx(;?&Gg``8VS*I_BUW9VG(0^ek)W9#okjNxi1&pFj1dn{Cp+u56QhUPa%bl&A<E
z;EuA;jWx(iGl2PHKfDY#>fdLB?OL1q-dI-ggee06P+C5=kMXL$*8hNmwHrIhQht$I
zUPhq<ept}uKjdA@7(-jbr)lBol(>oE?}@EvHxoYBm9aea$I6SkhAODl&qdtTTpc#i
zrc>@lXoob&BvtsSs<{IPyr8K8lP|MhL7xI081}FpkLyYfB@%W;1l1!zkzcxe{W<6J
zUijK`@8`WUhSfKAh@QK5cA^U?rcA#xWm>pDb~039pScBrWiJJp64);K94D15Mv@2X
z(R=QLC$b<wj3v%6bF;F8P<^;os@{xgR5I_rg~L*j=MZ^&pQ;>!s%4{Sm05Y174wSQ
zOcty=5@?goBoA4?^o)u61{J)MTtr(4S8kvii@^%AuSDAQHu`JriRoHceD;^aVD~{W
z^D)`!{tbaxg`&hg5A<NZgtOhB3)6_OuW^4ZVeAZd<I~iW9<>cvg-^&|pg(<jyqq#K
z&+m5svy#bw^J;-@WKOshl=*+N0Et;D!Ec~!rwD=AgnGpiJCE!Ri*2uL@QP=8yk>ro
zt5A8`A}hy-V~PWb0Zs{!7$Cd<fnG>KM@%O5QC~v2BtimRFTn7c^-A~W1nIvtO(ouC
z^JGOjoFr9|tgF66Jcaps+xg8I+kTB1!6(H#(gAup<dtFGZEJ<-({Jl8ZNW+$hE2Gj
zeC39B?E}DNStNE$_Tqejepak2`Arz}Zj}r~6HTqjRCXDXsZBTw4D*dwu-IJ<6w5G(
zI51x*()=9y$Ge#L+gpoL3y<H7^R7tlh<jyP6Sl$@iJugze&#%^7u{sR7W$!&1%YBF
zi)uhII^I77A@x}~nAc?N?;DNS6c7AmXObdsR>eK27r(+DbX04rGA~#2xwVne=fL3j
zhmFo1BlBVN*<9QCNklA-95Q!I$Ob-Tv3sKhr0M-yMn(7t4j-(;G1w}Q^{Odxp=Zad
zQ>(NuwV>fc1bC_1Oxgc3%CqtfFThI~2FQ*;c11%Nwd$Wzh2szdk?nmrj(<g@)riFg
zQNBhdy#@MEd_=0}%42f};Vr3fQL`oE?k7VM_Gs;;XzUxB0)aE<pyQ0E@cy!guOHh2
zxqk~-+$mAJBh13jgiNT`7h^U!*nRXB$%Af+@_)B3UUZ}<#!o&p2Yt=Kp({X<Y19<)
z`(K$2L{6Z=H=I@OrUm}qqeGpZuM5>X>N!l$*f;UUp^_iM2GwXQHThmg!!#;>!3|PF
z#@6Jpwb-;ta<kJvW|Q}m)_k4)%dr}&>KptE{fsIo%3l#FOL<P(Lhr3AFBEoA8gCbv
z!hjdS1^zdux(F;DG<kv{R?ul++raRz#*(EU!WrK(#&MHMi&<d@IM2qdIQK7+cbf(*
zzf|@UVU{-#E>X2j$kAp%7>H&xvBmz9Inmz|`N?6xW&;>=X9^11MiUgcAUy1F6?FM|
zqr6tXt5n5Sk+)cGr!>wx4wHo~z4d5kZP!?D48isXHn3iY)yksh`;d=hvY<QMGIPo&
z?)k<~)v8N`e6tP#@ep36`6%S($zRT6xq9CCd#wz&QX^$AhnbL3Voa%PWg3v6fygSf
zn?6havT~~;EPaI~qiCAYGN@^P=r+y|zF3AGWP`WMFSFugduhTfh=JdS#rnw2tU-xS
zY1V0O{|nmfA2%GukFaYlRsTMSDN@G_#XOFFjIZy=7hiQe@SigUaY2;_GKl2kb^?qF
zW)ddyl}dmi<FB=q0OHBROy_Z*3P<cE@h)++3RV+YW#oN-iV*)vCiVU@faO94Hk%1K
zNg4n{<q3hlpRe?HZ;LrDRRRdL0L%XSXR%&D=xU8U;0?^Si2oV^SLfwW7aT!K;_Mls
zcz68bz)`}dj(ZR8Ji9FnKU%v;y7ef$izN#>`mUUOs5{D(46u3gT7B)bK>GX36l}y(
zC#|LUdzO~P<a><_b)+<Mq?OXNZuUPu4;rYu?q-#=x>=+u#LjWgl!7!xUnOJR(;Q|;
z6v)pVEA2=5fi`#90CKF-&ll8Sjg)hEued*UU93Sim^Km0@x861S&4SYXdD6&^xcJM
z*z0LWdd`A*6@GDmCZrg5Ma+c6?>lAG%e`{1xDLZMZ`i?Gw1vki<J^aqM*x$7`T*Bc
z4i~10tl2*7Gx)d_>paenXmHBu>2z%nrI@bXlQ;JWLJveLBo_l`t{OCakNglBeA6{D
z!`TbL$B7&;3!?=z%tpBL>2;vk*9eKI*3iBZo(QKjYk>aBW`$cKu3t09?F9N`;Vd5%
z#rzeJ5=CDb44~LR@5$pYElVDWF{4ALdw{Mt|9nXq<HqhsH;F=GMu87!YIyq?u_t~g
zQaMN{y*8_On-;a%5Z&G5Sy*d0c5DW9A6|M`DEYEsk4^fhVDK_W^V$IQ<)y31R3<R`
zNqcwq35pla^T!k_XDq#?q3E?3w>P$Xs=lyR^+T5uIMcbZ3GJuspR-vqxGB=V-4VaY
zqrS0L;%!q&e6LyX(a@D)Bl`ycT{AIUc*=bI0l>$Eecvwgmc9FE0%7yR@NSh94*-dK
zWek1tm;Tk(8je_U%Fpn>+5Ax59U~?H<iR1MxEtX{W@7j0{e0tJz&v@DyVBwI3p=6s
z<AY6M<8qxd=L0%4<=o(+xt~b>h3U$~21)+GYIoe-i$bFby%z{1IicT`;-N8&goH#7
zvDUmucIIfK*csxR@YJtx{0N+b)th*)MqP=m6m8%4>Dp2b1ps-1=d@o1yg=yE37^+6
z3#i^y%@3x7zK|FL)DOe3X#->}m2m`K-ZGZF#C5`YP(o*f1T@a5&M>#<@H&LC|A?HD
zC$+7)=^7+LSZ^#P@FOz>0nBbVoDbJ+-)t|#ayR_}5Tgg+1q^9PAwM>oW7mjrjh|5#
zTS{hy{Cd$Md{=^<$4rF)3eTx!NVWE}#D#NQiN+(8P^1;*u={_Fy+%<&JFT`vr*q9B
z9Wf+j3`!g_vDX89q_Xl<-lJ~4^<;=eimuC&$|h%udEO7@W;yu?z)KRwq#oC#OMV~y
z2P7%Ml<R_Y74ShZT2<`9H#=YuR&Z4?!?!$0vIClUJp>SX8FSA$M`eU(DM{I!({R{e
z$U*oP(;)Vc*lC;}Uybe~qmjzKvZ2`a;Z%opiR|9r4kX0%>mbHjfH6y$il#44yXI6d
zG|;x3i%@<6IOWNgt~IH8G~>Iabbxt<#KM|jN%Br2TvKwGz3Fck?Lkf)x0tUK^Nl+w
z>Yo^g=tkbh(eF#V`56-{;VQ)aHlWW5s>g+tP&>Q`UoHMFlKAniKn%Q9`AQn{i@pud
z<xp>3t{Z#0k^CQs!g8WC=B|@=kC`atwKV<U%YyyMvf6V#0KG7M?IIljs!c<w(FQ)z
zPGsy>rXgoEjP@|P0ekcFBd2r}(v(vn(6hxHKB+m+J99^MgWpilA1Qxv{WuE!t#tp>
z4ktbgO6<?sGBI?IeH%l%GR5TGcCm2F+bgOKQkXTVE7G1X+uyJ|dZT<ghELX0oms6h
za()paX9busI{7ettR}ca`p7nN9rZLXSV1AqmY@Crke51!9bYMXhs-i4#RqVw{$xL;
zGq6j?a0>ou@P}KTR9oXX0Gt(wxo6m^ALsc(Q9M>klJo&3Y$o*KQDf`k{GFp;h8Fm7
zgd(Lx0Q$i*lakfb8`$~#I;%;Lqnh?Z@ih~2uRokBvQ2Up>ImJ6%URK4b26~C=#mp@
zDSPn+`uWBSAz?9h_+3+^&on<yW08eHix03x7{i^K!m97_3tLr=g&B8JAW6kMdM(r;
zT;&)&h!k~SVeUzrx@;1T^d9j{Eq`lFJ#<wd2yli9MOXxa+3X^*7Q*@q=}(`!Ms#gZ
ze-WoI!UnV>U4xNmnmg)WRqx**BXVuu6$64{4N>&UV~Q6Jj5T@Fva^9f)KsdZjZt}+
z8PU^~KKCVAKY|l9-w5M3%t`&kl&6$es1*P6TUsfdclP13j`?LBCZP?2G7=%@kz8S$
z)f7MynC<UT-{Z?MC4ByE$hiACK_hu*0;D1rl4o|hKTByN4$NZA0J9i-e@~E5YaWOw
z6V+IqKkD39o)%nN%pTx>;Y^}<{Be}^C`qLak7hnl9q<4<OvrZ}R%zk+wnv%$!K~N=
zXpS};b5yr*p$i86wc~F?h4;YY<U$T?X7+gH-_yYTAKu>jt*S5D9+qwpknZkoDUpyy
zknTKmmo%t!he#Yy8l)Sf4j>H&q&uX$Tj0A7pL^fu{sk|;@jS5iUTe)Y=a^%TwdU}L
zJ7;x*tuvyOwwNgI4>Zy-`p}+H@-{4<j05)8E-^2TIzGK~i$t58)Dway_y*oxmYHz_
z=ra(hzvCY3D;CT|pIa%``go_hCtp)1x$`C=TSRn09u1e%wD)A+%`M=YkyZ(Pv<~>w
zpswj>!xe0xoNDMQ3^2Q2#E}2d@6Twzh0m5rSLlz)B^l$^xyL6}2_)cU7FA!fu6aGf
z&ay<hNo9HwEVL@`JAj$2O}N=d`-fbdWX)Tyev`k70A;X94$wCgxc=Ll0LZm~l9Z0L
zOLRTJzp$|EqoiA4j#AkCT;a8tZKjs^)})(tySinWbp7d33@|4w*r()({=K5;{}NAY
zdGBA%71Dy*6k^-G0zIqG(<*=y*Ndo$R!~b<b`}|c)%ZvLh~gq=J{MA!<<|m6fw|93
zNzG}ETUtxUFG)~>&7N906wZM$g&F6M!CgjO)QDMfBOOhLoE34dW3Aumi5m#a&Dt{K
zq33#M@wNC7x6Y!%c@yXl*Wdhhy3$uiX8Xlq?Z>I@m(AH<m5NSxNJ?uyE*-#1vyBQ$
z#Z0Dtu;M@8)SeeAS025xFI@Pz5~YBxmEI9i<kpTJs&=I$dro$_usr(qkJsC00}h9(
z5dXXkyfb&!O}#v0S5n~;iru6&>g~^7gUg|pm>}{X_p6F+TJK)`0Mv==#D&`Mzz8lp
z5uIXW<-Jd-|3b@Dq&Kwac~W=#RM_^6Dgn0FxXa6Cl;po{Hcd?qD3}P}b2j_h|L7@`
zGY}eGpGRJ!?f&cRAJX4Uh?-`qn|XvGvv0Z=!7xl5NHK)JKy8R=X>Hgxc!}Ax-d|=o
zBzs)<4u?)zjY*Oy0_+~T7c9E)GF9x2AYnvGqZD%O(0vPcK!1R2+Z)8O5Q}O9>Yvih
z<1nlONTN`8oTu^SGV9%_8>3|kz{tAdA|}cdGtVU~5nt}H?qWhbUT84^jv9F*c(=PU
zw|z<w(GUyoFolrjO}D7XUz}#J>N-34Y<BvGx2b1;t~(S?Qwyoiv5Cy=+J=kX7QO<w
zQXGRXY)MH=OG*XKE;UsDZSdwPvCst26cVPB;#GbVJ1zHx308^Gj@xhoh(1Skr~pu0
zrMex25q+pyVfB8+Dc>;tPESu(xzYsx(SEuxE@qFpGM|s)b|nI8qeO?EhL);9`2<oQ
zac+4!hed#9t@HoHG_j*^Sh-$)x#w}bkrfj*m;F66NTno9DUh+p&R!H^538W7D_$dF
z^X!L)wnd}5wIuHtnp)&d(|$2{wnN2xI6tx}UdYEhZGRQfQ-*ebXGzp|pJYCo7CpvT
zp8edp<1{alnpC^Za<6v3NjXF#!CxbI)sz@Zc4anyiYxhYfRBa4;K8>!HeuyX(|TL~
zO*3XoZ3b0dqi)u5246E!thDt@;T!SovPv1^g~^C=S&ISMY@sA!1{khDBkM>EeuYdO
z*@=_~QBv}5P+!iUOC$Qghq16Ph1+)`+vH&Wk}tsvxVf(#0$HR^lt7r0(JS#b5j&)}
zY#WxV?*JMT4GV-23=||&ybxGNd<S)FwXruriSo@aX2*)JaLaGnV5ld3h%3Y>#tw_V
zX}EZ^T`=J0+|t8j)fv}FiW<09q^VX#CV(i^(uJ~14#wdcCf>5^Asyf<7~B%kUxDVw
zY!ffem)7UQf-#2wt2c)pK;LT}6*Y=kOb_K8aN!ly(Zw#TJEE=w+)BnJI69eBg}6h=
zk4$`%qC5M39-%KtMzrKjlTa?3M}f-x8CaO8Aek`r2QQFtt%2Ei-)TBaGpj%7ov=zt
zGw_AAQmRWnF^FJ2YllDtLeEv_=3kPEYIzy7J=MTMR?FubVwO2;`o+s?KHGAv2;tgu
z3N;j~e{{bnQ5KiAB1!ls6Q~-2hk_N1Xl+Fe$|XfH>)b1xyG3*?HT&oil@<N5@!HZP
z{;s3Whtd={;z9-YL!T=oXjt(J@9l~ch(>%xQiu1Z0PVmy*kKy~Co%mc2=JwrFkk<T
zl+ZcHP=f!U`S^nt!KZA6Cl&^3rt}8cg|{{6#AfrJSG;RHb1iBAP(ET^V14n%Etj@p
z3E^Z?7JMXO-@Pj4r@UiMk!pftJw%-g?wuJ5_>}E_>jX(zQjg<5j`|n+l_B8cMcPL$
zn=jz#G_1qhF9fh}17(&5pw0E=Gg!*Mni<PJ0Pg=M37ry(8YDyYe$I^xFj4YOORK;y
zzbAYZ$UV^TWaV;dK<W=EwEb#EE_f>>=F&<fkzM)IPEn73GeT}crvxQS_AMnXh1ehm
zirhz=U+$do%D<hu)abrmQ}a+?VaNa;4W=>D8Pm~D1J)K_i^i%cnt8)%aPvE;O)Q~J
zHW#M;ZGBe%CJ6%IlPTVYEky}4TIfB?6VE|&eaTOBlACY~8&pEtU!i6qQb`{=Pcrqa
z?OpFpsBKGU8ahhgZummt)_WzKWyidso28G*Ejb6y^O|~cv`g`}-Tq>JfO6%Ekz<W+
z@a8j2O`9=<3#pK+M@~VLD{oC~<BR-1vS0w+6bUdPWRgs!z8@8k<CuB%LG1<{oCmis
z<D?a5v6}BysABzY-|yY~hY0G$_{=-ZQzY7L^W9ey8F+a8)yjY$m~f)8BcHdpz9)N@
zi<HaZLx^j$|0`V#;m^S|2-A?4fF_GY3-8(7k>-6b@j1x4JS74J!hxy)Tbg92?sw%g
z;q}7W+?q^RR}vd4C*cc`^$Pcjmls)+xSs+GM}iH~B`)A5KshxO^XHt=&CmIz!*6xw
z1t5NE(Wl#t5Ap%;()d~BSAQtNnq~_lL-&L!cI-6o;cv<TT(47eI2C+&goCA;_mlM=
zpL^*wsu%wVnnlxY!Z(#nXmgjk1~2)fU85xPaq@H`sO_zwNsFl{rg_;jBVflb1>aJs
zLX*71BJ1O1aY6M0D21#7x)?VWyeZo(C_!^d0}@cFN7K>ZG|9L$JXfaB#NnM6{AqCh
zcWcQpv!Vx@@rP2qR7Vz$u)6ND98ggjN~zOWHrZ<66`ey)l~giA0S-dVJ~{Q|b=UW2
zZ;TR_<6y06pb%CXtM9`^rWV;pYHSVHwy6$Fjq<<<4(6H$h>H%BZX5y@JKsZ!R5EiL
zDyf=MmA*N}?q1NeeOnmXKk$V%f8t$*8lx`EB3(*=Fn#(fbRb(hgb{1-VBTIBouw?G
zALRlQFGV73(A64e1JtNZ_7UQR(0*tPuRV|+u{h#@0WyS9gL4Q_rG&~TAU0Uzmt3IK
zQ-mMrGbSE5Ec(sXZG+jkZCj2fq|joY$XPAB3YZJz>Vvqy-@}5(s2mve-)wP141WiY
z-DZIeQRKKXe@oa2{nsSkXA<fb5++w4Z!<!lms;z#lAy=zOiU=0x3bZO=~q#}U-w!K
z^9|Z0PN^3slz+!UHxv5M{m-8-*yk6POPL<mfXy?CDX5D<B+9r<*%t=XFZ-K0JA{#-
zePh({v`c@Ox?n~)@X`a&G%oj5Zqcd37p5^HtVaq}SZQ*2;{`xHQEn}P^lI;9FY8Tt
zb{X4_6;N{gW`?N^&^6mTacWWS70tZhsG1V>LnX!NAR9FgST<ZODzt{{JLC^r5PUaW
zuXUXji|W(2Uuu(okXnA#<Jx#%o67g&@Id1)h77bv@8!JsaHu|r{3#buq`=NXbnx#p
zJZlJ3#~bK{N2@+!Ep1|S8yiP~fXKfTteBUP`=9m!(EN2({&x~$#NtCZ7ks@azvgUq
zNYE@$?9rEF;j@n<d=L_WHVY&`PH5h^G#Ztz#>$SwEqu(NJZpk^0S)LIKw;%C$07ve
zC;I%+GEqx8o?XhmLwqnN%{amU@ntOUJ$L#?*6Gi57GV|3T^(;WS}!Bd);+Hi#sP?(
zMOLAL%!1ZX7B+>7Un}`qJ3uB8ylFq5hh+d0oI8fQG?<+#0-1cb@p6p`{m&_ckZig7
zF>hRv8TeWc_f^F1+;|fXL^Mi-gN8!;rtf+~^(lau-27TU*S(^u&P?rnCZ9X}ku`wr
z7|Xka2wT<#?O47w!=NEkrwFrl%bFxeq>;4#%=ndPBs-DkqjKoY{RmV*=hL6rfMWkp
zrrTQeAz9nKDzz6am06?*_S0@0bmr$dK>F^E<+o6e$9JHQR0i;TodB|T1p$u*HF&)d
z?yeF}Y_I96`ZnW06lr(Ky}Avg?SD<kv+NsEoUq6Nu`f*hA4=~($zJe_2*F-)#1|k>
z+>|j*=qmi?E3_c&;aAM@?^)C`U~FqJ#(P0PM|u3A&oWs%1dtVL5U_jWvUsa=K0Q+n
zG#0^ldGqI*+!Mu{HMFNGdWtqGP3B|(+<`V5*3K(jkWRewcbH@~1Of>wAoRKW?6#f3
zQILhJ%EPYuBYtgT72dQ_KE<56s#Luk&Z-p#SW2c2U&isW-`z~TrMqmX+zb1aWjiXe
zZRkWUVa4~OR7LraQvQ|TkZe{uP-Fod&tHZO+DRK5oYsN6McYYMV!>xwLkX`f9BOh&
zN+U479+mYkonO=);Rp&RY77Mdu92rdXxR5}v<y^4=anL!XhuD~uIV(Z=K19t;7Rc>
zKS?rsSIlLPRYa_fQJRtaDSp<gd^5|A=V{5^HL9%tzVR;0c-zqZf6g7GD2?cI4!!N}
zE<Kf{1sn%*dd%8>_gR=x=^HCzi)oE#=`}qGRvp0nS5`;(spumWZo)qD1*h$8c^TuP
z;(uk}#V>|oQ}9(M^lb&x`I~NQNZr#7fT@DrMe-zhlo&2JYPD%Hio$bX3QEi_M3}fK
zWt;;yEbS7{aFBWc$n4~YB;~zKg}taKQ<K;JM{6#wjtwZT0N2+{F5l{us&QMQHw4V)
zQG|n|rheySj#s4s5vdl>@_%KM$OIl{?TL>jg{dTR<)0>MWOGS5WSeGpjNddzDt7bn
z10}?k)6%ZIi_}|2j&EdACy9DWbrc9p^?ds<?iNeHfZi9wTx_xnIMlPQ>H?djX-C{R
z!F{y6;-s-M9aH@V`N<GmNW7y{s8xy!5Xpd&lC4n61E6MHGrQn?r#%<PfUP9Na|nA}
zg|U``W@A;Ptv}U)AY~)ZeAN!Dwu5HIp1}W;BcBL|tR7wCoG22gP`KpGWiii;OB1F8
zIE75WKi()!3MSd#cFU8fTTnnun2uHP11!D9{y{}ZnwiHIZAj&HXffUAP8XYam*(g1
z*o{LZx1Gl4lrnEsN=jwN3k4%P*m+QyXbd{X!rVT&_=}j{%1<yS)@<l|lHbGZ2?!3?
zp3SIVF)3?UpY_y`UcZ<jVmCduQG=6;^!b3#Y4O}xb`i_BImUAM>DHBDfbtYxIgzNy
zZSgmQrAfbC)cg7>331h{#I`vuW<~(AHo<o6PZ_~XmW&c{lsO-bD!{30F#=n>So`|T
zj{UTfONm}-uz+(S^9DO)ue<Aii*qGY-N7)4SyBw2U32S?Axr}xi3htQsR-35Rd<zX
zF$3jQL(A#&9C2uU3@;@h1>%mT<Q*;68p~*x=T};w0Xu%g`8J`F3j1&zEjU0U?EUA%
zqwTc2&l_#h-q*wp0I6$bH1AYxV#94u5Y?L_Za_Mfnz->A7BW7R-qVoV00O@G^ZG(A
zJO&Y*Dqr+do}uQcXLX4ied@Xnna;Wq4;tnuJ>KB3KFsmF@vrV^21suB?sdVG6_`3%
z|M%HpI10<R4$>=h{fXY+K#iK&n$$Q5K7b+6Kr5>j5UZ~f9J5FS)}xkG)Y$(SEF(bC
zB6SHqJ)RSfpMo>VsQdDD(tm6||56&+@#-)Orm%fCJAHL+*=9xa;T=1V<CX@Xs?(;(
zeRx7Lol;dQPU1e>mvKyO$Q#~)XarBQTd1)tQ}EJKL|zVO6Y36>0A3&)0>c&#=XIYj
z+hXkYS|ZxZZGn(U1iw#abRV#n2EZ21z}GJPRc-2y1ZbSV^!w9J&IM4vH=(zSI?~kW
zTQ3}WM47ACuK36Eoh$N6YJ_TKA)?dZpEI{?&4o_Yp5TOizS0EwSszqPtVtNzG^HUE
ze%D0KH};LOWoA4V@_LX&tz&~1^(q}{#?8Y4&WCXatXBKUAxXO{!8d?9l*6TB?t9Uo
zmS)7rrw%~%$U9#p80+TKS*3F_{V<@UD2h;&VWda=j;h+P>(CI)4;+B_T~_ozuIDWL
z=Tf>1EnqDA%uQ7Ejti6Y1(#mdcpKwb&ULh_t2SJ;(L0mX7$kQxep&3O!r(%Q6GQwp
zg~3guT4RZ`nXpWz4faVF8#Oj39+=btpz{>Hfiq1s{9-Hh@@4n5iM)8aqdUKx;k}9L
zfrJ$s6QzOgXE{9}evD4r+^2`V7}T54^Aaj>95o-?F;YOl#`az?;s~B}y!s)WJ}Hyh
zP2OW>0I#6K^_X(P*mxX}w@7s=*!q2`9roRW`2;~No+a7*MQMONoMyw@Zvf0$2t}2*
z<tL!Xzf6|dHqQk}upXdJgp8dK58%GE+i;8-w<NILGUlc!Q2Q}o9%-oR^!l^jqW?`?
zL2u5f^l2f!dA-|_uFW__W1cXlt7`U5KYzDzc2d{VHT}X{DANBu<8gcOZf*$3%z`5s
z%V}$!qGizJ%&rk{wYGZJ6k^?R|F2p<mCg4Nah}AcIMeoVFx^H}f@^8CF5OX!lv>K8
z#qZN9!)u4xL(wOL-<1ur^1BFym8#;Z1?++cn@pEIkBkbo@4id`$v)y0LCXvzD>|7K
z3$=N&jL1!t0AR)|Bgz5*tYrW%JzT*Y!xCjn3f+9GIP{Ve7EiUd4ZXyL|MHFbY%MA4
z&Q^j45}OkLR}1j<p^eODJ7UjdtVH@<!tcgMov&|=>1&oe8U78_eXG>;Pb_9h!Kea`
z^tAS|{!{_np}KcqWKAuMcN^FQ23>b0OKZihT}jN$#TUN|b5_h7{M^8ql&(uTAcz@w
z!(FEfX<_p@gOU|HBDw~{4p-<C5AL1<nSY=Nd~b-|`i1K&V}NTaw5O)4DvpzWd6s^Y
zGUy4UE!6+!%ZPZFpTRwVBjnOAQx<kuj?*rqhBE*m5KLPdrbD*d5&^a^>^&!f0_uGg
zZ<e^kKR_0wvBJId_?55W?+MF7reLiCe}-&Djkel&;pO%Bl^=Dv5(fkWo_Uk0iW3O!
z(jd1V>_YpSd_AM|`Z~6pasa|?m4X-npZ~WAp$|?{;OA71ApkKH?TzWtiQ}hi)YtTU
zPpbet`tdbBW?yBhTb?=)TQjygalcF5<ogJ9=4_2PG&!st70>CpKj9-*j^}hs*#8sx
z8G1daH-Dp5OU+oBA)r|HP$Ue{-Kb1ymnqfHnLZFh5M%h+mz81Sgvy<NCjj#etD3b=
z%gewda{j~PUd-FXgaQA4x^vFZe%vg3LllX6U?PB@TBQ(<l~7Mf@^Z;+PQCaKV%p<V
zYs6)`1t1frHhpCWE33e;B@9ICcbzgDq}P4f<adcxD2;eH0rsg`tmHDknmT7KEaIts
zau11(v7@R58vwtG%!sACASduRvUaRiExb+_tfhejCKfLtS0*Yy+E4^;ffgTJ*IEl_
z(w!i^fT)NShMPtS+EbhqAk~1%j#bjByBP#z*Y4FoF40KN{5|6`YVw*39ylBpyxDT<
z6|M}VXSMYRv6UHfFFErn%eVnh0aSQh{sz4a7_4JKq{s6@A+_$-3R*#)?W~*o=^^2`
zaL@*ol+1TA7P064Zs%2LJ4zs7#r{0ZY|3G7SUN_-gs^`Gu{iv~!0(c!P}=`6rkXSK
zg6CK7x@N>fvBCCV+SRw*qCd_9w9in0I0mgxnD207oCgjn6mat!U!X4kSeM&xe}hPk
zR3o3yib(D>jlY}+MgocJ+yL?P-(VRLcW?ZH%d;o|(a>}n;}#2LU>np%d-ViBa8JqA
zH{JFzJg{;t%ONIEt;O%Xh3&;<dHO<&he18!gVC`)-U(33<e3<)k!lgPf=tHEb>&j=
zZEMz2fQ%)!U#^1_@X+L-VDA-k@wy_E_-AZRUz9i7`j(UZnI$t{y>CZV<vx&n6Z&ri
zMy&z|1A$_@P>3jyur}B0^@z<A2mV01IhjEF@~cCEty7e~n@(9@aziIGXkb;~-_4}i
z_py#U+c8Se%qz#CaZ9yT*IJM!V`~+Q<(1$<>r%x-G=1{D-~*8&+U_qm)54KhncsH@
zg%A?~_Z4nH<Zt;xdnhafMlQ@z{=q^Oo;g_QODNr;Ga;FZT5g0vw8-(H;_`@NTDNCp
z4T%JapPrUNt+duF+HjOJy#ox9J$P)bY`Uv6=a*N!DeAE$nZ|6t%yQtteZdM~`68Q}
zbg}j&WCUGZVc<hqhjAn5>CVH2`?g*F%NlLs3Et)zPHi@uKS{5JNL^9U<nxhIZE$SH
zGkpde3yTUp4x}Nsp3Q#NQ39|lDF#lTY|7XI7m)q~utt^oI%ih(QC$Rca?hb>2Y8c@
z46XB@lI|l8`!C`DsQkPsnXL5+0{(et|Afj3*1XZRe1~L-|I!LWVfGp^^7Us2w6JvC
z%PBYyO$SdI*>@BkG7Vn>2B3^D(cmzt`&r?TXb${l5oi>y-IpbQ!lUIUA61-Bei*uZ
z@V86y_*r@1PoGus;kwzmHS8&K>94_y@0dgG51GtE>Fc8KC`gRiq-hM}hFdppVk$#7
zMI<K*#Es6Sl5OIszMMDzSoA`#L$-?K|1Q#w>!PfieJb9of6z=tON(1beoq_OLrLjS
z)@QcuOqM}Xe%T%ZIU?8=KCYR531KByY4B`1*(_(PU}8JWY0MDm-GGRdcteBm1+I60
z0arrMLI)s_1om|w-~I9I3RZzg#ba_=uU0OrrU!9uwftsb$uB?lb+S;JLw9NPXleCa
zz7uAr=hp`e={ZXh+mr|wIUgI?usG@aNWDp#KH{(@d~GNA4fo1YH+!;iyg;1Cx=qTq
z)kNl(bsP@dqc}U)=DP#)=&rL2nGyy5@IS($NLCGIITrS`BUW)ic-lUb_BsLIw4*6D
zU*bk;vMXayi6|xa|4ICKD8Wb@+8$7dxREj!=&Bd8b#o{DHFkod(kKs9L%!Y@Vym-1
zPML_F!g;t$lw>t*{bD=ZQXt)G9b|%|<WXVvMVv5|Y1{$)A>{4*d83$`($6(AGBrG#
zJKOR%N;ZYJ*fAp34`aj3<=)qw4wX^vi`(OQ$C#!Ho3e2EE!?}2X&jG<^CI9XwpCrl
zkee)fjqgrpj;>+hn+*S)byMYQo2O>r7{34u2YP2fnmQwsbXE~MX#MvakNGIUOIt>v
zyHp5K*BSUY+$u7{lGT4>_{7{XPVKVcAsBu1B|KhcXX59TuI9Y6+!tl?N|l3|I)BhZ
z@<32_x!F%uz<Rkh_QSgd5y@tZX{gfdjZ?1U61phJYvU`*izGF9TLXQv(TebV9`=|s
z2~rqnld3&fS921#>U}uXNnKHEMe}u10|!07ZhtM9)V6Sp!|9x3U>|MfXII)YC}o0t
zJL8m=37%`GB%G~t+<y0~uIL^w=I}G$dV@n0e==DB*=j_U*aRmnZVBB)d=Mes6?=S2
z;(_}bX-@jr*ZW6=s5ZYpy5X!WpW41a_X_Co8KMX78z0NpCP#lIofPBE?4lx{I@z)2
z@OBbQaY%R7BTSx;=MiIvAVn~~`B!HR9$J-_%NE@5DaB_#SyGcOu80L${!Cmi_xGtl
zGgsjc(&sVD7b@>ULE3vGe^ILh*q}V1_NQ~YaPf#!kDl}wP;SmZnmerDN9PenI#w(?
zyj_H0n+gF+v%F#-EFNi%bY4G#40Vm)mU14JD8rW#fNh1hdHU>+SEUp61^PNr5AaiU
zUjNgV$#2j99S=^Np6;I;=P%q%%;(d&@!ShSA3!=GB@xNoe+b4k^FfNu7;w`F3$uRR
z;+7o5C#I9H{<T*k2&WE_VY$x*RPktA!-{s|gxtKaYS<my?u9%@8@nmDg1GH%=F{sL
z!%IQUHH6r)N;oj~wND)3YGzD%n_Ax>&&yW3a0(wU+D2b|kVW)gKxjOD$TnX3AyKMU
z<h5`@)9GiVi_P92?6!!ujFllTRIMAnr>Qr{Tg+u8OFI+u>+?)pw-YD^mo+RMDRv<Y
zpEi-P$dHaWtR#HVgRK6LK{=#N+T0zJDB(-(jRSY;FE)0ncBU^)tUr#1RDN)cyT6F{
zcW@nwg(OAQDtT>vvd()n+H0qGnZzvIVYSqgqN$yE6Lv}ly7vIx`;wH?XgoQcRhs_u
z*3EV$qEp_6BFP7%@D7`hStASGE)8FCoib4+tm)HUTEtzOH&8{pN><sLo@vEYwIH15
zKb9!aUoxl^;<h1FK%{bfmQs6LT|ooy8pq?w?z~nn7m%WQ+CJC(+KykwpB3Uht$_fe
zKK#cq;lKVK?{Pro(QoS}ZnK&cH+`MVHQD3^SYd->zffo}?-h?zj|ly`rx&Ct1>SLS
z!+UMG?<2{(;~jZ-1>oM}m)1ftgE*W<>gfNdg+J_N`H%^Cswei_4U1hVU}t*Z5Pn1p
zbLXCfgw&*xla4+4#yLBC3$5r491G8wNiAG`SfOeXqc0Wptrb%30Q{xxm5jw~O|JUY
zEBAl4U@TsP?p-uxNIJyD*t}sS_EZeIpI*+Qk%?(R+zWz0e;ZBL4jW$8HPzl`7~(d;
z-B=OKEFf7BQP(&#Yf#l>CA57?Ox=XODN&mTW~Xnw#57T;z-gp&+hKUBPZBq6PC&B7
z+hCDxMPzSy=cG0ClTrNrD64UvrKG<2z+qTgzrhGt$x}|2(BE~LKy$bmPPkpszC6~I
z`p3+h@z$C<Metc$Oj4#s7iuQTBG{V-xS3n_MsY<a6-4yQ;={_6;@7%@(?;+mGdXd_
zj25MbTwXo!p6fXBE9%|}ntjMi!62R*^%<Y!wih9EpF+vKWdwK|@0{^SI;4rjA|{2b
zdHv?TpL6CVrZo77SZ^4HM`(75WT{_iE?dc~ptrX5`2MzvEPHF)H`<nyUh-~{bvhsw
zkw5Z4i;yd=Ww0n;u=LC`)v7v3S6ip7hZ2$iOt3R%BZ_p5rR>)6rqSCTxmhu=!8zck
zemUZv9JWT=@E0)tkq4O%4>S|v?q*xtt`qqX(FhEFWMXH#%r?`bE&ZyB5$jF{HA_Yg
z19?ryQ_T`zJF?=OmD*DLX&5YeHL=fXVokEZ#aW6m4pFbwY>Ch|CHyGwfN($$&#l_U
zpTVI~^!Uy>rH@S@a+rKu=5K{6L86_jD##?-9#P)HHU3|14r8LGT9Pu_2%kRpS#x#i
ztOO%{QG$n<UBhs0>YPk~q;)&pxAr<Od2Q=vvM)x(f9VZzQ>K`GLm7N(nAzFX=ng5t
zk{d>05gv)B<Vqsq$GoI}P>Q1B>%u)8!SYMZ>50DIG_`3I{$|L4?C=yWl|`K-oUTJb
z`WX}b=}0jdw{N44p~i<3y;uQc+i`<4d6VV}3#ALXEs<Hl@u8L^?j&YvVU_~uIE%RR
z%%YJmme>6tk}zNYi+a<*H&2X=%~-sVsR-fQ=7*>Vk3TKMefzzHdJK)BA!fkqJQ*lO
z-BRZt59ahSM+~#Ri!}-6e=is7cUsMC@o?G>!xwVXK6H<aNkeFt$^)@kgowV)x|2+{
zNk=#+KTBID^Z7<go8=~u$L`fv-Rj)Kn3#T!y&lrB@gXk4Bf}k??x4DLD1mf)U_Znb
z_O^7D*b$4DpQl$C_}x9xm9P<%w4Z)YZC2f>*Is|OpV4Vu<^|pJ_La`)MgzClGSFO&
zs!5{)1Cv*w4Q@M7NB2j|bM=ys<S*2bPfzg1jXlU)sUvqdPPM*rE(sK&9aos)O?nz?
zK`lYBy|)jsMd)0|7AMflvh91s-wqj5Zfq)@5~bUExmD0=pS42au~CJ>lZ~xQWU7+w
z7r6bSOsi#}vFlbwK9w&Tw}G0zRK2c&@#X9Z+eZtqLS5^cU^IMQPA91;ZEQDBZ|%3X
z6mObXhs|S$*s9QrRntjkyb@Wp>MwcxAjYh}k9MZ|IM}WH-xqT7eMqY5tm(shx60q{
z2O#i-q0leM>|Ys?eO7SPhWy$rd+X^Wat=}FqxgQJj^jwuLRQCdvGQ%cI(+H9(<`Jn
z`)GO8ZK9Ye`!mkGKc1}*K0smKf(!gzr<xL1uf9=U<jVuQn|B0%O?GFHwl7D?k;*&T
zSD!}7Pez0{TGN(TOD9CdUzWY=5!uS35-=!C>&;TK)GSg+K@^CL@s@9TO<$VGt|v^-
zKZ-sYzBQG!CWv8S9rNytQ&wgWEP2MdGSm_Ss@fyD#hvbDz8CC0g|tkuD9F67B3^g7
zs_ED?ikM8)$quAo!Wufis_&|id2P}ACmtRr3`AH0?bow|%L8SP9~lMBc&HCK09b1u
z;pWQlYVa429!1(A*<S~$q_1uabhJ2!&M%R|dPDWd7NE`tuI;#2IE1xiFTH!eMR>%!
zG98~G_3HaA7w~_EQsfJFK?@*7+*_80@eyT<c&6-h2feKriLc$=?a2s58kcf`J^LML
z#cfOBN+s81X_?Ib`{3uKh1;VzE|1&)ZzrKZ<QL!{8_ULRsJDh|bLB>~2cuk7Xs^H7
zIL7)R<Z2&USMrQw|Gt3_^Ky;e=xhq_A^+W3sKTZ-e!CzTwt&CbWh~4DA1m^iT_bb(
zw@6x|m)3Hqe3n~w^pM>|Q@W-JS+WH}fDX0<o7crwck0D5ibL$+=kfHVM@=TD4R))i
zs<N+<WCDJ%-^R#T*)|hJBY!P7m08m{u%dnMO~>9*mQUPEmnQSuFOJ>YoBvu?p2|BI
z7+#GF#rZSvL_6p9s4&PGgDw`VnW2`{D-da#3}H`%Hrp-I3F9C!67KwATX6T%h;N$0
zl&?IvD$*x%k}=>|39oHs;B*!dy3vPl(&#}gd-ccCjPh)w7tk_3o-eWUFJ_yiP=wTC
z^a76lT|OFEI_S#U*^lq|ZHCHqMJM}+PorDj_sCOcViP3faBar%MRMWr?0-xxa|=F1
zbe_j^RrIxLVO9z=<>D8PxsOk_lQTj_k!szJrB$tUho-B4t6Defp)BSNK|N&HG55Du
zs^={ax9_kr`+B&<Vr!+WLSN_x`F1p6=q>siY`g@&l~1*uEVCe-p?3@7VJ}^dsc8uo
zPhW3IbmQ%XlZjP~LWN+^gZs0mFO|sXWoEqa0%nb`@bb#O7C1z>zHKh8;7FtW+6=c{
z8&ij7_fi3MI~~F<5P7D_evzlEE4iW0jM;x5r20+Q%+4m8>Aw1jq*~__*M#4g%gJEh
z9QY_cgCkk)NaoVP%Y=ldr6Q(iE*VgVkg5-End!-`FFQ=@(K&GD9lVS=41Pk&ut!v*
z&p2g-s`<ooOi>T&SgGV%UDbONn_2U8UH!<44R$s&MA-qMB|?2jgfXm9<mLl6y-Q@w
z=?5gcYrt5-H)RrLKD1c^hiT!#;oWD$_v6-(BQu{NduI$gUriUvKfFEsfZ-_o&6II(
zqw0-FVBh8)z5rSENl>P43{05mT{?XkvB(cdMsko3X>*1C@Sw|kWREJ#wpc{^$K>cR
z%zRIYGHc*NG<EPx$f<$VZ(#yb8EoR(*mxo+nouLq%M_yaLOSGe^WE{urL5gT=8!lg
z$`Q(u8C=kxuW?D~br03W*NEJBQ9UCeDCY38zaajkP6lC{U*(|YI3iv`fnF<}1lz=F
zCx;YNWy03LcK5C0fb-P^Z?<C*Np!%yD<_+w)*Y52<`MmcPAafJhMSC0*H&w*yV7-#
znDzr%<4)qJ@GQ?`S{p~=b1f2-5F$r^fq)E;a8ewUCc770{VM25V2lkSEqsm8$Tyxn
z*eHBkb;J1Q%&V>dVls#WbX$?Gep+WYN;8*QNnq?LS5KBd8_QOvJ3S8H^l{@pxvUZk
zo;Y42ad?Pw*Z5BO9xI0IPLQbGMYK1Y#;1zQMfE-5OF_FU?(XulLj63&l{rK)r&hOJ
zbAd>0YZE_`rb3`eNeS7WX><htFBS_TT%V7g^9}YuW~gK6bMV<T2xo|IB|)0Wks=i(
zL4R25NOv<2bo>ri$PF~`Xr|}h3S7@mqh~7@o*;zY*rd+)@oOm)JL)h#ZXzk*u_EO8
zxZ_(S7FASe2jYP%>CVw@H}lNcUei;rGo(5MS-(+@T(~sTyJ3djSP#d&vT*)k@+K+S
zMfQy<g8h?+X_}WqWCTCA0MOwj<I@Tip_RkH4hC}gW~4_bK3~{nU^d08)XQWP3EAC$
zJ%hr0w)J&qp9bSd1##&1$aC5;_4o?a7b*GekQ;frvM~qk-sg-w_#xB+EjxOPfo@3S
zuh0{%QArejDVb)=Z;udPzko^tnQoS_`FK?VyL~)~09)N}lZVXtvZ}HIB{nLN%mbtt
z1caX~OLmMDqULTPlM?u;)?OyMsSy#A<j)@|^>$H}Hkf~jk6$gHjXl;rml(~F{AG%k
zPjdgq&$0s?a8qT)uvnE+Wzs`p&qq$I;loq+NA3XCJWuZqI-Q1tI&>}wdlG3{2GDzF
z#B{%i5@k68qplmm!Ks#yk+hn~havoJr|8-dvE8Ug1d#Rqno5dtmv8_KlbY3AiPOh6
zISOz7liUbcZ_^+@pDtA{E~5?FFuDuk!%ajkd|nb8N0rWFROQ8pZq5iXRIU8;!q^U+
zgX*f*$*Zl^+B?mZ#Qg9Otz}_>cq#z|VxbF1@Iv?5xW|f9P(_QG3<YtZ?R!;(+ClHY
z08^*k6?~v~mZlxh9*G~LcH!-L(iKmR53P|IWn*Ulj*8MKE`e3P!fzj$XlBB7DE1vU
zozuqf?qjoz`wiwvb(B5#GQ-+llsoC%Bhhsq2}!E;<8~E0(85LG`H9i}Mu;y;C@3?S
z#sxlDtg{k}-1i{ZhoF#e9n}ikE_kz!?lLb|;0*D~@!qB{FO|}*9u#Uozs6LB(&)wh
z)LG~xZtFVJc%IO#=LyZ7z2*eV0vYWV`D^t?u!2M(l{e6cSvPw@YDvPnltUbmS<_J3
zd@d$~!+o;Khgc1z;1Z-@cI^}Z>dK)Zc*Sqm;Jb_Ks@D*FnB6AI33TYSOMHH?`QWT9
z{qN<Bl$%J{@DpX0?KbyaZhlkzx-Ow~MRg|&g^=~XPSRf#Hkgl1tQC1=0jp`YHk^`j
zxmxsy#2!>BAh=#(57k~EXT1YV^JWt0v~A0nXr1&TA;xT2WWNs-<&oMK2Npr`ymb$h
zXr$`RhAUke3_5C}rna7n3W;UjmrG{GA`{3Q){X8!sz}tmzZp~KW3ycO4fKCs1X5Sp
zal=PqvTfN#)rgT-yZN^3N4@D(soT?+?vbsdAumtfiYe4m2pE81mQ>tqp6UK)DAV)s
z!>0@xmT%!3{6EDFqCcKdg+waJ&pZ9M!3&<PDcx()9~^Ejom}biTMxmUPxdv-)!@yc
zu*0~V(OnF``Q$K#e#K9*B76Yti(b6E=Rf@Clnc;-RYpDbq-uQMW*11wMt;QN^vzPU
zkN)#5j0xgkhs|s1^Sm-DFrhGE7na`~t|})&PgfIbKY6$By7o%?nI9P3<_;KvYYuC_
zZhL5K%-W8JJ{d!8e)xrdu1s?$DKD&b)$W;a{=LPZ^JNQYdo-ev474Sh%kLTL;#+F(
zO>-B*90h=M`ubzk!Ur>-67Rr`gEsFg<b9pfj8tfua30%Y1&%TqRB!Zpcf(!4P8%!y
zyCmU1zK}@gbJevy2&~f(kZ%BnpPAk#7U%A4Q}_o%?NOBfL;i<hg>i@hG)Y`!qZKL;
zI6o0#Fan9v3ES|PR`1?26Qf9(j&5(*w)^gxR~dWS9HqlY3F5jp01ROd*nne4k{BcW
zoL1B7$6r9ewc7uEI0->on$+Gm;()b&OgC9=Iy7>T^XykiQzm2*K5lRakYFULzbTGX
zX#KmSjZM-K6RL}DAo5QiP<8i{qWDPll!m;y<Cmv=oLqq0rYHaNsed#&h(C%7Pn|TJ
zlLU0Gt{Nt4Wd;ss<<MEDRsfT6%Hf4VrGKi=G6mQLqiuXEw3TlgPxj!KThxvNIF3B<
zQ9IwCPxw-`kcz0~ToYKcjOR7m`RVFxK?2@4D?>T74&RO{OA;ac7}~lJLeAqe)ne>#
zJ6uenB@u6vo|-yG9Q}D*aBF;9a&GPTaR4QOJNK_v%mRs%nkIN6BJQT6J%4wTxXt|Y
z;kRlZ;2Q7!=Y64_{fK>nnS`@`5@|9(t&?w2qJp7JrhMP>{qV$l39D9`)wt(?<<UO;
zo)x+qS8dNhzZqB6+Msp7$m&9^8Xq+yA1Ue4p<Z`+CuusgI@!lkp}uqu(5m#_&&yd#
zvc7E=sKq$P(qS=t`?Vv2aJP&tz6}9KG=`-0;RklmvGw&aYP-~?JvV+WJ86BE#qU_~
z9BYOQC9mDI99bgJ^OVQ;?+hdkbF_YATbX2mG8?#ST>uDzxQQSTI91&ZPK|5p1mk*y
z*<?d{SV7FigKhW5kXFs2!mY92x25y&u8Dgg>)iNur`)B{&l!)l9s6Hoz~N>vxR-Zp
z5l#3hS?VkgQ_tTFxfz&~_2)SOP4q6s-U^TuR7&|Re2q!>P?o!;WjpK7Vr)kWSDW`Q
z=&(|FliW{uvYgqdll>tiFKh%M7yI9lRQy$ZwrE{So9i@ce+NHxo+~*|GbAmtXl>xh
zjKp8^JN?S~0h&^`JJ8H->)DMQ%nOq+WfCFCVH|Dq+_hrNZg)ixMbT0$T%|9#W@8MU
zU*zd5e)oFn>lBs9Z$6*X8GoHy{udlIS60P*9Ulj-2N(d7V{=PBQiJ$ja6R^+vq`)=
zy6M_&uSuHM#l?vsu&*$l7ow%KSNzjyxC2o&onGF9YA?9MzF}YfgT12)Pkig<K^~p;
zR(QB26Njs(Hmz;E*teZvf<W=UXsTOXZ($vtE<$ba1ZuD0iBIb$+@c()?yYEQAc310
z8_>(p4d%Nd-tau&&MM7u{xwJ_6ym#U<rDe4C^c8XpfV)pvN7zn4pEvmT$5IX6sL1-
zwCQYXX5;@TuoCS3`=jo%`J_j!?Wq*LJA{Uyh)}?;H!bozX!v*L$rW30XL`9sAo4`-
zw);A4uK_u!j0_^+*J8h*rB_<eo0^!}uA%jUuMy(X7Ddkm3Ys0x4-8jt)3~|D?RNu@
zpU$>%%Hj(|H7V_b@;!h15p2s4w@km)I6@sV2;5)?O&$msZ>SM$PnLF%u0;LWHhMFd
zCEU$tG?cDJCOPZ@>yzjMn?Cu0I*Ur=j$Bsz^y{8O%~VeRFWsXLzo2YM+~wsga*O3=
zw)ZG>*2@y4WoLY*Nsz=QRJo0Qy%L2Dr#F2<zdcj=LaQ6{|AKwpXKzJQGNg9{Oy7ar
zgfGv)DfAS5TI<VD4_Hsf=Xdp^L_KO%G5u`FuBNm-W1F`5KALtO2uX9FuAHAAZ)z15
z;AESNr(?W+L47&s-Mbp?<7~S+bq=@qcaLY~>p&&eD##0&_30k$rnf0O6*)cqrJIRj
zcqg*a{5|;E@PD-cyGEw(;6s0wIf8pHP8+qYIDpp!986?HKMHJm^BplyoIHuHXqvJV
z^*?_4gKy2V^=Y)$+P?aifPD9?*W>q2W7Gj&syFw!Mk0sM&NQvSlV5z9)1&PK@Abg2
z4Urv%R!gh2LMBV<>V-eb{cQo>&2E8aJKz(~_Cqj=pnuAwHT;ysY7lV8j^xiXpbNA{
z9&Ga^5~zqiI@5;+A^Z$#QL)W8f3+NlgdpVKTGz6(h*fGFKG`@u{Yt446JQfQv%JEA
zV|6ynn3^u0yLZsm)f{}JC)an410q%`vZkgVb|!zqpX4~}i{Az;v(imj=<Tl9U&Ry_
z#)HfTXRpYo2?1!G?`<n9vyoRw5x|o-YJ`(C;a1w||1gfhB>MFaK2@(jtL+*oh|*on
zNdP!er5bvL|27v4Ff+Bm`Cd_>_V8|h84hO>8T<My85UOkTmO=;p9S05^#Kv_cM^j9
zgQ=<7Nw$d2#cKsOR2?<l1a}HxpwiC+{hG=1xE+%%jCccDE_h+^*NZhZdvGT*KFNil
z#6+Qb#mE=MQ2XcDz4km|J7$@dYpR}_*b+vm2SUSAufjsRp{ux_jcxi!(p8V}S3yp&
zl)c=d{*AZXJOZ4^t*xU<Q&8Ta!aPpb;Ty2pIx(@2!=zzIE$Vr9n%A)OEg{erx?T=&
zqPV-WF&1jTZVN4-5Eocq&j%xV;VG@?_3uP_n+K99m~kGr3VhpdZxB9)FF*$TFLdV|
z^eLd=ZyDCKAF|SPsc_M>lYqhUY(1gdAB;u>I@UoJLgymu_y|5vPPG2wiigo1g-QW0
z_!WYrrH{czRUXvFx1k@a9e8>+Pzx!=g^m@09O4R=L(rC*LOlY37dyjs{J0?ec*uQ>
z5!2=P>X7B)pfQ05|2Wu#bJ<NY8)~stt+r)UxKUt*UZ*up&q}ymeYKh;J*cMvkX1}<
zP)}VX6<P}#Kp94<p^(%2ZX_<v@Q34{!h}HdbBa!{p1BhKx7r3KjFKA^NtT!&;@f$S
z-vS>Y2=mCar9$gXCVal*AB2+!W7Fp?mx-*M<*&l7#_j978QT>826YEe(&Ge6Mlp@n
z+>~3_?-zFx_$_Iy^{3a)g`t7qD(?;{+dB^NziwMHZ~CHxmk&peC+>~W2Pg?<%od?8
zrLj-iDBq{T&1+~vQ{(?+J0ba_&t?>0H2!9eow~h$Dw=M?4kVta`wVogehtepB0Qim
z7DetixA9{~6Wp|37@Fa?FThKkUO`Wx;DWJIE^@(B*(z&=@$Kpj@<NLHKL6;i??3c5
z@NKo0x{$4ukDBDoP+S~0D#>$XLoo*i#(DO|e#>%+A$e@ebruoNN`m^nZZ}2S4Cixw
zrji=GgY*H7@5df<lz;~EwPT9n=%Lc-t`~VeL@<*nAIB#Kf>*k-=oSs(^$ljPh|f2?
zF5<A;xF(8EjX|%E-RKdt!Q<tl?u6BIg=9#C8uu!+FC4TRB^*zJkxX$LJ?j&BIjD;=
z$Cq5Nf6rb$Agj0WJ^oJ0ZYh=mCO->c(}4kxc)n}zxmZ_)91JzJrF)CemR{`P3$3?~
zZ;q0QopAa#l#zY-@{s&=chSwGN1`-exqr6(Dyd_<^cq`=;9q3hLBWqQMr+5krwGSv
ziD3Ju%gfeMpwIK&kLRb4URZE3=+zKx+*Wk-+bu56%e^JSiD@93v-zCWWhWottE)Y&
zuMe{D*et7Hz|?cMnZ4_^GSeFwzGW&o?!0i7%&!+PdSHqGddEDQ?UGPH7sjx#6Z<SK
zgwN+2U5$pqczt3m)^xfW&n|vLAWuoMI-lu*K8CB)@x{5{RqJQ-Avqd*vSWB1fSBj7
zM+h8h>7i&kYZ5)L02-d}#lwJ~Ml(sDYSFAWM$GXG=WV07espAxY=qYNl5N5$oa(Ew
zQKX7Tawg~d8A$7aNEVq0pI;&kf;Xn&HLKigS5+&>;vb2%HHiEg3q*0Ly1WVW?hb%K
zb{TVJl9q_wzAV)iXS6`ZD*EFjnHR!-T^hrcd%yXzMg-+8Dq4diPZfvv{svxL7Z|RT
zY+oK<BhHeV?b}V3`GJGXL%FygW^sXn*<<SvY*L?X^!G2j#q(j}YptjrwG=0*+6u5U
zZ4#DRVa1h5o8Mz7+(RR_(F{7@+w-4mX`Ynu+4`IANtToW_x^$oD(eEqIetQ=0+oH8
zan|Jp27C`YCGV|A<bi<noVm&i7Ls4`PsEGDp_7?C(p4e(e4|%!*h!ibuJpXQhtf(^
z?;>}Ww)g&>al(R@;q5n>S>$7q>b{`$HdHYyv%NMeniU(4Te~c3wCt_M7xC*FZ)F4G
zOz*R;S=#ribMXZ%;@BG0@XVeDV}JO%Ckp(D*0P(R4aDeTr`q@+HxR3wZr+@)l-~CE
z#xU1BeqndcB6{o+JS2Ti8k=lxs6;atPSWSl2N>4ht?9dewLr^Ff$}tOIH0*UeMR;O
zCpT_d|Jt^Lw7xL*HfoHS&o@SuE(g}5ca<AL#%9U!hcDZW%`b)Q8kGIk<nT;lCfq~g
z$(*@AnmT+&&0ZTF#)3M$yz(CA%GYiB!tzd1=Wdp#SsU0cu`n2nTheaZ_k?wW{7(6i
za5on>|InmM<fVnpa)AN@S?h*c>-gF0sx5RXlc213EU&z=j1P?n3xtrZwMW&vm)CNM
zoKWP-PEIB4#pG$`#638+-Sj!IM#`+A{xRtvUx%iz9}l*W1GEI^GYkqWjB!M9VwYS!
zIdANm0MhKPIfOihnY;XIu(%mZ9+NSG|LsG(-Wu*S1)k4lK%~2PxoA6Cwt))NbJk6T
zwziLCjO(as@7g`{QM=YFrsER;R|)v~#1p)wfVpaYj*Ig=&je@i1dvCW#<cx#lw6d1
zK{eF;+7>mmWb6^p!_;CCO5+8|S%|~<S2uAa)u5-D&&aLmQtMa8F?CyZQNk=B9E(6Q
zC!xQKzhf*``da`R1ou76{_Un>@=TB_m?c*MmVjj*JO8jH<S@7vze+osL6O4uctr9~
z?Mh}E&JVTtj;gKTn=GEHS6m+cC+=;+psetwozS9SES6VC`8t(Ze7c)Sn7sBeZC`E!
zR<9FY9sl5HlUAVt7DVfLt^(404#*$}XL%bZk(sNZStkVs76YJshp1|jG095af?lKR
z`kok(W75Sq(}|Jk5lbv<?5FyX{d7y6Om~FdZzR0TH(QNvzBy7(0`3}B*7D<hu9V#$
zG0~rXls`yRygs^Z9RdiWU4XC#qF0~_P#EO?Zq*W-DzX8tXK8Q<E6Ox;2)pkk-cOoO
zI9r>Qh8xN;FF^|}DVy^S@VzF^R`CC`A2jJeQoFx1b)NhR!|%7XJ4*Lq<jJB#D|Ra;
zJLI1hc$=HDJ378IsZX!fMq(zw(REoi3TW4?2s1oeF&&C0yc0Z^1;wDJhykRJ*36EF
z(p9NBX*k_J`9B4`!rdj%8d0pKhN90uJ_Hbwm3N?R%~&U`OuyL1<(S}Wj)Z#<LipRa
zJ>N_xR%;%JM(<v=!7x98^eUCz6cqz-OTbPAM)?23PYLf(%L~Ap*|}dELlVv`%Fp7T
zxNH5~Im)6J+qkMEssy=T?Vw%Uj!i7X&xg!}AVEqY@O*xiQ3X+xNZu<5x+otL$5+1T
zFh2w+xN|52>!BFsLqttWi#M=z50?p-$$7obZOUB`HunC<v7*E!%9|0v$i)B-(^pma
zRRUF51zXzQ=f=oe2x_T8{^rdlk`|!DuUhOH-yR8wpK{_0jvmnq3je^biYNw|Jfevq
zi-ACun)Qmn7souuAkV&~SdDXQ(be^o45=YX`)yr)X73g7c=WV1vp^`V_lrucKz}cW
z4k3~oja5LC!Jc#BS<qd{arDTz8K!=F`r<@~&+iv20kF1+04omclkApClmm@G2c5u+
z(fZ<;CO`NXxOO;y&TTiDe0Ss*qA66z?$<)We!&ZalFL>gE}ag5!%2kx_s?-Hl^6#q
zwykzTrrrK*Ke4@^;0vl7)i#WxBfb#J@9xhQTT!`O-$GO%mk<X&KenQI85tRgw=km`
zF!H$`u1M+qc?Bo&)me5*i<0f0qo6k}g1<p!F#hySOUnw5A%-EsqCF_v+7)mbi_cEO
zFa@}j7T$tIAe?lIJ*UFunhT+0JFhV*QhuH7q%&>41mb=aNZ^9xlIf%c5bAaxV1xWQ
zxYYO}j$Lwkv>CkE<cG701Nq}K1Nd$W@zs^Vc<aRnH`Cm7@eF4`^ES?&)QSQ0An)Bi
zifp0UII0as331Lt{<8@KE)@5~E_f$ZEh`&GCagh+FM(miz@m5(iML7j(i7E*unR*$
zw*g(HYo+KWPfH0T2lg7z&fqmj4<z~M5y6`Z?5+a5<j3=1T#lAUm(+45$?q7dq@WB_
zNyqRgTSi|ZCJX9WvW)mwmejnjb9{(k5kM9;XJ{XQN#Z@hS>=DjWtzHv)Pk@w+JcQ+
z;ujF&3>V*gZ+j%ceEbP8N}gw9p;-)|cae0F;AUU3vs3dKKA1^y;={v@93v7&`Z&3y
zHk~dD01%dEw?cc=UfA*kmxct~112tTKx}&78vQactd8;I!>WY$3g5Oq@YuL#<h-<X
z6b>JR5?3^UlW$Dm&Gmza4|iahDP-;_Fti0{poJLljFQiu@msSWm-iDEH&&MDB*}eF
zcZ+PkuLO?R>e2m{5df<uiJo7rv=|`0>a{9U=T}@CHwtV|+t=N}_Dc^qN6Spd=D=$u
zUY&Ek0RU5Y%Q3n#()3_UDm53}DEuhgHK;nc1qbnJl-7^I7?~28l0(uMkr2Td{umDX
z!uaSGfu+ri|0VH@3$7>ON<~1QoY9<;!L|>#|KUlLAyy;V*U$T@HC;Rz7L+s=F0iWr
zOd8b^MA`ImC*7OF=z_4Iuup8&IR*OOm+)inFrjr@Q%gKtp=HzWZiwY-Jfsb@MN+{q
zuDRGoQ~>&Omjb<?BfNQ4B{0U-H~wqgYBd_<rL-IhV6ww!Or|}w6b}zAxT<tELH&o+
zgw=%dv41#wxR%;m5`*}=)I~QWKG+tN3QFLjrEu{^5G<TzpU0j>m`x|}-kZv00Cd-0
zKF^PH{O@rCOMP%bKLkgs{Sq~#ZJciVP=?DmR+6+gj^bZrBJ~-gDs$H|bT-qDs~j2U
z*G<^Gsv@gmD^Q2(uR|0-SNp9Pz($_Wd&bJe{yh(`?5t7L(HBvMkt>j#N;gkgy^m2^
zRS!BEXW+s!^!!W<BM{kyV!e>C5wMX2hZ}R_Z^F_a1dnNf6>504H@3|qIu-$Q-wngT
zx2D?7sgfCULn1R1wnvX5iY?$=cEkq$+HH6~*?jcH05(OP2`bcs1b315^XmM|!_d(d
zU^kUeJTnvTn(pNwMvzsoqI`&GaCGp{u!EVZr{?da4tOvL@vR@9C=a)qjN9tb_ZM*p
zaf~Zuld141X>%$f(|{)ykb!L#y^xmc0+065A~)SfsuZWaUt`1B{bmpEj~@9}^CA7C
z8UK%|HxGpBecyo1j9q9f*{Pw7UB+6L%2-;EJ=u#<+4p^`)L2U>gOnk{gp9H?AE~5+
zC}d5tWf@zt^FE{B_kG_#KcB`q&v~Bvx$o<`?(3Xqz!9+uPJ5+}A^<UGReTiDq!!J-
zaY;O)104U?-aCG*0Bq}WOtIIUwpjO=pSZUfgx!i*2ht%n=<1o@A5@Vy598jpLWNla
z+7!uHN4U3TZPHnaD|M9IJ_qz?_JbuFou=ML?3=xqd<^G93}p@E;f{m`nY_B9pg5;(
zAE?k%1I?eroM!mWug)9tCgJlUeU+837MKQ8+B7iJQJY{sLA;Nz9?F4vc;O7P2Xrm3
zU=-XLa4PLoX`~GUCj1=~1^0kQFoo1#xVT?bzj*b<8?YSu2mADM4(t#VlI$M)s$+hi
zFn|##w`AL5!ZjYrJdRT7gpOnl{H9n@!1+4_I=76j^8hNJI8gY;!1iWxt7%=OIOBrw
z1g+ekr{0`cNqV3LCu0kYGY9-}e;F<~=99h3ykQY4zf`~t?;VJo6T^*aOWB8>)bM|A
zhsrvAlCRRPcUO_D10Q;{TSi>0+kTkT4|1#E!F_U=JszH=nvIoC`rj{!v^9A(!<*Sl
z8(d%;G)mvZ9PzBD<Dm`zl}<h|vI1}=LvH_dmDn^TyaPO<8|s9P*5~r9fXpD6NT?+|
zWfZ;`)bVSX+T^7_0JifxT86#pB?-H88zZvuh|qDU6D+I}rk+_n#UqGk4c<gJTLyBF
zIxPofrPr@B8MhtXn!a@ySa!Q0d05nA(;e#oRdCl;TCFPxeM)zTxwAoF<E&31NE0O9
z8u2^BDlxtS6SUQ)m6-yT+HkfPh*I%J`kh3=?-*BPs<c#e$F9=D_Y5%ZVSBey(Dpzc
z-0thKGk@|5eyEV2+{Wl(T~wfXma#bjtT*%g(}O{w|NZLjSVMRW8|^0rY0&(+u`U7Z
zgRZ0IplYYns*cfz5j6&VeSNrOmW^Ph6gZMESZTTX>B1tld%7QJnIOY~QEf&bD<}<8
zxF9zt+L@Vm2qO%3Na3Nx9(*MpuM9i5Qy1Uu)hO;9Nfc^i-QMZE5AIL15SYUQq3$M%
zx_92Gl+tDk&OyT#1Z57SQPRi0n^H&B)M-O`c+kI?TpH6{Kye|9wf2Q_`Vsu1Ibb|0
zz^{c&ovL(n>ibGji3QCFE(%12?QsbUZ7$vilmG8I@78m|gE*3MZs8UVels2X-+@4?
z9D8k)0c6kKc?1u96-SSY4<OX9BUI_`!RFGVg)jX!s&KUqT4x%S-rv!3LN1+JQmS~q
zlj#jWO1WQZNv84duBiRz4MxMe*KvO@U8d>EM-Lv?U?P;O3l>a26;FCp&zb+nEhK!*
zoC0hHv76rT2e1e5;3s11Sp)T^?s$tdf?Ux09KMm@VLi5T(7!rK+nmY|MiAse0)c62
zvUBAA;q{blr6ZXt-$v9}pzR7h+~0HeHtol$auf$jEG0KR>zs`s-TdXKh~k~ss=>{C
zHLx1djZ%Ht7oC@MY1!)c?KW=*u*&)wLPr(2)&uvCV(R75r6+2(7h_pM`&09?J3K6M
z8EWcHZ!t%*@UtIkC+B8_Wc2ioKcNd&zM5|#_@KW0>~HtzXV2T1p!u(70gy4f6X5d(
zZ|J`v>&s3|->~&Bh^Lif9gYyX8YI8Lf(rh5z-TuM<ymZW&35&$R@gehkRKDyl*!9q
zn^C{cao|UwRR=@=@5dC~a|w;2nUY5BBjGjM{jriU{xPro<cnog5ynipe(PUHB1an7
zxPDVQVr}#;xZMWPcjqAbG_Wa5!(dZ`Kjegq(nm3nGW<0%W;i3*LRv?nOP=bP-61yP
zyoG47caXVLrz-57`W9ksdR&GhMS`1;)I93(%F*v;QWw~$uNNZ(pG18Qr3=9*n$TkF
zUw8hF|9UKCD>ikV0e7C;cl{(~ml6dIv&eI%Fi@jj)t5g3e>5qyNj;QADtdhxOgD-a
z27*5%;pD;C&DhW$`r*bgYI9)#=KI5jx#CB=G26qDA)wSAKJE85)QRR*$ONHi_;EPW
z--++Sb(AgK{ju0??75T|@fO(#Z#r+7xA`rz9YhF!&1cA=^Yz=XrDY0967ukM%2lpe
z;T?WL$24t!k%JM@U%wrKsh3#1R#4mlDoOvyHep~WmVg2vTa;3kE<f^}<NL#&xo3N4
znuRZNe|m?yP#!(X=l~Oi?Qv+*4}0P+=JQ#kz5GzKeb@=U6zY_n^BGxu{Ilcz#%({H
z;NWLWP+q`?Pp@!~t=?1)@(oCYDJxzSv<v;V%;@y7!Tpmd=Y?NxyB+gTLt<*-+Jmu%
zjxRH>>HXKWVtgrQDHPhpc-^CB`nMI<SL3MKd^O0-TevQ)>`Py=;7{tE;oWHT!ov+D
z$dUn%VYUcI1P)<Rx2-U|o3{Db(p;4lN{Grk#@;@%O^3NjW$adB%=t;Z55S)CtB<j5
z!P!E;zl44w)Gz*~R$mT#w`ln7DA#XNQ~HOYXcj1VJ$pFPZZo{X%RKERW6k!olqcUd
zV}*X_B>r3dT8uY*bvW`d4Us<%Hr22_tvI&~yyBOsqwq^^@9m>I<YDrD!6S!`TUv`6
z;CHqf&pJI;mI@Y|p+-NiV!Kw|Fo!JmXHgVZ7YgYciT*_$sjJa9A_~`rn*{4{*1)gG
zEQVnPlVJJi<mVlM>-PR-k|uNXxJLfW<H>W%PK&~Qfn$MV=P$Tb44=Ju|K}@8V|vhB
z6MQ1DtWS_q;KyxLFeu6b^>jp<A%lOU^z={ul8Wp)f%0XflZ5ZfswFZ8Or`~%Ff|^I
zMEmeA5gOc)H{s71ynNR`QL3T&xCXY8%C-~TG9c<>hIi@4_AQ-@gT~4y0s1^Ub_`=%
zQ)d#e4u2t(^_KB1!`q@iRNF<UWS8=m5)IdR)p8Z}IdS+rsE`5K^<uC~#8Zy`dRaD{
z7dnUvb=#aV<POMs{ruqhbVRTt+XgpSJBu`!Bb}(<`ma^_!mGoLlCR0Tb?1#wSu{mB
za}6}f>{yS{JK1A~dZ8v~+;rB!)2BBN!!m8^3A^v0!pwnnX#UKF(_tUsYNms!=`TQ4
zuK-njv*HPy+{X?*Ix$Xlq?6ZYN2T5pWZlW_$)3tCr+&J{Wl5+nKYx=NG)H@QGenF|
z&9-vz;<MnBmWoN=`R3W{)7qfD5r{RF^BQM@h?xD4`=a^qTOJJe=qE^!ol^lJvJdJ!
zNoGj>iThhdFv5@<rR*Cu)s*&i!w`-gijFR>-y|N{Wdt9#zguX7U8$7usje5REs-of
zZ=pAdVJ@S4+g^VJ`BQOBKKO^y;yI-w8n@o^(DH~NzTR8!w@3U9aNcpOR>%C~Ln}Hh
z5S3n^P7>xRAcy&HWE+<*SE-b0L?mVX*YkWh(!dFIxvl<4>WO~78p_E2mu`W0@O=H=
zXpsUL)Ej623-_-srUoAqNN5<CU+aWUUi^CN_}<9RX4vVhfr4B60~qo*D2hRtRkqzJ
z{w(DffDi!^ev&sFgBN)-CE1~oenc6gblqcH>^Tumy9KJ)W_a-l(~R`;TAgEyr?3;^
zjCB2V+ieYOpA0AJ8y7*+Lr6Kk793fs$?gfUnQ*SR$Km=B2C$oq%S^5hrFv4^o?<WG
z3ILvhdPxey%n7&Dt5s@C2EmKfJ50S2CGg-M{OXe6!UejKF)|~O)!@QsCjNUEYA+=J
zW>Kb<iV71|had+|XkHbQ&9URi*u5Q8)oUw(=#GBI$TWTa`j+;KWqV|?QN4MX$T$B1
zrf(AMne{?GC%znFnn?IY)}{mm|BzTbcUvz7A<F_i`cT=9I1E0S0s?;wx)AwfV`!I=
zm?&EiMikn0XPiEN$9LT`c5%Y~KAzO)Ge&Z4zMO^*|AqGa#g#g!#-BM)O%9NAcS$om
z9X}yH9LeVN4q%gx`4URQVccJirP4#h>b9fi6XKBU@xModo+^lo_^qRSM4yj5LaqJ$
zOx+WEe!{e{y?<n1g7(Z8-xj?dU7M}lDhdEjj7p_##_6ZX9KPSE=UVFKYPlCw^m65@
z^+7Vp<wi%E97nDFnx-}tXJH3!=~>@R_?DkG9QnB+k(p~i;wpHlFZp_iQy*$<i_&lz
z_ZQ`3;4_c=FBDbEH85|TW@yzu!UWT41C0H5<tW9wSEAi;lVR#^!`$Iiuis~X&BK#~
z)k<f1C(P7PA74<F$g*YG50ur^z0dgMwv_;e)%zvEtC_pldb{L&`cp@ufL&@>(8GG~
ztY9Pzm5oKopnu#&hJN3E7i(h^U-tUP>@yS>X#IV%*vzRbr_E--vn;HD&pHCHlYbUl
zB9nKr=~KM08uw;}QOr4~(M0fPq0;K0tQHrxiR6W0EUc!iXS(hg+RIGYpUIbU4Bh{A
zh&UwW=^K4}LncIT_P;Dj9mOps&+@9j<5;@%tBed$Ace8ZZL!V=-(Ia;!ujMnTsq&F
z;BojO!e{*_MOy&djQy=y<A#1}FWGY`fijprnmH6N{m18<M1mUQcX`FGSaR$$Krmu!
zQGuUExGy*!{fIDl<jL(K6D;O}D|fBAXQ-7Zs`gtf=Sf^J&;$zf!K{e&3FfS$me`#N
z3BOkk-3+5@A6BQ^IPzNSKJUx(JTG^~RaPYSgT@Ro*}|DpX8n*X1C^c{ur3CRru+N(
zMlJmYkB>XBeXPlcS(IF@r<Yk4^)Yc8CCA#JdJFoID?t2U`!24y;!V-U{k`B+XlRci
ztHoR#*;R5<_BkOiTv(<+ef<G$%P<vb4{}}#AX?O@!#+wrSM@*7I2os=*!YaT{V()q
zdwrNrTCfO8<xIJ_OX#aun=bfv=~;<NKim}99{X&HPkYk!_(kkQT1VI@#j&aVnF9oX
zhS@(s!%!5*PO$#PKcCRn1xV}zhlP3S9q{&?gix5sF}j-VJ<2q3JZ2eZ#mOgtpJ<12
znK<C0@lY?{y81qAgxr^o`TuzVQ0O_WF?RqCJBYkBI(O_ucoceG&zvxYsY}zKd?oLu
z{w6Q(ZxKZ^^&Sq#hJM;B2#O>fsId_WiYtdOiA~q63-U6m?e~=L%-qMc@!aGo$2|;9
zsGqwUf=oRHh$ENU?RxqRugi}OzbcZ4Vr_{lU~PSQDsEox8=@$H*D$j>hQ}I;AlXE|
z|4_--v|n_`80yBZ4r^^Shy#5q{l6Dlfa!b!1Hf_pJ!NP_WUUS7ymorD`D>zCYL@SL
zzz4o5VZxvE@V@WnU}}0sV@s_9y2EjZi!sj_z)Q3F6>1CLBua+Wo!&hsRmV6o(f(f-
zBkl#I09;gGMInD!tY%xRU3>%}WL>52ddl5UF2K4sRqL?~pj5zu7a1ZX6<4YU^(4$v
zxe?^O8@N@V6bSad62OUZ?hK6RmInbMnGlKmu7q|!34Ye&Np0e-aI?tG!e(f|t|*}A
zjH(h13x<Xx>3zYsn!X2r#0uK{v2hZ6%k5KN|7?+JdYv6efIyUy_^VI$hvo^i$NhT2
z&U+g8SnEEG^wSx0B<+Y{!fEg14q&6mN*xfD6O7TNI<2D?`}tyw0%E;xTaFr)Q(vC8
z3@jCueg?2?CRaJQF=sp1%~RC9n@#~v6UDc<0)NC)2G82C#b9oOxlgHI<eW$H^mFVe
zqAwQwB-jY~gz`QaW>;ql`7p8w_C)<QI(X6iy&z!3W}7)R`>aVjPYGIlnc!vGC}!*k
zb9fqIgml7Gt!A5U%r-W)C>vncP?S-Agi+9hJn=I$|C9D8it!X%l~bQ$M5G$85EvR}
zsnsPnB~Xuwf5j%>sXPL2W~GgB5+k(EnY4qPxkRLHF)E_bb9!UYbJ<i}0RIx<IVotY
z3j9Z*Gj28Jx5krh#P<x&EdBEOZF}mTd9cpQ9mWTM%bIWY<eJ09qp#x>n5N>Dv%i9u
zNduk|b_JgE^L$qxjy$^bhSK&75V?PY+?`!Vh<B-x4dAQTtWTV=y2Vcy<q{|ylS~w|
z;AXa(7dtiYpwUmI>L8Z?cvH5{+IZ77vm8ullaQj4bjpf6>WeXvsxH9KpT4I2!k-sg
z5dHyfS}h_6ixNyf-V*@L9~+wv?SIWG7g6zbhH*?~L75BrJ7?vEmL!8dc#}7^edorS
z$?qxxE~vlK@mqU+WZ-`z_u>1Z{F~euTVXKI%EOIk=H-bXD&lEV`RDot^76CJ`iI6}
zjKzWMzAgCr$=@ASuzJ61wwoyXZi`L77SN?CDf?Ch!7mKcMhoImM~%`?7-cp3@M15Y
zJ(Kl~C(IPfgVa0or-zqbO1iOF`RtifJq5wcauRcUC%L_oq^9Rrp<J!-+{I~s?e289
zQ3;ntE%(vjSAkgHUuf;--Rxj4_Rb~>iAcI1`xR@0^Q>a8NCH6~7S43nMjYG9KW2W0
zTeA03!`B-v`rqeVrv9wScR?i4N#oBWaj6DjHy#W;OgfBv%8RTv*$|QEV!w>*WST#k
z1iFphY^%`KeBtK0X2lgr(dJu)NaO=}Hrz-@U(vaHhIOnKYEZ`nw_WP}8h|06*x;zk
z(=vhU@VXM-7~{M+NGB46*o2jqgX;{HeVFJl36)etClC0??jXuFBB`6wO_aqTP~#k9
z`Db)Qe&(=j(7(s_e8jA_L&NeI%hO36P?#~UlVx5y>CYEYGKVYf`H0@1Qhbfu_+min
z4LT)%=Y(vtjGxHm6vZx*O8au@Hmi8_%yKD0^(~d*ia)kh2OTtSXTE+_S}}>p{MSF>
zcK3NgZA6E=5~j2zm*PPr8N{a1X6%oE({a;2{;@CTcViN<2#j#1ae5%rl91_R8=(c}
z29xwPr6q)^l~7H06Z-|MCOgT*S2N&J$LHd9Spf1q38BuoGKcls5X2+RKj@FY|2H$R
zP<Rky$G@3~54mBcGluH6aG82Uc@me(q~EIUoNMEr{>!>qCQ0)I%Hi<T+Ua#u^4UcE
zYossz`^`<A{>EHZh6)xRd)(d$jAim#2Q*tLrgzNlCrq>IqX)W)zQHkl?S#+9MAR2O
zVzJQqlP9cy9vNFF%92$F1x7Y{r(=I%Z9IP#Mfbh-^ZQ^R6@<{XT=gq?d;EPT(KI&!
zhcikitRfuw^hGU<Daz!t(%>Y;qe+@4QKHX=Il*Ev5Nd^&Y@8=x$kY~1a$g%{gD!M`
zDJ+64XI>qooR0S}L|wDP=FrPB2s1ZWtUfAH-b0LZ5NfZDB%YM1l`LdW54+K2LmSSP
zbVUu?UD;<MJ?eHM77);pXWeVaWrKr><$&bc!&ucF(tA(Ha}luEq!j$S7(J<!hkK<{
z$1QK#jBP<XW+QAT-<>|^N!OmIHN+~;NehHdm#F}Xc1xSs6D@Jc&w9j9Z4jra2cNaZ
z<xJN;X@Uk*MWW&g^8?2Pytn)%X_P}eei3$&&XK;1e#`gc!X?U0Lh-P)S0BsdT+O2R
zRzGu<Zg`YTyOMjpNUR>#ru<|~o>r9avxYn9tjp4NqDbq+N@(zg!q^CrB)PQFYg}vS
zl7Yupi;t7=SH!N|8)uv>%X(rNXG#bS7)h+KGH*($|6wHt<`f;QEjpH`g?su55|E<a
zu}F!>yA}OSvy;fW3)wMzH{{ni_iw;_6={kq&+#F;nf)ia`WxxyqLIsIu)<tO8MusD
zgnC{2_@PLh?^>AMTFNZZLs;{U;^(lB=m6btFGhJT+I}*oz=@<MF=8AOk|hpwTOH0b
zK}dTZ<gVsQKk3#soSaZ8$`~cpek*@^)*<H2MeMNN>-?F_l}mfKC}993mhg1sW#0(F
zX&*sK_BS4O7nw9h@x^al(x{rov>0+OoSeI?QRT+zJkgCj`8@X6=y~N-$S!;QU6BNb
z`jvFozEcDZv5Gs2eiqo8O}}Y7iORurgPyWvd@6F;bWDqKiYIO&@y2LDm6+=k)2zeY
zH=Wrnvb_^Bb0SQ6;FGM92f@GyiMNNPoISL#Y)sq_dZ;*8jr2_e+uHMQ(T$A~A2FXg
zbm{r@({d5RP?-Ke#9rOX+)F5japPzO<5KsEZSVb3X^1W-i%=Re`yep2^7~>gHc|p(
z&G`1PKFDx3_d)#Bvxsv(z*{qIr8TDAfD>ww@0l*f`BIL7K<$(ISneg6B;4I2^xEdG
zjk#xlo7EG1h$PA@0WYTCT7<f$?W8d_N4ZJSnX~^X@yhVEHrXpwKl4RI^y@7t@S(RU
zu+F-bOa}>2l4FXm#_-Rx^kj*yBz!Z-p@UOr0!*Y9={tE{Rg!N>9@(fNs9eGhb0Z}U
zTHhjH)4!jn@<#B%5m7{|*Qtc!o#0!l$J?*%N3_V6n&Qf0K|Wc#>vyB8IxhA8p`aTN
zz$eC`;oC%(!j>xyiEX6ogj)KFWJSM_#E<2jvh4zF4M*FRO7*bAVo05Myj-k?)ad#;
zgFMsh;7xVDB^?#}p+SS%v>Q>*k9#i;c>P*OF7ttmG&G+K&T$u~NZr}hljnjF1a8QT
zHYef3<3e$s7`S~`m2C_g*2btnnoDc2=T}%Cm=h1|Fc;E5uk{{}T7%>B4aFA?siOF&
zbrD+b3cr2HP>xZin+p2=-v~QirX*V4HwFQf-O_eP{Mr|DIeQ7|h$EMc_yrKcC&1==
z>bEmH4btP=h@II6Vh$4)9A_+r%6)(*i(d<OI_rcOJCtA_U}^g{VgXZ{we`Ism|NwU
zA78gOYTO$nskZ}s_NDmkSjWH>Hd{xDb|^S+p()x7`{$bfC2}Eue9+FU7}h2^jj*U!
zZNC;}nqt!>6D(klL^?8B(MA1;`|Q;l=bou0-RbX0Wc&;zFM~Xj`;fo}8)6eT2n=I=
zzNUv7yGYsAv+;%-;47i4k{E0Hw><hBd^nZvYb~;i5|vg7_;B%SY-6@O^>L+@#&H8U
zI&5p=jcjWLIjE9q9%Xz=97R1mMR?Nzo4NOQm?5Y4w}Mw-DjHMtV&n5=jbkWLKH5L#
z%{V*(sJRr(^&~2lV2I5z^yPV5a;{r?l8PgjNNwXv234*+ah-a61Eg(f+SEaI^b22d
zQ*{Lfzs{nN6>|S_ZWa17DNxCu*Xg=*!Aer3x!iFmjFuq{k-pj$j(W>v;`XI$s>jz^
z$aWI9o<qX-g7~_NMF+2|O614<#@bZFr`eA`f1^i)azq!H8h@e2Z_=VfnDs7tZX91@
zmEP;(j`wr;csd^XuzhT)KcSMZ4BhW>u04B`7ko`3HC;D+l#zq)01L>+fiLyr^Eei6
zdZsdeM}|B@&$*8AgMAOs$W=;Mi8}a(z>e==FV?p@U~r?8^aI;^rDRTL29+9kr_xYa
zyrMv{OPaRDw5FY$1Wo&lD93f#Z@PlHbEE&ur7tRkRA2_XOyB04h7QV$Yf7cJodOX_
zLV6mwUGT-JPpp2^q@!Owu2sjc_VG;HylFZl3$hKjy4gYUs)bj)QS@uhqoQs<J`x}E
zG<H+ZrVH^g;b4{3uxh<-!g?yBPM*$>6TNWU=wNP3--5tGR;7+TT`aJGNGDnR<*s72
zRIHkoJeWSF{L)W$d`N5bZHu8SL2-;5EQn7(N&)47q^+-^bDs^;w_dUQ(_1c_WpDI*
z!4g?&l#y_~H&#=klhl*U6RDLBa;R4=?22Lf8wZ>*AJRK<g>-5tFFOL9Zj94?NDyOG
z<<@V{>aH#`q>o_AG)P~QUE=;Xol`SgQ%MXQNLQ7sIQbMW(t<fMFJjzd*BLhUbsQ3d
z8-e|6d3MT{*CorSeQieYMJFSP!%nW9%<3|Ah|<*31{PZ2V4-h=bRdR0_g8SZ<QI-s
zRZA6Dmhd59Q}+oH1SrhT6XmFJQD=v=NP&^;6qlirwWrdf+qhRp$rmjDp#HeA&OH`t
z4Q(&_X_YLp^lv-4!-bf|4Oqy7mJ;y4bfcjB!#4;ZOp~<{B#CxG1PJF_Rh1im8Js5;
z<81nL9LkT9Z>BYt@Ne(lVj$qs{FvS+H?{L&{7*UOvbat`l;F5j9on^znf|@pcobFe
z>ey9tu=#6ayxGJ#<MC>DLvgQ6Qyep%W-~-}S2&!o96U6lK7Nt{azUS?L&;J9VpgS6
z<!}aq<xXwZ?vu*Rt%n~aOq?8?*qn23E?}2~3zjtBFFRr8&fv-(c-=5Tjq1_MNpqQ6
zbXnRCh{24JwCc+jyPjA%N)KXv?apqTO~3wK@2j3>dp2haOLT0iUuHEM&%}agIWev2
zJF3<idgAhbUvl%c0FpCI*L&)Z8dr4|{qhK9itD`pH`zU1Qk@1Ko5P+ft`vzjUu}bo
zVlD5c^0AUh&6@FhZ3FFufr2KijK#xHN7|J5OFbXvZ8pZ0h|&={sgz+N$t{)}VA@w{
zglw1?@_jM`2bb&aeJh^$nB6bQ8I58aj<k9k$$P~vT}4p+LVE8Fg2o}wWjWu}wiDtg
zu3azU@0)GD87n`AKDNF#F=$O3zeN5deZPF?yZ}oQ&(y%-4BhY`q`oL^J3f`#zL&zI
zpDT(CW?S8RwU~${)E-_^ah_<yhZxY}#MS(B<lR)A6ns%!sL@}!s(L&~ZPF<`Hv2V=
zx1j~;Hd4#SFIoh#MVxQ$z?mJZob_VJPB-V~(;;q<(ViV3FZZ!KMAFF{*^c}7n-sWU
zOqVsETGX(q+k(BTf0`~4U+DmAQlP~Re-vK*FV;7A?b)1ko1G-4zvQU(tAtURb`cRA
zVom6b#tZ3~#V01vD}8Vx`cqJA!T~UFYZqx_Viq?^#xuo*?&p=$9)W&Ir={&D@}%)W
zsB0i9sufqh<3k)W`(1SO`ZLAGq{iURxobtz3E0cSPF5!!98ee??6UIZg-Wo_g=mxm
zQ<PMSJ?}=P`d3D8v4CgnqKw8gR@BWG!wV`10#uL_#o$&v;%|$1T}N1Vj1L|L!3G|t
z<(D<A4YH3l!Cwc1Iyru6PG_I4M4h_n>{QO`cc0|Zuy39)!gYbus@Iz0K^JwYo6a(e
zK=_Quc*X#bbDC8ggceD6@{YpfpP$^~<Ic{b(Z7d4c*!$FIPhyUcznBw16b5?M3+A_
z-GHo%^I{g3OA)yf&hecteKCI8f+zYi&dUyLC}9?o-C61<kSW*=L&?7J>On`wAjpC}
z<@J99Vqkf`>d~kZuhUJ_zU&#D?foZBa$Kg$erBH5&BsvRymN7$l|qUS&~qANl0?#n
zcIZVc=1XH|a<Eyii6p7qLS<pqo?=6&b<o?q^O#VNsJA+-#V7{Oo)xh@JH;B(@7<pf
z$(o@{2M$a4w@lkC;?cs$eXc1ZGsh$GO8yL0yYPE#Wa#Q~j9U@-s)w*BvYd5QP!hxU
zd`3X|zWP?+*k#|swb%F>WKB77gAmK6v|7qL$!Unw$E7^4lMJ5LYc=O}&1N^m+Oh1s
zzCE*`WIjOZEu@|S(3)CMCz6lzTncnDHSKc`xOu|_+!I~6^D@f2|FL%tu8*MgCD}3Z
z(PNVl>1T%>V6vuXcYKk{E)2DOKT38eN{FRINK*?lUA}ZG4X`aZpV`Pe;z<fVp|XQ<
zu6`z*8<x}#Em}Qv=cYl8QB#fu)26>7LdY)W)f1(Q30MMHZ*%8@U?d^%B_QB{(L7Xr
z;Mf7_6_=g)!(|_K$~kgcd8|93d|6|R3JIqY{H-J8l>DclVMLA4%SyGLc%*5su`Ky)
zJigg{C%ml1nK1A*jcvP?nN~pMLVAh^E=RCkxtzYn)ho=FThJuKWh$I;*+`^T8C7<W
z)<$POlxv?$%&x~xl~7b>-ja+x7V#l@M31@aldaho3|>FR<%RgHc0roQF>2CXTc2H~
z?klaL6Z*6BV+PVUxkFQk(L@^s0gj|HbhuiAc)@Ib52MReC2cuP+8{!=@vYq`Yy%p~
zMy)aTUv&jYptq&1_j42*PStR7qj&p@QU7;s6v(kE7jRyP96IPq_whY?k9p2JVT8>S
z&!t`d%s0pS1q1J*w0+Z`QVRRzo5knfH&@%v=&QI*<xnao`)4VG6ja8m0ODtatzK)K
zeO>NAjO&zI%rBXSRs^LF>1!R=f8!~nDYTJ}rryI}p(T}5gjxkXHsQGGnB#Q=X>Wcc
zV6Exq@Z+5in0wh?(GZI-#h6&L9XmOsYM-z9c}Kj;{KAR9noF>CREfTA0(NOJ52*(K
z+S_;}VZZDd<0##zRP)n}asRI2$^JucUU3-X@lV|wng(24adgv&Y|9XWH9AP>*#r}h
zu65JiXaY68Eez?K0m`B!*w37Fi%31H2-4n@rCSYvv0=Iz3tlFYFtR#v1-kmeqb!26
z?zf<03LXRCEkFh@zH3!odjDkW95%;(S><Y}ksc}r8s-$s%gSmt8;*JNwmEC9sdByF
zlhVNJID5+JKE9@UeD2R1sDaMjq)$ftTI4?*VVEFwht&jrQLlB5*Z})ol#3OQvvI3G
z<Dx3DoiB5Egdyj6`)nvd!wr{vsrz}|EWCSJ{xISD&#IXp?o4~Ih#m&iTp)5;c1h*=
z>?bRCn3~&^Hlg@b?x-}OmbD^YapkD<W1G@+gMnaPebLbcIP%YV0O!;Y+NcDf#Amm&
z0%b9LXHQ23Vue1G<E8=#n{s2uV=@-aUstb<o#u6XcePMcwNmT7h48k?gUf&R!kVaY
zne14sT|&^g-xCn_WXMz=G+eKF%M(!qK7tw#C=~lAhnag0nyfhhX{3MPi*NV;Djt{G
zoPw`Epg64dCXZ~TwordwK{;<dE=5Y}?dOHo`3#(vN?A%?Xn8|&ZI^V&Hs1-x#hs1`
zM2#=k@m*8pNBY8j0-ngLslE4Vjdq#pZzSKC1*<k!Jia84BBx}03}}{0(o{x`a!s*c
z`2{k*{f-X0UGPpBTP-b=%x-)vPnqez_n4qDM1T6eF~gC?o)=;;)p-1q`T#BWJbVc2
z2LIBNtS3EeWd-QNT2|}lpi@-}@3$?gWe@G}Y*^#=s)QH3(h6l~a~6v`0R<IPOhnH)
zk13n>Jy)qSOeegHLEKF(!nW$tNRkF~rha-Lw@*B})Xil|i4ZEg#Q(lC?|5CvX1$b`
z)qd}L_p4yV6Dc2N?p;vsP#*&z;mti6vA&2q)ODe3_Kj0M;W&p!gdvwHVS5MNu6BsM
z+bB@<{*Y%TSg+}#kVZ3s1J#gGFA!t>L;)^?uN;MQa365Ls5SGJw%sjPK2VAf9+pwB
z?7k}Po$FRykIO3amg7N|r$-{HnNsp*w0amH&<%y&ty)XO^QVEst3{dq&a6z{hY3A)
z^md(crPNa5Tu;`$(q|>p^spNo^f(^Z5vCle_F2Q;WK$VH@`&ocnyb(&HFzIxYakp>
zZBiuleEaq8&i=mA?>d!4DWNb@9#gjG?2*xQ+T6%|cLxKo8rhU8V$Fj1IFG3n_!U#k
zGniOexEybokb3Mm%UEfk!Uqy7VN+#H^4oqzsH~5WkA{zckFM<rCft-{_nL<=8;Kve
zjtATFIEIgrdbU4p%^&GohAtI1lIMy{9)DNZB1ADmF5g9Wkt~%~-|?Kbv?!OF({Jr1
zlG-zDFX@~)*&gia#2etvqr1%U9!U`&E~pcg=h`ju``%g<laJm?`IAT=rTZGO@?Ra_
zb>JW|^i^8Qt?O5cRf}zY>{tztMu^TovH$cdqdZ>?Arp@R0HQqpfX0{<W?mxsFfHZP
zNuE}#1aa{dwoiA2S5H&~x&4pMD!llvlD~8x{~eotJdHqxEh3K4AIVdnt@GIQRERVb
zU35-h!9|yaAM>0-br%5e&7)-;#CW76R6}?9l+UT9U-+7Q>if(<bDaDcQ}oql>YGdd
zedc*jJdIBA8Rpbv*6jIqUy`sX5MW^Xf$npiWT}mtlK=UHW6C8@Gi>!+<A|gbl{bb}
z+&(#Is*2Mme29L!8&LCVPxt_7BN@L@s#p$$4nZF-J>MIBSx+#R&-;Ge@>Ki$>KPCg
z9}~V_7XGxOT5+Od)6S3YeaCV!a@h>Xk);=FOI`UAnsPDU8gl*%5ei}cu8a~b3zb7y
zy&b9%89DhEKqOn50`v*`8ru~=?!~Cx!&Wbrz2ZFoL&={pK@!G>M}d=MQ~&)&1{9?Y
zd#s0CyI>_W%v|%58hEHhj*^SalN}s5>@w9ib0U6}3%SqZx|Rdk;m6T~MX|jzue#9Z
zPx>xvCY<bE?`;6e!Xv^WQ%YgxjqegN`mMledhNNAztEV4>2Nkh3Avnk5Fq}c2~QJB
zx<ZBYTAyKUbbBs}Q5YpK!9^k5W+5zBh?8kZ=+tAvoVl{z<5rl=dQU(yBX4}}^BJuG
zKlAFYY$G&g`o+w$N>f)qE2X}!=B^q#cV^^r)b4Rq?%eoVhoBTj$9P#|_fBBBYmA_|
zgmf@+ghlpv!j3a`Uj9H;*paJ<LsPf#8!yrBZL_%-6w$7ncN*`e{_u}&^DxwBA$R_M
z0XNmvWZvQ5h?9I`1H`5xw7%Ulwuc0a=_QPP7Lo6J52b;kN!g*u-f3tZqL3+HDHzIi
zN+V^2r#?eysJxYAjP!NIm9a($d>6YyoI1Xi=Go1Q*GCxqW8c<{sz9YiLxPq1yzw#i
zQrd^5H4S|IU2!5bUi1Jz{=sbi?(5jvT%y9zCUV)Bw&GW@4aTouY<s6|EkilT%(QDI
zV*wOsXW#30!FPc_xXorqpJsXTY`S@<@n^^pAy%}p)5OBA`QH~Akht5Ao&IRh`t@J3
z9C06XZB*^8JxLQmL^e_sR{*cEJm59?7bfM2`^mK0u{&d$fE)sKWN6kQ$wmRN&X|vL
z4)+PW&6QUIG<-q_$T!>)7|R#S0-Zam5Ou|!<*<+cwp>4*DwlrBVcdD;LPPrb6ffvc
z8pVVLs;gA$q7c_(bg?$OQzyqF62#T|*ITL(7!3J8X)*eRbV5B{sk!pYec7eat9*TQ
zfX+0=rGCV=k`KmxB{R?zyQ7yW*^Q^M%JU~3%qJ`S=IRLSW;kFDKdhfCh~#8l&6+<y
zHn=h;I3~|`4}wUJ>5WZgh_cU+R_p^)VLe-+4Z0D}%RhKd=Vj0CaJ}~pJRreF%XP=&
z^O=H?XLS>>JRK!&+^$-zJLhQh#gWd6$F-4N_*na`EJ<|M#2%t1`C8GJ-8K17;PR*2
zbHkowIJ!)EPy~4x^53Af-Ct_&tC`_C;q#zE4(f(O_pk%HYt_h;pBxec=QdHM8jQh`
z&J+J3mmmMHy~8GMl7zn>7ura59;>EkP~>uRU2r%nJl;Cy;%5cW5IW{0;1uelk)VBa
zwXc#A_7W&$3J0+~%zrt#Sj>R4dT3@7h18SWCtz(j>6#DJb8ED|iA)1bSg!q6f*yLS
zbb+HGgRoAwPFHPqNw!`C_2FB!CYbsy*QsmZ_@KvmXbw3<gIMP4&cHx(po^<HPauKr
z(?<Xbt&j7B0CG9lIoHC34=|J{r*P+qvrRC}+$Eeb+q`6wrZ#HtIOLx7TWU)oBIep4
z8)XLCk<l|Dmc|P0WIa(~ll-3-z!itvEt6$^W#9{Wcsl(Iv;M~Y_sr?4X)KMsd%{T4
z?SgDTE-Ar+8^s{HwNBRXshb}xgTd*jwQV9PN(ocpwaKt#hTF>>4;g$GVbKRcTW4{d
z%n`S*wGS{-?AFR&Rs)r;NiIqA8<_r6=757xQCqIqVHqfGZh%G^;SrYnq0hIY4<v~#
zd*_MQ$mJx(a>ou>MD0$P21cPE<a#Y})RjOWup8U(58{c6RZ@!XjWV-0!}Hw-cbR=E
z59FPTuU8$N5BX%GOO>>2C5Ze?YERK~9AlaXQUvz_3-KYLOO0?vviz=7krWn+0_s{o
z<7XudCcD9pxg&+=&W$NjsD@Vg&g#}<#U9#lEjSi5F7t1$;x~#E%emgoI#3D#prY^r
zVvqgTV{-utkwZ({V))MNLpg>Wx)5~?XBSjE=kSm~7`Usns!Q0snD8n0op0=o=YQXW
zYlgj7<w;)U9i>m<akVUwOvF;q0rffm>$1pG!htXd)8TTp>Hgy9Jr)ZIn|e*EVK89a
zWe*9_bY8^ou+yF$7jGp&5n_6rh8d>+Yfa{9ZG+gw<3GlQX8f+D&8&&9m5u8@-VjJ_
zv|eB^NOP0Rr5TxV<5CM+gv~WScM{>!Kvg&7QK{tL328nahb?RcmKWvyEy|24@!_K>
zjXXoJ#P~{(EE6lG`xCX|InG%()M=ySX?UwU_)ChT*4cE|w6{l>%oCdQ96ehIZl#Vm
zc{&pKto7>`VS6icjg&(?dWK5-yA7^~-rsFei<$mh?uOn=-scX%kB5BHMK0?<i4wwD
zrB&j0M8@a>Iv(2sG`-5}JYiTpq&No}L~f4G6M*(sDVCd=uES5H6J!w4devot;^Vi#
z+LnSR6FajW>-_{zYxD6=s(y`&J>Fh^Tyo<_V)vc;lafoU6}H%&N^0B{Z>jAh&r2tR
z!nB;aSrycpeEyuldf5I9gh-68shi4U*Hsi;{XWpGo6nbo(uXwcguz1&h16LWin&b{
z^X!`NQ0cTMP^mOfVGX3^;m;H<<nnEFxnHA|L>>ReT{P7M`8xGL5?}R6h*D#H0RQ~w
zYd|uT!@J?M`NnT^q32Aw$l8|NQZhaSkclgeO8z2FwoWqbBWLZEPoQu!D=HnNbA(zA
zAFjr)54SuMv<=nhssW0k#^bBq?R)9KR-&E>Zoj^Y_c5^|bEI>Ar5g071-f8`W!q;H
za;3Ojrvxc)TG~{^#}z=H?n4*3YQ<3X{qEy8;s73Zosy;8;%VgXLug~Y8#=X_J&qvP
zdm9hWl|hG`FbQ&BOM7d0_~M~0Y-q!LIHe3shpdl?&v74ipX=riYH(8oiW}Bf4OUwJ
z4_bMT`Iru`^3>xUkduLW3d0R_4+&55hf2bnu^v+Y>O1Vc1tyLub`o_h30;0tX|)l+
zH4~VS>7U@@&lnz)Bi<#x?0tHZX}`tHchs(^(QbYQXUvqt8c|kwJc(fsp2L<Sf;8!^
z;-KZeA74bAe<-5lX_EhiP0BjV$;))23F(`TE_Dwh0?0WBk2ZS`69a`33uM_xpas1S
zEAgFmjK@1BRtlDC=DwABpVm^xs-GXL5W*G~EmJha&eU{qF)24FwT<+%J-f(XYKss!
z^h1gflOups==a%ecbN*MOc875P}fBM@m3!vu+%mQ_So|HmAXP}K;B{QiQ}Eg__|!L
zOce)QF5UdmgnG^^$55ll$+b8r=jpZEpX4oultauuz@Mey+3F(f=WegOoGJg^xcn9L
zrB$wMHU&ym+~QN%KB8wj+lsGgO6*?{q;*9_fGYl8o*0~nYUW0MjIXRK`3ttT7u*gF
zj1MFp<o@AFFcmoYL&Jzmk_kJYWiHb`d)n3UezH`8-bh2S7&}P}sTQ=HW%U}e<Ec4x
zrC{pCrG!K*jy;3$m5#5walQB?#fGQDVSnI-dmjp;08{08zk3p;dW1%(aH6d9;tApK
zD<#E|J-0-D*r|RKmQT`r$ABUq6NoK46TtM|MJ_uD&(DYC(`%KCc@tAw7w{XXU>JXb
zynUDSV?rXr`b#zg3giCv*Kgz48?ruv6&~1#7YqzU6#&BM0KcM9nQ3?sXt4}`gCoD$
zNx<LITOnP6sC>ZbaPlk>=lMgOuu0rgYj5xy{#X)|$GL7w<t=|$a~I?wVDBL!ZSW?S
zQ`TbrDnx2_naZX7wXgZMK)H&1?TOX=7B{zc`_5e(K5VNajf9gq6-&``$OOjyWJ}xB
zmzp?Vpn`wH*H{D0rJ5ge6KkV}Xy$W$a{;>(OPqeE7E>ZLBFDNz8h5|47DX>>yN)`z
z$=1w=GbWukoD`gTRYhVup|vkYfyN14KDfSED2MaADZhp^YV^odpuMM7ywWNgPlpQc
zXyNy)!Tuq$j*>@&&#>w|8DVc8WJ!G7s|-RSOcFk46;TX`VR}NjGw<Q`wbDo7ATSIE
zC~HAZ|FJ6gi!Z%bjf(1m=3;vFe5bLk(*VQ)0bYl(Nh+aU>`K#b-SArj=PgpEwa$Qo
zrP}mgCX2{j>e^TsA6~g#Ze7T%!NDptVDUR-M{J2GJ+tW$h8>wxBscvLFOfUEn{|!L
zdQQ99ZK`mF6?=X8Kv&QWf6J|(aw9C3dG@r|TlVL-GPh3n6wuNeu))|ei)VZ^v{gVU
zp*V^*PKVV3>lZx7j)S{mYJ;`HZX{8Wy!VLk4Bm9bbVrEt*7f@A2i3p@i%sp)ot%I$
z?64e!anDA?{?@YzhE3xuZ}qN$um<==A!+A4cIP5(F_`jBhlSZ-LF1^B1>5=_V7j3z
zr4=WZ2nm(11ly&AaX5hVc)mg<OVSnRu{l<zQQRJJ|N7W`yQ)B4-&LwAN_mQPL>%FE
zO=e8_7tv)f4~Zn<V^C#0wpEMgeNMAQK>Rx;^EKu7(&>a!m`raY2WIYcIGw-s!)>k#
zU#y+^*&uNX(0EJ7*O<_TCH{qdp_XCeDY`VML?;~vj2AJHphc8~ce@M1%fCW#ZXIcA
zx!iIAxg0S-+AyKCk8kKn1r-U4cd9gcy4Oryr{wc|Y;c5+5<{+FgqF%yrY~Lejqoj8
z+5Q;a@onLK*1(v{lqSWC7prse<d^Zctd-dltCR#HsoK}%6wrHg!_(P++&93ouHNeH
z-Qy<I3N1zczr~0~`~5w~q%DOjKm;45yP2CtWj4nWEAs!KDqMgR+NqKUMetmC-f}UC
zQ63==_hO(X;=6erx}aN+2|DyaM?N;OfRqt^WLout#*Hx!AiYmK5Wi;qFZF3q`iM0`
zsB504R`me-5H_*66y8XwqI_DiaFE(r4+$D+ex}+E0r4U5=Z{|-<yy0QjRO;|Q!BhX
zPao`uDPpSSg7>m)F1k#$5H|H0%B393w%7aE+WRegpZ%VJNGr!;Z5%&Cyh{E_OFt$)
z&hBXy2a+YbI}d;n0%Sm1UtEn*TRK6ANf^~$c@~e)j%k#^k4hyL<@RN(zC7wLTOn3)
z37f-(^tSS0$IRLPfERMRi3%W_kGQECAJGl}%dIcENb7R?q3ceyy`c%ArS?kxkD-VQ
zS6&U3Qh%h`n7e}DdKR}YI;8ocK+<JOgI9BR*JY$xA-f9FwBHHdHO5I7g=gB_0amy1
zuHV-&t0l66D%B3SDD#c!Ex#ilJ32@RoB5V#gAH%9wJ(iD0dwzdHKcw@l?Zj*>|?a0
zD@~~UU}o{_l|#MRpNFPfZ`Hd3tPW2<6+||3xn<e-dn5-D2W%;7+pau+F1z>!1dBNr
z(DX&ny5CZA>?!9Kl2HJ~UYH`^(k6}?4?KW)CTsWD#G?g}>#VCJ1ag^vE8b-eH)S?{
zNr={9zr5GjkQ^jICa83Aj5nkreXG^U#Z53-bbFY9y462X`bb4CO*OSL`TfC|*chXM
zwK1WS1XDgZL#8lcZLY_>!`i3<btMUH%`#@*qWSd-SEhdEdObeGEYl6g4)PjZd$DG9
zUi6J_LxKiouqpP(x`i8PogNA7e1I2<3)Onj1NM0*!@NY2CK@$LvnuExNycZKW{eUA
ziUw%?rJt7N<ooC))k)6FHpvNYQtyJYCcn<4IM5~G@xgaNi_a4%awM=O_b8``HNJm9
zvU(XM+5La+L`OjC2X6>D34n$X1qdo%H+h$cii__EwJ#OB?s-M|j<SzyV%#5h+_kBO
z@v*E5%7Dhs%%>7yENYOZ<)qXW5?Opa$l0N*m;?aDDhzbHfd6EO2B+Gt?ac1Av^~SN
z{%X;rb?KkVr;OO;xanfb73bdILoEJH!Xks!5q(i%q!i>{ITEvuugrx<q5e@s;VVWw
zYDa*hsh3<bd_I6qF&{mr{YOn3^sz)LGHEt8V5#_H%rotI3`_vQJaer<@iUa=W)9x{
zS*L5}1}%36-EfX|(9h{~!O@A|rHRYocSE&`Y297<Lmo0oe>QPsj*MT{>p=9LUM_8v
zK~dplz#LGJ^U}5P?Aj6oh5d5J;6hpp$uX3#yLo|T$+=GHqG<wuZvOKq9yYZyDZM4x
z9UC)SIBq;<N25>+|2&GhS9|FBn8}4q+OiNi&-BQ=0~d}!+Xl*%x)SxVL#9^wu2aL5
z>bt4;^;>NZFeuHXhI}fF<YZY5d)xr#^rD$^o27s#@)t;$wAT4<nc@nQX!9WRlY~_(
zzG<83bUl=qqoRBHWULL=rXSlXP9zns(pp%{dSkmpl3KS3l4@f)FChrKB;H=fu)ysL
z%sDIz8@*x)m85e>U&-elh7E;^pYP%7>iC>+k<Pr%eFH7D{@`Y;$lcU~?j>f@>(lPt
zR7w5T>n#nrC*;6x@}o@OO=a4OAkz^35vO398ErX1v8!awz!~(Jf9YT_bDZrWL~9mu
z)+NvZHQ0boty?-tnfBcnGc>gle;Le`%!3;}jEp`^V@LmAr@T+(2^)C|e&om$fnd{U
z#XG6VHZ0SAi^O{G@1cK7`Oj_mOB@(r9J<nY0c6mnSe0ldO!Wgm!TO<G^a!$?Wt9|G
zow#aYavf+L`UH*B6;){J)x|9)C-u5tlwf%CK}(H;LL`#<Z-9etCyj}wF|+C|y#G2q
z$$#MoZioktp2Tgb(eD<IkvK4%NUL+foIX#{MX!N0<p|<-hSqeaRki==Jq`K~8_v2+
zNmD)~kb2Ix$dau-LA7W>t5RWMq&M>_iLIS8GniT2(&T9eL~^*uN~Ut*RC*1obi?Hj
zoVcC;oP)qGnoJB!@Zqns$MPApz5!yV>L3%ak{ZOA>)G^0wu`#~C`?$p|31!!lZ7lu
zV}Ue-sCJXvf$kyN(v~kiuIKD<{ZK6kB6rvvYaje!2w$qrM<su4Cj;jRG<Y=SNp1%~
zBA~5zT*RE<n7*XDxk;uoqIHg9$o5YK0RGARYZr%@TKz&hd;{)?Rq^o?Abk$ab3zjB
zbqC&s-e11XeG!CW!3B35Zq0N-B1{7H0bfZQ68VLqUyUNIZ+347nEikS-8wEbS*ZZ*
zz9{$=gQ~~Al>cZl?*EznelC|LuNNrF#MA=piR*JE2+Sm4J%8v09IguzdIHP=0}tn6
z4ZvI@;X_21rrxVdyK&crH;#-tr&T#XGUA{w<Z~Ti$q{d_+|oSOY3}(`1w#&l*dSE9
znei8objS{|02W#+1JK}qmI*;*IoqmW(JwF_nmhXH$17up|CMeo3Jnv1ZN`^N42iT{
zHb!B{xNOHvm8+S(%I!fy0Kh*x0LW^<VfX+pN#jfTDAQU?OPl3AOYE>XEjuDXGs)p-
zd!?XW>y<G9&^rbzrZSY%Lb9TD%RR?_m8cJUy#sbZ4TUA6{}a~AQ%{YYr`eyo1wYW;
zr-`mb!p&Qu&J#YsKP#g^^M)w_eo%YY##1XLZ&)uN_n?#31RQLdbU7!0?cyvDx>oIP
z)GzL%P@-H14yS-$*4}vhMG!bbqla-)-tu5iY^R@&zq($fg;9e8ctA@S$J(H{m~vpR
z3%y~ImnQUC0k+6zzi$L+>wzzf6+8`4ek(_x?;O@4gG39}nGD#LCD*59EU0$=pRW=Z
z9ROH29JtC=MxTSGxrUri%+eOf8=wY&b{EfxJW)m~>WxC96lB(j%qG}qHHcT~5^5PL
zO3<A&$?+(L54LB(uK^ULy&q0OBT>K?6R^-tt4_3*fMtx)-PCr>-@em!5+&zxWl2%h
z^D8Z+UZvFsEe+=fPNDX+PMpS6pBr-GN*KKd+8F%4UZ4xFR#m=`Mt1ued=fwqO6Uxu
z8eN1IN)$P@COGL!?tAHUqw6Npx145g)rWtLucXp-0`pKDthpGpI)Sy>eP11w3lb7=
z1D?TG%E#l~fnUiM452GLW^LA?l?T#Wo68O&?nhhe_1g*65N{8knm;5v7&qquQ?4_l
zCvirc%UnPDe&bhE;jN`X)n^RaM``w|1EVEm$GUM_(Jy)twPkWgqp(uE0zXq%4%4CK
zMPpo9993UtS)LeGIBXBj`eQ$j9X3#ji#M@)I1o5VC42GU=~QQX0!ykg)EA>|6-Uh1
zCK^>}!g+48WGHRR2;cQ$`fWscPb4*+d``m?%=5<^s3(!jB--Qt+td2MJ)`i$F0;j3
zx^1}OHgpQjguK*ILeMbbE0?q!t?@pQ;;H+!Cq8(6;9H~su$qWt0igo=<Yu~}-~JIz
zVg9OEs>C46l`{by!1nyFSD;4UhkPHpQ^I}^1b&MKuZui@JeCiKJV#`?*z?uPdM(`Z
zo_-7TzZllK5g2h8IQ3V}0gD%Ubf+7T26>urv6fN12Xg~LjA)BH=!_|_08=5ZKyhv!
zUt^!?wrkXj_<WVrfNUn;p3xW6_zWG7b*+yWNUo32I=*H~R-H$|7nwy!p0V$-Hu<sn
z2V)lfWJNtHA`i{VAc|WS7+<~>*J1jfCjAd^ETWXiVHUm<mm>eX9C};!GfODr<6FTO
zIm&P16#ayK-YS+qsWntSGx?_hlti5s+Ro9SA3=Q9IcOX<Vcydw`K+mgnT96HftLo_
z7=Bqt^CH)QB@$vRNf27;Rq`KY^{ao8ZP4){oU`Hrd%s8tCxVS-wJZf64GKR2yz@{k
zzNBs1_nET(kGcY<9)MP?<gLzcL0k*42HSvFlCj+Xe;jhz^f6)Jc{;;vH2(Vi?l1B7
zgj%{aUiYjGw?g@sPvtx3Tub85M83M6r}a_4m5sI?O>?7a6j6K9(A?=XT1mH~RLAw7
zlK4NQ87h3HHgU$~fujmJ%hGp(R2&)qwxB83(P;i+fh<=edyWD`-mAbUHlyc`kE#F5
z5n&(=NsQ_#Tbd7^uToPiojLV@t_bv224@m!*#oq(FmvB(d0o6fN6O-%tx6#G)PGkr
zFh6X6tuY<PJYjf@)OVN{5mn6t@)Z@7Fj_nLps|&VAG#YFdGisi@x!@MxO9ri;Qs&<
zEh!zmD!~o#0{d0$Fw3x9%2R=j8g;T6K|``4DET7u7`KW;bVbBBsN}B*$WOTp|3jEO
zSL^}8^!%^b+sKQCiZ2n}hdFmH9LV+zNBC$&7*u5fd&YwtUh{!jD)-j{akq9<w+!Wd
zi>7-G7-iZ2>&G|Pe7^Gse_1DI_Ts)J@I1!FEX4Km^CB0)vR@U)6e0csliuQTDXvdf
zT8b+}Og5X?nUDMB`H&FES5hdA;iK0EIKOLG$rBY$1U7sO4M=*%dA)phWlYi3>PPlB
zrrWzf1K13PxzSk04JIcfa6(Z|f|qu(>*`~@@tEo&{{2@zOg;^0cRz<`J)HWjKQOD>
zPEtQrrkS*vhovDB7T0-*<hXtc?Ui87RQ4+TnE7koLB=0$%w(YF0kaz0KeHNeATG!g
z%~9jp&JK>-4?sZ6!*~84*51RZ$>#e5B?(QC4uW(cNHGXV?-p9<gswDEKoF#N!9+#r
zy;p?@h9XT6sZl9Ped!${AV>$1-tNZl{mtAz;LbS1nB>_#d-jyiIeX5tapKP&5)(^6
zpvRy3y5C>;pAG3Q<mKb02>sCA-R;}Y62ToqxqPJHbG;%@ZYN3Vjh323XlQ#qtI-i@
zlP!GWZu;&;k9XpInVSuuS~?p6fPO(A>{?{i40$ZQL(SLLjvfsNFu?9)z5kNtL^y;X
zilB{YTS9dYs875t#wpEF4lZF#X;2ygM`z1^lrlE*A2mPk?0}Aqd&I-QjKk{$lKTsN
zd~<nU8=LnxiR7yrRT_g*2w~utV?bs5|KX$Dj0`pT$UPg+HHxk?Y2}h^tItN$tLb<O
zkmRt-r@HsXZEL;2QReOGf56t&5RXopp$JeW%S0^HWM|rdE3i#xZG!UWe*lez*z5DY
zc{4m?-0;0WH$??b&Uk(P5&J^1-#1b~zs<XBmpzg;C)4U}aLjWxnseFO1=MWvyb+3f
z!^1<Yq^tQVj_$UCtjlknHi1q8Ng{B~`qw-oUCnL&Be|ODMv6&ZLnxvX!>#O<no$j1
zrQ+|~S~AJPLx>C&B{Fm!qpogQ4w+?gsOdb&Q48LgJ&jQC^;WYY9wQe_V~9Z(NhqjP
zmn>0Jo6@dqxZ^xsRrjBFCr&i78R-vGrC*5t6zW(UWGv!F)y><zqt^(D&)5M%>75MF
z2C<c@x?CI-a|CFlkFtNe;jItqNUwv?2IN+oDaO><0_!@;GcE6c@=;mkid;Ek2O2w-
zTfK+Bn420%ElH{&B~ew$$u!OG5#i4OBpz>u>R#*K35mB{s?`K1YHUVks~2I-;d{&7
zI$sghwTHBAuYJNaF}A>vbQg~l@;eouDJ-SU+K6<%Al|~3F<7vk;sYX>OoQ<#N`ixD
zuI06dpr!=WB6kEmGFW;Ac^oO3#=4YIb6b99fAZ`1JN$E^_j5BW9r)%P3Aa4guKp65
zwy6%|o%bZ9{&{xob=Y4MP!&&N$i>0=Ixf=^2kxw^lk<}Y<K9~%=@#n@;y!pQRFd)v
z(iJJGnwL?G({*&a!8uLw^MCz*j??+MUNUqQ#d6+SH@pSxByJ4_GD+Ds(*~%=U#NKM
zcpcG+GUS$Ss8`B$B0mb|{jc_-_+yaxhOMhrZ-SB-<;s*-Z&$fhX1ekFHzZp>JBD17
zG{?SwQxY8+{)vc;rw!W@B-LL$5*RkBe#Sb)XAe|Li1lMfgM!%x)cEW)2PEtk?_r;J
zyWKDj(f(FC8v|WrbWnx?H|J7z|0auUqAfJm<L!6XmCjJ=qBoDT1H`skfEB6!5E0IS
zdEHvsG?J!e1P|h_3(enL?cjIfQTLzUk~zw88F4k8g6UD8T$fZeyj5#C`=dJ!HVcx`
zml+De0?VW>1~lcbDPwdbjU}4Cm5QYpAPrz<jP0?J;g!H#%A9|))AK$Xde->{k(Qwo
zE~$w6@PO>r5E;XEui9)8g0ak81^+(l&-?K<a8d+pM0xRY`6l@jP<(rWpK|>J3QQwa
zJin<WfR;ue+7se`_4ouos(6??awmgo%K)zGcHv+ZEAppz*@6W<Knr4~`y2<d+Q$D0
zSw@yg{P=}Kqw4KW8%6(!KThN$j1Ioo#?LcWY|B8uD@8UjjwGQZC-RcAeY(SX6_&Q&
zyTwS%VVex?AeuCFLp!H93uSVBu>L9SNU=xJoRu*OOEZ=l4q^W;e4<btDh1n8iG;2c
z;(g{$5<sDHwsX&7j@pQnEHsX!bMZ$WX)M#CuQuRm%v|*l)++Kz{Xn~MoxW`8?d?$9
z7L^A$2s`TFV&-3UD&Jx+F=Y15`_ZjRA`6LwsL(!elVYuaZ^{3Sndc!3z0&Ji<}Ad{
zwK4hbahY*wM#hZj?>J|R9nb|A!^n`4u>@(j@L;sJTb^%D;Qr#9<oQ~2CN*o2-qYXc
zKr54uqVu&r773Lw6<eDd>OL=7d1RCogA0b-VPF7xIrjR&Pp;f{S%12^|I&hEv=tk*
z7B+G#$doy#b94Q^mu<&cH6Eby#8D5c;w2+m@m9{eqE>Ct|GsulT6w|P<+l~Oj@Peu
zuDq<$S}1TF{{5PxDhYJBWzdYT<8i)X`FR(wxr-Q-248WMfrGTXw6ECLpu|7Rhf+Y#
zg%7FQMm*ou7i9})inp{evzuswR#}lRzU{{^#UJBuc*}$A>XamN!=hd}Pox^_&)2^k
z_4c{w*8ADd)mGtzZ3R|)N3LMl!4uH+m-}ul_&@5w*iy1i3X7Hb>a2&0ALqJ3{#jnA
z{WINg3d44%NocHB=Xm?q(l3S^d<x!-NrVYqdAG-29o!rRPs`*#Zuq8Kc7$>;n2$Dv
zhe}=~A@vUazghrZJ{yo2o$an)I%e3`B2EW7gQQcAzK?U_+2^`36Bm2lJQwDY<}k2?
z9|bt}!n-+yoD;Othv|}GlI*r{Xn45o{4{9${CjD7xok?|T!n*&VM(Hbj>mCCk((^G
zIGAB%5VV{W)?@6c;!)O`z03e9LR#`B3?jojFb$-muylqV+V_yI?l25p<Qz9PJ=N*l
z;80<PRXu+|pE(KEQ!3xg%0M>+NSE@2wYgywS1rObd>1$veo7R}2wZ2h<Tv$MaP{__
zF-cMMl%ZF%=3y|P*;<l0{622>J60`c14Db>rk;-s4-dwizZGiFwA^f<kSpB){l4cy
zjOwi=_#!mxie+pD%~xTD?br3J_mvIg|J)1I{o=|S%HMlWNivPWNx$b6zWaIh7v}C{
z^?bdTmaw-<E`GJ*CAM{1QlKnDkwB;)z3*teOIu;B_ILQPq1a)$QR%PLG8*(!eG8`~
z#~TXt^s3EE>E~6yRZGOdok1Tca_OD?j=yKjy}yhndvWl26ebq+p~1rOx<F?pfQA&-
zv+wWm&+&j*Cq4rrl=W$U8bCtMm;Qq3yY(;l=E{jOcxs+N$;<boAmGogtAE-9N7&Y-
ztwV@zodnD+;ZbV0$y&HLM|?Qj>t@?I$GOHIB1Jf1zqu1pK5q8k2C?B1c+=;rv7=@D
zPFb)`Mu(g$oy&rQZ*!g$im2@+hs)8+RRO^nhg)CZwAtr7nubTIkuZ2FR$TSa+)sVr
zXq<qjW!U}%N>yXF8|B=&L6^nQ`?&0~+zjssNkJzrg7Wih{UAx{O0fi&(P6o#L#`-C
z)+L<(;cj&J7~KK+mf!SaiRx#^f?I8WAc>}rsz5bycmTZx^?{o|ad?Sh&S4iB!xe7t
zO_rq$y`CC;($_}+{>FUGY4!X#$3?`~#`8pg8hBXStc~>ptIx5BKZ0AJS^#KcpRm5!
z-`&l@(knJ3GBM#!D>hmjx|Ld_^bF<dtxo8^pRYz7eUEOb)xFK9(H<Y#RKLG41@smt
zlE+qDlx;eb_I~X=Uv6UWrrO1zKdzQ=BfZib?gNmg^^&<WYI5jfq~BuH9IDF05Yp0h
zmG1+Y+3l8s{%-OOfk<e7ldl+7wD2yRU5u}nOoi0SYTB#Y^+s%TxH577M_OK5&LAK9
z%9&^HM|7L$2WBS6kx)~4y&6bbMt#}sC<)q60qmOmeQdEy?U11LxuLvBy;YK7+mb*X
zV4h(4NtxP}o<Vk`DPHEX2XXVcqrwePu1$?)nF1N(q%+W3vA*^!Uu{eHU9EHn8N<;x
zO~N^0`L>2BCIwTktD>|67j*m4!HLBB!@g9iG_{xh%?6o&>MU0y1sFVKD&Q4jTP{6a
z5|3ZBz)Cb*%fMpX$W4ihxlUmQsr}N%2NKv9N|_jnhCny3l7oA!!%Is?7>Zk-qnq*o
z^Bx$E#plsQ=(kGBP2AI@#bGzREsaK6Wk?)Z91h=)F9>tgstR<wfTLqB22Ds8qyw5O
z^|(-$Rt{nz$#-VCZ$I(AfRBNhXN+&|Z@5LqT+b;~34+)C$zmr54z{LD_U%i>grd}R
zKyL>5osb3B>MHkmE5{Ec2!U_~cOhddB7#V<<C-`1UC{L%S~Df^8JVfx)lDA;@6RCT
z<2z$v2quXl35M+tHSkq8dtTex4j+@}vndaja2xhacm$Hj>T0fJ2$D5QE80ffcbUft
znrIkCoqz5>8L5{aKLi@4*O)l!gPa)0`x3}6lcX>-OIRQiic8w~?}!n%eA2&+6}~XP
zZijD<2271&zTWZJH{nrZcz`@#GY><TQFfIad0qLULxyyZMdZ<!LWW9hH7oP|=M(xz
zw_227p^P4=z~&Qv=0WjPiWxctt!_zUq2&u@vMJiBi&m6VoD7zmiKPb0yxp0xb3br5
z23?Cmx2)qC?LocxUJ`TpH<w7hejR+x^K2cV_LOUWdf=G3TJz-!B?oiUTa%7AKo2{U
z6>l|pJMuZqCf~z=T9jLadFK7wT_j!k>lYkG9&Q>ozM9hCR@qmKtKAe$QKq@xaox6!
zbTV7gn@wC%oI?Cw%BbwBQMvKo*I-Q=qfKm&V~)XX@N;|#!}C@j)$@DMcU}fQT;yZs
zuYSF<AIbHOVLQNaMtvLq<bC10x@|6P$@K_aY^E~I3Y1kVX2`3yIk~fJre-`358ym7
zJtVv7*bCa@#5wA@tsM3K@SQ*7`3tHqD}SuIBor!{pW7dT0yb-U2C;{WJNWGU?{RP3
z`CMh_&5feJna2D%^KiUQ&(L`RU7Y{gEBg4|BhX02DWAj~(V1&lOg`sySok0^S+mE6
zf}3fv=JvSlFW<Wpe<!;$?+k#KkaY*mOn)tv4g(Txb_tS9)_HT*Nz-#^&6i;CJbODi
zBtnK!=ER1D*kpPU*Z>sE1<1x_?K{5UfWVEI#IE_~_7$Xvo4p-<<utR4CVt#@Y-Y8v
zrr*`vPFPqKu06Phpe*I>L`ffn($^U!50@vmo!$epIgUK|mkgzF@Sa)5(1EsY@_B87
z{Qa3AhjRL`9*qA5FF<p6xP<P1{HU8X$1c=Hy_dO9#7!SlR-aw%z9Cu7Jr5dsEfwDj
z%9V-sN^->i`92=@_4{Sau9{_JsM-T`6q!6z5>Qf?n~vAxo=l94=Vv#Y$QauivMm!I
z<nd1U-d)PI0ez(;><q2qS8(L|{h8kh#B6N~<!|d1z^fz{bk`Vf)=WBrvZe>&mx~J=
zKY{XMPz(4@4k|x$?>CP^dWIz(==AF@CF7gZBV4+_P@M5OUcAp$`~yjHSaQz|@Ar8T
zGLS;1QuUxA*G4b+r{eS*G!<v`k|yf;lIrrOuGaTQ^nM*jfU^K$Vk&=Pp8USqn}#2f
z9LZH3v0y>LmxJ;|+l;D7L&d&lWb1@ka_tL<#Hp6SExySS5V!PaJG-6#+c;@7O9uj?
z{9PR+y7%gAvOm?x0V0Mpdu3MtvZfB6$uO7x6#EsMSFCl+=-}vc@c2`{kQCi;4a<4p
z?h9XH#{S=Vg#7<#2#OTk6nT8~J!AOy4TAdp8AHE&t|Z+e7T*q^M+<-E4zNs?7Tfwl
z`>f1`b#6I7J9O{z{Sm+o8NiLWf7}q@o0BJ)-CqzVWPMdSR^8iBoQf?DIymqj_}%pS
zQn86qrWOn2)=hOa`nJfe>ilvlp@CaQ%p4;2cj()0r`eD}$e3?M{*Ap!dHXgxUS^Z$
zSnW<Dazoik4<wuVcDk9gEUOo@C6{_j$AjHy?mBf^E)129E(SJhr=82#7hlF7-tr_L
z3henndr^Kt*eNhq?2az~uOG}qEjVEX<DMA?wm+GOuB+tjN$}x#bv~p^+V@;I$?>ni
z=9?b6&K3DZ+3QL}&*GO3J?zrZA+re%<4q9H#j8G@maONC>-a5nh;5?7cs0Z`(^b}P
z86S|4$Av`cS;7;sei7FhMadgw<qD-N(u_}&tIIF~us!RM_vt!XG*$eKSNe7YULCmS
zYgo$<yKbm3ah88CTuH=cR%pSI>t0OaGIEPWuvEIVSBS2vANVlLl}|r*p8mXYmi0bg
zv;Q=l<hN8%v!u|J2THZ@7Wjt2ZW4Xkd~@x1MlLYd9qP)>_NNfh#eFea5LqlNwjzL2
zuR>&zXLE7-SrbmbNWA-^ASpf~^vdk-cdfyqpj~l~dpEPcL~<I*B{!=z#M{i<<YYOF
z>wtBw?R?n|<=`|(G%>yu0mp@en&0exu%?HNw9=T0v<5|~PFW<^$k%qJ5MB9&Xc~=2
zw)t10;XcKd7yc+c<EjX@`|jL&>45-J+A%>Zabn2;&-6tijY5Tk(>SvP(PeYRZ>9fw
zj_F%+eiz|=RAFY%LeL!5V;v|*-@4eZKoy>f2l%sG$Oo$M!H2Vah4Kd%)BFmBwG;2+
z`4ZqYx~UF>m_cgF5WC!^Yb^BUnOWbBXrm+#1Sa@XS$U|Z=;@vQ1Ivb5aj|)c8~6H=
z@M&<I$#hlWAfD{PeLGDUx98u^<m7VUxON015~X-bn$FGXeT9&gBk<+j4Qnc0%IHt4
zQ)jnxmsUw0ldY|u=$BVih3U(4w9ZCky7*}rX16a(S)T`ajCDkumTD!s^b)BuOm(13
zNTrLb74Wcwc)lC&ta4@aFtYpp`BFr9mW!XhVfNd4((siRA3bxIbow^v6bJYHXvg|q
z;9~&0SBkK>mIQsDg;aP=6j30{d6=2^zxV#>LS^t3WtXKa9cFqTDl(|&v!YeWTQ67X
z$7LwK_(}ttx$#<c_SI0sdvmAcDMEw$Lg1Mt!TQU6!FY`vz^_&!WuxkNQL<L93)wkK
zhv`szooa6h+;2vQ+JcBbO16+OaXTJXKaE?a0$%L>*+-1(deYvP_aI;(4Z>rxmny<t
zRo_!!0?3emyf;~jIN2r(<Dszv+VT7OoKE?GaIM-U<wdDquKv8#W16PMJ&xf|oBTK*
znbs-wNfO*3+vm9smP6l*+Q09d>|%$vHOOCwLJssjbde~Ye`4=<X{+zKeL0O)+S1_!
zSzDSTi~KLwE~UP-^qxF*UFqPkA&&-aSrQ|D^-C}rF2epSNhv-3?5p8wFrXfurB(M=
z*6_AvYK$oF2RLq#xTR4JmNHy&b$IL2i&l9{fj;FIoq1VdV&rY?v}<y!?!ZvME7WhE
zbX6mwvbkj+TBhnjh^FE{5hn(+nq|4+HPt^#eSehBp}6mLk01>Jj0aC3p8v-Jt5gS8
zsQIP3D0TGgufR}L?h-Xi9ZwDTSd2k2%;k+U%AMlO>8>ejajuKZo&J!B83y`&gB*>?
zGO#`o?A(8&5r>?#3wWS8k!6Wkl?OmWNWrUZwZ9yX@znA6?SyA(IQxNJUr$~-d~X>l
zmVaSKitrUJ$8a5zZ+0>Gv^(TG*f^f_NfFN%{YN;*z}&v9rNb|HH@qL&#!4rm>+X4w
z4k`<nBRH^J>sY}-^?R6)f5sgGb2Uq81$tI)&lP5iUUZe7e+I^(5AeP@wOWM;zRIiL
zr@-&C5l%(X=umhbm+m5SSx%8x-?nq-X+Z8$Fw7rnOLj@f!(R-NhY)Xu<LE5F3_V*c
z1RjC)$BKk@r9Okcou@g8d$>!#b>*X6DV2AUt8*}cF#8dQ;_-`Vr0to3otA0|zY`H%
zxisN}=6{s(1p9WtrPi<_*aPjc^;?#y)8=18;s3K5q&HI?k}!0zB<+b`;&$$YTBW`|
zKuUGuUdiHdh+XNYzQ3~!#ywtyMzmZ4-!Ws8K;KS6U~U}5hLyhD)Hn~UO|EYTh6XP&
zAt@Jj9!-O&ia6UQV%e*Ktv!lEbUhK+r4<<z9|(W3x}($r82<u1(zw7mgkX&?>{YXn
z@7vi0B)-O&Z?YG+I9TpIx|t1Xl;>aAi(YJG7*pmQp~mi4^(&O5xB>k%KzE?sVFgQn
z`uLQoo{D!>y`M1wyGyixe?=@)PpJ+()f;R%<Y)uneLH#b^;*+_Neu|`g-I=AI4f<q
z?~|L+hX1c5erA#|?&)1`Op5^`5E+=uLpnus!f-%YVfVvX7rNJ7<?8z5I0ZfoYDbU*
zH)(nOs5%XM=$?Y>xqt5|^~C|lP@vRTP34Vx7Ln~$drd-}?)|Ju_2uhS(YxFOkMeD#
zpA=i>E|n|>p5c`G&MB4DL?X*=Ocn5&)rf}A`KLOGF5jcvkOOG2`ZyDz3703&KB>he
zWUkqeSWR4p^s@)%=0VmjGjDuFbj_&jw~P>ZO&JiGt}!@>9IU*wD$%QKnL1o$6buYB
z37v7?<8PJtNU*jtg#??0K$YyFEN62&R=WZh$)J=MRS3nmD{we+_eTB-DfpA@Fy0lI
zyGecm8Eag5s$fRCx9Zxr7#K<eDzimBG=cFi(beAtl1&|$YujGJVc`Fmt%)`KO=wBx
zDfl*SDKM0xB6Rq(&&dZKYPFpF|AO$TSm^Oy>r=n{kZ;fgxHB(sX~^mnhw&XSk5*<q
zQ~yWV0Y>a%oh19hnPT70s+M}eDrT}8aqaOtnc>0B2w_HboV9AcrPb|_NVOK60_Mx_
zXp6~s6XuD=YW2S#L<UBy5sKJ<i!e#M(gtL#Yv(C^3uZT4?0xyUGd={rj(5wkb?>WM
zOVF-f!3_4ix*E`FS)NN`_F;z#1zb1G%G8$|&yRQU4J!Mi!~-cMExnU@qgLPPUewvj
zcHq-g2iszW3rJLme4<vOlzGmK>hV(GnJhsO|31=~J^Ck>qpk++-*?cX)F+sb`t*zy
z*U?{qpU2k#m9oB-E28DpInII&6*pBZ(pQfgufq%lJ10c$$Tby@iuCQ!AoV_(^Xj?h
zRK}2Nm?ap;o1^0#EdA~dM`$Ik^Z*~?3>>N=(1%I%AjY(~w@7CP`q-~FgA2lWFH}Kf
zY!in}c)vorc(toa7;FkzWA&U#=)IrK=X3{;!j8qh$_?DuA2rDdhvUwUoC8YXIPxmQ
zF*S~&!=SiVo&Dtwra0JGncB+SllFzLXWMa$bXS$)wcfYL4-lD;H{nQjM3h=0_DWZk
z>+Mtr9@rk=?$ZPp;Fm7oQ&@_&U#r~3t)kv^I(s^q)NNkPpyDK7i+31jG8N=UuJ91I
z+PbT1O?SYnPqk=*L&sUaw>03qCJ)$VAS^I{laI&QQp$!+pJ~Q!bXAo*TFR8IJcJ`p
z+rYAMf|jYuX%6F|ct?C*ajzyj{t&+qxu=}4qIrX6Sb$}He<IW-q=Nh^lme3FXzAxY
z{6j18C<$mKDjd;uM&(M~nD+5+qX{(_#=ti$Q>Pjc{5e0wzofWXO<#Jo*Jr>U`WP_!
zHjkcL^8cVHDjm`F2LYP)OYf|hKdjX9H5yK?Zq9I#N#a0n3v7B*dHDS}Uh^MBmXEJi
zBaZD-9SqEJ;^DY+qPY(PED9>J?LWe+;AchjkqT*lin8_I9u0pb;z?n=sletQ(fEo6
z=AF8*Z{0(A{+_l>H66aAoj7!p$f>X&Rj%5p4o(j(YlXKQ35bE1YLnvL<mwWgnRU~g
z)4hVKsCzBf1D~BfQu5%da7=aBtdWBwMV=E^EL??X00N+lNx_Ig_RX>rCyLgDolfP3
zU0>-4ySII1#Zc=^n78}@*NeoFbU9h>jRU0mK}G<HN+QypBGOe=1k^~StEvVw3e|+s
znP#U>{N(J+@{-}IdxH%Di(B)2Q<@;M^w4t89(laN>JQO`JO=++M0Dw|e<S}5%&pWv
z8?p{`I|rYGHww%J7dAm%>0D`|OK-?Z8>Bk)0hdivapyuq!&^wqOR+1vEY~uPdr*0A
zTM~nu0Q$|~7ZpIJ5OGOySO%3w$5LRk9PV}h9{wJNrMO!!#_Q@Y=7?U=`#kCmY;qNZ
z5G9zE<(A6I3Il<P;DtID;qcc<6mbGZ-$W4@{VX5JXO6i`mn&o{Br1?gqoa_5;x5Aw
zaFs6w^D`PBn=jj49?Ce&KYU~x^Zvj<ii(F?>ykgAIJ-DSVl|sFAc#bj5xwm2-Bbs8
zoN9+P-kAirIH(MvC9Gf<JuJNEXhs8sy$<ZrI@MH984xrJyA#wyOBw0Dof5SFrMfIh
zs%Y!5Wnc?n_-VW-z6{T0nVK?8r;~{NK;-*wPA|BmEoU8jxg~GuZ~$xHAMHkCCv9hH
zSNTWMR4)fvsh)pTS32vbedIMpW$4MfH)HBSWCyG`dY^N|<O|ExCe-~WU>G9Q#7R^k
zIH;oq^p*lrl=_w+snAqNDtYSK$+=gK?WVBU;D>2i1OxNx$Q!xS-&S^U(D^)5yR|Co
z+n&lVdY7Y_OOqzG_%C%NH0$IppX}H5K8x$AS_@klNP;61|Nr`j9e8Le$cseLARxLF
zxg`n-+z9AJ*d_8;{-N%STQ`=++Rc;Gh73}nHjt}ClZ7-T3WG~=7<w2pjCQ~XC{7MY
zp6*Ax$$5}^xC&&@&LrYjF*N91j48Sw?}cylKKx{i@x)i>*z%BZlX9=P(m@TNfeaBk
zA#)E21=!pDlK8P+nGZYX1~7w!-n3(dXIGJ^2hr~pAjrg^3h|1oIQoxAx-B1Q5ytmz
z5@aZ5$X)3gW2NrC=it|Bt8!S{^1qrurO`s(Jn<_Odo`WH;%#-$4^qMzq;}F%DiOf4
zf4dr`j*%tdNQ@LHr!ae$QDC12*`wII!qV7zL##r^IXMyg`Cj_poR2?Ap6$UsLYx}N
z4mg~Tir~l^kbg}yG4F!7lh^)sUH$J=C^NJY>cLwfCT`pIS!<=o3(uWHV@CzL^(8%6
zJOuWrKnxvC)PL(}(prcgT(9hIo?|Q{`*%>bf$zuKXeVYm!7DtSj^)H@>R9UN>(EjY
z-*fE}u^?TW2sd?BK^gtd!GFLCJGfQLc#!LFCr&uZRTw!bavrdH2z%Hpjs6&ZcNOV!
zjpzeJTuB>w0(dF{+CG~&ixE2T&rJpSa9#x%I{(@wv^UxoGD@K2N1~9KGn2OxO?Y%j
zC=$%hK3_PHTE9*olIjC{gwYx(y#!Oay>jm_y$5H7{kzM^#JgXJvioQiqDsasF#Wp}
z<)%=xB~Kuo81zP>_RZidW1BF2{<1Y8B<czXFA^iGR6Im*msejSyGp42pt0q^Glw|A
zog+7FG1s(8RJ9YCJHd#;6YO|P{46F!tH&}0VIYz%|6B_tRtw%7c=oalFpQVDBB3bQ
zEc6Vr_9`qM^OVk_3V;ad_C=tD4t2Nl;lgMlXJ1-l?qT{!3PgI}eUO3882K_LvO6md
zNPT2N>Xi#1S0af&5=*5xBgq~;bnlrN_4G->&P9``K&CD<w#-?<ks(BSaQ75RWMPWt
zIa)jcq7@FqNG+Ez2ed885>&@LD-w>IC0ZJqVM^5I+bE<ge`dpJvHnfeYGce0|C6+0
zrUdwI90O5xR<1=sS_F1m9wj322hZ)}NcXM_?cMYu7!g7VmkDG9b-O=^XYN-9eDPX#
z_w5+$`g@<LnwwRjdXx+l%rgh>xd{*W5ZocQ&_dI!SU7HDEru7#UOJ4XMoX9IV|D0~
zf_zVyKr<p~05pJ;?H(cY6Zwbh;%7dDtAyJFRGR)!G1fX&-13b9p&u+j<+O9oZ8$9G
z*o-Y5n?5I+RD{;9r~w%HOABCQyHc2ycK!Y024VcHR!P|@tgfJ%MH=<!i625}!-wEX
z=)xM^Nwi<U8|S$3M#UdRmr=O>H!g!c1E&!XS*SbNMu{9NNbUSXU9ueURBAe=Ip1A%
zNzN`>(OGG_6rQ5qU2d9)!MA^r*o5xEV<Hnxn#j<juq@al>>kOES!Vy5vd)UR&x3zZ
zssrqTv;GLlhj%vD7Ia}}U!N73pT0QS8)rj`*sJf!2FCmFAL-iZA}beRGdJ0hbsW1{
zg^G}|3)JdF`$z69wMBv>G2WGd$mM<19;;I4_Nmy72;nM(P9_JDCi0b1ao!ZEH+Xln
zIpmCGQ0HI{{Ezrt=6w}Hxk)fgl0h!#FFf>N<?DOt`;5n#+2&7<5~(T}w=NT8ip7|f
zp`{jUKefRVEB>lQ^;xM|S_V_BVkbgT{_x83o)7OF#c+=}AgX*ZsiiB5`{h^)7;*H!
zs<dxTvXVXV5`Q-b2CBVpc$W98H6|owx)>3du%?$wgqU+oPOkhLS9UcqlEGm*T?xW@
ztNxZtK6Q9-*@tWL{>Wcl;5~t=Mxk#X^)bd8fMHR2>1lt09!^1?#*dk{to(MIv#HKY
z%WlBBxM{BWf1j!?!Z>Kl-yr&h8h=FF>`Nuc8udl7<@91dRnPKiS?ykH)b0%sHcE5~
zGv`?L-Y5RDxVi?DCcM%9fND$B?n@Qz`>Wi78`3AJAD?xK<H*qS=pW3sLK8Ub1LC?&
zjLnUvXgZYfi@&(E%cA)=d`|+1Kg@GOYYNwD`3Q<vl>!C~cU2TK#luaX$PUD4GF*qs
zz@7*Rg--V{u{}oFA&{rb>~{QwII@igqINCNc^x7ZxS#lS<{hb{25cz1n@mLA=*~BR
zrR%t64M+>Nu3yc7WGBT>DiJ&30SDQeNeZ+tRrs+oLGq@}O;@B#!w>A{<{))s3*u6t
z05TD4cA0ic?}X|1HRrw+2k&_x_3G>wtTZGFBDh;;)DnjjV&RF{y$LQ0e!0aY{IQlS
zTO!t853&czz0SMWiEp3|zlJQ90H$cj#+EWxmTZhEKt%2X+<C7Z%9EeI+;q%JZ=7iI
zfS3i$nIUoI<lIr4Xo$>!n=aoVye4a%rm`qU*MSUX74VYl%%?sF&V(^SdLs6VB3nQy
zy6%{T`1t>lh?fNPsH1!+#Z}}A;m%t&<g}u^8#efG=$tkPIDu-^^ljizFxzKT+3aiv
zi9<QI3C&6TqGXN2;P<#fVq)jGQBZD1R;ciPG2Ho)7vT+bZo~8@NF>n!UxM|sq#C;_
zKEsdyjM;`Gn?94*U6)%_MF0FE0rHR!fm@q!khKric}n-bsMhrVY5~&!P1UeT(Qywt
z1}9GRia1fj8YkN-8DWVyl0@&7(0A2bFXoZ|FPR-m_$=7`DI}d9kjeZ&#KX%&m&icq
zbthrudZl!Qon2!!>;barF1rP}MdDw2SBTw^?z3E2pMPk`r2uj^3f=3ndN?UnSS;U%
zwEx=ieE5Sm0U&Dp$HPiDJMivd9oRhbMJ3yog57j)Ev@(~6HfMVhwdfxYxJ?=BoW6c
z<NwYKq=-mgI$-kb8l|I<`L-E~bde&`!F`Xcy&i2Mlo<JucbVLOvbVfkAhh_zKF95w
zW#}`dE!hDPqco^2Z1DNMD9buxE>ex;o*m#1yJ!gjAt>QRe!a>JL7^E6%-{?A;kJJK
z%ohpsD;rMhl32%|>Yo|Litq<7q<OZ??8Hz7yN4xuORBlRtM&3u!wqmUT+W860@4++
zA|Gt-xVkG6^^RpMQ;Leug~Qlo@7KYV%5tL?H}kzS#=VCQ1P<)7t!c|8@5x;9W{Oht
z@7J!h)u-0=osn7{Xe6@thy@~DUdKQmC__MzvcY;St+P*W6MhLDR-)%*m`bX0VT#J?
zCI2-OcXQJAyCfF;;vlQ*NZdfh?g{sItk0;T-|gKcm%DJFSRr^iE-1k-N*yY{+!*kn
zW?2hXe_d{d{0rD&X?vn{{M^M<exL&n{6HHdn9)t<ogrvx9(tqR{`QyhRwz6gjcMKc
zkGMrN#H3E9yNz8BK0ubD9o2xK&Zc|HYVm%~Dl#6j34KCA`*jsD{4EO05Nt#w=0)H(
zAF}6@g1D0Sj54Njh+7fn?-S})e~6h!M`7NH^r}Pau85DUU@8GEgUMHB^lC3INA%R=
z8L_W&3q*Rfirb@2O>_CB^_nT_I0D{%%|23J5Xu)sZoZIWK8DN|g^Y4dCOzr(Z<{MF
z_SLZ~HAN@1>fcXtl!jVF`S3`+@}c{vm2v^e5_BN|!lqe&{+T17^nFgvx_z0g>qXF%
z!IU?m<$WVY>gCx=uOE##ZXkMPSsGK>*gtIe5HE}AGt1EmGZPTK)l3auOzUkFtRCtg
z$IBAAK@%-}>#p+VI(`GMk2T6jB;Vu2vCf&|Q}EVC7*WRIE?WE*{0P8kyAeOJ`77<<
zcDMinCt(zu-~V?7Rgz)~eGq8;=B-?;A8WXy1!Eok7_<%mmLYwAm^{vd<37zv;2XIp
zk~~scym0-1ov4OLadXqoxj%`MPpxLq1y_UoAU2xp3s%p`_;9RIBs|dT{L0eG=)We#
z>#5Yy00PjAT*1zjB?@46v{-#n<5!_^6zv>LY&z?;*Kp(K5*ECPL6zKFECb)(?_k#J
zX&xrL4+@5z!}Uayn4L@slh`wLThhf6sVo=uOA+ACVx6AdCj(?HHg2MX*5V|?$Lg03
z(}2YI-3|X6f1-4vgiLsqP*`V6Zbj!hs7GS@fNe{f;A8hC(mNs3)e~iU`h);$rK#Bz
zOi<6S1ahET0ufC6SiTGrMB{iP?A(wew#fNf(xs<t`t_GD>$%J|3s>+1B+81P75bDm
zKJ)QGnCx(zI^S^H3byb}1)dgJa~bE<|M}uuO`LK>vBbp#;jJ$Ksoi}@Mqnls;G3}=
zT{3L?Yg_A{U^XRwE#)tfRv1Sr4~DJa0pltsifwnB6<344zrp6+e`j|{-1%5C_OJ)e
z#j3n9B3`~4Da$y##WhkO;f=5Uo+{R_s9`S!a^NnXe8POo=vqm3dzx=k6YW!QbVi)i
zm2ZoTAZRLxdhUP`gwBg<dTTP3sh<pPM}-IT?ueo`>+_Wi*i8qc44|{r-yL|FkZmcO
z48hfkCF;o2ZWT>-j7jn-CXa>9HgmWcANRt38dl20tg~Ku$=T%F4Io4{V|v(emg*3@
zCkgMLcEo1}Y8TIxBV}F00Hnp(7)(`74q^f^&bPKF>=?yw2#shW=`OFhNDRcxGm^Ec
zBz@GLNFr;^&H05?&*q|vJU6fl8HhASU7pd%^rHVMkCOCru1Mw8lepIe0OU3lXXtZw
z^VuVVe6RHvK)m#4blCqi`V2=f3;l7P_O{?1SPMxwfc8gWapS>8PcW1Nl#Mx<O=jk2
zZg!K;?R8)goMiPvwPpViVxYZWpa~|d)DWixN3#>UD79afta3Pj^iSh@&?U|rQwQJq
zjFL31aI!lvo(r*uN?Vr(pme4gv`=&A3jb?rdQ&%WGdK6x_VUMQVARRyALB2X3SL<@
zeFd?lh~@ZAXVQ3xne_=xF;RUCNlQA~m(qI(v&mX>@!Pvv24{1iavsiVA#Go4Tf#i1
z3U7D}k$5+LSvP6_tw((Z`Meue#XWIlnHQy#eO{qu68oUybDoL+<Ahh%y~e(LUlwVi
zK}1-+(@zM{gpHDSthM>rsoHsYOqqHdg>^D1vrAQpmpa~s%3VGtX#4t8N?LbW!bN5r
z@kJ&2w+G(1YSgDYCxYeurK!ri?`$`Z51@kxlD0?vA=!$8&V9IdQ`ec-IAZ-8t31lI
z=dZQZ58V~kS&CZnC^dBs{gpdXjbJZmCXO-6CHj1Z3*Ut_8J&6Euj~cQ1rP04?-fAp
z6$UIEB9%TN7@hTN1@zQYhj=ugMNsOyaFLNv{9_^!@gZ4@QVY=tMu6gB<0|4KJ}A1D
z`g)o=MY+X^FWXr8N-gY-i-OiV$Q7|`kk^3x-h6xl;4to57xcARj#~WpWye9-1DyN_
zb+j)>WtR`@m3quB<NrOnMp0@DLbCclmQiYL@|+gMU}t^T3-ElVf(*RCU-Y=JZDryE
z{7KtIIz_*1U!sZ??D>JkTTqj?qr4I1oTkKwWxnzmNsK^Mh{0V@75x^bIEnJVkHZrt
zfTSIY_Fy@2Gb3)QSddwAh~#8Y5D`z!ocFN%QJfS%)C8ik{|r0g*;UoEXq9M`!Uk1_
zRJ!8Lj6`<wef$ZnjQi%KQEDOs17EgnC}YiEI=z_hVdXRsiK4E4WcC0Z$HIK<K#(|^
zUwX;xY=gQMJy2M54<5O%K*;$baejf5E}N{8jq~1$;5T#(`V*7~ZXM0+Y>Y~H_u-l-
zjfR;o)aB#v<*TRSH-5eYK-lH$F=fw+p?yn-_kfFzAWW95J>{rBAKP|&2GW>iPyUXi
zQfEX&K5;Co${4MO9;~<t*Q0ns9(z@9^+ep+$J%I-Oh!n&d1y1gNPG8=SPKqBoWn2q
zBc!T_G5ZwlSvP}(>clRE!_i9^N#xRaCcX~|&IeT>;WZa39@{laqE9_tGNj^#v2)As
za%}n2e&&wnleMK}@&+yRxqR7<+!C)ml{vXw9{MZfrK2C4XI_LkdOF-z59Jc6i7cT!
z!<ZoMB5u^#ZdAtdJz?&LVda}_l(fC~q;PV_6n3wnbDA>0QZlawtqj)=J&RoOA$$f~
z;DS$3%e=2gP{wS>;-LvrY)ddjm^lfx8kujsWp)pS3pO9ZoX*B(-~y7cHuy29z2<dR
zgtQ*Gbp>KqL`2K>T<TMV7x&QaWNnEPAkeK&fQT}-$%}}O1mbHj+gKSkx~J9Xx^o0?
z;Se(uRd^t&O`aC2#e!#yUwj6G|A-Gjab%NEv9feWRj^HxxYI^T=SUTq5B!(I#OV%o
z?k&e+l&x-d)1VEQ>CF?F#i}Zv32b$|u|Q?%3e?O{-cJzH0Dz(ztq5SJ+n=W%jo!kK
zhDmT&as|#BVRD$d*J6Oi#@r!01?>gplp&e<0;nZ?WqJ>9cB`@w)<FuWezZ;qP^FF)
zl<rq1YvsHpGSFO&9!tcsB}DC6L9BR~bzBN6jzP|&DXKIeFQOnEYx7h{e1t2Yl8>gH
zhOEt+<Uo1L)XKpyamCTtE)5@`Nzo2cK^F*aMqdz&yN;}O)o&~Yx4Mj0+Su&!z}NF8
zlFs6hR*$a0Xs;^Y45afcS<*@jVhWt~x}cJt6to>U@U4b24p3>M;re3P_NRz8N-UN{
zgRHGS=iurX%GesFD-ytSEg@82g@hAYYPfX<4uw7mRNS#s3T8k~--{e0Q*E|ScpuyV
z%OY*dgmQ8ammrPVCvQK#fzwRKe&(RdwjF3T<K5i|W;?jHjNH4_$`USs^k$Wh{B1=j
z1bZ_1^n!(u(8xDD?ovd(<V86t@fl%kQ9)w8H?!xUA$SoMRir>o8%|(TjK8dS$6>(d
zlM|*(s~{S|jzoF-k<?y@l;)ar(`sU)S>s{b)UvDcK5p3ICe+-jyb80W1JCvc;khx}
z&CyNa*thk`CU!CG_Z3ZcV3WQw=rnXoQjis3Jw+o*&n0n4NRzz%NZI3_of6KCmTZwa
z(pSube5|gX<68umy3Y+~i!|&8r{0wRxGz5CRwY*E2X6G^@*$Exl9n$<oL!UM(}xom
zFJ<71L!xFUQpVJSV=oX1=)}K<&2vF?$)ePz4|umS-&lyjW+{o^Xy7NoH{5JGE?Ly*
zs1kj98FCSJYYle!IstuyB<$xO;b2~c>l6IDa~^XaY(djz_O`0NEJtPnHk87snNEoT
zC`{G^Eml#6>-=Q{a9l9Y6+JEsfI=3(E;}bmNp14&K93^gE2G>;NcJv7`?E=kPRwiN
zza6Ku5D*$sBith{V*)xRAwH9Usl?W@Q$G#&f&FK&C^hhi`sw?txaoY>^+WkBJ0eSB
z;TsbR?sy)@Ga9iVa(5d70Ut1X#adTqMSsDC?HS1vP*hVh{tlZW6RJO@)l$`?Fz}lU
zWl+$iHOm@jlAH!Nz3*;!`o^L>{^%QWrMDiRi`k}iNL3H!L`ntlP?%9h?keH5;5bEh
z@)>64YaK>vsE>nM1@6agYW-^n(lzMQw7-9kuM(p0k)~G#kOFM_?53B0JtR~T#fVeg
zifbuo09IjMsU;;xO+rE5t_TUZE}lCilR#70NBV>&di3Gp)OqAzo+1*(!R|bN4v6g)
zmgwu`d-(qG#LVS8b&ujqSUI2#WbGVVxu6A(z)6B&Vt&l&VQ+}Q#rToeQbkI~n8b_{
z#=e{1@nu<lUWn8C`5NL538kK*d73C?s+X8)$Gr6p9{_H6r2?$z>2KBh)xvl%fAg7L
z!lR8#5EWLo%~k9SdE%?<{C>>+<(`MbZ_}-Op({FZ&`Fprujs^oCM6`Zunhsd8t;c-
zkC(vCg}Bl-N{i1hR3F2l)V%l4(QPm6l`otK38fBcG(d=YNB&e=$n2h6qSkaK?NgBF
zlWPD`RxRhU(`gw#m1T(!IUQ;9acL4S39Mvogw@9-K0;sh@f|Q)E$LPUKA;04M%JD*
z@sQ2K!miO+%iu&hAQp})=Z4MDxYC^9h=a*^NIM6G8UJU(ItVhJA@fZ5KesA#1*Ol@
zhH}c#ZZGVAb-yD#OnB7WOoHHKUNs^V{Sz$eF<zmOhv0(2%8AwlwMZ{z=diCiS|L%H
zE^Nyht3h_V0QTeUTgU~2`g7d}y45dYtJGro6e#Kf^`Cv=>t7R9udj&mLd@79r`c&a
z+1WNb@OLoV6JN8a)f+g+AY;sODT}eSA)+4q&ZH?O?~s_v{LG@_P!$-03vApLkTn#?
zy4uw4Hy=X!=Tm_wwQ7G*Az)ZafgXHrk97MBu`7FHk%R{I3N<n6d@R4*@tSBBv;jmm
z{?#4XANg2r5|9fHzbpDD_^F8<Vz`43n_Fts{3>cst0~>>#q#x&O9vfOXP{>j6LZyf
zC(cVsTmT5%Req%Uq>w5}E@kxSRazGF{&tvP!s1N1cIJi$*_Kxdk}Q)>j%n<}irUa!
z5at8|+@u23OkSS2rJKAlwXxzcQVq@@Kojwr;Xs(x%V5mxKlfof&}08H0vou!(py)|
zWLTo4efN5xrXA8QcmPT-J22bhzjUQ+tJY{Z;(ZDc?GbfXq$fuM!6HhOH)s6xi^C{>
zsQ(1>H5d;qum<ANL~?hawp7vJmUmaX###XMigo$QnEia0&RGRS#adV@<SQgjrFR`}
z4a9H8AWP1)93s}@F7Mtn-Sy<HjM_Uv5UCDk{Pd`g8P)G+h+sS|=MQiAuQBKEM?;jq
zipGi&<9(&AoHrJy4+HE<orp=F0Peas)wk*`r;|;jCZGZQ6^7C{nh6m+9cJGQuv@@u
zVoM2AY0~6?F#uXj&bppZFP$wl2JbY$P*5DFi83~UbAw~(JeS4_?{(+jmq=)-qWz&;
zoA`iJdko$J2(NY1MXSMaUTdo|b#{l30?wxKDaA;)*ga^d{z?Np<!1)o0zgL8ZnM@@
zaFFU&7g11}=qwb4M&Kw|pzpFdR)vCLGNw-I{ZQ142t}R_M%kzJvsQXjt8CK6C3;sG
z_K!66!=4n3#+&IY<^h1e60+>uKvvFbk_(GCUYoh=wIR~`2sPXOzE5M}jz7*#Bk_n`
zGbc_kIV-ffR4229b=Pst@W~OX0HG_grj`?DD<pe*H=}<+*1r0@^*>8^aS;Qyy`KUy
z%6PoflI2!pPiKA<N5{DTxu(O`J6mmPY3{mxQN4~^wW{aRJgHrV*Pwf9b$GDk2T^%{
zoO3Mi#?z<I{pccElF~=FZ5;$>=r2VaeM8}cwTxT1`8Sj~*8Gs$uZ18LlAd{!xVo>F
zOwm{L#$%4G8cT-O-Z^Ga1f<vPY+rllI4jPP0PcKix;&Yj)jT8=mB<bU%g7UvJ)H<l
zOdsu^^Y;hPqeu@ukLidAK41K(_eC&7q~mI9sGqs8YzPa1c}|7y6ZBiBo~=tVEL@T2
zoCYzY$C%stqrY_*R`>i|rZ-v2ha!PWoq-z^xigpWh*AROT|Ijvhf=M}_-p-9Vfpzw
z?)kp##em>1$ML+OCcl3Z0z^jHTR&6;2m#mV`&b1vTPHO8wo5%2!T2u4fG-%r$v||e
z0vH3*_G7Abn^50fyv3!6A&n$74+%#+yA7*z$Mboe_((M-*nG@|=y!hrwsaYNMt1!o
z(JL2)Uu#sQds;sE%r!wMhA+|!vIW4_{|Bkusys4XkU}3rA0SU1IV%*mzCri5UqK(}
zNG`O7=DE|e>HNA&7vOK#D3+vRoA~O<ErK_Iy@D)}^#gl+{bu;uTa{jf??jmsr8u#*
zYvjlLz-%A&yI?B0DWe5;3$mql*Zj%acw&tGO=5##4*){5)nxJ)3*f^2dWGFMQJuT1
zrgSHcu4cjp9?7ZhBeS*t&jo5vF|O`Iok-hOoU+K<GBnoo!iLJd2=iD|rYL&Lu@uLp
zTp}Ni1~ppuZYe5>rw++PLGu7C;M}?`2AQw|?>87z5E}6zj1g%oyZ96?KJydHLOuCp
z=Z%~{<K(y7D^7i|Ss|f4Z4fXxUIN`DRGRqRf(POEJ}!A#ebiiOV@0<;C%UJ)QC?8`
zt}c_V0z1(Bho>lrxDqCJO~_0&n8umP_GQ+KIW0X;_APseXF;!}v;M}#*iT3gC6>qD
z_8h->F8|v>Buz;HCw1f0<M`T35q|uB?Cs`6!~K!G!oaTao5!IkS`_wRnhpH+`8Ix+
ztkwDrI(?vY1N-__AuQZVz@km@s`v<xM?W`?m4XSFD1Lk&KU7^baLnKpgQEMMiT&$!
zZ8vXH&sp_n{MHqeeze4lSdWYKT%lyI2dy(pW$3mOLG+8n5?!ny%|iv;0grU%LfI`(
zlSWyXJ5}T_BC<+_sa#^)eDwU%y7PmC-_xzq<5^JPk%3iQg$9$gD>A3qhDnvnujHSq
z6F$7LaEX<Ls#3)UDxR9cgX+-fq0exLQ6_Wv-Gsk8N<r*dbLuKWs?>Ev%PjMne&6G_
z3gPb?i?XaIGTBlr0-Xlv*H93E0CYTi2XttXwXOJXLKiPY?mD?bKb)JY@$ZCksPAk-
z?e{*iM@W(O4+?PUnLKkR`-fh9XasSJ*C5Bhsz%~hcWYT9_8=o55V~*>M8r5U@Lh_i
zxj!Z6yUlnD{n^2rHX^)>f5=)9sPFL`mUWSDI=v*F)t)9d!5#?PXsr1TT$by!SZRCP
zs{CIQ(}9~I;*GU>egamOzmpErK@5`sm0jgF7fvLE%v$cn)d_}?uo5GBW{Ek68mRpx
z;o|;<?yJo7#_Zpt@V=OB8w%G;YzCFUZB<Uc8fqHG(2=$)J}0OLPnf`uC@WkHOIb1Q
z|2!d+{p&&=2DXw}E^Vvrb-!#>2}b$u&F&bga7!Ss;fEf?430cF2{|Y0Fpj?8T040_
z_CFXsK$1%NiDZeq%_S#Li`8cEdF=z89vhe3E@0(zXm@QNCl%5iSex@Cg$JvuSb1%D
z-(U;~t9y{8;c{2GvHQjE{<v`EGv~jv$%?z5ej$|+`6?|;m^K|{C{25CcyJuJ+zpsL
zoY4qe&pb{+kb0S7G&Mo(Tyu)4WgGwLpX{<YUl^g3cmAv?@S5?sX~RUar<a*fNl1@^
zOp<mWP(B~TNY1HZg?oN5;bSn{i!fTs=%Sg=0Gx_-(C^<|b0j1JaggL$zAaOHm-SHn
zT223OYffB?nEbxN<f}2kul@|OZe=~03W<~i=v=H@`(D%yx;GS$8J?{@6WOK2F5I+N
z?O;Nd?7in!QJV@r=8N@94yshC<UcFmu0M~HiH09Zi32N8jrV^+R5ktzU&GR6tV`oS
z@&ph4y`e)1XKbpJVuGH#(^%A5-Io(Bh(tLEx}{`Wu6T?;9QbCLrcwSn0iOoWf6!7#
zx+woxfe&YY1PR4}>}uXEX3ybzSQl^y*&M(fJhSxL@ZIyZ&m(OiMVPKINSP;TGP)tx
zmY%fxX=hOMhrL4@_Z7qicio`7o%v%k{1jmTkwNTIO2x-9?C0w9hU|k#qP;ctATH?l
zjP`4WeGMgb5e4v>A{bl{RxS)2)x`4y@~=fHL8Lt+3w-@bSe!sYUXwF6>OGgXQtVrW
zu!9F@vYyv+wC>bMZ|5yHpu;+qD4RMP@%*h#d9hQeLEgf^$Eph~%>egjrX3L^>Dnsj
zE5<L{&*rOg_HpX(<HruDg2~@e$D*A|;jbQhB~Z?3@^+8qLfe!5*<RFAv~h0Ifgznq
z5>yMETwA~<NLBaI@2i|~n3p95F)05zqWM)gi|Akk#A{?e5XC75Gy1FOL(N11Cdj0#
zi#Ui1T9WN>2}%(1dPyjq<idOX;_9?=)3}Q%4Sz8Grgc7^{0~Fqq3h<o#aonUvhWbJ
z&!f-FIx*fXfbel5;X2ShrhUgXTO#7PC^)^Qo)b4K21aLxWZyYyJ29~vWQ;4I$+UrI
zz8*7bsD9!Pdz|VgRsBhNi?fY$epi6|wUlB3Iyn6NX$xf|uJIeahq&kFtcBfAufa5S
z2MYW0!I1YuFWedT9hJ0>z6j$Kd3g8iy~Df)%X5sFW!ska1-LcuNi}JadT_Qq<#uwN
z$Ivl01kKtxU`<iB?6;fmO#30$A7SMubL>^-`(RmV0i14&z_>P98B84>tR{N9C;tlP
zqCNZaZ$7w(7+BbaUxl`c1zO*9qw2!*E|wb4y#1)b5vit=WY#P^=PkeEC+gg3ZfT>l
zM!$`z)zML8ciy-$5NOuw6auX<4tzau_chagt}>+iA5+$}*L;sAh}$3t7BQulIdTQ3
zc+3=x`K<eSd9?Fu>xXFZRX=<1n24JY<E=Hyna^&cB*6(sPt-Wb8!yYHeT?=`=#aSl
zI;JF4M!+v)(NcAXBE?^*jH&5SUlCE<lP?}z15^tW=eWk82!C4sZ!OGQB;Zr?PQ4bh
z5$Kbmx~$=2tvf?3<)Z5O0z!`On&jQYNSqSPc&5WYE_lnDk?)b~L%GEy&iNa<%|#~S
zg!ihSfh%syGn>lk_ql<U7|QxSY$ymRNy&K1vU42umuX<-BEtr$4TUaUBnU~1Fq@=p
z>~y92cVE@Gfw2nHjhNz_=WF@(Bn%soSm!hb744=xcoWBgUf6LSxza@?sL}<cJM5pu
zbN|Zc#rZs_XLB~0^TI;cZnG=|!74<ZTVI*TQYYr3%Z&&sPp<AF8b9GfKK@9=pSFhN
zg+%+<3ON6M1^Gm>O3`*Kv9(RK0Sa4Go-7U1{~+NZS`!#vI-)FEfU}vlI7hh;r7#y<
zZ8SXdCnEB^d+%8065HUf)oUpZ{Pry^<P$cevAiGRXB-9T_nVc_#87PPHNdI@c5Orq
zY)jldwH*yhq=P~{_}Fql=~!kwX-K^4ch)e6mQH$!oZB@<(To32QQsX;_4~%nvG*pj
zvNv@IAsNTW%64p(W6x~iC@PdPl08mFwj6t&uae@JS&^Ncy;q+5_`ROz@gH8F`*V-$
zzOMIm-S_AHK7T&1+<ej0iY!$uj$l`nU+&byyx`|BW)LUQ<=ebCzK7dCx7Zuv8uo6w
znrVoZtFakz9v~V{pAEMXX&Wn{`nsO?=(QWUK_YT9<911$19`WrYs$3<t3<Y?7oWzT
zxnxB3OqI4%7PSmU8Y7{|v1H%Jy}M!a(=Q|DfniG?@^3!PBozb3*So7QKmA(yeP;8p
z^h>bu@4{p*RJ-fww|O5HVf$P{;~Rp9($Tk>WAN&3lxtahTW;j4Bg052wW5q<mWV0}
zTb?X34VkRp<Y%{HDAWCmQVLDMLG_PXt^a{uR=&q&90q@H)lOdhd9bGv5N+-2)DyeF
z3Q%Wvu`PN$G9_m66PA3C@u=a5qO$$~oBGdkow^qu4n_>4xB5$t)X)F#U4RT>j3cH3
zRA=>hLRqFYTpL7-6>|7CpR&`4*?^Jw-u3bN#?_-|;|e|oRN&$&O6#el=4Eo}6D)T(
zS%Mu=VEQ__P>7)=9=d!})t;3~)3J@M{MA6Cb}P<?m#%#un~?-aM+)WcfAnD6C|p@c
zaEwjO@+aKdzKLo5G12sUzd!>{ACwIi_Yv>_4OH5&8qH5jJfZAWusO|QcrEZURg8-V
z6D2*j(`tNk-^`8h>EMkSO$Eyopf3rKgG5|z$~Z)L_pT=JEn+V3ANj8uffb+t7h+t~
zy=cJ-XkALS-+_$B)`)Eom;@RsQ3X+k(wYL=tHgxDw;B}~<FO4c%=JgMw~GUoNcsv+
z_uMu9TOl3lp9pV9Tr2U9@u+t&4l53&plx>Uzk%EER`h3I5I?Ury!?<!;itVFwE_g!
zBikY8uWH&ve|JnG=#<__zX|A^r?z_HkgzghhNoX}UYz3S{uXjJ*L}~mZ4Ptv>0f3>
za0Z?=Av<XcnMMAm=an%t3`Y}Jn_dk}cTOQk+#%zV2p9|cYAoO5I-84+^hUkynT(*l
zl8~Y#wvaa61C}39uS&d^{=26BxDvw~43kMjwz@mbyBBG)pI@d+3pOWsI+xrfA(<#l
z3=z5@mU|^_gpgSa3%hAi$q(uX8TSETN`WDrz&n+}1*zU@0w1rhjP}p3#>fBggI$<G
z<7)q4N&f1?_8Uqrp;5aj#aoV{c;?0>6u7Dr{x<LF6Sj$345#!$q4C<NZ$6!(Y0lf{
zQv&#xe6?xE%*8nm+hhLj1O$WIM0x;3E-x(P3%9;sA0u`I7srS?PpP)sa4E{gwQ*UY
z(X9NDcZDRK>m&M@Xj8$Pgpve;iEK;ypX6BhmAO5o$0W6tFVmg1XR|QPkshC%<{a4o
zi#@eBr%Om$zMt}EWfz|p{33mhpKNuS4p&$*@FD~@IXCs>rgYav=`k0W4wW5hZX4MW
z3NPLYOIcQn(klymGoC=dB_?~(I1#g!6G9yTssL2_Yk@itF1&D!^l-}&d6~4DsEZ?Q
znxqtw-P{6Vi{$-x^RSZ3G`Vq)DOKB;dGMX!=gYi5zY7Xa*uV(Y8hBjCZq0gqZDm!K
z1Q60kA9#qCw9_}9WuXbqA}*=zqQb>LQi!Hi*6;(^ym>#rnJaoH(I>%wV16c7CGKND
zTu{eKa31^5`N50<4D}rrT9~K-u0Hlvf0dYEkP+oopYr^^v^15!>OfbBxBf0=B1PKI
z4N}h_EB@Ggc0Sj_aP7|2U#6jMfv%r+U;Y$mQ6!$`iRrP0)%YzRv8<mr;jP|rdboTk
z_)g-h0K_1HO|Nf!?N+C$YvPEu?A@~@4b~AuWj)#ESZNN~4*C3S*Tkkhj@h3opEpTH
zc}E1L)xSh4yeb{Nr~=dX?L-`m*zS|lV3Q|r47dzJ%q+Q^%dbsdLtDl5d2Gkfs{J)z
z2!&4<@McC{8Vt>|FD?>7t7w3kf#UCCp`=Xr=~s#N(<R@ZTs3zXK@0JCw?&RE__alb
zq=x#dd6A*T|CZOKPm8qt2z<JphFsYZJ$R>b@$y5CFb6qr7T~GsuVCmNFyl)L&own8
zSb{VA>cNGg%l$GwZM~#~)77vfSIuh&Y6&YFUpXpqv4&O6QcrFz({I9w=I;I9*KbA+
zJKr}7ye&}2x;VO6sLTgriLt$*q#{Rf%vdbjQDqdbo0xxUkv^QUEjMfV&|H6G865PY
zl$1rUR`>>3VW!Hn=G(EuSmCu^xeDCeG)6V-eU8`5b7HpP3&E4aACDWR!4ydFYoFRt
z5M(5AGDc+7?4K>vRBF`-`gGkPv#7l?$fSLw>{{k;@C!*L*HZfiNf|w(8_zZ<a2j3r
zAp1*uZR-=p;=-QN8*f|6g>cX&Yr|~FJJj4Fkx%%|`K3Z})ee1e&I$zvQRAe6@t)nr
z1Sx+p%_^`3h4qU+mBW_~!5+O7iubK+H(%lQ`Lf7-Ul&@Zul2g)Azw)Le*QkGy#l)<
zxCj2h6iI`p%&(*sW6k}MOOw7er(xkKokbq5mua8X!-nNqPX=23?;8BRz9Uv;feW<N
zN?>VBP9L3&h?vV};GM@y4?q16MFYMLOB7eNY(4&f;WgPq*HwV*@@oa&vMzbCtP?}v
zU0W;P%{SHD+k9XxKj4Bz<~jfq5jMV?QzbyedGB_@{+HEO3?!Np+#2eHCrhg?Jspy+
zE{SLx1-f5cK3#xb0>r`sjbE?8VND&#6%g`K4YKnt_IX#X%p45y2L^`<YnvEj5YyQN
zZEDt)x54%1I;vF%%|AnfbXFX3>L0ZzY}7dx%&)8|4p@_<xcrd@oG|D`gY3fPdt5MP
zEpD_NJ_)+txO$Wy4@0p|KAshO%63D$q{tA%iJ>yNggyztHI>7&dHjt)=jxdZhO;a*
zym3{w$M9<_-CKga54e^>L3{$KfvD_7_Anr6+zTM8a!{#^<kMEW8M}`>BrCZ*k*hEF
zgz<o?>DuCbFoM1NeXWMz)<)5*5a?aos|<iwyr0wmZnlZ%snYrfo<Zp$>(!ZgX=!aE
zfAD=|-f2$E^Qkp6zEg-#*P&Q3Npk*XOWOGQ{@90%@FNYAEDRnsgqb?_KxlgpXIvXV
zQ-X1wDU-!6|F!g*8_TTR?0P<z){y;co&$0#hHF$}G-4E3HA}6Be{>^`g1H4{Ot?s1
z^H04#rwD35>q!WDXv^$`%o1iors9aSMHMtph*!@njRL7@Ui&lSDqGRrCHnTvJ&+?h
zStWO6a9a!<2K=UO5fGY=!8kpC_}&qG&x>KhtYvvnR<=1*lqwT&@yWC&BWka03)qL+
zQ`n2o-yQp@ZQRP0?h=Y8$1Bv9e|k+L1QW`4@b8yg<o@>Y%^~Rq!8?}`0n7bsvptwW
zmCxT2D&V%HIK*rfN%8EVo?vZsgOZT#`qP&UH*Ag`^d}e@wU2*j*z@6Wd92Ftn)|?X
zg5#Ln`=$#~XUR(}P0bs@*0=Qewk*wwh5Y)c-~IFX;L@&9V~XIx*V0p`DeNTU(9cuj
zNCIuy5K)!`2q8G3DVpKz*7i?K;H=ZgdRv5pZLbBUv@}{-x5RN31r7WoVDjPRzxPEy
z)4Mc{(IA^Y{ZkDd<<kEctKc{CyCYxlB0-j04RDWY_f|s>g6`cSYl!#D`b=>#`Fz=V
z-ZrT#^5hCp1>&+x0Z)KxFJ1u)4Hz<E)t)*b1Y0o3eifu_(TkBsN#xR(g{Ks&J=z8$
zBb*<RYFf+oBRR@(>PAmma)zC%O16?>Feh1x>Dx~{w2iiMKaF+4Li0DN2t0vLJNLm^
z?X_7)fJ6e{r?(D^?LpoGyXAzt9v(=uk0(kO9152-SN$V#`I?mO<+dh+0-w+gQ<5Yx
z!-UQh9^dkoSS5=v*&1q+%WfE3RT+9lkl2Kl1s&{ZSo1arSNWacBU%g*0@#xm6uMJ}
zxy>(SXo_<N-<v$iyO3gzO&22oH?FhQo=k$txDY33(>|HuFnCw^Q08EHv^sxj$gpzk
z<yBHPhsgrP6TuW5NY?)QZp7wlhKP`YxU2*?gf_H*OXI0ea_C@~>_#SJ-0ve2Dtsy6
zDU|`^DQ@S0HO{aeB@`x&1b5bu&hQ^PHG?2Abw&%i8iygrmCv1MK|-PxG6d4empEui
zB?fj~nA;7bM{~<UTafeqd{l0_1EY(GMw+aT+Amyx-3+>~pPWj$NI$+_s9R3hqW;^h
zKJY3ZNi@lfzr)pTh{If*F2&uSWFMX3JQaV)$w)u27+x`|ry1jM-{d`(9g;2!kEs@)
zBARdpapB_DeUc`fFue7NsxyyOUtsg#jHGVzUC7Q&;33H59<~cEgN|Ao`)(TjWY-3`
zSgzMi3|?reU7GOTXYXHUV!U?eiQM8-vyiJUI#Eic%(rt%5SWQBzjJ*=2@Zn(+PWSZ
zq17cPo`8&5wnyVDwawI(bA>+}FV@ci=NsQ9p3h4T*x^q<7{wR<?WVOi9oH7K?higT
zKKS5(F=ae!-Dcm$pZFy*Z!&M&mEp4NCIma71XI}_*$HwjxCGB;Z$rcX2TV0?4MBq%
zNoJ~|yQ&vC<2j$~MjB}bu~#djUg39VAb_RH(?!!*auD>+`s%O+?;Ip_J5{)BLj2W*
z%7U?Xai|Xd0$A)LP;4=~rt+6uh`>V`)FK!i-C{3v)jgSG^8bClU99=QaE8Q*fZ{`d
z^Z~;!wM|L6Sgp0r|A6g0aybgL>aXD2?3Js(>Kirav66H|<Ag}qt9iCp`uMiy6A3~c
zM2vw9EUn-c_URX?A=m$4VJz%s(|N-~0LV<BZLXpqt~j>55Q$3|CP5`jw=;vSnB`+k
znB{RB=y8FE)?QXzLr{Ck*M$dOW_SX|zu#EzgNwFnG-nU6ffy6(1IC9%q|LY*052{b
z;9<%dE?5VLLg81-3Qmnqjt#8!Tg9#$Tj#BmgQ8AT;I+<{%jZ+Jgx?Zgn7v(he{!m8
z$(Ok11u85%Gc3lD2A~k*kE?QriIFSn{61L;w5ACV*nE?!n+^qasz<ME!u{VGp~q4f
z(Iq3wRpVnco;Uur=J<zl$}t@CxCAdAXtS6;|4drNQ^g4m64hwBM2gvSa#OeHy|NSI
zVnX$7z@b5}Ip{4H!4imROW(D6M^MwRjjv*<G5EU||G~`%jfV@D^?@@E0p^PnUG30S
z!bCiL$^`n5tps{-Z~;+KjQwOGXQU|kC->7U^1N6iHxCcDw@@MvnKr2^H?10(>3!!R
zO73@rr1|eS1@``ZM%cYxNVeIuYgZntl~nD%u!4pjVyF9U`$JH{s$0+Onhw;?JpJ}2
z@7q)6$+WmxbG=LBuMph6d%7ho`|U&}KNXOK7HHaaTz4qxTF~B+P_~O#3DhjZt9u=I
zf@rLkpV%o?Td--9c>+BZJox$0y4`d$X#XgfK#FMm#<#a$utN(b`!mLc^A61X#)DzD
zU0p2!=$1zIsfC@KW4+pv5rY1_W@tqmt}!S*_^Y;JxQw<^B+H<3<BUunO^1jt$LZOb
z#&3kP*<<KHxWNfaRX`b+N=Psex(?Y_0~Di^SDjJ|)D$Bk{@VN$ZT*XS<JdGuCb30n
zpq^`rc3so{eQNw+TR40Bq?g&_=Y!z}E_g3GPwDbA0O#+g)G^N#S@Vyfif!b6@qs5N
zgJeOhQ&~QyEj_Y5Sqg(noLuq28>4lD&N;J^kkQx!-YVZ=0*Zm@F@i@Iq*yTzPqj0p
z#lxTvIj)+yXDuP1TOPL|DY>D#oY%K@_ZCA}HeYq#yA1l^l_JX7o^D4l@Nd=)PyZFJ
z9rtI4cLVaq%Em`E6omH(?6WMCpY0pbY&6P`j$|zMQ>}2mg>DaIm-ypP-wSlIX4~5B
z^<C!ld)xKnX64kK0M-deM?PrSahzo%?C;<(qBDSgVoSKFtNGmIjJ&CT{g(aDtM{(u
zDR~x`|0fK(LWF7Bk(d!PKU6(a_kMfzFtUon#-B?PKLkvPg=ReLOm6z_^kN3QTUYhy
z;xTiTWlN8N_`yK78(3!e<~b`^Bw@vxBG;+Nz=0`N7TlEo4yK)2@Og-JtKZeTXQh4|
z($Z5;of*H`W)n+eEiGEji78rXD>|2(UM!lB9SE<SmctFOrw*{(QpSKeM?K{^BfEQV
zq>Py)H&ij4_%Hj`ZaGA4fH~$HXnq~jxw1JK_{g?7t)S<D-;BXsLbJDlC&eRVK}1u_
zhk>{O1#aFu3VO=7RJ(lNpd-b2Bx|P!H*|%c-h;V9Ymu^pQ!`w1;<YZm{7q*88dx`3
zv|l49%Po{Qq^Z9YnD_{S1;{oW#`zzR#jL4s{zL-WD6WOiM~GTE%4=fXmPFP<-PO)z
zkZ)vrqaD0~Kl7WV+_C|0ezoSWTQ~2gzIU`i=1}Za5Kpr#r7`seuT1~VydSinbc7P3
zKY;YnF4>TaF@pbSa{w+=FGe8D(vR|~l=G7G$u_ObkaA1FHRXuc#3AAZF^H|M-aL!y
zFYn-)^##1qbX0sT@Cx5HDbW$o+6C>@iOLfs;H*c${G_+}4b2E}grg{#EGar8$9Gaa
zt{(yUDo&cDj*=1ahL9~f7(T*roF=su7=_Npmfc~=n}qpE65V;LWy7~dK*_RnkuLS@
z7gofaCQ}^S%o?PZ>NE(C2~hZ(-62-`rvK$FXtYuk{D=Zw{g(v80)tbKIt`@3{SS$$
zfi8eiu8n%GB>hG510kbSqTk%zw?t8oA~|4iQBvdgVhWoK2oK_YK%1ThuQq9Z{Q=Vd
zs=B&NaGSwldNFFX4`IgPXy^plPL`590Hl)s$V<AVEQ90!9wFYZM+Jz?<{;~%f|->T
zlMe6Livp70H2xxrswAOx?T+i(Fj@Agf$T<{-n}?A(IJy#IYffi(eXvKmLGG~3!!z7
zS!UeaalGAxUEG?bH%#eVhN(`bb*FTQL7_T*)c0r%%^dnxoHe~>H9J~#A`Ji;FAS=h
zdcb1;LQ0YWFmi=sv{7QnCp*pbh><nOxoT=471+SAp2)HP@nbE1VeTk%iiX4e?@Z(=
zMF4Jbra?o@CaR2>ydjR%4~DWsg=)_GccgkiOZy@SGG0|P6MTrN77OnVyo=*H>v`E5
z4Tpl~Yi{Rh<@??QqLXIjcL4jcCjnrZcYFc3UFp1^aTh%XH<tjrzg822rLrmTj+3~D
z(J8l?7NzI+$RjBC=^ZcPyovMEOqWYn`mC(TtogdT*<lGQ?75}fB(wbXWkNk=uk<y5
za%nwEOy`?IM;ZP-r>p5yGv!NH8~3p`0Um;d&a$(&%r}eFpX_~x(6;^$%Q*E6f*B*R
z{2#xf7`}pkDMdn~gWEe7%+a3lQl-!VARLE4{213wHr}^Ucft`tPZN7G;if?rSq_8u
zke25}o4O@96E+2=<lqYcp7Yoh6ChuqEKrjUuj{2>E*I?s(yu`W0)LT)7Tn!GPzO7J
zfWKx%b=)20%duS{CHcfvnBIeez0{I)F5UyTfqtxEXrhBZ;8R2gr%?JQXdQHPV6lmx
zBc)2emm|Oorf|-{#x$C*HK-@Qhu4CS^GkPTWMw%T43Ztq)Rk3_AmP;8B!(&cZo(5O
zDqFZ!xa~OUZ5XG19Z+m9WjzP3z_e6!8|pAUf+6W>(JiU_j;8Rg@#g4OE5ybY(nwjS
z9=U-<Fjyi-w*bC8u}NUKsJrIZB7vAt90o_7PnSjL4m?KG%R{^omY6<*HFdXCa$UfH
z&NOI%l!3v~$m{Cx6l%cU252x5DIRVV=wxNP>W5Eo^k_gcq0}~Twy2{;6!|tPIL%Zq
z!I|4T)thP=@IA&BN^W091+zTB3Wf#O0ZK<59M9X1G4olR#cw$lAmz{uL<C@dA_I2G
zGF%P!livrAFvf&Od$J5FVR!+nInNym3$^5f+umrQo*^}G*W!vf?^rmHo~gGEGZq!x
z{uStUl+@nwej&AW%RXC5@~2376b&&otxYo>kWwgxDbGH3m<|p)cjW|9G@1Aq^UgFY
zGW2a&vtF}|`OcQz^HBWIxXRCv2BXZh{0p+?x{m>(4i8jPM(6}WO9BG$&RH)Wf0s7Q
z);5t|{s=h8+pla>vmWXz!8u`^)Q(Sun&be{P0Xu812}Z1jU;!Sw+e${SwZSvj?@}Q
zjs0uoi@`2u8h%+DlkK9n7Rlxtz4T+&31SEC)#M~K{%OB<mu_mgRO=Bc@P;n8aoFbJ
z8yvP6%GkcJJP1-$0wKtbe`H%NGE9BU1}1m*6<dM^+f2%f5NvMq?kR`hh@HoSp@gX%
zDw_kOw~_|9#>ETWg!@0}#`+FPL<t-Bbf&p1Y%Pq)b4~eNr-9I1nKdO)B0vy~#Z~)$
zOyn6Po%8R)lLS%$u}kiL2K%-h3TL~z!PAj;))wVv_zXPXdvy|4dRA;-1w4-Ec$_L`
z%o3v!yEmjI)6}YUsA^?m+E#c=G`$Vu?Jy0)&^y>lBwO*Z5&xBFLJ)Z8;U?@hNj%F^
zmfB6hWQ#@M4Wfl&hwLD2v?`vz+t?RsL+Ja`u_fh$*@H3^K$+`<nN6bYJ!0Yh2N$B-
z4ZxE)hsOeARlw+>%B+Qpv`k*s&4-E3oihM8MOw394v28!|B9*q);x?uEtYZ0S!c4=
z*A8;6O(lrcXBJbqekApJyp$D4Z;Fs|7|T-Sy$fV-m@klAq<a$Fm*U?{g_p@L%|Q$p
zvm(Q(FPN!MLb}NJ`o1lg_lnt;zABUpdrX+-b0_hbg!FNvR=%f<X!n2T67;4Tjd9M3
zfW8)Vun%I!;Mhv`TcEo;D?U~|i?m!wL>2<P4+8c?qG^i#E&dUhcB}{;tml`?O17fF
zjXpDUqBydbzQMD+O)K?w!LG=5rj%r_HJ``~EfAg%6TeN^CW%#`q1kXT)|9;6uDx<%
zW<hKXGz&ygHUn+1<gCC}GK+Z`Nz)0m5YJ+u3)OeL?N!G(69@d=d?+Uf+TyC?NS_KA
z@+WtBy#5AuiR%u9pVOl@-5_1d>l32%{`ld-Eu*!V&<;g3N}gsaX}%aE4OBef1#HL|
zx<828MR(Ex-aI#_&x^WKuD3NZKOlVc`g@u_l99}d;-Z+xZQ?d@tO5(@p?N3_wS}J%
zTY<jTV1k=Lg2B59=7-}MX{NlfDQMmwOL4P&mc926d96G`!Xi~VS_F}@QNbx;2hMLN
z8;Ecr+)R2o&+UB}ekyl&cX?f`x()E%V~uRb_i+DW$qSu(BI(fdE)AYoh|d)RJ;QH~
zg?=23er(m&L~te$ba9_bEfiC4MP0@Z9FopkaUdnM7akc%=l`jkXYfaqhYdMJWDm~Q
z)W|lWMc9B69aQHfF)GdXw)8Ws5C`eLb`TZZRo-~B$(1{u!z0BeYashq5WzN1Y}~m|
z^XMDqXOwJDIYBv7ObDJboh{({d<3MZ28H78Fd&Pf055*+t9hc3(O7luy7c$#+53=g
za1p9qYD>i)aKTq^SpnpDZh2)~1a@>w7tgj|H2UY(mi#Wh7h(AC>1^PYvtzWmjs)Tb
zo$CblWpYmf?FkG=-R+x%O2tL*9PhbA$tI36+ddKOSYEMlK$xs)cR5TFAj?TV&i?!>
zr5c)fKcO%k-Zc!gi(cUX;ymO|_BY!KO)@V^3nnu`MHhG4spMrg;ME@ioL&#|8l9Jh
zD{U_dzqJIM8FZgPW6dgE&&j5`OqwpZN8jd#JRgksJ2I{R_V|(MwKtm!HkA7y-6-BB
zZt9=ozgel|DwucnTa0k@Dix|0-DYj-dYsZXtz+HO{d*PDg!<cvk+~XGY?a%+Jbaw6
zji1q0-7~+xeZnt8l0(IZ!X*r4Ye=3NK$uDQ#3q~Yl>xTn#08YjXdvbCn?{kZTO?`;
zhPvxK0|TnfK(o(`&mTkTFzu1w{sx1MbrIQ)k$a-taU$aqXfj0MjNs~s->tcGZ6j>W
z4C=P|*sr{WVjBc#OG*ee0BWMxtJa_(rZu7?*KvS!-?XEVja)P`4*Y^}6&<W^^CzID
zcPiPSbWhypNnedUeBdmzh(EIz`J+Rzr%vd_;U|h21Pt{zynzA;DVmcO@EF?7N;_;u
zV~l_~B=|x4=$58Pu^{rN6*GNabWasp#y6zS5A22u))=pU!|wqwz@rF%J+68Q-~7rG
zbNelm$Uv53s>usX`0j8_F;5>wX5jkf#|~0emN?)xP`h}ifzvdCj4VU<KSL1`-gVqX
zeC5mZR01t|#kY)79e<5x4d~_h@;elz15jn{FlsRy>|pCK%<xSqn;YBmJYI7;9ln0&
zBS(9P5@)+BVzr*W!78(ny6Pp6$AH=^sPw7Nx~OKfcMxOhP-6U!rN6{x=^U~hCvQ4a
zyvycuGi$wp$p$#FCGL~!LDa^0H{BaATzFr)4&;{0`2Tn*mZvS6Gm1NPGxPJC4n9(J
zP`F?;<jnVyHRNa-RYVR(vCts!1Y`H6nU~X;Vn7z_Jj>P5qFSsu6ESU&>14*ZW}`la
z_XM|(4AWKR`qhNXVW^KptZ~S8nTu0f6<h6zSm0FjvLFUB=>BpQXGfFMXL9{zLewN}
zeBGy%8*^jP#x(A{eTwl?H@;v+p72x^3%SwZ#`>!oa$G9+<hoxo)O1vHPyLv)qwxtX
zxqA-TtsAd7H^qS*2IKI3TcT{HC3u~O-gt50z6TK7pd0?^LDkF@q?T$fcYraQ$5KUd
zy@K}cdg|3M^j1Lb;#Rox25@dQdVkrzEk9Rtz1jAwayjq%&LolCz2t&icbPp29yiY(
z(pwRPW!F_I;MrMte|fqs@d4TuDGQM{FtKc++)z+P1P3xT2{KV2XMk`OcHU2UE;My0
zVZOyuxR2M8TGw+YRQ$4?*~LYEl6WH{?NJmwCCpG)`L9lpSfPt-Haz`+BpjqcWI0q8
z`ejmhcr35A)m2Q)&>{9dgpFCGMQ1rL!mk&>rzr*5Ey{PT_CMx}H=FUd;-SgKG-rHo
zr&d`(sZMj{2^LlC9pYvH(*d<0NB>N+ac}n54U)qxR1g(m74KY2RXK0BY)_mmCTk^J
zLy|y(*^$XoX|OimkEDWc|Hl@`pbWOUjA1T!O*ATvi=drh34U1ICwwz5u4%Ch>itO$
zZK;WpulIQ>+J3|?W%Z8Af%FG8s?1U-u%LMaYZ+TD9-%oa+#xUOrU{fZ$|h2`m%e#+
zVAms$qJpDMX%v}vWDZF<A%z6WyiaeGG3?0n4wZ;X;T_-ICY<~6e0OSMW;<s~!s>JI
zFxs&<Y^D8eLBXQ#XJ{dQL-YF?FTR@fV!kQgI=U*fP$_<cTC(HGj`ZAl;-@l=AgH&%
z9QRZu199^HtL=1z%jip~&%3@Iw2@QMzjTl~;Ps=dL4<PrFWfc;{X{wVYBRl^(wVfm
zP?H^(_}edERf{(Rt%NeTM(Xbae}^T9D1tO|a;Ru6oA*2JWy6VSd>_eej{juvUgRnX
zqKq^@o(0P@r2>(_e#h3VV6tt>DyOewaE@cd&+^AN{++mY4l%8;I{cG4K5Nl+>S#8k
zcy)=a_0*Gv{=BB*cX5zn<0*?4YXVvUpJW|s&ZHd>1=O%T!eCW}h(o-&n=^3ltX5>L
z*5+#ku!prAQo=mpLlm^vVEZuC=>GlLbVTq0nYYVO-1npqdphqY9Y9ukqJ{F@ZYZwG
z#8Ltq`;e^=?j}Hx6AMl9lsD$+P%O?;&d`+0h37GN=L(e?t<%SbkoO>CP-16+-8qul
zjYJpfFlgM^uc#+*z5M;C%cDOFQ+Q|;TYTVai}mE@o|dzp^VP2h?iBbX%T?0bkTQI6
zJ)qn+BZ<(IUlc2T5)-c~o840LXnKEld%}Uv+hYi*QJ1um{(iU5vs-8a&Y8LPAE%fG
zCc0BZ7i7e#r<krie<6!sN9UB{rYy}HKItYSYRD3kIIi+(!k@@f#;rI`N|Xl35>Tu*
z90NbM&v35MXuZdE{sFI2pq3U|+I?#lo6q7<yu_2>IP!RZxr~Zw`Mr+mzEF|YKD(5T
zU#owljXHeM^7#W3<J7lx&M73_TMNO$^y2vX1|f6^v(GV@<b0L{&E7cmp2*5s@kRvP
zSHhvD1P=80s>>{&wJnOp@E9tko7KxA&AX37-#F(;)6gN_FOcRo3%RkM$jNH{0BbQt
zWu34O<jLJBA}{qq=z>RlDRxRRfj|Cf>7aRns2gsr!YtOr84*BN#mBflbAzl*u<!48
z&U?x#eOXNBHjX~xn>-2CBksvkqLS8pu9Imi6h9HnZ=lG)BwKac+EJ%)7H_t>EFq{)
zQ75Jz`CeP{tC4|xThmLRhsl1FJ4Iz~a1Nsx5jye(sEqSopvITYs5-Qq9|1L!V=si0
z*>O?Z+`()*R=pGn>N|X`v{1J(KE)AvBM%OZAaQT{X~V}UW<~SRuVsqeJce8~l2X_^
z)r1WOnZfyTlJV=UG>SI=&E$|M3O7hZEyt3?R^Ra@ozvxs9=!KlNK~>ZSLu~?7{Y>0
zjQc6a-Q;~$Y?<j6{!G_(OP-Nwn%E3d1*Vj5HOx@a{v4!Ll5LdZx2}$|JN6tP!paYe
zJCS@;*em2!z_TLt6)-wsczBSEmJ_n-)u2G{qKf3a;^id8nHl=%nnhQmQ-8I?$=NBe
zdLcK0#|D8m4N@gYEFW(9+h82_*i2$kpXXKO#@Dhxo;3>0W+aD9OSPIn!J;iT;-jL~
z;)C2IsY;nF(wAnUE%=JO-Q5faM_a$<TcqKH>;#$73ZmGdTsk?r`sd$Jnc_uI(w7qP
zaY5pU(Y7wKktZYa3}%!$s42QNo`g;hvb=j0jOIOQD6M_6k*xAP#W`!v=r+tfLo=&G
zm!|lR4OC`};U*y{OKJT;Ys?yT9K{_m*v7#VWFTL5q@Il@PkvBjIcA$9TGJd9@4`-O
zU-Oom&^9$=-y%cLXHz;7OPOT`GUkQdx__NOf!uequt}DLEmHW|`Umx}*?M3oucbr{
zK;o~s#pCL7t4b+vYGye%wX-xqYVBWoK8q3Gdrn(f=JE6gru~!Z1n8Qk=i7gN6Y-R$
zxXR*VPJzyb@6?+BP3s7IK?hs6c)CTCpRQ&oclo$#EfY<l-@=MSEfU?`*BA8%TCz2V
zQ;0Cam}$&@)YwBa#yGMJlYj5_Rbva&$w>A{FB&Hq>h?ki>*3NV1Wu5ygnlv}W-hP}
zoi|z#?=7R+7TrI|Rr141f6;fyow+I@D`3Iqs7dW(egKA3Cg~;$e`}l6@EHDJh=TUE
z;kRUNTVi+raz&xa-nMAp6MrP-1eqbeO%hIk{ZRHDi^s{Yc;k|4dcwUHM7BCmWHeQs
z@?~~Ra8~LFj;~GE6=F1X<7`s9yG}-8p{e4JITG2o6AT`*OEn$lp^I8}d_=mDuZc%9
zzwC+-5k*pvRX(@X3KEYt)k*mD$EL&c<w2waCZ~9V><v6YPf#)bkk@3Omob?^q@EGH
z>LLAv*^y18B>7(Y^%n>>3-NLUe-aTZ|4SfBd|jYBEw--pwpTLjA5WI{aEeC9!aA)z
z-nQE8FLm?BDK<T1%i$jQubodLbY7vfOsX@z5tu-vByF~qHL+rhl_Pcn;2MRwjJd<8
zRf)ibz<k|xDhD&J+#HawSm&UWUNy!`(Q=c=0{nuKH`am!t+*92EWtRn%}#K>kYHsp
zEPS#5y<!kcL#z~$_mf#Z)%6A44r*EGnZXk>uNUkFpSUtrgT&w+!^$f<U^`I@WpO<q
zao0MYt6?69+gANj=4?hwt!#ZSXny<F-LW3jQK6id&bdT2|0A)9odZqC7{wl52t&a0
zQCGG+n=-S0hJZ04>MXmY0ga<i+@<Oxu62~ST<@c86pMpMB^i1bf%v)ct?+V7WxTWY
z=3My7$bKjSwg=<`2NY*vHC;DSADF;UDQuB}>7ED#bLA0P=UFzYB{GVo3gOcn_keOm
zqI)uDyWzoR&|S!i$alk<bd@0L+tF1&tsF>K!KZKUx97iD7P-r~;r$cF_B0n@o`A55
z9yYGa0M*_*GAIwKagbA+#Y9J`Jv0r$BO%|r_tUj5_5rQ2VNLmaN;-rG<zK#T-%|J)
z*hp!|EwoVdZ(p2v!nI@u9^$zit`zozeG$hqOB!hgO!mFWp%c9AG$A)ZKjZ2)UAe?u
zGm63N)@034P>19Fh862N=bHh~B1qArgmpmO)pTB><HS=$ZBU8p&NV%&qEq**;HZuy
zRgQGkYb%z$-%wdkKWK*jPlC7SCQj)fb}rZ_+p14YcyF*Svs_2cNk?VSl~_tU`DdnY
zQLn?Z*9QX|o<5+zr+Aa3dx}d_;H9`ytmq5YD0GYoqa=NANr9*Qb&>BYl<X4UgYkoG
z-u+Aj^=R6Gf^V-sBK4ouVu?AK|NQxty^_5rJD;VFKs18DnFha!Ra2-wrtP?9hvw70
zH|bj__raMfw~|}1<mP5S0a_j2`l&TcyLR1G+F>H4)}u;loe7sNr==CVjsuN!-n2;_
zq1qCt{(~g}S{Rd@*B(52QL;j3n(&D(l?Pk8xHEHo+^#0x5S6KTT>u-Rj;k69|G~Z4
z2Pnzl+0iY7>7w?Trjt3Jyd&M5Fs%{#{i)6oIT}=7Iq?0M%I5TDSylA2J!stdu{fO!
zvE{3Q$9H`VRzr?-rXd#Z8~6PBfTSXHYcPH{m@SNPLX~YG-;|u!18K7QIN#mB*Bs1v
zr9ffg|Gl{dAEb2$grJZGwl?SXJ1H-_4#rQepEMdl%rLvf6$A?I&P<nun(r?wWIn>=
zgAeUMxjj<8LlM;PZ(J=HELeaH<9&|)n)uOOejUPYz1VJ=d9sT?0nxWgHts8Nkyl84
zU|%s}tPUlTFbE*11IeTyPAepNmmw62ehA8tkSZbv_BuGdK(1TPvo*`UI-)v8>rkE@
z-Blxi-TBxb+L0}qK;33m=UYO*f^;fH6(^0s)MH|wCikQPq)gUaA3fw1C|9iK+6`;d
z->@wD{Ry^D5h@j|3M7hXhk7^6HkBejKg(2He_J>5*Jl3LDguEZyAm6*VE*XE3XYff
z`lLlaR4=-V+gFlbz5!)_<S{j&C*dZ`lIf6do#cSIcW*J~3^bweW<a(0R{D1BBLqTz
z8Ml5ruVc9Pj5@A)qZ{66PWs-idDh+xVEJtNQEt}oD4pY^3qOp<wDgydp}y?_kv^l7
zNZe;Ih=*5$=;!N*=P6Jch_}2gI%YlV;9$%D@&VVILOC|`Quq%>`vM_1QTv~_{@HSj
zWStBT-9qI+KKQddxX5oCZ6Q?z3P4aa<JCZdQfR4vn4U2WC_S@A#|!lr{d&DigEFg0
z7gwA7XBtn0)2;H=nAoCzYUo|w4%s7;53Yr7&&*@jJ8@I`zup)#8l1}VGR9)(0|a;K
zGY<-O_u?#}M8_uYjD;7I(Y}^_CL~XrN6I|>F--Ra9hQvF<z=Cwj8}%RN;g|T>ig38
z7b`!4oD2Ug`Chj$kR{&Lb}o+rkEp}>Cb(7x|C=e!e^V(=F<7DC6;Ak<x37gMRj^O`
z|Bj-eB90qPeauj$PxuS5VOW<*g<24{1|I)9>4vd(5N9fX_nOLCXUs;VIN=zp&iJo~
zmo5ggJU$2l2d6|}6R)oJqCeDu<b|cOYN+ZMX?5>}uizZ4TvgCsOCh3-*x^XGoKt|k
zB`Zp!#_2|F{quox#GvH|sahlXT~2%U?LxVqSgcVWPPS#<5@OA2c=!)<nWuF9OPLZ^
zu7|vv7ya0rGqsCB$w=8BTZd7)jdOs2q^}2Qy-Sj9CGE`oH~-rd(>bpTh4$cG&C3QG
zO2KP>9mC=G)GQ{gTh3vWHrMKUM4_{c8{sDXpW%n(RYu8xD<xR8z5QlY5_be;Q`W=a
z!4Fl}b$yT_I=qoAJl}!tdh*pOk26Es<E0|5ZR1rrM2$&_vc9Z%S9M3K;r+~(MlkP;
z!mjjo1$PlM1yT^mN7iO?@OB53{%W5j3W8j_rgBI=+d}HwixnfdI=z}9xO^=YK{LxL
z{qqfW0!k93n>uC*YPnI&IhJ~~kA;MaqHE3gjB3(b$<A%wC6Q!B=FnP-lBoN=5k;oa
zIRdTmZh++xh@MC&Z`(J^sOQm|5W82$mS*nVDd>-uCrYqVR*br#etGgT{f5qXq-iy0
zo|bj#BoS+H6@^q*)fu|n?7L-abol-BG~AElfVyg_{&4-<$V>hv7Wv@Y<Wm>#_JidN
zS2g9FG!KF&^56l29i9c2P`lXKg$gr{ybZmB6W4I$fi?;&&U4&=ejGL{P-8ddF*T84
z1e_evEY7`~`I2vIQ;w~wIXeZh9t&h65tiu4uIOO3jEfL2dkz)Eka2Ii8y|ak*-*>(
z+;RT{>Fp+N!8l@Cfd_5GPhYO&)X%&MaKiQP9nQGSZe>(`5tJZ6T1A>8w-&Nsg~0E*
z+433HrWY(KqUaqRa%+-4$yViXSH2=K+aml8X(7)fE@S>8;{<W~>dgVg{q&@|#k3XV
z)lQ1dKD7V2qWl%>+YAqGBYpZ}X|E>HJKl_At|i5CZ`!5%e$q7NmY<!K6+-}-$laq0
z-t&f^`Pa9Z?8$c`wrn7OIWJy1BM|Vbk&X_zM13(_sN>u=R(0#V!0g;RA{=%2b;RkQ
z*r2N95Qwe7ym;2K6UAI94M%S75#@n;!upyQ&aFvLz8^3;q~2zkMG}rmu?O9XTu)Df
zlV7c`csXG_Z;P|GDu*|>H`HPIn-@~$*eS&nQ6{ynWuGb}>VX4+(eN(3m!!VC6Rvgg
z-pqL;hr+53wmze#GXFs4J5bvT)QquWYPWf7keySf1EU)R9r7G%!kZ^BPg&8K7b}*1
zclk4EJ|44evM-X@JkQelcXRr@F4g;c7^fc(dr0`rZJr+yo*5A|TI*vU!6Ecl<!e}M
znYb5yzyn?4(fdK-cwv!VGE>a-)RSR&L8(<{=%s(K@q#=#H%FO{&9|0%Jd71X&ct~_
zE#X5HF1|EU%B!$pd#I|ziqx!qN27tuE~&TJ>O~0fL{SYmtKJAE9)J1Z-7oIBTIsR4
zZOHO?;bjhi;(a+Cmpj{Hs|rV*^Rg*^9N!i0t`gOJOz>tN4`i^_{P8`X<w2x=RF=ha
z(&#*us4sm#UGL<D`ML~I+=Qa{wI}_kK;$fXg9M)jB-(1FEzt*PwA^#v3Ze^QwaEU1
zBGkaQV{p7+0&2+b&92k-)!zTImj#RZ^6LYC>$`w+7Ab*M7;OM~g~6S;YpszRNRLR4
z^ncCJDviXr5)45U^dqw%NNk}xg1BQ<v~LT+UznWk>B{2|Mk#GkUn*(b4?}bCD+#=4
zEfc2sb^i;gTpdGuufwKWD9$;qrS7YeHt!5sb3c;`591%;pYwms+Xyj~%~j6BjGu#2
zlmE{Mw5zl?<d<X$0GI$`-XEqb+!Yf%Q8OQ@w<A|JFx>fX<o(&r9}ylh+re&+C-itv
z`c3!dJ%3lYIoZHl!!+ci6{r-}fF&#{>W_oNqd~2p&o{4eF?;-yO8L`YWT`){olKO(
z(Du(=HLqLxE^(W#(5B#poD>vI=?yRswq%DfFM3(vyyMHzhDV3Wl6LxiIVVAiL<#yg
zH~xlyo&Z<j8^VmPCj0OI9;l_2qZ{W6l9{Vbt#xwm7&F*2L8l;S`<Cx_uMk#dvFIRk
z=mm`1-h-qID|V%ShPG6K{3U*kVR#~zwaMMc;Z;hS^rsp{*Pxu|)~+q*{JZ2xYVK@j
zF-S8dEzR^l5GkO>7Ub5X?nJ*;gB;vbn7#1(`TaIlF_}>nHs$$!25d2t=A{Rcv&|TM
zjN1>1PAs+>d-YU0?AqrRf^DaB{knp#hNudK8+q%a^WpZ6kTL&K_~Ko{KD;_Y&o8js
zP-tla&iOD$N8rui2i#zcGvjM!hyDWxV}b&HQ<h?U>>=z$?F$@I?~iHaavrcZ(MP<M
zfkNqU5lHO5BwZ{l1M-3P+szDq2Z8OU*s-Vae>vINkCM@bH|-=#ZSnMpiSd>bvWjs~
zfDQ*t;Oq!|Ws=)?@kE?oJ?NO*8?5@O$6d|nof4dx=DdB}rfzlUHxK}d;Opt({aCCn
zE?`3Ae)@LE?W&P_&@bav@-^{@CVmFZ_kauNQS+Ych4@=te&uD(gq$S*NLFarNfeV;
zV!<Y+y^2Qp=L`*`<JsN;gQOjCJX`@DhQV0_6$~$B$u?5pBc#7se%5My^UJESf~CF)
zWUi8_lJ(}0QvLx0UH$B*AA%1MU6c(46iE?TOX|Tyg8!0X8YXMZs+roxQoD20n%DIR
zG81>q*7Kulxx{h{-#Fcq2J$4yCLVx>EZo$l+|Hq$c=iqA9|e^=Bp`+Wt{c9(TRqPe
zNJ;)_i1z>&XN-J*?*nP24^8KU@E);4*PoA=M^W1Ez>ACL01iwmfb(v<|18g!&8h!H
z#Z&Y6>5YE{aE(?CXM#zI4mT_$J61|rf+A87`5&DvZ)G{66j@Kku$k>~IP;d?Ith&9
z<<&%#!S4mJ{4<;_DV(uNs`}!5?`H(44&Gpdga}q?=+yhDTk)l93DN)g?=cE|S;$vY
z<M_+HW9|%^F*OabC1MtAkN}vl<jRKyOVI=su8t1f!65W5ZCEV8ZePc{K(^`Cx3qk!
zkH3iaeh^}^>-VkiaR>gMVFQB&n_)mL8&W<B9eJ1du6t9jM^o7F{w11BA=-?u`aWp)
b)p>++bN-t<(c<QK;71##uU?^Q|Lp$&DmvP#

literal 0
HcmV?d00001

diff --git a/logo/FSFW_Logo_V3.svg b/logo/FSFW_Logo_V3.svg
new file mode 100644
index 000000000..da561d1ef
--- /dev/null
+++ b/logo/FSFW_Logo_V3.svg
@@ -0,0 +1,711 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="59.111mm"
+   height="67.383003mm"
+   viewBox="0 0 59.111 67.383003"
+   version="1.1"
+   id="svg22814"
+   inkscape:version="0.92.0 r15299"
+   sodipodi:docname="FSFW_Logo_V3.svg"
+   style="enable-background:new">
+  <defs
+     id="defs22808">
+    <inkscape:path-effect
+       effect="bspline"
+       id="path-effect23502"
+       is_visible="true"
+       weight="33.333333"
+       steps="2"
+       helper_size="0"
+       apply_no_weight="true"
+       apply_with_weight="true"
+       only_selected="false" />
+    <filter
+       inkscape:collect="always"
+       style="color-interpolation-filters:sRGB"
+       id="filter23683">
+      <feBlend
+         inkscape:collect="always"
+         mode="darken"
+         in2="BackgroundImage"
+         id="feBlend23685" />
+    </filter>
+    <meshgradient
+       inkscape:collect="always"
+       id="meshgradient23819"
+       gradientUnits="userSpaceOnUse"
+       x="-9.447978"
+       y="-28.967659"
+       gradientTransform="matrix(1.6672918,0,0,1.5637161,15.752536,45.300004)">
+      <meshrow
+         id="meshrow23821">
+        <meshpatch
+           id="meshpatch23823">
+          <stop
+             path="c 11.8178,0  23.6355,0  35.4533,0"
+             style="stop-color:#0087ce;stop-opacity:1"
+             id="stop23825" />
+          <stop
+             path="c 0,3.49232  0,6.98464  0,10.477"
+             style="stop-color:#00beff;stop-opacity:1"
+             id="stop23827" />
+          <stop
+             path="c -11.8178,0  -23.6355,0  -35.4533,0"
+             style="stop-color:#0087ce;stop-opacity:1"
+             id="stop23829" />
+          <stop
+             path="c 0,-3.49232  0,-6.98464  0,-10.477"
+             style="stop-color:#00519e;stop-opacity:1"
+             id="stop23831" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <clipPath
+       clipPathUnits="userSpaceOnUse"
+       id="clipPath24955">
+      <g
+         style="display:inline;fill:url(#meshgradient24977);fill-opacity:1;enable-background:new"
+         id="g24975"
+         transform="translate(-42.742183,-140.61702)"
+         clip-path="none">
+        <path
+           inkscape:export-ydpi="499.60001"
+           inkscape:export-xdpi="499.60001"
+           style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+           d="m 48.300305,143.44076 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668807,1.48047 1.480468,1.48047 h 9.625183 c 0.811661,0 1.109108,-0.75875 1.480469,-1.48047 l 4.00036,-7.77454 c 0.371361,-0.72172 -0.668808,-1.48047 -1.480469,-1.48047 z m 0,0.98828 h 9.625402 c 0.281935,0 0.621179,0.2415 0.492187,0.49219 l -4.00036,7.77454 c -0.128993,0.25069 -0.210251,0.49218 -0.492187,0.49218 h -9.625181 c -0.281935,0 -0.621175,-0.24149 -0.492189,-0.49218 l 4.000141,-7.77454 c 0.128986,-0.25069 0.210253,-0.49219 0.492187,-0.49219 z"
+           id="path24957"
+           inkscape:connector-curvature="0"
+           sodipodi:nodetypes="ssssssssssssssssss" />
+        <path
+           inkscape:export-ydpi="499.60001"
+           inkscape:export-xdpi="499.60001"
+           sodipodi:nodetypes="ssssssssssssssssss"
+           inkscape:connector-curvature="0"
+           id="path24959"
+           d="m 90.668816,143.44076 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668808,1.48047 1.480469,1.48047 h 9.625909 c 0.81166,0 1.109109,-0.75875 1.48047,-1.48047 l 4.000355,-7.77454 c 0.37136,-0.72172 -0.66881,-1.48047 -1.48046,-1.48047 z m 0,0.98828 h 9.626134 c 0.28193,0 0.62117,0.24151 0.49218,0.49219 l -4.000365,7.77454 c -0.128993,0.25069 -0.21025,0.49218 -0.49218,0.49218 h -9.625909 c -0.281935,0 -0.621174,-0.24149 -0.492188,-0.49218 l 4.00014,-7.77454 c 0.128986,-0.25069 0.210254,-0.49219 0.492188,-0.49219 z"
+           style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
+        <text
+           inkscape:export-ydpi="499.60001"
+           inkscape:export-xdpi="499.60001"
+           xml:space="preserve"
+           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+           x="69.980721"
+           y="150.38542"
+           id="text24965"><tspan
+             dy="-2"
+             dx="0"
+             sodipodi:role="line"
+             id="tspan24961"
+             x="69.980721"
+             y="150.38542"
+             style="text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;fill-opacity:1;stroke-width:0.26458332">fs</tspan><tspan
+             dx="0 0 -0.27000001"
+             id="tspan24963"
+             sodipodi:role="line"
+             x="69.980721"
+             y="157"
+             style="text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;fill-opacity:1;stroke-width:0.26458332">  fw</tspan></text>
+        <g
+           inkscape:export-ydpi="499.60001"
+           inkscape:export-xdpi="499.60001"
+           transform="translate(-1.937002)"
+           id="g24969"
+           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.23404284"
+           aria-label="{">
+          <path
+             sodipodi:nodetypes="ccssccsssccccssccccssscc"
+             inkscape:connector-curvature="0"
+             id="path24967"
+             style="font-size:18.72342873px;fill:#000000;fill-opacity:1;stroke-width:0.23404284"
+             d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z" />
+        </g>
+        <g
+           inkscape:export-ydpi="499.60001"
+           inkscape:export-xdpi="499.60001"
+           aria-label="{"
+           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.23404284"
+           id="g24973"
+           transform="rotate(180,73.264036,148.80851)">
+          <path
+             d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z"
+             style="font-size:18.72342873px;fill:#000000;fill-opacity:1;stroke-width:0.23404284"
+             id="path24971"
+             inkscape:connector-curvature="0"
+             sodipodi:nodetypes="ccssccsssccccssccccssscc" />
+        </g>
+      </g>
+    </clipPath>
+    <meshgradient
+       inkscape:collect="always"
+       id="meshgradient24977"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1.6672918,0,0,1.5637161,15.752536,45.300004)"
+       x="42.742184"
+       y="140.617">
+      <meshrow
+         id="meshrow24989">
+        <meshpatch
+           id="meshpatch24987">
+          <stop
+             path="c 19.7036,0  39.4071,0  59.1107,0"
+             style="stop-color:#00519e;stop-opacity:1"
+             id="stop24979" />
+          <stop
+             path="c 0,5.46099  0,10.922  0,16.383"
+             style="stop-color:#00beff;stop-opacity:1"
+             id="stop24981" />
+          <stop
+             path="c -19.7036,0  -39.4071,0  -59.1107,0"
+             style="stop-color:#00beff;stop-opacity:1"
+             id="stop24983" />
+          <stop
+             path="c 0,-5.46099  0,-10.922  0,-16.383"
+             style="stop-color:#00519e;stop-opacity:1"
+             id="stop24985" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="2"
+     inkscape:cx="110.06798"
+     inkscape:cy="138.03068"
+     inkscape:document-units="mm"
+     inkscape:current-layer="layer16"
+     showgrid="false"
+     inkscape:window-width="1536"
+     inkscape:window-height="801"
+     inkscape:window-x="-8"
+     inkscape:window-y="-8"
+     inkscape:window-maximized="1"
+     showguides="true"
+     inkscape:guide-bbox="true"
+     inkscape:pagecheckerboard="true" />
+  <metadata
+     id="metadata22811">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:groupmode="layer"
+     id="layer13"
+     inkscape:label="Corporate_Uni_Stuttgart"
+     transform="translate(0,16.383002)"
+     style="display:none;filter:url(#filter23683)">
+    <rect
+       style="opacity:1;fill:#3e444c;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23621"
+       width="8.499999"
+       height="8.499999"
+       x="-8.499999"
+       y="42.5" />
+    <rect
+       y="34"
+       x="-8.499999"
+       height="8.499999"
+       width="8.499999"
+       id="rect23623"
+       style="opacity:1;fill:#00519e;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23625"
+       width="8.499999"
+       height="8.499999"
+       x="-8.499999"
+       y="25.5" />
+    <rect
+       style="opacity:1;fill:#009e51;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23629"
+       width="8.499999"
+       height="8.499999"
+       x="-50.999996"
+       y="34" />
+    <rect
+       y="25.5"
+       x="-50.999996"
+       height="8.499999"
+       width="8.499999"
+       id="rect23631"
+       style="opacity:1;fill:#00ffbe;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       y="34"
+       x="-16.999998"
+       height="8.499999"
+       width="8.499999"
+       id="rect23635"
+       style="opacity:1;fill:#51009e;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#be00ff;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23637"
+       width="8.499999"
+       height="8.499999"
+       x="-16.999998"
+       y="25.5" />
+    <rect
+       y="42.5"
+       x="-50.999996"
+       height="8.499999"
+       width="8.499999"
+       id="rect23639"
+       style="opacity:1;fill:#3e4c44;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#443e4c;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23641"
+       width="8.499999"
+       height="8.499999"
+       x="-16.999998"
+       y="42.5" />
+    <rect
+       y="42.5"
+       x="-33.999996"
+       height="8.499999"
+       width="8.499999"
+       id="rect23655"
+       style="opacity:1;fill:#4c443e;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#9e5100;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23657"
+       width="8.499999"
+       height="8.499999"
+       x="-33.999996"
+       y="34" />
+    <rect
+       y="25.5"
+       x="-33.999996"
+       height="8.499999"
+       width="8.499999"
+       id="rect23659"
+       style="opacity:1;fill:#ffbe00;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#4c3e44;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23661"
+       width="8.499999"
+       height="8.499999"
+       x="-25.499998"
+       y="42.5" />
+    <rect
+       y="34"
+       x="-25.499998"
+       height="8.499999"
+       width="8.499999"
+       id="rect23663"
+       style="opacity:1;fill:#9e0051;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#ff00be;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23665"
+       width="8.499999"
+       height="8.499999"
+       x="-25.499998"
+       y="25.5" />
+    <rect
+       y="42.5"
+       x="-42.499996"
+       height="8.499999"
+       width="8.499999"
+       id="rect23667"
+       style="opacity:1;fill:#444c3e;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#519e00;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23669"
+       width="8.499999"
+       height="8.499999"
+       x="-42.499996"
+       y="34" />
+    <rect
+       y="25.5"
+       x="-42.499996"
+       height="8.499999"
+       width="8.499999"
+       id="rect23671"
+       style="opacity:1;fill:#beff00;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#006cb6;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23673"
+       width="8.499999"
+       height="8.499999"
+       x="-8.499999"
+       y="17" />
+    <rect
+       y="8.500001"
+       x="-8.499999"
+       height="8.499999"
+       width="8.499999"
+       id="rect23713"
+       style="opacity:1;fill:#0087ce;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#00a3e7;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23715"
+       width="8.499999"
+       height="8.499999"
+       x="-8.499999"
+       y="1.9073486e-006" />
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer10"
+     inkscape:label="Logo_mono_black"
+     transform="translate(0,-229.617)"
+     style="display:inline">
+    <g
+       style="display:inline"
+       id="g23526"
+       transform="translate(-42.742184,139.99998)">
+      <path
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+         d="m 48.300305,143.44076 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668807,1.48047 1.480468,1.48047 h 9.625183 c 0.811661,0 1.109108,-0.75875 1.480469,-1.48047 l 4.00036,-7.77454 c 0.371361,-0.72172 -0.668808,-1.48047 -1.480469,-1.48047 z m 0,0.98828 h 9.625402 c 0.281935,0 0.621179,0.2415 0.492187,0.49219 l -4.00036,7.77454 c -0.128993,0.25069 -0.210251,0.49218 -0.492187,0.49218 h -9.625181 c -0.281935,0 -0.621175,-0.24149 -0.492189,-0.49218 l 4.000141,-7.77454 c 0.128986,-0.25069 0.210253,-0.49219 0.492187,-0.49219 z"
+         id="path23506"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="ssssssssssssssssss" />
+      <path
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         sodipodi:nodetypes="ssssssssssssssssss"
+         inkscape:connector-curvature="0"
+         id="path23508"
+         d="m 90.668816,143.44076 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668808,1.48047 1.480469,1.48047 h 9.625909 c 0.81166,0 1.109109,-0.75875 1.48047,-1.48047 l 4.000355,-7.77454 c 0.37136,-0.72172 -0.66881,-1.48047 -1.48046,-1.48047 z m 0,0.98828 h 9.626134 c 0.28193,0 0.62117,0.24151 0.49218,0.49219 l -4.000365,7.77454 c -0.128993,0.25069 -0.21025,0.49218 -0.49218,0.49218 h -9.625909 c -0.281935,0 -0.621174,-0.24149 -0.492188,-0.49218 l 4.00014,-7.77454 c 0.128986,-0.25069 0.210254,-0.49219 0.492188,-0.49219 z"
+         style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
+      <text
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         xml:space="preserve"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         x="69.980721"
+         y="150.38542"
+         id="text23365-1"><tspan
+           dy="-2"
+           dx="0"
+           sodipodi:role="line"
+           id="tspan23363-7"
+           x="69.980721"
+           y="150.38542"
+           style="text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;stroke-width:0.26458332">fs</tspan><tspan
+           dx="0 0 -0.27000001"
+           id="tspan23367-0"
+           sodipodi:role="line"
+           x="69.980721"
+           y="157"
+           style="text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;stroke-width:0.26458332">  fw</tspan></text>
+      <g
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         transform="translate(-1.937002)"
+         id="text23461"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.23404284"
+         aria-label="{">
+        <path
+           sodipodi:nodetypes="ccssccsssccccssccccssscc"
+           inkscape:connector-curvature="0"
+           id="path23467"
+           style="font-size:18.72342873px;fill:#000000;fill-opacity:1;stroke-width:0.23404284"
+           d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z" />
+      </g>
+      <g
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         aria-label="{"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.23404284"
+         id="g23472"
+         transform="rotate(180,73.264036,148.80851)">
+        <path
+           d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z"
+           style="font-size:18.72342873px;fill:#000000;fill-opacity:1;stroke-width:0.23404284"
+           id="path23470"
+           inkscape:connector-curvature="0"
+           sodipodi:nodetypes="ccssccsssccccssccccssscc" />
+      </g>
+    </g>
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer12"
+     inkscape:label="Logo_mono_white"
+     style="display:inline"
+     transform="translate(0,16.383002)">
+    <g
+       id="g23618">
+      <path
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+         d="m 5.558122,20.44074 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668807,1.48047 1.480468,1.48047 h 9.625183 c 0.811661,0 1.109108,-0.75875 1.480469,-1.48047 l 4.00036,-7.77454 c 0.371361,-0.72172 -0.668808,-1.48047 -1.480469,-1.48047 z m 0,0.98828 h 9.625402 c 0.281935,0 0.621179,0.2415 0.492187,0.49219 l -4.00036,7.77454 c -0.128993,0.25069 -0.210251,0.49218 -0.492187,0.49218 H 1.557983 c -0.281935,0 -0.621175,-0.24149 -0.492189,-0.49218 l 4.000141,-7.77454 c 0.128986,-0.25069 0.210253,-0.49219 0.492187,-0.49219 z"
+         id="path23560"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="ssssssssssssssssss" />
+      <path
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         sodipodi:nodetypes="ssssssssssssssssss"
+         inkscape:connector-curvature="0"
+         id="path23562"
+         d="m 47.926633,20.44074 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668808,1.48047 1.480469,1.48047 h 9.625909 c 0.81166,0 1.109109,-0.75875 1.48047,-1.48047 l 4.000355,-7.77454 c 0.37136,-0.72172 -0.66881,-1.48047 -1.48046,-1.48047 z m 0,0.98828 h 9.626134 c 0.28193,0 0.62117,0.24151 0.49218,0.49219 l -4.000365,7.77454 c -0.128993,0.25069 -0.21025,0.49218 -0.49218,0.49218 h -9.625909 c -0.281935,0 -0.621174,-0.24149 -0.492188,-0.49218 l 4.00014,-7.77454 c 0.128986,-0.25069 0.210254,-0.49219 0.492188,-0.49219 z"
+         style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
+      <text
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         xml:space="preserve"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         x="27.238537"
+         y="27.385403"
+         id="text23568"><tspan
+           dy="-2"
+           dx="0"
+           sodipodi:role="line"
+           id="tspan23564"
+           x="27.238537"
+           y="27.385403"
+           style="text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;fill:#ffffff;stroke-width:0.26458332">fs</tspan><tspan
+           dx="0 0 -0.27000001"
+           id="tspan23566"
+           sodipodi:role="line"
+           x="27.238537"
+           y="33.999985"
+           style="text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;fill:#ffffff;stroke-width:0.26458332">  fw</tspan></text>
+      <g
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         transform="translate(-44.679185,-123.00002)"
+         id="g23572"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.23404284"
+         aria-label="{">
+        <path
+           sodipodi:nodetypes="ccssccsssccccssccccssscc"
+           inkscape:connector-curvature="0"
+           id="path23570"
+           style="font-size:18.72342873px;fill:#ffffff;fill-opacity:1;stroke-width:0.23404284"
+           d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z" />
+      </g>
+      <g
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         aria-label="{"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.23404284"
+         id="g23576"
+         transform="rotate(180,51.892944,87.3085)">
+        <path
+           d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z"
+           style="font-size:18.72342873px;fill:#ffffff;fill-opacity:1;stroke-width:0.23404284"
+           id="path23574"
+           inkscape:connector-curvature="0"
+           sodipodi:nodetypes="ccssccsssccccssccccssscc" />
+      </g>
+    </g>
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer14"
+     inkscape:label="Logo_colored"
+     style="display:inline"
+     transform="translate(0,17.000002)">
+    <g
+       id="g24826">
+      <path
+         sodipodi:nodetypes="ssssssssssssssssss"
+         inkscape:connector-curvature="0"
+         id="path23538"
+         d="m 5.558122,19.823743 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668807,1.48047 1.480468,1.48047 h 9.625183 c 0.811661,0 1.109108,-0.75875 1.480469,-1.48047 l 4.00036,-7.77454 c 0.371361,-0.72172 -0.668808,-1.48047 -1.480469,-1.48047 z m 0,0.98828 h 9.625402 c 0.281935,0 0.621179,0.2415 0.492187,0.49219 l -4.00036,7.77454 c -0.128993,0.25069 -0.210251,0.49218 -0.492187,0.49218 H 1.557983 c -0.281935,0 -0.621175,-0.24149 -0.492189,-0.49218 l 4.000141,-7.77454 c 0.128986,-0.25069 0.210253,-0.49219 0.492187,-0.49219 z"
+         style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#00beff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+         inkscape:export-xdpi="499.60001"
+         inkscape:export-ydpi="499.60001"
+         transform="translate(0,-17.000002)" />
+      <path
+         style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#00beff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+         d="m 47.926633,19.823743 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668808,1.48047 1.480469,1.48047 h 9.625909 c 0.81166,0 1.109109,-0.75875 1.48047,-1.48047 l 4.000355,-7.77454 c 0.37136,-0.72172 -0.66881,-1.48047 -1.48046,-1.48047 z m 0,0.98828 h 9.626134 c 0.28193,0 0.62117,0.24151 0.49218,0.49219 l -4.000365,7.77454 c -0.128993,0.25069 -0.21025,0.49218 -0.49218,0.49218 h -9.625909 c -0.281935,0 -0.621174,-0.24149 -0.492188,-0.49218 l 4.00014,-7.77454 c 0.128986,-0.25069 0.210254,-0.49219 0.492188,-0.49219 z"
+         id="path23540"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="ssssssssssssssssss"
+         inkscape:export-xdpi="499.60001"
+         inkscape:export-ydpi="499.60001"
+         transform="translate(0,-17.000002)" />
+      <g
+         aria-label="{"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;display:inline;opacity:0.98999999;fill:#00519e;fill-opacity:1;stroke:none;stroke-width:0.23404284;enable-background:new"
+         id="g23550"
+         transform="translate(-44.679185,-140.61702)"
+         inkscape:export-xdpi="499.60001"
+         inkscape:export-ydpi="499.60001">
+        <path
+           d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z"
+           style="font-size:18.72342873px;fill:#00519e;fill-opacity:1;stroke-width:0.23404284"
+           id="path23548"
+           inkscape:connector-curvature="0"
+           sodipodi:nodetypes="ccssccsssccccssccccssscc" />
+      </g>
+      <g
+         transform="rotate(180,51.892943,78.500001)"
+         id="g23554"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;display:inline;opacity:0.98999999;fill:#00519e;fill-opacity:1;stroke:none;stroke-width:0.23404284;enable-background:new"
+         aria-label="{"
+         inkscape:export-xdpi="499.60001"
+         inkscape:export-ydpi="499.60001">
+        <path
+           sodipodi:nodetypes="ccssccsssccccssccccssscc"
+           inkscape:connector-curvature="0"
+           id="path23552"
+           style="font-size:18.72342873px;fill:#00519e;fill-opacity:1;stroke-width:0.23404284"
+           d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z" />
+      </g>
+      <path
+         sodipodi:nodetypes="ccccc"
+         inkscape:connector-curvature="0"
+         id="path23705"
+         d="m 24.042453,7.7684013 h 0.98425 V 6.1909995 h -0.98425 z"
+         style="display:inline;fill:#00519e;fill-opacity:1;stroke:none;stroke-width:0.15297562px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23707"
+         d="m 26.264953,3.0725683 -2.2225,3e-7 v 0.7196666 l 2.2225,-3e-7 z"
+         style="display:inline;fill:#0087ce;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         transform="translate(0,-0.617)" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23709"
+         d="m 22.994703,3.0725686 v 0.7196666 h 1.04775 V 3.0725686 Z"
+         style="display:inline;fill:none;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         transform="translate(0,-0.617)" />
+      <path
+         id="path23719"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         d="m 26.41312,1.4850686 c -0.1905,-0.014111 -0.373945,-0.021167 -0.550334,-0.021167 -0.282222,0 -0.493889,0.045861 -0.635,0.1375834 -0.772583,-0.62441639 0,0 -0.772583,-0.62441639 0.282222,-0.23988888 0.663222,-0.35983332 1.143,-0.35983332 0.141111,0 0.278695,0.007056 0.41275,0.0211667 0.141111,0.0141111 0.275167,0.03175 0.402167,0.0529167 z"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="csccsccc"
+         transform="translate(0,-0.617)" />
+      <path
+         sodipodi:nodetypes="csccscc"
+         inkscape:connector-curvature="0"
+         d="m 25.227786,1.601485 c -0.134055,0.091722 -0.201083,0.2751666 -0.201083,0.5503333 v 0.92075 l -0.98425,3e-7 v -0.85725 c 0,-0.5926667 0.137583,-1.0054167 0.41275,-1.23824999 0.772583,0.62441639 0,0 0.772583,0.62441639 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00a3e7;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23717"
+         transform="translate(0,-0.617)" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23727"
+         d="m 22.994703,2.4555686 v 0.7196666 h 1.04775 V 2.4555686 h -1.04775"
+         style="fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23729"
+         d="m 24.042453,6.1909994 h 0.98425 V 3.1752349 l -0.98425,3e-7 v 3.0157642"
+         style="fill:#006cb6;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23731"
+         d="m 24.02759,11.070149 v 0.719667 h 2.032 v -0.719667 z"
+         style="fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23733"
+         d="m 27.29784,11.070149 v 0.719667 h -1.23825 v -0.719667"
+         style="fill:#00a3e7;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23735"
+         d="m 25.07534,13.366982 h 0.98425 v 3.016 h -0.98425 z"
+         style="fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0.21439861px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23737"
+         d="m 25.07534,11.789816 h 0.98425 v 1.577166 h -0.98425 v -1.577166"
+         style="fill:#00a3e7;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         sodipodi:nodetypes="cscsccscsccc"
+         d="m 27.446007,10.099652 c -0.1905,-0.01411 -0.373945,-0.02117 -0.550334,-0.02117 -0.282222,0 -0.493889,0.04586 -0.635,0.137584 -0.134055,0.09172 -0.201083,0.275166 -0.201083,0.550333 v 0.92075 h -0.98425 v -0.85725 c 0,-0.592667 0.137583,-1.0054166 0.41275,-1.2382499 0.282222,-0.2398889 0.663222,-0.3598333 1.143,-0.3598333 0.141111,0 0.278695,0.00706 0.41275,0.021167 0.141111,0.014111 0.275167,0.03175 0.402167,0.052917 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#006cb6;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23739"
+         inkscape:connector-curvature="0"
+         transform="translate(0,-0.617)" />
+      <path
+         d="m 28.921204,8.5335684 c -0.677333,0 -1.199444,-0.1481667 -1.566333,-0.4445 -0.359833,-0.3033889 -0.53975,-0.7307356 -0.53975,-1.2810689 l 1.04775,4.856e-4 c 0,0.3033889 0.09878,0.53975 0.296333,0.7090833 0.204611,0.1693333 0.497417,0.254 0.878417,0.254 0,0 0,0 -0.116417,0.762 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23748"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="ccccccc"
+         transform="translate(0,-0.617)" />
+      <path
+         d="m 29.799621,5.3903185 c 0.465667,0.1128889 0.811389,0.28575 1.037166,0.5185833 0.232833,0.2257778 0.34925,0.5326945 0.34925,0.92075 0,0.5221111 -0.197555,0.9383888 -0.592666,1.2488333 -0.395111,0.3033889 -0.9525,0.4550833 -1.672167,0.4550833 0.116417,-0.762 0,0 0.116417,-0.762 0.359833,0 0.631472,-0.077611 0.814917,-0.2328333 0.183444,-0.1552222 0.275166,-0.3563055 0.275166,-0.60325 0,-0.3175 -0.165805,-0.5221111 -0.497416,-0.6138333 0.169333,-0.9313333 0,0 0.169333,-0.9313333 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#0087ce;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23752"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="ccsccccscc"
+         transform="translate(0,-0.617)" />
+      <path
+         d="m 27.926371,4.4378185 c 0,0.3245555 0.215194,0.53975 0.645583,0.6455833 l 1.227667,0.3069167 c -0.169333,0.9313333 0,0 -0.169333,0.9313333 C 29.298677,6.222874 28.910621,6.1240962 28.466121,6.0253185 28.014566,5.9265407 27.644149,5.7677907 27.354871,5.5490685 27.065593,5.3303463 26.920954,4.9987352 26.920954,4.5542352 c 1.005417,-0.1164167 0,0 1.005417,-0.1164167 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00a3e7;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23755"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="cccccscc"
+         transform="translate(0,-0.617)" />
+      <path
+         d="m 31.048454,4.5436518 h -1.016 v -0.0635 c 0,-0.5362222 -0.342194,-0.8043333 -1.026583,-0.8043333 -0.338667,0 -0.60325,0.067028 -0.79375,0.2010834 -0.1905,0.127 -0.28575,0.3139722 -0.28575,0.5609166 -1.005417,0.1164167 0,0 -1.005417,0.1164167 0,-0.4797778 0.1905,-0.8678334 0.5715,-1.1641667 0.388056,-0.2963333 0.889001,-0.4444999 1.502834,-0.4444999 0.578555,0 1.065388,0.1199444 1.460499,0.3598333 0.395111,0.2328333 0.592667,0.5961944 0.592667,1.0900833 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#006cb6;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23758"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="ccssccccscsc"
+         transform="translate(0,-0.617)" />
+      <path
+         sodipodi:nodetypes="cccccc"
+         transform="translate(0,-0.617)"
+         inkscape:connector-curvature="0"
+         id="path23764"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         d="m 33.742924,15.878152 1.3335,-4.191 h 1.026583 l -1.87325,5.312833 h -1.142999 c 0.656166,-1.121833 0,0 0.656166,-1.121833 z" />
+      <path
+         sodipodi:nodetypes="ccccc"
+         d="m 32.536424,11.070152 1.2065,4.191 c -0.656166,1.121833 0,0 -0.656166,1.121833 l -1.248834,-4.370916 c 0.6985,-0.941917 0,0 0.6985,-0.941917 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00a3e7;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23766"
+         inkscape:connector-curvature="0" />
+      <path
+         sodipodi:nodetypes="ccccccc"
+         transform="translate(0,-0.617)"
+         inkscape:connector-curvature="0"
+         id="path23768"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#0087ce;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         d="m 29.890591,15.920485 1.344083,-4.233333 h 1.30175 c -0.6985,0.941917 0,0 -0.6985,0.941917 l -1.386416,4.370916 h -1.17475 c 0.613833,-1.0795 0,0 0.613833,-1.0795 z" />
+      <path
+         sodipodi:nodetypes="ccccc"
+         d="m 28.610008,11.687152 1.280583,4.233333 c -0.613833,1.0795 0,0 -0.613833,1.0795 l -1.756834,-5.312833 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00519e;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23770"
+         inkscape:connector-curvature="0"
+         transform="translate(0,-0.617)" />
+    </g>
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer16"
+     inkscape:label="Logo_gradient"
+     style="display:inline">
+    <rect
+       style="display:inline;opacity:1;fill:url(#meshgradient23819);fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke;enable-background:new"
+       id="rect23817"
+       width="59.111"
+       height="16.382999"
+       x="-1.110223e-016"
+       y="3.8147118e-006"
+       clip-path="url(#clipPath24955)" />
+  </g>
+</svg>
diff --git a/logo/FSFW_Logo_V3_bw.png b/logo/FSFW_Logo_V3_bw.png
new file mode 100644
index 0000000000000000000000000000000000000000..99b9b4f9608f4e53b86ff83747a114477004c9f1
GIT binary patch
literal 13369
zcmXwA1ymF6*WMW2&1h-qP6sF{ASxv&T>{cDx}{qrCS4**4;3aLj2s~;>gbW1NP~2I
z^Y=gB;cRDTZ0~#D``&o&bMKNLKh&inXCnsy091PSwTuA(f;Rl?K2l=*vycAE7ytkm
z=ccLoSWi>)mXDwJb2krX0N{33M3(CP-n$(Aww6^DxzvHQbVHAe#gdqOr$rdcHQqBl
z3y}J9L{T8eFD#Mq(!IMov%e-b^<x8d!^>Nzz?C)JTO6;zwWRQ;q<sv6dv`~5XAyX<
z6aV4)FT%1Hd07ty<2<~~NINTN_(=Iu5Pc6K9x|HjaoC>h?f;b+_}DRirF@>-F$5^R
z3mJj-@-E&gS^NYYyXd2P@|tnQf5kUe;{N4ez|6Yhn0De7MApG+>adT_p&Z@qNAmG?
zIsGF#T_&^2@Ti~8@rTSVpN$>s!wy&y4rYgCez{TeC2Nb_ivzIA=NQGrgX`IZ1*blh
z?(NYiM`l^cd>OV|v$)G7!jGc4Ch2OIr`Xq16wU#(*?L?!GLr5PjJA13anA)F5|Tnd
z=FjGAJpr<%Z-31_J0d0Z2C@9|G+YEp1VwiXS<CS2l2075kRvZxBTT5l2%^wm^NY_e
zlp+8!(`K8*N=k$SDLG$v_IFCg7Oz#mZ|;(ezx4a2`jA@@e=Wog2D(~+n}2_0U#qk6
z?~wW2f9ekaNbvo80E4U41MzQ?K=ll@N!BR1XavM>xd;ma0Ji{oTK7zYXSa((F1f$|
zKrMCI9-EPlz9hZ(-r7UEAnCQ7!-<8Zfu)0+k#-?(GCJkGxOn{&)x3)PTZBCDU4F)7
zfjm+Nsu{kaLsT*3rS0pmjXQ@|i}@EJT{ed)eZ^;sVLSQxve=R^YEqs!T8;mIx=kEF
zA4BV)Jf370Gj=!3Zhg&y2uw47n=V<zhqOsyPkN6`N?dsn_|5>LkyJHl!Aq+F7>zc}
zcHCaW<#CL{{KjnkWT1auM;;L>5dS1n5g-oqFXMUx4FBA>FTD4Y9>s50@$R$S5izyR
z@J%6cM;1q;5Vzep0k@uq1}STsMxUOposgZVU20#G$Fo(n01{$?3xO+3=Iz&xZXNmH
z!HUbvTgok0V_jW^;EqQGGysNZZF(533^bm0-3esJVh7mcD{_$|Yy)6{VI<Q+M&WJz
zD4U_BYJ$p`u-ED?_qFgx)q?*fElRVTvVOJit4DlwK_qc>>rbcQ)HEz5%DIkP*4JJU
z6s<$wh*yh|SRkPefxo{L??)M^<Ttpt4AdES&gBgh0($a4=NV4SBa6SyGKX2A+XV#*
z&F{Va80{!;%?tPmxF+l%vFbZm?T!CWI<x227;22PT_W<LjbSg$FrPF{0qN~Cqw<ir
z;6A^`-~^M#be;;vXMX44nh59Zh;hj2wTv@x$8cZ->|ByH|0ySFc7llIosaTF&8>(<
z8ko+5q=}~_u<~WUyb^<Fq;yL9l7d>&GmHoZ^ZVrm;mN7a;WWW2{bwNAtq~17t_E~G
zq;Gvg+G=a-1#;6gXcfJT%tKxywgfbi2+CoxwEd2{nCE4l8C`JNR_KMt0d{1lwA9pR
zGy|EFGhWO>-+S$AMN~%<J!1etJ>%CMS$j`nlUtLMcZ{eBVHb!x1}N|^nGH+ElmdhF
zF8`@n?dTC@N1ch-C`k!m3~&w<U7I+GH92zUozVR*0kI%MGa&%MS>eW6qlRhL|E$pI
z+XfQaY*-LQ;RBv1C%@{NMt3RJPD>g+Yy%1rWb$+SJzY>dj8+w}!GD_fjtXek>8K)-
z4c6Ndk&BZ0i5`!T-{$4}*|Y8ysotB}$3<WJ?+TUEee8*HJKneeqk7lp>X~-g&M$~W
zMn#&d$(j`RATy?>mPWixc!5P$`9%&P#Rh*r%7(*2J=T*xFYB)9aY_MNXPW69Pi*O{
z@XKYD>>$%}B$uU;=P_xO#qeF2+om>?Yh3DT@zWUioPh%)ex)ht1gJeZ35h~R#(;ED
z)dv<cC(u+_5O?nBKVQ3Z=WX!sNR2mK?<59%DJPFoMZVJ`_^ROTseMBD|D(a~;WJ~z
zEo4wJYiC>v!33l~q7~5krQT+RffoXGB&QR+15i!J77;>(C&{u3l#%z4)dPnLz)*wm
z{|xEWw+?=#i6l)nOiBsiRubtCNz{kprRqCy%dG#lYh|~JL`^frOC&k?HX6COyn6K8
zgGY;Kuu@bjm;)du|EY`Z%`G@tmavczah;^NPyg+>|4euUgH32jjiwNg;gNA6@TuJ|
zy5d*hal(=F<UMpLODw;-LW<HC(th#z0KaOvE1PWipUo!B(3zJ^!`$)T@>`{|>nM*f
z=rP<E(#ny`BaI^+oA~R@<<qLg%;@Rk3^NC*07X|F6bqMo9&D^AutgGtQ+9wlfZ>9Z
zL?h{lBm2%H;sJc5h`U#;bxZ4U2SwfH%&{7#T7DDTg3P4cHYX%zomGF8CP@|5yB*y~
zT%4_p=E*{_376J#ujo&xWu;xj_en8-cHzXxYhLI+e)!MoR>JC%#fvA)*p358f9qF0
zS+x+y!WD_A2i7G@O22~_K?w|zvj~e|GRp$#cp`E-(l*w3(nPBCZSL&B8hsN?u$|1F
zBnG9drg;a{)gKaw0^HHNlwY^koMT3GO#T<ul5!Gu2r#V4buTUngIN&(oW=UmPP(X#
zk9t$gy9z-Ib&;ssS!8s?aBrPIMI1HHO}O5HxR>)HM?7#32RvWUpG`3;aVsUv?z-W!
z!{>|g!1EQMkgT4GuO<$)BA(G+Ll;);+auj#7=MhR)tfhz){jC75-|#|pgCN*d5u1W
zVO)edz((e>ac0ShKLsoEPstFhIHt#?1wgC-x3;e7!5)j?BJp#AdOrkAJG2du2x?z#
zE_TgrEBc07Pvs_=kDudSw*D+7SY<)enjI$Q^CoTncIQqIU<@g)tX>?Bk)uM4TT^)o
zxuy6!Yg>7EG~T@klG>v&H2GoS)Pen(HRu=BX-oKk@H&a&cUG3AO##OEl9M8BpvswJ
z!yVOM0ahm|F`(q86H<*9&4&Hx25v@*merSET@*~syCzr$Qmd|Zk4G=Lwbcx0X<8~9
zA2{}|MO?G@1X?9s;s}dgQn)FxVBg^5qbfOq+*M+M7P*PwJj}#&T=Fa+nBTdH_^%R7
znYW%3nAh(FTfK|>97ByLJ{8Ztu_3`x6cNsAIKzMTzB*}o_CWg6_ATG_9vy_)j2C_U
z{jD|zUwf)Blt>(CNOHU?V};umNJ3aqtC}9MYuOYAuk{Vrd@((4BOLHM#7=RZzA#q-
zIf>ABbBnxq@pZSRhio9kjW5f2covZ>_O%@<wv8wv?znV5#(8C0);yWduwWBs*qw6&
z9<7rM9DkRO$TuOea)r16eK?wkeD3^KNQ@x5WNOXdC}+g(CPrxAMV}3#ZEO~{TvJ7Z
z8eY-D#i&tL4jv4#<#Ws|4HH_25)d#sWrHtwo$$_v>#U56(0l?(YF7IlDFTZ(-Mdi)
zTjY=zkVap>l0n#`^lj%HXO#ABt9z%D6tMhq?HQ_tRNr;e_&sN-G1(`g1*~)9KXRPM
z=mw6lfD@<r#2I8`bjZNr`HOQu6q`Z)<<?9Si-cnaZKnr`mC<v}Rz)xKue8jYKKrV*
zKXE7Zg#uW&VVNr77Mb=^pv(F+>=zuh;Pqbk8|NR@Uk`X|-zXpj=wt791CiIxa!_{r
zOgMvsw5M-Kkh`<%Q;V|S!#UzHKNF5y*Dm3{?eME-uId_#7Uo7dzpMR-%TN8YN|x^)
zHmic8v`@cCYM<K1d`_zWZUArbu=BX_7`qDjhVJCrJ{T`NYpbpueuj{X(0E(L&}5sh
z4`}V{42u-;;oD;tsd`FWuyU|=+|879KP){GF`D*6i(Saw;1}a~2IPzYd+(E2RIA2}
zl7>b(MXvPp?cN#WeJknYr}VbVA9|hnW>rF}tFL_KD<356WTEqvyn6c&#$KuAzOMI$
zTU)+W3L0Spw^g)QC{q70D}PkVTIxn_{i@uO`KM5F<I$R@9ScT2xgiItuNEGeyE4z^
zEDg0>t)V<SAoogscIVf~hzWw1QgMa;4C{83bei`1bIn9GCp_d_eOhjKLYyqtH_R*i
z4b2u0U+Z)@fU=Ki<E(anJ`lf3X1DtCb;aASY4ZoNG}zBk46fcvyA;V1Ds>+!13?m_
zUmh{Yi^sov$a}wE2dS2D%mS3u^Dx>|v;xO!t9Rb+H8!`z1SK3-MkiKDPVO=JbnO@I
z(_2C<Qh`U^^<Yw-W@plCd!^FXwgu{Rf~^)ySZ66{X8)39Ytn30CjIB$*9tGZ4y5^4
zRz?}Im+Tgr6%4$x3cc|>rw1-YvYNPvPPqojw(>dZQ@oGgw|jZSFQS6!@a~+C7VQ^V
zS?OoQLWxTNk-Yn4S!C6#+z0z)do0OfD%3KcipkT&+RDQ;9JbDzXq8M<=sCMkRV9b^
zolyQ~HV@BYz5~JOqI(mT4vf6=mVhg&?Qz}3c{I)~e5?fYO}M$dT}HyA8}=tlQBgq!
zqzj(4O&<9mw&F;)S4uv%L<9zPfUJnOsOos(<jbQ^Ps9Ax`#LXd7)$LFT6PI;;vBHn
z5Y`+0yA+R+p=m|rpY}ZN2%ViX?EA5Ltyj}OF;Hu`&hALFCD6eHk_Ej=ig$gr4UY#D
z$EIlX>8N8+3CAvv_qLvK`Wi4(Kr%(&@=d~tC7g2_GpsCDuS?u;e+ag6J6;%?ubw7M
zzb`dsyKqyr83?I3u2QIaryZ&wGxnF8U&fnDZt$;XPNkAgi4<;73v=@w%PgO{bIZdQ
z=3<~*;V9Km)JXHuci%?ilDaj-_is@{SEL{1gKIT9*p3e#)R`K_B&8Kc+u(&Mhn&LU
zcbam`ucR=4cxez6UPC><n!8N#TK&UMqhZTQ#^ZF4Ye5Rq24G(u-j#UYy)WV=bmn!M
zxRA7YE7MC2^8D5BLSmAH+av*q6xU9b1M;O0HRgTb1(QA7mN%dxQPt#(^3%pA-;nDL
zVr&%hqhF+fXkc(7ao1M~AASkgp`2A)dnaR<dOWRxBcLgLe@5+*Lu$$mP(k{Wy0~;O
zg*z^=KNtFUUB)g2ZzBrGe)V%do;_b6>O*2gXBtT;CPia9C2vUc+N-EK=+=am37@`(
zwFBZ@h76{v*Qd#61+I{koV?pzUBTL>xsR7Ac}2o;4H|0`1+=o7@D<S!k5VIwq~1y~
zV1HupbHLLfOyGCsd$m;lmk(yx&B;b#JdBVX<2TBrt<~Ky6F0lhAMYpZv>|~B$1ni5
z-lGZ!e~)#(L{KRUwC(`+B(ptc2l49Vko?ZbGh{t7;I!JDaYo9PcQEa|@Am$>Gv;}+
zxJUswVC^ZUp-R}&2%Hc#zYa}d4H6dlMQ3m}NJqp~OS!Pgu51qYBVdz2^4_!P=o$gN
zV=X6d*4vgcb)VN#gao5-a^}Z23!`OEBv_!_eq=9PE1@k7RqPY@KlP*Y`t>O(QQViT
zDnc2yl9yQ&(_!#=#l3UpRts^1&#2N12L0y9gSpxl&t6_4OdEbxMFEN&TyHph68o5$
z4B^h=A!5F2j0Hxg)p>7-KjoHap{|HI^It}BZM?A8lYG)A({C;OFcdEL327Fnaz|Rt
z#rSKE)A-Q)8gfxq>^da5?p~x@j-xH!S0f##vuw1veKPw}SMFf4tN11-zXzLeaALq?
zibprXtZngo_b*A6fCwts4BsP1^Yz-pYA);#GwPG!om53inQ#l<)C^{1J2B^%R?65;
zloW<0=I2y4E_kqvFPrT9ML@niWzf)sI7a}2w$2vB=PSMPl&$TfZ#g5c?K`%OHR9wy
zVH}>*e-`PVLW^9dvpiGOFxzP$wTF1)j!0KI7`cn`{cKMe1uM4<-t?_Ci;X5>(8LoA
zK?p9AFNYQOY6E&!OBKozhNX>{JFvluO8LE*d%9kty=5pc@g<i?J}X})JJgAHS#Ulo
z+Ak41IAN`@9c>G^sYgx}r--~?AB{*j3$|W4XBGng{Zg&P%vsHLwCe5=@+S6e=KeeI
zZO-J3g)|kv$4JMJ5vdGSXIx%h=)BkJnQ;07SE$(9uq~CpGz+$$ae}<Cdgmctqfd~`
zQvr^w#H!455=ZZ*vfsb&-BvjHk!4P%*y!x<QD~)*S8f>^nKd<``YbcSN_k9)yHL+5
znqm?jyxH=4u)^`pJ>3n*kzNk|t8|)dP5h0(8;x|2$%4hcQm($ymNwBFn)vK*K(2YB
zkt}Y0&Wc^7O-^HKa^^H5`gCf+dfHRQXKpFM<p43~ltNEj2VkE4)-#op*&H-L6z`Nb
ze=Xmpn0}`e^IpwO0rnwStMh?W%hD6x)m8*YpPCrq*sH;cRi{gX0!hGFvsH(0G-wfI
zzCH{qM^sVM(U7dvXq@?p*uygCXC{tW4Wl+Z(#7)*I5FEIM}LGd1|CE{&)ih}onOeD
zSgX#R^eTHZYl}1<qnmlINWhZvsVNyqql9DgWraMJyiiQY<-#w935iv-E5U=FCsySW
zn0;vf6I$o4mt&UZJyh1g@jksE8@Xe{!r%k!i`60z4tU*|^q?D8Q^~Zbii84gki%|N
zF2VW!7Kw+0t9o3MY5;E-HBlSuY$+Q;as5^-&$axpcs|L;wCy{laPPykZ5LM+e{2@x
zNpM=-OHcnbd8E5><9i$dhnH&<Q3KAz-Yrf%aZNUE`vb$wcgEoCgPhDy@8(%eFkk-Y
zBe)jA(j#i0lWhd0N3fTpw05A#yz6bgl?SqcJPMB%o*CEUP7CkpJ}0QHI?H+mX;VkF
zcu2<uua-EhlU_Qm0v=L?Lv#t$r9S;?hN^YAc`Sig%<~jIO)kf@3|)4@2_g2bT{1p*
zon$uCMooeQBn;mtB{m?t@gWRok^;d9BDTmn^RBW73)$I6;UTR$EEw%Q;g+?-Vv6g>
z6hA7%D39fAP^RU!B=2zMlByy#J^KS8AtbJ>S>a;w@_4BXsw!4RVl%?^0yGEwmhZ1>
zR%Sx^RUXQ14l2ZCy1ey;+z5C73VWZh^Zc!7>zp7;?Z>i)w^+n^io=G51h1&T!4ogs
z?nh#&xmz%GgW?Lug}#v0T0R%%2;^vXqxBLnGdn{|*WCkN*Gi;T;%EYXa%XsAG(8m4
z%joa-G$TSqPCH6x)5ypSp94z2+#M%f^ApGl*^J9)r&Kv$y~g`n|1)DF1OI(r@|J@v
z9@xVC%&9;-AovrZKe)M^qJ>e>fU6oi0kgsD;b-U3_sWVIk0ei%*%jJ^F@d}xl>zLW
zvN7L+;)wD?(er4_<vc(HNq8&%gmvqDnl>vp(k(KHshNv1P=6OkkFzuwq=DecxA)u^
zpzkI}_munHd(}<8{cwLfuWAEmkR7yFks!)XN;Seq)r5Mxhp&n}!tZ*B<70t6@ztA0
zh@qK_tTBV2Fue_FsOGP8!1aza(J9q$7`kO3e*W#%RcEN_betI+wJCx0>|88!YDNPJ
ztG(V&3#o*HImv}sB9Qg){{HmWc#VZ&{9`k$@bPx@bzy)_3T(ML$3@YPj&flK!HJ;|
zQF;z+1qcD}VDdg#M(A?S61aoHKrX8t@Z8G{dHgOptHxt<EXWdp*S(_yE^{fy#W=)V
z86US`phG!pn)r^N$?yBnqSX3urxWCP7qQPHBI0i`0tF+y;5I;4?F7y$FY=*KL~!3!
zhWVi4MeN?io39^VDtFMq+*=1dyr#GB85iQvW5Ko@mPf!=keW2*X()a{XkQC|u=d>u
z?}FfvslI0tY7!DN;mrLL^#&!16y!b~+2Ie8XTOsLx4-;y34j%Tal41|mOfISLOsn%
zlg15(-A%2aITfoEa*Dt&W)avu4*W@3HlFV5Rxak80?Xs7&!Su?m@FEG?Eg>_TnR*^
z`k;|Gq#G`nLaD|s0h5RB_|lbIqovEe8X?t$1KF_7jUCqFaoQy7+(11Y@F+;CW!Q6M
zSj>2UTwhxT+HL0EA^4ath*BcbIt~?x=qSw{+s7gW5Iu_J=D@GqbMHp;jI(iI_e-?<
zvm+o4YU9HnLHuQpP^rjd&%WLKoigWqbL+Q4fjrd8Jb}G~KVioq<Cb+x8YF{N$@|T4
zY2v63I^~x5?whn)uAiCS-X4@OB?E8{@xMtK*E*capKzd^IPskWzkjOhf1>6W%yj;V
zpvlwW$Vz*?oNP(;`D)<rU$AhS)MpX_hM0G3Y=}eOAMc)gUoDraOZXc1vGLHw>R|p3
zEz3{y5vl6LG~#xBQ<OI69)AnR_w-aX9Nhpc%KWz;)XI4xt7BM~D@N4llyoMJPwdaB
zWRo^Ox0JR#l;xwcM3Mc&T*`SjWJnxcl*E=C!L<cZM1C<u*Ncey!^-J7+r=5h2QBE9
z+jQ1dsv1TD!I2H$QDGTzvBtxv@!=2Lxo^o2RMooIf8{1t2G@~tB#3V8KTS~Cm*11|
z5pHs1g|HL&6i(OdKll)sP=SJbmU!@*C8gjaeQZWfMcXP9dPTw<k5&=|>c6|ZZPYL`
z&<qk8v-~iswI1@uJLT~06`8r%iZmvD&2dB2it;4fDs8(OAuwMZ(;nT0IndrIs#Hsr
z!o{ZkmW(ZLZ-?8GxSdz70xB~YJA;R3(U1VF9v)e1;)Nx_qG5GZ3n54lvU@OARBOwF
z@{-f?2kI5&f{I5;o4K%Un-<)IZMnxSJYbDgziH_BMQ?O9Nc|NaO5OJux!xvFgjO#*
zY!K_0#?w+waG>Qw)FUl!X$ILkmL5-<>Y~bZIM3WBN#;2%&#UaGvT(Q<@#WJY<rCBk
z+{6A556Ny%r#afHXnKuP6OzkU-ZJeF&9+a0A?$7GKE7+6S0Pz`F4=TT)nt2Z_jF6X
zT|_)hAEkD|ba_Z~BJPLMbGm>TuN*Nl$qz`4c$tBX{KP$nh)?$HD-dgT!s+qYCNmLL
zCX4sK(^G5-+*xODq$h8Bn(0~)BPRcfmHJ6XUn{2b95Y<cZH$i{li^3&3gBjReav?s
zrh!iW`H6TzB)_I@iH4{pe3HWwo&$FVA9?EZmen8es|<jlYpP}1_b3;3y>!@P6)MSi
zI0^}{tHZ_2&a$)11D#uM-7+#((^L*tD`<i#@a2q<zHUY3KdfX?6}g^ovjxIHb8H?Y
zq2Hs{bvqYMy(qgUJX7j<*Ln+faIW!ljVrZ$K`{G?N-9t!x2rI|^nep{hKPosnHMIk
zW!eX6=Z!OIE9SQV5M5sioy%EtrcJ>CPHE;npCvwS&asnRvg6(8a{4`A;uE+x%d&=B
zjnNS9?^-0?Oepiu0p~+BHJZ4!yqcn+CSOD@`NbqF?77q~c5thY)klZg(KVx<@!Zug
z4EkvxkJsCYmDuycwQ)VdfQ~u<$$%FmeKtqanhs5GUKv5yu=3*@hmG-Jw5-w4FS%)u
zYD_sY;#9KOu(#^-SrBhnNSW5pEsel4Uziw!D$v|#MG>*r_;9WL_a7}s?$*g^U6frV
zwYTvRaM!6rm>QO$g(|^EgIi^tiYRf-l9)NOqIH9<owX4Qu~IW1_}K1q{tHol<18M{
zK?&*;M~uE5jorFPW~IEBZH%|A_xEXC-8)uv)f2;}*kQ*6V3*$C6$x$dw4*4ua!eCL
zMvx(dOVa7cIE>BA*pk^W<{r|VHOdL!v3RPwr1NT2Wc+>^_h;+h%0&27B>Ukmw8(k-
z&tJTo0|yGv?C>hx@}AC8rI2gc_BB{Od_Rx&<TE?tau;YG;u|nZXc&B{pFW?Dj7Poz
zra2Q8DbBR+-b^0pqK1(y#GGg5lO$Fo5O?ri?QKD61vcP~JZ?~yQFi(Cd`PqFb=64N
z<hu_7GXTp?HrBR^Sq@!ic<T*iAJY1pl;#Z<#BM-T;fTP)Ucdq#{(ntZJnqE1lv3Y&
zzAFl~#qG3&tDsETw=y@o@`EDG=6G3RIq!G9K4e?=Oz_CWgQaxSTPiB{6g=%6I8XzM
zxl*a5X;nh|SgyNj>flF~kg)FAATv_nZRYns!awZ!&#GNsmy1p{6G$mnEnXE$DVCME
zhd&H}v1y^I&{InR;^)ycGK=%=|ElydBi-{HkIO`YkH#IOLUbnyql>0OrEp5?ti0O$
zEHyqFWvjoFMop^2gw)!=OD-%-5y<pt^Cr(vAF@ldwEZ!ju^DNiA2<RDp1%zi=HiC$
z%!_N96F#8Xf}bAxeEFie?tph7cYUggRdNq@F?0OZQT81}7kH0awJ=rllfEM;N#f2m
z8c4S}x`{B9$OSj~`>@+`_cP@nNX$de-7wBp@*ik?mjyH|z9_~&<YGQmb=jXze?_i^
znnha0W)$Jmwjyv*it>~Wf5Z54u<IkE;q5!9>R{z-35^A1nJV84;yn_pzr{LjMA{EM
zN;MS6X~G}C91o}K1?7`6YVjGcn0_r@eKt7zBoA-ELpq!@Dg^n{z}9N1MF-hgFFpJF
zMF~^PDVsj^Mv5q+NSdI2PqqWjaUZ;eK~Z_uP8Rqm$q|e%3@`o_mu!~xCq{Hb?+W*;
zngQmo1OyjlhOuG`eiiz4X@{=on;T+1jidp&_7GbF&bP#q``mcMN?d1p1iblqN^e~7
z_Ed>#PGZfFFMFJ5Anf)#t6a~t=6szuZUtJ(aOOlX+iCF6e&(PLnZu`O(z%jk6TCe=
zLDw)Y2;<XvAW{flrmAVM)+czf;$&C!<c~Egd3@`=l#R5x<Zv5UWJ*jXHk9{pnoPEp
z6}rZ!|9Bvh7LV<p{If;|%eLabe7WCm=X`$4a}Hkj%fWxIKQq{1BWL1kDZ9hrG*up6
z?ab&Y98=`s5jg^?+X?E_#@Df;cn=LR>ua7Jb)6_?NVYnb8+P_y2&~ZGN*$g27?`Zq
zqAoCInh2MjE#un-iQ`?8CjmH)sye0f^;K(uR4?%6nTdLYh@!N4VW6b;*CnJdI^wV4
za(i$K3Y$xt@7$a}<wCn8&ZFm6SJJ~t!i({!SH&K`=NGMk2y~#gV(MK%l1g4a-UlTz
zxOHv<?$oLSOk&P0JYxdyt9(Sge`V_J5yd<4^W!!FhVox<rMq!X4MCRj%M7s1D)40l
zKhGs&;h7>pqbJmyGIs*e4%g#)MPOd8Kp7Rfu^#8$+hVnt8mrT1$L9ZX0Y!`RX{vw>
zAh3Jm>%1aCKF3Q)8!x0q2Dj$XV-vyZ2p-Al8)Wg_#}~Sb{1bI|nenvP<)P^qYP*fa
z*SBW5Ta85N5iiKD10E5S{2-~oZpK0(-{-4k#J{vBD?P6bp#-!@f8tKDtP-y)pJP?(
z@mUb{HA~mBl8la}+SbJcx{zbV;bLUN6HL6}nu=>dWdhphJFf8x3Y$$#%K2KzFMAPG
z3nu@FCIg7@tG-t5B16dB7}AW0VM*%8M9arM0j<4+ov@gU<!ZD@E;ZldN5zBbU!zCU
zc5fO}J#Y;`j^~JtC4$awZM8azEtg4*lpg><FY<2|z%@#`!KwB%frir4JPQ%`p3Iuk
zQ*$0+mN;5?p;Ds)X8)^%eJ3f&5d4*pTQf-N8aVLLSJ_nCst71|>~RO5{dq6AxY=f}
z@2=3}J5FjcF2v{?)qe*sj>ea_EY!%nr)zR{_E}U50nw$b4MD;!0v1N$3O)a5C1Aso
zw);26R%Br>?(%4@e^UHJ<;nLf!XfAMz!sxp7-A|%@KE|w6g7hH=$`nlvod4UqXkOL
zIG(Oi`fdk}C<v!a-jziKFDYaX#=UQ&Ych_x=#p&FuhJx)HxZJ-(s~pYKLRnwtG#z-
zg|pj@{0iaOgX8(W7UX*L-*pJaAi3T_6V^8&ZroP-(RVS*_KBhIm7FM%NleU$o4@Kr
zx6fz@VjA+<;$VRTY}0+#+r%U_l)~N=zs5n;@nl`C#V~E5g6%i6_s$`*K2%Iso58AE
z$d(JF!xAx}xLSJq)Wl934|3<-C$diV8{aVVx!8-ont<D_hD|7SzTnJ;oL|Eje{Eay
zDVJK7LnLbNl`2Xd?_0lMX!|~d9)C4_!}Ve-EK2ot<tpwaWcAy$WUpvb;<8F_%y^ZM
z5uCFDQYMMT)VxbhfJ@xS<qp;i7z&TgeAbCrsO&ksU@99|d|W8-w_?%Xu&Li#4K!al
zrzTPW>QYpZ7{EgpRnD7dhozX;H>n7v-ibhwy+_G)A}0-lCAv-3y|wY>?Q|`WMyg37
zbkp$F;&*iCljPs2FL2ic79$hajO4UI!ZPc(?eN`Bd+n&FUdaZxw@1Fj<x4(ZLp_SN
z87S0P=hHTN3P_VF`A&6ek0D;2I(1{Zm}jzdI5&@BdGVISko<l7Xw1EY<4gia=!mYi
zD28A2qCGqFMuWZ0Wp#J-3V^V}<H~CG*-om<MlC_|hjcwG$AdVPA9B#tmC<+yFD-V`
zIxkmsi`GymN9xV<Ic>&og>$dU+f^q}KG!q1cVrX-f&Y2kux`rAq15qSJkV@w=^5Hs
zS3Gq)n#l>rT=E2u?{`7?&aV-iz~^Q8RXqZ{gWsRo;L4gYh?PA6U$$i*InWE(1COBw
zbC19JjfOb|*AF1}-gf*3Tn<iL>tVz{R4AhC3{n+M@x0>d{y5cF+PTFdI}4diFWZ0A
zIlav~OO|AqeQGuP%VAw|RIuYk2AUq0Nz!?LQqn*GRT#~emJw$iU0ZW&NmaJfChDNk
zw(CxdVeZXO&ox7LJocZ9spfBa?^+6O>zseHqRhpSxmv33$=gr)jpg?TlqbRdkF5RM
zveEIf@O7!JXMQ0Z4mrAwB1a$S_R8V5e6<se8OZSFQAr5V%~v)z_}X$wYJHg&mxq?`
z0ghVX=+NEHMD=CmDo1R_H_%Vf=6!-D_NLFv9ri=9W_`Wa$bkWpdb|Q<vIN7Ig%HKN
zAr61j&L_y`Hq&zh(ez`P-CTT}qT4>~Y2ja3gN^VcyO|FWZ}^vlO>^FF(-ZZ*;?fr~
zWY`|&{RvW~9~0Ng^TuyzoqG!+%9)xp$081>EKk9fB7=~Rl9b36k>Fy}@j{0EM$<OH
zTqlJQHSuzfW%!%S+WDszn=!?3aZ9TNJkP$0MXv}v(j-G^E3>AGzIL>4<+yO%Pg{%;
z*L_iv&>-+GnAxY$bUc+AnU!$7>hmR88v^ZV`GwIZ?<D)grSvU$%;`6tVFX^gy51;B
zJ#%0X5HLLLkyvBdeX*aG(f4FFz<oX;x6Uouzv<MEL`t&;+i!z!+1z_7=CDRHM3P10
z@8jk~VW`?bUl4DD=S!6c%-4rtJoNdum4EKVo5hU!Z>Bc79En;*gr=5TdduC9_+1EY
z@4P+tQr(hu&O1|q3e~5AT*mW?7=?Gtixb-(5bS+B%iji!(4IU+Z>s|triyQAL~8OS
z*}A!MsV+xeRvRx*VqlbAlj@0)yUwl`tj~Cw?IKDWNs4&k+P$P@`7U!$k)^{@xKO)y
z`$fz{nuk&mWO)TGNGh}l|A%m=P{tFRx-ZQMl56(3owP0&=rsLJMCQI?bNHB|G~2jh
zC8av^^LI)vxA%Un<x39hS<8&)X-L7Ar-YeH29ShX%cP#sQJBD>Yj&9Hx&LotVb=@;
zQ7EM8-Ezl8jIKcE^!rnNID+i7s{HC5auXTGdTcKl>m}|szerKE6|ysoSl<(p-8`g5
zP(eFydvp&N2#>RqZovjGfL1(ARf%G1e-TB0bO8~R*ipckWGXG&>ZWCNdb>4^<&2%t
zLuLm9bwRwl7AN{FQ{;_41Nqpz7IS?$x3<v>3J;V0<%on{n!869l$X1cSq8UaxW_;5
zX=M_R8H9M<vGV#+84#vB9*=;=Rl$!N`?l*Cc*TDajO$Y}*?%Qr*K?9zci$3jY<?j7
zlRau2H%NSLlPc%<SBG`}F8n*=&y}y|GG2{wv~Kwt$sJ!(xgp<0P6-$th-bgOB6^bP
zWs+RCVewJ&XdphqImWvso(Ne?b=fZPFv!15lQ?2=EVy{0hk4V#v-;!8n$u$Z{oY$s
z{h=hDID#SyNaGokF!*IEmi~u46i=wjWA9l#0gRyZn18oz?wzEmY4j3F?8sl+bWxsv
zO)TFYd7G&?O5rYyeO8~NMqyPpXY$sL!zW^f*sQCM>I;mL+1^RaC%NwxnJw#_B5d%*
z!-Bndv1Z9jQrP);qLIPb$p>U`ulMt;=ieM~2?(;$bKj>UuaG7&?a)+m(0AXNPx|IR
zphHz}PNF$|Lzv?&xNP|q;{!LI_v#KDi{5v-XGdj=d$hj)qtl)u)gq8h&fv7?kxwD)
zd$Y3FNvn64H>poUA$abW-&qi_snIt>d!B=$!(<>PLUF^@ctt!|-(MoH8-fAMH@F(H
zYqrK}F%!}_7}TRnhADPVLv>2+XUx*YmMOMHwoXbCS~7{wd#oqXoj;ZDWBJ=ERFxb;
ztX|HU+UT>9H$-v6ygil3U0If}?pB@s7yRU`Z7<JE6~pZr?8L`gMnqri6M8uh!1S9X
zEhrZrI}%3W8~68ajsLlayq4pr74Kt0k~wqPUCDG3MrF<k)bauxq-~e;dc9z`Wn7q-
z#sb<PDtb=c`167vcY8lwvC<6z-=i_@p4g_Y^FH-K2v3CA^iKo=?bms}lA%dY@6`0%
z?p$`jfc3$!KaMzw4OV<3{~95nLMNF?VCi^bLlz}wP`n_}U<ZyB4==yd<Tbo>@HegV
zC55&nR~~pQJ^F{=mMkK-;t{CWWkh5c71zqELZw8G24nk8t}hWw@)sD$mnz#YC!-Wf
zY-r&SC7J>8kl(dUm){<3M4DSsPbAapHFSt;wl<w42jub@o@%uAp^xlyT-w9nA^uar
z0pbZ>g91^%q(2qY?<olq=n@qBI@j$Ic20Y85HZlN23q&ZR_s{>O?HwM<#N==P`zgH
z3fsD4tc?h#?x607Hc;lR>5cMjpNp^nxh7MD(0;}WVrVPN-A4mnNQ1rqdYtg=@iyhV
zTwE)8mr2%wEQ4E$_0aZ43+X3*xCbN+`WXY^3=UJ$AuUOMQWP+=KSZBmtVoR<sZrv5
zXIx+P#ZooN1ycnP0zpgHV+I_A%v^^Z$Cd+sO6+kbP!F@S40)@Ig6O|+Dlew*L1IEU
zUqLPKv;m<8VXx@G@!bEe$~8`$vW!7OXED(-J)-q3t2@<^+^1HLl6DEq*#f;e&ln5_
zH6Z2DG$%F6FP}5vr66~2iC&=eJdpxF`-yHBf_uI@tbg4?-t^UFE)(t?{a)c`=J3sC
zAgxA11MSLOIQ0XCPdCzDdS-FmAoRi1PFfT=+B<wl&MGMu@AOv*$DJj(g}p|CAO?GH
zpB8Z2?y|lZ#eXwwoxK*Ca~r04eYQ>`5Dc~Eg#yAuaKusj((#qIko8k9g97-@DN{Xq
z#AoymsN|Od`pKi56qEl(+|q1b-|%G-#mk3x3yq=ym$GYb4Ow#n3g9gW@<O!-#9TDN
z4}%QUL?T!#=kES*C@$o7zd^8kvN(7LmG^qQTE76FhzzE}7^;Ee?6W5)r#GGUtiMRq
zsxMe)CG>r1{u7aoiW|_#I;%)btncy9>~RDhZD}`4^yYP_#P;l^N2vng<t!7tpj8M|
zvz5JNuWbLen)!d*IXf8A1n^5_n8e-7Tc)_mb9^i@G)R8osVDpMWfh7=k>oto2CKa_
zqf;~FJ8-i0**NNdV|}AH4yiCJveU{wX37&s(GP8Pdqhhf6#i)mFEk<XqM^$pQ#~w!
z1M72td7QkxSTItW7mZ}<l>Zx6EszzKRuSU>)d@`!bz6BXQ>aFdQC)^HT>Af9%oHuR
zB%>G-9DUR1+ewPx!ME&WTZ|Evz5==b8<!nfe&KlW96?`WDA0DRDNb^FvdKJ%q^uY#
zuj4%JZBVpRKoxE!Kj0n9iR?w@+{JoJ#&&nU>C)Sd$In-)KLMz93mmp`u;e&hCW285
zqD|L|y-a}p?VDmMt5v^of9y(+d9xjpm9pbf<jwIN?5?ZQiFwTC;w;id=PHcYGTH9m
zfNALUtDXsKKoP&DB58y4QIz14jbI~cd+|hB@z2zkM{MU;3y%}Kf=d+fT+ib`kd2}5
zIMu|eK7N+EX_7oxy$XJZ;AY`m26||(xC#!mU76pe!g3b-b|r!%!xWZ0Aho@@U4NCm
zO`{J#i%Sgr3~f|R@A#rYnCbwHCxzuBXN1R9$%CoU&m8JlPk^?pRIB|K3ebf--!AbP
z_JWljCO}L1vS9#~ul3!-X&LDq6h=c)OpGuCl_#M6Z=RdXFxo{A`@@=}>&!gGT(zE(
z%i1TzECRLHO+S{X2pJ!$gnFs&WtA_bD%uxgXRaxFEIeH)IY>K9x~~EnxQzad@H%@C
ze5=7Ycid9Gaj-LEZ8LKYT2+c9^w8N}g^Ta^@A6|G9C+L`vW@G>Vz6&h`>hXxa~%>%
z$ne{D@70pq4yR_GAq4(L_;87{ww+CJV7revQ8UQj3CDldrguT<2RHfU+YjXnQpI0q
zesyD=*R^fhni|FL94F;xuQRZ-;wa<wJHWCh^_OI7IfVq*k01_7AOmDBV;nxd4X<J?
zeBt`*eM<8Zqq+QE73FSW$SKPK-U4{ygaVN2vI>DL+`Fp>Eju9StMWqOur)cCYV7<j
z${%;At$gwY<i)q-Y|0$gUbhNXO~FszCS9g2EGvIS!XP&IS&$2+CMJm=`IHM#Ig)o+
zDcums;?g|L($?XoC{e&1P!~VdZ!>gO@+NWQId9x;+H?T|9`b%(jF#1A)5w`%qTA29
zQjXN8q#f}TL2n2;C?KSe8sVoB{?YBxS27(NPMH3piwH?6x!yltV@8w<6F8%}LGFNB
zkUP-2Rw?mgOzfaqZsEVP<n^>6Db{uutY>}oG8{#-by?>9Li3urZQ|8_EgP3O|G?^}
zZAATeJidfnCuP=Pq-9E@tw22J@#Me50FyM28~KVLxb@W6o$0)T6jshB+8~MPuue5N
zIeu$u@n3k@lw~*n;l_vIO6J3bw24-_M`)?V^Rn@Z7Kc*5u_!wWr2t1;K0Vdn6pf>_
z=F##DkqwbP!Ixtk_xwzBetqF&k+r7U=@nlxAMT=%(d7okMpOM=zWv{4gXd|EfT09I
z=99PRN3dMYWVYa^{c2G<=TuI3)y#uW=R4x(*1iZf<iIsz;$D@D#*w~3#aL&voZP|$
zB){GG_E1et#9n3ZF%{*JJ~(x5nwgCvS{mU2{<BQp{4KA5{J&Je@eTtq{j(~=VD$j*
zATXj+wM-GTERtuI9VQA<f7=wFkC@1eLC87Z0V!r11}D(+-p$c9Pg1go8wt6%?L#p3
zeU1f9hNibL<E<e-0ep<k6CUR_i&az4oCCn#IV@V$u)o;1-r&EAVgpk_iZ1cDg3mS;
zeGdkhiV%>qFl--YfgVkW%LDfs3e-HvkEgIj3-y2b_+h@i;F!-%&c`Rkf43*z(lqwO
zSJ`{%e%hQ%G@0oVNaBA7PWynUd1UY;@<m*&)(<N4_!>}?z8|zNUVE)S5#6l&K=M^x
z;{zwx^_jlM4Md9kZFcLstXJ3V$!ZS_G9JBNjhNSIR(u>@kMG4?(<pU2k4}x7+T(vz
P0?^ZbsMVlh_wxS$e42C#

literal 0
HcmV?d00001


From 606aac687b7d4eec45fa285f16d37958dc7a618a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:44:36 +0100
Subject: [PATCH 1063/1774] make event api change

---
 events/Event.cpp | 6 ++++--
 events/Event.h   | 5 +++--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/events/Event.cpp b/events/Event.cpp
index ea3d46fe4..0f76b4386 100644
--- a/events/Event.cpp
+++ b/events/Event.cpp
@@ -1,4 +1,5 @@
 #include "Event.h"
+
 namespace EVENT {
 EventId_t getEventId(Event event) {
 	return (event & 0xFFFF);
@@ -8,7 +9,8 @@ EventSeverity_t getSeverity(Event event) {
 	return ((event >> 16) & 0xFF);
 }
 
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity) {
-	return (eventSeverity << 16) + (eventId & 0xFFFF);
+Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
+		EventSeverity_t eventSeverity) {
+	return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
 }
 }
diff --git a/events/Event.h b/events/Event.h
index aba156f29..90ff1a901 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -18,9 +18,10 @@ EventId_t getEventId(Event event);
 
 EventSeverity_t getSeverity(Event event);
 
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
-
+Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
+		EventSeverity_t eventSeverity);
 }
+
 namespace SEVERITY {
 	static const EventSeverity_t INFO = 1;
 	static const EventSeverity_t LOW = 2;

From 94b108e03df766c50dd3178b95264b6a3c663d9c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:45:23 +0100
Subject: [PATCH 1064/1774] changelog update

---
 CHANGELOG | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index a6686478c..c221c811e 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -11,3 +11,7 @@ a C file without issues
 - It is now possible to change the message queue depth for the telecommand verification service (PUS1)
 - The same is possible for the event reporting service (PUS5)
 - PUS Health Service added, which allows to command and retrieve health via PUS packets
+
+### Events
+
+- makeEvent function: Not takes three input parameters instead of two and allows setting a unique ID

From 0116bb86635d9480f74b87e83a267d66e6f904e0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 18:15:09 +0100
Subject: [PATCH 1065/1774] replacing global pool with local pool DHB

---
 devicehandlers/DeviceHandlerBase.cpp | 39 ++++++++++++++++------------
 devicehandlers/DeviceHandlerBase.h   |  8 +++---
 2 files changed, 26 insertions(+), 21 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ccd5bebb3..969c4688d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,6 +16,7 @@
 
 #include <iomanip>
 
+#include "../datapoollocal/LocalPoolVariable.h"
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
@@ -56,7 +57,7 @@ void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
 }
 
 void DeviceHandlerBase::setThermalStateRequestPoolIds(
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId) {
+		gp_id_t thermalStatePoolId, gp_id_t thermalRequestPoolId) {
 	this->deviceThermalRequestPoolId = thermalStatePoolId;
 	this->deviceThermalRequestPoolId = thermalRequestPoolId;
 }
@@ -211,15 +212,15 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	fillCommandAndReplyMap();
 
 	//Set temperature target state to NON_OP.
-	GlobDataSet mySet;
-	gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-			PoolVariableIF::VAR_WRITE);
-	mySet.read();
-	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-	mySet.commit(PoolVariableIF::VALID);
+	LocalPoolVar<int8_t> thermalRequest(deviceThermalRequestPoolId, nullptr,
+			pool_rwm_t::VAR_WRITE);
+	ReturnValue_t result = thermalRequest.read();
+	if(result == HasReturnvaluesIF::RETURN_OK) {
+		thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+		thermalRequest.commit(PoolVariableIF::VALID);
+	}
 
 	return RETURN_OK;
-
 }
 
 void DeviceHandlerBase::decrementDeviceReplyMap() {
@@ -508,14 +509,18 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	Clock::getUptime(&timeoutStart);
 
 	if (mode == MODE_OFF) {
-		GlobDataSet mySet;
-		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-				PoolVariableIF::VAR_READ_WRITE);
-		mySet.read();
-		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-			thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+		LocalPoolVar<uint8_t> heaterRequest(deviceThermalRequestPoolId,
+				nullptr, PoolVariableIF::VAR_READ_WRITE);
+		ReturnValue_t result = heaterRequest.read();
+		if(heaterRequest == HasReturnvaluesIF::RETURN_OK) {
+			if (heaterRequest.value !=
+					ThermalComponentIF::STATE_REQUEST_IGNORE) {
+				heaterRequest.value = ThermalComponentIF::
+						STATE_REQUEST_NON_OPERATIONAL;
+			}
+			heaterRequest.commit(PoolVariableIF::VALID);
 		}
-		mySet.commit(PoolVariableIF::VALID);
+
 	}
 	changeHK(mode, submode, true);
 }
@@ -1374,8 +1379,8 @@ bool DeviceHandlerBase::commandIsExecuting(DeviceCommandId_t commandId) {
 void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 }
 
-void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
-	executingTask = task_;
+void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task){
+	executingTask = task;
 }
 
 // Default implementations empty.
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 627a64238..f5d6ec2b8 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -103,8 +103,8 @@ public:
 			size_t cmdQueueSize = 20);
 
 	void setHkDestination(object_id_t hkDestination);
-	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId);
+	void setThermalStateRequestPoolIds(gp_id_t thermalStatePoolId,
+			gp_id_t thermalRequestPoolId);
 	/**
 	 * @brief   Helper function to ease device handler development.
 	 * This will instruct the transition to MODE_ON immediately
@@ -699,14 +699,14 @@ protected:
 	 *
 	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
 	 */
-	uint32_t deviceThermalStatePoolId = PoolVariableIF::NO_PARAMETER;
+	gp_id_t deviceThermalStatePoolId;
 
 	/**
 	 * 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 = PoolVariableIF::NO_PARAMETER;
+	gp_id_t deviceThermalRequestPoolId;
 
 	/**
 	 * Optional Error code. Can be set in doStartUp(), doShutDown() and

From 3fb3039be530acdc21f41ca09dc7fc9d276827dc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 18:16:26 +0100
Subject: [PATCH 1066/1774] minus 1 replacement

---
 devicehandlers/DeviceHandlerIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index f64e1589c..f09ddbb82 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -21,7 +21,7 @@ using DeviceCommandId_t = uint32_t;
  */
 class DeviceHandlerIF {
 public:
-    static const DeviceCommandId_t NO_COMMAND = 0xffffffff;
+    static const DeviceCommandId_t NO_COMMAND = -1;
 
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;

From fff928a191eced806e6f8aa9fa2e58d2c26b3565 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 18:29:00 +0100
Subject: [PATCH 1067/1774] bugfixes and improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 45 ++++++++++++++++++----------
 devicehandlers/DeviceHandlerBase.h   | 20 +++++++++----
 devicehandlers/DeviceHandlerIF.h     |  3 ++
 3 files changed, 48 insertions(+), 20 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 969c4688d..60929fcd3 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -13,10 +13,11 @@
 #include "../ipc/MessageQueueMessage.h"
 #include "../ipc/QueueFactory.h"
 #include "../subsystem/SubsystemBase.h"
+#include "../datapoollocal/LocalPoolVariable.h"
 
 #include <iomanip>
 
-#include "../datapoollocal/LocalPoolVariable.h"
+
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
@@ -57,9 +58,9 @@ void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
 }
 
 void DeviceHandlerBase::setThermalStateRequestPoolIds(
-		gp_id_t thermalStatePoolId, gp_id_t thermalRequestPoolId) {
-	this->deviceThermalRequestPoolId = thermalStatePoolId;
-	this->deviceThermalRequestPoolId = thermalRequestPoolId;
+		lp_id_t thermalStatePoolId, lp_id_t thermalRequestPoolId) {
+	this->deviceHeaterRequestPoolId = thermalStatePoolId;
+	this->deviceHeaterRequestPoolId = thermalRequestPoolId;
 }
 
 
@@ -211,13 +212,17 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	fillCommandAndReplyMap();
 
-	//Set temperature target state to NON_OP.
-	LocalPoolVar<int8_t> thermalRequest(deviceThermalRequestPoolId, nullptr,
-			pool_rwm_t::VAR_WRITE);
-	ReturnValue_t result = thermalRequest.read();
-	if(result == HasReturnvaluesIF::RETURN_OK) {
-		thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-		thermalRequest.commit(PoolVariableIF::VALID);
+	if(deviceHeaterRequestPoolId != localpool::INVALID_LPID) {
+		//Set temperature target state to NON_OP.
+		LocalPoolVar<DeviceHandlerIF::dh_heater_request_t>
+		heaterRequest(this, deviceHeaterRequestPoolId, nullptr,
+				pool_rwm_t::VAR_WRITE);
+		result = heaterRequest.read();
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			heaterRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+			heaterRequest.commit(PoolVariableIF::VALID);
+		}
+
 	}
 
 	return RETURN_OK;
@@ -509,10 +514,11 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	Clock::getUptime(&timeoutStart);
 
 	if (mode == MODE_OFF) {
-		LocalPoolVar<uint8_t> heaterRequest(deviceThermalRequestPoolId,
+		LocalPoolVar<DeviceHandlerIF::dh_heater_request_t>
+		heaterRequest(this, deviceHeaterRequestPoolId,
 				nullptr, PoolVariableIF::VAR_READ_WRITE);
 		ReturnValue_t result = heaterRequest.read();
-		if(heaterRequest == HasReturnvaluesIF::RETURN_OK) {
+		if(result == HasReturnvaluesIF::RETURN_OK) {
 			if (heaterRequest.value !=
 					ThermalComponentIF::STATE_REQUEST_IGNORE) {
 				heaterRequest.value = ThermalComponentIF::
@@ -987,7 +993,7 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
 		GlobDataSet mySet;
 		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
 				PoolVariableIF::VAR_READ);
-		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+		gp_uint8_t thermalRequest(deviceHeaterRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -1015,7 +1021,7 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 					MODE_ON);
 			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
 			GlobDataSet mySet;
-			gp_int8_t thermalRequest(deviceThermalRequestPoolId,
+			gp_int8_t thermalRequest(deviceHeaterRequestPoolId,
 					&mySet, PoolVariableIF::VAR_READ_WRITE);
 			mySet.read();
 			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -1393,6 +1399,15 @@ void DeviceHandlerBase::performOperationHook() {
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
 		LocalDataPool &localDataPoolMap,
         LocalDataPoolManager& poolManager) {
+	if(deviceThermalStatePoolId != localpool::INVALID_LPID) {
+		localDataPoolMap.emplace(deviceThermalStatePoolId,
+				new PoolEntry<DeviceHandlerIF::dh_thermal_state_t>);
+	}
+
+	if(deviceHeaterRequestPoolId != localpool::INVALID_LPID) {
+		localDataPoolMap.emplace(deviceHeaterRequestPoolId,
+				new PoolEntry<DeviceHandlerIF::dh_heater_request_t>);
+	}
 	return RETURN_OK;
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index f5d6ec2b8..b41e7407c 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -103,8 +103,18 @@ public:
 			size_t cmdQueueSize = 20);
 
 	void setHkDestination(object_id_t hkDestination);
-	void setThermalStateRequestPoolIds(gp_id_t thermalStatePoolId,
-			gp_id_t thermalRequestPoolId);
+
+	/**
+	 * If the device handler is controlled by the FSFW thermal building blocks,
+	 * this function should be called. The device handler will then take care
+	 * of creating local pool entries for the device thermal state and device
+	 * heating request. Custom local pool IDs can be assigned as well.
+	 * @param thermalStatePoolId
+	 * @param thermalRequestPoolId
+	 */
+	void setThermalStateRequestPoolIds(
+			lp_id_t thermalStatePoolId = localpool::INVALID_LPID - 1,
+			lp_id_t thermalRequestPoolId = localpool::INVALID_LPID - 2);
 	/**
 	 * @brief   Helper function to ease device handler development.
 	 * This will instruct the transition to MODE_ON immediately
@@ -220,7 +230,7 @@ protected:
 	 *  - If the device does not change the mode, the mode will be changed to
 	 *    _MODE_POWER_DOWN, when the timeout (from getTransitionDelay())
 	 *    has passed.
-	 *
+	 * 0xffffffff
 	 * #transitionFailure can be set to a failure code indicating the reason
 	 * for a failed transition
 	 */
@@ -699,14 +709,14 @@ protected:
 	 *
 	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
 	 */
-	gp_id_t deviceThermalStatePoolId;
+	lp_id_t deviceThermalStatePoolId = localpool::INVALID_LPID;
 
 	/**
 	 * this is the datapool variable with the thermal request of the device
 	 *
 	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
 	 */
-	gp_id_t deviceThermalRequestPoolId;
+	lp_id_t deviceHeaterRequestPoolId = localpool::INVALID_LPID;
 
 	/**
 	 * Optional Error code. Can be set in doStartUp(), doShutDown() and
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index f09ddbb82..f1ea88011 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -26,6 +26,9 @@ public:
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
 
+	using dh_heater_request_t = uint8_t;
+	using dh_thermal_state_t = int8_t;
+
 	/**
 	 * @brief This is the mode the <strong>device handler</strong> is in.
 	 *

From 74b2830d9b2c612bff9467f063617028cbf309a8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 18:55:53 +0100
Subject: [PATCH 1068/1774] using new device handler thermal set

---
 devicehandlers/DeviceHandlerBase.cpp     | 56 ++++++++++++------------
 devicehandlers/DeviceHandlerBase.h       | 11 +++--
 devicehandlers/DeviceHandlerIF.h         |  9 ++++
 devicehandlers/DeviceHandlerThermalSet.h | 44 +++++++++++++++++++
 4 files changed, 90 insertions(+), 30 deletions(-)
 create mode 100644 devicehandlers/DeviceHandlerThermalSet.h

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 60929fcd3..609ba315f 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -58,9 +58,12 @@ void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
 }
 
 void DeviceHandlerBase::setThermalStateRequestPoolIds(
-		lp_id_t thermalStatePoolId, lp_id_t thermalRequestPoolId) {
+		lp_id_t thermalStatePoolId, lp_id_t heaterRequestPoolId,
+		uint32_t thermalSetId) {
 	this->deviceHeaterRequestPoolId = thermalStatePoolId;
-	this->deviceHeaterRequestPoolId = thermalRequestPoolId;
+	this->deviceHeaterRequestPoolId = heaterRequestPoolId;
+	thermalSet = new DeviceHandlerThermalSet(this, thermalSetId,
+			thermalStatePoolId, heaterRequestPoolId);
 }
 
 
@@ -212,15 +215,14 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	fillCommandAndReplyMap();
 
-	if(deviceHeaterRequestPoolId != localpool::INVALID_LPID) {
+	if(thermalSet != nullptr) {
 		//Set temperature target state to NON_OP.
-		LocalPoolVar<DeviceHandlerIF::dh_heater_request_t>
-		heaterRequest(this, deviceHeaterRequestPoolId, nullptr,
-				pool_rwm_t::VAR_WRITE);
-		result = heaterRequest.read();
+		ReturnValue_t result = thermalSet->read();
 		if(result == HasReturnvaluesIF::RETURN_OK) {
-			heaterRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-			heaterRequest.commit(PoolVariableIF::VALID);
+			thermalSet->heaterRequest.setReadWriteMode(pool_rwm_t::VAR_WRITE);
+			thermalSet->heaterRequest.value =
+					ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+			thermalSet->commit(PoolVariableIF::VALID);
 		}
 
 	}
@@ -513,18 +515,17 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	}
 	Clock::getUptime(&timeoutStart);
 
-	if (mode == MODE_OFF) {
-		LocalPoolVar<DeviceHandlerIF::dh_heater_request_t>
-		heaterRequest(this, deviceHeaterRequestPoolId,
-				nullptr, PoolVariableIF::VAR_READ_WRITE);
-		ReturnValue_t result = heaterRequest.read();
+	if (mode == MODE_OFF and thermalSet != nullptr) {
+		ReturnValue_t result = thermalSet->read();
 		if(result == HasReturnvaluesIF::RETURN_OK) {
-			if (heaterRequest.value !=
+			thermalSet->heaterRequest.setReadWriteMode(
+					pool_rwm_t::VAR_READ_WRITE);
+			if (thermalSet->heaterRequest.value !=
 					ThermalComponentIF::STATE_REQUEST_IGNORE) {
-				heaterRequest.value = ThermalComponentIF::
+				thermalSet->heaterRequest.value = ThermalComponentIF::
 						STATE_REQUEST_NON_OPERATIONAL;
 			}
-			heaterRequest.commit(PoolVariableIF::VALID);
+			thermalSet->heaterRequest.commit(PoolVariableIF::VALID);
 		}
 
 	}
@@ -989,17 +990,18 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
 	}
 
 	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
-			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)) {
-		GlobDataSet mySet;
-		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
-				PoolVariableIF::VAR_READ);
-		gp_uint8_t thermalRequest(deviceHeaterRequestPoolId, &mySet,
-				PoolVariableIF::VAR_READ);
-		mySet.read();
-		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-			if (!ThermalComponentIF::isOperational(thermalState)) {
+			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)
+			and thermalSet != nullptr) {
+		ReturnValue_t result = thermalSet->read();
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			thermalSet->thermalState.setReadWriteMode(pool_rwm_t::VAR_READ);
+			thermalSet->heaterRequest.setReadWriteMode(pool_rwm_t::VAR_READ);
+			if((thermalSet->heaterRequest.value !=
+					ThermalComponentIF::STATE_REQUEST_IGNORE) and (not
+					ThermalComponentIF::isOperational(
+							thermalSet->thermalState.value))) {
 				triggerEvent(ThermalComponentIF::TEMP_NOT_IN_OP_RANGE,
-						thermalState);
+						thermalSet->thermalState.value);
 				return NON_OP_TEMPERATURE;
 			}
 		}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index b41e7407c..eb15f22a3 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -4,6 +4,7 @@
 #include "DeviceHandlerIF.h"
 #include "DeviceCommunicationIF.h"
 #include "DeviceHandlerFailureIsolation.h"
+#include "DeviceHandlerThermalSet.h"
 
 #include "../objectmanager/SystemObject.h"
 #include "../tasks/ExecutableObjectIF.h"
@@ -112,9 +113,11 @@ public:
 	 * @param thermalStatePoolId
 	 * @param thermalRequestPoolId
 	 */
-	void setThermalStateRequestPoolIds(
-			lp_id_t thermalStatePoolId = localpool::INVALID_LPID - 1,
-			lp_id_t thermalRequestPoolId = localpool::INVALID_LPID - 2);
+	void setThermalStateRequestPoolIds(lp_id_t thermalStatePoolId =
+			DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
+			lp_id_t thermalRequestPoolId =
+			DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID,
+			uint32_t thermalSetId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID);
 	/**
 	 * @brief   Helper function to ease device handler development.
 	 * This will instruct the transition to MODE_ON immediately
@@ -718,6 +721,8 @@ protected:
 	 */
 	lp_id_t deviceHeaterRequestPoolId = localpool::INVALID_LPID;
 
+	DeviceHandlerThermalSet* thermalSet = nullptr;
+
 	/**
 	 * Optional Error code. Can be set in doStartUp(), doShutDown() and
 	 * doTransition() to signal cause for Transition failure.
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index f1ea88011..a86a2b3a5 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -4,6 +4,7 @@
 #include "DeviceHandlerMessage.h"
 
 #include "../action/HasActionsIF.h"
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
@@ -151,6 +152,14 @@ public:
 		NOTHING    //!< Do nothing.
 	};
 
+	static constexpr uint32_t DEFAULT_THERMAL_SET_ID = sid_t::INVALID_SID - 1;
+
+	static constexpr lp_id_t DEFAULT_THERMAL_STATE_POOL_ID =
+	        localpool::INVALID_LPID - 2;
+	static constexpr lp_id_t DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID =
+			localpool::INVALID_LPID - 1;
+
+
 	/**
 	 * Default Destructor
 	 */
diff --git a/devicehandlers/DeviceHandlerThermalSet.h b/devicehandlers/DeviceHandlerThermalSet.h
new file mode 100644
index 000000000..8e9f9c510
--- /dev/null
+++ b/devicehandlers/DeviceHandlerThermalSet.h
@@ -0,0 +1,44 @@
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_
+
+#include "DeviceHandlerIF.h"
+#include "../datapoollocal/StaticLocalDataSet.h"
+#include "../datapoollocal/LocalPoolVariable.h"
+
+
+class DeviceHandlerThermalSet: public StaticLocalDataSet<2> {
+public:
+
+	DeviceHandlerThermalSet(HasLocalDataPoolIF* hkOwner, uint32_t setId =
+			DeviceHandlerIF::DEFAULT_THERMAL_SET_ID,
+			lp_id_t thermalStateId =
+					DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
+			lp_id_t heaterRequestId =
+					DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID):
+			DeviceHandlerThermalSet(hkOwner->getObjectId(), setId,
+					thermalStateId, heaterRequestId) {}
+
+	DeviceHandlerThermalSet(object_id_t deviceHandler, uint32_t setId =
+					DeviceHandlerIF::DEFAULT_THERMAL_SET_ID,
+			lp_id_t thermalStateId =
+					DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
+			lp_id_t thermalStateRequestId =
+					DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID):
+			StaticLocalDataSet(sid_t(deviceHandler, setId)),
+			thermalStatePoolId(thermalStateId),
+			thermalStateRequestPoolId(thermalStateRequestId) {}
+
+	const lp_id_t thermalStatePoolId;
+	const lp_id_t thermalStateRequestPoolId;
+
+	lp_var_t<DeviceHandlerIF::dh_thermal_state_t> thermalState =
+			lp_var_t<DeviceHandlerIF::dh_thermal_state_t>(
+			thermalStatePoolId, sid.objectId, this);
+	lp_var_t<DeviceHandlerIF::dh_heater_request_t> heaterRequest =
+			lp_var_t<DeviceHandlerIF::dh_heater_request_t>(
+			thermalStateRequestPoolId, sid.objectId, this);
+};
+
+
+
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_ */

From e3de5ce7774b8571865ff6755056527912f0e7c2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 19:12:40 +0100
Subject: [PATCH 1069/1774] device handler changes complete

---
 devicehandlers/DeviceHandlerBase.cpp     | 71 ++++++++++++------------
 devicehandlers/DeviceHandlerBase.h       | 24 +++-----
 devicehandlers/DeviceHandlerIF.h         |  2 +-
 devicehandlers/DeviceHandlerThermalSet.h |  6 +-
 4 files changed, 46 insertions(+), 57 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 609ba315f..d14a8e36a 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -60,8 +60,6 @@ void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
 void DeviceHandlerBase::setThermalStateRequestPoolIds(
 		lp_id_t thermalStatePoolId, lp_id_t heaterRequestPoolId,
 		uint32_t thermalSetId) {
-	this->deviceHeaterRequestPoolId = thermalStatePoolId;
-	this->deviceHeaterRequestPoolId = heaterRequestPoolId;
 	thermalSet = new DeviceHandlerThermalSet(this, thermalSetId,
 			thermalStatePoolId, heaterRequestPoolId);
 }
@@ -217,9 +215,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	if(thermalSet != nullptr) {
 		//Set temperature target state to NON_OP.
-		ReturnValue_t result = thermalSet->read();
+		result = thermalSet->read();
 		if(result == HasReturnvaluesIF::RETURN_OK) {
-			thermalSet->heaterRequest.setReadWriteMode(pool_rwm_t::VAR_WRITE);
 			thermalSet->heaterRequest.value =
 					ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
 			thermalSet->commit(PoolVariableIF::VALID);
@@ -518,8 +515,6 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	if (mode == MODE_OFF and thermalSet != nullptr) {
 		ReturnValue_t result = thermalSet->read();
 		if(result == HasReturnvaluesIF::RETURN_OK) {
-			thermalSet->heaterRequest.setReadWriteMode(
-					pool_rwm_t::VAR_READ_WRITE);
 			if (thermalSet->heaterRequest.value !=
 					ThermalComponentIF::STATE_REQUEST_IGNORE) {
 				thermalSet->heaterRequest.value = ThermalComponentIF::
@@ -990,12 +985,9 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
 	}
 
 	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
-			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)
-			and thermalSet != nullptr) {
+			and (thermalSet != nullptr)) {
 		ReturnValue_t result = thermalSet->read();
 		if(result == HasReturnvaluesIF::RETURN_OK) {
-			thermalSet->thermalState.setReadWriteMode(pool_rwm_t::VAR_READ);
-			thermalSet->heaterRequest.setReadWriteMode(pool_rwm_t::VAR_READ);
 			if((thermalSet->heaterRequest.value !=
 					ThermalComponentIF::STATE_REQUEST_IGNORE) and (not
 					ThermalComponentIF::isOperational(
@@ -1014,32 +1006,15 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 		Submode_t commandedSubmode) {
 	switch (commandedMode) {
 	case MODE_ON:
-		if (mode == MODE_OFF) {
-			transitionSourceMode = _MODE_POWER_DOWN;
-			transitionSourceSubMode = SUBMODE_NONE;
-			setMode(_MODE_POWER_ON, commandedSubmode);
-			//already set the delay for the child transition so we don't need to call it twice
-			childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
-					MODE_ON);
-			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-			GlobDataSet mySet;
-			gp_int8_t thermalRequest(deviceHeaterRequestPoolId,
-					&mySet, PoolVariableIF::VAR_READ_WRITE);
-			mySet.read();
-			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-				thermalRequest = ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
-				mySet.commit(PoolVariableIF::VALID);
-			}
-		} else {
-			setTransition(MODE_ON, commandedSubmode);
-		}
+		handleTransitionToOnMode(commandedMode, commandedSubmode);
 		break;
 	case MODE_OFF:
 		if (mode == MODE_OFF) {
 			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
 			setMode(_MODE_POWER_DOWN, commandedSubmode);
 		} else {
-			//already set the delay for the child transition so we don't need to call it twice
+			// already set the delay for the child transition
+			// so we don't need to call it twice
 			childTransitionDelay = getTransitionDelayMs(mode, _MODE_POWER_DOWN);
 			transitionSourceMode = _MODE_POWER_DOWN;
 			transitionSourceSubMode = commandedSubmode;
@@ -1065,6 +1040,33 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 	}
 }
 
+void DeviceHandlerBase::handleTransitionToOnMode(Mode_t commandedMode,
+		Submode_t commandedSubmode) {
+	if (mode == MODE_OFF) {
+		transitionSourceMode = _MODE_POWER_DOWN;
+		transitionSourceSubMode = SUBMODE_NONE;
+		setMode(_MODE_POWER_ON, commandedSubmode);
+		// already set the delay for the child transition so we don't
+		// need to call it twice
+		childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
+				MODE_ON);
+		triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
+		if(thermalSet != nullptr) {
+			ReturnValue_t result = thermalSet->read();
+			if(result == HasReturnvaluesIF::RETURN_OK) {
+				if(thermalSet->heaterRequest !=
+						ThermalComponentIF::STATE_REQUEST_IGNORE) {
+					thermalSet->heaterRequest =
+							ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
+					thermalSet->commit();
+				}
+			}
+		}
+	} else {
+		setTransition(MODE_ON, commandedSubmode);
+	}
+}
+
 void DeviceHandlerBase::getMode(Mode_t* mode, Submode_t* submode) {
 	*mode = this->mode;
 	*submode = this->submode;
@@ -1401,13 +1403,10 @@ void DeviceHandlerBase::performOperationHook() {
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
 		LocalDataPool &localDataPoolMap,
         LocalDataPoolManager& poolManager) {
-	if(deviceThermalStatePoolId != localpool::INVALID_LPID) {
-		localDataPoolMap.emplace(deviceThermalStatePoolId,
+	if(thermalSet != nullptr) {
+		localDataPoolMap.emplace(thermalSet->thermalStatePoolId,
 				new PoolEntry<DeviceHandlerIF::dh_thermal_state_t>);
-	}
-
-	if(deviceHeaterRequestPoolId != localpool::INVALID_LPID) {
-		localDataPoolMap.emplace(deviceHeaterRequestPoolId,
+		localDataPoolMap.emplace(thermalSet->heaterRequestPoolId,
 				new PoolEntry<DeviceHandlerIF::dh_heater_request_t>);
 	}
 	return RETURN_OK;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index eb15f22a3..4deef763d 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -107,9 +107,10 @@ public:
 
 	/**
 	 * If the device handler is controlled by the FSFW thermal building blocks,
-	 * this function should be called. The device handler will then take care
-	 * of creating local pool entries for the device thermal state and device
-	 * heating request. Custom local pool IDs can be assigned as well.
+	 * this function should be called to initialize all required components.
+	 * The device handler will then take care of creating local pool entries
+	 * for the device thermal state and device heating request.
+	 * Custom local pool IDs can be assigned as well.
 	 * @param thermalStatePoolId
 	 * @param thermalRequestPoolId
 	 */
@@ -707,20 +708,6 @@ protected:
 	//! and to send replies.
 	MessageQueueIF* commandQueue = nullptr;
 
-	/**
-	 * this is the datapool variable with the thermal state of the device
-	 *
-	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
-	 */
-	lp_id_t deviceThermalStatePoolId = localpool::INVALID_LPID;
-
-	/**
-	 * this is the datapool variable with the thermal request of the device
-	 *
-	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
-	 */
-	lp_id_t deviceHeaterRequestPoolId = localpool::INVALID_LPID;
-
 	DeviceHandlerThermalSet* thermalSet = nullptr;
 
 	/**
@@ -1223,6 +1210,9 @@ private:
 
     void parseReply(const uint8_t* receivedData,
                 size_t receivedDataLen);
+
+    void handleTransitionToOnMode(Mode_t commandedMode,
+    		Submode_t commandedSubmode);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index a86a2b3a5..4cda99d4e 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -152,7 +152,7 @@ public:
 		NOTHING    //!< Do nothing.
 	};
 
-	static constexpr uint32_t DEFAULT_THERMAL_SET_ID = sid_t::INVALID_SID - 1;
+	static constexpr uint32_t DEFAULT_THERMAL_SET_ID = sid_t::INVALID_SET_ID - 1;
 
 	static constexpr lp_id_t DEFAULT_THERMAL_STATE_POOL_ID =
 	        localpool::INVALID_LPID - 2;
diff --git a/devicehandlers/DeviceHandlerThermalSet.h b/devicehandlers/DeviceHandlerThermalSet.h
index 8e9f9c510..239012e26 100644
--- a/devicehandlers/DeviceHandlerThermalSet.h
+++ b/devicehandlers/DeviceHandlerThermalSet.h
@@ -26,17 +26,17 @@ public:
 					DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID):
 			StaticLocalDataSet(sid_t(deviceHandler, setId)),
 			thermalStatePoolId(thermalStateId),
-			thermalStateRequestPoolId(thermalStateRequestId) {}
+			heaterRequestPoolId(thermalStateRequestId) {}
 
 	const lp_id_t thermalStatePoolId;
-	const lp_id_t thermalStateRequestPoolId;
+	const lp_id_t heaterRequestPoolId;
 
 	lp_var_t<DeviceHandlerIF::dh_thermal_state_t> thermalState =
 			lp_var_t<DeviceHandlerIF::dh_thermal_state_t>(
 			thermalStatePoolId, sid.objectId, this);
 	lp_var_t<DeviceHandlerIF::dh_heater_request_t> heaterRequest =
 			lp_var_t<DeviceHandlerIF::dh_heater_request_t>(
-			thermalStateRequestPoolId, sid.objectId, this);
+			heaterRequestPoolId, sid.objectId, this);
 };
 
 

From 4d76bf24b581aaeba5c2e276f4d09c90c806215e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 19:16:19 +0100
Subject: [PATCH 1070/1774] fsfw compiles without datapoolglob folder

---
 .../datapoolglob}/ControllerSet.cpp                  |  0
 .../datapoolglob}/ControllerSet.h                    |  0
 .../datapoolglob}/DataPoolAdmin.cpp                  |  0
 .../datapoolglob}/DataPoolAdmin.h                    |  0
 .../datapoolglob}/DataPoolParameterWrapper.cpp       |  0
 .../datapoolglob}/DataPoolParameterWrapper.h         |  0
 .../datapoolglob}/GlobalDataPool.cpp                 |  0
 .../datapoolglob}/GlobalDataPool.h                   |  0
 .../datapoolglob}/GlobalDataSet.cpp                  |  0
 .../datapoolglob}/GlobalDataSet.h                    |  0
 .../datapoolglob}/GlobalPoolVariable.h               |  0
 .../datapoolglob}/GlobalPoolVariable.tpp             |  0
 .../datapoolglob}/GlobalPoolVector.h                 |  0
 .../datapoolglob}/GlobalPoolVector.tpp               |  0
 {datapoolglob => archive/datapoolglob}/PIDReader.h   |  0
 .../datapoolglob}/PIDReaderList.h                    |  0
 .../datapoolglob}/PoolRawAccess.cpp                  |  0
 .../datapoolglob}/PoolRawAccess.h                    |  0
 devicehandlers/DeviceHandlerBase.cpp                 | 12 ++++++------
 internalError/InternalErrorReporter.cpp              |  2 --
 20 files changed, 6 insertions(+), 8 deletions(-)
 rename {datapoolglob => archive/datapoolglob}/ControllerSet.cpp (100%)
 rename {datapoolglob => archive/datapoolglob}/ControllerSet.h (100%)
 rename {datapoolglob => archive/datapoolglob}/DataPoolAdmin.cpp (100%)
 rename {datapoolglob => archive/datapoolglob}/DataPoolAdmin.h (100%)
 rename {datapoolglob => archive/datapoolglob}/DataPoolParameterWrapper.cpp (100%)
 rename {datapoolglob => archive/datapoolglob}/DataPoolParameterWrapper.h (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalDataPool.cpp (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalDataPool.h (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalDataSet.cpp (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalDataSet.h (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalPoolVariable.h (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalPoolVariable.tpp (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalPoolVector.h (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalPoolVector.tpp (100%)
 rename {datapoolglob => archive/datapoolglob}/PIDReader.h (100%)
 rename {datapoolglob => archive/datapoolglob}/PIDReaderList.h (100%)
 rename {datapoolglob => archive/datapoolglob}/PoolRawAccess.cpp (100%)
 rename {datapoolglob => archive/datapoolglob}/PoolRawAccess.h (100%)

diff --git a/datapoolglob/ControllerSet.cpp b/archive/datapoolglob/ControllerSet.cpp
similarity index 100%
rename from datapoolglob/ControllerSet.cpp
rename to archive/datapoolglob/ControllerSet.cpp
diff --git a/datapoolglob/ControllerSet.h b/archive/datapoolglob/ControllerSet.h
similarity index 100%
rename from datapoolglob/ControllerSet.h
rename to archive/datapoolglob/ControllerSet.h
diff --git a/datapoolglob/DataPoolAdmin.cpp b/archive/datapoolglob/DataPoolAdmin.cpp
similarity index 100%
rename from datapoolglob/DataPoolAdmin.cpp
rename to archive/datapoolglob/DataPoolAdmin.cpp
diff --git a/datapoolglob/DataPoolAdmin.h b/archive/datapoolglob/DataPoolAdmin.h
similarity index 100%
rename from datapoolglob/DataPoolAdmin.h
rename to archive/datapoolglob/DataPoolAdmin.h
diff --git a/datapoolglob/DataPoolParameterWrapper.cpp b/archive/datapoolglob/DataPoolParameterWrapper.cpp
similarity index 100%
rename from datapoolglob/DataPoolParameterWrapper.cpp
rename to archive/datapoolglob/DataPoolParameterWrapper.cpp
diff --git a/datapoolglob/DataPoolParameterWrapper.h b/archive/datapoolglob/DataPoolParameterWrapper.h
similarity index 100%
rename from datapoolglob/DataPoolParameterWrapper.h
rename to archive/datapoolglob/DataPoolParameterWrapper.h
diff --git a/datapoolglob/GlobalDataPool.cpp b/archive/datapoolglob/GlobalDataPool.cpp
similarity index 100%
rename from datapoolglob/GlobalDataPool.cpp
rename to archive/datapoolglob/GlobalDataPool.cpp
diff --git a/datapoolglob/GlobalDataPool.h b/archive/datapoolglob/GlobalDataPool.h
similarity index 100%
rename from datapoolglob/GlobalDataPool.h
rename to archive/datapoolglob/GlobalDataPool.h
diff --git a/datapoolglob/GlobalDataSet.cpp b/archive/datapoolglob/GlobalDataSet.cpp
similarity index 100%
rename from datapoolglob/GlobalDataSet.cpp
rename to archive/datapoolglob/GlobalDataSet.cpp
diff --git a/datapoolglob/GlobalDataSet.h b/archive/datapoolglob/GlobalDataSet.h
similarity index 100%
rename from datapoolglob/GlobalDataSet.h
rename to archive/datapoolglob/GlobalDataSet.h
diff --git a/datapoolglob/GlobalPoolVariable.h b/archive/datapoolglob/GlobalPoolVariable.h
similarity index 100%
rename from datapoolglob/GlobalPoolVariable.h
rename to archive/datapoolglob/GlobalPoolVariable.h
diff --git a/datapoolglob/GlobalPoolVariable.tpp b/archive/datapoolglob/GlobalPoolVariable.tpp
similarity index 100%
rename from datapoolglob/GlobalPoolVariable.tpp
rename to archive/datapoolglob/GlobalPoolVariable.tpp
diff --git a/datapoolglob/GlobalPoolVector.h b/archive/datapoolglob/GlobalPoolVector.h
similarity index 100%
rename from datapoolglob/GlobalPoolVector.h
rename to archive/datapoolglob/GlobalPoolVector.h
diff --git a/datapoolglob/GlobalPoolVector.tpp b/archive/datapoolglob/GlobalPoolVector.tpp
similarity index 100%
rename from datapoolglob/GlobalPoolVector.tpp
rename to archive/datapoolglob/GlobalPoolVector.tpp
diff --git a/datapoolglob/PIDReader.h b/archive/datapoolglob/PIDReader.h
similarity index 100%
rename from datapoolglob/PIDReader.h
rename to archive/datapoolglob/PIDReader.h
diff --git a/datapoolglob/PIDReaderList.h b/archive/datapoolglob/PIDReaderList.h
similarity index 100%
rename from datapoolglob/PIDReaderList.h
rename to archive/datapoolglob/PIDReaderList.h
diff --git a/datapoolglob/PoolRawAccess.cpp b/archive/datapoolglob/PoolRawAccess.cpp
similarity index 100%
rename from datapoolglob/PoolRawAccess.cpp
rename to archive/datapoolglob/PoolRawAccess.cpp
diff --git a/datapoolglob/PoolRawAccess.h b/archive/datapoolglob/PoolRawAccess.h
similarity index 100%
rename from datapoolglob/PoolRawAccess.h
rename to archive/datapoolglob/PoolRawAccess.h
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d14a8e36a..4bb7ed561 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -3,8 +3,6 @@
 #include "DeviceTmReportingWrapper.h"
 
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
@@ -1239,10 +1237,12 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 		}
 	}
 	//Try to cast to GlobDataSet and commit data.
-	if (!neverInDataPool) {
-		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
-		if (dataSet != NULL) {
-			dataSet->commit(PoolVariableIF::VALID);
+	if (not neverInDataPool) {
+		LocalPoolDataSetBase* dataSet =
+				dynamic_cast<LocalPoolDataSetBase*>(data);
+		if (dataSet != nullptr) {
+			dataSet->setValidity(true, true);
+			dataSet->commit();
 		}
 	}
 }
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 22e2c38ce..8d5c792b8 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,8 +1,6 @@
 #include "InternalErrorReporter.h"
 
 #include "../ipc/QueueFactory.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../ipc/MutexFactory.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 

From 37196c8e3b5e2795dc75243aa38412464e79de9e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 23:47:11 +0100
Subject: [PATCH 1071/1774] atomic fix

---
 osal/host/FixedTimeslotTask.h | 2 +-
 osal/host/PeriodicTask.h      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index 9985e2ee6..f3fffd0f0 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -74,7 +74,7 @@ protected:
     //!< Typedef for the List of objects.
     typedef std::vector<ExecutableObjectIF*> ObjectList;
     std::thread mainThread;
-    std::atomic<bool> terminateThread = false;
+    std::atomic<bool> terminateThread { false };
 
     //! Polling sequence table which contains the object to execute
     //! and information like the timeslots and the passed execution step.
diff --git a/osal/host/PeriodicTask.h b/osal/host/PeriodicTask.h
index 7689788ac..00cb6a24e 100644
--- a/osal/host/PeriodicTask.h
+++ b/osal/host/PeriodicTask.h
@@ -69,7 +69,7 @@ protected:
 	//!< Typedef for the List of objects.
 	typedef std::vector<ExecutableObjectIF*> ObjectList;
 	std::thread mainThread;
-	std::atomic<bool> terminateThread = false;
+	std::atomic<bool> terminateThread { false };
 
 	/**
 	 * @brief	This attribute holds a list of objects to be executed.

From a92f6c5d8e06c3cee2328671d1e3138211ba49e4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 00:05:54 +0100
Subject: [PATCH 1072/1774] mutex bugfix for host

---
 osal/host/Mutex.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index 8471cab80..fa3aa24c9 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -4,12 +4,12 @@
 Mutex::Mutex() {}
 
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
-	if(timeoutMs == MutexIF::BLOCKING) {
+	if(timeoutType == MutexIF::BLOCKING) {
 		mutex.lock();
 		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	else if(timeoutMs == MutexIF::POLLING) {
+	else if(timeoutType == MutexIF::POLLING) {
 		if(mutex.try_lock()) {
 			locked = true;
 			return HasReturnvaluesIF::RETURN_OK;

From 206d4b58b287a6a4a56df478d010225bfefe583d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 00:17:12 +0100
Subject: [PATCH 1073/1774] removed boolean var

---
 osal/host/Mutex.cpp | 7 -------
 osal/host/Mutex.h   | 2 +-
 2 files changed, 1 insertion(+), 8 deletions(-)

diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index fa3aa24c9..ad8873dfc 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -6,19 +6,16 @@ Mutex::Mutex() {}
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
 	if(timeoutType == MutexIF::BLOCKING) {
 		mutex.lock();
-		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else if(timeoutType == 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;
 		}
 	}
@@ -26,11 +23,7 @@ ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
 }
 
 ReturnValue_t Mutex::unlockMutex() {
-	if(not locked) {
-		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	}
 	mutex.unlock();
-	locked = false;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index 24dafbbda..c0fa19b78 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -22,7 +22,7 @@ public:
 
 	std::timed_mutex* getMutexHandle();
 private:
-	bool locked = false;
+	//bool locked = false;
 	std::timed_mutex mutex;
 };
 

From f5c384de14da3275fbd00487a2bc481de9cd99ea Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 00:27:53 +0100
Subject: [PATCH 1074/1774] some bugfixes

---
 osal/windows/TmTcWinUdpBridge.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 7e283c2a7..1f66290fb 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -6,6 +6,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
         uint16_t serverPort, uint16_t clientPort):
         TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
     mutex = MutexFactory::instance()->createMutex();
+    communicationLinkUp = false;
 
     // Initiates Winsock DLL.
     WSAData wsaData;
@@ -90,7 +91,6 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 //  sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
 //          " sent." << std::endl;
     return HasReturnvaluesIF::RETURN_OK;
-    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
@@ -101,6 +101,7 @@ void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
 //          &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;
+    registerCommConnect();
 
     // Set new IP address if it has changed.
     if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
@@ -114,7 +115,7 @@ void TmTcWinUdpBridge::handleSocketError() {
     switch(errCode) {
     case(WSANOTINITIALISED): {
         sif::info << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: "
-                << "WSAStartup(...) call " << "necessary" << std::endl;
+                << "WSAStartup(...) call necessary" << std::endl;
         break;
     }
     default: {
@@ -154,11 +155,11 @@ void TmTcWinUdpBridge::handleSendError() {
     switch(errCode) {
     case(WSANOTINITIALISED): {
         sif::info << "TmTcWinUdpBridge::handleSendError: WSANOTINITIALISED: "
-                << "WSAStartup(...) call " << "necessary" << std::endl;
+                << "WSAStartup(...) call necessary" << std::endl;
         break;
     }
     case(WSAEADDRNOTAVAIL): {
-        sif::info << "TmTcWinUdpBridge::handleReadError: WSAEADDRNOTAVAIL: "
+        sif::info << "TmTcWinUdpBridge::handleSendError: WSAEADDRNOTAVAIL: "
                 << "Check target address. " << std::endl;
         break;
     }

From 73d3defe9f1edc043911e17884ca09d8dcdda48a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 00:32:07 +0100
Subject: [PATCH 1075/1774] error output improved

---
 osal/host/QueueMapManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 1b2094e91..621f46bce 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -44,7 +44,7 @@ MessageQueueIF* QueueMapManager::getMessageQueue(
 		return queueIter->second;
 	}
 	else {
-		sif::warning << "QueueMapManager::getQueueHandle: The ID" <<
+		sif::warning << "QueueMapManager::getQueueHandle: The ID " <<
 				messageQueueId << " does not exists in the map" << std::endl;
 		return nullptr;
 	}

From 8ad30d489a35cdd6ee27c2e14cfd907d85b62ee0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 00:58:13 +0100
Subject: [PATCH 1076/1774] important bugfix for host osal

---
 osal/host/PeriodicTask.cpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index f4ee079b1..fb2369637 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -89,6 +89,10 @@ ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
 }
 
 void PeriodicTask::taskFunctionality() {
+    for (const auto& object: objectList) {
+        object->initializeAfterTaskCreation();
+    }
+
 	std::chrono::milliseconds periodChrono(static_cast<uint32_t>(period*1000));
 	auto currentStartTime {
 	    std::chrono::duration_cast<std::chrono::milliseconds>(
@@ -101,9 +105,8 @@ void PeriodicTask::taskFunctionality() {
 		if(terminateThread.load()) {
 			break;
 		}
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
+		for (const auto& object: objectList) {
+			object->performOperation();
 		}
 		if(not delayForInterval(&currentStartTime, periodChrono)) {
 			sif::warning << "PeriodicTask: " << taskName <<

From 7b742a2e6775d8f2b5e8b0121d39a84d293cdd94 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 01:00:07 +0100
Subject: [PATCH 1077/1774] warning removed from osal

---
 osal/host/PeriodicTask.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index fb2369637..5662c7cca 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -98,7 +98,7 @@ void PeriodicTask::taskFunctionality() {
 	    std::chrono::duration_cast<std::chrono::milliseconds>(
 	    std::chrono::system_clock::now().time_since_epoch())
 	};
-	auto nextStartTime{ currentStartTime };
+	auto nextStartTime { currentStartTime };
 
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
@@ -109,8 +109,6 @@ void PeriodicTask::taskFunctionality() {
 			object->performOperation();
 		}
 		if(not delayForInterval(&currentStartTime, periodChrono)) {
-			sif::warning << "PeriodicTask: " << taskName <<
-					" missed deadline!\n" << std::flush;
 			if(deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}

From 558220643e05a6eaaad0fce5107c3a1c12eea9ae Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 01:01:31 +0100
Subject: [PATCH 1078/1774] small form improvements

---
 osal/host/FixedTimeslotTask.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index e78c974a4..7000024ee 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -115,8 +115,9 @@ void FixedTimeslotTask::taskFunctionality() {
         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());
+            // this gives us the time to wait:
+            interval = chron_ms(
+                    this->pollingSeqTable.getIntervalToPreviousSlotMs());
             delayForInterval(&currentStartTime, interval);
             //TODO deadline missed check
         }

From 2deb7037b0e58156a8fc04095b57c9eee0003395 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 01:07:40 +0100
Subject: [PATCH 1079/1774] todo added

---
 osal/host/FixedTimeslotTask.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 7000024ee..9e892bb58 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -46,7 +46,7 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
                 << GetLastError() << std::endl;
     }
 #elif defined(LINUX)
-    // we can just copy and paste the code from linux here.
+    // TODO: we can just copy and paste the code from the linux OSAL here.
 #endif
 }
 

From 5e77058add5f51504b4bfab4afe18debf8d8a9df Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 23:15:30 +0100
Subject: [PATCH 1080/1774] added getter function for pending command

---
 devicehandlers/DeviceHandlerBase.cpp |  2 ++
 devicehandlers/DeviceHandlerBase.h   | 13 +++++++++++--
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ccd5bebb3..1b8c5f3d4 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1432,3 +1432,5 @@ dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
     return pstIntervalMs;
 }
 
+DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 627a64238..bd53e6331 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -737,10 +737,19 @@ protected:
 	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.
+
+	/**
+	 * Helper function to get pending command. This is useful for devices
+	 * like SPI sensors to identify the last sent command.
+	 * @return
+	 */
+	DeviceCommandId_t getPendingCommand() const;
+
 	/**
 	 * Helper function to report a missed reply
 	 *
-	 * Can be overwritten by children to act on missed replies or to fake reporting Id.
+	 * Can be overwritten by children to act on missed replies or to fake
+	 * reporting Id.
 	 *
 	 * @param id of the missed reply
 	 */
@@ -1184,7 +1193,7 @@ private:
 	 * @param[out] len
 	 * @return
 	 *   - @c RETURN_OK @c data is valid
-	 *   - @c RETURN_FAILED IPCStore is NULL
+	 *   - @c RETURN_FAILED IPCStore is nullptr
 	 *   - the return value from the IPCStore if it was not @c RETURN_OK
 	 */
 	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,

From f4ed0ce502b696cc6acf9eac3d20f0d9db6975d3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 23:18:48 +0100
Subject: [PATCH 1081/1774] doc format improvements

---
 devicehandlers/DeviceHandlerBase.h | 58 ++++++++++++++++++------------
 1 file changed, 35 insertions(+), 23 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index bd53e6331..b282ad4b9 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -893,7 +893,8 @@ protected:
 	 * @param data data to send
 	 * @param len length of @c data
 	 * @param sendTo the messageQueueId of the one to send to
-	 * @param isCommand marks the raw data as a command, the message then will be of type raw_command
+	 * @param isCommand marks the raw data as a command, the message then
+	 * will be of type raw_command
 	 */
 	virtual void replyRawData(const uint8_t *data, size_t len,
 			MessageQueueId_t sendTo, bool isCommand = false);
@@ -945,10 +946,11 @@ protected:
 	ReturnValue_t getStateOfSwitches(void);
 
 	/**
-	 * set all datapool variables that are update periodically in normal mode invalid
-	 *
-	 * Child classes should provide an implementation which sets all those variables invalid
-	 * which are set periodically during any normal mode.
+	 * @brief   Set all datapool variables that are update periodically in
+	 *          normal mode invalid
+	 * @details TODO: Use local pools
+	 * Child classes should provide an implementation which sets all those
+	 * variables invalid which are set periodically during any normal mode.
 	 */
 	virtual void setNormalDatapoolEntriesInvalid() = 0;
 
@@ -958,11 +960,12 @@ protected:
 	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 
 	/**
-	 * Children can overwrite this function to suppress checking of the command Queue
+	 * Children can overwrite this function to suppress checking of the
+	 * command Queue
 	 *
-	 * This can be used when the child does not want to receive a command in a certain
-	 * situation. Care must be taken that checking is not permanentely disabled as this
-	 * would render the handler unusable.
+	 * This can be used when the child does not want to receive a command in
+	 * a certain situation. Care must be taken that checking is not
+	 * permanentely disabled as this would render the handler unusable.
 	 *
 	 * @return whether checking the queue should NOT be done
 	 */
@@ -1001,17 +1004,20 @@ protected:
 	virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
 			uint32_t parameter2 = 0) const;
 	/**
-	 * Checks state of switches in conjunction with mode and triggers an event if they don't fit.
+	 * Checks state of switches in conjunction with mode and triggers an event
+	 * if they don't fit.
 	 */
 	virtual void checkSwitchState();
 
 	/**
-	 * Reserved for the rare case where a device needs to perform additional operation cyclically in OFF mode.
+	 * Reserved for the rare case where a device needs to perform additional
+	 * operation cyclically in OFF mode.
 	 */
 	virtual void doOffActivity();
 
 	/**
-	 * Reserved for the rare case where a device needs to perform additional operation cyclically in ON mode.
+	 * Reserved for the rare case where a device needs to perform additional
+	 * operation cyclically in ON mode.
 	 */
 	virtual void doOnActivity();
 
@@ -1052,9 +1058,10 @@ private:
 	/**
 	 * Information about a cookie.
 	 *
-	 * This is stored in a map for each cookie, to not only track the state, but also information
-	 * about  the sent command. Tracking this information is needed as
-	 * the state of a commandId (waiting for reply) is done when a RMAP write reply is received.
+	 * This is stored in a map for each cookie, to not only track the state,
+	 * but also information about the sent command. Tracking this information
+	 * is needed as the state of a commandId (waiting for reply) is done when a
+	 * write reply is received.
 	 */
 	struct CookieInfo {
 		CookieState_t state;
@@ -1111,10 +1118,14 @@ private:
 	/**
 	 * Handle the device handler mode.
 	 *
-	 * - checks whether commands are valid for the current mode, rejects them accordingly
-	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
-	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
-	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
+	 * - checks whether commands are valid for the current mode, rejects
+	 *   them accordingly
+	 * - checks whether commanded mode transitions are required and calls
+	 *   handleCommandedModeTransition()
+	 * - does the necessary action for the current mode or calls
+	 *   doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
+	 * - actions that happen in transitions (e.g. setting a timeout) are
+	 *   handled in setMode()
 	 */
 	void doStateMachine(void);
 
@@ -1124,16 +1135,17 @@ private:
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
-	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
-	 * but not received).
+	 * This is called at the beginning of each cycle. It checks whether a
+	 * reply has timed out (that means a reply was expected but not received).
 	 */
 	void decrementDeviceReplyMap(void);
 
 	/**
 	 * Convenience function to handle a reply.
 	 *
-	 * Called after scanForReply() has found a packet. Checks if the found id is in the #deviceCommandMap, if so,
-	 * calls interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) for further action.
+	 * Called after scanForReply() has found a packet. Checks if the found ID
+	 * is in the #deviceCommandMap, if so,  calls
+	 * #interpretDeviceReply for further action.
 	 *
 	 * It also resets the timeout counter for the command id.
 	 *

From 586e8b034780fcd107cdd8ae06cd0fbffe5947b3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 23:22:28 +0100
Subject: [PATCH 1082/1774] function more robust now

---
 devicehandlers/DeviceHandlerBase.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1b8c5f3d4..2a4d1338d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1433,4 +1433,8 @@ dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
 }
 
 DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
+    if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
+        return cookieInfo.pendingCommand->first;
+    }
+    return DeviceHandlerIF::NO_COMMAND;
 }

From 6d915b7dcf76c76672b07483936b9c9fcbbbb047 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 23:26:40 +0100
Subject: [PATCH 1083/1774] doc formatting

---
 devicehandlers/DeviceHandlerBase.h | 63 ++++++++++++++++++------------
 1 file changed, 38 insertions(+), 25 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 6d9b0be6b..49617cd5a 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -734,11 +734,14 @@ protected:
 	//! before setTaskIF was called.
 	PeriodicTaskIF* executingTask = nullptr;
 
-	static object_id_t powerSwitcherId; //!< Object which switches power on and off.
+	//!< Object which switches power on and off.
+	static object_id_t powerSwitcherId;
 
-	static object_id_t rawDataReceiverId; //!< Object which receives RAW data by default.
+	//!< Object which receives RAW data by default.
+	static object_id_t rawDataReceiverId;
 
-	static object_id_t defaultFdirParentId; //!< Object which may be the root cause of an identified fault.
+	//!< Object which may be the root cause of an identified fault.
+	static object_id_t defaultFdirParentId;
 
 	/**
 	 * Helper function to get pending command. This is useful for devices
@@ -858,15 +861,18 @@ protected:
 	/**
 	 * Build the device command to send for raw mode.
 	 *
-	 * This is only called in @c MODE_RAW. It is for the rare case that in raw mode packets
-	 * are to be sent by the handler itself. It is NOT needed for the raw commanding service.
-	 * Its only current use is in the STR handler which gets its raw packets from a different
-	 * source.
-	 * Also it can be used for transitional commands, to get the device ready for @c MODE_RAW
+	 * This is only called in @c MODE_RAW. It is for the rare case that in
+	 * raw mode packets are to be sent by the handler itself. It is NOT needed
+	 * for the raw commanding service. Its only current use is in the STR
+	 * handler which gets its raw packets from a different source.
+	 * Also it can be used for transitional commands, to get the device ready
+	 * for @c MODE_RAW
 	 *
-	 * As it is almost never used, there is a default implementation returning @c NOTHING_TO_SEND.
+	 * As it is almost never used, there is a default implementation
+	 * returning @c NOTHING_TO_SEND.
 	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet
+	 * to be sent.
 	 *
 	 * @param[out] id the device command id built
 	 * @return
@@ -879,7 +885,9 @@ protected:
 	 * Returns the delay cycle count of a reply.
 	 * A count != 0 indicates that the command is already executed.
 	 * @param deviceCommand	The command to look for
-	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
+	 * @return
+	 * The current delay count. If the command does not exist  (should never
+	 * happen) it returns 0.
 	 */
 	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
 
@@ -889,8 +897,8 @@ protected:
 	 * It gets space in the #IPCStore, copies data there, then sends a raw reply
 	 * containing the store address.
 	 *
-	 * This method is virtual, as the STR has a different channel to send raw replies
-	 * and overwrites it accordingly.
+	 * This method is virtual, as the STR has a different channel to send
+	 * raw replies and overwrites it accordingly.
 	 *
 	 * @param data data to send
 	 * @param len length of @c data
@@ -902,8 +910,9 @@ protected:
 			MessageQueueId_t sendTo, bool isCommand = false);
 
 	/**
-	 * Calls replyRawData() with #defaultRawReceiver, but checks if wiretapping is active and if so,
-	 * does not send the Data as the wiretapping will have sent it already
+	 * Calls replyRawData() with #defaultRawReceiver, but checks if wiretapping
+	 * is active and if so, does not send the data as the wiretapping will have
+	 * sent it already
 	 */
 	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
 
@@ -915,17 +924,19 @@ protected:
 	/**
 	 * Enable the reply checking for a command
 	 *
-	 * Is only called, if the command was sent (ie the getWriteReply was successful).
-	 * Must ensure that all replies are activated and correctly linked to the command that initiated it.
-	 * The default implementation looks for a reply with the same id as the command id in the replyMap or
-	 * uses the alternativeReplyId if flagged so.
-	 * When found, copies maxDelayCycles to delayCycles in the reply information and sets the command to
-	 * expect one reply.
+	 * Is only called, if the command was sent (i.e. the getWriteReply was
+	 * successful). Must ensure that all replies are activated and correctly
+	 * linked to the command that initiated it.
+	 * The default implementation looks for a reply with the same id as the
+	 * command id in the replyMap or uses the alternativeReplyId if flagged so.
+	 * When found, copies maxDelayCycles to delayCycles in the reply information
+	 * and sets the command to expect one reply.
 	 *
 	 * Can be overwritten by the child, if a command activates multiple replies
 	 * or replyId differs from commandId.
 	 * Notes for child implementations:
-	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
+	 * 	- If the command was not found in the reply map,
+	 * 	  NO_REPLY_EXPECTED MUST be returned.
 	 * 	- A failure code may be returned if something went fundamentally wrong.
 	 *
 	 * @param deviceCommand
@@ -941,9 +952,11 @@ protected:
 	 * get the state of the PCDU switches in the datapool
 	 *
 	 * @return
-	 *     - @c PowerSwitchIF::SWITCH_ON if all switches specified by #switches are on
-	 *     - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by #switches are off
-	 *     - @c PowerSwitchIF::RETURN_FAILED if an error occured
+	 *  - @c PowerSwitchIF::SWITCH_ON if all switches specified
+	 *       by #switches are on
+	 *  - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by
+	 *       #switches are off
+	 *  - @c PowerSwitchIF::RETURN_FAILED if an error occured
 	 */
 	ReturnValue_t getStateOfSwitches(void);
 

From 464988ca61570bf6464d2e1e1228744659fff9c0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 13:00:04 +0100
Subject: [PATCH 1084/1774] update

---
 datapoollocal/HasLocalDataPoolIF.h          |  51 +-
 datapoollocal/LocalDataPoolManager.cpp      | 805 ++++++++++++++------
 datapoollocal/LocalDataPoolManager.h        | 163 +++-
 datapoollocal/LocalPoolDataSetBase.cpp      |  97 ++-
 datapoollocal/LocalPoolDataSetBase.h        |  16 +-
 datapoollocal/LocalPoolObjectBase.cpp       |  73 ++
 datapoollocal/LocalPoolObjectBase.h         |  63 ++
 datapoollocal/LocalPoolVariable.h           |  54 +-
 datapoollocal/LocalPoolVariable.tpp         | 150 ++--
 datapoollocal/LocalPoolVector.h             |  68 +-
 datapoollocal/LocalPoolVector.tpp           |  85 +--
 datapoollocal/MarkChangedIF.h               |  17 +
 datapoollocal/locPoolDefinitions.h          |  93 +++
 housekeeping/AcceptsHkPacketsIF.h           |   1 +
 housekeeping/HousekeepingMessage.cpp        |  57 +-
 housekeeping/HousekeepingMessage.h          |  76 +-
 housekeeping/HousekeepingPacketUpdate.h     |  51 +-
 housekeeping/PeriodicHousekeepingHelper.cpp |   3 +-
 18 files changed, 1346 insertions(+), 577 deletions(-)
 create mode 100644 datapoollocal/LocalPoolObjectBase.cpp
 create mode 100644 datapoollocal/LocalPoolObjectBase.h
 create mode 100644 datapoollocal/MarkChangedIF.h
 create mode 100644 datapoollocal/locPoolDefinitions.h

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index f8f4ef4c4..7f1f202e7 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,6 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
+#include "locPoolDefinitions.h"
+
 #include "../datapool/PoolEntryIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
@@ -9,11 +11,8 @@
 
 class LocalDataPoolManager;
 class LocalPoolDataSetBase;
+class LocalPoolObjectBase;
 
-/**
- * @brief	Type definition for local pool entries.
- */
-using lp_id_t = uint32_t;
 using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
 using LocalDataPoolMapIter = LocalDataPool::iterator;
 
@@ -44,7 +43,8 @@ public:
 	virtual~ HasLocalDataPoolIF() {};
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
-	static constexpr lp_id_t NO_POOL_ID = 0xffffffff;
+
+	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
 	virtual object_id_t getObjectId() const = 0;
 
@@ -78,6 +78,47 @@ public:
 	 */
 	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
 
+	/**
+	 * Similar to the function above, but used to get a local pool variable
+	 * handle. This is only needed for update notifications, so it is not
+	 * defined as abstract.
+	 * @param localPoolId
+	 * @return
+	 */
+	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
+	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
+	            << ". Returning nullptr!" << std::endl;
+	    return nullptr;
+	}
+
+    /**
+     * @brief   This function will be called by the manager if an update
+     *          notification is received.
+     * @details
+     * Can be overriden by the child class to handle changed datasets.
+     * @param sid
+     * @param storeId If a snapshot was requested, data will be located inside
+     * the IPC store with this store ID.
+     */
+    virtual void handleChangedDataset(sid_t sid,
+            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
+        return;
+    }
+
+    /**
+     * @brief   This function will be called by the manager if an update
+     *          notification is received.
+     * @details
+     * Can be overriden by the child class to handle changed pool IDs.
+     * @param sid
+     * @param storeId If a snapshot was requested, data will be located inside
+     * the IPC store with this store ID.
+     */
+    virtual void handleChangedPoolVariable(lp_id_t poolId,
+            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
+        return;
+    }
+
 	/* These function can be implemented by pool owner, as they are required
 	 * by the housekeeping message interface */
 	virtual ReturnValue_t addDataSet(sid_t sid) {
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index c23f183b1..f649a3623 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,22 +1,25 @@
 #include "LocalDataPoolManager.h"
+#include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
 
+#include "../housekeeping/HousekeepingPacketUpdate.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
+
+#include "../timemanager/CCSDSTime.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
 #include "../ipc/QueueFactory.h"
-#include "../objectmanager/frameworkObjects.h"
 
 #include <array>
 #include <cmath>
 
 object_id_t LocalDataPoolManager::defaultHkDestination =
-		objects::PUS_SERVICE_3_HOUSEKEEPING;
+        objects::PUS_SERVICE_3_HOUSEKEEPING;
 
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
-        appendValidityBuffer(appendValidityBuffer) {
+                        appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
         sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                 << "Invalid supplied owner!" << std::endl;
@@ -59,7 +62,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
         }
         else {
             sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                   << "Default HK destination object is invalid!" << std::endl;
+                    << "Default HK destination object is invalid!" << std::endl;
             return HasReturnvaluesIF::RETURN_FAILED;
         }
     }
@@ -74,23 +77,22 @@ ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
 }
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
-	if(not mapInitialized) {
-		ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
-		        *this);
-		if(result == HasReturnvaluesIF::RETURN_OK) {
-			mapInitialized = true;
-		}
-		return result;
-	}
-	sif::warning << "HousekeepingManager: The map should only be initialized "
-	        << "once!" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
+    if(not mapInitialized) {
+        ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
+                *this);
+        if(result == HasReturnvaluesIF::RETURN_OK) {
+            mapInitialized = true;
+        }
+        return result;
+    }
+    sif::warning << "HousekeepingManager: The map should only be initialized "
+            << "once!" << std::endl;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
+    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
     for(auto& receiver: hkReceiversMap) {
-        //HkReceiver* receiver = &hkReceiversIter.second;
-
         switch(receiver.reportingType) {
         case(ReportingType::PERIODIC): {
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
@@ -100,8 +102,16 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
             performPeriodicHkGeneration(receiver);
             break;
         }
+        case(ReportingType::UPDATE_HK): {
+            handleHkUpdate(receiver, status);
+            break;
+        }
+        case(ReportingType::UPDATE_NOTIFICATION): {
+            handleNotificationUpdate(receiver, status);
+            break;
+        }
         case(ReportingType::UPDATE_SNAPSHOT): {
-            // check whether data has changed and send messages in case it has.
+            handleNotificationSnapshot(receiver, status);
             break;
         }
         default:
@@ -109,95 +119,441 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
     }
+    resetHkUpdateResetHelper();
+    return status;
+}
+
+ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
+        ReturnValue_t& status) {
+    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+        // Update packets shall only be generated from datasets.
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+            receiver.dataId.sid);
+    if(dataSet->hasChanged()) {
+        // prepare and send update notification
+        ReturnValue_t result = generateHousekeepingPacket(
+                receiver.dataId.sid, dataSet, true);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            status = result;
+        }
+    }
+    handleChangeResetLogic(receiver.dataType, receiver.dataId,
+            dataSet);
     return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
+        HkReceiver& receiver, ReturnValue_t& status) {
+    MarkChangedIF* toReset = nullptr;
+    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+                receiver.dataId.localPoolId);
+        if(poolObj == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        if(poolObj->hasChanged()) {
+            // prepare and send update notification.
+            CommandMessage notification;
+            HousekeepingMessage::setUpdateNotificationVariableCommand(
+                    &notification, receiver.dataId.localPoolId);
+            ReturnValue_t result = hkQueue->sendMessage(
+                    receiver.destinationQueue, &notification);
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                status = result;
+            }
+            toReset = poolObj;
+        }
+
+    }
+    else {
+        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                receiver.dataId.sid);
+        if(dataSet == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        if(dataSet->hasChanged()) {
+            // prepare and send update notification
+            CommandMessage notification;
+            HousekeepingMessage::setUpdateNotificationSetCommand(
+                    &notification, receiver.dataId.sid);
+            ReturnValue_t result = hkQueue->sendMessage(
+                    receiver.destinationQueue, &notification);
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                status = result;
+            }
+            toReset = dataSet;
+        }
+    }
+    if(toReset != nullptr) {
+        handleChangeResetLogic(receiver.dataType,
+                receiver.dataId, toReset);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
+        HkReceiver& receiver, ReturnValue_t& status) {
+    MarkChangedIF* toReset = nullptr;
+    // check whether data has changed and send messages in case it has.
+    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+                receiver.dataId.localPoolId);
+        if(poolObj == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+
+        if (not poolObj->hasChanged()) {
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+
+        // prepare and send update snapshot.
+        timeval now;
+        Clock::getClock_timeval(&now);
+        CCSDSTime::CDS_short cds;
+        CCSDSTime::convertToCcsds(&cds, &now);
+        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+                sizeof(cds), owner->getPoolObjectHandle(
+                receiver.dataId.localPoolId));
+
+        store_address_t storeId;
+        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+
+        CommandMessage notification;
+        HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
+                receiver.dataId.localPoolId, storeId);
+        result = hkQueue->sendMessage(receiver.destinationQueue,
+                &notification);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            status = result;
+        }
+        toReset = poolObj;
+    }
+    else {
+        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                receiver.dataId.sid);
+        if(dataSet == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+
+        if(not dataSet->hasChanged()) {
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+
+        // prepare and send update snapshot.
+        timeval now;
+        Clock::getClock_timeval(&now);
+        CCSDSTime::CDS_short cds;
+        CCSDSTime::convertToCcsds(&cds, &now);
+        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+                sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+
+        store_address_t storeId;
+        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+
+        CommandMessage notification;
+        HousekeepingMessage::setUpdateSnapshotSetCommand(
+                &notification, receiver.dataId.sid, storeId);
+        result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            status = result;
+        }
+        toReset = dataSet;
+
+    }
+    if(toReset != nullptr) {
+        handleChangeResetLogic(receiver.dataType,
+                receiver.dataId, toReset);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::addUpdateToStore(
+        HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
+    size_t updatePacketSize = updatePacket.getSerializedSize();
+    uint8_t *storePtr = nullptr;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            updatePacket.getSerializedSize(), &storePtr);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    size_t serializedSize = 0;
+    result = updatePacket.serialize(&storePtr, &serializedSize,
+            updatePacketSize, SerializeIF::Endianness::MACHINE);
+    return result;;
+}
+
+void LocalDataPoolManager::handleChangeResetLogic(
+        DataType type, DataId dataId, MarkChangedIF* toReset) {
+    if(hkUpdateResetList == nullptr) {
+        // config error!
+        return;
+    }
+
+    for(auto& changeInfo: *hkUpdateResetList) {
+        if(changeInfo.dataType != type) {
+            continue;
+        }
+        if((changeInfo.dataType == DataType::DATA_SET) and
+                (changeInfo.dataId.sid != dataId.sid)) {
+            continue;
+        }
+        if((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
+                (changeInfo.dataId.localPoolId != dataId.localPoolId)) {
+            continue;
+        }
+
+        if(changeInfo.updateCounter <= 1) {
+            toReset->setChanged(false);
+        }
+        if(changeInfo.currentUpdateCounter == 0) {
+            toReset->setChanged(false);
+        }
+        else {
+            changeInfo.currentUpdateCounter--;
+        }
+        return;
+    }
+}
+
+void LocalDataPoolManager::resetHkUpdateResetHelper() {
+    if(hkUpdateResetList == nullptr) {
+        return;
+    }
+
+    for(auto& changeInfo: *hkUpdateResetList) {
+        changeInfo.currentUpdateCounter = changeInfo.updateCounter;
+    }
+}
+
 ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
-		bool enableReporting, float collectionInterval, bool isDiagnostics,
-		object_id_t packetDestination) {
-	AcceptsHkPacketsIF* hkReceiverObject =
-			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-	if(hkReceiverObject == nullptr) {
-		sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-				<< " Invalid receiver!"<< std::endl;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+        bool enableReporting, float collectionInterval, bool isDiagnostics,
+        object_id_t packetDestination) {
+    AcceptsHkPacketsIF* hkReceiverObject =
+            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+    if(hkReceiverObject == nullptr) {
+        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
+                << " Invalid receiver!"<< std::endl;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	struct HkReceiver hkReceiver;
-	hkReceiver.dataId.sid = sid;
-	hkReceiver.reportingType = ReportingType::PERIODIC;
-	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+    struct HkReceiver hkReceiver;
+    hkReceiver.dataId.sid = sid;
+    hkReceiver.reportingType = ReportingType::PERIODIC;
+    hkReceiver.dataType = DataType::DATA_SET;
+    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if(dataSet != nullptr) {
-		dataSet->setReportingEnabled(enableReporting);
-		dataSet->setDiagnostic(isDiagnostics);
-		dataSet->initializePeriodicHelper(collectionInterval,
-				owner->getPeriodicOperationFrequency(), isDiagnostics);
-	}
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(dataSet != nullptr) {
+        dataSet->setReportingEnabled(enableReporting);
+        dataSet->setDiagnostic(isDiagnostics);
+        dataSet->initializePeriodicHelper(collectionInterval,
+                owner->getPeriodicOperationFrequency(), isDiagnostics);
+    }
 
-	hkReceiversMap.push_back(hkReceiver);
-	return HasReturnvaluesIF::RETURN_OK;
+    hkReceiversMap.push_back(hkReceiver);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
+        bool isDiagnostics, bool reportingEnabled,
+        object_id_t packetDestination) {
+    AcceptsHkPacketsIF* hkReceiverObject =
+            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+    if(hkReceiverObject == nullptr) {
+        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
+                << " Invalid receiver!"<< std::endl;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    struct HkReceiver hkReceiver;
+    hkReceiver.dataId.sid = sid;
+    hkReceiver.reportingType = ReportingType::UPDATE_HK;
+    hkReceiver.dataType = DataType::DATA_SET;
+    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(dataSet != nullptr) {
+        dataSet->setReportingEnabled(true);
+        dataSet->setDiagnostic(isDiagnostics);
+    }
+
+    hkReceiversMap.push_back(hkReceiver);
+
+    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
+        const uint32_t setId, object_id_t destinationObject,
+        MessageQueueId_t targetQueueId, bool generateSnapshot) {
+    struct HkReceiver hkReceiver;
+    hkReceiver.dataType = DataType::DATA_SET;
+    hkReceiver.dataId.sid = sid_t(this->getOwner()->getObjectId(), setId);
+    hkReceiver.destinationQueue = targetQueueId;
+    hkReceiver.objectId = destinationObject;
+    if(generateSnapshot) {
+        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+    }
+    else {
+        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+    }
+
+    hkReceiversMap.push_back(hkReceiver);
+
+    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessages(
+        const lp_id_t localPoolId, object_id_t destinationObject,
+        MessageQueueId_t targetQueueId, bool generateSnapshot) {
+    struct HkReceiver hkReceiver;
+    hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
+    hkReceiver.dataId.localPoolId = localPoolId;
+    hkReceiver.destinationQueue = targetQueueId;
+    hkReceiver.objectId = destinationObject;
+    if(generateSnapshot) {
+        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+    }
+    else {
+        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+    }
+
+    hkReceiversMap.push_back(hkReceiver);
+
+    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType,
+        DataId dataId) {
+    if(hkUpdateResetList == nullptr) {
+        hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
+    }
+
+    for(auto& updateResetStruct: *hkUpdateResetList) {
+        if(dataType == DataType::DATA_SET) {
+            if(updateResetStruct.dataId.sid == dataId.sid) {
+                updateResetStruct.updateCounter++;
+                updateResetStruct.currentUpdateCounter++;
+                return;
+            }
+        }
+        else {
+            if(updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
+                updateResetStruct.updateCounter++;
+                updateResetStruct.currentUpdateCounter++;
+                return;
+            }
+        }
+
+    }
+    HkUpdateResetHelper hkUpdateResetHelper;
+    hkUpdateResetHelper.currentUpdateCounter = 1;
+    hkUpdateResetHelper.updateCounter = 1;
+    hkUpdateResetHelper.dataType = dataType;
+    if(dataType == DataType::DATA_SET) {
+        hkUpdateResetHelper.dataId.sid = dataId.sid;
+    }
+    else {
+        hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
+    }
+    hkUpdateResetList->push_back(hkUpdateResetHelper);
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-		CommandMessage* message) {
+        CommandMessage* message) {
     Command_t command = message->getCommand();
     sid_t sid = HousekeepingMessage::getSid(message);
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     switch(command) {
+    // Houskeeping interface handling.
     case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-    	result = togglePeriodicGeneration(sid, true, true);
-    	break;
+        result = togglePeriodicGeneration(sid, true, true);
+        break;
     }
 
     case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-    	result = togglePeriodicGeneration(sid, false, true);
-    	break;
+        result = togglePeriodicGeneration(sid, false, true);
+        break;
     }
 
     case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
-    	result = togglePeriodicGeneration(sid, true, false);
-    	break;
+        result = togglePeriodicGeneration(sid, true, false);
+        break;
     }
 
     case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
-    	result = togglePeriodicGeneration(sid, false, false);
-    	break;
+        result = togglePeriodicGeneration(sid, false, false);
+        break;
     }
 
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
-        return generateSetStructurePacket(sid, true);
+                        return generateSetStructurePacket(sid, true);
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-        return generateSetStructurePacket(sid, false);
+                        return generateSetStructurePacket(sid, false);
     case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
     case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
-    	float newCollIntvl = 0;
-    	HousekeepingMessage::getCollectionIntervalModificationCommand(message,
-    			&newCollIntvl);
-    	if(command == HousekeepingMessage::
-    			MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
-    		result = changeCollectionInterval(sid, newCollIntvl, true);
-    	}
-    	else {
-    		result = changeCollectionInterval(sid, newCollIntvl, false);
-    	}
-    	break;
+        float newCollIntvl = 0;
+        HousekeepingMessage::getCollectionIntervalModificationCommand(message,
+                &newCollIntvl);
+        if(command == HousekeepingMessage::
+                MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
+            result = changeCollectionInterval(sid, newCollIntvl, true);
+        }
+        else {
+            result = changeCollectionInterval(sid, newCollIntvl, false);
+        }
+        break;
     }
 
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
     case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
-    	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    	if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
-    			and dataSet->isDiagnostics()) {
-    		return WRONG_HK_PACKET_TYPE;
-    	}
-    	else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
-    			and not dataSet->isDiagnostics()) {
-    		return WRONG_HK_PACKET_TYPE;
-    	}
-    	return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
-    			dataSet, true);
+        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+        if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
+                and dataSet->isDiagnostics()) {
+            return WRONG_HK_PACKET_TYPE;
+        }
+        else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
+                and not dataSet->isDiagnostics()) {
+            return WRONG_HK_PACKET_TYPE;
+        }
+        return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+                dataSet, true);
+    }
+
+    // Notification handling.
+    case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
+        owner->handleChangedDataset(sid);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
+        lp_id_t locPoolId = HousekeepingMessage::
+                getUpdateNotificationVariableCommand(message);
+        owner->handleChangedPoolVariable(locPoolId);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
+        store_address_t storeId;
+        HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
+        owner->handleChangedDataset(sid, storeId);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
+        store_address_t storeId;
+        lp_id_t localPoolId = HousekeepingMessage::
+                getUpdateSnapshotVariableCommand(message, &storeId);
+        owner->handleChangedPoolVariable(localPoolId, storeId);
+        return HasReturnvaluesIF::RETURN_OK;
     }
 
     default:
@@ -205,30 +561,30 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     }
 
     CommandMessage reply;
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
-	}
-	else {
-		HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
-	}
-	hkQueue->sendMessage(hkDestinationId, &reply);
-	return result;
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
+    }
+    else {
+        HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
+    }
+    hkQueue->sendMessage(hkDestinationId, &reply);
+    return result;
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
-		lp_id_t localPoolId) {
-	auto poolIter = localPoolMap.find(localPoolId);
-	if (poolIter == localPoolMap.end()) {
-		sif::debug << "HousekeepingManager::fechPoolEntry:"
-				<< " Pool entry not found." << std::endl;
-		return POOL_ENTRY_NOT_FOUND;
-	}
-	poolIter->second->print();
-	return HasReturnvaluesIF::RETURN_OK;
+        lp_id_t localPoolId) {
+    auto poolIter = localPoolMap.find(localPoolId);
+    if (poolIter == localPoolMap.end()) {
+        sif::debug << "HousekeepingManager::fechPoolEntry:"
+                << " Pool entry not found." << std::endl;
+        return POOL_ENTRY_NOT_FOUND;
+    }
+    poolIter->second->print();
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 MutexIF* LocalDataPoolManager::getMutexHandle() {
-	return mutex;
+    return mutex;
 }
 
 HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
@@ -236,51 +592,51 @@ HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-		LocalPoolDataSetBase* dataSet, bool forDownlink,
-		MessageQueueId_t destination) {
-	if(dataSet == nullptr) {
-		// Configuration error.
-		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				<< " Set ID not found or dataset not assigned!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        LocalPoolDataSetBase* dataSet, bool forDownlink,
+        MessageQueueId_t destination) {
+    if(dataSet == nullptr) {
+        // Configuration error.
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+                << " Set ID not found or dataset not assigned!" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	store_address_t storeId;
-	HousekeepingPacketDownlink hkPacket(sid, dataSet);
-	size_t serializedSize = 0;
-	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
-			forDownlink, &serializedSize);
-	if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
-	    return result;
-	}
+    store_address_t storeId;
+    HousekeepingPacketDownlink hkPacket(sid, dataSet);
+    size_t serializedSize = 0;
+    ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
+            forDownlink, &serializedSize);
+    if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
+        return result;
+    }
 
-	// and now we set a HK message and send it the HK packet destination.
-	CommandMessage hkMessage;
-	if(dataSet->isDiagnostics()) {
-		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
-	}
-	else {
-		HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
-	}
+    // and now we set a HK message and send it the HK packet destination.
+    CommandMessage hkMessage;
+    if(dataSet->isDiagnostics()) {
+        HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
+    }
+    else {
+        HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
+    }
 
-	if(hkQueue == nullptr) {
-	    return QUEUE_OR_DESTINATION_NOT_SET;
-	}
-	if(destination == MessageQueueIF::NO_QUEUE) {
-	    if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
-	        // error, all destinations invalid
-	        return HasReturnvaluesIF::RETURN_FAILED;
-	    }
-	    destination = hkDestinationId;
-	}
+    if(hkQueue == nullptr) {
+        return QUEUE_OR_DESTINATION_NOT_SET;
+    }
+    if(destination == MessageQueueIF::NO_QUEUE) {
+        if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
+            // error, all destinations invalid
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        destination = hkDestinationId;
+    }
 
-	return hkQueue->sendMessage(destination, &hkMessage);
+    return hkQueue->sendMessage(destination, &hkMessage);
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
         HousekeepingPacketDownlink& hkPacket,
         store_address_t& storeId, bool forDownlink,
-		size_t* serializedSize) {
+        size_t* serializedSize) {
     uint8_t* dataPtr = nullptr;
     const size_t maxSize = hkPacket.getSerializedSize();
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
@@ -290,8 +646,8 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
     }
 
     if(forDownlink) {
-    	return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-    	            SerializeIF::Endianness::BIG);
+        return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+                SerializeIF::Endianness::BIG);
     }
     return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
             SerializeIF::Endianness::MACHINE);
@@ -303,125 +659,124 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 }
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
-	sid_t sid = receiver.dataId.sid;
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if(not dataSet->getReportingEnabled()) {
-		return;
-	}
+    sid_t sid = receiver.dataId.sid;
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(not dataSet->getReportingEnabled()) {
+        return;
+    }
 
-	if(dataSet->periodicHelper == nullptr) {
-		// Configuration error.
-		return;
-	}
+    if(dataSet->periodicHelper == nullptr) {
+        // Configuration error.
+        return;
+    }
 
-	if(not dataSet->periodicHelper->checkOpNecessary()) {
-		return;
-	}
+    if(not dataSet->periodicHelper->checkOpNecessary()) {
+        return;
+    }
 
-	ReturnValue_t result = generateHousekeepingPacket(
-			sid, dataSet, true);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		// configuration error
-		sif::debug << "LocalDataPoolManager::performHkOperation:"
-				<< "0x" << std::hex << std::setfill('0') << std::setw(8)
-				<< owner->getObjectId() << " Error generating "
-				<< "HK packet" << std::setfill(' ') << std::dec << std::endl;
-	}
+    ReturnValue_t result = generateHousekeepingPacket(
+            sid, dataSet, true);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        // configuration error
+        sif::debug << "LocalDataPoolManager::performHkOperation:"
+                << "0x" << std::hex << std::setfill('0') << std::setw(8)
+                << owner->getObjectId() << " Error generating "
+                << "HK packet" << std::setfill(' ') << std::dec << std::endl;
+    }
 }
 
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
-		bool enable, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if((dataSet->isDiagnostics() and not isDiagnostics) or
-			(not dataSet->isDiagnostics() and isDiagnostics)) {
-		return WRONG_HK_PACKET_TYPE;
-	}
+        bool enable, bool isDiagnostics) {
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if((dataSet->isDiagnostics() and not isDiagnostics) or
+            (not dataSet->isDiagnostics() and isDiagnostics)) {
+        return WRONG_HK_PACKET_TYPE;
+    }
 
-	if((dataSet->getReportingEnabled() and enable) or
-			(not dataSet->getReportingEnabled() and not enable)) {
-		return REPORTING_STATUS_UNCHANGED;
-	}
+    if((dataSet->getReportingEnabled() and enable) or
+            (not dataSet->getReportingEnabled() and not enable)) {
+        return REPORTING_STATUS_UNCHANGED;
+    }
 
-	dataSet->setReportingEnabled(enable);
-	return HasReturnvaluesIF::RETURN_OK;
+    dataSet->setReportingEnabled(enable);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
-		float newCollectionInterval, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	bool targetIsDiagnostics = dataSet->isDiagnostics();
-	if((targetIsDiagnostics and not isDiagnostics) or
-			(not targetIsDiagnostics and isDiagnostics)) {
-		return WRONG_HK_PACKET_TYPE;
-	}
+        float newCollectionInterval, bool isDiagnostics) {
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    bool targetIsDiagnostics = dataSet->isDiagnostics();
+    if((targetIsDiagnostics and not isDiagnostics) or
+            (not targetIsDiagnostics and isDiagnostics)) {
+        return WRONG_HK_PACKET_TYPE;
+    }
 
-	if(dataSet->periodicHelper == nullptr) {
-		// config error
-		return PERIODIC_HELPER_INVALID;
-	}
+    if(dataSet->periodicHelper == nullptr) {
+        // config error
+        return PERIODIC_HELPER_INVALID;
+    }
 
-	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
-	return HasReturnvaluesIF::RETURN_OK;
+    dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
-		bool isDiagnostics) {
+        bool isDiagnostics) {
     // Get and check dataset first.
-	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-			owner->getDataSetHandle(sid));
-	if(dataSet == nullptr) {
-		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				<< " Set ID not found" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(dataSet == nullptr) {
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+                << " Set ID not found" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
 
-	bool targetIsDiagnostics = dataSet->isDiagnostics();
-	if((targetIsDiagnostics and not isDiagnostics) or
-			(not targetIsDiagnostics and isDiagnostics)) {
-		return WRONG_HK_PACKET_TYPE;
-	}
+    bool targetIsDiagnostics = dataSet->isDiagnostics();
+    if((targetIsDiagnostics and not isDiagnostics) or
+            (not targetIsDiagnostics and isDiagnostics)) {
+        return WRONG_HK_PACKET_TYPE;
+    }
 
-	bool valid = dataSet->isValid();
-	bool reportingEnabled = dataSet->getReportingEnabled();
-	float collectionInterval =
-			dataSet->periodicHelper->getCollectionIntervalInSeconds();
+    bool valid = dataSet->isValid();
+    bool reportingEnabled = dataSet->getReportingEnabled();
+    float collectionInterval =
+            dataSet->periodicHelper->getCollectionIntervalInSeconds();
 
-	// Generate set packet which can be serialized.
-	HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid,
-			reportingEnabled, valid, collectionInterval, dataSet);
-	size_t expectedSize = setPacket.getSerializedSize();
-	uint8_t* storePtr = nullptr;
-	store_address_t storeId;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-			expectedSize,&storePtr);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-				<< "Could not get free element from IPC store." << std::endl;
-		return result;
-	}
+    // Generate set packet which can be serialized.
+    HousekeepingSetPacket setPacket(sid,
+            reportingEnabled, valid, collectionInterval, dataSet);
+    size_t expectedSize = setPacket.getSerializedSize();
+    uint8_t* storePtr = nullptr;
+    store_address_t storeId;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            expectedSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+                << "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
 
-	// Serialize set packet into store.
-	size_t size = 0;
-	result = setPacket.serialize(&storePtr, &size, expectedSize,
-			SerializeIF::Endianness::BIG);
-	if(expectedSize != size) {
-		sif::error << "HousekeepingManager::generateSetStructurePacket: "
-				<< "Expected size is not equal to serialized size" << std::endl;
-	}
+    // Serialize set packet into store.
+    size_t size = 0;
+    result = setPacket.serialize(&storePtr, &size, expectedSize,
+            SerializeIF::Endianness::BIG);
+    if(expectedSize != size) {
+        sif::error << "HousekeepingManager::generateSetStructurePacket: "
+                << "Expected size is not equal to serialized size" << std::endl;
+    }
 
-	// Send structure reporting reply.
-	CommandMessage reply;
-	if(isDiagnostics) {
-	    HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
-	            sid, storeId);
-	}
-	else {
-	    HousekeepingMessage::setHkStuctureReportReply(&reply,
-	                    sid, storeId);
-	}
+    // Send structure reporting reply.
+    CommandMessage reply;
+    if(isDiagnostics) {
+        HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
+                sid, storeId);
+    }
+    else {
+        HousekeepingMessage::setHkStuctureReportReply(&reply,
+                sid, storeId);
+    }
 
-	hkQueue->reply(&reply);
-	return result;
+    hkQueue->reply(&reply);
+    return result;
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 779e30500..95d483032 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -20,16 +20,23 @@ namespace Factory {
 void setStaticFrameworkObjectIds();
 }
 
-class LocalDataSetBase;
-
+class LocalPoolDataSetBase;
+class HousekeepingPacketUpdate;
 
 /**
  * @brief 		This class is the managing instance for the local data pool.
  * @details
  * The actual data pool structure is a member of this class. Any class which
- * has a local data pool shall have this class as a member and implement
+ * has a local data pool shall have this manager class as a member and implement
  * the HasLocalDataPoolIF.
  *
+ * The manager offers some adaption points and functions which can be used
+ * by the owning class to simplify data handling significantly.
+ *
+ * Please ensure that both initialize and initializeAfterTaskCreation are
+ * called at some point by the owning class in the respective functions of the
+ * same name!
+ *
  * Users of the data pool use the helper classes LocalDataSet,
  * LocalPoolVariable and LocalPoolVector to access pool entries in
  * a thread-safe and efficient way.
@@ -41,10 +48,8 @@ class LocalDataSetBase;
  * @author 		R. Mueller
  */
 class LocalDataPoolManager {
-	template<typename T>
-	friend class LocalPoolVar;
-	template<typename T, uint16_t vecSize>
-	friend class LocalPoolVector;
+	template<typename T> friend class LocalPoolVar;
+	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
@@ -67,14 +72,16 @@ public:
      * initialize() has to be called in any case before using the object!
      * @param owner
      * @param queueToUse
-     * @param appendValidityBuffer
+     * @param appendValidityBuffer Specify whether a buffer containing the
+     * validity state is generated  when serializing or deserializing packets.
      */
 	LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
 	        bool appendValidityBuffer = true);
 	virtual~ LocalDataPoolManager();
 
 	/**
-	 * Assigns the queue to use.
+	 * Assigns the queue to use. Make sure to call this in the #initialize
+	 * function of the owner.
 	 * @param queueToUse
 	 * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
 	 * @return
@@ -84,27 +91,88 @@ public:
 	/**
 	 * Initializes the map by calling the map initialization function and
 	 * setting the periodic factor for non-diagnostic packets.
-	 * Don't forget to call this, otherwise the map will be invalid!
+	 * Don't forget to call this in the #initializeAfterTaskCreation call of
+	 * the owner, otherwise the map will be invalid!
 	 * @param nonDiagInvlFactor
 	 * @return
 	 */
-	ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
+	ReturnValue_t initializeAfterTaskCreation(
+	        uint8_t nonDiagInvlFactor = 5);
 
     /**
-     * This should be called in the periodic handler of the owner.
+     * @brief   This should be called in the periodic handler of the owner.
+     * @details
+     * This in generally called in the #performOperation function of the owner.
      * It performs all the periodic functionalities of the data pool manager,
      * for example generating periodic HK packets.
+     * Marked virtual as an adaption point for custom data pool managers.
      * @return
      */
-    ReturnValue_t performHkOperation();
+    virtual ReturnValue_t performHkOperation();
 
 	/**
+	 * @brief   Subscribe for the generation of periodic packets.
+	 * @details
+     * This subscription mechanism will generally be used by the data creator
+     * to generate housekeeping packets which are downlinked directly.
 	 * @return
 	 */
 	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
 			float collectionInterval, bool isDiagnostics,
 			object_id_t packetDestination = defaultHkDestination);
 
+	/**
+	 * @brief   Subscribe for the  generation of packets if the dataset
+	 *          is marked as changed.
+	 * @details
+	 * This subscription mechanism will generally be used by the data creator.
+	 * @param sid
+	 * @param isDiagnostics
+	 * @param packetDestination
+	 * @return
+	 */
+    ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool reportingEnabled,
+            bool isDiagnostics,
+            object_id_t packetDestination = defaultHkDestination);
+
+	/**
+	 * @brief   Subscribe for a notification message which will be sent
+	 *          if a dataset has changed.
+	 * @details
+	 * This subscription mechanism will generally be used internally by
+	 * other software components.
+	 * @param setId     Set ID of the set to receive update messages from.
+	 * @param destinationObject
+	 * @param targetQueueId
+	 * @param generateSnapshot If this is set to true, a copy of the current
+	 * data with a timestamp will be generated and sent via message.
+	 * Otherwise, only an notification message is sent.
+	 * @return
+	 */
+	ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
+	        object_id_t destinationObject,
+	        MessageQueueId_t targetQueueId,
+	        bool generateSnapshot);
+
+    /**
+     * @brief   Subscribe for an notification message which will be sent if a
+     *          pool variable has changed.
+     * @details
+     * This subscription mechanism will generally be used internally by
+     * other software components.
+     * @param localPoolId Pool ID of the pool variable
+     * @param destinationObject
+     * @param targetQueueId
+     * @param generateSnapshot If this is set to true, a copy of the current
+     * data with a timestamp will be generated and sent via message.
+     * Otherwise, only an notification message is sent.
+     * @return
+     */
+    ReturnValue_t subscribeForVariableUpdateMessages(const lp_id_t localPoolId,
+            object_id_t destinationObject,
+            MessageQueueId_t targetQueueId,
+            bool generateSnapshot);
+
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
 	 * than diagnostic packets.
@@ -116,6 +184,19 @@ public:
 	 */
 	void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
 
+    /**
+     * @brief   The manager is also able to handle housekeeping messages.
+     * @details
+     * This most commonly is used to handle messages for the housekeeping
+     * interface, but the manager is also able to handle update notifications
+     * and calls a special function which can be overriden by a child class
+     * to handle data set or pool variable updates. This is relevant
+     * for classes like controllers which have their own local datapool
+     * but pull their data from other local datapools.
+     * @param message
+     * @return
+     */
+    virtual ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
 	/**
 	 * Generate a housekeeping packet with a given SID.
@@ -126,16 +207,6 @@ public:
 			LocalPoolDataSetBase* dataSet, bool forDownlink,
 			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 
-	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
-
-	/**
-	 * This function is used to fill the local data pool map with pool
-	 * entries. It should only be called once by the pool owner.
-	 * @param localDataPoolMap
-	 * @return
-	 */
-	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
-
 	HasLocalDataPoolIF* getOwner();
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
@@ -194,17 +265,18 @@ private:
 	static object_id_t defaultHkDestination;
 	MessageQueueId_t hkDestinationId = MessageQueueIF::NO_QUEUE;
 
+    union DataId {
+        DataId(): sid() {};
+        sid_t sid;
+        lp_id_t localPoolId;
+    };
+
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
 		/** Object ID of receiver */
 		object_id_t objectId = objects::NO_OBJECT;
 
 		DataType dataType = DataType::DATA_SET;
-        union DataId {
-			DataId(): sid() {};
-            sid_t sid;
-            lp_id_t localPoolId;
-        };
         DataId dataId;
 
         ReportingType reportingType = ReportingType::PERIODIC;
@@ -216,6 +288,17 @@ private:
 
     HkReceivers hkReceiversMap;
 
+    struct HkUpdateResetHelper {
+        DataType dataType = DataType::DATA_SET;
+        DataId dataId;
+        uint8_t updateCounter;
+        uint8_t currentUpdateCounter;
+    };
+
+    using HkUpdateResetList = std::vector<struct HkUpdateResetHelper>;
+    // Will only be created when needed.
+    HkUpdateResetList* hkUpdateResetList = nullptr;
+
     /** This is the map holding the actual data. Should only be initialized
      * once ! */
     bool mapInitialized = false;
@@ -234,7 +317,7 @@ private:
 	StorageManagerIF* ipcStore = nullptr;
 	/**
 	 * Get the pointer to the mutex. Can be used to lock the data pool
-	 * eternally. Use with care and don't forget to unlock locked mutexes!
+	 * externally. Use with care and don't forget to unlock locked mutexes!
 	 * For now, only friend classes can accss this function.
 	 * @return
 	 */
@@ -255,6 +338,14 @@ private:
 	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
 			PoolEntry<T> **poolEntry);
 
+    /**
+     * This function is used to fill the local data pool map with pool
+     * entries. It should only be called once by the pool owner.
+     * @param localDataPoolMap
+     * @return
+     */
+    ReturnValue_t initializeHousekeepingPoolEntriesOnce();
+
 	ReturnValue_t serializeHkPacketIntoStore(
 	        HousekeepingPacketDownlink& hkPacket,
 	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
@@ -265,6 +356,20 @@ private:
 	ReturnValue_t changeCollectionInterval(sid_t sid,
 			float newCollectionInterval, bool isDiagnostics);
 	ReturnValue_t generateSetStructurePacket(sid_t sid, bool isDiagnostics);
+
+	void handleHkUpdateResetListInsertion(DataType dataType, DataId dataId);
+	void handleChangeResetLogic(DataType type,
+	        DataId dataId, MarkChangedIF* toReset);
+	void resetHkUpdateResetHelper();
+
+	ReturnValue_t handleHkUpdate(HkReceiver& hkReceiver,
+            ReturnValue_t& status);
+	ReturnValue_t handleNotificationUpdate(HkReceiver& hkReceiver,
+	        ReturnValue_t& status);
+	ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver,
+            ReturnValue_t& status);
+	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
+	        store_address_t& storeId);
 };
 
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index da0a86b2c..640956dba 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -7,22 +7,24 @@
 #include <cstring>
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-		uint32_t setId, PoolVariableIF** registeredVariablesArray,
-		const size_t maxNumberOfVariables, bool noPeriodicHandling):
-		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-	if(hkOwner == nullptr) {
-		// Configuration error.
-		sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-				<< "invalid!" << std::endl;
-		return;
-	}
+        uint32_t setId, PoolVariableIF** registeredVariablesArray,
+        const size_t maxNumberOfVariables, bool noPeriodicHandling):
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+    if(hkOwner == nullptr) {
+        // Configuration error.
+        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+                << "invalid!" << std::endl;
+        return;
+    }
     hkManager = hkOwner->getHkManagerHandle();
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
 
+    mutex = MutexFactory::instance()->createMutex();
+
     // Data creators get a periodic helper for periodic HK data generation.
     if(not noPeriodicHandling) {
-    	 periodicHelper = new PeriodicHousekeepingHelper(this);
+        periodicHelper = new PeriodicHousekeepingHelper(this);
     }
 }
 
@@ -33,21 +35,23 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
     if(hkOwner == nullptr) {
-    	// Configuration error.
+        // Configuration error.
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-        		<< "invalid!" << std::endl;
+                << "invalid!" << std::endl;
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
     this->sid = sid;
+
+    mutex = MutexFactory::instance()->createMutex();
 }
 
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
 }
 
 ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+    MutexIF* mutex = hkManager->getMutexHandle();
+    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
@@ -77,6 +81,10 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
             return result;
         }
     }
+
+    if(*size + validityMaskSize > maxSize) {
+        return SerializeIF::BUFFER_TOO_SHORT;
+    }
     // copy validity buffer to end
     std::memcpy(*buffer, validityMask, validityMaskSize);
     *size += validityMaskSize;
@@ -89,14 +97,18 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
     ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
     for (uint16_t count = 0; count < fillCount; count++) {
         result = registeredVariables[count]->deSerialize(buffer, size,
-                        streamEndianness);
+                streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             return result;
         }
     }
+
+    if(*size < std::ceil(static_cast<float>(fillCount) / 8.0)) {
+        return SerializeIF::STREAM_TOO_SHORT;
+    }
+
     uint8_t validBufferIndex = 0;
     uint8_t validBufferIndexBit = 0;
-    // could be made more efficient but make it work first
     for (uint16_t count = 0; count < fillCount; count++) {
         // set validity buffer here.
         bool nextVarValid = this->bitGetter(*buffer +
@@ -113,9 +125,10 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
     }
     return result;
 }
+
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->unlockMutex();
+    MutexIF* mutex = hkManager->getMutexHandle();
+    return mutex->unlockMutex();
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
@@ -192,7 +205,7 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
         sif::debug << "Pool Raw Access: Bit setting invalid position"
-        		<< std::endl;
+                << std::endl;
         return;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
@@ -200,45 +213,49 @@ void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
 }
 
 void LocalPoolDataSetBase::setDiagnostic(bool isDiagnostics) {
-	this->diagnostic = isDiagnostics;
+    this->diagnostic = isDiagnostics;
 }
 
 bool LocalPoolDataSetBase::isDiagnostics() const {
-	return diagnostic;
+    return diagnostic;
 }
 
 void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
-	this->reportingEnabled = reportingEnabled;
+    this->reportingEnabled = reportingEnabled;
 }
 
 bool LocalPoolDataSetBase::getReportingEnabled() const {
-	return reportingEnabled;
+    return reportingEnabled;
 }
 
 void LocalPoolDataSetBase::initializePeriodicHelper(
-		float collectionInterval, dur_millis_t minimumPeriodicInterval,
-		bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
-	periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
-			isDiagnostics, nonDiagIntervalFactor);
+        float collectionInterval, dur_millis_t minimumPeriodicInterval,
+        bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
+    periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
+            isDiagnostics, nonDiagIntervalFactor);
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-	this->changed = changed;
+    // TODO: Make this configurable?
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    this->changed = changed;
 }
 
-bool LocalPoolDataSetBase::isChanged() const {
-	return changed;
+bool LocalPoolDataSetBase::hasChanged() const {
+    // TODO: Make this configurable?
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    return changed;
 }
 
 sid_t LocalPoolDataSetBase::getSid() const {
-	return sid;
+    return sid;
 }
 
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
-		uint8_t position) const {
+        uint8_t position) const {
     if(position > 7) {
         sif::debug << "Pool Raw Access: Bit setting invalid position"
-        		<< std::endl;
+                << std::endl;
         return false;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
@@ -246,14 +263,16 @@ bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 }
 
 bool LocalPoolDataSetBase::isValid() const {
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
     return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
-	if(setEntriesRecursively) {
-		for(size_t idx = 0; idx < this->getFillCount(); idx++) {
-			registeredVariables[idx] -> setValid(valid);
-		}
-	}
-	this->valid = valid;
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
+    if(setEntriesRecursively) {
+        for(size_t idx = 0; idx < this->getFillCount(); idx++) {
+            registeredVariables[idx] -> setValid(valid);
+        }
+    }
+    this->valid = valid;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index d00af9920..aa155bf1b 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -2,6 +2,8 @@
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
 #include "HasLocalDataPoolIF.h"
+#include "MarkChangedIF.h"
+
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
 #include "../serialize/SerializeIF.h"
@@ -39,7 +41,8 @@ class PeriodicHousekeepingHelper;
  *
  * @ingroup data_pool
  */
-class LocalPoolDataSetBase: public PoolDataSetBase {
+class LocalPoolDataSetBase: public PoolDataSetBase,
+        public MarkChangedIF {
 	friend class LocalDataPoolManager;
 	friend class PeriodicHousekeepingHelper;
 public:
@@ -109,18 +112,23 @@ public:
 	uint8_t getLocalPoolIdsSerializedSize(bool serializeFillCount = true) const;
 
 	/**
-	 * Set the dataset valid or invalid
+	 * Set the dataset valid or invalid. These calls are mutex protected.
 	 * @param setEntriesRecursively
 	 * If this is true, all contained datasets will also be set recursively.
 	 */
 	void setValidity(bool valid, bool setEntriesRecursively);
 	bool isValid() const override;
 
-	void setChanged(bool changed);
-	bool isChanged() const;
+	/**
+	 * These calls are mutex protected.
+	 * @param changed
+	 */
+	void setChanged(bool changed) override;
+	bool hasChanged() const override;
 
 protected:
 	sid_t sid;
+	MutexIF* mutex = nullptr;
 
 	bool diagnostic = false;
 	void setDiagnostic(bool diagnostics);
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
new file mode 100644
index 000000000..b4d0e3062
--- /dev/null
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -0,0 +1,73 @@
+#include "LocalPoolObjectBase.h"
+
+LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
+        HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+        pool_rwm_t setReadWriteMode): localPoolId(poolId),
+        readWriteMode(setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
+    }
+    if(hkOwner == nullptr) {
+        sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+                << "owner is a invalid!" << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+    if (dataSet != nullptr) {
+        dataSet->registerVariable(this);
+    }
+}
+
+LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
+        readWriteMode(setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
+    }
+    HasLocalDataPoolIF* hkOwner =
+            objectManager->get<HasLocalDataPoolIF>(poolOwner);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalPoolVariable: The supplied pool owner did not "
+                << "implement the correct interface"
+                << " HasLocalDataPoolIF!" << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+    if(dataSet != nullptr) {
+        dataSet->registerVariable(this);
+    }
+}
+
+pool_rwm_t LocalPoolObjectBase::getReadWriteMode() const {
+    return readWriteMode;
+}
+
+bool LocalPoolObjectBase::isValid() const {
+    return valid;
+}
+
+void LocalPoolObjectBase::setValid(bool valid) {
+    this->valid = valid;
+}
+
+lp_id_t LocalPoolObjectBase::getDataPoolId() const {
+    return localPoolId;
+}
+
+void LocalPoolObjectBase::setDataPoolId(lp_id_t poolId) {
+    this->localPoolId = poolId;
+}
+
+void LocalPoolObjectBase::setChanged(bool changed) {
+    this->changed = changed;
+}
+
+bool LocalPoolObjectBase::hasChanged() const {
+    return changed;
+}
+
+void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
+	this->readWriteMode = newReadWriteMode;
+}
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
new file mode 100644
index 000000000..7165fc242
--- /dev/null
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -0,0 +1,63 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
+
+#include "MarkChangedIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../datapool/PoolVariableIF.h"
+
+
+class LocalPoolObjectBase: public PoolVariableIF,
+        public HasReturnvaluesIF,
+        public MarkChangedIF {
+public:
+    LocalPoolObjectBase(lp_id_t poolId,
+            HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+            pool_rwm_t setReadWriteMode);
+
+    LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+    void setReadWriteMode(pool_rwm_t newReadWriteMode);
+    pool_rwm_t getReadWriteMode() const;
+
+    bool isValid() const override;
+    void setValid(bool valid) override;
+
+    void setChanged(bool changed) override;
+    bool hasChanged() const override;
+
+    lp_id_t getDataPoolId() const override;
+    void setDataPoolId(lp_id_t poolId);
+
+protected:
+    /**
+     * @brief   To access the correct data pool entry on read and commit calls,
+     *          the data pool id is stored.
+     */
+    uint32_t localPoolId = PoolVariableIF::NO_PARAMETER;
+    /**
+     * @brief   The valid information as it was stored in the data pool
+     *          is copied to this attribute.
+     */
+    bool valid = false;
+
+    /**
+     * @brief   A local pool variable can be marked as changed.
+     */
+    bool changed = false;
+
+    /**
+     * @brief   The information whether the class is read-write or
+     *          read-only is stored here.
+     */
+    ReadWriteMode_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
+
+    //! @brief  Pointer to the class which manages the HK pool.
+    LocalDataPoolManager* hkManager;
+
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index ec5c8cd19..c18d54433 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 
+#include "LocalPoolObjectBase.h"
 #include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
 
@@ -21,7 +22,7 @@
  * @ingroup data_pool
  */
 template<typename T>
-class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
+class LocalPoolVar: public LocalPoolObjectBase {
 public:
 	//! Default ctor is forbidden.
 	LocalPoolVar() = delete;
@@ -42,7 +43,7 @@ public:
 	 * If nullptr, the variable is not registered.
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 */
-	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+	LocalPoolVar(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
@@ -63,9 +64,17 @@ public:
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 *
 	 */
-	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+	LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+	/**
+	 * Variation which takes the global unique identifier of a pool variable.
+	 * @param globalPoolId
+	 * @param dataSet
+	 * @param setReadWriteMode
+	 */
+	LocalPoolVar(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	virtual~ LocalPoolVar() {};
 
@@ -76,15 +85,6 @@ public:
 	 */
 	T value = 0;
 
-	pool_rwm_t getReadWriteMode() const override;
-
-	lp_id_t getDataPoolId() const override;
-	void setDataPoolId(lp_id_t poolId);
-
-	bool isValid() const override;
-	void setValid(bool validity) override;
-	uint8_t getValid() const;
-
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
 	        SerializeIF::Endianness streamEndianness) const override;
 	virtual size_t getSerializedSize() const override;
@@ -118,7 +118,25 @@ public:
 	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
 
 
-	LocalPoolVar<T> &operator=(T newValue);
+	LocalPoolVar<T> &operator=(const T& newValue);
+	LocalPoolVar<T> &operator=(const LocalPoolVar<T>& newPoolVariable);
+
+	//! Explicit type conversion operator. Allows casting the class to
+	//! its template type to perform operations on value.
+	explicit operator T() const;
+
+	bool operator==(const LocalPoolVar<T>& other) const;
+	bool operator==(const T& other) const;
+
+	bool operator!=(const LocalPoolVar<T>& other) const;
+	bool operator!=(const T& other) const;
+
+	bool operator<(const LocalPoolVar<T>& other) const;
+	bool operator<(const T& other) const;
+
+	bool operator>(const LocalPoolVar<T>& other) const;
+	bool operator>(const T& other) const;
+
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
@@ -145,15 +163,6 @@ protected:
 			const LocalPoolVar<U> &var);
 
 private:
-	//! @brief 	Pool ID of pool entry inside the used local pool.
-	lp_id_t localPoolId = PoolVariableIF::NO_PARAMETER;
-	//! @brief 	Read-write mode of the pool variable
-	pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
-	//! @brief 	Specifies whether the entry is valid or invalid.
-	bool valid = false;
-
-	//! Pointer to the class which manages the HK pool.
-	LocalDataPoolManager* hkManager;
 };
 
 #include "LocalPoolVariable.tpp"
@@ -173,5 +182,4 @@ using lp_int64_t = LocalPoolVar<int64_t>;
 using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
-
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index b0bdd7b9e..b9f7b906e 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -6,46 +6,22 @@
 #endif
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
-		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
-		pool_rwm_t setReadWriteMode):
-		localPoolId(poolId), readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-		        << "which is the NO_PARAMETER value!" << std::endl;
-	}
-	if(hkOwner == nullptr) {
-		sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
-		        << "owner is a invalid!" << std::endl;
-		return;
-	}
-	hkManager = hkOwner->getHkManagerHandle();
-	if(dataSet != nullptr) {
-	    dataSet->registerVariable(this);
-	}
-}
+inline LocalPoolVar<T>::LocalPoolVar(HasLocalDataPoolIF* hkOwner,
+		lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+inline LocalPoolVar<T>::LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-        localPoolId(poolId), readWriteMode(setReadWriteMode) {
-    if(poolId == PoolVariableIF::NO_PARAMETER) {
-        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
-    }
-    HasLocalDataPoolIF* hkOwner =
-            objectManager->get<HasLocalDataPoolIF>(poolOwner);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalPoolVariable: The supplied pool owner did not "
-                << "implement  the correct interface "
-                << "HasLocalDataPoolIF!" << std::endl;
-        return;
-	}
-	hkManager = hkOwner->getHkManagerHandle();
-	if(dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
+        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+
+
+template<typename T>
+inline LocalPoolVar<T>::LocalPoolVar(gp_id_t globalPoolId, DataSetIF *dataSet,
+		pool_rwm_t setReadWriteMode):
+		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+				dataSet, setReadWriteMode){}
+
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
@@ -104,43 +80,6 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 	return RETURN_OK;
 }
 
-template<typename T>
-inline LocalPoolVar<T> & LocalPoolVar<T>::operator =(T newValue) {
-    value = newValue;
-    return *this;
-}
-
-
-template<typename T>
-inline pool_rwm_t LocalPoolVar<T>::getReadWriteMode() const {
-	return readWriteMode;
-}
-
-template<typename T>
-inline lp_id_t LocalPoolVar<T>::getDataPoolId() const {
-	return localPoolId;
-}
-
-template<typename T>
-inline void LocalPoolVar<T>::setDataPoolId(lp_id_t poolId) {
-	this->localPoolId = poolId;
-}
-
-template<typename T>
-inline bool LocalPoolVar<T>::isValid() const {
-	return valid;
-}
-
-template<typename T>
-inline void LocalPoolVar<T>::setValid(bool validity) {
-	this->valid = validity;
-}
-
-template<typename T>
-inline uint8_t LocalPoolVar<T>::getValid() const {
-	return valid;
-}
-
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
@@ -166,4 +105,65 @@ inline std::ostream& operator<< (std::ostream &out,
     return out;
 }
 
-#endif
+template<typename T>
+inline LocalPoolVar<T>::operator T() const {
+	return value;
+}
+
+template<typename T>
+inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(const T& newValue) {
+    value = newValue;
+    return *this;
+}
+
+template<typename T>
+inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
+		const LocalPoolVar<T>& newPoolVariable) {
+	value = newPoolVariable.value;
+	return *this;
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator ==(const LocalPoolVar<T> &other) const {
+	return this->value == other.value;
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator ==(const T &other) const {
+	return this->value == other;
+}
+
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator !=(const LocalPoolVar<T> &other) const {
+	return not (*this == other);
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator !=(const T &other) const {
+	return not (*this == other);
+}
+
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator <(const LocalPoolVar<T> &other) const {
+	return this->value < other.value;
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator <(const T &other) const {
+	return this->value < other;
+}
+
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator >(const LocalPoolVar<T> &other) const {
+	return not (*this < other);
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator >(const T &other) const {
+	return not (*this < other);
+}
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 57c4b90b4..58face3cb 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,6 +1,7 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 
+#include "LocalPoolObjectBase.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
 #include "../datapool/PoolVariableIF.h"
@@ -30,7 +31,7 @@
  * @ingroup data_pool
  */
 template<typename T, uint16_t vectorSize>
-class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
+class LocalPoolVector: public LocalPoolObjectBase {
 public:
 	LocalPoolVector() = delete;
 	/**
@@ -46,10 +47,9 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+	LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE
-			);
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	/**
 	 * This constructor is used by data users like controllers to have
@@ -65,10 +65,19 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
+	LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE
-			);
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+	/**
+	 * Variation which takes the unique global identifier of a local pool
+	 * vector.
+	 * @param globalPoolId
+	 * @param dataSet
+	 * @param setReadWriteMode
+	 */
+	LocalPoolVector(gp_id_t globalPoolId,
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	/**
 	 * @brief	This is the local copy of the data pool entry.
@@ -91,27 +100,6 @@ public:
 		return vectorSize;
 	}
 
-	uint32_t getDataPoolId() const override;
-	/**
-	 * @brief This operation sets the data pool ID of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	pool_rwm_t getReadWriteMode() const;
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-	void setValid(bool valid) override;
-	uint8_t getValid() const;
-
 	T& operator [](int i);
 	const T &operator [](int i) const;
 
@@ -168,23 +156,7 @@ protected:
 	ReturnValue_t commitWithoutLock() override;
 
 private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t localPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	bool valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	//! @brief	Pointer to the class which manages the HK pool.
-	LocalDataPoolManager* hkManager;
+
 
 	// std::ostream is the type for object std::cout
 	template <typename U, uint16_t otherSize>
@@ -199,4 +171,4 @@ private:
 template<typename T, uint16_t vectorSize>
 using lp_vec_t = LocalPoolVector<T, vectorSize>;
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 2aa6fbb5f..46123ccc1 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -1,47 +1,27 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
 
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 #error Include LocalPoolVector.h before LocalPoolVector.tpp!
 #endif
 
 template<typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
+		HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
 		pool_rwm_t setReadWriteMode):
-		localPoolId(poolId), valid(false), readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: PoolVariableIF::NO_PARAMETER passed "
-				<< "as pool ID, which is the NO_PARAMETER value!" << std::endl;
-	}
-	std::memset(this->value, 0, vectorSize * sizeof(T));
-	hkManager = hkOwner->getHkManagerHandle();
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
+		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		object_id_t poolOwner, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: PoolVariableIF::NO_PARAMETER passed "
-				<< "as pool ID, which is the NO_PARAMETER value!" << std::endl;
-	}
-	HasLocalDataPoolIF* hkOwner =
-			objectManager->get<HasLocalDataPoolIF>(poolOwner);
-	if(hkOwner == nullptr) {
-		sif::error << "LocalPoolVariable: The supplied pool owner did not "
-				<< "implement the correct interface HasHkPoolParametersIF!"
-				<< std::endl;
-		return;
-	}
-	hkManager = hkOwner->getHkManagerHandle();
-	if(dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
+		lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+		LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+
+
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
+		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+				dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
@@ -161,37 +141,6 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
 	return result;
 }
 
-template<typename T, uint16_t vectorSize>
-inline pool_rwm_t LocalPoolVector<T, vectorSize>::getReadWriteMode() const {
-	return this->readWriteMode;
-}
-
-
-template<typename T, uint16_t vectorSize>
-inline uint32_t LocalPoolVector<T, vectorSize>::getDataPoolId() const {
-	return localPoolId;
-}
-
-template<typename T, uint16_t vectorSize>
-inline void LocalPoolVector<T, vectorSize>::setDataPoolId(uint32_t poolId) {
-	this->localPoolId = poolId;
-}
-
-template<typename T, uint16_t vectorSize>
-inline void LocalPoolVector<T, vectorSize>::setValid(bool valid) {
-	this->valid = valid;
-}
-
-template<typename T, uint16_t vectorSize>
-inline uint8_t LocalPoolVector<T, vectorSize>::getValid() const {
-	return valid;
-}
-
-template<typename T, uint16_t vectorSize>
-inline bool LocalPoolVector<T, vectorSize>::isValid() const {
-	return valid;
-}
-
 template<typename T, uint16_t vectorSize>
 inline std::ostream& operator<< (std::ostream &out,
         const LocalPoolVector<T, vectorSize> &var) {
@@ -206,4 +155,4 @@ inline std::ostream& operator<< (std::ostream &out,
     return out;
 }
 
-#endif
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_ */
diff --git a/datapoollocal/MarkChangedIF.h b/datapoollocal/MarkChangedIF.h
new file mode 100644
index 000000000..e575d1d3e
--- /dev/null
+++ b/datapoollocal/MarkChangedIF.h
@@ -0,0 +1,17 @@
+#ifndef FSFW_DATAPOOLLOCAL_MARKCHANGEDIF_H_
+#define FSFW_DATAPOOLLOCAL_MARKCHANGEDIF_H_
+
+/**
+ * Common interface for local pool entities which can be marked as changed.
+ */
+class MarkChangedIF {
+public:
+    virtual~ MarkChangedIF() {};
+
+    virtual bool hasChanged() const = 0;
+    virtual void setChanged(bool changed) = 0;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_MARKCHANGEDIF_H_ */
diff --git a/datapoollocal/locPoolDefinitions.h b/datapoollocal/locPoolDefinitions.h
new file mode 100644
index 000000000..6e74d349a
--- /dev/null
+++ b/datapoollocal/locPoolDefinitions.h
@@ -0,0 +1,93 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
+#define FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
+
+#include <cstdint>
+#include "../objectmanager/SystemObjectIF.h"
+#include "../objectmanager/frameworkObjects.h"
+
+/**
+ * @brief   Type definition for local pool entries.
+ */
+using lp_id_t = uint32_t;
+
+namespace localpool {
+static constexpr uint32_t INVALID_LPID = -1;
+}
+
+/**
+ * Used as a unique identifier for data sets.
+ */
+union sid_t {
+    static constexpr uint64_t INVALID_SID = -1;
+    static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+    static constexpr uint32_t INVALID_SET_ID = -1;
+
+
+    sid_t(): raw(INVALID_SID) {}
+
+    sid_t(object_id_t objectId, uint32_t setId):
+            objectId(objectId),
+            ownerSetId(setId) {}
+
+    struct {
+        object_id_t objectId ;
+        /**
+         * A generic 32 bit ID to identify unique HK packets for a single
+         * object. For example, the DeviceCommandId_t is used for
+         * DeviceHandlers
+         */
+        uint32_t ownerSetId;
+    };
+    /**
+     * Alternative access to the raw value. This is also the size of the type.
+     */
+    uint64_t raw;
+
+    bool notSet() const {
+        return raw == INVALID_SID;
+    }
+
+    bool operator==(const sid_t& other) const {
+        return raw == other.raw;
+    }
+
+    bool operator!=(const sid_t& other) const {
+        return not (raw == other.raw);
+    }
+};
+
+/**
+ * Used as a global unique identifier for local pool variables.
+ */
+union gp_id_t {
+	static constexpr uint64_t INVALID_GPID = -1;
+    static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
+
+	gp_id_t(): raw(INVALID_GPID) {}
+
+	gp_id_t(object_id_t objectId, lp_id_t localPoolId):
+			objectId(objectId),
+			localPoolId(localPoolId) {}
+
+	struct {
+		object_id_t objectId;
+		lp_id_t localPoolId;
+	};
+
+	uint64_t raw;
+
+	bool notSet() const {
+		return raw == INVALID_GPID;
+	}
+
+    bool operator==(const sid_t& other) const {
+        return raw == other.raw;
+    }
+
+    bool operator!=(const sid_t& other) const {
+        return not (raw == other.raw);
+    }
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_ */
diff --git a/housekeeping/AcceptsHkPacketsIF.h b/housekeeping/AcceptsHkPacketsIF.h
index b3ba6e7c0..6fa151b19 100644
--- a/housekeeping/AcceptsHkPacketsIF.h
+++ b/housekeeping/AcceptsHkPacketsIF.h
@@ -1,5 +1,6 @@
 #ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
 #define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+
 #include "../ipc/MessageQueueMessageIF.h"
 
 class AcceptsHkPacketsIF {
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index d2ab546b0..221f0a6f8 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,5 +1,6 @@
-#include <fsfw/objectmanager/ObjectManagerIF.h>
 #include "HousekeepingMessage.h"
+
+#include "../objectmanager/ObjectManagerIF.h"
 #include <cstring>
 
 HousekeepingMessage::~HousekeepingMessage() {}
@@ -148,7 +149,7 @@ void HousekeepingMessage::clear(CommandMessage* message) {
     case(DIAGNOSTICS_REPORT):
     case(HK_DEFINITIONS_REPORT):
     case(DIAGNOSTICS_DEFINITION_REPORT):
-    case(UPDATE_SNAPSHOT): {
+    case(UPDATE_SNAPSHOT_SET): {
         store_address_t storeId;
         getHkDataReply(message, &storeId);
         StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
@@ -160,3 +161,55 @@ void HousekeepingMessage::clear(CommandMessage* message) {
     }
     message->setCommand(CommandMessage::CMD_NONE);
 }
+
+void HousekeepingMessage::setUpdateNotificationSetCommand(
+        CommandMessage *command, sid_t sid) {
+    command->setCommand(UPDATE_NOTIFICATION_SET);
+    setSid(command, sid);
+}
+
+void HousekeepingMessage::setUpdateNotificationVariableCommand(
+        CommandMessage *command, lp_id_t localPoolId) {
+    command->setCommand(UPDATE_NOTIFICATION_VARIABLE);
+    command->setParameter(localPoolId);
+}
+
+void HousekeepingMessage::setUpdateSnapshotSetCommand(CommandMessage *command,
+        sid_t sid, store_address_t storeId) {
+    command->setCommand(UPDATE_SNAPSHOT_VARIABLE);
+    setSid(command, sid);
+    command->setParameter3(storeId.raw);
+}
+
+void HousekeepingMessage::setUpdateSnapshotVariableCommand(
+        CommandMessage *command, lp_id_t localPoolId, store_address_t storeId) {
+    command->setCommand(UPDATE_SNAPSHOT_VARIABLE);
+    command->setParameter(localPoolId);
+    command->setParameter3(storeId.raw);
+}
+
+sid_t HousekeepingMessage::getUpdateNotificationSetCommand(
+        const CommandMessage *command) {
+    return getSid(command);
+}
+
+lp_id_t HousekeepingMessage::getUpdateNotificationVariableCommand(
+        const CommandMessage *command) {
+    return command->getParameter();
+}
+
+sid_t HousekeepingMessage::getUpdateSnapshotSetCommand(
+        const CommandMessage *command, store_address_t *storeId) {
+    if(storeId != nullptr) {
+        *storeId = command->getParameter3();
+    }
+    return getSid(command);
+}
+
+lp_id_t HousekeepingMessage::getUpdateSnapshotVariableCommand(
+        const CommandMessage *command, store_address_t *storeId) {
+    if(storeId != nullptr) {
+        *storeId = command->getParameter3();
+    }
+    return command->getParameter();
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 6dc95f542..90bbe594a 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,49 +1,12 @@
 #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
 #include "../objectmanager/frameworkObjects.h"
-#include "../objectmanager/SystemObjectIF.h"
 #include "../storagemanager/StorageManagerIF.h"
 
-union sid_t {
-	static constexpr uint64_t INVALID_SID = -1;
-	static constexpr uint32_t INVALID_SET_ID = -1;
-	static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
-	sid_t(): raw(INVALID_SID) {}
-
-	sid_t(object_id_t objectId, uint32_t setId):
-			objectId(objectId),
-			ownerSetId(setId) {}
-
-	struct {
-		object_id_t objectId ;
-		/**
-		 * A generic 32 bit ID to identify unique HK packets for a single
-		 * object. For example, the DeviceCommandId_t is used for
-		 * DeviceHandlers
-		 */
-		uint32_t ownerSetId;
-	};
-	/**
-	 * Alternative access to the raw value. This is also the size of the type.
-	 */
-	uint64_t raw;
-
-	bool notSet() const {
-	    return raw == INVALID_SID;
-	}
-
-	bool operator==(const sid_t& other) const {
-		return raw == other.raw;
-	}
-
-	bool operator!=(const sid_t& other) const {
-		return not (raw == other.raw);
-	}
-};
-
 
 /**
  * @brief	Special command message type for housekeeping messages
@@ -101,14 +64,20 @@ public:
 	static constexpr Command_t HK_REQUEST_FAILURE =
 			MAKE_COMMAND_ID(129);
 
-	static constexpr Command_t UPDATE_NOTIFICATION = MAKE_COMMAND_ID(130);
-	static constexpr Command_t UPDATE_SNAPSHOT = MAKE_COMMAND_ID(131);
+	static constexpr Command_t UPDATE_NOTIFICATION_SET =
+	        MAKE_COMMAND_ID(130);
+	static constexpr Command_t UPDATE_NOTIFICATION_VARIABLE =
+	        MAKE_COMMAND_ID(131);
 
-	static constexpr Command_t UPDATE_HK_REPORT = MAKE_COMMAND_ID(132);
+	static constexpr Command_t UPDATE_SNAPSHOT_SET = MAKE_COMMAND_ID(132);
+	static constexpr Command_t UPDATE_SNAPSHOT_VARIABLE = MAKE_COMMAND_ID(133);
+
+	//static constexpr Command_t UPDATE_HK_REPORT = MAKE_COMMAND_ID(134);
 
 	static sid_t getSid(const CommandMessage* message);
 
-	/** Setter functions */
+	/* Housekeeping Interface Messages */
+
 	static void setToggleReportingCommand(CommandMessage* command, sid_t sid,
 			bool enableReporting, bool isDiagnostics);
 	static void setStructureReportingCommand(CommandMessage* command, sid_t sid,
@@ -148,6 +117,29 @@ public:
 	static sid_t getCollectionIntervalModificationCommand(
 			const CommandMessage* command, float* newCollectionInterval);
 
+
+    /* Update Notification Messages */
+
+    static void setUpdateNotificationSetCommand(CommandMessage* command,
+            sid_t sid);
+    static void setUpdateNotificationVariableCommand(CommandMessage* command,
+            lp_id_t localPoolId);
+
+    static void setUpdateSnapshotSetCommand(CommandMessage* command, sid_t sid,
+            store_address_t storeId);
+    static void setUpdateSnapshotVariableCommand(CommandMessage* command,
+            lp_id_t localPoolId, store_address_t storeId);
+
+    static sid_t getUpdateNotificationSetCommand(const CommandMessage* command);
+    static lp_id_t getUpdateNotificationVariableCommand(
+            const CommandMessage* command);
+
+    static sid_t getUpdateSnapshotSetCommand(const CommandMessage* command,
+            store_address_t* storeId);
+    static lp_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command,
+            store_address_t* storeId);
+
+    /** Utility */
 	static void clear(CommandMessage* message);
 private:
 	static void setSid(CommandMessage* message, sid_t sid);
diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index eebdc11cc..43ec0619c 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
-#define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
 
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialLinkedListAdapter.h"
@@ -12,6 +12,7 @@
 class HousekeepingPacketUpdate: public SerializeIF {
 public:
     /**
+     * Update packet constructor for datasets
      * @param timeStamp
      * @param timeStampSize
      * @param hkData
@@ -19,8 +20,19 @@ public:
      */
     HousekeepingPacketUpdate(uint8_t* timeStamp, size_t timeStampSize,
             LocalPoolDataSetBase* dataSetPtr):
-            timeStamp(timeStamp), timeStampSize(timeStampSize),
-            dataSetPtr(dataSetPtr) {};
+                timeStamp(timeStamp), timeStampSize(timeStampSize),
+                updateData(dataSetPtr) {};
+
+    /**
+     * Update packet constructor for pool variables.
+     * @param timeStamp
+     * @param timeStampSize
+     * @param dataSetPtr
+     */
+    HousekeepingPacketUpdate(uint8_t* timeStamp, size_t timeStampSize,
+            LocalPoolObjectBase* dataSetPtr):
+                timeStamp(timeStamp), timeStampSize(timeStampSize),
+                updateData(dataSetPtr) {};
 
     virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
             size_t maxSize, Endianness streamEndianness) const {
@@ -31,43 +43,50 @@ public:
             *size += timeStampSize;
             *buffer += timeStampSize;
         }
-        if(dataSetPtr == nullptr) {
+        if(updateData == nullptr) {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
 
-        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
+        return updateData->serialize(buffer, size, maxSize, streamEndianness);
     }
 
     virtual size_t getSerializedSize() const {
-        if(dataSetPtr == nullptr) {
+        if(updateData == nullptr) {
             return 0;
         }
-        return timeStampSize + dataSetPtr->getSerializedSize();
+        return timeStampSize + updateData->getSerializedSize();
     }
 
     virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
             SerializeIF::Endianness streamEndianness) override {
+        if(*size < timeStampSize) {
+            return SerializeIF::STREAM_TOO_SHORT;
+        }
+
         if(timeStamp != nullptr) {
             /* Endianness will always be MACHINE, so we can simply use memcpy
             here. */
             std::memcpy(timeStamp, *buffer, timeStampSize);
-            *size += timeStampSize;
+            *size -= timeStampSize;
             *buffer += timeStampSize;
         }
 
-        if(dataSetPtr == nullptr) {
+        if(updateData == nullptr) {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
-        return dataSetPtr->deSerialize(buffer, size, streamEndianness);
+        if(*size < updateData->getSerializedSize()) {
+            return SerializeIF::STREAM_TOO_SHORT;
+        }
+
+        return updateData->deSerialize(buffer, size, streamEndianness);
     }
 
 private:
-   uint8_t* timeStamp;
-   size_t timeStampSize;
+   uint8_t* timeStamp = nullptr;
+   size_t timeStampSize = 0;
 
-   LocalPoolDataSetBase* dataSetPtr = nullptr;
+   SerializeIF* updateData = nullptr;
 };
 
 
-
-#endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_ */
+#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_ */
diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
index 37349f815..365f00048 100644
--- a/housekeeping/PeriodicHousekeepingHelper.cpp
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -1,5 +1,6 @@
-#include "../datapoollocal/LocalPoolDataSetBase.h"
 #include "PeriodicHousekeepingHelper.h"
+
+#include "../datapoollocal/LocalPoolDataSetBase.h"
 #include <cmath>
 
 PeriodicHousekeepingHelper::PeriodicHousekeepingHelper(

From 74ba8b76644c31405d67878421b2081306eab453 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 13:10:33 +0100
Subject: [PATCH 1085/1774] changel og updated

---
 CHANGELOG | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index a6686478c..62a6b0a9c 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -11,3 +11,19 @@ a C file without issues
 - It is now possible to change the message queue depth for the telecommand verification service (PUS1)
 - The same is possible for the event reporting service (PUS5)
 - PUS Health Service added, which allows to command and retrieve health via PUS packets
+
+### Parameter Service
+
+- The API of the parameter service has been changed to prevent incosistencies
+and clarify usage when inspecting the code.
+- The parameter ID now consists of:
+	1. Domain ID (1 byte)
+	2. Unique Identifier (1 byte)
+	3. Linear Index (2 bytes)
+The linear index can be used for arrays as well as matrices.
+The parameter load command now explicitely expects the ECSS PTC and PFC
+information as well as  the rows and column number. Rows and column will
+default to one, which is equivalent to one scalar parameter (the most
+important use-case)
+
+   

From 3f9f062435061c32818c4c4ddb078cb328ea8f4d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 13:11:52 +0100
Subject: [PATCH 1086/1774] changelog update

---
 CHANGELOG | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG b/CHANGELOG
index 62a6b0a9c..8341e1389 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -14,8 +14,8 @@ a C file without issues
 
 ### Parameter Service
 
-- The API of the parameter service has been changed to prevent incosistencies
-and clarify usage when inspecting the code.
+- The API of the parameter service has been changed to prevent inconsistencies
+between documentation and actual code and to clarify usage.
 - The parameter ID now consists of:
 	1. Domain ID (1 byte)
 	2. Unique Identifier (1 byte)

From 795ff585f858f7ca4a155eaf7bf704964ad6f13d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 13:14:30 +0100
Subject: [PATCH 1087/1774] controller base update

---
 controller/ControllerBase.cpp | 41 ++++++++++--------
 controller/ControllerBase.h   | 78 +++++++++++++++++++++--------------
 2 files changed, 71 insertions(+), 48 deletions(-)

diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 695517310..45e678eb4 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -1,16 +1,16 @@
-#include "../subsystem/SubsystemBase.h"
 #include "ControllerBase.h"
+
 #include "../subsystem/SubsystemBase.h"
 #include "../ipc/QueueFactory.h"
 #include "../action/HasActionsIF.h"
 
-ControllerBase::ControllerBase(uint32_t setObjectId, uint32_t parentId,
+ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
 		size_t commandQueueDepth) :
-		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF), submode(
-				SUBMODE_NONE), commandQueue(NULL), modeHelper(
-				this), healthHelper(this, setObjectId),hkSwitcher(this),executingTask(NULL) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
-
+		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
+		submode(SUBMODE_NONE), modeHelper(this),
+		healthHelper(this, setObjectId), hkSwitcher(this) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(
+	        commandQueueDepth);
 }
 
 ControllerBase::~ControllerBase() {
@@ -24,9 +24,9 @@ ReturnValue_t ControllerBase::initialize() {
 	}
 
 	MessageQueueId_t parentQueue = 0;
-	if (parentId != 0) {
+	if (parentId != objects::NO_OBJECT) {
 		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
+		if (parent == nullptr) {
 			return RETURN_FAILED;
 		}
 		parentQueue = parent->getCommandQueue();
@@ -56,26 +56,27 @@ MessageQueueId_t ControllerBase::getCommandQueue() const {
 }
 
 void ControllerBase::handleQueue() {
-	CommandMessage message;
-	ReturnValue_t result;
-	for (result = commandQueue->receiveMessage(&message); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&message)) {
+	CommandMessage command;
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	for (result = commandQueue->receiveMessage(&command);
+	        result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
 
-		result = modeHelper.handleModeCommand(&message);
+		result = modeHelper.handleModeCommand(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
-		result = handleCommandMessage(&message);
+		result = handleCommandMessage(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
-		message.setToUnknownCommand();
-		commandQueue->reply(&message);
+		command.setToUnknownCommand();
+		commandQueue->reply(&command);
 	}
 
 }
@@ -135,3 +136,7 @@ void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
 
 void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 }
+
+ReturnValue_t ControllerBase::initializeAfterTaskCreation() {
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index f5182ceb3..25d3ab1f3 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -1,5 +1,5 @@
-#ifndef CONTROLLERBASE_H_
-#define CONTROLLERBASE_H_
+#ifndef FSFW_CONTROLLER_CONTROLLERBASE_H_
+#define FSFW_CONTROLLER_CONTROLLERBASE_H_
 
 #include "../health/HasHealthIF.h"
 #include "../health/HealthHelper.h"
@@ -7,73 +7,91 @@
 #include "../modes/ModeHelper.h"
 #include "../objectmanager/SystemObject.h"
 #include "../tasks/ExecutableObjectIF.h"
+#include "../tasks/PeriodicTaskIF.h"
 #include "../datapool/HkSwitchHelper.h"
 
-
+/**
+ * @brief   Generic base class for controller classes
+ * @details
+ * Implements common interfaces for controllers, which generally have
+ * a mode and a health state. This avoids boilerplate code.
+ */
 class ControllerBase: public HasModesIF,
 		public HasHealthIF,
 		public ExecutableObjectIF,
 		public SystemObject,
 		public HasReturnvaluesIF {
 public:
-
 	static const Mode_t MODE_NORMAL = 2;
 
-	ControllerBase(uint32_t setObjectId, uint32_t parentId,
+	ControllerBase(object_id_t setObjectId, object_id_t parentId,
 			size_t commandQueueDepth = 3);
 	virtual ~ControllerBase();
 
-	ReturnValue_t initialize();
+	/** SystemObject override */
+	virtual ReturnValue_t initialize() override;
 
-	virtual MessageQueueId_t getCommandQueue() const;
+	virtual MessageQueueId_t getCommandQueue() const override;
 
-	virtual ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual ReturnValue_t setHealth(HealthState health);
-
-	virtual HasHealthIF::HealthState getHealth();
-
-	/**
-	 * Implementation of ExecutableObjectIF function
-	 *
-	 * Used to setup the reference of the task, that executes this component
-	 * @param task_ Pointer to the taskIF of this task
-	 */
-	virtual  void setTaskIF(PeriodicTaskIF* task_);
+	/** HasHealthIF overrides */
+	virtual ReturnValue_t setHealth(HealthState health) override;
+	virtual HasHealthIF::HealthState getHealth() override;
 
+	/** ExecutableObjectIF overrides */
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual void setTaskIF(PeriodicTaskIF* task) override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
 
 protected:
-	const uint32_t parentId;
+
+	/**
+	 * Implemented by child class. Handle command messages which are not
+	 * mode or health messages.
+	 * @param message
+	 * @return
+	 */
+    virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+    /**
+     * Periodic helper, implemented by child class.
+     */
+    virtual void performControlOperation() = 0;
+
+    virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+            uint32_t *msToReachTheMode) = 0;
+
+	const object_id_t parentId;
 
 	Mode_t mode;
 
 	Submode_t submode;
 
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 
 	ModeHelper modeHelper;
 
 	HealthHelper healthHelper;
 
+	// Is this still needed?
 	HkSwitchHelper hkSwitcher;
 
 	/**
-	 * 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;
+	PeriodicTaskIF* executingTask = nullptr;
 
-	void handleQueue();
+	/** Handle mode and health messages */
+	virtual void handleQueue();
 
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
-	virtual void performControlOperation() = 0;
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode) = 0;
+	/** Mode helpers */
 	virtual void modeChanged(Mode_t mode, Submode_t submode);
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
 	virtual void setToExternalControl();
 	virtual void announceMode(bool recursive);
+	/** HK helpers */
 	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 };
 
-#endif /* CONTROLLERBASE_H_ */
+#endif /* FSFW_CONTROLLER_CONTROLLERBASE_H_ */

From 5e092778edcce53ba6bdc89c8b5e0b9a7b9482b8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 13:17:28 +0100
Subject: [PATCH 1088/1774] some minor changes

---
 datalinklayer/MapPacketExtraction.cpp | 17 +++++------------
 datalinklayer/MapPacketExtraction.h   |  8 +-------
 2 files changed, 6 insertions(+), 19 deletions(-)

diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index d64348e15..45f7d3f8b 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -1,10 +1,3 @@
-/**
- * @file	MapPacketExtraction.cpp
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
 #include "MapPacketExtraction.h"
 #include "../ipc/QueueFactory.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
@@ -12,14 +5,14 @@
 #include "../tmtcpacket/SpacePacketBase.h"
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../tmtcservices/TmTcMessage.h"
-#include <string.h>
+#include <cstring>
 
 MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
 		object_id_t setPacketDestination) :
-		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0), bufferPosition(
-				packetBuffer), packetDestination(setPacketDestination), packetStore(
-				NULL), tcQueueId(MessageQueueIF::NO_QUEUE) {
-	memset(packetBuffer, 0, sizeof(packetBuffer));
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
+		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
+		packetStore(NULL), tcQueueId(MessageQueueIF::NO_QUEUE) {
+	std::memset(packetBuffer, 0, sizeof(packetBuffer));
 }
 
 ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
diff --git a/datalinklayer/MapPacketExtraction.h b/datalinklayer/MapPacketExtraction.h
index 507f13dbe..eff9b7c3c 100644
--- a/datalinklayer/MapPacketExtraction.h
+++ b/datalinklayer/MapPacketExtraction.h
@@ -1,10 +1,3 @@
-/**
- * @file	MapPacketExtraction.h
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
 #ifndef MAPPACKETEXTRACTION_H_
 #define MAPPACKETEXTRACTION_H_
 
@@ -20,6 +13,7 @@ class StorageManagerIF;
  * The class implements the full MAP Packet Extraction functionality as described in the CCSDS
  * TC Space Data Link Protocol. It internally stores incomplete segmented packets until they are
  * fully received. All found packets are forwarded to a single distribution entity.
+ * @author B. Baetz
  */
 class MapPacketExtraction: public MapPacketExtractionIF {
 private:

From f7f062570e63a249eea95d51312b0dbb0dd104d3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 13:21:44 +0100
Subject: [PATCH 1089/1774] new internal error reporter using local pools

---
 internalError/InternalErrorDataset.h    |  34 +++++++
 internalError/InternalErrorReporter.cpp | 127 ++++++++++++++++++------
 internalError/InternalErrorReporter.h   |  66 +++++++++---
 3 files changed, 182 insertions(+), 45 deletions(-)
 create mode 100644 internalError/InternalErrorDataset.h

diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
new file mode 100644
index 000000000..fa91116d4
--- /dev/null
+++ b/internalError/InternalErrorDataset.h
@@ -0,0 +1,34 @@
+#ifndef FSFW_INTERNALERROR_INTERNALERRORDATASET_H_
+#define FSFW_INTERNALERROR_INTERNALERRORDATASET_H_
+
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+
+enum errorPoolIds {
+    TM_HITS,
+    QUEUE_HITS,
+    STORE_HITS
+};
+
+
+class InternalErrorDataset: public StaticLocalDataSet<3 * sizeof(uint32_t)> {
+public:
+    static constexpr uint8_t ERROR_SET_ID = 0;
+
+    InternalErrorDataset(HasLocalDataPoolIF* owner):
+            StaticLocalDataSet(owner, ERROR_SET_ID) {}
+
+    InternalErrorDataset(object_id_t objectId):
+           StaticLocalDataSet(sid_t(objectId , ERROR_SET_ID)) {}
+
+    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    		TM_HITS, this);
+    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    		QUEUE_HITS, this);
+    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    		STORE_HITS, this);
+};
+
+
+
+#endif /* FSFW_INTERNALERROR_INTERNALERRORDATASET_H_ */
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 861e1595e..8d5c792b8 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,17 +1,17 @@
 #include "InternalErrorReporter.h"
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PoolVariable.h"
+#include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
-
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
-		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
-		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId), tmPoolId(
-				tmPoolId), storePoolId(
-				storePoolId), queueHits(0), tmHits(0), storeHits(
-				0) {
+        uint32_t messageQueueDepth) :
+		SystemObject(setObjectId),
+		commandQueue(QueueFactory::instance()->
+		        createMessageQueue(messageQueueDepth)),
+		poolManager(this, commandQueue),
+		internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
+		internalErrorDataset(this) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
@@ -19,28 +19,42 @@ InternalErrorReporter::~InternalErrorReporter() {
 	MutexFactory::instance()->deleteMutex(mutex);
 }
 
+void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
+    this->diagnosticPrintout = enable;
+}
+
 ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
-
-	DataSet mySet;
-	PoolVariable<uint32_t> queueHitsInPool(queuePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	PoolVariable<uint32_t> tmHitsInPool(tmPoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-
-	PoolVariable<uint32_t> storeHitsInPool(storePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
+    internalErrorDataset.read(INTERNAL_ERROR_MUTEX_TIMEOUT);
 
 	uint32_t newQueueHits = getAndResetQueueHits();
 	uint32_t newTmHits = getAndResetTmHits();
 	uint32_t newStoreHits = getAndResetStoreHits();
 
-	queueHitsInPool.value += newQueueHits;
-	tmHitsInPool.value += newTmHits;
-	storeHitsInPool.value += newStoreHits;
+#ifdef DEBUG
+	if(diagnosticPrintout) {
+	    if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
+	        sif::debug << "InternalErrorReporter::performOperation: Errors "
+	                << "occured!" << std::endl;
+	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
+	        sif::debug << "TM errors: " << newTmHits << std::endl;
+	        sif::debug << "Store errors: " << newStoreHits << std::endl;
+	    }
+	}
+#endif
 
-	mySet.commit(PoolVariableIF::VALID);
+	internalErrorDataset.queueHits.value += newQueueHits;
+	internalErrorDataset.storeHits.value += newStoreHits;
+	internalErrorDataset.tmHits.value += newTmHits;
 
+	internalErrorDataset.commit(INTERNAL_ERROR_MUTEX_TIMEOUT);
+
+	poolManager.performHkOperation();
+
+	CommandMessage message;
+	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	if(result != MessageQueueIF::EMPTY) {
+	    poolManager.handleHousekeepingMessage(&message);
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -54,7 +68,7 @@ void InternalErrorReporter::lostTm() {
 
 uint32_t InternalErrorReporter::getAndResetQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = queueHits;
 	queueHits = 0;
 	mutex->unlockMutex();
@@ -63,21 +77,21 @@ uint32_t InternalErrorReporter::getAndResetQueueHits() {
 
 uint32_t InternalErrorReporter::getQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = queueHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	queueHits++;
 	mutex->unlockMutex();
 }
 
 uint32_t InternalErrorReporter::getAndResetTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = tmHits;
 	tmHits = 0;
 	mutex->unlockMutex();
@@ -86,14 +100,14 @@ uint32_t InternalErrorReporter::getAndResetTmHits() {
 
 uint32_t InternalErrorReporter::getTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = tmHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	tmHits++;
 	mutex->unlockMutex();
 }
@@ -104,7 +118,7 @@ void InternalErrorReporter::storeFull() {
 
 uint32_t InternalErrorReporter::getAndResetStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = storeHits;
 	storeHits = 0;
 	mutex->unlockMutex();
@@ -113,14 +127,65 @@ uint32_t InternalErrorReporter::getAndResetStoreHits() {
 
 uint32_t InternalErrorReporter::getStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = storeHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	storeHits++;
 	mutex->unlockMutex();
 }
+
+object_id_t InternalErrorReporter::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
+    return this->commandQueue->getId();
+}
+
+ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
+        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+    localDataPoolMap.emplace(errorPoolIds::TM_HITS,
+            new PoolEntry<uint32_t>());
+    localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS,
+            new PoolEntry<uint32_t>());
+    localDataPoolMap.emplace(errorPoolIds::STORE_HITS,
+            new PoolEntry<uint32_t>());
+    poolManager.subscribeForPeriodicPacket(internalErrorSid, false,
+            getPeriodicOperationFrequency(), true);
+    internalErrorDataset.setValidity(true, true);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() {
+    return &poolManager;
+}
+
+dur_millis_t InternalErrorReporter::getPeriodicOperationFrequency() const {
+    return this->executingTask->getPeriodMs();
+}
+
+LocalPoolDataSetBase* InternalErrorReporter::getDataSetHandle(sid_t sid) {
+    return &internalErrorDataset;
+}
+
+void InternalErrorReporter::setTaskIF(PeriodicTaskIF *task) {
+    this->executingTask = task;
+}
+
+ReturnValue_t InternalErrorReporter::initialize() {
+    ReturnValue_t result = poolManager.initialize(commandQueue);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return SystemObject::initialize();
+}
+
+ReturnValue_t InternalErrorReporter::initializeAfterTaskCreation() {
+    return poolManager.initializeAfterTaskCreation();
+}
+
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 9aa24a0fa..8d33c06e2 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -1,37 +1,75 @@
-#ifndef INTERNALERRORREPORTER_H_
-#define INTERNALERRORREPORTER_H_
+#ifndef FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_
+#define FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_
 
 #include "InternalErrorReporterIF.h"
 
+#include "../tasks/PeriodicTaskIF.h"
+#include "../internalError/InternalErrorDataset.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../ipc/MutexIF.h"
 
+/**
+ * @brief   This class is used to track internal errors like lost telemetry,
+ *          failed message sending or a full store.
+ * @details
+ * All functions were kept virtual so this class can be extended easily
+ * to store custom internal errors (e.g. communication interface errors).
+ */
 class InternalErrorReporter: public SystemObject,
 		public ExecutableObjectIF,
-		public InternalErrorReporterIF {
+		public InternalErrorReporterIF,
+		public HasLocalDataPoolIF {
 public:
-	InternalErrorReporter(object_id_t setObjectId, uint32_t queuePoolId,
-			uint32_t tmPoolId, uint32_t storePoolId);
+    static constexpr uint8_t INTERNAL_ERROR_MUTEX_TIMEOUT = 20;
+
+	InternalErrorReporter(object_id_t setObjectId,
+	        uint32_t messageQueueDepth = 5);
+
+	/**
+	 * Enable diagnostic printout. Please note that this feature will
+	 * only work if DEBUG has been supplied to the build defines.
+	 * @param enable
+	 */
+	void setDiagnosticPrintout(bool enable);
+
 	virtual ~InternalErrorReporter();
 
-	virtual ReturnValue_t performOperation(uint8_t opCode);
+    virtual object_id_t getObjectId() const override;
+    virtual MessageQueueId_t getCommandQueue() const override;
+    virtual ReturnValue_t initializeLocalDataPool(
+            LocalDataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override;
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
+    virtual dur_millis_t getPeriodicOperationFrequency() const override;
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+
+    virtual ReturnValue_t initialize() override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
 	virtual void queueMessageNotSent();
 
 	virtual void lostTm();
 
 	virtual void storeFull();
+
+	virtual void setTaskIF(PeriodicTaskIF* task) override;
 protected:
-	MutexIF* mutex;
+	MessageQueueIF* commandQueue;
+	LocalDataPoolManager poolManager;
 
-	uint32_t queuePoolId;
-	uint32_t tmPoolId;
-	uint32_t storePoolId;
+	PeriodicTaskIF* executingTask = nullptr;
+	MutexIF* mutex = nullptr;
+	sid_t internalErrorSid;
+	InternalErrorDataset internalErrorDataset;
 
-	uint32_t queueHits;
-	uint32_t tmHits;
-	uint32_t storeHits;
+	bool diagnosticPrintout = true;
+
+	uint32_t queueHits = 0;
+	uint32_t tmHits = 0;
+	uint32_t storeHits = 0;
 
 	uint32_t getAndResetQueueHits();
 	uint32_t getQueueHits();
@@ -47,4 +85,4 @@ protected:
 
 };
 
-#endif /* INTERNALERRORREPORTER_H_ */
+#endif /* FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_ */

From c6db9944fd57d934fed5a54f0816feeea346ebf1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 13:26:50 +0100
Subject: [PATCH 1090/1774] changelog update

---
 CHANGELOG | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index a6686478c..b8f589f88 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -11,3 +11,10 @@ a C file without issues
 - It is now possible to change the message queue depth for the telecommand verification service (PUS1)
 - The same is possible for the event reporting service (PUS5)
 - PUS Health Service added, which allows to command and retrieve health via PUS packets
+
+### Internal Error Reporter
+
+- The new internal error reporter uses the local data pools. The pool IDs for
+the exisiting three error values and the new error set will be hardcoded for
+now, the the constructor for the internal error reporter just takes an object
+ID for now.

From b7a29235f876fa60d783654ebfb449799451948d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 13:28:56 +0100
Subject: [PATCH 1091/1774] deleted memory proxy file

---
 memory/MemoryProxyIF.h | 22 ----------------------
 1 file changed, 22 deletions(-)
 delete mode 100644 memory/MemoryProxyIF.h

diff --git a/memory/MemoryProxyIF.h b/memory/MemoryProxyIF.h
deleted file mode 100644
index 31045d3f9..000000000
--- a/memory/MemoryProxyIF.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-
-#include "../memory/AcceptsMemoryMessagesIF.h"
-
-/**
- * This was a nice idea to transparently forward incoming messages to another object.
- * But it doesn't work like that.
- */
-class MemoryProxyIF : public AcceptsMemoryMessagesIF {
-public:
-	virtual MessageQueueId_t getProxyQueue() const = 0;
-	MessageQueueId_t getCommandQueue() const {
-		return getProxyQueue();
-	}
-	virtual ~MemoryProxyIF() {}
-
-};
-
-
-
-#endif /* FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ */

From 03aacea4ddd5f0ab293dd319ddad2860c99cd6aa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 14:44:11 +0100
Subject: [PATCH 1092/1774] fixed unittest

---
 unittest/core/CatchFactory.cpp                |  60 ++++
 .../objects/Factory.h => core/CatchFactory.h} |   0
 unittest/core/CatchSetup.cpp                  |   3 +-
 unittest/testcfg/objects/Factory.cpp          |  34 ---
 unittest/tests/action/TestActionHelper.cpp    | 213 +++++++-------
 unittest/tests/action/TestActionHelper.h      | 263 +++++++++---------
 6 files changed, 300 insertions(+), 273 deletions(-)
 create mode 100644 unittest/core/CatchFactory.cpp
 rename unittest/{testcfg/objects/Factory.h => core/CatchFactory.h} (100%)
 delete mode 100644 unittest/testcfg/objects/Factory.cpp

diff --git a/unittest/core/CatchFactory.cpp b/unittest/core/CatchFactory.cpp
new file mode 100644
index 000000000..cf10e94af
--- /dev/null
+++ b/unittest/core/CatchFactory.cpp
@@ -0,0 +1,60 @@
+#include "CatchFactory.h"
+
+#include "../../events/EventManager.h"
+#include "../../health/HealthTable.h"
+
+#include "../../internalError/InternalErrorReporter.h"
+#include "../../objectmanager/frameworkObjects.h"
+#include "../../storagemanager/PoolManager.h"
+
+/**
+ * @brief Produces system objects.
+ * @details
+ * Build tasks by using SystemObject Interface (Interface).
+ * Header files of all tasks must be included
+ * Please note that an object has to implement the system object interface
+ * if the interface validity is checked or retrieved later by using the
+ * get<TargetInterface>(object_id) function from the ObjectManagerIF.
+ *
+ * Framework objects are created first.
+ *
+ * @ingroup init
+ */
+void Factory::produce(void) {
+	setStaticFrameworkObjectIds();
+	new EventManager(objects::EVENT_MANAGER);
+	new HealthTable(objects::HEALTH_TABLE);
+	//new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+
+	{
+		static constexpr uint8_t NUMBER_OF_POOLS = 5;
+		const uint16_t element_sizes[NUMBER_OF_POOLS] = {16, 32, 64, 128, 1024};
+		const uint16_t n_elements[NUMBER_OF_POOLS] = {100, 50, 25, 15, 5};
+		new PoolManager<NUMBER_OF_POOLS>(objects::TC_STORE, element_sizes,
+				n_elements);
+	}
+
+	{
+		static constexpr uint8_t NUMBER_OF_POOLS = 5;
+		const uint16_t element_sizes[NUMBER_OF_POOLS] = {16, 32, 64, 128, 1024};
+		const uint16_t n_elements[NUMBER_OF_POOLS] = {100, 50, 25, 15, 5};
+		new PoolManager<NUMBER_OF_POOLS>(objects::TM_STORE, element_sizes,
+				n_elements);
+	}
+
+	{
+		static constexpr uint8_t NUMBER_OF_POOLS = 6;
+		const uint16_t element_sizes[NUMBER_OF_POOLS] = {32, 64, 512,
+				1024, 2048, 4096};
+		const uint16_t n_elements[NUMBER_OF_POOLS] = {200, 100, 50, 25, 15, 5};
+		new PoolManager<NUMBER_OF_POOLS>(objects::IPC_STORE, element_sizes,
+				n_elements);
+	}
+
+}
+
+void Factory::setStaticFrameworkObjectIds() {
+
+}
+
+
diff --git a/unittest/testcfg/objects/Factory.h b/unittest/core/CatchFactory.h
similarity index 100%
rename from unittest/testcfg/objects/Factory.h
rename to unittest/core/CatchFactory.h
diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index f8543fd2a..cb5bd33ed 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,8 +1,7 @@
 #include "CatchDefinitions.h"
+#include "CatchFactory.h"
 
 #include <testcfg/cdatapool/dataPoolInit.h>
-#include <testcfg/objects/Factory.h>
-
 
 #ifdef GCOV
 #include <gcov.h>
diff --git a/unittest/testcfg/objects/Factory.cpp b/unittest/testcfg/objects/Factory.cpp
deleted file mode 100644
index e05b7942e..000000000
--- a/unittest/testcfg/objects/Factory.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "Factory.h"
-
-#include <fsfw/events/EventManager.h>
-#include <fsfw/health/HealthTable.h>
-
-#include <fsfw/internalError/InternalErrorReporter.h>
-#include <fsfw/objectmanager/frameworkObjects.h>
-
-/**
- * @brief Produces system objects.
- * @details
- * Build tasks by using SystemObject Interface (Interface).
- * Header files of all tasks must be included
- * Please note that an object has to implement the system object interface
- * if the interface validity is checked or retrieved later by using the
- * get<TargetInterface>(object_id) function from the ObjectManagerIF.
- *
- * Framework objects are created first.
- *
- * @ingroup init
- */
-void Factory::produce(void) {
-	setStaticFrameworkObjectIds();
-	new EventManager(objects::EVENT_MANAGER);
-	new HealthTable(objects::HEALTH_TABLE);
-	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
-
-}
-
-void Factory::setStaticFrameworkObjectIds() {
-
-}
-
-
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index d5b2e467b..944ad7059 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -1,106 +1,107 @@
-//#include "TestActionHelper.h"
-//#include <fsfw/action/ActionHelper.h>
-//#include <fsfw/ipc/CommandMessage.h>
-//#include <catch2/catch.hpp>
-//#include "../../core/CatchDefinitions.h"
-//
-//
-//TEST_CASE( "Action Helper" , "[ActionHelper]") {
-//	ActionHelperOwnerMockBase testDhMock;
-//	MessageQueueMockBase testMqMock;
-//	ActionHelper actionHelper = ActionHelper(
-//			&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
-//	CommandMessage actionMessage;
-//	ActionId_t testActionId = 777;
-//	std::array <uint8_t, 3> testParams {1, 2, 3};
-//	store_address_t paramAddress;
-//	StorageManagerIF *ipcStore = tglob::getIpcStoreHandle();
-//	ipcStore->addData(&paramAddress, testParams.data(), 3);
-//	REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
-//
-//	SECTION ("Simple tests") {
-//		 ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
-//		 CHECK(not testDhMock.executeActionCalled);
-//		 REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-//		 CHECK(testDhMock.executeActionCalled);
-//		 // No message is sent if everything is alright.
-//		 CHECK(not testMqMock.wasMessageSent());
-//		 store_address_t invalidAddress;
-//		 ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
-//		 actionHelper.handleActionMessage(&actionMessage);
-//		 CHECK(testMqMock.wasMessageSent());
-//		 const uint8_t* ptr = nullptr;
-//		 size_t size = 0;
-//		 REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
-//		 REQUIRE(ptr == nullptr);
-//		 REQUIRE(size == 0);
-//		 testDhMock.getBuffer(&ptr, &size);
-//		 REQUIRE(size == 3);
-//		 for(uint8_t i = 0; i<3;i++){
-//			 REQUIRE(ptr[i] == (i+1));
-//		 }
-//		 testDhMock.clearBuffer();
-//	}
-//
-//	SECTION("Handle failures"){
-//		actionMessage.setCommand(1234);
-//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
-//		CHECK(not testMqMock.wasMessageSent());
-//		uint16_t step = 5;
-//		ReturnValue_t status = 0x1234;
-//		actionHelper.step(step, testMqMock.getId(), testActionId, status);
-//		step += 1;
-//		CHECK(testMqMock.wasMessageSent());
-//		CommandMessage testMessage;
-//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-//		REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
-//		uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
-//		REQUIRE(testMessage.getParameter2() == parameter2);
-//		REQUIRE(ActionMessage::getStep(&testMessage) == step);
-//	}
-//
-//	SECTION("Handle finish"){
-//		CHECK(not testMqMock.wasMessageSent());
-//		ReturnValue_t status = 0x9876;
-//		actionHelper.finish(testMqMock.getId(), testActionId, status);
-//		CHECK(testMqMock.wasMessageSent());
-//		CommandMessage testMessage;
-//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
-//		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
-//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
-//	}
-//
-//	SECTION("Handle failed"){
-//		store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
-//		std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
-//		REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
-//		ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
-//		CHECK(not testDhMock.executeActionCalled);
-//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-//		REQUIRE(ipcStore->getData(toLongParamAddress).first == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
-//		CommandMessage testMessage;
-//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
-//		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
-//		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
-//	}
-//
-//	SECTION("Missing IPC Data"){
-//		ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
-//		CHECK(not testDhMock.executeActionCalled);
-//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-//		CommandMessage testMessage;
-//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
-//		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
-//	}
-//
-//
-//	SECTION("Data Reply"){
-//
-//	}
-//}
+#include "TestActionHelper.h"
+#include <fsfw/action/ActionHelper.h>
+#include <fsfw/ipc/CommandMessage.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
+
+
+TEST_CASE( "Action Helper" , "[ActionHelper]") {
+	ActionHelperOwnerMockBase testDhMock;
+	MessageQueueMockBase testMqMock;
+	ActionHelper actionHelper = ActionHelper(
+			&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
+	CommandMessage actionMessage;
+	ActionId_t testActionId = 777;
+	std::array <uint8_t, 3> testParams {1, 2, 3};
+	store_address_t paramAddress;
+	StorageManagerIF *ipcStore = tglob::getIpcStoreHandle();
+	REQUIRE(ipcStore != nullptr);
+	ipcStore->addData(&paramAddress, testParams.data(), 3);
+	REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
+
+	SECTION ("Simple tests") {
+		 ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
+		 CHECK(not testDhMock.executeActionCalled);
+		 REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		 CHECK(testDhMock.executeActionCalled);
+		 // No message is sent if everything is alright.
+		 CHECK(not testMqMock.wasMessageSent());
+		 store_address_t invalidAddress;
+		 ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
+		 actionHelper.handleActionMessage(&actionMessage);
+		 CHECK(testMqMock.wasMessageSent());
+		 const uint8_t* ptr = nullptr;
+		 size_t size = 0;
+		 REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+		 REQUIRE(ptr == nullptr);
+		 REQUIRE(size == 0);
+		 testDhMock.getBuffer(&ptr, &size);
+		 REQUIRE(size == 3);
+		 for(uint8_t i = 0; i<3;i++){
+			 REQUIRE(ptr[i] == (i+1));
+		 }
+		 testDhMock.clearBuffer();
+	}
+
+	SECTION("Handle failures"){
+		actionMessage.setCommand(1234);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
+		CHECK(not testMqMock.wasMessageSent());
+		uint16_t step = 5;
+		ReturnValue_t status = 0x1234;
+		actionHelper.step(step, testMqMock.getId(), testActionId, status);
+		step += 1;
+		CHECK(testMqMock.wasMessageSent());
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
+		uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
+		REQUIRE(testMessage.getParameter2() == parameter2);
+		REQUIRE(ActionMessage::getStep(&testMessage) == step);
+	}
+
+	SECTION("Handle finish"){
+		CHECK(not testMqMock.wasMessageSent());
+		ReturnValue_t status = 0x9876;
+		actionHelper.finish(testMqMock.getId(), testActionId, status);
+		CHECK(testMqMock.wasMessageSent());
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
+		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
+	}
+
+	SECTION("Handle failed"){
+		store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
+		std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
+		REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
+		ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
+		CHECK(not testDhMock.executeActionCalled);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		REQUIRE(ipcStore->getData(toLongParamAddress).first == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
+		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+	}
+
+	SECTION("Missing IPC Data"){
+		ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
+		CHECK(not testDhMock.executeActionCalled);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
+		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+	}
+
+
+	SECTION("Data Reply"){
+
+	}
+}
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
index 9bc93d3e1..4ba417eb1 100644
--- a/unittest/tests/action/TestActionHelper.h
+++ b/unittest/tests/action/TestActionHelper.h
@@ -1,131 +1,132 @@
-//#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
-//#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
-//
-//#include <fsfw/action/HasActionsIF.h>
-//#include <fsfw/ipc/MessageQueueIF.h>
-//#include <fsfw/unittest/core/CatchDefinitions.h>
-//#include <cstring>
-//
-//
-//class ActionHelperOwnerMockBase: public HasActionsIF {
-//public:
-//	bool getCommandQueueCalled = false;
-//	bool executeActionCalled = false;
-//	static const size_t MAX_SIZE = 3;
-//	uint8_t buffer[MAX_SIZE] = {0, 0, 0};
-//	size_t size = 0;
-//
-//	MessageQueueId_t getCommandQueue() const override {
-//		return tconst::testQueueId;
-//	}
-//
-//	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-//			const uint8_t* data, size_t size) override {
-//		executeActionCalled = true;
-//		if(size > MAX_SIZE){
-//			return 0xAFFE;
-//		}
-//		this->size = size;
-//		memcpy(buffer, data, size);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//
-//	void clearBuffer(){
-//		this->size = 0;
-//		for(size_t i = 0; i<MAX_SIZE; i++){
-//			buffer[i] = 0;
-//		}
-//	}
-//
-//	void getBuffer(const uint8_t** ptr, size_t* size){
-//		if(size != nullptr){
-//			*size = this->size;
-//		}
-//		if(ptr != nullptr){
-//			*ptr = buffer;
-//		}
-//	}
-//};
-//
-//
-//class MessageQueueMockBase: public MessageQueueIF {
-//public:
-//	MessageQueueId_t myQueueId = 0;
-//	bool defaultDestSet = false;
-//	bool messageSent = false;
-//
-//
-//
-//	bool wasMessageSent() {
-//		bool tempMessageSent = messageSent;
-//		messageSent = false;
-//		return tempMessageSent;
-//	}
-//
-//	virtual ReturnValue_t reply( MessageQueueMessage* message ) {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	};
-//	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message,
-//			MessageQueueId_t *receivedFrom) {
-//		(*message) = lastMessage;
-//		lastMessage.clear();
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) {
-//		(*message) = lastMessage;
-//		lastMessage.clear();
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t flush(uint32_t* count) {
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual MessageQueueId_t getLastPartner() const {
-//		return tconst::testQueueId;
-//	}
-//	virtual MessageQueueId_t getId() const {
-//		return tconst::testQueueId;
-//	}
-//	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-//			MessageQueueMessage* message, MessageQueueId_t sentFrom,
-//			bool ignoreFault = false ) {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-//			MessageQueueMessage* message, bool ignoreFault = false ) override {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
-//			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message ) {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
-//		myQueueId = defaultDestination;
-//		defaultDestSet = true;
-//	}
-//
-//	virtual MessageQueueId_t getDefaultDestination() const {
-//		return myQueueId;
-//	}
-//	virtual bool isDefaultDestinationSet() const {
-//		return defaultDestSet;
-//	}
-//private:
-//	MessageQueueMessage lastMessage;
-//
-//};
-//
-//
-//#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
+#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
+#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
+
+#include <fsfw/action/HasActionsIF.h>
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <cstring>
+
+
+class ActionHelperOwnerMockBase: public HasActionsIF {
+public:
+	bool getCommandQueueCalled = false;
+	bool executeActionCalled = false;
+	static const size_t MAX_SIZE = 3;
+	uint8_t buffer[MAX_SIZE] = {0, 0, 0};
+	size_t size = 0;
+
+	MessageQueueId_t getCommandQueue() const override {
+		return tconst::testQueueId;
+	}
+
+	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+			const uint8_t* data, size_t size) override {
+		executeActionCalled = true;
+		if(size > MAX_SIZE){
+			return 0xAFFE;
+		}
+		this->size = size;
+		memcpy(buffer, data, size);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	void clearBuffer(){
+		this->size = 0;
+		for(size_t i = 0; i<MAX_SIZE; i++){
+			buffer[i] = 0;
+		}
+	}
+
+	void getBuffer(const uint8_t** ptr, size_t* size){
+		if(size != nullptr){
+			*size = this->size;
+		}
+		if(ptr != nullptr){
+			*ptr = buffer;
+		}
+	}
+};
+
+
+class MessageQueueMockBase: public MessageQueueIF {
+public:
+	MessageQueueId_t myQueueId = 0;
+	bool defaultDestSet = false;
+	bool messageSent = false;
+
+
+
+	bool wasMessageSent() {
+		bool tempMessageSent = messageSent;
+		messageSent = false;
+		return tempMessageSent;
+	}
+
+	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	};
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) {
+		(*message) = lastMessage;
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
+		memcpy(message->getBuffer(), lastMessage.getBuffer(),
+				message->getMessageSize());
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t flush(uint32_t* count) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual MessageQueueId_t getLastPartner() const {
+		return tconst::testQueueId;
+	}
+	virtual MessageQueueId_t getId() const {
+		return tconst::testQueueId;
+	}
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+		myQueueId = defaultDestination;
+		defaultDestSet = true;
+	}
+
+	virtual MessageQueueId_t getDefaultDestination() const {
+		return myQueueId;
+	}
+	virtual bool isDefaultDestinationSet() const {
+		return defaultDestSet;
+	}
+private:
+	MessageQueueMessage lastMessage;
+
+};
+
+
+#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */

From 9781105ad0378ee66d14d93c5994f01602a091ae Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 14:50:28 +0100
Subject: [PATCH 1093/1774] moved catch factory again

---
 unittest/{core => testcfg}/CatchFactory.cpp | 10 +++++-----
 unittest/{core => testcfg}/CatchFactory.h   |  0
 unittest/testcfg/testcfg.mk                 |  1 +
 3 files changed, 6 insertions(+), 5 deletions(-)
 rename unittest/{core => testcfg}/CatchFactory.cpp (87%)
 rename unittest/{core => testcfg}/CatchFactory.h (100%)

diff --git a/unittest/core/CatchFactory.cpp b/unittest/testcfg/CatchFactory.cpp
similarity index 87%
rename from unittest/core/CatchFactory.cpp
rename to unittest/testcfg/CatchFactory.cpp
index cf10e94af..c74a8126d 100644
--- a/unittest/core/CatchFactory.cpp
+++ b/unittest/testcfg/CatchFactory.cpp
@@ -1,11 +1,11 @@
 #include "CatchFactory.h"
 
-#include "../../events/EventManager.h"
-#include "../../health/HealthTable.h"
+#include <fsfw/events/EventManager.h>
+#include <fsfw/health/HealthTable.h>
 
-#include "../../internalError/InternalErrorReporter.h"
-#include "../../objectmanager/frameworkObjects.h"
-#include "../../storagemanager/PoolManager.h"
+#include <fsfw/internalError/InternalErrorReporter.h>
+#include <fsfw/objectmanager/frameworkObjects.h>
+#include <fsfw/storagemanager/PoolManager.h>
 
 /**
  * @brief Produces system objects.
diff --git a/unittest/core/CatchFactory.h b/unittest/testcfg/CatchFactory.h
similarity index 100%
rename from unittest/core/CatchFactory.h
rename to unittest/testcfg/CatchFactory.h
diff --git a/unittest/testcfg/testcfg.mk b/unittest/testcfg/testcfg.mk
index 64fa87f65..31d3b60a5 100644
--- a/unittest/testcfg/testcfg.mk
+++ b/unittest/testcfg/testcfg.mk
@@ -3,6 +3,7 @@ CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
 
 INCLUDES += $(CURRENTPATH)
 INCLUDES += $(CURRENTPATH)/objects

From ec3c83bcc1e9cbf587b4602fa3d65d9f797c781e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 18:24:51 +0100
Subject: [PATCH 1094/1774] monitoring update

---
 monitoring/AbsLimitMonitor.h          | 28 +++++++-----
 monitoring/HasMonitorsIF.h            | 12 ++---
 monitoring/LimitMonitor.h             | 27 ++++++-----
 monitoring/MonitorBase.h              | 64 +++++++++++++++++----------
 monitoring/MonitorReporter.h          | 37 +++++++++-------
 monitoring/MonitoringIF.h             |  8 ++--
 monitoring/MonitoringMessageContent.h | 37 ++++++++++------
 monitoring/TriplexMonitor.h           |  2 +-
 8 files changed, 127 insertions(+), 88 deletions(-)

diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index 2e60f6f8c..5feb369c0 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
+#ifndef FSFW_MONITORING_ABSLIMITMONITOR_H_
+#define FSFW_MONITORING_ABSLIMITMONITOR_H_
 
 #include "MonitorBase.h"
 #include <cmath>
@@ -7,9 +7,14 @@
 template<typename T>
 class AbsLimitMonitor: public MonitorBase<T> {
 public:
-	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
-			uint16_t confirmationLimit, T limit, Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE, bool aboveIsViolation = true) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), limit(limit), violationEvent(violationEvent), aboveIsViolation(aboveIsViolation) {
+	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId,
+	        gp_id_t globalPoolId, uint16_t confirmationLimit, T limit,
+	        Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE,
+	        bool aboveIsViolation = true) :
+			MonitorBase<T>(reporterId, monitorId, globalPoolId,
+					confirmationLimit),
+			limit(limit), violationEvent(violationEvent),
+			aboveIsViolation(aboveIsViolation) {
 	}
 	virtual ~AbsLimitMonitor() {
 	}
@@ -32,8 +37,9 @@ public:
 			const ParameterWrapper *newValues, uint16_t startAtIndex) {
 		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
 				parameterId, parameterWrapper, newValues, startAtIndex);
-		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
+		// We'll reuse the DOMAIN_ID of MonitorReporter,
+		// as we know the parameterIds used there.
+		if (result != this->INVALID_IDENTIFIER_ID) {
 			return result;
 		}
 		switch (parameterId) {
@@ -41,7 +47,7 @@ public:
 			parameterWrapper->set(this->limit);
 			break;
 		default:
-			return this->INVALID_MATRIX_ID;
+			return this->INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -59,7 +65,9 @@ protected:
 	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
 		switch (state) {
 		case MonitoringIF::OUT_OF_RANGE:
-			EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->parameterId);
+			EventManagerIF::triggerEvent(this->reportingId,
+			        violationEvent, this->globalPoolId.objectId,
+					this->globalPoolId.localPoolId);
 			break;
 		default:
 			break;
@@ -70,4 +78,4 @@ protected:
 	const bool aboveIsViolation;
 };
 
-#endif /* FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ */
+#endif /* FSFW_MONITORING_ABSLIMITMONITOR_H_ */
diff --git a/monitoring/HasMonitorsIF.h b/monitoring/HasMonitorsIF.h
index 85d92b6b9..04f634374 100644
--- a/monitoring/HasMonitorsIF.h
+++ b/monitoring/HasMonitorsIF.h
@@ -1,11 +1,5 @@
-/**
- * @file	HasMonitorsIF.h
- * @brief	This file defines the HasMonitorsIF class.
- * @date	28.07.2014
- * @author	baetz
- */
-#ifndef HASMONITORSIF_H_
-#define HASMONITORSIF_H_
+#ifndef FSFW_MONITORING_HASMONITORSIF_H_
+#define FSFW_MONITORING_HASMONITORSIF_H_
 
 #include "../events/EventReportingProxyIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
@@ -27,4 +21,4 @@ public:
 	}
 };
 
-#endif /* HASMONITORSIF_H_ */
+#endif /* FSFW_MONITORING_HASMONITORSIF_H_ */
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index 66e6725e8..c4448ceda 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -12,13 +12,15 @@
 template<typename T>
 class LimitMonitor: public MonitorBase<T> {
 public:
-	LimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
-			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
-			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
+	LimitMonitor(object_id_t reporterId, uint8_t monitorId,
+	        gp_id_t globalPoolId, uint16_t confirmationLimit, T lowerLimit,
+			T upperLimit, Event belowLowEvent =
+					MonitoringIF::VALUE_BELOW_LOW_LIMIT,
 			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), lowerLimit(
-					lowerLimit), upperLimit(upperLimit), belowLowEvent(
-					belowLowEvent), aboveHighEvent(aboveHighEvent) {
+			MonitorBase<T>(reporterId, monitorId, globalPoolId,
+			        confirmationLimit),
+			lowerLimit(lowerLimit), upperLimit(upperLimit),
+			belowLowEvent(belowLowEvent), aboveHighEvent(aboveHighEvent) {
 	}
 	virtual ~LimitMonitor() {
 	}
@@ -41,7 +43,7 @@ public:
 		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
 				parameterId, parameterWrapper, newValues, startAtIndex);
 		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
+		if (result != this->INVALID_IDENTIFIER_ID) {
 			return result;
 		}
 		switch (parameterId) {
@@ -52,12 +54,13 @@ public:
 			parameterWrapper->set(this->upperLimit);
 			break;
 		default:
-			return this->INVALID_MATRIX_ID;
+			return this->INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	bool isOutOfLimits() {
-		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT || this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
+		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT or
+		        this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
 			return true;
 		} else {
 			return false;
@@ -76,10 +79,12 @@ protected:
 	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
 		switch (state) {
 		case MonitoringIF::BELOW_LOW_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent, this->parameterId);
+			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent,
+			        this->globalPoolId.objectId, this->globalPoolId.localPoolId);
 			break;
 		case MonitoringIF::ABOVE_HIGH_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent, this->parameterId);
+			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent,
+			        this->globalPoolId.objectId, this->globalPoolId.localPoolId);
 			break;
 		default:
 			break;
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index b2d0e6cbb..530a38409 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,39 +1,50 @@
-#ifndef MONITORBASE_H_
-#define MONITORBASE_H_
+#ifndef FSFW_MONITORING_MONITORBASE_H_
+#define FSFW_MONITORING_MONITORBASE_H_
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PIDReader.h"
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
 #include "MonitorReporter.h"
 
+#include "../datapoollocal/LocalPoolVariable.h"
+
+
 /**
- * Base class for monitoring of parameters.
- * Can be used anywhere, specializations need to implement checkSample and should override sendTransitionEvent.
- * Manages state handling, enabling and disabling of events/reports and forwarding of transition
- * reports via MonitorReporter. In addition, it provides default implementations for fetching the parameter sample from
- * the data pool and a simple confirmation counter.
+ * @brief   Base class for monitoring of parameters.
+ * @details
+ * Can be used anywhere, specializations need to implement checkSample and
+ * should override sendTransitionEvent.
+ * Manages state handling, enabling and disabling of events/reports and
+ * forwarding of transition reports via MonitorReporter.
+ *
+ * In addition, it provides default implementations for fetching the
+ * parameter sample from the data pool and a simple confirmation counter.
  */
 template<typename T>
 class MonitorBase: public MonitorReporter<T> {
 public:
+
 	MonitorBase(object_id_t reporterId, uint8_t monitorId,
-			uint32_t parameterId, uint16_t confirmationLimit) :
-			MonitorReporter<T>(reporterId, monitorId, parameterId, confirmationLimit) {
+	        gp_id_t globalPoolId, uint16_t confirmationLimit):
+	        MonitorReporter<T>(reporterId, monitorId, globalPoolId,
+	                confirmationLimit),
+	        poolVariable(globalPoolId) {
 	}
+
 	virtual ~MonitorBase() {
 	}
+
 	virtual ReturnValue_t check() {
-		//1. Fetch sample of type T, return validity.
+		// 1. Fetch sample of type T, return validity.
 		T sample = 0;
 		ReturnValue_t validity = fetchSample(&sample);
 
-		//2. If returning from fetch != OK, parameter is invalid. Report (if oldState is != invalidity).
+		// 2. If returning from fetch != OK, parameter is invalid.
+		// Report (if oldState is != invalidity).
 		if (validity != HasReturnvaluesIF::RETURN_OK) {
 			this->monitorStateIs(validity, sample, 0);
-			//3. Otherwise, check sample.
 		} else {
+            //3. Otherwise, check sample.
 			this->oldState = doCheck(sample);
 		}
 		return this->oldState;
@@ -43,20 +54,25 @@ public:
 		ReturnValue_t currentState = checkSample(sample, &crossedLimit);
 		return this->monitorStateIs(currentState,sample, crossedLimit);
 	}
-	//Abstract or default.
+
+	// Abstract or default.
 	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
 
 protected:
+
 	virtual ReturnValue_t fetchSample(T* sample) {
-		DataSet mySet;
-		PIDReader<T> parameter(this->parameterId, &mySet);
-		mySet.read();
-		if (!parameter.isValid()) {
-			return MonitoringIF::INVALID;
-		}
-		*sample = parameter.value;
-		return HasReturnvaluesIF::RETURN_OK;
+	    ReturnValue_t result = poolVariable.read();
+	    if(result != HasReturnvaluesIF::RETURN_OK) {
+	        return result;
+	    }
+	    if (not poolVariable.isValid()) {
+	        return MonitoringIF::INVALID;
+	    }
+	    *sample = poolVariable.value;
+	    return HasReturnvaluesIF::RETURN_OK;
 	}
+
+	LocalPoolVar<T> poolVariable;
 };
 
-#endif /* MONITORBASE_H_ */
+#endif /* FSFW_MONITORING_MONITORBASE_H_ */
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index ca2b534b9..9028e7e4a 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -1,10 +1,12 @@
-#ifndef FRAMEWORK_MONITORING_MONITORREPORTER_H_
-#define FRAMEWORK_MONITORING_MONITORREPORTER_H_
+#ifndef FSFW_MONITORING_MONITORREPORTER_H_
+#define FSFW_MONITORING_MONITORREPORTER_H_
 
-#include "../events/EventManagerIF.h"
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
+
+#include "../datapoollocal/locPoolDefinitions.h"
+#include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 
 template<typename T>
@@ -14,11 +16,14 @@ public:
 	static const uint8_t ENABLED = 1;
 	static const uint8_t DISABLED = 0;
 
-	MonitorReporter(object_id_t reportingId, uint8_t monitorId, uint32_t parameterId, uint16_t confirmationLimit) :
-			monitorId(monitorId), parameterId(parameterId), reportingId(
-					reportingId), oldState(MonitoringIF::UNCHECKED), reportingEnabled(
-			ENABLED), eventEnabled(ENABLED), currentCounter(0), confirmationLimit(
-					confirmationLimit) {
+	// TODO: Adapt to use SID instead of parameter ID.
+
+	MonitorReporter(object_id_t reportingId, uint8_t monitorId,
+	        gp_id_t globalPoolId, uint16_t confirmationLimit) :
+			monitorId(monitorId), globalPoolId(globalPoolId),
+			reportingId(reportingId), oldState(MonitoringIF::UNCHECKED),
+			reportingEnabled(ENABLED), eventEnabled(ENABLED), currentCounter(0),
+			confirmationLimit(confirmationLimit) {
 	}
 
 	virtual ~MonitorReporter() {
@@ -63,7 +68,7 @@ public:
 			parameterWrapper->set(this->eventEnabled);
 			break;
 		default:
-			return INVALID_MATRIX_ID;
+			return INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -91,7 +96,7 @@ public:
 
 protected:
 	const uint8_t monitorId;
-	const uint32_t parameterId;
+	const gp_id_t globalPoolId;
 	object_id_t reportingId;
 	ReturnValue_t oldState;
 
@@ -148,7 +153,8 @@ protected:
 		case HasReturnvaluesIF::RETURN_OK:
 			break;
 		default:
-			EventManagerIF::triggerEvent(reportingId, MonitoringIF::MONITOR_CHANGED_STATE, state);
+			EventManagerIF::triggerEvent(reportingId,
+			        MonitoringIF::MONITOR_CHANGED_STATE, state);
 			break;
 		}
 	}
@@ -159,14 +165,15 @@ protected:
 	 * @param crossedLimit The limit crossed (if applicable).
 	 * @param state Current state the monitor is in.
 	 */
-	virtual void sendTransitionReport(T parameterValue, T crossedLimit, ReturnValue_t state) {
-		MonitoringReportContent<T> report(parameterId,
+	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
+	        ReturnValue_t state) {
+		MonitoringReportContent<T> report(globalPoolId,
 				parameterValue, crossedLimit, oldState, state);
 		LimitViolationReporter::sendLimitViolationReport(&report);
 	}
 	ReturnValue_t setToState(ReturnValue_t state) {
 		if (oldState != state && reportingEnabled) {
-			MonitoringReportContent<T> report(parameterId, 0, 0, oldState,
+			MonitoringReportContent<T> report(globalPoolId, 0, 0, oldState,
 					state);
 			LimitViolationReporter::sendLimitViolationReport(&report);
 			oldState = state;
@@ -175,4 +182,4 @@ protected:
 	}
 };
 
-#endif /* FRAMEWORK_MONITORING_MONITORREPORTER_H_ */
+#endif /* FSFW_MONITORING_MONITORREPORTER_H_ */
diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h
index 44218c36d..aa266f337 100644
--- a/monitoring/MonitoringIF.h
+++ b/monitoring/MonitoringIF.h
@@ -1,8 +1,8 @@
-#ifndef MONITORINGIF_H_
-#define MONITORINGIF_H_
+#ifndef FSFW_MONITORING_MONITORINGIF_H_
+#define FSFW_MONITORING_MONITORINGIF_H_
 
-#include "../memory/HasMemoryIF.h"
 #include "MonitoringMessage.h"
+#include "../memory/HasMemoryIF.h"
 #include "../serialize/SerializeIF.h"
 
 class MonitoringIF : public SerializeIF {
@@ -64,4 +64,4 @@ public:
 
 
 
-#endif /* MONITORINGIF_H_ */
+#endif /* FSFW_MONITORING_MONITORINGIF_H_ */
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index c82506f3a..44d326565 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -3,6 +3,7 @@
 
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
@@ -16,12 +17,17 @@ void setStaticFrameworkObjectIds();
 }
 
 //PID(uint32_t), TYPE, LIMIT_ID, value,limitValue, previous, later, timestamp
+/**
+ * @brief	Does magic.
+ * @tparam T
+ */
 template<typename T>
 class MonitoringReportContent: public SerialLinkedListAdapter<SerializeIF> {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	SerializeElement<uint8_t> monitorId;
-	SerializeElement<uint32_t> parameterId;
+	SerializeElement<uint32_t> parameterObjectId;
+	SerializeElement<lp_id_t> localPoolId;
 	SerializeElement<T> parameterValue;
 	SerializeElement<T> limitValue;
 	SerializeElement<ReturnValue_t> oldState;
@@ -30,20 +36,23 @@ public:
 	SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
 	TimeStamperIF* timeStamper;
 	MonitoringReportContent() :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					0), parameterValue(0), limitValue(0), oldState(0), newState(
-					0), rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
+			SerialLinkedListAdapter<SerializeIF>(&parameterObjectId),
+					monitorId(0), parameterObjectId(0),
+					localPoolId(0), parameterValue(0),
+					limitValue(0), oldState(0), newState(0),
+					rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
 					sizeof(rawTimestamp)), timeStamper(NULL) {
 		setAllNext();
 	}
-	MonitoringReportContent(uint32_t setPID, T value, T limitValue,
+	MonitoringReportContent(gp_id_t globalPoolId, T value, T limitValue,
 			ReturnValue_t oldState, ReturnValue_t newState) :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					setPID), parameterValue(value), limitValue(limitValue), oldState(
-					oldState), newState(newState), timestampSerializer(rawTimestamp,
-							sizeof(rawTimestamp)), timeStamper(NULL) {
+			SerialLinkedListAdapter<SerializeIF>(&parameterObjectId),
+					monitorId(0), parameterObjectId(globalPoolId.objectId),
+					localPoolId(globalPoolId.localPoolId),
+					parameterValue(value), limitValue(limitValue),
+					oldState(oldState), newState(newState),
+					timestampSerializer(rawTimestamp, sizeof(rawTimestamp)),
+					timeStamper(NULL) {
 		setAllNext();
 		if (checkAndSetStamper()) {
 			timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
@@ -53,16 +62,16 @@ private:
 
 	static object_id_t timeStamperId;
 	void setAllNext() {
-		parameterId.setNext(&parameterValue);
+		parameterObjectId.setNext(&parameterValue);
 		parameterValue.setNext(&limitValue);
 		limitValue.setNext(&oldState);
 		oldState.setNext(&newState);
 		newState.setNext(&timestampSerializer);
 	}
 	bool checkAndSetStamper() {
-		if (timeStamper == NULL) {
+		if (timeStamper == nullptr) {
 			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
-			if ( timeStamper == NULL ) {
+			if ( timeStamper == nullptr ) {
 				sif::error << "MonitoringReportContent::checkAndSetStamper: "
 				        "Stamper not found!" << std::endl;
 				return false;
diff --git a/monitoring/TriplexMonitor.h b/monitoring/TriplexMonitor.h
index 9b60aeb63..c4b3c5375 100644
--- a/monitoring/TriplexMonitor.h
+++ b/monitoring/TriplexMonitor.h
@@ -82,7 +82,7 @@ public:
 			parameterWrapper->set(limit);
 			break;
 		default:
-			return INVALID_MATRIX_ID;
+			return INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}

From 9ba8ef1ae212f9058671399933cf29335cd436f5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 18:29:28 +0100
Subject: [PATCH 1095/1774] power update

---
 power/Fuse.cpp           | 33 +++++++++++++++-------------
 power/Fuse.h             | 47 ++++++++++++++++++++++------------------
 power/PowerComponent.cpp | 27 ++++++++++-------------
 power/PowerComponent.h   | 24 +++++++++++---------
 power/PowerComponentIF.h | 19 ++++++++--------
 power/PowerSensor.cpp    | 30 ++++++++++++++-----------
 power/PowerSensor.h      | 38 ++++++++++++++++++--------------
 power/PowerSwitchIF.h    | 22 +++++++++----------
 power/PowerSwitcher.cpp  | 28 +++++++++++++++---------
 power/PowerSwitcher.h    | 17 ++++++++++-----
 10 files changed, 156 insertions(+), 129 deletions(-)

diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 9986ab6bb..1c30d83f3 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -1,22 +1,25 @@
+#include "Fuse.h"
+
 #include "../monitoring/LimitViolationReporter.h"
 #include "../monitoring/MonitoringMessageContent.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "Fuse.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../ipc/QueueFactory.h"
 
 object_id_t Fuse::powerSwitchId = 0;
 
-Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
+Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId,
+		sid_t variableSet, VariableIds ids,
 		float maxCurrent, uint16_t confirmationCount) :
-		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
-		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
-				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
-				DataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
-				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
-				ids.pidCurrent, &set), state(ids.pidState, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
-				NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
+		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId),
+		currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
+				maxCurrent, FUSE_CURRENT_HIGH),
+		powerMonitor(fuseObjectId, 2, ids.poolIdPower,
+				confirmationCount),
+		set(variableSet), voltage(ids.pidVoltage, &set),
+		current(ids.pidCurrent, &set), state(ids.pidState, &set),
+		power(ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE),
+		parameterHelper(this), healthHelper(this, fuseObjectId) {
 	commandQueue = QueueFactory::instance()->createMessageQueue();
 }
 
@@ -75,7 +78,7 @@ ReturnValue_t Fuse::check() {
 		float lowLimit = 0.0;
 		float highLimit = RESIDUAL_POWER;
 		calculatePowerLimits(&lowLimit, &highLimit);
-		result = powerMonitor.checkPower(power, lowLimit, highLimit);
+		result = powerMonitor.checkPower(power.value, lowLimit, highLimit);
 		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
 			reportEvents(POWER_BELOW_LOW_LIMIT);
 		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
@@ -109,7 +112,7 @@ size_t Fuse::getSerializedSize() const {
 }
 
 ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
-Endianness streamEndianness) {
+        Endianness streamEndianness) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
 			iter++) {
@@ -132,7 +135,7 @@ void Fuse::calculateFusePower() {
 		return;
 	}
 	//Calculate fuse power.
-	power = current * voltage;
+	power.value = current.value * voltage.value;
 	power.setValid(PoolVariableIF::VALID);
 }
 
@@ -190,12 +193,12 @@ void Fuse::checkFuseState() {
 			reportEvents(FUSE_WENT_OFF);
 		}
 	}
-	oldFuseState = state;
+	oldFuseState = state.value;
 }
 
 float Fuse::getPower() {
 	if (power.isValid()) {
-		return power;
+		return power.value;
 	} else {
 		return 0.0;
 	}
diff --git a/power/Fuse.h b/power/Fuse.h
index 279642be6..e9e9290b4 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -1,16 +1,16 @@
-#ifndef FUSE_H_
-#define FUSE_H_
+#ifndef FSFW_POWER_FUSE_H_
+#define FSFW_POWER_FUSE_H_
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PIDReader.h"
-#include "../devicehandlers/HealthDevice.h"
-#include "../monitoring/AbsLimitMonitor.h"
 #include "PowerComponentIF.h"
 #include "PowerSwitchIF.h"
+
+#include "../devicehandlers/HealthDevice.h"
+#include "../monitoring/AbsLimitMonitor.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../parameters/ParameterHelper.h"
 #include <list>
 
+#include "../datapoollocal/StaticLocalDataSet.h"
 namespace Factory {
 void setStaticFrameworkObjectIds();
 }
@@ -25,10 +25,10 @@ private:
 	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
 public:
 	struct VariableIds {
-		uint32_t pidVoltage;
-		uint32_t pidCurrent;
-		uint32_t pidState;
-		uint32_t poolIdPower;
+		gp_id_t pidVoltage;
+		gp_id_t pidCurrent;
+		gp_id_t pidState;
+		gp_id_t poolIdPower;
 	};
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
@@ -38,8 +38,8 @@ public:
 	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
 
 	typedef std::list<PowerComponentIF*> DeviceList;
-	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
-			float maxCurrent, uint16_t confirmationCount = 2);
+	Fuse(object_id_t fuseObjectId, uint8_t fuseId, sid_t variableSet,
+			VariableIds ids, float maxCurrent, uint16_t confirmationCount = 2);
 	virtual ~Fuse();
 	void addDevice(PowerComponentIF *set);
 	float getPower();
@@ -69,12 +69,12 @@ public:
 private:
 	uint8_t oldFuseState;
 	uint8_t fuseId;
-	PowerSwitchIF *powerIF; //could be static in our case.
+	PowerSwitchIF *powerIF = nullptr; //could be static in our case.
 	AbsLimitMonitor<float> currentLimit;
 	class PowerMonitor: public MonitorReporter<float> {
 	public:
 		template<typename ... Args>
-		PowerMonitor(Args ... args) :
+		PowerMonitor(Args ... args):
 				MonitorReporter<float>(std::forward<Args>(args)...) {
 		}
 		ReturnValue_t checkPower(float sample, float lowerLimit,
@@ -84,12 +84,17 @@ private:
 
 	};
 	PowerMonitor powerMonitor;
-	DataSet set;
-	PIDReader<float> voltage;
-	PIDReader<float> current;
-	PIDReader<uint8_t> state;
-	db_float_t power;
-	MessageQueueIF *commandQueue;
+	StaticLocalDataSet<3> set;
+	//LocalPoolDataSetBase* set = nullptr;
+	//PIDReader<float> voltage;
+	//PIDReader<float> current;
+	//PIDReader<uint8_t> state;
+	lp_var_t<float> voltage;
+	lp_var_t<float> current;
+	lp_var_t<uint8_t> state;
+
+	lp_var_t<float> power;
+	MessageQueueIF* commandQueue = nullptr;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
 	static object_id_t powerSwitchId;
@@ -102,4 +107,4 @@ private:
 	bool areSwitchesOfComponentOn(DeviceList::iterator iter);
 };
 
-#endif /* FUSE_H_ */
+#endif /* FSFW_POWER_FUSE_H_ */
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 6012ad4ca..c31b9a85e 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -1,20 +1,15 @@
-/**
- * @file	PowerComponent.cpp
- * @brief	This file defines the PowerComponent class.
- * @date	28.08.2014
- * @author	baetz
- */
-
 #include "PowerComponent.h"
+#include "../serialize/SerializeAdapter.h"
 
-PowerComponent::PowerComponent() :
-		deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
-		false), min(0.0), max(0.0), moduleId(0) {
+PowerComponent::PowerComponent(): switchId1(0xFF), switchId2(0xFF),
+        doIHaveTwoSwitches(false) {
 }
-PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
-		uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
-		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2), doIHaveTwoSwitches(
-				twoSwitches), min(min), max(max), moduleId(moduleId) {
+
+PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min,
+        float max, uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
+		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2),
+		doIHaveTwoSwitches(twoSwitches), min(min), max(max),
+		moduleId(moduleId) {
 }
 
 ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
@@ -57,7 +52,7 @@ float PowerComponent::getMax() {
 }
 
 ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
-Endianness streamEndianness) {
+        Endianness streamEndianness) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
 			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -80,7 +75,7 @@ ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
 		parameterWrapper->set<>(max);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 6d1c9c06d..c1add3b91 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -1,13 +1,17 @@
-#ifndef POWERCOMPONENT_H_
-#define POWERCOMPONENT_H_
+#ifndef FSFW_POWER_POWERCOMPONENT_H_
+#define FSFW_POWER_POWERCOMPONENT_H_
 
-#include "../objectmanager/SystemObjectIF.h"
 #include "PowerComponentIF.h"
 
+#include "../objectmanager/frameworkObjects.h"
+#include "../objectmanager/SystemObjectIF.h"
+
+
 class PowerComponent: public PowerComponentIF {
 public:
-	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
-			bool twoSwitches = false, uint8_t switchId2 = 0xFF);
+	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
+	        uint8_t switchId1, bool twoSwitches = false,
+	        uint8_t switchId2 = 0xFF);
 
 	virtual object_id_t getDeviceObjectId();
 
@@ -31,18 +35,18 @@ public:
 				ParameterWrapper *parameterWrapper,
 				const ParameterWrapper *newValues, uint16_t startAtIndex);
 private:
-	const object_id_t deviceObjectId;
+	const object_id_t deviceObjectId = objects::NO_OBJECT;
 	const uint8_t switchId1;
 	const uint8_t switchId2;
 
 	const bool doIHaveTwoSwitches;
 
-	float min;
-	float max;
+	float min = 0.0;
+	float max = 0.0;
 
-	uint8_t moduleId;
+	uint8_t moduleId = 0;
 
 	PowerComponent();
 };
 
-#endif /* POWERCOMPONENT_H_ */
+#endif /* FSFW_POWER_POWERCOMPONENT_H_ */
diff --git a/power/PowerComponentIF.h b/power/PowerComponentIF.h
index c2e3a6a56..f35b4d1d3 100644
--- a/power/PowerComponentIF.h
+++ b/power/PowerComponentIF.h
@@ -1,24 +1,23 @@
-#ifndef POWERCOMPONENTIF_H_
-#define POWERCOMPONENTIF_H_
+#ifndef FSFW_POWER_POWERCOMPONENTIF_H_
+#define FSFW_POWER_POWERCOMPONENTIF_H_
 
 #include "../serialize/SerializeIF.h"
 #include "../parameters/HasParametersIF.h"
+#include "../objectmanager/SystemObjectIF.h"
 
 class PowerComponentIF : public SerializeIF, public HasParametersIF {
 public:
-	virtual ~PowerComponentIF() {
+	virtual ~PowerComponentIF() {}
 
-	}
+	virtual object_id_t getDeviceObjectId() = 0;
 
-	virtual object_id_t getDeviceObjectId()=0;
-
-	virtual uint8_t getSwitchId1()=0;
-	virtual uint8_t getSwitchId2()=0;
-	virtual bool hasTwoSwitches()=0;
+	virtual uint8_t getSwitchId1() = 0;
+	virtual uint8_t getSwitchId2() = 0;
+	virtual bool hasTwoSwitches() = 0;
 
 	virtual float getMin() = 0;
 	virtual float getMax() = 0;
 
 };
 
-#endif /* POWERCOMPONENTIF_H_ */
+#endif /* FSFW_POWER_POWERCOMPONENTIF_H_ */
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 50cb6acd2..1ef041e30 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -1,14 +1,18 @@
 #include "PowerSensor.h"
+
 #include "../ipc/QueueFactory.h"
 
-PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
+PowerSensor::PowerSensor(object_id_t objectId, sid_t setId,  VariableIds ids,
 		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
-		SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
-				ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
-				setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
+		SystemObject(objectId), parameterHelper(this),
+		healthHelper(this, objectId),
+		powerSensorSet(setId), current(ids.pidCurrent, &powerSensorSet),
+		voltage(ids.pidVoltage, &powerSensorSet),
+		power(ids.poolIdPower, &powerSensorSet, PoolVariableIF::VAR_WRITE),
+		currentLimit(objectId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
 				limits.currentMin, limits.currentMax, events.currentLow,
-				events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
+				events.currentHigh),
+		voltageLimit(objectId, MODULE_ID_VOLTAGE,
 				ids.pidVoltage, confirmationCount, limits.voltageMin,
 				limits.voltageMax, events.voltageLow, events.voltageHigh) {
 		commandQueue = QueueFactory::instance()->createMessageQueue();
@@ -19,13 +23,13 @@ PowerSensor::~PowerSensor() {
 }
 
 ReturnValue_t PowerSensor::calculatePower() {
-	set.read();
+	powerSensorSet.read();
 	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
 	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
 	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
 			&& current.isValid()) {
-		result1 = voltageLimit.doCheck(voltage);
-		result2 = currentLimit.doCheck(current);
+		result1 = voltageLimit.doCheck(voltage.value);
+		result2 = currentLimit.doCheck(current.value);
 	} else {
 		voltageLimit.setToInvalid();
 		currentLimit.setToInvalid();
@@ -37,9 +41,9 @@ ReturnValue_t PowerSensor::calculatePower() {
 		power.setValid(PoolVariableIF::INVALID);
 	} else {
 		power.setValid(PoolVariableIF::VALID);
-		power = current * voltage;
+		power.value = current.value * voltage.value;
 	}
-	set.commit();
+	powerSensorSet.commit();
 	return result1;
 }
 
@@ -92,8 +96,8 @@ void PowerSensor::checkCommandQueue() {
 }
 
 void PowerSensor::setDataPoolEntriesInvalid() {
-	set.read();
-	set.commit(PoolVariableIF::INVALID);
+	powerSensorSet.read();
+	powerSensorSet.commit(PoolVariableIF::INVALID);
 }
 
 float PowerSensor::getPower() {
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index 0f973e455..a0ccb1ca7 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -1,9 +1,7 @@
-#ifndef POWERSENSOR_H_
-#define POWERSENSOR_H_
+#ifndef FSFW_POWER_POWERSENSOR_H_
+#define FSFW_POWER_POWERSENSOR_H_
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PIDReader.h"
-#include "../datapool/PoolVariable.h"
+#include "../datapoollocal/StaticLocalDataSet.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../monitoring/LimitMonitor.h"
 #include "../parameters/ParameterHelper.h"
@@ -12,15 +10,18 @@
 
 class PowerController;
 
+/**
+ * @brief	Does magic.
+ */
 class PowerSensor: public SystemObject,
 		public ReceivesParameterMessagesIF,
 		public HasHealthIF {
 	friend class PowerController;
 public:
 	struct VariableIds {
-		uint32_t pidCurrent;
-		uint32_t pidVoltage;
-		uint32_t poolIdPower;
+		gp_id_t pidCurrent;
+		gp_id_t pidVoltage;
+		gp_id_t poolIdPower;
 	};
 	struct DefaultLimits {
 		float currentMin;
@@ -34,8 +35,9 @@ public:
 		Event voltageLow;
 		Event voltageHigh;
 	};
-	PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
-			SensorEvents events, uint16_t confirmationCount = 0);
+	PowerSensor(object_id_t objectId, sid_t sid, VariableIds setIds,
+			DefaultLimits limits, SensorEvents events,
+			uint16_t confirmationCount = 0);
 	virtual ~PowerSensor();
 	ReturnValue_t calculatePower();
 	ReturnValue_t performOperation(uint8_t opCode);
@@ -50,15 +52,19 @@ public:
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex);
 private:
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
-	DataSet set;
+	//GlobDataSet set;
+	StaticLocalDataSet<3> powerSensorSet;
 	//Variables in
-	PIDReader<float> current;
-	PIDReader<float> voltage;
+	lp_var_t<float> current;
+	lp_var_t<float> voltage;
+	//PIDReader<float> current;
+	//PIDReader<float> voltage;
 	//Variables out
-	db_float_t power;
+	lp_var_t<float> power;
+	//gp_float_t power;
 
 	static const uint8_t MODULE_ID_CURRENT = 1;
 	static const uint8_t MODULE_ID_VOLTAGE = 2;
@@ -68,4 +74,4 @@ protected:
 	LimitMonitor<float> voltageLimit;
 };
 
-#endif /* POWERSENSOR_H_ */
+#endif /* FSFW_POWER_POWERSENSOR_H_ */
diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h
index 40220fb62..1422baebc 100644
--- a/power/PowerSwitchIF.h
+++ b/power/PowerSwitchIF.h
@@ -1,18 +1,16 @@
-/**
- * @file	PowerSwitchIF.h
- * @brief	This file defines the PowerSwitchIF class.
- * @date	20.03.2013
- * @author	baetz
- */
-
-#ifndef POWERSWITCHIF_H_
-#define POWERSWITCHIF_H_
+#ifndef FSFW_POWER_POWERSWITCHIF_H_
+#define FSFW_POWER_POWERSWITCHIF_H_
 
 #include "../events/Event.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 /**
- * This interface defines a connection to a device that is capable of turning on and off
- * switches of devices identified by a switch ID.
+ *
+ * @brief   This interface defines a connection to a device that is capable of
+ *          turning on and off switches of devices identified by a switch ID.
+ * @details
+ * The virtual functions of this interface do not allow to make any assignments
+ * because they can be called asynchronosuly (const ending).
+ * @ingroup interfaces
  */
 class PowerSwitchIF : public HasReturnvaluesIF {
 public:
@@ -72,4 +70,4 @@ public:
 };
 
 
-#endif /* POWERSWITCHIF_H_ */
+#endif /* FSFW_POWER_POWERSWITCHIF_H_ */
diff --git a/power/PowerSwitcher.cpp b/power/PowerSwitcher.cpp
index 6296a04c7..ed37998ec 100644
--- a/power/PowerSwitcher.cpp
+++ b/power/PowerSwitcher.cpp
@@ -1,15 +1,17 @@
-#include "../objectmanager/ObjectManagerIF.h"
 #include "PowerSwitcher.h"
+
+#include "../objectmanager/ObjectManagerIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
-		PowerSwitcher::State_t setStartState) :
-		state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
+		PowerSwitcher::State_t setStartState):
+		state(setStartState), firstSwitch(setSwitch1),
+		secondSwitch(setSwitch2) {
 }
 
 ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
 	power = objectManager->get<PowerSwitchIF>(powerSwitchId);
-	if (power == NULL) {
+	if (power == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
@@ -17,19 +19,25 @@ ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
 
 ReturnValue_t PowerSwitcher::getStateOfSwitches() {
 	SwitchReturn_t result = howManySwitches();
+
 	switch (result) {
 	case ONE_SWITCH:
 		return power->getSwitchState(firstSwitch);
-	case TWO_SWITCHES:
-		if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
+	case TWO_SWITCHES: {
+	    ReturnValue_t firstSwitchState = power->getSwitchState(firstSwitch);
+	    ReturnValue_t secondSwitchState = power->getSwitchState(firstSwitch);
+		if ((firstSwitchState == PowerSwitchIF::SWITCH_ON)
+				&& (secondSwitchState == PowerSwitchIF::SWITCH_ON)) {
 			return PowerSwitchIF::SWITCH_ON;
-		} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
+		}
+		else if ((firstSwitchState == PowerSwitchIF::SWITCH_OFF)
+				&& (secondSwitchState  == PowerSwitchIF::SWITCH_OFF)) {
 			return PowerSwitchIF::SWITCH_OFF;
-		} else {
+		}
+		else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
+	}
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
diff --git a/power/PowerSwitcher.h b/power/PowerSwitcher.h
index 0f1c02deb..f4e2138d4 100644
--- a/power/PowerSwitcher.h
+++ b/power/PowerSwitcher.h
@@ -1,10 +1,13 @@
-#ifndef POWERSWITCHER_H_
-#define POWERSWITCHER_H_
+#ifndef FSFW_POWER_POWERSWITCHER_H_
+#define FSFW_POWER_POWERSWITCHER_H_
+
 #include "PowerSwitchIF.h"
+
+#include "../objectmanager/SystemObjectIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../timemanager/Countdown.h"
 
-class PowerSwitcher : public HasReturnvaluesIF {
+class PowerSwitcher: public HasReturnvaluesIF {
 public:
 	enum State_t {
 		WAIT_OFF,
@@ -16,7 +19,8 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
 	static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
-	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
+	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH,
+	        State_t setStartState = SWITCH_IS_OFF );
 	ReturnValue_t initialize(object_id_t powerSwitchId);
 	void turnOn();
 	void turnOff();
@@ -29,7 +33,8 @@ public:
 private:
 	uint8_t firstSwitch;
 	uint8_t secondSwitch;
-	PowerSwitchIF* power;
+	PowerSwitchIF* power = nullptr;
+
 	static const uint8_t NO_SWITCH = 0xFF;
 	enum SwitchReturn_t {
 		ONE_SWITCH = 1,
@@ -42,4 +47,4 @@ private:
 
 
 
-#endif /* POWERSWITCHER_H_ */
+#endif /* FSFW_POWER_POWERSWITCHER_H_ */

From 64cf0d0a7028313a5f5ad9429d9738964902762e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 18:32:32 +0100
Subject: [PATCH 1096/1774] thermal update

---
 thermal/AbstractTemperatureSensor.cpp |  12 +-
 thermal/AbstractTemperatureSensor.h   |  10 +
 thermal/AcceptsThermalMessagesIF.h    |  22 ++
 thermal/Heater.cpp                    |  10 +-
 thermal/RedundantHeater.h             |  13 +-
 thermal/TemperatureSensor.h           | 138 +++++++++----
 thermal/ThermalComponent.cpp          |  59 +++---
 thermal/ThermalComponent.h            |  49 ++++-
 thermal/ThermalComponentCore.cpp      | 285 ++++++++++++++++++++++++++
 thermal/ThermalComponentCore.h        | 117 +++++++++++
 thermal/ThermalComponentIF.h          |  12 +-
 thermal/ThermalModule.cpp             |  84 ++++----
 thermal/ThermalModule.h               |  49 +++--
 thermal/ThermalMonitorReporter.cpp    |  75 +++++++
 thermal/ThermalMonitorReporter.h      |  28 +++
 thermal/tcsDefinitions.h              |   2 +-
 16 files changed, 796 insertions(+), 169 deletions(-)
 create mode 100644 thermal/AcceptsThermalMessagesIF.h
 create mode 100644 thermal/ThermalComponentCore.cpp
 create mode 100644 thermal/ThermalComponentCore.h
 create mode 100644 thermal/ThermalMonitorReporter.cpp
 create mode 100644 thermal/ThermalMonitorReporter.h

diff --git a/thermal/AbstractTemperatureSensor.cpp b/thermal/AbstractTemperatureSensor.cpp
index 45ebe4a2a..40b305af9 100644
--- a/thermal/AbstractTemperatureSensor.cpp
+++ b/thermal/AbstractTemperatureSensor.cpp
@@ -44,19 +44,19 @@ ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
 }
 
 void AbstractTemperatureSensor::handleCommandQueue() {
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
-		result = parameterHelper.handleParameterMessage(&message);
+		result = parameterHelper.handleParameterMessage(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
-		message.setToUnknownCommand();
-		commandQueue->reply(&message);
+		command.setToUnknownCommand();
+		commandQueue->reply(&command);
 	}
 }
 
diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h
index 726ab9f4c..cc064ce47 100644
--- a/thermal/AbstractTemperatureSensor.h
+++ b/thermal/AbstractTemperatureSensor.h
@@ -10,6 +10,16 @@
 #include "ThermalModuleIF.h"
 #include "tcsDefinitions.h"
 
+/**
+ * @defgroup thermal Thermal Components
+ * @brief Contains all components related to thermal tasks (sensors, heaters)
+ */
+
+/**
+ * @brief Base class for Temperature Sensor, implements all important interfaces.
+ *        Please use the TemperatureSensor class to implement the actual sensors.
+ * @ingroup thermal
+ */
 class AbstractTemperatureSensor: public HasHealthIF,
 		public SystemObject,
 		public ExecutableObjectIF,
diff --git a/thermal/AcceptsThermalMessagesIF.h b/thermal/AcceptsThermalMessagesIF.h
new file mode 100644
index 000000000..5fbd6bb38
--- /dev/null
+++ b/thermal/AcceptsThermalMessagesIF.h
@@ -0,0 +1,22 @@
+/**
+ * \file AcceptsThermalMessagesIF.h
+ *
+ * \date 16.02.2020
+ */
+
+#ifndef FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
+#define FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
+#include "../ipc/MessageQueueSenderIF.h"
+
+class AcceptsThermalMessagesIF {
+public:
+
+	/**
+	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~AcceptsThermalMessagesIF() { }
+
+	virtual MessageQueueId_t getReceptionQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_ */
diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index 1301e2e01..ce965d5ea 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -279,14 +279,14 @@ ReturnValue_t Heater::initialize() {
 }
 
 void Heater::handleQueue() {
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
-		parameterHelper.handleParameterMessage(&message);
+		parameterHelper.handleParameterMessage(&command);
 	}
 }
 
@@ -301,7 +301,7 @@ ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
 		parameterWrapper->set(heaterOnCountdown.timeout);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/thermal/RedundantHeater.h b/thermal/RedundantHeater.h
index ab745a698..765375420 100644
--- a/thermal/RedundantHeater.h
+++ b/thermal/RedundantHeater.h
@@ -1,7 +1,7 @@
 #ifndef REDUNDANTHEATER_H_
 #define REDUNDANTHEATER_H_
 
-#include "Heater.h"
+#include "../thermal/Heater.h"
 
 class RedundantHeater {
 public:
@@ -10,15 +10,14 @@ public:
 		Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
 				uint8_t switch0Heater0, uint8_t switch1Heater0,
 				uint8_t switch0Heater1, uint8_t switch1Heater1) :
-				objectIdHeater0(objectIdHeater0), objectIdHeater1(
-						objectIdHeater1), switch0Heater0(switch0Heater0), switch1Heater0(
-						switch1Heater0), switch0Heater1(switch0Heater1), switch1Heater1(
-						switch1Heater1) {
+				objectIdHeater0(objectIdHeater0), objectIdHeater1(objectIdHeater1),
+				switch0Heater0(switch0Heater0),switch1Heater0(switch1Heater0),
+				switch0Heater1(switch0Heater1), switch1Heater1(switch1Heater1) {
 		}
 
 		Parameters() :
-				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0), switch1Heater0(
-						0), switch0Heater1(0), switch1Heater1(0) {
+				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0),
+				switch1Heater0(0), switch0Heater1(0), switch1Heater1(0) {
 		}
 
 		uint32_t objectIdHeater0;
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 356ca7220..f41b3761b 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -1,40 +1,101 @@
 #ifndef TEMPERATURESENSOR_H_
 #define TEMPERATURESENSOR_H_
 
-#include "../datapool/DataSet.h"
-#include "AbstractTemperatureSensor.h"
+#include "../thermal/AbstractTemperatureSensor.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../monitoring/LimitMonitor.h"
 
-template<typename T>
+/**
+ * @brief 	This building block handles non-linear value conversion and
+ * 			range checks for analog temperature sensors.
+ * @details This class can be used to perform all necessary tasks for temperature sensors.
+ *          A sensor can be instantiated by calling the constructor.
+ *          The temperature is calculated from an input value with
+ *			the calculateOutputTemperature() function. Range checking and
+ *			limit monitoring is performed automatically.
+ *			The inputType specifies the type of the raw input while the
+ *			limitType specifies the type of the upper and lower limit to check against.
+ * @ingroup thermal
+ */
+
+template<typename inputType, typename limitType = inputType>
 class TemperatureSensor: public AbstractTemperatureSensor {
 public:
+	/**
+	 * This structure contains parameters required for range checking
+	 * and the conversion from the input value to the output temperature.
+	 * a, b and c can be any parameters required to calculate the output
+	 * temperature from the input value, depending on the formula used.
+	 *
+	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
+	 *
+	 * The lower and upper limits can be specified in any type, for example float for C values
+	 * or any other type for raw values.
+	 */
 	struct Parameters {
 		float a;
 		float b;
 		float c;
-		T lowerLimit;
-		T upperLimit;
-		float gradient;
+		limitType lowerLimit;
+		limitType upperLimit;
+		float maxGradient;
 	};
+
+	/**
+	 * Forward declaration for explicit instantiation of used parameters.
+	 */
 	struct UsedParameters {
 		UsedParameters(Parameters parameters) :
-				a(parameters.a), b(parameters.b), c(parameters.c), gradient(
-						parameters.gradient) {
-		}
+			a(parameters.a), b(parameters.b), c(parameters.c),
+			gradient(parameters.maxGradient) {}
 		float a;
 		float b;
 		float c;
 		float gradient;
 	};
 
-	static const uint16_t ADDRESS_A = 0;
-	static const uint16_t ADDRESS_B = 1;
-	static const uint16_t ADDRESS_C = 2;
-	static const uint16_t ADDRESS_GRADIENT = 3;
+	/**
+	 * Instantiate Temperature Sensor Object.
+	 * @param setObjectid objectId of the sensor object
+	 * @param inputValue Input value which is converted to a temperature
+	 * @param poolVariable Pool Variable to store the temperature value
+	 * @param vectorIndex Vector Index for the sensor monitor
+	 * @param parameters Calculation parameters, temperature limits, gradient limit
+	 * @param datapoolId Datapool ID of the output temperature
+	 * @param outputSet Output dataset for the output temperature to fetch it with read()
+	 * @param thermalModule respective thermal module, if it has one
+	 */
+	TemperatureSensor(object_id_t setObjectid,
+			inputType *inputValue, PoolVariableIF *poolVariable,
+			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
+			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
+			inputValue(inputValue), poolVariable(poolVariable),
+			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
+			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
+				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
+				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
+			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
+	}
+
+
+protected:
+	/**
+	 * This formula is used to calculate the temperature from an input value
+	 * with an arbitrary type.
+	 * A default implementation is provided but can be replaced depending
+	 * on the required calculation.
+	 * @param inputTemperature
+	 * @return
+	 */
+	virtual float calculateOutputTemperature(inputType inputValue) {
+		return parameters.a * inputValue * inputValue
+				+ parameters.b * inputValue + parameters.c;
+	}
 
-	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
 
-	static const uint8_t DOMAIN_ID_SENSOR = 1;
 private:
 	void setInvalid() {
 		outputTemperature = INVALID_TEMPERATURE;
@@ -47,22 +108,17 @@ protected:
 
 	UsedParameters parameters;
 
-	T *inputTemperature;
+	inputType * inputValue;
 
 	PoolVariableIF *poolVariable;
 
-	PoolVariable<float> outputTemperature;
+	gp_float_t outputTemperature;
 
-	LimitMonitor<T> sensorMonitor;
+	LimitMonitor<limitType> sensorMonitor;
 
 	float oldTemperature;
 	timeval uptimeOfOldTemperature;
 
-	virtual float calculateOutputTemperature(T inputTemperature) {
-		return parameters.a * inputTemperature * inputTemperature
-				+ parameters.b * inputTemperature + parameters.c;
-	}
-
 	void doChildOperation() {
 		if (!poolVariable->isValid()
 				|| !healthHelper.healthTable->isHealthy(getObjectId())) {
@@ -70,7 +126,7 @@ protected:
 			return;
 		}
 
-		outputTemperature = calculateOutputTemperature(*inputTemperature);
+		outputTemperature = calculateOutputTemperature(*inputValue);
 		outputTemperature.setValid(PoolVariableIF::VALID);
 
 		timeval uptime;
@@ -78,7 +134,7 @@ protected:
 
 		if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
 			//In theory, we could use an AbsValueMonitor to monitor the gradient.
-			//But this would require storing the gradient in DP and quite some overhead.
+			//But this would require storing the maxGradient in DP and quite some overhead.
 			//The concept of delta limits is a bit strange anyway.
 			float deltaTime;
 			float deltaTemp;
@@ -96,8 +152,8 @@ protected:
 			}
 		}
 
-		//Check is done against raw limits. SHOULDDO: Why? Using °C would be more easy to handle.
-		sensorMonitor.doCheck(*inputTemperature);
+		//Check is done against raw limits. SHOULDDO: Why? Using �C would be more easy to handle.
+		sensorMonitor.doCheck(outputTemperature.value);
 
 		if (sensorMonitor.isOutOfLimits()) {
 			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
@@ -110,23 +166,6 @@ protected:
 	}
 
 public:
-	TemperatureSensor(object_id_t setObjectid,
-			T *inputTemperature, PoolVariableIF *poolVariable,
-			uint8_t vectorIndex, Parameters parameters, uint32_t datapoolId,
-			DataSet *outputSet, ThermalModuleIF *thermalModule) :
-			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(
-					parameters), inputTemperature(inputTemperature), poolVariable(
-					poolVariable), outputTemperature(datapoolId, outputSet,
-					PoolVariableIF::VAR_WRITE), sensorMonitor(setObjectid,
-							DOMAIN_ID_SENSOR,
-					DataPool::poolIdAndPositionToPid(
-							poolVariable->getDataPoolId(), vectorIndex),
-					DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit,
-					parameters.upperLimit, TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH), oldTemperature(
-					20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
-
-	}
-
 	float getTemperature() {
 		return outputTemperature;
 	}
@@ -135,6 +174,15 @@ public:
 		return outputTemperature.isValid();
 	}
 
+	static const uint16_t ADDRESS_A = 0;
+	static const uint16_t ADDRESS_B = 1;
+	static const uint16_t ADDRESS_C = 2;
+	static const uint16_t ADDRESS_GRADIENT = 3;
+
+	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
+
+	static const uint8_t DOMAIN_ID_SENSOR = 1;
+
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) {
@@ -160,7 +208,7 @@ public:
 			parameterWrapper->set(parameters.gradient);
 			break;
 		default:
-			return INVALID_MATRIX_ID;
+			return INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 5dcd0bc64..084201dd4 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -1,48 +1,46 @@
 #include "ThermalComponent.h"
 
 ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
-		uint8_t domainId, uint32_t temperaturePoolId,
-		uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-		uint32_t requestPoolId, DataSet* dataSet,
+		uint8_t domainId, gp_id_t temperaturePoolId,
+		gp_id_t targetStatePoolId, gp_id_t currentStatePoolId,
+		gp_id_t requestPoolId, LocalPoolDataSetBase* dataSet,
 		AbstractTemperatureSensor* sensor,
 		AbstractTemperatureSensor* firstRedundantSensor,
 		AbstractTemperatureSensor* secondRedundantSensor,
 		ThermalModuleIF* thermalModule, Parameters parameters,
 		Priority priority) :
-		CoreComponent(reportingObjectId, domainId, temperaturePoolId,
+		ThermalComponentCore(reportingObjectId, domainId, temperaturePoolId,
 				targetStatePoolId, currentStatePoolId, requestPoolId, dataSet,
-				sensor, firstRedundantSensor, secondRedundantSensor,
-				thermalModule,
 				{ parameters.lowerOpLimit, parameters.upperOpLimit,
-						parameters.heaterOn, parameters.hysteresis,
-						parameters.heaterSwitchoff }, priority,
-				ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL), nopParameters(
-				{ parameters.lowerNopLimit, parameters.upperNopLimit }) {
+				parameters.heaterOn, parameters.hysteresis,
+				parameters.heaterSwitchoff },
+				ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL),
+		nopParameters({ parameters.lowerNopLimit, parameters.upperNopLimit }) {
 }
 
 ThermalComponent::~ThermalComponent() {
 }
 
 ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
-	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
-			&& (newState != STATE_REQUEST_IGNORE)) {
+	targetState.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
+	targetState.read();
+	if ((targetState == STATE_REQUEST_OPERATIONAL)
+			and (newState != STATE_REQUEST_IGNORE)) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	switch (newState) {
 	case STATE_REQUEST_NON_OPERATIONAL:
-		writableTargetState = newState;
-		mySet.commit(PoolVariableIF::VALID);
+		targetState = newState;
+		targetState.setValid(true);
+		targetState.commit(PoolVariableIF::VALID);
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
-		return CoreComponent::setTargetState(newState);
+		return ThermalComponentCore::setTargetState(newState);
 	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
+ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
 	if (size != 4 * sizeof(parameters.lowerOpLimit)) {
 		return MonitoringIF::INVALID_SIZE;
 	}
@@ -59,11 +57,11 @@ ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
 }
 
 ThermalComponentIF::State ThermalComponent::getState(float temperature,
-		CoreComponent::Parameters parameters, int8_t targetState) {
+		ThermalComponentCore::Parameters parameters, int8_t targetState) {
 	if (temperature < nopParameters.lowerNopLimit) {
 		return OUT_OF_RANGE_LOW;
 	} else {
-		State state = CoreComponent::getState(temperature, parameters,
+		State state = ThermalComponentCore::getState(temperature, parameters,
 				targetState);
 		if (state != NON_OPERATIONAL_HIGH
 				&& state != NON_OPERATIONAL_HIGH_IGNORED) {
@@ -80,18 +78,19 @@ ThermalComponentIF::State ThermalComponent::getState(float temperature,
 }
 
 void ThermalComponent::checkLimits(ThermalComponentIF::State state) {
-	if (targetState == STATE_REQUEST_OPERATIONAL || targetState == STATE_REQUEST_IGNORE) {
-		CoreComponent::checkLimits(state);
+	if ((targetState == STATE_REQUEST_OPERATIONAL) or
+			(targetState == STATE_REQUEST_IGNORE)) {
+		ThermalComponentCore::checkLimits(state);
 		return;
 	}
-	//If component is not operational, it checks the NOP limits.
+	// If component is not operational, it checks the NOP limits.
 	temperatureMonitor.translateState(state, temperature.value,
 			nopParameters.lowerNopLimit, nopParameters.upperNopLimit, false);
 }
 
 ThermalComponentIF::HeaterRequest ThermalComponent::getHeaterRequest(
 		int8_t targetState, float temperature,
-		CoreComponent::Parameters parameters) {
+		ThermalComponentCore::Parameters parameters) {
 	if (targetState == STATE_REQUEST_IGNORE) {
 		isHeating = false;
 		return HEATER_DONT_CARE;
@@ -144,16 +143,16 @@ ThermalComponentIF::State ThermalComponent::getIgnoredState(int8_t state) {
 	case OUT_OF_RANGE_HIGH_IGNORED:
 		return OUT_OF_RANGE_HIGH_IGNORED;
 	default:
-		return CoreComponent::getIgnoredState(state);
+		return ThermalComponentCore::getIgnoredState(state);
 	}
 }
 
 ReturnValue_t ThermalComponent::getParameter(uint8_t domainId,
 		uint16_t parameterId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = CoreComponent::getParameter(domainId, parameterId,
+	ReturnValue_t result = ThermalComponentCore::getParameter(domainId, parameterId,
 			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_MATRIX_ID) {
+	if (result != INVALID_IDENTIFIER_ID) {
 		return result;
 	}
 	switch (parameterId) {
@@ -164,7 +163,7 @@ ReturnValue_t ThermalComponent::getParameter(uint8_t domainId,
 		parameterWrapper->set(nopParameters.upperNopLimit);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 932438684..0785a9141 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -1,9 +1,14 @@
-#ifndef THERMALCOMPONENT_H_
-#define THERMALCOMPONENT_H_
+#ifndef FSFW_THERMAL_THERMALCOMPONENT_H_
+#define FSFW_THERMAL_THERMALCOMPONENT_H_
 
-#include "CoreComponent.h"
+#include "ThermalComponentCore.h"
 
-class ThermalComponent: public CoreComponent {
+/**
+ * @brief
+ * @details
+ * Some more documentation.
+ */
+class ThermalComponent: public ThermalComponentCore {
 public:
 	struct Parameters {
 		float lowerNopLimit;
@@ -14,13 +19,35 @@ public:
 		float hysteresis;
 		float heaterSwitchoff;
 	};
+
+	/**
+	 * Non-Operational Temperatures
+	 */
 	struct NopParameters {
 		float lowerNopLimit;
 		float upperNopLimit;
 	};
-	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
-			uint32_t targetStatePoolId, uint32_t currentStatePoolId, uint32_t requestPoolId,
-			DataSet *dataSet, AbstractTemperatureSensor *sensor,
+
+	/**
+	 * How to use.
+	 * @param reportingObjectId
+	 * @param domainId
+	 * @param temperaturePoolId
+	 * @param targetStatePoolId
+	 * @param currentStatePoolId
+	 * @param requestPoolId
+	 * @param dataSet
+	 * @param sensor
+	 * @param firstRedundantSensor
+	 * @param secondRedundantSensor
+	 * @param thermalModule
+	 * @param parameters
+	 * @param priority
+	 */
+	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId,
+	        gp_id_t temperaturePoolId, gp_id_t targetStatePoolId,
+	        gp_id_t currentStatePoolId, gp_id_t requestPoolId,
+			LocalPoolDataSetBase *dataSet, AbstractTemperatureSensor *sensor,
 			AbstractTemperatureSensor *firstRedundantSensor,
 			AbstractTemperatureSensor *secondRedundantSensor,
 			ThermalModuleIF *thermalModule, Parameters parameters,
@@ -29,7 +56,7 @@ public:
 
 	ReturnValue_t setTargetState(int8_t newState);
 
-	virtual ReturnValue_t setLimits( const uint8_t* data, uint32_t size);
+	virtual ReturnValue_t setLimits( const uint8_t* data, size_t size);
 
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,
@@ -39,15 +66,15 @@ protected:
 
 	NopParameters nopParameters;
 
-	State getState(float temperature, CoreComponent::Parameters parameters,
+	State getState(float temperature, ThermalComponentCore::Parameters parameters,
 			int8_t targetState);
 
 	virtual void checkLimits(State state);
 
 	virtual HeaterRequest getHeaterRequest(int8_t targetState, float temperature,
-			CoreComponent::Parameters parameters);
+			ThermalComponentCore::Parameters parameters);
 
 	State getIgnoredState(int8_t state);
 };
 
-#endif /* THERMALCOMPONENT_H_ */
+#endif /* FSFW_THERMAL_THERMALCOMPONENT_H_ */
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
new file mode 100644
index 000000000..7b594d0c9
--- /dev/null
+++ b/thermal/ThermalComponentCore.cpp
@@ -0,0 +1,285 @@
+#include "ThermalComponentCore.h"
+
+ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
+        uint8_t domainId, gp_id_t temperaturePoolId,
+        gp_id_t targetStatePoolId, gp_id_t currentStatePoolId,
+		gp_id_t requestPoolId, LocalPoolDataSetBase* dataSet,
+		Parameters parameters, StateRequest initialTargetState) :
+		temperature(temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ),
+		currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		heaterRequest(requestPoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		parameters(parameters), domainId(domainId),
+		temperatureMonitor(reportingObjectId, domainId + 1,temperaturePoolId,
+				COMPONENT_TEMP_CONFIRMATION) {
+	//Set thermal state once, then leave to operator.
+	targetState.setReadWriteMode(PoolVariableIF::VAR_WRITE);
+	ReturnValue_t result = targetState.read();
+	if(result == HasReturnvaluesIF::RETURN_OK) {
+		targetState = initialTargetState;
+		targetState.setValid(true);
+		targetState.commit();
+	}
+	targetState.setReadWriteMode(PoolVariableIF::VAR_READ);
+}
+
+void ThermalComponentCore::addSensor(AbstractTemperatureSensor* sensor) {
+    this->sensor = sensor;
+}
+
+void ThermalComponentCore::addFirstRedundantSensor(
+        AbstractTemperatureSensor *firstRedundantSensor) {
+    this->firstRedundantSensor = firstRedundantSensor;
+}
+
+void ThermalComponentCore::addSecondRedundantSensor(
+        AbstractTemperatureSensor *secondRedundantSensor) {
+    this->secondRedundantSensor = secondRedundantSensor;
+}
+
+void ThermalComponentCore::addThermalModule(ThermalModule *thermalModule,
+        Priority priority) {
+    this->thermalModule = thermalModule;
+    if(thermalModule != nullptr) {
+        thermalModule->registerComponent(this, priority);
+    }
+}
+
+void ThermalComponentCore::setPriority(Priority priority) {
+    if(priority == SAFE) {
+        this->isSafeComponent = true;
+    }
+}
+
+ThermalComponentCore::~ThermalComponentCore() {
+}
+
+ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
+        uint8_t opCode) {
+	HeaterRequest request = HEATER_DONT_CARE;
+	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
+	temperature = getTemperature();
+	updateMinMaxTemp();
+	if (temperature != INVALID_TEMPERATURE) {
+		temperature.setValid(PoolVariableIF::VALID);
+		State state = getState(temperature.value, getParameters(),
+				targetState.value);
+		currentState = state;
+		checkLimits(state);
+		request = getHeaterRequest(targetState.value, temperature.value,
+				getParameters());
+	} else {
+		temperatureMonitor.setToInvalid();
+		temperature.setValid(PoolVariableIF::INVALID);
+		currentState = UNKNOWN;
+		request = HEATER_DONT_CARE;
+	}
+	currentState.setValid(PoolVariableIF::VALID);
+	heaterRequest = request;
+	heaterRequest.setValid(PoolVariableIF::VALID);
+	return request;
+}
+
+void ThermalComponentCore::markStateIgnored() {
+	currentState = getIgnoredState(currentState.value);
+}
+
+object_id_t ThermalComponentCore::getObjectId() {
+	return temperatureMonitor.getReporterId();
+	return 0;
+}
+
+float ThermalComponentCore::getLowerOpLimit() {
+	return parameters.lowerOpLimit;
+}
+
+
+
+ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
+	targetState.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
+	targetState.read();
+	if((targetState == STATE_REQUEST_OPERATIONAL) and
+			(newState != STATE_REQUEST_IGNORE)) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	switch (newState) {
+	case STATE_REQUEST_HEATING:
+	case STATE_REQUEST_IGNORE:
+	case STATE_REQUEST_OPERATIONAL:
+		targetState = newState;
+		break;
+	case STATE_REQUEST_NON_OPERATIONAL:
+	default:
+		return INVALID_TARGET_STATE;
+	}
+	targetState.setValid(true);
+	targetState.commit();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ThermalComponentCore::setOutputInvalid() {
+	temperature = INVALID_TEMPERATURE;
+	temperature.setValid(PoolVariableIF::INVALID);
+	currentState.setValid(PoolVariableIF::INVALID);
+	heaterRequest = HEATER_DONT_CARE;
+	heaterRequest.setValid(PoolVariableIF::INVALID);
+	temperatureMonitor.setToUnchecked();
+}
+
+float ThermalComponentCore::getTemperature() {
+	if ((sensor != nullptr) && (sensor->isValid())) {
+		return sensor->getTemperature();
+	}
+
+	if ((firstRedundantSensor != nullptr) &&
+	        (firstRedundantSensor->isValid())) {
+		return firstRedundantSensor->getTemperature();
+	}
+
+	if ((secondRedundantSensor != nullptr) &&
+	        (secondRedundantSensor->isValid())) {
+		return secondRedundantSensor->getTemperature();
+	}
+
+	if (thermalModule != nullptr) {
+		float temperature = thermalModule->getTemperature();
+		if (temperature != ThermalModuleIF::INVALID_TEMPERATURE) {
+			return temperature;
+		} else {
+			return INVALID_TEMPERATURE;
+		}
+	} else {
+		return INVALID_TEMPERATURE;
+	}
+}
+
+ThermalComponentIF::State ThermalComponentCore::getState(float temperature,
+		Parameters parameters, int8_t targetState) {
+	ThermalComponentIF::State state;
+
+	if (temperature < parameters.lowerOpLimit) {
+		state = NON_OPERATIONAL_LOW;
+	} else if (temperature < parameters.upperOpLimit) {
+		state = OPERATIONAL;
+	} else {
+		state = NON_OPERATIONAL_HIGH;
+	}
+	if (targetState == STATE_REQUEST_IGNORE) {
+		state = getIgnoredState(state);
+	}
+
+	return state;
+}
+
+void ThermalComponentCore::checkLimits(ThermalComponentIF::State state) {
+	//Checks operational limits only.
+	temperatureMonitor.translateState(state, temperature.value,
+			getParameters().lowerOpLimit, getParameters().upperOpLimit);
+
+}
+
+ThermalComponentIF::HeaterRequest ThermalComponentCore::getHeaterRequest(
+		int8_t targetState, float temperature, Parameters parameters) {
+	if (targetState == STATE_REQUEST_IGNORE) {
+		isHeating = false;
+		return HEATER_DONT_CARE;
+	}
+
+	if (temperature > parameters.upperOpLimit - parameters.heaterSwitchoff) {
+		isHeating = false;
+		return HEATER_REQUEST_EMERGENCY_OFF;
+	}
+
+	float opHeaterLimit = parameters.lowerOpLimit + parameters.heaterOn;
+
+	if (isHeating) {
+		opHeaterLimit += parameters.hysteresis;
+	}
+
+	if (temperature < opHeaterLimit) {
+		isHeating = true;
+		return HEATER_REQUEST_EMERGENCY_ON;
+	}
+	isHeating = false;
+	return HEATER_DONT_CARE;
+}
+
+ThermalComponentIF::State ThermalComponentCore::getIgnoredState(int8_t state) {
+	switch (state) {
+	case NON_OPERATIONAL_LOW:
+		return NON_OPERATIONAL_LOW_IGNORED;
+	case OPERATIONAL:
+		return OPERATIONAL_IGNORED;
+	case NON_OPERATIONAL_HIGH:
+		return NON_OPERATIONAL_HIGH_IGNORED;
+	case NON_OPERATIONAL_LOW_IGNORED:
+		return NON_OPERATIONAL_LOW_IGNORED;
+	case OPERATIONAL_IGNORED:
+		return OPERATIONAL_IGNORED;
+	case NON_OPERATIONAL_HIGH_IGNORED:
+		return NON_OPERATIONAL_HIGH_IGNORED;
+	default:
+	case UNKNOWN:
+		return UNKNOWN;
+	}
+}
+
+void ThermalComponentCore::updateMinMaxTemp() {
+	if (temperature == INVALID_TEMPERATURE) {
+		return;
+	}
+	if (temperature < minTemp) {
+		minTemp = static_cast<float>(temperature);
+	}
+	if (temperature > maxTemp) {
+		maxTemp = static_cast<float>(temperature);
+	}
+}
+
+uint8_t ThermalComponentCore::getDomainId() const {
+	return domainId;
+}
+
+ThermalComponentCore::Parameters ThermalComponentCore::getParameters() {
+	return parameters;
+}
+
+ReturnValue_t ThermalComponentCore::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	ReturnValue_t result = temperatureMonitor.getParameter(domainId,
+			parameterId, parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	if (domainId != this->domainId) {
+		return INVALID_DOMAIN_ID;
+	}
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set(parameters.heaterOn);
+		break;
+	case 1:
+		parameterWrapper->set(parameters.hysteresis);
+		break;
+	case 2:
+		parameterWrapper->set(parameters.heaterSwitchoff);
+		break;
+	case 3:
+		parameterWrapper->set(minTemp);
+		break;
+	case 4:
+		parameterWrapper->set(maxTemp);
+		break;
+	case 10:
+		parameterWrapper->set(parameters.lowerOpLimit);
+		break;
+	case 11:
+		parameterWrapper->set(parameters.upperOpLimit);
+		break;
+	default:
+		return INVALID_IDENTIFIER_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/thermal/ThermalComponentCore.h b/thermal/ThermalComponentCore.h
new file mode 100644
index 000000000..da9424e68
--- /dev/null
+++ b/thermal/ThermalComponentCore.h
@@ -0,0 +1,117 @@
+#ifndef FSFW_THERMAL_THERMALCOMPONENTCORE_H_
+#define FSFW_THERMAL_THERMALCOMPONENTCORE_H_
+
+#include "ThermalMonitorReporter.h"
+#include "ThermalComponentIF.h"
+#include "AbstractTemperatureSensor.h"
+#include "ThermalModule.h"
+
+#include "../datapoollocal/LocalPoolVariable.h"
+
+/**
+ * @brief
+ * @details
+ */
+class ThermalComponentCore: public ThermalComponentIF {
+public:
+	struct Parameters {
+		float lowerOpLimit;
+		float upperOpLimit;
+		float heaterOn;
+		float hysteresis;
+		float heaterSwitchoff;
+	};
+
+	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
+
+	/**
+	 * Some documentation
+	 * @param reportingObjectId
+	 * @param domainId
+	 * @param temperaturePoolId
+	 * @param targetStatePoolId
+	 * @param currentStatePoolId
+	 * @param requestPoolId
+	 * @param dataSet
+	 * @param parameters
+	 * @param initialTargetState
+	 */
+	ThermalComponentCore(object_id_t reportingObjectId, uint8_t domainId,
+	        gp_id_t temperaturePoolId, gp_id_t targetStatePoolId,
+	        gp_id_t currentStatePoolId, gp_id_t requestPoolId,
+			LocalPoolDataSetBase* dataSet, Parameters parameters,
+			StateRequest initialTargetState =
+					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
+
+	void addSensor(AbstractTemperatureSensor* firstRedundantSensor);
+	void addFirstRedundantSensor(
+	        AbstractTemperatureSensor* firstRedundantSensor);
+    void addSecondRedundantSensor(
+            AbstractTemperatureSensor* secondRedundantSensor);
+    void addThermalModule(ThermalModule* thermalModule, Priority priority);
+
+    void setPriority(Priority priority);
+
+	virtual ~ThermalComponentCore();
+
+	virtual HeaterRequest performOperation(uint8_t opCode);
+
+	void markStateIgnored();
+
+	object_id_t getObjectId();
+
+	uint8_t getDomainId() const;
+
+	virtual float getLowerOpLimit();
+
+	ReturnValue_t setTargetState(int8_t newState);
+
+	virtual void setOutputInvalid();
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+protected:
+
+	AbstractTemperatureSensor *sensor = nullptr;
+	AbstractTemperatureSensor *firstRedundantSensor = nullptr;
+	AbstractTemperatureSensor *secondRedundantSensor = nullptr;
+	ThermalModuleIF *thermalModule = nullptr;
+
+	lp_var_t<float> temperature;
+	lp_var_t<int8_t> targetState;
+	lp_var_t<int8_t> currentState;
+	lp_var_t<uint8_t> heaterRequest;
+
+	bool isHeating = false;
+
+	bool isSafeComponent = false;
+
+	float minTemp = 999;
+
+	float maxTemp = AbstractTemperatureSensor::ZERO_KELVIN_C;
+
+	Parameters parameters;
+
+	const uint8_t domainId;
+
+	ThermalMonitorReporter temperatureMonitor;
+
+	virtual float getTemperature();
+	virtual State getState(float temperature, Parameters parameters,
+			int8_t targetState);
+
+	virtual void checkLimits(State state);
+
+	virtual HeaterRequest getHeaterRequest(int8_t targetState,
+			float temperature, Parameters parameters);
+
+	virtual State getIgnoredState(int8_t state);
+
+	void updateMinMaxTemp();
+
+	virtual Parameters getParameters();
+};
+
+#endif /* FSFW_THERMAL_THERMALCOMPONENT_CORE_H_ */
diff --git a/thermal/ThermalComponentIF.h b/thermal/ThermalComponentIF.h
index 522d4e443..16739e362 100644
--- a/thermal/ThermalComponentIF.h
+++ b/thermal/ThermalComponentIF.h
@@ -49,18 +49,18 @@ public:
 		SAFE = 0,             //!< SAFE
 		IDLE,                 //!< IDLE
 		PAYLOAD,              //!< PAYLOAD
-		NUMBER_OF_PRIORITIES          //!< MAX_PRIORITY
+		NUMBER_OF_PRIORITIES  //!< MAX_PRIORITY
 	};
 
 	/**
 	 * The elements are ordered by priority, lowest have highest priority
 	 */
 	enum HeaterRequest {
-		HEATER_REQUEST_EMERGENCY_OFF = 0,          //!< REQUEST_EMERGENCY_OFF
-		HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
-		HEATER_REQUEST_OFF,          //!< REQUEST_OFF
-		HEATER_REQUEST_ON,           //!< REQUEST_ON
-		HEATER_DONT_CARE             //!< DONT_CARE
+		HEATER_REQUEST_EMERGENCY_OFF = 0,   //!< REQUEST_EMERGENCY_OFF
+		HEATER_REQUEST_EMERGENCY_ON,        //!< REQUEST_EMERGENCY_ON
+		HEATER_REQUEST_OFF,                 //!< REQUEST_OFF
+		HEATER_REQUEST_ON,                  //!< REQUEST_ON
+		HEATER_DONT_CARE                    //!< DONT_CARE
 	};
 
 	virtual ~ThermalComponentIF() {
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index c573008e6..2bc1741f6 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -1,28 +1,31 @@
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringMessageContent.h"
 #include "ThermalModule.h"
-
 #include "AbstractTemperatureSensor.h"
 
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
-		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
-		DataSet *dataSet, Parameters parameters,
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringMessageContent.h"
+
+
+ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
+		gp_id_t currentStatePoolId, gp_id_t targetStatePoolId,
+		LocalPoolDataSetBase *dataSet, Parameters parameters,
 		RedundantHeater::Parameters heaterParameters) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters(parameters), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
-				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
-				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
+		oldStrategy(ACTIVE_SINGLE), parameters(parameters),
+		moduleTemperature(moduleTemperaturePoolId, dataSet,
+				PoolVariableIF::VAR_WRITE),
+		currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
 	heater = new RedundantHeater(heaterParameters);
 }
 
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, DataSet* dataSet) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters( { 0, 0 }), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
-				NULL), currentState(PoolVariableIF::INVALID, dataSet,
-				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
-				dataSet, PoolVariableIF::VAR_READ) {
+ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
+		LocalPoolDataSetBase* dataSet) :
+		oldStrategy(ACTIVE_SINGLE), parameters( { 0, 0 }),
+		moduleTemperature(moduleTemperaturePoolId, dataSet,
+				PoolVariableIF::VAR_WRITE),
+		currentState(gp_id_t(), dataSet,
+				PoolVariableIF::VAR_WRITE),
+		targetState(gp_id_t(), dataSet,
+				PoolVariableIF::VAR_READ) {
 }
 
 ThermalModule::~ThermalModule() {
@@ -30,7 +33,7 @@ ThermalModule::~ThermalModule() {
 }
 
 void ThermalModule::performOperation(uint8_t opCode) {
-	if (heater != NULL) {
+	if (heater != nullptr) {
 		heater->performOperation(0);
 	}
 }
@@ -42,7 +45,7 @@ void ThermalModule::performMode(Strategy strategy) {
 	ThermalComponentIF::HeaterRequest componentHeaterRequest =
 			letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
 
-	if (heater == NULL) {
+	if (heater == nullptr) {
 		informComponentsAboutHeaterState(false, NONE);
 		return;
 	}
@@ -53,8 +56,8 @@ void ThermalModule::performMode(Strategy strategy) {
 		//Components overwrite the module request.
 		heating = ((componentHeaterRequest
 				== ThermalComponentIF::HEATER_REQUEST_ON)
-				|| (componentHeaterRequest
-						== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
+				or (componentHeaterRequest
+				== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
 	}
 
 	bool dual = (strategy == ACTIVE_DUAL);
@@ -76,7 +79,7 @@ void ThermalModule::performMode(Strategy strategy) {
 }
 
 float ThermalModule::getTemperature() {
-	return moduleTemperature;
+	return moduleTemperature.value;
 }
 
 void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
@@ -85,7 +88,8 @@ void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
 
 void ThermalModule::registerComponent(ThermalComponentIF* component,
 		ThermalComponentIF::Priority priority) {
-	components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
+	components.push_back(ComponentData( { component, priority,
+		ThermalComponentIF::HEATER_DONT_CARE }));
 }
 
 void ThermalModule::calculateTemperature() {
@@ -94,12 +98,13 @@ void ThermalModule::calculateTemperature() {
 	std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
 	for (; iter != sensors.end(); iter++) {
 		if ((*iter)->isValid()) {
-			moduleTemperature = moduleTemperature + (*iter)->getTemperature();
+			moduleTemperature = moduleTemperature.value +
+					(*iter)->getTemperature();
 			numberOfValidSensors++;
 		}
 	}
 	if (numberOfValidSensors != 0) {
-		moduleTemperature = moduleTemperature / numberOfValidSensors;
+		moduleTemperature = moduleTemperature.value / numberOfValidSensors;
 		moduleTemperature.setValid(PoolVariableIF::VALID);
 	} else {
 		moduleTemperature = INVALID_TEMPERATURE;
@@ -117,9 +122,10 @@ ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
 	return NULL;
 }
 
-ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
-		bool safeOnly) {
-	ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
+ThermalComponentIF::HeaterRequest
+ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly) {
+	ThermalComponentIF::HeaterRequest
+	heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
 
 	survivalTargetTemp = -999;
 	targetTemp = -999;
@@ -224,7 +230,7 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 		limit = survivalTargetTemp;
 	}
 
-	if (moduleTemperature >= limit) {
+	if (moduleTemperature.value >= limit) {
 		currentState = OPERATIONAL;
 	} else {
 		currentState = NON_OPERATIONAL;
@@ -250,15 +256,15 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 }
 
 void ThermalModule::setHeating(bool on) {
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_WRITE);
-	if (on) {
-		writableTargetState = STATE_REQUEST_HEATING;
-	} else {
-		writableTargetState = STATE_REQUEST_PASSIVE;
-	}
-	mySet.commit(PoolVariableIF::VALID);
+//	GlobDataSet mySet;
+//	gp_int8_t writableTargetState(targetState.getDataPoolId(),
+//			&mySet, PoolVariableIF::VAR_WRITE);
+//	if (on) {
+//		writableTargetState = STATE_REQUEST_HEATING;
+//	} else {
+//		writableTargetState = STATE_REQUEST_PASSIVE;
+//	}
+//	mySet.commit(PoolVariableIF::VALID);
 }
 
 void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index 19ab9a549..d1e4fccbf 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -1,16 +1,25 @@
-#ifndef THERMALMODULE_H_
-#define THERMALMODULE_H_
+#ifndef FSFW_THERMAL_THERMALMODULE_H_
+#define FSFW_THERMAL_THERMALMODULE_H_
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PoolVariable.h"
-#include "../devicehandlers/HealthDevice.h"
-#include "../events/EventReportingProxyIF.h"
 #include "ThermalModuleIF.h"
-#include <list>
 #include "tcsDefinitions.h"
 #include "RedundantHeater.h"
+
+//#include "../datapoolglob/GlobalDataSet.h"
+//#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoollocal/LocalPoolDataSetBase.h"
+#include "../datapoollocal/LocalPoolVariable.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../events/EventReportingProxyIF.h"
+
+#include <list>
+
+
 class PowerSwitchIF;
 
+/**
+ * @brief Allows creation of different thermal control domains within a system.
+ */
 class ThermalModule: public ThermalModuleIF {
 	friend class ThermalController;
 public:
@@ -19,11 +28,12 @@ public:
 		float hysteresis;
 	};
 
-	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
-			uint32_t targetStatePoolId, DataSet *dataSet, Parameters parameters,
-			RedundantHeater::Parameters heaterParameters);
+	ThermalModule(gp_id_t moduleTemperaturePoolId, gp_id_t currentStatePoolId,
+			gp_id_t targetStatePoolId, LocalPoolDataSetBase *dataSet,
+			Parameters parameters, RedundantHeater::Parameters heaterParameters);
 
-	ThermalModule(uint32_t moduleTemperaturePoolId, DataSet *dataSet);
+	ThermalModule(gp_id_t moduleTemperaturePoolId,
+			LocalPoolDataSetBase *dataSet);
 
 	virtual ~ThermalModule();
 
@@ -59,20 +69,21 @@ protected:
 
 	Strategy oldStrategy;
 
-	float survivalTargetTemp;
+	float survivalTargetTemp = 0.0;
 
-	float targetTemp;
+	float targetTemp = 0.0;
 
-	bool heating;
+	bool heating = false;
 
 	Parameters parameters;
 
-	db_float_t moduleTemperature;
+	lp_var_t<float> moduleTemperature;
+	//gp_float_t moduleTemperature;
 
-	RedundantHeater *heater;
+	RedundantHeater *heater = nullptr;
 
-	db_int8_t currentState;
-	db_int8_t targetState;
+	lp_var_t<int8_t> currentState;
+	lp_var_t<int8_t> targetState;
 
 	std::list<AbstractTemperatureSensor *> sensors;
 	std::list<ComponentData> components;
@@ -89,4 +100,4 @@ protected:
 	void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
 };
 
-#endif /* THERMALMODULE_H_ */
+#endif /* FSFW_THERMAL_THERMALMODULE_H_ */
diff --git a/thermal/ThermalMonitorReporter.cpp b/thermal/ThermalMonitorReporter.cpp
new file mode 100644
index 000000000..cefc61107
--- /dev/null
+++ b/thermal/ThermalMonitorReporter.cpp
@@ -0,0 +1,75 @@
+#include "ThermalMonitorReporter.h"
+#include "ThermalComponentIF.h"
+
+#include "../monitoring/MonitoringIF.h"
+
+ThermalMonitorReporter::~ThermalMonitorReporter() {
+}
+
+void ThermalMonitorReporter::sendTransitionEvent(float currentValue,
+		ReturnValue_t state) {
+	switch (state) {
+	case MonitoringIF::BELOW_LOW_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_OOL_LOW, state);
+		break;
+	case MonitoringIF::ABOVE_HIGH_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH, state);
+		break;
+	case ThermalComponentIF::BELOW_OPERATIONAL_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_LOW, state);
+		break;
+	case ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_HIGH, state);
+		break;
+	default:
+		break;
+	}
+}
+
+bool ThermalMonitorReporter::isAboveHighLimit() {
+	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+ReturnValue_t ThermalMonitorReporter::translateState(
+		ThermalComponentIF::State state, float sample, float lowerLimit,
+		float upperLimit, bool componentIsOperational) {
+	if (ThermalComponentIF::isIgnoredState(state)) {
+		setToUnchecked();
+		return MonitoringIF::UNCHECKED;
+	}
+	switch (state) {
+	case ThermalComponentIF::OUT_OF_RANGE_LOW:
+		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
+				lowerLimit);
+	case ThermalComponentIF::NON_OPERATIONAL_LOW:
+		if (componentIsOperational) {
+			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT,
+					sample, lowerLimit);
+		} else {
+			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+		}
+	case ThermalComponentIF::OPERATIONAL:
+		return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+	case ThermalComponentIF::NON_OPERATIONAL_HIGH:
+		if (componentIsOperational) {
+			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT,
+					sample, upperLimit);
+		} else {
+			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+		}
+	case ThermalComponentIF::OUT_OF_RANGE_HIGH:
+		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
+				upperLimit);
+	default:
+		//Never reached, all states covered.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
diff --git a/thermal/ThermalMonitorReporter.h b/thermal/ThermalMonitorReporter.h
new file mode 100644
index 000000000..4fb68a991
--- /dev/null
+++ b/thermal/ThermalMonitorReporter.h
@@ -0,0 +1,28 @@
+#ifndef FSFW_THERMAL_THERMALMONITORREPORTER_H_
+#define FSFW_THERMAL_THERMALMONITORREPORTER_H_
+
+#include "ThermalComponentIF.h"
+#include "../monitoring/MonitorReporter.h"
+
+
+/**
+ * @brief   Monitor Reporter implementation for thermal components.
+ */
+class ThermalMonitorReporter: public MonitorReporter<float> {
+public:
+	template<typename ... Args>
+	ThermalMonitorReporter(Args ... args) :
+			MonitorReporter<float>(std::forward<Args>(args)...) {
+	}
+	~ThermalMonitorReporter();
+	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
+			float lowerLimit, float upperLimit,
+			bool componentIsOperational = true);
+
+	bool isAboveHighLimit();
+protected:
+	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
+
+};
+
+#endif /* FSFW_THERMAL_THERMALMONITORREPORTERREPORTER_H_ */
diff --git a/thermal/tcsDefinitions.h b/thermal/tcsDefinitions.h
index ad258ced7..37e5b849d 100644
--- a/thermal/tcsDefinitions.h
+++ b/thermal/tcsDefinitions.h
@@ -2,7 +2,7 @@
 #define TCSDEFINITIONS_H_
 
 
-static const uint32_t INVALID_TEMPERATURE = 999;
+static const float INVALID_TEMPERATURE = 999;
 
 
 #endif /* TCSDEFINITIONS_H_ */

From c5c776e676a6b7c39e9bc8d4535ab9cba836d977 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 18:57:50 +0100
Subject: [PATCH 1097/1774] rtems changes taken over from upstream

---
 osal/rtems/MultiObjectTask.cpp |  5 +++--
 osal/rtems/MultiObjectTask.h   | 20 +++++++-------------
 osal/rtems/Mutex.cpp           | 19 ++++++++++++++++---
 osal/rtems/Mutex.h             |  6 +++---
 osal/rtems/PollingTask.cpp     | 10 +++++-----
 osal/rtems/PollingTask.h       |  4 ++--
 6 files changed, 36 insertions(+), 28 deletions(-)

diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index 8f969a1d1..2342c24c2 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -78,8 +78,9 @@ ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
-	ReturnValue_t result = newObject->initializeAfterTaskCreation();
-	return result;
+	newObject->setTaskIF(this);
+
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 uint32_t MultiObjectTask::getPeriodMs() const {
diff --git a/osal/rtems/MultiObjectTask.h b/osal/rtems/MultiObjectTask.h
index 28d05fb1a..736e79dd1 100644
--- a/osal/rtems/MultiObjectTask.h
+++ b/osal/rtems/MultiObjectTask.h
@@ -1,11 +1,5 @@
-/**
- * @file	MultiObjectTask.h
- * @brief	This file defines the MultiObjectTask class.
- * @date	30.01.2014
- * @author	baetz
- */
-#ifndef MULTIOBJECTTASK_H_
-#define MULTIOBJECTTASK_H_
+#ifndef FSFW_OSAL_RTEMS_MULTIOBJECTTASK_H_
+#define FSFW_OSAL_RTEMS_MULTIOBJECTTASK_H_
 
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../tasks/PeriodicTaskIF.h"
@@ -21,7 +15,7 @@ class ExecutableObjectIF;
  * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
  * 			multiple objects that implement the ExecutableObjectIF interface. The objects must be
  * 			added prior to starting the task.
- *
+ * @author  baetz
  * @ingroup task_handling
  */
 class MultiObjectTask: public TaskBase, public PeriodicTaskIF {
@@ -63,11 +57,11 @@ public:
 	 * @param object Id of the object to add.
 	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
 	 */
-	ReturnValue_t addComponent(object_id_t object);
+	ReturnValue_t addComponent(object_id_t object) override;
 
-	uint32_t getPeriodMs() const;
+	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t sleepFor(uint32_t ms);
+	ReturnValue_t sleepFor(uint32_t ms) override;
 protected:
 	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
 	/**
@@ -110,4 +104,4 @@ protected:
 	void taskFunctionality(void);
 };
 
-#endif /* MULTIOBJECTTASK_H_ */
+#endif /* FSFW_OSAL_RTEMS_MULTIOBJECTTASK_H_ */
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index d8babcde7..9553ac79c 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -1,7 +1,6 @@
 #include "Mutex.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-const uint32_t MutexIF::NO_TIMEOUT = RTEMS_NO_TIMEOUT;
 uint8_t Mutex::count = 0;
 
 Mutex::Mutex() :
@@ -24,8 +23,22 @@ Mutex::~Mutex() {
 	}
 }
 
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	rtems_status_code status = rtems_semaphore_obtain(mutexId, RTEMS_WAIT, timeoutMs);
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType =
+        TimeoutType::BLOCKING, uint32_t timeoutMs) {
+	if(timeoutMs == MutexIF::TimeoutType::BLOCKING) {
+		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+				RTEMS_WAIT, RTEMS_NO_TIMEOUT);
+	}
+	else if(timeoutMs == MutexIF::TimeoutType::POLLING) {
+		timeoutMs = RTEMS_NO_TIMEOUT;
+		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+				RTEMS_NO_WAIT, 0);
+	}
+	else {
+		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+				RTEMS_WAIT, timeoutMs);
+	}
+
 	switch(status){
 	case RTEMS_SUCCESSFUL:
 		//semaphore obtained successfully
diff --git a/osal/rtems/Mutex.h b/osal/rtems/Mutex.h
index 340bb16b7..723682104 100644
--- a/osal/rtems/Mutex.h
+++ b/osal/rtems/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
+#ifndef FRAMEWORK_OSAL_RTEMS_MUTEX_H_
+#define FRAMEWORK_OSAL_RTEMS_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 #include "RtemsBasic.h"
@@ -8,7 +8,7 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs);
+	ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs = 0);
 	ReturnValue_t unlockMutex();
 private:
 	rtems_id mutexId;
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index efb425d97..04191515b 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -1,7 +1,7 @@
-#include "../../tasks/FixedSequenceSlot.h"
+#include "../../devicehandlers/FixedSequenceSlot.h"
 #include "../../objectmanager/SystemObjectIF.h"
-#include "../../osal/rtems/PollingTask.h"
-#include "../../osal/rtems/RtemsBasic.h"
+#include "PollingTask.h"
+#include "RtemsBasic.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include <rtems/bspIo.h>
@@ -73,7 +73,7 @@ ReturnValue_t PollingTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	sif::error << "Component " << std::hex << componentId <<
+	error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
@@ -82,7 +82,7 @@ uint32_t PollingTask::getPeriodMs() const {
 	return pst.getLengthMs();
 }
 
-ReturnValue_t PollingTask::checkAndInitializeSequence() const {
+ReturnValue_t PollingTask::checkSequence() const {
 	return pst.checkSequence();
 }
 
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 1502f0c60..199c34e71 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -1,7 +1,7 @@
 #ifndef POLLINGTASK_H_
 #define POLLINGTASK_H_
 
-#include "../../tasks/FixedSlotSequence.h"
+#include "../../devicehandlers/FixedSlotSequence.h"
 #include "../../tasks/FixedTimeslotTaskIF.h"
 #include "TaskBase.h"
 
@@ -42,7 +42,7 @@ class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
 
 	uint32_t getPeriodMs() const;
 
-	ReturnValue_t checkAndInitializeSequence() const;
+	ReturnValue_t checkSequence() const;
 
 	ReturnValue_t sleepFor(uint32_t ms);
 protected:

From 983556b3b3c70b9d4c337ebfc44cbe0290da96ec Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 5 Dec 2020 01:21:04 +0100
Subject: [PATCH 1098/1774] evil bug fixed

---
 osal/host/MessageQueue.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index bced37139..f1f5867b5 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -34,7 +34,7 @@ ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != 0) {
+	if (this->lastPartner != MessageQueueIF::NO_QUEUE) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
 		return MessageQueueIF::NO_REPLY_PARTNER;
@@ -106,6 +106,7 @@ bool MessageQueue::isDefaultDestinationSet() const {
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
         bool ignoreFault) {
+    message->setSender(sentFrom);
 	if(message->getMessageSize() > message->getMaximumMessageSize()) {
 		// Actually, this should never happen or an error will be emitted
 		// in MessageQueueMessage.
@@ -126,7 +127,6 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		// TODO: Better returnvalue
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
 		MutexHelper mutexLock(targetQueue->queueLock,
 		        MutexIF::TimeoutType::WAITING, 20);
@@ -145,7 +145,6 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	else {
 		return MessageQueueIF::FULL;
 	}
-    message->setSender(sentFrom);
     return HasReturnvaluesIF::RETURN_OK;
 }
 

From c0e9c22f3442086eb773c9f1029f0ad0bcbaa8da Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 5 Dec 2020 10:40:53 +0100
Subject: [PATCH 1099/1774] hotfix for message queue

---
 osal/host/MessageQueue.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index bced37139..d662d782c 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -34,7 +34,7 @@ ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != 0) {
+	if (this->lastPartner != MessageQueueIF::NO_QUEUE) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
 		return MessageQueueIF::NO_REPLY_PARTNER;
@@ -106,6 +106,7 @@ bool MessageQueue::isDefaultDestinationSet() const {
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
         bool ignoreFault) {
+	message->setSender(sentFrom);
 	if(message->getMessageSize() > message->getMaximumMessageSize()) {
 		// Actually, this should never happen or an error will be emitted
 		// in MessageQueueMessage.
@@ -126,7 +127,6 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		// TODO: Better returnvalue
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
 		MutexHelper mutexLock(targetQueue->queueLock,
 		        MutexIF::TimeoutType::WAITING, 20);
@@ -145,7 +145,6 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	else {
 		return MessageQueueIF::FULL;
 	}
-    message->setSender(sentFrom);
     return HasReturnvaluesIF::RETURN_OK;
 }
 

From 6766abc0fa4dcd4bf74e95aa939e36291ed0bced Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 5 Dec 2020 10:41:37 +0100
Subject: [PATCH 1100/1774] changelog update

---
 CHANGELOG | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index a6686478c..07899769c 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,5 +1,8 @@
 ## Changes from ASTP 0.0.1 to 1.0.0
 
+### Host OSAL
+
+- Bugfix in MessageQueue, which caused the sender not to be set properly
 
 ### FreeRTOS OSAL
 

From 248ceebf81e824f337edbb15fa774fb3596289b5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 5 Dec 2020 17:09:49 +0100
Subject: [PATCH 1101/1774] taken over host osal from upstream branch

---
 osal/host/Clock.cpp             |  5 -----
 osal/host/FixedTimeslotTask.cpp | 24 +++++++++++++-----------
 osal/host/FixedTimeslotTask.h   |  2 +-
 osal/host/MessageQueue.cpp      |  5 ++---
 osal/host/Mutex.cpp             | 11 ++---------
 osal/host/Mutex.h               |  8 ++++----
 osal/host/PeriodicTask.cpp      | 15 +++++----------
 osal/host/PeriodicTask.h        |  2 +-
 osal/host/QueueFactory.cpp      |  6 +++++-
 osal/host/QueueMapManager.cpp   | 14 +++-----------
 10 files changed, 36 insertions(+), 56 deletions(-)

diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 17d98ba88..41321eeb5 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -106,11 +106,6 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-uint32_t Clock::getUptimeSeconds() {
-	timeval uptime = getUptime();
-	return uptime.tv_sec;
-}
-
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 	// do some magic with chrono (C++20!)
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 3c31eb760..9e892bb58 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -1,7 +1,9 @@
-#include "FixedTimeslotTask.h"
-#include "Mutex.h"
+#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"
 
@@ -33,18 +35,18 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             ABOVE_NORMAL_PRIORITY_CLASS);
     if(result != 0) {
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with "
-                << "code " << GetLastError() << std::endl;
+        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;
+        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.
+    // TODO: we can just copy and paste the code from the linux OSAL here.
 #endif
 }
 
@@ -58,8 +60,7 @@ FixedTimeslotTask::~FixedTimeslotTask(void) {
 }
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
-    FixedTimeslotTask *originalTask(
-            reinterpret_cast<FixedTimeslotTask*>(argument));
+    FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
 
     if (not originalTask->started) {
         // we have to suspend/block here until the task is started.
@@ -114,8 +115,9 @@ void FixedTimeslotTask::taskFunctionality() {
         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());
+            // this gives us the time to wait:
+            interval = chron_ms(
+                    this->pollingSeqTable.getIntervalToPreviousSlotMs());
             delayForInterval(&currentStartTime, interval);
             //TODO deadline missed check
         }
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index 9985e2ee6..f3fffd0f0 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -74,7 +74,7 @@ protected:
     //!< Typedef for the List of objects.
     typedef std::vector<ExecutableObjectIF*> ObjectList;
     std::thread mainThread;
-    std::atomic<bool> terminateThread = false;
+    std::atomic<bool> terminateThread { false };
 
     //! Polling sequence table which contains the object to execute
     //! and information like the timeslots and the passed execution step.
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index bced37139..d662d782c 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -34,7 +34,7 @@ ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != 0) {
+	if (this->lastPartner != MessageQueueIF::NO_QUEUE) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
 		return MessageQueueIF::NO_REPLY_PARTNER;
@@ -106,6 +106,7 @@ bool MessageQueue::isDefaultDestinationSet() const {
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
         bool ignoreFault) {
+	message->setSender(sentFrom);
 	if(message->getMessageSize() > message->getMaximumMessageSize()) {
 		// Actually, this should never happen or an error will be emitted
 		// in MessageQueueMessage.
@@ -126,7 +127,6 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		// TODO: Better returnvalue
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
 		MutexHelper mutexLock(targetQueue->queueLock,
 		        MutexIF::TimeoutType::WAITING, 20);
@@ -145,7 +145,6 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	else {
 		return MessageQueueIF::FULL;
 	}
-    message->setSender(sentFrom);
     return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index 8471cab80..ad8873dfc 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -4,21 +4,18 @@
 Mutex::Mutex() {}
 
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
-	if(timeoutMs == MutexIF::BLOCKING) {
+	if(timeoutType == MutexIF::BLOCKING) {
 		mutex.lock();
-		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	else if(timeoutMs == MutexIF::POLLING) {
+	else if(timeoutType == 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;
 		}
 	}
@@ -26,11 +23,7 @@ ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
 }
 
 ReturnValue_t Mutex::unlockMutex() {
-	if(not locked) {
-		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	}
 	mutex.unlock();
-	locked = false;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index af56b8f79..c0fa19b78 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef FSFW_OSAL_HOST_MUTEX_H_
-#define FSFW_OSAL_HOST_MUTEX_H_
+#ifndef FSFW_OSAL_HOSTED_MUTEX_H_
+#define FSFW_OSAL_HOSTED_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 
@@ -22,8 +22,8 @@ public:
 
 	std::timed_mutex* getMutexHandle();
 private:
-	bool locked = false;
+	//bool locked = false;
 	std::timed_mutex mutex;
 };
 
-#endif /* FSFW_OSAL_HOST_MUTEX_H_ */
+#endif /* FSFW_OSAL_HOSTED_MUTEX_H_ */
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index f7807a171..5662c7cca 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -89,16 +89,16 @@ ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
 }
 
 void PeriodicTask::taskFunctionality() {
+    for (const auto& object: objectList) {
+        object->initializeAfterTaskCreation();
+    }
+
 	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 };
-
-	for (const auto& object: objectList) {
-	    object->initializeAfterTaskCreation();
-	}
+	auto nextStartTime { currentStartTime };
 
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
@@ -109,10 +109,6 @@ void PeriodicTask::taskFunctionality() {
 			object->performOperation();
 		}
 		if(not delayForInterval(&currentStartTime, periodChrono)) {
-#ifdef DEBUG
-			sif::warning << "PeriodicTask: " << taskName <<
-					" missed deadline!\n" << std::flush;
-#endif
 			if(deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
@@ -126,7 +122,6 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	if (newObject == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	newObject->setTaskIF(this);
 	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/host/PeriodicTask.h b/osal/host/PeriodicTask.h
index 7689788ac..00cb6a24e 100644
--- a/osal/host/PeriodicTask.h
+++ b/osal/host/PeriodicTask.h
@@ -69,7 +69,7 @@ protected:
 	//!< Typedef for the List of objects.
 	typedef std::vector<ExecutableObjectIF*> ObjectList;
 	std::thread mainThread;
-	std::atomic<bool> terminateThread = false;
+	std::atomic<bool> terminateThread { false };
 
 	/**
 	 * @brief	This attribute holds a list of objects to be executed.
diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
index 7feb1ad67..1a679c96c 100644
--- a/osal/host/QueueFactory.cpp
+++ b/osal/host/QueueFactory.cpp
@@ -1,7 +1,11 @@
+
 #include "MessageQueue.h"
-#include "../../ipc/QueueFactory.h"
+
 #include "../../ipc/MessageQueueSenderIF.h"
+#include "../../ipc/MessageQueueMessageIF.h"
+#include "../../ipc/QueueFactory.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
+
 #include <cstring>
 
 QueueFactory* QueueFactory::factoryInstance = nullptr;
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index c3d945848..621f46bce 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -44,17 +44,9 @@ MessageQueueIF* QueueMapManager::getMessageQueue(
 		return queueIter->second;
 	}
 	else {
-	    if(messageQueueId == MessageQueueIF::NO_QUEUE) {
-	        sif::error << "QueueMapManager::getQueueHandle: Configuration"
-	                << " error, NO_QUEUE was passed to this function!"
-	                << std::endl;
-	    }
-	    else {
-	        sif::warning << "QueueMapManager::getQueueHandle: The ID "
-	                << messageQueueId << " does not exists in the map."
-	                << std::endl;
-	    }
-	    return nullptr;
+		sif::warning << "QueueMapManager::getQueueHandle: The ID " <<
+				messageQueueId << " does not exists in the map" << std::endl;
+		return nullptr;
 	}
 }
 

From 89e80beb62f8f52625a92b397cb2d4b16429c12b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 5 Dec 2020 17:10:36 +0100
Subject: [PATCH 1102/1774] task if set now

---
 osal/host/PeriodicTask.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 5662c7cca..bfa6c3fd6 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -122,6 +122,7 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	if (newObject == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	newObject->setTaskIF(this);
 	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }

From bb11bc5685e54366c819803c8ec5655ba4acdc4d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 5 Dec 2020 17:11:34 +0100
Subject: [PATCH 1103/1774] task if is set now

---
 osal/host/PeriodicTask.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 5662c7cca..bfa6c3fd6 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -122,6 +122,7 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	if (newObject == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	newObject->setTaskIF(this);
 	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }

From 5e234f1e23e82c98a18f7f82c8ff37d66ed98f5e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 7 Dec 2020 01:40:10 +0100
Subject: [PATCH 1104/1774] cmake init, printChar tests

---
 CMakeLists.txt                              | 58 +++++++++++++++++++++
 action/CMakeLists.txt                       |  7 +++
 container/CMakeLists.txt                    |  5 ++
 controller/CMakeLists.txt                   |  4 ++
 coordinates/CMakeLists.txt                  |  5 ++
 datalinklayer/CMakeLists.txt                | 12 +++++
 datapool/CMakeLists.txt                     | 11 ++++
 defaultcfg/fsfwconfig/CMakeLists.txt        | 15 ++++++
 devicehandlers/CMakeLists.txt               | 11 ++++
 events/CMakeLists.txt                       |  8 +++
 events/eventmatching/CMakeLists.txt         |  7 +++
 fdir/CMakeLists.txt                         |  6 +++
 globalfunctions/CMakeLists.txt              | 12 +++++
 globalfunctions/math/CMakeLists.txt         |  4 ++
 health/CMakeLists.txt                       |  6 +++
 internalError/CMakeLists.txt                |  4 ++
 ipc/CMakeLists.txt                          |  6 +++
 memory/CMakeLists.txt                       |  5 ++
 modes/CMakeLists.txt                        |  5 ++
 monitoring/CMakeLists.txt                   |  5 ++
 objectmanager/CMakeLists.txt                |  5 ++
 osal/CMakeLists.txt                         | 28 ++++++++++
 osal/host/CMakeLists.txt                    | 13 +++++
 osal/windows/CMakeLists.txt                 | 11 ++++
 parameters/CMakeLists.txt                   |  6 +++
 power/CMakeLists.txt                        |  7 +++
 pus/CMakeLists.txt                          | 11 ++++
 rmap/CMakeLists.txt                         |  7 +++
 serialize/CMakeLists.txt                    |  4 ++
 serviceinterface/CMakeLists.txt             |  5 ++
 serviceinterface/ServiceInterfaceBuffer.cpp |  2 +-
 storagemanager/CMakeLists.txt               |  5 ++
 subsystem/CMakeLists.txt                    |  7 +++
 subsystem/modes/CMakeLists.txt              |  5 ++
 tasks/CMakeLists.txt                        |  5 ++
 tcdistribution/CMakeLists.txt               |  7 +++
 thermal/CMakeLists.txt                      | 10 ++++
 timemanager/CMakeLists.txt                  |  8 +++
 tmstorage/CMakeLists.txt                    |  4 ++
 tmtcpacket/CMakeLists.txt                   |  8 +++
 tmtcpacket/packetmatcher/CMakeLists.txt     |  4 ++
 tmtcpacket/pus/CMakeLists.txt               |  8 +++
 tmtcservices/CMakeLists.txt                 |  9 ++++
 43 files changed, 374 insertions(+), 1 deletion(-)
 create mode 100644 CMakeLists.txt
 create mode 100644 action/CMakeLists.txt
 create mode 100644 container/CMakeLists.txt
 create mode 100644 controller/CMakeLists.txt
 create mode 100644 coordinates/CMakeLists.txt
 create mode 100644 datalinklayer/CMakeLists.txt
 create mode 100644 datapool/CMakeLists.txt
 create mode 100644 defaultcfg/fsfwconfig/CMakeLists.txt
 create mode 100644 devicehandlers/CMakeLists.txt
 create mode 100644 events/CMakeLists.txt
 create mode 100644 events/eventmatching/CMakeLists.txt
 create mode 100644 fdir/CMakeLists.txt
 create mode 100644 globalfunctions/CMakeLists.txt
 create mode 100644 globalfunctions/math/CMakeLists.txt
 create mode 100644 health/CMakeLists.txt
 create mode 100644 internalError/CMakeLists.txt
 create mode 100644 ipc/CMakeLists.txt
 create mode 100644 memory/CMakeLists.txt
 create mode 100644 modes/CMakeLists.txt
 create mode 100644 monitoring/CMakeLists.txt
 create mode 100644 objectmanager/CMakeLists.txt
 create mode 100644 osal/CMakeLists.txt
 create mode 100644 osal/host/CMakeLists.txt
 create mode 100644 osal/windows/CMakeLists.txt
 create mode 100644 parameters/CMakeLists.txt
 create mode 100644 power/CMakeLists.txt
 create mode 100644 pus/CMakeLists.txt
 create mode 100644 rmap/CMakeLists.txt
 create mode 100644 serialize/CMakeLists.txt
 create mode 100644 serviceinterface/CMakeLists.txt
 create mode 100644 storagemanager/CMakeLists.txt
 create mode 100644 subsystem/CMakeLists.txt
 create mode 100644 subsystem/modes/CMakeLists.txt
 create mode 100644 tasks/CMakeLists.txt
 create mode 100644 tcdistribution/CMakeLists.txt
 create mode 100644 thermal/CMakeLists.txt
 create mode 100644 timemanager/CMakeLists.txt
 create mode 100644 tmstorage/CMakeLists.txt
 create mode 100644 tmtcpacket/CMakeLists.txt
 create mode 100644 tmtcpacket/packetmatcher/CMakeLists.txt
 create mode 100644 tmtcpacket/pus/CMakeLists.txt
 create mode 100644 tmtcservices/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 000000000..eff272dfb
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,58 @@
+cmake_minimum_required(VERSION 3.13)
+
+set(LIB_FSFW_NAME fsfw)
+add_library(${LIB_FSFW_NAME})
+
+option(FSFW_USE_RMAP "Compile with RMAP" ON)
+
+add_subdirectory(action)
+add_subdirectory(container)
+add_subdirectory(controller)
+add_subdirectory(coordinates)
+add_subdirectory(datalinklayer)
+add_subdirectory(datapool)
+add_subdirectory(devicehandlers)
+add_subdirectory(events)
+add_subdirectory(fdir)
+add_subdirectory(globalfunctions)
+add_subdirectory(health)
+add_subdirectory(internalError)
+add_subdirectory(ipc)
+add_subdirectory(memory)
+add_subdirectory(modes)
+add_subdirectory(monitoring)
+add_subdirectory(objectmanager)
+add_subdirectory(osal)
+add_subdirectory(parameters)
+add_subdirectory(power)
+add_subdirectory(pus)
+
+if(FSFW_USE_RMAP)
+add_subdirectory(rmap)
+endif()
+
+add_subdirectory(serialize)
+add_subdirectory(serviceinterface)
+add_subdirectory(storagemanager)
+add_subdirectory(subsystem)
+add_subdirectory(tasks)
+add_subdirectory(tcdistribution)
+add_subdirectory(thermal)
+add_subdirectory(timemanager)
+add_subdirectory(tmstorage)
+add_subdirectory(tmtcpacket)
+add_subdirectory(tmtcservices)
+
+# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
+# If this is not given, we include the default configuration and emit a warning.
+if(NOT FSFW_CONFIG_PATH)
+message(WARNING "Flight Software Framework configuration path not set!")
+message(WARNING "Setting default configuration!")
+add_subdirectory(defaultcfg/fsfwconfig)
+endif()
+
+# Required include paths to compile the FSFW
+target_include_directories(${LIB_FSFW_NAME} 
+	INTERFACE 
+		${FSFW_CONFIG_PATH}
+)
diff --git a/action/CMakeLists.txt b/action/CMakeLists.txt
new file mode 100644
index 000000000..a62d4044b
--- /dev/null
+++ b/action/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ActionHelper.cpp
+		ActionMessage.cpp
+		CommandActionHelper.cpp
+		SimpleActionHelper.cpp
+)
\ No newline at end of file
diff --git a/container/CMakeLists.txt b/container/CMakeLists.txt
new file mode 100644
index 000000000..904cde55b
--- /dev/null
+++ b/container/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		SharedRingBuffer.cpp
+		SimpleRingBuffer.cpp
+)
\ No newline at end of file
diff --git a/controller/CMakeLists.txt b/controller/CMakeLists.txt
new file mode 100644
index 000000000..6f6607388
--- /dev/null
+++ b/controller/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ControllerBase.cpp
+)
\ No newline at end of file
diff --git a/coordinates/CMakeLists.txt b/coordinates/CMakeLists.txt
new file mode 100644
index 000000000..a1fa1e52b
--- /dev/null
+++ b/coordinates/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CoordinateTransformations.cpp
+		Sgp4Propagator.cpp
+)
\ No newline at end of file
diff --git a/datalinklayer/CMakeLists.txt b/datalinklayer/CMakeLists.txt
new file mode 100644
index 000000000..148e7c5de
--- /dev/null
+++ b/datalinklayer/CMakeLists.txt
@@ -0,0 +1,12 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clcw.cpp
+		DataLinkLayer.cpp
+		Farm1StateLockout.cpp
+		Farm1StateOpen.cpp
+		Farm1StateWait.cpp
+		MapPacketExtraction.cpp
+		TcTransferFrame.cpp
+		TcTransferFrameLocal.cpp
+		VirtualChannelReception.cpp
+)
\ No newline at end of file
diff --git a/datapool/CMakeLists.txt b/datapool/CMakeLists.txt
new file mode 100644
index 000000000..e741f6a13
--- /dev/null
+++ b/datapool/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ControllerSet.cpp
+		DataPool.cpp
+		DataPoolAdmin.cpp
+		DataPoolParameterWrapper.cpp
+		DataSet.cpp
+		HkSwitchHelper.cpp
+		PoolEntry.cpp
+		PoolRawAccess.cpp
+)
\ No newline at end of file
diff --git a/defaultcfg/fsfwconfig/CMakeLists.txt b/defaultcfg/fsfwconfig/CMakeLists.txt
new file mode 100644
index 000000000..b8b41c930
--- /dev/null
+++ b/defaultcfg/fsfwconfig/CMakeLists.txt
@@ -0,0 +1,15 @@
+target_sources(${TARGET_NAME} 
+	PRIVATE
+)
+
+# Add include paths for the executable
+target_include_directories(${TARGET_NAME} 
+	PUBLIC 
+		${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+# Add include paths for the FSFW library
+target_include_directories(${LIB_FSFW_NAME} 
+	PUBLIC
+		${CMAKE_CURRENT_SOURCE_DIR}
+)
\ No newline at end of file
diff --git a/devicehandlers/CMakeLists.txt b/devicehandlers/CMakeLists.txt
new file mode 100644
index 000000000..50c1008fb
--- /dev/null
+++ b/devicehandlers/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		AssemblyBase.cpp
+		ChildHandlerBase.cpp
+		ChildHandlerFDIR.cpp
+		DeviceHandlerBase.cpp
+		DeviceHandlerFailureIsolation.cpp
+		DeviceHandlerMessage.cpp
+		DeviceTmReportingWrapper.cpp
+		HealthDevice.cpp
+)
\ No newline at end of file
diff --git a/events/CMakeLists.txt b/events/CMakeLists.txt
new file mode 100644
index 000000000..9e63deb89
--- /dev/null
+++ b/events/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Event.cpp
+		EventManager.cpp
+		EventMessage.cpp
+)
+
+add_subdirectory(eventmatching)
\ No newline at end of file
diff --git a/events/eventmatching/CMakeLists.txt b/events/eventmatching/CMakeLists.txt
new file mode 100644
index 000000000..81ff9ed84
--- /dev/null
+++ b/events/eventmatching/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		EventIdRangeMatcher.cpp
+		EventMatchTree.cpp
+		ReporterRangeMatcher.cpp
+		SeverityRangeMatcher.cpp
+)
\ No newline at end of file
diff --git a/fdir/CMakeLists.txt b/fdir/CMakeLists.txt
new file mode 100644
index 000000000..f5ffbba8d
--- /dev/null
+++ b/fdir/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		EventCorrelation.cpp
+		FailureIsolationBase.cpp
+		FaultCounter.cpp
+)
\ No newline at end of file
diff --git a/globalfunctions/CMakeLists.txt b/globalfunctions/CMakeLists.txt
new file mode 100644
index 000000000..2b3dcf8ed
--- /dev/null
+++ b/globalfunctions/CMakeLists.txt
@@ -0,0 +1,12 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		arrayprinter.cpp
+		AsciiConverter.cpp
+		CRC.cpp
+		DleEncoder.cpp
+		PeriodicOperationDivider.cpp
+		timevalOperations.cpp
+		Type.cpp
+)
+
+add_subdirectory(math)
\ No newline at end of file
diff --git a/globalfunctions/math/CMakeLists.txt b/globalfunctions/math/CMakeLists.txt
new file mode 100644
index 000000000..a9c4ded78
--- /dev/null
+++ b/globalfunctions/math/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		QuaternionOperations.cpp
+)
diff --git a/health/CMakeLists.txt b/health/CMakeLists.txt
new file mode 100644
index 000000000..d5f3ccd30
--- /dev/null
+++ b/health/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		HealthHelper.cpp
+		HealthMessage.cpp
+		HealthTable.cpp	
+)
\ No newline at end of file
diff --git a/internalError/CMakeLists.txt b/internalError/CMakeLists.txt
new file mode 100644
index 000000000..2b383914c
--- /dev/null
+++ b/internalError/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		InternalErrorReporter.cpp
+)
\ No newline at end of file
diff --git a/ipc/CMakeLists.txt b/ipc/CMakeLists.txt
new file mode 100644
index 000000000..6a3afe33e
--- /dev/null
+++ b/ipc/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CommandMessage.cpp
+		CommandMessageCleaner.cpp
+		MessageQueueMessage.cpp
+)
\ No newline at end of file
diff --git a/memory/CMakeLists.txt b/memory/CMakeLists.txt
new file mode 100644
index 000000000..9edb9031f
--- /dev/null
+++ b/memory/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		MemoryHelper.cpp
+		MemoryMessage.cpp
+)
\ No newline at end of file
diff --git a/modes/CMakeLists.txt b/modes/CMakeLists.txt
new file mode 100644
index 000000000..8e5c719bc
--- /dev/null
+++ b/modes/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ModeHelper.cpp
+		ModeMessage.cpp
+)
\ No newline at end of file
diff --git a/monitoring/CMakeLists.txt b/monitoring/CMakeLists.txt
new file mode 100644
index 000000000..d26e807c3
--- /dev/null
+++ b/monitoring/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		LimitViolationReporter.cpp
+		MonitoringMessage.cpp
+)
\ No newline at end of file
diff --git a/objectmanager/CMakeLists.txt b/objectmanager/CMakeLists.txt
new file mode 100644
index 000000000..72aaec896
--- /dev/null
+++ b/objectmanager/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ObjectManager.cpp
+		SystemObject.cpp
+)
\ No newline at end of file
diff --git a/osal/CMakeLists.txt b/osal/CMakeLists.txt
new file mode 100644
index 000000000..d7aa13034
--- /dev/null
+++ b/osal/CMakeLists.txt
@@ -0,0 +1,28 @@
+# Check the OS_FSFW variable
+if(${OS_FSFW} STREQUAL "freertos")
+	add_subdirectory(FreeRTOS)
+elseif(${OS_FSFW} STREQUAL "rtems")
+	add_subdirectory(rtems)
+elseif(${OS_FSFW} STREQUAL "linux")
+	add_subdirectory(linux)
+elseif(${OS_FSFW} STREQUAL "host")
+	add_subdirectory(host)
+	if (WIN32)
+		add_subdirectory(windows)
+	endif ()
+
+else()
+
+	message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
+	# Not set. Assumuing this is a host build, try to determine host OS
+	if (WIN32)
+		add_subdirectory(host)
+		add_subdirectory(windows)
+	elseif (UNIX)
+		add_subdirectory(linux)
+	else ()
+		# MacOS or other OSes have not been tested yet / are not supported.
+		message(FATAL_ERROR "The host OS could not be determined! Aborting.")
+	endif()
+
+endif()
\ No newline at end of file
diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
new file mode 100644
index 000000000..3efd91d2e
--- /dev/null
+++ b/osal/host/CMakeLists.txt
@@ -0,0 +1,13 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		FixedTimeslotTask.cpp
+		MessageQueue.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PeriodicTask.cpp
+		QueueFactory.cpp
+		QueueMapManager.cpp
+		SemaphoreFactory.cpp
+		TaskFactory.cpp
+)
\ No newline at end of file
diff --git a/osal/windows/CMakeLists.txt b/osal/windows/CMakeLists.txt
new file mode 100644
index 000000000..b6e76d6a3
--- /dev/null
+++ b/osal/windows/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		TcWinUdpPollingTask.cpp
+		TmTcWinUdpBridge.cpp
+)
+
+target_link_libraries(${LIB_FSFW_NAME} 
+	PRIVATE
+		wsock32 
+		ws2_32
+)
\ No newline at end of file
diff --git a/parameters/CMakeLists.txt b/parameters/CMakeLists.txt
new file mode 100644
index 000000000..fb5e45900
--- /dev/null
+++ b/parameters/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ParameterHelper.cpp
+		ParameterMessage.cpp
+		ParameterWrapper.cpp
+)
\ No newline at end of file
diff --git a/power/CMakeLists.txt b/power/CMakeLists.txt
new file mode 100644
index 000000000..1c625db11
--- /dev/null
+++ b/power/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Fuse.cpp
+		PowerComponent.cpp
+		PowerSensor.cpp
+		PowerSwitcher.cpp
+)
\ No newline at end of file
diff --git a/pus/CMakeLists.txt b/pus/CMakeLists.txt
new file mode 100644
index 000000000..758c26293
--- /dev/null
+++ b/pus/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CService200ModeCommanding.cpp
+		CService201HealthCommanding.cpp
+		Service17Test.cpp
+		Service1TelecommandVerification.cpp
+		Service2DeviceAccess.cpp
+		Service5EventReporting.cpp
+		Service8FunctionManagement.cpp
+		Service9TimeManagement.cpp
+)
\ No newline at end of file
diff --git a/rmap/CMakeLists.txt b/rmap/CMakeLists.txt
new file mode 100644
index 000000000..78c99e420
--- /dev/null
+++ b/rmap/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		RMAP.cpp
+		RMAPCookie.cpp
+		RmapDeviceCommunicationIF.cpp
+)
+
diff --git a/serialize/CMakeLists.txt b/serialize/CMakeLists.txt
new file mode 100644
index 000000000..fc2387e80
--- /dev/null
+++ b/serialize/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		SerialBufferAdapter.cpp
+)
\ No newline at end of file
diff --git a/serviceinterface/CMakeLists.txt b/serviceinterface/CMakeLists.txt
new file mode 100644
index 000000000..d84adbeb4
--- /dev/null
+++ b/serviceinterface/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ServiceInterfaceStream.cpp
+		ServiceInterfaceBuffer.cpp
+)
\ No newline at end of file
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 68fc4dec3..bc360334d 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -4,7 +4,7 @@
 #include <inttypes.h>
 
 // to be implemented by bsp
-extern "C" void printChar(const char*, bool errStream);
+/*extern "C" */void printChar(const char*, bool errStream);
 
 #ifndef UT699
 
diff --git a/storagemanager/CMakeLists.txt b/storagemanager/CMakeLists.txt
new file mode 100644
index 000000000..57c921952
--- /dev/null
+++ b/storagemanager/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ConstStorageAccessor.cpp
+		StorageAccessor.cpp
+)
\ No newline at end of file
diff --git a/subsystem/CMakeLists.txt b/subsystem/CMakeLists.txt
new file mode 100644
index 000000000..5c98ee707
--- /dev/null
+++ b/subsystem/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Subsystem.cpp
+		SubsystemBase.cpp
+)
+
+add_subdirectory(modes)
\ No newline at end of file
diff --git a/subsystem/modes/CMakeLists.txt b/subsystem/modes/CMakeLists.txt
new file mode 100644
index 000000000..6ac6a293a
--- /dev/null
+++ b/subsystem/modes/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ModeSequenceMessage.cpp
+		ModeStore.cpp
+)
diff --git a/tasks/CMakeLists.txt b/tasks/CMakeLists.txt
new file mode 100644
index 000000000..1964bb4e6
--- /dev/null
+++ b/tasks/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		FixedSequenceSlot.cpp
+		FixedSlotSequence.cpp
+)
\ No newline at end of file
diff --git a/tcdistribution/CMakeLists.txt b/tcdistribution/CMakeLists.txt
new file mode 100644
index 000000000..17dc186c3
--- /dev/null
+++ b/tcdistribution/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CCSDSDistributor.cpp
+		PUSDistributor.cpp
+		TcDistributor.cpp
+		TcPacketCheck.cpp
+)
diff --git a/thermal/CMakeLists.txt b/thermal/CMakeLists.txt
new file mode 100644
index 000000000..67664fbe5
--- /dev/null
+++ b/thermal/CMakeLists.txt
@@ -0,0 +1,10 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		AbstractTemperatureSensor.cpp
+		CoreComponent.cpp
+		Heater.cpp
+		RedundantHeater.cpp
+		ThermalComponent.cpp
+		ThermalModule.cpp
+		ThermalMonitor.cpp
+)
diff --git a/timemanager/CMakeLists.txt b/timemanager/CMakeLists.txt
new file mode 100644
index 000000000..3367775f4
--- /dev/null
+++ b/timemanager/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CCSDSTime.cpp
+		Countdown.cpp
+		Stopwatch.cpp
+		TimeMessage.cpp
+		TimeStamper.cpp
+)
diff --git a/tmstorage/CMakeLists.txt b/tmstorage/CMakeLists.txt
new file mode 100644
index 000000000..7990d85a1
--- /dev/null
+++ b/tmstorage/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		TmStoreMessage.cpp
+)
diff --git a/tmtcpacket/CMakeLists.txt b/tmtcpacket/CMakeLists.txt
new file mode 100644
index 000000000..fe3d2a4d2
--- /dev/null
+++ b/tmtcpacket/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		SpacePacket.cpp
+		SpacePacketBase.cpp
+)
+
+add_subdirectory(packetmatcher)
+add_subdirectory(pus)
\ No newline at end of file
diff --git a/tmtcpacket/packetmatcher/CMakeLists.txt b/tmtcpacket/packetmatcher/CMakeLists.txt
new file mode 100644
index 000000000..e9a8d03bb
--- /dev/null
+++ b/tmtcpacket/packetmatcher/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		PacketMatchTree.cpp
+)
diff --git a/tmtcpacket/pus/CMakeLists.txt b/tmtcpacket/pus/CMakeLists.txt
new file mode 100644
index 000000000..fcfc82d2c
--- /dev/null
+++ b/tmtcpacket/pus/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		TcPacketBase.cpp
+		TcPacketStored.cpp
+		TmPacketBase.cpp
+		TmPacketMinimal.cpp
+		TmPacketStored.cpp
+)
diff --git a/tmtcservices/CMakeLists.txt b/tmtcservices/CMakeLists.txt
new file mode 100644
index 000000000..c30af214f
--- /dev/null
+++ b/tmtcservices/CMakeLists.txt
@@ -0,0 +1,9 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CommandingServiceBase.cpp
+		PusServiceBase.cpp
+		PusVerificationReport.cpp
+		TmTcBridge.cpp
+		TmTcMessage.cpp
+		VerificationReporter.cpp
+)
\ No newline at end of file

From 33d4b574001e89828c044eff295ca0a20295e549 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 7 Dec 2020 02:03:42 +0100
Subject: [PATCH 1105/1774] additional build option

---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index eff272dfb..9973c0ec0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,6 +4,7 @@ set(LIB_FSFW_NAME fsfw)
 add_library(${LIB_FSFW_NAME})
 
 option(FSFW_USE_RMAP "Compile with RMAP" ON)
+option(FSFW_USE_DATALINKLAYER "Compile with Data Link Layer" ON)
 
 add_subdirectory(action)
 add_subdirectory(container)

From c4ba243885cf912eb940e0442bb2728802eac46b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 7 Dec 2020 12:17:02 +0100
Subject: [PATCH 1106/1774] small bugfixes

---
 osal/host/CMakeLists.txt                    | 10 +++++++++-
 serviceinterface/ServiceInterfaceBuffer.cpp |  2 +-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
index 3efd91d2e..d54cfac8b 100644
--- a/osal/host/CMakeLists.txt
+++ b/osal/host/CMakeLists.txt
@@ -10,4 +10,12 @@ target_sources(${LIB_FSFW_NAME}
 		QueueMapManager.cpp
 		SemaphoreFactory.cpp
 		TaskFactory.cpp
-)
\ No newline at end of file
+)
+
+if(UNIX)
+	target_link_libraries(${LIB_FSFW_NAME} 
+	PRIVATE
+		pthread
+		rt
+	)
+endif()
\ No newline at end of file
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index bc360334d..68fc4dec3 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -4,7 +4,7 @@
 #include <inttypes.h>
 
 // to be implemented by bsp
-/*extern "C" */void printChar(const char*, bool errStream);
+extern "C" void printChar(const char*, bool errStream);
 
 #ifndef UT699
 

From 489a2097b850313154866cf4d7bbfbc09320a5b5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 7 Dec 2020 12:25:30 +0100
Subject: [PATCH 1107/1774] fix for host osal linux

---
 osal/CMakeLists.txt | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/osal/CMakeLists.txt b/osal/CMakeLists.txt
index d7aa13034..02ff24057 100644
--- a/osal/CMakeLists.txt
+++ b/osal/CMakeLists.txt
@@ -9,6 +9,12 @@ elseif(${OS_FSFW} STREQUAL "host")
 	add_subdirectory(host)
 	if (WIN32)
 		add_subdirectory(windows)
+	elseif(UNIX)
+		target_sources(${LIB_FSFW_NAME}
+			PUBLIC
+				linux/TcUnixUdpPollingTask.cpp
+				linux/TmTcUnixUdpBridge.cpp
+		)
 	endif ()
 
 else()

From d93a8692e08abbe7926955ffdaa95ad569c372f9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 7 Dec 2020 12:59:09 +0100
Subject: [PATCH 1108/1774] cmakelists update

---
 CMakeLists.txt            | 26 ++++++++++++++++++++++++++
 osal/host/CMakeLists.txt  |  2 +-
 osal/linux/CMakeLists.txt | 25 +++++++++++++++++++++++++
 3 files changed, 52 insertions(+), 1 deletion(-)
 create mode 100644 osal/linux/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9973c0ec0..669283c74 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,6 +3,32 @@ cmake_minimum_required(VERSION 3.13)
 set(LIB_FSFW_NAME fsfw)
 add_library(${LIB_FSFW_NAME})
 
+# Set options for FSFW OSAL selection.
+if(UNIX)
+set(OS_FSFW  "linux" CACHE STRING "OS abstraction layer used in the FSFW")
+elseif(WIN32)
+set(OS_FSFW  "host" CACHE STRING "OS abstraction layer used in the FSFW")
+endif()
+
+set_property(CACHE OS_FSFW PROPERTY STRINGS host linux rtems freertos)
+
+if(${OS_FSFW} STREQUAL host)
+set(OS_FSFW_NAME "Host")
+elseif(${OS_FSFW} STREQUAL linux)
+set(OS_FSFW_NAME "Linux")
+elseif(${OS_FSFW} STREQUAL  freertos)
+set(OS_FSFW_NAME "FreeRTOS")
+elseif(${OS_FSFW} STREQUAL rtems)
+set(OS_FSFW_NAME "RTEMS")
+else()
+message(WARNING "Invalid operating system for FSFW specified! Setting to host..")
+set(OS_FSFW_NAME "Host")
+set(OS_FSFW "host")
+endif()
+
+message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system")
+
+# Options to exclude parts of the FSFW from compilation.
 option(FSFW_USE_RMAP "Compile with RMAP" ON)
 option(FSFW_USE_DATALINKLAYER "Compile with Data Link Layer" ON)
 
diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
index d54cfac8b..d73e6f275 100644
--- a/osal/host/CMakeLists.txt
+++ b/osal/host/CMakeLists.txt
@@ -13,9 +13,9 @@ target_sources(${LIB_FSFW_NAME}
 )
 
 if(UNIX)
+	add_definitions(-pthread)
 	target_link_libraries(${LIB_FSFW_NAME} 
 	PRIVATE
-		pthread
 		rt
 	)
 endif()
\ No newline at end of file
diff --git a/osal/linux/CMakeLists.txt b/osal/linux/CMakeLists.txt
new file mode 100644
index 000000000..c0096e428
--- /dev/null
+++ b/osal/linux/CMakeLists.txt
@@ -0,0 +1,25 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		BinarySemaphore.cpp
+		CountingSemaphore.cpp
+		FixedTimeslotTask.cpp
+		InternalErrorCodes.cpp
+		MessageQueue.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PeriodicPosixTask.cpp
+		PosixThread.cpp
+		QueueFactory.cpp
+		SemaphoreFactory.cpp
+		TaskFactory.cpp
+		TcUnixUdpPollingTask.cpp
+		TmTcUnixUdpBridge.cpp
+		Timer.cpp
+)
+
+target_link_libraries(${LIB_FSFW_NAME} 
+	PRIVATE
+		rt
+		pthread
+)

From 2a025de321396315ac1119d0f5e46d9abdc95249 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 14:19:53 +0100
Subject: [PATCH 1109/1774] changelog update

---
 CHANGELOG | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG b/CHANGELOG
index c221c811e..2d1152c75 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -14,4 +14,4 @@ a C file without issues
 
 ### Events
 
-- makeEvent function: Not takes three input parameters instead of two and allows setting a unique ID
+- makeEvent function: Now takes three input parameters instead of two and allows setting a unique ID

From d9cccdedf30b8ad95b87799dba5b426b66494f56 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 14:34:56 +0100
Subject: [PATCH 1110/1774] event update

---
 datalinklayer/DataLinkLayer.h                 | 10 ++---
 datapool/HkSwitchHelper.h                     |  2 +-
 .../DeviceHandlerFailureIsolation.cpp         |  6 +--
 devicehandlers/DeviceHandlerIF.h              | 22 +++++-----
 events/Event.cpp                              | 16 -------
 events/Event.h                                | 43 ++++++++-----------
 events/EventMessage.cpp                       |  4 +-
 fdir/FailureIsolationBase.cpp                 |  4 +-
 fdir/FailureIsolationBase.h                   |  6 +--
 health/HasHealthIF.h                          | 14 +++---
 modes/HasModesIF.h                            | 16 +++----
 monitoring/MonitoringIF.h                     |  8 ++--
 power/Fuse.h                                  |  8 ++--
 power/PowerSwitchIF.h                         |  2 +-
 pus/Service17Test.h                           |  2 +-
 pus/Service9TimeManagement.h                  |  4 +-
 storagemanager/StorageManagerIF.h             |  4 +-
 thermal/AbstractTemperatureSensor.h           |  6 +--
 thermal/Heater.h                              | 10 ++---
 thermal/ThermalComponentIF.h                  | 10 ++---
 tmstorage/TmStoreBackendIF.h                  | 32 +++++++-------
 21 files changed, 104 insertions(+), 125 deletions(-)
 delete mode 100644 events/Event.cpp

diff --git a/datalinklayer/DataLinkLayer.h b/datalinklayer/DataLinkLayer.h
index 5a900099e..30e548e8c 100644
--- a/datalinklayer/DataLinkLayer.h
+++ b/datalinklayer/DataLinkLayer.h
@@ -19,12 +19,12 @@ class VirtualChannelReception;
 class DataLinkLayer : public CCSDSReturnValuesIF {
 public:
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_1;
-	static const Event RF_AVAILABLE = MAKE_EVENT(0, SEVERITY::INFO); //!< A RF available signal was detected. P1: raw RFA state, P2: 0
-	static const Event RF_LOST = MAKE_EVENT(1, SEVERITY::INFO); //!< A previously found RF available signal was lost. P1: raw RFA state, P2: 0
-	static const Event BIT_LOCK = MAKE_EVENT(2, SEVERITY::INFO); //!< A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0
-	static const Event BIT_LOCK_LOST = MAKE_EVENT(3, SEVERITY::INFO); //!< A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
+	static const Event RF_AVAILABLE = MAKE_EVENT(0, severity::INFO); //!< A RF available signal was detected. P1: raw RFA state, P2: 0
+	static const Event RF_LOST = MAKE_EVENT(1, severity::INFO); //!< A previously found RF available signal was lost. P1: raw RFA state, P2: 0
+	static const Event BIT_LOCK = MAKE_EVENT(2, severity::INFO); //!< A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0
+	static const Event BIT_LOCK_LOST = MAKE_EVENT(3, severity::INFO); //!< A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
 //	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, SEVERITY::INFO); //!< The CCSDS Board detected that either bit lock or RF available or both are lost. No parameters.
-	static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< The CCSDS Board could not interpret a TC
+	static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, severity::LOW); //!< The CCSDS Board could not interpret a TC
 	/**
 	 * The Constructor sets the passed parameters and nothing else.
 	 * @param set_frame_buffer The buffer in which incoming frame candidates are stored.
diff --git a/datapool/HkSwitchHelper.h b/datapool/HkSwitchHelper.h
index 385b2047f..bb9e7dc68 100644
--- a/datapool/HkSwitchHelper.h
+++ b/datapool/HkSwitchHelper.h
@@ -13,7 +13,7 @@ class HkSwitchHelper: public ExecutableObjectIF, public CommandsActionsIF {
 public:
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HK;
-	static const Event SWITCHING_TM_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Commanding the HK Service failed, p1: error code, p2 action: 0 disable / 1 enable
+	static const Event SWITCHING_TM_FAILED = MAKE_EVENT(1, severity::LOW); //!< Commanding the HK Service failed, p1: error code, p2 action: 0 disable / 1 enable
 
 	HkSwitchHelper(EventReportingProxyIF *eventProxy);
 	virtual ~HkSwitchHelper();
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 24fe15a03..9d0535bf2 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -191,7 +191,7 @@ void DeviceHandlerFailureIsolation::triggerEvent(Event event, uint32_t parameter
 		uint32_t parameter2) {
 	//Do not throw error events if fdirState != none.
 	//This will still forward MODE and HEALTH INFO events in any case.
-	if (fdirState == NONE || EVENT::getSeverity(event) == SEVERITY::INFO) {
+	if (fdirState == NONE || event::getSeverity(event) == severity::INFO) {
 		FailureIsolationBase::triggerEvent(event, parameter1, parameter2);
 	}
 }
@@ -201,7 +201,7 @@ bool DeviceHandlerFailureIsolation::isFdirActionInProgress() {
 }
 
 void DeviceHandlerFailureIsolation::startRecovery(Event reason) {
-	throwFdirEvent(FDIR_STARTS_RECOVERY, EVENT::getEventId(reason));
+	throwFdirEvent(FDIR_STARTS_RECOVERY, event::getEventId(reason));
 	setOwnerHealth(HasHealthIF::NEEDS_RECOVERY);
 	setFdirState(RECOVERY_ONGOING);
 }
@@ -228,7 +228,7 @@ ReturnValue_t DeviceHandlerFailureIsolation::getParameter(uint8_t domainId,
 }
 
 void DeviceHandlerFailureIsolation::setFaulty(Event reason) {
-	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, EVENT::getEventId(reason));
+	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, event::getEventId(reason));
 	setOwnerHealth(HasHealthIF::FAULTY);
 	setFdirState(AWAIT_SHUTDOWN);
 }
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 4cda99d4e..12036bf11 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -95,17 +95,17 @@ public:
 	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
-	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
-	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
-	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
-	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
-	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
-	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
+	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, severity::LOW);
+	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, severity::LOW);
+	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, severity::LOW);
+	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, severity::LOW);
+	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, severity::LOW);
+	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, severity::LOW);
+	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, severity::LOW);
+	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, severity::LOW);
+	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, severity::LOW); //!< Indicates a SW bug in child class.
+	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, severity::LOW);
+	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, severity::HIGH);
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 
diff --git a/events/Event.cpp b/events/Event.cpp
deleted file mode 100644
index 0f76b4386..000000000
--- a/events/Event.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "Event.h"
-
-namespace EVENT {
-EventId_t getEventId(Event event) {
-	return (event & 0xFFFF);
-}
-
-EventSeverity_t getSeverity(Event event) {
-	return ((event >> 16) & 0xFF);
-}
-
-Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
-		EventSeverity_t eventSeverity) {
-	return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
-}
-}
diff --git a/events/Event.h b/events/Event.h
index 90ff1a901..aebc4bc54 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 #include "fwSubsystemIdRanges.h"
-//could be move to more suitable location
+// could be moved to more suitable location
 #include <events/subsystemIdRanges.h>
 
 typedef uint16_t EventId_t;
@@ -13,33 +13,28 @@ typedef uint8_t EventSeverity_t;
 
 typedef uint32_t Event;
 
-namespace EVENT {
-EventId_t getEventId(Event event);
+namespace event {
 
-EventSeverity_t getSeverity(Event event);
-
-Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
-		EventSeverity_t eventSeverity);
+constexpr EventId_t getEventId(Event event) {
+	return (event & 0xFFFF);
 }
 
-namespace SEVERITY {
-	static const EventSeverity_t INFO = 1;
-	static const EventSeverity_t LOW = 2;
-	static const EventSeverity_t MEDIUM = 3;
-	static const EventSeverity_t HIGH = 4;
+constexpr EventSeverity_t getSeverity(Event event) {
+	return ((event >> 16) & 0xFF);
 }
 
-//Unfortunately, this does not work nicely because of the inability to define static classes in headers.
-//struct Event {
-//	Event(uint8_t domain, uint8_t counter, EventSeverity_t severity) :
-//			id(domain*100+counter), severity(severity) {
-//	}
-//	EventId_t id;
-//	EventSeverity_t severity;
-//	static const EventSeverity_t INFO = 1;
-//	static const EventSeverity_t LOW = 2;
-//	static const EventSeverity_t MEDIUM = 3;
-//	static const EventSeverity_t HIGH = 4;
-//};
+constexpr Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
+		EventSeverity_t eventSeverity) {
+	return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
+}
+
+}
+
+namespace severity {
+	static constexpr EventSeverity_t INFO = 1;
+	static constexpr EventSeverity_t LOW = 2;
+	static constexpr EventSeverity_t MEDIUM = 3;
+	static constexpr EventSeverity_t HIGH = 4;
+}
 
 #endif /* EVENTOBJECT_EVENT_H_ */
diff --git a/events/EventMessage.cpp b/events/EventMessage.cpp
index b911abab9..bbc41e100 100644
--- a/events/EventMessage.cpp
+++ b/events/EventMessage.cpp
@@ -48,7 +48,7 @@ void EventMessage::setMessageId(uint8_t id) {
 EventSeverity_t EventMessage::getSeverity() {
 	Event event;
 	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getSeverity(event);
+	return event::getSeverity(event);
 }
 
 void EventMessage::setSeverity(EventSeverity_t severity) {
@@ -61,7 +61,7 @@ void EventMessage::setSeverity(EventSeverity_t severity) {
 EventId_t EventMessage::getEventId() {
 	Event event;
 	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getEventId(event);
+	return event::getEventId(event);
 }
 
 void EventMessage::setEventId(EventId_t eventId) {
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index f3b34f0fb..a04a0313b 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -139,7 +139,7 @@ void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
 		uint32_t parameter2) {
 	//With this mechanism, all events are disabled for a certain device.
 	//That's not so good for visibility.
-	if (isFdirDisabledForSeverity(EVENT::getSeverity(event))) {
+	if (isFdirDisabledForSeverity(event::getSeverity(event))) {
 		return;
 	}
 	EventMessage message(event, ownerId, parameter1, parameter2);
@@ -148,7 +148,7 @@ void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
 }
 
 bool FailureIsolationBase::isFdirDisabledForSeverity(EventSeverity_t severity) {
-	if ((owner != NULL) && (severity != SEVERITY::INFO)) {
+	if ((owner != NULL) && (severity != severity::INFO)) {
 		if (owner->getHealth() == HasHealthIF::EXTERNAL_CONTROL) {
 			//External control disables handling of fault messages.
 			return true;
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index 5b2c099ae..4a3f5adf8 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -14,9 +14,9 @@ class FailureIsolationBase: public HasReturnvaluesIF,
 		public HasParametersIF {
 public:
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
-	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.
+	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 = objects::NO_OBJECT,
diff --git a/health/HasHealthIF.h b/health/HasHealthIF.h
index 86863ea8b..a6254e395 100644
--- a/health/HasHealthIF.h
+++ b/health/HasHealthIF.h
@@ -21,13 +21,13 @@ public:
 	static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
-	static const Event HEALTH_INFO = MAKE_EVENT(6, SEVERITY::INFO);
-	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, SEVERITY::INFO);
-	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, SEVERITY::LOW);
-	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, SEVERITY::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
-	static const Event TRYING_RECOVERY = MAKE_EVENT(10, SEVERITY::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
-	static const Event RECOVERY_STEP = MAKE_EVENT(11, SEVERITY::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
-	static const Event RECOVERY_DONE = MAKE_EVENT(12, SEVERITY::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
+	static const Event HEALTH_INFO = MAKE_EVENT(6, severity::INFO);
+	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, severity::INFO);
+	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, severity::LOW);
+	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, severity::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
+	static const Event TRYING_RECOVERY = MAKE_EVENT(10, severity::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
+	static const Event RECOVERY_STEP = MAKE_EVENT(11, severity::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
+	static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
 
 	virtual ~HasHealthIF() {
 	}
diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h
index 34a159375..c29a0a96e 100644
--- a/modes/HasModesIF.h
+++ b/modes/HasModesIF.h
@@ -18,14 +18,14 @@ public:
 	static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-	static const Event CHANGING_MODE = MAKE_EVENT(0, SEVERITY::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
-	static const Event MODE_INFO = MAKE_EVENT(1, SEVERITY::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
-	static const Event FALLBACK_FAILED = MAKE_EVENT(2, SEVERITY::HIGH);
-	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, SEVERITY::HIGH);
-	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, SEVERITY::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
-	static const Event FORCING_MODE = MAKE_EVENT(6, SEVERITY::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
-	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, SEVERITY::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
+	static const Event CHANGING_MODE = MAKE_EVENT(0, severity::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
+	static const Event MODE_INFO = MAKE_EVENT(1, severity::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
+	static const Event FALLBACK_FAILED = MAKE_EVENT(2, severity::HIGH);
+	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, severity::LOW);
+	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, severity::HIGH);
+	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, severity::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
+	static const Event FORCING_MODE = MAKE_EVENT(6, severity::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
+	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, severity::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
 
 	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h
index aa266f337..32c625307 100644
--- a/monitoring/MonitoringIF.h
+++ b/monitoring/MonitoringIF.h
@@ -15,10 +15,10 @@ public:
 	static const uint8_t LIMIT_TYPE_OBJECT = 128;
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_2;
-	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, severity::LOW);
+	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, severity::LOW);
+	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, severity::LOW);
+	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, severity::LOW);
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::LIMITS_IF;
 	static const ReturnValue_t UNCHECKED = MAKE_RETURN_CODE(1);
diff --git a/power/Fuse.h b/power/Fuse.h
index e9e9290b4..cc1d534f4 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -32,10 +32,10 @@ public:
 	};
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
-	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
-	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
-	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
-	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
+	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, severity::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
+	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, severity::LOW); //!< PSS detected a fuse that went off.
+	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, severity::LOW); //!< PSS detected a fuse that violates its limits.
+	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, severity::LOW); //!< PSS detected a fuse that violates its limits.
 
 	typedef std::list<PowerComponentIF*> DeviceList;
 	Fuse(object_id_t fuseObjectId, uint8_t fuseId, sid_t variableSet,
diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h
index 1422baebc..b1f53a35a 100644
--- a/power/PowerSwitchIF.h
+++ b/power/PowerSwitchIF.h
@@ -30,7 +30,7 @@ public:
 	static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
 	static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
-	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
+	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, severity::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
 	/**
 	 * send a direct command to the Power Unit to enable/disable the specified switch.
 	 *
diff --git a/pus/Service17Test.h b/pus/Service17Test.h
index e26818659..83d436ea3 100644
--- a/pus/Service17Test.h
+++ b/pus/Service17Test.h
@@ -21,7 +21,7 @@ class Service17Test: public PusServiceBase {
 public:
 	// Custom events which can be triggered
 	static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_17;
-	static constexpr Event TEST = MAKE_EVENT(0, SEVERITY::INFO);
+	static constexpr Event TEST = MAKE_EVENT(0, severity::INFO);
 
 	enum Subservice: uint8_t {
 		//! [EXPORT] : [COMMAND] Perform connection test
diff --git a/pus/Service9TimeManagement.h b/pus/Service9TimeManagement.h
index 4802cdecc..70b86966d 100644
--- a/pus/Service9TimeManagement.h
+++ b/pus/Service9TimeManagement.h
@@ -7,8 +7,8 @@ class Service9TimeManagement: public PusServiceBase {
 public:
 
 	static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_9;
-	static constexpr Event CLOCK_SET = MAKE_EVENT(0, SEVERITY::INFO); //!< Clock has been set. P1: New Uptime. P2: Old Uptime
-	static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(1, SEVERITY::LOW); //!< Clock could not be set. P1: Returncode.
+	static constexpr Event CLOCK_SET = MAKE_EVENT(0, severity::INFO); //!< Clock has been set. P1: New Uptime. P2: Old Uptime
+	static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(1, severity::LOW); //!< Clock could not be set. P1: Returncode.
 
 	static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_9;
 
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 769616d78..622519336 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -40,8 +40,8 @@ public:
 	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
-	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event GET_DATA_FAILED = MAKE_EVENT(0, severity::LOW);
+	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, severity::LOW);
 
 	//!< Indicates an invalid (i.e unused) storage address.
 	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF;
diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h
index cc064ce47..a1153314e 100644
--- a/thermal/AbstractTemperatureSensor.h
+++ b/thermal/AbstractTemperatureSensor.h
@@ -27,9 +27,9 @@ class AbstractTemperatureSensor: public HasHealthIF,
 public:
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::T_SENSORS;
-	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, severity::LOW);
+	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, severity::LOW);
+	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, severity::LOW);
 
 	static constexpr float ZERO_KELVIN_C = -273.15;
 	AbstractTemperatureSensor(object_id_t setObjectid,
diff --git a/thermal/Heater.h b/thermal/Heater.h
index 63fe20667..b034dfee5 100644
--- a/thermal/Heater.h
+++ b/thermal/Heater.h
@@ -14,11 +14,11 @@ class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
 public:
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
-	static const Event HEATER_ON = MAKE_EVENT(0, SEVERITY::INFO);
-	static const Event HEATER_OFF = MAKE_EVENT(1, SEVERITY::INFO);
-	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event HEATER_ON = MAKE_EVENT(0, severity::INFO);
+	static const Event HEATER_OFF = MAKE_EVENT(1, severity::INFO);
+	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, severity::LOW);
+	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, severity::LOW);
+	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, severity::LOW);
 
 	Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
 	virtual ~Heater();
diff --git a/thermal/ThermalComponentIF.h b/thermal/ThermalComponentIF.h
index 16739e362..89c2b2d0e 100644
--- a/thermal/ThermalComponentIF.h
+++ b/thermal/ThermalComponentIF.h
@@ -10,11 +10,11 @@ class ThermalComponentIF : public HasParametersIF {
 public:
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_1;
-	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, SEVERITY::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
+	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, severity::LOW);
+	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, severity::LOW);
+	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, severity::LOW);
+	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, severity::LOW);
+	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, severity::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
 	static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index bfabdd31d..2ebe85e4c 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -31,22 +31,22 @@ public:
 	static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
-	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, SEVERITY::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, SEVERITY::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_READ_FAILED = MAKE_EVENT(3, SEVERITY::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
-	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, SEVERITY::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
-	static const Event STORING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, SEVERITY::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, SEVERITY::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, SEVERITY::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
-	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, SEVERITY::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
-	static const Event STORE_INITIALIZE = MAKE_EVENT(10, SEVERITY::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event INIT_DONE = MAKE_EVENT(11, SEVERITY::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event DUMP_FINISHED = MAKE_EVENT(12, SEVERITY::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FINISHED = MAKE_EVENT(13, SEVERITY::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FAILED = MAKE_EVENT(14, SEVERITY::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
-	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
+	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, severity::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, severity::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, severity::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_READ_FAILED = MAKE_EVENT(3, severity::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
+	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, severity::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
+	static const Event STORING_FAILED = MAKE_EVENT(5, severity::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, severity::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, severity::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, severity::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
+	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, severity::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
+	static const Event STORE_INITIALIZE = MAKE_EVENT(10, severity::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event INIT_DONE = MAKE_EVENT(11, severity::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event DUMP_FINISHED = MAKE_EVENT(12, severity::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FINISHED = MAKE_EVENT(13, severity::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FAILED = MAKE_EVENT(14, severity::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
+	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, severity::INFO);//!< Info that the a auto catalog report failed
 
 	virtual ~TmStoreBackendIF() {}
 

From fdbe5408b7b5924ee431206d5cdc32c47a3374b8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 14:43:44 +0100
Subject: [PATCH 1111/1774] renamed namespaces

---
 datalinklayer/DataLinkLayer.h                 | 12 +++---
 datapool/HkSwitchHelper.h                     |  2 +-
 .../DeviceHandlerFailureIsolation.cpp         |  6 +--
 devicehandlers/DeviceHandlerIF.h              | 22 +++++-----
 events/Event.h                                | 43 ++++++++-----------
 events/EventManager.cpp                       |  2 +-
 fdir/FailureIsolationBase.cpp                 |  4 +-
 fdir/FailureIsolationBase.h                   |  6 +--
 health/HasHealthIF.h                          | 14 +++---
 modes/HasModesIF.h                            | 16 +++----
 monitoring/MonitoringIF.h                     |  8 ++--
 power/Fuse.h                                  |  8 ++--
 power/PowerSwitchIF.h                         |  2 +-
 pus/Service17Test.h                           |  2 +-
 pus/Service9TimeManagement.h                  |  4 +-
 storagemanager/StorageManagerIF.h             |  4 +-
 thermal/AbstractTemperatureSensor.h           |  6 +--
 thermal/Heater.h                              | 10 ++---
 thermal/ThermalComponentIF.h                  | 10 ++---
 tmstorage/TmStoreBackendIF.h                  | 32 +++++++-------
 20 files changed, 104 insertions(+), 109 deletions(-)

diff --git a/datalinklayer/DataLinkLayer.h b/datalinklayer/DataLinkLayer.h
index 5a900099e..17a57d61d 100644
--- a/datalinklayer/DataLinkLayer.h
+++ b/datalinklayer/DataLinkLayer.h
@@ -19,12 +19,12 @@ class VirtualChannelReception;
 class DataLinkLayer : public CCSDSReturnValuesIF {
 public:
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_1;
-	static const Event RF_AVAILABLE = MAKE_EVENT(0, SEVERITY::INFO); //!< A RF available signal was detected. P1: raw RFA state, P2: 0
-	static const Event RF_LOST = MAKE_EVENT(1, SEVERITY::INFO); //!< A previously found RF available signal was lost. P1: raw RFA state, P2: 0
-	static const Event BIT_LOCK = MAKE_EVENT(2, SEVERITY::INFO); //!< A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0
-	static const Event BIT_LOCK_LOST = MAKE_EVENT(3, SEVERITY::INFO); //!< A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
-//	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, SEVERITY::INFO); //!< The CCSDS Board detected that either bit lock or RF available or both are lost. No parameters.
-	static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< The CCSDS Board could not interpret a TC
+	static const Event RF_AVAILABLE = MAKE_EVENT(0, severity::INFO); //!< A RF available signal was detected. P1: raw RFA state, P2: 0
+	static const Event RF_LOST = MAKE_EVENT(1, severity::INFO); //!< A previously found RF available signal was lost. P1: raw RFA state, P2: 0
+	static const Event BIT_LOCK = MAKE_EVENT(2, severity::INFO); //!< A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0
+	static const Event BIT_LOCK_LOST = MAKE_EVENT(3, severity::INFO); //!< A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
+//	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, severity::INFO); //!< The CCSDS Board detected that either bit lock or RF available or both are lost. No parameters.
+	static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, severity::LOW); //!< The CCSDS Board could not interpret a TC
 	/**
 	 * The Constructor sets the passed parameters and nothing else.
 	 * @param set_frame_buffer The buffer in which incoming frame candidates are stored.
diff --git a/datapool/HkSwitchHelper.h b/datapool/HkSwitchHelper.h
index 385b2047f..bb9e7dc68 100644
--- a/datapool/HkSwitchHelper.h
+++ b/datapool/HkSwitchHelper.h
@@ -13,7 +13,7 @@ class HkSwitchHelper: public ExecutableObjectIF, public CommandsActionsIF {
 public:
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HK;
-	static const Event SWITCHING_TM_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Commanding the HK Service failed, p1: error code, p2 action: 0 disable / 1 enable
+	static const Event SWITCHING_TM_FAILED = MAKE_EVENT(1, severity::LOW); //!< Commanding the HK Service failed, p1: error code, p2 action: 0 disable / 1 enable
 
 	HkSwitchHelper(EventReportingProxyIF *eventProxy);
 	virtual ~HkSwitchHelper();
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 9fbe71d85..f49663516 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -191,7 +191,7 @@ void DeviceHandlerFailureIsolation::triggerEvent(Event event, uint32_t parameter
 		uint32_t parameter2) {
 	//Do not throw error events if fdirState != none.
 	//This will still forward MODE and HEALTH INFO events in any case.
-	if (fdirState == NONE || EVENT::getSeverity(event) == SEVERITY::INFO) {
+	if (fdirState == NONE || event::getSeverity(event) == severity::INFO) {
 		FailureIsolationBase::triggerEvent(event, parameter1, parameter2);
 	}
 }
@@ -201,7 +201,7 @@ bool DeviceHandlerFailureIsolation::isFdirActionInProgress() {
 }
 
 void DeviceHandlerFailureIsolation::startRecovery(Event reason) {
-	throwFdirEvent(FDIR_STARTS_RECOVERY, EVENT::getEventId(reason));
+	throwFdirEvent(FDIR_STARTS_RECOVERY, event::getEventId(reason));
 	setOwnerHealth(HasHealthIF::NEEDS_RECOVERY);
 	setFdirState(RECOVERY_ONGOING);
 }
@@ -228,7 +228,7 @@ ReturnValue_t DeviceHandlerFailureIsolation::getParameter(uint8_t domainId,
 }
 
 void DeviceHandlerFailureIsolation::setFaulty(Event reason) {
-	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, EVENT::getEventId(reason));
+	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, event::getEventId(reason));
 	setOwnerHealth(HasHealthIF::FAULTY);
 	setFdirState(AWAIT_SHUTDOWN);
 }
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 35bbe3764..39a0e39a8 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -83,17 +83,17 @@ public:
 	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
-	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
-	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
-	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
-	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
-	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
-	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
+	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, severity::LOW);
+	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, severity::LOW);
+	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, severity::LOW);
+	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, severity::LOW);
+	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, severity::LOW);
+	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, severity::LOW);
+	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, severity::LOW);
+	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, severity::LOW);
+	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, severity::LOW); //!< Indicates a SW bug in child class.
+	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, severity::LOW);
+	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, severity::HIGH);
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 
diff --git a/events/Event.h b/events/Event.h
index 90ff1a901..aebc4bc54 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 #include "fwSubsystemIdRanges.h"
-//could be move to more suitable location
+// could be moved to more suitable location
 #include <events/subsystemIdRanges.h>
 
 typedef uint16_t EventId_t;
@@ -13,33 +13,28 @@ typedef uint8_t EventSeverity_t;
 
 typedef uint32_t Event;
 
-namespace EVENT {
-EventId_t getEventId(Event event);
+namespace event {
 
-EventSeverity_t getSeverity(Event event);
-
-Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
-		EventSeverity_t eventSeverity);
+constexpr EventId_t getEventId(Event event) {
+	return (event & 0xFFFF);
 }
 
-namespace SEVERITY {
-	static const EventSeverity_t INFO = 1;
-	static const EventSeverity_t LOW = 2;
-	static const EventSeverity_t MEDIUM = 3;
-	static const EventSeverity_t HIGH = 4;
+constexpr EventSeverity_t getSeverity(Event event) {
+	return ((event >> 16) & 0xFF);
 }
 
-//Unfortunately, this does not work nicely because of the inability to define static classes in headers.
-//struct Event {
-//	Event(uint8_t domain, uint8_t counter, EventSeverity_t severity) :
-//			id(domain*100+counter), severity(severity) {
-//	}
-//	EventId_t id;
-//	EventSeverity_t severity;
-//	static const EventSeverity_t INFO = 1;
-//	static const EventSeverity_t LOW = 2;
-//	static const EventSeverity_t MEDIUM = 3;
-//	static const EventSeverity_t HIGH = 4;
-//};
+constexpr Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
+		EventSeverity_t eventSeverity) {
+	return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
+}
+
+}
+
+namespace severity {
+	static constexpr EventSeverity_t INFO = 1;
+	static constexpr EventSeverity_t LOW = 2;
+	static constexpr EventSeverity_t MEDIUM = 3;
+	static constexpr EventSeverity_t HIGH = 4;
+}
 
 #endif /* EVENTOBJECT_EVENT_H_ */
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index f60a8a66d..71d1e2e62 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -118,7 +118,7 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
 	switch (message->getSeverity()) {
-	case SEVERITY::INFO:
+	case severity::INFO:
 #ifdef DEBUG_INFO_EVENT
 		string = translateObject(message->getReporter());
 		sif::info << "EVENT: ";
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index f3b34f0fb..a04a0313b 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -139,7 +139,7 @@ void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
 		uint32_t parameter2) {
 	//With this mechanism, all events are disabled for a certain device.
 	//That's not so good for visibility.
-	if (isFdirDisabledForSeverity(EVENT::getSeverity(event))) {
+	if (isFdirDisabledForSeverity(event::getSeverity(event))) {
 		return;
 	}
 	EventMessage message(event, ownerId, parameter1, parameter2);
@@ -148,7 +148,7 @@ void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
 }
 
 bool FailureIsolationBase::isFdirDisabledForSeverity(EventSeverity_t severity) {
-	if ((owner != NULL) && (severity != SEVERITY::INFO)) {
+	if ((owner != NULL) && (severity != severity::INFO)) {
 		if (owner->getHealth() == HasHealthIF::EXTERNAL_CONTROL) {
 			//External control disables handling of fault messages.
 			return true;
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index 5b2c099ae..4a3f5adf8 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -14,9 +14,9 @@ class FailureIsolationBase: public HasReturnvaluesIF,
 		public HasParametersIF {
 public:
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
-	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.
+	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 = objects::NO_OBJECT,
diff --git a/health/HasHealthIF.h b/health/HasHealthIF.h
index 86863ea8b..a6254e395 100644
--- a/health/HasHealthIF.h
+++ b/health/HasHealthIF.h
@@ -21,13 +21,13 @@ public:
 	static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
-	static const Event HEALTH_INFO = MAKE_EVENT(6, SEVERITY::INFO);
-	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, SEVERITY::INFO);
-	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, SEVERITY::LOW);
-	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, SEVERITY::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
-	static const Event TRYING_RECOVERY = MAKE_EVENT(10, SEVERITY::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
-	static const Event RECOVERY_STEP = MAKE_EVENT(11, SEVERITY::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
-	static const Event RECOVERY_DONE = MAKE_EVENT(12, SEVERITY::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
+	static const Event HEALTH_INFO = MAKE_EVENT(6, severity::INFO);
+	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, severity::INFO);
+	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, severity::LOW);
+	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, severity::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
+	static const Event TRYING_RECOVERY = MAKE_EVENT(10, severity::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
+	static const Event RECOVERY_STEP = MAKE_EVENT(11, severity::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
+	static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
 
 	virtual ~HasHealthIF() {
 	}
diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h
index 34a159375..c29a0a96e 100644
--- a/modes/HasModesIF.h
+++ b/modes/HasModesIF.h
@@ -18,14 +18,14 @@ public:
 	static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-	static const Event CHANGING_MODE = MAKE_EVENT(0, SEVERITY::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
-	static const Event MODE_INFO = MAKE_EVENT(1, SEVERITY::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
-	static const Event FALLBACK_FAILED = MAKE_EVENT(2, SEVERITY::HIGH);
-	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, SEVERITY::HIGH);
-	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, SEVERITY::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
-	static const Event FORCING_MODE = MAKE_EVENT(6, SEVERITY::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
-	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, SEVERITY::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
+	static const Event CHANGING_MODE = MAKE_EVENT(0, severity::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
+	static const Event MODE_INFO = MAKE_EVENT(1, severity::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
+	static const Event FALLBACK_FAILED = MAKE_EVENT(2, severity::HIGH);
+	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, severity::LOW);
+	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, severity::HIGH);
+	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, severity::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
+	static const Event FORCING_MODE = MAKE_EVENT(6, severity::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
+	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, severity::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
 
 	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h
index 44218c36d..040539ef1 100644
--- a/monitoring/MonitoringIF.h
+++ b/monitoring/MonitoringIF.h
@@ -15,10 +15,10 @@ public:
 	static const uint8_t LIMIT_TYPE_OBJECT = 128;
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_2;
-	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, severity::LOW);
+	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, severity::LOW);
+	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, severity::LOW);
+	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, severity::LOW);
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::LIMITS_IF;
 	static const ReturnValue_t UNCHECKED = MAKE_RETURN_CODE(1);
diff --git a/power/Fuse.h b/power/Fuse.h
index 279642be6..c67f69cce 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -32,10 +32,10 @@ public:
 	};
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
-	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
-	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
-	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
-	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
+	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, severity::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
+	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, severity::LOW); //!< PSS detected a fuse that went off.
+	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, severity::LOW); //!< PSS detected a fuse that violates its limits.
+	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, severity::LOW); //!< PSS detected a fuse that violates its limits.
 
 	typedef std::list<PowerComponentIF*> DeviceList;
 	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h
index 40220fb62..c6e4b2573 100644
--- a/power/PowerSwitchIF.h
+++ b/power/PowerSwitchIF.h
@@ -32,7 +32,7 @@ public:
 	static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
 	static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
-	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
+	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, severity::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
 	/**
 	 * send a direct command to the Power Unit to enable/disable the specified switch.
 	 *
diff --git a/pus/Service17Test.h b/pus/Service17Test.h
index e26818659..83d436ea3 100644
--- a/pus/Service17Test.h
+++ b/pus/Service17Test.h
@@ -21,7 +21,7 @@ class Service17Test: public PusServiceBase {
 public:
 	// Custom events which can be triggered
 	static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_17;
-	static constexpr Event TEST = MAKE_EVENT(0, SEVERITY::INFO);
+	static constexpr Event TEST = MAKE_EVENT(0, severity::INFO);
 
 	enum Subservice: uint8_t {
 		//! [EXPORT] : [COMMAND] Perform connection test
diff --git a/pus/Service9TimeManagement.h b/pus/Service9TimeManagement.h
index 4802cdecc..70b86966d 100644
--- a/pus/Service9TimeManagement.h
+++ b/pus/Service9TimeManagement.h
@@ -7,8 +7,8 @@ class Service9TimeManagement: public PusServiceBase {
 public:
 
 	static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_9;
-	static constexpr Event CLOCK_SET = MAKE_EVENT(0, SEVERITY::INFO); //!< Clock has been set. P1: New Uptime. P2: Old Uptime
-	static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(1, SEVERITY::LOW); //!< Clock could not be set. P1: Returncode.
+	static constexpr Event CLOCK_SET = MAKE_EVENT(0, severity::INFO); //!< Clock has been set. P1: New Uptime. P2: Old Uptime
+	static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(1, severity::LOW); //!< Clock could not be set. P1: Returncode.
 
 	static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_9;
 
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 834e75637..ab1998bf9 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -37,8 +37,8 @@ public:
 	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
-	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event GET_DATA_FAILED = MAKE_EVENT(0, severity::LOW);
+	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, severity::LOW);
 
 	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
 	/**
diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h
index 726ab9f4c..eaca48fba 100644
--- a/thermal/AbstractTemperatureSensor.h
+++ b/thermal/AbstractTemperatureSensor.h
@@ -17,9 +17,9 @@ class AbstractTemperatureSensor: public HasHealthIF,
 public:
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::T_SENSORS;
-	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, severity::LOW);
+	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, severity::LOW);
+	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, severity::LOW);
 
 	static constexpr float ZERO_KELVIN_C = -273.15;
 	AbstractTemperatureSensor(object_id_t setObjectid,
diff --git a/thermal/Heater.h b/thermal/Heater.h
index 63fe20667..b034dfee5 100644
--- a/thermal/Heater.h
+++ b/thermal/Heater.h
@@ -14,11 +14,11 @@ class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
 public:
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
-	static const Event HEATER_ON = MAKE_EVENT(0, SEVERITY::INFO);
-	static const Event HEATER_OFF = MAKE_EVENT(1, SEVERITY::INFO);
-	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event HEATER_ON = MAKE_EVENT(0, severity::INFO);
+	static const Event HEATER_OFF = MAKE_EVENT(1, severity::INFO);
+	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, severity::LOW);
+	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, severity::LOW);
+	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, severity::LOW);
 
 	Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
 	virtual ~Heater();
diff --git a/thermal/ThermalComponentIF.h b/thermal/ThermalComponentIF.h
index 522d4e443..e542c8420 100644
--- a/thermal/ThermalComponentIF.h
+++ b/thermal/ThermalComponentIF.h
@@ -10,11 +10,11 @@ class ThermalComponentIF : public HasParametersIF {
 public:
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_1;
-	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, SEVERITY::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
+	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, severity::LOW);
+	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, severity::LOW);
+	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, severity::LOW);
+	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, severity::LOW);
+	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, severity::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
 	static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index a441808e4..4b2a88361 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -31,22 +31,22 @@ public:
 	static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
-	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, SEVERITY::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, SEVERITY::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_READ_FAILED = MAKE_EVENT(3, SEVERITY::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
-	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, SEVERITY::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
-	static const Event STORING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, SEVERITY::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, SEVERITY::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, SEVERITY::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
-	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, SEVERITY::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
-	static const Event STORE_INITIALIZE = MAKE_EVENT(10, SEVERITY::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event INIT_DONE = MAKE_EVENT(11, SEVERITY::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event DUMP_FINISHED = MAKE_EVENT(12, SEVERITY::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FINISHED = MAKE_EVENT(13, SEVERITY::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FAILED = MAKE_EVENT(14, SEVERITY::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
-	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
+	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, severity::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, severity::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, severity::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_READ_FAILED = MAKE_EVENT(3, severity::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
+	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, severity::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
+	static const Event STORING_FAILED = MAKE_EVENT(5, severity::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, severity::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, severity::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, severity::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
+	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, severity::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
+	static const Event STORE_INITIALIZE = MAKE_EVENT(10, severity::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event INIT_DONE = MAKE_EVENT(11, severity::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event DUMP_FINISHED = MAKE_EVENT(12, severity::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FINISHED = MAKE_EVENT(13, severity::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FAILED = MAKE_EVENT(14, severity::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
+	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, severity::INFO);//!< Info that the a auto catalog report failed
 
 	virtual ~TmStoreBackendIF() {}
 	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;

From 7d70cce4dec572ca0db9012dfed4ddee31767a48 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 14:45:43 +0100
Subject: [PATCH 1112/1774] namepsace fix

---
 events/EventMessage.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/events/EventMessage.cpp b/events/EventMessage.cpp
index b911abab9..bbc41e100 100644
--- a/events/EventMessage.cpp
+++ b/events/EventMessage.cpp
@@ -48,7 +48,7 @@ void EventMessage::setMessageId(uint8_t id) {
 EventSeverity_t EventMessage::getSeverity() {
 	Event event;
 	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getSeverity(event);
+	return event::getSeverity(event);
 }
 
 void EventMessage::setSeverity(EventSeverity_t severity) {
@@ -61,7 +61,7 @@ void EventMessage::setSeverity(EventSeverity_t severity) {
 EventId_t EventMessage::getEventId() {
 	Event event;
 	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getEventId(event);
+	return event::getEventId(event);
 }
 
 void EventMessage::setEventId(EventId_t eventId) {

From f0b13427e63ea7dfa2da89efe0894b78c1c546c9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 14:51:36 +0100
Subject: [PATCH 1113/1774] changelog update

---
 CHANGELOG | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG b/CHANGELOG
index 33665e606..634eb2a73 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -17,4 +17,7 @@ a C file without issues
 
 ### Events
 
-- makeEvent function: Now takes three input parameters instead of two and allows setting a unique ID
+- makeEvent function: Now takes three input parameters instead of two and
+allows setting a unique ID. Event.cpp source file removed, functions now
+defined in header directly. Namespaces renamed. Functions declared `constexpr`
+now

From 6ee4ceeb65c53ddaefe30c2c9001d6691c032182 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 14:58:24 +0100
Subject: [PATCH 1114/1774] deleted event.cpp source file

---
 events/Event.cpp | 16 ----------------
 1 file changed, 16 deletions(-)
 delete mode 100644 events/Event.cpp

diff --git a/events/Event.cpp b/events/Event.cpp
deleted file mode 100644
index 0f76b4386..000000000
--- a/events/Event.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "Event.h"
-
-namespace EVENT {
-EventId_t getEventId(Event event) {
-	return (event & 0xFFFF);
-}
-
-EventSeverity_t getSeverity(Event event) {
-	return ((event >> 16) & 0xFF);
-}
-
-Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
-		EventSeverity_t eventSeverity) {
-	return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
-}
-}

From 4a4634928620b68fc0aa253cf9ccd1e977a81318 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 15:14:39 +0100
Subject: [PATCH 1115/1774] minor imrpovements

---
 datalinklayer/MapPacketExtraction.cpp |  4 ++--
 datalinklayer/MapPacketExtraction.h   | 11 ++++++-----
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 45f7d3f8b..845ed7c17 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -9,9 +9,9 @@
 
 MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
 		object_id_t setPacketDestination) :
-		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId),
 		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
-		packetStore(NULL), tcQueueId(MessageQueueIF::NO_QUEUE) {
+		tcQueueId(MessageQueueIF::NO_QUEUE) {
 	std::memset(packetBuffer, 0, sizeof(packetBuffer));
 }
 
diff --git a/datalinklayer/MapPacketExtraction.h b/datalinklayer/MapPacketExtraction.h
index eff9b7c3c..ddb867fb2 100644
--- a/datalinklayer/MapPacketExtraction.h
+++ b/datalinklayer/MapPacketExtraction.h
@@ -1,5 +1,5 @@
-#ifndef MAPPACKETEXTRACTION_H_
-#define MAPPACKETEXTRACTION_H_
+#ifndef FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_
+#define FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_
 
 #include "MapPacketExtractionIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
@@ -20,11 +20,12 @@ private:
 	static const uint32_t MAX_PACKET_SIZE = 4096;
 	uint8_t lastSegmentationFlag;	//!< The segmentation flag of the last received frame.
 	uint8_t mapId;	//!< MAP ID of this MAP Channel.
-	uint32_t packetLength;	//!< Complete length of the current Space Packet.
+	uint32_t packetLength = 0;	//!< Complete length of the current Space Packet.
 	uint8_t* bufferPosition;	//!< Position to write to in the internal Packet buffer.
 	uint8_t packetBuffer[MAX_PACKET_SIZE];	//!< The internal Space Packet Buffer.
 	object_id_t packetDestination;
-	StorageManagerIF* packetStore;	//!< Pointer to the store where full TC packets are stored.
+	//!< Pointer to the store where full TC packets are stored.
+	StorageManagerIF* packetStore = nullptr;
 	MessageQueueId_t tcQueueId;		//!< QueueId to send found packets to the distributor.
 	/**
 	 * Debug method to print the packet Buffer's content.
@@ -69,4 +70,4 @@ public:
 	uint8_t getMapId() const;
 };
 
-#endif /* MAPPACKETEXTRACTION_H_ */
+#endif /* FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_ */

From 322dd1253e222ecfc81f40c671864d75d2e0334a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 15:15:22 +0100
Subject: [PATCH 1116/1774] map packet extract update

---
 datalinklayer/MapPacketExtraction.cpp |  4 ++--
 datalinklayer/MapPacketExtraction.h   | 11 ++++++-----
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 45f7d3f8b..845ed7c17 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -9,9 +9,9 @@
 
 MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
 		object_id_t setPacketDestination) :
-		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId),
 		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
-		packetStore(NULL), tcQueueId(MessageQueueIF::NO_QUEUE) {
+		tcQueueId(MessageQueueIF::NO_QUEUE) {
 	std::memset(packetBuffer, 0, sizeof(packetBuffer));
 }
 
diff --git a/datalinklayer/MapPacketExtraction.h b/datalinklayer/MapPacketExtraction.h
index eff9b7c3c..ddb867fb2 100644
--- a/datalinklayer/MapPacketExtraction.h
+++ b/datalinklayer/MapPacketExtraction.h
@@ -1,5 +1,5 @@
-#ifndef MAPPACKETEXTRACTION_H_
-#define MAPPACKETEXTRACTION_H_
+#ifndef FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_
+#define FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_
 
 #include "MapPacketExtractionIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
@@ -20,11 +20,12 @@ private:
 	static const uint32_t MAX_PACKET_SIZE = 4096;
 	uint8_t lastSegmentationFlag;	//!< The segmentation flag of the last received frame.
 	uint8_t mapId;	//!< MAP ID of this MAP Channel.
-	uint32_t packetLength;	//!< Complete length of the current Space Packet.
+	uint32_t packetLength = 0;	//!< Complete length of the current Space Packet.
 	uint8_t* bufferPosition;	//!< Position to write to in the internal Packet buffer.
 	uint8_t packetBuffer[MAX_PACKET_SIZE];	//!< The internal Space Packet Buffer.
 	object_id_t packetDestination;
-	StorageManagerIF* packetStore;	//!< Pointer to the store where full TC packets are stored.
+	//!< Pointer to the store where full TC packets are stored.
+	StorageManagerIF* packetStore = nullptr;
 	MessageQueueId_t tcQueueId;		//!< QueueId to send found packets to the distributor.
 	/**
 	 * Debug method to print the packet Buffer's content.
@@ -69,4 +70,4 @@ public:
 	uint8_t getMapId() const;
 };
 
-#endif /* MAPPACKETEXTRACTION_H_ */
+#endif /* FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_ */

From bd1137d089539288fbfe3840ded67bea858ebc9d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 15:33:32 +0100
Subject: [PATCH 1117/1774] replaced hardcoded value with `NO_COMMAND`

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index e4bb6d711..e6c15f9e6 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -678,7 +678,7 @@ void DeviceHandlerBase::doGetRead() {
 void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		size_t receivedDataLen) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	DeviceCommandId_t foundId = 0xffffffff;
+	DeviceCommandId_t foundId = DeviceHandlerIF::NO_COMMAND;
 	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

From ac5446b2b145eee8a3a5183913989b66d20fcc63 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 15:43:58 +0100
Subject: [PATCH 1118/1774] removed hk switcher helper member

---
 controller/ControllerBase.cpp | 7 +------
 controller/ControllerBase.h   | 3 ---
 2 files changed, 1 insertion(+), 9 deletions(-)

diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 45e678eb4..2a4024680 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -8,7 +8,7 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
 		size_t commandQueueDepth) :
 		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
 		submode(SUBMODE_NONE), modeHelper(this),
-		healthHelper(this, setObjectId), hkSwitcher(this) {
+		healthHelper(this, setObjectId) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(
 	        commandQueueDepth);
 }
@@ -44,10 +44,6 @@ ReturnValue_t ControllerBase::initialize() {
 		return result;
 	}
 
-	result = hkSwitcher.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
 	return RETURN_OK;
 }
 
@@ -107,7 +103,6 @@ void ControllerBase::announceMode(bool recursive) {
 
 ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
 	handleQueue();
-	hkSwitcher.performOperation();
 	performControlOperation();
 	return RETURN_OK;
 }
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 25d3ab1f3..6e83fe80b 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -72,9 +72,6 @@ protected:
 
 	HealthHelper healthHelper;
 
-	// Is this still needed?
-	HkSwitchHelper hkSwitcher;
-
 	/**
 	 * Pointer to the task which executes this component,
 	 * is invalid before setTaskIF was called.

From a612e19e94a3edcbd3a5997410e8c4b87800cfb3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 15:49:46 +0100
Subject: [PATCH 1119/1774] ndentation

---
 internalError/InternalErrorReporter.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 12f36f336..818b00cfc 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -6,8 +6,7 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
-        uint32_t messageQueueDepth) :
-		SystemObject(setObjectId),
+        uint32_t messageQueueDepth): SystemObject(setObjectId),
 		commandQueue(QueueFactory::instance()->
 		        createMessageQueue(messageQueueDepth)),
 		poolManager(this, commandQueue),

From 7f40566031f40d8ebe214bf29a7958731d936cd0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 15:50:21 +0100
Subject: [PATCH 1120/1774] include removed

---
 internalError/InternalErrorReporter.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 818b00cfc..bfb672891 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,4 +1,3 @@
-#include "../datapoolglob/GlobalDataSet.h"
 #include "InternalErrorReporter.h"
 
 #include "../ipc/QueueFactory.h"

From beab942f07458c709cb39d8b4976fd1462438fd6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 15:57:30 +0100
Subject: [PATCH 1121/1774] fixes taken over from master

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4bda08500..733106e57 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -693,7 +693,7 @@ void DeviceHandlerBase::doGetRead() {
 void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		size_t receivedDataLen) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	DeviceCommandId_t foundId = 0xffffffff;
+	DeviceCommandId_t foundId = DeviceHandlerIF::NO_COMMAND;
 	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

From 5e2e18ac078b3ea78ab1328adda5116d532b222c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 15:59:30 +0100
Subject: [PATCH 1122/1774] device handler uses local pools now

---
 devicehandlers/DeviceHandlerBase.cpp | 148 +++++++++++++----------
 devicehandlers/DeviceHandlerBase.h   | 169 ++++++++++++++++-----------
 2 files changed, 193 insertions(+), 124 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index b5d43d77d..733106e57 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -3,8 +3,6 @@
 #include "DeviceTmReportingWrapper.h"
 
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
@@ -13,9 +11,11 @@
 #include "../ipc/MessageQueueMessage.h"
 #include "../ipc/QueueFactory.h"
 #include "../subsystem/SubsystemBase.h"
+#include "../datapoollocal/LocalPoolVariable.h"
 
 #include <iomanip>
 
+
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
@@ -56,9 +56,10 @@ void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
 }
 
 void DeviceHandlerBase::setThermalStateRequestPoolIds(
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId) {
-	this->deviceThermalRequestPoolId = thermalStatePoolId;
-	this->deviceThermalRequestPoolId = thermalRequestPoolId;
+		lp_id_t thermalStatePoolId, lp_id_t heaterRequestPoolId,
+		uint32_t thermalSetId) {
+	thermalSet = new DeviceHandlerThermalSet(this, thermalSetId,
+			thermalStatePoolId, heaterRequestPoolId);
 }
 
 
@@ -86,7 +87,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		decrementDeviceReplyMap();
 		fdirInstance->checkForFailures();
 		hkSwitcher.performOperation();
-		hkManager.performHkOperation();
 		performOperationHook();
 		return RETURN_OK;
 	}
@@ -111,6 +111,9 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		break;
 	case CommunicationAction::GET_READ:
 		doGetRead();
+		// This will be performed after datasets have been updated by the
+		// custom device implementation.
+        hkManager.performHkOperation();
 		break;
 	default:
 		break;
@@ -208,16 +211,18 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	fillCommandAndReplyMap();
 
-	//Set temperature target state to NON_OP.
-	GlobDataSet mySet;
-	gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-			PoolVariableIF::VAR_WRITE);
-	mySet.read();
-	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-	mySet.commit(PoolVariableIF::VALID);
+	if(thermalSet != nullptr) {
+		//Set temperature target state to NON_OP.
+		result = thermalSet->read();
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			thermalSet->heaterRequest.value =
+					ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+			thermalSet->commit(PoolVariableIF::VALID);
+		}
+
+	}
 
 	return RETURN_OK;
-
 }
 
 void DeviceHandlerBase::decrementDeviceReplyMap() {
@@ -505,15 +510,17 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	}
 	Clock::getUptime(&timeoutStart);
 
-	if (mode == MODE_OFF) {
-		GlobDataSet mySet;
-		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-				PoolVariableIF::VAR_READ_WRITE);
-		mySet.read();
-		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-			thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+	if (mode == MODE_OFF and thermalSet != nullptr) {
+		ReturnValue_t result = thermalSet->read();
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			if (thermalSet->heaterRequest.value !=
+					ThermalComponentIF::STATE_REQUEST_IGNORE) {
+				thermalSet->heaterRequest.value = ThermalComponentIF::
+						STATE_REQUEST_NON_OPERATIONAL;
+			}
+			thermalSet->heaterRequest.commit(PoolVariableIF::VALID);
 		}
-		mySet.commit(PoolVariableIF::VALID);
+
 	}
 	changeHK(mode, submode, true);
 }
@@ -976,17 +983,15 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
 	}
 
 	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
-			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)) {
-		GlobDataSet mySet;
-		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
-				PoolVariableIF::VAR_READ);
-		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-				PoolVariableIF::VAR_READ);
-		mySet.read();
-		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-			if (!ThermalComponentIF::isOperational(thermalState)) {
+			and (thermalSet != nullptr)) {
+		ReturnValue_t result = thermalSet->read();
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			if((thermalSet->heaterRequest.value !=
+					ThermalComponentIF::STATE_REQUEST_IGNORE) and (not
+					ThermalComponentIF::isOperational(
+							thermalSet->thermalState.value))) {
 				triggerEvent(ThermalComponentIF::TEMP_NOT_IN_OP_RANGE,
-						thermalState);
+						thermalSet->thermalState.value);
 				return NON_OP_TEMPERATURE;
 			}
 		}
@@ -999,32 +1004,15 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 		Submode_t commandedSubmode) {
 	switch (commandedMode) {
 	case MODE_ON:
-		if (mode == MODE_OFF) {
-			transitionSourceMode = _MODE_POWER_DOWN;
-			transitionSourceSubMode = SUBMODE_NONE;
-			setMode(_MODE_POWER_ON, commandedSubmode);
-			//already set the delay for the child transition so we don't need to call it twice
-			childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
-					MODE_ON);
-			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-			GlobDataSet mySet;
-			gp_int8_t thermalRequest(deviceThermalRequestPoolId,
-					&mySet, PoolVariableIF::VAR_READ_WRITE);
-			mySet.read();
-			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-				thermalRequest = ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
-				mySet.commit(PoolVariableIF::VALID);
-			}
-		} else {
-			setTransition(MODE_ON, commandedSubmode);
-		}
+		handleTransitionToOnMode(commandedMode, commandedSubmode);
 		break;
 	case MODE_OFF:
 		if (mode == MODE_OFF) {
 			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
 			setMode(_MODE_POWER_DOWN, commandedSubmode);
 		} else {
-			//already set the delay for the child transition so we don't need to call it twice
+			// already set the delay for the child transition
+			// so we don't need to call it twice
 			childTransitionDelay = getTransitionDelayMs(mode, _MODE_POWER_DOWN);
 			transitionSourceMode = _MODE_POWER_DOWN;
 			transitionSourceSubMode = commandedSubmode;
@@ -1050,6 +1038,33 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 	}
 }
 
+void DeviceHandlerBase::handleTransitionToOnMode(Mode_t commandedMode,
+		Submode_t commandedSubmode) {
+	if (mode == MODE_OFF) {
+		transitionSourceMode = _MODE_POWER_DOWN;
+		transitionSourceSubMode = SUBMODE_NONE;
+		setMode(_MODE_POWER_ON, commandedSubmode);
+		// already set the delay for the child transition so we don't
+		// need to call it twice
+		childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
+				MODE_ON);
+		triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
+		if(thermalSet != nullptr) {
+			ReturnValue_t result = thermalSet->read();
+			if(result == HasReturnvaluesIF::RETURN_OK) {
+				if(thermalSet->heaterRequest !=
+						ThermalComponentIF::STATE_REQUEST_IGNORE) {
+					thermalSet->heaterRequest =
+							ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
+					thermalSet->commit();
+				}
+			}
+		}
+	} else {
+		setTransition(MODE_ON, commandedSubmode);
+	}
+}
+
 void DeviceHandlerBase::getMode(Mode_t* mode, Submode_t* submode) {
 	*mode = this->mode;
 	*submode = this->submode;
@@ -1222,10 +1237,12 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 		}
 	}
 	//Try to cast to GlobDataSet and commit data.
-	if (!neverInDataPool) {
-		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
-		if (dataSet != NULL) {
-			dataSet->commit(PoolVariableIF::VALID);
+	if (not neverInDataPool) {
+		LocalPoolDataSetBase* dataSet =
+				dynamic_cast<LocalPoolDataSetBase*>(data);
+		if (dataSet != nullptr) {
+			dataSet->setValidity(true, true);
+			dataSet->commit();
 		}
 	}
 }
@@ -1262,7 +1279,8 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (result == BUSY) {
 		    //so we can track misconfigurations
 			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Busy" << std::dec << std::endl;
+					<< ": DHB::buildInternalCommand: Busy" << std::dec
+					<< std::endl;
 			result = NOTHING_TO_SEND; //no need to report this
 		}
 	}
@@ -1371,8 +1389,8 @@ bool DeviceHandlerBase::commandIsExecuting(DeviceCommandId_t commandId) {
 void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 }
 
-void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
-	executingTask = task_;
+void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task){
+	executingTask = task;
 }
 
 // Default implementations empty.
@@ -1385,6 +1403,12 @@ void DeviceHandlerBase::performOperationHook() {
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
 		LocalDataPool &localDataPoolMap,
         LocalDataPoolManager& poolManager) {
+	if(thermalSet != nullptr) {
+		localDataPoolMap.emplace(thermalSet->thermalStatePoolId,
+				new PoolEntry<DeviceHandlerIF::dh_thermal_state_t>);
+		localDataPoolMap.emplace(thermalSet->heaterRequestPoolId,
+				new PoolEntry<DeviceHandlerIF::dh_heater_request_t>);
+	}
 	return RETURN_OK;
 }
 
@@ -1429,3 +1453,9 @@ dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
     return pstIntervalMs;
 }
 
+DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
+    if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
+        return cookieInfo.pendingCommand->first;
+    }
+    return DeviceHandlerIF::NO_COMMAND;
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 627a64238..2bfa62a66 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -4,6 +4,7 @@
 #include "DeviceHandlerIF.h"
 #include "DeviceCommunicationIF.h"
 #include "DeviceHandlerFailureIsolation.h"
+#include "DeviceHandlerThermalSet.h"
 
 #include "../objectmanager/SystemObject.h"
 #include "../tasks/ExecutableObjectIF.h"
@@ -103,8 +104,21 @@ public:
 			size_t cmdQueueSize = 20);
 
 	void setHkDestination(object_id_t hkDestination);
-	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId);
+
+	/**
+	 * If the device handler is controlled by the FSFW thermal building blocks,
+	 * this function should be called to initialize all required components.
+	 * The device handler will then take care of creating local pool entries
+	 * for the device thermal state and device heating request.
+	 * Custom local pool IDs can be assigned as well.
+	 * @param thermalStatePoolId
+	 * @param thermalRequestPoolId
+	 */
+	void setThermalStateRequestPoolIds(lp_id_t thermalStatePoolId =
+			DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
+			lp_id_t thermalRequestPoolId =
+			DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID,
+			uint32_t thermalSetId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID);
 	/**
 	 * @brief   Helper function to ease device handler development.
 	 * This will instruct the transition to MODE_ON immediately
@@ -694,19 +708,7 @@ protected:
 	//! and to send replies.
 	MessageQueueIF* commandQueue = nullptr;
 
-	/**
-	 * this is the datapool variable with the thermal state of the device
-	 *
-	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
-	 */
-	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 = PoolVariableIF::NO_PARAMETER;
+	DeviceHandlerThermalSet* thermalSet = nullptr;
 
 	/**
 	 * Optional Error code. Can be set in doStartUp(), doShutDown() and
@@ -732,15 +734,27 @@ protected:
 	//! before setTaskIF was called.
 	PeriodicTaskIF* executingTask = nullptr;
 
-	static object_id_t powerSwitcherId; //!< Object which switches power on and off.
+	//!< Object which switches power on and off.
+	static object_id_t powerSwitcherId;
 
-	static object_id_t rawDataReceiverId; //!< Object which receives RAW data by default.
+	//!< Object which receives RAW data by default.
+	static object_id_t rawDataReceiverId;
+
+	//!< Object which may be the root cause of an identified fault.
+	static object_id_t defaultFdirParentId;
+
+	/**
+	 * Helper function to get pending command. This is useful for devices
+	 * like SPI sensors to identify the last sent command.
+	 * @return
+	 */
+	DeviceCommandId_t getPendingCommand() const;
 
-	static object_id_t defaultFdirParentId; //!< Object which may be the root cause of an identified fault.
 	/**
 	 * Helper function to report a missed reply
 	 *
-	 * Can be overwritten by children to act on missed replies or to fake reporting Id.
+	 * Can be overwritten by children to act on missed replies or to fake
+	 * reporting Id.
 	 *
 	 * @param id of the missed reply
 	 */
@@ -847,15 +861,18 @@ protected:
 	/**
 	 * Build the device command to send for raw mode.
 	 *
-	 * This is only called in @c MODE_RAW. It is for the rare case that in raw mode packets
-	 * are to be sent by the handler itself. It is NOT needed for the raw commanding service.
-	 * Its only current use is in the STR handler which gets its raw packets from a different
-	 * source.
-	 * Also it can be used for transitional commands, to get the device ready for @c MODE_RAW
+	 * This is only called in @c MODE_RAW. It is for the rare case that in
+	 * raw mode packets are to be sent by the handler itself. It is NOT needed
+	 * for the raw commanding service. Its only current use is in the STR
+	 * handler which gets its raw packets from a different source.
+	 * Also it can be used for transitional commands, to get the device ready
+	 * for @c MODE_RAW
 	 *
-	 * As it is almost never used, there is a default implementation returning @c NOTHING_TO_SEND.
+	 * As it is almost never used, there is a default implementation
+	 * returning @c NOTHING_TO_SEND.
 	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet
+	 * to be sent.
 	 *
 	 * @param[out] id the device command id built
 	 * @return
@@ -868,7 +885,9 @@ protected:
 	 * Returns the delay cycle count of a reply.
 	 * A count != 0 indicates that the command is already executed.
 	 * @param deviceCommand	The command to look for
-	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
+	 * @return
+	 * The current delay count. If the command does not exist  (should never
+	 * happen) it returns 0.
 	 */
 	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
 
@@ -878,20 +897,22 @@ protected:
 	 * It gets space in the #IPCStore, copies data there, then sends a raw reply
 	 * containing the store address.
 	 *
-	 * This method is virtual, as the STR has a different channel to send raw replies
-	 * and overwrites it accordingly.
+	 * This method is virtual, as the STR has a different channel to send
+	 * raw replies and overwrites it accordingly.
 	 *
 	 * @param data data to send
 	 * @param len length of @c data
 	 * @param sendTo the messageQueueId of the one to send to
-	 * @param isCommand marks the raw data as a command, the message then will be of type raw_command
+	 * @param isCommand marks the raw data as a command, the message then
+	 * will be of type raw_command
 	 */
 	virtual void replyRawData(const uint8_t *data, size_t len,
 			MessageQueueId_t sendTo, bool isCommand = false);
 
 	/**
-	 * Calls replyRawData() with #defaultRawReceiver, but checks if wiretapping is active and if so,
-	 * does not send the Data as the wiretapping will have sent it already
+	 * Calls replyRawData() with #defaultRawReceiver, but checks if wiretapping
+	 * is active and if so, does not send the data as the wiretapping will have
+	 * sent it already
 	 */
 	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
 
@@ -903,17 +924,19 @@ protected:
 	/**
 	 * Enable the reply checking for a command
 	 *
-	 * Is only called, if the command was sent (ie the getWriteReply was successful).
-	 * Must ensure that all replies are activated and correctly linked to the command that initiated it.
-	 * The default implementation looks for a reply with the same id as the command id in the replyMap or
-	 * uses the alternativeReplyId if flagged so.
-	 * When found, copies maxDelayCycles to delayCycles in the reply information and sets the command to
-	 * expect one reply.
+	 * Is only called, if the command was sent (i.e. the getWriteReply was
+	 * successful). Must ensure that all replies are activated and correctly
+	 * linked to the command that initiated it.
+	 * The default implementation looks for a reply with the same id as the
+	 * command id in the replyMap or uses the alternativeReplyId if flagged so.
+	 * When found, copies maxDelayCycles to delayCycles in the reply information
+	 * and sets the command to expect one reply.
 	 *
 	 * Can be overwritten by the child, if a command activates multiple replies
 	 * or replyId differs from commandId.
 	 * Notes for child implementations:
-	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
+	 * 	- If the command was not found in the reply map,
+	 * 	  NO_REPLY_EXPECTED MUST be returned.
 	 * 	- A failure code may be returned if something went fundamentally wrong.
 	 *
 	 * @param deviceCommand
@@ -929,17 +952,20 @@ protected:
 	 * get the state of the PCDU switches in the datapool
 	 *
 	 * @return
-	 *     - @c PowerSwitchIF::SWITCH_ON if all switches specified by #switches are on
-	 *     - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by #switches are off
-	 *     - @c PowerSwitchIF::RETURN_FAILED if an error occured
+	 *  - @c PowerSwitchIF::SWITCH_ON if all switches specified
+	 *       by #switches are on
+	 *  - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by
+	 *       #switches are off
+	 *  - @c PowerSwitchIF::RETURN_FAILED if an error occured
 	 */
 	ReturnValue_t getStateOfSwitches(void);
 
 	/**
-	 * set all datapool variables that are update periodically in normal mode invalid
-	 *
-	 * Child classes should provide an implementation which sets all those variables invalid
-	 * which are set periodically during any normal mode.
+	 * @brief   Set all datapool variables that are update periodically in
+	 *          normal mode invalid
+	 * @details TODO: Use local pools
+	 * Child classes should provide an implementation which sets all those
+	 * variables invalid which are set periodically during any normal mode.
 	 */
 	virtual void setNormalDatapoolEntriesInvalid() = 0;
 
@@ -949,11 +975,12 @@ protected:
 	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 
 	/**
-	 * Children can overwrite this function to suppress checking of the command Queue
+	 * Children can overwrite this function to suppress checking of the
+	 * command Queue
 	 *
-	 * This can be used when the child does not want to receive a command in a certain
-	 * situation. Care must be taken that checking is not permanentely disabled as this
-	 * would render the handler unusable.
+	 * This can be used when the child does not want to receive a command in
+	 * a certain situation. Care must be taken that checking is not
+	 * permanentely disabled as this would render the handler unusable.
 	 *
 	 * @return whether checking the queue should NOT be done
 	 */
@@ -992,17 +1019,20 @@ protected:
 	virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
 			uint32_t parameter2 = 0) const;
 	/**
-	 * Checks state of switches in conjunction with mode and triggers an event if they don't fit.
+	 * Checks state of switches in conjunction with mode and triggers an event
+	 * if they don't fit.
 	 */
 	virtual void checkSwitchState();
 
 	/**
-	 * Reserved for the rare case where a device needs to perform additional operation cyclically in OFF mode.
+	 * Reserved for the rare case where a device needs to perform additional
+	 * operation cyclically in OFF mode.
 	 */
 	virtual void doOffActivity();
 
 	/**
-	 * Reserved for the rare case where a device needs to perform additional operation cyclically in ON mode.
+	 * Reserved for the rare case where a device needs to perform additional
+	 * operation cyclically in ON mode.
 	 */
 	virtual void doOnActivity();
 
@@ -1043,9 +1073,10 @@ private:
 	/**
 	 * Information about a cookie.
 	 *
-	 * This is stored in a map for each cookie, to not only track the state, but also information
-	 * about  the sent command. Tracking this information is needed as
-	 * the state of a commandId (waiting for reply) is done when a RMAP write reply is received.
+	 * This is stored in a map for each cookie, to not only track the state,
+	 * but also information about the sent command. Tracking this information
+	 * is needed as the state of a commandId (waiting for reply) is done when a
+	 * write reply is received.
 	 */
 	struct CookieInfo {
 		CookieState_t state;
@@ -1102,10 +1133,14 @@ private:
 	/**
 	 * Handle the device handler mode.
 	 *
-	 * - checks whether commands are valid for the current mode, rejects them accordingly
-	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
-	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
-	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
+	 * - checks whether commands are valid for the current mode, rejects
+	 *   them accordingly
+	 * - checks whether commanded mode transitions are required and calls
+	 *   handleCommandedModeTransition()
+	 * - does the necessary action for the current mode or calls
+	 *   doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
+	 * - actions that happen in transitions (e.g. setting a timeout) are
+	 *   handled in setMode()
 	 */
 	void doStateMachine(void);
 
@@ -1115,16 +1150,17 @@ private:
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
-	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
-	 * but not received).
+	 * This is called at the beginning of each cycle. It checks whether a
+	 * reply has timed out (that means a reply was expected but not received).
 	 */
 	void decrementDeviceReplyMap(void);
 
 	/**
 	 * Convenience function to handle a reply.
 	 *
-	 * Called after scanForReply() has found a packet. Checks if the found id is in the #deviceCommandMap, if so,
-	 * calls interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) for further action.
+	 * Called after scanForReply() has found a packet. Checks if the found ID
+	 * is in the #deviceCommandMap, if so,  calls
+	 * #interpretDeviceReply for further action.
 	 *
 	 * It also resets the timeout counter for the command id.
 	 *
@@ -1184,7 +1220,7 @@ private:
 	 * @param[out] len
 	 * @return
 	 *   - @c RETURN_OK @c data is valid
-	 *   - @c RETURN_FAILED IPCStore is NULL
+	 *   - @c RETURN_FAILED IPCStore is nullptr
 	 *   - the return value from the IPCStore if it was not @c RETURN_OK
 	 */
 	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
@@ -1208,6 +1244,9 @@ private:
 
     void parseReply(const uint8_t* receivedData,
                 size_t receivedDataLen);
+
+    void handleTransitionToOnMode(Mode_t commandedMode,
+    		Submode_t commandedSubmode);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */

From e9a740f110c61cff3c836afecfdb1f635ba533f5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 16:00:02 +0100
Subject: [PATCH 1123/1774] small tweak

---
 devicehandlers/DeviceHandlerBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 49617cd5a..2bfa62a66 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -234,7 +234,7 @@ protected:
 	 *  - If the device does not change the mode, the mode will be changed to
 	 *    _MODE_POWER_DOWN, when the timeout (from getTransitionDelay())
 	 *    has passed.
-	 * 0xffffffff
+	 *
 	 * #transitionFailure can be set to a failure code indicating the reason
 	 * for a failed transition
 	 */

From df333e0cc828afaacc7b591527ea724b342025b5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 16:01:23 +0100
Subject: [PATCH 1124/1774] tab replacement

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 733106e57..f095834e2 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -113,7 +113,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		doGetRead();
 		// This will be performed after datasets have been updated by the
 		// custom device implementation.
-        hkManager.performHkOperation();
+		hkManager.performHkOperation();
 		break;
 	default:
 		break;

From 46596f9397d7cea1a82a16f093117e64e133c919 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 16:01:48 +0100
Subject: [PATCH 1125/1774] tab changed

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 733106e57..f095834e2 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -113,7 +113,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		doGetRead();
 		// This will be performed after datasets have been updated by the
 		// custom device implementation.
-        hkManager.performHkOperation();
+		hkManager.performHkOperation();
 		break;
 	default:
 		break;

From ff62ab8427f84442cb14759e81fb03972caa7bfc Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 16:32:52 +0100
Subject: [PATCH 1126/1774] removed core component

---
 thermal/CoreComponent.cpp | 257 --------------------------------------
 thermal/CoreComponent.h   |  96 --------------
 2 files changed, 353 deletions(-)
 delete mode 100644 thermal/CoreComponent.cpp
 delete mode 100644 thermal/CoreComponent.h

diff --git a/thermal/CoreComponent.cpp b/thermal/CoreComponent.cpp
deleted file mode 100644
index 657e79cb0..000000000
--- a/thermal/CoreComponent.cpp
+++ /dev/null
@@ -1,257 +0,0 @@
-#include "CoreComponent.h"
-
-CoreComponent::CoreComponent(object_id_t reportingObjectId, uint8_t domainId,
-		uint32_t temperaturePoolId, uint32_t targetStatePoolId,
-		uint32_t currentStatePoolId, uint32_t requestPoolId, GlobDataSet* dataSet,
-		AbstractTemperatureSensor* sensor,
-		AbstractTemperatureSensor* firstRedundantSensor,
-		AbstractTemperatureSensor* secondRedundantSensor,
-		ThermalModuleIF* thermalModule, Parameters parameters,
-		Priority priority, StateRequest initialTargetState) :
-		sensor(sensor), firstRedundantSensor(firstRedundantSensor), secondRedundantSensor(
-				secondRedundantSensor), thermalModule(thermalModule), temperature(
-				temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
-				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ), currentState(
-				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), heaterRequest(
-				requestPoolId, dataSet, PoolVariableIF::VAR_WRITE), isHeating(
-		false), isSafeComponent(priority == SAFE), minTemp(999), maxTemp(
-				AbstractTemperatureSensor::ZERO_KELVIN_C), parameters(
-				parameters), temperatureMonitor(reportingObjectId,
-				domainId + 1,
-				GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
-				COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
-	if (thermalModule != NULL) {
-		thermalModule->registerComponent(this, priority);
-	}
-	//Set thermal state once, then leave to operator.
-	GlobDataSet mySet;
-	gp_uint8_t writableTargetState(targetStatePoolId, &mySet,
-			PoolVariableIF::VAR_WRITE);
-	writableTargetState = initialTargetState;
-	mySet.commit(PoolVariableIF::VALID);
-}
-
-CoreComponent::~CoreComponent() {
-}
-
-ThermalComponentIF::HeaterRequest CoreComponent::performOperation(uint8_t opCode) {
-	HeaterRequest request = HEATER_DONT_CARE;
-	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
-	temperature = getTemperature();
-	updateMinMaxTemp();
-	if ((temperature != INVALID_TEMPERATURE)) {
-		temperature.setValid(PoolVariableIF::VALID);
-		State state = getState(temperature, getParameters(), targetState);
-		currentState = state;
-		checkLimits(state);
-		request = getHeaterRequest(targetState, temperature, getParameters());
-	} else {
-		temperatureMonitor.setToInvalid();
-		temperature.setValid(PoolVariableIF::INVALID);
-		currentState = UNKNOWN;
-		request = HEATER_DONT_CARE;
-	}
-	currentState.setValid(PoolVariableIF::VALID);
-	heaterRequest = request;
-	heaterRequest.setValid(PoolVariableIF::VALID);
-	return request;
-}
-
-void CoreComponent::markStateIgnored() {
-	currentState = getIgnoredState(currentState);
-}
-
-object_id_t CoreComponent::getObjectId() {
-	return temperatureMonitor.getReporterId();
-}
-
-float CoreComponent::getLowerOpLimit() {
-	return parameters.lowerOpLimit;
-}
-
-ReturnValue_t CoreComponent::setTargetState(int8_t newState) {
-	GlobDataSet mySet;
-	gp_uint8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
-	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
-			&& (newState != STATE_REQUEST_IGNORE)) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	switch (newState) {
-	case STATE_REQUEST_HEATING:
-	case STATE_REQUEST_IGNORE:
-	case STATE_REQUEST_OPERATIONAL:
-		writableTargetState = newState;
-		break;
-	case STATE_REQUEST_NON_OPERATIONAL:
-	default:
-		return INVALID_TARGET_STATE;
-	}
-	mySet.commit(PoolVariableIF::VALID);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void CoreComponent::setOutputInvalid() {
-	temperature = INVALID_TEMPERATURE;
-	temperature.setValid(PoolVariableIF::INVALID);
-	currentState.setValid(PoolVariableIF::INVALID);
-	heaterRequest = HEATER_DONT_CARE;
-	heaterRequest.setValid(PoolVariableIF::INVALID);
-	temperatureMonitor.setToUnchecked();
-}
-
-float CoreComponent::getTemperature() {
-	if ((sensor != NULL) && (sensor->isValid())) {
-		return sensor->getTemperature();
-	}
-
-	if ((firstRedundantSensor != NULL) && (firstRedundantSensor->isValid())) {
-		return firstRedundantSensor->getTemperature();
-	}
-
-	if ((secondRedundantSensor != NULL) && (secondRedundantSensor->isValid())) {
-		return secondRedundantSensor->getTemperature();
-	}
-
-	if (thermalModule != NULL) {
-		float temperature = thermalModule->getTemperature();
-		if (temperature != ThermalModuleIF::INVALID_TEMPERATURE) {
-			return temperature;
-		} else {
-			return INVALID_TEMPERATURE;
-		}
-	} else {
-		return INVALID_TEMPERATURE;
-	}
-}
-
-ThermalComponentIF::State CoreComponent::getState(float temperature,
-		Parameters parameters, int8_t targetState) {
-	ThermalComponentIF::State state;
-
-	if (temperature < parameters.lowerOpLimit) {
-		state = NON_OPERATIONAL_LOW;
-	} else if (temperature < parameters.upperOpLimit) {
-		state = OPERATIONAL;
-	} else {
-		state = NON_OPERATIONAL_HIGH;
-	}
-	if (targetState == STATE_REQUEST_IGNORE) {
-		state = getIgnoredState(state);
-	}
-
-	return state;
-}
-
-void CoreComponent::checkLimits(ThermalComponentIF::State state) {
-	//Checks operational limits only.
-	temperatureMonitor.translateState(state, temperature.value,
-			getParameters().lowerOpLimit, getParameters().upperOpLimit);
-
-}
-
-ThermalComponentIF::HeaterRequest CoreComponent::getHeaterRequest(
-		int8_t targetState, float temperature, Parameters parameters) {
-	if (targetState == STATE_REQUEST_IGNORE) {
-		isHeating = false;
-		return HEATER_DONT_CARE;
-	}
-
-	if (temperature > parameters.upperOpLimit - parameters.heaterSwitchoff) {
-		isHeating = false;
-		return HEATER_REQUEST_EMERGENCY_OFF;
-	}
-
-	float opHeaterLimit = parameters.lowerOpLimit + parameters.heaterOn;
-
-	if (isHeating) {
-		opHeaterLimit += parameters.hysteresis;
-	}
-
-	if (temperature < opHeaterLimit) {
-		isHeating = true;
-		return HEATER_REQUEST_EMERGENCY_ON;
-	}
-	isHeating = false;
-	return HEATER_DONT_CARE;
-}
-
-ThermalComponentIF::State CoreComponent::getIgnoredState(int8_t state) {
-	switch (state) {
-	case NON_OPERATIONAL_LOW:
-		return NON_OPERATIONAL_LOW_IGNORED;
-	case OPERATIONAL:
-		return OPERATIONAL_IGNORED;
-	case NON_OPERATIONAL_HIGH:
-		return NON_OPERATIONAL_HIGH_IGNORED;
-	case NON_OPERATIONAL_LOW_IGNORED:
-		return NON_OPERATIONAL_LOW_IGNORED;
-	case OPERATIONAL_IGNORED:
-		return OPERATIONAL_IGNORED;
-	case NON_OPERATIONAL_HIGH_IGNORED:
-		return NON_OPERATIONAL_HIGH_IGNORED;
-	default:
-	case UNKNOWN:
-		return UNKNOWN;
-	}
-}
-
-void CoreComponent::updateMinMaxTemp() {
-	if (temperature == INVALID_TEMPERATURE) {
-		return;
-	}
-	if (temperature < minTemp) {
-		minTemp = temperature;
-	}
-	if (temperature > maxTemp) {
-		maxTemp = temperature;
-	}
-}
-
-uint8_t CoreComponent::getDomainId() const {
-	return domainId;
-}
-
-CoreComponent::Parameters CoreComponent::getParameters() {
-	return parameters;
-}
-
-ReturnValue_t CoreComponent::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = temperatureMonitor.getParameter(domainId,
-			parameterId, parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	if (domainId != this->domainId) {
-		return INVALID_DOMAIN_ID;
-	}
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set(parameters.heaterOn);
-		break;
-	case 1:
-		parameterWrapper->set(parameters.hysteresis);
-		break;
-	case 2:
-		parameterWrapper->set(parameters.heaterSwitchoff);
-		break;
-	case 3:
-		parameterWrapper->set(minTemp);
-		break;
-	case 4:
-		parameterWrapper->set(maxTemp);
-		break;
-	case 10:
-		parameterWrapper->set(parameters.lowerOpLimit);
-		break;
-	case 11:
-		parameterWrapper->set(parameters.upperOpLimit);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
deleted file mode 100644
index 8093711d6..000000000
--- a/thermal/CoreComponent.h
+++ /dev/null
@@ -1,96 +0,0 @@
-#ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-#define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../thermal/ThermalComponentIF.h"
-#include "../thermal/AbstractTemperatureSensor.h"
-#include "../thermal/ThermalModule.h"
-#include "../thermal/ThermalMonitor.h"
-
-// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
-class CoreComponent: public ThermalComponentIF {
-public:
-	struct Parameters {
-		float lowerOpLimit;
-		float upperOpLimit;
-		float heaterOn;
-		float hysteresis;
-		float heaterSwitchoff;
-	};
-
-	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
-
-	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
-			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-			uint32_t requestPoolId, GlobDataSet *dataSet,
-			AbstractTemperatureSensor *sensor,
-			AbstractTemperatureSensor *firstRedundantSensor,
-			AbstractTemperatureSensor *secondRedundantSensor,
-			ThermalModuleIF *thermalModule, Parameters parameters,
-			Priority priority, StateRequest initialTargetState =
-					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
-
-	virtual ~CoreComponent();
-
-	virtual HeaterRequest performOperation(uint8_t opCode);
-
-	void markStateIgnored();
-
-	object_id_t getObjectId();
-
-	uint8_t getDomainId() const;
-
-	virtual float getLowerOpLimit();
-
-	ReturnValue_t setTargetState(int8_t newState);
-
-	virtual void setOutputInvalid();
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-protected:
-
-	AbstractTemperatureSensor *sensor;
-	AbstractTemperatureSensor *firstRedundantSensor;
-	AbstractTemperatureSensor *secondRedundantSensor;
-	ThermalModuleIF *thermalModule;
-
-	gp_float_t temperature;
-	gp_int8_t targetState;
-	gp_int8_t currentState;
-	gp_uint8_t heaterRequest;
-
-	bool isHeating;
-
-	bool isSafeComponent;
-
-	float minTemp;
-
-	float maxTemp;
-
-	Parameters parameters;
-
-	ThermalMonitor temperatureMonitor;
-
-	const uint8_t domainId;
-
-	virtual float getTemperature();
-	virtual State getState(float temperature, Parameters parameters,
-			int8_t targetState);
-
-	virtual void checkLimits(State state);
-
-	virtual HeaterRequest getHeaterRequest(int8_t targetState,
-			float temperature, Parameters parameters);
-
-	virtual State getIgnoredState(int8_t state);
-
-	void updateMinMaxTemp();
-
-	virtual Parameters getParameters();
-};
-
-#endif /* MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ */

From 0a5099e293acc10407dcfe8078fddca303b901a3 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 16:34:25 +0100
Subject: [PATCH 1127/1774] deleted file which was renamed

---
 thermal/ThermalMonitor.cpp | 68 --------------------------------------
 thermal/ThermalMonitor.h   | 23 -------------
 2 files changed, 91 deletions(-)
 delete mode 100644 thermal/ThermalMonitor.cpp
 delete mode 100644 thermal/ThermalMonitor.h

diff --git a/thermal/ThermalMonitor.cpp b/thermal/ThermalMonitor.cpp
deleted file mode 100644
index 11abfbe54..000000000
--- a/thermal/ThermalMonitor.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "ThermalMonitor.h"
-#include "ThermalComponentIF.h"
-#include "../monitoring/MonitoringIF.h"
-ThermalMonitor::~ThermalMonitor() {
-}
-
-void ThermalMonitor::sendTransitionEvent(float currentValue,
-		ReturnValue_t state) {
-	switch (state) {
-	case MonitoringIF::BELOW_LOW_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_OOL_LOW, state);
-		break;
-	case MonitoringIF::ABOVE_HIGH_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH, state);
-		break;
-	case ThermalComponentIF::BELOW_OPERATIONAL_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_LOW, state);
-		break;
-	case ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_HIGH, state);
-		break;
-	default:
-		break;
-	}
-}
-
-bool ThermalMonitor::isAboveHighLimit() {
-	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-ReturnValue_t ThermalMonitor::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
-		float upperLimit, bool componentIsOperational) {
-	if (ThermalComponentIF::isIgnoredState(state)) {
-		setToUnchecked();
-		return MonitoringIF::UNCHECKED;
-	}
-	switch (state) {
-	case ThermalComponentIF::OUT_OF_RANGE_LOW:
-		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample, lowerLimit);
-	case ThermalComponentIF::NON_OPERATIONAL_LOW:
-		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT, sample, lowerLimit);
-		} else {
-			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-		}
-	case ThermalComponentIF::OPERATIONAL:
-		return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-	case ThermalComponentIF::NON_OPERATIONAL_HIGH:
-		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT, sample, upperLimit);
-		} else {
-			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-		}
-	case ThermalComponentIF::OUT_OF_RANGE_HIGH:
-		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample, upperLimit);
-	default:
-		//Never reached, all states covered.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
diff --git a/thermal/ThermalMonitor.h b/thermal/ThermalMonitor.h
deleted file mode 100644
index 5c6806c1d..000000000
--- a/thermal/ThermalMonitor.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_
-#define FRAMEWORK_THERMAL_THERMALMONITOR_H_
-
-#include "../monitoring/MonitorReporter.h"
-#include "ThermalComponentIF.h"
-
-class ThermalMonitor: public MonitorReporter<float> {
-public:
-	template<typename ... Args>
-	ThermalMonitor(Args ... args) :
-			MonitorReporter<float>(std::forward<Args>(args)...) {
-	}
-	~ThermalMonitor();
-	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
-			float lowerLimit, float upperLimit, bool componentIsOperational = true);
-
-	bool isAboveHighLimit();
-protected:
-	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
-
-};
-
-#endif /* FRAMEWORK_THERMAL_THERMALMONITOR_H_ */

From f81c9d7ecc54442eeabfae066f4fafc7feae7698 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 16:36:09 +0100
Subject: [PATCH 1128/1774] resolved merge conflicts

---
 thermal/ThermalModule.cpp | 28 ----------------------------
 1 file changed, 28 deletions(-)

diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index cc541c8cc..2bc1741f6 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -5,15 +5,9 @@
 #include "../monitoring/MonitoringMessageContent.h"
 
 
-<<<<<<< HEAD
 ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
 		gp_id_t currentStatePoolId, gp_id_t targetStatePoolId,
 		LocalPoolDataSetBase *dataSet, Parameters parameters,
-=======
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
-		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
-		GlobDataSet *dataSet, Parameters parameters,
->>>>>>> upstream/development
 		RedundantHeater::Parameters heaterParameters) :
 		oldStrategy(ACTIVE_SINGLE), parameters(parameters),
 		moduleTemperature(moduleTemperaturePoolId, dataSet,
@@ -23,7 +17,6 @@ ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
 	heater = new RedundantHeater(heaterParameters);
 }
 
-<<<<<<< HEAD
 ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
 		LocalPoolDataSetBase* dataSet) :
 		oldStrategy(ACTIVE_SINGLE), parameters( { 0, 0 }),
@@ -33,15 +26,6 @@ ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
 				PoolVariableIF::VAR_WRITE),
 		targetState(gp_id_t(), dataSet,
 				PoolVariableIF::VAR_READ) {
-=======
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters( { 0, 0 }), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
-				NULL), currentState(PoolVariableIF::INVALID, dataSet,
-				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
-				dataSet, PoolVariableIF::VAR_READ) {
->>>>>>> upstream/development
 }
 
 ThermalModule::~ThermalModule() {
@@ -272,7 +256,6 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 }
 
 void ThermalModule::setHeating(bool on) {
-<<<<<<< HEAD
 //	GlobDataSet mySet;
 //	gp_int8_t writableTargetState(targetState.getDataPoolId(),
 //			&mySet, PoolVariableIF::VAR_WRITE);
@@ -282,17 +265,6 @@ void ThermalModule::setHeating(bool on) {
 //		writableTargetState = STATE_REQUEST_PASSIVE;
 //	}
 //	mySet.commit(PoolVariableIF::VALID);
-=======
-	GlobDataSet mySet;
-	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_WRITE);
-	if (on) {
-		writableTargetState = STATE_REQUEST_HEATING;
-	} else {
-		writableTargetState = STATE_REQUEST_PASSIVE;
-	}
-	mySet.commit(PoolVariableIF::VALID);
->>>>>>> upstream/development
 }
 
 void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,

From 9a540e97c557e58a8b7b933c6f41fde21e8fa315 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 16:36:44 +0100
Subject: [PATCH 1129/1774] taken over thermal module from thermal-update

---
 thermal/ThermalModule.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index d1e4fccbf..0abe51c7e 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -5,8 +5,6 @@
 #include "tcsDefinitions.h"
 #include "RedundantHeater.h"
 
-//#include "../datapoolglob/GlobalDataSet.h"
-//#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../datapoollocal/LocalPoolDataSetBase.h"
 #include "../datapoollocal/LocalPoolVariable.h"
 #include "../devicehandlers/HealthDevice.h"
@@ -78,7 +76,6 @@ protected:
 	Parameters parameters;
 
 	lp_var_t<float> moduleTemperature;
-	//gp_float_t moduleTemperature;
 
 	RedundantHeater *heater = nullptr;
 

From 5bad1142059af8a946fe57c0cad31284fd8496ea Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 16:39:31 +0100
Subject: [PATCH 1130/1774] thermal module set heating repaired

---
 thermal/ThermalModule.cpp | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index 2bc1741f6..457a6743d 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -256,15 +256,16 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 }
 
 void ThermalModule::setHeating(bool on) {
-//	GlobDataSet mySet;
-//	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-//			&mySet, PoolVariableIF::VAR_WRITE);
-//	if (on) {
-//		writableTargetState = STATE_REQUEST_HEATING;
-//	} else {
-//		writableTargetState = STATE_REQUEST_PASSIVE;
-//	}
-//	mySet.commit(PoolVariableIF::VALID);
+	ReturnValue_t result = targetState.read();
+	if(result == HasReturnvaluesIF::RETURN_OK) {
+		if(on) {
+			targetState.value = STATE_REQUEST_HEATING;
+		}
+		else {
+			targetState.value = STATE_REQUEST_PASSIVE;
+		}
+	}
+	targetState.setValid(true);
 }
 
 void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,

From be9913f262e879f8c264f54550d61e983fddc1e5 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 16:40:22 +0100
Subject: [PATCH 1131/1774] themral module update

---
 thermal/ThermalModule.cpp | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index 2bc1741f6..457a6743d 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -256,15 +256,16 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 }
 
 void ThermalModule::setHeating(bool on) {
-//	GlobDataSet mySet;
-//	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-//			&mySet, PoolVariableIF::VAR_WRITE);
-//	if (on) {
-//		writableTargetState = STATE_REQUEST_HEATING;
-//	} else {
-//		writableTargetState = STATE_REQUEST_PASSIVE;
-//	}
-//	mySet.commit(PoolVariableIF::VALID);
+	ReturnValue_t result = targetState.read();
+	if(result == HasReturnvaluesIF::RETURN_OK) {
+		if(on) {
+			targetState.value = STATE_REQUEST_HEATING;
+		}
+		else {
+			targetState.value = STATE_REQUEST_PASSIVE;
+		}
+	}
+	targetState.setValid(true);
 }
 
 void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,

From 50ad2c03809502d9494e37bff99a54bf39fc024c Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 16:57:43 +0100
Subject: [PATCH 1132/1774] resolved merge conflicts

---
 power/Fuse.h | 24 +-----------------------
 1 file changed, 1 insertion(+), 23 deletions(-)

diff --git a/power/Fuse.h b/power/Fuse.h
index 8a1b29f00..b892611bc 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -1,21 +1,11 @@
 #ifndef FSFW_POWER_FUSE_H_
 #define FSFW_POWER_FUSE_H_
 
-<<<<<<< HEAD
 #include "PowerComponentIF.h"
 #include "PowerSwitchIF.h"
 
 #include "../devicehandlers/HealthDevice.h"
 #include "../monitoring/AbsLimitMonitor.h"
-=======
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../datapoolglob/PIDReader.h"
-#include "../devicehandlers/HealthDevice.h"
-#include "../monitoring/AbsLimitMonitor.h"
-#include "../power/PowerComponentIF.h"
-#include "../power/PowerSwitchIF.h"
->>>>>>> upstream/development
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../parameters/ParameterHelper.h"
 #include <list>
@@ -94,26 +84,14 @@ private:
 
 	};
 	PowerMonitor powerMonitor;
-<<<<<<< HEAD
 	StaticLocalDataSet<3> set;
-	//LocalPoolDataSetBase* set = nullptr;
-	//PIDReader<float> voltage;
-	//PIDReader<float> current;
-	//PIDReader<uint8_t> state;
+
 	lp_var_t<float> voltage;
 	lp_var_t<float> current;
 	lp_var_t<uint8_t> state;
 
 	lp_var_t<float> power;
 	MessageQueueIF* commandQueue = nullptr;
-=======
-	GlobDataSet set;
-	PIDReader<float> voltage;
-	PIDReader<float> current;
-	PIDReader<uint8_t> state;
-	gp_float_t power;
-	MessageQueueIF* commandQueue;
->>>>>>> upstream/development
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
 	static object_id_t powerSwitchId;

From b2d01a31c224cf609ed2cc83e5e482604881a64d Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 16:58:18 +0100
Subject: [PATCH 1133/1774] removed some commented stuff

---
 power/Fuse.h | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/power/Fuse.h b/power/Fuse.h
index cc1d534f4..b892611bc 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -85,10 +85,7 @@ private:
 	};
 	PowerMonitor powerMonitor;
 	StaticLocalDataSet<3> set;
-	//LocalPoolDataSetBase* set = nullptr;
-	//PIDReader<float> voltage;
-	//PIDReader<float> current;
-	//PIDReader<uint8_t> state;
+
 	lp_var_t<float> voltage;
 	lp_var_t<float> current;
 	lp_var_t<uint8_t> state;

From a2823835dd8f6708fd004aef2d95d74547c7cdf7 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 17:05:41 +0100
Subject: [PATCH 1134/1774] explicit cast added

---
 parameters/ParameterWrapper.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 239555162..d9f1ef685 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -123,7 +123,8 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
 		//get the start element of this row in data
-	    uint16_t offset = (((startingRow + fromRow) * columns) + startingColumn);
+	    uint16_t offset = (((startingRow + fromRow) *
+	    		static_cast<uint16_t>(columns)) + startingColumn);
 		T *dataWithDataType = static_cast<T*>(data) + offset;
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
@@ -296,8 +297,8 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		//need a type to do arithmetic
 		uint8_t* typedData = static_cast<uint8_t*>(data);
 		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
-			size_t offset = (((startingRow + fromRow) * columns) +
-					startingColumn) * typeSize;
+			size_t offset = (((startingRow + fromRow) * static_cast<uint16_t>(
+					columns)) + startingColumn) * typeSize;
 			std::memcpy(typedData +  offset, from->readonlyData,
 					typeSize * from->columns);
 		}

From 7986584d17d65da8ed06fc217b216472e0cc12da Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 17:18:46 +0100
Subject: [PATCH 1135/1774] updated comment

---
 devicehandlers/DeviceHandlerBase.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 2bfa62a66..9a5287e03 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -746,6 +746,7 @@ protected:
 	/**
 	 * Helper function to get pending command. This is useful for devices
 	 * like SPI sensors to identify the last sent command.
+	 * This only returns the command sent in the last SEND_WRITE cycle.
 	 * @return
 	 */
 	DeviceCommandId_t getPendingCommand() const;

From bb7ebf4b275331db5181826e8be33088170f9a8d Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 17:29:23 +0100
Subject: [PATCH 1136/1774] removed glob pool

---
 datapoolglob/ControllerSet.cpp            |  14 -
 datapoolglob/ControllerSet.h              |  15 --
 datapoolglob/DataPoolAdmin.cpp            | 301 ----------------------
 datapoolglob/DataPoolAdmin.h              |  60 -----
 datapoolglob/DataPoolParameterWrapper.cpp | 179 -------------
 datapoolglob/DataPoolParameterWrapper.h   |  38 ---
 datapoolglob/GlobalDataPool.cpp           | 133 ----------
 datapoolglob/GlobalDataPool.h             | 149 -----------
 datapoolglob/GlobalDataSet.cpp            |  48 ----
 datapoolglob/GlobalDataSet.h              |  98 -------
 datapoolglob/GlobalPoolVariable.h         | 213 ---------------
 datapoolglob/GlobalPoolVariable.tpp       | 117 ---------
 datapoolglob/GlobalPoolVector.h           | 185 -------------
 datapoolglob/GlobalPoolVector.tpp         | 117 ---------
 datapoolglob/PIDReader.h                  | 164 ------------
 datapoolglob/PIDReaderList.h              |  27 --
 datapoolglob/PoolRawAccess.cpp            | 239 -----------------
 datapoolglob/PoolRawAccess.h              | 220 ----------------
 18 files changed, 2317 deletions(-)
 delete mode 100644 datapoolglob/ControllerSet.cpp
 delete mode 100644 datapoolglob/ControllerSet.h
 delete mode 100644 datapoolglob/DataPoolAdmin.cpp
 delete mode 100644 datapoolglob/DataPoolAdmin.h
 delete mode 100644 datapoolglob/DataPoolParameterWrapper.cpp
 delete mode 100644 datapoolglob/DataPoolParameterWrapper.h
 delete mode 100644 datapoolglob/GlobalDataPool.cpp
 delete mode 100644 datapoolglob/GlobalDataPool.h
 delete mode 100644 datapoolglob/GlobalDataSet.cpp
 delete mode 100644 datapoolglob/GlobalDataSet.h
 delete mode 100644 datapoolglob/GlobalPoolVariable.h
 delete mode 100644 datapoolglob/GlobalPoolVariable.tpp
 delete mode 100644 datapoolglob/GlobalPoolVector.h
 delete mode 100644 datapoolglob/GlobalPoolVector.tpp
 delete mode 100644 datapoolglob/PIDReader.h
 delete mode 100644 datapoolglob/PIDReaderList.h
 delete mode 100644 datapoolglob/PoolRawAccess.cpp
 delete mode 100644 datapoolglob/PoolRawAccess.h

diff --git a/datapoolglob/ControllerSet.cpp b/datapoolglob/ControllerSet.cpp
deleted file mode 100644
index 54fc6e8c9..000000000
--- a/datapoolglob/ControllerSet.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <fsfw/datapoolglob/ControllerSet.h>
-
-ControllerSet::ControllerSet() {
-
-}
-
-ControllerSet::~ControllerSet() {
-}
-
-void ControllerSet::setInvalid() {
-	read();
-	setToDefault();
-	commit(PoolVariableIF::INVALID);
-}
diff --git a/datapoolglob/ControllerSet.h b/datapoolglob/ControllerSet.h
deleted file mode 100644
index 5da113973..000000000
--- a/datapoolglob/ControllerSet.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef FSFW_DATAPOOLGLOB_CONTROLLERSET_H_
-#define FSFW_DATAPOOLGLOB_CONTROLLERSET_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-
-class ControllerSet :public GlobDataSet {
-public:
-	ControllerSet();
-	virtual ~ControllerSet();
-
-	virtual void setToDefault() = 0;
-	void setInvalid();
-};
-
-#endif /*  FSFW_DATAPOOLGLOB_CONTROLLERSET_H_ */
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
deleted file mode 100644
index 6ede0841e..000000000
--- a/datapoolglob/DataPoolAdmin.cpp
+++ /dev/null
@@ -1,301 +0,0 @@
-#include "DataPoolAdmin.h"
-#include "GlobalDataSet.h"
-#include "GlobalDataPool.h"
-#include "PoolRawAccess.h"
-
-#include "../ipc/CommandMessage.h"
-#include "../ipc/QueueFactory.h"
-#include "../parameters/ParameterMessage.h"
-
-DataPoolAdmin::DataPoolAdmin(object_id_t objectId) :
-		SystemObject(objectId), storage(NULL), commandQueue(NULL), memoryHelper(
-				this, NULL), actionHelper(this, NULL) {
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-DataPoolAdmin::~DataPoolAdmin() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t DataPoolAdmin::performOperation(uint8_t opCode) {
-	handleCommand();
-	return RETURN_OK;
-}
-
-MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
-	if (actionId != SET_VALIDITY) {
-		return INVALID_ACTION_ID;
-	}
-
-	if (size != 5) {
-		return INVALID_PARAMETERS;
-	}
-
-	uint32_t address = (data[0] << 24) | (data[1] << 16) | (data[2] << 8)
-			| data[3];
-
-	uint8_t valid = data[4];
-
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-
-	GlobDataSet mySet;
-	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
-	ReturnValue_t status = mySet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	if (valid != 0) {
-		variable.setValid(PoolVariableIF::VALID);
-	} else {
-		variable.setValid(PoolVariableIF::INVALID);
-	}
-
-	mySet.commit();
-
-	return EXECUTION_FINISHED;
-}
-
-ReturnValue_t DataPoolAdmin::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-void DataPoolAdmin::handleCommand() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != RETURN_OK) {
-		return;
-	}
-
-	result = actionHelper.handleActionMessage(&command);
-
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-
-	result = handleParameterCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-
-	result = memoryHelper.handleMemoryCommand(&command);
-	if (result != RETURN_OK) {
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
-}
-
-ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
-		const uint8_t* data, size_t size, uint8_t** dataPointer) {
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
-	GlobDataSet testSet;
-	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
-			PoolVariableIF::VAR_READ);
-	ReturnValue_t status = testSet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	uint8_t typeSize = varToGetSize.getSizeOfType();
-
-	if (size % typeSize != 0) {
-		return INVALID_SIZE;
-	}
-
-	if (size > varToGetSize.getSizeTillEnd()) {
-		return INVALID_SIZE;
-	}
-	const uint8_t* readPosition = data;
-
-	for (; size > 0; size -= typeSize) {
-		GlobDataSet rawSet;
-		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
-				PoolVariableIF::VAR_READ_WRITE);
-		status = rawSet.read();
-		if (status == RETURN_OK) {
-			status = variable.setEntryFromBigEndian(readPosition, typeSize);
-			if (status == RETURN_OK) {
-				status = rawSet.commit();
-			}
-		}
-		arrayIndex += 1;
-		readPosition += typeSize;
-	}
-	return ACTIVITY_COMPLETED;
-}
-
-ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
-		uint8_t** dataPointer, uint8_t* copyHere) {
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
-	GlobDataSet testSet;
-	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
-			PoolVariableIF::VAR_READ);
-	ReturnValue_t status = testSet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	uint8_t typeSize = varToGetSize.getSizeOfType();
-	if (size > varToGetSize.getSizeTillEnd()) {
-		return INVALID_SIZE;
-	}
-	uint8_t* ptrToCopy = copyHere;
-	for (; size > 0; size -= typeSize) {
-		GlobDataSet rawSet;
-		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
-				PoolVariableIF::VAR_READ);
-		status = rawSet.read();
-		if (status == RETURN_OK) {
-			size_t temp = 0;
-			status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
-			if (status != RETURN_OK) {
-				return RETURN_FAILED;
-			}
-		} else {
-			//Error reading parameter.
-		}
-		arrayIndex += 1;
-		ptrToCopy += typeSize;
-	}
-	return ACTIVITY_COMPLETED;
-}
-
-ReturnValue_t DataPoolAdmin::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = memoryHelper.initialize(commandQueue);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (storage == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	result = actionHelper.initialize(commandQueue);
-
-	return result;
-}
-
-//mostly identical to ParameterHelper::handleParameterMessage()
-ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch (command->getCommand()) {
-	case ParameterMessage::CMD_PARAMETER_DUMP: {
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(command));
-
-		DataPoolParameterWrapper wrapper;
-		result = wrapper.set(domain, parameterId);
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(command->getSender(),
-					ParameterMessage::getParameterId(command), &wrapper);
-		}
-	}
-		break;
-	case ParameterMessage::CMD_PARAMETER_LOAD: {
-
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(command));
-		uint8_t index = HasParametersIF::getIndex(
-				ParameterMessage::getParameterId(command));
-
-		const uint8_t *storedStream;
-		size_t storedStreamSize;
-		result = storage->getData(ParameterMessage::getStoreId(command),
-				&storedStream, &storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-
-		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(storedStream, storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(command));
-			break;
-		}
-
-		DataPoolParameterWrapper poolWrapper;
-		result = poolWrapper.set(domain, parameterId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(command));
-			break;
-		}
-
-		result = poolWrapper.copyFrom(&streamWrapper, index);
-
-		storage->deleteData(ParameterMessage::getStoreId(command));
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(command->getSender(),
-					ParameterMessage::getParameterId(command), &poolWrapper);
-		}
-	}
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		rejectCommand(command->getSender(), result, command->getCommand());
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-//identical to ParameterHelper::sendParameter()
-ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
-		const DataPoolParameterWrapper* wrapper) {
-	size_t serializedSize = wrapper->getSerializedSize();
-
-	uint8_t *storeElement;
-	store_address_t address;
-
-	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
-			&storeElement);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	size_t storeElementSize = 0;
-
-	result = wrapper->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		storage->deleteData(address);
-		return result;
-	}
-
-	CommandMessage reply;
-
-	ParameterMessage::setParameterDumpReply(&reply, id, address);
-
-	commandQueue->sendMessage(to, &reply);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//identical to ParameterHelper::rejectCommand()
-void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-		Command_t initialCommand) {
-	CommandMessage reply;
-	reply.setReplyRejected(reason, initialCommand);
-	commandQueue->sendMessage(to, &reply);
-}
diff --git a/datapoolglob/DataPoolAdmin.h b/datapoolglob/DataPoolAdmin.h
deleted file mode 100644
index d8871b651..000000000
--- a/datapoolglob/DataPoolAdmin.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_
-#define FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_
-
-#include "DataPoolParameterWrapper.h"
-
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../action/HasActionsIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../parameters/ReceivesParameterMessagesIF.h"
-#include "../action/SimpleActionHelper.h"
-#include "../memory/MemoryHelper.h"
-
-
-class DataPoolAdmin: public HasActionsIF,
-		public ExecutableObjectIF,
-		public AcceptsMemoryMessagesIF,
-		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF,
-		public SystemObject {
-public:
-	static const ActionId_t SET_VALIDITY = 1;
-
-	DataPoolAdmin(object_id_t objectId);
-
-	~DataPoolAdmin();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
-			size_t size, uint8_t** dataPointer);
-	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
-			uint8_t** dataPointer, uint8_t* copyHere);
-
-	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
-
-	//not implemented as ParameterHelper is no used
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-	ReturnValue_t initialize();
-private:
-	StorageManagerIF *storage;
-	MessageQueueIF* commandQueue;
-	MemoryHelper memoryHelper;
-	SimpleActionHelper actionHelper;
-	void handleCommand();
-	ReturnValue_t handleParameterCommand(CommandMessage *command);
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
-			const DataPoolParameterWrapper* wrapper);
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-			Command_t initialCommand);
-};
-
-#endif /* FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_ */
diff --git a/datapoolglob/DataPoolParameterWrapper.cpp b/datapoolglob/DataPoolParameterWrapper.cpp
deleted file mode 100644
index 3a57d90df..000000000
--- a/datapoolglob/DataPoolParameterWrapper.cpp
+++ /dev/null
@@ -1,179 +0,0 @@
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/DataPoolParameterWrapper.h"
-#include "../datapoolglob/PoolRawAccess.h"
-#include "../parameters/HasParametersIF.h"
-
-
-DataPoolParameterWrapper::DataPoolParameterWrapper() :
-		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
-				PoolVariableIF::NO_PARAMETER) {
-
-}
-
-DataPoolParameterWrapper::~DataPoolParameterWrapper() {
-
-}
-
-ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
-		uint16_t parameterId) {
-	poolId = (domainId << 16) + parameterId;
-
-	GlobDataSet mySet;
-	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
-	ReturnValue_t status = mySet.read();
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		//should only fail for invalid pool id
-		return HasParametersIF::INVALID_MATRIX_ID;
-	}
-
-	type = raw.getType();
-	rows = raw.getArraySize();
-	columns = 1;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result;
-
-	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&columns, buffer, size,
-			maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	for (uint8_t index = 0; index < rows; index++){
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
-		mySet.read();
-		result = raw.serialize(buffer,size,maxSize,streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//same as ParameterWrapper
-size_t DataPoolParameterWrapper::getSerializedSize() const {
-	size_t serializedSize = 0;
-	serializedSize += type.getSerializedSize();
-	serializedSize += sizeof(rows);
-	serializedSize += sizeof(columns);
-	serializedSize += rows * columns * type.getSize();
-
-	return serializedSize;
-}
-
-ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-template<typename T>
-ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
-		uint8_t startingColumn, const void* from, uint8_t fromRows) {
-	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t *) from;
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-
-	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
-
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
-				PoolVariableIF::VAR_READ_WRITE);
-		mySet.read();
-
-		result = raw.setEntryFromBigEndian(fromAsStream, sizeof(T));
-
-		fromAsStream += sizeof(T);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		mySet.commit();
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::copyFrom(const ParameterWrapper* from,
-		uint16_t startWritingAtIndex) {
-	if (poolId == PoolVariableIF::NO_PARAMETER) {
-		return ParameterWrapper::NOT_SET;
-	}
-
-	if (type != from->type) {
-		return ParameterWrapper::DATATYPE_MISSMATCH;
-	}
-
-	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
-
-	if ((from->rows > (rows - startingRow))
-			|| (from->columns > (columns - startingColumn))) {
-		return ParameterWrapper::TOO_BIG;
-	}
-
-	ReturnValue_t result;
-	//copy data
-	if (from->pointsToStream) {
-		switch (type) {
-		case Type::UINT8_T:
-			result = deSerializeData<uint8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT8_T:
-			result = deSerializeData<int8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT16_T:
-			result = deSerializeData<uint16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT16_T:
-			result = deSerializeData<int16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT32_T:
-			result = deSerializeData<uint32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT32_T:
-			result = deSerializeData<int32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::FLOAT:
-			result = deSerializeData<float>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::DOUBLE:
-			result = deSerializeData<double>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		default:
-			result = ParameterWrapper::UNKNOW_DATATYPE;
-			break;
-		}
-	} else {
-		//not supported
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	return result;
-}
diff --git a/datapoolglob/DataPoolParameterWrapper.h b/datapoolglob/DataPoolParameterWrapper.h
deleted file mode 100644
index b1e505a75..000000000
--- a/datapoolglob/DataPoolParameterWrapper.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef DATAPOOLPARAMETERWRAPPER_H_
-#define DATAPOOLPARAMETERWRAPPER_H_
-
-#include "../globalfunctions/Type.h"
-#include "../parameters/ParameterWrapper.h"
-
-class DataPoolParameterWrapper: public SerializeIF {
-public:
-	DataPoolParameterWrapper();
-	virtual ~DataPoolParameterWrapper();
-
-	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
-
-	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;
-
-	ReturnValue_t copyFrom(const ParameterWrapper *from,
-			uint16_t startWritingAtIndex);
-
-private:
-	Type type;
-	uint8_t rows;
-	uint8_t columns;
-
-	uint32_t poolId;
-
-	template<typename T>
-	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
-			const void *from, uint8_t fromRows);
-
-};
-
-#endif /* DATAPOOLPARAMETERWRAPPER_H_ */
diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
deleted file mode 100644
index afb27b772..000000000
--- a/datapoolglob/GlobalDataPool.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../ipc/MutexFactory.h"
-
-GlobalDataPool::GlobalDataPool(
-		void(*initFunction)(GlobPoolMap* pool_map)) {
-	mutex = MutexFactory::instance()->createMutex();
-	if (initFunction != NULL ) {
-		initFunction( &this->globDataPool );
-	}
-}
-
-GlobalDataPool::~GlobalDataPool() {
-	MutexFactory::instance()->deleteMutex(mutex);
-	for(GlobPoolMapIter it = this->globDataPool.begin();
-	    it != this->globDataPool.end(); ++it )
-	{
-		delete it->second;
-	}
-}
-
-// The function checks PID, type and array length before returning a copy of
-// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
-template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
-		uint8_t sizeOrPosition ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
-		if (entry != nullptr ) {
-			if ( sizeOrPosition <= entry->length ) {
-				return entry;
-			}
-		}
-	}
-	return nullptr;
-}
-
-PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		return it->second;
-	} else {
-		return nullptr;
-	}
-}
-
-ReturnValue_t GlobalDataPool::unlockDataPool() {
-	ReturnValue_t status = mutex->unlockMutex();
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: unlock of mutex failed with"
-				" error code: " << status << std::endl;
-	}
-	return status;
-}
-
-ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
-	        timeoutMs);
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: lock of mutex failed "
-				"with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-void GlobalDataPool::print() {
-	sif::debug << "DataPool contains: " << std::endl;
-	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
-	dataPoolIt = this->globDataPool.begin();
-	while( dataPoolIt != this->globDataPool.end() ) {
-		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
-		dataPoolIt->second->print();
-		dataPoolIt++;
-	}
-}
-
-uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
-	return (parameter_id >> 8) & 0x00FFFFFF;
-}
-
-uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
-	return (parameter_id & 0x000000FF);
-}
-
-uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
-	return (poolId << 8) + index;
-}
-
-
-//SHOULDDO: Do we need a mutex lock here... I don't think so,
-//as we only check static const values of elements in a list that do not change.
-//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
-ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
-	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
-	if ( it != this->globDataPool.end() ) {
-		*type = it->second->getType();
-		return RETURN_OK;
-	} else {
-		*type = Type::UNKNOWN_TYPE;
-		return RETURN_FAILED;
-	}
-}
-
-bool GlobalDataPool::exists(uint32_t parameterId) {
-	uint32_t poolId = PIDToDataPoolId(parameterId);
-	uint32_t index = PIDToArrayIndex(parameterId);
-	GlobPoolMapIter it = this->globDataPool.find( poolId );
-	if (it != globDataPool.end()) {
-		if (it->second->getSize() >= index) {
-			return true;
-		}
-	}
-	return false;
-}
-
-template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
-		uint32_t data_pool_id, uint8_t size);
-template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<float>* GlobalDataPool::getData<float>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<double>* GlobalDataPool::getData<double>(
-		uint32_t data_pool_id, uint8_t size);
diff --git a/datapoolglob/GlobalDataPool.h b/datapoolglob/GlobalDataPool.h
deleted file mode 100644
index ce5b132c0..000000000
--- a/datapoolglob/GlobalDataPool.h
+++ /dev/null
@@ -1,149 +0,0 @@
-#ifndef GLOBALDATAPOOL_H_
-#define GLOBALDATAPOOL_H_
-
-#include "../datapool/PoolEntry.h"
-#include "../globalfunctions/Type.h"
-#include "../ipc/MutexIF.h"
-#include <map>
-
-/**
- * @defgroup data_pool Global data pool
- * This is the group, where all classes associated with global
- * data pool handling belong to.
- * This includes classes to access Data Pool variables.
- */
-
-/**
- * Typedefs for the global pool representations
- */
-using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
-using GlobPoolMapIter = GlobPoolMap::iterator;
-
-/**
- * @brief		This class represents the OBSW global data-pool.
- *
- * @details
- * All variables are registered and space is allocated in an initialization
- * function, which is passed do the constructor. Space for the variables is
- * allocated on the heap (with a new call).
- *
- * The data is found by a data pool id, which uniquely represents a variable.
- * Data pool variables should be used with a blackboard logic in mind,
- * which means read data is valid (if flagged so),
- * but not necessarily up-to-date.
- *
- * Variables are either single values or arrays.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class GlobalDataPool : public HasReturnvaluesIF {
-private:
-	/**
-	 * @brief	This is the actual data pool itself.
-	 * @details	It is represented by a map with the data pool id as index
-	 * 			and a pointer to a single PoolEntry as value.
-	 */
-	GlobPoolMap globDataPool;
-
-	/**
-	 * @brief	The mutex is created in the constructor and makes
-	 * 			access mutual exclusive.
-	 * @details	Locking and unlocking the pool is only done by the DataSet class.
-	 */
-	MutexIF*	mutex;
-public:
-	/**
-	 * @brief	In the classes constructor,
-	 * 			the passed initialization function is called.
-	 * @details
-	 * To enable filling the pool, a pointer to the map is passed,
-	 * allowing direct access to the pool's content.
-	 * On runtime, adding or removing variables is forbidden.
-	 */
-	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
-
-	/**
-	 * 	@brief	The destructor iterates through the data_pool map and
-	 * 			calls all entries destructors to clean up the heap.
-	 */
-	~GlobalDataPool();
-
-	/**
-	 * @brief	This is the default call to access the pool.
-	 * @details
-	 * A pointer to the PoolEntry object is returned.
-	 * The call checks data pool id, type and array size.
-	 * Returns NULL in case of failure.
-	 * @param data_pool_id	The data pool id to search.
-	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
-	 * or the position the user wants to read.
-	 * 			If smaller than the entry size, everything's ok.
-	 */
-	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
-			uint8_t sizeOrPosition );
-
-	/**
-	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
-	 * 			(i.e. in Housekeeping Telemetry).
-	 * @details	It returns a basic interface and does NOT perform
-	 * 			a size check. The caller has to assure he does not copy too much data.
-	 * 			Returns NULL in case the entry is not found.
-	 * @param data_pool_id	The data pool id to search.
-	 */
-	PoolEntryIF* getRawData( uint32_t data_pool_id );
-	/**
-	 * @brief	This is a small helper function to facilitate locking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
-	/**
-	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to free the mutex.
-	 */
-	ReturnValue_t unlockDataPool();
-	/**
-	 * @brief	The print call is a simple debug method.
-	 * @details	It prints the current content of the data pool.
-	 *  		It iterates through the data_pool map and calls each entry's print() method.
-	 */
-	void print();
-	/**
-	 * Extracts the data pool id from a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The data pool id as used within the OBSW.
-	 */
-	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
-	/**
-	 * Extracts an array index out of a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The index of the corresponding data pool entry.
-	 */
-	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
-	/**
-	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
-	 */
-	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
-
-	/**
-	 * Method to return the type of a pool variable.
-	 * @param parameter_id A parameterID (not pool id) of a DP member.
-	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
-	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
-	 */
-	ReturnValue_t getType( uint32_t parameter_id, Type* type );
-
-	/**
-	 * Method to check if a PID exists. Does not lock, as there's no
-	 * possibility to alter the list that is checked during run-time.
-	 * @param parameterId The PID (not pool id!) of a parameter.
-	 * @return	true if exists, false else.
-	 */
-	bool exists(uint32_t parameterId);
-};
-
-//We assume someone globally instantiates a DataPool.
-namespace glob {
-extern GlobalDataPool dataPool;
-}
-
-#endif /* DATAPOOL_H_ */
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
deleted file mode 100644
index 1e99f8051..000000000
--- a/datapoolglob/GlobalDataSet.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-GlobDataSet::GlobDataSet(): PoolDataSetBase(
-        reinterpret_cast<PoolVariableIF**>(&registeredVariables),
-        DATA_SET_MAX_SIZE) {}
-
-// Don't do anything with your variables, they are dead already!
-// (Destructor is already called)
-GlobDataSet::~GlobDataSet() {}
-
-ReturnValue_t GlobDataSet::commit(bool valid, uint32_t lockTimeout) {
-	setEntriesValid(valid);
-	setSetValid(valid);
-	return commit(lockTimeout);
-}
-
-ReturnValue_t GlobDataSet::commit(uint32_t lockTimeout) {
-	return PoolDataSetBase::commit(lockTimeout);
-}
-
-bool GlobDataSet::isValid() const {
-    return this->valid;
-}
-
-ReturnValue_t GlobDataSet::unlockDataPool() {
-	return glob::dataPool.unlockDataPool();
-}
-
-ReturnValue_t GlobDataSet::lockDataPool(uint32_t timeoutMs) {
-	return glob::dataPool.lockDataPool(timeoutMs);
-}
-
-void GlobDataSet::setEntriesValid(bool valid) {
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ) {
-			registeredVariables[count]->setValid(valid);
-		}
-	}
-}
-
-void GlobDataSet::setSetValid(bool valid) {
-	this->valid = valid;
-}
-
-
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
deleted file mode 100644
index 2f0edbd5c..000000000
--- a/datapoolglob/GlobalDataSet.h
+++ /dev/null
@@ -1,98 +0,0 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_DATASET_H_
-#define FRAMEWORK_DATAPOOLGLOB_DATASET_H_
-
-#include "../datapool/PoolDataSetBase.h"
-
-/**
- * @brief	The DataSet class manages a set of locally checked out variables
- * 			for the global data pool.
- * @details
- * This class uses the read-commit() semantic provided by the DataSetBase class.
- * It extends the base class by using the global data pool,
- * having a valid state and implementing lock und unlock calls for the global
- * datapool.
- *
- * For more information on how this class works, see the DataSetBase
- * documentation.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class GlobDataSet: public PoolDataSetBase {
-public:
-
-	/**
-	 * @brief	Creates an empty GlobDataSet. Use registerVariable or
-	 * 			supply a pointer to this dataset to PoolVariable
-	 * 			initializations to register pool variables.
-	 */
-	GlobDataSet();
-
-	/**
-	 * @brief	The destructor automatically manages writing the valid
-	 * 			information of variables.
-	 * @details
-	 * In case the data set was read out, but not committed(indicated by state),
-	 * the destructor parses all variables that are still registered to the set.
-	 * For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~GlobDataSet();
-
-	/**
-	 * Variant of method above which sets validity of all elements of the set.
-	 * @param valid Validity information from PoolVariableIF.
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
-	 * 			     contains non write-only variables
-	 */
-	ReturnValue_t commit(bool valid, uint32_t lockTimeout = MutexIF::BLOCKING);
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-	/**
-	 * Set all entries
-	 * @param valid
-	 */
-	void setSetValid(bool valid);
-
-	bool isValid() const override;
-
-	/**
-	 * Set the valid information of all variables contained in the set which
-	 * are not read-only
-	 *
-	 * @param valid Validity information from PoolVariableIF.
-	 */
-	void setEntriesValid(bool valid);
-
-	//!< This definition sets the maximum number of variables to
-	//! register in one DataSet.
-	static const uint8_t DATA_SET_MAX_SIZE = 63;
-
-private:
-	/**
-	 * If the valid state of a dataset is always relevant to the whole
-	 * data set we can use this flag.
-	 */
-	bool valid = false;
-
-	/**
-	 * @brief	This is a small helper function to facilitate locking
-	 * 			the global data pool.
-	 * @details
-	 * It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
-	/**
-	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the global data pool
-	 * @details
-	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	ReturnValue_t unlockDataPool() override;
-
-	void handleAlreadyReadDatasetCommit();
-	ReturnValue_t handleUnreadDatasetCommit();
-
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-};
-
-#endif /* FRAMEWORK_DATAPOOLGLOB_DATASET_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
deleted file mode 100644
index a995bfaf2..000000000
--- a/datapoolglob/GlobalPoolVariable.h
+++ /dev/null
@@ -1,213 +0,0 @@
-#ifndef GLOBALPOOLVARIABLE_H_
-#define GLOBALPOOLVARIABLE_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-template<typename T, uint8_t n_var> class PoolVarList;
-
-
-/**
- * @brief	This is the access class for non-array data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly
- * on the data pool entries, but on local copies. This class provides simple
- * type-safe access to single data pool entries (i.e. entries with length = 1).
- * The class can be instantiated as read-write and read only.
- * It provides a commit-and-roll-back semantic, which means that the
- * variable's value in the data pool is not changed until the
- * commit call is executed.
- * 	@tparam	T The template parameter sets the type of the variable.
- * 	Currently, all plain data types are supported, but in principle
- * 	any type is possible.
- *	@ingroup data_pool
- */
-template<typename T>
-class GlobPoolVar: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PoolVarList;
-	static_assert(not std::is_same<T, bool>::value,
-			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
-			"There is no boolean type in CCSDS.");
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if nullptr is not passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but
-	 * sets the value attribute to default (0).
-	 * The value is fetched within the read() operation.
-	 * @param set_id	This is the id in the global data pool
-	 * 					this instance of the access class corresponds to.
-	 * @param dataSet	The data set in which the variable shall register
-	 * 					itself. If NULL, the variable is not registered.
-	 * @param setWritable If this flag is set to true, changes in the value
-	 * 			attribute can be written back to the data pool, otherwise not.
-	 */
-	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value = 0;
-
-	/**
-	 * @brief 	Copy ctor to copy classes containing Pool Variables.
-	 * 			(Robin): This only copies member variables, which is done
-	 * 			by the default copy ctor. maybe we can ommit this ctor?
-	 */
-	GlobPoolVar(const GlobPoolVar& rhs);
-
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVar() {}
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * The commit call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool is stored.
-	 */
-	uint32_t dataPoolId;
-
-	/**
-	 * @brief	The valid information as it was stored in the data pool is
-	 * 			copied to this attribute.
-	 */
-	uint8_t valid;
-
-	/**
-	 * @brief	The information whether the class is read-write or read-only
-	 * 			is stored here.
-	 */
-	pool_rwm_t readWriteMode;
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	GlobPoolVar();
-public:
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const override;
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const override;
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-
-	uint8_t getValid();
-
-	void setValid(bool valid) override;
-
-	operator T() {
-		return value;
-	}
-
-	operator T() const {
-		return value;
-	}
-
-	GlobPoolVar<T> &operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
-		value = newPoolVariable.value;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size,
-			SerializeIF::Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, max_size,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-		        streamEndianness);
-	}
-};
-
-#include "../datapoolglob/GlobalPoolVariable.tpp"
-
-typedef GlobPoolVar<uint8_t> gp_bool_t;
-typedef GlobPoolVar<uint8_t> gp_uint8_t;
-typedef GlobPoolVar<uint16_t> gp_uint16_t;
-typedef GlobPoolVar<uint32_t> gp_uint32_t;
-typedef GlobPoolVar<int8_t> gp_int8_t;
-typedef GlobPoolVar<int16_t> gp_int16_t;
-typedef GlobPoolVar<int32_t> gp_int32_t;
-typedef GlobPoolVar<float> gp_float_t;
-typedef GlobPoolVar<double> gp_double_t;
-
-#endif /* POOLVARIABLE_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.tpp b/datapoolglob/GlobalPoolVariable.tpp
deleted file mode 100644
index d61d605d7..000000000
--- a/datapoolglob/GlobalPoolVariable.tpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#ifndef GLOBALPOOLVARIABLE_TPP_
-#define GLOBALPOOLVARIABLE_TPP_
-
-template <class T>
-inline GlobPoolVar<T>::GlobPoolVar(uint32_t set_id,
-		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode):
-		dataPoolId(set_id), valid(PoolVariableIF::INVALID),
-		readWriteMode(setReadWriteMode)
-{
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
-
-template<typename T>
-inline ReturnValue_t GlobPoolVar<T>::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-template<typename T>
-inline ReturnValue_t GlobPoolVar<T>::commit(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-template <class T>
-inline ReturnValue_t GlobPoolVar<T>::readWithoutLock() {
-	PoolEntry<T>* read_out = glob::dataPool.getData<T>(dataPoolId, 1);
-	if (read_out != NULL) {
-		valid = read_out->valid;
-		value = *(read_out->address);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		value = 0;
-		valid = false;
-		sif::error << "PoolVariable: read of DP Variable 0x" << std::hex
-				<< dataPoolId << std::dec << " failed." << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template <class T>
-inline ReturnValue_t GlobPoolVar<T>::commitWithoutLock() {
-	PoolEntry<T>* write_back = glob::dataPool.getData<T>(dataPoolId, 1);
-	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-		write_back->valid = valid;
-		*(write_back->address) = value;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template <class T>
-inline GlobPoolVar<T>::GlobPoolVar():
-		dataPoolId(PoolVariableIF::NO_PARAMETER),
-		valid(PoolVariableIF::INVALID),
-		readWriteMode(VAR_READ), value(0) {}
-
-template <class T>
-inline GlobPoolVar<T>::GlobPoolVar(const GlobPoolVar& rhs) :
-		dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode(
-		rhs.readWriteMode), value(rhs.value) {}
-
-template <class T>
-inline pool_rwm_t GlobPoolVar<T>::getReadWriteMode() const  {
-	return readWriteMode;
-}
-
-template <class T>
-inline uint32_t GlobPoolVar<T>::getDataPoolId() const {
-	return dataPoolId;
-}
-
-template <class T>
-inline void GlobPoolVar<T>::setDataPoolId(uint32_t poolId) {
-	dataPoolId = poolId;
-}
-
-template <class T>
-inline bool GlobPoolVar<T>::isValid() const {
-	if (valid)
-		return true;
-	else
-		return false;
-}
-
-template <class T>
-inline uint8_t GlobPoolVar<T>::getValid() {
-	return valid;
-}
-
-template <class T>
-inline void GlobPoolVar<T>::setValid(bool valid) {
-	this->valid = valid;
-}
-
-#endif
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
deleted file mode 100644
index 0f5daacd8..000000000
--- a/datapoolglob/GlobalPoolVector.h
+++ /dev/null
@@ -1,185 +0,0 @@
-#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_
-#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-/**
- * @brief	This is the access class for array-type data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly on the
- * data pool entries, but on local copies. This class provides simple type-
- * and length-safe access to vector-style data pool entries (i.e. entries with
- * length > 1). The class can be instantiated as read-write and read only.
- *
- * It provides a commit-and-roll-back semantic, which means that no array
- * entry in the data pool is changed until the commit call is executed.
- * There are two template parameters:
- * @tparam	T
- * This template parameter specifies the data type of an array entry. Currently,
- * all plain data types are supported, but in principle any type is possible.
- * @tparam  vector_size
- * This template parameter specifies the vector size of this entry. Using a
- * template parameter for this is not perfect, but avoids
- * dynamic memory allocation.
- * @ingroup data_pool
- */
-template<typename T, uint16_t vectorSize>
-class GlobPoolVector: public PoolVariableIF {
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if no nullptr is passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but sets the
-	 * value attribute to default (0). The value is fetched within the
-	 * read() operation.
-	 * @param set_id
-	 * This is the id in the global data pool this instance of the access
-	 * class corresponds to.
-	 * @param dataSet
-	 * The data set in which the variable shall register itself. If nullptr,
-	 * the variable is not registered.
-	 * @param setWritable
-	 * If this flag is set to true, changes in the value attribute can be
-	 * written back to the data pool, otherwise not.
-	 */
-	GlobPoolVector(uint32_t set_id, DataSetIF* set,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * @brief This operation sets the data pool id of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid != INVALID)
-			return true;
-		else
-			return false;
-	}
-	void setValid(bool valid) {this->valid = valid;}
-	uint8_t getValid() {return valid;}
-
-	T &operator [](int i) {return value[i];}
-	const T &operator [](int i) const {return value[i];}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t max_size, Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) override;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies all array values
-	 * and the valid information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The commit call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#include "../datapoolglob/GlobalPoolVector.tpp"
-
-template<typename T, uint16_t vectorSize>
-using gp_vec_t = GlobPoolVector<T, vectorSize>;
-
-#endif /* FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_ */
diff --git a/datapoolglob/GlobalPoolVector.tpp b/datapoolglob/GlobalPoolVector.tpp
deleted file mode 100644
index 013a682a4..000000000
--- a/datapoolglob/GlobalPoolVector.tpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
-#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
-
-
-template<typename T, uint16_t vectorSize>
-inline GlobPoolVector<T, vectorSize>::GlobPoolVector(uint32_t set_id,
-		DataSetIF* set, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
-	memset(this->value, 0, vectorSize * sizeof(T));
-	if (set != nullptr) {
-		set->registerVariable(this);
-	}
-}
-
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::commit(
-		uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::readWithoutLock() {
-	PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
-			vectorSize);
-	if (read_out != nullptr) {
-		this->valid = read_out->valid;
-		memcpy(this->value, read_out->address, read_out->getByteSize());
-
-		return HasReturnvaluesIF::RETURN_OK;
-
-	} else {
-		memset(this->value, 0, vectorSize * sizeof(T));
-		sif::error << "PoolVector: Read of DP Variable 0x" << std::hex
-				<< std::setw(8) << std::setfill('0') << dataPoolId <<
-				std::dec << " failed." << std::endl;
-		this->valid = INVALID;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::commitWithoutLock() {
-	PoolEntry<T>* writeBack = glob::dataPool.getData<T>(this->dataPoolId,
-			vectorSize);
-	if ((writeBack != nullptr) && (this->readWriteMode != VAR_READ)) {
-		writeBack->valid = valid;
-		memcpy(writeBack->address, this->value, writeBack->getByteSize());
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-		size_t* size, size_t max_size,
-		SerializeIF::Endianness streamEndianness) const {
-	uint16_t i;
-	ReturnValue_t result;
-	for (i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-				max_size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-template<typename T, uint16_t vectorSize>
-inline size_t GlobPoolVector<T, vectorSize>::getSerializedSize() const {
-	return vectorSize * SerializeAdapter::getSerializedSize(value);
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::deSerialize(
-		const uint8_t** buffer, size_t* size,
-		SerializeIF::Endianness streamEndianness) {
-	uint16_t i;
-	ReturnValue_t result;
-	for (i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
-		        streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-#endif
diff --git a/datapoolglob/PIDReader.h b/datapoolglob/PIDReader.h
deleted file mode 100644
index 9431e1d40..000000000
--- a/datapoolglob/PIDReader.h
+++ /dev/null
@@ -1,164 +0,0 @@
-#ifndef PIDREADER_H_
-#define PIDREADER_H_
-#include "../datapool/DataSetIF.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-template<typename U, uint8_t n_var> class PIDReaderList;
-
-template<typename T>
-class PIDReader: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PIDReaderList;
-protected:
-	uint32_t parameterId;
-	uint8_t valid;
-	ReturnValue_t readWithoutLock() {
-		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
-				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
-		if (read_out != NULL) {
-			valid = read_out->valid;
-			value = read_out->address[arrayIndex];
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			value = 0;
-			valid = false;
-			sif::error << "PIDReader: read of PID 0x" << std::hex << parameterId
-					<< std::dec << " failed." << std::endl;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * Never commit, is read-only.
-	 * Reason is the possibility to access a single DP vector element, but if we commit,
-	 * we set validity of the whole vector.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t commitWithoutLock() override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	PIDReader() :
-			parameterId(PoolVariableIF::NO_PARAMETER), valid(
-					PoolVariableIF::INVALID), value(0) {
-
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 */
-	T value;
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
-	 */
-	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
-			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
-					0) {
-		if (dataSet != NULL) {
-			dataSet->registerVariable(this);
-		}
-	}
-
-	ReturnValue_t read(uint32_t lockTimeout) override {
-		ReturnValue_t result = glob::dataPool.lockDataPool();
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = readWithoutLock();
-		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "PIDReader::read: Could not unlock data pool!"
-					<< std::endl;
-		}
-		return result;
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-	PIDReader(const PIDReader &rhs) :
-			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
-	}
-
-	/**
-	 * \brief	The classes destructor is empty.
-	 */
-	~PIDReader() {
-
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return GlobalDataPool::PIDToDataPoolId(parameterId);
-	}
-	uint32_t getParameterId() const {
-		return parameterId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return VAR_READ;
-	}
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid)
-			return true;
-		else
-			return false;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	void setValid(bool valid) {
-		this->valid = valid;
-	}
-
-	operator T() {
-		return value;
-	}
-
-	PIDReader<T>& operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-				streamEndianness);
-	}
-};
-
-#endif /* PIDREADER_H_ */
diff --git a/datapoolglob/PIDReaderList.h b/datapoolglob/PIDReaderList.h
deleted file mode 100644
index ae99f3aa2..000000000
--- a/datapoolglob/PIDReaderList.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-
-#include "../datapool/PoolVariableIF.h"
-#include "../datapoolglob/PIDReader.h"
-template <class T, uint8_t n_var>
-class PIDReaderList {
-private:
-	PIDReader<T> variables[n_var];
-public:
-	PIDReaderList( const uint32_t setPid[n_var], DataSetIF* dataSet) {
-		//I really should have a look at the new init list c++ syntax.
-		if (dataSet == NULL) {
-			return;
-		}
-		for (uint8_t count = 0; count < n_var; count++) {
-			variables[count].parameterId = setPid[count];
-			dataSet->registerVariable(&variables[count]);
-		}
-	}
-
-	PIDReader<T> &operator [](int i) { return variables[i]; }
-};
-
-
-
-#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
deleted file mode 100644
index 53706c6d3..000000000
--- a/datapoolglob/PoolRawAccess.cpp
+++ /dev/null
@@ -1,239 +0,0 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapoolglob/PoolRawAccess.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serialize/EndianConverter.h"
-
-#include <cstring>
-
-PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
-		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
-		readWriteMode(setReadWriteMode) {
-	memset(value, 0, sizeof(value));
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
-
-PoolRawAccess::~PoolRawAccess() {}
-
-ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::readWithoutLock() {
-	ReturnValue_t result = RETURN_FAILED;
-	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
-	if (readOut != nullptr) {
-		result = handleReadOut(readOut);
-		if(result == RETURN_OK) {
-			return result;
-		}
-	} else {
-		result = READ_ENTRY_NON_EXISTENT;
-	}
-	handleReadError(result);
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
-	ReturnValue_t result = RETURN_FAILED;
-	valid = readOut->getValid();
-	if (readOut->getSize() > arrayEntry) {
-		arraySize = readOut->getSize();
-		typeSize = readOut->getByteSize() / readOut->getSize();
-		type = readOut->getType();
-		if (typeSize <= sizeof(value)) {
-			uint16_t arrayPosition = arrayEntry * typeSize;
-			sizeTillEnd = readOut->getByteSize() - arrayPosition;
-			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
-			memcpy(value, ptr, typeSize);
-			return RETURN_OK;
-		} else {
-			result = READ_TYPE_TOO_LARGE;
-		}
-	} else {
-		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
-		result = READ_INDEX_TOO_LARGE;
-	}
-	return result;
-}
-
-void PoolRawAccess::handleReadError(ReturnValue_t result) {
-	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed, ";
-	if(result == READ_TYPE_TOO_LARGE) {
-		sif::error << "type too large." << std::endl;
-	}
-	else if(result == READ_INDEX_TOO_LARGE) {
-		sif::error << "index too large." << std::endl;
-	}
-	else if(result == READ_ENTRY_NON_EXISTENT) {
-		sif::error << "entry does not exist." << std::endl;
-	}
-
-	valid = INVALID;
-	typeSize = 0;
-	sizeTillEnd = 0;
-	memset(value, 0, sizeof(value));
-}
-
-ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::commitWithoutLock() {
-	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
-	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-		write_back->setValid(valid);
-		uint8_t array_position = arrayEntry * typeSize;
-		uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position];
-		memcpy(ptr, value, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t* PoolRawAccess::getEntry() {
-	return value;
-}
-
-ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		size_t* writtenBytes, size_t max_size) {
-	uint8_t* data_ptr = getEntry();
-	// debug << "PoolRawAccess::getEntry: Array position: " <<
-	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
-	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
-	if (typeSize == 0)
-		return DATA_POOL_ACCESS_FAILED;
-	if (typeSize > max_size)
-		return INCORRECT_SIZE;
-	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
-	*writtenBytes = typeSize;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-        size_t maxSize, Endianness streamEndianness) const {
-    if (typeSize + *size <= maxSize) {
-    	switch(streamEndianness) {
-    	case(Endianness::BIG):
-    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::MACHINE):
-    	default:
-            memcpy(*buffer, value, typeSize);
-            break;
-        }
-        *size += typeSize;
-        (*buffer) += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    } else {
-        return SerializeIF::BUFFER_TOO_SHORT;
-    }
-}
-
-
-Type PoolRawAccess::getType() {
-	return type;
-}
-
-size_t PoolRawAccess::getSizeOfType() {
-	return typeSize;
-}
-
-size_t PoolRawAccess::getArraySize(){
-	return arraySize;
-}
-
-uint32_t PoolRawAccess::getDataPoolId() const {
-	return dataPoolId;
-}
-
-PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
-	return readWriteMode;
-}
-
-ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
-		size_t setSize) {
-	if (typeSize == setSize) {
-		EndianConverter::convertBigEndian(value, buffer, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
-				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
-				<< std::endl;
-		return INCORRECT_SIZE;
-	}
-}
-
-bool PoolRawAccess::isValid() const {
-	if (valid != INVALID)
-		return true;
-	else
-		return false;
-}
-
-void PoolRawAccess::setValid(bool valid) {
-	this->valid = valid;
-}
-
-size_t PoolRawAccess::getSizeTillEnd() const {
-	return sizeTillEnd;
-}
-
-
-size_t PoolRawAccess::getSerializedSize() const {
-	return typeSize;
-}
-
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
-        Endianness streamEndianness) {
-
-    if (*size >= typeSize) {
-        switch(streamEndianness) {
-        case(Endianness::BIG):
-			EndianConverter::convertBigEndian(value, *buffer, typeSize);
-		    break;
-        case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
-		   	break;
-        case(Endianness::MACHINE):
-        default:
-            memcpy(value, *buffer, typeSize);
-            break;
-        }
-    	*size -= typeSize;
-        *buffer += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-    	return SerializeIF::STREAM_TOO_SHORT;
-    }
-}
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
deleted file mode 100644
index 15643a41c..000000000
--- a/datapoolglob/PoolRawAccess.h
+++ /dev/null
@@ -1,220 +0,0 @@
-#ifndef POOLRAWACCESS_H_
-#define POOLRAWACCESS_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntryIF.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../globalfunctions/Type.h"
-
-/**
- * @brief This class allows accessing Data Pool variables as raw bytes.
- * @details
- * This is necessary to have an access method for HK data, as the PID's alone
- * do not provide type information. Please note that the the raw pool access
- * read() and commit() calls are not thread-safe.
- *
- * Please supply a data set and use the data set read(), commit() calls for
- * thread-safe data pool access.
- * @ingroup data_pool
- */
-class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
-public:
-	/**
-	 * This constructor is used to access a data pool entry with a
-	 * given ID if the target type is not known. A DataSet object is supplied
-	 * and the data pool entry with the given ID is registered to that data set.
-	 * Please note that a pool raw access buffer only has a buffer
-	 * with a size of double. As such, for vector entries which have
-	 * @param data_pool_id Target data pool entry ID
-	 * @param arrayEntry
-	 * @param data_set Dataset to register data pool entry to
-	 * @param setReadWriteMode
-	 * @param registerVectors If set to true, the constructor checks if
-	 *                        there are multiple vector entries to registers
-	 *                        and registers all of them recursively into the data_set
-	 *
-	 */
-	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
-			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-					PoolVariableIF::VAR_READ);
-
-	/**
-	 * @brief	This operation returns a pointer to the entry fetched.
-	 * @details	Return pointer to the buffer containing the raw data
-	 *          Size and number of data can be retrieved by other means.
-	 */
-	uint8_t* getEntry();
-	/**
-	 * @brief 	This operation returns the fetched entry from the data pool and
-	 * 			flips the bytes, if necessary.
-	 * @details	It makes use of the getEntry call of this function, but additionally flips the
-	 * 			bytes to big endian, which is the default for external communication (as House-
-	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given max_size.
-	 * @param buffer	A pointer to a buffer to write to
-	 * @param writtenBytes	The number of bytes written is returned with this value.
-	 * @param max_size	The maximum size that the function may write to buffer.
-	 * @return	- @c RETURN_OK if entry could be acquired
-	 * 			- @c RETURN_FAILED else.
-	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
-			size_t maxSize);
-
-	/**
-	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @param buffer Provided buffer. Raw pool data will be copied here
-	 * @param size [out] Increment provided size value by serialized size
-	 * @param max_size Maximum allowed serialization size
-	 * @param bigEndian Specify endianess
-	 * @return - @c RETURN_OK if serialization was successfull
-	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
-	 */
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-	        size_t maxSize, Endianness streamEndianness) const override;
-
-    size_t getSerializedSize() const override;
-
-    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-            Endianness streamEndianness) override;
-
-	/**
-	 * With this method, the content can be set from a big endian buffer safely.
-	 * @param buffer	Pointer to the data to set
-	 * @param size		Size of the data to write. Must fit this->size.
-	 * @return	- @c RETURN_OK on success
-	 * 			- @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			size_t setSize);
-	/**
-	 *  @brief This operation returns the type of the entry currently stored.
-	 */
-	Type getType();
-	/**
-	 *  @brief This operation returns the size of the entry currently stored.
-	 */
-	size_t getSizeOfType();
-	/**
-	 *
-	 * @return the size of the datapool array
-	 */
-	size_t getArraySize();
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
-	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
-	uint8_t value[RAW_MAX_SIZE];
-
-
-	/**
-	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolRawAccess();
-
-	/**
-	 * This method returns if the variable is read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const;
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const;
-
-	void setValid(bool valid);
-	/**
-	 * Getter for the remaining size.
-	 */
-	size_t getSizeTillEnd() const;
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The call is protected by a lock of the global data pool.
-	 * @return -@c RETURN_OK Read successfull
-	 * 		   -@c READ_TYPE_TOO_LARGE
-	 * 		   -@c READ_INDEX_TOO_LARGE
-	 * 		   -@c READ_ENTRY_NON_EXISTENT
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The call is protected by a lock of the global data pool.
-	 *
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
-	void handleReadError(ReturnValue_t result);
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The array entry that is fetched from the data pool.
-	 */
-	uint8_t arrayEntry;
-	/**
-	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	This value contains the type of the data pool entry.
-	 */
-	Type type;
-	/**
-	 * @brief	This value contains the size of the data pool entry type in bytes.
-	 */
-	size_t typeSize;
-	/**
-	 * The size of the DP array (single values return 1)
-	 */
-	size_t arraySize;
-	/**
-	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
-	 */
-	size_t sizeTillEnd;
-	/**
-	 * @brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#endif /* POOLRAWACCESS_H_ */

From f9d54032041237396b03c4c94e9b3f591769d824 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 11 Dec 2020 23:50:00 +0100
Subject: [PATCH 1137/1774] added device handler thermalset

---
 devicehandlers/DeviceHandlerThermalSet.h | 44 ++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 devicehandlers/DeviceHandlerThermalSet.h

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

From 101babd863788df611316d68a342e1548d4584e7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 11 Dec 2020 23:53:29 +0100
Subject: [PATCH 1138/1774] indentation consistent now

---
 devicehandlers/DeviceHandlerIF.h | 282 ++++++++++++++++---------------
 1 file changed, 146 insertions(+), 136 deletions(-)

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

From d0d6247753120c8354ecbde51266b7fb63d3c47e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 12 Dec 2020 00:01:36 +0100
Subject: [PATCH 1139/1774] and now it compiles

---
 controller/ExtendedControllerBase.cpp |  1 -
 fdir/FaultCounter.cpp                 |  2 +-
 fsfw.mk                               |  1 -
 thermal/ThermalComponentCore.cpp      | 13 +++++++------
 thermal/ThermalModule.cpp             |  6 +++---
 thermal/ThermalModuleIF.h             |  3 +--
 thermal/tcsDefinitions.h              |  6 +++---
 7 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index f69d2ea1a..fa4f67867 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -97,7 +97,6 @@ ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
 
 ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
     handleQueue();
-    hkSwitcher.performOperation();
     localPoolManager.performHkOperation();
     performControlOperation();
     return RETURN_OK;
diff --git a/fdir/FaultCounter.cpp b/fdir/FaultCounter.cpp
index 443adb52e..6519a3a88 100644
--- a/fdir/FaultCounter.cpp
+++ b/fdir/FaultCounter.cpp
@@ -76,7 +76,7 @@ ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
 		parameterWrapper->set(timer.timeout);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/fsfw.mk b/fsfw.mk
index c58475540..3df63060e 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -9,7 +9,6 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/controller/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoolglob/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index 7b594d0c9..ba8750532 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -1,4 +1,5 @@
 #include "ThermalComponentCore.h"
+#include "tcsDefinitions.h"
 
 ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
         uint8_t domainId, gp_id_t temperaturePoolId,
@@ -60,7 +61,7 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
 	temperature = getTemperature();
 	updateMinMaxTemp();
-	if (temperature != INVALID_TEMPERATURE) {
+	if (temperature != thermal::INVALID_TEMPERATURE) {
 		temperature.setValid(PoolVariableIF::VALID);
 		State state = getState(temperature.value, getParameters(),
 				targetState.value);
@@ -119,7 +120,7 @@ ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
 }
 
 void ThermalComponentCore::setOutputInvalid() {
-	temperature = INVALID_TEMPERATURE;
+	temperature = thermal::INVALID_TEMPERATURE;
 	temperature.setValid(PoolVariableIF::INVALID);
 	currentState.setValid(PoolVariableIF::INVALID);
 	heaterRequest = HEATER_DONT_CARE;
@@ -144,13 +145,13 @@ float ThermalComponentCore::getTemperature() {
 
 	if (thermalModule != nullptr) {
 		float temperature = thermalModule->getTemperature();
-		if (temperature != ThermalModuleIF::INVALID_TEMPERATURE) {
+		if (temperature != thermal::INVALID_TEMPERATURE) {
 			return temperature;
 		} else {
-			return INVALID_TEMPERATURE;
+			return thermal::INVALID_TEMPERATURE;
 		}
 	} else {
-		return INVALID_TEMPERATURE;
+		return thermal::INVALID_TEMPERATURE;
 	}
 }
 
@@ -226,7 +227,7 @@ ThermalComponentIF::State ThermalComponentCore::getIgnoredState(int8_t state) {
 }
 
 void ThermalComponentCore::updateMinMaxTemp() {
-	if (temperature == INVALID_TEMPERATURE) {
+	if (temperature == thermal::INVALID_TEMPERATURE) {
 		return;
 	}
 	if (temperature < minTemp) {
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index 457a6743d..de3475429 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -107,7 +107,7 @@ void ThermalModule::calculateTemperature() {
 		moduleTemperature = moduleTemperature.value / numberOfValidSensors;
 		moduleTemperature.setValid(PoolVariableIF::VALID);
 	} else {
-		moduleTemperature = INVALID_TEMPERATURE;
+		moduleTemperature.value = thermal::INVALID_TEMPERATURE;
 		moduleTemperature.setValid(PoolVariableIF::INVALID);
 	}
 }
@@ -219,7 +219,7 @@ void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
 bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 		Strategy strategy) {
 	currentState.setValid(PoolVariableIF::VALID);
-	if (moduleTemperature == INVALID_TEMPERATURE) {
+	if (moduleTemperature == thermal::INVALID_TEMPERATURE) {
 		currentState = UNKNOWN;
 		return false;
 	}
@@ -282,7 +282,7 @@ void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
 }
 
 void ThermalModule::setOutputInvalid() {
-	moduleTemperature = INVALID_TEMPERATURE;
+	moduleTemperature = thermal::INVALID_TEMPERATURE;
 	moduleTemperature.setValid(PoolVariableIF::INVALID);
 	currentState.setValid(PoolVariableIF::INVALID);
 	std::list<ComponentData>::iterator iter = components.begin();
diff --git a/thermal/ThermalModuleIF.h b/thermal/ThermalModuleIF.h
index 2d11a6f25..89cf93d69 100644
--- a/thermal/ThermalModuleIF.h
+++ b/thermal/ThermalModuleIF.h
@@ -2,6 +2,7 @@
 #define THERMALMODULEIF_H_
 
 #include "ThermalComponentIF.h"
+
 class AbstractTemperatureSensor;
 
 class ThermalModuleIF{
@@ -18,8 +19,6 @@ public:
 		NON_OPERATIONAL = 0, OPERATIONAL = 1, UNKNOWN = 2
 	};
 
-	static constexpr float INVALID_TEMPERATURE = 999;
-
 	virtual ~ThermalModuleIF() {
 
 	}
diff --git a/thermal/tcsDefinitions.h b/thermal/tcsDefinitions.h
index 37e5b849d..3225be5c3 100644
--- a/thermal/tcsDefinitions.h
+++ b/thermal/tcsDefinitions.h
@@ -1,8 +1,8 @@
 #ifndef TCSDEFINITIONS_H_
 #define TCSDEFINITIONS_H_
 
-
-static const float INVALID_TEMPERATURE = 999;
-
+namespace thermal {
+static constexpr float INVALID_TEMPERATURE = 999;
+}
 
 #endif /* TCSDEFINITIONS_H_ */

From 5927d944de61672a16afc366d0ebec10f46e19c2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 12 Dec 2020 18:32:24 +0100
Subject: [PATCH 1140/1774] cmake fixes

---
 CMakeLists.txt                | 2 ++
 datapool/CMakeLists.txt       | 7 +------
 datapoollocal/CMakeLists.txt  | 8 ++++++++
 events/CMakeLists.txt         | 1 -
 housekeeping/CMakeLists.txt   | 5 +++++
 storagemanager/CMakeLists.txt | 2 ++
 thermal/CMakeLists.txt        | 4 ++--
 7 files changed, 20 insertions(+), 9 deletions(-)
 create mode 100644 datapoollocal/CMakeLists.txt
 create mode 100644 housekeeping/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 669283c74..09760f8ea 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -38,6 +38,8 @@ add_subdirectory(controller)
 add_subdirectory(coordinates)
 add_subdirectory(datalinklayer)
 add_subdirectory(datapool)
+add_subdirectory(datapoollocal)
+add_subdirectory(housekeeping)
 add_subdirectory(devicehandlers)
 add_subdirectory(events)
 add_subdirectory(fdir)
diff --git a/datapool/CMakeLists.txt b/datapool/CMakeLists.txt
index e741f6a13..0d53e1ba1 100644
--- a/datapool/CMakeLists.txt
+++ b/datapool/CMakeLists.txt
@@ -1,11 +1,6 @@
 target_sources(${LIB_FSFW_NAME} 
 	PRIVATE 
-		ControllerSet.cpp
-		DataPool.cpp
-		DataPoolAdmin.cpp
-		DataPoolParameterWrapper.cpp
-		DataSet.cpp
 		HkSwitchHelper.cpp
+		PoolDataSetBase.cpp
 		PoolEntry.cpp
-		PoolRawAccess.cpp
 )
\ No newline at end of file
diff --git a/datapoollocal/CMakeLists.txt b/datapoollocal/CMakeLists.txt
new file mode 100644
index 000000000..c6b187cd2
--- /dev/null
+++ b/datapoollocal/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		LocalDataPoolManager.cpp
+		LocalDataSet.cpp
+		LocalPoolDataSetBase.cpp
+		LocalPoolObjectBase.cpp
+		SharedLocalDataSet.cpp
+)
\ No newline at end of file
diff --git a/events/CMakeLists.txt b/events/CMakeLists.txt
index 9e63deb89..4e935167a 100644
--- a/events/CMakeLists.txt
+++ b/events/CMakeLists.txt
@@ -1,6 +1,5 @@
 target_sources(${LIB_FSFW_NAME} 
 	PRIVATE 
-		Event.cpp
 		EventManager.cpp
 		EventMessage.cpp
 )
diff --git a/housekeeping/CMakeLists.txt b/housekeeping/CMakeLists.txt
new file mode 100644
index 000000000..fecad2e3d
--- /dev/null
+++ b/housekeeping/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		HousekeepingMessage.cpp
+		PeriodicHousekeepingHelper.cpp
+)
\ No newline at end of file
diff --git a/storagemanager/CMakeLists.txt b/storagemanager/CMakeLists.txt
index 57c921952..b8138cae7 100644
--- a/storagemanager/CMakeLists.txt
+++ b/storagemanager/CMakeLists.txt
@@ -2,4 +2,6 @@ target_sources(${LIB_FSFW_NAME}
 	PRIVATE 
 		ConstStorageAccessor.cpp
 		StorageAccessor.cpp
+		LocalPool.cpp
+		PoolManager.cpp
 )
\ No newline at end of file
diff --git a/thermal/CMakeLists.txt b/thermal/CMakeLists.txt
index 67664fbe5..ad5327214 100644
--- a/thermal/CMakeLists.txt
+++ b/thermal/CMakeLists.txt
@@ -1,10 +1,10 @@
 target_sources(${LIB_FSFW_NAME} 
 	PRIVATE 
 		AbstractTemperatureSensor.cpp
-		CoreComponent.cpp
 		Heater.cpp
 		RedundantHeater.cpp
+		ThermalComponentCore.cpp
 		ThermalComponent.cpp
 		ThermalModule.cpp
-		ThermalMonitor.cpp
+		ThermalMonitorReporter.cpp
 )

From bc6936ddddd59030b659f662127b642740474201 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 12 Dec 2020 18:35:58 +0100
Subject: [PATCH 1141/1774] indentation corrected (again)

---
 devicehandlers/DeviceHandlerIF.h | 264 +++++++++++++++----------------
 1 file changed, 132 insertions(+), 132 deletions(-)

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

From b7dbdb072d46d72e8b8730c9edad97c710f4d3ad Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 21:50:33 +0100
Subject: [PATCH 1142/1774] taken over upstream changes

---
 CHANGELOG                             | 49 +++++++++++++++
 CMakeLists.txt                        | 85 +++++++++++++++++++++++++++
 FSFWVersion.h                         |  3 +-
 controller/CMakeLists.txt             |  4 ++
 controller/ControllerBase.cpp         |  7 +--
 controller/ControllerBase.h           |  3 -
 controller/ExtendedControllerBase.cpp |  1 -
 7 files changed, 141 insertions(+), 11 deletions(-)
 create mode 100644 CMakeLists.txt
 create mode 100644 controller/CMakeLists.txt

diff --git a/CHANGELOG b/CHANGELOG
index a6686478c..7b07db082 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,5 +1,8 @@
 ## Changes from ASTP 0.0.1 to 1.0.0
 
+### Host OSAL
+
+- Bugfix in MessageQueue, which caused the sender not to be set properly
 
 ### FreeRTOS OSAL
 
@@ -11,3 +14,49 @@ a C file without issues
 - It is now possible to change the message queue depth for the telecommand verification service (PUS1)
 - The same is possible for the event reporting service (PUS5)
 - PUS Health Service added, which allows to command and retrieve health via PUS packets
+
+
+### EnhancedControllerBase
+
+- New base class for a controller which also implements HasActionsIF and HasLocalDataPoolIF
+
+### Local Pool
+
+- Interface of LocalPools has changed. LocalPool is not a template anymore. Instead the size and bucket number of the pools per page and the number of pages are passed to the ctor instead of two ctor arguments and a template parameter
+
+### Parameter Service
+
+- The API of the parameter service has been changed to prevent inconsistencies
+between documentation and actual code and to clarify usage.
+- The parameter ID now consists of:
+	1. Domain ID (1 byte)
+	2. Unique Identifier (1 byte)
+	3. Linear Index (2 bytes)
+The linear index can be used for arrays as well as matrices.
+The parameter load command now explicitely expects the ECSS PTC and PFC
+information as well as  the rows and column number. Rows and column will
+default to one, which is equivalent to one scalar parameter (the most
+important use-case)
+   
+### File System Interface
+
+- A new interfaces specifies the functions for a software object which exposes the file system of a given hardware to use message based file handling (e.g. PUS commanding)
+
+### Internal Error Reporter
+
+- The new internal error reporter uses the local data pools. The pool IDs for
+the exisiting three error values and the new error set will be hardcoded for
+now, the the constructor for the internal error reporter just takes an object
+ID for now.
+
+### Device Handler Base
+
+- There is an additional `PERFORM_OPERATION` step for the device handler base. It is important
+that DHB users adapt their polling sequence tables to perform this step. This steps allows for aclear distinction between operation and communication steps
+
+### Events
+
+- makeEvent function: Now takes three input parameters instead of two and
+allows setting a unique ID. Event.cpp source file removed, functions now
+defined in header directly. Namespaces renamed. Functions declared `constexpr`
+now
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 000000000..669283c74
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,85 @@
+cmake_minimum_required(VERSION 3.13)
+
+set(LIB_FSFW_NAME fsfw)
+add_library(${LIB_FSFW_NAME})
+
+# Set options for FSFW OSAL selection.
+if(UNIX)
+set(OS_FSFW  "linux" CACHE STRING "OS abstraction layer used in the FSFW")
+elseif(WIN32)
+set(OS_FSFW  "host" CACHE STRING "OS abstraction layer used in the FSFW")
+endif()
+
+set_property(CACHE OS_FSFW PROPERTY STRINGS host linux rtems freertos)
+
+if(${OS_FSFW} STREQUAL host)
+set(OS_FSFW_NAME "Host")
+elseif(${OS_FSFW} STREQUAL linux)
+set(OS_FSFW_NAME "Linux")
+elseif(${OS_FSFW} STREQUAL  freertos)
+set(OS_FSFW_NAME "FreeRTOS")
+elseif(${OS_FSFW} STREQUAL rtems)
+set(OS_FSFW_NAME "RTEMS")
+else()
+message(WARNING "Invalid operating system for FSFW specified! Setting to host..")
+set(OS_FSFW_NAME "Host")
+set(OS_FSFW "host")
+endif()
+
+message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system")
+
+# Options to exclude parts of the FSFW from compilation.
+option(FSFW_USE_RMAP "Compile with RMAP" ON)
+option(FSFW_USE_DATALINKLAYER "Compile with Data Link Layer" ON)
+
+add_subdirectory(action)
+add_subdirectory(container)
+add_subdirectory(controller)
+add_subdirectory(coordinates)
+add_subdirectory(datalinklayer)
+add_subdirectory(datapool)
+add_subdirectory(devicehandlers)
+add_subdirectory(events)
+add_subdirectory(fdir)
+add_subdirectory(globalfunctions)
+add_subdirectory(health)
+add_subdirectory(internalError)
+add_subdirectory(ipc)
+add_subdirectory(memory)
+add_subdirectory(modes)
+add_subdirectory(monitoring)
+add_subdirectory(objectmanager)
+add_subdirectory(osal)
+add_subdirectory(parameters)
+add_subdirectory(power)
+add_subdirectory(pus)
+
+if(FSFW_USE_RMAP)
+add_subdirectory(rmap)
+endif()
+
+add_subdirectory(serialize)
+add_subdirectory(serviceinterface)
+add_subdirectory(storagemanager)
+add_subdirectory(subsystem)
+add_subdirectory(tasks)
+add_subdirectory(tcdistribution)
+add_subdirectory(thermal)
+add_subdirectory(timemanager)
+add_subdirectory(tmstorage)
+add_subdirectory(tmtcpacket)
+add_subdirectory(tmtcservices)
+
+# The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
+# If this is not given, we include the default configuration and emit a warning.
+if(NOT FSFW_CONFIG_PATH)
+message(WARNING "Flight Software Framework configuration path not set!")
+message(WARNING "Setting default configuration!")
+add_subdirectory(defaultcfg/fsfwconfig)
+endif()
+
+# Required include paths to compile the FSFW
+target_include_directories(${LIB_FSFW_NAME} 
+	INTERFACE 
+		${FSFW_CONFIG_PATH}
+)
diff --git a/FSFWVersion.h b/FSFWVersion.h
index dcb592dc9..11a608919 100644
--- a/FSFWVersion.h
+++ b/FSFWVersion.h
@@ -1,10 +1,11 @@
 #ifndef FSFW_DEFAULTCFG_VERSION_H_
 #define FSFW_DEFAULTCFG_VERSION_H_
 
-const char* const FSFW_VERSION_NAME = "fsfw";
+const char* const FSFW_VERSION_NAME = "ASTP";
 
 #define FSFW_VERSION 		0
 #define	FSFW_SUBVERSION 	0
+#define	FSFW_REVISION 	1
 
 
 
diff --git a/controller/CMakeLists.txt b/controller/CMakeLists.txt
new file mode 100644
index 000000000..6f6607388
--- /dev/null
+++ b/controller/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ControllerBase.cpp
+)
\ No newline at end of file
diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 45e678eb4..2a4024680 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -8,7 +8,7 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
 		size_t commandQueueDepth) :
 		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
 		submode(SUBMODE_NONE), modeHelper(this),
-		healthHelper(this, setObjectId), hkSwitcher(this) {
+		healthHelper(this, setObjectId) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(
 	        commandQueueDepth);
 }
@@ -44,10 +44,6 @@ ReturnValue_t ControllerBase::initialize() {
 		return result;
 	}
 
-	result = hkSwitcher.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
 	return RETURN_OK;
 }
 
@@ -107,7 +103,6 @@ void ControllerBase::announceMode(bool recursive) {
 
 ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
 	handleQueue();
-	hkSwitcher.performOperation();
 	performControlOperation();
 	return RETURN_OK;
 }
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 25d3ab1f3..6e83fe80b 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -72,9 +72,6 @@ protected:
 
 	HealthHelper healthHelper;
 
-	// Is this still needed?
-	HkSwitchHelper hkSwitcher;
-
 	/**
 	 * Pointer to the task which executes this component,
 	 * is invalid before setTaskIF was called.
diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index f69d2ea1a..fa4f67867 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -97,7 +97,6 @@ ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
 
 ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
     handleQueue();
-    hkSwitcher.performOperation();
     localPoolManager.performHkOperation();
     performControlOperation();
     return RETURN_OK;

From 0e42ba062dd9b217e1f89eb62f30295d4e31beb4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 21:51:46 +0100
Subject: [PATCH 1143/1774] notice taken over

---
 NOTICE | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/NOTICE b/NOTICE
index e16632827..be1a37c47 100644
--- a/NOTICE
+++ b/NOTICE
@@ -4,6 +4,8 @@ The initial version of the Flight Software Framework was developed during
 the Flying Laptop Project by the Universität Stuttgart in coorporation
 with Airbus Defence and Space GmbH.
 
+The supreme FSFW Logo was designed by Markus Koller and Luise Trilsbach.
+
 Copyrights in the Flight Software Framework are retained by their contributors.
 No copyright assignment is required to contribute to the Flight Software Framework.
 

From f69113b4d516b12a2a9fc7624f17ab311e6f91fb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 21:53:37 +0100
Subject: [PATCH 1144/1774] taken over upstream change in ipc

---
 ipc/MutexFactory.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ipc/MutexFactory.h b/ipc/MutexFactory.h
index f34d3b04c..f8133d814 100644
--- a/ipc/MutexFactory.h
+++ b/ipc/MutexFactory.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
 #define FRAMEWORK_IPC_MUTEXFACTORY_H_
 
-#include "../ipc/MutexIF.h"
+#include "MutexIF.h"
 /**
  * Creates Mutex.
  * This class is a "singleton" interface, i.e. it provides an

From d944e25d4a3b037f82981fad278de5fb9e367086 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 21:54:46 +0100
Subject: [PATCH 1145/1774] taken over upstream changes

---
 ipc/MessageQueueSenderIF.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 42d4078fe..683c29085 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_IPC_MESSAGEQUEUESENDERIF_H_
 #define FSFW_IPC_MESSAGEQUEUESENDERIF_H_
 
-#include "../ipc/MessageQueueIF.h"
-#include "../ipc/MessageQueueMessageIF.h"
+#include "MessageQueueIF.h"
+#include "MessageQueueMessageIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
 class MessageQueueSenderIF {

From 0b056720bae878adf65bcb1fa6cf01f98ccdd6a4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 21:57:06 +0100
Subject: [PATCH 1146/1774] taken over master

---
 ipc/CommandMessage.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 8f5daa044..28822dd00 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -2,6 +2,7 @@
 #define FSFW_IPC_COMMANDMESSAGE_H_
 
 #include "CommandMessageIF.h"
+
 #include "MessageQueueMessage.h"
 #include "FwMessageTypes.h"
 

From 7c390c07eed79ee02fa23266ece8d0218672923e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 21:58:54 +0100
Subject: [PATCH 1147/1774] taken over unnittest folder from upstream

---
 unittest/core/CatchSetup.cpp                  |  11 +-
 unittest/internal/InternalUnitTester.h        |   2 +-
 unittest/internal/UnittDefinitions.cpp        |   2 +-
 unittest/internal/osal/IntTestMq.cpp          |   9 +-
 unittest/internal/osal/IntTestMutex.cpp       |   8 +-
 unittest/internal/osal/IntTestSemaphore.cpp   |   9 +-
 .../serialize/IntTestSerialization.cpp        |   9 +-
 .../internal/serialize/IntTestSerialization.h |   9 +-
 unittest/testcfg/CatchFactory.cpp             |  60 ++++
 unittest/testcfg/CatchFactory.h               |  16 ++
 unittest/testcfg/FSFWConfig.h                 |   2 +-
 unittest/testcfg/cdatapool/dataPoolInit.h     |   2 +-
 unittest/testcfg/testcfg.mk                   |   1 +
 unittest/tests/action/TestActionHelper.cpp    | 213 +++++++-------
 unittest/tests/action/TestActionHelper.h      | 263 +++++++++---------
 unittest/tests/container/RingBufferTest.cpp   |   4 +-
 unittest/tests/container/TestArrayList.cpp    |   5 +-
 unittest/tests/container/TestDynamicFifo.cpp  |   6 +-
 unittest/tests/container/TestFifo.cpp         |   6 +-
 .../tests/container/TestFixedArrayList.cpp    |   4 +-
 unittest/tests/container/TestFixedMap.cpp     |   4 +-
 .../container/TestFixedOrderedMultimap.cpp    |   4 +-
 unittest/tests/osal/TestMessageQueue.cpp      |   8 +-
 .../serialize/TestSerialBufferAdapter.cpp     |   2 +-
 .../serialize/TestSerialLinkedPacket.cpp      |   7 +-
 .../tests/serialize/TestSerialization.cpp     |   2 +-
 26 files changed, 376 insertions(+), 292 deletions(-)
 create mode 100644 unittest/testcfg/CatchFactory.cpp
 create mode 100644 unittest/testcfg/CatchFactory.h

diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index 5749ecd11..cb5bd33ed 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,8 +1,7 @@
 #include "CatchDefinitions.h"
+#include "CatchFactory.h"
 
 #include <testcfg/cdatapool/dataPoolInit.h>
-#include <testcfg/objects/Factory.h>
-
 
 #ifdef GCOV
 #include <gcov.h>
@@ -11,15 +10,15 @@
 #include "../../objectmanager/ObjectManager.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../datapoolglob/GlobalDataPool.h"
+#include "../../datapool/DataPool.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 
 /* Global instantiations normally done in main.cpp */
 /* Initialize Data Pool */
-namespace glob {
-GlobalDataPool dataPool(datapool::dataPoolInit);
-}
+//namespace glob {
+DataPool dataPool(datapool::dataPoolInit);
+//}
 
 
 namespace sif {
diff --git a/unittest/internal/InternalUnitTester.h b/unittest/internal/InternalUnitTester.h
index b301b9232..d0b1c106d 100644
--- a/unittest/internal/InternalUnitTester.h
+++ b/unittest/internal/InternalUnitTester.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_TEST_UNITTESTCLASS_H_
 
 #include "UnittDefinitions.h"
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 /**
  * @brief	Can be used for internal testing, for example for hardware specific
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index 0bdbfcc72..6265e9fdb 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/unittest/internal/UnittDefinitions.h>
+#include "UnittDefinitions.h"
 
  ReturnValue_t unitt::put_error(std::string errorId) {
 	sif::error << "Unit Tester error: Failed at test ID "
diff --git a/unittest/internal/osal/IntTestMq.cpp b/unittest/internal/osal/IntTestMq.cpp
index 630163743..8d95f51ed 100644
--- a/unittest/internal/osal/IntTestMq.cpp
+++ b/unittest/internal/osal/IntTestMq.cpp
@@ -1,7 +1,8 @@
-#include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/ipc/QueueFactory.h>
-#include <fsfw/unittest/internal/osal/IntTestMq.h>
-#include <fsfw/unittest/internal/UnittDefinitions.h>
+#include "IntTestMq.h"
+#include "../UnittDefinitions.h"
+
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/QueueFactory.h"
 
 #include <array>
 
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index 3fd668dfd..015813470 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -1,10 +1,10 @@
 #include "IntTestMutex.h"
 
-#include <fsfw/ipc/MutexFactory.h>
-#include <unittest/internal/UnittDefinitions.h>
+#include "../../ipc/MutexFactory.h"
+#include "../UnittDefinitions.h"
 
 #if defined(hosted)
-#include <fsfw/osal/hosted/Mutex.h>
+#include "../../osal/hosted/Mutex.h"
 #include <thread>
 #include <future>
 #endif
@@ -20,7 +20,7 @@ void testmutex::testMutex() {
 	// timed_mutex from the C++ library specifies undefined behaviour if
 	// the timed mutex is locked twice from the same thread.
 #if defined(hosted)
-	// hold on, this actually worked ? :-D This calls the function from
+	// This calls the function from
 	// another thread and stores the returnvalue in a future.
 	auto future = std::async(&MutexIF::lockMutex, mutex, 1);
 	result = future.get();
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index 534a6a6d5..f260b6a51 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -1,8 +1,9 @@
 #include "IntTestSemaphore.h"
-#include <fsfw/tasks/SemaphoreFactory.h>
-#include <unittest/internal/UnittDefinitions.h>
-#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
-#include <fsfw/timemanager/Stopwatch.h>
+#include "../UnittDefinitions.h"
+
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Stopwatch.h"
 
 
 void testsemaph::testBinSemaph() {
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
index 3f231a417..1e33ff335 100644
--- a/unittest/internal/serialize/IntTestSerialization.cpp
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -1,8 +1,9 @@
 #include "IntTestSerialization.h"
-#include <fsfw/serialize/SerializeElement.h>
-#include <fsfw/serialize/SerialBufferAdapter.h>
-#include <unittest/internal/UnittDefinitions.h>
-#include <fsfw/serialize/SerializeIF.h>
+#include "../UnittDefinitions.h"
+#include "../../serialize/SerializeElement.h"
+#include "../../serialize/SerialBufferAdapter.h"
+#include "../../serialize/SerializeIF.h"
+
 #include <array>
 
 using retval = HasReturnvaluesIF;
diff --git a/unittest/internal/serialize/IntTestSerialization.h b/unittest/internal/serialize/IntTestSerialization.h
index f8841b820..e8dbd35a0 100644
--- a/unittest/internal/serialize/IntTestSerialization.h
+++ b/unittest/internal/serialize/IntTestSerialization.h
@@ -1,6 +1,7 @@
-#ifndef UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
-#define UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#ifndef FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
+#define FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
 #include <array>
 
 namespace testserialize {
@@ -12,4 +13,4 @@ ReturnValue_t test_serial_buffer_adapter();
 extern std::array<uint8_t, 512> test_array;
 }
 
-#endif /* UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_ */
+#endif /* FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_ */
diff --git a/unittest/testcfg/CatchFactory.cpp b/unittest/testcfg/CatchFactory.cpp
new file mode 100644
index 000000000..c74a8126d
--- /dev/null
+++ b/unittest/testcfg/CatchFactory.cpp
@@ -0,0 +1,60 @@
+#include "CatchFactory.h"
+
+#include <fsfw/events/EventManager.h>
+#include <fsfw/health/HealthTable.h>
+
+#include <fsfw/internalError/InternalErrorReporter.h>
+#include <fsfw/objectmanager/frameworkObjects.h>
+#include <fsfw/storagemanager/PoolManager.h>
+
+/**
+ * @brief Produces system objects.
+ * @details
+ * Build tasks by using SystemObject Interface (Interface).
+ * Header files of all tasks must be included
+ * Please note that an object has to implement the system object interface
+ * if the interface validity is checked or retrieved later by using the
+ * get<TargetInterface>(object_id) function from the ObjectManagerIF.
+ *
+ * Framework objects are created first.
+ *
+ * @ingroup init
+ */
+void Factory::produce(void) {
+	setStaticFrameworkObjectIds();
+	new EventManager(objects::EVENT_MANAGER);
+	new HealthTable(objects::HEALTH_TABLE);
+	//new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+
+	{
+		static constexpr uint8_t NUMBER_OF_POOLS = 5;
+		const uint16_t element_sizes[NUMBER_OF_POOLS] = {16, 32, 64, 128, 1024};
+		const uint16_t n_elements[NUMBER_OF_POOLS] = {100, 50, 25, 15, 5};
+		new PoolManager<NUMBER_OF_POOLS>(objects::TC_STORE, element_sizes,
+				n_elements);
+	}
+
+	{
+		static constexpr uint8_t NUMBER_OF_POOLS = 5;
+		const uint16_t element_sizes[NUMBER_OF_POOLS] = {16, 32, 64, 128, 1024};
+		const uint16_t n_elements[NUMBER_OF_POOLS] = {100, 50, 25, 15, 5};
+		new PoolManager<NUMBER_OF_POOLS>(objects::TM_STORE, element_sizes,
+				n_elements);
+	}
+
+	{
+		static constexpr uint8_t NUMBER_OF_POOLS = 6;
+		const uint16_t element_sizes[NUMBER_OF_POOLS] = {32, 64, 512,
+				1024, 2048, 4096};
+		const uint16_t n_elements[NUMBER_OF_POOLS] = {200, 100, 50, 25, 15, 5};
+		new PoolManager<NUMBER_OF_POOLS>(objects::IPC_STORE, element_sizes,
+				n_elements);
+	}
+
+}
+
+void Factory::setStaticFrameworkObjectIds() {
+
+}
+
+
diff --git a/unittest/testcfg/CatchFactory.h b/unittest/testcfg/CatchFactory.h
new file mode 100644
index 000000000..84f9207e2
--- /dev/null
+++ b/unittest/testcfg/CatchFactory.h
@@ -0,0 +1,16 @@
+#ifndef FACTORY_H_
+#define FACTORY_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+
+namespace Factory {
+	/**
+	 * @brief 	Creates all SystemObject elements which are persistent
+	 * 			during execution.
+	 */
+	void produce();
+	void setStaticFrameworkObjectIds();
+
+}
+
+#endif /* FACTORY_H_ */
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index d3451985e..4fb224c15 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -12,7 +12,7 @@
 #define FSFW_REDUCED_PRINTOUT		0
 
 //! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_VERBOSE_PRINTOUT       0
+#define FSFW_DEBUGGING              0
 
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle
diff --git a/unittest/testcfg/cdatapool/dataPoolInit.h b/unittest/testcfg/cdatapool/dataPoolInit.h
index 23a3d01f0..9425d7678 100644
--- a/unittest/testcfg/cdatapool/dataPoolInit.h
+++ b/unittest/testcfg/cdatapool/dataPoolInit.h
@@ -1,7 +1,7 @@
 #ifndef HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
 #define HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
 
-#include <fsfw/datapoolglob/GlobalDataPool.h>
+#include <fsfw/datapool/DataPool.h>
 #include <fsfw/datapool/PoolEntryIF.h>
 #include <map>
 #include <cstdint>
diff --git a/unittest/testcfg/testcfg.mk b/unittest/testcfg/testcfg.mk
index 64fa87f65..31d3b60a5 100644
--- a/unittest/testcfg/testcfg.mk
+++ b/unittest/testcfg/testcfg.mk
@@ -3,6 +3,7 @@ CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
 
 INCLUDES += $(CURRENTPATH)
 INCLUDES += $(CURRENTPATH)/objects
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index d5b2e467b..944ad7059 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -1,106 +1,107 @@
-//#include "TestActionHelper.h"
-//#include <fsfw/action/ActionHelper.h>
-//#include <fsfw/ipc/CommandMessage.h>
-//#include <catch2/catch.hpp>
-//#include "../../core/CatchDefinitions.h"
-//
-//
-//TEST_CASE( "Action Helper" , "[ActionHelper]") {
-//	ActionHelperOwnerMockBase testDhMock;
-//	MessageQueueMockBase testMqMock;
-//	ActionHelper actionHelper = ActionHelper(
-//			&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
-//	CommandMessage actionMessage;
-//	ActionId_t testActionId = 777;
-//	std::array <uint8_t, 3> testParams {1, 2, 3};
-//	store_address_t paramAddress;
-//	StorageManagerIF *ipcStore = tglob::getIpcStoreHandle();
-//	ipcStore->addData(&paramAddress, testParams.data(), 3);
-//	REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
-//
-//	SECTION ("Simple tests") {
-//		 ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
-//		 CHECK(not testDhMock.executeActionCalled);
-//		 REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-//		 CHECK(testDhMock.executeActionCalled);
-//		 // No message is sent if everything is alright.
-//		 CHECK(not testMqMock.wasMessageSent());
-//		 store_address_t invalidAddress;
-//		 ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
-//		 actionHelper.handleActionMessage(&actionMessage);
-//		 CHECK(testMqMock.wasMessageSent());
-//		 const uint8_t* ptr = nullptr;
-//		 size_t size = 0;
-//		 REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
-//		 REQUIRE(ptr == nullptr);
-//		 REQUIRE(size == 0);
-//		 testDhMock.getBuffer(&ptr, &size);
-//		 REQUIRE(size == 3);
-//		 for(uint8_t i = 0; i<3;i++){
-//			 REQUIRE(ptr[i] == (i+1));
-//		 }
-//		 testDhMock.clearBuffer();
-//	}
-//
-//	SECTION("Handle failures"){
-//		actionMessage.setCommand(1234);
-//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
-//		CHECK(not testMqMock.wasMessageSent());
-//		uint16_t step = 5;
-//		ReturnValue_t status = 0x1234;
-//		actionHelper.step(step, testMqMock.getId(), testActionId, status);
-//		step += 1;
-//		CHECK(testMqMock.wasMessageSent());
-//		CommandMessage testMessage;
-//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-//		REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
-//		uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
-//		REQUIRE(testMessage.getParameter2() == parameter2);
-//		REQUIRE(ActionMessage::getStep(&testMessage) == step);
-//	}
-//
-//	SECTION("Handle finish"){
-//		CHECK(not testMqMock.wasMessageSent());
-//		ReturnValue_t status = 0x9876;
-//		actionHelper.finish(testMqMock.getId(), testActionId, status);
-//		CHECK(testMqMock.wasMessageSent());
-//		CommandMessage testMessage;
-//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
-//		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
-//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
-//	}
-//
-//	SECTION("Handle failed"){
-//		store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
-//		std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
-//		REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
-//		ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
-//		CHECK(not testDhMock.executeActionCalled);
-//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-//		REQUIRE(ipcStore->getData(toLongParamAddress).first == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
-//		CommandMessage testMessage;
-//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
-//		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
-//		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
-//	}
-//
-//	SECTION("Missing IPC Data"){
-//		ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
-//		CHECK(not testDhMock.executeActionCalled);
-//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-//		CommandMessage testMessage;
-//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
-//		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
-//	}
-//
-//
-//	SECTION("Data Reply"){
-//
-//	}
-//}
+#include "TestActionHelper.h"
+#include <fsfw/action/ActionHelper.h>
+#include <fsfw/ipc/CommandMessage.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
+
+
+TEST_CASE( "Action Helper" , "[ActionHelper]") {
+	ActionHelperOwnerMockBase testDhMock;
+	MessageQueueMockBase testMqMock;
+	ActionHelper actionHelper = ActionHelper(
+			&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
+	CommandMessage actionMessage;
+	ActionId_t testActionId = 777;
+	std::array <uint8_t, 3> testParams {1, 2, 3};
+	store_address_t paramAddress;
+	StorageManagerIF *ipcStore = tglob::getIpcStoreHandle();
+	REQUIRE(ipcStore != nullptr);
+	ipcStore->addData(&paramAddress, testParams.data(), 3);
+	REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
+
+	SECTION ("Simple tests") {
+		 ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
+		 CHECK(not testDhMock.executeActionCalled);
+		 REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		 CHECK(testDhMock.executeActionCalled);
+		 // No message is sent if everything is alright.
+		 CHECK(not testMqMock.wasMessageSent());
+		 store_address_t invalidAddress;
+		 ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
+		 actionHelper.handleActionMessage(&actionMessage);
+		 CHECK(testMqMock.wasMessageSent());
+		 const uint8_t* ptr = nullptr;
+		 size_t size = 0;
+		 REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+		 REQUIRE(ptr == nullptr);
+		 REQUIRE(size == 0);
+		 testDhMock.getBuffer(&ptr, &size);
+		 REQUIRE(size == 3);
+		 for(uint8_t i = 0; i<3;i++){
+			 REQUIRE(ptr[i] == (i+1));
+		 }
+		 testDhMock.clearBuffer();
+	}
+
+	SECTION("Handle failures"){
+		actionMessage.setCommand(1234);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
+		CHECK(not testMqMock.wasMessageSent());
+		uint16_t step = 5;
+		ReturnValue_t status = 0x1234;
+		actionHelper.step(step, testMqMock.getId(), testActionId, status);
+		step += 1;
+		CHECK(testMqMock.wasMessageSent());
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
+		uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
+		REQUIRE(testMessage.getParameter2() == parameter2);
+		REQUIRE(ActionMessage::getStep(&testMessage) == step);
+	}
+
+	SECTION("Handle finish"){
+		CHECK(not testMqMock.wasMessageSent());
+		ReturnValue_t status = 0x9876;
+		actionHelper.finish(testMqMock.getId(), testActionId, status);
+		CHECK(testMqMock.wasMessageSent());
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
+		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
+	}
+
+	SECTION("Handle failed"){
+		store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
+		std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
+		REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
+		ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
+		CHECK(not testDhMock.executeActionCalled);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		REQUIRE(ipcStore->getData(toLongParamAddress).first == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
+		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+	}
+
+	SECTION("Missing IPC Data"){
+		ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
+		CHECK(not testDhMock.executeActionCalled);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
+		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+	}
+
+
+	SECTION("Data Reply"){
+
+	}
+}
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
index 9bc93d3e1..4ba417eb1 100644
--- a/unittest/tests/action/TestActionHelper.h
+++ b/unittest/tests/action/TestActionHelper.h
@@ -1,131 +1,132 @@
-//#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
-//#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
-//
-//#include <fsfw/action/HasActionsIF.h>
-//#include <fsfw/ipc/MessageQueueIF.h>
-//#include <fsfw/unittest/core/CatchDefinitions.h>
-//#include <cstring>
-//
-//
-//class ActionHelperOwnerMockBase: public HasActionsIF {
-//public:
-//	bool getCommandQueueCalled = false;
-//	bool executeActionCalled = false;
-//	static const size_t MAX_SIZE = 3;
-//	uint8_t buffer[MAX_SIZE] = {0, 0, 0};
-//	size_t size = 0;
-//
-//	MessageQueueId_t getCommandQueue() const override {
-//		return tconst::testQueueId;
-//	}
-//
-//	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-//			const uint8_t* data, size_t size) override {
-//		executeActionCalled = true;
-//		if(size > MAX_SIZE){
-//			return 0xAFFE;
-//		}
-//		this->size = size;
-//		memcpy(buffer, data, size);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//
-//	void clearBuffer(){
-//		this->size = 0;
-//		for(size_t i = 0; i<MAX_SIZE; i++){
-//			buffer[i] = 0;
-//		}
-//	}
-//
-//	void getBuffer(const uint8_t** ptr, size_t* size){
-//		if(size != nullptr){
-//			*size = this->size;
-//		}
-//		if(ptr != nullptr){
-//			*ptr = buffer;
-//		}
-//	}
-//};
-//
-//
-//class MessageQueueMockBase: public MessageQueueIF {
-//public:
-//	MessageQueueId_t myQueueId = 0;
-//	bool defaultDestSet = false;
-//	bool messageSent = false;
-//
-//
-//
-//	bool wasMessageSent() {
-//		bool tempMessageSent = messageSent;
-//		messageSent = false;
-//		return tempMessageSent;
-//	}
-//
-//	virtual ReturnValue_t reply( MessageQueueMessage* message ) {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	};
-//	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message,
-//			MessageQueueId_t *receivedFrom) {
-//		(*message) = lastMessage;
-//		lastMessage.clear();
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) {
-//		(*message) = lastMessage;
-//		lastMessage.clear();
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t flush(uint32_t* count) {
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual MessageQueueId_t getLastPartner() const {
-//		return tconst::testQueueId;
-//	}
-//	virtual MessageQueueId_t getId() const {
-//		return tconst::testQueueId;
-//	}
-//	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-//			MessageQueueMessage* message, MessageQueueId_t sentFrom,
-//			bool ignoreFault = false ) {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-//			MessageQueueMessage* message, bool ignoreFault = false ) override {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
-//			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message ) {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
-//		myQueueId = defaultDestination;
-//		defaultDestSet = true;
-//	}
-//
-//	virtual MessageQueueId_t getDefaultDestination() const {
-//		return myQueueId;
-//	}
-//	virtual bool isDefaultDestinationSet() const {
-//		return defaultDestSet;
-//	}
-//private:
-//	MessageQueueMessage lastMessage;
-//
-//};
-//
-//
-//#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
+#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
+#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
+
+#include <fsfw/action/HasActionsIF.h>
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <cstring>
+
+
+class ActionHelperOwnerMockBase: public HasActionsIF {
+public:
+	bool getCommandQueueCalled = false;
+	bool executeActionCalled = false;
+	static const size_t MAX_SIZE = 3;
+	uint8_t buffer[MAX_SIZE] = {0, 0, 0};
+	size_t size = 0;
+
+	MessageQueueId_t getCommandQueue() const override {
+		return tconst::testQueueId;
+	}
+
+	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+			const uint8_t* data, size_t size) override {
+		executeActionCalled = true;
+		if(size > MAX_SIZE){
+			return 0xAFFE;
+		}
+		this->size = size;
+		memcpy(buffer, data, size);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	void clearBuffer(){
+		this->size = 0;
+		for(size_t i = 0; i<MAX_SIZE; i++){
+			buffer[i] = 0;
+		}
+	}
+
+	void getBuffer(const uint8_t** ptr, size_t* size){
+		if(size != nullptr){
+			*size = this->size;
+		}
+		if(ptr != nullptr){
+			*ptr = buffer;
+		}
+	}
+};
+
+
+class MessageQueueMockBase: public MessageQueueIF {
+public:
+	MessageQueueId_t myQueueId = 0;
+	bool defaultDestSet = false;
+	bool messageSent = false;
+
+
+
+	bool wasMessageSent() {
+		bool tempMessageSent = messageSent;
+		messageSent = false;
+		return tempMessageSent;
+	}
+
+	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	};
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) {
+		(*message) = lastMessage;
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
+		memcpy(message->getBuffer(), lastMessage.getBuffer(),
+				message->getMessageSize());
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t flush(uint32_t* count) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual MessageQueueId_t getLastPartner() const {
+		return tconst::testQueueId;
+	}
+	virtual MessageQueueId_t getId() const {
+		return tconst::testQueueId;
+	}
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+		myQueueId = defaultDestination;
+		defaultDestSet = true;
+	}
+
+	virtual MessageQueueId_t getDefaultDestination() const {
+		return myQueueId;
+	}
+	virtual bool isDefaultDestinationSet() const {
+		return defaultDestSet;
+	}
+private:
+	MessageQueueMessage lastMessage;
+
+};
+
+
+#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
diff --git a/unittest/tests/container/RingBufferTest.cpp b/unittest/tests/container/RingBufferTest.cpp
index 8b82d407f..9c1c8a23b 100644
--- a/unittest/tests/container/RingBufferTest.cpp
+++ b/unittest/tests/container/RingBufferTest.cpp
@@ -1,7 +1,7 @@
-#include <fsfw/container/SimpleRingBuffer.h>
-#include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
+#include "../../container/SimpleRingBuffer.h"
 
+#include <catch2/catch.hpp>
 #include <cstring>
 
 TEST_CASE("Ring Buffer Test" , "[RingBufferTest]") {
diff --git a/unittest/tests/container/TestArrayList.cpp b/unittest/tests/container/TestArrayList.cpp
index 914188cb7..2f8842764 100644
--- a/unittest/tests/container/TestArrayList.cpp
+++ b/unittest/tests/container/TestArrayList.cpp
@@ -1,5 +1,6 @@
-#include <fsfw/container/ArrayList.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/ArrayList.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
 
diff --git a/unittest/tests/container/TestDynamicFifo.cpp b/unittest/tests/container/TestDynamicFifo.cpp
index 6c9b7415d..bb19131eb 100644
--- a/unittest/tests/container/TestDynamicFifo.cpp
+++ b/unittest/tests/container/TestDynamicFifo.cpp
@@ -1,7 +1,7 @@
 
-#include <fsfw/container/DynamicFIFO.h>
-#include <fsfw/container/FIFO.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/DynamicFIFO.h"
+#include "../../container/FIFO.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch.hpp>
 #include <CatchDefinitions.h>
diff --git a/unittest/tests/container/TestFifo.cpp b/unittest/tests/container/TestFifo.cpp
index 3775f4242..bd727e00c 100644
--- a/unittest/tests/container/TestFifo.cpp
+++ b/unittest/tests/container/TestFifo.cpp
@@ -1,7 +1,7 @@
 
-#include <fsfw/container/DynamicFIFO.h>
-#include <fsfw/container/FIFO.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/DynamicFIFO.h"
+#include "../../container/FIFO.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
diff --git a/unittest/tests/container/TestFixedArrayList.cpp b/unittest/tests/container/TestFixedArrayList.cpp
index 737932e36..5a1bd280a 100644
--- a/unittest/tests/container/TestFixedArrayList.cpp
+++ b/unittest/tests/container/TestFixedArrayList.cpp
@@ -1,7 +1,7 @@
 #include "../../core/CatchDefinitions.h"
 
-#include <fsfw/container/FixedArrayList.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/FixedArrayList.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch2/catch.hpp>
 
diff --git a/unittest/tests/container/TestFixedMap.cpp b/unittest/tests/container/TestFixedMap.cpp
index 079062f00..da0c84e3e 100644
--- a/unittest/tests/container/TestFixedMap.cpp
+++ b/unittest/tests/container/TestFixedMap.cpp
@@ -1,5 +1,5 @@
-#include <fsfw/container/FixedMap.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/FixedMap.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
diff --git a/unittest/tests/container/TestFixedOrderedMultimap.cpp b/unittest/tests/container/TestFixedOrderedMultimap.cpp
index 95194cb5a..e625b5599 100644
--- a/unittest/tests/container/TestFixedOrderedMultimap.cpp
+++ b/unittest/tests/container/TestFixedOrderedMultimap.cpp
@@ -1,5 +1,5 @@
-#include <fsfw/container/FixedOrderedMultimap.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/FixedOrderedMultimap.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
diff --git a/unittest/tests/osal/TestMessageQueue.cpp b/unittest/tests/osal/TestMessageQueue.cpp
index 8e59fa084..441d32e7d 100644
--- a/unittest/tests/osal/TestMessageQueue.cpp
+++ b/unittest/tests/osal/TestMessageQueue.cpp
@@ -1,8 +1,8 @@
-#include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/ipc/QueueFactory.h>
-#include "catch.hpp"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/QueueFactory.h"
+#include <catch.hpp>
 #include <array>
-#include "core/CatchDefinitions.h"
+#include "../../core/CatchDefinitions.h"
 
 TEST_CASE("MessageQueue Basic Test","[TestMq]") {
 	MessageQueueIF* testSenderMq =
diff --git a/unittest/tests/serialize/TestSerialBufferAdapter.cpp b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
index 9919ed844..07cd3f9c5 100644
--- a/unittest/tests/serialize/TestSerialBufferAdapter.cpp
+++ b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/serialize/SerialBufferAdapter.h>
+#include "../../serialize/SerialBufferAdapter.h"
 
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.cpp b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
index 0a09e430c..fbe488946 100644
--- a/unittest/tests/serialize/TestSerialLinkedPacket.cpp
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
@@ -1,8 +1,9 @@
-#include <fsfw/globalfunctions/arrayprinter.h>
+#include "TestSerialLinkedPacket.h"
+#include "../../core/CatchDefinitions.h"
+
+#include "../../globalfunctions/arrayprinter.h"
 
 #include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
-#include "TestSerialLinkedPacket.h"
 
 
 TEST_CASE("Serial Linked Packet" , "[SerLinkPacket]") {
diff --git a/unittest/tests/serialize/TestSerialization.cpp b/unittest/tests/serialize/TestSerialization.cpp
index 4c9ba1818..6e31170a1 100644
--- a/unittest/tests/serialize/TestSerialization.cpp
+++ b/unittest/tests/serialize/TestSerialization.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/serialize/SerializeAdapter.h>
+#include "../../serialize/SerializeAdapter.h"
 
 #include "catch.hpp"
 #include <array>

From 3f77fab2d9ada5b029cf823674adaa5e5ea7d403 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 22:01:38 +0100
Subject: [PATCH 1148/1774] taken over cmake lists

---
 rmap/CMakeLists.txt | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 rmap/CMakeLists.txt

diff --git a/rmap/CMakeLists.txt b/rmap/CMakeLists.txt
new file mode 100644
index 000000000..78c99e420
--- /dev/null
+++ b/rmap/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		RMAP.cpp
+		RMAPCookie.cpp
+		RmapDeviceCommunicationIF.cpp
+)
+

From 715386e366d40eb4dacfed62cd529ab72e53cb79 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 22:12:57 +0100
Subject: [PATCH 1149/1774] clened up a bit

---
 rmap/RMAP.cpp                      |  14 ++--
 rmap/RMAP.h                        |  12 ++--
 rmap/RMAPChannelIF.h               |  11 +--
 rmap/RMAPCookie.cpp                |   9 +--
 rmap/RMAPCookie.h                  |  16 +++--
 rmap/RmapDeviceCommunicationIF.cpp |  10 +--
 rmap/RmapDeviceCommunicationIF.h   | 105 ++++++++++++++++-------------
 rmap/rmapStructs.h                 |   8 +--
 8 files changed, 100 insertions(+), 85 deletions(-)

diff --git a/rmap/RMAP.cpp b/rmap/RMAP.cpp
index 4ab8b17ba..7ea6e5329 100644
--- a/rmap/RMAP.cpp
+++ b/rmap/RMAP.cpp
@@ -1,8 +1,10 @@
-#include "../devicehandlers/DeviceCommunicationIF.h"
-#include "rmapStructs.h"
 #include "RMAP.h"
+#include "rmapStructs.h"
 #include "RMAPChannelIF.h"
-#include <stddef.h>
+
+#include "../devicehandlers/DeviceCommunicationIF.h"
+
+#include <cstddef>
 
 ReturnValue_t RMAP::reset(RMAPCookie* cookie) {
 	return cookie->getChannel()->reset();
@@ -12,8 +14,8 @@ RMAP::RMAP(){
 
 }
 
-ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, uint8_t* buffer,
-		uint32_t length) {
+ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+		size_t length) {
 	uint8_t instruction;
 
 	if ((buffer == NULL) && (length != 0)) {
@@ -61,7 +63,7 @@ ReturnValue_t RMAP::sendReadCommand(RMAPCookie *cookie, uint32_t expLength) {
 }
 
 ReturnValue_t RMAP::getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-		uint32_t *size) {
+		size_t *size) {
 	if (cookie->getChannel() == NULL) {
 		return COMMAND_NO_CHANNEL;
 	}
diff --git a/rmap/RMAP.h b/rmap/RMAP.h
index d14320cbc..83e29fede 100644
--- a/rmap/RMAP.h
+++ b/rmap/RMAP.h
@@ -1,8 +1,8 @@
-#ifndef RMAPpp_H_
-#define RMAPpp_H_
+#ifndef FSFW_RMAP_RMAP_H_
+#define FSFW_RMAP_RMAP_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "RMAPCookie.h"
+#include "../rmap/RMAPCookie.h"
 
 //SHOULDTODO: clean up includes for RMAP, should be enough to include RMAP.h but right now it's quite chaotic...
 
@@ -153,8 +153,8 @@ public:
 	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command
 	 *      - return codes of RMAPChannelIF::sendCommand()
 	 */
-	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, uint8_t* buffer,
-			uint32_t length);
+	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+			size_t length);
 
 	/**
 	 * get the reply to a write command
@@ -204,7 +204,7 @@ public:
 	 *      - return codes of RMAPChannelIF::getReply()
 	 */
 	static ReturnValue_t getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-			uint32_t *size);
+			size_t *size);
 
 	/**
 	 * @see sendReadCommand()
diff --git a/rmap/RMAPChannelIF.h b/rmap/RMAPChannelIF.h
index dac4a7220..0aa809c53 100644
--- a/rmap/RMAPChannelIF.h
+++ b/rmap/RMAPChannelIF.h
@@ -1,8 +1,9 @@
-#ifndef RMAPCHANNELIF_H_
-#define RMAPCHANNELIF_H_
+#ifndef FSFW_RMAP_RMAPCHANNELIF_H_
+#define FSFW_RMAP_RMAPCHANNELIF_H_
 
 #include "RMAPCookie.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
 
 class RMAPChannelIF {
 public:
@@ -73,7 +74,7 @@ public:
 	 *      - @c NOT_SUPPORTED						if you dont feel like implementing something...
 	 */
 	virtual ReturnValue_t sendCommand(RMAPCookie *cookie, uint8_t instruction,
-			uint8_t *data, uint32_t datalen)=0;
+			const uint8_t *data, size_t datalen)=0;
 
 	/**
 	 * get the reply to an rmap command
@@ -92,7 +93,7 @@ public:
 	 *      - all RMAP standard replies
 	 */
 	virtual ReturnValue_t getReply(RMAPCookie *cookie, uint8_t **databuffer,
-			uint32_t *len)=0;
+			size_t *len)=0;
 
 	/**
 	 *
@@ -112,4 +113,4 @@ public:
 
 };
 
-#endif /* RMAPCHANNELIF_H_ */
+#endif /* FSFW_RMAP_RMAPCHANNELIF_H_ */
diff --git a/rmap/RMAPCookie.cpp b/rmap/RMAPCookie.cpp
index 597f066c5..f8fe2d3eb 100644
--- a/rmap/RMAPCookie.cpp
+++ b/rmap/RMAPCookie.cpp
@@ -1,6 +1,6 @@
 #include "RMAPChannelIF.h"
 #include "RMAPCookie.h"
-#include <stddef.h>
+#include <cstddef>
 
 
 RMAPCookie::RMAPCookie() {
@@ -31,7 +31,8 @@ RMAPCookie::RMAPCookie() {
 
 
 RMAPCookie::RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-		RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen) {
+		RMAPChannelIF *set_channel, uint8_t set_command_mask,
+		size_t maxReplyLen) {
 	this->header.dest_address = 0;
 	this->header.protocol = 0x01;
 	this->header.instruction = 0;
@@ -93,11 +94,11 @@ RMAPCookie::~RMAPCookie() {
 
 }
 
-uint32_t RMAPCookie::getMaxReplyLen() const {
+size_t RMAPCookie::getMaxReplyLen() const {
 	return maxReplyLen;
 }
 
-void RMAPCookie::setMaxReplyLen(uint32_t maxReplyLen) {
+void RMAPCookie::setMaxReplyLen(size_t maxReplyLen) {
 	this->maxReplyLen = maxReplyLen;
 }
 
diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h
index 4c6081bdd..385426468 100644
--- a/rmap/RMAPCookie.h
+++ b/rmap/RMAPCookie.h
@@ -1,8 +1,9 @@
-#ifndef RMAPCOOKIE_H_
-#define RMAPCOOKIE_H_
+#ifndef FSFW_RMAP_RMAPCOOKIE_H_
+#define FSFW_RMAP_RMAPCOOKIE_H_
 
-#include "../devicehandlers/CookieIF.h"
 #include "rmapStructs.h"
+#include "../devicehandlers/CookieIF.h"
+#include <cstddef>
 
 class RMAPChannelIF;
 
@@ -12,7 +13,8 @@ public:
 	RMAPCookie();
 
 	RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-			RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen = 0);
+			RMAPChannelIF *set_channel, uint8_t set_command_mask,
+			size_t maxReplyLen = 0);
 	virtual ~RMAPCookie();
 
 
@@ -28,8 +30,8 @@ public:
 	void setCommandMask(uint8_t commandMask);
 	uint8_t getCommandMask();
 
-	uint32_t getMaxReplyLen() const;
-	void setMaxReplyLen(uint32_t maxReplyLen);
+	size_t getMaxReplyLen() const;
+	void setMaxReplyLen(size_t maxReplyLen);
 
 	uint16_t getTransactionIdentifier() const;
 	void setTransactionIdentifier(uint16_t id_);
@@ -55,4 +57,4 @@ protected:
 	uint8_t dataCRC;
 };
 
-#endif /* RMAPCOOKIE_H_ */
+#endif /* FSFW_RMAP_RMAPCOOKIE_H_ */
diff --git a/rmap/RmapDeviceCommunicationIF.cpp b/rmap/RmapDeviceCommunicationIF.cpp
index db4a75b55..d81baabd5 100644
--- a/rmap/RmapDeviceCommunicationIF.cpp
+++ b/rmap/RmapDeviceCommunicationIF.cpp
@@ -5,9 +5,9 @@
 RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF* cookie,
-		uint8_t* data, uint32_t len) {
-	return RMAP::sendWriteCommand((RMAPCookie *) cookie, data, len);
+ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF *cookie,
+		const uint8_t * sendData, size_t sendLen) {
+	return RMAP::sendWriteCommand((RMAPCookie *) cookie, sendData, sendLen);
 }
 
 ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
@@ -15,13 +15,13 @@ ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
 }
 
 ReturnValue_t RmapDeviceCommunicationIF::requestReceiveMessage(
-		CookieIF* cookie) {
+		CookieIF *cookie, size_t requestLen) {
 	return RMAP::sendReadCommand((RMAPCookie *) cookie,
 				((RMAPCookie *) cookie)->getMaxReplyLen());
 }
 
 ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
-		uint8_t** buffer, uint32_t* size) {
+		uint8_t** buffer, size_t * size) {
 	return RMAP::getReadReply((RMAPCookie *) cookie, buffer, size);
 }
 
diff --git a/rmap/RmapDeviceCommunicationIF.h b/rmap/RmapDeviceCommunicationIF.h
index dacc720b4..1333966a7 100644
--- a/rmap/RmapDeviceCommunicationIF.h
+++ b/rmap/RmapDeviceCommunicationIF.h
@@ -1,10 +1,11 @@
-#ifndef MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
-#define MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+#ifndef FSFW_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+#define FSFW_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
 
 #include "../devicehandlers/DeviceCommunicationIF.h"
 
 /**
- * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls. It expects RMAPCookies or a derived class of RMAPCookies
+ * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls.
+ *          It expects RMAPCookies or a derived class of RMAPCookies
  *
  * @details	The open, close and reOpen calls are mission specific
  * 			The open call might return any child of RMAPCookies
@@ -16,65 +17,73 @@ class RmapDeviceCommunicationIF: public DeviceCommunicationIF {
 public:
 	virtual ~RmapDeviceCommunicationIF();
 
-
 	/**
-	 * This method is mission specific as the open call will return a mission specific cookie
-	 *
-	 * @param cookie A cookie, can be mission specific subclass of RMAP Cookie
-	 * @param address The address of the RMAP Cookie
-	 * @param maxReplyLen Maximum length of expected reply
-	 * @return
-	 */
-	virtual ReturnValue_t open(CookieIF **cookie, uint32_t address,
-			uint32_t maxReplyLen) = 0;
-
-	/**
-	 * Use an existing cookie to open a connection to a new DeviceCommunication.
-	 * The previous connection must not be closed.
-	 * If the returnvalue is not RETURN_OK, the cookie is unchanged and
-	 * can be used with the previous connection.
-	 *
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
 	 * @param cookie
-	 * @param address
-	 * @param maxReplyLen
-	 * @return
+	 * @return -@c RETURN_OK if initialization was successfull
+	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t reOpen(CookieIF *cookie, uint32_t address,
-			uint32_t maxReplyLen) = 0;
-
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
 
 	/**
-	 * Closing call of connection and memory free of cookie. Mission dependent call
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
 	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return -@c RETURN_OK for successfull send
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
-	virtual void close(CookieIF *cookie) = 0;
+	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
+			size_t sendLen);
 
-	//SHOULDDO can data be const?
 	/**
-	 *
-	 *
-	 * @param cookie Expects an RMAPCookie or derived from RMAPCookie Class
-	 * @param data Data to be send
-	 * @param len Length of the data to be send
-	 * @return - Return codes of RMAP::sendWriteCommand()
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return -@c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t sendMessage(CookieIF *cookie, uint8_t *data,
-			uint32_t len);
-
 	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
 
-	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie);
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device.
+	 *
+	 * @param cookie
+	 * @return -@c RETURN_OK to confirm the request for data has been sent.
+	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
+	 *         	   will not be called in the respective communication cycle.
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen);
 
+	/**
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return @c RETURN_OK for successfull receive
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
 	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
-			uint32_t *size);
+			size_t *size);
 
-	virtual ReturnValue_t setAddress(CookieIF *cookie, uint32_t address);
-
-	virtual uint32_t getAddress(CookieIF *cookie);
-
-	virtual ReturnValue_t setParameter(CookieIF *cookie, uint32_t parameter);
-
-	virtual uint32_t getParameter(CookieIF *cookie);
+	ReturnValue_t setAddress(CookieIF* cookie,
+			uint32_t address);
+	uint32_t getAddress(CookieIF* cookie);
+	ReturnValue_t setParameter(CookieIF* cookie,
+			uint32_t parameter);
+	uint32_t getParameter(CookieIF* cookie);
 };
 
-#endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
+#endif /* FSFW_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
diff --git a/rmap/rmapStructs.h b/rmap/rmapStructs.h
index bf0fb2606..11d8bb85b 100644
--- a/rmap/rmapStructs.h
+++ b/rmap/rmapStructs.h
@@ -1,7 +1,7 @@
-#ifndef RMAPSTRUCTS_H_
-#define RMAPSTRUCTS_H_
+#ifndef FSFW_RMAP_RMAPSTRUCTS_H_
+#define FSFW_RMAP_RMAPSTRUCTS_H_
 
-#include <stdint.h>
+#include <cstdint>
 
 //SHOULDDO: having the defines within a namespace would be nice. Problem are the defines referencing the previous define, eg RMAP_COMMAND_WRITE
 
@@ -95,4 +95,4 @@ struct rmap_write_reply_header {
 
 }
 
-#endif /* RMAPSTRUCTS_H_ */
+#endif /* FSFW_RMAP_RMAPSTRUCTS_H_ */

From 692aa087d8d4dfb3c02cb7bf61b93ea47e1ba8df Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 22:13:22 +0100
Subject: [PATCH 1150/1774] taken over cleaned up branch

---
 rmap/RMAP.cpp                      | 10 ++++++----
 rmap/RMAP.h                        |  4 ++--
 rmap/RMAPChannelIF.h               |  8 ++++----
 rmap/RMAPCookie.cpp                |  9 +++++----
 rmap/RMAPCookie.h                  | 11 ++++++-----
 rmap/RmapDeviceCommunicationIF.cpp |  4 ++--
 rmap/RmapDeviceCommunicationIF.h   |  6 +++---
 rmap/rmapStructs.h                 |  8 ++++----
 8 files changed, 32 insertions(+), 28 deletions(-)

diff --git a/rmap/RMAP.cpp b/rmap/RMAP.cpp
index d0872c8e6..7ea6e5329 100644
--- a/rmap/RMAP.cpp
+++ b/rmap/RMAP.cpp
@@ -1,8 +1,10 @@
+#include "RMAP.h"
+#include "rmapStructs.h"
+#include "RMAPChannelIF.h"
+
 #include "../devicehandlers/DeviceCommunicationIF.h"
-#include "../rmap/rmapStructs.h"
-#include "../rmap/RMAP.h"
-#include "../rmap/RMAPChannelIF.h"
-#include <stddef.h>
+
+#include <cstddef>
 
 ReturnValue_t RMAP::reset(RMAPCookie* cookie) {
 	return cookie->getChannel()->reset();
diff --git a/rmap/RMAP.h b/rmap/RMAP.h
index e083d407f..83e29fede 100644
--- a/rmap/RMAP.h
+++ b/rmap/RMAP.h
@@ -1,5 +1,5 @@
-#ifndef RMAPpp_H_
-#define RMAPpp_H_
+#ifndef FSFW_RMAP_RMAP_H_
+#define FSFW_RMAP_RMAP_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../rmap/RMAPCookie.h"
diff --git a/rmap/RMAPChannelIF.h b/rmap/RMAPChannelIF.h
index d851885b1..0aa809c53 100644
--- a/rmap/RMAPChannelIF.h
+++ b/rmap/RMAPChannelIF.h
@@ -1,7 +1,7 @@
-#ifndef RMAPCHANNELIF_H_
-#define RMAPCHANNELIF_H_
+#ifndef FSFW_RMAP_RMAPCHANNELIF_H_
+#define FSFW_RMAP_RMAPCHANNELIF_H_
 
-#include "../rmap/RMAPCookie.h"
+#include "RMAPCookie.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
 
@@ -113,4 +113,4 @@ public:
 
 };
 
-#endif /* RMAPCHANNELIF_H_ */
+#endif /* FSFW_RMAP_RMAPCHANNELIF_H_ */
diff --git a/rmap/RMAPCookie.cpp b/rmap/RMAPCookie.cpp
index c92ee4337..f8fe2d3eb 100644
--- a/rmap/RMAPCookie.cpp
+++ b/rmap/RMAPCookie.cpp
@@ -1,6 +1,6 @@
-#include "../rmap/RMAPChannelIF.h"
-#include "../rmap/RMAPCookie.h"
-#include <stddef.h>
+#include "RMAPChannelIF.h"
+#include "RMAPCookie.h"
+#include <cstddef>
 
 
 RMAPCookie::RMAPCookie() {
@@ -31,7 +31,8 @@ RMAPCookie::RMAPCookie() {
 
 
 RMAPCookie::RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-		RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen) {
+		RMAPChannelIF *set_channel, uint8_t set_command_mask,
+		size_t maxReplyLen) {
 	this->header.dest_address = 0;
 	this->header.protocol = 0x01;
 	this->header.instruction = 0;
diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h
index 8832f857b..385426468 100644
--- a/rmap/RMAPCookie.h
+++ b/rmap/RMAPCookie.h
@@ -1,8 +1,8 @@
-#ifndef RMAPCOOKIE_H_
-#define RMAPCOOKIE_H_
+#ifndef FSFW_RMAP_RMAPCOOKIE_H_
+#define FSFW_RMAP_RMAPCOOKIE_H_
 
+#include "rmapStructs.h"
 #include "../devicehandlers/CookieIF.h"
-#include "../rmap/rmapStructs.h"
 #include <cstddef>
 
 class RMAPChannelIF;
@@ -13,7 +13,8 @@ public:
 	RMAPCookie();
 
 	RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-			RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen = 0);
+			RMAPChannelIF *set_channel, uint8_t set_command_mask,
+			size_t maxReplyLen = 0);
 	virtual ~RMAPCookie();
 
 
@@ -56,4 +57,4 @@ protected:
 	uint8_t dataCRC;
 };
 
-#endif /* RMAPCOOKIE_H_ */
+#endif /* FSFW_RMAP_RMAPCOOKIE_H_ */
diff --git a/rmap/RmapDeviceCommunicationIF.cpp b/rmap/RmapDeviceCommunicationIF.cpp
index 62a3f3ef3..d81baabd5 100644
--- a/rmap/RmapDeviceCommunicationIF.cpp
+++ b/rmap/RmapDeviceCommunicationIF.cpp
@@ -1,5 +1,5 @@
-#include "../rmap/RmapDeviceCommunicationIF.h"
-#include "../rmap/RMAP.h"
+#include "RmapDeviceCommunicationIF.h"
+#include "RMAP.h"
 
 //TODO Cast here are all potential bugs
 RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
diff --git a/rmap/RmapDeviceCommunicationIF.h b/rmap/RmapDeviceCommunicationIF.h
index 52efa3de9..1333966a7 100644
--- a/rmap/RmapDeviceCommunicationIF.h
+++ b/rmap/RmapDeviceCommunicationIF.h
@@ -1,5 +1,5 @@
-#ifndef MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
-#define MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+#ifndef FSFW_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+#define FSFW_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
 
 #include "../devicehandlers/DeviceCommunicationIF.h"
 
@@ -86,4 +86,4 @@ public:
 	uint32_t getParameter(CookieIF* cookie);
 };
 
-#endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
+#endif /* FSFW_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
diff --git a/rmap/rmapStructs.h b/rmap/rmapStructs.h
index bf0fb2606..11d8bb85b 100644
--- a/rmap/rmapStructs.h
+++ b/rmap/rmapStructs.h
@@ -1,7 +1,7 @@
-#ifndef RMAPSTRUCTS_H_
-#define RMAPSTRUCTS_H_
+#ifndef FSFW_RMAP_RMAPSTRUCTS_H_
+#define FSFW_RMAP_RMAPSTRUCTS_H_
 
-#include <stdint.h>
+#include <cstdint>
 
 //SHOULDDO: having the defines within a namespace would be nice. Problem are the defines referencing the previous define, eg RMAP_COMMAND_WRITE
 
@@ -95,4 +95,4 @@ struct rmap_write_reply_header {
 
 }
 
-#endif /* RMAPSTRUCTS_H_ */
+#endif /* FSFW_RMAP_RMAPSTRUCTS_H_ */

From f161a94113c6c95ce7014a2cf9597817d8f4c0b1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 10:44:48 +0100
Subject: [PATCH 1151/1774] taken over upstream fixes

---
 thermal/ThermalComponentCore.cpp | 13 +++++++------
 thermal/ThermalModule.cpp        |  6 +++---
 thermal/ThermalModuleIF.h        |  3 +--
 thermal/tcsDefinitions.h         |  6 +++---
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index 7b594d0c9..ba8750532 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -1,4 +1,5 @@
 #include "ThermalComponentCore.h"
+#include "tcsDefinitions.h"
 
 ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
         uint8_t domainId, gp_id_t temperaturePoolId,
@@ -60,7 +61,7 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
 	temperature = getTemperature();
 	updateMinMaxTemp();
-	if (temperature != INVALID_TEMPERATURE) {
+	if (temperature != thermal::INVALID_TEMPERATURE) {
 		temperature.setValid(PoolVariableIF::VALID);
 		State state = getState(temperature.value, getParameters(),
 				targetState.value);
@@ -119,7 +120,7 @@ ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
 }
 
 void ThermalComponentCore::setOutputInvalid() {
-	temperature = INVALID_TEMPERATURE;
+	temperature = thermal::INVALID_TEMPERATURE;
 	temperature.setValid(PoolVariableIF::INVALID);
 	currentState.setValid(PoolVariableIF::INVALID);
 	heaterRequest = HEATER_DONT_CARE;
@@ -144,13 +145,13 @@ float ThermalComponentCore::getTemperature() {
 
 	if (thermalModule != nullptr) {
 		float temperature = thermalModule->getTemperature();
-		if (temperature != ThermalModuleIF::INVALID_TEMPERATURE) {
+		if (temperature != thermal::INVALID_TEMPERATURE) {
 			return temperature;
 		} else {
-			return INVALID_TEMPERATURE;
+			return thermal::INVALID_TEMPERATURE;
 		}
 	} else {
-		return INVALID_TEMPERATURE;
+		return thermal::INVALID_TEMPERATURE;
 	}
 }
 
@@ -226,7 +227,7 @@ ThermalComponentIF::State ThermalComponentCore::getIgnoredState(int8_t state) {
 }
 
 void ThermalComponentCore::updateMinMaxTemp() {
-	if (temperature == INVALID_TEMPERATURE) {
+	if (temperature == thermal::INVALID_TEMPERATURE) {
 		return;
 	}
 	if (temperature < minTemp) {
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index 457a6743d..de3475429 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -107,7 +107,7 @@ void ThermalModule::calculateTemperature() {
 		moduleTemperature = moduleTemperature.value / numberOfValidSensors;
 		moduleTemperature.setValid(PoolVariableIF::VALID);
 	} else {
-		moduleTemperature = INVALID_TEMPERATURE;
+		moduleTemperature.value = thermal::INVALID_TEMPERATURE;
 		moduleTemperature.setValid(PoolVariableIF::INVALID);
 	}
 }
@@ -219,7 +219,7 @@ void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
 bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 		Strategy strategy) {
 	currentState.setValid(PoolVariableIF::VALID);
-	if (moduleTemperature == INVALID_TEMPERATURE) {
+	if (moduleTemperature == thermal::INVALID_TEMPERATURE) {
 		currentState = UNKNOWN;
 		return false;
 	}
@@ -282,7 +282,7 @@ void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
 }
 
 void ThermalModule::setOutputInvalid() {
-	moduleTemperature = INVALID_TEMPERATURE;
+	moduleTemperature = thermal::INVALID_TEMPERATURE;
 	moduleTemperature.setValid(PoolVariableIF::INVALID);
 	currentState.setValid(PoolVariableIF::INVALID);
 	std::list<ComponentData>::iterator iter = components.begin();
diff --git a/thermal/ThermalModuleIF.h b/thermal/ThermalModuleIF.h
index 2d11a6f25..89cf93d69 100644
--- a/thermal/ThermalModuleIF.h
+++ b/thermal/ThermalModuleIF.h
@@ -2,6 +2,7 @@
 #define THERMALMODULEIF_H_
 
 #include "ThermalComponentIF.h"
+
 class AbstractTemperatureSensor;
 
 class ThermalModuleIF{
@@ -18,8 +19,6 @@ public:
 		NON_OPERATIONAL = 0, OPERATIONAL = 1, UNKNOWN = 2
 	};
 
-	static constexpr float INVALID_TEMPERATURE = 999;
-
 	virtual ~ThermalModuleIF() {
 
 	}
diff --git a/thermal/tcsDefinitions.h b/thermal/tcsDefinitions.h
index 37e5b849d..3225be5c3 100644
--- a/thermal/tcsDefinitions.h
+++ b/thermal/tcsDefinitions.h
@@ -1,8 +1,8 @@
 #ifndef TCSDEFINITIONS_H_
 #define TCSDEFINITIONS_H_
 
-
-static const float INVALID_TEMPERATURE = 999;
-
+namespace thermal {
+static constexpr float INVALID_TEMPERATURE = 999;
+}
 
 #endif /* TCSDEFINITIONS_H_ */

From 720e3baa9080eb0d2a3b3bbcf398788ed4639a4f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 10:48:39 +0100
Subject: [PATCH 1152/1774] fixed includes

---
 unittest/internal/osal/IntTestMq.cpp                 | 4 ++--
 unittest/internal/osal/IntTestMutex.cpp              | 2 +-
 unittest/internal/osal/IntTestSemaphore.cpp          | 6 +++---
 unittest/internal/serialize/IntTestSerialization.cpp | 7 ++++---
 unittest/internal/serialize/IntTestSerialization.h   | 2 +-
 5 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/unittest/internal/osal/IntTestMq.cpp b/unittest/internal/osal/IntTestMq.cpp
index 8d95f51ed..9917285f5 100644
--- a/unittest/internal/osal/IntTestMq.cpp
+++ b/unittest/internal/osal/IntTestMq.cpp
@@ -1,8 +1,8 @@
 #include "IntTestMq.h"
 #include "../UnittDefinitions.h"
 
-#include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/QueueFactory.h"
+#include "../../../ipc/MessageQueueIF.h"
+#include "../../../ipc/QueueFactory.h"
 
 #include <array>
 
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index 015813470..d2f8b9628 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -1,6 +1,6 @@
 #include "IntTestMutex.h"
 
-#include "../../ipc/MutexFactory.h"
+#include "../../../ipc/MutexFactory.h"
 #include "../UnittDefinitions.h"
 
 #if defined(hosted)
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index f260b6a51..6d2719d57 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -1,9 +1,9 @@
 #include "IntTestSemaphore.h"
 #include "../UnittDefinitions.h"
 
-#include "../../tasks/SemaphoreFactory.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../timemanager/Stopwatch.h"
+#include "../../../tasks/SemaphoreFactory.h"
+#include "../../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../../timemanager/Stopwatch.h"
 
 
 void testsemaph::testBinSemaph() {
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
index 1e33ff335..793661c5b 100644
--- a/unittest/internal/serialize/IntTestSerialization.cpp
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -1,8 +1,9 @@
 #include "IntTestSerialization.h"
 #include "../UnittDefinitions.h"
-#include "../../serialize/SerializeElement.h"
-#include "../../serialize/SerialBufferAdapter.h"
-#include "../../serialize/SerializeIF.h"
+
+#include "../../../serialize/SerializeElement.h"
+#include "../../../serialize/SerialBufferAdapter.h"
+#include "../../../serialize/SerializeIF.h"
 
 #include <array>
 
diff --git a/unittest/internal/serialize/IntTestSerialization.h b/unittest/internal/serialize/IntTestSerialization.h
index e8dbd35a0..8706e0572 100644
--- a/unittest/internal/serialize/IntTestSerialization.h
+++ b/unittest/internal/serialize/IntTestSerialization.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
 #define FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
 
-#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 #include <array>
 
 namespace testserialize {

From 0ccd266f51f8238f3489b192ec36496c90fc24fe Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 10:49:00 +0100
Subject: [PATCH 1153/1774] internal unittests fixed

---
 unittest/internal/osal/IntTestMq.cpp                 | 4 ++--
 unittest/internal/osal/IntTestMutex.cpp              | 2 +-
 unittest/internal/osal/IntTestSemaphore.cpp          | 6 +++---
 unittest/internal/serialize/IntTestSerialization.cpp | 7 ++++---
 unittest/internal/serialize/IntTestSerialization.h   | 2 +-
 5 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/unittest/internal/osal/IntTestMq.cpp b/unittest/internal/osal/IntTestMq.cpp
index 8d95f51ed..9917285f5 100644
--- a/unittest/internal/osal/IntTestMq.cpp
+++ b/unittest/internal/osal/IntTestMq.cpp
@@ -1,8 +1,8 @@
 #include "IntTestMq.h"
 #include "../UnittDefinitions.h"
 
-#include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/QueueFactory.h"
+#include "../../../ipc/MessageQueueIF.h"
+#include "../../../ipc/QueueFactory.h"
 
 #include <array>
 
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index 015813470..d2f8b9628 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -1,6 +1,6 @@
 #include "IntTestMutex.h"
 
-#include "../../ipc/MutexFactory.h"
+#include "../../../ipc/MutexFactory.h"
 #include "../UnittDefinitions.h"
 
 #if defined(hosted)
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index f260b6a51..6d2719d57 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -1,9 +1,9 @@
 #include "IntTestSemaphore.h"
 #include "../UnittDefinitions.h"
 
-#include "../../tasks/SemaphoreFactory.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../timemanager/Stopwatch.h"
+#include "../../../tasks/SemaphoreFactory.h"
+#include "../../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../../timemanager/Stopwatch.h"
 
 
 void testsemaph::testBinSemaph() {
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
index 1e33ff335..793661c5b 100644
--- a/unittest/internal/serialize/IntTestSerialization.cpp
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -1,8 +1,9 @@
 #include "IntTestSerialization.h"
 #include "../UnittDefinitions.h"
-#include "../../serialize/SerializeElement.h"
-#include "../../serialize/SerialBufferAdapter.h"
-#include "../../serialize/SerializeIF.h"
+
+#include "../../../serialize/SerializeElement.h"
+#include "../../../serialize/SerialBufferAdapter.h"
+#include "../../../serialize/SerializeIF.h"
 
 #include <array>
 
diff --git a/unittest/internal/serialize/IntTestSerialization.h b/unittest/internal/serialize/IntTestSerialization.h
index e8dbd35a0..8706e0572 100644
--- a/unittest/internal/serialize/IntTestSerialization.h
+++ b/unittest/internal/serialize/IntTestSerialization.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
 #define FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
 
-#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 #include <array>
 
 namespace testserialize {

From 7ace117c42832ad65d657b2d203f5371fb3ad2a7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:06:09 +0100
Subject: [PATCH 1154/1774] added cmakelistst

---
 globalfunctions/CMakeLists.txt      | 12 ++++++++++++
 globalfunctions/math/CMakeLists.txt |  4 ++++
 2 files changed, 16 insertions(+)
 create mode 100644 globalfunctions/CMakeLists.txt
 create mode 100644 globalfunctions/math/CMakeLists.txt

diff --git a/globalfunctions/CMakeLists.txt b/globalfunctions/CMakeLists.txt
new file mode 100644
index 000000000..2b3dcf8ed
--- /dev/null
+++ b/globalfunctions/CMakeLists.txt
@@ -0,0 +1,12 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		arrayprinter.cpp
+		AsciiConverter.cpp
+		CRC.cpp
+		DleEncoder.cpp
+		PeriodicOperationDivider.cpp
+		timevalOperations.cpp
+		Type.cpp
+)
+
+add_subdirectory(math)
\ No newline at end of file
diff --git a/globalfunctions/math/CMakeLists.txt b/globalfunctions/math/CMakeLists.txt
new file mode 100644
index 000000000..a9c4ded78
--- /dev/null
+++ b/globalfunctions/math/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		QuaternionOperations.cpp
+)

From 073cd4f5e1ebbf1bcc09a3c71ae8da16b6e4ddad Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:09:53 +0100
Subject: [PATCH 1155/1774] small tweaks

---
 globalfunctions/Type.cpp | 2 +-
 globalfunctions/Type.h   | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index 97f38473e..fa6d2f281 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -1,4 +1,4 @@
-#include "../globalfunctions/Type.h"
+#include "Type.h"
 #include "../serialize/SerializeAdapter.h"
 
 Type::Type() :
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 8d03c4677..d28f56ac8 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -1,5 +1,5 @@
-#ifndef TYPE_H_
-#define TYPE_H_
+#ifndef FSFW_GLOBALFUNCTIONS_TYPE_H_
+#define FSFW_GLOBALFUNCTIONS_TYPE_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
@@ -95,4 +95,4 @@ struct PodTypeConversion<double> {
 	static const Type::ActualType_t type = Type::DOUBLE;
 };
 
-#endif /* TYPE_H_ */
+#endif /* FSFW_GLOBALFUNCTIONS_TYPE_H_ */

From dc72fa938d593083b8fb60ff38ea7f9b6d754711 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:10:22 +0100
Subject: [PATCH 1156/1774] type update

---
 globalfunctions/Type.cpp |  1 -
 globalfunctions/Type.h   | 13 ++++++++++---
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index ae595b812..fa6d2f281 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -1,4 +1,3 @@
-#include "../serialize/SerializeAdapter.h"
 #include "Type.h"
 #include "../serialize/SerializeAdapter.h"
 
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index be499ffc6..d28f56ac8 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -1,9 +1,12 @@
-#ifndef TYPE_H_
-#define TYPE_H_
+#ifndef FSFW_GLOBALFUNCTIONS_TYPE_H_
+#define FSFW_GLOBALFUNCTIONS_TYPE_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
 
+/**
+ * @brief 	Type definition for CCSDS or ECSS.
+ */
 class Type: public SerializeIF {
 public:
 	enum ActualType_t {
@@ -56,6 +59,10 @@ struct PodTypeConversion {
 	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
 };
 template<>
+struct PodTypeConversion<bool> {
+    static const Type::ActualType_t type = Type::UINT8_T;
+};
+template<>
 struct PodTypeConversion<uint8_t> {
 	static const Type::ActualType_t type = Type::UINT8_T;
 };
@@ -88,4 +95,4 @@ struct PodTypeConversion<double> {
 	static const Type::ActualType_t type = Type::DOUBLE;
 };
 
-#endif /* TYPE_H_ */
+#endif /* FSFW_GLOBALFUNCTIONS_TYPE_H_ */

From 94fa917202970b0e7ecf516497be87ce8f1727c3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:17:22 +0100
Subject: [PATCH 1157/1774] some tweaks

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      |  8 +++++--
 osal/FreeRTOS/BinSemaphUsingTask.h        | 27 ++++++++++++++++++-----
 osal/FreeRTOS/BinarySemaphore.cpp         |  4 ++--
 osal/FreeRTOS/BinarySemaphore.h           |  6 ++---
 osal/FreeRTOS/Clock.cpp                   | 10 ++++++++-
 osal/FreeRTOS/CountingSemaphUsingTask.cpp |  5 +++--
 osal/FreeRTOS/CountingSemaphUsingTask.h   | 13 ++++++-----
 osal/FreeRTOS/CountingSemaphore.cpp       |  5 +++--
 osal/FreeRTOS/CountingSemaphore.h         |  3 ++-
 osal/FreeRTOS/MessageQueue.cpp            |  7 +++++-
 osal/FreeRTOS/MessageQueue.h              |  3 ++-
 osal/FreeRTOS/MutexFactory.cpp            | 10 +++++----
 osal/FreeRTOS/QueueFactory.cpp            |  4 ++--
 osal/FreeRTOS/TaskFactory.cpp             | 20 ++++++++---------
 osal/FreeRTOS/TaskManagement.cpp          |  2 +-
 osal/FreeRTOS/TaskManagement.h            |  3 +--
 osal/FreeRTOS/Timekeeper.cpp              |  2 +-
 timemanager/Clock.h                       |  6 ++---
 18 files changed, 88 insertions(+), 50 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index dd1e48ca9..9c29948e9 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -1,5 +1,5 @@
-#include "../../osal/FreeRTOS/BinSemaphUsingTask.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "BinSemaphUsingTask.h"
+#include "TaskManagement.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
@@ -16,6 +16,10 @@ BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
 }
 
+void BinarySemaphoreUsingTask::refreshTaskHandle() {
+	handle = TaskManagement::getCurrentTaskHandle();
+}
+
 ReturnValue_t BinarySemaphoreUsingTask::acquire(TimeoutType timeoutType,
         uint32_t timeoutMs) {
     TickType_t timeout = 0;
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index f3c0b0eaf..65a091a3f 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+#ifndef FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+#define FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include "../../tasks/SemaphoreIF.h"
@@ -7,13 +7,20 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
+// todo: does not work for older FreeRTOS version, so we should
+// actually check whether tskKERNEL_VERSION_MAJOR is larger than.. 7 or 8 ?
+
 /**
  * @brief 	Binary Semaphore implementation using the task notification value.
  * 			The notification value should therefore not be used
- * 			for other purposes.
+ * 			for other purposes!
  * @details
  * Additional information: https://www.freertos.org/RTOS-task-notifications.html
  * and general semaphore documentation.
+ * This semaphore is bound to the task it is created in!
+ * Take care of building this class with the correct executing task,
+ * (for example in the initializeAfterTaskCreation() function) or
+ * by calling refreshTaskHandle() with the correct executing task.
  */
 class BinarySemaphoreUsingTask: public SemaphoreIF,
 		public HasReturnvaluesIF {
@@ -25,6 +32,16 @@ public:
 	//! @brief Default dtor
 	virtual~ BinarySemaphoreUsingTask();
 
+	/**
+	 * This function can be used to get the correct task handle from the
+	 * currently executing task.
+	 *
+	 * This is required because the task notification value will be used
+	 * as a binary semaphore, and the semaphore might be created by another
+	 * task.
+	 */
+	void refreshTaskHandle();
+
 	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
 	        uint32_t timeoutMs = portMAX_DELAY) override;
 	ReturnValue_t release() override;
@@ -67,10 +84,10 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
-				BaseType_t * higherPriorityTaskWoken);
+				BaseType_t* higherPriorityTaskWoken);
 
 protected:
 	TaskHandle_t handle;
 };
 
-#endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
+#endif /* FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 8cc3c4957..6fee5c353 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -1,5 +1,5 @@
-#include "../../osal/FreeRTOS/BinarySemaphore.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "BinarySemaphore.h"
+#include "TaskManagement.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 BinarySemaphore::BinarySemaphore() {
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index c6cedc539..8969d5038 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#ifndef FSFW_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FSFW_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include "../../tasks/SemaphoreIF.h"
@@ -104,4 +104,4 @@ protected:
 	SemaphoreHandle_t handle;
 };
 
-#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
+#endif /* FSFW_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index acfa98d7a..d3f4e68e1 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -1,6 +1,7 @@
+#include "Timekeeper.h"
+
 #include "../../timemanager/Clock.h"
 #include "../../globalfunctions/timevalOperations.h"
-#include "Timekeeper.h"
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
@@ -67,6 +68,13 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+//uint32_t Clock::getUptimeSeconds() {
+//	timeval uptime = getUptime();
+//	return uptime.tv_sec;
+//}
+
+
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 	timeval time_timeval;
 	ReturnValue_t result = getClock_timeval(&time_timeval);
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index a47341bcb..17cdf7ce3 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -1,5 +1,6 @@
-#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "CountingSemaphUsingTask.h"
+#include "TaskManagement.h"
+
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 8977258ca..f258197ba 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -1,13 +1,11 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+#ifndef FSFW_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+#define FSFW_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
 
-#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
+#include "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
@@ -16,6 +14,9 @@ extern "C" {
  * @details
  *  Additional information: https://www.freertos.org/RTOS-task-notifications.html
  *  and general semaphore documentation.
+ *  This semaphore is bound to the task it is created in!
+ *  Take care of calling this function with the correct executing task,
+ *  (for example in the initializeAfterTaskCreation() function).
  */
 class CountingSemaphoreUsingTask: public SemaphoreIF {
 public:
@@ -99,4 +100,4 @@ private:
 	const uint8_t maxCount;
 };
 
-#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
+#endif /* FSFW_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index d1310a6ab..a202e4806 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,6 +1,7 @@
-#include "../../osal/FreeRTOS/CountingSemaphore.h"
+#include "CountingSemaphore.h"
+#include "TaskManagement.h"
+
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
 
 #include <freertos/semphr.h>
 
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index ae2f62aee..6af1d6d26 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
 #define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
-#include "../../osal/FreeRTOS/BinarySemaphore.h"
+
+#include "BinarySemaphore.h"
 
 /**
  * @brief 	Counting semaphores, which can be acquire more than once.
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 2dfe5ab65..fdadf8b7d 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -11,7 +11,12 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		maxMessageSize(maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
 	if (handle == nullptr) {
-		sif::error << "MessageQueue::MessageQueue Creation failed" << std::endl;
+		sif::error << "MessageQueue::MessageQueue:"
+		        << " Creation failed." << std::endl;
+		sif::error << "Specified Message Depth: " << messageDepth
+		        << std::endl;
+		sif::error << "Specified Maximum Message Size: "
+		        << maxMessageSize << std::endl;
 	}
 }
 
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index b99bf7c8d..8fa862831 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -1,10 +1,11 @@
 #ifndef FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 #define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 
+#include "TaskManagement.h"
+
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueIF.h"
 #include "../../ipc/MessageQueueMessageIF.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/queue.h>
diff --git a/osal/FreeRTOS/MutexFactory.cpp b/osal/FreeRTOS/MutexFactory.cpp
index 75b63d078..d9569e35d 100644
--- a/osal/FreeRTOS/MutexFactory.cpp
+++ b/osal/FreeRTOS/MutexFactory.cpp
@@ -1,10 +1,12 @@
+#include "Mutex.h"
+
 #include "../../ipc/MutexFactory.h"
 
-#include "../FreeRTOS/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
+//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 = NULL;
+MutexFactory* MutexFactory::factoryInstance = nullptr;
 
 MutexFactory::MutexFactory() {
 }
@@ -13,7 +15,7 @@ MutexFactory::~MutexFactory() {
 }
 
 MutexFactory* MutexFactory::instance() {
-	if (factoryInstance == NULL){
+	if (factoryInstance == nullptr){
 		factoryInstance = new MutexFactory();
 	}
 	return MutexFactory::factoryInstance;
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index ed29e10cf..5b3c73dca 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -1,8 +1,8 @@
-#include "MessageQueue.h"
-
 #include "../../ipc/MessageQueueSenderIF.h"
 #include "../../ipc/QueueFactory.h"
 
+#include "../../osal/FreeRTOS/MessageQueue.h"
+
 
 QueueFactory* QueueFactory::factoryInstance = nullptr;
 
diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 80df38b2f..3ac5cb495 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -13,32 +13,30 @@ TaskFactory::~TaskFactory() {
 TaskFactory* TaskFactory::instance() {
 	return TaskFactory::factoryInstance;
 }
-/***
- * Keep in Mind that you need to call before this vTaskStartScheduler()!
- * High taskPriority_ number means high priority.
- */
+
 PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
 		TaskPriority taskPriority_, TaskStackSize stackSize_,
 		TaskPeriod period_,
 		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return (PeriodicTaskIF*) (new PeriodicTask(name_, taskPriority_, stackSize_,
-			period_, deadLineMissedFunction_));
+	return dynamic_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_,
+			stackSize_, period_, deadLineMissedFunction_));
 }
-/***
+
+/**
  * Keep in Mind that you need to call before this vTaskStartScheduler()!
  */
 FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
 		TaskPriority taskPriority_, TaskStackSize stackSize_,
 		TaskPeriod period_,
 		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return (FixedTimeslotTaskIF*) (new FixedTimeslotTask(name_, taskPriority_,
-			stackSize_, period_, deadLineMissedFunction_));
+	return dynamic_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_,
+			taskPriority_,stackSize_, period_, deadLineMissedFunction_));
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	if (task == NULL) {
+	if (task == nullptr) {
 		//delete self
-		vTaskDelete(NULL);
+		vTaskDelete(nullptr);
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
 		//TODO not implemented
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index b77f12a9e..18572045e 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "TaskManagement.h"
 
 void TaskManagement::vRequestContextSwitchFromTask() {
 	vTaskDelay(0);
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index eb7351859..c6c46f21c 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -3,10 +3,9 @@
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-}
+
 #include <cstdint>
 
 /**
diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index 1031f0c4d..d986d832e 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -1,6 +1,6 @@
 #include "Timekeeper.h"
 
-#include "FreeRTOSConfig.h"
+#include <FreeRTOSConfig.h>
 
 Timekeeper * Timekeeper::myinstance = nullptr;
 
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index bc1123880..d8b06fda5 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_TIMEMANAGER_CLOCK_H_
-#define FRAMEWORK_TIMEMANAGER_CLOCK_H_
+#ifndef FSFW_TIMEMANAGER_CLOCK_H_
+#define FSFW_TIMEMANAGER_CLOCK_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../ipc/MutexHelper.h"
@@ -151,4 +151,4 @@ private:
 };
 
 
-#endif /* FRAMEWORK_TIMEMANAGER_CLOCK_H_ */
+#endif /* FSFW_TIMEMANAGER_CLOCK_H_ */

From 620c9c6ae15008631d506aa57181a11ff5130e52 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:19:05 +0100
Subject: [PATCH 1158/1774] taken over freeRTOS changes

---
 osal/FreeRTOS/BinarySemaphore.cpp         |  4 ++--
 osal/FreeRTOS/BinarySemaphore.h           |  6 +++---
 osal/FreeRTOS/Clock.cpp                   |  3 ++-
 osal/FreeRTOS/CountingSemaphUsingTask.cpp |  5 +++--
 osal/FreeRTOS/CountingSemaphUsingTask.h   | 10 ++++------
 osal/FreeRTOS/CountingSemaphore.cpp       |  5 +++--
 osal/FreeRTOS/CountingSemaphore.h         |  3 ++-
 osal/FreeRTOS/MessageQueue.h              |  3 ++-
 osal/FreeRTOS/Mutex.cpp                   |  2 +-
 osal/FreeRTOS/MutexFactory.cpp            |  4 +++-
 osal/FreeRTOS/TaskManagement.cpp          |  2 +-
 osal/FreeRTOS/TaskManagement.h            |  5 ++---
 osal/FreeRTOS/Timekeeper.cpp              |  4 ++--
 13 files changed, 30 insertions(+), 26 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 8cc3c4957..6fee5c353 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -1,5 +1,5 @@
-#include "../../osal/FreeRTOS/BinarySemaphore.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "BinarySemaphore.h"
+#include "TaskManagement.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 BinarySemaphore::BinarySemaphore() {
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index c6cedc539..8969d5038 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#ifndef FSFW_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FSFW_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include "../../tasks/SemaphoreIF.h"
@@ -104,4 +104,4 @@ protected:
 	SemaphoreHandle_t handle;
 };
 
-#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
+#endif /* FSFW_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index f3d8516a3..d3f4e68e1 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -1,6 +1,7 @@
+#include "Timekeeper.h"
+
 #include "../../timemanager/Clock.h"
 #include "../../globalfunctions/timevalOperations.h"
-#include "../../osal/FreeRTOS/Timekeeper.h"
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index a47341bcb..17cdf7ce3 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -1,5 +1,6 @@
-#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "CountingSemaphUsingTask.h"
+#include "TaskManagement.h"
+
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 49ff3ee54..f258197ba 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -1,13 +1,11 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+#ifndef FSFW_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+#define FSFW_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
 
-#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
+#include "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
@@ -102,4 +100,4 @@ private:
 	const uint8_t maxCount;
 };
 
-#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
+#endif /* FSFW_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index d1310a6ab..a202e4806 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,6 +1,7 @@
-#include "../../osal/FreeRTOS/CountingSemaphore.h"
+#include "CountingSemaphore.h"
+#include "TaskManagement.h"
+
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
 
 #include <freertos/semphr.h>
 
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index ae2f62aee..6af1d6d26 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
 #define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
-#include "../../osal/FreeRTOS/BinarySemaphore.h"
+
+#include "BinarySemaphore.h"
 
 /**
  * @brief 	Counting semaphores, which can be acquire more than once.
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index b99bf7c8d..8fa862831 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -1,10 +1,11 @@
 #ifndef FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 #define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 
+#include "TaskManagement.h"
+
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueIF.h"
 #include "../../ipc/MessageQueueMessageIF.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/queue.h>
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 82f23ff98..9d9638b5f 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/FreeRTOS/Mutex.h"
+#include "Mutex.h"
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
diff --git a/osal/FreeRTOS/MutexFactory.cpp b/osal/FreeRTOS/MutexFactory.cpp
index 1f34cc18f..d9569e35d 100644
--- a/osal/FreeRTOS/MutexFactory.cpp
+++ b/osal/FreeRTOS/MutexFactory.cpp
@@ -1,5 +1,7 @@
+#include "Mutex.h"
+
 #include "../../ipc/MutexFactory.h"
-#include "../../osal/FreeRTOS/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
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index b77f12a9e..18572045e 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "TaskManagement.h"
 
 void TaskManagement::vRequestContextSwitchFromTask() {
 	vTaskDelay(0);
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 4b7fe3eb3..c6c46f21c 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -3,17 +3,16 @@
 
 #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();
+extern "C" void vRequestContextSwitchFromISR();
 
 /*!
  * Used by functions to tell if they are being called from
diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index 836f0b21d..d986d832e 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -1,6 +1,6 @@
-#include "../../osal/FreeRTOS/Timekeeper.h"
+#include "Timekeeper.h"
 
-#include "FreeRTOSConfig.h"
+#include <FreeRTOSConfig.h>
 
 Timekeeper * Timekeeper::myinstance = nullptr;
 

From 313d898aef8dd1f2591892aebbec7daab2be3fad Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:22:44 +0100
Subject: [PATCH 1159/1774] small update

---
 ipc/QueueFactory.h             | 1 +
 osal/FreeRTOS/QueueFactory.cpp | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index 9853d2562..6fc0643e8 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -3,6 +3,7 @@
 
 #include "MessageQueueIF.h"
 #include "MessageQueueMessage.h"
+
 #include <cstdint>
 
 /**
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index 5b3c73dca..ed29e10cf 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -1,8 +1,8 @@
+#include "MessageQueue.h"
+
 #include "../../ipc/MessageQueueSenderIF.h"
 #include "../../ipc/QueueFactory.h"
 
-#include "../../osal/FreeRTOS/MessageQueue.h"
-
 
 QueueFactory* QueueFactory::factoryInstance = nullptr;
 

From 5c6916a07848a8aed3c7ec2fbc8fded1f37f2a08 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:23:23 +0100
Subject: [PATCH 1160/1774] small tweaks

---
 ipc/QueueFactory.h             | 1 +
 osal/FreeRTOS/QueueFactory.cpp | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index 9853d2562..6fc0643e8 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -3,6 +3,7 @@
 
 #include "MessageQueueIF.h"
 #include "MessageQueueMessage.h"
+
 #include <cstdint>
 
 /**
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index 5b3c73dca..ed29e10cf 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -1,8 +1,8 @@
+#include "MessageQueue.h"
+
 #include "../../ipc/MessageQueueSenderIF.h"
 #include "../../ipc/QueueFactory.h"
 
-#include "../../osal/FreeRTOS/MessageQueue.h"
-
 
 QueueFactory* QueueFactory::factoryInstance = nullptr;
 

From 7eeba71619c982fd8f7ca5449cdf3441b42a4ef1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:34:54 +0100
Subject: [PATCH 1161/1774] subsystem update

---
 subsystem/Subsystem.cpp                 |  4 +++-
 subsystem/SubsystemBase.cpp             | 10 +++++-----
 subsystem/modes/ModeDefinitions.h       | 21 +++++++++------------
 subsystem/modes/ModeSequenceMessage.cpp | 25 ++++++-------------------
 subsystem/modes/ModeSequenceMessage.h   | 10 ++++++----
 subsystem/modes/ModeStore.cpp           |  4 +++-
 subsystem/modes/ModeStore.h             |  6 ++++--
 subsystem/modes/ModeStoreIF.h           |  6 ++++--
 8 files changed, 40 insertions(+), 46 deletions(-)

diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 56d47da23..50fc4d05d 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -1,10 +1,12 @@
+#include "Subsystem.h"
+
 #include "../health/HealthMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialArrayListAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../serialize/SerializeElement.h"
 #include "../serialize/SerialLinkedListAdapter.h"
-#include "Subsystem.h"
+
 #include <string>
 
 Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 56ae10628..787d6be12 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -1,13 +1,13 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
 #include "SubsystemBase.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../ipc/QueueFactory.h"
 
 SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
 		Mode_t initialMode, uint16_t commandQueueDepth) :
-		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE), childrenChangedMode(
-		false), commandsOutstanding(0), commandQueue(NULL), healthHelper(this,
-				setObjectId), modeHelper(this), parentId(parent) {
+		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
+		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
+		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
 			CommandMessage::MAX_MESSAGE_SIZE);
 }
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index a865ab0cf..13a780ee0 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -1,22 +1,19 @@
-#ifndef MODEDEFINITIONS_H_
-#define MODEDEFINITIONS_H_
+#ifndef FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_
+#define FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_
 
 #include "../../modes/HasModesIF.h"
 #include "../../objectmanager/SystemObjectIF.h"
 #include "../../serialize/SerializeIF.h"
 #include "../../serialize/SerialLinkedListAdapter.h"
+
 class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
 public:
-	ModeListEntry() :
-			LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0), value4(
-					0) {
+	ModeListEntry(): LinkedElement<ModeListEntry>(this) {}
 
-	}
-
-	uint32_t value1;
-	uint32_t value2;
-	uint8_t value3;
-	uint8_t value4;
+	uint32_t value1 = 0;
+	uint32_t value2 = 0;
+	uint8_t value3 = 0;
+	uint8_t value4 = 0;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			size_t maxSize, Endianness streamEndianness) const {
@@ -149,4 +146,4 @@ public:
 	}
 };
 
-#endif //MODEDEFINITIONS_H_
+#endif /* FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_ */
diff --git a/subsystem/modes/ModeSequenceMessage.cpp b/subsystem/modes/ModeSequenceMessage.cpp
index 33019f58f..7733098e3 100644
--- a/subsystem/modes/ModeSequenceMessage.cpp
+++ b/subsystem/modes/ModeSequenceMessage.cpp
@@ -1,8 +1,7 @@
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
+#include "ModeSequenceMessage.h"
+
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "ModeSequenceMessage.h"
 
 void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
 		Command_t command, Mode_t sequence, store_address_t storeAddress) {
@@ -11,25 +10,12 @@ void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
 	message->setParameter2(sequence);
 }
 
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table, store_address_t storeAddress) {
-//	message->setCommand(command);
-//	message->setParameter(storeAddress.raw);
-//	message->setParameter2(table);
-//}
-
 void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
 		Command_t command, Mode_t sequence) {
 	message->setCommand(command);
 	message->setParameter2(sequence);
 }
 
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table) {
-//	message->setCommand(command);
-//	message->setParameter2(table);
-//}
-
 void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
 		Command_t command, store_address_t storeAddress) {
 	message->setCommand(command);
@@ -63,9 +49,10 @@ void ModeSequenceMessage::clear(CommandMessage *message) {
 	case SEQUENCE_LIST:
 	case TABLE_LIST:
 	case TABLE:
-	case SEQUENCE:{
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore != NULL){
+	case SEQUENCE: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+		        objects::IPC_STORE);
+		if (ipcStore != nullptr){
 			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
 		}
 	}
diff --git a/subsystem/modes/ModeSequenceMessage.h b/subsystem/modes/ModeSequenceMessage.h
index bbf747f14..7852c9848 100644
--- a/subsystem/modes/ModeSequenceMessage.h
+++ b/subsystem/modes/ModeSequenceMessage.h
@@ -1,9 +1,11 @@
-#ifndef MODESEQUENCEMESSAGE_H_
-#define MODESEQUENCEMESSAGE_H_
+#ifndef FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_
+#define FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_
+
+#include "ModeDefinitions.h"
 
 #include "../../ipc/CommandMessage.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "ModeDefinitions.h"
+
 
 class ModeSequenceMessage {
 public:
@@ -45,4 +47,4 @@ private:
 	ModeSequenceMessage();
 };
 
-#endif /* MODESEQUENCEMESSAGE_H_ */
+#endif /* FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_ */
diff --git a/subsystem/modes/ModeStore.cpp b/subsystem/modes/ModeStore.cpp
index 217e177c8..e216a167a 100644
--- a/subsystem/modes/ModeStore.cpp
+++ b/subsystem/modes/ModeStore.cpp
@@ -1,6 +1,8 @@
 #include "ModeStore.h"
 
-#ifdef USE_MODESTORE
+// todo: I think some parts are deprecated. If this is used,  the define
+// USE_MODESTORE could be part of the new FSFWConfig.h file.
+#if FSFW_USE_MODESTORE == 1
 
 ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
 		SystemObject(objectId), store(slots), emptySlot(store.front()) {
diff --git a/subsystem/modes/ModeStore.h b/subsystem/modes/ModeStore.h
index 0bf856a3e..c05086c7d 100644
--- a/subsystem/modes/ModeStore.h
+++ b/subsystem/modes/ModeStore.h
@@ -1,12 +1,14 @@
 #ifndef MODESTORE_H_
 #define MODESTORE_H_
 
-#ifdef USE_MODESTORE
+#include <FSFWConfig.h>
+
+#if FSFW_USE_MODESTORE == 1
 
 #include "../../container/ArrayList.h"
 #include "../../container/SinglyLinkedList.h"
 #include "../../objectmanager/SystemObject.h"
-#include "ModeStoreIF.h"
+#include "../../subsystem/modes/ModeStoreIF.h"
 
 class ModeStore: public ModeStoreIF, public SystemObject {
 public:
diff --git a/subsystem/modes/ModeStoreIF.h b/subsystem/modes/ModeStoreIF.h
index e5cac3b2e..9e76deefc 100644
--- a/subsystem/modes/ModeStoreIF.h
+++ b/subsystem/modes/ModeStoreIF.h
@@ -1,12 +1,14 @@
 #ifndef MODESTOREIF_H_
 #define MODESTOREIF_H_
 
-#ifdef USE_MODESTORE
+#include <FSFWConfig.h>
+
+#if FSFW_USE_MODESTORE == 1
 
 #include "../../container/ArrayList.h"
 #include "../../container/SinglyLinkedList.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
-#include "ModeDefinitions.h"
+#include "../../subsystem/modes/ModeDefinitions.h"
 
 class ModeStoreIF {
 public:

From 252bfa5c3935681ebd4717027eb67ce9dc5fcb0f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:35:45 +0100
Subject: [PATCH 1162/1774] subsystem convergence

---
 subsystem/Subsystem.cpp     | 39 ++++++++++------------
 subsystem/Subsystem.h       | 59 ++++++++++++++++++----------------
 subsystem/SubsystemBase.cpp | 64 ++++++++++++++++++-------------------
 subsystem/SubsystemBase.h   | 27 +++++++++-------
 4 files changed, 96 insertions(+), 93 deletions(-)

diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 50fc4d05d..9712d7d42 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -1,5 +1,4 @@
 #include "Subsystem.h"
-
 #include "../health/HealthMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialArrayListAdapter.h"
@@ -11,21 +10,12 @@
 
 Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
 		uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) :
-		SubsystemBase(setObjectId, parent, 0), isInTransition(false), childrenChangedHealth(
-				false), uptimeStartTable(0), currentTargetTable(), targetMode(
-				0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables(
-				maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore(
-		NULL)
-#ifdef USE_MODESTORE
-,modeStore(NULL)
-#endif
-{
+		SubsystemBase(setObjectId, parent, 0), isInTransition(false),
+		childrenChangedHealth(false), currentTargetTable(),
+		targetSubmode(SUBMODE_NONE), currentSequenceIterator(),
+		modeTables(maxNumberOfTables), modeSequences(maxNumberOfSequences) {}
 
-}
-
-Subsystem::~Subsystem() {
-	//Auto-generated destructor stub
-}
+Subsystem::~Subsystem() {}
 
 ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
 		Mode_t fallbackSequence) {
@@ -351,7 +341,8 @@ ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
 
 	ReturnValue_t result;
 
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
+	//Before initialize() is called, tables must not be checked as the
+	//children are not added yet.
 	//Sequences added before are checked by initialize()
 	if (!preInit) {
 		result = checkSequence(
@@ -397,8 +388,8 @@ ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
 
 	ReturnValue_t result;
 
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
-	//Tables added before are checked by initialize()
+	//Before initialize() is called, tables must not be checked as the children
+	//are not added yet. Tables added before are checked by initialize()
 	if (!preInit) {
 		result = checkTable(
 				HybridIterator<ModeListEntry>(table->front(), table->back()));
@@ -589,12 +580,14 @@ void Subsystem::transitionFailed(ReturnValue_t failureCode,
 	triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter);
 	if (mode == targetMode) {
 		//already tried going back to the current mode
-		//go into fallback mode, also set current mode to fallback mode, so we come here at the next fail
+		//go into fallback mode, also set current mode to fallback mode,
+	    //so we come here at the next fail
 		modeHelper.setForced(true);
 		ReturnValue_t result;
 		if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
 			triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
-			isInTransition = false; //keep still and allow arbitrary mode commands to recover
+			//keep still and allow arbitrary mode commands to recover
+			isInTransition = false;
 			return;
 		}
 		mode = getFallbackSequence(mode);
@@ -658,8 +651,10 @@ void Subsystem::cantKeepMode() {
 
 	modeHelper.setForced(true);
 
-	//already set the mode, so that we do not try to go back in our old mode when the transition fails
+	//already set the mode, so that we do not try to go back in our old mode
+	//when the transition fails
 	mode = getFallbackSequence(mode);
-	//SHOULDDO: We should store submodes for fallback sequence as well, otherwise we should get rid of submodes completely.
+	//SHOULDDO: We should store submodes for fallback sequence as well,
+	//otherwise we should get rid of submodes completely.
 	startTransition(mode, SUBMODE_NONE);
 }
diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index a40b8028d..09d7850ab 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -1,14 +1,19 @@
-#ifndef SUBSYSTEM_H_
-#define SUBSYSTEM_H_
+#ifndef FSFW_SUBSYSTEM_SUBSYSTEM_H_
+#define FSFW_SUBSYSTEM_SUBSYSTEM_H_
+
+#include "SubsystemBase.h"
+#include "modes/ModeDefinitions.h"
 
 #include "../container/FixedArrayList.h"
 #include "../container/FixedMap.h"
 #include "../container/HybridIterator.h"
 #include "../container/SinglyLinkedList.h"
 #include "../serialize/SerialArrayListAdapter.h"
-#include "modes/ModeDefinitions.h"
-#include "SubsystemBase.h"
 
+/**
+ * @brief   TODO: documentation missing
+ * @details
+ */
 class Subsystem: public SubsystemBase, public HasModeSequenceIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM;
@@ -30,8 +35,13 @@ public:
 	static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1);
 	static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2);
 
-
-
+	/**
+	 * TODO: Doc for constructor
+	 * @param setObjectId
+	 * @param parent
+	 * @param maxNumberOfSequences
+	 * @param maxNumberOfTables
+	 */
 	Subsystem(object_id_t setObjectId, object_id_t parent,
 			uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
 	virtual ~Subsystem();
@@ -44,31 +54,27 @@ public:
 
 	void setInitialMode(Mode_t mode);
 
-	virtual ReturnValue_t initialize();
+	virtual ReturnValue_t initialize() override;
 
-	virtual ReturnValue_t checkObjectConnections();
+	virtual ReturnValue_t checkObjectConnections() override;
 
-	virtual MessageQueueId_t getSequenceCommandQueue() const;
+	virtual MessageQueueId_t getSequenceCommandQueue() const override;
 
 	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
+	 * @brief    Checks whether a sequence, identified by a mode.
 	 * @param sequence
 	 * @return
 	 */
 	ReturnValue_t checkSequence(Mode_t sequence);
 
 	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
+	 * @brief   Checks whether a sequence, identified by a mode list iterator
+	 *          and a fallback sequence.
 	 * @param iter
 	 * @return
 	 */
-	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter, Mode_t fallbackSequence);
+	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter,
+	        Mode_t fallbackSequence);
 protected:
 
 	struct EntryPointer {
@@ -92,15 +98,15 @@ protected:
 
 	bool childrenChangedHealth;
 
-	uint32_t uptimeStartTable;
+	uint32_t uptimeStartTable = 0;
 
 	HybridIterator<ModeListEntry> currentTargetTable;
 
-	Mode_t targetMode;
+	Mode_t targetMode = 0;
 
 	Submode_t targetSubmode;
 
-	Mode_t initialMode;
+	Mode_t initialMode = 0;
 
 	HybridIterator<ModeListEntry> currentSequenceIterator;
 
@@ -108,10 +114,10 @@ protected:
 
 	FixedMap<Mode_t, SequenceInfo> modeSequences;
 
-	StorageManagerIF *IPCStore;
+	StorageManagerIF *IPCStore = nullptr;
 
 #ifdef USE_MODESTORE
-	ModeStoreIF *modeStore;
+	ModeStoreIF *modeStore = nullptr;
 #endif
 
 	bool existsModeSequence(Mode_t id);
@@ -124,8 +130,6 @@ protected:
 
 	HybridIterator<ModeListEntry> getCurrentTable();
 
-//	void startSequence(Mode_t sequence);
-
 	/**
 	 * DO NOT USE ON NON EXISTING SEQUENCE
 	 *
@@ -153,7 +157,8 @@ protected:
 
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 
-	void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);
+	void sendSerializablesAsCommandMessage(Command_t command,
+	        SerializeIF **elements, uint8_t count);
 
 	void transitionFailed(ReturnValue_t failureCode, uint32_t parameter);
 
@@ -161,4 +166,4 @@ protected:
 
 };
 
-#endif /* SUBSYSTEM_H_ */
+#endif /* FSFW_SUBSYSTEM_SUBSYSTEM_H_ */
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 787d6be12..f60c88478 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -1,15 +1,15 @@
-#include "SubsystemBase.h"
-
 #include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../subsystem/SubsystemBase.h"
 #include "../ipc/QueueFactory.h"
 
 SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
 		Mode_t initialMode, uint16_t commandQueueDepth) :
 		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
-		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
+		childrenChangedMode(false),
+		commandQueue(QueueFactory::instance()->createMessageQueue(
+		        commandQueueDepth, CommandMessage::MAX_MESSAGE_SIZE)),
 		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
-			CommandMessage::MAX_MESSAGE_SIZE);
 }
 
 SubsystemBase::~SubsystemBase() {
@@ -21,10 +21,11 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
 	ChildInfo info;
 
 	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
-	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
+	// This is a rather ugly hack to have the changedHealth info for all
+	// children available.
 	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
-	if (child == NULL) {
-		if (healthChild == NULL) {
+	if (child == nullptr) {
+		if (healthChild == nullptr) {
 			return CHILD_DOESNT_HAVE_MODES;
 		} else {
 			info.commandQueue = healthChild->getCommandQueue();
@@ -38,14 +39,11 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
 	info.submode = SUBMODE_NONE;
 	info.healthChanged = false;
 
-	std::pair<std::map<object_id_t, ChildInfo>::iterator, bool> returnValue =
-			childrenMap.insert(
-					std::pair<object_id_t, ChildInfo>(objectId, info));
-	if (!(returnValue.second)) {
+	auto resultPair = childrenMap.emplace(objectId, info);
+	if (not resultPair.second) {
 		return COULD_NOT_INSERT_CHILD;
-	} else {
-		return RETURN_OK;
 	}
+	return RETURN_OK;
 }
 
 ReturnValue_t SubsystemBase::checkStateAgainstTable(
@@ -76,15 +74,15 @@ ReturnValue_t SubsystemBase::checkStateAgainstTable(
 	return RETURN_OK;
 }
 
-void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
-
-	CommandMessage message;
+void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
+        Submode_t targetSubmode) {
+	CommandMessage command;
 
 	std::map<object_id_t, ChildInfo>::iterator iter;
 
 	commandsOutstanding = 0;
 
-	for (; tableIter.value != NULL; ++tableIter) {
+	for (; tableIter.value != nullptr; ++tableIter) {
 		object_id_t object = tableIter.value->getObject();
 		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
 			//illegal table entry, should only happen due to misconfigured mode table
@@ -100,17 +98,17 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
 
 		if (healthHelper.healthTable->hasHealth(object)) {
 			if (healthHelper.healthTable->isFaulty(object)) {
-				ModeMessage::setModeMessage(&message,
+				ModeMessage::setModeMessage(&command,
 						ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
 						SUBMODE_NONE);
 			} else {
 				if (modeHelper.isForced()) {
-					ModeMessage::setModeMessage(&message,
+					ModeMessage::setModeMessage(&command,
 							ModeMessage::CMD_MODE_COMMAND_FORCED,
 							tableIter.value->getMode(), submodeToCommand);
 				} else {
 					if (healthHelper.healthTable->isCommandable(object)) {
-						ModeMessage::setModeMessage(&message,
+						ModeMessage::setModeMessage(&command,
 								ModeMessage::CMD_MODE_COMMAND,
 								tableIter.value->getMode(), submodeToCommand);
 					} else {
@@ -119,17 +117,17 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
 				}
 			}
 		} else {
-			ModeMessage::setModeMessage(&message, ModeMessage::CMD_MODE_COMMAND,
+			ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
 					tableIter.value->getMode(), submodeToCommand);
 		}
 
-		if ((iter->second.mode == ModeMessage::getMode(&message))
-				&& (iter->second.submode == ModeMessage::getSubmode(&message))
+		if ((iter->second.mode == ModeMessage::getMode(&command))
+				&& (iter->second.submode == ModeMessage::getSubmode(&command))
 				&& !modeHelper.isForced()) {
 			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
 		}
 		ReturnValue_t result = commandQueue->sendMessage(
-				iter->second.commandQueue, &message);
+				iter->second.commandQueue, &command);
 		if (result == RETURN_OK) {
 			++commandsOutstanding;
 		}
@@ -306,31 +304,31 @@ void SubsystemBase::announceMode(bool recursive) {
 
 void SubsystemBase::checkCommandQueue() {
 	ReturnValue_t result;
-	CommandMessage message;
+	CommandMessage command;
 
-	for (result = commandQueue->receiveMessage(&message); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&message)) {
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
 
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = modeHelper.handleModeCommand(&message);
+		result = modeHelper.handleModeCommand(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = handleModeReply(&message);
+		result = handleModeReply(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = handleCommandMessage(&message);
+		result = handleCommandMessage(&command);
 		if (result != RETURN_OK) {
 			CommandMessage reply;
 			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
-					message.getCommand());
+					command.getCommand());
 			replyToCommand(&reply);
 		}
 	}
diff --git a/subsystem/SubsystemBase.h b/subsystem/SubsystemBase.h
index 61a7eaef1..b8e4f9029 100644
--- a/subsystem/SubsystemBase.h
+++ b/subsystem/SubsystemBase.h
@@ -1,5 +1,7 @@
-#ifndef SUBSYSTEMBASE_H_
-#define SUBSYSTEMBASE_H_
+#ifndef FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_
+#define FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_
+
+#include "modes/HasModeSequenceIF.h"
 
 #include "../container/HybridIterator.h"
 #include "../health/HasHealthIF.h"
@@ -7,11 +9,14 @@
 #include "../modes/HasModesIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "modes/HasModeSequenceIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include <map>
 
+/**
+ * @defgroup subsystems Subsystem Objects
+ * Contains all Subsystem and Assemblies
+ */
 class SubsystemBase: public SystemObject,
 		public HasModesIF,
 		public HasHealthIF,
@@ -30,17 +35,17 @@ public:
 			Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
 	virtual ~SubsystemBase();
 
-	virtual MessageQueueId_t getCommandQueue() const;
+	virtual MessageQueueId_t getCommandQueue() const override;
 
 	ReturnValue_t registerChild(object_id_t objectId);
 
-	virtual ReturnValue_t initialize();
+	virtual ReturnValue_t initialize() override;
 
-	virtual ReturnValue_t performOperation(uint8_t opCode);
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
-	virtual ReturnValue_t setHealth(HealthState health);
+	virtual ReturnValue_t setHealth(HealthState health) override;
 
-	virtual HasHealthIF::HealthState getHealth();
+	virtual HasHealthIF::HealthState getHealth() override;
 
 protected:
 	struct ChildInfo {
@@ -58,9 +63,9 @@ protected:
 	/**
 	 * Always check this against <=0, so you are robust against too many replies
 	 */
-	int32_t commandsOutstanding;
+	int32_t commandsOutstanding = 0;
 
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 
 	HealthHelper healthHelper;
 
@@ -122,4 +127,4 @@ protected:
 	virtual void modeChanged();
 };
 
-#endif /* SUBSYSTEMBASE_H_ */
+#endif /* FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_ */

From e97787cceb7380d78b64d157333672c2a56edde3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:39:19 +0100
Subject: [PATCH 1163/1774] some more tweaks

---
 subsystem/Subsystem.cpp | 12 ++++++------
 subsystem/Subsystem.h   |  4 +++-
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 9712d7d42..4de6906c1 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -367,7 +367,7 @@ ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
 	}
 
 	if (inStore) {
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 		result = modeStore->storeArray(sequence,
 				&(modeSequences.find(id)->entries.firstLinkedElement));
 		if (result != RETURN_OK) {
@@ -410,7 +410,7 @@ ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
 	}
 
 	if (inStore) {
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 		result = modeStore->storeArray(table,
 				&(modeTables.find(id)->firstLinkedElement));
 		if (result != RETURN_OK) {
@@ -440,7 +440,7 @@ ReturnValue_t Subsystem::deleteSequence(Mode_t id) {
 		return ACCESS_DENIED;
 	}
 
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 	modeStore->deleteList(sequenceInfo->entries.firstLinkedElement);
 #endif
 	modeSequences.erase(id);
@@ -463,7 +463,7 @@ ReturnValue_t Subsystem::deleteTable(Mode_t id) {
 		return ACCESS_DENIED;
 	}
 
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 	modeStore->deleteList(pointer->firstLinkedElement);
 #endif
 	modeSequences.erase(id);
@@ -482,10 +482,10 @@ ReturnValue_t Subsystem::initialize() {
 		return RETURN_FAILED;
 	}
 
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 	modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
 
-	if (modeStore == NULL) {
+	if (modeStore == nullptr) {
 		return RETURN_FAILED;
 	}
 #endif
diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index 09d7850ab..c3a72d542 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -10,6 +10,8 @@
 #include "../container/SinglyLinkedList.h"
 #include "../serialize/SerialArrayListAdapter.h"
 
+#include <FSFWConfig.h>
+
 /**
  * @brief   TODO: documentation missing
  * @details
@@ -116,7 +118,7 @@ protected:
 
 	StorageManagerIF *IPCStore = nullptr;
 
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 	ModeStoreIF *modeStore = nullptr;
 #endif
 

From 89de4cc321e32ce94d458d72d76c14999cfd6437 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:40:26 +0100
Subject: [PATCH 1164/1774] changes and tweaks taken over

---
 subsystem/CMakeLists.txt              |  7 +++++++
 subsystem/Subsystem.cpp               | 12 ++++++------
 subsystem/Subsystem.h                 |  4 +++-
 subsystem/modes/CMakeLists.txt        |  5 +++++
 subsystem/modes/ModeSequenceMessage.h |  1 +
 subsystem/modes/ModeStore.cpp         |  4 ++--
 subsystem/modes/ModeStore.h           |  4 +++-
 subsystem/modes/ModeStoreIF.h         |  4 +++-
 8 files changed, 30 insertions(+), 11 deletions(-)
 create mode 100644 subsystem/CMakeLists.txt
 create mode 100644 subsystem/modes/CMakeLists.txt

diff --git a/subsystem/CMakeLists.txt b/subsystem/CMakeLists.txt
new file mode 100644
index 000000000..5c98ee707
--- /dev/null
+++ b/subsystem/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Subsystem.cpp
+		SubsystemBase.cpp
+)
+
+add_subdirectory(modes)
\ No newline at end of file
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 9712d7d42..4de6906c1 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -367,7 +367,7 @@ ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
 	}
 
 	if (inStore) {
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 		result = modeStore->storeArray(sequence,
 				&(modeSequences.find(id)->entries.firstLinkedElement));
 		if (result != RETURN_OK) {
@@ -410,7 +410,7 @@ ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
 	}
 
 	if (inStore) {
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 		result = modeStore->storeArray(table,
 				&(modeTables.find(id)->firstLinkedElement));
 		if (result != RETURN_OK) {
@@ -440,7 +440,7 @@ ReturnValue_t Subsystem::deleteSequence(Mode_t id) {
 		return ACCESS_DENIED;
 	}
 
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 	modeStore->deleteList(sequenceInfo->entries.firstLinkedElement);
 #endif
 	modeSequences.erase(id);
@@ -463,7 +463,7 @@ ReturnValue_t Subsystem::deleteTable(Mode_t id) {
 		return ACCESS_DENIED;
 	}
 
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 	modeStore->deleteList(pointer->firstLinkedElement);
 #endif
 	modeSequences.erase(id);
@@ -482,10 +482,10 @@ ReturnValue_t Subsystem::initialize() {
 		return RETURN_FAILED;
 	}
 
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 	modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
 
-	if (modeStore == NULL) {
+	if (modeStore == nullptr) {
 		return RETURN_FAILED;
 	}
 #endif
diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index 09d7850ab..c3a72d542 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -10,6 +10,8 @@
 #include "../container/SinglyLinkedList.h"
 #include "../serialize/SerialArrayListAdapter.h"
 
+#include <FSFWConfig.h>
+
 /**
  * @brief   TODO: documentation missing
  * @details
@@ -116,7 +118,7 @@ protected:
 
 	StorageManagerIF *IPCStore = nullptr;
 
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 	ModeStoreIF *modeStore = nullptr;
 #endif
 
diff --git a/subsystem/modes/CMakeLists.txt b/subsystem/modes/CMakeLists.txt
new file mode 100644
index 000000000..6ac6a293a
--- /dev/null
+++ b/subsystem/modes/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ModeSequenceMessage.cpp
+		ModeStore.cpp
+)
diff --git a/subsystem/modes/ModeSequenceMessage.h b/subsystem/modes/ModeSequenceMessage.h
index 9be4586e2..7852c9848 100644
--- a/subsystem/modes/ModeSequenceMessage.h
+++ b/subsystem/modes/ModeSequenceMessage.h
@@ -2,6 +2,7 @@
 #define FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_
 
 #include "ModeDefinitions.h"
+
 #include "../../ipc/CommandMessage.h"
 #include "../../storagemanager/StorageManagerIF.h"
 
diff --git a/subsystem/modes/ModeStore.cpp b/subsystem/modes/ModeStore.cpp
index 260e5ab21..e216a167a 100644
--- a/subsystem/modes/ModeStore.cpp
+++ b/subsystem/modes/ModeStore.cpp
@@ -1,8 +1,8 @@
-#include "../../subsystem/modes/ModeStore.h"
+#include "ModeStore.h"
 
 // todo: I think some parts are deprecated. If this is used,  the define
 // USE_MODESTORE could be part of the new FSFWConfig.h file.
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 
 ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
 		SystemObject(objectId), store(slots), emptySlot(store.front()) {
diff --git a/subsystem/modes/ModeStore.h b/subsystem/modes/ModeStore.h
index 3d031cc80..c05086c7d 100644
--- a/subsystem/modes/ModeStore.h
+++ b/subsystem/modes/ModeStore.h
@@ -1,7 +1,9 @@
 #ifndef MODESTORE_H_
 #define MODESTORE_H_
 
-#ifdef USE_MODESTORE
+#include <FSFWConfig.h>
+
+#if FSFW_USE_MODESTORE == 1
 
 #include "../../container/ArrayList.h"
 #include "../../container/SinglyLinkedList.h"
diff --git a/subsystem/modes/ModeStoreIF.h b/subsystem/modes/ModeStoreIF.h
index 30cca1f7b..9e76deefc 100644
--- a/subsystem/modes/ModeStoreIF.h
+++ b/subsystem/modes/ModeStoreIF.h
@@ -1,7 +1,9 @@
 #ifndef MODESTOREIF_H_
 #define MODESTOREIF_H_
 
-#ifdef USE_MODESTORE
+#include <FSFWConfig.h>
+
+#if FSFW_USE_MODESTORE == 1
 
 #include "../../container/ArrayList.h"
 #include "../../container/SinglyLinkedList.h"

From d3239b90644126af99b12dd029d2c19690d2e775 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:41:40 +0100
Subject: [PATCH 1165/1774] tiny format stuff

---
 subsystem/modes/ModeStoreIF.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/subsystem/modes/ModeStoreIF.h b/subsystem/modes/ModeStoreIF.h
index 9e76deefc..9682501d6 100644
--- a/subsystem/modes/ModeStoreIF.h
+++ b/subsystem/modes/ModeStoreIF.h
@@ -5,10 +5,11 @@
 
 #if FSFW_USE_MODESTORE == 1
 
+#include "ModeDefinitions.h"
+
 #include "../../container/ArrayList.h"
 #include "../../container/SinglyLinkedList.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../subsystem/modes/ModeDefinitions.h"
 
 class ModeStoreIF {
 public:

From 5eafd4f353a2dd48fe5f4546a2a17d2bd16ad3f7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:42:02 +0100
Subject: [PATCH 1166/1774] tiny format stuff

---
 subsystem/modes/ModeStoreIF.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/subsystem/modes/ModeStoreIF.h b/subsystem/modes/ModeStoreIF.h
index 9e76deefc..9682501d6 100644
--- a/subsystem/modes/ModeStoreIF.h
+++ b/subsystem/modes/ModeStoreIF.h
@@ -5,10 +5,11 @@
 
 #if FSFW_USE_MODESTORE == 1
 
+#include "ModeDefinitions.h"
+
 #include "../../container/ArrayList.h"
 #include "../../container/SinglyLinkedList.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../subsystem/modes/ModeDefinitions.h"
 
 class ModeStoreIF {
 public:

From 9d5ac16398d1da81116b9ba0df0a3100bf85390d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:43:08 +0100
Subject: [PATCH 1167/1774] some more improvements

---
 subsystem/modes/ModeStore.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/subsystem/modes/ModeStore.h b/subsystem/modes/ModeStore.h
index c05086c7d..a5cb4059c 100644
--- a/subsystem/modes/ModeStore.h
+++ b/subsystem/modes/ModeStore.h
@@ -1,14 +1,15 @@
-#ifndef MODESTORE_H_
-#define MODESTORE_H_
+#ifndef FSFW_SUBSYSTEM_MODES_MODESTORE_H_
+#define FSFW_SUBSYSTEM_MODES_MODESTORE_H_
 
 #include <FSFWConfig.h>
 
 #if FSFW_USE_MODESTORE == 1
 
+#include "ModeStoreIF.h"
+
 #include "../../container/ArrayList.h"
 #include "../../container/SinglyLinkedList.h"
 #include "../../objectmanager/SystemObject.h"
-#include "../../subsystem/modes/ModeStoreIF.h"
 
 class ModeStore: public ModeStoreIF, public SystemObject {
 public:
@@ -43,5 +44,5 @@ private:
 
 #endif
 
-#endif /* MODESTORE_H_ */
+#endif /* FSFW_SUBSYSTEM_MODES_MODESTORE_H_ */
 

From 3dd86039bb01448c57425f1b9d6f9c4135de3622 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:43:32 +0100
Subject: [PATCH 1168/1774] changes taken over

---
 subsystem/modes/ModeStore.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/subsystem/modes/ModeStore.h b/subsystem/modes/ModeStore.h
index c05086c7d..a5cb4059c 100644
--- a/subsystem/modes/ModeStore.h
+++ b/subsystem/modes/ModeStore.h
@@ -1,14 +1,15 @@
-#ifndef MODESTORE_H_
-#define MODESTORE_H_
+#ifndef FSFW_SUBSYSTEM_MODES_MODESTORE_H_
+#define FSFW_SUBSYSTEM_MODES_MODESTORE_H_
 
 #include <FSFWConfig.h>
 
 #if FSFW_USE_MODESTORE == 1
 
+#include "ModeStoreIF.h"
+
 #include "../../container/ArrayList.h"
 #include "../../container/SinglyLinkedList.h"
 #include "../../objectmanager/SystemObject.h"
-#include "../../subsystem/modes/ModeStoreIF.h"
 
 class ModeStore: public ModeStoreIF, public SystemObject {
 public:
@@ -43,5 +44,5 @@ private:
 
 #endif
 
-#endif /* MODESTORE_H_ */
+#endif /* FSFW_SUBSYSTEM_MODES_MODESTORE_H_ */
 

From a547fafa33576ce33423536f28d1fa1333a6423a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:49:01 +0100
Subject: [PATCH 1169/1774] minor tweaks

---
 tasks/CMakeLists.txt        |  5 +++++
 tasks/FixedSlotSequence.h   |  9 +++++++++
 tasks/FixedTimeslotTaskIF.h | 11 ++++++-----
 tasks/TaskFactory.h         | 39 +++++++++++++++++++------------------
 4 files changed, 40 insertions(+), 24 deletions(-)
 create mode 100644 tasks/CMakeLists.txt

diff --git a/tasks/CMakeLists.txt b/tasks/CMakeLists.txt
new file mode 100644
index 000000000..1964bb4e6
--- /dev/null
+++ b/tasks/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		FixedSequenceSlot.cpp
+		FixedSlotSequence.cpp
+)
\ No newline at end of file
diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 19a05f210..077dd10ba 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -139,6 +139,15 @@ public:
 	 */
 	ReturnValue_t checkSequence() const;
 
+	/**
+	 * @brief   A custom check can be injected for the respective slot list.
+	 * @details
+	 * This can be used by the developer to check the validity of a certain
+	 * sequence. The function will be run in the #checkSequence function.
+	 * The general check will be continued for now if the custom check function
+	 * fails but a diagnostic debug output will be given.
+	 * @param customCheckFunction
+	 */
 	void addCustomCheck(ReturnValue_t (*customCheckFunction)(const SlotList &));
 
 	/**
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index 6344efa52..a138db4e2 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -1,12 +1,12 @@
 #ifndef FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
 #define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
 
+#include "PeriodicTaskIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../tasks/PeriodicTaskIF.h"
 
 /**
  * @brief Following the same principle as the base class IF.
- *        This is the interface for a Fixed timeslot task
+ * This is the interface for a Fixed timeslot task
  */
 class FixedTimeslotTaskIF : public PeriodicTaskIF {
 public:
@@ -20,9 +20,8 @@ public:
 	 * @param executionStep
 	 * @return
 	 */
-	virtual ReturnValue_t addSlot(object_id_t componentId,
-			uint32_t slotTimeMs, int8_t executionStep) = 0;
-
+	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+	        int8_t executionStep) = 0;
 	/**
 	 * Check whether the sequence is valid and perform all other required
 	 * initialization steps which are needed after task creation
@@ -30,4 +29,6 @@ public:
 	virtual ReturnValue_t checkSequence() const = 0;
 };
 
+
+
 #endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index fd2f4460d..85cdda900 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -1,9 +1,10 @@
-#ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
-#define FRAMEWORK_TASKS_TASKFACTORY_H_
+#ifndef FSFW_TASKS_TASKFACTORY_H_
+#define FSFW_TASKS_TASKFACTORY_H_
+
+#include "FixedTimeslotTaskIF.h"
+#include "Typedef.h"
 
 #include <cstdlib>
-#include "../tasks/FixedTimeslotTaskIF.h"
-#include "../tasks/Typedef.h"
 
 /**
  * Singleton Class that produces Tasks.
@@ -19,14 +20,13 @@ public:
 	static TaskFactory* instance();
 
 	/**
-	 * Generic interface to create a periodic task
+	 * Creates a new periodic task and returns the interface pointer.
 	 * @param name_ Name of the task
 	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack size if the task
-	 * @param periodInSeconds_ Period in seconds
-	 * @param deadLineMissedFunction_ This function is called if a deadline was
-	 * missed
-	 * @return Pointer to the created periodic task class
+	 * @param stackSize_ Stack Size of the task
+	 * @param period_ Period of the task
+	 * @param deadLineMissedFunction_ Function to be called if a deadline was missed
+	 * @return PeriodicTaskIF* Pointer to the newly created Task
 	 */
 	PeriodicTaskIF* createPeriodicTask(TaskName name_,
 			TaskPriority taskPriority_, TaskStackSize stackSize_,
@@ -34,14 +34,13 @@ public:
 			TaskDeadlineMissedFunction deadLineMissedFunction_);
 
 	/**
-	 * Generic interface to create a fixed timeslot task
+	 *
 	 * @param name_ Name of the task
 	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack size if the task
-	 * @param periodInSeconds_ Period in seconds
-	 * @param deadLineMissedFunction_ This function is called if a deadline was
-	 * missed
-	 * @return Pointer to the created periodic task class
+	 * @param stackSize_ Stack Size of the task
+	 * @param period_ Period of the task
+	 * @param deadLineMissedFunction_ Function to be called if a deadline was missed
+	 * @return FixedTimeslotTaskIF* Pointer to the newly created Task
 	 */
 	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
 			TaskPriority taskPriority_, TaskStackSize stackSize_,
@@ -51,10 +50,10 @@ public:
 	/**
 	 * Function to be called to delete a task
 	 * @param task The pointer to the task that shall be deleted,
-	 * 				NULL specifies current Task
+	 * nullptr specifies current Task
 	 * @return Success of deletion
 	 */
-	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
+	static ReturnValue_t deleteTask(PeriodicTaskIF* task = nullptr);
 
 	/**
 	 * Function to be called to delay current task
@@ -62,12 +61,14 @@ public:
 	 * @return Success of deletion
 	 */
 	static ReturnValue_t delayTask(uint32_t delayMs);
+
 private:
 	/**
 	 * External instantiation is not allowed.
 	 */
 	TaskFactory();
 	static TaskFactory* factoryInstance;
+
 };
 
-#endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */
+#endif /* FSFW_TASKS_TASKFACTORY_H_ */

From d62e092be6c57ccfad63d61cc5dea3e785ddad98 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:49:30 +0100
Subject: [PATCH 1170/1774] task convergence

---
 tasks/FixedTimeslotTaskIF.h | 21 ++++++++++++++++++---
 tasks/TaskFactory.h         | 14 ++++++++------
 2 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index 421978f0d..a138db4e2 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -1,16 +1,31 @@
 #ifndef FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
 #define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
 
-#include "../objectmanager/ObjectManagerIF.h"
 #include "PeriodicTaskIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
 
 /**
- * Following the same principle as the base class IF. This is the interface for a Fixed timeslot task
+ * @brief Following the same principle as the base class IF.
+ * This is the interface for a Fixed timeslot task
  */
 class FixedTimeslotTaskIF : public PeriodicTaskIF {
 public:
 	virtual ~FixedTimeslotTaskIF() {}
-	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep) = 0;
+
+	/**
+	 * Add an object with a slot time and the execution step to the task.
+	 * The execution step shall be passed to the object.
+	 * @param componentId
+	 * @param slotTimeMs
+	 * @param executionStep
+	 * @return
+	 */
+	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+	        int8_t executionStep) = 0;
+	/**
+	 * Check whether the sequence is valid and perform all other required
+	 * initialization steps which are needed after task creation
+	 */
 	virtual ReturnValue_t checkSequence() const = 0;
 };
 
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index cbf2272c3..85cdda900 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -1,10 +1,11 @@
-#ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
-#define FRAMEWORK_TASKS_TASKFACTORY_H_
+#ifndef FSFW_TASKS_TASKFACTORY_H_
+#define FSFW_TASKS_TASKFACTORY_H_
 
-#include <stdlib.h>
 #include "FixedTimeslotTaskIF.h"
 #include "Typedef.h"
 
+#include <cstdlib>
+
 /**
  * Singleton Class that produces Tasks.
  */
@@ -48,10 +49,11 @@ public:
 
 	/**
 	 * Function to be called to delete a task
-	 * @param task The pointer to the task that shall be deleted, NULL specifies current Task
+	 * @param task The pointer to the task that shall be deleted,
+	 * nullptr specifies current Task
 	 * @return Success of deletion
 	 */
-	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
+	static ReturnValue_t deleteTask(PeriodicTaskIF* task = nullptr);
 
 	/**
 	 * Function to be called to delay current task
@@ -69,4 +71,4 @@ private:
 
 };
 
-#endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */
+#endif /* FSFW_TASKS_TASKFACTORY_H_ */

From a0e7584e841f3d9a2469ef091fae79fc55560c7c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 20:19:23 +0100
Subject: [PATCH 1171/1774] tiny tweak

---
 datalinklayer/DataLinkLayer.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datalinklayer/DataLinkLayer.h b/datalinklayer/DataLinkLayer.h
index 30e548e8c..17a57d61d 100644
--- a/datalinklayer/DataLinkLayer.h
+++ b/datalinklayer/DataLinkLayer.h
@@ -23,7 +23,7 @@ public:
 	static const Event RF_LOST = MAKE_EVENT(1, severity::INFO); //!< A previously found RF available signal was lost. P1: raw RFA state, P2: 0
 	static const Event BIT_LOCK = MAKE_EVENT(2, severity::INFO); //!< A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0
 	static const Event BIT_LOCK_LOST = MAKE_EVENT(3, severity::INFO); //!< A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
-//	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, SEVERITY::INFO); //!< The CCSDS Board detected that either bit lock or RF available or both are lost. No parameters.
+//	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, severity::INFO); //!< The CCSDS Board detected that either bit lock or RF available or both are lost. No parameters.
 	static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, severity::LOW); //!< The CCSDS Board could not interpret a TC
 	/**
 	 * The Constructor sets the passed parameters and nothing else.

From 57853ba566eb786b66eaaaf64954bbf2e1d694cb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 20:22:59 +0100
Subject: [PATCH 1172/1774] event update

---
 events/EventManager.cpp |  9 ++++-----
 events/EventManagerIF.h | 22 ++++++++++++++--------
 2 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 3fbe3ee8f..182fb72be 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,7 +1,5 @@
 #include "EventManager.h"
-#include "EventMessage.h"
 #include <FSFWConfig.h>
-
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
@@ -11,6 +9,7 @@
 // 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.
+// This should be configurable..
 const LocalPool::LocalPoolConfig EventManager::poolConfig = {
         {fsfwconfig::FSFW_EVENTMGMR_MATCHTREE_NODES,
         		sizeof(EventMatchTree::Node)},
@@ -43,7 +42,7 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {
 		EventMessage message;
 		result = eventReportQueue->receiveMessage(&message);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
-#ifdef DEBUG
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 			printEvent(&message);
 #endif
 			notifyListeners(&message);
@@ -119,8 +118,8 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
 	switch (message->getSeverity()) {
-	case severity::INFO:
-#ifdef DEBUG_INFO_EVENT
+	case SEVERITY::INFO:
+#if DEBUG_INFO_EVENT == 1
 		string = translateObject(message->getReporter());
 		sif::info << "EVENT: ";
 		if (string != 0) {
diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h
index f9ac420b3..253e6910c 100644
--- a/events/EventManagerIF.h
+++ b/events/EventManagerIF.h
@@ -1,10 +1,11 @@
 #ifndef EVENTMANAGERIF_H_
 #define EVENTMANAGERIF_H_
 
-#include "eventmatching/eventmatching.h"
 #include "EventMessage.h"
+#include "eventmatching/eventmatching.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
+#include "../ipc/MessageQueueIF.h"
 
 class EventManagerIF {
 public:
@@ -16,7 +17,8 @@ public:
 
 	virtual MessageQueueId_t getEventReportQueue() = 0;
 
-	virtual ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false) = 0;
+	virtual ReturnValue_t registerListener(MessageQueueId_t listener,
+	        bool forwardAllButSelected = false) = 0;
 	virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener,
 			EventId_t event) = 0;
 	virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
@@ -31,18 +33,22 @@ public:
 			bool reporterInverted = false) = 0;
 
 	static void triggerEvent(object_id_t reportingObject, Event event,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0, MessageQueueId_t sentFrom = 0) {
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0,
+			MessageQueueId_t sentFrom = 0) {
 		EventMessage message(event, reportingObject, parameter1, parameter2);
 		triggerEvent(&message, sentFrom);
 	}
-	static void triggerEvent(EventMessage* message, MessageQueueId_t sentFrom = 0) {
-		static MessageQueueId_t eventmanagerQueue = 0;
-		if (eventmanagerQueue == 0) {
+
+	static void triggerEvent(EventMessage* message,
+	        MessageQueueId_t sentFrom = 0) {
+		static MessageQueueId_t eventmanagerQueue = MessageQueueIF::NO_QUEUE;
+		if (eventmanagerQueue == MessageQueueIF::NO_QUEUE) {
 			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
 					objects::EVENT_MANAGER);
-			if (eventmanager != NULL) {
-				eventmanagerQueue = eventmanager->getEventReportQueue();
+			if (eventmanager == nullptr) {
+			    return;
 			}
+			eventmanagerQueue = eventmanager->getEventReportQueue();
 		}
 		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
 	}

From 0f6d878d86d3f01b9ee32b5d842e50b77873aba8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 20:48:41 +0100
Subject: [PATCH 1173/1774] update

---
 events/EventManager.cpp |  3 ++-
 events/EventManager.h   | 12 +++++++-----
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 182fb72be..332761419 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,4 +1,6 @@
 #include "EventManager.h"
+#include "EventMessage.h"
+
 #include <FSFWConfig.h>
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../ipc/QueueFactory.h"
@@ -9,7 +11,6 @@
 // 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.
-// This should be configurable..
 const LocalPool::LocalPoolConfig EventManager::poolConfig = {
         {fsfwconfig::FSFW_EVENTMGMR_MATCHTREE_NODES,
         		sizeof(EventMatchTree::Node)},
diff --git a/events/EventManager.h b/events/EventManager.h
index fe35d9d3e..6678fc071 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -1,14 +1,16 @@
-#ifndef EVENTMANAGER_H_
-#define EVENTMANAGER_H_
+#ifndef FSFW_EVENT_EVENTMANAGER_H_
+#define FSFW_EVENT_EVENTMANAGER_H_
 
-#include "eventmatching/EventMatchTree.h"
 #include "EventManagerIF.h"
+#include "eventmatching/EventMatchTree.h"
+
+#include <FSFWConfig.h>
+
 #include "../objectmanager/SystemObject.h"
 #include "../storagemanager/LocalPool.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MutexIF.h"
-#include <FSFWConfig.h>
 
 #include <map>
 
@@ -68,4 +70,4 @@ protected:
 	void unlockMutex();
 };
 
-#endif /* EVENTMANAGER_H_ */
+#endif /* FSFW_EVENT_EVENTMANAGER_H_ */

From 2100ae34f2c69d9a982e1d52d2f8068558daff9b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 20:49:17 +0100
Subject: [PATCH 1174/1774] event folder taken over

---
 events/CMakeLists.txt               |  8 ++++++++
 events/EventManager.cpp             |  3 ++-
 events/EventManager.h               | 12 +++++++-----
 events/eventmatching/CMakeLists.txt |  7 +++++++
 events/fwSubsystemIdRanges.h        |  6 +++---
 5 files changed, 27 insertions(+), 9 deletions(-)
 create mode 100644 events/CMakeLists.txt
 create mode 100644 events/eventmatching/CMakeLists.txt

diff --git a/events/CMakeLists.txt b/events/CMakeLists.txt
new file mode 100644
index 000000000..9e63deb89
--- /dev/null
+++ b/events/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Event.cpp
+		EventManager.cpp
+		EventMessage.cpp
+)
+
+add_subdirectory(eventmatching)
\ No newline at end of file
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 182fb72be..332761419 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,4 +1,6 @@
 #include "EventManager.h"
+#include "EventMessage.h"
+
 #include <FSFWConfig.h>
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../ipc/QueueFactory.h"
@@ -9,7 +11,6 @@
 // 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.
-// This should be configurable..
 const LocalPool::LocalPoolConfig EventManager::poolConfig = {
         {fsfwconfig::FSFW_EVENTMGMR_MATCHTREE_NODES,
         		sizeof(EventMatchTree::Node)},
diff --git a/events/EventManager.h b/events/EventManager.h
index fe35d9d3e..6678fc071 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -1,14 +1,16 @@
-#ifndef EVENTMANAGER_H_
-#define EVENTMANAGER_H_
+#ifndef FSFW_EVENT_EVENTMANAGER_H_
+#define FSFW_EVENT_EVENTMANAGER_H_
 
-#include "eventmatching/EventMatchTree.h"
 #include "EventManagerIF.h"
+#include "eventmatching/EventMatchTree.h"
+
+#include <FSFWConfig.h>
+
 #include "../objectmanager/SystemObject.h"
 #include "../storagemanager/LocalPool.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MutexIF.h"
-#include <FSFWConfig.h>
 
 #include <map>
 
@@ -68,4 +70,4 @@ protected:
 	void unlockMutex();
 };
 
-#endif /* EVENTMANAGER_H_ */
+#endif /* FSFW_EVENT_EVENTMANAGER_H_ */
diff --git a/events/eventmatching/CMakeLists.txt b/events/eventmatching/CMakeLists.txt
new file mode 100644
index 000000000..81ff9ed84
--- /dev/null
+++ b/events/eventmatching/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		EventIdRangeMatcher.cpp
+		EventMatchTree.cpp
+		ReporterRangeMatcher.cpp
+		SeverityRangeMatcher.cpp
+)
\ No newline at end of file
diff --git a/events/fwSubsystemIdRanges.h b/events/fwSubsystemIdRanges.h
index 8dc4def76..1b0b238e2 100644
--- a/events/fwSubsystemIdRanges.h
+++ b/events/fwSubsystemIdRanges.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_EVENTS_FWSUBSYSTEMIDRANGES_H_
-#define FRAMEWORK_EVENTS_FWSUBSYSTEMIDRANGES_H_
+#ifndef FSFW_EVENTS_FWSUBSYSTEMIDRANGES_H_
+#define FSFW_EVENTS_FWSUBSYSTEMIDRANGES_H_
 
 namespace SUBSYSTEM_ID {
 enum {
@@ -27,4 +27,4 @@ enum {
 
 
 
-#endif /* FRAMEWORK_EVENTS_FWSUBSYSTEMIDRANGES_H_ */
+#endif /* FSFW_EVENTS_FWSUBSYSTEMIDRANGES_H_ */

From b14c1c43ccbd97fe774a2a2b9f812487b14afcd3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 20:50:56 +0100
Subject: [PATCH 1175/1774] small fix

---
 events/EventManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 332761419..40c821399 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -119,7 +119,7 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
 	switch (message->getSeverity()) {
-	case SEVERITY::INFO:
+	case severity::INFO:
 #if DEBUG_INFO_EVENT == 1
 		string = translateObject(message->getReporter());
 		sif::info << "EVENT: ";

From 14a0573f3d99025347a40bea9df2633b188d80ea Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 20:58:20 +0100
Subject: [PATCH 1176/1774] one define now

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 2 --
 events/EventManager.cpp            | 2 +-
 events/EventManager.h              | 4 ++--
 unittest/testcfg/FSFWConfig.h      | 4 +---
 4 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 1386bf66f..7e19235cd 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -27,13 +27,11 @@
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
-#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
 #include <translateObjects.h>
 #include <translateEvents.h>
 #else
-#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 40c821399..6cc97eb6c 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -114,7 +114,7 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 	return result;
 }
 
-#if FSFW_DEBUG_OUTPUT == 1
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
diff --git a/events/EventManager.h b/events/EventManager.h
index 6678fc071..c6bd07be8 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -14,7 +14,7 @@
 
 #include <map>
 
-#if FSFW_DEBUG_OUTPUT == 1
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 // forward declaration, should be implemented by mission
 extern const char* translateObject(object_id_t object);
 extern const char* translateEvents(Event event);
@@ -61,7 +61,7 @@ protected:
 
 	void notifyListeners(EventMessage *message);
 
-#if FSFW_DEBUG_OUTPUT == 1
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 	void printEvent(EventMessage *message);
 #endif
 
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 4fb224c15..599345602 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -29,13 +29,11 @@
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiles source files)
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
-#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
-#define FSFW_DEBUG_INFO				1
+#define FSFW_DEBUG_INFO             1
 #include <translateObjects.h>
 #include <translateEvents.h>
 #else
-#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities

From d96d3d6c46c1c8e060f6705c17f0f7489f415385 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 20:58:20 +0100
Subject: [PATCH 1177/1774] one define now

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 2 --
 events/EventManager.cpp            | 2 +-
 events/EventManager.h              | 4 ++--
 unittest/testcfg/FSFWConfig.h      | 4 +---
 4 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 1386bf66f..7e19235cd 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -27,13 +27,11 @@
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
-#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
 #include <translateObjects.h>
 #include <translateEvents.h>
 #else
-#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 332761419..ba31cc588 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -114,7 +114,7 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 	return result;
 }
 
-#if FSFW_DEBUG_OUTPUT == 1
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
diff --git a/events/EventManager.h b/events/EventManager.h
index 6678fc071..c6bd07be8 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -14,7 +14,7 @@
 
 #include <map>
 
-#if FSFW_DEBUG_OUTPUT == 1
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 // forward declaration, should be implemented by mission
 extern const char* translateObject(object_id_t object);
 extern const char* translateEvents(Event event);
@@ -61,7 +61,7 @@ protected:
 
 	void notifyListeners(EventMessage *message);
 
-#if FSFW_DEBUG_OUTPUT == 1
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 	void printEvent(EventMessage *message);
 #endif
 
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 4fb224c15..599345602 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -29,13 +29,11 @@
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiles source files)
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
-#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
-#define FSFW_DEBUG_INFO				1
+#define FSFW_DEBUG_INFO             1
 #include <translateObjects.h>
 #include <translateEvents.h>
 #else
-#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities

From a3ebad46e7335f0b4287f388359f02793062d44b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:00:15 +0100
Subject: [PATCH 1178/1774] small fix

---
 events/EventManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index ba31cc588..6cc97eb6c 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -119,7 +119,7 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
 	switch (message->getSeverity()) {
-	case SEVERITY::INFO:
+	case severity::INFO:
 #if DEBUG_INFO_EVENT == 1
 		string = translateObject(message->getReporter());
 		sif::info << "EVENT: ";

From 050770c184a8a965a856df53aea37ad75f0962ff Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:07:58 +0100
Subject: [PATCH 1179/1774] catch factory fixes

---
 unittest/testcfg/CatchFactory.cpp | 30 +++++++++++++-----------------
 1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/unittest/testcfg/CatchFactory.cpp b/unittest/testcfg/CatchFactory.cpp
index c74a8126d..3177212f4 100644
--- a/unittest/testcfg/CatchFactory.cpp
+++ b/unittest/testcfg/CatchFactory.cpp
@@ -24,31 +24,27 @@ void Factory::produce(void) {
 	setStaticFrameworkObjectIds();
 	new EventManager(objects::EVENT_MANAGER);
 	new HealthTable(objects::HEALTH_TABLE);
-	//new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
 
 	{
-		static constexpr uint8_t NUMBER_OF_POOLS = 5;
-		const uint16_t element_sizes[NUMBER_OF_POOLS] = {16, 32, 64, 128, 1024};
-		const uint16_t n_elements[NUMBER_OF_POOLS] = {100, 50, 25, 15, 5};
-		new PoolManager<NUMBER_OF_POOLS>(objects::TC_STORE, element_sizes,
-				n_elements);
+		PoolManager::LocalPoolConfig poolCfg = {
+		        {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
+		};
+		new PoolManager(objects::TC_STORE, poolCfg);
 	}
 
 	{
-		static constexpr uint8_t NUMBER_OF_POOLS = 5;
-		const uint16_t element_sizes[NUMBER_OF_POOLS] = {16, 32, 64, 128, 1024};
-		const uint16_t n_elements[NUMBER_OF_POOLS] = {100, 50, 25, 15, 5};
-		new PoolManager<NUMBER_OF_POOLS>(objects::TM_STORE, element_sizes,
-				n_elements);
+        PoolManager::LocalPoolConfig poolCfg = {
+                {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
+        };
+		new PoolManager(objects::TM_STORE, poolCfg);
 	}
 
 	{
-		static constexpr uint8_t NUMBER_OF_POOLS = 6;
-		const uint16_t element_sizes[NUMBER_OF_POOLS] = {32, 64, 512,
-				1024, 2048, 4096};
-		const uint16_t n_elements[NUMBER_OF_POOLS] = {200, 100, 50, 25, 15, 5};
-		new PoolManager<NUMBER_OF_POOLS>(objects::IPC_STORE, element_sizes,
-				n_elements);
+        PoolManager::LocalPoolConfig poolCfg = {
+                {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
+        };
+		new PoolManager(objects::IPC_STORE, poolCfg);
 	}
 
 }

From c1a156dde3956be55c96469c98e204d27bb3a0c9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:08:35 +0100
Subject: [PATCH 1180/1774] catch factory in objects folder again

---
 .../testcfg/{ => objects}/CatchFactory.cpp    |  0
 unittest/testcfg/{ => objects}/CatchFactory.h |  0
 unittest/testcfg/objects/Factory.cpp          | 34 -------------------
 unittest/testcfg/objects/Factory.h            | 16 ---------
 4 files changed, 50 deletions(-)
 rename unittest/testcfg/{ => objects}/CatchFactory.cpp (100%)
 rename unittest/testcfg/{ => objects}/CatchFactory.h (100%)
 delete mode 100644 unittest/testcfg/objects/Factory.cpp
 delete mode 100644 unittest/testcfg/objects/Factory.h

diff --git a/unittest/testcfg/CatchFactory.cpp b/unittest/testcfg/objects/CatchFactory.cpp
similarity index 100%
rename from unittest/testcfg/CatchFactory.cpp
rename to unittest/testcfg/objects/CatchFactory.cpp
diff --git a/unittest/testcfg/CatchFactory.h b/unittest/testcfg/objects/CatchFactory.h
similarity index 100%
rename from unittest/testcfg/CatchFactory.h
rename to unittest/testcfg/objects/CatchFactory.h
diff --git a/unittest/testcfg/objects/Factory.cpp b/unittest/testcfg/objects/Factory.cpp
deleted file mode 100644
index e05b7942e..000000000
--- a/unittest/testcfg/objects/Factory.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "Factory.h"
-
-#include <fsfw/events/EventManager.h>
-#include <fsfw/health/HealthTable.h>
-
-#include <fsfw/internalError/InternalErrorReporter.h>
-#include <fsfw/objectmanager/frameworkObjects.h>
-
-/**
- * @brief Produces system objects.
- * @details
- * Build tasks by using SystemObject Interface (Interface).
- * Header files of all tasks must be included
- * Please note that an object has to implement the system object interface
- * if the interface validity is checked or retrieved later by using the
- * get<TargetInterface>(object_id) function from the ObjectManagerIF.
- *
- * Framework objects are created first.
- *
- * @ingroup init
- */
-void Factory::produce(void) {
-	setStaticFrameworkObjectIds();
-	new EventManager(objects::EVENT_MANAGER);
-	new HealthTable(objects::HEALTH_TABLE);
-	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
-
-}
-
-void Factory::setStaticFrameworkObjectIds() {
-
-}
-
-
diff --git a/unittest/testcfg/objects/Factory.h b/unittest/testcfg/objects/Factory.h
deleted file mode 100644
index 84f9207e2..000000000
--- a/unittest/testcfg/objects/Factory.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef FACTORY_H_
-#define FACTORY_H_
-
-#include <fsfw/objectmanager/SystemObjectIF.h>
-
-namespace Factory {
-	/**
-	 * @brief 	Creates all SystemObject elements which are persistent
-	 * 			during execution.
-	 */
-	void produce();
-	void setStaticFrameworkObjectIds();
-
-}
-
-#endif /* FACTORY_H_ */

From 55a663beb20ff5b9435b3dc358e6b869d8353ef8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:14:38 +0100
Subject: [PATCH 1181/1774] unittest update

---
 unittest/testcfg/CatchFactory.cpp             | 60 -------------------
 unittest/testcfg/FSFWConfig.h                 |  4 +-
 unittest/testcfg/objects/CatchFactory.cpp     | 56 +++++++++++++++++
 unittest/testcfg/{ => objects}/CatchFactory.h |  0
 4 files changed, 57 insertions(+), 63 deletions(-)
 delete mode 100644 unittest/testcfg/CatchFactory.cpp
 create mode 100644 unittest/testcfg/objects/CatchFactory.cpp
 rename unittest/testcfg/{ => objects}/CatchFactory.h (100%)

diff --git a/unittest/testcfg/CatchFactory.cpp b/unittest/testcfg/CatchFactory.cpp
deleted file mode 100644
index c74a8126d..000000000
--- a/unittest/testcfg/CatchFactory.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "CatchFactory.h"
-
-#include <fsfw/events/EventManager.h>
-#include <fsfw/health/HealthTable.h>
-
-#include <fsfw/internalError/InternalErrorReporter.h>
-#include <fsfw/objectmanager/frameworkObjects.h>
-#include <fsfw/storagemanager/PoolManager.h>
-
-/**
- * @brief Produces system objects.
- * @details
- * Build tasks by using SystemObject Interface (Interface).
- * Header files of all tasks must be included
- * Please note that an object has to implement the system object interface
- * if the interface validity is checked or retrieved later by using the
- * get<TargetInterface>(object_id) function from the ObjectManagerIF.
- *
- * Framework objects are created first.
- *
- * @ingroup init
- */
-void Factory::produce(void) {
-	setStaticFrameworkObjectIds();
-	new EventManager(objects::EVENT_MANAGER);
-	new HealthTable(objects::HEALTH_TABLE);
-	//new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
-
-	{
-		static constexpr uint8_t NUMBER_OF_POOLS = 5;
-		const uint16_t element_sizes[NUMBER_OF_POOLS] = {16, 32, 64, 128, 1024};
-		const uint16_t n_elements[NUMBER_OF_POOLS] = {100, 50, 25, 15, 5};
-		new PoolManager<NUMBER_OF_POOLS>(objects::TC_STORE, element_sizes,
-				n_elements);
-	}
-
-	{
-		static constexpr uint8_t NUMBER_OF_POOLS = 5;
-		const uint16_t element_sizes[NUMBER_OF_POOLS] = {16, 32, 64, 128, 1024};
-		const uint16_t n_elements[NUMBER_OF_POOLS] = {100, 50, 25, 15, 5};
-		new PoolManager<NUMBER_OF_POOLS>(objects::TM_STORE, element_sizes,
-				n_elements);
-	}
-
-	{
-		static constexpr uint8_t NUMBER_OF_POOLS = 6;
-		const uint16_t element_sizes[NUMBER_OF_POOLS] = {32, 64, 512,
-				1024, 2048, 4096};
-		const uint16_t n_elements[NUMBER_OF_POOLS] = {200, 100, 50, 25, 15, 5};
-		new PoolManager<NUMBER_OF_POOLS>(objects::IPC_STORE, element_sizes,
-				n_elements);
-	}
-
-}
-
-void Factory::setStaticFrameworkObjectIds() {
-
-}
-
-
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 4fb224c15..599345602 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -29,13 +29,11 @@
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiles source files)
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
-#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
-#define FSFW_DEBUG_INFO				1
+#define FSFW_DEBUG_INFO             1
 #include <translateObjects.h>
 #include <translateEvents.h>
 #else
-#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities
diff --git a/unittest/testcfg/objects/CatchFactory.cpp b/unittest/testcfg/objects/CatchFactory.cpp
new file mode 100644
index 000000000..3177212f4
--- /dev/null
+++ b/unittest/testcfg/objects/CatchFactory.cpp
@@ -0,0 +1,56 @@
+#include "CatchFactory.h"
+
+#include <fsfw/events/EventManager.h>
+#include <fsfw/health/HealthTable.h>
+
+#include <fsfw/internalError/InternalErrorReporter.h>
+#include <fsfw/objectmanager/frameworkObjects.h>
+#include <fsfw/storagemanager/PoolManager.h>
+
+/**
+ * @brief Produces system objects.
+ * @details
+ * Build tasks by using SystemObject Interface (Interface).
+ * Header files of all tasks must be included
+ * Please note that an object has to implement the system object interface
+ * if the interface validity is checked or retrieved later by using the
+ * get<TargetInterface>(object_id) function from the ObjectManagerIF.
+ *
+ * Framework objects are created first.
+ *
+ * @ingroup init
+ */
+void Factory::produce(void) {
+	setStaticFrameworkObjectIds();
+	new EventManager(objects::EVENT_MANAGER);
+	new HealthTable(objects::HEALTH_TABLE);
+	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+
+	{
+		PoolManager::LocalPoolConfig poolCfg = {
+		        {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
+		};
+		new PoolManager(objects::TC_STORE, poolCfg);
+	}
+
+	{
+        PoolManager::LocalPoolConfig poolCfg = {
+                {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
+        };
+		new PoolManager(objects::TM_STORE, poolCfg);
+	}
+
+	{
+        PoolManager::LocalPoolConfig poolCfg = {
+                {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
+        };
+		new PoolManager(objects::IPC_STORE, poolCfg);
+	}
+
+}
+
+void Factory::setStaticFrameworkObjectIds() {
+
+}
+
+
diff --git a/unittest/testcfg/CatchFactory.h b/unittest/testcfg/objects/CatchFactory.h
similarity index 100%
rename from unittest/testcfg/CatchFactory.h
rename to unittest/testcfg/objects/CatchFactory.h

From 6911f91744ff1b1022adca763bf8b42c208cff97 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:15:41 +0100
Subject: [PATCH 1182/1774] rtems fixes taken over

---
 osal/rtems/Clock.cpp              | 32 ++++++++++++------------------
 osal/rtems/CpuUsage.cpp           |  2 +-
 osal/rtems/InternalErrorCodes.cpp |  4 ++--
 osal/rtems/MessageQueue.cpp       | 33 +++++++++++++++++--------------
 osal/rtems/MessageQueue.h         | 29 ++++++++++-----------------
 osal/rtems/MultiObjectTask.cpp    |  8 ++++----
 osal/rtems/MultiObjectTask.h      |  2 +-
 osal/rtems/Mutex.cpp              | 11 ++++++-----
 osal/rtems/Mutex.h                |  6 +++---
 osal/rtems/MutexFactory.cpp       |  1 -
 osal/rtems/PollingTask.cpp        | 23 ++++++++++-----------
 osal/rtems/PollingTask.h          |  8 ++++----
 osal/rtems/QueueFactory.cpp       |  9 +++++----
 osal/rtems/RtemsBasic.h           |  6 +++---
 osal/rtems/TaskBase.cpp           |  2 +-
 osal/rtems/TaskBase.h             |  6 +++---
 16 files changed, 86 insertions(+), 96 deletions(-)

diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index eeffd7f33..e5f37ec6a 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -3,7 +3,7 @@
 #include <rtems/score/todimpl.h>
 
 uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
+MutexIF* Clock::timeMutex = nullptr;
 
 uint32_t Clock::getTicksPerSecond(void){
 	rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
@@ -40,7 +40,7 @@ ReturnValue_t Clock::setClock(const timeval* time) {
 	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
 	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
 	//TODO Second parameter is ISR_lock_Context
-	_TOD_Set(&newTime,NULL);
+	_TOD_Set(&newTime,nullptr);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -131,7 +131,7 @@ ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
 
 ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
 	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == NULL) {
+	if (timeMutex == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -157,40 +157,34 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+	MutexHelper helper(timeMutex);
+
 
 	leapSeconds = leapSeconds_;
 
-	result = timeMutex->unlockMutex();
-	return result;
+
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if(timeMutex==NULL){
+	if(timeMutex==nullptr){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+	MutexHelper helper(timeMutex);
 
 	*leapSeconds_ = leapSeconds;
 
-	result = timeMutex->unlockMutex();
-	return result;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex==NULL){
+	if(timeMutex==nullptr){
 		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
+		if (mutexFactory == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
+		if (timeMutex == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index d49de4ad6..6655c69b6 100644
--- a/osal/rtems/CpuUsage.cpp
+++ b/osal/rtems/CpuUsage.cpp
@@ -158,7 +158,7 @@ uint32_t CpuUsage::ThreadData::getSerializedSize() const {
 }
 
 ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
-		int32_t* size, Endianness streamEndianness) {
+		size_t* size, Endianness streamEndianness) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
 			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/osal/rtems/InternalErrorCodes.cpp b/osal/rtems/InternalErrorCodes.cpp
index 9346cf15d..ddf365d5f 100644
--- a/osal/rtems/InternalErrorCodes.cpp
+++ b/osal/rtems/InternalErrorCodes.cpp
@@ -12,8 +12,8 @@ ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
 //		return INVALID_WORKSPACE_ADDRESS;
 	case INTERNAL_ERROR_TOO_LITTLE_WORKSPACE:
 		return TOO_LITTLE_WORKSPACE;
-	case INTERNAL_ERROR_WORKSPACE_ALLOCATION:
-		return WORKSPACE_ALLOCATION;
+//	case INTERNAL_ERROR_WORKSPACE_ALLOCATION:
+//		return WORKSPACE_ALLOCATION;
 //	case INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL:
 //		return INTERRUPT_STACK_TOO_SMALL;
 	case INTERNAL_ERROR_THREAD_EXITTED:
diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index 700db444e..839182a67 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -1,14 +1,15 @@
 #include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../objectmanager/ObjectManagerIF.h"
 #include "MessageQueue.h"
 #include "RtemsBasic.h"
 #include <cstring>
 MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(NULL) {
+		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(nullptr) {
 	rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
 	rtems_status_code status = rtems_message_queue_create(name, message_depth,
 			max_message_size, 0, &(this->id));
 	if (status != RTEMS_SUCCESSFUL) {
-		error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 				<< name << std::dec << " failed with status:"
 				<< (uint32_t) status << std::endl;
 		this->id = 0;
@@ -20,15 +21,15 @@ MessageQueue::~MessageQueue() {
 }
 
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
+		MessageQueueMessageIF* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
 }
 
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
 	if (this->lastPartner != 0) {
 		return sendMessage(this->lastPartner, message, this->getId());
 	} else {
@@ -36,27 +37,29 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	}
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
 	*receivedFrom = this->lastPartner;
 	return status;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	size_t size = 0;
 	rtems_status_code status = rtems_message_queue_receive(id,
-			message->getBuffer(), &(message->messageSize),
+			message->getBuffer(),&size,
 			RTEMS_NO_WAIT, 1);
 	if (status == RTEMS_SUCCESSFUL) {
+		message->setMessageSize(size);
 		this->lastPartner = message->getSender();
 		//Check size of incoming message.
-		if (message->messageSize < message->getMinimumMessageSize()) {
+		if (message->getMessageSize() < message->getMinimumMessageSize()) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	} else {
 		//No message was received. Keep lastPartner anyway, I might send something later.
 		//But still, delete packet content.
-		memset(message->getData(), 0, message->MAX_DATA_SIZE);
+		memset(message->getData(), 0, message->getMaximumMessageSize());
 	}
 	return convertReturnCode(status);
 }
@@ -79,20 +82,20 @@ void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
 }
 
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 
 	message->setSender(sentFrom);
 	rtems_status_code result = rtems_message_queue_send(sendTo,
-			message->getBuffer(), message->messageSize);
+			message->getBuffer(), message->getMessageSize());
 
 	//TODO: Check if we're in ISR.
 	if (result != RTEMS_SUCCESSFUL && !ignoreFault) {
-		if (internalErrorReporter == NULL) {
+		if (internalErrorReporter == nullptr) {
 			internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
 					objects::INTERNAL_ERROR_REPORTER);
 		}
-		if (internalErrorReporter != NULL) {
+		if (internalErrorReporter != nullptr) {
 			internalErrorReporter->queueMessageNotSent();
 		}
 	}
@@ -105,7 +108,7 @@ ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 	return returnCode;
 }
 
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 		MessageQueueId_t sentFrom, bool ignoreFault) {
 	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
 }
diff --git a/osal/rtems/MessageQueue.h b/osal/rtems/MessageQueue.h
index c6fc62d52..342f1e30f 100644
--- a/osal/rtems/MessageQueue.h
+++ b/osal/rtems/MessageQueue.h
@@ -1,14 +1,5 @@
-/**
- *	@file	MessageQueue.h
- *
- *  @date	10/02/2012
- *	@author	Bastian Baetz
- *
- *	@brief	This file contains the definition of the MessageQueue class.
- */
-
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
+#ifndef FSFW_OSAL_RTEMS_MESSAGEQUEUE_H_
+#define FSFW_OSAL_RTEMS_MESSAGEQUEUE_H_
 
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueIF.h"
@@ -60,14 +51,14 @@ public:
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false );
+			MessageQueueMessageIF* message, bool ignoreFault = false );
 	/**
 	 * @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( MessageQueueMessage* message );
+	ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
 	/**
 	 * @brief	This operation sends a message to the last communication partner.
 	 * @details	This operation simplifies answering an incoming message by using the stored
@@ -75,7 +66,7 @@ public:
 	 * 			(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( MessageQueueMessage* message );
+	ReturnValue_t reply( MessageQueueMessageIF* message );
 
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
@@ -84,7 +75,7 @@ public:
 	 * @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(MessageQueueMessage* message,
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom);
 
 	/**
@@ -95,7 +86,7 @@ public:
 	 * 			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(MessageQueueMessage* message);
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
@@ -121,7 +112,7 @@ public:
 	 * 					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, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 	/**
 	 * \brief	The sendToDefault method sends a queue message to the default destination.
 	 * \details	In all other aspects, it works identical to the sendMessage method.
@@ -129,7 +120,7 @@ public:
 	 * \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( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 	/**
 	 * \brief	This method is a simple setter for the default destination.
 	 */
@@ -178,4 +169,4 @@ private:
 	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
 };
 
-#endif /* MESSAGEQUEUE_H_ */
+#endif /* FSFW_OSAL_RTEMS_MESSAGEQUEUE_H_ */
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index 2342c24c2..970d01e1d 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -30,7 +30,7 @@ ReturnValue_t MultiObjectTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
-		error << "ObjectTask::startTask for " << std::hex << this->getId()
+		sif::error << "ObjectTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
 	}
 	switch(status){
@@ -63,8 +63,8 @@ void MultiObjectTask::taskFunctionality() {
 			char nameSpace[8] = { 0 };
 			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
 					nameSpace);
-			error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
-			if (this->deadlineMissedFunc != NULL) {
+			sif::error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
+			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
 		}
@@ -74,7 +74,7 @@ void MultiObjectTask::taskFunctionality() {
 ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
-	if (newObject == NULL) {
+	if (newObject == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
diff --git a/osal/rtems/MultiObjectTask.h b/osal/rtems/MultiObjectTask.h
index 736e79dd1..04d122a3d 100644
--- a/osal/rtems/MultiObjectTask.h
+++ b/osal/rtems/MultiObjectTask.h
@@ -80,7 +80,7 @@ protected:
 	/**
 	 * @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,
+	 * 			So, each may react individually on a timing failure. The pointer may be nullptr,
 	 * 			then nothing happens on missing the deadline. The deadline is equal to the next execution
 	 * 			of the periodic task.
 	 */
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index 9553ac79c..a5ec96358 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -10,7 +10,7 @@ Mutex::Mutex() :
 	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
 			&mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
-		error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
+		sif::error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
 				<< " failed with " << status << std::endl;
 	}
 }
@@ -18,24 +18,25 @@ Mutex::Mutex() :
 Mutex::~Mutex() {
 	rtems_status_code status = rtems_semaphore_delete(mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
-		error << "Mutex: deletion for id " << mutexId
+		sif::error << "Mutex: deletion for id " << mutexId
 				<< " failed with " << status << std::endl;
 	}
 }
 
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType =
         TimeoutType::BLOCKING, uint32_t timeoutMs) {
+	rtems_status_code status = RTEMS_INVALID_ID;
 	if(timeoutMs == MutexIF::TimeoutType::BLOCKING) {
-		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_WAIT, RTEMS_NO_TIMEOUT);
 	}
 	else if(timeoutMs == MutexIF::TimeoutType::POLLING) {
 		timeoutMs = RTEMS_NO_TIMEOUT;
-		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_NO_WAIT, 0);
 	}
 	else {
-		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_WAIT, timeoutMs);
 	}
 
diff --git a/osal/rtems/Mutex.h b/osal/rtems/Mutex.h
index 723682104..4c8613183 100644
--- a/osal/rtems/Mutex.h
+++ b/osal/rtems/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_RTEMS_MUTEX_H_
-#define FRAMEWORK_OSAL_RTEMS_MUTEX_H_
+#ifndef FSFW_OSAL_RTEMS_MUTEX_H_
+#define FSFW_OSAL_RTEMS_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 #include "RtemsBasic.h"
@@ -15,4 +15,4 @@ private:
 	static uint8_t count;
 };
 
-#endif /* OS_RTEMS_MUTEX_H_ */
+#endif /* FSFW_OSAL_RTEMS_MUTEX_H_ */
diff --git a/osal/rtems/MutexFactory.cpp b/osal/rtems/MutexFactory.cpp
index ea5947895..24af5fa95 100644
--- a/osal/rtems/MutexFactory.cpp
+++ b/osal/rtems/MutexFactory.cpp
@@ -2,7 +2,6 @@
 #include "Mutex.h"
 #include "RtemsBasic.h"
 
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
 MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
 
 MutexFactory::MutexFactory() {
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index 04191515b..db7864fea 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -1,5 +1,6 @@
-#include "../../devicehandlers/FixedSequenceSlot.h"
+#include "../../tasks/FixedSequenceSlot.h"
 #include "../../objectmanager/SystemObjectIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
 #include "PollingTask.h"
 #include "RtemsBasic.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
@@ -34,14 +35,14 @@ rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
 	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
 	//The task's functionality is called.
 	originalTask->taskFunctionality();
-	debug << "Polling task " << originalTask->getId()
+	sif::debug << "Polling task " << originalTask->getId()
 			<< " returned from taskFunctionality." << std::endl;
 }
 
 void PollingTask::missedDeadlineCounter() {
 	PollingTask::deadlineMissedCount++;
 	if (PollingTask::deadlineMissedCount % 10 == 0) {
-		error << "PST missed " << PollingTask::deadlineMissedCount
+		sif::error << "PST missed " << PollingTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
 	}
 }
@@ -50,7 +51,7 @@ ReturnValue_t PollingTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
-		error << "PollingTask::startTask for " << std::hex << this->getId()
+		sif::error << "PollingTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
 	}
 	switch(status){
@@ -68,12 +69,13 @@ ReturnValue_t PollingTask::startTask() {
 
 ReturnValue_t PollingTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+	ExecutableObjectIF* object = objectManager->get<ExecutableObjectIF>(componentId);
+	if (object != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, object, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	error << "Component " << std::hex << componentId <<
+	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
@@ -90,11 +92,10 @@ ReturnValue_t PollingTask::checkSequence() const {
 
 void PollingTask::taskFunctionality() {
 	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
-	std::list<FixedSequenceSlot*>::iterator it = pst.current;
+	FixedSlotSequence::SlotListIter it = pst.current;
 
 	//The start time for the first entry is read.
-	rtems_interval interval = RtemsBasic::convertMsToTicks(
-			(*it)->pollingTimeMs);
+	rtems_interval interval = RtemsBasic::convertMsToTicks(it->pollingTimeMs);
 	TaskBase::setAndStartPeriod(interval,&periodId);
 	//The task's "infinite" inner loop is entered.
 	while (1) {
@@ -107,7 +108,7 @@ void PollingTask::taskFunctionality() {
 			//If the deadline was missed, the deadlineMissedFunc is called.
 			rtems_status_code status = TaskBase::restartPeriod(interval,periodId);
 			if (status == RTEMS_TIMEOUT) {
-				if (this->deadlineMissedFunc != NULL) {
+				if (this->deadlineMissedFunc != nullptr) {
 					this->deadlineMissedFunc();
 				}
 			}
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 199c34e71..42deaf09d 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -1,7 +1,7 @@
-#ifndef POLLINGTASK_H_
-#define POLLINGTASK_H_
+#ifndef FSFW_OSAL_RTEMS_POLLINGTASK_H_
+#define FSFW_OSAL_RTEMS_POLLINGTASK_H_
 
-#include "../../devicehandlers/FixedSlotSequence.h"
+#include "../../tasks/FixedSlotSequence.h"
 #include "../../tasks/FixedTimeslotTaskIF.h"
 #include "TaskBase.h"
 
@@ -82,4 +82,4 @@ protected:
 	void taskFunctionality( void );
 };
 
-#endif /* POLLINGTASK_H_ */
+#endif /* FSFW_OSAL_RTEMS_POLLINGTASK_H_ */
diff --git a/osal/rtems/QueueFactory.cpp b/osal/rtems/QueueFactory.cpp
index fce55a0e4..ff5613041 100644
--- a/osal/rtems/QueueFactory.cpp
+++ b/osal/rtems/QueueFactory.cpp
@@ -1,16 +1,17 @@
 #include "../../ipc/QueueFactory.h"
+#include "../../ipc/MessageQueueSenderIF.h"
 #include "MessageQueue.h"
 #include "RtemsBasic.h"
 
-QueueFactory* QueueFactory::factoryInstance = NULL;
+QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,bool ignoreFault) {
 	//TODO add ignoreFault functionality
 	message->setSender(sentFrom);
 	rtems_status_code result = rtems_message_queue_send(sendTo, message->getBuffer(),
-			message->messageSize);
+			message->getMessageSize());
 	switch(result){
 	case RTEMS_SUCCESSFUL:
 			//message sent successfully
@@ -37,7 +38,7 @@ ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
 }
 
 QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == NULL) {
+	if (factoryInstance == nullptr) {
 		factoryInstance = new QueueFactory;
 	}
 	return factoryInstance;
diff --git a/osal/rtems/RtemsBasic.h b/osal/rtems/RtemsBasic.h
index 78e0d46e7..d0ca5abab 100644
--- a/osal/rtems/RtemsBasic.h
+++ b/osal/rtems/RtemsBasic.h
@@ -1,5 +1,5 @@
-#ifndef OS_RTEMS_RTEMSBASIC_H_
-#define OS_RTEMS_RTEMSBASIC_H_
+#ifndef FSFW_OSAL_RTEMS_RTEMSBASIC_H_
+#define FSFW_OSAL_RTEMS_RTEMSBASIC_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include <rtems.h>
@@ -22,4 +22,4 @@ public:
 	}
 };
 
-#endif /* OS_RTEMS_RTEMSBASIC_H_ */
+#endif /* FSFW_OSAL_RTEMS_RTEMSBASIC_H_ */
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index adf6ee707..4e0c8f008 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -22,7 +22,7 @@ TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
 	}
 	ReturnValue_t result = convertReturnCode(status);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-		error << "TaskBase::TaskBase: createTask with name " << std::hex
+		sif::error << "TaskBase::TaskBase: createTask with name " << std::hex
 				<< osalName << std::dec << " failed with return code "
 				<< (uint32_t) status << std::endl;
 		this->id = 0;
diff --git a/osal/rtems/TaskBase.h b/osal/rtems/TaskBase.h
index 410d9110e..0e186e671 100644
--- a/osal/rtems/TaskBase.h
+++ b/osal/rtems/TaskBase.h
@@ -1,5 +1,5 @@
-#ifndef TASKBASE_H_
-#define TASKBASE_H_
+#ifndef FSFW_OSAL_RTEMS_TASKBASE_H_
+#define FSFW_OSAL_RTEMS_TASKBASE_H_
 
 #include "RtemsBasic.h"
 #include "../../tasks/PeriodicTaskIF.h"
@@ -44,4 +44,4 @@ private:
 };
 
 
-#endif /* TASKBASE_H_ */
+#endif /* FSFW_OSAL_RTEMS_TASKBASE_H_ */

From f604d621e8958ebe906f0cc0bf3c77fad775cd41 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:19:12 +0100
Subject: [PATCH 1183/1774] removed interrupt class

---
 osal/rtems/Interrupt.cpp | 86 ----------------------------------------
 osal/rtems/Interrupt.h   | 50 -----------------------
 2 files changed, 136 deletions(-)
 delete mode 100644 osal/rtems/Interrupt.cpp
 delete mode 100644 osal/rtems/Interrupt.h

diff --git a/osal/rtems/Interrupt.cpp b/osal/rtems/Interrupt.cpp
deleted file mode 100644
index b740f1ca7..000000000
--- a/osal/rtems/Interrupt.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "Interrupt.h"
-extern "C" {
-#include <bsp_flp/hw_timer/hw_timer.h>
-#include <bsp_flp/hw_uart/hw_uart.h>
-}
-#include "RtemsBasic.h"
-
-
-ReturnValue_t Interrupt::enableInterrupt(InterruptNumber_t interruptNumber) {
-	volatile uint32_t* irqMask = hw_irq_mask;
-	uint32_t expectedValue = *irqMask | (1 << interruptNumber);
-	*irqMask = expectedValue;
-	uint32_t tempValue = *irqMask;
-	if (tempValue == expectedValue) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Interrupt::setInterruptServiceRoutine(IsrHandler_t handler,
-		InterruptNumber_t interrupt, IsrHandler_t* oldHandler) {
-	IsrHandler_t oldHandler_local;
-	if (oldHandler == NULL) {
-		oldHandler = &oldHandler_local;
-	}
-	//+ 0x10 comes because of trap type assignment to IRQs in UT699 processor
-	rtems_status_code status = rtems_interrupt_catch(handler, interrupt + 0x10,
-			oldHandler);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ISR established successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_INVALID_NUMBER:
-		//illegal vector number
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		//illegal ISR entry point or invalid old_isr_handler
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-}
-
-ReturnValue_t Interrupt::disableInterrupt(InterruptNumber_t interruptNumber) {
-	//TODO Not implemented
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-//SHOULDDO: Make default values (edge, polarity) settable?
-ReturnValue_t Interrupt::enableGpioInterrupt(InterruptNumber_t interrupt) {
-	volatile uint32_t* irqMask = hw_irq_mask;
-	uint32_t expectedValue = *irqMask | (1 << interrupt);
-	*irqMask = expectedValue;
-	uint32_t tempValue = *irqMask;
-	if (tempValue == expectedValue) {
-		volatile hw_gpio_port_t* ioPorts = hw_gpio_port;
-		ioPorts->direction &= ~(1 << interrupt); //Direction In
-		ioPorts->interrupt_edge |= 1 << interrupt; //Edge triggered
-		ioPorts->interrupt_polarity |= 1 << interrupt; //Trigger on rising edge
-		ioPorts->interrupt_mask |= 1 << interrupt; //Enable
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Interrupt::disableGpioInterrupt(InterruptNumber_t interrupt) {
-	volatile uint32_t* irqMask = hw_irq_mask;
-	uint32_t expectedValue = *irqMask & ~(1 << interrupt);
-	*irqMask = expectedValue;
-	uint32_t tempValue = *irqMask;
-	if (tempValue == expectedValue) {
-		//Disable gpio IRQ
-		volatile hw_gpio_port_t* ioPorts = hw_gpio_port;
-		ioPorts->interrupt_mask &= ~(1 << interrupt);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-bool Interrupt::isInterruptInProgress() {
-	return rtems_interrupt_is_in_progress();
-}
diff --git a/osal/rtems/Interrupt.h b/osal/rtems/Interrupt.h
deleted file mode 100644
index 2152e2f03..000000000
--- a/osal/rtems/Interrupt.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef OS_RTEMS_INTERRUPT_H_
-#define OS_RTEMS_INTERRUPT_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include <cstring>
-#include <rtems.h>
-
-typedef rtems_isr_entry IsrHandler_t;
-typedef rtems_isr IsrReturn_t;
-typedef rtems_vector_number InterruptNumber_t;
-
-class Interrupt {
-public:
-	virtual ~Interrupt(){};
-
-	/**
-	 * Establishes a new interrupt service routine.
-	 * @param handler	The service routine to establish
-	 * @param interrupt	The interrupt (NOT trap type) the routine shall react to.
-	 * @return	RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setInterruptServiceRoutine(IsrHandler_t handler,
-			InterruptNumber_t interrupt, IsrHandler_t *oldHandler = NULL);
-	static ReturnValue_t enableInterrupt(InterruptNumber_t interruptNumber);
-	static ReturnValue_t disableInterrupt(InterruptNumber_t interruptNumber);
-	/**
-	 * Enables the interrupt given.
-	 * The function tests, if the InterruptMask register was written successfully.
-	 * @param interrupt The interrupt to enable.
-	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
-	 */
-	static ReturnValue_t enableGpioInterrupt(InterruptNumber_t interrupt);
-	/**
-	 * Disables the interrupt given.
-	 * @param interrupt The interrupt to disable.
-	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
-	 */
-	static ReturnValue_t disableGpioInterrupt(InterruptNumber_t interrupt);
-
-
-	/**
-	 * Checks if the current executing context is an ISR.
-	 * @return true if handling an interrupt, false else.
-	 */
-	static bool isInterruptInProgress();
-
-};
-
-
-#endif /* OS_RTEMS_INTERRUPT_H_ */

From d2f631a955bfd439ac04fcf3d75327e5171a3ca0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:20:21 +0100
Subject: [PATCH 1184/1774] cast added

---
 returnvalues/HasReturnvaluesIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index a39ac7423..4a3835b63 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -24,7 +24,7 @@ public:
 	 */
 	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
 			uint8_t number) {
-	    return (interfaceId << 8) + number;
+	    return (static_cast<ReturnValue_t>(interfaceId) << 8) + number;
 	}
 };
 

From 25db9bc9ed8bb53b211d1e0ea5b46ed6967888c6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:30:39 +0100
Subject: [PATCH 1185/1774] tmtcservices update

---
 pus/servicepackets/Service1Packets.h   |  8 ++---
 tcdistribution/PUSDistributor.cpp      |  4 +--
 tmtcservices/AcceptsTelecommandsIF.h   | 12 +++----
 tmtcservices/AcceptsTelemetryIF.h      |  9 ++---
 tmtcservices/AcceptsVerifyMessageIF.h  |  6 ++--
 tmtcservices/CommandingServiceBase.cpp | 40 +++++++++++-----------
 tmtcservices/CommandingServiceBase.h   | 10 +++---
 tmtcservices/PusServiceBase.cpp        | 47 ++++++++++++++------------
 tmtcservices/PusServiceBase.h          | 13 +++----
 tmtcservices/PusVerificationReport.cpp |  2 +-
 tmtcservices/PusVerificationReport.h   |  2 --
 tmtcservices/ServiceTypes.h            |  8 +----
 tmtcservices/SourceSequenceCounter.h   | 12 ++-----
 tmtcservices/TmTcBridge.cpp            |  8 ++---
 tmtcservices/TmTcBridge.h              | 10 +++---
 tmtcservices/TmTcMessage.cpp           | 11 +++---
 tmtcservices/TmTcMessage.h             | 16 ++++-----
 tmtcservices/VerificationCodes.h       |  2 +-
 18 files changed, 107 insertions(+), 113 deletions(-)

diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index ecb62693c..2249b4b0f 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -49,7 +49,7 @@ public:
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
+		if (failureSubtype == tc_verification::PROGRESS_FAILURE) {
 			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
 			        maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -77,7 +77,7 @@ public:
 		size_t size = 0;
 		size += SerializeAdapter::getSerializedSize(&packetId);
 		size += sizeof(packetSequenceControl);
-		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
+		if(failureSubtype==tc_verification::PROGRESS_FAILURE){
 			size += SerializeAdapter::getSerializedSize(&stepNumber);
 		}
 		size += SerializeAdapter::getSerializedSize(&errorCode);
@@ -131,7 +131,7 @@ public:
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
+		if (subtype == tc_verification::PROGRESS_SUCCESS) {
 			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
 					maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -145,7 +145,7 @@ public:
 		size_t size = 0;
 		size += SerializeAdapter::getSerializedSize(&packetId);
 		size += sizeof(packetSequenceControl);
-		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
+		if(subtype == tc_verification::PROGRESS_SUCCESS){
 			size += SerializeAdapter::getSerializedSize(&stepNumber);
 		}
 		return size;
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index d964202fb..8e5b94cc1 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -77,14 +77,14 @@ ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
 		tcStatus = queueStatus;
 	}
 	if (tcStatus != RETURN_OK) {
-		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
+		this->verifyChannel.sendFailureReport(tc_verification::ACCEPTANCE_FAILURE,
 				currentPacket, tcStatus);
 		// A failed packet is deleted immediately after reporting,
 		// otherwise it will block memory.
 		currentPacket->deletePacket();
 		return RETURN_FAILED;
 	} else {
-		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
+		this->verifyChannel.sendSuccessReport(tc_verification::ACCEPTANCE_SUCCESS,
 				currentPacket);
 		return RETURN_OK;
 	}
diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h
index 76d10a592..bff0e9550 100644
--- a/tmtcservices/AcceptsTelecommandsIF.h
+++ b/tmtcservices/AcceptsTelecommandsIF.h
@@ -1,5 +1,5 @@
-#ifndef ACCEPTSTELECOMMANDSIF_H_
-#define ACCEPTSTELECOMMANDSIF_H_
+#ifndef FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
+#define FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
 
 #include "../ipc/MessageQueueSenderIF.h"
 
@@ -12,7 +12,7 @@
 class AcceptsTelecommandsIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
-	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
 	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
 	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
 	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);
@@ -26,9 +26,9 @@ public:
 	/**
 	 * @brief	Getter for the service id.
 	 * @details	Any receiving service (at least any PUS service) shall have a
-	 * 			service id. If the receiver can handle Telecommands, but for
+	 * 			service ID. If the receiver can handle Telecommands, but for
 	 * 			some reason has no service id, it shall return 0.
-	 * @return	The service id or 0.
+	 * @return	The service ID or 0.
 	 */
 	virtual uint16_t getIdentifier() = 0;
 	/**
@@ -40,4 +40,4 @@ public:
 };
 
 
-#endif /* ACCEPTSTELECOMMANDSIF_H_ */
+#endif /* FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_ */
diff --git a/tmtcservices/AcceptsTelemetryIF.h b/tmtcservices/AcceptsTelemetryIF.h
index 2325dbe08..43173d89b 100644
--- a/tmtcservices/AcceptsTelemetryIF.h
+++ b/tmtcservices/AcceptsTelemetryIF.h
@@ -1,5 +1,5 @@
-#ifndef ACCEPTSTELEMETRYIF_H_
-#define ACCEPTSTELEMETRYIF_H_
+#ifndef FSFW_TMTCSERVICES_ACCEPTSTELEMETRYIF_H_
+#define FSFW_TMTCSERVICES_ACCEPTSTELEMETRYIF_H_
 
 #include "../ipc/MessageQueueSenderIF.h"
 /**
@@ -20,7 +20,8 @@ public:
 	 * 			receiving message queue.
 	 * @return	The telemetry reception message queue id.
 	 */
-	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) = 0;
+	virtual MessageQueueId_t getReportReceptionQueue(
+	        uint8_t virtualChannel = 0) = 0;
 };
 
-#endif /* ACCEPTSTELEMETRYIF_H_ */
+#endif /* FSFW_TMTCSERVICES_ACCEPTSTELEMETRYIF_H_ */
diff --git a/tmtcservices/AcceptsVerifyMessageIF.h b/tmtcservices/AcceptsVerifyMessageIF.h
index c9318ab01..d16def4db 100644
--- a/tmtcservices/AcceptsVerifyMessageIF.h
+++ b/tmtcservices/AcceptsVerifyMessageIF.h
@@ -1,5 +1,5 @@
-#ifndef ACCEPTSVERIFICATIONMESSAGEIF_H_
-#define ACCEPTSVERIFICATIONMESSAGEIF_H_
+#ifndef FSFW_TMTCSERVICES_ACCEPTSVERIFICATIONMESSAGEIF_H_
+#define FSFW_TMTCSERVICES_ACCEPTSVERIFICATIONMESSAGEIF_H_
 
 #include "../ipc/MessageQueueSenderIF.h"
 
@@ -12,4 +12,4 @@ public:
 };
 
 
-#endif /* ACCEPTSVERIFICATIONMESSAGEIF_H_ */
+#endif /* FSFW_TMTCSERVICES_ACCEPTSVERIFICATIONMESSAGEIF_H_ */
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 0ebc3944f..ed765ecc8 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -1,9 +1,9 @@
-#include "../tcdistribution/PUSDistributorIF.h"
 #include "AcceptsTelemetryIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
 #include "CommandingServiceBase.h"
 #include "TmTcMessage.h"
+
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
 #include "../ipc/QueueFactory.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcpacket/pus/TmPacketStored.h"
@@ -149,13 +149,13 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	default:
 		if (isStep) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
+					tc_verification::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					result, ++iter->second.step, failureParameter1,
 					failureParameter2);
 		} else {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
+					tc_verification::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					result, 0, failureParameter1, failureParameter2);
 		}
@@ -184,13 +184,13 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 	if (sendResult == RETURN_OK) {
 		if (isStep and result != NO_STEP_MESSAGE) {
 			verificationReporter.sendSuccessReport(
-					TC_VERIFY::PROGRESS_SUCCESS,
+					tc_verification::PROGRESS_SUCCESS,
 					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
 					iter->second.tcInfo.tcSequenceControl, ++iter->second.step);
 		}
 		else {
 			verificationReporter.sendSuccessReport(
-					TC_VERIFY::COMPLETION_SUCCESS,
+					tc_verification::COMPLETION_SUCCESS,
 					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
 					iter->second.tcInfo.tcSequenceControl, 0);
 			checkAndExecuteFifo(iter);
@@ -200,14 +200,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		if (isStep) {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
+					tc_verification::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId,
 					iter->second.tcInfo.tcSequenceControl, sendResult,
 					++iter->second.step, failureParameter1, failureParameter2);
 		} else {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE,
+					tc_verification::COMPLETION_FAILURE,
 					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
 					iter->second.tcInfo.tcSequenceControl, sendResult, 0,
 					failureParameter1, failureParameter2);
@@ -232,14 +232,14 @@ void CommandingServiceBase::handleRequestQueue() {
 
 		if ((packet.getSubService() == 0)
 				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
+			rejectPacket(tc_verification::START_FAILURE, &packet, INVALID_SUBSERVICE);
 			continue;
 		}
 		result = getMessageQueueAndObject(packet.getSubService(),
 				packet.getApplicationData(), packet.getApplicationDataSize(),
 				&queue, &objectId);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, result);
+			rejectPacket(tc_verification::START_FAILURE, &packet, result);
 			continue;
 		}
 
@@ -250,14 +250,14 @@ void CommandingServiceBase::handleRequestQueue() {
 		if (iter != commandMap.end()) {
 			result = iter->second.fifo.insert(address);
 			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
+				rejectPacket(tc_verification::START_FAILURE, &packet, OBJECT_BUSY);
 			}
 		} else {
 			CommandInfo newInfo; //Info will be set by startExecution if neccessary
 			newInfo.objectId = objectId;
 			result = commandMap.insert(queue, newInfo, &iter);
 			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, BUSY);
+				rejectPacket(tc_verification::START_FAILURE, &packet, BUSY);
 			} else {
 				startExecution(&packet, iter);
 			}
@@ -338,10 +338,10 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 			iter->second.tcInfo.tcPacketId = storedPacket->getPacketId();
 			iter->second.tcInfo.tcSequenceControl =
 					storedPacket->getPacketSequenceControl();
-			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
+			acceptPacket(tc_verification::START_SUCCESS, storedPacket);
 		} else {
 			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			rejectPacket(tc_verification::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
 		break;
@@ -352,18 +352,18 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 					&command);
 		}
 		if (sendResult == RETURN_OK) {
-			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
+			verificationReporter.sendSuccessReport(tc_verification::START_SUCCESS,
 					storedPacket);
-			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
+			acceptPacket(tc_verification::COMPLETION_SUCCESS, storedPacket);
 			checkAndExecuteFifo(iter);
 		} else {
 			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			rejectPacket(tc_verification::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
 		break;
 	default:
-		rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, result);
+		rejectPacket(tc_verification::START_FAILURE, storedPacket, result);
 		checkAndExecuteFifo(iter);
 		break;
 	}
@@ -414,7 +414,7 @@ void CommandingServiceBase::checkTimeout() {
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
 		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
+					tc_verification::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					TIMEOUT);
 			checkAndExecuteFifo(iter);
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 252b69435..3611d7c62 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -1,18 +1,20 @@
 #ifndef FSFW_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
 #define FSFW_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
 
+#include "AcceptsTelecommandsIF.h"
+#include "VerificationReporter.h"
+
 #include "../objectmanager/SystemObject.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
-#include "AcceptsTelecommandsIF.h"
-
-#include "VerificationReporter.h"
 #include "../ipc/CommandMessage.h"
 #include "../container/FixedMap.h"
 #include "../container/FIFO.h"
 #include "../serialize/SerializeIF.h"
 
+#include <FSFWConfig.h>
+
 class TcPacketStored;
 
 namespace Factory{
@@ -40,7 +42,7 @@ class CommandingServiceBase: public SystemObject,
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	// We could make this configurable via preprocessor and the FSFWConfig file.
-	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH = 3;
+	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH = FSFW_CSB_FIFO_DEPTH;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
 
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index d35944a46..cb5a1247c 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -1,9 +1,10 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/PUSDistributorIF.h"
-#include "AcceptsTelemetryIF.h"
 #include "PusServiceBase.h"
+#include "AcceptsTelemetryIF.h"
 #include "PusVerificationReport.h"
 #include "TmTcMessage.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/PUSDistributorIF.h"
 #include "../ipc/QueueFactory.h"
 
 object_id_t PusServiceBase::packetSource = 0;
@@ -41,9 +42,14 @@ void PusServiceBase::handleRequestQueue() {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
 		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
-		//	debug << "PusServiceBase::performOperation: Receiving from MQ ID: "
-		//      << std::hex << this->requestQueue.getId()
-		//      << std::dec << " returned: " << status << std::endl;
+//		if(status != MessageQueueIF::EMPTY) {
+//			sif::debug << "PusServiceBase::performOperation: Receiving from "
+//					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
+//					<< std::setfill('0') << this->requestQueue->getId()
+//					<< std::dec << " returned: " << status << std::setfill(' ')
+//					<<  std::endl;
+//		}
+
 		if (status == RETURN_OK) {
 			this->currentPacket.setStoreAddress(message.getStorageId());
 			//info << "Service " << (uint16_t) this->serviceId <<
@@ -55,11 +61,11 @@ void PusServiceBase::handleRequestQueue() {
 			//    ": handleRequest returned: " << (int)return_code << std::endl;
 			if (result == RETURN_OK) {
 				this->verifyReporter.sendSuccessReport(
-						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
+						tc_verification::COMPLETION_SUCCESS, &this->currentPacket);
 			}
 			else {
 				this->verifyReporter.sendFailureReport(
-						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
+						tc_verification::COMPLETION_FAILURE, &this->currentPacket,
 						result, 0, errorParameter1, errorParameter2);
 			}
 			this->currentPacket.deletePacket();
@@ -74,9 +80,8 @@ void PusServiceBase::handleRequestQueue() {
 		}
 		else {
 			sif::error << "PusServiceBase::performOperation: Service "
-					<< (uint16_t) this->serviceId
-					<< ": Error receiving packet. Code: " << std::hex << status
-					<< std::dec << std::endl;
+					<< this->serviceId << ": Error receiving packet. Code: "
+					<< std::hex << status << std::dec << std::endl;
 		}
 	}
 }
@@ -98,19 +103,17 @@ ReturnValue_t PusServiceBase::initialize() {
 			packetDestination);
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
-	if ((destService != nullptr) && (distributor != nullptr)) {
-		this->requestQueue->setDefaultDestination(
-				destService->getReportReceptionQueue());
-		distributor->registerService(this);
-		return RETURN_OK;
-	}
-	else {
+	if (destService == nullptr or distributor == nullptr) {
 		sif::error << "PusServiceBase::PusServiceBase: Service "
-				<< (uint32_t) this->serviceId << ": Configuration error."
-				<< " Make sure packetSource and packetDestination are defined "
-			       "correctly" << std::endl;
-		return RETURN_FAILED;
+				<< this->serviceId << ": Configuration error. Make sure "
+				<<	"packetSource and packetDestination are defined correctly"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
+	this->requestQueue->setDefaultDestination(
+			destService->getReportReceptionQueue());
+	distributor->registerService(this);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 98d65efbb..4d3d99bc4 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -1,14 +1,15 @@
-#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+#ifndef FSFW_TMTCSERVICES_PUSSERVICEBASE_H_
+#define FSFW_TMTCSERVICES_PUSSERVICEBASE_H_
+
+#include "AcceptsTelecommandsIF.h"
+#include "VerificationCodes.h"
+#include "VerificationReporter.h"
 
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
-#include "AcceptsTelecommandsIF.h"
-#include "VerificationCodes.h"
-#include "VerificationReporter.h"
 #include "../ipc/MessageQueueIF.h"
 
 namespace Factory{
@@ -156,4 +157,4 @@ private:
 	void handleRequestQueue();
 };
 
-#endif /* PUSSERVICEBASE_H_ */
+#endif /* FSFW_TMTCSERVICES_PUSSERVICEBASE_H_ */
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index bfad9ec5e..c64e5feb3 100644
--- a/tmtcservices/PusVerificationReport.cpp
+++ b/tmtcservices/PusVerificationReport.cpp
@@ -1,5 +1,5 @@
 #include "../serialize/SerializeAdapter.h"
-#include "PusVerificationReport.h"
+#include "../tmtcservices/PusVerificationReport.h"
 
 PusVerificationMessage::PusVerificationMessage() {
 }
diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h
index 88954cfd5..9dce95ac7 100644
--- a/tmtcservices/PusVerificationReport.h
+++ b/tmtcservices/PusVerificationReport.h
@@ -7,8 +7,6 @@
 #include "../tmtcpacket/pus/TcPacketBase.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 
-#include <cstdint>
-
 class PusVerificationMessage: public MessageQueueMessage {
 private:
 	struct verifciationMessageContent {
diff --git a/tmtcservices/ServiceTypes.h b/tmtcservices/ServiceTypes.h
index 1f5bff42f..552601f97 100644
--- a/tmtcservices/ServiceTypes.h
+++ b/tmtcservices/ServiceTypes.h
@@ -1,13 +1,7 @@
-/**
- * @file	ServiceTypes.h
- * @brief	This file defines the ServiceTypes class.
- * @date	11.04.2013
- * @author	baetz
- */
-
 #ifndef SERVICETYPES_H_
 #define SERVICETYPES_H_
 
+// SHOULDDO: This is a duplication of existing configuration structures. Delete it?
 namespace SERVICE {
 enum ServiceTypes {
 	TELECOMMAND_VERIFICATION = 1,
diff --git a/tmtcservices/SourceSequenceCounter.h b/tmtcservices/SourceSequenceCounter.h
index 1cc587587..2b30a53f2 100644
--- a/tmtcservices/SourceSequenceCounter.h
+++ b/tmtcservices/SourceSequenceCounter.h
@@ -1,12 +1,6 @@
-/**
- * @file	SourceSequenceCounter.h
- * @brief	This file defines the SourceSequenceCounter class.
- * @date	04.02.2013
- * @author	baetz
- */
+#ifndef FSFW_TMTCSERVICES_SOURCESEQUENCECOUNTER_H_
+#define FSFW_TMTCSERVICES_SOURCESEQUENCECOUNTER_H_
 
-#ifndef SOURCESEQUENCECOUNTER_H_
-#define SOURCESEQUENCECOUNTER_H_
 #include "../tmtcpacket/SpacePacketBase.h"
 
 class SourceSequenceCounter {
@@ -27,4 +21,4 @@ public:
 };
 
 
-#endif /* SOURCESEQUENCECOUNTER_H_ */
+#endif /* FSFW_TMTCSERVICES_SOURCESEQUENCECOUNTER_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 8c2f15e5b..b4e9967bf 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -1,7 +1,6 @@
-#include "../tmtcservices/TmTcBridge.h"
+#include "TmTcBridge.h"
 
 #include "../ipc/QueueFactory.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../globalfunctions/arrayprinter.h"
 
@@ -95,8 +94,9 @@ ReturnValue_t TmTcBridge::handleTm() {
     ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
-		sif::error << "TmTcBridge::handleTm: Error handling TM queue!"
-		        << std::endl;
+		sif::error << "TmTcBridge::handleTm: Error handling TM queue with "
+		       << "error code 0x" << std::hex << result  << std::dec
+			   << "!" << std::endl;
 		status = result;
 	}
 
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 62cfdaac6..0177648c0 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
-#define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
+#ifndef FSFW_TMTCSERVICES_TMTCBRIDGE_H_
+#define FSFW_TMTCSERVICES_TMTCBRIDGE_H_
 
+#include "AcceptsTelemetryIF.h"
+#include "AcceptsTelecommandsIF.h"
 
 #include "../objectmanager/SystemObject.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../container/DynamicFIFO.h"
 #include "../tmtcservices/TmTcMessage.h"
 
@@ -159,4 +159,4 @@ protected:
 };
 
 
-#endif /* FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ */
+#endif /* FSFW_TMTCSERVICES_TMTCBRIDGE_H_ */
diff --git a/tmtcservices/TmTcMessage.cpp b/tmtcservices/TmTcMessage.cpp
index 987bd2321..ae0283158 100644
--- a/tmtcservices/TmTcMessage.cpp
+++ b/tmtcservices/TmTcMessage.cpp
@@ -1,5 +1,6 @@
 #include "TmTcMessage.h"
-#include <string.h>
+
+#include <cstring>
 
 
 TmTcMessage::TmTcMessage() {
@@ -15,15 +16,15 @@ store_address_t TmTcMessage::getStorageId() {
 	return temp_id;
 }
 
-TmTcMessage::TmTcMessage(store_address_t store_id) {
+TmTcMessage::TmTcMessage(store_address_t storeId) {
 	this->messageSize += sizeof(store_address_t);
-	this->setStorageId(store_id);
+	this->setStorageId(storeId);
 }
 
 size_t TmTcMessage::getMinimumMessageSize() {
 	return this->HEADER_SIZE + sizeof(store_address_t);
 }
 
-void TmTcMessage::setStorageId(store_address_t store_id) {
-	memcpy(this->getData(), &store_id, sizeof(store_address_t) );
+void TmTcMessage::setStorageId(store_address_t storeId) {
+	memcpy(this->getData(), &storeId, sizeof(store_address_t) );
 }
diff --git a/tmtcservices/TmTcMessage.h b/tmtcservices/TmTcMessage.h
index b5e1ff8d4..41fe198a9 100644
--- a/tmtcservices/TmTcMessage.h
+++ b/tmtcservices/TmTcMessage.h
@@ -1,5 +1,5 @@
-#ifndef TMTCMESSAGE_H_
-#define TMTCMESSAGE_H_
+#ifndef FSFW_TMTCSERVICES_TMTCMESSAGE_H_
+#define FSFW_TMTCSERVICES_TMTCMESSAGE_H_
 
 #include "../ipc/MessageQueueMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
@@ -10,13 +10,13 @@
  * 			a packet stored in one of the IPC stores (typically a special TM and
  * 			a special TC store). This makes passing commands very simple and
  * 			efficient.
- *	\ingroup message_queue
+ * @ingroup message_queue
  */
 class TmTcMessage : public MessageQueueMessage {
 protected:
 	/**
 	 * @brief	This call always returns the same fixed size of the message.
-	 * @return	Returns HEADER_SIZE + \c sizeof(store_address_t).
+	 * @return	Returns HEADER_SIZE + @c sizeof(store_address_t).
 	 */
 	size_t getMinimumMessageSize();
 public:
@@ -29,7 +29,7 @@ public:
 	 * 			into the message.
 	 * @param packet_id	The packet id to put into the message.
 	 */
-	TmTcMessage( store_address_t packet_id );
+	TmTcMessage( store_address_t packetId );
 	/**
 	 * @brief	The class's destructor is empty.
 	 */
@@ -42,9 +42,9 @@ public:
 	/**
 	 * @brief	In some cases it might be useful to have a setter for packet id
 	 * 			as well.
-	 * @param packet_id	The packet id to put into the message.
+	 * @param packetId	The packet id to put into the message.
 	 */
-	void setStorageId( store_address_t packet_id );
+	void setStorageId( store_address_t packetId );
 };
 
-#endif /* TMTCMESSAGE_H_ */
+#endif /* FSFW_TMTCSERVICES_TMTCMESSAGE_H_ */
diff --git a/tmtcservices/VerificationCodes.h b/tmtcservices/VerificationCodes.h
index e3e89b5a0..35ad6819e 100644
--- a/tmtcservices/VerificationCodes.h
+++ b/tmtcservices/VerificationCodes.h
@@ -1,7 +1,7 @@
 #ifndef VERIFICATIONCODES_H_
 #define VERIFICATIONCODES_H_
 
-namespace TC_VERIFY {
+namespace tc_verification {
 
 enum verification_flags {
 	NONE = 0b0000,

From 8c88255873283ea51cbe02f6bf9c3c36900e567c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:31:50 +0100
Subject: [PATCH 1186/1774] taken over some tweaks

---
 tmtcservices/AcceptsTelemetryIF.h      |  9 +++---
 tmtcservices/AcceptsVerifyMessageIF.h  |  6 ++--
 tmtcservices/CMakeLists.txt            |  9 ++++++
 tmtcservices/CommandingServiceBase.cpp | 40 +++++++++++++-------------
 tmtcservices/PusServiceBase.cpp        | 13 +++++----
 tmtcservices/PusServiceBase.h          | 13 +++++----
 tmtcservices/PusVerificationReport.cpp | 25 ----------------
 tmtcservices/ServiceTypes.h            |  8 +-----
 tmtcservices/SourceSequenceCounter.h   | 12 ++------
 tmtcservices/TmTcBridge.cpp            |  3 +-
 tmtcservices/TmTcBridge.h              | 10 +++----
 tmtcservices/TmTcMessage.cpp           |  5 ++--
 tmtcservices/VerificationCodes.h       |  2 +-
 13 files changed, 65 insertions(+), 90 deletions(-)
 create mode 100644 tmtcservices/CMakeLists.txt

diff --git a/tmtcservices/AcceptsTelemetryIF.h b/tmtcservices/AcceptsTelemetryIF.h
index 2325dbe08..43173d89b 100644
--- a/tmtcservices/AcceptsTelemetryIF.h
+++ b/tmtcservices/AcceptsTelemetryIF.h
@@ -1,5 +1,5 @@
-#ifndef ACCEPTSTELEMETRYIF_H_
-#define ACCEPTSTELEMETRYIF_H_
+#ifndef FSFW_TMTCSERVICES_ACCEPTSTELEMETRYIF_H_
+#define FSFW_TMTCSERVICES_ACCEPTSTELEMETRYIF_H_
 
 #include "../ipc/MessageQueueSenderIF.h"
 /**
@@ -20,7 +20,8 @@ public:
 	 * 			receiving message queue.
 	 * @return	The telemetry reception message queue id.
 	 */
-	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) = 0;
+	virtual MessageQueueId_t getReportReceptionQueue(
+	        uint8_t virtualChannel = 0) = 0;
 };
 
-#endif /* ACCEPTSTELEMETRYIF_H_ */
+#endif /* FSFW_TMTCSERVICES_ACCEPTSTELEMETRYIF_H_ */
diff --git a/tmtcservices/AcceptsVerifyMessageIF.h b/tmtcservices/AcceptsVerifyMessageIF.h
index c9318ab01..d16def4db 100644
--- a/tmtcservices/AcceptsVerifyMessageIF.h
+++ b/tmtcservices/AcceptsVerifyMessageIF.h
@@ -1,5 +1,5 @@
-#ifndef ACCEPTSVERIFICATIONMESSAGEIF_H_
-#define ACCEPTSVERIFICATIONMESSAGEIF_H_
+#ifndef FSFW_TMTCSERVICES_ACCEPTSVERIFICATIONMESSAGEIF_H_
+#define FSFW_TMTCSERVICES_ACCEPTSVERIFICATIONMESSAGEIF_H_
 
 #include "../ipc/MessageQueueSenderIF.h"
 
@@ -12,4 +12,4 @@ public:
 };
 
 
-#endif /* ACCEPTSVERIFICATIONMESSAGEIF_H_ */
+#endif /* FSFW_TMTCSERVICES_ACCEPTSVERIFICATIONMESSAGEIF_H_ */
diff --git a/tmtcservices/CMakeLists.txt b/tmtcservices/CMakeLists.txt
new file mode 100644
index 000000000..c30af214f
--- /dev/null
+++ b/tmtcservices/CMakeLists.txt
@@ -0,0 +1,9 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CommandingServiceBase.cpp
+		PusServiceBase.cpp
+		PusVerificationReport.cpp
+		TmTcBridge.cpp
+		TmTcMessage.cpp
+		VerificationReporter.cpp
+)
\ No newline at end of file
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 0ebc3944f..ed765ecc8 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -1,9 +1,9 @@
-#include "../tcdistribution/PUSDistributorIF.h"
 #include "AcceptsTelemetryIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
 #include "CommandingServiceBase.h"
 #include "TmTcMessage.h"
+
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
 #include "../ipc/QueueFactory.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcpacket/pus/TmPacketStored.h"
@@ -149,13 +149,13 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	default:
 		if (isStep) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
+					tc_verification::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					result, ++iter->second.step, failureParameter1,
 					failureParameter2);
 		} else {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
+					tc_verification::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					result, 0, failureParameter1, failureParameter2);
 		}
@@ -184,13 +184,13 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 	if (sendResult == RETURN_OK) {
 		if (isStep and result != NO_STEP_MESSAGE) {
 			verificationReporter.sendSuccessReport(
-					TC_VERIFY::PROGRESS_SUCCESS,
+					tc_verification::PROGRESS_SUCCESS,
 					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
 					iter->second.tcInfo.tcSequenceControl, ++iter->second.step);
 		}
 		else {
 			verificationReporter.sendSuccessReport(
-					TC_VERIFY::COMPLETION_SUCCESS,
+					tc_verification::COMPLETION_SUCCESS,
 					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
 					iter->second.tcInfo.tcSequenceControl, 0);
 			checkAndExecuteFifo(iter);
@@ -200,14 +200,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		if (isStep) {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
+					tc_verification::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId,
 					iter->second.tcInfo.tcSequenceControl, sendResult,
 					++iter->second.step, failureParameter1, failureParameter2);
 		} else {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE,
+					tc_verification::COMPLETION_FAILURE,
 					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
 					iter->second.tcInfo.tcSequenceControl, sendResult, 0,
 					failureParameter1, failureParameter2);
@@ -232,14 +232,14 @@ void CommandingServiceBase::handleRequestQueue() {
 
 		if ((packet.getSubService() == 0)
 				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
+			rejectPacket(tc_verification::START_FAILURE, &packet, INVALID_SUBSERVICE);
 			continue;
 		}
 		result = getMessageQueueAndObject(packet.getSubService(),
 				packet.getApplicationData(), packet.getApplicationDataSize(),
 				&queue, &objectId);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, result);
+			rejectPacket(tc_verification::START_FAILURE, &packet, result);
 			continue;
 		}
 
@@ -250,14 +250,14 @@ void CommandingServiceBase::handleRequestQueue() {
 		if (iter != commandMap.end()) {
 			result = iter->second.fifo.insert(address);
 			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
+				rejectPacket(tc_verification::START_FAILURE, &packet, OBJECT_BUSY);
 			}
 		} else {
 			CommandInfo newInfo; //Info will be set by startExecution if neccessary
 			newInfo.objectId = objectId;
 			result = commandMap.insert(queue, newInfo, &iter);
 			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, BUSY);
+				rejectPacket(tc_verification::START_FAILURE, &packet, BUSY);
 			} else {
 				startExecution(&packet, iter);
 			}
@@ -338,10 +338,10 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 			iter->second.tcInfo.tcPacketId = storedPacket->getPacketId();
 			iter->second.tcInfo.tcSequenceControl =
 					storedPacket->getPacketSequenceControl();
-			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
+			acceptPacket(tc_verification::START_SUCCESS, storedPacket);
 		} else {
 			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			rejectPacket(tc_verification::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
 		break;
@@ -352,18 +352,18 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 					&command);
 		}
 		if (sendResult == RETURN_OK) {
-			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
+			verificationReporter.sendSuccessReport(tc_verification::START_SUCCESS,
 					storedPacket);
-			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
+			acceptPacket(tc_verification::COMPLETION_SUCCESS, storedPacket);
 			checkAndExecuteFifo(iter);
 		} else {
 			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			rejectPacket(tc_verification::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
 		break;
 	default:
-		rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, result);
+		rejectPacket(tc_verification::START_FAILURE, storedPacket, result);
 		checkAndExecuteFifo(iter);
 		break;
 	}
@@ -414,7 +414,7 @@ void CommandingServiceBase::checkTimeout() {
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
 		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
+					tc_verification::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					TIMEOUT);
 			checkAndExecuteFifo(iter);
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index 9d4aabd96..cb5a1247c 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -1,9 +1,10 @@
+#include "PusServiceBase.h"
+#include "AcceptsTelemetryIF.h"
+#include "PusVerificationReport.h"
+#include "TmTcMessage.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../tcdistribution/PUSDistributorIF.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../tmtcservices/PusServiceBase.h"
-#include "../tmtcservices/PusVerificationReport.h"
-#include "../tmtcservices/TmTcMessage.h"
 #include "../ipc/QueueFactory.h"
 
 object_id_t PusServiceBase::packetSource = 0;
@@ -60,11 +61,11 @@ void PusServiceBase::handleRequestQueue() {
 			//    ": handleRequest returned: " << (int)return_code << std::endl;
 			if (result == RETURN_OK) {
 				this->verifyReporter.sendSuccessReport(
-						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
+						tc_verification::COMPLETION_SUCCESS, &this->currentPacket);
 			}
 			else {
 				this->verifyReporter.sendFailureReport(
-						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
+						tc_verification::COMPLETION_FAILURE, &this->currentPacket,
 						result, 0, errorParameter1, errorParameter2);
 			}
 			this->currentPacket.deletePacket();
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 7c8f504c1..4d3d99bc4 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -1,14 +1,15 @@
-#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+#ifndef FSFW_TMTCSERVICES_PUSSERVICEBASE_H_
+#define FSFW_TMTCSERVICES_PUSSERVICEBASE_H_
+
+#include "AcceptsTelecommandsIF.h"
+#include "VerificationCodes.h"
+#include "VerificationReporter.h"
 
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../tmtcservices/VerificationCodes.h"
-#include "../tmtcservices/VerificationReporter.h"
 #include "../ipc/MessageQueueIF.h"
 
 namespace Factory{
@@ -156,4 +157,4 @@ private:
 	void handleRequestQueue();
 };
 
-#endif /* PUSSERVICEBASE_H_ */
+#endif /* FSFW_TMTCSERVICES_PUSSERVICEBASE_H_ */
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index 369519d8a..c64e5feb3 100644
--- a/tmtcservices/PusVerificationReport.cpp
+++ b/tmtcservices/PusVerificationReport.cpp
@@ -4,31 +4,6 @@
 PusVerificationMessage::PusVerificationMessage() {
 }
 
-//PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
-//		TcPacketBase* current_packet, ReturnValue_t set_error_code,
-//		uint8_t set_step, uint32_t parameter1, uint32_t parameter2) {
-//	uint8_t ackFlags = current_packet->getAcknowledgeFlags();
-//	uint16_t tcPacketId = current_packet->getPacketId();
-//	uint16_t tcSequenceControl = current_packet->getPacketSequenceControl();
-//	uint8_t* data = this->getBuffer();
-//	data[messageSize] = set_report_id;
-//	messageSize += sizeof(set_report_id);
-//	data[messageSize] = ackFlags;
-//	messageSize += sizeof(ackFlags);
-//	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
-//	messageSize += sizeof(tcPacketId);
-//	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
-//	messageSize += sizeof(tcSequenceControl);
-//	data[messageSize] = set_step;
-//	messageSize += sizeof(set_step);
-//	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
-//	messageSize += sizeof(set_error_code);
-//	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
-//	messageSize += sizeof(parameter1);
-//	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
-//	messageSize += sizeof(parameter2);
-//}
-
 PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
 		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
 		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
diff --git a/tmtcservices/ServiceTypes.h b/tmtcservices/ServiceTypes.h
index 1f5bff42f..552601f97 100644
--- a/tmtcservices/ServiceTypes.h
+++ b/tmtcservices/ServiceTypes.h
@@ -1,13 +1,7 @@
-/**
- * @file	ServiceTypes.h
- * @brief	This file defines the ServiceTypes class.
- * @date	11.04.2013
- * @author	baetz
- */
-
 #ifndef SERVICETYPES_H_
 #define SERVICETYPES_H_
 
+// SHOULDDO: This is a duplication of existing configuration structures. Delete it?
 namespace SERVICE {
 enum ServiceTypes {
 	TELECOMMAND_VERIFICATION = 1,
diff --git a/tmtcservices/SourceSequenceCounter.h b/tmtcservices/SourceSequenceCounter.h
index 1cc587587..2b30a53f2 100644
--- a/tmtcservices/SourceSequenceCounter.h
+++ b/tmtcservices/SourceSequenceCounter.h
@@ -1,12 +1,6 @@
-/**
- * @file	SourceSequenceCounter.h
- * @brief	This file defines the SourceSequenceCounter class.
- * @date	04.02.2013
- * @author	baetz
- */
+#ifndef FSFW_TMTCSERVICES_SOURCESEQUENCECOUNTER_H_
+#define FSFW_TMTCSERVICES_SOURCESEQUENCECOUNTER_H_
 
-#ifndef SOURCESEQUENCECOUNTER_H_
-#define SOURCESEQUENCECOUNTER_H_
 #include "../tmtcpacket/SpacePacketBase.h"
 
 class SourceSequenceCounter {
@@ -27,4 +21,4 @@ public:
 };
 
 
-#endif /* SOURCESEQUENCECOUNTER_H_ */
+#endif /* FSFW_TMTCSERVICES_SOURCESEQUENCECOUNTER_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 8abe37a2a..b4e9967bf 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -1,7 +1,6 @@
-#include "../tmtcservices/TmTcBridge.h"
+#include "TmTcBridge.h"
 
 #include "../ipc/QueueFactory.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../globalfunctions/arrayprinter.h"
 
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 62cfdaac6..0177648c0 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
-#define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
+#ifndef FSFW_TMTCSERVICES_TMTCBRIDGE_H_
+#define FSFW_TMTCSERVICES_TMTCBRIDGE_H_
 
+#include "AcceptsTelemetryIF.h"
+#include "AcceptsTelecommandsIF.h"
 
 #include "../objectmanager/SystemObject.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../container/DynamicFIFO.h"
 #include "../tmtcservices/TmTcMessage.h"
 
@@ -159,4 +159,4 @@ protected:
 };
 
 
-#endif /* FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ */
+#endif /* FSFW_TMTCSERVICES_TMTCBRIDGE_H_ */
diff --git a/tmtcservices/TmTcMessage.cpp b/tmtcservices/TmTcMessage.cpp
index f81eba62e..ae0283158 100644
--- a/tmtcservices/TmTcMessage.cpp
+++ b/tmtcservices/TmTcMessage.cpp
@@ -1,5 +1,6 @@
-#include "../tmtcservices/TmTcMessage.h"
-#include <string.h>
+#include "TmTcMessage.h"
+
+#include <cstring>
 
 
 TmTcMessage::TmTcMessage() {
diff --git a/tmtcservices/VerificationCodes.h b/tmtcservices/VerificationCodes.h
index e3e89b5a0..35ad6819e 100644
--- a/tmtcservices/VerificationCodes.h
+++ b/tmtcservices/VerificationCodes.h
@@ -1,7 +1,7 @@
 #ifndef VERIFICATIONCODES_H_
 #define VERIFICATIONCODES_H_
 
-namespace TC_VERIFY {
+namespace tc_verification {
 
 enum verification_flags {
 	NONE = 0b0000,

From 796f0e2e17152a40d6f58c9c592b9c74fc573148 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:33:19 +0100
Subject: [PATCH 1187/1774] important changes adapted

---
 pus/servicepackets/Service1Packets.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index ecb62693c..2249b4b0f 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -49,7 +49,7 @@ public:
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
+		if (failureSubtype == tc_verification::PROGRESS_FAILURE) {
 			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
 			        maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -77,7 +77,7 @@ public:
 		size_t size = 0;
 		size += SerializeAdapter::getSerializedSize(&packetId);
 		size += sizeof(packetSequenceControl);
-		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
+		if(failureSubtype==tc_verification::PROGRESS_FAILURE){
 			size += SerializeAdapter::getSerializedSize(&stepNumber);
 		}
 		size += SerializeAdapter::getSerializedSize(&errorCode);
@@ -131,7 +131,7 @@ public:
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
+		if (subtype == tc_verification::PROGRESS_SUCCESS) {
 			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
 					maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -145,7 +145,7 @@ public:
 		size_t size = 0;
 		size += SerializeAdapter::getSerializedSize(&packetId);
 		size += sizeof(packetSequenceControl);
-		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
+		if(subtype == tc_verification::PROGRESS_SUCCESS){
 			size += SerializeAdapter::getSerializedSize(&stepNumber);
 		}
 		return size;

From 1c79da0e75309662bdfe5b94c4a71c93c1825492 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:34:29 +0100
Subject: [PATCH 1188/1774] tc distrib changed  taken over

---
 tcdistribution/PUSDistributor.cpp | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 63d1dcde5..8e5b94cc1 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -77,14 +77,14 @@ ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
 		tcStatus = queueStatus;
 	}
 	if (tcStatus != RETURN_OK) {
-		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
+		this->verifyChannel.sendFailureReport(tc_verification::ACCEPTANCE_FAILURE,
 				currentPacket, tcStatus);
 		// A failed packet is deleted immediately after reporting,
 		// otherwise it will block memory.
 		currentPacket->deletePacket();
 		return RETURN_FAILED;
 	} else {
-		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
+		this->verifyChannel.sendSuccessReport(tc_verification::ACCEPTANCE_SUCCESS,
 				currentPacket);
 		return RETURN_OK;
 	}
@@ -95,16 +95,19 @@ uint16_t PUSDistributor::getIdentifier() {
 }
 
 ReturnValue_t PUSDistributor::initialize() {
+    currentPacket = new TcPacketStored();
+    if(currentPacket == nullptr) {
+        // Should not happen, memory allocation failed!
+        return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
+
 	CCSDSDistributorIF* ccsdsDistributor =
 			objectManager->get<CCSDSDistributorIF>(packetSource);
-	currentPacket = new TcPacketStored();
 	if (ccsdsDistributor == nullptr) {
 		sif::error << "PUSDistributor::initialize: Packet source invalid."
 		        << " Make sure it exists and implements CCSDSDistributorIF!"
 		        << std::endl;
 	    return RETURN_FAILED;
 	}
-	else {
-		return ccsdsDistributor->registerApplication(this);
-	}
+	return ccsdsDistributor->registerApplication(this);
 }

From db42e79fd4eb299c960a3da50ef629098f9bb409 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:38:45 +0100
Subject: [PATCH 1189/1774] taken over cmakelists file

---
 osal/linux/CMakeLists.txt | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 osal/linux/CMakeLists.txt

diff --git a/osal/linux/CMakeLists.txt b/osal/linux/CMakeLists.txt
new file mode 100644
index 000000000..c0096e428
--- /dev/null
+++ b/osal/linux/CMakeLists.txt
@@ -0,0 +1,25 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		BinarySemaphore.cpp
+		CountingSemaphore.cpp
+		FixedTimeslotTask.cpp
+		InternalErrorCodes.cpp
+		MessageQueue.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PeriodicPosixTask.cpp
+		PosixThread.cpp
+		QueueFactory.cpp
+		SemaphoreFactory.cpp
+		TaskFactory.cpp
+		TcUnixUdpPollingTask.cpp
+		TmTcUnixUdpBridge.cpp
+		Timer.cpp
+)
+
+target_link_libraries(${LIB_FSFW_NAME} 
+	PRIVATE
+		rt
+		pthread
+)

From 336b43572f1bb928be5475c2eabebdfa6d53a587 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:46:33 +0100
Subject: [PATCH 1190/1774] linux update

---
 ipc/MutexFactory.h              |  6 +++---
 osal/linux/BinarySemaphore.cpp  |  2 +-
 osal/linux/Clock.cpp            | 14 +++++++-------
 osal/linux/MessageQueue.cpp     |  1 +
 osal/linux/Mutex.h              |  5 ++---
 osal/linux/MutexFactory.cpp     |  3 ++-
 osal/linux/PosixThread.cpp      | 10 +++++++---
 osal/linux/SemaphoreFactory.cpp |  3 ++-
 osal/linux/TaskFactory.cpp      |  1 +
 osal/linux/Timer.cpp            |  3 ++-
 tasks/TaskFactory.h             |  8 ++++----
 11 files changed, 32 insertions(+), 24 deletions(-)

diff --git a/ipc/MutexFactory.h b/ipc/MutexFactory.h
index f8133d814..db505ff94 100644
--- a/ipc/MutexFactory.h
+++ b/ipc/MutexFactory.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
-#define FRAMEWORK_IPC_MUTEXFACTORY_H_
+#ifndef FSFW_IPC_MUTEXFACTORY_H_
+#define FSFW_IPC_MUTEXFACTORY_H_
 
 #include "MutexIF.h"
 /**
@@ -31,4 +31,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_IPC_MUTEXFACTORY_H_ */
+#endif /* FSFW_IPC_MUTEXFACTORY_H_ */
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 8c0eeae71..b81fa1090 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/linux/BinarySemaphore.h"
+#include "BinarySemaphore.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 extern "C" {
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 4de18f83b..6cddda35b 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -76,25 +76,25 @@ timeval Clock::getUptime() {
 
 ReturnValue_t Clock::getUptime(timeval* uptime) {
     //TODO This is not posix compatible and delivers only seconds precision
-    // is the OS not called Linux?
-    //Linux specific file read but more precise
+    // Linux specific file read but more precise.
     double uptimeSeconds;
     if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
         uptime->tv_sec = uptimeSeconds;
         uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
     }
+    return HasReturnvaluesIF::RETURN_OK;
+}
 
-	//TODO This is not posix compatible and delivers only seconds precision
-    // I suggest this is moved into another clock function which will
-    // deliver second precision later.
+// Wait for new FSFW Clock function delivering seconds uptime.
+//uint32_t Clock::getUptimeSeconds() {
+//	//TODO This is not posix compatible and delivers only seconds precision
 //	struct sysinfo sysInfo;
 //	int result = sysinfo(&sysInfo);
 //	if(result != 0){
 //		return HasReturnvaluesIF::RETURN_FAILED;
 //	}
 //	return sysInfo.uptime;
-    return HasReturnvaluesIF::RETURN_OK;
-}
+//}
 
 ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 	timeval uptime;
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index bc14374ac..cfadb7931 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -3,6 +3,7 @@
 #include "../../objectmanager/ObjectManagerIF.h"
 
 #include <fstream>
+
 #include <fcntl.h>           /* For O_* constants */
 #include <sys/stat.h>        /* For mode constants */
 #include <cstring>
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index ecb47a336..cfce407f7 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -1,10 +1,9 @@
-#ifndef OS_LINUX_MUTEX_H_
-#define OS_LINUX_MUTEX_H_
+#ifndef FSFW_OSAL_LINUX_MUTEX_H_
+#define FSFW_OSAL_LINUX_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 #include <pthread.h>
 
-
 class Mutex : public MutexIF {
 public:
 	Mutex();
diff --git a/osal/linux/MutexFactory.cpp b/osal/linux/MutexFactory.cpp
index 8c2faf888..80211f8bc 100644
--- a/osal/linux/MutexFactory.cpp
+++ b/osal/linux/MutexFactory.cpp
@@ -1,6 +1,7 @@
-#include "../../ipc/MutexFactory.h"
 #include "Mutex.h"
 
+#include "../../ipc/MutexFactory.h"
+
 //TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
 MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
 
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index ddb1f74f6..55d74de3e 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,5 +1,7 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "PosixThread.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
 #include <cstring>
 #include <errno.h>
 
@@ -149,8 +151,10 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
 	if(status != 0){
-		sif::error << "Posix Thread attribute setStack failed with: " <<
-				strerror(status) << std::endl;
+		sif::error << "PosixThread::createTask: pthread_attr_setstack "
+				" failed with: " << strerror(status) <<  std::endl;
+		sif::error << "Make sure the specified stack size is valid and is "
+				"larger than the minimum allowed stack size." << std::endl;
 	}
 
 	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index e4710933e..cfb5f12dd 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,6 +1,7 @@
-#include "../../tasks/SemaphoreFactory.h"
 #include "BinarySemaphore.h"
 #include "CountingSemaphore.h"
+
+#include "../../tasks/SemaphoreFactory.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
diff --git a/osal/linux/TaskFactory.cpp b/osal/linux/TaskFactory.cpp
index f507c7671..d18a03161 100644
--- a/osal/linux/TaskFactory.cpp
+++ b/osal/linux/TaskFactory.cpp
@@ -1,5 +1,6 @@
 #include "FixedTimeslotTask.h"
 #include "PeriodicPosixTask.h"
+
 #include "../../tasks/TaskFactory.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index ee964baa0..bae631d72 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -1,6 +1,7 @@
+#include "Timer.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include <errno.h>
-#include "Timer.h"
+
 
 Timer::Timer() {
 	sigevent sigEvent;
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index cbf2272c3..404dd2a88 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -1,9 +1,9 @@
-#ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
-#define FRAMEWORK_TASKS_TASKFACTORY_H_
+#ifndef FSFW_TASKS_TASKFACTORY_H_
+#define FSFW_TASKS_TASKFACTORY_H_
 
-#include <stdlib.h>
 #include "FixedTimeslotTaskIF.h"
 #include "Typedef.h"
+#include <cstdlib>
 
 /**
  * Singleton Class that produces Tasks.
@@ -69,4 +69,4 @@ private:
 
 };
 
-#endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */
+#endif /* FSFW_TASKS_TASKFACTORY_H_ */

From f2ba653833924f073a44974fd6e902ce6f5d1815 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:47:42 +0100
Subject: [PATCH 1191/1774] ipc changes taken over

---
 ipc/MutexFactory.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ipc/MutexFactory.h b/ipc/MutexFactory.h
index f8133d814..db505ff94 100644
--- a/ipc/MutexFactory.h
+++ b/ipc/MutexFactory.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
-#define FRAMEWORK_IPC_MUTEXFACTORY_H_
+#ifndef FSFW_IPC_MUTEXFACTORY_H_
+#define FSFW_IPC_MUTEXFACTORY_H_
 
 #include "MutexIF.h"
 /**
@@ -31,4 +31,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_IPC_MUTEXFACTORY_H_ */
+#endif /* FSFW_IPC_MUTEXFACTORY_H_ */

From 4f2470b93f8947fafb4e5f2ea4323a30ed3fd5ff Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:48:12 +0100
Subject: [PATCH 1192/1774] task factory

---
 tasks/TaskFactory.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 404dd2a88..85cdda900 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -3,6 +3,7 @@
 
 #include "FixedTimeslotTaskIF.h"
 #include "Typedef.h"
+
 #include <cstdlib>
 
 /**
@@ -48,10 +49,11 @@ public:
 
 	/**
 	 * Function to be called to delete a task
-	 * @param task The pointer to the task that shall be deleted, NULL specifies current Task
+	 * @param task The pointer to the task that shall be deleted,
+	 * nullptr specifies current Task
 	 * @return Success of deletion
 	 */
-	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
+	static ReturnValue_t deleteTask(PeriodicTaskIF* task = nullptr);
 
 	/**
 	 * Function to be called to delay current task

From 3ee25785a2cefa7eca6d33bba49e046df75a18e1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:54:03 +0100
Subject: [PATCH 1193/1774] linux changes adapted

---
 osal/linux/BinarySemaphore.cpp  |  2 +-
 osal/linux/Clock.cpp            | 20 ++++++++++----------
 osal/linux/Mutex.cpp            |  2 +-
 osal/linux/Mutex.h              |  8 ++------
 osal/linux/MutexFactory.cpp     |  3 ++-
 osal/linux/PosixThread.cpp      |  4 +++-
 osal/linux/SemaphoreFactory.cpp |  3 ++-
 osal/linux/TaskFactory.cpp      |  5 +++--
 osal/linux/Timer.cpp            |  3 ++-
 9 files changed, 26 insertions(+), 24 deletions(-)

diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 8c0eeae71..b81fa1090 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/linux/BinarySemaphore.h"
+#include "BinarySemaphore.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 extern "C" {
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 468fcb80f..6cddda35b 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,4 +1,3 @@
-#include <fsfw/timemanager/Stopwatch.h>
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../timemanager/Clock.h"
 
@@ -86,15 +85,16 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-uint32_t Clock::getUptimeSeconds() {
-	//TODO This is not posix compatible and delivers only seconds precision
-	struct sysinfo sysInfo;
-	int result = sysinfo(&sysInfo);
-	if(result != 0){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return sysInfo.uptime;
-}
+// Wait for new FSFW Clock function delivering seconds uptime.
+//uint32_t Clock::getUptimeSeconds() {
+//	//TODO This is not posix compatible and delivers only seconds precision
+//	struct sysinfo sysInfo;
+//	int result = sysinfo(&sysInfo);
+//	if(result != 0){
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//	return sysInfo.uptime;
+//}
 
 ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 	timeval uptime;
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index 2ecae0cb8..b27ff8c0a 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/linux/Mutex.h"
+#include "Mutex.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../timemanager/Clock.h"
 
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index 3acb6d90c..cfce407f7 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -1,12 +1,8 @@
-#ifndef OS_LINUX_MUTEX_H_
-#define OS_LINUX_MUTEX_H_
+#ifndef FSFW_OSAL_LINUX_MUTEX_H_
+#define FSFW_OSAL_LINUX_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
-
-extern "C" {
 #include <pthread.h>
-}
-
 
 class Mutex : public MutexIF {
 public:
diff --git a/osal/linux/MutexFactory.cpp b/osal/linux/MutexFactory.cpp
index 73ab10a2f..80211f8bc 100644
--- a/osal/linux/MutexFactory.cpp
+++ b/osal/linux/MutexFactory.cpp
@@ -1,5 +1,6 @@
+#include "Mutex.h"
+
 #include "../../ipc/MutexFactory.h"
-#include "../../osal/linux/Mutex.h"
 
 //TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
 MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index f6ace3805..55d74de3e 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,5 +1,7 @@
+#include "PosixThread.h"
+
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/PosixThread.h"
+
 #include <cstring>
 #include <errno.h>
 
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index e4710933e..cfb5f12dd 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,6 +1,7 @@
-#include "../../tasks/SemaphoreFactory.h"
 #include "BinarySemaphore.h"
 #include "CountingSemaphore.h"
+
+#include "../../tasks/SemaphoreFactory.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
diff --git a/osal/linux/TaskFactory.cpp b/osal/linux/TaskFactory.cpp
index a25b817d7..d18a03161 100644
--- a/osal/linux/TaskFactory.cpp
+++ b/osal/linux/TaskFactory.cpp
@@ -1,5 +1,6 @@
-#include "../../osal/linux/FixedTimeslotTask.h"
-#include "../../osal/linux/PeriodicPosixTask.h"
+#include "FixedTimeslotTask.h"
+#include "PeriodicPosixTask.h"
+
 #include "../../tasks/TaskFactory.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index b458fd905..bae631d72 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -1,6 +1,7 @@
+#include "Timer.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include <errno.h>
-#include "../../osal/linux/Timer.h"
+
 
 Timer::Timer() {
 	sigevent sigEvent;

From 95b2191824f8ca051021801cf84aa9b440a45d37 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 22:55:12 +0100
Subject: [PATCH 1194/1774] long name

---
 datapoollocal/LocalDataPoolManager.h |  2 +-
 datapoollocal/LocalPoolVariable.h    | 50 ++++++++++++++--------------
 datapoollocal/LocalPoolVariable.tpp  | 46 ++++++++++++-------------
 monitoring/MonitorBase.h             |  2 +-
 4 files changed, 50 insertions(+), 50 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 95d483032..c4024cf9e 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -48,7 +48,7 @@ class HousekeepingPacketUpdate;
  * @author 		R. Mueller
  */
 class LocalDataPoolManager {
-	template<typename T> friend class LocalPoolVar;
+	template<typename T> friend class LocalPoolVariable;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index c18d54433..7b7e443e1 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -22,10 +22,10 @@
  * @ingroup data_pool
  */
 template<typename T>
-class LocalPoolVar: public LocalPoolObjectBase {
+class LocalPoolVariable: public LocalPoolObjectBase {
 public:
 	//! Default ctor is forbidden.
-	LocalPoolVar() = delete;
+	LocalPoolVariable() = delete;
 
 	/**
 	 * This constructor is used by the data creators to have pool variable
@@ -43,7 +43,7 @@ public:
 	 * If nullptr, the variable is not registered.
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 */
-	LocalPoolVar(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+	LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
@@ -64,7 +64,7 @@ public:
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 *
 	 */
-	LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
+	LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 	/**
@@ -73,10 +73,10 @@ public:
 	 * @param dataSet
 	 * @param setReadWriteMode
 	 */
-	LocalPoolVar(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+	LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-	virtual~ LocalPoolVar() {};
+	virtual~ LocalPoolVariable() {};
 
 	/**
 	 * @brief	This is the local copy of the data pool entry.
@@ -118,23 +118,23 @@ public:
 	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
 
 
-	LocalPoolVar<T> &operator=(const T& newValue);
-	LocalPoolVar<T> &operator=(const LocalPoolVar<T>& newPoolVariable);
+	LocalPoolVariable<T> &operator=(const T& newValue);
+	LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
 
 	//! Explicit type conversion operator. Allows casting the class to
 	//! its template type to perform operations on value.
 	explicit operator T() const;
 
-	bool operator==(const LocalPoolVar<T>& other) const;
+	bool operator==(const LocalPoolVariable<T>& other) const;
 	bool operator==(const T& other) const;
 
-	bool operator!=(const LocalPoolVar<T>& other) const;
+	bool operator!=(const LocalPoolVariable<T>& other) const;
 	bool operator!=(const T& other) const;
 
-	bool operator<(const LocalPoolVar<T>& other) const;
+	bool operator<(const LocalPoolVariable<T>& other) const;
 	bool operator<(const T& other) const;
 
-	bool operator>(const LocalPoolVar<T>& other) const;
+	bool operator>(const LocalPoolVariable<T>& other) const;
 	bool operator>(const T& other) const;
 
 protected:
@@ -160,7 +160,7 @@ protected:
 	// std::ostream is the type for object std::cout
 	template <typename U>
 	friend std::ostream& operator<< (std::ostream &out,
-			const LocalPoolVar<U> &var);
+			const LocalPoolVariable<U> &var);
 
 private:
 };
@@ -168,18 +168,18 @@ private:
 #include "LocalPoolVariable.tpp"
 
 template<class T>
-using lp_var_t = LocalPoolVar<T>;
+using lp_var_t = LocalPoolVariable<T>;
 
-using lp_bool_t = LocalPoolVar<uint8_t>;
-using lp_uint8_t = LocalPoolVar<uint8_t>;
-using lp_uint16_t = LocalPoolVar<uint16_t>;
-using lp_uint32_t = LocalPoolVar<uint32_t>;
-using lp_uint64_t = LocalPoolVar<uint64_t>;
-using lp_int8_t = LocalPoolVar<int8_t>;
-using lp_int16_t = LocalPoolVar<int16_t>;
-using lp_int32_t = LocalPoolVar<int32_t>;
-using lp_int64_t = LocalPoolVar<int64_t>;
-using lp_float_t = LocalPoolVar<float>;
-using lp_double_t = LocalPoolVar<double>;
+using lp_bool_t = LocalPoolVariable<uint8_t>;
+using lp_uint8_t = LocalPoolVariable<uint8_t>;
+using lp_uint16_t = LocalPoolVariable<uint16_t>;
+using lp_uint32_t = LocalPoolVariable<uint32_t>;
+using lp_uint64_t = LocalPoolVariable<uint64_t>;
+using lp_int8_t = LocalPoolVariable<int8_t>;
+using lp_int16_t = LocalPoolVariable<int16_t>;
+using lp_int32_t = LocalPoolVariable<int32_t>;
+using lp_int64_t = LocalPoolVariable<int64_t>;
+using lp_float_t = LocalPoolVariable<float>;
+using lp_double_t = LocalPoolVariable<double>;
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index b9f7b906e..48649ad58 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -6,32 +6,32 @@
 #endif
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(HasLocalDataPoolIF* hkOwner,
+inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
 		lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
         LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(gp_id_t globalPoolId, DataSetIF *dataSet,
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF *dataSet,
 		pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
 				dataSet, setReadWriteMode){}
 
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
+inline ReturnValue_t LocalPoolVariable<T>::read(dur_millis_t lockTimeout) {
 	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
 			lockTimeout);
 	return readWithoutLock();
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
+inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
@@ -53,14 +53,14 @@ inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::commit(dur_millis_t lockTimeout) {
+inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
 	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
 			lockTimeout);
 	return commitWithoutLock();
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
+inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 		sif::debug << "LocalPoolVar: Invalid read write "
 				 "mode for commit() call." << std::endl;
@@ -81,88 +81,88 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
+inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
 	return SerializeAdapter::serialize(&value,
 			buffer, size ,max_size, streamEndianness);
 }
 
 template<typename T>
-inline size_t LocalPoolVar<T>::getSerializedSize() const {
+inline size_t LocalPoolVariable<T>::getSerializedSize() const {
 	return SerializeAdapter::getSerializedSize(&value);
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
+inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
 		size_t* size, SerializeIF::Endianness streamEndianness) {
 	return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
 template<typename T>
 inline std::ostream& operator<< (std::ostream &out,
-		const LocalPoolVar<T> &var) {
+		const LocalPoolVariable<T> &var) {
     out << var.value;
     return out;
 }
 
 template<typename T>
-inline LocalPoolVar<T>::operator T() const {
+inline LocalPoolVariable<T>::operator T() const {
 	return value;
 }
 
 template<typename T>
-inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(const T& newValue) {
+inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(const T& newValue) {
     value = newValue;
     return *this;
 }
 
 template<typename T>
-inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
-		const LocalPoolVar<T>& newPoolVariable) {
+inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
+		const LocalPoolVariable<T>& newPoolVariable) {
 	value = newPoolVariable.value;
 	return *this;
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator ==(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator ==(const LocalPoolVariable<T> &other) const {
 	return this->value == other.value;
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator ==(const T &other) const {
+inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
 	return this->value == other;
 }
 
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator !=(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator !=(const LocalPoolVariable<T> &other) const {
 	return not (*this == other);
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator !=(const T &other) const {
+inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
 	return not (*this == other);
 }
 
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator <(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator <(const LocalPoolVariable<T> &other) const {
 	return this->value < other.value;
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator <(const T &other) const {
+inline bool LocalPoolVariable<T>::operator <(const T &other) const {
 	return this->value < other;
 }
 
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator >(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator >(const LocalPoolVariable<T> &other) const {
 	return not (*this < other);
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator >(const T &other) const {
+inline bool LocalPoolVariable<T>::operator >(const T &other) const {
 	return not (*this < other);
 }
 
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 530a38409..967f0f62f 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -72,7 +72,7 @@ protected:
 	    return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	LocalPoolVar<T> poolVariable;
+	LocalPoolVariable<T> poolVariable;
 };
 
 #endif /* FSFW_MONITORING_MONITORBASE_H_ */

From 93842bb91315e53deee34c577912b279676b32b1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 22:56:30 +0100
Subject: [PATCH 1195/1774] using long name now

---
 datapoollocal/LocalDataPoolManager.h |  2 +-
 datapoollocal/LocalPoolVariable.h    | 50 ++++++++++++++--------------
 datapoollocal/LocalPoolVariable.tpp  | 46 ++++++++++++-------------
 monitoring/MonitorBase.h             |  2 +-
 4 files changed, 50 insertions(+), 50 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 95d483032..c4024cf9e 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -48,7 +48,7 @@ class HousekeepingPacketUpdate;
  * @author 		R. Mueller
  */
 class LocalDataPoolManager {
-	template<typename T> friend class LocalPoolVar;
+	template<typename T> friend class LocalPoolVariable;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index c18d54433..7b7e443e1 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -22,10 +22,10 @@
  * @ingroup data_pool
  */
 template<typename T>
-class LocalPoolVar: public LocalPoolObjectBase {
+class LocalPoolVariable: public LocalPoolObjectBase {
 public:
 	//! Default ctor is forbidden.
-	LocalPoolVar() = delete;
+	LocalPoolVariable() = delete;
 
 	/**
 	 * This constructor is used by the data creators to have pool variable
@@ -43,7 +43,7 @@ public:
 	 * If nullptr, the variable is not registered.
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 */
-	LocalPoolVar(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+	LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
@@ -64,7 +64,7 @@ public:
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 *
 	 */
-	LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
+	LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 	/**
@@ -73,10 +73,10 @@ public:
 	 * @param dataSet
 	 * @param setReadWriteMode
 	 */
-	LocalPoolVar(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+	LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-	virtual~ LocalPoolVar() {};
+	virtual~ LocalPoolVariable() {};
 
 	/**
 	 * @brief	This is the local copy of the data pool entry.
@@ -118,23 +118,23 @@ public:
 	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
 
 
-	LocalPoolVar<T> &operator=(const T& newValue);
-	LocalPoolVar<T> &operator=(const LocalPoolVar<T>& newPoolVariable);
+	LocalPoolVariable<T> &operator=(const T& newValue);
+	LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
 
 	//! Explicit type conversion operator. Allows casting the class to
 	//! its template type to perform operations on value.
 	explicit operator T() const;
 
-	bool operator==(const LocalPoolVar<T>& other) const;
+	bool operator==(const LocalPoolVariable<T>& other) const;
 	bool operator==(const T& other) const;
 
-	bool operator!=(const LocalPoolVar<T>& other) const;
+	bool operator!=(const LocalPoolVariable<T>& other) const;
 	bool operator!=(const T& other) const;
 
-	bool operator<(const LocalPoolVar<T>& other) const;
+	bool operator<(const LocalPoolVariable<T>& other) const;
 	bool operator<(const T& other) const;
 
-	bool operator>(const LocalPoolVar<T>& other) const;
+	bool operator>(const LocalPoolVariable<T>& other) const;
 	bool operator>(const T& other) const;
 
 protected:
@@ -160,7 +160,7 @@ protected:
 	// std::ostream is the type for object std::cout
 	template <typename U>
 	friend std::ostream& operator<< (std::ostream &out,
-			const LocalPoolVar<U> &var);
+			const LocalPoolVariable<U> &var);
 
 private:
 };
@@ -168,18 +168,18 @@ private:
 #include "LocalPoolVariable.tpp"
 
 template<class T>
-using lp_var_t = LocalPoolVar<T>;
+using lp_var_t = LocalPoolVariable<T>;
 
-using lp_bool_t = LocalPoolVar<uint8_t>;
-using lp_uint8_t = LocalPoolVar<uint8_t>;
-using lp_uint16_t = LocalPoolVar<uint16_t>;
-using lp_uint32_t = LocalPoolVar<uint32_t>;
-using lp_uint64_t = LocalPoolVar<uint64_t>;
-using lp_int8_t = LocalPoolVar<int8_t>;
-using lp_int16_t = LocalPoolVar<int16_t>;
-using lp_int32_t = LocalPoolVar<int32_t>;
-using lp_int64_t = LocalPoolVar<int64_t>;
-using lp_float_t = LocalPoolVar<float>;
-using lp_double_t = LocalPoolVar<double>;
+using lp_bool_t = LocalPoolVariable<uint8_t>;
+using lp_uint8_t = LocalPoolVariable<uint8_t>;
+using lp_uint16_t = LocalPoolVariable<uint16_t>;
+using lp_uint32_t = LocalPoolVariable<uint32_t>;
+using lp_uint64_t = LocalPoolVariable<uint64_t>;
+using lp_int8_t = LocalPoolVariable<int8_t>;
+using lp_int16_t = LocalPoolVariable<int16_t>;
+using lp_int32_t = LocalPoolVariable<int32_t>;
+using lp_int64_t = LocalPoolVariable<int64_t>;
+using lp_float_t = LocalPoolVariable<float>;
+using lp_double_t = LocalPoolVariable<double>;
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index b9f7b906e..48649ad58 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -6,32 +6,32 @@
 #endif
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(HasLocalDataPoolIF* hkOwner,
+inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
 		lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
         LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(gp_id_t globalPoolId, DataSetIF *dataSet,
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF *dataSet,
 		pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
 				dataSet, setReadWriteMode){}
 
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
+inline ReturnValue_t LocalPoolVariable<T>::read(dur_millis_t lockTimeout) {
 	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
 			lockTimeout);
 	return readWithoutLock();
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
+inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
@@ -53,14 +53,14 @@ inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::commit(dur_millis_t lockTimeout) {
+inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
 	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
 			lockTimeout);
 	return commitWithoutLock();
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
+inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 		sif::debug << "LocalPoolVar: Invalid read write "
 				 "mode for commit() call." << std::endl;
@@ -81,88 +81,88 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
+inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
 	return SerializeAdapter::serialize(&value,
 			buffer, size ,max_size, streamEndianness);
 }
 
 template<typename T>
-inline size_t LocalPoolVar<T>::getSerializedSize() const {
+inline size_t LocalPoolVariable<T>::getSerializedSize() const {
 	return SerializeAdapter::getSerializedSize(&value);
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
+inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
 		size_t* size, SerializeIF::Endianness streamEndianness) {
 	return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
 template<typename T>
 inline std::ostream& operator<< (std::ostream &out,
-		const LocalPoolVar<T> &var) {
+		const LocalPoolVariable<T> &var) {
     out << var.value;
     return out;
 }
 
 template<typename T>
-inline LocalPoolVar<T>::operator T() const {
+inline LocalPoolVariable<T>::operator T() const {
 	return value;
 }
 
 template<typename T>
-inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(const T& newValue) {
+inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(const T& newValue) {
     value = newValue;
     return *this;
 }
 
 template<typename T>
-inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
-		const LocalPoolVar<T>& newPoolVariable) {
+inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
+		const LocalPoolVariable<T>& newPoolVariable) {
 	value = newPoolVariable.value;
 	return *this;
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator ==(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator ==(const LocalPoolVariable<T> &other) const {
 	return this->value == other.value;
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator ==(const T &other) const {
+inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
 	return this->value == other;
 }
 
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator !=(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator !=(const LocalPoolVariable<T> &other) const {
 	return not (*this == other);
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator !=(const T &other) const {
+inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
 	return not (*this == other);
 }
 
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator <(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator <(const LocalPoolVariable<T> &other) const {
 	return this->value < other.value;
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator <(const T &other) const {
+inline bool LocalPoolVariable<T>::operator <(const T &other) const {
 	return this->value < other;
 }
 
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator >(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator >(const LocalPoolVariable<T> &other) const {
 	return not (*this < other);
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator >(const T &other) const {
+inline bool LocalPoolVariable<T>::operator >(const T &other) const {
 	return not (*this < other);
 }
 
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 530a38409..967f0f62f 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -72,7 +72,7 @@ protected:
 	    return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	LocalPoolVar<T> poolVariable;
+	LocalPoolVariable<T> poolVariable;
 };
 
 #endif /* FSFW_MONITORING_MONITORBASE_H_ */

From 9170f466e8ccaf74da9bd97d260fd846fcb6551a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 23:21:07 +0100
Subject: [PATCH 1196/1774] freeRTOS version checks

---
 osal/FreeRTOS/BinSemaphUsingTask.h | 5 +++++
 osal/FreeRTOS/PeriodicTask.cpp     | 3 +++
 2 files changed, 8 insertions(+)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 65a091a3f..0061c252f 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -7,6 +7,9 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
+#if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8
+
 // todo: does not work for older FreeRTOS version, so we should
 // actually check whether tskKERNEL_VERSION_MAJOR is larger than.. 7 or 8 ?
 
@@ -90,4 +93,6 @@ protected:
 	TaskHandle_t handle;
 };
 
+#endif
+
 #endif /* FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 5c0a840da..04c588d23 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -112,6 +112,8 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
      * it. */
     TickType_t currentTickCount = xTaskGetTickCount();
     TickType_t timeToWake = xLastWakeTime + interval;
+#if tskKERNEL_VERSION_MAJOR >= 10 && tskKERNEL_VERSION_MINOR > 4)
+#else
     // Time to wake has not overflown.
     if(timeToWake > xLastWakeTime) {
         /* If the current time has overflown exclusively or the current
@@ -126,6 +128,7 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
     else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
         handleMissedDeadline();
     }
+#endif
 }
 
 TaskHandle_t PeriodicTask::getTaskHandle() {

From b8f4d8690bec206be73a4e819ae71685177ae3e9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 23:38:06 +0100
Subject: [PATCH 1197/1774] determination of freeRTOS features from version

---
 osal/FreeRTOS/BinSemaphUsingTask.h |  3 ---
 osal/FreeRTOS/PeriodicTask.cpp     | 18 +++++++++++-------
 osal/FreeRTOS/PeriodicTask.h       |  1 +
 3 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 0061c252f..8a413d5ad 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -10,9 +10,6 @@
 #if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
     tskKERNEL_VERSION_MAJOR > 8
 
-// todo: does not work for older FreeRTOS version, so we should
-// actually check whether tskKERNEL_VERSION_MAJOR is larger than.. 7 or 8 ?
-
 /**
  * @brief 	Binary Semaphore implementation using the task notification value.
  * 			The notification value should therefore not be used
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 04c588d23..963891877 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -80,10 +80,16 @@ void PeriodicTask::taskFunctionality() {
 			object->performOperation();
 		}
 
-		checkMissedDeadline(xLastWakeTime, xPeriod);
-
-		vTaskDelayUntil(&xLastWakeTime, xPeriod);
-
+#if (tskKERNEL_VERSION_MAJOR == 10 && tskKERNEL_VERSION_MINOR >= 4) || \
+    tskKERNEL_VERSION_MAJOR > 10
+		BaseType_t wasDelayed = xTaskDelayUntil(&xLastWakeTime, xPeriod);
+		if(wasDelayed == pdFALSE) {
+		    handleMissedDeadline();
+		}
+#else
+        checkMissedDeadline(xLastWakeTime, xPeriod);
+        vTaskDelayUntil(&xLastWakeTime, xPeriod);
+#endif
 	}
 }
 
@@ -112,8 +118,6 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
      * it. */
     TickType_t currentTickCount = xTaskGetTickCount();
     TickType_t timeToWake = xLastWakeTime + interval;
-#if tskKERNEL_VERSION_MAJOR >= 10 && tskKERNEL_VERSION_MINOR > 4)
-#else
     // Time to wake has not overflown.
     if(timeToWake > xLastWakeTime) {
         /* If the current time has overflown exclusively or the current
@@ -128,7 +132,7 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
     else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
         handleMissedDeadline();
     }
-#endif
+
 }
 
 TaskHandle_t PeriodicTask::getTaskHandle() {
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 87b8b6d2f..80d00bf16 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -71,6 +71,7 @@ public:
 
 	TaskHandle_t getTaskHandle() override;
 protected:
+
 	bool started;
 	TaskHandle_t handle;
 

From 0c3e87f1deee38f1ee30acf8090c86377ebcb840 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 23:55:54 +0100
Subject: [PATCH 1198/1774] using new xTaskDelayUntil

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      |  6 +++
 osal/FreeRTOS/BinSemaphUsingTask.h        |  3 +-
 osal/FreeRTOS/CountingSemaphUsingTask.cpp |  5 ++
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  6 +++
 osal/FreeRTOS/FixedTimeslotTask.cpp       | 42 ++++++-----------
 osal/FreeRTOS/FixedTimeslotTask.h         |  2 -
 osal/FreeRTOS/FreeRTOSTaskIF.h            | 38 +++++++++++++--
 osal/FreeRTOS/PeriodicTask.cpp            | 28 ++---------
 osal/FreeRTOS/PeriodicTask.h              |  2 -
 osal/FreeRTOS/TaskManagement.cpp          |  1 +
 osal/FreeRTOS/TaskManagement.h            | 57 +++++++++++------------
 11 files changed, 98 insertions(+), 92 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 9c29948e9..a420ec489 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -2,6 +2,9 @@
 #include "TaskManagement.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
+#if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8
+
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
@@ -97,3 +100,6 @@ uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
 			higherPriorityTaskWoken);
 	return notificationValue;
 }
+
+#endif /* (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8 */
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 8a413d5ad..ec434853e 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -90,6 +90,7 @@ protected:
 	TaskHandle_t handle;
 };
 
-#endif
+#endif /* (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8 */
 
 #endif /* FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 17cdf7ce3..9d309acc3 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -3,6 +3,9 @@
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
+#if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8
+
 CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 		uint8_t initCount): maxCount(maxCount) {
 	if(initCount > maxCount) {
@@ -113,3 +116,5 @@ uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
 uint8_t CountingSemaphoreUsingTask::getMaxCount() const {
 	return maxCount;
 }
+
+#endif
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index f258197ba..45915b6b5 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -7,6 +7,9 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
+#if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8
+
 /**
  * @brief 	Couting Semaphore implementation which uses the notification value
  * 			of the task. The notification value should therefore not be used
@@ -100,4 +103,7 @@ private:
 	const uint8_t maxCount;
 };
 
+#endif /* (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8 */
+
 #endif /* FSFW_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 062686e2b..fc5b89fe0 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -114,38 +114,24 @@ void FixedTimeslotTask::taskFunctionality() {
 	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
 	        interval = pdMS_TO_TICKS(intervalMs);
 
-	        checkMissedDeadline(xLastWakeTime, interval);
-
-	        // Wait for the interval. This exits immediately if a deadline was
-	        // missed while also updating the last wake time.
-	        vTaskDelayUntil(&xLastWakeTime, interval);
+#if (tskKERNEL_VERSION_MAJOR == 10 && tskKERNEL_VERSION_MINOR >= 4) || \
+    tskKERNEL_VERSION_MAJOR > 10
+	        BaseType_t wasDelayed = xTaskDelayUntil(&xLastWakeTime, interval);
+	        if(wasDelayed == pdFALSE) {
+	            handleMissedDeadline();
+	        }
+#else
+            if(checkMissedDeadline(xLastWakeTime, interval)) {
+                handleMissedDeadline();
+            }
+            // Wait for the interval. This exits immediately if a deadline was
+            // missed while also updating the last wake time.
+            vTaskDelayUntil(&xLastWakeTime, interval);
+#endif
 	    }
 	}
 }
 
-void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-}
-
 void FixedTimeslotTask::handleMissedDeadline() {
     if(deadlineMissedFunc != nullptr) {
         this->deadlineMissedFunc();
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 7d2cdb703..f2245ba4a 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -93,8 +93,6 @@ protected:
 	 */
 	void taskFunctionality(void);
 
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
 	void handleMissedDeadline();
 };
 
diff --git a/osal/FreeRTOS/FreeRTOSTaskIF.h b/osal/FreeRTOS/FreeRTOSTaskIF.h
index 06fda2828..2a2d94947 100644
--- a/osal/FreeRTOS/FreeRTOSTaskIF.h
+++ b/osal/FreeRTOS/FreeRTOSTaskIF.h
@@ -1,13 +1,41 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_
-#define FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_
+#ifndef FSFW_OSAL_FREERTOS_FREERTOSTASKIF_H_
+#define FSFW_OSAL_FREERTOS_FREERTOSTASKIF_H_
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
 class FreeRTOSTaskIF {
 public:
-	virtual~ FreeRTOSTaskIF() {}
-	virtual TaskHandle_t getTaskHandle() = 0;
+    virtual~ FreeRTOSTaskIF() {}
+    virtual TaskHandle_t getTaskHandle() = 0;
+
+protected:
+
+    bool checkMissedDeadline(const TickType_t xLastWakeTime,
+            const TickType_t interval) {
+        /* Check whether deadline was missed while also taking overflows
+         * into account. Drawing this on paper with a timeline helps to understand
+         * it. */
+        TickType_t currentTickCount = xTaskGetTickCount();
+        TickType_t timeToWake = xLastWakeTime + interval;
+        // Time to wake has not overflown.
+        if(timeToWake > xLastWakeTime) {
+            /* If the current time has overflown exclusively or the current
+             * tick count is simply larger than the time to wake, a deadline was
+             * missed */
+            if((currentTickCount < xLastWakeTime) or
+                    (currentTickCount > timeToWake)) {
+                return true;
+            }
+        }
+        /* Time to wake has overflown. A deadline was missed if the current time
+         * is larger than the time to wake */
+        else if((timeToWake < xLastWakeTime) and
+                (currentTickCount > timeToWake)) {
+            return true;
+        }
+        return false;
+    }
 };
 
-#endif /* FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_ */
+#endif /* FSFW_OSAL_FREERTOS_FREERTOSTASKIF_H_ */
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 963891877..2ee7bec01 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -87,7 +87,9 @@ void PeriodicTask::taskFunctionality() {
 		    handleMissedDeadline();
 		}
 #else
-        checkMissedDeadline(xLastWakeTime, xPeriod);
+        if(checkMissedDeadline(xLastWakeTime, xPeriod)) {
+            handleMissedDeadline();
+        }
         vTaskDelayUntil(&xLastWakeTime, xPeriod);
 #endif
 	}
@@ -111,30 +113,6 @@ uint32_t PeriodicTask::getPeriodMs() const {
 	return period * 1000;
 }
 
-void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-
-}
-
 TaskHandle_t PeriodicTask::getTaskHandle() {
     return handle;
 }
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 80d00bf16..36ef568f6 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -119,8 +119,6 @@ protected:
 	 */
 	void taskFunctionality(void);
 
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
 	void handleMissedDeadline();
 };
 
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 18572045e..c0d0067e9 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -22,3 +22,4 @@ size_t TaskManagement::getTaskStackHighWatermark(
         TaskHandle_t task) {
 	return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
 }
+
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index c6c46f21c..b9aece48b 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -26,38 +26,37 @@ enum class CallContext {
 };
 
 
-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);
+namespace TaskManagement {
+/**
+ * @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.
+ */
+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);
+/**
+ * If task preemption in FreeRTOS is disabled, a context switch
+ * can be requested manually by calling this function.
+ */
+void vRequestContextSwitchFromTask(void);
 
-	/**
-	 * @return The current task handle
-	 */
-	static TaskHandle_t getCurrentTaskHandle();
+/**
+ * @return The current task handle
+ */
+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.
+ */
+size_t getTaskStackHighWatermark(TaskHandle_t task = nullptr);
 
-	/**
-	 * 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_ */

From 3cc053a58105c51828147e0ea92efaeb11418b59 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 23:56:44 +0100
Subject: [PATCH 1199/1774] changes from mueller/master taken over

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      |  6 +++
 osal/FreeRTOS/BinSemaphUsingTask.h        |  7 ++-
 osal/FreeRTOS/CountingSemaphUsingTask.cpp |  5 ++
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  6 +++
 osal/FreeRTOS/FixedTimeslotTask.cpp       | 42 ++++++-----------
 osal/FreeRTOS/FixedTimeslotTask.h         |  2 -
 osal/FreeRTOS/FreeRTOSTaskIF.h            | 38 +++++++++++++--
 osal/FreeRTOS/PeriodicTask.cpp            | 39 +++++-----------
 osal/FreeRTOS/PeriodicTask.h              |  3 +-
 osal/FreeRTOS/TaskManagement.cpp          |  1 +
 osal/FreeRTOS/TaskManagement.h            | 57 +++++++++++------------
 11 files changed, 111 insertions(+), 95 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 9c29948e9..a420ec489 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -2,6 +2,9 @@
 #include "TaskManagement.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
+#if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8
+
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
@@ -97,3 +100,6 @@ uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
 			higherPriorityTaskWoken);
 	return notificationValue;
 }
+
+#endif /* (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8 */
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 65a091a3f..ec434853e 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -7,8 +7,8 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
-// todo: does not work for older FreeRTOS version, so we should
-// actually check whether tskKERNEL_VERSION_MAJOR is larger than.. 7 or 8 ?
+#if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8
 
 /**
  * @brief 	Binary Semaphore implementation using the task notification value.
@@ -90,4 +90,7 @@ protected:
 	TaskHandle_t handle;
 };
 
+#endif /* (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8 */
+
 #endif /* FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 17cdf7ce3..9d309acc3 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -3,6 +3,9 @@
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
+#if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8
+
 CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 		uint8_t initCount): maxCount(maxCount) {
 	if(initCount > maxCount) {
@@ -113,3 +116,5 @@ uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
 uint8_t CountingSemaphoreUsingTask::getMaxCount() const {
 	return maxCount;
 }
+
+#endif
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index f258197ba..45915b6b5 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -7,6 +7,9 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
+#if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8
+
 /**
  * @brief 	Couting Semaphore implementation which uses the notification value
  * 			of the task. The notification value should therefore not be used
@@ -100,4 +103,7 @@ private:
 	const uint8_t maxCount;
 };
 
+#endif /* (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8 */
+
 #endif /* FSFW_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 062686e2b..fc5b89fe0 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -114,38 +114,24 @@ void FixedTimeslotTask::taskFunctionality() {
 	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
 	        interval = pdMS_TO_TICKS(intervalMs);
 
-	        checkMissedDeadline(xLastWakeTime, interval);
-
-	        // Wait for the interval. This exits immediately if a deadline was
-	        // missed while also updating the last wake time.
-	        vTaskDelayUntil(&xLastWakeTime, interval);
+#if (tskKERNEL_VERSION_MAJOR == 10 && tskKERNEL_VERSION_MINOR >= 4) || \
+    tskKERNEL_VERSION_MAJOR > 10
+	        BaseType_t wasDelayed = xTaskDelayUntil(&xLastWakeTime, interval);
+	        if(wasDelayed == pdFALSE) {
+	            handleMissedDeadline();
+	        }
+#else
+            if(checkMissedDeadline(xLastWakeTime, interval)) {
+                handleMissedDeadline();
+            }
+            // Wait for the interval. This exits immediately if a deadline was
+            // missed while also updating the last wake time.
+            vTaskDelayUntil(&xLastWakeTime, interval);
+#endif
 	    }
 	}
 }
 
-void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-}
-
 void FixedTimeslotTask::handleMissedDeadline() {
     if(deadlineMissedFunc != nullptr) {
         this->deadlineMissedFunc();
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 7d2cdb703..f2245ba4a 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -93,8 +93,6 @@ protected:
 	 */
 	void taskFunctionality(void);
 
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
 	void handleMissedDeadline();
 };
 
diff --git a/osal/FreeRTOS/FreeRTOSTaskIF.h b/osal/FreeRTOS/FreeRTOSTaskIF.h
index 06fda2828..2a2d94947 100644
--- a/osal/FreeRTOS/FreeRTOSTaskIF.h
+++ b/osal/FreeRTOS/FreeRTOSTaskIF.h
@@ -1,13 +1,41 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_
-#define FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_
+#ifndef FSFW_OSAL_FREERTOS_FREERTOSTASKIF_H_
+#define FSFW_OSAL_FREERTOS_FREERTOSTASKIF_H_
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
 class FreeRTOSTaskIF {
 public:
-	virtual~ FreeRTOSTaskIF() {}
-	virtual TaskHandle_t getTaskHandle() = 0;
+    virtual~ FreeRTOSTaskIF() {}
+    virtual TaskHandle_t getTaskHandle() = 0;
+
+protected:
+
+    bool checkMissedDeadline(const TickType_t xLastWakeTime,
+            const TickType_t interval) {
+        /* Check whether deadline was missed while also taking overflows
+         * into account. Drawing this on paper with a timeline helps to understand
+         * it. */
+        TickType_t currentTickCount = xTaskGetTickCount();
+        TickType_t timeToWake = xLastWakeTime + interval;
+        // Time to wake has not overflown.
+        if(timeToWake > xLastWakeTime) {
+            /* If the current time has overflown exclusively or the current
+             * tick count is simply larger than the time to wake, a deadline was
+             * missed */
+            if((currentTickCount < xLastWakeTime) or
+                    (currentTickCount > timeToWake)) {
+                return true;
+            }
+        }
+        /* Time to wake has overflown. A deadline was missed if the current time
+         * is larger than the time to wake */
+        else if((timeToWake < xLastWakeTime) and
+                (currentTickCount > timeToWake)) {
+            return true;
+        }
+        return false;
+    }
 };
 
-#endif /* FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_ */
+#endif /* FSFW_OSAL_FREERTOS_FREERTOSTASKIF_H_ */
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 5c0a840da..2ee7bec01 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -80,10 +80,18 @@ void PeriodicTask::taskFunctionality() {
 			object->performOperation();
 		}
 
-		checkMissedDeadline(xLastWakeTime, xPeriod);
-
-		vTaskDelayUntil(&xLastWakeTime, xPeriod);
-
+#if (tskKERNEL_VERSION_MAJOR == 10 && tskKERNEL_VERSION_MINOR >= 4) || \
+    tskKERNEL_VERSION_MAJOR > 10
+		BaseType_t wasDelayed = xTaskDelayUntil(&xLastWakeTime, xPeriod);
+		if(wasDelayed == pdFALSE) {
+		    handleMissedDeadline();
+		}
+#else
+        if(checkMissedDeadline(xLastWakeTime, xPeriod)) {
+            handleMissedDeadline();
+        }
+        vTaskDelayUntil(&xLastWakeTime, xPeriod);
+#endif
 	}
 }
 
@@ -105,29 +113,6 @@ uint32_t PeriodicTask::getPeriodMs() const {
 	return period * 1000;
 }
 
-void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-}
-
 TaskHandle_t PeriodicTask::getTaskHandle() {
     return handle;
 }
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 87b8b6d2f..36ef568f6 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -71,6 +71,7 @@ public:
 
 	TaskHandle_t getTaskHandle() override;
 protected:
+
 	bool started;
 	TaskHandle_t handle;
 
@@ -118,8 +119,6 @@ protected:
 	 */
 	void taskFunctionality(void);
 
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
 	void handleMissedDeadline();
 };
 
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 18572045e..c0d0067e9 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -22,3 +22,4 @@ size_t TaskManagement::getTaskStackHighWatermark(
         TaskHandle_t task) {
 	return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
 }
+
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index c6c46f21c..b9aece48b 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -26,38 +26,37 @@ enum class CallContext {
 };
 
 
-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);
+namespace TaskManagement {
+/**
+ * @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.
+ */
+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);
+/**
+ * If task preemption in FreeRTOS is disabled, a context switch
+ * can be requested manually by calling this function.
+ */
+void vRequestContextSwitchFromTask(void);
 
-	/**
-	 * @return The current task handle
-	 */
-	static TaskHandle_t getCurrentTaskHandle();
+/**
+ * @return The current task handle
+ */
+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.
+ */
+size_t getTaskStackHighWatermark(TaskHandle_t task = nullptr);
 
-	/**
-	 * 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_ */

From 052e2ed1e82128356c3cf8260d4d874d47ea53b6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 14:40:49 +0100
Subject: [PATCH 1200/1774] type update, assert that type is not boolean

---
 globalfunctions/Type.h | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 8d03c4677..d9d2356fd 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -3,6 +3,7 @@
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
+#include <type_traits>
 
 /**
  * @brief 	Type definition for CCSDS or ECSS.
@@ -56,13 +57,14 @@ private:
 
 template<typename T>
 struct PodTypeConversion {
+	static_assert(not std::is_same<T, bool>::value,
+				"Do not use boolean for the PoolEntry type, use uint8_t "
+				"instead! The ECSS standard defines a boolean as a one bit "
+				"field. Therefore it is preferred to store a boolean as an "
+				"uint8_t");
 	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
 };
 template<>
-struct PodTypeConversion<bool> {
-    static const Type::ActualType_t type = Type::UINT8_T;
-};
-template<>
 struct PodTypeConversion<uint8_t> {
 	static const Type::ActualType_t type = Type::UINT8_T;
 };

From f733a85a9c51a8612084f947485c33161d75346f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 14:41:33 +0100
Subject: [PATCH 1201/1774] type update

---
 globalfunctions/Type.h | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index d28f56ac8..fa894e3e9 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -3,6 +3,7 @@
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
+#include <type_traits>
 
 /**
  * @brief 	Type definition for CCSDS or ECSS.
@@ -56,13 +57,14 @@ private:
 
 template<typename T>
 struct PodTypeConversion {
+	static_assert(not std::is_same<T, bool>::value,
+				"Do not use boolean for the PoolEntry type, use uint8_t "
+				"instead! The ECSS standard defines a boolean as a one bit "
+				"field. Therefore it is preferred to store a boolean as an "
+				"uint8_t");
 	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
 };
 template<>
-struct PodTypeConversion<bool> {
-    static const Type::ActualType_t type = Type::UINT8_T;
-};
-template<>
 struct PodTypeConversion<uint8_t> {
 	static const Type::ActualType_t type = Type::UINT8_T;
 };

From a57af5852d9ce76cd3340e147e82bceffce92303 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 15:04:07 +0100
Subject: [PATCH 1202/1774] made check sequence

---
 subsystem/Subsystem.h | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index c3a72d542..a3f7de452 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -62,21 +62,6 @@ public:
 
 	virtual MessageQueueId_t getSequenceCommandQueue() const override;
 
-	/**
-	 * @brief    Checks whether a sequence, identified by a mode.
-	 * @param sequence
-	 * @return
-	 */
-	ReturnValue_t checkSequence(Mode_t sequence);
-
-	/**
-	 * @brief   Checks whether a sequence, identified by a mode list iterator
-	 *          and a fallback sequence.
-	 * @param iter
-	 * @return
-	 */
-	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter,
-	        Mode_t fallbackSequence);
 protected:
 
 	struct EntryPointer {
@@ -166,6 +151,21 @@ protected:
 
 	void cantKeepMode();
 
+	/**
+	 * @brief    Checks whether a sequence, identified by a mode.
+	 * @param sequence
+	 * @return
+	 */
+	ReturnValue_t checkSequence(Mode_t sequence);
+
+	/**
+	 * @brief   Checks whether a sequence, identified by a mode list iterator
+	 *          and a fallback sequence.
+	 * @param iter
+	 * @return
+	 */
+	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter,
+	        Mode_t fallbackSequence);
 };
 
 #endif /* FSFW_SUBSYSTEM_SUBSYSTEM_H_ */

From 4c152e9fd83f94916b36410a53d0c530b94c7d55 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 15:07:41 +0100
Subject: [PATCH 1203/1774] subsystem doc upodate

---
 subsystem/Subsystem.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index a3f7de452..69563643e 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -160,7 +160,8 @@ protected:
 
 	/**
 	 * @brief   Checks whether a sequence, identified by a mode list iterator
-	 *          and a fallback sequence.
+	 *          and a fallback sequence. Iterator needs to point to a valid
+	 *          sequence.
 	 * @param iter
 	 * @return
 	 */

From 103d8b8c6a1669c6dabf2d10b7b20505088fe58c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 15:12:31 +0100
Subject: [PATCH 1204/1774] fixed timeslot task IF

---
 tasks/FixedTimeslotTaskIF.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index a138db4e2..2fc7e0922 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -14,7 +14,8 @@ public:
 
 	/**
 	 * Add an object with a slot time and the execution step to the task.
-	 * The execution step shall be passed to the object.
+	 * The execution step will be passed to the object (e.g. as an operation
+	 * code in #performOperation)
 	 * @param componentId
 	 * @param slotTimeMs
 	 * @param executionStep

From 703d2590ffbf21603e37a2ecad50e3a7d1a767ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 15:20:08 +0100
Subject: [PATCH 1205/1774] update csb

---
 CHANGELOG                            | 4 ++++
 tmtcservices/CommandingServiceBase.h | 3 ++-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG b/CHANGELOG
index 7b07db082..2ddd76736 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -60,3 +60,7 @@ that DHB users adapt their polling sequence tables to perform this step. This st
 allows setting a unique ID. Event.cpp source file removed, functions now
 defined in header directly. Namespaces renamed. Functions declared `constexpr`
 now
+
+### Commanding Service Base
+
+- CSB uses the 
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 3611d7c62..e10f2ddd2 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -42,7 +42,8 @@ class CommandingServiceBase: public SystemObject,
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	// We could make this configurable via preprocessor and the FSFWConfig file.
-	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH = FSFW_CSB_FIFO_DEPTH;
+	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH =
+			fsfwconfig::FSFW_CSB_FIFO_DEPTH;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
 

From ca52255d300047093bf1939dfafec621b47eec7b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 15:20:32 +0100
Subject: [PATCH 1206/1774] update

---
 tmtcservices/CommandingServiceBase.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 3611d7c62..e10f2ddd2 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -42,7 +42,8 @@ class CommandingServiceBase: public SystemObject,
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	// We could make this configurable via preprocessor and the FSFWConfig file.
-	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH = FSFW_CSB_FIFO_DEPTH;
+	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH =
+			fsfwconfig::FSFW_CSB_FIFO_DEPTH;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
 

From 48aef068379cfd9cbb43f2a23481c7853b219b0a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 15:24:46 +0100
Subject: [PATCH 1207/1774] fsfwconfig update

---
 unittest/testcfg/FSFWConfig.h | 49 +++++++++++++++++++++--------------
 1 file changed, 30 insertions(+), 19 deletions(-)

diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 599345602..418992faf 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -1,36 +1,28 @@
-#ifndef CONFIG_FSFWCONFIG_H_
-#define CONFIG_FSFWCONFIG_H_
+#ifndef FSFWCONFIG_FSFWCONFIG_H_
+#define FSFWCONFIG_FSFWCONFIG_H_
 
-#include <FSFWVersion.h>
+#include <cstddef>
+#include <cstdint>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrese code size
+//! Reduced printout to further decrease code size
 //! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_REDUCED_PRINTOUT		0
+#define FSFW_ENHANCED_PRINTOUT		0
 
-//! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_DEBUGGING              0
-
-//! Defines the FIFO depth of each commanding service base which
-//! also determines how many commands a CSB service can handle in one cycle
-//! simulataneously. This will increase the required RAM for
-//! each CSB service !
-#define FSFW_CSB_FIFO_DEPTH			6
+//! Can be used to enable additional debugging printouts for developing the FSFW
+#define FSFW_PRINT_VERBOSITY_LEVEL   0
 
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
-#define FSFW_OBJ_EVENT_TRANSLATION	0
+#define FSFW_OBJ_EVENT_TRANSLATION	1
 
-//! If -DDEBUG is supplied in the build defines, there will be
-//! additional output which requires the translation files translateObjects
-//! and translateEvents (and their compiles source files)
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 //! Specify whether info events are printed too.
-#define FSFW_DEBUG_INFO             1
+#define FSFW_DEBUG_INFO				1
 #include <translateObjects.h>
 #include <translateEvents.h>
 #else
@@ -40,5 +32,24 @@
 //! will not be provided. This define should be set to 1 if this is the case.
 #define FSFW_NO_C99_IO 	1
 
+//! Specify whether a special mode store is used for Subsystem components.
+#define FSFW_USE_MODESTORE          0
 
-#endif /* CONFIG_FSFWCONFIG_H_ */
+namespace fsfwconfig {
+//! Default timestamp size. The default timestamp will be an eight byte CDC
+//! short timestamp.
+static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 8;
+
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 3;
+}
+
+#endif /* FSFWCONFIG_FSFWCONFIG_H_ */

From 72c54d59fac16ceaeb3d32458c6de5e28f60c18e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 15:32:56 +0100
Subject: [PATCH 1208/1774] fsfw config

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 1386bf66f..334f352a1 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -15,12 +15,6 @@
 //! Can be used to enable additional debugging printouts for developing the FSFW
 #define FSFW_PRINT_VERBOSITY_LEVEL   0
 
-//! Defines the FIFO depth of each commanding service base which
-//! also determines how many commands a CSB service can handle in one cycle
-//! simulataneously. This will increase the required RAM for
-//! each CSB service !
-#define FSFW_CSB_FIFO_DEPTH			6
-
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
@@ -52,6 +46,12 @@ static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 8;
 static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
 static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
 static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

From 82a83a50ee01613c4227407b846173555015b4b4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 15:39:33 +0100
Subject: [PATCH 1209/1774] change log update

---
 CHANGELOG | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG b/CHANGELOG
index 2ddd76736..68b457f49 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -63,4 +63,4 @@ now
 
 ### Commanding Service Base
 
-- CSB uses the 
+- CSB uses the new fsfwconfig::FSFW_CSB_FIFO_DEPTH variable to determine  the FIFO depth for each CSB instance. This variable has to be set in the FSFWConfig.h file

From 910e6817ef94b6692cde80be3bb3c759a22ff93c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 15:48:06 +0100
Subject: [PATCH 1210/1774] default cfg update

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 7e19235cd..334f352a1 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -15,23 +15,19 @@
 //! Can be used to enable additional debugging printouts for developing the FSFW
 #define FSFW_PRINT_VERBOSITY_LEVEL   0
 
-//! Defines the FIFO depth of each commanding service base which
-//! also determines how many commands a CSB service can handle in one cycle
-//! simulataneously. This will increase the required RAM for
-//! each CSB service !
-#define FSFW_CSB_FIFO_DEPTH			6
-
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
+#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
 #include <translateObjects.h>
 #include <translateEvents.h>
 #else
+#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities
@@ -50,6 +46,12 @@ static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 8;
 static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
 static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
 static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

From e39c4fe2a862706f5be1a00fb14b21daa9f097da Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 22:42:50 +0100
Subject: [PATCH 1211/1774] added hk service 3

---
 pus/Service3Housekeeping.cpp         | 295 +++++++++++++++++++++++++++
 pus/Service3Housekeeping.h           | 105 ++++++++++
 pus/servicepackets/Service3Packets.h |  21 ++
 3 files changed, 421 insertions(+)
 create mode 100644 pus/Service3Housekeeping.cpp
 create mode 100644 pus/Service3Housekeeping.h
 create mode 100644 pus/servicepackets/Service3Packets.h

diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
new file mode 100644
index 000000000..175af026b
--- /dev/null
+++ b/pus/Service3Housekeeping.cpp
@@ -0,0 +1,295 @@
+#include "Service3Housekeeping.h"
+#include "servicepackets/Service3Packets.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+
+
+Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid,
+			uint8_t serviceId):
+		CommandingServiceBase(objectId, apid, serviceId,
+		NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {}
+
+Service3Housekeeping::~Service3Housekeeping() {}
+
+ReturnValue_t Service3Housekeeping::isValidSubservice(uint8_t subservice) {
+	switch(static_cast<Subservice>(subservice)) {
+	case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
+	case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
+	case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+	case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+	case Subservice::REPORT_HK_REPORT_STRUCTURES:
+	case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES :
+	case Subservice::GENERATE_ONE_PARAMETER_REPORT:
+	case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
+	case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
+	case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
+		return HasReturnvaluesIF::RETURN_OK;
+	// Telemetry or invalid subservice.
+	case Subservice::HK_DEFINITIONS_REPORT:
+	case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
+	case Subservice::HK_REPORT:
+	case Subservice::DIAGNOSTICS_REPORT:
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service3Housekeeping::getMessageQueueAndObject(uint8_t subservice,
+		const uint8_t *tcData, size_t tcDataLen,
+		MessageQueueId_t *id, object_id_t *objectId) {
+	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
+	if(result != RETURN_OK) {
+		return result;
+	}
+	return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t Service3Housekeeping::checkAndAcquireTargetID(
+		object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) {
+	if(SerializeAdapter::deSerialize(objectIdToSet, &tcData, &tcDataLen,
+	        SerializeIF::Endianness::BIG) != HasReturnvaluesIF::RETURN_OK) {
+		return CommandingServiceBase::INVALID_TC;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+	// check HasLocalDataPoolIF property of target
+	HasLocalDataPoolIF* possibleTarget =
+			objectManager->get<HasLocalDataPoolIF>(*objectId);
+	if(possibleTarget == nullptr){
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+	*messageQueueToSet = possibleTarget->getCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service3Housekeeping::prepareCommand(CommandMessage* message,
+		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+		uint32_t *state, object_id_t objectId) {
+	switch(static_cast<Subservice>(subservice)) {
+	case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
+		return prepareReportingTogglingCommand(message, objectId, true, false,
+				tcData, tcDataLen);
+	case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
+		return prepareReportingTogglingCommand(message, objectId, false, false,
+				tcData, tcDataLen);
+	case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+		return prepareReportingTogglingCommand(message, objectId, true, true,
+				tcData, tcDataLen);
+	case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+		return prepareReportingTogglingCommand(message, objectId, false, true,
+				tcData, tcDataLen);
+	case Subservice::REPORT_HK_REPORT_STRUCTURES:
+		return prepareStructureReportingCommand(message, objectId, false, tcData,
+				tcDataLen);
+	case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES:
+		return prepareStructureReportingCommand(message, objectId, true, tcData,
+				tcDataLen);
+	case Subservice::GENERATE_ONE_PARAMETER_REPORT:
+		return prepareOneShotReportCommand(message, objectId, false,
+				tcData, tcDataLen);
+	case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
+		return prepareOneShotReportCommand(message, objectId, true,
+				tcData, tcDataLen);
+	case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
+		return prepareCollectionIntervalModificationCommand(message, objectId,
+				false, tcData, tcDataLen);
+	case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
+		return prepareCollectionIntervalModificationCommand(message, objectId,
+				true, tcData, tcDataLen);
+	case Subservice::HK_DEFINITIONS_REPORT:
+	case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
+	case Subservice::HK_REPORT:
+	case Subservice::DIAGNOSTICS_REPORT:
+		// Those are telemetry packets.
+		return CommandingServiceBase::INVALID_TC;
+	default:
+		// should never happen, subservice was already checked.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(
+		CommandMessage *command, object_id_t objectId,
+		bool enableReporting, bool isDiagnostics,
+		const uint8_t* tcData, size_t tcDataLen) {
+	if(tcDataLen < sizeof(sid_t)) {
+		// TC data should consist of object ID and set ID.
+		return CommandingServiceBase::INVALID_TC;
+	}
+
+	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
+	HousekeepingMessage::setToggleReportingCommand(command, targetSid,
+			enableReporting, isDiagnostics);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::prepareStructureReportingCommand(
+		CommandMessage *command, object_id_t objectId, bool isDiagnostics,
+		const uint8_t* tcData, size_t tcDataLen) {
+	if(tcDataLen < sizeof(sid_t)) {
+		// TC data should consist of object ID and set ID.
+		return CommandingServiceBase::INVALID_TC;
+	}
+
+	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
+	HousekeepingMessage::setStructureReportingCommand(command, targetSid,
+			isDiagnostics);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::prepareOneShotReportCommand(
+		CommandMessage *command, object_id_t objectId, bool isDiagnostics,
+		const uint8_t *tcData, size_t tcDataLen) {
+	if(tcDataLen < sizeof(sid_t)) {
+		// TC data should consist of object ID and set ID.
+		return CommandingServiceBase::INVALID_TC;
+	}
+
+	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
+	HousekeepingMessage::setOneShotReportCommand(command, targetSid,
+			isDiagnostics);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand(
+		CommandMessage *command, object_id_t objectId, bool isDiagnostics,
+		const uint8_t *tcData, size_t tcDataLen) {
+	if(tcDataLen < sizeof(sid_t) + sizeof(float)) {
+		// SID plus the size of the new collection intervL.
+		return CommandingServiceBase::INVALID_TC;
+	}
+
+	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
+	float newCollectionInterval = 0;
+	SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	HousekeepingMessage::setCollectionIntervalModificationCommand(command,
+			targetSid, newCollectionInterval, isDiagnostics);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
+		Command_t previousCommand, uint32_t *state,
+		CommandMessage* optionalNextCommand, object_id_t objectId,
+		bool *isStep) {
+	Command_t command = reply->getCommand();
+	switch(command) {
+
+	case(HousekeepingMessage::HK_REPORT): {
+		ReturnValue_t result = generateHkReply(reply,
+				static_cast<uint8_t>(Subservice::HK_REPORT));
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+
+	case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
+		ReturnValue_t result = generateHkReply(reply,
+				static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+
+    case(HousekeepingMessage::HK_DEFINITIONS_REPORT): {
+        return generateHkReply(reply, static_cast<uint8_t>(
+                Subservice::HK_DEFINITIONS_REPORT));
+        break;
+    }
+    case(HousekeepingMessage::DIAGNOSTICS_DEFINITION_REPORT): {
+        return generateHkReply(reply, static_cast<uint8_t>(
+                Subservice::DIAGNOSTICS_DEFINITION_REPORT));
+        break;
+    }
+
+	case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+
+	case(HousekeepingMessage::HK_REQUEST_FAILURE): {
+		failureParameter1 = objectId;
+		ReturnValue_t error = HasReturnvaluesIF::RETURN_FAILED;
+		HousekeepingMessage::getHkRequestFailureReply(reply,&error);
+		failureParameter2 = error;
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+
+	default:
+		sif::error << "Service3Housekeeping::handleReply: Invalid reply with "
+				<< "reply command " << command << "!" << std::endl;
+		return CommandingServiceBase::INVALID_REPLY;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Service3Housekeeping::handleUnrequestedReply(
+		CommandMessage* reply) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	Command_t command = reply->getCommand();
+
+	switch(command) {
+
+	case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
+		result = generateHkReply(reply,
+				static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
+		break;
+	}
+
+	case(HousekeepingMessage::HK_REPORT): {
+		result = generateHkReply(reply,
+				static_cast<uint8_t>(Subservice::HK_REPORT));
+		break;
+	}
+
+	default:
+		sif::error << "Service3Housekeeping::handleUnrequestedReply: Invalid "
+		        << "reply with " << "reply command " << command << "!"
+		        << std::endl;
+		return;
+	}
+
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		// Configuration error
+		sif::debug << "Service3Housekeeping::handleUnrequestedReply:"
+				<< "Could not generate reply!" << std::endl;
+	}
+}
+
+MessageQueueId_t Service3Housekeeping::getHkQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t Service3Housekeeping::generateHkReply(
+		const CommandMessage* hkMessage, uint8_t subserviceId) {
+	store_address_t storeId;
+
+	sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId);
+	auto resultPair = IPCStore->getData(storeId);
+	if(resultPair.first != HasReturnvaluesIF::RETURN_OK) {
+		return resultPair.first;
+	}
+
+	HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size());
+	return sendTmPacket(static_cast<uint8_t>(subserviceId),
+			hkPacket.hkData, hkPacket.hkSize, nullptr, 0);
+}
+
+sid_t Service3Housekeeping::buildSid(object_id_t objectId,
+		const uint8_t** tcData, size_t* tcDataLen) {
+	sid_t targetSid;
+	targetSid.objectId = objectId;
+	// skip deserialization of object ID, was already done.
+	*tcData += sizeof(object_id_t);
+	*tcDataLen -= sizeof(object_id_t);
+	// size check is expected to be performed beforehand!
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, tcData, tcDataLen,
+			SerializeIF::Endianness::BIG);
+	return targetSid;
+}
diff --git a/pus/Service3Housekeeping.h b/pus/Service3Housekeeping.h
new file mode 100644
index 000000000..269710ef3
--- /dev/null
+++ b/pus/Service3Housekeeping.h
@@ -0,0 +1,105 @@
+#ifndef FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_
+#define FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_
+
+#include "../housekeeping/AcceptsHkPacketsIF.h"
+#include "../housekeeping/HousekeepingMessage.h"
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief   Manges spacecraft housekeeping reports and
+ *          sends pool variables (temperature, GPS data ...) to ground.
+ *
+ * @details Full Documentation: ECSS-E70-41A or ECSS-E-ST-70-41C.
+ * Implementation based on PUS-C
+ *
+ * The housekeeping service type provides means to control and adapt the
+ * spacecraft reporting plan according to the mission phases.
+ * The housekeeping service type provides the visibility of any
+ * on-board parameters assembled in housekeeping parameter report structures
+ * or diagnostic parameter report structures as required for the mission.
+ * The parameter report structures used by the housekeeping service can
+ * be predefined on-board or created when needed.
+ *
+ * @author 	R. Mueller
+ * @ingroup pus_services
+ */
+class Service3Housekeeping: public CommandingServiceBase,
+		public AcceptsHkPacketsIF {
+public:
+	static constexpr uint8_t NUM_OF_PARALLEL_COMMANDS = 4;
+	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+
+	Service3Housekeeping(object_id_t objectId, uint16_t apid, uint8_t serviceId);
+	virtual~ Service3Housekeeping();
+protected:
+	/* CSB abstract functions implementation . See CSB documentation. */
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) override;
+
+	virtual MessageQueueId_t getHkQueue() const;
+private:
+	enum class Subservice {
+		ENABLE_PERIODIC_HK_REPORT_GENERATION = 5, //!< [EXPORT] : [TC]
+		DISABLE_PERIODIC_HK_REPORT_GENERATION = 6, //!< [EXPORT] : [TC]
+
+		ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION = 7, //!< [EXPORT] : [TC]
+		DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION = 8, //!< [EXPORT] : [TC]
+
+		//! [EXPORT] : [TC] Report HK structure by supplying SID
+		REPORT_HK_REPORT_STRUCTURES = 9,
+		//! [EXPORT] : [TC] Report Diagnostics structure by supplying SID
+		REPORT_DIAGNOSTICS_REPORT_STRUCTURES = 11,
+
+		//! [EXPORT] : [TM] Report corresponding to Subservice 9 TC
+		HK_DEFINITIONS_REPORT = 10,
+		//! [EXPORT] : [TM] Report corresponding to Subservice 11 TC
+		DIAGNOSTICS_DEFINITION_REPORT = 12,
+
+		//! [EXPORT] : [TM] Core packet. Contains Housekeeping data
+		HK_REPORT = 25,
+		//! [EXPORT] : [TM] Core packet. Contains diagnostics data
+		DIAGNOSTICS_REPORT = 26,
+
+		/* PUS-C */
+		GENERATE_ONE_PARAMETER_REPORT = 27, //!< [EXPORT] : [TC]
+		GENERATE_ONE_DIAGNOSTICS_REPORT = 28, //!< [EXPORT] : [TC]
+
+		MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL = 31, //!< [EXPORT] : [TC]
+		MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL = 32, //!< [EXPORT] : [TC]
+	};
+
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+			MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
+
+	ReturnValue_t generateHkReply(const CommandMessage* hkMessage,
+			uint8_t subserviceId);
+	ReturnValue_t prepareReportingTogglingCommand(CommandMessage* command,
+			object_id_t objectId, bool enableReporting, bool isDiagnostics,
+			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t prepareStructureReportingCommand(CommandMessage* command,
+			object_id_t objectId, bool isDiagnostics, const uint8_t* tcData,
+			size_t tcDataLen);
+	ReturnValue_t prepareOneShotReportCommand(CommandMessage* command,
+			object_id_t objectId, bool isDiagnostics, const uint8_t* tcData,
+			size_t tcDataLen);
+	ReturnValue_t prepareCollectionIntervalModificationCommand(
+			CommandMessage* command, object_id_t objectId, bool isDiagnostics,
+			const uint8_t* tcData, size_t tcDataLen);
+
+	void handleUnrequestedReply(CommandMessage* reply) override;
+	sid_t buildSid(object_id_t objectId, const uint8_t** tcData,
+			size_t* tcDataLen);
+};
+
+#endif /* FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_ */
diff --git a/pus/servicepackets/Service3Packets.h b/pus/servicepackets/Service3Packets.h
new file mode 100644
index 000000000..05732e11b
--- /dev/null
+++ b/pus/servicepackets/Service3Packets.h
@@ -0,0 +1,21 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE3PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE3PACKETS_H_
+
+#include <fsfw/housekeeping/HousekeepingMessage.h>
+#include <cstdint>
+
+/**
+ * @brief Subservices 25 and 26: TM packets
+ * @ingroup spacepackets
+ */
+class HkPacket { //!< [EXPORT] : [SUBSERVICE] 25, 26
+public:
+    sid_t sid; //!< [EXPORT] : [COMMENT] Structure ID (SID) of housekeeping data.
+    const uint8_t* hkData; //!< [EXPORT] : [MAXSIZE] Deduced size
+    size_t hkSize; //!< [EXPORT] : [IGNORE]
+
+    HkPacket(sid_t sid, const uint8_t* data, size_t size):
+            sid(sid), hkData(data), hkSize(size) {}
+};
+
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE3PACKETS_H_ */

From 1f7938f610ca08e35add7264036104d2ecc0280f Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 22:46:55 +0100
Subject: [PATCH 1212/1774] deleted archive folder

---
 archive/datapoolglob/ControllerSet.cpp        |  14 -
 archive/datapoolglob/ControllerSet.h          |  15 -
 archive/datapoolglob/DataPoolAdmin.cpp        | 301 ------------------
 archive/datapoolglob/DataPoolAdmin.h          |  60 ----
 .../datapoolglob/DataPoolParameterWrapper.cpp | 179 -----------
 .../datapoolglob/DataPoolParameterWrapper.h   |  38 ---
 archive/datapoolglob/GlobalDataPool.cpp       | 133 --------
 archive/datapoolglob/GlobalDataPool.h         | 149 ---------
 archive/datapoolglob/GlobalDataSet.cpp        |  48 ---
 archive/datapoolglob/GlobalDataSet.h          |  98 ------
 archive/datapoolglob/GlobalPoolVariable.h     | 213 -------------
 archive/datapoolglob/GlobalPoolVariable.tpp   | 117 -------
 archive/datapoolglob/GlobalPoolVector.h       | 185 -----------
 archive/datapoolglob/GlobalPoolVector.tpp     | 117 -------
 archive/datapoolglob/PIDReader.h              | 164 ----------
 archive/datapoolglob/PIDReaderList.h          |  27 --
 archive/datapoolglob/PoolRawAccess.cpp        | 239 --------------
 archive/datapoolglob/PoolRawAccess.h          | 220 -------------
 18 files changed, 2317 deletions(-)
 delete mode 100644 archive/datapoolglob/ControllerSet.cpp
 delete mode 100644 archive/datapoolglob/ControllerSet.h
 delete mode 100644 archive/datapoolglob/DataPoolAdmin.cpp
 delete mode 100644 archive/datapoolglob/DataPoolAdmin.h
 delete mode 100644 archive/datapoolglob/DataPoolParameterWrapper.cpp
 delete mode 100644 archive/datapoolglob/DataPoolParameterWrapper.h
 delete mode 100644 archive/datapoolglob/GlobalDataPool.cpp
 delete mode 100644 archive/datapoolglob/GlobalDataPool.h
 delete mode 100644 archive/datapoolglob/GlobalDataSet.cpp
 delete mode 100644 archive/datapoolglob/GlobalDataSet.h
 delete mode 100644 archive/datapoolglob/GlobalPoolVariable.h
 delete mode 100644 archive/datapoolglob/GlobalPoolVariable.tpp
 delete mode 100644 archive/datapoolglob/GlobalPoolVector.h
 delete mode 100644 archive/datapoolglob/GlobalPoolVector.tpp
 delete mode 100644 archive/datapoolglob/PIDReader.h
 delete mode 100644 archive/datapoolglob/PIDReaderList.h
 delete mode 100644 archive/datapoolglob/PoolRawAccess.cpp
 delete mode 100644 archive/datapoolglob/PoolRawAccess.h

diff --git a/archive/datapoolglob/ControllerSet.cpp b/archive/datapoolglob/ControllerSet.cpp
deleted file mode 100644
index 54fc6e8c9..000000000
--- a/archive/datapoolglob/ControllerSet.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <fsfw/datapoolglob/ControllerSet.h>
-
-ControllerSet::ControllerSet() {
-
-}
-
-ControllerSet::~ControllerSet() {
-}
-
-void ControllerSet::setInvalid() {
-	read();
-	setToDefault();
-	commit(PoolVariableIF::INVALID);
-}
diff --git a/archive/datapoolglob/ControllerSet.h b/archive/datapoolglob/ControllerSet.h
deleted file mode 100644
index 5da113973..000000000
--- a/archive/datapoolglob/ControllerSet.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef FSFW_DATAPOOLGLOB_CONTROLLERSET_H_
-#define FSFW_DATAPOOLGLOB_CONTROLLERSET_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-
-class ControllerSet :public GlobDataSet {
-public:
-	ControllerSet();
-	virtual ~ControllerSet();
-
-	virtual void setToDefault() = 0;
-	void setInvalid();
-};
-
-#endif /*  FSFW_DATAPOOLGLOB_CONTROLLERSET_H_ */
diff --git a/archive/datapoolglob/DataPoolAdmin.cpp b/archive/datapoolglob/DataPoolAdmin.cpp
deleted file mode 100644
index 2bae75f09..000000000
--- a/archive/datapoolglob/DataPoolAdmin.cpp
+++ /dev/null
@@ -1,301 +0,0 @@
-#include "DataPoolAdmin.h"
-#include "GlobalDataSet.h"
-#include "GlobalDataPool.h"
-#include "PoolRawAccess.h"
-
-#include "../ipc/CommandMessage.h"
-#include "../ipc/QueueFactory.h"
-#include "../parameters/ParameterMessage.h"
-
-DataPoolAdmin::DataPoolAdmin(object_id_t objectId) :
-		SystemObject(objectId), storage(NULL), commandQueue(NULL), memoryHelper(
-				this, NULL), actionHelper(this, NULL) {
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-DataPoolAdmin::~DataPoolAdmin() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t DataPoolAdmin::performOperation(uint8_t opCode) {
-	handleCommand();
-	return RETURN_OK;
-}
-
-MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
-	if (actionId != SET_VALIDITY) {
-		return INVALID_ACTION_ID;
-	}
-
-	if (size != 5) {
-		return INVALID_PARAMETERS;
-	}
-
-	uint32_t address = (data[0] << 24) | (data[1] << 16) | (data[2] << 8)
-			| data[3];
-
-	uint8_t valid = data[4];
-
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-
-	GlobDataSet mySet;
-	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
-	ReturnValue_t status = mySet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	if (valid != 0) {
-		variable.setValid(PoolVariableIF::VALID);
-	} else {
-		variable.setValid(PoolVariableIF::INVALID);
-	}
-
-	mySet.commit();
-
-	return EXECUTION_FINISHED;
-}
-
-ReturnValue_t DataPoolAdmin::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-void DataPoolAdmin::handleCommand() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != RETURN_OK) {
-		return;
-	}
-
-	result = actionHelper.handleActionMessage(&command);
-
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-
-	result = handleParameterCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-
-	result = memoryHelper.handleMemoryCommand(&command);
-	if (result != RETURN_OK) {
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
-}
-
-ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
-		const uint8_t* data, size_t size, uint8_t** dataPointer) {
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
-	GlobDataSet testSet;
-	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
-			PoolVariableIF::VAR_READ);
-	ReturnValue_t status = testSet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	uint8_t typeSize = varToGetSize.getSizeOfType();
-
-	if (size % typeSize != 0) {
-		return INVALID_SIZE;
-	}
-
-	if (size > varToGetSize.getSizeTillEnd()) {
-		return INVALID_SIZE;
-	}
-	const uint8_t* readPosition = data;
-
-	for (; size > 0; size -= typeSize) {
-		GlobDataSet rawSet;
-		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
-				PoolVariableIF::VAR_READ_WRITE);
-		status = rawSet.read();
-		if (status == RETURN_OK) {
-			status = variable.setEntryFromBigEndian(readPosition, typeSize);
-			if (status == RETURN_OK) {
-				status = rawSet.commit();
-			}
-		}
-		arrayIndex += 1;
-		readPosition += typeSize;
-	}
-	return ACTIVITY_COMPLETED;
-}
-
-ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
-		uint8_t** dataPointer, uint8_t* copyHere) {
-	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
-	GlobDataSet testSet;
-	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
-			PoolVariableIF::VAR_READ);
-	ReturnValue_t status = testSet.read();
-	if (status != RETURN_OK) {
-		return INVALID_ADDRESS;
-	}
-	uint8_t typeSize = varToGetSize.getSizeOfType();
-	if (size > varToGetSize.getSizeTillEnd()) {
-		return INVALID_SIZE;
-	}
-	uint8_t* ptrToCopy = copyHere;
-	for (; size > 0; size -= typeSize) {
-		GlobDataSet rawSet;
-		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
-				PoolVariableIF::VAR_READ);
-		status = rawSet.read();
-		if (status == RETURN_OK) {
-			size_t temp = 0;
-			status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
-			if (status != RETURN_OK) {
-				return RETURN_FAILED;
-			}
-		} else {
-			//Error reading parameter.
-		}
-		arrayIndex += 1;
-		ptrToCopy += typeSize;
-	}
-	return ACTIVITY_COMPLETED;
-}
-
-ReturnValue_t DataPoolAdmin::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = memoryHelper.initialize(commandQueue);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (storage == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	result = actionHelper.initialize(commandQueue);
-
-	return result;
-}
-
-//mostly identical to ParameterHelper::handleParameterMessage()
-ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch (command->getCommand()) {
-	case ParameterMessage::CMD_PARAMETER_DUMP: {
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getUniqueIdentifierId(
-				ParameterMessage::getParameterId(command));
-
-		DataPoolParameterWrapper wrapper;
-		result = wrapper.set(domain, parameterId);
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(command->getSender(),
-					ParameterMessage::getParameterId(command), &wrapper);
-		}
-	}
-		break;
-	case ParameterMessage::CMD_PARAMETER_LOAD: {
-
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(command));
-		uint8_t parameterId = HasParametersIF::getUniqueIdentifierId(
-				ParameterMessage::getParameterId(command));
-		uint16_t index = HasParametersIF::getIndex(
-				ParameterMessage::getParameterId(command));
-
-		const uint8_t *storedStream;
-		size_t storedStreamSize;
-		result = storage->getData(ParameterMessage::getStoreId(command),
-				&storedStream, &storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-
-		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(storedStream, storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(command));
-			break;
-		}
-
-		DataPoolParameterWrapper poolWrapper;
-		result = poolWrapper.set(domain, parameterId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(command));
-			break;
-		}
-
-		result = poolWrapper.copyFrom(&streamWrapper, index);
-
-		storage->deleteData(ParameterMessage::getStoreId(command));
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(command->getSender(),
-					ParameterMessage::getParameterId(command), &poolWrapper);
-		}
-	}
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		rejectCommand(command->getSender(), result, command->getCommand());
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-//identical to ParameterHelper::sendParameter()
-ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
-		const DataPoolParameterWrapper* wrapper) {
-	size_t serializedSize = wrapper->getSerializedSize();
-
-	uint8_t *storeElement;
-	store_address_t address;
-
-	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
-			&storeElement);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	size_t storeElementSize = 0;
-
-	result = wrapper->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		storage->deleteData(address);
-		return result;
-	}
-
-	CommandMessage reply;
-
-	ParameterMessage::setParameterDumpReply(&reply, id, address);
-
-	commandQueue->sendMessage(to, &reply);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//identical to ParameterHelper::rejectCommand()
-void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-		Command_t initialCommand) {
-	CommandMessage reply;
-	reply.setReplyRejected(reason, initialCommand);
-	commandQueue->sendMessage(to, &reply);
-}
diff --git a/archive/datapoolglob/DataPoolAdmin.h b/archive/datapoolglob/DataPoolAdmin.h
deleted file mode 100644
index d8871b651..000000000
--- a/archive/datapoolglob/DataPoolAdmin.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_
-#define FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_
-
-#include "DataPoolParameterWrapper.h"
-
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../action/HasActionsIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../parameters/ReceivesParameterMessagesIF.h"
-#include "../action/SimpleActionHelper.h"
-#include "../memory/MemoryHelper.h"
-
-
-class DataPoolAdmin: public HasActionsIF,
-		public ExecutableObjectIF,
-		public AcceptsMemoryMessagesIF,
-		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF,
-		public SystemObject {
-public:
-	static const ActionId_t SET_VALIDITY = 1;
-
-	DataPoolAdmin(object_id_t objectId);
-
-	~DataPoolAdmin();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
-			size_t size, uint8_t** dataPointer);
-	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
-			uint8_t** dataPointer, uint8_t* copyHere);
-
-	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
-
-	//not implemented as ParameterHelper is no used
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-	ReturnValue_t initialize();
-private:
-	StorageManagerIF *storage;
-	MessageQueueIF* commandQueue;
-	MemoryHelper memoryHelper;
-	SimpleActionHelper actionHelper;
-	void handleCommand();
-	ReturnValue_t handleParameterCommand(CommandMessage *command);
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
-			const DataPoolParameterWrapper* wrapper);
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-			Command_t initialCommand);
-};
-
-#endif /* FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_ */
diff --git a/archive/datapoolglob/DataPoolParameterWrapper.cpp b/archive/datapoolglob/DataPoolParameterWrapper.cpp
deleted file mode 100644
index e5d55006d..000000000
--- a/archive/datapoolglob/DataPoolParameterWrapper.cpp
+++ /dev/null
@@ -1,179 +0,0 @@
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/DataPoolParameterWrapper.h"
-#include "../datapoolglob/PoolRawAccess.h"
-#include "../parameters/HasParametersIF.h"
-
-
-DataPoolParameterWrapper::DataPoolParameterWrapper() :
-		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
-				PoolVariableIF::NO_PARAMETER) {
-
-}
-
-DataPoolParameterWrapper::~DataPoolParameterWrapper() {
-
-}
-
-ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
-		uint16_t parameterId) {
-	poolId = (domainId << 16) + parameterId;
-
-	GlobDataSet mySet;
-	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
-	ReturnValue_t status = mySet.read();
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		//should only fail for invalid pool id
-		return HasParametersIF::INVALID_IDENTIFIER_ID;
-	}
-
-	type = raw.getType();
-	rows = raw.getArraySize();
-	columns = 1;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result;
-
-	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&columns, buffer, size,
-			maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	for (uint8_t index = 0; index < rows; index++){
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
-		mySet.read();
-		result = raw.serialize(buffer,size,maxSize,streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//same as ParameterWrapper
-size_t DataPoolParameterWrapper::getSerializedSize() const {
-	size_t serializedSize = 0;
-	serializedSize += type.getSerializedSize();
-	serializedSize += sizeof(rows);
-	serializedSize += sizeof(columns);
-	serializedSize += rows * columns * type.getSize();
-
-	return serializedSize;
-}
-
-ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-template<typename T>
-ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
-		uint8_t startingColumn, const void* from, uint8_t fromRows) {
-	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t *) from;
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-
-	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
-
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
-				PoolVariableIF::VAR_READ_WRITE);
-		mySet.read();
-
-		result = raw.setEntryFromBigEndian(fromAsStream, sizeof(T));
-
-		fromAsStream += sizeof(T);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		mySet.commit();
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::copyFrom(const ParameterWrapper* from,
-		uint16_t startWritingAtIndex) {
-	if (poolId == PoolVariableIF::NO_PARAMETER) {
-		return ParameterWrapper::NOT_SET;
-	}
-
-	if (type != from->type) {
-		return ParameterWrapper::DATATYPE_MISSMATCH;
-	}
-
-	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
-
-	if ((from->rows > (rows - startingRow))
-			|| (from->columns > (columns - startingColumn))) {
-		return ParameterWrapper::TOO_BIG;
-	}
-
-	ReturnValue_t result;
-	//copy data
-	if (from->pointsToStream) {
-		switch (type) {
-		case Type::UINT8_T:
-			result = deSerializeData<uint8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT8_T:
-			result = deSerializeData<int8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT16_T:
-			result = deSerializeData<uint16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT16_T:
-			result = deSerializeData<int16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT32_T:
-			result = deSerializeData<uint32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT32_T:
-			result = deSerializeData<int32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::FLOAT:
-			result = deSerializeData<float>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::DOUBLE:
-			result = deSerializeData<double>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		default:
-			result = ParameterWrapper::UNKNOW_DATATYPE;
-			break;
-		}
-	} else {
-		//not supported
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	return result;
-}
diff --git a/archive/datapoolglob/DataPoolParameterWrapper.h b/archive/datapoolglob/DataPoolParameterWrapper.h
deleted file mode 100644
index b1e505a75..000000000
--- a/archive/datapoolglob/DataPoolParameterWrapper.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef DATAPOOLPARAMETERWRAPPER_H_
-#define DATAPOOLPARAMETERWRAPPER_H_
-
-#include "../globalfunctions/Type.h"
-#include "../parameters/ParameterWrapper.h"
-
-class DataPoolParameterWrapper: public SerializeIF {
-public:
-	DataPoolParameterWrapper();
-	virtual ~DataPoolParameterWrapper();
-
-	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
-
-	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;
-
-	ReturnValue_t copyFrom(const ParameterWrapper *from,
-			uint16_t startWritingAtIndex);
-
-private:
-	Type type;
-	uint8_t rows;
-	uint8_t columns;
-
-	uint32_t poolId;
-
-	template<typename T>
-	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
-			const void *from, uint8_t fromRows);
-
-};
-
-#endif /* DATAPOOLPARAMETERWRAPPER_H_ */
diff --git a/archive/datapoolglob/GlobalDataPool.cpp b/archive/datapoolglob/GlobalDataPool.cpp
deleted file mode 100644
index afb27b772..000000000
--- a/archive/datapoolglob/GlobalDataPool.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../ipc/MutexFactory.h"
-
-GlobalDataPool::GlobalDataPool(
-		void(*initFunction)(GlobPoolMap* pool_map)) {
-	mutex = MutexFactory::instance()->createMutex();
-	if (initFunction != NULL ) {
-		initFunction( &this->globDataPool );
-	}
-}
-
-GlobalDataPool::~GlobalDataPool() {
-	MutexFactory::instance()->deleteMutex(mutex);
-	for(GlobPoolMapIter it = this->globDataPool.begin();
-	    it != this->globDataPool.end(); ++it )
-	{
-		delete it->second;
-	}
-}
-
-// The function checks PID, type and array length before returning a copy of
-// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
-template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
-		uint8_t sizeOrPosition ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
-		if (entry != nullptr ) {
-			if ( sizeOrPosition <= entry->length ) {
-				return entry;
-			}
-		}
-	}
-	return nullptr;
-}
-
-PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		return it->second;
-	} else {
-		return nullptr;
-	}
-}
-
-ReturnValue_t GlobalDataPool::unlockDataPool() {
-	ReturnValue_t status = mutex->unlockMutex();
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: unlock of mutex failed with"
-				" error code: " << status << std::endl;
-	}
-	return status;
-}
-
-ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
-	        timeoutMs);
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: lock of mutex failed "
-				"with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-void GlobalDataPool::print() {
-	sif::debug << "DataPool contains: " << std::endl;
-	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
-	dataPoolIt = this->globDataPool.begin();
-	while( dataPoolIt != this->globDataPool.end() ) {
-		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
-		dataPoolIt->second->print();
-		dataPoolIt++;
-	}
-}
-
-uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
-	return (parameter_id >> 8) & 0x00FFFFFF;
-}
-
-uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
-	return (parameter_id & 0x000000FF);
-}
-
-uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
-	return (poolId << 8) + index;
-}
-
-
-//SHOULDDO: Do we need a mutex lock here... I don't think so,
-//as we only check static const values of elements in a list that do not change.
-//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
-ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
-	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
-	if ( it != this->globDataPool.end() ) {
-		*type = it->second->getType();
-		return RETURN_OK;
-	} else {
-		*type = Type::UNKNOWN_TYPE;
-		return RETURN_FAILED;
-	}
-}
-
-bool GlobalDataPool::exists(uint32_t parameterId) {
-	uint32_t poolId = PIDToDataPoolId(parameterId);
-	uint32_t index = PIDToArrayIndex(parameterId);
-	GlobPoolMapIter it = this->globDataPool.find( poolId );
-	if (it != globDataPool.end()) {
-		if (it->second->getSize() >= index) {
-			return true;
-		}
-	}
-	return false;
-}
-
-template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
-		uint32_t data_pool_id, uint8_t size);
-template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<float>* GlobalDataPool::getData<float>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<double>* GlobalDataPool::getData<double>(
-		uint32_t data_pool_id, uint8_t size);
diff --git a/archive/datapoolglob/GlobalDataPool.h b/archive/datapoolglob/GlobalDataPool.h
deleted file mode 100644
index ce5b132c0..000000000
--- a/archive/datapoolglob/GlobalDataPool.h
+++ /dev/null
@@ -1,149 +0,0 @@
-#ifndef GLOBALDATAPOOL_H_
-#define GLOBALDATAPOOL_H_
-
-#include "../datapool/PoolEntry.h"
-#include "../globalfunctions/Type.h"
-#include "../ipc/MutexIF.h"
-#include <map>
-
-/**
- * @defgroup data_pool Global data pool
- * This is the group, where all classes associated with global
- * data pool handling belong to.
- * This includes classes to access Data Pool variables.
- */
-
-/**
- * Typedefs for the global pool representations
- */
-using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
-using GlobPoolMapIter = GlobPoolMap::iterator;
-
-/**
- * @brief		This class represents the OBSW global data-pool.
- *
- * @details
- * All variables are registered and space is allocated in an initialization
- * function, which is passed do the constructor. Space for the variables is
- * allocated on the heap (with a new call).
- *
- * The data is found by a data pool id, which uniquely represents a variable.
- * Data pool variables should be used with a blackboard logic in mind,
- * which means read data is valid (if flagged so),
- * but not necessarily up-to-date.
- *
- * Variables are either single values or arrays.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class GlobalDataPool : public HasReturnvaluesIF {
-private:
-	/**
-	 * @brief	This is the actual data pool itself.
-	 * @details	It is represented by a map with the data pool id as index
-	 * 			and a pointer to a single PoolEntry as value.
-	 */
-	GlobPoolMap globDataPool;
-
-	/**
-	 * @brief	The mutex is created in the constructor and makes
-	 * 			access mutual exclusive.
-	 * @details	Locking and unlocking the pool is only done by the DataSet class.
-	 */
-	MutexIF*	mutex;
-public:
-	/**
-	 * @brief	In the classes constructor,
-	 * 			the passed initialization function is called.
-	 * @details
-	 * To enable filling the pool, a pointer to the map is passed,
-	 * allowing direct access to the pool's content.
-	 * On runtime, adding or removing variables is forbidden.
-	 */
-	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
-
-	/**
-	 * 	@brief	The destructor iterates through the data_pool map and
-	 * 			calls all entries destructors to clean up the heap.
-	 */
-	~GlobalDataPool();
-
-	/**
-	 * @brief	This is the default call to access the pool.
-	 * @details
-	 * A pointer to the PoolEntry object is returned.
-	 * The call checks data pool id, type and array size.
-	 * Returns NULL in case of failure.
-	 * @param data_pool_id	The data pool id to search.
-	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
-	 * or the position the user wants to read.
-	 * 			If smaller than the entry size, everything's ok.
-	 */
-	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
-			uint8_t sizeOrPosition );
-
-	/**
-	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
-	 * 			(i.e. in Housekeeping Telemetry).
-	 * @details	It returns a basic interface and does NOT perform
-	 * 			a size check. The caller has to assure he does not copy too much data.
-	 * 			Returns NULL in case the entry is not found.
-	 * @param data_pool_id	The data pool id to search.
-	 */
-	PoolEntryIF* getRawData( uint32_t data_pool_id );
-	/**
-	 * @brief	This is a small helper function to facilitate locking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
-	/**
-	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to free the mutex.
-	 */
-	ReturnValue_t unlockDataPool();
-	/**
-	 * @brief	The print call is a simple debug method.
-	 * @details	It prints the current content of the data pool.
-	 *  		It iterates through the data_pool map and calls each entry's print() method.
-	 */
-	void print();
-	/**
-	 * Extracts the data pool id from a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The data pool id as used within the OBSW.
-	 */
-	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
-	/**
-	 * Extracts an array index out of a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The index of the corresponding data pool entry.
-	 */
-	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
-	/**
-	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
-	 */
-	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
-
-	/**
-	 * Method to return the type of a pool variable.
-	 * @param parameter_id A parameterID (not pool id) of a DP member.
-	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
-	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
-	 */
-	ReturnValue_t getType( uint32_t parameter_id, Type* type );
-
-	/**
-	 * Method to check if a PID exists. Does not lock, as there's no
-	 * possibility to alter the list that is checked during run-time.
-	 * @param parameterId The PID (not pool id!) of a parameter.
-	 * @return	true if exists, false else.
-	 */
-	bool exists(uint32_t parameterId);
-};
-
-//We assume someone globally instantiates a DataPool.
-namespace glob {
-extern GlobalDataPool dataPool;
-}
-
-#endif /* DATAPOOL_H_ */
diff --git a/archive/datapoolglob/GlobalDataSet.cpp b/archive/datapoolglob/GlobalDataSet.cpp
deleted file mode 100644
index 1e99f8051..000000000
--- a/archive/datapoolglob/GlobalDataSet.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-GlobDataSet::GlobDataSet(): PoolDataSetBase(
-        reinterpret_cast<PoolVariableIF**>(&registeredVariables),
-        DATA_SET_MAX_SIZE) {}
-
-// Don't do anything with your variables, they are dead already!
-// (Destructor is already called)
-GlobDataSet::~GlobDataSet() {}
-
-ReturnValue_t GlobDataSet::commit(bool valid, uint32_t lockTimeout) {
-	setEntriesValid(valid);
-	setSetValid(valid);
-	return commit(lockTimeout);
-}
-
-ReturnValue_t GlobDataSet::commit(uint32_t lockTimeout) {
-	return PoolDataSetBase::commit(lockTimeout);
-}
-
-bool GlobDataSet::isValid() const {
-    return this->valid;
-}
-
-ReturnValue_t GlobDataSet::unlockDataPool() {
-	return glob::dataPool.unlockDataPool();
-}
-
-ReturnValue_t GlobDataSet::lockDataPool(uint32_t timeoutMs) {
-	return glob::dataPool.lockDataPool(timeoutMs);
-}
-
-void GlobDataSet::setEntriesValid(bool valid) {
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ) {
-			registeredVariables[count]->setValid(valid);
-		}
-	}
-}
-
-void GlobDataSet::setSetValid(bool valid) {
-	this->valid = valid;
-}
-
-
diff --git a/archive/datapoolglob/GlobalDataSet.h b/archive/datapoolglob/GlobalDataSet.h
deleted file mode 100644
index 2f0edbd5c..000000000
--- a/archive/datapoolglob/GlobalDataSet.h
+++ /dev/null
@@ -1,98 +0,0 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_DATASET_H_
-#define FRAMEWORK_DATAPOOLGLOB_DATASET_H_
-
-#include "../datapool/PoolDataSetBase.h"
-
-/**
- * @brief	The DataSet class manages a set of locally checked out variables
- * 			for the global data pool.
- * @details
- * This class uses the read-commit() semantic provided by the DataSetBase class.
- * It extends the base class by using the global data pool,
- * having a valid state and implementing lock und unlock calls for the global
- * datapool.
- *
- * For more information on how this class works, see the DataSetBase
- * documentation.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class GlobDataSet: public PoolDataSetBase {
-public:
-
-	/**
-	 * @brief	Creates an empty GlobDataSet. Use registerVariable or
-	 * 			supply a pointer to this dataset to PoolVariable
-	 * 			initializations to register pool variables.
-	 */
-	GlobDataSet();
-
-	/**
-	 * @brief	The destructor automatically manages writing the valid
-	 * 			information of variables.
-	 * @details
-	 * In case the data set was read out, but not committed(indicated by state),
-	 * the destructor parses all variables that are still registered to the set.
-	 * For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~GlobDataSet();
-
-	/**
-	 * Variant of method above which sets validity of all elements of the set.
-	 * @param valid Validity information from PoolVariableIF.
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
-	 * 			     contains non write-only variables
-	 */
-	ReturnValue_t commit(bool valid, uint32_t lockTimeout = MutexIF::BLOCKING);
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-	/**
-	 * Set all entries
-	 * @param valid
-	 */
-	void setSetValid(bool valid);
-
-	bool isValid() const override;
-
-	/**
-	 * Set the valid information of all variables contained in the set which
-	 * are not read-only
-	 *
-	 * @param valid Validity information from PoolVariableIF.
-	 */
-	void setEntriesValid(bool valid);
-
-	//!< This definition sets the maximum number of variables to
-	//! register in one DataSet.
-	static const uint8_t DATA_SET_MAX_SIZE = 63;
-
-private:
-	/**
-	 * If the valid state of a dataset is always relevant to the whole
-	 * data set we can use this flag.
-	 */
-	bool valid = false;
-
-	/**
-	 * @brief	This is a small helper function to facilitate locking
-	 * 			the global data pool.
-	 * @details
-	 * It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
-	/**
-	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the global data pool
-	 * @details
-	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	ReturnValue_t unlockDataPool() override;
-
-	void handleAlreadyReadDatasetCommit();
-	ReturnValue_t handleUnreadDatasetCommit();
-
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-};
-
-#endif /* FRAMEWORK_DATAPOOLGLOB_DATASET_H_ */
diff --git a/archive/datapoolglob/GlobalPoolVariable.h b/archive/datapoolglob/GlobalPoolVariable.h
deleted file mode 100644
index a995bfaf2..000000000
--- a/archive/datapoolglob/GlobalPoolVariable.h
+++ /dev/null
@@ -1,213 +0,0 @@
-#ifndef GLOBALPOOLVARIABLE_H_
-#define GLOBALPOOLVARIABLE_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-template<typename T, uint8_t n_var> class PoolVarList;
-
-
-/**
- * @brief	This is the access class for non-array data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly
- * on the data pool entries, but on local copies. This class provides simple
- * type-safe access to single data pool entries (i.e. entries with length = 1).
- * The class can be instantiated as read-write and read only.
- * It provides a commit-and-roll-back semantic, which means that the
- * variable's value in the data pool is not changed until the
- * commit call is executed.
- * 	@tparam	T The template parameter sets the type of the variable.
- * 	Currently, all plain data types are supported, but in principle
- * 	any type is possible.
- *	@ingroup data_pool
- */
-template<typename T>
-class GlobPoolVar: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PoolVarList;
-	static_assert(not std::is_same<T, bool>::value,
-			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
-			"There is no boolean type in CCSDS.");
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if nullptr is not passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but
-	 * sets the value attribute to default (0).
-	 * The value is fetched within the read() operation.
-	 * @param set_id	This is the id in the global data pool
-	 * 					this instance of the access class corresponds to.
-	 * @param dataSet	The data set in which the variable shall register
-	 * 					itself. If NULL, the variable is not registered.
-	 * @param setWritable If this flag is set to true, changes in the value
-	 * 			attribute can be written back to the data pool, otherwise not.
-	 */
-	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value = 0;
-
-	/**
-	 * @brief 	Copy ctor to copy classes containing Pool Variables.
-	 * 			(Robin): This only copies member variables, which is done
-	 * 			by the default copy ctor. maybe we can ommit this ctor?
-	 */
-	GlobPoolVar(const GlobPoolVar& rhs);
-
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVar() {}
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * The commit call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool is stored.
-	 */
-	uint32_t dataPoolId;
-
-	/**
-	 * @brief	The valid information as it was stored in the data pool is
-	 * 			copied to this attribute.
-	 */
-	uint8_t valid;
-
-	/**
-	 * @brief	The information whether the class is read-write or read-only
-	 * 			is stored here.
-	 */
-	pool_rwm_t readWriteMode;
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	GlobPoolVar();
-public:
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const override;
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const override;
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-
-	uint8_t getValid();
-
-	void setValid(bool valid) override;
-
-	operator T() {
-		return value;
-	}
-
-	operator T() const {
-		return value;
-	}
-
-	GlobPoolVar<T> &operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
-		value = newPoolVariable.value;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size,
-			SerializeIF::Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, max_size,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-		        streamEndianness);
-	}
-};
-
-#include "../datapoolglob/GlobalPoolVariable.tpp"
-
-typedef GlobPoolVar<uint8_t> gp_bool_t;
-typedef GlobPoolVar<uint8_t> gp_uint8_t;
-typedef GlobPoolVar<uint16_t> gp_uint16_t;
-typedef GlobPoolVar<uint32_t> gp_uint32_t;
-typedef GlobPoolVar<int8_t> gp_int8_t;
-typedef GlobPoolVar<int16_t> gp_int16_t;
-typedef GlobPoolVar<int32_t> gp_int32_t;
-typedef GlobPoolVar<float> gp_float_t;
-typedef GlobPoolVar<double> gp_double_t;
-
-#endif /* POOLVARIABLE_H_ */
diff --git a/archive/datapoolglob/GlobalPoolVariable.tpp b/archive/datapoolglob/GlobalPoolVariable.tpp
deleted file mode 100644
index d61d605d7..000000000
--- a/archive/datapoolglob/GlobalPoolVariable.tpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#ifndef GLOBALPOOLVARIABLE_TPP_
-#define GLOBALPOOLVARIABLE_TPP_
-
-template <class T>
-inline GlobPoolVar<T>::GlobPoolVar(uint32_t set_id,
-		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode):
-		dataPoolId(set_id), valid(PoolVariableIF::INVALID),
-		readWriteMode(setReadWriteMode)
-{
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
-
-template<typename T>
-inline ReturnValue_t GlobPoolVar<T>::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-template<typename T>
-inline ReturnValue_t GlobPoolVar<T>::commit(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-template <class T>
-inline ReturnValue_t GlobPoolVar<T>::readWithoutLock() {
-	PoolEntry<T>* read_out = glob::dataPool.getData<T>(dataPoolId, 1);
-	if (read_out != NULL) {
-		valid = read_out->valid;
-		value = *(read_out->address);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		value = 0;
-		valid = false;
-		sif::error << "PoolVariable: read of DP Variable 0x" << std::hex
-				<< dataPoolId << std::dec << " failed." << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template <class T>
-inline ReturnValue_t GlobPoolVar<T>::commitWithoutLock() {
-	PoolEntry<T>* write_back = glob::dataPool.getData<T>(dataPoolId, 1);
-	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-		write_back->valid = valid;
-		*(write_back->address) = value;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template <class T>
-inline GlobPoolVar<T>::GlobPoolVar():
-		dataPoolId(PoolVariableIF::NO_PARAMETER),
-		valid(PoolVariableIF::INVALID),
-		readWriteMode(VAR_READ), value(0) {}
-
-template <class T>
-inline GlobPoolVar<T>::GlobPoolVar(const GlobPoolVar& rhs) :
-		dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode(
-		rhs.readWriteMode), value(rhs.value) {}
-
-template <class T>
-inline pool_rwm_t GlobPoolVar<T>::getReadWriteMode() const  {
-	return readWriteMode;
-}
-
-template <class T>
-inline uint32_t GlobPoolVar<T>::getDataPoolId() const {
-	return dataPoolId;
-}
-
-template <class T>
-inline void GlobPoolVar<T>::setDataPoolId(uint32_t poolId) {
-	dataPoolId = poolId;
-}
-
-template <class T>
-inline bool GlobPoolVar<T>::isValid() const {
-	if (valid)
-		return true;
-	else
-		return false;
-}
-
-template <class T>
-inline uint8_t GlobPoolVar<T>::getValid() {
-	return valid;
-}
-
-template <class T>
-inline void GlobPoolVar<T>::setValid(bool valid) {
-	this->valid = valid;
-}
-
-#endif
diff --git a/archive/datapoolglob/GlobalPoolVector.h b/archive/datapoolglob/GlobalPoolVector.h
deleted file mode 100644
index 0f5daacd8..000000000
--- a/archive/datapoolglob/GlobalPoolVector.h
+++ /dev/null
@@ -1,185 +0,0 @@
-#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_
-#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-/**
- * @brief	This is the access class for array-type data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly on the
- * data pool entries, but on local copies. This class provides simple type-
- * and length-safe access to vector-style data pool entries (i.e. entries with
- * length > 1). The class can be instantiated as read-write and read only.
- *
- * It provides a commit-and-roll-back semantic, which means that no array
- * entry in the data pool is changed until the commit call is executed.
- * There are two template parameters:
- * @tparam	T
- * This template parameter specifies the data type of an array entry. Currently,
- * all plain data types are supported, but in principle any type is possible.
- * @tparam  vector_size
- * This template parameter specifies the vector size of this entry. Using a
- * template parameter for this is not perfect, but avoids
- * dynamic memory allocation.
- * @ingroup data_pool
- */
-template<typename T, uint16_t vectorSize>
-class GlobPoolVector: public PoolVariableIF {
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if no nullptr is passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but sets the
-	 * value attribute to default (0). The value is fetched within the
-	 * read() operation.
-	 * @param set_id
-	 * This is the id in the global data pool this instance of the access
-	 * class corresponds to.
-	 * @param dataSet
-	 * The data set in which the variable shall register itself. If nullptr,
-	 * the variable is not registered.
-	 * @param setWritable
-	 * If this flag is set to true, changes in the value attribute can be
-	 * written back to the data pool, otherwise not.
-	 */
-	GlobPoolVector(uint32_t set_id, DataSetIF* set,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * @brief This operation sets the data pool id of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid != INVALID)
-			return true;
-		else
-			return false;
-	}
-	void setValid(bool valid) {this->valid = valid;}
-	uint8_t getValid() {return valid;}
-
-	T &operator [](int i) {return value[i];}
-	const T &operator [](int i) const {return value[i];}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t max_size, Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) override;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies all array values
-	 * and the valid information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The commit call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#include "../datapoolglob/GlobalPoolVector.tpp"
-
-template<typename T, uint16_t vectorSize>
-using gp_vec_t = GlobPoolVector<T, vectorSize>;
-
-#endif /* FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_ */
diff --git a/archive/datapoolglob/GlobalPoolVector.tpp b/archive/datapoolglob/GlobalPoolVector.tpp
deleted file mode 100644
index 013a682a4..000000000
--- a/archive/datapoolglob/GlobalPoolVector.tpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
-#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
-
-
-template<typename T, uint16_t vectorSize>
-inline GlobPoolVector<T, vectorSize>::GlobPoolVector(uint32_t set_id,
-		DataSetIF* set, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
-	memset(this->value, 0, vectorSize * sizeof(T));
-	if (set != nullptr) {
-		set->registerVariable(this);
-	}
-}
-
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::commit(
-		uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::readWithoutLock() {
-	PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
-			vectorSize);
-	if (read_out != nullptr) {
-		this->valid = read_out->valid;
-		memcpy(this->value, read_out->address, read_out->getByteSize());
-
-		return HasReturnvaluesIF::RETURN_OK;
-
-	} else {
-		memset(this->value, 0, vectorSize * sizeof(T));
-		sif::error << "PoolVector: Read of DP Variable 0x" << std::hex
-				<< std::setw(8) << std::setfill('0') << dataPoolId <<
-				std::dec << " failed." << std::endl;
-		this->valid = INVALID;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::commitWithoutLock() {
-	PoolEntry<T>* writeBack = glob::dataPool.getData<T>(this->dataPoolId,
-			vectorSize);
-	if ((writeBack != nullptr) && (this->readWriteMode != VAR_READ)) {
-		writeBack->valid = valid;
-		memcpy(writeBack->address, this->value, writeBack->getByteSize());
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-		size_t* size, size_t max_size,
-		SerializeIF::Endianness streamEndianness) const {
-	uint16_t i;
-	ReturnValue_t result;
-	for (i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-				max_size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-template<typename T, uint16_t vectorSize>
-inline size_t GlobPoolVector<T, vectorSize>::getSerializedSize() const {
-	return vectorSize * SerializeAdapter::getSerializedSize(value);
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::deSerialize(
-		const uint8_t** buffer, size_t* size,
-		SerializeIF::Endianness streamEndianness) {
-	uint16_t i;
-	ReturnValue_t result;
-	for (i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
-		        streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-#endif
diff --git a/archive/datapoolglob/PIDReader.h b/archive/datapoolglob/PIDReader.h
deleted file mode 100644
index 9431e1d40..000000000
--- a/archive/datapoolglob/PIDReader.h
+++ /dev/null
@@ -1,164 +0,0 @@
-#ifndef PIDREADER_H_
-#define PIDREADER_H_
-#include "../datapool/DataSetIF.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-template<typename U, uint8_t n_var> class PIDReaderList;
-
-template<typename T>
-class PIDReader: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PIDReaderList;
-protected:
-	uint32_t parameterId;
-	uint8_t valid;
-	ReturnValue_t readWithoutLock() {
-		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
-				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
-		if (read_out != NULL) {
-			valid = read_out->valid;
-			value = read_out->address[arrayIndex];
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			value = 0;
-			valid = false;
-			sif::error << "PIDReader: read of PID 0x" << std::hex << parameterId
-					<< std::dec << " failed." << std::endl;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * Never commit, is read-only.
-	 * Reason is the possibility to access a single DP vector element, but if we commit,
-	 * we set validity of the whole vector.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t commitWithoutLock() override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	PIDReader() :
-			parameterId(PoolVariableIF::NO_PARAMETER), valid(
-					PoolVariableIF::INVALID), value(0) {
-
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 */
-	T value;
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
-	 */
-	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
-			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
-					0) {
-		if (dataSet != NULL) {
-			dataSet->registerVariable(this);
-		}
-	}
-
-	ReturnValue_t read(uint32_t lockTimeout) override {
-		ReturnValue_t result = glob::dataPool.lockDataPool();
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = readWithoutLock();
-		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "PIDReader::read: Could not unlock data pool!"
-					<< std::endl;
-		}
-		return result;
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-	PIDReader(const PIDReader &rhs) :
-			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
-	}
-
-	/**
-	 * \brief	The classes destructor is empty.
-	 */
-	~PIDReader() {
-
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return GlobalDataPool::PIDToDataPoolId(parameterId);
-	}
-	uint32_t getParameterId() const {
-		return parameterId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return VAR_READ;
-	}
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid)
-			return true;
-		else
-			return false;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	void setValid(bool valid) {
-		this->valid = valid;
-	}
-
-	operator T() {
-		return value;
-	}
-
-	PIDReader<T>& operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-				streamEndianness);
-	}
-};
-
-#endif /* PIDREADER_H_ */
diff --git a/archive/datapoolglob/PIDReaderList.h b/archive/datapoolglob/PIDReaderList.h
deleted file mode 100644
index ae99f3aa2..000000000
--- a/archive/datapoolglob/PIDReaderList.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-
-#include "../datapool/PoolVariableIF.h"
-#include "../datapoolglob/PIDReader.h"
-template <class T, uint8_t n_var>
-class PIDReaderList {
-private:
-	PIDReader<T> variables[n_var];
-public:
-	PIDReaderList( const uint32_t setPid[n_var], DataSetIF* dataSet) {
-		//I really should have a look at the new init list c++ syntax.
-		if (dataSet == NULL) {
-			return;
-		}
-		for (uint8_t count = 0; count < n_var; count++) {
-			variables[count].parameterId = setPid[count];
-			dataSet->registerVariable(&variables[count]);
-		}
-	}
-
-	PIDReader<T> &operator [](int i) { return variables[i]; }
-};
-
-
-
-#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
diff --git a/archive/datapoolglob/PoolRawAccess.cpp b/archive/datapoolglob/PoolRawAccess.cpp
deleted file mode 100644
index 53706c6d3..000000000
--- a/archive/datapoolglob/PoolRawAccess.cpp
+++ /dev/null
@@ -1,239 +0,0 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapoolglob/PoolRawAccess.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serialize/EndianConverter.h"
-
-#include <cstring>
-
-PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
-		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
-		readWriteMode(setReadWriteMode) {
-	memset(value, 0, sizeof(value));
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
-
-PoolRawAccess::~PoolRawAccess() {}
-
-ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::readWithoutLock() {
-	ReturnValue_t result = RETURN_FAILED;
-	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
-	if (readOut != nullptr) {
-		result = handleReadOut(readOut);
-		if(result == RETURN_OK) {
-			return result;
-		}
-	} else {
-		result = READ_ENTRY_NON_EXISTENT;
-	}
-	handleReadError(result);
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
-	ReturnValue_t result = RETURN_FAILED;
-	valid = readOut->getValid();
-	if (readOut->getSize() > arrayEntry) {
-		arraySize = readOut->getSize();
-		typeSize = readOut->getByteSize() / readOut->getSize();
-		type = readOut->getType();
-		if (typeSize <= sizeof(value)) {
-			uint16_t arrayPosition = arrayEntry * typeSize;
-			sizeTillEnd = readOut->getByteSize() - arrayPosition;
-			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
-			memcpy(value, ptr, typeSize);
-			return RETURN_OK;
-		} else {
-			result = READ_TYPE_TOO_LARGE;
-		}
-	} else {
-		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
-		result = READ_INDEX_TOO_LARGE;
-	}
-	return result;
-}
-
-void PoolRawAccess::handleReadError(ReturnValue_t result) {
-	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed, ";
-	if(result == READ_TYPE_TOO_LARGE) {
-		sif::error << "type too large." << std::endl;
-	}
-	else if(result == READ_INDEX_TOO_LARGE) {
-		sif::error << "index too large." << std::endl;
-	}
-	else if(result == READ_ENTRY_NON_EXISTENT) {
-		sif::error << "entry does not exist." << std::endl;
-	}
-
-	valid = INVALID;
-	typeSize = 0;
-	sizeTillEnd = 0;
-	memset(value, 0, sizeof(value));
-}
-
-ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::commitWithoutLock() {
-	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
-	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-		write_back->setValid(valid);
-		uint8_t array_position = arrayEntry * typeSize;
-		uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position];
-		memcpy(ptr, value, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t* PoolRawAccess::getEntry() {
-	return value;
-}
-
-ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		size_t* writtenBytes, size_t max_size) {
-	uint8_t* data_ptr = getEntry();
-	// debug << "PoolRawAccess::getEntry: Array position: " <<
-	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
-	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
-	if (typeSize == 0)
-		return DATA_POOL_ACCESS_FAILED;
-	if (typeSize > max_size)
-		return INCORRECT_SIZE;
-	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
-	*writtenBytes = typeSize;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-        size_t maxSize, Endianness streamEndianness) const {
-    if (typeSize + *size <= maxSize) {
-    	switch(streamEndianness) {
-    	case(Endianness::BIG):
-    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::MACHINE):
-    	default:
-            memcpy(*buffer, value, typeSize);
-            break;
-        }
-        *size += typeSize;
-        (*buffer) += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    } else {
-        return SerializeIF::BUFFER_TOO_SHORT;
-    }
-}
-
-
-Type PoolRawAccess::getType() {
-	return type;
-}
-
-size_t PoolRawAccess::getSizeOfType() {
-	return typeSize;
-}
-
-size_t PoolRawAccess::getArraySize(){
-	return arraySize;
-}
-
-uint32_t PoolRawAccess::getDataPoolId() const {
-	return dataPoolId;
-}
-
-PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
-	return readWriteMode;
-}
-
-ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
-		size_t setSize) {
-	if (typeSize == setSize) {
-		EndianConverter::convertBigEndian(value, buffer, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
-				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
-				<< std::endl;
-		return INCORRECT_SIZE;
-	}
-}
-
-bool PoolRawAccess::isValid() const {
-	if (valid != INVALID)
-		return true;
-	else
-		return false;
-}
-
-void PoolRawAccess::setValid(bool valid) {
-	this->valid = valid;
-}
-
-size_t PoolRawAccess::getSizeTillEnd() const {
-	return sizeTillEnd;
-}
-
-
-size_t PoolRawAccess::getSerializedSize() const {
-	return typeSize;
-}
-
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
-        Endianness streamEndianness) {
-
-    if (*size >= typeSize) {
-        switch(streamEndianness) {
-        case(Endianness::BIG):
-			EndianConverter::convertBigEndian(value, *buffer, typeSize);
-		    break;
-        case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
-		   	break;
-        case(Endianness::MACHINE):
-        default:
-            memcpy(value, *buffer, typeSize);
-            break;
-        }
-    	*size -= typeSize;
-        *buffer += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-    	return SerializeIF::STREAM_TOO_SHORT;
-    }
-}
diff --git a/archive/datapoolglob/PoolRawAccess.h b/archive/datapoolglob/PoolRawAccess.h
deleted file mode 100644
index 15643a41c..000000000
--- a/archive/datapoolglob/PoolRawAccess.h
+++ /dev/null
@@ -1,220 +0,0 @@
-#ifndef POOLRAWACCESS_H_
-#define POOLRAWACCESS_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntryIF.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../globalfunctions/Type.h"
-
-/**
- * @brief This class allows accessing Data Pool variables as raw bytes.
- * @details
- * This is necessary to have an access method for HK data, as the PID's alone
- * do not provide type information. Please note that the the raw pool access
- * read() and commit() calls are not thread-safe.
- *
- * Please supply a data set and use the data set read(), commit() calls for
- * thread-safe data pool access.
- * @ingroup data_pool
- */
-class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
-public:
-	/**
-	 * This constructor is used to access a data pool entry with a
-	 * given ID if the target type is not known. A DataSet object is supplied
-	 * and the data pool entry with the given ID is registered to that data set.
-	 * Please note that a pool raw access buffer only has a buffer
-	 * with a size of double. As such, for vector entries which have
-	 * @param data_pool_id Target data pool entry ID
-	 * @param arrayEntry
-	 * @param data_set Dataset to register data pool entry to
-	 * @param setReadWriteMode
-	 * @param registerVectors If set to true, the constructor checks if
-	 *                        there are multiple vector entries to registers
-	 *                        and registers all of them recursively into the data_set
-	 *
-	 */
-	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
-			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-					PoolVariableIF::VAR_READ);
-
-	/**
-	 * @brief	This operation returns a pointer to the entry fetched.
-	 * @details	Return pointer to the buffer containing the raw data
-	 *          Size and number of data can be retrieved by other means.
-	 */
-	uint8_t* getEntry();
-	/**
-	 * @brief 	This operation returns the fetched entry from the data pool and
-	 * 			flips the bytes, if necessary.
-	 * @details	It makes use of the getEntry call of this function, but additionally flips the
-	 * 			bytes to big endian, which is the default for external communication (as House-
-	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given max_size.
-	 * @param buffer	A pointer to a buffer to write to
-	 * @param writtenBytes	The number of bytes written is returned with this value.
-	 * @param max_size	The maximum size that the function may write to buffer.
-	 * @return	- @c RETURN_OK if entry could be acquired
-	 * 			- @c RETURN_FAILED else.
-	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
-			size_t maxSize);
-
-	/**
-	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @param buffer Provided buffer. Raw pool data will be copied here
-	 * @param size [out] Increment provided size value by serialized size
-	 * @param max_size Maximum allowed serialization size
-	 * @param bigEndian Specify endianess
-	 * @return - @c RETURN_OK if serialization was successfull
-	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
-	 */
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-	        size_t maxSize, Endianness streamEndianness) const override;
-
-    size_t getSerializedSize() const override;
-
-    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-            Endianness streamEndianness) override;
-
-	/**
-	 * With this method, the content can be set from a big endian buffer safely.
-	 * @param buffer	Pointer to the data to set
-	 * @param size		Size of the data to write. Must fit this->size.
-	 * @return	- @c RETURN_OK on success
-	 * 			- @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			size_t setSize);
-	/**
-	 *  @brief This operation returns the type of the entry currently stored.
-	 */
-	Type getType();
-	/**
-	 *  @brief This operation returns the size of the entry currently stored.
-	 */
-	size_t getSizeOfType();
-	/**
-	 *
-	 * @return the size of the datapool array
-	 */
-	size_t getArraySize();
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
-	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
-	uint8_t value[RAW_MAX_SIZE];
-
-
-	/**
-	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolRawAccess();
-
-	/**
-	 * This method returns if the variable is read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const;
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const;
-
-	void setValid(bool valid);
-	/**
-	 * Getter for the remaining size.
-	 */
-	size_t getSizeTillEnd() const;
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The call is protected by a lock of the global data pool.
-	 * @return -@c RETURN_OK Read successfull
-	 * 		   -@c READ_TYPE_TOO_LARGE
-	 * 		   -@c READ_INDEX_TOO_LARGE
-	 * 		   -@c READ_ENTRY_NON_EXISTENT
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The call is protected by a lock of the global data pool.
-	 *
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
-	void handleReadError(ReturnValue_t result);
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The array entry that is fetched from the data pool.
-	 */
-	uint8_t arrayEntry;
-	/**
-	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	This value contains the type of the data pool entry.
-	 */
-	Type type;
-	/**
-	 * @brief	This value contains the size of the data pool entry type in bytes.
-	 */
-	size_t typeSize;
-	/**
-	 * The size of the DP array (single values return 1)
-	 */
-	size_t arraySize;
-	/**
-	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
-	 */
-	size_t sizeTillEnd;
-	/**
-	 * @brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#endif /* POOLRAWACCESS_H_ */

From f99bf6d75c51d84d49f8bbc3ca6d2c736cac06fd Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 22:51:30 +0100
Subject: [PATCH 1213/1774] taken over cmake list for storagemanager

---
 storagemanager/CMakeLists.txt | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 storagemanager/CMakeLists.txt

diff --git a/storagemanager/CMakeLists.txt b/storagemanager/CMakeLists.txt
new file mode 100644
index 000000000..57c921952
--- /dev/null
+++ b/storagemanager/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ConstStorageAccessor.cpp
+		StorageAccessor.cpp
+)
\ No newline at end of file

From a411df18db4a74f855bfdff1cfa6ffa06ab2cbf0 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 22:52:29 +0100
Subject: [PATCH 1214/1774] deleted tpp files, replaced by source files

---
 storagemanager/LocalPool.tpp   | 305 ---------------------------------
 storagemanager/PoolManager.tpp |  56 ------
 2 files changed, 361 deletions(-)
 delete mode 100644 storagemanager/LocalPool.tpp
 delete mode 100644 storagemanager/PoolManager.tpp

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
deleted file mode 100644
index 5e61efe45..000000000
--- a/storagemanager/LocalPool.tpp
+++ /dev/null
@@ -1,305 +0,0 @@
-#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_TPP_
-#define FSFW_STORAGEMANAGER_LOCALPOOL_TPP_
-
-#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_H_
-#error Include LocalPool.h before LocalPool.tpp!
-#endif
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
-		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS], bool registered,
-		bool spillsToHigherPools) :
-		SystemObject(setObjectId, registered),  internalErrorReporter(nullptr),
-		spillsToHigherPools(spillsToHigherPools)
-{
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		this->element_sizes[n] = element_sizes[n];
-		this->n_elements[n] = n_elements[n];
-		store[n] = new uint8_t[n_elements[n] * element_sizes[n]];
-		size_list[n] = new uint32_t[n_elements[n]];
-		memset(store[n], 0x00, (n_elements[n] * element_sizes[n]));
-		//TODO checkme
-		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
-	}
-}
-
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
-		uint16_t* element) {
-	ReturnValue_t status = DATA_STORAGE_FULL;
-	for (uint16_t foundElement = 0; foundElement < n_elements[pool_index];
-			foundElement++) {
-		if (size_list[pool_index][foundElement] == STORAGE_FREE) {
-			*element = foundElement;
-			status = RETURN_OK;
-			break;
-		}
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::write(store_address_t packet_id,
-		const uint8_t* data, size_t size) {
-	uint8_t* ptr;
-	uint32_t packet_position = getRawPosition(packet_id);
-
-	//check size? -> Not necessary, because size is checked before calling this function.
-	ptr = &store[packet_id.pool_index][packet_position];
-	memcpy(ptr, data, size);
-	size_list[packet_id.pool_index][packet_id.packet_index] = size;
-}
-
-//Returns page size of 0 in case store_index is illegal
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getPageSize(uint16_t pool_index) {
-	if (pool_index < NUMBER_OF_POOLS) {
-		return element_sizes[pool_index];
-	} else {
-		return 0;
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getPoolIndex(
-		size_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex) {
-	for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
-		//debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: " <<
-		//		n << ", Element Size: " << element_sizes[n] << std::endl;
-		if (element_sizes[n] >= packet_size) {
-			*poolIndex = n;
-			return RETURN_OK;
-		}
-	}
-	return DATA_TOO_LARGE;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getRawPosition(
-		store_address_t packet_id) {
-	return packet_id.packet_index * element_sizes[packet_id.pool_index];
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
-		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	ReturnValue_t status = getPoolIndex(size, &address->pool_index);
-	if (status != RETURN_OK) {
-		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
-				<< " )::reserveSpace: Packet too large." << std::endl;
-		return status;
-	}
-	status = findEmpty(address->pool_index, &address->packet_index);
-	while (status != RETURN_OK && spillsToHigherPools) {
-		status = getPoolIndex(size, &address->pool_index, address->pool_index + 1);
-		if (status != RETURN_OK) {
-			//We don't find any fitting pool anymore.
-			break;
-		}
-		status = findEmpty(address->pool_index, &address->packet_index);
-	}
-	if (status == RETURN_OK) {
-		// if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
-		//	   debug << "Reserve: Pool: " << std::dec << address->pool_index <<
-		//				" Index: " << address->packet_index << std::endl;
-		// }
-
-		size_list[address->pool_index][address->packet_index] = size;
-	} else {
-		if (!ignoreFault and internalErrorReporter != nullptr) {
-			internalErrorReporter->storeFull();
-		}
-		// error << "LocalPool( " << std::hex << getObjectId() << std::dec
-		// 			<< " )::reserveSpace: Packet store is full." << std::endl;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		delete[] store[n];
-		delete[] size_list[n];
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(
-		store_address_t* storageId, const uint8_t* data, size_t size,
-		bool ignoreFault) {
-	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
-	if (status == RETURN_OK) {
-		write(*storageId, data, size);
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
-		store_address_t* storageId, const size_t size,
-		uint8_t** p_data, bool ignoreFault) {
-	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
-	if (status == RETURN_OK) {
-		*p_data = &store[storageId->pool_index][getRawPosition(*storageId)];
-	} else {
-		*p_data = NULL;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ConstAccessorPair LocalPool<NUMBER_OF_POOLS>::getData(
-		store_address_t storeId) {
-	uint8_t* tempData = nullptr;
-	ConstStorageAccessor constAccessor(storeId, this);
-	ReturnValue_t status = modifyData(storeId, &tempData, &constAccessor.size_);
-	constAccessor.constDataPointer = tempData;
-	return ConstAccessorPair(status, std::move(constAccessor));
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(store_address_t storeId,
-		ConstStorageAccessor& storeAccessor) {
-	uint8_t* tempData = nullptr;
-	ReturnValue_t status = modifyData(storeId, &tempData, &storeAccessor.size_);
-	storeAccessor.assignStore(this);
-	storeAccessor.constDataPointer = tempData;
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
-		store_address_t packet_id, const uint8_t** packet_ptr, size_t* size) {
-	uint8_t* tempData = nullptr;
-	ReturnValue_t status = modifyData(packet_id, &tempData, size);
-	*packet_ptr = tempData;
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline AccessorPair LocalPool<NUMBER_OF_POOLS>::modifyData(
-		store_address_t storeId) {
-	StorageAccessor accessor(storeId, this);
-	ReturnValue_t status = modifyData(storeId, &accessor.dataPointer,
-			&accessor.size_);
-	accessor.assignConstPointer();
-	return AccessorPair(status, std::move(accessor));
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
-		store_address_t storeId, StorageAccessor& storeAccessor) {
-	storeAccessor.assignStore(this);
-	ReturnValue_t status = modifyData(storeId, &storeAccessor.dataPointer,
-			&storeAccessor.size_);
-	storeAccessor.assignConstPointer();
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
-		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
-	ReturnValue_t status = RETURN_FAILED;
-	if (packet_id.pool_index >= NUMBER_OF_POOLS) {
-		return ILLEGAL_STORAGE_ID;
-	}
-	if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
-		return ILLEGAL_STORAGE_ID;
-	}
-	if (size_list[packet_id.pool_index][packet_id.packet_index]
-			!= STORAGE_FREE) {
-		uint32_t packet_position = getRawPosition(packet_id);
-		*packet_ptr = &store[packet_id.pool_index][packet_position];
-		*size = size_list[packet_id.pool_index][packet_id.packet_index];
-		status = RETURN_OK;
-	} else {
-		status = DATA_DOES_NOT_EXIST;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
-		store_address_t packet_id) {
-	//if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
-	//	debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: "
-	//	         << packet_id.packet_index << std::endl;
-	//}
-	ReturnValue_t status = RETURN_OK;
-	uint32_t page_size = getPageSize(packet_id.pool_index);
-	if ((page_size != 0)
-			&& (packet_id.packet_index < n_elements[packet_id.pool_index])) {
-		uint16_t packet_position = getRawPosition(packet_id);
-		uint8_t* ptr = &store[packet_id.pool_index][packet_position];
-		memset(ptr, 0, page_size);
-		//Set free list
-		size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
-	} else {
-		//pool_index or packet_index is too large
-		sif::error << "LocalPool:deleteData failed." << std::endl;
-		status = ILLEGAL_STORAGE_ID;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::clearStore() {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		//TODO checkme
-		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
-		size_t size, store_address_t* storeId) {
-	store_address_t localId;
-	ReturnValue_t result = ILLEGAL_ADDRESS;
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		//Not sure if new allocates all stores in order. so better be careful.
-		if ((store[n] <= ptr) && (&store[n][n_elements[n]*element_sizes[n]]) > ptr) {
-			localId.pool_index = n;
-			uint32_t deltaAddress = ptr - store[n];
-			// Getting any data from the right "block" is ok.
-			// This is necessary, as IF's sometimes don't point to the first
-			// element of an object.
-			localId.packet_index = deltaAddress / element_sizes[n];
-			result = deleteData(localId);
-			//if (deltaAddress % element_sizes[n] != 0) {
-			//	error << "Pool::deleteData: address not aligned!" << std::endl;
-			//}
-			break;
-		}
-	}
-	if (storeId != NULL) {
-		*storeId = localId;
-	}
-	return result;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-			objects::INTERNAL_ERROR_REPORTER);
-	if (internalErrorReporter == nullptr){
-		return ObjectManagerIF::INTERNAL_ERR_REPORTER_UNINIT;
-	}
-
-	//Check if any pool size is large than the maximum allowed.
-	for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
-		if (element_sizes[count] >= STORAGE_FREE) {
-			sif::error << "LocalPool::initialize: Pool is too large! "
-					"Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
-			return StorageManagerIF::POOL_TOO_LARGE;
-		}
-	}
-	return RETURN_OK;
-}
-
-#endif /* FSFW_STORAGEMANAGER_LOCALPOOL_TPP_ */
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
deleted file mode 100644
index 2be44ece2..000000000
--- a/storagemanager/PoolManager.tpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
-#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
-
-#ifndef FSFW_STORAGEMANAGER_POOLMANAGER_H_
-#error Include PoolManager.h before PoolManager.tpp!
-#endif
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
-		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS]) :
-		LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
-		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
-			address,ignoreFault);
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
-		store_address_t packet_id) {
-	// debug << "PoolManager( " << translateObject(getObjectId()) <<
-	//       " )::deleteData from store " << packet_id.pool_index <<
-	//       ". id is "<< packet_id.packet_index << std::endl;
-	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
-		size_t size, store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
-			size, storeId);
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void PoolManager<NUMBER_OF_POOLS>::setMutexTimeout(
-		uint32_t mutexTimeoutMs) {
-	this->mutexTimeout = mutexTimeoutMs;
-}
-
-#endif /* FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_ */

From 8706d663d5121b56277a1f17ca40384087e20189 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 22:57:14 +0100
Subject: [PATCH 1215/1774] upstream changes taken over

---
 devicehandlers/CMakeLists.txt      | 11 +++++++++++
 devicehandlers/DeviceHandlerBase.h |  1 +
 devicehandlers/DeviceHandlerIF.h   | 10 +++++-----
 3 files changed, 17 insertions(+), 5 deletions(-)
 create mode 100644 devicehandlers/CMakeLists.txt

diff --git a/devicehandlers/CMakeLists.txt b/devicehandlers/CMakeLists.txt
new file mode 100644
index 000000000..50c1008fb
--- /dev/null
+++ b/devicehandlers/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		AssemblyBase.cpp
+		ChildHandlerBase.cpp
+		ChildHandlerFDIR.cpp
+		DeviceHandlerBase.cpp
+		DeviceHandlerFailureIsolation.cpp
+		DeviceHandlerMessage.cpp
+		DeviceTmReportingWrapper.cpp
+		HealthDevice.cpp
+)
\ No newline at end of file
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 2bfa62a66..9a5287e03 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -746,6 +746,7 @@ protected:
 	/**
 	 * Helper function to get pending command. This is useful for devices
 	 * like SPI sensors to identify the last sent command.
+	 * This only returns the command sent in the last SEND_WRITE cycle.
 	 * @return
 	 */
 	DeviceCommandId_t getPendingCommand() const;
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 12036bf11..dba6b2288 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -22,10 +22,10 @@ using DeviceCommandId_t = uint32_t;
  */
 class DeviceHandlerIF {
 public:
-    static const DeviceCommandId_t NO_COMMAND = -1;
+	static constexpr DeviceCommandId_t NO_COMMAND = -1;
 
-	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
-	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
+	static constexpr uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
+	static constexpr uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
 
 	using dh_heater_request_t = uint8_t;
 	using dh_thermal_state_t = int8_t;
@@ -144,7 +144,7 @@ public:
 	 * This is used by the child class to tell the base class what to do.
 	 */
 	enum CommunicationAction: uint8_t {
-	    PERFORM_OPERATION,
+		PERFORM_OPERATION,
 		SEND_WRITE,//!< Send write
 		GET_WRITE, //!< Get write
 		SEND_READ, //!< Send read
@@ -155,7 +155,7 @@ public:
 	static constexpr uint32_t DEFAULT_THERMAL_SET_ID = sid_t::INVALID_SET_ID - 1;
 
 	static constexpr lp_id_t DEFAULT_THERMAL_STATE_POOL_ID =
-	        localpool::INVALID_LPID - 2;
+			localpool::INVALID_LPID - 2;
 	static constexpr lp_id_t DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID =
 			localpool::INVALID_LPID - 1;
 

From c8ddfe598b7ccb1c4f7a4c67dbbd6aa27231137e Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 23:00:30 +0100
Subject: [PATCH 1216/1774] timemanager update

---
 timemanager/CCSDSTime.cpp        |  38 ++---
 timemanager/CCSDSTime.h          |  39 ++---
 timemanager/Clock.h              | 265 ++++++++++++++++---------------
 timemanager/Countdown.cpp        |  10 +-
 timemanager/Countdown.h          |  28 ++--
 timemanager/ReceivesTimeInfoIF.h |  13 +-
 timemanager/TimeMessage.cpp      |   7 -
 timemanager/TimeMessage.h        |  15 +-
 timemanager/TimeStamperIF.h      |   6 +-
 timemanager/clockDefinitions.h   |  13 ++
 10 files changed, 217 insertions(+), 217 deletions(-)
 create mode 100644 timemanager/clockDefinitions.h

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index f137e0305..aefcac2eb 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,9 +1,9 @@
 #include "CCSDSTime.h"
-
+#include <FSFWConfig.h>
 #include <cstdio>
 #include <cinttypes>
 #include <cmath>
-#include <FSFWConfig.h>
+
 
 CCSDSTime::CCSDSTime() {
 }
@@ -53,8 +53,8 @@ ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
 	return RETURN_OK;
 }
 
-ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint32_t length) {
+ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to,
+        const uint8_t* from, size_t length) {
 	ReturnValue_t result;
 	if (length > 0xFF) {
 		return LENGTH_MISMATCH;
@@ -72,7 +72,7 @@ ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t*
 	case CDS:
 		return convertFromCDS(to, from, length);
 	case CCS: {
-		uint32_t temp = 0;
+		size_t temp = 0;
 		return convertFromCCS(to, from, &temp, length);
 	}
 
@@ -81,13 +81,13 @@ ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t*
 	}
 }
 
-ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
+ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint8_t length) {
 	return UNSUPPORTED_TIME_FORMAT;
 }
 
-ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
+ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint8_t length) {
 	timeval time;
 	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -96,8 +96,8 @@ ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* f
 	return convertTimevalToTimeOfDay(to, &time);
 }
 
-ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to,
+        const uint8_t* from, size_t* foundLength, size_t maxLength) {
 	uint8_t subsecondsLength = *from & 0b111;
 	uint32_t totalLength = subsecondsLength + 8;
 	if (maxLength < totalLength) {
@@ -152,8 +152,8 @@ ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* f
 
 }
 
-ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
+ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint8_t length) {
 	if (length < 19) {
 		return RETURN_FAILED;
 	}
@@ -395,7 +395,7 @@ ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
 }
 
 ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+		size_t* foundLength, size_t maxLength) {
 	//We don't expect ascii here. SHOULDDO
 	uint8_t codeIdentification = (*from >> 4);
 	switch (codeIdentification) {
@@ -413,7 +413,7 @@ ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+		size_t* foundLength, size_t maxLength) {
 	if (maxLength < 1) {
 		return INVALID_TIME_FORMAT;
 	}
@@ -491,7 +491,7 @@ ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
 }
 
 ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+		size_t* foundLength, size_t maxLength) {
 	uint8_t pField = *from;
 	from++;
 //Check epoch
@@ -556,12 +556,12 @@ ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
-		const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
+		const uint8_t* from, size_t* foundLength, size_t maxLength) {
 	uint32_t secs = 0;
 	uint32_t subSeconds = 0;
 	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
 	uint8_t nFine = (pField & 0b11);
-	uint32_t totalLength = nCoarse + nFine;
+	size_t totalLength = nCoarse + nFine;
 	if (foundLength != NULL) {
 		*foundLength = totalLength;
 	}
@@ -593,7 +593,7 @@ uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
 }
 
 ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+		size_t* foundLength, size_t maxLength) {
 	Clock::TimeOfDay_t tempTime;
 	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
 			maxLength);
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index 89fcff92f..e9e6957f2 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -1,9 +1,10 @@
-#ifndef CCSDSTIME_H_
-#define CCSDSTIME_H_
+#ifndef FSFW_TIMEMANAGER_CCSDSTIME_H_
+#define FSFW_TIMEMANAGER_CCSDSTIME_H_
 
 // COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
 
 #include "Clock.h"
+#include "clockDefinitions.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstdint>
 
@@ -154,8 +155,8 @@ public:
 	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
 	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
 	 */
-	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint32_t length);
+	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, size_t length);
 
 	/**
 	 * not implemented yet
@@ -165,34 +166,34 @@ public:
 	 * @return
 	 */
 	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+			size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
+	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint8_t length);
 
 	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+			size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+			uint8_t const *from, size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+			size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+			uint8_t const *from, size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
+	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint8_t length);
 
 	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+			size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
+	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint8_t length);
 
 	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
 private:
@@ -230,4 +231,4 @@ private:
 			timeval* from);
 };
 
-#endif /* CCSDSTIME_H_ */
+#endif /* FSFW_TIMEMANAGER_CCSDSTIME_H_ */
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index d8b06fda5..f4ed847ac 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -1,153 +1,166 @@
 #ifndef FSFW_TIMEMANAGER_CLOCK_H_
 #define FSFW_TIMEMANAGER_CLOCK_H_
 
+#include "clockDefinitions.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MutexHelper.h"
+#include "../ipc/MutexFactory.h"
 #include "../globalfunctions/timevalOperations.h"
 
 #include <cstdint>
 #include <sys/time.h>
 
-//! Don't use these for time points, type is not large enough for UNIX epoch.
-using dur_millis_t = uint32_t;
-
 class Clock {
 public:
-	typedef struct {
-	  uint32_t year; //!< Year, A.D.
-	  uint32_t month; //!< Month, 1 .. 12.
-	  uint32_t day; //!< Day, 1 .. 31.
-	  uint32_t hour; //!< Hour, 0 .. 23.
-	  uint32_t minute; //!< Minute, 0 .. 59.
-	  uint32_t second; //!< Second, 0 .. 59.
-	  uint32_t usecond; //!< Microseconds, 0 .. 999999
-	}   TimeOfDay_t;
+    typedef struct {
+        uint32_t year; //!< Year, A.D.
+        uint32_t month; //!< Month, 1 .. 12.
+        uint32_t day; //!< Day, 1 .. 31.
+        uint32_t hour; //!< Hour, 0 .. 23.
+        uint32_t minute; //!< Minute, 0 .. 59.
+        uint32_t second; //!< Second, 0 .. 59.
+        uint32_t usecond; //!< Microseconds, 0 .. 999999
+    } TimeOfDay_t;
 
-	/**
-	 * This method returns the number of clock ticks per second.
-	 * In RTEMS, this is typically 1000.
-	 * @return	The number of ticks.
-	 *
-	 * @deprecated, we should not worry about ticks, but only time
-	 */
-	static uint32_t getTicksPerSecond(void);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a TimeOfDay_t struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
-	 * 				is returned.
-	 */
-	static ReturnValue_t setClock(const TimeOfDay_t* time);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a timeval struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setClock(const timeval* time);
-	/**
-	 * This system call returns the current system clock in timeval format.
-	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
-	 * microseconds since an OS-defined epoch.
-	 * @param time	A pointer to a timeval struct where the current time is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_timeval(timeval* time);
+    /**
+     * This method returns the number of clock ticks per second.
+     * In RTEMS, this is typically 1000.
+     * @return	The number of ticks.
+     *
+     * @deprecated, we should not worry about ticks, but only time
+     */
+    static uint32_t getTicksPerSecond(void);
+    /**
+     * This system call sets the system time.
+     * To set the time, it uses a TimeOfDay_t struct.
+     * @param time The struct with the time settings to set.
+     * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
+     * 				is returned.
+     */
+    static ReturnValue_t setClock(const TimeOfDay_t* time);
+    /**
+     * This system call sets the system time.
+     * To set the time, it uses a timeval struct.
+     * @param time The struct with the time settings to set.
+     * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t setClock(const timeval* time);
+    /**
+     * This system call returns the current system clock in timeval format.
+     * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
+     * microseconds since an OS-defined epoch.
+     * @param time	A pointer to a timeval struct where the current time is stored.
+     * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getClock_timeval(timeval* time);
 
-	/**
-	 * Get the time since boot in a timeval struct
-	 *
-	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 *
-	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
-	 */
-	static ReturnValue_t getUptime(timeval* uptime);
+    /**
+     * Get the time since boot in a timeval struct
+     *
+     * @param[out] time A pointer to a timeval struct where the uptime is stored.
+     * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+     *
+     * @deprecated, I do not think this should be able to fail, use timeval getUptime()
+     */
+    static ReturnValue_t getUptime(timeval* uptime);
 
-	static timeval getUptime();
+    static timeval getUptime();
 
-	/**
-	 * Get the time since boot in milliseconds
-	 *
-	 * This value can overflow! Still, it can be used to calculate time intervalls
-	 * between two calls up to 49 days by always using uint32_t in the calculation
-	 *
-	 * @param ms uptime in ms
-	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getUptime(uint32_t* uptimeMs);
+    /**
+     * Get the time since boot in milliseconds
+     *
+     * This value can overflow! Still, it can be used to calculate time intervalls
+     * between two calls up to 49 days by always using uint32_t in the calculation
+     *
+     * @param ms uptime in ms
+     * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getUptime(uint32_t* uptimeMs);
 
-	/**
-	 * Returns the time in microseconds since an OS-defined epoch.
-	 * The time is returned in a 64 bit unsigned integer.
-	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_usecs(uint64_t* time);
-	/**
-	 * Returns the time in a TimeOfDay_t struct.
-	 * @param time A pointer to a TimeOfDay_t struct.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
+    /**
+     * Returns the time in microseconds since an OS-defined epoch.
+     * The time is returned in a 64 bit unsigned integer.
+     * @param time A pointer to a 64 bit unisigned integer where the data is stored.
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getClock_usecs(uint64_t* time);
+    /**
+     * Returns the time in a TimeOfDay_t struct.
+     * @param time A pointer to a TimeOfDay_t struct.
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
 
-	/**
-	 * Converts a time of day struct to POSIX seconds.
-	 * @param time The time of day as input
-	 * @param timeval The corresponding seconds since the epoch.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-			timeval* to);
+    /**
+     * Converts a time of day struct to POSIX seconds.
+     * @param time The time of day as input
+     * @param timeval The corresponding seconds since the epoch.
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+            timeval* to);
 
-	/**
-	 * Converts a time represented as seconds and subseconds since unix epoch to days since J2000
-	 *
-	 * @param time seconds since unix epoch
-	 * @param[out] JD2000 days since J2000
-	 * @return \c RETURN_OK
-	 */
-	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
+    /**
+     * Converts a time represented as seconds and subseconds since unix
+     * epoch to days since J2000
+     *
+     * @param time seconds since unix epoch
+     * @param[out] JD2000 days since J2000
+     * @return @c RETURN_OK
+     */
+    static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
 
-	/**
-	 * Calculates and adds the offset between UTC and TT
-	 *
-	 * Depends on the leap seconds to be set correctly.
-	 *
-	 * @param utc timeval, corresponding to UTC time
-	 * @param[out] tt timeval, corresponding to Terrestial Time
-	 * @return \c RETURN_OK on success, \c RETURN_FAILED if leapSeconds are not set
-	 */
-	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
+    /**
+     * Calculates and adds the offset between UTC and TT
+     *
+     * Depends on the leap seconds to be set correctly.
+     *
+     * @param utc timeval, corresponding to UTC time
+     * @param[out] tt timeval, corresponding to Terrestial Time
+     * @return
+     *  - @c RETURN_OK on success
+     *  - @c RETURN_FAILED if leapSeconds are not set
+     */
+    static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
 
-	/**
-	 * Set the Leap Seconds since 1972
-	 *
-	 * @param leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
+    /**
+     * Set the Leap Seconds since 1972
+     *
+     * @param leapSeconds_
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
 
-	/**
-	 * Get the Leap Seconds since 1972
-	 *
-	 * Must be set before!
-	 *
-	 * @param[out] leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
+    /**
+     * Get the Leap Seconds since 1972
+     *
+     * Must be set before!
+     *
+     * @param[out] leapSeconds_
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
 
-	/**
-	 * Function to check and create the Mutex for the clock
-	 * @return \c RETURN_OK on success. Otherwise \c RETURN_FAILED if not able to create one
-	 */
-	static ReturnValue_t checkOrCreateClockMutex();
+    /**
+     * Function to check and create the Mutex for the clock
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise @c RETURN_FAILED if not able to create one
+     */
+    static ReturnValue_t checkOrCreateClockMutex();
 
 private:
-	static MutexIF* timeMutex;
-	static uint16_t leapSeconds;
+    static MutexIF* timeMutex;
+    static uint16_t leapSeconds;
 };
 
 
diff --git a/timemanager/Countdown.cpp b/timemanager/Countdown.cpp
index d56957301..20b56189f 100644
--- a/timemanager/Countdown.cpp
+++ b/timemanager/Countdown.cpp
@@ -1,14 +1,6 @@
-/**
- * @file	Countdown.cpp
- * @brief	This file defines the Countdown class.
- * @date	21.03.2013
- * @author	baetz
- */
-
-
 #include "Countdown.h"
 
-Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) {
+Countdown::Countdown(uint32_t initialTimeout): timeout(initialTimeout) {
 }
 
 Countdown::~Countdown() {
diff --git a/timemanager/Countdown.h b/timemanager/Countdown.h
index b86d9fe0b..f6a41e73d 100644
--- a/timemanager/Countdown.h
+++ b/timemanager/Countdown.h
@@ -1,18 +1,13 @@
-/**
- * @file	Countdown.h
- * @brief	This file defines the Countdown class.
- * @date	21.03.2013
- * @author	baetz
- */
-
-#ifndef COUNTDOWN_H_
-#define COUNTDOWN_H_
+#ifndef FSFW_TIMEMANAGER_COUNTDOWN_H_
+#define FSFW_TIMEMANAGER_COUNTDOWN_H_
 
 #include "Clock.h"
 
+/**
+ * @brief	This file defines the Countdown class.
+ * @author	baetz
+ */
 class Countdown {
-private:
-	uint32_t startTime;
 public:
 	uint32_t timeout;
 	Countdown(uint32_t initialTimeout = 0);
@@ -23,9 +18,14 @@ public:
 
 	bool isBusy() const;
 
-	ReturnValue_t resetTimer(); //!< Use last set timeout value and restart timer.
+	//!< Use last set timeout value and restart timer.
+	ReturnValue_t resetTimer();
 
-	void timeOut(); //!< Make hasTimedOut() return true
+	//!< Make hasTimedOut() return true
+	void timeOut();
+
+private:
+	uint32_t startTime = 0;
 };
 
-#endif /* COUNTDOWN_H_ */
+#endif /* FSFW_TIMEMANAGER_COUNTDOWN_H_ */
diff --git a/timemanager/ReceivesTimeInfoIF.h b/timemanager/ReceivesTimeInfoIF.h
index 14a750c56..c1247a42f 100644
--- a/timemanager/ReceivesTimeInfoIF.h
+++ b/timemanager/ReceivesTimeInfoIF.h
@@ -1,12 +1,7 @@
-/**
- * @file	ReceivesTimeInfoIF.h
- * @brief	This file defines the ReceivesTimeInfoIF class.
- * @date	26.02.2013
- * @author	baetz
- */
+#ifndef FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_
+#define FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_
 
-#ifndef RECEIVESTIMEINFOIF_H_
-#define RECEIVESTIMEINFOIF_H_
+#include "../ipc/MessageQueueSenderIF.h"
 
 /**
  * This is a Interface for classes that receive timing information
@@ -28,4 +23,4 @@ public:
 };
 
 
-#endif /* RECEIVESTIMEINFOIF_H_ */
+#endif /* FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_ */
diff --git a/timemanager/TimeMessage.cpp b/timemanager/TimeMessage.cpp
index 5a9a416b5..a1042efe5 100644
--- a/timemanager/TimeMessage.cpp
+++ b/timemanager/TimeMessage.cpp
@@ -1,10 +1,3 @@
-/**
- * @file	TimeMessage.cpp
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
 #include "TimeMessage.h"
 
 TimeMessage::TimeMessage() {
diff --git a/timemanager/TimeMessage.h b/timemanager/TimeMessage.h
index 116002e6d..f5ac3e14d 100644
--- a/timemanager/TimeMessage.h
+++ b/timemanager/TimeMessage.h
@@ -1,15 +1,8 @@
-/**
- * @file	TimeMessage.h
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
+#ifndef FSFW_TIMEMANAGER_TIMEMESSAGE_H_
+#define FSFW_TIMEMANAGER_TIMEMESSAGE_H_
 
-#ifndef TIMEMESSAGE_H_
-#define TIMEMESSAGE_H_
-
-#include "../ipc/MessageQueueMessage.h"
 #include "Clock.h"
+#include "../ipc/MessageQueueMessage.h"
 #include <cstring>
 
 class TimeMessage : public MessageQueueMessage {
@@ -53,4 +46,4 @@ public:
 	uint32_t getCounterValue();
 };
 
-#endif /* TIMEMESSAGE_H_ */
+#endif /* FSFW_TIMEMANAGER_TIMEMESSAGE_H_ */
diff --git a/timemanager/TimeStamperIF.h b/timemanager/TimeStamperIF.h
index 96011088d..57b7f0149 100644
--- a/timemanager/TimeStamperIF.h
+++ b/timemanager/TimeStamperIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
-#define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+#ifndef FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
+#define FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 
@@ -25,4 +25,4 @@ public:
 
 
 
-#endif /* FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ */
+#endif /* FSFW_TIMEMANAGER_TIMESTAMPERIF_H_ */
diff --git a/timemanager/clockDefinitions.h b/timemanager/clockDefinitions.h
new file mode 100644
index 000000000..bba6e3ca2
--- /dev/null
+++ b/timemanager/clockDefinitions.h
@@ -0,0 +1,13 @@
+#ifndef FSFW_TIMEMANAGER_CLOCKDEFINITIONS_H_
+#define FSFW_TIMEMANAGER_CLOCKDEFINITIONS_H_
+
+#include <cstdint>
+
+// I'd also like to include the TimeOfDay_t struct here, but that would
+// break code which uses Clock::TimeOfDay_t. Solution would be to use
+// a Clock namespace instead of class with static functions.
+
+//! Don't use these for time points, type is not large enough for UNIX epoch.
+using dur_millis_t = uint32_t;
+
+#endif /* FSFW_TIMEMANAGER_CLOCKDEFINITIONS_H_ */

From f128a1dc3d33c7bd22919b13240230373843f13c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 23:44:43 +0100
Subject: [PATCH 1217/1774] made datalinklayer optional

---
 CMakeLists.txt | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 09760f8ea..c8092629d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -36,7 +36,11 @@ add_subdirectory(action)
 add_subdirectory(container)
 add_subdirectory(controller)
 add_subdirectory(coordinates)
+
+if(FSFW_USE_DATALINKLAYER)
 add_subdirectory(datalinklayer)
+endif()
+
 add_subdirectory(datapool)
 add_subdirectory(datapoollocal)
 add_subdirectory(housekeeping)

From f8b34bcb5305b946380d2e401c8c57976ad07aae Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 16 Dec 2020 13:53:36 +0100
Subject: [PATCH 1218/1774] some readme improvements

---
 README.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 4aabe36a9..fd652f1dd 100644
--- a/README.md
+++ b/README.md
@@ -14,9 +14,9 @@ The framework is designed for systems, which communicate with external devices,
 Therefore, a mode and health system provides control over the states of the software and the controlled devices. 
 In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 
 
-The recommended hardware is a microprocessor with more than 2 MB of RAM and 1 MB of non-volatile Memory. 
+The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile Memory. 
 For reference, current Applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC.
-
+The `fsfw` was also tested on the STM32H743ZI-Nucleo board.
 
 ## Structure
 
@@ -121,12 +121,13 @@ If the communication is based on CCSDS Frames and Space Packets, several classes
 If Space Packets are used, a timestamper must be created. 
 An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
 
-#### DeviceHandling
+#### Device Handlers
 
 DeviceHandlers are a core component of the FSFW. 
 The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
 By separating the underlying Communication Interface with DeviceCommunicationIF, a DH can be tested on different hardware.
 The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
+Device Handlers can be created by overriding `DeviceHandlerBase`.
 A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
 
 #### Modes, Health
@@ -151,7 +152,8 @@ The on-board FDIR uses the health state for isolation and recovery.
 
 ## Example config
 
-A example config can be found in defaultcfg/fsfwconfig.
+A example config can be found in defaultcfg/fsfwconfig. The fsfw will require certain configuration files,
+so a configuration folder should be provided and the folder should be added to the include path.
 
 ## Unit Tests
 

From ac40b1c966bb025ce433dc55554100de29f77d5a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 17 Dec 2020 11:46:50 +0100
Subject: [PATCH 1219/1774] cmake list formatting

---
 CMakeLists.txt | 49 ++++++++++++++++++++++++++++++-------------------
 1 file changed, 30 insertions(+), 19 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c8092629d..fbbe386b0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,27 +3,38 @@ cmake_minimum_required(VERSION 3.13)
 set(LIB_FSFW_NAME fsfw)
 add_library(${LIB_FSFW_NAME})
 
-# Set options for FSFW OSAL selection.
-if(UNIX)
-set(OS_FSFW  "linux" CACHE STRING "OS abstraction layer used in the FSFW")
-elseif(WIN32)
-set(OS_FSFW  "host" CACHE STRING "OS abstraction layer used in the FSFW")
-endif()
-
 set_property(CACHE OS_FSFW PROPERTY STRINGS host linux rtems freertos)
 
+if(NOT OS_FSFW)
+	message(STATUS "No OS for FSFW via OS_FSFW set. Assuming host OS")
+	# Assume host OS and autodetermine from OS_FSFW
+	if(UNIX)
+		set(OS_FSFW  "linux" 
+			CACHE STRING 
+			"OS abstraction layer used in the FSFW"
+		)
+	elseif(WIN32)
+		set(OS_FSFW  "host" 
+			CACHE STRING "OS abstraction layer used in the FSFW"
+		)
+	endif()
+
+endif
+
 if(${OS_FSFW} STREQUAL host)
-set(OS_FSFW_NAME "Host")
+	set(OS_FSFW_NAME "Host")
 elseif(${OS_FSFW} STREQUAL linux)
-set(OS_FSFW_NAME "Linux")
+	set(OS_FSFW_NAME "Linux")
 elseif(${OS_FSFW} STREQUAL  freertos)
-set(OS_FSFW_NAME "FreeRTOS")
+	set(OS_FSFW_NAME "FreeRTOS")
 elseif(${OS_FSFW} STREQUAL rtems)
-set(OS_FSFW_NAME "RTEMS")
+	set(OS_FSFW_NAME "RTEMS")
 else()
-message(WARNING "Invalid operating system for FSFW specified! Setting to host..")
-set(OS_FSFW_NAME "Host")
-set(OS_FSFW "host")
+	message(WARNING 
+		"Invalid operating system for FSFW specified! Setting to host.."
+	)
+	set(OS_FSFW_NAME "Host")
+	set(OS_FSFW "host")
 endif()
 
 message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system")
@@ -38,7 +49,7 @@ add_subdirectory(controller)
 add_subdirectory(coordinates)
 
 if(FSFW_USE_DATALINKLAYER)
-add_subdirectory(datalinklayer)
+	add_subdirectory(datalinklayer)
 endif()
 
 add_subdirectory(datapool)
@@ -61,7 +72,7 @@ add_subdirectory(power)
 add_subdirectory(pus)
 
 if(FSFW_USE_RMAP)
-add_subdirectory(rmap)
+	add_subdirectory(rmap)
 endif()
 
 add_subdirectory(serialize)
@@ -79,9 +90,9 @@ add_subdirectory(tmtcservices)
 # The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
 # If this is not given, we include the default configuration and emit a warning.
 if(NOT FSFW_CONFIG_PATH)
-message(WARNING "Flight Software Framework configuration path not set!")
-message(WARNING "Setting default configuration!")
-add_subdirectory(defaultcfg/fsfwconfig)
+	message(WARNING "Flight Software Framework configuration path not set!")
+	message(WARNING "Setting default configuration!")
+	add_subdirectory(defaultcfg/fsfwconfig)
 endif()
 
 # Required include paths to compile the FSFW

From 60d69c95c497945fbb7650dca21655fbfd9649f5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 17 Dec 2020 17:10:27 +0100
Subject: [PATCH 1220/1774] address in use handling for socket

---
 osal/windows/TmTcWinUdpBridge.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 7e283c2a7..2af3daa51 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -137,6 +137,11 @@ void TmTcWinUdpBridge::handleBindError() {
                 << "WSAStartup(...) call " << "necessary" << std::endl;
         break;
     }
+    case(WSAEADDRINUSE): {
+    	sif::warning << "TmTcWinUdpBridge::handleBindError: WSAEADDRINUSE: "
+    			<< "Port is already in use!" << std::endl;
+    	break;
+    }
     default: {
         /*
         https://docs.microsoft.com/en-us/windows/win32/winsock/

From 62b5c19063c6b55f08aae54bc93e879619bd1a06 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 17 Dec 2020 20:18:16 +0100
Subject: [PATCH 1221/1774] small fix

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index fbbe386b0..5cb4b28ec 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,7 +19,7 @@ if(NOT OS_FSFW)
 		)
 	endif()
 
-endif
+endif()
 
 if(${OS_FSFW} STREQUAL host)
 	set(OS_FSFW_NAME "Host")

From c0099481a16897273b10a0c8b59c8f2504392b3d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 19 Dec 2020 00:21:08 +0100
Subject: [PATCH 1222/1774] added freertos cmakelists

---
 osal/FreeRTOS/CMakeLists.txt | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 osal/FreeRTOS/CMakeLists.txt

diff --git a/osal/FreeRTOS/CMakeLists.txt b/osal/FreeRTOS/CMakeLists.txt
new file mode 100644
index 000000000..a7b1338f9
--- /dev/null
+++ b/osal/FreeRTOS/CMakeLists.txt
@@ -0,0 +1,18 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		FixedTimeslotTask.cpp
+		BinarySemaphore.cpp
+		BinSemaphUsingTask.cpp
+		CountingSemaphore.cpp
+		CountingSemaphUsingTask.cpp
+		MessageQueue.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PeriodicTask.cpp
+		QueueFactory.cpp
+		QueueMapManager.cpp
+		SemaphoreFactory.cpp
+		TaskFactory.cpp
+		Timekeeper.cpp
+)
\ No newline at end of file

From e030d7ed97609c377af8540b7754b08bbb7c87ef Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 19 Dec 2020 02:29:22 +0100
Subject: [PATCH 1223/1774] correct interface and private includes

---
 CMakeLists.txt               | 24 +++++++++++++++++++++---
 osal/FreeRTOS/CMakeLists.txt | 15 +++++++++++++--
 2 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5cb4b28ec..a3ca3e0d6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -95,8 +95,26 @@ if(NOT FSFW_CONFIG_PATH)
 	add_subdirectory(defaultcfg/fsfwconfig)
 endif()
 
+# FSFW might be part of a possibly complicated folder structure, so we 
+# extract the absolute path of the fsfwconfig folder.
+if(IS_ABSOLUTE ${FSFW_CONFIG_PATH})
+	set(${FSFW_CONFIG_PATH_ABSOLUTE} ${FSFW_CONFIG_PATH})
+else()
+	get_filename_component(${FSFW_CONFIG_PATH_ABSOLUTE} 
+		${FSFW_CONFIG_PATH} ABSOLUTE
+	)
+endif()
+
 # Required include paths to compile the FSFW
-target_include_directories(${LIB_FSFW_NAME} 
-	INTERFACE 
-		${FSFW_CONFIG_PATH}
+target_include_directories(${LIB_FSFW_NAME} INTERFACE 
+	${CMAKE_SOURCE_DIR}
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+)
+
+# Includes path required to compile FSFW itself as well
+# We assume that the fsfwconfig folder uses include relative to the project
+# root here!
+target_include_directories(${LIB_FSFW_NAME} PRIVATE 
+	${CMAKE_SOURCE_DIR}
+	${FSFW_CONFIG_PATH_ABSOLUTE}
 )
diff --git a/osal/FreeRTOS/CMakeLists.txt b/osal/FreeRTOS/CMakeLists.txt
index a7b1338f9..c310c5cf4 100644
--- a/osal/FreeRTOS/CMakeLists.txt
+++ b/osal/FreeRTOS/CMakeLists.txt
@@ -11,8 +11,19 @@ target_sources(${LIB_FSFW_NAME}
 		MutexFactory.cpp
 		PeriodicTask.cpp
 		QueueFactory.cpp
-		QueueMapManager.cpp
 		SemaphoreFactory.cpp
 		TaskFactory.cpp
 		Timekeeper.cpp
-)
\ No newline at end of file
+)
+
+# FreeRTOS is required to link the FSFW now. It is recommended to compile 
+# FreeRTOS as a static library and set LIB_OS_NAME to the target name of the 
+# library.
+if(NOT LIB_OS_NAME)
+	message(FATAL_ERROR 
+		"FreeRTOS needs to be linked as a target and "
+		"LIB_OS_NAME needs to be set to the target"
+	)
+endif()
+
+target_link_libraries(${LIB_FSWFW_NAME} ${LIB_OS_NAME})
\ No newline at end of file

From be20978998bc2d6852cd7ecdc6d3061354e13104 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 19 Dec 2020 12:10:29 +0100
Subject: [PATCH 1224/1774] better path determination

---
 CMakeLists.txt | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a3ca3e0d6..21f4c90e0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -98,10 +98,10 @@ endif()
 # FSFW might be part of a possibly complicated folder structure, so we 
 # extract the absolute path of the fsfwconfig folder.
 if(IS_ABSOLUTE ${FSFW_CONFIG_PATH})
-	set(${FSFW_CONFIG_PATH_ABSOLUTE} ${FSFW_CONFIG_PATH})
+	set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
 else()
-	get_filename_component(${FSFW_CONFIG_PATH_ABSOLUTE} 
-		${FSFW_CONFIG_PATH} ABSOLUTE
+	get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE
+		${FSFW_CONFIG_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR}
 	)
 endif()
 

From b8e703ca833295d5dbfaadf20bb45b358295b6ff Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 19 Dec 2020 13:04:16 +0100
Subject: [PATCH 1225/1774] linked against OS

---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 21f4c90e0..5660443fc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -27,6 +27,7 @@ elseif(${OS_FSFW} STREQUAL linux)
 	set(OS_FSFW_NAME "Linux")
 elseif(${OS_FSFW} STREQUAL  freertos)
 	set(OS_FSFW_NAME "FreeRTOS")
+	target_link_libraries(${LIB_FSFW_NAME} ${LIB_OS_NAME})
 elseif(${OS_FSFW} STREQUAL rtems)
 	set(OS_FSFW_NAME "RTEMS")
 else()

From 8ede00fdf18c8a0fb7afd808a2d76d69bd5c23a9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 19 Dec 2020 18:38:02 +0100
Subject: [PATCH 1226/1774] small bugfixes

---
 CMakeLists.txt               | 4 ++++
 osal/FreeRTOS/CMakeLists.txt | 1 +
 2 files changed, 5 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5660443fc..0497a42ff 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -119,3 +119,7 @@ target_include_directories(${LIB_FSFW_NAME} PRIVATE
 	${CMAKE_SOURCE_DIR}
 	${FSFW_CONFIG_PATH_ABSOLUTE}
 )
+
+target_compile_options(${LIB_FSFW_NAME} PRIVATE 
+	${ABI_FLAGS}
+)
diff --git a/osal/FreeRTOS/CMakeLists.txt b/osal/FreeRTOS/CMakeLists.txt
index c310c5cf4..95462010f 100644
--- a/osal/FreeRTOS/CMakeLists.txt
+++ b/osal/FreeRTOS/CMakeLists.txt
@@ -14,6 +14,7 @@ target_sources(${LIB_FSFW_NAME}
 		SemaphoreFactory.cpp
 		TaskFactory.cpp
 		Timekeeper.cpp
+		TaskManagement.cpp
 )
 
 # FreeRTOS is required to link the FSFW now. It is recommended to compile 

From d186b70d2edf5265f99e6d933ce90ccf5faf641f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 19 Dec 2020 18:41:28 +0100
Subject: [PATCH 1227/1774] comment added

---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0497a42ff..b2c55d957 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -120,6 +120,7 @@ target_include_directories(${LIB_FSFW_NAME} PRIVATE
 	${FSFW_CONFIG_PATH_ABSOLUTE}
 )
 
+# Machine specific options can be set with the ABI_FLAGS variable.
 target_compile_options(${LIB_FSFW_NAME} PRIVATE 
 	${ABI_FLAGS}
 )

From c64a9654ea54ab843406b9966fffd9f26c76e17a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 19 Dec 2020 22:51:10 +0100
Subject: [PATCH 1228/1774] xcompile update

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b2c55d957..2fc33e588 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -38,7 +38,7 @@ else()
 	set(OS_FSFW "host")
 endif()
 
-message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system")
+message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
 
 # Options to exclude parts of the FSFW from compilation.
 option(FSFW_USE_RMAP "Compile with RMAP" ON)

From ebe7f02fc4c65ac4f28825d54671fe402e61cd9f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 20 Dec 2020 01:56:21 +0100
Subject: [PATCH 1229/1774] better error handling

---
 osal/windows/TcWinUdpPollingTask.cpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 7b54bb2cf..06deafd10 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -119,7 +119,7 @@ void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
 	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
 			reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
 	if(result == -1) {
-		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+		sif::error << "TcWinUdpPollingTask::TcSocketPollingTask: Setting "
 				"receive timeout failed with " << strerror(errno) << std::endl;
 	}
 }
@@ -128,17 +128,22 @@ void TcWinUdpPollingTask::handleReadError() {
     int error = WSAGetLastError();
     switch(error) {
     case(WSANOTINITIALISED): {
-        sif::info << "TmTcWinUdpBridge::handleReadError: WSANOTINITIALISED: "
+        sif::info << "TcWinUdpPollingTask::handleReadError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call " << "necessary" << std::endl;
         break;
     }
     case(WSAEFAULT): {
-        sif::info << "TmTcWinUdpBridge::handleReadError: WSADEFAULT: "
+        sif::info << "TcWinUdpPollingTask::handleReadError: WSADEFAULT: "
                 << "Bad address " << std::endl;
         break;
     }
+    case(WSAEINVAL): {
+        sif::info << "TcWinUdpPollingTask::handleReadError: WSAEINVAL: "
+                << "Invalid input parameters. " << std::endl;
+        break;
+    }
     default: {
-        sif::info << "TmTcWinUdpBridge::handleReadError: Error code: "
+        sif::info << "TcWinUdpPollingTask::handleReadError: Error code: "
                 << error << std::endl;
         break;
     }

From a0d5b2331183d40edacc4a81a6022573d00a18a0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 20 Dec 2020 02:09:08 +0100
Subject: [PATCH 1230/1774] small improvement

---
 osal/host/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
index d73e6f275..aa32990be 100644
--- a/osal/host/CMakeLists.txt
+++ b/osal/host/CMakeLists.txt
@@ -13,9 +13,9 @@ target_sources(${LIB_FSFW_NAME}
 )
 
 if(UNIX)
-	add_definitions(-pthread)
 	target_link_libraries(${LIB_FSFW_NAME} 
 	PRIVATE
 		rt
+		pthread
 	)
 endif()
\ No newline at end of file

From 3540adf022c792c5ba3470482a2cc4e83aad96fa Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 20 Dec 2020 13:21:12 +0100
Subject: [PATCH 1231/1774] added warning flags

---
 CMakeLists.txt | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2fc33e588..084bd4ae9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -106,6 +106,15 @@ else()
 	)
 endif()
 
+set(WARNING_FLAGS
+	-Wall
+	-Wextra
+	-Wshadow=local
+	-Wimplicit-fallthrough=1
+	-Wno-unused-parameter
+	-Wno-psabi
+)
+
 # Required include paths to compile the FSFW
 target_include_directories(${LIB_FSFW_NAME} INTERFACE 
 	${CMAKE_SOURCE_DIR}
@@ -122,5 +131,6 @@ target_include_directories(${LIB_FSFW_NAME} PRIVATE
 
 # Machine specific options can be set with the ABI_FLAGS variable.
 target_compile_options(${LIB_FSFW_NAME} PRIVATE 
+	${WARNING_FLAGS}
 	${ABI_FLAGS}
 )

From d8e5000d47c705e4527f9cd8fe5c5960bdcea64f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 20 Dec 2020 15:32:03 +0100
Subject: [PATCH 1232/1774] msvc tests

---
 CMakeLists.txt                            | 23 +++++++++++++++--------
 coordinates/Sgp4Propagator.h              |  2 ++
 globalfunctions/timevalOperations.h       |  6 ++++++
 osal/Endiness.h                           | 14 ++++++++++++++
 serviceinterface/ServiceInterfaceBuffer.h |  2 +-
 timemanager/Clock.h                       |  2 ++
 6 files changed, 40 insertions(+), 9 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 084bd4ae9..02849ca44 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -106,14 +106,20 @@ else()
 	)
 endif()
 
-set(WARNING_FLAGS
-	-Wall
-	-Wextra
-	-Wshadow=local
-	-Wimplicit-fallthrough=1
-	-Wno-unused-parameter
-	-Wno-psabi
-)
+if(CMAKE_COMPILER_IS_GNUCXX)
+	set(WARNING_FLAGS
+		-Wall
+		-Wextra
+		-Wshadow=local
+		-Wimplicit-fallthrough=1
+		-Wno-unused-parameter
+		-Wno-psabi
+	)
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+	set(COMPILER_FLAGS "/permissive-")
+endif()
 
 # Required include paths to compile the FSFW
 target_include_directories(${LIB_FSFW_NAME} INTERFACE 
@@ -132,5 +138,6 @@ target_include_directories(${LIB_FSFW_NAME} PRIVATE
 # Machine specific options can be set with the ABI_FLAGS variable.
 target_compile_options(${LIB_FSFW_NAME} PRIVATE 
 	${WARNING_FLAGS}
+	${COMPILER_FLAGS}
 	${ABI_FLAGS}
 )
diff --git a/coordinates/Sgp4Propagator.h b/coordinates/Sgp4Propagator.h
index 3949547e1..f813c6f4d 100644
--- a/coordinates/Sgp4Propagator.h
+++ b/coordinates/Sgp4Propagator.h
@@ -1,7 +1,9 @@
 #ifndef SGP4PROPAGATOR_H_
 #define SGP4PROPAGATOR_H_
 
+#ifndef WIN32
 #include <sys/time.h>
+#endif
 #include "../contrib/sgp4/sgp4unit.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 
diff --git a/globalfunctions/timevalOperations.h b/globalfunctions/timevalOperations.h
index 3977d5d96..18eef866d 100644
--- a/globalfunctions/timevalOperations.h
+++ b/globalfunctions/timevalOperations.h
@@ -2,7 +2,13 @@
 #define TIMEVALOPERATIONS_H_
 
 #include <stdint.h>
+
+#ifdef WIN32
+// Why MSVC? Why? :)))
+#include <Windows.h>
+#else
 #include <sys/time.h>
+#endif
 
 timeval& operator+=(timeval& lhs, const timeval& rhs);
 
diff --git a/osal/Endiness.h b/osal/Endiness.h
index 65cc0a10f..9d3fdef0f 100644
--- a/osal/Endiness.h
+++ b/osal/Endiness.h
@@ -22,9 +22,23 @@
 #else
 #error "Can't decide which end is which!"
 #endif
+#else
+
+#ifdef WIN32
+#include <Windows.h>
+#if REG_DWORD == REG_DWORD_LITTLE_ENDIAN
+#define BYTE_ORDER_SYSTEM LITTLE_ENDIAN
+#else
+#define BYTE_ORDER_SYSTEM BIG_ENDIAN
+#endif
+
+
 #else
 #error __BYTE_ORDER__ not defined
 #endif
+
+#endif
+
 #endif
 
 
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index c5d5b2584..e69538d1d 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ protected:
 	//! This is called when buffer becomes full. If
 	//! buffer is not used, then this is called every
 	//! time when characters are put to stream.
-	int overflow(int c = Traits::eof()) override;
+	int overflow(int c = std::ostream::traits_type::eof()) override;
 
 	//! This function is called when stream is flushed,
 	//! for example when std::endl is put to stream.
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index d8b06fda5..7e27e40db 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -6,7 +6,9 @@
 #include "../globalfunctions/timevalOperations.h"
 
 #include <cstdint>
+#ifndef WIN32
 #include <sys/time.h>
+#endif
 
 //! Don't use these for time points, type is not large enough for UNIX epoch.
 using dur_millis_t = uint32_t;

From de183e6c6589386cbbfefe6ba56e0dc45a2f6faa Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 20 Dec 2020 17:01:22 +0100
Subject: [PATCH 1233/1774] removed comment

---
 globalfunctions/timevalOperations.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/globalfunctions/timevalOperations.h b/globalfunctions/timevalOperations.h
index 18eef866d..46f763b97 100644
--- a/globalfunctions/timevalOperations.h
+++ b/globalfunctions/timevalOperations.h
@@ -4,7 +4,6 @@
 #include <stdint.h>
 
 #ifdef WIN32
-// Why MSVC? Why? :)))
 #include <Windows.h>
 #else
 #include <sys/time.h>

From fc4da433d504efec43814e54dd91c62ed91b13c2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 13:49:42 +0100
Subject: [PATCH 1234/1774] using winsock2 now

---
 globalfunctions/timevalOperations.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/globalfunctions/timevalOperations.h b/globalfunctions/timevalOperations.h
index 46f763b97..db68f3304 100644
--- a/globalfunctions/timevalOperations.h
+++ b/globalfunctions/timevalOperations.h
@@ -4,7 +4,7 @@
 #include <stdint.h>
 
 #ifdef WIN32
-#include <Windows.h>
+#include <winsock2.h>
 #else
 #include <sys/time.h>
 #endif

From 5c45b823ad8807d4cd83e109eed7da87feceb56e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 13:52:41 +0100
Subject: [PATCH 1235/1774] include fix

---
 globalfunctions/timevalOperations.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/globalfunctions/timevalOperations.h b/globalfunctions/timevalOperations.h
index 46f763b97..db68f3304 100644
--- a/globalfunctions/timevalOperations.h
+++ b/globalfunctions/timevalOperations.h
@@ -4,7 +4,7 @@
 #include <stdint.h>
 
 #ifdef WIN32
-#include <Windows.h>
+#include <winsock2.h>
 #else
 #include <sys/time.h>
 #endif

From ca2571464680d6fbef9e011c61fbcabe9b178e84 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:01:48 +0100
Subject: [PATCH 1236/1774] upstream coordinates taken over

---
 coordinates/CMakeLists.txt   | 5 +++++
 coordinates/Sgp4Propagator.h | 2 ++
 2 files changed, 7 insertions(+)
 create mode 100644 coordinates/CMakeLists.txt

diff --git a/coordinates/CMakeLists.txt b/coordinates/CMakeLists.txt
new file mode 100644
index 000000000..a1fa1e52b
--- /dev/null
+++ b/coordinates/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CoordinateTransformations.cpp
+		Sgp4Propagator.cpp
+)
\ No newline at end of file
diff --git a/coordinates/Sgp4Propagator.h b/coordinates/Sgp4Propagator.h
index 3949547e1..f813c6f4d 100644
--- a/coordinates/Sgp4Propagator.h
+++ b/coordinates/Sgp4Propagator.h
@@ -1,7 +1,9 @@
 #ifndef SGP4PROPAGATOR_H_
 #define SGP4PROPAGATOR_H_
 
+#ifndef WIN32
 #include <sys/time.h>
+#endif
 #include "../contrib/sgp4/sgp4unit.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 

From de61d0c3ac331e179d0839284f1b537acf56f825 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:02:13 +0100
Subject: [PATCH 1237/1774] upstream timeval op

---
 globalfunctions/timevalOperations.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/globalfunctions/timevalOperations.h b/globalfunctions/timevalOperations.h
index 3977d5d96..db68f3304 100644
--- a/globalfunctions/timevalOperations.h
+++ b/globalfunctions/timevalOperations.h
@@ -2,7 +2,12 @@
 #define TIMEVALOPERATIONS_H_
 
 #include <stdint.h>
+
+#ifdef WIN32
+#include <winsock2.h>
+#else
 #include <sys/time.h>
+#endif
 
 timeval& operator+=(timeval& lhs, const timeval& rhs);
 

From e511dc61b48b12d944302a781326ad79811dfd8b Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:02:41 +0100
Subject: [PATCH 1238/1774] upstream osal endiness adapted

---
 osal/Endiness.h | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/osal/Endiness.h b/osal/Endiness.h
index 55d0aeb33..9d3fdef0f 100644
--- a/osal/Endiness.h
+++ b/osal/Endiness.h
@@ -1,10 +1,6 @@
 #ifndef FRAMEWORK_OSAL_ENDINESS_H_
 #define FRAMEWORK_OSAL_ENDINESS_H_
 
-/**
- * @defgroup osal Operating System Abstraction Layer
- * @brief Provides clean interfaces to use OS functionalities
- */
 
 /*
  * BSD-style endian declaration
@@ -26,9 +22,23 @@
 #else
 #error "Can't decide which end is which!"
 #endif
+#else
+
+#ifdef WIN32
+#include <Windows.h>
+#if REG_DWORD == REG_DWORD_LITTLE_ENDIAN
+#define BYTE_ORDER_SYSTEM LITTLE_ENDIAN
+#else
+#define BYTE_ORDER_SYSTEM BIG_ENDIAN
+#endif
+
+
 #else
 #error __BYTE_ORDER__ not defined
 #endif
+
+#endif
+
 #endif
 
 

From 30c9209c7488ac4bc69c1ee0bcd6424009d39c07 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:03:19 +0100
Subject: [PATCH 1239/1774] better win udp polling task error handling

---
 osal/windows/TcWinUdpPollingTask.cpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 7b54bb2cf..06deafd10 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -119,7 +119,7 @@ void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
 	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
 			reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
 	if(result == -1) {
-		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+		sif::error << "TcWinUdpPollingTask::TcSocketPollingTask: Setting "
 				"receive timeout failed with " << strerror(errno) << std::endl;
 	}
 }
@@ -128,17 +128,22 @@ void TcWinUdpPollingTask::handleReadError() {
     int error = WSAGetLastError();
     switch(error) {
     case(WSANOTINITIALISED): {
-        sif::info << "TmTcWinUdpBridge::handleReadError: WSANOTINITIALISED: "
+        sif::info << "TcWinUdpPollingTask::handleReadError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call " << "necessary" << std::endl;
         break;
     }
     case(WSAEFAULT): {
-        sif::info << "TmTcWinUdpBridge::handleReadError: WSADEFAULT: "
+        sif::info << "TcWinUdpPollingTask::handleReadError: WSADEFAULT: "
                 << "Bad address " << std::endl;
         break;
     }
+    case(WSAEINVAL): {
+        sif::info << "TcWinUdpPollingTask::handleReadError: WSAEINVAL: "
+                << "Invalid input parameters. " << std::endl;
+        break;
+    }
     default: {
-        sif::info << "TmTcWinUdpBridge::handleReadError: Error code: "
+        sif::info << "TcWinUdpPollingTask::handleReadError: Error code: "
                 << error << std::endl;
         break;
     }

From a6e38afb98317abb7d0c592fe7be9edee1cbb356 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:04:04 +0100
Subject: [PATCH 1240/1774] buffer more explicit eof()

---
 serviceinterface/ServiceInterfaceBuffer.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index c5d5b2584..e69538d1d 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ protected:
 	//! This is called when buffer becomes full. If
 	//! buffer is not used, then this is called every
 	//! time when characters are put to stream.
-	int overflow(int c = Traits::eof()) override;
+	int overflow(int c = std::ostream::traits_type::eof()) override;
 
 	//! This function is called when stream is flushed,
 	//! for example when std::endl is put to stream.

From 17a12b78073c98eb0abdce9f7c46df9c18e46fac Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:05:44 +0100
Subject: [PATCH 1241/1774] clock update

---
 timemanager/Clock.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index f4ed847ac..9f6f9885b 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -7,7 +7,12 @@
 #include "../globalfunctions/timevalOperations.h"
 
 #include <cstdint>
+
+#ifdef WIN32
+#include <winsock2.h>
+#else
 #include <sys/time.h>
+#endif
 
 class Clock {
 public:

From 1d080ba6cb3d6a73fa5647c32033ec718fe3bb72 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:07:06 +0100
Subject: [PATCH 1242/1774] clock update

---
 timemanager/Clock.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 7e27e40db..fcc602a2d 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -6,7 +6,10 @@
 #include "../globalfunctions/timevalOperations.h"
 
 #include <cstdint>
-#ifndef WIN32
+
+#ifdef WIN32
+#include <winsock2.h>
+#else
 #include <sys/time.h>
 #endif
 

From 59eab8866d8cd8c7f34c710ba6eec8e9845caab2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 17:16:44 +0100
Subject: [PATCH 1243/1774] using traits again

---
 serviceinterface/ServiceInterfaceBuffer.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index e69538d1d..c5d5b2584 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ protected:
 	//! This is called when buffer becomes full. If
 	//! buffer is not used, then this is called every
 	//! time when characters are put to stream.
-	int overflow(int c = std::ostream::traits_type::eof()) override;
+	int overflow(int c = Traits::eof()) override;
 
 	//! This function is called when stream is flushed,
 	//! for example when std::endl is put to stream.

From 71ee86a6884762e40b66fdafb700f9cce65b8cf7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 17:18:31 +0100
Subject: [PATCH 1244/1774] reverted sif buffer changes

---
 serviceinterface/ServiceInterfaceBuffer.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index e69538d1d..c5d5b2584 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ protected:
 	//! This is called when buffer becomes full. If
 	//! buffer is not used, then this is called every
 	//! time when characters are put to stream.
-	int overflow(int c = std::ostream::traits_type::eof()) override;
+	int overflow(int c = Traits::eof()) override;
 
 	//! This function is called when stream is flushed,
 	//! for example when std::endl is put to stream.

From 5317391f8a1077eebc179e3ce3df8cdb9e753315 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 17:19:43 +0100
Subject: [PATCH 1245/1774] reverted change

---
 serviceinterface/ServiceInterfaceBuffer.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index e69538d1d..c5d5b2584 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ protected:
 	//! This is called when buffer becomes full. If
 	//! buffer is not used, then this is called every
 	//! time when characters are put to stream.
-	int overflow(int c = std::ostream::traits_type::eof()) override;
+	int overflow(int c = Traits::eof()) override;
 
 	//! This function is called when stream is flushed,
 	//! for example when std::endl is put to stream.

From 31b82975c7ef701fa7f1ba3413cfa19cc73aa2ca Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 19:51:34 +0100
Subject: [PATCH 1246/1774] typo fix

---
 devicehandlers/DeviceHandlerIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index dba6b2288..e56487515 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -131,7 +131,7 @@ public:
 	// Standard codes used in  interpretDeviceReply
 	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
 	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
-	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t UNKNOWN_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
 	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
 
 	// Standard codes used in buildCommandFromCommand

From c2619bf07052faa2d36ec9e09468b2843aa1dac4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 23:39:24 +0100
Subject: [PATCH 1247/1774] transition delay not 0 anymore

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index f095834e2..53f5aea23 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -928,7 +928,7 @@ void DeviceHandlerBase::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
 
 uint32_t DeviceHandlerBase::getTransitionDelayMs(Mode_t modeFrom,
 		Mode_t modeTo) {
-	return 0;
+	return 5000;
 }
 
 ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {

From 6abc56009405b64e7536f919f025f4f443df8b6a Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 00:55:47 +0100
Subject: [PATCH 1248/1774] feed back include improvements

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 4 ++--
 defaultcfg/fsfwconfig/OBSWConfig.h | 4 ++++
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 334f352a1..dda8497d7 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -24,8 +24,8 @@
 #define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
-#include <translateObjects.h>
-#include <translateEvents.h>
+#include "objects/translateObjects.h"
+#include "events/translateEvents.h"
 #else
 #define FSFW_DEBUG_OUTPUT			0
 #endif
diff --git a/defaultcfg/fsfwconfig/OBSWConfig.h b/defaultcfg/fsfwconfig/OBSWConfig.h
index a9f576386..8ad2cb675 100644
--- a/defaultcfg/fsfwconfig/OBSWConfig.h
+++ b/defaultcfg/fsfwconfig/OBSWConfig.h
@@ -3,6 +3,10 @@
 
 #include "OBSWVersion.h"
 
+#include "objects/systemObjectList.h"
+#include "events/subsystemIdRanges.h"
+#include "returnvalues/classIds.h"
+
 #ifdef __cplusplus
 namespace config {
 #endif

From 38983407fd8973c48f4c23c02f3e8d7c34eb20da Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 00:22:35 +0100
Subject: [PATCH 1249/1774] added default implementation for setNormalDatapool

entries invalid
---
 devicehandlers/DeviceHandlerBase.cpp |  8 ++++
 devicehandlers/DeviceHandlerBase.h   | 69 ++++++++++++++--------------
 2 files changed, 43 insertions(+), 34 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 53f5aea23..cb0407145 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1459,3 +1459,11 @@ DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
     }
     return DeviceHandlerIF::NO_COMMAND;
 }
+
+void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
+	for(const auto& reply: deviceReplyMap) {
+		if(reply.second.dataSet != nullptr) {
+			reply.second.dataSet->setValidity(false, true);
+		}
+	}
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 9a5287e03..ee4447ed1 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -254,9 +254,10 @@ protected:
 	 *
 	 * @param[out] id the device command id that has been built
 	 * @return
-	 *    - @c RETURN_OK to send command after setting #rawPacket and #rawPacketLen.
-	 *    - @c NOTHING_TO_SEND when no command is to be sent.
-	 *    - Anything else triggers an even with the returnvalue as a parameter.
+	 *  - @c RETURN_OK to send command after setting #rawPacket and
+	 *    #rawPacketLen.
+	 *  - @c NOTHING_TO_SEND when no command is to be sent.
+	 *  - Anything else triggers an even with the returnvalue as a parameter.
 	 */
 	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
 
@@ -273,7 +274,8 @@ protected:
 	 * and filling them in doStartUp(), doShutDown() and doTransition() so no
 	 * modes have to be checked here.
 	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 * #rawPacket and #rawPacketLen must be set by this method to the
+	 * packet to be sent.
 	 *
 	 * @param[out] id the device command id built
 	 * @return
@@ -284,19 +286,23 @@ protected:
 	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
 
 	/**
-	 * @brief Build a device command packet from data supplied by a direct command.
+	 * @brief 	Build a device command packet from data supplied by a
+	 * 			direct command.
 	 *
 	 * @details
-	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
-	 * The existence of the command in the command map and the command size check
-	 * against 0 are done by the base class.
+	 * #rawPacket and #rawPacketLen should be set by this method to the packet
+	 * to be sent. The existence of the command in the command map and the
+	 * command size check against 0 are done by the base class.
 	 *
-	 * @param deviceCommand the command to build, already checked against deviceCommandMap
+	 * @param deviceCommand the command to build, already checked against
+	 * deviceCommandMap
 	 * @param commandData pointer to the data from the direct command
 	 * @param commandDataLen length of commandData
 	 * @return
-	 *     - @c RETURN_OK to send command after #rawPacket and #rawPacketLen have been set.
-	 *     - Anything else triggers an event with the returnvalue as a parameter
+	 *  - @c RETURN_OK to send command after #rawPacket and #rawPacketLen
+	 *       have been set.
+	 *  - Anything else triggers an event with the
+	 *    returnvalue as a parameter
 	 */
 	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
 			const uint8_t * commandData, size_t commandDataLen) = 0;
@@ -681,7 +687,7 @@ protected:
 		//! 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)
-		LocalPoolDataSetBase* dataSet;
+		LocalPoolDataSetBase* dataSet = nullptr;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -743,6 +749,17 @@ protected:
 	//!< Object which may be the root cause of an identified fault.
 	static object_id_t defaultFdirParentId;
 
+	/**
+	 * @brief   Set all datapool variables that are update periodically in
+	 *          normal mode invalid
+	 * @details
+	 * The default implementation will set all datasets which have been added
+	 * in #fillCommandAndReplyMap to invalid. It will also set all pool
+	 * variables inside the dataset to invalid. The user can override this
+	 * method optionally.
+	 */
+	virtual void setNormalDatapoolEntriesInvalid();
+
 	/**
 	 * Helper function to get pending command. This is useful for devices
 	 * like SPI sensors to identify the last sent command.
@@ -785,7 +802,6 @@ protected:
 	 *
 	 * The submode is left unchanged.
 	 *
-	 *
 	 * @param newMode
 	 */
 	void setMode(Mode_t newMode);
@@ -838,8 +854,6 @@ protected:
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
 
 	/**
-	 * Is the combination of mode and submode valid?
-	 *
 	 * @param mode
 	 * @param submode
 	 * @return
@@ -850,13 +864,10 @@ protected:
 			Submode_t submode);
 
 	/**
-	 * Get the Rmap action for the current step.
-	 *
+	 * Get the communication action for the current step.
 	 * The step number can be read from #pstStep.
-	 *
-	 * @return The Rmap action to execute in this step
+	 * @return The communication action to execute in this step
 	 */
-
 	virtual CommunicationAction getComAction();
 
 	/**
@@ -898,8 +909,8 @@ protected:
 	 * It gets space in the #IPCStore, copies data there, then sends a raw reply
 	 * containing the store address.
 	 *
-	 * This method is virtual, as the STR has a different channel to send
-	 * raw replies and overwrites it accordingly.
+	 * This method is virtual, as devices can have different channels to send
+	 * raw replies
 	 *
 	 * @param data data to send
 	 * @param len length of @c data
@@ -918,7 +929,7 @@ protected:
 	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
 
 	/**
-	 * notify child about mode change
+	 * @brief	Notify child about mode change.
 	 */
 	virtual void modeChanged(void);
 
@@ -950,8 +961,7 @@ protected:
 			DeviceCommandId_t alternateReplyID = 0);
 
 	/**
-	 * get the state of the PCDU switches in the datapool
-	 *
+	 * Get the state of the PCDU switches in the local datapool
 	 * @return
 	 *  - @c PowerSwitchIF::SWITCH_ON if all switches specified
 	 *       by #switches are on
@@ -961,15 +971,6 @@ protected:
 	 */
 	ReturnValue_t getStateOfSwitches(void);
 
-	/**
-	 * @brief   Set all datapool variables that are update periodically in
-	 *          normal mode invalid
-	 * @details TODO: Use local pools
-	 * Child classes should provide an implementation which sets all those
-	 * variables invalid which are set periodically during any normal mode.
-	 */
-	virtual void setNormalDatapoolEntriesInvalid() = 0;
-
 	/**
 	 * build a list of sids and pass it to the #hkSwitcher
 	 */

From 81201d6fb73393ce83b725b6a86c09bdc3586c2a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 00:39:51 +0100
Subject: [PATCH 1250/1774] typo

---
 devicehandlers/DeviceHandlerIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index dba6b2288..e56487515 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -131,7 +131,7 @@ public:
 	// Standard codes used in  interpretDeviceReply
 	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
 	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
-	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t UNKNOWN_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
 	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
 
 	// Standard codes used in buildCommandFromCommand

From b28bf35fc340cf9718af100c7531f15ea6bf1a8f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 12:44:55 +0100
Subject: [PATCH 1251/1774] devicehandler updates

---
 devicehandlers/DeviceHandlerBase.cpp | 10 +++-
 devicehandlers/DeviceHandlerBase.h   | 69 ++++++++++++++--------------
 devicehandlers/DeviceHandlerIF.h     |  2 +-
 3 files changed, 45 insertions(+), 36 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index f095834e2..cb0407145 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -928,7 +928,7 @@ void DeviceHandlerBase::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
 
 uint32_t DeviceHandlerBase::getTransitionDelayMs(Mode_t modeFrom,
 		Mode_t modeTo) {
-	return 0;
+	return 5000;
 }
 
 ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
@@ -1459,3 +1459,11 @@ DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
     }
     return DeviceHandlerIF::NO_COMMAND;
 }
+
+void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
+	for(const auto& reply: deviceReplyMap) {
+		if(reply.second.dataSet != nullptr) {
+			reply.second.dataSet->setValidity(false, true);
+		}
+	}
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 9a5287e03..ee4447ed1 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -254,9 +254,10 @@ protected:
 	 *
 	 * @param[out] id the device command id that has been built
 	 * @return
-	 *    - @c RETURN_OK to send command after setting #rawPacket and #rawPacketLen.
-	 *    - @c NOTHING_TO_SEND when no command is to be sent.
-	 *    - Anything else triggers an even with the returnvalue as a parameter.
+	 *  - @c RETURN_OK to send command after setting #rawPacket and
+	 *    #rawPacketLen.
+	 *  - @c NOTHING_TO_SEND when no command is to be sent.
+	 *  - Anything else triggers an even with the returnvalue as a parameter.
 	 */
 	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
 
@@ -273,7 +274,8 @@ protected:
 	 * and filling them in doStartUp(), doShutDown() and doTransition() so no
 	 * modes have to be checked here.
 	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 * #rawPacket and #rawPacketLen must be set by this method to the
+	 * packet to be sent.
 	 *
 	 * @param[out] id the device command id built
 	 * @return
@@ -284,19 +286,23 @@ protected:
 	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
 
 	/**
-	 * @brief Build a device command packet from data supplied by a direct command.
+	 * @brief 	Build a device command packet from data supplied by a
+	 * 			direct command.
 	 *
 	 * @details
-	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
-	 * The existence of the command in the command map and the command size check
-	 * against 0 are done by the base class.
+	 * #rawPacket and #rawPacketLen should be set by this method to the packet
+	 * to be sent. The existence of the command in the command map and the
+	 * command size check against 0 are done by the base class.
 	 *
-	 * @param deviceCommand the command to build, already checked against deviceCommandMap
+	 * @param deviceCommand the command to build, already checked against
+	 * deviceCommandMap
 	 * @param commandData pointer to the data from the direct command
 	 * @param commandDataLen length of commandData
 	 * @return
-	 *     - @c RETURN_OK to send command after #rawPacket and #rawPacketLen have been set.
-	 *     - Anything else triggers an event with the returnvalue as a parameter
+	 *  - @c RETURN_OK to send command after #rawPacket and #rawPacketLen
+	 *       have been set.
+	 *  - Anything else triggers an event with the
+	 *    returnvalue as a parameter
 	 */
 	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
 			const uint8_t * commandData, size_t commandDataLen) = 0;
@@ -681,7 +687,7 @@ protected:
 		//! 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)
-		LocalPoolDataSetBase* dataSet;
+		LocalPoolDataSetBase* dataSet = nullptr;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -743,6 +749,17 @@ protected:
 	//!< Object which may be the root cause of an identified fault.
 	static object_id_t defaultFdirParentId;
 
+	/**
+	 * @brief   Set all datapool variables that are update periodically in
+	 *          normal mode invalid
+	 * @details
+	 * The default implementation will set all datasets which have been added
+	 * in #fillCommandAndReplyMap to invalid. It will also set all pool
+	 * variables inside the dataset to invalid. The user can override this
+	 * method optionally.
+	 */
+	virtual void setNormalDatapoolEntriesInvalid();
+
 	/**
 	 * Helper function to get pending command. This is useful for devices
 	 * like SPI sensors to identify the last sent command.
@@ -785,7 +802,6 @@ protected:
 	 *
 	 * The submode is left unchanged.
 	 *
-	 *
 	 * @param newMode
 	 */
 	void setMode(Mode_t newMode);
@@ -838,8 +854,6 @@ protected:
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
 
 	/**
-	 * Is the combination of mode and submode valid?
-	 *
 	 * @param mode
 	 * @param submode
 	 * @return
@@ -850,13 +864,10 @@ protected:
 			Submode_t submode);
 
 	/**
-	 * Get the Rmap action for the current step.
-	 *
+	 * Get the communication action for the current step.
 	 * The step number can be read from #pstStep.
-	 *
-	 * @return The Rmap action to execute in this step
+	 * @return The communication action to execute in this step
 	 */
-
 	virtual CommunicationAction getComAction();
 
 	/**
@@ -898,8 +909,8 @@ protected:
 	 * It gets space in the #IPCStore, copies data there, then sends a raw reply
 	 * containing the store address.
 	 *
-	 * This method is virtual, as the STR has a different channel to send
-	 * raw replies and overwrites it accordingly.
+	 * This method is virtual, as devices can have different channels to send
+	 * raw replies
 	 *
 	 * @param data data to send
 	 * @param len length of @c data
@@ -918,7 +929,7 @@ protected:
 	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
 
 	/**
-	 * notify child about mode change
+	 * @brief	Notify child about mode change.
 	 */
 	virtual void modeChanged(void);
 
@@ -950,8 +961,7 @@ protected:
 			DeviceCommandId_t alternateReplyID = 0);
 
 	/**
-	 * get the state of the PCDU switches in the datapool
-	 *
+	 * Get the state of the PCDU switches in the local datapool
 	 * @return
 	 *  - @c PowerSwitchIF::SWITCH_ON if all switches specified
 	 *       by #switches are on
@@ -961,15 +971,6 @@ protected:
 	 */
 	ReturnValue_t getStateOfSwitches(void);
 
-	/**
-	 * @brief   Set all datapool variables that are update periodically in
-	 *          normal mode invalid
-	 * @details TODO: Use local pools
-	 * Child classes should provide an implementation which sets all those
-	 * variables invalid which are set periodically during any normal mode.
-	 */
-	virtual void setNormalDatapoolEntriesInvalid() = 0;
-
 	/**
 	 * build a list of sids and pass it to the #hkSwitcher
 	 */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index dba6b2288..e56487515 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -131,7 +131,7 @@ public:
 	// Standard codes used in  interpretDeviceReply
 	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
 	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
-	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t UNKNOWN_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
 	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
 
 	// Standard codes used in buildCommandFromCommand

From ca2d242adb50a4795de8f9d33459707aec93490c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 12:45:51 +0100
Subject: [PATCH 1252/1774] defaultcfg update

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 16 ++++++++--------
 defaultcfg/fsfwconfig/OBSWConfig.h |  4 ++++
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 1386bf66f..dda8497d7 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -15,12 +15,6 @@
 //! Can be used to enable additional debugging printouts for developing the FSFW
 #define FSFW_PRINT_VERBOSITY_LEVEL   0
 
-//! Defines the FIFO depth of each commanding service base which
-//! also determines how many commands a CSB service can handle in one cycle
-//! simulataneously. This will increase the required RAM for
-//! each CSB service !
-#define FSFW_CSB_FIFO_DEPTH			6
-
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
@@ -30,8 +24,8 @@
 #define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
-#include <translateObjects.h>
-#include <translateEvents.h>
+#include "objects/translateObjects.h"
+#include "events/translateEvents.h"
 #else
 #define FSFW_DEBUG_OUTPUT			0
 #endif
@@ -52,6 +46,12 @@ static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 8;
 static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
 static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
 static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/defaultcfg/fsfwconfig/OBSWConfig.h b/defaultcfg/fsfwconfig/OBSWConfig.h
index a9f576386..8ad2cb675 100644
--- a/defaultcfg/fsfwconfig/OBSWConfig.h
+++ b/defaultcfg/fsfwconfig/OBSWConfig.h
@@ -3,6 +3,10 @@
 
 #include "OBSWVersion.h"
 
+#include "objects/systemObjectList.h"
+#include "events/subsystemIdRanges.h"
+#include "returnvalues/classIds.h"
+
 #ifdef __cplusplus
 namespace config {
 #endif

From 9de2b054ef6155293237cc928ca97bf2a5b0c718 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 12:53:03 +0100
Subject: [PATCH 1253/1774] updated changelog

---
 CHANGELOG | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index 7b07db082..4e51bc64e 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -53,6 +53,12 @@ ID for now.
 
 - There is an additional `PERFORM_OPERATION` step for the device handler base. It is important
 that DHB users adapt their polling sequence tables to perform this step. This steps allows for aclear distinction between operation and communication steps
+- setNormalDatapoolEntriesInvalid is not an abstract method and a default implementation was provided
+- getTransitionDelayMs now return 5000 ms instead of 0 in default implementation
+
+### DeviceHandlerIF
+
+- Typo for UNKNOWN_DEVICE_REPLY 
 
 ### Events
 

From 6f756a721c9262cce17003d2dfe4163738e583d4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:05:59 +0100
Subject: [PATCH 1254/1774] clearing HK messagei ncluded now

---
 ipc/CommandMessageCleaner.cpp | 8 ++++++--
 ipc/MessageQueueMessageIF.h   | 2 +-
 ipc/MutexFactory.h            | 6 +++---
 ipc/MutexHelper.h             | 4 ++--
 4 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
index 6a99b4d2d..6a3640699 100644
--- a/ipc/CommandMessageCleaner.cpp
+++ b/ipc/CommandMessageCleaner.cpp
@@ -1,4 +1,4 @@
-#include "../ipc/CommandMessageCleaner.h"
+#include "CommandMessageCleaner.h"
 
 #include "../devicehandlers/DeviceHandlerMessage.h"
 #include "../health/HealthMessage.h"
@@ -7,11 +7,12 @@
 #include "../monitoring/MonitoringMessage.h"
 #include "../subsystem/modes/ModeSequenceMessage.h"
 #include "../tmstorage/TmStoreMessage.h"
+#include "../housekeeping/HousekeepingMessage.h"
 #include "../parameters/ParameterMessage.h"
 
 void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
 	switch(message->getMessageType()){
-	case  messagetypes::MODE_COMMAND:
+	case messagetypes::MODE_COMMAND:
 		ModeMessage::clear(message);
 		break;
 	case messagetypes::HEALTH_COMMAND:
@@ -38,6 +39,9 @@ void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
 	case messagetypes::PARAMETER:
 		ParameterMessage::clear(message);
 		break;
+	case messagetypes::HOUSEKEEPING:
+	    HousekeepingMessage::clear(message);
+	    break;
 	default:
 		messagetypes::clearMissionMessage(message);
 		break;
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index b5a30c086..33e01e7d0 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 
-#include <fsfw/ipc/messageQueueDefinitions.h>
+#include "messageQueueDefinitions.h"
 #include <cstddef>
 #include <cstdint>
 
diff --git a/ipc/MutexFactory.h b/ipc/MutexFactory.h
index f8133d814..db505ff94 100644
--- a/ipc/MutexFactory.h
+++ b/ipc/MutexFactory.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
-#define FRAMEWORK_IPC_MUTEXFACTORY_H_
+#ifndef FSFW_IPC_MUTEXFACTORY_H_
+#define FSFW_IPC_MUTEXFACTORY_H_
 
 #include "MutexIF.h"
 /**
@@ -31,4 +31,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_IPC_MUTEXFACTORY_H_ */
+#endif /* FSFW_IPC_MUTEXFACTORY_H_ */
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 3dc369213..97001ade9 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -16,8 +16,8 @@ public:
 					<< timeoutMs << " milliseconds!" << std::endl;
 		}
 		else if(status != HasReturnvaluesIF::RETURN_OK){
-			sif::error << "MutexHelper: Lock of Mutex failed with code " <<
-					status << std::endl;
+			sif::error << "MutexHelper: Lock of Mutex failed with code "
+			        << status << std::endl;
 		}
 	}
 

From 770336fff3de55194b4b0e6fc3f9f582f2ed3ef9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:06:35 +0100
Subject: [PATCH 1255/1774] added ipc cmakelists

---
 ipc/CMakeLists.txt | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 ipc/CMakeLists.txt

diff --git a/ipc/CMakeLists.txt b/ipc/CMakeLists.txt
new file mode 100644
index 000000000..6a3afe33e
--- /dev/null
+++ b/ipc/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CommandMessage.cpp
+		CommandMessageCleaner.cpp
+		MessageQueueMessage.cpp
+)
\ No newline at end of file

From b97b67d56e362ef1a329cb0f118653b9f5cc5ea0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:19:07 +0100
Subject: [PATCH 1256/1774] updating unittest folder

---
 unittest/core/CatchSetup.cpp                    | 6 +-----
 unittest/testcfg/{objects => }/CatchFactory.cpp | 0
 unittest/testcfg/{objects => }/CatchFactory.h   | 0
 unittest/testcfg/testcfg.mk                     | 8 --------
 4 files changed, 1 insertion(+), 13 deletions(-)
 rename unittest/testcfg/{objects => }/CatchFactory.cpp (100%)
 rename unittest/testcfg/{objects => }/CatchFactory.h (100%)

diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index cb5bd33ed..99ee63b55 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,5 +1,5 @@
 #include "CatchDefinitions.h"
-#include "CatchFactory.h"
+#include <CatchFactory.h>
 
 #include <testcfg/cdatapool/dataPoolInit.h>
 
@@ -10,15 +10,11 @@
 #include "../../objectmanager/ObjectManager.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../datapool/DataPool.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 
 /* Global instantiations normally done in main.cpp */
 /* Initialize Data Pool */
-//namespace glob {
-DataPool dataPool(datapool::dataPoolInit);
-//}
 
 
 namespace sif {
diff --git a/unittest/testcfg/objects/CatchFactory.cpp b/unittest/testcfg/CatchFactory.cpp
similarity index 100%
rename from unittest/testcfg/objects/CatchFactory.cpp
rename to unittest/testcfg/CatchFactory.cpp
diff --git a/unittest/testcfg/objects/CatchFactory.h b/unittest/testcfg/CatchFactory.h
similarity index 100%
rename from unittest/testcfg/objects/CatchFactory.h
rename to unittest/testcfg/CatchFactory.h
diff --git a/unittest/testcfg/testcfg.mk b/unittest/testcfg/testcfg.mk
index 31d3b60a5..fca2f7327 100644
--- a/unittest/testcfg/testcfg.mk
+++ b/unittest/testcfg/testcfg.mk
@@ -6,11 +6,3 @@ CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
 
 INCLUDES += $(CURRENTPATH)
-INCLUDES += $(CURRENTPATH)/objects
-INCLUDES += $(CURRENTPATH)/ipc
-INCLUDES += $(CURRENTPATH)/pollingsequence
-INCLUDES += $(CURRENTPATH)/returnvalues
-INCLUDES += $(CURRENTPATH)/tmtc
-INCLUDES += $(CURRENTPATH)/events
-INCLUDES += $(CURRENTPATH)/devices
-INCLUDES += $(CURRENTPATH)/cdatapool

From e41aba719c93fe25cf97d8cccee5cb2a01a3530f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:20:17 +0100
Subject: [PATCH 1257/1774] updated testcfg

---
 unittest/testcfg/FSFWConfig.h | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 418992faf..94f6e59d1 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -1,5 +1,5 @@
-#ifndef FSFWCONFIG_FSFWCONFIG_H_
-#define FSFWCONFIG_FSFWCONFIG_H_
+#ifndef CONFIG_FSFWCONFIG_H_
+#define CONFIG_FSFWCONFIG_H_
 
 #include <cstddef>
 #include <cstdint>
@@ -18,19 +18,21 @@
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
-#define FSFW_OBJ_EVENT_TRANSLATION	1
+#define FSFW_OBJ_EVENT_TRANSLATION	0
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
+#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
-#include <translateObjects.h>
-#include <translateEvents.h>
+#include "objects/translateObjects.h"
+#include "events/translateEvents.h"
 #else
+#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities
 //! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NO_C99_IO 	1
+#define FSFW_NO_C99_IO 	            1
 
 //! Specify whether a special mode store is used for Subsystem components.
 #define FSFW_USE_MODESTORE          0
@@ -52,4 +54,4 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 3;
 }
 
-#endif /* FSFWCONFIG_FSFWCONFIG_H_ */
+#endif /* CONFIG_FSFWCONFIG_H_ */

From 5e8aff0603c6507b6f417ecb882446b25b9b54f7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:25:00 +0100
Subject: [PATCH 1258/1774] unittest update

---
 unittest/{testcfg => core}/CatchFactory.cpp |  0
 unittest/{testcfg => core}/CatchFactory.h   |  6 +++---
 unittest/core/CatchSetup.cpp                |  3 +--
 unittest/testcfg/Makefile-FSFW-Tests        | 13 +++++++------
 4 files changed, 11 insertions(+), 11 deletions(-)
 rename unittest/{testcfg => core}/CatchFactory.cpp (100%)
 rename unittest/{testcfg => core}/CatchFactory.h (71%)

diff --git a/unittest/testcfg/CatchFactory.cpp b/unittest/core/CatchFactory.cpp
similarity index 100%
rename from unittest/testcfg/CatchFactory.cpp
rename to unittest/core/CatchFactory.cpp
diff --git a/unittest/testcfg/CatchFactory.h b/unittest/core/CatchFactory.h
similarity index 71%
rename from unittest/testcfg/CatchFactory.h
rename to unittest/core/CatchFactory.h
index 84f9207e2..f06e7ae55 100644
--- a/unittest/testcfg/CatchFactory.h
+++ b/unittest/core/CatchFactory.h
@@ -1,5 +1,5 @@
-#ifndef FACTORY_H_
-#define FACTORY_H_
+#ifndef FSFW_CATCHFACTORY_H_
+#define FSFW_CATCHFACTORY_H_
 
 #include <fsfw/objectmanager/SystemObjectIF.h>
 
@@ -13,4 +13,4 @@ namespace Factory {
 
 }
 
-#endif /* FACTORY_H_ */
+#endif /* FSFW_CATCHFACTORY_H_ */
diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index 99ee63b55..c93cf0323 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,6 +1,5 @@
+#include <fsfw/unittest/core/CatchFactory.h>
 #include "CatchDefinitions.h"
-#include <CatchFactory.h>
-
 #include <testcfg/cdatapool/dataPoolInit.h>
 
 #ifdef GCOV
diff --git a/unittest/testcfg/Makefile-FSFW-Tests b/unittest/testcfg/Makefile-FSFW-Tests
index 2017d2bd8..550fd1dee 100644
--- a/unittest/testcfg/Makefile-FSFW-Tests
+++ b/unittest/testcfg/Makefile-FSFW-Tests
@@ -15,7 +15,7 @@ SHELL = /bin/sh
 # (can be overriden by adding CHIP=chip and BOARD=board to the command-line)
 # Unit Test can only be run on host machine for now (Linux)
 FRAMEWORK_PATH = fsfw
-FILE_ROOT = $(FRAMEWORK_PATH)/unittest
+TEST_FILE_ROOT = $(FRAMEWORK_PATH)/unittest
 BOARD = unittest
 LINUX = 1
 OS_FSFW = linux
@@ -58,9 +58,10 @@ endif
 
 UNIT_TEST = 1
 # General folder paths
-CONFIG_PATH = $(FILE_ROOT)/config
-UNIT_TEST_PATH = $(FILE_ROOT)/tests
-CORE_PATH = $(FILE_ROOT)/core
+CONFIG_PATH = testcfg
+# Core copy has to be copied as well.
+CORE_PATH = core
+UNIT_TEST_PATH = $(TEST_FILE_ROOT)/tests
 
 # Output file basename
 BASENAME = fsfw
@@ -154,8 +155,8 @@ include $(S)/$(notdir $S).mk
 endef
 $(foreach S,$(SUBDIRS),$(eval $(INCLUDE_FILE)))
 
-INCLUDES += $(FILE_ROOT)
-INCLUDES += $(FILE_ROOT)/catch2/
+INCLUDES += $(TEST_FILE_ROOT)
+INCLUDES += $(TEST_FILE_ROOT)/catch2/
 
 #-------------------------------------------------------------------------------
 #		Source Files

From ee05a34c9ead0bd79b0209afcf8ba9f070db758a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:27:47 +0100
Subject: [PATCH 1259/1774] added gitmodules

---
 .gitmodules | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 .gitmodules

diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 000000000..e69de29bb

From 95a8dd418c487c3b0ab2a76d1e85ff3221a23a22 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:29:58 +0100
Subject: [PATCH 1260/1774] added cmake lists

---
 datapool/CMakeLists.txt | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 datapool/CMakeLists.txt

diff --git a/datapool/CMakeLists.txt b/datapool/CMakeLists.txt
new file mode 100644
index 000000000..e741f6a13
--- /dev/null
+++ b/datapool/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ControllerSet.cpp
+		DataPool.cpp
+		DataPoolAdmin.cpp
+		DataPoolParameterWrapper.cpp
+		DataSet.cpp
+		HkSwitchHelper.cpp
+		PoolEntry.cpp
+		PoolRawAccess.cpp
+)
\ No newline at end of file

From 632f319a2f181207ad3309c109ff790e919e4abd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:19:00 +0100
Subject: [PATCH 1261/1774] updated readme

---
 README.md                     | 93 +++++++++++------------------------
 doc/README-config.md          | 21 ++++++++
 doc/README-core.md            | 50 +++++++++++++++++++
 doc/README-devicehandlers.txt |  0
 4 files changed, 100 insertions(+), 64 deletions(-)
 create mode 100644 doc/README-config.md
 create mode 100644 doc/README-core.md
 create mode 100644 doc/README-devicehandlers.txt

diff --git a/README.md b/README.md
index fd652f1dd..9d5a158c6 100644
--- a/README.md
+++ b/README.md
@@ -18,79 +18,48 @@ The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB
 For reference, current Applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC.
 The `fsfw` was also tested on the STM32H743ZI-Nucleo board.
 
+## How to Use
+
+The [FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example) provides a good starting point and a demo
+to see the FSFW capabilities. Generally, the FSFW is included in a project by compiling the FSFW sources and providing
+a configuration folder. A template configuration folder was provided and can be copied into the project root to have
+a starting point. The [configuration section](doc/README-config.md#top) provides more specific information about
+the possible options.
+
 ## Structure
 
-The general structure is driven by the usage of interfaces provided by objects. The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
+The general structure is driven by the usage of interfaces provided by objects. 
+The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
 The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
 This simplifies the instantiation of objects and allows the usage of some standard containers. 
 Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
-The fsfw uses Run-time type information.
-Exceptions are not allowed.
+The fsfw uses run-time type information but exceptions are not allowed.
 
 ### Failure Handling
 
-Functions should return a defined ReturnValue_t to signal to the caller that something is gone wrong. 
+Functions should return a defined ReturnValue_t to signal to the caller that something has gone wrong. 
 Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
 The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
 
 ### OSAL
-The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. A independent OSAL called "host" is currently not finished. This aims to be running on windows as well. 
+
+The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
+A independent OSAL called "host" is in development. 
+This OSAL is intended to provide abstraction for common type of host OSes (tested for Linux and Windows, not for MacOS yet).
 The OSAL provides periodic tasks, message queues, clocks and Semaphores as well as Mutexes.
 
 ### Core Components 
 
-Clock:
- * This is a class of static functions that can be used at anytime
- * Leap Seconds must be set if any time conversions from UTC to other times is used
-
-ObjectManager (must be created): 
-
-* The component which handles all references. All SystemObjects register at this component. 
-* Any SystemObject needs to have a unique ObjectId. Those can be managed like objects::framework_objects.
-* A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
-A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
-
-``` c++
-	template <typename T> T* ObjectManagerIF::get( object_id_t id )
-
-```
-* A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
-By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.
-
-Event Manager:
-
-* Component which allows routing of events
-* Other objects can subscribe to specific events, ranges of events or all events of an object.
-* Subscriptions can be done during runtime but should be done during initialization
-* Amounts of allowed subscriptions must be configured by setting this parameters:
-
-``` c++
-namespace fsfwconfig {
-//! Configure the allocated pool sizes for the event manager.
-static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
-static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
-static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
-}
-```
-
-
-Health Table:
-
-* A component which holds every health state 
-* Provides a thread safe way to access all health states without the need of message exchanges
-
-Stores
-
-* The message based communication can only exchange a few bytes of information inside the message itself. Therefore, additional information can be exchanged with Stores. With this, only the store address must be exchanged in the message.
-* Internally, the FSFW uses an IPC Store to exchange data between processes. For incoming TCs a TC Store is used. For outgoing TM a TM store is used.
-* All of them should use the Thread Safe Class storagemanager/PoolManager
-
-Tasks
-
-There are two different types of tasks:
- * The PeriodicTask just executes objects that are of type ExecutableObjectIF in the order of the insertion to the Tasks.
- * FixedTimeslotTask executes a list of calls in the order of the given list. This is intended for DeviceHandlers, where polling should be in a defined order. An example can be found in defaultcfg/fsfwconfig/pollingSequence
+The FSFW has following core components. More detailed informations can be found in the
+[core component section](doc/README-core.md#top):
 
+1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks with fixed timeslots
+2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID to the object handles.
+3. Static Stores: Different stores are provided to store data of variable size (like telecommands or small telemetry) in a pool structure without
+   using dynamic memory allocation. These pools are allocated up front.
+3. Clock: This module provided common time related functions
+4. EventManager: This module allows routing of events generated by `SystemObjects`
+5. HealthTable: A component which stores the health states of objects
 
 ### Static Ids in the framework
 
@@ -123,12 +92,13 @@ An example can be found in the timemanager folder, this uses CCSDSTime::CDS_shor
 
 #### Device Handlers
 
-DeviceHandlers are a core component of the FSFW. 
+DeviceHandlers are another important component of the FSFW. 
 The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
-By separating the underlying Communication Interface with DeviceCommunicationIF, a DH can be tested on different hardware.
+By separating the underlying Communication Interface with DeviceCommunicationIF, a device handler (DH) can be tested on different hardware.
 The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
-Device Handlers can be created by overriding `DeviceHandlerBase`.
+Device Handlers can be created by overriding `DeviceHandlerBase`. 
 A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
+More information on DeviceHandlers can be found in the related [documentation section](doc/README-devicehandlers.md#top).
 
 #### Modes, Health
 
@@ -150,11 +120,6 @@ The health state represents if the component is able to perform its tasks.
 This can be used to signal the system to avoid using this component instead of a redundant one.
 The on-board FDIR uses the health state for isolation and recovery. 
 
-## Example config
-
-A example config can be found in defaultcfg/fsfwconfig. The fsfw will require certain configuration files,
-so a configuration folder should be provided and the folder should be added to the include path.
-
 ## Unit Tests
 
 Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. 
diff --git a/doc/README-config.md b/doc/README-config.md
new file mode 100644
index 000000000..036a7d14c
--- /dev/null
+++ b/doc/README-config.md
@@ -0,0 +1,21 @@
+
+## Configuring the FSFW
+
+The FSFW can be configured via the `fsfwconfig` folder. A template folder has
+been provided to have a starting point for this. The folder should be added
+to the include path.
+
+
+### Configuring the Event Manager
+
+The number of allowed subscriptions can be modified with the following
+parameters:
+
+``` c++
+namespace fsfwconfig {
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+}
+```
\ No newline at end of file
diff --git a/doc/README-core.md b/doc/README-core.md
new file mode 100644
index 000000000..c47ae0f29
--- /dev/null
+++ b/doc/README-core.md
@@ -0,0 +1,50 @@
+## FSFW Core Modules
+
+These core modules provide the most important functionalities of the 
+Flight Software Framework
+
+### Clock
+
+ * This is a class of static functions that can be used at anytime
+ * Leap Seconds must be set if any time conversions from UTC to other times is used
+
+### ObjectManager
+
+* Must be created during program startup
+* The component which handles all references. All SystemObjects register at this component. 
+* Any SystemObject needs to have a unique ObjectId. Those can be managed like objects::framework_objects.
+* A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
+A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
+
+``` c++
+	template <typename T> T* ObjectManagerIF::get( object_id_t id )
+
+```
+* A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
+By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.
+
+### Event Manager
+
+* Component which allows routing of events
+* Other objects can subscribe to specific events, ranges of events or all events of an object.
+* Subscriptions can be done during runtime but should be done during initialization
+* Amounts of allowed subscriptions can be configured in `FSFWConfig.h`
+
+### Health Table
+
+* A component which holds every health state 
+* Provides a thread safe way to access all health states without the need of message exchanges
+
+### Stores
+
+* The message based communication can only exchange a few bytes of information inside the message itself. Therefore, additional information can 
+  be exchanged with Stores. With this, only the store address must be exchanged in the message.
+* Internally, the FSFW uses an IPC Store to exchange data between processes. For incoming TCs a TC Store is used. For outgoing TM a TM store is used.
+* All of them should use the Thread Safe Class storagemanager/PoolManager
+
+### Tasks
+
+There are two different types of tasks:
+ * The PeriodicTask just executes objects that are of type ExecutableObjectIF in the order of the insertion to the Tasks.
+ * FixedTimeslotTask executes a list of calls in the order of the given list. This is intended for DeviceHandlers, where polling should be in a defined order. An example can be found in defaultcfg/fsfwconfig/pollingSequence
+
diff --git a/doc/README-devicehandlers.txt b/doc/README-devicehandlers.txt
new file mode 100644
index 000000000..e69de29bb

From 88967529277732fca91a74696a06d63dd43cd3fa Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:22:10 +0100
Subject: [PATCH 1262/1774] updated readme

---
 README.md | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 9d5a158c6..8552e0c81 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,5 @@
 ![FSFW Logo](logo/FSFW_Logo_V3_bw.png)
+
 # Flight Software Framework (FSFW)
 
 The Flight Software Framework is a C++ Object Oriented Framework for unmanned,
@@ -21,8 +22,10 @@ The `fsfw` was also tested on the STM32H743ZI-Nucleo board.
 ## How to Use
 
 The [FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example) provides a good starting point and a demo
-to see the FSFW capabilities. Generally, the FSFW is included in a project by compiling the FSFW sources and providing
-a configuration folder. A template configuration folder was provided and can be copied into the project root to have
+to see the FSFW capabilities and build it with the Make or the CMake build system. 
+Generally, the FSFW is included in a project by compiling the FSFW sources and providing
+a configuration folder and adding it to the include path. 
+A template configuration folder was provided and can be copied into the project root to have
 a starting point. The [configuration section](doc/README-config.md#top) provides more specific information about
 the possible options.
 
@@ -44,9 +47,9 @@ The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds
 ### OSAL
 
 The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
-A independent OSAL called "host" is in development. 
-This OSAL is intended to provide abstraction for common type of host OSes (tested for Linux and Windows, not for MacOS yet).
-The OSAL provides periodic tasks, message queues, clocks and Semaphores as well as Mutexes.
+A independent Host OSAL is in development which will provide abstraction for common type of 
+host OSes (tested for Linux and Windows, not for MacOS yet).
+The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
 
 ### Core Components 
 

From 820731de7bfa40d88a592a927031793bbc73f873 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:23:19 +0100
Subject: [PATCH 1263/1774] updated docs, added new doc folder

---
 README.md                     | 100 ++++++++++++----------------------
 doc/README-config.md          |  21 +++++++
 doc/README-core.md            |  50 +++++++++++++++++
 doc/README-devicehandlers.txt |   0
 4 files changed, 106 insertions(+), 65 deletions(-)
 create mode 100644 doc/README-config.md
 create mode 100644 doc/README-core.md
 create mode 100644 doc/README-devicehandlers.txt

diff --git a/README.md b/README.md
index 4aabe36a9..8552e0c81 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,5 @@
 ![FSFW Logo](logo/FSFW_Logo_V3_bw.png)
+
 # Flight Software Framework (FSFW)
 
 The Flight Software Framework is a C++ Object Oriented Framework for unmanned,
@@ -14,83 +15,54 @@ The framework is designed for systems, which communicate with external devices,
 Therefore, a mode and health system provides control over the states of the software and the controlled devices. 
 In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 
 
-The recommended hardware is a microprocessor with more than 2 MB of RAM and 1 MB of non-volatile Memory. 
+The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile Memory. 
 For reference, current Applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC.
+The `fsfw` was also tested on the STM32H743ZI-Nucleo board.
 
+## How to Use
+
+The [FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example) provides a good starting point and a demo
+to see the FSFW capabilities and build it with the Make or the CMake build system. 
+Generally, the FSFW is included in a project by compiling the FSFW sources and providing
+a configuration folder and adding it to the include path. 
+A template configuration folder was provided and can be copied into the project root to have
+a starting point. The [configuration section](doc/README-config.md#top) provides more specific information about
+the possible options.
 
 ## Structure
 
-The general structure is driven by the usage of interfaces provided by objects. The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
+The general structure is driven by the usage of interfaces provided by objects. 
+The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
 The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
 This simplifies the instantiation of objects and allows the usage of some standard containers. 
 Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
-The fsfw uses Run-time type information.
-Exceptions are not allowed.
+The fsfw uses run-time type information but exceptions are not allowed.
 
 ### Failure Handling
 
-Functions should return a defined ReturnValue_t to signal to the caller that something is gone wrong. 
+Functions should return a defined ReturnValue_t to signal to the caller that something has gone wrong. 
 Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
 The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
 
 ### OSAL
-The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. A independent OSAL called "host" is currently not finished. This aims to be running on windows as well. 
-The OSAL provides periodic tasks, message queues, clocks and Semaphores as well as Mutexes.
+
+The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
+A independent Host OSAL is in development which will provide abstraction for common type of 
+host OSes (tested for Linux and Windows, not for MacOS yet).
+The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
 
 ### Core Components 
 
-Clock:
- * This is a class of static functions that can be used at anytime
- * Leap Seconds must be set if any time conversions from UTC to other times is used
-
-ObjectManager (must be created): 
-
-* The component which handles all references. All SystemObjects register at this component. 
-* Any SystemObject needs to have a unique ObjectId. Those can be managed like objects::framework_objects.
-* A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
-A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
-
-``` c++
-	template <typename T> T* ObjectManagerIF::get( object_id_t id )
-
-```
-* A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
-By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.
-
-Event Manager:
-
-* Component which allows routing of events
-* Other objects can subscribe to specific events, ranges of events or all events of an object.
-* Subscriptions can be done during runtime but should be done during initialization
-* Amounts of allowed subscriptions must be configured by setting this parameters:
-
-``` c++
-namespace fsfwconfig {
-//! Configure the allocated pool sizes for the event manager.
-static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
-static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
-static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
-}
-```
-
-
-Health Table:
-
-* A component which holds every health state 
-* Provides a thread safe way to access all health states without the need of message exchanges
-
-Stores
-
-* The message based communication can only exchange a few bytes of information inside the message itself. Therefore, additional information can be exchanged with Stores. With this, only the store address must be exchanged in the message.
-* Internally, the FSFW uses an IPC Store to exchange data between processes. For incoming TCs a TC Store is used. For outgoing TM a TM store is used.
-* All of them should use the Thread Safe Class storagemanager/PoolManager
-
-Tasks
-
-There are two different types of tasks:
- * The PeriodicTask just executes objects that are of type ExecutableObjectIF in the order of the insertion to the Tasks.
- * FixedTimeslotTask executes a list of calls in the order of the given list. This is intended for DeviceHandlers, where polling should be in a defined order. An example can be found in defaultcfg/fsfwconfig/pollingSequence
+The FSFW has following core components. More detailed informations can be found in the
+[core component section](doc/README-core.md#top):
 
+1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks with fixed timeslots
+2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID to the object handles.
+3. Static Stores: Different stores are provided to store data of variable size (like telecommands or small telemetry) in a pool structure without
+   using dynamic memory allocation. These pools are allocated up front.
+3. Clock: This module provided common time related functions
+4. EventManager: This module allows routing of events generated by `SystemObjects`
+5. HealthTable: A component which stores the health states of objects
 
 ### Static Ids in the framework
 
@@ -121,13 +93,15 @@ If the communication is based on CCSDS Frames and Space Packets, several classes
 If Space Packets are used, a timestamper must be created. 
 An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
 
-#### DeviceHandling
+#### Device Handlers
 
-DeviceHandlers are a core component of the FSFW. 
+DeviceHandlers are another important component of the FSFW. 
 The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
-By separating the underlying Communication Interface with DeviceCommunicationIF, a DH can be tested on different hardware.
+By separating the underlying Communication Interface with DeviceCommunicationIF, a device handler (DH) can be tested on different hardware.
 The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
+Device Handlers can be created by overriding `DeviceHandlerBase`. 
 A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
+More information on DeviceHandlers can be found in the related [documentation section](doc/README-devicehandlers.md#top).
 
 #### Modes, Health
 
@@ -149,10 +123,6 @@ The health state represents if the component is able to perform its tasks.
 This can be used to signal the system to avoid using this component instead of a redundant one.
 The on-board FDIR uses the health state for isolation and recovery. 
 
-## Example config
-
-A example config can be found in defaultcfg/fsfwconfig.
-
 ## Unit Tests
 
 Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. 
diff --git a/doc/README-config.md b/doc/README-config.md
new file mode 100644
index 000000000..036a7d14c
--- /dev/null
+++ b/doc/README-config.md
@@ -0,0 +1,21 @@
+
+## Configuring the FSFW
+
+The FSFW can be configured via the `fsfwconfig` folder. A template folder has
+been provided to have a starting point for this. The folder should be added
+to the include path.
+
+
+### Configuring the Event Manager
+
+The number of allowed subscriptions can be modified with the following
+parameters:
+
+``` c++
+namespace fsfwconfig {
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+}
+```
\ No newline at end of file
diff --git a/doc/README-core.md b/doc/README-core.md
new file mode 100644
index 000000000..c47ae0f29
--- /dev/null
+++ b/doc/README-core.md
@@ -0,0 +1,50 @@
+## FSFW Core Modules
+
+These core modules provide the most important functionalities of the 
+Flight Software Framework
+
+### Clock
+
+ * This is a class of static functions that can be used at anytime
+ * Leap Seconds must be set if any time conversions from UTC to other times is used
+
+### ObjectManager
+
+* Must be created during program startup
+* The component which handles all references. All SystemObjects register at this component. 
+* Any SystemObject needs to have a unique ObjectId. Those can be managed like objects::framework_objects.
+* A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
+A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
+
+``` c++
+	template <typename T> T* ObjectManagerIF::get( object_id_t id )
+
+```
+* A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
+By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.
+
+### Event Manager
+
+* Component which allows routing of events
+* Other objects can subscribe to specific events, ranges of events or all events of an object.
+* Subscriptions can be done during runtime but should be done during initialization
+* Amounts of allowed subscriptions can be configured in `FSFWConfig.h`
+
+### Health Table
+
+* A component which holds every health state 
+* Provides a thread safe way to access all health states without the need of message exchanges
+
+### Stores
+
+* The message based communication can only exchange a few bytes of information inside the message itself. Therefore, additional information can 
+  be exchanged with Stores. With this, only the store address must be exchanged in the message.
+* Internally, the FSFW uses an IPC Store to exchange data between processes. For incoming TCs a TC Store is used. For outgoing TM a TM store is used.
+* All of them should use the Thread Safe Class storagemanager/PoolManager
+
+### Tasks
+
+There are two different types of tasks:
+ * The PeriodicTask just executes objects that are of type ExecutableObjectIF in the order of the insertion to the Tasks.
+ * FixedTimeslotTask executes a list of calls in the order of the given list. This is intended for DeviceHandlers, where polling should be in a defined order. An example can be found in defaultcfg/fsfwconfig/pollingSequence
+
diff --git a/doc/README-devicehandlers.txt b/doc/README-devicehandlers.txt
new file mode 100644
index 000000000..e69de29bb

From 6b1a8afe2b50a59f35946086ee6e846c28742ae1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:25:50 +0100
Subject: [PATCH 1264/1774] unittest update 2

---
 .../objects => core}/CatchFactory.cpp         |  0
 .../{testcfg/objects => core}/CatchFactory.h  |  6 +--
 unittest/core/CatchSetup.cpp                  |  7 +--
 unittest/testcfg/FSFWConfig.h                 | 49 ++++++++++++-------
 unittest/testcfg/Makefile-FSFW-Tests          | 13 ++---
 unittest/testcfg/testcfg.mk                   |  8 ---
 6 files changed, 42 insertions(+), 41 deletions(-)
 rename unittest/{testcfg/objects => core}/CatchFactory.cpp (100%)
 rename unittest/{testcfg/objects => core}/CatchFactory.h (71%)

diff --git a/unittest/testcfg/objects/CatchFactory.cpp b/unittest/core/CatchFactory.cpp
similarity index 100%
rename from unittest/testcfg/objects/CatchFactory.cpp
rename to unittest/core/CatchFactory.cpp
diff --git a/unittest/testcfg/objects/CatchFactory.h b/unittest/core/CatchFactory.h
similarity index 71%
rename from unittest/testcfg/objects/CatchFactory.h
rename to unittest/core/CatchFactory.h
index 84f9207e2..f06e7ae55 100644
--- a/unittest/testcfg/objects/CatchFactory.h
+++ b/unittest/core/CatchFactory.h
@@ -1,5 +1,5 @@
-#ifndef FACTORY_H_
-#define FACTORY_H_
+#ifndef FSFW_CATCHFACTORY_H_
+#define FSFW_CATCHFACTORY_H_
 
 #include <fsfw/objectmanager/SystemObjectIF.h>
 
@@ -13,4 +13,4 @@ namespace Factory {
 
 }
 
-#endif /* FACTORY_H_ */
+#endif /* FSFW_CATCHFACTORY_H_ */
diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index cb5bd33ed..c93cf0323 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,6 +1,5 @@
+#include <fsfw/unittest/core/CatchFactory.h>
 #include "CatchDefinitions.h"
-#include "CatchFactory.h"
-
 #include <testcfg/cdatapool/dataPoolInit.h>
 
 #ifdef GCOV
@@ -10,15 +9,11 @@
 #include "../../objectmanager/ObjectManager.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../datapool/DataPool.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 
 /* Global instantiations normally done in main.cpp */
 /* Initialize Data Pool */
-//namespace glob {
-DataPool dataPool(datapool::dataPoolInit);
-//}
 
 
 namespace sif {
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 599345602..94f6e59d1 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -1,44 +1,57 @@
 #ifndef CONFIG_FSFWCONFIG_H_
 #define CONFIG_FSFWCONFIG_H_
 
-#include <FSFWVersion.h>
+#include <cstddef>
+#include <cstdint>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrese code size
+//! Reduced printout to further decrease code size
 //! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_REDUCED_PRINTOUT		0
+#define FSFW_ENHANCED_PRINTOUT		0
 
-//! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_DEBUGGING              0
-
-//! Defines the FIFO depth of each commanding service base which
-//! also determines how many commands a CSB service can handle in one cycle
-//! simulataneously. This will increase the required RAM for
-//! each CSB service !
-#define FSFW_CSB_FIFO_DEPTH			6
+//! Can be used to enable additional debugging printouts for developing the FSFW
+#define FSFW_PRINT_VERBOSITY_LEVEL   0
 
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
-//! If -DDEBUG is supplied in the build defines, there will be
-//! additional output which requires the translation files translateObjects
-//! and translateEvents (and their compiles source files)
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
+#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
-#define FSFW_DEBUG_INFO             1
-#include <translateObjects.h>
-#include <translateEvents.h>
+#define FSFW_DEBUG_INFO				1
+#include "objects/translateObjects.h"
+#include "events/translateEvents.h"
 #else
+#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities
 //! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NO_C99_IO 	1
+#define FSFW_NO_C99_IO 	            1
 
+//! Specify whether a special mode store is used for Subsystem components.
+#define FSFW_USE_MODESTORE          0
+
+namespace fsfwconfig {
+//! Default timestamp size. The default timestamp will be an eight byte CDC
+//! short timestamp.
+static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 8;
+
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 3;
+}
 
 #endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/unittest/testcfg/Makefile-FSFW-Tests b/unittest/testcfg/Makefile-FSFW-Tests
index 2017d2bd8..550fd1dee 100644
--- a/unittest/testcfg/Makefile-FSFW-Tests
+++ b/unittest/testcfg/Makefile-FSFW-Tests
@@ -15,7 +15,7 @@ SHELL = /bin/sh
 # (can be overriden by adding CHIP=chip and BOARD=board to the command-line)
 # Unit Test can only be run on host machine for now (Linux)
 FRAMEWORK_PATH = fsfw
-FILE_ROOT = $(FRAMEWORK_PATH)/unittest
+TEST_FILE_ROOT = $(FRAMEWORK_PATH)/unittest
 BOARD = unittest
 LINUX = 1
 OS_FSFW = linux
@@ -58,9 +58,10 @@ endif
 
 UNIT_TEST = 1
 # General folder paths
-CONFIG_PATH = $(FILE_ROOT)/config
-UNIT_TEST_PATH = $(FILE_ROOT)/tests
-CORE_PATH = $(FILE_ROOT)/core
+CONFIG_PATH = testcfg
+# Core copy has to be copied as well.
+CORE_PATH = core
+UNIT_TEST_PATH = $(TEST_FILE_ROOT)/tests
 
 # Output file basename
 BASENAME = fsfw
@@ -154,8 +155,8 @@ include $(S)/$(notdir $S).mk
 endef
 $(foreach S,$(SUBDIRS),$(eval $(INCLUDE_FILE)))
 
-INCLUDES += $(FILE_ROOT)
-INCLUDES += $(FILE_ROOT)/catch2/
+INCLUDES += $(TEST_FILE_ROOT)
+INCLUDES += $(TEST_FILE_ROOT)/catch2/
 
 #-------------------------------------------------------------------------------
 #		Source Files
diff --git a/unittest/testcfg/testcfg.mk b/unittest/testcfg/testcfg.mk
index 31d3b60a5..fca2f7327 100644
--- a/unittest/testcfg/testcfg.mk
+++ b/unittest/testcfg/testcfg.mk
@@ -6,11 +6,3 @@ CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
 
 INCLUDES += $(CURRENTPATH)
-INCLUDES += $(CURRENTPATH)/objects
-INCLUDES += $(CURRENTPATH)/ipc
-INCLUDES += $(CURRENTPATH)/pollingsequence
-INCLUDES += $(CURRENTPATH)/returnvalues
-INCLUDES += $(CURRENTPATH)/tmtc
-INCLUDES += $(CURRENTPATH)/events
-INCLUDES += $(CURRENTPATH)/devices
-INCLUDES += $(CURRENTPATH)/cdatapool

From 4c41e3604424f508556d96b4a32081cca0b5f8bb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:29:06 +0100
Subject: [PATCH 1265/1774] nullptr check added

---
 datapool/PoolDataSetBase.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 1acd3fd3b..cb2348f72 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -59,6 +59,11 @@ uint16_t PoolDataSetBase::getFillCount() const {
 
 ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	if(registeredVariables[count] == nullptr) {
+	    // configuration error.
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	// These checks are often performed by the respective
 	// variable implementation too, but I guess a double check does not hurt.
 	if (registeredVariables[count]->getReadWriteMode() !=

From 9937842ded66d2ffca374bff275719cbba0fe4c1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 14:11:36 +0100
Subject: [PATCH 1266/1774] get transiition delay abstract

---
 devicehandlers/DeviceHandlerBase.cpp | 5 -----
 devicehandlers/DeviceHandlerBase.h   | 2 +-
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index cb0407145..d2d4ecb8d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -926,11 +926,6 @@ void DeviceHandlerBase::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
 	setMode(getBaseMode(mode));
 }
 
-uint32_t DeviceHandlerBase::getTransitionDelayMs(Mode_t modeFrom,
-		Mode_t modeTo) {
-	return 5000;
-}
-
 ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 	if(powerSwitcher == nullptr) {
 		return NO_SWITCH;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index ee4447ed1..45450f627 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -490,7 +490,7 @@ protected:
 	 * @param modeTo
 	 * @return time in ms
 	 */
-	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo);
+	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) = 0;
 
 	/**
 	 * Return the switches connected to the device.

From 362578e982e5754911ae93e3edc90420f207d813 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 14:12:35 +0100
Subject: [PATCH 1267/1774] transition delay abstract

---
 devicehandlers/DeviceHandlerBase.cpp | 5 -----
 devicehandlers/DeviceHandlerBase.h   | 2 +-
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index cb0407145..d2d4ecb8d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -926,11 +926,6 @@ void DeviceHandlerBase::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
 	setMode(getBaseMode(mode));
 }
 
-uint32_t DeviceHandlerBase::getTransitionDelayMs(Mode_t modeFrom,
-		Mode_t modeTo) {
-	return 5000;
-}
-
 ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 	if(powerSwitcher == nullptr) {
 		return NO_SWITCH;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index ee4447ed1..45450f627 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -490,7 +490,7 @@ protected:
 	 * @param modeTo
 	 * @return time in ms
 	 */
-	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo);
+	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) = 0;
 
 	/**
 	 * Return the switches connected to the device.

From 3b391d33801ef998d8748364711c0dbb17231664 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 14:15:21 +0100
Subject: [PATCH 1268/1774] deleted service types header

---
 tmtcservices/ServiceTypes.h | 26 --------------------------
 1 file changed, 26 deletions(-)
 delete mode 100644 tmtcservices/ServiceTypes.h

diff --git a/tmtcservices/ServiceTypes.h b/tmtcservices/ServiceTypes.h
deleted file mode 100644
index 552601f97..000000000
--- a/tmtcservices/ServiceTypes.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef SERVICETYPES_H_
-#define SERVICETYPES_H_
-
-// SHOULDDO: This is a duplication of existing configuration structures. Delete it?
-namespace SERVICE {
-enum ServiceTypes {
-	TELECOMMAND_VERIFICATION = 1,
-	DEVICE_COMMAND_DISTRIBUTION = 2,
-	HOUSEKEEPING_AND_DIAGNOSTIC_DATA_REPORTING = 3,
-	PARAMETER_STATISTICS_REPORTING = 4,
-	EVENT_REPORTING = 5,
-	MEMORY_MANAGEMENT = 6,
-	FUNCTION_MANAGEMENT = 8,
-	TIME_MANAGEMENT = 9,
-	ON_BOARD_OPERATIONS_SCHEDULING = 11,
-	ON_BOARD_MONITORING = 12,
-	LARGE_DATA_TRANSFER = 13,
-	PACKET_FORWARDING_CONTROL = 14,
-	ON_BOARD_STORAGE_AND_RETRIEVAL = 15,
-	TEST = 17,
-	ON_BOARD_OPERATIONS_PROCEDURE = 18,
-	EVENT_ACTION = 19
-};
-}
-
-#endif /* SERVICETYPES_H_ */

From 947dfd69e97f894287d758eb929cdf9caa1b1f23 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 14:16:33 +0100
Subject: [PATCH 1269/1774] service types.h delted

---
 tmtcservices/ServiceTypes.h | 26 --------------------------
 1 file changed, 26 deletions(-)
 delete mode 100644 tmtcservices/ServiceTypes.h

diff --git a/tmtcservices/ServiceTypes.h b/tmtcservices/ServiceTypes.h
deleted file mode 100644
index 552601f97..000000000
--- a/tmtcservices/ServiceTypes.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef SERVICETYPES_H_
-#define SERVICETYPES_H_
-
-// SHOULDDO: This is a duplication of existing configuration structures. Delete it?
-namespace SERVICE {
-enum ServiceTypes {
-	TELECOMMAND_VERIFICATION = 1,
-	DEVICE_COMMAND_DISTRIBUTION = 2,
-	HOUSEKEEPING_AND_DIAGNOSTIC_DATA_REPORTING = 3,
-	PARAMETER_STATISTICS_REPORTING = 4,
-	EVENT_REPORTING = 5,
-	MEMORY_MANAGEMENT = 6,
-	FUNCTION_MANAGEMENT = 8,
-	TIME_MANAGEMENT = 9,
-	ON_BOARD_OPERATIONS_SCHEDULING = 11,
-	ON_BOARD_MONITORING = 12,
-	LARGE_DATA_TRANSFER = 13,
-	PACKET_FORWARDING_CONTROL = 14,
-	ON_BOARD_STORAGE_AND_RETRIEVAL = 15,
-	TEST = 17,
-	ON_BOARD_OPERATIONS_PROCEDURE = 18,
-	EVENT_ACTION = 19
-};
-}
-
-#endif /* SERVICETYPES_H_ */

From 7ba660a222a3c0cdb1276942557ba27891783138 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 14:18:48 +0100
Subject: [PATCH 1270/1774] removed comment

---
 tmtcservices/AcceptsTelecommandsIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h
index bff0e9550..7c8710498 100644
--- a/tmtcservices/AcceptsTelecommandsIF.h
+++ b/tmtcservices/AcceptsTelecommandsIF.h
@@ -12,7 +12,7 @@
 class AcceptsTelecommandsIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
-	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
+	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
 	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
 	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);

From d607332f8d20477d47624e4562417f279b9ccd85 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 14:19:13 +0100
Subject: [PATCH 1271/1774] removed comment

---
 tmtcservices/AcceptsTelecommandsIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h
index bff0e9550..7c8710498 100644
--- a/tmtcservices/AcceptsTelecommandsIF.h
+++ b/tmtcservices/AcceptsTelecommandsIF.h
@@ -12,7 +12,7 @@
 class AcceptsTelecommandsIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
-	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
+	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
 	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
 	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);

From 9ac07368da3fab3a60fa0caffe0f10f8c35e2fd9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 14:26:42 +0100
Subject: [PATCH 1272/1774] changelog update

---
 CHANGELOG | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG b/CHANGELOG
index 4e51bc64e..8b13b68d5 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -54,7 +54,7 @@ ID for now.
 - There is an additional `PERFORM_OPERATION` step for the device handler base. It is important
 that DHB users adapt their polling sequence tables to perform this step. This steps allows for aclear distinction between operation and communication steps
 - setNormalDatapoolEntriesInvalid is not an abstract method and a default implementation was provided
-- getTransitionDelayMs now return 5000 ms instead of 0 in default implementation
+- getTransitionDelayMs is now an abstract method
 
 ### DeviceHandlerIF
 

From ab9965cb8153fcfa6948a7c2d631715d0e37ad46 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 15:29:42 +0100
Subject: [PATCH 1273/1774] clock corrected

---
 timemanager/Clock.h | 274 ++++++++++++++++++++++----------------------
 1 file changed, 137 insertions(+), 137 deletions(-)

diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index f4ed847ac..61e40d19c 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -11,156 +11,156 @@
 
 class Clock {
 public:
-    typedef struct {
-        uint32_t year; //!< Year, A.D.
-        uint32_t month; //!< Month, 1 .. 12.
-        uint32_t day; //!< Day, 1 .. 31.
-        uint32_t hour; //!< Hour, 0 .. 23.
-        uint32_t minute; //!< Minute, 0 .. 59.
-        uint32_t second; //!< Second, 0 .. 59.
-        uint32_t usecond; //!< Microseconds, 0 .. 999999
-    } TimeOfDay_t;
+	typedef struct {
+		uint32_t year; //!< Year, A.D.
+		uint32_t month; //!< Month, 1 .. 12.
+		uint32_t day; //!< Day, 1 .. 31.
+		uint32_t hour; //!< Hour, 0 .. 23.
+		uint32_t minute; //!< Minute, 0 .. 59.
+		uint32_t second; //!< Second, 0 .. 59.
+		uint32_t usecond; //!< Microseconds, 0 .. 999999
+	} TimeOfDay_t;
 
-    /**
-     * This method returns the number of clock ticks per second.
-     * In RTEMS, this is typically 1000.
-     * @return	The number of ticks.
-     *
-     * @deprecated, we should not worry about ticks, but only time
-     */
-    static uint32_t getTicksPerSecond(void);
-    /**
-     * This system call sets the system time.
-     * To set the time, it uses a TimeOfDay_t struct.
-     * @param time The struct with the time settings to set.
-     * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
-     * 				is returned.
-     */
-    static ReturnValue_t setClock(const TimeOfDay_t* time);
-    /**
-     * This system call sets the system time.
-     * To set the time, it uses a timeval struct.
-     * @param time The struct with the time settings to set.
-     * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t setClock(const timeval* time);
-    /**
-     * This system call returns the current system clock in timeval format.
-     * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
-     * microseconds since an OS-defined epoch.
-     * @param time	A pointer to a timeval struct where the current time is stored.
-     * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getClock_timeval(timeval* time);
+	/**
+	 * This method returns the number of clock ticks per second.
+	 * In RTEMS, this is typically 1000.
+	 * @return	The number of ticks.
+	 *
+	 * @deprecated, we should not worry about ticks, but only time
+	 */
+	static uint32_t getTicksPerSecond(void);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a TimeOfDay_t struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
+	 * 				is returned.
+	 */
+	static ReturnValue_t setClock(const TimeOfDay_t* time);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a timeval struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setClock(const timeval* time);
+	/**
+	 * This system call returns the current system clock in timeval format.
+	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
+	 * microseconds since an OS-defined epoch.
+	 * @param time	A pointer to a timeval struct where the current time is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_timeval(timeval* time);
 
-    /**
-     * Get the time since boot in a timeval struct
-     *
-     * @param[out] time A pointer to a timeval struct where the uptime is stored.
-     * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-     *
-     * @deprecated, I do not think this should be able to fail, use timeval getUptime()
-     */
-    static ReturnValue_t getUptime(timeval* uptime);
+	/**
+	 * Get the time since boot in a timeval struct
+	 *
+	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 *
+	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
+	 */
+	static ReturnValue_t getUptime(timeval* uptime);
 
-    static timeval getUptime();
+	static timeval getUptime();
 
-    /**
-     * Get the time since boot in milliseconds
-     *
-     * This value can overflow! Still, it can be used to calculate time intervalls
-     * between two calls up to 49 days by always using uint32_t in the calculation
-     *
-     * @param ms uptime in ms
-     * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getUptime(uint32_t* uptimeMs);
+	/**
+	 * Get the time since boot in milliseconds
+	 *
+	 * This value can overflow! Still, it can be used to calculate time intervalls
+	 * between two calls up to 49 days by always using uint32_t in the calculation
+	 *
+	 * @param ms uptime in ms
+	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getUptime(uint32_t* uptimeMs);
 
-    /**
-     * Returns the time in microseconds since an OS-defined epoch.
-     * The time is returned in a 64 bit unsigned integer.
-     * @param time A pointer to a 64 bit unisigned integer where the data is stored.
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getClock_usecs(uint64_t* time);
-    /**
-     * Returns the time in a TimeOfDay_t struct.
-     * @param time A pointer to a TimeOfDay_t struct.
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
+	/**
+	 * Returns the time in microseconds since an OS-defined epoch.
+	 * The time is returned in a 64 bit unsigned integer.
+	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_usecs(uint64_t* time);
+	/**
+	 * Returns the time in a TimeOfDay_t struct.
+	 * @param time A pointer to a TimeOfDay_t struct.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
 
-    /**
-     * Converts a time of day struct to POSIX seconds.
-     * @param time The time of day as input
-     * @param timeval The corresponding seconds since the epoch.
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-            timeval* to);
+	/**
+	 * Converts a time of day struct to POSIX seconds.
+	 * @param time The time of day as input
+	 * @param timeval The corresponding seconds since the epoch.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+			timeval* to);
 
-    /**
-     * Converts a time represented as seconds and subseconds since unix
-     * epoch to days since J2000
-     *
-     * @param time seconds since unix epoch
-     * @param[out] JD2000 days since J2000
-     * @return @c RETURN_OK
-     */
-    static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
+	/**
+	 * Converts a time represented as seconds and subseconds since unix
+	 * epoch to days since J2000
+	 *
+	 * @param time seconds since unix epoch
+	 * @param[out] JD2000 days since J2000
+	 * @return @c RETURN_OK
+	 */
+	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
 
-    /**
-     * Calculates and adds the offset between UTC and TT
-     *
-     * Depends on the leap seconds to be set correctly.
-     *
-     * @param utc timeval, corresponding to UTC time
-     * @param[out] tt timeval, corresponding to Terrestial Time
-     * @return
-     *  - @c RETURN_OK on success
-     *  - @c RETURN_FAILED if leapSeconds are not set
-     */
-    static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
+	/**
+	 * Calculates and adds the offset between UTC and TT
+	 *
+	 * Depends on the leap seconds to be set correctly.
+	 *
+	 * @param utc timeval, corresponding to UTC time
+	 * @param[out] tt timeval, corresponding to Terrestial Time
+	 * @return
+	 *  - @c RETURN_OK on success
+	 *  - @c RETURN_FAILED if leapSeconds are not set
+	 */
+	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
 
-    /**
-     * Set the Leap Seconds since 1972
-     *
-     * @param leapSeconds_
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
+	/**
+	 * Set the Leap Seconds since 1972
+	 *
+	 * @param leapSeconds_
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
 
-    /**
-     * Get the Leap Seconds since 1972
-     *
-     * Must be set before!
-     *
-     * @param[out] leapSeconds_
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
+	/**
+	 * Get the Leap Seconds since 1972
+	 *
+	 * Must be set before!
+	 *
+	 * @param[out] leapSeconds_
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
 
-    /**
-     * Function to check and create the Mutex for the clock
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise @c RETURN_FAILED if not able to create one
-     */
-    static ReturnValue_t checkOrCreateClockMutex();
+	/**
+	 * Function to check and create the Mutex for the clock
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise @c RETURN_FAILED if not able to create one
+	 */
+	static ReturnValue_t checkOrCreateClockMutex();
 
 private:
-    static MutexIF* timeMutex;
-    static uint16_t leapSeconds;
+	static MutexIF* timeMutex;
+	static uint16_t leapSeconds;
 };
 
 

From 822cc0306c90603bbd66365293670e1163dc36cd Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Tue, 22 Dec 2020 15:35:23 +0100
Subject: [PATCH 1274/1774] Fixed file ending of devicehanlder remake

---
 doc/README-devicehandlers.md  | 1 +
 doc/README-devicehandlers.txt | 0
 2 files changed, 1 insertion(+)
 create mode 100644 doc/README-devicehandlers.md
 delete mode 100644 doc/README-devicehandlers.txt

diff --git a/doc/README-devicehandlers.md b/doc/README-devicehandlers.md
new file mode 100644
index 000000000..6e737cc5a
--- /dev/null
+++ b/doc/README-devicehandlers.md
@@ -0,0 +1 @@
+## FSFW DeviceHandlers
\ No newline at end of file
diff --git a/doc/README-devicehandlers.txt b/doc/README-devicehandlers.txt
deleted file mode 100644
index e69de29bb..000000000

From 958db291e823746348434b72b7409baef2e031d4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 15:49:31 +0100
Subject: [PATCH 1275/1774] now it compiles

---
 timemanager/CCSDSTime.h         |  1 +
 tmstorage/TmStorePackets.h      | 15 +++++++++------
 tmtcpacket/pus/TmPacketBase.cpp |  2 +-
 3 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index e9e6957f2..d74adc61d 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -7,6 +7,7 @@
 #include "clockDefinitions.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstdint>
+#include <cstddef>
 
 bool operator<(const timeval& lhs, const timeval& rhs);
 bool operator<=(const timeval& lhs, const timeval& rhs);
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index e88e741a8..b46ae6f6a 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -139,8 +139,9 @@ public:
 	static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime){
 		if(packet->isValid()){
 			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			size_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,
+					&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
 			if(packetTime <= *cmpTime){
 				return true;
 			}
@@ -151,8 +152,9 @@ public:
 	static bool isNewerThan(const TmPacketInformation* packet, const timeval* cmpTime){
 		if(packet->isValid()){
 			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			size_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],
+					&foundlen,sizeof(rawTimestamp));
 			if(packetTime >= *cmpTime){
 				return true;
 			}
@@ -204,8 +206,9 @@ public:
 
 	timeval getTime() const {
 		timeval packetTime = {0,0};
-		uint32_t foundlen = 0;
-		CCSDSTime::convertFromCcsds(&packetTime,&this->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+		size_t foundlen = 0;
+		CCSDSTime::convertFromCcsds(&packetTime, &this->rawTimestamp[0],
+				&foundlen,sizeof(rawTimestamp));
 		return packetTime;
 	}
 
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index f3bc3f001..2c8bfd632 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -74,7 +74,7 @@ bool TmPacketBase::checkAndSetStamper() {
 }
 
 ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
-	uint32_t tempSize = 0;
+	size_t tempSize = 0;
 	return CCSDSTime::convertFromCcsds(timestamp, tmData->data_field.time,
 			&tempSize, sizeof(tmData->data_field.time));
 }

From 021b9b8c50e15adfdd0705663ea447ff7fdf10ab Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 15:57:43 +0100
Subject: [PATCH 1276/1774] improvements

---
 tmstorage/TmStoreBackendIF.h  | 25 ++++++++++++++++++++++---
 tmstorage/TmStoreFrontendIF.h | 17 +++++++++++++----
 tmstorage/TmStoreMessage.cpp  |  4 ++--
 tmstorage/TmStoreMessage.h    |  4 ++--
 tmstorage/TmStorePackets.h    |  8 ++++----
 5 files changed, 43 insertions(+), 15 deletions(-)

diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index 4b2a88361..4ae776095 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -1,5 +1,5 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
+#ifndef FSFW_TMTCSERVICES_TMSTOREBACKENDIF_H_
+#define FSFW_TMTCSERVICES_TMSTOREBACKENDIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../objectmanager/SystemObjectIF.h"
@@ -49,14 +49,33 @@ public:
 	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, severity::INFO);//!< Info that the a auto catalog report failed
 
 	virtual ~TmStoreBackendIF() {}
+
+	/**
+	 * SHOULDDO: Specification on what has to be implemented here
+	 * @param opCode
+	 * @return
+	 */
 	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
 	virtual ReturnValue_t initialize() = 0;
+
+	/**
+	 * Implement the storage of TM packets to mass memory
+	 * @param tmPacket
+	 * @return
+	 */
 	virtual ReturnValue_t storePacket(TmPacketMinimal* tmPacket) = 0;
 	virtual ReturnValue_t setFetchLimitTime(const timeval* loverLimit, const timeval* upperLimit) = 0;
 	virtual ReturnValue_t setFetchLimitBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
 	virtual ReturnValue_t fetchPackets(bool fromBegin = false) = 0;
 	virtual ReturnValue_t initializeStore(object_id_t dumpTarget) = 0;
 	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
+
+	/**
+	 * SHOULDDO: Adapt for file management system?
+	 * @param startAddress
+	 * @param endAddress
+	 * @return
+	 */
 	virtual ReturnValue_t deleteBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
 	virtual ReturnValue_t deleteTime(const timeval* timeUntil,
 				uint32_t* deletedPackets) = 0;
@@ -73,4 +92,4 @@ public:
 
 
 
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
+#endif /* FSFW_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
diff --git a/tmstorage/TmStoreFrontendIF.h b/tmstorage/TmStoreFrontendIF.h
index e1bc3a148..beee7ede0 100644
--- a/tmstorage/TmStoreFrontendIF.h
+++ b/tmstorage/TmStoreFrontendIF.h
@@ -1,9 +1,10 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+#ifndef FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+#define FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "TmStorePackets.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
+
 class TmPacketMinimal;
 class SpacePacketBase;
 class TmStoreBackendIF;
@@ -11,6 +12,14 @@ class TmStoreBackendIF;
 class TmStoreFrontendIF {
 public:
 	virtual TmStoreBackendIF* getBackend() const = 0;
+
+	/**
+	 * What do I need to implement here?
+	 * This is propably used by PUS Service 15 so we should propably check for messages..
+	 * Provide base implementation?
+	 * @param opCode
+	 * @return
+	 */
 	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
 	/**
 	 * Callback from the back-end to indicate a certain packet was received.
@@ -52,4 +61,4 @@ public:
 
 
 
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
+#endif /* FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp
index d2efd4033..753ac1b74 100644
--- a/tmstorage/TmStoreMessage.cpp
+++ b/tmstorage/TmStoreMessage.cpp
@@ -1,5 +1,5 @@
 #include "../objectmanager/ObjectManagerIF.h"
-#include "TmStoreMessage.h"
+#include "../tmstorage/TmStoreMessage.h"
 
 TmStoreMessage::~TmStoreMessage() {
 	
@@ -74,7 +74,7 @@ void TmStoreMessage::clear(CommandMessage* cmd) {
 	case DELETE_STORE_CONTENT_BLOCKS:
 	case DOWNLINK_STORE_CONTENT_BLOCKS:
 	case REPORT_INDEX_REQUEST:
-		cmd->setCommand(UNKNOWN_COMMAND);
+		cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
 		cmd->setParameter(0);
 		cmd->setParameter2(0);
 		break;
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index 5b928569d..59354a203 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -3,9 +3,9 @@
 
 #include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "TmStorePackets.h"
+#include "../tmstorage/TmStorePackets.h"
 #include "../objectmanager/SystemObjectIF.h"
-class TmStoreMessage: public CommandMessage {
+class TmStoreMessage  {
 public:
 	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
 			bool setEnabled);
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index b46ae6f6a..0312a9989 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -140,8 +140,8 @@ public:
 		if(packet->isValid()){
 			timeval packetTime = {0,0};
 			size_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,
-					&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],
+			        &foundlen,sizeof(rawTimestamp));
 			if(packetTime <= *cmpTime){
 				return true;
 			}
@@ -154,7 +154,7 @@ public:
 			timeval packetTime = {0,0};
 			size_t foundlen = 0;
 			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],
-					&foundlen,sizeof(rawTimestamp));
+			        &foundlen,sizeof(rawTimestamp));
 			if(packetTime >= *cmpTime){
 				return true;
 			}
@@ -208,7 +208,7 @@ public:
 		timeval packetTime = {0,0};
 		size_t foundlen = 0;
 		CCSDSTime::convertFromCcsds(&packetTime, &this->rawTimestamp[0],
-				&foundlen,sizeof(rawTimestamp));
+		        &foundlen, sizeof(rawTimestamp));
 		return packetTime;
 	}
 

From 09161f22d070089265202a7fb67a11ac53990c26 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 15:58:52 +0100
Subject: [PATCH 1277/1774] updated tm storage

---
 tmstorage/TmStoreMessage.cpp |  2 +-
 tmstorage/TmStoreMessage.h   | 15 +++++++++------
 tmstorage/TmStorePackets.h   |  6 +++---
 3 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp
index 753ac1b74..033cbb1d2 100644
--- a/tmstorage/TmStoreMessage.cpp
+++ b/tmstorage/TmStoreMessage.cpp
@@ -1,5 +1,5 @@
+#include "TmStoreMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../tmstorage/TmStoreMessage.h"
 
 TmStoreMessage::~TmStoreMessage() {
 	
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index 59354a203..d0178920c 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -1,10 +1,11 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
+#ifndef FSFW_TMSTORAGE_TMSTOREMESSAGE_H_
+#define FSFW_TMSTORAGE_TMSTOREMESSAGE_H_
 
+#include "TmStorePackets.h"
 #include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "../tmstorage/TmStorePackets.h"
 #include "../objectmanager/SystemObjectIF.h"
+
 class TmStoreMessage  {
 public:
 	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
@@ -25,8 +26,10 @@ public:
 	static void setDownlinkContentTimeMessage(CommandMessage* cmd,
 			store_address_t storeId);
 	static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
-	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
-	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd,
+			uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd,
+			uint32_t addressLow, uint32_t addressHigh);
 	static ReturnValue_t setIndexRequestMessage(CommandMessage* cmd);
 	static void setDeleteContentTimeMessage(CommandMessage* cmd,
 			store_address_t storeId);
@@ -60,4 +63,4 @@ private:
 	TmStoreMessage();
 };
 
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ */
+#endif /* FSFW_TMSTORAGE_TMSTOREMESSAGE_H_ */
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 0312a9989..3abd0c1ca 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
+#ifndef FSFW_TMSTORAGE_TMSTOREPACKETS_H_
+#define FSFW_TMSTORAGE_TMSTOREPACKETS_H_
 
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../serialize/SerializeElement.h"
@@ -300,4 +300,4 @@ private:
 	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
 
 };
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ */
+#endif /* FSFW_TMSTORAGE_TMSTOREPACKETS_H_ */

From 75a0df4cd97fd14bd5bb99475dcbaf14fbc4dda8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 15:59:28 +0100
Subject: [PATCH 1278/1774] tm storage update

---
 tmstorage/CMakeLists.txt      |  4 ++++
 tmstorage/TmStoreBackendIF.h  | 10 +++++-----
 tmstorage/TmStoreFrontendIF.h |  9 +++++----
 tmstorage/TmStoreMessage.cpp  |  2 +-
 tmstorage/TmStoreMessage.h    | 15 +++++++++------
 tmstorage/TmStorePackets.h    |  6 +++---
 6 files changed, 27 insertions(+), 19 deletions(-)
 create mode 100644 tmstorage/CMakeLists.txt

diff --git a/tmstorage/CMakeLists.txt b/tmstorage/CMakeLists.txt
new file mode 100644
index 000000000..7990d85a1
--- /dev/null
+++ b/tmstorage/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		TmStoreMessage.cpp
+)
diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index 2ebe85e4c..4ae776095 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -1,5 +1,5 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
+#ifndef FSFW_TMTCSERVICES_TMSTOREBACKENDIF_H_
+#define FSFW_TMTCSERVICES_TMSTOREBACKENDIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../objectmanager/SystemObjectIF.h"
@@ -51,7 +51,7 @@ public:
 	virtual ~TmStoreBackendIF() {}
 
 	/**
-	 * What do I need to implement here ?
+	 * SHOULDDO: Specification on what has to be implemented here
 	 * @param opCode
 	 * @return
 	 */
@@ -71,7 +71,7 @@ public:
 	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
 
 	/**
-	 * TODO: Adapt for file management system?
+	 * SHOULDDO: Adapt for file management system?
 	 * @param startAddress
 	 * @param endAddress
 	 * @return
@@ -92,4 +92,4 @@ public:
 
 
 
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
+#endif /* FSFW_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
diff --git a/tmstorage/TmStoreFrontendIF.h b/tmstorage/TmStoreFrontendIF.h
index e0a7e0782..beee7ede0 100644
--- a/tmstorage/TmStoreFrontendIF.h
+++ b/tmstorage/TmStoreFrontendIF.h
@@ -1,9 +1,10 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+#ifndef FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+#define FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_
 
+#include "TmStorePackets.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tmstorage/TmStorePackets.h"
 #include "../ipc/MessageQueueSenderIF.h"
+
 class TmPacketMinimal;
 class SpacePacketBase;
 class TmStoreBackendIF;
@@ -60,4 +61,4 @@ public:
 
 
 
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
+#endif /* FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp
index 753ac1b74..033cbb1d2 100644
--- a/tmstorage/TmStoreMessage.cpp
+++ b/tmstorage/TmStoreMessage.cpp
@@ -1,5 +1,5 @@
+#include "TmStoreMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../tmstorage/TmStoreMessage.h"
 
 TmStoreMessage::~TmStoreMessage() {
 	
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index 59354a203..d0178920c 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -1,10 +1,11 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
+#ifndef FSFW_TMSTORAGE_TMSTOREMESSAGE_H_
+#define FSFW_TMSTORAGE_TMSTOREMESSAGE_H_
 
+#include "TmStorePackets.h"
 #include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "../tmstorage/TmStorePackets.h"
 #include "../objectmanager/SystemObjectIF.h"
+
 class TmStoreMessage  {
 public:
 	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
@@ -25,8 +26,10 @@ public:
 	static void setDownlinkContentTimeMessage(CommandMessage* cmd,
 			store_address_t storeId);
 	static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
-	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
-	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd,
+			uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd,
+			uint32_t addressLow, uint32_t addressHigh);
 	static ReturnValue_t setIndexRequestMessage(CommandMessage* cmd);
 	static void setDeleteContentTimeMessage(CommandMessage* cmd,
 			store_address_t storeId);
@@ -60,4 +63,4 @@ private:
 	TmStoreMessage();
 };
 
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ */
+#endif /* FSFW_TMSTORAGE_TMSTOREMESSAGE_H_ */
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 0312a9989..3abd0c1ca 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
+#ifndef FSFW_TMSTORAGE_TMSTOREPACKETS_H_
+#define FSFW_TMSTORAGE_TMSTOREPACKETS_H_
 
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../serialize/SerializeElement.h"
@@ -300,4 +300,4 @@ private:
 	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
 
 };
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ */
+#endif /* FSFW_TMSTORAGE_TMSTOREPACKETS_H_ */

From a73cd37e52119057da75030643b41389c16c4ce2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 15:59:46 +0100
Subject: [PATCH 1279/1774] taken over changelog

---
 CHANGELOG | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index 7b07db082..2d9017918 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -53,6 +53,12 @@ ID for now.
 
 - There is an additional `PERFORM_OPERATION` step for the device handler base. It is important
 that DHB users adapt their polling sequence tables to perform this step. This steps allows for aclear distinction between operation and communication steps
+- setNormalDatapoolEntriesInvalid is not an abstract method and a default implementation was provided
+- getTransitionDelayMs is now an abstract method
+
+### DeviceHandlerIF
+
+- Typo for UNKNOWN_DEVICE_REPLY 
 
 ### Events
 
@@ -60,3 +66,7 @@ that DHB users adapt their polling sequence tables to perform this step. This st
 allows setting a unique ID. Event.cpp source file removed, functions now
 defined in header directly. Namespaces renamed. Functions declared `constexpr`
 now
+
+### Commanding Service Base
+
+- CSB uses the new fsfwconfig::FSFW_CSB_FIFO_DEPTH variable to determine  the FIFO depth for each CSB instance. This variable has to be set in the FSFWConfig.h file

From 8f88032110f8be06e7eb653fa39e95335f7a7104 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:00:30 +0100
Subject: [PATCH 1280/1774] taken over upstream .mk file

---
 fsfw.mk | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/fsfw.mk b/fsfw.mk
index 1dd4f1665..3df63060e 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -9,7 +9,6 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/controller/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoolglob/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
@@ -73,5 +72,3 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)
-
-INCLUDES += $(CURRENTPATH)

From df7a2322bfa34504049238a0c299cc1aa2eccac4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:03:56 +0100
Subject: [PATCH 1281/1774] timemanager update

---
 timemanager/CCSDSTime.h    |   1 +
 timemanager/CMakeLists.txt |   8 ++
 timemanager/Clock.h        | 274 ++++++++++++++++++-------------------
 3 files changed, 146 insertions(+), 137 deletions(-)
 create mode 100644 timemanager/CMakeLists.txt

diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index e9e6957f2..d74adc61d 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -7,6 +7,7 @@
 #include "clockDefinitions.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstdint>
+#include <cstddef>
 
 bool operator<(const timeval& lhs, const timeval& rhs);
 bool operator<=(const timeval& lhs, const timeval& rhs);
diff --git a/timemanager/CMakeLists.txt b/timemanager/CMakeLists.txt
new file mode 100644
index 000000000..3367775f4
--- /dev/null
+++ b/timemanager/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CCSDSTime.cpp
+		Countdown.cpp
+		Stopwatch.cpp
+		TimeMessage.cpp
+		TimeStamper.cpp
+)
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 9f6f9885b..6400d284c 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -16,156 +16,156 @@
 
 class Clock {
 public:
-    typedef struct {
-        uint32_t year; //!< Year, A.D.
-        uint32_t month; //!< Month, 1 .. 12.
-        uint32_t day; //!< Day, 1 .. 31.
-        uint32_t hour; //!< Hour, 0 .. 23.
-        uint32_t minute; //!< Minute, 0 .. 59.
-        uint32_t second; //!< Second, 0 .. 59.
-        uint32_t usecond; //!< Microseconds, 0 .. 999999
-    } TimeOfDay_t;
+	typedef struct {
+		uint32_t year; //!< Year, A.D.
+		uint32_t month; //!< Month, 1 .. 12.
+		uint32_t day; //!< Day, 1 .. 31.
+		uint32_t hour; //!< Hour, 0 .. 23.
+		uint32_t minute; //!< Minute, 0 .. 59.
+		uint32_t second; //!< Second, 0 .. 59.
+		uint32_t usecond; //!< Microseconds, 0 .. 999999
+	} TimeOfDay_t;
 
-    /**
-     * This method returns the number of clock ticks per second.
-     * In RTEMS, this is typically 1000.
-     * @return	The number of ticks.
-     *
-     * @deprecated, we should not worry about ticks, but only time
-     */
-    static uint32_t getTicksPerSecond(void);
-    /**
-     * This system call sets the system time.
-     * To set the time, it uses a TimeOfDay_t struct.
-     * @param time The struct with the time settings to set.
-     * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
-     * 				is returned.
-     */
-    static ReturnValue_t setClock(const TimeOfDay_t* time);
-    /**
-     * This system call sets the system time.
-     * To set the time, it uses a timeval struct.
-     * @param time The struct with the time settings to set.
-     * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t setClock(const timeval* time);
-    /**
-     * This system call returns the current system clock in timeval format.
-     * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
-     * microseconds since an OS-defined epoch.
-     * @param time	A pointer to a timeval struct where the current time is stored.
-     * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getClock_timeval(timeval* time);
+	/**
+	 * This method returns the number of clock ticks per second.
+	 * In RTEMS, this is typically 1000.
+	 * @return	The number of ticks.
+	 *
+	 * @deprecated, we should not worry about ticks, but only time
+	 */
+	static uint32_t getTicksPerSecond(void);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a TimeOfDay_t struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
+	 * 				is returned.
+	 */
+	static ReturnValue_t setClock(const TimeOfDay_t* time);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a timeval struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setClock(const timeval* time);
+	/**
+	 * This system call returns the current system clock in timeval format.
+	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
+	 * microseconds since an OS-defined epoch.
+	 * @param time	A pointer to a timeval struct where the current time is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_timeval(timeval* time);
 
-    /**
-     * Get the time since boot in a timeval struct
-     *
-     * @param[out] time A pointer to a timeval struct where the uptime is stored.
-     * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-     *
-     * @deprecated, I do not think this should be able to fail, use timeval getUptime()
-     */
-    static ReturnValue_t getUptime(timeval* uptime);
+	/**
+	 * Get the time since boot in a timeval struct
+	 *
+	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 *
+	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
+	 */
+	static ReturnValue_t getUptime(timeval* uptime);
 
-    static timeval getUptime();
+	static timeval getUptime();
 
-    /**
-     * Get the time since boot in milliseconds
-     *
-     * This value can overflow! Still, it can be used to calculate time intervalls
-     * between two calls up to 49 days by always using uint32_t in the calculation
-     *
-     * @param ms uptime in ms
-     * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getUptime(uint32_t* uptimeMs);
+	/**
+	 * Get the time since boot in milliseconds
+	 *
+	 * This value can overflow! Still, it can be used to calculate time intervalls
+	 * between two calls up to 49 days by always using uint32_t in the calculation
+	 *
+	 * @param ms uptime in ms
+	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getUptime(uint32_t* uptimeMs);
 
-    /**
-     * Returns the time in microseconds since an OS-defined epoch.
-     * The time is returned in a 64 bit unsigned integer.
-     * @param time A pointer to a 64 bit unisigned integer where the data is stored.
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getClock_usecs(uint64_t* time);
-    /**
-     * Returns the time in a TimeOfDay_t struct.
-     * @param time A pointer to a TimeOfDay_t struct.
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
+	/**
+	 * Returns the time in microseconds since an OS-defined epoch.
+	 * The time is returned in a 64 bit unsigned integer.
+	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_usecs(uint64_t* time);
+	/**
+	 * Returns the time in a TimeOfDay_t struct.
+	 * @param time A pointer to a TimeOfDay_t struct.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
 
-    /**
-     * Converts a time of day struct to POSIX seconds.
-     * @param time The time of day as input
-     * @param timeval The corresponding seconds since the epoch.
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-            timeval* to);
+	/**
+	 * Converts a time of day struct to POSIX seconds.
+	 * @param time The time of day as input
+	 * @param timeval The corresponding seconds since the epoch.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+			timeval* to);
 
-    /**
-     * Converts a time represented as seconds and subseconds since unix
-     * epoch to days since J2000
-     *
-     * @param time seconds since unix epoch
-     * @param[out] JD2000 days since J2000
-     * @return @c RETURN_OK
-     */
-    static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
+	/**
+	 * Converts a time represented as seconds and subseconds since unix
+	 * epoch to days since J2000
+	 *
+	 * @param time seconds since unix epoch
+	 * @param[out] JD2000 days since J2000
+	 * @return @c RETURN_OK
+	 */
+	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
 
-    /**
-     * Calculates and adds the offset between UTC and TT
-     *
-     * Depends on the leap seconds to be set correctly.
-     *
-     * @param utc timeval, corresponding to UTC time
-     * @param[out] tt timeval, corresponding to Terrestial Time
-     * @return
-     *  - @c RETURN_OK on success
-     *  - @c RETURN_FAILED if leapSeconds are not set
-     */
-    static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
+	/**
+	 * Calculates and adds the offset between UTC and TT
+	 *
+	 * Depends on the leap seconds to be set correctly.
+	 *
+	 * @param utc timeval, corresponding to UTC time
+	 * @param[out] tt timeval, corresponding to Terrestial Time
+	 * @return
+	 *  - @c RETURN_OK on success
+	 *  - @c RETURN_FAILED if leapSeconds are not set
+	 */
+	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
 
-    /**
-     * Set the Leap Seconds since 1972
-     *
-     * @param leapSeconds_
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
+	/**
+	 * Set the Leap Seconds since 1972
+	 *
+	 * @param leapSeconds_
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
 
-    /**
-     * Get the Leap Seconds since 1972
-     *
-     * Must be set before!
-     *
-     * @param[out] leapSeconds_
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
+	/**
+	 * Get the Leap Seconds since 1972
+	 *
+	 * Must be set before!
+	 *
+	 * @param[out] leapSeconds_
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
 
-    /**
-     * Function to check and create the Mutex for the clock
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise @c RETURN_FAILED if not able to create one
-     */
-    static ReturnValue_t checkOrCreateClockMutex();
+	/**
+	 * Function to check and create the Mutex for the clock
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise @c RETURN_FAILED if not able to create one
+	 */
+	static ReturnValue_t checkOrCreateClockMutex();
 
 private:
-    static MutexIF* timeMutex;
-    static uint16_t leapSeconds;
+	static MutexIF* timeMutex;
+	static uint16_t leapSeconds;
 };
 
 

From 7b98b0d5dd01806048753f6f6992402d84632654 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:04:39 +0100
Subject: [PATCH 1282/1774] txt is md now

---
 doc/{README-devicehandlers.txt => README-devicehandlers.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename doc/{README-devicehandlers.txt => README-devicehandlers.md} (100%)

diff --git a/doc/README-devicehandlers.txt b/doc/README-devicehandlers.md
similarity index 100%
rename from doc/README-devicehandlers.txt
rename to doc/README-devicehandlers.md

From f21f43754bd02535d4f3e31fd70779617e701178 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:06:46 +0100
Subject: [PATCH 1283/1774] taken over upstream defaultcfg

---
 defaultcfg/fsfwconfig/CMakeLists.txt | 15 +++++++++++++++
 defaultcfg/fsfwconfig/FSFWConfig.h   |  2 --
 2 files changed, 15 insertions(+), 2 deletions(-)
 create mode 100644 defaultcfg/fsfwconfig/CMakeLists.txt

diff --git a/defaultcfg/fsfwconfig/CMakeLists.txt b/defaultcfg/fsfwconfig/CMakeLists.txt
new file mode 100644
index 000000000..b8b41c930
--- /dev/null
+++ b/defaultcfg/fsfwconfig/CMakeLists.txt
@@ -0,0 +1,15 @@
+target_sources(${TARGET_NAME} 
+	PRIVATE
+)
+
+# Add include paths for the executable
+target_include_directories(${TARGET_NAME} 
+	PUBLIC 
+		${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+# Add include paths for the FSFW library
+target_include_directories(${LIB_FSFW_NAME} 
+	PUBLIC
+		${CMAKE_CURRENT_SOURCE_DIR}
+)
\ No newline at end of file
diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index dda8497d7..e1815d050 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -21,13 +21,11 @@
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
-#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
 #include "objects/translateObjects.h"
 #include "events/translateEvents.h"
 #else
-#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities

From c603bcc91c528f1d2c76c2af8132e26873c9f7c1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:08:24 +0100
Subject: [PATCH 1284/1774] some upstream stuff taken over

---
 action/CMakeLists.txt        |  7 +++++++
 container/CMakeLists.txt     |  5 +++++
 datalinklayer/CMakeLists.txt | 12 ++++++++++++
 datapool/CMakeLists.txt      |  7 +------
 datapoollocal/CMakeLists.txt |  8 ++++++++
 doc/README-devicehandlers.md |  1 +
 6 files changed, 34 insertions(+), 6 deletions(-)
 create mode 100644 action/CMakeLists.txt
 create mode 100644 container/CMakeLists.txt
 create mode 100644 datalinklayer/CMakeLists.txt
 create mode 100644 datapoollocal/CMakeLists.txt

diff --git a/action/CMakeLists.txt b/action/CMakeLists.txt
new file mode 100644
index 000000000..a62d4044b
--- /dev/null
+++ b/action/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ActionHelper.cpp
+		ActionMessage.cpp
+		CommandActionHelper.cpp
+		SimpleActionHelper.cpp
+)
\ No newline at end of file
diff --git a/container/CMakeLists.txt b/container/CMakeLists.txt
new file mode 100644
index 000000000..904cde55b
--- /dev/null
+++ b/container/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		SharedRingBuffer.cpp
+		SimpleRingBuffer.cpp
+)
\ No newline at end of file
diff --git a/datalinklayer/CMakeLists.txt b/datalinklayer/CMakeLists.txt
new file mode 100644
index 000000000..148e7c5de
--- /dev/null
+++ b/datalinklayer/CMakeLists.txt
@@ -0,0 +1,12 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clcw.cpp
+		DataLinkLayer.cpp
+		Farm1StateLockout.cpp
+		Farm1StateOpen.cpp
+		Farm1StateWait.cpp
+		MapPacketExtraction.cpp
+		TcTransferFrame.cpp
+		TcTransferFrameLocal.cpp
+		VirtualChannelReception.cpp
+)
\ No newline at end of file
diff --git a/datapool/CMakeLists.txt b/datapool/CMakeLists.txt
index e741f6a13..0d53e1ba1 100644
--- a/datapool/CMakeLists.txt
+++ b/datapool/CMakeLists.txt
@@ -1,11 +1,6 @@
 target_sources(${LIB_FSFW_NAME} 
 	PRIVATE 
-		ControllerSet.cpp
-		DataPool.cpp
-		DataPoolAdmin.cpp
-		DataPoolParameterWrapper.cpp
-		DataSet.cpp
 		HkSwitchHelper.cpp
+		PoolDataSetBase.cpp
 		PoolEntry.cpp
-		PoolRawAccess.cpp
 )
\ No newline at end of file
diff --git a/datapoollocal/CMakeLists.txt b/datapoollocal/CMakeLists.txt
new file mode 100644
index 000000000..c6b187cd2
--- /dev/null
+++ b/datapoollocal/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		LocalDataPoolManager.cpp
+		LocalDataSet.cpp
+		LocalPoolDataSetBase.cpp
+		LocalPoolObjectBase.cpp
+		SharedLocalDataSet.cpp
+)
\ No newline at end of file
diff --git a/doc/README-devicehandlers.md b/doc/README-devicehandlers.md
index e69de29bb..6e737cc5a 100644
--- a/doc/README-devicehandlers.md
+++ b/doc/README-devicehandlers.md
@@ -0,0 +1 @@
+## FSFW DeviceHandlers
\ No newline at end of file

From e052a9694ffa14cda100ce39a3c106b23dbc79f3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:10:13 +0100
Subject: [PATCH 1285/1774] upstream stuff

---
 CMakeLists.txt                          | 114 ++++++++++++++++++------
 events/CMakeLists.txt                   |   1 -
 fdir/CMakeLists.txt                     |   6 ++
 health/CMakeLists.txt                   |   6 ++
 housekeeping/CMakeLists.txt             |   5 ++
 internalError/CMakeLists.txt            |   4 +
 internalError/InternalErrorReporter.cpp |   3 +-
 memory/CMakeLists.txt                   |   5 ++
 modes/CMakeLists.txt                    |   5 ++
 monitoring/CMakeLists.txt               |   5 ++
 objectmanager/CMakeLists.txt            |   5 ++
 11 files changed, 128 insertions(+), 31 deletions(-)
 create mode 100644 fdir/CMakeLists.txt
 create mode 100644 health/CMakeLists.txt
 create mode 100644 housekeeping/CMakeLists.txt
 create mode 100644 internalError/CMakeLists.txt
 create mode 100644 memory/CMakeLists.txt
 create mode 100644 modes/CMakeLists.txt
 create mode 100644 monitoring/CMakeLists.txt
 create mode 100644 objectmanager/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 669283c74..02849ca44 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,30 +3,42 @@ cmake_minimum_required(VERSION 3.13)
 set(LIB_FSFW_NAME fsfw)
 add_library(${LIB_FSFW_NAME})
 
-# Set options for FSFW OSAL selection.
-if(UNIX)
-set(OS_FSFW  "linux" CACHE STRING "OS abstraction layer used in the FSFW")
-elseif(WIN32)
-set(OS_FSFW  "host" CACHE STRING "OS abstraction layer used in the FSFW")
-endif()
-
 set_property(CACHE OS_FSFW PROPERTY STRINGS host linux rtems freertos)
 
-if(${OS_FSFW} STREQUAL host)
-set(OS_FSFW_NAME "Host")
-elseif(${OS_FSFW} STREQUAL linux)
-set(OS_FSFW_NAME "Linux")
-elseif(${OS_FSFW} STREQUAL  freertos)
-set(OS_FSFW_NAME "FreeRTOS")
-elseif(${OS_FSFW} STREQUAL rtems)
-set(OS_FSFW_NAME "RTEMS")
-else()
-message(WARNING "Invalid operating system for FSFW specified! Setting to host..")
-set(OS_FSFW_NAME "Host")
-set(OS_FSFW "host")
+if(NOT OS_FSFW)
+	message(STATUS "No OS for FSFW via OS_FSFW set. Assuming host OS")
+	# Assume host OS and autodetermine from OS_FSFW
+	if(UNIX)
+		set(OS_FSFW  "linux" 
+			CACHE STRING 
+			"OS abstraction layer used in the FSFW"
+		)
+	elseif(WIN32)
+		set(OS_FSFW  "host" 
+			CACHE STRING "OS abstraction layer used in the FSFW"
+		)
+	endif()
+
 endif()
 
-message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system")
+if(${OS_FSFW} STREQUAL host)
+	set(OS_FSFW_NAME "Host")
+elseif(${OS_FSFW} STREQUAL linux)
+	set(OS_FSFW_NAME "Linux")
+elseif(${OS_FSFW} STREQUAL  freertos)
+	set(OS_FSFW_NAME "FreeRTOS")
+	target_link_libraries(${LIB_FSFW_NAME} ${LIB_OS_NAME})
+elseif(${OS_FSFW} STREQUAL rtems)
+	set(OS_FSFW_NAME "RTEMS")
+else()
+	message(WARNING 
+		"Invalid operating system for FSFW specified! Setting to host.."
+	)
+	set(OS_FSFW_NAME "Host")
+	set(OS_FSFW "host")
+endif()
+
+message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
 
 # Options to exclude parts of the FSFW from compilation.
 option(FSFW_USE_RMAP "Compile with RMAP" ON)
@@ -36,8 +48,14 @@ add_subdirectory(action)
 add_subdirectory(container)
 add_subdirectory(controller)
 add_subdirectory(coordinates)
-add_subdirectory(datalinklayer)
+
+if(FSFW_USE_DATALINKLAYER)
+	add_subdirectory(datalinklayer)
+endif()
+
 add_subdirectory(datapool)
+add_subdirectory(datapoollocal)
+add_subdirectory(housekeeping)
 add_subdirectory(devicehandlers)
 add_subdirectory(events)
 add_subdirectory(fdir)
@@ -55,7 +73,7 @@ add_subdirectory(power)
 add_subdirectory(pus)
 
 if(FSFW_USE_RMAP)
-add_subdirectory(rmap)
+	add_subdirectory(rmap)
 endif()
 
 add_subdirectory(serialize)
@@ -73,13 +91,53 @@ add_subdirectory(tmtcservices)
 # The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
 # If this is not given, we include the default configuration and emit a warning.
 if(NOT FSFW_CONFIG_PATH)
-message(WARNING "Flight Software Framework configuration path not set!")
-message(WARNING "Setting default configuration!")
-add_subdirectory(defaultcfg/fsfwconfig)
+	message(WARNING "Flight Software Framework configuration path not set!")
+	message(WARNING "Setting default configuration!")
+	add_subdirectory(defaultcfg/fsfwconfig)
+endif()
+
+# FSFW might be part of a possibly complicated folder structure, so we 
+# extract the absolute path of the fsfwconfig folder.
+if(IS_ABSOLUTE ${FSFW_CONFIG_PATH})
+	set(FSFW_CONFIG_PATH_ABSOLUTE ${FSFW_CONFIG_PATH})
+else()
+	get_filename_component(FSFW_CONFIG_PATH_ABSOLUTE
+		${FSFW_CONFIG_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR}
+	)
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+	set(WARNING_FLAGS
+		-Wall
+		-Wextra
+		-Wshadow=local
+		-Wimplicit-fallthrough=1
+		-Wno-unused-parameter
+		-Wno-psabi
+	)
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+	set(COMPILER_FLAGS "/permissive-")
 endif()
 
 # Required include paths to compile the FSFW
-target_include_directories(${LIB_FSFW_NAME} 
-	INTERFACE 
-		${FSFW_CONFIG_PATH}
+target_include_directories(${LIB_FSFW_NAME} INTERFACE 
+	${CMAKE_SOURCE_DIR}
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+)
+
+# Includes path required to compile FSFW itself as well
+# We assume that the fsfwconfig folder uses include relative to the project
+# root here!
+target_include_directories(${LIB_FSFW_NAME} PRIVATE 
+	${CMAKE_SOURCE_DIR}
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+)
+
+# Machine specific options can be set with the ABI_FLAGS variable.
+target_compile_options(${LIB_FSFW_NAME} PRIVATE 
+	${WARNING_FLAGS}
+	${COMPILER_FLAGS}
+	${ABI_FLAGS}
 )
diff --git a/events/CMakeLists.txt b/events/CMakeLists.txt
index 9e63deb89..4e935167a 100644
--- a/events/CMakeLists.txt
+++ b/events/CMakeLists.txt
@@ -1,6 +1,5 @@
 target_sources(${LIB_FSFW_NAME} 
 	PRIVATE 
-		Event.cpp
 		EventManager.cpp
 		EventMessage.cpp
 )
diff --git a/fdir/CMakeLists.txt b/fdir/CMakeLists.txt
new file mode 100644
index 000000000..f5ffbba8d
--- /dev/null
+++ b/fdir/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		EventCorrelation.cpp
+		FailureIsolationBase.cpp
+		FaultCounter.cpp
+)
\ No newline at end of file
diff --git a/health/CMakeLists.txt b/health/CMakeLists.txt
new file mode 100644
index 000000000..d5f3ccd30
--- /dev/null
+++ b/health/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		HealthHelper.cpp
+		HealthMessage.cpp
+		HealthTable.cpp	
+)
\ No newline at end of file
diff --git a/housekeeping/CMakeLists.txt b/housekeeping/CMakeLists.txt
new file mode 100644
index 000000000..fecad2e3d
--- /dev/null
+++ b/housekeeping/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		HousekeepingMessage.cpp
+		PeriodicHousekeepingHelper.cpp
+)
\ No newline at end of file
diff --git a/internalError/CMakeLists.txt b/internalError/CMakeLists.txt
new file mode 100644
index 000000000..2b383914c
--- /dev/null
+++ b/internalError/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		InternalErrorReporter.cpp
+)
\ No newline at end of file
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 8d5c792b8..bfb672891 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -5,8 +5,7 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
-        uint32_t messageQueueDepth) :
-		SystemObject(setObjectId),
+        uint32_t messageQueueDepth): SystemObject(setObjectId),
 		commandQueue(QueueFactory::instance()->
 		        createMessageQueue(messageQueueDepth)),
 		poolManager(this, commandQueue),
diff --git a/memory/CMakeLists.txt b/memory/CMakeLists.txt
new file mode 100644
index 000000000..9edb9031f
--- /dev/null
+++ b/memory/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		MemoryHelper.cpp
+		MemoryMessage.cpp
+)
\ No newline at end of file
diff --git a/modes/CMakeLists.txt b/modes/CMakeLists.txt
new file mode 100644
index 000000000..8e5c719bc
--- /dev/null
+++ b/modes/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ModeHelper.cpp
+		ModeMessage.cpp
+)
\ No newline at end of file
diff --git a/monitoring/CMakeLists.txt b/monitoring/CMakeLists.txt
new file mode 100644
index 000000000..d26e807c3
--- /dev/null
+++ b/monitoring/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		LimitViolationReporter.cpp
+		MonitoringMessage.cpp
+)
\ No newline at end of file
diff --git a/objectmanager/CMakeLists.txt b/objectmanager/CMakeLists.txt
new file mode 100644
index 000000000..72aaec896
--- /dev/null
+++ b/objectmanager/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ObjectManager.cpp
+		SystemObject.cpp
+)
\ No newline at end of file

From 571a64c42a72efb1ce0fc717215f714f81294fcb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:10:53 +0100
Subject: [PATCH 1286/1774] time stamper ID added

---
 objectmanager/frameworkObjects.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 57783286a..8f8e93af7 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -22,6 +22,7 @@ enum framework_objects {
 	//IDs for PUS Packet Communication
 	TC_STORE = 0x534f0100,
 	TM_STORE = 0x534f0200,
+	TIME_STAMPER = 0x53500010,
 
 	NO_OBJECT = 0xFFFFFFFF
 };

From c174c9ecb82fd18a796cdaf41706b44982e3ba79 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:15:18 +0100
Subject: [PATCH 1287/1774] osal taken over

---
 osal/CMakeLists.txt               | 34 +++++++++++++++++++++++++++++++
 osal/FreeRTOS/CMakeLists.txt      | 30 +++++++++++++++++++++++++++
 osal/host/CMakeLists.txt          | 21 +++++++++++++++++++
 osal/windows/CMakeLists.txt       | 11 ++++++++++
 osal/windows/TmTcWinUdpBridge.cpp |  9 ++++----
 5 files changed, 101 insertions(+), 4 deletions(-)
 create mode 100644 osal/CMakeLists.txt
 create mode 100644 osal/FreeRTOS/CMakeLists.txt
 create mode 100644 osal/host/CMakeLists.txt
 create mode 100644 osal/windows/CMakeLists.txt

diff --git a/osal/CMakeLists.txt b/osal/CMakeLists.txt
new file mode 100644
index 000000000..02ff24057
--- /dev/null
+++ b/osal/CMakeLists.txt
@@ -0,0 +1,34 @@
+# Check the OS_FSFW variable
+if(${OS_FSFW} STREQUAL "freertos")
+	add_subdirectory(FreeRTOS)
+elseif(${OS_FSFW} STREQUAL "rtems")
+	add_subdirectory(rtems)
+elseif(${OS_FSFW} STREQUAL "linux")
+	add_subdirectory(linux)
+elseif(${OS_FSFW} STREQUAL "host")
+	add_subdirectory(host)
+	if (WIN32)
+		add_subdirectory(windows)
+	elseif(UNIX)
+		target_sources(${LIB_FSFW_NAME}
+			PUBLIC
+				linux/TcUnixUdpPollingTask.cpp
+				linux/TmTcUnixUdpBridge.cpp
+		)
+	endif ()
+
+else()
+
+	message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
+	# Not set. Assumuing this is a host build, try to determine host OS
+	if (WIN32)
+		add_subdirectory(host)
+		add_subdirectory(windows)
+	elseif (UNIX)
+		add_subdirectory(linux)
+	else ()
+		# MacOS or other OSes have not been tested yet / are not supported.
+		message(FATAL_ERROR "The host OS could not be determined! Aborting.")
+	endif()
+
+endif()
\ No newline at end of file
diff --git a/osal/FreeRTOS/CMakeLists.txt b/osal/FreeRTOS/CMakeLists.txt
new file mode 100644
index 000000000..95462010f
--- /dev/null
+++ b/osal/FreeRTOS/CMakeLists.txt
@@ -0,0 +1,30 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		FixedTimeslotTask.cpp
+		BinarySemaphore.cpp
+		BinSemaphUsingTask.cpp
+		CountingSemaphore.cpp
+		CountingSemaphUsingTask.cpp
+		MessageQueue.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PeriodicTask.cpp
+		QueueFactory.cpp
+		SemaphoreFactory.cpp
+		TaskFactory.cpp
+		Timekeeper.cpp
+		TaskManagement.cpp
+)
+
+# FreeRTOS is required to link the FSFW now. It is recommended to compile 
+# FreeRTOS as a static library and set LIB_OS_NAME to the target name of the 
+# library.
+if(NOT LIB_OS_NAME)
+	message(FATAL_ERROR 
+		"FreeRTOS needs to be linked as a target and "
+		"LIB_OS_NAME needs to be set to the target"
+	)
+endif()
+
+target_link_libraries(${LIB_FSWFW_NAME} ${LIB_OS_NAME})
\ No newline at end of file
diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
new file mode 100644
index 000000000..aa32990be
--- /dev/null
+++ b/osal/host/CMakeLists.txt
@@ -0,0 +1,21 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		FixedTimeslotTask.cpp
+		MessageQueue.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PeriodicTask.cpp
+		QueueFactory.cpp
+		QueueMapManager.cpp
+		SemaphoreFactory.cpp
+		TaskFactory.cpp
+)
+
+if(UNIX)
+	target_link_libraries(${LIB_FSFW_NAME} 
+	PRIVATE
+		rt
+		pthread
+	)
+endif()
\ No newline at end of file
diff --git a/osal/windows/CMakeLists.txt b/osal/windows/CMakeLists.txt
new file mode 100644
index 000000000..b6e76d6a3
--- /dev/null
+++ b/osal/windows/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		TcWinUdpPollingTask.cpp
+		TmTcWinUdpBridge.cpp
+)
+
+target_link_libraries(${LIB_FSFW_NAME} 
+	PRIVATE
+		wsock32 
+		ws2_32
+)
\ No newline at end of file
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 2af3daa51..e1ba132ee 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -6,6 +6,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
         uint16_t serverPort, uint16_t clientPort):
         TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
     mutex = MutexFactory::instance()->createMutex();
+    communicationLinkUp = false;
 
     // Initiates Winsock DLL.
     WSAData wsaData;
@@ -90,7 +91,6 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 //  sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
 //          " sent." << std::endl;
     return HasReturnvaluesIF::RETURN_OK;
-    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
@@ -101,6 +101,7 @@ void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
 //          &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;
+    registerCommConnect();
 
     // Set new IP address if it has changed.
     if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
@@ -114,7 +115,7 @@ void TmTcWinUdpBridge::handleSocketError() {
     switch(errCode) {
     case(WSANOTINITIALISED): {
         sif::info << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: "
-                << "WSAStartup(...) call " << "necessary" << std::endl;
+                << "WSAStartup(...) call necessary" << std::endl;
         break;
     }
     default: {
@@ -159,11 +160,11 @@ void TmTcWinUdpBridge::handleSendError() {
     switch(errCode) {
     case(WSANOTINITIALISED): {
         sif::info << "TmTcWinUdpBridge::handleSendError: WSANOTINITIALISED: "
-                << "WSAStartup(...) call " << "necessary" << std::endl;
+                << "WSAStartup(...) call necessary" << std::endl;
         break;
     }
     case(WSAEADDRNOTAVAIL): {
-        sif::info << "TmTcWinUdpBridge::handleReadError: WSAEADDRNOTAVAIL: "
+        sif::info << "TmTcWinUdpBridge::handleSendError: WSAEADDRNOTAVAIL: "
                 << "Check target address. " << std::endl;
         break;
     }

From e674b9248a272a48f1aed66e6550770bfb9abcf1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:15:40 +0100
Subject: [PATCH 1288/1774] better error handling

---
 osal/windows/TmTcWinUdpBridge.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 1f66290fb..e1ba132ee 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -138,6 +138,11 @@ void TmTcWinUdpBridge::handleBindError() {
                 << "WSAStartup(...) call " << "necessary" << std::endl;
         break;
     }
+    case(WSAEADDRINUSE): {
+    	sif::warning << "TmTcWinUdpBridge::handleBindError: WSAEADDRINUSE: "
+    			<< "Port is already in use!" << std::endl;
+    	break;
+    }
     default: {
         /*
         https://docs.microsoft.com/en-us/windows/win32/winsock/

From f6e7e232f58ce9119265ac9be8c6cf596b3af76d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:17:15 +0100
Subject: [PATCH 1289/1774] parameter upstream taken over

---
 parameters/CMakeLists.txt       | 6 ++++++
 parameters/ParameterWrapper.cpp | 7 ++++---
 2 files changed, 10 insertions(+), 3 deletions(-)
 create mode 100644 parameters/CMakeLists.txt

diff --git a/parameters/CMakeLists.txt b/parameters/CMakeLists.txt
new file mode 100644
index 000000000..fb5e45900
--- /dev/null
+++ b/parameters/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ParameterHelper.cpp
+		ParameterMessage.cpp
+		ParameterWrapper.cpp
+)
\ No newline at end of file
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 239555162..d9f1ef685 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -123,7 +123,8 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
 		//get the start element of this row in data
-	    uint16_t offset = (((startingRow + fromRow) * columns) + startingColumn);
+	    uint16_t offset = (((startingRow + fromRow) *
+	    		static_cast<uint16_t>(columns)) + startingColumn);
 		T *dataWithDataType = static_cast<T*>(data) + offset;
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
@@ -296,8 +297,8 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		//need a type to do arithmetic
 		uint8_t* typedData = static_cast<uint8_t*>(data);
 		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
-			size_t offset = (((startingRow + fromRow) * columns) +
-					startingColumn) * typeSize;
+			size_t offset = (((startingRow + fromRow) * static_cast<uint16_t>(
+					columns)) + startingColumn) * typeSize;
 			std::memcpy(typedData +  offset, from->readonlyData,
 					typeSize * from->columns);
 		}

From 2e1ad41da76ea50847a9fa9756e1751d503ae85c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:18:12 +0100
Subject: [PATCH 1290/1774] power and pus upstream taken over

---
 power/CMakeLists.txt                |  7 +++++++
 pus/CMakeLists.txt                  | 11 +++++++++++
 pus/CService201HealthCommanding.cpp |  6 +++++-
 3 files changed, 23 insertions(+), 1 deletion(-)
 create mode 100644 power/CMakeLists.txt
 create mode 100644 pus/CMakeLists.txt

diff --git a/power/CMakeLists.txt b/power/CMakeLists.txt
new file mode 100644
index 000000000..1c625db11
--- /dev/null
+++ b/power/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Fuse.cpp
+		PowerComponent.cpp
+		PowerSensor.cpp
+		PowerSwitcher.cpp
+)
\ No newline at end of file
diff --git a/pus/CMakeLists.txt b/pus/CMakeLists.txt
new file mode 100644
index 000000000..758c26293
--- /dev/null
+++ b/pus/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CService200ModeCommanding.cpp
+		CService201HealthCommanding.cpp
+		Service17Test.cpp
+		Service1TelecommandVerification.cpp
+		Service2DeviceAccess.cpp
+		Service5EventReporting.cpp
+		Service8FunctionManagement.cpp
+		Service9TimeManagement.cpp
+)
\ No newline at end of file
diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index db43db898..edacd73a5 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -86,11 +86,15 @@ ReturnValue_t CService201HealthCommanding::handleReply
 		object_id_t objectId, bool *isStep) {
 	Command_t replyId = reply->getCommand();
 	if (replyId == HealthMessage::REPLY_HEALTH_SET) {
-		return prepareHealthSetReply(reply);
+		return EXECUTION_COMPLETE;
+	}
+	else if(replyId == CommandMessageIF::REPLY_REJECTED) {
+		return reply->getReplyRejectedReason();
 	}
 	return CommandingServiceBase::INVALID_REPLY;
 }
 
+// Not used for now, health state already reported by event
 ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(
         const CommandMessage* reply) {
 	prepareHealthSetReply(reply);

From 707bb9dd5d3fe500d511c30f95f7bed596dd9e66 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:18:50 +0100
Subject: [PATCH 1291/1774] serviceinterface taken over

---
 serviceinterface/CMakeLists.txt           | 5 +++++
 serviceinterface/ServiceInterfaceBuffer.h | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)
 create mode 100644 serviceinterface/CMakeLists.txt

diff --git a/serviceinterface/CMakeLists.txt b/serviceinterface/CMakeLists.txt
new file mode 100644
index 000000000..d84adbeb4
--- /dev/null
+++ b/serviceinterface/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ServiceInterfaceStream.cpp
+		ServiceInterfaceBuffer.cpp
+)
\ No newline at end of file
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index e69538d1d..c5d5b2584 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ protected:
 	//! This is called when buffer becomes full. If
 	//! buffer is not used, then this is called every
 	//! time when characters are put to stream.
-	int overflow(int c = std::ostream::traits_type::eof()) override;
+	int overflow(int c = Traits::eof()) override;
 
 	//! This function is called when stream is flushed,
 	//! for example when std::endl is put to stream.

From 41dc9ce6c6942ef92722d9a6c82dde8efa954a88 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:19:30 +0100
Subject: [PATCH 1292/1774] cmake lists form upstream taken over

---
 serialize/CMakeLists.txt      |  4 ++++
 storagemanager/CMakeLists.txt |  2 ++
 tcdistribution/CMakeLists.txt |  7 +++++++
 thermal/CMakeLists.txt        | 10 ++++++++++
 4 files changed, 23 insertions(+)
 create mode 100644 serialize/CMakeLists.txt
 create mode 100644 tcdistribution/CMakeLists.txt
 create mode 100644 thermal/CMakeLists.txt

diff --git a/serialize/CMakeLists.txt b/serialize/CMakeLists.txt
new file mode 100644
index 000000000..fc2387e80
--- /dev/null
+++ b/serialize/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		SerialBufferAdapter.cpp
+)
\ No newline at end of file
diff --git a/storagemanager/CMakeLists.txt b/storagemanager/CMakeLists.txt
index 57c921952..b8138cae7 100644
--- a/storagemanager/CMakeLists.txt
+++ b/storagemanager/CMakeLists.txt
@@ -2,4 +2,6 @@ target_sources(${LIB_FSFW_NAME}
 	PRIVATE 
 		ConstStorageAccessor.cpp
 		StorageAccessor.cpp
+		LocalPool.cpp
+		PoolManager.cpp
 )
\ No newline at end of file
diff --git a/tcdistribution/CMakeLists.txt b/tcdistribution/CMakeLists.txt
new file mode 100644
index 000000000..17dc186c3
--- /dev/null
+++ b/tcdistribution/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CCSDSDistributor.cpp
+		PUSDistributor.cpp
+		TcDistributor.cpp
+		TcPacketCheck.cpp
+)
diff --git a/thermal/CMakeLists.txt b/thermal/CMakeLists.txt
new file mode 100644
index 000000000..ad5327214
--- /dev/null
+++ b/thermal/CMakeLists.txt
@@ -0,0 +1,10 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		AbstractTemperatureSensor.cpp
+		Heater.cpp
+		RedundantHeater.cpp
+		ThermalComponentCore.cpp
+		ThermalComponent.cpp
+		ThermalModule.cpp
+		ThermalMonitorReporter.cpp
+)

From f905a753e2b7517bdeff19fc9bbaf9435df9f807 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:20:24 +0100
Subject: [PATCH 1293/1774] upstream unittest folder adapted

---
 unittest/testcfg/FSFWConfig.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 94f6e59d1..6b0def902 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -21,13 +21,11 @@
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
-#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
 #include "objects/translateObjects.h"
 #include "events/translateEvents.h"
 #else
-#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities

From 27d03dc17f6bb14a03f85f5c69f21eed485b52ed Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:21:17 +0100
Subject: [PATCH 1294/1774] upstream cmakelists f iles taken over

---
 tmtcpacket/CMakeLists.txt               | 8 ++++++++
 tmtcpacket/packetmatcher/CMakeLists.txt | 4 ++++
 tmtcpacket/pus/CMakeLists.txt           | 8 ++++++++
 3 files changed, 20 insertions(+)
 create mode 100644 tmtcpacket/CMakeLists.txt
 create mode 100644 tmtcpacket/packetmatcher/CMakeLists.txt
 create mode 100644 tmtcpacket/pus/CMakeLists.txt

diff --git a/tmtcpacket/CMakeLists.txt b/tmtcpacket/CMakeLists.txt
new file mode 100644
index 000000000..fe3d2a4d2
--- /dev/null
+++ b/tmtcpacket/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		SpacePacket.cpp
+		SpacePacketBase.cpp
+)
+
+add_subdirectory(packetmatcher)
+add_subdirectory(pus)
\ No newline at end of file
diff --git a/tmtcpacket/packetmatcher/CMakeLists.txt b/tmtcpacket/packetmatcher/CMakeLists.txt
new file mode 100644
index 000000000..e9a8d03bb
--- /dev/null
+++ b/tmtcpacket/packetmatcher/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		PacketMatchTree.cpp
+)
diff --git a/tmtcpacket/pus/CMakeLists.txt b/tmtcpacket/pus/CMakeLists.txt
new file mode 100644
index 000000000..fcfc82d2c
--- /dev/null
+++ b/tmtcpacket/pus/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		TcPacketBase.cpp
+		TcPacketStored.cpp
+		TmPacketBase.cpp
+		TmPacketMinimal.cpp
+		TmPacketStored.cpp
+)

From f017e9c6d4f16cc8a417d1d06c06a439139a0bb1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:22:11 +0100
Subject: [PATCH 1295/1774] include guards

---
 tmtcpacket/pus/TmPacketStored.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tmtcpacket/pus/TmPacketStored.h b/tmtcpacket/pus/TmPacketStored.h
index 6ddbf1318..b231407d0 100644
--- a/tmtcpacket/pus/TmPacketStored.h
+++ b/tmtcpacket/pus/TmPacketStored.h
@@ -1,5 +1,5 @@
-#ifndef TMTCPACKET_PUS_TMPACKETSTORED_H_
-#define TMTCPACKET_PUS_TMPACKETSTORED_H_
+#ifndef FSFW_TMTCPACKET_PUS_TMPACKETSTORED_H_
+#define FSFW_TMTCPACKET_PUS_TMPACKETSTORED_H_
 
 #include "TmPacketBase.h"
 
@@ -105,4 +105,4 @@ private:
 };
 
 
-#endif /* TMTCPACKET_PUS_TMPACKETSTORED_H_ */
+#endif /* FSFW_TMTCPACKET_PUS_TMPACKETSTORED_H_ */

From e55df691ff1d121e5b72dbefd0493aee737ef55e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:24:15 +0100
Subject: [PATCH 1296/1774] upstream subsystem taken over

---
 subsystem/Subsystem.h | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index c3a72d542..69563643e 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -62,21 +62,6 @@ public:
 
 	virtual MessageQueueId_t getSequenceCommandQueue() const override;
 
-	/**
-	 * @brief    Checks whether a sequence, identified by a mode.
-	 * @param sequence
-	 * @return
-	 */
-	ReturnValue_t checkSequence(Mode_t sequence);
-
-	/**
-	 * @brief   Checks whether a sequence, identified by a mode list iterator
-	 *          and a fallback sequence.
-	 * @param iter
-	 * @return
-	 */
-	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter,
-	        Mode_t fallbackSequence);
 protected:
 
 	struct EntryPointer {
@@ -166,6 +151,22 @@ protected:
 
 	void cantKeepMode();
 
+	/**
+	 * @brief    Checks whether a sequence, identified by a mode.
+	 * @param sequence
+	 * @return
+	 */
+	ReturnValue_t checkSequence(Mode_t sequence);
+
+	/**
+	 * @brief   Checks whether a sequence, identified by a mode list iterator
+	 *          and a fallback sequence. Iterator needs to point to a valid
+	 *          sequence.
+	 * @param iter
+	 * @return
+	 */
+	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter,
+	        Mode_t fallbackSequence);
 };
 
 #endif /* FSFW_SUBSYSTEM_SUBSYSTEM_H_ */

From 208ad7d479d983f77629ee6b86ca19c24d2ed95b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:24:52 +0100
Subject: [PATCH 1297/1774] fixed timeslot task doc

---
 tasks/FixedTimeslotTaskIF.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index a138db4e2..2fc7e0922 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -14,7 +14,8 @@ public:
 
 	/**
 	 * Add an object with a slot time and the execution step to the task.
-	 * The execution step shall be passed to the object.
+	 * The execution step will be passed to the object (e.g. as an operation
+	 * code in #performOperation)
 	 * @param componentId
 	 * @param slotTimeMs
 	 * @param executionStep

From dcc111e4facf39137fe52d8234361b7d99bdde06 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 23 Dec 2020 20:17:10 +0100
Subject: [PATCH 1298/1774] moved no comamnd and raw command to device handler
 IF

---
 devicehandlers/DeviceHandlerBase.cpp | 4 ++--
 devicehandlers/DeviceHandlerBase.h   | 2 --
 devicehandlers/DeviceHandlerIF.h     | 3 ++-
 3 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d2d4ecb8d..d06308543 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -693,7 +693,7 @@ void DeviceHandlerBase::doGetRead() {
 void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		size_t receivedDataLen) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	DeviceCommandId_t foundId = DeviceHandlerIF::NO_COMMAND;
+	DeviceCommandId_t foundId = DeviceHandlerIF::NO_COMMAND_ID;
 	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
@@ -1452,7 +1452,7 @@ DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
     if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
         return cookieInfo.pendingCommand->first;
     }
-    return DeviceHandlerIF::NO_COMMAND;
+    return DeviceHandlerIF::NO_COMMAND_ID;
 }
 
 void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 45450f627..24ba0372c 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -575,8 +575,6 @@ protected:
 	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE0);
 	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE1);
 
-	static const DeviceCommandId_t RAW_COMMAND_ID = -1;
-	static const DeviceCommandId_t NO_COMMAND_ID = -2;
 	static const MessageQueueId_t NO_COMMANDER = 0;
 
 	/** Pointer to the raw packet that will be sent.*/
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index e56487515..865b38b36 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -22,7 +22,8 @@ using DeviceCommandId_t = uint32_t;
  */
 class DeviceHandlerIF {
 public:
-	static constexpr DeviceCommandId_t NO_COMMAND = -1;
+	static const DeviceCommandId_t RAW_COMMAND_ID = -1;
+	static const DeviceCommandId_t NO_COMMAND_ID = -2;
 
 	static constexpr uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static constexpr uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;

From 68fe923a014533e1097465e0b279aaaff9e34f86 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 24 Dec 2020 02:03:33 +0100
Subject: [PATCH 1299/1774] renamed class enums

---
 datapool/PoolDataSetBase.cpp | 12 ++++++------
 datapool/PoolDataSetBase.h   |  6 +++---
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index cb2348f72..49495a889 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -11,7 +11,7 @@ PoolDataSetBase::~PoolDataSetBase() {}
 
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
-	if (state != States::DATA_SET_UNINITIALISED) {
+	if (state != States::STATE_SET_UNINITIALISED) {
 		sif::error << "DataSet::registerVariable: "
 				"Call made in wrong position." << std::endl;
 		return DataSetIF::DATA_SET_UNINITIALISED;
@@ -33,7 +33,7 @@ ReturnValue_t PoolDataSetBase::registerVariable(
 
 ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	if (state == States::DATA_SET_UNINITIALISED) {
+	if (state == States::STATE_SET_UNINITIALISED) {
 		lockDataPool(lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
 			result = readVariable(count);
@@ -41,7 +41,7 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 				break;
 			}
 		}
-		state = States::DATA_SET_WAS_READ;
+		state = States::STATE_SET_WAS_READ;
 		unlockDataPool();
 	}
 	else {
@@ -80,7 +80,7 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 }
 
 ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
-	if (state == States::DATA_SET_WAS_READ) {
+	if (state == States::STATE_SET_WAS_READ) {
 		handleAlreadyReadDatasetCommit(lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -99,7 +99,7 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 			registeredVariables[count]->commitWithoutLock();
 		}
 	}
-	state = States::DATA_SET_UNINITIALISED;
+	state = States::STATE_SET_UNINITIALISED;
 	unlockDataPool();
 }
 
@@ -121,7 +121,7 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 			}
 		}
 	}
-	state = States::DATA_SET_UNINITIALISED;
+	state = States::STATE_SET_UNINITIALISED;
 	unlockDataPool();
 	return result;
 }
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index a8931d628..66a1924ce 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -124,14 +124,14 @@ protected:
 	 * States of the seet.
 	 */
 	enum class States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
+		STATE_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
+		STATE_SET_WAS_READ     //!< DATA_SET_WAS_READ
 	};
 	/**
 	 * @brief	state manages the internal state of the data set,
 	 *          which is important e.g. for the behavior on destruction.
 	 */
-	States state = States::DATA_SET_UNINITIALISED;
+	States state = States::STATE_SET_UNINITIALISED;
 
 	/**
 	 * @brief	This array represents all pool variables registered in this set.

From 3486a04741a1705d67f450c312e099935973552d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 25 Dec 2020 00:37:24 +0100
Subject: [PATCH 1300/1774] renaming for name shadowing

---
 datapool/PoolDataSetBase.cpp | 12 ++++++------
 datapool/PoolDataSetBase.h   |  6 +++---
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index cb2348f72..49495a889 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -11,7 +11,7 @@ PoolDataSetBase::~PoolDataSetBase() {}
 
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
-	if (state != States::DATA_SET_UNINITIALISED) {
+	if (state != States::STATE_SET_UNINITIALISED) {
 		sif::error << "DataSet::registerVariable: "
 				"Call made in wrong position." << std::endl;
 		return DataSetIF::DATA_SET_UNINITIALISED;
@@ -33,7 +33,7 @@ ReturnValue_t PoolDataSetBase::registerVariable(
 
 ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	if (state == States::DATA_SET_UNINITIALISED) {
+	if (state == States::STATE_SET_UNINITIALISED) {
 		lockDataPool(lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
 			result = readVariable(count);
@@ -41,7 +41,7 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 				break;
 			}
 		}
-		state = States::DATA_SET_WAS_READ;
+		state = States::STATE_SET_WAS_READ;
 		unlockDataPool();
 	}
 	else {
@@ -80,7 +80,7 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 }
 
 ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
-	if (state == States::DATA_SET_WAS_READ) {
+	if (state == States::STATE_SET_WAS_READ) {
 		handleAlreadyReadDatasetCommit(lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -99,7 +99,7 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 			registeredVariables[count]->commitWithoutLock();
 		}
 	}
-	state = States::DATA_SET_UNINITIALISED;
+	state = States::STATE_SET_UNINITIALISED;
 	unlockDataPool();
 }
 
@@ -121,7 +121,7 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 			}
 		}
 	}
-	state = States::DATA_SET_UNINITIALISED;
+	state = States::STATE_SET_UNINITIALISED;
 	unlockDataPool();
 	return result;
 }
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index a8931d628..66a1924ce 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -124,14 +124,14 @@ protected:
 	 * States of the seet.
 	 */
 	enum class States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
+		STATE_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
+		STATE_SET_WAS_READ     //!< DATA_SET_WAS_READ
 	};
 	/**
 	 * @brief	state manages the internal state of the data set,
 	 *          which is important e.g. for the behavior on destruction.
 	 */
-	States state = States::DATA_SET_UNINITIALISED;
+	States state = States::STATE_SET_UNINITIALISED;
 
 	/**
 	 * @brief	This array represents all pool variables registered in this set.

From 9eec75df263f3c184a279281a793b520c5daed81 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 25 Dec 2020 01:49:44 +0100
Subject: [PATCH 1301/1774] linking against thread lib

---
 osal/host/CMakeLists.txt  | 2 +-
 osal/linux/CMakeLists.txt | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
index aa32990be..ee6b4cdbc 100644
--- a/osal/host/CMakeLists.txt
+++ b/osal/host/CMakeLists.txt
@@ -16,6 +16,6 @@ if(UNIX)
 	target_link_libraries(${LIB_FSFW_NAME} 
 	PRIVATE
 		rt
-		pthread
+		${CMAKE_THREAD_LIBS_INIT}
 	)
 endif()
\ No newline at end of file
diff --git a/osal/linux/CMakeLists.txt b/osal/linux/CMakeLists.txt
index c0096e428..e9a2935b0 100644
--- a/osal/linux/CMakeLists.txt
+++ b/osal/linux/CMakeLists.txt
@@ -18,8 +18,8 @@ target_sources(${LIB_FSFW_NAME}
 		Timer.cpp
 )
 
-target_link_libraries(${LIB_FSFW_NAME} 
-	PRIVATE
-		rt
-		pthread
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+	${CMAKE_THREAD_LIBS_INIT}
+	rt
 )
+

From b469340ef45fc63c65069874e413c9aeeab198b3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 26 Dec 2020 18:06:56 +0100
Subject: [PATCH 1302/1774] bugfix

---
 datapoollocal/LocalPoolVariable.tpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 48649ad58..fb1296353 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -40,11 +40,11 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK and poolEntry != nullptr) {
+	if(result != RETURN_OK or poolEntry == nullptr) {
 		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
-				std::dec << " failed.\n" << std::flush;
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< hkManager->getOwner() << " and lp ID " << localPoolId
+				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
 		return result;
 	}
 	this->value = *(poolEntry->address);
@@ -62,7 +62,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		sif::debug << "LocalPoolVar: Invalid read write "
+		sif::debug << "LocalPoolVariable: Invalid read write "
 				 "mode for commit() call." << std::endl;
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}

From e35c2cd604658ac83850aa27891543e461f3a1e9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 26 Dec 2020 23:16:33 +0100
Subject: [PATCH 1303/1774] hk manager optional now

---
 datapoollocal/LocalPoolDataSetBase.cpp | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 640956dba..dc81a6125 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -34,13 +34,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
-    if(hkOwner == nullptr) {
-        // Configuration error.
-        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-                << "invalid!" << std::endl;
-        return;
+    if(hkOwner != nullptr) {
+    	hkManager = hkOwner->getHkManagerHandle();
     }
-    hkManager = hkOwner->getHkManagerHandle();
     this->sid = sid;
 
     mutex = MutexFactory::instance()->createMutex();
@@ -50,8 +46,11 @@ LocalPoolDataSetBase::~LocalPoolDataSetBase() {
 }
 
 ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
-    MutexIF* mutex = hkManager->getMutexHandle();
-    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+	if(hkManager != nullptr) {
+	    MutexIF* mutex = hkManager->getMutexHandle();
+	    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
@@ -127,8 +126,11 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-    MutexIF* mutex = hkManager->getMutexHandle();
-    return mutex->unlockMutex();
+	if(hkManager != nullptr) {
+	    MutexIF* mutex = hkManager->getMutexHandle();
+	    return mutex->unlockMutex();
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,

From 76696e34be711277fdbdd07575380f1e2b294a17 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 26 Dec 2020 23:57:23 +0100
Subject: [PATCH 1304/1774] its possible to protect every read/commit now

---
 datapool/PoolDataSetBase.cpp           | 31 +++++++++++++++++++++++---
 datapool/PoolDataSetBase.h             | 13 +++++++++++
 datapoollocal/LocalPoolDataSetBase.cpp | 10 +++++++--
 datapoollocal/LocalPoolDataSetBase.h   | 13 ++++++++++-
 4 files changed, 61 insertions(+), 6 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 49495a889..ad1de8e4d 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -9,6 +9,8 @@ PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
 
 PoolDataSetBase::~PoolDataSetBase() {}
 
+
+
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
 	if (state != States::STATE_SET_UNINITIALISED) {
@@ -71,7 +73,13 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 		registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER)
 	{
-		result = registeredVariables[count]->readWithoutLock();
+		if(protectEveryReadCommitCall) {
+			result = registeredVariables[count]->read(mutexTimeout);
+		}
+		else {
+			result = registeredVariables[count]->readWithoutLock();
+		}
+
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			result = INVALID_PARAMETER_DEFINITION;
 		}
@@ -96,7 +104,12 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 				!= PoolVariableIF::VAR_READ
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commitWithoutLock();
+			if(protectEveryReadCommitCall) {
+				registeredVariables[count]->commit(mutexTimeout);
+			}
+			else {
+				registeredVariables[count]->commitWithoutLock();
+			}
 		}
 	}
 	state = States::STATE_SET_UNINITIALISED;
@@ -111,7 +124,13 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 				== PoolVariableIF::VAR_WRITE
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commitWithoutLock();
+			if(protectEveryReadCommitCall) {
+				result = registeredVariables[count]->commit(mutexTimeout);
+			}
+			else {
+				result = registeredVariables[count]->commitWithoutLock();
+			}
+
 		} else if (registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if (result != COMMITING_WITHOUT_READING) {
@@ -172,3 +191,9 @@ size_t PoolDataSetBase::getSerializedSize() const {
 void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
     this->registeredVariables = variablesContainer;
 }
+
+void PoolDataSetBase::setReadCommitProtectionBehaviour(
+		bool protectEveryReadCommit, uint32_t mutexTimeout) {
+	this->protectEveryReadCommitCall = protectEveryReadCommit;
+	this->mutexTimeout = mutexTimeout;
+}
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 66a1924ce..3f52fcd0c 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -89,6 +89,7 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override;
+
 	/**
 	 * Provides the means to lock the underlying data structure to ensure
 	 * thread-safety. Default implementation is empty
@@ -114,6 +115,15 @@ public:
 	        SerializeIF::Endianness streamEndianness) override;
 
 protected:
+
+	/**
+	 * Can be used to individually protect every read and commit call.
+	 * @param protectEveryReadCommit
+	 * @param mutexTimeout
+	 */
+	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+			uint32_t mutexTimeout = 20);
+
 	/**
 	 * @brief	The fill_count attribute ensures that the variables
 	 * 			register in the correct array position and that the maximum
@@ -144,6 +154,9 @@ protected:
 	void setContainer(PoolVariableIF** variablesContainer);
 
 private:
+	bool protectEveryReadCommitCall = false;
+	uint32_t mutexTimeout = 20;
+
 	ReturnValue_t readVariable(uint16_t count);
 	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
 	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index dc81a6125..9ecad2183 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -8,7 +8,7 @@
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         uint32_t setId, PoolVariableIF** registeredVariablesArray,
-        const size_t maxNumberOfVariables, bool noPeriodicHandling):
+        const size_t maxNumberOfVariables, bool periodicHandling):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
     if(hkOwner == nullptr) {
         // Configuration error.
@@ -23,7 +23,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     mutex = MutexFactory::instance()->createMutex();
 
     // Data creators get a periodic helper for periodic HK data generation.
-    if(not noPeriodicHandling) {
+    if(periodicHandling) {
         periodicHelper = new PeriodicHousekeepingHelper(this);
     }
 }
@@ -278,3 +278,9 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     }
     this->valid = valid;
 }
+
+void LocalPoolDataSetBase::setReadCommitProtectionBehaviour(
+		bool protectEveryReadCommit, uint32_t mutexTimeout) {
+	PoolDataSetBase::setReadCommitProtectionBehaviour(protectEveryReadCommit,
+			mutexTimeout);
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index aa155bf1b..7eabd3689 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -54,7 +54,7 @@ public:
 	 */
 	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 			uint32_t setId, PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables, bool noPeriodicHandling = false);
+	        const size_t maxNumberOfVariables, bool periodicHandling = true);
 
 	/**
 	 * @brief	Constructor for users of local pool data.
@@ -77,6 +77,16 @@ public:
 	 */
 	~LocalPoolDataSetBase();
 
+	/**
+	 * If the data is pulled from different local data pools, every read and
+	 * commit call should be mutex protected for thread safety.
+	 * This can be specified with the second parameter.
+	 * @param dataCreator
+	 * @param protectEveryReadCommit
+	 */
+	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+			uint32_t mutexTimeout = 20);
+
 	void setValidityBufferGeneration(bool withValidityBuffer);
 
 	sid_t getSid() const;
@@ -128,6 +138,7 @@ public:
 
 protected:
 	sid_t sid;
+	uint32_t mutexTimeout = 20;
 	MutexIF* mutex = nullptr;
 
 	bool diagnostic = false;

From 639dbee8a342593f6b765b0efff09f69606d3563 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 00:21:39 +0100
Subject: [PATCH 1305/1774] form stuff

---
 datapoollocal/LocalPoolVariable.tpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index fb1296353..a685ea8d9 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -11,14 +11,14 @@ inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner,
+		lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
         LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 
 template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF *dataSet,
-		pool_rwm_t setReadWriteMode):
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
+		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
 				dataSet, setReadWriteMode){}
 

From 535b51ef7046b9e056371092737c07069dbb2ff1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 01:15:52 +0100
Subject: [PATCH 1306/1774] improvements and clarifications

---
 datapool/PoolDataSetBase.cpp         |  7 ++++++-
 datapool/PoolDataSetBase.h           | 15 ++++++++++-----
 datapoollocal/HasLocalDataPoolIF.h   |  3 +++
 datapoollocal/LocalDataPoolManager.h | 15 ++++++---------
 4 files changed, 25 insertions(+), 15 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index ad1de8e4d..63cbe73e5 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -35,12 +35,13 @@ ReturnValue_t PoolDataSetBase::registerVariable(
 
 ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	ReturnValue_t error = result;
 	if (state == States::STATE_SET_UNINITIALISED) {
 		lockDataPool(lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
 			result = readVariable(count);
 			if(result != RETURN_OK) {
-				break;
+				error = result;
 			}
 		}
 		state = States::STATE_SET_WAS_READ;
@@ -52,6 +53,10 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 				" member datasets!" << std::endl;
 		result = SET_WAS_ALREADY_READ;
 	}
+
+	if(error != HasReturnvaluesIF::RETURN_OK) {
+		result = error;
+	}
 	return result;
 }
 
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 3f52fcd0c..18715b1be 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -44,7 +44,11 @@ public:
 
 	/**
 	 * @brief	The read call initializes reading out all registered variables.
+	 * 			It is mandatory to call commit after every read call!
 	 * @details
+	 *
+	 * TODO: Write RAII helper so user can not forget to call commit anymore.
+	 *
 	 * It iterates through the list of registered variables and calls all read()
 	 * functions of the registered pool variables (which read out their values
 	 * from the data pool) which are not write-only.
@@ -52,13 +56,14 @@ public:
 	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
 	 *
 	 * The data pool is locked during the whole read operation and
-	 * freed afterwards.The state changes to "was written" after this operation.
+	 * freed afterwards. It is mandatory to call commit after a read call,
+	 * even if the read operation is not successful!
 	 * @return
 	 * - @c RETURN_OK if all variables were read successfully.
-	 * - @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
-	 * requested variable is invalid.
+	 * - @c INVALID_PARAMETER_DEFINITION if a pool entry does not exist or there
+	 *      is a type conflict.
 	 * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
-	 * commit() in between
+	 *      commit() in between
 	 */
 	virtual ReturnValue_t read(uint32_t lockTimeout =
 			MutexIF::BLOCKING) override;
@@ -75,7 +80,7 @@ public:
 	 * If the set does contain at least one variable which is not write-only
 	 * commit() can only be called after read(). If the set only contains
 	 * variables which are write only, commit() can be called without a
-	 * preceding read() call.
+	 * preceding read() call. Every read call must be followed by a commit call!
 	 * @return	- @c RETURN_OK if all variables were read successfully.
 	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
 	 * 			  contains non write-only variables
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 7f1f202e7..df8551101 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -44,6 +44,9 @@ public:
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 
+    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
+    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+
 	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
 	virtual object_id_t getObjectId() const = 0;
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c4024cf9e..cdefa2c29 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -55,14 +55,11 @@ class LocalDataPoolManager {
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
-    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x0);
 
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x02);
-
-    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x03);
-    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x04);
-    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x05);
+    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x01);
+    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x02);
+    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x03);
 
     /**
      * This constructor is used by a class which wants to implement
@@ -380,14 +377,14 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 	if (poolIter == localPoolMap.end()) {
 		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
 		        "not found." << std::endl;
-		return POOL_ENTRY_NOT_FOUND;
+		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
 		sif::debug << "HousekeepingManager::fetchPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return POOL_ENTRY_TYPE_CONFLICT;
+		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }

From f852c774f8e41a6ebf00b5cb6e5e24a815345837 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 01:52:48 +0100
Subject: [PATCH 1307/1774] accessor test

---
 datapool/PoolDataSetIF.h               |  6 ++--
 datapool/PoolVariableIF.h              | 40 ++-----------------------
 datapool/ReadCommitIF.h                | 31 +++++++++++++++++++
 datapoollocal/LocalDataPoolManager.cpp |  2 +-
 datapoollocal/PoolReadHelper.h         | 41 ++++++++++++++++++++++++++
 5 files changed, 78 insertions(+), 42 deletions(-)
 create mode 100644 datapool/ReadCommitIF.h
 create mode 100644 datapoollocal/PoolReadHelper.h

diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index aa45fa548..99c06cfd7 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -1,19 +1,17 @@
 #ifndef FSFW_DATAPOOL_POOLDATASETIF_H_
 #define FSFW_DATAPOOL_POOLDATASETIF_H_
 
+#include "ReadCommitIF.h"
 #include "DataSetIF.h"
 
 /**
  * @brief   Extendes the DataSetIF by adding abstract functions to lock
  *          and unlock a data pool and read/commit semantics.
  */
-class PoolDataSetIF: public DataSetIF {
+class PoolDataSetIF: public DataSetIF, public ReadCommitIF {
 public:
     virtual~ PoolDataSetIF() {};
 
-    virtual ReturnValue_t read(dur_millis_t lockTimeout) = 0;
-    virtual ReturnValue_t commit(dur_millis_t lockTimeout) = 0;
-
     /**
      * @brief   Most underlying data structures will have a pool like structure
      *          and will require a lock and unlock mechanism to ensure
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index cd15f7445..9740fc121 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -3,6 +3,7 @@
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
+#include "ReadCommitIF.h"
 
 /**
  * @brief	This interface is used to control data pool
@@ -17,9 +18,9 @@
  * @author 	Bastian Baetz
  * @ingroup data_pool
  */
-class PoolVariableIF : public SerializeIF {
+class PoolVariableIF : public SerializeIF,
+		public ReadCommitIF {
 	friend class PoolDataSetBase;
-	friend class GlobDataSet;
 	friend class LocalPoolDataSetBase;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
@@ -57,41 +58,6 @@ public:
 	 */
 	virtual void setValid(bool validity) = 0;
 
-	/**
-	 * @brief	The commit call shall write back a newly calculated local
-	 * 			value to the data pool.
-	 * @details
-	 * It is assumed that these calls are implemented in a thread-safe manner!
-	 */
-	virtual ReturnValue_t commit(uint32_t lockTimeout) = 0;
-	/**
-	 * @brief	The read call shall read the value of this parameter from
-	 * 			the data pool and store the content locally.
-	 * @details
-	 * It is assumbed that these calls are implemented in a thread-safe manner!
-	 */
-	virtual ReturnValue_t read(uint32_t lockTimeout) = 0;
-
-protected:
-
-	/**
-	 * @brief 	Same as commit with the difference that comitting will be
-	 * 			performed without a lock
-	 * @return
-	 * This can be used if the lock protection is handled externally
-	 * to avoid the overhead of locking and unlocking consecutively.
-	 * Declared protected to avoid free public usage.
-	 */
-	virtual ReturnValue_t readWithoutLock() = 0;
-	/**
-	 * @brief 	Same as commit with the difference that comitting will be
-	 * 			performed without a lock
-	 * @return
-	 * This can be used if the lock protection is handled externally
-	 * to avoid the overhead of locking and unlocking consecutively.
-	 * Declared protected to avoid free public usage.
-	 */
-	virtual ReturnValue_t commitWithoutLock() = 0;
 };
 
 using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h
new file mode 100644
index 000000000..0cdce3718
--- /dev/null
+++ b/datapool/ReadCommitIF.h
@@ -0,0 +1,31 @@
+#ifndef FSFW_DATAPOOL_READCOMMITIF_H_
+#define FSFW_DATAPOOL_READCOMMITIF_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+/**
+ * @brief 	Common interface for all software objects which employ read-commit
+ * 			semantics.
+ */
+class ReadCommitIF {
+public:
+	virtual ~ReadCommitIF() {}
+	virtual ReturnValue_t read(uint32_t mutexTimeout) = 0;
+	virtual ReturnValue_t commit(uint32_t mutexTimeout) = 0;
+
+protected:
+
+	//! Optional and protected because this is interesting for classes grouping
+	//! members with commit and read semantics where the lock is only necessary
+	//! once.
+	virtual ReturnValue_t readWithoutLock()  {
+		return read(20);
+	}
+
+	virtual ReturnValue_t commitWithoutLock() {
+		return commit(20);
+	}
+};
+
+
+#endif /* FSFW_DATAPOOL_READCOMMITIF_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f649a3623..5f0d15d3c 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -577,7 +577,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
     if (poolIter == localPoolMap.end()) {
         sif::debug << "HousekeepingManager::fechPoolEntry:"
                 << " Pool entry not found." << std::endl;
-        return POOL_ENTRY_NOT_FOUND;
+        return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
     poolIter->second->print();
     return HasReturnvaluesIF::RETURN_OK;
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
new file mode 100644
index 000000000..4fe506ee4
--- /dev/null
+++ b/datapoollocal/PoolReadHelper.h
@@ -0,0 +1,41 @@
+#ifndef FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
+#define FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
+
+#include <fsfw/datapoollocal/LocalPoolDataSetBase.h>
+#include <FSFWConfig.h>
+
+/**
+ * @brief 	Helper class to read data sets or pool variables
+ */
+class PoolReadHelper {
+public:
+	PoolReadHelper(ReadCommitIF* readObject, uint32_t mutexTimeout = 20):
+			readObject(readObject), mutexTimeout(mutexTimeout) {
+		if(readObject != nullptr) {
+			readResult = readObject->read(mutexTimeout);
+#if FSFW_PRINT_VERBOSITY_LEVEL == 1
+			sif::error << "PoolReadHelper: Read failed!" << std::endl;
+#endif
+		}
+	}
+
+	ReturnValue_t getReadResult() const {
+		return readResult;
+	}
+
+	~PoolReadHelper() {
+		if(readObject != nullptr) {
+			readObject->commit(mutexTimeout);
+		}
+
+	}
+
+private:
+	ReadCommitIF* readObject = nullptr;
+	ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+	uint32_t mutexTimeout = 20;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_ */

From 76403ce0aba4ae4b68d2011a40310f7573296d62 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 01:53:59 +0100
Subject: [PATCH 1308/1774] renaming

---
 datapoollocal/LocalDataPoolManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f649a3623..5f0d15d3c 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -577,7 +577,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
     if (poolIter == localPoolMap.end()) {
         sif::debug << "HousekeepingManager::fechPoolEntry:"
                 << " Pool entry not found." << std::endl;
-        return POOL_ENTRY_NOT_FOUND;
+        return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
     poolIter->second->print();
     return HasReturnvaluesIF::RETURN_OK;

From ed473d0a1bbd6bc80c3526eb2a02b8586bbfeec7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 02:04:45 +0100
Subject: [PATCH 1309/1774] bugfix

---
 datapoollocal/LocalPoolDataSetBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 7eabd3689..d9b6a2212 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -192,7 +192,7 @@ protected:
 	 */
 	ReturnValue_t unlockDataPool() override;
 
-	LocalDataPoolManager* hkManager;
+	LocalDataPoolManager* hkManager = nullptr;
 
 	/**
 	 * Set n-th bit of a byte, with n being the position from 0

From e24e50b5eea21840a1f74f451baffddc96637ae4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 12:58:05 +0100
Subject: [PATCH 1310/1774] removed todo

---
 datapool/PoolDataSetBase.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 18715b1be..7c1d84a41 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -46,9 +46,6 @@ public:
 	 * @brief	The read call initializes reading out all registered variables.
 	 * 			It is mandatory to call commit after every read call!
 	 * @details
-	 *
-	 * TODO: Write RAII helper so user can not forget to call commit anymore.
-	 *
 	 * It iterates through the list of registered variables and calls all read()
 	 * functions of the registered pool variables (which read out their values
 	 * from the data pool) which are not write-only.

From 39887db8d2b457aeb5edc0801c136d44e6d8258c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 12:59:25 +0100
Subject: [PATCH 1311/1774] removed newline

---
 datapool/PoolDataSetBase.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 63cbe73e5..8f0733594 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -10,7 +10,6 @@ PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
 PoolDataSetBase::~PoolDataSetBase() {}
 
 
-
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
 	if (state != States::STATE_SET_UNINITIALISED) {

From 37463b660b626133c53376fedfb98646a82b11be Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 14:14:38 +0100
Subject: [PATCH 1312/1774] restructured test folder and enabled cmake v3
 support

---
 unittest/CMakeLists.txt                          |  2 ++
 unittest/internal/CMakeLists.txt                 |  7 +++++++
 unittest/internal/osal/CMakeLists.txt            |  5 +++++
 unittest/internal/serialize/CMakeLists.txt       |  3 +++
 unittest/tests/CMakeLists.txt                    |  6 ++++++
 unittest/tests/action/CMakeLists.txt             |  3 +++
 unittest/tests/action/TestActionHelper.cpp       |  7 +++++--
 unittest/tests/action/TestActionHelper.h         |  2 +-
 unittest/tests/container/CMakeLists.txt          | 10 ++++++++++
 unittest/tests/container/RingBufferTest.cpp      |  6 +++---
 unittest/tests/container/TestArrayList.cpp       |  8 ++++----
 unittest/tests/container/TestDynamicFifo.cpp     | 11 +++++------
 unittest/tests/container/TestFifo.cpp            | 11 +++++------
 unittest/tests/container/TestFixedArrayList.cpp  |  9 ++++-----
 unittest/tests/container/TestFixedMap.cpp        |  8 ++++----
 .../tests/container/TestFixedOrderedMultimap.cpp |  8 ++++----
 unittest/tests/osal/CMakeLists.txt               |  4 ++++
 unittest/tests/osal/TestMessageQueue.cpp         | 10 ++++++----
 unittest/tests/serialize/CMakeLists.txt          |  5 +++++
 .../tests/serialize/TestSerialBufferAdapter.cpp  |  8 +++++---
 .../tests/serialize/TestSerialLinkedPacket.cpp   |  9 ++++++---
 .../tests/serialize/TestSerialLinkedPacket.h     |  2 +-
 unittest/tests/serialize/TestSerialization.cpp   | 16 +++++++++-------
 unittest/tests/storagemanager/CMakeLists.txt     |  4 ++++
 unittest/tests/storagemanager/TestPool.cpp       |  6 ++----
 unittest/user/CMakeLists.txt                     |  1 +
 unittest/user/testcfg/CMakeLists.txt             | 11 +++++++++++
 unittest/{ => user}/testcfg/FSFWConfig.h         |  0
 unittest/{ => user}/testcfg/Makefile-FSFW-Tests  |  0
 unittest/{ => user}/testcfg/TestsConfig.h        |  0
 .../testcfg/cdatapool/dataPoolInit.cpp           |  0
 .../{ => user}/testcfg/cdatapool/dataPoolInit.h  |  0
 .../testcfg/devices/logicalAddresses.cpp         |  0
 .../testcfg/devices/logicalAddresses.h           |  0
 .../testcfg/devices/powerSwitcherList.cpp        |  0
 .../testcfg/devices/powerSwitcherList.h          |  0
 .../testcfg/events/subsystemIdRanges.h           |  0
 .../testcfg/ipc/MissionMessageTypes.cpp          |  0
 .../{ => user}/testcfg/ipc/MissionMessageTypes.h |  0
 .../testcfg/objects/systemObjectList.h           |  0
 .../pollingsequence/PollingSequenceFactory.cpp   |  0
 .../pollingsequence/PollingSequenceFactory.h     |  0
 .../{ => user}/testcfg/returnvalues/classIds.h   |  0
 unittest/{ => user}/testcfg/testcfg.mk           |  0
 unittest/{ => user}/testcfg/tmtc/apid.h          |  0
 unittest/{ => user}/testcfg/tmtc/pusIds.h        |  0
 .../{ => user}/testtemplate/TestTemplate.cpp     |  0
 unittest/user/unittest/core/CMakeLists.txt       |  7 +++++++
 .../unittest}/core/CatchDefinitions.cpp          |  0
 .../{ => user/unittest}/core/CatchDefinitions.h  |  0
 .../{ => user/unittest}/core/CatchFactory.cpp    |  0
 unittest/{ => user/unittest}/core/CatchFactory.h |  0
 .../{ => user/unittest}/core/CatchRunner.cpp     |  0
 unittest/{ => user/unittest}/core/CatchSetup.cpp |  0
 unittest/{ => user/unittest}/core/core.mk        |  0
 unittest/{ => user/unittest}/core/printChar.cpp  |  0
 unittest/{ => user/unittest}/core/printChar.h    |  0
 unittest/{ => user}/unlockRealtime.sh            |  0
 58 files changed, 132 insertions(+), 57 deletions(-)
 create mode 100644 unittest/CMakeLists.txt
 create mode 100644 unittest/internal/CMakeLists.txt
 create mode 100644 unittest/internal/osal/CMakeLists.txt
 create mode 100644 unittest/internal/serialize/CMakeLists.txt
 create mode 100644 unittest/tests/CMakeLists.txt
 create mode 100644 unittest/tests/action/CMakeLists.txt
 create mode 100644 unittest/tests/container/CMakeLists.txt
 create mode 100644 unittest/tests/osal/CMakeLists.txt
 create mode 100644 unittest/tests/serialize/CMakeLists.txt
 create mode 100644 unittest/tests/storagemanager/CMakeLists.txt
 create mode 100644 unittest/user/CMakeLists.txt
 create mode 100644 unittest/user/testcfg/CMakeLists.txt
 rename unittest/{ => user}/testcfg/FSFWConfig.h (100%)
 rename unittest/{ => user}/testcfg/Makefile-FSFW-Tests (100%)
 rename unittest/{ => user}/testcfg/TestsConfig.h (100%)
 rename unittest/{ => user}/testcfg/cdatapool/dataPoolInit.cpp (100%)
 rename unittest/{ => user}/testcfg/cdatapool/dataPoolInit.h (100%)
 rename unittest/{ => user}/testcfg/devices/logicalAddresses.cpp (100%)
 rename unittest/{ => user}/testcfg/devices/logicalAddresses.h (100%)
 rename unittest/{ => user}/testcfg/devices/powerSwitcherList.cpp (100%)
 rename unittest/{ => user}/testcfg/devices/powerSwitcherList.h (100%)
 rename unittest/{ => user}/testcfg/events/subsystemIdRanges.h (100%)
 rename unittest/{ => user}/testcfg/ipc/MissionMessageTypes.cpp (100%)
 rename unittest/{ => user}/testcfg/ipc/MissionMessageTypes.h (100%)
 rename unittest/{ => user}/testcfg/objects/systemObjectList.h (100%)
 rename unittest/{ => user}/testcfg/pollingsequence/PollingSequenceFactory.cpp (100%)
 rename unittest/{ => user}/testcfg/pollingsequence/PollingSequenceFactory.h (100%)
 rename unittest/{ => user}/testcfg/returnvalues/classIds.h (100%)
 rename unittest/{ => user}/testcfg/testcfg.mk (100%)
 rename unittest/{ => user}/testcfg/tmtc/apid.h (100%)
 rename unittest/{ => user}/testcfg/tmtc/pusIds.h (100%)
 rename unittest/{ => user}/testtemplate/TestTemplate.cpp (100%)
 create mode 100644 unittest/user/unittest/core/CMakeLists.txt
 rename unittest/{ => user/unittest}/core/CatchDefinitions.cpp (100%)
 rename unittest/{ => user/unittest}/core/CatchDefinitions.h (100%)
 rename unittest/{ => user/unittest}/core/CatchFactory.cpp (100%)
 rename unittest/{ => user/unittest}/core/CatchFactory.h (100%)
 rename unittest/{ => user/unittest}/core/CatchRunner.cpp (100%)
 rename unittest/{ => user/unittest}/core/CatchSetup.cpp (100%)
 rename unittest/{ => user/unittest}/core/core.mk (100%)
 rename unittest/{ => user/unittest}/core/printChar.cpp (100%)
 rename unittest/{ => user/unittest}/core/printChar.h (100%)
 rename unittest/{ => user}/unlockRealtime.sh (100%)

diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt
new file mode 100644
index 000000000..119ef243a
--- /dev/null
+++ b/unittest/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_subdirectory(internal)
+add_subdirectory(tests)
\ No newline at end of file
diff --git a/unittest/internal/CMakeLists.txt b/unittest/internal/CMakeLists.txt
new file mode 100644
index 000000000..9c24317f5
--- /dev/null
+++ b/unittest/internal/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${TARGET_NAME} PRIVATE
+	InternalUnitTester.cpp
+	UnittDefinitions.cpp
+)
+
+add_subdirectory(osal)
+add_subdirectory(serialize)
\ No newline at end of file
diff --git a/unittest/internal/osal/CMakeLists.txt b/unittest/internal/osal/CMakeLists.txt
new file mode 100644
index 000000000..c6f1eb95c
--- /dev/null
+++ b/unittest/internal/osal/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${TARGET_NAME} PRIVATE
+	IntTestMq.cpp
+	IntTestMutex.cpp
+	IntTestSemaphore.cpp
+)
diff --git a/unittest/internal/serialize/CMakeLists.txt b/unittest/internal/serialize/CMakeLists.txt
new file mode 100644
index 000000000..e8dc5717f
--- /dev/null
+++ b/unittest/internal/serialize/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(${TARGET_NAME} PRIVATE
+	IntTestSerialization.cpp
+)
diff --git a/unittest/tests/CMakeLists.txt b/unittest/tests/CMakeLists.txt
new file mode 100644
index 000000000..970744174
--- /dev/null
+++ b/unittest/tests/CMakeLists.txt
@@ -0,0 +1,6 @@
+add_subdirectory(action)
+add_subdirectory(container)
+add_subdirectory(osal)
+add_subdirectory(serialize)
+add_subdirectory(storagemanager)
+
diff --git a/unittest/tests/action/CMakeLists.txt b/unittest/tests/action/CMakeLists.txt
new file mode 100644
index 000000000..0339000f3
--- /dev/null
+++ b/unittest/tests/action/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(${TARGET_NAME} PRIVATE
+	TestActionHelper.cpp
+)
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index 944ad7059..3109eba1a 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -1,8 +1,11 @@
 #include "TestActionHelper.h"
+
+#include <unittest/core/CatchDefinitions.h>
+
 #include <fsfw/action/ActionHelper.h>
 #include <fsfw/ipc/CommandMessage.h>
-#include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
+
+#include <catch2/catch_test_macros.hpp>
 
 
 TEST_CASE( "Action Helper" , "[ActionHelper]") {
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
index 4ba417eb1..610fb09ea 100644
--- a/unittest/tests/action/TestActionHelper.h
+++ b/unittest/tests/action/TestActionHelper.h
@@ -3,7 +3,7 @@
 
 #include <fsfw/action/HasActionsIF.h>
 #include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <unittest/core/CatchDefinitions.h>
 #include <cstring>
 
 
diff --git a/unittest/tests/container/CMakeLists.txt b/unittest/tests/container/CMakeLists.txt
new file mode 100644
index 000000000..966c58346
--- /dev/null
+++ b/unittest/tests/container/CMakeLists.txt
@@ -0,0 +1,10 @@
+target_sources(${TARGET_NAME} PRIVATE
+	RingBufferTest.cpp
+	TestArrayList.cpp
+	TestDynamicFifo.cpp
+	TestFifo.cpp
+	TestFixedArrayList.cpp
+	TestFixedMap.cpp
+	TestFixedOrderedMultimap.cpp
+	TestPlacementFactory.cpp
+)
diff --git a/unittest/tests/container/RingBufferTest.cpp b/unittest/tests/container/RingBufferTest.cpp
index 9c1c8a23b..32a2502d0 100644
--- a/unittest/tests/container/RingBufferTest.cpp
+++ b/unittest/tests/container/RingBufferTest.cpp
@@ -1,7 +1,7 @@
-#include "../../core/CatchDefinitions.h"
-#include "../../container/SimpleRingBuffer.h"
+#include <unittest/core/CatchDefinitions.h>
+#include <fsfw/container/SimpleRingBuffer.h>
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 #include <cstring>
 
 TEST_CASE("Ring Buffer Test" , "[RingBufferTest]") {
diff --git a/unittest/tests/container/TestArrayList.cpp b/unittest/tests/container/TestArrayList.cpp
index 2f8842764..1fd330b67 100644
--- a/unittest/tests/container/TestArrayList.cpp
+++ b/unittest/tests/container/TestArrayList.cpp
@@ -1,8 +1,8 @@
-#include "../../container/ArrayList.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <fsfw/container/ArrayList.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
-#include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 /**
  * @brief 	Array List test
diff --git a/unittest/tests/container/TestDynamicFifo.cpp b/unittest/tests/container/TestDynamicFifo.cpp
index bb19131eb..759fcc66b 100644
--- a/unittest/tests/container/TestDynamicFifo.cpp
+++ b/unittest/tests/container/TestDynamicFifo.cpp
@@ -1,10 +1,9 @@
+#include "../../../container/DynamicFIFO.h"
+#include "../../../container/FIFO.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 
-#include "../../container/DynamicFIFO.h"
-#include "../../container/FIFO.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-#include <catch.hpp>
-#include <CatchDefinitions.h>
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE( "Dynamic Fifo Tests", "[TestDynamicFifo]") {
 	INFO("Dynamic Fifo Tests");
diff --git a/unittest/tests/container/TestFifo.cpp b/unittest/tests/container/TestFifo.cpp
index bd727e00c..f7bfb1de4 100644
--- a/unittest/tests/container/TestFifo.cpp
+++ b/unittest/tests/container/TestFifo.cpp
@@ -1,10 +1,9 @@
+#include "../../../container/DynamicFIFO.h"
+#include "../../../container/FIFO.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 
-#include "../../container/DynamicFIFO.h"
-#include "../../container/FIFO.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-#include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE( "Static Fifo Tests", "[TestFifo]") {
 	INFO("Fifo Tests");
diff --git a/unittest/tests/container/TestFixedArrayList.cpp b/unittest/tests/container/TestFixedArrayList.cpp
index 5a1bd280a..b2baa3e76 100644
--- a/unittest/tests/container/TestFixedArrayList.cpp
+++ b/unittest/tests/container/TestFixedArrayList.cpp
@@ -1,9 +1,8 @@
-#include "../../core/CatchDefinitions.h"
+#include "../../../container/FixedArrayList.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 
-#include "../../container/FixedArrayList.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 
 TEST_CASE( "FixedArrayList Tests", "[TestFixedArrayList]") {
diff --git a/unittest/tests/container/TestFixedMap.cpp b/unittest/tests/container/TestFixedMap.cpp
index da0c84e3e..f93065b6e 100644
--- a/unittest/tests/container/TestFixedMap.cpp
+++ b/unittest/tests/container/TestFixedMap.cpp
@@ -1,8 +1,8 @@
-#include "../../container/FixedMap.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../../container/FixedMap.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 
-#include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 template class FixedMap<unsigned int, unsigned short>;
 
diff --git a/unittest/tests/container/TestFixedOrderedMultimap.cpp b/unittest/tests/container/TestFixedOrderedMultimap.cpp
index e625b5599..b337a9c8d 100644
--- a/unittest/tests/container/TestFixedOrderedMultimap.cpp
+++ b/unittest/tests/container/TestFixedOrderedMultimap.cpp
@@ -1,8 +1,8 @@
-#include "../../container/FixedOrderedMultimap.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../../container/FixedOrderedMultimap.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 
-#include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE( "FixedOrderedMultimap Tests", "[TestFixedOrderedMultimap]") {
 	INFO("FixedOrderedMultimap Tests");
diff --git a/unittest/tests/osal/CMakeLists.txt b/unittest/tests/osal/CMakeLists.txt
new file mode 100644
index 000000000..5ca5e4005
--- /dev/null
+++ b/unittest/tests/osal/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${TARGET_NAME} PRIVATE
+	TestMessageQueue.cpp
+	TestSemaphore.cpp
+)
diff --git a/unittest/tests/osal/TestMessageQueue.cpp b/unittest/tests/osal/TestMessageQueue.cpp
index 441d32e7d..5360974f6 100644
--- a/unittest/tests/osal/TestMessageQueue.cpp
+++ b/unittest/tests/osal/TestMessageQueue.cpp
@@ -1,8 +1,10 @@
-#include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/QueueFactory.h"
-#include <catch.hpp>
+#include "../../../ipc/MessageQueueIF.h"
+#include "../../../ipc/QueueFactory.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+
 #include <array>
-#include "../../core/CatchDefinitions.h"
 
 TEST_CASE("MessageQueue Basic Test","[TestMq]") {
 	MessageQueueIF* testSenderMq =
diff --git a/unittest/tests/serialize/CMakeLists.txt b/unittest/tests/serialize/CMakeLists.txt
new file mode 100644
index 000000000..5a9d9a0f2
--- /dev/null
+++ b/unittest/tests/serialize/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${TARGET_NAME} PRIVATE
+	TestSerialBufferAdapter.cpp
+	TestSerialization.cpp
+	TestSerialLinkedPacket.cpp
+)
diff --git a/unittest/tests/serialize/TestSerialBufferAdapter.cpp b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
index 07cd3f9c5..778f857ed 100644
--- a/unittest/tests/serialize/TestSerialBufferAdapter.cpp
+++ b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
@@ -1,7 +1,9 @@
-#include "../../serialize/SerialBufferAdapter.h"
+#include "../../../serialize/SerialBufferAdapter.h"
 
-#include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+
+#include <array>
 
 
 static bool test_value_bool = true;
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.cpp b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
index fbe488946..83bdf8578 100644
--- a/unittest/tests/serialize/TestSerialLinkedPacket.cpp
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
@@ -1,9 +1,12 @@
 #include "TestSerialLinkedPacket.h"
-#include "../../core/CatchDefinitions.h"
+#include <unittest/core/CatchDefinitions.h>
 
-#include "../../globalfunctions/arrayprinter.h"
+#include "../../../globalfunctions/arrayprinter.h"
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+
+#include <array>
 
 
 TEST_CASE("Serial Linked Packet" , "[SerLinkPacket]") {
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.h b/unittest/tests/serialize/TestSerialLinkedPacket.h
index 6c720577b..71f258f9a 100644
--- a/unittest/tests/serialize/TestSerialLinkedPacket.h
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.h
@@ -37,7 +37,7 @@ public:
 		return buffer.entry.getConstBuffer();
 	}
 
-	const size_t getBufferLength() {
+	size_t getBufferLength() {
 		return buffer.getSerializedSize();
 	}
 
diff --git a/unittest/tests/serialize/TestSerialization.cpp b/unittest/tests/serialize/TestSerialization.cpp
index 6e31170a1..2877d09ab 100644
--- a/unittest/tests/serialize/TestSerialization.cpp
+++ b/unittest/tests/serialize/TestSerialization.cpp
@@ -1,8 +1,10 @@
-#include "../../serialize/SerializeAdapter.h"
+#include "../../../serialize/SerializeAdapter.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_approx.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
-#include "catch.hpp"
 #include <array>
-#include "../../core/CatchDefinitions.h"
 
 static bool test_value_bool = true;
 static uint8_t tv_uint8   {5};
@@ -119,10 +121,10 @@ TEST_CASE("Auto Serialize Adapter testing", "[single-file]") {
 		REQUIRE(tv_int16 == -829);
 		REQUIRE(tv_int32 == -2312);
 
-		REQUIRE(tv_float == Approx(8.214921));
-		REQUIRE(tv_double == Approx(9.2132142141e8));
-		REQUIRE(tv_sfloat == Approx(-922.2321321));
-		REQUIRE(tv_sdouble == Approx(-2.2421e19));
+		REQUIRE(tv_float == Catch::Approx(8.214921));
+		REQUIRE(tv_double == Catch::Approx(9.2132142141e8));
+		REQUIRE(tv_sfloat == Catch::Approx(-922.2321321));
+		REQUIRE(tv_sdouble == Catch::Approx(-2.2421e19));
 	}
 }
 
diff --git a/unittest/tests/storagemanager/CMakeLists.txt b/unittest/tests/storagemanager/CMakeLists.txt
new file mode 100644
index 000000000..ed7be7d5c
--- /dev/null
+++ b/unittest/tests/storagemanager/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${TARGET_NAME} PRIVATE
+	TestNewAccessor.cpp
+	TestPool.cpp
+)
diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
index daeb6bb52..dcfb6c035 100644
--- a/unittest/tests/storagemanager/TestPool.cpp
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -1,10 +1,8 @@
-#include "CatchDefinitions.h"
-
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/storagemanager/LocalPool.h>
 
-#include <catch.hpp>
-#include <CatchDefinitions.h>
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 #include <cstring>
 
diff --git a/unittest/user/CMakeLists.txt b/unittest/user/CMakeLists.txt
new file mode 100644
index 000000000..ad6d4787c
--- /dev/null
+++ b/unittest/user/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(core)
diff --git a/unittest/user/testcfg/CMakeLists.txt b/unittest/user/testcfg/CMakeLists.txt
new file mode 100644
index 000000000..dbf0256fa
--- /dev/null
+++ b/unittest/user/testcfg/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${TARGET_NAME} 
+	PRIVATE
+		ipc/MissionMessageTypes.cpp
+		pollingsequence/PollingSequenceFactory.cpp
+)
+
+# Add include paths for the executable
+target_include_directories(${TARGET_NAME} 
+	PUBLIC 
+		${CMAKE_CURRENT_SOURCE_DIR}
+)
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/user/testcfg/FSFWConfig.h
similarity index 100%
rename from unittest/testcfg/FSFWConfig.h
rename to unittest/user/testcfg/FSFWConfig.h
diff --git a/unittest/testcfg/Makefile-FSFW-Tests b/unittest/user/testcfg/Makefile-FSFW-Tests
similarity index 100%
rename from unittest/testcfg/Makefile-FSFW-Tests
rename to unittest/user/testcfg/Makefile-FSFW-Tests
diff --git a/unittest/testcfg/TestsConfig.h b/unittest/user/testcfg/TestsConfig.h
similarity index 100%
rename from unittest/testcfg/TestsConfig.h
rename to unittest/user/testcfg/TestsConfig.h
diff --git a/unittest/testcfg/cdatapool/dataPoolInit.cpp b/unittest/user/testcfg/cdatapool/dataPoolInit.cpp
similarity index 100%
rename from unittest/testcfg/cdatapool/dataPoolInit.cpp
rename to unittest/user/testcfg/cdatapool/dataPoolInit.cpp
diff --git a/unittest/testcfg/cdatapool/dataPoolInit.h b/unittest/user/testcfg/cdatapool/dataPoolInit.h
similarity index 100%
rename from unittest/testcfg/cdatapool/dataPoolInit.h
rename to unittest/user/testcfg/cdatapool/dataPoolInit.h
diff --git a/unittest/testcfg/devices/logicalAddresses.cpp b/unittest/user/testcfg/devices/logicalAddresses.cpp
similarity index 100%
rename from unittest/testcfg/devices/logicalAddresses.cpp
rename to unittest/user/testcfg/devices/logicalAddresses.cpp
diff --git a/unittest/testcfg/devices/logicalAddresses.h b/unittest/user/testcfg/devices/logicalAddresses.h
similarity index 100%
rename from unittest/testcfg/devices/logicalAddresses.h
rename to unittest/user/testcfg/devices/logicalAddresses.h
diff --git a/unittest/testcfg/devices/powerSwitcherList.cpp b/unittest/user/testcfg/devices/powerSwitcherList.cpp
similarity index 100%
rename from unittest/testcfg/devices/powerSwitcherList.cpp
rename to unittest/user/testcfg/devices/powerSwitcherList.cpp
diff --git a/unittest/testcfg/devices/powerSwitcherList.h b/unittest/user/testcfg/devices/powerSwitcherList.h
similarity index 100%
rename from unittest/testcfg/devices/powerSwitcherList.h
rename to unittest/user/testcfg/devices/powerSwitcherList.h
diff --git a/unittest/testcfg/events/subsystemIdRanges.h b/unittest/user/testcfg/events/subsystemIdRanges.h
similarity index 100%
rename from unittest/testcfg/events/subsystemIdRanges.h
rename to unittest/user/testcfg/events/subsystemIdRanges.h
diff --git a/unittest/testcfg/ipc/MissionMessageTypes.cpp b/unittest/user/testcfg/ipc/MissionMessageTypes.cpp
similarity index 100%
rename from unittest/testcfg/ipc/MissionMessageTypes.cpp
rename to unittest/user/testcfg/ipc/MissionMessageTypes.cpp
diff --git a/unittest/testcfg/ipc/MissionMessageTypes.h b/unittest/user/testcfg/ipc/MissionMessageTypes.h
similarity index 100%
rename from unittest/testcfg/ipc/MissionMessageTypes.h
rename to unittest/user/testcfg/ipc/MissionMessageTypes.h
diff --git a/unittest/testcfg/objects/systemObjectList.h b/unittest/user/testcfg/objects/systemObjectList.h
similarity index 100%
rename from unittest/testcfg/objects/systemObjectList.h
rename to unittest/user/testcfg/objects/systemObjectList.h
diff --git a/unittest/testcfg/pollingsequence/PollingSequenceFactory.cpp b/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
similarity index 100%
rename from unittest/testcfg/pollingsequence/PollingSequenceFactory.cpp
rename to unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
diff --git a/unittest/testcfg/pollingsequence/PollingSequenceFactory.h b/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.h
similarity index 100%
rename from unittest/testcfg/pollingsequence/PollingSequenceFactory.h
rename to unittest/user/testcfg/pollingsequence/PollingSequenceFactory.h
diff --git a/unittest/testcfg/returnvalues/classIds.h b/unittest/user/testcfg/returnvalues/classIds.h
similarity index 100%
rename from unittest/testcfg/returnvalues/classIds.h
rename to unittest/user/testcfg/returnvalues/classIds.h
diff --git a/unittest/testcfg/testcfg.mk b/unittest/user/testcfg/testcfg.mk
similarity index 100%
rename from unittest/testcfg/testcfg.mk
rename to unittest/user/testcfg/testcfg.mk
diff --git a/unittest/testcfg/tmtc/apid.h b/unittest/user/testcfg/tmtc/apid.h
similarity index 100%
rename from unittest/testcfg/tmtc/apid.h
rename to unittest/user/testcfg/tmtc/apid.h
diff --git a/unittest/testcfg/tmtc/pusIds.h b/unittest/user/testcfg/tmtc/pusIds.h
similarity index 100%
rename from unittest/testcfg/tmtc/pusIds.h
rename to unittest/user/testcfg/tmtc/pusIds.h
diff --git a/unittest/testtemplate/TestTemplate.cpp b/unittest/user/testtemplate/TestTemplate.cpp
similarity index 100%
rename from unittest/testtemplate/TestTemplate.cpp
rename to unittest/user/testtemplate/TestTemplate.cpp
diff --git a/unittest/user/unittest/core/CMakeLists.txt b/unittest/user/unittest/core/CMakeLists.txt
new file mode 100644
index 000000000..d78f45f18
--- /dev/null
+++ b/unittest/user/unittest/core/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${TARGET_NAME} PRIVATE
+	CatchDefinitions.cpp
+	CatchFactory.cpp
+	CatchRunner.cpp
+	CatchSetup.cpp
+	printChar.cpp
+)
diff --git a/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
similarity index 100%
rename from unittest/core/CatchDefinitions.cpp
rename to unittest/user/unittest/core/CatchDefinitions.cpp
diff --git a/unittest/core/CatchDefinitions.h b/unittest/user/unittest/core/CatchDefinitions.h
similarity index 100%
rename from unittest/core/CatchDefinitions.h
rename to unittest/user/unittest/core/CatchDefinitions.h
diff --git a/unittest/core/CatchFactory.cpp b/unittest/user/unittest/core/CatchFactory.cpp
similarity index 100%
rename from unittest/core/CatchFactory.cpp
rename to unittest/user/unittest/core/CatchFactory.cpp
diff --git a/unittest/core/CatchFactory.h b/unittest/user/unittest/core/CatchFactory.h
similarity index 100%
rename from unittest/core/CatchFactory.h
rename to unittest/user/unittest/core/CatchFactory.h
diff --git a/unittest/core/CatchRunner.cpp b/unittest/user/unittest/core/CatchRunner.cpp
similarity index 100%
rename from unittest/core/CatchRunner.cpp
rename to unittest/user/unittest/core/CatchRunner.cpp
diff --git a/unittest/core/CatchSetup.cpp b/unittest/user/unittest/core/CatchSetup.cpp
similarity index 100%
rename from unittest/core/CatchSetup.cpp
rename to unittest/user/unittest/core/CatchSetup.cpp
diff --git a/unittest/core/core.mk b/unittest/user/unittest/core/core.mk
similarity index 100%
rename from unittest/core/core.mk
rename to unittest/user/unittest/core/core.mk
diff --git a/unittest/core/printChar.cpp b/unittest/user/unittest/core/printChar.cpp
similarity index 100%
rename from unittest/core/printChar.cpp
rename to unittest/user/unittest/core/printChar.cpp
diff --git a/unittest/core/printChar.h b/unittest/user/unittest/core/printChar.h
similarity index 100%
rename from unittest/core/printChar.h
rename to unittest/user/unittest/core/printChar.h
diff --git a/unittest/unlockRealtime.sh b/unittest/user/unlockRealtime.sh
similarity index 100%
rename from unittest/unlockRealtime.sh
rename to unittest/user/unlockRealtime.sh

From d8d2f207e172ec8fd4f20104112f38fe176231b9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 14:20:26 +0100
Subject: [PATCH 1313/1774] cleaned up includes

---
 unittest/tests/container/TestDynamicFifo.cpp         | 6 +++---
 unittest/tests/container/TestFifo.cpp                | 6 +++---
 unittest/tests/container/TestFixedMap.cpp            | 4 ++--
 unittest/tests/osal/TestMessageQueue.cpp             | 4 ++--
 unittest/tests/serialize/TestSerialBufferAdapter.cpp | 2 +-
 unittest/tests/serialize/TestSerialLinkedPacket.cpp  | 2 +-
 unittest/tests/serialize/TestSerialization.cpp       | 2 +-
 7 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/unittest/tests/container/TestDynamicFifo.cpp b/unittest/tests/container/TestDynamicFifo.cpp
index 759fcc66b..2b572d520 100644
--- a/unittest/tests/container/TestDynamicFifo.cpp
+++ b/unittest/tests/container/TestDynamicFifo.cpp
@@ -1,6 +1,6 @@
-#include "../../../container/DynamicFIFO.h"
-#include "../../../container/FIFO.h"
-#include "../../../returnvalues/HasReturnvaluesIF.h"
+#include <fsfw/container/DynamicFIFO.h>
+#include <fsfw/container/FIFO.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/container/TestFifo.cpp b/unittest/tests/container/TestFifo.cpp
index f7bfb1de4..fbcd40cc6 100644
--- a/unittest/tests/container/TestFifo.cpp
+++ b/unittest/tests/container/TestFifo.cpp
@@ -1,6 +1,6 @@
-#include "../../../container/DynamicFIFO.h"
-#include "../../../container/FIFO.h"
-#include "../../../returnvalues/HasReturnvaluesIF.h"
+#include <fsfw/container/DynamicFIFO.h>
+#include <fsfw/container/FIFO.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/container/TestFixedMap.cpp b/unittest/tests/container/TestFixedMap.cpp
index f93065b6e..297171ca0 100644
--- a/unittest/tests/container/TestFixedMap.cpp
+++ b/unittest/tests/container/TestFixedMap.cpp
@@ -1,5 +1,5 @@
-#include "../../../container/FixedMap.h"
-#include "../../../returnvalues/HasReturnvaluesIF.h"
+#include <fsfw/container/FixedMap.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/osal/TestMessageQueue.cpp b/unittest/tests/osal/TestMessageQueue.cpp
index 5360974f6..e33b72404 100644
--- a/unittest/tests/osal/TestMessageQueue.cpp
+++ b/unittest/tests/osal/TestMessageQueue.cpp
@@ -1,5 +1,5 @@
-#include "../../../ipc/MessageQueueIF.h"
-#include "../../../ipc/QueueFactory.h"
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/serialize/TestSerialBufferAdapter.cpp b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
index 778f857ed..1938746d7 100644
--- a/unittest/tests/serialize/TestSerialBufferAdapter.cpp
+++ b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
@@ -1,4 +1,4 @@
-#include "../../../serialize/SerialBufferAdapter.h"
+#include <fsfw/serialize/SerialBufferAdapter.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.cpp b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
index 83bdf8578..b90ae9f86 100644
--- a/unittest/tests/serialize/TestSerialLinkedPacket.cpp
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
@@ -1,7 +1,7 @@
 #include "TestSerialLinkedPacket.h"
 #include <unittest/core/CatchDefinitions.h>
 
-#include "../../../globalfunctions/arrayprinter.h"
+#include <fsfw/globalfunctions/arrayprinter.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/serialize/TestSerialization.cpp b/unittest/tests/serialize/TestSerialization.cpp
index 2877d09ab..3de581ec9 100644
--- a/unittest/tests/serialize/TestSerialization.cpp
+++ b/unittest/tests/serialize/TestSerialization.cpp
@@ -1,4 +1,4 @@
-#include "../../../serialize/SerializeAdapter.h"
+#include <fsfw/serialize/SerializeAdapter.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/catch_approx.hpp>

From f60f02c5b84033a63b94b80925ed2f8e1a64953d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 14:53:37 +0100
Subject: [PATCH 1314/1774] updated readme

---
 unittest/README.md           |  62 +++----------
 unittest/user/CMakeLists.txt | 166 ++++++++++++++++++++++++++++++++++-
 2 files changed, 176 insertions(+), 52 deletions(-)

diff --git a/unittest/README.md b/unittest/README.md
index 8a787c07a..d6a4bb85a 100644
--- a/unittest/README.md
+++ b/unittest/README.md
@@ -1,59 +1,19 @@
 ## FSFW Testing
-This repository contains testing and unit testing components.
 
-[Catch2](https://github.com/catchorg/Catch2) has been used as a framework,
-and these unit tests can only be run on a linux host machine.
-The makefile with default settings creates the unit test binary which can be
-run in the terminal or in eclipse.
+This folder contains testing and unit testing components.
 
 ### Instructions
 
-To run the fsfw unittests in the project, perform following steps:
+The easiest way to run the unittest contained in this folder is to follow
+the steps in the [test repository](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_tests).
+This is recommended even if the goal is to set up a custom test repository to have
+a starting point.
 
-1. Copy the testcfg folder  the project root (folder containing the FSFW).
-2. There is a makefile inside the testcfg folder which can be used to have 
-   a starting point to compile the unit tests. Copy that Makefile to the project
-   root
-3. Create a folder named catch2 (can have other name which requires Makefile 
-   adaption) and copy the Catch2 header files there (NOTE: CMake support
-   not enabled yet!)
+To set up a custom test repository or project, following steps can be performed:
+
+1. Copy the user folder content into the project root.
+2. Clone [Catch2](https://github.com/catchorg/Catch2) in the project root.
+3. Use the `CMakeLists.txt` as a starting point to add tests and build the test
+   executable.
    
-### Eclipse CDT settings
-
-The default eclipse terminal has issues displaying the colors used
-when running the unit test binary by catch2. To fix this issue,
-install the ANSI Escape In Console package from the eclipse marketplace.
-
-### GCOV integration
-
-GCOV has been integrated as a code coverage tool.
-It can be enabled by adding `GCOV=1` to the build process as an additional argument.
-Coverage data will be provided in form of .gcno and .gcda files.
-These can be displayed in eclipse by looking
-for a .gcno or .gcda file in the \_obj folder, double-clicking it
-and picking the right source-binary. This will generate 
-information about which lines of a file have run, provided it is open in 
-eclipse.
-
-### LCOV integration
-
-The files generated by GCOV can also be processed by the tool LCOV.
-On ubuntu, the tool can be installed with the following command:
-
-```sh 
-sudo apt-get install lcov
-```` 
-
-After that, the tool can be run by building the unit tests with `GCOV=1`,
-running them at least one time and then executing the `lcov.sh` script.
-
-### Adding unit tests
-
-The catch unit tests are located in unittest/testfw. To add new unit tests,
-add them to the UnitTestCatch.cpp file or add a new source file which
-includes catch.hpp.
-
-For writing basics tests, the [assertion documentation](https://github.com/catchorg/Catch2/blob/master/docs/assertions.md#top)
-or the existing examples are a good guideliens.
-For more advanced tests, refer to the [catch2 documentation](https://github.com/catchorg/Catch2/blob/master/docs/Readme.md#top).
 
diff --git a/unittest/user/CMakeLists.txt b/unittest/user/CMakeLists.txt
index ad6d4787c..6ec314c3b 100644
--- a/unittest/user/CMakeLists.txt
+++ b/unittest/user/CMakeLists.txt
@@ -1 +1,165 @@
-add_subdirectory(core)
+################################################################################
+# CMake support for the Flight Software Framework Tests
+# 
+# Developed in an effort to replace Make with a modern build system.
+# 
+# Author: R. Mueller
+################################################################################
+
+################################################################################
+# Pre-Project preparation
+################################################################################
+cmake_minimum_required(VERSION 3.13)
+
+# set(CMAKE_VERBOSE TRUE)
+
+set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/buildsystem/cmake")
+
+# Tests can be built with the Host OSAL or with the Linux OSAL.
+if(NOT OS_FSFW)
+	set(OS_FSFW host CACHE STRING "OS for the FSFW.")
+endif()
+
+option(CUSTOM_UNITTEST_RUNNER 
+	"Specify whether custom main or Catch2 main is used" TRUE
+)
+
+# Perform steps like loading toolchain files where applicable.
+#include(${CMAKE_SCRIPT_PATH}/PreProjectConfig.cmake)
+#pre_project_config()
+
+# Project Name
+project(fsfw_tests C CXX)
+
+################################################################################
+# Pre-Sources preparation
+################################################################################
+
+# Specify the C++ standard
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+# Set names and variables
+set(TARGET_NAME ${CMAKE_PROJECT_NAME}) 
+if(CUSTOM_UNITTEST_RUNNER)
+	set(CATCH2_TARGET Catch2)
+else()
+	set(CATCH2_TARGET Catch2WithMain)
+endif()
+set(LIB_FSFW_NAME fsfw)
+
+# Set path names
+set(FSFW_PATH fsfw)
+set(CATCH2_PATH Catch2)
+set(FSFW_TESTS_PATH fsfw/unittest)
+set(TEST_SETUP_PATH unittest)
+
+# Analyse different OS and architecture/target options and
+# determine BSP_PATH
+
+# FreeRTOS
+if(${OS_FSFW} STREQUAL linux)
+	add_definitions(-DUNIX -DLINUX)	
+	find_package(Threads REQUIRED)
+# Hosted
+else()
+	if(WIN32)
+    	add_definitions(-DWIN32)
+	elseif(UNIX)
+		find_package(Threads REQUIRED)
+		add_definitions(-DUNIX -DLINUX)	
+	endif()
+endif()
+
+set(FSFW_CONFIG_PATH testcfg)
+
+################################################################################
+# Executable and Sources
+################################################################################
+
+# Add executable
+add_executable(${TARGET_NAME})
+
+# Add subdirectories
+add_subdirectory(${FSFW_PATH})
+add_subdirectory(${CATCH2_PATH})
+add_subdirectory(${FSFW_CONFIG_PATH})
+add_subdirectory(${FSFW_TESTS_PATH})
+add_subdirectory(${TEST_SETUP_PATH})
+
+################################################################################
+# Post-Sources preparation
+################################################################################
+
+# Add libraries for all sources.
+target_link_libraries(${TARGET_NAME} PRIVATE
+	${LIB_FSFW_NAME} 
+	${CATCH2_TARGET}
+)
+
+# Add include paths for all sources.
+target_include_directories(${TARGET_NAME} PRIVATE
+	${CMAKE_CURRENT_SOURCE_DIR}
+	${FSFW_CONFIG_PATH}
+)	
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+	set(WARNING_FLAGS
+		-Wall
+		-Wextra
+		-Wshadow=local
+		-Wimplicit-fallthrough=1
+		-Wno-unused-parameter
+		-Wno-psabi
+	)
+	
+	# Remove unused sections.
+	target_compile_options(${TARGET_NAME} PRIVATE
+		"-ffunction-sections"
+		"-fdata-sections"
+	)
+
+	# Removed unused sections.
+	target_link_options(${TARGET_NAME} PRIVATE
+		"-Wl,--gc-sections"
+	)
+	
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+	set(COMPILER_FLAGS "/permissive-")
+endif()
+
+if(CMAKE_VERBOSE)
+	message(STATUS "Warning flags: ${WARNING_FLAGS}")
+endif()
+		 
+
+# Compile options for all sources.
+target_compile_options(${TARGET_NAME} PRIVATE
+	$<$<COMPILE_LANGUAGE:C>:${WARNING_FLAGS} ${COMPILER_FLAGS}>
+	$<$<COMPILE_LANGUAGE:CXX>:${WARNING_FLAGS} ${COMPILER_FLAGS}>
+	${ABI_FLAGS}
+)
+
+if(NOT CMAKE_SIZE)
+	set(CMAKE_SIZE size)
+	if(WIN32)
+		set(FILE_SUFFIX ".exe")
+	endif()
+endif()
+
+add_custom_command(
+   TARGET ${TARGET_NAME}
+   POST_BUILD
+   COMMAND echo "Build directory: ${CMAKE_BINARY_DIR}"
+   COMMAND echo "Target OSAL: ${OS_FSFW}"
+   COMMAND echo "Target Build Type: ${CMAKE_BUILD_TYPE}"
+   COMMAND ${CMAKE_SIZE} ${TARGET_NAME}${FILE_SUFFIX}
+)
+
+include (${CMAKE_CURRENT_SOURCE_DIR}/buildsystem/cmake/BuildType.cmake)
+set_build_type()
+
+
+
+
+

From 254b1437e978f7f17a57a07876f3ac7668898ef0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 15:15:51 +0100
Subject: [PATCH 1315/1774] repaired windows unittests

---
 unittest/internal/osal/IntTestMq.cpp                 |  6 +++---
 unittest/internal/osal/IntTestMutex.cpp              |  6 +++---
 unittest/internal/osal/IntTestSemaphore.cpp          | 11 ++++++-----
 unittest/internal/serialize/IntTestSerialization.cpp |  8 ++++----
 4 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/unittest/internal/osal/IntTestMq.cpp b/unittest/internal/osal/IntTestMq.cpp
index 9917285f5..fc8e963ef 100644
--- a/unittest/internal/osal/IntTestMq.cpp
+++ b/unittest/internal/osal/IntTestMq.cpp
@@ -1,8 +1,8 @@
 #include "IntTestMq.h"
-#include "../UnittDefinitions.h"
+#include <fsfw/unittest/internal/UnittDefinitions.h>
 
-#include "../../../ipc/MessageQueueIF.h"
-#include "../../../ipc/QueueFactory.h"
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
 
 #include <array>
 
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index d2f8b9628..3316de749 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -1,10 +1,10 @@
 #include "IntTestMutex.h"
 
-#include "../../../ipc/MutexFactory.h"
-#include "../UnittDefinitions.h"
+#include <fsfw/ipc/MutexFactory.h>
+#include <fsfw/unittest/internal/UnittDefinitions.h>
 
 #if defined(hosted)
-#include "../../osal/hosted/Mutex.h"
+#include <fsfw/osal/hosted/Mutex.h>
 #include <thread>
 #include <future>
 #endif
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index 6d2719d57..5a82f78c6 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -1,10 +1,11 @@
 #include "IntTestSemaphore.h"
-#include "../UnittDefinitions.h"
+#include <fsfw/unittest/internal/UnittDefinitions.h>
 
-#include "../../../tasks/SemaphoreFactory.h"
-#include "../../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../../timemanager/Stopwatch.h"
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/timemanager/Stopwatch.h>
 
+#include <cstdlib>
 
 void testsemaph::testBinSemaph() {
 	std::string id = "[BinSemaphore]";
@@ -138,7 +139,7 @@ void testsemaph::testCountingSemaphImplementation(SemaphoreIF* countingSemaph,
 		// attempt to take when count is 0, measure time
 		result = countingSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
 		dur_millis_t time = stopwatch.stop();
-		if(abs(time - 10) > 1) {
+		if(std::abs(static_cast<int32_t>(time - 10)) > 1) {
 			unitt::put_error(id);
 		}
 	}
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
index 793661c5b..69d82942e 100644
--- a/unittest/internal/serialize/IntTestSerialization.cpp
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -1,9 +1,9 @@
 #include "IntTestSerialization.h"
-#include "../UnittDefinitions.h"
+#include <fsfw/unittest/internal/UnittDefinitions.h>
 
-#include "../../../serialize/SerializeElement.h"
-#include "../../../serialize/SerialBufferAdapter.h"
-#include "../../../serialize/SerializeIF.h"
+#include <fsfw/serialize/SerializeElement.h>
+#include <fsfw/serialize/SerialBufferAdapter.h>
+#include <fsfw/serialize/SerializeIF.h>
 
 #include <array>
 

From f9bcc835d7e170c97b153422ea80f2a2306dbe16 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 01:17:03 +0100
Subject: [PATCH 1316/1774] include updated

---
 unittest/tests/container/TestFixedArrayList.cpp       | 4 ++--
 unittest/tests/container/TestFixedOrderedMultimap.cpp | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/unittest/tests/container/TestFixedArrayList.cpp b/unittest/tests/container/TestFixedArrayList.cpp
index b2baa3e76..1a85f30d8 100644
--- a/unittest/tests/container/TestFixedArrayList.cpp
+++ b/unittest/tests/container/TestFixedArrayList.cpp
@@ -1,5 +1,5 @@
-#include "../../../container/FixedArrayList.h"
-#include "../../../returnvalues/HasReturnvaluesIF.h"
+#include <fsfw/container/FixedArrayList.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/container/TestFixedOrderedMultimap.cpp b/unittest/tests/container/TestFixedOrderedMultimap.cpp
index b337a9c8d..a47d6efb0 100644
--- a/unittest/tests/container/TestFixedOrderedMultimap.cpp
+++ b/unittest/tests/container/TestFixedOrderedMultimap.cpp
@@ -1,5 +1,5 @@
-#include "../../../container/FixedOrderedMultimap.h"
-#include "../../../returnvalues/HasReturnvaluesIF.h"
+#include <fsfw/container/FixedOrderedMultimap.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>

From b126149215b8f1c9536f8a9c19ea63705f7ed7c6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 16:49:43 +0100
Subject: [PATCH 1317/1774] removed abi flags, are part of cross compile file
 now

---
 CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 02849ca44..3cc5ffd58 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -139,5 +139,4 @@ target_include_directories(${LIB_FSFW_NAME} PRIVATE
 target_compile_options(${LIB_FSFW_NAME} PRIVATE 
 	${WARNING_FLAGS}
 	${COMPILER_FLAGS}
-	${ABI_FLAGS}
 )

From d268c6d96cf22cb7317c87b80f648b81c8afb1db Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 16:59:39 +0100
Subject: [PATCH 1318/1774] moved includes to allow c inclusion

---
 defaultcfg/fsfwconfig/OBSWConfig.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/OBSWConfig.h b/defaultcfg/fsfwconfig/OBSWConfig.h
index 8ad2cb675..6ed8ea2c4 100644
--- a/defaultcfg/fsfwconfig/OBSWConfig.h
+++ b/defaultcfg/fsfwconfig/OBSWConfig.h
@@ -3,11 +3,12 @@
 
 #include "OBSWVersion.h"
 
+#ifdef __cplusplus
+
 #include "objects/systemObjectList.h"
 #include "events/subsystemIdRanges.h"
 #include "returnvalues/classIds.h"
 
-#ifdef __cplusplus
 namespace config {
 #endif
 

From bc475f0a9a794d75b90317ade116d7e3ada7aa9b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 17:48:26 +0100
Subject: [PATCH 1319/1774] bugfixes

---
 osal/host/CMakeLists.txt  | 2 ++
 osal/linux/CMakeLists.txt | 6 ++++++
 2 files changed, 8 insertions(+)

diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
index ee6b4cdbc..367f721e0 100644
--- a/osal/host/CMakeLists.txt
+++ b/osal/host/CMakeLists.txt
@@ -13,6 +13,8 @@ target_sources(${LIB_FSFW_NAME}
 )
 
 if(UNIX)
+	find_package(Threads REQUIRED)
+	
 	target_link_libraries(${LIB_FSFW_NAME} 
 	PRIVATE
 		rt
diff --git a/osal/linux/CMakeLists.txt b/osal/linux/CMakeLists.txt
index e9a2935b0..474e548bf 100644
--- a/osal/linux/CMakeLists.txt
+++ b/osal/linux/CMakeLists.txt
@@ -18,8 +18,14 @@ target_sources(${LIB_FSFW_NAME}
 		Timer.cpp
 )
 
+find_package(Threads REQUIRED)
+
 target_link_libraries(${LIB_FSFW_NAME} PRIVATE
 	${CMAKE_THREAD_LIBS_INIT}
 	rt
 )
 
+target_link_libraries(${LIB_FSFW_NAME} INTERFACE
+	${CMAKE_THREAD_LIBS_INIT}
+)
+

From 91cb061da941f610d2c7001ed2e47d64eaa6872f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 17:55:19 +0100
Subject: [PATCH 1320/1774] datapool updates, fixes, pool read helper

---
 datapool/PoolDataSetBase.cpp           | 49 ++++++++++++++++++++------
 datapool/PoolDataSetBase.h             | 31 +++++++++++-----
 datapool/PoolDataSetIF.h               |  6 ++--
 datapool/PoolVariableIF.h              | 40 ++-------------------
 datapool/ReadCommitIF.h                | 31 ++++++++++++++++
 datapoollocal/HasLocalDataPoolIF.h     |  3 ++
 datapoollocal/LocalDataPoolManager.cpp |  2 +-
 datapoollocal/LocalDataPoolManager.h   | 15 ++++----
 datapoollocal/LocalPoolDataSetBase.cpp | 32 ++++++++++-------
 datapoollocal/LocalPoolDataSetBase.h   | 15 ++++++--
 datapoollocal/LocalPoolVariable.tpp    | 18 +++++-----
 datapoollocal/PoolReadHelper.h         | 41 +++++++++++++++++++++
 12 files changed, 191 insertions(+), 92 deletions(-)
 create mode 100644 datapool/ReadCommitIF.h
 create mode 100644 datapoollocal/PoolReadHelper.h

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index cb2348f72..8f0733594 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -9,9 +9,10 @@ PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
 
 PoolDataSetBase::~PoolDataSetBase() {}
 
+
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
-	if (state != States::DATA_SET_UNINITIALISED) {
+	if (state != States::STATE_SET_UNINITIALISED) {
 		sif::error << "DataSet::registerVariable: "
 				"Call made in wrong position." << std::endl;
 		return DataSetIF::DATA_SET_UNINITIALISED;
@@ -33,15 +34,16 @@ ReturnValue_t PoolDataSetBase::registerVariable(
 
 ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	if (state == States::DATA_SET_UNINITIALISED) {
+	ReturnValue_t error = result;
+	if (state == States::STATE_SET_UNINITIALISED) {
 		lockDataPool(lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
 			result = readVariable(count);
 			if(result != RETURN_OK) {
-				break;
+				error = result;
 			}
 		}
-		state = States::DATA_SET_WAS_READ;
+		state = States::STATE_SET_WAS_READ;
 		unlockDataPool();
 	}
 	else {
@@ -50,6 +52,10 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 				" member datasets!" << std::endl;
 		result = SET_WAS_ALREADY_READ;
 	}
+
+	if(error != HasReturnvaluesIF::RETURN_OK) {
+		result = error;
+	}
 	return result;
 }
 
@@ -71,7 +77,13 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 		registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER)
 	{
-		result = registeredVariables[count]->readWithoutLock();
+		if(protectEveryReadCommitCall) {
+			result = registeredVariables[count]->read(mutexTimeout);
+		}
+		else {
+			result = registeredVariables[count]->readWithoutLock();
+		}
+
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			result = INVALID_PARAMETER_DEFINITION;
 		}
@@ -80,7 +92,7 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 }
 
 ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
-	if (state == States::DATA_SET_WAS_READ) {
+	if (state == States::STATE_SET_WAS_READ) {
 		handleAlreadyReadDatasetCommit(lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -96,10 +108,15 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 				!= PoolVariableIF::VAR_READ
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commitWithoutLock();
+			if(protectEveryReadCommitCall) {
+				registeredVariables[count]->commit(mutexTimeout);
+			}
+			else {
+				registeredVariables[count]->commitWithoutLock();
+			}
 		}
 	}
-	state = States::DATA_SET_UNINITIALISED;
+	state = States::STATE_SET_UNINITIALISED;
 	unlockDataPool();
 }
 
@@ -111,7 +128,13 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 				== PoolVariableIF::VAR_WRITE
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commitWithoutLock();
+			if(protectEveryReadCommitCall) {
+				result = registeredVariables[count]->commit(mutexTimeout);
+			}
+			else {
+				result = registeredVariables[count]->commitWithoutLock();
+			}
+
 		} else if (registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if (result != COMMITING_WITHOUT_READING) {
@@ -121,7 +144,7 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 			}
 		}
 	}
-	state = States::DATA_SET_UNINITIALISED;
+	state = States::STATE_SET_UNINITIALISED;
 	unlockDataPool();
 	return result;
 }
@@ -172,3 +195,9 @@ size_t PoolDataSetBase::getSerializedSize() const {
 void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
     this->registeredVariables = variablesContainer;
 }
+
+void PoolDataSetBase::setReadCommitProtectionBehaviour(
+		bool protectEveryReadCommit, uint32_t mutexTimeout) {
+	this->protectEveryReadCommitCall = protectEveryReadCommit;
+	this->mutexTimeout = mutexTimeout;
+}
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index a8931d628..7c1d84a41 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -44,6 +44,7 @@ public:
 
 	/**
 	 * @brief	The read call initializes reading out all registered variables.
+	 * 			It is mandatory to call commit after every read call!
 	 * @details
 	 * It iterates through the list of registered variables and calls all read()
 	 * functions of the registered pool variables (which read out their values
@@ -52,13 +53,14 @@ public:
 	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
 	 *
 	 * The data pool is locked during the whole read operation and
-	 * freed afterwards.The state changes to "was written" after this operation.
+	 * freed afterwards. It is mandatory to call commit after a read call,
+	 * even if the read operation is not successful!
 	 * @return
 	 * - @c RETURN_OK if all variables were read successfully.
-	 * - @c INVALID_PARAMETER_DEFINITION if PID, size or type of the
-	 * requested variable is invalid.
+	 * - @c INVALID_PARAMETER_DEFINITION if a pool entry does not exist or there
+	 *      is a type conflict.
 	 * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
-	 * commit() in between
+	 *      commit() in between
 	 */
 	virtual ReturnValue_t read(uint32_t lockTimeout =
 			MutexIF::BLOCKING) override;
@@ -75,7 +77,7 @@ public:
 	 * If the set does contain at least one variable which is not write-only
 	 * commit() can only be called after read(). If the set only contains
 	 * variables which are write only, commit() can be called without a
-	 * preceding read() call.
+	 * preceding read() call. Every read call must be followed by a commit call!
 	 * @return	- @c RETURN_OK if all variables were read successfully.
 	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
 	 * 			  contains non write-only variables
@@ -89,6 +91,7 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override;
+
 	/**
 	 * Provides the means to lock the underlying data structure to ensure
 	 * thread-safety. Default implementation is empty
@@ -114,6 +117,15 @@ public:
 	        SerializeIF::Endianness streamEndianness) override;
 
 protected:
+
+	/**
+	 * Can be used to individually protect every read and commit call.
+	 * @param protectEveryReadCommit
+	 * @param mutexTimeout
+	 */
+	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+			uint32_t mutexTimeout = 20);
+
 	/**
 	 * @brief	The fill_count attribute ensures that the variables
 	 * 			register in the correct array position and that the maximum
@@ -124,14 +136,14 @@ protected:
 	 * States of the seet.
 	 */
 	enum class States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
+		STATE_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
+		STATE_SET_WAS_READ     //!< DATA_SET_WAS_READ
 	};
 	/**
 	 * @brief	state manages the internal state of the data set,
 	 *          which is important e.g. for the behavior on destruction.
 	 */
-	States state = States::DATA_SET_UNINITIALISED;
+	States state = States::STATE_SET_UNINITIALISED;
 
 	/**
 	 * @brief	This array represents all pool variables registered in this set.
@@ -144,6 +156,9 @@ protected:
 	void setContainer(PoolVariableIF** variablesContainer);
 
 private:
+	bool protectEveryReadCommitCall = false;
+	uint32_t mutexTimeout = 20;
+
 	ReturnValue_t readVariable(uint16_t count);
 	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
 	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index aa45fa548..99c06cfd7 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -1,19 +1,17 @@
 #ifndef FSFW_DATAPOOL_POOLDATASETIF_H_
 #define FSFW_DATAPOOL_POOLDATASETIF_H_
 
+#include "ReadCommitIF.h"
 #include "DataSetIF.h"
 
 /**
  * @brief   Extendes the DataSetIF by adding abstract functions to lock
  *          and unlock a data pool and read/commit semantics.
  */
-class PoolDataSetIF: public DataSetIF {
+class PoolDataSetIF: public DataSetIF, public ReadCommitIF {
 public:
     virtual~ PoolDataSetIF() {};
 
-    virtual ReturnValue_t read(dur_millis_t lockTimeout) = 0;
-    virtual ReturnValue_t commit(dur_millis_t lockTimeout) = 0;
-
     /**
      * @brief   Most underlying data structures will have a pool like structure
      *          and will require a lock and unlock mechanism to ensure
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index cd15f7445..9740fc121 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -3,6 +3,7 @@
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
+#include "ReadCommitIF.h"
 
 /**
  * @brief	This interface is used to control data pool
@@ -17,9 +18,9 @@
  * @author 	Bastian Baetz
  * @ingroup data_pool
  */
-class PoolVariableIF : public SerializeIF {
+class PoolVariableIF : public SerializeIF,
+		public ReadCommitIF {
 	friend class PoolDataSetBase;
-	friend class GlobDataSet;
 	friend class LocalPoolDataSetBase;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
@@ -57,41 +58,6 @@ public:
 	 */
 	virtual void setValid(bool validity) = 0;
 
-	/**
-	 * @brief	The commit call shall write back a newly calculated local
-	 * 			value to the data pool.
-	 * @details
-	 * It is assumed that these calls are implemented in a thread-safe manner!
-	 */
-	virtual ReturnValue_t commit(uint32_t lockTimeout) = 0;
-	/**
-	 * @brief	The read call shall read the value of this parameter from
-	 * 			the data pool and store the content locally.
-	 * @details
-	 * It is assumbed that these calls are implemented in a thread-safe manner!
-	 */
-	virtual ReturnValue_t read(uint32_t lockTimeout) = 0;
-
-protected:
-
-	/**
-	 * @brief 	Same as commit with the difference that comitting will be
-	 * 			performed without a lock
-	 * @return
-	 * This can be used if the lock protection is handled externally
-	 * to avoid the overhead of locking and unlocking consecutively.
-	 * Declared protected to avoid free public usage.
-	 */
-	virtual ReturnValue_t readWithoutLock() = 0;
-	/**
-	 * @brief 	Same as commit with the difference that comitting will be
-	 * 			performed without a lock
-	 * @return
-	 * This can be used if the lock protection is handled externally
-	 * to avoid the overhead of locking and unlocking consecutively.
-	 * Declared protected to avoid free public usage.
-	 */
-	virtual ReturnValue_t commitWithoutLock() = 0;
 };
 
 using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h
new file mode 100644
index 000000000..0cdce3718
--- /dev/null
+++ b/datapool/ReadCommitIF.h
@@ -0,0 +1,31 @@
+#ifndef FSFW_DATAPOOL_READCOMMITIF_H_
+#define FSFW_DATAPOOL_READCOMMITIF_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+/**
+ * @brief 	Common interface for all software objects which employ read-commit
+ * 			semantics.
+ */
+class ReadCommitIF {
+public:
+	virtual ~ReadCommitIF() {}
+	virtual ReturnValue_t read(uint32_t mutexTimeout) = 0;
+	virtual ReturnValue_t commit(uint32_t mutexTimeout) = 0;
+
+protected:
+
+	//! Optional and protected because this is interesting for classes grouping
+	//! members with commit and read semantics where the lock is only necessary
+	//! once.
+	virtual ReturnValue_t readWithoutLock()  {
+		return read(20);
+	}
+
+	virtual ReturnValue_t commitWithoutLock() {
+		return commit(20);
+	}
+};
+
+
+#endif /* FSFW_DATAPOOL_READCOMMITIF_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 7f1f202e7..df8551101 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -44,6 +44,9 @@ public:
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 
+    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
+    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+
 	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
 	virtual object_id_t getObjectId() const = 0;
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f649a3623..5f0d15d3c 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -577,7 +577,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
     if (poolIter == localPoolMap.end()) {
         sif::debug << "HousekeepingManager::fechPoolEntry:"
                 << " Pool entry not found." << std::endl;
-        return POOL_ENTRY_NOT_FOUND;
+        return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
     poolIter->second->print();
     return HasReturnvaluesIF::RETURN_OK;
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c4024cf9e..cdefa2c29 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -55,14 +55,11 @@ class LocalDataPoolManager {
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
-    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x0);
 
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x02);
-
-    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x03);
-    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x04);
-    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x05);
+    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x01);
+    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x02);
+    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x03);
 
     /**
      * This constructor is used by a class which wants to implement
@@ -380,14 +377,14 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 	if (poolIter == localPoolMap.end()) {
 		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
 		        "not found." << std::endl;
-		return POOL_ENTRY_NOT_FOUND;
+		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
 		sif::debug << "HousekeepingManager::fetchPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return POOL_ENTRY_TYPE_CONFLICT;
+		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 640956dba..9ecad2183 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -8,7 +8,7 @@
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         uint32_t setId, PoolVariableIF** registeredVariablesArray,
-        const size_t maxNumberOfVariables, bool noPeriodicHandling):
+        const size_t maxNumberOfVariables, bool periodicHandling):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
     if(hkOwner == nullptr) {
         // Configuration error.
@@ -23,7 +23,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     mutex = MutexFactory::instance()->createMutex();
 
     // Data creators get a periodic helper for periodic HK data generation.
-    if(not noPeriodicHandling) {
+    if(periodicHandling) {
         periodicHelper = new PeriodicHousekeepingHelper(this);
     }
 }
@@ -34,13 +34,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
-    if(hkOwner == nullptr) {
-        // Configuration error.
-        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-                << "invalid!" << std::endl;
-        return;
+    if(hkOwner != nullptr) {
+    	hkManager = hkOwner->getHkManagerHandle();
     }
-    hkManager = hkOwner->getHkManagerHandle();
     this->sid = sid;
 
     mutex = MutexFactory::instance()->createMutex();
@@ -50,8 +46,11 @@ LocalPoolDataSetBase::~LocalPoolDataSetBase() {
 }
 
 ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
-    MutexIF* mutex = hkManager->getMutexHandle();
-    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+	if(hkManager != nullptr) {
+	    MutexIF* mutex = hkManager->getMutexHandle();
+	    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
@@ -127,8 +126,11 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-    MutexIF* mutex = hkManager->getMutexHandle();
-    return mutex->unlockMutex();
+	if(hkManager != nullptr) {
+	    MutexIF* mutex = hkManager->getMutexHandle();
+	    return mutex->unlockMutex();
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
@@ -276,3 +278,9 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     }
     this->valid = valid;
 }
+
+void LocalPoolDataSetBase::setReadCommitProtectionBehaviour(
+		bool protectEveryReadCommit, uint32_t mutexTimeout) {
+	PoolDataSetBase::setReadCommitProtectionBehaviour(protectEveryReadCommit,
+			mutexTimeout);
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index aa155bf1b..d9b6a2212 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -54,7 +54,7 @@ public:
 	 */
 	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 			uint32_t setId, PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables, bool noPeriodicHandling = false);
+	        const size_t maxNumberOfVariables, bool periodicHandling = true);
 
 	/**
 	 * @brief	Constructor for users of local pool data.
@@ -77,6 +77,16 @@ public:
 	 */
 	~LocalPoolDataSetBase();
 
+	/**
+	 * If the data is pulled from different local data pools, every read and
+	 * commit call should be mutex protected for thread safety.
+	 * This can be specified with the second parameter.
+	 * @param dataCreator
+	 * @param protectEveryReadCommit
+	 */
+	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+			uint32_t mutexTimeout = 20);
+
 	void setValidityBufferGeneration(bool withValidityBuffer);
 
 	sid_t getSid() const;
@@ -128,6 +138,7 @@ public:
 
 protected:
 	sid_t sid;
+	uint32_t mutexTimeout = 20;
 	MutexIF* mutex = nullptr;
 
 	bool diagnostic = false;
@@ -181,7 +192,7 @@ protected:
 	 */
 	ReturnValue_t unlockDataPool() override;
 
-	LocalDataPoolManager* hkManager;
+	LocalDataPoolManager* hkManager = nullptr;
 
 	/**
 	 * Set n-th bit of a byte, with n being the position from 0
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 48649ad58..a685ea8d9 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -11,14 +11,14 @@ inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner,
+		lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
         LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 
 template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF *dataSet,
-		pool_rwm_t setReadWriteMode):
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
+		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
 				dataSet, setReadWriteMode){}
 
@@ -40,11 +40,11 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK and poolEntry != nullptr) {
+	if(result != RETURN_OK or poolEntry == nullptr) {
 		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
-				std::dec << " failed.\n" << std::flush;
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< hkManager->getOwner() << " and lp ID " << localPoolId
+				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
 		return result;
 	}
 	this->value = *(poolEntry->address);
@@ -62,7 +62,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		sif::debug << "LocalPoolVar: Invalid read write "
+		sif::debug << "LocalPoolVariable: Invalid read write "
 				 "mode for commit() call." << std::endl;
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
new file mode 100644
index 000000000..4fe506ee4
--- /dev/null
+++ b/datapoollocal/PoolReadHelper.h
@@ -0,0 +1,41 @@
+#ifndef FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
+#define FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
+
+#include <fsfw/datapoollocal/LocalPoolDataSetBase.h>
+#include <FSFWConfig.h>
+
+/**
+ * @brief 	Helper class to read data sets or pool variables
+ */
+class PoolReadHelper {
+public:
+	PoolReadHelper(ReadCommitIF* readObject, uint32_t mutexTimeout = 20):
+			readObject(readObject), mutexTimeout(mutexTimeout) {
+		if(readObject != nullptr) {
+			readResult = readObject->read(mutexTimeout);
+#if FSFW_PRINT_VERBOSITY_LEVEL == 1
+			sif::error << "PoolReadHelper: Read failed!" << std::endl;
+#endif
+		}
+	}
+
+	ReturnValue_t getReadResult() const {
+		return readResult;
+	}
+
+	~PoolReadHelper() {
+		if(readObject != nullptr) {
+			readObject->commit(mutexTimeout);
+		}
+
+	}
+
+private:
+	ReadCommitIF* readObject = nullptr;
+	ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+	uint32_t mutexTimeout = 20;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_ */

From bc1513c649dc6e8d8c4ab161537b1a2f12d41d3c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 18:06:00 +0100
Subject: [PATCH 1321/1774] cmake lists updates

---
 CMakeLists.txt            |  1 -
 osal/host/CMakeLists.txt  |  4 +++-
 osal/linux/CMakeLists.txt | 14 ++++++++++----
 unittest/CMakeLists.txt   |  2 ++
 4 files changed, 15 insertions(+), 6 deletions(-)
 create mode 100644 unittest/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 02849ca44..3cc5ffd58 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -139,5 +139,4 @@ target_include_directories(${LIB_FSFW_NAME} PRIVATE
 target_compile_options(${LIB_FSFW_NAME} PRIVATE 
 	${WARNING_FLAGS}
 	${COMPILER_FLAGS}
-	${ABI_FLAGS}
 )
diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
index aa32990be..367f721e0 100644
--- a/osal/host/CMakeLists.txt
+++ b/osal/host/CMakeLists.txt
@@ -13,9 +13,11 @@ target_sources(${LIB_FSFW_NAME}
 )
 
 if(UNIX)
+	find_package(Threads REQUIRED)
+	
 	target_link_libraries(${LIB_FSFW_NAME} 
 	PRIVATE
 		rt
-		pthread
+		${CMAKE_THREAD_LIBS_INIT}
 	)
 endif()
\ No newline at end of file
diff --git a/osal/linux/CMakeLists.txt b/osal/linux/CMakeLists.txt
index c0096e428..474e548bf 100644
--- a/osal/linux/CMakeLists.txt
+++ b/osal/linux/CMakeLists.txt
@@ -18,8 +18,14 @@ target_sources(${LIB_FSFW_NAME}
 		Timer.cpp
 )
 
-target_link_libraries(${LIB_FSFW_NAME} 
-	PRIVATE
-		rt
-		pthread
+find_package(Threads REQUIRED)
+
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+	${CMAKE_THREAD_LIBS_INIT}
+	rt
 )
+
+target_link_libraries(${LIB_FSFW_NAME} INTERFACE
+	${CMAKE_THREAD_LIBS_INIT}
+)
+
diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt
new file mode 100644
index 000000000..119ef243a
--- /dev/null
+++ b/unittest/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_subdirectory(internal)
+add_subdirectory(tests)
\ No newline at end of file

From c8af75f9c754816dba4561baf64aa5e8753406fb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 18:06:34 +0100
Subject: [PATCH 1322/1774] moved inlcudes

---
 defaultcfg/fsfwconfig/OBSWConfig.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/OBSWConfig.h b/defaultcfg/fsfwconfig/OBSWConfig.h
index 8ad2cb675..6ed8ea2c4 100644
--- a/defaultcfg/fsfwconfig/OBSWConfig.h
+++ b/defaultcfg/fsfwconfig/OBSWConfig.h
@@ -3,11 +3,12 @@
 
 #include "OBSWVersion.h"
 
+#ifdef __cplusplus
+
 #include "objects/systemObjectList.h"
 #include "events/subsystemIdRanges.h"
 #include "returnvalues/classIds.h"
 
-#ifdef __cplusplus
 namespace config {
 #endif
 

From 219c057fb9821b3b75805acb4b177b52e16d2f51 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 29 Dec 2020 14:08:48 +0100
Subject: [PATCH 1323/1774] added service 3 cmake support

---
 pus/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pus/CMakeLists.txt b/pus/CMakeLists.txt
index 758c26293..c0e004481 100644
--- a/pus/CMakeLists.txt
+++ b/pus/CMakeLists.txt
@@ -5,6 +5,7 @@ target_sources(${LIB_FSFW_NAME}
 		Service17Test.cpp
 		Service1TelecommandVerification.cpp
 		Service2DeviceAccess.cpp
+		Service3Housekeeping.cpp
 		Service5EventReporting.cpp
 		Service8FunctionManagement.cpp
 		Service9TimeManagement.cpp

From 8ef6283bf4f5cf5d12131c48365a753825fea637 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 29 Dec 2020 14:10:38 +0100
Subject: [PATCH 1324/1774] added srv3

---
 pus/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pus/CMakeLists.txt b/pus/CMakeLists.txt
index 758c26293..c0e004481 100644
--- a/pus/CMakeLists.txt
+++ b/pus/CMakeLists.txt
@@ -5,6 +5,7 @@ target_sources(${LIB_FSFW_NAME}
 		Service17Test.cpp
 		Service1TelecommandVerification.cpp
 		Service2DeviceAccess.cpp
+		Service3Housekeeping.cpp
 		Service5EventReporting.cpp
 		Service8FunctionManagement.cpp
 		Service9TimeManagement.cpp

From 1ac2479b28c1114b0876123e0db4155abfbf06fe Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 29 Dec 2020 18:06:25 +0100
Subject: [PATCH 1325/1774] made warning flag optional

---
 CMakeLists.txt | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 02849ca44..aaf9a8af9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -110,11 +110,18 @@ if(CMAKE_COMPILER_IS_GNUCXX)
 	set(WARNING_FLAGS
 		-Wall
 		-Wextra
-		-Wshadow=local
 		-Wimplicit-fallthrough=1
 		-Wno-unused-parameter
 		-Wno-psabi
 	)
+	
+	if(NOT DEFINED WARNING_SHADOW_LOCAL)
+		option(WARNING_SHADOW_LOCAL "Show shadows declarations warning." ON)
+	endif()
+	
+	if(WARNING_SHADOW_LOCAL)
+		list(APPEND WARNING_FLAGS "-Wshadow=local")
+	endif()
 endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")

From 44dcd3104eae56157adee88e0ecbd8712fe86881 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Dec 2020 22:01:11 +0100
Subject: [PATCH 1326/1774] device handler base update

---
 devicehandlers/DeviceHandlerBase.cpp | 19 +++++++++++--------
 devicehandlers/DeviceHandlerBase.h   |  4 ++--
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d06308543..efee14620 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,8 +16,8 @@
 #include <iomanip>
 
 
-object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::defaultPowerSwitcherId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::defaultRawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
@@ -151,9 +151,9 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
-	if(rawDataReceiverId != objects::NO_OBJECT) {
+	if(defaultRawDataReceiverId != objects::NO_OBJECT) {
 		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
-				AcceptsDeviceResponsesIF>(rawDataReceiverId);
+				AcceptsDeviceResponsesIF>(defaultRawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
 			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
@@ -165,8 +165,9 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		defaultRawReceiver = rawReceiver->getDeviceQueue();
 	}
 
-	if(powerSwitcherId != objects::NO_OBJECT) {
-		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
+	if(defaultPowerSwitcherId != objects::NO_OBJECT) {
+		powerSwitcher = objectManager->get<PowerSwitchIF>(
+				defaultPowerSwitcherId);
 		if (powerSwitcher == nullptr) {
 			sif::error << "DeviceHandlerBase::initialize: Power switcher "
 					<< "object ID set but no valid object found." << std::endl;
@@ -682,8 +683,10 @@ void DeviceHandlerBase::doGetRead() {
 		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
 	}
 
-	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
-		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
+	if (mode == MODE_RAW) {
+		if(defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
+			replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
+		}
 	}
 	else {
 		parseReply(receivedData, receivedDataLen);
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 24ba0372c..0d14bf4ea 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -739,10 +739,10 @@ protected:
 	PeriodicTaskIF* executingTask = nullptr;
 
 	//!< Object which switches power on and off.
-	static object_id_t powerSwitcherId;
+	static object_id_t defaultPowerSwitcherId;
 
 	//!< Object which receives RAW data by default.
-	static object_id_t rawDataReceiverId;
+	static object_id_t defaultRawDataReceiverId;
 
 	//!< Object which may be the root cause of an identified fault.
 	static object_id_t defaultFdirParentId;

From 56eac4647265deb8b115eb1c970a0b81153a03cc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Dec 2020 22:17:08 +0100
Subject: [PATCH 1327/1774] Revert "device handler base update"

This reverts commit 44dcd3104eae56157adee88e0ecbd8712fe86881.
---
 devicehandlers/DeviceHandlerBase.cpp | 19 ++++++++-----------
 devicehandlers/DeviceHandlerBase.h   |  4 ++--
 2 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index efee14620..d06308543 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,8 +16,8 @@
 #include <iomanip>
 
 
-object_id_t DeviceHandlerBase::defaultPowerSwitcherId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::defaultRawDataReceiverId = objects::NO_OBJECT;
+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,
@@ -151,9 +151,9 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
-	if(defaultRawDataReceiverId != objects::NO_OBJECT) {
+	if(rawDataReceiverId != objects::NO_OBJECT) {
 		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
-				AcceptsDeviceResponsesIF>(defaultRawDataReceiverId);
+				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
 			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
@@ -165,9 +165,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		defaultRawReceiver = rawReceiver->getDeviceQueue();
 	}
 
-	if(defaultPowerSwitcherId != objects::NO_OBJECT) {
-		powerSwitcher = objectManager->get<PowerSwitchIF>(
-				defaultPowerSwitcherId);
+	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;
@@ -683,10 +682,8 @@ void DeviceHandlerBase::doGetRead() {
 		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
 	}
 
-	if (mode == MODE_RAW) {
-		if(defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
-			replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
-		}
+	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
+		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
 	}
 	else {
 		parseReply(receivedData, receivedDataLen);
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 0d14bf4ea..24ba0372c 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -739,10 +739,10 @@ protected:
 	PeriodicTaskIF* executingTask = nullptr;
 
 	//!< Object which switches power on and off.
-	static object_id_t defaultPowerSwitcherId;
+	static object_id_t powerSwitcherId;
 
 	//!< Object which receives RAW data by default.
-	static object_id_t defaultRawDataReceiverId;
+	static object_id_t rawDataReceiverId;
 
 	//!< Object which may be the root cause of an identified fault.
 	static object_id_t defaultFdirParentId;

From 0a4d0b593713e61b7ddf47ecb4b1657d8a0a8674 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Dec 2020 22:34:40 +0100
Subject: [PATCH 1328/1774] bugfix

---
 devicehandlers/DeviceHandlerBase.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d06308543..251320cbe 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -682,8 +682,10 @@ void DeviceHandlerBase::doGetRead() {
 		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
 	}
 
-	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
-		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
+	if (mode == MODE_RAW) {
+		if (defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
+			replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
+		}
 	}
 	else {
 		parseReply(receivedData, receivedDataLen);

From c4fb1f49d813a97113099d4c6e257d5606955182 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Dec 2020 22:56:46 +0100
Subject: [PATCH 1329/1774] updated defaultcfg

---
 defaultcfg/fsfwconfig/CMakeLists.txt          | 21 +++++++-------
 .../fsfwconfig/devices/logicalAddresses.cpp   |  5 ----
 .../fsfwconfig/devices/logicalAddresses.h     |  2 +-
 .../fsfwconfig/devices/powerSwitcherList.cpp  |  4 ---
 .../objects/{Factory.cpp => FsfwFactory.cpp}  | 29 +++++++++----------
 .../objects/{Factory.h => FsfwFactory.h}      |  2 +-
 6 files changed, 26 insertions(+), 37 deletions(-)
 delete mode 100644 defaultcfg/fsfwconfig/devices/logicalAddresses.cpp
 delete mode 100644 defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp
 rename defaultcfg/fsfwconfig/objects/{Factory.cpp => FsfwFactory.cpp} (60%)
 rename defaultcfg/fsfwconfig/objects/{Factory.h => FsfwFactory.h} (91%)

diff --git a/defaultcfg/fsfwconfig/CMakeLists.txt b/defaultcfg/fsfwconfig/CMakeLists.txt
index b8b41c930..4b8f44749 100644
--- a/defaultcfg/fsfwconfig/CMakeLists.txt
+++ b/defaultcfg/fsfwconfig/CMakeLists.txt
@@ -1,15 +1,14 @@
-target_sources(${TARGET_NAME} 
-	PRIVATE
+target_sources(${LIB_FSFW_NAME} PRIVATE
+	ipc/missionMessageTypes.cpp
+	objects/FsfwFactory.cpp
+	pollingsequence/PollingSequenceFactory.cpp
 )
 
-# Add include paths for the executable
-target_include_directories(${TARGET_NAME} 
-	PUBLIC 
-		${CMAKE_CURRENT_SOURCE_DIR}
+# Should be added to include path
+target_include_directories(${TARGET_NAME} PRIVATE
+	${CMAKE_CURRENT_SOURCE_DIR}
 )
 
-# Add include paths for the FSFW library
-target_include_directories(${LIB_FSFW_NAME} 
-	PUBLIC
-		${CMAKE_CURRENT_SOURCE_DIR}
-)
\ No newline at end of file
+if(NOT FSFW_CONFIG_PATH)
+	set(FSFW_CONFIG_PATH ${CMAKE_CURRENT_SOURCE_DIR})
+endif()
diff --git a/defaultcfg/fsfwconfig/devices/logicalAddresses.cpp b/defaultcfg/fsfwconfig/devices/logicalAddresses.cpp
deleted file mode 100644
index c7ce314d1..000000000
--- a/defaultcfg/fsfwconfig/devices/logicalAddresses.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "logicalAddresses.h"
-
-
-
-
diff --git a/defaultcfg/fsfwconfig/devices/logicalAddresses.h b/defaultcfg/fsfwconfig/devices/logicalAddresses.h
index e0827ba33..53edcd544 100644
--- a/defaultcfg/fsfwconfig/devices/logicalAddresses.h
+++ b/defaultcfg/fsfwconfig/devices/logicalAddresses.h
@@ -2,7 +2,7 @@
 #define CONFIG_DEVICES_LOGICALADDRESSES_H_
 
 #include <fsfw/devicehandlers/CookieIF.h>
-#include "../objects/systemObjectList.h"
+#include <objects/systemObjectList.h>
 #include <cstdint>
 
 /**
diff --git a/defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp b/defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp
deleted file mode 100644
index 343f78d04..000000000
--- a/defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "powerSwitcherList.h"
-
-
-
diff --git a/defaultcfg/fsfwconfig/objects/Factory.cpp b/defaultcfg/fsfwconfig/objects/FsfwFactory.cpp
similarity index 60%
rename from defaultcfg/fsfwconfig/objects/Factory.cpp
rename to defaultcfg/fsfwconfig/objects/FsfwFactory.cpp
index 41333b1c3..428adf1d7 100644
--- a/defaultcfg/fsfwconfig/objects/Factory.cpp
+++ b/defaultcfg/fsfwconfig/objects/FsfwFactory.cpp
@@ -1,9 +1,5 @@
-#include "Factory.h"
-#include "../tmtc/apid.h"
-#include "../tmtc/pusIds.h"
-#include "../objects/systemObjectList.h"
-#include "../devices/logicalAddresses.h"
-#include "../devices/powerSwitcherList.h"
+#include "FsfwFactory.h"
+#include <OBSWConfig.h>
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <fsfw/events/EventManager.h>
@@ -11,24 +7,27 @@
 #include <fsfw/tmtcpacket/pus/TmPacketStored.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
-#include <internalError/InternalErrorReporter.h>
+#include <fsfw/internalError/InternalErrorReporter.h>
 
 #include <cstdint>
 
 /**
- * This class should be used to create all system objects required for
- * the on-board software, using the object ID list from the configuration
- * folder.
+ * This function builds all system objects required for using
+ * the FSFW. It is recommended to build all other required objects
+ * in a function with an identical prototype, call this function in it and
+ * then pass the function to the object manager so it builds all system
+ * objects on software startup.
  *
- * The objects are registered in the internal object manager automatically.
- * This is used later to add objects to tasks.
+ * All system objects are registered in the internal object manager
+ * automatically. The objects should be added to tasks at a later stage, using
+ * their objects IDs.
  *
- * This file also sets static framework IDs.
+ * This function also sets static framework IDs.
  *
- * Framework objects are created first.
+ * Framework should be created first before creating mission system objects.
  * @ingroup init
  */
-void Factory::produce(void) {
+void Factory::produceFsfwObjects(void) {
 	setStaticFrameworkObjectIds();
 	new EventManager(objects::EVENT_MANAGER);
 	new HealthTable(objects::HEALTH_TABLE);
diff --git a/defaultcfg/fsfwconfig/objects/Factory.h b/defaultcfg/fsfwconfig/objects/FsfwFactory.h
similarity index 91%
rename from defaultcfg/fsfwconfig/objects/Factory.h
rename to defaultcfg/fsfwconfig/objects/FsfwFactory.h
index fe55defff..2724d2e3e 100644
--- a/defaultcfg/fsfwconfig/objects/Factory.h
+++ b/defaultcfg/fsfwconfig/objects/FsfwFactory.h
@@ -9,7 +9,7 @@ namespace Factory {
 	 * @brief   Creates all SystemObject elements which are persistent
 	 *          during execution.
 	 */
-	void produce();
+	void produceFsfwObjects();
 	void setStaticFrameworkObjectIds();
 }
 

From 7b15a5a431b7a2b1c8d1cbdeffbf2431f0b37315 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Dec 2020 22:57:52 +0100
Subject: [PATCH 1330/1774] moved includes

---
 defaultcfg/fsfwconfig/OBSWConfig.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/OBSWConfig.h b/defaultcfg/fsfwconfig/OBSWConfig.h
index 8ad2cb675..6ed8ea2c4 100644
--- a/defaultcfg/fsfwconfig/OBSWConfig.h
+++ b/defaultcfg/fsfwconfig/OBSWConfig.h
@@ -3,11 +3,12 @@
 
 #include "OBSWVersion.h"
 
+#ifdef __cplusplus
+
 #include "objects/systemObjectList.h"
 #include "events/subsystemIdRanges.h"
 #include "returnvalues/classIds.h"
 
-#ifdef __cplusplus
 namespace config {
 #endif
 

From 5be95fada76a6ea8ab24ed9d37d4f157a6910ac0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 1 Jan 2021 17:18:37 +0100
Subject: [PATCH 1331/1774] bugfixes and RTEMS update for STM32

---
 defaultcfg/fsfwconfig/CMakeLists.txt |  8 +++-----
 osal/rtems/CMakeLists.txt            | 18 ++++++++++++++++++
 osal/rtems/Clock.cpp                 |  5 ++++-
 osal/rtems/InternalErrorCodes.cpp    |  2 ++
 4 files changed, 27 insertions(+), 6 deletions(-)
 create mode 100644 osal/rtems/CMakeLists.txt

diff --git a/defaultcfg/fsfwconfig/CMakeLists.txt b/defaultcfg/fsfwconfig/CMakeLists.txt
index b8b41c930..c37d8ddda 100644
--- a/defaultcfg/fsfwconfig/CMakeLists.txt
+++ b/defaultcfg/fsfwconfig/CMakeLists.txt
@@ -8,8 +8,6 @@ target_include_directories(${TARGET_NAME}
 		${CMAKE_CURRENT_SOURCE_DIR}
 )
 
-# Add include paths for the FSFW library
-target_include_directories(${LIB_FSFW_NAME} 
-	PUBLIC
-		${CMAKE_CURRENT_SOURCE_DIR}
-)
\ No newline at end of file
+if(NOT DEFINED FSFW_CONFIG_DIRECTORY)
+	set(FSFW_CONFIG_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+endif()
\ No newline at end of file
diff --git a/osal/rtems/CMakeLists.txt b/osal/rtems/CMakeLists.txt
new file mode 100644
index 000000000..bff031842
--- /dev/null
+++ b/osal/rtems/CMakeLists.txt
@@ -0,0 +1,18 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		CpuUsage.cpp
+		InitTask.cpp
+		InternalErrorCodes.cpp
+		MessageQueue.cpp
+		MultiObjectTask.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PollingTask.cpp
+		QueueFactory.cpp
+		RtemsBasic.cpp
+		TaskBase.cpp
+		TaskFactory.cpp
+)
+
+
diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index e5f37ec6a..aa135adea 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -1,5 +1,8 @@
-#include "../../timemanager/Clock.h"
 #include "RtemsBasic.h"
+
+#include "../../timemanager/Clock.h"
+#include "../../ipc/MutexHelper.h"
+
 #include <rtems/score/todimpl.h>
 
 uint16_t Clock::leapSeconds = 0;
diff --git a/osal/rtems/InternalErrorCodes.cpp b/osal/rtems/InternalErrorCodes.cpp
index ddf365d5f..f40798147 100644
--- a/osal/rtems/InternalErrorCodes.cpp
+++ b/osal/rtems/InternalErrorCodes.cpp
@@ -34,8 +34,10 @@ ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
 		return OUT_OF_PROXIES;
 	case INTERNAL_ERROR_INVALID_GLOBAL_ID:
 		return INVALID_GLOBAL_ID;
+#ifndef STM32H743ZI_NUCLEO
 	case INTERNAL_ERROR_BAD_STACK_HOOK:
 		return BAD_STACK_HOOK;
+#endif
 //	case INTERNAL_ERROR_BAD_ATTRIBUTES:
 //		return BAD_ATTRIBUTES;
 //	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:

From f223aa148edc13ee76ffc807b933a29cab92aae1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 1 Jan 2021 18:05:02 +0100
Subject: [PATCH 1332/1774] updated cmake lists

---
 defaultcfg/fsfwconfig/CMakeLists.txt | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/defaultcfg/fsfwconfig/CMakeLists.txt b/defaultcfg/fsfwconfig/CMakeLists.txt
index 8c8d8086f..cbd4ecdec 100644
--- a/defaultcfg/fsfwconfig/CMakeLists.txt
+++ b/defaultcfg/fsfwconfig/CMakeLists.txt
@@ -9,6 +9,7 @@ target_include_directories(${TARGET_NAME} PRIVATE
 	${CMAKE_CURRENT_SOURCE_DIR}
 )
 
-if(NOT DEFINED FSFW_CONFIG_DIRECTORY)
-	set(FSFW_CONFIG_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+if(NOT FSFW_CONFIG_PATH)
+	set(FSFW_CONFIG_PATH ${CMAKE_CURRENT_SOURCE_DIR})
 endif()
+

From ced753b513f65ed6948e4a3b048bb744b2c04805 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 1 Jan 2021 18:06:33 +0100
Subject: [PATCH 1333/1774] include guard

---
 defaultcfg/fsfwconfig/objects/FsfwFactory.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/defaultcfg/fsfwconfig/objects/FsfwFactory.h b/defaultcfg/fsfwconfig/objects/FsfwFactory.h
index 2724d2e3e..198b22f28 100644
--- a/defaultcfg/fsfwconfig/objects/FsfwFactory.h
+++ b/defaultcfg/fsfwconfig/objects/FsfwFactory.h
@@ -1,5 +1,5 @@
-#ifndef FACTORY_H_
-#define FACTORY_H_
+#ifndef FSFWCONFIG_OBJECTS_FACTORY_H_
+#define FSFWCONFIG_OBJECTS_FACTORY_H_
 
 #include <fsfw/objectmanager/SystemObjectIF.h>
 #include <cstddef>
@@ -14,4 +14,4 @@ namespace Factory {
 }
 
 
-#endif /* FACTORY_H_ */
+#endif /* FSFWCONFIG_OBJECTS_FACTORY_H_ */

From 4de5fc44b429812c1de1da77c8745157a06d045f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 1 Jan 2021 21:19:42 +0100
Subject: [PATCH 1334/1774] rtems init

---
 osal/rtems/CMakeLists.txt         | 18 ++++++++++++++++++
 osal/rtems/Clock.cpp              |  5 ++++-
 osal/rtems/InternalErrorCodes.cpp |  2 ++
 3 files changed, 24 insertions(+), 1 deletion(-)
 create mode 100644 osal/rtems/CMakeLists.txt

diff --git a/osal/rtems/CMakeLists.txt b/osal/rtems/CMakeLists.txt
new file mode 100644
index 000000000..bff031842
--- /dev/null
+++ b/osal/rtems/CMakeLists.txt
@@ -0,0 +1,18 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		CpuUsage.cpp
+		InitTask.cpp
+		InternalErrorCodes.cpp
+		MessageQueue.cpp
+		MultiObjectTask.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PollingTask.cpp
+		QueueFactory.cpp
+		RtemsBasic.cpp
+		TaskBase.cpp
+		TaskFactory.cpp
+)
+
+
diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index e5f37ec6a..aa135adea 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -1,5 +1,8 @@
-#include "../../timemanager/Clock.h"
 #include "RtemsBasic.h"
+
+#include "../../timemanager/Clock.h"
+#include "../../ipc/MutexHelper.h"
+
 #include <rtems/score/todimpl.h>
 
 uint16_t Clock::leapSeconds = 0;
diff --git a/osal/rtems/InternalErrorCodes.cpp b/osal/rtems/InternalErrorCodes.cpp
index ddf365d5f..f40798147 100644
--- a/osal/rtems/InternalErrorCodes.cpp
+++ b/osal/rtems/InternalErrorCodes.cpp
@@ -34,8 +34,10 @@ ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
 		return OUT_OF_PROXIES;
 	case INTERNAL_ERROR_INVALID_GLOBAL_ID:
 		return INVALID_GLOBAL_ID;
+#ifndef STM32H743ZI_NUCLEO
 	case INTERNAL_ERROR_BAD_STACK_HOOK:
 		return BAD_STACK_HOOK;
+#endif
 //	case INTERNAL_ERROR_BAD_ATTRIBUTES:
 //		return BAD_ATTRIBUTES;
 //	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:

From e5b3f991efbf74cd7d50c74ed774779b25b7c56c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 2 Jan 2021 19:39:02 +0100
Subject: [PATCH 1335/1774] added important rtems include

---
 osal/rtems/Clock.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index aa135adea..dda154648 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -4,6 +4,7 @@
 #include "../../ipc/MutexHelper.h"
 
 #include <rtems/score/todimpl.h>
+#include <rtems/rtems/clockimpl.h>
 
 uint16_t Clock::leapSeconds = 0;
 MutexIF* Clock::timeMutex = nullptr;

From 4c07ca21eb7c9c36c49608107afc687ea08e53cd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 2 Jan 2021 19:40:00 +0100
Subject: [PATCH 1336/1774] important include fix

---
 osal/rtems/Clock.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index aa135adea..dda154648 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -4,6 +4,7 @@
 #include "../../ipc/MutexHelper.h"
 
 #include <rtems/score/todimpl.h>
+#include <rtems/rtems/clockimpl.h>
 
 uint16_t Clock::leapSeconds = 0;
 MutexIF* Clock::timeMutex = nullptr;

From 7759b19961a9892d9f1473c49fe64f450dee468d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 2 Jan 2021 23:22:50 +0100
Subject: [PATCH 1337/1774] added new files

---
 serviceinterface/CMakeLists.txt              | 8 ++++----
 serviceinterface/ServiceInterfacePrinter.cpp | 2 ++
 serviceinterface/ServiceInterfacePrinter.h   | 0
 3 files changed, 6 insertions(+), 4 deletions(-)
 create mode 100644 serviceinterface/ServiceInterfacePrinter.cpp
 create mode 100644 serviceinterface/ServiceInterfacePrinter.h

diff --git a/serviceinterface/CMakeLists.txt b/serviceinterface/CMakeLists.txt
index d84adbeb4..84c791770 100644
--- a/serviceinterface/CMakeLists.txt
+++ b/serviceinterface/CMakeLists.txt
@@ -1,5 +1,5 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		ServiceInterfaceStream.cpp
-		ServiceInterfaceBuffer.cpp
+target_sources(${LIB_FSFW_NAME} PRIVATE 
+	ServiceInterfaceStream.cpp
+	ServiceInterfaceBuffer.cpp
+	ServiceInterfacePrinter.cpp
 )
\ No newline at end of file
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
new file mode 100644
index 000000000..4c4c28cb8
--- /dev/null
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -0,0 +1,2 @@
+#include "ServiceInterfacePrinter.h"
+
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
new file mode 100644
index 000000000..e69de29bb

From b30405fee73317379f6c959adce720d5ba677a23 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 01:02:07 +0100
Subject: [PATCH 1338/1774] added stdio pinters

---
 defaultcfg/fsfwconfig/FSFWConfig.h           |  14 ++-
 serviceinterface/ServiceInterfaceBuffer.h    |   3 +-
 serviceinterface/ServiceInterfacePrinter.cpp | 102 +++++++++++++++++++
 serviceinterface/ServiceInterfacePrinter.h   |  33 ++++++
 4 files changed, 149 insertions(+), 3 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index e1815d050..d94f6cc7e 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -4,14 +4,20 @@
 #include <cstddef>
 #include <cstdint>
 
-//! Used to determine whether C++ ostreams are used
-//! Those can lead to code bloat.
+//! Used to determine whether C++ ostreams are used which can increase
+//! the binary size significantly. If this is disabled,
+//! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
 //! Reduced printout to further decrease code size
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_ENHANCED_PRINTOUT		0
 
+//! Can be used to completely disable printouts, even the C stdio ones.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	#define FSFW_DISABLE_PRINTOUT 	0
+#endif
+
 //! Can be used to enable additional debugging printouts for developing the FSFW
 #define FSFW_PRINT_VERBOSITY_LEVEL   0
 
@@ -20,6 +26,8 @@
 //! and translateEvents (and their compiled source files)
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
+#define FSFW_COLORED_OUTPUT 		1
+
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
@@ -50,6 +58,8 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 //! simulataneously. This will increase the required RAM for
 //! each CSB service !
 static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
+
+static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index c5d5b2584..c953846df 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -2,6 +2,7 @@
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
+#include <FSFWConfig.h>
 #include <iostream>
 #include <sstream>
 #include <iomanip>
@@ -54,7 +55,7 @@ private:
 	bool errStream;
 
 	//! Needed for buffered mode.
-	static size_t const BUF_SIZE = 128;
+	static size_t const BUF_SIZE = fsfwconfig::FSFW_PRINT_BUFFER_SIZE;
 	char buf[BUF_SIZE];
 
 	//! In this function, the characters are parsed.
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index 4c4c28cb8..04430d61f 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -1,2 +1,104 @@
 #include "ServiceInterfacePrinter.h"
 
+#include "../timemanager/Clock.h"
+
+#include <FSFWConfig.h>
+#include <cstdarg>
+#include <cstdint>
+
+
+fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
+uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
+
+void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
+    uint32_t len = 0;
+
+    /* Check logger level */
+    if(printType == fsfw::PrintLevel::NONE or printType > printLevel) {
+        return;
+    }
+
+    /* Log message to terminal */
+
+#if FSFW_COLORED_OUTPUT == 1
+    if(printType == fsfw::PrintLevel::INFO) {
+    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_GREEN);
+    }
+    else if(printType == fsfw::PrintLevel::DEBUG) {
+    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_BLUE);
+    }
+    else if(printType == fsfw::PrintLevel::WARNING) {
+    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_YELLOW);
+    }
+    else if(printType == fsfw::PrintLevel::ERROR_TYPE) {
+    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_RED);
+    }
+#endif
+
+   if (printType == fsfw::PrintLevel::INFO) {
+       len += sprintf((char *)printBuffer + len, "INFO: ");
+   }
+   if(printType == fsfw::PrintLevel::DEBUG) {
+	   len += sprintf((char *)printBuffer + len, "DEBUG: ");
+   }
+   if(printType == fsfw::PrintLevel::WARNING) {
+	   len += sprintf((char *)printBuffer + len, "WARNING: ");
+   }
+
+   if(printType == fsfw::PrintLevel::ERROR_TYPE) {
+	   len += sprintf((char *)printBuffer + len, "ERROR: ");
+   }
+
+    Clock::TimeOfDay_t now;
+    Clock::getDateAndTime(&now);
+    /*
+     * Log current time to terminal if desired.
+     */
+    len += sprintf((char*)printBuffer + len, "| %lu:%02lu:%02lu.%03lu | ",
+    		(unsigned long) now.hour,
+			(unsigned long) now.minute,
+			(unsigned long) now.second,
+			(unsigned long) now.usecond /1000);
+
+    //changed Jan 2017.  Need to update length with buffer size
+    len += vsnprintf((char *)(printBuffer + len),
+    		sizeof(printBuffer)-len, fmt, arg);
+
+    printf("%s", printBuffer);
+}
+
+void fsfw::setPrintLevel(PrintLevel printLevel_) {
+	printLevel = printLevel_;
+}
+
+fsfw::PrintLevel fsfw::getPrintLevel() {
+	return printLevel;
+}
+
+void fsfw::printInfo(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(fsfw::PrintLevel::INFO, fmt, args);
+    va_end(args);
+}
+
+void fsfw::printWarning(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(fsfw::PrintLevel::WARNING, fmt, args);
+    va_end(args);
+}
+
+void fsfw::printDebug(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(fsfw::PrintLevel::DEBUG, fmt, args);
+    va_end(args);
+}
+
+void fsfw::printError(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(fsfw::PrintLevel::ERROR_TYPE, fmt, args);
+    va_end(args);
+}
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index e69de29bb..a2ba483db 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -0,0 +1,33 @@
+#include <stdio.h>
+
+namespace fsfw {
+
+enum class PrintLevel {
+	NONE = 0,
+	//! Strange error when using just ERROR..
+	ERROR_TYPE = 1,
+	WARNING = 2,
+	INFO = 3,
+	DEBUG = 4
+};
+
+
+static const char* const ANSI_COLOR_RED = "\x1b[31m";
+static const char* const ANSI_COLOR_GREEN = "\x1b[32m";
+static const char* const ANSI_COLOR_YELLOW = "\x1b[33m";
+static const char* const ANSI_COLOR_BLUE = "\x1b[34m";
+static const char* const ANSI_COLOR_MAGENTA = "\x1b[35m";
+static const char* const ANSI_COLOR_CYAN = "\x1b[36m";
+static const char* const ANSI_COLOR_RESET = "\x1b[0m";
+
+void setPrintLevel(PrintLevel printLevel);
+PrintLevel getPrintLevel();
+
+
+void printInfo(const char *fmt, ...);
+void printWarning(const char* fmt, ...);
+void printDebug(const char* fmt, ...);
+void printError(const char* fmt, ...);
+
+}
+

From 0e2875b22d20c68408b052d37c0ff0e69e37b903 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 01:35:17 +0100
Subject: [PATCH 1339/1774] added colored output for streams as well

---
 defaultcfg/fsfwconfig/FSFWConfig.h            |  9 ++++----
 serviceinterface/ServiceInterfaceBuffer.cpp   | 23 +++++++++++++++++++
 serviceinterface/ServiceInterfaceBuffer.h     |  5 ++++
 serviceinterface/ServiceInterfacePrinter.cpp  |  4 +++-
 serviceinterface/ServiceInterfacePrinter.h    |  9 --------
 serviceinterface/ServiceInterfaceStream.cpp   | 17 --------------
 serviceinterface/ServiceInterfaceStream.h     |  7 ------
 serviceinterface/serviceInterfaceDefintions.h | 16 +++++++++++++
 8 files changed, 52 insertions(+), 38 deletions(-)
 create mode 100644 serviceinterface/serviceInterfaceDefintions.h

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index d94f6cc7e..261e3d6d2 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -9,25 +9,26 @@
 //! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrease code size
+//! More FSFW related printouts.
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_ENHANCED_PRINTOUT		0
 
 //! Can be used to completely disable printouts, even the C stdio ones.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
 	#define FSFW_DISABLE_PRINTOUT 	0
 #endif
 
 //! Can be used to enable additional debugging printouts for developing the FSFW
 #define FSFW_PRINT_VERBOSITY_LEVEL   0
 
+//! Can be used to disable the ANSI color sequences for C stdio.
+#define FSFW_COLORED_OUTPUT 		1
+
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
-#define FSFW_COLORED_OUTPUT 		1
-
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 68fc4dec3..eb940cfab 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,5 +1,7 @@
 #include "../timemanager/Clock.h"
 #include "ServiceInterfaceBuffer.h"
+#include "serviceInterfaceDefintions.h"
+#include <FSFWConfig.h>
 #include <cstring>
 #include <inttypes.h>
 
@@ -17,6 +19,21 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 		// Set pointers if the stream is buffered.
 		setp( buf, buf + BUF_SIZE );
 	}
+
+#if FSFW_COLORED_OUTPUT == 1
+	if(setMessage.find("DEBUG")) {
+		colorPrefix = fsfw::ANSI_COLOR_MAGENTA;
+	}
+	else if(setMessage.find("INFO")) {
+		colorPrefix = fsfw::ANSI_COLOR_GREEN;
+	}
+	else if(setMessage.find("WARNING")) {
+		colorPrefix = fsfw::ANSI_COLOR_YELLOW;
+	}
+	else if(setMessage.find("ERROR")) {
+		colorPrefix = fsfw::ANSI_COLOR_RED;
+	}
+#endif
 	preamble.reserve(MAX_PREAMBLE_SIZE);
 	preamble.resize(MAX_PREAMBLE_SIZE);
 }
@@ -102,6 +119,12 @@ std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 		currentSize += 1;
 		parsePosition += 1;
 	}
+
+#if FSFW_COLORED_OUTPUT == 1
+	currentSize += sprintf(parsePosition, "%s", colorPrefix.c_str());
+	parsePosition += colorPrefix.size();
+#endif
+
 	int32_t charCount = sprintf(parsePosition,
 			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
 					this->logMessage.c_str(), loggerTime.hour,
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index c953846df..8f2a601c2 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -42,6 +42,11 @@ private:
 	//! For additional message information
 	std::string logMessage;
 	std::string preamble;
+
+#if FSFW_COLORED_OUTPUT == 1
+	std::string colorPrefix;
+#endif
+
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
 
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index 04430d61f..177d7c4ae 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -1,8 +1,10 @@
 #include "ServiceInterfacePrinter.h"
+#include "serviceInterfaceDefintions.h"
 
 #include "../timemanager/Clock.h"
 
 #include <FSFWConfig.h>
+
 #include <cstdarg>
 #include <cstdint>
 
@@ -25,7 +27,7 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_GREEN);
     }
     else if(printType == fsfw::PrintLevel::DEBUG) {
-    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_BLUE);
+    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_MAGENTA);
     }
     else if(printType == fsfw::PrintLevel::WARNING) {
     	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_YELLOW);
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index a2ba483db..1991f412b 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -11,15 +11,6 @@ enum class PrintLevel {
 	DEBUG = 4
 };
 
-
-static const char* const ANSI_COLOR_RED = "\x1b[31m";
-static const char* const ANSI_COLOR_GREEN = "\x1b[32m";
-static const char* const ANSI_COLOR_YELLOW = "\x1b[33m";
-static const char* const ANSI_COLOR_BLUE = "\x1b[34m";
-static const char* const ANSI_COLOR_MAGENTA = "\x1b[35m";
-static const char* const ANSI_COLOR_CYAN = "\x1b[36m";
-static const char* const ANSI_COLOR_RESET = "\x1b[0m";
-
 void setPrintLevel(PrintLevel printLevel);
 PrintLevel getPrintLevel();
 
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 5b7b9f004..056434604 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -13,20 +13,3 @@ std::string* ServiceInterfaceStream::getPreamble() {
 	return streambuf.getPreamble();
 }
 
-void ServiceInterfaceStream::print(std::string error,
-		bool withPreamble, bool withNewline, bool flush) {
-	if(not streambuf.isBuffered() and withPreamble) {
-		*this << getPreamble() << error;
-	}
-	else {
-		*this << error;
-	}
-
-	if(withNewline) {
-		*this << "\n";
-	}
-	// if mode is non-buffered, no need to flush.
-	if(flush and streambuf.isBuffered()) {
-		this->flush();
-	}
-}
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 76fa1bf23..cd2adf859 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -35,13 +35,6 @@ public:
 	 */
 	std::string* getPreamble();
 
-	/**
-	 * This prints an error with a preamble. Useful if using the unbuffered
-	 * mode. Flushes in default mode (prints immediately).
-	 */
-	void print(std::string error, bool withPreamble = true,
-			bool withNewline = true, bool flush = true);
-
 protected:
 	ServiceInterfaceBuffer streambuf;
 };
diff --git a/serviceinterface/serviceInterfaceDefintions.h b/serviceinterface/serviceInterfaceDefintions.h
new file mode 100644
index 000000000..684c73668
--- /dev/null
+++ b/serviceinterface/serviceInterfaceDefintions.h
@@ -0,0 +1,16 @@
+#ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
+#define FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
+
+namespace fsfw {
+
+static const char* const ANSI_COLOR_RED = "\x1b[31m";
+static const char* const ANSI_COLOR_GREEN = "\x1b[32m";
+static const char* const ANSI_COLOR_YELLOW = "\x1b[33m";
+static const char* const ANSI_COLOR_BLUE = "\x1b[34m";
+static const char* const ANSI_COLOR_MAGENTA = "\x1b[35m";
+static const char* const ANSI_COLOR_CYAN = "\x1b[36m";
+static const char* const ANSI_COLOR_RESET = "\x1b[0m";
+
+}
+
+#endif /* FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_ */

From 5c42888f10c10e42f1c90de98e17feb9fc560cae Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 01:39:06 +0100
Subject: [PATCH 1340/1774] whitespace

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index eb940cfab..bbfb69c7b 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -34,6 +34,7 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 		colorPrefix = fsfw::ANSI_COLOR_RED;
 	}
 #endif
+
 	preamble.reserve(MAX_PREAMBLE_SIZE);
 	preamble.resize(MAX_PREAMBLE_SIZE);
 }

From e300207f48d8c4a6790c37c360ce88dab007be54 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 01:40:35 +0100
Subject: [PATCH 1341/1774] removed comment

---
 serviceinterface/ServiceInterfacePrinter.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index 177d7c4ae..5ab9e425c 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -62,7 +62,6 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 			(unsigned long) now.second,
 			(unsigned long) now.usecond /1000);
 
-    //changed Jan 2017.  Need to update length with buffer size
     len += vsnprintf((char *)(printBuffer + len),
     		sizeof(printBuffer)-len, fmt, arg);
 

From 717027792e830dc046209842500a7aa74761c51e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 01:47:01 +0100
Subject: [PATCH 1342/1774] minor improvements and docuemntation

---
 serviceinterface/ServiceInterfacePrinter.cpp | 22 ++++++++++----------
 serviceinterface/ServiceInterfacePrinter.h   |  8 ++++++-
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index 5ab9e425c..f67dfb53c 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -14,6 +14,7 @@ uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 
 void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     uint32_t len = 0;
+    char* bufferPosition = reinterpret_cast<char*>(printBuffer);
 
     /* Check logger level */
     if(printType == fsfw::PrintLevel::NONE or printType > printLevel) {
@@ -24,31 +25,31 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 
 #if FSFW_COLORED_OUTPUT == 1
     if(printType == fsfw::PrintLevel::INFO) {
-    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_GREEN);
+    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_GREEN);
     }
     else if(printType == fsfw::PrintLevel::DEBUG) {
-    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_MAGENTA);
+    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_MAGENTA);
     }
     else if(printType == fsfw::PrintLevel::WARNING) {
-    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_YELLOW);
+    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_YELLOW);
     }
     else if(printType == fsfw::PrintLevel::ERROR_TYPE) {
-    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_RED);
+    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_RED);
     }
 #endif
 
    if (printType == fsfw::PrintLevel::INFO) {
-       len += sprintf((char *)printBuffer + len, "INFO: ");
+       len += sprintf(bufferPosition + len, "INFO: ");
    }
    if(printType == fsfw::PrintLevel::DEBUG) {
-	   len += sprintf((char *)printBuffer + len, "DEBUG: ");
+	   len += sprintf(bufferPosition + len, "DEBUG: ");
    }
    if(printType == fsfw::PrintLevel::WARNING) {
-	   len += sprintf((char *)printBuffer + len, "WARNING: ");
+	   len += sprintf(bufferPosition + len, "WARNING: ");
    }
 
    if(printType == fsfw::PrintLevel::ERROR_TYPE) {
-	   len += sprintf((char *)printBuffer + len, "ERROR: ");
+	   len += sprintf(bufferPosition + len, "ERROR: ");
    }
 
     Clock::TimeOfDay_t now;
@@ -56,14 +57,13 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     /*
      * Log current time to terminal if desired.
      */
-    len += sprintf((char*)printBuffer + len, "| %lu:%02lu:%02lu.%03lu | ",
+    len += sprintf(bufferPosition + len, "| %lu:%02lu:%02lu.%03lu | ",
     		(unsigned long) now.hour,
 			(unsigned long) now.minute,
 			(unsigned long) now.second,
 			(unsigned long) now.usecond /1000);
 
-    len += vsnprintf((char *)(printBuffer + len),
-    		sizeof(printBuffer)-len, fmt, arg);
+    len += vsnprintf(bufferPosition + len, sizeof(printBuffer) - len, fmt, arg);
 
     printf("%s", printBuffer);
 }
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index 1991f412b..8b81ee7a0 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -14,7 +14,13 @@ enum class PrintLevel {
 void setPrintLevel(PrintLevel printLevel);
 PrintLevel getPrintLevel();
 
-
+/**
+ * These functions can be used like the C stdio printf and forward the
+ * supplied formatted string arguments to a printf function.
+ * They prepend the string with a color (if enabled), a log preamble and
+ * a timestamp.
+ * @param fmt Formatted string
+ */
 void printInfo(const char *fmt, ...);
 void printWarning(const char* fmt, ...);
 void printDebug(const char* fmt, ...);

From 087482300d0177e7297a7749adf279959b34625f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 01:49:12 +0100
Subject: [PATCH 1343/1774] include order

---
 serviceinterface/ServiceInterfacePrinter.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index f67dfb53c..369edd0fb 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -1,10 +1,8 @@
+#include <FSFWConfig.h>
 #include "ServiceInterfacePrinter.h"
 #include "serviceInterfaceDefintions.h"
-
 #include "../timemanager/Clock.h"
 
-#include <FSFWConfig.h>
-
 #include <cstdarg>
 #include <cstdint>
 
@@ -13,7 +11,7 @@ fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
 uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 
 void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
-    uint32_t len = 0;
+    size_t len = 0;
     char* bufferPosition = reinterpret_cast<char*>(printBuffer);
 
     /* Check logger level */

From 61fc6cac97e8febcc2dfcff7956819b8737d3a64 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 13:25:42 +0100
Subject: [PATCH 1344/1774] added change for windows

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index bbfb69c7b..222c1e2c4 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -5,6 +5,10 @@
 #include <cstring>
 #include <inttypes.h>
 
+#if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
+#include "Windows.h"
+#endif
+
 // to be implemented by bsp
 extern "C" void printChar(const char*, bool errStream);
 
@@ -33,6 +37,15 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 	else if(setMessage.find("ERROR")) {
 		colorPrefix = fsfw::ANSI_COLOR_RED;
 	}
+
+#ifdef WIN32
+	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+	DWORD dwMode = 0;
+	GetConsoleMode(hOut, &dwMode);
+	dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+	SetConsoleMode(hOut, dwMode);
+#endif
+
 #endif
 
 	preamble.reserve(MAX_PREAMBLE_SIZE);

From c19e628d7971e23b64ce87f36bd1f6b2caf2a113 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 13:58:18 +0100
Subject: [PATCH 1345/1774] all cstdout uses wrapped in preprocessor defines

---
 container/SharedRingBuffer.cpp                |  2 ++
 controller/ExtendedControllerBase.cpp         |  2 ++
 datalinklayer/Clcw.cpp                        |  2 ++
 datalinklayer/DataLinkLayer.cpp               |  4 +++
 datalinklayer/MapPacketExtraction.cpp         | 12 +++++++
 datalinklayer/TcTransferFrame.cpp             | 23 ++++++++----
 datalinklayer/TcTransferFrameLocal.cpp        |  2 ++
 datalinklayer/VirtualChannelReception.cpp     |  2 ++
 datapool/PoolDataSetBase.cpp                  | 10 ++++++
 datapool/PoolEntry.cpp                        |  6 ++++
 datapoollocal/HasLocalDataPoolIF.h            |  2 ++
 datapoollocal/LocalDataPoolManager.cpp        | 28 +++++++++++++++
 datapoollocal/LocalDataPoolManager.h          |  4 +++
 datapoollocal/LocalPoolDataSetBase.cpp        |  8 +++++
 datapoollocal/LocalPoolObjectBase.cpp         |  8 +++++
 datapoollocal/LocalPoolVariable.tpp           |  8 +++++
 datapoollocal/LocalPoolVector.tpp             | 12 +++++++
 datapoollocal/PoolReadHelper.h                |  2 ++
 .../PollingSequenceFactory.cpp                |  2 ++
 devicehandlers/DeviceHandlerBase.cpp          | 20 +++++++++++
 .../DeviceHandlerFailureIsolation.cpp         |  4 +++
 events/EventManager.cpp                       |  7 ++--
 fdir/FailureIsolationBase.cpp                 |  8 +++++
 globalfunctions/arrayprinter.cpp              | 10 +++++-
 health/HealthHelper.cpp                       |  8 +++++
 internalError/InternalErrorReporter.cpp       |  4 ++-
 ipc/MessageQueueMessage.cpp                   |  4 +++
 ipc/MutexHelper.h                             |  4 +++
 memory/MemoryHelper.cpp                       |  2 ++
 monitoring/MonitoringMessageContent.h         |  2 ++
 objectmanager/ObjectManager.cpp               | 24 ++++++++++++-
 objectmanager/ObjectManagerIF.h               |  2 ++
 osal/FreeRTOS/BinSemaphUsingTask.cpp          |  2 ++
 osal/FreeRTOS/BinarySemaphore.cpp             |  6 ++++
 osal/FreeRTOS/CountingSemaphUsingTask.cpp     |  6 ++++
 osal/FreeRTOS/CountingSemaphore.cpp           |  8 +++++
 osal/FreeRTOS/FixedTimeslotTask.cpp           |  6 ++++
 osal/FreeRTOS/MessageQueue.cpp                |  3 ++
 osal/FreeRTOS/Mutex.cpp                       |  2 ++
 osal/FreeRTOS/PeriodicTask.cpp                |  6 ++++
 osal/FreeRTOS/SemaphoreFactory.cpp            |  4 +++
 osal/host/Clock.cpp                           | 16 +++++++++
 osal/host/FixedTimeslotTask.cpp               |  8 +++++
 osal/host/MessageQueue.cpp                    |  4 +++
 osal/host/PeriodicTask.cpp                    |  6 ++++
 osal/host/QueueMapManager.cpp                 |  4 +++
 osal/host/SemaphoreFactory.cpp                |  4 +++
 osal/linux/BinarySemaphore.cpp                |  6 ++++
 osal/linux/Clock.cpp                          |  2 ++
 osal/linux/CountingSemaphore.cpp              |  2 ++
 osal/linux/FixedTimeslotTask.cpp              |  4 +++
 osal/linux/MessageQueue.cpp                   | 35 ++++++++++++++++++-
 osal/linux/Mutex.cpp                          |  8 +++++
 osal/linux/PeriodicPosixTask.cpp              |  8 +++++
 osal/linux/PosixThread.cpp                    | 32 +++++++++++++++++
 osal/linux/TcUnixUdpPollingTask.cpp           | 18 ++++++++++
 osal/linux/Timer.cpp                          |  2 ++
 osal/linux/TmTcUnixUdpBridge.cpp              | 24 +++++++++++++
 osal/rtems/MessageQueue.cpp                   |  2 ++
 osal/rtems/MultiObjectTask.cpp                |  4 +++
 osal/rtems/Mutex.cpp                          |  4 +++
 osal/rtems/PollingTask.cpp                    |  8 +++++
 osal/rtems/TaskBase.cpp                       |  2 ++
 osal/windows/TcWinUdpPollingTask.cpp          | 24 +++++++++++++
 osal/windows/TmTcWinUdpBridge.cpp             | 30 ++++++++++++++++
 parameters/ParameterHelper.cpp                |  2 ++
 pus/CService201HealthCommanding.cpp           |  2 ++
 pus/Service1TelecommandVerification.cpp       |  4 +++
 pus/Service2DeviceAccess.cpp                  |  6 ++++
 pus/Service3Housekeeping.cpp                  |  6 ++++
 pus/Service5EventReporting.cpp                |  4 +++
 pus/Service8FunctionManagement.cpp            |  6 ++++
 serialize/SerialBufferAdapter.cpp             |  4 +++
 storagemanager/ConstStorageAccessor.cpp       |  8 +++++
 storagemanager/LocalPool.cpp                  | 16 +++++++++
 storagemanager/PoolManager.cpp                |  2 ++
 storagemanager/StorageAccessor.cpp            | 10 ++++++
 subsystem/SubsystemBase.cpp                   |  2 ++
 tasks/FixedSlotSequence.cpp                   | 12 +++++++
 tcdistribution/CCSDSDistributor.cpp           |  8 +++++
 tcdistribution/PUSDistributor.cpp             | 12 +++++++
 tcdistribution/TcDistributor.cpp              |  3 +-
 timemanager/Stopwatch.cpp                     |  4 +++
 tmtcpacket/pus/TcPacketBase.cpp               |  2 ++
 tmtcpacket/pus/TcPacketStored.cpp             |  6 ++++
 tmtcpacket/pus/TmPacketBase.cpp               |  4 +++
 tmtcpacket/pus/TmPacketStored.cpp             |  2 ++
 tmtcservices/CommandingServiceBase.cpp        |  4 +++
 tmtcservices/PusServiceBase.cpp               |  8 +++++
 tmtcservices/TmTcBridge.cpp                   | 30 ++++++++++++++++
 tmtcservices/VerificationReporter.cpp         | 12 +++++++
 unittest/internal/InternalUnitTester.cpp      |  4 +++
 unittest/internal/UnittDefinitions.cpp        |  2 ++
 unittest/internal/osal/IntTestSemaphore.cpp   |  2 ++
 .../PollingSequenceFactory.cpp                |  2 ++
 .../user/unittest/core/CatchDefinitions.cpp   |  2 ++
 96 files changed, 715 insertions(+), 14 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 6ddb3d3ee..340bce370 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -47,9 +47,11 @@ ReturnValue_t SharedRingBuffer::initialize() {
 DynamicFIFO<size_t>* SharedRingBuffer::getReceiveSizesFIFO() {
 	if(receiveSizesFIFO == nullptr) {
 		// Configuration error.
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
 				<< " was not configured to have sizes FIFO, returning nullptr!"
 				<< std::endl;
+#endif
 	}
 	return receiveSizesFIFO;
 }
diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index fa4f67867..f9f7534d8 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -107,7 +107,9 @@ MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
 }
 
 LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
+#if CPP_OSTREAM_ENABLED == 1
     sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
             << " implementation provided, returning nullptr!" << std::endl;
+#endif
     return nullptr;
 }
diff --git a/datalinklayer/Clcw.cpp b/datalinklayer/Clcw.cpp
index dc435a2b4..19aa4e7b0 100644
--- a/datalinklayer/Clcw.cpp
+++ b/datalinklayer/Clcw.cpp
@@ -55,7 +55,9 @@ void Clcw::setBitLock(bool bitLock) {
 }
 
 void Clcw::print() {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
+#endif
 }
 
 void Clcw::setWhole(uint32_t rawClcw) {
diff --git a/datalinklayer/DataLinkLayer.cpp b/datalinklayer/DataLinkLayer.cpp
index 75f2edda0..6a3838517 100644
--- a/datalinklayer/DataLinkLayer.cpp
+++ b/datalinklayer/DataLinkLayer.cpp
@@ -98,8 +98,10 @@ ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
 	receivedDataLength = length;
 	ReturnValue_t status = allFramesReception();
 	if (status != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataLinkLayer::processFrame: frame reception failed. "
 		         "Error code: " << std::hex << status << std::dec << std::endl;
+#endif
 //		currentFrame.print();
 		return status;
 	} else {
@@ -124,7 +126,9 @@ ReturnValue_t DataLinkLayer::initialize() {
 	if ( virtualChannels.begin() != virtualChannels.end() ) {
 		clcw->setVirtualChannel( virtualChannels.begin()->second->getChannelId() );
 	} else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
+#endif
 		return RETURN_FAILED;
 	}
 
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 845ed7c17..0bf79f425 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -29,9 +29,11 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 			bufferPosition = &packetBuffer[packetLength];
 			status = RETURN_OK;
 		} else {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error
 					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
 					<< packetLength << std::endl;
+#endif
 			clearBuffers();
 			status = CONTENT_TOO_LARGE;
 		}
@@ -51,24 +53,30 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 				}
 				status = RETURN_OK;
 			} else {
+#if CPP_OSTREAM_ENABLED == 1
 				sif::error
 						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
 						<< packetLength << std::endl;
+#endif
 				clearBuffers();
 				status = CONTENT_TOO_LARGE;
 			}
 		} else {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error
 					<< "MapPacketExtraction::extractPackets. Illegal segment! Last flag: "
 					<< (int) lastSegmentationFlag << std::endl;
+#endif
 			clearBuffers();
 			status = ILLEGAL_SEGMENTATION_FLAG;
 		}
 		break;
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error
 				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
 				<< (int) segmentationFlag << std::endl;
+#endif
 		clearBuffers();
 		status = DATA_CORRUPTED;
 		break;
@@ -135,10 +143,14 @@ ReturnValue_t MapPacketExtraction::initialize() {
 }
 
 void MapPacketExtraction::printPacketBuffer(void) {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "DLL: packet_buffer contains: " << std::endl;
+#endif
 	for (uint32_t i = 0; i < this->packetLength; ++i) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
 				<< (uint16_t) this->packetBuffer[i] << std::endl;
+#endif
 	}
 }
 
diff --git a/datalinklayer/TcTransferFrame.cpp b/datalinklayer/TcTransferFrame.cpp
index f1a70bdcf..0050994a5 100644
--- a/datalinklayer/TcTransferFrame.cpp
+++ b/datalinklayer/TcTransferFrame.cpp
@@ -87,16 +87,25 @@ uint8_t* TcTransferFrame::getFullDataField() {
 }
 
 void TcTransferFrame::print() {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Raw Frame: " << std::hex << std::endl;
 	for (uint16_t count = 0; count < this->getFullSize(); count++ ) {
 		sif::debug << (uint16_t)this->getFullFrame()[count] << " ";
 	}
 	sif::debug << std::dec << std::endl;
-//	debug << "Frame Header:" << std::endl;
-//	debug << "Version Number: " << std::hex << (uint16_t)this->current_frame.getVersionNumber() << std::endl;
-//	debug << "Bypass Flag set?| Ctrl Cmd Flag set?: " << (uint16_t)this->current_frame.bypassFlagSet() << " | " << (uint16_t)this->current_frame.controlCommandFlagSet()  << std::endl;
-//	debug << "SCID : " << this->current_frame.getSpacecraftId() << std::endl;
-//	debug << "VCID : " << (uint16_t)this->current_frame.getVirtualChannelId() << std::endl;
-//	debug << "Frame length: " << std::dec << this->current_frame.getFrameLength() << std::endl;
-//	debug << "Sequence Number: " << (uint16_t)this->current_frame.getSequenceNumber() << std::endl;
+
+	sif::debug << "Frame Header:" << std::endl;
+	sif::debug << "Version Number: " << std::hex
+			<< (uint16_t)this->getVersionNumber() << std::endl;
+	sif::debug << "Bypass Flag set?| Ctrl Cmd Flag set?: "
+			<< (uint16_t)this->bypassFlagSet() << " | "
+			<< (uint16_t)this->controlCommandFlagSet()  << std::endl;
+	sif::debug << "SCID : " << this->getSpacecraftId() << std::endl;
+	sif::debug << "VCID : " << (uint16_t)this->getVirtualChannelId()
+			<< std::endl;
+	sif::debug << "Frame length: " << std::dec << this->getFrameLength()
+			<< std::endl;
+	sif::debug << "Sequence Number: " << (uint16_t)this->getSequenceNumber()
+			<< std::endl;
+#endif
 }
diff --git a/datalinklayer/TcTransferFrameLocal.cpp b/datalinklayer/TcTransferFrameLocal.cpp
index e8785c92a..1ef772a22 100644
--- a/datalinklayer/TcTransferFrameLocal.cpp
+++ b/datalinklayer/TcTransferFrameLocal.cpp
@@ -37,7 +37,9 @@ TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uin
 			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
 			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
 		} else {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
+#endif
 		}
 	} else {
 		//No data in frame
diff --git a/datalinklayer/VirtualChannelReception.cpp b/datalinklayer/VirtualChannelReception.cpp
index cde28de37..8ad65740d 100644
--- a/datalinklayer/VirtualChannelReception.cpp
+++ b/datalinklayer/VirtualChannelReception.cpp
@@ -102,8 +102,10 @@ uint8_t VirtualChannelReception::getChannelId() const {
 ReturnValue_t VirtualChannelReception::initialize() {
 	ReturnValue_t returnValue = RETURN_FAILED;
 	if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
 				<< (int) slidingWindowWidth << std::endl;
+#endif
 		return RETURN_FAILED;
 	}
 	for (mapChannelIterator iterator = mapChannels.begin(); iterator != mapChannels.end();
diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 8f0733594..f2c2b8679 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -13,18 +13,24 @@ PoolDataSetBase::~PoolDataSetBase() {}
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
 	if (state != States::STATE_SET_UNINITIALISED) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::registerVariable: "
 				"Call made in wrong position." << std::endl;
+#endif
 		return DataSetIF::DATA_SET_UNINITIALISED;
 	}
 	if (variable == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::registerVariable: "
 				"Pool variable is nullptr." << std::endl;
+#endif
 		return DataSetIF::POOL_VAR_NULL;
 	}
 	if (fillCount >= maxFillCount) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::registerVariable: "
 				"DataSet is full." << std::endl;
+#endif
 		return DataSetIF::DATA_SET_FULL;
 	}
 	registeredVariables[fillCount] = variable;
@@ -47,9 +53,11 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 		unlockDataPool();
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::read(): "
 				"Call made in wrong position. Don't forget to commit"
 				" member datasets!" << std::endl;
+#endif
 		result = SET_WAS_ALREADY_READ;
 	}
 
@@ -138,8 +146,10 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 		} else if (registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if (result != COMMITING_WITHOUT_READING) {
+#if CPP_OSTREAM_ENABLED == 1
 				sif::error << "DataSet::commit(): commit-without-read call made "
 						"with non write-only variable." << std::endl;
+#endif
 				result = COMMITING_WITHOUT_READING;
 			}
 		}
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index fb73328ca..b1ccb260a 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -12,9 +12,11 @@ PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
 		std::memset(this->address, 0, this->getByteSize());
 	}
 	else if (initValue.size() != setLength){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "PoolEntry: setLength is not equal to initializer list"
 				"length! Performing zero initialization with given setLength"
 				<< std::endl;
+#endif
 		std::memset(this->address, 0, this->getByteSize());
 	}
 	else {
@@ -67,10 +69,14 @@ bool PoolEntry<T>::getValid() {
 
 template <typename T>
 void PoolEntry<T>::print() {
+#if CPP_OSTREAM_ENABLED == 1
 	 sif::debug << "Pool Entry Validity: " <<
 			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
+#endif
 	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << std::dec << std::endl;
+#endif
 }
 
 template<typename T>
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index df8551101..e94af1674 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -89,8 +89,10 @@ public:
 	 * @return
 	 */
 	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
 	            << ". Returning nullptr!" << std::endl;
+#endif
 	    return nullptr;
 	}
 
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 5f0d15d3c..0eb6f5f5d 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -21,15 +21,19 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
                         appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                 << "Invalid supplied owner!" << std::endl;
+#endif
         return;
     }
     this->owner = owner;
     mutex = MutexFactory::instance()->createMutex();
     if(mutex == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                 << "Could not create mutex." << std::endl;
+#endif
     }
 
     hkQueue = queueToUse;
@@ -39,17 +43,21 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::initialize: "
                 << std::hex << "0x" << owner->getObjectId() << ". Supplied "
                 << "queue invalid!" << std::dec << std::endl;
+#endif
     }
     hkQueue = queueToUse;
 
     ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
     if(ipcStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::initialize: "
                 << std::hex << "0x" << owner->getObjectId() << ": Could not "
                 << "set IPC store." <<std::dec << std::endl;
+#endif
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
@@ -61,8 +69,10 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
             hkDestinationId = hkPacketReceiver->getHkQueue();
         }
         else {
+#if CPP_OSTREAM_ENABLED == 1
             sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                     << "Default HK destination object is invalid!" << std::endl;
+#endif
             return HasReturnvaluesIF::RETURN_FAILED;
         }
     }
@@ -85,8 +95,10 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
         }
         return result;
     }
+#if CPP_OSTREAM_ENABLED == 1
     sif::warning << "HousekeepingManager: The map should only be initialized "
             << "once!" << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -339,8 +351,10 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
                 << " Invalid receiver!"<< std::endl;
+#endif
         return HasReturnvaluesIF::RETURN_OK;
     }
 
@@ -369,8 +383,10 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
                 << " Invalid receiver!"<< std::endl;
+#endif
         return HasReturnvaluesIF::RETURN_OK;
     }
 
@@ -575,8 +591,10 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
         lp_id_t localPoolId) {
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "HousekeepingManager::fechPoolEntry:"
                 << " Pool entry not found." << std::endl;
+#endif
         return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
     poolIter->second->print();
@@ -596,8 +614,10 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t destination) {
     if(dataSet == nullptr) {
         // Configuration error.
+#if CPP_OSTREAM_ENABLED == 1
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
                 << " Set ID not found or dataset not assigned!" << std::endl;
+#endif
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
@@ -678,10 +698,12 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
             sid, dataSet, true);
     if(result != HasReturnvaluesIF::RETURN_OK) {
         // configuration error
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "LocalDataPoolManager::performHkOperation:"
                 << "0x" << std::hex << std::setfill('0') << std::setw(8)
                 << owner->getObjectId() << " Error generating "
                 << "HK packet" << std::setfill(' ') << std::dec << std::endl;
+#endif
     }
 }
 
@@ -726,8 +748,10 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     // Get and check dataset first.
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
                 << " Set ID not found" << std::endl;
+#endif
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
@@ -752,8 +776,10 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
             expectedSize,&storePtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "HousekeepingManager::generateHousekeepingPacket: "
                 << "Could not get free element from IPC store." << std::endl;
+#endif
         return result;
     }
 
@@ -762,8 +788,10 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     result = setPacket.serialize(&storePtr, &size, expectedSize,
             SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "HousekeepingManager::generateSetStructurePacket: "
                 << "Expected size is not equal to serialized size" << std::endl;
+#endif
     }
 
     // Send structure reporting reply.
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index cdefa2c29..37ae8152a 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -375,15 +375,19 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
 		        "not found." << std::endl;
+#endif
 		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "HousekeepingManager::fetchPoolEntry:"
 				" Pool entry not found." << std::endl;
+#endif
 		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 9ecad2183..8e13b602b 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -12,8 +12,10 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
     if(hkOwner == nullptr) {
         // Configuration error.
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
                 << "invalid!" << std::endl;
+#endif
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
@@ -147,8 +149,10 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
         auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
                 size, maxSize, streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
             sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
                     " error!" << std::endl;
+#endif
             return result;
         }
     }
@@ -206,8 +210,10 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
 
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "Pool Raw Access: Bit setting invalid position"
                 << std::endl;
+#endif
         return;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
@@ -256,8 +262,10 @@ sid_t LocalPoolDataSetBase::getSid() const {
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
         uint8_t position) const {
     if(position > 7) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "Pool Raw Access: Bit setting invalid position"
                 << std::endl;
+#endif
         return false;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index b4d0e3062..5abef424f 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -5,12 +5,16 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
         pool_rwm_t setReadWriteMode): localPoolId(poolId),
         readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;
+#endif
     }
     if(hkOwner == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
                 << "owner is a invalid!" << std::endl;
+#endif
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
@@ -23,15 +27,19 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
         readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;
+#endif
     }
     HasLocalDataPoolIF* hkOwner =
             objectManager->get<HasLocalDataPoolIF>(poolOwner);
     if(hkOwner == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolVariable: The supplied pool owner did not "
                 << "implement the correct interface"
                 << " HasLocalDataPoolIF!" << std::endl;
+#endif
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index a685ea8d9..38e9cf4bc 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -33,18 +33,22 @@ inline ReturnValue_t LocalPoolVariable<T>::read(dur_millis_t lockTimeout) {
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
+#endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK or poolEntry == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				<< std::hex << std::setw(8) << std::setfill('0')
 				<< hkManager->getOwner() << " and lp ID " << localPoolId
 				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
+#endif
 		return result;
 	}
 	this->value = *(poolEntry->address);
@@ -62,17 +66,21 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVariable: Invalid read write "
 				 "mode for commit() call." << std::endl;
+#endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
 				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
 				std::dec << " failed.\n" << std::flush;
+#endif
 		return result;
 	}
 	*(poolEntry->address) = this->value;
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 46123ccc1..dc91fb9b7 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -32,8 +32,10 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout)
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
+#endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
@@ -42,10 +44,12 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	memset(this->value, 0, vectorSize * sizeof(T));
 
 	if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
 				hkManager->getOwner() << "and lp ID 0x" << localPoolId <<
 				std::dec << " failed." << std::endl;
+#endif
 		return result;
 	}
 	std::memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
@@ -64,17 +68,21 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for commit() call." << std::endl;
+#endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
 				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
 				std::dec << " failed.\n" << std::flush;
+#endif
 		return result;
 	}
 	std::memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
@@ -89,8 +97,10 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
 	}
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
+#endif
 	return value[i];
 }
 
@@ -101,8 +111,10 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
 	}
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
+#endif
 	return value[i];
 }
 
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index 4fe506ee4..bf962c959 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -14,7 +14,9 @@ public:
 		if(readObject != nullptr) {
 			readResult = readObject->read(mutexTimeout);
 #if FSFW_PRINT_VERBOSITY_LEVEL == 1
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "PoolReadHelper: Read failed!" << std::endl;
+#endif
 #endif
 		}
 	}
diff --git a/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
index f836a7462..443b2bbbc 100644
--- a/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
+++ b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
@@ -15,8 +15,10 @@ ReturnValue_t pst::pollingSequenceInitDefault(
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
 		        << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 251320cbe..da2b823dc 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -39,11 +39,13 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		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;
+#endif
 	}
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
@@ -130,24 +132,30 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	communicationInterface = objectManager->get<DeviceCommunicationIF>(
 			deviceCommunicationId);
 	if (communicationInterface == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerBase::initialize: Communication interface "
 				"invalid." << std::endl;
 		sif::error << "Make sure it is set up properly and implements"
 				" DeviceCommunicationIF" << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "DeviceHandlerBase::initialize: Initializing "
 	            "communication interface failed!" << std::endl;
+#endif
 	    return result;
 	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
 				"factory." << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -156,10 +164,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 			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;
+#endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 		defaultRawReceiver = rawReceiver->getDeviceQueue();
@@ -168,10 +178,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 			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;
+#endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 	}
@@ -708,8 +720,10 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
 			if(foundLen == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
 			            " Packet parsing will be stuck." << std::endl;
+#endif
 			}
 			break;
 		case APERIODIC_REPLY: {
@@ -720,8 +734,10 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 			            foundId);
 			}
 			if(foundLen == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
 			            " Packet parsing will be stuck." << std::endl;
+#endif
 			}
 			break;
 		}
@@ -1275,9 +1291,11 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
 		    //so we can track misconfigurations
+#if CPP_OSTREAM_ENABLED == 1
 			sif::debug << std::hex << getObjectId()
 					<< ": DHB::buildInternalCommand: Busy" << std::dec
 					<< std::endl;
+#endif
 			result = NOTHING_TO_SEND; //no need to report this
 		}
 	}
@@ -1302,10 +1320,12 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
 			//so we can track misconfigurations
+#if CPP_OSTREAM_ENABLED == 1
 			sif::debug << std::hex << getObjectId()
 					<< ": DHB::buildInternalCommand: Command "
 					<< deviceCommandId << " isExecuting" << std::dec
 					<< std::endl;
+#endif
 			// this is an internal command, no need to report a failure here,
 			// missed reply will track if a reply is too late, otherwise, it's ok
 			return;
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 9d0535bf2..c7f878590 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -169,8 +169,10 @@ void DeviceHandlerFailureIsolation::clearFaultCounters() {
 ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
 	ReturnValue_t result = FailureIsolationBase::initialize();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerFailureIsolation::initialize: Could not"
 				" initialize FailureIsolationBase." << std::endl;
+#endif
 		return result;
 	}
 	ConfirmsFailuresIF* power = objectManager->get<ConfirmsFailuresIF>(
@@ -250,8 +252,10 @@ bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
 
 	if (owner == nullptr) {
 	    // Configuration error.
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "DeviceHandlerFailureIsolation::"
 	            << "isFdirInActionOrAreWeFaulty: Owner not set!" << std::endl;
+#endif
 	    return false;
 	}
 
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 6cc97eb6c..6742ff861 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -122,6 +122,7 @@ void EventManager::printEvent(EventMessage* message) {
 	case severity::INFO:
 #if DEBUG_INFO_EVENT == 1
 		string = translateObject(message->getReporter());
+#if CPP_OSTREAM_ENABLED == 1
 		sif::info << "EVENT: ";
 		if (string != 0) {
 			sif::info << string;
@@ -132,10 +133,12 @@ void EventManager::printEvent(EventMessage* message) {
 				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
 				<< message->getParameter1() << " P2: 0x"
 				<< message->getParameter2() << std::dec << std::endl;
-#endif
+#endif /* CPP_OSTREAM_ENABLED == 1 */
+#endif /* DEBUG_INFO_EVENT == 1 */
 		break;
 	default:
 		string = translateObject(message->getReporter());
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "EventManager: ";
 		if (string != 0) {
 			sif::debug << string;
@@ -146,13 +149,13 @@ void EventManager::printEvent(EventMessage* message) {
 		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;
+#endif
 		break;
 	}
 }
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index a04a0313b..fed301b5a 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -21,8 +21,10 @@ ReturnValue_t FailureIsolationBase::initialize() {
 	EventManagerIF* manager = objectManager->get<EventManagerIF>(
 			objects::EVENT_MANAGER);
 	if (manager == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "FailureIsolationBase::initialize: Event Manager has not"
 				" been initialized!" << std::endl;
+#endif
 		return RETURN_FAILED;
 	}
 	ReturnValue_t result = manager->registerListener(eventQueue->getId());
@@ -36,8 +38,10 @@ ReturnValue_t FailureIsolationBase::initialize() {
 		}
 		owner = objectManager->get<HasHealthIF>(ownerId);
 		if (owner == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "FailureIsolationBase::intialize: Owner object "
 					"invalid. Make sure it implements HasHealthIF" << std::endl;
+#endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 	}
@@ -45,10 +49,14 @@ ReturnValue_t FailureIsolationBase::initialize() {
 		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
 				faultTreeParent);
 		if (parentIF == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "FailureIsolationBase::intialize: Parent object"
 					<< "invalid." << std::endl;
+#endif
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "Make sure it implements ConfirmsFailuresIF."
 					<< std::endl;
+#endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 			return RETURN_FAILED;
 		}
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index b1e888c55..c14cc7c62 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -4,10 +4,12 @@
 
 void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 		bool printInfo, size_t maxCharPerLine) {
+#if CPP_OSTREAM_ENABLED == 1
 	if(printInfo) {
 		sif::info << "Printing data with size " << size << ": ";
 	}
 	sif::info << "[";
+#endif
 	if(type == OutputType::HEX) {
 		arrayprinter::printHex(data, size, maxCharPerLine);
 	}
@@ -21,6 +23,7 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 
 void arrayprinter::printHex(const uint8_t *data, size_t size,
 		size_t maxCharPerLine) {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::info << std::hex;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
@@ -28,16 +31,18 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 			sif::info << " , ";
 			if(i > 0 and i % maxCharPerLine == 0) {
 				sif::info << std::endl;
+
 			}
-		}
 
 	}
 	sif::info << std::dec;
 	sif::info << "]" << std::endl;
+#endif
 }
 
 void arrayprinter::printDec(const uint8_t *data, size_t size,
 		size_t maxCharPerLine) {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::info << std::dec;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << static_cast<int>(data[i]);
@@ -49,13 +54,16 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
 		}
 	}
 	sif::info << "]" << std::endl;
+#endif
 }
 
 void arrayprinter::printBin(const uint8_t *data, size_t size) {
+#if CPP_OSTREAM_ENABLED == 1
     sif::info << "\n" << std::flush;
     for(size_t i = 0; i < size; i++) {
         sif::info << "Byte " << i + 1 << ": 0b"<<
                 std::bitset<8>(data[i]) << ",\n" << std::flush;
     }
     sif::info << "]" << std::endl;
+#endif
 }
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index d574634d8..de795a6c5 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -41,14 +41,18 @@ ReturnValue_t HealthHelper::initialize() {
 	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
 
 	if (healthTable == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "HealthHelper::initialize: Health table object needs"
 	            "to be created in factory." << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	if(eventSender == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "HealthHelper::initialize: Owner has to implement "
 	            "ReportingProxyIF." << std::endl;
+#endif
 	    return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -79,8 +83,10 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 			health, oldHealth);
 	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
 	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "HealthHelper::informParent: sending health reply failed."
 				<< std::endl;
+#endif
 	}
 }
 
@@ -98,8 +104,10 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
 	}
 	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
 	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "HealthHelper::handleHealthCommand: sending health "
 		        "reply failed." << std::endl;
+#endif
 
 	}
 }
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index bfb672891..a2dc529d9 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -29,14 +29,16 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	uint32_t newTmHits = getAndResetTmHits();
 	uint32_t newStoreHits = getAndResetStoreHits();
 
-#ifdef DEBUG
+#if FSFW_ENHANCED_PRINTOUT == 1
 	if(diagnosticPrintout) {
 	    if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
+#if CPP_OSTREAM_ENABLED == 1
 	        sif::debug << "InternalErrorReporter::performOperation: Errors "
 	                << "occured!" << std::endl;
 	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
 	        sif::debug << "TM errors: " << newTmHits << std::endl;
 	        sif::debug << "Store errors: " << newStoreHits << std::endl;
+#endif
 	    }
 	}
 #endif
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index dcd4def35..cdd4d9435 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -15,8 +15,10 @@ MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
 		this->messageSize = this->HEADER_SIZE + size;
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
 				"allowed size! Setting content to 0" << std::endl;
+#endif
 		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
 		this->messageSize = this->HEADER_SIZE;
 	}
@@ -52,7 +54,9 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
 }
 
 void MessageQueueMessage::print(bool printWholeMessage) {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "MessageQueueMessage content: " << std::endl;
+#endif
 	if(printWholeMessage) {
 	    arrayprinter::print(getData(), getMaximumMessageSize());
 	}
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 97001ade9..bd2f51875 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -12,12 +12,16 @@ public:
 		ReturnValue_t status = mutex->lockMutex(timeoutType,
 		        timeoutMs);
 		if(status == MutexIF::MUTEX_TIMEOUT) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
 					<< timeoutMs << " milliseconds!" << std::endl;
+#endif
 		}
 		else if(status != HasReturnvaluesIF::RETURN_OK){
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MutexHelper: Lock of Mutex failed with code "
 			        << status << std::endl;
+#endif
 		}
 	}
 
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 6b11882f3..1d2a62a9d 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -16,7 +16,9 @@ ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
 	lastSender = message->getSender();
 	lastCommand = message->getCommand();
 	if (busy) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "MemHelper: Busy!" << std::endl;
+#endif
 	}
 	switch (lastCommand) {
 	case MemoryMessage::CMD_MEMORY_DUMP:
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index 44d326565..44661e4c9 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -72,8 +72,10 @@ private:
 		if (timeStamper == nullptr) {
 			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
 			if ( timeStamper == nullptr ) {
+#if CPP_OSTREAM_ENABLED == 1
 				sif::error << "MonitoringReportContent::checkAndSetStamper: "
 				        "Stamper not found!" << std::endl;
+#endif
 				return false;
 			}
 		}
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 5871bfcdf..12f4ef4fd 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -18,13 +18,18 @@ ObjectManager::~ObjectManager() {
 ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 	auto returnPair = objectList.emplace(id, object);
 	if (returnPair.second) {
+#if CPP_OSTREAM_ENABLED == 1
 	    // sif::debug << "ObjectManager::insert: Object " << std::hex
 	    //            << (int)id << std::dec << " inserted." << std::endl;
+#endif
 		return this->RETURN_OK;
 	} else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::insert: Object id " << std::hex
-		           << (int)id << std::dec << " is already in use!" << std::endl;
+		           << static_cast<uint32_t> id << std::dec
+				   << " is already in use!" << std::endl;
 		sif::error << "Terminating program." << std::endl;
+#endif
 		//This is very severe and difficult to handle in other places.
 		std::exit(INSERTION_FAILED);
 	}
@@ -33,12 +38,16 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 ReturnValue_t ObjectManager::remove( object_id_t id ) {
 	if ( this->getSystemObject(id) != NULL ) {
 		this->objectList.erase( id );
+#if CPP_OSTREAM_ENABLED == 1
 		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
 		//           << (int)id << std::dec << " removed." << std::endl;
+#endif
 		return RETURN_OK;
 	} else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::removeObject: Requested object "
 		        << std::hex << (int)id << std::dec << " not found." << std::endl;
+#endif
 		return NOT_FOUND;
 	}
 }
@@ -60,8 +69,10 @@ ObjectManager::ObjectManager() : produceObjects(nullptr) {
 
 void ObjectManager::initialize() {
 	if(produceObjects == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::initialize: Passed produceObjects "
 				"functions is nullptr!" << std::endl;
+#endif
 		return;
 	}
 	this->produceObjects();
@@ -71,37 +82,48 @@ void ObjectManager::initialize() {
 		result = it.second->initialize();
 		if ( result != RETURN_OK ) {
 			object_id_t var = it.first;
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
 					std::setw(8) << std::setfill('0')<< var << " failed to "
 					"initialize with code 0x" << result << std::dec <<
 					std::setfill(' ') << std::endl;
+#endif
 			errorCount++;
 		}
 	}
 	if (errorCount > 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
 		           << " failed initializations." << std::endl;
+#endif
 	}
 	//Init was successful. Now check successful interconnections.
 	errorCount = 0;
 	for (auto const& it : objectList) {
 		result = it.second->checkObjectConnections();
 		if ( result != RETURN_OK ) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
 					(int) it.first  << " connection check failed with code 0x"
 					<< result << std::dec << std::endl;
+#endif
 			errorCount++;
 		}
 	}
 	if (errorCount > 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
 		           << " failed connection checks." << std::endl;
+#endif
 	}
 }
 
 void ObjectManager::printList() {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "ObjectManager: Object List contains:" << std::endl;
 	for (auto const& it : objectList) {
 		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
+
 	}
+#endif
 }
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 4bd1d915a..167006256 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -86,8 +86,10 @@ extern ObjectManagerIF *objectManager;
 template <typename T>
 T* ObjectManagerIF::get( object_id_t id ) {
 	if(objectManager == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManagerIF: Global object manager has not "
 				"been initialized yet!" << std::endl;
+#endif
 	}
 	SystemObjectIF* temp = this->getSystemObject(id);
 	return dynamic_cast<T*>(temp);
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index a420ec489..d9f4a3cb7 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -8,8 +8,10 @@
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Could not retrieve task handle. Please ensure the"
 				"constructor was called inside a task." << std::endl;
+#endif
 	}
 	xTaskNotifyGive(handle);
 }
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 6fee5c353..3915afe90 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -5,7 +5,9 @@
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
+#endif
 	}
 	// Initiated semaphore must be given before it can be taken.
 	xSemaphoreGive(handle);
@@ -18,7 +20,9 @@ BinarySemaphore::~BinarySemaphore() {
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "Binary semaphore creation failure" << std::endl;
+#endif
     }
     xSemaphoreGive(handle);
 }
@@ -28,7 +32,9 @@ BinarySemaphore& BinarySemaphore::operator =(
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
             sif::error << "Binary semaphore creation failure" << std::endl;
+#endif
         }
         xSemaphoreGive(handle);
     }
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 9d309acc3..e66f044d7 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -9,25 +9,31 @@
 CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 		uint8_t initCount): maxCount(maxCount) {
 	if(initCount > maxCount) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
 				"intial cout. Setting initial count to max count." << std::endl;
+#endif
 		initCount = maxCount;
 	}
 
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Could not retrieve task "
 				"handle. Please ensure the constructor was called inside a "
 				"task." << std::endl;
+#endif
 	}
 
 	uint32_t oldNotificationValue;
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite,
 			&oldNotificationValue);
 	if(oldNotificationValue != 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		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;
+#endif
 	}
 	for(int i = 0; i < initCount; i++) {
 		xTaskNotifyGive(handle);
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index a202e4806..2521e52ed 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -10,14 +10,18 @@
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
 	if(initCount > maxCount) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
 				"intial cout. Setting initial count to max count." << std::endl;
+#endif
 		initCount = maxCount;
 	}
 
 	handle = xSemaphoreCreateCounting(maxCount, initCount);
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+#endif
 	}
 }
 
@@ -25,7 +29,9 @@ CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
 		maxCount(other.maxCount), initCount(other.initCount) {
 	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+#endif
 	}
 }
 
@@ -33,7 +39,9 @@ CountingSemaphore& CountingSemaphore::operator =(
 		CountingSemaphore&& other) {
 	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+#endif
 	}
 	return * this;
 }
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index fc5b89fe0..6b289df78 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -37,15 +37,19 @@ void FixedTimeslotTask::taskEntryPoint(void* argument) {
 	}
 
 	originalTask->taskFunctionality();
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->handle
 			<< " returned from taskFunctionality." << std::endl;
+#endif
 }
 
 void FixedTimeslotTask::missedDeadlineCounter() {
 	FixedTimeslotTask::deadlineMissedCount++;
 	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
+#endif
 	}
 }
 
@@ -69,8 +73,10 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index fdadf8b7d..27b9a769d 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -10,6 +10,7 @@
 MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		maxMessageSize(maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
+#if CPP_OSTREAM_ENABLED == 1
 	if (handle == nullptr) {
 		sif::error << "MessageQueue::MessageQueue:"
 		        << " Creation failed." << std::endl;
@@ -17,7 +18,9 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		        << std::endl;
 		sif::error << "Specified Maximum Message Size: "
 		        << maxMessageSize << std::endl;
+
 	}
+#endif
 }
 
 MessageQueue::~MessageQueue() {
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 9d9638b5f..1722660c8 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -5,7 +5,9 @@
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
+#endif
 	}
 }
 
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 2ee7bec01..155f6ac70 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -13,8 +13,10 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 	BaseType_t status = xTaskCreate(taskEntryPoint, name,
 			stackSize, this, setPriority, &handle);
 	if(status != pdPASS){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
 		        "Status: " << status << std::endl;
+#endif
 	}
 
 }
@@ -41,8 +43,10 @@ void PeriodicTask::taskEntryPoint(void* argument) {
 	}
 
 	originalTask->taskFunctionality();
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->handle
 			<< " returned from taskFunctionality." << std::endl;
+#endif
 }
 
 ReturnValue_t PeriodicTask::startTask() {
@@ -99,8 +103,10 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
 	            "it implement ExecutableObjectIF" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index beb0d096d..4db46c69e 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -32,8 +32,10 @@ SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
 		return new BinarySemaphoreUsingTask();
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
 				"binary semaphore" << std::endl;
+#endif
 		return new BinarySemaphore();
 	}
 }
@@ -47,8 +49,10 @@ SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount,
 		return new CountingSemaphoreUsingTask(maxCount, initCount);
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
 						"binary semaphore" << std::endl;
+#endif
 		return new CountingSemaphore(maxCount, initCount);
 	}
 
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 41321eeb5..7a763a602 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -14,7 +14,9 @@ MutexIF* Clock::timeMutex = NULL;
 using SystemClock = std::chrono::system_clock;
 
 uint32_t Clock::getTicksPerSecond(void){
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getTicksPerSecond: not implemented yet" << std::endl;
+#endif
 	return 0;
 	//return CLOCKS_PER_SEC;
 	//uint32_t ticks = sysconf(_SC_CLK_TCK);
@@ -23,7 +25,9 @@ uint32_t Clock::getTicksPerSecond(void){
 
 ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
 	// do some magic with chrono
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::setClock: not implemented yet" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -36,7 +40,9 @@ ReturnValue_t Clock::setClock(const timeval* time) {
 #else
 
 #endif
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
@@ -60,7 +66,9 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 	time->tv_usec = timeUnix.tv_nsec / 1000.0;
 	return HasReturnvaluesIF::RETURN_OK;
 #else
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 #endif
 
@@ -68,7 +76,9 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 	// do some magic with chrono
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::gerClock_usecs: not implemented yet" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -90,7 +100,9 @@ timeval Clock::getUptime() {
 		timeval.tv_usec = uptimeSeconds *(double) 1e6 - (timeval.tv_sec *1e6);
 	}
 #else
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+#endif
 #endif
 	return timeval;
 }
@@ -126,7 +138,9 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 	auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
 	time->usecond = usecond.count();
 
+#if CPP_OSTREAM_ENABLED == 1
 	//sif::warning << "Clock::getDateAndTime: not implemented yet" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -148,7 +162,9 @@ ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
 	to->tv_usec = from->usecond;
 	//Fails in 2038..
 	return HasReturnvaluesIF::RETURN_OK;
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::convertTimeBla: not implemented yet" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 9e892bb58..1fd3cd7f0 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -35,15 +35,19 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             ABOVE_NORMAL_PRIORITY_CLASS);
     if(result != 0) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
+#endif
     }
     result = SetThreadPriority(
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             THREAD_PRIORITY_NORMAL);
     if(result != 0) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
+#endif
     }
 #elif defined(LINUX)
     // TODO: we can just copy and paste the code from the linux OSAL here.
@@ -70,8 +74,10 @@ void FixedTimeslotTask::taskEntryPoint(void* argument) {
     }
 
     this->taskFunctionality();
+#if CPP_OSTREAM_ENABLED == 1
     sif::debug << "FixedTimeslotTask::taskEntryPoint: "
             "Returned from taskFunctionality." << std::endl;
+#endif
 }
 
 ReturnValue_t FixedTimeslotTask::startTask() {
@@ -134,8 +140,10 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
         return HasReturnvaluesIF::RETURN_OK;
     }
 
+#if CPP_OSTREAM_ENABLED == 1
     sif::error << "Component " << std::hex << componentId <<
             " not found, not adding it to pst" << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index d662d782c..0c0481203 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -10,8 +10,10 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 	queueLock = MutexFactory::instance()->createMutex();
 	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue:"
 		        << " Could not be created" << std::endl;
+#endif
 	}
 }
 
@@ -137,8 +139,10 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			targetQueue->messageQueue.push(*mqmMessage);
 		}
 		else {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessageFromMessageQueue: Message"
 					"is not MessageQueueMessage!" << std::endl;
+#endif
 		}
 
 	}
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index bfa6c3fd6..09acd2cb2 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -33,15 +33,19 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             ABOVE_NORMAL_PRIORITY_CLASS);
     if(result != 0) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
+#endif
     }
     result = SetThreadPriority(
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             THREAD_PRIORITY_NORMAL);
     if(result != 0) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
+#endif
     }
 #elif defined(LINUX)
     // we can just copy and paste the code from linux here.
@@ -69,8 +73,10 @@ void PeriodicTask::taskEntryPoint(void* argument) {
 	}
 
 	this->taskFunctionality();
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "PeriodicTask::taskEntryPoint: "
 			"Returned from taskFunctionality." << std::endl;
+#endif
 }
 
 ReturnValue_t PeriodicTask::startTask() {
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 621f46bce..620f8add3 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -26,8 +26,10 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 	auto returnPair = queueMap.emplace(currentId, queueToInsert);
 	if(not returnPair.second) {
 		// this should never happen for the atomic variable.
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "QueueMapManager: This ID is already inside the map!"
 				<< std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if (id != nullptr) {
@@ -44,8 +46,10 @@ MessageQueueIF* QueueMapManager::getMessageQueue(
 		return queueIter->second;
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "QueueMapManager::getQueueHandle: The ID " <<
 				messageQueueId << " does not exists in the map" << std::endl;
+#endif
 		return nullptr;
 	}
 }
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index b19b2c75a..840dacef5 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -21,16 +21,20 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
 	// Just gonna wait for full C++20 for now.
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "SemaphoreFactory: Binary Semaphore not implemented yet."
 			" Returning nullptr!\n" << std::flush;
+#endif
 	return nullptr;
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
 		uint8_t initCount, uint32_t arguments) {
 	// Just gonna wait for full C++20 for now.
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
 				" Returning nullptr!\n" << std::flush;
+#endif
 	return nullptr;
 }
 
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index b81fa1090..22d35e3a2 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -43,8 +43,10 @@ ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
 		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
 	    result = sem_timedwait(&handle, &timeOut);
 	    if(result != 0 and errno == EINVAL) {
+#if CPP_OSTREAM_ENABLED == 1
 	    	sif::debug << "BinarySemaphore::acquire: Invalid time value possible"
 	    			<< std::endl;
+#endif
 	    }
 	}
 	if(result == 0) {
@@ -62,8 +64,10 @@ ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
 		return SemaphoreIF::SEMAPHORE_INVALID;
 	case(EINTR):
 		// Call was interrupted by signal handler
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted."
 				"Code " << strerror(errno) << std::endl;
+#endif
 		/* No break */
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;
@@ -126,8 +130,10 @@ void BinarySemaphore::initSemaphore(uint8_t initCount) {
 			// Value exceeds SEM_VALUE_MAX
 		case(ENOSYS):
 		// System does not support process-shared semaphores
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
 				<< std::endl;
+#endif
 		}
 	}
 }
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 6cddda35b..e4e7df86f 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -69,7 +69,9 @@ timeval Clock::getUptime() {
 	timeval uptime;
 	auto result = getUptime(&uptime);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
+#endif
 	}
 	return uptime;
 }
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
index 183393994..22cb16154 100644
--- a/osal/linux/CountingSemaphore.cpp
+++ b/osal/linux/CountingSemaphore.cpp
@@ -4,8 +4,10 @@
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
 	if(initCount > maxCount) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
 				"intial cout. Setting initial count to max count." << std::endl;
+#endif
 		initCount = maxCount;
 	}
 
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 247a34ed8..0635b5601 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -47,8 +47,10 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::dec << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
@@ -91,7 +93,9 @@ void FixedTimeslotTask::taskFunctionality() {
 void FixedTimeslotTask::missedDeadlineCounter() {
 	FixedTimeslotTask::deadlineMissedCount++;
 	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
 				   << " deadlines." << std::endl;
+#endif
 	}
 }
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index cfadb7931..28dfb9c73 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -10,7 +10,6 @@
 #include <errno.h>
 
 
-
 MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
 		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
 		defaultDestination(MessageQueueIF::NO_QUEUE),
@@ -43,13 +42,17 @@ MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
 MessageQueue::~MessageQueue() {
 	int status = mq_close(this->id);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
 				   << strerror(errno) <<std::endl;
+#endif
 	}
 	status = mq_unlink(name);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
 				   << strerror(errno) << std::endl;
+#endif
 	}
 }
 
@@ -57,8 +60,10 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		uint32_t messageDepth) {
 	switch(errno) {
 	case(EINVAL): {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
 				" for message size" << std::endl;
+#endif
 		size_t defaultMqMaxMsg = 0;
 		// Not POSIX conformant, but should work for all UNIX systems.
 		// Just an additional helpful printout :-)
@@ -79,11 +84,13 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
 			Apply changes with: sudo sysctl -p
 			*/
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::MessageQueue: Default MQ size "
 					<< defaultMqMaxMsg << " is too small for requested size "
 					<< messageDepth << std::endl;
 			sif::error << "This error can be fixed by setting the maximum "
 					"allowed message size higher!" << std::endl;
+#endif
 
 		}
 		break;
@@ -95,8 +102,10 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		//We unlink the other queue
 		int status = mq_unlink(name);
 		if (status != 0) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "mq_unlink Failed with status: " << strerror(errno)
 													<< std::endl;
+#endif
 		}
 		else {
 			// Successful unlinking, try to open again
@@ -114,9 +123,11 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 
 	default:
 		// Failed either the first time or the second time
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 		<< name << std::dec << " failed with status: "
 		<< strerror(errno) << std::endl;
+#endif
 
 	}
 	return HasReturnvaluesIF::RETURN_FAILED;
@@ -151,15 +162,19 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	if(message == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::receiveMessage: Message is "
 				"nullptr!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
 	if(message->getMaximumMessageSize() < maxMessageSize) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::receiveMessage: Message size "
 				<< message->getMaximumMessageSize()
 				<< " too small to receive data!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -187,8 +202,10 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			return MessageQueueIF::EMPTY;
 		case EBADF:
 			//mqdes doesn't represent a valid queue open for reading.
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::receive: configuration error "
 			           << strerror(errno)  << std::endl;
+#endif
 			/*NO BREAK*/
 		case EINVAL:
 			/*
@@ -200,8 +217,10 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
 			 *   been set in the queue's mq_flags.
 			 */
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::receive: configuration error "
 					   << strerror(errno)  << std::endl;
+#endif
 			/*NO BREAK*/
 		case EMSGSIZE:
 			/*
@@ -213,8 +232,10 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			 *   given msg_len is too short for the message that would have
 			 *   been received.
 			 */
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::receive: configuration error "
 			           << strerror(errno)  << std::endl;
+#endif
 			/*NO BREAK*/
 		case EINTR:
 			//The operation was interrupted by a signal.
@@ -237,8 +258,10 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		switch(errno){
 		case EBADF:
 			//mqdes doesn't represent a valid message queue.
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::flush configuration error, "
 					"called flush with an invalid queue ID" << std::endl;
+#endif
 			/*NO BREAK*/
 		case EINVAL:
 			//mq_attr is NULL
@@ -253,8 +276,10 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		switch(errno){
 		case EBADF:
 			//mqdes doesn't represent a valid message queue.
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::flush configuration error, "
 					"called flush with an invalid queue ID" << std::endl;
+#endif
 			/*NO BREAK*/
 		case EINVAL:
 			/*
@@ -306,8 +331,10 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	if(message == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
 				"nullptr!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -335,11 +362,13 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		case EBADF: {
 			//mq_des doesn't represent a valid message queue descriptor,
 			//or mq_des wasn't opened for writing.
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
 					<< " destination invalid."  << std::endl;
 			sif::error << strerror(errno) << " in "
 					<<"mq_send to: " << sendTo << " sent from "
 					<< sentFrom << std::endl;
+#endif
 			return DESTINVATION_INVALID;
 		}
 		case EINTR:
@@ -354,14 +383,18 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
 			 *   msg_prio is greater than the priority of the calling process.
 			 */
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessage: Configuration error "
 			           << strerror(errno) << " in mq_send" << std::endl;
+#endif
 			/*NO BREAK*/
 		case EMSGSIZE:
 			// The msg_len is greater than the msgsize associated with
 			//the specified queue.
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessage: Size error [" <<
 					strerror(errno) << "] in mq_send" << std::endl;
+#endif
 			/*NO BREAK*/
 		default:
 			return HasReturnvaluesIF::RETURN_FAILED;
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index b27ff8c0a..e20126346 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -12,24 +12,32 @@ Mutex::Mutex() {
 	pthread_mutexattr_t mutexAttr;
 	int status = pthread_mutexattr_init(&mutexAttr);
 	if (status != 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
+#endif
 	}
 	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
 	if (status != 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
 				<< std::endl;
+#endif
 	}
 	status = pthread_mutex_init(&mutex, &mutexAttr);
 	if (status != 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
 				<< ", " << " failed with " << strerror(status) << std::endl;
+#endif
 	}
 	// After a mutex attributes object has been used to initialize one or more
 	// mutexes, any function affecting the attributes object
 	// (including destruction) shall not affect any previously initialized mutexes.
 	status = pthread_mutexattr_destroy(&mutexAttr);
 	if (status != 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
+#endif
 	}
 }
 
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index 3c1df6bb1..1c69124d7 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -25,8 +25,10 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
 				<< " it implements ExecutableObjectIF!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
@@ -42,7 +44,9 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
 
 ReturnValue_t PeriodicPosixTask::startTask(void) {
 	started = true;
+#if CPP_OSTREAM_ENABLED == 1
 	//sif::info << stackSize << std::endl;
+#endif
 	PosixThread::createTask(&taskEntryPoint,this);
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -67,12 +71,16 @@ void PeriodicPosixTask::taskFunctionality(void) {
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(), name, sizeof(name));
 			if(status == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 				sif::error << "PeriodicPosixTask " << name << ": Deadline "
 						"missed." << std::endl;
+#endif
 			}
 			else {
+#if CPP_OSTREAM_ENABLED == 1
 				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
 						status << std::endl;
+#endif
 			}
 			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 55d74de3e..80bf52c2d 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -48,8 +48,10 @@ void PosixThread::suspend() {
 	sigaddset(&waitSignal, SIGUSR1);
 	sigwait(&waitSignal, &caughtSig);
 	if (caughtSig != SIGUSR1) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
 				caughtSig << std::endl;
+#endif
 	}
 }
 
@@ -118,7 +120,9 @@ uint64_t PosixThread::getCurrentMonotonicTimeMs(){
 
 
 void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
+#if CPP_OSTREAM_ENABLED == 1
 	//sif::debug << "PosixThread::createTask" << std::endl;
+#endif
 	/*
 	 * The attr argument points to a pthread_attr_t structure whose contents
        are used at thread creation time to determine attributes for the new
@@ -129,53 +133,69 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	pthread_attr_t attributes;
 	int status = pthread_attr_init(&attributes);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute init failed with: " <<
 				strerror(status) << std::endl;
+#endif
 	}
 	void* stackPointer;
 	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PosixThread::createTask: Stack init failed with: " <<
 				strerror(status) << std::endl;
+#endif
 		if(errno == ENOMEM) {
 			uint64_t stackMb = stackSize/10e6;
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Insufficient memory for"
 					" the requested " << stackMb << " MB" << std::endl;
+#endif
 		}
 		else if(errno == EINVAL) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Wrong alignment argument!"
 					<< std::endl;
+#endif
 		}
 		return;
 	}
 
 	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PosixThread::createTask: pthread_attr_setstack "
 				" failed with: " << strerror(status) <<  std::endl;
 		sif::error << "Make sure the specified stack size is valid and is "
 				"larger than the minimum allowed stack size." << std::endl;
+#endif
 	}
 
 	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
 					strerror(status) << std::endl;
+#endif
 	}
 
 	// TODO FIFO -> This needs root privileges for the process
 	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute schedule policy failed with: " <<
 				strerror(status) << std::endl;
+#endif
 	}
 
 	sched_param scheduleParams;
 	scheduleParams.__sched_priority = priority;
 	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute schedule params failed with: " <<
 				strerror(status) << std::endl;
+#endif
 	}
 
 	//Set Signal Mask for suspend until startTask is called
@@ -184,36 +204,48 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	sigaddset(&waitSignal, SIGUSR1);
 	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread sigmask failed failed with: " <<
 				strerror(status) << " errno: " << strerror(errno) << std::endl;
+#endif
 	}
 
 
 	status = pthread_create(&thread,&attributes,fnc_,arg_);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread create failed with: " <<
 				strerror(status) << std::endl;
+#endif
 	}
 
 	status = pthread_setname_np(thread,name);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PosixThread::createTask: setname failed with: " <<
 				strerror(status) << std::endl;
+#endif
 		if(status == ERANGE) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Task name length longer"
 					" than 16 chars. Truncating.." << std::endl;
+#endif
 			name[15] = '\0';
 			status = pthread_setname_np(thread,name);
 			if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 				sif::error << "PosixThread::createTask: Setting name"
 						" did not work.." << std::endl;
+#endif
 			}
 		}
 	}
 
 	status = pthread_attr_destroy(&attributes);
 	if(status!=0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute destroy failed with: " <<
 				strerror(status) << std::endl;
+#endif
 	}
 }
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index af99ec91f..9cbb1d02d 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -39,14 +39,18 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
 		if(bytesReceived < 0) {
 			// handle error
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcSocketPollingTask::performOperation: Reception"
 					"error." << std::endl;
+#endif
 			handleReadError();
 
 			continue;
 		}
+#if CPP_OSTREAM_ENABLED == 1
 //		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
 //				<< " bytes received" << std::endl;
+#endif
 
 		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
 		if(result != HasReturnvaluesIF::RETURN_FAILED) {
@@ -65,9 +69,11 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 			receptionBuffer.data(), bytesRead);
 	// arrayprinter::print(receptionBuffer.data(), bytesRead);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
 				"storage failed" << std::endl;
 		sif::error << "Packet size: " << bytesRead << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -75,8 +81,10 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 
 	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Serial Polling: Sending message to queue failed"
 				<< std::endl;
+#endif
 		tcStore->deleteData(storeId);
 	}
 	return result;
@@ -85,15 +93,19 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 ReturnValue_t TcUnixUdpPollingTask::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
 				<< std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
 	if(tmtcBridge == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
 				" TMTC bridge object!" << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -115,8 +127,10 @@ void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
 	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
 			&tval, sizeof(receptionTimeout));
 	if(result == -1) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
 				"receive timeout failed with " << strerror(errno) << std::endl;
+#endif
 	}
 }
 
@@ -126,13 +140,17 @@ void TcUnixUdpPollingTask::handleReadError() {
 	case(EAGAIN): {
 		// todo: When working in timeout mode, this will occur more often
 		// and is not an error.
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcUnixUdpPollingTask::handleReadError: Timeout."
 				<< std::endl;
+#endif
 		break;
 	}
 	default: {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcUnixUdpPollingTask::handleReadError: "
 				<< strerror(errno) << std::endl;
+#endif
 	}
 	}
 }
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index bae631d72..0142025ef 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -10,8 +10,10 @@ Timer::Timer() {
 	sigEvent.sigev_value.sival_ptr = &timerId;
 	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
 	if(status!=0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Timer creation failed with: " << status <<
 				" errno: " << errno << std::endl;
+#endif
 	}
 }
 
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index ab28623ef..769e8affb 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -26,8 +26,10 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	//clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 	if(serverSocket < 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
 				" UDP socket!" << std::endl;
+#endif
 		handleSocketError();
 		return;
 	}
@@ -51,9 +53,11 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 			reinterpret_cast<struct sockaddr*>(&serverAddress),
 			serverAddressLen);
 	if(result == -1) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
 				"local port " << setServerPort << " to server socket!"
 				<< std::endl;
+#endif
 		handleBindError();
 		return;
 	}
@@ -74,18 +78,24 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	}
 
 //	char ipAddress [15];
+#if CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
 //					&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+#endif
 
 	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
 			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
 	if(bytesSent < 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
 				<< std::endl;
+#endif
 		handleSendError();
 	}
+#if CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
 //			" sent." << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -93,10 +103,12 @@ void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
 	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //	char ipAddress [15];
+#if CPP_OSTREAM_ENABLED == 1
 //	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;
+#endif
 
 	// Set new IP address if it has changed.
 	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
@@ -117,12 +129,16 @@ void TmTcUnixUdpBridge::handleSocketError() {
 	case(ENOBUFS):
 	case(ENOMEM):
 	case(EPROTONOSUPPORT):
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSocketError: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
+#endif
 		break;
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSocketError: Unknown error"
 				<< std::endl;
+#endif
 		break;
 	}
 }
@@ -135,10 +151,12 @@ void TmTcUnixUdpBridge::handleBindError() {
 		 Ephermeral ports can be shown with following command:
 		 sysctl -A | grep ip_local_port_range
 		 */
+#if CPP_OSTREAM_ENABLED == 1
 		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;
+#endif
 	}
 	break;
 	case(EADDRINUSE):
@@ -153,13 +171,17 @@ void TmTcUnixUdpBridge::handleBindError() {
 	case(ENOMEM):
 	case(ENOTDIR):
 	case(EROFS): {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleBindError: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
+#endif
 		break;
 	}
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleBindError: Unknown error"
 				<< std::endl;
+#endif
 		break;
 	}
 }
@@ -167,8 +189,10 @@ void TmTcUnixUdpBridge::handleBindError() {
 void TmTcUnixUdpBridge::handleSendError() {
 	switch(errno) {
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSendError: "
 		        << strerror(errno) << std::endl;
+#endif
 	}
 }
 
diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index 839182a67..eff8a0fb6 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -9,9 +9,11 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 	rtems_status_code status = rtems_message_queue_create(name, message_depth,
 			max_message_size, 0, &(this->id));
 	if (status != RTEMS_SUCCESSFUL) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 				<< name << std::dec << " failed with status:"
 				<< (uint32_t) status << std::endl;
+#endif
 		this->id = 0;
 	}
 }
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index 970d01e1d..a315681b8 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -30,8 +30,10 @@ ReturnValue_t MultiObjectTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
+#endif
 	}
 	switch(status){
 	case RTEMS_SUCCESSFUL:
@@ -63,7 +65,9 @@ void MultiObjectTask::taskFunctionality() {
 			char nameSpace[8] = { 0 };
 			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
 					nameSpace);
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
+#endif
 			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index a5ec96358..5278a076f 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -10,16 +10,20 @@ Mutex::Mutex() :
 	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
 			&mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
 				<< " failed with " << status << std::endl;
+#endif
 	}
 }
 
 Mutex::~Mutex() {
 	rtems_status_code status = rtems_semaphore_delete(mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: deletion for id " << mutexId
 				<< " failed with " << status << std::endl;
+#endif
 	}
 }
 
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index db7864fea..591ba743c 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -35,15 +35,19 @@ rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
 	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
 	//The task's functionality is called.
 	originalTask->taskFunctionality();
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->getId()
 			<< " returned from taskFunctionality." << std::endl;
+#endif
 }
 
 void PollingTask::missedDeadlineCounter() {
 	PollingTask::deadlineMissedCount++;
 	if (PollingTask::deadlineMissedCount % 10 == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << PollingTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
+#endif
 	}
 }
 
@@ -51,8 +55,10 @@ ReturnValue_t PollingTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PollingTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
+#endif
 	}
 	switch(status){
 	case RTEMS_SUCCESSFUL:
@@ -75,8 +81,10 @@ ReturnValue_t PollingTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index 4e0c8f008..7e3bd57aa 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -22,9 +22,11 @@ TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
 	}
 	ReturnValue_t result = convertReturnCode(status);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TaskBase::TaskBase: createTask with name " << std::hex
 				<< osalName << std::dec << " failed with return code "
 				<< (uint32_t) status << std::endl;
+#endif
 		this->id = 0;
 	}
 }
diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 06deafd10..e59316096 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -43,13 +43,17 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 				&senderAddressSize);
 		if(bytesReceived == SOCKET_ERROR) {
 			// handle error
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcWinUdpPollingTask::performOperation: Reception"
 					" error." << std::endl;
+#endif
 			handleReadError();
 			continue;
 		}
+#if CPP_OSTREAM_ENABLED == 1
 		//sif::debug << "TcWinUdpPollingTask::performOperation: " << bytesReceived
 		//		<< " bytes received" << std::endl;
+#endif
 
 		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
 		if(result != HasReturnvaluesIF::RETURN_FAILED) {
@@ -68,9 +72,11 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 			receptionBuffer.data(), bytesRead);
 	// arrayprinter::print(receptionBuffer.data(), bytesRead);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
 				"storage failed" << std::endl;
 		sif::error << "Packet size: " << bytesRead << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -78,8 +84,10 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 
 	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Serial Polling: Sending message to queue failed"
 				<< std::endl;
+#endif
 		tcStore->deleteData(storeId);
 	}
 	return result;
@@ -88,21 +96,27 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 ReturnValue_t TcWinUdpPollingTask::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
 				<< std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	tmtcBridge = objectManager->get<TmTcWinUdpBridge>(tmtcBridgeId);
 	if(tmtcBridge == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
 				" TMTC bridge object!" << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	serverUdpSocket = tmtcBridge->serverSocket;
+#if CPP_OSTREAM_ENABLED == 1
 	//sif::info << "TcWinUdpPollingTask::initialize: Server UDP socket "
 	//        << serverUdpSocket << std::endl;
+#endif
 
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -119,8 +133,10 @@ void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
 	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
 			reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
 	if(result == -1) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcWinUdpPollingTask::TcSocketPollingTask: Setting "
 				"receive timeout failed with " << strerror(errno) << std::endl;
+#endif
 	}
 }
 
@@ -128,23 +144,31 @@ void TcWinUdpPollingTask::handleReadError() {
     int error = WSAGetLastError();
     switch(error) {
     case(WSANOTINITIALISED): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call " << "necessary" << std::endl;
+#endif
         break;
     }
     case(WSAEFAULT): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: WSADEFAULT: "
                 << "Bad address " << std::endl;
+#endif
         break;
     }
     case(WSAEINVAL): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: WSAEINVAL: "
                 << "Invalid input parameters. " << std::endl;
+#endif
         break;
     }
     default: {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: Error code: "
                 << error << std::endl;
+#endif
         break;
     }
     }
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index e1ba132ee..b99451682 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -15,8 +15,10 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     if (err != 0) {
         /* Tell the user that we could not find a usable */
         /* Winsock DLL.                                  */
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge:"
                 "WSAStartup failed with error: " << err << std::endl;
+#endif
         return;
     }
 
@@ -34,8 +36,10 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     //clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
     serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
     if(serverSocket == INVALID_SOCKET) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open"
                 " UDP socket!" << std::endl;
+#endif
         handleSocketError();
         return;
     }
@@ -59,9 +63,11 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
             reinterpret_cast<struct sockaddr*>(&serverAddress),
             serverAddressLen);
     if(result != 0) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
                 "local port " << setServerPort << " to server socket!"
                 << std::endl;
+#endif
         handleBindError();
     }
 }
@@ -77,19 +83,25 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
     //clientAddressLen = sizeof(serverAddress);
 
 //  char ipAddress [15];
+#if CPP_OSTREAM_ENABLED == 1
 //  sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
 //                  &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+#endif
 
     ssize_t bytesSent = sendto(serverSocket,
             reinterpret_cast<const char*>(data), dataLen, flags,
             reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
     if(bytesSent == SOCKET_ERROR) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::sendTm: Send operation failed."
                 << std::endl;
+#endif
         handleSendError();
     }
+#if CPP_OSTREAM_ENABLED == 1
 //  sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
 //          " sent." << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -97,10 +109,12 @@ void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
     MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //  char ipAddress [15];
+#if CPP_OSTREAM_ENABLED == 1
 //  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;
+#endif
     registerCommConnect();
 
     // Set new IP address if it has changed.
@@ -114,8 +128,10 @@ void TmTcWinUdpBridge::handleSocketError() {
     int errCode = WSAGetLastError();
     switch(errCode) {
     case(WSANOTINITIALISED): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call necessary" << std::endl;
+#endif
         break;
     }
     default: {
@@ -123,8 +139,10 @@ void TmTcWinUdpBridge::handleSocketError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
          */
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSocketError: Error code: "
                 << errCode << std::endl;
+#endif
         break;
     }
     }
@@ -134,13 +152,17 @@ void TmTcWinUdpBridge::handleBindError() {
     int errCode = WSAGetLastError();
     switch(errCode) {
     case(WSANOTINITIALISED): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleBindError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call " << "necessary" << std::endl;
+#endif
         break;
     }
     case(WSAEADDRINUSE): {
+#if CPP_OSTREAM_ENABLED == 1
     	sif::warning << "TmTcWinUdpBridge::handleBindError: WSAEADDRINUSE: "
     			<< "Port is already in use!" << std::endl;
+#endif
     	break;
     }
     default: {
@@ -148,8 +170,10 @@ void TmTcWinUdpBridge::handleBindError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
         */
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleBindError: Error code: "
                 << errCode << std::endl;
+#endif
         break;
     }
     }
@@ -159,13 +183,17 @@ void TmTcWinUdpBridge::handleSendError() {
     int errCode = WSAGetLastError();
     switch(errCode) {
     case(WSANOTINITIALISED): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSendError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call necessary" << std::endl;
+#endif
         break;
     }
     case(WSAEADDRNOTAVAIL): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSendError: WSAEADDRNOTAVAIL: "
                 << "Check target address. " << std::endl;
+#endif
         break;
     }
     default: {
@@ -173,8 +201,10 @@ void TmTcWinUdpBridge::handleSendError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
         */
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSendError: Error code: "
                 << errCode << std::endl;
+#endif
         break;
     }
     }
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 23d1a1f35..5014e44c4 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -48,8 +48,10 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
         ConstStorageAccessor accessor(storeId);
         result = storage->getData(storeId, accessor);
         if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
             sif::error << "ParameterHelper::handleParameterMessage: Getting"
                     << " store data failed for load command." << std::endl;
+#endif
             break;
         }
 
diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index edacd73a5..f2c579d5a 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -22,7 +22,9 @@ ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice)
 	case(Subservice::COMMAND_ANNOUNCE_HEALTH_ALL):
 		return RETURN_OK;
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Invalid Subservice" << std::endl;
+#endif
 		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
 	}
 }
diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index 86b0dcded..9194ab24d 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -51,8 +51,10 @@ ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
 		result = generateSuccessReport(message);
 	}
 	if(result != HasReturnvaluesIF::RETURN_OK){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service1TelecommandVerification::sendVerificationReport: "
 		        "Sending verification packet failed !" << std::endl;
+#endif
 	}
 	return result;
 }
@@ -88,9 +90,11 @@ ReturnValue_t Service1TelecommandVerification::initialize() {
 	AcceptsTelemetryIF* funnel = objectManager->
 			get<AcceptsTelemetryIF>(targetDestination);
 	if(funnel == nullptr){
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "Service1TelecommandVerification::initialize: Specified"
 	            " TM funnel invalid. Make sure it is set up and implements"
 	            " AcceptsTelemetryIF." << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 3648b7eb6..f79c0a79f 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -25,7 +25,9 @@ ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
 	case Subservice::COMMAND_TOGGLE_WIRETAPPING:
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Invalid Subservice" << std::endl;
+#endif
 		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
 	}
 }
@@ -125,9 +127,11 @@ void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
 				static_cast<uint8_t>(Subservice::REPLY_RAW));
 		break;
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Unknown message in Service2DeviceAccess::"
 				"handleUnrequestedReply with command ID " <<
 				reply->getCommand() << std::endl;
+#endif
 		break;
 	}
 	//Must be reached by all cases to clear message
@@ -143,9 +147,11 @@ void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
 	size_t size = 0;
 	ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
 	if(result != HasReturnvaluesIF::RETURN_OK){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
 		        "handleUnrequestedReply with failure ID "<< result
 		        << std::endl;
+#endif
 		return;
 	}
 
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index 175af026b..d52ab50db 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -222,8 +222,10 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 	}
 
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service3Housekeeping::handleReply: Invalid reply with "
 				<< "reply command " << command << "!" << std::endl;
+#endif
 		return CommandingServiceBase::INVALID_REPLY;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
@@ -249,16 +251,20 @@ void Service3Housekeeping::handleUnrequestedReply(
 	}
 
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service3Housekeeping::handleUnrequestedReply: Invalid "
 		        << "reply with " << "reply command " << command << "!"
 		        << std::endl;
+#endif
 		return;
 	}
 
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		// Configuration error
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "Service3Housekeeping::handleUnrequestedReply:"
 				<< "Could not generate reply!" << std::endl;
+#endif
 	}
 }
 
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index e0b34a5b4..21bf27805 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -37,8 +37,10 @@ ReturnValue_t Service5EventReporting::performService() {
 	       }
 	    }
 	}
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug <<  "Service5EventReporting::generateEventReport:"
 	        " Too many events" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -53,8 +55,10 @@ ReturnValue_t Service5EventReporting::generateEventReport(
 	ReturnValue_t result = tmPacket.sendPacket(
 	        requestQueue->getDefaultDestination(),requestQueue->getId());
 	if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "Service5EventReporting::generateEventReport:"
 		        " Could not send TM packet" << std::endl;
+#endif
 	}
 	return result;
 }
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index d710c56e1..df25dd857 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -60,9 +60,11 @@ ReturnValue_t Service8FunctionManagement::prepareCommand(
 ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
 		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
     if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
                 << " TC size smaller thant minimum size of direct command."
                 << std::endl;
+#endif
         return CommandingServiceBase::INVALID_TC;
     }
 
@@ -125,8 +127,10 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(
     const uint8_t * buffer = nullptr;
     ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
     if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "Service 8: Could not retrieve data for data reply"
                 << std::endl;
+#endif
         return result;
     }
     DataReply dataReply(objectId, actionId, buffer, size);
@@ -135,8 +139,10 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(
 
     auto deletionResult = IPCStore->deleteData(storeId);
     if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::warning << "Service8FunctionManagement::handleReply: Deletion"
                 << " of data in pool failed." << std::endl;
+#endif
     }
     return result;
 }
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 1c11afd4b..303de7421 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -95,8 +95,10 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 template<typename count_t>
 uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 	if(buffer == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Wrong access function for stored type !"
 				 " Use getConstBuffer()." << std::endl;
+#endif
 		return nullptr;
 	}
 	return buffer;
@@ -105,8 +107,10 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "SerialBufferAdapter::getConstBuffer:"
 				" Buffers are unitialized!" << std::endl;
+#endif
 		return nullptr;
 	}
 	return constBuffer;
diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 842f1ce88..0beef64f3 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -46,7 +46,9 @@ const uint8_t* ConstStorageAccessor::data() const {
 
 size_t ConstStorageAccessor::size() const {
 	if(internalState == AccessState::UNINIT) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+#endif
 	}
 	return size_;
 }
@@ -54,12 +56,16 @@ size_t ConstStorageAccessor::size() const {
 ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
 		size_t maxSize) {
 	if(internalState == AccessState::UNINIT) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(size_ > maxSize) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "StorageAccessor: Supplied buffer not large enough"
 				<< std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(constDataPointer, constDataPointer + size_, pointer);
@@ -76,7 +82,9 @@ store_address_t ConstStorageAccessor::getId() const {
 
 void ConstStorageAccessor::print() const {
 	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+#endif
 		return;
 	}
 	arrayprinter::print(constDataPointer, size_);
diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 74e362d49..b2d5ffc4a 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -8,8 +8,10 @@ LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
 		NUMBER_OF_POOLS(poolConfig.size()),
 		spillsToHigherPools(spillsToHigherPools) {
 	if(NUMBER_OF_POOLS == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalPool::LocalPool: Passed pool configuration is "
 				<< " invalid!" << std::endl;
+#endif
 	}
 	max_pools_t index = 0;
 	for (const auto& currentPoolConfig: poolConfig) {
@@ -118,8 +120,10 @@ ReturnValue_t LocalPool::modifyData(store_address_t storeId,
 
 ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
 #if FSFW_VERBOSE_PRINTOUT == 2
+#if CPP_OSTREAM_ENABLED == 1
       sif::debug << "Delete: Pool: " << std::dec << storeId.poolIndex
               << " Index: " << storeId.packetIndex << std::endl;
+#endif
 
 #endif
     ReturnValue_t status = RETURN_OK;
@@ -134,8 +138,10 @@ ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
     }
     else {
         //pool_index or packet_index is too large
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPool::deleteData: Illegal store ID, no deletion!"
         		<< std::endl;
+#endif
         status = ILLEGAL_STORAGE_ID;
     }
     return status;
@@ -158,8 +164,10 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
             result = deleteData(localId);
 #if FSFW_VERBOSE_PRINTOUT == 2
             if (deltaAddress % elementSizes[n] != 0) {
+#if CPP_OSTREAM_ENABLED == 1
                 sif::error << "LocalPool::deleteData: Address not aligned!"
                         << std::endl;
+#endif
             }
 #endif
             break;
@@ -186,8 +194,10 @@ ReturnValue_t LocalPool::initialize() {
     //Check if any pool size is large than the maximum allowed.
     for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
         if (elementSizes[count] >= STORAGE_FREE) {
+#if CPP_OSTREAM_ENABLED == 1
             sif::error << "LocalPool::initialize: Pool is too large! "
                     "Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
+#endif
             return StorageManagerIF::POOL_TOO_LARGE;
         }
     }
@@ -209,8 +219,10 @@ ReturnValue_t LocalPool::reserveSpace(const size_t size,
         store_address_t *storeId, bool ignoreFault) {
     ReturnValue_t status = getPoolIndex(size, &storeId->poolIndex);
     if (status != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
                 << " )::reserveSpace: Packet too large." << std::endl;
+#endif
         return status;
     }
     status = findEmpty(storeId->poolIndex, &storeId->packetIndex);
@@ -224,9 +236,11 @@ ReturnValue_t LocalPool::reserveSpace(const size_t size,
     }
     if (status == RETURN_OK) {
 #if FSFW_VERBOSE_PRINTOUT == 2
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "Reserve: Pool: " << std::dec
                 << storeId->poolIndex << " Index: " << storeId->packetIndex
                 << std::endl;
+#endif
 #endif
         sizeLists[storeId->poolIndex][storeId->packetIndex] = size;
     }
@@ -266,8 +280,10 @@ ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
         uint16_t startAtIndex) {
     for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
 #if FSFW_VERBOSE_PRINTOUT == 2
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: "
              << n << ", Element Size: " << elementSizes[n] << std::endl;
+#endif
 #endif
         if (elementSizes[n] >= packetSize) {
             *poolIndex = n;
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index 3b7b549bd..7612fbc04 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -26,9 +26,11 @@ ReturnValue_t PoolManager::reserveSpace(const size_t size,
 ReturnValue_t PoolManager::deleteData(
         store_address_t storeId) {
 #if FSFW_VERBOSE_PRINTOUT == 2
+#if CPP_OSTREAM_ENABLED == 1
      sif::debug << "PoolManager( " << translateObject(getObjectId()) <<
            " )::deleteData from store " << storeId.poolIndex <<
            ". id is "<< storeId.packetIndex << std::endl;
+#endif
 #endif
     MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
             mutexTimeoutMs);
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index 9c2f936a5..373407b0b 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -26,12 +26,16 @@ StorageAccessor::StorageAccessor(StorageAccessor&& other):
 
 ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
 	if(internalState == AccessState::UNINIT) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(size_ > maxSize) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "StorageAccessor: Supplied buffer not large "
 				"enough" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(dataPointer, dataPointer + size_, pointer);
@@ -40,7 +44,9 @@ ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
 
 uint8_t* StorageAccessor::data() {
 	if(internalState == AccessState::UNINIT) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+#endif
 	}
 	return dataPointer;
 }
@@ -48,12 +54,16 @@ uint8_t* StorageAccessor::data() {
 ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
 		uint16_t offset) {
 	if(internalState == AccessState::UNINIT) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(offset + size > size_) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "StorageAccessor: Data too large for pool "
 				"entry!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(data, data + size, dataPointer + offset);
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index f60c88478..4ae508580 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -86,8 +86,10 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
 		object_id_t object = tableIter.value->getObject();
 		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
 			//illegal table entry, should only happen due to misconfigured mode table
+#if CPP_OSTREAM_ENABLED == 1
 			sif::debug << std::hex << getObjectId() << ": invalid mode table entry"
 					<< std::endl;
+#endif
 			continue;
 		}
 
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index e5db4301e..9d15a9c7f 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -91,8 +91,10 @@ void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "FixedSlotSequence::checkSequence:"
 				<< " Slot list is empty!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -100,8 +102,10 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 		ReturnValue_t result = customCheckFunction(slotList);
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			// Continue for now but print error output.
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "FixedSlotSequence::checkSequence:"
 					<< " Custom check failed!" << std::endl;
+#endif
 		}
 	}
 
@@ -112,21 +116,27 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 			errorCount++;
 		}
 		else if (slot.pollingTimeMs < time) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "FixedSlotSequence::checkSequence: Time: "
 					<< slot.pollingTimeMs << " is smaller than previous with "
 					<< time << std::endl;
+#endif
 			errorCount++;
 		}
 		else {
 			// All ok, print slot.
+#if CPP_OSTREAM_ENABLED == 1
 			//sif::info << "Current slot polling time: " << std::endl;
 			//sif::info << std::dec << slotIt->pollingTimeMs << std::endl;
+#endif
 		}
 		time = slot.pollingTimeMs;
 
 	}
+#if CPP_OSTREAM_ENABLED == 1
 	//sif::info << "Number of elements in slot list: "
 	//	   << slotList.size() << std::endl;
+#endif
 	if (errorCount > 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -149,8 +159,10 @@ ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
         }
     }
     if (count > 0) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "FixedSlotSequence::intializeSequenceAfterTaskCreation:"
                 "Counted " << count << " failed initializations!"  << std::endl;
+#endif
         return HasReturnvaluesIF::RETURN_FAILED;
     }
     return HasReturnvaluesIF::RETURN_OK;
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index ddd633083..742dd6486 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -11,21 +11,27 @@ CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
 CCSDSDistributor::~CCSDSDistributor() {}
 
 TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
+#if CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "CCSDSDistributor::selectDestination received: " <<
 //			this->currentMessage.getStorageId().pool_index << ", " <<
 //			this->currentMessage.getStorageId().packet_index << std::endl;
+#endif
 	const uint8_t* packet = nullptr;
 	size_t size = 0;
 	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
 			&packet, &size );
 	if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
 				" store failed!" << std::endl;
+#endif
 	}
 	SpacePacketBase currentPacket(packet);
 
+#if CPP_OSTREAM_ENABLED == 1
 //	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
 //			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
+#endif
 	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
 	if ( position != this->queueMap.end() ) {
 		return position;
@@ -70,8 +76,10 @@ ReturnValue_t CCSDSDistributor::initialize() {
 	ReturnValue_t status = this->TcDistributor::initialize();
 	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
 	if (this->tcStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CCSDSDistributor::initialize: Could not initialize"
 	            " TC store!" << std::endl;
+#endif
 	    status = RETURN_FAILED;
 	}
 	return status;
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 8e5b94cc1..3a2142689 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -13,9 +13,11 @@ PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
 PUSDistributor::~PUSDistributor() {}
 
 PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
+#if CPP_OSTREAM_ENABLED == 1
     // sif:: debug << "PUSDistributor::handlePacket received: "
     //          << this->current_packet_id.store_index << ", "
     //          << this->current_packet_id.packet_index << std::endl;
+#endif
     TcMqMapIter queueMapIt = this->queueMap.end();
     if(this->currentPacket == nullptr) {
         return queueMapIt;
@@ -25,9 +27,11 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
         tcStatus = checker.checkPacket(currentPacket);
 #ifdef DEBUG
         if(tcStatus != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
             sif::debug << "PUSDistributor::handlePacket: Packet format "
                     << "invalid, code "<< static_cast<int>(tcStatus)
                     << std::endl;
+#endif
         }
 #endif
         uint32_t queue_id = currentPacket->getService();
@@ -40,8 +44,10 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
     if (queueMapIt == this->queueMap.end()) {
         tcStatus = DESTINATION_NOT_FOUND;
 #ifdef DEBUG
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "PUSDistributor::handlePacket: Destination not found, "
                 << "code "<< static_cast<int>(tcStatus) << std::endl;
+#endif
 #endif
     }
 
@@ -57,12 +63,16 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
 
 ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
 	uint16_t serviceId = service->getIdentifier();
+#if CPP_OSTREAM_ENABLED == 1
 	// sif::info << "Service ID: " << (int)serviceId << std::endl;
+#endif
 	MessageQueueId_t queue = service->getRequestQueue();
 	auto returnPair = queueMap.emplace(serviceId, queue);
 	if (not returnPair.second) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PUSDistributor::registerService: Service ID already"
 				" exists in map." << std::endl;
+#endif
 		return SERVICE_ID_ALREADY_EXISTS;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
@@ -104,9 +114,11 @@ ReturnValue_t PUSDistributor::initialize() {
 	CCSDSDistributorIF* ccsdsDistributor =
 			objectManager->get<CCSDSDistributorIF>(packetSource);
 	if (ccsdsDistributor == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PUSDistributor::initialize: Packet source invalid."
 		        << " Make sure it exists and implements CCSDSDistributorIF!"
 		        << std::endl;
+#endif
 	    return RETURN_FAILED;
 	}
 	return ccsdsDistributor->registerApplication(this);
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index 06e1817f8..0bd4a906a 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -39,6 +39,7 @@ ReturnValue_t TcDistributor::handlePacket() {
 }
 
 void TcDistributor::print() {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Distributor content is: " << std::endl
 	        << "ID\t| Message Queue ID" << std::endl;
 	sif::debug << std::setfill('0') << std::setw(8) << std::hex;
@@ -47,7 +48,7 @@ void TcDistributor::print() {
 		         << std::endl;
 	}
 	sif::debug << std::setfill(' ') << std::dec;
-
+#endif
 }
 
 ReturnValue_t TcDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 302e2ac07..b3d080ba5 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -28,13 +28,17 @@ double Stopwatch::stopSeconds() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
                 elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
+#endif
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info <<"Stopwatch: Operation took "  << std::setprecision(3)
              << std::fixed << timevalOperations::toDouble(elapsedTime)
              << " seconds" << std::endl;
+#endif
     }
 }
 
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index eaa8416a9..1a28419cd 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -63,7 +63,9 @@ uint8_t TcPacketBase::getPusVersionNumber() {
 }
 
 void TcPacketBase::print() {
+#if CPP_OSTREAM_ENABLED == 1
     sif::debug << "TcPacketBase::print: " << std::endl;
+#endif
 	arrayprinter::print(getWholeData(), getFullSize());
 }
 
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index fffc86ae9..021b6d677 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -23,8 +23,10 @@ TcPacketStored::TcPacketStored(uint16_t apid,  uint8_t service,
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
 			(TC_PACKET_MIN_SIZE + size), &pData);
 	if (returnValue != this->store->RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "TcPacketStored: Could not get free element from store!"
 				<< std::endl;
+#endif
 		return;
 	}
 	this->setData(pData);
@@ -39,7 +41,9 @@ ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
 		size_t* dataSize) {
 	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
+#endif
 	}
 	return result;
 }
@@ -61,8 +65,10 @@ bool TcPacketStored::checkAndSetStore() {
 	if (this->store == nullptr) {
 		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 		if (this->store == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
 					<< std::endl;
+#endif
 			return false;
 		}
 	}
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index 2c8bfd632..bf892ccff 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -57,7 +57,9 @@ void TmPacketBase::setData(const uint8_t* p_Data) {
 }
 
 void TmPacketBase::print() {
+#if CPP_OSTREAM_ENABLED == 1
 	 sif::debug << "TmPacketBase::print: " << std::endl;
+#endif
 	 arrayprinter::print(getWholeData(), getFullSize());
 }
 
@@ -65,8 +67,10 @@ bool TmPacketBase::checkAndSetStamper() {
 	if (timeStamper == NULL) {
 		timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
 		if (timeStamper == NULL) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "TmPacketBase::checkAndSetStamper: Stamper not found!"
 					<< std::endl;
+#endif
 			return false;
 		}
 	}
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 0fb789aa3..21f237bd7 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -105,8 +105,10 @@ bool TmPacketStored::checkAndSetStore() {
 	if (store == nullptr) {
 		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
 		if (store == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
 					<< std::endl;
+#endif
 			return false;
 		}
 	}
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index ed765ecc8..2be6e2ce1 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -75,8 +75,10 @@ ReturnValue_t CommandingServiceBase::initialize() {
 			packetSource);
 
 	if (packetForwarding == nullptr or distributor == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CommandingServiceBase::intialize: Packet source or "
 	            "packet destination invalid!" << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -88,8 +90,10 @@ ReturnValue_t CommandingServiceBase::initialize() {
 	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 
 	if (IPCStore == nullptr or TCStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
 	                    "not initialized yet!" << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index cb5a1247c..1b03a7f01 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -25,9 +25,11 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
 	handleRequestQueue();
 	ReturnValue_t result = this->performService();
 	if (result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PusService " << (uint16_t) this->serviceId
 				<< ": performService returned with " << (int16_t) result
 				<< std::endl;
+#endif
 		return RETURN_FAILED;
 	}
 	return RETURN_OK;
@@ -43,11 +45,13 @@ void PusServiceBase::handleRequestQueue() {
 	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
 		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
 //		if(status != MessageQueueIF::EMPTY) {
+#if CPP_OSTREAM_ENABLED == 1
 //			sif::debug << "PusServiceBase::performOperation: Receiving from "
 //					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
 //					<< std::setfill('0') << this->requestQueue->getId()
 //					<< std::dec << " returned: " << status << std::setfill(' ')
 //					<<  std::endl;
+#endif
 //		}
 
 		if (status == RETURN_OK) {
@@ -79,9 +83,11 @@ void PusServiceBase::handleRequestQueue() {
 			break;
 		}
 		else {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "PusServiceBase::performOperation: Service "
 					<< this->serviceId << ": Error receiving packet. Code: "
 					<< std::hex << status << std::dec << std::endl;
+#endif
 		}
 	}
 }
@@ -104,10 +110,12 @@ ReturnValue_t PusServiceBase::initialize() {
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
 	if (destService == nullptr or distributor == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PusServiceBase::PusServiceBase: Service "
 				<< this->serviceId << ": Configuration error. Make sure "
 				<<	"packetSource and packetDestination are defined correctly"
 				<< std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 	this->requestQueue->setDefaultDestination(
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index b4e9967bf..954e3e75d 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -23,9 +23,11 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 		return RETURN_OK;
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of "
 	             << "packets sent per cycle exceeds limits. "
 	             << "Keeping default value." << std::endl;
+#endif
 		return RETURN_FAILED;
 	}
 }
@@ -37,9 +39,11 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
         return RETURN_OK;
     }
     else {
+#if CPP_OSTREAM_ENABLED == 1
         sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of "
                 << "packets stored exceeds limits. "
                 << "Keeping default value." << std::endl;
+#endif
         return RETURN_FAILED;
     }
 }
@@ -47,21 +51,27 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
 ReturnValue_t TmTcBridge::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
 	if (tcStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
 				"it is created and set up properly." << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 	tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
 	if (tmStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
 				"it is created and set up properly." << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 	AcceptsTelecommandsIF* tcDistributor =
 			objectManager->get<AcceptsTelecommandsIF>(tcDestination);
 	if (tcDistributor == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TC Distributor invalid"
 				<< std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -75,13 +85,17 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 	ReturnValue_t result;
 	result = handleTc();
 	if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "TmTcBridge::performOperation: "
 		        << "Error handling TCs" << std::endl;
+#endif
 	}
 	result = handleTm();
 	if (result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::debug << "TmTcBridge::performOperation: "
 	                    << "Error handling TMs" << std::endl;
+#endif
 	}
 	return result;
 }
@@ -94,9 +108,11 @@ ReturnValue_t TmTcBridge::handleTm() {
     ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::handleTm: Error handling TM queue with "
 		       << "error code 0x" << std::hex << result  << std::dec
 			   << "!" << std::endl;
+#endif
 		status = result;
 	}
 
@@ -104,8 +120,10 @@ ReturnValue_t TmTcBridge::handleTm() {
 	        (packetSentCounter < sentPacketsPerCycle)) {
 	    result = handleStoredTm();
 	    if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 	        sif::error << "TmTcBridge::handleTm: Error handling stored TMs!"
 	                << std::endl;
+#endif
 	        status = result;
 	    }
 	}
@@ -122,7 +140,9 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 		 result == HasReturnvaluesIF::RETURN_OK;
 		 result = tmTcReceptionQueue->receiveMessage(&message))
 	{
+#if CPP_OSTREAM_ENABLED == 1
 	    //sif::info << (int) packetSentCounter << std::endl;
+#endif
 		if(communicationLinkUp == false or
 		        packetSentCounter >= sentPacketsPerCycle) {
 			storeDownlinkData(&message);
@@ -151,8 +171,10 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	store_address_t storeId = 0;
 
 	if(tmFifo->full()) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::debug << "TmTcBridge::storeDownlinkData: TM downlink max. number "
 	                    << "of stored packet IDs reached! " << std::endl;
+#endif
 	    if(overwriteOld) {
 	        tmFifo->retrieve(&storeId);
 	        tmStore->deleteData(storeId);
@@ -171,8 +193,10 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 ReturnValue_t TmTcBridge::handleStoredTm() {
     ReturnValue_t status = RETURN_OK;
 	while(not tmFifo->empty() and packetSentCounter < sentPacketsPerCycle) {
+#if CPP_OSTREAM_ENABLED == 1
 		//sif::info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) tmFifo->size() << " left to send\r\n" << std::flush;
+#endif
 
 		store_address_t storeId;
 		const uint8_t* data = nullptr;
@@ -185,8 +209,10 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 
 		result = sendTm(data,size);
 		if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "TMTC Bridge: Could not send stored downlink data"
 			      << std::endl;
+#endif
 			status = result;
 		}
 		packetSentCounter ++;
@@ -201,13 +227,17 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 
 void TmTcBridge::registerCommConnect() {
 	if(not communicationLinkUp) {
+#if CPP_OSTREAM_ENABLED == 1
 		//sif::info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
+#endif
 		communicationLinkUp = true;
 	}
 }
 
 void TmTcBridge::registerCommDisconnect() {
+#if CPP_OSTREAM_ENABLED == 1
 	//sif::info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
+#endif
 	if(communicationLinkUp) {
 		communicationLinkUp = false;
 	}
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 7e40bd275..3bd1f067a 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -27,9 +27,11 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 			&message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				<< "to queue. Code: " << std::hex << status << std::dec
 				<< std::endl;
+#endif
 	}
 }
 
@@ -44,9 +46,11 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 			&message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				<< "to queue. Code: " << std::hex << status << std::dec
 				<< std::endl;
+#endif
 	}
 }
 
@@ -64,9 +68,11 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendFailureReport: Error writing "
 				<< "to queue. Code: " << std::hex  << "0x" << status << std::dec
 				<< std::endl;
+#endif
 	}
 }
 
@@ -82,24 +88,30 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendFailureReport: Error writing "
 				<< "to queue. Code: " << std::hex << "0x" << status << std::dec
 				<< std::endl;
+#endif
 	}
 }
 
 void VerificationReporter::initialize() {
 	if(messageReceiver == objects::NO_OBJECT) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "VerificationReporter::initialize: Verification message"
 				" receiver object ID not set yet in Factory!" << std::endl;
+#endif
 		return;
 	}
 	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
 			messageReceiver);
 	if (temp == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::initialize: Message "
 				<< "receiver invalid. Make sure it is set up properly and "
 				<< "implementsAcceptsVerifyMessageIF" << std::endl;
+#endif
 		return;
 	}
 	this->acknowledgeQueue = temp->getVerificationQueue();
diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
index 503a71ec3..6771b17ef 100644
--- a/unittest/internal/InternalUnitTester.cpp
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -13,13 +13,17 @@ InternalUnitTester::InternalUnitTester() {}
 InternalUnitTester::~InternalUnitTester() {}
 
 ReturnValue_t InternalUnitTester::performTests() {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::info << "Running internal unit tests.." << std::endl;
+#endif
 	testserialize::test_serialization();
 	testmq::testMq();
 	testsemaph::testBinSemaph();
 	testsemaph::testCountingSemaph();
 	testmutex::testMutex();
+#if CPP_OSTREAM_ENABLED == 1
 	sif::info << "Internal unit tests finished." << std::endl;
+#endif
 	return RETURN_OK;
 }
 
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index 6265e9fdb..292c4b8a6 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -1,7 +1,9 @@
 #include "UnittDefinitions.h"
 
  ReturnValue_t unitt::put_error(std::string errorId) {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "Unit Tester error: Failed at test ID "
 			<< errorId << "\n" << std::flush;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index 5a82f78c6..908326d44 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -94,8 +94,10 @@ void testsemaph::testBinSemaphoreImplementation(SemaphoreIF* binSemaph,
 		result = binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
 		//dur_millis_t time = stopwatch.stop();
 //		if(abs(time - 10) > 2) {
+#if CPP_OSTREAM_ENABLED == 1
 //		    sif::error << "UnitTester: Semaphore timeout measured incorrect."
 //		            << std::endl;
+#endif
 //			unitt::put_error(id);
 //		}
 	}
diff --git a/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp b/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
index f836a7462..443b2bbbc 100644
--- a/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
+++ b/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
@@ -15,8 +15,10 @@ ReturnValue_t pst::pollingSequenceInitDefault(
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
 		        << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
diff --git a/unittest/user/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
index 0b66558ac..6504700c7 100644
--- a/unittest/user/unittest/core/CatchDefinitions.cpp
+++ b/unittest/user/unittest/core/CatchDefinitions.cpp
@@ -5,7 +5,9 @@ StorageManagerIF* tglob::getIpcStoreHandle() {
 	if(objectManager != nullptr) {
 		return objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	} else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;
+#endif
 		return nullptr;
 	}
 }

From afda3b2fa063b8d45b5b725ad2a36822041dc4d8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 14:00:29 +0100
Subject: [PATCH 1346/1774] small tweak

---
 objectmanager/ObjectManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 12f4ef4fd..a7e3ac4c0 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -81,8 +81,8 @@ void ObjectManager::initialize() {
 	for (auto const& it : objectList) {
 		result = it.second->initialize();
 		if ( result != RETURN_OK ) {
-			object_id_t var = it.first;
 #if CPP_OSTREAM_ENABLED == 1
+			object_id_t var = it.first;
 			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
 					std::setw(8) << std::setfill('0')<< var << " failed to "
 					"initialize with code 0x" << result << std::dec <<

From 4515c0d3cd5c4eb00218767da8d75c72448e1f23 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 14:08:40 +0100
Subject: [PATCH 1347/1774] exlcuding ostream headers

---
 datapool/PoolEntry.cpp                      | 1 +
 health/HealthTableIF.h                      | 2 ++
 objectmanager/ObjectManager.cpp             | 3 +++
 serviceinterface/ServiceInterfaceBuffer.cpp | 9 +++++++--
 serviceinterface/ServiceInterfaceBuffer.h   | 4 ++++
 serviceinterface/ServiceInterfaceStream.cpp | 4 ++++
 serviceinterface/ServiceInterfaceStream.h   | 5 +++++
 7 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index b1ccb260a..369799c27 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -3,6 +3,7 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../globalfunctions/arrayprinter.h"
 #include <cstring>
+#include <algorithm>
 
 template <typename T>
 PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h
index d61e67616..727c44961 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -5,6 +5,8 @@
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 
+#include <utility>
+
 class HealthTableIF: public ManagesHealthIF {
 public:
 	virtual ~HealthTableIF() {}
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index a7e3ac4c0..251dbc707 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,6 +1,9 @@
 #include "ObjectManager.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
+
+#if CPP_OSTREAM_ENABLED == 1
 #include <iomanip>
+#endif
 #include <cstdlib>
 
 ObjectManager::ObjectManager( void (*setProducer)() ):
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 222c1e2c4..abe296cb4 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,7 +1,10 @@
-#include "../timemanager/Clock.h"
 #include "ServiceInterfaceBuffer.h"
+
+#if CPP_OSTREAM_ENABLED == 1
+
+#include "../timemanager/Clock.h"
+
 #include "serviceInterfaceDefintions.h"
-#include <FSFWConfig.h>
 #include <cstring>
 #include <inttypes.h>
 
@@ -252,3 +255,5 @@ void ServiceInterfaceBuffer::initSocket() {
 }
 
 #endif //ML505
+
+#endif /* CPP_OSTREAM_ENABLED == 1 */
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 8f2a601c2..d13143cdc 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -3,6 +3,9 @@
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <FSFWConfig.h>
+
+#if CPP_OSTREAM_ENABLED == 1
+
 #include <iostream>
 #include <sstream>
 #include <iomanip>
@@ -147,5 +150,6 @@ private:
 };
 #endif //ML505
 
+#endif /* CPP_OSTREAM_ENABLED == 1 */
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 056434604..c618d989a 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,5 +1,7 @@
 #include "ServiceInterfaceStream.h"
 
+#if CPP_OSTREAM_ENABLED == 1
+
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
 		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
 		std::ostream(&streambuf),
@@ -13,3 +15,5 @@ std::string* ServiceInterfaceStream::getPreamble() {
 	return streambuf.getPreamble();
 }
 
+#endif
+
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index cd2adf859..ddeded805 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -2,6 +2,9 @@
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
 
 #include "ServiceInterfaceBuffer.h"
+
+#if CPP_OSTREAM_ENABLED == 1
+
 #include <iostream>
 #include <cstdio>
 
@@ -48,4 +51,6 @@ extern ServiceInterfaceStream warning;
 extern ServiceInterfaceStream error;
 }
 
+#endif /* CPP_OSTREAM_ENABLED == 1 */
+
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

From 2edf15831202666468599a2880933a4398ab0681 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 14:16:52 +0100
Subject: [PATCH 1348/1774] correct preprocessor define now used

---
 container/SharedRingBuffer.cpp                |  2 +-
 controller/ExtendedControllerBase.cpp         |  2 +-
 datalinklayer/Clcw.cpp                        |  2 +-
 datalinklayer/DataLinkLayer.cpp               |  4 +--
 datalinklayer/MapPacketExtraction.cpp         | 12 +++----
 datalinklayer/TcTransferFrame.cpp             |  2 +-
 datalinklayer/TcTransferFrameLocal.cpp        |  2 +-
 datalinklayer/VirtualChannelReception.cpp     |  2 +-
 datapool/PoolDataSetBase.cpp                  | 10 +++---
 datapool/PoolEntry.cpp                        |  6 ++--
 datapoollocal/HasLocalDataPoolIF.h            |  2 +-
 datapoollocal/LocalDataPoolManager.cpp        | 28 +++++++--------
 datapoollocal/LocalDataPoolManager.h          |  4 +--
 datapoollocal/LocalPoolDataSetBase.cpp        |  8 ++---
 datapoollocal/LocalPoolObjectBase.cpp         |  8 ++---
 datapoollocal/LocalPoolVariable.tpp           |  8 ++---
 datapoollocal/LocalPoolVector.tpp             | 12 +++----
 datapoollocal/PoolReadHelper.h                |  2 +-
 .../PollingSequenceFactory.cpp                |  2 +-
 devicehandlers/DeviceHandlerBase.cpp          | 20 +++++------
 .../DeviceHandlerFailureIsolation.cpp         |  4 +--
 events/EventManager.cpp                       |  6 ++--
 fdir/FailureIsolationBase.cpp                 |  8 ++---
 globalfunctions/arrayprinter.cpp              |  8 ++---
 health/HealthHelper.cpp                       |  8 ++---
 internalError/InternalErrorReporter.cpp       |  2 +-
 ipc/MessageQueueMessage.cpp                   |  4 +--
 ipc/MutexHelper.h                             |  4 +--
 memory/MemoryHelper.cpp                       |  2 +-
 monitoring/MonitoringMessageContent.h         |  2 +-
 objectmanager/ObjectManager.cpp               | 22 ++++++------
 objectmanager/ObjectManagerIF.h               |  2 +-
 osal/FreeRTOS/BinSemaphUsingTask.cpp          |  2 +-
 osal/FreeRTOS/BinarySemaphore.cpp             |  6 ++--
 osal/FreeRTOS/CountingSemaphUsingTask.cpp     |  6 ++--
 osal/FreeRTOS/CountingSemaphore.cpp           |  8 ++---
 osal/FreeRTOS/FixedTimeslotTask.cpp           |  6 ++--
 osal/FreeRTOS/MessageQueue.cpp                |  2 +-
 osal/FreeRTOS/Mutex.cpp                       |  2 +-
 osal/FreeRTOS/PeriodicTask.cpp                |  6 ++--
 osal/FreeRTOS/SemaphoreFactory.cpp            |  4 +--
 osal/host/Clock.cpp                           | 16 ++++-----
 osal/host/FixedTimeslotTask.cpp               |  8 ++---
 osal/host/MessageQueue.cpp                    |  4 +--
 osal/host/PeriodicTask.cpp                    |  6 ++--
 osal/host/QueueMapManager.cpp                 |  4 +--
 osal/host/SemaphoreFactory.cpp                |  4 +--
 osal/linux/BinarySemaphore.cpp                |  6 ++--
 osal/linux/Clock.cpp                          |  2 +-
 osal/linux/CountingSemaphore.cpp              |  2 +-
 osal/linux/FixedTimeslotTask.cpp              |  4 +--
 osal/linux/MessageQueue.cpp                   | 34 +++++++++----------
 osal/linux/Mutex.cpp                          |  8 ++---
 osal/linux/PeriodicPosixTask.cpp              |  8 ++---
 osal/linux/PosixThread.cpp                    | 32 ++++++++---------
 osal/linux/TcUnixUdpPollingTask.cpp           | 18 +++++-----
 osal/linux/Timer.cpp                          |  2 +-
 osal/linux/TmTcUnixUdpBridge.cpp              | 24 ++++++-------
 osal/rtems/MessageQueue.cpp                   |  2 +-
 osal/rtems/MultiObjectTask.cpp                |  4 +--
 osal/rtems/Mutex.cpp                          |  4 +--
 osal/rtems/PollingTask.cpp                    |  8 ++---
 osal/rtems/TaskBase.cpp                       |  2 +-
 osal/windows/TcWinUdpPollingTask.cpp          | 24 ++++++-------
 osal/windows/TmTcWinUdpBridge.cpp             | 30 ++++++++--------
 parameters/ParameterHelper.cpp                |  2 +-
 pus/CService201HealthCommanding.cpp           |  2 +-
 pus/Service1TelecommandVerification.cpp       |  4 +--
 pus/Service2DeviceAccess.cpp                  |  6 ++--
 pus/Service3Housekeeping.cpp                  |  6 ++--
 pus/Service5EventReporting.cpp                |  4 +--
 pus/Service8FunctionManagement.cpp            |  6 ++--
 serialize/SerialBufferAdapter.cpp             |  4 +--
 serviceinterface/ServiceInterfaceBuffer.cpp   |  4 +--
 serviceinterface/ServiceInterfaceBuffer.h     |  4 +--
 serviceinterface/ServiceInterfaceStream.cpp   |  2 +-
 serviceinterface/ServiceInterfaceStream.h     |  4 +--
 storagemanager/ConstStorageAccessor.cpp       |  8 ++---
 storagemanager/LocalPool.cpp                  | 16 ++++-----
 storagemanager/PoolManager.cpp                |  2 +-
 storagemanager/StorageAccessor.cpp            | 10 +++---
 subsystem/SubsystemBase.cpp                   |  2 +-
 tasks/FixedSlotSequence.cpp                   | 12 +++----
 tcdistribution/CCSDSDistributor.cpp           |  8 ++---
 tcdistribution/PUSDistributor.cpp             | 12 +++----
 tcdistribution/TcDistributor.cpp              |  2 +-
 timemanager/Stopwatch.cpp                     |  4 +--
 tmtcpacket/pus/TcPacketBase.cpp               |  2 +-
 tmtcpacket/pus/TcPacketStored.cpp             |  6 ++--
 tmtcpacket/pus/TmPacketBase.cpp               |  4 +--
 tmtcpacket/pus/TmPacketStored.cpp             |  2 +-
 tmtcservices/CommandingServiceBase.cpp        |  4 +--
 tmtcservices/PusServiceBase.cpp               |  8 ++---
 tmtcservices/TmTcBridge.cpp                   | 30 ++++++++--------
 tmtcservices/VerificationReporter.cpp         | 12 +++----
 unittest/internal/InternalUnitTester.cpp      |  4 +--
 unittest/internal/UnittDefinitions.cpp        |  2 +-
 unittest/internal/osal/IntTestSemaphore.cpp   |  2 +-
 .../PollingSequenceFactory.cpp                |  2 +-
 .../user/unittest/core/CatchDefinitions.cpp   |  2 +-
 100 files changed, 356 insertions(+), 356 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 340bce370..769ce0000 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -47,7 +47,7 @@ ReturnValue_t SharedRingBuffer::initialize() {
 DynamicFIFO<size_t>* SharedRingBuffer::getReceiveSizesFIFO() {
 	if(receiveSizesFIFO == nullptr) {
 		// Configuration error.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
 				<< " was not configured to have sizes FIFO, returning nullptr!"
 				<< std::endl;
diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index f9f7534d8..017acafe1 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -107,7 +107,7 @@ MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
 }
 
 LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
             << " implementation provided, returning nullptr!" << std::endl;
 #endif
diff --git a/datalinklayer/Clcw.cpp b/datalinklayer/Clcw.cpp
index 19aa4e7b0..13971929c 100644
--- a/datalinklayer/Clcw.cpp
+++ b/datalinklayer/Clcw.cpp
@@ -55,7 +55,7 @@ void Clcw::setBitLock(bool bitLock) {
 }
 
 void Clcw::print() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
 #endif
 }
diff --git a/datalinklayer/DataLinkLayer.cpp b/datalinklayer/DataLinkLayer.cpp
index 6a3838517..1bdaa4f5f 100644
--- a/datalinklayer/DataLinkLayer.cpp
+++ b/datalinklayer/DataLinkLayer.cpp
@@ -98,7 +98,7 @@ ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
 	receivedDataLength = length;
 	ReturnValue_t status = allFramesReception();
 	if (status != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataLinkLayer::processFrame: frame reception failed. "
 		         "Error code: " << std::hex << status << std::dec << std::endl;
 #endif
@@ -126,7 +126,7 @@ ReturnValue_t DataLinkLayer::initialize() {
 	if ( virtualChannels.begin() != virtualChannels.end() ) {
 		clcw->setVirtualChannel( virtualChannels.begin()->second->getChannelId() );
 	} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
 #endif
 		return RETURN_FAILED;
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 0bf79f425..cdc9ae270 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -29,7 +29,7 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 			bufferPosition = &packetBuffer[packetLength];
 			status = RETURN_OK;
 		} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error
 					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
 					<< packetLength << std::endl;
@@ -53,7 +53,7 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 				}
 				status = RETURN_OK;
 			} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error
 						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
 						<< packetLength << std::endl;
@@ -62,7 +62,7 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 				status = CONTENT_TOO_LARGE;
 			}
 		} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error
 					<< "MapPacketExtraction::extractPackets. Illegal segment! Last flag: "
 					<< (int) lastSegmentationFlag << std::endl;
@@ -72,7 +72,7 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 		}
 		break;
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error
 				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
 				<< (int) segmentationFlag << std::endl;
@@ -143,11 +143,11 @@ ReturnValue_t MapPacketExtraction::initialize() {
 }
 
 void MapPacketExtraction::printPacketBuffer(void) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "DLL: packet_buffer contains: " << std::endl;
 #endif
 	for (uint32_t i = 0; i < this->packetLength; ++i) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
 				<< (uint16_t) this->packetBuffer[i] << std::endl;
 #endif
diff --git a/datalinklayer/TcTransferFrame.cpp b/datalinklayer/TcTransferFrame.cpp
index 0050994a5..ee094dc32 100644
--- a/datalinklayer/TcTransferFrame.cpp
+++ b/datalinklayer/TcTransferFrame.cpp
@@ -87,7 +87,7 @@ uint8_t* TcTransferFrame::getFullDataField() {
 }
 
 void TcTransferFrame::print() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Raw Frame: " << std::hex << std::endl;
 	for (uint16_t count = 0; count < this->getFullSize(); count++ ) {
 		sif::debug << (uint16_t)this->getFullFrame()[count] << " ";
diff --git a/datalinklayer/TcTransferFrameLocal.cpp b/datalinklayer/TcTransferFrameLocal.cpp
index 1ef772a22..de8f568f4 100644
--- a/datalinklayer/TcTransferFrameLocal.cpp
+++ b/datalinklayer/TcTransferFrameLocal.cpp
@@ -37,7 +37,7 @@ TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uin
 			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
 			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
 		} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
 #endif
 		}
diff --git a/datalinklayer/VirtualChannelReception.cpp b/datalinklayer/VirtualChannelReception.cpp
index 8ad65740d..3a56fe1e2 100644
--- a/datalinklayer/VirtualChannelReception.cpp
+++ b/datalinklayer/VirtualChannelReception.cpp
@@ -102,7 +102,7 @@ uint8_t VirtualChannelReception::getChannelId() const {
 ReturnValue_t VirtualChannelReception::initialize() {
 	ReturnValue_t returnValue = RETURN_FAILED;
 	if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
 				<< (int) slidingWindowWidth << std::endl;
 #endif
diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index f2c2b8679..5fb1c3c7d 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -13,21 +13,21 @@ PoolDataSetBase::~PoolDataSetBase() {}
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
 	if (state != States::STATE_SET_UNINITIALISED) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::registerVariable: "
 				"Call made in wrong position." << std::endl;
 #endif
 		return DataSetIF::DATA_SET_UNINITIALISED;
 	}
 	if (variable == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::registerVariable: "
 				"Pool variable is nullptr." << std::endl;
 #endif
 		return DataSetIF::POOL_VAR_NULL;
 	}
 	if (fillCount >= maxFillCount) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::registerVariable: "
 				"DataSet is full." << std::endl;
 #endif
@@ -53,7 +53,7 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 		unlockDataPool();
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::read(): "
 				"Call made in wrong position. Don't forget to commit"
 				" member datasets!" << std::endl;
@@ -146,7 +146,7 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 		} else if (registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if (result != COMMITING_WITHOUT_READING) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error << "DataSet::commit(): commit-without-read call made "
 						"with non write-only variable." << std::endl;
 #endif
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 369799c27..583751626 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -13,7 +13,7 @@ PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
 		std::memset(this->address, 0, this->getByteSize());
 	}
 	else if (initValue.size() != setLength){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "PoolEntry: setLength is not equal to initializer list"
 				"length! Performing zero initialization with given setLength"
 				<< std::endl;
@@ -70,12 +70,12 @@ bool PoolEntry<T>::getValid() {
 
 template <typename T>
 void PoolEntry<T>::print() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	 sif::debug << "Pool Entry Validity: " <<
 			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
 #endif
 	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << std::dec << std::endl;
 #endif
 }
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index e94af1674..7707fab84 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -89,7 +89,7 @@ public:
 	 * @return
 	 */
 	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
 	            << ". Returning nullptr!" << std::endl;
 #endif
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 0eb6f5f5d..24516aad5 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -21,7 +21,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
                         appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                 << "Invalid supplied owner!" << std::endl;
 #endif
@@ -30,7 +30,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
     this->owner = owner;
     mutex = MutexFactory::instance()->createMutex();
     if(mutex == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                 << "Could not create mutex." << std::endl;
 #endif
@@ -43,7 +43,7 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::initialize: "
                 << std::hex << "0x" << owner->getObjectId() << ". Supplied "
                 << "queue invalid!" << std::dec << std::endl;
@@ -53,7 +53,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
 
     ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
     if(ipcStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::initialize: "
                 << std::hex << "0x" << owner->getObjectId() << ": Could not "
                 << "set IPC store." <<std::dec << std::endl;
@@ -69,7 +69,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
             hkDestinationId = hkPacketReceiver->getHkQueue();
         }
         else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                     << "Default HK destination object is invalid!" << std::endl;
 #endif
@@ -95,7 +95,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
         }
         return result;
     }
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "HousekeepingManager: The map should only be initialized "
             << "once!" << std::endl;
 #endif
@@ -351,7 +351,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
                 << " Invalid receiver!"<< std::endl;
 #endif
@@ -383,7 +383,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
                 << " Invalid receiver!"<< std::endl;
 #endif
@@ -591,7 +591,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
         lp_id_t localPoolId) {
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "HousekeepingManager::fechPoolEntry:"
                 << " Pool entry not found." << std::endl;
 #endif
@@ -614,7 +614,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t destination) {
     if(dataSet == nullptr) {
         // Configuration error.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
                 << " Set ID not found or dataset not assigned!" << std::endl;
 #endif
@@ -698,7 +698,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
             sid, dataSet, true);
     if(result != HasReturnvaluesIF::RETURN_OK) {
         // configuration error
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "LocalDataPoolManager::performHkOperation:"
                 << "0x" << std::hex << std::setfill('0') << std::setw(8)
                 << owner->getObjectId() << " Error generating "
@@ -748,7 +748,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     // Get and check dataset first.
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
                 << " Set ID not found" << std::endl;
 #endif
@@ -776,7 +776,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
             expectedSize,&storePtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "HousekeepingManager::generateHousekeepingPacket: "
                 << "Could not get free element from IPC store." << std::endl;
 #endif
@@ -788,7 +788,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     result = setPacket.serialize(&storePtr, &size, expectedSize,
             SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "HousekeepingManager::generateSetStructurePacket: "
                 << "Expected size is not equal to serialized size" << std::endl;
 #endif
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 37ae8152a..0e98b90cb 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -375,7 +375,7 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
 		        "not found." << std::endl;
 #endif
@@ -384,7 +384,7 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "HousekeepingManager::fetchPoolEntry:"
 				" Pool entry not found." << std::endl;
 #endif
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 8e13b602b..dbe34dfd3 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -12,7 +12,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
     if(hkOwner == nullptr) {
         // Configuration error.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
                 << "invalid!" << std::endl;
 #endif
@@ -149,7 +149,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
         auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
                 size, maxSize, streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
                     " error!" << std::endl;
 #endif
@@ -210,7 +210,7 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
 
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "Pool Raw Access: Bit setting invalid position"
                 << std::endl;
 #endif
@@ -262,7 +262,7 @@ sid_t LocalPoolDataSetBase::getSid() const {
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
         uint8_t position) const {
     if(position > 7) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "Pool Raw Access: Bit setting invalid position"
                 << std::endl;
 #endif
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 5abef424f..4b57dede4 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -5,13 +5,13 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
         pool_rwm_t setReadWriteMode): localPoolId(poolId),
         readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;
 #endif
     }
     if(hkOwner == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
                 << "owner is a invalid!" << std::endl;
 #endif
@@ -27,7 +27,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
         readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;
 #endif
@@ -35,7 +35,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
     HasLocalDataPoolIF* hkOwner =
             objectManager->get<HasLocalDataPoolIF>(poolOwner);
     if(hkOwner == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolVariable: The supplied pool owner did not "
                 << "implement the correct interface"
                 << " HasLocalDataPoolIF!" << std::endl;
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 38e9cf4bc..aa5e5393b 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -33,7 +33,7 @@ inline ReturnValue_t LocalPoolVariable<T>::read(dur_millis_t lockTimeout) {
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
 #endif
@@ -43,7 +43,7 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK or poolEntry == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				<< std::hex << std::setw(8) << std::setfill('0')
 				<< hkManager->getOwner() << " and lp ID " << localPoolId
@@ -66,7 +66,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVariable: Invalid read write "
 				 "mode for commit() call." << std::endl;
 #endif
@@ -75,7 +75,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
 				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index dc91fb9b7..5c3b0ce01 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -32,7 +32,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout)
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
 #endif
@@ -44,7 +44,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	memset(this->value, 0, vectorSize * sizeof(T));
 
 	if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
 				hkManager->getOwner() << "and lp ID 0x" << localPoolId <<
@@ -68,7 +68,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for commit() call." << std::endl;
 #endif
@@ -77,7 +77,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
 				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
@@ -97,7 +97,7 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
 	}
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
 #endif
@@ -111,7 +111,7 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
 	}
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
 #endif
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index bf962c959..a059685bf 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -14,7 +14,7 @@ public:
 		if(readObject != nullptr) {
 			readResult = readObject->read(mutexTimeout);
 #if FSFW_PRINT_VERBOSITY_LEVEL == 1
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PoolReadHelper: Read failed!" << std::endl;
 #endif
 #endif
diff --git a/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
index 443b2bbbc..b7f1fb3e1 100644
--- a/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
+++ b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
@@ -15,7 +15,7 @@ ReturnValue_t pst::pollingSequenceInitDefault(
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
 		        << std::endl;
 #endif
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index da2b823dc..1af6932ae 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -39,7 +39,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		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 "
@@ -132,7 +132,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	communicationInterface = objectManager->get<DeviceCommunicationIF>(
 			deviceCommunicationId);
 	if (communicationInterface == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerBase::initialize: Communication interface "
 				"invalid." << std::endl;
 		sif::error << "Make sure it is set up properly and implements"
@@ -143,7 +143,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "DeviceHandlerBase::initialize: Initializing "
 	            "communication interface failed!" << std::endl;
 #endif
@@ -152,7 +152,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
 				"factory." << std::endl;
 #endif
@@ -164,7 +164,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			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"
@@ -178,7 +178,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			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"
@@ -720,7 +720,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
 			if(foundLen == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
 			            " Packet parsing will be stuck." << std::endl;
 #endif
@@ -734,7 +734,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 			            foundId);
 			}
 			if(foundLen == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
 			            " Packet parsing will be stuck." << std::endl;
 #endif
@@ -1291,7 +1291,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
 		    //so we can track misconfigurations
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::debug << std::hex << getObjectId()
 					<< ": DHB::buildInternalCommand: Busy" << std::dec
 					<< std::endl;
@@ -1320,7 +1320,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
 			//so we can track misconfigurations
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::debug << std::hex << getObjectId()
 					<< ": DHB::buildInternalCommand: Command "
 					<< deviceCommandId << " isExecuting" << std::dec
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index c7f878590..5f7ab89f6 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -169,7 +169,7 @@ void DeviceHandlerFailureIsolation::clearFaultCounters() {
 ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
 	ReturnValue_t result = FailureIsolationBase::initialize();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerFailureIsolation::initialize: Could not"
 				" initialize FailureIsolationBase." << std::endl;
 #endif
@@ -252,7 +252,7 @@ bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
 
 	if (owner == nullptr) {
 	    // Configuration error.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "DeviceHandlerFailureIsolation::"
 	            << "isFdirInActionOrAreWeFaulty: Owner not set!" << std::endl;
 #endif
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 6742ff861..65e19d102 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -122,7 +122,7 @@ void EventManager::printEvent(EventMessage* message) {
 	case severity::INFO:
 #if DEBUG_INFO_EVENT == 1
 		string = translateObject(message->getReporter());
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::info << "EVENT: ";
 		if (string != 0) {
 			sif::info << string;
@@ -133,12 +133,12 @@ void EventManager::printEvent(EventMessage* message) {
 				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
 				<< message->getParameter1() << " P2: 0x"
 				<< message->getParameter2() << std::dec << std::endl;
-#endif /* CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* DEBUG_INFO_EVENT == 1 */
 		break;
 	default:
 		string = translateObject(message->getReporter());
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "EventManager: ";
 		if (string != 0) {
 			sif::debug << string;
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index fed301b5a..69cb0f018 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -21,7 +21,7 @@ ReturnValue_t FailureIsolationBase::initialize() {
 	EventManagerIF* manager = objectManager->get<EventManagerIF>(
 			objects::EVENT_MANAGER);
 	if (manager == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "FailureIsolationBase::initialize: Event Manager has not"
 				" been initialized!" << std::endl;
 #endif
@@ -38,7 +38,7 @@ ReturnValue_t FailureIsolationBase::initialize() {
 		}
 		owner = objectManager->get<HasHealthIF>(ownerId);
 		if (owner == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "FailureIsolationBase::intialize: Owner object "
 					"invalid. Make sure it implements HasHealthIF" << std::endl;
 #endif
@@ -49,11 +49,11 @@ ReturnValue_t FailureIsolationBase::initialize() {
 		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
 				faultTreeParent);
 		if (parentIF == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "FailureIsolationBase::intialize: Parent object"
 					<< "invalid." << std::endl;
 #endif
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "Make sure it implements ConfirmsFailuresIF."
 					<< std::endl;
 #endif
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index c14cc7c62..d0b0a3bf4 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -4,7 +4,7 @@
 
 void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 		bool printInfo, size_t maxCharPerLine) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	if(printInfo) {
 		sif::info << "Printing data with size " << size << ": ";
 	}
@@ -23,7 +23,7 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 
 void arrayprinter::printHex(const uint8_t *data, size_t size,
 		size_t maxCharPerLine) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::info << std::hex;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
@@ -42,7 +42,7 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 
 void arrayprinter::printDec(const uint8_t *data, size_t size,
 		size_t maxCharPerLine) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::info << std::dec;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << static_cast<int>(data[i]);
@@ -58,7 +58,7 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
 }
 
 void arrayprinter::printBin(const uint8_t *data, size_t size) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::info << "\n" << std::flush;
     for(size_t i = 0; i < size; i++) {
         sif::info << "Byte " << i + 1 << ": 0b"<<
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index de795a6c5..231d616e2 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -41,7 +41,7 @@ ReturnValue_t HealthHelper::initialize() {
 	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
 
 	if (healthTable == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "HealthHelper::initialize: Health table object needs"
 	            "to be created in factory." << std::endl;
 #endif
@@ -49,7 +49,7 @@ ReturnValue_t HealthHelper::initialize() {
 	}
 
 	if(eventSender == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "HealthHelper::initialize: Owner has to implement "
 	            "ReportingProxyIF." << std::endl;
 #endif
@@ -83,7 +83,7 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 			health, oldHealth);
 	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
 	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "HealthHelper::informParent: sending health reply failed."
 				<< std::endl;
 #endif
@@ -104,7 +104,7 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
 	}
 	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
 	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "HealthHelper::handleHealthCommand: sending health "
 		        "reply failed." << std::endl;
 #endif
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index a2dc529d9..48b6f851b 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -32,7 +32,7 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 #if FSFW_ENHANCED_PRINTOUT == 1
 	if(diagnosticPrintout) {
 	    if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	        sif::debug << "InternalErrorReporter::performOperation: Errors "
 	                << "occured!" << std::endl;
 	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index cdd4d9435..e97778c3f 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -15,7 +15,7 @@ MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
 		this->messageSize = this->HEADER_SIZE + size;
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
 				"allowed size! Setting content to 0" << std::endl;
 #endif
@@ -54,7 +54,7 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
 }
 
 void MessageQueueMessage::print(bool printWholeMessage) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "MessageQueueMessage content: " << std::endl;
 #endif
 	if(printWholeMessage) {
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index bd2f51875..befa69bcd 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -12,13 +12,13 @@ public:
 		ReturnValue_t status = mutex->lockMutex(timeoutType,
 		        timeoutMs);
 		if(status == MutexIF::MUTEX_TIMEOUT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
 					<< timeoutMs << " milliseconds!" << std::endl;
 #endif
 		}
 		else if(status != HasReturnvaluesIF::RETURN_OK){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MutexHelper: Lock of Mutex failed with code "
 			        << status << std::endl;
 #endif
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 1d2a62a9d..42ac26544 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -16,7 +16,7 @@ ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
 	lastSender = message->getSender();
 	lastCommand = message->getCommand();
 	if (busy) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "MemHelper: Busy!" << std::endl;
 #endif
 	}
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index 44661e4c9..2822743ac 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -72,7 +72,7 @@ private:
 		if (timeStamper == nullptr) {
 			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
 			if ( timeStamper == nullptr ) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error << "MonitoringReportContent::checkAndSetStamper: "
 				        "Stamper not found!" << std::endl;
 #endif
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 251dbc707..69dd905ba 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,7 +1,7 @@
 #include "ObjectManager.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 #include <iomanip>
 #endif
 #include <cstdlib>
@@ -21,13 +21,13 @@ ObjectManager::~ObjectManager() {
 ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 	auto returnPair = objectList.emplace(id, object);
 	if (returnPair.second) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    // sif::debug << "ObjectManager::insert: Object " << std::hex
 	    //            << (int)id << std::dec << " inserted." << std::endl;
 #endif
 		return this->RETURN_OK;
 	} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::insert: Object id " << std::hex
 		           << static_cast<uint32_t> id << std::dec
 				   << " is already in use!" << std::endl;
@@ -41,13 +41,13 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 ReturnValue_t ObjectManager::remove( object_id_t id ) {
 	if ( this->getSystemObject(id) != NULL ) {
 		this->objectList.erase( id );
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
 		//           << (int)id << std::dec << " removed." << std::endl;
 #endif
 		return RETURN_OK;
 	} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::removeObject: Requested object "
 		        << std::hex << (int)id << std::dec << " not found." << std::endl;
 #endif
@@ -72,7 +72,7 @@ ObjectManager::ObjectManager() : produceObjects(nullptr) {
 
 void ObjectManager::initialize() {
 	if(produceObjects == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::initialize: Passed produceObjects "
 				"functions is nullptr!" << std::endl;
 #endif
@@ -84,7 +84,7 @@ void ObjectManager::initialize() {
 	for (auto const& it : objectList) {
 		result = it.second->initialize();
 		if ( result != RETURN_OK ) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			object_id_t var = it.first;
 			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
 					std::setw(8) << std::setfill('0')<< var << " failed to "
@@ -95,7 +95,7 @@ void ObjectManager::initialize() {
 		}
 	}
 	if (errorCount > 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
 		           << " failed initializations." << std::endl;
 #endif
@@ -105,7 +105,7 @@ void ObjectManager::initialize() {
 	for (auto const& it : objectList) {
 		result = it.second->checkObjectConnections();
 		if ( result != RETURN_OK ) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
 					(int) it.first  << " connection check failed with code 0x"
 					<< result << std::dec << std::endl;
@@ -114,7 +114,7 @@ void ObjectManager::initialize() {
 		}
 	}
 	if (errorCount > 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
 		           << " failed connection checks." << std::endl;
 #endif
@@ -122,7 +122,7 @@ void ObjectManager::initialize() {
 }
 
 void ObjectManager::printList() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "ObjectManager: Object List contains:" << std::endl;
 	for (auto const& it : objectList) {
 		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 167006256..8bebb609e 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -86,7 +86,7 @@ extern ObjectManagerIF *objectManager;
 template <typename T>
 T* ObjectManagerIF::get( object_id_t id ) {
 	if(objectManager == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManagerIF: Global object manager has not "
 				"been initialized yet!" << std::endl;
 #endif
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index d9f4a3cb7..7d609aeed 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -8,7 +8,7 @@
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Could not retrieve task handle. Please ensure the"
 				"constructor was called inside a task." << std::endl;
 #endif
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 3915afe90..c0349b7c9 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -5,7 +5,7 @@
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
 #endif
 	}
@@ -20,7 +20,7 @@ BinarySemaphore::~BinarySemaphore() {
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "Binary semaphore creation failure" << std::endl;
 #endif
     }
@@ -32,7 +32,7 @@ BinarySemaphore& BinarySemaphore::operator =(
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "Binary semaphore creation failure" << std::endl;
 #endif
         }
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index e66f044d7..750ea9d65 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -9,7 +9,7 @@
 CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 		uint8_t initCount): maxCount(maxCount) {
 	if(initCount > maxCount) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
 				"intial cout. Setting initial count to max count." << std::endl;
 #endif
@@ -18,7 +18,7 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Could not retrieve task "
 				"handle. Please ensure the constructor was called inside a "
 				"task." << std::endl;
@@ -29,7 +29,7 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite,
 			&oldNotificationValue);
 	if(oldNotificationValue != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		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;
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index 2521e52ed..40884d273 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -10,7 +10,7 @@
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
 	if(initCount > maxCount) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
 				"intial cout. Setting initial count to max count." << std::endl;
 #endif
@@ -19,7 +19,7 @@ CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 
 	handle = xSemaphoreCreateCounting(maxCount, initCount);
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
 #endif
 	}
@@ -29,7 +29,7 @@ CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
 		maxCount(other.maxCount), initCount(other.initCount) {
 	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
 #endif
 	}
@@ -39,7 +39,7 @@ CountingSemaphore& CountingSemaphore::operator =(
 		CountingSemaphore&& other) {
 	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
 #endif
 	}
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 6b289df78..aa7e6c59b 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -37,7 +37,7 @@ void FixedTimeslotTask::taskEntryPoint(void* argument) {
 	}
 
 	originalTask->taskFunctionality();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->handle
 			<< " returned from taskFunctionality." << std::endl;
 #endif
@@ -46,7 +46,7 @@ void FixedTimeslotTask::taskEntryPoint(void* argument) {
 void FixedTimeslotTask::missedDeadlineCounter() {
 	FixedTimeslotTask::deadlineMissedCount++;
 	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
 #endif
@@ -73,7 +73,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
 #endif
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 27b9a769d..c0c82cf11 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -10,7 +10,7 @@
 MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		maxMessageSize(maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	if (handle == nullptr) {
 		sif::error << "MessageQueue::MessageQueue:"
 		        << " Creation failed." << std::endl;
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 1722660c8..0b85ca135 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -5,7 +5,7 @@
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
 #endif
 	}
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 155f6ac70..3e830c7f3 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -13,7 +13,7 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 	BaseType_t status = xTaskCreate(taskEntryPoint, name,
 			stackSize, this, setPriority, &handle);
 	if(status != pdPASS){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
 		        "Status: " << status << std::endl;
 #endif
@@ -43,7 +43,7 @@ void PeriodicTask::taskEntryPoint(void* argument) {
 	}
 
 	originalTask->taskFunctionality();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->handle
 			<< " returned from taskFunctionality." << std::endl;
 #endif
@@ -103,7 +103,7 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
 	            "it implement ExecutableObjectIF" << std::endl;
 #endif
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 4db46c69e..df005f6a5 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -32,7 +32,7 @@ SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
 		return new BinarySemaphoreUsingTask();
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
 				"binary semaphore" << std::endl;
 #endif
@@ -49,7 +49,7 @@ SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount,
 		return new CountingSemaphoreUsingTask(maxCount, initCount);
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
 						"binary semaphore" << std::endl;
 #endif
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 7a763a602..2bc78785f 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -14,7 +14,7 @@ MutexIF* Clock::timeMutex = NULL;
 using SystemClock = std::chrono::system_clock;
 
 uint32_t Clock::getTicksPerSecond(void){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getTicksPerSecond: not implemented yet" << std::endl;
 #endif
 	return 0;
@@ -25,7 +25,7 @@ uint32_t Clock::getTicksPerSecond(void){
 
 ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
 	// do some magic with chrono
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::setClock: not implemented yet" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_OK;
@@ -40,7 +40,7 @@ ReturnValue_t Clock::setClock(const timeval* time) {
 #else
 
 #endif
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_FAILED;
@@ -66,7 +66,7 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 	time->tv_usec = timeUnix.tv_nsec / 1000.0;
 	return HasReturnvaluesIF::RETURN_OK;
 #else
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_FAILED;
@@ -76,7 +76,7 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 	// do some magic with chrono
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::gerClock_usecs: not implemented yet" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_OK;
@@ -100,7 +100,7 @@ timeval Clock::getUptime() {
 		timeval.tv_usec = uptimeSeconds *(double) 1e6 - (timeval.tv_sec *1e6);
 	}
 #else
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
 #endif
 #endif
@@ -138,7 +138,7 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 	auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
 	time->usecond = usecond.count();
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	//sif::warning << "Clock::getDateAndTime: not implemented yet" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_OK;
@@ -162,7 +162,7 @@ ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
 	to->tv_usec = from->usecond;
 	//Fails in 2038..
 	return HasReturnvaluesIF::RETURN_OK;
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::convertTimeBla: not implemented yet" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 1fd3cd7f0..272d99b9a 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -35,7 +35,7 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             ABOVE_NORMAL_PRIORITY_CLASS);
     if(result != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
 #endif
@@ -44,7 +44,7 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             THREAD_PRIORITY_NORMAL);
     if(result != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
 #endif
@@ -74,7 +74,7 @@ void FixedTimeslotTask::taskEntryPoint(void* argument) {
     }
 
     this->taskFunctionality();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::debug << "FixedTimeslotTask::taskEntryPoint: "
             "Returned from taskFunctionality." << std::endl;
 #endif
@@ -140,7 +140,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
         return HasReturnvaluesIF::RETURN_OK;
     }
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "Component " << std::hex << componentId <<
             " not found, not adding it to pst" << std::endl;
 #endif
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 0c0481203..dfc045e8d 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -10,7 +10,7 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 	queueLock = MutexFactory::instance()->createMutex();
 	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue:"
 		        << " Could not be created" << std::endl;
 #endif
@@ -139,7 +139,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			targetQueue->messageQueue.push(*mqmMessage);
 		}
 		else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessageFromMessageQueue: Message"
 					"is not MessageQueueMessage!" << std::endl;
 #endif
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 09acd2cb2..1f4275464 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -33,7 +33,7 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             ABOVE_NORMAL_PRIORITY_CLASS);
     if(result != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
 #endif
@@ -42,7 +42,7 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             THREAD_PRIORITY_NORMAL);
     if(result != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
 #endif
@@ -73,7 +73,7 @@ void PeriodicTask::taskEntryPoint(void* argument) {
 	}
 
 	this->taskFunctionality();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "PeriodicTask::taskEntryPoint: "
 			"Returned from taskFunctionality." << std::endl;
 #endif
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 620f8add3..7ffd47583 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -26,7 +26,7 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 	auto returnPair = queueMap.emplace(currentId, queueToInsert);
 	if(not returnPair.second) {
 		// this should never happen for the atomic variable.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "QueueMapManager: This ID is already inside the map!"
 				<< std::endl;
 #endif
@@ -46,7 +46,7 @@ MessageQueueIF* QueueMapManager::getMessageQueue(
 		return queueIter->second;
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "QueueMapManager::getQueueHandle: The ID " <<
 				messageQueueId << " does not exists in the map" << std::endl;
 #endif
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index 840dacef5..3d3fe17f3 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -21,7 +21,7 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
 	// Just gonna wait for full C++20 for now.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "SemaphoreFactory: Binary Semaphore not implemented yet."
 			" Returning nullptr!\n" << std::flush;
 #endif
@@ -31,7 +31,7 @@ SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
 		uint8_t initCount, uint32_t arguments) {
 	// Just gonna wait for full C++20 for now.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
 				" Returning nullptr!\n" << std::flush;
 #endif
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 22d35e3a2..0a6bb29f0 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -43,7 +43,7 @@ ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
 		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
 	    result = sem_timedwait(&handle, &timeOut);
 	    if(result != 0 and errno == EINVAL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    	sif::debug << "BinarySemaphore::acquire: Invalid time value possible"
 	    			<< std::endl;
 #endif
@@ -64,7 +64,7 @@ ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
 		return SemaphoreIF::SEMAPHORE_INVALID;
 	case(EINTR):
 		// Call was interrupted by signal handler
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted."
 				"Code " << strerror(errno) << std::endl;
 #endif
@@ -130,7 +130,7 @@ void BinarySemaphore::initSemaphore(uint8_t initCount) {
 			// Value exceeds SEM_VALUE_MAX
 		case(ENOSYS):
 		// System does not support process-shared semaphores
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
 				<< std::endl;
 #endif
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index e4e7df86f..54dad8395 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -69,7 +69,7 @@ timeval Clock::getUptime() {
 	timeval uptime;
 	auto result = getUptime(&uptime);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
 #endif
 	}
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
index 22cb16154..0bb718319 100644
--- a/osal/linux/CountingSemaphore.cpp
+++ b/osal/linux/CountingSemaphore.cpp
@@ -4,7 +4,7 @@
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
 	if(initCount > maxCount) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
 				"intial cout. Setting initial count to max count." << std::endl;
 #endif
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 0635b5601..a545eeb7d 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -47,7 +47,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::dec << std::endl;
 #endif
@@ -93,7 +93,7 @@ void FixedTimeslotTask::taskFunctionality() {
 void FixedTimeslotTask::missedDeadlineCounter() {
 	FixedTimeslotTask::deadlineMissedCount++;
 	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
 				   << " deadlines." << std::endl;
 #endif
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 28dfb9c73..e7b09b4f9 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -42,14 +42,14 @@ MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
 MessageQueue::~MessageQueue() {
 	int status = mq_close(this->id);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
 				   << strerror(errno) <<std::endl;
 #endif
 	}
 	status = mq_unlink(name);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
 				   << strerror(errno) << std::endl;
 #endif
@@ -60,7 +60,7 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		uint32_t messageDepth) {
 	switch(errno) {
 	case(EINVAL): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
 				" for message size" << std::endl;
 #endif
@@ -84,7 +84,7 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
 			Apply changes with: sudo sysctl -p
 			*/
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::MessageQueue: Default MQ size "
 					<< defaultMqMaxMsg << " is too small for requested size "
 					<< messageDepth << std::endl;
@@ -102,7 +102,7 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		//We unlink the other queue
 		int status = mq_unlink(name);
 		if (status != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "mq_unlink Failed with status: " << strerror(errno)
 													<< std::endl;
 #endif
@@ -123,7 +123,7 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 
 	default:
 		// Failed either the first time or the second time
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 		<< name << std::dec << " failed with status: "
 		<< strerror(errno) << std::endl;
@@ -162,7 +162,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	if(message == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::receiveMessage: Message is "
 				"nullptr!" << std::endl;
 #endif
@@ -170,7 +170,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	}
 
 	if(message->getMaximumMessageSize() < maxMessageSize) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::receiveMessage: Message size "
 				<< message->getMaximumMessageSize()
 				<< " too small to receive data!" << std::endl;
@@ -202,7 +202,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			return MessageQueueIF::EMPTY;
 		case EBADF:
 			//mqdes doesn't represent a valid queue open for reading.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::receive: configuration error "
 			           << strerror(errno)  << std::endl;
 #endif
@@ -217,7 +217,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
 			 *   been set in the queue's mq_flags.
 			 */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::receive: configuration error "
 					   << strerror(errno)  << std::endl;
 #endif
@@ -232,7 +232,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			 *   given msg_len is too short for the message that would have
 			 *   been received.
 			 */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::receive: configuration error "
 			           << strerror(errno)  << std::endl;
 #endif
@@ -258,7 +258,7 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		switch(errno){
 		case EBADF:
 			//mqdes doesn't represent a valid message queue.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::flush configuration error, "
 					"called flush with an invalid queue ID" << std::endl;
 #endif
@@ -276,7 +276,7 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		switch(errno){
 		case EBADF:
 			//mqdes doesn't represent a valid message queue.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::flush configuration error, "
 					"called flush with an invalid queue ID" << std::endl;
 #endif
@@ -331,7 +331,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	if(message == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
 				"nullptr!" << std::endl;
 #endif
@@ -362,7 +362,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		case EBADF: {
 			//mq_des doesn't represent a valid message queue descriptor,
 			//or mq_des wasn't opened for writing.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
 					<< " destination invalid."  << std::endl;
 			sif::error << strerror(errno) << " in "
@@ -383,7 +383,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
 			 *   msg_prio is greater than the priority of the calling process.
 			 */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessage: Configuration error "
 			           << strerror(errno) << " in mq_send" << std::endl;
 #endif
@@ -391,7 +391,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		case EMSGSIZE:
 			// The msg_len is greater than the msgsize associated with
 			//the specified queue.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessage: Size error [" <<
 					strerror(errno) << "] in mq_send" << std::endl;
 #endif
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index e20126346..c642b1321 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -12,20 +12,20 @@ Mutex::Mutex() {
 	pthread_mutexattr_t mutexAttr;
 	int status = pthread_mutexattr_init(&mutexAttr);
 	if (status != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
 #endif
 	}
 	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
 	if (status != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
 				<< std::endl;
 #endif
 	}
 	status = pthread_mutex_init(&mutex, &mutexAttr);
 	if (status != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
 				<< ", " << " failed with " << strerror(status) << std::endl;
 #endif
@@ -35,7 +35,7 @@ Mutex::Mutex() {
 	// (including destruction) shall not affect any previously initialized mutexes.
 	status = pthread_mutexattr_destroy(&mutexAttr);
 	if (status != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
 #endif
 	}
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index 1c69124d7..a8f2de601 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -25,7 +25,7 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
 				<< " it implements ExecutableObjectIF!" << std::endl;
 #endif
@@ -44,7 +44,7 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
 
 ReturnValue_t PeriodicPosixTask::startTask(void) {
 	started = true;
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	//sif::info << stackSize << std::endl;
 #endif
 	PosixThread::createTask(&taskEntryPoint,this);
@@ -71,13 +71,13 @@ void PeriodicPosixTask::taskFunctionality(void) {
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(), name, sizeof(name));
 			if(status == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error << "PeriodicPosixTask " << name << ": Deadline "
 						"missed." << std::endl;
 #endif
 			}
 			else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
 						status << std::endl;
 #endif
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 80bf52c2d..a0e540cfd 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -48,7 +48,7 @@ void PosixThread::suspend() {
 	sigaddset(&waitSignal, SIGUSR1);
 	sigwait(&waitSignal, &caughtSig);
 	if (caughtSig != SIGUSR1) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
 				caughtSig << std::endl;
 #endif
@@ -120,7 +120,7 @@ uint64_t PosixThread::getCurrentMonotonicTimeMs(){
 
 
 void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	//sif::debug << "PosixThread::createTask" << std::endl;
 #endif
 	/*
@@ -133,7 +133,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	pthread_attr_t attributes;
 	int status = pthread_attr_init(&attributes);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute init failed with: " <<
 				strerror(status) << std::endl;
 #endif
@@ -141,19 +141,19 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	void* stackPointer;
 	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PosixThread::createTask: Stack init failed with: " <<
 				strerror(status) << std::endl;
 #endif
 		if(errno == ENOMEM) {
 			uint64_t stackMb = stackSize/10e6;
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Insufficient memory for"
 					" the requested " << stackMb << " MB" << std::endl;
 #endif
 		}
 		else if(errno == EINVAL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Wrong alignment argument!"
 					<< std::endl;
 #endif
@@ -163,7 +163,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PosixThread::createTask: pthread_attr_setstack "
 				" failed with: " << strerror(status) <<  std::endl;
 		sif::error << "Make sure the specified stack size is valid and is "
@@ -173,7 +173,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
 					strerror(status) << std::endl;
 #endif
@@ -182,7 +182,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	// TODO FIFO -> This needs root privileges for the process
 	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute schedule policy failed with: " <<
 				strerror(status) << std::endl;
 #endif
@@ -192,7 +192,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	scheduleParams.__sched_priority = priority;
 	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute schedule params failed with: " <<
 				strerror(status) << std::endl;
 #endif
@@ -204,7 +204,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	sigaddset(&waitSignal, SIGUSR1);
 	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread sigmask failed failed with: " <<
 				strerror(status) << " errno: " << strerror(errno) << std::endl;
 #endif
@@ -213,7 +213,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_create(&thread,&attributes,fnc_,arg_);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread create failed with: " <<
 				strerror(status) << std::endl;
 #endif
@@ -221,19 +221,19 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_setname_np(thread,name);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PosixThread::createTask: setname failed with: " <<
 				strerror(status) << std::endl;
 #endif
 		if(status == ERANGE) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Task name length longer"
 					" than 16 chars. Truncating.." << std::endl;
 #endif
 			name[15] = '\0';
 			status = pthread_setname_np(thread,name);
 			if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error << "PosixThread::createTask: Setting name"
 						" did not work.." << std::endl;
 #endif
@@ -243,7 +243,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_attr_destroy(&attributes);
 	if(status!=0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute destroy failed with: " <<
 				strerror(status) << std::endl;
 #endif
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 9cbb1d02d..a8387e87f 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -39,7 +39,7 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
 		if(bytesReceived < 0) {
 			// handle error
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcSocketPollingTask::performOperation: Reception"
 					"error." << std::endl;
 #endif
@@ -47,7 +47,7 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 
 			continue;
 		}
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
 //				<< " bytes received" << std::endl;
 #endif
@@ -69,7 +69,7 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 			receptionBuffer.data(), bytesRead);
 	// arrayprinter::print(receptionBuffer.data(), bytesRead);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
 				"storage failed" << std::endl;
 		sif::error << "Packet size: " << bytesRead << std::endl;
@@ -81,7 +81,7 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 
 	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Serial Polling: Sending message to queue failed"
 				<< std::endl;
 #endif
@@ -93,7 +93,7 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 ReturnValue_t TcUnixUdpPollingTask::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
 				<< std::endl;
 #endif
@@ -102,7 +102,7 @@ ReturnValue_t TcUnixUdpPollingTask::initialize() {
 
 	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
 	if(tmtcBridge == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
 				" TMTC bridge object!" << std::endl;
 #endif
@@ -127,7 +127,7 @@ void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
 	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
 			&tval, sizeof(receptionTimeout));
 	if(result == -1) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
 				"receive timeout failed with " << strerror(errno) << std::endl;
 #endif
@@ -140,14 +140,14 @@ void TcUnixUdpPollingTask::handleReadError() {
 	case(EAGAIN): {
 		// todo: When working in timeout mode, this will occur more often
 		// and is not an error.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcUnixUdpPollingTask::handleReadError: Timeout."
 				<< std::endl;
 #endif
 		break;
 	}
 	default: {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcUnixUdpPollingTask::handleReadError: "
 				<< strerror(errno) << std::endl;
 #endif
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index 0142025ef..fe0fbebba 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -10,7 +10,7 @@ Timer::Timer() {
 	sigEvent.sigev_value.sival_ptr = &timerId;
 	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
 	if(status!=0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Timer creation failed with: " << status <<
 				" errno: " << errno << std::endl;
 #endif
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 769e8affb..1d318d3b0 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -26,7 +26,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	//clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 	if(serverSocket < 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
 				" UDP socket!" << std::endl;
 #endif
@@ -53,7 +53,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 			reinterpret_cast<struct sockaddr*>(&serverAddress),
 			serverAddressLen);
 	if(result == -1) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
 				"local port " << setServerPort << " to server socket!"
 				<< std::endl;
@@ -78,7 +78,7 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	}
 
 //	char ipAddress [15];
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
 //					&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 #endif
@@ -86,13 +86,13 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
 			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
 	if(bytesSent < 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
 				<< std::endl;
 #endif
 		handleSendError();
 	}
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
 //			" sent." << std::endl;
 #endif
@@ -103,7 +103,7 @@ void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
 	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //	char ipAddress [15];
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //	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,
@@ -129,13 +129,13 @@ void TmTcUnixUdpBridge::handleSocketError() {
 	case(ENOBUFS):
 	case(ENOMEM):
 	case(EPROTONOSUPPORT):
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSocketError: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
 #endif
 		break;
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSocketError: Unknown error"
 				<< std::endl;
 #endif
@@ -151,7 +151,7 @@ void TmTcUnixUdpBridge::handleBindError() {
 		 Ephermeral ports can be shown with following command:
 		 sysctl -A | grep ip_local_port_range
 		 */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		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."
@@ -171,14 +171,14 @@ void TmTcUnixUdpBridge::handleBindError() {
 	case(ENOMEM):
 	case(ENOTDIR):
 	case(EROFS): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleBindError: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
 #endif
 		break;
 	}
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleBindError: Unknown error"
 				<< std::endl;
 #endif
@@ -189,7 +189,7 @@ void TmTcUnixUdpBridge::handleBindError() {
 void TmTcUnixUdpBridge::handleSendError() {
 	switch(errno) {
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSendError: "
 		        << strerror(errno) << std::endl;
 #endif
diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index eff8a0fb6..bfaf35690 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -9,7 +9,7 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 	rtems_status_code status = rtems_message_queue_create(name, message_depth,
 			max_message_size, 0, &(this->id));
 	if (status != RTEMS_SUCCESSFUL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 				<< name << std::dec << " failed with status:"
 				<< (uint32_t) status << std::endl;
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index a315681b8..b111f724c 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -30,7 +30,7 @@ ReturnValue_t MultiObjectTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
 #endif
@@ -65,7 +65,7 @@ void MultiObjectTask::taskFunctionality() {
 			char nameSpace[8] = { 0 };
 			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
 					nameSpace);
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
 #endif
 			if (this->deadlineMissedFunc != nullptr) {
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index 5278a076f..71c5782ff 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -10,7 +10,7 @@ Mutex::Mutex() :
 	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
 			&mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
 				<< " failed with " << status << std::endl;
 #endif
@@ -20,7 +20,7 @@ Mutex::Mutex() :
 Mutex::~Mutex() {
 	rtems_status_code status = rtems_semaphore_delete(mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: deletion for id " << mutexId
 				<< " failed with " << status << std::endl;
 #endif
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index 591ba743c..0ebf63e2e 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -35,7 +35,7 @@ rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
 	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
 	//The task's functionality is called.
 	originalTask->taskFunctionality();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->getId()
 			<< " returned from taskFunctionality." << std::endl;
 #endif
@@ -44,7 +44,7 @@ rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
 void PollingTask::missedDeadlineCounter() {
 	PollingTask::deadlineMissedCount++;
 	if (PollingTask::deadlineMissedCount % 10 == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << PollingTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
 #endif
@@ -55,7 +55,7 @@ ReturnValue_t PollingTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PollingTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
 #endif
@@ -81,7 +81,7 @@ ReturnValue_t PollingTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
 #endif
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index 7e3bd57aa..6abfcca8d 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -22,7 +22,7 @@ TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
 	}
 	ReturnValue_t result = convertReturnCode(status);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TaskBase::TaskBase: createTask with name " << std::hex
 				<< osalName << std::dec << " failed with return code "
 				<< (uint32_t) status << std::endl;
diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index e59316096..4fd88c937 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -43,14 +43,14 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 				&senderAddressSize);
 		if(bytesReceived == SOCKET_ERROR) {
 			// handle error
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcWinUdpPollingTask::performOperation: Reception"
 					" error." << std::endl;
 #endif
 			handleReadError();
 			continue;
 		}
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		//sif::debug << "TcWinUdpPollingTask::performOperation: " << bytesReceived
 		//		<< " bytes received" << std::endl;
 #endif
@@ -72,7 +72,7 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 			receptionBuffer.data(), bytesRead);
 	// arrayprinter::print(receptionBuffer.data(), bytesRead);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
 				"storage failed" << std::endl;
 		sif::error << "Packet size: " << bytesRead << std::endl;
@@ -84,7 +84,7 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 
 	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Serial Polling: Sending message to queue failed"
 				<< std::endl;
 #endif
@@ -96,7 +96,7 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 ReturnValue_t TcWinUdpPollingTask::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
 				<< std::endl;
 #endif
@@ -105,7 +105,7 @@ ReturnValue_t TcWinUdpPollingTask::initialize() {
 
 	tmtcBridge = objectManager->get<TmTcWinUdpBridge>(tmtcBridgeId);
 	if(tmtcBridge == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
 				" TMTC bridge object!" << std::endl;
 #endif
@@ -113,7 +113,7 @@ ReturnValue_t TcWinUdpPollingTask::initialize() {
 	}
 
 	serverUdpSocket = tmtcBridge->serverSocket;
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	//sif::info << "TcWinUdpPollingTask::initialize: Server UDP socket "
 	//        << serverUdpSocket << std::endl;
 #endif
@@ -133,7 +133,7 @@ void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
 	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
 			reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
 	if(result == -1) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcWinUdpPollingTask::TcSocketPollingTask: Setting "
 				"receive timeout failed with " << strerror(errno) << std::endl;
 #endif
@@ -144,28 +144,28 @@ void TcWinUdpPollingTask::handleReadError() {
     int error = WSAGetLastError();
     switch(error) {
     case(WSANOTINITIALISED): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call " << "necessary" << std::endl;
 #endif
         break;
     }
     case(WSAEFAULT): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: WSADEFAULT: "
                 << "Bad address " << std::endl;
 #endif
         break;
     }
     case(WSAEINVAL): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: WSAEINVAL: "
                 << "Invalid input parameters. " << std::endl;
 #endif
         break;
     }
     default: {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: Error code: "
                 << error << std::endl;
 #endif
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index b99451682..69a48f3ee 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -15,7 +15,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     if (err != 0) {
         /* Tell the user that we could not find a usable */
         /* Winsock DLL.                                  */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge:"
                 "WSAStartup failed with error: " << err << std::endl;
 #endif
@@ -36,7 +36,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     //clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
     serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
     if(serverSocket == INVALID_SOCKET) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open"
                 " UDP socket!" << std::endl;
 #endif
@@ -63,7 +63,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
             reinterpret_cast<struct sockaddr*>(&serverAddress),
             serverAddressLen);
     if(result != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
                 "local port " << setServerPort << " to server socket!"
                 << std::endl;
@@ -83,7 +83,7 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
     //clientAddressLen = sizeof(serverAddress);
 
 //  char ipAddress [15];
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //  sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
 //                  &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 #endif
@@ -92,13 +92,13 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
             reinterpret_cast<const char*>(data), dataLen, flags,
             reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
     if(bytesSent == SOCKET_ERROR) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::sendTm: Send operation failed."
                 << std::endl;
 #endif
         handleSendError();
     }
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //  sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
 //          " sent." << std::endl;
 #endif
@@ -109,7 +109,7 @@ void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
     MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //  char ipAddress [15];
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //  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,
@@ -128,7 +128,7 @@ void TmTcWinUdpBridge::handleSocketError() {
     int errCode = WSAGetLastError();
     switch(errCode) {
     case(WSANOTINITIALISED): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call necessary" << std::endl;
 #endif
@@ -139,7 +139,7 @@ void TmTcWinUdpBridge::handleSocketError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
          */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSocketError: Error code: "
                 << errCode << std::endl;
 #endif
@@ -152,14 +152,14 @@ void TmTcWinUdpBridge::handleBindError() {
     int errCode = WSAGetLastError();
     switch(errCode) {
     case(WSANOTINITIALISED): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleBindError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call " << "necessary" << std::endl;
 #endif
         break;
     }
     case(WSAEADDRINUSE): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     	sif::warning << "TmTcWinUdpBridge::handleBindError: WSAEADDRINUSE: "
     			<< "Port is already in use!" << std::endl;
 #endif
@@ -170,7 +170,7 @@ void TmTcWinUdpBridge::handleBindError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
         */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleBindError: Error code: "
                 << errCode << std::endl;
 #endif
@@ -183,14 +183,14 @@ void TmTcWinUdpBridge::handleSendError() {
     int errCode = WSAGetLastError();
     switch(errCode) {
     case(WSANOTINITIALISED): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSendError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call necessary" << std::endl;
 #endif
         break;
     }
     case(WSAEADDRNOTAVAIL): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSendError: WSAEADDRNOTAVAIL: "
                 << "Check target address. " << std::endl;
 #endif
@@ -201,7 +201,7 @@ void TmTcWinUdpBridge::handleSendError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
         */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSendError: Error code: "
                 << errCode << std::endl;
 #endif
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 5014e44c4..4ad5cdf25 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -48,7 +48,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
         ConstStorageAccessor accessor(storeId);
         result = storage->getData(storeId, accessor);
         if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "ParameterHelper::handleParameterMessage: Getting"
                     << " store data failed for load command." << std::endl;
 #endif
diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index f2c579d5a..ca761f14a 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -22,7 +22,7 @@ ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice)
 	case(Subservice::COMMAND_ANNOUNCE_HEALTH_ALL):
 		return RETURN_OK;
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Invalid Subservice" << std::endl;
 #endif
 		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index 9194ab24d..9e86c752a 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -51,7 +51,7 @@ ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
 		result = generateSuccessReport(message);
 	}
 	if(result != HasReturnvaluesIF::RETURN_OK){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service1TelecommandVerification::sendVerificationReport: "
 		        "Sending verification packet failed !" << std::endl;
 #endif
@@ -90,7 +90,7 @@ ReturnValue_t Service1TelecommandVerification::initialize() {
 	AcceptsTelemetryIF* funnel = objectManager->
 			get<AcceptsTelemetryIF>(targetDestination);
 	if(funnel == nullptr){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "Service1TelecommandVerification::initialize: Specified"
 	            " TM funnel invalid. Make sure it is set up and implements"
 	            " AcceptsTelemetryIF." << std::endl;
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index f79c0a79f..72db82df3 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -25,7 +25,7 @@ ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
 	case Subservice::COMMAND_TOGGLE_WIRETAPPING:
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Invalid Subservice" << std::endl;
 #endif
 		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
@@ -127,7 +127,7 @@ void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
 				static_cast<uint8_t>(Subservice::REPLY_RAW));
 		break;
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Unknown message in Service2DeviceAccess::"
 				"handleUnrequestedReply with command ID " <<
 				reply->getCommand() << std::endl;
@@ -147,7 +147,7 @@ void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
 	size_t size = 0;
 	ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
 	if(result != HasReturnvaluesIF::RETURN_OK){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
 		        "handleUnrequestedReply with failure ID "<< result
 		        << std::endl;
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index d52ab50db..ba7ff6ee4 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -222,7 +222,7 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 	}
 
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service3Housekeeping::handleReply: Invalid reply with "
 				<< "reply command " << command << "!" << std::endl;
 #endif
@@ -251,7 +251,7 @@ void Service3Housekeeping::handleUnrequestedReply(
 	}
 
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service3Housekeeping::handleUnrequestedReply: Invalid "
 		        << "reply with " << "reply command " << command << "!"
 		        << std::endl;
@@ -261,7 +261,7 @@ void Service3Housekeeping::handleUnrequestedReply(
 
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		// Configuration error
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "Service3Housekeeping::handleUnrequestedReply:"
 				<< "Could not generate reply!" << std::endl;
 #endif
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index 21bf27805..29eb7f20e 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -37,7 +37,7 @@ ReturnValue_t Service5EventReporting::performService() {
 	       }
 	    }
 	}
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug <<  "Service5EventReporting::generateEventReport:"
 	        " Too many events" << std::endl;
 #endif
@@ -55,7 +55,7 @@ ReturnValue_t Service5EventReporting::generateEventReport(
 	ReturnValue_t result = tmPacket.sendPacket(
 	        requestQueue->getDefaultDestination(),requestQueue->getId());
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "Service5EventReporting::generateEventReport:"
 		        " Could not send TM packet" << std::endl;
 #endif
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index df25dd857..49fa6ebe4 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -60,7 +60,7 @@ ReturnValue_t Service8FunctionManagement::prepareCommand(
 ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
 		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
     if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
                 << " TC size smaller thant minimum size of direct command."
                 << std::endl;
@@ -127,7 +127,7 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(
     const uint8_t * buffer = nullptr;
     ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
     if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "Service 8: Could not retrieve data for data reply"
                 << std::endl;
 #endif
@@ -139,7 +139,7 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(
 
     auto deletionResult = IPCStore->deleteData(storeId);
     if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "Service8FunctionManagement::handleReply: Deletion"
                 << " of data in pool failed." << std::endl;
 #endif
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 303de7421..53b8c3d53 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -95,7 +95,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 template<typename count_t>
 uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 	if(buffer == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Wrong access function for stored type !"
 				 " Use getConstBuffer()." << std::endl;
 #endif
@@ -107,7 +107,7 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "SerialBufferAdapter::getConstBuffer:"
 				" Buffers are unitialized!" << std::endl;
 #endif
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index abe296cb4..20ea61ddf 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,6 +1,6 @@
 #include "ServiceInterfaceBuffer.h"
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 
 #include "../timemanager/Clock.h"
 
@@ -256,4 +256,4 @@ void ServiceInterfaceBuffer::initSocket() {
 
 #endif //ML505
 
-#endif /* CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index d13143cdc..b1a508486 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -4,7 +4,7 @@
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <FSFWConfig.h>
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 
 #include <iostream>
 #include <sstream>
@@ -150,6 +150,6 @@ private:
 };
 #endif //ML505
 
-#endif /* CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index c618d989a..59526536c 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,6 +1,6 @@
 #include "ServiceInterfaceStream.h"
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
 		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index ddeded805..c18c6c2e3 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -3,7 +3,7 @@
 
 #include "ServiceInterfaceBuffer.h"
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 
 #include <iostream>
 #include <cstdio>
@@ -51,6 +51,6 @@ extern ServiceInterfaceStream warning;
 extern ServiceInterfaceStream error;
 }
 
-#endif /* CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */
diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 0beef64f3..39530ac9f 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -46,7 +46,7 @@ const uint8_t* ConstStorageAccessor::data() const {
 
 size_t ConstStorageAccessor::size() const {
 	if(internalState == AccessState::UNINIT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 #endif
 	}
@@ -56,13 +56,13 @@ size_t ConstStorageAccessor::size() const {
 ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
 		size_t maxSize) {
 	if(internalState == AccessState::UNINIT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 #endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(size_ > maxSize) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "StorageAccessor: Supplied buffer not large enough"
 				<< std::endl;
 #endif
@@ -82,7 +82,7 @@ store_address_t ConstStorageAccessor::getId() const {
 
 void ConstStorageAccessor::print() const {
 	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 #endif
 		return;
diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index b2d5ffc4a..cc7c92662 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -8,7 +8,7 @@ LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
 		NUMBER_OF_POOLS(poolConfig.size()),
 		spillsToHigherPools(spillsToHigherPools) {
 	if(NUMBER_OF_POOLS == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalPool::LocalPool: Passed pool configuration is "
 				<< " invalid!" << std::endl;
 #endif
@@ -120,7 +120,7 @@ ReturnValue_t LocalPool::modifyData(store_address_t storeId,
 
 ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
 #if FSFW_VERBOSE_PRINTOUT == 2
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::debug << "Delete: Pool: " << std::dec << storeId.poolIndex
               << " Index: " << storeId.packetIndex << std::endl;
 #endif
@@ -138,7 +138,7 @@ ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
     }
     else {
         //pool_index or packet_index is too large
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPool::deleteData: Illegal store ID, no deletion!"
         		<< std::endl;
 #endif
@@ -164,7 +164,7 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
             result = deleteData(localId);
 #if FSFW_VERBOSE_PRINTOUT == 2
             if (deltaAddress % elementSizes[n] != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
                 sif::error << "LocalPool::deleteData: Address not aligned!"
                         << std::endl;
 #endif
@@ -194,7 +194,7 @@ ReturnValue_t LocalPool::initialize() {
     //Check if any pool size is large than the maximum allowed.
     for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
         if (elementSizes[count] >= STORAGE_FREE) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "LocalPool::initialize: Pool is too large! "
                     "Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
 #endif
@@ -219,7 +219,7 @@ ReturnValue_t LocalPool::reserveSpace(const size_t size,
         store_address_t *storeId, bool ignoreFault) {
     ReturnValue_t status = getPoolIndex(size, &storeId->poolIndex);
     if (status != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
                 << " )::reserveSpace: Packet too large." << std::endl;
 #endif
@@ -236,7 +236,7 @@ ReturnValue_t LocalPool::reserveSpace(const size_t size,
     }
     if (status == RETURN_OK) {
 #if FSFW_VERBOSE_PRINTOUT == 2
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "Reserve: Pool: " << std::dec
                 << storeId->poolIndex << " Index: " << storeId->packetIndex
                 << std::endl;
@@ -280,7 +280,7 @@ ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
         uint16_t startAtIndex) {
     for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
 #if FSFW_VERBOSE_PRINTOUT == 2
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: "
              << n << ", Element Size: " << elementSizes[n] << std::endl;
 #endif
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index 7612fbc04..4e8014fd3 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -26,7 +26,7 @@ ReturnValue_t PoolManager::reserveSpace(const size_t size,
 ReturnValue_t PoolManager::deleteData(
         store_address_t storeId) {
 #if FSFW_VERBOSE_PRINTOUT == 2
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::debug << "PoolManager( " << translateObject(getObjectId()) <<
            " )::deleteData from store " << storeId.poolIndex <<
            ". id is "<< storeId.packetIndex << std::endl;
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index 373407b0b..fec5d75ea 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -26,13 +26,13 @@ StorageAccessor::StorageAccessor(StorageAccessor&& other):
 
 ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
 	if(internalState == AccessState::UNINIT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 #endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(size_ > maxSize) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "StorageAccessor: Supplied buffer not large "
 				"enough" << std::endl;
 #endif
@@ -44,7 +44,7 @@ ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
 
 uint8_t* StorageAccessor::data() {
 	if(internalState == AccessState::UNINIT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 #endif
 	}
@@ -54,13 +54,13 @@ uint8_t* StorageAccessor::data() {
 ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
 		uint16_t offset) {
 	if(internalState == AccessState::UNINIT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 #endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(offset + size > size_) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "StorageAccessor: Data too large for pool "
 				"entry!" << std::endl;
 #endif
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 4ae508580..bcfa4b0e3 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -86,7 +86,7 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
 		object_id_t object = tableIter.value->getObject();
 		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
 			//illegal table entry, should only happen due to misconfigured mode table
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::debug << std::hex << getObjectId() << ": invalid mode table entry"
 					<< std::endl;
 #endif
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index 9d15a9c7f..54b6ae6d3 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -91,7 +91,7 @@ void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "FixedSlotSequence::checkSequence:"
 				<< " Slot list is empty!" << std::endl;
 #endif
@@ -102,7 +102,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 		ReturnValue_t result = customCheckFunction(slotList);
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			// Continue for now but print error output.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "FixedSlotSequence::checkSequence:"
 					<< " Custom check failed!" << std::endl;
 #endif
@@ -116,7 +116,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 			errorCount++;
 		}
 		else if (slot.pollingTimeMs < time) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "FixedSlotSequence::checkSequence: Time: "
 					<< slot.pollingTimeMs << " is smaller than previous with "
 					<< time << std::endl;
@@ -125,7 +125,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 		}
 		else {
 			// All ok, print slot.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			//sif::info << "Current slot polling time: " << std::endl;
 			//sif::info << std::dec << slotIt->pollingTimeMs << std::endl;
 #endif
@@ -133,7 +133,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 		time = slot.pollingTimeMs;
 
 	}
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	//sif::info << "Number of elements in slot list: "
 	//	   << slotList.size() << std::endl;
 #endif
@@ -159,7 +159,7 @@ ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
         }
     }
     if (count > 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "FixedSlotSequence::intializeSequenceAfterTaskCreation:"
                 "Counted " << count << " failed initializations!"  << std::endl;
 #endif
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index 742dd6486..b795854f2 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -11,7 +11,7 @@ CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
 CCSDSDistributor::~CCSDSDistributor() {}
 
 TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "CCSDSDistributor::selectDestination received: " <<
 //			this->currentMessage.getStorageId().pool_index << ", " <<
 //			this->currentMessage.getStorageId().packet_index << std::endl;
@@ -21,14 +21,14 @@ TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
 	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
 			&packet, &size );
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
 				" store failed!" << std::endl;
 #endif
 	}
 	SpacePacketBase currentPacket(packet);
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
 //			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
 #endif
@@ -76,7 +76,7 @@ ReturnValue_t CCSDSDistributor::initialize() {
 	ReturnValue_t status = this->TcDistributor::initialize();
 	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
 	if (this->tcStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CCSDSDistributor::initialize: Could not initialize"
 	            " TC store!" << std::endl;
 #endif
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 3a2142689..00fd9029a 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -13,7 +13,7 @@ PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
 PUSDistributor::~PUSDistributor() {}
 
 PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     // sif:: debug << "PUSDistributor::handlePacket received: "
     //          << this->current_packet_id.store_index << ", "
     //          << this->current_packet_id.packet_index << std::endl;
@@ -27,7 +27,7 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
         tcStatus = checker.checkPacket(currentPacket);
 #ifdef DEBUG
         if(tcStatus != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::debug << "PUSDistributor::handlePacket: Packet format "
                     << "invalid, code "<< static_cast<int>(tcStatus)
                     << std::endl;
@@ -44,7 +44,7 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
     if (queueMapIt == this->queueMap.end()) {
         tcStatus = DESTINATION_NOT_FOUND;
 #ifdef DEBUG
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "PUSDistributor::handlePacket: Destination not found, "
                 << "code "<< static_cast<int>(tcStatus) << std::endl;
 #endif
@@ -63,13 +63,13 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
 
 ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
 	uint16_t serviceId = service->getIdentifier();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	// sif::info << "Service ID: " << (int)serviceId << std::endl;
 #endif
 	MessageQueueId_t queue = service->getRequestQueue();
 	auto returnPair = queueMap.emplace(serviceId, queue);
 	if (not returnPair.second) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PUSDistributor::registerService: Service ID already"
 				" exists in map." << std::endl;
 #endif
@@ -114,7 +114,7 @@ ReturnValue_t PUSDistributor::initialize() {
 	CCSDSDistributorIF* ccsdsDistributor =
 			objectManager->get<CCSDSDistributorIF>(packetSource);
 	if (ccsdsDistributor == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PUSDistributor::initialize: Packet source invalid."
 		        << " Make sure it exists and implements CCSDSDistributorIF!"
 		        << std::endl;
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index 0bd4a906a..df0695564 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -39,7 +39,7 @@ ReturnValue_t TcDistributor::handlePacket() {
 }
 
 void TcDistributor::print() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Distributor content is: " << std::endl
 	        << "ID\t| Message Queue ID" << std::endl;
 	sif::debug << std::setfill('0') << std::setw(8) << std::hex;
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index b3d080ba5..f79d2eebd 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -28,13 +28,13 @@ double Stopwatch::stopSeconds() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
                 elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
 #endif
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info <<"Stopwatch: Operation took "  << std::setprecision(3)
              << std::fixed << timevalOperations::toDouble(elapsedTime)
              << " seconds" << std::endl;
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 1a28419cd..ca3e2a99a 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -63,7 +63,7 @@ uint8_t TcPacketBase::getPusVersionNumber() {
 }
 
 void TcPacketBase::print() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::debug << "TcPacketBase::print: " << std::endl;
 #endif
 	arrayprinter::print(getWholeData(), getFullSize());
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 021b6d677..f320386c2 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -23,7 +23,7 @@ TcPacketStored::TcPacketStored(uint16_t apid,  uint8_t service,
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
 			(TC_PACKET_MIN_SIZE + size), &pData);
 	if (returnValue != this->store->RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "TcPacketStored: Could not get free element from store!"
 				<< std::endl;
 #endif
@@ -41,7 +41,7 @@ ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
 		size_t* dataSize) {
 	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
 #endif
 	}
@@ -65,7 +65,7 @@ bool TcPacketStored::checkAndSetStore() {
 	if (this->store == nullptr) {
 		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 		if (this->store == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
 					<< std::endl;
 #endif
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index bf892ccff..c8e4b4302 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -57,7 +57,7 @@ void TmPacketBase::setData(const uint8_t* p_Data) {
 }
 
 void TmPacketBase::print() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	 sif::debug << "TmPacketBase::print: " << std::endl;
 #endif
 	 arrayprinter::print(getWholeData(), getFullSize());
@@ -67,7 +67,7 @@ bool TmPacketBase::checkAndSetStamper() {
 	if (timeStamper == NULL) {
 		timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
 		if (timeStamper == NULL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TmPacketBase::checkAndSetStamper: Stamper not found!"
 					<< std::endl;
 #endif
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 21f237bd7..0fd2a4a03 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -105,7 +105,7 @@ bool TmPacketStored::checkAndSetStore() {
 	if (store == nullptr) {
 		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
 		if (store == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
 					<< std::endl;
 #endif
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 2be6e2ce1..259f2ccbc 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -75,7 +75,7 @@ ReturnValue_t CommandingServiceBase::initialize() {
 			packetSource);
 
 	if (packetForwarding == nullptr or distributor == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CommandingServiceBase::intialize: Packet source or "
 	            "packet destination invalid!" << std::endl;
 #endif
@@ -90,7 +90,7 @@ ReturnValue_t CommandingServiceBase::initialize() {
 	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 
 	if (IPCStore == nullptr or TCStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
 	                    "not initialized yet!" << std::endl;
 #endif
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index 1b03a7f01..0a5cb2029 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -25,7 +25,7 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
 	handleRequestQueue();
 	ReturnValue_t result = this->performService();
 	if (result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PusService " << (uint16_t) this->serviceId
 				<< ": performService returned with " << (int16_t) result
 				<< std::endl;
@@ -45,7 +45,7 @@ void PusServiceBase::handleRequestQueue() {
 	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
 		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
 //		if(status != MessageQueueIF::EMPTY) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //			sif::debug << "PusServiceBase::performOperation: Receiving from "
 //					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
 //					<< std::setfill('0') << this->requestQueue->getId()
@@ -83,7 +83,7 @@ void PusServiceBase::handleRequestQueue() {
 			break;
 		}
 		else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PusServiceBase::performOperation: Service "
 					<< this->serviceId << ": Error receiving packet. Code: "
 					<< std::hex << status << std::dec << std::endl;
@@ -110,7 +110,7 @@ ReturnValue_t PusServiceBase::initialize() {
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
 	if (destService == nullptr or distributor == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PusServiceBase::PusServiceBase: Service "
 				<< this->serviceId << ": Configuration error. Make sure "
 				<<	"packetSource and packetDestination are defined correctly"
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 954e3e75d..2513071a5 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -23,7 +23,7 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 		return RETURN_OK;
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of "
 	             << "packets sent per cycle exceeds limits. "
 	             << "Keeping default value." << std::endl;
@@ -39,7 +39,7 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
         return RETURN_OK;
     }
     else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of "
                 << "packets stored exceeds limits. "
                 << "Keeping default value." << std::endl;
@@ -51,7 +51,7 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
 ReturnValue_t TmTcBridge::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
 	if (tcStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
 				"it is created and set up properly." << std::endl;
 #endif
@@ -59,7 +59,7 @@ ReturnValue_t TmTcBridge::initialize() {
 	}
 	tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
 	if (tmStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
 				"it is created and set up properly." << std::endl;
 #endif
@@ -68,7 +68,7 @@ ReturnValue_t TmTcBridge::initialize() {
 	AcceptsTelecommandsIF* tcDistributor =
 			objectManager->get<AcceptsTelecommandsIF>(tcDestination);
 	if (tcDistributor == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TC Distributor invalid"
 				<< std::endl;
 #endif
@@ -85,14 +85,14 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 	ReturnValue_t result;
 	result = handleTc();
 	if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "TmTcBridge::performOperation: "
 		        << "Error handling TCs" << std::endl;
 #endif
 	}
 	result = handleTm();
 	if (result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::debug << "TmTcBridge::performOperation: "
 	                    << "Error handling TMs" << std::endl;
 #endif
@@ -108,7 +108,7 @@ ReturnValue_t TmTcBridge::handleTm() {
     ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::handleTm: Error handling TM queue with "
 		       << "error code 0x" << std::hex << result  << std::dec
 			   << "!" << std::endl;
@@ -120,7 +120,7 @@ ReturnValue_t TmTcBridge::handleTm() {
 	        (packetSentCounter < sentPacketsPerCycle)) {
 	    result = handleStoredTm();
 	    if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	        sif::error << "TmTcBridge::handleTm: Error handling stored TMs!"
 	                << std::endl;
 #endif
@@ -140,7 +140,7 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 		 result == HasReturnvaluesIF::RETURN_OK;
 		 result = tmTcReceptionQueue->receiveMessage(&message))
 	{
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    //sif::info << (int) packetSentCounter << std::endl;
 #endif
 		if(communicationLinkUp == false or
@@ -171,7 +171,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	store_address_t storeId = 0;
 
 	if(tmFifo->full()) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::debug << "TmTcBridge::storeDownlinkData: TM downlink max. number "
 	                    << "of stored packet IDs reached! " << std::endl;
 #endif
@@ -193,7 +193,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 ReturnValue_t TmTcBridge::handleStoredTm() {
     ReturnValue_t status = RETURN_OK;
 	while(not tmFifo->empty() and packetSentCounter < sentPacketsPerCycle) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		//sif::info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) tmFifo->size() << " left to send\r\n" << std::flush;
 #endif
@@ -209,7 +209,7 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 
 		result = sendTm(data,size);
 		if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TMTC Bridge: Could not send stored downlink data"
 			      << std::endl;
 #endif
@@ -227,7 +227,7 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 
 void TmTcBridge::registerCommConnect() {
 	if(not communicationLinkUp) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		//sif::info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
 #endif
 		communicationLinkUp = true;
@@ -235,7 +235,7 @@ void TmTcBridge::registerCommConnect() {
 }
 
 void TmTcBridge::registerCommDisconnect() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	//sif::info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
 #endif
 	if(communicationLinkUp) {
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 3bd1f067a..ff6f54f99 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -27,7 +27,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 			&message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				<< "to queue. Code: " << std::hex << status << std::dec
 				<< std::endl;
@@ -46,7 +46,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 			&message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				<< "to queue. Code: " << std::hex << status << std::dec
 				<< std::endl;
@@ -68,7 +68,7 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendFailureReport: Error writing "
 				<< "to queue. Code: " << std::hex  << "0x" << status << std::dec
 				<< std::endl;
@@ -88,7 +88,7 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendFailureReport: Error writing "
 				<< "to queue. Code: " << std::hex << "0x" << status << std::dec
 				<< std::endl;
@@ -98,7 +98,7 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 
 void VerificationReporter::initialize() {
 	if(messageReceiver == objects::NO_OBJECT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "VerificationReporter::initialize: Verification message"
 				" receiver object ID not set yet in Factory!" << std::endl;
 #endif
@@ -107,7 +107,7 @@ void VerificationReporter::initialize() {
 	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
 			messageReceiver);
 	if (temp == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::initialize: Message "
 				<< "receiver invalid. Make sure it is set up properly and "
 				<< "implementsAcceptsVerifyMessageIF" << std::endl;
diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
index 6771b17ef..bd41969c9 100644
--- a/unittest/internal/InternalUnitTester.cpp
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -13,7 +13,7 @@ InternalUnitTester::InternalUnitTester() {}
 InternalUnitTester::~InternalUnitTester() {}
 
 ReturnValue_t InternalUnitTester::performTests() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::info << "Running internal unit tests.." << std::endl;
 #endif
 	testserialize::test_serialization();
@@ -21,7 +21,7 @@ ReturnValue_t InternalUnitTester::performTests() {
 	testsemaph::testBinSemaph();
 	testsemaph::testCountingSemaph();
 	testmutex::testMutex();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::info << "Internal unit tests finished." << std::endl;
 #endif
 	return RETURN_OK;
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index 292c4b8a6..7138e6c62 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -1,7 +1,7 @@
 #include "UnittDefinitions.h"
 
  ReturnValue_t unitt::put_error(std::string errorId) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Unit Tester error: Failed at test ID "
 			<< errorId << "\n" << std::flush;
 #endif
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index 908326d44..43990c2cd 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -94,7 +94,7 @@ void testsemaph::testBinSemaphoreImplementation(SemaphoreIF* binSemaph,
 		result = binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
 		//dur_millis_t time = stopwatch.stop();
 //		if(abs(time - 10) > 2) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //		    sif::error << "UnitTester: Semaphore timeout measured incorrect."
 //		            << std::endl;
 #endif
diff --git a/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp b/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
index 443b2bbbc..b7f1fb3e1 100644
--- a/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
+++ b/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
@@ -15,7 +15,7 @@ ReturnValue_t pst::pollingSequenceInitDefault(
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
 		        << std::endl;
 #endif
diff --git a/unittest/user/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
index 6504700c7..00daf0156 100644
--- a/unittest/user/unittest/core/CatchDefinitions.cpp
+++ b/unittest/user/unittest/core/CatchDefinitions.cpp
@@ -5,7 +5,7 @@ StorageManagerIF* tglob::getIpcStoreHandle() {
 	if(objectManager != nullptr) {
 		return objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;
 #endif
 		return nullptr;

From 695a767164573b73a3360e9bf10a70773236ef2c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 14:33:17 +0100
Subject: [PATCH 1349/1774] some include fixes

---
 globalfunctions/arrayprinter.cpp          | 2 +-
 objectmanager/ObjectManager.cpp           | 2 +-
 serviceinterface/ServiceInterfaceStream.h | 1 +
 storagemanager/ConstStorageAccessor.cpp   | 2 ++
 storagemanager/StorageAccessor.cpp        | 2 ++
 5 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index d0b0a3bf4..c273b250f 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -33,7 +33,7 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 				sif::info << std::endl;
 
 			}
-
+		}
 	}
 	sif::info << std::dec;
 	sif::info << "]" << std::endl;
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 69dd905ba..882d2762a 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -29,7 +29,7 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 	} else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::insert: Object id " << std::hex
-		           << static_cast<uint32_t> id << std::dec
+		           << static_cast<uint32_t>(id) << std::dec
 				   << " is already in use!" << std::endl;
 		sif::error << "Terminating program." << std::endl;
 #endif
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index c18c6c2e3..f3cb2cd05 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -2,6 +2,7 @@
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
 
 #include "ServiceInterfaceBuffer.h"
+#include <FSFWConfig.h>
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 
diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 39530ac9f..aab848628 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -4,6 +4,8 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../globalfunctions/arrayprinter.h"
 
+#include <algorithm>
+
 ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
 		storeId(storeId) {}
 
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index fec5d75ea..a7b4fae4f 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -2,6 +2,8 @@
 #include "StorageManagerIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
+#include <algorithm>
+
 StorageAccessor::StorageAccessor(store_address_t storeId):
 		ConstStorageAccessor(storeId) {
 }

From 98af84c1455f57e96cf300a9746d759930e31f78 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 14:41:54 +0100
Subject: [PATCH 1350/1774] additional tweask

---
 datapoollocal/LocalPoolVariable.h   | 2 ++
 datapoollocal/LocalPoolVariable.tpp | 2 ++
 serialize/EndianConverter.h         | 1 -
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 7b7e443e1..84be54b10 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -157,10 +157,12 @@ protected:
 	 */
 	ReturnValue_t commitWithoutLock() override;
 
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	// std::ostream is the type for object std::cout
 	template <typename U>
 	friend std::ostream& operator<< (std::ostream &out,
 			const LocalPoolVariable<U> &var);
+#endif
 
 private:
 };
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index aa5e5393b..cd5117c80 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -106,12 +106,14 @@ inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
 	return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 template<typename T>
 inline std::ostream& operator<< (std::ostream &out,
 		const LocalPoolVariable<T> &var) {
     out << var.value;
     return out;
 }
+#endif
 
 template<typename T>
 inline LocalPoolVariable<T>::operator T() const {
diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index c888a905a..8f3c7a7ed 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -3,7 +3,6 @@
 
 #include "../osal/Endiness.h"
 #include <cstring>
-#include <iostream>
 
 /**
  * Helper class to convert variables or bitstreams between machine

From 8c8965177f5007a770e323311e287bf0ab186ad9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 15:04:37 +0100
Subject: [PATCH 1351/1774] new amalgated header

---
 serviceinterface/ServiceInterface.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 serviceinterface/ServiceInterface.h

diff --git a/serviceinterface/ServiceInterface.h b/serviceinterface/ServiceInterface.h
new file mode 100644
index 000000000..0c7c43837
--- /dev/null
+++ b/serviceinterface/ServiceInterface.h
@@ -0,0 +1,12 @@
+#ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
+#define FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
+
+#include <FSFWConfig.h>
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#else
+#include <fsfw/serviceinterface/ServiceInterfacePrinter.h>
+#endif
+
+#endif /* FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_ */

From 59d327f8b6f27eea4e3694541505ae86b96a81f7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 15:15:03 +0100
Subject: [PATCH 1352/1774] console init for printf on windows

---
 serviceinterface/ServiceInterfacePrinter.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index 369edd0fb..e8eb498f9 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -9,8 +9,23 @@
 
 fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
 uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
+#if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
+bool consoleInitialized = false;
+#endif
 
 void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
+
+#if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
+	if(not consoleInitialized) {
+		HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+		DWORD dwMode = 0;
+		GetConsoleMode(hOut, &dwMode);
+		dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+		SetConsoleMode(hOut, dwMode);
+	}
+	consoleInitialized = true;
+#endif
+
     size_t len = 0;
     char* bufferPosition = reinterpret_cast<char*>(printBuffer);
 

From c94a396ffb478a96b67269bc72bbb6f63dcc88fd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 15:31:44 +0100
Subject: [PATCH 1353/1774] changelog update

---
 CHANGELOG | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index 2d9017918..298ef0d41 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -70,3 +70,15 @@ now
 ### Commanding Service Base
 
 - CSB uses the new fsfwconfig::FSFW_CSB_FIFO_DEPTH variable to determine  the FIFO depth for each CSB instance. This variable has to be set in the FSFWConfig.h file
+
+### Service Interface
+
+- Proper printf support contained in ServiceInterfacePrinter.h
+- CPP ostream support now optional (can reduce executable size by 150 - 250 kB)
+- Amalagated header which determines automatically which service interface to use depending on FSFWConfig.h configuration. 
+  Users can just use #include <fsfw/serviceinterface/ServiceInterface.h>
+- If CPP streams are excluded, sif:: calls won't work anymore and need to be replaced by their printf counterparts. 
+  For the fsfw, this can be done by checking the processor define FSFW_CPP_OSTREAM_ENABLED from FSFWConfig.h. 
+  For mission code, developers need to replace sif:: calls by the printf counterparts, but only if the CPP stream are excluded. 
+  If this is not the case, everything should work as usual.
+- 
\ No newline at end of file

From f64e356de398cf20d467110f9d1078efcaefbec5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 16:42:29 +0100
Subject: [PATCH 1354/1774] small include fix

---
 serialize/EndianConverter.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index 8f3c7a7ed..3b19832e7 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -3,6 +3,7 @@
 
 #include "../osal/Endiness.h"
 #include <cstring>
+#include <cstdint>
 
 /**
  * Helper class to convert variables or bitstreams between machine

From 51cdf6cc76262e64c3362ee256046fb8293ba97a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 16:48:18 +0100
Subject: [PATCH 1355/1774] missing include added

---
 serialize/EndianConverter.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index 8f3c7a7ed..3b19832e7 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -3,6 +3,7 @@
 
 #include "../osal/Endiness.h"
 #include <cstring>
+#include <cstdint>
 
 /**
  * Helper class to convert variables or bitstreams between machine

From e9da8e79f32fc2dfc34b779aa069c0c1faae339a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 22:00:40 +0100
Subject: [PATCH 1356/1774] updated testcfg

---
 unittest/user/testcfg/FSFWConfig.h | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/unittest/user/testcfg/FSFWConfig.h b/unittest/user/testcfg/FSFWConfig.h
index 6b0def902..261e3d6d2 100644
--- a/unittest/user/testcfg/FSFWConfig.h
+++ b/unittest/user/testcfg/FSFWConfig.h
@@ -4,17 +4,26 @@
 #include <cstddef>
 #include <cstdint>
 
-//! Used to determine whether C++ ostreams are used
-//! Those can lead to code bloat.
+//! Used to determine whether C++ ostreams are used which can increase
+//! the binary size significantly. If this is disabled,
+//! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrease code size
+//! More FSFW related printouts.
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_ENHANCED_PRINTOUT		0
 
+//! Can be used to completely disable printouts, even the C stdio ones.
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
+	#define FSFW_DISABLE_PRINTOUT 	0
+#endif
+
 //! Can be used to enable additional debugging printouts for developing the FSFW
 #define FSFW_PRINT_VERBOSITY_LEVEL   0
 
+//! Can be used to disable the ANSI color sequences for C stdio.
+#define FSFW_COLORED_OUTPUT 		1
+
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
@@ -49,7 +58,9 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 //! also determines how many commands a CSB service can handle in one cycle
 //! simulataneously. This will increase the required RAM for
 //! each CSB service !
-static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 3;
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
+
+static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

From e9a8313df7e5f4ae8f5afb732ef461bd348fcbb5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 23:18:10 +0100
Subject: [PATCH 1357/1774] repaired unit tests

---
 container/FixedOrderedMultimap.h              |   1 +
 .../tests/container/TestPlacementFactory.cpp  |  93 ++---
 .../tests/storagemanager/TestNewAccessor.cpp  | 321 +++++++++---------
 unittest/tests/storagemanager/TestPool.cpp    |   2 -
 4 files changed, 209 insertions(+), 208 deletions(-)

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 96bc00735..acf2368af 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -3,6 +3,7 @@
 
 #include "ArrayList.h"
 #include <cstring>
+#include <functional>
 
 /**
  * @brief  An associative container which allows multiple entries of the same key.
diff --git a/unittest/tests/container/TestPlacementFactory.cpp b/unittest/tests/container/TestPlacementFactory.cpp
index 5edbb9d22..14cf8eb4c 100644
--- a/unittest/tests/container/TestPlacementFactory.cpp
+++ b/unittest/tests/container/TestPlacementFactory.cpp
@@ -1,45 +1,48 @@
-//#include <fsfw/container/PlacementFactory.h>
-//#include <fsfw/storagemanager/LocalPool.h>
-//#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-//#include <fsfw/container/ArrayList.h>
-//
-//#include <catch2/catch.hpp>
-//#include "../../core/CatchDefinitions.h"
-//
-//TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
-//	INFO("PlacementFactory Tests");
-//
-//	const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
-//	const uint16_t n_elements[3] = {1, 1, 1};
-//	LocalPool<3> storagePool(0x1, element_sizes, n_elements, false, true);
-//	PlacementFactory factory(&storagePool);
-//
-//	SECTION("Pool overload"){
-//		store_address_t address;
-//		uint8_t* ptr = nullptr;
-//		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
-//				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
-//		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
-//		REQUIRE(list2 == nullptr);
-//	}
-//
-//	SECTION("Test generate and destroy"){
-//		uint64_t* number = factory.generate<uint64_t>(32000);
-//		REQUIRE(number != nullptr);
-//		REQUIRE(*number == 32000);
-//		store_address_t address;
-//		uint8_t* ptr = nullptr;
-//		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
-//						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
-//		uint64_t* number2 = factory.generate<uint64_t>(12345);
-//		REQUIRE(number2 == nullptr);
-//		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
-//						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-//
-//		//Check that PlacementFactory checks for nullptr
-//		ptr = nullptr;
-//		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
-//	}
-//}
+#include <fsfw/container/PlacementFactory.h>
+#include <fsfw/storagemanager/LocalPool.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/container/ArrayList.h>
+
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+
+TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
+	INFO("PlacementFactory Tests");
+
+	LocalPool::LocalPoolConfig poolCfg= {{1, sizeof(uint16_t)},
+			{1, sizeof(uint32_t)}, {1, sizeof(uint64_t)}
+	};
+	//const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
+	//const uint16_t n_elements[3] = {1, 1, 1};
+	LocalPool storagePool(0x1, poolCfg, false, true);
+	PlacementFactory factory(&storagePool);
+
+	SECTION("Pool overload"){
+		store_address_t address;
+		uint8_t* ptr = nullptr;
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
+				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
+		REQUIRE(list2 == nullptr);
+	}
+
+	SECTION("Test generate and destroy"){
+		uint64_t* number = factory.generate<uint64_t>(32000);
+		REQUIRE(number != nullptr);
+		REQUIRE(*number == 32000);
+		store_address_t address;
+		uint8_t* ptr = nullptr;
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+		uint64_t* number2 = factory.generate<uint64_t>(12345);
+		REQUIRE(number2 == nullptr);
+		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+
+		//Check that PlacementFactory checks for nullptr
+		ptr = nullptr;
+		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+	}
+}
diff --git a/unittest/tests/storagemanager/TestNewAccessor.cpp b/unittest/tests/storagemanager/TestNewAccessor.cpp
index 7bd0dee2f..87ea00ca8 100644
--- a/unittest/tests/storagemanager/TestNewAccessor.cpp
+++ b/unittest/tests/storagemanager/TestNewAccessor.cpp
@@ -1,161 +1,160 @@
-//#include <fsfw/storagemanager/LocalPool.h>
-//#include <catch2/catch.hpp>
-//#include "../../core/CatchDefinitions.h"
-//#include <array>
-//
-//TEST_CASE( "New Accessor" , "[NewAccessor]") {
-//	uint16_t numberOfElements[1] = {1};
-//	uint16_t sizeofElements[1] = {10};
-//	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
-//	std::array<uint8_t, 20> testDataArray;
-//	std::array<uint8_t, 20> receptionArray;
-//	store_address_t testStoreId;
-//	ReturnValue_t result = retval::CATCH_FAILED;
-//
-//	for(size_t i = 0; i < testDataArray.size(); i++) {
-//		testDataArray[i] = i;
-//	}
-//	size_t size = 10;
-//
-//	SECTION ("Simple tests getter functions") {
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		auto resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//		resultPair.second.getDataCopy(receptionArray.data(), 20);
-//		CHECK(resultPair.second.getId() == testStoreId);
-//		CHECK(resultPair.second.size() == 10);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//
-//		std::copy(resultPair.second.data(), resultPair.second.data() +
-//				resultPair.second.size(), receptionArray.data());
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//
-//		{
-//			auto resultPairLoc = SimplePool.getData(testStoreId);
-//			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
-//			// data should be deleted when accessor goes out of scope.
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-//
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			ConstStorageAccessor constAccessor(testStoreId);
-//			result = SimplePool.getData(testStoreId, constAccessor);
-//			REQUIRE(result == retval::CATCH_OK);
-//			constAccessor.getDataCopy(receptionArray.data(), 20);
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			// likewise, data should be deleted when accessor gets out of scope.
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-//
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		{
-//			resultPair = SimplePool.getData(testStoreId);
-//			REQUIRE(resultPair.first == retval::CATCH_OK);
-//			resultPair.second.release();
-//			// now data should not be deleted anymore
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//		resultPair.second.getDataCopy(receptionArray.data(), 20);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//	}
-//
-//
-//	SECTION("Simple tests modify functions") {
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			StorageAccessor accessor(testStoreId);
-//			result = SimplePool.modifyData(testStoreId, accessor);
-//			REQUIRE(result == retval::CATCH_OK);
-//			CHECK(accessor.getId() == testStoreId);
-//			CHECK(accessor.size() == 10);
-//			accessor.getDataCopy(receptionArray.data(), 20);
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			std::copy(accessor.data(), accessor.data() +
-//					accessor.size(), receptionArray.data());
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			// data should be deleted when accessor goes out of scope
-//		}
-//		auto resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-//
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			auto resultPairLoc = SimplePool.modifyData(testStoreId);
-//			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
-//			CHECK(resultPairLoc.second.getId() == testStoreId);
-//			CHECK(resultPairLoc.second.size() == 10);
-//			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
-//					resultPairLoc.second.size(), receptionArray.data());
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			resultPairLoc.second.release();
-//			// data should not be deleted when accessor goes out of scope
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//	}
-//
-//
-//	SECTION("Write tests") {
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			auto resultPair = SimplePool.modifyData(testStoreId);
-//			REQUIRE(resultPair.first == retval::CATCH_OK);
-//			testDataArray[9] = 42;
-//			resultPair.second.write(testDataArray.data(), 10, 0);
-//			// now data should not be deleted
-//			resultPair.second.release();
-//		}
-//		auto resultConstPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultConstPair.first == retval::CATCH_OK);
-//
-//		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
-//		for(size_t i = 0; i < size-1; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//		CHECK(receptionArray[9] == 42 );
-//
-//		auto resultPair = SimplePool.modifyData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//		result = resultPair.second.write(testDataArray.data(), 20, 0);
-//		REQUIRE(result == retval::CATCH_FAILED);
-//		result = resultPair.second.write(testDataArray.data(), 10, 5);
-//		REQUIRE(result == retval::CATCH_FAILED);
-//
-//		memset(testDataArray.data(), 42, 5);
-//		result = resultPair.second.write(testDataArray.data(), 5, 5);
-//		REQUIRE(result == retval::CATCH_OK);
-//		resultConstPair = SimplePool.getData(testStoreId);
-//		resultPair.second.getDataCopy(receptionArray.data(), 20);
-//		for(size_t i = 5; i < 10; i++) {
-//			CHECK(receptionArray[i] == 42 );
-//		}
-//
-//	}
-//}
+#include <fsfw/storagemanager/LocalPool.h>
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+#include <array>
+
+TEST_CASE( "New Accessor" , "[NewAccessor]") {
+	LocalPool::LocalPoolConfig poolCfg = {{1, 10}};
+	LocalPool SimplePool = LocalPool(0, poolCfg);
+	std::array<uint8_t, 20> testDataArray;
+	std::array<uint8_t, 20> receptionArray;
+	store_address_t testStoreId;
+	ReturnValue_t result = retval::CATCH_FAILED;
+
+	for(size_t i = 0; i < testDataArray.size(); i++) {
+		testDataArray[i] = i;
+	}
+	size_t size = 10;
+
+	SECTION ("Simple tests getter functions") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		auto resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		CHECK(resultPair.second.getId() == testStoreId);
+		CHECK(resultPair.second.size() == 10);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		std::copy(resultPair.second.data(), resultPair.second.data() +
+				resultPair.second.size(), receptionArray.data());
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		{
+			auto resultPairLoc = SimplePool.getData(testStoreId);
+			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+			// data should be deleted when accessor goes out of scope.
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			ConstStorageAccessor constAccessor(testStoreId);
+			result = SimplePool.getData(testStoreId, constAccessor);
+			REQUIRE(result == retval::CATCH_OK);
+			constAccessor.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			// likewise, data should be deleted when accessor gets out of scope.
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		{
+			resultPair = SimplePool.getData(testStoreId);
+			REQUIRE(resultPair.first == retval::CATCH_OK);
+			resultPair.second.release();
+			// now data should not be deleted anymore
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+	}
+
+
+	SECTION("Simple tests modify functions") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			StorageAccessor accessor(testStoreId);
+			result = SimplePool.modifyData(testStoreId, accessor);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(accessor.getId() == testStoreId);
+			CHECK(accessor.size() == 10);
+			accessor.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			std::copy(accessor.data(), accessor.data() +
+					accessor.size(), receptionArray.data());
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			// data should be deleted when accessor goes out of scope
+		}
+		auto resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			auto resultPairLoc = SimplePool.modifyData(testStoreId);
+			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+			CHECK(resultPairLoc.second.getId() == testStoreId);
+			CHECK(resultPairLoc.second.size() == 10);
+			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
+					resultPairLoc.second.size(), receptionArray.data());
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			resultPairLoc.second.release();
+			// data should not be deleted when accessor goes out of scope
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+	}
+
+
+	SECTION("Write tests") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			auto resultPair = SimplePool.modifyData(testStoreId);
+			REQUIRE(resultPair.first == retval::CATCH_OK);
+			testDataArray[9] = 42;
+			resultPair.second.write(testDataArray.data(), 10, 0);
+			// now data should not be deleted
+			resultPair.second.release();
+		}
+		auto resultConstPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultConstPair.first == retval::CATCH_OK);
+
+		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
+		for(size_t i = 0; i < size-1; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+		CHECK(receptionArray[9] == 42 );
+
+		auto resultPair = SimplePool.modifyData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		result = resultPair.second.write(testDataArray.data(), 20, 0);
+		REQUIRE(result == retval::CATCH_FAILED);
+		result = resultPair.second.write(testDataArray.data(), 10, 5);
+		REQUIRE(result == retval::CATCH_FAILED);
+
+		memset(testDataArray.data(), 42, 5);
+		result = resultPair.second.write(testDataArray.data(), 5, 5);
+		REQUIRE(result == retval::CATCH_OK);
+		resultConstPair = SimplePool.getData(testStoreId);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		for(size_t i = 5; i < 10; i++) {
+			CHECK(receptionArray[i] == 42 );
+		}
+
+	}
+}
diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
index dcfb6c035..50bde01ab 100644
--- a/unittest/tests/storagemanager/TestPool.cpp
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -8,8 +8,6 @@
 
 
 TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
-//	uint16_t numberOfElements[1] = {1};
-//	uint16_t sizeofElements[1] = {10};
 	LocalPool::LocalPoolConfig config = {{1, 10}};
 	LocalPool simplePool(0, config);
 	std::array<uint8_t, 20> testDataArray;

From 49c6cd947300bef7db1622a547af7ce5fdf7980b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 23:27:49 +0100
Subject: [PATCH 1358/1774] added local pool owner base

---
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 unittest/tests/datapoollocal/LocalPoolOwnerBase.h

diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
new file mode 100644
index 000000000..5e62234b5
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -0,0 +1,8 @@
+#ifndef FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
+#define FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
+
+
+
+
+
+#endif /* FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_ */

From 8e3aef5df05669d686d1ec0a6a899e3c6a369d7a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 4 Jan 2021 00:21:44 +0100
Subject: [PATCH 1359/1774] adding new tests for local pool variable

---
 unittest/tests/CMakeLists.txt                 |  1 +
 unittest/tests/datapoollocal/CMakeLists.txt   |  3 +
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 75 +++++++++++++++++++
 .../datapoollocal/LocalPoolVariableTest.cpp   | 37 +++++++++
 .../user/testcfg/objects/systemObjectList.h   | 14 +++-
 5 files changed, 129 insertions(+), 1 deletion(-)
 create mode 100644 unittest/tests/datapoollocal/CMakeLists.txt
 create mode 100644 unittest/tests/datapoollocal/LocalPoolVariableTest.cpp

diff --git a/unittest/tests/CMakeLists.txt b/unittest/tests/CMakeLists.txt
index 970744174..180e1a51d 100644
--- a/unittest/tests/CMakeLists.txt
+++ b/unittest/tests/CMakeLists.txt
@@ -2,5 +2,6 @@ add_subdirectory(action)
 add_subdirectory(container)
 add_subdirectory(osal)
 add_subdirectory(serialize)
+add_subdirectory(datapoollocal)
 add_subdirectory(storagemanager)
 
diff --git a/unittest/tests/datapoollocal/CMakeLists.txt b/unittest/tests/datapoollocal/CMakeLists.txt
new file mode 100644
index 000000000..569a8d5f4
--- /dev/null
+++ b/unittest/tests/datapoollocal/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(${TARGET_NAME} PRIVATE
+	LocalPoolVariableTest.cpp
+)
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 5e62234b5..b73c52996 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -1,8 +1,83 @@
 #ifndef FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
 #define FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
 
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <testcfg/objects/systemObjectList.h>
+
+namespace lpool {
+static constexpr lp_id_t uint8VarId = 0;
+static constexpr lp_id_t floatVarId = 1;
+}
 
 
+class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
+public:
+	LocalPoolOwnerBase(
+			object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE):
+		SystemObject(objectId), hkManager(this, messageQueue)  {
+		messageQueue = QueueFactory::instance()->createMessageQueue(10);
+	}
 
+	~LocalPoolOwnerBase() {
+		QueueFactory::instance()->deleteMessageQueue(messageQueue);
+	}
+
+	object_id_t getObjectId() const override {
+		return SystemObject::getObjectId();
+	}
+
+	ReturnValue_t initializeHkManager() {
+		return hkManager.initialize(messageQueue);
+
+	}
+
+	ReturnValue_t initializeHkManagerAfterTaskCreation() {
+		return hkManager.initializeAfterTaskCreation();
+	}
+
+	/** Command queue for housekeeping messages. */
+	MessageQueueId_t getCommandQueue() const override {
+		return messageQueue->getId();
+	}
+
+	virtual ReturnValue_t initializeLocalDataPool(
+	        LocalDataPool& localDataPoolMap,
+	        LocalDataPoolManager& poolManager) {
+		// Default initialization empty for now.
+		localDataPoolMap.emplace(lpool::uint8VarId, new PoolEntry<uint8_t>({0}));
+		localDataPoolMap.emplace(lpool::floatVarId, new PoolEntry<float>({0}));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	LocalDataPoolManager* getHkManagerHandle() override {
+		return &hkManager;
+	}
+
+	uint32_t getPeriodicOperationFrequency() const override {
+		return 0;
+	}
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override  {
+		// empty for now
+		return nullptr;
+	}
+private:
+
+	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
+	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
+
+	MessageQueueIF* messageQueue = nullptr;
+	LocalDataPoolManager hkManager;
+
+};
 
 #endif /* FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_ */
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
new file mode 100644
index 000000000..0c2331937
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -0,0 +1,37 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <unittest/core/CatchDefinitions.h>
+
+
+TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
+	LocalPoolOwnerBase poolOwner(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner.initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+
+	// very basic test.
+	lp_var_t<uint8_t> testVariable = lp_var_t<uint8_t>(
+			objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+	REQUIRE(testVariable.read() == retval::CATCH_OK);
+	CHECK(testVariable.value == 0);
+	testVariable.value = 5;
+	REQUIRE(testVariable.commit() == retval::CATCH_OK);
+	REQUIRE(testVariable.read() == retval::CATCH_OK);
+	REQUIRE(testVariable.value == 5);
+
+	// not try to use a local pool variable which does not exist
+	lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
+			objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+	REQUIRE(invalidVariable.read() ==
+			static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+
+	// now try to access with wrong type
+	lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
+			objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+	REQUIRE(invalidVariable2.read() ==
+			static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+}
+
+
diff --git a/unittest/user/testcfg/objects/systemObjectList.h b/unittest/user/testcfg/objects/systemObjectList.h
index 0e034aff8..da95617cc 100644
--- a/unittest/user/testcfg/objects/systemObjectList.h
+++ b/unittest/user/testcfg/objects/systemObjectList.h
@@ -9,7 +9,19 @@ namespace objects {
 	enum sourceObjects: uint32_t {
 		/* All addresses between start and end are reserved for the FSFW */
 		FSFW_CONFIG_RESERVED_START = PUS_SERVICE_1_VERIFICATION,
-		FSFW_CONFIG_RESERVED_END = TM_STORE
+		FSFW_CONFIG_RESERVED_END = TM_STORE,
+
+		CCSDS_DISTRIBUTOR = 10,
+		PUS_DISTRIBUTOR = 11,
+		TM_FUNNEL = 12,
+
+		UDP_BRIDGE = 15,
+		UDP_POLLING_TASK = 16,
+
+		TEST_ECHO_COM_IF = 20,
+		TEST_DEVICE = 21,
+
+		TEST_LOCAL_POOL_OWNER_BASE = 25
 	};
 }
 

From cca5689a18425627559308e87dfde34f22cc28d0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Jan 2021 15:17:11 +0100
Subject: [PATCH 1360/1774] clock improvements for rtems

---
 osal/rtems/Clock.cpp | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index dda154648..8bd7ac37e 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -37,15 +37,24 @@ ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
 }
 
 ReturnValue_t Clock::setClock(const timeval* time) {
-	//TODO This routine uses _TOD_Set which is not
 	timespec newTime;
 	newTime.tv_sec = time->tv_sec;
+	if(time->tv_usec < 0) {
+		// better returnvalue.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
 	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
-	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
-	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
-	//TODO Second parameter is ISR_lock_Context
-	_TOD_Set(&newTime,nullptr);
-	return HasReturnvaluesIF::RETURN_OK;
+
+	ISR_lock_Context context;
+	_TOD_Lock();
+	_TOD_Acquire(&context);
+	Status_Control status = _TOD_Set(&newTime, &context);
+	_TOD_Unlock();
+	if(status == STATUS_SUCCESSFUL) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	// better returnvalue
+	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t Clock::getClock_timeval(timeval* time) {
@@ -95,6 +104,7 @@ ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 }
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	// TIsn't this a bug? Are RTEMS ticks always microseconds?
 	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
 	rtems_status_code status = rtems_clock_get_tod(timeRtems);
 	switch (status) {

From 3c041388d6705bccda5790ceeb5545ed9e48613d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Jan 2021 15:31:06 +0100
Subject: [PATCH 1361/1774] bugfix

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 20ea61ddf..5846d233a 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -28,18 +28,21 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 	}
 
 #if FSFW_COLORED_OUTPUT == 1
-	if(setMessage.find("DEBUG")) {
+	if(setMessage.find("DEBUG") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_MAGENTA;
 	}
-	else if(setMessage.find("INFO")) {
+	else if(setMessage.find("INFO") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_GREEN;
 	}
-	else if(setMessage.find("WARNING")) {
+	else if(setMessage.find("WARNING") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_YELLOW;
 	}
-	else if(setMessage.find("ERROR")) {
+	else if(setMessage.find("ERROR") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_RED;
 	}
+	else {
+		colorPrefix = fsfw::ANSI_COLOR_RESET;
+	}
 
 #ifdef WIN32
 	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);

From 63e80206bcb8a36e9f0ead86f15b4fd687223756 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Jan 2021 15:34:08 +0100
Subject: [PATCH 1362/1774] rtems osal update

---
 osal/rtems/Clock.cpp           | 22 ++++++++++++++++------
 osal/rtems/MessageQueue.cpp    |  2 ++
 osal/rtems/MultiObjectTask.cpp |  4 ++++
 osal/rtems/Mutex.cpp           |  4 ++++
 osal/rtems/PollingTask.cpp     |  8 ++++++++
 osal/rtems/TaskBase.cpp        |  2 ++
 6 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index dda154648..8bd7ac37e 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -37,15 +37,24 @@ ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
 }
 
 ReturnValue_t Clock::setClock(const timeval* time) {
-	//TODO This routine uses _TOD_Set which is not
 	timespec newTime;
 	newTime.tv_sec = time->tv_sec;
+	if(time->tv_usec < 0) {
+		// better returnvalue.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
 	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
-	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
-	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
-	//TODO Second parameter is ISR_lock_Context
-	_TOD_Set(&newTime,nullptr);
-	return HasReturnvaluesIF::RETURN_OK;
+
+	ISR_lock_Context context;
+	_TOD_Lock();
+	_TOD_Acquire(&context);
+	Status_Control status = _TOD_Set(&newTime, &context);
+	_TOD_Unlock();
+	if(status == STATUS_SUCCESSFUL) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	// better returnvalue
+	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t Clock::getClock_timeval(timeval* time) {
@@ -95,6 +104,7 @@ ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 }
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	// TIsn't this a bug? Are RTEMS ticks always microseconds?
 	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
 	rtems_status_code status = rtems_clock_get_tod(timeRtems);
 	switch (status) {
diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index 839182a67..bfaf35690 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -9,9 +9,11 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 	rtems_status_code status = rtems_message_queue_create(name, message_depth,
 			max_message_size, 0, &(this->id));
 	if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 				<< name << std::dec << " failed with status:"
 				<< (uint32_t) status << std::endl;
+#endif
 		this->id = 0;
 	}
 }
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index 970d01e1d..b111f724c 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -30,8 +30,10 @@ ReturnValue_t MultiObjectTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
+#endif
 	}
 	switch(status){
 	case RTEMS_SUCCESSFUL:
@@ -63,7 +65,9 @@ void MultiObjectTask::taskFunctionality() {
 			char nameSpace[8] = { 0 };
 			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
 					nameSpace);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
+#endif
 			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index a5ec96358..71c5782ff 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -10,16 +10,20 @@ Mutex::Mutex() :
 	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
 			&mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
 				<< " failed with " << status << std::endl;
+#endif
 	}
 }
 
 Mutex::~Mutex() {
 	rtems_status_code status = rtems_semaphore_delete(mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: deletion for id " << mutexId
 				<< " failed with " << status << std::endl;
+#endif
 	}
 }
 
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index db7864fea..0ebf63e2e 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -35,15 +35,19 @@ rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
 	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
 	//The task's functionality is called.
 	originalTask->taskFunctionality();
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->getId()
 			<< " returned from taskFunctionality." << std::endl;
+#endif
 }
 
 void PollingTask::missedDeadlineCounter() {
 	PollingTask::deadlineMissedCount++;
 	if (PollingTask::deadlineMissedCount % 10 == 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << PollingTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
+#endif
 	}
 }
 
@@ -51,8 +55,10 @@ ReturnValue_t PollingTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PollingTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
+#endif
 	}
 	switch(status){
 	case RTEMS_SUCCESSFUL:
@@ -75,8 +81,10 @@ ReturnValue_t PollingTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index 4e0c8f008..6abfcca8d 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -22,9 +22,11 @@ TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
 	}
 	ReturnValue_t result = convertReturnCode(status);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TaskBase::TaskBase: createTask with name " << std::hex
 				<< osalName << std::dec << " failed with return code "
 				<< (uint32_t) status << std::endl;
+#endif
 		this->id = 0;
 	}
 }

From e64b2e0616a6fbdc126f28f4a84f7af4662aa4b3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Jan 2021 15:38:46 +0100
Subject: [PATCH 1363/1774] bugfix

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 20ea61ddf..5846d233a 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -28,18 +28,21 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 	}
 
 #if FSFW_COLORED_OUTPUT == 1
-	if(setMessage.find("DEBUG")) {
+	if(setMessage.find("DEBUG") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_MAGENTA;
 	}
-	else if(setMessage.find("INFO")) {
+	else if(setMessage.find("INFO") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_GREEN;
 	}
-	else if(setMessage.find("WARNING")) {
+	else if(setMessage.find("WARNING") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_YELLOW;
 	}
-	else if(setMessage.find("ERROR")) {
+	else if(setMessage.find("ERROR") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_RED;
 	}
+	else {
+		colorPrefix = fsfw::ANSI_COLOR_RESET;
+	}
 
 #ifdef WIN32
 	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);

From 85764ba94c3f4edf1cbabc260cb94dd916b2d72f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 Jan 2021 17:30:15 +0100
Subject: [PATCH 1364/1774] added include

---
 unittest/tests/storagemanager/TestNewAccessor.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/unittest/tests/storagemanager/TestNewAccessor.cpp b/unittest/tests/storagemanager/TestNewAccessor.cpp
index 87ea00ca8..10d05c6b1 100644
--- a/unittest/tests/storagemanager/TestNewAccessor.cpp
+++ b/unittest/tests/storagemanager/TestNewAccessor.cpp
@@ -2,6 +2,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
 #include <array>
+#include <cstring>
 
 TEST_CASE( "New Accessor" , "[NewAccessor]") {
 	LocalPool::LocalPoolConfig poolCfg = {{1, 10}};
@@ -147,7 +148,7 @@ TEST_CASE( "New Accessor" , "[NewAccessor]") {
 		result = resultPair.second.write(testDataArray.data(), 10, 5);
 		REQUIRE(result == retval::CATCH_FAILED);
 
-		memset(testDataArray.data(), 42, 5);
+		std::memset(testDataArray.data(), 42, 5);
 		result = resultPair.second.write(testDataArray.data(), 5, 5);
 		REQUIRE(result == retval::CATCH_OK);
 		resultConstPair = SimplePool.getData(testStoreId);

From a05cf8d4ab54066f6cc9f6450f80f98577fad1af Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 5 Jan 2021 22:46:17 +0100
Subject: [PATCH 1365/1774] updated tests

---
 .../datapoollocal/LocalPoolVariableTest.cpp   | 50 ++++++++++++-------
 1 file changed, 31 insertions(+), 19 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index 0c2331937..f52ff9251 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -11,27 +11,39 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 	REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation()
 			== retval::CATCH_OK);
 
-	// very basic test.
-	lp_var_t<uint8_t> testVariable = lp_var_t<uint8_t>(
-			objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
-	REQUIRE(testVariable.read() == retval::CATCH_OK);
-	CHECK(testVariable.value == 0);
-	testVariable.value = 5;
-	REQUIRE(testVariable.commit() == retval::CATCH_OK);
-	REQUIRE(testVariable.read() == retval::CATCH_OK);
-	REQUIRE(testVariable.value == 5);
+	SECTION("Basic Tests") {
+		// very basic test.
+		lp_var_t<uint8_t> testVariable = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+		REQUIRE(testVariable.read() == retval::CATCH_OK);
+		CHECK(testVariable.value == 0);
+		testVariable.value = 5;
+		REQUIRE(testVariable.commit() == retval::CATCH_OK);
+		REQUIRE(testVariable.read() == retval::CATCH_OK);
+		REQUIRE(testVariable.value == 5);
 
-	// not try to use a local pool variable which does not exist
-	lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
-			objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
-	REQUIRE(invalidVariable.read() ==
-			static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+		CHECK(not testVariable.isValid());
+
+		// not try to use a local pool variable which does not exist
+		lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+		REQUIRE(invalidVariable.read() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+
+		// now try to access with wrong type
+		lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+		REQUIRE(invalidVariable2.read() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+
+		// now try to access with wrong type
+		lp_var_t<int8_t> readOnlyVar = lp_var_t<int8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
+				nullptr, pool_rwm_t::VAR_READ);
+		REQUIRE(readOnlyVar.commit() ==
+				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+	}
 
-	// now try to access with wrong type
-	lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
-			objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
-	REQUIRE(invalidVariable2.read() ==
-			static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
 }
 
 

From b241ef6aad5861dc570548fd17bdf856e3332984 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 5 Jan 2021 22:51:49 +0100
Subject: [PATCH 1366/1774] continued tests

---
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h  |  2 ++
 .../tests/datapoollocal/LocalPoolVariableTest.cpp  | 14 ++++++++++++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index b73c52996..40f657be9 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -10,6 +10,7 @@
 namespace lpool {
 static constexpr lp_id_t uint8VarId = 0;
 static constexpr lp_id_t floatVarId = 1;
+static constexpr lp_id_t uint32VarId = 2;
 }
 
 
@@ -74,6 +75,7 @@ private:
 
 	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
 	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
+	lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
 
 	MessageQueueIF* messageQueue = nullptr;
 	LocalDataPoolManager hkManager;
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index f52ff9251..faca03e37 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -23,6 +23,8 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		REQUIRE(testVariable.value == 5);
 
 		CHECK(not testVariable.isValid());
+		testVariable.setValid(true);
+		CHECK(testVariable.isValid());
 
 		// not try to use a local pool variable which does not exist
 		lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
@@ -36,12 +38,20 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		REQUIRE(invalidVariable2.read() ==
 				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
 
-		// now try to access with wrong type
-		lp_var_t<int8_t> readOnlyVar = lp_var_t<int8_t>(
+		lp_var_t<uint8_t> readOnlyVar = lp_var_t<uint8_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
 				nullptr, pool_rwm_t::VAR_READ);
 		REQUIRE(readOnlyVar.commit() ==
 				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+		lp_var_t<uint8_t> writeOnlyVar = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
+				nullptr, pool_rwm_t::VAR_WRITE);
+		REQUIRE(writeOnlyVar.read() == static_cast<int>(
+				PoolVariableIF::INVALID_READ_WRITE_MODE));
+
+		lp_var_t<uint32_t> uint32tVar = lp_var_t<uint32_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId);
+		sif::info << "LocalPoolVariable printout: " <<uint32tVar << std::endl;
 	}
 
 }

From bd93392b59b3904ef450a61d0005196d896af948 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 16:26:08 +0100
Subject: [PATCH 1367/1774] local pool variabel tweaks and fixes

---
 datapoollocal/LocalPoolVariable.tpp | 34 +++++++++++++++++------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index cd5117c80..dd6219b14 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -34,7 +34,7 @@ template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVar: Invalid read write "
+		sif::warning << "LocalPoolVariable: Invalid read write "
 				"mode for read() call." << std::endl;
 #endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
@@ -44,7 +44,7 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK or poolEntry == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
+		sif::error << "PoolPoolVariable: Read of local pool variable of object "
 				<< std::hex << std::setw(8) << std::setfill('0')
 				<< hkManager->getOwner() << " and lp ID " << localPoolId
 				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
@@ -67,7 +67,7 @@ template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVariable: Invalid read write "
+		sif::warning << "LocalPoolVariable: Invalid read write "
 				 "mode for commit() call." << std::endl;
 #endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
@@ -76,10 +76,10 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
-				std::dec << " failed.\n" << std::flush;
+		sif::error << "PoolPoolVariable: Read of local pool variable of "
+				<< "object " << std::hex << std::setw(8) << std::setfill('0')
+				<< hkManager->getOwner() << " and lp ID " << localPoolId
+				<< std::dec << " failed." << std::endl;
 #endif
 		return result;
 	}
@@ -89,8 +89,9 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
+inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer,
+		size_t* size, const size_t max_size,
+		SerializeIF::Endianness streamEndianness) const {
 	return SerializeAdapter::serialize(&value,
 			buffer, size ,max_size, streamEndianness);
 }
@@ -121,7 +122,8 @@ inline LocalPoolVariable<T>::operator T() const {
 }
 
 template<typename T>
-inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(const T& newValue) {
+inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(
+		const T& newValue) {
     value = newValue;
     return *this;
 }
@@ -134,7 +136,8 @@ inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
 }
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator ==(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator ==(
+		const LocalPoolVariable<T> &other) const {
 	return this->value == other.value;
 }
 
@@ -145,7 +148,8 @@ inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
 
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator !=(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator !=(
+		const LocalPoolVariable<T> &other) const {
 	return not (*this == other);
 }
 
@@ -156,7 +160,8 @@ inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
 
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator <(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator <(
+		const LocalPoolVariable<T> &other) const {
 	return this->value < other.value;
 }
 
@@ -167,7 +172,8 @@ inline bool LocalPoolVariable<T>::operator <(const T &other) const {
 
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator >(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator >(
+		const LocalPoolVariable<T> &other) const {
 	return not (*this < other);
 }
 

From 16458f6a1e42fa75c4ca0155f22117bd0acf2b0b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 18:20:38 +0100
Subject: [PATCH 1368/1774] continued tests

---
 datapoollocal/LocalPoolVariable.tpp           |  4 ++--
 datapoollocal/LocalPoolVector.tpp             | 20 +++++++++----------
 .../datapoollocal/LocalPoolVariableTest.cpp   | 11 ++++++++++
 3 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index dd6219b14..153a13d03 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -46,7 +46,7 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolPoolVariable: Read of local pool variable of object "
 				<< std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << " and lp ID " << localPoolId
+				<< hkManager->getOwner() << " and lp ID 0x" << localPoolId
 				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
 #endif
 		return result;
@@ -78,7 +78,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolPoolVariable: Read of local pool variable of "
 				<< "object " << std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << " and lp ID " << localPoolId
+				<< hkManager->getOwner() << " and lp ID 0x" << localPoolId
 				<< std::dec << " failed." << std::endl;
 #endif
 		return result;
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 5c3b0ce01..a010a8bb8 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -33,7 +33,7 @@ template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVar: Invalid read write "
+		sif::warning << "LocalPoolVector: Invalid read write "
 				"mode for read() call." << std::endl;
 #endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
@@ -45,10 +45,10 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 
 	if(result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << "and lp ID 0x" << localPoolId <<
-				std::dec << " failed." << std::endl;
+		sif::error << "LocalPoolVector: Read of local pool variable of object "
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< hkManager->getOwner() << "and lp ID 0x" << localPoolId
+				<< std::dec << " failed." << std::endl;
 #endif
 		return result;
 	}
@@ -69,7 +69,7 @@ template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVar: Invalid read write "
+		sif::warning << "LocalPoolVector: Invalid read write "
 				"mode for commit() call." << std::endl;
 #endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
@@ -78,10 +78,10 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
-				std::dec << " failed.\n" << std::flush;
+		sif::error << "LocalPoolVector: Read of local pool variable of object "
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< hkManager->getOwner() << " and lp ID " << localPoolId
+				<< std::dec << " failed." << std::endl;
 #endif
 		return result;
 	}
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index faca03e37..2a7f98636 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -26,12 +26,23 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		testVariable.setValid(true);
 		CHECK(testVariable.isValid());
 
+		gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE,
+				lpool::uint8VarId);
+		lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
+		REQUIRE(testVariable.read() == retval::CATCH_OK);
+		REQUIRE(testVariable == 5);
+	}
+
+	SECTION("ErrorHandling") {
+
 		// not try to use a local pool variable which does not exist
 		lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
 		REQUIRE(invalidVariable.read() ==
 				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
 
+		REQUIRE(invalidVariable.commit() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
 		// now try to access with wrong type
 		lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);

From dc8dd770e7e9500da1ce5813a954ea5c8111ca8f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 19:07:35 +0100
Subject: [PATCH 1369/1774] added more tests

---
 .../datapoollocal/LocalPoolVariableTest.cpp   | 21 +++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index 2a7f98636..e60d5a6b6 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -29,8 +29,25 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE,
 				lpool::uint8VarId);
 		lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
-		REQUIRE(testVariable.read() == retval::CATCH_OK);
-		REQUIRE(testVariable == 5);
+		REQUIRE(testVariable2.read() == retval::CATCH_OK);
+		CHECK(testVariable2 == 5);
+		CHECK(testVariable == testVariable2);
+		testVariable = 10;
+		CHECK(testVariable != 5);
+		//CHECK(not testVariable != testVariable2);
+		uint8_t variableRaw = 0;
+		uint8_t* varPtr = &variableRaw;
+		size_t maxSize = testVariable.getSerializedSize();
+		CHECK(maxSize == 1);
+		size_t serSize = 0;
+		CHECK(testVariable.serialize(&varPtr, &serSize, maxSize,
+				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+		CHECK(variableRaw == 10);
+		const uint8_t* varConstPtr = &variableRaw;
+		testVariable = 5;
+		CHECK(testVariable.deSerialize(&varConstPtr, &serSize,
+				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+		CHECK(testVariable == 10);
 	}
 
 	SECTION("ErrorHandling") {

From 8807772d134c04dc495627ebeef7d4f45cb31057 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 19:16:41 +0100
Subject: [PATCH 1370/1774] 100 % line coverage reached

---
 .../tests/datapoollocal/LocalPoolVariableTest.cpp     | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index e60d5a6b6..b173089c1 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -48,6 +48,17 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		CHECK(testVariable.deSerialize(&varConstPtr, &serSize,
 				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
 		CHECK(testVariable == 10);
+		CHECK(testVariable != testVariable2);
+		CHECK(testVariable2 < testVariable);
+		CHECK(testVariable2 < 10);
+		CHECK(testVariable > 5);
+		CHECK(testVariable > testVariable2);
+		variableRaw = static_cast<uint8_t>(testVariable2);
+		CHECK(variableRaw == 5);
+
+		CHECK(testVariable == 10);
+		testVariable = testVariable2;
+		CHECK(testVariable == 5);
 	}
 
 	SECTION("ErrorHandling") {

From db7d28f8526c7a6998f712b5ed4f904f757f011a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 19:32:33 +0100
Subject: [PATCH 1371/1774] test update

---
 datapoollocal/LocalPoolVariable.h             |   1 +
 datapoollocal/LocalPoolVariable.tpp           |  21 +++-
 unittest/internal/UnittDefinitions.h          |   1 +
 unittest/tests/action/TestActionHelper.cpp    |   2 +
 .../datapoollocal/LocalPoolVariableTest.cpp   |   2 +
 unittest/user/CMakeLists.txt                  | 108 ++++++++++++++++--
 unittest/user/unittest/core/CMakeLists.txt    |   6 +
 .../user/unittest/core/CatchDefinitions.cpp   |   3 +
 unittest/user/unittest/core/CatchFactory.cpp  |  22 +++-
 unittest/user/unittest/core/CatchRunner.cpp   |  13 +--
 unittest/user/unittest/core/CatchSetup.cpp    |  14 +--
 unittest/user/unittest/core/printChar.cpp     |   2 +-
 12 files changed, 164 insertions(+), 31 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 84be54b10..21ee27644 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -7,6 +7,7 @@
 
 #include "../datapool/PoolVariableIF.h"
 #include "../datapool/DataSetIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerializeAdapter.h"
 
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 153a13d03..f35c8be26 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -35,8 +35,11 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalPoolVariable: Invalid read write "
-				"mode for read() call." << std::endl;
-#endif
+				"mode for read call." << std::endl;
+#else
+		fsfw::printWarning("LocalPoolVariable: Invalid read write "
+				"mode for read call.");
+#endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
@@ -48,7 +51,11 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 				<< std::hex << std::setw(8) << std::setfill('0')
 				<< hkManager->getOwner() << " and lp ID 0x" << localPoolId
 				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
-#endif
+#else
+		fsfw::printError("LocalPoolVariable: Read of local pool variable of "
+				"object 0x%08x and lp ID 0x08x failed.", hkManager->getOwner(),
+				localPoolId);
+#endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return result;
 	}
 	this->value = *(poolEntry->address);
@@ -69,7 +76,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalPoolVariable: Invalid read write "
 				 "mode for commit() call." << std::endl;
-#endif
+#endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
@@ -80,7 +87,11 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 				<< "object " << std::hex << std::setw(8) << std::setfill('0')
 				<< hkManager->getOwner() << " and lp ID 0x" << localPoolId
 				<< std::dec << " failed." << std::endl;
-#endif
+#else
+		fsfw::printError("LocalPoolVariable: Read of local pool variable of "
+				"object 0x%08x and lp ID 0x08x failed.", hkManager->getOwner(),
+				localPoolId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return result;
 	}
 	*(poolEntry->address) = this->value;
diff --git a/unittest/internal/UnittDefinitions.h b/unittest/internal/UnittDefinitions.h
index ea36fea40..d319f4bce 100644
--- a/unittest/internal/UnittDefinitions.h
+++ b/unittest/internal/UnittDefinitions.h
@@ -5,6 +5,7 @@
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include <cstdint>
 #include <cstddef>
+#include <string>
 
 namespace tv {
 // POD test values
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index 3109eba1a..3957bba2f 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -7,6 +7,8 @@
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <array>
+
 
 TEST_CASE( "Action Helper" , "[ActionHelper]") {
 	ActionHelperOwnerMockBase testDhMock;
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index b173089c1..cf4f4b6b3 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -90,7 +90,9 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 
 		lp_var_t<uint32_t> uint32tVar = lp_var_t<uint32_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::info << "LocalPoolVariable printout: " <<uint32tVar << std::endl;
+#endif
 	}
 
 }
diff --git a/unittest/user/CMakeLists.txt b/unittest/user/CMakeLists.txt
index 6ec314c3b..722cc424c 100644
--- a/unittest/user/CMakeLists.txt
+++ b/unittest/user/CMakeLists.txt
@@ -13,7 +13,19 @@ cmake_minimum_required(VERSION 3.13)
 
 # set(CMAKE_VERBOSE TRUE)
 
-set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/buildsystem/cmake")
+set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+option(TMTC_TEST "Build binary for manual or automatic TMTC tests" FALSE)
+option(GENERATE_COVERAGE 
+	"Specify whether coverage data is generated with GCOV" 
+	TRUE
+)
+
+if(TMTC_TEST)
+	set(LINK_CATCH2 FALSE)
+else()
+	set(LINK_CATCH2 TRUE)
+endif()
 
 # Tests can be built with the Host OSAL or with the Linux OSAL.
 if(NOT OS_FSFW)
@@ -53,6 +65,7 @@ set(FSFW_PATH fsfw)
 set(CATCH2_PATH Catch2)
 set(FSFW_TESTS_PATH fsfw/unittest)
 set(TEST_SETUP_PATH unittest)
+set(TMTC_TEST_PATH tests)
 
 # Analyse different OS and architecture/target options and
 # determine BSP_PATH
@@ -71,6 +84,15 @@ else()
 	endif()
 endif()
 
+if(GENERATE_COVERAGE)
+	list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/cmake-modules)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+    	include(CodeCoverage)
+    	# Add compile options on target base, we don't want coverage for Catch2
+    	# append_coverage_compiler_flags()
+   	endif()
+endif()
+
 set(FSFW_CONFIG_PATH testcfg)
 
 ################################################################################
@@ -82,10 +104,16 @@ add_executable(${TARGET_NAME})
 
 # Add subdirectories
 add_subdirectory(${FSFW_PATH})
-add_subdirectory(${CATCH2_PATH})
 add_subdirectory(${FSFW_CONFIG_PATH})
-add_subdirectory(${FSFW_TESTS_PATH})
-add_subdirectory(${TEST_SETUP_PATH})
+
+if(LINK_CATCH2)
+	add_subdirectory(${CATCH2_PATH})
+	add_subdirectory(${FSFW_TESTS_PATH})
+	add_subdirectory(${TEST_SETUP_PATH})
+else()
+	add_subdirectory(${TMTC_TEST_PATH})
+endif()
+
 
 ################################################################################
 # Post-Sources preparation
@@ -94,9 +122,74 @@ add_subdirectory(${TEST_SETUP_PATH})
 # Add libraries for all sources.
 target_link_libraries(${TARGET_NAME} PRIVATE
 	${LIB_FSFW_NAME} 
-	${CATCH2_TARGET}
 )
 
+if(LINK_CATCH2)
+	target_link_libraries(${TARGET_NAME} PRIVATE
+		${CATCH2_TARGET}
+	)
+endif()
+
+if(GENERATE_COVERAGE)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+		set(CODE_COVERAGE_VERBOSE TRUE)
+    	include(CodeCoverage)
+    	
+    	# Remove quotes.
+    	separate_arguments(COVERAGE_COMPILER_FLAGS 
+    		NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}"
+    	)
+    	
+    	# Add compile options manually, we don't want coverage for Catch2
+    	target_compile_options(${TARGET_NAME} PRIVATE
+    		"${COVERAGE_COMPILER_FLAGS}"
+    	)
+    	target_compile_options(${LIB_FSFW_NAME} PRIVATE
+    		"${COVERAGE_COMPILER_FLAGS}"
+    	)
+    	
+		# Exclude internal unittest from coverage for now.
+    	if(WIN32)
+			set(GCOVR_ADDITIONAL_ARGS 
+				"--exclude-throw-branches"
+				"--exclude-unreachable-branches"
+			)
+			set(COVERAGE_EXCLUDES
+				"/c/msys64/mingw64/*" "Catch2"
+				"${CMAKE_CURRENT_SOURCE_DIR}/fsfw/unittest/internal"
+			)
+		elseif(UNIX)
+			set(COVERAGE_EXCLUDES
+				"/usr/include/*" "/usr/bin/*" "Catch2/*"
+				"fsfw/unittest/internal/*"
+			)
+		endif()
+    	
+		target_link_options(${TARGET_NAME} PRIVATE
+			-fprofile-arcs
+			-ftest-coverage
+    	)
+    	target_link_options(${LIB_FSFW_NAME} PRIVATE
+			-fprofile-arcs
+			-ftest-coverage
+    	)
+    	
+		if(WIN32)
+			setup_target_for_coverage_gcovr_html(
+				NAME ${TARGET_NAME}_coverage
+				EXECUTABLE ${TARGET_NAME}
+				DEPENDENCIES ${TARGET_NAME}
+			)
+    	else()
+			setup_target_for_coverage_lcov(
+				NAME ${TARGET_NAME}_coverage
+				EXECUTABLE ${TARGET_NAME}
+				DEPENDENCIES ${TARGET_NAME}
+			)
+		endif()
+	endif()
+endif()
+
 # Add include paths for all sources.
 target_include_directories(${TARGET_NAME} PRIVATE
 	${CMAKE_CURRENT_SOURCE_DIR}
@@ -147,8 +240,7 @@ if(NOT CMAKE_SIZE)
 	endif()
 endif()
 
-add_custom_command(
-   TARGET ${TARGET_NAME}
+add_custom_command(TARGET ${TARGET_NAME}
    POST_BUILD
    COMMAND echo "Build directory: ${CMAKE_BINARY_DIR}"
    COMMAND echo "Target OSAL: ${OS_FSFW}"
@@ -156,7 +248,7 @@ add_custom_command(
    COMMAND ${CMAKE_SIZE} ${TARGET_NAME}${FILE_SUFFIX}
 )
 
-include (${CMAKE_CURRENT_SOURCE_DIR}/buildsystem/cmake/BuildType.cmake)
+include (${CMAKE_SCRIPT_PATH}/BuildType.cmake)
 set_build_type()
 
 
diff --git a/unittest/user/unittest/core/CMakeLists.txt b/unittest/user/unittest/core/CMakeLists.txt
index d78f45f18..0989926c3 100644
--- a/unittest/user/unittest/core/CMakeLists.txt
+++ b/unittest/user/unittest/core/CMakeLists.txt
@@ -5,3 +5,9 @@ target_sources(${TARGET_NAME} PRIVATE
 	CatchSetup.cpp
 	printChar.cpp
 )
+
+if(CUSTOM_UNITTEST_RUNNER)
+	target_sources(${TARGET_NAME} PRIVATE
+		CatchRunner.cpp
+	)
+endif()
\ No newline at end of file
diff --git a/unittest/user/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
index 00daf0156..02a935d23 100644
--- a/unittest/user/unittest/core/CatchDefinitions.cpp
+++ b/unittest/user/unittest/core/CatchDefinitions.cpp
@@ -1,4 +1,5 @@
 #include "CatchDefinitions.h"
+#include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
 
 StorageManagerIF* tglob::getIpcStoreHandle() {
@@ -7,6 +8,8 @@ StorageManagerIF* tglob::getIpcStoreHandle() {
 	} else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;
+#else
+		fsfw::printError("Global object manager uninitialized");
 #endif
 		return nullptr;
 	}
diff --git a/unittest/user/unittest/core/CatchFactory.cpp b/unittest/user/unittest/core/CatchFactory.cpp
index 3177212f4..0597f08c0 100644
--- a/unittest/user/unittest/core/CatchFactory.cpp
+++ b/unittest/user/unittest/core/CatchFactory.cpp
@@ -1,11 +1,15 @@
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include "CatchFactory.h"
 
 #include <fsfw/events/EventManager.h>
 #include <fsfw/health/HealthTable.h>
-
 #include <fsfw/internalError/InternalErrorReporter.h>
 #include <fsfw/objectmanager/frameworkObjects.h>
 #include <fsfw/storagemanager/PoolManager.h>
+#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
 
 /**
  * @brief Produces system objects.
@@ -50,7 +54,23 @@ void Factory::produce(void) {
 }
 
 void Factory::setStaticFrameworkObjectIds() {
+	PusServiceBase::packetSource = objects::NO_OBJECT;
+	PusServiceBase::packetDestination = objects::NO_OBJECT;
 
+	CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+	CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
+
+	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+
+	DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+	DeviceHandlerBase::rawDataReceiverId = objects::PUS_SERVICE_2_DEVICE_ACCESS;
+
+	LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
+
+	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
+
+	TmPacketStored::timeStamperId = objects::NO_OBJECT;
 }
 
 
+
diff --git a/unittest/user/unittest/core/CatchRunner.cpp b/unittest/user/unittest/core/CatchRunner.cpp
index 35c53cd47..886d641f3 100644
--- a/unittest/user/unittest/core/CatchRunner.cpp
+++ b/unittest/user/unittest/core/CatchRunner.cpp
@@ -1,17 +1,16 @@
 /**
- * @file 	CatchSource.cpp
+ * @file 	CatchRunner.cpp
  * @brief 	Source file to compile catch framework.
  * @details	All tests should be written in other files.
  * For eclipse console output, install ANSI Escape in Console
  * from the eclipse market place to get colored characters.
  */
 
-#ifndef NO_UNIT_TEST_FRAMEWORK
+#include <TestsConfig.h>
 
-#define CATCH_CONFIG_RUNNER
-#include <catch2/catch.hpp>
+#define CATCH_CONFIG_COLOUR_WINDOWS
 
-#if CUSTOM_UNITTEST_RUNNER == 0
+#include <catch2/catch_session.hpp>
 
 extern int customSetup();
 
@@ -25,7 +24,3 @@ int main( int argc, char* argv[] ) {
     return result;
 }
 
-#endif
-
-
-#endif
diff --git a/unittest/user/unittest/core/CatchSetup.cpp b/unittest/user/unittest/core/CatchSetup.cpp
index c93cf0323..bda314003 100644
--- a/unittest/user/unittest/core/CatchSetup.cpp
+++ b/unittest/user/unittest/core/CatchSetup.cpp
@@ -1,21 +1,20 @@
-#include <fsfw/unittest/core/CatchFactory.h>
+#include "CatchFactory.h"
 #include "CatchDefinitions.h"
-#include <testcfg/cdatapool/dataPoolInit.h>
 
 #ifdef GCOV
 #include <gcov.h>
 #endif
 
-#include "../../objectmanager/ObjectManager.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../storagemanager/StorageManagerIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/storagemanager/StorageManagerIF.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 
 
 /* Global instantiations normally done in main.cpp */
 /* Initialize Data Pool */
 
-
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 namespace sif {
 /* Set up output streams */
 ServiceInterfaceStream debug("DEBUG");
@@ -23,6 +22,7 @@ ServiceInterfaceStream info("INFO");
 ServiceInterfaceStream error("ERROR");
 ServiceInterfaceStream warning("WARNING");
 }
+#endif
 
 /* Global object manager */
 ObjectManagerIF *objectManager;
diff --git a/unittest/user/unittest/core/printChar.cpp b/unittest/user/unittest/core/printChar.cpp
index 755a13b22..5d4f1b173 100644
--- a/unittest/user/unittest/core/printChar.cpp
+++ b/unittest/user/unittest/core/printChar.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/unittest/core/printChar.h>
+#include "printChar.h"
 #include <cstdio>
 
 void printChar(const char* character, bool errStream) {

From 91cf5f176400a12c18e66ef53bf7efe1fab9265f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 19:49:58 +0100
Subject: [PATCH 1372/1774] added way to completely disable printouts

---
 datapoollocal/LocalPoolVariable.tpp          | 15 +++++----
 serviceinterface/ServiceInterfacePrinter.cpp | 32 ++++++++++++++------
 serviceinterface/ServiceInterfacePrinter.h   |  2 ++
 unittest/internal/UnittDefinitions.cpp       |  6 ++--
 unittest/internal/UnittDefinitions.h         |  2 +-
 5 files changed, 38 insertions(+), 19 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index f35c8be26..f70e4e918 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -38,7 +38,7 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 				"mode for read call." << std::endl;
 #else
 		fsfw::printWarning("LocalPoolVariable: Invalid read write "
-				"mode for read call.");
+				"mode for read call.\n\r");
 #endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
@@ -53,8 +53,8 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
 #else
 		fsfw::printError("LocalPoolVariable: Read of local pool variable of "
-				"object 0x%08x and lp ID 0x08x failed.", hkManager->getOwner(),
-				localPoolId);
+				"object 0x%08x and lp ID 0x%08x failed.\n\r",
+				hkManager->getOwner(), localPoolId);
 #endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return result;
 	}
@@ -75,7 +75,10 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalPoolVariable: Invalid read write "
-				 "mode for commit() call." << std::endl;
+				 "mode for commit call." << std::endl;
+#else
+		fsfw::printWarning("LocalPoolVariable: Invalid read write "
+				 "mode for commit call.\n\r");
 #endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
@@ -89,8 +92,8 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 				<< std::dec << " failed." << std::endl;
 #else
 		fsfw::printError("LocalPoolVariable: Read of local pool variable of "
-				"object 0x%08x and lp ID 0x08x failed.", hkManager->getOwner(),
-				localPoolId);
+				"object 0x%08x and lp ID 0x%08x failed.\n\r",
+				hkManager->getOwner(), localPoolId);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return result;
 	}
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index e8eb498f9..15e738a80 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -6,12 +6,14 @@
 #include <cstdarg>
 #include <cstdint>
 
-
 fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
-uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
 bool consoleInitialized = false;
-#endif
+#endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
+
+
+#if FSFW_DISABLE_PRINTOUT == 0
+uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 
 void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 
@@ -81,13 +83,6 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     printf("%s", printBuffer);
 }
 
-void fsfw::setPrintLevel(PrintLevel printLevel_) {
-	printLevel = printLevel_;
-}
-
-fsfw::PrintLevel fsfw::getPrintLevel() {
-	return printLevel;
-}
 
 void fsfw::printInfo(const char *fmt, ...) {
     va_list args;
@@ -116,3 +111,20 @@ void fsfw::printError(const char *fmt, ...) {
     fsfwPrint(fsfw::PrintLevel::ERROR_TYPE, fmt, args);
     va_end(args);
 }
+
+#else
+
+void fsfw::printInfo(const char *fmt, ...) {}
+void fsfw::printWarning(const char *fmt, ...) {}
+void fsfw::printDebug(const char *fmt, ...) {}
+void fsfw::printError(const char *fmt, ...) {}
+
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
+
+void fsfw::setPrintLevel(PrintLevel printLevel_) {
+	printLevel = printLevel_;
+}
+
+fsfw::PrintLevel fsfw::getPrintLevel() {
+	return printLevel;
+}
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index 8b81ee7a0..a60b6332f 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -1,4 +1,6 @@
+#if FSFW_DISABLE_PRINTOUT == 0
 #include <stdio.h>
+#endif
 
 namespace fsfw {
 
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index 7138e6c62..d20771a43 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -3,7 +3,9 @@
  ReturnValue_t unitt::put_error(std::string errorId) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Unit Tester error: Failed at test ID "
-			<< errorId << "\n" << std::flush;
-#endif
+			<< errorId << std::endl;
+#else
+	fsfw::printError("Unit Tester error: Failed at test ID 0x%08x", errorId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/unittest/internal/UnittDefinitions.h b/unittest/internal/UnittDefinitions.h
index d319f4bce..3e14fec57 100644
--- a/unittest/internal/UnittDefinitions.h
+++ b/unittest/internal/UnittDefinitions.h
@@ -2,7 +2,7 @@
 #define UNITTEST_INTERNAL_UNITTDEFINITIONS_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include <cstdint>
 #include <cstddef>
 #include <string>

From dacdfc62d3841a89be5aa4988e35784737027dd1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 21:14:23 +0100
Subject: [PATCH 1373/1774] a lot of bugfixes and important api change

---
 datapool/PoolDataSetBase.cpp                  | 34 ++++++----
 datapool/PoolDataSetBase.h                    | 23 ++++---
 datapool/PoolDataSetIF.h                      |  5 +-
 datapool/PoolEntry.cpp                        |  2 +
 datapool/ReadCommitIF.h                       | 11 ++--
 datapoollocal/LocalPoolDataSetBase.cpp        | 65 +++++++++++++++----
 datapoollocal/LocalPoolDataSetBase.h          | 21 +++++-
 datapoollocal/LocalPoolVariable.h             | 19 +++++-
 datapoollocal/LocalPoolVariable.tpp           | 19 ++++--
 datapoollocal/LocalPoolVector.h               | 14 ++--
 datapoollocal/LocalPoolVector.tpp             | 13 ++--
 devicehandlers/DeviceHandlerBase.cpp          |  3 +-
 events/EventManager.cpp                       |  8 ++-
 events/EventManager.h                         |  4 ++
 internalError/InternalErrorReporter.cpp       | 29 +++++----
 internalError/InternalErrorReporter.h         |  8 ++-
 ipc/MutexIF.h                                 |  2 +-
 osal/host/Clock.cpp                           |  4 +-
 osal/host/Mutex.cpp                           |  6 +-
 power/Fuse.cpp                                |  7 +-
 power/PowerSensor.cpp                         |  3 +-
 unittest/internal/osal/IntTestMutex.cpp       |  2 +-
 unittest/tests/datapoollocal/DataSetTest.cpp  | 21 ++++++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 39 +++++++++--
 .../datapoollocal/LocalPoolVariableTest.cpp   | 29 ++++++++-
 .../datapoollocal/LocalPoolVectorTest.cpp     | 16 +++++
 26 files changed, 314 insertions(+), 93 deletions(-)
 create mode 100644 unittest/tests/datapoollocal/DataSetTest.cpp
 create mode 100644 unittest/tests/datapoollocal/LocalPoolVectorTest.cpp

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 5fb1c3c7d..05797012f 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -38,11 +38,12 @@ ReturnValue_t PoolDataSetBase::registerVariable(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::read(MutexIF::TimeoutType timeoutType,
+		uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t error = result;
 	if (state == States::STATE_SET_UNINITIALISED) {
-		lockDataPool(lockTimeout);
+		lockDataPool(timeoutType, lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
 			result = readVariable(count);
 			if(result != RETURN_OK) {
@@ -86,7 +87,8 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 				!= PoolVariableIF::NO_PARAMETER)
 	{
 		if(protectEveryReadCommitCall) {
-			result = registeredVariables[count]->read(mutexTimeout);
+			result = registeredVariables[count]->read(
+					MutexIF::TimeoutType::WAITING, mutexTimeout);
 		}
 		else {
 			result = registeredVariables[count]->readWithoutLock();
@@ -99,25 +101,28 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 	return result;
 }
 
-ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::commit(MutexIF::TimeoutType timeoutType,
+		uint32_t lockTimeout) {
 	if (state == States::STATE_SET_WAS_READ) {
-		handleAlreadyReadDatasetCommit(lockTimeout);
+		handleAlreadyReadDatasetCommit(timeoutType, lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-		return handleUnreadDatasetCommit(lockTimeout);
+		return handleUnreadDatasetCommit(timeoutType, lockTimeout);
 	}
 }
 
-void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
-	lockDataPool(lockTimeout);
+void PoolDataSetBase::handleAlreadyReadDatasetCommit(
+		MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
+	lockDataPool(timeoutType, lockTimeout);
 	for (uint16_t count = 0; count < fillCount; count++) {
 		if (registeredVariables[count]->getReadWriteMode()
 				!= PoolVariableIF::VAR_READ
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if(protectEveryReadCommitCall) {
-				registeredVariables[count]->commit(mutexTimeout);
+				registeredVariables[count]->commit(
+						MutexIF::TimeoutType::WAITING, mutexTimeout);
 			}
 			else {
 				registeredVariables[count]->commitWithoutLock();
@@ -128,16 +133,18 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 	unlockDataPool();
 }
 
-ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(
+		MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	lockDataPool(lockTimeout);
+	lockDataPool(timeoutType, lockTimeout);
 	for (uint16_t count = 0; count < fillCount; count++) {
 		if (registeredVariables[count]->getReadWriteMode()
 				== PoolVariableIF::VAR_WRITE
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if(protectEveryReadCommitCall) {
-				result = registeredVariables[count]->commit(mutexTimeout);
+				result = registeredVariables[count]->commit(
+						MutexIF::TimeoutType::WAITING, mutexTimeout);
 			}
 			else {
 				result = registeredVariables[count]->commitWithoutLock();
@@ -160,7 +167,8 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 }
 
 
-ReturnValue_t PoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
+ReturnValue_t PoolDataSetBase::lockDataPool(MutexIF::TimeoutType timeoutType,
+		uint32_t lockTimeout) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 7c1d84a41..0528f40f3 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -62,8 +62,9 @@ public:
 	 * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
 	 *      commit() in between
 	 */
-	virtual ReturnValue_t read(uint32_t lockTimeout =
-			MutexIF::BLOCKING) override;
+	virtual ReturnValue_t read(
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t lockTimeout = 20) override;
 	/**
 	 * @brief	The commit call initializes writing back the registered variables.
 	 * @details
@@ -82,8 +83,9 @@ public:
 	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
 	 * 			  contains non write-only variables
 	 */
-	virtual ReturnValue_t commit(uint32_t lockTimeout =
-			MutexIF::BLOCKING) override;
+	virtual ReturnValue_t commit(
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t lockTimeout = 20) override;
 
 	/**
 	 * Register the passed pool variable instance into the data set.
@@ -97,8 +99,9 @@ public:
 	 * thread-safety. Default implementation is empty
 	 * @return Always returns -@c RETURN_OK
 	 */
-	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs =
-			MutexIF::BLOCKING) override;
+	virtual ReturnValue_t lockDataPool(
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 	/**
 	 * Provides the means to unlock the underlying data structure to ensure
 	 * thread-safety. Default implementation is empty
@@ -160,8 +163,12 @@ private:
 	uint32_t mutexTimeout = 20;
 
 	ReturnValue_t readVariable(uint16_t count);
-	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
-	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
+	void handleAlreadyReadDatasetCommit(
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
+	ReturnValue_t handleUnreadDatasetCommit(
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
 };
 
 #endif /* FSFW_DATAPOOL_POOLDATASETBASE_H_ */
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index 99c06cfd7..1f52871d9 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -18,7 +18,10 @@ public:
      *          thread-safety
      * @return Lock operation result
      */
-    virtual ReturnValue_t lockDataPool(dur_millis_t timeoutMs) = 0;
+    virtual ReturnValue_t lockDataPool(
+    		MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) = 0;
+
     /**
      * @brief   Unlock call corresponding to the lock call.
      * @return Unlock operation result
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 583751626..5f5f56f25 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -88,8 +88,10 @@ Type PoolEntry<T>::getType() {
 template class PoolEntry<uint8_t>;
 template class PoolEntry<uint16_t>;
 template class PoolEntry<uint32_t>;
+template class PoolEntry<uint64_t>;
 template class PoolEntry<int8_t>;
 template class PoolEntry<int16_t>;
 template class PoolEntry<int32_t>;
+template class PoolEntry<int64_t>;
 template class PoolEntry<float>;
 template class PoolEntry<double>;
diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h
index 0cdce3718..efe515944 100644
--- a/datapool/ReadCommitIF.h
+++ b/datapool/ReadCommitIF.h
@@ -2,6 +2,7 @@
 #define FSFW_DATAPOOL_READCOMMITIF_H_
 
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/ipc/MutexIF.h>
 
 /**
  * @brief 	Common interface for all software objects which employ read-commit
@@ -10,8 +11,10 @@
 class ReadCommitIF {
 public:
 	virtual ~ReadCommitIF() {}
-	virtual ReturnValue_t read(uint32_t mutexTimeout) = 0;
-	virtual ReturnValue_t commit(uint32_t mutexTimeout) = 0;
+	virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) = 0;
+	virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) = 0;
 
 protected:
 
@@ -19,11 +22,11 @@ protected:
 	//! members with commit and read semantics where the lock is only necessary
 	//! once.
 	virtual ReturnValue_t readWithoutLock()  {
-		return read(20);
+		return read(MutexIF::TimeoutType::WAITING, 20);
 	}
 
 	virtual ReturnValue_t commitWithoutLock() {
-		return commit(20);
+		return commit(MutexIF::TimeoutType::WAITING, 20);
 	}
 };
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index dbe34dfd3..af492146d 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -1,4 +1,6 @@
 #include "LocalPoolDataSetBase.h"
+
+#include "../serviceinterface/ServiceInterface.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../housekeeping/PeriodicHousekeepingHelper.h"
 #include "../serialize/SerializeAdapter.h"
@@ -15,7 +17,10 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
                 << "invalid!" << std::endl;
-#endif
+#else
+        fsfw::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+                "invalid!\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
@@ -44,13 +49,26 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
     mutex = MutexFactory::instance()->createMutex();
 }
 
+LocalPoolDataSetBase::LocalPoolDataSetBase(
+		PoolVariableIF **registeredVariablesArray,
+		const size_t maxNumberOfVariables, bool protectFunctions):
+		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+	if(protectFunctions) {
+	    mutex = MutexFactory::instance()->createMutex();
+	}
+
+}
+
+
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
 }
 
-ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
+ReturnValue_t LocalPoolDataSetBase::lockDataPool(
+		MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
 	if(hkManager != nullptr) {
-	    MutexIF* mutex = hkManager->getMutexHandle();
-	    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+	    MutexIF* poolMutex = hkManager->getMutexHandle();
+	    return poolMutex->lockMutex(timeoutType, timeoutMs);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -150,9 +168,12 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
                 size, maxSize, streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
-                    " error!" << std::endl;
-#endif
+            sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
+            		<< "Serialization error!" << std::endl;
+#else
+            fsfw::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
+            		"Serialization error!\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
             return result;
         }
     }
@@ -211,8 +232,11 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "Pool Raw Access: Bit setting invalid position"
+        sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
                 << std::endl;
+#else
+        fsfw::printWarning("LocalPoolDataSetBase::bitSetter: "
+        		"Invalid position!\n\r");
 #endif
         return;
     }
@@ -244,14 +268,19 @@ void LocalPoolDataSetBase::initializePeriodicHelper(
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-    // TODO: Make this configurable?
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+	if(mutex == nullptr) {
+		this->changed = changed;
+		return;
+	}
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
     this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
-    // TODO: Make this configurable?
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+	if(mutex == nullptr) {
+		return changed;
+	}
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
     return changed;
 }
 
@@ -273,18 +302,22 @@ bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 }
 
 bool LocalPoolDataSetBase::isValid() const {
+	if(mutex == nullptr) {
+		return this->valid;
+	}
     MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
     return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
+	mutex->lockMutex(timeoutType, mutexTimeout);
     if(setEntriesRecursively) {
         for(size_t idx = 0; idx < this->getFillCount(); idx++) {
             registeredVariables[idx] -> setValid(valid);
         }
     }
     this->valid = valid;
+    mutex->unlockMutex();
 }
 
 void LocalPoolDataSetBase::setReadCommitProtectionBehaviour(
@@ -292,3 +325,9 @@ void LocalPoolDataSetBase::setReadCommitProtectionBehaviour(
 	PoolDataSetBase::setReadCommitProtectionBehaviour(protectEveryReadCommit,
 			mutexTimeout);
 }
+
+void LocalPoolDataSetBase::setDataSetMutexTimeout(
+		MutexIF::TimeoutType timeoutType, uint32_t mutexTimeout) {
+	this->timeoutType = timeoutType;
+	this->mutexTimeout = mutexTimeout;
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index d9b6a2212..b44f607ff 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -67,6 +67,15 @@ public:
 	LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
+	/**
+	 * Simple constructor, if the dataset is not owner permanently by
+	 * a class with a HK manager.
+	 * @param registeredVariablesArray
+	 * @param maxNumberOfVariables
+	 */
+	LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray,
+	        const size_t maxNumberOfVariables, bool protectFunctions = true);
+
 	/**
 	 * @brief	The destructor automatically manages writing the valid
 	 * 			information of variables.
@@ -87,6 +96,9 @@ public:
 	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
 			uint32_t mutexTimeout = 20);
 
+	void setDataSetMutexTimeout(MutexIF::TimeoutType timeoutType,
+			uint32_t mutexTimeout);
+
 	void setValidityBufferGeneration(bool withValidityBuffer);
 
 	sid_t getSid() const;
@@ -138,7 +150,12 @@ public:
 
 protected:
 	sid_t sid;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
 	uint32_t mutexTimeout = 20;
+	/**
+	 * This mutex is required because the dataset can potentially be accessed
+	 * by multiple threads for information like change status or validity.
+	 */
 	MutexIF* mutex = nullptr;
 
 	bool diagnostic = false;
@@ -183,7 +200,9 @@ protected:
 	 * @details
 	 * It makes use of the lockDataPool method offered by the DataPool class.
 	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
+	ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) override;
+
 	/**
 	 * @brief	This is a small helper function to facilitate
 	 * 			unlocking the global data pool
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 21ee27644..c81967a11 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -106,7 +106,9 @@ public:
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 *
 	 */
-	ReturnValue_t read(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
@@ -116,8 +118,21 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 
+	/**
+	 * @brief	This commit function can be used to set the pool variable valid
+	 * 			as well.
+	 * @param setValid
+	 * @param timeoutType
+	 * @param timeoutMs
+	 * @return
+	 */
+	ReturnValue_t commit(bool setValid, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
 
 	LocalPoolVariable<T> &operator=(const T& newValue);
 	LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index f70e4e918..9387acc52 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -24,9 +24,9 @@ inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
 
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::read(dur_millis_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+inline ReturnValue_t LocalPoolVariable<T>::read(
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
 	return readWithoutLock();
 }
 
@@ -64,9 +64,16 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	this->setValid(setValid);
+	return commit(timeoutType, timeoutMs);
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commit(
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
 	return commitWithoutLock();
 }
 
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 58face3cb..773a52cc7 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -7,7 +7,7 @@
 #include "../datapool/PoolVariableIF.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 
 /**
@@ -123,7 +123,9 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
@@ -133,7 +135,9 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 
 protected:
 	/**
@@ -157,12 +161,12 @@ protected:
 
 private:
 
-
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	// std::ostream is the type for object std::cout
 	template <typename U, uint16_t otherSize>
 	friend std::ostream& operator<< (std::ostream &out,
 	        const LocalPoolVector<U, otherSize> &var);
-
+#endif
 
 };
 
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index a010a8bb8..6af80de66 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -24,9 +24,9 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
 				dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
 	return readWithoutLock();
 }
 template<typename T, uint16_t vectorSize>
@@ -59,9 +59,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
-		uint32_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
 	return commitWithoutLock();
 }
 
@@ -153,6 +152,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
 	return result;
 }
 
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 template<typename T, uint16_t vectorSize>
 inline std::ostream& operator<< (std::ostream &out,
         const LocalPoolVector<T, vectorSize> &var) {
@@ -166,5 +166,6 @@ inline std::ostream& operator<< (std::ostream &out,
     out << "]";
     return out;
 }
+#endif
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1af6932ae..580f8c0d0 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -229,7 +229,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			thermalSet->heaterRequest.value =
 					ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-			thermalSet->commit(PoolVariableIF::VALID);
+			thermalSet->heaterRequest.setValid(true);
+			thermalSet->commit();
 		}
 
 	}
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 65e19d102..e25e574f0 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -162,9 +162,15 @@ void EventManager::printEvent(EventMessage* message) {
 #endif
 
 void EventManager::lockMutex() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(timeoutType, timeoutMs);
 }
 
 void EventManager::unlockMutex() {
 	mutex->unlockMutex();
 }
+
+void EventManager::setMutexTimeout(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	this->timeoutType = timeoutType;
+	this->timeoutMs = timeoutMs;
+}
diff --git a/events/EventManager.h b/events/EventManager.h
index c6bd07be8..abce9b8ba 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -29,6 +29,8 @@ public:
 	EventManager(object_id_t setObjectId);
 	virtual ~EventManager();
 
+	void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
+
 	MessageQueueId_t getEventReportQueue();
 
 	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
@@ -51,6 +53,8 @@ protected:
 	std::map<MessageQueueId_t, EventMatchTree> listenerList;
 
 	MutexIF* mutex = nullptr;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	uint32_t timeoutMs = 20;
 
 	static const uint8_t N_POOLS = 3;
 	LocalPool factoryBackend;
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 48b6f851b..6842da8e8 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -23,7 +23,7 @@ void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
 }
 
 ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
-    internalErrorDataset.read(INTERNAL_ERROR_MUTEX_TIMEOUT);
+    internalErrorDataset.read(timeoutType, timeoutMs);
 
 	uint32_t newQueueHits = getAndResetQueueHits();
 	uint32_t newTmHits = getAndResetTmHits();
@@ -46,8 +46,8 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	internalErrorDataset.queueHits.value += newQueueHits;
 	internalErrorDataset.storeHits.value += newStoreHits;
 	internalErrorDataset.tmHits.value += newTmHits;
-
-	internalErrorDataset.commit(INTERNAL_ERROR_MUTEX_TIMEOUT);
+	internalErrorDataset.setValidity(true, true);
+	internalErrorDataset.commit(timeoutType, timeoutMs);
 
 	poolManager.performHkOperation();
 
@@ -69,7 +69,7 @@ void InternalErrorReporter::lostTm() {
 
 uint32_t InternalErrorReporter::getAndResetQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = queueHits;
 	queueHits = 0;
 	mutex->unlockMutex();
@@ -78,21 +78,21 @@ uint32_t InternalErrorReporter::getAndResetQueueHits() {
 
 uint32_t InternalErrorReporter::getQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = queueHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	queueHits++;
 	mutex->unlockMutex();
 }
 
 uint32_t InternalErrorReporter::getAndResetTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = tmHits;
 	tmHits = 0;
 	mutex->unlockMutex();
@@ -101,14 +101,14 @@ uint32_t InternalErrorReporter::getAndResetTmHits() {
 
 uint32_t InternalErrorReporter::getTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = tmHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	tmHits++;
 	mutex->unlockMutex();
 }
@@ -119,7 +119,7 @@ void InternalErrorReporter::storeFull() {
 
 uint32_t InternalErrorReporter::getAndResetStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = storeHits;
 	storeHits = 0;
 	mutex->unlockMutex();
@@ -128,14 +128,14 @@ uint32_t InternalErrorReporter::getAndResetStoreHits() {
 
 uint32_t InternalErrorReporter::getStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = storeHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	storeHits++;
 	mutex->unlockMutex();
 }
@@ -190,3 +190,8 @@ ReturnValue_t InternalErrorReporter::initializeAfterTaskCreation() {
     return poolManager.initializeAfterTaskCreation();
 }
 
+void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	this->timeoutType = timeoutType;
+	this->timeoutMs = timeoutMs;
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 8d33c06e2..c85057d6d 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -22,7 +22,6 @@ class InternalErrorReporter: public SystemObject,
 		public InternalErrorReporterIF,
 		public HasLocalDataPoolIF {
 public:
-    static constexpr uint8_t INTERNAL_ERROR_MUTEX_TIMEOUT = 20;
 
 	InternalErrorReporter(object_id_t setObjectId,
 	        uint32_t messageQueueDepth = 5);
@@ -34,6 +33,9 @@ public:
 	 */
 	void setDiagnosticPrintout(bool enable);
 
+	void setMutexTimeout(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs);
+
 	virtual ~InternalErrorReporter();
 
     virtual object_id_t getObjectId() const override;
@@ -61,7 +63,11 @@ protected:
 	LocalDataPoolManager poolManager;
 
 	PeriodicTaskIF* executingTask = nullptr;
+
 	MutexIF* mutex = nullptr;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	uint32_t timeoutMs = 20;
+
 	sid_t internalErrorSid;
 	InternalErrorDataset internalErrorDataset;
 
diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 5673e4d79..084b702b4 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -14,7 +14,7 @@ public:
     /**
      * Different types of timeout for the mutex lock.
      */
-    enum TimeoutType {
+    enum class TimeoutType {
         POLLING, //!< If mutex is not available, return immediately
         WAITING, //!< Wait a specified time for the mutex to become available
         BLOCKING //!< Block indefinitely until the mutex becomes available.
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 2bc78785f..88bf51d23 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -202,7 +202,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -217,7 +217,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex == nullptr){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index ad8873dfc..892028b23 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -4,16 +4,16 @@
 Mutex::Mutex() {}
 
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
-	if(timeoutType == MutexIF::BLOCKING) {
+	if(timeoutType == TimeoutType::BLOCKING) {
 		mutex.lock();
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	else if(timeoutType == MutexIF::POLLING) {
+	else if(timeoutType == TimeoutType::POLLING) {
 		if(mutex.try_lock()) {
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
-	else if(timeoutMs > MutexIF::POLLING){
+	else if(timeoutType == TimeoutType::WAITING){
 		auto chronoMs = std::chrono::milliseconds(timeoutMs);
 		if(mutex.try_lock_for(chronoMs)) {
 			return HasReturnvaluesIF::RETURN_OK;
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 1c30d83f3..b6e0a7f16 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -65,8 +65,8 @@ ReturnValue_t Fuse::check() {
 	set.read();
 	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
 		setAllMonitorsToUnchecked();
-		set.commit(PoolVariableIF::INVALID);
-		return RETURN_OK;
+		set.setValidity(false, true);
+		return set.commit();
 	}
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	checkFuseState();
@@ -206,7 +206,8 @@ float Fuse::getPower() {
 
 void Fuse::setDataPoolEntriesInvalid() {
 	set.read();
-	set.commit(PoolVariableIF::INVALID);
+	set.setValidity(false, true);
+	set.commit();
 }
 
 ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 1ef041e30..fb181d9f9 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -97,7 +97,8 @@ void PowerSensor::checkCommandQueue() {
 
 void PowerSensor::setDataPoolEntriesInvalid() {
 	powerSensorSet.read();
-	powerSensorSet.commit(PoolVariableIF::INVALID);
+	powerSensorSet.setValidity(false, true);
+	powerSensorSet.commit();
 }
 
 float PowerSensor::getPower() {
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index 3316de749..2a1584b8e 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -13,7 +13,7 @@
 void testmutex::testMutex() {
 	std::string id = "[testMutex]";
 	MutexIF* mutex = MutexFactory::instance()->createMutex();
-	auto result = mutex->lockMutex(MutexIF::POLLING);
+	auto result = mutex->lockMutex(MutexIF::TimeoutType::POLLING);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		unitt::put_error(id);
 	}
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
new file mode 100644
index 000000000..ccb7603d4
--- /dev/null
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -0,0 +1,21 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <unittest/core/CatchDefinitions.h>
+
+TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+
+	SECTION("BasicTest") {
+		//StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>()
+	}
+}
+
+
+
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 40f657be9..c665cb7f8 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -4,6 +4,7 @@
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/datapoollocal/LocalPoolVariable.h>
+#include <fsfw/datapoollocal/LocalPoolVector.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <testcfg/objects/systemObjectList.h>
 
@@ -11,9 +12,12 @@ namespace lpool {
 static constexpr lp_id_t uint8VarId = 0;
 static constexpr lp_id_t floatVarId = 1;
 static constexpr lp_id_t uint32VarId = 2;
+static constexpr lp_id_t uint16Vec3Id = 3;
+static constexpr lp_id_t int64Vec2Id = 4;
 }
 
 
+
 class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
 public:
 	LocalPoolOwnerBase(
@@ -31,12 +35,19 @@ public:
 	}
 
 	ReturnValue_t initializeHkManager() {
-		return hkManager.initialize(messageQueue);
-
+		if(not initialized) {
+			initialized = true;
+			return hkManager.initialize(messageQueue);
+		}
+		return HasReturnvaluesIF::RETURN_OK;
 	}
 
 	ReturnValue_t initializeHkManagerAfterTaskCreation() {
-		return hkManager.initializeAfterTaskCreation();
+		if(not initializedAfterTaskCreation) {
+			initializedAfterTaskCreation = true;
+			return hkManager.initializeAfterTaskCreation();
+		}
+		return HasReturnvaluesIF::RETURN_OK;
 	}
 
 	/** Command queue for housekeeping messages. */
@@ -44,12 +55,22 @@ public:
 		return messageQueue->getId();
 	}
 
+	// This is called by initializeAfterTaskCreation of the HK manager.
 	virtual ReturnValue_t initializeLocalDataPool(
 	        LocalDataPool& localDataPoolMap,
 	        LocalDataPoolManager& poolManager) {
 		// Default initialization empty for now.
-		localDataPoolMap.emplace(lpool::uint8VarId, new PoolEntry<uint8_t>({0}));
-		localDataPoolMap.emplace(lpool::floatVarId, new PoolEntry<float>({0}));
+		localDataPoolMap.emplace(lpool::uint8VarId,
+				new PoolEntry<uint8_t>({0}));
+		localDataPoolMap.emplace(lpool::floatVarId,
+				new PoolEntry<float>({0}));
+		localDataPoolMap.emplace(lpool::uint32VarId,
+				new PoolEntry<uint32_t>({0}));
+
+		localDataPoolMap.emplace(lpool::uint16Vec3Id,
+				new PoolEntry<uint16_t>({0, 0, 0}));
+		localDataPoolMap.emplace(lpool::int64Vec2Id,
+				new PoolEntry<int64_t>({0, 0}));
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
@@ -77,9 +98,17 @@ private:
 	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
 	lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
 
+	lp_vec_t<uint16_t, 3> testUint16Vec = lp_vec_t<uint16_t, 3>(this,
+			lpool::uint16Vec3Id);
+	lp_vec_t<int64_t, 2> testInt64Vec = lp_vec_t<int64_t, 2>(this,
+			lpool::int64Vec2Id);
+
 	MessageQueueIF* messageQueue = nullptr;
 	LocalDataPoolManager hkManager;
 
+	bool initialized = false;
+	bool initializedAfterTaskCreation = false;
+
 };
 
 #endif /* FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_ */
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index cf4f4b6b3..eb5abf35a 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -6,9 +6,11 @@
 
 
 TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
-	LocalPoolOwnerBase poolOwner(objects::TEST_LOCAL_POOL_OWNER_BASE);
-	REQUIRE(poolOwner.initializeHkManager() == retval::CATCH_OK);
-	REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation()
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
 			== retval::CATCH_OK);
 
 	SECTION("Basic Tests") {
@@ -26,6 +28,18 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		testVariable.setValid(true);
 		CHECK(testVariable.isValid());
 
+		testVariable.setReadWriteMode(pool_rwm_t::VAR_READ);
+		CHECK(testVariable.getReadWriteMode() == pool_rwm_t::VAR_READ);
+		testVariable.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
+
+		testVariable.setDataPoolId(22);
+		CHECK(testVariable.getDataPoolId() == 22);
+		testVariable.setDataPoolId(lpool::uint8VarId);
+
+		testVariable.setChanged(true);
+		CHECK(testVariable.hasChanged());
+		testVariable.setChanged(false);
+
 		gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE,
 				lpool::uint8VarId);
 		lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
@@ -93,6 +107,15 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::info << "LocalPoolVariable printout: " <<uint32tVar << std::endl;
 #endif
+
+		// for code coverage. If program does not crash -> OK
+		lp_var_t<uint8_t> invalidObjectVar = lp_var_t<uint8_t>(
+				0xffffffff, lpool::uint8VarId);
+		gp_id_t globPoolId(0xffffffff,
+				lpool::uint8VarId);
+		lp_var_t<uint8_t> invalidObjectVar2 = lp_var_t<uint8_t>(globPoolId);
+		lp_var_t<uint8_t> invalidObjectVar3 = lp_var_t<uint8_t>(nullptr,
+				lpool::uint8VarId);
 	}
 
 }
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
new file mode 100644
index 000000000..c86a26818
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -0,0 +1,16 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <unittest/core/CatchDefinitions.h>
+
+TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+}
+
+

From 2b287dfc3ac227af78f68a003948b92656cd4005 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 21:33:54 +0100
Subject: [PATCH 1374/1774] freertos and pool read helper fix

---
 datapoollocal/PoolReadHelper.h | 9 ++++++---
 osal/FreeRTOS/Clock.cpp        | 4 ++--
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index a059685bf..c89fff982 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -9,10 +9,12 @@
  */
 class PoolReadHelper {
 public:
-	PoolReadHelper(ReadCommitIF* readObject, uint32_t mutexTimeout = 20):
+	PoolReadHelper(ReadCommitIF* readObject,
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t mutexTimeout = 20):
 			readObject(readObject), mutexTimeout(mutexTimeout) {
 		if(readObject != nullptr) {
-			readResult = readObject->read(mutexTimeout);
+			readResult = readObject->read(timeoutType, mutexTimeout);
 #if FSFW_PRINT_VERBOSITY_LEVEL == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PoolReadHelper: Read failed!" << std::endl;
@@ -27,7 +29,7 @@ public:
 
 	~PoolReadHelper() {
 		if(readObject != nullptr) {
-			readObject->commit(mutexTimeout);
+			readObject->commit(timeoutType, mutexTimeout);
 		}
 
 	}
@@ -35,6 +37,7 @@ public:
 private:
 	ReadCommitIF* readObject = nullptr;
 	ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
 	uint32_t mutexTimeout = 20;
 };
 
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index d3f4e68e1..9c0a02679 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -163,7 +163,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -178,7 +178,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if (timeMutex == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}

From fcb33201a4c40ae868d82fcff1060fc6fdf2c342 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 21:45:35 +0100
Subject: [PATCH 1375/1774] fixed linux osal

---
 osal/linux/Clock.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 54dad8395..35cbfae03 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -182,7 +182,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -197,7 +197,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex==NULL){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -209,13 +209,13 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 }
 
 ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex==NULL){
+	if(timeMutex == nullptr){
 		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
+		if (mutexFactory == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
+		if (timeMutex == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}

From 8aaf45049faa4677208d3486ce4e6c2946416ee2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 21:49:40 +0100
Subject: [PATCH 1376/1774] major bugfix in rtems osal

---
 osal/rtems/Mutex.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index 71c5782ff..7dd512fae 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -30,11 +30,11 @@ Mutex::~Mutex() {
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType =
         TimeoutType::BLOCKING, uint32_t timeoutMs) {
 	rtems_status_code status = RTEMS_INVALID_ID;
-	if(timeoutMs == MutexIF::TimeoutType::BLOCKING) {
+	if(timeoutType == MutexIF::TimeoutType::BLOCKING) {
 		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_WAIT, RTEMS_NO_TIMEOUT);
 	}
-	else if(timeoutMs == MutexIF::TimeoutType::POLLING) {
+	else if(timeoutType == MutexIF::TimeoutType::POLLING) {
 		timeoutMs = RTEMS_NO_TIMEOUT;
 		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_NO_WAIT, 0);

From 007526c0502d7db92d37dcdc080bf4c08c5f9030 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 7 Jan 2021 19:10:07 +0100
Subject: [PATCH 1377/1774] new f unctions for read error reporting, bugfix

---
 datapool/PoolVariableIF.h            |  1 +
 datapoollocal/LocalDataPoolManager.h | 11 +++++-
 datapoollocal/LocalPoolVariable.h    |  1 +
 datapoollocal/LocalPoolVariable.tpp  | 58 ++++++++++++++++++----------
 4 files changed, 48 insertions(+), 23 deletions(-)

diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 9740fc121..444e19d00 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -25,6 +25,7 @@ class PoolVariableIF : public SerializeIF,
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
 	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
+	static constexpr ReturnValue_t INVALID_POOL_ENTRY = MAKE_RETURN_CODE(0xA1);
 
 	static constexpr bool VALID = 1;
 	static constexpr bool INVALID = 0;
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 0e98b90cb..bcb8f0aff 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -3,6 +3,7 @@
 
 #include "HasLocalDataPoolIF.h"
 
+#include "../serviceinterface/ServiceInterface.h"
 #include "../housekeeping/HousekeepingPacketDownlink.h"
 #include "../housekeeping/HousekeepingMessage.h"
 #include "../housekeeping/PeriodicHousekeepingHelper.h"
@@ -378,6 +379,9 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
 		        "not found." << std::endl;
+#else
+		fsfw::printWarning("HousekeepingManager::fechPoolEntry: Pool entry "
+		        "not found.");
 #endif
 		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
@@ -385,8 +389,11 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "HousekeepingManager::fetchPoolEntry:"
-				" Pool entry not found." << std::endl;
+		sif::warning << "HousekeepingManager::fetchPoolEntry:"
+				" Pool entry type conflict." << std::endl;
+#else
+		fsfw::printWarning("HousekeepingManager::fetchPoolEntry:"
+				" Pool entry type conflict.");
 #endif
 		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index c81967a11..ca0aede94 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -181,6 +181,7 @@ protected:
 #endif
 
 private:
+	void reportReadCommitError(bool read, object_id_t objectId, lp_id_t lpId);
 };
 
 #include "LocalPoolVariable.tpp"
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 9387acc52..c20e92303 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -46,18 +46,17 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK or poolEntry == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolPoolVariable: Read of local pool variable of object "
-				<< std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << " and lp ID 0x" << localPoolId
-				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
-#else
-		fsfw::printError("LocalPoolVariable: Read of local pool variable of "
-				"object 0x%08x and lp ID 0x%08x failed.\n\r",
-				hkManager->getOwner(), localPoolId);
-#endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError(true, ownerObjectId, localPoolId);
 		return result;
 	}
+
+	if(poolEntry->address == nullptr) {
+		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError(true, ownerObjectId, localPoolId);
+		return PoolVariableIF::INVALID_POOL_ENTRY;
+	}
+
 	this->value = *(poolEntry->address);
 	this->valid = poolEntry->valid;
 	return RETURN_OK;
@@ -91,19 +90,12 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	}
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolPoolVariable: Read of local pool variable of "
-				<< "object " << std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << " and lp ID 0x" << localPoolId
-				<< std::dec << " failed." << std::endl;
-#else
-		fsfw::printError("LocalPoolVariable: Read of local pool variable of "
-				"object 0x%08x and lp ID 0x%08x failed.\n\r",
-				hkManager->getOwner(), localPoolId);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+	if(result != RETURN_OK or poolEntry == nullptr) {
+		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError(false, ownerObjectId, localPoolId);
 		return result;
 	}
+
 	*(poolEntry->address) = this->value;
 	poolEntry->valid = this->valid;
 	return RETURN_OK;
@@ -203,4 +195,28 @@ inline bool LocalPoolVariable<T>::operator >(const T &other) const {
 	return not (*this < other);
 }
 
+template<typename T>
+inline void LocalPoolVariable<T>::reportReadCommitError(bool read,
+		object_id_t objectId, lp_id_t lpId) {
+	const char* type = nullptr;
+	if(read) {
+		type = "read";
+	}
+	else {
+		type = "commit";
+	}
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	sif::warning << "PoolPoolVariable: " << type << " of local pool "
+			<<"variable of object " << std::hex << std::setw(8)
+			<< std::setfill('0') << objectId << " and lp ID 0x" << lpId
+			<< std::dec << " failed." << std::endl;
+#else
+	fsfw::printWarning("LocalPoolVariable: %s of local pool variable of "
+			"object 0x%08x and lp ID 0x%08x failed.\n\r",
+			type, objectId, lpId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+}
+
+
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */

From 3be51762cccb8964ab3d19e379f1d427a99710b7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 7 Jan 2021 20:23:23 +0100
Subject: [PATCH 1378/1774] improved error handling significantly

---
 datapoollocal/LocalPoolObjectBase.cpp | 41 +++++++++++++++++++++++++++
 datapoollocal/LocalPoolObjectBase.h   |  2 ++
 datapoollocal/LocalPoolVariable.h     |  3 --
 datapoollocal/LocalPoolVariable.tpp   | 41 +++++++--------------------
 datapoollocal/LocalPoolVector.tpp     | 23 +++++++--------
 5 files changed, 64 insertions(+), 46 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 4b57dede4..b84569b80 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -79,3 +79,44 @@ bool LocalPoolObjectBase::hasChanged() const {
 void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
 	this->readWriteMode = newReadWriteMode;
 }
+
+void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
+		ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId) {
+#if FSFW_DISABLE_PRINTOUT == 0
+	const char* type = nullptr;
+	if(read) {
+		type = "read";
+	}
+	else {
+		type = "commit";
+	}
+
+	const char* errMsg = nullptr;
+	if(error == HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND) {
+		errMsg = "Pool entry not found";
+	}
+	else if(error == HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT) {
+		errMsg = "Pool entry type conflict";
+	}
+	else if(error == PoolVariableIF::INVALID_READ_WRITE_MODE) {
+		errMsg = "Pool variable wrong read-write mode";
+	}
+	else if(error == PoolVariableIF::INVALID_POOL_ENTRY) {
+		errMsg = "Pool entry invalid";
+	}
+	else {
+		errMsg = "Unknown error code";
+	}
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	sif::warning << variableType << ": " << type << " call | " << errMsg
+			<< " | Owner: " << std::hex << std::setw(8)
+			<< std::setfill('0') << objectId << " LPID: 0x" << lpId
+			<< std::dec << std::endl;
+#else
+	fsfw::printWarning("LocalPoolVariable: %s of local pool variable of "
+			"object 0x%08x and lp ID 0x%08x failed.\n\r",
+			type, objectId, lpId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
+}
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 7165fc242..25ca594d9 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -56,6 +56,8 @@ protected:
     //! @brief  Pointer to the class which manages the HK pool.
     LocalDataPoolManager* hkManager;
 
+	void reportReadCommitError(const char* variableType,
+			ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId);
 };
 
 
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index ca0aede94..22019c2f5 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -179,9 +179,6 @@ protected:
 	friend std::ostream& operator<< (std::ostream &out,
 			const LocalPoolVariable<U> &var);
 #endif
-
-private:
-	void reportReadCommitError(bool read, object_id_t objectId, lp_id_t lpId);
 };
 
 #include "LocalPoolVariable.tpp"
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index c20e92303..4d472c31b 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -45,16 +45,20 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK or poolEntry == nullptr) {
+	if(result != RETURN_OK) {
 		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError(true, ownerObjectId, localPoolId);
+		reportReadCommitError("LocalPoolVariable", result,
+				false, ownerObjectId, localPoolId);
 		return result;
 	}
 
+	// Actually this should never happen..
 	if(poolEntry->address == nullptr) {
+		result = PoolVariableIF::INVALID_POOL_ENTRY;
 		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError(true, ownerObjectId, localPoolId);
-		return PoolVariableIF::INVALID_POOL_ENTRY;
+		reportReadCommitError("LocalPoolVariable", result,
+				false, ownerObjectId, localPoolId);
+		return result;
 	}
 
 	this->value = *(poolEntry->address);
@@ -90,9 +94,10 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	}
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK or poolEntry == nullptr) {
+	if(result != RETURN_OK) {
 		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError(false, ownerObjectId, localPoolId);
+		reportReadCommitError("LocalPoolVariable", result,
+				false, ownerObjectId, localPoolId);
 		return result;
 	}
 
@@ -195,28 +200,4 @@ inline bool LocalPoolVariable<T>::operator >(const T &other) const {
 	return not (*this < other);
 }
 
-template<typename T>
-inline void LocalPoolVariable<T>::reportReadCommitError(bool read,
-		object_id_t objectId, lp_id_t lpId) {
-	const char* type = nullptr;
-	if(read) {
-		type = "read";
-	}
-	else {
-		type = "commit";
-	}
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << "PoolPoolVariable: " << type << " of local pool "
-			<<"variable of object " << std::hex << std::setw(8)
-			<< std::setfill('0') << objectId << " and lp ID 0x" << lpId
-			<< std::dec << " failed." << std::endl;
-#else
-	fsfw::printWarning("LocalPoolVariable: %s of local pool variable of "
-			"object 0x%08x and lp ID 0x%08x failed.\n\r",
-			type, objectId, lpId);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-}
-
-
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 6af80de66..99e37a877 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -44,12 +44,9 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	memset(this->value, 0, vectorSize * sizeof(T));
 
 	if(result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "LocalPoolVector: Read of local pool variable of object "
-				<< std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << "and lp ID 0x" << localPoolId
-				<< std::dec << " failed." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+				localPoolId);
 		return result;
 	}
 	std::memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
@@ -69,19 +66,19 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalPoolVector: Invalid read write "
-				"mode for commit() call." << std::endl;
+				"mode for commit call." << std::endl;
+#else
+		sif::warning << "LocalPoolVector: Invalid read write "
+				"mode for commit call." << std::endl;
 #endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "LocalPoolVector: Read of local pool variable of object "
-				<< std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << " and lp ID " << localPoolId
-				<< std::dec << " failed." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+				localPoolId);
 		return result;
 	}
 	std::memcpy(poolEntry->address, this->value, poolEntry->getByteSize());

From 44a5430555766db0d6bae8a1dca7221c122c80a9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 7 Jan 2021 20:28:03 +0100
Subject: [PATCH 1379/1774] pool vector improvements

---
 datapoollocal/LocalPoolVector.tpp | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 99e37a877..88ba084ab 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -32,10 +32,10 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolVector: Invalid read write "
-				"mode for read() call." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
@@ -64,20 +64,17 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolVector: Invalid read write "
-				"mode for commit call." << std::endl;
-#else
-		sif::warning << "LocalPoolVector: Invalid read write "
-				"mode for commit call." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
 		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+		reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
 				localPoolId);
 		return result;
 	}

From d3fbe4a3b96184b1f1620041fd7f433cf902b56e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 7 Jan 2021 20:29:38 +0100
Subject: [PATCH 1380/1774] local pool variable error handling improved

---
 datapoollocal/LocalPoolVariable.tpp | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 4d472c31b..3cf0fc844 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -33,13 +33,10 @@ inline ReturnValue_t LocalPoolVariable<T>::read(
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolVariable: Invalid read write "
-				"mode for read call." << std::endl;
-#else
-		fsfw::printWarning("LocalPoolVariable: Invalid read write "
-				"mode for read call.\n\r");
-#endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
@@ -83,13 +80,10 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolVariable: Invalid read write "
-				 "mode for commit call." << std::endl;
-#else
-		fsfw::printWarning("LocalPoolVariable: Invalid read write "
-				 "mode for commit call.\n\r");
-#endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;

From d3405ee34063eca17a529dcf521ff860d91e5b50 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 7 Jan 2021 20:30:52 +0100
Subject: [PATCH 1381/1774] whitespace

---
 datapoollocal/LocalPoolVariable.tpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 3cf0fc844..d9d45d38d 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -86,6 +86,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
+
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {

From c1c331e29ef4501d923830cc38a3179d7d7b6332 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 00:10:10 +0100
Subject: [PATCH 1382/1774] fixed vector test

---
 datapool/PoolEntry.cpp                        | 14 +++---------
 datapool/PoolEntry.h                          |  8 +++----
 datapoollocal/LocalPoolVector.h               |  8 +++++++
 datapoollocal/LocalPoolVector.tpp             |  7 ++++++
 osal/host/Mutex.h                             |  1 -
 unittest/tests/datapoollocal/CMakeLists.txt   |  1 +
 .../datapoollocal/LocalPoolVectorTest.cpp     | 22 +++++++++++++++++++
 7 files changed, 45 insertions(+), 16 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 5f5f56f25..d21cf2ec4 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -6,27 +6,19 @@
 #include <algorithm>
 
 template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
-		bool setValid ) : length(setLength), valid(setValid) {
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, bool setValid ):
+		length(initValue.size()), valid(setValid) {
 	this->address = new T[this->length];
 	if(initValue.size() == 0) {
 		std::memset(this->address, 0, this->getByteSize());
 	}
-	else if (initValue.size() != setLength){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "PoolEntry: setLength is not equal to initializer list"
-				"length! Performing zero initialization with given setLength"
-				<< std::endl;
-#endif
-		std::memset(this->address, 0, this->getByteSize());
-	}
 	else {
 		std::copy(initValue.begin(), initValue.end(), this->address);
 	}
 }
 
 template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t setLength, bool setValid ) :
+PoolEntry<T>::PoolEntry(T* initValue, uint8_t setLength, bool setValid):
 		length(setLength), valid(setValid) {
 	this->address = new T[this->length];
 	if (initValue != nullptr) {
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 033db40d0..83f7fc502 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -43,16 +43,16 @@ public:
 	 * corresponding length should be passed too, otherwise a zero
 	 * initialization will be performed with the given setLength.
 	 * @param initValue
-	 * Initializer list with values to initialize with, for example {0,0} to
-	 * initialize the two entries to zero.
+	 * Initializer list with values to initialize with, for example {0, 0} to
+	 * initialize the a pool entry of a vector with two entries to 0.
 	 * @param setLength
 	 * Defines the array length of this entry. Should be equal to the
 	 * intializer list length.
 	 * @param setValid
 	 * Sets the initialization flag. It is invalid by default.
 	 */
-	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
-			bool setValid = false);
+	PoolEntry(std::initializer_list<T> initValue = {0}, bool setValid = false);
+
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
 	 * 			potential init values are copied to that space.
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 773a52cc7..ce3b1a145 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -139,6 +139,14 @@ public:
 			MutexIF::TimeoutType::WAITING,
 			uint32_t timeoutMs = 20) override;
 
+	/**
+	 * @brief	This commit call also sets the validity of the pool entry.
+	 * @details
+	 */
+	ReturnValue_t commit(bool valid, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
+
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 88ba084ab..ce68982b3 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -54,6 +54,13 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	return RETURN_OK;
 }
 
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	this->setValid(valid);
+	return commit(timeoutType, timeoutMs);
+}
+
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index c0fa19b78..0bd93c8ac 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -22,7 +22,6 @@ public:
 
 	std::timed_mutex* getMutexHandle();
 private:
-	//bool locked = false;
 	std::timed_mutex mutex;
 };
 
diff --git a/unittest/tests/datapoollocal/CMakeLists.txt b/unittest/tests/datapoollocal/CMakeLists.txt
index 569a8d5f4..9d828de58 100644
--- a/unittest/tests/datapoollocal/CMakeLists.txt
+++ b/unittest/tests/datapoollocal/CMakeLists.txt
@@ -1,3 +1,4 @@
 target_sources(${TARGET_NAME} PRIVATE
 	LocalPoolVariableTest.cpp
+	LocalPoolVectorTest.cpp
 )
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
index c86a26818..188011dfe 100644
--- a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -11,6 +11,28 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
 	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
 			== retval::CATCH_OK);
+
+	SECTION("BasicTest") {
+		// very basic test.
+		lp_vec_t<uint16_t, 3> testVector = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+		CHECK(testVector.read() == retval::CATCH_OK);
+		testVector.value[0] = 5;
+		testVector.value[1] = 232;
+		testVector.value[2] = 32023;
+
+		REQUIRE(testVector.commit(true) == retval::CATCH_OK);
+		CHECK(testVector.isValid());
+
+		testVector.value[0] = 0;
+		testVector.value[1] = 0;
+		testVector.value[2] = 0;
+
+		CHECK(testVector.read() == retval::CATCH_OK);
+		CHECK(testVector.value[0] == 5);
+		CHECK(testVector.value[1] == 232);
+		CHECK(testVector.value[2] == 32023);
+	}
 }
 
 

From 8e3f4c81a5d0db9709052012e71824ca019938b9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 00:20:39 +0100
Subject: [PATCH 1383/1774] pool entry doc correction

---
 datapool/PoolEntry.h | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 83f7fc502..d3d4cd6dd 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -35,19 +35,17 @@ public:
 				"uint8_t");
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
-	 * 			potential init values are copied to that space.
+	 * 			potential initialization values are copied to that space.
 	 * @details
 	 * Not passing any arguments will initialize an non-array pool entry
-	 * (setLength = 1) with an initial invalid state.
-	 * Please note that if an initializer list is passed, the correct
-	 * corresponding length should be passed too, otherwise a zero
-	 * initialization will be performed with the given setLength.
+	 * with an initial invalid state and the value 0.
+	 * Please note that if an initializer list is passed, the length of the
+	 * initializer list needs to be correct for vector entries because
+	 * required allocated space will be deduced from the initializer list length
+	 * and the pool entry type.
 	 * @param initValue
 	 * Initializer list with values to initialize with, for example {0, 0} to
 	 * initialize the a pool entry of a vector with two entries to 0.
-	 * @param setLength
-	 * Defines the array length of this entry. Should be equal to the
-	 * intializer list length.
 	 * @param setValid
 	 * Sets the initialization flag. It is invalid by default.
 	 */

From 41d8cbda5597c61aac6c965cc14f4fe571fe3263 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 00:22:04 +0100
Subject: [PATCH 1384/1774] small form changes

---
 datapool/PoolEntry.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index d3d4cd6dd..aecfce94f 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -64,9 +64,9 @@ public:
 	 */
 	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
 
-	//! Explicitely deleted copy ctor, copying is not allowed!
+	//! Explicitely deleted copy ctor, copying is not allowed.
 	PoolEntry(const PoolEntry&) = delete;
-	//! Explicitely deleted copy assignment, copying is not allowed!
+	//! Explicitely deleted copy assignment, copying is not allowed.
 	PoolEntry& operator=(const PoolEntry&) = delete;
 
 	/**

From 4255176b5c499d3be11947f8b77d9bbcc21bb12c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 01:49:00 +0100
Subject: [PATCH 1385/1774] more tests, minor bugfix

---
 datapoollocal/LocalPoolVector.h               |  5 +--
 datapoollocal/LocalPoolVector.tpp             | 18 ++++++----
 .../datapoollocal/LocalPoolVectorTest.cpp     | 34 ++++++++++++++++++-
 3 files changed, 48 insertions(+), 9 deletions(-)

diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index ce3b1a145..a28fe327a 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -100,8 +100,8 @@ public:
 		return vectorSize;
 	}
 
-	T& operator [](int i);
-	const T &operator [](int i) const;
+	T& operator [](size_t i);
+	const T &operator [](size_t i) const;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t maxSize,
@@ -126,6 +126,7 @@ public:
 	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
 			MutexIF::TimeoutType::WAITING,
 			uint32_t timeoutMs = 20) override;
+
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index ce68982b3..6612a4917 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -91,8 +91,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 }
 
 template<typename T, uint16_t vectorSize>
-inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
-	if(i <= vectorSize) {
+inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
+	if(i < vectorSize) {
 		return value[i];
 	}
 	// If this happens, I have to set some value. I consider this
@@ -100,13 +100,16 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
+#else
+	fsfw::printError("LocalPoolVector: Invalid index. Setting or returning"
+			" last value!\n\r");
 #endif
-	return value[i];
+	return value[vectorSize];
 }
 
 template<typename T, uint16_t vectorSize>
-inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
-	if(i <= vectorSize) {
+inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
+	if(i < vectorSize) {
 		return value[i];
 	}
 	// If this happens, I have to set some value. I consider this
@@ -114,8 +117,11 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
+#else
+	fsfw::printError("LocalPoolVector: Invalid index. Setting or returning"
+			" last value!\n\r");
 #endif
-	return value[i];
+	return value[vectorSize];
 }
 
 template<typename T, uint16_t vectorSize>
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
index 188011dfe..7e40e898c 100644
--- a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -16,7 +16,7 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 		// very basic test.
 		lp_vec_t<uint16_t, 3> testVector = lp_vec_t<uint16_t, 3>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
-		CHECK(testVector.read() == retval::CATCH_OK);
+		REQUIRE(testVector.read() == retval::CATCH_OK);
 		testVector.value[0] = 5;
 		testVector.value[1] = 232;
 		testVector.value[2] = 32023;
@@ -32,6 +32,38 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 		CHECK(testVector.value[0] == 5);
 		CHECK(testVector.value[1] == 232);
 		CHECK(testVector.value[2] == 32023);
+
+		CHECK(testVector[0] == 5);
+
+		// This is invalid access, so the last value will be set instead.
+		// (we can't throw exceptions)
+		testVector[4] = 12;
+		CHECK(testVector[3] == 12);
+		CHECK(testVector.commit() == retval::CATCH_OK);
+
+		// Use read-only reference.
+		const lp_vec_t<uint16_t, 3>& roTestVec = testVector;
+		uint16_t valueOne = roTestVec[0];
+		CHECK(valueOne == 5);
+
+		uint16_t lastVal = roTestVec[25];
+		CHECK(lastVal == 12);
+	}
+
+	SECTION("ErrorHandling") {
+		// not try to use a local pool variable which does not exist
+		lp_vec_t<uint16_t, 3> invalidVector = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+		REQUIRE(invalidVector.read() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+		REQUIRE(invalidVector.commit() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+
+		// now try to access with wrong type
+		lp_vec_t<uint32_t, 3> invalidVector2 = lp_vec_t<uint32_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+		REQUIRE(invalidVector2.read() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
 	}
 }
 

From 2ef3e0aa7b502b5ac1d40057a4fdc9b324af9fcb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 02:06:27 +0100
Subject: [PATCH 1386/1774] added option to add CR for printf support

---
 datapoollocal/LocalDataPoolManager.h         |  8 ++++----
 datapoollocal/LocalPoolObjectBase.cpp        | 11 +++++------
 datapoollocal/LocalPoolVector.tpp            | 12 ++++++------
 serviceinterface/ServiceInterfacePrinter.cpp | 10 +++++++++-
 serviceinterface/ServiceInterfacePrinter.h   |  2 ++
 5 files changed, 26 insertions(+), 17 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index bcb8f0aff..7fa480cb4 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -377,11 +377,11 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
+		sif::warning << "HousekeepingManager::fetchPoolEntry: Pool entry "
 		        "not found." << std::endl;
 #else
-		fsfw::printWarning("HousekeepingManager::fechPoolEntry: Pool entry "
-		        "not found.");
+		fsfw::printWarning("HousekeepingManager::fetchPoolEntry: Pool entry "
+		        "not found.\n");
 #endif
 		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
@@ -393,7 +393,7 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 				" Pool entry type conflict." << std::endl;
 #else
 		fsfw::printWarning("HousekeepingManager::fetchPoolEntry:"
-				" Pool entry type conflict.");
+				" Pool entry type conflict.\n");
 #endif
 		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index b84569b80..bb7822dad 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -110,13 +110,12 @@ void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << variableType << ": " << type << " call | " << errMsg
-			<< " | Owner: " << std::hex << std::setw(8)
-			<< std::setfill('0') << objectId << " LPID: 0x" << lpId
-			<< std::dec << std::endl;
+			<< " | Owner: 0x" << std::hex << std::setw(8)
+			<< std::setfill('0') << objectId << std::dec << " LPID: " << lpId
+			<< std::endl;
 #else
-	fsfw::printWarning("LocalPoolVariable: %s of local pool variable of "
-			"object 0x%08x and lp ID 0x%08x failed.\n\r",
-			type, objectId, lpId);
+	fsfw::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
+			variableType, type, errMsg, objectId, lpId);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_DISABLE_PRINTOUT == 0 */
 }
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 6612a4917..94f3916e2 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -98,11 +98,11 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
 #else
-	fsfw::printError("LocalPoolVector: Invalid index. Setting or returning"
-			" last value!\n\r");
+	fsfw::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+			" last value!\n");
 #endif
 	return value[vectorSize];
 }
@@ -115,11 +115,11 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
 #else
-	fsfw::printError("LocalPoolVector: Invalid index. Setting or returning"
-			" last value!\n\r");
+	fsfw::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+			" last value!\n");
 #endif
 	return value[vectorSize];
 }
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index 15e738a80..cb3a958d7 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -10,7 +10,7 @@ fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
 bool consoleInitialized = false;
 #endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
-
+bool addCrAtEnd = false;
 
 #if FSFW_DISABLE_PRINTOUT == 0
 uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
@@ -80,6 +80,10 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 
     len += vsnprintf(bufferPosition + len, sizeof(printBuffer) - len, fmt, arg);
 
+    if(addCrAtEnd) {
+    	len += sprintf(bufferPosition + len, "\r");
+    }
+
     printf("%s", printBuffer);
 }
 
@@ -105,6 +109,10 @@ void fsfw::printDebug(const char *fmt, ...) {
     va_end(args);
 }
 
+void fsfw::setToAddCrAtEnd(bool addCrAtEnd_) {
+	addCrAtEnd = addCrAtEnd_;
+}
+
 void fsfw::printError(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index a60b6332f..1f82ba982 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -16,6 +16,8 @@ enum class PrintLevel {
 void setPrintLevel(PrintLevel printLevel);
 PrintLevel getPrintLevel();
 
+void setToAddCrAtEnd(bool addCrAtEnd_);
+
 /**
  * These functions can be used like the C stdio printf and forward the
  * supplied formatted string arguments to a printf function.

From 3b39c6b6e26fd523b732b14bf00c4c5933cf0ea3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 02:07:37 +0100
Subject: [PATCH 1387/1774] defaultcfg update

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 261e3d6d2..e251729cd 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -9,8 +9,7 @@
 //! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! More FSFW related printouts.
-//! Be careful, this also turns off most diagnostic prinouts!
+//! More FSFW related printouts. Useful for development.
 #define FSFW_ENHANCED_PRINTOUT		0
 
 //! Can be used to completely disable printouts, even the C stdio ones.

From 5a8647d36701b9eda4d6b6a29f2d83dd9b5eeeab Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 13:40:13 +0100
Subject: [PATCH 1388/1774] better returnvalues etc.

---
 datapool/PoolEntry.cpp                 | 26 +++++++++++++------
 datapool/PoolEntry.h                   | 35 ++++++++++++++++----------
 datapoollocal/LocalDataPoolManager.cpp |  6 ++---
 datapoollocal/LocalDataPoolManager.h   | 10 +++++---
 datapoollocal/LocalPoolVariable.tpp    | 22 ++++++++--------
 datapoollocal/LocalPoolVector.tpp      |  8 +++---
 globalfunctions/arrayprinter.cpp       | 10 +++++++-
 7 files changed, 74 insertions(+), 43 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index d21cf2ec4..1e99a28c4 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,6 +1,6 @@
 #include "PoolEntry.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../globalfunctions/arrayprinter.h"
 #include <cstring>
 #include <algorithm>
@@ -62,14 +62,26 @@ bool PoolEntry<T>::getValid() {
 
 template <typename T>
 void PoolEntry<T>::print() {
+	const char* validString = nullptr;
+	if(valid) {
+		validString = "Valid";
+	}
+	else {
+		validString = "Invalid";
+	}
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	 sif::debug << "Pool Entry Validity: " <<
-			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
-#endif
-	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::debug << std::dec << std::endl;
+	 sif::info << "PoolEntry information." << std::endl;
+	 sif::info << "PoolEntry validity: " << validString << std::endl;
+#else
+	 fsfw::printInfo("PoolEntry information.\n");
+	 fsfw::printInfo("PoolEntry validity: %s\n", validString);
 #endif
+	arrayprinter::print(reinterpret_cast<uint8_t*>(address), getByteSize());
+}
+
+template<typename T>
+inline T* PoolEntry<T>::getDataPtr() {
+	return this->address;
 }
 
 template<typename T>
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index aecfce94f..30940320c 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -80,21 +80,16 @@ public:
 	~PoolEntry();
 
 	/**
-	 * @brief	This is the address pointing to the allocated memory.
+	 * Return typed pointer to start of data.
+	 * @return
 	 */
-	T* address;
-	/**
-	 * @brief	This attribute stores the length information.
-	 */
-	uint8_t length;
-	/**
-	 * @brief	Here, the validity information for a variable is stored.
-	 * 			Every entry (single variable or vector) has one valid flag.
-	 */
-	uint8_t valid;
+	T* getDataPtr();
+
 	/**
 	 * @brief	getSize returns the array size of the entry.
-	 * @details	A single parameter has size 1.
+	 * @details
+	 * For non-array pool entries return type size, for vector entries
+	 * return type size times the number of entries.
 	 */
 	uint8_t getSize();
 	/**
@@ -121,8 +116,22 @@ public:
 	 * 			information to the screen. It prints all array entries in a row.
 	 */
 	void print();
-
 	Type getType();
+
+private:
+	/**
+	 * @brief	This attribute stores the length information.
+	 */
+	uint8_t length;
+	/**
+	 * @brief	Here, the validity information for a variable is stored.
+	 * 			Every entry (single variable or vector) has one valid flag.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	This is the address pointing to the allocated memory.
+	 */
+	T* address;
 };
 
 #endif /* FSFW_DATAPOOL_POOLENTRY_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 24516aad5..db5cd5dd9 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -213,7 +213,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
+            return POOLOBJECT_NOT_FOUND;
         }
 
         if (not poolObj->hasChanged()) {
@@ -249,7 +249,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
+            return DATASET_NOT_FOUND;
         }
 
         if(not dataSet->hasChanged()) {
@@ -618,7 +618,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
                 << " Set ID not found or dataset not assigned!" << std::endl;
 #endif
-        return HasReturnvaluesIF::RETURN_FAILED;
+        return DATASET_NOT_FOUND;
     }
 
     store_address_t storeId;
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 7fa480cb4..098158da7 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -56,11 +56,13 @@ class LocalDataPoolManager {
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x0);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0);
 
-    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x01);
-    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x02);
-    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x03);
+    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(1);
+    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(2);
+    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(3);
+    static constexpr ReturnValue_t POOLOBJECT_NOT_FOUND = MAKE_RETURN_CODE(4);
+    static constexpr ReturnValue_t DATASET_NOT_FOUND = MAKE_RETURN_CODE(5);
 
     /**
      * This constructor is used by a class which wants to implement
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index d9d45d38d..ef94b6207 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -50,16 +50,16 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	}
 
 	// Actually this should never happen..
-	if(poolEntry->address == nullptr) {
-		result = PoolVariableIF::INVALID_POOL_ENTRY;
-		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVariable", result,
-				false, ownerObjectId, localPoolId);
-		return result;
-	}
+//	if(poolEntry->address == nullptr) {
+//		result = PoolVariableIF::INVALID_POOL_ENTRY;
+//		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+//		reportReadCommitError("LocalPoolVariable", result,
+//				false, ownerObjectId, localPoolId);
+//		return result;
+//	}
 
-	this->value = *(poolEntry->address);
-	this->valid = poolEntry->valid;
+	this->value = *(poolEntry->getDataPtr());
+	this->valid = poolEntry->getValid();
 	return RETURN_OK;
 }
 
@@ -96,8 +96,8 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 		return result;
 	}
 
-	*(poolEntry->address) = this->value;
-	poolEntry->valid = this->valid;
+	*(poolEntry->getDataPtr()) = this->value;
+	poolEntry->setValid(this->valid);
 	return RETURN_OK;
 }
 
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 94f3916e2..a0e32f624 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -49,8 +49,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 				localPoolId);
 		return result;
 	}
-	std::memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
-	this->valid = poolEntry->valid;
+	std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+	this->valid = poolEntry->getValid();
 	return RETURN_OK;
 }
 
@@ -85,8 +85,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 				localPoolId);
 		return result;
 	}
-	std::memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
-	poolEntry->valid = this->valid;
+	std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+	poolEntry->setValid(this->valid);
 	return RETURN_OK;
 }
 
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index c273b250f..ebf21bb86 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -1,5 +1,5 @@
 #include "arrayprinter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include <bitset>
 
 void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
@@ -9,6 +9,8 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 		sif::info << "Printing data with size " << size << ": ";
 	}
 	sif::info << "[";
+#else
+	fsfw::printInfo("Printing data with size %zu: [", size);
 #endif
 	if(type == OutputType::HEX) {
 		arrayprinter::printHex(data, size, maxCharPerLine);
@@ -37,6 +39,8 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 	}
 	sif::info << std::dec;
 	sif::info << "]" << std::endl;
+#else
+	// how much memory to reserve for printout?
 #endif
 }
 
@@ -54,6 +58,8 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
 		}
 	}
 	sif::info << "]" << std::endl;
+#else
+	// how much memory to reserve for printout?
 #endif
 }
 
@@ -65,5 +71,7 @@ void arrayprinter::printBin(const uint8_t *data, size_t size) {
                 std::bitset<8>(data[i]) << ",\n" << std::flush;
     }
     sif::info << "]" << std::endl;
+#else
+    // how much memory to reserve for printout?
 #endif
 }

From f2ecd6d740763e55e682c5892b8ad3b0df74e627 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 15:10:33 +0100
Subject: [PATCH 1389/1774] revamed and imroved error handling

---
 datapoollocal/LocalDataPoolManager.cpp | 187 ++++++++++++++++---------
 datapoollocal/LocalDataPoolManager.h   |  11 +-
 2 files changed, 131 insertions(+), 67 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index db5cd5dd9..e5ee499cd 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -3,6 +3,7 @@
 #include "LocalPoolDataSetBase.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
 
@@ -21,19 +22,17 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
                         appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                << "Invalid supplied owner!" << std::endl;
-#endif
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
+				"Invalid supplied owner");
         return;
     }
     this->owner = owner;
     mutex = MutexFactory::instance()->createMutex();
     if(mutex == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                << "Could not create mutex." << std::endl;
-#endif
+    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
+				"Could not create mutex");
     }
 
     hkQueue = queueToUse;
@@ -43,21 +42,18 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::initialize: "
-                << std::hex << "0x" << owner->getObjectId() << ". Supplied "
-                << "queue invalid!" << std::dec << std::endl;
-#endif
+        // error, all destinations invalid
+    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    			"initialize", QUEUE_OR_DESTINATION_INVALID);
     }
     hkQueue = queueToUse;
 
     ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
     if(ipcStore == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::initialize: "
-                << std::hex << "0x" << owner->getObjectId() << ": Could not "
-                << "set IPC store." <<std::dec << std::endl;
-#endif
+        // error, all destinations invalid
+    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    			"initialize", HasReturnvaluesIF::RETURN_FAILED,
+				"Could not set IPC store.");
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
@@ -69,11 +65,9 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
             hkDestinationId = hkPacketReceiver->getHkQueue();
         }
         else {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                    << "Default HK destination object is invalid!" << std::endl;
-#endif
-            return HasReturnvaluesIF::RETURN_FAILED;
+        	printWarningOrError(ErrorTypes::ERROR_TYPE,
+        			"initialize", QUEUE_OR_DESTINATION_INVALID);
+            return QUEUE_OR_DESTINATION_INVALID;
         }
     }
 
@@ -95,10 +89,10 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
         }
         return result;
     }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "HousekeepingManager: The map should only be initialized "
-            << "once!" << std::endl;
-#endif
+
+	printWarningOrError(ErrorTypes::WARNING_TYPE,
+			"initialize", HasReturnvaluesIF::RETURN_FAILED,
+			"The map should only be initialized once");
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -163,7 +157,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
+        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        			"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
+            return POOLOBJECT_NOT_FOUND;
         }
         if(poolObj->hasChanged()) {
             // prepare and send update notification.
@@ -183,7 +179,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
+        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        			"handleNotificationUpdate", DATASET_NOT_FOUND);
+            return DATASET_NOT_FOUND;
         }
         if(dataSet->hasChanged()) {
             // prepare and send update notification
@@ -213,6 +211,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
+        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        			"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
             return POOLOBJECT_NOT_FOUND;
         }
 
@@ -249,6 +249,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
+        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        			"handleNotificationSnapshot", DATASET_NOT_FOUND);
             return DATASET_NOT_FOUND;
         }
 
@@ -351,11 +353,9 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-                << " Invalid receiver!"<< std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_OK;
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
+        return QUEUE_OR_DESTINATION_INVALID;
     }
 
     struct HkReceiver hkReceiver;
@@ -383,11 +383,9 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-                << " Invalid receiver!"<< std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_OK;
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
+        return QUEUE_OR_DESTINATION_INVALID;
     }
 
     struct HkReceiver hkReceiver;
@@ -591,10 +589,8 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
         lp_id_t localPoolId) {
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "HousekeepingManager::fechPoolEntry:"
-                << " Pool entry not found." << std::endl;
-#endif
+    	printWarningOrError(ErrorTypes::WARNING_TYPE, "printPoolEntry",
+    			 HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
         return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
     poolIter->second->print();
@@ -614,10 +610,9 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t destination) {
     if(dataSet == nullptr) {
         // Configuration error.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                << " Set ID not found or dataset not assigned!" << std::endl;
-#endif
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"generateHousekeepingPacket",
+    			DATASET_NOT_FOUND);
         return DATASET_NOT_FOUND;
     }
 
@@ -640,12 +635,18 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
     }
 
     if(hkQueue == nullptr) {
-        return QUEUE_OR_DESTINATION_NOT_SET;
+        // error, all destinations invalid
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"generateHousekeepingPacket",
+    			QUEUE_OR_DESTINATION_INVALID);
+        return QUEUE_OR_DESTINATION_INVALID;
     }
     if(destination == MessageQueueIF::NO_QUEUE) {
         if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
             // error, all destinations invalid
-            return HasReturnvaluesIF::RETURN_FAILED;
+        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        			"generateHousekeepingPacket",
+        			QUEUE_OR_DESTINATION_INVALID);
         }
         destination = hkDestinationId;
     }
@@ -681,6 +682,13 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
     sid_t sid = receiver.dataId.sid;
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(dataSet == nullptr) {
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"performPeriodicHkGeneration",
+    			DATASET_NOT_FOUND);
+    	return;
+    }
+
     if(not dataSet->getReportingEnabled()) {
         return;
     }
@@ -699,10 +707,11 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
     if(result != HasReturnvaluesIF::RETURN_OK) {
         // configuration error
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "LocalDataPoolManager::performHkOperation:"
-                << "0x" << std::hex << std::setfill('0') << std::setw(8)
-                << owner->getObjectId() << " Error generating "
-                << "HK packet" << std::setfill(' ') << std::dec << std::endl;
+        sif::warning << "LocalDataPoolManager::performHkOperation: "
+                << "HK generation failed." << std::endl;
+#else
+        fsfw::printWarning("LocalDataPoolManager::performHkOperation: "
+        		"HK generation failed.\n");
 #endif
     }
 }
@@ -748,11 +757,10 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     // Get and check dataset first.
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                << " Set ID not found" << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"performPeriodicHkGeneration",
+    			DATASET_NOT_FOUND);
+        return DATASET_NOT_FOUND;
     }
 
 
@@ -776,10 +784,9 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
             expectedSize,&storePtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                << "Could not get free element from IPC store." << std::endl;
-#endif
+    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
+				"Could not get free element from IPC store.");
         return result;
     }
 
@@ -788,10 +795,9 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     result = setPacket.serialize(&storePtr, &size, expectedSize,
             SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "HousekeepingManager::generateSetStructurePacket: "
-                << "Expected size is not equal to serialized size" << std::endl;
-#endif
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
+				"Expected size is not equal to serialized size");
     }
 
     // Send structure reporting reply.
@@ -808,3 +814,52 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     hkQueue->reply(&reply);
     return result;
 }
+
+void LocalDataPoolManager::printWarningOrError(ErrorTypes errorType,
+		const char* functionName, ReturnValue_t error, const char* errorPrint) {
+	if(errorPrint == nullptr) {
+		if(error == DATASET_NOT_FOUND) {
+			errorPrint = "Dataset not found";
+		}
+		else if(error == POOLOBJECT_NOT_FOUND) {
+			errorPrint = "Pool Object not found";
+		}
+		else if(error == HasReturnvaluesIF::RETURN_FAILED) {
+			if(errorType == ErrorTypes::WARNING_TYPE) {
+				errorPrint = "Generic Warning";
+			}
+			else {
+				errorPrint = "Generic error";
+			}
+		}
+		else if(error == QUEUE_OR_DESTINATION_INVALID) {
+			errorPrint = "Queue or destination not set";
+		}
+		else {
+			errorPrint = "Unknown error";
+		}
+	}
+
+	if(errorType == ErrorTypes::WARNING_TYPE) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::warning << "LocalDataPoolManager::" << functionName
+				<< ": Object ID " << std::setw(8) << std::setfill('0')
+				<< std::hex << owner->getObjectId() << " | " << errorPrint
+				<< std::dec << std::setfill(' ') << std::endl;
+#else
+		fsfw::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
+				owner->getObjectId(), errorPrint);
+#endif
+	}
+	else if(errorType == ErrorTypes::ERROR_TYPE) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::error << "LocalDataPoolManager::" << functionName
+				<< ": Object ID " << std::setw(8) << std::setfill('0')
+				<< std::hex << owner->getObjectId() << " | " << errorPrint
+				<< std::dec << std::setfill(' ') << std::endl;
+#else
+		fsfw::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
+				owner->getObjectId(), errorPrint);
+#endif
+	}
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 098158da7..6502294ef 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -56,7 +56,7 @@ class LocalDataPoolManager {
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_INVALID = MAKE_RETURN_CODE(0);
 
     static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(1);
     static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(2);
@@ -370,6 +370,15 @@ private:
             ReturnValue_t& status);
 	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
 	        store_address_t& storeId);
+
+	enum class ErrorTypes {
+		WARNING_TYPE,
+		ERROR_TYPE
+	};
+
+	void printWarningOrError(ErrorTypes errorType, const char* functionName,
+			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+			const char* errorPrint = nullptr);
 };
 
 

From 541478e4d5f4ad029dd4fd968e10ccc6cc72068d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 15:15:02 +0100
Subject: [PATCH 1390/1774] another small improvement

---
 datapoollocal/LocalDataPoolManager.cpp |  8 ++++++--
 datapoollocal/LocalDataPoolManager.h   | 18 ++++--------------
 2 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index e5ee499cd..d1ab553d8 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -3,10 +3,8 @@
 #include "LocalPoolDataSetBase.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
-#include "../serviceinterface/ServiceInterface.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
-
 #include "../timemanager/CCSDSTime.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
@@ -835,6 +833,12 @@ void LocalDataPoolManager::printWarningOrError(ErrorTypes errorType,
 		else if(error == QUEUE_OR_DESTINATION_INVALID) {
 			errorPrint = "Queue or destination not set";
 		}
+		else if(error == HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT) {
+			errorPrint = "Pool entry type conflict";
+		}
+		else if(error == HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND) {
+			errorPrint = "Pool entry not found";
+		}
 		else {
 			errorPrint = "Unknown error";
 		}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 6502294ef..730e03e4a 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -387,25 +387,15 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "HousekeepingManager::fetchPoolEntry: Pool entry "
-		        "not found." << std::endl;
-#else
-		fsfw::printWarning("HousekeepingManager::fetchPoolEntry: Pool entry "
-		        "not found.\n");
-#endif
+    	printWarningOrError(ErrorTypes::ERROR_TYPE, "fetchPoolEntry",
+				HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
 		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "HousekeepingManager::fetchPoolEntry:"
-				" Pool entry type conflict." << std::endl;
-#else
-		fsfw::printWarning("HousekeepingManager::fetchPoolEntry:"
-				" Pool entry type conflict.\n");
-#endif
+    	printWarningOrError(ErrorTypes::ERROR_TYPE, "fetchPoolEntry",
+    			HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT);
 		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;

From c0fd981360dbb7d16018e9803a2a9a0f97de32f9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 16:14:11 +0100
Subject: [PATCH 1391/1774] improved DHB error handling

---
 datapoollocal/LocalDataPoolManager.cpp        |  48 +++---
 datapoollocal/LocalDataPoolManager.h          |  12 +-
 devicehandlers/DeviceHandlerBase.cpp          | 143 ++++++++++++------
 devicehandlers/DeviceHandlerBase.h            |  20 ++-
 serviceinterface/ServiceInterface.h           |   1 +
 serviceinterface/ServiceInterfacePrinter.h    |   8 +-
 serviceinterface/serviceInterfaceDefintions.h |   7 +
 7 files changed, 152 insertions(+), 87 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index d1ab553d8..0ab6f150f 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -20,7 +20,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
                         appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
 				"Invalid supplied owner");
         return;
@@ -28,7 +28,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
     this->owner = owner;
     mutex = MutexFactory::instance()->createMutex();
     if(mutex == nullptr) {
-    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
     			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not create mutex");
     }
@@ -41,7 +41,7 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
         // error, all destinations invalid
-    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
     			"initialize", QUEUE_OR_DESTINATION_INVALID);
     }
     hkQueue = queueToUse;
@@ -49,7 +49,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
     if(ipcStore == nullptr) {
         // error, all destinations invalid
-    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
     			"initialize", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not set IPC store.");
         return HasReturnvaluesIF::RETURN_FAILED;
@@ -63,7 +63,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
             hkDestinationId = hkPacketReceiver->getHkQueue();
         }
         else {
-        	printWarningOrError(ErrorTypes::ERROR_TYPE,
+        	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
         			"initialize", QUEUE_OR_DESTINATION_INVALID);
             return QUEUE_OR_DESTINATION_INVALID;
         }
@@ -88,7 +88,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
         return result;
     }
 
-	printWarningOrError(ErrorTypes::WARNING_TYPE,
+	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 			"initialize", HasReturnvaluesIF::RETURN_FAILED,
 			"The map should only be initialized once");
     return HasReturnvaluesIF::RETURN_OK;
@@ -155,7 +155,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
-        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
             return POOLOBJECT_NOT_FOUND;
         }
@@ -177,7 +177,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
-        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"handleNotificationUpdate", DATASET_NOT_FOUND);
             return DATASET_NOT_FOUND;
         }
@@ -209,7 +209,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
-        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
             return POOLOBJECT_NOT_FOUND;
         }
@@ -247,7 +247,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
-        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"handleNotificationSnapshot", DATASET_NOT_FOUND);
             return DATASET_NOT_FOUND;
         }
@@ -351,7 +351,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
         return QUEUE_OR_DESTINATION_INVALID;
     }
@@ -381,7 +381,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
         return QUEUE_OR_DESTINATION_INVALID;
     }
@@ -587,7 +587,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
         lp_id_t localPoolId) {
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE, "printPoolEntry",
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING, "printPoolEntry",
     			 HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
         return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
@@ -608,7 +608,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t destination) {
     if(dataSet == nullptr) {
         // Configuration error.
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"generateHousekeepingPacket",
     			DATASET_NOT_FOUND);
         return DATASET_NOT_FOUND;
@@ -634,7 +634,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
     if(hkQueue == nullptr) {
         // error, all destinations invalid
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"generateHousekeepingPacket",
     			QUEUE_OR_DESTINATION_INVALID);
         return QUEUE_OR_DESTINATION_INVALID;
@@ -642,7 +642,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
     if(destination == MessageQueueIF::NO_QUEUE) {
         if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
             // error, all destinations invalid
-        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"generateHousekeepingPacket",
         			QUEUE_OR_DESTINATION_INVALID);
         }
@@ -681,7 +681,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
     sid_t sid = receiver.dataId.sid;
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"performPeriodicHkGeneration",
     			DATASET_NOT_FOUND);
     	return;
@@ -755,7 +755,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     // Get and check dataset first.
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"performPeriodicHkGeneration",
     			DATASET_NOT_FOUND);
         return DATASET_NOT_FOUND;
@@ -782,7 +782,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
             expectedSize,&storePtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
-    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
     			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not get free element from IPC store.");
         return result;
@@ -793,7 +793,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     result = setPacket.serialize(&storePtr, &size, expectedSize,
             SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
 				"Expected size is not equal to serialized size");
     }
@@ -813,7 +813,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     return result;
 }
 
-void LocalDataPoolManager::printWarningOrError(ErrorTypes errorType,
+void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 		const char* functionName, ReturnValue_t error, const char* errorPrint) {
 	if(errorPrint == nullptr) {
 		if(error == DATASET_NOT_FOUND) {
@@ -823,7 +823,7 @@ void LocalDataPoolManager::printWarningOrError(ErrorTypes errorType,
 			errorPrint = "Pool Object not found";
 		}
 		else if(error == HasReturnvaluesIF::RETURN_FAILED) {
-			if(errorType == ErrorTypes::WARNING_TYPE) {
+			if(outputType == fsfw::OutputTypes::OUT_WARNING) {
 				errorPrint = "Generic Warning";
 			}
 			else {
@@ -844,7 +844,7 @@ void LocalDataPoolManager::printWarningOrError(ErrorTypes errorType,
 		}
 	}
 
-	if(errorType == ErrorTypes::WARNING_TYPE) {
+	if(outputType == fsfw::OutputTypes::OUT_WARNING) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
@@ -855,7 +855,7 @@ void LocalDataPoolManager::printWarningOrError(ErrorTypes errorType,
 				owner->getObjectId(), errorPrint);
 #endif
 	}
-	else if(errorType == ErrorTypes::ERROR_TYPE) {
+	else if(outputType == fsfw::OutputTypes::OUT_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 730e03e4a..eee4c5931 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -371,12 +371,8 @@ private:
 	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
 	        store_address_t& storeId);
 
-	enum class ErrorTypes {
-		WARNING_TYPE,
-		ERROR_TYPE
-	};
-
-	void printWarningOrError(ErrorTypes errorType, const char* functionName,
+	void printWarningOrError(fsfw::OutputTypes outputType,
+			const char* functionName,
 			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
 			const char* errorPrint = nullptr);
 };
@@ -387,14 +383,14 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
-    	printWarningOrError(ErrorTypes::ERROR_TYPE, "fetchPoolEntry",
+    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "fetchPoolEntry",
 				HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
 		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
-    	printWarningOrError(ErrorTypes::ERROR_TYPE, "fetchPoolEntry",
+    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "fetchPoolEntry",
     			HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT);
 		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 580f8c0d0..7ca9922a9 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -39,13 +39,8 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		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;
-#endif
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
+				HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
 	}
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
@@ -132,30 +127,24 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	communicationInterface = objectManager->get<DeviceCommunicationIF>(
 			deviceCommunicationId);
 	if (communicationInterface == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DeviceHandlerBase::initialize: Communication interface "
-				"invalid." << std::endl;
-		sif::error << "Make sure it is set up properly and implements"
-				" DeviceCommunicationIF" << std::endl;
-#endif
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "initialize",
+				ObjectManagerIF::CHILD_INIT_FAILED,
+				"Passed communication IF invalid");
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	    sif::error << "DeviceHandlerBase::initialize: Initializing "
-	            "communication interface failed!" << std::endl;
-#endif
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "initialize",
+				ObjectManagerIF::CHILD_INIT_FAILED,
+				"ComIF initialization failed");
 	    return result;
 	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
-				"factory." << std::endl;
-#endif
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "initialize",
+				ObjectManagerIF::CHILD_INIT_FAILED, "IPC Store not set up");
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -164,11 +153,15 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
+			printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+					"Raw receiver object ID set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			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;
+#else
+			fsfw::printError("Make sure the raw receiver object is set up "
+					"properly and implements AcceptsDeviceResponsesIF\n");
 #endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
@@ -178,11 +171,15 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == nullptr) {
+			printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+					"Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			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;
+			sif::error << "Make sure the power switcher object is set up "
+					<< "properly and implements PowerSwitchIF" << std::endl;
+#else
+			fsfw::printError("Make sure the power switcher object is set up "
+					"properly and implements PowerSwitchIF\n");
 #endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
@@ -556,17 +553,17 @@ void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
 
 void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
 		uint32_t parameter) {
-//Check if we reply to a raw command.
+	// Check if we reply to a raw command.
 	if (cookieInfo.pendingCommand->first == RAW_COMMAND_ID) {
 		if (status == NO_REPLY_EXPECTED) {
 			status = RETURN_OK;
 		}
 		replyReturnvalueToCommand(status, parameter);
-		//Always delete data from a raw command.
+		// Always delete data from a raw command.
 		IPCStore->deleteData(storedRawData);
 		return;
 	}
-//Check if we were externally commanded.
+	// Check if we were externally commanded.
 	if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
 		MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
 		if (status == NO_REPLY_EXPECTED) {
@@ -581,15 +578,17 @@ void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
 
 void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 		ReturnValue_t status) {
-//No need to check if iter exists, as this is checked by callers. If someone else uses the method, add check.
+	// No need to check if iter exists, as this is checked by callers.
+	// If someone else uses the method, add check.
 	if (iter->second.command == deviceCommandMap.end()) {
 		//Is most likely periodic reply. Silent return.
 		return;
 	}
-//Check if more replies are expected. If so, do nothing.
+	// Check if more replies are expected. If so, do nothing.
 	DeviceCommandInfo* info = &(iter->second.command->second);
 	if (--info->expectedReplies == 0) {
-		//Check if it was transition or internal command. Don't send any replies in that case.
+		// Check if it was transition or internal command.
+		// Don't send any replies in that case.
 		if (info->sendReplyTo != NO_COMMANDER) {
 			actionHelper.finish(info->sendReplyTo, iter->first, status);
 		}
@@ -606,7 +605,7 @@ void DeviceHandlerBase::doSendWrite() {
 		if (result == RETURN_OK) {
 			cookieInfo.state = COOKIE_WRITE_SENT;
 		} else {
-			//always generate a failure event, so that FDIR knows what's up
+			// always generate a failure event, so that FDIR knows what's up
 			triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
 					cookieInfo.pendingCommand->first);
 			replyToCommand(result);
@@ -735,6 +734,9 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 			            foundId);
 			}
 			if(foundLen == 0) {
+				printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
+						"Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
 			            " Packet parsing will be stuck." << std::endl;
@@ -968,7 +970,8 @@ ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 }
 
 Mode_t DeviceHandlerBase::getBaseMode(Mode_t transitionMode) {
-//only child action special modes are handled, as a child should never see any base action modes
+	// only child action special modes are handled, as a child should
+	// never see any base action modes
 	if (transitionMode == _MODE_START_UP) {
 		return _MODE_TO_ON;
 	}
@@ -1291,12 +1294,11 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 	if (mode == MODE_NORMAL) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
-		    //so we can track misconfigurations
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Busy" << std::dec
-					<< std::endl;
-#endif
+		    // so we can track misconfigurations
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"buildInternalCommand",
+					HasReturnvaluesIF::RETURN_FAILED,
+					"Busy.");
 			result = NOTHING_TO_SEND; //no need to report this
 		}
 	}
@@ -1320,13 +1322,13 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
-			//so we can track misconfigurations
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Command "
-					<< deviceCommandId << " isExecuting" << std::dec
-					<< std::endl;
-#endif
+			char* output = nullptr;
+			sprintf(output, "Command %lu is executing", deviceCommandId);
+			// so we can track misconfigurations
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"buildInternalCommand",
+					HasReturnvaluesIF::RETURN_FAILED,
+					output);
 			// this is an internal command, no need to report a failure here,
 			// missed reply will track if a reply is too late, otherwise, it's ok
 			return;
@@ -1485,3 +1487,48 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 		}
 	}
 }
+
+void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
+		const char *functionName, ReturnValue_t errorCode,
+		const char *errorPrint) {
+	if(errorPrint == nullptr) {
+		if(errorCode == ObjectManagerIF::CHILD_INIT_FAILED) {
+			errorPrint = "Initialization error";
+		}
+		if(errorCode == HasReturnvaluesIF::RETURN_FAILED) {
+			if(errorType == fsfw::OutputTypes::OUT_WARNING) {
+				errorPrint = "Generic Warning";
+			}
+			else {
+				errorPrint = "Generic Error";
+			}
+		}
+		else {
+			errorPrint = "Unknown error";
+		}
+	}
+
+	if(errorType == fsfw::OutputTypes::OUT_WARNING) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::warning << "DeviceHandlerBase::" << functionName << ": Object ID "
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< this->getObjectId() << " | " << errorPrint << std::dec
+				<< std::setfill(' ') << std::endl;
+#else
+		fsfw::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+				this->getObjectId(), errorPrint);
+#endif
+	}
+	else if(errorType == fsfw::OutputTypes::OUT_ERROR) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::error << "DeviceHandlerBase::" << functionName << ": Object ID "
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< this->getObjectId() << " | " << errorPrint << std::dec
+				<< std::setfill(' ') << std::endl;
+#else
+		fsfw::printError("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+				this->getObjectId(), errorPrint);
+#endif
+	}
+
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 24ba0372c..4c745b4f1 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -6,6 +6,8 @@
 #include "DeviceHandlerFailureIsolation.h"
 #include "DeviceHandlerThermalSet.h"
 
+#include "../serviceinterface/ServiceInterface.h"
+#include "../serviceinterface/serviceInterfaceDefintions.h"
 #include "../objectmanager/SystemObject.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -1111,7 +1113,7 @@ private:
 	/**
 	 * @brief   The mode the current transition originated from
 	 *
-	 * This is private so the child can not change it and fuck up the timeouts
+	 * This is private so the child can not change it and mess up the timeouts
 	 *
 	 * IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!!
 	 * (it is _MODE_POWER_DOWN during this modes)
@@ -1190,7 +1192,8 @@ private:
 	 * Check if the RMAP sendWrite action was successful.
 	 *
 	 * Depending on the result, the following is done
-	 * - if the device command was external commanded, a reply is sent indicating the result
+	 * - if the device command was external commanded, a reply is sent
+	 *   indicating the result
 	 * - if the action was successful, the reply timout counter is initialized
 	 */
 	void doGetWrite(void);
@@ -1206,9 +1209,9 @@ private:
 	/**
 	 * Check the getRead reply and the contained data.
 	 *
-	 * If data was received scanForReply() and, if successful, handleReply() are called.
-	 * If the current mode is @c MODE_RAW, the received packet is sent to the commanding object
-	 * via commandQueue.
+	 * If data was received scanForReply() and, if successful, handleReply()
+	 * are called. If the current mode is @c MODE_RAW, the received packet
+	 * is sent to the commanding object via commandQueue.
 	 */
 	void doGetRead(void);
 
@@ -1227,7 +1230,7 @@ private:
 			uint32_t *len);
 
 	/**
-	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
+	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW, nothing else!
 	 */
 	void setTransition(Mode_t modeTo, Submode_t submodeTo);
 
@@ -1247,6 +1250,11 @@ private:
 
     void handleTransitionToOnMode(Mode_t commandedMode,
     		Submode_t commandedSubmode);
+
+    void printWarningOrError(fsfw::OutputTypes errorType,
+    		const char* functionName,
+			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+			const char* errorPrint = nullptr);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
diff --git a/serviceinterface/ServiceInterface.h b/serviceinterface/ServiceInterface.h
index 0c7c43837..1f7e5e84a 100644
--- a/serviceinterface/ServiceInterface.h
+++ b/serviceinterface/ServiceInterface.h
@@ -2,6 +2,7 @@
 #define FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
 
 #include <FSFWConfig.h>
+#include "serviceInterfaceDefintions.h"
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index 1f82ba982..9a84f6297 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -4,7 +4,7 @@
 
 namespace fsfw {
 
-enum class PrintLevel {
+enum PrintLevel {
 	NONE = 0,
 	//! Strange error when using just ERROR..
 	ERROR_TYPE = 1,
@@ -13,6 +13,12 @@ enum class PrintLevel {
 	DEBUG = 4
 };
 
+/**
+ * Set the print level. All print types with a smaller level will be printed
+ * as well. For example, set to PrintLevel::WARNING to only enable error
+ * and warning output.
+ * @param printLevel
+ */
 void setPrintLevel(PrintLevel printLevel);
 PrintLevel getPrintLevel();
 
diff --git a/serviceinterface/serviceInterfaceDefintions.h b/serviceinterface/serviceInterfaceDefintions.h
index 684c73668..de445907c 100644
--- a/serviceinterface/serviceInterfaceDefintions.h
+++ b/serviceinterface/serviceInterfaceDefintions.h
@@ -3,6 +3,13 @@
 
 namespace fsfw {
 
+enum class OutputTypes {
+	OUT_INFO,
+	OUT_DEBUG,
+	OUT_WARNING,
+	OUT_ERROR
+};
+
 static const char* const ANSI_COLOR_RED = "\x1b[31m";
 static const char* const ANSI_COLOR_GREEN = "\x1b[32m";
 static const char* const ANSI_COLOR_YELLOW = "\x1b[33m";

From a9dba82661f6a88eeaa3fd1aab0948bf1919158c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 16:16:17 +0100
Subject: [PATCH 1392/1774] bugfix

---
 devicehandlers/DeviceHandlerBase.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 7ca9922a9..1a1068448 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1322,8 +1322,8 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
-			char* output = nullptr;
-			sprintf(output, "Command %lu is executing", deviceCommandId);
+			char output[36];
+			sprintf(output, "Command 0x%08x is executing", deviceCommandId);
 			// so we can track misconfigurations
 			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 					"buildInternalCommand",

From a1c394143a1b6ba4c80abcb54302ca1020053f69 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 16:18:08 +0100
Subject: [PATCH 1393/1774] small formatting stuff

---
 devicehandlers/DeviceHandlerBase.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1a1068448..835a02b8c 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -749,7 +749,8 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case IGNORE_FULL_PACKET:
 			return;
 		default:
-			//We need to wait for timeout.. don't know what command failed and who sent it.
+			// 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;

From 9f15cd697d154d0d464560ce2c26cedee9c87388 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 16:23:57 +0100
Subject: [PATCH 1394/1774] improved includes

---
 devicehandlers/DeviceHandlerBase.cpp       | 14 ++++++--------
 serviceinterface/ServiceInterfacePrinter.h |  2 +-
 2 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 835a02b8c..0efdeba04 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -2,7 +2,7 @@
 #include "AcceptsDeviceResponsesIF.h"
 #include "DeviceTmReportingWrapper.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
@@ -13,9 +13,6 @@
 #include "../subsystem/SubsystemBase.h"
 #include "../datapoollocal/LocalPoolVariable.h"
 
-#include <iomanip>
-
-
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
@@ -720,10 +717,9 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
 			if(foundLen == 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
-			            " Packet parsing will be stuck." << std::endl;
-#endif
+				printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
+						"Found length is one, parsing might be stuck");
 			}
 			break;
 		case APERIODIC_REPLY: {
@@ -1323,6 +1319,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
+#if FSFW_DISABLE_PRINTOUT == 0
 			char output[36];
 			sprintf(output, "Command 0x%08x is executing", deviceCommandId);
 			// so we can track misconfigurations
@@ -1330,6 +1327,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 					"buildInternalCommand",
 					HasReturnvaluesIF::RETURN_FAILED,
 					output);
+#endif
 			// this is an internal command, no need to report a failure here,
 			// missed reply will track if a reply is too late, otherwise, it's ok
 			return;
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index 9a84f6297..fdff797a2 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -1,5 +1,5 @@
 #if FSFW_DISABLE_PRINTOUT == 0
-#include <stdio.h>
+#include <cstdio>
 #endif
 
 namespace fsfw {

From 7c47b1ce345182c6a69ff2fcaf6e89d81ef8c867 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 20:44:05 +0100
Subject: [PATCH 1395/1774] 100 percent test coverage for pool vector

---
 datapoollocal/LocalPoolVector.tpp             |  4 +-
 unittest/tests/datapoollocal/CMakeLists.txt   |  1 +
 unittest/tests/datapoollocal/DataSetTest.cpp  |  6 ++-
 .../datapoollocal/LocalPoolVariableTest.cpp   |  2 +-
 .../datapoollocal/LocalPoolVectorTest.cpp     | 52 ++++++++++++++++++-
 5 files changed, 59 insertions(+), 6 deletions(-)

diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index a0e32f624..f311c23d5 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -104,7 +104,7 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
 	fsfw::printWarning("LocalPoolVector: Invalid index. Setting or returning"
 			" last value!\n");
 #endif
-	return value[vectorSize];
+	return value[vectorSize - 1];
 }
 
 template<typename T, uint16_t vectorSize>
@@ -121,7 +121,7 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
 	fsfw::printWarning("LocalPoolVector: Invalid index. Setting or returning"
 			" last value!\n");
 #endif
-	return value[vectorSize];
+	return value[vectorSize - 1];
 }
 
 template<typename T, uint16_t vectorSize>
diff --git a/unittest/tests/datapoollocal/CMakeLists.txt b/unittest/tests/datapoollocal/CMakeLists.txt
index 9d828de58..fd7f61b82 100644
--- a/unittest/tests/datapoollocal/CMakeLists.txt
+++ b/unittest/tests/datapoollocal/CMakeLists.txt
@@ -1,4 +1,5 @@
 target_sources(${TARGET_NAME} PRIVATE
 	LocalPoolVariableTest.cpp
 	LocalPoolVectorTest.cpp
+	DataSetTest.cpp
 )
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index ccb7603d4..968a0b3df 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -2,6 +2,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
@@ -11,9 +12,10 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
 	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
 	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
 			== retval::CATCH_OK);
-
+	const uint32_t setId = 0;
 	SECTION("BasicTest") {
-		//StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>()
+		StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>(
+				sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, setId));
 	}
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index eb5abf35a..5f7118ff2 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -23,10 +23,10 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		REQUIRE(testVariable.commit() == retval::CATCH_OK);
 		REQUIRE(testVariable.read() == retval::CATCH_OK);
 		REQUIRE(testVariable.value == 5);
-
 		CHECK(not testVariable.isValid());
 		testVariable.setValid(true);
 		CHECK(testVariable.isValid());
+		CHECK(testVariable.commit(true) == retval::CATCH_OK);
 
 		testVariable.setReadWriteMode(pool_rwm_t::VAR_READ);
 		CHECK(testVariable.getReadWriteMode() == pool_rwm_t::VAR_READ);
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
index 7e40e898c..cfc2ec2ed 100644
--- a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -38,7 +38,7 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 		// This is invalid access, so the last value will be set instead.
 		// (we can't throw exceptions)
 		testVector[4] = 12;
-		CHECK(testVector[3] == 12);
+		CHECK(testVector[2] == 12);
 		CHECK(testVector.commit() == retval::CATCH_OK);
 
 		// Use read-only reference.
@@ -48,6 +48,42 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 
 		uint16_t lastVal = roTestVec[25];
 		CHECK(lastVal == 12);
+
+		size_t maxSize = testVector.getSerializedSize();
+		CHECK(maxSize == 6);
+
+		uint16_t serializedVector[3];
+		uint8_t* vecPtr = reinterpret_cast<uint8_t*>(serializedVector);
+		size_t serSize = 0;
+		REQUIRE(testVector.serialize(&vecPtr, &serSize,
+				maxSize, SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+
+		CHECK(serSize == 6);
+		CHECK(serializedVector[0] == 5);
+		CHECK(serializedVector[1] == 232);
+		CHECK(serializedVector[2] == 12);
+
+		maxSize = 1;
+		REQUIRE(testVector.serialize(&vecPtr, &serSize,
+				maxSize, SerializeIF::Endianness::MACHINE) ==
+				static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+
+		serializedVector[0] = 16;
+		serializedVector[1] = 7832;
+		serializedVector[2] = 39232;
+
+		const uint8_t* constVecPtr = reinterpret_cast<const uint8_t*>(
+				serializedVector);
+		REQUIRE(testVector.deSerialize(&constVecPtr, &serSize,
+				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+		CHECK(testVector[0] == 16);
+		CHECK(testVector[1] == 7832);
+		CHECK(testVector[2] == 39232);
+
+		serSize = 1;
+		REQUIRE(testVector.deSerialize(&constVecPtr, &serSize,
+				SerializeIF::Endianness::MACHINE) ==
+				static_cast<int>(SerializeIF::STREAM_TOO_SHORT));
 	}
 
 	SECTION("ErrorHandling") {
@@ -64,6 +100,20 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
 		REQUIRE(invalidVector2.read() ==
 				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+		REQUIRE(invalidVector2.commit() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+
+		lp_vec_t<uint16_t, 3> writeOnlyVec = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
+				nullptr, pool_rwm_t::VAR_WRITE);
+		REQUIRE(writeOnlyVec.read() ==
+				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+
+		lp_vec_t<uint16_t, 3> readOnlyVec = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
+				nullptr, pool_rwm_t::VAR_READ);
+		REQUIRE(readOnlyVec.commit() ==
+				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
 	}
 }
 

From 12091ca6ab48df043708b2a63e0b695679f5315d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 20:55:36 +0100
Subject: [PATCH 1396/1774] enum members renamed, global vars static now

---
 serviceinterface/ServiceInterfacePrinter.cpp | 30 ++++++++++----------
 serviceinterface/ServiceInterfacePrinter.h   |  8 +++---
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index cb3a958d7..fff6753b8 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -6,11 +6,11 @@
 #include <cstdarg>
 #include <cstdint>
 
-fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
+static fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG_LEVEL;
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
-bool consoleInitialized = false;
+static bool consoleInitialized = false;
 #endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
-bool addCrAtEnd = false;
+static bool addCrAtEnd = false;
 
 #if FSFW_DISABLE_PRINTOUT == 0
 uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
@@ -39,31 +39,31 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     /* Log message to terminal */
 
 #if FSFW_COLORED_OUTPUT == 1
-    if(printType == fsfw::PrintLevel::INFO) {
+    if(printType == fsfw::PrintLevel::INFO_LEVEL) {
     	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_GREEN);
     }
-    else if(printType == fsfw::PrintLevel::DEBUG) {
+    else if(printType == fsfw::PrintLevel::DEBUG_LEVEL) {
     	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_MAGENTA);
     }
-    else if(printType == fsfw::PrintLevel::WARNING) {
+    else if(printType == fsfw::PrintLevel::WARNING_LEVEL) {
     	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_YELLOW);
     }
-    else if(printType == fsfw::PrintLevel::ERROR_TYPE) {
+    else if(printType == fsfw::PrintLevel::ERROR_LEVEL) {
     	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_RED);
     }
 #endif
 
-   if (printType == fsfw::PrintLevel::INFO) {
+   if (printType == fsfw::PrintLevel::INFO_LEVEL) {
        len += sprintf(bufferPosition + len, "INFO: ");
    }
-   if(printType == fsfw::PrintLevel::DEBUG) {
+   if(printType == fsfw::PrintLevel::DEBUG_LEVEL) {
 	   len += sprintf(bufferPosition + len, "DEBUG: ");
    }
-   if(printType == fsfw::PrintLevel::WARNING) {
+   if(printType == fsfw::PrintLevel::WARNING_LEVEL) {
 	   len += sprintf(bufferPosition + len, "WARNING: ");
    }
 
-   if(printType == fsfw::PrintLevel::ERROR_TYPE) {
+   if(printType == fsfw::PrintLevel::ERROR_LEVEL) {
 	   len += sprintf(bufferPosition + len, "ERROR: ");
    }
 
@@ -91,21 +91,21 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 void fsfw::printInfo(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::INFO, fmt, args);
+    fsfwPrint(fsfw::PrintLevel::INFO_LEVEL, fmt, args);
     va_end(args);
 }
 
 void fsfw::printWarning(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::WARNING, fmt, args);
+    fsfwPrint(fsfw::PrintLevel::WARNING_LEVEL, fmt, args);
     va_end(args);
 }
 
 void fsfw::printDebug(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::DEBUG, fmt, args);
+    fsfwPrint(fsfw::PrintLevel::DEBUG_LEVEL, fmt, args);
     va_end(args);
 }
 
@@ -116,7 +116,7 @@ void fsfw::setToAddCrAtEnd(bool addCrAtEnd_) {
 void fsfw::printError(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::ERROR_TYPE, fmt, args);
+    fsfwPrint(fsfw::PrintLevel::ERROR_LEVEL, fmt, args);
     va_end(args);
 }
 
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index fdff797a2..f49ccbb7e 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -7,10 +7,10 @@ namespace fsfw {
 enum PrintLevel {
 	NONE = 0,
 	//! Strange error when using just ERROR..
-	ERROR_TYPE = 1,
-	WARNING = 2,
-	INFO = 3,
-	DEBUG = 4
+	ERROR_LEVEL = 1,
+	WARNING_LEVEL = 2,
+	INFO_LEVEL = 3,
+	DEBUG_LEVEL = 4
 };
 
 /**

From 57829faa64f004a48510e057742c4a9fb03a3726 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 21:03:47 +0100
Subject: [PATCH 1397/1774] added cast

---
 devicehandlers/DeviceHandlerBase.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 0efdeba04..4fa7b09c0 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1321,7 +1321,8 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		} else if (iter->second.isExecuting) {
 #if FSFW_DISABLE_PRINTOUT == 0
 			char output[36];
-			sprintf(output, "Command 0x%08x is executing", deviceCommandId);
+			sprintf(output, "Command 0x%08x is executing",
+					static_cast<unsigned int>(deviceCommandId));
 			// so we can track misconfigurations
 			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 					"buildInternalCommand",

From dbe326e78743ca64888cea4506acefdbb1bf566b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 9 Jan 2021 13:52:47 +0100
Subject: [PATCH 1398/1774] minor tweak

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3cc5ffd58..587e67012 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -106,7 +106,7 @@ else()
 	)
 endif()
 
-if(CMAKE_COMPILER_IS_GNUCXX)
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	set(WARNING_FLAGS
 		-Wall
 		-Wextra

From 7129ea67bdf4c85d496a22c692a84f0f7a6ede97 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 Jan 2021 16:06:54 +0100
Subject: [PATCH 1399/1774] linux fixes

---
 osal/linux/BinarySemaphore.cpp      | 20 +++++++++++++-------
 osal/linux/CountingSemaphore.cpp    |  4 +++-
 osal/linux/MessageQueue.cpp         | 14 ++++++++------
 osal/linux/TcUnixUdpPollingTask.cpp |  2 ++
 osal/linux/TmTcUnixUdpBridge.cpp    |  8 ++++++--
 5 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 0a6bb29f0..c2eb85149 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -1,10 +1,11 @@
 #include "BinarySemaphore.h"
+#include "../../serviceinterface/ServiceInterfacePrinter.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-extern "C" {
+#include <time.h>
 #include <errno.h>
 #include <string.h>
-}
+
 
 BinarySemaphore::BinarySemaphore() {
 	// Using unnamed semaphores for now
@@ -113,7 +114,8 @@ uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
 	}
 	else if(result != 0 and errno == EINVAL) {
 		// Could be called from interrupt, use lightweight printf
-		printf("BinarySemaphore::getSemaphoreCounter: Invalid semaphore\n");
+		fsfw::printError("BinarySemaphore::getSemaphoreCounter: "
+				"Invalid semaphore\n");
 		return 0;
 	}
 	else {
@@ -128,13 +130,17 @@ void BinarySemaphore::initSemaphore(uint8_t initCount) {
 		switch(errno) {
 		case(EINVAL):
 			// Value exceeds SEM_VALUE_MAX
-		case(ENOSYS):
-		// System does not support process-shared semaphores
+		case(ENOSYS): {
+			// System does not support process-shared semaphores
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
-				<< std::endl;
+				sif::error << "BinarySemaphore: Init failed with "
+						<< strerror(errno) << std::endl;
+#else
+				fsfw::printError("BinarySemaphore: Init failed with %s\n",
+						strerror(errno));
 #endif
 		}
+		}
 	}
 }
 
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
index 0bb718319..07c522129 100644
--- a/osal/linux/CountingSemaphore.cpp
+++ b/osal/linux/CountingSemaphore.cpp
@@ -1,5 +1,7 @@
 #include "../../osal/linux/CountingSemaphore.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
+
+#include <errno.h>
 
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index e7b09b4f9..d93b7f6d5 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,5 +1,5 @@
 #include "MessageQueue.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 
 #include <fstream>
@@ -121,14 +121,16 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		break;
 	}
 
-	default:
+	default: {
 		// Failed either the first time or the second time
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-		<< name << std::dec << " failed with status: "
-		<< strerror(errno) << std::endl;
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << name
+				<< " failed with status: " << strerror(errno) << std::endl;
+#else
+		fsfw::printError("MessageQueue::MessageQueue: Creating Queue %s"
+				" failed with status: %s\n", name, strerror(errno));
 #endif
-
+	}
 	}
 	return HasReturnvaluesIF::RETURN_FAILED;
 
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index a8387e87f..11ed7fee6 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,6 +1,8 @@
 #include "TcUnixUdpPollingTask.h"
 #include "../../globalfunctions/arrayprinter.h"
 
+#include <errno.h>
+
 TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,
 		double timeoutSeconds): SystemObject(objectId),
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 1d318d3b0..0bedce0f0 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,5 +1,5 @@
 #include "TmTcUnixUdpBridge.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../ipc/MutexHelper.h"
 
 #include <errno.h>
@@ -188,12 +188,16 @@ void TmTcUnixUdpBridge::handleBindError() {
 
 void TmTcUnixUdpBridge::handleSendError() {
 	switch(errno) {
-	default:
+	default: {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSendError: "
 		        << strerror(errno) << std::endl;
+#else
+		fsfw::printError("TmTcUnixBridge::handleSendError: %s\n",
+				strerror(errno));
 #endif
 	}
+	}
 }
 
 void TmTcUnixUdpBridge::setClientAddressToAny(bool ipAddrAnySet){

From 13ffcfe801c61a5d4cca3ccb55d2d9300e100ffd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 Jan 2021 16:20:35 +0100
Subject: [PATCH 1400/1774] prints added

---
 osal/linux/PosixThread.cpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index a0e540cfd..8d368c182 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,6 +1,6 @@
 #include "PosixThread.h"
 
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 #include <cstring>
 #include <errno.h>
@@ -146,16 +146,22 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 				strerror(status) << std::endl;
 #endif
 		if(errno == ENOMEM) {
-			uint64_t stackMb = stackSize/10e6;
+			size_t stackMb = stackSize/10e6;
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Insufficient memory for"
 					" the requested " << stackMb << " MB" << std::endl;
+#else
+			fsfw::printError("PosixThread::createTask: Insufficient memory for "
+					"the requested %zu MB\n", stackMb);
 #endif
 		}
 		else if(errno == EINVAL) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Wrong alignment argument!"
 					<< std::endl;
+#else
+			fsfw::printError("PosixThread::createTask: "
+					"Wrong alignment argument!\n");
 #endif
 		}
 		return;

From f8abf3527dead67938a7c03f39cf63f46ca73ff5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 11:51:33 +0100
Subject: [PATCH 1401/1774] fixed indentation

---
 datapoollocal/LocalDataPoolManager.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 0ab6f150f..8ccc620cb 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -509,10 +509,13 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
         break;
     }
 
-    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
-                        return generateSetStructurePacket(sid, true);
-    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-                        return generateSetStructurePacket(sid, false);
+    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES): {
+        return generateSetStructurePacket(sid, true);
+    }
+
+    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
+        return generateSetStructurePacket(sid, false);
+    }
     case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
     case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
         float newCollIntvl = 0;

From 918200e88c542a985e9751c1a053dfa37bc4c66e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 12:53:01 +0100
Subject: [PATCH 1402/1774] added first unit tests for hk manager

---
 datapool/PoolDataSetBase.cpp                  |  4 +
 datapool/PoolDataSetBase.h                    |  1 +
 datapoollocal/LocalDataPoolManager.cpp        |  6 +-
 unittest/tests/action/TestActionHelper.cpp    |  1 +
 unittest/tests/action/TestActionHelper.h      | 81 -----------------
 unittest/tests/datapoollocal/CMakeLists.txt   |  1 +
 .../datapoollocal/LocalPoolManagerTest.cpp    | 28 ++++++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 59 ++++++++++--
 unittest/tests/mocks/MessageQueueMockBase.h   | 90 +++++++++++++++++++
 9 files changed, 179 insertions(+), 92 deletions(-)
 create mode 100644 unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
 create mode 100644 unittest/tests/mocks/MessageQueueMockBase.h

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 05797012f..7731a8df4 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -214,6 +214,10 @@ void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
     this->registeredVariables = variablesContainer;
 }
 
+PoolVariableIF** PoolDataSetBase::getContainer() const {
+	return registeredVariables;
+}
+
 void PoolDataSetBase::setReadCommitProtectionBehaviour(
 		bool protectEveryReadCommit, uint32_t mutexTimeout) {
 	this->protectEveryReadCommitCall = protectEveryReadCommit;
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 0528f40f3..665f4b33c 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -157,6 +157,7 @@ protected:
 	const size_t maxFillCount = 0;
 
 	void setContainer(PoolVariableIF** variablesContainer);
+	PoolVariableIF** getContainer() const;
 
 private:
 	bool protectEveryReadCommitCall = false;
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 8ccc620cb..564604cd8 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -308,8 +308,8 @@ void LocalDataPoolManager::handleChangeResetLogic(
         // config error!
         return;
     }
-
-    for(auto& changeInfo: *hkUpdateResetList) {
+    HkUpdateResetList& listRef = *hkUpdateResetList;
+    for(auto& changeInfo: listRef) {
         if(changeInfo.dataType != type) {
             continue;
         }
@@ -636,7 +636,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
     }
 
     if(hkQueue == nullptr) {
-        // error, all destinations invalid
+        // error, no queue available to send packet with.
     	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"generateHousekeepingPacket",
     			QUEUE_OR_DESTINATION_INVALID);
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index 3957bba2f..2493a6b8e 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -4,6 +4,7 @@
 
 #include <fsfw/action/ActionHelper.h>
 #include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
 
 #include <catch2/catch_test_macros.hpp>
 
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
index 610fb09ea..641ea2c63 100644
--- a/unittest/tests/action/TestActionHelper.h
+++ b/unittest/tests/action/TestActionHelper.h
@@ -48,85 +48,4 @@ public:
 };
 
 
-class MessageQueueMockBase: public MessageQueueIF {
-public:
-	MessageQueueId_t myQueueId = 0;
-	bool defaultDestSet = false;
-	bool messageSent = false;
-
-
-
-	bool wasMessageSent() {
-		bool tempMessageSent = messageSent;
-		messageSent = false;
-		return tempMessageSent;
-	}
-
-	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	};
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) {
-		(*message) = lastMessage;
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
-		memcpy(message->getBuffer(), lastMessage.getBuffer(),
-				message->getMessageSize());
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t flush(uint32_t* count) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual MessageQueueId_t getLastPartner() const {
-		return tconst::testQueueId;
-	}
-	virtual MessageQueueId_t getId() const {
-		return tconst::testQueueId;
-	}
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
-		myQueueId = defaultDestination;
-		defaultDestSet = true;
-	}
-
-	virtual MessageQueueId_t getDefaultDestination() const {
-		return myQueueId;
-	}
-	virtual bool isDefaultDestinationSet() const {
-		return defaultDestSet;
-	}
-private:
-	MessageQueueMessage lastMessage;
-
-};
-
-
 #endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
diff --git a/unittest/tests/datapoollocal/CMakeLists.txt b/unittest/tests/datapoollocal/CMakeLists.txt
index fd7f61b82..f196a080a 100644
--- a/unittest/tests/datapoollocal/CMakeLists.txt
+++ b/unittest/tests/datapoollocal/CMakeLists.txt
@@ -2,4 +2,5 @@ target_sources(${TARGET_NAME} PRIVATE
 	LocalPoolVariableTest.cpp
 	LocalPoolVectorTest.cpp
 	DataSetTest.cpp
+	LocalPoolManagerTest.cpp
 )
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
new file mode 100644
index 000000000..4cea3ed15
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -0,0 +1,28 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <unittest/core/CatchDefinitions.h>
+
+
+TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+	REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK);
+	MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
+	REQUIRE(mqMock != nullptr);
+
+	poolOwner->subscribeWrapperSetUpdate();
+	SECTION("BasicTest") {
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(mqMock->wasMessageSent() == true);
+
+	}
+}
+
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index c665cb7f8..c211801a0 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -7,6 +7,8 @@
 #include <fsfw/datapoollocal/LocalPoolVector.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <testcfg/objects/systemObjectList.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
 
 namespace lpool {
 static constexpr lp_id_t uint8VarId = 0;
@@ -14,16 +16,45 @@ static constexpr lp_id_t floatVarId = 1;
 static constexpr lp_id_t uint32VarId = 2;
 static constexpr lp_id_t uint16Vec3Id = 3;
 static constexpr lp_id_t int64Vec2Id = 4;
+
+static constexpr uint32_t testSetId = 0;
 }
 
 
+class LocalPoolTestDataSet: public StaticLocalDataSet<3> {
+public:
+	LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
+		StaticLocalDataSet(owner, setId) {
+	}
+
+	ReturnValue_t assignPointers() {
+		PoolVariableIF** rawVarArray = getContainer();
+		localPoolVarUint8 = dynamic_cast<lp_var_t<uint8_t>*>(rawVarArray[0]);
+		localPoolVarFloat = dynamic_cast<lp_var_t<float>*>(rawVarArray[1]);
+		localPoolUint16Vec = dynamic_cast<lp_vec_t<uint16_t, 3>*>(
+				rawVarArray[2]);
+		if(localPoolVarUint8 == nullptr or  localPoolVarFloat == nullptr or
+				localPoolUint16Vec == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	lp_var_t<uint8_t>* localPoolVarUint8 = nullptr;
+	lp_var_t<float>* localPoolVarFloat = nullptr;
+	lp_vec_t<uint16_t, 3>* localPoolUint16Vec = nullptr;
+
+private:
+};
+
 
 class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
 public:
 	LocalPoolOwnerBase(
 			object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE):
-		SystemObject(objectId), hkManager(this, messageQueue)  {
-		messageQueue = QueueFactory::instance()->createMessageQueue(10);
+		SystemObject(objectId), hkManager(this, messageQueue),
+		dataset(this, lpool::testSetId) {
+		messageQueue = new MessageQueueMockBase();
 	}
 
 	~LocalPoolOwnerBase() {
@@ -89,22 +120,34 @@ public:
 	 * @return
 	 */
 	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override  {
-		// empty for now
-		return nullptr;
+		return &dataset;
 	}
+
+	MessageQueueMockBase* getMockQueueHandle() const {
+		return dynamic_cast<MessageQueueMockBase*>(messageQueue);
+	}
+
+	void subscribeWrapperSetUpdate() {
+		hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
+				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
+	}
+
+	LocalDataPoolManager hkManager;
+	LocalPoolTestDataSet dataset;
 private:
 
-	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
-	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
+	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId,
+			&dataset);
+	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId,
+			&dataset);
 	lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
 
 	lp_vec_t<uint16_t, 3> testUint16Vec = lp_vec_t<uint16_t, 3>(this,
-			lpool::uint16Vec3Id);
+			lpool::uint16Vec3Id, &dataset);
 	lp_vec_t<int64_t, 2> testInt64Vec = lp_vec_t<int64_t, 2>(this,
 			lpool::int64Vec2Id);
 
 	MessageQueueIF* messageQueue = nullptr;
-	LocalDataPoolManager hkManager;
 
 	bool initialized = false;
 	bool initializedAfterTaskCreation = false;
diff --git a/unittest/tests/mocks/MessageQueueMockBase.h b/unittest/tests/mocks/MessageQueueMockBase.h
new file mode 100644
index 000000000..5a1573297
--- /dev/null
+++ b/unittest/tests/mocks/MessageQueueMockBase.h
@@ -0,0 +1,90 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/MessageQueueMessage.h>
+#include <unittest/core/CatchDefinitions.h>
+#include <cstring>
+
+
+class MessageQueueMockBase: public MessageQueueIF {
+public:
+	MessageQueueId_t myQueueId = 0;
+	bool defaultDestSet = false;
+	bool messageSent = false;
+
+
+	bool wasMessageSent() {
+		bool tempMessageSent = messageSent;
+		messageSent = false;
+		return tempMessageSent;
+	}
+
+	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	};
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) {
+		(*message) = lastMessage;
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
+		std::memcpy(message->getBuffer(), lastMessage.getBuffer(),
+				message->getMessageSize());
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t flush(uint32_t* count) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual MessageQueueId_t getLastPartner() const {
+		return tconst::testQueueId;
+	}
+	virtual MessageQueueId_t getId() const {
+		return tconst::testQueueId;
+	}
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+		myQueueId = defaultDestination;
+		defaultDestSet = true;
+	}
+
+	virtual MessageQueueId_t getDefaultDestination() const {
+		return myQueueId;
+	}
+	virtual bool isDefaultDestinationSet() const {
+		return defaultDestSet;
+	}
+private:
+	MessageQueueMessage lastMessage;
+
+};
+
+
+#endif /* FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_ */

From b570da6467fb11497e14d3d05abd20d386f68e4b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 13:58:33 +0100
Subject: [PATCH 1403/1774] more tests added

---
 datapoollocal/HasLocalDataPoolIF.h            |  4 +
 .../datapoollocal/LocalPoolManagerTest.cpp    | 40 +++++++++-
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 21 ++++-
 unittest/tests/mocks/HkReceiverMock.h         | 20 +++++
 unittest/tests/mocks/MessageQueueMockBase.h   | 76 ++++++++++++-------
 .../user/testcfg/objects/systemObjectList.h   |  1 +
 6 files changed, 131 insertions(+), 31 deletions(-)
 create mode 100644 unittest/tests/mocks/HkReceiverMock.h

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 7707fab84..07c6882be 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -4,6 +4,7 @@
 #include "locPoolDefinitions.h"
 
 #include "../datapool/PoolEntryIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
 
@@ -92,6 +93,9 @@ public:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
 	            << ". Returning nullptr!" << std::endl;
+#else
+	    fsfw::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
+	    		"Not overriden. Returning nullptr!\n");
 #endif
 	    return nullptr;
 	}
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 4cea3ed15..2c797505e 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -3,6 +3,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/ipc/CommandMessageCleaner.h>
 #include <unittest/core/CatchDefinitions.h>
 
 
@@ -17,12 +18,49 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 	MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
 	REQUIRE(mqMock != nullptr);
 
-	poolOwner->subscribeWrapperSetUpdate();
+
 	SECTION("BasicTest") {
+		// Subscribe for message generation on update.
+		REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
+		// Subscribe for an update message.
 		poolOwner->dataset.setChanged(true);
+		// Now the update message should be generated.
 		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
 		REQUIRE(mqMock->wasMessageSent() == true);
+		CommandMessage messageSent;
+		uint8_t messagesSent = 0;
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
 
+		// Should have been reset.
+		CHECK(poolOwner->dataset.hasChanged() == false);
+		// Set changed again, result should be the same.
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 1);
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+		// now subscribe for set update HK as well.
+		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 2);
+		// first message sent should be the update notification, considering
+		// the internal list is a vector checked in insertion order.
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::HK_REPORT));
+		CommandMessageCleaner::clearCommandMessage(&messageSent);
 	}
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index c211801a0..5ff146983 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -18,6 +18,8 @@ static constexpr lp_id_t uint16Vec3Id = 3;
 static constexpr lp_id_t int64Vec2Id = 4;
 
 static constexpr uint32_t testSetId = 0;
+static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE,
+		testSetId);
 }
 
 
@@ -123,12 +125,27 @@ public:
 		return &dataset;
 	}
 
+	virtual LocalPoolObjectBase* getPoolObjectHandle(
+			lp_id_t localPoolId) override {
+		return &testUint8;
+	}
+
 	MessageQueueMockBase* getMockQueueHandle() const {
 		return dynamic_cast<MessageQueueMockBase*>(messageQueue);
 	}
 
-	void subscribeWrapperSetUpdate() {
-		hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
+	ReturnValue_t subscribeWrapperSetUpdate() {
+		return hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
+				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
+	}
+
+	ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) {
+		return hkManager.subscribeForUpdatePackets(lpool::testSid, diagnostics,
+				false, objects::HK_RECEIVER_MOCK);
+	}
+
+	ReturnValue_t subscribeWrapperVariableUpdate() {
+		return hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
 				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
 	}
 
diff --git a/unittest/tests/mocks/HkReceiverMock.h b/unittest/tests/mocks/HkReceiverMock.h
new file mode 100644
index 000000000..e7509c592
--- /dev/null
+++ b/unittest/tests/mocks/HkReceiverMock.h
@@ -0,0 +1,20 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_
+
+#include <fsfw/housekeeping/AcceptsHkPacketsIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+
+class HkReceiverMock: public SystemObject, public AcceptsHkPacketsIF {
+public:
+	HkReceiverMock(object_id_t objectId): SystemObject(objectId) {
+
+	}
+
+	MessageQueueId_t getHkQueue() const {
+		return MessageQueueIF::NO_QUEUE;
+	}
+};
+
+
+
+#endif /* FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_ */
diff --git a/unittest/tests/mocks/MessageQueueMockBase.h b/unittest/tests/mocks/MessageQueueMockBase.h
index 5a1573297..4792772fe 100644
--- a/unittest/tests/mocks/MessageQueueMockBase.h
+++ b/unittest/tests/mocks/MessageQueueMockBase.h
@@ -6,68 +6,81 @@
 #include <unittest/core/CatchDefinitions.h>
 #include <cstring>
 
+#include <queue>
 
 class MessageQueueMockBase: public MessageQueueIF {
 public:
-	MessageQueueId_t myQueueId = 0;
+	MessageQueueId_t myQueueId = tconst::testQueueId;
+	uint8_t messageSentCounter = 0;
 	bool defaultDestSet = false;
 	bool messageSent = false;
 
 
-	bool wasMessageSent() {
+	bool wasMessageSent(uint8_t* messageSentCounter = nullptr,
+			bool resetCounter = true) {
 		bool tempMessageSent = messageSent;
 		messageSent = false;
+		if(messageSentCounter != nullptr) {
+			*messageSentCounter = this->messageSentCounter;
+		}
+		if(resetCounter) {
+			this->messageSentCounter = 0;
+		}
 		return tempMessageSent;
 	}
 
 	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return sendMessage(myQueueId, message);
 		return HasReturnvaluesIF::RETURN_OK;
 	};
 	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom) {
-		(*message) = lastMessage;
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
+		return receiveMessage(message);
 	}
 	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
-		std::memcpy(message->getBuffer(), lastMessage.getBuffer(),
+		std::memcpy(message->getBuffer(), messagesSentQueue.front().getBuffer(),
 				message->getMessageSize());
-		lastMessage.clear();
+		messagesSentQueue.pop();
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	virtual ReturnValue_t flush(uint32_t* count) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	virtual MessageQueueId_t getLastPartner() const {
-		return tconst::testQueueId;
+		return myQueueId;
 	}
 	virtual MessageQueueId_t getId() const {
-		return tconst::testQueueId;
+		return myQueueId;
 	}
 	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		//return HasReturnvaluesIF::RETURN_OK;
+		return sendMessage(sendTo, message);
+	}
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		//return HasReturnvaluesIF::RETURN_OK;
+		return sendMessage(myQueueId, message);
+	}
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return sendMessage(myQueueId, message);
 	}
 	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
 		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		messageSentCounter++;
+		MessageQueueMessage& messageRef = *(
+				dynamic_cast<MessageQueueMessage*>(message));
+		messagesSentQueue.push(messageRef);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
@@ -81,9 +94,16 @@ public:
 	virtual bool isDefaultDestinationSet() const {
 		return defaultDestSet;
 	}
-private:
-	MessageQueueMessage lastMessage;
 
+	void clearMessages() {
+		while(not messagesSentQueue.empty()) {
+			messagesSentQueue.pop();
+		}
+	}
+
+private:
+	std::queue<MessageQueueMessage> messagesSentQueue;
+	//MessageQueueMessage lastMessage;
 };
 
 
diff --git a/unittest/user/testcfg/objects/systemObjectList.h b/unittest/user/testcfg/objects/systemObjectList.h
index da95617cc..88b92131c 100644
--- a/unittest/user/testcfg/objects/systemObjectList.h
+++ b/unittest/user/testcfg/objects/systemObjectList.h
@@ -21,6 +21,7 @@ namespace objects {
 		TEST_ECHO_COM_IF = 20,
 		TEST_DEVICE = 21,
 
+		HK_RECEIVER_MOCK = 22,
 		TEST_LOCAL_POOL_OWNER_BASE = 25
 	};
 }

From 1af28dd45737440a43cf4f8560e9d28ed3b9cd69 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 13:59:40 +0100
Subject: [PATCH 1404/1774] updated user folder for unittests

---
 unittest/user/unittest/CMakeLists.txt            | 1 +
 unittest/user/unittest/core/CatchDefinitions.cpp | 4 ++--
 unittest/user/unittest/core/CatchFactory.cpp     | 7 ++++++-
 3 files changed, 9 insertions(+), 3 deletions(-)
 create mode 100644 unittest/user/unittest/CMakeLists.txt

diff --git a/unittest/user/unittest/CMakeLists.txt b/unittest/user/unittest/CMakeLists.txt
new file mode 100644
index 000000000..ad6d4787c
--- /dev/null
+++ b/unittest/user/unittest/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(core)
diff --git a/unittest/user/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
index 02a935d23..531ee87b7 100644
--- a/unittest/user/unittest/core/CatchDefinitions.cpp
+++ b/unittest/user/unittest/core/CatchDefinitions.cpp
@@ -9,8 +9,8 @@ StorageManagerIF* tglob::getIpcStoreHandle() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;
 #else
-		fsfw::printError("Global object manager uninitialized");
-#endif
+		fsfw::printError("Global object manager uninitialized\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return nullptr;
 	}
 }
diff --git a/unittest/user/unittest/core/CatchFactory.cpp b/unittest/user/unittest/core/CatchFactory.cpp
index 0597f08c0..eabaa21df 100644
--- a/unittest/user/unittest/core/CatchFactory.cpp
+++ b/unittest/user/unittest/core/CatchFactory.cpp
@@ -10,6 +10,8 @@
 #include <fsfw/tmtcpacket/pus/TmPacketStored.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
+#include <fsfw/unittest/tests/datapoollocal/LocalPoolOwnerBase.h>
+#include <fsfw/unittest/tests/mocks/HkReceiverMock.h>
 
 /**
  * @brief Produces system objects.
@@ -30,6 +32,9 @@ void Factory::produce(void) {
 	new HealthTable(objects::HEALTH_TABLE);
 	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
 
+	new LocalPoolOwnerBase (objects::TEST_LOCAL_POOL_OWNER_BASE);
+	new HkReceiverMock(objects::HK_RECEIVER_MOCK);
+
 	{
 		PoolManager::LocalPoolConfig poolCfg = {
 		        {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
@@ -65,7 +70,7 @@ void Factory::setStaticFrameworkObjectIds() {
 	DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 	DeviceHandlerBase::rawDataReceiverId = objects::PUS_SERVICE_2_DEVICE_ACCESS;
 
-	LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
+	LocalDataPoolManager::defaultHkDestination = objects::HK_RECEIVER_MOCK;
 
 	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
 

From 69e931c07b8a6dbb7c3c0f665b33d8722cce8223 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 14:27:57 +0100
Subject: [PATCH 1405/1774] important logic fix

---
 datapoollocal/LocalDataPoolManager.cpp        |  6 +++-
 .../datapoollocal/LocalPoolManagerTest.cpp    | 18 +++++++++++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 31 +++++++++++++++----
 3 files changed, 48 insertions(+), 7 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 564604cd8..c12203f72 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -322,12 +322,16 @@ void LocalDataPoolManager::handleChangeResetLogic(
             continue;
         }
 
+        // only one update recipient, we can reset changes status immediately.
         if(changeInfo.updateCounter <= 1) {
             toReset->setChanged(false);
         }
-        if(changeInfo.currentUpdateCounter == 0) {
+        // All recipients have been notified, reset the changed flag.
+        if(changeInfo.currentUpdateCounter <= 1) {
             toReset->setChanged(false);
+            changeInfo.currentUpdateCounter = 0;
         }
+        // Not all recipiens have been notified yet, decrement.
         else {
             changeInfo.currentUpdateCounter--;
         }
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 2c797505e..bc07c9d97 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -60,7 +60,25 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
 		CHECK(messageSent.getCommand() == static_cast<int>(
 				HousekeepingMessage::HK_REPORT));
+		// clear message to avoid memory leak, our mock won't do it for us (yet)
 		CommandMessageCleaner::clearCommandMessage(&messageSent);
+
+		// now subscribe for variable update as well
+		REQUIRE(not poolOwner->dataset.hasChanged());
+		REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
+				retval::CATCH_OK);
+		lp_var_t<uint8_t>* poolVar = dynamic_cast<lp_var_t<uint8_t>*>(
+				poolOwner->getPoolObjectHandle(lpool::uint8VarId));
+		REQUIRE(poolVar != nullptr);
+		poolVar->setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 1);
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+
 	}
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 5ff146983..430c8b07f 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -2,6 +2,7 @@
 #define FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
 
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/LocalDataSet.h>
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/datapoollocal/LocalPoolVariable.h>
 #include <fsfw/datapoollocal/LocalPoolVector.h>
@@ -18,15 +19,16 @@ static constexpr lp_id_t uint16Vec3Id = 3;
 static constexpr lp_id_t int64Vec2Id = 4;
 
 static constexpr uint32_t testSetId = 0;
+static constexpr uint8_t dataSetMaxVariables = 10;
 static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE,
 		testSetId);
 }
 
 
-class LocalPoolTestDataSet: public StaticLocalDataSet<3> {
+class LocalPoolTestDataSet: public LocalDataSet {
 public:
 	LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
-		StaticLocalDataSet(owner, setId) {
+		LocalDataSet(owner, setId, lpool::dataSetMaxVariables) {
 	}
 
 	ReturnValue_t assignPointers() {
@@ -127,7 +129,24 @@ public:
 
 	virtual LocalPoolObjectBase* getPoolObjectHandle(
 			lp_id_t localPoolId) override {
-		return &testUint8;
+		if(localPoolId == lpool::uint8VarId) {
+			return &testUint8;
+		}
+		else if(localPoolId == lpool::uint16Vec3Id) {
+			return &testUint16Vec;
+		}
+		else if(localPoolId == lpool::floatVarId) {
+			return &testFloat;
+		}
+		else if(localPoolId == lpool::int64Vec2Id) {
+			return &testInt64Vec;
+		}
+		else if(localPoolId == lpool::uint32VarId) {
+			return &testUint32;
+		}
+		else {
+			return &testUint8;
+		}
 	}
 
 	MessageQueueMockBase* getMockQueueHandle() const {
@@ -144,9 +163,9 @@ public:
 				false, objects::HK_RECEIVER_MOCK);
 	}
 
-	ReturnValue_t subscribeWrapperVariableUpdate() {
-		return hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
-				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
+	ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) {
+		return hkManager.subscribeForVariableUpdateMessages(localPoolId,
+				MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false);
 	}
 
 	LocalDataPoolManager hkManager;

From 4fa9a1fe1934694999a031fc802119721f05bd93 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 14:33:02 +0100
Subject: [PATCH 1406/1774] added more tests

---
 .../datapoollocal/LocalPoolManagerTest.cpp      | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index bc07c9d97..ef8f7f333 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -17,6 +17,8 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 	REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK);
 	MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
 	REQUIRE(mqMock != nullptr);
+	CommandMessage messageSent;
+	uint8_t messagesSent = 0;
 
 
 	SECTION("BasicTest") {
@@ -27,8 +29,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		// Now the update message should be generated.
 		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
 		REQUIRE(mqMock->wasMessageSent() == true);
-		CommandMessage messageSent;
-		uint8_t messagesSent = 0;
+
 		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
 		CHECK(messageSent.getCommand() == static_cast<int>(
 				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
@@ -62,8 +63,10 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 				HousekeepingMessage::HK_REPORT));
 		// clear message to avoid memory leak, our mock won't do it for us (yet)
 		CommandMessageCleaner::clearCommandMessage(&messageSent);
+	}
 
-		// now subscribe for variable update as well
+	SECTION("AdvancedTests") {
+		// Subscribe for variable update as well
 		REQUIRE(not poolOwner->dataset.hasChanged());
 		REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
 				retval::CATCH_OK);
@@ -73,12 +76,20 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		poolVar->setChanged(true);
 		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
 
+		// Check update notification was sent.
 		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
 		CHECK(messagesSent == 1);
+		// Should have been reset.
+		CHECK(poolVar->hasChanged() == false);
 		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
 		CHECK(messageSent.getCommand() == static_cast<int>(
 				HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
 
+		// now subscribe for the dataset update (HK and update) again
+		REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
+		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
+
+
 	}
 }
 

From 6993415873b88b68e987ef7796e5f371a21fbef4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 14:54:05 +0100
Subject: [PATCH 1407/1774] more tests

---
 datapoollocal/LocalDataPoolManager.cpp        |  5 ++++
 datapoollocal/LocalDataPoolManager.h          |  6 +++++
 .../datapoollocal/LocalPoolManagerTest.cpp    | 25 +++++++++++++++++++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  |  4 +++
 unittest/tests/mocks/MessageQueueMockBase.h   | 13 +++++++++-
 5 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index c12203f72..da6e91a87 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -820,6 +820,11 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     return result;
 }
 
+void LocalDataPoolManager::clearReceiversList() {
+	// clear the vector completely and releases allocated memory.
+	HkReceivers().swap(hkReceiversMap);
+}
+
 void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 		const char* functionName, ReturnValue_t error, const char* errorPrint) {
 	if(errorPrint == nullptr) {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index eee4c5931..2ced2efd0 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -250,6 +250,12 @@ public:
     LocalDataPoolManager(const LocalDataPoolManager &) = delete;
     LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 
+    /**
+     * This function can be used to clear the receivers list. This is
+     * intended for test functions and not for regular operations, because
+     * the insertion operations allocate dynamically.
+     */
+    void clearReceiversList();
 private:
     LocalDataPool localPoolMap;
     //! Every housekeeping data manager has a mutex to protect access
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index ef8f7f333..2ea169b29 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -66,6 +66,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 	}
 
 	SECTION("AdvancedTests") {
+		poolOwner->resetSubscriptionList();
 		// Subscribe for variable update as well
 		REQUIRE(not poolOwner->dataset.hasChanged());
 		REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
@@ -89,7 +90,31 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
 		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
 
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		// now two messages should be sent.
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 2);
+		mqMock->clearMessages(true);
 
+		poolOwner->dataset.setChanged(true);
+		poolVar->setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		// now three messages should be sent.
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 3);
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::HK_REPORT));
+		CommandMessageCleaner::clearCommandMessage(&messageSent);
+		REQUIRE(mqMock->receiveMessage(&messageSent) ==
+				static_cast<int>(MessageQueueIF::EMPTY));
 	}
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 430c8b07f..a5389812b 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -168,6 +168,10 @@ public:
 				MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false);
 	}
 
+	void resetSubscriptionList() {
+		hkManager.clearReceiversList();
+	}
+
 	LocalDataPoolManager hkManager;
 	LocalPoolTestDataSet dataset;
 private:
diff --git a/unittest/tests/mocks/MessageQueueMockBase.h b/unittest/tests/mocks/MessageQueueMockBase.h
index 4792772fe..7b810b41f 100644
--- a/unittest/tests/mocks/MessageQueueMockBase.h
+++ b/unittest/tests/mocks/MessageQueueMockBase.h
@@ -40,6 +40,10 @@ public:
 		return receiveMessage(message);
 	}
 	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
+		if(messagesSentQueue.empty()) {
+			return MessageQueueIF::EMPTY;
+		}
+
 		std::memcpy(message->getBuffer(), messagesSentQueue.front().getBuffer(),
 				message->getMessageSize());
 		messagesSentQueue.pop();
@@ -95,8 +99,15 @@ public:
 		return defaultDestSet;
 	}
 
-	void clearMessages() {
+	void clearMessages(bool clearCommandMessages = true) {
 		while(not messagesSentQueue.empty()) {
+			if(clearCommandMessages) {
+				CommandMessage message;
+				std::memcpy(message.getBuffer(),
+						messagesSentQueue.front().getBuffer(),
+						message.getMessageSize());
+				message.clear();
+			}
 			messagesSentQueue.pop();
 		}
 	}

From 15b65b78e730d73a840d9708658a7d0d2817a19e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 14:57:56 +0100
Subject: [PATCH 1408/1774] ndentiation

---
 datapoollocal/LocalDataPoolManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index da6e91a87..19c940492 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -48,7 +48,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
 
     ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
     if(ipcStore == nullptr) {
-        // error, all destinations invalid
+    	// error, all destinations invalid
     	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
     			"initialize", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not set IPC store.");

From 63ce87acab188be447f820c421661487fda7b5a9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 14:59:03 +0100
Subject: [PATCH 1409/1774] more indentation corrections

---
 datapoollocal/LocalDataPoolManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 19c940492..2a0ec923c 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -65,7 +65,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
         else {
         	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
         			"initialize", QUEUE_OR_DESTINATION_INVALID);
-            return QUEUE_OR_DESTINATION_INVALID;
+        	return QUEUE_OR_DESTINATION_INVALID;
         }
     }
 

From 4bfbeead0024898b1e2139ec6ed4a877e60980c3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 15:04:47 +0100
Subject: [PATCH 1410/1774] additional doc

---
 unittest/tests/datapoollocal/LocalPoolManagerTest.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 2ea169b29..f497e6101 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -66,6 +66,8 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 	}
 
 	SECTION("AdvancedTests") {
+		// we need to reset the subscription list because the pool owner
+		// is a global object.
 		poolOwner->resetSubscriptionList();
 		// Subscribe for variable update as well
 		REQUIRE(not poolOwner->dataset.hasChanged());

From 7a053b6f72b50a3868019bcbc9af4f80c5f03d55 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:24:19 +0100
Subject: [PATCH 1411/1774] updated README

---
 README.md               | 130 +++++++---------------------------------
 doc/README-highlevel.md |  99 ++++++++++++++++++++++++++++++
 doc/README-osal.md      |  32 ++++++++++
 3 files changed, 153 insertions(+), 108 deletions(-)
 create mode 100644 doc/README-highlevel.md
 create mode 100644 doc/README-osal.md

diff --git a/README.md b/README.md
index 8552e0c81..f308ac9f4 100644
--- a/README.md
+++ b/README.md
@@ -9,121 +9,35 @@ The initial version of the Flight Software Framework was developed during
 the Flying Laptop Project by the University of Stuttgart in cooperation
 with Airbus Defence and Space GmbH.
 
-## Intended Use
+## Quick facts
 
-The framework is designed for systems, which communicate with external devices, perform control loops, receive telecommands and send telemetry, and need to maintain a high level of availability. 
-Therefore, a mode and health system provides control over the states of the software and the controlled devices. 
-In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 
+The framework is designed for systems, which communicate with external devices, perform control loops, receive telecommands and send telemetry, and need to maintain a high level of availability. Therefore, a mode and health system provides control over the states of the software and the controlled devices. In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 
 
-The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile Memory. 
-For reference, current Applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC.
-The `fsfw` was also tested on the STM32H743ZI-Nucleo board.
+The FSFW provides abstraction layers for operating systems to provide a uniform operating system abstraction layer (OSAL). Some components of this OSAL are required internally by the FSFW but is also very useful for developers to implement the same application logic on different operating systems with a uniform interface.
 
-## How to Use
+Currently, the FSFW provides the following OSALs:
+
+- Linux
+- Host 
+- FreeRTOS
+- RTEMS
+
+The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile Memory. For reference, current applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC. The `fsfw` was also successfully run on the STM32H743ZI-Nucleo board and on a Raspberry Pi.
+
+## Getting started
+
+The [FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example) provides a good starting point and a demo to see the FSFW capabilities and build it with the Make or the CMake build system. It is recommended to evaluate the FSFW by building and playing around with the demo application.
 
-The [FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example) provides a good starting point and a demo
-to see the FSFW capabilities and build it with the Make or the CMake build system. 
 Generally, the FSFW is included in a project by compiling the FSFW sources and providing
-a configuration folder and adding it to the include path. 
+a configuration folder and adding it to the include path. There are some functions like `printChar` which are different depending on the target architecture and need to be implemented by the mission developer.
+
 A template configuration folder was provided and can be copied into the project root to have
-a starting point. The [configuration section](doc/README-config.md#top) provides more specific information about
-the possible options.
+a starting point. The [configuration section](doc/README-config.md#top) provides more specific information about the possible options.
 
-## Structure
+## Index
 
-The general structure is driven by the usage of interfaces provided by objects. 
-The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
-The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
-This simplifies the instantiation of objects and allows the usage of some standard containers. 
-Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
-The fsfw uses run-time type information but exceptions are not allowed.
+[1. High-level overview](doc/README-highlevel.md#top)
+[2. Core components](doc/README-core.md#top)
+[3. OSAL overview](doc/README-osal.md#top)
 
-### Failure Handling
 
-Functions should return a defined ReturnValue_t to signal to the caller that something has gone wrong. 
-Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
-The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
-
-### OSAL
-
-The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
-A independent Host OSAL is in development which will provide abstraction for common type of 
-host OSes (tested for Linux and Windows, not for MacOS yet).
-The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
-
-### Core Components 
-
-The FSFW has following core components. More detailed informations can be found in the
-[core component section](doc/README-core.md#top):
-
-1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks with fixed timeslots
-2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID to the object handles.
-3. Static Stores: Different stores are provided to store data of variable size (like telecommands or small telemetry) in a pool structure without
-   using dynamic memory allocation. These pools are allocated up front.
-3. Clock: This module provided common time related functions
-4. EventManager: This module allows routing of events generated by `SystemObjects`
-5. HealthTable: A component which stores the health states of objects
-
-### Static Ids in the framework
-
-Some parts of the framework use a static routing address for communication. 
-An example setup of ids can be found in the example config in "defaultcft/fsfwconfig/objects/Factory::setStaticFrameworkObjectIds()".
-
-### Events
-
-Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. This works analog to the returnvalues.
-Every object that needs own EventIds has to get a unique SUBSYSTEM_ID. 
-Every SystemObject can call triggerEvent from the parent class.
-Therefore, event messages contain the specific EventId and the objectId of the object that has triggered.
-
-### Internal Communication
-
-Components communicate mostly over Message through Queues. 
-Those queues are created by calling the singleton QueueFactory::instance()->create(). 
-
-### External Communication
-
-The external communication with the mission control system is mostly up to the user implementation.
-The FSFW provides PUS Services which can be used to but don't need to be used. 
-The services can be seen as a conversion from a TC to a message based communication and back.
-
-#### CCSDS Frames, CCSDS Space Packets and PUS
-
-If the communication is based on CCSDS Frames and Space Packets, several classes can be used to distributed the packets to the corresponding services. Those can be found in tcdistribution. 
-If Space Packets are used, a timestamper must be created. 
-An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
-
-#### Device Handlers
-
-DeviceHandlers are another important component of the FSFW. 
-The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
-By separating the underlying Communication Interface with DeviceCommunicationIF, a device handler (DH) can be tested on different hardware.
-The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
-Device Handlers can be created by overriding `DeviceHandlerBase`. 
-A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
-More information on DeviceHandlers can be found in the related [documentation section](doc/README-devicehandlers.md#top).
-
-#### Modes, Health
-
-The two interfaces HasModesIF and HasHealthIF provide access for commanding and monitoring of components.
-On-board Mode Management is implement in hierarchy system. 
-DeviceHandlers and Controllers are the lowest part of the hierarchy. 
-The next layer are Assemblies. Those assemblies act as a component which handle redundancies of handlers. 
-Assemblies share a common core with the next level which are the Subsystems. 
-
-Those Assemblies are intended to act as auto-generated components from a database which describes the subsystem modes. 
-The definitions contain transition and target tables which contain the DH, Assembly and Controller Modes to be commanded.
-Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a switch into any higher AOCS mode might first turn on the sensors, than the actuators and the controller as last component. 
-The target table is used to describe the state that is checked continuously by the subsystem. 
-All of this allows System Modes to be generated as Subsystem object as well from the same database. 
-This System contains list of subsystem modes in the transition and target tables. 
-Therefore, it allows a modular system to create system modes and easy commanding of those, because only the highest components must be commanded.
-
-The health state represents if the component is able to perform its tasks. 
-This can be used to signal the system to avoid using this component instead of a redundant one.
-The on-board FDIR uses the health state for isolation and recovery. 
-
-## Unit Tests
-
-Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. 
-See README.md in the unittest Folder.
\ No newline at end of file
diff --git a/doc/README-highlevel.md b/doc/README-highlevel.md
new file mode 100644
index 000000000..fac89c536
--- /dev/null
+++ b/doc/README-highlevel.md
@@ -0,0 +1,99 @@
+# High-level overview
+
+## Structure
+
+The general structure is driven by the usage of interfaces provided by objects. 
+The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
+The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
+This simplifies the instantiation of objects and allows the usage of some standard containers. 
+Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
+The fsfw uses run-time type information but exceptions are not allowed.
+
+### Failure Handling
+
+Functions should return a defined ReturnValue_t to signal to the caller that something has gone wrong. 
+Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
+The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
+
+### OSAL
+
+The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
+The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
+The [OSAL README](doc/README-osal.md#top) provides more detailed information on provided components and how to use them.
+
+### Core Components 
+
+The FSFW has following core components. More detailed informations can be found in the
+[core component section](doc/README-core.md#top):
+
+1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks with fixed timeslots
+2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID to the object handles.
+3. Static Stores: Different stores are provided to store data of variable size (like telecommands or small telemetry) in a pool structure without
+   using dynamic memory allocation. These pools are allocated up front.
+3. Clock: This module provided common time related functions
+4. EventManager: This module allows routing of events generated by `SystemObjects`
+5. HealthTable: A component which stores the health states of objects
+
+### Static IDs in the framework
+
+Some parts of the framework use a static routing address for communication. 
+An example setup of ids can be found in the example config in "defaultcft/fsfwconfig/objects/Factory::setStaticFrameworkObjectIds()".
+
+### Events
+
+Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. This works analog to the returnvalues.
+Every object that needs own EventIds has to get a unique SUBSYSTEM_ID. 
+Every SystemObject can call triggerEvent from the parent class.
+Therefore, event messages contain the specific EventId and the objectId of the object that has triggered.
+
+### Internal Communication
+
+Components communicate mostly over Message through Queues. 
+Those queues are created by calling the singleton QueueFactory::instance()->create(). 
+
+### External Communication
+
+The external communication with the mission control system is mostly up to the user implementation.
+The FSFW provides PUS Services which can be used to but don't need to be used. 
+The services can be seen as a conversion from a TC to a message based communication and back.
+
+#### CCSDS Frames, CCSDS Space Packets and PUS
+
+If the communication is based on CCSDS Frames and Space Packets, several classes can be used to distributed the packets to the corresponding services. Those can be found in tcdistribution. 
+If Space Packets are used, a timestamper must be created. 
+An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
+
+#### Device Handlers
+
+DeviceHandlers are another important component of the FSFW. 
+The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
+By separating the underlying Communication Interface with DeviceCommunicationIF, a device handler (DH) can be tested on different hardware.
+The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
+Device Handlers can be created by overriding `DeviceHandlerBase`. 
+A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
+More information on DeviceHandlers can be found in the related [documentation section](doc/README-devicehandlers.md#top).
+
+#### Modes, Health
+
+The two interfaces HasModesIF and HasHealthIF provide access for commanding and monitoring of components.
+On-board Mode Management is implement in hierarchy system. 
+DeviceHandlers and Controllers are the lowest part of the hierarchy. 
+The next layer are Assemblies. Those assemblies act as a component which handle redundancies of handlers. 
+Assemblies share a common core with the next level which are the Subsystems. 
+
+Those Assemblies are intended to act as auto-generated components from a database which describes the subsystem modes. 
+The definitions contain transition and target tables which contain the DH, Assembly and Controller Modes to be commanded.
+Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a switch into any higher AOCS mode might first turn on the sensors, than the actuators and the controller as last component. 
+The target table is used to describe the state that is checked continuously by the subsystem. 
+All of this allows System Modes to be generated as Subsystem object as well from the same database. 
+This System contains list of subsystem modes in the transition and target tables. 
+Therefore, it allows a modular system to create system modes and easy commanding of those, because only the highest components must be commanded.
+
+The health state represents if the component is able to perform its tasks. 
+This can be used to signal the system to avoid using this component instead of a redundant one.
+The on-board FDIR uses the health state for isolation and recovery. 
+
+## Unit Tests
+
+Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. More information on how to run these tests can be found in the separate
+[`fsfw_tests` reposoitory](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_tests)
diff --git a/doc/README-osal.md b/doc/README-osal.md
new file mode 100644
index 000000000..206596ac4
--- /dev/null
+++ b/doc/README-osal.md
@@ -0,0 +1,32 @@
+# Operating System Abstraction Layer (OSAL)
+
+Some specific information on the provided OSALs are provided.
+
+## Linux OSAL
+
+This OSAL can be used to compile for Linux host systems like Ubuntu 20.04 or for 
+embedded Linux targets like the Raspberry Pi. This OSAL generally requires threading support
+and real-time functionalities. This is generally done by adding `-lrt` and `-lpthread` to the linked libraries in the compilation process. The CMake build support provided will do this automatically for the `fsfw` target. It should be noted that most UNIX systems need to be configured specifically to allow the real-time functionalities required by the FSFW.
+
+More information on how to set up a Linux system accordingly can be found in the 
+[Linux README of the FSFW example application](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example/src/branch/master/doc/README-linux.md#top)
+
+## Hosted OSAL
+
+This is the newest OSAL. Support for Semaphores has not been implemented yet and will propably be implemented as soon as C++20 with Semaphore support has matured. This OSAL can be used to run the FSFW on any host system, but currently has only been tested on Windows 10 and Ubuntu 20.04. Unlike the other OSALs, it uses dynamic memory allocation (e.g. for the message queue implementation). Cross-platform serial port (USB) support might be added soon.
+
+## FreeRTOS OSAL
+
+FreeRTOS is not included and the developer needs to take care of compiling the FreeRTOS sources and adding the `FreeRTOSConfig.h` file location to the include path. This OSAL has only been tested extensively with the pre-emptive scheduler configuration so far but it should in principle also be possible to use a cooperative scheduler. It is recommended to use the `heap_4` allocation scheme. When using newlib (nano), it is also recommended to add `#define configUSE_NEWLIB_REENTRANT` to the FreeRTOS configuration file to ensure thread-safety.
+
+When using this OSAL, developers also need to provide an implementation for the `vRequestContextSwitchFromISR` function. This has been done because the call to request a context switch from an ISR is generally located in the `portmacro.h` header and is different depending on the target architecture or device.
+
+## RTEMS OSAL
+
+The RTEMS OSAL was the first implemented OSAL which is also used on the active satellite Flying Laptop.
+
+## TCP/IP socket abstraction
+
+The Linux and Host OSAL provide abstraction layers for the socket API. Currently, only UDP sockets have been imlemented. This is very useful to test TMTC handling either on the host computer directly (targeting localhost with a TMTC application) or on embedded Linux devices, sending TMTC packets via Ethernet.
+
+

From 952438f2528aa792638348fb5cce90a36e116837 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:25:19 +0100
Subject: [PATCH 1412/1774] README

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f308ac9f4..d74c4c76d 100644
--- a/README.md
+++ b/README.md
@@ -22,7 +22,7 @@ Currently, the FSFW provides the following OSALs:
 - FreeRTOS
 - RTEMS
 
-The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile Memory. For reference, current applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC. The `fsfw` was also successfully run on the STM32H743ZI-Nucleo board and on a Raspberry Pi.
+The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile Memory. For reference, current applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC. The `fsfw` was also successfully run on the STM32H743ZI-Nucleo board and on a Raspberry Pi and is currently running on the active satellite mission Flying Laptop.
 
 ## Getting started
 

From 6dde0ab8f66dc144b0323437f93e3e8d689eb41f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:25:51 +0100
Subject: [PATCH 1413/1774] readme update

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index d74c4c76d..ba64f7571 100644
--- a/README.md
+++ b/README.md
@@ -36,8 +36,8 @@ a starting point. The [configuration section](doc/README-config.md#top) provides
 
 ## Index
 
-[1. High-level overview](doc/README-highlevel.md#top)
-[2. Core components](doc/README-core.md#top)
-[3. OSAL overview](doc/README-osal.md#top)
+[1. High-level overview](doc/README-highlevel.md#top) <br>
+[2. Core components](doc/README-core.md#top) <br>
+[3. OSAL overview](doc/README-osal.md#top) <br>
 
 

From 368b42c7b031cbc9c4689ed41576249b51c396f2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:26:48 +0100
Subject: [PATCH 1414/1774] formatting improvements

---
 doc/README-core.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/doc/README-core.md b/doc/README-core.md
index c47ae0f29..6431b8311 100644
--- a/doc/README-core.md
+++ b/doc/README-core.md
@@ -16,9 +16,8 @@ Flight Software Framework
 * A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
 A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
 
-``` c++
-	template <typename T> T* ObjectManagerIF::get( object_id_t id )
-
+```cpp
+template <typename T> T* ObjectManagerIF::get( object_id_t id )
 ```
 * A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
 By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.

From 1f901a14ffcb8af674dfc7703b79eefb78bb5cf9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:28:13 +0100
Subject: [PATCH 1415/1774] updated osal readme

---
 doc/README-osal.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/README-osal.md b/doc/README-osal.md
index 206596ac4..6f8ce60f5 100644
--- a/doc/README-osal.md
+++ b/doc/README-osal.md
@@ -6,7 +6,7 @@ Some specific information on the provided OSALs are provided.
 
 This OSAL can be used to compile for Linux host systems like Ubuntu 20.04 or for 
 embedded Linux targets like the Raspberry Pi. This OSAL generally requires threading support
-and real-time functionalities. This is generally done by adding `-lrt` and `-lpthread` to the linked libraries in the compilation process. The CMake build support provided will do this automatically for the `fsfw` target. It should be noted that most UNIX systems need to be configured specifically to allow the real-time functionalities required by the FSFW.
+and real-time functionalities. For most UNIX systems, this is done by adding `-lrt` and `-lpthread` to the linked libraries in the compilation process. The CMake build support provided will do this automatically for the `fsfw` target. It should be noted that most UNIX systems need to be configured specifically to allow the real-time functionalities required by the FSFW.
 
 More information on how to set up a Linux system accordingly can be found in the 
 [Linux README of the FSFW example application](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example/src/branch/master/doc/README-linux.md#top)

From c956feafd6fc5932570181cde9e51b525f20980c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:30:31 +0100
Subject: [PATCH 1416/1774] added new readme which will be filled later

---
 doc/README-devicehandlers.md | 2 +-
 doc/README-localpools.md     | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)
 create mode 100644 doc/README-localpools.md

diff --git a/doc/README-devicehandlers.md b/doc/README-devicehandlers.md
index 6e737cc5a..8b6551aa0 100644
--- a/doc/README-devicehandlers.md
+++ b/doc/README-devicehandlers.md
@@ -1 +1 @@
-## FSFW DeviceHandlers
\ No newline at end of file
+## Device Handlers
diff --git a/doc/README-localpools.md b/doc/README-localpools.md
new file mode 100644
index 000000000..8dd83385e
--- /dev/null
+++ b/doc/README-localpools.md
@@ -0,0 +1,3 @@
+## Local Data Pools
+
+

From e497c4ab1505f7438c96283a391f3b71de81fd8e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:34:21 +0100
Subject: [PATCH 1417/1774] added new reamde file stubs

---
 README.md                 | 5 +++++
 doc/README-controllers.md | 1 +
 doc/README-pus.md         | 1 +
 3 files changed, 7 insertions(+)
 create mode 100644 doc/README-controllers.md
 create mode 100644 doc/README-pus.md

diff --git a/README.md b/README.md
index ba64f7571..fb3be429e 100644
--- a/README.md
+++ b/README.md
@@ -39,5 +39,10 @@ a starting point. The [configuration section](doc/README-config.md#top) provides
 [1. High-level overview](doc/README-highlevel.md#top) <br>
 [2. Core components](doc/README-core.md#top) <br>
 [3. OSAL overview](doc/README-osal.md#top) <br>
+[4. PUS services](doc/README-pus.md#top) <br>
+[5. Device Handler overview](doc/README-devicehandlers.md#top) <br>
+[6. Controller overview](doc/README-controllers.md#top) <br>
+[7. Local Data Pools](doc/README-localpools.md#top) <br>
+
 
 
diff --git a/doc/README-controllers.md b/doc/README-controllers.md
new file mode 100644
index 000000000..7af0652d4
--- /dev/null
+++ b/doc/README-controllers.md
@@ -0,0 +1 @@
+## Controllers
diff --git a/doc/README-pus.md b/doc/README-pus.md
new file mode 100644
index 000000000..928d2eda0
--- /dev/null
+++ b/doc/README-pus.md
@@ -0,0 +1 @@
+## PUS Services

From 60102465927399d7c66d4bd1e8a379770325212b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 16:21:41 +0100
Subject: [PATCH 1418/1774] rearchitectured a little bit

---
 datapool/PoolDataSetBase.cpp           | 15 ++++---
 datapool/PoolDataSetBase.h             |  4 +-
 datapoollocal/LocalPoolDataSetBase.cpp | 58 +++++++-------------------
 datapoollocal/LocalPoolDataSetBase.h   | 42 +++++++------------
 4 files changed, 43 insertions(+), 76 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 7731a8df4..010697854 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -88,7 +88,8 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 	{
 		if(protectEveryReadCommitCall) {
 			result = registeredVariables[count]->read(
-					MutexIF::TimeoutType::WAITING, mutexTimeout);
+					timeoutTypeForSingleVars,
+					mutexTimeoutForSingleVars);
 		}
 		else {
 			result = registeredVariables[count]->readWithoutLock();
@@ -122,7 +123,8 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(
 				!= PoolVariableIF::NO_PARAMETER) {
 			if(protectEveryReadCommitCall) {
 				registeredVariables[count]->commit(
-						MutexIF::TimeoutType::WAITING, mutexTimeout);
+						timeoutTypeForSingleVars,
+						mutexTimeoutForSingleVars);
 			}
 			else {
 				registeredVariables[count]->commitWithoutLock();
@@ -144,7 +146,8 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(
 				!= PoolVariableIF::NO_PARAMETER) {
 			if(protectEveryReadCommitCall) {
 				result = registeredVariables[count]->commit(
-						MutexIF::TimeoutType::WAITING, mutexTimeout);
+						timeoutTypeForSingleVars,
+						mutexTimeoutForSingleVars);
 			}
 			else {
 				result = registeredVariables[count]->commitWithoutLock();
@@ -219,7 +222,9 @@ PoolVariableIF** PoolDataSetBase::getContainer() const {
 }
 
 void PoolDataSetBase::setReadCommitProtectionBehaviour(
-		bool protectEveryReadCommit, uint32_t mutexTimeout) {
+		bool protectEveryReadCommit, MutexIF::TimeoutType timeoutType,
+		uint32_t mutexTimeout) {
 	this->protectEveryReadCommitCall = protectEveryReadCommit;
-	this->mutexTimeout = mutexTimeout;
+	this->timeoutTypeForSingleVars = timeoutType;
+	this->mutexTimeoutForSingleVars = mutexTimeout;
 }
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 665f4b33c..6f3c5fa4b 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -127,6 +127,7 @@ protected:
 	 * @param mutexTimeout
 	 */
 	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
 			uint32_t mutexTimeout = 20);
 
 	/**
@@ -161,7 +162,8 @@ protected:
 
 private:
 	bool protectEveryReadCommitCall = false;
-	uint32_t mutexTimeout = 20;
+	MutexIF::TimeoutType timeoutTypeForSingleVars;
+	uint32_t mutexTimeoutForSingleVars = 20;
 
 	ReturnValue_t readVariable(uint16_t count);
 	void handleAlreadyReadDatasetCommit(
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index af492146d..006239f66 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -19,15 +19,16 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
                 << "invalid!" << std::endl;
 #else
         fsfw::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-                "invalid!\n\r");
+                "invalid!\n");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
     }
-    hkManager = hkOwner->getHkManagerHandle();
+    LocalDataPoolManager* hkManager = hkOwner->getHkManagerHandle();
+    mutexIfSingleDataCreator = hkManager->getMutexHandle();
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
 
-    mutex = MutexFactory::instance()->createMutex();
+    //mutex = MutexFactory::instance()->createMutex();
 
     // Data creators get a periodic helper for periodic HK data generation.
     if(periodicHandling) {
@@ -41,34 +42,29 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
-    if(hkOwner != nullptr) {
-    	hkManager = hkOwner->getHkManagerHandle();
-    }
+    LocalDataPoolManager* hkManager = hkOwner->getHkManagerHandle();
+    mutexIfSingleDataCreator = hkManager->getMutexHandle();
     this->sid = sid;
-
-    mutex = MutexFactory::instance()->createMutex();
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(
 		PoolVariableIF **registeredVariablesArray,
-		const size_t maxNumberOfVariables, bool protectFunctions):
+		const size_t maxNumberOfVariables):
 		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-	if(protectFunctions) {
-	    mutex = MutexFactory::instance()->createMutex();
-	}
-
 }
 
 
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
+	if(periodicHelper != nullptr) {
+		delete periodicHelper;
+	}
 }
 
 ReturnValue_t LocalPoolDataSetBase::lockDataPool(
 		MutexIF::TimeoutType timeoutType,
 		uint32_t timeoutMs) {
-	if(hkManager != nullptr) {
-	    MutexIF* poolMutex = hkManager->getMutexHandle();
-	    return poolMutex->lockMutex(timeoutType, timeoutMs);
+	if(mutexIfSingleDataCreator != nullptr) {
+	    return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -146,9 +142,8 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-	if(hkManager != nullptr) {
-	    MutexIF* mutex = hkManager->getMutexHandle();
-	    return mutex->unlockMutex();
+	if(mutexIfSingleDataCreator != nullptr) {
+	    return mutexIfSingleDataCreator->unlockMutex();
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -268,19 +263,10 @@ void LocalPoolDataSetBase::initializePeriodicHelper(
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-	if(mutex == nullptr) {
-		this->changed = changed;
-		return;
-	}
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
     this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
-	if(mutex == nullptr) {
-		return changed;
-	}
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
     return changed;
 }
 
@@ -302,32 +288,16 @@ bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 }
 
 bool LocalPoolDataSetBase::isValid() const {
-	if(mutex == nullptr) {
-		return this->valid;
-	}
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
     return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
-	mutex->lockMutex(timeoutType, mutexTimeout);
     if(setEntriesRecursively) {
         for(size_t idx = 0; idx < this->getFillCount(); idx++) {
             registeredVariables[idx] -> setValid(valid);
         }
     }
     this->valid = valid;
-    mutex->unlockMutex();
 }
 
-void LocalPoolDataSetBase::setReadCommitProtectionBehaviour(
-		bool protectEveryReadCommit, uint32_t mutexTimeout) {
-	PoolDataSetBase::setReadCommitProtectionBehaviour(protectEveryReadCommit,
-			mutexTimeout);
-}
 
-void LocalPoolDataSetBase::setDataSetMutexTimeout(
-		MutexIF::TimeoutType timeoutType, uint32_t mutexTimeout) {
-	this->timeoutType = timeoutType;
-	this->mutexTimeout = mutexTimeout;
-}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index b44f607ff..fdd8b3c75 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -57,7 +57,8 @@ public:
 	        const size_t maxNumberOfVariables, bool periodicHandling = true);
 
 	/**
-	 * @brief	Constructor for users of local pool data.
+	 * @brief	Constructor for users of the local pool data, which need
+	 *          to access data created by one HK manager.
 	 * @details
 	 * @param sid Unique identifier of dataset consisting of object ID and
 	 * set ID.
@@ -68,13 +69,22 @@ public:
 	        const size_t maxNumberOfVariables);
 
 	/**
-	 * Simple constructor, if the dataset is not owner permanently by
-	 * a class with a HK manager.
+	 * Simple constructor, if the dataset is not the owner by
+	 * a class with a HK manager. This function should also be called by
+	 * classes which needs to access pool variables from different creators.
+	 *
+	 * If the class is intended to access pool variables from different
+	 * creators, the third argument should be set to true. The mutex
+	 * properties can be set with #setReadCommitProtectionBehaviour .
 	 * @param registeredVariablesArray
 	 * @param maxNumberOfVariables
+	 * @param protectEveryReadCommitCall If the pool variables are created by
+	 * multiple creators, this flag can be set to protect all read and
+	 * commit calls separately.
 	 */
 	LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables, bool protectFunctions = true);
+	        const size_t maxNumberOfVariables,
+			bool protectEveryReadCommitCall = true);
 
 	/**
 	 * @brief	The destructor automatically manages writing the valid
@@ -86,19 +96,6 @@ public:
 	 */
 	~LocalPoolDataSetBase();
 
-	/**
-	 * If the data is pulled from different local data pools, every read and
-	 * commit call should be mutex protected for thread safety.
-	 * This can be specified with the second parameter.
-	 * @param dataCreator
-	 * @param protectEveryReadCommit
-	 */
-	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
-			uint32_t mutexTimeout = 20);
-
-	void setDataSetMutexTimeout(MutexIF::TimeoutType timeoutType,
-			uint32_t mutexTimeout);
-
 	void setValidityBufferGeneration(bool withValidityBuffer);
 
 	sid_t getSid() const;
@@ -150,13 +147,8 @@ public:
 
 protected:
 	sid_t sid;
-	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-	uint32_t mutexTimeout = 20;
-	/**
-	 * This mutex is required because the dataset can potentially be accessed
-	 * by multiple threads for information like change status or validity.
-	 */
-	MutexIF* mutex = nullptr;
+	//! This mutex is used if the data is created by one object only.
+	MutexIF* mutexIfSingleDataCreator = nullptr;
 
 	bool diagnostic = false;
 	void setDiagnostic(bool diagnostics);
@@ -211,8 +203,6 @@ protected:
 	 */
 	ReturnValue_t unlockDataPool() override;
 
-	LocalDataPoolManager* hkManager = nullptr;
-
 	/**
 	 * Set n-th bit of a byte, with n being the position from 0
 	 * (most significant bit) to 7 (least significant bit)

From af7def3368a7e1ed7cec29242bc265c5c17bffd3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 16:26:46 +0100
Subject: [PATCH 1419/1774] some bugfixes

---
 datapoollocal/LocalPoolDataSetBase.cpp | 3 ++-
 internalError/InternalErrorDataset.h   | 6 +++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 006239f66..163ef3420 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -49,8 +49,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(
 		PoolVariableIF **registeredVariablesArray,
-		const size_t maxNumberOfVariables):
+		const size_t maxNumberOfVariables, bool protectEveryReadCommitCall):
 		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+	this->setReadCommitProtectionBehaviour(protectEveryReadCommitCall);
 }
 
 
diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
index fa91116d4..bd9062ed5 100644
--- a/internalError/InternalErrorDataset.h
+++ b/internalError/InternalErrorDataset.h
@@ -21,11 +21,11 @@ public:
     InternalErrorDataset(object_id_t objectId):
            StaticLocalDataSet(sid_t(objectId , ERROR_SET_ID)) {}
 
-    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(sid.objectId,
     		TM_HITS, this);
-    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(sid.objectId,
     		QUEUE_HITS, this);
-    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(sid.objectId,
     		STORE_HITS, this);
 };
 

From 5e251705f682642b683b1b91bae7c7a5cce9bce8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 16:33:02 +0100
Subject: [PATCH 1420/1774] getter function for object iD

---
 datapoollocal/LocalPoolDataSetBase.cpp | 29 +++++++++++++++++++-------
 datapoollocal/LocalPoolDataSetBase.h   |  2 ++
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 163ef3420..8a39823ea 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -23,13 +23,15 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
     }
-    LocalDataPoolManager* hkManager = hkOwner->getHkManagerHandle();
-    mutexIfSingleDataCreator = hkManager->getMutexHandle();
+    hkManager = hkOwner->getHkManagerHandle();
+
+    if(hkManager != nullptr) {
+        mutexIfSingleDataCreator = hkManager->getMutexHandle();
+    }
+
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
 
-    //mutex = MutexFactory::instance()->createMutex();
-
     // Data creators get a periodic helper for periodic HK data generation.
     if(periodicHandling) {
         periodicHelper = new PeriodicHousekeepingHelper(this);
@@ -42,8 +44,13 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
-    LocalDataPoolManager* hkManager = hkOwner->getHkManagerHandle();
-    mutexIfSingleDataCreator = hkManager->getMutexHandle();
+    if(hkOwner != nullptr) {
+        hkManager = hkOwner->getHkManagerHandle();
+    }
+
+    if(hkManager != nullptr) {
+        mutexIfSingleDataCreator = hkManager->getMutexHandle();
+    }
     this->sid = sid;
 }
 
@@ -301,4 +308,12 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     this->valid = valid;
 }
 
-
+object_id_t LocalPoolDataSetBase::getCreatorObjectId(object_id_t objectId) {
+	if(hkManager != nullptr) {
+		HasLocalDataPoolIF* owner = hkManager->getOwner();
+		if(owner != nullptr) {
+			return owner->getObjectId();
+		}
+	}
+	return objects::NO_OBJECT;
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index fdd8b3c75..ccbf7b96e 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -145,6 +145,7 @@ public:
 	void setChanged(bool changed) override;
 	bool hasChanged() const override;
 
+	object_id_t getCreatorObjectId(object_id_t objectId);
 protected:
 	sid_t sid;
 	//! This mutex is used if the data is created by one object only.
@@ -211,6 +212,7 @@ protected:
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
+	LocalDataPoolManager* hkManager = nullptr;
 
 };
 

From ef9ad60ba8a79be6e32f24aee9f6d2c3cb0c1d0d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 16:38:25 +0100
Subject: [PATCH 1421/1774] doc update

---
 datapoollocal/LocalPoolDataSetBase.h | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index ccbf7b96e..77a22f147 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -58,8 +58,10 @@ public:
 
 	/**
 	 * @brief	Constructor for users of the local pool data, which need
-	 *          to access data created by one HK manager.
+	 *          to access data created by one (!) HK manager.
 	 * @details
+	 * Unlike the first constructor, no component for periodic handling
+	 * will be initiated.
 	 * @param sid Unique identifier of dataset consisting of object ID and
 	 * set ID.
 	 * @param registeredVariablesArray
@@ -69,9 +71,13 @@ public:
 	        const size_t maxNumberOfVariables);
 
 	/**
-	 * Simple constructor, if the dataset is not the owner by
-	 * a class with a HK manager. This function should also be called by
-	 * classes which needs to access pool variables from different creators.
+	 * @brief	Simple constructor, if the dataset is not the owner by
+	 * 			a class with a HK manager.
+	 * @details
+	 * This constructor won't create components required for periodic handling
+	 * and it also won't try to deduce the HK manager because no SID is
+	 * supplied. This function should therefore be called by classes which need
+	 * to access pool variables from different creators.
 	 *
 	 * If the class is intended to access pool variables from different
 	 * creators, the third argument should be set to true. The mutex

From 217866c042d92bdfe7ea8bccab4338fd22b2bfda Mon Sep 17 00:00:00 2001
From: NguSa1 <sa.nguyen@gmx.de>
Date: Mon, 11 Jan 2021 19:44:07 +0100
Subject: [PATCH 1422/1774] SubscriptIF implementation started

---
 datapoollocal/LocalDataPoolManager.h          | 14 ++--
 .../ProvidesDataPoolSubscriptionIF.h          | 79 +++++++++++++++++++
 2 files changed, 88 insertions(+), 5 deletions(-)
 create mode 100644 datapoollocal/ProvidesDataPoolSubscriptionIF.h

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 0e98b90cb..d4e2052cb 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 #define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 
+#include <fsfw/datapoollocal/ProvidesDataPoolSubscriptionIF.h>
 #include "HasLocalDataPoolIF.h"
 
 #include "../housekeeping/HousekeepingPacketDownlink.h"
@@ -47,11 +48,13 @@ class HousekeepingPacketUpdate;
  * Each pool entry has a valid state too.
  * @author 		R. Mueller
  */
-class LocalDataPoolManager {
+class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF {
 	template<typename T> friend class LocalPoolVariable;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
+
+
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
@@ -61,6 +64,7 @@ public:
     static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x02);
     static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x03);
 
+
     /**
      * This constructor is used by a class which wants to implement
      * a personal local data pool. The queueToUse can be supplied if it
@@ -116,7 +120,7 @@ public:
 	 */
 	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
 			float collectionInterval, bool isDiagnostics,
-			object_id_t packetDestination = defaultHkDestination);
+			object_id_t packetDestination = defaultHkDestination) override;
 
 	/**
 	 * @brief   Subscribe for the  generation of packets if the dataset
@@ -130,7 +134,7 @@ public:
 	 */
     ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool reportingEnabled,
             bool isDiagnostics,
-            object_id_t packetDestination = defaultHkDestination);
+            object_id_t packetDestination = defaultHkDestination) override;
 
 	/**
 	 * @brief   Subscribe for a notification message which will be sent
@@ -149,7 +153,7 @@ public:
 	ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
 	        object_id_t destinationObject,
 	        MessageQueueId_t targetQueueId,
-	        bool generateSnapshot);
+	        bool generateSnapshot) override;
 
     /**
      * @brief   Subscribe for an notification message which will be sent if a
@@ -168,7 +172,7 @@ public:
     ReturnValue_t subscribeForVariableUpdateMessages(const lp_id_t localPoolId,
             object_id_t destinationObject,
             MessageQueueId_t targetQueueId,
-            bool generateSnapshot);
+            bool generateSnapshot) override;
 
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
new file mode 100644
index 000000000..6f96d5180
--- /dev/null
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -0,0 +1,79 @@
+#include <fsfw/datapoollocal/locPoolDefinitions.h>
+#include <fsfw/ipc/messageQueueDefinitions.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+
+
+class ProvidesDataPoolSubscriptionIF{
+public:
+	virtual ~ProvidesDataPoolSubscriptionIF(){};
+
+	/**
+	 * @brief   Subscribe for the generation of periodic packets.
+	 * @details
+	 * This subscription mechanism will generally be used by the data creator
+	 * to generate housekeeping packets which are downlinked directly.
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid,
+			bool enableReporting,
+			float collectionInterval, bool isDiagnostics,
+			object_id_t packetDestination) = 0;
+
+
+	/**
+	 * @brief   Subscribe for the  generation of packets if the dataset
+	 *          is marked as changed.
+	 * @details
+	 * This subscription mechanism will generally be used by the data creator.
+	 * @param sid
+	 * @param isDiagnostics
+	 * @param packetDestination
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForUpdatePackets(sid_t sid,
+			bool reportingEnabled,
+			bool isDiagnostics,
+			object_id_t packetDestination) = 0;
+
+
+	/**
+	 * @brief   Subscribe for a notification message which will be sent
+	 *          if a dataset has changed.
+	 * @details
+	 * This subscription mechanism will generally be used internally by
+	 * other software components.
+	 * @param setId     Set ID of the set to receive update messages from.
+	 * @param destinationObject
+	 * @param targetQueueId
+	 * @param generateSnapshot If this is set to true, a copy of the current
+	 * data with a timestamp will be generated and sent via message.
+	 * Otherwise, only an notification message is sent.
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
+			object_id_t destinationObject,
+			MessageQueueId_t targetQueueId,
+			bool generateSnapshot) = 0;
+
+	/**
+	 * @brief   Subscribe for an notification message which will be sent if a
+	 *          pool variable has changed.
+	 * @details
+	 * This subscription mechanism will generally be used internally by
+	 * other software components.
+	 * @param localPoolId Pool ID of the pool variable
+	 * @param destinationObject
+	 * @param targetQueueId
+	 * @param generateSnapshot If this is set to true, a copy of the current
+	 * data with a timestamp will be generated and sent via message.
+	 * Otherwise, only an notification message is sent.
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForVariableUpdateMessages(
+			const lp_id_t localPoolId,
+			object_id_t destinationObject,
+			MessageQueueId_t targetQueueId,
+			bool generateSnapshot) = 0;
+
+};

From 0bf0d8e743de5978910726d3e73358ebe42b81f8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 20:20:39 +0100
Subject: [PATCH 1423/1774] stuff

---
 datapoollocal/HasLocalDataPoolIF.h | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 07c6882be..55b98c454 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -40,6 +40,8 @@ using LocalDataPoolMapIter = LocalDataPool::iterator;
  * of the LocalDataPoolManager.
  */
 class HasLocalDataPoolIF {
+	friend class LocalPoolDataSetBase;
+	friend class LocalPoolObjectBase;
 public:
 	virtual~ HasLocalDataPoolIF() {};
 
@@ -64,9 +66,6 @@ public:
 	        LocalDataPool& localDataPoolMap,
 	        LocalDataPoolManager& poolManager) = 0;
 
-	/** Can be used to get a handle to the local data pool manager. */
-	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
-
 	/**
 	 * Returns the minimum sampling frequency in milliseconds, which will
 	 * usually be the period the pool owner performs its periodic operation.
@@ -140,6 +139,12 @@ public:
 	        float newIntervalSeconds) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
+
+	virtual ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() = 0;
+protected:
+
+	/** Can be used to get a handle to the local data pool manager. */
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */

From 037bd83af9cd7f05680323e1ae856b73b31eb007 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 21:31:03 +0100
Subject: [PATCH 1424/1774] trying new interface

---
 controller/ExtendedControllerBase.cpp         |  5 ++
 controller/ExtendedControllerBase.h           |  2 +
 datapoollocal/AccessLocalDataPoolIF.h         | 17 ++++
 datapoollocal/HasLocalDataPoolIF.h            | 81 +++++++++++--------
 datapoollocal/LocalDataPoolManager.h          |  2 +-
 datapoollocal/LocalPoolDataSetBase.cpp        |  2 +-
 datapoollocal/LocalPoolDataSetBase.h          |  8 +-
 datapoollocal/LocalPoolObjectBase.h           |  2 +-
 .../ProvidesDataPoolSubscriptionIF.h          |  7 +-
 devicehandlers/DeviceHandlerBase.cpp          |  4 +
 devicehandlers/DeviceHandlerBase.h            |  4 +-
 internalError/InternalErrorReporter.cpp       |  5 ++
 internalError/InternalErrorReporter.h         |  1 +
 13 files changed, 100 insertions(+), 40 deletions(-)
 create mode 100644 datapoollocal/AccessLocalDataPoolIF.h

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 017acafe1..101ac5582 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -113,3 +113,8 @@ LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
 #endif
     return nullptr;
 }
+
+ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubsciptionInterface(
+		) {
+	return &localPoolManager;
+}
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index 02c5728e1..ec8d149d2 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -32,6 +32,8 @@ public:
     virtual ReturnValue_t performOperation(uint8_t opCode) override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
+   ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() override;
+
 protected:
     LocalDataPoolManager localPoolManager;
     ActionHelper actionHelper;
diff --git a/datapoollocal/AccessLocalDataPoolIF.h b/datapoollocal/AccessLocalDataPoolIF.h
new file mode 100644
index 000000000..d204a0883
--- /dev/null
+++ b/datapoollocal/AccessLocalDataPoolIF.h
@@ -0,0 +1,17 @@
+#ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_
+#define FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_
+
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+
+
+class AccessLocalDataPoolIF {
+public:
+	virtual ~AccessLocalDataPoolIF() {};
+
+protected:
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+};
+
+
+#endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 55b98c454..5b296d97a 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
+#include "ProvidesDataPoolSubscriptionIF.h"
 #include "locPoolDefinitions.h"
 
 #include "../datapool/PoolEntryIF.h"
@@ -40,8 +41,9 @@ using LocalDataPoolMapIter = LocalDataPool::iterator;
  * of the LocalDataPoolManager.
  */
 class HasLocalDataPoolIF {
-	friend class LocalPoolDataSetBase;
-	friend class LocalPoolObjectBase;
+	friend class LocalDataPoolManager;
+	//friend class LocalPoolDataSetBase;
+	//friend class LocalPoolObjectBase;
 public:
 	virtual~ HasLocalDataPoolIF() {};
 
@@ -73,36 +75,10 @@ public:
 	 */
 	virtual uint32_t getPeriodicOperationFrequency() const = 0;
 
-	/**
-	 * This function is used by the pool manager to get a valid dataset
-     * from a SID
-	 * @param sid Corresponding structure ID
-	 * @return
-	 */
-	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
-
-	/**
-	 * Similar to the function above, but used to get a local pool variable
-	 * handle. This is only needed for update notifications, so it is not
-	 * defined as abstract.
-	 * @param localPoolId
-	 * @return
-	 */
-	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
-	            << ". Returning nullptr!" << std::endl;
-#else
-	    fsfw::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
-	    		"Not overriden. Returning nullptr!\n");
-#endif
-	    return nullptr;
-	}
-
     /**
      * @brief   This function will be called by the manager if an update
      *          notification is received.
-     * @details
+     * @details  HasLocalDataPoolIF
      * Can be overriden by the child class to handle changed datasets.
      * @param sid
      * @param storeId If a snapshot was requested, data will be located inside
@@ -127,8 +103,10 @@ public:
         return;
     }
 
-	/* These function can be implemented by pool owner, as they are required
-	 * by the housekeeping message interface */
+	/**
+	 * These function can be implemented by pool owner, if they are required
+	 * and used by the housekeeping message interface.
+	 * */
 	virtual ReturnValue_t addDataSet(sid_t sid) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
@@ -140,11 +118,50 @@ public:
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
 
+	/**
+	 * This function can be used by data pool consumers to retrieve a  handle
+	 * which allows subscriptions to dataset and variable updates.
+	 * @return
+	 */
 	virtual ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() = 0;
 protected:
 
-	/** Can be used to get a handle to the local data pool manager. */
+	/**
+	 * Can be used to get a handle to the local data pool manager.
+	 * This function is protected because it should only be used by the
+	 * class imlementing the interface.
+	 */
 	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID. This function is protected to prevent users from
+     * using raw data set pointers which could not be thread-safe. Users
+     * should use the #ProvidesDataPoolSubscriptionIF.
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
+
+	/**
+	 * Similar to the function above, but used to get a local pool variable
+	 * handle. This is only needed for update notifications, so it is not
+	 * defined as abstract. This function is protected to prevent users from
+     * using raw pool variable pointers which could not be thread-safe.
+     * Users should use the #ProvidesDataPoolSubscriptionIF.
+	 * @param localPoolId
+	 * @return
+	 */
+	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
+	            << ". Returning nullptr!" << std::endl;
+#else
+	    fsfw::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
+	    		"Not overriden. Returning nullptr!\n");
+#endif
+	    return nullptr;
+	}
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index d0a1181fa..7a4e376c7 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 #define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 
-#include <fsfw/datapoollocal/ProvidesDataPoolSubscriptionIF.h>
+#include "ProvidesDataPoolSubscriptionIF.h"
 #include "HasLocalDataPoolIF.h"
 
 #include "../serviceinterface/ServiceInterface.h"
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 8a39823ea..9fc3f924f 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -8,7 +8,7 @@
 #include <cmath>
 #include <cstring>
 
-LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
+LocalPoolDataSetBase::LocalPoolDataSetBase(AccessLocalDataPoolIF *hkOwner,
         uint32_t setId, PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables, bool periodicHandling):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 77a22f147..58b658806 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -3,6 +3,7 @@
 
 #include "HasLocalDataPoolIF.h"
 #include "MarkChangedIF.h"
+#include "AccessLocalDataPoolIF.h"
 
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
@@ -42,7 +43,8 @@ class PeriodicHousekeepingHelper;
  * @ingroup data_pool
  */
 class LocalPoolDataSetBase: public PoolDataSetBase,
-        public MarkChangedIF {
+        public MarkChangedIF,
+		public AccessLocalDataPoolIF {
 	friend class LocalDataPoolManager;
 	friend class PeriodicHousekeepingHelper;
 public:
@@ -52,7 +54,7 @@ public:
 	 * This constructor also initializes the components required for
 	 * periodic handling.
 	 */
-	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
+	LocalPoolDataSetBase(AccessLocalDataPoolIF *hkOwner,
 			uint32_t setId, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables, bool periodicHandling = true);
 
@@ -218,7 +220,7 @@ protected:
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
-	LocalDataPoolManager* hkManager = nullptr;
+	AccessLocalDataPoolIF* hkManager = nullptr;
 
 };
 
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 25ca594d9..e7414131a 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -54,7 +54,7 @@ protected:
     ReadWriteMode_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
 
     //! @brief  Pointer to the class which manages the HK pool.
-    LocalDataPoolManager* hkManager;
+    LocalDataPoolManager* hkManager = nullptr;
 
 	void reportReadCommitError(const char* variableType,
 			ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId);
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index 6f96d5180..7f0cc7540 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -1,10 +1,13 @@
+#ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
+#define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
+
 #include <fsfw/datapoollocal/locPoolDefinitions.h>
 #include <fsfw/ipc/messageQueueDefinitions.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 
 
-class ProvidesDataPoolSubscriptionIF{
+class ProvidesDataPoolSubscriptionIF {
 public:
 	virtual ~ProvidesDataPoolSubscriptionIF(){};
 
@@ -77,3 +80,5 @@ public:
 			bool generateSnapshot) = 0;
 
 };
+
+#endif /* FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4fa7b09c0..de45c7d48 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1532,3 +1532,7 @@ void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
 	}
 
 }
+
+ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubsciptionInterface() {
+	return &hkManager;
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 4c745b4f1..556c23a2a 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -518,7 +518,9 @@ protected:
 				LocalDataPoolManager& poolManager) override;
 
 	/** Get the HK manager object handle */
-	virtual LocalDataPoolManager* getHkManagerHandle() override;
+	LocalDataPoolManager* getHkManagerHandle() override;
+
+    ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 6842da8e8..16c6412b4 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -195,3 +195,8 @@ void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType,
 	this->timeoutType = timeoutType;
 	this->timeoutMs = timeoutMs;
 }
+
+ProvidesDataPoolSubscriptionIF* InternalErrorReporter::getSubsciptionInterface(
+		) {
+	return &poolManager;
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index c85057d6d..1fcf733fc 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -46,6 +46,7 @@ public:
     virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+    ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;

From 5bc46bae02eb34a352df97ebafe9b594d799c604 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:18:42 +0100
Subject: [PATCH 1425/1774] reverted some stuff

---
 datapool/PoolDataSetBase.h             |  1 +
 datapoollocal/AccessLocalDataPoolIF.h  | 20 ++++++++++++--------
 datapoollocal/HasLocalDataPoolIF.h     |  4 ++--
 datapoollocal/LocalDataPoolManager.h   |  2 ++
 datapoollocal/LocalPoolDataSetBase.cpp |  2 +-
 datapoollocal/LocalPoolDataSetBase.h   |  7 +++----
 6 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 6f3c5fa4b..d741dabc8 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -3,6 +3,7 @@
 
 #include "PoolDataSetIF.h"
 #include "PoolVariableIF.h"
+#include "../serialize/SerializeIF.h"
 #include "../ipc/MutexIF.h"
 
 /**
diff --git a/datapoollocal/AccessLocalDataPoolIF.h b/datapoollocal/AccessLocalDataPoolIF.h
index d204a0883..5bed34adf 100644
--- a/datapoollocal/AccessLocalDataPoolIF.h
+++ b/datapoollocal/AccessLocalDataPoolIF.h
@@ -4,14 +4,18 @@
 #include <fsfw/datapoollocal/LocalDataPoolManager.h>
 
 
-class AccessLocalDataPoolIF {
-public:
-	virtual ~AccessLocalDataPoolIF() {};
-
-protected:
-	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
-
-};
+//class AccessLocalDataPoolIF {
+//public:
+//	virtual ~AccessLocalDataPoolIF() {};
+//
+//protected:
+//
+//	template <class T> ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
+//			lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
+//		return manager.fetchPoolEntry(localPoolId, poolEntry);
+//	}
+//
+//};
 
 
 #endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 5b296d97a..215ac8a5a 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -42,8 +42,8 @@ using LocalDataPoolMapIter = LocalDataPool::iterator;
  */
 class HasLocalDataPoolIF {
 	friend class LocalDataPoolManager;
-	//friend class LocalPoolDataSetBase;
-	//friend class LocalPoolObjectBase;
+	friend class LocalPoolDataSetBase;
+	friend class LocalPoolObjectBase;
 public:
 	virtual~ HasLocalDataPoolIF() {};
 
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 7a4e376c7..8571aa027 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -17,6 +17,7 @@
 #include "../ipc/MutexHelper.h"
 
 #include <map>
+#include <vector>
 
 namespace Factory {
 void setStaticFrameworkObjectIds();
@@ -53,6 +54,7 @@ class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF {
 	template<typename T> friend class LocalPoolVariable;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
+	//friend class AccessLocalDataPoolIF;
 	friend void (Factory::setStaticFrameworkObjectIds)();
 
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 9fc3f924f..8a39823ea 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -8,7 +8,7 @@
 #include <cmath>
 #include <cstring>
 
-LocalPoolDataSetBase::LocalPoolDataSetBase(AccessLocalDataPoolIF *hkOwner,
+LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         uint32_t setId, PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables, bool periodicHandling):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 58b658806..5ad02269d 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -43,8 +43,7 @@ class PeriodicHousekeepingHelper;
  * @ingroup data_pool
  */
 class LocalPoolDataSetBase: public PoolDataSetBase,
-        public MarkChangedIF,
-		public AccessLocalDataPoolIF {
+        public MarkChangedIF {
 	friend class LocalDataPoolManager;
 	friend class PeriodicHousekeepingHelper;
 public:
@@ -54,7 +53,7 @@ public:
 	 * This constructor also initializes the components required for
 	 * periodic handling.
 	 */
-	LocalPoolDataSetBase(AccessLocalDataPoolIF *hkOwner,
+	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 			uint32_t setId, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables, bool periodicHandling = true);
 
@@ -220,7 +219,7 @@ protected:
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
-	AccessLocalDataPoolIF* hkManager = nullptr;
+	LocalDataPoolManager* hkManager = nullptr;
 
 };
 

From 065f79615ad97b96bad42e1e588f172179c70281 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:21:21 +0100
Subject: [PATCH 1426/1774] compiling again

---
 datapoollocal/LocalPoolDataSetBase.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 5ad02269d..9df65b9c7 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -3,11 +3,9 @@
 
 #include "HasLocalDataPoolIF.h"
 #include "MarkChangedIF.h"
-#include "AccessLocalDataPoolIF.h"
 
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
-#include "../serialize/SerializeIF.h"
 
 #include <vector>
 

From a8873e608c7f86ca544221b02b583e664584c803 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:25:39 +0100
Subject: [PATCH 1427/1774] cleaning up

---
 controller/ExtendedControllerBase.cpp   |  3 +--
 controller/ExtendedControllerBase.h     |  2 +-
 datapoollocal/AccessLocalDataPoolIF.h   | 21 ---------------------
 datapoollocal/HasLocalDataPoolIF.h      |  2 +-
 datapoollocal/LocalDataPoolManager.h    |  3 ---
 devicehandlers/DeviceHandlerBase.cpp    |  2 +-
 devicehandlers/DeviceHandlerBase.h      |  2 +-
 internalError/InternalErrorReporter.cpp |  5 ++---
 internalError/InternalErrorReporter.h   |  2 +-
 9 files changed, 8 insertions(+), 34 deletions(-)
 delete mode 100644 datapoollocal/AccessLocalDataPoolIF.h

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 101ac5582..3759d9c72 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -114,7 +114,6 @@ LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
     return nullptr;
 }
 
-ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubsciptionInterface(
-		) {
+ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubscriptionInterface() {
 	return &localPoolManager;
 }
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index ec8d149d2..7e6d32da9 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -32,7 +32,7 @@ public:
     virtual ReturnValue_t performOperation(uint8_t opCode) override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
-   ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() override;
+   ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
 protected:
     LocalDataPoolManager localPoolManager;
diff --git a/datapoollocal/AccessLocalDataPoolIF.h b/datapoollocal/AccessLocalDataPoolIF.h
deleted file mode 100644
index 5bed34adf..000000000
--- a/datapoollocal/AccessLocalDataPoolIF.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_
-#define FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_
-
-#include <fsfw/datapoollocal/LocalDataPoolManager.h>
-
-
-//class AccessLocalDataPoolIF {
-//public:
-//	virtual ~AccessLocalDataPoolIF() {};
-//
-//protected:
-//
-//	template <class T> ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
-//			lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
-//		return manager.fetchPoolEntry(localPoolId, poolEntry);
-//	}
-//
-//};
-
-
-#endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 215ac8a5a..263a4e79d 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -123,7 +123,7 @@ public:
 	 * which allows subscriptions to dataset and variable updates.
 	 * @return
 	 */
-	virtual ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() = 0;
+	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
 protected:
 
 	/**
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 8571aa027..6a87e716d 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -54,10 +54,7 @@ class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF {
 	template<typename T> friend class LocalPoolVariable;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
-	//friend class AccessLocalDataPoolIF;
 	friend void (Factory::setStaticFrameworkObjectIds)();
-
-
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index de45c7d48..8f64dd258 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1533,6 +1533,6 @@ void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
 
 }
 
-ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubsciptionInterface() {
+ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubscriptionInterface() {
 	return &hkManager;
 }
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 556c23a2a..190843580 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -520,7 +520,7 @@ protected:
 	/** Get the HK manager object handle */
 	LocalDataPoolManager* getHkManagerHandle() override;
 
-    ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() override;
+    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 16c6412b4..6c722789c 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -2,7 +2,7 @@
 
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
         uint32_t messageQueueDepth): SystemObject(setObjectId),
@@ -196,7 +196,6 @@ void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType,
 	this->timeoutMs = timeoutMs;
 }
 
-ProvidesDataPoolSubscriptionIF* InternalErrorReporter::getSubsciptionInterface(
-		) {
+ProvidesDataPoolSubscriptionIF* InternalErrorReporter::getSubscriptionInterface() {
 	return &poolManager;
 }
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 1fcf733fc..8085d918f 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -46,7 +46,7 @@ public:
     virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
-    ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() override;
+    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;

From 44955db341c4b732437e75bd00e134fa0c5da333 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:27:24 +0100
Subject: [PATCH 1428/1774] tab replacement

---
 devicehandlers/DeviceHandlerBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 190843580..a2f603929 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -520,7 +520,7 @@ protected:
 	/** Get the HK manager object handle */
 	LocalDataPoolManager* getHkManagerHandle() override;
 
-    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
+	ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per

From 0be4c35b737d08d4ba6b78d664be8bba915b5e2d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:32:36 +0100
Subject: [PATCH 1429/1774] using 100 line width now

---
 datapoollocal/LocalDataPoolManager.cpp | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 2a0ec923c..ff399abab 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -16,9 +16,9 @@
 object_id_t LocalDataPoolManager::defaultHkDestination =
         objects::PUS_SERVICE_3_HOUSEKEEPING;
 
-LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
-        MessageQueueIF* queueToUse, bool appendValidityBuffer):
-                        appendValidityBuffer(appendValidityBuffer) {
+LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+		bool appendValidityBuffer):
+				appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
     	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
@@ -148,12 +148,11 @@ ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
-        HkReceiver& receiver, ReturnValue_t& status) {
+ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receiver,
+		ReturnValue_t& status) {
     MarkChangedIF* toReset = nullptr;
     if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                receiver.dataId.localPoolId);
+        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
         	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
@@ -162,8 +161,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         if(poolObj->hasChanged()) {
             // prepare and send update notification.
             CommandMessage notification;
-            HousekeepingMessage::setUpdateNotificationVariableCommand(
-                    &notification, receiver.dataId.localPoolId);
+            HousekeepingMessage::setUpdateNotificationVariableCommand(&notification,
+            		receiver.dataId.localPoolId);
             ReturnValue_t result = hkQueue->sendMessage(
                     receiver.destinationQueue, &notification);
             if(result != HasReturnvaluesIF::RETURN_OK) {
@@ -174,8 +173,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
 
     }
     else {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                receiver.dataId.sid);
+        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(receiver.dataId.sid);
         if(dataSet == nullptr) {
         	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"handleNotificationUpdate", DATASET_NOT_FOUND);

From 58d813c249842e3c627123d0584607e5f3f338a6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:33:58 +0100
Subject: [PATCH 1430/1774] minor formatting stuff

---
 datapoollocal/LocalPoolObjectBase.cpp | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index bb7822dad..18414d40b 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,9 +1,8 @@
 #include "LocalPoolObjectBase.h"
 
-LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
-        HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
-        pool_rwm_t setReadWriteMode): localPoolId(poolId),
-        readWriteMode(setReadWriteMode) {
+LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+		localPoolId(poolId), readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
@@ -23,9 +22,9 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
     }
 }
 
-LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
-        readWriteMode(setReadWriteMode) {
+LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF *dataSet,
+		pool_rwm_t setReadWriteMode):
+		localPoolId(poolId), readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
@@ -109,10 +108,9 @@ void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
 	}
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << variableType << ": " << type << " call | " << errMsg
-			<< " | Owner: 0x" << std::hex << std::setw(8)
-			<< std::setfill('0') << objectId << std::dec << " LPID: " << lpId
-			<< std::endl;
+	sif::warning << variableType << ": " << type << " call | " << errMsg << " | Owner: 0x"
+			<< std::hex << std::setw(8) << std::setfill('0') << objectId << std::dec
+			<< " LPID: " << lpId << std::endl;
 #else
 	fsfw::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
 			variableType, type, errMsg, objectId, lpId);

From fa5580cb7fb12cccaff1feac60f2eb21544e2bfa Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:45:04 +0100
Subject: [PATCH 1431/1774] indentation

---
 datapoollocal/AccessLocalPoolF.h       |   17 +
 datapoollocal/LocalDataPoolManager.cpp | 1290 ++++++++++++------------
 datapoollocal/LocalPoolVariable.h      |    3 +-
 3 files changed, 664 insertions(+), 646 deletions(-)
 create mode 100644 datapoollocal/AccessLocalPoolF.h

diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
new file mode 100644
index 000000000..7b507523f
--- /dev/null
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -0,0 +1,17 @@
+#ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
+#define FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
+
+#include <fsfw/datapool/PoolEntry.h>
+#include <fsfw/datapoollocal/locPoolDefinitions.h>
+
+template <typename T>
+class AccessLocalPoolIF {
+public:
+	virtual~ AccessLocalPoolIF() {};
+
+	virtual ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry) = 0;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index ff399abab..995a54a4c 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -14,808 +14,808 @@
 #include <cmath>
 
 object_id_t LocalDataPoolManager::defaultHkDestination =
-        objects::PUS_SERVICE_3_HOUSEKEEPING;
+		objects::PUS_SERVICE_3_HOUSEKEEPING;
 
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
 		bool appendValidityBuffer):
-				appendValidityBuffer(appendValidityBuffer) {
-    if(owner == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
+						appendValidityBuffer(appendValidityBuffer) {
+	if(owner == nullptr) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
 				"Invalid supplied owner");
-        return;
-    }
-    this->owner = owner;
-    mutex = MutexFactory::instance()->createMutex();
-    if(mutex == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
-    			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
+		return;
+	}
+	this->owner = owner;
+	mutex = MutexFactory::instance()->createMutex();
+	if(mutex == nullptr) {
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+				"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not create mutex");
-    }
+	}
 
-    hkQueue = queueToUse;
+	hkQueue = queueToUse;
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
-    if(queueToUse == nullptr) {
-        // error, all destinations invalid
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
-    			"initialize", QUEUE_OR_DESTINATION_INVALID);
-    }
-    hkQueue = queueToUse;
+	if(queueToUse == nullptr) {
+		// error, all destinations invalid
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+				"initialize", QUEUE_OR_DESTINATION_INVALID);
+	}
+	hkQueue = queueToUse;
 
-    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-    if(ipcStore == nullptr) {
-    	// error, all destinations invalid
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
-    			"initialize", HasReturnvaluesIF::RETURN_FAILED,
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if(ipcStore == nullptr) {
+		// error, all destinations invalid
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+				"initialize", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not set IPC store.");
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
 
 
-    if(defaultHkDestination != objects::NO_OBJECT) {
-        AcceptsHkPacketsIF* hkPacketReceiver =
-                objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
-        if(hkPacketReceiver != nullptr) {
-            hkDestinationId = hkPacketReceiver->getHkQueue();
-        }
-        else {
-        	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
-        			"initialize", QUEUE_OR_DESTINATION_INVALID);
-        	return QUEUE_OR_DESTINATION_INVALID;
-        }
-    }
+	if(defaultHkDestination != objects::NO_OBJECT) {
+		AcceptsHkPacketsIF* hkPacketReceiver =
+				objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
+		if(hkPacketReceiver != nullptr) {
+			hkDestinationId = hkPacketReceiver->getHkQueue();
+		}
+		else {
+			printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+					"initialize", QUEUE_OR_DESTINATION_INVALID);
+			return QUEUE_OR_DESTINATION_INVALID;
+		}
+	}
 
-    return HasReturnvaluesIF::RETURN_OK;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
-        uint8_t nonDiagInvlFactor) {
-    setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
-    return initializeHousekeepingPoolEntriesOnce();
+		uint8_t nonDiagInvlFactor) {
+	setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
+	return initializeHousekeepingPoolEntriesOnce();
 }
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
-    if(not mapInitialized) {
-        ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
-                *this);
-        if(result == HasReturnvaluesIF::RETURN_OK) {
-            mapInitialized = true;
-        }
-        return result;
-    }
+	if(not mapInitialized) {
+		ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
+				*this);
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			mapInitialized = true;
+		}
+		return result;
+	}
 
 	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 			"initialize", HasReturnvaluesIF::RETURN_FAILED,
 			"The map should only be initialized once");
-    return HasReturnvaluesIF::RETURN_OK;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
-    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-    for(auto& receiver: hkReceiversMap) {
-        switch(receiver.reportingType) {
-        case(ReportingType::PERIODIC): {
-            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-                // Periodic packets shall only be generated from datasets.
-                continue;
-            }
-            performPeriodicHkGeneration(receiver);
-            break;
-        }
-        case(ReportingType::UPDATE_HK): {
-            handleHkUpdate(receiver, status);
-            break;
-        }
-        case(ReportingType::UPDATE_NOTIFICATION): {
-            handleNotificationUpdate(receiver, status);
-            break;
-        }
-        case(ReportingType::UPDATE_SNAPSHOT): {
-            handleNotificationSnapshot(receiver, status);
-            break;
-        }
-        default:
-            // This should never happen.
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-    }
-    resetHkUpdateResetHelper();
-    return status;
+	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+	for(auto& receiver: hkReceiversMap) {
+		switch(receiver.reportingType) {
+		case(ReportingType::PERIODIC): {
+			if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+				// Periodic packets shall only be generated from datasets.
+				continue;
+			}
+			performPeriodicHkGeneration(receiver);
+			break;
+		}
+		case(ReportingType::UPDATE_HK): {
+			handleHkUpdate(receiver, status);
+			break;
+		}
+		case(ReportingType::UPDATE_NOTIFICATION): {
+			handleNotificationUpdate(receiver, status);
+			break;
+		}
+		case(ReportingType::UPDATE_SNAPSHOT): {
+			handleNotificationSnapshot(receiver, status);
+			break;
+		}
+		default:
+			// This should never happen.
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	resetHkUpdateResetHelper();
+	return status;
 }
 
 ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
-        ReturnValue_t& status) {
-    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        // Update packets shall only be generated from datasets.
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-            receiver.dataId.sid);
-    if(dataSet->hasChanged()) {
-        // prepare and send update notification
-        ReturnValue_t result = generateHousekeepingPacket(
-                receiver.dataId.sid, dataSet, true);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            status = result;
-        }
-    }
-    handleChangeResetLogic(receiver.dataType, receiver.dataId,
-            dataSet);
-    return HasReturnvaluesIF::RETURN_OK;
+		ReturnValue_t& status) {
+	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+		// Update packets shall only be generated from datasets.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+			receiver.dataId.sid);
+	if(dataSet->hasChanged()) {
+		// prepare and send update notification
+		ReturnValue_t result = generateHousekeepingPacket(
+				receiver.dataId.sid, dataSet, true);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+	}
+	handleChangeResetLogic(receiver.dataType, receiver.dataId,
+			dataSet);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receiver,
 		ReturnValue_t& status) {
-    MarkChangedIF* toReset = nullptr;
-    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
-        if(poolObj == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-        			"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
-            return POOLOBJECT_NOT_FOUND;
-        }
-        if(poolObj->hasChanged()) {
-            // prepare and send update notification.
-            CommandMessage notification;
-            HousekeepingMessage::setUpdateNotificationVariableCommand(&notification,
-            		receiver.dataId.localPoolId);
-            ReturnValue_t result = hkQueue->sendMessage(
-                    receiver.destinationQueue, &notification);
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                status = result;
-            }
-            toReset = poolObj;
-        }
+	MarkChangedIF* toReset = nullptr;
+	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+		LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
+		if(poolObj == nullptr) {
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
+			return POOLOBJECT_NOT_FOUND;
+		}
+		if(poolObj->hasChanged()) {
+			// prepare and send update notification.
+			CommandMessage notification;
+			HousekeepingMessage::setUpdateNotificationVariableCommand(&notification,
+					receiver.dataId.localPoolId);
+			ReturnValue_t result = hkQueue->sendMessage(
+					receiver.destinationQueue, &notification);
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				status = result;
+			}
+			toReset = poolObj;
+		}
 
-    }
-    else {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(receiver.dataId.sid);
-        if(dataSet == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-        			"handleNotificationUpdate", DATASET_NOT_FOUND);
-            return DATASET_NOT_FOUND;
-        }
-        if(dataSet->hasChanged()) {
-            // prepare and send update notification
-            CommandMessage notification;
-            HousekeepingMessage::setUpdateNotificationSetCommand(
-                    &notification, receiver.dataId.sid);
-            ReturnValue_t result = hkQueue->sendMessage(
-                    receiver.destinationQueue, &notification);
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                status = result;
-            }
-            toReset = dataSet;
-        }
-    }
-    if(toReset != nullptr) {
-        handleChangeResetLogic(receiver.dataType,
-                receiver.dataId, toReset);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(receiver.dataId.sid);
+		if(dataSet == nullptr) {
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"handleNotificationUpdate", DATASET_NOT_FOUND);
+			return DATASET_NOT_FOUND;
+		}
+		if(dataSet->hasChanged()) {
+			// prepare and send update notification
+			CommandMessage notification;
+			HousekeepingMessage::setUpdateNotificationSetCommand(
+					&notification, receiver.dataId.sid);
+			ReturnValue_t result = hkQueue->sendMessage(
+					receiver.destinationQueue, &notification);
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				status = result;
+			}
+			toReset = dataSet;
+		}
+	}
+	if(toReset != nullptr) {
+		handleChangeResetLogic(receiver.dataType,
+				receiver.dataId, toReset);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
-        HkReceiver& receiver, ReturnValue_t& status) {
-    MarkChangedIF* toReset = nullptr;
-    // check whether data has changed and send messages in case it has.
-    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                receiver.dataId.localPoolId);
-        if(poolObj == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-        			"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
-            return POOLOBJECT_NOT_FOUND;
-        }
+		HkReceiver& receiver, ReturnValue_t& status) {
+	MarkChangedIF* toReset = nullptr;
+	// check whether data has changed and send messages in case it has.
+	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+		LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+				receiver.dataId.localPoolId);
+		if(poolObj == nullptr) {
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
+			return POOLOBJECT_NOT_FOUND;
+		}
 
-        if (not poolObj->hasChanged()) {
-            return HasReturnvaluesIF::RETURN_OK;
-        }
+		if (not poolObj->hasChanged()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
 
-        // prepare and send update snapshot.
-        timeval now;
-        Clock::getClock_timeval(&now);
-        CCSDSTime::CDS_short cds;
-        CCSDSTime::convertToCcsds(&cds, &now);
-        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-                sizeof(cds), owner->getPoolObjectHandle(
-                receiver.dataId.localPoolId));
+		// prepare and send update snapshot.
+		timeval now;
+		Clock::getClock_timeval(&now);
+		CCSDSTime::CDS_short cds;
+		CCSDSTime::convertToCcsds(&cds, &now);
+		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+				sizeof(cds), owner->getPoolObjectHandle(
+						receiver.dataId.localPoolId));
 
-        store_address_t storeId;
-        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
+		store_address_t storeId;
+		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 
-        CommandMessage notification;
-        HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
-                receiver.dataId.localPoolId, storeId);
-        result = hkQueue->sendMessage(receiver.destinationQueue,
-                &notification);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            status = result;
-        }
-        toReset = poolObj;
-    }
-    else {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                receiver.dataId.sid);
-        if(dataSet == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-        			"handleNotificationSnapshot", DATASET_NOT_FOUND);
-            return DATASET_NOT_FOUND;
-        }
+		CommandMessage notification;
+		HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
+				receiver.dataId.localPoolId, storeId);
+		result = hkQueue->sendMessage(receiver.destinationQueue,
+				&notification);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+		toReset = poolObj;
+	}
+	else {
+		LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+				receiver.dataId.sid);
+		if(dataSet == nullptr) {
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"handleNotificationSnapshot", DATASET_NOT_FOUND);
+			return DATASET_NOT_FOUND;
+		}
 
-        if(not dataSet->hasChanged()) {
-            return HasReturnvaluesIF::RETURN_OK;
-        }
+		if(not dataSet->hasChanged()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
 
-        // prepare and send update snapshot.
-        timeval now;
-        Clock::getClock_timeval(&now);
-        CCSDSTime::CDS_short cds;
-        CCSDSTime::convertToCcsds(&cds, &now);
-        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-                sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+		// prepare and send update snapshot.
+		timeval now;
+		Clock::getClock_timeval(&now);
+		CCSDSTime::CDS_short cds;
+		CCSDSTime::convertToCcsds(&cds, &now);
+		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+				sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
 
-        store_address_t storeId;
-        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
+		store_address_t storeId;
+		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 
-        CommandMessage notification;
-        HousekeepingMessage::setUpdateSnapshotSetCommand(
-                &notification, receiver.dataId.sid, storeId);
-        result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            status = result;
-        }
-        toReset = dataSet;
+		CommandMessage notification;
+		HousekeepingMessage::setUpdateSnapshotSetCommand(
+				&notification, receiver.dataId.sid, storeId);
+		result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+		toReset = dataSet;
 
-    }
-    if(toReset != nullptr) {
-        handleChangeResetLogic(receiver.dataType,
-                receiver.dataId, toReset);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+	}
+	if(toReset != nullptr) {
+		handleChangeResetLogic(receiver.dataType,
+				receiver.dataId, toReset);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::addUpdateToStore(
-        HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
-    size_t updatePacketSize = updatePacket.getSerializedSize();
-    uint8_t *storePtr = nullptr;
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            updatePacket.getSerializedSize(), &storePtr);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    size_t serializedSize = 0;
-    result = updatePacket.serialize(&storePtr, &serializedSize,
-            updatePacketSize, SerializeIF::Endianness::MACHINE);
-    return result;;
+		HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
+	size_t updatePacketSize = updatePacket.getSerializedSize();
+	uint8_t *storePtr = nullptr;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			updatePacket.getSerializedSize(), &storePtr);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	size_t serializedSize = 0;
+	result = updatePacket.serialize(&storePtr, &serializedSize,
+			updatePacketSize, SerializeIF::Endianness::MACHINE);
+	return result;;
 }
 
 void LocalDataPoolManager::handleChangeResetLogic(
-        DataType type, DataId dataId, MarkChangedIF* toReset) {
-    if(hkUpdateResetList == nullptr) {
-        // config error!
-        return;
-    }
-    HkUpdateResetList& listRef = *hkUpdateResetList;
-    for(auto& changeInfo: listRef) {
-        if(changeInfo.dataType != type) {
-            continue;
-        }
-        if((changeInfo.dataType == DataType::DATA_SET) and
-                (changeInfo.dataId.sid != dataId.sid)) {
-            continue;
-        }
-        if((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
-                (changeInfo.dataId.localPoolId != dataId.localPoolId)) {
-            continue;
-        }
+		DataType type, DataId dataId, MarkChangedIF* toReset) {
+	if(hkUpdateResetList == nullptr) {
+		// config error!
+		return;
+	}
+	HkUpdateResetList& listRef = *hkUpdateResetList;
+	for(auto& changeInfo: listRef) {
+		if(changeInfo.dataType != type) {
+			continue;
+		}
+		if((changeInfo.dataType == DataType::DATA_SET) and
+				(changeInfo.dataId.sid != dataId.sid)) {
+			continue;
+		}
+		if((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
+				(changeInfo.dataId.localPoolId != dataId.localPoolId)) {
+			continue;
+		}
 
-        // only one update recipient, we can reset changes status immediately.
-        if(changeInfo.updateCounter <= 1) {
-            toReset->setChanged(false);
-        }
-        // All recipients have been notified, reset the changed flag.
-        if(changeInfo.currentUpdateCounter <= 1) {
-            toReset->setChanged(false);
-            changeInfo.currentUpdateCounter = 0;
-        }
-        // Not all recipiens have been notified yet, decrement.
-        else {
-            changeInfo.currentUpdateCounter--;
-        }
-        return;
-    }
+		// only one update recipient, we can reset changes status immediately.
+		if(changeInfo.updateCounter <= 1) {
+			toReset->setChanged(false);
+		}
+		// All recipients have been notified, reset the changed flag.
+		if(changeInfo.currentUpdateCounter <= 1) {
+			toReset->setChanged(false);
+			changeInfo.currentUpdateCounter = 0;
+		}
+		// Not all recipiens have been notified yet, decrement.
+		else {
+			changeInfo.currentUpdateCounter--;
+		}
+		return;
+	}
 }
 
 void LocalDataPoolManager::resetHkUpdateResetHelper() {
-    if(hkUpdateResetList == nullptr) {
-        return;
-    }
+	if(hkUpdateResetList == nullptr) {
+		return;
+	}
 
-    for(auto& changeInfo: *hkUpdateResetList) {
-        changeInfo.currentUpdateCounter = changeInfo.updateCounter;
-    }
+	for(auto& changeInfo: *hkUpdateResetList) {
+		changeInfo.currentUpdateCounter = changeInfo.updateCounter;
+	}
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
-        bool enableReporting, float collectionInterval, bool isDiagnostics,
-        object_id_t packetDestination) {
-    AcceptsHkPacketsIF* hkReceiverObject =
-            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-    if(hkReceiverObject == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
-        return QUEUE_OR_DESTINATION_INVALID;
-    }
+		bool enableReporting, float collectionInterval, bool isDiagnostics,
+		object_id_t packetDestination) {
+	AcceptsHkPacketsIF* hkReceiverObject =
+			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	if(hkReceiverObject == nullptr) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
+		return QUEUE_OR_DESTINATION_INVALID;
+	}
 
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataId.sid = sid;
-    hkReceiver.reportingType = ReportingType::PERIODIC;
-    hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataId.sid = sid;
+	hkReceiver.reportingType = ReportingType::PERIODIC;
+	hkReceiver.dataType = DataType::DATA_SET;
+	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet != nullptr) {
-        dataSet->setReportingEnabled(enableReporting);
-        dataSet->setDiagnostic(isDiagnostics);
-        dataSet->initializePeriodicHelper(collectionInterval,
-                owner->getPeriodicOperationFrequency(), isDiagnostics);
-    }
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet != nullptr) {
+		dataSet->setReportingEnabled(enableReporting);
+		dataSet->setDiagnostic(isDiagnostics);
+		dataSet->initializePeriodicHelper(collectionInterval,
+				owner->getPeriodicOperationFrequency(), isDiagnostics);
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
-    return HasReturnvaluesIF::RETURN_OK;
+	hkReceiversMap.push_back(hkReceiver);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 
 ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
-        bool isDiagnostics, bool reportingEnabled,
-        object_id_t packetDestination) {
-    AcceptsHkPacketsIF* hkReceiverObject =
-            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-    if(hkReceiverObject == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
-        return QUEUE_OR_DESTINATION_INVALID;
-    }
+		bool isDiagnostics, bool reportingEnabled,
+		object_id_t packetDestination) {
+	AcceptsHkPacketsIF* hkReceiverObject =
+			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	if(hkReceiverObject == nullptr) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
+		return QUEUE_OR_DESTINATION_INVALID;
+	}
 
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataId.sid = sid;
-    hkReceiver.reportingType = ReportingType::UPDATE_HK;
-    hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataId.sid = sid;
+	hkReceiver.reportingType = ReportingType::UPDATE_HK;
+	hkReceiver.dataType = DataType::DATA_SET;
+	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet != nullptr) {
-        dataSet->setReportingEnabled(true);
-        dataSet->setDiagnostic(isDiagnostics);
-    }
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet != nullptr) {
+		dataSet->setReportingEnabled(true);
+		dataSet->setDiagnostic(isDiagnostics);
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 
-    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-    return HasReturnvaluesIF::RETURN_OK;
+	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
-        const uint32_t setId, object_id_t destinationObject,
-        MessageQueueId_t targetQueueId, bool generateSnapshot) {
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.dataId.sid = sid_t(this->getOwner()->getObjectId(), setId);
-    hkReceiver.destinationQueue = targetQueueId;
-    hkReceiver.objectId = destinationObject;
-    if(generateSnapshot) {
-        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
-    }
-    else {
-        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
-    }
+		const uint32_t setId, object_id_t destinationObject,
+		MessageQueueId_t targetQueueId, bool generateSnapshot) {
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataType = DataType::DATA_SET;
+	hkReceiver.dataId.sid = sid_t(this->getOwner()->getObjectId(), setId);
+	hkReceiver.destinationQueue = targetQueueId;
+	hkReceiver.objectId = destinationObject;
+	if(generateSnapshot) {
+		hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+	}
+	else {
+		hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 
-    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-    return HasReturnvaluesIF::RETURN_OK;
+	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessages(
-        const lp_id_t localPoolId, object_id_t destinationObject,
-        MessageQueueId_t targetQueueId, bool generateSnapshot) {
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
-    hkReceiver.dataId.localPoolId = localPoolId;
-    hkReceiver.destinationQueue = targetQueueId;
-    hkReceiver.objectId = destinationObject;
-    if(generateSnapshot) {
-        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
-    }
-    else {
-        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
-    }
+		const lp_id_t localPoolId, object_id_t destinationObject,
+		MessageQueueId_t targetQueueId, bool generateSnapshot) {
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
+	hkReceiver.dataId.localPoolId = localPoolId;
+	hkReceiver.destinationQueue = targetQueueId;
+	hkReceiver.objectId = destinationObject;
+	if(generateSnapshot) {
+		hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+	}
+	else {
+		hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 
-    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-    return HasReturnvaluesIF::RETURN_OK;
+	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType,
-        DataId dataId) {
-    if(hkUpdateResetList == nullptr) {
-        hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
-    }
+		DataId dataId) {
+	if(hkUpdateResetList == nullptr) {
+		hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
+	}
 
-    for(auto& updateResetStruct: *hkUpdateResetList) {
-        if(dataType == DataType::DATA_SET) {
-            if(updateResetStruct.dataId.sid == dataId.sid) {
-                updateResetStruct.updateCounter++;
-                updateResetStruct.currentUpdateCounter++;
-                return;
-            }
-        }
-        else {
-            if(updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
-                updateResetStruct.updateCounter++;
-                updateResetStruct.currentUpdateCounter++;
-                return;
-            }
-        }
+	for(auto& updateResetStruct: *hkUpdateResetList) {
+		if(dataType == DataType::DATA_SET) {
+			if(updateResetStruct.dataId.sid == dataId.sid) {
+				updateResetStruct.updateCounter++;
+				updateResetStruct.currentUpdateCounter++;
+				return;
+			}
+		}
+		else {
+			if(updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
+				updateResetStruct.updateCounter++;
+				updateResetStruct.currentUpdateCounter++;
+				return;
+			}
+		}
 
-    }
-    HkUpdateResetHelper hkUpdateResetHelper;
-    hkUpdateResetHelper.currentUpdateCounter = 1;
-    hkUpdateResetHelper.updateCounter = 1;
-    hkUpdateResetHelper.dataType = dataType;
-    if(dataType == DataType::DATA_SET) {
-        hkUpdateResetHelper.dataId.sid = dataId.sid;
-    }
-    else {
-        hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
-    }
-    hkUpdateResetList->push_back(hkUpdateResetHelper);
+	}
+	HkUpdateResetHelper hkUpdateResetHelper;
+	hkUpdateResetHelper.currentUpdateCounter = 1;
+	hkUpdateResetHelper.updateCounter = 1;
+	hkUpdateResetHelper.dataType = dataType;
+	if(dataType == DataType::DATA_SET) {
+		hkUpdateResetHelper.dataId.sid = dataId.sid;
+	}
+	else {
+		hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
+	}
+	hkUpdateResetList->push_back(hkUpdateResetHelper);
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-        CommandMessage* message) {
-    Command_t command = message->getCommand();
-    sid_t sid = HousekeepingMessage::getSid(message);
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    switch(command) {
-    // Houskeeping interface handling.
-    case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-        result = togglePeriodicGeneration(sid, true, true);
-        break;
-    }
+		CommandMessage* message) {
+	Command_t command = message->getCommand();
+	sid_t sid = HousekeepingMessage::getSid(message);
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	switch(command) {
+	// Houskeeping interface handling.
+	case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+		result = togglePeriodicGeneration(sid, true, true);
+		break;
+	}
 
-    case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-        result = togglePeriodicGeneration(sid, false, true);
-        break;
-    }
+	case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+		result = togglePeriodicGeneration(sid, false, true);
+		break;
+	}
 
-    case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
-        result = togglePeriodicGeneration(sid, true, false);
-        break;
-    }
+	case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
+		result = togglePeriodicGeneration(sid, true, false);
+		break;
+	}
 
-    case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
-        result = togglePeriodicGeneration(sid, false, false);
-        break;
-    }
+	case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
+		result = togglePeriodicGeneration(sid, false, false);
+		break;
+	}
 
-    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES): {
-        return generateSetStructurePacket(sid, true);
-    }
+	case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES): {
+		return generateSetStructurePacket(sid, true);
+	}
 
-    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
-        return generateSetStructurePacket(sid, false);
-    }
-    case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
-    case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
-        float newCollIntvl = 0;
-        HousekeepingMessage::getCollectionIntervalModificationCommand(message,
-                &newCollIntvl);
-        if(command == HousekeepingMessage::
-                MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
-            result = changeCollectionInterval(sid, newCollIntvl, true);
-        }
-        else {
-            result = changeCollectionInterval(sid, newCollIntvl, false);
-        }
-        break;
-    }
+	case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
+		return generateSetStructurePacket(sid, false);
+	}
+	case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
+	case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
+		float newCollIntvl = 0;
+		HousekeepingMessage::getCollectionIntervalModificationCommand(message,
+				&newCollIntvl);
+		if(command == HousekeepingMessage::
+				MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
+			result = changeCollectionInterval(sid, newCollIntvl, true);
+		}
+		else {
+			result = changeCollectionInterval(sid, newCollIntvl, false);
+		}
+		break;
+	}
 
-    case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
-    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-        if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
-                and dataSet->isDiagnostics()) {
-            return WRONG_HK_PACKET_TYPE;
-        }
-        else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
-                and not dataSet->isDiagnostics()) {
-            return WRONG_HK_PACKET_TYPE;
-        }
-        return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
-                dataSet, true);
-    }
+	case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
+	case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
+		LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+		if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
+				and dataSet->isDiagnostics()) {
+			return WRONG_HK_PACKET_TYPE;
+		}
+		else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
+				and not dataSet->isDiagnostics()) {
+			return WRONG_HK_PACKET_TYPE;
+		}
+		return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+				dataSet, true);
+	}
 
-    // Notification handling.
-    case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
-        owner->handleChangedDataset(sid);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
-        lp_id_t locPoolId = HousekeepingMessage::
-                getUpdateNotificationVariableCommand(message);
-        owner->handleChangedPoolVariable(locPoolId);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
-        store_address_t storeId;
-        HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
-        owner->handleChangedDataset(sid, storeId);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
-        store_address_t storeId;
-        lp_id_t localPoolId = HousekeepingMessage::
-                getUpdateSnapshotVariableCommand(message, &storeId);
-        owner->handleChangedPoolVariable(localPoolId, storeId);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+	// Notification handling.
+	case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
+		owner->handleChangedDataset(sid);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
+		lp_id_t locPoolId = HousekeepingMessage::
+				getUpdateNotificationVariableCommand(message);
+		owner->handleChangedPoolVariable(locPoolId);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
+		store_address_t storeId;
+		HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
+		owner->handleChangedDataset(sid, storeId);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
+		store_address_t storeId;
+		lp_id_t localPoolId = HousekeepingMessage::
+				getUpdateSnapshotVariableCommand(message, &storeId);
+		owner->handleChangedPoolVariable(localPoolId, storeId);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
 
-    default:
-        return CommandMessageIF::UNKNOWN_COMMAND;
-    }
+	default:
+		return CommandMessageIF::UNKNOWN_COMMAND;
+	}
 
-    CommandMessage reply;
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
-    }
-    else {
-        HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
-    }
-    hkQueue->sendMessage(hkDestinationId, &reply);
-    return result;
+	CommandMessage reply;
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
+	}
+	else {
+		HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
+	}
+	hkQueue->sendMessage(hkDestinationId, &reply);
+	return result;
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
-        lp_id_t localPoolId) {
-    auto poolIter = localPoolMap.find(localPoolId);
-    if (poolIter == localPoolMap.end()) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING, "printPoolEntry",
-    			 HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
-        return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
-    }
-    poolIter->second->print();
-    return HasReturnvaluesIF::RETURN_OK;
+		lp_id_t localPoolId) {
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING, "printPoolEntry",
+				HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
+		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
+	}
+	poolIter->second->print();
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 MutexIF* LocalDataPoolManager::getMutexHandle() {
-    return mutex;
+	return mutex;
 }
 
 HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
-    return owner;
+	return owner;
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        LocalPoolDataSetBase* dataSet, bool forDownlink,
-        MessageQueueId_t destination) {
-    if(dataSet == nullptr) {
-        // Configuration error.
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"generateHousekeepingPacket",
-    			DATASET_NOT_FOUND);
-        return DATASET_NOT_FOUND;
-    }
+		LocalPoolDataSetBase* dataSet, bool forDownlink,
+		MessageQueueId_t destination) {
+	if(dataSet == nullptr) {
+		// Configuration error.
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"generateHousekeepingPacket",
+				DATASET_NOT_FOUND);
+		return DATASET_NOT_FOUND;
+	}
 
-    store_address_t storeId;
-    HousekeepingPacketDownlink hkPacket(sid, dataSet);
-    size_t serializedSize = 0;
-    ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
-            forDownlink, &serializedSize);
-    if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
-        return result;
-    }
+	store_address_t storeId;
+	HousekeepingPacketDownlink hkPacket(sid, dataSet);
+	size_t serializedSize = 0;
+	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
+			forDownlink, &serializedSize);
+	if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
+		return result;
+	}
 
-    // and now we set a HK message and send it the HK packet destination.
-    CommandMessage hkMessage;
-    if(dataSet->isDiagnostics()) {
-        HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
-    }
-    else {
-        HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
-    }
+	// and now we set a HK message and send it the HK packet destination.
+	CommandMessage hkMessage;
+	if(dataSet->isDiagnostics()) {
+		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
+	}
+	else {
+		HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
+	}
 
-    if(hkQueue == nullptr) {
-        // error, no queue available to send packet with.
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"generateHousekeepingPacket",
-    			QUEUE_OR_DESTINATION_INVALID);
-        return QUEUE_OR_DESTINATION_INVALID;
-    }
-    if(destination == MessageQueueIF::NO_QUEUE) {
-        if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
-            // error, all destinations invalid
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-        			"generateHousekeepingPacket",
-        			QUEUE_OR_DESTINATION_INVALID);
-        }
-        destination = hkDestinationId;
-    }
+	if(hkQueue == nullptr) {
+		// error, no queue available to send packet with.
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"generateHousekeepingPacket",
+				QUEUE_OR_DESTINATION_INVALID);
+		return QUEUE_OR_DESTINATION_INVALID;
+	}
+	if(destination == MessageQueueIF::NO_QUEUE) {
+		if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
+			// error, all destinations invalid
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"generateHousekeepingPacket",
+					QUEUE_OR_DESTINATION_INVALID);
+		}
+		destination = hkDestinationId;
+	}
 
-    return hkQueue->sendMessage(destination, &hkMessage);
+	return hkQueue->sendMessage(destination, &hkMessage);
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-        HousekeepingPacketDownlink& hkPacket,
-        store_address_t& storeId, bool forDownlink,
-        size_t* serializedSize) {
-    uint8_t* dataPtr = nullptr;
-    const size_t maxSize = hkPacket.getSerializedSize();
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            maxSize, &dataPtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
+		HousekeepingPacketDownlink& hkPacket,
+		store_address_t& storeId, bool forDownlink,
+		size_t* serializedSize) {
+	uint8_t* dataPtr = nullptr;
+	const size_t maxSize = hkPacket.getSerializedSize();
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			maxSize, &dataPtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
 
-    if(forDownlink) {
-        return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-                SerializeIF::Endianness::BIG);
-    }
-    return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-            SerializeIF::Endianness::MACHINE);
+	if(forDownlink) {
+		return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+				SerializeIF::Endianness::BIG);
+	}
+	return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+			SerializeIF::Endianness::MACHINE);
 }
 
 void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
-        uint8_t nonDiagInvlFactor) {
-    this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
+		uint8_t nonDiagInvlFactor) {
+	this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
 }
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
-    sid_t sid = receiver.dataId.sid;
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"performPeriodicHkGeneration",
-    			DATASET_NOT_FOUND);
-    	return;
-    }
+	sid_t sid = receiver.dataId.sid;
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet == nullptr) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"performPeriodicHkGeneration",
+				DATASET_NOT_FOUND);
+		return;
+	}
 
-    if(not dataSet->getReportingEnabled()) {
-        return;
-    }
+	if(not dataSet->getReportingEnabled()) {
+		return;
+	}
 
-    if(dataSet->periodicHelper == nullptr) {
-        // Configuration error.
-        return;
-    }
+	if(dataSet->periodicHelper == nullptr) {
+		// Configuration error.
+		return;
+	}
 
-    if(not dataSet->periodicHelper->checkOpNecessary()) {
-        return;
-    }
+	if(not dataSet->periodicHelper->checkOpNecessary()) {
+		return;
+	}
 
-    ReturnValue_t result = generateHousekeepingPacket(
-            sid, dataSet, true);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        // configuration error
+	ReturnValue_t result = generateHousekeepingPacket(
+			sid, dataSet, true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		// configuration error
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalDataPoolManager::performHkOperation: "
-                << "HK generation failed." << std::endl;
+		sif::warning << "LocalDataPoolManager::performHkOperation: "
+				<< "HK generation failed." << std::endl;
 #else
-        fsfw::printWarning("LocalDataPoolManager::performHkOperation: "
-        		"HK generation failed.\n");
+		fsfw::printWarning("LocalDataPoolManager::performHkOperation: "
+				"HK generation failed.\n");
 #endif
-    }
+	}
 }
 
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
-        bool enable, bool isDiagnostics) {
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if((dataSet->isDiagnostics() and not isDiagnostics) or
-            (not dataSet->isDiagnostics() and isDiagnostics)) {
-        return WRONG_HK_PACKET_TYPE;
-    }
+		bool enable, bool isDiagnostics) {
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if((dataSet->isDiagnostics() and not isDiagnostics) or
+			(not dataSet->isDiagnostics() and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    if((dataSet->getReportingEnabled() and enable) or
-            (not dataSet->getReportingEnabled() and not enable)) {
-        return REPORTING_STATUS_UNCHANGED;
-    }
+	if((dataSet->getReportingEnabled() and enable) or
+			(not dataSet->getReportingEnabled() and not enable)) {
+		return REPORTING_STATUS_UNCHANGED;
+	}
 
-    dataSet->setReportingEnabled(enable);
-    return HasReturnvaluesIF::RETURN_OK;
+	dataSet->setReportingEnabled(enable);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
-        float newCollectionInterval, bool isDiagnostics) {
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    bool targetIsDiagnostics = dataSet->isDiagnostics();
-    if((targetIsDiagnostics and not isDiagnostics) or
-            (not targetIsDiagnostics and isDiagnostics)) {
-        return WRONG_HK_PACKET_TYPE;
-    }
+		float newCollectionInterval, bool isDiagnostics) {
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	bool targetIsDiagnostics = dataSet->isDiagnostics();
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    if(dataSet->periodicHelper == nullptr) {
-        // config error
-        return PERIODIC_HELPER_INVALID;
-    }
+	if(dataSet->periodicHelper == nullptr) {
+		// config error
+		return PERIODIC_HELPER_INVALID;
+	}
 
-    dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
-    return HasReturnvaluesIF::RETURN_OK;
+	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
-        bool isDiagnostics) {
-    // Get and check dataset first.
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"performPeriodicHkGeneration",
-    			DATASET_NOT_FOUND);
-        return DATASET_NOT_FOUND;
-    }
+		bool isDiagnostics) {
+	// Get and check dataset first.
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet == nullptr) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"performPeriodicHkGeneration",
+				DATASET_NOT_FOUND);
+		return DATASET_NOT_FOUND;
+	}
 
 
-    bool targetIsDiagnostics = dataSet->isDiagnostics();
-    if((targetIsDiagnostics and not isDiagnostics) or
-            (not targetIsDiagnostics and isDiagnostics)) {
-        return WRONG_HK_PACKET_TYPE;
-    }
+	bool targetIsDiagnostics = dataSet->isDiagnostics();
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    bool valid = dataSet->isValid();
-    bool reportingEnabled = dataSet->getReportingEnabled();
-    float collectionInterval =
-            dataSet->periodicHelper->getCollectionIntervalInSeconds();
+	bool valid = dataSet->isValid();
+	bool reportingEnabled = dataSet->getReportingEnabled();
+	float collectionInterval =
+			dataSet->periodicHelper->getCollectionIntervalInSeconds();
 
-    // Generate set packet which can be serialized.
-    HousekeepingSetPacket setPacket(sid,
-            reportingEnabled, valid, collectionInterval, dataSet);
-    size_t expectedSize = setPacket.getSerializedSize();
-    uint8_t* storePtr = nullptr;
-    store_address_t storeId;
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            expectedSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
-    			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
+	// Generate set packet which can be serialized.
+	HousekeepingSetPacket setPacket(sid,
+			reportingEnabled, valid, collectionInterval, dataSet);
+	size_t expectedSize = setPacket.getSerializedSize();
+	uint8_t* storePtr = nullptr;
+	store_address_t storeId;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			expectedSize,&storePtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+				"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not get free element from IPC store.");
-        return result;
-    }
+		return result;
+	}
 
-    // Serialize set packet into store.
-    size_t size = 0;
-    result = setPacket.serialize(&storePtr, &size, expectedSize,
-            SerializeIF::Endianness::BIG);
-    if(expectedSize != size) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
+	// Serialize set packet into store.
+	size_t size = 0;
+	result = setPacket.serialize(&storePtr, &size, expectedSize,
+			SerializeIF::Endianness::BIG);
+	if(expectedSize != size) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
 				"Expected size is not equal to serialized size");
-    }
+	}
 
-    // Send structure reporting reply.
-    CommandMessage reply;
-    if(isDiagnostics) {
-        HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
-                sid, storeId);
-    }
-    else {
-        HousekeepingMessage::setHkStuctureReportReply(&reply,
-                sid, storeId);
-    }
+	// Send structure reporting reply.
+	CommandMessage reply;
+	if(isDiagnostics) {
+		HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
+				sid, storeId);
+	}
+	else {
+		HousekeepingMessage::setHkStuctureReportReply(&reply,
+				sid, storeId);
+	}
 
-    hkQueue->reply(&reply);
-    return result;
+	hkQueue->reply(&reply);
+	return result;
 }
 
 void LocalDataPoolManager::clearReceiversList() {
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 22019c2f5..26eb9fce6 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -4,6 +4,7 @@
 #include "LocalPoolObjectBase.h"
 #include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
+#include "AccessLocalPoolF.h"
 
 #include "../datapool/PoolVariableIF.h"
 #include "../datapool/DataSetIF.h"
@@ -23,7 +24,7 @@
  * @ingroup data_pool
  */
 template<typename T>
-class LocalPoolVariable: public LocalPoolObjectBase {
+class LocalPoolVariable: public LocalPoolObjectBase, public AccessLocalPoolIF<T> {
 public:
 	//! Default ctor is forbidden.
 	LocalPoolVariable() = delete;

From 0109428d470193820d5cd66bdee83db216ea9f73 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:46:40 +0100
Subject: [PATCH 1432/1774] indentation

---
 datapoollocal/LocalDataPoolManager.cpp |  5 +-
 datapoollocal/LocalPoolObjectBase.cpp  | 74 +++++++++++++-------------
 2 files changed, 39 insertions(+), 40 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 995a54a4c..de8517878 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -13,12 +13,11 @@
 #include <array>
 #include <cmath>
 
-object_id_t LocalDataPoolManager::defaultHkDestination =
-		objects::PUS_SERVICE_3_HOUSEKEEPING;
+object_id_t LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING;
 
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
 		bool appendValidityBuffer):
-						appendValidityBuffer(appendValidityBuffer) {
+		appendValidityBuffer(appendValidityBuffer) {
 	if(owner == nullptr) {
 		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 				"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 18414d40b..c74380cf6 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -3,76 +3,76 @@
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
 		localPoolId(poolId), readWriteMode(setReadWriteMode) {
-    if(poolId == PoolVariableIF::NO_PARAMETER) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+				<< "which is the NO_PARAMETER value!" << std::endl;
 #endif
-    }
-    if(hkOwner == nullptr) {
+	}
+	if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
-                << "owner is a invalid!" << std::endl;
+		sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+				<< "owner is a invalid!" << std::endl;
 #endif
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-    if (dataSet != nullptr) {
-        dataSet->registerVariable(this);
-    }
+		return;
+	}
+	hkManager = hkOwner->getHkManagerHandle();
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
 }
 
 LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF *dataSet,
 		pool_rwm_t setReadWriteMode):
-		localPoolId(poolId), readWriteMode(setReadWriteMode) {
-    if(poolId == PoolVariableIF::NO_PARAMETER) {
+				localPoolId(poolId), readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+				<< "which is the NO_PARAMETER value!" << std::endl;
 #endif
-    }
-    HasLocalDataPoolIF* hkOwner =
-            objectManager->get<HasLocalDataPoolIF>(poolOwner);
-    if(hkOwner == nullptr) {
+	}
+	HasLocalDataPoolIF* hkOwner =
+			objectManager->get<HasLocalDataPoolIF>(poolOwner);
+	if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalPoolVariable: The supplied pool owner did not "
-                << "implement the correct interface"
-                << " HasLocalDataPoolIF!" << std::endl;
+		sif::error << "LocalPoolVariable: The supplied pool owner did not "
+				<< "implement the correct interface"
+				<< " HasLocalDataPoolIF!" << std::endl;
 #endif
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-    if(dataSet != nullptr) {
-        dataSet->registerVariable(this);
-    }
+		return;
+	}
+	hkManager = hkOwner->getHkManagerHandle();
+	if(dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
 }
 
 pool_rwm_t LocalPoolObjectBase::getReadWriteMode() const {
-    return readWriteMode;
+	return readWriteMode;
 }
 
 bool LocalPoolObjectBase::isValid() const {
-    return valid;
+	return valid;
 }
 
 void LocalPoolObjectBase::setValid(bool valid) {
-    this->valid = valid;
+	this->valid = valid;
 }
 
 lp_id_t LocalPoolObjectBase::getDataPoolId() const {
-    return localPoolId;
+	return localPoolId;
 }
 
 void LocalPoolObjectBase::setDataPoolId(lp_id_t poolId) {
-    this->localPoolId = poolId;
+	this->localPoolId = poolId;
 }
 
 void LocalPoolObjectBase::setChanged(bool changed) {
-    this->changed = changed;
+	this->changed = changed;
 }
 
 bool LocalPoolObjectBase::hasChanged() const {
-    return changed;
+	return changed;
 }
 
 void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {

From bb10c259096d9837c1dfe35b4d6a55c846eca0f6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 00:13:49 +0100
Subject: [PATCH 1433/1774] introduced new accessor IF

---
 controller/ExtendedControllerBase.cpp    |  4 ++++
 controller/ExtendedControllerBase.h      |  1 +
 datapoollocal/AccessLocalPoolF.h         | 22 +++++++++++++++----
 datapoollocal/HasLocalDataPoolIF.h       |  5 +++--
 datapoollocal/LocalDataPoolManager.cpp   | 18 ++++++++++++---
 datapoollocal/LocalDataPoolManager.h     |  9 ++++++--
 datapoollocal/LocalPoolDataSetBase.cpp   | 28 +++++++++++-------------
 datapoollocal/LocalPoolDataSetBase.h     |  4 ++--
 datapoollocal/LocalPoolVariable.h        |  2 +-
 datapoollocal/LocalPoolVariable.tpp      |  8 +++----
 datapoollocal/LocalPoolVector.tpp        |  8 +++----
 devicehandlers/DeviceHandlerBase.cpp     |  4 ++++
 devicehandlers/DeviceHandlerBase.h       |  3 +++
 devicehandlers/DeviceHandlerThermalSet.h |  2 +-
 internalError/InternalErrorReporter.cpp  |  4 ++++
 internalError/InternalErrorReporter.h    |  1 +
 16 files changed, 85 insertions(+), 38 deletions(-)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 3759d9c72..2b72a89d5 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -106,6 +106,10 @@ MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
     return commandQueue->getId();
 }
 
+AccessLocalPoolIF* ExtendedControllerBase::getAccessorHandle() {
+	return &localPoolManager;
+}
+
 LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index 7e6d32da9..47c180e64 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -33,6 +33,7 @@ public:
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
+   AccessLocalPoolIF* getAccessorHandle() override;
 
 protected:
     LocalDataPoolManager localPoolManager;
diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
index 7b507523f..51d2ec46b 100644
--- a/datapoollocal/AccessLocalPoolF.h
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -1,17 +1,31 @@
 #ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
 #define FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
 
-#include <fsfw/datapool/PoolEntry.h>
 #include <fsfw/datapoollocal/locPoolDefinitions.h>
+#include <fsfw/datapool/PoolEntry.h>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/ipc/MutexIF.h>
 
-template <typename T>
 class AccessLocalPoolIF {
 public:
-	virtual~ AccessLocalPoolIF() {};
+	virtual ~AccessLocalPoolIF() {};
 
-	virtual ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry) = 0;
+	virtual ReturnValue_t retrieveLocalPoolMutex(MutexIF* mutex) = 0;
+	virtual object_id_t getCreatorObjectId() const = 0;
+
+protected:
+
+	//virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 };
 
+//template <typename T>
+//class AccessLocalPoolTypedIF {
+//public:
+//	virtual ~AccessLocalPoolTypedIF() {};
+//
+//	virtual ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry) = 0;
+//};
+
 
 
 #endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 263a4e79d..967abd4a8 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
+#include "AccessLocalPoolF.h"
 #include "ProvidesDataPoolSubscriptionIF.h"
 #include "locPoolDefinitions.h"
 
@@ -54,8 +55,6 @@ public:
 
 	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
-	virtual object_id_t getObjectId() const = 0;
-
 	/** Command queue for housekeeping messages. */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
@@ -124,6 +123,8 @@ public:
 	 * @return
 	 */
 	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
+
+	virtual AccessLocalPoolIF* getAccessorHandle() = 0;
 protected:
 
 	/**
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index de8517878..4aeb8677f 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -410,7 +410,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
 		MessageQueueId_t targetQueueId, bool generateSnapshot) {
 	struct HkReceiver hkReceiver;
 	hkReceiver.dataType = DataType::DATA_SET;
-	hkReceiver.dataId.sid = sid_t(this->getOwner()->getObjectId(), setId);
+	hkReceiver.dataId.sid = sid_t(this->getCreatorObjectId(), setId);
 	hkReceiver.destinationQueue = targetQueueId;
 	hkReceiver.objectId = destinationObject;
 	if(generateSnapshot) {
@@ -822,6 +822,18 @@ void LocalDataPoolManager::clearReceiversList() {
 	HkReceivers().swap(hkReceiversMap);
 }
 
+ReturnValue_t LocalDataPoolManager::retrieveLocalPoolMutex(MutexIF *mutex) {
+	if(this->mutex == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	mutex = this->mutex;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+object_id_t LocalDataPoolManager::getCreatorObjectId() const {
+	return owner->getAccessorHandle()->getCreatorObjectId();
+}
+
 void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 		const char* functionName, ReturnValue_t error, const char* errorPrint) {
 	if(errorPrint == nullptr) {
@@ -857,7 +869,7 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
-				<< std::hex << owner->getObjectId() << " | " << errorPrint
+				<< std::hex << this->getCreatorObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
 		fsfw::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
@@ -868,7 +880,7 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
-				<< std::hex << owner->getObjectId() << " | " << errorPrint
+				<< std::hex << this->getCreatorObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
 		fsfw::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 6a87e716d..3544c9446 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -50,10 +50,11 @@ class HousekeepingPacketUpdate;
  * Each pool entry has a valid state too.
  * @author 		R. Mueller
  */
-class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF {
+class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF,
+		public AccessLocalPoolIF {
 	template<typename T> friend class LocalPoolVariable;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
-	friend class LocalPoolDataSetBase;
+	//friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
@@ -176,6 +177,8 @@ public:
             MessageQueueId_t targetQueueId,
             bool generateSnapshot) override;
 
+    ReturnValue_t retrieveLocalPoolMutex(MutexIF* mutex) override;
+
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
 	 * than diagnostic packets.
@@ -259,6 +262,8 @@ public:
      * the insertion operations allocate dynamically.
      */
     void clearReceiversList();
+
+    object_id_t getCreatorObjectId() const override;
 private:
     LocalDataPool localPoolMap;
     //! Every housekeeping data manager has a mutex to protect access
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 8a39823ea..c4bed0a41 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -23,13 +23,14 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
     }
-    hkManager = hkOwner->getHkManagerHandle();
+    localPoolAccessor = hkOwner->getAccessorHandle();
 
-    if(hkManager != nullptr) {
-        mutexIfSingleDataCreator = hkManager->getMutexHandle();
+    if(localPoolAccessor != nullptr) {
+    	localPoolAccessor->retrieveLocalPoolMutex(mutexIfSingleDataCreator);
+        //mutexIfSingleDataCreator = hkManager->getAc();
     }
 
-    this->sid.objectId = hkOwner->getObjectId();
+    this->sid.objectId = localPoolAccessor->getCreatorObjectId();
     this->sid.ownerSetId = setId;
 
     // Data creators get a periodic helper for periodic HK data generation.
@@ -42,15 +43,15 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
-    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+	AccessLocalPoolIF* hkOwner = objectManager->get<AccessLocalPoolIF>(
             sid.objectId);
     if(hkOwner != nullptr) {
-        hkManager = hkOwner->getHkManagerHandle();
+        ReturnValue_t result = hkOwner->retrieveLocalPoolMutex(mutexIfSingleDataCreator);
     }
 
-    if(hkManager != nullptr) {
-        mutexIfSingleDataCreator = hkManager->getMutexHandle();
-    }
+    //if(hkManager != nullptr) {
+    //    mutexIfSingleDataCreator = hkManager->getMutexHandle();
+    //}
     this->sid = sid;
 }
 
@@ -308,12 +309,9 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     this->valid = valid;
 }
 
-object_id_t LocalPoolDataSetBase::getCreatorObjectId(object_id_t objectId) {
-	if(hkManager != nullptr) {
-		HasLocalDataPoolIF* owner = hkManager->getOwner();
-		if(owner != nullptr) {
-			return owner->getObjectId();
-		}
+object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
+	if(localPoolAccessor != nullptr) {
+		return localPoolAccessor->getCreatorObjectId();
 	}
 	return objects::NO_OBJECT;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 9df65b9c7..442d93c83 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -150,7 +150,7 @@ public:
 	void setChanged(bool changed) override;
 	bool hasChanged() const override;
 
-	object_id_t getCreatorObjectId(object_id_t objectId);
+	object_id_t getCreatorObjectId();
 protected:
 	sid_t sid;
 	//! This mutex is used if the data is created by one object only.
@@ -217,7 +217,7 @@ protected:
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
-	LocalDataPoolManager* hkManager = nullptr;
+	AccessLocalPoolIF* localPoolAccessor = nullptr;
 
 };
 
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 26eb9fce6..eac915160 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -24,7 +24,7 @@
  * @ingroup data_pool
  */
 template<typename T>
-class LocalPoolVariable: public LocalPoolObjectBase, public AccessLocalPoolIF<T> {
+class LocalPoolVariable: public LocalPoolObjectBase {
 public:
 	//! Default ctor is forbidden.
 	LocalPoolVariable() = delete;
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index ef94b6207..e55ea2a0f 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -33,7 +33,7 @@ inline ReturnValue_t LocalPoolVariable<T>::read(
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector",
 				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
 				localPoolId);
@@ -43,7 +43,7 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
-		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVariable", result,
 				false, ownerObjectId, localPoolId);
 		return result;
@@ -80,7 +80,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector",
 				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
 				localPoolId);
@@ -90,7 +90,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
-		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVariable", result,
 				false, ownerObjectId, localPoolId);
 		return result;
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index f311c23d5..24421b0b6 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -32,7 +32,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector",
 				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
 				localPoolId);
@@ -44,7 +44,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	memset(this->value, 0, vectorSize * sizeof(T));
 
 	if(result != RETURN_OK) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
 				localPoolId);
 		return result;
@@ -71,7 +71,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector",
 				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
 				localPoolId);
@@ -80,7 +80,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
 				localPoolId);
 		return result;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 8f64dd258..2492535a4 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1488,6 +1488,10 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 	}
 }
 
+AccessLocalPoolIF* DeviceHandlerBase::getAccessorHandle() {
+	return &hkManager;
+}
+
 void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
 		const char *functionName, ReturnValue_t errorCode,
 		const char *errorPrint) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index a2f603929..f3f208a60 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -517,11 +517,14 @@ protected:
 	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
 				LocalDataPoolManager& poolManager) override;
 
+
 	/** Get the HK manager object handle */
 	LocalDataPoolManager* getHkManagerHandle() override;
 
 	ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
+	AccessLocalPoolIF* getAccessorHandle() override;
+
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
 	 * 			performOperation(). Default implementation is empty.
diff --git a/devicehandlers/DeviceHandlerThermalSet.h b/devicehandlers/DeviceHandlerThermalSet.h
index 239012e26..0fabd3b30 100644
--- a/devicehandlers/DeviceHandlerThermalSet.h
+++ b/devicehandlers/DeviceHandlerThermalSet.h
@@ -15,7 +15,7 @@ public:
 					DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
 			lp_id_t heaterRequestId =
 					DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID):
-			DeviceHandlerThermalSet(hkOwner->getObjectId(), setId,
+			DeviceHandlerThermalSet(hkOwner->getAccessorHandle()->getCreatorObjectId(), setId,
 					thermalStateId, heaterRequestId) {}
 
 	DeviceHandlerThermalSet(object_id_t deviceHandler, uint32_t setId =
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 6c722789c..0817c0809 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -134,6 +134,10 @@ uint32_t InternalErrorReporter::getStoreHits() {
 	return value;
 }
 
+AccessLocalPoolIF* InternalErrorReporter::getAccessorHandle() {
+	return &poolManager;
+}
+
 void InternalErrorReporter::incrementStoreHits() {
 	mutex->lockMutex(timeoutType, timeoutMs);
 	storeHits++;
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 8085d918f..5bd5785a6 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -47,6 +47,7 @@ public:
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
     ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
+	AccessLocalPoolIF* getAccessorHandle() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;

From 071ce21f09a0afd7abf10e34e003d76a6e24e02a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 13:12:44 +0100
Subject: [PATCH 1434/1774] renamed namepsace for printers

---
 serviceinterface/ServiceInterfacePrinter.cpp  | 60 +++++++++----------
 serviceinterface/ServiceInterfacePrinter.h    |  2 +-
 serviceinterface/serviceInterfaceDefintions.h |  2 +-
 3 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index fff6753b8..f3d34bb0d 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -6,7 +6,7 @@
 #include <cstdarg>
 #include <cstdint>
 
-static fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG_LEVEL;
+static sif::PrintLevel printLevel = sif::PrintLevel::DEBUG_LEVEL;
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
 static bool consoleInitialized = false;
 #endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
@@ -15,7 +15,7 @@ static bool addCrAtEnd = false;
 #if FSFW_DISABLE_PRINTOUT == 0
 uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 
-void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
+void fsfwPrint(sif::PrintLevel printType, const char* fmt, va_list arg) {
 
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
 	if(not consoleInitialized) {
@@ -32,38 +32,38 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     char* bufferPosition = reinterpret_cast<char*>(printBuffer);
 
     /* Check logger level */
-    if(printType == fsfw::PrintLevel::NONE or printType > printLevel) {
+    if(printType == sif::PrintLevel::NONE or printType > printLevel) {
         return;
     }
 
     /* Log message to terminal */
 
 #if FSFW_COLORED_OUTPUT == 1
-    if(printType == fsfw::PrintLevel::INFO_LEVEL) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_GREEN);
+    if(printType == sif::PrintLevel::INFO_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_GREEN);
     }
-    else if(printType == fsfw::PrintLevel::DEBUG_LEVEL) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_MAGENTA);
+    else if(printType == sif::PrintLevel::DEBUG_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_MAGENTA);
     }
-    else if(printType == fsfw::PrintLevel::WARNING_LEVEL) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_YELLOW);
+    else if(printType == sif::PrintLevel::WARNING_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_YELLOW);
     }
-    else if(printType == fsfw::PrintLevel::ERROR_LEVEL) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_RED);
+    else if(printType == sif::PrintLevel::ERROR_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_RED);
     }
 #endif
 
-   if (printType == fsfw::PrintLevel::INFO_LEVEL) {
+   if (printType == sif::PrintLevel::INFO_LEVEL) {
        len += sprintf(bufferPosition + len, "INFO: ");
    }
-   if(printType == fsfw::PrintLevel::DEBUG_LEVEL) {
+   if(printType == sif::PrintLevel::DEBUG_LEVEL) {
 	   len += sprintf(bufferPosition + len, "DEBUG: ");
    }
-   if(printType == fsfw::PrintLevel::WARNING_LEVEL) {
+   if(printType == sif::PrintLevel::WARNING_LEVEL) {
 	   len += sprintf(bufferPosition + len, "WARNING: ");
    }
 
-   if(printType == fsfw::PrintLevel::ERROR_LEVEL) {
+   if(printType == sif::PrintLevel::ERROR_LEVEL) {
 	   len += sprintf(bufferPosition + len, "ERROR: ");
    }
 
@@ -88,51 +88,51 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 }
 
 
-void fsfw::printInfo(const char *fmt, ...) {
+void sif::printInfo(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::INFO_LEVEL, fmt, args);
+    fsfwPrint(sif::PrintLevel::INFO_LEVEL, fmt, args);
     va_end(args);
 }
 
-void fsfw::printWarning(const char *fmt, ...) {
+void sif::printWarning(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::WARNING_LEVEL, fmt, args);
+    fsfwPrint(sif::PrintLevel::WARNING_LEVEL, fmt, args);
     va_end(args);
 }
 
-void fsfw::printDebug(const char *fmt, ...) {
+void sif::printDebug(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::DEBUG_LEVEL, fmt, args);
+    fsfwPrint(sif::PrintLevel::DEBUG_LEVEL, fmt, args);
     va_end(args);
 }
 
-void fsfw::setToAddCrAtEnd(bool addCrAtEnd_) {
+void sif::setToAddCrAtEnd(bool addCrAtEnd_) {
 	addCrAtEnd = addCrAtEnd_;
 }
 
-void fsfw::printError(const char *fmt, ...) {
+void sif::printError(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::ERROR_LEVEL, fmt, args);
+    fsfwPrint(sif::PrintLevel::ERROR_LEVEL, fmt, args);
     va_end(args);
 }
 
 #else
 
-void fsfw::printInfo(const char *fmt, ...) {}
-void fsfw::printWarning(const char *fmt, ...) {}
-void fsfw::printDebug(const char *fmt, ...) {}
-void fsfw::printError(const char *fmt, ...) {}
+void sif::printInfo(const char *fmt, ...) {}
+void sif::printWarning(const char *fmt, ...) {}
+void sif::printDebug(const char *fmt, ...) {}
+void sif::printError(const char *fmt, ...) {}
 
 #endif /* FSFW_DISABLE_PRINTOUT == 0 */
 
-void fsfw::setPrintLevel(PrintLevel printLevel_) {
+void sif::setPrintLevel(PrintLevel printLevel_) {
 	printLevel = printLevel_;
 }
 
-fsfw::PrintLevel fsfw::getPrintLevel() {
+sif::PrintLevel sif::getPrintLevel() {
 	return printLevel;
 }
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index f49ccbb7e..fbdccdd16 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -2,7 +2,7 @@
 #include <cstdio>
 #endif
 
-namespace fsfw {
+namespace sif {
 
 enum PrintLevel {
 	NONE = 0,
diff --git a/serviceinterface/serviceInterfaceDefintions.h b/serviceinterface/serviceInterfaceDefintions.h
index de445907c..eb36a84b3 100644
--- a/serviceinterface/serviceInterfaceDefintions.h
+++ b/serviceinterface/serviceInterfaceDefintions.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
 #define FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
 
-namespace fsfw {
+namespace sif {
 
 enum class OutputTypes {
 	OUT_INFO,

From 7e394ea15fd199d9adcef11b779e12bb747cdcaa Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 13:18:18 +0100
Subject: [PATCH 1435/1774] replaced all fsfw:: by sif:: for printouts

---
 datapool/PoolEntry.cpp                        |  4 +-
 datapoollocal/HasLocalDataPoolIF.h            |  2 +-
 datapoollocal/LocalDataPoolManager.cpp        | 54 +++++++++----------
 datapoollocal/LocalDataPoolManager.h          |  6 +--
 datapoollocal/LocalPoolDataSetBase.cpp        |  6 +--
 datapoollocal/LocalPoolObjectBase.cpp         |  2 +-
 datapoollocal/LocalPoolVector.tpp             |  4 +-
 devicehandlers/DeviceHandlerBase.cpp          | 36 ++++++-------
 devicehandlers/DeviceHandlerBase.h            |  2 +-
 globalfunctions/arrayprinter.cpp              |  2 +-
 osal/linux/BinarySemaphore.cpp                |  4 +-
 osal/linux/MessageQueue.cpp                   |  2 +-
 osal/linux/PosixThread.cpp                    |  4 +-
 osal/linux/TmTcUnixUdpBridge.cpp              |  2 +-
 serviceinterface/ServiceInterfaceBuffer.cpp   | 10 ++--
 unittest/internal/UnittDefinitions.cpp        |  2 +-
 .../user/unittest/core/CatchDefinitions.cpp   |  2 +-
 17 files changed, 72 insertions(+), 72 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 1e99a28c4..a5867222b 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -73,8 +73,8 @@ void PoolEntry<T>::print() {
 	 sif::info << "PoolEntry information." << std::endl;
 	 sif::info << "PoolEntry validity: " << validString << std::endl;
 #else
-	 fsfw::printInfo("PoolEntry information.\n");
-	 fsfw::printInfo("PoolEntry validity: %s\n", validString);
+	 sif::printInfo("PoolEntry information.\n");
+	 sif::printInfo("PoolEntry validity: %s\n", validString);
 #endif
 	arrayprinter::print(reinterpret_cast<uint8_t*>(address), getByteSize());
 }
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 07c6882be..3aa9a554a 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -94,7 +94,7 @@ public:
 	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
 	            << ". Returning nullptr!" << std::endl;
 #else
-	    fsfw::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
+	    sif::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
 	    		"Not overriden. Returning nullptr!\n");
 #endif
 	    return nullptr;
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 2a0ec923c..0c5e6d70d 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -20,7 +20,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
                         appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
 				"Invalid supplied owner");
         return;
@@ -28,7 +28,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
     this->owner = owner;
     mutex = MutexFactory::instance()->createMutex();
     if(mutex == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR,
     			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not create mutex");
     }
@@ -41,7 +41,7 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
         // error, all destinations invalid
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR,
     			"initialize", QUEUE_OR_DESTINATION_INVALID);
     }
     hkQueue = queueToUse;
@@ -49,7 +49,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
     if(ipcStore == nullptr) {
     	// error, all destinations invalid
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR,
     			"initialize", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not set IPC store.");
         return HasReturnvaluesIF::RETURN_FAILED;
@@ -63,7 +63,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
             hkDestinationId = hkPacketReceiver->getHkQueue();
         }
         else {
-        	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+        	printWarningOrError(sif::OutputTypes::OUT_ERROR,
         			"initialize", QUEUE_OR_DESTINATION_INVALID);
         	return QUEUE_OR_DESTINATION_INVALID;
         }
@@ -88,7 +88,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
         return result;
     }
 
-	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+	printWarningOrError(sif::OutputTypes::OUT_WARNING,
 			"initialize", HasReturnvaluesIF::RETURN_FAILED,
 			"The map should only be initialized once");
     return HasReturnvaluesIF::RETURN_OK;
@@ -155,7 +155,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+        	printWarningOrError(sif::OutputTypes::OUT_WARNING,
         			"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
             return POOLOBJECT_NOT_FOUND;
         }
@@ -177,7 +177,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+        	printWarningOrError(sif::OutputTypes::OUT_WARNING,
         			"handleNotificationUpdate", DATASET_NOT_FOUND);
             return DATASET_NOT_FOUND;
         }
@@ -209,7 +209,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+        	printWarningOrError(sif::OutputTypes::OUT_WARNING,
         			"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
             return POOLOBJECT_NOT_FOUND;
         }
@@ -247,7 +247,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+        	printWarningOrError(sif::OutputTypes::OUT_WARNING,
         			"handleNotificationSnapshot", DATASET_NOT_FOUND);
             return DATASET_NOT_FOUND;
         }
@@ -355,7 +355,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
         return QUEUE_OR_DESTINATION_INVALID;
     }
@@ -385,7 +385,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
         return QUEUE_OR_DESTINATION_INVALID;
     }
@@ -594,7 +594,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
         lp_id_t localPoolId) {
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING, "printPoolEntry",
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING, "printPoolEntry",
     			 HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
         return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
@@ -615,7 +615,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t destination) {
     if(dataSet == nullptr) {
         // Configuration error.
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"generateHousekeepingPacket",
     			DATASET_NOT_FOUND);
         return DATASET_NOT_FOUND;
@@ -641,7 +641,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
     if(hkQueue == nullptr) {
         // error, no queue available to send packet with.
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"generateHousekeepingPacket",
     			QUEUE_OR_DESTINATION_INVALID);
         return QUEUE_OR_DESTINATION_INVALID;
@@ -649,7 +649,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
     if(destination == MessageQueueIF::NO_QUEUE) {
         if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
             // error, all destinations invalid
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+        	printWarningOrError(sif::OutputTypes::OUT_WARNING,
         			"generateHousekeepingPacket",
         			QUEUE_OR_DESTINATION_INVALID);
         }
@@ -688,7 +688,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
     sid_t sid = receiver.dataId.sid;
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"performPeriodicHkGeneration",
     			DATASET_NOT_FOUND);
     	return;
@@ -715,7 +715,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
         sif::warning << "LocalDataPoolManager::performHkOperation: "
                 << "HK generation failed." << std::endl;
 #else
-        fsfw::printWarning("LocalDataPoolManager::performHkOperation: "
+        sif::printWarning("LocalDataPoolManager::performHkOperation: "
         		"HK generation failed.\n");
 #endif
     }
@@ -762,7 +762,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     // Get and check dataset first.
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"performPeriodicHkGeneration",
     			DATASET_NOT_FOUND);
         return DATASET_NOT_FOUND;
@@ -789,7 +789,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
             expectedSize,&storePtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR,
     			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not get free element from IPC store.");
         return result;
@@ -800,7 +800,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     result = setPacket.serialize(&storePtr, &size, expectedSize,
             SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
 				"Expected size is not equal to serialized size");
     }
@@ -825,7 +825,7 @@ void LocalDataPoolManager::clearReceiversList() {
 	HkReceivers().swap(hkReceiversMap);
 }
 
-void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
+void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 		const char* functionName, ReturnValue_t error, const char* errorPrint) {
 	if(errorPrint == nullptr) {
 		if(error == DATASET_NOT_FOUND) {
@@ -835,7 +835,7 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 			errorPrint = "Pool Object not found";
 		}
 		else if(error == HasReturnvaluesIF::RETURN_FAILED) {
-			if(outputType == fsfw::OutputTypes::OUT_WARNING) {
+			if(outputType == sif::OutputTypes::OUT_WARNING) {
 				errorPrint = "Generic Warning";
 			}
 			else {
@@ -856,25 +856,25 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 		}
 	}
 
-	if(outputType == fsfw::OutputTypes::OUT_WARNING) {
+	if(outputType == sif::OutputTypes::OUT_WARNING) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
 				<< std::hex << owner->getObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
-		fsfw::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
+		sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
 				owner->getObjectId(), errorPrint);
 #endif
 	}
-	else if(outputType == fsfw::OutputTypes::OUT_ERROR) {
+	else if(outputType == sif::OutputTypes::OUT_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
 				<< std::hex << owner->getObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
-		fsfw::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
+		sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
 				owner->getObjectId(), errorPrint);
 #endif
 	}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 2ced2efd0..2bc0cf7ed 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -377,7 +377,7 @@ private:
 	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
 	        store_address_t& storeId);
 
-	void printWarningOrError(fsfw::OutputTypes outputType,
+	void printWarningOrError(sif::OutputTypes outputType,
 			const char* functionName,
 			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
 			const char* errorPrint = nullptr);
@@ -389,14 +389,14 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "fetchPoolEntry",
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
 				HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
 		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "fetchPoolEntry",
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
     			HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT);
 		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index af492146d..bd22698f4 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -18,7 +18,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
                 << "invalid!" << std::endl;
 #else
-        fsfw::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+        sif::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
                 "invalid!\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
@@ -171,7 +171,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
             sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
             		<< "Serialization error!" << std::endl;
 #else
-            fsfw::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
+            sif::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
             		"Serialization error!\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
             return result;
@@ -235,7 +235,7 @@ void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
         sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
                 << std::endl;
 #else
-        fsfw::printWarning("LocalPoolDataSetBase::bitSetter: "
+        sif::printWarning("LocalPoolDataSetBase::bitSetter: "
         		"Invalid position!\n\r");
 #endif
         return;
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index bb7822dad..c2872617a 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -114,7 +114,7 @@ void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
 			<< std::setfill('0') << objectId << std::dec << " LPID: " << lpId
 			<< std::endl;
 #else
-	fsfw::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
+	sif::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
 			variableType, type, errMsg, objectId, lpId);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_DISABLE_PRINTOUT == 0 */
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index f311c23d5..df2feb24f 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -101,7 +101,7 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
 	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
 #else
-	fsfw::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+	sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
 			" last value!\n");
 #endif
 	return value[vectorSize - 1];
@@ -118,7 +118,7 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
 	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
 #else
-	fsfw::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+	sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
 			" last value!\n");
 #endif
 	return value[vectorSize - 1];
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4fa7b09c0..d515ac975 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -36,7 +36,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
-		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
 				HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
 	}
 	if (this->fdirInstance == nullptr) {
@@ -124,7 +124,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	communicationInterface = objectManager->get<DeviceCommunicationIF>(
 			deviceCommunicationId);
 	if (communicationInterface == nullptr) {
-		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "initialize",
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
 				ObjectManagerIF::CHILD_INIT_FAILED,
 				"Passed communication IF invalid");
 		return ObjectManagerIF::CHILD_INIT_FAILED;
@@ -132,7 +132,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
-		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "initialize",
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
 				ObjectManagerIF::CHILD_INIT_FAILED,
 				"ComIF initialization failed");
 	    return result;
@@ -140,7 +140,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == nullptr) {
-		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "initialize",
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
 				ObjectManagerIF::CHILD_INIT_FAILED, "IPC Store not set up");
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
@@ -150,14 +150,14 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
-			printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+			printWarningOrError(sif::OutputTypes::OUT_ERROR,
 					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
 					"Raw receiver object ID set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "Make sure the raw receiver object is set up properly"
 					" and implements AcceptsDeviceResponsesIF" << std::endl;
 #else
-			fsfw::printError("Make sure the raw receiver object is set up "
+			sif::printError("Make sure the raw receiver object is set up "
 					"properly and implements AcceptsDeviceResponsesIF\n");
 #endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
@@ -168,14 +168,14 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == nullptr) {
-			printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+			printWarningOrError(sif::OutputTypes::OUT_ERROR,
 					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
 					"Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "Make sure the power switcher object is set up "
 					<< "properly and implements PowerSwitchIF" << std::endl;
 #else
-			fsfw::printError("Make sure the power switcher object is set up "
+			sif::printError("Make sure the power switcher object is set up "
 					"properly and implements PowerSwitchIF\n");
 #endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
@@ -717,7 +717,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
 			if(foundLen == 0) {
-				printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				printWarningOrError(sif::OutputTypes::OUT_WARNING,
 						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
 						"Found length is one, parsing might be stuck");
 			}
@@ -730,7 +730,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 			            foundId);
 			}
 			if(foundLen == 0) {
-				printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+				printWarningOrError(sif::OutputTypes::OUT_ERROR,
 						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
 						"Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -1292,7 +1292,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
 		    // so we can track misconfigurations
-			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
 					"buildInternalCommand",
 					HasReturnvaluesIF::RETURN_FAILED,
 					"Busy.");
@@ -1324,7 +1324,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 			sprintf(output, "Command 0x%08x is executing",
 					static_cast<unsigned int>(deviceCommandId));
 			// so we can track misconfigurations
-			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
 					"buildInternalCommand",
 					HasReturnvaluesIF::RETURN_FAILED,
 					output);
@@ -1488,7 +1488,7 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 	}
 }
 
-void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
+void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
 		const char *functionName, ReturnValue_t errorCode,
 		const char *errorPrint) {
 	if(errorPrint == nullptr) {
@@ -1496,7 +1496,7 @@ void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
 			errorPrint = "Initialization error";
 		}
 		if(errorCode == HasReturnvaluesIF::RETURN_FAILED) {
-			if(errorType == fsfw::OutputTypes::OUT_WARNING) {
+			if(errorType == sif::OutputTypes::OUT_WARNING) {
 				errorPrint = "Generic Warning";
 			}
 			else {
@@ -1508,25 +1508,25 @@ void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
 		}
 	}
 
-	if(errorType == fsfw::OutputTypes::OUT_WARNING) {
+	if(errorType == sif::OutputTypes::OUT_WARNING) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "DeviceHandlerBase::" << functionName << ": Object ID "
 				<< std::hex << std::setw(8) << std::setfill('0')
 				<< this->getObjectId() << " | " << errorPrint << std::dec
 				<< std::setfill(' ') << std::endl;
 #else
-		fsfw::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+		sif::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
 				this->getObjectId(), errorPrint);
 #endif
 	}
-	else if(errorType == fsfw::OutputTypes::OUT_ERROR) {
+	else if(errorType == sif::OutputTypes::OUT_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerBase::" << functionName << ": Object ID "
 				<< std::hex << std::setw(8) << std::setfill('0')
 				<< this->getObjectId() << " | " << errorPrint << std::dec
 				<< std::setfill(' ') << std::endl;
 #else
-		fsfw::printError("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+		sif::printError("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
 				this->getObjectId(), errorPrint);
 #endif
 	}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 4c745b4f1..414588e18 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1251,7 +1251,7 @@ private:
     void handleTransitionToOnMode(Mode_t commandedMode,
     		Submode_t commandedSubmode);
 
-    void printWarningOrError(fsfw::OutputTypes errorType,
+    void printWarningOrError(sif::OutputTypes errorType,
     		const char* functionName,
 			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
 			const char* errorPrint = nullptr);
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index ebf21bb86..25d6fcf4b 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -10,7 +10,7 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 	}
 	sif::info << "[";
 #else
-	fsfw::printInfo("Printing data with size %zu: [", size);
+	sif::printInfo("Printing data with size %zu: [", size);
 #endif
 	if(type == OutputType::HEX) {
 		arrayprinter::printHex(data, size, maxCharPerLine);
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index c2eb85149..5716e5602 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -114,7 +114,7 @@ uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
 	}
 	else if(result != 0 and errno == EINVAL) {
 		// Could be called from interrupt, use lightweight printf
-		fsfw::printError("BinarySemaphore::getSemaphoreCounter: "
+		sif::printError("BinarySemaphore::getSemaphoreCounter: "
 				"Invalid semaphore\n");
 		return 0;
 	}
@@ -136,7 +136,7 @@ void BinarySemaphore::initSemaphore(uint8_t initCount) {
 				sif::error << "BinarySemaphore: Init failed with "
 						<< strerror(errno) << std::endl;
 #else
-				fsfw::printError("BinarySemaphore: Init failed with %s\n",
+				sif::printError("BinarySemaphore: Init failed with %s\n",
 						strerror(errno));
 #endif
 		}
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index d93b7f6d5..60d15dee7 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -127,7 +127,7 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << name
 				<< " failed with status: " << strerror(errno) << std::endl;
 #else
-		fsfw::printError("MessageQueue::MessageQueue: Creating Queue %s"
+		sif::printError("MessageQueue::MessageQueue: Creating Queue %s"
 				" failed with status: %s\n", name, strerror(errno));
 #endif
 	}
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 8d368c182..2499b442e 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -151,7 +151,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 			sif::error << "PosixThread::createTask: Insufficient memory for"
 					" the requested " << stackMb << " MB" << std::endl;
 #else
-			fsfw::printError("PosixThread::createTask: Insufficient memory for "
+			sif::printError("PosixThread::createTask: Insufficient memory for "
 					"the requested %zu MB\n", stackMb);
 #endif
 		}
@@ -160,7 +160,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 			sif::error << "PosixThread::createTask: Wrong alignment argument!"
 					<< std::endl;
 #else
-			fsfw::printError("PosixThread::createTask: "
+			sif::printError("PosixThread::createTask: "
 					"Wrong alignment argument!\n");
 #endif
 		}
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 0bedce0f0..0af1fc68b 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -193,7 +193,7 @@ void TmTcUnixUdpBridge::handleSendError() {
 		sif::error << "TmTcUnixBridge::handleSendError: "
 		        << strerror(errno) << std::endl;
 #else
-		fsfw::printError("TmTcUnixBridge::handleSendError: %s\n",
+		sif::printError("TmTcUnixBridge::handleSendError: %s\n",
 				strerror(errno));
 #endif
 	}
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 5846d233a..1a02d6e90 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -29,19 +29,19 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 
 #if FSFW_COLORED_OUTPUT == 1
 	if(setMessage.find("DEBUG") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_MAGENTA;
+		colorPrefix = sif::ANSI_COLOR_MAGENTA;
 	}
 	else if(setMessage.find("INFO") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_GREEN;
+		colorPrefix = sif::ANSI_COLOR_GREEN;
 	}
 	else if(setMessage.find("WARNING") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_YELLOW;
+		colorPrefix = sif::ANSI_COLOR_YELLOW;
 	}
 	else if(setMessage.find("ERROR") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_RED;
+		colorPrefix = sif::ANSI_COLOR_RED;
 	}
 	else {
-		colorPrefix = fsfw::ANSI_COLOR_RESET;
+		colorPrefix = sif::ANSI_COLOR_RESET;
 	}
 
 #ifdef WIN32
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index d20771a43..517f561ab 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -5,7 +5,7 @@
 	sif::error << "Unit Tester error: Failed at test ID "
 			<< errorId << std::endl;
 #else
-	fsfw::printError("Unit Tester error: Failed at test ID 0x%08x", errorId);
+	sif::printError("Unit Tester error: Failed at test ID 0x%08x", errorId);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/unittest/user/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
index 531ee87b7..bae028759 100644
--- a/unittest/user/unittest/core/CatchDefinitions.cpp
+++ b/unittest/user/unittest/core/CatchDefinitions.cpp
@@ -9,7 +9,7 @@ StorageManagerIF* tglob::getIpcStoreHandle() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;
 #else
-		fsfw::printError("Global object manager uninitialized\n\r");
+		sif::printError("Global object manager uninitialized\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return nullptr;
 	}

From 25a86e91de099405992b9666fecf0605216907c0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 13:23:24 +0100
Subject: [PATCH 1436/1774] fixed warning of static var

---
 serviceinterface/ServiceInterfacePrinter.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index f3d34bb0d..a12f49e3c 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -10,9 +10,11 @@ static sif::PrintLevel printLevel = sif::PrintLevel::DEBUG_LEVEL;
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
 static bool consoleInitialized = false;
 #endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
-static bool addCrAtEnd = false;
 
 #if FSFW_DISABLE_PRINTOUT == 0
+
+static bool addCrAtEnd = false;
+
 uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 
 void fsfwPrint(sif::PrintLevel printType, const char* fmt, va_list arg) {

From cafc8e4ccbdd8ee5df48b7b7a247898b16d1cc20 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 14:08:51 +0100
Subject: [PATCH 1437/1774] updated attorneys

---
 controller/ExtendedControllerBase.cpp      |   6 +-
 controller/ExtendedControllerBase.h        |   3 +-
 datapoollocal/AccessLocalPoolF.h           |  33 +++---
 datapoollocal/HasLocalDataPoolIF.h         |  56 ++++------
 datapoollocal/HasLocalDataPoolIFAttorney.h |  38 +++++++
 datapoollocal/LocalDataPoolManager.cpp     | 114 ++++++++++++---------
 datapoollocal/LocalDataPoolManager.h       |  14 +--
 datapoollocal/LocalDpManagerAttorney.h     |  32 ++++++
 datapoollocal/LocalPoolDataSetAttorney.h   |  40 ++++++++
 datapoollocal/LocalPoolDataSetBase.cpp     |  19 ++--
 datapoollocal/LocalPoolDataSetBase.h       |   5 +-
 datapoollocal/LocalPoolObjectBase.cpp      |  10 +-
 datapoollocal/LocalPoolVariable.h          |   2 +-
 datapoollocal/LocalPoolVariable.tpp        |  12 ++-
 datapoollocal/LocalPoolVector.h            |   1 +
 datapoollocal/LocalPoolVector.tpp          |  10 +-
 devicehandlers/DeviceHandlerBase.cpp       |   7 +-
 devicehandlers/DeviceHandlerBase.h         |   4 +-
 devicehandlers/DeviceHandlerThermalSet.h   |   2 +-
 internalError/InternalErrorReporter.cpp    |   6 +-
 internalError/InternalErrorReporter.h      |   3 +-
 21 files changed, 266 insertions(+), 151 deletions(-)
 create mode 100644 datapoollocal/HasLocalDataPoolIFAttorney.h
 create mode 100644 datapoollocal/LocalDpManagerAttorney.h
 create mode 100644 datapoollocal/LocalPoolDataSetAttorney.h

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 2b72a89d5..379f189c5 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -26,7 +26,7 @@ object_id_t ExtendedControllerBase::getObjectId() const {
     return SystemObject::getObjectId();
 }
 
-LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() {
+AccessPoolManagerIF* ExtendedControllerBase::getAccessorHandle() {
     return &localPoolManager;
 }
 
@@ -106,10 +106,6 @@ MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
     return commandQueue->getId();
 }
 
-AccessLocalPoolIF* ExtendedControllerBase::getAccessorHandle() {
-	return &localPoolManager;
-}
-
 LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index 47c180e64..ed1d71930 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -33,7 +33,7 @@ public:
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
-   AccessLocalPoolIF* getAccessorHandle() override;
+   AccessPoolManagerIF* getAccessorHandle() override;
 
 protected:
     LocalDataPoolManager localPoolManager;
@@ -65,7 +65,6 @@ protected:
     virtual ReturnValue_t initializeLocalDataPool(
             LocalDataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
-    virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual uint32_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 };
diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
index 51d2ec46b..88ccec936 100644
--- a/datapoollocal/AccessLocalPoolF.h
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -1,31 +1,26 @@
 #ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
 #define FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
 
-#include <fsfw/datapoollocal/locPoolDefinitions.h>
-#include <fsfw/datapool/PoolEntry.h>
-#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+//#include "LocalDataPoolManager.h"
 #include <fsfw/ipc/MutexIF.h>
 
-class AccessLocalPoolIF {
-public:
-	virtual ~AccessLocalPoolIF() {};
+class LocalDataPoolManager;
 
-	virtual ReturnValue_t retrieveLocalPoolMutex(MutexIF* mutex) = 0;
-	virtual object_id_t getCreatorObjectId() const = 0;
+class AccessPoolManagerIF {
+public:
+	virtual ~AccessPoolManagerIF() {};
+
+	virtual MutexIF* getLocalPoolMutex() = 0;
+
+	/**
+	 * Can be used to get a handle to the local data pool manager.
+	 * This function is protected because it should only be used by the
+	 * class imlementing the interface.
+	 */
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 
 protected:
 
-	//virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 };
 
-//template <typename T>
-//class AccessLocalPoolTypedIF {
-//public:
-//	virtual ~AccessLocalPoolTypedIF() {};
-//
-//	virtual ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry) = 0;
-//};
-
-
-
 #endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 967abd4a8..c0899203e 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -12,7 +12,6 @@
 
 #include <map>
 
-class LocalDataPoolManager;
 class LocalPoolDataSetBase;
 class LocalPoolObjectBase;
 
@@ -20,31 +19,26 @@ using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
 using LocalDataPoolMapIter = LocalDataPool::iterator;
 
 /**
- * @brief 		This interface is implemented by classes which posses a local
- * 				data pool (not the managing class). It defines the relationship
- * 				between the local data pool owner and the LocalDataPoolManager.
+ * @brief 		This interface is implemented by classes which posses a local data pool (not the
+ * 				managing class). It defines the relationship between the local data pool owner
+ * 				and the LocalDataPoolManager.
  * @details
- * Any class implementing this interface shall also have a LocalDataPoolManager
- * member class which contains the actual pool data structure
- * and exposes the public interface for it.
- * This is required because the pool entries are templates, which makes
- * specifying an interface rather difficult. The local data pool can be
- * accessed by using the LocalPoolVariable, LocalPoolVector or LocalDataSet
- * classes.
+ * Any class implementing this interface shall also have a LocalDataPoolManager member class which
+ * contains the actual pool data structure and exposes the public interface for it.
+ * This is required because the pool entries are templates, which makes specifying an interface
+ * rather difficult. The local data pool can be accessed by using the LocalPoolVariable,
+ * LocalPoolVector or LocalDataSet classes.
  *
  * Architectural Note:
- * This could be circumvented by using a wrapper/accessor function or
- * implementing the templated function in this interface..
- * The first solution sounds better than the second but
- * the LocalPoolVariable classes are templates as well, so this just shifts
- * the problem somewhere else. Interfaces are nice, but the most
- * pragmatic solution I found was to offer the client the full interface
- * of the LocalDataPoolManager.
+ * This could be circumvented by using a wrapper/accessor function or implementing the templated
+ * function in this interface.. The first solution sounds better than the second but the
+ * LocalPoolVariable classes are templates as well, so this just shifts the problem somewhere else.
+ * Interfaces are nice, but the most pragmatic solution I found was to offer the client the full
+ * interface of the LocalDataPoolManager.
  */
 class HasLocalDataPoolIF {
-	friend class LocalDataPoolManager;
-	friend class LocalPoolDataSetBase;
-	friend class LocalPoolObjectBase;
+	friend class HasLocalDpIFManagerAttorney;
+	friend class HasLocalDpIFUserAttorney;
 public:
 	virtual~ HasLocalDataPoolIF() {};
 
@@ -55,6 +49,8 @@ public:
 
 	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
+	virtual object_id_t getObjectId() const = 0;
+
 	/** Command queue for housekeeping messages. */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
@@ -63,8 +59,7 @@ public:
 	 * The manager instance shall also be passed to this function.
 	 * It can be used to subscribe for periodic packets for for updates.
 	 */
-	virtual ReturnValue_t initializeLocalDataPool(
-	        LocalDataPool& localDataPoolMap,
+	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
 	        LocalDataPoolManager& poolManager) = 0;
 
 	/**
@@ -84,7 +79,7 @@ public:
      * the IPC store with this store ID.
      */
     virtual void handleChangedDataset(sid_t sid,
-            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
+    		store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
         return;
     }
 
@@ -112,27 +107,20 @@ public:
 	virtual ReturnValue_t removeDataSet(sid_t sid) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
-	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
-	        float newIntervalSeconds) {
+	virtual ReturnValue_t changeCollectionInterval(sid_t sid, float newIntervalSeconds) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
 
 	/**
-	 * This function can be used by data pool consumers to retrieve a  handle
+	 * This function can be used by data pool consumers to retrieve a handle
 	 * which allows subscriptions to dataset and variable updates.
 	 * @return
 	 */
 	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
 
-	virtual AccessLocalPoolIF* getAccessorHandle() = 0;
 protected:
 
-	/**
-	 * Can be used to get a handle to the local data pool manager.
-	 * This function is protected because it should only be used by the
-	 * class imlementing the interface.
-	 */
-	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+	virtual AccessPoolManagerIF* getAccessorHandle() = 0;
 
 	/**
 	 * This function is used by the pool manager to get a valid dataset
diff --git a/datapoollocal/HasLocalDataPoolIFAttorney.h b/datapoollocal/HasLocalDataPoolIFAttorney.h
new file mode 100644
index 000000000..dd01e74ee
--- /dev/null
+++ b/datapoollocal/HasLocalDataPoolIFAttorney.h
@@ -0,0 +1,38 @@
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIFATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIFATTORNEY_H_
+
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+
+class HasLocalDpIFUserAttorney {
+private:
+
+	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* interface) {
+		return interface->getAccessorHandle();
+	}
+
+	friend class LocalPoolObjectBase;
+	friend class LocalPoolDataSetBase;
+
+};
+
+class HasLocalDpIFManagerAttorney {
+
+	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* interface, sid_t sid) {
+		return interface->getDataSetHandle(sid);
+	}
+
+	static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* interface,
+			lp_id_t localPoolId) {
+		return interface->getPoolObjectHandle(localPoolId);
+	}
+
+	static object_id_t getObjectId(HasLocalDataPoolIF* interface) {
+		return interface->getObjectId();
+	}
+
+	friend class LocalDataPoolManager;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIFATTORNEY_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 4aeb8677f..f471bea86 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,6 +1,8 @@
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
+#include "HasLocalDataPoolIFAttorney.h"
+#include "LocalPoolDataSetAttorney.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
@@ -132,7 +134,7 @@ ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
 		// Update packets shall only be generated from datasets.
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
 			receiver.dataId.sid);
 	if(dataSet->hasChanged()) {
 		// prepare and send update notification
@@ -151,7 +153,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
 		ReturnValue_t& status) {
 	MarkChangedIF* toReset = nullptr;
 	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-		LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
+		LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
+				receiver.dataId.localPoolId);
+		//LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
 		if(poolObj == nullptr) {
 			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 					"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
@@ -172,7 +176,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
 
 	}
 	else {
-		LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(receiver.dataId.sid);
+		LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
+				receiver.dataId.sid);
 		if(dataSet == nullptr) {
 			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 					"handleNotificationUpdate", DATASET_NOT_FOUND);
@@ -203,7 +208,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 	MarkChangedIF* toReset = nullptr;
 	// check whether data has changed and send messages in case it has.
 	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-		LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+		LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
 				receiver.dataId.localPoolId);
 		if(poolObj == nullptr) {
 			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
@@ -221,7 +226,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 		CCSDSTime::CDS_short cds;
 		CCSDSTime::convertToCcsds(&cds, &now);
 		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-				sizeof(cds), owner->getPoolObjectHandle(
+				sizeof(cds), HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
 						receiver.dataId.localPoolId));
 
 		store_address_t storeId;
@@ -241,7 +246,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 		toReset = poolObj;
 	}
 	else {
-		LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+		LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
 				receiver.dataId.sid);
 		if(dataSet == nullptr) {
 			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
@@ -259,7 +264,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 		CCSDSTime::CDS_short cds;
 		CCSDSTime::convertToCcsds(&cds, &now);
 		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-				sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+				sizeof(cds), HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
+						receiver.dataId.sid));
 
 		store_address_t storeId;
 		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
@@ -363,11 +369,12 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	hkReceiver.dataType = DataType::DATA_SET;
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	if(dataSet != nullptr) {
-		dataSet->setReportingEnabled(enableReporting);
-		dataSet->setDiagnostic(isDiagnostics);
-		dataSet->initializePeriodicHelper(collectionInterval,
+		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enableReporting);
+		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
+		LocalPoolDataSetAttorney::initializePeriodicHelper(*dataSet, collectionInterval,
 				owner->getPeriodicOperationFrequency(), isDiagnostics);
 	}
 
@@ -393,10 +400,11 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
 	hkReceiver.dataType = DataType::DATA_SET;
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	if(dataSet != nullptr) {
-		dataSet->setReportingEnabled(true);
-		dataSet->setDiagnostic(isDiagnostics);
+		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, true);
+		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
 	}
 
 	hkReceiversMap.push_back(hkReceiver);
@@ -410,7 +418,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
 		MessageQueueId_t targetQueueId, bool generateSnapshot) {
 	struct HkReceiver hkReceiver;
 	hkReceiver.dataType = DataType::DATA_SET;
-	hkReceiver.dataId.sid = sid_t(this->getCreatorObjectId(), setId);
+	hkReceiver.dataId.sid = sid_t(owner->getObjectId(), setId);
 	hkReceiver.destinationQueue = targetQueueId;
 	hkReceiver.objectId = destinationObject;
 	if(generateSnapshot) {
@@ -534,13 +542,14 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 
 	case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
 	case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
-		LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+		LocalPoolDataSetBase* dataSet =HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+		//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 		if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
-				and dataSet->isDiagnostics()) {
+				and LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
 			return WRONG_HK_PACKET_TYPE;
 		}
 		else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
-				and not dataSet->isDiagnostics()) {
+				and not LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
 			return WRONG_HK_PACKET_TYPE;
 		}
 		return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
@@ -629,7 +638,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
 	// and now we set a HK message and send it the HK packet destination.
 	CommandMessage hkMessage;
-	if(dataSet->isDiagnostics()) {
+	if(LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
 		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
 	}
 	else {
@@ -683,7 +692,8 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 	sid_t sid = receiver.dataId.sid;
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
 	if(dataSet == nullptr) {
 		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 				"performPeriodicHkGeneration",
@@ -691,16 +701,19 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 		return;
 	}
 
-	if(not dataSet->getReportingEnabled()) {
+	if(not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet)) {
 		return;
 	}
 
-	if(dataSet->periodicHelper == nullptr) {
+	PeriodicHousekeepingHelper* periodicHelper =
+			LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
+
+	if(periodicHelper == nullptr) {
 		// Configuration error.
 		return;
 	}
 
-	if(not dataSet->periodicHelper->checkOpNecessary()) {
+	if(periodicHelper->checkOpNecessary()) {
 		return;
 	}
 
@@ -721,43 +734,49 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
 		bool enable, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if((dataSet->isDiagnostics() and not isDiagnostics) or
-			(not dataSet->isDiagnostics() and isDiagnostics)) {
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	if((LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and not isDiagnostics) or
+			(not LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
 	}
 
-	if((dataSet->getReportingEnabled() and enable) or
-			(not dataSet->getReportingEnabled() and not enable)) {
+	if((LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and enable) or
+			(not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and not enable)) {
 		return REPORTING_STATUS_UNCHANGED;
 	}
 
-	dataSet->setReportingEnabled(enable);
+	LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enable);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 		float newCollectionInterval, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	bool targetIsDiagnostics = dataSet->isDiagnostics();
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
 	if((targetIsDiagnostics and not isDiagnostics) or
 			(not targetIsDiagnostics and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
 	}
 
-	if(dataSet->periodicHelper == nullptr) {
+	PeriodicHousekeepingHelper* periodicHelper =
+			LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
+
+	if(periodicHelper == nullptr) {
 		// config error
 		return PERIODIC_HELPER_INVALID;
 	}
 
-	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
+	periodicHelper->changeCollectionInterval(newCollectionInterval);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		bool isDiagnostics) {
 	// Get and check dataset first.
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
 	if(dataSet == nullptr) {
 		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 				"performPeriodicHkGeneration",
@@ -766,16 +785,16 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 	}
 
 
-	bool targetIsDiagnostics = dataSet->isDiagnostics();
+	bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
 	if((targetIsDiagnostics and not isDiagnostics) or
 			(not targetIsDiagnostics and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
 	}
 
 	bool valid = dataSet->isValid();
-	bool reportingEnabled = dataSet->getReportingEnabled();
-	float collectionInterval =
-			dataSet->periodicHelper->getCollectionIntervalInSeconds();
+	bool reportingEnabled = LocalPoolDataSetAttorney::getReportingEnabled(*dataSet);
+	float collectionInterval = LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet)->
+			getCollectionIntervalInSeconds();
 
 	// Generate set packet which can be serialized.
 	HousekeepingSetPacket setPacket(sid,
@@ -822,16 +841,13 @@ void LocalDataPoolManager::clearReceiversList() {
 	HkReceivers().swap(hkReceiversMap);
 }
 
-ReturnValue_t LocalDataPoolManager::retrieveLocalPoolMutex(MutexIF *mutex) {
-	if(this->mutex == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	mutex = this->mutex;
-	return HasReturnvaluesIF::RETURN_OK;
+MutexIF* LocalDataPoolManager::getLocalPoolMutex() {
+	return this->mutex;
 }
 
 object_id_t LocalDataPoolManager::getCreatorObjectId() const {
-	return owner->getAccessorHandle()->getCreatorObjectId();
+	return owner->getObjectId();
+	//return owner->getObjectId();
 }
 
 void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
@@ -869,7 +885,7 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
-				<< std::hex << this->getCreatorObjectId() << " | " << errorPrint
+				<< std::hex << owner->getObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
 		fsfw::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
@@ -880,7 +896,7 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
-				<< std::hex << this->getCreatorObjectId() << " | " << errorPrint
+				<< std::hex << owner->getObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
 		fsfw::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
@@ -888,3 +904,7 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 #endif
 	}
 }
+
+LocalDataPoolManager* LocalDataPoolManager::getHkManagerHandle() {
+	return this;
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 3544c9446..f94f0ec1b 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -51,11 +51,11 @@ class HousekeepingPacketUpdate;
  * @author 		R. Mueller
  */
 class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF,
-		public AccessLocalPoolIF {
-	template<typename T> friend class LocalPoolVariable;
-	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
-	//friend class LocalPoolDataSetBase;
+		public AccessPoolManagerIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
+	//! Some classes using the pool manager directly need to access class internals of the
+	//! manager. The attorney provides granular control of access to these internals.
+	friend class LocalDpManagerAttorney;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
@@ -177,7 +177,7 @@ public:
             MessageQueueId_t targetQueueId,
             bool generateSnapshot) override;
 
-    ReturnValue_t retrieveLocalPoolMutex(MutexIF* mutex) override;
+    MutexIF* getLocalPoolMutex() override;
 
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
@@ -263,7 +263,9 @@ public:
      */
     void clearReceiversList();
 
-    object_id_t getCreatorObjectId() const override;
+    object_id_t getCreatorObjectId() const;
+
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
 private:
     LocalDataPool localPoolMap;
     //! Every housekeeping data manager has a mutex to protect access
diff --git a/datapoollocal/LocalDpManagerAttorney.h b/datapoollocal/LocalDpManagerAttorney.h
new file mode 100644
index 000000000..1d72f607f
--- /dev/null
+++ b/datapoollocal/LocalDpManagerAttorney.h
@@ -0,0 +1,32 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
+
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+
+/**
+ * @brief	This is a helper class implements the Attorney-Client idiom for access to
+ * 			LocalDataPoolManager internals
+ * @details
+ * This helper class provides better control over which classes are allowed to access
+ * LocalDataPoolManager internals in a granular and encapsulated way when compared to
+ * other methods like direct friend declarations. It allows these classes to use
+ * an explicit subset of the pool manager private/protected functions.
+ * See: https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Friendship_and_the_Attorney-Client
+ */
+class LocalDpManagerAttorney {
+private:
+	template<typename T> static ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
+			lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
+		return manager.fetchPoolEntry(localPoolId, poolEntry);
+	}
+
+	static MutexIF* getMutexHandle(LocalDataPoolManager& manager) {
+		return manager.getMutexHandle();
+	}
+
+
+	template<typename T> friend class LocalPoolVariable;
+	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_ */
diff --git a/datapoollocal/LocalPoolDataSetAttorney.h b/datapoollocal/LocalPoolDataSetAttorney.h
new file mode 100644
index 000000000..36358db41
--- /dev/null
+++ b/datapoollocal/LocalPoolDataSetAttorney.h
@@ -0,0 +1,40 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
+
+#include <fsfw/datapoollocal/LocalPoolDataSetBase.h>
+
+class LocalPoolDataSetAttorney {
+private:
+	static void setDiagnostic(LocalPoolDataSetBase& set, bool diagnostics) {
+		set.setDiagnostic(diagnostics);
+	}
+
+	static bool isDiagnostics(LocalPoolDataSetBase& set) {
+		return set.isDiagnostics();
+	}
+
+	static void initializePeriodicHelper(LocalPoolDataSetBase& set, float collectionInterval,
+			uint32_t minimumPeriodicIntervalMs,
+			bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5) {
+		set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs, isDiagnostics,
+				nonDiagIntervalFactor);
+	}
+
+	static void setReportingEnabled(LocalPoolDataSetBase& set, bool enabled) {
+		set.setReportingEnabled(enabled);
+	}
+
+	static bool getReportingEnabled(LocalPoolDataSetBase& set) {
+		return set.getReportingEnabled();
+	}
+
+	static PeriodicHousekeepingHelper* getPeriodicHelper(LocalPoolDataSetBase& set) {
+		return set.periodicHelper;
+	}
+
+	friend class LocalDataPoolManager;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_ */
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index c4bed0a41..9bed85830 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -1,4 +1,5 @@
 #include "LocalPoolDataSetBase.h"
+#include "HasLocalDataPoolIFAttorney.h"
 
 #include "../serviceinterface/ServiceInterface.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
@@ -23,14 +24,14 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
     }
-    localPoolAccessor = hkOwner->getAccessorHandle();
+    AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
 
-    if(localPoolAccessor != nullptr) {
-    	localPoolAccessor->retrieveLocalPoolMutex(mutexIfSingleDataCreator);
-        //mutexIfSingleDataCreator = hkManager->getAc();
+    if(poolManager != nullptr) {
+        poolManager = accessor->getHkManagerHandle();
+    	mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
     }
 
-    this->sid.objectId = localPoolAccessor->getCreatorObjectId();
+    this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
 
     // Data creators get a periodic helper for periodic HK data generation.
@@ -43,10 +44,10 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
-	AccessLocalPoolIF* hkOwner = objectManager->get<AccessLocalPoolIF>(
+	AccessPoolManagerIF* hkOwner = objectManager->get<AccessPoolManagerIF>(
             sid.objectId);
     if(hkOwner != nullptr) {
-        ReturnValue_t result = hkOwner->retrieveLocalPoolMutex(mutexIfSingleDataCreator);
+    	mutexIfSingleDataCreator = hkOwner->getLocalPoolMutex();
     }
 
     //if(hkManager != nullptr) {
@@ -310,8 +311,8 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
 }
 
 object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
-	if(localPoolAccessor != nullptr) {
-		return localPoolAccessor->getCreatorObjectId();
+	if(poolManager != nullptr) {
+		return poolManager->getCreatorObjectId();
 	}
 	return objects::NO_OBJECT;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 442d93c83..f815ac441 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -42,7 +42,8 @@ class PeriodicHousekeepingHelper;
  */
 class LocalPoolDataSetBase: public PoolDataSetBase,
         public MarkChangedIF {
-	friend class LocalDataPoolManager;
+	//friend class LocalDataPoolManager;
+	friend class LocalPoolDataSetAttorney;
 	friend class PeriodicHousekeepingHelper;
 public:
 	/**
@@ -217,7 +218,7 @@ protected:
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
-	AccessLocalPoolIF* localPoolAccessor = nullptr;
+	LocalDataPoolManager* poolManager = nullptr;
 
 };
 
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index c74380cf6..e7abf9df8 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,4 +1,5 @@
 #include "LocalPoolObjectBase.h"
+#include "HasLocalDataPoolIFAttorney.h"
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
@@ -16,7 +17,9 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkO
 #endif
 		return;
 	}
-	hkManager = hkOwner->getHkManagerHandle();
+	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+	hkManager = poolManAccessor->getHkManagerHandle();
+	//HasLohkOwner->getHkManagerHandle();
 	if (dataSet != nullptr) {
 		dataSet->registerVariable(this);
 	}
@@ -41,7 +44,10 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
 #endif
 		return;
 	}
-	hkManager = hkOwner->getHkManagerHandle();
+	//hkManager = hkOwner->getHkManagerHandle();
+	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+	//hkManager = HasLocalDpIFUserAttorney::getHkManagerHandle(hkOwner);
+	hkManager = poolManAccessor->getHkManagerHandle();
 	if(dataSet != nullptr) {
 		dataSet->registerVariable(this);
 	}
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index eac915160..e66c565c8 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,11 +1,11 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 
+#include <fsfw/datapoollocal/LocalDpManagerAttorney.h>
 #include "LocalPoolObjectBase.h"
 #include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
 #include "AccessLocalPoolF.h"
-
 #include "../datapool/PoolVariableIF.h"
 #include "../datapool/DataSetIF.h"
 #include "../serviceinterface/ServiceInterface.h"
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index e55ea2a0f..6fd34171a 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -26,7 +26,7 @@ inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::read(
 		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return readWithoutLock();
 }
 
@@ -41,7 +41,9 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	}
 
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
+	//ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
 		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVariable", result,
@@ -73,7 +75,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commit(
 		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return commitWithoutLock();
 }
 
@@ -88,7 +90,9 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	}
 
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	//ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
 	if(result != RETURN_OK) {
 		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVariable", result,
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index a28fe327a..3f26b9f51 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 
+#include <fsfw/datapoollocal/LocalDpManagerAttorney.h>
 #include "LocalPoolObjectBase.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 24421b0b6..6476b1e17 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -26,7 +26,7 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
 		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return readWithoutLock();
 }
 template<typename T, uint16_t vectorSize>
@@ -40,7 +40,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	}
 
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
 	memset(this->value, 0, vectorSize * sizeof(T));
 
 	if(result != RETURN_OK) {
@@ -64,7 +65,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return commitWithoutLock();
 }
 
@@ -78,7 +79,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
 	if(result != RETURN_OK) {
 		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 2492535a4..ef0219e8c 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1432,11 +1432,6 @@ ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
 	return RETURN_OK;
 }
 
-LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
-	return &hkManager;
-}
-
-
 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 :-)
@@ -1488,7 +1483,7 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 	}
 }
 
-AccessLocalPoolIF* DeviceHandlerBase::getAccessorHandle() {
+AccessPoolManagerIF* DeviceHandlerBase::getAccessorHandle() {
 	return &hkManager;
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index f3f208a60..7abc67058 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -519,11 +519,11 @@ protected:
 
 
 	/** Get the HK manager object handle */
-	LocalDataPoolManager* getHkManagerHandle() override;
+	//LocalDataPoolManager* getHkManagerHandle() override;
 
 	ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
-	AccessLocalPoolIF* getAccessorHandle() override;
+	AccessPoolManagerIF* getAccessorHandle() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
diff --git a/devicehandlers/DeviceHandlerThermalSet.h b/devicehandlers/DeviceHandlerThermalSet.h
index 0fabd3b30..239012e26 100644
--- a/devicehandlers/DeviceHandlerThermalSet.h
+++ b/devicehandlers/DeviceHandlerThermalSet.h
@@ -15,7 +15,7 @@ public:
 					DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
 			lp_id_t heaterRequestId =
 					DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID):
-			DeviceHandlerThermalSet(hkOwner->getAccessorHandle()->getCreatorObjectId(), setId,
+			DeviceHandlerThermalSet(hkOwner->getObjectId(), setId,
 					thermalStateId, heaterRequestId) {}
 
 	DeviceHandlerThermalSet(object_id_t deviceHandler, uint32_t setId =
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 0817c0809..3a05b3509 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -134,7 +134,7 @@ uint32_t InternalErrorReporter::getStoreHits() {
 	return value;
 }
 
-AccessLocalPoolIF* InternalErrorReporter::getAccessorHandle() {
+AccessPoolManagerIF* InternalErrorReporter::getAccessorHandle() {
 	return &poolManager;
 }
 
@@ -166,10 +166,6 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() {
-    return &poolManager;
-}
-
 dur_millis_t InternalErrorReporter::getPeriodicOperationFrequency() const {
     return this->executingTask->getPeriodMs();
 }
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 5bd5785a6..0cb6be593 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -43,11 +43,10 @@ public:
     virtual ReturnValue_t initializeLocalDataPool(
             LocalDataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
-    virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
     ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
-	AccessLocalPoolIF* getAccessorHandle() override;
+	AccessPoolManagerIF* getAccessorHandle() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;

From 165710b43c2d24f405d3f1a0f184c72c9a0c0c51 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 15:06:25 +0100
Subject: [PATCH 1438/1774] service interface update

---
 serviceinterface/ServiceInterface.h           |   1 +
 serviceinterface/ServiceInterfaceBuffer.cpp   |  10 +-
 serviceinterface/ServiceInterfacePrinter.cpp  | 120 +++++++++++-------
 serviceinterface/ServiceInterfacePrinter.h    |  24 +++-
 serviceinterface/serviceInterfaceDefintions.h |   9 +-
 5 files changed, 102 insertions(+), 62 deletions(-)

diff --git a/serviceinterface/ServiceInterface.h b/serviceinterface/ServiceInterface.h
index 0c7c43837..1f7e5e84a 100644
--- a/serviceinterface/ServiceInterface.h
+++ b/serviceinterface/ServiceInterface.h
@@ -2,6 +2,7 @@
 #define FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
 
 #include <FSFWConfig.h>
+#include "serviceInterfaceDefintions.h"
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 5846d233a..1a02d6e90 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -29,19 +29,19 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 
 #if FSFW_COLORED_OUTPUT == 1
 	if(setMessage.find("DEBUG") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_MAGENTA;
+		colorPrefix = sif::ANSI_COLOR_MAGENTA;
 	}
 	else if(setMessage.find("INFO") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_GREEN;
+		colorPrefix = sif::ANSI_COLOR_GREEN;
 	}
 	else if(setMessage.find("WARNING") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_YELLOW;
+		colorPrefix = sif::ANSI_COLOR_YELLOW;
 	}
 	else if(setMessage.find("ERROR") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_RED;
+		colorPrefix = sif::ANSI_COLOR_RED;
 	}
 	else {
-		colorPrefix = fsfw::ANSI_COLOR_RESET;
+		colorPrefix = sif::ANSI_COLOR_RESET;
 	}
 
 #ifdef WIN32
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index e8eb498f9..a12f49e3c 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -6,14 +6,18 @@
 #include <cstdarg>
 #include <cstdint>
 
-
-fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
-uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
+static sif::PrintLevel printLevel = sif::PrintLevel::DEBUG_LEVEL;
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
-bool consoleInitialized = false;
-#endif
+static bool consoleInitialized = false;
+#endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
 
-void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
+#if FSFW_DISABLE_PRINTOUT == 0
+
+static bool addCrAtEnd = false;
+
+uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
+
+void fsfwPrint(sif::PrintLevel printType, const char* fmt, va_list arg) {
 
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
 	if(not consoleInitialized) {
@@ -30,38 +34,38 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     char* bufferPosition = reinterpret_cast<char*>(printBuffer);
 
     /* Check logger level */
-    if(printType == fsfw::PrintLevel::NONE or printType > printLevel) {
+    if(printType == sif::PrintLevel::NONE or printType > printLevel) {
         return;
     }
 
     /* Log message to terminal */
 
 #if FSFW_COLORED_OUTPUT == 1
-    if(printType == fsfw::PrintLevel::INFO) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_GREEN);
+    if(printType == sif::PrintLevel::INFO_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_GREEN);
     }
-    else if(printType == fsfw::PrintLevel::DEBUG) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_MAGENTA);
+    else if(printType == sif::PrintLevel::DEBUG_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_MAGENTA);
     }
-    else if(printType == fsfw::PrintLevel::WARNING) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_YELLOW);
+    else if(printType == sif::PrintLevel::WARNING_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_YELLOW);
     }
-    else if(printType == fsfw::PrintLevel::ERROR_TYPE) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_RED);
+    else if(printType == sif::PrintLevel::ERROR_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_RED);
     }
 #endif
 
-   if (printType == fsfw::PrintLevel::INFO) {
+   if (printType == sif::PrintLevel::INFO_LEVEL) {
        len += sprintf(bufferPosition + len, "INFO: ");
    }
-   if(printType == fsfw::PrintLevel::DEBUG) {
+   if(printType == sif::PrintLevel::DEBUG_LEVEL) {
 	   len += sprintf(bufferPosition + len, "DEBUG: ");
    }
-   if(printType == fsfw::PrintLevel::WARNING) {
+   if(printType == sif::PrintLevel::WARNING_LEVEL) {
 	   len += sprintf(bufferPosition + len, "WARNING: ");
    }
 
-   if(printType == fsfw::PrintLevel::ERROR_TYPE) {
+   if(printType == sif::PrintLevel::ERROR_LEVEL) {
 	   len += sprintf(bufferPosition + len, "ERROR: ");
    }
 
@@ -78,41 +82,59 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 
     len += vsnprintf(bufferPosition + len, sizeof(printBuffer) - len, fmt, arg);
 
+    if(addCrAtEnd) {
+    	len += sprintf(bufferPosition + len, "\r");
+    }
+
     printf("%s", printBuffer);
 }
 
-void fsfw::setPrintLevel(PrintLevel printLevel_) {
+
+void sif::printInfo(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(sif::PrintLevel::INFO_LEVEL, fmt, args);
+    va_end(args);
+}
+
+void sif::printWarning(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(sif::PrintLevel::WARNING_LEVEL, fmt, args);
+    va_end(args);
+}
+
+void sif::printDebug(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(sif::PrintLevel::DEBUG_LEVEL, fmt, args);
+    va_end(args);
+}
+
+void sif::setToAddCrAtEnd(bool addCrAtEnd_) {
+	addCrAtEnd = addCrAtEnd_;
+}
+
+void sif::printError(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(sif::PrintLevel::ERROR_LEVEL, fmt, args);
+    va_end(args);
+}
+
+#else
+
+void sif::printInfo(const char *fmt, ...) {}
+void sif::printWarning(const char *fmt, ...) {}
+void sif::printDebug(const char *fmt, ...) {}
+void sif::printError(const char *fmt, ...) {}
+
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
+
+void sif::setPrintLevel(PrintLevel printLevel_) {
 	printLevel = printLevel_;
 }
 
-fsfw::PrintLevel fsfw::getPrintLevel() {
+sif::PrintLevel sif::getPrintLevel() {
 	return printLevel;
 }
-
-void fsfw::printInfo(const char *fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::INFO, fmt, args);
-    va_end(args);
-}
-
-void fsfw::printWarning(const char *fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::WARNING, fmt, args);
-    va_end(args);
-}
-
-void fsfw::printDebug(const char *fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::DEBUG, fmt, args);
-    va_end(args);
-}
-
-void fsfw::printError(const char *fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::ERROR_TYPE, fmt, args);
-    va_end(args);
-}
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index 8b81ee7a0..fbdccdd16 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -1,19 +1,29 @@
-#include <stdio.h>
+#if FSFW_DISABLE_PRINTOUT == 0
+#include <cstdio>
+#endif
 
-namespace fsfw {
+namespace sif {
 
-enum class PrintLevel {
+enum PrintLevel {
 	NONE = 0,
 	//! Strange error when using just ERROR..
-	ERROR_TYPE = 1,
-	WARNING = 2,
-	INFO = 3,
-	DEBUG = 4
+	ERROR_LEVEL = 1,
+	WARNING_LEVEL = 2,
+	INFO_LEVEL = 3,
+	DEBUG_LEVEL = 4
 };
 
+/**
+ * Set the print level. All print types with a smaller level will be printed
+ * as well. For example, set to PrintLevel::WARNING to only enable error
+ * and warning output.
+ * @param printLevel
+ */
 void setPrintLevel(PrintLevel printLevel);
 PrintLevel getPrintLevel();
 
+void setToAddCrAtEnd(bool addCrAtEnd_);
+
 /**
  * These functions can be used like the C stdio printf and forward the
  * supplied formatted string arguments to a printf function.
diff --git a/serviceinterface/serviceInterfaceDefintions.h b/serviceinterface/serviceInterfaceDefintions.h
index 684c73668..eb36a84b3 100644
--- a/serviceinterface/serviceInterfaceDefintions.h
+++ b/serviceinterface/serviceInterfaceDefintions.h
@@ -1,7 +1,14 @@
 #ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
 #define FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
 
-namespace fsfw {
+namespace sif {
+
+enum class OutputTypes {
+	OUT_INFO,
+	OUT_DEBUG,
+	OUT_WARNING,
+	OUT_ERROR
+};
 
 static const char* const ANSI_COLOR_RED = "\x1b[31m";
 static const char* const ANSI_COLOR_GREEN = "\x1b[32m";

From 71a12792a94ac3008876eade5c9c8515713483e3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 19:41:47 +0100
Subject: [PATCH 1439/1774] hopefully this fixes circular includes

---
 ...torney.h => HasLocalDpIFManagerAttorney.h} | 22 +++++--------------
 datapoollocal/HasLocalDpIFUserAttorney.h      | 20 +++++++++++++++++
 datapoollocal/LocalDataPoolManager.cpp        |  2 +-
 datapoollocal/LocalPoolDataSetBase.cpp        |  6 ++---
 datapoollocal/LocalPoolDataSetBase.h          |  4 ++--
 datapoollocal/LocalPoolObjectBase.cpp         |  5 +++--
 datapoollocal/LocalPoolObjectBase.h           |  7 +++++-
 7 files changed, 39 insertions(+), 27 deletions(-)
 rename datapoollocal/{HasLocalDataPoolIFAttorney.h => HasLocalDpIFManagerAttorney.h} (50%)
 create mode 100644 datapoollocal/HasLocalDpIFUserAttorney.h

diff --git a/datapoollocal/HasLocalDataPoolIFAttorney.h b/datapoollocal/HasLocalDpIFManagerAttorney.h
similarity index 50%
rename from datapoollocal/HasLocalDataPoolIFAttorney.h
rename to datapoollocal/HasLocalDpIFManagerAttorney.h
index dd01e74ee..bb47639cb 100644
--- a/datapoollocal/HasLocalDataPoolIFAttorney.h
+++ b/datapoollocal/HasLocalDpIFManagerAttorney.h
@@ -1,19 +1,9 @@
-#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIFATTORNEY_H_
-#define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIFATTORNEY_H_
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
 
-#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+#include "HasLocalDataPoolIF.h"
 
-class HasLocalDpIFUserAttorney {
-private:
-
-	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* interface) {
-		return interface->getAccessorHandle();
-	}
-
-	friend class LocalPoolObjectBase;
-	friend class LocalPoolDataSetBase;
-
-};
+class LocalPoolDataSetBase;
 
 class HasLocalDpIFManagerAttorney {
 
@@ -33,6 +23,4 @@ class HasLocalDpIFManagerAttorney {
 	friend class LocalDataPoolManager;
 };
 
-
-
-#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIFATTORNEY_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_ */
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.h b/datapoollocal/HasLocalDpIFUserAttorney.h
new file mode 100644
index 000000000..ebac9374f
--- /dev/null
+++ b/datapoollocal/HasLocalDpIFUserAttorney.h
@@ -0,0 +1,20 @@
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
+
+class AccessPoolManagerIF;
+class HasLocalDataPoolIF;
+
+class HasLocalDpIFUserAttorney {
+private:
+
+	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* interface) {
+		return interface->getAccessorHandle();
+	}
+
+	friend class LocalPoolObjectBase;
+	friend class LocalPoolDataSetBase;
+
+};
+
+
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index b48f9b136..b54b0601e 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,7 +1,7 @@
+#include <fsfw/datapoollocal/HasLocalDpIFManagerAttorney.h>
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
-#include "HasLocalDataPoolIFAttorney.h"
 #include "LocalPoolDataSetAttorney.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 70bf42c06..cd0f8931e 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -1,5 +1,6 @@
 #include "LocalPoolDataSetBase.h"
-#include "HasLocalDataPoolIFAttorney.h"
+#include "HasLocalDataPoolIF.h"
+#include "HasLocalDpIFUserAttorney.h"
 
 #include "../serviceinterface/ServiceInterface.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
@@ -50,9 +51,6 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
     	mutexIfSingleDataCreator = hkOwner->getLocalPoolMutex();
     }
 
-    //if(hkManager != nullptr) {
-    //    mutexIfSingleDataCreator = hkManager->getMutexHandle();
-    //}
     this->sid = sid;
 }
 
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index f815ac441..ba4c1b6dd 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,15 +1,16 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
-#include "HasLocalDataPoolIF.h"
 #include "MarkChangedIF.h"
 
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
 
 #include <vector>
 
 class LocalDataPoolManager;
+class HasLocalDataPoolIF;
 class PeriodicHousekeepingHelper;
 
 /**
@@ -42,7 +43,6 @@ class PeriodicHousekeepingHelper;
  */
 class LocalPoolDataSetBase: public PoolDataSetBase,
         public MarkChangedIF {
-	//friend class LocalDataPoolManager;
 	friend class LocalPoolDataSetAttorney;
 	friend class PeriodicHousekeepingHelper;
 public:
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 5140df001..2ba9ef794 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,5 +1,6 @@
+#include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
-#include "HasLocalDataPoolIFAttorney.h"
+#include "HasLocalDpIFUserAttorney.h"
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
@@ -19,7 +20,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkO
 	}
 	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
 	hkManager = poolManAccessor->getHkManagerHandle();
-	//HasLohkOwner->getHkManagerHandle();
+
 	if (dataSet != nullptr) {
 		dataSet->registerVariable(this);
 	}
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index e7414131a..5e6d215cd 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -2,9 +2,14 @@
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 
 #include "MarkChangedIF.h"
-#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../datapoollocal/locPoolDefinitions.h"
+#include "../objectmanager/SystemObjectIF.h"
 #include "../datapool/PoolVariableIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 
+class LocalDataPoolManager;
+class DataSetIF;
+class HasLocalDataPoolIF;
 
 class LocalPoolObjectBase: public PoolVariableIF,
         public HasReturnvaluesIF,

From 40ae81c4ff264e01911392f650297a32975ecec5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 19:58:29 +0100
Subject: [PATCH 1440/1774] unfortunate api change

should improve include robustness
---
 controller/ExtendedControllerBase.cpp         |  2 +-
 controller/ExtendedControllerBase.h           |  2 +-
 datapoollocal/HasLocalDataPoolIF.h            | 18 +++++-------------
 datapoollocal/HasLocalDpIFUserAttorney.h      |  3 ++-
 datapoollocal/LocalDataPoolManager.cpp        | 11 ++++++-----
 datapoollocal/LocalDataPoolManager.h          | 14 ++++++++------
 datapoollocal/LocalPoolDataSetBase.h          |  2 +-
 datapoollocal/LocalPoolObjectBase.cpp         | 10 ++++++----
 datapoollocal/LocalPoolObjectBase.h           |  2 +-
 .../ProvidesDataPoolSubscriptionIF.h          |  2 +-
 ...olDefinitions.h => localPoolDefinitions.h} | 19 +++++++++++++++----
 devicehandlers/DeviceHandlerBase.cpp          |  2 +-
 devicehandlers/DeviceHandlerBase.h            |  2 +-
 devicehandlers/DeviceHandlerIF.h              |  2 +-
 housekeeping/HousekeepingMessage.h            |  2 +-
 internalError/InternalErrorReporter.cpp       |  2 +-
 internalError/InternalErrorReporter.h         |  2 +-
 monitoring/MonitorReporter.h                  |  2 +-
 monitoring/MonitoringMessageContent.h         |  2 +-
 19 files changed, 55 insertions(+), 46 deletions(-)
 rename datapoollocal/{locPoolDefinitions.h => localPoolDefinitions.h} (78%)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 379f189c5..74453b253 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -17,7 +17,7 @@ ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
 
 
 ReturnValue_t ExtendedControllerBase::initializeLocalDataPool(
-        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
     // needs to be overriden and implemented by child class.
     return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index ed1d71930..6076b2fec 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -63,7 +63,7 @@ protected:
     /** HasLocalDatapoolIF overrides */
     virtual object_id_t getObjectId() const override;
     virtual ReturnValue_t initializeLocalDataPool(
-            LocalDataPool& localDataPoolMap,
+            localpool::DataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
     virtual uint32_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 822a85905..3132277d4 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,10 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
-#include "AccessLocalPoolF.h"
-#include "ProvidesDataPoolSubscriptionIF.h"
-#include "locPoolDefinitions.h"
-
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "../datapool/PoolEntryIF.h"
 #include "../serviceinterface/ServiceInterface.h"
 #include "../ipc/MessageQueueSenderIF.h"
@@ -12,11 +9,11 @@
 
 #include <map>
 
+class AccessPoolManagerIF;
+class ProvidesDataPoolSubscriptionIF;
 class LocalPoolDataSetBase;
 class LocalPoolObjectBase;
-
-using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
-using LocalDataPoolMapIter = LocalDataPool::iterator;
+class LocalDataPoolManager;
 
 /**
  * @brief 		This interface is implemented by classes which posses a local data pool (not the
@@ -42,11 +39,6 @@ class HasLocalDataPoolIF {
 public:
 	virtual~ HasLocalDataPoolIF() {};
 
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
-
-    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
-    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
-
 	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
 	virtual object_id_t getObjectId() const = 0;
@@ -59,7 +51,7 @@ public:
 	 * The manager instance shall also be passed to this function.
 	 * It can be used to subscribe for periodic packets for for updates.
 	 */
-	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
+	virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
 	        LocalDataPoolManager& poolManager) = 0;
 
 	/**
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.h b/datapoollocal/HasLocalDpIFUserAttorney.h
index ebac9374f..51260dbf4 100644
--- a/datapoollocal/HasLocalDpIFUserAttorney.h
+++ b/datapoollocal/HasLocalDpIFUserAttorney.h
@@ -1,8 +1,9 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
 
+#include "HasLocalDataPoolIF.h"
+
 class AccessPoolManagerIF;
-class HasLocalDataPoolIF;
 
 class HasLocalDpIFUserAttorney {
 private:
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index b54b0601e..3902a0fe5 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,8 +1,9 @@
-#include <fsfw/datapoollocal/HasLocalDpIFManagerAttorney.h>
+#include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
 #include "LocalPoolDataSetAttorney.h"
+#include "HasLocalDpIFManagerAttorney.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
@@ -601,8 +602,8 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
 		printWarningOrError(sif::OutputTypes::OUT_WARNING, "printPoolEntry",
-				HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
-		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
+				localpool::POOL_ENTRY_NOT_FOUND);
+		return localpool::POOL_ENTRY_NOT_FOUND;
 	}
 	poolIter->second->print();
 	return HasReturnvaluesIF::RETURN_OK;
@@ -870,10 +871,10 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 		else if(error == QUEUE_OR_DESTINATION_INVALID) {
 			errorPrint = "Queue or destination not set";
 		}
-		else if(error == HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT) {
+		else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
 			errorPrint = "Pool entry type conflict";
 		}
-		else if(error == HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND) {
+		else if(error == localpool::POOL_ENTRY_NOT_FOUND) {
 			errorPrint = "Pool entry not found";
 		}
 		else {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index cba797769..580ac8b93 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -2,7 +2,7 @@
 #define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 
 #include "ProvidesDataPoolSubscriptionIF.h"
-#include "HasLocalDataPoolIF.h"
+#include "AccessLocalPoolF.h"
 
 #include "../serviceinterface/ServiceInterface.h"
 #include "../housekeeping/HousekeepingPacketDownlink.h"
@@ -25,6 +25,8 @@ void setStaticFrameworkObjectIds();
 
 class LocalPoolDataSetBase;
 class HousekeepingPacketUpdate;
+class HasLocalDataPoolIF;
+class LocalDataPool;
 
 /**
  * @brief 		This class is the managing instance for the local data pool.
@@ -267,7 +269,7 @@ public:
 
     virtual LocalDataPoolManager* getHkManagerHandle() override;
 private:
-    LocalDataPool localPoolMap;
+    localpool::DataPool localPoolMap;
     //! Every housekeeping data manager has a mutex to protect access
     //! to it's data pool.
     MutexIF* mutex = nullptr;
@@ -400,15 +402,15 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
     	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
-				HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
-		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
+    			localpool::POOL_ENTRY_NOT_FOUND);
+		return localpool::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
     	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
-    			HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT);
-		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
+    			localpool::POOL_ENTRY_TYPE_CONFLICT);
+		return localpool::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index ba4c1b6dd..2d170c3ff 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,9 +1,9 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "MarkChangedIF.h"
 
-#include "../datapoollocal/locPoolDefinitions.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
 
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 2ba9ef794..6dc6e356d 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,6 +1,9 @@
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "HasLocalDpIFUserAttorney.h"
+#include "HasLocalDataPoolIF.h"
+
+#include "../objectmanager/ObjectManagerIF.h"
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
@@ -35,8 +38,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
 				<< "which is the NO_PARAMETER value!" << std::endl;
 #endif
 	}
-	HasLocalDataPoolIF* hkOwner =
-			objectManager->get<HasLocalDataPoolIF>(poolOwner);
+	HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(poolOwner);
 	if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalPoolVariable: The supplied pool owner did not "
@@ -98,10 +100,10 @@ void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
 	}
 
 	const char* errMsg = nullptr;
-	if(error == HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND) {
+	if(error == localpool::POOL_ENTRY_NOT_FOUND) {
 		errMsg = "Pool entry not found";
 	}
-	else if(error == HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT) {
+	else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
 		errMsg = "Pool entry type conflict";
 	}
 	else if(error == PoolVariableIF::INVALID_READ_WRITE_MODE) {
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 5e6d215cd..2dddc2461 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "MarkChangedIF.h"
-#include "../datapoollocal/locPoolDefinitions.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../datapool/PoolVariableIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index 7f0cc7540..e6d6257e1 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
 #define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
 
-#include <fsfw/datapoollocal/locPoolDefinitions.h>
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include <fsfw/ipc/messageQueueDefinitions.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
diff --git a/datapoollocal/locPoolDefinitions.h b/datapoollocal/localPoolDefinitions.h
similarity index 78%
rename from datapoollocal/locPoolDefinitions.h
rename to datapoollocal/localPoolDefinitions.h
index 6e74d349a..5f5588958 100644
--- a/datapoollocal/locPoolDefinitions.h
+++ b/datapoollocal/localPoolDefinitions.h
@@ -1,10 +1,13 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
-#define FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_
 
-#include <cstdint>
+#include "../datapool/PoolEntryIF.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../objectmanager/frameworkObjects.h"
 
+#include <cstdint>
+#include <map>
+
 /**
  * @brief   Type definition for local pool entries.
  */
@@ -12,6 +15,14 @@ using lp_id_t = uint32_t;
 
 namespace localpool {
 static constexpr uint32_t INVALID_LPID = -1;
+
+static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
+
+static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
+static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+
+using DataPool =  std::map<lp_id_t, PoolEntryIF*>;
+using DataPoolMapIter = DataPool::iterator;
 }
 
 /**
@@ -90,4 +101,4 @@ union gp_id_t {
     }
 };
 
-#endif /* FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index abe0f701f..acfdd81ec 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1421,7 +1421,7 @@ void DeviceHandlerBase::performOperationHook() {
 }
 
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
-		LocalDataPool &localDataPoolMap,
+		localpool::DataPool &localDataPoolMap,
         LocalDataPoolManager& poolManager) {
 	if(thermalSet != nullptr) {
 		localDataPoolMap.emplace(thermalSet->thermalStatePoolId,
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index c062603fe..6042d2497 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -514,7 +514,7 @@ protected:
 	 * @param localDataPoolMap
 	 * @return
 	 */
-	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
+	virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
 				LocalDataPoolManager& poolManager) override;
 
 
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 865b38b36..bae68516e 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,10 +1,10 @@
 #ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 #define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "DeviceHandlerMessage.h"
 
 #include "../action/HasActionsIF.h"
-#include "../datapoollocal/locPoolDefinitions.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 90bbe594a..a64ce18be 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 
-#include "../datapoollocal/locPoolDefinitions.h"
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
 #include "../objectmanager/frameworkObjects.h"
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 3a05b3509..5656f208a 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -153,7 +153,7 @@ MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
 }
 
 ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
-        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
     localDataPoolMap.emplace(errorPoolIds::TM_HITS,
             new PoolEntry<uint32_t>());
     localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS,
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 0cb6be593..ec9134d42 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -41,7 +41,7 @@ public:
     virtual object_id_t getObjectId() const override;
     virtual MessageQueueId_t getCommandQueue() const override;
     virtual ReturnValue_t initializeLocalDataPool(
-            LocalDataPool& localDataPoolMap,
+    		localpool::DataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 9028e7e4a..6b3204b38 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -1,11 +1,11 @@
 #ifndef FSFW_MONITORING_MONITORREPORTER_H_
 #define FSFW_MONITORING_MONITORREPORTER_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
 
-#include "../datapoollocal/locPoolDefinitions.h"
 #include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index 2822743ac..e44e8480a 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -1,9 +1,9 @@
 #ifndef MONITORINGMESSAGECONTENT_H_
 #define MONITORINGMESSAGECONTENT_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
-#include "../datapoollocal/locPoolDefinitions.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"

From 0643faf0e509f3cc968305afffb6b6bef8064841 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 19:59:43 +0100
Subject: [PATCH 1441/1774] forward declaration correctness

---
 datapoollocal/HasLocalDpIFManagerAttorney.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.h b/datapoollocal/HasLocalDpIFManagerAttorney.h
index bb47639cb..5a62bba0f 100644
--- a/datapoollocal/HasLocalDpIFManagerAttorney.h
+++ b/datapoollocal/HasLocalDpIFManagerAttorney.h
@@ -4,6 +4,7 @@
 #include "HasLocalDataPoolIF.h"
 
 class LocalPoolDataSetBase;
+class LocalPoolObjectBase;
 
 class HasLocalDpIFManagerAttorney {
 

From fa636fded5f0bd1e631e276b2a75940f47994d68 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:15:15 +0100
Subject: [PATCH 1442/1774] source files for attorney

---
 datapoollocal/HasLocalDpIFManagerAttorney.cpp | 18 ++++++++++++++++++
 datapoollocal/HasLocalDpIFManagerAttorney.h   | 15 +++++----------
 datapoollocal/HasLocalDpIFUserAttorney.cpp    |  6 ++++++
 datapoollocal/HasLocalDpIFUserAttorney.h      |  7 ++-----
 4 files changed, 31 insertions(+), 15 deletions(-)
 create mode 100644 datapoollocal/HasLocalDpIFManagerAttorney.cpp
 create mode 100644 datapoollocal/HasLocalDpIFUserAttorney.cpp

diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.cpp b/datapoollocal/HasLocalDpIFManagerAttorney.cpp
new file mode 100644
index 000000000..997f4dfa4
--- /dev/null
+++ b/datapoollocal/HasLocalDpIFManagerAttorney.cpp
@@ -0,0 +1,18 @@
+#include "HasLocalDpIFManagerAttorney.h"
+#include "LocalPoolObjectBase.h"
+#include "LocalPoolDataSetBase.h"
+#include "HasLocalDataPoolIF.h"
+
+LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* interface,
+		sid_t sid) {
+	return interface->getDataSetHandle(sid);
+}
+
+LocalPoolObjectBase* HasLocalDpIFManagerAttorney::getPoolObjectHandle(HasLocalDataPoolIF* interface,
+		lp_id_t localPoolId) {
+	return interface->getPoolObjectHandle(localPoolId);
+}
+
+object_id_t HasLocalDpIFManagerAttorney::getObjectId(HasLocalDataPoolIF* interface) {
+	return interface->getObjectId();
+}
diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.h b/datapoollocal/HasLocalDpIFManagerAttorney.h
index 5a62bba0f..ca5965995 100644
--- a/datapoollocal/HasLocalDpIFManagerAttorney.h
+++ b/datapoollocal/HasLocalDpIFManagerAttorney.h
@@ -1,25 +1,20 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
 
-#include "HasLocalDataPoolIF.h"
+#include "localPoolDefinitions.h"
 
+class HasLocalDataPoolIF;
 class LocalPoolDataSetBase;
 class LocalPoolObjectBase;
 
 class HasLocalDpIFManagerAttorney {
 
-	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* interface, sid_t sid) {
-		return interface->getDataSetHandle(sid);
-	}
+	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* interface, sid_t sid);
 
 	static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* interface,
-			lp_id_t localPoolId) {
-		return interface->getPoolObjectHandle(localPoolId);
-	}
+			lp_id_t localPoolId);
 
-	static object_id_t getObjectId(HasLocalDataPoolIF* interface) {
-		return interface->getObjectId();
-	}
+	static object_id_t getObjectId(HasLocalDataPoolIF* interface);
 
 	friend class LocalDataPoolManager;
 };
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.cpp b/datapoollocal/HasLocalDpIFUserAttorney.cpp
new file mode 100644
index 000000000..002230fee
--- /dev/null
+++ b/datapoollocal/HasLocalDpIFUserAttorney.cpp
@@ -0,0 +1,6 @@
+#include "HasLocalDpIFUserAttorney.h"
+#include "HasLocalDataPoolIF.h"
+
+AccessPoolManagerIF* HasLocalDpIFUserAttorney::getAccessorHandle(HasLocalDataPoolIF *interface) {
+	return interface->getAccessorHandle();
+}
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.h b/datapoollocal/HasLocalDpIFUserAttorney.h
index 51260dbf4..67b51a4ae 100644
--- a/datapoollocal/HasLocalDpIFUserAttorney.h
+++ b/datapoollocal/HasLocalDpIFUserAttorney.h
@@ -1,16 +1,13 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
 
-#include "HasLocalDataPoolIF.h"
-
+class HasLocalDataPoolIF;
 class AccessPoolManagerIF;
 
 class HasLocalDpIFUserAttorney {
 private:
 
-	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* interface) {
-		return interface->getAccessorHandle();
-	}
+	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* interface);
 
 	friend class LocalPoolObjectBase;
 	friend class LocalPoolDataSetBase;

From 20bf7b6fc4653b74431f00e4b2cc31ecf4189289 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:33:53 +0100
Subject: [PATCH 1443/1774] fixed annoying bug

---
 datapoollocal/CMakeLists.txt                        |  2 ++
 datapoollocal/HasLocalDataPoolIF.h                  |  3 ++-
 datapoollocal/HasLocalDpIFManagerAttorney.cpp       | 12 ++++++------
 datapoollocal/HasLocalDpIFManagerAttorney.h         |  6 +++---
 datapoollocal/HasLocalDpIFUserAttorney.cpp          |  5 +++--
 datapoollocal/HasLocalDpIFUserAttorney.h            |  2 +-
 datapoollocal/LocalPoolDataSetBase.h                |  2 +-
 datapoollocal/localPoolDefinitions.h                |  3 +++
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h   | 13 +++++++++++--
 .../tests/datapoollocal/LocalPoolVariableTest.cpp   |  6 +++---
 .../tests/datapoollocal/LocalPoolVectorTest.cpp     |  8 ++++----
 11 files changed, 39 insertions(+), 23 deletions(-)

diff --git a/datapoollocal/CMakeLists.txt b/datapoollocal/CMakeLists.txt
index c6b187cd2..925be505c 100644
--- a/datapoollocal/CMakeLists.txt
+++ b/datapoollocal/CMakeLists.txt
@@ -5,4 +5,6 @@ target_sources(${LIB_FSFW_NAME}
 		LocalPoolDataSetBase.cpp
 		LocalPoolObjectBase.cpp
 		SharedLocalDataSet.cpp
+		HasLocalDpIFUserAttorney.cpp
+		HasLocalDpIFManagerAttorney.cpp
 )
\ No newline at end of file
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 3132277d4..c1afb4a07 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,7 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
+#include "localPoolDefinitions.h"
+
 #include "../datapool/PoolEntryIF.h"
 #include "../serviceinterface/ServiceInterface.h"
 #include "../ipc/MessageQueueSenderIF.h"
diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.cpp b/datapoollocal/HasLocalDpIFManagerAttorney.cpp
index 997f4dfa4..a683cf7be 100644
--- a/datapoollocal/HasLocalDpIFManagerAttorney.cpp
+++ b/datapoollocal/HasLocalDpIFManagerAttorney.cpp
@@ -3,16 +3,16 @@
 #include "LocalPoolDataSetBase.h"
 #include "HasLocalDataPoolIF.h"
 
-LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* interface,
+LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* clientIF,
 		sid_t sid) {
-	return interface->getDataSetHandle(sid);
+	return clientIF->getDataSetHandle(sid);
 }
 
-LocalPoolObjectBase* HasLocalDpIFManagerAttorney::getPoolObjectHandle(HasLocalDataPoolIF* interface,
+LocalPoolObjectBase* HasLocalDpIFManagerAttorney::getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
 		lp_id_t localPoolId) {
-	return interface->getPoolObjectHandle(localPoolId);
+	return clientIF->getPoolObjectHandle(localPoolId);
 }
 
-object_id_t HasLocalDpIFManagerAttorney::getObjectId(HasLocalDataPoolIF* interface) {
-	return interface->getObjectId();
+object_id_t HasLocalDpIFManagerAttorney::getObjectId(HasLocalDataPoolIF* clientIF) {
+	return clientIF->getObjectId();
 }
diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.h b/datapoollocal/HasLocalDpIFManagerAttorney.h
index ca5965995..44b06592a 100644
--- a/datapoollocal/HasLocalDpIFManagerAttorney.h
+++ b/datapoollocal/HasLocalDpIFManagerAttorney.h
@@ -9,12 +9,12 @@ class LocalPoolObjectBase;
 
 class HasLocalDpIFManagerAttorney {
 
-	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* interface, sid_t sid);
+	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* clientIF, sid_t sid);
 
-	static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* interface,
+	static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
 			lp_id_t localPoolId);
 
-	static object_id_t getObjectId(HasLocalDataPoolIF* interface);
+	static object_id_t getObjectId(HasLocalDataPoolIF* clientIF);
 
 	friend class LocalDataPoolManager;
 };
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.cpp b/datapoollocal/HasLocalDpIFUserAttorney.cpp
index 002230fee..bb4d83d14 100644
--- a/datapoollocal/HasLocalDpIFUserAttorney.cpp
+++ b/datapoollocal/HasLocalDpIFUserAttorney.cpp
@@ -1,6 +1,7 @@
 #include "HasLocalDpIFUserAttorney.h"
+#include "AccessLocalPoolF.h"
 #include "HasLocalDataPoolIF.h"
 
-AccessPoolManagerIF* HasLocalDpIFUserAttorney::getAccessorHandle(HasLocalDataPoolIF *interface) {
-	return interface->getAccessorHandle();
+AccessPoolManagerIF* HasLocalDpIFUserAttorney::getAccessorHandle(HasLocalDataPoolIF *clientIF) {
+	return clientIF->getAccessorHandle();
 }
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.h b/datapoollocal/HasLocalDpIFUserAttorney.h
index 67b51a4ae..a07c2d595 100644
--- a/datapoollocal/HasLocalDpIFUserAttorney.h
+++ b/datapoollocal/HasLocalDpIFUserAttorney.h
@@ -7,7 +7,7 @@ class AccessPoolManagerIF;
 class HasLocalDpIFUserAttorney {
 private:
 
-	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* interface);
+	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* clientIF);
 
 	friend class LocalPoolObjectBase;
 	friend class LocalPoolDataSetBase;
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 2d170c3ff..5f17eeb68 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "MarkChangedIF.h"
+#include "localPoolDefinitions.h"
 
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
diff --git a/datapoollocal/localPoolDefinitions.h b/datapoollocal/localPoolDefinitions.h
index 5f5588958..86073e6fc 100644
--- a/datapoollocal/localPoolDefinitions.h
+++ b/datapoollocal/localPoolDefinitions.h
@@ -21,8 +21,11 @@ static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
 static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
 
+//! This is the core data structure of the local data pools. Users should insert all desired
+//! pool variables, using the std::map interface.
 using DataPool =  std::map<lp_id_t, PoolEntryIF*>;
 using DataPoolMapIter = DataPool::iterator;
+
 }
 
 /**
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index a5389812b..aaccc90ed 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -92,7 +92,7 @@ public:
 
 	// This is called by initializeAfterTaskCreation of the HK manager.
 	virtual ReturnValue_t initializeLocalDataPool(
-	        LocalDataPool& localDataPoolMap,
+	        localpool::DataPool& localDataPoolMap,
 	        LocalDataPoolManager& poolManager) {
 		// Default initialization empty for now.
 		localDataPoolMap.emplace(lpool::uint8VarId,
@@ -109,7 +109,16 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	LocalDataPoolManager* getHkManagerHandle() override {
+	/**
+	 * This function can be used by data pool consumers to retrieve a handle
+	 * which allows subscriptions to dataset and variable updates.
+	 * @return
+	 */
+	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override {
+		return &hkManager;
+	}
+
+	virtual AccessPoolManagerIF* getAccessorHandle() override {
 		return &hkManager;
 	}
 
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index 5f7118ff2..2e4cb7ecd 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -81,15 +81,15 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
 		REQUIRE(invalidVariable.read() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
 
 		REQUIRE(invalidVariable.commit() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
 		// now try to access with wrong type
 		lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
 		REQUIRE(invalidVariable2.read() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
 
 		lp_var_t<uint8_t> readOnlyVar = lp_var_t<uint8_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
index cfc2ec2ed..7c309bbb8 100644
--- a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -91,17 +91,17 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 		lp_vec_t<uint16_t, 3> invalidVector = lp_vec_t<uint16_t, 3>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
 		REQUIRE(invalidVector.read() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
 		REQUIRE(invalidVector.commit() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
 
 		// now try to access with wrong type
 		lp_vec_t<uint32_t, 3> invalidVector2 = lp_vec_t<uint32_t, 3>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
 		REQUIRE(invalidVector2.read() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
 		REQUIRE(invalidVector2.commit() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
 
 		lp_vec_t<uint16_t, 3> writeOnlyVec = lp_vec_t<uint16_t, 3>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,

From b3e2e93f52fe2ee5743f8f3beb6467067235d556 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:46:34 +0100
Subject: [PATCH 1444/1774] cleaned up a bit

---
 datapoollocal/CMakeLists.txt                  |  6 ++---
 datapoollocal/HasLocalDataPoolIF.h            | 23 +++++++++++--------
 datapoollocal/LocalDataPoolManager.cpp        |  4 ++--
 datapoollocal/LocalPoolDataSetBase.cpp        |  2 +-
 datapoollocal/LocalPoolObjectBase.cpp         |  2 +-
 datapoollocal/LocalPoolVariable.h             |  3 ++-
 datapoollocal/LocalPoolVector.h               |  3 ++-
 datapoollocal/PoolReadHelper.h                |  5 +++-
 datapoollocal/SharedLocalDataSet.h            |  7 ++++++
 datapoollocal/internal/CMakeLists.txt         |  5 ++++
 .../HasLocalDpIFManagerAttorney.cpp           |  6 ++---
 .../HasLocalDpIFManagerAttorney.h             |  2 +-
 .../HasLocalDpIFUserAttorney.cpp              |  4 ++--
 .../{ => internal}/HasLocalDpIFUserAttorney.h |  0
 .../{ => internal}/LocalDpManagerAttorney.h   |  0
 .../{ => internal}/LocalPoolDataSetAttorney.h |  3 +--
 datapoollocal/localPoolDefinitions.h          |  5 ++--
 17 files changed, 50 insertions(+), 30 deletions(-)
 create mode 100644 datapoollocal/internal/CMakeLists.txt
 rename datapoollocal/{ => internal}/HasLocalDpIFManagerAttorney.cpp (82%)
 rename datapoollocal/{ => internal}/HasLocalDpIFManagerAttorney.h (94%)
 rename datapoollocal/{ => internal}/HasLocalDpIFUserAttorney.cpp (72%)
 rename datapoollocal/{ => internal}/HasLocalDpIFUserAttorney.h (100%)
 rename datapoollocal/{ => internal}/LocalDpManagerAttorney.h (100%)
 rename datapoollocal/{ => internal}/LocalPoolDataSetAttorney.h (95%)

diff --git a/datapoollocal/CMakeLists.txt b/datapoollocal/CMakeLists.txt
index 925be505c..e2db39eb0 100644
--- a/datapoollocal/CMakeLists.txt
+++ b/datapoollocal/CMakeLists.txt
@@ -5,6 +5,6 @@ target_sources(${LIB_FSFW_NAME}
 		LocalPoolDataSetBase.cpp
 		LocalPoolObjectBase.cpp
 		SharedLocalDataSet.cpp
-		HasLocalDpIFUserAttorney.cpp
-		HasLocalDpIFManagerAttorney.cpp
-)
\ No newline at end of file
+)
+
+add_subdirectory(internal)
\ No newline at end of file
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index c1afb4a07..569f2b099 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -23,16 +23,11 @@ class LocalDataPoolManager;
  * @details
  * Any class implementing this interface shall also have a LocalDataPoolManager member class which
  * contains the actual pool data structure and exposes the public interface for it.
- * This is required because the pool entries are templates, which makes specifying an interface
- * rather difficult. The local data pool can be accessed by using the LocalPoolVariable,
- * LocalPoolVector or LocalDataSet classes.
+ * The local data pool can be accessed using helper classes by using the
+ * LocalPoolVariable, LocalPoolVector or LocalDataSet classes. Every local pool variable can
+ * be uniquely identified by a global pool ID (gp_id_t) and every dataset tied
+ * to a pool manager can be uniqely identified by a global structure ID (sid_t).
  *
- * Architectural Note:
- * This could be circumvented by using a wrapper/accessor function or implementing the templated
- * function in this interface.. The first solution sounds better than the second but the
- * LocalPoolVariable classes are templates as well, so this just shifts the problem somewhere else.
- * Interfaces are nice, but the most pragmatic solution I found was to offer the client the full
- * interface of the LocalDataPoolManager.
  */
 class HasLocalDataPoolIF {
 	friend class HasLocalDpIFManagerAttorney;
@@ -106,13 +101,21 @@ public:
 
 	/**
 	 * This function can be used by data pool consumers to retrieve a handle
-	 * which allows subscriptions to dataset and variable updates.
+	 * which allows subscriptions to dataset and variable updates in form of messages.
+	 * The consumers can then read the most recent variable value by calling read with
+	 * an own pool variable or set instance or using the deserialized snapshot data.
 	 * @return
 	 */
 	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
 
 protected:
 
+	/**
+	 * Accessor handle required for internal handling. Not intended for users and therefore
+	 * declared protected. Users should instead use pool variables, sets or the subscription
+	 * interface to access pool entries.
+	 * @return
+	 */
 	virtual AccessPoolManagerIF* getAccessorHandle() = 0;
 
 	/**
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 3902a0fe5..462ef17fa 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -2,8 +2,8 @@
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
-#include "LocalPoolDataSetAttorney.h"
-#include "HasLocalDpIFManagerAttorney.h"
+#include "internal/LocalPoolDataSetAttorney.h"
+#include "internal/HasLocalDpIFManagerAttorney.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index cd0f8931e..5343a9c91 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -1,6 +1,6 @@
 #include "LocalPoolDataSetBase.h"
 #include "HasLocalDataPoolIF.h"
-#include "HasLocalDpIFUserAttorney.h"
+#include "internal/HasLocalDpIFUserAttorney.h"
 
 #include "../serviceinterface/ServiceInterface.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 6dc6e356d..bd1bfa0f0 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,6 +1,6 @@
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
-#include "HasLocalDpIFUserAttorney.h"
+#include "internal/HasLocalDpIFUserAttorney.h"
 #include "HasLocalDataPoolIF.h"
 
 #include "../objectmanager/ObjectManagerIF.h"
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index e66c565c8..859c8f08c 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,11 +1,12 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 
-#include <fsfw/datapoollocal/LocalDpManagerAttorney.h>
 #include "LocalPoolObjectBase.h"
 #include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
 #include "AccessLocalPoolF.h"
+#include "internal/LocalDpManagerAttorney.h"
+
 #include "../datapool/PoolVariableIF.h"
 #include "../datapool/DataSetIF.h"
 #include "../serviceinterface/ServiceInterface.h"
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 3f26b9f51..742556054 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,8 +1,9 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 
-#include <fsfw/datapoollocal/LocalDpManagerAttorney.h>
 #include "LocalPoolObjectBase.h"
+#include "internal/LocalDpManagerAttorney.h"
+
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
 #include "../datapool/PoolVariableIF.h"
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index c89fff982..61e5feaf3 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -1,7 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
 #define FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
 
-#include <fsfw/datapoollocal/LocalPoolDataSetBase.h>
+#include "LocalPoolDataSetBase.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include <FSFWConfig.h>
 
 /**
@@ -19,6 +20,8 @@ public:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PoolReadHelper: Read failed!" << std::endl;
 #endif
+#else
+			sif::printError("PoolReadHelper: Read failed!\n");
 #endif
 		}
 	}
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index 2e5a76fa9..713d435b1 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -6,6 +6,13 @@
 #include "../objectmanager/SystemObject.h"
 #include <vector>
 
+/**
+ * This local dataset variation can be used if the dataset is used concurrently across
+ * multiple threads. It provides a lock in addition to all other functionalities provided
+ * by the LocalPoolDataSetBase class.
+ *
+ * TODO: override and protect read, commit and some other calls used by pool manager.
+ */
 class SharedLocalDataSet: public SystemObject,
         public LocalPoolDataSetBase,
         public SharedDataSetIF {
diff --git a/datapoollocal/internal/CMakeLists.txt b/datapoollocal/internal/CMakeLists.txt
new file mode 100644
index 000000000..554f3b884
--- /dev/null
+++ b/datapoollocal/internal/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		HasLocalDpIFUserAttorney.cpp
+		HasLocalDpIFManagerAttorney.cpp
+)
diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.cpp b/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
similarity index 82%
rename from datapoollocal/HasLocalDpIFManagerAttorney.cpp
rename to datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
index a683cf7be..bc07170f9 100644
--- a/datapoollocal/HasLocalDpIFManagerAttorney.cpp
+++ b/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
@@ -1,7 +1,7 @@
 #include "HasLocalDpIFManagerAttorney.h"
-#include "LocalPoolObjectBase.h"
-#include "LocalPoolDataSetBase.h"
-#include "HasLocalDataPoolIF.h"
+#include "../LocalPoolObjectBase.h"
+#include "../LocalPoolDataSetBase.h"
+#include "../HasLocalDataPoolIF.h"
 
 LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* clientIF,
 		sid_t sid) {
diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.h b/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
similarity index 94%
rename from datapoollocal/HasLocalDpIFManagerAttorney.h
rename to datapoollocal/internal/HasLocalDpIFManagerAttorney.h
index 44b06592a..ef180b37c 100644
--- a/datapoollocal/HasLocalDpIFManagerAttorney.h
+++ b/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
 
-#include "localPoolDefinitions.h"
+#include "../localPoolDefinitions.h"
 
 class HasLocalDataPoolIF;
 class LocalPoolDataSetBase;
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.cpp b/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
similarity index 72%
rename from datapoollocal/HasLocalDpIFUserAttorney.cpp
rename to datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
index bb4d83d14..838204a76 100644
--- a/datapoollocal/HasLocalDpIFUserAttorney.cpp
+++ b/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
@@ -1,6 +1,6 @@
 #include "HasLocalDpIFUserAttorney.h"
-#include "AccessLocalPoolF.h"
-#include "HasLocalDataPoolIF.h"
+#include "../AccessLocalPoolF.h"
+#include "../HasLocalDataPoolIF.h"
 
 AccessPoolManagerIF* HasLocalDpIFUserAttorney::getAccessorHandle(HasLocalDataPoolIF *clientIF) {
 	return clientIF->getAccessorHandle();
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.h b/datapoollocal/internal/HasLocalDpIFUserAttorney.h
similarity index 100%
rename from datapoollocal/HasLocalDpIFUserAttorney.h
rename to datapoollocal/internal/HasLocalDpIFUserAttorney.h
diff --git a/datapoollocal/LocalDpManagerAttorney.h b/datapoollocal/internal/LocalDpManagerAttorney.h
similarity index 100%
rename from datapoollocal/LocalDpManagerAttorney.h
rename to datapoollocal/internal/LocalDpManagerAttorney.h
diff --git a/datapoollocal/LocalPoolDataSetAttorney.h b/datapoollocal/internal/LocalPoolDataSetAttorney.h
similarity index 95%
rename from datapoollocal/LocalPoolDataSetAttorney.h
rename to datapoollocal/internal/LocalPoolDataSetAttorney.h
index 36358db41..9804444af 100644
--- a/datapoollocal/LocalPoolDataSetAttorney.h
+++ b/datapoollocal/internal/LocalPoolDataSetAttorney.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
 
-#include <fsfw/datapoollocal/LocalPoolDataSetBase.h>
+#include "../LocalPoolDataSetBase.h"
 
 class LocalPoolDataSetAttorney {
 private:
@@ -36,5 +36,4 @@ private:
 };
 
 
-
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_ */
diff --git a/datapoollocal/localPoolDefinitions.h b/datapoollocal/localPoolDefinitions.h
index 86073e6fc..3ff1feeda 100644
--- a/datapoollocal/localPoolDefinitions.h
+++ b/datapoollocal/localPoolDefinitions.h
@@ -29,7 +29,7 @@ using DataPoolMapIter = DataPool::iterator;
 }
 
 /**
- * Used as a unique identifier for data sets.
+ * Used as a unique identifier for data sets. Consists of 4 byte object ID and 4 byte set ID.
  */
 union sid_t {
     static constexpr uint64_t INVALID_SID = -1;
@@ -71,7 +71,8 @@ union sid_t {
 };
 
 /**
- * Used as a global unique identifier for local pool variables.
+ * Used as a global unique identifier for local pool variables. Consists of 4 byte object ID
+ * and 4 byte local pool ID.
  */
 union gp_id_t {
 	static constexpr uint64_t INVALID_GPID = -1;

From f9a8c3d35a625c5bfde4edb1705f5a477a19444e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:46:54 +0100
Subject: [PATCH 1445/1774] updated .mk support

---
 fsfw.mk | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fsfw.mk b/fsfw.mk
index 3df63060e..0d72fae14 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -10,6 +10,7 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/internal/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp)

From 59b4f50c1ca40a7485598aef2bd9b4a8313998e2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:53:30 +0100
Subject: [PATCH 1446/1774] added FSFW verbose level

---
 datapoollocal/AccessLocalPoolF.h        | 7 ++++---
 defaultcfg/fsfwconfig/FSFWConfig.h      | 4 ++--
 internalError/InternalErrorReporter.cpp | 7 ++++++-
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
index 88ccec936..da08644f8 100644
--- a/datapoollocal/AccessLocalPoolF.h
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -1,11 +1,12 @@
 #ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
 #define FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
 
-//#include "LocalDataPoolManager.h"
-#include <fsfw/ipc/MutexIF.h>
-
 class LocalDataPoolManager;
+class MutexIF;
 
+/**
+ * @brief 	Accessor class which can be used by classes which like to use the pool manager.
+ */
 class AccessPoolManagerIF {
 public:
 	virtual ~AccessPoolManagerIF() {};
diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index e251729cd..49678d357 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -9,8 +9,8 @@
 //! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! More FSFW related printouts. Useful for development.
-#define FSFW_ENHANCED_PRINTOUT		0
+//! More FSFW related printouts depending on level. Useful for development.
+#define FSFW_VERBOSE_LEVEL			1
 
 //! Can be used to completely disable printouts, even the C stdio ones.
 #if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 5656f208a..bc72ada24 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -29,7 +29,7 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	uint32_t newTmHits = getAndResetTmHits();
 	uint32_t newStoreHits = getAndResetStoreHits();
 
-#if FSFW_ENHANCED_PRINTOUT == 1
+#if FSFW_VERBOSE_LEVEL == 1
 	if(diagnosticPrintout) {
 	    if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -38,6 +38,11 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
 	        sif::debug << "TM errors: " << newTmHits << std::endl;
 	        sif::debug << "Store errors: " << newStoreHits << std::endl;
+#else
+	        sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
+	        sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
+	        sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
+	        sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
 #endif
 	    }
 	}

From b637f033899f3b68d5d8e339811059696721504e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:54:52 +0100
Subject: [PATCH 1447/1774] updated defaultconfig

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 49678d357..0740c9c7b 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -13,7 +13,7 @@
 #define FSFW_VERBOSE_LEVEL			1
 
 //! Can be used to completely disable printouts, even the C stdio ones.
-#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
 	#define FSFW_DISABLE_PRINTOUT 	0
 #endif
 

From 0b08ac10041cd6803cf3058ddd0ef030422157ca Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:56:53 +0100
Subject: [PATCH 1448/1774] updated template config files

---
 datapoollocal/PoolReadHelper.h     |  2 +-
 defaultcfg/fsfwconfig/FSFWConfig.h |  3 ---
 unittest/user/testcfg/FSFWConfig.h | 10 +++-------
 3 files changed, 4 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index 61e5feaf3..62db15982 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -16,7 +16,7 @@ public:
 			readObject(readObject), mutexTimeout(mutexTimeout) {
 		if(readObject != nullptr) {
 			readResult = readObject->read(timeoutType, mutexTimeout);
-#if FSFW_PRINT_VERBOSITY_LEVEL == 1
+#if FSFW_VERBOSE_LEVEL == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PoolReadHelper: Read failed!" << std::endl;
 #endif
diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 0740c9c7b..ed86e6e1f 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -17,9 +17,6 @@
 	#define FSFW_DISABLE_PRINTOUT 	0
 #endif
 
-//! Can be used to enable additional debugging printouts for developing the FSFW
-#define FSFW_PRINT_VERBOSITY_LEVEL   0
-
 //! Can be used to disable the ANSI color sequences for C stdio.
 #define FSFW_COLORED_OUTPUT 		1
 
diff --git a/unittest/user/testcfg/FSFWConfig.h b/unittest/user/testcfg/FSFWConfig.h
index 261e3d6d2..ed86e6e1f 100644
--- a/unittest/user/testcfg/FSFWConfig.h
+++ b/unittest/user/testcfg/FSFWConfig.h
@@ -9,18 +9,14 @@
 //! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! More FSFW related printouts.
-//! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_ENHANCED_PRINTOUT		0
+//! More FSFW related printouts depending on level. Useful for development.
+#define FSFW_VERBOSE_LEVEL			1
 
 //! Can be used to completely disable printouts, even the C stdio ones.
-#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
 	#define FSFW_DISABLE_PRINTOUT 	0
 #endif
 
-//! Can be used to enable additional debugging printouts for developing the FSFW
-#define FSFW_PRINT_VERBOSITY_LEVEL   0
-
 //! Can be used to disable the ANSI color sequences for C stdio.
 #define FSFW_COLORED_OUTPUT 		1
 

From 634a8f3469154c009698ccea120520b4d6d2c3a1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:59:15 +0100
Subject: [PATCH 1449/1774] renamed to pool manager for consistency

---
 devicehandlers/DeviceHandlerBase.cpp               | 14 +++++++-------
 devicehandlers/DeviceHandlerBase.h                 | 12 +++++++-----
 .../tests/datapoollocal/LocalPoolManagerTest.cpp   | 12 ++++++------
 3 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index acfdd81ec..c40985255 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -24,7 +24,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		actionHelper(this, nullptr), hkManager(this, nullptr),
+		actionHelper(this, nullptr), poolManager(this, nullptr),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
 		switchOffWasReported(false), childTransitionDelay(5000),
@@ -107,7 +107,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		doGetRead();
 		// This will be performed after datasets have been updated by the
 		// custom device implementation.
-		hkManager.performHkOperation();
+		poolManager.performHkOperation();
 		break;
 	default:
 		break;
@@ -210,7 +210,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-	result = hkManager.initialize(commandQueue);
+	result = poolManager.initialize(commandQueue);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -280,7 +280,7 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	result = hkManager.handleHousekeepingMessage(&command);
+	result = poolManager.handleHousekeepingMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
@@ -1438,7 +1438,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
     if(executingTask != nullptr) {
         pstIntervalMs = executingTask->getPeriodMs();
     }
-    this->hkManager.initializeAfterTaskCreation();
+    this->poolManager.initializeAfterTaskCreation();
 
     if(setStartupImmediately) {
         startTransition(MODE_ON, SUBMODE_NONE);
@@ -1484,7 +1484,7 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 }
 
 AccessPoolManagerIF* DeviceHandlerBase::getAccessorHandle() {
-	return &hkManager;
+	return &poolManager;
 }
 
 void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
@@ -1533,5 +1533,5 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
 }
 
 ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubscriptionInterface() {
-	return &hkManager;
+	return &poolManager;
 }
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 6042d2497..43f61897a 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -517,12 +517,14 @@ protected:
 	virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
 				LocalDataPoolManager& poolManager) override;
 
-
-	/** Get the HK manager object handle */
-	//LocalDataPoolManager* getHkManagerHandle() override;
-
+	/**
+	 * Provides the subscription handle which can be used by classes like controllers
+	 * to get messages on data updates.
+	 * @return
+	 */
 	ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
+	//! Accessor handle required for internal handling.
 	AccessPoolManagerIF* getAccessorHandle() override;
 
 	/**
@@ -653,7 +655,7 @@ protected:
 	/** Action helper for HasActionsIF */
 	ActionHelper actionHelper;
 	/** Housekeeping Manager */
-	LocalDataPoolManager hkManager;
+	LocalDataPoolManager poolManager;
 
 	/**
 	 *  @brief Information about commands
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index f497e6101..f550582e9 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -27,7 +27,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		// Subscribe for an update message.
 		poolOwner->dataset.setChanged(true);
 		// Now the update message should be generated.
-		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 		REQUIRE(mqMock->wasMessageSent() == true);
 
 		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
@@ -38,7 +38,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		CHECK(poolOwner->dataset.hasChanged() == false);
 		// Set changed again, result should be the same.
 		poolOwner->dataset.setChanged(true);
-		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 
 		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
 		CHECK(messagesSent == 1);
@@ -49,7 +49,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		// now subscribe for set update HK as well.
 		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
 		poolOwner->dataset.setChanged(true);
-		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
 		CHECK(messagesSent == 2);
 		// first message sent should be the update notification, considering
@@ -77,7 +77,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 				poolOwner->getPoolObjectHandle(lpool::uint8VarId));
 		REQUIRE(poolVar != nullptr);
 		poolVar->setChanged(true);
-		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 
 		// Check update notification was sent.
 		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
@@ -93,7 +93,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
 
 		poolOwner->dataset.setChanged(true);
-		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 		// now two messages should be sent.
 		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
 		CHECK(messagesSent == 2);
@@ -101,7 +101,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 
 		poolOwner->dataset.setChanged(true);
 		poolVar->setChanged(true);
-		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 		// now three messages should be sent.
 		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
 		CHECK(messagesSent == 3);

From af7e9194e5f2acdd5be08f3959511d93befa1477 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 21:01:55 +0100
Subject: [PATCH 1450/1774] more consistency renamings

---
 controller/ExtendedControllerBase.cpp | 16 ++++++++--------
 controller/ExtendedControllerBase.h   | 13 ++++++++++---
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 74453b253..e0aec63a5 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -4,7 +4,7 @@
 ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId,
         object_id_t parentId, size_t commandQueueDepth):
         ControllerBase(objectId, parentId, commandQueueDepth),
-        localPoolManager(this, commandQueue),
+        poolManager(this, commandQueue),
         actionHelper(this, commandQueue) {
 }
 
@@ -27,7 +27,7 @@ object_id_t ExtendedControllerBase::getObjectId() const {
 }
 
 AccessPoolManagerIF* ExtendedControllerBase::getAccessorHandle() {
-    return &localPoolManager;
+    return &poolManager;
 }
 
 uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const {
@@ -40,7 +40,7 @@ ReturnValue_t ExtendedControllerBase::handleCommandMessage(
     if(result == HasReturnvaluesIF::RETURN_OK) {
         return result;
     }
-    return localPoolManager.handleHousekeepingMessage(message);
+    return poolManager.handleHousekeepingMessage(message);
 }
 
 void ExtendedControllerBase::handleQueue() {
@@ -64,7 +64,7 @@ void ExtendedControllerBase::handleQueue() {
             continue;
         }
 
-        result = localPoolManager.handleHousekeepingMessage(&command);
+        result = poolManager.handleHousekeepingMessage(&command);
         if (result == RETURN_OK) {
             continue;
         }
@@ -88,16 +88,16 @@ ReturnValue_t ExtendedControllerBase::initialize() {
         return result;
     }
 
-    return localPoolManager.initialize(commandQueue);
+    return poolManager.initialize(commandQueue);
 }
 
 ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
-    return localPoolManager.initializeAfterTaskCreation();
+    return poolManager.initializeAfterTaskCreation();
 }
 
 ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
     handleQueue();
-    localPoolManager.performHkOperation();
+    poolManager.performHkOperation();
     performControlOperation();
     return RETURN_OK;
 }
@@ -115,5 +115,5 @@ LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
 }
 
 ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubscriptionInterface() {
-	return &localPoolManager;
+	return &poolManager;
 }
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index 6076b2fec..b27605141 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -32,13 +32,20 @@ public:
     virtual ReturnValue_t performOperation(uint8_t opCode) override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
-   ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
-   AccessPoolManagerIF* getAccessorHandle() override;
+    /**
+     * Provides a subscription interface for objects which required updates on changed
+     * controller variables or datasets
+     * @return
+     */
+    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
 protected:
-    LocalDataPoolManager localPoolManager;
+    LocalDataPoolManager poolManager;
     ActionHelper actionHelper;
 
+    //! Accessor handle required for internal handling
+    AccessPoolManagerIF* getAccessorHandle() override;
+
     /**
      * Implemented by child class. Handle all command messages which are
      * not health, mode, action or housekeeping messages.

From eb5c56664fd3bc41fb6ea006987096150b95dec1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 21:03:09 +0100
Subject: [PATCH 1451/1774] relative include

---
 housekeeping/HousekeepingMessage.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index a64ce18be..0c7680dc0 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
 #include "../objectmanager/frameworkObjects.h"

From 482f240995f9d72bd1c3cf1f08de890cd3e4e3f2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 11:39:19 +0100
Subject: [PATCH 1452/1774] doc update

---
 README.md                    | 133 +++++++----------------------------
 doc/README-controllers.md    |   1 +
 doc/README-core.md           |   5 +-
 doc/README-devicehandlers.md |   2 +-
 doc/README-highlevel.md      |  99 ++++++++++++++++++++++++++
 doc/README-localpools.md     |   3 +
 doc/README-osal.md           |  32 +++++++++
 doc/README-pus.md            |   1 +
 8 files changed, 165 insertions(+), 111 deletions(-)
 create mode 100644 doc/README-controllers.md
 create mode 100644 doc/README-highlevel.md
 create mode 100644 doc/README-localpools.md
 create mode 100644 doc/README-osal.md
 create mode 100644 doc/README-pus.md

diff --git a/README.md b/README.md
index 8552e0c81..fb3be429e 100644
--- a/README.md
+++ b/README.md
@@ -9,121 +9,40 @@ The initial version of the Flight Software Framework was developed during
 the Flying Laptop Project by the University of Stuttgart in cooperation
 with Airbus Defence and Space GmbH.
 
-## Intended Use
+## Quick facts
 
-The framework is designed for systems, which communicate with external devices, perform control loops, receive telecommands and send telemetry, and need to maintain a high level of availability. 
-Therefore, a mode and health system provides control over the states of the software and the controlled devices. 
-In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 
+The framework is designed for systems, which communicate with external devices, perform control loops, receive telecommands and send telemetry, and need to maintain a high level of availability. Therefore, a mode and health system provides control over the states of the software and the controlled devices. In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 
 
-The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile Memory. 
-For reference, current Applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC.
-The `fsfw` was also tested on the STM32H743ZI-Nucleo board.
+The FSFW provides abstraction layers for operating systems to provide a uniform operating system abstraction layer (OSAL). Some components of this OSAL are required internally by the FSFW but is also very useful for developers to implement the same application logic on different operating systems with a uniform interface.
 
-## How to Use
+Currently, the FSFW provides the following OSALs:
+
+- Linux
+- Host 
+- FreeRTOS
+- RTEMS
+
+The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile Memory. For reference, current applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC. The `fsfw` was also successfully run on the STM32H743ZI-Nucleo board and on a Raspberry Pi and is currently running on the active satellite mission Flying Laptop.
+
+## Getting started
+
+The [FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example) provides a good starting point and a demo to see the FSFW capabilities and build it with the Make or the CMake build system. It is recommended to evaluate the FSFW by building and playing around with the demo application.
 
-The [FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example) provides a good starting point and a demo
-to see the FSFW capabilities and build it with the Make or the CMake build system. 
 Generally, the FSFW is included in a project by compiling the FSFW sources and providing
-a configuration folder and adding it to the include path. 
+a configuration folder and adding it to the include path. There are some functions like `printChar` which are different depending on the target architecture and need to be implemented by the mission developer.
+
 A template configuration folder was provided and can be copied into the project root to have
-a starting point. The [configuration section](doc/README-config.md#top) provides more specific information about
-the possible options.
+a starting point. The [configuration section](doc/README-config.md#top) provides more specific information about the possible options.
 
-## Structure
+## Index
 
-The general structure is driven by the usage of interfaces provided by objects. 
-The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
-The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
-This simplifies the instantiation of objects and allows the usage of some standard containers. 
-Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
-The fsfw uses run-time type information but exceptions are not allowed.
+[1. High-level overview](doc/README-highlevel.md#top) <br>
+[2. Core components](doc/README-core.md#top) <br>
+[3. OSAL overview](doc/README-osal.md#top) <br>
+[4. PUS services](doc/README-pus.md#top) <br>
+[5. Device Handler overview](doc/README-devicehandlers.md#top) <br>
+[6. Controller overview](doc/README-controllers.md#top) <br>
+[7. Local Data Pools](doc/README-localpools.md#top) <br>
 
-### Failure Handling
 
-Functions should return a defined ReturnValue_t to signal to the caller that something has gone wrong. 
-Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
-The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
 
-### OSAL
-
-The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
-A independent Host OSAL is in development which will provide abstraction for common type of 
-host OSes (tested for Linux and Windows, not for MacOS yet).
-The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
-
-### Core Components 
-
-The FSFW has following core components. More detailed informations can be found in the
-[core component section](doc/README-core.md#top):
-
-1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks with fixed timeslots
-2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID to the object handles.
-3. Static Stores: Different stores are provided to store data of variable size (like telecommands or small telemetry) in a pool structure without
-   using dynamic memory allocation. These pools are allocated up front.
-3. Clock: This module provided common time related functions
-4. EventManager: This module allows routing of events generated by `SystemObjects`
-5. HealthTable: A component which stores the health states of objects
-
-### Static Ids in the framework
-
-Some parts of the framework use a static routing address for communication. 
-An example setup of ids can be found in the example config in "defaultcft/fsfwconfig/objects/Factory::setStaticFrameworkObjectIds()".
-
-### Events
-
-Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. This works analog to the returnvalues.
-Every object that needs own EventIds has to get a unique SUBSYSTEM_ID. 
-Every SystemObject can call triggerEvent from the parent class.
-Therefore, event messages contain the specific EventId and the objectId of the object that has triggered.
-
-### Internal Communication
-
-Components communicate mostly over Message through Queues. 
-Those queues are created by calling the singleton QueueFactory::instance()->create(). 
-
-### External Communication
-
-The external communication with the mission control system is mostly up to the user implementation.
-The FSFW provides PUS Services which can be used to but don't need to be used. 
-The services can be seen as a conversion from a TC to a message based communication and back.
-
-#### CCSDS Frames, CCSDS Space Packets and PUS
-
-If the communication is based on CCSDS Frames and Space Packets, several classes can be used to distributed the packets to the corresponding services. Those can be found in tcdistribution. 
-If Space Packets are used, a timestamper must be created. 
-An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
-
-#### Device Handlers
-
-DeviceHandlers are another important component of the FSFW. 
-The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
-By separating the underlying Communication Interface with DeviceCommunicationIF, a device handler (DH) can be tested on different hardware.
-The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
-Device Handlers can be created by overriding `DeviceHandlerBase`. 
-A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
-More information on DeviceHandlers can be found in the related [documentation section](doc/README-devicehandlers.md#top).
-
-#### Modes, Health
-
-The two interfaces HasModesIF and HasHealthIF provide access for commanding and monitoring of components.
-On-board Mode Management is implement in hierarchy system. 
-DeviceHandlers and Controllers are the lowest part of the hierarchy. 
-The next layer are Assemblies. Those assemblies act as a component which handle redundancies of handlers. 
-Assemblies share a common core with the next level which are the Subsystems. 
-
-Those Assemblies are intended to act as auto-generated components from a database which describes the subsystem modes. 
-The definitions contain transition and target tables which contain the DH, Assembly and Controller Modes to be commanded.
-Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a switch into any higher AOCS mode might first turn on the sensors, than the actuators and the controller as last component. 
-The target table is used to describe the state that is checked continuously by the subsystem. 
-All of this allows System Modes to be generated as Subsystem object as well from the same database. 
-This System contains list of subsystem modes in the transition and target tables. 
-Therefore, it allows a modular system to create system modes and easy commanding of those, because only the highest components must be commanded.
-
-The health state represents if the component is able to perform its tasks. 
-This can be used to signal the system to avoid using this component instead of a redundant one.
-The on-board FDIR uses the health state for isolation and recovery. 
-
-## Unit Tests
-
-Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. 
-See README.md in the unittest Folder.
\ No newline at end of file
diff --git a/doc/README-controllers.md b/doc/README-controllers.md
new file mode 100644
index 000000000..7af0652d4
--- /dev/null
+++ b/doc/README-controllers.md
@@ -0,0 +1 @@
+## Controllers
diff --git a/doc/README-core.md b/doc/README-core.md
index c47ae0f29..6431b8311 100644
--- a/doc/README-core.md
+++ b/doc/README-core.md
@@ -16,9 +16,8 @@ Flight Software Framework
 * A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
 A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
 
-``` c++
-	template <typename T> T* ObjectManagerIF::get( object_id_t id )
-
+```cpp
+template <typename T> T* ObjectManagerIF::get( object_id_t id )
 ```
 * A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
 By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.
diff --git a/doc/README-devicehandlers.md b/doc/README-devicehandlers.md
index 6e737cc5a..8b6551aa0 100644
--- a/doc/README-devicehandlers.md
+++ b/doc/README-devicehandlers.md
@@ -1 +1 @@
-## FSFW DeviceHandlers
\ No newline at end of file
+## Device Handlers
diff --git a/doc/README-highlevel.md b/doc/README-highlevel.md
new file mode 100644
index 000000000..fac89c536
--- /dev/null
+++ b/doc/README-highlevel.md
@@ -0,0 +1,99 @@
+# High-level overview
+
+## Structure
+
+The general structure is driven by the usage of interfaces provided by objects. 
+The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
+The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
+This simplifies the instantiation of objects and allows the usage of some standard containers. 
+Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
+The fsfw uses run-time type information but exceptions are not allowed.
+
+### Failure Handling
+
+Functions should return a defined ReturnValue_t to signal to the caller that something has gone wrong. 
+Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
+The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
+
+### OSAL
+
+The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
+The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
+The [OSAL README](doc/README-osal.md#top) provides more detailed information on provided components and how to use them.
+
+### Core Components 
+
+The FSFW has following core components. More detailed informations can be found in the
+[core component section](doc/README-core.md#top):
+
+1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks with fixed timeslots
+2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID to the object handles.
+3. Static Stores: Different stores are provided to store data of variable size (like telecommands or small telemetry) in a pool structure without
+   using dynamic memory allocation. These pools are allocated up front.
+3. Clock: This module provided common time related functions
+4. EventManager: This module allows routing of events generated by `SystemObjects`
+5. HealthTable: A component which stores the health states of objects
+
+### Static IDs in the framework
+
+Some parts of the framework use a static routing address for communication. 
+An example setup of ids can be found in the example config in "defaultcft/fsfwconfig/objects/Factory::setStaticFrameworkObjectIds()".
+
+### Events
+
+Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. This works analog to the returnvalues.
+Every object that needs own EventIds has to get a unique SUBSYSTEM_ID. 
+Every SystemObject can call triggerEvent from the parent class.
+Therefore, event messages contain the specific EventId and the objectId of the object that has triggered.
+
+### Internal Communication
+
+Components communicate mostly over Message through Queues. 
+Those queues are created by calling the singleton QueueFactory::instance()->create(). 
+
+### External Communication
+
+The external communication with the mission control system is mostly up to the user implementation.
+The FSFW provides PUS Services which can be used to but don't need to be used. 
+The services can be seen as a conversion from a TC to a message based communication and back.
+
+#### CCSDS Frames, CCSDS Space Packets and PUS
+
+If the communication is based on CCSDS Frames and Space Packets, several classes can be used to distributed the packets to the corresponding services. Those can be found in tcdistribution. 
+If Space Packets are used, a timestamper must be created. 
+An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
+
+#### Device Handlers
+
+DeviceHandlers are another important component of the FSFW. 
+The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
+By separating the underlying Communication Interface with DeviceCommunicationIF, a device handler (DH) can be tested on different hardware.
+The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
+Device Handlers can be created by overriding `DeviceHandlerBase`. 
+A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
+More information on DeviceHandlers can be found in the related [documentation section](doc/README-devicehandlers.md#top).
+
+#### Modes, Health
+
+The two interfaces HasModesIF and HasHealthIF provide access for commanding and monitoring of components.
+On-board Mode Management is implement in hierarchy system. 
+DeviceHandlers and Controllers are the lowest part of the hierarchy. 
+The next layer are Assemblies. Those assemblies act as a component which handle redundancies of handlers. 
+Assemblies share a common core with the next level which are the Subsystems. 
+
+Those Assemblies are intended to act as auto-generated components from a database which describes the subsystem modes. 
+The definitions contain transition and target tables which contain the DH, Assembly and Controller Modes to be commanded.
+Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a switch into any higher AOCS mode might first turn on the sensors, than the actuators and the controller as last component. 
+The target table is used to describe the state that is checked continuously by the subsystem. 
+All of this allows System Modes to be generated as Subsystem object as well from the same database. 
+This System contains list of subsystem modes in the transition and target tables. 
+Therefore, it allows a modular system to create system modes and easy commanding of those, because only the highest components must be commanded.
+
+The health state represents if the component is able to perform its tasks. 
+This can be used to signal the system to avoid using this component instead of a redundant one.
+The on-board FDIR uses the health state for isolation and recovery. 
+
+## Unit Tests
+
+Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. More information on how to run these tests can be found in the separate
+[`fsfw_tests` reposoitory](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_tests)
diff --git a/doc/README-localpools.md b/doc/README-localpools.md
new file mode 100644
index 000000000..8dd83385e
--- /dev/null
+++ b/doc/README-localpools.md
@@ -0,0 +1,3 @@
+## Local Data Pools
+
+
diff --git a/doc/README-osal.md b/doc/README-osal.md
new file mode 100644
index 000000000..6f8ce60f5
--- /dev/null
+++ b/doc/README-osal.md
@@ -0,0 +1,32 @@
+# Operating System Abstraction Layer (OSAL)
+
+Some specific information on the provided OSALs are provided.
+
+## Linux OSAL
+
+This OSAL can be used to compile for Linux host systems like Ubuntu 20.04 or for 
+embedded Linux targets like the Raspberry Pi. This OSAL generally requires threading support
+and real-time functionalities. For most UNIX systems, this is done by adding `-lrt` and `-lpthread` to the linked libraries in the compilation process. The CMake build support provided will do this automatically for the `fsfw` target. It should be noted that most UNIX systems need to be configured specifically to allow the real-time functionalities required by the FSFW.
+
+More information on how to set up a Linux system accordingly can be found in the 
+[Linux README of the FSFW example application](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example/src/branch/master/doc/README-linux.md#top)
+
+## Hosted OSAL
+
+This is the newest OSAL. Support for Semaphores has not been implemented yet and will propably be implemented as soon as C++20 with Semaphore support has matured. This OSAL can be used to run the FSFW on any host system, but currently has only been tested on Windows 10 and Ubuntu 20.04. Unlike the other OSALs, it uses dynamic memory allocation (e.g. for the message queue implementation). Cross-platform serial port (USB) support might be added soon.
+
+## FreeRTOS OSAL
+
+FreeRTOS is not included and the developer needs to take care of compiling the FreeRTOS sources and adding the `FreeRTOSConfig.h` file location to the include path. This OSAL has only been tested extensively with the pre-emptive scheduler configuration so far but it should in principle also be possible to use a cooperative scheduler. It is recommended to use the `heap_4` allocation scheme. When using newlib (nano), it is also recommended to add `#define configUSE_NEWLIB_REENTRANT` to the FreeRTOS configuration file to ensure thread-safety.
+
+When using this OSAL, developers also need to provide an implementation for the `vRequestContextSwitchFromISR` function. This has been done because the call to request a context switch from an ISR is generally located in the `portmacro.h` header and is different depending on the target architecture or device.
+
+## RTEMS OSAL
+
+The RTEMS OSAL was the first implemented OSAL which is also used on the active satellite Flying Laptop.
+
+## TCP/IP socket abstraction
+
+The Linux and Host OSAL provide abstraction layers for the socket API. Currently, only UDP sockets have been imlemented. This is very useful to test TMTC handling either on the host computer directly (targeting localhost with a TMTC application) or on embedded Linux devices, sending TMTC packets via Ethernet.
+
+
diff --git a/doc/README-pus.md b/doc/README-pus.md
new file mode 100644
index 000000000..928d2eda0
--- /dev/null
+++ b/doc/README-pus.md
@@ -0,0 +1 @@
+## PUS Services

From 27e5254ecdb34ee197353230e88da718c5e9049e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 11:45:47 +0100
Subject: [PATCH 1453/1774] include fixes

---
 monitoring/MonitorReporter.h          | 2 +-
 monitoring/MonitoringMessageContent.h | 9 +++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 6b3204b38..7ce110e57 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -1,11 +1,11 @@
 #ifndef FSFW_MONITORING_MONITORREPORTER_H_
 #define FSFW_MONITORING_MONITORREPORTER_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
 
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index e44e8480a..d830e3136 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -1,9 +1,10 @@
-#ifndef MONITORINGMESSAGECONTENT_H_
-#define MONITORINGMESSAGECONTENT_H_
+#ifndef FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_
+#define FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
+
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
@@ -85,4 +86,4 @@ private:
 template<typename T>
 object_id_t MonitoringReportContent<T>::timeStamperId = 0;
 
-#endif /* MONITORINGMESSAGECONTENT_H_ */
+#endif /* FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_ */

From c9913ea53adf8b07e65d2e7a0ad8fd735002af7a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 11:47:04 +0100
Subject: [PATCH 1454/1774] updated cmakelists

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3cc5ffd58..587e67012 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -106,7 +106,7 @@ else()
 	)
 endif()
 
-if(CMAKE_COMPILER_IS_GNUCXX)
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	set(WARNING_FLAGS
 		-Wall
 		-Wextra

From e8cadd069ee1fde7f820af222764d379c76664bd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 11:53:34 +0100
Subject: [PATCH 1455/1774] Squashed commit of the following:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

commit 27e5254ecdb34ee197353230e88da718c5e9049e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 13 11:45:47 2021 +0100

    include fixes

commit eb5c56664fd3bc41fb6ea006987096150b95dec1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 21:03:09 2021 +0100

    relative include

commit af7e9194e5f2acdd5be08f3959511d93befa1477
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 21:01:55 2021 +0100

    more consistency renamings

commit 634a8f3469154c009698ccea120520b4d6d2c3a1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:59:15 2021 +0100

    renamed to pool manager for consistency

commit 0b08ac10041cd6803cf3058ddd0ef030422157ca
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:56:53 2021 +0100

    updated template config files

commit b637f033899f3b68d5d8e339811059696721504e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:54:52 2021 +0100

    updated defaultconfig

commit 59b4f50c1ca40a7485598aef2bd9b4a8313998e2
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:53:30 2021 +0100

    added FSFW verbose level

commit f9a8c3d35a625c5bfde4edb1705f5a477a19444e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:46:54 2021 +0100

    updated .mk support

commit b3e2e93f52fe2ee5743f8f3beb6467067235d556
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:46:34 2021 +0100

    cleaned up a bit

commit 20bf7b6fc4653b74431f00e4b2cc31ecf4189289
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:33:53 2021 +0100

    fixed annoying bug

commit fa636fded5f0bd1e631e276b2a75940f47994d68
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:15:15 2021 +0100

    source files for attorney

commit 0643faf0e509f3cc968305afffb6b6bef8064841
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 19:59:43 2021 +0100

    forward declaration correctness

commit 40ae81c4ff264e01911392f650297a32975ecec5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 19:58:29 2021 +0100

    unfortunate api change

    should improve include robustness

commit 71a12792a94ac3008876eade5c9c8515713483e3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 19:41:47 2021 +0100

    hopefully this fixes circular includes

commit 3242264a7714ae50ab52d6fe030de3884377edac
Merge: cafc8e4c 25a86e91
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 15:04:00 2021 +0100

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

commit cafc8e4ccbdd8ee5df48b7b7a247898b16d1cc20
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 14:08:51 2021 +0100

    updated attorneys

commit 25a86e91de099405992b9666fecf0605216907c0
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 13:23:24 2021 +0100

    fixed warning of static var

commit 7e394ea15fd199d9adcef11b779e12bb747cdcaa
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 13:18:18 2021 +0100

    replaced all fsfw:: by sif:: for printouts

commit 071ce21f09a0afd7abf10e34e003d76a6e24e02a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 13:12:44 2021 +0100

    renamed namepsace for printers

commit bb10c259096d9837c1dfe35b4d6a55c846eca0f6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 00:13:49 2021 +0100

    introduced new accessor IF

commit 0109428d470193820d5cd66bdee83db216ea9f73
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:46:40 2021 +0100

    indentation

commit fa5580cb7fb12cccaff1feac60f2eb21544e2bfa
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:45:04 2021 +0100

    indentation

commit 58d813c249842e3c627123d0584607e5f3f338a6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:33:58 2021 +0100

    minor formatting stuff

commit 0be4c35b737d08d4ba6b78d664be8bba915b5e2d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:32:36 2021 +0100

    using 100 line width now

commit 44955db341c4b732437e75bd00e134fa0c5da333
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:27:24 2021 +0100

    tab replacement

commit a8873e608c7f86ca544221b02b583e664584c803
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:25:39 2021 +0100

    cleaning up

commit 065f79615ad97b96bad42e1e588f172179c70281
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:21:21 2021 +0100

    compiling again

commit 5bc46bae02eb34a352df97ebafe9b594d799c604
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:18:42 2021 +0100

    reverted some stuff

commit 037bd83af9cd7f05680323e1ae856b73b31eb007
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 21:31:03 2021 +0100

    trying new interface

commit 0bf0d8e743de5978910726d3e73358ebe42b81f8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 20:20:39 2021 +0100

    stuff

commit 54e97f7bdc120b1aaa1c0dfc27894ebaa0c0b73e
Merge: ef9ad60b 217866c0
Author: NguSa1 <sa.nguyen@gmx.de>
Date:   Mon Jan 11 20:18:11 2021 +0100

    Merge branch 'sa/new-if' into mueller/master

commit 217866c042d92bdfe7ea8bccab4338fd22b2bfda
Author: NguSa1 <sa.nguyen@gmx.de>
Date:   Mon Jan 11 19:44:07 2021 +0100

    SubscriptIF implementation started

commit ef9ad60ba8a79be6e32f24aee9f6d2c3cb0c1d0d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 16:38:25 2021 +0100

    doc update

commit 5e251705f682642b683b1b91bae7c7a5cce9bce8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 16:33:02 2021 +0100

    getter function for object iD

commit af7def3368a7e1ed7cec29242bc265c5c17bffd3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 16:26:46 2021 +0100

    some bugfixes

commit 60102465927399d7c66d4bd1e8a379770325212b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 16:21:41 2021 +0100

    rearchitectured a little bit

commit 2d28f71eca6e57e2db9129b64f14a5df9e4fc54f
Merge: f083e83f e497c4ab
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 00:49:33 2021 +0100

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

commit e497c4ab1505f7438c96283a391f3b71de81fd8e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:34:21 2021 +0100

    added new reamde file stubs

commit c956feafd6fc5932570181cde9e51b525f20980c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:30:31 2021 +0100

    added new readme which will be filled later

commit 1f901a14ffcb8af674dfc7703b79eefb78bb5cf9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:28:13 2021 +0100

    updated osal readme

commit 368b42c7b031cbc9c4689ed41576249b51c396f2
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:26:48 2021 +0100

    formatting improvements

commit 6dde0ab8f66dc144b0323437f93e3e8d689eb41f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:25:51 2021 +0100

    readme update

commit 952438f2528aa792638348fb5cce90a36e116837
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:25:19 2021 +0100

    README

commit 7a053b6f72b50a3868019bcbc9af4f80c5f03d55
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:24:19 2021 +0100

    updated README

commit 4bfbeead0024898b1e2139ec6ed4a877e60980c3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 15:04:47 2021 +0100

    additional doc

commit 63ce87acab188be447f820c421661487fda7b5a9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 14:59:03 2021 +0100

    more indentation corrections

commit 15b65b78e730d73a840d9708658a7d0d2817a19e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 14:57:56 2021 +0100

    ndentiation

commit 6993415873b88b68e987ef7796e5f371a21fbef4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 14:54:05 2021 +0100

    more tests

commit 4fa9a1fe1934694999a031fc802119721f05bd93
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 14:33:02 2021 +0100

    added more tests

commit 69e931c07b8a6dbb7c3c0f665b33d8722cce8223
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 14:27:57 2021 +0100

    important logic fix

commit 1af28dd45737440a43cf4f8560e9d28ed3b9cd69
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 13:59:40 2021 +0100

    updated user folder for unittests

commit b570da6467fb11497e14d3d05abd20d386f68e4b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 13:58:33 2021 +0100

    more tests added

commit 918200e88c542a985e9751c1a053dfa37bc4c66e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 12:53:01 2021 +0100

    added first unit tests for hk manager

commit f8abf3527dead67938a7c03f39cf63f46ca73ff5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 11:51:33 2021 +0100

    fixed indentation

commit 13ffcfe801c61a5d4cca3ccb55d2d9300e100ffd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 9 16:20:35 2021 +0100

    prints added

commit 7129ea67bdf4c85d496a22c692a84f0f7a6ede97
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 9 16:06:54 2021 +0100

    linux fixes

commit 36bc7609c5ff94c6ab8c6cba7a30a263bed9530d
Merge: dbe326e7 57829faa
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 9 13:52:57 2021 +0100

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/fsfw/fsfw into mueller/master

commit dbe326e78743ca64888cea4506acefdbb1bf566b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 9 13:52:47 2021 +0100

    minor tweak

commit f083e83f63c89ff505262144d45a1e29edaa6635
Merge: ffb7b41f 57829faa
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 21:09:29 2021 +0100

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

commit 57829faa64f004a48510e057742c4a9fb03a3726
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 21:03:47 2021 +0100

    added cast

commit ffb7b41f0aa48a627dd5594d344841a03107dc14
Merge: b59d6d32 12091ca6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 20:56:23 2021 +0100

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

commit 12091ca6ab48df043708b2a63e0b695679f5315d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 20:55:36 2021 +0100

    enum members renamed, global vars static now

commit b59d6d3244fb584c5796dd09a4a0e164a5950be0
Merge: f64e356d 7c47b1ce
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 20:46:49 2021 +0100

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

commit 7c47b1ce345182c6a69ff2fcaf6e89d81ef8c867
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 20:44:05 2021 +0100

    100 percent test coverage for pool vector

commit 9f15cd697d154d0d464560ce2c26cedee9c87388
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 16:23:57 2021 +0100

    improved includes

commit a1c394143a1b6ba4c80abcb54302ca1020053f69
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 16:18:08 2021 +0100

    small formatting stuff

commit a9dba82661f6a88eeaa3fd1aab0948bf1919158c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 16:16:17 2021 +0100

    bugfix

commit c0fd981360dbb7d16018e9803a2a9a0f97de32f9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 16:14:11 2021 +0100

    improved DHB error handling

commit 541478e4d5f4ad029dd4fd968e10ccc6cc72068d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 15:15:02 2021 +0100

    another small improvement

commit f2ecd6d740763e55e682c5892b8ad3b0df74e627
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 15:10:33 2021 +0100

    revamed and imroved error handling

commit 5a8647d36701b9eda4d6b6a29f2d83dd9b5eeeab
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 13:40:13 2021 +0100

    better returnvalues etc.

commit 3b39c6b6e26fd523b732b14bf00c4c5933cf0ea3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 02:07:37 2021 +0100

    defaultcfg update

commit 2ef3e0aa7b502b5ac1d40057a4fdc9b324af9fcb
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 02:06:27 2021 +0100

    added option to add CR for printf support

commit 4255176b5c499d3be11947f8b77d9bbcc21bb12c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 01:49:00 2021 +0100

    more tests, minor bugfix

commit 41d8cbda5597c61aac6c965cc14f4fe571fe3263
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 00:22:04 2021 +0100

    small form changes

commit 8e3f4c81a5d0db9709052012e71824ca019938b9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 00:20:39 2021 +0100

    pool entry doc correction

commit c1c331e29ef4501d923830cc38a3179d7d7b6332
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 00:10:10 2021 +0100

    fixed vector test

commit d3405ee34063eca17a529dcf521ff860d91e5b50
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 7 20:30:52 2021 +0100

    whitespace

commit d3fbe4a3b96184b1f1620041fd7f433cf902b56e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 7 20:29:38 2021 +0100

    local pool variable error handling improved

commit 44a5430555766db0d6bae8a1dca7221c122c80a9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 7 20:28:03 2021 +0100

    pool vector improvements

commit 3be51762cccb8964ab3d19e379f1d427a99710b7
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 7 20:23:23 2021 +0100

    improved error handling significantly

commit 007526c0502d7db92d37dcdc080bf4c08c5f9030
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 7 19:10:07 2021 +0100

    new f unctions for read error reporting, bugfix

commit 8aaf45049faa4677208d3486ce4e6c2946416ee2
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 21:49:40 2021 +0100

    major bugfix in rtems osal

commit fcb33201a4c40ae868d82fcff1060fc6fdf2c342
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 21:45:35 2021 +0100

    fixed linux osal

commit 2b287dfc3ac227af78f68a003948b92656cd4005
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 21:33:54 2021 +0100

    freertos and pool read helper fix

commit dacdfc62d3841a89be5aa4988e35784737027dd1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 21:14:23 2021 +0100

    a lot of bugfixes and important api change

commit 91cf5f176400a12c18e66ef53bf7efe1fab9265f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 19:49:58 2021 +0100

    added way to completely disable printouts

commit db7d28f8526c7a6998f712b5ed4f904f757f011a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 19:32:33 2021 +0100

    test update

commit 8807772d134c04dc495627ebeef7d4f45cb31057
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 19:16:41 2021 +0100

    100 % line coverage reached

commit dc8dd770e7e9500da1ce5813a954ea5c8111ca8f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 19:07:35 2021 +0100

    added more tests

commit 16458f6a1e42fa75c4ca0155f22117bd0acf2b0b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 18:20:38 2021 +0100

    continued tests

commit bd93392b59b3904ef450a61d0005196d896af948
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 16:26:08 2021 +0100

    local pool variabel tweaks and fixes

commit b241ef6aad5861dc570548fd17bdf856e3332984
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 5 22:51:49 2021 +0100

    continued tests

commit a05cf8d4ab54066f6cc9f6450f80f98577fad1af
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 5 22:46:17 2021 +0100

    updated tests

commit 85764ba94c3f4edf1cbabc260cb94dd916b2d72f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 5 17:30:15 2021 +0100

    added include

commit fbb063cedad666c48947f014b70e6a9ffb393a63
Merge: 8e3aef5d 3c041388
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 5 16:44:52 2021 +0100

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/fsfw/fsfw into mueller/master

commit 3c041388d6705bccda5790ceeb5545ed9e48613d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 4 15:31:06 2021 +0100

    bugfix

commit cca5689a18425627559308e87dfde34f22cc28d0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 4 15:17:11 2021 +0100

    clock improvements for rtems

commit 8e3aef5df05669d686d1ec0a6a899e3c6a369d7a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 4 00:21:44 2021 +0100

    adding new tests for local pool variable

commit 49c6cd947300bef7db1622a547af7ce5fdf7980b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 3 23:27:49 2021 +0100

    added local pool owner base

commit e9a8313df7e5f4ae8f5afb732ef461bd348fcbb5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 3 23:18:10 2021 +0100

    repaired unit tests

commit e9da8e79f32fc2dfc34b779aa069c0c1faae339a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 3 22:00:40 2021 +0100

    updated testcfg

commit f64e356de398cf20d467110f9d1078efcaefbec5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 3 16:42:29 2021 +0100

    small include fix

commit fd44fb4781a291c284f82cb879d1b35aac1ad4cb
Merge: 3486a047 c94a396f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 3 16:00:09 2021 +0100

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

commit 3486a04741a1705d67f450c312e099935973552d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Dec 25 00:37:24 2020 +0100

    renaming for name shadowing

commit ccbbef777808757c8f74d1070b663adfbbd0b21b
Merge: 208ad7d4 52d9a55d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 17:54:10 2020 +0100

    Merge branch 'development' into mueller/master

commit 208ad7d479d983f77629ee6b86ca19c24d2ed95b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:24:52 2020 +0100

    fixed timeslot task doc

commit e55df691ff1d121e5b72dbefd0493aee737ef55e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:24:15 2020 +0100

    upstream subsystem taken over

commit 27d03dc17f6bb14a03f85f5c69f21eed485b52ed
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:21:17 2020 +0100

    upstream cmakelists f iles taken over

commit f905a753e2b7517bdeff19fc9bbaf9435df9f807
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:20:24 2020 +0100

    upstream unittest folder adapted

commit 41dc9ce6c6942ef92722d9a6c82dde8efa954a88
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:19:30 2020 +0100

    cmake lists form upstream taken over

commit 707bb9dd5d3fe500d511c30f95f7bed596dd9e66
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:18:50 2020 +0100

    serviceinterface taken over

commit 2e1ad41da76ea50847a9fa9756e1751d503ae85c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:18:12 2020 +0100

    power and pus upstream taken over

commit f6e7e232f58ce9119265ac9be8c6cf596b3af76d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:17:15 2020 +0100

    parameter upstream taken over

commit c174c9ecb82fd18a796cdaf41706b44982e3ba79
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:15:18 2020 +0100

    osal taken over

commit e052a9694ffa14cda100ce39a3c106b23dbc79f3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:10:13 2020 +0100

    upstream stuff

commit c603bcc91c528f1d2c76c2af8132e26873c9f7c1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:08:24 2020 +0100

    some upstream stuff taken over

commit f21f43754bd02535d4f3e31fd70779617e701178
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:06:46 2020 +0100

    taken over upstream defaultcfg

commit 7b98b0d5dd01806048753f6f6992402d84632654
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:04:39 2020 +0100

    txt is md now

commit df7a2322bfa34504049238a0c299cc1aa2eccac4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:03:56 2020 +0100

    timemanager update

commit 8f88032110f8be06e7eb653fa39e95335f7a7104
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:00:30 2020 +0100

    taken over upstream .mk file

commit a73cd37e52119057da75030643b41389c16c4ce2
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 15:59:46 2020 +0100

    taken over changelog

commit 75a0df4cd97fd14bd5bb99475dcbaf14fbc4dda8
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 15:59:28 2020 +0100

    tm storage update

commit 7ba660a222a3c0cdb1276942557ba27891783138
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 14:18:48 2020 +0100

    removed comment

commit 947dfd69e97f894287d758eb929cdf9caa1b1f23
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 14:16:33 2020 +0100

    service types.h delted

commit 362578e982e5754911ae93e3edc90420f207d813
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 14:12:35 2020 +0100

    transition delay abstract

commit 88967529277732fca91a74696a06d63dd43cd3fa
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:22:10 2020 +0100

    updated readme

commit 632f319a2f181207ad3309c109ff790e919e4abd
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:19:00 2020 +0100

    updated readme

commit 95a8dd418c487c3b0ab2a76d1e85ff3221a23a22
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:29:58 2020 +0100

    added cmake lists

commit ee05a34c9ead0bd79b0209afcf8ba9f070db758a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:27:47 2020 +0100

    added gitmodules

commit 5e8aff0603c6507b6f417ecb882446b25b9b54f7
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:25:00 2020 +0100

    unittest update

commit e41aba719c93fe25cf97d8cccee5cb2a01a3530f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:20:17 2020 +0100

    updated testcfg

commit b97b67d56e362ef1a329cb0f118653b9f5cc5ea0
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:19:07 2020 +0100

    updating unittest folder

commit 770336fff3de55194b4b0e6fc3f9f582f2ed3ef9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:06:35 2020 +0100

    added ipc cmakelists

commit 81201d6fb73393ce83b725b6a86c09bdc3586c2a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 00:39:51 2020 +0100

    typo

commit 38983407fd8973c48f4c23c02f3e8d7c34eb20da
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 00:22:35 2020 +0100

    added default implementation for setNormalDatapool

    entries invalid

commit 6abc56009405b64e7536f919f025f4f443df8b6a
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 00:55:47 2020 +0100

    feed back include improvements

commit 8dd9d6ad9195b7adbf54cb69a78bbee15fd3ed78
Merge: c2619bf0 17a12b78
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 23:39:34 2020 +0100

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit c2619bf07052faa2d36ec9e09468b2843aa1dac4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 23:39:24 2020 +0100

    transition delay not 0 anymore

commit 17a12b78073c98eb0abdce9f7c46df9c18e46fac
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 14:05:44 2020 +0100

    clock update

commit a6e38afb98317abb7d0c592fe7be9edee1cbb356
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 14:04:04 2020 +0100

    buffer more explicit eof()

commit 30c9209c7488ac4bc69c1ee0bcd6424009d39c07
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 14:03:19 2020 +0100

    better win udp polling task error handling

commit e511dc61b48b12d944302a781326ad79811dfd8b
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 14:02:41 2020 +0100

    upstream osal endiness adapted

commit de61d0c3ac331e179d0839284f1b537acf56f825
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 14:02:13 2020 +0100

    upstream timeval op

commit ca2571464680d6fbef9e011c61fbcabe9b178e84
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 14:01:48 2020 +0100

    upstream coordinates taken over

commit 60d69c95c497945fbb7650dca21655fbfd9649f5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 17 17:10:27 2020 +0100

    address in use handling for socket

commit f8b34bcb5305b946380d2e401c8c57976ad07aae
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 16 13:53:36 2020 +0100

    some readme improvements

commit 8706d663d5121b56277a1f17ca40384087e20189
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 22:57:14 2020 +0100

    upstream changes taken over

commit f99bf6d75c51d84d49f8bbc3ca6d2c736cac06fd
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 22:51:30 2020 +0100

    taken over cmake list for storagemanager

commit 1f7938f610ca08e35add7264036104d2ecc0280f
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 22:46:55 2020 +0100

    deleted archive folder

commit 910e6817ef94b6692cde80be3bb3c759a22ff93c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 15:48:06 2020 +0100

    default cfg update

commit 48aef068379cfd9cbb43f2a23481c7853b219b0a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 15:24:46 2020 +0100

    fsfwconfig update

commit ca52255d300047093bf1939dfafec621b47eec7b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 15:20:32 2020 +0100

    update

commit 3e41b202a105603c7f4eb2a9bf3dc7fbb96b72ac
Merge: 052e2ed1 0c3e87f1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 14:41:07 2020 +0100

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit 052e2ed1e82128356c3cf8260d4d874d47ea53b6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 14:40:49 2020 +0100

    type update, assert that type is not boolean

commit 0c3e87f1deee38f1ee30acf8090c86377ebcb840
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 23:55:54 2020 +0100

    using new xTaskDelayUntil

commit b8f4d8690bec206be73a4e819ae71685177ae3e9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 23:38:06 2020 +0100

    determination of freeRTOS features from version

commit 9170f466e8ccaf74da9bd97d260fd846fcb6551a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 23:21:07 2020 +0100

    freeRTOS version checks

commit 95b2191824f8ca051021801cf84aa9b440a45d37
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 22:55:12 2020 +0100

    long name

commit 3ee25785a2cefa7eca6d33bba49e046df75a18e1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:54:03 2020 +0100

    linux changes adapted

commit f2ba653833924f073a44974fd6e902ce6f5d1815
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:47:42 2020 +0100

    ipc changes taken over

commit db42e79fd4eb299c960a3da50ef629098f9bb409
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:38:45 2020 +0100

    taken over cmakelists file

commit 1c79da0e75309662bdfe5b94c4a71c93c1825492
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:34:29 2020 +0100

    tc distrib changed  taken over

commit 796f0e2e17152a40d6f58c9c592b9c74fc573148
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:33:19 2020 +0100

    important changes adapted

commit 8c88255873283ea51cbe02f6bf9c3c36900e567c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:31:50 2020 +0100

    taken over some tweaks

commit d2f631a955bfd439ac04fcf3d75327e5171a3ca0
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:20:21 2020 +0100

    cast added

commit f604d621e8958ebe906f0cc0bf3c77fad775cd41
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:19:12 2020 +0100

    removed interrupt class

commit 6911f91744ff1b1022adca763bf8b42c208cff97
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:15:41 2020 +0100

    rtems fixes taken over

commit c1a156dde3956be55c96469c98e204d27bb3a0c9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:08:35 2020 +0100

    catch factory in objects folder again

commit 050770c184a8a965a856df53aea37ad75f0962ff
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:07:58 2020 +0100

    catch factory fixes

commit 14a0573f3d99025347a40bea9df2633b188d80ea
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 20:58:20 2020 +0100

    one define now

commit b14c1c43ccbd97fe774a2a2b9f812487b14afcd3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 20:50:56 2020 +0100

    small fix

commit 2100ae34f2c69d9a982e1d52d2f8068558daff9b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 20:49:17 2020 +0100

    event folder taken over

commit a0e7584e841f3d9a2469ef091fae79fc55560c7c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 20:19:23 2020 +0100

    tiny tweak

commit a547fafa33576ce33423536f28d1fa1333a6423a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:49:01 2020 +0100

    minor tweaks

commit 3dd86039bb01448c57425f1b9d6f9c4135de3622
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:43:32 2020 +0100

    changes taken over

commit d3239b90644126af99b12dd029d2c19690d2e775
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:41:40 2020 +0100

    tiny format stuff

commit 89de4cc321e32ce94d458d72d76c14999cfd6437
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:40:26 2020 +0100

    changes and tweaks taken over

commit 5c6916a07848a8aed3c7ec2fbc8fded1f37f2a08
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:23:23 2020 +0100

    small tweaks

commit 620c9c6ae15008631d506aa57181a11ff5130e52
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:19:05 2020 +0100

    taken over freeRTOS changes

commit 073cd4f5e1ebbf1bcc09a3c71ae8da16b6e4ddad
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:09:53 2020 +0100

    small tweaks

commit 7ace117c42832ad65d657b2d203f5371fb3ad2a7
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:06:09 2020 +0100

    added cmakelistst

commit 0ccd266f51f8238f3489b192ec36496c90fc24fe
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 10:49:00 2020 +0100

    internal unittests fixed

commit f161a94113c6c95ce7014a2cf9597817d8f4c0b1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 10:44:48 2020 +0100

    taken over upstream fixes

commit 692aa087d8d4dfb3c02cb7bf61b93ea47e1ba8df
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 22:13:22 2020 +0100

    taken over cleaned up branch

commit 3f77fab2d9ada5b029cf823674adaa5e5ea7d403
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 22:01:38 2020 +0100

    taken over cmake lists

commit 7c390c07eed79ee02fa23266ece8d0218672923e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:58:54 2020 +0100

    taken over unnittest folder from upstream

commit 0b056720bae878adf65bcb1fa6cf01f98ccdd6a4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:57:06 2020 +0100

    taken over master

commit d944e25d4a3b037f82981fad278de5fb9e367086
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:54:46 2020 +0100

    taken over upstream changes

commit f69113b4d516b12a2a9fc7624f17ab311e6f91fb
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:53:37 2020 +0100

    taken over upstream change in ipc

commit 0e42ba062dd9b217e1f89eb62f30295d4e31beb4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:51:46 2020 +0100

    notice taken over

commit 62e16b13d343ad134fb308f56b185243515fa215
Merge: b7dbdb07 b2d01a31
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:51:09 2020 +0100

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit b7dbdb072d46d72e8b8730c9edad97c710f4d3ad
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:50:33 2020 +0100

    taken over upstream changes

commit b2d01a31c224cf609ed2cc83e5e482604881a64d
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Thu Dec 10 16:58:18 2020 +0100

    removed some commented stuff

commit 5bad1142059af8a946fe57c0cad31284fd8496ea
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Thu Dec 10 16:39:31 2020 +0100

    thermal module set heating repaired

commit 9a540e97c557e58a8b7b933c6f41fde21e8fa315
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Thu Dec 10 16:36:44 2020 +0100

    taken over thermal module from thermal-update

commit df333e0cc828afaacc7b591527ea724b342025b5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 8 16:01:23 2020 +0100

    tab replacement

commit e9a740f110c61cff3c836afecfdb1f635ba533f5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 8 16:00:02 2020 +0100

    small tweak

commit beab942f07458c709cb39d8b4976fd1462438fd6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 8 15:57:30 2020 +0100

    fixes taken over from master

commit 322dd1253e222ecfc81f40c671864d75d2e0334a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 8 15:15:22 2020 +0100

    map packet extract update

commit d9cccdedf30b8ad95b87799dba5b426b66494f56
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 8 14:34:56 2020 +0100

    event update

commit 89e80beb62f8f52625a92b397cb2d4b16429c12b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Dec 5 17:10:36 2020 +0100

    task if set now

commit 248ceebf81e824f337edbb15fa774fb3596289b5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Dec 5 17:09:49 2020 +0100

    taken over host osal from upstream branch

commit c5c776e676a6b7c39e9bc8d4535ab9cba836d977
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 3 18:57:50 2020 +0100

    rtems changes taken over from upstream

commit b7a29235f876fa60d783654ebfb449799451948d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 3 13:28:56 2020 +0100

    deleted memory proxy file

commit 6d915b7dcf76c76672b07483936b9c9fcbbbb047
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 2 23:26:40 2020 +0100

    doc formatting

commit 21c3db4ffc7c95b31f323bbdd825a869389dafde
Merge: 586e8b03 4d76bf24
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 2 23:22:40 2020 +0100

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit 586e8b034780fcd107cdd8ae06cd0fbffe5947b3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 2 23:22:28 2020 +0100

    function more robust now

commit f4ed0ce502b696cc6acf9eac3d20f0d9db6975d3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 2 23:18:48 2020 +0100

    doc format improvements

commit 5e77058add5f51504b4bfab4afe18debf8d8a9df
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 2 23:15:30 2020 +0100

    added getter function for pending command

commit 4d76bf24b581aaeba5c2e276f4d09c90c806215e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 19:16:19 2020 +0100

    fsfw compiles without datapoolglob folder

commit e3de5ce7774b8571865ff6755056527912f0e7c2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 19:12:40 2020 +0100

    device handler changes complete

commit 74b2830d9b2c612bff9467f063617028cbf309a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 18:55:53 2020 +0100

    using new device handler thermal set

commit fff928a191eced806e6f8aa9fa2e58d2c26b3565
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 18:29:00 2020 +0100

    bugfixes and improvements

commit 3fb3039be530acdc21f41ca09dc7fc9d276827dc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 18:16:26 2020 +0100

    minus 1 replacement

commit 0116bb86635d9480f74b87e83a267d66e6f904e0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 18:15:09 2020 +0100

    replacing global pool with local pool DHB

commit 84ab5f83189481909f23dc7016082f51010fdfa0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 17:19:26 2020 +0100

    readme and logo update

commit 314dc577b547f734ef32b0552d109a9b5f88e7b4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 17:19:00 2020 +0100

    added changelog from upstream

commit e0f063f232f92931f17d874de122d9c30c795d73
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 17:14:44 2020 +0100

    comment added

commit e323c69f20da5b2321fbecd5ef2ab84dc1b2060d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 13:36:30 2020 +0100

    better name for preproc define

commit f357de21c9b37a5ca384590be0d511c0c503aa16
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 13:23:51 2020 +0100

    updated testcfg

commit ef2e07b3891a3c2a2429d973d5db68208db7e526
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 17:03:14 2020 +0100

    added explicit type conversion operator

commit d1beb96c6030c82bf20d65eea0196cb4d904c8a2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 16:30:20 2020 +0100

    some more replacements

commit f108ae883c1a19eaa74f1c67cd4278815c98538a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 16:28:16 2020 +0100

    local pool replacement

commit f581b37fcf51415fe9f24ff22bb61aaf367739f8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 16:25:09 2020 +0100

    thermal module replacements

commit 4bb9dd816ec910870cd8183951efbdae9cb74d0d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 16:06:59 2020 +0100

    compiling again

commit f70ee7696a82f96268d5cc06b6182a6c30780515
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 15:30:56 2020 +0100

    it compiles again

commit e7a96d5ad8dd7169818e624943bcf15b651c0af1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 14:13:52 2020 +0100

    it doesnt work? comment it !

commit 25f08b8c1f8143bbcabfab7f40541351eb2adc50
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 13:59:54 2020 +0100

    started replacing local pool vars

commit b7945dfe606e2b2edd1a618aa089f893876ed75c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 13:45:08 2020 +0100

    added gp_id_t

commit fa4597782ec20090f45d390c9cee6542561de7f6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 13:09:56 2020 +0100

    some improvements taken over from master

commit f0ca4be71eec5e3883d270e98b5b53ceab4fe1e2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 13:09:03 2020 +0100

    fsfw version include removed

commit 952978f999936c515de731e796f95076373c5528
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Nov 29 13:04:38 2020 +0100

    moved perform hk op call

commit 279df93cdf84eb99b3d1609b97c422be6e07d512
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Nov 29 13:01:37 2020 +0100

    form and doc comments

commit b7fb1b42e660795325c66f7fcf5e1a9d2388bb12
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Nov 29 12:43:19 2020 +0100

    added new cfg option

commit 03fad1cfcd91fad4456188ff18b2bee0d1e0de03
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Nov 19 00:10:59 2020 +0100

    better naming.. hopefully..

commit 0d79d4ab030c3b40cf53203a74ff7d7425b24ade
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Nov 18 21:15:48 2020 +0100

    replaced spaces with tab

commit cb5fa4a2175bc684e21fb885c94a420b97e680a8
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Nov 18 21:15:14 2020 +0100

    monitoring changes

commit 434709ca9693a68a27b1595d9a86c9472f52a610
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 10 11:16:56 2020 +0100

    parameter small stuff

commit 72f7a1b1b786d97624632d8291a7fb2eaeb26882
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 9 21:24:23 2020 +0100

    translation files removed

commit 225e65628db70873cc6267cef55e915f65088ad8
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 9 00:12:39 2020 +0100

    include corrections

commit 319ae724785807329a8bf9304e3228604a64fbe9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Nov 8 15:29:06 2020 +0100

    folder config renamed to fsfwconfig

commit aa45d34b4a682c1240f5c4ad8d86bff99f858bae
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Nov 8 15:20:51 2020 +0100

    include improvements /factory improvement

commit 1b2af5285d6269b482f8717902fc811d5781f99e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Nov 5 13:12:42 2020 +0100

    message queue depth configurable

commit 8d109b7cd0a4955a1289a54cd7d6e9e148ae6650
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Nov 5 11:57:05 2020 +0100

    preproc define correction

commit 5efbc7496a57ff5549ca381dad521b277c0798ed
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 23:39:56 2020 +0100

    doc improved, some functions virtual now

commit cf7385d64ec3f541d69b7fe23ad38ec8b6b0e9bf
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 23:32:34 2020 +0100

    include fixes

commit e99cf32bddf33f7c44c14a355ae2c167f2a8a78e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 23:29:03 2020 +0100

    amazing size checks

commit f72ee0b7acb70dc0e91f7a50884a491ece57a334
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 23:26:28 2020 +0100

    small bugfix

commit 65aecc356590778da5f66939d8bfe0c10226f8bb
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 23:23:05 2020 +0100

    IT IS DONE

commit e9aecdac26b83e8548ca03b04ff4d1660e33de78
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 22:58:09 2020 +0100

    sth with eclipse indentiation

commit d87f78f5c3576d4d3f27f206690047c1783da1b5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 22:25:14 2020 +0100

    timer stamper in fsfw now

commit c69681b402ea3523cc16cb45799715045d14b13a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 22:22:26 2020 +0100

    time stamper

commit 5908f99f0b352ef41db992708888c6c2e64bcde8
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 17:09:33 2020 +0100

    size t changes

commit 30947d3901ef412f860b4758e66e9c77cd79afdb
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 17:08:40 2020 +0100

    size_t changes

commit d424d85f6d0699a7f9da63f28e973a2855873243
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 17:07:48 2020 +0100

    sizet changes and indentation

commit 695b161934052c7d18f1db7dbb04c71e66e6f3de
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 16:54:56 2020 +0100

    some bugfixes

commit 9e97357b8caa13883e59ed16d5fd60362697a55b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 16:46:43 2020 +0100

    taken over changes from master

commit f69f9bb31e505537a1093ed2c5af26d672e03b19
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 16:31:25 2020 +0100

    comments removed

commit 81f5783d371bdf3b3521d8c37a59592bf7d45b79
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 16:06:30 2020 +0100

    clock update, definitions file

commit dcf36d4ceebc8c70f4d17f14fd1cdf78fa4969ea
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 15:54:27 2020 +0100

    cstdint include added

commit 83f0b4bffc25dd4f8619220401a0f5ed2f1c1e15
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 15:51:56 2020 +0100

    defaultcfg changes taken over

commit 633203eb5406adbf3d4f48e1cbcc6397352fe19d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 15:50:55 2020 +0100

    upstream time stamper taken over

commit 38b5695a1008af28ecd783b437770b08775bd2ab
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 15:45:04 2020 +0100

    size check + include guard

commit b71ccf8dd8274b6dc00dcec74e412bad25c812cd
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 15:28:55 2020 +0100

    some refactoring

commit cd71a9cc12fc799905f781a0e2453e28590bffe7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 2 15:53:08 2020 +0100

    fsfw container taken over

commit 41bf5622f313c205a931d5bc439b4302ccdc0af9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 2 15:50:14 2020 +0100

    master taken over

commit aed7f31f24cfd2a0b83117de8925a250c16e2917
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 2 15:47:09 2020 +0100

    health changes taken over

commit e0a11f3a6edb5a3493e9bc5214a655caf2eea208
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 17:46:44 2020 +0100

    include guard update

commit 6edc2ef1d67f074b57d252ca67650646ae50b202
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 17:42:05 2020 +0100

    class IDs moved

commit 641da2aa2184edeab2b3f282615c8ac27b6eae4b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 17:33:22 2020 +0100

    config make update

commit 777457482b8ea3bb5c78e9b86c5c4e06ed1d08ee
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 17:21:51 2020 +0100

    fixes for internal unittest

commit 3fc206801153370773adbabd7b9260b8b13d1c23
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 17:09:16 2020 +0100

    fsfwconfig update

commit 0919d2c53231934748bcb581915993ed670f2e87
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 16:52:06 2020 +0100

    updates taken over

commit 3d2778fdf79eeb315ace8944fd8b555b35d550d3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 16:45:47 2020 +0100

    doc update

commit 42e611899befd5992d639ab3a46b08f7c5785069
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 16:43:03 2020 +0100

    added timestamp size

commit fb12045f23151e60c30359ee00c09bcef2b0b700
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 15:25:03 2020 +0100

    changes from master taken over

commit 4b2af9eaa6ce2c418cfb280d633772d870f0dc86
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 15:15:08 2020 +0100

    static keyword removed

commit 172fbd7e4840bcc2001fcf425684a552f2488ad1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 15:13:03 2020 +0100

    some changes taken over

commit 7970043cb5a138afe4259b9442034c501b327380
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 15:12:36 2020 +0100

    deleted some sutff

commit 176ca56e355405d4e9d81e503187e2f87d87f84f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 15:12:05 2020 +0100

    core changes taken over

commit 565fd63d0855e10fc29e46a7ab0f31a45e253ba8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 12:07:48 2020 +0100

    makefile moved

commit 29187fbc4badd33e7533c53b2aaa8032b73353e0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 11:59:50 2020 +0100

    some config adaptions

commit a38c3e5005eb96ea7dd3be1e50896f9e1fd5329f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 11:47:03 2020 +0100

    config folder renamed

commit a9b48749048c128e128ee77c4fc59e0deb68d871
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 22:49:19 2020 +0100

    new defines added

commit b860d8bce788c3f530282721d63fea3995e7a376
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 22:34:41 2020 +0100

    include fixes

commit 6325eb764717af8470715cb34934c2e7e0953f0d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 22:11:13 2020 +0100

    include fixes

commit 24cb83498ae4c8a50db33ce6f235913fbe2695bc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 21:28:59 2020 +0100

    include fix

commit 82ccd146927f80e154e430ab5ce13b966a596263
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 21:25:11 2020 +0100

    added new tests

commit ea04e7d4d644c7c50faf862902fceafb8490d994
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 21:13:00 2020 +0100

    removed catch2

commit 3244487eaec76a8cf014d35df062daacc24edf41
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 20:18:58 2020 +0100

    slight improvements

commit dcb24360d85b94a8124e697c3b5640c8dc220dd1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 20:17:50 2020 +0100

    form improvements taken over

commit d1a399a1a8c55a83a932cd326fea87141ddf9d44
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 19:46:27 2020 +0100

    tm packet store update

commit 90bdb844e703951ef783f0a025799efefcf6fc98
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 19:27:00 2020 +0100

    taken over some changes

commit e7210a34f95cfa2ef4a980c18e37629f54aa0bd6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 22 14:34:52 2020 +0200

    output tweaked

commit 742cc6eb7660adbff54e498b29afe73bfca4bbdd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 21 18:19:51 2020 +0200

    no command added

commit b9f3c1ee84e331e0c5d52f88c313643d43dbf3c4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 20 17:53:47 2020 +0200

    takne over defaultcfg

commit 057f3b859e9857d7139be783c9fb89987fc8fa15
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 20 17:39:48 2020 +0200

    added readme and efaultcfg

commit 9309562716da79a49e9d04a4f9081eb730216581
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 20 17:24:53 2020 +0200

    defaultcfg folder added

commit bb53c71f70132beae2dcf7f39201df769be697d8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 20 17:21:20 2020 +0200

    fsfs config update

commit 7033328962e8997e1757b5ca0999a89a9d04c7fc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 20 17:12:56 2020 +0200

    unittest folder added

commit 95924dd55bf9d6f1f8231fd16b8b3a54871caf32
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 19 15:38:22 2020 +0200

    some more bugfixes

commit 22e4e464c79fe2924c3a2a88948b0b17c31dab9a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 19 00:43:10 2020 +0200

    doc improved, new returnvalue

commit 75e67ce5f8e1383796de2c0c9f7754456d011625
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 19 00:37:26 2020 +0200

    small form improvements

commit ad9ac7537e150150679a4104b915836f8cc0f248
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 19 00:25:03 2020 +0200

    bool is mapped to uint8 now for pod type conversion

commit 8b8324f21c1b0d30ba1c5ef7919846bfeb283e62
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 18 23:50:02 2020 +0200

    some stuff renamed

commit 1bddfeb86bf42a9dfd5fdf9ecdddc7522058469a
Merge: 88a89d67 6baa8596
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 18 22:41:37 2020 +0200

    Merge branch 'mueller/LocalPoolTests' into mueller/master

commit 88a89d6797a22c108d2841a1f7c835edf55afcec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 18 17:32:10 2020 +0200

    added basic documentation

commit 8e498060571c89c06574f1a9aec381fb3290f886
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 18 17:23:47 2020 +0200

    some adaptions

commit 3b0b474ab6e5586cd81c4950d9af1b61f7c07518
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 18 17:01:49 2020 +0200

    better naming

commit 02b7c51318f096447703d6845365aa568d280e03
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 18 16:54:55 2020 +0200

    HasParametersIF less confusing

commit 9a70f75a4bf043292f213b4791364a8183267fef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Oct 16 01:45:07 2020 +0200

    returnvalues added

commit 6f955ed8bad01074039de13e54b7534b248706c0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Oct 16 00:42:49 2020 +0200

    another bugfix

commit 91cf33127a1a869a7a0b959f609dea09ec735e57
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Oct 16 00:41:50 2020 +0200

    bugfix

commit 6baa859628857c5ac0acbb115095eeac667c652f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 13:42:35 2020 +0200

    fsfw config removed for now

commit ba02becfc9fa228ab156efeb1c39e7a15cae73ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 13:38:41 2020 +0200

    deleted old files

commit b6ae82ec2ceb33936f25a2f4c5b5a9ec483fe810
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 13:21:46 2020 +0200

    bugfixes

commit 6e5f029a641ba7c77f85ea9e1d1f1a58d1a58b9a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 12:47:21 2020 +0200

    type usage improved, getFillCoutn implemented

commit 48ff5dea0831610897c9aec52bea2734c68f0720
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 01:57:30 2020 +0200

    line break added

commit 56dc06e0ed1a0c0956793409aec24e5821385c42
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 01:51:12 2020 +0200

    some little formatting stuff

commit e5000abbb786f01a8664012fe52059ade71c0e61
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 01:31:11 2020 +0200

    custom cmp operator

commit 364bce90ddc44aa7e71852c458c6eff5c7aefc93
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 01:07:20 2020 +0200

    small fixes

commit 1ee01ffcdb3a8e65a6f6e227aada9a109ec8680b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 00:54:00 2020 +0200

    important bugfixes

commit 64bed475fe8976c7d84a82540b2b7e0dfa915561
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 00:43:23 2020 +0200

    important bugfix

commit d1498366122e861703ee808fdf10eae4560d802b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 00:34:20 2020 +0200

    better  form

commit bdfea9ea38331a5c36f72100834d0fb524100b4b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 23:53:50 2020 +0200

    includes reordered

commit b3e5946291a7c6a5365c79b68e3ea52aa3aca497
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 23:42:49 2020 +0200

    implementation added

commit 57c9775d7d9863072aa9d06e782c10184185bce3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 23:41:16 2020 +0200

    add fill count func added

commit 7bd536e76395a38a3a0cdecba436b7efccdc596e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 23:20:53 2020 +0200

    new templateless pool prototype

commit ab603abada422d906a6cedb9d204ca2fe5e200ad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 20:05:39 2020 +0200

    subscription mechanism almost complete

commit a9a31308ae40618e49db5c6e98f131bfdebddcb7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 19:52:06 2020 +0200

    update notifications working

commit 5b96161331519c43d9ea8903d0ad7d7029d8f410
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 16:46:00 2020 +0200

    optimization and printout improvements

commit 088bc35301dc87ebb7b4d30e789deda7264b973e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 12:42:30 2020 +0200

    update handler continued

commit 45c0acec5f4744862a411c3b1852d6a7785f6b3c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 01:38:27 2020 +0200

    its all falling into places

commit 9ca086e0269c5a09bea5dc992c9050fcd24e0dad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 01:25:15 2020 +0200

    base class extraction complete

commit 72ca2bfa43e56a98a7462f9a372fe290c7e67e5e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 00:50:24 2020 +0200

    added new messages

commit 9917f7126d53f6e6387c1c46a779560b34735699
Merge: 3af79e57 d22c6a5f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 18:19:28 2020 +0200

    Merge branch 'mueller/DHB_separating_steps' into mueller/master

commit 3af79e572ef34c8508b9d6f6315893952cfacda5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 18:19:11 2020 +0200

    default msg size for health device

commit afe5a627895f40bb05d314aaa98eb9ee898424ca
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 18:12:26 2020 +0200

    imrpoved form, removed comm msg for now

commit d22c6a5fe929d9c0c7dcfb584bcb7cf1879b3ec2
Merge: dbb394f7 736ce2d5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 17:44:58 2020 +0200

    Merge branch 'mueller/master' into mueller/DHB_separating_steps

commit 736ce2d5fd199ed5c18eb2d59718ce4faa3b5cff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 17:42:30 2020 +0200

    some more form improvements

commit 06c7919daa1f30e93452d2fe284d7ff0ccae4a41
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 17:39:13 2020 +0200

    monitoring form improvements

commit e4c74ec060df2beb86eb34f1b2a9a8b1193adbd8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 16:57:37 2020 +0200

    added todos

commit 8c689751b4238589902b796a36e4aa484c46feee
Merge: b9ebd153 18671a0d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 16:55:57 2020 +0200

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit b9ebd153a2d6e897b76c41d09f2f2f8d40c1d517
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 16:55:40 2020 +0200

    added action helper function

commit 18671a0db7357a0e209cc547d64271f84f8893af
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 13:40:24 2020 +0200

    doc wrong

commit ed71a3700435aa8532abd2764ddfa9d5be882235
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 20:11:20 2020 +0200

    get command queue override

commit 3e79d2e73ad239b5f1c4838178f35348ac5ca6b8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 20:04:01 2020 +0200

    added extended controller base

commit 670e9bfa0f4fa55fddfd3cbcd7669987e65aa3f5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 18:12:22 2020 +0200

    CMD/REPLY prefixes added

commit b9c7d1bd3f77f8d2da1e7376ef55df99ea26ec92
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 18:09:04 2020 +0200

    added health subservices

commit 01e7a98425f8fd09b08d8f0e8edbbe9bed695de6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 17:55:38 2020 +0200

    added announce all subservice

commit bc0402faf7c819d5b63630bc209444b3c2df89bb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 17:49:50 2020 +0200

    health update

commit 837a18135e2d643f52213ff1c1995af3d1cd9f2d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 17:41:51 2020 +0200

    subsystem folder update

commit 3aa666633e4d561847e2cf12972c2fb916d41ee8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 17:14:52 2020 +0200

    include guard replacements

commit 94884c2402e3c5077bfe5b88c3255cd554a4ad5b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 17:11:11 2020 +0200

    service 1 small improvements

commit e338b4662d8682f391cdf950ed4a47e80eaf37da
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Oct 9 02:49:18 2020 +0200

    fix for c++11 comformity

commit 2364c4f9a4d1aa551557e0d2a4b616652da8d2db
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 7 20:47:46 2020 +0200

    form improvements

commit 6e9db0d67533b8b3fa25def2b185691749c2b6f6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 7 18:43:56 2020 +0200

    retval added

commit 9fb38e9b7c168e514706b3b757e70b2d1b163c3f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 6 19:58:29 2020 +0200

    better error output

commit df1a730cdff36835424057e64f89f3817fda24bb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 6 16:01:35 2020 +0200

    some form stuff

commit 6a077c583dd2063ad9b71d9298967c78e59d967b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 6 14:00:18 2020 +0200

    action helper some formatting stuff

commit 8c43c6993eca053fdf8dc633ea049ceed6564a43
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 5 22:47:32 2020 +0200

    CSB fifo depth configurable

commit c17d50bd1e16031be3861723d68b9269c4623cbf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 5 19:46:25 2020 +0200

    file syste mmessage moved to mission code for now

commit 1431116417672389bfef1ea1a77bf832cbbe309e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 5 12:11:11 2020 +0200

    NULL exception somewhere

commit a7fe23c3004d8c933b36d3c5a23f0b8322eaa022
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 5 00:12:52 2020 +0200

    small stuff

commit f955cd9eee41ad52eb854f8fb8cca4b040dba181
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 4 23:37:22 2020 +0200

    made interface more generic

commit a8a6d448ecc601fc74cefbc7b80736985b8ca06b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 4 23:24:36 2020 +0200

    added subservices

commit 2b1029916bab936cd7553d8c93f5300abeefe495
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 4 15:55:39 2020 +0200

    using deletei nstead

commit 20c261514b672d3919c036c85702d71fe107723e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 4 14:31:06 2020 +0200

    made message interface more readable (dec instead hex)

commit 0c1c61558ba2d2c831260d4a6be51cc9b90a1ee4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 3 03:45:29 2020 +0200

    very important bugfix

commit 55a4c0423db264b8a1d16bd7bc8abb527d9a9597
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:45:28 2020 +0200

    typo

commit af038d0a2f04c30cd4bfbe6ff3811afdc2740ddc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:44:27 2020 +0200

    master taken over

commit f9e6b9facac4e9f8c4c7a261f4bccf04337c1f07
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:42:28 2020 +0200

    taken over master

commit 0b1b159582b7b3234fdb926f4a1cb4fb875ad69d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:40:45 2020 +0200

    taken over master

commit bf3276cbb2545c1773b1478569703dda9bb402d1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:40:02 2020 +0200

    taken over master

commit 148bbb4be4ef309ac023631782064140fa8d5966
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:36:43 2020 +0200

    master taken over

commit f2c07ee9c6268f255eca9f8cbb374f393cf1ef72
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:35:56 2020 +0200

    removed tests

commit 5fbb8f8ef02747e8c95c74f4301b369982a7b2f7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:35:13 2020 +0200

    taken over fixed array list from master

commit 1ecca4b3d882fcbc704f21a0ed9f32c0e2d2524e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:33:50 2020 +0200

    taken over array list

commit 0714dc6e06d7bbd30b12775d1f7f39bac189b216
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:31:30 2020 +0200

    taken over container

commit 26454356f8958bf077e8756471869dc0bb8e0af8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 13:57:34 2020 +0200

    tpp extraction

commit 315777d265a57b50aff944bc795a15a24e64ac72
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 13:21:23 2020 +0200

    tc distribution equalization

commit 32ebca48b864039cd5ee334b6f69ff6010d1d700
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 11:07:46 2020 +0200

    FIFO updates

commit 43b44c57b6754c82e3813444568b8fc275469f92
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 11:07:20 2020 +0200

    placement fact update

commit aed2d7fc9369e006cc7aa672a1cfeb7fb46e9f25
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 30 23:42:18 2020 +0200

    slight formatting

commit d44428f49c8d99de93632b20307d9ddbe4b77584
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 30 23:38:54 2020 +0200

    DH IF and DH message improved

commit d8392de058b1ecde643dabb5903f3534b68acefb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 30 20:28:33 2020 +0200

    made define more generic

commit b59a4c5de62863afd9fa3a45912a4f4e7f862b4b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 18:02:41 2020 +0200

    equalization complete

commit 3c814a5e6105390bbbee8ae7df825af45fa53df1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 18:01:55 2020 +0200

    include fixes

commit 4f3cfdcaaf57a790ae7b8cf874c76252f20ceb6d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 16:41:14 2020 +0200

    fixed map and array list implemented as non - members

commit 9013ac240ff9a9ef2f488c1e6bee22ec314b6a37
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 16:12:01 2020 +0200

    array list taken over

commit d85096d98b951890bf93d373c4a928bea822676f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 16:03:01 2020 +0200

    service 200 take over

commit e1eb1a3be17fa8b417859ff5d3231dc32cf1535f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 15:48:42 2020 +0200

    small tweaks

commit 1ea1c8c02fca9cc46536831280e3160b0c73b3f5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 15:16:20 2020 +0200

    srv9 fix

commit 207d2cab9c6345c02b93f754344e0e34fc446a5f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 15:15:29 2020 +0200

    service 1 changes taken over

commit bc23fd65a678fef98a3a7e701d6e40fdac8cf387
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 15:13:51 2020 +0200

    master taken over

commit fd87a16661290a771e18287bd88ef9df42d60cb2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 14:51:25 2020 +0200

    changes taken over

commit 485e96f12f74dc6dd891aed548b8915872dd540c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 14:49:57 2020 +0200

    merged changes

commit 224248dfa1e3ca25eaa4cd94910b8e1293679406
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 14:27:31 2020 +0200

    removed debug outpuzt for missed deadline

commit 1691d63169c7bec77954873c476f1fa530f981ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 13:54:08 2020 +0200

    include fix

commit 3663d7269ca37b8ac2a5af62e1f86557d9766462
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 13:37:21 2020 +0200

    changes taken over

commit 7b1f72254f866666d251f097b6587fc1c92f67e2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 13:30:30 2020 +0200

    object id names improved

commit 53a62257906df8ca44d3a447dd4434e3d7b889ea
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 12:50:36 2020 +0200

    doc & tweaks

commit 260fac43f73d638823c4dd1d887e2e8409c9a480
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 23:38:37 2020 +0200

    bugfix

commit 1f70b1159d39527d58cbcd2a0e85ca46c2d66695
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 23:21:21 2020 +0200

    another small bugfix

commit 7ff9c29b62cbd3738377bcb6883ac42362db4731
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 22:51:02 2020 +0200

    added another command

commit 62ee1391bf195337af99bddb151cd65fcc95504e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 22:48:10 2020 +0200

    added two new commands

commit 1d972fcbef9e935121ad5a168ec1f5f6f2c8619d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 22:46:18 2020 +0200

    hk messages are cleared properly now

commit 7e9d095ed16264786480e648465efa7d44abe8d8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 22:38:36 2020 +0200

    important bugfixes

commit e48dbb87973ccbce0fb5679b7bd0ad726c34161b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 22:17:18 2020 +0200

    small improvements

commit 786dcdf88d915c701a0266768b06e6158cdd59e9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 22:13:17 2020 +0200

    removed clock include

commit ad2ca814b2e100c7da2b3371244f28c70baa1e32
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 21:28:03 2020 +0200

    improved doc

commit bf574c12e4ea8397062d17a3e047e7de7d223437
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 21:09:56 2020 +0200

    bugfixes, owner ptr not const anymore

commit 88c4b2a5390a927d1eda33e9ac410ddc757cfc45
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 16:56:42 2020 +0200

    bugfixes for srv3

commit c12110cbf16c71394aa939e67629fc3c11370472
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 22:23:17 2020 +0200

    has file system IF retvals

commit 6eaade239579ca814bb3aaded0f858b8f7bf47d7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 17:28:03 2020 +0200

    added new mode for local datapool manager

commit c3830da3d0a1f871bfca904b240f7cedfbb2a366
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 17:24:06 2020 +0200

    bugfixes

commit 4a97596030f2dbebcdebdd00c2c524e74df00d36
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 17:21:32 2020 +0200

    internal error reporter uses new local datapool now

commit e67b1fce9a1f23d30a73d41142472adb7fb42b57
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 16:38:07 2020 +0200

    added additional include

commit 52d8c4f3a84c870e67f251be025ec27f657d2e17
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:35:10 2020 +0200

    include guard fix

commit de08bd6c8a9b8ec3f0627a028c319446d0a09bc7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:33:24 2020 +0200

    small include fix

commit 50621704073764a4673288442e54346af7bf4af2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:32:16 2020 +0200

    correct function used now

commit 55bdd2c2f5e8d656375912dc24a4d40515bca925
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:28:28 2020 +0200

    include fix

commit 6fd39dfac38da3c825f14b8171e05ef961dcb96c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:27:06 2020 +0200

    set struct reporting continued

commit 08d0e0949342c3620fb119c9d2e6dabde243e2aa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:16:13 2020 +0200

    power equalization

commit fab7eb8a5d40386237ee243cc98af78e22f5fffe
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:03:04 2020 +0200

    controller base update

commit 9aca5cb6f246d3db825bb447fa18d28468a59ec4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 14:59:40 2020 +0200

    taken over convergence changes

commit cf28c9ff9d861b7ecd30a45b172635ed1766b882
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 25 19:01:59 2020 +0200

    make event func changed

commit a65745d037a2ef26e51302d5c585620681a0f56a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 25 18:40:04 2020 +0200

    added explicit function to refresh task handle

commit 5ca1c7bca2d7a5c431488afde034dbe6625807cb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 23 19:58:51 2020 +0200

    coutndown update

commit 43ab0ba2702f482f1f5e7d39493a90e66bb91336
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 23 19:55:48 2020 +0200

    updated subsystemId ranged

commit 2f0b36de46938bf6dd58539f75f91f183e567d25
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 23 19:54:22 2020 +0200

    updated framework object list

commit 9ff3a8537cb711b11be97321d02d45bb50264df8
Merge: 320a5ac3 c7a6711e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 23 17:44:41 2020 +0200

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit 320a5ac355728fd8b357d8bb3e0bca889e2e280e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 23 17:44:22 2020 +0200

    has health IF improvements

commit c7a6711eecddf89a5bad9ab193f166dfd8e93452
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 22 16:25:10 2020 +0200

    include fix

commit 4074ca1b8970e3c3c115f77df15dc87e60f64f59
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 22 14:22:14 2020 +0200

    error code improved

commit 5072c09bc030e381df054b5b28ff979804030cff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 22 13:59:25 2020 +0200

    csb hotfix

commit e3cbc4dfd5a854204130df4e0dd3434438b8d795
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 22 02:12:02 2020 +0200

    shared ring buffer extended

commit f5d793a1cf63b9ebe87bef2e0d49e55947c11cf1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 20 13:38:53 2020 +0200

    file system message getter func

commit 763c52cfca0c173cf54924cb736ebb4262171489
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 21:57:23 2020 +0200

    CSB FIFO first steps to make configurable

commit 40db85e73f54d77cd813afe7f57667ca7e3f56cc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 21:36:12 2020 +0200

    separate messages for success/failure

commit cad08e1ea9d722801b1e6675b88a8513bdc6078a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 20:54:27 2020 +0200

    error output for failed deletion

commit e140d39944ba02407aa281cc6397bc75e69017ad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 20:08:25 2020 +0200

    some  fixes for sd card handler

commit 9e9bde03951b143fec0e16078bcb0a02f0cd442e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 19:50:02 2020 +0200

    srv23 taken over

commit 44989ada64c2fa5919e2ae6245d964eed009976f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 19:41:41 2020 +0200

    file system message taken over

commit 718502c04b35f2677c39d68da4c00f5052e01d33
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 17:15:33 2020 +0200

    added additional flag which casn be used to disable

    periodic handling

commit 02f778ea1d4bbe07df38a7e58ca50ebf6ea81232
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 17:14:09 2020 +0200

    new error code added

commit 4ab7a0838702698e23590c636b93f375103688f8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 17:08:08 2020 +0200

    srv3 continued

commit 32c0140cc24c2aee082abf777f9bcda65b6ba43c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 15:58:34 2020 +0200

    hk stuff continued

commit 9ecbc8199e458e6c56a91c4de91b6217d30d9ea3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 02:46:29 2020 +0200

    added periodic helper

commit ba56f48e8e87f0087b9c5e29846723505abe71cf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 01:17:43 2020 +0200

    huge progress on hk + testing

commit 757d2275ea9f1f19e134e896459fa8a02c9bedcb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 15:06:14 2020 +0200

    internal bugfix

commit 33e7cca23c3175b7349654e790fadb9a2938546c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 15:01:35 2020 +0200

    several bugfixes amd improvements

commit 5e3f40a2c1c163eaa36705de597db37b36ec8635
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:40:48 2020 +0200

    changes taken over from pull request

commit 3a043b5773de78516ac6efd0c3b483e79ebd729e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:31:51 2020 +0200

    object manager tweaks complete

commit f50a80fc3c61066d69117d033b59a85722212c09
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:29:42 2020 +0200

    minor tweaks

commit 4d4166071ca864ce4e60d0aa92ddcc6b74fa1644
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:28:20 2020 +0200

    added pus services to framework objects

commit 1b5c3786b61ceecdb4e7cf1b7b664e81399dbcf6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:24:06 2020 +0200

    taken over serviceinterface folder

commit b429359864f3a25eb33af17f52958fa102ffb8b9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:14:01 2020 +0200

    renormalize files

commit 57c88059e5be68191b25dac2f179df237b125df2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:12:07 2020 +0200

    DHB small improvements

commit 7b0ddb3941729647276cdfe0218d0727d2f6e343
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:09:23 2020 +0200

    quick fix DHB

commit e70e9e3f1f67e007245ab457c1e2f685d5450697
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 12:57:30 2020 +0200

    added uptime seconds functions

commit 19632b8fb1cf4cdedf13795ee5ecaa6158f91f10
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 12:36:36 2020 +0200

    linux fixes

commit e0b2e0b00a578f59ac692c57d1d3b2bc1ea4528c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 12:31:11 2020 +0200

    fxed linux message queues

commit 37f4cc46447906295f11e9e368e32e010eedecad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 12:28:29 2020 +0200

    taken over stopwatch changes

commit 0c6514a682a03e4dc74e5b7878960b0af8bf34f3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 17 22:31:28 2020 +0200

    clock uses getUptime again

commit 6ef5e3e5501e5d925160306f25e39c3e1cfbb312
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 16 21:22:53 2020 +0200

    queue factory host OS fix

commit e5dac30e98f694ad92ea82cc8c15ff7bfc7bd8b2
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 17:37:43 2020 +0200

    new include used now

commit 0d5724e3d416f837348b764cde3f7f732c2c5af6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 17:34:07 2020 +0200

    include improvements taken over

commit 347d591deff649540ff9dbeee1115c2803c060c3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 17:33:21 2020 +0200

    uses new define and config file now

commit 7643af8607ad9b1ccb27f9bd120a324869807134
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 17:15:22 2020 +0200

    include guard fix

commit b8ad17639ceb8b773175749608477d8ff970521c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 17:02:31 2020 +0200

    include guard fix

commit 850a4a3e3deddf8a13a9ee52e53262a8e0c7fe41
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 16:44:48 2020 +0200

    header file renamed

commit 15891b3cf08b585a9e177447d0d15a5ba7490705
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 16:42:17 2020 +0200

    fixed some message queue includes

commit ad98a63e87602790de874b7fa336a2d04d012a1a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 16:02:58 2020 +0200

    changes taken over from upstream master

commit e707c5e05117b9734f50f4a144987ec51b4dfb65
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 15:58:12 2020 +0200

    fixes taken over

commit e8de2fc47a1f1c6451ec5a7a6ec3767377289de7
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 14 18:29:19 2020 +0200

    added srv3

commit 2d2316a0c7824defdd1f079f7fd5d23c29f5d27c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 14 18:01:48 2020 +0200

    hk message continued

commit f9612afe06248d38db5b8b4bb875bd7c66a12598
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 11 14:06:08 2020 +0200

    added report status toggler

commit 71125c075a267e5f0b8cc6229095827b1e9285da
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 21:05:50 2020 +0200

    added new setter function

commit 2d2d0de35cefdc627e556d33e9537cee4dca36a5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 20:24:49 2020 +0200

    local data pool manager bugfixes

commit d7bbd4b652ff2e2e4fe63485fe57e5622ec3d82a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 19:51:17 2020 +0200

    severla bugfixes, new periodic op divider added

commit e4d95a4e0991e766725ddcb4158f26341c7d213e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 16:07:09 2020 +0200

    subsystem changes taken over

commit e57d4a11ae1db3b965a24e3de5efcae1ffc29781
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 16:01:05 2020 +0200

    fixed ordered multi map changes integrated

commit d9dcee3692aa548a94fc614529c954ffcd36b9fe
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:55:56 2020 +0200

    array list changes taken over

commit f35efa3cbe3926b1e47e8a62faeb81a6dae9a1ef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:52:00 2020 +0200

    taken over CSB changes

commit 96e471add600b1829d08958e87b505d37e45a8e3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:51:11 2020 +0200

    merged fixed map changes

commit bbc73a6aaf5d607aca25c04b2bc59a1f7d4b031c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:25:29 2020 +0200

    taken over serialize adapter changes

commit fd09774fc3577eb3993759d2473112796c87a0cb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:18:45 2020 +0200

    serialize if update

commit f663de2418ae1be1064ab4acbf132651c0e5b509
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:17:38 2020 +0200

    taken over changes from master

commit 224ea3914a08710227f057703b64c8a0aaf4d240
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:15:13 2020 +0200

    deleted file not needed anymore

commit db3e32655d70fc4b56c69325faee75449190bf01
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:05:26 2020 +0200

    changes taken over from master

commit 18e6de7d6ba75326262918d4bd0dde93e5c6fa0a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:04:43 2020 +0200

    added compile time check

commit cefac2db0b9f2672039e83bce27d38a92cdb7933
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:03:28 2020 +0200

    assignment operator added

commit d43ef479b6191923a60b308fa9a3efa7fd1bd249
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:02:58 2020 +0200

    assignment operator added

commit 26bb2de0504114bff116277fbd264fa2f39b3ff2
Merge: d99b100a e085deb2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:01:49 2020 +0200

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit e085deb2355e68e4456143988964a152ff96134b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 7 15:23:27 2020 +0200

    fifo fix

commit d99b100ace281a6a371e42ba15c8d260a27159ff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 18:46:56 2020 +0200

    debug output removed

commit 26cbcdbff058a542a30055ba4104b18cb16353a7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 15:21:02 2020 +0200

    removed comment

commit 673af264724261873f78079e72e5fc109fbf2f63
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 14:57:05 2020 +0200

    rework/restructuring

commit 50ae50d28679e620d0a60392f5b557ae4875995d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 14:01:41 2020 +0200

    removed pool raw access helper

commit ac2f6c5ed4dff00bf3ce3228896e393813998bf7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 12:59:59 2020 +0200

    minor improvements

commit efa41b29aa2fb45180d7bd6c2805a8ced32378fd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 12:16:43 2020 +0200

    added informative comment

commit 8db9a4a1911862a359d6c9a27569fb4e640670a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 12:00:57 2020 +0200

    some minor tweaks

commit 7774434d7a211f212ec376bb8296d6aa9f63aab7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 11:58:12 2020 +0200

    windows sockets working

commit 3e0819f954d3eb6b6fb090f7b0d157d867f4ed6c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 11:48:32 2020 +0200

    some bugfixes

commit b7c4f5ce05ec1c235cbea3b825d21ce4497dd095
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 10:36:39 2020 +0200

    continued win sockets

commit 0c85b05aca4d7a1adc8f5bf1a85133c845ecc63f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 09:54:22 2020 +0200

    continued win bridge

commit 08ffbfefae6ea75186a6b405afacc1b9e73e0f55
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 09:33:02 2020 +0200

    added windows udp bridge

commit f698275a0bafc6494780f9b65858ca7d920e8e5a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:59:17 2020 +0200

    removed seconds typedef, confusing

commit c7606b7b1e870b510488da7d72c0dbe9b47e6ddb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:51:17 2020 +0200

    updating and cleaning pool files

commit cb970b1883b35412b64145ddff4f1c5eb1604529
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:24:59 2020 +0200

    task IF is set now

commit 7a24f899158ad8b6a3a74ff2da8a0ba530dc8539
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:19:15 2020 +0200

    removed comment

commit c43ae66205f6fc4c594075660d34b0f6317569fa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:18:30 2020 +0200

    some tweaks

commit 883103af2b4de3e099180e1fb999af974675e7ff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:13:07 2020 +0200

    queue map manager update

commit 80e60566d82c5a6ed35c91af6f3d6cc21866dd7f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:11:27 2020 +0200

    compiling and working again

commit 39b675cf9984a1b22c215979821073a81202b273
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 20:39:10 2020 +0200

    repairing host osal

commit 05814dc805e3901aecdfd353c6e63712e9ed2c27
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 15:58:53 2020 +0200

    added way to start DH immediately, bugfix in event manager

commit faeeca8707857dc75451f06fb78e1c5bffd22b63
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 16:07:54 2020 +0200

    seiralize folder converged

commit 1803030640f2201a006a3e3e30e8029cf001464b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 16:04:11 2020 +0200

    taken over serialize element changes

commit 721b981df2df5ea852d0ad8a0381b488099f2d32
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 16:01:18 2020 +0200

    changes taken over

commit 305d8ef84079a9e0e0861b4708147e3b562d2e10
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:56:52 2020 +0200

    taken over changes

commit f2f7a5de87b728868e13d96765846e50349a789f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:47:33 2020 +0200

    taken over convergence changes

commit 0d69e9beca4b0f35b2c0aea86d5c6df983e9ccaa
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:42:15 2020 +0200

    taken over serial uffer adapter from upstream

commit 37764f7ca710f3ae0ab3b41b7e6b72ea6ba3a14b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:39:17 2020 +0200

    include guard fixed

commit be89e7ebb73f273077c4211eb01078e01d8f537a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:36:53 2020 +0200

    taken over from upstream with little tweak

commit cfa952d9829b4b686ab615b5383c5fa59de285d1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:33:36 2020 +0200

    hybrid iterator same to FSFW

commit fff0131c9b27b25d8705ce42837f432035b51741
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:20:07 2020 +0200

    taken over changes

commit 147ab94149e2dff309ea628b5d77e74ed9a58208
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:13:32 2020 +0200

    include guard improvements

commit f4a50677751b01417a476dc1f309b5074e337601
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 14:53:27 2020 +0200

    update fw class Ids

commit 94b45d7407bd6413926184e8ec8f746fda648cfe
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 14:49:27 2020 +0200

    changed taken over

commit 9d1f292af0f2973f595b0db09957a45a94782662
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 14:32:32 2020 +0200

    changed taken over

commit 6980245c984c69f052c8d1ba2ad1c5c240f50c56
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 14:30:04 2020 +0200

    added line break

commit 31c16382fc5d40cccc9ca3a58a8a60cef5d7a04f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 14:28:43 2020 +0200

    took over changed for fixed slot sequence

commit 403d83f32cedcd6c655e95e25e4f421df9e94971
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 3 13:01:14 2020 +0200

    removed commented out code

commit dbb394f761a147aae4a2fb722cb7ffc264452079
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 3 00:22:16 2020 +0200

    new member to store last step

commit 822a908353608f053590fecd9e0a3115c37cb6f9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 3 00:17:01 2020 +0200

    separated steps, everything seems to work

commit e8fa9816ceea383d1e15e55b6bbf84d1e6327702
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 2 23:45:14 2020 +0200

    doc improved

commit 6069c64048b2850f7cb080cac2d0f836c4543be0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 2 23:36:54 2020 +0200

    doc improved

commit 631b2ca70536b0f05465dfbc790a01cbf509aac5
Merge: ae9bc39b 33039f8c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 2 17:59:45 2020 +0200

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit ae9bc39bdaadb7323dfe009b5e93276e620e6d76
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 2 17:59:26 2020 +0200

    some bugfixes and improvements

commit 33039f8c6055b45cb75b39a4e86a8a38430222a9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 1 12:57:56 2020 +0200

    include  guard correction

commit bec562ece0ae8cc5f7c81d7e998f47ebfaaa083b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 1 12:54:33 2020 +0200

    FIFO updates

commit a634875b4b08cde12d2c2ea14d50303ab13d573d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 1 12:50:17 2020 +0200

    dynamic fifo update

commit 7cf79c17a9e54de41fd9a10e630ad07fd967829f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 1 12:48:51 2020 +0200

    fifo update

commit f7f134ac20ca6bb76fedd14804290fc06455c44a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 1 12:48:11 2020 +0200

    corrections

commit edde2ee58b54270aa832193312ecd289940fe0d2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 1 12:43:50 2020 +0200

    offsetr update

commit 15bb0aee985cc5b558cea21e635b1600db5905f5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 29 19:08:10 2020 +0200

    handler ID cached, debug output improved

commit 6c02776975fbebb9a49302825943c0244c3ebc55
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 29 00:16:40 2020 +0200

    added srv9

commit b0673c7fa6e7f66d9c76a5f66c3d209579a759f1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 18:47:11 2020 +0200

    typo fixes

commit b6a19f911d177e4129dfc0a5a10e0e499aa1ba88
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 18:45:19 2020 +0200

    include guards improved

commit 1b9c8446b7bb7fa005eaf7ce390c12800a3a2177
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 18:33:29 2020 +0200

    renormalized line endings

commit 9abd796e6fd1ad0d8fa91e78bf7b68e8d61ca61b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:58:36 2020 +0200

    updated map packet extraction

commit 8596810fe24836ab9be154aaa47f584447ddef37
Merge: 9f522466 b71cab39
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:58:31 2020 +0200

    Merge branch 'event/git-update' into mueller/master

commit b71cab399330f3ae631bb51fd2cfdbb43dd32cf7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:55:13 2020 +0200

    integrated all changes

commit 9f522466f0529e4fc56abc0ebf2d952e82d39e89
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:52:13 2020 +0200

    wrapped info output in additonal ifdef

commit e800aad97993d36f6800a35cc6ccd805a6e269d1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:44:10 2020 +0200

    event git update

commit d2ef2b2be46e6ac29a6b75a5b44e32f56a7f16b3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:40:53 2020 +0200

    taken over datalinklayer form upstream

commit 5ce954672b023ea804d7915ac3031b284ad10091
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:40:21 2020 +0200

    taken over coordinates  from upstream

commit 2e23fc1201dbd6177527563ed74652961e53018b
Merge: 468ebfb8 8862f35a
Author: Robin Müller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:37:29 2020 +0200

    Merge pull request 'git is weird' (#15) from mueller/action-git-update into mueller/master

    Reviewed-on: https://egit.irs.uni-stuttgart.de/KSat/fsfw/pulls/15

commit 8862f35ad136991e4f4a04d5551a507aba3ed31b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:35:27 2020 +0200

    git is weird

commit 468ebfb809f4ec6140492e3146f134f54b4f1d7d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:18:11 2020 +0200

    include improvement

commit 5ca26a72ea2101786cdfbd6a812a2d9913809224
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:00:16 2020 +0200

    fixed some shadowing issues

commit 42dd665e2649b8e37a27862640f1f73c1147c627
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 20:06:19 2020 +0200

    include improvement

commit ed70f3861272b064fae00a6fab155ccfe67b1e93
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 20:04:17 2020 +0200

    some renaming

commit a6e99e443aaa483b705d8b5570d30ef2a524ec9e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 20:00:36 2020 +0200

    took over dHB failure isolation base fixes

commit 4d1b1ba50662984bd90af489dfa811d8165be6fb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 17:24:40 2020 +0200

    additonal doc for freeRTOS semaphores

commit b9314cffb955b95234a7c82e1a847c9533fee57a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 17:13:52 2020 +0200

    small improvements

commit 5aa664648e8e0d102e29a68c42fac9b16c5ecbb9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 17:03:54 2020 +0200

    linux semaph update

commit fd42d8cd46bdefece3002e15e585fa18578f1372
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 16:14:42 2020 +0200

    periodic task taken over from master

commit 6d3fdab9446d0129823b16aba8cc9e71e2067006
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 15:52:55 2020 +0200

    adapted semaphore IF to mutex IF

commit 1dfdd65662583271a202ee759c2fb48cc0ad6386
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 14:42:10 2020 +0200

    new initializeSequence func

commit 790e0399b7ce5cbb431cf8736cda0ca23b9a216f
Merge: 67ab1f62 3aa6858c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 14:23:14 2020 +0200

    Merge branch 'mueller/project/distribDatapool' into mueller/master

commit 67ab1f6240772ba1c85c6c826f8e9ee097418127
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 14:17:13 2020 +0200

    initialize after task crteation moved

commit 0f9930524b4b7ff8e3e4d5b13ea926ce4b3676f3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Aug 26 15:54:13 2020 +0200

    some minor improvements

commit 83c9d4fc1cb22228f1d58a0f6ba5a1f0f36b6fb0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Aug 26 14:55:27 2020 +0200

    improved tmtc bridge

commit 51b62fd9b189ea149b64a2015c0497240041129c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Aug 26 03:21:26 2020 +0200

    debug output fix

commit c314792e86042a2d60a7ce3a6af265fea4da61a7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Aug 26 02:52:59 2020 +0200

    linebreak changed

commit da3b2b2500592047335c689d8f7d9b9b15f60a86
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 25 18:09:05 2020 +0200

    form improvements

commit 6afbeb8423cdb3d5a0cf2d2c41623d1310ed2e73
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 25 13:42:11 2020 +0200

    removed linker forward decl

commit 92e18b91a3a9d4dac069281971009b4dba5a1dd7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 25 13:38:53 2020 +0200

    seriasl buffer update

commit b97128c12eed9d6b3e5d74f861ab99c6c7cea7ba
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 25 13:29:10 2020 +0200

    deserialize improved

commit c8ba486538fe6086ab8835a70c5656dd5a4ce1af
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 25 13:17:57 2020 +0200

    serial buffer adapter

commit 3aa6858c93594a08a670479fda9354bd9940816e
Merge: 11ce3d02 6afbeb84
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 25 13:04:20 2020 +0200

    Merge branch 'mueller/master' into mueller/project/distribDatapool

commit 11ce3d025fc58fd4205ddc3ef4302ab5262f8c2b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Aug 24 22:08:27 2020 +0200

    srv3 received reply now

commit 8e7f167a6628c0b219b0cbe18e991a2b203a2170
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Aug 24 14:48:22 2020 +0200

    small fix taken over

commit a5227115e5b0361ec33242453ae3435589033200
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 23 23:24:48 2020 +0200

    first subscriptio nfunction written

commit a95bc6b293683e63c3070b5f2ce33a5e2b3f942f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 23 22:33:22 2020 +0200

    sid cached now

commit 687e124929f367f8009b517450e8f61322bb0613
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 23 21:52:44 2020 +0200

    doc added

commit 2b63f1b3f3557ae05bdb55791d90e2febf8a17c8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 23 21:00:25 2020 +0200

    New reporting mode

commit 2f53a3fb1b283cdb26fa4323af2c071107397b57
Merge: f39b8bdb cdaed452
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 23 20:27:00 2020 +0200

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit cdaed4523bdbe6f27820de605344340fec6698b2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 21 16:15:40 2020 +0200

    tmtc bridge todo added

commit 0d476062299a1c5f305146327be3920480fd940a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 21 15:49:06 2020 +0200

    tm/tc packet stored improvements

commit 15fd30b23f313a2f8678fb0946a7ec9c84c52266
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 20 22:31:58 2020 +0200

    assigned read len for decoding error

commit 9385f9024132a5f5edb23284ee70911e7a302110
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 20 20:36:49 2020 +0200

    some bugfixes and improvements

commit adbf39166f1cd7d9b86033148f02b9c18c21f438
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 20 18:13:17 2020 +0200

    removed pus parser

commit f90bd012825b29ef0d4ec1d7b58f1b48da424103
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Aug 19 17:00:50 2020 +0200

    added srv17 and srv201

commit 7b998268cb782f90e8daab6d3bbe94c08cb37047
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Aug 19 13:17:40 2020 +0200

    error message improvement

commit a1d94ec556b6fbb35b6dbcc76499ba9620d663ef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 18 20:51:13 2020 +0200

    added aditional comment

commit 5af50cfbf74fdf025b30030f0f2edfa29ed080b6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 18 20:50:24 2020 +0200

    renamed .mk file

commit fbecda75492905c8c8301b774d66ee777e791037
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 18 13:09:15 2020 +0200

    include replacements

commit f39b8bdb419bd2832d8b1e6b44b13ece12ceb0b8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Aug 10 18:33:28 2020 +0200

    several simplifications

commit 87eb31b65aa7c68c4b3ad40cfac7353349b7b968
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 9 20:06:29 2020 +0200

    local data pool manager uses new packet now

commit 9e7d92b387249a6156a889e277cefc80fd53d667
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 9 19:46:37 2020 +0200

    some renaming , hk packets finished

commit a181f19c02a0abe25966be3b9c18026f7e1d824f
Merge: b092850d 5d09ae32
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 9 17:13:58 2020 +0200

    Merge branch 'mueller/master' into mueller/project/distribDatapool

commit 5d09ae322176247536667994806ca8aa6bb3b1e5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 23:47:44 2020 +0200

    additional comment

commit f9ce1d9eb9f5fcf85a339fc28b3b5806cb1c644c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 23:46:21 2020 +0200

    more simplifications for shared ring buffer

commit 6484c1a27697f1b3a8326dbae0d3fa5eb4be7b4f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 23:45:18 2020 +0200

    shared ring buffer simplified

commit b092850dfcb0a37f3d9fd8b67933b8201d8d622b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 21:32:15 2020 +0200

    internal housekeeping packet finished

commit b828d7c6d7b8267e9867369a557d6e0b9c4d8452
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 19:56:42 2020 +0200

    continued with local datapool manager

commit e7d28d630cfe41ed859f516084b661df3b37a565
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 19:43:28 2020 +0200

    continued with implementation

commit 03cd5780f9b6f915566c07b07482a1b86b103eed
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 13:29:38 2020 +0200

    null initializations in header

commit 121e94a3854049c4a4075327034f8d492b1b3bb8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 13:20:02 2020 +0200

    local pool var update

commit 5c85d03c39af4e9ec31a03e238dd1994b02ea68a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 13:04:31 2020 +0200

    additional check for freeRTOS

commit fba8775f49347da75646b0c70e4adbea94cbd1b3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 12:51:31 2020 +0200

    some renaming

commit f766398b20a1c148f63d10eaea70aad46bf2f3a2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 12:49:20 2020 +0200

    some bugfixes

commit af11c8fcf96c242447baeffbbb9731c9807a6f8e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 12:38:39 2020 +0200

    freeRTOS corrections

commit a6a1e656071342e70d2408a51289ccfe42de78e4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 12:17:27 2020 +0200

    local data set fix

commit 4afb19be51b4fee35d8140f08072df043ec7fd21
Merge: b7411591 03cd5780
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 12:04:52 2020 +0200

    Merge branch 'mueller/master' into mueller/project/distribDatapool

commit 979fea3400668661d817621766c64af1a62ed379
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 22:15:03 2020 +0200

    mutex helper api change

commit 458e849f7d86ca95b0a3ae675d4d00895e26ede8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 22:11:13 2020 +0200

    adapting mutex helper to new interface

commit 44b70b45e216600bf5cfdca4899166f6bad0fd41
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 22:06:20 2020 +0200

    little doc correction

commit e3d094b2dec8ddc838a0f70218b0200b8c1b1ce4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 22:02:23 2020 +0200

    linux: removed old static timeout values

commit 37f2539d894b8f1e9b85fd29005032c9bd4ba12a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 20:44:40 2020 +0200

    empty line removed

commit bfecbfbd80a9f64f84b55246b742c07bf1beccf9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 20:36:37 2020 +0200

    implemented new mutex interface

commit 1a118fe215350eb321184bae30777278095cb1c7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 19:21:47 2020 +0200

    added documentation to assembly base

commit 66039bd3feb553e913fe8440a48e09c1b8843166
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 18:14:39 2020 +0200

    move group def down

commit c4ffb1acd5bff2a8214ddb9f4336d081b3f84636
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 18:12:15 2020 +0200

    subservice number correction

commit 3f87537c6106feb54ab0151247be0ad300a88580
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 15:25:24 2020 +0200

    minor corrections

commit 4d3f0875c18a69147c18f99d401175e5b64c361f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 15:23:37 2020 +0200

    periodic task if adapted

commit 2177877625aa1543c585504505b55b49fd1c2904
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 15:16:09 2020 +0200

    updated framework subsystem ID ranges

commit 4dcfa5125edf80f2bc6bde7861e1da394b4d7a4e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 11:47:47 2020 +0200

    added additional calls

commit 6b475792a4a7c57a5006a010c554dda8b31d41b7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 02:25:10 2020 +0200

    shared ring buffer continued

commit 4e9e465360b2b4757699e79b265c12358ac5e8db
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 02:00:00 2020 +0200

    shared ring buffer continued

commit 0ead44bea976bba70676fc40ed9716f2ae6b84d8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 01:07:59 2020 +0200

    getFreeElement implemented

commit f240827bbdd9ad7542e21ca5810235e6acb20c96
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 00:59:19 2020 +0200

    added getFreeElement

commit ebf5d41a7880f4c866fa1eb29113ecc960bd0efc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 1 19:03:03 2020 +0200

    parameters IF doc and improvement

commit 7475e6a9b85278512a1f4c922e564519cbe63a8f
Merge: 76cc3e96 66eac57e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 1 17:06:12 2020 +0200

    Merge branch 'mueller/master' into source/master

commit 66eac57e3bb77c73a4030d1320a64b42e5841641
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 1 16:54:54 2020 +0200

    csb update

commit 58a4f4f8a1d9608b671cd6fab087afea5d086dc1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 1 16:39:17 2020 +0200

    command message bugfix, CSB improvement

    parameter helper diagnostic message

commit 76cc3e96e8680127fd16c30d83bb4b4c32f6f31f
Merge: ffba6641 18899a4c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 1 12:34:46 2020 +0200

    Merge branch 'mueller/master' into source/master

commit 18899a4c828262258699d9c80beab12cd251b506
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 29 20:07:24 2020 +0200

    hotfix for deadline checking

commit 276c3b172e18df8b7f457e23fb43c22e9c332553
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 29 15:32:36 2020 +0200

    better diagnostic warning for DHB

commit c64aa9f7f55e4afbc5f21cf149bfc71a889a06e5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 28 21:00:11 2020 +0200

    another important bugfix

commit 9fa9421ba58d4c6793aa19886ce6ee17e7f85d71
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 28 20:57:05 2020 +0200

    important bugfix

commit 9acf82cf510be6dfd0f7e94601cdf4795213e5f4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 28 18:12:10 2020 +0200

    doc improved

commit 69f9ff02f047917c2c6a622bcb6fc6244d60564f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 28 17:00:51 2020 +0200

    better returnvalue for failed  comIF init

commit afc16ef2d72dd6662ecb19c4a08a9aedc2119aab
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 28 12:49:18 2020 +0200

    new servicei nterface buffer /stream

commit 6425c0dd4c43ba0fa0711d5d894ae76a1858782f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 26 03:12:04 2020 +0200

    better init error output

commit e179288c00ffedf8e160b399db15a0ec26395ea2
Author: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date:   Thu Jun 25 18:09:32 2020 +0200

    Fixed spelling mistake in HealthHelper

commit b7411591a151419687d1c55054543ec065e7345f
Merge: a0b8f885 b4d6d970
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 16 12:42:02 2020 +0200

    Merge branch 'mueller/master' into mueller/project/distribDatapool

commit b4d6d970bc9890c24b4abb3c671dad2104aac383
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 16 12:41:05 2020 +0200

    removed HK manager virtual functions

commit aaafed7b28bc7110321f0a092a81beb8002990bb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 16 12:38:21 2020 +0200

    health table init now mandatory, better

    diagnostic output for uninit health table or invalid health helper owner

commit 47b3a428c68ff74a6019eb2c36c9fb253cc427fd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 16 12:33:03 2020 +0200

    removed device switch, not necessary anymore

commit a0b8f8855ced699701290f643c1fab8658bd323b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 16 11:45:23 2020 +0200

    cotinued distir datapool

commit e5ab7ada682fb80db4daa3ba7b4f5f20b364fedd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 14 15:45:03 2020 +0200

    added new interfaces for datasets

commit e204bd77c6cf4ac9a4229ed434674a43d72a94c3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 14 02:21:11 2020 +0200

    created tpp file for fixed ordered multimap

commit e7b6999c5ea11e776848cb63a11f1e9673af0efa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 13 22:13:19 2020 +0200

    added back inttypes.h for cleaner code

commit 15052cb33304f18d3e5ce95a4b547a2ff0826c99
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 13 19:54:38 2020 +0200

    singly linked list update

commit 6d99ab3df3e105901cf6af955a034968b7f8364d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 13 19:37:33 2020 +0200

    ncreased readability of DHB function

commit b4f292f3d7fc4f606bf1b6d48618bd0cf1878e26
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 12 18:01:09 2020 +0200

    new generic freertos task interface

commit 99aef0cf287fcdf23f9336927c171762e8bf4f7c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 12 01:16:32 2020 +0200

    C++ linkage for yield from ISR function

commit 7d794c76235c8247602b6327034f604d962b71c5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 18:24:09 2020 +0200

    task management functions have freertos syntax now

commit 799846d89fecc4c17dc6305d17b903217b0687ba
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 14:29:30 2020 +0200

    little formatting changes

commit e4f795d209f36bbfaa39a1d03e46c759d4a86acd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 13:38:14 2020 +0200

    stack high watermark in bytes now

commit ffba6641448c921f74ec7e4ff48e774d8d037b2a
Merge: 69946d52 35d4267b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 11:57:46 2020 +0200

    Merge branch 'mueller_framework' into front_branch

    changes for new freertos task monitor

commit 69946d5276549dce7624540df1de75c94ffc5004
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 11:52:01 2020 +0200

    FIFO hotfix

commit 35d4267b400a950847447d2adc24e53096e4ef86
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 02:36:04 2020 +0200

    dynamic fifo bug fixed

commit 6a6395313f8dce6ec9693acddb6b93d3cda9549a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 01:06:01 2020 +0200

    added copy ctor and assignment for FIFObase

commit 444ee80f356a8e6b8e639c1cb847da320a21713b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 20:31:10 2020 +0200

    removed unnecessary case and added more size checks

commit 31450362106ebec643d99dd60d963e822516b0a5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 19:34:18 2020 +0200

    getter functions for task handle

commit 36a7f2f9ee86b00370bee48721f470d9392bf93c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 14:32:25 2020 +0200

    removed file header comment

commit e29226c9bba6587460d5db87e3ad3b3d7eab2357
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 14:28:36 2020 +0200

    srv8 improved

commit 9716bcdd749cca8ea2e569448a7a1b8ab7cd2298
Merge: c8821ae7 a7d68f8c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 13:55:14 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit a7d68f8c52886f39d116a9ad0553f26463c753b8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 13:31:45 2020 +0200

    deleted copy ctor

commit be8913efeaada850906e19f2d40b6e503b7ec270
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 03:30:52 2020 +0200

    srv8 improvements

commit 9cbc1a18b8c305c095f1c70ada691541e1df6bd1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 03:16:08 2020 +0200

    csrv200 improvements

commit bdc6e881986e9048eac100561ac0e0159b1b0eca
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 03:09:32 2020 +0200

    reordered includes

commit 3551a767a71635c47af18df4b5afbc393416838e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 03:06:18 2020 +0200

    removed old code

commit f3739fd213acd0849399fa4b755ffa7a126da6ab
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 02:44:58 2020 +0200

    bugfix failure isolation base

commit 7a4cc1a6b692b39c596bb88e67051af69b97f928
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 01:22:23 2020 +0200

    hk manager initialized now

commit 1fde3c2c992f3fd96cd0098bfb23c5ab6fa51589
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 00:19:25 2020 +0200

    added srv200, CSB doc

commit cdd877032fe211cd6e9e56940352f608b7e90efb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 23:20:48 2020 +0200

    doc for system object IF improved

commit 57418eb877888bed655eb8f3fee2d58b6f4cbe82
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 20:04:49 2020 +0200

    distrinction between default settings

    and individual settings for service

commit ad049cc634b1c0aa9b0505bc4de42cb6a89a6679
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 19:41:52 2020 +0200

    tmtc bridge formatting improvements

commit ceb61979048feb501a31530ac363aaf53c6b5e43
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 17:01:12 2020 +0200

    some minor improvements

commit da30680d04bffca3ebd17a446fc7cad765a6770f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 16:54:18 2020 +0200

    readability improvement

commit 0cdce6e3272b72044a6d2acf1248d821b62d7002
Merge: a5d3d9ea ac9e6e13
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 16:47:39 2020 +0200

    Merge branch 'mueller_devel_distribDatapool' into mueller_framework

commit a5d3d9ea8030d5f14a7c584641b68a5bf4f21d58
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 16:46:57 2020 +0200

    improved init function

commit 5a351474d2de7e2b38c2ccf232f1a9ba6241bf10
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 16:31:33 2020 +0200

    DHB ctor simplified

commit 32ef807341f2b868af94a11507db532990a4c771
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 15:49:52 2020 +0200

    newline

commit ecd740a1015f47d60ec73b48d54f632dc6aa38bd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 15:47:50 2020 +0200

    ring buffer base calls made protected

commit 6f50356964da86b311b9e96b08d33de6c2b76233
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 14:26:15 2020 +0200

    new shared ring buffer

commit ac9e6e1337acc8a5f68811be1f5da30c69a3e52e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 00:59:10 2020 +0200

    continued with local data pool manager

commit c8821ae74f90cbbbcf4d2d89d29b981b74219ad0
Merge: e48de981 64c290ff
Author: Robin Müller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 18:49:09 2020 +0200

    Merge pull request 'A lot of new features and tweaks' (#12) from mueller_framework into front_branch

commit 64c290ffe44ce6a4352152bcb1a04ff643bfd395
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 18:38:58 2020 +0200

    include guard fix

commit dc27cc9aff73e6c17eb36281d056bd7c217ba6b6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 18:37:26 2020 +0200

    srv8 added to framework

commit 8046d005a46e734aa2112cbd6f617920da2ec753
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 18:18:54 2020 +0200

    CSB static framework id setting

commit 236ad1b85b600acecc741127faa19c72925542fc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 15:06:46 2020 +0200

    a lot of debug output added

commit 5ec78b065c4ca0ba486b9837c0e4c0eba40d5b15
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 13:29:57 2020 +0200

    error handling for invalid dest queues improved

commit b56aa94f99730cee982eebc09dd8fa88a3fbc077
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 12:54:40 2020 +0200

    additional doc

commit 01b10803766e61833eaa9762327a48e0fff76c29
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 12:53:46 2020 +0200

    readability increase

commit 94f9b1e1ef0ecdbd0f92751284f74dc02310b7c2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 12:41:15 2020 +0200

    dle encoder doc finished and hopefully correct

commit 264914e86a1b9a2854dbc8d83ed96445a1255482
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 03:18:09 2020 +0200

    tmtcbridge tweaks.

    UDP bridge now working :-D

commit 2efcda735f84166665c2c1b42dc604048a7bbb34
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 02:20:38 2020 +0200

    message arriving.

    big clean up in tcdistribution folder

commit 399fc0e287048b1fb8e1343185d637c78a791a80
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 17:42:37 2020 +0200

    fifo replacements

commit dd48f7ccadc824b275ea3bf2af0da1c9820ad61b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 17:28:00 2020 +0200

    some form improvements

commit 06d389ed1e6157f1fe736c5dacf121eec247ea14
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 17:25:52 2020 +0200

    increased srv2 readability

commit 684b56ac883b0ee0528edc55b492977518611430
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 17:21:47 2020 +0200

    srv2 tweak: CSB params now configurable

commit 7698f3f13e4ff5886c6c56145e56111a49a6ff4f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 17:18:33 2020 +0200

    moved srv2 to framework

commit 359163886ba2d926cefe8f57b6691818a1e70b8e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 17:06:30 2020 +0200

    pus srv5 and 1 moved to framework

commit 4f1f610ae03bd4f0fecc9e19ecafa5803ee8a231
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 16:36:41 2020 +0200

    doc and improvements for DLE encoder

commit e48de981f54e611d67bba1b2b7907ba2425051a8
Merge: 062ebabb cb691db8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 23:31:38 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit cb691db807d562c8f84178d48650464c4cb58ecc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 23:07:38 2020 +0200

    fifo tweaks, pus parser fixes

commit fd1e612ea5d931d20177405a827c34bf52ee7c54
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 20:17:05 2020 +0200

    pus parser fixes

commit 8ba75fc3c2fad46fc0e37fe17a627a99cfa3f09a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 19:36:21 2020 +0200

    pus parser implemented

commit f442a5889ec4bb213f35668a9320dd4cfedeee94
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 16:34:11 2020 +0200

    pus parser continued

commit 78283ddbeecefb733fe68408befb3337ad869173
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 14:09:33 2020 +0200

    queue map manager: not using std::atomic anymore

commit b61e1df8bcd2177f06cbdb28e7c4352cee75422c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 13:43:41 2020 +0200

    fifo in namespace now

commit bb5de8f11041014ad9f6c33c98fc6d6e0822afc3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 13:41:07 2020 +0200

    merged new changes

commit 2158208a2fbbd98c1fa5ced154866803f80d04f1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 00:33:55 2020 +0200

    new pus parser

commit ebec074655d40dd60c4553c8b94ce3018d6f7358
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 23:53:13 2020 +0200

    Split up FIFO into StaticFIFO and normale FIFO

commit 2395e487aee6c5cc6701a4e0a50de2ea676e4f0c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 20:42:05 2020 +0200

    udp polling taks init

commit 327b1e9d2f242c49c331533a6d8c34407bf0060f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 19:11:21 2020 +0200

    file renamed

commit 724fee09ff30d8c1e435870a93cd4800e6ac0c86
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 18:58:16 2020 +0200

    new task for tc unix polling

commit 26ab1983dcad5ae88addd3aa9b947db9ee6edfc6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 18:22:39 2020 +0200

    new ports

commit 9e2fa165506192b18ca2ea4fa2540c7918c9e480
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 15:31:02 2020 +0200

    mq stack error improved

commit fcf3f04377910154f4a8302481b5f0cbec5273fe
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 01:25:49 2020 +0200

    diag output for inits improved

commit 9dcf0c711854aff22789f0bdcb5375bde51e74bd
Author: Ulrich Mohr <mohr@irs.uni-stuttgart.de>
Date:   Fri Jul 3 15:50:29 2020 +0200

    size_t for DataPoolAdmin

commit b86e5664c470bf1b1c9615abb8557d51d3f86eb8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 00:33:03 2020 +0200

    include which was missing, pool raw access size_t replacements

commit 1a177d2efa05f62c86fe33352cf3608d1b96340b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 00:28:06 2020 +0200

    integrated pool raw access serialize changes

commit 24240b6c7d73d124af1caae18ead919ccde203c8
Author: Ulrich Mohr <mohr@irs.uni-stuttgart.de>
Date:   Fri Jul 3 15:46:00 2020 +0200

    Documented EndianConverter and changed length to size_t

commit c160000027bbe6311fd9c0d318c62a51179129ac
Author: Ulrich Mohr <mohr@irs.uni-stuttgart.de>
Date:   Fri Jul 3 12:44:08 2020 +0200

    Corrected filename of EndianConverter.h

commit 5cee12684142153d01f31627b0bd9b17bcee31d2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 00:06:30 2020 +0200

    formatting

commit 571da391087a8c03220989ed61b1333543aef4ee
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 4 23:52:44 2020 +0200

    continued new bridge

commit e0a3257f8b945da09aba28e784ebc2756e72f984
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 4 23:20:29 2020 +0200

    even better output for unset max msg size

commit 72768a68152b3fb6778e7c90aead2b6f46d596ab
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 4 00:51:49 2020 +0200

    started unix udp bridge

commit 18173772affc0a39866e74465f443328625a4ead
Merge: 47b8ed23 099e6281
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 2 16:56:27 2020 +0200

    Merge branch 'mueller_framework' into mueller_merge_mohr_serialize

commit 099e6281ecdaccf39127da33e7b86b6eaa3f2335
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 2 16:54:53 2020 +0200

    DataSetBase not bound to max size anymore

commit 3e069c34aa6a076f0394ab6bdf3c66f14294ba53
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 2 16:29:29 2020 +0200

    datasetbase stays same f or now

commit 8011d49ebc3c935cb2aba3ccc267f33ed342a60e
Merge: 837fecf8 68c41e23
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 2 16:07:16 2020 +0200

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

commit 47b8ed2321c1a71743cb50fa555cbb3f6b2a3a62
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 1 14:34:16 2020 +0200

    split up long debug message

commit d7bff31a4cfd5e720847a0c9525a4099b97560ac
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 1 14:17:55 2020 +0200

    compiling again

commit 6802ff7d710ddab109d513c2091d683d566b68bc
Merge: 837fecf8 6553450b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 1 13:15:58 2020 +0200

    Merge remote-tracking branch 'upstream/mohr_serialize' into mueller_merge_mohr_serialize

commit 837fecf8599a54102c59ea549ac56a876ff5c32b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 30 21:22:26 2020 +0200

    added hk receiver obj id to dhb ctor

commit 062ebabb9a4d6ff625d3fab05cd385978bf201db
Merge: 2de972bb 1820b5f9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 30 16:41:38 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 1820b5f95c4e3d03c06cd7c0ee9b2fa6639adac9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 30 16:02:07 2020 +0200

    hotfix for copy ctor

commit 2de972bb8a9a35b81824f5c6bc5d00802c32dadd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 30 15:51:19 2020 +0200

    const store accessor copy ctor fixx

commit 3a850018550b319476a4ec8b68bd75b035909df2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 30 00:48:48 2020 +0200

    bit setter correction

commit 85cc936d5da669f8f74ea02c87a8204f4a6235c4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 16:50:45 2020 +0200

    added back clear CommandMessage function

commit e2a36efce3d210c85c1ba924cd627a43b1cac922
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 16:47:58 2020 +0200

    csb changes taken over

commit 48df3cbe8382423b671d7b5d651e3b623f4e2d90
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 16:43:02 2020 +0200

    csb comment improved

commit 691be0dcd4f6c8586b4a29b866bc7d9808d345c5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 16:39:55 2020 +0200

    dhb doc improvements

commit 044aa259e6298bf8accff8c8ab53cd373ed186bc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 16:37:55 2020 +0200

    dhb cached pst interval now

commit ae6314d8cd43a0ad8f0c1a7b9bd567be378203d3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 16:06:53 2020 +0200

    added task handle member

commit 003e70bf4785a8b9e57a8f8ab5f67ae0b0dfade3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 15:55:20 2020 +0200

    new initializeAfterTaskCreation()

commit d5d968a39365b2b0c285d8f283a054050e94be3b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 15:46:16 2020 +0200

    some more correctioons

commit b81b458ba6cc5c6819b9dae6045e25469a1d43cc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 15:44:18 2020 +0200

    exec task if new init function, some corrections

commit 71f997888b71a0c3b5fc77cec93537a849f5984b
Merge: 61370d43 ba5b8bd6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 26 13:33:19 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit ba5b8bd682e1e3e36612a9c8974a4b27c8bf1151
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 26 13:28:58 2020 +0200

    hybrid iter update

commit 08f25370f3505ebf39f26166b2bf5a4000c28461
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 12:03:52 2020 +0200

    moved typedefs into namespace

commit 0c32a964529105b611b600938c84df647f8fa0cf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 11:54:41 2020 +0200

    some more singly linked list improvements

commit 8d633bf1278e473a23ab67ee86458771a5c45bc2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 11:40:48 2020 +0200

    took over changed for singly linked list

commit 6f2bb4125d7e4cd9baaf812c3dcd118883f65e71
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 02:02:57 2020 +0200

    bugfix

commit 7f3607c3d998fb4473fd7b35b3ddf9ebff7b1dbb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 02:00:26 2020 +0200

    hk service fixed

commit 61370d43da713b54379251bca1c6a07f1456318e
Merge: 65c775b8 bb9f606f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 01:29:11 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit bb9f606ffde07095531ee2d3fac85812ce5f59cf
Merge: 16cbbb26 b2c352b0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 01:26:23 2020 +0200

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

commit 16cbbb2693a18cc588661270c482325d4257e95f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 01:11:48 2020 +0200

    linux fixes

commit af24cc7d047cccf09ff5a002a86aa222b18b19ed
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 00:49:13 2020 +0200

    some bugfixes

commit c7c49b4239fe42f4c4da47eba686c41ff687cf17
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 00:30:32 2020 +0200

    deleted command messge base

commit 3bf29a7315d926dc1447e954494f393061ee2c8a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 00:24:15 2020 +0200

    removed CommandMessageBase, changed interfaces

commit 905c1a92e38865558e25bebb10a8c7ca380d2ab6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 21:03:22 2020 +0200

    reverted some changes

commit 56455a5fa290d69f62ad6a17a2ad66b311401c5e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 14:11:53 2020 +0200

    added static function as alternative to macro

commit 67366c25a0bd0b4e532cb8ee48d3d795215c773b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 13:49:25 2020 +0200

    typo fix

commit 5f16d30d822a26fd42ddd2cdc4bc5211db695f41
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 13:47:38 2020 +0200

    all ones value for return failed now

commit 6f4682e1c8848e8fb578af9329c6f274e84a6f60
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 12:53:30 2020 +0200

    hasactionsIF include guard and doc

commit 2ecd7c44937180ab0aad13a1185ed9cc54c9eaa4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 11:05:40 2020 +0200

    some minor improvements

commit 446e7d2f82d46ce9690d3f2c4c84b166407a8c2d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 11:00:40 2020 +0200

    const storage accessor improvement

commit 45ffb7549aa0654f1423ef5cd8dd0f012ab0537a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 10:58:48 2020 +0200

    storage accessor const in own file now

commit e27310da40a420e78cc894746301d318da632bc9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 10:47:31 2020 +0200

    updates for tmtcbridge

commit c0beef44630f991e7307727bbcca6adc81bb48a0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 10:27:44 2020 +0200

    some include guards, todo comments

commit 64a02c55ba9c0f067e64b460b66750b613a31526
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 01:37:25 2020 +0200

    linux fixed, size checks added

commit f7d55a8a37559bf9717b49e414c19db99c5113e9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 01:15:35 2020 +0200

    equal to pull request now

commit 847292ea30e3c71678b0cf994e6436caad71a463
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 01:10:19 2020 +0200

    added overflow checking for periodic task

commit a82dbcbd501a6c035430f8394d5eaebe06480918
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 22 23:47:18 2020 +0200

    minor doc correction

commit 6a7f47e06d95c91f8f9885c38f0716894735a10a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 22 23:46:44 2020 +0200

    doc fix

commit dadc867d9ed44d82782d2f3f66cc0f54b50bfe00
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 22 20:18:13 2020 +0200

    adapted MessageQueueSenderIF function calls

commit 5734a0a0e948df50c57f9d589a2eddac479bb70b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 22 19:22:52 2020 +0200

    some fixes necessary to perform size check

commit 3b2fa978e1b86ccf1b9c113ab958dcaf81e63b4a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 22 19:06:10 2020 +0200

    replaced break with continue

commit 109fdad8b36ca1fe99f0ebad89fb28b04fa7d197
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 22 15:34:35 2020 +0200

    size check for message queue

commit 65c775b83c4ef3c40e3666a10a90c06847349c8b
Merge: 555b7cc9 45a55044
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:48:35 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 45a55044ddd3ded4cac2522313f1db53ac62c1d4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:47:36 2020 +0200

    using debug stream now

commit 95b646046b162d2c47e0a231ae8fad35cc733f21
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:43:29 2020 +0200

    debug output working again

commit 3936fe93609875c7f49332a8a5f24b09d67b7c1c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:34:19 2020 +0200

    linux fix

commit 2c04b87418f2552f836775e4c3eaa1b14bcd033c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:18:00 2020 +0200

    corrected includes

commit 1b0e7c84c7ac2fff9e8b7129110271681c147620
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:15:58 2020 +0200

    linux periodic task improvements

commit 2de811e0afd0ae6a1dc9e4d700bedc693a888691
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:14:56 2020 +0200

    moved timeslot files to task folder

    implmented setting task IF for regular periodic tasks

commit eb4ce980fe93feaba64f01cf13d43d96aaa7d20a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 14:32:04 2020 +0200

    small fixed

commit 60ae2d45655330a3d81dd897b8dfb0ff6456dcd4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 14:25:03 2020 +0200

    continued with hk data pool

    added deadline missed check for fixed timeslot task,
    improved doc for both periodic task and fixed timeslot task

commit 84b8d733c0065280fbb1e39d81bcb8f20fc1ddb7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 03:03:17 2020 +0200

    hk continued

commit 583efec3f8d93efab38c792a9f264f29b0bc01c2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 20:45:44 2020 +0200

    nullptr

commit ed26992d7f1decf404e04d39477836381ec5635b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 20:40:40 2020 +0200

    shoulddo added

commit bb16fd80b8d60813f0605737e2cdd47d729effbf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 20:37:45 2020 +0200

    singly linked list improvements

commit 259517ac9ba0cc51e61980883467374b3ed849f5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 20:22:09 2020 +0200

    single linked list improvement

commit d5ae74f86073c2f9847f4abbd9ed921cdb5ae094
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 20:21:49 2020 +0200

    bugfix hk message size

commit b68ad9e4f9182f8e216e69b34d58138e4044494f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 19:50:26 2020 +0200

    new ctor for simple ring buffer which does not

    allocate

commit f8f10a173033b71d0bb4916cf89243327c0c2921
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 19:41:10 2020 +0200

    slight hybrid iter improvements

commit 38676308e332ead072d35238c95953b7e64abaec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 19:37:55 2020 +0200

    improved array list a bit

commit 813e82415affa80420751065d83454ae88d47262
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 16 11:03:24 2020 +0200

    additional doc info

commit 555b7cc9823123443724d3d61281576cca288fc0
Merge: cd424d79 7871ee7c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 15 17:59:59 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 7871ee7ca810bc49380b3362b3d0c9e1c0e49e0d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 15 17:39:52 2020 +0200

    mutex helper little formatting correction

commit e39d5689e537be8ae3595383005d62e656ad554d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 15 16:56:22 2020 +0200

    device com IF formattign

commit c9d8bd59f0120dca352352dab737d39c43896131
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 15 11:11:42 2020 +0200

    ctor improved

commit 6ecf1cf534b1eaf45be731263a241b629fa3d937
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 14 19:03:28 2020 +0200

    hk message continued

commit 9f69191f234d84e8d73b6ceeeabac3699466aaea
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 14 17:59:14 2020 +0200

    optimized command messages a bit

commit cd424d79e7fe68e3fb14249399bc2beb96eaad10
Merge: 60aed39b 8c03f6a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 14 17:13:52 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 8c03f6a823afca715f51d01cbecdbaa5e6ca185e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 13 21:01:01 2020 +0200

    command message only passed IF now

commit 6b67f46c802aa1b421689097d3faf96668073c71
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 13 17:37:48 2020 +0200

    evil hidden bug found.

    CSB uses CommandMessageIF now

commit 7b538e9750001a7b91a89fbde5a47f9b619674eb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 12 20:23:39 2020 +0200

    introduced command message base and

    command message IF

commit f578c3ea29731f29153741b1ee99ae95c02782c6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 11 16:46:18 2020 +0200

    set buffer: const buffer is set too

commit 60aed39bc5bd5bcc3bf6abe04ebfed73f1b95eee
Merge: b6427d01 6838a9e7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 11 16:22:50 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 6838a9e7687a7232f903b5b39c11fe026bf476ff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 11 16:19:22 2020 +0200

    serial buffer adapter bugfix

commit 206235ed47e0b086acc06015aeb36484bfeeab76
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 11 16:03:09 2020 +0200

    dataset base bugfixes

commit a9c7ad84c8b93c39021194e99306e023432b4ee0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 11 02:03:18 2020 +0200

    added new interface to host and linux osal

commit c1fe326f67f7e734b2f2a8b8d2f9bd569fc537b2
Merge: b2ed0edc 3268806f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 23:42:09 2020 +0200

    Merge branch 'mueller_framework' into mueller_newCommandMessageTest

commit 3268806f75a3ea8ceaf7ce933276133d26b05719
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 22:51:54 2020 +0200

    split up huge function to be more readable

commit b2ed0edce0fd0499fab41e900d877ea42d10b6ae
Merge: 47aa9ddc 454524d2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 22:45:04 2020 +0200

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

commit bb9a299e33ce7429314acb58606f964613a31589
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 22:19:40 2020 +0200

    added back removed comments

commit 5007041bc87e39a44284de14f465fa0478cbc2a0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 22:12:29 2020 +0200

    cleaned up includes and improved doc a bit

commit 659594bac71505492c01feff182a2577f79fb1fe
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 21:35:47 2020 +0200

    better include guard and doc form improvement

commit 606957dc243f31d18d80f51885f4684fc134186b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 21:26:45 2020 +0200

    PSB update

commit 8fbd414a86c82e66f21c1a2fa89f2af005fed1e9
Merge: 52c88792 454524d2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 20:57:04 2020 +0200

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

commit 52c887925fe68f0729db72925c24e3b703ca600b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 20:53:28 2020 +0200

    iomanip include

commit b6427d017be03a19bd847e8ffe800c1e7b9fb892
Merge: b20ba1f9 20e3b3c0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 01:19:00 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 20e3b3c0e2eeec791f2f7c25e1893808af28c0eb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 01:10:16 2020 +0200

    0 replaced by MQIF::NO_QUEUE

commit 3277d199ac166db242ff1fb7b5edfab6fa2964ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 01:07:50 2020 +0200

    linux mq update

commit 47aa9ddcc382393279c0a769e51e7d732cf25a35
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 9 02:46:19 2020 +0200

    doc for mqm improved

commit 8ff6506ad90965f6a42d2b03a1fa2b2638f436c9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 9 02:18:39 2020 +0200

    MessageQueue refactoring complete

commit b1f91439c6325593c59099cbf93d214c27820fc8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 8 17:50:09 2020 +0200

    deleted copy ctor taskes const ref now

commit 07302e0d2aa55dc7a0ed77c595e94f3c4ae9899f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 8 17:44:54 2020 +0200

    removed include

commit b20ba1f938a213c6408d326eb6a591d119b81e61
Merge: 3b4413a6 514ff4f4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 8 14:06:01 2020 +0200

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

commit 3cb79ebc864d17556c4b0743ec3c57f71001fea7
Merge: 0ea249aa 514ff4f4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 8 14:05:40 2020 +0200

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

commit 0ea249aac46c7416aa5b908b9c5f844ac8e09388
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 8 12:25:20 2020 +0200

    messagetype namespace im small letters now

commit 4c41456ddffb6800119c0e6a0d90f4ff03bd4618
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 8 01:22:21 2020 +0200

    thoughts on message queuee message

    new interface. What if there are MQ messages with different sizes?
    -> generic interface

    furthermore, maybe command message should be refactored to operate
    on a mq message instead of implementing it

commit 2649fa150706bc93d88137dc1de595d2d17272b2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 23:38:15 2020 +0200

    small small command message tweaks

commit e8bc2cec9f267079f29e78c94d90d4e107e7eba0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 23:26:52 2020 +0200

    small comment in semaph factory

commit 4a90f41122339e106b7ec52f45fcd982dccc5c39
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 18:53:55 2020 +0200

    generate HK packet function continued

commit 3b4413a6ee268d2759a5ef94c1ce8348c7f4d425
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 16:12:23 2020 +0200

    added queue lock for  receiveMessage

commit 98e6ca5f78b19e679f5f527db1c3612f8e1f214a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 15:22:32 2020 +0200

    removed locks in lockless functions

commit 73932f0349a958aa15b932f23e56dfa4277a02a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 13:58:51 2020 +0200

    object maanager tweaks

commit fe5b50d8857bb07d7c84d2a89e8cf79d65f6d7a6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 02:22:18 2020 +0200

    improved documentation signigicantly

commit d0b218c18e2cdd65405903626566f5c996064876
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 01:40:48 2020 +0200

    renaming for host os

commit 3c80bdfefa8149823ed9fb6273cabaac3d02ccc0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 01:18:19 2020 +0200

    some linebreaks

commit 33cc8591dc2f2ca920dbe86d05e35f8aa40c736c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 01:17:24 2020 +0200

    yaaay, hardcoded values

commit c81613690be10ae70c6e18f373a303d77b80052c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 23:41:54 2020 +0200

    no_queue value is 0xffffffff now

commit 65999ac6d6c2d8d1cc1b7b30f38366bf67f96054
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 23:30:16 2020 +0200

    pool var no param is one now

commit 3d8993b0c599636fb7549ade76ca08cb47f0b4f2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 23:23:20 2020 +0200

    new typedef names

commit 9ed92e5e6f24721446613138f81939c763ae4783
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 23:21:51 2020 +0200

    clock typedefs renamed

commit 70212d9f4e979b1092e151cc7cb666b085acddad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 23:15:42 2020 +0200

    slight formatting

commit 8216b26fdee2f5e7dc552b0d037219149abc7edb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 23:15:05 2020 +0200

    datapoollocal updates

commit ea548dea5bbd969ca17cf9cb48a6b5cfad5e8fda
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 21:16:47 2020 +0200

    map lock init

commit d99be255292e7682bac12dea38258c9cc4eed707
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 20:52:28 2020 +0200

    cookie info iter was uninitialized

    leads to crash

commit 262d34174ea9a7bd46b7ffd12b70e9e1258fe063
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 18:56:54 2020 +0200

    using strncat now

commit b79efa6d6c87cbb9d122b654b706a0279df093a9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 16:25:06 2020 +0200

    variable for name len

commit 096fbec156dc27d269154bebd70b61e9d7ed1c70
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 15:40:10 2020 +0200

    cleaned includesu p a bit

commit dc9ef41bec99951a0012cfa1a6ae17edfbff5bd5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 15:31:45 2020 +0200

    added doc for linux

commit b0634ab0a2f53fc7e1e194391f7ef4da80077931
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 15:26:22 2020 +0200

    fixed bug (critical!)

commit ef01b7814064e6847ce8e90ea00e8ea09bb36111
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 15:01:57 2020 +0200

    some issue with stack size ..

commit 212cd58f9a7a8c7b1ed86b5a4b4f46c09f645022
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 14:45:45 2020 +0200

    issues with fixed timeslo ttask on linux

commit 788f7a37459dbd445253c4876da62d0a2298c2d6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 13:59:00 2020 +0200

    better name for mq

commit 95bc5a871b6a3e823cc6ed1c7564e3540456fda0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 13:56:35 2020 +0200

    improved diagnostic messages for linux

commit 04236859daecfcde5ed24829623d0a5dbf5da070
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 13:03:37 2020 +0200

    slight improvements to diagnostic ouput

commit 5289497ab5769fc61ba1816322c4f86377cfd36f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 12:59:43 2020 +0200

    health helper optional, diagnostic output improved

commit d35524ecbcbcd49d8f95e37180c787f606fad493
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 12:41:17 2020 +0200

    decoupling from raw reciever, linux mq improvements

commit 8e7593d68a8bf7f909cf87f2daea6625c6ef4010
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 02:10:21 2020 +0200

    removed error handling in separate fnctn

commit b4561465ba273718f03b8f32e73eb4d5ffcb7610
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 01:36:07 2020 +0200

    some little form improvements

commit d600d488167c891407e27b3d3f545d02e319fb2e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 01:31:08 2020 +0200

    added the decoupling of DHB from powerSwitcher

    + some first hk maanger changes, might comment them out

commit 87f64d99cd1b7eae59b601140d13a5b92565f384
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 23:18:00 2020 +0200

    implemented fixed timeslot task

commit d74f2c7560452a9b82ddfa4020335b73d971b8a5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 21:40:06 2020 +0200

    housekeeping folder added to .mk file

commit 579115f904e5287ad0bd8d15038b6d707a72523f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 21:36:50 2020 +0200

    adapting host osal

commit 2b646551e96882aac5c62232b9c88a0271209440
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:40:22 2020 +0200

    mutex helper new output error

commit e9a9a543ce3fbf8a9ff57e337513e050e6004c8e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:38:59 2020 +0200

    fw message count one line further

commit 0d4d4123ab28a10376c8ba6c6cc7bd3be5c54e74
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:37:46 2020 +0200

    added new message  type (hk)

commit 7247a1af7efde551f6e7d619e66917d9d4717562
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:36:25 2020 +0200

    new class ids

commit 9ec2283d1397b5699796517cc47e3f82e327757a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:35:08 2020 +0200

    hk folder update

commit 319fa9ddb6237c58d9fe8b0e5763b0b463ec82a4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:34:34 2020 +0200

    datapoollocal update

commit e04e6a6f1506ca90498803bbce49e854e5ed5d4b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:33:57 2020 +0200

    datapoolglob update

commit 9fd5ef0194ebad3e2fe1bfc90b705fe7438ac29b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:28:06 2020 +0200

    updated datapool files

commit 8d3ac33b0ef0b22e35dc102f9d715878780d50df
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:18:38 2020 +0200

    reordering init list for compiler

commit 872c350a9296999af94ad2c275fd2bf34abec1b0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 18:36:22 2020 +0200

    another small bugfix (this-> was missing)

commit ef3e5c4582df70896758e775bed5383b7c415689
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 18:20:21 2020 +0200

    very important bugfix for serial buffer adapter

commit dbeb04895b2d86731be07c4f6af7b1f7f09316fc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 17:55:03 2020 +0200

    added hosted OSAL

commit 4ebd937fe036e5a9427f2bda8683bfca58d5207b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 16:47:46 2020 +0200

    deleted old printer file

commit abcd818f2f48f6805ca1bfadf9d9694078e6a963
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 16:44:31 2020 +0200

    printer renamed to arrayprinter

commit 2a632ae711565b8dbcfd149e5b82f44b647681b0
Merge: 405e1149 d7036edb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 16:03:58 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit d7036edb94e7d64626e3cacf3d205c2b9db143a9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 15:53:20 2020 +0200

    hotfix

commit dd210e99af8ece3866bc898ec3daa631d90b8d9d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 13:45:18 2020 +0200

    additional include which was missing

commit 904721cc3638ffac5a1c4758e84395726d2a415b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 13:44:11 2020 +0200

    improved pool entry iF

commit dd193fd64d302e5592dfddc8a4395101d921b61b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 21:27:37 2020 +0200

    obj manager.cpp improvements

commit e4944a067c3624a669c4703bfa0d5dce5f1b4119
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 21:24:44 2020 +0200

    change made was wrong (pointers in map are not deleted!)

commit d423c001156916fe62b3113c539dee9931f359fb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 21:14:35 2020 +0200

    additional nullptr check

commit 569724843e7196d5c7ca0b324cd575b6aa9aa9ba
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 21:11:49 2020 +0200

    object manager improvements

commit 849053b830d92ccd463779569cb6c450033b47c1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 21:04:24 2020 +0200

    small fix for object manager.cpp

commit 71487d60ca524042c95dffdf1582252f028f35e2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 21:01:09 2020 +0200

    onj managerIF update

commit 3eca16ff785b928f7015444d987a5dbed0ce99dd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 20:59:52 2020 +0200

    removed exit clause

commit 405e1149e56e2a802587b98ff4451ea16268d5c9
Merge: f0be1b1f 4d59ddc3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 20:41:30 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 4d59ddc3db6d9382e61bc4492e51c63283174489
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 19:50:26 2020 +0200

    some fixes, check for preamble size

commit 6ff1cf46c5cda5e6c9ecb85926acc68c8825b1ad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 19:40:43 2020 +0200

    new service interface stream

commit f2a9d2969617f8f3ca9ae8b5fce1e156e8dfb36a
Merge: a115bf11 d75e4716
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 14:45:06 2020 +0200

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

commit a115bf1186d075ea8c6b98c03ba847f22d41251b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 14:43:33 2020 +0200

    store access improvements

commit 925a54dec965b0c52d312616f9f42902fd5fac2e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 01:06:03 2020 +0200

    more improvements for servicei nterface

commit 17ed9b77967f6a8ba2deb281a730df3b33fdadb3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 3 23:38:02 2020 +0200

    OS renamed to OS_FSFW (nameclash with system variable)

commit 5eb3d77bdbb1f4537c95d5c6919a0792b8f274e6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 3 23:29:00 2020 +0200

    clarfiying comment

commit 0a512abc3364855116a4756e42aeac33c0aa2fe2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 3 23:26:27 2020 +0200

    additional clarification comment

commit 5b93799ea659b0b93bd769657c0d00c390786e26
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 3 23:10:04 2020 +0200

    added forward declarations for service interface streams

commit 1c0ca4c329c99caa75f438745b53a53f2978cd30
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 3 23:02:23 2020 +0200

    some changes to take care of activity

commit 3483dff2abf171f85f61e498c6ce3c10131783ff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 3 22:56:03 2020 +0200

    some more interface improvements

commit 5036cdbef3f23cc878c2ce09f66fc648fd34bbe5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 23:54:24 2020 +0200

    queue factory first param uint32_t again

commit 6972e72fbf2a1a5f9dd1adae9c8274ecb1119581
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 23:52:31 2020 +0200

    fixed order

commit f0be1b1fff0c43e0562c577bcc5166e54f5212d6
Merge: c34c6238 54edeacb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 22:27:57 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 54edeacb2d20dcd5a01c0a11e3337b18fb3cf364
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 22:25:28 2020 +0200

    changed names for linux

commit 986dc2047e7ef0f52ebe8bd54fdf7f0fd565a518
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 22:19:48 2020 +0200

    replaced mutexIF and semaphoreIF name for timeouts

commit f0a25b5e2b0e26e549145ff429fc707a5f7c6bb3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 22:10:34 2020 +0200

    new timeout values for MUtexIF and SemaphIF

commit de6ed5c0859e528b798fdb214cf62b7a3143762e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 15:57:04 2020 +0200

    improved include guard and removed old comment

commit 42f0687a6bcf0f1c947ef00dfeea95fa3e060af8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 31 23:28:51 2020 +0200

    self deletion nullptr

commit c8a36a79de45c228e7071cc827423e0b4a383998
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 31 00:23:38 2020 +0200

    corrected doc for task factory interface

commit c34c6238c63b70df5167c0c0856dabbdb65a0890
Merge: 66b75802 7a22d12d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 17:56:06 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 7a22d12d0f1328ff55e3e2826e58000e191ef643
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 17:48:24 2020 +0200

    removed extern "C", not needed

commit 914bf8b9fc1afff3cf98675b4a98707099cb4021
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 17:45:53 2020 +0200

    seconds_t is double now

commit 4d4ca2f3bd87efaca572378e107f92dda2c57eb2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 17:43:37 2020 +0200

    doc fix for stopwatch

commit f13eff79c90a174011c6d3b6c617ce25b575cc76
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 16:51:09 2020 +0200

    another little include guard fix

commit 6b0558d6c71a5b23b2f678d5b18e170cde60e706
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 16:49:11 2020 +0200

    added author tag back

commit 3ef939aca8cff90c0ad51418e859eb69a76a655f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 16:46:26 2020 +0200

    fixed inclue protection

commit 5cf9e938cccf450c5a4ad5b7fb74f7cc4b3705ff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 16:45:03 2020 +0200

    added include protection

commit b90492562ac44f576ab7c7519826ae272d5be68e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 16:40:57 2020 +0200

    added author tag back at class definition

commit f14bacba32e97c7d74e55405d59b9230ec4e362c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 14:15:45 2020 +0200

    using nullptr now

    added new distinction between blocking (MAX_TIMEOUT) and polling
    (NO_TIMEOUT)

commit 6a3dc94108304d9cf0cdde1cc82ecc6dc62390d8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 13:18:27 2020 +0200

    removed extern "C" for freertos includes

commit d5352a9b87a604cd8535963d2a7fcc8176b2182b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 13:15:37 2020 +0200

    actually extern "C" is not needed

    it is included by freeRTOS

commit e7ae35c6592fb101ebe2fd44517a8cfc62b1096d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 13:09:47 2020 +0200

    improved structure a bit

commit 5169c09fd8d56eb041011da9062bb325578a313e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 13:07:35 2020 +0200

    improved includes

commit 78ae109a08ec58c17b1b966944992da0b74da011
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 13:02:13 2020 +0200

    removed context switch request

    (shall be done at end of ISR, so must be performed by caller)

commit da403c01d0178d814896d4c26561e092c1ac2a6e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 03:03:48 2020 +0200

    retval fix, unittest running again

commit 3d2935ac6917b6d8f20c68011cd77cf9d5890686
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 02:23:14 2020 +0200

    linux time lib improvements

    stop watch other function used (more precise for linux)

commit ccf79ab5b63d5870dfd8aabde90895746f9cdc08
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 01:55:20 2020 +0200

    output correction for linux

commit 671f298935a640e33274e1a5fd52339e790068b6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 01:41:16 2020 +0200

    implemented counting semaph for linux

commit 56498e5bc12076330e8f1b74ce7955b16005d0aa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 00:50:44 2020 +0200

    linux bin semaph unlocked

commit 8676fcd9a929b619b65c1598434c75261fdb74b1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 00:47:54 2020 +0200

    yay, linux bin semaph finished

commit 60872f936ce2c2566b388e1e40bdb24194178453
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 23:43:40 2020 +0200

    some output improvements

commit 08ffe89682e72c70876d3dbfd0555161e16608e9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 23:41:59 2020 +0200

    doc and api improvements

commit 7ce505fdf9234630298dc6560b625cc44f41770a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 23:29:06 2020 +0200

    some safety updates and fixes

commit 63dbf995925f181f406173ba380d36b8faadb393
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 22:12:52 2020 +0200

    counting semaph implementation finished

commit 95bf5c1071a84696cc0e15abf9a01102764caaca
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 21:33:34 2020 +0200

    improved const correctness

commit c4e60946d3282c497714cb9345918069afb11047
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 21:30:20 2020 +0200

    improved bin semaph implementation

commit 88e3dc15b2604de0c337f2bf4911ee5e4780588f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 21:27:31 2020 +0200

    replaced old semaph api

commit 7145982b4ade5f3da12e8dd05161b11e45512998
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 19:59:59 2020 +0200

    improved documentation

commit eabee85ba9f1dd014abc66d13e212427dc328242
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 19:56:02 2020 +0200

    tweaked factory to have configurability

commit b4065c776437b39613542d9beff87ba06e6242ad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 19:46:56 2020 +0200

    seperation of semaph implementations finished

commit 8a1e0dab0370c5b454fcb9e95de0f1349000b380
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 19:03:46 2020 +0200

    continued with task notifications

commit 2d33274c2306fd51b4ea512d5d399502755f20fa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 17:42:18 2020 +0200

    implementing new task notifications

commit 968d7fad815877213c154845bc058140e47ee91b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 17:07:35 2020 +0200

    replaced some timeout values

commit 66b75802b24f1498f8baf189d2475ae6c3e7797c
Merge: 9b5095e5 5b521e03
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 12:58:17 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 5b521e039b9cb3973561cc3483ed15794c1d41a3
Merge: badcacad 18d19fbb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 12:40:01 2020 +0200

    Merge branch 'mueller_fw_loc_globpool_distinction' into mueller_framework

commit 9b5095e5b8009a0b4fa11a6824f8b536ad018f2c
Merge: a926312b badcacad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 12:28:43 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit badcacad49e3790df3cda101dc9da973287238de
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 11:48:11 2020 +0200

    added new timeout values

commit f6ae0348cb50dddefa867dc3a0344dac99efef2e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 11:41:36 2020 +0200

    some linux mutex tweaks

commit be4ac0bc8fa03faee1330a9899cb9051485eebba
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 00:28:13 2020 +0200

    added semaph factory to linux

commit f7dd91891a644c660ff8ae7d6c183e84faf75d9a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 26 16:05:03 2020 +0200

    removed comments

commit 1a623a6a527599efc6ee8d4e28e85c405c58cb9a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 26 11:05:49 2020 +0200

    added override

commit a19fa231f51c6b83c0417afe08e208e2bc8c2563
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 26 01:21:48 2020 +0200

    comment improvements

commit 9f2d5b64e009349a03be6990f43b8a3fddc5a02b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 26 01:03:26 2020 +0200

    comment improvements

commit a926312b2506c2c3b324d2856767d1252d76ab16
Merge: 8ddccfe3 242ca355
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 26 00:08:00 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 242ca355f51008eb9ada619295cf397dbc49ae35
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 26 00:01:07 2020 +0200

    removed swappers for arraylist for now

commit 8ddccfe3bd017d69b576945f06814f9fd1fd4723
Merge: 219d85d7 3fd30635
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 23:54:39 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 3fd306356a4b2eefeb78bf6f4cf6d197b7c5c7ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 23:43:44 2020 +0200

    fix for dh returnvalues

commit 243ea9cd8782a4edd74259351b8fb536fdf95bca
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 23:38:51 2020 +0200

    improved dhb IF returnvalues

commit eacda67f027dc24a65f60f08b837b2358aa094f5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 23:36:03 2020 +0200

    added some comments for returnvalues

commit 18d19fbb2c7575cf7b880e0caebf5cbcbc447358
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 23:12:25 2020 +0200

    < removed

commit a37f01cd0ee31c57f8f76f3b299c2f51718e9d85
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 23:11:56 2020 +0200

    improved readability of mode explanations

commit 96462ba8dc4cc7c6389428dca2e35f1e584fe260
Merge: f6ec65d3 7a0cbfb2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 22:29:33 2020 +0200

    Merge branch 'mueller_framework' into mueller_fw_loc_globpool_distinction

commit 7a0cbfb2f5cb9b17fe05a1db1978837796dea0ad
Merge: d6af9da5 cb14ec15
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 22:21:13 2020 +0200

    Merge remote-tracking branch 'upstram/master' into mueller_framework

commit 219d85d700d3791efb3158544f281b2a97b4e1f5
Merge: 723e7150 5e91363d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 15:59:17 2020 +0200

    Merge remote-tracking branch 'upstram/master' into front_branch

commit d6af9da5661f7ccc4e423ff0422a687a5cfbfc8e
Merge: 723e7150 5e91363d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 15:58:57 2020 +0200

    Merge remote-tracking branch 'upstram/master' into mueller_framework

commit f6ec65d35dac92c7de50eb848fc0a7d3ac11a02e
Merge: 8eb13ec6 5e91363d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 14:49:22 2020 +0200

    Merge remote-tracking branch 'upstram/master' into mueller_fw_loc_globpool_distinction

commit 8eb13ec6279624aaecd5e3b9e95744461a7b79b6
Merge: 2f16b1e7 723e7150
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 14:02:43 2020 +0200

    Merge branch 'mueller_framework' into mueller_fw_loc_globpool_distinction

commit 723e715022e6d5ada2dfdee9da5a6f3d7450faa9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 14:01:35 2020 +0200

    consistency fix

commit 2f16b1e7336a1b174bfc0da4ae5437c925c6ac21
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 13:48:43 2020 +0200

    moved some files

commit d4abfacd27b09c17f898e80c62f969610a5d6367
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 22 01:15:02 2020 +0200

    found solution for circ dependency

    had to put store_address_t in own file though

commit d2d1ef9a854727a0381ccab719d2a8cba8a4acf0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 22 00:58:30 2020 +0200

    better include guards

commit aea18c423e030a65309495152332f32592bcd06a
Merge: 7c48274c f6b17d6e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu May 21 17:01:29 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit f6b17d6e2ea6156d06214937c70bee305707a836
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 20 12:50:56 2020 +0200

    deleted copyctor and copy assignment

commit 338651af2f7a67422cda787b56b513f020325df4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 23:07:28 2020 +0200

    binary printer added

commit 9b53e2b64fe9327f55eb12b393a91c666b836dde
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 22:45:48 2020 +0200

    added informative comment for counting semaphore

commit 7afaa752f37422254f962982a41038afb0fbe8da
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 20:25:54 2020 +0200

    form improvement

commit 1aef000eff336b97917ac4c178d95749ec9cd5dc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 20:24:58 2020 +0200

    printer improvements and fixes

    tc packet stored getter function

commit e2418d61a6263f67f2db96ac265f0e271766a28c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 19:53:10 2020 +0200

    improved printer

commit f612b095c1c508466098576866827dc065dc9809
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 19:39:19 2020 +0200

    updated tmtc packet base

commit 2790a40d6c35d27bb8e86121e02c6ca9f0ddf4ef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 18:55:13 2020 +0200

    some renamings

commit 3c7e2c7cfff53bffd4e84de778dcf5d71fc13939
Merge: b12bace3 066930b1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 20:46:50 2020 +0200

    Merge branch 'mueller_BinSempahInterface' into mueller_framework

commit 066930b110730c8c781f0b680e1f7b99f1dbe920
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 20:39:48 2020 +0200

    improvements

commit 7227c3a8667a1ead8c4160b8372d350e79617de4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 20:35:13 2020 +0200

    implemented semaph factory

commit 067cd9573100952c1398b956a8b7d2cbeab93a3a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 19:42:45 2020 +0200

    removed file header

commit b1d9d55f50a0e242ec57604934659c7fff50eb01
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 19:42:05 2020 +0200

    improved documentation

commit 4dd6594845deb381b80fcb2ba8e0ec27acec27e1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 19:38:02 2020 +0200

    integrated interface into bin semaphore

commit 9ba21b1e288ba9f8e20fae9c4cc7ea6923b2651f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 19:30:50 2020 +0200

    semaphore if continued

commit 87bf843beffe92f7f535609cb83fcb4378f952be
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 19:19:50 2020 +0200

    binary semaphore IF init

commit 45b0193ef38b70a4f1d5be76564258bc6ab5c928
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 18:06:40 2020 +0200

    bin semaph todo

commit b23728731548d900b97a70e3d32565ebcfcc50e7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 17:48:16 2020 +0200

    bin semaph sif replacements

commit ec8538b442eef934a6cc1dfb8033c069cbed06a6
Merge: 41c0ca6c fc4199c3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 17:46:04 2020 +0200

    Merge branch 'mueller_binSemaph' into mueller_FreeRTOS_improvements

commit 41c0ca6c52a728ffaf359805efb0df0319b9dcc3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 17:39:10 2020 +0200

    added doc for switchSystemContext

commit f8614e23a867d21d64922329164920c41ab55c38
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 17:38:19 2020 +0200

    deleted copy ans assignment ctor

commit d1500a78685d18e05b94419be69f9cb09056c127
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 17:31:05 2020 +0200

    mq doc improvements

commit 1d4d01d1906d1300eb7fe4e65d259afe64210a81
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 17:22:10 2020 +0200

    Added ISR calls for MQ and task mgmt

    The task management defines an external function which
    implements a context switch call from an ISR

commit b12bace3857588cfca51e0b0c8df37fec0d6c31a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 16:40:11 2020 +0200

    changed order of input arguments (relevance)

    default argument for ACK

commit 7e04c055b353b1cfe6817a2cc2e0fbbca4db631e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 16:13:46 2020 +0200

    tc packet stored formatting

commit 355bc2b9057da4f79ead6aa0e7882b9220edffd7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 15:42:47 2020 +0200

    improvements

commit 767850e12546ddb7b17d344ee32a1c5bb389a593
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 23:58:57 2020 +0200

    deleted poolvector

commit d1b315c7df5882427c41c77bf732f606c73ab50b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 23:54:56 2020 +0200

    pool raw access adaptions

commit 1d28e1398ea927a74a0fc492e4db468122d41afa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 23:41:28 2020 +0200

    DataSetBase class finished

commit 71f1722b886d002a0b8fe550771ee1ed4cde1cc3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 22:20:54 2020 +0200

    removed old poolVar file

commit 9da0b0b2b299b7abeb9b73dd8fdb624942de996c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 22:16:25 2020 +0200

    glob pool vec implementation in tpp file

commit 8b1fef730dcb4cd4f21c3f90121b1c6a74758f63
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 18:02:58 2020 +0200

    resolved conflict

commit 234fd8e300d37bd5293508542ec0b6e5b16c259b
Merge: e9a4056d 0467b6a1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 18:00:51 2020 +0200

    Merge branch 'mueller_framework' into mueller_fw_loc_globpool_distinction

commit 0467b6a1bf60481b74850096c60fc09304bb7ee6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 17:53:18 2020 +0200

    slight DHB improvements

commit 7c48274c9b5a2ae904accae6cd5f01e9e85a8164
Merge: ebcc4742 9597a012
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 17:27:04 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 9597a0121ba7177b7b18beca9319c37be0f230d7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 15:49:46 2020 +0200

    DHB update

commit da972e1b5823cde5cfdf4611e42736d6e8bf7b11
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 15:41:42 2020 +0200

    DHB improvements

commit e9a4056deb17756f70973d6f383182fbabdf90b2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 15:19:24 2020 +0200

    added DHB cookie init

    (why was that never a problem beofre????) ¯\_(ツ)_/¯

commit 9056ad36ed69575e499376558839d0bc044ca4d3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 14:13:31 2020 +0200

    object manager better output

commit 5b8a6e35dcc3e36715e2eaa39345744e3b2ebaef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 13:37:50 2020 +0200

    renaming complete, pool in namespace

commit cbfa21d45a51bbe97d6d35a6b54ab8f409a8f2d1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 01:17:11 2020 +0200

    merging renaming into main branch

commit b673e13892cf7aac425569709a140dc4b589ec70
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat May 16 20:58:48 2020 +0200

    some refactoring

commit 7d579889792144e9cf45fdcc332bb3636c69f488
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat May 16 13:09:50 2020 +0200

    added deadline check

commit 20900227f8bc119befa7dcc2bd5ca3fea3d74e1b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 22:53:01 2020 +0200

    periodic posix task ctor format

commit ebcc4742a92c6aa2152aa7cc8953a587f05fec5b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 21:14:21 2020 +0200

    removed conflict markers

commit abdf04ce79b58a34c8576f18b466327c398694d2
Merge: d44a06fa 0e243841
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 21:10:56 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 0e2438416d0af245d086175868a5496c679b94ef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 20:00:43 2020 +0200

    added comment

commit 5b41f2a6bd4e91956874fff43774865d9887dab5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 19:58:58 2020 +0200

    optimization

commit c77ec9e7fcbe038a4622b3faf3cf311d6d3cc901
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 19:56:54 2020 +0200

    uint16_t correction

commit 3f71babfa995965ef39299f5285ad5990efe6921
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 19:50:51 2020 +0200

    app data len uint16_t, full length size_t

commit 24bfbfbd33e93d35dabd716d72d67eefc9512b11
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 18:56:06 2020 +0200

    removed StorageAccessoremoved StorageAccessorr

commit 80cee2742964485910faa168cb9a1c96e2c0dec3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 18:53:54 2020 +0200

    printer fixes

commit d48fe8fb0997c996d6f30ab1b017b7e5f1da9529
Merge: 6e1bb16d 1b093d96
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 18:51:58 2020 +0200

    Merge branch 'mueller_globalPrinter' into mueller_framework

commit 6e1bb16d4e22f5e4b0b3d9010a5662ffe7f1b16e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 18:46:58 2020 +0200

    printers continued,

    possible  bugfix in tc packet base

commit 237dd4a256598ed805442a71bef58a4ddc9aabb4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 18:23:57 2020 +0200

    added additonal functions for tc packet base

commit 5ac32b14f070c926429969a459106559e8cdf08d
Merge: 684da2b8 effac0e9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 18:23:45 2020 +0200

    Merge branch 'mueller_globalPrinter' into mueller_framework

commit 684da2b8d5400ad68a59a59579bbb9244a1be5c3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 15:30:29 2020 +0200

    set application data function added

commit 69237bc2e87fba9d5b3c8dfc91d11e328e2bdfc8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu May 14 21:26:04 2020 +0200

    freertos includes adapted

commit 49fa2fe32c6bfc4fba6fc91e8cbf564eb7532658
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu May 14 16:12:01 2020 +0200

    changed void* cast to QueueHandle_t cast

commit 50a1b5170aa472c143c8a1a349e04316fb399225
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 13 18:03:09 2020 +0200

    formatting

commit 19e51575cf67c8c1eee1ec402e55cc4dfec74611
Merge: 3122f62b 0e56a094
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 13 12:53:25 2020 +0200

    Merge remote-tracking branch 'origin/meier_framework' into mueller_framework

commit 3122f62b0a1e81268ad5f7ac8fa249a5458dc906
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 12 19:02:59 2020 +0200

    bugfixes for write() call

commit 291710f257745e60e8417b2fa3648dcbfa09ed5d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 12 17:57:37 2020 +0200

    new ctor and bugfixes

commit d873fcbf8ece518e1da89500ef8195da4384c1a3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 12 16:47:47 2020 +0200

    added documentation for storage manager IF

commit 6c70abfe1621a83074f21476d680bc808a52576f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 12 16:32:01 2020 +0200

    moved pool accessor fuctions to local pool

commit 5af0c15dfc6906eb16675e53416c0fe2f95b34b0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 12 14:12:39 2020 +0200

    simplified storage accessor

commit 1946af64af5afb479bda4604b33d712eef99e43a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 12 14:11:00 2020 +0200

    storage accessor mutex lock removed

commit e5c46c5ec1be4ed2c6e890b26a33361b9c3cdbdf
Merge: 43d3ca7e 77565c74
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 11 19:25:45 2020 +0200

    Merge branch 'mueller_FixedSequenceImprovements' into mueller_framework

commit 43d3ca7e379cf1dd20cd0372cf4883eb468d030a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 10 21:56:21 2020 +0200

    memory message: no retval

    CSB: retval

commit d44a06fafc1a63ec38354438910b556e0f1c6b81
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 10 12:48:22 2020 +0200

    removed cfg include

commit 2f58c3a3052506e922ba1758e9a7fa4f1c642c9f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 10 00:14:00 2020 +0200

    commented out storage accessor

commit 0f286461d065f25ddda7b63f4f3ae45d2e6b5db3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat May 9 18:10:26 2020 +0200

    added new storage raw accessor

commit d35a6e6c147e381dce6029db1fd857625fff9ec9
Merge: c05b9cbd 6dc05e49
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 8 18:41:07 2020 +0200

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

commit 9489b7abc1bee2a2b164e81f178222706a8c2b8e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu May 7 19:23:56 2020 +0200

    modifyData override deleted

    is not really thread-safe anyway

commit fe9aa46cf8d33ccb93b570fe77631abb08555829
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu May 7 12:22:17 2020 +0200

    removed system object list include.

    makes it difficult for multiple configurations, because the wrong header
    might be included

commit b016f2995a00a3a5183794bb576820d17b6f078b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 6 16:34:43 2020 +0200

    added default vlaue for init function

commit e950051b4ab7edcc6919af226f3c7a1eae63602e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 6 14:35:30 2020 +0200

    some object managerIF security measures

    objectmanager get function checks whether global object manager was
    initialized now.
    New returnvalues, which are also used for local pool init

commit 6b205e166ba6eab2addc3289bde1734e9ff3830f
Merge: cc0469fe 77c21fc2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 6 13:54:18 2020 +0200

    Merge branch 'master' into mueller_framework

commit cc0469fef6031ebde23583f958fcf1c0b1e5ef3e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 20:09:42 2020 +0200

    return failed insteead of exiting

commit f09836a9eb4aeb561ae1e6fa13e20c0aa0fc01cf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 19:30:03 2020 +0200

    removed exit for empty psremoved exit for empty pstt

commit 4695e87cdca7d9a87e9021d715dced763e079ae8
Merge: 160a0979 df9e6683
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 19:08:46 2020 +0200

    Merge branch 'mueller_fifo_enhancement' into mueller_framework

commit 160a09790e112fdd6cc40cbb75b502c9ca057fd8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 18:53:25 2020 +0200

    removed c omment for now

commit bc17b5a907ca3fe2ead9829a1a582bedc84389b1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 18:43:28 2020 +0200

    resolved conflict

commit ad31a1b97db9cb78a9e6ddd8c8c95537fa4005a4
Merge: 399e6b3a f1a0bb9d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 18:41:40 2020 +0200

    Merge branch 'luz_FixedTimeslotTask_ExistenceCheck' into mueller_framework

commit 399e6b3a09126fc8f63072428acf99de73e36658
Merge: 6817aa4d c05b9cbd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 15:07:47 2020 +0200

    Merge branch 'front_branch' into mueller_framework

commit c05b9cbd01b490046f6d7881bf4ff62f7e2a63c2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 14:07:27 2020 +0200

    reverted ResultIF. for now, keep using HasReturnvaluesIF

commit 1825924b7bf46d65fc163ac89921d9d70ddbe33b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 10:16:16 2020 +0200

    abbreviation for resultIF

commit 6817aa4d03f542939742ef9ccdadd578faaf428a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 4 16:57:08 2020 +0200

    pool manager refactoring

commit b947253ac3107e05ccb85760bb0413d28c46b5c5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 4 16:49:15 2020 +0200

    local pool neat

commit 4b65d6e84739ea13e82441768917c530154d656f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 4 12:33:57 2020 +0200

    local pool bugfix

commit 3e4263f068aa476a608102acccad93f47b0a6d99
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 3 12:27:18 2020 +0200

    freeRTOS task factory fix

commit 35594d4b717e5296581f0227e6d952aebf506cf4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 3 00:48:18 2020 +0200

    goofed up, delay function back in task factory

commit 281da25bf97f344fd7b7727530208879c9c7a153
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 1 16:47:53 2020 +0200

    extended task management for freeRTOS

commit 15c03863c008fb6d8b455bed15985ed725df3bc9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 1 14:49:52 2020 +0200

    additional docmentation for freeRTOS task factory

commit 03333c2af0cc698646f617812fc183a2627ce974
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 30 21:37:02 2020 +0200

    pool raw acces printout

commit 431709a3ecefb0a358726e7f94e2f45131a7d914
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 30 15:42:33 2020 +0200

    pool raw acces helper bugfix

commit e1aa285b6db9733c3b302a0c3c1c0231a2a5e561
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 29 13:46:30 2020 +0200

    linux osal output in namespace

commit 7ec6d2ceaa74f3823db8fe49cef0ff811cbabdd6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Apr 28 18:58:55 2020 +0200

    remove dspecial character messing with decoding

commit ecf3b4b535f7becb1adbd8f0ca1619545b04f4ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 22:05:12 2020 +0200

    stopwatch warning fix

commit a5d2cbd7db6d6f47e7a3f75cc429ac36070f806e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 21:59:24 2020 +0200

    some more sif replacements

commit 0ea692a5ea8e5230ccb14ae42156ac74f05ac851
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 20:04:48 2020 +0200

    some more sif changes

commit 01195093e3309c6bc9722c3b98c4886883e6d384
Merge: 1415cd23 2c6b4465
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 19:21:12 2020 +0200

    Merge branch 'mueller_sifRenaming_soooMany' into mueller_framework

commit fc4199c3b12dfc6f7996d75c035fb0767c21a004
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 18:13:14 2020 +0200

    architecture dependant call delcared external

commit 328737d0ad5d6efb098963fdf0e5088776f50f64
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 18:12:02 2020 +0200

    newer non-deprecated semaphore call used

commit 1415cd2339931cec2dda229782af069459a02f3d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 17:54:41 2020 +0200

    using newer bin semaph create call.

    architecture dependant function call is external now and shall
    be implemented by developer

commit 44d467808939a803f837d188b006cedd332f3d0a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 14:06:48 2020 +0200

    fifo features and stopwatch enhancement

commit ee2ee745c7329445a408137dd95b7e243a4b5adf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 12:47:59 2020 +0200

    fifo renamed

commit d546317e6aa5070873062a12c04b98cf5504a019
Merge: 40d952a3 3a3960ed
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 10:33:19 2020 +0200

    Merge branch 'mueller_TmTcBridge_cherryPicked' into mueller_framework

commit 40d952a3491f549989f5bfb15da6000b8f77b3d1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 10:24:34 2020 +0200

    minor form changes

commit e40c9f42c676ef5fabe55e1392f88e3a8ba11884
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 10:22:25 2020 +0200

    info output commented out

commit c075e1bf2334e6984da63997589c3652d5d39b74
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 10:20:19 2020 +0200

    adapting tmtc bridge

commit db535e25f2e3d978c4eab4a83d4f8751816a9b91
Merge: 2c2ccf8a d0ce075e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 10:03:15 2020 +0200

    Merge branch 'mueller_TmTcBridge_cherryPicked' into mueller_framework

commit 2c2ccf8a8d0b4828b7d63dd34d4dbf0449fc38d9
Merge: 9f7f8073 50265170
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 23:49:10 2020 +0200

    Merge branch 'mueller_TmTcBridge_cherryPicked' into mueller_framework

commit 0e6f8d3f821d3fa6907de2310e9102a33d30afb2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 19:53:06 2020 +0200

    comment adapted

commit 1b5127dc85f236d7e02cdb22c722bea4976d531b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 19:50:07 2020 +0200

    added task management implementation

commit 6eda5a08381891907d67e3b23a93e80808585b07
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 19:46:49 2020 +0200

    task management header added

commit e26f0d54b2828e786c4d91ef38345a7e68d1fbcf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 19:44:03 2020 +0200

    binary semaphore init

commit 9f7f8073f17df0081406804bf2fc84034420da54
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 19:42:42 2020 +0200

    freertos includes in extern "C"

commit fb9a5678fc463aba32a4bbcf01a8cf8994638a30
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 10:24:00 2020 +0200

    removed comment belonging in egit

commit 4e76b8133e905446c90b3447abfaad3744da5d87
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 01:08:36 2020 +0200

    uninitialized variable

commit 326e5cf5febda0dd3ad55cd6c5b181969ebdf9ad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 01:01:32 2020 +0200

    initialized uninitialized variables

commit 6553450b4b85ea7ec53e88850195af35d76d85b2
Author: Uli <uli@vnks.de>
Date:   Tue Apr 21 22:28:43 2020 +0200

    Actually, not that horrible, thanks to sed

commit a42832ca01d9b5554b3e6b7c274bf16ce5d13f58
Author: Uli <uli@vnks.de>
Date:   Tue Apr 21 21:34:03 2020 +0200

    working on updating SerializeIF, to quote Basti: This is going to be horrible

commit 7e3af7cf839ee07cca12093812f323b7b396be04
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 19 21:36:10 2020 +0200

    replaced slotLengthMs with lengthMs

commit 36715e3f4cf98cb21049eaf2001129fe3acbe625
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 19 12:06:28 2020 +0200

    test folder moved to separate test folder

    for fsfw for now

commit e77ca55b1d383afd0079152a4d6809d3e79a6a93
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 17:12:26 2020 +0200

    serial fixed array list adapter doc fix

commit a7d3b4c4a03a0ec2afee9ab0ec5021750fc80dca
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 15:05:51 2020 +0200

    added std:: before uint32_t typedef

commit 9580f51c30590617084b2ef21b8c4fa4a23e0d92
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 14:16:46 2020 +0200

    removed self-inclusion

commit e34a438e774aee4dfe39ab881519e01e8735cb52
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 13:38:05 2020 +0200

    using size_t

commit 4d8aca8417f722ab6fcf15f3defd73652cc0a18a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 13:32:40 2020 +0200

    message queue adaptation for ISRs

commit a405357578cb683f91bad536b9e0b100670a2c1b
Merge: ea1d55b0 05c1330b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 13:30:22 2020 +0200

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

commit ea1d55b0336dd860c7c5ab7a2a6b62d408d3244c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 13:16:00 2020 +0200

    null replaced by nullptr.

    storeID initialization added, all nullptr/0 initializations in header

commit 5595b0f3ce76e9d4c169e09b11960c46b7d2531f
Merge: eb362dca f45a8cc1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 17:02:10 2020 +0200

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit eb362dcad2adb126156d19c558794892526a8791
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 17:02:04 2020 +0200

    some comment line break

commit f45a8cc17193fb3176a8410bd8b00e4ca351bad9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 13:17:26 2020 +0200

    fixed slot sequence safety check added

commit 21650b064dbd901aaaae72345ad326aada79137b
Merge: 5582ca27 33b834ad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 13:01:17 2020 +0200

    Merge branch 'mueller_framework'

commit 33b834ad910ca269c4131d8b796c2deba94a2eed
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 10:43:50 2020 +0200

    null replaced by nullptr

commit 7c360be1e0fe9eeb6d28f8ac6bd473c6d66ae43b
Merge: bd0b9cb8 9284fe81
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 09:30:26 2020 +0200

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit bd0b9cb877ec6138d6d83727480748d4a676975e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 09:30:02 2020 +0200

    catch example informative comment

commit fc08754b98698708dfd36b0f2d1f121e1755922f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 15 23:28:45 2020 +0200

    some doc unclarities comment added

commit 9284fe81da14628f26001536e22a66c1873517f3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 15 20:53:03 2020 +0200

    added override specifiers, some doc fixes

commit 906f941f32bc949edf899e5e8b9ededf45797793
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 15 15:53:46 2020 +0200

    ssize_t in deSerialize replaced by size_t

commit af27a2441affb1923a4a2ff33c044ce825549094
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Apr 14 16:19:13 2020 +0200

    added catch framework for basic testing

commit c5e5de1530acb3f3212514c254dea65635ece647
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Apr 14 12:24:26 2020 +0200

    deleted example values

commit 2cc4386b4c98f92f83c79c0fdfd07dba091d3544
Merge: b48a0a4a 03b0ae7b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Apr 14 11:18:24 2020 +0200

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit 03b0ae7b68541f8d6268c0dcc8b763e04870d185
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Apr 14 11:16:51 2020 +0200

    unit test fixes

commit b48a0a4a4ce5ea9b4e85b76223e357fe49ce6907
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 13 22:45:23 2020 +0200

    unit test class continued. serialize adapter

    functions which are internal, extracted to separate class

commit fe45c7eb8b7f66d01d1ca4f3e06dd91b79987f9f
Merge: 0d016e5a a0ee0109
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 13 16:38:29 2020 +0200

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit 0d016e5a2b2e5b566c7c7f2a11e64c1c93dcc4d3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 13 16:37:25 2020 +0200

    slight formatting

commit a0ee010926eb3870c61c8eaa8cd39f9601b1fa86
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 13 16:27:05 2020 +0200

    Added test folder.

commit eb2df3d88cc3bc2c70bda89208bf4e392bbef860
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 12 23:06:57 2020 +0200

    Using C++ to implement preamble. adding optional flag for carriage return

commit 69e9710bf17013f974188ee420279107b472e822
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Apr 10 17:06:06 2020 +0200

    added intial carriage return im preamble

commit 841b28b65d3c46a175d283d01e92729495f218d9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 9 18:02:10 2020 +0200

    stopwatch ms now working

commit 8a8761ea88e361ff610dd18ba22e59f3f5a9140b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 9 17:56:48 2020 +0200

    stopwatch bugfix

commit 5582ca278b7b050550af3948b6b37331e3575841
Merge: 94137896 640cc1dd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 19:44:21 2020 +0200

    Merge branch 'mueller_framework'

commit 94137896cc171cd5b9e1c461c53dca464c885885
Merge: 35eff6df 2a72e94d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 19:44:10 2020 +0200

    Merge branch 'mueller_stopwatch'

commit 35eff6dfbaf15f722975ca339f88716f988b8b2f
Merge: 826e2bdb c88c6c2a
Author: Robin Müller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 19:35:26 2020 +0200

    Merge branch 'ksat_master' of KSat/fsfw into master

commit 640cc1ddec6fa6e53c8dca212b06b61604e5a6da
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 19:30:39 2020 +0200

    some more bugfixes

commit 5b0f80509f7f8dec258d333c26766dfdf8336ccc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 19:24:24 2020 +0200

    usec replaced by seconds

commit da9bb97b23f2519137674a8b352e7b93592f4ef4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 19:05:21 2020 +0200

    added precision for double output

commit 3dbf35338561897c356a1f949ed2a74ec7e9f311
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 18:33:38 2020 +0200

    some more refactoring for stopwatch

commit 3af241b9c48f1c0f5685435f198d27e4333caa99
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 18:27:18 2020 +0200

    stopwatch more lightweight now

commit e0e1e64a092b9a06570149c2c694102230af182c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 18:08:14 2020 +0200

    various changes, stopwatch

    Semaphore: Some bugfixes, some constructors added
    Stopwatch: First implementation, can measure in ms(double) and
    ms(normal)

commit 30ed08005fd07cd894a49dee5123e028d1fbeed6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Apr 7 22:16:43 2020 +0200

    reverted some naming changes

commit c88c6c2a45482d19f51ec0548ffe50e5b1203a82
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 6 19:51:45 2020 +0200

    binary semaphore info printout added

commit aaabbe8aef2a759d1928b22c6b3acfca2fd9980d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 6 13:59:57 2020 +0200

    DHB fix

commit 78aad91aab99ff6123d8575300613dd14a79b81e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 6 12:38:39 2020 +0200

    PSB subservice passed to handleRequest

commit 3654c7bf8162cd176509db6d83241f077bdfb929
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 6 11:15:44 2020 +0200

    some form stuff

commit e791f44c41525bc742c9027bbeb08a530cd5a424
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 23:03:32 2020 +0200

    copy ctor and assgnment op forbidden

    for serial linked lists

commit 42838272a522b76c9e055f93bdf7af6d00b84b01
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 22:42:48 2020 +0200

    replaced int32_t size by ssize_t (type trait trick)

commit 87852e5f2a3983e21c99a18f8503a511a158cecd
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 21:54:11 2020 +0200

    replaced getSerializedSize returnvalue with size_t

commit 7079c9c56dc03bc1eb89311b831ff9f622257f81
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 17:58:39 2020 +0200

    replaced serializeIF serialize sizes with size_t

commit 06ae64d59c7de1bfaa63c63249cc56c53c47d829
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 15:46:10 2020 +0200

    CSB: replaced some uint32 with size_t

commit a65a19f583b4f71b4c13e3d553fc6e990fd49ba9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 15:33:24 2020 +0200

    deletd serial buffer adapter2

commit 4a35035b2890f3491d096afb22ad3421bc4d1e60
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 15:30:31 2020 +0200

    serial buffer adapted improvements

commit 80b1d28bc84ed4d9e86791b6e1c3e74abae3a4d4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 00:23:29 2020 +0200

    new dvice com IF return value

commit bd468a1b7498d217ca681e25c1932a39639f155f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 1 17:19:03 2020 +0200

    timeslot time 0 definitely leads to error

commit 335df7787ab118078b1a22a26cdd1259d46240ed
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 1 17:15:27 2020 +0200

    testing timeslot task 0

commit 8f39820ace6ecd146b5ac8e0ce10797c79159801
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 1 17:05:55 2020 +0200

    doc formatting

commit 996dbc9e4b952fa208b1e4b12d1ee291701ddf57
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 1 12:41:54 2020 +0200

    DHB/Cookie refactoring

commit 5218a0d84f987272ac2281c6a09ac4ef431dceb6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Mar 28 19:42:24 2020 +0100

    doc fix

commit 93678adc5a8570f444e82259c991f8b5e378cae8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Mar 28 00:09:15 2020 +0100

    replace std::set by std::multiset

    so there can be multiple entries with same pollignTime

commit 5d071a1cf1e4160386566cd1bcd1eeb70e65e5f7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Mar 26 19:53:05 2020 +0100

    new device comIF return value in DHB

    request receive message

commit 0e56a094d305a35b80bdb20cc0c3cdcd533bd888
Author: jakob.meier <jakob.meier@outlook.de>
Date:   Thu Mar 26 19:43:38 2020 +0100

    merged FwMessageTypes

commit e252a5b795147d11371514b9defad39d91a596ed
Author: jakob.meier <jakob.meier@outlook.de>
Date:   Thu Mar 26 19:20:16 2020 +0100

    file system support

commit 093fef5d6f2aea6589abe45077037057bfb879ba
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Mar 26 15:20:17 2020 +0100

    moved address_t typedef to cookieImoved address_t typedef to cookieIFF

commit 163779622fd9b7d367a0fe05d236928e2727d06e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Mar 25 02:08:35 2020 +0100

    DHB: replyLen in replyMap now

commit b2b6b8ee23bc1ed05a4b1e1fc583a9c3f1f71cef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Mar 24 15:33:18 2020 +0100

    added initializeInterface for comIF/cookie

commit ea49d88c4be5929208192fd86d9f2ccf99889cb8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Mar 24 14:21:57 2020 +0100

    moved all return values to DH IF

commit 7e8d92f956220734c4d65dc026550595cfbf577f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Mar 24 00:22:17 2020 +0100

    replaced std::list by std::set for fixedSlotSequen

commit f7b7e10d05224dcd6ab5e2c0c4e778ce5585c544
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 23 19:14:36 2020 +0100

    date format changed

commit b6bf9d71477b3695b1a3dfe7253137c5936c7ebc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 23 19:09:42 2020 +0100

    to avoid dynamic casting, introuced CookieIF

commit f7bd661e6923713740c77e91c2602caa74e6abe5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 23 18:08:24 2020 +0100

    small fixes

commit fa058ee6025cfe03e0a60f62ebb744d80b676637
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 23 18:05:39 2020 +0100

    renamed rmap to com (more generic)

commit d3e2652078913332c407845920b14cd0c5e459a6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 23 17:58:23 2020 +0100

    replaced DHB sizes by size_t, rework

    Cookie now passed to DHB, rework in progress

commit c50d9d90d61a727ddc90e64d75ee98a4d3679bd0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 23 13:14:23 2020 +0100

    replaced std::variant by two uint32 parameters

commit af6d18d60b323ea2759e1ca5af5980bd25673015
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Mar 20 22:47:07 2020 +0100

    added additional parameter form open/reopen call

commit 52c05e2f3da8043336f77deba36e1fefa53e61fd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Mar 19 12:44:24 2020 +0100

    minor formatting for pull request

commit b7e3449b04c48ff65e6e21767667c328938701dd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Mar 19 12:38:11 2020 +0100

    some more doc for containers

commit a3903f80fb915a046eb69e1492254ef4e69b5987
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Mar 19 00:49:47 2020 +0100

    typedef address_t moved to deviceComIF

commit b5fe1fa530ed9fd91b5936b0cb617a9774861a6a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 9 22:15:52 2020 +0100

    dhb virtual function moved to top

commit 6579200f5551f93349ce018127b249ab7cdb3739
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Mar 6 19:01:31 2020 +0100

    removed counter, will be implemented in childclass

commit 68cda479d699ef0f5c73b9ee95c352e178171896
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Mar 6 18:48:48 2020 +0100

    DHB: performOperation Hook + polling counter

    polling counter to specify how often communication opertions are
    performed, however this still needs to be changed..

commit 22e4dabd1bf778c1a4c32aa76d8bf72b99936576
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Mar 6 15:39:42 2020 +0100

    BinSemaphore reset function added

commit 43ac0ec04bbaffc1f7a23b478fd747396a3a4ad4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Mar 4 23:07:54 2020 +0100

    Communication Message continued

commit fb6172fdc51a6e76513437ec74ed733da3847e1f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Mar 4 00:37:58 2020 +0100

    communication message continued.

    Some fixed timeslot task improvements

commit dd4a5a45e3a25ce5bbbedfdd37a407273b62ac54
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Mar 3 21:20:08 2020 +0100

    communication message extended

commit 72963f5855bc8a12dd21d4405cfec3a5a603fbc4
Merge: d0e8eb38 238892bd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Mar 3 00:07:48 2020 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit d0e8eb386ce45b3aa99f8d1413b2c05b1db079d7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 2 01:00:17 2020 +0100

    renamed system context to call context

    to avoid conflicts with ISIS library, I don't want to fiddle with
    it if we don't have source code

commit 238892bd6648f090c8356a6eac9e5dfaddae1de9
Merge: 6d6c78b2 fa38a376
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Feb 29 01:22:41 2020 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit 6d6c78b255407dc08979dbfbf927b9e4dd54db44
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Feb 29 01:21:36 2020 +0100

    task management doc

commit fa38a3760448e28109b6a73bb46e3ee50bb583a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Feb 28 22:55:25 2020 +0100

    all context switches calls to TaskManagement.h now

commit c93ee5c6cdc0098dbcf41ff3fe4c5511534e6c69
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Feb 27 19:00:51 2020 +0100

    message queue IF return values

commit abccd81fdfddb1fc065af32bf6c603c4c3722430
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Feb 26 16:55:35 2020 +0100

    new file for freeRTOS task management functions

commit 083cc7c50ac017a12061e66d6d937a82b2908c92
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Feb 25 17:04:21 2020 +0100

    sempahore wrapper extended

commit 685c18dc4ee3f96af909b90904160048fd39489d
Merge: 7a426ace bfc7a768
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Feb 25 12:55:20 2020 +0100

    Merge branch 'ksat_master' into mueller_framework

commit bfc7a768ce73b1db2a535d7919f24cc1b3244736
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Feb 25 12:54:28 2020 +0100

    message queue adaptions for calls from ISR

    functions moved to top
    binary sempahore file init
    mutex return values

commit 7a426acece7e6fb6135f48b62f1431c894c8e711
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Feb 21 16:08:43 2020 +0100

    therm sensor doc correction

commit 54eeb71f02d1c4c4e49f25e25ed0821a7325b093
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Feb 17 21:20:51 2020 +0100

    bugfix: added implementation

commit 6ab07aeb1978d7a630944a698abebca1097b1d71
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Feb 16 21:04:17 2020 +0100

    valid mask bugfixes

commit 1001c1d48bc7aff5a88bcd58028e6f6d58777265
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Feb 16 17:21:06 2020 +0100

    added new IF for thermal messages

commit 99b90e625d916dafe30cda283c7d75ec772376a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Feb 16 16:14:29 2020 +0100

    refactored: limit type specified separately

commit ddae9ee80f2c74383fa4efa91082c3871b60f6d3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Feb 16 14:59:45 2020 +0100

    adapted temp sensor to use °C limits, doc added

commit d8ed5bb1c15587ef853432a84a3c0334350f9ebd
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Feb 15 18:55:22 2020 +0100

    some comments for missing doc

commit e15839b3a6cdccf3f437991262c0c2eddb6b4ba6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Feb 15 18:26:25 2020 +0100

    Thermal: Some formatting stuff, doc to do

    Need to find out how to use the thermal components

commit a7964c7200bee823cdf20063673f9cd905ef720c
Merge: b3faf1e4 413d6593
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Feb 15 15:34:53 2020 +0100

    Merge branch 'luz_FixedTimeslotTask_ExistenceCheck' into mueller_framework

commit b3faf1e4adee4097b9bcc15ad61c299adacc33a2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 31 23:42:11 2020 +0100

    old timestring used

commit 5190e4c16e0f6618cd1c6b3a3b8f8ad7683172f7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 31 00:54:34 2020 +0100

    Serial Buffer dapter changes reverted

    CCSDS time bugfixes in separate section (for C98)
    Serial buffer adapter 2 bugfixes

commit 09144b18c4fad1c9c92510f3c99ad377ddbbac58
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 29 01:03:20 2020 +0100

    ccsds time changes changed

commit 7dd4694d9d9e25114c6b52f7539ced43b8bdca3f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 28 23:19:19 2020 +0100

    CCSDS time extra defined for avr lib

commit 8f17d5147e7b13179c32fa47f2c2bdc7408e4ef5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 27 00:43:01 2020 +0100

    SerialFixedArrayList constructor bugfix

commit 85048cc9ee180ce6ba14485d18d85bf694e1e51f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 26 22:13:56 2020 +0100

    Pool Raw Access change bugfix

commit d9fa13b6ebd597b6c23f5768405dc757b467028e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 26 18:31:17 2020 +0100

    ADDED old pool entry constructor

commit 6eedb3f09748ed698ece38cb9fc5be6ebe1d3c66
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 23 15:45:21 2020 +0100

    New Pool List Initializer.

    Needs testing !!!

commit d330958abb5813261936198700a2fac535aa1884
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 22 14:27:11 2020 +0100

    Array List endian swapper protected now

commit 1977942c4b2a785e503c21f5cd5cc235ee69e9ed
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 22 14:24:48 2020 +0100

    Array List Entry swapper function

    And respective SerialAdapter functions to use it

commit 3d2bdae14df5427251b59bd81dc44a82f7667a34
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 20 23:29:36 2020 +0100

    CSB abstract functions moved to top

    So documentation of functions to implement is closer to the top

commit dba26baee6b4df5c0379f6886c7eaf12a387683d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 20 23:00:23 2020 +0100

    Restructured header file

    Abstract functions are closer to the top
    because they must be implemented and documentation
    should be near the top.
    Important virtual functions moved up too.
    Additional documentation added

commit 424c82ce165e1da122729ce058be19a32ade7dfa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 18 23:07:43 2020 +0100

    Extracted one logic block

    To increase readability

commit 5cb591a063cb9df22954a26e490806b5648d4061
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 18 18:01:37 2020 +0100

    Array List swapper for SerialFixedArrayList

commit 6fe0f45c278e51b4a54a7f3a105edcafaad9f89a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 18 16:48:33 2020 +0100

    SerialBufferAdapter new setBuffer function

    Serial Fixed Array List Adapter documentation adapted
    SinglyLinkedList setEnd() function added

commit c9e4c73bd251b15c05c7d3140413ca39a2617919
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 18 15:03:22 2020 +0100

    Local pool public members/functions moved to top

commit 1f4391f56e5f95a44529bf89661c69c821fbb5c4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 17 21:11:39 2020 +0100

    Endian Swapper buffer swapper changes reverted

commit 1d1bb88a6f173ba3426a176fb6609e27740928cd
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 16 19:07:53 2020 +0100

    Merge request check

commit 9bdbc2c380780ae7f523c4367560a13f1c64ca66
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 16 18:46:29 2020 +0100

    Endian swapper changes, Serial buffer adapter

    New Serial Buffer Adapter with complete template class for buffer type.
    Endian Swapper input now standard uint8_t * pointers instead of template
    type. Fixed Array List new ctor, but commented out for now

commit 1437f33027cf60c8561eb3517418df2b16194016
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 15 17:30:23 2020 +0100

    Serial Fixed Array List template type clarifications

commit 9aa57f29b81d066429f77cd163043f661062d7ed
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 15 13:52:18 2020 +0100

    basic documentation thermal

commit 9ec0b80497d7c605f40f2764b3699c424b4987ad
Merge: f16cce8b b0d88129
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 15 13:32:41 2020 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit f16cce8be11be06f704fd0f141cb28dea233d802
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 15 13:32:21 2020 +0100

    Basic doc for thermal modules started

commit b0d88129db48db94d4d8ed4526408c62c962e2f0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 14 01:39:47 2020 +0100

    Pool Raw Access Helper bugfix

    debug output commented

commit c7479523363c83db5e1c3c9a207a5eeee5cf5a65
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 14 00:49:09 2020 +0100

    fixed map full() function added.

    Pool raw access debugging

commit 01551b8fa5bf642bac0ec124eef94f192087188a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 13 01:21:53 2020 +0100

    Getter function in SerialBufferAdapter

    For const uint8_t *

commit 1369e792b4c1f3327923c1e7418641c687bb512e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 13 00:14:14 2020 +0100

    CommandingServiceBase documentation

commit d2325e60b69650b5dde10f28dc88a929decf6527
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 12 15:51:59 2020 +0100

    Import bugfix in MessageQueue.cpp

    lastPartner is only assigned if receiveMessage is successful

commit a8247eb2f0406ea78259f9a5c3f70f7b02cef15a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 12 14:18:12 2020 +0100

    Some more debugging output switched on

commit 0ce67de8c8eb8f4eb532e4445e3a1e3765ff07f2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 10 00:57:09 2020 +0100

    Changes to pool access classes

    1. PoolRawAccessHelper is more robust now and has better error handling
    2. PoolRawAccess: Removed an unneeded constructor value, moved serialize
    further to the top. Added new returnvalues and more precise error
    handling for read() call
    3. DataSet: Made MAX Number of data pool entries public so it can be
    used by pool raw access error handling

commit 59b25bee863987dd8a38517f95ac3dc2b780be1a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 9 19:04:33 2020 +0100

    pool raw helper input buffer type changed to uint32_t

commit 0ddc44062ddc1d29c077f4e04d64e2fb7bc3e313
Merge: a7450144 2ec486a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 9 12:50:00 2020 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit 2ec486a8806f9c0bdf287ef81b04c6b494c592ef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 5 18:20:57 2020 +0100

    max number of stored packets lowered

commit 827f185e20788b0b72eaf4cd5d322e78fb7cadd6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 4 16:37:08 2020 +0100

    Some bugfixes(?) for PusServiceBase.
    Getter Function for Serial Buffer Adapter.

commit a7450144de20cb086ba5a9602bd5a7ad44fb83af
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 3 15:39:32 2020 +0100

    doxygen group definitions moved to framework

commit 0a57103339a45c3a7cb18463c891c04644757c5c
Merge: f6e88e83 e2f07cbc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 2 21:12:42 2020 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit f6e88e83db014f529151126d7ba5fe681604981c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 2 21:12:21 2020 +0100

    debug output change

commit e2f07cbcd1436176c45ad8c846657436b0aed832
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 2 14:01:21 2020 +0100

    connect and disconnect functions public

commit 831a01e79ef7d5c5fd6885486f9a9fc7333d504e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 1 17:31:17 2020 +0100

    recvBuffer and recvSize initialized

commit c73cb90c3645f50794cd2919ef73fc755cc93948
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 1 16:54:05 2020 +0100

    receiveTc function adapted

commit a762c159fe334f1e1be6f448dd9ed6ea2519246b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 30 01:13:33 2019 +0100

    pool raw access helper info output commented out

commit 2425685e446ec9a0dae320ea6f0cf0ca95e0cd33
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 29 01:59:02 2019 +0100

    Pool Raw Access Helper serialization of vectors implemented

commit 666341d03ddbe1394e452b0f15af2a4457a0f148
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Dec 27 22:43:09 2019 +0100

    new bool datatype for possible pool entries

commit 79e7fee8072abbf40d65d2114157f35d856bbb5d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 22:15:19 2019 +0100

    comment deleted

commit a38a2f4b3a4e07b77e4989300871c91705496718
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 22:07:17 2019 +0100

    tmtc bridge bugfix: tm data deleted when overwriting old data

commit 33a7c033a27dd741ebbec31f5d517b6acabd342a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 20:38:15 2019 +0100

    doc extended, instructions for sendTm and receiveTc

commit 19e257a90aa57622732177166a9b1ff547da9456
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 20:35:11 2019 +0100

    tmtc bridge debug output corrected

commit 8397f5b2b1961bc875282829fa687adb6cdb6d97
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 20:17:21 2019 +0100

    tmtc bridge bugfix

commit 0066a6b78819777a62f8f1b0ec8512f56b4a49d4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 19:47:46 2019 +0100

    Generic TMTC Bridge added

commit 29b4480fc4f6d752e1236e6b9172dc622ea640ba
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 18:55:31 2019 +0100

    include adapted

commit e24f9b89e4c1965387de84520c80d2439337a9e3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 16:44:50 2019 +0100

    Pool Raw Access Helper tested, appesrs to work. SerializeAdapter doc
    changes, tm packet stored debug output if not enough
    storage available

commit 1f1831c4a14ddf806a6a360e1f60b1c46e90d968
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 24 22:15:39 2019 +0100

    pool raw access init

commit f6b9b232877d29d6a68640967f131d6091c7f2de
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 24 01:41:04 2019 +0100

    pool raw access init

commit 89f490ac36dd3178616cbdfa712adea389ab15ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Dec 20 23:09:35 2019 +0100

    assembly constructor formatting

commit d17146d847610b403118c7992908a94deb361e1c
Author: Maximilian Luz <luzmaximilian@gmail.com>
Date:   Thu Dec 19 16:09:50 2019 +0100

    Check object existence before adding it to the PST

    Currently, adding new objects/components to the FixedSlotSequence PST is
    not being checked, meaning that it is possible to add NULL objects here
    without any warning. This causes NULL-pointer errors when non-existent
    components are added, which can be hard to debug.

    To solve this, add a check for the object existence before adding it to
    PST and emit an error message.

    Signed-off-by: Maximilian Luz <luzmaximilian@gmail.com>

commit fa6cbe7e0c8862f903e7c78bdf938c8caff93863
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 11 23:18:28 2019 +0100

    pool raw access changed reverted

commit 625f3dc79c33794c041bf91af87bd0a2d271e67b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 11 23:15:34 2019 +0100

    local pool modify data doc modifided

commit 9382eb03e6cfb0985d78587df3f4696e52ead038
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 11 22:50:08 2019 +0100

    function to serialize pool ID buffers into dataset created

commit 29a15e8154d5de81d5dff878f6e54f413f5fe12d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 11 13:03:51 2019 +0100

    commented out functions which will propably not
    be needed and removed

commit 138cac98d100affabc0916e27f8189c42af3f3b9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 11 01:57:36 2019 +0100

    experimenting with recursive constructor and dataset call

commit f7d8f0c1617295aae5ed652ee99566f98d84111c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 10 23:26:48 2019 +0100

    Reverted changed  pool raw access commit

commit 6abb3cc525fece4f32f905200e7fa00fba4818c7
Merge: f33949ba 356d1d35
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 10 14:54:32 2019 +0100

    Merge remote-tracking branch 'origin/feature_EndianSwapper_UINT32_BUFFER_PoolRawAccess_Modification_For_Vectors' into mueller_framework

commit f33949ba4b2e7ef3784d712af06e94a04c45ebac
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 10 14:54:17 2019 +0100

    doc adapted, merging

commit 356d1d35dc97232e92778a4d0602947db812dc59
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 10 13:29:16 2019 +0100

    experimenting with recursive constructor to enable
    automatic vector registering

commit e765f8c99bbe6827b44a8ea21a9808ca51471cf1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 9 12:27:14 2019 +0100

    pool raw access modified so vectors are properly serialized now
    Endian swapper can swap the entries of a uint16,uint32 buffers now.
    Some documentation for functions added. setter function for serial buffer
    adapter written but does not appear to compile, commented out

commit 8168885dd905992920029c38444b9abf27541d52
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 8 22:57:03 2019 +0100

    Serialization documentation update

commit 3159ccbc4017f7a9662b82054ac3adbce3aa6261
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 8 22:26:42 2019 +0100

    fixed map and local pool doc

commit d99ed4715017fddab2c1f80610c9c72d3b428315
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 8 19:04:53 2019 +0100

    fixed map bugfix (fist instead of first), new access functions for fixed maP
    (first(), second()), some documentation, raw pool access read() call public
    because call is necessary before using public serialize function.
    maybe integrate read() call into serialize function?

commit 950a48078c6464decada0262f5590c75c5d35a6f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 5 12:21:06 2019 +0100

    some documentation, question about HasParametersIF,
    variable in ParameterHelper intialized (compiler warning)

commit 9c3a9323b7ee50685fd23b57c9d1b39445c43a18
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 3 19:30:37 2019 +0100

    some doc change proposals while
    writing hk service.
    Added Type.h in PoolRawAccess.h, compiler error
    when not doing that

commit 37a70df24496dd0924969c4f52c960ed80d5a1d1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 1 17:48:05 2019 +0100

    SerialBufferAdapter can process uint32_t * buffers now

commit 10c24e39a31293ba54ee8bfdbb2f3835b91dad9e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Nov 29 19:56:05 2019 +0100

    new returnvalue for scanForReply to ignore full packet

commit 2039aa56658923cb4127fddb409c251fdb8d55af
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 25 00:14:39 2019 +0100

    Service Interface Stream buffer size higher to print long buffers (like nav data)

commit 2f14fd5d4d67d2b8223b115d2c5d421cccecffb5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 11 22:45:53 2019 +0100

    Cant reach mode reason getter function added

commit 2b44e1c9c4aa5e516114a6adb922e860c5044417
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Nov 10 13:08:02 2019 +0100

    CCSDS sscanf function adapted for atmel stdio.c (see comments)

commit b8af3b5e3df66e67c8fa7e0e99b6d5b2554deef4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Nov 9 18:15:45 2019 +0100

    debugInterface extended

commit 537e2ceb18ddd360176fddec37331bb952f8c674
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Nov 9 13:29:12 2019 +0100

    Getter method for logicalAddress

commit ee765eafc766d9a4a1053d3d685d7d63e6f9f95f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Nov 9 13:17:54 2019 +0100

    ioBoardAddress renamed to logicalAddress

commit 801bd4d7ebce3ce32eab46e561dec5bc95401c4a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Nov 9 13:07:26 2019 +0100

    debug interface for dhb created.
    This is useful to track states or values
    in child handler. some documentation added.
    New doxygen group for interfaced added.

commit bf7bc342ff2bb816d910bd2c142661fecd25c867
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 5 19:30:02 2019 +0100

    Revert "documentation for DHB init function, ioBoard addres has default value 0 now, order in ctor changed (not used in source)"

    This reverts commit c6e34cada64f59757e420347dec8373401d73c7a.

commit af4e9db9e3be75265cfcb0e48e6c7122fb02591a
Merge: b594bc2a 8a93a873
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 5 19:25:27 2019 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit b594bc2a9719b6ffb99cb3fdaf4813c688576158
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 5 19:25:00 2019 +0100

    removed obsolete comment

commit 8a93a873a8d28afa8b43635a2611b2930cd7e764
Merge: e7f7625a cb919ada
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 4 11:07:02 2019 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit e7f7625adf27263aec16580fa70ca137e412aef6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 4 11:06:59 2019 +0100

    removed wrong include

commit cb919ada2a99b818624d05a4e4fdfeb85e9b8174
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 4 01:55:40 2019 +0100

    assuming that a default value of 0 for expectedReplies is needed, I introduced a new variable into DeviceCommandInfo, which stores another number of replies expected. this value is assigned in enableReplyInReplyMap. That way, the initial value of 0 remains the same (if it was needed), and is only set to another desired value if a write was sent

commit 12f51575eb42bffc9e2cf5a72a5678975f87db34
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 4 00:53:05 2019 +0100

    removed a flag by accident, fixed now

commit 8eb1a5b13e2fccf21176aed9a6a27287196fd236
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 4 00:47:46 2019 +0100

    proposal 1: expectedReplies parameter is set in insertInCommandAndReplyMap, default value stays one. overriding enableReplyInReplyMap is not necessary anymore.second proposal: the commander id is supplied in the interpretDeviceReply function, so we don't have to look for it in the DeviceCommandMap. was it removed at some point because it is listed in the documentation?

commit 46986f69e4a17923717464c120f4d227df561618
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Nov 2 23:30:12 2019 +0100

    serialize tools more documentation

commit d47496db40de8ef8a9be221b9bd023b229a59cc6
Merge: 16af33a7 3887cb8c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 29 19:31:20 2019 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit 16af33a7bb52e3d9363e1e6f61e16a67783f74df
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 29 19:31:18 2019 +0100

    doc for fifo, device com if..

commit 3887cb8ca14f4a12a2fd446e1779b66c76096962
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 29 18:22:34 2019 +0100

    removed wrong include in dhb

commit 3f1d68542e1787e098f37a98005d984a8d83abaa
Merge: e8a16ac5 1ee445ce
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 29 18:21:03 2019 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit e8a16ac59cf87d27d1e79a6571a6ee11f0edc3c2
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 29 18:21:01 2019 +0100

    dummy com if sendMessage data const

commit 1ee445ce245b0383a3d770b44f971693ff37542f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 29 11:17:07 2019 +0100

    fifo typo

commit b51536c772c9d058b7c7a4449f8cf8ca107773ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 28 12:48:41 2019 +0100

    CSB doc correction

commit d79f072851264ec3f9e369f2b2ccbfa7fddd3145
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 27 13:38:08 2019 +0100

    Additional documentation for DHB and CSB

commit 64f84d9d9ffbf2d4b357ac72ad24956b8540db07
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 27 03:21:38 2019 +0100

    doc for dhb, serializeIF and SerializeAdapter

commit 8f1517d276aac56dc260b8ea4609204ab8e1036a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Oct 25 21:12:11 2019 +0200

    additional comments on endianness (I hope this is correct)

commit 1631e739b8c0b3b7ab0af314309da898df7e2eae
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 23 12:03:32 2019 +0200

    at91sam9g20 uses custom stdio.c, unsigned long cast in sprintf does not seem to work, casting (unsigned int) does, timestamp now visible in debug output

commit 07950b0c2bb9c3822729a225302cb685cb62ea7a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 23 00:31:45 2019 +0200

    documentation for object manager IF get function

commit cd1b26b04cff83ba4d238bf74c5d9bace467ea3b
Merge: c6e34cad 4db655e4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 22 17:15:54 2019 +0200

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit c6e34cada64f59757e420347dec8373401d73c7a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 22 17:15:29 2019 +0200

    documentation for DHB init function, ioBoard addres has default value 0 now, order in ctor changed (not used in source)

commit 4db655e4898de934f6388365ec036d9d6e6b1bbe
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 22 14:01:17 2019 +0200

    task priority order comment

commit cbc8012198da6e94870f2b5fe63b799587092bc8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 22 00:06:11 2019 +0200

    ioBoardAddress protected instead of private to allow custom initialize

commit 907664cea9958f1259ed19560839c26533481cf7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 21 11:38:13 2019 +0200

    added do performOperation where the comIF functions are called, some comments added in DeviceHandlerIF

commit 5e3b7c36257314bab40b36c78c13c0525b08eb86
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Oct 18 13:37:09 2019 +0200

    explanation of cookie purpose added, device handler base indentation

commit 743d8abeaffe55cefbddbd2b264be4adcac4d19c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 17 00:23:46 2019 +0200

    first attempt to document and explain serialization tools for application developers
---
 container/FixedOrderedMultimap.h              |    1 +
 controller/ExtendedControllerBase.cpp         |   22 +-
 controller/ExtendedControllerBase.h           |   15 +-
 datapool/PoolDataSetBase.cpp                  |   51 +-
 datapool/PoolDataSetBase.h                    |   29 +-
 datapool/PoolDataSetIF.h                      |    5 +-
 datapool/PoolEntry.cpp                        |   42 +-
 datapool/PoolEntry.h                          |   61 +-
 datapool/PoolVariableIF.h                     |    1 +
 datapool/ReadCommitIF.h                       |   11 +-
 datapoollocal/AccessLocalPoolF.h              |   27 +
 datapoollocal/CMakeLists.txt                  |    4 +-
 datapoollocal/HasLocalDataPoolIF.h            |  135 +-
 datapoollocal/LocalDataPoolManager.cpp        | 1407 +++++++++--------
 datapoollocal/LocalDataPoolManager.h          |   70 +-
 datapoollocal/LocalPoolDataSetBase.cpp        |   80 +-
 datapoollocal/LocalPoolDataSetBase.h          |   55 +-
 datapoollocal/LocalPoolObjectBase.cpp         |  133 +-
 datapoollocal/LocalPoolObjectBase.h           |   11 +-
 datapoollocal/LocalPoolVariable.h             |   24 +-
 datapoollocal/LocalPoolVariable.tpp           |  103 +-
 datapoollocal/LocalPoolVector.h               |   29 +-
 datapoollocal/LocalPoolVector.tpp             |   90 +-
 datapoollocal/PoolReadHelper.h                |   16 +-
 .../ProvidesDataPoolSubscriptionIF.h          |   84 +
 datapoollocal/SharedLocalDataSet.h            |    7 +
 datapoollocal/internal/CMakeLists.txt         |    5 +
 .../internal/HasLocalDpIFManagerAttorney.cpp  |   18 +
 .../internal/HasLocalDpIFManagerAttorney.h    |   22 +
 .../internal/HasLocalDpIFUserAttorney.cpp     |    7 +
 .../internal/HasLocalDpIFUserAttorney.h       |   18 +
 .../internal/LocalDpManagerAttorney.h         |   32 +
 .../internal/LocalPoolDataSetAttorney.h       |   39 +
 ...olDefinitions.h => localPoolDefinitions.h} |   27 +-
 defaultcfg/fsfwconfig/FSFWConfig.h            |   10 +-
 devicehandlers/DeviceHandlerBase.cpp          |  187 ++-
 devicehandlers/DeviceHandlerBase.h            |   35 +-
 devicehandlers/DeviceHandlerIF.h              |    2 +-
 events/EventManager.cpp                       |    8 +-
 events/EventManager.h                         |    4 +
 fsfw.mk                                       |    1 +
 globalfunctions/arrayprinter.cpp              |   10 +-
 housekeeping/HousekeepingMessage.h            |    2 +-
 internalError/InternalErrorDataset.h          |    6 +-
 internalError/InternalErrorReporter.cpp       |   52 +-
 internalError/InternalErrorReporter.h         |   13 +-
 ipc/MutexIF.h                                 |    2 +-
 monitoring/MonitorReporter.h                  |    2 +-
 monitoring/MonitoringMessageContent.h         |    9 +-
 osal/FreeRTOS/Clock.cpp                       |    4 +-
 osal/host/Clock.cpp                           |    4 +-
 osal/host/Mutex.cpp                           |    6 +-
 osal/host/Mutex.h                             |    1 -
 osal/linux/BinarySemaphore.cpp                |   20 +-
 osal/linux/Clock.cpp                          |   10 +-
 osal/linux/CountingSemaphore.cpp              |    4 +-
 osal/linux/MessageQueue.cpp                   |   14 +-
 osal/linux/PosixThread.cpp                    |   10 +-
 osal/linux/TcUnixUdpPollingTask.cpp           |    2 +
 osal/linux/TmTcUnixUdpBridge.cpp              |    8 +-
 osal/rtems/Mutex.cpp                          |    4 +-
 power/Fuse.cpp                                |    7 +-
 power/PowerSensor.cpp                         |    3 +-
 unittest/internal/UnittDefinitions.cpp        |    6 +-
 unittest/internal/UnittDefinitions.h          |    3 +-
 unittest/internal/osal/IntTestMutex.cpp       |    2 +-
 unittest/tests/CMakeLists.txt                 |    1 +
 unittest/tests/action/TestActionHelper.cpp    |    3 +
 unittest/tests/action/TestActionHelper.h      |   81 -
 .../tests/container/TestPlacementFactory.cpp  |   93 +-
 unittest/tests/datapoollocal/CMakeLists.txt   |    6 +
 unittest/tests/datapoollocal/DataSetTest.cpp  |   23 +
 .../datapoollocal/LocalPoolManagerTest.cpp    |  122 ++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  |  206 +++
 .../datapoollocal/LocalPoolVariableTest.cpp   |  123 ++
 .../datapoollocal/LocalPoolVectorTest.cpp     |  120 ++
 unittest/tests/mocks/HkReceiverMock.h         |   20 +
 unittest/tests/mocks/MessageQueueMockBase.h   |  121 ++
 .../tests/storagemanager/TestNewAccessor.cpp  |  322 ++--
 unittest/tests/storagemanager/TestPool.cpp    |    2 -
 unittest/user/CMakeLists.txt                  |  108 +-
 unittest/user/testcfg/FSFWConfig.h            |   23 +-
 .../user/testcfg/objects/systemObjectList.h   |   15 +-
 unittest/user/unittest/CMakeLists.txt         |    1 +
 unittest/user/unittest/core/CMakeLists.txt    |    6 +
 .../user/unittest/core/CatchDefinitions.cpp   |    5 +-
 unittest/user/unittest/core/CatchFactory.cpp  |   27 +-
 unittest/user/unittest/core/CatchRunner.cpp   |   13 +-
 unittest/user/unittest/core/CatchSetup.cpp    |   14 +-
 unittest/user/unittest/core/printChar.cpp     |    2 +-
 90 files changed, 3080 insertions(+), 1509 deletions(-)
 create mode 100644 datapoollocal/AccessLocalPoolF.h
 create mode 100644 datapoollocal/ProvidesDataPoolSubscriptionIF.h
 create mode 100644 datapoollocal/internal/CMakeLists.txt
 create mode 100644 datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
 create mode 100644 datapoollocal/internal/HasLocalDpIFManagerAttorney.h
 create mode 100644 datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
 create mode 100644 datapoollocal/internal/HasLocalDpIFUserAttorney.h
 create mode 100644 datapoollocal/internal/LocalDpManagerAttorney.h
 create mode 100644 datapoollocal/internal/LocalPoolDataSetAttorney.h
 rename datapoollocal/{locPoolDefinitions.h => localPoolDefinitions.h} (68%)
 create mode 100644 unittest/tests/datapoollocal/CMakeLists.txt
 create mode 100644 unittest/tests/datapoollocal/DataSetTest.cpp
 create mode 100644 unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
 create mode 100644 unittest/tests/datapoollocal/LocalPoolOwnerBase.h
 create mode 100644 unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
 create mode 100644 unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
 create mode 100644 unittest/tests/mocks/HkReceiverMock.h
 create mode 100644 unittest/tests/mocks/MessageQueueMockBase.h
 create mode 100644 unittest/user/unittest/CMakeLists.txt

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 96bc00735..acf2368af 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -3,6 +3,7 @@
 
 #include "ArrayList.h"
 #include <cstring>
+#include <functional>
 
 /**
  * @brief  An associative container which allows multiple entries of the same key.
diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 017acafe1..e0aec63a5 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -4,7 +4,7 @@
 ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId,
         object_id_t parentId, size_t commandQueueDepth):
         ControllerBase(objectId, parentId, commandQueueDepth),
-        localPoolManager(this, commandQueue),
+        poolManager(this, commandQueue),
         actionHelper(this, commandQueue) {
 }
 
@@ -17,7 +17,7 @@ ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
 
 
 ReturnValue_t ExtendedControllerBase::initializeLocalDataPool(
-        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
     // needs to be overriden and implemented by child class.
     return HasReturnvaluesIF::RETURN_OK;
 }
@@ -26,8 +26,8 @@ object_id_t ExtendedControllerBase::getObjectId() const {
     return SystemObject::getObjectId();
 }
 
-LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() {
-    return &localPoolManager;
+AccessPoolManagerIF* ExtendedControllerBase::getAccessorHandle() {
+    return &poolManager;
 }
 
 uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const {
@@ -40,7 +40,7 @@ ReturnValue_t ExtendedControllerBase::handleCommandMessage(
     if(result == HasReturnvaluesIF::RETURN_OK) {
         return result;
     }
-    return localPoolManager.handleHousekeepingMessage(message);
+    return poolManager.handleHousekeepingMessage(message);
 }
 
 void ExtendedControllerBase::handleQueue() {
@@ -64,7 +64,7 @@ void ExtendedControllerBase::handleQueue() {
             continue;
         }
 
-        result = localPoolManager.handleHousekeepingMessage(&command);
+        result = poolManager.handleHousekeepingMessage(&command);
         if (result == RETURN_OK) {
             continue;
         }
@@ -88,16 +88,16 @@ ReturnValue_t ExtendedControllerBase::initialize() {
         return result;
     }
 
-    return localPoolManager.initialize(commandQueue);
+    return poolManager.initialize(commandQueue);
 }
 
 ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
-    return localPoolManager.initializeAfterTaskCreation();
+    return poolManager.initializeAfterTaskCreation();
 }
 
 ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
     handleQueue();
-    localPoolManager.performHkOperation();
+    poolManager.performHkOperation();
     performControlOperation();
     return RETURN_OK;
 }
@@ -113,3 +113,7 @@ LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
 #endif
     return nullptr;
 }
+
+ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubscriptionInterface() {
+	return &poolManager;
+}
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index 02c5728e1..b27605141 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -32,10 +32,20 @@ public:
     virtual ReturnValue_t performOperation(uint8_t opCode) override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
+    /**
+     * Provides a subscription interface for objects which required updates on changed
+     * controller variables or datasets
+     * @return
+     */
+    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
+
 protected:
-    LocalDataPoolManager localPoolManager;
+    LocalDataPoolManager poolManager;
     ActionHelper actionHelper;
 
+    //! Accessor handle required for internal handling
+    AccessPoolManagerIF* getAccessorHandle() override;
+
     /**
      * Implemented by child class. Handle all command messages which are
      * not health, mode, action or housekeeping messages.
@@ -60,9 +70,8 @@ protected:
     /** HasLocalDatapoolIF overrides */
     virtual object_id_t getObjectId() const override;
     virtual ReturnValue_t initializeLocalDataPool(
-            LocalDataPool& localDataPoolMap,
+            localpool::DataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
-    virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual uint32_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 };
diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 5fb1c3c7d..010697854 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -38,11 +38,12 @@ ReturnValue_t PoolDataSetBase::registerVariable(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::read(MutexIF::TimeoutType timeoutType,
+		uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t error = result;
 	if (state == States::STATE_SET_UNINITIALISED) {
-		lockDataPool(lockTimeout);
+		lockDataPool(timeoutType, lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
 			result = readVariable(count);
 			if(result != RETURN_OK) {
@@ -86,7 +87,9 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 				!= PoolVariableIF::NO_PARAMETER)
 	{
 		if(protectEveryReadCommitCall) {
-			result = registeredVariables[count]->read(mutexTimeout);
+			result = registeredVariables[count]->read(
+					timeoutTypeForSingleVars,
+					mutexTimeoutForSingleVars);
 		}
 		else {
 			result = registeredVariables[count]->readWithoutLock();
@@ -99,25 +102,29 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 	return result;
 }
 
-ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::commit(MutexIF::TimeoutType timeoutType,
+		uint32_t lockTimeout) {
 	if (state == States::STATE_SET_WAS_READ) {
-		handleAlreadyReadDatasetCommit(lockTimeout);
+		handleAlreadyReadDatasetCommit(timeoutType, lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-		return handleUnreadDatasetCommit(lockTimeout);
+		return handleUnreadDatasetCommit(timeoutType, lockTimeout);
 	}
 }
 
-void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
-	lockDataPool(lockTimeout);
+void PoolDataSetBase::handleAlreadyReadDatasetCommit(
+		MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
+	lockDataPool(timeoutType, lockTimeout);
 	for (uint16_t count = 0; count < fillCount; count++) {
 		if (registeredVariables[count]->getReadWriteMode()
 				!= PoolVariableIF::VAR_READ
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if(protectEveryReadCommitCall) {
-				registeredVariables[count]->commit(mutexTimeout);
+				registeredVariables[count]->commit(
+						timeoutTypeForSingleVars,
+						mutexTimeoutForSingleVars);
 			}
 			else {
 				registeredVariables[count]->commitWithoutLock();
@@ -128,16 +135,19 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 	unlockDataPool();
 }
 
-ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(
+		MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	lockDataPool(lockTimeout);
+	lockDataPool(timeoutType, lockTimeout);
 	for (uint16_t count = 0; count < fillCount; count++) {
 		if (registeredVariables[count]->getReadWriteMode()
 				== PoolVariableIF::VAR_WRITE
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if(protectEveryReadCommitCall) {
-				result = registeredVariables[count]->commit(mutexTimeout);
+				result = registeredVariables[count]->commit(
+						timeoutTypeForSingleVars,
+						mutexTimeoutForSingleVars);
 			}
 			else {
 				result = registeredVariables[count]->commitWithoutLock();
@@ -160,7 +170,8 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 }
 
 
-ReturnValue_t PoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
+ReturnValue_t PoolDataSetBase::lockDataPool(MutexIF::TimeoutType timeoutType,
+		uint32_t lockTimeout) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -206,8 +217,14 @@ void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
     this->registeredVariables = variablesContainer;
 }
 
-void PoolDataSetBase::setReadCommitProtectionBehaviour(
-		bool protectEveryReadCommit, uint32_t mutexTimeout) {
-	this->protectEveryReadCommitCall = protectEveryReadCommit;
-	this->mutexTimeout = mutexTimeout;
+PoolVariableIF** PoolDataSetBase::getContainer() const {
+	return registeredVariables;
+}
+
+void PoolDataSetBase::setReadCommitProtectionBehaviour(
+		bool protectEveryReadCommit, MutexIF::TimeoutType timeoutType,
+		uint32_t mutexTimeout) {
+	this->protectEveryReadCommitCall = protectEveryReadCommit;
+	this->timeoutTypeForSingleVars = timeoutType;
+	this->mutexTimeoutForSingleVars = mutexTimeout;
 }
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 7c1d84a41..d741dabc8 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -3,6 +3,7 @@
 
 #include "PoolDataSetIF.h"
 #include "PoolVariableIF.h"
+#include "../serialize/SerializeIF.h"
 #include "../ipc/MutexIF.h"
 
 /**
@@ -62,8 +63,9 @@ public:
 	 * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
 	 *      commit() in between
 	 */
-	virtual ReturnValue_t read(uint32_t lockTimeout =
-			MutexIF::BLOCKING) override;
+	virtual ReturnValue_t read(
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t lockTimeout = 20) override;
 	/**
 	 * @brief	The commit call initializes writing back the registered variables.
 	 * @details
@@ -82,8 +84,9 @@ public:
 	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
 	 * 			  contains non write-only variables
 	 */
-	virtual ReturnValue_t commit(uint32_t lockTimeout =
-			MutexIF::BLOCKING) override;
+	virtual ReturnValue_t commit(
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t lockTimeout = 20) override;
 
 	/**
 	 * Register the passed pool variable instance into the data set.
@@ -97,8 +100,9 @@ public:
 	 * thread-safety. Default implementation is empty
 	 * @return Always returns -@c RETURN_OK
 	 */
-	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs =
-			MutexIF::BLOCKING) override;
+	virtual ReturnValue_t lockDataPool(
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 	/**
 	 * Provides the means to unlock the underlying data structure to ensure
 	 * thread-safety. Default implementation is empty
@@ -124,6 +128,7 @@ protected:
 	 * @param mutexTimeout
 	 */
 	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
 			uint32_t mutexTimeout = 20);
 
 	/**
@@ -154,14 +159,20 @@ protected:
 	const size_t maxFillCount = 0;
 
 	void setContainer(PoolVariableIF** variablesContainer);
+	PoolVariableIF** getContainer() const;
 
 private:
 	bool protectEveryReadCommitCall = false;
-	uint32_t mutexTimeout = 20;
+	MutexIF::TimeoutType timeoutTypeForSingleVars;
+	uint32_t mutexTimeoutForSingleVars = 20;
 
 	ReturnValue_t readVariable(uint16_t count);
-	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
-	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
+	void handleAlreadyReadDatasetCommit(
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
+	ReturnValue_t handleUnreadDatasetCommit(
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
 };
 
 #endif /* FSFW_DATAPOOL_POOLDATASETBASE_H_ */
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index 99c06cfd7..1f52871d9 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -18,7 +18,10 @@ public:
      *          thread-safety
      * @return Lock operation result
      */
-    virtual ReturnValue_t lockDataPool(dur_millis_t timeoutMs) = 0;
+    virtual ReturnValue_t lockDataPool(
+    		MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) = 0;
+
     /**
      * @brief   Unlock call corresponding to the lock call.
      * @return Unlock operation result
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 583751626..a5867222b 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,32 +1,24 @@
 #include "PoolEntry.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../globalfunctions/arrayprinter.h"
 #include <cstring>
 #include <algorithm>
 
 template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
-		bool setValid ) : length(setLength), valid(setValid) {
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, bool setValid ):
+		length(initValue.size()), valid(setValid) {
 	this->address = new T[this->length];
 	if(initValue.size() == 0) {
 		std::memset(this->address, 0, this->getByteSize());
 	}
-	else if (initValue.size() != setLength){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "PoolEntry: setLength is not equal to initializer list"
-				"length! Performing zero initialization with given setLength"
-				<< std::endl;
-#endif
-		std::memset(this->address, 0, this->getByteSize());
-	}
 	else {
 		std::copy(initValue.begin(), initValue.end(), this->address);
 	}
 }
 
 template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t setLength, bool setValid ) :
+PoolEntry<T>::PoolEntry(T* initValue, uint8_t setLength, bool setValid):
 		length(setLength), valid(setValid) {
 	this->address = new T[this->length];
 	if (initValue != nullptr) {
@@ -70,14 +62,26 @@ bool PoolEntry<T>::getValid() {
 
 template <typename T>
 void PoolEntry<T>::print() {
+	const char* validString = nullptr;
+	if(valid) {
+		validString = "Valid";
+	}
+	else {
+		validString = "Invalid";
+	}
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	 sif::debug << "Pool Entry Validity: " <<
-			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
-#endif
-	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::debug << std::dec << std::endl;
+	 sif::info << "PoolEntry information." << std::endl;
+	 sif::info << "PoolEntry validity: " << validString << std::endl;
+#else
+	 sif::printInfo("PoolEntry information.\n");
+	 sif::printInfo("PoolEntry validity: %s\n", validString);
 #endif
+	arrayprinter::print(reinterpret_cast<uint8_t*>(address), getByteSize());
+}
+
+template<typename T>
+inline T* PoolEntry<T>::getDataPtr() {
+	return this->address;
 }
 
 template<typename T>
@@ -88,8 +92,10 @@ Type PoolEntry<T>::getType() {
 template class PoolEntry<uint8_t>;
 template class PoolEntry<uint16_t>;
 template class PoolEntry<uint32_t>;
+template class PoolEntry<uint64_t>;
 template class PoolEntry<int8_t>;
 template class PoolEntry<int16_t>;
 template class PoolEntry<int32_t>;
+template class PoolEntry<int64_t>;
 template class PoolEntry<float>;
 template class PoolEntry<double>;
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 033db40d0..30940320c 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -35,24 +35,22 @@ public:
 				"uint8_t");
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
-	 * 			potential init values are copied to that space.
+	 * 			potential initialization values are copied to that space.
 	 * @details
 	 * Not passing any arguments will initialize an non-array pool entry
-	 * (setLength = 1) with an initial invalid state.
-	 * Please note that if an initializer list is passed, the correct
-	 * corresponding length should be passed too, otherwise a zero
-	 * initialization will be performed with the given setLength.
+	 * with an initial invalid state and the value 0.
+	 * Please note that if an initializer list is passed, the length of the
+	 * initializer list needs to be correct for vector entries because
+	 * required allocated space will be deduced from the initializer list length
+	 * and the pool entry type.
 	 * @param initValue
-	 * Initializer list with values to initialize with, for example {0,0} to
-	 * initialize the two entries to zero.
-	 * @param setLength
-	 * Defines the array length of this entry. Should be equal to the
-	 * intializer list length.
+	 * Initializer list with values to initialize with, for example {0, 0} to
+	 * initialize the a pool entry of a vector with two entries to 0.
 	 * @param setValid
 	 * Sets the initialization flag. It is invalid by default.
 	 */
-	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
-			bool setValid = false);
+	PoolEntry(std::initializer_list<T> initValue = {0}, bool setValid = false);
+
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
 	 * 			potential init values are copied to that space.
@@ -66,9 +64,9 @@ public:
 	 */
 	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
 
-	//! Explicitely deleted copy ctor, copying is not allowed!
+	//! Explicitely deleted copy ctor, copying is not allowed.
 	PoolEntry(const PoolEntry&) = delete;
-	//! Explicitely deleted copy assignment, copying is not allowed!
+	//! Explicitely deleted copy assignment, copying is not allowed.
 	PoolEntry& operator=(const PoolEntry&) = delete;
 
 	/**
@@ -82,21 +80,16 @@ public:
 	~PoolEntry();
 
 	/**
-	 * @brief	This is the address pointing to the allocated memory.
+	 * Return typed pointer to start of data.
+	 * @return
 	 */
-	T* address;
-	/**
-	 * @brief	This attribute stores the length information.
-	 */
-	uint8_t length;
-	/**
-	 * @brief	Here, the validity information for a variable is stored.
-	 * 			Every entry (single variable or vector) has one valid flag.
-	 */
-	uint8_t valid;
+	T* getDataPtr();
+
 	/**
 	 * @brief	getSize returns the array size of the entry.
-	 * @details	A single parameter has size 1.
+	 * @details
+	 * For non-array pool entries return type size, for vector entries
+	 * return type size times the number of entries.
 	 */
 	uint8_t getSize();
 	/**
@@ -123,8 +116,22 @@ public:
 	 * 			information to the screen. It prints all array entries in a row.
 	 */
 	void print();
-
 	Type getType();
+
+private:
+	/**
+	 * @brief	This attribute stores the length information.
+	 */
+	uint8_t length;
+	/**
+	 * @brief	Here, the validity information for a variable is stored.
+	 * 			Every entry (single variable or vector) has one valid flag.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	This is the address pointing to the allocated memory.
+	 */
+	T* address;
 };
 
 #endif /* FSFW_DATAPOOL_POOLENTRY_H_ */
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 9740fc121..444e19d00 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -25,6 +25,7 @@ class PoolVariableIF : public SerializeIF,
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
 	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
+	static constexpr ReturnValue_t INVALID_POOL_ENTRY = MAKE_RETURN_CODE(0xA1);
 
 	static constexpr bool VALID = 1;
 	static constexpr bool INVALID = 0;
diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h
index 0cdce3718..efe515944 100644
--- a/datapool/ReadCommitIF.h
+++ b/datapool/ReadCommitIF.h
@@ -2,6 +2,7 @@
 #define FSFW_DATAPOOL_READCOMMITIF_H_
 
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/ipc/MutexIF.h>
 
 /**
  * @brief 	Common interface for all software objects which employ read-commit
@@ -10,8 +11,10 @@
 class ReadCommitIF {
 public:
 	virtual ~ReadCommitIF() {}
-	virtual ReturnValue_t read(uint32_t mutexTimeout) = 0;
-	virtual ReturnValue_t commit(uint32_t mutexTimeout) = 0;
+	virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) = 0;
+	virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) = 0;
 
 protected:
 
@@ -19,11 +22,11 @@ protected:
 	//! members with commit and read semantics where the lock is only necessary
 	//! once.
 	virtual ReturnValue_t readWithoutLock()  {
-		return read(20);
+		return read(MutexIF::TimeoutType::WAITING, 20);
 	}
 
 	virtual ReturnValue_t commitWithoutLock() {
-		return commit(20);
+		return commit(MutexIF::TimeoutType::WAITING, 20);
 	}
 };
 
diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
new file mode 100644
index 000000000..da08644f8
--- /dev/null
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -0,0 +1,27 @@
+#ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
+#define FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
+
+class LocalDataPoolManager;
+class MutexIF;
+
+/**
+ * @brief 	Accessor class which can be used by classes which like to use the pool manager.
+ */
+class AccessPoolManagerIF {
+public:
+	virtual ~AccessPoolManagerIF() {};
+
+	virtual MutexIF* getLocalPoolMutex() = 0;
+
+	/**
+	 * Can be used to get a handle to the local data pool manager.
+	 * This function is protected because it should only be used by the
+	 * class imlementing the interface.
+	 */
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+protected:
+
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_ */
diff --git a/datapoollocal/CMakeLists.txt b/datapoollocal/CMakeLists.txt
index c6b187cd2..e2db39eb0 100644
--- a/datapoollocal/CMakeLists.txt
+++ b/datapoollocal/CMakeLists.txt
@@ -5,4 +5,6 @@ target_sources(${LIB_FSFW_NAME}
 		LocalPoolDataSetBase.cpp
 		LocalPoolObjectBase.cpp
 		SharedLocalDataSet.cpp
-)
\ No newline at end of file
+)
+
+add_subdirectory(internal)
\ No newline at end of file
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 7707fab84..569f2b099 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,52 +1,40 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
-#include "locPoolDefinitions.h"
+#include "localPoolDefinitions.h"
 
 #include "../datapool/PoolEntryIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
 
 #include <map>
 
-class LocalDataPoolManager;
+class AccessPoolManagerIF;
+class ProvidesDataPoolSubscriptionIF;
 class LocalPoolDataSetBase;
 class LocalPoolObjectBase;
-
-using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
-using LocalDataPoolMapIter = LocalDataPool::iterator;
+class LocalDataPoolManager;
 
 /**
- * @brief 		This interface is implemented by classes which posses a local
- * 				data pool (not the managing class). It defines the relationship
- * 				between the local data pool owner and the LocalDataPoolManager.
+ * @brief 		This interface is implemented by classes which posses a local data pool (not the
+ * 				managing class). It defines the relationship between the local data pool owner
+ * 				and the LocalDataPoolManager.
  * @details
- * Any class implementing this interface shall also have a LocalDataPoolManager
- * member class which contains the actual pool data structure
- * and exposes the public interface for it.
- * This is required because the pool entries are templates, which makes
- * specifying an interface rather difficult. The local data pool can be
- * accessed by using the LocalPoolVariable, LocalPoolVector or LocalDataSet
- * classes.
+ * Any class implementing this interface shall also have a LocalDataPoolManager member class which
+ * contains the actual pool data structure and exposes the public interface for it.
+ * The local data pool can be accessed using helper classes by using the
+ * LocalPoolVariable, LocalPoolVector or LocalDataSet classes. Every local pool variable can
+ * be uniquely identified by a global pool ID (gp_id_t) and every dataset tied
+ * to a pool manager can be uniqely identified by a global structure ID (sid_t).
  *
- * Architectural Note:
- * This could be circumvented by using a wrapper/accessor function or
- * implementing the templated function in this interface..
- * The first solution sounds better than the second but
- * the LocalPoolVariable classes are templates as well, so this just shifts
- * the problem somewhere else. Interfaces are nice, but the most
- * pragmatic solution I found was to offer the client the full interface
- * of the LocalDataPoolManager.
  */
 class HasLocalDataPoolIF {
+	friend class HasLocalDpIFManagerAttorney;
+	friend class HasLocalDpIFUserAttorney;
 public:
 	virtual~ HasLocalDataPoolIF() {};
 
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
-
-    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
-    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
-
 	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
 	virtual object_id_t getObjectId() const = 0;
@@ -59,13 +47,9 @@ public:
 	 * The manager instance shall also be passed to this function.
 	 * It can be used to subscribe for periodic packets for for updates.
 	 */
-	virtual ReturnValue_t initializeLocalDataPool(
-	        LocalDataPool& localDataPoolMap,
+	virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
 	        LocalDataPoolManager& poolManager) = 0;
 
-	/** Can be used to get a handle to the local data pool manager. */
-	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
-
 	/**
 	 * Returns the minimum sampling frequency in milliseconds, which will
 	 * usually be the period the pool owner performs its periodic operation.
@@ -73,40 +57,17 @@ public:
 	 */
 	virtual uint32_t getPeriodicOperationFrequency() const = 0;
 
-	/**
-	 * This function is used by the pool manager to get a valid dataset
-     * from a SID
-	 * @param sid Corresponding structure ID
-	 * @return
-	 */
-	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
-
-	/**
-	 * Similar to the function above, but used to get a local pool variable
-	 * handle. This is only needed for update notifications, so it is not
-	 * defined as abstract.
-	 * @param localPoolId
-	 * @return
-	 */
-	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
-	            << ". Returning nullptr!" << std::endl;
-#endif
-	    return nullptr;
-	}
-
     /**
      * @brief   This function will be called by the manager if an update
      *          notification is received.
-     * @details
+     * @details  HasLocalDataPoolIF
      * Can be overriden by the child class to handle changed datasets.
      * @param sid
      * @param storeId If a snapshot was requested, data will be located inside
      * the IPC store with this store ID.
      */
     virtual void handleChangedDataset(sid_t sid,
-            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
+    		store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
         return;
     }
 
@@ -124,18 +85,68 @@ public:
         return;
     }
 
-	/* These function can be implemented by pool owner, as they are required
-	 * by the housekeeping message interface */
+	/**
+	 * These function can be implemented by pool owner, if they are required
+	 * and used by the housekeeping message interface.
+	 * */
 	virtual ReturnValue_t addDataSet(sid_t sid) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
 	virtual ReturnValue_t removeDataSet(sid_t sid) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
-	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
-	        float newIntervalSeconds) {
+	virtual ReturnValue_t changeCollectionInterval(sid_t sid, float newIntervalSeconds) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
+
+	/**
+	 * This function can be used by data pool consumers to retrieve a handle
+	 * which allows subscriptions to dataset and variable updates in form of messages.
+	 * The consumers can then read the most recent variable value by calling read with
+	 * an own pool variable or set instance or using the deserialized snapshot data.
+	 * @return
+	 */
+	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
+
+protected:
+
+	/**
+	 * Accessor handle required for internal handling. Not intended for users and therefore
+	 * declared protected. Users should instead use pool variables, sets or the subscription
+	 * interface to access pool entries.
+	 * @return
+	 */
+	virtual AccessPoolManagerIF* getAccessorHandle() = 0;
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID. This function is protected to prevent users from
+     * using raw data set pointers which could not be thread-safe. Users
+     * should use the #ProvidesDataPoolSubscriptionIF.
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
+
+	/**
+	 * Similar to the function above, but used to get a local pool variable
+	 * handle. This is only needed for update notifications, so it is not
+	 * defined as abstract. This function is protected to prevent users from
+     * using raw pool variable pointers which could not be thread-safe.
+     * Users should use the #ProvidesDataPoolSubscriptionIF.
+	 * @param localPoolId
+	 * @return
+	 */
+	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
+	            << ". Returning nullptr!" << std::endl;
+#else
+	    sif::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
+	    		"Not overriden. Returning nullptr!\n");
+#endif
+	    return nullptr;
+	}
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 24516aad5..462ef17fa 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,11 +1,13 @@
+#include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
+#include "internal/LocalPoolDataSetAttorney.h"
+#include "internal/HasLocalDpIFManagerAttorney.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
-
 #include "../timemanager/CCSDSTime.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
@@ -14,797 +16,896 @@
 #include <array>
 #include <cmath>
 
-object_id_t LocalDataPoolManager::defaultHkDestination =
-        objects::PUS_SERVICE_3_HOUSEKEEPING;
+object_id_t LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING;
 
-LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
-        MessageQueueIF* queueToUse, bool appendValidityBuffer):
-                        appendValidityBuffer(appendValidityBuffer) {
-    if(owner == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                << "Invalid supplied owner!" << std::endl;
-#endif
-        return;
-    }
-    this->owner = owner;
-    mutex = MutexFactory::instance()->createMutex();
-    if(mutex == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                << "Could not create mutex." << std::endl;
-#endif
-    }
+LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+		bool appendValidityBuffer):
+		appendValidityBuffer(appendValidityBuffer) {
+	if(owner == nullptr) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
+				"Invalid supplied owner");
+		return;
+	}
+	this->owner = owner;
+	mutex = MutexFactory::instance()->createMutex();
+	if(mutex == nullptr) {
+		printWarningOrError(sif::OutputTypes::OUT_ERROR,
+				"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
+				"Could not create mutex");
+	}
 
-    hkQueue = queueToUse;
+	hkQueue = queueToUse;
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
-    if(queueToUse == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::initialize: "
-                << std::hex << "0x" << owner->getObjectId() << ". Supplied "
-                << "queue invalid!" << std::dec << std::endl;
-#endif
-    }
-    hkQueue = queueToUse;
+	if(queueToUse == nullptr) {
+		// error, all destinations invalid
+		printWarningOrError(sif::OutputTypes::OUT_ERROR,
+				"initialize", QUEUE_OR_DESTINATION_INVALID);
+	}
+	hkQueue = queueToUse;
 
-    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-    if(ipcStore == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::initialize: "
-                << std::hex << "0x" << owner->getObjectId() << ": Could not "
-                << "set IPC store." <<std::dec << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if(ipcStore == nullptr) {
+		// error, all destinations invalid
+		printWarningOrError(sif::OutputTypes::OUT_ERROR,
+				"initialize", HasReturnvaluesIF::RETURN_FAILED,
+				"Could not set IPC store.");
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
 
 
-    if(defaultHkDestination != objects::NO_OBJECT) {
-        AcceptsHkPacketsIF* hkPacketReceiver =
-                objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
-        if(hkPacketReceiver != nullptr) {
-            hkDestinationId = hkPacketReceiver->getHkQueue();
-        }
-        else {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                    << "Default HK destination object is invalid!" << std::endl;
-#endif
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-    }
+	if(defaultHkDestination != objects::NO_OBJECT) {
+		AcceptsHkPacketsIF* hkPacketReceiver =
+				objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
+		if(hkPacketReceiver != nullptr) {
+			hkDestinationId = hkPacketReceiver->getHkQueue();
+		}
+		else {
+			printWarningOrError(sif::OutputTypes::OUT_ERROR,
+					"initialize", QUEUE_OR_DESTINATION_INVALID);
+			return QUEUE_OR_DESTINATION_INVALID;
+		}
+	}
 
-    return HasReturnvaluesIF::RETURN_OK;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
-        uint8_t nonDiagInvlFactor) {
-    setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
-    return initializeHousekeepingPoolEntriesOnce();
+		uint8_t nonDiagInvlFactor) {
+	setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
+	return initializeHousekeepingPoolEntriesOnce();
 }
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
-    if(not mapInitialized) {
-        ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
-                *this);
-        if(result == HasReturnvaluesIF::RETURN_OK) {
-            mapInitialized = true;
-        }
-        return result;
-    }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "HousekeepingManager: The map should only be initialized "
-            << "once!" << std::endl;
-#endif
-    return HasReturnvaluesIF::RETURN_OK;
+	if(not mapInitialized) {
+		ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
+				*this);
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			mapInitialized = true;
+		}
+		return result;
+	}
+
+	printWarningOrError(sif::OutputTypes::OUT_WARNING,
+			"initialize", HasReturnvaluesIF::RETURN_FAILED,
+			"The map should only be initialized once");
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
-    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-    for(auto& receiver: hkReceiversMap) {
-        switch(receiver.reportingType) {
-        case(ReportingType::PERIODIC): {
-            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-                // Periodic packets shall only be generated from datasets.
-                continue;
-            }
-            performPeriodicHkGeneration(receiver);
-            break;
-        }
-        case(ReportingType::UPDATE_HK): {
-            handleHkUpdate(receiver, status);
-            break;
-        }
-        case(ReportingType::UPDATE_NOTIFICATION): {
-            handleNotificationUpdate(receiver, status);
-            break;
-        }
-        case(ReportingType::UPDATE_SNAPSHOT): {
-            handleNotificationSnapshot(receiver, status);
-            break;
-        }
-        default:
-            // This should never happen.
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-    }
-    resetHkUpdateResetHelper();
-    return status;
+	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+	for(auto& receiver: hkReceiversMap) {
+		switch(receiver.reportingType) {
+		case(ReportingType::PERIODIC): {
+			if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+				// Periodic packets shall only be generated from datasets.
+				continue;
+			}
+			performPeriodicHkGeneration(receiver);
+			break;
+		}
+		case(ReportingType::UPDATE_HK): {
+			handleHkUpdate(receiver, status);
+			break;
+		}
+		case(ReportingType::UPDATE_NOTIFICATION): {
+			handleNotificationUpdate(receiver, status);
+			break;
+		}
+		case(ReportingType::UPDATE_SNAPSHOT): {
+			handleNotificationSnapshot(receiver, status);
+			break;
+		}
+		default:
+			// This should never happen.
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	resetHkUpdateResetHelper();
+	return status;
 }
 
 ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
-        ReturnValue_t& status) {
-    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        // Update packets shall only be generated from datasets.
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-            receiver.dataId.sid);
-    if(dataSet->hasChanged()) {
-        // prepare and send update notification
-        ReturnValue_t result = generateHousekeepingPacket(
-                receiver.dataId.sid, dataSet, true);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            status = result;
-        }
-    }
-    handleChangeResetLogic(receiver.dataType, receiver.dataId,
-            dataSet);
-    return HasReturnvaluesIF::RETURN_OK;
+		ReturnValue_t& status) {
+	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+		// Update packets shall only be generated from datasets.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
+			receiver.dataId.sid);
+	if(dataSet->hasChanged()) {
+		// prepare and send update notification
+		ReturnValue_t result = generateHousekeepingPacket(
+				receiver.dataId.sid, dataSet, true);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+	}
+	handleChangeResetLogic(receiver.dataType, receiver.dataId,
+			dataSet);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
-        HkReceiver& receiver, ReturnValue_t& status) {
-    MarkChangedIF* toReset = nullptr;
-    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                receiver.dataId.localPoolId);
-        if(poolObj == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        if(poolObj->hasChanged()) {
-            // prepare and send update notification.
-            CommandMessage notification;
-            HousekeepingMessage::setUpdateNotificationVariableCommand(
-                    &notification, receiver.dataId.localPoolId);
-            ReturnValue_t result = hkQueue->sendMessage(
-                    receiver.destinationQueue, &notification);
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                status = result;
-            }
-            toReset = poolObj;
-        }
+ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receiver,
+		ReturnValue_t& status) {
+	MarkChangedIF* toReset = nullptr;
+	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+		LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
+				receiver.dataId.localPoolId);
+		//LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
+		if(poolObj == nullptr) {
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
+			return POOLOBJECT_NOT_FOUND;
+		}
+		if(poolObj->hasChanged()) {
+			// prepare and send update notification.
+			CommandMessage notification;
+			HousekeepingMessage::setUpdateNotificationVariableCommand(&notification,
+					receiver.dataId.localPoolId);
+			ReturnValue_t result = hkQueue->sendMessage(
+					receiver.destinationQueue, &notification);
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				status = result;
+			}
+			toReset = poolObj;
+		}
 
-    }
-    else {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                receiver.dataId.sid);
-        if(dataSet == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        if(dataSet->hasChanged()) {
-            // prepare and send update notification
-            CommandMessage notification;
-            HousekeepingMessage::setUpdateNotificationSetCommand(
-                    &notification, receiver.dataId.sid);
-            ReturnValue_t result = hkQueue->sendMessage(
-                    receiver.destinationQueue, &notification);
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                status = result;
-            }
-            toReset = dataSet;
-        }
-    }
-    if(toReset != nullptr) {
-        handleChangeResetLogic(receiver.dataType,
-                receiver.dataId, toReset);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
+				receiver.dataId.sid);
+		if(dataSet == nullptr) {
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"handleNotificationUpdate", DATASET_NOT_FOUND);
+			return DATASET_NOT_FOUND;
+		}
+		if(dataSet->hasChanged()) {
+			// prepare and send update notification
+			CommandMessage notification;
+			HousekeepingMessage::setUpdateNotificationSetCommand(
+					&notification, receiver.dataId.sid);
+			ReturnValue_t result = hkQueue->sendMessage(
+					receiver.destinationQueue, &notification);
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				status = result;
+			}
+			toReset = dataSet;
+		}
+	}
+	if(toReset != nullptr) {
+		handleChangeResetLogic(receiver.dataType,
+				receiver.dataId, toReset);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
-        HkReceiver& receiver, ReturnValue_t& status) {
-    MarkChangedIF* toReset = nullptr;
-    // check whether data has changed and send messages in case it has.
-    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                receiver.dataId.localPoolId);
-        if(poolObj == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
+		HkReceiver& receiver, ReturnValue_t& status) {
+	MarkChangedIF* toReset = nullptr;
+	// check whether data has changed and send messages in case it has.
+	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+		LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
+				receiver.dataId.localPoolId);
+		if(poolObj == nullptr) {
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
+			return POOLOBJECT_NOT_FOUND;
+		}
 
-        if (not poolObj->hasChanged()) {
-            return HasReturnvaluesIF::RETURN_OK;
-        }
+		if (not poolObj->hasChanged()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
 
-        // prepare and send update snapshot.
-        timeval now;
-        Clock::getClock_timeval(&now);
-        CCSDSTime::CDS_short cds;
-        CCSDSTime::convertToCcsds(&cds, &now);
-        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-                sizeof(cds), owner->getPoolObjectHandle(
-                receiver.dataId.localPoolId));
+		// prepare and send update snapshot.
+		timeval now;
+		Clock::getClock_timeval(&now);
+		CCSDSTime::CDS_short cds;
+		CCSDSTime::convertToCcsds(&cds, &now);
+		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+				sizeof(cds), HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
+						receiver.dataId.localPoolId));
 
-        store_address_t storeId;
-        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
+		store_address_t storeId;
+		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 
-        CommandMessage notification;
-        HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
-                receiver.dataId.localPoolId, storeId);
-        result = hkQueue->sendMessage(receiver.destinationQueue,
-                &notification);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            status = result;
-        }
-        toReset = poolObj;
-    }
-    else {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                receiver.dataId.sid);
-        if(dataSet == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
+		CommandMessage notification;
+		HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
+				receiver.dataId.localPoolId, storeId);
+		result = hkQueue->sendMessage(receiver.destinationQueue,
+				&notification);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+		toReset = poolObj;
+	}
+	else {
+		LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
+				receiver.dataId.sid);
+		if(dataSet == nullptr) {
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"handleNotificationSnapshot", DATASET_NOT_FOUND);
+			return DATASET_NOT_FOUND;
+		}
 
-        if(not dataSet->hasChanged()) {
-            return HasReturnvaluesIF::RETURN_OK;
-        }
+		if(not dataSet->hasChanged()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
 
-        // prepare and send update snapshot.
-        timeval now;
-        Clock::getClock_timeval(&now);
-        CCSDSTime::CDS_short cds;
-        CCSDSTime::convertToCcsds(&cds, &now);
-        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-                sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+		// prepare and send update snapshot.
+		timeval now;
+		Clock::getClock_timeval(&now);
+		CCSDSTime::CDS_short cds;
+		CCSDSTime::convertToCcsds(&cds, &now);
+		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+				sizeof(cds), HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
+						receiver.dataId.sid));
 
-        store_address_t storeId;
-        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
+		store_address_t storeId;
+		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 
-        CommandMessage notification;
-        HousekeepingMessage::setUpdateSnapshotSetCommand(
-                &notification, receiver.dataId.sid, storeId);
-        result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            status = result;
-        }
-        toReset = dataSet;
+		CommandMessage notification;
+		HousekeepingMessage::setUpdateSnapshotSetCommand(
+				&notification, receiver.dataId.sid, storeId);
+		result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+		toReset = dataSet;
 
-    }
-    if(toReset != nullptr) {
-        handleChangeResetLogic(receiver.dataType,
-                receiver.dataId, toReset);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+	}
+	if(toReset != nullptr) {
+		handleChangeResetLogic(receiver.dataType,
+				receiver.dataId, toReset);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::addUpdateToStore(
-        HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
-    size_t updatePacketSize = updatePacket.getSerializedSize();
-    uint8_t *storePtr = nullptr;
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            updatePacket.getSerializedSize(), &storePtr);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    size_t serializedSize = 0;
-    result = updatePacket.serialize(&storePtr, &serializedSize,
-            updatePacketSize, SerializeIF::Endianness::MACHINE);
-    return result;;
+		HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
+	size_t updatePacketSize = updatePacket.getSerializedSize();
+	uint8_t *storePtr = nullptr;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			updatePacket.getSerializedSize(), &storePtr);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	size_t serializedSize = 0;
+	result = updatePacket.serialize(&storePtr, &serializedSize,
+			updatePacketSize, SerializeIF::Endianness::MACHINE);
+	return result;;
 }
 
 void LocalDataPoolManager::handleChangeResetLogic(
-        DataType type, DataId dataId, MarkChangedIF* toReset) {
-    if(hkUpdateResetList == nullptr) {
-        // config error!
-        return;
-    }
+		DataType type, DataId dataId, MarkChangedIF* toReset) {
+	if(hkUpdateResetList == nullptr) {
+		// config error!
+		return;
+	}
+	HkUpdateResetList& listRef = *hkUpdateResetList;
+	for(auto& changeInfo: listRef) {
+		if(changeInfo.dataType != type) {
+			continue;
+		}
+		if((changeInfo.dataType == DataType::DATA_SET) and
+				(changeInfo.dataId.sid != dataId.sid)) {
+			continue;
+		}
+		if((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
+				(changeInfo.dataId.localPoolId != dataId.localPoolId)) {
+			continue;
+		}
 
-    for(auto& changeInfo: *hkUpdateResetList) {
-        if(changeInfo.dataType != type) {
-            continue;
-        }
-        if((changeInfo.dataType == DataType::DATA_SET) and
-                (changeInfo.dataId.sid != dataId.sid)) {
-            continue;
-        }
-        if((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
-                (changeInfo.dataId.localPoolId != dataId.localPoolId)) {
-            continue;
-        }
-
-        if(changeInfo.updateCounter <= 1) {
-            toReset->setChanged(false);
-        }
-        if(changeInfo.currentUpdateCounter == 0) {
-            toReset->setChanged(false);
-        }
-        else {
-            changeInfo.currentUpdateCounter--;
-        }
-        return;
-    }
+		// only one update recipient, we can reset changes status immediately.
+		if(changeInfo.updateCounter <= 1) {
+			toReset->setChanged(false);
+		}
+		// All recipients have been notified, reset the changed flag.
+		if(changeInfo.currentUpdateCounter <= 1) {
+			toReset->setChanged(false);
+			changeInfo.currentUpdateCounter = 0;
+		}
+		// Not all recipiens have been notified yet, decrement.
+		else {
+			changeInfo.currentUpdateCounter--;
+		}
+		return;
+	}
 }
 
 void LocalDataPoolManager::resetHkUpdateResetHelper() {
-    if(hkUpdateResetList == nullptr) {
-        return;
-    }
+	if(hkUpdateResetList == nullptr) {
+		return;
+	}
 
-    for(auto& changeInfo: *hkUpdateResetList) {
-        changeInfo.currentUpdateCounter = changeInfo.updateCounter;
-    }
+	for(auto& changeInfo: *hkUpdateResetList) {
+		changeInfo.currentUpdateCounter = changeInfo.updateCounter;
+	}
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
-        bool enableReporting, float collectionInterval, bool isDiagnostics,
-        object_id_t packetDestination) {
-    AcceptsHkPacketsIF* hkReceiverObject =
-            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-    if(hkReceiverObject == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-                << " Invalid receiver!"<< std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+		bool enableReporting, float collectionInterval, bool isDiagnostics,
+		object_id_t packetDestination) {
+	AcceptsHkPacketsIF* hkReceiverObject =
+			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	if(hkReceiverObject == nullptr) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
+		return QUEUE_OR_DESTINATION_INVALID;
+	}
 
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataId.sid = sid;
-    hkReceiver.reportingType = ReportingType::PERIODIC;
-    hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataId.sid = sid;
+	hkReceiver.reportingType = ReportingType::PERIODIC;
+	hkReceiver.dataType = DataType::DATA_SET;
+	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet != nullptr) {
-        dataSet->setReportingEnabled(enableReporting);
-        dataSet->setDiagnostic(isDiagnostics);
-        dataSet->initializePeriodicHelper(collectionInterval,
-                owner->getPeriodicOperationFrequency(), isDiagnostics);
-    }
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet != nullptr) {
+		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enableReporting);
+		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
+		LocalPoolDataSetAttorney::initializePeriodicHelper(*dataSet, collectionInterval,
+				owner->getPeriodicOperationFrequency(), isDiagnostics);
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
-    return HasReturnvaluesIF::RETURN_OK;
+	hkReceiversMap.push_back(hkReceiver);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 
 ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
-        bool isDiagnostics, bool reportingEnabled,
-        object_id_t packetDestination) {
-    AcceptsHkPacketsIF* hkReceiverObject =
-            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-    if(hkReceiverObject == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-                << " Invalid receiver!"<< std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+		bool isDiagnostics, bool reportingEnabled,
+		object_id_t packetDestination) {
+	AcceptsHkPacketsIF* hkReceiverObject =
+			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	if(hkReceiverObject == nullptr) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
+		return QUEUE_OR_DESTINATION_INVALID;
+	}
 
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataId.sid = sid;
-    hkReceiver.reportingType = ReportingType::UPDATE_HK;
-    hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataId.sid = sid;
+	hkReceiver.reportingType = ReportingType::UPDATE_HK;
+	hkReceiver.dataType = DataType::DATA_SET;
+	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet != nullptr) {
-        dataSet->setReportingEnabled(true);
-        dataSet->setDiagnostic(isDiagnostics);
-    }
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet != nullptr) {
+		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, true);
+		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 
-    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-    return HasReturnvaluesIF::RETURN_OK;
+	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
-        const uint32_t setId, object_id_t destinationObject,
-        MessageQueueId_t targetQueueId, bool generateSnapshot) {
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.dataId.sid = sid_t(this->getOwner()->getObjectId(), setId);
-    hkReceiver.destinationQueue = targetQueueId;
-    hkReceiver.objectId = destinationObject;
-    if(generateSnapshot) {
-        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
-    }
-    else {
-        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
-    }
+		const uint32_t setId, object_id_t destinationObject,
+		MessageQueueId_t targetQueueId, bool generateSnapshot) {
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataType = DataType::DATA_SET;
+	hkReceiver.dataId.sid = sid_t(owner->getObjectId(), setId);
+	hkReceiver.destinationQueue = targetQueueId;
+	hkReceiver.objectId = destinationObject;
+	if(generateSnapshot) {
+		hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+	}
+	else {
+		hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 
-    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-    return HasReturnvaluesIF::RETURN_OK;
+	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessages(
-        const lp_id_t localPoolId, object_id_t destinationObject,
-        MessageQueueId_t targetQueueId, bool generateSnapshot) {
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
-    hkReceiver.dataId.localPoolId = localPoolId;
-    hkReceiver.destinationQueue = targetQueueId;
-    hkReceiver.objectId = destinationObject;
-    if(generateSnapshot) {
-        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
-    }
-    else {
-        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
-    }
+		const lp_id_t localPoolId, object_id_t destinationObject,
+		MessageQueueId_t targetQueueId, bool generateSnapshot) {
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
+	hkReceiver.dataId.localPoolId = localPoolId;
+	hkReceiver.destinationQueue = targetQueueId;
+	hkReceiver.objectId = destinationObject;
+	if(generateSnapshot) {
+		hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+	}
+	else {
+		hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 
-    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-    return HasReturnvaluesIF::RETURN_OK;
+	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType,
-        DataId dataId) {
-    if(hkUpdateResetList == nullptr) {
-        hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
-    }
+		DataId dataId) {
+	if(hkUpdateResetList == nullptr) {
+		hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
+	}
 
-    for(auto& updateResetStruct: *hkUpdateResetList) {
-        if(dataType == DataType::DATA_SET) {
-            if(updateResetStruct.dataId.sid == dataId.sid) {
-                updateResetStruct.updateCounter++;
-                updateResetStruct.currentUpdateCounter++;
-                return;
-            }
-        }
-        else {
-            if(updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
-                updateResetStruct.updateCounter++;
-                updateResetStruct.currentUpdateCounter++;
-                return;
-            }
-        }
+	for(auto& updateResetStruct: *hkUpdateResetList) {
+		if(dataType == DataType::DATA_SET) {
+			if(updateResetStruct.dataId.sid == dataId.sid) {
+				updateResetStruct.updateCounter++;
+				updateResetStruct.currentUpdateCounter++;
+				return;
+			}
+		}
+		else {
+			if(updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
+				updateResetStruct.updateCounter++;
+				updateResetStruct.currentUpdateCounter++;
+				return;
+			}
+		}
 
-    }
-    HkUpdateResetHelper hkUpdateResetHelper;
-    hkUpdateResetHelper.currentUpdateCounter = 1;
-    hkUpdateResetHelper.updateCounter = 1;
-    hkUpdateResetHelper.dataType = dataType;
-    if(dataType == DataType::DATA_SET) {
-        hkUpdateResetHelper.dataId.sid = dataId.sid;
-    }
-    else {
-        hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
-    }
-    hkUpdateResetList->push_back(hkUpdateResetHelper);
+	}
+	HkUpdateResetHelper hkUpdateResetHelper;
+	hkUpdateResetHelper.currentUpdateCounter = 1;
+	hkUpdateResetHelper.updateCounter = 1;
+	hkUpdateResetHelper.dataType = dataType;
+	if(dataType == DataType::DATA_SET) {
+		hkUpdateResetHelper.dataId.sid = dataId.sid;
+	}
+	else {
+		hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
+	}
+	hkUpdateResetList->push_back(hkUpdateResetHelper);
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-        CommandMessage* message) {
-    Command_t command = message->getCommand();
-    sid_t sid = HousekeepingMessage::getSid(message);
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    switch(command) {
-    // Houskeeping interface handling.
-    case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-        result = togglePeriodicGeneration(sid, true, true);
-        break;
-    }
+		CommandMessage* message) {
+	Command_t command = message->getCommand();
+	sid_t sid = HousekeepingMessage::getSid(message);
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	switch(command) {
+	// Houskeeping interface handling.
+	case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+		result = togglePeriodicGeneration(sid, true, true);
+		break;
+	}
 
-    case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-        result = togglePeriodicGeneration(sid, false, true);
-        break;
-    }
+	case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+		result = togglePeriodicGeneration(sid, false, true);
+		break;
+	}
 
-    case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
-        result = togglePeriodicGeneration(sid, true, false);
-        break;
-    }
+	case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
+		result = togglePeriodicGeneration(sid, true, false);
+		break;
+	}
 
-    case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
-        result = togglePeriodicGeneration(sid, false, false);
-        break;
-    }
+	case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
+		result = togglePeriodicGeneration(sid, false, false);
+		break;
+	}
 
-    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
-                        return generateSetStructurePacket(sid, true);
-    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-                        return generateSetStructurePacket(sid, false);
-    case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
-    case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
-        float newCollIntvl = 0;
-        HousekeepingMessage::getCollectionIntervalModificationCommand(message,
-                &newCollIntvl);
-        if(command == HousekeepingMessage::
-                MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
-            result = changeCollectionInterval(sid, newCollIntvl, true);
-        }
-        else {
-            result = changeCollectionInterval(sid, newCollIntvl, false);
-        }
-        break;
-    }
+	case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES): {
+		return generateSetStructurePacket(sid, true);
+	}
 
-    case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
-    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-        if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
-                and dataSet->isDiagnostics()) {
-            return WRONG_HK_PACKET_TYPE;
-        }
-        else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
-                and not dataSet->isDiagnostics()) {
-            return WRONG_HK_PACKET_TYPE;
-        }
-        return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
-                dataSet, true);
-    }
+	case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
+		return generateSetStructurePacket(sid, false);
+	}
+	case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
+	case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
+		float newCollIntvl = 0;
+		HousekeepingMessage::getCollectionIntervalModificationCommand(message,
+				&newCollIntvl);
+		if(command == HousekeepingMessage::
+				MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
+			result = changeCollectionInterval(sid, newCollIntvl, true);
+		}
+		else {
+			result = changeCollectionInterval(sid, newCollIntvl, false);
+		}
+		break;
+	}
 
-    // Notification handling.
-    case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
-        owner->handleChangedDataset(sid);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
-        lp_id_t locPoolId = HousekeepingMessage::
-                getUpdateNotificationVariableCommand(message);
-        owner->handleChangedPoolVariable(locPoolId);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
-        store_address_t storeId;
-        HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
-        owner->handleChangedDataset(sid, storeId);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
-        store_address_t storeId;
-        lp_id_t localPoolId = HousekeepingMessage::
-                getUpdateSnapshotVariableCommand(message, &storeId);
-        owner->handleChangedPoolVariable(localPoolId, storeId);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+	case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
+	case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
+		LocalPoolDataSetBase* dataSet =HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+		//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+		if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
+				and LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
+			return WRONG_HK_PACKET_TYPE;
+		}
+		else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
+				and not LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
+			return WRONG_HK_PACKET_TYPE;
+		}
+		return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+				dataSet, true);
+	}
 
-    default:
-        return CommandMessageIF::UNKNOWN_COMMAND;
-    }
+	// Notification handling.
+	case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
+		owner->handleChangedDataset(sid);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
+		lp_id_t locPoolId = HousekeepingMessage::
+				getUpdateNotificationVariableCommand(message);
+		owner->handleChangedPoolVariable(locPoolId);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
+		store_address_t storeId;
+		HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
+		owner->handleChangedDataset(sid, storeId);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
+		store_address_t storeId;
+		lp_id_t localPoolId = HousekeepingMessage::
+				getUpdateSnapshotVariableCommand(message, &storeId);
+		owner->handleChangedPoolVariable(localPoolId, storeId);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
 
-    CommandMessage reply;
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
-    }
-    else {
-        HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
-    }
-    hkQueue->sendMessage(hkDestinationId, &reply);
-    return result;
+	default:
+		return CommandMessageIF::UNKNOWN_COMMAND;
+	}
+
+	CommandMessage reply;
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
+	}
+	else {
+		HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
+	}
+	hkQueue->sendMessage(hkDestinationId, &reply);
+	return result;
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
-        lp_id_t localPoolId) {
-    auto poolIter = localPoolMap.find(localPoolId);
-    if (poolIter == localPoolMap.end()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "HousekeepingManager::fechPoolEntry:"
-                << " Pool entry not found." << std::endl;
-#endif
-        return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
-    }
-    poolIter->second->print();
-    return HasReturnvaluesIF::RETURN_OK;
+		lp_id_t localPoolId) {
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING, "printPoolEntry",
+				localpool::POOL_ENTRY_NOT_FOUND);
+		return localpool::POOL_ENTRY_NOT_FOUND;
+	}
+	poolIter->second->print();
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 MutexIF* LocalDataPoolManager::getMutexHandle() {
-    return mutex;
+	return mutex;
 }
 
 HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
-    return owner;
+	return owner;
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        LocalPoolDataSetBase* dataSet, bool forDownlink,
-        MessageQueueId_t destination) {
-    if(dataSet == nullptr) {
-        // Configuration error.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                << " Set ID not found or dataset not assigned!" << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+		LocalPoolDataSetBase* dataSet, bool forDownlink,
+		MessageQueueId_t destination) {
+	if(dataSet == nullptr) {
+		// Configuration error.
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"generateHousekeepingPacket",
+				DATASET_NOT_FOUND);
+		return DATASET_NOT_FOUND;
+	}
 
-    store_address_t storeId;
-    HousekeepingPacketDownlink hkPacket(sid, dataSet);
-    size_t serializedSize = 0;
-    ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
-            forDownlink, &serializedSize);
-    if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
-        return result;
-    }
+	store_address_t storeId;
+	HousekeepingPacketDownlink hkPacket(sid, dataSet);
+	size_t serializedSize = 0;
+	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
+			forDownlink, &serializedSize);
+	if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
+		return result;
+	}
 
-    // and now we set a HK message and send it the HK packet destination.
-    CommandMessage hkMessage;
-    if(dataSet->isDiagnostics()) {
-        HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
-    }
-    else {
-        HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
-    }
+	// and now we set a HK message and send it the HK packet destination.
+	CommandMessage hkMessage;
+	if(LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
+		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
+	}
+	else {
+		HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
+	}
 
-    if(hkQueue == nullptr) {
-        return QUEUE_OR_DESTINATION_NOT_SET;
-    }
-    if(destination == MessageQueueIF::NO_QUEUE) {
-        if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
-            // error, all destinations invalid
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        destination = hkDestinationId;
-    }
+	if(hkQueue == nullptr) {
+		// error, no queue available to send packet with.
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"generateHousekeepingPacket",
+				QUEUE_OR_DESTINATION_INVALID);
+		return QUEUE_OR_DESTINATION_INVALID;
+	}
+	if(destination == MessageQueueIF::NO_QUEUE) {
+		if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
+			// error, all destinations invalid
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"generateHousekeepingPacket",
+					QUEUE_OR_DESTINATION_INVALID);
+		}
+		destination = hkDestinationId;
+	}
 
-    return hkQueue->sendMessage(destination, &hkMessage);
+	return hkQueue->sendMessage(destination, &hkMessage);
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-        HousekeepingPacketDownlink& hkPacket,
-        store_address_t& storeId, bool forDownlink,
-        size_t* serializedSize) {
-    uint8_t* dataPtr = nullptr;
-    const size_t maxSize = hkPacket.getSerializedSize();
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            maxSize, &dataPtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
+		HousekeepingPacketDownlink& hkPacket,
+		store_address_t& storeId, bool forDownlink,
+		size_t* serializedSize) {
+	uint8_t* dataPtr = nullptr;
+	const size_t maxSize = hkPacket.getSerializedSize();
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			maxSize, &dataPtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
 
-    if(forDownlink) {
-        return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-                SerializeIF::Endianness::BIG);
-    }
-    return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-            SerializeIF::Endianness::MACHINE);
+	if(forDownlink) {
+		return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+				SerializeIF::Endianness::BIG);
+	}
+	return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+			SerializeIF::Endianness::MACHINE);
 }
 
 void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
-        uint8_t nonDiagInvlFactor) {
-    this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
+		uint8_t nonDiagInvlFactor) {
+	this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
 }
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
-    sid_t sid = receiver.dataId.sid;
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(not dataSet->getReportingEnabled()) {
-        return;
-    }
+	sid_t sid = receiver.dataId.sid;
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	if(dataSet == nullptr) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"performPeriodicHkGeneration",
+				DATASET_NOT_FOUND);
+		return;
+	}
 
-    if(dataSet->periodicHelper == nullptr) {
-        // Configuration error.
-        return;
-    }
+	if(not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet)) {
+		return;
+	}
 
-    if(not dataSet->periodicHelper->checkOpNecessary()) {
-        return;
-    }
+	PeriodicHousekeepingHelper* periodicHelper =
+			LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
 
-    ReturnValue_t result = generateHousekeepingPacket(
-            sid, dataSet, true);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        // configuration error
+	if(periodicHelper == nullptr) {
+		// Configuration error.
+		return;
+	}
+
+	if(periodicHelper->checkOpNecessary()) {
+		return;
+	}
+
+	ReturnValue_t result = generateHousekeepingPacket(
+			sid, dataSet, true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		// configuration error
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "LocalDataPoolManager::performHkOperation:"
-                << "0x" << std::hex << std::setfill('0') << std::setw(8)
-                << owner->getObjectId() << " Error generating "
-                << "HK packet" << std::setfill(' ') << std::dec << std::endl;
+		sif::warning << "LocalDataPoolManager::performHkOperation: "
+				<< "HK generation failed." << std::endl;
+#else
+		sif::printWarning("LocalDataPoolManager::performHkOperation: "
+				"HK generation failed.\n");
 #endif
-    }
+	}
 }
 
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
-        bool enable, bool isDiagnostics) {
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if((dataSet->isDiagnostics() and not isDiagnostics) or
-            (not dataSet->isDiagnostics() and isDiagnostics)) {
-        return WRONG_HK_PACKET_TYPE;
-    }
+		bool enable, bool isDiagnostics) {
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	if((LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and not isDiagnostics) or
+			(not LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    if((dataSet->getReportingEnabled() and enable) or
-            (not dataSet->getReportingEnabled() and not enable)) {
-        return REPORTING_STATUS_UNCHANGED;
-    }
+	if((LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and enable) or
+			(not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and not enable)) {
+		return REPORTING_STATUS_UNCHANGED;
+	}
 
-    dataSet->setReportingEnabled(enable);
-    return HasReturnvaluesIF::RETURN_OK;
+	LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enable);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
-        float newCollectionInterval, bool isDiagnostics) {
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    bool targetIsDiagnostics = dataSet->isDiagnostics();
-    if((targetIsDiagnostics and not isDiagnostics) or
-            (not targetIsDiagnostics and isDiagnostics)) {
-        return WRONG_HK_PACKET_TYPE;
-    }
+		float newCollectionInterval, bool isDiagnostics) {
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    if(dataSet->periodicHelper == nullptr) {
-        // config error
-        return PERIODIC_HELPER_INVALID;
-    }
+	PeriodicHousekeepingHelper* periodicHelper =
+			LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
 
-    dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
-    return HasReturnvaluesIF::RETURN_OK;
+	if(periodicHelper == nullptr) {
+		// config error
+		return PERIODIC_HELPER_INVALID;
+	}
+
+	periodicHelper->changeCollectionInterval(newCollectionInterval);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
-        bool isDiagnostics) {
-    // Get and check dataset first.
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                << " Set ID not found" << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+		bool isDiagnostics) {
+	// Get and check dataset first.
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	if(dataSet == nullptr) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"performPeriodicHkGeneration",
+				DATASET_NOT_FOUND);
+		return DATASET_NOT_FOUND;
+	}
 
 
-    bool targetIsDiagnostics = dataSet->isDiagnostics();
-    if((targetIsDiagnostics and not isDiagnostics) or
-            (not targetIsDiagnostics and isDiagnostics)) {
-        return WRONG_HK_PACKET_TYPE;
-    }
+	bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    bool valid = dataSet->isValid();
-    bool reportingEnabled = dataSet->getReportingEnabled();
-    float collectionInterval =
-            dataSet->periodicHelper->getCollectionIntervalInSeconds();
+	bool valid = dataSet->isValid();
+	bool reportingEnabled = LocalPoolDataSetAttorney::getReportingEnabled(*dataSet);
+	float collectionInterval = LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet)->
+			getCollectionIntervalInSeconds();
 
-    // Generate set packet which can be serialized.
-    HousekeepingSetPacket setPacket(sid,
-            reportingEnabled, valid, collectionInterval, dataSet);
-    size_t expectedSize = setPacket.getSerializedSize();
-    uint8_t* storePtr = nullptr;
-    store_address_t storeId;
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            expectedSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                << "Could not get free element from IPC store." << std::endl;
-#endif
-        return result;
-    }
+	// Generate set packet which can be serialized.
+	HousekeepingSetPacket setPacket(sid,
+			reportingEnabled, valid, collectionInterval, dataSet);
+	size_t expectedSize = setPacket.getSerializedSize();
+	uint8_t* storePtr = nullptr;
+	store_address_t storeId;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			expectedSize,&storePtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		printWarningOrError(sif::OutputTypes::OUT_ERROR,
+				"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
+				"Could not get free element from IPC store.");
+		return result;
+	}
 
-    // Serialize set packet into store.
-    size_t size = 0;
-    result = setPacket.serialize(&storePtr, &size, expectedSize,
-            SerializeIF::Endianness::BIG);
-    if(expectedSize != size) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "HousekeepingManager::generateSetStructurePacket: "
-                << "Expected size is not equal to serialized size" << std::endl;
-#endif
-    }
+	// Serialize set packet into store.
+	size_t size = 0;
+	result = setPacket.serialize(&storePtr, &size, expectedSize,
+			SerializeIF::Endianness::BIG);
+	if(expectedSize != size) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
+				"Expected size is not equal to serialized size");
+	}
 
-    // Send structure reporting reply.
-    CommandMessage reply;
-    if(isDiagnostics) {
-        HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
-                sid, storeId);
-    }
-    else {
-        HousekeepingMessage::setHkStuctureReportReply(&reply,
-                sid, storeId);
-    }
+	// Send structure reporting reply.
+	CommandMessage reply;
+	if(isDiagnostics) {
+		HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
+				sid, storeId);
+	}
+	else {
+		HousekeepingMessage::setHkStuctureReportReply(&reply,
+				sid, storeId);
+	}
 
-    hkQueue->reply(&reply);
-    return result;
+	hkQueue->reply(&reply);
+	return result;
+}
+
+void LocalDataPoolManager::clearReceiversList() {
+	// clear the vector completely and releases allocated memory.
+	HkReceivers().swap(hkReceiversMap);
+}
+
+MutexIF* LocalDataPoolManager::getLocalPoolMutex() {
+	return this->mutex;
+}
+
+object_id_t LocalDataPoolManager::getCreatorObjectId() const {
+	return owner->getObjectId();
+	//return owner->getObjectId();
+}
+
+void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
+		const char* functionName, ReturnValue_t error, const char* errorPrint) {
+	if(errorPrint == nullptr) {
+		if(error == DATASET_NOT_FOUND) {
+			errorPrint = "Dataset not found";
+		}
+		else if(error == POOLOBJECT_NOT_FOUND) {
+			errorPrint = "Pool Object not found";
+		}
+		else if(error == HasReturnvaluesIF::RETURN_FAILED) {
+			if(outputType == sif::OutputTypes::OUT_WARNING) {
+				errorPrint = "Generic Warning";
+			}
+			else {
+				errorPrint = "Generic error";
+			}
+		}
+		else if(error == QUEUE_OR_DESTINATION_INVALID) {
+			errorPrint = "Queue or destination not set";
+		}
+		else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
+			errorPrint = "Pool entry type conflict";
+		}
+		else if(error == localpool::POOL_ENTRY_NOT_FOUND) {
+			errorPrint = "Pool entry not found";
+		}
+		else {
+			errorPrint = "Unknown error";
+		}
+	}
+
+	if(outputType == sif::OutputTypes::OUT_WARNING) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::warning << "LocalDataPoolManager::" << functionName
+				<< ": Object ID " << std::setw(8) << std::setfill('0')
+				<< std::hex << owner->getObjectId() << " | " << errorPrint
+				<< std::dec << std::setfill(' ') << std::endl;
+#else
+		sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
+				owner->getObjectId(), errorPrint);
+#endif
+	}
+	else if(outputType == sif::OutputTypes::OUT_ERROR) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::error << "LocalDataPoolManager::" << functionName
+				<< ": Object ID " << std::setw(8) << std::setfill('0')
+				<< std::hex << owner->getObjectId() << " | " << errorPrint
+				<< std::dec << std::setfill(' ') << std::endl;
+#else
+		sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
+				owner->getObjectId(), errorPrint);
+#endif
+	}
+}
+
+LocalDataPoolManager* LocalDataPoolManager::getHkManagerHandle() {
+	return this;
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 0e98b90cb..580ac8b93 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,8 +1,10 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 #define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 
-#include "HasLocalDataPoolIF.h"
+#include "ProvidesDataPoolSubscriptionIF.h"
+#include "AccessLocalPoolF.h"
 
+#include "../serviceinterface/ServiceInterface.h"
 #include "../housekeeping/HousekeepingPacketDownlink.h"
 #include "../housekeeping/HousekeepingMessage.h"
 #include "../housekeeping/PeriodicHousekeepingHelper.h"
@@ -15,6 +17,7 @@
 #include "../ipc/MutexHelper.h"
 
 #include <map>
+#include <vector>
 
 namespace Factory {
 void setStaticFrameworkObjectIds();
@@ -22,6 +25,8 @@ void setStaticFrameworkObjectIds();
 
 class LocalPoolDataSetBase;
 class HousekeepingPacketUpdate;
+class HasLocalDataPoolIF;
+class LocalDataPool;
 
 /**
  * @brief 		This class is the managing instance for the local data pool.
@@ -47,19 +52,23 @@ class HousekeepingPacketUpdate;
  * Each pool entry has a valid state too.
  * @author 		R. Mueller
  */
-class LocalDataPoolManager {
-	template<typename T> friend class LocalPoolVariable;
-	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
-	friend class LocalPoolDataSetBase;
+class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF,
+		public AccessPoolManagerIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
+	//! Some classes using the pool manager directly need to access class internals of the
+	//! manager. The attorney provides granular control of access to these internals.
+	friend class LocalDpManagerAttorney;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x0);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_INVALID = MAKE_RETURN_CODE(0);
+
+    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(1);
+    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(2);
+    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(3);
+    static constexpr ReturnValue_t POOLOBJECT_NOT_FOUND = MAKE_RETURN_CODE(4);
+    static constexpr ReturnValue_t DATASET_NOT_FOUND = MAKE_RETURN_CODE(5);
 
-    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x01);
-    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x02);
-    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x03);
 
     /**
      * This constructor is used by a class which wants to implement
@@ -116,7 +125,7 @@ public:
 	 */
 	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
 			float collectionInterval, bool isDiagnostics,
-			object_id_t packetDestination = defaultHkDestination);
+			object_id_t packetDestination = defaultHkDestination) override;
 
 	/**
 	 * @brief   Subscribe for the  generation of packets if the dataset
@@ -130,7 +139,7 @@ public:
 	 */
     ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool reportingEnabled,
             bool isDiagnostics,
-            object_id_t packetDestination = defaultHkDestination);
+            object_id_t packetDestination = defaultHkDestination) override;
 
 	/**
 	 * @brief   Subscribe for a notification message which will be sent
@@ -149,7 +158,7 @@ public:
 	ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
 	        object_id_t destinationObject,
 	        MessageQueueId_t targetQueueId,
-	        bool generateSnapshot);
+	        bool generateSnapshot) override;
 
     /**
      * @brief   Subscribe for an notification message which will be sent if a
@@ -168,7 +177,9 @@ public:
     ReturnValue_t subscribeForVariableUpdateMessages(const lp_id_t localPoolId,
             object_id_t destinationObject,
             MessageQueueId_t targetQueueId,
-            bool generateSnapshot);
+            bool generateSnapshot) override;
+
+    MutexIF* getLocalPoolMutex() override;
 
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
@@ -247,8 +258,18 @@ public:
     LocalDataPoolManager(const LocalDataPoolManager &) = delete;
     LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 
+    /**
+     * This function can be used to clear the receivers list. This is
+     * intended for test functions and not for regular operations, because
+     * the insertion operations allocate dynamically.
+     */
+    void clearReceiversList();
+
+    object_id_t getCreatorObjectId() const;
+
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
 private:
-    LocalDataPool localPoolMap;
+    localpool::DataPool localPoolMap;
     //! Every housekeeping data manager has a mutex to protect access
     //! to it's data pool.
     MutexIF* mutex = nullptr;
@@ -367,6 +388,11 @@ private:
             ReturnValue_t& status);
 	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
 	        store_address_t& storeId);
+
+	void printWarningOrError(sif::OutputTypes outputType,
+			const char* functionName,
+			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+			const char* errorPrint = nullptr);
 };
 
 
@@ -375,20 +401,16 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
-		        "not found." << std::endl;
-#endif
-		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
+    			localpool::POOL_ENTRY_NOT_FOUND);
+		return localpool::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "HousekeepingManager::fetchPoolEntry:"
-				" Pool entry not found." << std::endl;
-#endif
-		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
+    			localpool::POOL_ENTRY_TYPE_CONFLICT);
+		return localpool::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index dbe34dfd3..5343a9c91 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -1,4 +1,8 @@
 #include "LocalPoolDataSetBase.h"
+#include "HasLocalDataPoolIF.h"
+#include "internal/HasLocalDpIFUserAttorney.h"
+
+#include "../serviceinterface/ServiceInterface.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../housekeeping/PeriodicHousekeepingHelper.h"
 #include "../serialize/SerializeAdapter.h"
@@ -15,15 +19,22 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
                 << "invalid!" << std::endl;
-#endif
+#else
+        sif::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+                "invalid!\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
     }
-    hkManager = hkOwner->getHkManagerHandle();
+    AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+
+    if(poolManager != nullptr) {
+        poolManager = accessor->getHkManagerHandle();
+    	mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
+    }
+
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
 
-    mutex = MutexFactory::instance()->createMutex();
-
     // Data creators get a periodic helper for periodic HK data generation.
     if(periodicHandling) {
         periodicHelper = new PeriodicHousekeepingHelper(this);
@@ -34,23 +45,34 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
-    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+	AccessPoolManagerIF* hkOwner = objectManager->get<AccessPoolManagerIF>(
             sid.objectId);
     if(hkOwner != nullptr) {
-    	hkManager = hkOwner->getHkManagerHandle();
+    	mutexIfSingleDataCreator = hkOwner->getLocalPoolMutex();
     }
-    this->sid = sid;
 
-    mutex = MutexFactory::instance()->createMutex();
+    this->sid = sid;
 }
 
+LocalPoolDataSetBase::LocalPoolDataSetBase(
+		PoolVariableIF **registeredVariablesArray,
+		const size_t maxNumberOfVariables, bool protectEveryReadCommitCall):
+		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+	this->setReadCommitProtectionBehaviour(protectEveryReadCommitCall);
+}
+
+
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
+	if(periodicHelper != nullptr) {
+		delete periodicHelper;
+	}
 }
 
-ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
-	if(hkManager != nullptr) {
-	    MutexIF* mutex = hkManager->getMutexHandle();
-	    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+ReturnValue_t LocalPoolDataSetBase::lockDataPool(
+		MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	if(mutexIfSingleDataCreator != nullptr) {
+	    return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -128,9 +150,8 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-	if(hkManager != nullptr) {
-	    MutexIF* mutex = hkManager->getMutexHandle();
-	    return mutex->unlockMutex();
+	if(mutexIfSingleDataCreator != nullptr) {
+	    return mutexIfSingleDataCreator->unlockMutex();
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -150,9 +171,12 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
                 size, maxSize, streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
-                    " error!" << std::endl;
-#endif
+            sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
+            		<< "Serialization error!" << std::endl;
+#else
+            sif::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
+            		"Serialization error!\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
             return result;
         }
     }
@@ -211,8 +235,11 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "Pool Raw Access: Bit setting invalid position"
+        sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
                 << std::endl;
+#else
+        sif::printWarning("LocalPoolDataSetBase::bitSetter: "
+        		"Invalid position!\n\r");
 #endif
         return;
     }
@@ -244,14 +271,10 @@ void LocalPoolDataSetBase::initializePeriodicHelper(
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-    // TODO: Make this configurable?
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
     this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
-    // TODO: Make this configurable?
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
     return changed;
 }
 
@@ -273,12 +296,10 @@ bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 }
 
 bool LocalPoolDataSetBase::isValid() const {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
     return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
     if(setEntriesRecursively) {
         for(size_t idx = 0; idx < this->getFillCount(); idx++) {
             registeredVariables[idx] -> setValid(valid);
@@ -287,8 +308,9 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     this->valid = valid;
 }
 
-void LocalPoolDataSetBase::setReadCommitProtectionBehaviour(
-		bool protectEveryReadCommit, uint32_t mutexTimeout) {
-	PoolDataSetBase::setReadCommitProtectionBehaviour(protectEveryReadCommit,
-			mutexTimeout);
+object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
+	if(poolManager != nullptr) {
+		return poolManager->getCreatorObjectId();
+	}
+	return objects::NO_OBJECT;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index d9b6a2212..5f17eeb68 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,16 +1,16 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
-#include "HasLocalDataPoolIF.h"
 #include "MarkChangedIF.h"
+#include "localPoolDefinitions.h"
 
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
-#include "../serialize/SerializeIF.h"
 
 #include <vector>
 
 class LocalDataPoolManager;
+class HasLocalDataPoolIF;
 class PeriodicHousekeepingHelper;
 
 /**
@@ -43,7 +43,7 @@ class PeriodicHousekeepingHelper;
  */
 class LocalPoolDataSetBase: public PoolDataSetBase,
         public MarkChangedIF {
-	friend class LocalDataPoolManager;
+	friend class LocalPoolDataSetAttorney;
 	friend class PeriodicHousekeepingHelper;
 public:
 	/**
@@ -57,8 +57,11 @@ public:
 	        const size_t maxNumberOfVariables, bool periodicHandling = true);
 
 	/**
-	 * @brief	Constructor for users of local pool data.
+	 * @brief	Constructor for users of the local pool data, which need
+	 *          to access data created by one (!) HK manager.
 	 * @details
+	 * Unlike the first constructor, no component for periodic handling
+	 * will be initiated.
 	 * @param sid Unique identifier of dataset consisting of object ID and
 	 * set ID.
 	 * @param registeredVariablesArray
@@ -67,6 +70,28 @@ public:
 	LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
+	/**
+	 * @brief	Simple constructor, if the dataset is not the owner by
+	 * 			a class with a HK manager.
+	 * @details
+	 * This constructor won't create components required for periodic handling
+	 * and it also won't try to deduce the HK manager because no SID is
+	 * supplied. This function should therefore be called by classes which need
+	 * to access pool variables from different creators.
+	 *
+	 * If the class is intended to access pool variables from different
+	 * creators, the third argument should be set to true. The mutex
+	 * properties can be set with #setReadCommitProtectionBehaviour .
+	 * @param registeredVariablesArray
+	 * @param maxNumberOfVariables
+	 * @param protectEveryReadCommitCall If the pool variables are created by
+	 * multiple creators, this flag can be set to protect all read and
+	 * commit calls separately.
+	 */
+	LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray,
+	        const size_t maxNumberOfVariables,
+			bool protectEveryReadCommitCall = true);
+
 	/**
 	 * @brief	The destructor automatically manages writing the valid
 	 * 			information of variables.
@@ -77,16 +102,6 @@ public:
 	 */
 	~LocalPoolDataSetBase();
 
-	/**
-	 * If the data is pulled from different local data pools, every read and
-	 * commit call should be mutex protected for thread safety.
-	 * This can be specified with the second parameter.
-	 * @param dataCreator
-	 * @param protectEveryReadCommit
-	 */
-	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
-			uint32_t mutexTimeout = 20);
-
 	void setValidityBufferGeneration(bool withValidityBuffer);
 
 	sid_t getSid() const;
@@ -136,10 +151,11 @@ public:
 	void setChanged(bool changed) override;
 	bool hasChanged() const override;
 
+	object_id_t getCreatorObjectId();
 protected:
 	sid_t sid;
-	uint32_t mutexTimeout = 20;
-	MutexIF* mutex = nullptr;
+	//! This mutex is used if the data is created by one object only.
+	MutexIF* mutexIfSingleDataCreator = nullptr;
 
 	bool diagnostic = false;
 	void setDiagnostic(bool diagnostics);
@@ -183,7 +199,9 @@ protected:
 	 * @details
 	 * It makes use of the lockDataPool method offered by the DataPool class.
 	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
+	ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) override;
+
 	/**
 	 * @brief	This is a small helper function to facilitate
 	 * 			unlocking the global data pool
@@ -192,8 +210,6 @@ protected:
 	 */
 	ReturnValue_t unlockDataPool() override;
 
-	LocalDataPoolManager* hkManager = nullptr;
-
 	/**
 	 * Set n-th bit of a byte, with n being the position from 0
 	 * (most significant bit) to 7 (least significant bit)
@@ -202,6 +218,7 @@ protected:
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
+	LocalDataPoolManager* poolManager = nullptr;
 
 };
 
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 4b57dede4..bd1bfa0f0 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,81 +1,128 @@
+#include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
+#include "internal/HasLocalDpIFUserAttorney.h"
+#include "HasLocalDataPoolIF.h"
 
-LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
-        HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
-        pool_rwm_t setReadWriteMode): localPoolId(poolId),
-        readWriteMode(setReadWriteMode) {
-    if(poolId == PoolVariableIF::NO_PARAMETER) {
+#include "../objectmanager/ObjectManagerIF.h"
+
+LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+		localPoolId(poolId), readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+				<< "which is the NO_PARAMETER value!" << std::endl;
 #endif
-    }
-    if(hkOwner == nullptr) {
+	}
+	if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
-                << "owner is a invalid!" << std::endl;
+		sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+				<< "owner is a invalid!" << std::endl;
 #endif
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-    if (dataSet != nullptr) {
-        dataSet->registerVariable(this);
-    }
+		return;
+	}
+	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+	hkManager = poolManAccessor->getHkManagerHandle();
+
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
 }
 
-LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
-        readWriteMode(setReadWriteMode) {
-    if(poolId == PoolVariableIF::NO_PARAMETER) {
+LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF *dataSet,
+		pool_rwm_t setReadWriteMode):
+				localPoolId(poolId), readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+				<< "which is the NO_PARAMETER value!" << std::endl;
 #endif
-    }
-    HasLocalDataPoolIF* hkOwner =
-            objectManager->get<HasLocalDataPoolIF>(poolOwner);
-    if(hkOwner == nullptr) {
+	}
+	HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(poolOwner);
+	if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalPoolVariable: The supplied pool owner did not "
-                << "implement the correct interface"
-                << " HasLocalDataPoolIF!" << std::endl;
+		sif::error << "LocalPoolVariable: The supplied pool owner did not "
+				<< "implement the correct interface"
+				<< " HasLocalDataPoolIF!" << std::endl;
 #endif
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-    if(dataSet != nullptr) {
-        dataSet->registerVariable(this);
-    }
+		return;
+	}
+	//hkManager = hkOwner->getHkManagerHandle();
+	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+	//hkManager = HasLocalDpIFUserAttorney::getHkManagerHandle(hkOwner);
+	hkManager = poolManAccessor->getHkManagerHandle();
+	if(dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
 }
 
 pool_rwm_t LocalPoolObjectBase::getReadWriteMode() const {
-    return readWriteMode;
+	return readWriteMode;
 }
 
 bool LocalPoolObjectBase::isValid() const {
-    return valid;
+	return valid;
 }
 
 void LocalPoolObjectBase::setValid(bool valid) {
-    this->valid = valid;
+	this->valid = valid;
 }
 
 lp_id_t LocalPoolObjectBase::getDataPoolId() const {
-    return localPoolId;
+	return localPoolId;
 }
 
 void LocalPoolObjectBase::setDataPoolId(lp_id_t poolId) {
-    this->localPoolId = poolId;
+	this->localPoolId = poolId;
 }
 
 void LocalPoolObjectBase::setChanged(bool changed) {
-    this->changed = changed;
+	this->changed = changed;
 }
 
 bool LocalPoolObjectBase::hasChanged() const {
-    return changed;
+	return changed;
 }
 
 void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
 	this->readWriteMode = newReadWriteMode;
 }
+
+void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
+		ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId) {
+#if FSFW_DISABLE_PRINTOUT == 0
+	const char* type = nullptr;
+	if(read) {
+		type = "read";
+	}
+	else {
+		type = "commit";
+	}
+
+	const char* errMsg = nullptr;
+	if(error == localpool::POOL_ENTRY_NOT_FOUND) {
+		errMsg = "Pool entry not found";
+	}
+	else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
+		errMsg = "Pool entry type conflict";
+	}
+	else if(error == PoolVariableIF::INVALID_READ_WRITE_MODE) {
+		errMsg = "Pool variable wrong read-write mode";
+	}
+	else if(error == PoolVariableIF::INVALID_POOL_ENTRY) {
+		errMsg = "Pool entry invalid";
+	}
+	else {
+		errMsg = "Unknown error code";
+	}
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	sif::warning << variableType << ": " << type << " call | " << errMsg << " | Owner: 0x"
+			<< std::hex << std::setw(8) << std::setfill('0') << objectId << std::dec
+			<< " LPID: " << lpId << std::endl;
+#else
+	sif::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
+			variableType, type, errMsg, objectId, lpId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
+}
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 7165fc242..2dddc2461 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -1,10 +1,15 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "MarkChangedIF.h"
-#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../objectmanager/SystemObjectIF.h"
 #include "../datapool/PoolVariableIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 
+class LocalDataPoolManager;
+class DataSetIF;
+class HasLocalDataPoolIF;
 
 class LocalPoolObjectBase: public PoolVariableIF,
         public HasReturnvaluesIF,
@@ -54,8 +59,10 @@ protected:
     ReadWriteMode_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
 
     //! @brief  Pointer to the class which manages the HK pool.
-    LocalDataPoolManager* hkManager;
+    LocalDataPoolManager* hkManager = nullptr;
 
+	void reportReadCommitError(const char* variableType,
+			ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId);
 };
 
 
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 84be54b10..859c8f08c 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -4,9 +4,12 @@
 #include "LocalPoolObjectBase.h"
 #include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
+#include "AccessLocalPoolF.h"
+#include "internal/LocalDpManagerAttorney.h"
 
 #include "../datapool/PoolVariableIF.h"
 #include "../datapool/DataSetIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerializeAdapter.h"
 
@@ -105,7 +108,9 @@ public:
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 *
 	 */
-	ReturnValue_t read(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
@@ -115,8 +120,21 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 
+	/**
+	 * @brief	This commit function can be used to set the pool variable valid
+	 * 			as well.
+	 * @param setValid
+	 * @param timeoutType
+	 * @param timeoutMs
+	 * @return
+	 */
+	ReturnValue_t commit(bool setValid, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
 
 	LocalPoolVariable<T> &operator=(const T& newValue);
 	LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
@@ -163,8 +181,6 @@ protected:
 	friend std::ostream& operator<< (std::ostream &out,
 			const LocalPoolVariable<U> &var);
 #endif
-
-private:
 };
 
 #include "LocalPoolVariable.tpp"
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index cd5117c80..6fd34171a 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -24,73 +24,91 @@ inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
 
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::read(dur_millis_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+inline ReturnValue_t LocalPoolVariable<T>::read(
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return readWithoutLock();
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVar: Invalid read write "
-				"mode for read() call." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK or poolEntry == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				<< std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << " and lp ID " << localPoolId
-				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
-#endif
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
+	//ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	if(result != RETURN_OK) {
+		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVariable", result,
+				false, ownerObjectId, localPoolId);
 		return result;
 	}
-	this->value = *(poolEntry->address);
-	this->valid = poolEntry->valid;
+
+	// Actually this should never happen..
+//	if(poolEntry->address == nullptr) {
+//		result = PoolVariableIF::INVALID_POOL_ENTRY;
+//		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+//		reportReadCommitError("LocalPoolVariable", result,
+//				false, ownerObjectId, localPoolId);
+//		return result;
+//	}
+
+	this->value = *(poolEntry->getDataPtr());
+	this->valid = poolEntry->getValid();
 	return RETURN_OK;
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	this->setValid(setValid);
+	return commit(timeoutType, timeoutMs);
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commit(
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return commitWithoutLock();
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVariable: Invalid read write "
-				 "mode for commit() call." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
+
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	//ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
 	if(result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
-				std::dec << " failed.\n" << std::flush;
-#endif
+		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVariable", result,
+				false, ownerObjectId, localPoolId);
 		return result;
 	}
-	*(poolEntry->address) = this->value;
-	poolEntry->valid = this->valid;
+
+	*(poolEntry->getDataPtr()) = this->value;
+	poolEntry->setValid(this->valid);
 	return RETURN_OK;
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
+inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer,
+		size_t* size, const size_t max_size,
+		SerializeIF::Endianness streamEndianness) const {
 	return SerializeAdapter::serialize(&value,
 			buffer, size ,max_size, streamEndianness);
 }
@@ -121,7 +139,8 @@ inline LocalPoolVariable<T>::operator T() const {
 }
 
 template<typename T>
-inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(const T& newValue) {
+inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(
+		const T& newValue) {
     value = newValue;
     return *this;
 }
@@ -134,7 +153,8 @@ inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
 }
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator ==(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator ==(
+		const LocalPoolVariable<T> &other) const {
 	return this->value == other.value;
 }
 
@@ -145,7 +165,8 @@ inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
 
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator !=(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator !=(
+		const LocalPoolVariable<T> &other) const {
 	return not (*this == other);
 }
 
@@ -156,7 +177,8 @@ inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
 
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator <(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator <(
+		const LocalPoolVariable<T> &other) const {
 	return this->value < other.value;
 }
 
@@ -167,7 +189,8 @@ inline bool LocalPoolVariable<T>::operator <(const T &other) const {
 
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator >(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator >(
+		const LocalPoolVariable<T> &other) const {
 	return not (*this < other);
 }
 
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 58face3cb..742556054 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -2,12 +2,14 @@
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 
 #include "LocalPoolObjectBase.h"
+#include "internal/LocalDpManagerAttorney.h"
+
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
 #include "../datapool/PoolVariableIF.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 
 /**
@@ -100,8 +102,8 @@ public:
 		return vectorSize;
 	}
 
-	T& operator [](int i);
-	const T &operator [](int i) const;
+	T& operator [](size_t i);
+	const T &operator [](size_t i) const;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t maxSize,
@@ -123,7 +125,10 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
+
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
@@ -133,7 +138,17 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
+
+	/**
+	 * @brief	This commit call also sets the validity of the pool entry.
+	 * @details
+	 */
+	ReturnValue_t commit(bool valid, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
 
 protected:
 	/**
@@ -157,12 +172,12 @@ protected:
 
 private:
 
-
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	// std::ostream is the type for object std::cout
 	template <typename U, uint16_t otherSize>
 	friend std::ostream& operator<< (std::ostream &out,
 	        const LocalPoolVector<U, otherSize> &var);
-
+#endif
 
 };
 
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 5c3b0ce01..acffebeec 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -24,98 +24,106 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
 				dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return readWithoutLock();
 }
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVar: Invalid read write "
-				"mode for read() call." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
 	memset(this->value, 0, vectorSize * sizeof(T));
 
 	if(result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << "and lp ID 0x" << localPoolId <<
-				std::dec << " failed." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+				localPoolId);
 		return result;
 	}
-	std::memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
-	this->valid = poolEntry->valid;
+	std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+	this->valid = poolEntry->getValid();
 	return RETURN_OK;
 }
 
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	this->setValid(valid);
+	return commit(timeoutType, timeoutMs);
+}
+
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
-		uint32_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return commitWithoutLock();
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVar: Invalid read write "
-				"mode for commit() call." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
 	if(result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
-				std::dec << " failed.\n" << std::flush;
-#endif
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
+				localPoolId);
 		return result;
 	}
-	std::memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
-	poolEntry->valid = this->valid;
+	std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+	poolEntry->setValid(this->valid);
 	return RETURN_OK;
 }
 
 template<typename T, uint16_t vectorSize>
-inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
-	if(i <= vectorSize) {
+inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
+	if(i < vectorSize) {
 		return value[i];
 	}
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
+#else
+	sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+			" last value!\n");
 #endif
-	return value[i];
+	return value[vectorSize - 1];
 }
 
 template<typename T, uint16_t vectorSize>
-inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
-	if(i <= vectorSize) {
+inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
+	if(i < vectorSize) {
 		return value[i];
 	}
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
+#else
+	sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+			" last value!\n");
 #endif
-	return value[i];
+	return value[vectorSize - 1];
 }
 
 template<typename T, uint16_t vectorSize>
@@ -153,6 +161,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
 	return result;
 }
 
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 template<typename T, uint16_t vectorSize>
 inline std::ostream& operator<< (std::ostream &out,
         const LocalPoolVector<T, vectorSize> &var) {
@@ -166,5 +175,6 @@ inline std::ostream& operator<< (std::ostream &out,
     out << "]";
     return out;
 }
+#endif
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_ */
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index 0510dbb50..6a816c1ff 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -1,7 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
 #define FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
 
-#include <fsfw/datapoollocal/LocalPoolDataSetBase.h>
+#include "LocalPoolDataSetBase.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include <FSFWConfig.h>
 
 /**
@@ -9,13 +10,17 @@
  */
 class PoolReadHelper {
 public:
-	PoolReadHelper(ReadCommitIF* readObject, uint32_t mutexTimeout = 20):
+	PoolReadHelper(ReadCommitIF* readObject,
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t mutexTimeout = 20):
 			readObject(readObject), mutexTimeout(mutexTimeout) {
 		if(readObject != nullptr) {
-			readResult = readObject->read(mutexTimeout);
-#if FSFW_PRINT_VERBOSITY_LEVEL == 1
+			readResult = readObject->read(timeoutType, mutexTimeout);
+#if FSFW_VERBOSE_LEVEL == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PoolReadHelper: Read failed!" << std::endl;
+#else
+			sif::printError("PoolReadHelper: Read failed!\n");
 #endif /* FSFW_PRINT_VERBOSITY_LEVEL == 1 */
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		}
@@ -27,7 +32,7 @@ public:
 
 	~PoolReadHelper() {
 		if(readObject != nullptr) {
-			readObject->commit(mutexTimeout);
+			readObject->commit(timeoutType, mutexTimeout);
 		}
 
 	}
@@ -35,6 +40,7 @@ public:
 private:
 	ReadCommitIF* readObject = nullptr;
 	ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
 	uint32_t mutexTimeout = 20;
 };
 
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
new file mode 100644
index 000000000..e6d6257e1
--- /dev/null
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -0,0 +1,84 @@
+#ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
+#define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
+
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
+#include <fsfw/ipc/messageQueueDefinitions.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+
+
+class ProvidesDataPoolSubscriptionIF {
+public:
+	virtual ~ProvidesDataPoolSubscriptionIF(){};
+
+	/**
+	 * @brief   Subscribe for the generation of periodic packets.
+	 * @details
+	 * This subscription mechanism will generally be used by the data creator
+	 * to generate housekeeping packets which are downlinked directly.
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid,
+			bool enableReporting,
+			float collectionInterval, bool isDiagnostics,
+			object_id_t packetDestination) = 0;
+
+
+	/**
+	 * @brief   Subscribe for the  generation of packets if the dataset
+	 *          is marked as changed.
+	 * @details
+	 * This subscription mechanism will generally be used by the data creator.
+	 * @param sid
+	 * @param isDiagnostics
+	 * @param packetDestination
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForUpdatePackets(sid_t sid,
+			bool reportingEnabled,
+			bool isDiagnostics,
+			object_id_t packetDestination) = 0;
+
+
+	/**
+	 * @brief   Subscribe for a notification message which will be sent
+	 *          if a dataset has changed.
+	 * @details
+	 * This subscription mechanism will generally be used internally by
+	 * other software components.
+	 * @param setId     Set ID of the set to receive update messages from.
+	 * @param destinationObject
+	 * @param targetQueueId
+	 * @param generateSnapshot If this is set to true, a copy of the current
+	 * data with a timestamp will be generated and sent via message.
+	 * Otherwise, only an notification message is sent.
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
+			object_id_t destinationObject,
+			MessageQueueId_t targetQueueId,
+			bool generateSnapshot) = 0;
+
+	/**
+	 * @brief   Subscribe for an notification message which will be sent if a
+	 *          pool variable has changed.
+	 * @details
+	 * This subscription mechanism will generally be used internally by
+	 * other software components.
+	 * @param localPoolId Pool ID of the pool variable
+	 * @param destinationObject
+	 * @param targetQueueId
+	 * @param generateSnapshot If this is set to true, a copy of the current
+	 * data with a timestamp will be generated and sent via message.
+	 * Otherwise, only an notification message is sent.
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForVariableUpdateMessages(
+			const lp_id_t localPoolId,
+			object_id_t destinationObject,
+			MessageQueueId_t targetQueueId,
+			bool generateSnapshot) = 0;
+
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_ */
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index 2e5a76fa9..713d435b1 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -6,6 +6,13 @@
 #include "../objectmanager/SystemObject.h"
 #include <vector>
 
+/**
+ * This local dataset variation can be used if the dataset is used concurrently across
+ * multiple threads. It provides a lock in addition to all other functionalities provided
+ * by the LocalPoolDataSetBase class.
+ *
+ * TODO: override and protect read, commit and some other calls used by pool manager.
+ */
 class SharedLocalDataSet: public SystemObject,
         public LocalPoolDataSetBase,
         public SharedDataSetIF {
diff --git a/datapoollocal/internal/CMakeLists.txt b/datapoollocal/internal/CMakeLists.txt
new file mode 100644
index 000000000..554f3b884
--- /dev/null
+++ b/datapoollocal/internal/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		HasLocalDpIFUserAttorney.cpp
+		HasLocalDpIFManagerAttorney.cpp
+)
diff --git a/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp b/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
new file mode 100644
index 000000000..bc07170f9
--- /dev/null
+++ b/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
@@ -0,0 +1,18 @@
+#include "HasLocalDpIFManagerAttorney.h"
+#include "../LocalPoolObjectBase.h"
+#include "../LocalPoolDataSetBase.h"
+#include "../HasLocalDataPoolIF.h"
+
+LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* clientIF,
+		sid_t sid) {
+	return clientIF->getDataSetHandle(sid);
+}
+
+LocalPoolObjectBase* HasLocalDpIFManagerAttorney::getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
+		lp_id_t localPoolId) {
+	return clientIF->getPoolObjectHandle(localPoolId);
+}
+
+object_id_t HasLocalDpIFManagerAttorney::getObjectId(HasLocalDataPoolIF* clientIF) {
+	return clientIF->getObjectId();
+}
diff --git a/datapoollocal/internal/HasLocalDpIFManagerAttorney.h b/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
new file mode 100644
index 000000000..ef180b37c
--- /dev/null
+++ b/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
@@ -0,0 +1,22 @@
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
+
+#include "../localPoolDefinitions.h"
+
+class HasLocalDataPoolIF;
+class LocalPoolDataSetBase;
+class LocalPoolObjectBase;
+
+class HasLocalDpIFManagerAttorney {
+
+	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* clientIF, sid_t sid);
+
+	static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
+			lp_id_t localPoolId);
+
+	static object_id_t getObjectId(HasLocalDataPoolIF* clientIF);
+
+	friend class LocalDataPoolManager;
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_ */
diff --git a/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp b/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
new file mode 100644
index 000000000..838204a76
--- /dev/null
+++ b/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
@@ -0,0 +1,7 @@
+#include "HasLocalDpIFUserAttorney.h"
+#include "../AccessLocalPoolF.h"
+#include "../HasLocalDataPoolIF.h"
+
+AccessPoolManagerIF* HasLocalDpIFUserAttorney::getAccessorHandle(HasLocalDataPoolIF *clientIF) {
+	return clientIF->getAccessorHandle();
+}
diff --git a/datapoollocal/internal/HasLocalDpIFUserAttorney.h b/datapoollocal/internal/HasLocalDpIFUserAttorney.h
new file mode 100644
index 000000000..a07c2d595
--- /dev/null
+++ b/datapoollocal/internal/HasLocalDpIFUserAttorney.h
@@ -0,0 +1,18 @@
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
+
+class HasLocalDataPoolIF;
+class AccessPoolManagerIF;
+
+class HasLocalDpIFUserAttorney {
+private:
+
+	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* clientIF);
+
+	friend class LocalPoolObjectBase;
+	friend class LocalPoolDataSetBase;
+
+};
+
+
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_ */
diff --git a/datapoollocal/internal/LocalDpManagerAttorney.h b/datapoollocal/internal/LocalDpManagerAttorney.h
new file mode 100644
index 000000000..1d72f607f
--- /dev/null
+++ b/datapoollocal/internal/LocalDpManagerAttorney.h
@@ -0,0 +1,32 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
+
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+
+/**
+ * @brief	This is a helper class implements the Attorney-Client idiom for access to
+ * 			LocalDataPoolManager internals
+ * @details
+ * This helper class provides better control over which classes are allowed to access
+ * LocalDataPoolManager internals in a granular and encapsulated way when compared to
+ * other methods like direct friend declarations. It allows these classes to use
+ * an explicit subset of the pool manager private/protected functions.
+ * See: https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Friendship_and_the_Attorney-Client
+ */
+class LocalDpManagerAttorney {
+private:
+	template<typename T> static ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
+			lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
+		return manager.fetchPoolEntry(localPoolId, poolEntry);
+	}
+
+	static MutexIF* getMutexHandle(LocalDataPoolManager& manager) {
+		return manager.getMutexHandle();
+	}
+
+
+	template<typename T> friend class LocalPoolVariable;
+	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_ */
diff --git a/datapoollocal/internal/LocalPoolDataSetAttorney.h b/datapoollocal/internal/LocalPoolDataSetAttorney.h
new file mode 100644
index 000000000..9804444af
--- /dev/null
+++ b/datapoollocal/internal/LocalPoolDataSetAttorney.h
@@ -0,0 +1,39 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
+
+#include "../LocalPoolDataSetBase.h"
+
+class LocalPoolDataSetAttorney {
+private:
+	static void setDiagnostic(LocalPoolDataSetBase& set, bool diagnostics) {
+		set.setDiagnostic(diagnostics);
+	}
+
+	static bool isDiagnostics(LocalPoolDataSetBase& set) {
+		return set.isDiagnostics();
+	}
+
+	static void initializePeriodicHelper(LocalPoolDataSetBase& set, float collectionInterval,
+			uint32_t minimumPeriodicIntervalMs,
+			bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5) {
+		set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs, isDiagnostics,
+				nonDiagIntervalFactor);
+	}
+
+	static void setReportingEnabled(LocalPoolDataSetBase& set, bool enabled) {
+		set.setReportingEnabled(enabled);
+	}
+
+	static bool getReportingEnabled(LocalPoolDataSetBase& set) {
+		return set.getReportingEnabled();
+	}
+
+	static PeriodicHousekeepingHelper* getPeriodicHelper(LocalPoolDataSetBase& set) {
+		return set.periodicHelper;
+	}
+
+	friend class LocalDataPoolManager;
+};
+
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_ */
diff --git a/datapoollocal/locPoolDefinitions.h b/datapoollocal/localPoolDefinitions.h
similarity index 68%
rename from datapoollocal/locPoolDefinitions.h
rename to datapoollocal/localPoolDefinitions.h
index 6e74d349a..3ff1feeda 100644
--- a/datapoollocal/locPoolDefinitions.h
+++ b/datapoollocal/localPoolDefinitions.h
@@ -1,10 +1,13 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
-#define FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_
 
-#include <cstdint>
+#include "../datapool/PoolEntryIF.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../objectmanager/frameworkObjects.h"
 
+#include <cstdint>
+#include <map>
+
 /**
  * @brief   Type definition for local pool entries.
  */
@@ -12,10 +15,21 @@ using lp_id_t = uint32_t;
 
 namespace localpool {
 static constexpr uint32_t INVALID_LPID = -1;
+
+static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
+
+static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
+static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+
+//! This is the core data structure of the local data pools. Users should insert all desired
+//! pool variables, using the std::map interface.
+using DataPool =  std::map<lp_id_t, PoolEntryIF*>;
+using DataPoolMapIter = DataPool::iterator;
+
 }
 
 /**
- * Used as a unique identifier for data sets.
+ * Used as a unique identifier for data sets. Consists of 4 byte object ID and 4 byte set ID.
  */
 union sid_t {
     static constexpr uint64_t INVALID_SID = -1;
@@ -57,7 +71,8 @@ union sid_t {
 };
 
 /**
- * Used as a global unique identifier for local pool variables.
+ * Used as a global unique identifier for local pool variables. Consists of 4 byte object ID
+ * and 4 byte local pool ID.
  */
 union gp_id_t {
 	static constexpr uint64_t INVALID_GPID = -1;
@@ -90,4 +105,4 @@ union gp_id_t {
     }
 };
 
-#endif /* FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_ */
diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 261e3d6d2..ed86e6e1f 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -9,18 +9,14 @@
 //! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! More FSFW related printouts.
-//! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_ENHANCED_PRINTOUT		0
+//! More FSFW related printouts depending on level. Useful for development.
+#define FSFW_VERBOSE_LEVEL			1
 
 //! Can be used to completely disable printouts, even the C stdio ones.
-#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
 	#define FSFW_DISABLE_PRINTOUT 	0
 #endif
 
-//! Can be used to enable additional debugging printouts for developing the FSFW
-#define FSFW_PRINT_VERBOSITY_LEVEL   0
-
 //! Can be used to disable the ANSI color sequences for C stdio.
 #define FSFW_COLORED_OUTPUT 		1
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1af6932ae..c40985255 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -2,7 +2,7 @@
 #include "AcceptsDeviceResponsesIF.h"
 #include "DeviceTmReportingWrapper.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
@@ -13,9 +13,6 @@
 #include "../subsystem/SubsystemBase.h"
 #include "../datapoollocal/LocalPoolVariable.h"
 
-#include <iomanip>
-
-
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
@@ -27,7 +24,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		actionHelper(this, nullptr), hkManager(this, nullptr),
+		actionHelper(this, nullptr), poolManager(this, nullptr),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
 		switchOffWasReported(false), childTransitionDelay(5000),
@@ -39,13 +36,8 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		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;
-#endif
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
+				HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
 	}
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
@@ -115,7 +107,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		doGetRead();
 		// This will be performed after datasets have been updated by the
 		// custom device implementation.
-		hkManager.performHkOperation();
+		poolManager.performHkOperation();
 		break;
 	default:
 		break;
@@ -132,30 +124,24 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	communicationInterface = objectManager->get<DeviceCommunicationIF>(
 			deviceCommunicationId);
 	if (communicationInterface == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DeviceHandlerBase::initialize: Communication interface "
-				"invalid." << std::endl;
-		sif::error << "Make sure it is set up properly and implements"
-				" DeviceCommunicationIF" << std::endl;
-#endif
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
+				ObjectManagerIF::CHILD_INIT_FAILED,
+				"Passed communication IF invalid");
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	    sif::error << "DeviceHandlerBase::initialize: Initializing "
-	            "communication interface failed!" << std::endl;
-#endif
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
+				ObjectManagerIF::CHILD_INIT_FAILED,
+				"ComIF initialization failed");
 	    return result;
 	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
-				"factory." << std::endl;
-#endif
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
+				ObjectManagerIF::CHILD_INIT_FAILED, "IPC Store not set up");
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -164,11 +150,15 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
+			printWarningOrError(sif::OutputTypes::OUT_ERROR,
+					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+					"Raw receiver object ID set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			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;
+#else
+			sif::printError("Make sure the raw receiver object is set up "
+					"properly and implements AcceptsDeviceResponsesIF\n");
 #endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
@@ -178,11 +168,15 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == nullptr) {
+			printWarningOrError(sif::OutputTypes::OUT_ERROR,
+					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+					"Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			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;
+			sif::error << "Make sure the power switcher object is set up "
+					<< "properly and implements PowerSwitchIF" << std::endl;
+#else
+			sif::printError("Make sure the power switcher object is set up "
+					"properly and implements PowerSwitchIF\n");
 #endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
@@ -216,7 +210,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-	result = hkManager.initialize(commandQueue);
+	result = poolManager.initialize(commandQueue);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -229,7 +223,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			thermalSet->heaterRequest.value =
 					ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-			thermalSet->commit(PoolVariableIF::VALID);
+			thermalSet->heaterRequest.setValid(true);
+			thermalSet->commit();
 		}
 
 	}
@@ -285,7 +280,7 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	result = hkManager.handleHousekeepingMessage(&command);
+	result = poolManager.handleHousekeepingMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
@@ -555,17 +550,17 @@ void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
 
 void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
 		uint32_t parameter) {
-//Check if we reply to a raw command.
+	// Check if we reply to a raw command.
 	if (cookieInfo.pendingCommand->first == RAW_COMMAND_ID) {
 		if (status == NO_REPLY_EXPECTED) {
 			status = RETURN_OK;
 		}
 		replyReturnvalueToCommand(status, parameter);
-		//Always delete data from a raw command.
+		// Always delete data from a raw command.
 		IPCStore->deleteData(storedRawData);
 		return;
 	}
-//Check if we were externally commanded.
+	// Check if we were externally commanded.
 	if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
 		MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
 		if (status == NO_REPLY_EXPECTED) {
@@ -580,15 +575,17 @@ void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
 
 void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 		ReturnValue_t status) {
-//No need to check if iter exists, as this is checked by callers. If someone else uses the method, add check.
+	// No need to check if iter exists, as this is checked by callers.
+	// If someone else uses the method, add check.
 	if (iter->second.command == deviceCommandMap.end()) {
 		//Is most likely periodic reply. Silent return.
 		return;
 	}
-//Check if more replies are expected. If so, do nothing.
+	// Check if more replies are expected. If so, do nothing.
 	DeviceCommandInfo* info = &(iter->second.command->second);
 	if (--info->expectedReplies == 0) {
-		//Check if it was transition or internal command. Don't send any replies in that case.
+		// Check if it was transition or internal command.
+		// Don't send any replies in that case.
 		if (info->sendReplyTo != NO_COMMANDER) {
 			actionHelper.finish(info->sendReplyTo, iter->first, status);
 		}
@@ -605,7 +602,7 @@ void DeviceHandlerBase::doSendWrite() {
 		if (result == RETURN_OK) {
 			cookieInfo.state = COOKIE_WRITE_SENT;
 		} else {
-			//always generate a failure event, so that FDIR knows what's up
+			// always generate a failure event, so that FDIR knows what's up
 			triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
 					cookieInfo.pendingCommand->first);
 			replyToCommand(result);
@@ -720,10 +717,9 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
 			if(foundLen == 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
-			            " Packet parsing will be stuck." << std::endl;
-#endif
+				printWarningOrError(sif::OutputTypes::OUT_WARNING,
+						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
+						"Found length is one, parsing might be stuck");
 			}
 			break;
 		case APERIODIC_REPLY: {
@@ -734,6 +730,9 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 			            foundId);
 			}
 			if(foundLen == 0) {
+				printWarningOrError(sif::OutputTypes::OUT_ERROR,
+						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
+						"Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
 			            " Packet parsing will be stuck." << std::endl;
@@ -746,7 +745,8 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case IGNORE_FULL_PACKET:
 			return;
 		default:
-			//We need to wait for timeout.. don't know what command failed and who sent it.
+			// 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;
@@ -967,7 +967,8 @@ ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 }
 
 Mode_t DeviceHandlerBase::getBaseMode(Mode_t transitionMode) {
-//only child action special modes are handled, as a child should never see any base action modes
+	// only child action special modes are handled, as a child should
+	// never see any base action modes
 	if (transitionMode == _MODE_START_UP) {
 		return _MODE_TO_ON;
 	}
@@ -1290,12 +1291,11 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 	if (mode == MODE_NORMAL) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
-		    //so we can track misconfigurations
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Busy" << std::dec
-					<< std::endl;
-#endif
+		    // so we can track misconfigurations
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"buildInternalCommand",
+					HasReturnvaluesIF::RETURN_FAILED,
+					"Busy.");
 			result = NOTHING_TO_SEND; //no need to report this
 		}
 	}
@@ -1319,12 +1319,15 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
-			//so we can track misconfigurations
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Command "
-					<< deviceCommandId << " isExecuting" << std::dec
-					<< std::endl;
+#if FSFW_DISABLE_PRINTOUT == 0
+			char output[36];
+			sprintf(output, "Command 0x%08x is executing",
+					static_cast<unsigned int>(deviceCommandId));
+			// so we can track misconfigurations
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"buildInternalCommand",
+					HasReturnvaluesIF::RETURN_FAILED,
+					output);
 #endif
 			// this is an internal command, no need to report a failure here,
 			// missed reply will track if a reply is too late, otherwise, it's ok
@@ -1418,7 +1421,7 @@ void DeviceHandlerBase::performOperationHook() {
 }
 
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
-		LocalDataPool &localDataPoolMap,
+		localpool::DataPool &localDataPoolMap,
         LocalDataPoolManager& poolManager) {
 	if(thermalSet != nullptr) {
 		localDataPoolMap.emplace(thermalSet->thermalStatePoolId,
@@ -1429,18 +1432,13 @@ ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
 	return RETURN_OK;
 }
 
-LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
-	return &hkManager;
-}
-
-
 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();
     }
-    this->hkManager.initializeAfterTaskCreation();
+    this->poolManager.initializeAfterTaskCreation();
 
     if(setStartupImmediately) {
         startTransition(MODE_ON, SUBMODE_NONE);
@@ -1484,3 +1482,56 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 		}
 	}
 }
+
+AccessPoolManagerIF* DeviceHandlerBase::getAccessorHandle() {
+	return &poolManager;
+}
+
+void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
+		const char *functionName, ReturnValue_t errorCode,
+		const char *errorPrint) {
+	if(errorPrint == nullptr) {
+		if(errorCode == ObjectManagerIF::CHILD_INIT_FAILED) {
+			errorPrint = "Initialization error";
+		}
+		if(errorCode == HasReturnvaluesIF::RETURN_FAILED) {
+			if(errorType == sif::OutputTypes::OUT_WARNING) {
+				errorPrint = "Generic Warning";
+			}
+			else {
+				errorPrint = "Generic Error";
+			}
+		}
+		else {
+			errorPrint = "Unknown error";
+		}
+	}
+
+	if(errorType == sif::OutputTypes::OUT_WARNING) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::warning << "DeviceHandlerBase::" << functionName << ": Object ID "
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< this->getObjectId() << " | " << errorPrint << std::dec
+				<< std::setfill(' ') << std::endl;
+#else
+		sif::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+				this->getObjectId(), errorPrint);
+#endif
+	}
+	else if(errorType == sif::OutputTypes::OUT_ERROR) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::error << "DeviceHandlerBase::" << functionName << ": Object ID "
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< this->getObjectId() << " | " << errorPrint << std::dec
+				<< std::setfill(' ') << std::endl;
+#else
+		sif::printError("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+				this->getObjectId(), errorPrint);
+#endif
+	}
+
+}
+
+ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubscriptionInterface() {
+	return &poolManager;
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 24ba0372c..43f61897a 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -6,6 +6,8 @@
 #include "DeviceHandlerFailureIsolation.h"
 #include "DeviceHandlerThermalSet.h"
 
+#include "../serviceinterface/ServiceInterface.h"
+#include "../serviceinterface/serviceInterfaceDefintions.h"
 #include "../objectmanager/SystemObject.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -512,11 +514,18 @@ protected:
 	 * @param localDataPoolMap
 	 * @return
 	 */
-	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
+	virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
 				LocalDataPoolManager& poolManager) override;
 
-	/** Get the HK manager object handle */
-	virtual LocalDataPoolManager* getHkManagerHandle() override;
+	/**
+	 * Provides the subscription handle which can be used by classes like controllers
+	 * to get messages on data updates.
+	 * @return
+	 */
+	ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
+
+	//! Accessor handle required for internal handling.
+	AccessPoolManagerIF* getAccessorHandle() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
@@ -646,7 +655,7 @@ protected:
 	/** Action helper for HasActionsIF */
 	ActionHelper actionHelper;
 	/** Housekeeping Manager */
-	LocalDataPoolManager hkManager;
+	LocalDataPoolManager poolManager;
 
 	/**
 	 *  @brief Information about commands
@@ -1111,7 +1120,7 @@ private:
 	/**
 	 * @brief   The mode the current transition originated from
 	 *
-	 * This is private so the child can not change it and fuck up the timeouts
+	 * This is private so the child can not change it and mess up the timeouts
 	 *
 	 * IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!!
 	 * (it is _MODE_POWER_DOWN during this modes)
@@ -1190,7 +1199,8 @@ private:
 	 * Check if the RMAP sendWrite action was successful.
 	 *
 	 * Depending on the result, the following is done
-	 * - if the device command was external commanded, a reply is sent indicating the result
+	 * - if the device command was external commanded, a reply is sent
+	 *   indicating the result
 	 * - if the action was successful, the reply timout counter is initialized
 	 */
 	void doGetWrite(void);
@@ -1206,9 +1216,9 @@ private:
 	/**
 	 * Check the getRead reply and the contained data.
 	 *
-	 * If data was received scanForReply() and, if successful, handleReply() are called.
-	 * If the current mode is @c MODE_RAW, the received packet is sent to the commanding object
-	 * via commandQueue.
+	 * If data was received scanForReply() and, if successful, handleReply()
+	 * are called. If the current mode is @c MODE_RAW, the received packet
+	 * is sent to the commanding object via commandQueue.
 	 */
 	void doGetRead(void);
 
@@ -1227,7 +1237,7 @@ private:
 			uint32_t *len);
 
 	/**
-	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
+	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW, nothing else!
 	 */
 	void setTransition(Mode_t modeTo, Submode_t submodeTo);
 
@@ -1247,6 +1257,11 @@ private:
 
     void handleTransitionToOnMode(Mode_t commandedMode,
     		Submode_t commandedSubmode);
+
+    void printWarningOrError(sif::OutputTypes errorType,
+    		const char* functionName,
+			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+			const char* errorPrint = nullptr);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 865b38b36..bae68516e 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,10 +1,10 @@
 #ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 #define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "DeviceHandlerMessage.h"
 
 #include "../action/HasActionsIF.h"
-#include "../datapoollocal/locPoolDefinitions.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 65e19d102..e25e574f0 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -162,9 +162,15 @@ void EventManager::printEvent(EventMessage* message) {
 #endif
 
 void EventManager::lockMutex() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(timeoutType, timeoutMs);
 }
 
 void EventManager::unlockMutex() {
 	mutex->unlockMutex();
 }
+
+void EventManager::setMutexTimeout(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	this->timeoutType = timeoutType;
+	this->timeoutMs = timeoutMs;
+}
diff --git a/events/EventManager.h b/events/EventManager.h
index c6bd07be8..abce9b8ba 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -29,6 +29,8 @@ public:
 	EventManager(object_id_t setObjectId);
 	virtual ~EventManager();
 
+	void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
+
 	MessageQueueId_t getEventReportQueue();
 
 	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
@@ -51,6 +53,8 @@ protected:
 	std::map<MessageQueueId_t, EventMatchTree> listenerList;
 
 	MutexIF* mutex = nullptr;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	uint32_t timeoutMs = 20;
 
 	static const uint8_t N_POOLS = 3;
 	LocalPool factoryBackend;
diff --git a/fsfw.mk b/fsfw.mk
index 3df63060e..0d72fae14 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -10,6 +10,7 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/internal/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp)
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index c273b250f..25d6fcf4b 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -1,5 +1,5 @@
 #include "arrayprinter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include <bitset>
 
 void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
@@ -9,6 +9,8 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 		sif::info << "Printing data with size " << size << ": ";
 	}
 	sif::info << "[";
+#else
+	sif::printInfo("Printing data with size %zu: [", size);
 #endif
 	if(type == OutputType::HEX) {
 		arrayprinter::printHex(data, size, maxCharPerLine);
@@ -37,6 +39,8 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 	}
 	sif::info << std::dec;
 	sif::info << "]" << std::endl;
+#else
+	// how much memory to reserve for printout?
 #endif
 }
 
@@ -54,6 +58,8 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
 		}
 	}
 	sif::info << "]" << std::endl;
+#else
+	// how much memory to reserve for printout?
 #endif
 }
 
@@ -65,5 +71,7 @@ void arrayprinter::printBin(const uint8_t *data, size_t size) {
                 std::bitset<8>(data[i]) << ",\n" << std::flush;
     }
     sif::info << "]" << std::endl;
+#else
+    // how much memory to reserve for printout?
 #endif
 }
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 90bbe594a..0c7680dc0 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 
-#include "../datapoollocal/locPoolDefinitions.h"
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
 #include "../objectmanager/frameworkObjects.h"
diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
index fa91116d4..bd9062ed5 100644
--- a/internalError/InternalErrorDataset.h
+++ b/internalError/InternalErrorDataset.h
@@ -21,11 +21,11 @@ public:
     InternalErrorDataset(object_id_t objectId):
            StaticLocalDataSet(sid_t(objectId , ERROR_SET_ID)) {}
 
-    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(sid.objectId,
     		TM_HITS, this);
-    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(sid.objectId,
     		QUEUE_HITS, this);
-    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(sid.objectId,
     		STORE_HITS, this);
 };
 
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 48b6f851b..bc72ada24 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -2,7 +2,7 @@
 
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
         uint32_t messageQueueDepth): SystemObject(setObjectId),
@@ -23,13 +23,13 @@ void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
 }
 
 ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
-    internalErrorDataset.read(INTERNAL_ERROR_MUTEX_TIMEOUT);
+    internalErrorDataset.read(timeoutType, timeoutMs);
 
 	uint32_t newQueueHits = getAndResetQueueHits();
 	uint32_t newTmHits = getAndResetTmHits();
 	uint32_t newStoreHits = getAndResetStoreHits();
 
-#if FSFW_ENHANCED_PRINTOUT == 1
+#if FSFW_VERBOSE_LEVEL == 1
 	if(diagnosticPrintout) {
 	    if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -38,6 +38,11 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
 	        sif::debug << "TM errors: " << newTmHits << std::endl;
 	        sif::debug << "Store errors: " << newStoreHits << std::endl;
+#else
+	        sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
+	        sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
+	        sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
+	        sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
 #endif
 	    }
 	}
@@ -46,8 +51,8 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	internalErrorDataset.queueHits.value += newQueueHits;
 	internalErrorDataset.storeHits.value += newStoreHits;
 	internalErrorDataset.tmHits.value += newTmHits;
-
-	internalErrorDataset.commit(INTERNAL_ERROR_MUTEX_TIMEOUT);
+	internalErrorDataset.setValidity(true, true);
+	internalErrorDataset.commit(timeoutType, timeoutMs);
 
 	poolManager.performHkOperation();
 
@@ -69,7 +74,7 @@ void InternalErrorReporter::lostTm() {
 
 uint32_t InternalErrorReporter::getAndResetQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = queueHits;
 	queueHits = 0;
 	mutex->unlockMutex();
@@ -78,21 +83,21 @@ uint32_t InternalErrorReporter::getAndResetQueueHits() {
 
 uint32_t InternalErrorReporter::getQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = queueHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	queueHits++;
 	mutex->unlockMutex();
 }
 
 uint32_t InternalErrorReporter::getAndResetTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = tmHits;
 	tmHits = 0;
 	mutex->unlockMutex();
@@ -101,14 +106,14 @@ uint32_t InternalErrorReporter::getAndResetTmHits() {
 
 uint32_t InternalErrorReporter::getTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = tmHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	tmHits++;
 	mutex->unlockMutex();
 }
@@ -119,7 +124,7 @@ void InternalErrorReporter::storeFull() {
 
 uint32_t InternalErrorReporter::getAndResetStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = storeHits;
 	storeHits = 0;
 	mutex->unlockMutex();
@@ -128,14 +133,18 @@ uint32_t InternalErrorReporter::getAndResetStoreHits() {
 
 uint32_t InternalErrorReporter::getStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = storeHits;
 	mutex->unlockMutex();
 	return value;
 }
 
+AccessPoolManagerIF* InternalErrorReporter::getAccessorHandle() {
+	return &poolManager;
+}
+
 void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	storeHits++;
 	mutex->unlockMutex();
 }
@@ -149,7 +158,7 @@ MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
 }
 
 ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
-        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
     localDataPoolMap.emplace(errorPoolIds::TM_HITS,
             new PoolEntry<uint32_t>());
     localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS,
@@ -162,10 +171,6 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() {
-    return &poolManager;
-}
-
 dur_millis_t InternalErrorReporter::getPeriodicOperationFrequency() const {
     return this->executingTask->getPeriodMs();
 }
@@ -190,3 +195,12 @@ ReturnValue_t InternalErrorReporter::initializeAfterTaskCreation() {
     return poolManager.initializeAfterTaskCreation();
 }
 
+void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	this->timeoutType = timeoutType;
+	this->timeoutMs = timeoutMs;
+}
+
+ProvidesDataPoolSubscriptionIF* InternalErrorReporter::getSubscriptionInterface() {
+	return &poolManager;
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 8d33c06e2..ec9134d42 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -22,7 +22,6 @@ class InternalErrorReporter: public SystemObject,
 		public InternalErrorReporterIF,
 		public HasLocalDataPoolIF {
 public:
-    static constexpr uint8_t INTERNAL_ERROR_MUTEX_TIMEOUT = 20;
 
 	InternalErrorReporter(object_id_t setObjectId,
 	        uint32_t messageQueueDepth = 5);
@@ -34,16 +33,20 @@ public:
 	 */
 	void setDiagnosticPrintout(bool enable);
 
+	void setMutexTimeout(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs);
+
 	virtual ~InternalErrorReporter();
 
     virtual object_id_t getObjectId() const override;
     virtual MessageQueueId_t getCommandQueue() const override;
     virtual ReturnValue_t initializeLocalDataPool(
-            LocalDataPool& localDataPoolMap,
+    		localpool::DataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
-    virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
+	AccessPoolManagerIF* getAccessorHandle() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
@@ -61,7 +64,11 @@ protected:
 	LocalDataPoolManager poolManager;
 
 	PeriodicTaskIF* executingTask = nullptr;
+
 	MutexIF* mutex = nullptr;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	uint32_t timeoutMs = 20;
+
 	sid_t internalErrorSid;
 	InternalErrorDataset internalErrorDataset;
 
diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 5673e4d79..084b702b4 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -14,7 +14,7 @@ public:
     /**
      * Different types of timeout for the mutex lock.
      */
-    enum TimeoutType {
+    enum class TimeoutType {
         POLLING, //!< If mutex is not available, return immediately
         WAITING, //!< Wait a specified time for the mutex to become available
         BLOCKING //!< Block indefinitely until the mutex becomes available.
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 9028e7e4a..7ce110e57 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -5,7 +5,7 @@
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
 
-#include "../datapoollocal/locPoolDefinitions.h"
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index 2822743ac..d830e3136 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -1,9 +1,10 @@
-#ifndef MONITORINGMESSAGECONTENT_H_
-#define MONITORINGMESSAGECONTENT_H_
+#ifndef FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_
+#define FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_
 
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
-#include "../datapoollocal/locPoolDefinitions.h"
+
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
@@ -85,4 +86,4 @@ private:
 template<typename T>
 object_id_t MonitoringReportContent<T>::timeStamperId = 0;
 
-#endif /* MONITORINGMESSAGECONTENT_H_ */
+#endif /* FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_ */
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index d3f4e68e1..9c0a02679 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -163,7 +163,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -178,7 +178,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if (timeMutex == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 2bc78785f..88bf51d23 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -202,7 +202,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -217,7 +217,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex == nullptr){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index ad8873dfc..892028b23 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -4,16 +4,16 @@
 Mutex::Mutex() {}
 
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
-	if(timeoutType == MutexIF::BLOCKING) {
+	if(timeoutType == TimeoutType::BLOCKING) {
 		mutex.lock();
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	else if(timeoutType == MutexIF::POLLING) {
+	else if(timeoutType == TimeoutType::POLLING) {
 		if(mutex.try_lock()) {
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
-	else if(timeoutMs > MutexIF::POLLING){
+	else if(timeoutType == TimeoutType::WAITING){
 		auto chronoMs = std::chrono::milliseconds(timeoutMs);
 		if(mutex.try_lock_for(chronoMs)) {
 			return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index c0fa19b78..0bd93c8ac 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -22,7 +22,6 @@ public:
 
 	std::timed_mutex* getMutexHandle();
 private:
-	//bool locked = false;
 	std::timed_mutex mutex;
 };
 
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 0a6bb29f0..5716e5602 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -1,10 +1,11 @@
 #include "BinarySemaphore.h"
+#include "../../serviceinterface/ServiceInterfacePrinter.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-extern "C" {
+#include <time.h>
 #include <errno.h>
 #include <string.h>
-}
+
 
 BinarySemaphore::BinarySemaphore() {
 	// Using unnamed semaphores for now
@@ -113,7 +114,8 @@ uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
 	}
 	else if(result != 0 and errno == EINVAL) {
 		// Could be called from interrupt, use lightweight printf
-		printf("BinarySemaphore::getSemaphoreCounter: Invalid semaphore\n");
+		sif::printError("BinarySemaphore::getSemaphoreCounter: "
+				"Invalid semaphore\n");
 		return 0;
 	}
 	else {
@@ -128,13 +130,17 @@ void BinarySemaphore::initSemaphore(uint8_t initCount) {
 		switch(errno) {
 		case(EINVAL):
 			// Value exceeds SEM_VALUE_MAX
-		case(ENOSYS):
-		// System does not support process-shared semaphores
+		case(ENOSYS): {
+			// System does not support process-shared semaphores
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
-				<< std::endl;
+				sif::error << "BinarySemaphore: Init failed with "
+						<< strerror(errno) << std::endl;
+#else
+				sif::printError("BinarySemaphore: Init failed with %s\n",
+						strerror(errno));
 #endif
 		}
+		}
 	}
 }
 
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 54dad8395..35cbfae03 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -182,7 +182,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -197,7 +197,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex==NULL){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -209,13 +209,13 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 }
 
 ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex==NULL){
+	if(timeMutex == nullptr){
 		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
+		if (mutexFactory == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
+		if (timeMutex == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
index 0bb718319..07c522129 100644
--- a/osal/linux/CountingSemaphore.cpp
+++ b/osal/linux/CountingSemaphore.cpp
@@ -1,5 +1,7 @@
 #include "../../osal/linux/CountingSemaphore.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
+
+#include <errno.h>
 
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index e7b09b4f9..60d15dee7 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,5 +1,5 @@
 #include "MessageQueue.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 
 #include <fstream>
@@ -121,14 +121,16 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		break;
 	}
 
-	default:
+	default: {
 		// Failed either the first time or the second time
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-		<< name << std::dec << " failed with status: "
-		<< strerror(errno) << std::endl;
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << name
+				<< " failed with status: " << strerror(errno) << std::endl;
+#else
+		sif::printError("MessageQueue::MessageQueue: Creating Queue %s"
+				" failed with status: %s\n", name, strerror(errno));
 #endif
-
+	}
 	}
 	return HasReturnvaluesIF::RETURN_FAILED;
 
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index a0e540cfd..2499b442e 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,6 +1,6 @@
 #include "PosixThread.h"
 
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 #include <cstring>
 #include <errno.h>
@@ -146,16 +146,22 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 				strerror(status) << std::endl;
 #endif
 		if(errno == ENOMEM) {
-			uint64_t stackMb = stackSize/10e6;
+			size_t stackMb = stackSize/10e6;
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Insufficient memory for"
 					" the requested " << stackMb << " MB" << std::endl;
+#else
+			sif::printError("PosixThread::createTask: Insufficient memory for "
+					"the requested %zu MB\n", stackMb);
 #endif
 		}
 		else if(errno == EINVAL) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Wrong alignment argument!"
 					<< std::endl;
+#else
+			sif::printError("PosixThread::createTask: "
+					"Wrong alignment argument!\n");
 #endif
 		}
 		return;
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index a8387e87f..11ed7fee6 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,6 +1,8 @@
 #include "TcUnixUdpPollingTask.h"
 #include "../../globalfunctions/arrayprinter.h"
 
+#include <errno.h>
+
 TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,
 		double timeoutSeconds): SystemObject(objectId),
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 1d318d3b0..0af1fc68b 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,5 +1,5 @@
 #include "TmTcUnixUdpBridge.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../ipc/MutexHelper.h"
 
 #include <errno.h>
@@ -188,12 +188,16 @@ void TmTcUnixUdpBridge::handleBindError() {
 
 void TmTcUnixUdpBridge::handleSendError() {
 	switch(errno) {
-	default:
+	default: {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSendError: "
 		        << strerror(errno) << std::endl;
+#else
+		sif::printError("TmTcUnixBridge::handleSendError: %s\n",
+				strerror(errno));
 #endif
 	}
+	}
 }
 
 void TmTcUnixUdpBridge::setClientAddressToAny(bool ipAddrAnySet){
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index 71c5782ff..7dd512fae 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -30,11 +30,11 @@ Mutex::~Mutex() {
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType =
         TimeoutType::BLOCKING, uint32_t timeoutMs) {
 	rtems_status_code status = RTEMS_INVALID_ID;
-	if(timeoutMs == MutexIF::TimeoutType::BLOCKING) {
+	if(timeoutType == MutexIF::TimeoutType::BLOCKING) {
 		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_WAIT, RTEMS_NO_TIMEOUT);
 	}
-	else if(timeoutMs == MutexIF::TimeoutType::POLLING) {
+	else if(timeoutType == MutexIF::TimeoutType::POLLING) {
 		timeoutMs = RTEMS_NO_TIMEOUT;
 		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_NO_WAIT, 0);
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 1c30d83f3..b6e0a7f16 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -65,8 +65,8 @@ ReturnValue_t Fuse::check() {
 	set.read();
 	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
 		setAllMonitorsToUnchecked();
-		set.commit(PoolVariableIF::INVALID);
-		return RETURN_OK;
+		set.setValidity(false, true);
+		return set.commit();
 	}
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	checkFuseState();
@@ -206,7 +206,8 @@ float Fuse::getPower() {
 
 void Fuse::setDataPoolEntriesInvalid() {
 	set.read();
-	set.commit(PoolVariableIF::INVALID);
+	set.setValidity(false, true);
+	set.commit();
 }
 
 ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 1ef041e30..fb181d9f9 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -97,7 +97,8 @@ void PowerSensor::checkCommandQueue() {
 
 void PowerSensor::setDataPoolEntriesInvalid() {
 	powerSensorSet.read();
-	powerSensorSet.commit(PoolVariableIF::INVALID);
+	powerSensorSet.setValidity(false, true);
+	powerSensorSet.commit();
 }
 
 float PowerSensor::getPower() {
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index 7138e6c62..517f561ab 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -3,7 +3,9 @@
  ReturnValue_t unitt::put_error(std::string errorId) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Unit Tester error: Failed at test ID "
-			<< errorId << "\n" << std::flush;
-#endif
+			<< errorId << std::endl;
+#else
+	sif::printError("Unit Tester error: Failed at test ID 0x%08x", errorId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/unittest/internal/UnittDefinitions.h b/unittest/internal/UnittDefinitions.h
index ea36fea40..3e14fec57 100644
--- a/unittest/internal/UnittDefinitions.h
+++ b/unittest/internal/UnittDefinitions.h
@@ -2,9 +2,10 @@
 #define UNITTEST_INTERNAL_UNITTDEFINITIONS_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include <cstdint>
 #include <cstddef>
+#include <string>
 
 namespace tv {
 // POD test values
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index 3316de749..2a1584b8e 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -13,7 +13,7 @@
 void testmutex::testMutex() {
 	std::string id = "[testMutex]";
 	MutexIF* mutex = MutexFactory::instance()->createMutex();
-	auto result = mutex->lockMutex(MutexIF::POLLING);
+	auto result = mutex->lockMutex(MutexIF::TimeoutType::POLLING);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		unitt::put_error(id);
 	}
diff --git a/unittest/tests/CMakeLists.txt b/unittest/tests/CMakeLists.txt
index 970744174..180e1a51d 100644
--- a/unittest/tests/CMakeLists.txt
+++ b/unittest/tests/CMakeLists.txt
@@ -2,5 +2,6 @@ add_subdirectory(action)
 add_subdirectory(container)
 add_subdirectory(osal)
 add_subdirectory(serialize)
+add_subdirectory(datapoollocal)
 add_subdirectory(storagemanager)
 
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index 3109eba1a..2493a6b8e 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -4,9 +4,12 @@
 
 #include <fsfw/action/ActionHelper.h>
 #include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <array>
+
 
 TEST_CASE( "Action Helper" , "[ActionHelper]") {
 	ActionHelperOwnerMockBase testDhMock;
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
index 610fb09ea..641ea2c63 100644
--- a/unittest/tests/action/TestActionHelper.h
+++ b/unittest/tests/action/TestActionHelper.h
@@ -48,85 +48,4 @@ public:
 };
 
 
-class MessageQueueMockBase: public MessageQueueIF {
-public:
-	MessageQueueId_t myQueueId = 0;
-	bool defaultDestSet = false;
-	bool messageSent = false;
-
-
-
-	bool wasMessageSent() {
-		bool tempMessageSent = messageSent;
-		messageSent = false;
-		return tempMessageSent;
-	}
-
-	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	};
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) {
-		(*message) = lastMessage;
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
-		memcpy(message->getBuffer(), lastMessage.getBuffer(),
-				message->getMessageSize());
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t flush(uint32_t* count) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual MessageQueueId_t getLastPartner() const {
-		return tconst::testQueueId;
-	}
-	virtual MessageQueueId_t getId() const {
-		return tconst::testQueueId;
-	}
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
-		myQueueId = defaultDestination;
-		defaultDestSet = true;
-	}
-
-	virtual MessageQueueId_t getDefaultDestination() const {
-		return myQueueId;
-	}
-	virtual bool isDefaultDestinationSet() const {
-		return defaultDestSet;
-	}
-private:
-	MessageQueueMessage lastMessage;
-
-};
-
-
 #endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
diff --git a/unittest/tests/container/TestPlacementFactory.cpp b/unittest/tests/container/TestPlacementFactory.cpp
index 5edbb9d22..14cf8eb4c 100644
--- a/unittest/tests/container/TestPlacementFactory.cpp
+++ b/unittest/tests/container/TestPlacementFactory.cpp
@@ -1,45 +1,48 @@
-//#include <fsfw/container/PlacementFactory.h>
-//#include <fsfw/storagemanager/LocalPool.h>
-//#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-//#include <fsfw/container/ArrayList.h>
-//
-//#include <catch2/catch.hpp>
-//#include "../../core/CatchDefinitions.h"
-//
-//TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
-//	INFO("PlacementFactory Tests");
-//
-//	const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
-//	const uint16_t n_elements[3] = {1, 1, 1};
-//	LocalPool<3> storagePool(0x1, element_sizes, n_elements, false, true);
-//	PlacementFactory factory(&storagePool);
-//
-//	SECTION("Pool overload"){
-//		store_address_t address;
-//		uint8_t* ptr = nullptr;
-//		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
-//				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
-//		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
-//		REQUIRE(list2 == nullptr);
-//	}
-//
-//	SECTION("Test generate and destroy"){
-//		uint64_t* number = factory.generate<uint64_t>(32000);
-//		REQUIRE(number != nullptr);
-//		REQUIRE(*number == 32000);
-//		store_address_t address;
-//		uint8_t* ptr = nullptr;
-//		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
-//						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
-//		uint64_t* number2 = factory.generate<uint64_t>(12345);
-//		REQUIRE(number2 == nullptr);
-//		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
-//						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-//
-//		//Check that PlacementFactory checks for nullptr
-//		ptr = nullptr;
-//		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
-//	}
-//}
+#include <fsfw/container/PlacementFactory.h>
+#include <fsfw/storagemanager/LocalPool.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/container/ArrayList.h>
+
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+
+TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
+	INFO("PlacementFactory Tests");
+
+	LocalPool::LocalPoolConfig poolCfg= {{1, sizeof(uint16_t)},
+			{1, sizeof(uint32_t)}, {1, sizeof(uint64_t)}
+	};
+	//const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
+	//const uint16_t n_elements[3] = {1, 1, 1};
+	LocalPool storagePool(0x1, poolCfg, false, true);
+	PlacementFactory factory(&storagePool);
+
+	SECTION("Pool overload"){
+		store_address_t address;
+		uint8_t* ptr = nullptr;
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
+				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
+		REQUIRE(list2 == nullptr);
+	}
+
+	SECTION("Test generate and destroy"){
+		uint64_t* number = factory.generate<uint64_t>(32000);
+		REQUIRE(number != nullptr);
+		REQUIRE(*number == 32000);
+		store_address_t address;
+		uint8_t* ptr = nullptr;
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+		uint64_t* number2 = factory.generate<uint64_t>(12345);
+		REQUIRE(number2 == nullptr);
+		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+
+		//Check that PlacementFactory checks for nullptr
+		ptr = nullptr;
+		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+	}
+}
diff --git a/unittest/tests/datapoollocal/CMakeLists.txt b/unittest/tests/datapoollocal/CMakeLists.txt
new file mode 100644
index 000000000..f196a080a
--- /dev/null
+++ b/unittest/tests/datapoollocal/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${TARGET_NAME} PRIVATE
+	LocalPoolVariableTest.cpp
+	LocalPoolVectorTest.cpp
+	DataSetTest.cpp
+	LocalPoolManagerTest.cpp
+)
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
new file mode 100644
index 000000000..968a0b3df
--- /dev/null
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -0,0 +1,23 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <unittest/core/CatchDefinitions.h>
+
+TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+	const uint32_t setId = 0;
+	SECTION("BasicTest") {
+		StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>(
+				sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, setId));
+	}
+}
+
+
+
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
new file mode 100644
index 000000000..f550582e9
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -0,0 +1,122 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/ipc/CommandMessageCleaner.h>
+#include <unittest/core/CatchDefinitions.h>
+
+
+TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+	REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK);
+	MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
+	REQUIRE(mqMock != nullptr);
+	CommandMessage messageSent;
+	uint8_t messagesSent = 0;
+
+
+	SECTION("BasicTest") {
+		// Subscribe for message generation on update.
+		REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
+		// Subscribe for an update message.
+		poolOwner->dataset.setChanged(true);
+		// Now the update message should be generated.
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(mqMock->wasMessageSent() == true);
+
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+		// Should have been reset.
+		CHECK(poolOwner->dataset.hasChanged() == false);
+		// Set changed again, result should be the same.
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 1);
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+		// now subscribe for set update HK as well.
+		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 2);
+		// first message sent should be the update notification, considering
+		// the internal list is a vector checked in insertion order.
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::HK_REPORT));
+		// clear message to avoid memory leak, our mock won't do it for us (yet)
+		CommandMessageCleaner::clearCommandMessage(&messageSent);
+	}
+
+	SECTION("AdvancedTests") {
+		// we need to reset the subscription list because the pool owner
+		// is a global object.
+		poolOwner->resetSubscriptionList();
+		// Subscribe for variable update as well
+		REQUIRE(not poolOwner->dataset.hasChanged());
+		REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
+				retval::CATCH_OK);
+		lp_var_t<uint8_t>* poolVar = dynamic_cast<lp_var_t<uint8_t>*>(
+				poolOwner->getPoolObjectHandle(lpool::uint8VarId));
+		REQUIRE(poolVar != nullptr);
+		poolVar->setChanged(true);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+
+		// Check update notification was sent.
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 1);
+		// Should have been reset.
+		CHECK(poolVar->hasChanged() == false);
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+
+		// now subscribe for the dataset update (HK and update) again
+		REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
+		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
+
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+		// now two messages should be sent.
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 2);
+		mqMock->clearMessages(true);
+
+		poolOwner->dataset.setChanged(true);
+		poolVar->setChanged(true);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+		// now three messages should be sent.
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 3);
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::HK_REPORT));
+		CommandMessageCleaner::clearCommandMessage(&messageSent);
+		REQUIRE(mqMock->receiveMessage(&messageSent) ==
+				static_cast<int>(MessageQueueIF::EMPTY));
+	}
+}
+
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
new file mode 100644
index 000000000..aaccc90ed
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -0,0 +1,206 @@
+#ifndef FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
+#define FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
+
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/LocalDataSet.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+#include <fsfw/datapoollocal/LocalPoolVector.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <testcfg/objects/systemObjectList.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
+
+namespace lpool {
+static constexpr lp_id_t uint8VarId = 0;
+static constexpr lp_id_t floatVarId = 1;
+static constexpr lp_id_t uint32VarId = 2;
+static constexpr lp_id_t uint16Vec3Id = 3;
+static constexpr lp_id_t int64Vec2Id = 4;
+
+static constexpr uint32_t testSetId = 0;
+static constexpr uint8_t dataSetMaxVariables = 10;
+static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE,
+		testSetId);
+}
+
+
+class LocalPoolTestDataSet: public LocalDataSet {
+public:
+	LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
+		LocalDataSet(owner, setId, lpool::dataSetMaxVariables) {
+	}
+
+	ReturnValue_t assignPointers() {
+		PoolVariableIF** rawVarArray = getContainer();
+		localPoolVarUint8 = dynamic_cast<lp_var_t<uint8_t>*>(rawVarArray[0]);
+		localPoolVarFloat = dynamic_cast<lp_var_t<float>*>(rawVarArray[1]);
+		localPoolUint16Vec = dynamic_cast<lp_vec_t<uint16_t, 3>*>(
+				rawVarArray[2]);
+		if(localPoolVarUint8 == nullptr or  localPoolVarFloat == nullptr or
+				localPoolUint16Vec == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	lp_var_t<uint8_t>* localPoolVarUint8 = nullptr;
+	lp_var_t<float>* localPoolVarFloat = nullptr;
+	lp_vec_t<uint16_t, 3>* localPoolUint16Vec = nullptr;
+
+private:
+};
+
+
+class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
+public:
+	LocalPoolOwnerBase(
+			object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE):
+		SystemObject(objectId), hkManager(this, messageQueue),
+		dataset(this, lpool::testSetId) {
+		messageQueue = new MessageQueueMockBase();
+	}
+
+	~LocalPoolOwnerBase() {
+		QueueFactory::instance()->deleteMessageQueue(messageQueue);
+	}
+
+	object_id_t getObjectId() const override {
+		return SystemObject::getObjectId();
+	}
+
+	ReturnValue_t initializeHkManager() {
+		if(not initialized) {
+			initialized = true;
+			return hkManager.initialize(messageQueue);
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t initializeHkManagerAfterTaskCreation() {
+		if(not initializedAfterTaskCreation) {
+			initializedAfterTaskCreation = true;
+			return hkManager.initializeAfterTaskCreation();
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	/** Command queue for housekeeping messages. */
+	MessageQueueId_t getCommandQueue() const override {
+		return messageQueue->getId();
+	}
+
+	// This is called by initializeAfterTaskCreation of the HK manager.
+	virtual ReturnValue_t initializeLocalDataPool(
+	        localpool::DataPool& localDataPoolMap,
+	        LocalDataPoolManager& poolManager) {
+		// Default initialization empty for now.
+		localDataPoolMap.emplace(lpool::uint8VarId,
+				new PoolEntry<uint8_t>({0}));
+		localDataPoolMap.emplace(lpool::floatVarId,
+				new PoolEntry<float>({0}));
+		localDataPoolMap.emplace(lpool::uint32VarId,
+				new PoolEntry<uint32_t>({0}));
+
+		localDataPoolMap.emplace(lpool::uint16Vec3Id,
+				new PoolEntry<uint16_t>({0, 0, 0}));
+		localDataPoolMap.emplace(lpool::int64Vec2Id,
+				new PoolEntry<int64_t>({0, 0}));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	/**
+	 * This function can be used by data pool consumers to retrieve a handle
+	 * which allows subscriptions to dataset and variable updates.
+	 * @return
+	 */
+	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override {
+		return &hkManager;
+	}
+
+	virtual AccessPoolManagerIF* getAccessorHandle() override {
+		return &hkManager;
+	}
+
+	uint32_t getPeriodicOperationFrequency() const override {
+		return 0;
+	}
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override  {
+		return &dataset;
+	}
+
+	virtual LocalPoolObjectBase* getPoolObjectHandle(
+			lp_id_t localPoolId) override {
+		if(localPoolId == lpool::uint8VarId) {
+			return &testUint8;
+		}
+		else if(localPoolId == lpool::uint16Vec3Id) {
+			return &testUint16Vec;
+		}
+		else if(localPoolId == lpool::floatVarId) {
+			return &testFloat;
+		}
+		else if(localPoolId == lpool::int64Vec2Id) {
+			return &testInt64Vec;
+		}
+		else if(localPoolId == lpool::uint32VarId) {
+			return &testUint32;
+		}
+		else {
+			return &testUint8;
+		}
+	}
+
+	MessageQueueMockBase* getMockQueueHandle() const {
+		return dynamic_cast<MessageQueueMockBase*>(messageQueue);
+	}
+
+	ReturnValue_t subscribeWrapperSetUpdate() {
+		return hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
+				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
+	}
+
+	ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) {
+		return hkManager.subscribeForUpdatePackets(lpool::testSid, diagnostics,
+				false, objects::HK_RECEIVER_MOCK);
+	}
+
+	ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) {
+		return hkManager.subscribeForVariableUpdateMessages(localPoolId,
+				MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false);
+	}
+
+	void resetSubscriptionList() {
+		hkManager.clearReceiversList();
+	}
+
+	LocalDataPoolManager hkManager;
+	LocalPoolTestDataSet dataset;
+private:
+
+	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId,
+			&dataset);
+	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId,
+			&dataset);
+	lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
+
+	lp_vec_t<uint16_t, 3> testUint16Vec = lp_vec_t<uint16_t, 3>(this,
+			lpool::uint16Vec3Id, &dataset);
+	lp_vec_t<int64_t, 2> testInt64Vec = lp_vec_t<int64_t, 2>(this,
+			lpool::int64Vec2Id);
+
+	MessageQueueIF* messageQueue = nullptr;
+
+	bool initialized = false;
+	bool initializedAfterTaskCreation = false;
+
+};
+
+#endif /* FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_ */
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
new file mode 100644
index 000000000..2e4cb7ecd
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -0,0 +1,123 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <unittest/core/CatchDefinitions.h>
+
+
+TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+
+	SECTION("Basic Tests") {
+		// very basic test.
+		lp_var_t<uint8_t> testVariable = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+		REQUIRE(testVariable.read() == retval::CATCH_OK);
+		CHECK(testVariable.value == 0);
+		testVariable.value = 5;
+		REQUIRE(testVariable.commit() == retval::CATCH_OK);
+		REQUIRE(testVariable.read() == retval::CATCH_OK);
+		REQUIRE(testVariable.value == 5);
+		CHECK(not testVariable.isValid());
+		testVariable.setValid(true);
+		CHECK(testVariable.isValid());
+		CHECK(testVariable.commit(true) == retval::CATCH_OK);
+
+		testVariable.setReadWriteMode(pool_rwm_t::VAR_READ);
+		CHECK(testVariable.getReadWriteMode() == pool_rwm_t::VAR_READ);
+		testVariable.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
+
+		testVariable.setDataPoolId(22);
+		CHECK(testVariable.getDataPoolId() == 22);
+		testVariable.setDataPoolId(lpool::uint8VarId);
+
+		testVariable.setChanged(true);
+		CHECK(testVariable.hasChanged());
+		testVariable.setChanged(false);
+
+		gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE,
+				lpool::uint8VarId);
+		lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
+		REQUIRE(testVariable2.read() == retval::CATCH_OK);
+		CHECK(testVariable2 == 5);
+		CHECK(testVariable == testVariable2);
+		testVariable = 10;
+		CHECK(testVariable != 5);
+		//CHECK(not testVariable != testVariable2);
+		uint8_t variableRaw = 0;
+		uint8_t* varPtr = &variableRaw;
+		size_t maxSize = testVariable.getSerializedSize();
+		CHECK(maxSize == 1);
+		size_t serSize = 0;
+		CHECK(testVariable.serialize(&varPtr, &serSize, maxSize,
+				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+		CHECK(variableRaw == 10);
+		const uint8_t* varConstPtr = &variableRaw;
+		testVariable = 5;
+		CHECK(testVariable.deSerialize(&varConstPtr, &serSize,
+				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+		CHECK(testVariable == 10);
+		CHECK(testVariable != testVariable2);
+		CHECK(testVariable2 < testVariable);
+		CHECK(testVariable2 < 10);
+		CHECK(testVariable > 5);
+		CHECK(testVariable > testVariable2);
+		variableRaw = static_cast<uint8_t>(testVariable2);
+		CHECK(variableRaw == 5);
+
+		CHECK(testVariable == 10);
+		testVariable = testVariable2;
+		CHECK(testVariable == 5);
+	}
+
+	SECTION("ErrorHandling") {
+
+		// not try to use a local pool variable which does not exist
+		lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+		REQUIRE(invalidVariable.read() ==
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+
+		REQUIRE(invalidVariable.commit() ==
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+		// now try to access with wrong type
+		lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+		REQUIRE(invalidVariable2.read() ==
+				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+
+		lp_var_t<uint8_t> readOnlyVar = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
+				nullptr, pool_rwm_t::VAR_READ);
+		REQUIRE(readOnlyVar.commit() ==
+				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+		lp_var_t<uint8_t> writeOnlyVar = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
+				nullptr, pool_rwm_t::VAR_WRITE);
+		REQUIRE(writeOnlyVar.read() == static_cast<int>(
+				PoolVariableIF::INVALID_READ_WRITE_MODE));
+
+		lp_var_t<uint32_t> uint32tVar = lp_var_t<uint32_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::info << "LocalPoolVariable printout: " <<uint32tVar << std::endl;
+#endif
+
+		// for code coverage. If program does not crash -> OK
+		lp_var_t<uint8_t> invalidObjectVar = lp_var_t<uint8_t>(
+				0xffffffff, lpool::uint8VarId);
+		gp_id_t globPoolId(0xffffffff,
+				lpool::uint8VarId);
+		lp_var_t<uint8_t> invalidObjectVar2 = lp_var_t<uint8_t>(globPoolId);
+		lp_var_t<uint8_t> invalidObjectVar3 = lp_var_t<uint8_t>(nullptr,
+				lpool::uint8VarId);
+	}
+
+}
+
+
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
new file mode 100644
index 000000000..7c309bbb8
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -0,0 +1,120 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <unittest/core/CatchDefinitions.h>
+
+TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+
+	SECTION("BasicTest") {
+		// very basic test.
+		lp_vec_t<uint16_t, 3> testVector = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+		REQUIRE(testVector.read() == retval::CATCH_OK);
+		testVector.value[0] = 5;
+		testVector.value[1] = 232;
+		testVector.value[2] = 32023;
+
+		REQUIRE(testVector.commit(true) == retval::CATCH_OK);
+		CHECK(testVector.isValid());
+
+		testVector.value[0] = 0;
+		testVector.value[1] = 0;
+		testVector.value[2] = 0;
+
+		CHECK(testVector.read() == retval::CATCH_OK);
+		CHECK(testVector.value[0] == 5);
+		CHECK(testVector.value[1] == 232);
+		CHECK(testVector.value[2] == 32023);
+
+		CHECK(testVector[0] == 5);
+
+		// This is invalid access, so the last value will be set instead.
+		// (we can't throw exceptions)
+		testVector[4] = 12;
+		CHECK(testVector[2] == 12);
+		CHECK(testVector.commit() == retval::CATCH_OK);
+
+		// Use read-only reference.
+		const lp_vec_t<uint16_t, 3>& roTestVec = testVector;
+		uint16_t valueOne = roTestVec[0];
+		CHECK(valueOne == 5);
+
+		uint16_t lastVal = roTestVec[25];
+		CHECK(lastVal == 12);
+
+		size_t maxSize = testVector.getSerializedSize();
+		CHECK(maxSize == 6);
+
+		uint16_t serializedVector[3];
+		uint8_t* vecPtr = reinterpret_cast<uint8_t*>(serializedVector);
+		size_t serSize = 0;
+		REQUIRE(testVector.serialize(&vecPtr, &serSize,
+				maxSize, SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+
+		CHECK(serSize == 6);
+		CHECK(serializedVector[0] == 5);
+		CHECK(serializedVector[1] == 232);
+		CHECK(serializedVector[2] == 12);
+
+		maxSize = 1;
+		REQUIRE(testVector.serialize(&vecPtr, &serSize,
+				maxSize, SerializeIF::Endianness::MACHINE) ==
+				static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+
+		serializedVector[0] = 16;
+		serializedVector[1] = 7832;
+		serializedVector[2] = 39232;
+
+		const uint8_t* constVecPtr = reinterpret_cast<const uint8_t*>(
+				serializedVector);
+		REQUIRE(testVector.deSerialize(&constVecPtr, &serSize,
+				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+		CHECK(testVector[0] == 16);
+		CHECK(testVector[1] == 7832);
+		CHECK(testVector[2] == 39232);
+
+		serSize = 1;
+		REQUIRE(testVector.deSerialize(&constVecPtr, &serSize,
+				SerializeIF::Endianness::MACHINE) ==
+				static_cast<int>(SerializeIF::STREAM_TOO_SHORT));
+	}
+
+	SECTION("ErrorHandling") {
+		// not try to use a local pool variable which does not exist
+		lp_vec_t<uint16_t, 3> invalidVector = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+		REQUIRE(invalidVector.read() ==
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+		REQUIRE(invalidVector.commit() ==
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+
+		// now try to access with wrong type
+		lp_vec_t<uint32_t, 3> invalidVector2 = lp_vec_t<uint32_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+		REQUIRE(invalidVector2.read() ==
+				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+		REQUIRE(invalidVector2.commit() ==
+				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+
+		lp_vec_t<uint16_t, 3> writeOnlyVec = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
+				nullptr, pool_rwm_t::VAR_WRITE);
+		REQUIRE(writeOnlyVec.read() ==
+				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+
+		lp_vec_t<uint16_t, 3> readOnlyVec = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
+				nullptr, pool_rwm_t::VAR_READ);
+		REQUIRE(readOnlyVec.commit() ==
+				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+	}
+}
+
+
diff --git a/unittest/tests/mocks/HkReceiverMock.h b/unittest/tests/mocks/HkReceiverMock.h
new file mode 100644
index 000000000..e7509c592
--- /dev/null
+++ b/unittest/tests/mocks/HkReceiverMock.h
@@ -0,0 +1,20 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_
+
+#include <fsfw/housekeeping/AcceptsHkPacketsIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+
+class HkReceiverMock: public SystemObject, public AcceptsHkPacketsIF {
+public:
+	HkReceiverMock(object_id_t objectId): SystemObject(objectId) {
+
+	}
+
+	MessageQueueId_t getHkQueue() const {
+		return MessageQueueIF::NO_QUEUE;
+	}
+};
+
+
+
+#endif /* FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_ */
diff --git a/unittest/tests/mocks/MessageQueueMockBase.h b/unittest/tests/mocks/MessageQueueMockBase.h
new file mode 100644
index 000000000..7b810b41f
--- /dev/null
+++ b/unittest/tests/mocks/MessageQueueMockBase.h
@@ -0,0 +1,121 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/MessageQueueMessage.h>
+#include <unittest/core/CatchDefinitions.h>
+#include <cstring>
+
+#include <queue>
+
+class MessageQueueMockBase: public MessageQueueIF {
+public:
+	MessageQueueId_t myQueueId = tconst::testQueueId;
+	uint8_t messageSentCounter = 0;
+	bool defaultDestSet = false;
+	bool messageSent = false;
+
+
+	bool wasMessageSent(uint8_t* messageSentCounter = nullptr,
+			bool resetCounter = true) {
+		bool tempMessageSent = messageSent;
+		messageSent = false;
+		if(messageSentCounter != nullptr) {
+			*messageSentCounter = this->messageSentCounter;
+		}
+		if(resetCounter) {
+			this->messageSentCounter = 0;
+		}
+		return tempMessageSent;
+	}
+
+	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return sendMessage(myQueueId, message);
+		return HasReturnvaluesIF::RETURN_OK;
+	};
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) {
+		return receiveMessage(message);
+	}
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
+		if(messagesSentQueue.empty()) {
+			return MessageQueueIF::EMPTY;
+		}
+
+		std::memcpy(message->getBuffer(), messagesSentQueue.front().getBuffer(),
+				message->getMessageSize());
+		messagesSentQueue.pop();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t flush(uint32_t* count) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual MessageQueueId_t getLastPartner() const {
+		return myQueueId;
+	}
+	virtual MessageQueueId_t getId() const {
+		return myQueueId;
+	}
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) {
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		//return HasReturnvaluesIF::RETURN_OK;
+		return sendMessage(sendTo, message);
+	}
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		//return HasReturnvaluesIF::RETURN_OK;
+		return sendMessage(myQueueId, message);
+	}
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return sendMessage(myQueueId, message);
+	}
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
+		messageSent = true;
+		messageSentCounter++;
+		MessageQueueMessage& messageRef = *(
+				dynamic_cast<MessageQueueMessage*>(message));
+		messagesSentQueue.push(messageRef);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+		myQueueId = defaultDestination;
+		defaultDestSet = true;
+	}
+
+	virtual MessageQueueId_t getDefaultDestination() const {
+		return myQueueId;
+	}
+	virtual bool isDefaultDestinationSet() const {
+		return defaultDestSet;
+	}
+
+	void clearMessages(bool clearCommandMessages = true) {
+		while(not messagesSentQueue.empty()) {
+			if(clearCommandMessages) {
+				CommandMessage message;
+				std::memcpy(message.getBuffer(),
+						messagesSentQueue.front().getBuffer(),
+						message.getMessageSize());
+				message.clear();
+			}
+			messagesSentQueue.pop();
+		}
+	}
+
+private:
+	std::queue<MessageQueueMessage> messagesSentQueue;
+	//MessageQueueMessage lastMessage;
+};
+
+
+#endif /* FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_ */
diff --git a/unittest/tests/storagemanager/TestNewAccessor.cpp b/unittest/tests/storagemanager/TestNewAccessor.cpp
index 7bd0dee2f..10d05c6b1 100644
--- a/unittest/tests/storagemanager/TestNewAccessor.cpp
+++ b/unittest/tests/storagemanager/TestNewAccessor.cpp
@@ -1,161 +1,161 @@
-//#include <fsfw/storagemanager/LocalPool.h>
-//#include <catch2/catch.hpp>
-//#include "../../core/CatchDefinitions.h"
-//#include <array>
-//
-//TEST_CASE( "New Accessor" , "[NewAccessor]") {
-//	uint16_t numberOfElements[1] = {1};
-//	uint16_t sizeofElements[1] = {10};
-//	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
-//	std::array<uint8_t, 20> testDataArray;
-//	std::array<uint8_t, 20> receptionArray;
-//	store_address_t testStoreId;
-//	ReturnValue_t result = retval::CATCH_FAILED;
-//
-//	for(size_t i = 0; i < testDataArray.size(); i++) {
-//		testDataArray[i] = i;
-//	}
-//	size_t size = 10;
-//
-//	SECTION ("Simple tests getter functions") {
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		auto resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//		resultPair.second.getDataCopy(receptionArray.data(), 20);
-//		CHECK(resultPair.second.getId() == testStoreId);
-//		CHECK(resultPair.second.size() == 10);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//
-//		std::copy(resultPair.second.data(), resultPair.second.data() +
-//				resultPair.second.size(), receptionArray.data());
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//
-//		{
-//			auto resultPairLoc = SimplePool.getData(testStoreId);
-//			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
-//			// data should be deleted when accessor goes out of scope.
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-//
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			ConstStorageAccessor constAccessor(testStoreId);
-//			result = SimplePool.getData(testStoreId, constAccessor);
-//			REQUIRE(result == retval::CATCH_OK);
-//			constAccessor.getDataCopy(receptionArray.data(), 20);
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			// likewise, data should be deleted when accessor gets out of scope.
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-//
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		{
-//			resultPair = SimplePool.getData(testStoreId);
-//			REQUIRE(resultPair.first == retval::CATCH_OK);
-//			resultPair.second.release();
-//			// now data should not be deleted anymore
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//		resultPair.second.getDataCopy(receptionArray.data(), 20);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//	}
-//
-//
-//	SECTION("Simple tests modify functions") {
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			StorageAccessor accessor(testStoreId);
-//			result = SimplePool.modifyData(testStoreId, accessor);
-//			REQUIRE(result == retval::CATCH_OK);
-//			CHECK(accessor.getId() == testStoreId);
-//			CHECK(accessor.size() == 10);
-//			accessor.getDataCopy(receptionArray.data(), 20);
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			std::copy(accessor.data(), accessor.data() +
-//					accessor.size(), receptionArray.data());
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			// data should be deleted when accessor goes out of scope
-//		}
-//		auto resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-//
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			auto resultPairLoc = SimplePool.modifyData(testStoreId);
-//			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
-//			CHECK(resultPairLoc.second.getId() == testStoreId);
-//			CHECK(resultPairLoc.second.size() == 10);
-//			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
-//					resultPairLoc.second.size(), receptionArray.data());
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			resultPairLoc.second.release();
-//			// data should not be deleted when accessor goes out of scope
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//	}
-//
-//
-//	SECTION("Write tests") {
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			auto resultPair = SimplePool.modifyData(testStoreId);
-//			REQUIRE(resultPair.first == retval::CATCH_OK);
-//			testDataArray[9] = 42;
-//			resultPair.second.write(testDataArray.data(), 10, 0);
-//			// now data should not be deleted
-//			resultPair.second.release();
-//		}
-//		auto resultConstPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultConstPair.first == retval::CATCH_OK);
-//
-//		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
-//		for(size_t i = 0; i < size-1; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//		CHECK(receptionArray[9] == 42 );
-//
-//		auto resultPair = SimplePool.modifyData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//		result = resultPair.second.write(testDataArray.data(), 20, 0);
-//		REQUIRE(result == retval::CATCH_FAILED);
-//		result = resultPair.second.write(testDataArray.data(), 10, 5);
-//		REQUIRE(result == retval::CATCH_FAILED);
-//
-//		memset(testDataArray.data(), 42, 5);
-//		result = resultPair.second.write(testDataArray.data(), 5, 5);
-//		REQUIRE(result == retval::CATCH_OK);
-//		resultConstPair = SimplePool.getData(testStoreId);
-//		resultPair.second.getDataCopy(receptionArray.data(), 20);
-//		for(size_t i = 5; i < 10; i++) {
-//			CHECK(receptionArray[i] == 42 );
-//		}
-//
-//	}
-//}
+#include <fsfw/storagemanager/LocalPool.h>
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+#include <array>
+#include <cstring>
+
+TEST_CASE( "New Accessor" , "[NewAccessor]") {
+	LocalPool::LocalPoolConfig poolCfg = {{1, 10}};
+	LocalPool SimplePool = LocalPool(0, poolCfg);
+	std::array<uint8_t, 20> testDataArray;
+	std::array<uint8_t, 20> receptionArray;
+	store_address_t testStoreId;
+	ReturnValue_t result = retval::CATCH_FAILED;
+
+	for(size_t i = 0; i < testDataArray.size(); i++) {
+		testDataArray[i] = i;
+	}
+	size_t size = 10;
+
+	SECTION ("Simple tests getter functions") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		auto resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		CHECK(resultPair.second.getId() == testStoreId);
+		CHECK(resultPair.second.size() == 10);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		std::copy(resultPair.second.data(), resultPair.second.data() +
+				resultPair.second.size(), receptionArray.data());
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		{
+			auto resultPairLoc = SimplePool.getData(testStoreId);
+			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+			// data should be deleted when accessor goes out of scope.
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			ConstStorageAccessor constAccessor(testStoreId);
+			result = SimplePool.getData(testStoreId, constAccessor);
+			REQUIRE(result == retval::CATCH_OK);
+			constAccessor.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			// likewise, data should be deleted when accessor gets out of scope.
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		{
+			resultPair = SimplePool.getData(testStoreId);
+			REQUIRE(resultPair.first == retval::CATCH_OK);
+			resultPair.second.release();
+			// now data should not be deleted anymore
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+	}
+
+
+	SECTION("Simple tests modify functions") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			StorageAccessor accessor(testStoreId);
+			result = SimplePool.modifyData(testStoreId, accessor);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(accessor.getId() == testStoreId);
+			CHECK(accessor.size() == 10);
+			accessor.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			std::copy(accessor.data(), accessor.data() +
+					accessor.size(), receptionArray.data());
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			// data should be deleted when accessor goes out of scope
+		}
+		auto resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			auto resultPairLoc = SimplePool.modifyData(testStoreId);
+			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+			CHECK(resultPairLoc.second.getId() == testStoreId);
+			CHECK(resultPairLoc.second.size() == 10);
+			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
+					resultPairLoc.second.size(), receptionArray.data());
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			resultPairLoc.second.release();
+			// data should not be deleted when accessor goes out of scope
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+	}
+
+
+	SECTION("Write tests") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			auto resultPair = SimplePool.modifyData(testStoreId);
+			REQUIRE(resultPair.first == retval::CATCH_OK);
+			testDataArray[9] = 42;
+			resultPair.second.write(testDataArray.data(), 10, 0);
+			// now data should not be deleted
+			resultPair.second.release();
+		}
+		auto resultConstPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultConstPair.first == retval::CATCH_OK);
+
+		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
+		for(size_t i = 0; i < size-1; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+		CHECK(receptionArray[9] == 42 );
+
+		auto resultPair = SimplePool.modifyData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		result = resultPair.second.write(testDataArray.data(), 20, 0);
+		REQUIRE(result == retval::CATCH_FAILED);
+		result = resultPair.second.write(testDataArray.data(), 10, 5);
+		REQUIRE(result == retval::CATCH_FAILED);
+
+		std::memset(testDataArray.data(), 42, 5);
+		result = resultPair.second.write(testDataArray.data(), 5, 5);
+		REQUIRE(result == retval::CATCH_OK);
+		resultConstPair = SimplePool.getData(testStoreId);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		for(size_t i = 5; i < 10; i++) {
+			CHECK(receptionArray[i] == 42 );
+		}
+
+	}
+}
diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
index dcfb6c035..50bde01ab 100644
--- a/unittest/tests/storagemanager/TestPool.cpp
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -8,8 +8,6 @@
 
 
 TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
-//	uint16_t numberOfElements[1] = {1};
-//	uint16_t sizeofElements[1] = {10};
 	LocalPool::LocalPoolConfig config = {{1, 10}};
 	LocalPool simplePool(0, config);
 	std::array<uint8_t, 20> testDataArray;
diff --git a/unittest/user/CMakeLists.txt b/unittest/user/CMakeLists.txt
index 6ec314c3b..722cc424c 100644
--- a/unittest/user/CMakeLists.txt
+++ b/unittest/user/CMakeLists.txt
@@ -13,7 +13,19 @@ cmake_minimum_required(VERSION 3.13)
 
 # set(CMAKE_VERBOSE TRUE)
 
-set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/buildsystem/cmake")
+set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+option(TMTC_TEST "Build binary for manual or automatic TMTC tests" FALSE)
+option(GENERATE_COVERAGE 
+	"Specify whether coverage data is generated with GCOV" 
+	TRUE
+)
+
+if(TMTC_TEST)
+	set(LINK_CATCH2 FALSE)
+else()
+	set(LINK_CATCH2 TRUE)
+endif()
 
 # Tests can be built with the Host OSAL or with the Linux OSAL.
 if(NOT OS_FSFW)
@@ -53,6 +65,7 @@ set(FSFW_PATH fsfw)
 set(CATCH2_PATH Catch2)
 set(FSFW_TESTS_PATH fsfw/unittest)
 set(TEST_SETUP_PATH unittest)
+set(TMTC_TEST_PATH tests)
 
 # Analyse different OS and architecture/target options and
 # determine BSP_PATH
@@ -71,6 +84,15 @@ else()
 	endif()
 endif()
 
+if(GENERATE_COVERAGE)
+	list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/cmake-modules)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+    	include(CodeCoverage)
+    	# Add compile options on target base, we don't want coverage for Catch2
+    	# append_coverage_compiler_flags()
+   	endif()
+endif()
+
 set(FSFW_CONFIG_PATH testcfg)
 
 ################################################################################
@@ -82,10 +104,16 @@ add_executable(${TARGET_NAME})
 
 # Add subdirectories
 add_subdirectory(${FSFW_PATH})
-add_subdirectory(${CATCH2_PATH})
 add_subdirectory(${FSFW_CONFIG_PATH})
-add_subdirectory(${FSFW_TESTS_PATH})
-add_subdirectory(${TEST_SETUP_PATH})
+
+if(LINK_CATCH2)
+	add_subdirectory(${CATCH2_PATH})
+	add_subdirectory(${FSFW_TESTS_PATH})
+	add_subdirectory(${TEST_SETUP_PATH})
+else()
+	add_subdirectory(${TMTC_TEST_PATH})
+endif()
+
 
 ################################################################################
 # Post-Sources preparation
@@ -94,9 +122,74 @@ add_subdirectory(${TEST_SETUP_PATH})
 # Add libraries for all sources.
 target_link_libraries(${TARGET_NAME} PRIVATE
 	${LIB_FSFW_NAME} 
-	${CATCH2_TARGET}
 )
 
+if(LINK_CATCH2)
+	target_link_libraries(${TARGET_NAME} PRIVATE
+		${CATCH2_TARGET}
+	)
+endif()
+
+if(GENERATE_COVERAGE)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+		set(CODE_COVERAGE_VERBOSE TRUE)
+    	include(CodeCoverage)
+    	
+    	# Remove quotes.
+    	separate_arguments(COVERAGE_COMPILER_FLAGS 
+    		NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}"
+    	)
+    	
+    	# Add compile options manually, we don't want coverage for Catch2
+    	target_compile_options(${TARGET_NAME} PRIVATE
+    		"${COVERAGE_COMPILER_FLAGS}"
+    	)
+    	target_compile_options(${LIB_FSFW_NAME} PRIVATE
+    		"${COVERAGE_COMPILER_FLAGS}"
+    	)
+    	
+		# Exclude internal unittest from coverage for now.
+    	if(WIN32)
+			set(GCOVR_ADDITIONAL_ARGS 
+				"--exclude-throw-branches"
+				"--exclude-unreachable-branches"
+			)
+			set(COVERAGE_EXCLUDES
+				"/c/msys64/mingw64/*" "Catch2"
+				"${CMAKE_CURRENT_SOURCE_DIR}/fsfw/unittest/internal"
+			)
+		elseif(UNIX)
+			set(COVERAGE_EXCLUDES
+				"/usr/include/*" "/usr/bin/*" "Catch2/*"
+				"fsfw/unittest/internal/*"
+			)
+		endif()
+    	
+		target_link_options(${TARGET_NAME} PRIVATE
+			-fprofile-arcs
+			-ftest-coverage
+    	)
+    	target_link_options(${LIB_FSFW_NAME} PRIVATE
+			-fprofile-arcs
+			-ftest-coverage
+    	)
+    	
+		if(WIN32)
+			setup_target_for_coverage_gcovr_html(
+				NAME ${TARGET_NAME}_coverage
+				EXECUTABLE ${TARGET_NAME}
+				DEPENDENCIES ${TARGET_NAME}
+			)
+    	else()
+			setup_target_for_coverage_lcov(
+				NAME ${TARGET_NAME}_coverage
+				EXECUTABLE ${TARGET_NAME}
+				DEPENDENCIES ${TARGET_NAME}
+			)
+		endif()
+	endif()
+endif()
+
 # Add include paths for all sources.
 target_include_directories(${TARGET_NAME} PRIVATE
 	${CMAKE_CURRENT_SOURCE_DIR}
@@ -147,8 +240,7 @@ if(NOT CMAKE_SIZE)
 	endif()
 endif()
 
-add_custom_command(
-   TARGET ${TARGET_NAME}
+add_custom_command(TARGET ${TARGET_NAME}
    POST_BUILD
    COMMAND echo "Build directory: ${CMAKE_BINARY_DIR}"
    COMMAND echo "Target OSAL: ${OS_FSFW}"
@@ -156,7 +248,7 @@ add_custom_command(
    COMMAND ${CMAKE_SIZE} ${TARGET_NAME}${FILE_SUFFIX}
 )
 
-include (${CMAKE_CURRENT_SOURCE_DIR}/buildsystem/cmake/BuildType.cmake)
+include (${CMAKE_SCRIPT_PATH}/BuildType.cmake)
 set_build_type()
 
 
diff --git a/unittest/user/testcfg/FSFWConfig.h b/unittest/user/testcfg/FSFWConfig.h
index 6b0def902..ed86e6e1f 100644
--- a/unittest/user/testcfg/FSFWConfig.h
+++ b/unittest/user/testcfg/FSFWConfig.h
@@ -4,16 +4,21 @@
 #include <cstddef>
 #include <cstdint>
 
-//! Used to determine whether C++ ostreams are used
-//! Those can lead to code bloat.
+//! Used to determine whether C++ ostreams are used which can increase
+//! the binary size significantly. If this is disabled,
+//! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrease code size
-//! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_ENHANCED_PRINTOUT		0
+//! More FSFW related printouts depending on level. Useful for development.
+#define FSFW_VERBOSE_LEVEL			1
 
-//! Can be used to enable additional debugging printouts for developing the FSFW
-#define FSFW_PRINT_VERBOSITY_LEVEL   0
+//! Can be used to completely disable printouts, even the C stdio ones.
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
+	#define FSFW_DISABLE_PRINTOUT 	0
+#endif
+
+//! Can be used to disable the ANSI color sequences for C stdio.
+#define FSFW_COLORED_OUTPUT 		1
 
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
@@ -49,7 +54,9 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 //! also determines how many commands a CSB service can handle in one cycle
 //! simulataneously. This will increase the required RAM for
 //! each CSB service !
-static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 3;
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
+
+static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/unittest/user/testcfg/objects/systemObjectList.h b/unittest/user/testcfg/objects/systemObjectList.h
index 0e034aff8..88b92131c 100644
--- a/unittest/user/testcfg/objects/systemObjectList.h
+++ b/unittest/user/testcfg/objects/systemObjectList.h
@@ -9,7 +9,20 @@ namespace objects {
 	enum sourceObjects: uint32_t {
 		/* All addresses between start and end are reserved for the FSFW */
 		FSFW_CONFIG_RESERVED_START = PUS_SERVICE_1_VERIFICATION,
-		FSFW_CONFIG_RESERVED_END = TM_STORE
+		FSFW_CONFIG_RESERVED_END = TM_STORE,
+
+		CCSDS_DISTRIBUTOR = 10,
+		PUS_DISTRIBUTOR = 11,
+		TM_FUNNEL = 12,
+
+		UDP_BRIDGE = 15,
+		UDP_POLLING_TASK = 16,
+
+		TEST_ECHO_COM_IF = 20,
+		TEST_DEVICE = 21,
+
+		HK_RECEIVER_MOCK = 22,
+		TEST_LOCAL_POOL_OWNER_BASE = 25
 	};
 }
 
diff --git a/unittest/user/unittest/CMakeLists.txt b/unittest/user/unittest/CMakeLists.txt
new file mode 100644
index 000000000..ad6d4787c
--- /dev/null
+++ b/unittest/user/unittest/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(core)
diff --git a/unittest/user/unittest/core/CMakeLists.txt b/unittest/user/unittest/core/CMakeLists.txt
index d78f45f18..0989926c3 100644
--- a/unittest/user/unittest/core/CMakeLists.txt
+++ b/unittest/user/unittest/core/CMakeLists.txt
@@ -5,3 +5,9 @@ target_sources(${TARGET_NAME} PRIVATE
 	CatchSetup.cpp
 	printChar.cpp
 )
+
+if(CUSTOM_UNITTEST_RUNNER)
+	target_sources(${TARGET_NAME} PRIVATE
+		CatchRunner.cpp
+	)
+endif()
\ No newline at end of file
diff --git a/unittest/user/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
index 00daf0156..bae028759 100644
--- a/unittest/user/unittest/core/CatchDefinitions.cpp
+++ b/unittest/user/unittest/core/CatchDefinitions.cpp
@@ -1,4 +1,5 @@
 #include "CatchDefinitions.h"
+#include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
 
 StorageManagerIF* tglob::getIpcStoreHandle() {
@@ -7,7 +8,9 @@ StorageManagerIF* tglob::getIpcStoreHandle() {
 	} else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;
-#endif
+#else
+		sif::printError("Global object manager uninitialized\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return nullptr;
 	}
 }
diff --git a/unittest/user/unittest/core/CatchFactory.cpp b/unittest/user/unittest/core/CatchFactory.cpp
index 3177212f4..eabaa21df 100644
--- a/unittest/user/unittest/core/CatchFactory.cpp
+++ b/unittest/user/unittest/core/CatchFactory.cpp
@@ -1,11 +1,17 @@
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include "CatchFactory.h"
 
 #include <fsfw/events/EventManager.h>
 #include <fsfw/health/HealthTable.h>
-
 #include <fsfw/internalError/InternalErrorReporter.h>
 #include <fsfw/objectmanager/frameworkObjects.h>
 #include <fsfw/storagemanager/PoolManager.h>
+#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
+#include <fsfw/unittest/tests/datapoollocal/LocalPoolOwnerBase.h>
+#include <fsfw/unittest/tests/mocks/HkReceiverMock.h>
 
 /**
  * @brief Produces system objects.
@@ -26,6 +32,9 @@ void Factory::produce(void) {
 	new HealthTable(objects::HEALTH_TABLE);
 	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
 
+	new LocalPoolOwnerBase (objects::TEST_LOCAL_POOL_OWNER_BASE);
+	new HkReceiverMock(objects::HK_RECEIVER_MOCK);
+
 	{
 		PoolManager::LocalPoolConfig poolCfg = {
 		        {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
@@ -50,7 +59,23 @@ void Factory::produce(void) {
 }
 
 void Factory::setStaticFrameworkObjectIds() {
+	PusServiceBase::packetSource = objects::NO_OBJECT;
+	PusServiceBase::packetDestination = objects::NO_OBJECT;
 
+	CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+	CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
+
+	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+
+	DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+	DeviceHandlerBase::rawDataReceiverId = objects::PUS_SERVICE_2_DEVICE_ACCESS;
+
+	LocalDataPoolManager::defaultHkDestination = objects::HK_RECEIVER_MOCK;
+
+	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
+
+	TmPacketStored::timeStamperId = objects::NO_OBJECT;
 }
 
 
+
diff --git a/unittest/user/unittest/core/CatchRunner.cpp b/unittest/user/unittest/core/CatchRunner.cpp
index 35c53cd47..886d641f3 100644
--- a/unittest/user/unittest/core/CatchRunner.cpp
+++ b/unittest/user/unittest/core/CatchRunner.cpp
@@ -1,17 +1,16 @@
 /**
- * @file 	CatchSource.cpp
+ * @file 	CatchRunner.cpp
  * @brief 	Source file to compile catch framework.
  * @details	All tests should be written in other files.
  * For eclipse console output, install ANSI Escape in Console
  * from the eclipse market place to get colored characters.
  */
 
-#ifndef NO_UNIT_TEST_FRAMEWORK
+#include <TestsConfig.h>
 
-#define CATCH_CONFIG_RUNNER
-#include <catch2/catch.hpp>
+#define CATCH_CONFIG_COLOUR_WINDOWS
 
-#if CUSTOM_UNITTEST_RUNNER == 0
+#include <catch2/catch_session.hpp>
 
 extern int customSetup();
 
@@ -25,7 +24,3 @@ int main( int argc, char* argv[] ) {
     return result;
 }
 
-#endif
-
-
-#endif
diff --git a/unittest/user/unittest/core/CatchSetup.cpp b/unittest/user/unittest/core/CatchSetup.cpp
index c93cf0323..bda314003 100644
--- a/unittest/user/unittest/core/CatchSetup.cpp
+++ b/unittest/user/unittest/core/CatchSetup.cpp
@@ -1,21 +1,20 @@
-#include <fsfw/unittest/core/CatchFactory.h>
+#include "CatchFactory.h"
 #include "CatchDefinitions.h"
-#include <testcfg/cdatapool/dataPoolInit.h>
 
 #ifdef GCOV
 #include <gcov.h>
 #endif
 
-#include "../../objectmanager/ObjectManager.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../storagemanager/StorageManagerIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/storagemanager/StorageManagerIF.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 
 
 /* Global instantiations normally done in main.cpp */
 /* Initialize Data Pool */
 
-
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 namespace sif {
 /* Set up output streams */
 ServiceInterfaceStream debug("DEBUG");
@@ -23,6 +22,7 @@ ServiceInterfaceStream info("INFO");
 ServiceInterfaceStream error("ERROR");
 ServiceInterfaceStream warning("WARNING");
 }
+#endif
 
 /* Global object manager */
 ObjectManagerIF *objectManager;
diff --git a/unittest/user/unittest/core/printChar.cpp b/unittest/user/unittest/core/printChar.cpp
index 755a13b22..5d4f1b173 100644
--- a/unittest/user/unittest/core/printChar.cpp
+++ b/unittest/user/unittest/core/printChar.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/unittest/core/printChar.h>
+#include "printChar.h"
 #include <cstdio>
 
 void printChar(const char* character, bool errStream) {

From eb6a8519358270a8560bc6d77a55a4f08854dc7c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 12:02:23 +0100
Subject: [PATCH 1456/1774] pool entry update

---
 datapool/PoolEntry.cpp | 42 ++++++++++++++++-------------
 datapool/PoolEntry.h   | 61 +++++++++++++++++++++++-------------------
 2 files changed, 58 insertions(+), 45 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 583751626..a5867222b 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,32 +1,24 @@
 #include "PoolEntry.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../globalfunctions/arrayprinter.h"
 #include <cstring>
 #include <algorithm>
 
 template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
-		bool setValid ) : length(setLength), valid(setValid) {
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, bool setValid ):
+		length(initValue.size()), valid(setValid) {
 	this->address = new T[this->length];
 	if(initValue.size() == 0) {
 		std::memset(this->address, 0, this->getByteSize());
 	}
-	else if (initValue.size() != setLength){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "PoolEntry: setLength is not equal to initializer list"
-				"length! Performing zero initialization with given setLength"
-				<< std::endl;
-#endif
-		std::memset(this->address, 0, this->getByteSize());
-	}
 	else {
 		std::copy(initValue.begin(), initValue.end(), this->address);
 	}
 }
 
 template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t setLength, bool setValid ) :
+PoolEntry<T>::PoolEntry(T* initValue, uint8_t setLength, bool setValid):
 		length(setLength), valid(setValid) {
 	this->address = new T[this->length];
 	if (initValue != nullptr) {
@@ -70,14 +62,26 @@ bool PoolEntry<T>::getValid() {
 
 template <typename T>
 void PoolEntry<T>::print() {
+	const char* validString = nullptr;
+	if(valid) {
+		validString = "Valid";
+	}
+	else {
+		validString = "Invalid";
+	}
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	 sif::debug << "Pool Entry Validity: " <<
-			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
-#endif
-	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::debug << std::dec << std::endl;
+	 sif::info << "PoolEntry information." << std::endl;
+	 sif::info << "PoolEntry validity: " << validString << std::endl;
+#else
+	 sif::printInfo("PoolEntry information.\n");
+	 sif::printInfo("PoolEntry validity: %s\n", validString);
 #endif
+	arrayprinter::print(reinterpret_cast<uint8_t*>(address), getByteSize());
+}
+
+template<typename T>
+inline T* PoolEntry<T>::getDataPtr() {
+	return this->address;
 }
 
 template<typename T>
@@ -88,8 +92,10 @@ Type PoolEntry<T>::getType() {
 template class PoolEntry<uint8_t>;
 template class PoolEntry<uint16_t>;
 template class PoolEntry<uint32_t>;
+template class PoolEntry<uint64_t>;
 template class PoolEntry<int8_t>;
 template class PoolEntry<int16_t>;
 template class PoolEntry<int32_t>;
+template class PoolEntry<int64_t>;
 template class PoolEntry<float>;
 template class PoolEntry<double>;
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 033db40d0..30940320c 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -35,24 +35,22 @@ public:
 				"uint8_t");
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
-	 * 			potential init values are copied to that space.
+	 * 			potential initialization values are copied to that space.
 	 * @details
 	 * Not passing any arguments will initialize an non-array pool entry
-	 * (setLength = 1) with an initial invalid state.
-	 * Please note that if an initializer list is passed, the correct
-	 * corresponding length should be passed too, otherwise a zero
-	 * initialization will be performed with the given setLength.
+	 * with an initial invalid state and the value 0.
+	 * Please note that if an initializer list is passed, the length of the
+	 * initializer list needs to be correct for vector entries because
+	 * required allocated space will be deduced from the initializer list length
+	 * and the pool entry type.
 	 * @param initValue
-	 * Initializer list with values to initialize with, for example {0,0} to
-	 * initialize the two entries to zero.
-	 * @param setLength
-	 * Defines the array length of this entry. Should be equal to the
-	 * intializer list length.
+	 * Initializer list with values to initialize with, for example {0, 0} to
+	 * initialize the a pool entry of a vector with two entries to 0.
 	 * @param setValid
 	 * Sets the initialization flag. It is invalid by default.
 	 */
-	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
-			bool setValid = false);
+	PoolEntry(std::initializer_list<T> initValue = {0}, bool setValid = false);
+
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
 	 * 			potential init values are copied to that space.
@@ -66,9 +64,9 @@ public:
 	 */
 	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
 
-	//! Explicitely deleted copy ctor, copying is not allowed!
+	//! Explicitely deleted copy ctor, copying is not allowed.
 	PoolEntry(const PoolEntry&) = delete;
-	//! Explicitely deleted copy assignment, copying is not allowed!
+	//! Explicitely deleted copy assignment, copying is not allowed.
 	PoolEntry& operator=(const PoolEntry&) = delete;
 
 	/**
@@ -82,21 +80,16 @@ public:
 	~PoolEntry();
 
 	/**
-	 * @brief	This is the address pointing to the allocated memory.
+	 * Return typed pointer to start of data.
+	 * @return
 	 */
-	T* address;
-	/**
-	 * @brief	This attribute stores the length information.
-	 */
-	uint8_t length;
-	/**
-	 * @brief	Here, the validity information for a variable is stored.
-	 * 			Every entry (single variable or vector) has one valid flag.
-	 */
-	uint8_t valid;
+	T* getDataPtr();
+
 	/**
 	 * @brief	getSize returns the array size of the entry.
-	 * @details	A single parameter has size 1.
+	 * @details
+	 * For non-array pool entries return type size, for vector entries
+	 * return type size times the number of entries.
 	 */
 	uint8_t getSize();
 	/**
@@ -123,8 +116,22 @@ public:
 	 * 			information to the screen. It prints all array entries in a row.
 	 */
 	void print();
-
 	Type getType();
+
+private:
+	/**
+	 * @brief	This attribute stores the length information.
+	 */
+	uint8_t length;
+	/**
+	 * @brief	Here, the validity information for a variable is stored.
+	 * 			Every entry (single variable or vector) has one valid flag.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	This is the address pointing to the allocated memory.
+	 */
+	T* address;
 };
 
 #endif /* FSFW_DATAPOOL_POOLENTRY_H_ */

From c3bca518e707f8dd563f39b9e873b949d58f6961 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 12:12:08 +0100
Subject: [PATCH 1457/1774] bugfixes and auto indentation

---
 datapoollocal/LocalPoolDataSetBase.cpp | 369 +++++++++++++------------
 1 file changed, 186 insertions(+), 183 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 5343a9c91..f3cd71065 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -11,47 +11,50 @@
 #include <cstring>
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-        uint32_t setId, PoolVariableIF** registeredVariablesArray,
-        const size_t maxNumberOfVariables, bool periodicHandling):
-        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-    if(hkOwner == nullptr) {
-        // Configuration error.
+		uint32_t setId, PoolVariableIF** registeredVariablesArray,
+		const size_t maxNumberOfVariables, bool periodicHandling):
+		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+	if(hkOwner == nullptr) {
+		// Configuration error.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-                << "invalid!" << std::endl;
+		sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+				<< "invalid!" << std::endl;
 #else
-        sif::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-                "invalid!\n\r");
+		sif::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+				"invalid!\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-        return;
-    }
-    AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+		return;
+	}
+	AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
 
-    if(poolManager != nullptr) {
-        poolManager = accessor->getHkManagerHandle();
-    	mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
-    }
+	if(accessor != nullptr) {
+		poolManager = accessor->getHkManagerHandle();
+		mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
+	}
 
-    this->sid.objectId = hkOwner->getObjectId();
-    this->sid.ownerSetId = setId;
+	this->sid.objectId = hkOwner->getObjectId();
+	this->sid.ownerSetId = setId;
 
-    // Data creators get a periodic helper for periodic HK data generation.
-    if(periodicHandling) {
-        periodicHelper = new PeriodicHousekeepingHelper(this);
-    }
+	// Data creators get a periodic helper for periodic HK data generation.
+	if(periodicHandling) {
+		periodicHelper = new PeriodicHousekeepingHelper(this);
+	}
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
-        PoolVariableIF** registeredVariablesArray,
-        const size_t maxNumberOfVariables):
+		PoolVariableIF** registeredVariablesArray,
+		const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
-	AccessPoolManagerIF* hkOwner = objectManager->get<AccessPoolManagerIF>(
-            sid.objectId);
-    if(hkOwner != nullptr) {
-    	mutexIfSingleDataCreator = hkOwner->getLocalPoolMutex();
-    }
+	HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+			sid.objectId);
+	if(hkOwner != nullptr) {
+		AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+		if(accessor != nullptr) {
+			mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
+		}
+	}
 
-    this->sid = sid;
+	this->sid = sid;
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(
@@ -72,240 +75,240 @@ ReturnValue_t LocalPoolDataSetBase::lockDataPool(
 		MutexIF::TimeoutType timeoutType,
 		uint32_t timeoutMs) {
 	if(mutexIfSingleDataCreator != nullptr) {
-	    return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
+		return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
-        size_t *size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-    uint8_t validityMask[validityMaskSize];
-    uint8_t validBufferIndex = 0;
-    uint8_t validBufferIndexBit = 0;
-    for (uint16_t count = 0; count < fillCount; count++) {
-        if(registeredVariables[count]->isValid()) {
-            // set validity buffer here.
-            this->bitSetter(validityMask + validBufferIndex,
-                    validBufferIndexBit);
-            if(validBufferIndexBit == 7) {
-                validBufferIndex ++;
-                validBufferIndexBit = 0;
-            }
-            else {
-                validBufferIndexBit ++;
-            }
-        }
-        result = registeredVariables[count]->serialize(buffer, size, maxSize,
-                streamEndianness);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-    }
+		size_t *size, size_t maxSize,
+		SerializeIF::Endianness streamEndianness) const {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+	uint8_t validityMask[validityMaskSize];
+	uint8_t validBufferIndex = 0;
+	uint8_t validBufferIndexBit = 0;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if(registeredVariables[count]->isValid()) {
+			// set validity buffer here.
+			this->bitSetter(validityMask + validBufferIndex,
+					validBufferIndexBit);
+			if(validBufferIndexBit == 7) {
+				validBufferIndex ++;
+				validBufferIndexBit = 0;
+			}
+			else {
+				validBufferIndexBit ++;
+			}
+		}
+		result = registeredVariables[count]->serialize(buffer, size, maxSize,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
 
-    if(*size + validityMaskSize > maxSize) {
-        return SerializeIF::BUFFER_TOO_SHORT;
-    }
-    // copy validity buffer to end
-    std::memcpy(*buffer, validityMask, validityMaskSize);
-    *size += validityMaskSize;
-    return result;
+	if(*size + validityMaskSize > maxSize) {
+		return SerializeIF::BUFFER_TOO_SHORT;
+	}
+	// copy validity buffer to end
+	std::memcpy(*buffer, validityMask, validityMaskSize);
+	*size += validityMaskSize;
+	return result;
 }
 
 ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
-        const uint8_t **buffer, size_t *size,
-        SerializeIF::Endianness streamEndianness) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    for (uint16_t count = 0; count < fillCount; count++) {
-        result = registeredVariables[count]->deSerialize(buffer, size,
-                streamEndianness);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-    }
+		const uint8_t **buffer, size_t *size,
+		SerializeIF::Endianness streamEndianness) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		result = registeredVariables[count]->deSerialize(buffer, size,
+				streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
 
-    if(*size < std::ceil(static_cast<float>(fillCount) / 8.0)) {
-        return SerializeIF::STREAM_TOO_SHORT;
-    }
+	if(*size < std::ceil(static_cast<float>(fillCount) / 8.0)) {
+		return SerializeIF::STREAM_TOO_SHORT;
+	}
 
-    uint8_t validBufferIndex = 0;
-    uint8_t validBufferIndexBit = 0;
-    for (uint16_t count = 0; count < fillCount; count++) {
-        // set validity buffer here.
-        bool nextVarValid = this->bitGetter(*buffer +
-                validBufferIndex, validBufferIndexBit);
-        registeredVariables[count]->setValid(nextVarValid);
+	uint8_t validBufferIndex = 0;
+	uint8_t validBufferIndexBit = 0;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		// set validity buffer here.
+		bool nextVarValid = this->bitGetter(*buffer +
+				validBufferIndex, validBufferIndexBit);
+		registeredVariables[count]->setValid(nextVarValid);
 
-        if(validBufferIndexBit == 7) {
-            validBufferIndex ++;
-            validBufferIndexBit = 0;
-        }
-        else {
-            validBufferIndexBit ++;
-        }
-    }
-    return result;
+		if(validBufferIndexBit == 7) {
+			validBufferIndex ++;
+			validBufferIndexBit = 0;
+		}
+		else {
+			validBufferIndexBit ++;
+		}
+	}
+	return result;
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
 	if(mutexIfSingleDataCreator != nullptr) {
-	    return mutexIfSingleDataCreator->unlockMutex();
+		return mutexIfSingleDataCreator->unlockMutex();
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, size_t maxSize,SerializeIF::Endianness streamEndianness,
-        bool serializeFillCount) const {
-    // Serialize as uint8_t
-    uint8_t fillCount = this->fillCount;
-    if(serializeFillCount) {
-        SerializeAdapter::serialize(&fillCount, buffer, size, maxSize,
-                streamEndianness);
-    }
-    for (uint16_t count = 0; count < fillCount; count++) {
-        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
-                size, maxSize, streamEndianness);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
+		size_t* size, size_t maxSize,SerializeIF::Endianness streamEndianness,
+		bool serializeFillCount) const {
+	// Serialize as uint8_t
+	uint8_t fillCount = this->fillCount;
+	if(serializeFillCount) {
+		SerializeAdapter::serialize(&fillCount, buffer, size, maxSize,
+				streamEndianness);
+	}
+	for (uint16_t count = 0; count < fillCount; count++) {
+		lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
+		auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
+				size, maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
-            		<< "Serialization error!" << std::endl;
+		sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
+				<< "Serialization error!" << std::endl;
 #else
-            sif::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
-            		"Serialization error!\n\r");
+		sif::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
+				"Serialization error!\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-            return result;
-        }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+		return result;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 
 uint8_t LocalPoolDataSetBase::getLocalPoolIdsSerializedSize(
-        bool serializeFillCount) const {
-    if(serializeFillCount) {
-        return fillCount * sizeof(lp_id_t) + sizeof(uint8_t);
-    }
-    else {
-        return fillCount * sizeof(lp_id_t);
-    }
+		bool serializeFillCount) const {
+	if(serializeFillCount) {
+		return fillCount * sizeof(lp_id_t) + sizeof(uint8_t);
+	}
+	else {
+		return fillCount * sizeof(lp_id_t);
+	}
 }
 
 size_t LocalPoolDataSetBase::getSerializedSize() const {
-    if(withValidityBuffer) {
-        uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-        return validityMaskSize + PoolDataSetBase::getSerializedSize();
-    }
-    else {
-        return PoolDataSetBase::getSerializedSize();
-    }
+	if(withValidityBuffer) {
+		uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+		return validityMaskSize + PoolDataSetBase::getSerializedSize();
+	}
+	else {
+		return PoolDataSetBase::getSerializedSize();
+	}
 }
 
 void LocalPoolDataSetBase::setValidityBufferGeneration(
-        bool withValidityBuffer) {
-    this->withValidityBuffer = withValidityBuffer;
+		bool withValidityBuffer) {
+	this->withValidityBuffer = withValidityBuffer;
 }
 
 ReturnValue_t LocalPoolDataSetBase::deSerialize(const uint8_t **buffer,
-        size_t *size, SerializeIF::Endianness streamEndianness) {
-    if(withValidityBuffer) {
-        return this->deSerializeWithValidityBuffer(buffer, size,
-                streamEndianness);
-    }
-    else {
-        return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
-    }
+		size_t *size, SerializeIF::Endianness streamEndianness) {
+	if(withValidityBuffer) {
+		return this->deSerializeWithValidityBuffer(buffer, size,
+				streamEndianness);
+	}
+	else {
+		return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
+	}
 }
 
 ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
-        size_t maxSize, SerializeIF::Endianness streamEndianness) const {
-    if(withValidityBuffer) {
-        return this->serializeWithValidityBuffer(buffer, size,
-                maxSize, streamEndianness);
-    }
-    else {
-        return PoolDataSetBase::serialize(buffer, size, maxSize,
-                streamEndianness);
-    }
+		size_t maxSize, SerializeIF::Endianness streamEndianness) const {
+	if(withValidityBuffer) {
+		return this->serializeWithValidityBuffer(buffer, size,
+				maxSize, streamEndianness);
+	}
+	else {
+		return PoolDataSetBase::serialize(buffer, size, maxSize,
+				streamEndianness);
+	}
 }
 
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
-    if(position > 7) {
+	if(position > 7) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
-                << std::endl;
+		sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
+		<< std::endl;
 #else
-        sif::printWarning("LocalPoolDataSetBase::bitSetter: "
-        		"Invalid position!\n\r");
+		sif::printWarning("LocalPoolDataSetBase::bitSetter: "
+				"Invalid position!\n\r");
 #endif
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
+		return;
+	}
+	uint8_t shiftNumber = position + (7 - 2 * position);
+	*byte |= 1 << shiftNumber;
 }
 
 void LocalPoolDataSetBase::setDiagnostic(bool isDiagnostics) {
-    this->diagnostic = isDiagnostics;
+	this->diagnostic = isDiagnostics;
 }
 
 bool LocalPoolDataSetBase::isDiagnostics() const {
-    return diagnostic;
+	return diagnostic;
 }
 
 void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
-    this->reportingEnabled = reportingEnabled;
+	this->reportingEnabled = reportingEnabled;
 }
 
 bool LocalPoolDataSetBase::getReportingEnabled() const {
-    return reportingEnabled;
+	return reportingEnabled;
 }
 
 void LocalPoolDataSetBase::initializePeriodicHelper(
-        float collectionInterval, dur_millis_t minimumPeriodicInterval,
-        bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
-    periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
-            isDiagnostics, nonDiagIntervalFactor);
+		float collectionInterval, dur_millis_t minimumPeriodicInterval,
+		bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
+	periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
+			isDiagnostics, nonDiagIntervalFactor);
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-    this->changed = changed;
+	this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
-    return changed;
+	return changed;
 }
 
 sid_t LocalPoolDataSetBase::getSid() const {
-    return sid;
+	return sid;
 }
 
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
-        uint8_t position) const {
-    if(position > 7) {
+		uint8_t position) const {
+	if(position > 7) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "Pool Raw Access: Bit setting invalid position"
-                << std::endl;
+		sif::debug << "Pool Raw Access: Bit setting invalid position"
+				<< std::endl;
 #endif
-        return false;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    return *byte & (1 << shiftNumber);
+		return false;
+	}
+	uint8_t shiftNumber = position + (7 - 2 * position);
+	return *byte & (1 << shiftNumber);
 }
 
 bool LocalPoolDataSetBase::isValid() const {
-    return this->valid;
+	return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
-    if(setEntriesRecursively) {
-        for(size_t idx = 0; idx < this->getFillCount(); idx++) {
-            registeredVariables[idx] -> setValid(valid);
-        }
-    }
-    this->valid = valid;
+	if(setEntriesRecursively) {
+		for(size_t idx = 0; idx < this->getFillCount(); idx++) {
+			registeredVariables[idx] -> setValid(valid);
+		}
+	}
+	this->valid = valid;
 }
 
 object_id_t LocalPoolDataSetBase::getCreatorObjectId() {

From fdef8bc22b3f85652ce76b060d68c1142eacd3e4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 12:18:05 +0100
Subject: [PATCH 1458/1774] read commit if

---
 datapool/ReadCommitIF.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h
index efe515944..e6355e824 100644
--- a/datapool/ReadCommitIF.h
+++ b/datapool/ReadCommitIF.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_DATAPOOL_READCOMMITIF_H_
 #define FSFW_DATAPOOL_READCOMMITIF_H_
 
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-#include <fsfw/ipc/MutexIF.h>
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MutexIF.h"
 
 /**
  * @brief 	Common interface for all software objects which employ read-commit

From a4e0f15dac6109aec504805a774cd8689c1eaa93 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 12:41:24 +0100
Subject: [PATCH 1459/1774] consistency changes

---
 datapoollocal/AccessLocalPoolF.h              |  16 +-
 datapoollocal/HasLocalDataPoolIF.h            | 138 +++---
 datapoollocal/LocalDataSet.cpp                |   6 +-
 datapoollocal/LocalDataSet.h                  |   2 +-
 datapoollocal/LocalPoolDataSetBase.cpp        | 412 +++++++++---------
 datapoollocal/LocalPoolDataSetBase.h          | 311 ++++++-------
 datapoollocal/LocalPoolObjectBase.cpp         | 150 +++----
 datapoollocal/LocalPoolObjectBase.h           |  17 +-
 datapoollocal/LocalPoolVariable.h             | 272 ++++++------
 datapoollocal/LocalPoolVariable.tpp           | 176 ++++----
 datapoollocal/LocalPoolVector.h               | 258 +++++------
 datapoollocal/LocalPoolVector.tpp             | 198 ++++-----
 datapoollocal/PoolReadHelper.h                |  44 +-
 .../ProvidesDataPoolSubscriptionIF.h          | 126 +++---
 datapoollocal/SharedLocalDataSet.h            |   3 +-
 datapoollocal/StaticLocalDataSet.h            |  32 +-
 datapoollocal/localPoolDefinitions.h          |  32 +-
 17 files changed, 1099 insertions(+), 1094 deletions(-)

diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
index da08644f8..f68189f65 100644
--- a/datapoollocal/AccessLocalPoolF.h
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -9,16 +9,16 @@ class MutexIF;
  */
 class AccessPoolManagerIF {
 public:
-	virtual ~AccessPoolManagerIF() {};
+    virtual ~AccessPoolManagerIF() {};
 
-	virtual MutexIF* getLocalPoolMutex() = 0;
+    virtual MutexIF* getLocalPoolMutex() = 0;
 
-	/**
-	 * Can be used to get a handle to the local data pool manager.
-	 * This function is protected because it should only be used by the
-	 * class imlementing the interface.
-	 */
-	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+    /**
+     * Can be used to get a handle to the local data pool manager.
+     * This function is protected because it should only be used by the
+     * class imlementing the interface.
+     */
+    virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 
 protected:
 
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 569f2b099..3d822650b 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -30,32 +30,32 @@ class LocalDataPoolManager;
  *
  */
 class HasLocalDataPoolIF {
-	friend class HasLocalDpIFManagerAttorney;
-	friend class HasLocalDpIFUserAttorney;
+    friend class HasLocalDpIFManagerAttorney;
+    friend class HasLocalDpIFUserAttorney;
 public:
-	virtual~ HasLocalDataPoolIF() {};
+    virtual~ HasLocalDataPoolIF() {};
 
-	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
+    static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
-	virtual object_id_t getObjectId() const = 0;
+    virtual object_id_t getObjectId() const = 0;
 
-	/** Command queue for housekeeping messages. */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
+    /** Command queue for housekeeping messages. */
+    virtual MessageQueueId_t getCommandQueue() const = 0;
 
-	/**
-	 * Is used by pool owner to initialize the pool map once
-	 * The manager instance shall also be passed to this function.
-	 * It can be used to subscribe for periodic packets for for updates.
-	 */
-	virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-	        LocalDataPoolManager& poolManager) = 0;
+    /**
+     * Is used by pool owner to initialize the pool map once
+     * The manager instance shall also be passed to this function.
+     * It can be used to subscribe for periodic packets for for updates.
+     */
+    virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) = 0;
 
-	/**
-	 * Returns the minimum sampling frequency in milliseconds, which will
-	 * usually be the period the pool owner performs its periodic operation.
-	 * @return
-	 */
-	virtual uint32_t getPeriodicOperationFrequency() const = 0;
+    /**
+     * Returns the minimum sampling frequency in milliseconds, which will
+     * usually be the period the pool owner performs its periodic operation.
+     * @return
+     */
+    virtual uint32_t getPeriodicOperationFrequency() const = 0;
 
     /**
      * @brief   This function will be called by the manager if an update
@@ -67,7 +67,7 @@ public:
      * the IPC store with this store ID.
      */
     virtual void handleChangedDataset(sid_t sid,
-    		store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
+            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
         return;
     }
 
@@ -85,68 +85,68 @@ public:
         return;
     }
 
-	/**
-	 * These function can be implemented by pool owner, if they are required
-	 * and used by the housekeeping message interface.
-	 * */
-	virtual ReturnValue_t addDataSet(sid_t sid) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-	virtual ReturnValue_t removeDataSet(sid_t sid) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-	virtual ReturnValue_t changeCollectionInterval(sid_t sid, float newIntervalSeconds) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
+    /**
+     * These function can be implemented by pool owner, if they are required
+     * and used by the housekeeping message interface.
+     * */
+    virtual ReturnValue_t addDataSet(sid_t sid) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    };
+    virtual ReturnValue_t removeDataSet(sid_t sid) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    };
+    virtual ReturnValue_t changeCollectionInterval(sid_t sid, float newIntervalSeconds) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    };
 
-	/**
-	 * This function can be used by data pool consumers to retrieve a handle
-	 * which allows subscriptions to dataset and variable updates in form of messages.
-	 * The consumers can then read the most recent variable value by calling read with
-	 * an own pool variable or set instance or using the deserialized snapshot data.
-	 * @return
-	 */
-	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
+    /**
+     * This function can be used by data pool consumers to retrieve a handle
+     * which allows subscriptions to dataset and variable updates in form of messages.
+     * The consumers can then read the most recent variable value by calling read with
+     * an own pool variable or set instance or using the deserialized snapshot data.
+     * @return
+     */
+    virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
 
 protected:
 
-	/**
-	 * Accessor handle required for internal handling. Not intended for users and therefore
-	 * declared protected. Users should instead use pool variables, sets or the subscription
-	 * interface to access pool entries.
-	 * @return
-	 */
-	virtual AccessPoolManagerIF* getAccessorHandle() = 0;
+    /**
+     * Accessor handle required for internal handling. Not intended for users and therefore
+     * declared protected. Users should instead use pool variables, sets or the subscription
+     * interface to access pool entries.
+     * @return
+     */
+    virtual AccessPoolManagerIF* getAccessorHandle() = 0;
 
-	/**
-	 * This function is used by the pool manager to get a valid dataset
+    /**
+     * This function is used by the pool manager to get a valid dataset
      * from a SID. This function is protected to prevent users from
      * using raw data set pointers which could not be thread-safe. Users
      * should use the #ProvidesDataPoolSubscriptionIF.
-	 * @param sid Corresponding structure ID
-	 * @return
-	 */
-	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
+     * @param sid Corresponding structure ID
+     * @return
+     */
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
 
-	/**
-	 * Similar to the function above, but used to get a local pool variable
-	 * handle. This is only needed for update notifications, so it is not
-	 * defined as abstract. This function is protected to prevent users from
+    /**
+     * Similar to the function above, but used to get a local pool variable
+     * handle. This is only needed for update notifications, so it is not
+     * defined as abstract. This function is protected to prevent users from
      * using raw pool variable pointers which could not be thread-safe.
      * Users should use the #ProvidesDataPoolSubscriptionIF.
-	 * @param localPoolId
-	 * @return
-	 */
-	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
+     * @param localPoolId
+     * @return
+     */
+    virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
-	            << ". Returning nullptr!" << std::endl;
+        sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
+                << ". Returning nullptr!" << std::endl;
 #else
-	    sif::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
-	    		"Not overriden. Returning nullptr!\n");
+        sif::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
+                "Not overriden. Returning nullptr!\n");
 #endif
-	    return nullptr;
-	}
+        return nullptr;
+    }
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 394a9abe9..aeb5c6b32 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -9,13 +9,13 @@ LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner, uint32_t setId,
         const size_t maxNumberOfVariables):
         LocalPoolDataSetBase(hkOwner, setId, nullptr, maxNumberOfVariables),
         poolVarList(maxNumberOfVariables) {
-	this->setContainer(poolVarList.data());
+    this->setContainer(poolVarList.data());
 }
 
 LocalDataSet::LocalDataSet(sid_t sid, const size_t maxNumberOfVariables):
         LocalPoolDataSetBase(sid, nullptr, maxNumberOfVariables),
-		poolVarList(maxNumberOfVariables) {
-	this->setContainer(poolVarList.data());
+        poolVarList(maxNumberOfVariables) {
+    this->setContainer(poolVarList.data());
 }
 
 LocalDataSet::~LocalDataSet() {}
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 0368f26d1..b7f8f90f0 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -7,7 +7,7 @@
 class LocalDataSet: public LocalPoolDataSetBase {
 public:
     LocalDataSet(HasLocalDataPoolIF* hkOwner, uint32_t setId,
-    		const size_t maxSize);
+            const size_t maxSize);
     LocalDataSet(sid_t sid, const size_t maxSize);
     virtual~ LocalDataSet();
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index f3cd71065..4dae757eb 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -11,309 +11,309 @@
 #include <cstring>
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-		uint32_t setId, PoolVariableIF** registeredVariablesArray,
-		const size_t maxNumberOfVariables, bool periodicHandling):
-		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-	if(hkOwner == nullptr) {
-		// Configuration error.
+        uint32_t setId, PoolVariableIF** registeredVariablesArray,
+        const size_t maxNumberOfVariables, bool periodicHandling):
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+    if(hkOwner == nullptr) {
+        // Configuration error.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-				<< "invalid!" << std::endl;
+        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+                << "invalid!" << std::endl;
 #else
-		sif::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-				"invalid!\n\r");
+        sif::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+                "invalid!\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-		return;
-	}
-	AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+        return;
+    }
+    AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
 
-	if(accessor != nullptr) {
-		poolManager = accessor->getHkManagerHandle();
-		mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
-	}
+    if(accessor != nullptr) {
+        poolManager = accessor->getHkManagerHandle();
+        mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
+    }
 
-	this->sid.objectId = hkOwner->getObjectId();
-	this->sid.ownerSetId = setId;
+    this->sid.objectId = hkOwner->getObjectId();
+    this->sid.ownerSetId = setId;
 
-	// Data creators get a periodic helper for periodic HK data generation.
-	if(periodicHandling) {
-		periodicHelper = new PeriodicHousekeepingHelper(this);
-	}
+    // Data creators get a periodic helper for periodic HK data generation.
+    if(periodicHandling) {
+        periodicHelper = new PeriodicHousekeepingHelper(this);
+    }
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
-		PoolVariableIF** registeredVariablesArray,
-		const size_t maxNumberOfVariables):
-        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
-	HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
-			sid.objectId);
-	if(hkOwner != nullptr) {
-		AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
-		if(accessor != nullptr) {
-			mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
-		}
-	}
+        PoolVariableIF** registeredVariablesArray,
+        const size_t maxNumberOfVariables):
+                PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
+    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+            sid.objectId);
+    if(hkOwner != nullptr) {
+        AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+        if(accessor != nullptr) {
+            mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
+        }
+    }
 
-	this->sid = sid;
+    this->sid = sid;
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(
-		PoolVariableIF **registeredVariablesArray,
-		const size_t maxNumberOfVariables, bool protectEveryReadCommitCall):
-		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-	this->setReadCommitProtectionBehaviour(protectEveryReadCommitCall);
+        PoolVariableIF **registeredVariablesArray,
+        const size_t maxNumberOfVariables, bool protectEveryReadCommitCall):
+		        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+    this->setReadCommitProtectionBehaviour(protectEveryReadCommitCall);
 }
 
 
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
-	if(periodicHelper != nullptr) {
-		delete periodicHelper;
-	}
+    if(periodicHelper != nullptr) {
+        delete periodicHelper;
+    }
 }
 
 ReturnValue_t LocalPoolDataSetBase::lockDataPool(
-		MutexIF::TimeoutType timeoutType,
-		uint32_t timeoutMs) {
-	if(mutexIfSingleDataCreator != nullptr) {
-		return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+        MutexIF::TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    if(mutexIfSingleDataCreator != nullptr) {
+        return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
-		size_t *size, size_t maxSize,
-		SerializeIF::Endianness streamEndianness) const {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-	uint8_t validityMask[validityMaskSize];
-	uint8_t validBufferIndex = 0;
-	uint8_t validBufferIndexBit = 0;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if(registeredVariables[count]->isValid()) {
-			// set validity buffer here.
-			this->bitSetter(validityMask + validBufferIndex,
-					validBufferIndexBit);
-			if(validBufferIndexBit == 7) {
-				validBufferIndex ++;
-				validBufferIndexBit = 0;
-			}
-			else {
-				validBufferIndexBit ++;
-			}
-		}
-		result = registeredVariables[count]->serialize(buffer, size, maxSize,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
+        size_t *size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+    uint8_t validityMask[validityMaskSize];
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if(registeredVariables[count]->isValid()) {
+            // set validity buffer here.
+            this->bitSetter(validityMask + validBufferIndex,
+                    validBufferIndexBit);
+            if(validBufferIndexBit == 7) {
+                validBufferIndex ++;
+                validBufferIndexBit = 0;
+            }
+            else {
+                validBufferIndexBit ++;
+            }
+        }
+        result = registeredVariables[count]->serialize(buffer, size, maxSize,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
 
-	if(*size + validityMaskSize > maxSize) {
-		return SerializeIF::BUFFER_TOO_SHORT;
-	}
-	// copy validity buffer to end
-	std::memcpy(*buffer, validityMask, validityMaskSize);
-	*size += validityMaskSize;
-	return result;
+    if(*size + validityMaskSize > maxSize) {
+        return SerializeIF::BUFFER_TOO_SHORT;
+    }
+    // copy validity buffer to end
+    std::memcpy(*buffer, validityMask, validityMaskSize);
+    *size += validityMaskSize;
+    return result;
 }
 
 ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
-		const uint8_t **buffer, size_t *size,
-		SerializeIF::Endianness streamEndianness) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		result = registeredVariables[count]->deSerialize(buffer, size,
-				streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
+        const uint8_t **buffer, size_t *size,
+        SerializeIF::Endianness streamEndianness) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        result = registeredVariables[count]->deSerialize(buffer, size,
+                streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
 
-	if(*size < std::ceil(static_cast<float>(fillCount) / 8.0)) {
-		return SerializeIF::STREAM_TOO_SHORT;
-	}
+    if(*size < std::ceil(static_cast<float>(fillCount) / 8.0)) {
+        return SerializeIF::STREAM_TOO_SHORT;
+    }
 
-	uint8_t validBufferIndex = 0;
-	uint8_t validBufferIndexBit = 0;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		// set validity buffer here.
-		bool nextVarValid = this->bitGetter(*buffer +
-				validBufferIndex, validBufferIndexBit);
-		registeredVariables[count]->setValid(nextVarValid);
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        // set validity buffer here.
+        bool nextVarValid = this->bitGetter(*buffer +
+                validBufferIndex, validBufferIndexBit);
+        registeredVariables[count]->setValid(nextVarValid);
 
-		if(validBufferIndexBit == 7) {
-			validBufferIndex ++;
-			validBufferIndexBit = 0;
-		}
-		else {
-			validBufferIndexBit ++;
-		}
-	}
-	return result;
+        if(validBufferIndexBit == 7) {
+            validBufferIndex ++;
+            validBufferIndexBit = 0;
+        }
+        else {
+            validBufferIndexBit ++;
+        }
+    }
+    return result;
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-	if(mutexIfSingleDataCreator != nullptr) {
-		return mutexIfSingleDataCreator->unlockMutex();
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    if(mutexIfSingleDataCreator != nullptr) {
+        return mutexIfSingleDataCreator->unlockMutex();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
-		size_t* size, size_t maxSize,SerializeIF::Endianness streamEndianness,
-		bool serializeFillCount) const {
-	// Serialize as uint8_t
-	uint8_t fillCount = this->fillCount;
-	if(serializeFillCount) {
-		SerializeAdapter::serialize(&fillCount, buffer, size, maxSize,
-				streamEndianness);
-	}
-	for (uint16_t count = 0; count < fillCount; count++) {
-		lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-		auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
-				size, maxSize, streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
+        size_t* size, size_t maxSize,SerializeIF::Endianness streamEndianness,
+        bool serializeFillCount) const {
+    // Serialize as uint8_t
+    uint8_t fillCount = this->fillCount;
+    if(serializeFillCount) {
+        SerializeAdapter::serialize(&fillCount, buffer, size, maxSize,
+                streamEndianness);
+    }
+    for (uint16_t count = 0; count < fillCount; count++) {
+        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
+        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
+                size, maxSize, streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
-				<< "Serialization error!" << std::endl;
+            sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
+                    << "Serialization error!" << std::endl;
 #else
-		sif::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
-				"Serialization error!\n\r");
+            sif::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
+                    "Serialization error!\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-		return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+            return result;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 
 uint8_t LocalPoolDataSetBase::getLocalPoolIdsSerializedSize(
-		bool serializeFillCount) const {
-	if(serializeFillCount) {
-		return fillCount * sizeof(lp_id_t) + sizeof(uint8_t);
-	}
-	else {
-		return fillCount * sizeof(lp_id_t);
-	}
+        bool serializeFillCount) const {
+    if(serializeFillCount) {
+        return fillCount * sizeof(lp_id_t) + sizeof(uint8_t);
+    }
+    else {
+        return fillCount * sizeof(lp_id_t);
+    }
 }
 
 size_t LocalPoolDataSetBase::getSerializedSize() const {
-	if(withValidityBuffer) {
-		uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-		return validityMaskSize + PoolDataSetBase::getSerializedSize();
-	}
-	else {
-		return PoolDataSetBase::getSerializedSize();
-	}
+    if(withValidityBuffer) {
+        uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+        return validityMaskSize + PoolDataSetBase::getSerializedSize();
+    }
+    else {
+        return PoolDataSetBase::getSerializedSize();
+    }
 }
 
 void LocalPoolDataSetBase::setValidityBufferGeneration(
-		bool withValidityBuffer) {
-	this->withValidityBuffer = withValidityBuffer;
+        bool withValidityBuffer) {
+    this->withValidityBuffer = withValidityBuffer;
 }
 
 ReturnValue_t LocalPoolDataSetBase::deSerialize(const uint8_t **buffer,
-		size_t *size, SerializeIF::Endianness streamEndianness) {
-	if(withValidityBuffer) {
-		return this->deSerializeWithValidityBuffer(buffer, size,
-				streamEndianness);
-	}
-	else {
-		return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
-	}
+        size_t *size, SerializeIF::Endianness streamEndianness) {
+    if(withValidityBuffer) {
+        return this->deSerializeWithValidityBuffer(buffer, size,
+                streamEndianness);
+    }
+    else {
+        return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
+    }
 }
 
 ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
-		size_t maxSize, SerializeIF::Endianness streamEndianness) const {
-	if(withValidityBuffer) {
-		return this->serializeWithValidityBuffer(buffer, size,
-				maxSize, streamEndianness);
-	}
-	else {
-		return PoolDataSetBase::serialize(buffer, size, maxSize,
-				streamEndianness);
-	}
+        size_t maxSize, SerializeIF::Endianness streamEndianness) const {
+    if(withValidityBuffer) {
+        return this->serializeWithValidityBuffer(buffer, size,
+                maxSize, streamEndianness);
+    }
+    else {
+        return PoolDataSetBase::serialize(buffer, size, maxSize,
+                streamEndianness);
+    }
 }
 
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
-	if(position > 7) {
+    if(position > 7) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
-		<< std::endl;
+        sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
+                << std::endl;
 #else
-		sif::printWarning("LocalPoolDataSetBase::bitSetter: "
-				"Invalid position!\n\r");
+        sif::printWarning("LocalPoolDataSetBase::bitSetter: "
+                "Invalid position!\n\r");
 #endif
-		return;
-	}
-	uint8_t shiftNumber = position + (7 - 2 * position);
-	*byte |= 1 << shiftNumber;
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1 << shiftNumber;
 }
 
 void LocalPoolDataSetBase::setDiagnostic(bool isDiagnostics) {
-	this->diagnostic = isDiagnostics;
+    this->diagnostic = isDiagnostics;
 }
 
 bool LocalPoolDataSetBase::isDiagnostics() const {
-	return diagnostic;
+    return diagnostic;
 }
 
 void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
-	this->reportingEnabled = reportingEnabled;
+    this->reportingEnabled = reportingEnabled;
 }
 
 bool LocalPoolDataSetBase::getReportingEnabled() const {
-	return reportingEnabled;
+    return reportingEnabled;
 }
 
 void LocalPoolDataSetBase::initializePeriodicHelper(
-		float collectionInterval, dur_millis_t minimumPeriodicInterval,
-		bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
-	periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
-			isDiagnostics, nonDiagIntervalFactor);
+        float collectionInterval, dur_millis_t minimumPeriodicInterval,
+        bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
+    periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
+            isDiagnostics, nonDiagIntervalFactor);
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-	this->changed = changed;
+    this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
-	return changed;
+    return changed;
 }
 
 sid_t LocalPoolDataSetBase::getSid() const {
-	return sid;
+    return sid;
 }
 
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
-		uint8_t position) const {
-	if(position > 7) {
+        uint8_t position) const {
+    if(position > 7) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "Pool Raw Access: Bit setting invalid position"
-				<< std::endl;
+        sif::debug << "Pool Raw Access: Bit setting invalid position"
+                << std::endl;
 #endif
-		return false;
-	}
-	uint8_t shiftNumber = position + (7 - 2 * position);
-	return *byte & (1 << shiftNumber);
+        return false;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    return *byte & (1 << shiftNumber);
 }
 
 bool LocalPoolDataSetBase::isValid() const {
-	return this->valid;
+    return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
-	if(setEntriesRecursively) {
-		for(size_t idx = 0; idx < this->getFillCount(); idx++) {
-			registeredVariables[idx] -> setValid(valid);
-		}
-	}
-	this->valid = valid;
+    if(setEntriesRecursively) {
+        for(size_t idx = 0; idx < this->getFillCount(); idx++) {
+            registeredVariables[idx] -> setValid(valid);
+        }
+    }
+    this->valid = valid;
 }
 
 object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
-	if(poolManager != nullptr) {
-		return poolManager->getCreatorObjectId();
-	}
-	return objects::NO_OBJECT;
+    if(poolManager != nullptr) {
+        return poolManager->getCreatorObjectId();
+    }
+    return objects::NO_OBJECT;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 5f17eeb68..cc41b0eb2 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -41,184 +41,185 @@ class PeriodicHousekeepingHelper;
  *
  * @ingroup data_pool
  */
-class LocalPoolDataSetBase: public PoolDataSetBase,
+class LocalPoolDataSetBase:
+        public PoolDataSetBase,
         public MarkChangedIF {
-	friend class LocalPoolDataSetAttorney;
-	friend class PeriodicHousekeepingHelper;
+    friend class LocalPoolDataSetAttorney;
+    friend class PeriodicHousekeepingHelper;
 public:
-	/**
-	 * @brief	Constructor for the creator of local pool data.
-	 * @details
-	 * This constructor also initializes the components required for
-	 * periodic handling.
-	 */
-	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-			uint32_t setId, PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables, bool periodicHandling = true);
+    /**
+     * @brief	Constructor for the creator of local pool data.
+     * @details
+     * This constructor also initializes the components required for
+     * periodic handling.
+     */
+    LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
+            uint32_t setId, PoolVariableIF** registeredVariablesArray,
+            const size_t maxNumberOfVariables, bool periodicHandling = true);
 
-	/**
-	 * @brief	Constructor for users of the local pool data, which need
-	 *          to access data created by one (!) HK manager.
-	 * @details
-	 * Unlike the first constructor, no component for periodic handling
-	 * will be initiated.
-	 * @param sid Unique identifier of dataset consisting of object ID and
-	 * set ID.
-	 * @param registeredVariablesArray
-	 * @param maxNumberOfVariables
-	 */
-	LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables);
+    /**
+     * @brief	Constructor for users of the local pool data, which need
+     *          to access data created by one (!) HK manager.
+     * @details
+     * Unlike the first constructor, no component for periodic handling
+     * will be initiated.
+     * @param sid Unique identifier of dataset consisting of object ID and
+     * set ID.
+     * @param registeredVariablesArray
+     * @param maxNumberOfVariables
+     */
+    LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
+            const size_t maxNumberOfVariables);
 
-	/**
-	 * @brief	Simple constructor, if the dataset is not the owner by
-	 * 			a class with a HK manager.
-	 * @details
-	 * This constructor won't create components required for periodic handling
-	 * and it also won't try to deduce the HK manager because no SID is
-	 * supplied. This function should therefore be called by classes which need
-	 * to access pool variables from different creators.
-	 *
-	 * If the class is intended to access pool variables from different
-	 * creators, the third argument should be set to true. The mutex
-	 * properties can be set with #setReadCommitProtectionBehaviour .
-	 * @param registeredVariablesArray
-	 * @param maxNumberOfVariables
-	 * @param protectEveryReadCommitCall If the pool variables are created by
-	 * multiple creators, this flag can be set to protect all read and
-	 * commit calls separately.
-	 */
-	LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables,
-			bool protectEveryReadCommitCall = true);
+    /**
+     * @brief	Simple constructor, if the dataset is not the owner by
+     * 			a class with a HK manager.
+     * @details
+     * This constructor won't create components required for periodic handling
+     * and it also won't try to deduce the HK manager because no SID is
+     * supplied. This function should therefore be called by classes which need
+     * to access pool variables from different creators.
+     *
+     * If the class is intended to access pool variables from different
+     * creators, the third argument should be set to true. The mutex
+     * properties can be set with #setReadCommitProtectionBehaviour .
+     * @param registeredVariablesArray
+     * @param maxNumberOfVariables
+     * @param protectEveryReadCommitCall If the pool variables are created by
+     * multiple creators, this flag can be set to protect all read and
+     * commit calls separately.
+     */
+    LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray,
+            const size_t maxNumberOfVariables,
+            bool protectEveryReadCommitCall = true);
 
-	/**
-	 * @brief	The destructor automatically manages writing the valid
-	 * 			information of variables.
-	 * @details
-	 * In case the data set was read out, but not committed(indicated by state),
-	 * the destructor parses all variables that are still registered to the set.
-	 * For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~LocalPoolDataSetBase();
+    /**
+     * @brief	The destructor automatically manages writing the valid
+     * 			information of variables.
+     * @details
+     * In case the data set was read out, but not committed(indicated by state),
+     * the destructor parses all variables that are still registered to the set.
+     * For each, the valid flag in the data pool is set to "invalid".
+     */
+    ~LocalPoolDataSetBase();
 
-	void setValidityBufferGeneration(bool withValidityBuffer);
+    void setValidityBufferGeneration(bool withValidityBuffer);
 
-	sid_t getSid() const;
+    sid_t getSid() const;
 
-	/** SerializeIF overrides */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-	            SerializeIF::Endianness streamEndianness) const override;
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
-	        SerializeIF::Endianness streamEndianness) override;
-	size_t getSerializedSize() const override;
+    /** SerializeIF overrides */
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+            SerializeIF::Endianness streamEndianness) const override;
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
+            SerializeIF::Endianness streamEndianness) override;
+    size_t getSerializedSize() const override;
 
-	/**
-	 * Special version of the serilization function which appends a
-	 * validity buffer at the end. Each bit of this validity buffer
-	 * denotes whether the container data set entries are valid from left
-	 * to right, MSB first. (length = ceil(N/8), N = number of pool variables)
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param bigEndian
-	 * @param withValidityBuffer
-	 * @return
-	 */
-	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
-	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const;
-	ReturnValue_t deSerializeWithValidityBuffer(const uint8_t** buffer,
-	        size_t *size, SerializeIF::Endianness streamEndianness);
-	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
-	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness,
-	        bool serializeFillCount = true) const;
-	uint8_t getLocalPoolIdsSerializedSize(bool serializeFillCount = true) const;
+    /**
+     * Special version of the serilization function which appends a
+     * validity buffer at the end. Each bit of this validity buffer
+     * denotes whether the container data set entries are valid from left
+     * to right, MSB first. (length = ceil(N/8), N = number of pool variables)
+     * @param buffer
+     * @param size
+     * @param maxSize
+     * @param bigEndian
+     * @param withValidityBuffer
+     * @return
+     */
+    ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
+            size_t* size, size_t maxSize,
+            SerializeIF::Endianness streamEndianness) const;
+    ReturnValue_t deSerializeWithValidityBuffer(const uint8_t** buffer,
+            size_t *size, SerializeIF::Endianness streamEndianness);
+    ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
+            size_t* size, size_t maxSize,
+            SerializeIF::Endianness streamEndianness,
+            bool serializeFillCount = true) const;
+    uint8_t getLocalPoolIdsSerializedSize(bool serializeFillCount = true) const;
 
-	/**
-	 * Set the dataset valid or invalid. These calls are mutex protected.
-	 * @param setEntriesRecursively
-	 * If this is true, all contained datasets will also be set recursively.
-	 */
-	void setValidity(bool valid, bool setEntriesRecursively);
-	bool isValid() const override;
+    /**
+     * Set the dataset valid or invalid. These calls are mutex protected.
+     * @param setEntriesRecursively
+     * If this is true, all contained datasets will also be set recursively.
+     */
+    void setValidity(bool valid, bool setEntriesRecursively);
+    bool isValid() const override;
 
-	/**
-	 * These calls are mutex protected.
-	 * @param changed
-	 */
-	void setChanged(bool changed) override;
-	bool hasChanged() const override;
+    /**
+     * These calls are mutex protected.
+     * @param changed
+     */
+    void setChanged(bool changed) override;
+    bool hasChanged() const override;
 
-	object_id_t getCreatorObjectId();
+    object_id_t getCreatorObjectId();
 protected:
-	sid_t sid;
-	//! This mutex is used if the data is created by one object only.
-	MutexIF* mutexIfSingleDataCreator = nullptr;
+    sid_t sid;
+    //! This mutex is used if the data is created by one object only.
+    MutexIF* mutexIfSingleDataCreator = nullptr;
 
-	bool diagnostic = false;
-	void setDiagnostic(bool diagnostics);
-	bool isDiagnostics() const;
+    bool diagnostic = false;
+    void setDiagnostic(bool diagnostics);
+    bool isDiagnostics() const;
 
-	/**
-	 * Used for periodic generation.
-	 */
-	bool reportingEnabled = false;
-	void setReportingEnabled(bool enabled);
-	bool getReportingEnabled() const;
+    /**
+     * Used for periodic generation.
+     */
+    bool reportingEnabled = false;
+    void setReportingEnabled(bool enabled);
+    bool getReportingEnabled() const;
 
-	void initializePeriodicHelper(float collectionInterval,
-			dur_millis_t minimumPeriodicInterval,
-			bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5);
+    void initializePeriodicHelper(float collectionInterval,
+            dur_millis_t minimumPeriodicInterval,
+            bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5);
 
-	/**
-	 * If the valid state of a dataset is always relevant to the whole
-	 * data set we can use this flag.
-	 */
-	bool valid = false;
+    /**
+     * If the valid state of a dataset is always relevant to the whole
+     * data set we can use this flag.
+     */
+    bool valid = false;
 
-	/**
-	 * Can be used to mark the dataset as changed, which is used
-	 * by the LocalDataPoolManager to send out update messages.
-	 */
-	bool changed = false;
+    /**
+     * Can be used to mark the dataset as changed, which is used
+     * by the LocalDataPoolManager to send out update messages.
+     */
+    bool changed = false;
 
-	/**
-	 * Specify whether the validity buffer is serialized too when serializing
-	 * or deserializing the packet. Each bit of the validity buffer will
-	 * contain the validity state of the pool variables from left to right.
-	 * The size of validity buffer thus will be ceil(N / 8) with N = number of
-	 * pool variables.
-	 */
-	bool withValidityBuffer = true;
+    /**
+     * Specify whether the validity buffer is serialized too when serializing
+     * or deserializing the packet. Each bit of the validity buffer will
+     * contain the validity state of the pool variables from left to right.
+     * The size of validity buffer thus will be ceil(N / 8) with N = number of
+     * pool variables.
+     */
+    bool withValidityBuffer = true;
 
-	/**
-	 * @brief	This is a small helper function to facilitate locking
-	 * 			the global data pool.
-	 * @details
-	 * It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType,
-			uint32_t timeoutMs) override;
+    /**
+     * @brief	This is a small helper function to facilitate locking
+     * 			the global data pool.
+     * @details
+     * It makes use of the lockDataPool method offered by the DataPool class.
+     */
+    ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType,
+            uint32_t timeoutMs) override;
 
-	/**
-	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the global data pool
-	 * @details
-	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	ReturnValue_t unlockDataPool() override;
+    /**
+     * @brief	This is a small helper function to facilitate
+     * 			unlocking the global data pool
+     * @details
+     * It makes use of the freeDataPoolLock method offered by the DataPool class.
+     */
+    ReturnValue_t unlockDataPool() override;
 
-	/**
-	 * Set n-th bit of a byte, with n being the position from 0
-	 * (most significant bit) to 7 (least significant bit)
-	 */
-	void bitSetter(uint8_t* byte, uint8_t position) const;
-	bool bitGetter(const uint8_t* byte, uint8_t position) const;
+    /**
+     * Set n-th bit of a byte, with n being the position from 0
+     * (most significant bit) to 7 (least significant bit)
+     */
+    void bitSetter(uint8_t* byte, uint8_t position) const;
+    bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
-	PeriodicHousekeepingHelper* periodicHelper = nullptr;
-	LocalDataPoolManager* poolManager = nullptr;
+    PeriodicHousekeepingHelper* periodicHelper = nullptr;
+    LocalDataPoolManager* poolManager = nullptr;
 
 };
 
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index bd1bfa0f0..a0bf57080 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,128 +1,130 @@
-#include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
+#include "LocalDataPoolManager.h"
 #include "internal/HasLocalDpIFUserAttorney.h"
 #include "HasLocalDataPoolIF.h"
 
 #include "../objectmanager/ObjectManagerIF.h"
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
-		localPoolId(poolId), readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
+        DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+        localPoolId(poolId), readWriteMode(setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-				<< "which is the NO_PARAMETER value!" << std::endl;
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
 #endif
-	}
-	if(hkOwner == nullptr) {
+    }
+    if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
-				<< "owner is a invalid!" << std::endl;
+        sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+                << "owner is a invalid!" << std::endl;
 #endif
-		return;
-	}
-	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
-	hkManager = poolManAccessor->getHkManagerHandle();
+        return;
+    }
+    AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+    hkManager = poolManAccessor->getHkManagerHandle();
 
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
+    if (dataSet != nullptr) {
+        dataSet->registerVariable(this);
+    }
 }
 
 LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF *dataSet,
-		pool_rwm_t setReadWriteMode):
-				localPoolId(poolId), readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
+        pool_rwm_t setReadWriteMode):
+		                localPoolId(poolId), readWriteMode(setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-				<< "which is the NO_PARAMETER value!" << std::endl;
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
 #endif
-	}
-	HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(poolOwner);
-	if(hkOwner == nullptr) {
+    }
+    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(poolOwner);
+    if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "LocalPoolVariable: The supplied pool owner did not "
-				<< "implement the correct interface"
-				<< " HasLocalDataPoolIF!" << std::endl;
+        sif::error << "LocalPoolVariable: The supplied pool owner did not "
+                << "implement the correct interface"
+                << " HasLocalDataPoolIF!" << std::endl;
 #endif
-		return;
-	}
-	//hkManager = hkOwner->getHkManagerHandle();
-	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
-	//hkManager = HasLocalDpIFUserAttorney::getHkManagerHandle(hkOwner);
-	hkManager = poolManAccessor->getHkManagerHandle();
-	if(dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
+        return;
+    }
+
+    AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+    if(accessor != nullptr) {
+        hkManager = accessor->getHkManagerHandle();
+    }
+
+    if(dataSet != nullptr) {
+        dataSet->registerVariable(this);
+    }
 }
 
 pool_rwm_t LocalPoolObjectBase::getReadWriteMode() const {
-	return readWriteMode;
+    return readWriteMode;
 }
 
 bool LocalPoolObjectBase::isValid() const {
-	return valid;
+    return valid;
 }
 
 void LocalPoolObjectBase::setValid(bool valid) {
-	this->valid = valid;
+    this->valid = valid;
 }
 
 lp_id_t LocalPoolObjectBase::getDataPoolId() const {
-	return localPoolId;
+    return localPoolId;
 }
 
 void LocalPoolObjectBase::setDataPoolId(lp_id_t poolId) {
-	this->localPoolId = poolId;
+    this->localPoolId = poolId;
 }
 
 void LocalPoolObjectBase::setChanged(bool changed) {
-	this->changed = changed;
+    this->changed = changed;
 }
 
 bool LocalPoolObjectBase::hasChanged() const {
-	return changed;
+    return changed;
 }
 
 void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
-	this->readWriteMode = newReadWriteMode;
+    this->readWriteMode = newReadWriteMode;
 }
 
 void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
-		ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId) {
+        ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId) {
 #if FSFW_DISABLE_PRINTOUT == 0
-	const char* type = nullptr;
-	if(read) {
-		type = "read";
-	}
-	else {
-		type = "commit";
-	}
+    const char* type = nullptr;
+    if(read) {
+        type = "read";
+    }
+    else {
+        type = "commit";
+    }
 
-	const char* errMsg = nullptr;
-	if(error == localpool::POOL_ENTRY_NOT_FOUND) {
-		errMsg = "Pool entry not found";
-	}
-	else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
-		errMsg = "Pool entry type conflict";
-	}
-	else if(error == PoolVariableIF::INVALID_READ_WRITE_MODE) {
-		errMsg = "Pool variable wrong read-write mode";
-	}
-	else if(error == PoolVariableIF::INVALID_POOL_ENTRY) {
-		errMsg = "Pool entry invalid";
-	}
-	else {
-		errMsg = "Unknown error code";
-	}
+    const char* errMsg = nullptr;
+    if(error == localpool::POOL_ENTRY_NOT_FOUND) {
+        errMsg = "Pool entry not found";
+    }
+    else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
+        errMsg = "Pool entry type conflict";
+    }
+    else if(error == PoolVariableIF::INVALID_READ_WRITE_MODE) {
+        errMsg = "Pool variable wrong read-write mode";
+    }
+    else if(error == PoolVariableIF::INVALID_POOL_ENTRY) {
+        errMsg = "Pool entry invalid";
+    }
+    else {
+        errMsg = "Unknown error code";
+    }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << variableType << ": " << type << " call | " << errMsg << " | Owner: 0x"
-			<< std::hex << std::setw(8) << std::setfill('0') << objectId << std::dec
-			<< " LPID: " << lpId << std::endl;
+    sif::warning << variableType << ": " << type << " call | " << errMsg << " | Owner: 0x"
+            << std::hex << std::setw(8) << std::setfill('0') << objectId << std::dec
+            << " LPID: " << lpId << std::endl;
 #else
-	sif::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
-			variableType, type, errMsg, objectId, lpId);
+    sif::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
+            variableType, type, errMsg, objectId, lpId);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_DISABLE_PRINTOUT == 0 */
 }
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 2dddc2461..44a0c82b9 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -1,8 +1,9 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "MarkChangedIF.h"
+#include "localPoolDefinitions.h"
+
 #include "../objectmanager/SystemObjectIF.h"
 #include "../datapool/PoolVariableIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -11,9 +12,13 @@ class LocalDataPoolManager;
 class DataSetIF;
 class HasLocalDataPoolIF;
 
+/**
+ * @brief 	This class serves as a non-template base for pool objects like pool variables
+ * 			or pool vectors.
+ */
 class LocalPoolObjectBase: public PoolVariableIF,
-        public HasReturnvaluesIF,
-        public MarkChangedIF {
+public HasReturnvaluesIF,
+public MarkChangedIF {
 public:
     LocalPoolObjectBase(lp_id_t poolId,
             HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
@@ -61,10 +66,8 @@ protected:
     //! @brief  Pointer to the class which manages the HK pool.
     LocalDataPoolManager* hkManager = nullptr;
 
-	void reportReadCommitError(const char* variableType,
-			ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId);
+    void reportReadCommitError(const char* variableType,
+            ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId);
 };
 
-
-
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 859c8f08c..76629489a 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -27,159 +27,159 @@
 template<typename T>
 class LocalPoolVariable: public LocalPoolObjectBase {
 public:
-	//! Default ctor is forbidden.
-	LocalPoolVariable() = delete;
+    //! Default ctor is forbidden.
+    LocalPoolVariable() = delete;
 
-	/**
-	 * This constructor is used by the data creators to have pool variable
-	 * instances which can also be stored in datasets.
-	 *
-	 * It does not fetch the current value from the data pool, which
-	 * has to be done by calling the read() operation.
-	 * Datasets can be used to access multiple local pool entries in an
-	 * efficient way. A pointer to a dataset can be passed to register
-	 * the pool variable in that dataset directly.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 */
-	LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    /**
+     * This constructor is used by the data creators to have pool variable
+     * instances which can also be stored in datasets.
+     *
+     * It does not fetch the current value from the data pool, which
+     * has to be done by calling the read() operation.
+     * Datasets can be used to access multiple local pool entries in an
+     * efficient way. A pointer to a dataset can be passed to register
+     * the pool variable in that dataset directly.
+     * @param poolId ID of the local pool entry.
+     * @param hkOwner Pointer of the owner. This will generally be the calling
+     * class itself which passes "this".
+     * @param dataSet The data set in which the variable shall register itself.
+     * If nullptr, the variable is not registered.
+     * @param setReadWriteMode Specify the read-write mode of the pool variable.
+     */
+    LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-	/**
-	 * This constructor is used by data users like controllers to have
-	 * access to the local pool variables of data creators by supplying
-	 * the respective creator object ID.
-	 *
-	 * It does not fetch the current value from the data pool, which
-	 * has to be done by calling the read() operation.
-	 * Datasets can be used to access multiple local pool entries in an
-	 * efficient way. A pointer to a dataset can be passed to register
-	 * the pool variable in that dataset directly.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner object ID of the pool owner.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 *
-	 */
-	LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
-			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
-	/**
-	 * Variation which takes the global unique identifier of a pool variable.
-	 * @param globalPoolId
-	 * @param dataSet
-	 * @param setReadWriteMode
-	 */
-	LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    /**
+     * This constructor is used by data users like controllers to have
+     * access to the local pool variables of data creators by supplying
+     * the respective creator object ID.
+     *
+     * It does not fetch the current value from the data pool, which
+     * has to be done by calling the read() operation.
+     * Datasets can be used to access multiple local pool entries in an
+     * efficient way. A pointer to a dataset can be passed to register
+     * the pool variable in that dataset directly.
+     * @param poolId ID of the local pool entry.
+     * @param hkOwner object ID of the pool owner.
+     * @param dataSet The data set in which the variable shall register itself.
+     * If nullptr, the variable is not registered.
+     * @param setReadWriteMode Specify the read-write mode of the pool variable.
+     *
+     */
+    LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    /**
+     * Variation which takes the global unique identifier of a pool variable.
+     * @param globalPoolId
+     * @param dataSet
+     * @param setReadWriteMode
+     */
+    LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-	virtual~ LocalPoolVariable() {};
+    virtual~ LocalPoolVariable() {};
 
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value = 0;
+    /**
+     * @brief	This is the local copy of the data pool entry.
+     * @details	The user can work on this attribute
+     * 			just like he would on a simple local variable.
+     */
+    T value = 0;
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override;
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+            SerializeIF::Endianness streamEndianness) const override;
+    virtual size_t getSerializedSize() const override;
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            SerializeIF::Endianness streamEndianness) override;
 
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the data pool and copies all array values and the valid
-	 * information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 *
-	 */
-	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the local valid flag is written back as well.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20) override;
+    /**
+     * @brief	This is a call to read the array's values
+     * 			from the global data pool.
+     * @details
+     * When executed, this operation tries to fetch the pool entry with matching
+     * data pool id from the data pool and copies all array values and the valid
+     * information to its local attributes.
+     * In case of a failure (wrong type, size or pool id not found), the
+     * variable is set to zero and invalid.
+     * The read call is protected with a lock.
+     * It is recommended to use DataSets to read and commit multiple variables
+     * at once to avoid the overhead of unnecessary lock und unlock operations.
+     *
+     */
+    ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
+    /**
+     * @brief	The commit call copies the array values back to the data pool.
+     * @details
+     * It checks type and size, as well as if the variable is writable. If so,
+     * the value is copied and the local valid flag is written back as well.
+     * The read call is protected with a lock.
+     * It is recommended to use DataSets to read and commit multiple variables
+     * at once to avoid the overhead of unnecessary lock und unlock operations.
+     */
+    ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
 
-	/**
-	 * @brief	This commit function can be used to set the pool variable valid
-	 * 			as well.
-	 * @param setValid
-	 * @param timeoutType
-	 * @param timeoutMs
-	 * @return
-	 */
-	ReturnValue_t commit(bool setValid, MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20);
+    /**
+     * @brief	This commit function can be used to set the pool variable valid
+     * 			as well.
+     * @param setValid
+     * @param timeoutType
+     * @param timeoutMs
+     * @return
+     */
+    ReturnValue_t commit(bool setValid, MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20);
 
-	LocalPoolVariable<T> &operator=(const T& newValue);
-	LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
+    LocalPoolVariable<T> &operator=(const T& newValue);
+    LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
 
-	//! Explicit type conversion operator. Allows casting the class to
-	//! its template type to perform operations on value.
-	explicit operator T() const;
+    //! Explicit type conversion operator. Allows casting the class to
+    //! its template type to perform operations on value.
+    explicit operator T() const;
 
-	bool operator==(const LocalPoolVariable<T>& other) const;
-	bool operator==(const T& other) const;
+    bool operator==(const LocalPoolVariable<T>& other) const;
+    bool operator==(const T& other) const;
 
-	bool operator!=(const LocalPoolVariable<T>& other) const;
-	bool operator!=(const T& other) const;
+    bool operator!=(const LocalPoolVariable<T>& other) const;
+    bool operator!=(const T& other) const;
 
-	bool operator<(const LocalPoolVariable<T>& other) const;
-	bool operator<(const T& other) const;
+    bool operator<(const LocalPoolVariable<T>& other) const;
+    bool operator<(const T& other) const;
 
-	bool operator>(const LocalPoolVariable<T>& other) const;
-	bool operator>(const T& other) const;
+    bool operator>(const LocalPoolVariable<T>& other) const;
+    bool operator>(const T& other) const;
 
 protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
+    /**
+     * @brief	Like #read, but without a lock protection of the global pool.
+     * @details
+     * The operation does NOT provide any mutual exclusive protection by itself.
+     * This can be used if the lock is handled externally to avoid the overhead
+     * of consecutive lock und unlock operations.
+     * Declared protected to discourage free public usage.
+     */
+    ReturnValue_t readWithoutLock() override;
+    /**
+     * @brief	Like #commit, but without a lock protection of the global pool.
+     * @details
+     * The operation does NOT provide any mutual exclusive protection by itself.
+     * This can be used if the lock is handled externally to avoid the overhead
+     * of consecutive lock und unlock operations.
+     * Declared protected to discourage free public usage.
+     */
+    ReturnValue_t commitWithoutLock() override;
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	// std::ostream is the type for object std::cout
-	template <typename U>
-	friend std::ostream& operator<< (std::ostream &out,
-			const LocalPoolVariable<U> &var);
+    // std::ostream is the type for object std::cout
+    template <typename U>
+    friend std::ostream& operator<< (std::ostream &out,
+            const LocalPoolVariable<U> &var);
 #endif
 };
 
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 6fd34171a..35de4ebdf 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -7,127 +7,127 @@
 
 template<typename T>
 inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
-		lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
-		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+        lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
 inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner,
-		lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
         LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 
 template<typename T>
 inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
-		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
-				dataSet, setReadWriteMode){}
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+                dataSet, setReadWriteMode){}
 
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::read(
-		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-	return readWithoutLock();
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    return readWithoutLock();
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
-	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-		object_id_t targetObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVector",
-				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
-				localPoolId);
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
+    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
 
-	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-			&poolEntry);
-	//ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK) {
-		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVariable", result,
-				false, ownerObjectId, localPoolId);
-		return result;
-	}
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    //ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+    if(result != RETURN_OK) {
+        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVariable", result,
+                false, ownerObjectId, localPoolId);
+        return result;
+    }
 
-	// Actually this should never happen..
-//	if(poolEntry->address == nullptr) {
-//		result = PoolVariableIF::INVALID_POOL_ENTRY;
-//		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-//		reportReadCommitError("LocalPoolVariable", result,
-//				false, ownerObjectId, localPoolId);
-//		return result;
-//	}
+    // Actually this should never happen..
+    //	if(poolEntry->address == nullptr) {
+    //		result = PoolVariableIF::INVALID_POOL_ENTRY;
+    //		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+    //		reportReadCommitError("LocalPoolVariable", result,
+    //				false, ownerObjectId, localPoolId);
+    //		return result;
+    //	}
 
-	this->value = *(poolEntry->getDataPtr());
-	this->valid = poolEntry->getValid();
-	return RETURN_OK;
+    this->value = *(poolEntry->getDataPtr());
+    this->valid = poolEntry->getValid();
+    return RETURN_OK;
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
-		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	this->setValid(setValid);
-	return commit(timeoutType, timeoutMs);
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    this->setValid(setValid);
+    return commit(timeoutType, timeoutMs);
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commit(
-		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-	return commitWithoutLock();
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    return commitWithoutLock();
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
-	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		object_id_t targetObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVector",
-				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
-				localPoolId);
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
+    if(readWriteMode == pool_rwm_t::VAR_READ) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
 
-	PoolEntry<T>* poolEntry = nullptr;
-	//ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-			&poolEntry);
-	if(result != RETURN_OK) {
-		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVariable", result,
-				false, ownerObjectId, localPoolId);
-		return result;
-	}
+    PoolEntry<T>* poolEntry = nullptr;
+    //ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    if(result != RETURN_OK) {
+        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVariable", result,
+                false, ownerObjectId, localPoolId);
+        return result;
+    }
 
-	*(poolEntry->getDataPtr()) = this->value;
-	poolEntry->setValid(this->valid);
-	return RETURN_OK;
+    *(poolEntry->getDataPtr()) = this->value;
+    poolEntry->setValid(this->valid);
+    return RETURN_OK;
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size,
-		SerializeIF::Endianness streamEndianness) const {
-	return SerializeAdapter::serialize(&value,
-			buffer, size ,max_size, streamEndianness);
+        size_t* size, const size_t max_size,
+        SerializeIF::Endianness streamEndianness) const {
+    return SerializeAdapter::serialize(&value,
+            buffer, size ,max_size, streamEndianness);
 }
 
 template<typename T>
 inline size_t LocalPoolVariable<T>::getSerializedSize() const {
-	return SerializeAdapter::getSerializedSize(&value);
+    return SerializeAdapter::getSerializedSize(&value);
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
-		size_t* size, SerializeIF::Endianness streamEndianness) {
-	return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+        size_t* size, SerializeIF::Endianness streamEndianness) {
+    return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 template<typename T>
 inline std::ostream& operator<< (std::ostream &out,
-		const LocalPoolVariable<T> &var) {
+        const LocalPoolVariable<T> &var) {
     out << var.value;
     return out;
 }
@@ -135,68 +135,68 @@ inline std::ostream& operator<< (std::ostream &out,
 
 template<typename T>
 inline LocalPoolVariable<T>::operator T() const {
-	return value;
+    return value;
 }
 
 template<typename T>
 inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(
-		const T& newValue) {
+        const T& newValue) {
     value = newValue;
     return *this;
 }
 
 template<typename T>
 inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
-		const LocalPoolVariable<T>& newPoolVariable) {
-	value = newPoolVariable.value;
-	return *this;
+        const LocalPoolVariable<T>& newPoolVariable) {
+    value = newPoolVariable.value;
+    return *this;
 }
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator ==(
-		const LocalPoolVariable<T> &other) const {
-	return this->value == other.value;
+        const LocalPoolVariable<T> &other) const {
+    return this->value == other.value;
 }
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
-	return this->value == other;
+    return this->value == other;
 }
 
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator !=(
-		const LocalPoolVariable<T> &other) const {
-	return not (*this == other);
+        const LocalPoolVariable<T> &other) const {
+    return not (*this == other);
 }
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
-	return not (*this == other);
+    return not (*this == other);
 }
 
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator <(
-		const LocalPoolVariable<T> &other) const {
-	return this->value < other.value;
+        const LocalPoolVariable<T> &other) const {
+    return this->value < other.value;
 }
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator <(const T &other) const {
-	return this->value < other;
+    return this->value < other;
 }
 
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator >(
-		const LocalPoolVariable<T> &other) const {
-	return not (*this < other);
+        const LocalPoolVariable<T> &other) const {
+    return not (*this < other);
 }
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator >(const T &other) const {
-	return not (*this < other);
+    return not (*this < other);
 }
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 742556054..593d26ab6 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -35,148 +35,148 @@
 template<typename T, uint16_t vectorSize>
 class LocalPoolVector: public LocalPoolObjectBase {
 public:
-	LocalPoolVector() = delete;
-	/**
-	 * This constructor is used by the data creators to have pool variable
-	 * instances which can also be stored in datasets.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    LocalPoolVector() = delete;
+    /**
+     * This constructor is used by the data creators to have pool variable
+     * instances which can also be stored in datasets.
+     * It does not fetch the current value from the data pool. This is performed
+     * by the read() operation (which is not thread-safe).
+     * Datasets can be used to access local pool entires in a thread-safe way.
+     * @param poolId ID of the local pool entry.
+     * @param hkOwner Pointer of the owner. This will generally be the calling
+     * class itself which passes "this".
+     * @param setReadWriteMode Specify the read-write mode of the pool variable.
+     * @param dataSet The data set in which the variable shall register itself.
+     * If nullptr, the variable is not registered.
+     */
+    LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-	/**
-	 * This constructor is used by data users like controllers to have
-	 * access to the local pool variables of data creators by supplying
-	 * the respective creator object ID.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
-			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
-	/**
-	 * Variation which takes the unique global identifier of a local pool
-	 * vector.
-	 * @param globalPoolId
-	 * @param dataSet
-	 * @param setReadWriteMode
-	 */
-	LocalPoolVector(gp_id_t globalPoolId,
-			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    /**
+     * This constructor is used by data users like controllers to have
+     * access to the local pool variables of data creators by supplying
+     * the respective creator object ID.
+     * It does not fetch the current value from the data pool. This is performed
+     * by the read() operation (which is not thread-safe).
+     * Datasets can be used to access local pool entires in a thread-safe way.
+     * @param poolId ID of the local pool entry.
+     * @param hkOwner Pointer of the owner. This will generally be the calling
+     * class itself which passes "this".
+     * @param setReadWriteMode Specify the read-write mode of the pool variable.
+     * @param dataSet The data set in which the variable shall register itself.
+     * If nullptr, the variable is not registered.
+     */
+    LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    /**
+     * Variation which takes the unique global identifier of a local pool
+     * vector.
+     * @param globalPoolId
+     * @param dataSet
+     * @param setReadWriteMode
+     */
+    LocalPoolVector(gp_id_t globalPoolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details
-	 * The user can work on this attribute just like he would on a local
-	 * array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~LocalPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
+    /**
+     * @brief	This is the local copy of the data pool entry.
+     * @details
+     * The user can work on this attribute just like he would on a local
+     * array of this type.
+     */
+    T value[vectorSize];
+    /**
+     * @brief	The classes destructor is empty.
+     * @details	If commit() was not called, the local value is
+     * 			discarded and not written back to the data pool.
+     */
+    ~LocalPoolVector() {};
+    /**
+     * @brief	The operation returns the number of array entries
+     * 			in this variable.
+     */
+    uint8_t getSize() {
+        return vectorSize;
+    }
 
-	T& operator [](size_t i);
-	const T &operator [](size_t i) const;
+    T& operator [](size_t i);
+    const T &operator [](size_t i) const;
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t maxSize,
-			SerializeIF::Endianness streamEndiannes) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override;
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            const size_t maxSize,
+            SerializeIF::Endianness streamEndiannes) const override;
+    virtual size_t getSerializedSize() const override;
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            SerializeIF::Endianness streamEndianness) override;
 
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the data pool and copies all array values and the valid
-	 * information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20) override;
+    /**
+     * @brief	This is a call to read the array's values
+     * 			from the global data pool.
+     * @details
+     * When executed, this operation tries to fetch the pool entry with matching
+     * data pool id from the data pool and copies all array values and the valid
+     * information to its local attributes.
+     * In case of a failure (wrong type, size or pool id not found), the
+     * variable is set to zero and invalid.
+     * The read call is protected with a lock.
+     * It is recommended to use DataSets to read and commit multiple variables
+     * at once to avoid the overhead of unnecessary lock und unlock operations.
+     */
+    ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
 
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the local valid flag is written back as well.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20) override;
+    /**
+     * @brief	The commit call copies the array values back to the data pool.
+     * @details
+     * It checks type and size, as well as if the variable is writable. If so,
+     * the value is copied and the local valid flag is written back as well.
+     * The read call is protected with a lock.
+     * It is recommended to use DataSets to read and commit multiple variables
+     * at once to avoid the overhead of unnecessary lock und unlock operations.
+     */
+    ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
 
-	/**
-	 * @brief	This commit call also sets the validity of the pool entry.
-	 * @details
-	 */
-	ReturnValue_t commit(bool valid, MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20);
+    /**
+     * @brief	This commit call also sets the validity of the pool entry.
+     * @details
+     */
+    ReturnValue_t commit(bool valid, MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20);
 
 protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
+    /**
+     * @brief	Like #read, but without a lock protection of the global pool.
+     * @details
+     * The operation does NOT provide any mutual exclusive protection by itself.
+     * This can be used if the lock is handled externally to avoid the overhead
+     * of consecutive lock und unlock operations.
+     * Declared protected to discourage free public usage.
+     */
+    ReturnValue_t readWithoutLock() override;
+    /**
+     * @brief	Like #commit, but without a lock protection of the global pool.
+     * @details
+     * The operation does NOT provide any mutual exclusive protection by itself.
+     * This can be used if the lock is handled externally to avoid the overhead
+     * of consecutive lock und unlock operations.
+     * Declared protected to discourage free public usage.
+     */
+    ReturnValue_t commitWithoutLock() override;
 
 private:
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	// std::ostream is the type for object std::cout
-	template <typename U, uint16_t otherSize>
-	friend std::ostream& operator<< (std::ostream &out,
-	        const LocalPoolVector<U, otherSize> &var);
+    // std::ostream is the type for object std::cout
+    template <typename U, uint16_t otherSize>
+    friend std::ostream& operator<< (std::ostream &out,
+            const LocalPoolVector<U, otherSize> &var);
 #endif
 
 };
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index acffebeec..98eb27f9c 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -7,158 +7,158 @@
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
-		HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
-		pool_rwm_t setReadWriteMode):
-		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+        HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
+        pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
-		lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
-		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
-				dataSet, setReadWriteMode) {}
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+                dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
-		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-	return readWithoutLock();
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    return readWithoutLock();
 }
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
-	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-		object_id_t targetObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVector",
-				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
-				localPoolId);
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
+    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
 
-	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-			&poolEntry);
-	memset(this->value, 0, vectorSize * sizeof(T));
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    memset(this->value, 0, vectorSize * sizeof(T));
 
-	if(result != RETURN_OK) {
-		object_id_t targetObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
-				localPoolId);
-		return result;
-	}
-	std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
-	this->valid = poolEntry->getValid();
-	return RETURN_OK;
+    if(result != RETURN_OK) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+                localPoolId);
+        return result;
+    }
+    std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+    this->valid = poolEntry->getValid();
+    return RETURN_OK;
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
-		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	this->setValid(valid);
-	return commit(timeoutType, timeoutMs);
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    this->setValid(valid);
+    return commit(timeoutType, timeoutMs);
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
-		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-	return commitWithoutLock();
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    return commitWithoutLock();
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
-	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		object_id_t targetObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVector",
-				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
-				localPoolId);
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
-	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-			&poolEntry);
-	if(result != RETURN_OK) {
-		object_id_t targetObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
-				localPoolId);
-		return result;
-	}
-	std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
-	poolEntry->setValid(this->valid);
-	return RETURN_OK;
+    if(readWriteMode == pool_rwm_t::VAR_READ) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    if(result != RETURN_OK) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
+                localPoolId);
+        return result;
+    }
+    std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+    poolEntry->setValid(this->valid);
+    return RETURN_OK;
 }
 
 template<typename T, uint16_t vectorSize>
 inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
-	if(i < vectorSize) {
-		return value[i];
-	}
-	// If this happens, I have to set some value. I consider this
-	// a configuration error, but I wont exit here.
+    if(i < vectorSize) {
+        return value[i];
+    }
+    // If this happens, I have to set some value. I consider this
+    // a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-			" last value!" << std::endl;
+    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+            " last value!" << std::endl;
 #else
-	sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
-			" last value!\n");
+    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+            " last value!\n");
 #endif
-	return value[vectorSize - 1];
+    return value[vectorSize - 1];
 }
 
 template<typename T, uint16_t vectorSize>
 inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
-	if(i < vectorSize) {
-		return value[i];
-	}
-	// If this happens, I have to set some value. I consider this
-	// a configuration error, but I wont exit here.
+    if(i < vectorSize) {
+        return value[i];
+    }
+    // If this happens, I have to set some value. I consider this
+    // a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-			" last value!" << std::endl;
+    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+            " last value!" << std::endl;
 #else
-	sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
-			" last value!\n");
+    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+            " last value!\n");
 #endif
-	return value[vectorSize - 1];
+    return value[vectorSize - 1];
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize,
-		SerializeIF::Endianness streamEndianness) const {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-	}
-	return result;
+        size_t* size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t i = 0; i < vectorSize; i++) {
+        result = SerializeAdapter::serialize(&(value[i]), buffer, size,
+                maxSize, streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            break;
+        }
+    }
+    return result;
 }
 
 template<typename T, uint16_t vectorSize>
 inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
-	return vectorSize * SerializeAdapter::getSerializedSize(value);
+    return vectorSize * SerializeAdapter::getSerializedSize(value);
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
-		const uint8_t** buffer, size_t* size,
-		SerializeIF::Endianness streamEndianness) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-	}
-	return result;
+        const uint8_t** buffer, size_t* size,
+        SerializeIF::Endianness streamEndianness) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t i = 0; i < vectorSize; i++) {
+        result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            break;
+        }
+    }
+    return result;
 }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index 6a816c1ff..509aaae98 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -10,38 +10,38 @@
  */
 class PoolReadHelper {
 public:
-	PoolReadHelper(ReadCommitIF* readObject,
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t mutexTimeout = 20):
-			readObject(readObject), mutexTimeout(mutexTimeout) {
-		if(readObject != nullptr) {
-			readResult = readObject->read(timeoutType, mutexTimeout);
+    PoolReadHelper(ReadCommitIF* readObject,
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t mutexTimeout = 20):
+                readObject(readObject), mutexTimeout(mutexTimeout) {
+        if(readObject != nullptr) {
+            readResult = readObject->read(timeoutType, mutexTimeout);
 #if FSFW_VERBOSE_LEVEL == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "PoolReadHelper: Read failed!" << std::endl;
+            sif::error << "PoolReadHelper: Read failed!" << std::endl;
 #else
-			sif::printError("PoolReadHelper: Read failed!\n");
+            sif::printError("PoolReadHelper: Read failed!\n");
 #endif /* FSFW_PRINT_VERBOSITY_LEVEL == 1 */
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-		}
-	}
+        }
+    }
 
-	ReturnValue_t getReadResult() const {
-		return readResult;
-	}
+    ReturnValue_t getReadResult() const {
+        return readResult;
+    }
 
-	~PoolReadHelper() {
-		if(readObject != nullptr) {
-			readObject->commit(timeoutType, mutexTimeout);
-		}
+    ~PoolReadHelper() {
+        if(readObject != nullptr) {
+            readObject->commit(timeoutType, mutexTimeout);
+        }
 
-	}
+    }
 
 private:
-	ReadCommitIF* readObject = nullptr;
-	ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
-	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-	uint32_t mutexTimeout = 20;
+    ReadCommitIF* readObject = nullptr;
+    ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+    uint32_t mutexTimeout = 20;
 };
 
 
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index e6d6257e1..6c70046da 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -9,75 +9,75 @@
 
 class ProvidesDataPoolSubscriptionIF {
 public:
-	virtual ~ProvidesDataPoolSubscriptionIF(){};
+    virtual ~ProvidesDataPoolSubscriptionIF(){};
 
-	/**
-	 * @brief   Subscribe for the generation of periodic packets.
-	 * @details
-	 * This subscription mechanism will generally be used by the data creator
-	 * to generate housekeeping packets which are downlinked directly.
-	 * @return
-	 */
-	virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid,
-			bool enableReporting,
-			float collectionInterval, bool isDiagnostics,
-			object_id_t packetDestination) = 0;
+    /**
+     * @brief   Subscribe for the generation of periodic packets.
+     * @details
+     * This subscription mechanism will generally be used by the data creator
+     * to generate housekeeping packets which are downlinked directly.
+     * @return
+     */
+    virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid,
+            bool enableReporting,
+            float collectionInterval, bool isDiagnostics,
+            object_id_t packetDestination) = 0;
 
 
-	/**
-	 * @brief   Subscribe for the  generation of packets if the dataset
-	 *          is marked as changed.
-	 * @details
-	 * This subscription mechanism will generally be used by the data creator.
-	 * @param sid
-	 * @param isDiagnostics
-	 * @param packetDestination
-	 * @return
-	 */
-	virtual ReturnValue_t subscribeForUpdatePackets(sid_t sid,
-			bool reportingEnabled,
-			bool isDiagnostics,
-			object_id_t packetDestination) = 0;
+    /**
+     * @brief   Subscribe for the  generation of packets if the dataset
+     *          is marked as changed.
+     * @details
+     * This subscription mechanism will generally be used by the data creator.
+     * @param sid
+     * @param isDiagnostics
+     * @param packetDestination
+     * @return
+     */
+    virtual ReturnValue_t subscribeForUpdatePackets(sid_t sid,
+            bool reportingEnabled,
+            bool isDiagnostics,
+            object_id_t packetDestination) = 0;
 
 
-	/**
-	 * @brief   Subscribe for a notification message which will be sent
-	 *          if a dataset has changed.
-	 * @details
-	 * This subscription mechanism will generally be used internally by
-	 * other software components.
-	 * @param setId     Set ID of the set to receive update messages from.
-	 * @param destinationObject
-	 * @param targetQueueId
-	 * @param generateSnapshot If this is set to true, a copy of the current
-	 * data with a timestamp will be generated and sent via message.
-	 * Otherwise, only an notification message is sent.
-	 * @return
-	 */
-	virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
-			object_id_t destinationObject,
-			MessageQueueId_t targetQueueId,
-			bool generateSnapshot) = 0;
+    /**
+     * @brief   Subscribe for a notification message which will be sent
+     *          if a dataset has changed.
+     * @details
+     * This subscription mechanism will generally be used internally by
+     * other software components.
+     * @param setId     Set ID of the set to receive update messages from.
+     * @param destinationObject
+     * @param targetQueueId
+     * @param generateSnapshot If this is set to true, a copy of the current
+     * data with a timestamp will be generated and sent via message.
+     * Otherwise, only an notification message is sent.
+     * @return
+     */
+    virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
+            object_id_t destinationObject,
+            MessageQueueId_t targetQueueId,
+            bool generateSnapshot) = 0;
 
-	/**
-	 * @brief   Subscribe for an notification message which will be sent if a
-	 *          pool variable has changed.
-	 * @details
-	 * This subscription mechanism will generally be used internally by
-	 * other software components.
-	 * @param localPoolId Pool ID of the pool variable
-	 * @param destinationObject
-	 * @param targetQueueId
-	 * @param generateSnapshot If this is set to true, a copy of the current
-	 * data with a timestamp will be generated and sent via message.
-	 * Otherwise, only an notification message is sent.
-	 * @return
-	 */
-	virtual ReturnValue_t subscribeForVariableUpdateMessages(
-			const lp_id_t localPoolId,
-			object_id_t destinationObject,
-			MessageQueueId_t targetQueueId,
-			bool generateSnapshot) = 0;
+    /**
+     * @brief   Subscribe for an notification message which will be sent if a
+     *          pool variable has changed.
+     * @details
+     * This subscription mechanism will generally be used internally by
+     * other software components.
+     * @param localPoolId Pool ID of the pool variable
+     * @param destinationObject
+     * @param targetQueueId
+     * @param generateSnapshot If this is set to true, a copy of the current
+     * data with a timestamp will be generated and sent via message.
+     * Otherwise, only an notification message is sent.
+     * @return
+     */
+    virtual ReturnValue_t subscribeForVariableUpdateMessages(
+            const lp_id_t localPoolId,
+            object_id_t destinationObject,
+            MessageQueueId_t targetQueueId,
+            bool generateSnapshot) = 0;
 
 };
 
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index 713d435b1..83f2a72f1 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -13,7 +13,8 @@
  *
  * TODO: override and protect read, commit and some other calls used by pool manager.
  */
-class SharedLocalDataSet: public SystemObject,
+class SharedLocalDataSet:
+        public SystemObject,
         public LocalPoolDataSetBase,
         public SharedDataSetIF {
 public:
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index a637e360f..0e51fb5bb 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -20,26 +20,24 @@
 template <uint8_t NUM_VARIABLES>
 class StaticLocalDataSet: public LocalPoolDataSetBase {
 public:
-	/**
-	 * Constructor used by data owner and creator like device handlers.
-	 * This constructor also initialized the components required for
-	 * periodic handling.
-	 * @param hkOwner
-	 * @param setId
-	 */
-    StaticLocalDataSet(HasLocalDataPoolIF* hkOwner,
-    		uint32_t setId): LocalPoolDataSetBase(hkOwner, setId, nullptr,
-            NUM_VARIABLES) {
+    /**
+     * Constructor used by data owner and creator like device handlers.
+     * This constructor also initialized the components required for
+     * periodic handling.
+     * @param hkOwner
+     * @param setId
+     */
+    StaticLocalDataSet(HasLocalDataPoolIF* hkOwner, uint32_t setId):
+            LocalPoolDataSetBase(hkOwner, setId, nullptr, NUM_VARIABLES) {
         this->setContainer(poolVarList.data());
     }
 
-	/**
-	 * Constructor used by data users like controllers.
-	 * @param hkOwner
-	 * @param setId
-	 */
-    StaticLocalDataSet(sid_t sid): LocalPoolDataSetBase(sid, nullptr,
-            NUM_VARIABLES) {
+    /**
+     * Constructor used by data users like controllers.
+     * @param hkOwner
+     * @param setId
+     */
+    StaticLocalDataSet(sid_t sid): LocalPoolDataSetBase(sid, nullptr, NUM_VARIABLES) {
         this->setContainer(poolVarList.data());
     }
 
diff --git a/datapoollocal/localPoolDefinitions.h b/datapoollocal/localPoolDefinitions.h
index 3ff1feeda..ff44fb8e7 100644
--- a/datapoollocal/localPoolDefinitions.h
+++ b/datapoollocal/localPoolDefinitions.h
@@ -40,8 +40,8 @@ union sid_t {
     sid_t(): raw(INVALID_SID) {}
 
     sid_t(object_id_t objectId, uint32_t setId):
-            objectId(objectId),
-            ownerSetId(setId) {}
+        objectId(objectId),
+        ownerSetId(setId) {}
 
     struct {
         object_id_t objectId ;
@@ -75,26 +75,26 @@ union sid_t {
  * and 4 byte local pool ID.
  */
 union gp_id_t {
-	static constexpr uint64_t INVALID_GPID = -1;
+    static constexpr uint64_t INVALID_GPID = -1;
     static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
-	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
+    static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
-	gp_id_t(): raw(INVALID_GPID) {}
+    gp_id_t(): raw(INVALID_GPID) {}
 
-	gp_id_t(object_id_t objectId, lp_id_t localPoolId):
-			objectId(objectId),
-			localPoolId(localPoolId) {}
+    gp_id_t(object_id_t objectId, lp_id_t localPoolId):
+        objectId(objectId),
+        localPoolId(localPoolId) {}
 
-	struct {
-		object_id_t objectId;
-		lp_id_t localPoolId;
-	};
+    struct {
+        object_id_t objectId;
+        lp_id_t localPoolId;
+    };
 
-	uint64_t raw;
+    uint64_t raw;
 
-	bool notSet() const {
-		return raw == INVALID_GPID;
-	}
+    bool notSet() const {
+        return raw == INVALID_GPID;
+    }
 
     bool operator==(const sid_t& other) const {
         return raw == other.raw;

From 3a4b89cc280e6c27759ae58ffa83ecccb28536bc Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 12:43:53 +0100
Subject: [PATCH 1460/1774] more changes

---
 datapoollocal/ProvidesDataPoolSubscriptionIF.h | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index 6c70046da..a0d73b93f 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -1,10 +1,9 @@
 #ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
 #define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
-#include <fsfw/ipc/messageQueueDefinitions.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-
+#include "localPoolDefinitions.h"
+#include "../ipc/messageQueueDefinitions.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 
 
 class ProvidesDataPoolSubscriptionIF {

From fa49def1cfe54a53e22d1de8136c27dc03aaede3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 12:53:05 +0100
Subject: [PATCH 1461/1774] indentation

---
 datapoollocal/LocalPoolObjectBase.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 44a0c82b9..797cf8b5a 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -17,8 +17,8 @@ class HasLocalDataPoolIF;
  * 			or pool vectors.
  */
 class LocalPoolObjectBase: public PoolVariableIF,
-public HasReturnvaluesIF,
-public MarkChangedIF {
+        public HasReturnvaluesIF,
+        public MarkChangedIF {
 public:
     LocalPoolObjectBase(lp_id_t poolId,
             HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,

From cd3f19d0e4857e18fc5a9ae84fa199bd0a22e42c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 12:56:55 +0100
Subject: [PATCH 1462/1774] updated defaultcfg

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 261e3d6d2..ed86e6e1f 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -9,18 +9,14 @@
 //! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! More FSFW related printouts.
-//! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_ENHANCED_PRINTOUT		0
+//! More FSFW related printouts depending on level. Useful for development.
+#define FSFW_VERBOSE_LEVEL			1
 
 //! Can be used to completely disable printouts, even the C stdio ones.
-#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
 	#define FSFW_DISABLE_PRINTOUT 	0
 #endif
 
-//! Can be used to enable additional debugging printouts for developing the FSFW
-#define FSFW_PRINT_VERBOSITY_LEVEL   0
-
 //! Can be used to disable the ANSI color sequences for C stdio.
 #define FSFW_COLORED_OUTPUT 		1
 

From 7ac59c6d188e4773a72a5ee1a8afecbbae487309 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 13:01:41 +0100
Subject: [PATCH 1463/1774] include fix

---
 devicehandlers/DeviceHandlerIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index bae68516e..fc31cce09 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,9 +1,9 @@
 #ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 #define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "DeviceHandlerMessage.h"
 
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../action/HasActionsIF.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"

From 2e456cebb7278539b6e70c7ff8bf4ad9debb7d6e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 13:06:30 +0100
Subject: [PATCH 1464/1774] include fix

---
 datapoollocal/internal/LocalDpManagerAttorney.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/internal/LocalDpManagerAttorney.h b/datapoollocal/internal/LocalDpManagerAttorney.h
index 1d72f607f..9047d158b 100644
--- a/datapoollocal/internal/LocalDpManagerAttorney.h
+++ b/datapoollocal/internal/LocalDpManagerAttorney.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
 
-#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+#include "../LocalDataPoolManager.h"
 
 /**
  * @brief	This is a helper class implements the Attorney-Client idiom for access to

From 5710f3824aef3db29ecb72d60b5a6fa101c8b5d8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 13:06:57 +0100
Subject: [PATCH 1465/1774] indentation consistent now

---
 .../internal/HasLocalDpIFManagerAttorney.cpp  | 10 ++---
 .../internal/HasLocalDpIFManagerAttorney.h    | 10 ++---
 .../internal/HasLocalDpIFUserAttorney.h       |  6 +--
 .../internal/LocalDpManagerAttorney.h         | 18 ++++----
 .../internal/LocalPoolDataSetAttorney.h       | 44 +++++++++----------
 5 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp b/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
index bc07170f9..65feda75e 100644
--- a/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
+++ b/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
@@ -4,15 +4,15 @@
 #include "../HasLocalDataPoolIF.h"
 
 LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* clientIF,
-		sid_t sid) {
-	return clientIF->getDataSetHandle(sid);
+        sid_t sid) {
+    return clientIF->getDataSetHandle(sid);
 }
 
 LocalPoolObjectBase* HasLocalDpIFManagerAttorney::getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
-		lp_id_t localPoolId) {
-	return clientIF->getPoolObjectHandle(localPoolId);
+        lp_id_t localPoolId) {
+    return clientIF->getPoolObjectHandle(localPoolId);
 }
 
 object_id_t HasLocalDpIFManagerAttorney::getObjectId(HasLocalDataPoolIF* clientIF) {
-	return clientIF->getObjectId();
+    return clientIF->getObjectId();
 }
diff --git a/datapoollocal/internal/HasLocalDpIFManagerAttorney.h b/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
index ef180b37c..dfe333a64 100644
--- a/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
+++ b/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
@@ -9,14 +9,14 @@ class LocalPoolObjectBase;
 
 class HasLocalDpIFManagerAttorney {
 
-	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* clientIF, sid_t sid);
+    static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* clientIF, sid_t sid);
 
-	static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
-			lp_id_t localPoolId);
+    static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
+            lp_id_t localPoolId);
 
-	static object_id_t getObjectId(HasLocalDataPoolIF* clientIF);
+    static object_id_t getObjectId(HasLocalDataPoolIF* clientIF);
 
-	friend class LocalDataPoolManager;
+    friend class LocalDataPoolManager;
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_ */
diff --git a/datapoollocal/internal/HasLocalDpIFUserAttorney.h b/datapoollocal/internal/HasLocalDpIFUserAttorney.h
index a07c2d595..77eaa8bde 100644
--- a/datapoollocal/internal/HasLocalDpIFUserAttorney.h
+++ b/datapoollocal/internal/HasLocalDpIFUserAttorney.h
@@ -7,10 +7,10 @@ class AccessPoolManagerIF;
 class HasLocalDpIFUserAttorney {
 private:
 
-	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* clientIF);
+    static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* clientIF);
 
-	friend class LocalPoolObjectBase;
-	friend class LocalPoolDataSetBase;
+    friend class LocalPoolObjectBase;
+    friend class LocalPoolDataSetBase;
 
 };
 
diff --git a/datapoollocal/internal/LocalDpManagerAttorney.h b/datapoollocal/internal/LocalDpManagerAttorney.h
index 9047d158b..bb64fb422 100644
--- a/datapoollocal/internal/LocalDpManagerAttorney.h
+++ b/datapoollocal/internal/LocalDpManagerAttorney.h
@@ -15,18 +15,18 @@
  */
 class LocalDpManagerAttorney {
 private:
-	template<typename T> static ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
-			lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
-		return manager.fetchPoolEntry(localPoolId, poolEntry);
-	}
+    template<typename T> static ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
+            lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
+        return manager.fetchPoolEntry(localPoolId, poolEntry);
+    }
 
-	static MutexIF* getMutexHandle(LocalDataPoolManager& manager) {
-		return manager.getMutexHandle();
-	}
+    static MutexIF* getMutexHandle(LocalDataPoolManager& manager) {
+        return manager.getMutexHandle();
+    }
 
 
-	template<typename T> friend class LocalPoolVariable;
-	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
+    template<typename T> friend class LocalPoolVariable;
+    template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_ */
diff --git a/datapoollocal/internal/LocalPoolDataSetAttorney.h b/datapoollocal/internal/LocalPoolDataSetAttorney.h
index 9804444af..7a34e9c8e 100644
--- a/datapoollocal/internal/LocalPoolDataSetAttorney.h
+++ b/datapoollocal/internal/LocalPoolDataSetAttorney.h
@@ -5,34 +5,34 @@
 
 class LocalPoolDataSetAttorney {
 private:
-	static void setDiagnostic(LocalPoolDataSetBase& set, bool diagnostics) {
-		set.setDiagnostic(diagnostics);
-	}
+    static void setDiagnostic(LocalPoolDataSetBase& set, bool diagnostics) {
+        set.setDiagnostic(diagnostics);
+    }
 
-	static bool isDiagnostics(LocalPoolDataSetBase& set) {
-		return set.isDiagnostics();
-	}
+    static bool isDiagnostics(LocalPoolDataSetBase& set) {
+        return set.isDiagnostics();
+    }
 
-	static void initializePeriodicHelper(LocalPoolDataSetBase& set, float collectionInterval,
-			uint32_t minimumPeriodicIntervalMs,
-			bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5) {
-		set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs, isDiagnostics,
-				nonDiagIntervalFactor);
-	}
+    static void initializePeriodicHelper(LocalPoolDataSetBase& set, float collectionInterval,
+            uint32_t minimumPeriodicIntervalMs,
+            bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5) {
+        set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs, isDiagnostics,
+                nonDiagIntervalFactor);
+    }
 
-	static void setReportingEnabled(LocalPoolDataSetBase& set, bool enabled) {
-		set.setReportingEnabled(enabled);
-	}
+    static void setReportingEnabled(LocalPoolDataSetBase& set, bool enabled) {
+        set.setReportingEnabled(enabled);
+    }
 
-	static bool getReportingEnabled(LocalPoolDataSetBase& set) {
-		return set.getReportingEnabled();
-	}
+    static bool getReportingEnabled(LocalPoolDataSetBase& set) {
+        return set.getReportingEnabled();
+    }
 
-	static PeriodicHousekeepingHelper* getPeriodicHelper(LocalPoolDataSetBase& set) {
-		return set.periodicHelper;
-	}
+    static PeriodicHousekeepingHelper* getPeriodicHelper(LocalPoolDataSetBase& set) {
+        return set.periodicHelper;
+    }
 
-	friend class LocalDataPoolManager;
+    friend class LocalDataPoolManager;
 };
 
 

From 0cd457725e8edae8b3c8bc580262f77fd09ab82d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 21:35:17 +0100
Subject: [PATCH 1466/1774] trying to suppress certain warnings

---
 CMakeLists.txt             | 21 +++++++++++----------
 datapool/PoolDataSetBase.h | 17 ++++++++---------
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 587e67012..76542842f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -107,14 +107,16 @@ else()
 endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-	set(WARNING_FLAGS
-		-Wall
-		-Wextra
-		-Wshadow=local
-		-Wimplicit-fallthrough=1
-		-Wno-unused-parameter
-		-Wno-psabi
-	)
+    if(NOT DEFINED FSFW_WARNING_FLAGS)
+	   set(FSFW_WARNING_FLAGS
+		  -Wall
+		  -Wextra
+		  -Wshadow=local
+		  -Wimplicit-fallthrough=1
+		  -Wno-unused-parameter
+		  -Wno-psabi
+        )
+	endif()
 endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
@@ -135,8 +137,7 @@ target_include_directories(${LIB_FSFW_NAME} PRIVATE
 	${FSFW_CONFIG_PATH_ABSOLUTE}
 )
 
-# Machine specific options can be set with the ABI_FLAGS variable.
 target_compile_options(${LIB_FSFW_NAME} PRIVATE 
-	${WARNING_FLAGS}
+	${FSFW_WARNING_FLAGS}
 	${COMPILER_FLAGS}
 )
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index d741dabc8..65a6651e5 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -120,17 +120,16 @@ public:
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	        SerializeIF::Endianness streamEndianness) override;
 
+    /**
+     * Can be used to individually protect every read and commit call.
+     * @param protectEveryReadCommit
+     * @param mutexTimeout
+     */
+    void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t mutexTimeout = 20);
 protected:
 
-	/**
-	 * Can be used to individually protect every read and commit call.
-	 * @param protectEveryReadCommit
-	 * @param mutexTimeout
-	 */
-	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t mutexTimeout = 20);
-
 	/**
 	 * @brief	The fill_count attribute ensures that the variables
 	 * 			register in the correct array position and that the maximum

From 7bb570540baea7f769c5f4b995d4709ce975b1ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 11:27:35 +0100
Subject: [PATCH 1467/1774] added hk service

---
 pus/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pus/CMakeLists.txt b/pus/CMakeLists.txt
index 758c26293..c0e004481 100644
--- a/pus/CMakeLists.txt
+++ b/pus/CMakeLists.txt
@@ -5,6 +5,7 @@ target_sources(${LIB_FSFW_NAME}
 		Service17Test.cpp
 		Service1TelecommandVerification.cpp
 		Service2DeviceAccess.cpp
+		Service3Housekeeping.cpp
 		Service5EventReporting.cpp
 		Service8FunctionManagement.cpp
 		Service9TimeManagement.cpp

From 6b1c7084ac3bc6478562cfa5323b3e9c687689f7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 11:29:38 +0100
Subject: [PATCH 1468/1774] added srv3

---
 pus/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pus/CMakeLists.txt b/pus/CMakeLists.txt
index 758c26293..c0e004481 100644
--- a/pus/CMakeLists.txt
+++ b/pus/CMakeLists.txt
@@ -5,6 +5,7 @@ target_sources(${LIB_FSFW_NAME}
 		Service17Test.cpp
 		Service1TelecommandVerification.cpp
 		Service2DeviceAccess.cpp
+		Service3Housekeeping.cpp
 		Service5EventReporting.cpp
 		Service8FunctionManagement.cpp
 		Service9TimeManagement.cpp

From a5e20657c6eb22043c4313a00fd4c4f4bcf2e98a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 11:31:26 +0100
Subject: [PATCH 1469/1774] resolved merge conflicts

---
 datapoollocal/LocalPoolVariable.tpp | 55 -----------------------------
 pus/CMakeLists.txt                  |  1 -
 2 files changed, 56 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 7eea2a463..35de4ebdf 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -32,37 +32,6 @@ inline ReturnValue_t LocalPoolVariable<T>::read(
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
-<<<<<<< HEAD
-	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVector",
-				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
-				localPoolId);
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
-
-	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK) {
-		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVariable", result,
-				false, ownerObjectId, localPoolId);
-		return result;
-	}
-
-	// Actually this should never happen..
-	if(poolEntry->address == nullptr) {
-		result = PoolVariableIF::INVALID_POOL_ENTRY;
-		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVariable", result,
-				false, ownerObjectId, localPoolId);
-		return result;
-	}
-
-	this->value = *(poolEntry->address);
-	this->valid = poolEntry->valid;
-	return RETURN_OK;
-=======
     if(readWriteMode == pool_rwm_t::VAR_WRITE) {
         object_id_t targetObjectId = hkManager->getCreatorObjectId();
         reportReadCommitError("LocalPoolVector",
@@ -94,7 +63,6 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
     this->value = *(poolEntry->getDataPtr());
     this->valid = poolEntry->getValid();
     return RETURN_OK;
->>>>>>> upstream/mueller/master
 }
 
 template<typename T>
@@ -113,28 +81,6 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
-<<<<<<< HEAD
-	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVector",
-				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
-				localPoolId);
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
-
-	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK) {
-		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVariable", result,
-				false, ownerObjectId, localPoolId);
-		return result;
-	}
-
-	*(poolEntry->address) = this->value;
-	poolEntry->valid = this->valid;
-	return RETURN_OK;
-=======
     if(readWriteMode == pool_rwm_t::VAR_READ) {
         object_id_t targetObjectId = hkManager->getCreatorObjectId();
         reportReadCommitError("LocalPoolVector",
@@ -157,7 +103,6 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
     *(poolEntry->getDataPtr()) = this->value;
     poolEntry->setValid(this->valid);
     return RETURN_OK;
->>>>>>> upstream/mueller/master
 }
 
 template<typename T>
diff --git a/pus/CMakeLists.txt b/pus/CMakeLists.txt
index c0e004481..758c26293 100644
--- a/pus/CMakeLists.txt
+++ b/pus/CMakeLists.txt
@@ -5,7 +5,6 @@ target_sources(${LIB_FSFW_NAME}
 		Service17Test.cpp
 		Service1TelecommandVerification.cpp
 		Service2DeviceAccess.cpp
-		Service3Housekeeping.cpp
 		Service5EventReporting.cpp
 		Service8FunctionManagement.cpp
 		Service9TimeManagement.cpp

From 67ce8d2e24dcb8636f2dd4b04e3d275bb18a7fe4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 11:50:33 +0100
Subject: [PATCH 1470/1774] improved internal interface

---
 controller/ExtendedControllerBase.cpp   |  8 ++------
 controller/ExtendedControllerBase.h     | 11 +----------
 datapoollocal/HasLocalDataPoolIF.h      | 25 +++++++++++++++++++------
 devicehandlers/DeviceHandlerBase.cpp    |  8 ++------
 devicehandlers/DeviceHandlerBase.h      |  8 ++------
 internalError/InternalErrorReporter.cpp |  8 ++------
 internalError/InternalErrorReporter.h   |  3 +--
 7 files changed, 29 insertions(+), 42 deletions(-)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index e0aec63a5..397c8c10f 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -26,10 +26,6 @@ object_id_t ExtendedControllerBase::getObjectId() const {
     return SystemObject::getObjectId();
 }
 
-AccessPoolManagerIF* ExtendedControllerBase::getAccessorHandle() {
-    return &poolManager;
-}
-
 uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const {
     return this->executingTask->getPeriodMs();
 }
@@ -114,6 +110,6 @@ LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
     return nullptr;
 }
 
-ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubscriptionInterface() {
-	return &poolManager;
+LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() {
+    return &poolManager;
 }
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index b27605141..bcb414dd3 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -32,20 +32,10 @@ public:
     virtual ReturnValue_t performOperation(uint8_t opCode) override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
-    /**
-     * Provides a subscription interface for objects which required updates on changed
-     * controller variables or datasets
-     * @return
-     */
-    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
-
 protected:
     LocalDataPoolManager poolManager;
     ActionHelper actionHelper;
 
-    //! Accessor handle required for internal handling
-    AccessPoolManagerIF* getAccessorHandle() override;
-
     /**
      * Implemented by child class. Handle all command messages which are
      * not health, mode, action or housekeeping messages.
@@ -68,6 +58,7 @@ protected:
             size_t size) override;
 
     /** HasLocalDatapoolIF overrides */
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual object_id_t getObjectId() const override;
     virtual ReturnValue_t initializeLocalDataPool(
             localpool::DataPool& localDataPoolMap,
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 3d822650b..1d87d47c9 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -2,6 +2,7 @@
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
 #include "localPoolDefinitions.h"
+#include "LocalDataPoolManager.h"
 
 #include "../datapool/PoolEntryIF.h"
 #include "../serviceinterface/ServiceInterface.h"
@@ -14,7 +15,6 @@ class AccessPoolManagerIF;
 class ProvidesDataPoolSubscriptionIF;
 class LocalPoolDataSetBase;
 class LocalPoolObjectBase;
-class LocalDataPoolManager;
 
 /**
  * @brief 		This interface is implemented by classes which posses a local data pool (not the
@@ -104,19 +104,32 @@ public:
      * which allows subscriptions to dataset and variable updates in form of messages.
      * The consumers can then read the most recent variable value by calling read with
      * an own pool variable or set instance or using the deserialized snapshot data.
+     * Returns the HK manager casted to the required interface by default.
      * @return
      */
-    virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
+    virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() {
+        return getHkManagerHandle();
+    }
 
 protected:
 
     /**
-     * Accessor handle required for internal handling. Not intended for users and therefore
-     * declared protected. Users should instead use pool variables, sets or the subscription
-     * interface to access pool entries.
+     * Every class implementing this interface should have a local data pool manager. This
+     * function will return a reference to the manager.
      * @return
      */
-    virtual AccessPoolManagerIF* getAccessorHandle() = 0;
+    virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+    /**
+     * Accessor handle required for internal handling. Not intended for users and therefore
+     * declared protected. Users should instead use pool variables, sets or the subscription
+     * interface to access pool entries. Returns the HK manager casted to a different interface
+     * by default.
+     * @return
+     */
+    virtual AccessPoolManagerIF* getAccessorHandle() {
+        return getHkManagerHandle();
+    }
 
     /**
      * This function is used by the pool manager to get a valid dataset
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index c40985255..6092a89f8 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1483,10 +1483,6 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 	}
 }
 
-AccessPoolManagerIF* DeviceHandlerBase::getAccessorHandle() {
-	return &poolManager;
-}
-
 void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
 		const char *functionName, ReturnValue_t errorCode,
 		const char *errorPrint) {
@@ -1532,6 +1528,6 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
 
 }
 
-ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubscriptionInterface() {
-	return &poolManager;
+LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
+    return &poolManager;
 }
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 43f61897a..3a993aff0 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -518,14 +518,10 @@ protected:
 				LocalDataPoolManager& poolManager) override;
 
 	/**
-	 * Provides the subscription handle which can be used by classes like controllers
-	 * to get messages on data updates.
+	 * Required for HasLocalDataPoolIF, return a handle to the local pool manager.
 	 * @return
 	 */
-	ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
-
-	//! Accessor handle required for internal handling.
-	AccessPoolManagerIF* getAccessorHandle() override;
+	LocalDataPoolManager* getHkManagerHandle() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index bc72ada24..7e5a316ca 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -139,10 +139,6 @@ uint32_t InternalErrorReporter::getStoreHits() {
 	return value;
 }
 
-AccessPoolManagerIF* InternalErrorReporter::getAccessorHandle() {
-	return &poolManager;
-}
-
 void InternalErrorReporter::incrementStoreHits() {
 	mutex->lockMutex(timeoutType, timeoutMs);
 	storeHits++;
@@ -201,6 +197,6 @@ void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType,
 	this->timeoutMs = timeoutMs;
 }
 
-ProvidesDataPoolSubscriptionIF* InternalErrorReporter::getSubscriptionInterface() {
-	return &poolManager;
+LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() {
+    return &poolManager;
 }
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index ec9134d42..a237418ed 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -45,8 +45,7 @@ public:
             LocalDataPoolManager& poolManager) override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
-    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
-	AccessPoolManagerIF* getAccessorHandle() override;
+	LocalDataPoolManager* getHkManagerHandle() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;

From 2c4cd756c6d868a9a1d6e08cb6bfb503012a9cae Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 11:58:50 +0100
Subject: [PATCH 1471/1774] updated to new internal interface

---
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 29 +++++++------------
 1 file changed, 10 insertions(+), 19 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index aaccc90ed..916b3e45a 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -56,7 +56,7 @@ class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
 public:
 	LocalPoolOwnerBase(
 			object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE):
-		SystemObject(objectId), hkManager(this, messageQueue),
+		SystemObject(objectId), poolManager(this, messageQueue),
 		dataset(this, lpool::testSetId) {
 		messageQueue = new MessageQueueMockBase();
 	}
@@ -72,7 +72,7 @@ public:
 	ReturnValue_t initializeHkManager() {
 		if(not initialized) {
 			initialized = true;
-			return hkManager.initialize(messageQueue);
+			return poolManager.initialize(messageQueue);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -80,7 +80,7 @@ public:
 	ReturnValue_t initializeHkManagerAfterTaskCreation() {
 		if(not initializedAfterTaskCreation) {
 			initializedAfterTaskCreation = true;
-			return hkManager.initializeAfterTaskCreation();
+			return poolManager.initializeAfterTaskCreation();
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -109,17 +109,8 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	/**
-	 * This function can be used by data pool consumers to retrieve a handle
-	 * which allows subscriptions to dataset and variable updates.
-	 * @return
-	 */
-	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override {
-		return &hkManager;
-	}
-
-	virtual AccessPoolManagerIF* getAccessorHandle() override {
-		return &hkManager;
+	LocalDataPoolManager* getHkManagerHandle() override {
+	    return &poolManager;
 	}
 
 	uint32_t getPeriodicOperationFrequency() const override {
@@ -163,25 +154,25 @@ public:
 	}
 
 	ReturnValue_t subscribeWrapperSetUpdate() {
-		return hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
+		return poolManager.subscribeForSetUpdateMessages(lpool::testSetId,
 				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
 	}
 
 	ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) {
-		return hkManager.subscribeForUpdatePackets(lpool::testSid, diagnostics,
+		return poolManager.subscribeForUpdatePackets(lpool::testSid, diagnostics,
 				false, objects::HK_RECEIVER_MOCK);
 	}
 
 	ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) {
-		return hkManager.subscribeForVariableUpdateMessages(localPoolId,
+		return poolManager.subscribeForVariableUpdateMessages(localPoolId,
 				MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false);
 	}
 
 	void resetSubscriptionList() {
-		hkManager.clearReceiversList();
+		poolManager.clearReceiversList();
 	}
 
-	LocalDataPoolManager hkManager;
+	LocalDataPoolManager poolManager;
 	LocalPoolTestDataSet dataset;
 private:
 

From 549afaee1d5713de7700445d771a8ada95e96a2d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 12:02:20 +0100
Subject: [PATCH 1472/1774] initialized member

---
 datapool/PoolDataSetBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 65a6651e5..756541469 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -162,7 +162,7 @@ protected:
 
 private:
 	bool protectEveryReadCommitCall = false;
-	MutexIF::TimeoutType timeoutTypeForSingleVars;
+	MutexIF::TimeoutType timeoutTypeForSingleVars = MutexIF::TimeoutType::WAITING;
 	uint32_t mutexTimeoutForSingleVars = 20;
 
 	ReturnValue_t readVariable(uint16_t count);

From 1996215bc7c4e82480f5ef64a3aab8a22d4d9539 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 12:15:43 +0100
Subject: [PATCH 1473/1774] small bugfix

---
 datapoollocal/PoolReadHelper.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index 509aaae98..b863a0f1f 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -16,13 +16,15 @@ public:
                 readObject(readObject), mutexTimeout(mutexTimeout) {
         if(readObject != nullptr) {
             readResult = readObject->read(timeoutType, mutexTimeout);
+            if(readResult != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "PoolReadHelper: Read failed!" << std::endl;
+                sif::error << "PoolReadHelper: Read failed!" << std::endl;
 #else
-            sif::printError("PoolReadHelper: Read failed!\n");
+                sif::printError("PoolReadHelper: Read failed!\n");
 #endif /* FSFW_PRINT_VERBOSITY_LEVEL == 1 */
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+            }
         }
     }
 

From d6b0af3be7a61ca2f00a1158b770d8a0a9c99878 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 12:21:40 +0100
Subject: [PATCH 1474/1774] moved read helper into correct folder

---
 {datapoollocal => datapool}/PoolReadHelper.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
 rename {datapoollocal => datapool}/PoolReadHelper.h (88%)

diff --git a/datapoollocal/PoolReadHelper.h b/datapool/PoolReadHelper.h
similarity index 88%
rename from datapoollocal/PoolReadHelper.h
rename to datapool/PoolReadHelper.h
index b863a0f1f..5c3153bb6 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapool/PoolReadHelper.h
@@ -1,7 +1,7 @@
-#ifndef FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
-#define FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
+#ifndef FSFW_DATAPOOL_POOLREADHELPER_H_
+#define FSFW_DATAPOOL_POOLREADHELPER_H_
 
-#include "LocalPoolDataSetBase.h"
+#include "ReadCommitIF.h"
 #include "../serviceinterface/ServiceInterface.h"
 #include <FSFWConfig.h>
 
@@ -48,4 +48,4 @@ private:
 
 
 
-#endif /* FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_ */
+#endif /* FSFW_DATAPOOL_POOLREADHELPER_H_ */

From fd11cae7be5bebcae0e4483a532f407e362f1a11 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 19:32:18 +0100
Subject: [PATCH 1475/1774] printer: helper macros

---
 serviceinterface/ServiceInterfacePrinter.h | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index fbdccdd16..e898adf68 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -2,6 +2,20 @@
 #include <cstdio>
 #endif
 
+//! https://stackoverflow.com/questions/111928/is-there-a-printf-converter-to-print-in-binary-format
+//! Can be used to print out binary numbers in human-readable format.
+#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
+#define BYTE_TO_BINARY(byte)  \
+  (byte & 0x80 ? '1' : '0'), \
+  (byte & 0x40 ? '1' : '0'), \
+  (byte & 0x20 ? '1' : '0'), \
+  (byte & 0x10 ? '1' : '0'), \
+  (byte & 0x08 ? '1' : '0'), \
+  (byte & 0x04 ? '1' : '0'), \
+  (byte & 0x02 ? '1' : '0'), \
+  (byte & 0x01 ? '1' : '0')
+
+
 namespace sif {
 
 enum PrintLevel {

From eb5548333ee365711f78372dd39c6bf48e10aff7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 20:00:48 +0100
Subject: [PATCH 1476/1774] added missing include guards

---
 serviceinterface/ServiceInterfacePrinter.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index e898adf68..6b062108b 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -1,3 +1,6 @@
+#ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACEPRINTER
+#define FSFW_SERVICEINTERFACE_SERVICEINTERFACEPRINTER
+
 #if FSFW_DISABLE_PRINTOUT == 0
 #include <cstdio>
 #endif
@@ -52,3 +55,4 @@ void printError(const char* fmt, ...);
 
 }
 
+#endif /* FSFW_SERVICEINTERFACE_SERVICEINTERFACEPRINTER */

From f69d6d49c75998d76d30bb51d3b783332283152c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 Jan 2021 15:21:13 +0100
Subject: [PATCH 1477/1774] replaced zu with lu

---
 globalfunctions/arrayprinter.cpp | 3 ++-
 osal/linux/PosixThread.cpp       | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index 25d6fcf4b..b50aeb21c 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -10,7 +10,8 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 	}
 	sif::info << "[";
 #else
-	sif::printInfo("Printing data with size %zu: [", size);
+	// TODO: Use %zu or %lu depending on whether C99 support is given.
+	sif::printInfo("Printing data with size %lu: [", static_cast<unsigned long>(size));
 #endif
 	if(type == OutputType::HEX) {
 		arrayprinter::printHex(data, size, maxCharPerLine);
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 2499b442e..bd8e72583 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -152,7 +152,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 					" the requested " << stackMb << " MB" << std::endl;
 #else
 			sif::printError("PosixThread::createTask: Insufficient memory for "
-					"the requested %zu MB\n", stackMb);
+					"the requested %lu MB\n", static_cast<unsigned long>(stackMb));
 #endif
 		}
 		else if(errno == EINVAL) {

From 05508418a793df4d4c8e1116cf15fe7cbcef5d91 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 15 Jan 2021 16:32:25 +0100
Subject: [PATCH 1478/1774] printf support for array printer

---
 globalfunctions/arrayprinter.cpp | 134 ++++++++++++++++++++-----------
 globalfunctions/arrayprinter.h   |  12 ++-
 2 files changed, 95 insertions(+), 51 deletions(-)

diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index b50aeb21c..6dc959d70 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -3,64 +3,101 @@
 #include <bitset>
 
 void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
-		bool printInfo, size_t maxCharPerLine) {
+        bool printInfo, size_t maxCharPerLine) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	if(printInfo) {
-		sif::info << "Printing data with size " << size << ": ";
-	}
-	sif::info << "[";
+    if(printInfo) {
+        sif::info << "Printing data with size " << size << ": ";
+    }
+    sif::info << "[";
 #else
-	// TODO: Use %zu or %lu depending on whether C99 support is given.
-	sif::printInfo("Printing data with size %lu: [", static_cast<unsigned long>(size));
-#endif
-	if(type == OutputType::HEX) {
-		arrayprinter::printHex(data, size, maxCharPerLine);
-	}
-	else if (type == OutputType::DEC) {
-		arrayprinter::printDec(data, size, maxCharPerLine);
-	}
-	else if(type == OutputType::BIN) {
-	    arrayprinter::printBin(data, size);
-	}
+#if FSFW_NO_C99_IO == 1
+    sif::printInfo("Printing data with size %lu: [", static_cast<unsigned long>(size));
+#else
+    sif::printInfo("Printing data with size %zu: [", size);
+#endif /* FSFW_NO_C99_IO == 1 */
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+    if(type == OutputType::HEX) {
+        arrayprinter::printHex(data, size, maxCharPerLine);
+    }
+    else if (type == OutputType::DEC) {
+        arrayprinter::printDec(data, size, maxCharPerLine);
+    }
+    else if(type == OutputType::BIN) {
+        arrayprinter::printBin(data, size);
+    }
 }
 
 void arrayprinter::printHex(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
+        size_t maxCharPerLine) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::info << std::hex;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << "0x" << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
+    sif::info << std::hex;
+    for(size_t i = 0; i < size; i++) {
+        sif::info << "0x" << static_cast<int>(data[i]);
+        if(i < size - 1) {
+            sif::info << " , ";
+            if(i > 0 and i % maxCharPerLine == 0) {
+                sif::info << std::endl;
 
-			}
-		}
-	}
-	sif::info << std::dec;
-	sif::info << "]" << std::endl;
+            }
+        }
+    }
+    sif::info << std::dec;
+    sif::info << "]" << std::endl;
 #else
-	// how much memory to reserve for printout?
+    // General format: 0x01, 0x02, 0x03 so it is number of chars times 6
+    // plus line break plus small safety margin.
+    char printBuffer[(size + 1) * 7 + 1];
+    size_t currentPos = 0;
+    for(size_t i = 0; i < size; i++) {
+        // To avoid buffer overflows.
+        if(sizeof(printBuffer) - currentPos <= 7) {
+            break;
+        }
+
+        currentPos += snprintf(printBuffer + currentPos, 6, "0x%02x", data[i]);
+        if(i < size - 1) {
+            currentPos += sprintf(printBuffer + currentPos, ", ");
+            if(i > 0 and i % maxCharPerLine == 0) {
+                currentPos += sprintf(printBuffer + currentPos, "\n");
+            }
+        }
+    }
 #endif
 }
 
 void arrayprinter::printDec(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
+        size_t maxCharPerLine) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::info << std::dec;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-			}
-		}
-	}
-	sif::info << "]" << std::endl;
+    sif::info << std::dec;
+    for(size_t i = 0; i < size; i++) {
+        sif::info << static_cast<int>(data[i]);
+        if(i < size - 1){
+            sif::info << " , ";
+            if(i > 0 and i % maxCharPerLine == 0) {
+                sif::info << std::endl;
+            }
+        }
+    }
+    sif::info << "]" << std::endl;
 #else
-	// how much memory to reserve for printout?
+    // General format: 32, 243, -12 so it is number of chars times 5
+    // plus line break plus small safety margin.
+    char printBuffer[(size + 1) * 5 + 1];
+    size_t currentPos = 0;
+    for(size_t i = 0; i < size; i++) {
+        // To avoid buffer overflows.
+        if(sizeof(printBuffer) - currentPos <= 5) {
+            break;
+        }
+
+        currentPos += snprintf(printBuffer + currentPos, 3, "%d", data[i]);
+        if(i < size - 1) {
+            currentPos += sprintf(printBuffer + currentPos, ", ");
+            if(i > 0 and i % maxCharPerLine == 0) {
+                currentPos += sprintf(printBuffer + currentPos, "\n");
+            }
+        }
+    }
 #endif
 }
 
@@ -68,11 +105,14 @@ void arrayprinter::printBin(const uint8_t *data, size_t size) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::info << "\n" << std::flush;
     for(size_t i = 0; i < size; i++) {
-        sif::info << "Byte " << i + 1 << ": 0b"<<
-                std::bitset<8>(data[i]) << ",\n" << std::flush;
+        sif::info << "Byte " << i + 1 << ": 0b" <<  std::bitset<8>(data[i]) << "," << std::endl;
     }
     sif::info << "]" << std::endl;
 #else
-    // how much memory to reserve for printout?
+    sif::printInfo("\n");
+    for(size_t i = 0; i < size; i++) {
+        sif::printInfo("Byte %d: 0b" BYTE_TO_BINARY_PATTERN ",\n", BYTE_TO_BINARY(data[i]));
+    }
+    sif::printInfo("]\n");
 #endif
 }
diff --git a/globalfunctions/arrayprinter.h b/globalfunctions/arrayprinter.h
index e57d8e047..6dfa6ecdc 100644
--- a/globalfunctions/arrayprinter.h
+++ b/globalfunctions/arrayprinter.h
@@ -1,20 +1,24 @@
 #ifndef FRAMEWORK_GLOBALFUNCTIONS_ARRAYPRINTER_H_
 #define FRAMEWORK_GLOBALFUNCTIONS_ARRAYPRINTER_H_
+
 #include <cstdint>
 #include <cstddef>
 
 enum class OutputType {
-	DEC,
-	HEX,
-	BIN
+    DEC,
+    HEX,
+    BIN
 };
 
+//! TODO: Write unit tests for this module.
 namespace arrayprinter {
+
 void print(const uint8_t* data, size_t size, OutputType type = OutputType::HEX,
-		bool printInfo = true, size_t maxCharPerLine = 12);
+        bool printInfo = true, size_t maxCharPerLine = 12);
 void printHex(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
 void printDec(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
 void printBin(const uint8_t* data, size_t size);
+
 }
 
 #endif /* FRAMEWORK_GLOBALFUNCTIONS_ARRAYPRINTER_H_ */

From baba8fa5d796acc11d3a67f1f57ce427147a3fe2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 15 Jan 2021 16:34:05 +0100
Subject: [PATCH 1479/1774] added array printer test stubs

---
 unittest/tests/globalfunctions/CMakeLists.txt       | 3 +++
 unittest/tests/globalfunctions/TestArrayPrinter.cpp | 5 +++++
 2 files changed, 8 insertions(+)
 create mode 100644 unittest/tests/globalfunctions/CMakeLists.txt
 create mode 100644 unittest/tests/globalfunctions/TestArrayPrinter.cpp

diff --git a/unittest/tests/globalfunctions/CMakeLists.txt b/unittest/tests/globalfunctions/CMakeLists.txt
new file mode 100644
index 000000000..4ea49bf74
--- /dev/null
+++ b/unittest/tests/globalfunctions/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(${TARGET_NAME} PRIVATE
+	TestArrayPrinter.cpp
+)
diff --git a/unittest/tests/globalfunctions/TestArrayPrinter.cpp b/unittest/tests/globalfunctions/TestArrayPrinter.cpp
new file mode 100644
index 000000000..591436196
--- /dev/null
+++ b/unittest/tests/globalfunctions/TestArrayPrinter.cpp
@@ -0,0 +1,5 @@
+#include <catch2/catch_test_macros.hpp>
+
+
+
+

From 73b9d058e5a9fb2b897b0a6e59cb2e51feb7dbb5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 15 Jan 2021 16:56:36 +0100
Subject: [PATCH 1480/1774] updated internal unit test

---
 unittest/internal/InternalUnitTester.cpp          | 15 ++++++++++++++-
 unittest/internal/InternalUnitTester.h            |  2 +-
 .../internal/globalfunctions/TestArrayPrinter.cpp |  4 ++++
 .../internal/globalfunctions/TestArrayPrinter.h   | 12 ++++++++++++
 .../tests/globalfunctions/TestArrayPrinter.cpp    |  5 -----
 5 files changed, 31 insertions(+), 7 deletions(-)
 create mode 100644 unittest/internal/globalfunctions/TestArrayPrinter.cpp
 create mode 100644 unittest/internal/globalfunctions/TestArrayPrinter.h
 delete mode 100644 unittest/tests/globalfunctions/TestArrayPrinter.cpp

diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
index bd41969c9..199a3cf04 100644
--- a/unittest/internal/InternalUnitTester.cpp
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -5,24 +5,37 @@
 #include "osal/IntTestSemaphore.h"
 #include "osal/IntTestMutex.h"
 #include "serialize/IntTestSerialization.h"
+#include "globalfunctions/TestArrayPrinter.h"
 
 #include <cstdlib>
 
+struct TestConfig {
+    bool testArrayPrinter;
+};
 InternalUnitTester::InternalUnitTester() {}
 
 InternalUnitTester::~InternalUnitTester() {}
 
-ReturnValue_t InternalUnitTester::performTests() {
+ReturnValue_t InternalUnitTester::performTests(struct TestConfig testConfig) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::info << "Running internal unit tests.." << std::endl;
+#else
+	sif::printInfo("Running internal unit tests..\n");
 #endif
+
 	testserialize::test_serialization();
 	testmq::testMq();
 	testsemaph::testBinSemaph();
 	testsemaph::testCountingSemaph();
 	testmutex::testMutex();
+	if(testConfig.testArrayPrinter) {
+	    arrayprinter::testArrayPrinter();
+	}
+
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::info << "Internal unit tests finished." << std::endl;
+#else
+	sif::printInfo("Running internal unit tests..\n");
 #endif
 	return RETURN_OK;
 }
diff --git a/unittest/internal/InternalUnitTester.h b/unittest/internal/InternalUnitTester.h
index d0b1c106d..e67777b92 100644
--- a/unittest/internal/InternalUnitTester.h
+++ b/unittest/internal/InternalUnitTester.h
@@ -22,7 +22,7 @@ public:
 	 * Some function which calls all other tests
 	 * @return
 	 */
-	virtual ReturnValue_t performTests();
+	virtual ReturnValue_t performTests(struct TestConfig testConfig);
 };
 
 
diff --git a/unittest/internal/globalfunctions/TestArrayPrinter.cpp b/unittest/internal/globalfunctions/TestArrayPrinter.cpp
new file mode 100644
index 000000000..078134e18
--- /dev/null
+++ b/unittest/internal/globalfunctions/TestArrayPrinter.cpp
@@ -0,0 +1,4 @@
+#include "TestArrayPrinter.cpp"
+
+void arrayprinter::testArrayPrinter() {
+}
diff --git a/unittest/internal/globalfunctions/TestArrayPrinter.h b/unittest/internal/globalfunctions/TestArrayPrinter.h
new file mode 100644
index 000000000..b77f18975
--- /dev/null
+++ b/unittest/internal/globalfunctions/TestArrayPrinter.h
@@ -0,0 +1,12 @@
+#ifndef FSFW_UNITTEST_INTERNAL_GLOBALFUNCTIONS_TESTARRAYPRINTER_H_
+#define FSFW_UNITTEST_INTERNAL_GLOBALFUNCTIONS_TESTARRAYPRINTER_H_
+
+namespace arrayprinter {
+
+void testArrayPrinter();
+
+}
+
+
+
+#endif /* FSFW_UNITTEST_INTERNAL_GLOBALFUNCTIONS_TESTARRAYPRINTER_H_ */
diff --git a/unittest/tests/globalfunctions/TestArrayPrinter.cpp b/unittest/tests/globalfunctions/TestArrayPrinter.cpp
deleted file mode 100644
index 591436196..000000000
--- a/unittest/tests/globalfunctions/TestArrayPrinter.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include <catch2/catch_test_macros.hpp>
-
-
-
-

From 79cf009049675f07e695fe4627b021b5912902e3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 15 Jan 2021 17:06:05 +0100
Subject: [PATCH 1481/1774] updated internal unit tester

---
 unittest/internal/CMakeLists.txt                       | 3 ++-
 unittest/internal/InternalUnitTester.cpp               | 5 +----
 unittest/internal/InternalUnitTester.h                 | 7 ++++++-
 unittest/internal/globalfunctions/CMakeLists.txt       | 3 +++
 unittest/internal/globalfunctions/TestArrayPrinter.cpp | 2 +-
 unittest/internal/internal.mk                          | 1 +
 6 files changed, 14 insertions(+), 7 deletions(-)
 create mode 100644 unittest/internal/globalfunctions/CMakeLists.txt

diff --git a/unittest/internal/CMakeLists.txt b/unittest/internal/CMakeLists.txt
index 9c24317f5..11fd2b2ff 100644
--- a/unittest/internal/CMakeLists.txt
+++ b/unittest/internal/CMakeLists.txt
@@ -4,4 +4,5 @@ target_sources(${TARGET_NAME} PRIVATE
 )
 
 add_subdirectory(osal)
-add_subdirectory(serialize)
\ No newline at end of file
+add_subdirectory(serialize)
+add_subdirectory(globalfunctions)
\ No newline at end of file
diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
index 199a3cf04..f89d093af 100644
--- a/unittest/internal/InternalUnitTester.cpp
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -9,14 +9,11 @@
 
 #include <cstdlib>
 
-struct TestConfig {
-    bool testArrayPrinter;
-};
 InternalUnitTester::InternalUnitTester() {}
 
 InternalUnitTester::~InternalUnitTester() {}
 
-ReturnValue_t InternalUnitTester::performTests(struct TestConfig testConfig) {
+ReturnValue_t InternalUnitTester::performTests(struct InternalUnitTester::TestConfig& testConfig) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::info << "Running internal unit tests.." << std::endl;
 #else
diff --git a/unittest/internal/InternalUnitTester.h b/unittest/internal/InternalUnitTester.h
index e67777b92..ae954c6ac 100644
--- a/unittest/internal/InternalUnitTester.h
+++ b/unittest/internal/InternalUnitTester.h
@@ -4,6 +4,7 @@
 #include "UnittDefinitions.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 
+
 /**
  * @brief	Can be used for internal testing, for example for hardware specific
  * 			tests which can not be run on a host-machine.
@@ -15,6 +16,10 @@
  */
 class InternalUnitTester: public HasReturnvaluesIF {
 public:
+    struct TestConfig {
+        bool testArrayPrinter;
+    };
+
 	InternalUnitTester();
 	virtual~ InternalUnitTester();
 
@@ -22,7 +27,7 @@ public:
 	 * Some function which calls all other tests
 	 * @return
 	 */
-	virtual ReturnValue_t performTests(struct TestConfig testConfig);
+	virtual ReturnValue_t performTests(struct InternalUnitTester::TestConfig& testConfig);
 };
 
 
diff --git a/unittest/internal/globalfunctions/CMakeLists.txt b/unittest/internal/globalfunctions/CMakeLists.txt
new file mode 100644
index 000000000..4ea49bf74
--- /dev/null
+++ b/unittest/internal/globalfunctions/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(${TARGET_NAME} PRIVATE
+	TestArrayPrinter.cpp
+)
diff --git a/unittest/internal/globalfunctions/TestArrayPrinter.cpp b/unittest/internal/globalfunctions/TestArrayPrinter.cpp
index 078134e18..c26faa853 100644
--- a/unittest/internal/globalfunctions/TestArrayPrinter.cpp
+++ b/unittest/internal/globalfunctions/TestArrayPrinter.cpp
@@ -1,4 +1,4 @@
-#include "TestArrayPrinter.cpp"
+#include "TestArrayPrinter.h"
 
 void arrayprinter::testArrayPrinter() {
 }
diff --git a/unittest/internal/internal.mk b/unittest/internal/internal.mk
index 799fd7960..1d4c9c997 100644
--- a/unittest/internal/internal.mk
+++ b/unittest/internal/internal.mk
@@ -1,3 +1,4 @@
 CXXSRC += $(wildcard $(CURRENTPATH)/osal/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/serialize/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/globalfunctions/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
\ No newline at end of file

From eae3175976c55ada568cc6785f10ace3eb27a9ad Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 15 Jan 2021 17:25:27 +0100
Subject: [PATCH 1482/1774] repaired internal unit test

---
 unittest/CMakeLists.txt                 |  5 ++++-
 unittest/internal/UnittDefinitions.cpp  |  2 +-
 unittest/internal/osal/IntTestMutex.cpp | 15 ++++++++++-----
 3 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt
index 119ef243a..24f8ef6ff 100644
--- a/unittest/CMakeLists.txt
+++ b/unittest/CMakeLists.txt
@@ -1,2 +1,5 @@
 add_subdirectory(internal)
-add_subdirectory(tests)
\ No newline at end of file
+
+if(LINK_CATCH2)
+    add_subdirectory(tests)
+endif()
\ No newline at end of file
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index 517f561ab..ed4b59c1c 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -5,7 +5,7 @@
 	sif::error << "Unit Tester error: Failed at test ID "
 			<< errorId << std::endl;
 #else
-	sif::printError("Unit Tester error: Failed at test ID 0x%08x", errorId);
+	sif::printError("Unit Tester error: Failed at test ID %s\n", errorId.c_str());
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index 2a1584b8e..13d87a8b0 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -3,8 +3,8 @@
 #include <fsfw/ipc/MutexFactory.h>
 #include <fsfw/unittest/internal/UnittDefinitions.h>
 
-#if defined(hosted)
-#include <fsfw/osal/hosted/Mutex.h>
+#if defined(WIN32) || defined(UNIX)
+#include <fsfw/osal/host/Mutex.h>
 #include <thread>
 #include <future>
 #endif
@@ -19,10 +19,11 @@ void testmutex::testMutex() {
 	}
 	// timed_mutex from the C++ library specifies undefined behaviour if
 	// the timed mutex is locked twice from the same thread.
-#if defined(hosted)
+    // TODO: we should pass a define like FSFW_OSAL_HOST to the build.
+#if defined(WIN32) || defined(UNIX)
 	// This calls the function from
 	// another thread and stores the returnvalue in a future.
-	auto future = std::async(&MutexIF::lockMutex, mutex, 1);
+	auto future = std::async(&MutexIF::lockMutex, mutex, MutexIF::TimeoutType::WAITING, 1);
 	result = future.get();
 #else
 	result = mutex->lockMutex(MutexIF::TimeoutType::WAITING, 1);
@@ -35,8 +36,12 @@ void testmutex::testMutex() {
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		unitt::put_error(id);
 	}
-	result = mutex->unlockMutex();
+
+	// TODO: we should pass a define like FSFW_OSAL_HOST to the build.
+#if !defined(WIN32) && !defined(UNIX)
+    result = mutex->unlockMutex();
 	if(result != MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX) {
 		unitt::put_error(id);
 	}
+#endif
 }

From 38dd2308879d37ca666b308cda743e2c9079c464 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 15 Jan 2021 17:28:31 +0100
Subject: [PATCH 1483/1774] fixed syntax error

---
 unittest/internal/globalfunctions/TestArrayPrinter.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/unittest/internal/globalfunctions/TestArrayPrinter.h b/unittest/internal/globalfunctions/TestArrayPrinter.h
index b77f18975..714c3aed4 100644
--- a/unittest/internal/globalfunctions/TestArrayPrinter.h
+++ b/unittest/internal/globalfunctions/TestArrayPrinter.h
@@ -7,6 +7,4 @@ void testArrayPrinter();
 
 }
 
-
-
 #endif /* FSFW_UNITTEST_INTERNAL_GLOBALFUNCTIONS_TESTARRAYPRINTER_H_ */

From a9135696a58b8ec783ffa46770c4869541d21846 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 15 Jan 2021 18:07:32 +0100
Subject: [PATCH 1484/1774] array printer tests complete

---
 globalfunctions/arrayprinter.cpp              | 57 +++++++++++--------
 globalfunctions/arrayprinter.h                |  9 +--
 serviceinterface/ServiceInterfaceBuffer.cpp   |  4 +-
 serviceinterface/ServiceInterfaceBuffer.h     |  2 +
 serviceinterface/ServiceInterfaceStream.cpp   |  4 ++
 serviceinterface/ServiceInterfaceStream.h     |  2 +
 unittest/internal/InternalUnitTester.cpp      |  2 +-
 .../globalfunctions/TestArrayPrinter.cpp      | 25 ++++++++
 .../globalfunctions/TestArrayPrinter.h        |  3 +
 9 files changed, 77 insertions(+), 31 deletions(-)

diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index 6dc959d70..7dc056b08 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -2,20 +2,21 @@
 #include "../serviceinterface/ServiceInterface.h"
 #include <bitset>
 
+
 void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
         bool printInfo, size_t maxCharPerLine) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     if(printInfo) {
-        sif::info << "Printing data with size " << size << ": ";
+         sif::info << "Printing data with size " << size << ": " << std::endl;
     }
-    sif::info << "[";
 #else
 #if FSFW_NO_C99_IO == 1
-    sif::printInfo("Printing data with size %lu: [", static_cast<unsigned long>(size));
+    sif::printInfo("Printing data with size %lu: \n", static_cast<unsigned long>(size));
 #else
-    sif::printInfo("Printing data with size %zu: [", size);
+    sif::printInfo("Printing data with size %zu: \n", size);
 #endif /* FSFW_NO_C99_IO == 1 */
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
     if(type == OutputType::HEX) {
         arrayprinter::printHex(data, size, maxCharPerLine);
     }
@@ -30,19 +31,23 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 void arrayprinter::printHex(const uint8_t *data, size_t size,
         size_t maxCharPerLine) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << std::hex;
+    if(sif::info.crAdditionEnabled()) {
+        std::cout << "\r" << std::endl;
+    }
+
+    std::cout << "[" << std::hex;
     for(size_t i = 0; i < size; i++) {
-        sif::info << "0x" << static_cast<int>(data[i]);
+        std::cout << "0x" << static_cast<int>(data[i]);
         if(i < size - 1) {
-            sif::info << " , ";
-            if(i > 0 and i % maxCharPerLine == 0) {
-                sif::info << std::endl;
+            std::cout << " , ";
+            if(i > 0 and (i + 1) % maxCharPerLine == 0) {
+                std::cout << std::endl;
 
             }
         }
     }
-    sif::info << std::dec;
-    sif::info << "]" << std::endl;
+    std::cout << std::dec;
+    std::cout << "]" << std::endl;
 #else
     // General format: 0x01, 0x02, 0x03 so it is number of chars times 6
     // plus line break plus small safety margin.
@@ -57,28 +62,33 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
         currentPos += snprintf(printBuffer + currentPos, 6, "0x%02x", data[i]);
         if(i < size - 1) {
             currentPos += sprintf(printBuffer + currentPos, ", ");
-            if(i > 0 and i % maxCharPerLine == 0) {
+            if(i > 0 and (i + 1) % maxCharPerLine == 0) {
                 currentPos += sprintf(printBuffer + currentPos, "\n");
             }
         }
     }
+    printf("[%s]\n", printBuffer);
 #endif
 }
 
 void arrayprinter::printDec(const uint8_t *data, size_t size,
         size_t maxCharPerLine) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << std::dec;
+    if(sif::info.crAdditionEnabled()) {
+        std::cout << "\r" << std::endl;
+    }
+
+    std::cout << "[" << std::dec;
     for(size_t i = 0; i < size; i++) {
-        sif::info << static_cast<int>(data[i]);
+        std::cout << static_cast<int>(data[i]);
         if(i < size - 1){
-            sif::info << " , ";
-            if(i > 0 and i % maxCharPerLine == 0) {
-                sif::info << std::endl;
+            std::cout << " , ";
+            if(i > 0 and (i + 1) % maxCharPerLine == 0) {
+                std::cout << std::endl;
             }
         }
     }
-    sif::info << "]" << std::endl;
+    std::cout << "]" << std::endl;
 #else
     // General format: 32, 243, -12 so it is number of chars times 5
     // plus line break plus small safety margin.
@@ -93,26 +103,23 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
         currentPos += snprintf(printBuffer + currentPos, 3, "%d", data[i]);
         if(i < size - 1) {
             currentPos += sprintf(printBuffer + currentPos, ", ");
-            if(i > 0 and i % maxCharPerLine == 0) {
+            if(i > 0 and (i + 1) % maxCharPerLine == 0) {
                 currentPos += sprintf(printBuffer + currentPos, "\n");
             }
         }
     }
+    printf("[%s]\n", printBuffer);
 #endif
 }
 
 void arrayprinter::printBin(const uint8_t *data, size_t size) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "\n" << std::flush;
     for(size_t i = 0; i < size; i++) {
-        sif::info << "Byte " << i + 1 << ": 0b" <<  std::bitset<8>(data[i]) << "," << std::endl;
+        sif::info << "Byte " << i + 1 << ": 0b" <<  std::bitset<8>(data[i]) << std::endl;
     }
-    sif::info << "]" << std::endl;
 #else
-    sif::printInfo("\n");
     for(size_t i = 0; i < size; i++) {
-        sif::printInfo("Byte %d: 0b" BYTE_TO_BINARY_PATTERN ",\n", BYTE_TO_BINARY(data[i]));
+        sif::printInfo("Byte %d: 0b" BYTE_TO_BINARY_PATTERN "\n", i + 1, BYTE_TO_BINARY(data[i]));
     }
-    sif::printInfo("]\n");
 #endif
 }
diff --git a/globalfunctions/arrayprinter.h b/globalfunctions/arrayprinter.h
index 6dfa6ecdc..e6b3ea6b3 100644
--- a/globalfunctions/arrayprinter.h
+++ b/globalfunctions/arrayprinter.h
@@ -10,13 +10,14 @@ enum class OutputType {
     BIN
 };
 
-//! TODO: Write unit tests for this module.
 namespace arrayprinter {
 
+
+
 void print(const uint8_t* data, size_t size, OutputType type = OutputType::HEX,
-        bool printInfo = true, size_t maxCharPerLine = 12);
-void printHex(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
-void printDec(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+        bool printInfo = true, size_t maxCharPerLine = 10);
+void printHex(const uint8_t* data, size_t size, size_t maxCharPerLine = 10);
+void printDec(const uint8_t* data, size_t size, size_t maxCharPerLine = 10);
 void printBin(const uint8_t* data, size_t size);
 
 }
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 1a02d6e90..3f6245642 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -167,7 +167,9 @@ std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 	return &preamble;
 }
 
-
+bool ServiceInterfaceBuffer::crAdditionEnabled() const {
+    return addCrToPreamble;
+}
 
 #ifdef UT699
 #include "../osal/rtems/Interrupt.h"
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index b1a508486..9d3ce0694 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -70,6 +70,8 @@ private:
 	void putChars(char const* begin, char const* end);
 
 	std::string* getPreamble(size_t * preambleSize = nullptr);
+
+	bool crAdditionEnabled() const;
 };
 
 #endif
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 59526536c..ad14cd04b 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -15,5 +15,9 @@ std::string* ServiceInterfaceStream::getPreamble() {
 	return streambuf.getPreamble();
 }
 
+bool ServiceInterfaceStream::crAdditionEnabled() const {
+    return streambuf.crAdditionEnabled();
+}
+
 #endif
 
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index f3cb2cd05..e3c0ea7ab 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -39,6 +39,8 @@ public:
 	 */
 	std::string* getPreamble();
 
+	bool crAdditionEnabled() const;
+
 protected:
 	ServiceInterfaceBuffer streambuf;
 };
diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
index f89d093af..a9394ad3f 100644
--- a/unittest/internal/InternalUnitTester.cpp
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -32,7 +32,7 @@ ReturnValue_t InternalUnitTester::performTests(struct InternalUnitTester::TestCo
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::info << "Internal unit tests finished." << std::endl;
 #else
-	sif::printInfo("Running internal unit tests..\n");
+	sif::printInfo("Internal unit tests finished.\n");
 #endif
 	return RETURN_OK;
 }
diff --git a/unittest/internal/globalfunctions/TestArrayPrinter.cpp b/unittest/internal/globalfunctions/TestArrayPrinter.cpp
index c26faa853..de016d198 100644
--- a/unittest/internal/globalfunctions/TestArrayPrinter.cpp
+++ b/unittest/internal/globalfunctions/TestArrayPrinter.cpp
@@ -1,4 +1,29 @@
 #include "TestArrayPrinter.h"
 
 void arrayprinter::testArrayPrinter() {
+    {
+        const std::array<uint8_t, 5> testDataSmall = {0x01, 0x02, 0x03, 0x04, 0x05};
+        arrayprinter::print(testDataSmall.data(), testDataSmall.size());
+        arrayprinter::print(testDataSmall.data(), testDataSmall.size(), OutputType::DEC);
+        arrayprinter::print(testDataSmall.data(), testDataSmall.size(), OutputType::BIN);
+    }
+
+    {
+        std::array<uint8_t, 16> testDataMed;
+        for(size_t idx = 0; idx < testDataMed.size(); idx ++) {
+            testDataMed[idx] = testDataMed.size() - idx;
+        }
+        arrayprinter::print(testDataMed.data(), testDataMed.size());
+        arrayprinter::print(testDataMed.data(), testDataMed.size(), OutputType::DEC, 8);
+    }
+
+    {
+        std::array<uint8_t, 32> testDataLarge;
+        for(size_t idx = 0; idx < testDataLarge.size(); idx ++) {
+            testDataLarge[idx] = idx;
+        }
+        arrayprinter::print(testDataLarge.data(), testDataLarge.size());
+        arrayprinter::print(testDataLarge.data(), testDataLarge.size(), OutputType::DEC);
+    }
+
 }
diff --git a/unittest/internal/globalfunctions/TestArrayPrinter.h b/unittest/internal/globalfunctions/TestArrayPrinter.h
index 714c3aed4..50b82ca0c 100644
--- a/unittest/internal/globalfunctions/TestArrayPrinter.h
+++ b/unittest/internal/globalfunctions/TestArrayPrinter.h
@@ -1,6 +1,9 @@
 #ifndef FSFW_UNITTEST_INTERNAL_GLOBALFUNCTIONS_TESTARRAYPRINTER_H_
 #define FSFW_UNITTEST_INTERNAL_GLOBALFUNCTIONS_TESTARRAYPRINTER_H_
 
+#include <fsfw/globalfunctions/arrayprinter.h>
+#include <array>
+
 namespace arrayprinter {
 
 void testArrayPrinter();

From 0514ab4d050628773b7279cccf5880593bb3ee3c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 15 Jan 2021 18:15:52 +0100
Subject: [PATCH 1485/1774] doc

---
 serviceinterface/ServiceInterfaceStream.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index e3c0ea7ab..0ea44f0b9 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -39,6 +39,11 @@ public:
 	 */
 	std::string* getPreamble();
 
+	/**
+	 * Can be used to determine if the stream was configured to add CR characters in addition
+	 * to newline characters.
+	 * @return
+	 */
 	bool crAdditionEnabled() const;
 
 protected:

From aa7ea35b80e86c3d5e7d8b2bb0f374b55480d351 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 16 Jan 2021 14:24:59 +0100
Subject: [PATCH 1486/1774] cyan instead of magenta for debug now

---
 serviceinterface/ServiceInterfaceBuffer.cpp  | 2 +-
 serviceinterface/ServiceInterfacePrinter.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 3f6245642..ccc051c37 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -29,7 +29,7 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 
 #if FSFW_COLORED_OUTPUT == 1
 	if(setMessage.find("DEBUG") != std::string::npos) {
-		colorPrefix = sif::ANSI_COLOR_MAGENTA;
+		colorPrefix = sif::ANSI_COLOR_CYAN;
 	}
 	else if(setMessage.find("INFO") != std::string::npos) {
 		colorPrefix = sif::ANSI_COLOR_GREEN;
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index a12f49e3c..ce797f1c1 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -45,7 +45,7 @@ void fsfwPrint(sif::PrintLevel printType, const char* fmt, va_list arg) {
     	len += sprintf(bufferPosition, sif::ANSI_COLOR_GREEN);
     }
     else if(printType == sif::PrintLevel::DEBUG_LEVEL) {
-    	len += sprintf(bufferPosition, sif::ANSI_COLOR_MAGENTA);
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_CYAN);
     }
     else if(printType == sif::PrintLevel::WARNING_LEVEL) {
     	len += sprintf(bufferPosition, sif::ANSI_COLOR_YELLOW);

From 2c21400aed50fab873a4ca75be24777bfef00bc7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 18 Jan 2021 19:43:44 +0100
Subject: [PATCH 1487/1774] important bugfix

---
 action/ActionMessage.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index b0bcabaa0..4e56feea2 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/action/HasActionsIF.h>
 #include "ActionMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../storagemanager/StorageManagerIF.h"
@@ -53,7 +54,7 @@ void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
 
 void ActionMessage::setCompletionReply(CommandMessage* message,
 		ActionId_t fid, ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK) {
+	if (result == HasReturnvaluesIF::RETURN_OK or result == HasActionsIF::EXECUTION_FINISHED) {
 		message->setCommand(COMPLETION_SUCCESS);
 	} else {
 		message->setCommand(COMPLETION_FAILED);

From 113b4b5ffaa32bbd6b6ec94bab6763112bd3d764 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 18 Jan 2021 19:44:25 +0100
Subject: [PATCH 1488/1774] important bugfix

---
 action/ActionMessage.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index b0bcabaa0..4e56feea2 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/action/HasActionsIF.h>
 #include "ActionMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../storagemanager/StorageManagerIF.h"
@@ -53,7 +54,7 @@ void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
 
 void ActionMessage::setCompletionReply(CommandMessage* message,
 		ActionId_t fid, ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK) {
+	if (result == HasReturnvaluesIF::RETURN_OK or result == HasActionsIF::EXECUTION_FINISHED) {
 		message->setCommand(COMPLETION_SUCCESS);
 	} else {
 		message->setCommand(COMPLETION_FAILED);

From d4b08459f4e27441181d068dcbeb903eec325578 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 18 Jan 2021 19:49:15 +0100
Subject: [PATCH 1489/1774] smaller changes and documentation

---
 action/ActionMessage.cpp | 3 ++-
 action/ActionMessage.h   | 9 ++++++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index 4e56feea2..1c00dee0f 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -1,5 +1,6 @@
-#include <fsfw/action/HasActionsIF.h>
 #include "ActionMessage.h"
+#include "HasActionsIF.h"
+
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../storagemanager/StorageManagerIF.h"
 
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index 7a859de0d..be7116d7f 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -4,8 +4,15 @@
 #include "../ipc/CommandMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../storagemanager/StorageManagerIF.h"
-typedef uint32_t ActionId_t;
 
+using ActionId_t = uint32_t;
+
+/**
+ * @brief   These messages are part of the action module of the FSFW.
+ * @details
+ * These messages are sent amongst objects implementing the HasActionsIF. The ActionHelper
+ * class is able to process these messages.
+ */
 class ActionMessage {
 private:
 	ActionMessage();

From 87fbb5ce756e77fb3f82b134b1705f79547b9fdc Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 18 Jan 2021 19:49:59 +0100
Subject: [PATCH 1490/1774] imrpoved doc

---
 action/ActionMessage.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index be7116d7f..deb110952 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -10,8 +10,8 @@ using ActionId_t = uint32_t;
 /**
  * @brief   These messages are part of the action module of the FSFW.
  * @details
- * These messages are sent amongst objects implementing the HasActionsIF. The ActionHelper
- * class is able to process these messages.
+ * These messages are sent amongst objects implementing the HasActionsIF. Classes like the
+ * ActionHelper are able to process these messages.
  */
 class ActionMessage {
 private:

From 74def820c6ee13c81c08fa799785d75a14f88baa Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 18 Jan 2021 20:03:03 +0100
Subject: [PATCH 1491/1774] improved naming convention

---
 storagemanager/LocalPool.cpp      | 12 ++++++++----
 storagemanager/LocalPool.h        | 27 +++++++++++++++++----------
 storagemanager/StorageManagerIF.h | 10 ++++++++--
 3 files changed, 33 insertions(+), 16 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index cc7c92662..b72f21caa 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -348,16 +348,20 @@ void LocalPool::getFillCount(uint8_t *buffer, uint8_t *bytesWritten) {
 }
 
 
-void LocalPool::clearPage(max_pools_t  pageIndex) {
-	if(pageIndex >= NUMBER_OF_POOLS) {
+void LocalPool::clearPool(max_pools_t  poolIndex) {
+	if(poolIndex >= NUMBER_OF_POOLS) {
 		return;
 	}
 
 	// Mark the storage as free
-	for(auto& size: sizeLists[pageIndex]) {
+	for(auto& size: sizeLists[poolIndex]) {
 		size = STORAGE_FREE;
 	}
 
 	// Set all the page content to 0.
-	std::memset(store[pageIndex].data(), 0, elementSizes[pageIndex]);
+	std::memset(store[poolIndex].data(), 0, elementSizes[poolIndex]);
+}
+
+LocalPool::max_pools_t LocalPool::getNumberOfPools() const {
+    return NUMBER_OF_POOLS;
 }
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index db7711520..4d3994bb6 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -60,15 +60,6 @@ public:
 	};
     using LocalPoolConfig = std::multiset<LocalPoolCfgPair, LocalPoolConfigCmp>;
 
-    /**
-     * @brief   This definition generally sets the number of
-     * 			different sized pools. It is derived from the number of pairs
-     * 			inside the LocalPoolConfig set on object creation.
-     * @details
-     * This must be less than the maximum number of pools (currently 0xff).
-     */
-    const max_pools_t NUMBER_OF_POOLS;
-
     /**
      * @brief   This is the default constructor for a pool manager instance.
      * @details
@@ -143,9 +134,15 @@ public:
 	void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) override;
 
 	void clearStore() override;
-	void clearPage(max_pools_t pageIndex) override;
+	void clearPool(max_pools_t poolIndex) override;
 
 	ReturnValue_t initialize() override;
+
+    /**
+     * Get number pools. Each pool has pages with a specific bucket size.
+     * @return
+     */
+    max_pools_t getNumberOfPools() const override;
 protected:
 	/**
 	 * With this helper method, a free element of @c size is reserved.
@@ -158,6 +155,16 @@ protected:
 			store_address_t* address, bool ignoreFault);
 
 private:
+
+    /**
+     * @brief   This definition generally sets the number of
+     *          different sized pools. It is derived from the number of pairs
+     *          inside the LocalPoolConfig set on object creation.
+     * @details
+     * This must be less than the maximum number of pools (currently 0xff).
+     */
+    const max_pools_t NUMBER_OF_POOLS;
+
     /**
      * Indicates that this element is free.
      * This value limits the maximum size of a pool.
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 622519336..cd878c6f5 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -171,10 +171,10 @@ public:
 	virtual void clearStore() = 0;
 
 	/**
-	 * Clears a page in the store. Use with care!
+	 * Clears a pool in the store with the given pool index. Use with care!
 	 * @param pageIndex
 	 */
-	virtual void clearPage(uint8_t pageIndex) = 0;
+	virtual void clearPool(uint8_t poolIndex) = 0;
 
 	/**
 	 * Get the fill count of the pool. The exact form will be implementation
@@ -185,6 +185,12 @@ public:
 	virtual void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) = 0;
 
 	virtual size_t getTotalSize(size_t* additionalSize) = 0;
+
+	/**
+	 * Get number of pools.
+	 * @return
+	 */
+	virtual max_pools_t getNumberOfPools() const = 0;
 };
 
 #endif /* FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_ */

From f7b70984c19ef8752bfef7173a4cc12a3c352acb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 18 Jan 2021 20:20:01 +0100
Subject: [PATCH 1492/1774] updated doc

---
 storagemanager/StorageManagerIF.h | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index cd878c6f5..7aeca5d36 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -177,10 +177,13 @@ public:
 	virtual void clearPool(uint8_t poolIndex) = 0;
 
 	/**
-	 * Get the fill count of the pool. The exact form will be implementation
-	 * dependant.
+	 * Get the fill count of the pool. Each character inside the provided
+	 * buffer will be assigned to a rounded percentage fill count for each
+	 * page. The last written byte (at the index bytesWritten - 1)
+	 * will contain the total fill count of the pool as a mean of the
+	 * percentages of single pages.
 	 * @param buffer
-	 * @param bytesWritten
+	 * @param maxSize
 	 */
 	virtual void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) = 0;
 

From f4a60a03236da519ff89ef0a4ecc829e6789df23 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 19 Jan 2021 14:37:52 +0100
Subject: [PATCH 1493/1774] less confusing code

---
 events/EventManager.cpp |  1 +
 events/EventManagerIF.h | 21 +++++++++++++++++----
 2 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index e25e574f0..5b2b31b54 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -6,6 +6,7 @@
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
 
+MessageQueueId_t EventManagerIF::eventmanagerQueue = MessageQueueIF::NO_QUEUE;
 
 // If one checks registerListener calls, there are around 40 (to max 50)
 // objects registering for certain events.
diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h
index 253e6910c..ea22f8ae6 100644
--- a/events/EventManagerIF.h
+++ b/events/EventManagerIF.h
@@ -1,11 +1,12 @@
-#ifndef EVENTMANAGERIF_H_
-#define EVENTMANAGERIF_H_
+#ifndef FSFW_EVENTS_EVENTMANAGERIF_H_
+#define FSFW_EVENTS_EVENTMANAGERIF_H_
 
 #include "EventMessage.h"
 #include "eventmatching/eventmatching.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../ipc/MessageQueueIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 class EventManagerIF {
 public:
@@ -41,11 +42,19 @@ public:
 
 	static void triggerEvent(EventMessage* message,
 	        MessageQueueId_t sentFrom = 0) {
-		static MessageQueueId_t eventmanagerQueue = MessageQueueIF::NO_QUEUE;
 		if (eventmanagerQueue == MessageQueueIF::NO_QUEUE) {
 			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
 					objects::EVENT_MANAGER);
 			if (eventmanager == nullptr) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+			    sif::warning << "EventManagerIF::triggerEvent: EventManager invalid or not found!"
+			            << std::endl;
+#else
+			    sif::printWarning("EventManagerIF::triggerEvent: "
+			            "EventManager invalid or not found!");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 			    return;
 			}
 			eventmanagerQueue = eventmanager->getEventReportQueue();
@@ -53,6 +62,10 @@ public:
 		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
 	}
 
+private:
+	//! Initialized by EventManager (C++11 does not allow header-only static member initialization).
+    static MessageQueueId_t eventmanagerQueue;
+
 };
 
-#endif /* EVENTMANAGERIF_H_ */
+#endif /* FSFW_EVENTS_EVENTMANAGERIF_H_ */

From b6888a81855159796594f128eb81e335a3d19872 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 19 Jan 2021 15:04:47 +0100
Subject: [PATCH 1494/1774] better naming

---
 storagemanager/LocalPool.cpp      | 36 +++++++++++++++----------------
 storagemanager/LocalPool.h        | 18 ++++++++--------
 storagemanager/StorageManagerIF.h | 10 ++++-----
 3 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index b72f21caa..2742de772 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -5,15 +5,15 @@
 LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
 		bool registered, bool spillsToHigherPools):
 		SystemObject(setObjectId, registered),
-		NUMBER_OF_POOLS(poolConfig.size()),
+		NUMBER_OF_SUBPOOLS(poolConfig.size()),
 		spillsToHigherPools(spillsToHigherPools) {
-	if(NUMBER_OF_POOLS == 0) {
+	if(NUMBER_OF_SUBPOOLS == 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalPool::LocalPool: Passed pool configuration is "
 				<< " invalid!" << std::endl;
 #endif
 	}
-	max_pools_t index = 0;
+	max_subpools_t index = 0;
 	for (const auto& currentPoolConfig: poolConfig) {
 		this->numberOfElements[index] = currentPoolConfig.first;
 		this->elementSizes[index] = currentPoolConfig.second;
@@ -98,7 +98,7 @@ ReturnValue_t LocalPool::modifyData(store_address_t storeId,
 ReturnValue_t LocalPool::modifyData(store_address_t storeId,
         uint8_t **packetPtr, size_t *size) {
     ReturnValue_t status = RETURN_FAILED;
-    if (storeId.poolIndex >= NUMBER_OF_POOLS) {
+    if (storeId.poolIndex >= NUMBER_OF_SUBPOOLS) {
         return ILLEGAL_STORAGE_ID;
     }
     if ((storeId.packetIndex >= numberOfElements[storeId.poolIndex])) {
@@ -151,7 +151,7 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
         store_address_t *storeId) {
     store_address_t localId;
     ReturnValue_t result = ILLEGAL_ADDRESS;
-    for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+    for (uint16_t n = 0; n < NUMBER_OF_SUBPOOLS; n++) {
         //Not sure if new allocates all stores in order. so better be careful.
         if ((store[n].data() <= ptr) and
         		(&store[n][numberOfElements[n]*elementSizes[n]] > ptr)) {
@@ -192,7 +192,7 @@ ReturnValue_t LocalPool::initialize() {
     }
 
     //Check if any pool size is large than the maximum allowed.
-    for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
+    for (uint8_t count = 0; count < NUMBER_OF_SUBPOOLS; count++) {
         if (elementSizes[count] >= STORAGE_FREE) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "LocalPool::initialize: Pool is too large! "
@@ -263,8 +263,8 @@ void LocalPool::write(store_address_t storeId, const uint8_t *data,
     sizeLists[storeId.poolIndex][storeId.packetIndex] = size;
 }
 
-LocalPool::size_type LocalPool::getPageSize(max_pools_t poolIndex) {
-    if (poolIndex < NUMBER_OF_POOLS) {
+LocalPool::size_type LocalPool::getPageSize(max_subpools_t poolIndex) {
+    if (poolIndex < NUMBER_OF_SUBPOOLS) {
         return elementSizes[poolIndex];
     }
     else {
@@ -278,7 +278,7 @@ void LocalPool::setToSpillToHigherPools(bool enable) {
 
 ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
         uint16_t startAtIndex) {
-    for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
+    for (uint16_t n = startAtIndex; n < NUMBER_OF_SUBPOOLS; n++) {
 #if FSFW_VERBOSE_PRINTOUT == 2
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: "
@@ -313,7 +313,7 @@ ReturnValue_t LocalPool::findEmpty(n_pool_elem_t poolIndex, uint16_t *element) {
 size_t LocalPool::getTotalSize(size_t* additionalSize) {
     size_t totalSize = 0;
     size_t sizesSize = 0;
-    for(uint8_t idx = 0; idx < NUMBER_OF_POOLS; idx ++) {
+    for(uint8_t idx = 0; idx < NUMBER_OF_SUBPOOLS; idx ++) {
         totalSize += elementSizes[idx] * numberOfElements[idx];
         sizesSize += numberOfElements[idx] * sizeof(size_type);
     }
@@ -331,7 +331,7 @@ void LocalPool::getFillCount(uint8_t *buffer, uint8_t *bytesWritten) {
 	uint16_t reservedHits = 0;
 	uint8_t idx = 0;
 	uint16_t sum = 0;
-	for(; idx < NUMBER_OF_POOLS; idx ++) {
+	for(; idx < NUMBER_OF_SUBPOOLS; idx ++) {
 		for(const auto& size: sizeLists[idx]) {
 			if(size != STORAGE_FREE) {
 				reservedHits++;
@@ -343,25 +343,25 @@ void LocalPool::getFillCount(uint8_t *buffer, uint8_t *bytesWritten) {
 		sum += buffer[idx];
 		reservedHits = 0;
 	}
-	buffer[idx] = sum / NUMBER_OF_POOLS;
+	buffer[idx] = sum / NUMBER_OF_SUBPOOLS;
 	*bytesWritten += 1;
 }
 
 
-void LocalPool::clearPool(max_pools_t  poolIndex) {
-	if(poolIndex >= NUMBER_OF_POOLS) {
+void LocalPool::clearSubPool(max_subpools_t  subpoolIndex) {
+	if(subpoolIndex >= NUMBER_OF_SUBPOOLS) {
 		return;
 	}
 
 	// Mark the storage as free
-	for(auto& size: sizeLists[poolIndex]) {
+	for(auto& size: sizeLists[subpoolIndex]) {
 		size = STORAGE_FREE;
 	}
 
 	// Set all the page content to 0.
-	std::memset(store[poolIndex].data(), 0, elementSizes[poolIndex]);
+	std::memset(store[subpoolIndex].data(), 0, elementSizes[subpoolIndex]);
 }
 
-LocalPool::max_pools_t LocalPool::getNumberOfPools() const {
-    return NUMBER_OF_POOLS;
+LocalPool::max_subpools_t LocalPool::getNumberOfSubPools() const {
+    return NUMBER_OF_SUBPOOLS;
 }
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 4d3994bb6..a58f911b7 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -134,15 +134,15 @@ public:
 	void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) override;
 
 	void clearStore() override;
-	void clearPool(max_pools_t poolIndex) override;
+	void clearSubPool(max_subpools_t poolIndex) override;
 
 	ReturnValue_t initialize() override;
 
     /**
-     * Get number pools. Each pool has pages with a specific bucket size.
+     * Get number sub pools. Each pool has pages with a specific bucket size.
      * @return
      */
-    max_pools_t getNumberOfPools() const override;
+    max_subpools_t getNumberOfSubPools() const override;
 protected:
 	/**
 	 * With this helper method, a free element of @c size is reserved.
@@ -163,7 +163,7 @@ private:
      * @details
      * This must be less than the maximum number of pools (currently 0xff).
      */
-    const max_pools_t NUMBER_OF_POOLS;
+    const max_subpools_t NUMBER_OF_SUBPOOLS;
 
     /**
      * Indicates that this element is free.
@@ -177,20 +177,20 @@ private:
 	 * 			must be set in ascending order on construction.
 	 */
     std::vector<size_type> elementSizes =
-            std::vector<size_type>(NUMBER_OF_POOLS);
+            std::vector<size_type>(NUMBER_OF_SUBPOOLS);
 	/**
 	 * @brief	n_elements stores the number of elements per pool.
 	 * @details	These numbers are maintained for internal pool management.
 	 */
 	std::vector<uint16_t> numberOfElements =
-	        std::vector<uint16_t>(NUMBER_OF_POOLS);
+	        std::vector<uint16_t>(NUMBER_OF_SUBPOOLS);
 	/**
 	 * @brief	store represents the actual memory pool.
 	 * @details	It is an array of pointers to memory, which was allocated with
 	 * 			a @c new call on construction.
 	 */
 	std::vector<std::vector<uint8_t>> store =
-	        std::vector<std::vector<uint8_t>>(NUMBER_OF_POOLS);
+	        std::vector<std::vector<uint8_t>>(NUMBER_OF_SUBPOOLS);
 
 	/**
 	 * @brief	The size_list attribute stores the size values of every pool element.
@@ -198,7 +198,7 @@ private:
 	 * 			is also dynamically allocated there.
 	 */
 	std::vector<std::vector<size_type>> sizeLists =
-	        std::vector<std::vector<size_type>>(NUMBER_OF_POOLS);
+	        std::vector<std::vector<size_type>>(NUMBER_OF_SUBPOOLS);
 
 	//! A variable to determine whether higher n pools are used if
 	//! the store is full.
@@ -217,7 +217,7 @@ private:
 	 * @param pool_index	The pool in which to look.
 	 * @return	Returns the size of an element or 0.
 	 */
-	size_type getPageSize(max_pools_t poolIndex);
+	size_type getPageSize(max_subpools_t poolIndex);
 
 	/**
 	 * @brief	This helper method looks up a fitting pool for a given size.
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 7aeca5d36..da7ce01d3 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -29,7 +29,7 @@ using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
 class StorageManagerIF : public HasReturnvaluesIF {
 public:
 	using size_type = size_t;
-	using max_pools_t = uint8_t;
+	using max_subpools_t = uint8_t;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
 	static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
@@ -149,10 +149,10 @@ public:
 	virtual ReturnValue_t modifyData(store_address_t packet_id,
 			uint8_t** packet_ptr, size_t* size) = 0;
 	/**
-	 * This method reserves an element of \c size.
+	 * This method reserves an element of @c size.
 	 *
 	 * It returns the packet id of this element as well as a direct pointer to the
-	 * data of the element. It must be assured that exactly \c size data is
+	 * data of the element. It must be assured that exactly @c size data is
 	 * written to p_data!
 	 * @param storageId A pointer to the storageId to retrieve.
 	 * @param size		The size of the space to be reserved.
@@ -174,7 +174,7 @@ public:
 	 * Clears a pool in the store with the given pool index. Use with care!
 	 * @param pageIndex
 	 */
-	virtual void clearPool(uint8_t poolIndex) = 0;
+	virtual void clearSubPool(uint8_t poolIndex) = 0;
 
 	/**
 	 * Get the fill count of the pool. Each character inside the provided
@@ -193,7 +193,7 @@ public:
 	 * Get number of pools.
 	 * @return
 	 */
-	virtual max_pools_t getNumberOfPools() const = 0;
+	virtual max_subpools_t getNumberOfSubPools() const = 0;
 };
 
 #endif /* FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_ */

From ca22ff5d8e8b9ab1e9fd3e6ddffccb52d44509ca Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 19 Jan 2021 15:06:21 +0100
Subject: [PATCH 1495/1774] more renaming

---
 storagemanager/LocalPool.cpp | 16 ++++++++--------
 storagemanager/LocalPool.h   |  4 ++--
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 2742de772..2b7335481 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -127,7 +127,7 @@ ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
 
 #endif
     ReturnValue_t status = RETURN_OK;
-    size_type pageSize = getPageSize(storeId.poolIndex);
+    size_type pageSize = getSubpoolElementSize(storeId.poolIndex);
     if ((pageSize != 0) and
             (storeId.packetIndex < numberOfElements[storeId.poolIndex])) {
         uint16_t packetPosition = getRawPosition(storeId);
@@ -217,7 +217,7 @@ void LocalPool::clearStore() {
 
 ReturnValue_t LocalPool::reserveSpace(const size_t size,
         store_address_t *storeId, bool ignoreFault) {
-    ReturnValue_t status = getPoolIndex(size, &storeId->poolIndex);
+    ReturnValue_t status = getSubPoolIndex(size, &storeId->poolIndex);
     if (status != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
@@ -227,7 +227,7 @@ ReturnValue_t LocalPool::reserveSpace(const size_t size,
     }
     status = findEmpty(storeId->poolIndex, &storeId->packetIndex);
     while (status != RETURN_OK && spillsToHigherPools) {
-        status = getPoolIndex(size, &storeId->poolIndex, storeId->poolIndex + 1);
+        status = getSubPoolIndex(size, &storeId->poolIndex, storeId->poolIndex + 1);
         if (status != RETURN_OK) {
             //We don't find any fitting pool anymore.
             break;
@@ -263,9 +263,9 @@ void LocalPool::write(store_address_t storeId, const uint8_t *data,
     sizeLists[storeId.poolIndex][storeId.packetIndex] = size;
 }
 
-LocalPool::size_type LocalPool::getPageSize(max_subpools_t poolIndex) {
-    if (poolIndex < NUMBER_OF_SUBPOOLS) {
-        return elementSizes[poolIndex];
+LocalPool::size_type LocalPool::getSubpoolElementSize(max_subpools_t subpoolIndex) {
+    if (subpoolIndex < NUMBER_OF_SUBPOOLS) {
+        return elementSizes[subpoolIndex];
     }
     else {
         return 0;
@@ -276,7 +276,7 @@ void LocalPool::setToSpillToHigherPools(bool enable) {
 	this->spillsToHigherPools = enable;
 }
 
-ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
+ReturnValue_t LocalPool::getSubPoolIndex(size_t packetSize, uint16_t *subpoolIndex,
         uint16_t startAtIndex) {
     for (uint16_t n = startAtIndex; n < NUMBER_OF_SUBPOOLS; n++) {
 #if FSFW_VERBOSE_PRINTOUT == 2
@@ -286,7 +286,7 @@ ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
 #endif
 #endif
         if (elementSizes[n] >= packetSize) {
-            *poolIndex = n;
+            *subpoolIndex = n;
             return RETURN_OK;
         }
     }
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index a58f911b7..6a6664853 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -217,7 +217,7 @@ private:
 	 * @param pool_index	The pool in which to look.
 	 * @return	Returns the size of an element or 0.
 	 */
-	size_type getPageSize(max_subpools_t poolIndex);
+	size_type getSubpoolElementSize(max_subpools_t subpoolIndex);
 
 	/**
 	 * @brief	This helper method looks up a fitting pool for a given size.
@@ -228,7 +228,7 @@ private:
 	 * @return	- @c RETURN_OK on success,
 	 * 			- @c DATA_TOO_LARGE otherwise.
 	 */
-	ReturnValue_t getPoolIndex(size_t packetSize, uint16_t* poolIndex,
+	ReturnValue_t getSubPoolIndex(size_t packetSize, uint16_t* subpoolIndex,
 			uint16_t startAtIndex = 0);
 	/**
 	 * @brief	This helper method calculates the true array position in store

From 583d354fb5af3d68615f6597fb3ead4f57ce6f89 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 19 Jan 2021 15:48:50 +0100
Subject: [PATCH 1496/1774] removed include

---
 action/ActionMessage.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index 34b7913e3..1c00dee0f 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -1,4 +1,3 @@
-#include <fsfw/action/HasActionsIF.h>
 #include "ActionMessage.h"
 #include "HasActionsIF.h"
 

From ffb6208b24278a10612f17180d142ac58aa5aab1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 19 Jan 2021 16:13:10 +0100
Subject: [PATCH 1497/1774] cmake lists update

---
 CMakeLists.txt | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 76542842f..d6911f613 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -116,7 +116,15 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 		  -Wno-unused-parameter
 		  -Wno-psabi
         )
+		
+	if(NOT DEFINED WARNING_SHADOW_LOCAL)
+		option(WARNING_SHADOW_LOCAL "Show shadows declarations warning." ON)
 	endif()
+	
+	if(WARNING_SHADOW_LOCAL)
+		list(APPEND WARNING_FLAGS "-Wshadow=local")
+	endif()
+	
 endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")

From b23309a5f4f1b73f86ee5d560f830e551e4b1e5e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 19 Jan 2021 16:30:17 +0100
Subject: [PATCH 1498/1774] improved options

---
 CMakeLists.txt | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d6911f613..9dbd24cb4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,10 @@
 cmake_minimum_required(VERSION 3.13)
 
+option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
+# Options to exclude parts of the FSFW from compilation.
+option(FSFW_USE_RMAP "Compile with RMAP" ON)
+option(FSFW_USE_DATALINKLAYER "Compile with Data Link Layer" ON)
+
 set(LIB_FSFW_NAME fsfw)
 add_library(${LIB_FSFW_NAME})
 
@@ -40,9 +45,7 @@ endif()
 
 message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
 
-# Options to exclude parts of the FSFW from compilation.
-option(FSFW_USE_RMAP "Compile with RMAP" ON)
-option(FSFW_USE_DATALINKLAYER "Compile with Data Link Layer" ON)
+
 
 add_subdirectory(action)
 add_subdirectory(container)
@@ -116,12 +119,8 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 		  -Wno-unused-parameter
 		  -Wno-psabi
         )
-		
-	if(NOT DEFINED WARNING_SHADOW_LOCAL)
-		option(WARNING_SHADOW_LOCAL "Show shadows declarations warning." ON)
-	endif()
 	
-	if(WARNING_SHADOW_LOCAL)
+	if(FSFW_WARNING_SHADOW_LOCAL_GCC)
 		list(APPEND WARNING_FLAGS "-Wshadow=local")
 	endif()
 	

From 2e9a85518187bc6256cfeb5890a3252be2d2b629 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 19 Jan 2021 16:33:01 +0100
Subject: [PATCH 1499/1774] updating cmakelists

---
 CMakeLists.txt | 2 --
 1 file changed, 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9dbd24cb4..80bb11bb2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -45,8 +45,6 @@ endif()
 
 message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
 
-
-
 add_subdirectory(action)
 add_subdirectory(container)
 add_subdirectory(controller)

From e0f8113eac7f4628cab072aa000a717572fa3336 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 19 Jan 2021 16:39:12 +0100
Subject: [PATCH 1500/1774] added missing endif

---
 CMakeLists.txt | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9dbd24cb4..e18e3edea 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -119,10 +119,11 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 		  -Wno-unused-parameter
 		  -Wno-psabi
         )
-	
-	if(FSFW_WARNING_SHADOW_LOCAL_GCC)
-		list(APPEND WARNING_FLAGS "-Wshadow=local")
-	endif()
+    endif()
+        
+    if(FSFW_WARNING_SHADOW_LOCAL_GCC)
+        list(APPEND WARNING_FLAGS "-Wshadow=local")
+    endif()
 	
 endif()
 

From 50733e223adaf9fc95d9728c62a026ea6efac1d2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 19 Jan 2021 16:42:18 +0100
Subject: [PATCH 1501/1774] small fix

---
 CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 70836d9ec..3b0917fd2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -112,7 +112,6 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	   set(FSFW_WARNING_FLAGS
 		  -Wall
 		  -Wextra
-		  -Wshadow=local
 		  -Wimplicit-fallthrough=1
 		  -Wno-unused-parameter
 		  -Wno-psabi

From 7b82a7c1a787f68cb39cd565db418d79e73e47ef Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 22 Jan 2021 12:21:45 +0100
Subject: [PATCH 1502/1774] added stopwatch printf support

---
 timemanager/Stopwatch.cpp | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index f79d2eebd..5d67e6c1f 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -1,5 +1,5 @@
 #include "Stopwatch.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include <iomanip>
 
 Stopwatch::Stopwatch(bool displayOnDestruction,
@@ -28,9 +28,13 @@ double Stopwatch::stopSeconds() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
+        dur_millis_t timeMillis = static_cast<dur_millis_t>(
+                elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000);
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
-                elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
+        sif::info << "Stopwatch: Operation took " << timeMillis << " milliseconds" << std::endl;
+#else
+        sif::printInfo("Stopwatch: Operation took %lu milliseconds\n\r",
+                static_cast<unsigned int>(timeMillis));
 #endif
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {
@@ -38,6 +42,9 @@ void Stopwatch::display() {
         sif::info <<"Stopwatch: Operation took "  << std::setprecision(3)
              << std::fixed << timevalOperations::toDouble(elapsedTime)
              << " seconds" << std::endl;
+#else
+        sif::printInfo("Stopwatch: Operation took %.3f seconds\n\r",
+                static_cast<float>(timevalOperations::toDouble(elapsedTime)));
 #endif
     }
 }

From bdd1bdb080c06ca9d26cfb946622cd0ad6e95bb4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 24 Jan 2021 16:53:58 +0100
Subject: [PATCH 1503/1774] bugfix

---
 housekeeping/HousekeepingMessage.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 221f0a6f8..5d7329610 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -176,7 +176,7 @@ void HousekeepingMessage::setUpdateNotificationVariableCommand(
 
 void HousekeepingMessage::setUpdateSnapshotSetCommand(CommandMessage *command,
         sid_t sid, store_address_t storeId) {
-    command->setCommand(UPDATE_SNAPSHOT_VARIABLE);
+    command->setCommand(UPDATE_SNAPSHOT_SET);
     setSid(command, sid);
     command->setParameter3(storeId.raw);
 }

From 8850b770ee0b6e49a8627136fa69c7d190adc287 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 24 Jan 2021 17:03:03 +0100
Subject: [PATCH 1504/1774] important bugfix

---
 housekeeping/HousekeepingMessage.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 221f0a6f8..5d7329610 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -176,7 +176,7 @@ void HousekeepingMessage::setUpdateNotificationVariableCommand(
 
 void HousekeepingMessage::setUpdateSnapshotSetCommand(CommandMessage *command,
         sid_t sid, store_address_t storeId) {
-    command->setCommand(UPDATE_SNAPSHOT_VARIABLE);
+    command->setCommand(UPDATE_SNAPSHOT_SET);
     setSid(command, sid);
     command->setParameter3(storeId.raw);
 }

From e245f56a4f47d3cde6ce266d981347a6097e56f1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 24 Jan 2021 21:18:22 +0100
Subject: [PATCH 1505/1774] updated indentation

---
 unittest/tests/datapoollocal/DataSetTest.cpp  |  22 +-
 .../datapoollocal/LocalPoolManagerTest.cpp    | 196 ++++++-------
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 266 +++++++++---------
 .../datapoollocal/LocalPoolVariableTest.cpp   | 194 ++++++-------
 .../datapoollocal/LocalPoolVectorTest.cpp     | 182 ++++++------
 5 files changed, 430 insertions(+), 430 deletions(-)

diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 968a0b3df..5c2428ae1 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -6,17 +6,17 @@
 #include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
-	LocalPoolOwnerBase* poolOwner = objectManager->
-			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
-	REQUIRE(poolOwner != nullptr);
-	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
-	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
-			== retval::CATCH_OK);
-	const uint32_t setId = 0;
-	SECTION("BasicTest") {
-		StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>(
-				sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, setId));
-	}
+    LocalPoolOwnerBase* poolOwner = objectManager->
+            get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+    REQUIRE(poolOwner != nullptr);
+    REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+    REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+            == retval::CATCH_OK);
+    const uint32_t setId = 0;
+    SECTION("BasicTest") {
+        StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>(
+                sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, setId));
+    }
 }
 
 
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index f550582e9..ccd8e70e0 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -8,115 +8,115 @@
 
 
 TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
-	LocalPoolOwnerBase* poolOwner = objectManager->
-			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
-	REQUIRE(poolOwner != nullptr);
-	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
-	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
-			== retval::CATCH_OK);
-	REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK);
-	MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
-	REQUIRE(mqMock != nullptr);
-	CommandMessage messageSent;
-	uint8_t messagesSent = 0;
+    LocalPoolOwnerBase* poolOwner = objectManager->
+            get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+    REQUIRE(poolOwner != nullptr);
+    REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+    REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+            == retval::CATCH_OK);
+    REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK);
+    MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
+    REQUIRE(mqMock != nullptr);
+    CommandMessage messageSent;
+    uint8_t messagesSent = 0;
 
 
-	SECTION("BasicTest") {
-		// Subscribe for message generation on update.
-		REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
-		// Subscribe for an update message.
-		poolOwner->dataset.setChanged(true);
-		// Now the update message should be generated.
-		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
-		REQUIRE(mqMock->wasMessageSent() == true);
+    SECTION("BasicTest") {
+        /* Subscribe for message generation on update. */
+        REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
+        /* Subscribe for an update message. */
+        poolOwner->dataset.setChanged(true);
+        /* Now the update message should be generated. */
+        REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+        REQUIRE(mqMock->wasMessageSent() == true);
 
-		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
-		CHECK(messageSent.getCommand() == static_cast<int>(
-				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+        REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+        CHECK(messageSent.getCommand() == static_cast<int>(
+                HousekeepingMessage::UPDATE_NOTIFICATION_SET));
 
-		// Should have been reset.
-		CHECK(poolOwner->dataset.hasChanged() == false);
-		// Set changed again, result should be the same.
-		poolOwner->dataset.setChanged(true);
-		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+        /* Should have been reset. */
+        CHECK(poolOwner->dataset.hasChanged() == false);
+        /* Set changed again, result should be the same. */
+        poolOwner->dataset.setChanged(true);
+        REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 
-		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
-		CHECK(messagesSent == 1);
-		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
-		CHECK(messageSent.getCommand() == static_cast<int>(
-				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+        REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+        CHECK(messageSent.getCommand() == static_cast<int>(
+                HousekeepingMessage::UPDATE_NOTIFICATION_SET));
 
-		// now subscribe for set update HK as well.
-		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
-		poolOwner->dataset.setChanged(true);
-		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
-		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
-		CHECK(messagesSent == 2);
-		// first message sent should be the update notification, considering
-		// the internal list is a vector checked in insertion order.
-		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
-		CHECK(messageSent.getCommand() == static_cast<int>(
-				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+        /* Now subscribe for set update HK as well. */
+        REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
+        poolOwner->dataset.setChanged(true);
+        REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 2);
+        /* first message sent should be the update notification, considering
+        the internal list is a vector checked in insertion order. */
+        REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+        CHECK(messageSent.getCommand() == static_cast<int>(
+                HousekeepingMessage::UPDATE_NOTIFICATION_SET));
 
-		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
-		CHECK(messageSent.getCommand() == static_cast<int>(
-				HousekeepingMessage::HK_REPORT));
-		// clear message to avoid memory leak, our mock won't do it for us (yet)
-		CommandMessageCleaner::clearCommandMessage(&messageSent);
-	}
+        REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+        CHECK(messageSent.getCommand() == static_cast<int>(
+                HousekeepingMessage::HK_REPORT));
+        /* Clear message to avoid memory leak, our mock won't do it for us (yet) */
+        CommandMessageCleaner::clearCommandMessage(&messageSent);
+    }
 
-	SECTION("AdvancedTests") {
-		// we need to reset the subscription list because the pool owner
-		// is a global object.
-		poolOwner->resetSubscriptionList();
-		// Subscribe for variable update as well
-		REQUIRE(not poolOwner->dataset.hasChanged());
-		REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
-				retval::CATCH_OK);
-		lp_var_t<uint8_t>* poolVar = dynamic_cast<lp_var_t<uint8_t>*>(
-				poolOwner->getPoolObjectHandle(lpool::uint8VarId));
-		REQUIRE(poolVar != nullptr);
-		poolVar->setChanged(true);
-		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+    SECTION("AdvancedTests") {
+        /* we need to reset the subscription list because the pool owner
+        is a global object. */
+        poolOwner->resetSubscriptionList();
+        /* Subscribe for variable update as well */
+        REQUIRE(not poolOwner->dataset.hasChanged());
+        REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
+                retval::CATCH_OK);
+        lp_var_t<uint8_t>* poolVar = dynamic_cast<lp_var_t<uint8_t>*>(
+                poolOwner->getPoolObjectHandle(lpool::uint8VarId));
+        REQUIRE(poolVar != nullptr);
+        poolVar->setChanged(true);
+        REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 
-		// Check update notification was sent.
-		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
-		CHECK(messagesSent == 1);
-		// Should have been reset.
-		CHECK(poolVar->hasChanged() == false);
-		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
-		CHECK(messageSent.getCommand() == static_cast<int>(
-				HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+        /* Check update notification was sent. */
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+        /* Should have been reset. */
+        CHECK(poolVar->hasChanged() == false);
+        REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+        CHECK(messageSent.getCommand() == static_cast<int>(
+                HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
 
-		// now subscribe for the dataset update (HK and update) again
-		REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
-		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
+        /* Now subscribe for the dataset update (HK and update) again */
+        REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
+        REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
 
-		poolOwner->dataset.setChanged(true);
-		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
-		// now two messages should be sent.
-		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
-		CHECK(messagesSent == 2);
-		mqMock->clearMessages(true);
+        poolOwner->dataset.setChanged(true);
+        REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+        /* Now two messages should be sent. */
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 2);
+        mqMock->clearMessages(true);
 
-		poolOwner->dataset.setChanged(true);
-		poolVar->setChanged(true);
-		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
-		// now three messages should be sent.
-		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
-		CHECK(messagesSent == 3);
-		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
-		CHECK(messageSent.getCommand() == static_cast<int>(
-				HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
-		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
-		CHECK(messageSent.getCommand() == static_cast<int>(
-				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
-		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
-		CHECK(messageSent.getCommand() == static_cast<int>(
-				HousekeepingMessage::HK_REPORT));
-		CommandMessageCleaner::clearCommandMessage(&messageSent);
-		REQUIRE(mqMock->receiveMessage(&messageSent) ==
-				static_cast<int>(MessageQueueIF::EMPTY));
-	}
+        poolOwner->dataset.setChanged(true);
+        poolVar->setChanged(true);
+        REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+        /* Now three messages should be sent. */
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 3);
+        REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+        CHECK(messageSent.getCommand() == static_cast<int>(
+                HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+        REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+        CHECK(messageSent.getCommand() == static_cast<int>(
+                HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+        REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+        CHECK(messageSent.getCommand() == static_cast<int>(
+                HousekeepingMessage::HK_REPORT));
+        CommandMessageCleaner::clearCommandMessage(&messageSent);
+        REQUIRE(mqMock->receiveMessage(&messageSent) ==
+                static_cast<int>(MessageQueueIF::EMPTY));
+    }
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 916b3e45a..737f2613c 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -21,32 +21,32 @@ static constexpr lp_id_t int64Vec2Id = 4;
 static constexpr uint32_t testSetId = 0;
 static constexpr uint8_t dataSetMaxVariables = 10;
 static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE,
-		testSetId);
+        testSetId);
 }
 
 
 class LocalPoolTestDataSet: public LocalDataSet {
 public:
-	LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
-		LocalDataSet(owner, setId, lpool::dataSetMaxVariables) {
-	}
+    LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
+        LocalDataSet(owner, setId, lpool::dataSetMaxVariables) {
+    }
 
-	ReturnValue_t assignPointers() {
-		PoolVariableIF** rawVarArray = getContainer();
-		localPoolVarUint8 = dynamic_cast<lp_var_t<uint8_t>*>(rawVarArray[0]);
-		localPoolVarFloat = dynamic_cast<lp_var_t<float>*>(rawVarArray[1]);
-		localPoolUint16Vec = dynamic_cast<lp_vec_t<uint16_t, 3>*>(
-				rawVarArray[2]);
-		if(localPoolVarUint8 == nullptr or  localPoolVarFloat == nullptr or
-				localPoolUint16Vec == nullptr) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t assignPointers() {
+        PoolVariableIF** rawVarArray = getContainer();
+        localPoolVarUint8 = dynamic_cast<lp_var_t<uint8_t>*>(rawVarArray[0]);
+        localPoolVarFloat = dynamic_cast<lp_var_t<float>*>(rawVarArray[1]);
+        localPoolUint16Vec = dynamic_cast<lp_vec_t<uint16_t, 3>*>(
+                rawVarArray[2]);
+        if(localPoolVarUint8 == nullptr or  localPoolVarFloat == nullptr or
+                localPoolUint16Vec == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	lp_var_t<uint8_t>* localPoolVarUint8 = nullptr;
-	lp_var_t<float>* localPoolVarFloat = nullptr;
-	lp_vec_t<uint16_t, 3>* localPoolUint16Vec = nullptr;
+    lp_var_t<uint8_t>* localPoolVarUint8 = nullptr;
+    lp_var_t<float>* localPoolVarFloat = nullptr;
+    lp_vec_t<uint16_t, 3>* localPoolUint16Vec = nullptr;
 
 private:
 };
@@ -54,143 +54,143 @@ private:
 
 class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
 public:
-	LocalPoolOwnerBase(
-			object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE):
-		SystemObject(objectId), poolManager(this, messageQueue),
-		dataset(this, lpool::testSetId) {
-		messageQueue = new MessageQueueMockBase();
-	}
+    LocalPoolOwnerBase(
+            object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE):
+                SystemObject(objectId), poolManager(this, messageQueue),
+                dataset(this, lpool::testSetId) {
+        messageQueue = new MessageQueueMockBase();
+    }
 
-	~LocalPoolOwnerBase() {
-		QueueFactory::instance()->deleteMessageQueue(messageQueue);
-	}
+    ~LocalPoolOwnerBase() {
+        QueueFactory::instance()->deleteMessageQueue(messageQueue);
+    }
 
-	object_id_t getObjectId() const override {
-		return SystemObject::getObjectId();
-	}
+    object_id_t getObjectId() const override {
+        return SystemObject::getObjectId();
+    }
 
-	ReturnValue_t initializeHkManager() {
-		if(not initialized) {
-			initialized = true;
-			return poolManager.initialize(messageQueue);
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t initializeHkManager() {
+        if(not initialized) {
+            initialized = true;
+            return poolManager.initialize(messageQueue);
+        }
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	ReturnValue_t initializeHkManagerAfterTaskCreation() {
-		if(not initializedAfterTaskCreation) {
-			initializedAfterTaskCreation = true;
-			return poolManager.initializeAfterTaskCreation();
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t initializeHkManagerAfterTaskCreation() {
+        if(not initializedAfterTaskCreation) {
+            initializedAfterTaskCreation = true;
+            return poolManager.initializeAfterTaskCreation();
+        }
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	/** Command queue for housekeeping messages. */
-	MessageQueueId_t getCommandQueue() const override {
-		return messageQueue->getId();
-	}
+    /** Command queue for housekeeping messages. */
+    MessageQueueId_t getCommandQueue() const override {
+        return messageQueue->getId();
+    }
 
-	// This is called by initializeAfterTaskCreation of the HK manager.
-	virtual ReturnValue_t initializeLocalDataPool(
-	        localpool::DataPool& localDataPoolMap,
-	        LocalDataPoolManager& poolManager) {
-		// Default initialization empty for now.
-		localDataPoolMap.emplace(lpool::uint8VarId,
-				new PoolEntry<uint8_t>({0}));
-		localDataPoolMap.emplace(lpool::floatVarId,
-				new PoolEntry<float>({0}));
-		localDataPoolMap.emplace(lpool::uint32VarId,
-				new PoolEntry<uint32_t>({0}));
+    // This is called by initializeAfterTaskCreation of the HK manager.
+    virtual ReturnValue_t initializeLocalDataPool(
+            localpool::DataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) {
+        // Default initialization empty for now.
+        localDataPoolMap.emplace(lpool::uint8VarId,
+                new PoolEntry<uint8_t>({0}));
+        localDataPoolMap.emplace(lpool::floatVarId,
+                new PoolEntry<float>({0}));
+        localDataPoolMap.emplace(lpool::uint32VarId,
+                new PoolEntry<uint32_t>({0}));
 
-		localDataPoolMap.emplace(lpool::uint16Vec3Id,
-				new PoolEntry<uint16_t>({0, 0, 0}));
-		localDataPoolMap.emplace(lpool::int64Vec2Id,
-				new PoolEntry<int64_t>({0, 0}));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+        localDataPoolMap.emplace(lpool::uint16Vec3Id,
+                new PoolEntry<uint16_t>({0, 0, 0}));
+        localDataPoolMap.emplace(lpool::int64Vec2Id,
+                new PoolEntry<int64_t>({0, 0}));
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	LocalDataPoolManager* getHkManagerHandle() override {
-	    return &poolManager;
-	}
+    LocalDataPoolManager* getHkManagerHandle() override {
+        return &poolManager;
+    }
 
-	uint32_t getPeriodicOperationFrequency() const override {
-		return 0;
-	}
+    uint32_t getPeriodicOperationFrequency() const override {
+        return 0;
+    }
 
-	/**
-	 * This function is used by the pool manager to get a valid dataset
+    /**
+     * This function is used by the pool manager to get a valid dataset
      * from a SID
-	 * @param sid Corresponding structure ID
-	 * @return
-	 */
-	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override  {
-		return &dataset;
-	}
+     * @param sid Corresponding structure ID
+     * @return
+     */
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override  {
+        return &dataset;
+    }
 
-	virtual LocalPoolObjectBase* getPoolObjectHandle(
-			lp_id_t localPoolId) override {
-		if(localPoolId == lpool::uint8VarId) {
-			return &testUint8;
-		}
-		else if(localPoolId == lpool::uint16Vec3Id) {
-			return &testUint16Vec;
-		}
-		else if(localPoolId == lpool::floatVarId) {
-			return &testFloat;
-		}
-		else if(localPoolId == lpool::int64Vec2Id) {
-			return &testInt64Vec;
-		}
-		else if(localPoolId == lpool::uint32VarId) {
-			return &testUint32;
-		}
-		else {
-			return &testUint8;
-		}
-	}
+    virtual LocalPoolObjectBase* getPoolObjectHandle(
+            lp_id_t localPoolId) override {
+        if(localPoolId == lpool::uint8VarId) {
+            return &testUint8;
+        }
+        else if(localPoolId == lpool::uint16Vec3Id) {
+            return &testUint16Vec;
+        }
+        else if(localPoolId == lpool::floatVarId) {
+            return &testFloat;
+        }
+        else if(localPoolId == lpool::int64Vec2Id) {
+            return &testInt64Vec;
+        }
+        else if(localPoolId == lpool::uint32VarId) {
+            return &testUint32;
+        }
+        else {
+            return &testUint8;
+        }
+    }
 
-	MessageQueueMockBase* getMockQueueHandle() const {
-		return dynamic_cast<MessageQueueMockBase*>(messageQueue);
-	}
+    MessageQueueMockBase* getMockQueueHandle() const {
+        return dynamic_cast<MessageQueueMockBase*>(messageQueue);
+    }
 
-	ReturnValue_t subscribeWrapperSetUpdate() {
-		return poolManager.subscribeForSetUpdateMessages(lpool::testSetId,
-				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
-	}
+    ReturnValue_t subscribeWrapperSetUpdate() {
+        return poolManager.subscribeForSetUpdateMessages(lpool::testSetId,
+                objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
+    }
 
-	ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) {
-		return poolManager.subscribeForUpdatePackets(lpool::testSid, diagnostics,
-				false, objects::HK_RECEIVER_MOCK);
-	}
+    ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) {
+        return poolManager.subscribeForUpdatePackets(lpool::testSid, diagnostics,
+                false, objects::HK_RECEIVER_MOCK);
+    }
 
-	ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) {
-		return poolManager.subscribeForVariableUpdateMessages(localPoolId,
-				MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false);
-	}
+    ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) {
+        return poolManager.subscribeForVariableUpdateMessages(localPoolId,
+                MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false);
+    }
 
-	void resetSubscriptionList() {
-		poolManager.clearReceiversList();
-	}
+    void resetSubscriptionList() {
+        poolManager.clearReceiversList();
+    }
 
-	LocalDataPoolManager poolManager;
-	LocalPoolTestDataSet dataset;
+    LocalDataPoolManager poolManager;
+    LocalPoolTestDataSet dataset;
 private:
 
-	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId,
-			&dataset);
-	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId,
-			&dataset);
-	lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
+    lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId,
+            &dataset);
+    lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId,
+            &dataset);
+    lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
 
-	lp_vec_t<uint16_t, 3> testUint16Vec = lp_vec_t<uint16_t, 3>(this,
-			lpool::uint16Vec3Id, &dataset);
-	lp_vec_t<int64_t, 2> testInt64Vec = lp_vec_t<int64_t, 2>(this,
-			lpool::int64Vec2Id);
+    lp_vec_t<uint16_t, 3> testUint16Vec = lp_vec_t<uint16_t, 3>(this,
+            lpool::uint16Vec3Id, &dataset);
+    lp_vec_t<int64_t, 2> testInt64Vec = lp_vec_t<int64_t, 2>(this,
+            lpool::int64Vec2Id);
 
-	MessageQueueIF* messageQueue = nullptr;
+    MessageQueueIF* messageQueue = nullptr;
 
-	bool initialized = false;
-	bool initializedAfterTaskCreation = false;
+    bool initialized = false;
+    bool initializedAfterTaskCreation = false;
 
 };
 
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index 2e4cb7ecd..eb99e58df 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -6,117 +6,117 @@
 
 
 TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
-	LocalPoolOwnerBase* poolOwner = objectManager->
-			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
-	REQUIRE(poolOwner != nullptr);
-	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
-	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
-			== retval::CATCH_OK);
+    LocalPoolOwnerBase* poolOwner = objectManager->
+            get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+    REQUIRE(poolOwner != nullptr);
+    REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+    REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+            == retval::CATCH_OK);
 
-	SECTION("Basic Tests") {
-		// very basic test.
-		lp_var_t<uint8_t> testVariable = lp_var_t<uint8_t>(
-				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
-		REQUIRE(testVariable.read() == retval::CATCH_OK);
-		CHECK(testVariable.value == 0);
-		testVariable.value = 5;
-		REQUIRE(testVariable.commit() == retval::CATCH_OK);
-		REQUIRE(testVariable.read() == retval::CATCH_OK);
-		REQUIRE(testVariable.value == 5);
-		CHECK(not testVariable.isValid());
-		testVariable.setValid(true);
-		CHECK(testVariable.isValid());
-		CHECK(testVariable.commit(true) == retval::CATCH_OK);
+    SECTION("Basic Tests") {
+        /* very basic test. */
+        lp_var_t<uint8_t> testVariable = lp_var_t<uint8_t>(
+                objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+        REQUIRE(testVariable.read() == retval::CATCH_OK);
+        CHECK(testVariable.value == 0);
+        testVariable.value = 5;
+        REQUIRE(testVariable.commit() == retval::CATCH_OK);
+        REQUIRE(testVariable.read() == retval::CATCH_OK);
+        REQUIRE(testVariable.value == 5);
+        CHECK(not testVariable.isValid());
+        testVariable.setValid(true);
+        CHECK(testVariable.isValid());
+        CHECK(testVariable.commit(true) == retval::CATCH_OK);
 
-		testVariable.setReadWriteMode(pool_rwm_t::VAR_READ);
-		CHECK(testVariable.getReadWriteMode() == pool_rwm_t::VAR_READ);
-		testVariable.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
+        testVariable.setReadWriteMode(pool_rwm_t::VAR_READ);
+        CHECK(testVariable.getReadWriteMode() == pool_rwm_t::VAR_READ);
+        testVariable.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
 
-		testVariable.setDataPoolId(22);
-		CHECK(testVariable.getDataPoolId() == 22);
-		testVariable.setDataPoolId(lpool::uint8VarId);
+        testVariable.setDataPoolId(22);
+        CHECK(testVariable.getDataPoolId() == 22);
+        testVariable.setDataPoolId(lpool::uint8VarId);
 
-		testVariable.setChanged(true);
-		CHECK(testVariable.hasChanged());
-		testVariable.setChanged(false);
+        testVariable.setChanged(true);
+        CHECK(testVariable.hasChanged());
+        testVariable.setChanged(false);
 
-		gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE,
-				lpool::uint8VarId);
-		lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
-		REQUIRE(testVariable2.read() == retval::CATCH_OK);
-		CHECK(testVariable2 == 5);
-		CHECK(testVariable == testVariable2);
-		testVariable = 10;
-		CHECK(testVariable != 5);
-		//CHECK(not testVariable != testVariable2);
-		uint8_t variableRaw = 0;
-		uint8_t* varPtr = &variableRaw;
-		size_t maxSize = testVariable.getSerializedSize();
-		CHECK(maxSize == 1);
-		size_t serSize = 0;
-		CHECK(testVariable.serialize(&varPtr, &serSize, maxSize,
-				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
-		CHECK(variableRaw == 10);
-		const uint8_t* varConstPtr = &variableRaw;
-		testVariable = 5;
-		CHECK(testVariable.deSerialize(&varConstPtr, &serSize,
-				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
-		CHECK(testVariable == 10);
-		CHECK(testVariable != testVariable2);
-		CHECK(testVariable2 < testVariable);
-		CHECK(testVariable2 < 10);
-		CHECK(testVariable > 5);
-		CHECK(testVariable > testVariable2);
-		variableRaw = static_cast<uint8_t>(testVariable2);
-		CHECK(variableRaw == 5);
+        gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE,
+                lpool::uint8VarId);
+        lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
+        REQUIRE(testVariable2.read() == retval::CATCH_OK);
+        CHECK(testVariable2 == 5);
+        CHECK(testVariable == testVariable2);
+        testVariable = 10;
+        CHECK(testVariable != 5);
+        //CHECK(not testVariable != testVariable2);
+        uint8_t variableRaw = 0;
+        uint8_t* varPtr = &variableRaw;
+        size_t maxSize = testVariable.getSerializedSize();
+        CHECK(maxSize == 1);
+        size_t serSize = 0;
+        CHECK(testVariable.serialize(&varPtr, &serSize, maxSize,
+                SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+        CHECK(variableRaw == 10);
+        const uint8_t* varConstPtr = &variableRaw;
+        testVariable = 5;
+        CHECK(testVariable.deSerialize(&varConstPtr, &serSize,
+                SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+        CHECK(testVariable == 10);
+        CHECK(testVariable != testVariable2);
+        CHECK(testVariable2 < testVariable);
+        CHECK(testVariable2 < 10);
+        CHECK(testVariable > 5);
+        CHECK(testVariable > testVariable2);
+        variableRaw = static_cast<uint8_t>(testVariable2);
+        CHECK(variableRaw == 5);
 
-		CHECK(testVariable == 10);
-		testVariable = testVariable2;
-		CHECK(testVariable == 5);
-	}
+        CHECK(testVariable == 10);
+        testVariable = testVariable2;
+        CHECK(testVariable == 5);
+    }
 
-	SECTION("ErrorHandling") {
+    SECTION("ErrorHandling") {
 
-		// not try to use a local pool variable which does not exist
-		lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
-				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
-		REQUIRE(invalidVariable.read() ==
-				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+        /* now try to use a local pool variable which does not exist */
+        lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
+                objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+        REQUIRE(invalidVariable.read() ==
+                static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
 
-		REQUIRE(invalidVariable.commit() ==
-				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
-		// now try to access with wrong type
-		lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
-				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
-		REQUIRE(invalidVariable2.read() ==
-				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+        REQUIRE(invalidVariable.commit() ==
+                static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+        /* now try to access with wrong type */
+        lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
+                objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+        REQUIRE(invalidVariable2.read() ==
+                static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
 
-		lp_var_t<uint8_t> readOnlyVar = lp_var_t<uint8_t>(
-				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
-				nullptr, pool_rwm_t::VAR_READ);
-		REQUIRE(readOnlyVar.commit() ==
-				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
-		lp_var_t<uint8_t> writeOnlyVar = lp_var_t<uint8_t>(
-				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
-				nullptr, pool_rwm_t::VAR_WRITE);
-		REQUIRE(writeOnlyVar.read() == static_cast<int>(
-				PoolVariableIF::INVALID_READ_WRITE_MODE));
+        lp_var_t<uint8_t> readOnlyVar = lp_var_t<uint8_t>(
+                objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
+                nullptr, pool_rwm_t::VAR_READ);
+        REQUIRE(readOnlyVar.commit() ==
+                static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+        lp_var_t<uint8_t> writeOnlyVar = lp_var_t<uint8_t>(
+                objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
+                nullptr, pool_rwm_t::VAR_WRITE);
+        REQUIRE(writeOnlyVar.read() == static_cast<int>(
+                PoolVariableIF::INVALID_READ_WRITE_MODE));
 
-		lp_var_t<uint32_t> uint32tVar = lp_var_t<uint32_t>(
-				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId);
+        lp_var_t<uint32_t> uint32tVar = lp_var_t<uint32_t>(
+                objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId);
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::info << "LocalPoolVariable printout: " <<uint32tVar << std::endl;
+        sif::info << "LocalPoolVariable printout: " <<uint32tVar << std::endl;
 #endif
 
-		// for code coverage. If program does not crash -> OK
-		lp_var_t<uint8_t> invalidObjectVar = lp_var_t<uint8_t>(
-				0xffffffff, lpool::uint8VarId);
-		gp_id_t globPoolId(0xffffffff,
-				lpool::uint8VarId);
-		lp_var_t<uint8_t> invalidObjectVar2 = lp_var_t<uint8_t>(globPoolId);
-		lp_var_t<uint8_t> invalidObjectVar3 = lp_var_t<uint8_t>(nullptr,
-				lpool::uint8VarId);
-	}
+        /* for code coverage. If program does not crash -> OK */
+        lp_var_t<uint8_t> invalidObjectVar = lp_var_t<uint8_t>(
+                0xffffffff, lpool::uint8VarId);
+        gp_id_t globPoolId(0xffffffff,
+                lpool::uint8VarId);
+        lp_var_t<uint8_t> invalidObjectVar2 = lp_var_t<uint8_t>(globPoolId);
+        lp_var_t<uint8_t> invalidObjectVar3 = lp_var_t<uint8_t>(nullptr,
+                lpool::uint8VarId);
+    }
 
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
index 7c309bbb8..2bc47568f 100644
--- a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -5,116 +5,116 @@
 #include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
-	LocalPoolOwnerBase* poolOwner = objectManager->
-			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
-	REQUIRE(poolOwner != nullptr);
-	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
-	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
-			== retval::CATCH_OK);
+    LocalPoolOwnerBase* poolOwner = objectManager->
+            get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+    REQUIRE(poolOwner != nullptr);
+    REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+    REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+            == retval::CATCH_OK);
 
-	SECTION("BasicTest") {
-		// very basic test.
-		lp_vec_t<uint16_t, 3> testVector = lp_vec_t<uint16_t, 3>(
-				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
-		REQUIRE(testVector.read() == retval::CATCH_OK);
-		testVector.value[0] = 5;
-		testVector.value[1] = 232;
-		testVector.value[2] = 32023;
+    SECTION("BasicTest") {
+        // very basic test.
+        lp_vec_t<uint16_t, 3> testVector = lp_vec_t<uint16_t, 3>(
+                objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+        REQUIRE(testVector.read() == retval::CATCH_OK);
+        testVector.value[0] = 5;
+        testVector.value[1] = 232;
+        testVector.value[2] = 32023;
 
-		REQUIRE(testVector.commit(true) == retval::CATCH_OK);
-		CHECK(testVector.isValid());
+        REQUIRE(testVector.commit(true) == retval::CATCH_OK);
+        CHECK(testVector.isValid());
 
-		testVector.value[0] = 0;
-		testVector.value[1] = 0;
-		testVector.value[2] = 0;
+        testVector.value[0] = 0;
+        testVector.value[1] = 0;
+        testVector.value[2] = 0;
 
-		CHECK(testVector.read() == retval::CATCH_OK);
-		CHECK(testVector.value[0] == 5);
-		CHECK(testVector.value[1] == 232);
-		CHECK(testVector.value[2] == 32023);
+        CHECK(testVector.read() == retval::CATCH_OK);
+        CHECK(testVector.value[0] == 5);
+        CHECK(testVector.value[1] == 232);
+        CHECK(testVector.value[2] == 32023);
 
-		CHECK(testVector[0] == 5);
+        CHECK(testVector[0] == 5);
 
-		// This is invalid access, so the last value will be set instead.
-		// (we can't throw exceptions)
-		testVector[4] = 12;
-		CHECK(testVector[2] == 12);
-		CHECK(testVector.commit() == retval::CATCH_OK);
+        /* This is invalid access, so the last value will be set instead.
+        (we can't throw exceptions) */
+        testVector[4] = 12;
+        CHECK(testVector[2] == 12);
+        CHECK(testVector.commit() == retval::CATCH_OK);
 
-		// Use read-only reference.
-		const lp_vec_t<uint16_t, 3>& roTestVec = testVector;
-		uint16_t valueOne = roTestVec[0];
-		CHECK(valueOne == 5);
+        /* Use read-only reference. */
+        const lp_vec_t<uint16_t, 3>& roTestVec = testVector;
+        uint16_t valueOne = roTestVec[0];
+        CHECK(valueOne == 5);
 
-		uint16_t lastVal = roTestVec[25];
-		CHECK(lastVal == 12);
+        uint16_t lastVal = roTestVec[25];
+        CHECK(lastVal == 12);
 
-		size_t maxSize = testVector.getSerializedSize();
-		CHECK(maxSize == 6);
+        size_t maxSize = testVector.getSerializedSize();
+        CHECK(maxSize == 6);
 
-		uint16_t serializedVector[3];
-		uint8_t* vecPtr = reinterpret_cast<uint8_t*>(serializedVector);
-		size_t serSize = 0;
-		REQUIRE(testVector.serialize(&vecPtr, &serSize,
-				maxSize, SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+        uint16_t serializedVector[3];
+        uint8_t* vecPtr = reinterpret_cast<uint8_t*>(serializedVector);
+        size_t serSize = 0;
+        REQUIRE(testVector.serialize(&vecPtr, &serSize,
+                maxSize, SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
 
-		CHECK(serSize == 6);
-		CHECK(serializedVector[0] == 5);
-		CHECK(serializedVector[1] == 232);
-		CHECK(serializedVector[2] == 12);
+        CHECK(serSize == 6);
+        CHECK(serializedVector[0] == 5);
+        CHECK(serializedVector[1] == 232);
+        CHECK(serializedVector[2] == 12);
 
-		maxSize = 1;
-		REQUIRE(testVector.serialize(&vecPtr, &serSize,
-				maxSize, SerializeIF::Endianness::MACHINE) ==
-				static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+        maxSize = 1;
+        REQUIRE(testVector.serialize(&vecPtr, &serSize,
+                maxSize, SerializeIF::Endianness::MACHINE) ==
+                        static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
 
-		serializedVector[0] = 16;
-		serializedVector[1] = 7832;
-		serializedVector[2] = 39232;
+        serializedVector[0] = 16;
+        serializedVector[1] = 7832;
+        serializedVector[2] = 39232;
 
-		const uint8_t* constVecPtr = reinterpret_cast<const uint8_t*>(
-				serializedVector);
-		REQUIRE(testVector.deSerialize(&constVecPtr, &serSize,
-				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
-		CHECK(testVector[0] == 16);
-		CHECK(testVector[1] == 7832);
-		CHECK(testVector[2] == 39232);
+        const uint8_t* constVecPtr = reinterpret_cast<const uint8_t*>(
+                serializedVector);
+        REQUIRE(testVector.deSerialize(&constVecPtr, &serSize,
+                SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+        CHECK(testVector[0] == 16);
+        CHECK(testVector[1] == 7832);
+        CHECK(testVector[2] == 39232);
 
-		serSize = 1;
-		REQUIRE(testVector.deSerialize(&constVecPtr, &serSize,
-				SerializeIF::Endianness::MACHINE) ==
-				static_cast<int>(SerializeIF::STREAM_TOO_SHORT));
-	}
+        serSize = 1;
+        REQUIRE(testVector.deSerialize(&constVecPtr, &serSize,
+                SerializeIF::Endianness::MACHINE) ==
+                        static_cast<int>(SerializeIF::STREAM_TOO_SHORT));
+    }
 
-	SECTION("ErrorHandling") {
-		// not try to use a local pool variable which does not exist
-		lp_vec_t<uint16_t, 3> invalidVector = lp_vec_t<uint16_t, 3>(
-				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
-		REQUIRE(invalidVector.read() ==
-				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
-		REQUIRE(invalidVector.commit() ==
-				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+    SECTION("ErrorHandling") {
+        /* Now try to use a local pool variable which does not exist */
+        lp_vec_t<uint16_t, 3> invalidVector = lp_vec_t<uint16_t, 3>(
+                objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+        REQUIRE(invalidVector.read() ==
+                static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+        REQUIRE(invalidVector.commit() ==
+                static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
 
-		// now try to access with wrong type
-		lp_vec_t<uint32_t, 3> invalidVector2 = lp_vec_t<uint32_t, 3>(
-				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
-		REQUIRE(invalidVector2.read() ==
-				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
-		REQUIRE(invalidVector2.commit() ==
-				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+        /* Now try to access with wrong type */
+        lp_vec_t<uint32_t, 3> invalidVector2 = lp_vec_t<uint32_t, 3>(
+                objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+        REQUIRE(invalidVector2.read() ==
+                static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+        REQUIRE(invalidVector2.commit() ==
+                static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
 
-		lp_vec_t<uint16_t, 3> writeOnlyVec = lp_vec_t<uint16_t, 3>(
-				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
-				nullptr, pool_rwm_t::VAR_WRITE);
-		REQUIRE(writeOnlyVec.read() ==
-				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+        lp_vec_t<uint16_t, 3> writeOnlyVec = lp_vec_t<uint16_t, 3>(
+                objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
+                nullptr, pool_rwm_t::VAR_WRITE);
+        REQUIRE(writeOnlyVec.read() ==
+                static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
 
-		lp_vec_t<uint16_t, 3> readOnlyVec = lp_vec_t<uint16_t, 3>(
-				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
-				nullptr, pool_rwm_t::VAR_READ);
-		REQUIRE(readOnlyVec.commit() ==
-				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
-	}
+        lp_vec_t<uint16_t, 3> readOnlyVec = lp_vec_t<uint16_t, 3>(
+                objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
+                nullptr, pool_rwm_t::VAR_READ);
+        REQUIRE(readOnlyVec.commit() ==
+                static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+    }
 }
 
 

From 094d237814124e5a9b4be0133d04307bb64e93e6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 24 Jan 2021 21:34:38 +0100
Subject: [PATCH 1506/1774] added more tests

---
 .../datapoollocal/LocalPoolManagerTest.cpp    | 21 ++++++++++++++++---
 .../tests/datapoollocal/LocalPoolOwnerBase.h  |  7 ++++++-
 2 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index ccd8e70e0..d43f3c800 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -63,12 +63,27 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
                 HousekeepingMessage::HK_REPORT));
         /* Clear message to avoid memory leak, our mock won't do it for us (yet) */
         CommandMessageCleaner::clearCommandMessage(&messageSent);
-    }
-
-    SECTION("AdvancedTests") {
         /* we need to reset the subscription list because the pool owner
         is a global object. */
         poolOwner->resetSubscriptionList();
+    }
+
+    SECTION("SnapshotUpdateTests") {
+        /* we need to reset the subscription list because the pool owner
+        is a global object. */
+        poolOwner->resetSubscriptionList();
+
+        /* Subscribe for snapshot generation on update. */
+        REQUIRE(poolOwner->subscribeWrapperSetUpdateSnapshot() == retval::CATCH_OK);
+        poolOwner->dataset.setChanged(true);
+        REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+
+    }
+
+    SECTION("AdvancedTests") {
+
         /* Subscribe for variable update as well */
         REQUIRE(not poolOwner->dataset.hasChanged());
         REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 737f2613c..353f7b4dd 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -155,7 +155,12 @@ public:
 
     ReturnValue_t subscribeWrapperSetUpdate() {
         return poolManager.subscribeForSetUpdateMessages(lpool::testSetId,
-                objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
+                objects::NO_OBJECT, objects::HK_RECEIVER_MOCK, false);
+    }
+
+    ReturnValue_t subscribeWrapperSetUpdateSnapshot() {
+        return poolManager.subscribeForSetUpdateMessages(lpool::testSetId,
+                objects::NO_OBJECT, objects::HK_RECEIVER_MOCK, true);
     }
 
     ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) {

From 5289c274f38a3c2b8e43559b287d047b4e132ffb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 24 Jan 2021 21:40:44 +0100
Subject: [PATCH 1507/1774] cmake lists update

---
 CMakeLists.txt | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d6911f613..3b0917fd2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,10 @@
 cmake_minimum_required(VERSION 3.13)
 
+option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
+# Options to exclude parts of the FSFW from compilation.
+option(FSFW_USE_RMAP "Compile with RMAP" ON)
+option(FSFW_USE_DATALINKLAYER "Compile with Data Link Layer" ON)
+
 set(LIB_FSFW_NAME fsfw)
 add_library(${LIB_FSFW_NAME})
 
@@ -40,10 +45,6 @@ endif()
 
 message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
 
-# Options to exclude parts of the FSFW from compilation.
-option(FSFW_USE_RMAP "Compile with RMAP" ON)
-option(FSFW_USE_DATALINKLAYER "Compile with Data Link Layer" ON)
-
 add_subdirectory(action)
 add_subdirectory(container)
 add_subdirectory(controller)
@@ -111,19 +112,15 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	   set(FSFW_WARNING_FLAGS
 		  -Wall
 		  -Wextra
-		  -Wshadow=local
 		  -Wimplicit-fallthrough=1
 		  -Wno-unused-parameter
 		  -Wno-psabi
         )
-		
-	if(NOT DEFINED WARNING_SHADOW_LOCAL)
-		option(WARNING_SHADOW_LOCAL "Show shadows declarations warning." ON)
-	endif()
-	
-	if(WARNING_SHADOW_LOCAL)
-		list(APPEND WARNING_FLAGS "-Wshadow=local")
-	endif()
+    endif()
+        
+    if(FSFW_WARNING_SHADOW_LOCAL_GCC)
+        list(APPEND WARNING_FLAGS "-Wshadow=local")
+    endif()
 	
 endif()
 

From d1c83159e533d66eb0113cf65e20d5f39a280818 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 25 Jan 2021 00:55:27 +0100
Subject: [PATCH 1508/1774] added more unittests

---
 datapoollocal/LocalDataPoolManager.cpp        |  8 +-
 datapoollocal/LocalDataPoolManager.h          |  4 +-
 datapoollocal/LocalDataSet.h                  | 15 ++++
 datapoollocal/LocalPoolVector.h               |  5 +-
 datapoollocal/LocalPoolVector.tpp             |  1 -
 datapoollocal/StaticLocalDataSet.h            |  3 +-
 housekeeping/HousekeepingMessage.cpp          |  2 +-
 ...gPacketUpdate.h => HousekeepingSnapshot.h} | 39 ++++++---
 osal/host/Clock.cpp                           |  7 +-
 .../datapoollocal/LocalPoolManagerTest.cpp    | 79 ++++++++++++++++---
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 46 ++++++-----
 11 files changed, 152 insertions(+), 57 deletions(-)
 rename housekeeping/{HousekeepingPacketUpdate.h => HousekeepingSnapshot.h} (64%)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 462ef17fa..d2732582e 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -5,8 +5,8 @@
 #include "internal/LocalPoolDataSetAttorney.h"
 #include "internal/HasLocalDpIFManagerAttorney.h"
 
-#include "../housekeeping/HousekeepingPacketUpdate.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
+#include "../housekeeping/HousekeepingSnapshot.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
 #include "../timemanager/CCSDSTime.h"
 #include "../ipc/MutexFactory.h"
@@ -226,7 +226,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 		Clock::getClock_timeval(&now);
 		CCSDSTime::CDS_short cds;
 		CCSDSTime::convertToCcsds(&cds, &now);
-		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+		HousekeepingSnapshot updatePacket(reinterpret_cast<uint8_t*>(&cds),
 				sizeof(cds), HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
 						receiver.dataId.localPoolId));
 
@@ -264,7 +264,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 		Clock::getClock_timeval(&now);
 		CCSDSTime::CDS_short cds;
 		CCSDSTime::convertToCcsds(&cds, &now);
-		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+		HousekeepingSnapshot updatePacket(reinterpret_cast<uint8_t*>(&cds),
 				sizeof(cds), HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
 						receiver.dataId.sid));
 
@@ -292,7 +292,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 }
 
 ReturnValue_t LocalDataPoolManager::addUpdateToStore(
-		HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
+		HousekeepingSnapshot& updatePacket, store_address_t& storeId) {
 	size_t updatePacketSize = updatePacket.getSerializedSize();
 	uint8_t *storePtr = nullptr;
 	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 580ac8b93..a72641b08 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -24,7 +24,7 @@ void setStaticFrameworkObjectIds();
 }
 
 class LocalPoolDataSetBase;
-class HousekeepingPacketUpdate;
+class HousekeepingSnapshot;
 class HasLocalDataPoolIF;
 class LocalDataPool;
 
@@ -386,7 +386,7 @@ private:
 	        ReturnValue_t& status);
 	ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver,
             ReturnValue_t& status);
-	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
+	ReturnValue_t addUpdateToStore(HousekeepingSnapshot& updatePacket,
 	        store_address_t& storeId);
 
 	void printWarningOrError(sif::OutputTypes outputType,
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index b7f8f90f0..92bad9b57 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -4,11 +4,26 @@
 #include "LocalPoolDataSetBase.h"
 #include <vector>
 
+/**
+ * @brief   This dataset type can be used to group related pool variables if the number of
+ *          variables should not be fixed.
+ * @details
+ * This will is the primary data structure to organize pool variables into
+ * sets which can be accessed via the housekeeping service interface or
+ * which can be sent to other software objects.
+ *
+ * It is recommended to read the documentation of the LocalPoolDataSetBase
+ * class for more information on how this class works and how to use it.
+ * @tparam capacity Capacity of the static dataset, which is usually known
+ * beforehand.
+ */
 class LocalDataSet: public LocalPoolDataSetBase {
 public:
     LocalDataSet(HasLocalDataPoolIF* hkOwner, uint32_t setId,
             const size_t maxSize);
+
     LocalDataSet(sid_t sid, const size_t maxSize);
+
     virtual~ LocalDataSet();
 
     //! Copying forbidden for now.
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 593d26ab6..591dd6f38 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -77,8 +77,7 @@ public:
      * @param dataSet
      * @param setReadWriteMode
      */
-    LocalPoolVector(gp_id_t globalPoolId,
-            DataSetIF* dataSet = nullptr,
+    LocalPoolVector(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
             pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
     /**
@@ -87,7 +86,7 @@ public:
      * The user can work on this attribute just like he would on a local
      * array of this type.
      */
-    T value[vectorSize];
+    T value[vectorSize]= {};
     /**
      * @brief	The classes destructor is empty.
      * @details	If commit() was not called, the local value is
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 98eb27f9c..5b2089b39 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -16,7 +16,6 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
         lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
         LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
-
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index 0e51fb5bb..4d1cc6378 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -6,7 +6,8 @@
 #include <array>
 
 /**
- * @brief   This local dataset type is created on the stack.
+ * @brief   This dataset type can be used to group related pool variables if the number of
+ *          variables is fixed.
  * @details
  * This will is the primary data structure to organize pool variables into
  * sets which can be accessed via the housekeeping service interface or
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 221f0a6f8..5d7329610 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -176,7 +176,7 @@ void HousekeepingMessage::setUpdateNotificationVariableCommand(
 
 void HousekeepingMessage::setUpdateSnapshotSetCommand(CommandMessage *command,
         sid_t sid, store_address_t storeId) {
-    command->setCommand(UPDATE_SNAPSHOT_VARIABLE);
+    command->setCommand(UPDATE_SNAPSHOT_SET);
     setSid(command, sid);
     command->setParameter3(storeId.raw);
 }
diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingSnapshot.h
similarity index 64%
rename from housekeeping/HousekeepingPacketUpdate.h
rename to housekeeping/HousekeepingSnapshot.h
index 43ec0619c..50afd4af5 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingSnapshot.h
@@ -1,24 +1,37 @@
-#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
-#define FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGSNAPSHOT_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGSNAPSHOT_H_
 
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialLinkedListAdapter.h"
 #include "../datapoollocal/LocalPoolDataSetBase.h"
+#include "../datapoollocal/LocalPoolObjectBase.h"
+#include "../timemanager/CCSDSTime.h"
 
 /**
- * @brief   This helper class will be used to serialize and deserialize
- *          update housekeeping packets into the store.
+ * @brief   This helper class will be used to serialize and deserialize update housekeeping packets
+ *          into the store.
  */
-class HousekeepingPacketUpdate: public SerializeIF {
+class HousekeepingSnapshot: public SerializeIF {
 public:
+
     /**
-     * Update packet constructor for datasets
-     * @param timeStamp
-     * @param timeStampSize
-     * @param hkData
-     * @param hkDataSize
+     * Update packet constructor for datasets.
+     * @param cdsShort          If a CSD short timestamp is used, a reference should be
+     *                          supplied here
+     * @param dataSetPtr        Pointer to the dataset instance to serialize or deserialize the
+     *                          data into
      */
-    HousekeepingPacketUpdate(uint8_t* timeStamp, size_t timeStampSize,
+    HousekeepingSnapshot(CCSDSTime::CDS_short* cdsShort, LocalPoolDataSetBase* dataSetPtr):
+                timeStamp(reinterpret_cast<uint8_t*>(cdsShort)),
+                timeStampSize(sizeof(CCSDSTime::CDS_short)), updateData(dataSetPtr) {};
+
+    /**
+     * Update packet constructor for datasets.
+     * @param timeStamp         Pointer to the buffer where the timestamp will be stored.
+     * @param timeStampSize     Size of the timestamp
+     * @param dataSetPtr        Pointer to the dataset instance to deserialize the data into
+     */
+    HousekeepingSnapshot(uint8_t* timeStamp, size_t timeStampSize,
             LocalPoolDataSetBase* dataSetPtr):
                 timeStamp(timeStamp), timeStampSize(timeStampSize),
                 updateData(dataSetPtr) {};
@@ -29,7 +42,7 @@ public:
      * @param timeStampSize
      * @param dataSetPtr
      */
-    HousekeepingPacketUpdate(uint8_t* timeStamp, size_t timeStampSize,
+    HousekeepingSnapshot(uint8_t* timeStamp, size_t timeStampSize,
             LocalPoolObjectBase* dataSetPtr):
                 timeStamp(timeStamp), timeStampSize(timeStampSize),
                 updateData(dataSetPtr) {};
@@ -89,4 +102,4 @@ private:
 };
 
 
-#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_ */
+#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGSNAPSHOT_H_ */
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 88bf51d23..0b3063490 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -53,8 +53,7 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 	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();
+	time->tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(fraction).count();
 	return HasReturnvaluesIF::RETURN_OK;
 #elif defined(LINUX)
 	timespec timeUnix;
@@ -67,7 +66,9 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 	return HasReturnvaluesIF::RETURN_OK;
 #else
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+	sif::warning << "Clock::getUptime: Not implemented for found OS!" << std::endl;
+#else
+	sif::printWarning("Clock::getUptime: Not implemented for found OS!\n");
 #endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 #endif
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index d43f3c800..b12d484f6 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -1,10 +1,16 @@
 #include "LocalPoolOwnerBase.h"
 
 #include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_approx.hpp>
+
+#include <fsfw/datapool/PoolReadHelper.h>
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/housekeeping/HousekeepingSnapshot.h>
 #include <fsfw/ipc/CommandMessageCleaner.h>
+#include <fsfw/timemanager/CCSDSTime.h>
 #include <unittest/core/CatchDefinitions.h>
+#include <iostream>
 
 
 TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
@@ -14,7 +20,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
     REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
     REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
             == retval::CATCH_OK);
-    REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK);
+    //REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK);
     MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
     REQUIRE(mqMock != nullptr);
     CommandMessage messageSent;
@@ -63,29 +69,76 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
                 HousekeepingMessage::HK_REPORT));
         /* Clear message to avoid memory leak, our mock won't do it for us (yet) */
         CommandMessageCleaner::clearCommandMessage(&messageSent);
-        /* we need to reset the subscription list because the pool owner
-        is a global object. */
-        poolOwner->resetSubscriptionList();
+
     }
 
     SECTION("SnapshotUpdateTests") {
-        /* we need to reset the subscription list because the pool owner
-        is a global object. */
-        poolOwner->resetSubscriptionList();
+        /* Set the variables in the set to certain values. These are checked later. */
+        {
+            PoolReadHelper readHelper(&poolOwner->dataset);
+            REQUIRE(readHelper.getReadResult() == retval::CATCH_OK);
+            poolOwner->dataset.localPoolVarUint8.value = 5;
+            poolOwner->dataset.localPoolVarFloat.value = -12.242;
+            poolOwner->dataset.localPoolUint16Vec.value[0] = 2;
+            poolOwner->dataset.localPoolUint16Vec.value[1] = 32;
+            poolOwner->dataset.localPoolUint16Vec.value[2] = 42932;
+        }
 
         /* Subscribe for snapshot generation on update. */
         REQUIRE(poolOwner->subscribeWrapperSetUpdateSnapshot() == retval::CATCH_OK);
         poolOwner->dataset.setChanged(true);
+
+        /* Store current time, we are going to check the (approximate) time equality later */
+        CCSDSTime::CDS_short timeCdsNow;
+        timeval now;
+        Clock::getClock_timeval(&now);
+        CCSDSTime::convertToCcsds(&timeCdsNow, &now);
+
+        /* Trigger generation of snapshot */
         REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
         REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
         CHECK(messagesSent == 1);
+        REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+        /* Check that snapshot was generated */
+        CHECK(messageSent.getCommand() == static_cast<int>(
+                HousekeepingMessage::UPDATE_SNAPSHOT_SET));
+        /* Now we deserialize the snapshot into a new dataset instance */
+        CCSDSTime::CDS_short cdsShort;
+        LocalPoolTestDataSet newSet;
+        HousekeepingSnapshot snapshot(&cdsShort, &newSet);
+        store_address_t storeId;
+        HousekeepingMessage::getUpdateSnapshotSetCommand(&messageSent, &storeId);
+        ConstAccessorPair accessorPair = tglob::getIpcStoreHandle()->getData(storeId);
+        REQUIRE(accessorPair.first == retval::CATCH_OK);
+        const uint8_t* readOnlyPtr = accessorPair.second.data();
+        size_t sizeToDeserialize = accessorPair.second.size();
+        CHECK(newSet.localPoolVarFloat.value == 0);
+        CHECK(newSet.localPoolVarUint8 == 0);
+        CHECK(newSet.localPoolUint16Vec.value[0] == 0);
+        CHECK(newSet.localPoolUint16Vec.value[1] == 0);
+        CHECK(newSet.localPoolUint16Vec.value[2] == 0);
+        /* Fill the dataset and timestamp */
+        REQUIRE(snapshot.deSerialize(&readOnlyPtr, &sizeToDeserialize,
+                SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+        /* Now we check that the snapshot is actually correct */
+        CHECK(newSet.localPoolVarFloat.value == Catch::Approx(-12.242));
+        CHECK(newSet.localPoolVarUint8 == 5);
+        CHECK(newSet.localPoolUint16Vec.value[0] == 2);
+        CHECK(newSet.localPoolUint16Vec.value[1] == 32);
+        CHECK(newSet.localPoolUint16Vec.value[2] == 42932);
 
+        /* Now we check that both times are equal */
+        CHECK(cdsShort.pField == timeCdsNow.pField);
+        CHECK(cdsShort.dayLSB == Catch::Approx(timeCdsNow.dayLSB).margin(1));
+        CHECK(cdsShort.dayMSB == Catch::Approx(timeCdsNow.dayMSB).margin(1));
+        CHECK(cdsShort.msDay_h == Catch::Approx(timeCdsNow.msDay_h).margin(1));
+        CHECK(cdsShort.msDay_hh == Catch::Approx(timeCdsNow.msDay_hh).margin(1));
+        CHECK(cdsShort.msDay_l == Catch::Approx(timeCdsNow.msDay_l).margin(1));
+        CHECK(cdsShort.msDay_ll == Catch::Approx(timeCdsNow.msDay_ll).margin(1));
     }
 
     SECTION("AdvancedTests") {
-
-        /* Subscribe for variable update as well */
-        REQUIRE(not poolOwner->dataset.hasChanged());
+        /* Subscribe for variable update */
         REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
                 retval::CATCH_OK);
         lp_var_t<uint8_t>* poolVar = dynamic_cast<lp_var_t<uint8_t>*>(
@@ -102,7 +155,6 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
         CHECK(messageSent.getCommand() == static_cast<int>(
                 HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
-
         /* Now subscribe for the dataset update (HK and update) again */
         REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
         REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
@@ -133,5 +185,10 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         REQUIRE(mqMock->receiveMessage(&messageSent) ==
                 static_cast<int>(MessageQueueIF::EMPTY));
     }
+
+    /* we need to reset the subscription list because the pool owner
+    is a global object. */
+    poolOwner->resetSubscriptionList();
+    mqMock->clearMessages(true);
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 353f7b4dd..876ae5f5b 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -20,33 +20,43 @@ static constexpr lp_id_t int64Vec2Id = 4;
 
 static constexpr uint32_t testSetId = 0;
 static constexpr uint8_t dataSetMaxVariables = 10;
-static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE,
-        testSetId);
+
+static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, testSetId);
+
+static const gp_id_t uint8VarGpid = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, uint8VarId);
+static const gp_id_t floatVarGpid = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, floatVarId);
+static const gp_id_t uint32Gpid = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, uint32VarId);
+static const gp_id_t uint16Vec3Gpid = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, uint16Vec3Id);
+static const gp_id_t uint64Vec2Id = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, int64Vec2Id);
 }
 
 
 class LocalPoolTestDataSet: public LocalDataSet {
 public:
+    LocalPoolTestDataSet():
+        LocalDataSet(lpool::testSid, lpool::dataSetMaxVariables) {
+    }
+
     LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
         LocalDataSet(owner, setId, lpool::dataSetMaxVariables) {
     }
 
-    ReturnValue_t assignPointers() {
-        PoolVariableIF** rawVarArray = getContainer();
-        localPoolVarUint8 = dynamic_cast<lp_var_t<uint8_t>*>(rawVarArray[0]);
-        localPoolVarFloat = dynamic_cast<lp_var_t<float>*>(rawVarArray[1]);
-        localPoolUint16Vec = dynamic_cast<lp_vec_t<uint16_t, 3>*>(
-                rawVarArray[2]);
-        if(localPoolVarUint8 == nullptr or  localPoolVarFloat == nullptr or
-                localPoolUint16Vec == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+//    ReturnValue_t assignPointers() {
+//        PoolVariableIF** rawVarArray = getContainer();
+//        localPoolVarUint8 = dynamic_cast<lp_var_t<uint8_t>*>(rawVarArray[0]);
+//        localPoolVarFloat = dynamic_cast<lp_var_t<float>*>(rawVarArray[1]);
+//        localPoolUint16Vec = dynamic_cast<lp_vec_t<uint16_t, 3>*>(
+//                rawVarArray[2]);
+//        if(localPoolVarUint8 == nullptr or  localPoolVarFloat == nullptr or
+//                localPoolUint16Vec == nullptr) {
+//            return HasReturnvaluesIF::RETURN_FAILED;
+//        }
+//        return HasReturnvaluesIF::RETURN_OK;
+//    }
 
-    lp_var_t<uint8_t>* localPoolVarUint8 = nullptr;
-    lp_var_t<float>* localPoolVarFloat = nullptr;
-    lp_vec_t<uint16_t, 3>* localPoolUint16Vec = nullptr;
+    lp_var_t<uint8_t> localPoolVarUint8 = lp_var_t<uint8_t>(lpool::uint8VarGpid, this);
+    lp_var_t<float> localPoolVarFloat = lp_var_t<float>(lpool::floatVarGpid, this);
+    lp_vec_t<uint16_t, 3> localPoolUint16Vec = lp_vec_t<uint16_t, 3>(lpool::uint16Vec3Gpid, this);
 
 private:
 };
@@ -170,7 +180,7 @@ public:
 
     ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) {
         return poolManager.subscribeForVariableUpdateMessages(localPoolId,
-                MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false);
+                MessageQueueIF::NO_QUEUE, objects::HK_RECEIVER_MOCK, false);
     }
 
     void resetSubscriptionList() {

From 0495f390ef1dcf32af5111b448804cbb239bdbdc Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 25 Jan 2021 00:58:19 +0100
Subject: [PATCH 1509/1774] small stuff

---
 datapoollocal/LocalDataPoolManager.h | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index a72641b08..f70474190 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -243,12 +243,9 @@ public:
         UPDATE_SNAPSHOT,
     };
 
-    /**
-     * Different data types are possible in the HK receiver map.
-     * For example, updates can be requested for full datasets or
-     * for single pool variables. Periodic reporting is only possible for
-     * data sets.
-     */
+    /** Different data types are possible in the HK receiver map. For example, updates can be
+    requested for full datasets or for single pool variables. Periodic reporting is only possible
+    for data sets. */
     enum class DataType: uint8_t {
     	LOCAL_POOL_VARIABLE,
 		DATA_SET
@@ -270,8 +267,8 @@ public:
     virtual LocalDataPoolManager* getHkManagerHandle() override;
 private:
     localpool::DataPool localPoolMap;
-    //! Every housekeeping data manager has a mutex to protect access
-    //! to it's data pool.
+    /** Every housekeeping data manager has a mutex to protect access
+    to it's data pool. */
     MutexIF* mutex = nullptr;
 
     /** The class which actually owns the manager (and its datapool). */

From 47402055f9f195ed04f94cec217b83879004bd4b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 25 Jan 2021 11:07:02 +0100
Subject: [PATCH 1510/1774] added doxy folder

---
 doc/doxy/.gitignore    |    3 +
 doc/doxy/OPUS.doxyfile | 2515 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 2518 insertions(+)
 create mode 100644 doc/doxy/.gitignore
 create mode 100644 doc/doxy/OPUS.doxyfile

diff --git a/doc/doxy/.gitignore b/doc/doxy/.gitignore
new file mode 100644
index 000000000..e9e9961d7
--- /dev/null
+++ b/doc/doxy/.gitignore
@@ -0,0 +1,3 @@
+html
+latex
+rtf
\ No newline at end of file
diff --git a/doc/doxy/OPUS.doxyfile b/doc/doxy/OPUS.doxyfile
new file mode 100644
index 000000000..e53032de6
--- /dev/null
+++ b/doc/doxy/OPUS.doxyfile
@@ -0,0 +1,2515 @@
+# Doxyfile 1.8.16
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the configuration
+# file that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
+# The default value is: UTF-8.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+# double-quotes, unless you are using Doxywizard) that should identify the
+# project for which the documentation is generated. This name is used in the
+# title of most generated pages and in a few other places.
+# The default value is: My Project.
+
+PROJECT_NAME           = "Flight Software Framework (FSFW) STS-1"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+# could be handy for archiving the generated documentation or if some version
+# control system is used.
+
+PROJECT_NUMBER         =
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer a
+# quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          =
+
+# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
+# in the documentation. The maximum height of the logo should not exceed 55
+# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
+# the logo to the output directory.
+
+PROJECT_LOGO           = ./SOURCEbadge.png
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+# into which the generated documentation will be written. If a relative path is
+# entered, it will be relative to the location where doxygen was started. If
+# left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = .
+
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
+# directories (in 2 levels) under the output directory of each output format and
+# will distribute the generated files over these directories. Enabling this
+# option can be useful when feeding doxygen a huge amount of source files, where
+# putting all generated files in the same directory would otherwise causes
+# performance problems for the file system.
+# The default value is: NO.
+
+CREATE_SUBDIRS         = NO
+
+# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
+# characters to appear in the names of generated files. If set to NO, non-ASCII
+# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
+# U+3044.
+# The default value is: NO.
+
+ALLOW_UNICODE_NAMES    = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
+# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
+# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
+# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
+# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
+# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
+# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
+# Ukrainian and Vietnamese.
+# The default value is: English.
+
+OUTPUT_LANGUAGE        = English
+
+# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all generated output in the proper direction.
+# Possible values are: None, LTR, RTL and Context.
+# The default value is: None.
+
+OUTPUT_TEXT_DIRECTION  = None
+
+# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
+# descriptions after the members that are listed in the file and class
+# documentation (similar to Javadoc). Set to NO to disable this.
+# The default value is: YES.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
+# description of a member or function before the detailed description
+#
+# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+# The default value is: YES.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator that is
+# used to form the text in various listings. Each string in this list, if found
+# as the leading text of the brief description, will be stripped from the text
+# and the result, after processing the whole list, is used as the annotated
+# text. Otherwise, the brief description is used as-is. If left blank, the
+# following values are used ($name is automatically replaced with the name of
+# the entity):The $name class, The $name widget, The $name file, is, provides,
+# specifies, contains, represents, a, an and the.
+
+ABBREVIATE_BRIEF       =
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# doxygen will generate a detailed section even if there is only a brief
+# description.
+# The default value is: NO.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+# The default value is: NO.
+
+INLINE_INHERITED_MEMB  = YES
+
+# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
+# before files name in the file list and in the header files. If set to NO the
+# shortest path that makes the file name unique will be used
+# The default value is: YES.
+
+FULL_PATH_NAMES        = YES
+
+# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+# Stripping is only done if one of the specified strings matches the left-hand
+# part of the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the path to
+# strip.
+#
+# Note that you can specify absolute paths here, but also relative paths, which
+# will be relative from the directory where doxygen is started.
+# This tag requires that the tag FULL_PATH_NAMES is set to YES.
+
+STRIP_FROM_PATH        = ../../
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+# path mentioned in the documentation of a class, which tells the reader which
+# header file to include in order to use a class. If left blank only the name of
+# the header file containing the class definition is used. Otherwise one should
+# specify the list of include paths that are normally passed to the compiler
+# using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+# less readable) file names. This can be useful is your file systems doesn't
+# support long names like on DOS, Mac, or CD-ROM.
+# The default value is: NO.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+# first line (until the first dot) of a Javadoc-style comment as the brief
+# description. If set to NO, the Javadoc-style will behave just like regular Qt-
+# style comments (thus requiring an explicit @brief command for a brief
+# description.)
+# The default value is: NO.
+
+JAVADOC_AUTOBRIEF      = YES
+
+# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
+# such as
+# /***************
+# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
+# Javadoc-style will behave just like regular comments and it will not be
+# interpreted by doxygen.
+# The default value is: NO.
+
+JAVADOC_BANNER         = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+# line (until the first dot) of a Qt-style comment as the brief description. If
+# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+# requiring an explicit \brief command for a brief description.)
+# The default value is: NO.
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
+# a brief description. This used to be the default behavior. The new default is
+# to treat a multi-line C++ comment block as a detailed description. Set this
+# tag to YES if you prefer the old behavior instead.
+#
+# Note that setting this tag to YES also means that rational rose comments are
+# not recognized any more.
+# The default value is: NO.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+# documentation from any documented member that it re-implements.
+# The default value is: YES.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
+# page for each member. If set to NO, the documentation of a member will be part
+# of the file/class/namespace that contains it.
+# The default value is: NO.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+# uses this value to replace tabs by spaces in code fragments.
+# Minimum value: 1, maximum value: 16, default value: 4.
+
+TAB_SIZE               = 8
+
+# This tag can be used to specify a number of aliases that act as commands in
+# the documentation. An alias has the form:
+# name=value
+# For example adding
+# "sideeffect=@par Side Effects:\n"
+# will allow you to put the command \sideeffect (or @sideeffect) in the
+# documentation, which will result in a user-defined paragraph with heading
+# "Side Effects:". You can put \n's in the value part of an alias to insert
+# newlines (in the resulting output). You can put ^^ in the value part of an
+# alias to insert a newline as if a physical newline was in the original file.
+# When you need a literal { or } or , in the value part of an alias you have to
+# escape them by means of a backslash (\), this can lead to conflicts with the
+# commands \{ and \} for these it is advised to use the version @{ and @} or use
+# a double escape (\\{ and \\})
+
+ALIASES                =
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding "class=itcl::class"
+# will allow you to use the command class in the itcl::class meaning.
+
+TCL_SUBST              =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+# only. Doxygen will then generate output that is more tailored for C. For
+# instance, some of the names that are used will be different. The list of all
+# members will be omitted, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+# Python sources only. Doxygen will then generate output that is more tailored
+# for that language. For instance, namespaces will be presented as packages,
+# qualified scopes will look different, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources. Doxygen will then generate output that is tailored for Fortran.
+# The default value is: NO.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for VHDL.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
+# sources only. Doxygen will then generate output that is more tailored for that
+# language. For instance, namespaces will be presented as modules, types will be
+# separated into more groups, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_SLICE  = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension, and
+# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
+# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice,
+# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
+# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
+# tries to guess whether the code is fixed or free formatted code, this is the
+# default for Fortran type files), VHDL, tcl. For instance to make doxygen treat
+# .inc files as Fortran files (default is PHP), and .f files as C (default is
+# Fortran), use: inc=Fortran f=C.
+#
+# Note: For files without extension you can use no_extension as a placeholder.
+#
+# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+# the files are not read by doxygen.
+
+EXTENSION_MAPPING      =
+
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
+# documentation. See https://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
+
+MARKDOWN_SUPPORT       = YES
+
+# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
+# to that level are automatically included in the table of contents, even if
+# they do not have an id attribute.
+# Note: This feature currently applies only to Markdown headings.
+# Minimum value: 0, maximum value: 99, default value: 5.
+# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
+
+TOC_INCLUDE_HEADINGS   = 0
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should set this
+# tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string);
+# versus func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+# The default value is: NO.
+
+BUILTIN_STL_SUPPORT    = YES
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+# The default value is: NO.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
+# will parse them like normal C++ but will assume all classes use public instead
+# of private inheritance when no explicit protection keyword is present.
+# The default value is: NO.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES will make
+# doxygen to replace the get and set methods by a property in the documentation.
+# This will only work if the methods are indeed getting or setting a simple
+# type. If this is not the case, or you want to show the methods anyway, you
+# should set this option to NO.
+# The default value is: YES.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+# The default value is: NO.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# If one adds a struct or class to a group and this option is enabled, then also
+# any nested class or struct is added to the same group. By default this option
+# is disabled and one has to add nested compounds explicitly via \ingroup.
+# The default value is: NO.
+
+GROUP_NESTED_COMPOUNDS = NO
+
+# Set the SUBGROUPING tag to YES to allow class member groups of the same type
+# (for instance a group of public functions) to be put as a subgroup of that
+# type (e.g. under the Public Functions section). Set it to NO to prevent
+# subgrouping. Alternatively, this can be done per class using the
+# \nosubgrouping command.
+# The default value is: YES.
+
+SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+# are shown inside the group in which they are included (e.g. using \ingroup)
+# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+# and RTF).
+#
+# Note that this feature does not work in combination with
+# SEPARATE_MEMBER_PAGES.
+# The default value is: NO.
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+# with only public data fields or simple typedef fields will be shown inline in
+# the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO, structs, classes, and unions are shown on a separate page (for HTML and
+# Man pages) or section (for LaTeX and RTF).
+# The default value is: NO.
+
+INLINE_SIMPLE_STRUCTS  = NO
+
+# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+# enum is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically be
+# useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+# The default value is: NO.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can be
+# an expensive process and often the same symbol appears multiple times in the
+# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+# doxygen will become slower. If the cache is too large, memory is wasted. The
+# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+# symbols. At the end of a run doxygen will report the cache usage and suggest
+# the optimal cache size from a speed point of view.
+# Minimum value: 0, maximum value: 9, default value: 0.
+
+LOOKUP_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
+# documentation are documented, even if no documentation was available. Private
+# class members and static file members will be hidden unless the
+# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+# Note: This will also disable the warnings about undocumented members that are
+# normally produced when WARNINGS is set to YES.
+# The default value is: NO.
+
+EXTRACT_ALL            = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
+# be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIVATE        = YES
+
+# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
+# methods of a class will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIV_VIRTUAL   = NO
+
+# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
+# scope will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PACKAGE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
+# included in the documentation.
+# The default value is: NO.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO,
+# only classes defined in header files are included. Does not have any effect
+# for Java sources.
+# The default value is: YES.
+
+EXTRACT_LOCAL_CLASSES  = NO
+
+# This flag is only useful for Objective-C code. If set to YES, local methods,
+# which are defined in the implementation section but not in the interface are
+# included in the documentation. If set to NO, only methods in the interface are
+# included.
+# The default value is: NO.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base name of
+# the file that contains the anonymous namespace. By default anonymous namespace
+# are hidden.
+# The default value is: NO.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+# undocumented members inside documented classes or files. If set to NO these
+# members will be included in the various overviews, but no documentation
+# section is generated. This option has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy. If set
+# to NO, these classes will be included in the various overviews. This option
+# has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# (class|struct|union) declarations. If set to NO, these declarations will be
+# included in the documentation.
+# The default value is: NO.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+# documentation blocks found inside the body of a function. If set to NO, these
+# blocks will be appended to the function's detailed documentation block.
+# The default value is: NO.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation that is typed after a
+# \internal command is included. If the tag is set to NO then the documentation
+# will be excluded. Set it to YES to include the internal documentation.
+# The default value is: NO.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+# names in lower-case letters. If set to YES, upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# (including Cygwin) ands Mac users are advised to set this option to NO.
+# The default value is: system dependent.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+# their full class and namespace scopes in the documentation. If set to YES, the
+# scope will be hidden.
+# The default value is: NO.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
+# append additional text to a page's title, such as Class Reference. If set to
+# YES the compound reference will be hidden.
+# The default value is: NO.
+
+HIDE_COMPOUND_REFERENCE= NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+# the files that are included by a file in the documentation of that file.
+# The default value is: YES.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+# grouped member an include statement to the documentation, telling the reader
+# which file to include in order to use the member.
+# The default value is: NO.
+
+SHOW_GROUPED_MEMB_INC  = NO
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+# files with double quotes in the documentation rather than with sharp brackets.
+# The default value is: NO.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+# documentation for inline members.
+# The default value is: YES.
+
+INLINE_INFO            = NO
+
+# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+# (detailed) documentation of file and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order.
+# The default value is: YES.
+
+SORT_MEMBER_DOCS       = NO
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+# descriptions of file, namespace and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order. Note that
+# this will also influence the order of the classes in the class list.
+# The default value is: NO.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+# (brief and detailed) documentation of class members so that constructors and
+# destructors are listed first. If set to NO the constructors will appear in the
+# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+# member documentation.
+# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+# detailed member documentation.
+# The default value is: NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+# of group names into alphabetical order. If set to NO the group names will
+# appear in their defined order.
+# The default value is: NO.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+# fully-qualified names, including namespaces. If set to NO, the class list will
+# be sorted only by class name, not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the alphabetical
+# list.
+# The default value is: NO.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+# type resolution of all parameters of a function it will reject a match between
+# the prototype and the implementation of a member function even if there is
+# only one candidate or it is obvious which candidate to choose by doing a
+# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+# accept a match between prototype and implementation in such cases.
+# The default value is: NO.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
+# list. This list is created by putting \todo commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
+# list. This list is created by putting \test commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
+# list. This list is created by putting \bug commands in the documentation.
+# The default value is: YES.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
+# the deprecated list. This list is created by putting \deprecated commands in
+# the documentation.
+# The default value is: YES.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional documentation
+# sections, marked by \if <section_label> ... \endif and \cond <section_label>
+# ... \endcond blocks.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+# initial value of a variable or macro / define can have for it to appear in the
+# documentation. If the initializer consists of more lines than specified here
+# it will be hidden. Use a value of 0 to hide initializers completely. The
+# appearance of the value of individual variables and macros / defines can be
+# controlled using \showinitializer or \hideinitializer command in the
+# documentation regardless of this setting.
+# Minimum value: 0, maximum value: 10000, default value: 30.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+# the bottom of the documentation of classes and structs. If set to YES, the
+# list will mention the files that were used to generate the documentation.
+# The default value is: YES.
+
+SHOW_USED_FILES        = NO
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+# will remove the Files entry from the Quick Index and from the Folder Tree View
+# (if specified).
+# The default value is: YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+# page. This will remove the Namespaces entry from the Quick Index and from the
+# Folder Tree View (if specified).
+# The default value is: YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command command input-file, where command is the value of the
+# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+# by doxygen. Whatever the program writes to standard output is used as the file
+# version. For an example see the documentation.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option. You can
+# optionally specify a file name after the option, if omitted DoxygenLayout.xml
+# will be used as the name of the layout file.
+#
+# Note that if you run doxygen from a directory containing a file called
+# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+# tag is left empty.
+
+LAYOUT_FILE            = OPUSLayout.xml
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+# the reference definitions. This must be a list of .bib files. The .bib
+# extension is automatically appended if omitted. This requires the bibtex tool
+# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
+# For LaTeX the style of the bibliography can be controlled using
+# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+# search path. See also \cite for info how to create references.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated to
+# standard output by doxygen. If QUIET is set to YES this implies that the
+# messages are off.
+# The default value is: NO.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
+# this implies that the warnings are on.
+#
+# Tip: Turn warnings on while writing the documentation.
+# The default value is: YES.
+
+WARNINGS               = YES
+
+# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
+# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: YES.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some parameters
+# in a documented function, or documenting parameters that don't exist or using
+# markup commands wrongly.
+# The default value is: YES.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+# are documented, but have no documentation for their parameters or return
+# value. If set to NO, doxygen will only warn about wrong or incomplete
+# parameter documentation, but not about the absence of documentation. If
+# EXTRACT_ALL is set to YES then this flag will automatically be disabled.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = NO
+
+# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
+# a warning is encountered.
+# The default value is: NO.
+
+WARN_AS_ERROR          = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that doxygen
+# can produce. The string should contain the $file, $line, and $text tags, which
+# will be replaced by the file and line number from which the warning originated
+# and the warning text. Optionally the format may contain $version, which will
+# be replaced by the version of the file (if it could be obtained via
+# FILE_VERSION_FILTER)
+# The default value is: $file:$line: $text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning and error
+# messages should be written. If left blank the output is written to standard
+# error (stderr).
+
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag is used to specify the files and/or directories that contain
+# documented source files. You may enter file names like myfile.cpp or
+# directories like /usr/src/myproject. Separate the files or directories with
+# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = ../../fsfw/ 
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+# documentation (see: https://www.gnu.org/software/libiconv/) for the list of
+# possible encodings.
+# The default value is: UTF-8.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+# *.h) to filter out the source-files in the directories.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# read by doxygen.
+#
+# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
+# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
+# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
+# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.pyw, *.f90, *.f95, *.f03, *.f08,
+# *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, *.qsf and *.ice.
+
+FILE_PATTERNS          = *.cpp \
+                         *.h \
+                         *.c
+
+# The RECURSIVE tag can be used to specify whether or not subdirectories should
+# be searched for input files as well.
+# The default value is: NO.
+
+RECURSIVE              = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+#
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE                =
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+# The default value is: NO.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories.
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories use the pattern */test/*
+
+EXCLUDE_SYMBOLS        =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or directories
+# that contain example code fragments that are included (see the \include
+# command).
+
+EXAMPLE_PATH           =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank all
+# files are included.
+
+EXAMPLE_PATTERNS       =
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude commands
+# irrespective of the value of the RECURSIVE tag.
+# The default value is: NO.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or directories
+# that contain images that are to be included in the documentation (see the
+# \image command).
+
+IMAGE_PATH             = ../uml
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command:
+#
+# <filter> <input-file>
+#
+# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+# name of an input file. Doxygen will then use the output that the filter
+# program writes to standard output. If FILTER_PATTERNS is specified, this tag
+# will be ignored.
+#
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+INPUT_FILTER           =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form: pattern=filter
+# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+# patterns match the file name, INPUT_FILTER is applied.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+FILTER_PATTERNS        =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will also be used to filter the input files that are used for
+# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# The default value is: NO.
+
+FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+# it is also possible to disable source filtering for a specific pattern using
+# *.ext= (so without naming a filter).
+# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want to reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE =
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+# generated. Documented entities will be cross-referenced with these sources.
+#
+# Note: To get rid of all source code in the generated output, make sure that
+# also VERBATIM_HEADERS is set to NO.
+# The default value is: NO.
+
+SOURCE_BROWSER         = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body of functions,
+# classes and enums directly into the documentation.
+# The default value is: NO.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+# special comment blocks from generated source code fragments. Normal C, C++ and
+# Fortran comments will always remain visible.
+# The default value is: YES.
+
+STRIP_CODE_COMMENTS    = NO
+
+# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+# entity all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES then for each documented function
+# all documented entities called/used by that function will be listed.
+# The default value is: NO.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+# to YES then the hyperlinks from functions in REFERENCES_RELATION and
+# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+# link to the documentation.
+# The default value is: YES.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+# source code will show a tooltip with additional information such as prototype,
+# brief description and links to the definition and documentation. Since this
+# will make the HTML file larger and loading of large files a bit slower, you
+# can opt to disable this feature.
+# The default value is: YES.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+SOURCE_TOOLTIPS        = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code will
+# point to the HTML generated by the htags(1) tool instead of doxygen built-in
+# source browser. The htags tool is part of GNU's global source tagging system
+# (see https://www.gnu.org/software/global/global.html). You will need version
+# 4.8.6 or higher.
+#
+# To use it do the following:
+# - Install the latest version of global
+# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
+# - Make sure the INPUT points to the root of the source tree
+# - Run doxygen as normal
+#
+# Doxygen will invoke htags (and that will in turn invoke gtags), so these
+# tools must be available from the command line (i.e. in the search path).
+#
+# The result: instead of the source browser generated by doxygen, the links to
+# source code will now point to the output of htags.
+# The default value is: NO.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+# verbatim copy of the header file for each class for which an include is
+# specified. Set to NO to disable this.
+# See also: Section \class.
+# The default value is: YES.
+
+VERBATIM_HEADERS       = YES
+
+# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
+# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
+# cost of reduced performance. This can be particularly helpful with template
+# rich C++ code for which doxygen's built-in parser lacks the necessary type
+# information.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+# The default value is: NO.
+
+CLANG_ASSISTED_PARSING = NO
+
+# If clang assisted parsing is enabled you can provide the compiler with command
+# line options that you would normally use when invoking the compiler. Note that
+# the include paths will already be set by doxygen for the files and directories
+# specified with INPUT and INCLUDE_PATH.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_OPTIONS          =
+
+# If clang assisted parsing is enabled you can provide the clang parser with the
+# path to the compilation database (see:
+# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) used when the files
+# were built. This is equivalent to specifying the "-p" option to a clang tool,
+# such as clang-check. These options will then be passed to the parser.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+
+CLANG_DATABASE_PATH    =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+# compounds will be generated. Enable this if the project contains a lot of
+# classes, structs, unions or interfaces.
+# The default value is: YES.
+
+ALPHABETICAL_INDEX     = NO
+
+# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
+# which the alphabetical index list will be split.
+# Minimum value: 1, maximum value: 20, default value: 5.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
+# The default value is: YES.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+# generated HTML page (for example: .htm, .php, .asp).
+# The default value is: .html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+# each generated HTML page. If the tag is left blank doxygen will generate a
+# standard header.
+#
+# To get valid HTML the header file that includes any scripts and style sheets
+# that doxygen needs, which is dependent on the configuration options used (e.g.
+# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+# default header using
+# doxygen -w html new_header.html new_footer.html new_stylesheet.css
+# YourConfigFile
+# and then modify the file new_header.html. See also section "Doxygen usage"
+# for information on how to generate the default header that doxygen normally
+# uses.
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. For a description
+# of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+# generated HTML page. If the tag is left blank doxygen will generate a standard
+# footer. See HTML_HEADER for more information on how to generate a default
+# footer and what special commands can be used inside the footer. See also
+# section "Doxygen usage" for information on how to generate the default footer
+# that doxygen normally uses.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+# sheet that is used by each HTML page. It can be used to fine-tune the look of
+# the HTML output. If left blank doxygen will generate a default style sheet.
+# See also section "Doxygen usage" for information on how to generate the style
+# sheet that doxygen normally uses.
+# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+# it is more robust and this tag (HTML_STYLESHEET) will in the future become
+# obsolete.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# cascading style sheets that are included after the standard style sheets
+# created by doxygen. Using this option one can overrule certain style aspects.
+# This is preferred over using HTML_STYLESHEET since it does not replace the
+# standard style sheet and is therefore more robust against future updates.
+# Doxygen will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list). For an example see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+# files will be copied as-is; there are no commands or markers available.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+# will adjust the colors in the style sheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+# purple, and 360 is red again.
+# Minimum value: 0, maximum value: 359, default value: 220.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+# in the HTML output. For a value of 0 the output will use grayscales only. A
+# value of 255 will produce the most vivid colors.
+# Minimum value: 0, maximum value: 255, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+# luminance component of the colors in the HTML output. Values below 100
+# gradually make the output lighter, whereas values above 100 make the output
+# darker. The value divided by 100 is the actual gamma applied, so 80 represents
+# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+# change the gamma.
+# Minimum value: 40, maximum value: 240, default value: 80.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to YES can help to show when doxygen was last run and thus if the
+# documentation is up to date.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = YES
+
+# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
+# documentation will contain a main index with vertical navigation menus that
+# are dynamically created via Javascript. If disabled, the navigation index will
+# consists of multiple levels of tabs that are statically embedded in every HTML
+# page. Disable this option to support browsers that do not have Javascript,
+# like the Qt help browser.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_MENUS     = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+# shown in the various tree structured indices initially; the user can expand
+# and collapse entries dynamically later on. Doxygen will expand the tree to
+# such a level that at most the specified number of entries are visible (unless
+# a fully collapsed tree already exceeds this amount). So setting the number of
+# entries 1 will produce a full collapsed tree by default. 0 is a special value
+# representing an infinite number of entries and will result in a full expanded
+# tree by default.
+# Minimum value: 0, maximum value: 9999, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_INDEX_NUM_ENTRIES = 100
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files will be
+# generated that can be used as input for Apple's Xcode 3 integrated development
+# environment (see: https://developer.apple.com/xcode/), introduced with OSX
+# 10.5 (Leopard). To create a documentation set, doxygen will generate a
+# Makefile in the HTML output directory. Running make will produce the docset in
+# that directory and running make install will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
+# genXcode/_index.html for more information.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_DOCSET        = NO
+
+# This tag determines the name of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# The default value is: Doxygen generated docs.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# This tag specifies a string that should uniquely identify the documentation
+# set bundle. This should be a reverse domain-name style string, e.g.
+# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+# The default value is: org.doxygen.Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+# The default value is: Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+# (see: https://www.microsoft.com/en-us/download/details.aspx?id=21138) on
+# Windows.
+#
+# The HTML Help Workshop contains a compiler that can convert all HTML output
+# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+# files are now used as the Windows 98 help format, and will replace the old
+# Windows help format (.hlp) on all Windows platforms in the future. Compressed
+# HTML files also contain an index, a table of contents, and you can search for
+# words in the documentation. The HTML workshop also contains a viewer for
+# compressed HTML files.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_HTMLHELP      = NO
+
+# The CHM_FILE tag can be used to specify the file name of the resulting .chm
+# file. You can add a path in front of the file if the result should not be
+# written to the html output directory.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_FILE               =
+
+# The HHC_LOCATION tag can be used to specify the location (absolute path
+# including file name) of the HTML help compiler (hhc.exe). If non-empty,
+# doxygen will try to run the HTML help compiler on the generated index.hhp.
+# The file has to be specified with full path.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+HHC_LOCATION           =
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated
+# (YES) or that it should be included in the master .chm file (NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = NO
+
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
+# and project file content.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_INDEX_ENCODING     =
+
+# The BINARY_TOC flag controls whether a binary table of contents is generated
+# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
+# enables the Previous and Next buttons.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members to
+# the table of contents of the HTML help documentation and to the tree view.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+# (.qch) of the generated HTML documentation.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+# the file name of the resulting .qch file. The path specified is relative to
+# the HTML output folder.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+# Project output. For more information please see Qt Help Project / Namespace
+# (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+# Help Project output. For more information please see Qt Help Project / Virtual
+# Folders (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-
+# folders).
+# The default value is: doc.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+# filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# The QHG_LOCATION tag can be used to specify the location of Qt's
+# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
+# generated .qhp file.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHG_LOCATION           =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+# generated, together with the HTML files, they form an Eclipse help plugin. To
+# install this plugin and make it available under the help contents menu in
+# Eclipse, the contents of the directory containing the HTML and XML files needs
+# to be copied into the plugins directory of eclipse. The name of the directory
+# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+# After copying Eclipse needs to be restarted before the help appears.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the Eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have this
+# name. Each documentation set should have its own identifier.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# If you want full control over the layout of the generated HTML pages it might
+# be necessary to disable the index and replace it with your own. The
+# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+# of each HTML page. A value of NO enables the index and the value YES disables
+# it. Since the tabs in the index contain the same information as the navigation
+# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+DISABLE_INDEX          = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information. If the tag
+# value is set to YES, a side panel will be generated containing a tree-like
+# index structure (just like the one that is generated for HTML Help). For this
+# to work a browser that supports JavaScript, DHTML, CSS and frames is required
+# (i.e. any modern browser). Windows users are probably better off using the
+# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
+# further fine-tune the look of the index. As an example, the default style
+# sheet generated by doxygen has an example that shows how to put an image at
+# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
+# the same information as the tab index, you could consider setting
+# DISABLE_INDEX to YES when enabling this option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_TREEVIEW      = YES
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+# doxygen will group on one line in the generated HTML documentation.
+#
+# Note that a value of 0 will completely suppress the enum values from appearing
+# in the overview section.
+# Minimum value: 0, maximum value: 20, default value: 4.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+# to set the initial width (in pixels) of the frame in which the tree is shown.
+# Minimum value: 0, maximum value: 1500, default value: 250.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+TREEVIEW_WIDTH         = 250
+
+# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
+# external symbols imported via tag files in a separate window.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# Use this tag to change the font size of LaTeX formulas included as images in
+# the HTML documentation. When you change the font size after a successful
+# doxygen run you need to manually remove any form_*.png images from the HTML
+# output directory to force them to be regenerated.
+# Minimum value: 8, maximum value: 50, default value: 10.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# https://www.mathjax.org) which uses client side Javascript for the rendering
+# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
+# installed or if you want to formulas look prettier in the HTML output. When
+# enabled you may also need to install MathJax separately and configure the path
+# to it using the MATHJAX_RELPATH option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. See the MathJax site (see:
+# http://docs.mathjax.org/en/latest/output.html) for more details.
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility), NativeMML (i.e. MathML) and SVG.
+# The default value is: HTML-CSS.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the HTML
+# output directory using the MATHJAX_RELPATH option. The destination directory
+# should contain the MathJax.js script. For instance, if the mathjax directory
+# is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
+# Content Delivery Network so you can quickly see the result without installing
+# MathJax. However, it is strongly recommended to install a local copy of
+# MathJax from https://www.mathjax.org before deployment.
+# The default value is: https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+# of code that will be used on startup of the MathJax code. See the MathJax site
+# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# example see the documentation.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+# the HTML output. The underlying search engine uses javascript and DHTML and
+# should work on any modern browser. Note that when using HTML help
+# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+# there is already a search function so this one should typically be disabled.
+# For large projects the javascript based search engine can be slow, then
+# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+# search using the keyboard; to jump to the search box use <access key> + S
+# (what the <access key> is depends on the OS and browser, but it is typically
+# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+# key> to jump into the search results window, the results can be navigated
+# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+# the search. The filter options can be selected when the cursor is inside the
+# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+# to select a filter and <Enter> or <escape> to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using Javascript. There
+# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+# setting. When disabled, doxygen will generate a PHP script for searching and
+# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+# and searching needs to be provided by external tools. See the section
+# "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SERVER_BASED_SEARCH    = NO
+
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: https://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: https://xapian.org/). See the section "External Indexing and
+# Searching" for details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
+# The default value is: YES.
+
+GENERATE_LATEX         = YES
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked.
+#
+# Note that when not enabling USE_PDFLATEX the default is latex when enabling
+# USE_PDFLATEX the default is pdflatex and when in the later case latex is
+# chosen this is overwritten by pdflatex. For specific output languages the
+# default can have been set differently, this depends on the implementation of
+# the output language.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# Note: This tag is used in the Makefile / make.bat.
+# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
+# (.tex).
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
+# generate index for LaTeX. In case there is no backslash (\) as first character
+# it will be automatically added in the LaTeX code.
+# Note: This tag is used in the generated output file (.tex).
+# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
+# The default value is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_MAKEINDEX_CMD    = \makeindex
+
+# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. The package can be specified just
+# by its name or with the correct syntax as to be used with the LaTeX
+# \usepackage command. To get the times font for instance you can specify :
+# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+# To use the option intlimits with the amsmath package you can specify:
+# EXTRA_PACKAGES=[intlimits]{amsmath}
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+EXTRA_PACKAGES         =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+# generated LaTeX document. The header should contain everything until the first
+# chapter. If it is left blank doxygen will generate a standard header. See
+# section "Doxygen usage" for information on how to let doxygen write the
+# default header to a separate file.
+#
+# Note: Only use a user-defined header if you know what you are doing! The
+# following commands have a special meaning inside the header: $title,
+# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
+# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
+# string, for the replacement values of the other commands the user is referred
+# to HTML_HEADER.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+# generated LaTeX document. The footer should contain everything after the last
+# chapter. If it is left blank doxygen will generate a standard footer. See
+# LATEX_HEADER for more information on how to generate a default footer and what
+# special commands can be used inside the footer.
+#
+# Note: Only use a user-defined footer if you know what you are doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# LaTeX style sheets that are included after the standard style sheets created
+# by doxygen. Using this option one can overrule certain style aspects. Doxygen
+# will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list).
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_STYLESHEET =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_FILES      =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+# the PDF file directly from the LaTeX files. Set this option to YES, to get a
+# higher quality PDF documentation.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help. This option is also used
+# when generating formulas in HTML.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BATCHMODE        = NO
+
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HIDE_INDICES     = NO
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BIB_STYLE        = plain
+
+# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_TIMESTAMP        = NO
+
+# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
+# path from which the emoji images will be read. If a relative path is entered,
+# it will be relative to the LATEX_OUTPUT directory. If left blank the
+# LATEX_OUTPUT directory will be used.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EMOJI_DIRECTORY  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# configuration file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's configuration file. A template extensions file can be
+# generated using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_EXTENSIONS_FILE    =
+
+# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
+# with syntax highlighting in the RTF output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_SOURCE_CODE        = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_EXTENSION          = .3
+
+# The MAN_SUBDIR tag determines the name of the directory created within
+# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+# MAN_EXTENSION with the initial . removed.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_SUBDIR             =
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: xml.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_OUTPUT             = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
+# listings (including syntax highlighting and cross-referencing information) to
+# the XML output. Note that enabling this will significantly increase the size
+# of the XML output.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_PROGRAMLISTING     = YES
+
+# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
+# namespace members in file scope as well, matching the HTML output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_NS_MEMB_FILE_SCOPE = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
+# that can be used to generate PDF.
+# The default value is: NO.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it.
+# The default directory is: docbook.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_OUTPUT         = docbook
+
+# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
+# program listings (including syntax highlighting and cross-referencing
+# information) to the DOCBOOK output. Note that enabling this will significantly
+# increase the size of the DOCBOOK output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_PROGRAMLISTING = NO
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
+# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
+# the structure of the code including all documentation. Note that this feature
+# is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
+# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+# output from the Perl module output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
+# formatted so it can be parsed by a human reader. This is useful if you want to
+# understand what is going on. On the other hand, if this tag is set to NO, the
+# size of the Perl module output will be much smaller and Perl will parse it
+# just the same.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file are
+# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+# so different doxyrules.make files included by the same Makefile don't
+# overwrite each other's variables.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
+# in the source code. If set to NO, only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES, the include files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by the
+# preprocessor.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
+INCLUDE_PATH           =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+PREDEFINED             =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have
+# an all uppercase name, and do not end with a semicolon. Such function macros
+# are typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have a unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
+# the class index. If set to NO, only the inherited external classes will be
+# listed.
+# The default value is: NO.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
+
+EXTERNAL_GROUPS        = YES
+
+# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
+
+EXTERNAL_PAGES         = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = YES
+
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
+# If set to YES the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz (see:
+# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: NO.
+
+HAVE_DOT               = YES
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NUM_THREADS        = 0
+
+# When you want a differently looking font in the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = FreeSans
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+# each documented class showing the direct and indirect inheritance relations.
+# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LOOK               = YES
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+TEMPLATE_RELATIONS     = YES
+
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDE_GRAPH          = YES
+
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command. Disabling a call graph can be
+# accomplished by means of the command \hidecallgraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALL_GRAPH             = YES
+
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command. Disabling a caller graph can be
+# accomplished by means of the command \hidecallergraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = YES
+
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. For an explanation of the image formats see the section
+# output formats in the documentation of the dot tool (Graphviz (see:
+# http://www.graphviz.org/)).
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
+# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# png:gdiplus:gdiplus.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_IMAGE_FORMAT       = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG        = NO
+
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
+
+MSCFILE_DIRS           =
+
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS           =
+
+# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+# path where java can find the plantuml.jar file. If left blank, it is assumed
+# PlantUML is not used or called during a preprocessing step. Doxygen will
+# generate a warning when it encounters a \startuml command in this case and
+# will not generate output for the diagram.
+
+PLANTUML_JAR_PATH      =
+
+# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
+# configuration file for plantuml.
+
+PLANTUML_CFG_FILE      =
+
+# When using plantuml, the specified paths are searched for files specified by
+# the !include statement in a plantuml block.
+
+PLANTUML_INCLUDE_PATH  =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = YES
+
+# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+# files that are used to generate the various graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_CLEANUP            = YES

From ef93c70665012393d800052af807b4a861678472 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 25 Jan 2021 11:16:30 +0100
Subject: [PATCH 1511/1774] updated doxyfiles

---
 doc/doxy/OPUS.doxyfile | 264 ++++++++++++++++++++++++++++-------------
 1 file changed, 179 insertions(+), 85 deletions(-)

diff --git a/doc/doxy/OPUS.doxyfile b/doc/doxy/OPUS.doxyfile
index e53032de6..f43b06058 100644
--- a/doc/doxy/OPUS.doxyfile
+++ b/doc/doxy/OPUS.doxyfile
@@ -1,4 +1,4 @@
-# Doxyfile 1.8.16
+# Doxyfile 1.9.1
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
@@ -51,7 +51,7 @@ PROJECT_BRIEF          =
 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
 # the logo to the output directory.
 
-PROJECT_LOGO           = ./SOURCEbadge.png
+PROJECT_LOGO           = C:/Users/Robin/Documents/FSFW/fsfw_tests/fsfw/logo/FSFW_Logo_V3_bw.png
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
 # into which the generated documentation will be written. If a relative path is
@@ -217,6 +217,14 @@ QT_AUTOBRIEF           = NO
 
 MULTILINE_CPP_IS_BRIEF = NO
 
+# By default Python docstrings are displayed as preformatted text and doxygen's
+# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the
+# doxygen's special commands can be used and the contents of the docstring
+# documentation blocks is shown as doxygen documentation.
+# The default value is: YES.
+
+PYTHON_DOCSTRING       = YES
+
 # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
 # documentation from any documented member that it re-implements.
 # The default value is: YES.
@@ -253,12 +261,6 @@ TAB_SIZE               = 8
 
 ALIASES                =
 
-# This tag can be used to specify a number of word-keyword mappings (TCL only).
-# A mapping has the form "name=value". For example adding "class=itcl::class"
-# will allow you to use the command class in the itcl::class meaning.
-
-TCL_SUBST              =
-
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
 # only. Doxygen will then generate output that is more tailored for C. For
 # instance, some of the names that are used will be different. The list of all
@@ -299,19 +301,22 @@ OPTIMIZE_OUTPUT_SLICE  = NO
 # parses. With this tag you can assign which parser to use for a given
 # extension. Doxygen has a built-in mapping, but you can override or extend it
 # using this tag. The format is ext=language, where ext is a file extension, and
-# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
-# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice,
+# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
+# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, VHDL,
 # Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
 # FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
 # tries to guess whether the code is fixed or free formatted code, this is the
-# default for Fortran type files), VHDL, tcl. For instance to make doxygen treat
-# .inc files as Fortran files (default is PHP), and .f files as C (default is
-# Fortran), use: inc=Fortran f=C.
+# default for Fortran type files). For instance to make doxygen treat .inc files
+# as Fortran files (default is PHP), and .f files as C (default is Fortran),
+# use: inc=Fortran f=C.
 #
 # Note: For files without extension you can use no_extension as a placeholder.
 #
 # Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen.
+# the files are not read by doxygen. When specifying no_extension you should add
+# * to the FILE_PATTERNS.
+#
+# Note see also the list of default file extension mappings.
 
 EXTENSION_MAPPING      =
 
@@ -445,6 +450,19 @@ TYPEDEF_HIDES_STRUCT   = NO
 
 LOOKUP_CACHE_SIZE      = 0
 
+# The NUM_PROC_THREADS specifies the number threads doxygen is allowed to use
+# during processing. When set to 0 doxygen will based this on the number of
+# cores available in the system. You can set it explicitly to a value larger
+# than 0 to get more control over the balance between CPU load and processing
+# speed. At this moment only the input processing can be done using multiple
+# threads. Since this is still an experimental feature the default is set to 1,
+# which efficively disables parallel processing. Please report any issues you
+# encounter. Generating dot graphs in parallel is controlled by the
+# DOT_NUM_THREADS setting.
+# Minimum value: 0, maximum value: 32, default value: 1.
+
+NUM_PROC_THREADS       = 1
+
 #---------------------------------------------------------------------------
 # Build related configuration options
 #---------------------------------------------------------------------------
@@ -463,7 +481,7 @@ EXTRACT_ALL            = NO
 # be included in the documentation.
 # The default value is: NO.
 
-EXTRACT_PRIVATE        = YES
+EXTRACT_PRIVATE        = NO
 
 # If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
 # methods of a class will be included in the documentation.
@@ -481,7 +499,7 @@ EXTRACT_PACKAGE        = NO
 # included in the documentation.
 # The default value is: NO.
 
-EXTRACT_STATIC         = YES
+EXTRACT_STATIC         = NO
 
 # If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
 # locally in source files will be included in the documentation. If set to NO,
@@ -489,7 +507,7 @@ EXTRACT_STATIC         = YES
 # for Java sources.
 # The default value is: YES.
 
-EXTRACT_LOCAL_CLASSES  = NO
+EXTRACT_LOCAL_CLASSES  = YES
 
 # This flag is only useful for Objective-C code. If set to YES, local methods,
 # which are defined in the implementation section but not in the interface are
@@ -508,6 +526,13 @@ EXTRACT_LOCAL_METHODS  = NO
 
 EXTRACT_ANON_NSPACES   = NO
 
+# If this flag is set to YES, the name of an unnamed parameter in a declaration
+# will be determined by the corresponding definition. By default unnamed
+# parameters remain unnamed in the output.
+# The default value is: YES.
+
+RESOLVE_UNNAMED_PARAMS = YES
+
 # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
 # undocumented members inside documented classes or files. If set to NO these
 # members will be included in the various overviews, but no documentation
@@ -525,8 +550,8 @@ HIDE_UNDOC_MEMBERS     = NO
 HIDE_UNDOC_CLASSES     = NO
 
 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# (class|struct|union) declarations. If set to NO, these declarations will be
-# included in the documentation.
+# declarations. If set to NO, these declarations will be included in the
+# documentation.
 # The default value is: NO.
 
 HIDE_FRIEND_COMPOUNDS  = NO
@@ -545,14 +570,21 @@ HIDE_IN_BODY_DOCS      = NO
 
 INTERNAL_DOCS          = NO
 
-# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
-# names in lower-case letters. If set to YES, upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# (including Cygwin) ands Mac users are advised to set this option to NO.
+# With the correct setting of option CASE_SENSE_NAMES doxygen will better be
+# able to match the capabilities of the underlying filesystem. In case the
+# filesystem is case sensitive (i.e. it supports files in the same directory
+# whose names only differ in casing), the option must be set to YES to properly
+# deal with such files in case they appear in the input. For filesystems that
+# are not case sensitive the option should be be set to NO to properly deal with
+# output files written for symbols that only differ in casing, such as for two
+# classes, one named CLASS and the other named Class, and to also support
+# references to files without having to specify the exact matching casing. On
+# Windows (including Cygwin) and MacOS, users should typically set this option
+# to NO, whereas on Linux or other Unix flavors it should typically be set to
+# YES.
 # The default value is: system dependent.
 
-CASE_SENSE_NAMES       = YES
+CASE_SENSE_NAMES       = NO
 
 # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
 # their full class and namespace scopes in the documentation. If set to YES, the
@@ -591,7 +623,7 @@ FORCE_LOCAL_INCLUDES   = NO
 # documentation for inline members.
 # The default value is: YES.
 
-INLINE_INFO            = NO
+INLINE_INFO            = YES
 
 # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
 # (detailed) documentation of file and class members alphabetically by member
@@ -788,7 +820,10 @@ WARN_IF_DOC_ERROR      = YES
 WARN_NO_PARAMDOC       = NO
 
 # If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
-# a warning is encountered.
+# a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
+# then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
+# at the end of the doxygen process doxygen will return with a non-zero status.
+# Possible values are: NO, YES and FAIL_ON_WARNINGS.
 # The default value is: NO.
 
 WARN_AS_ERROR          = NO
@@ -819,13 +854,13 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = ../../fsfw/ 
+INPUT                  = ../../
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
 # libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see: https://www.gnu.org/software/libiconv/) for the list of
-# possible encodings.
+# documentation (see:
+# https://www.gnu.org/software/libiconv/) for the list of possible encodings.
 # The default value is: UTF-8.
 
 INPUT_ENCODING         = UTF-8
@@ -838,15 +873,20 @@ INPUT_ENCODING         = UTF-8
 # need to set EXTENSION_MAPPING for the extension otherwise the files are not
 # read by doxygen.
 #
+# Note the list of default checked file patterns might differ from the list of
+# default file extension mappings.
+#
 # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
 # *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
 # *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
-# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.pyw, *.f90, *.f95, *.f03, *.f08,
-# *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, *.qsf and *.ice.
+# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment),
+# *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd, *.vhdl,
+# *.ucf, *.qsf and *.ice.
 
 FILE_PATTERNS          = *.cpp \
                          *.h \
-                         *.c
+                         *.c \
+                         *.tpp
 
 # The RECURSIVE tag can be used to specify whether or not subdirectories should
 # be searched for input files as well.
@@ -996,7 +1036,7 @@ INLINE_SOURCES         = NO
 # Fortran comments will always remain visible.
 # The default value is: YES.
 
-STRIP_CODE_COMMENTS    = NO
+STRIP_CODE_COMMENTS    = YES
 
 # If the REFERENCED_BY_RELATION tag is set to YES then for each documented
 # entity all documented functions referencing it will be listed.
@@ -1059,16 +1099,22 @@ USE_HTAGS              = NO
 VERBATIM_HEADERS       = YES
 
 # If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
-# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
-# cost of reduced performance. This can be particularly helpful with template
-# rich C++ code for which doxygen's built-in parser lacks the necessary type
-# information.
+# clang parser (see:
+# http://clang.llvm.org/) for more accurate parsing at the cost of reduced
+# performance. This can be particularly helpful with template rich C++ code for
+# which doxygen's built-in parser lacks the necessary type information.
 # Note: The availability of this option depends on whether or not doxygen was
 # generated with the -Duse_libclang=ON option for CMake.
 # The default value is: NO.
 
 CLANG_ASSISTED_PARSING = NO
 
+# If clang assisted parsing is enabled and the CLANG_ADD_INC_PATHS tag is set to
+# YES then doxygen will add the directory of each input to the include path.
+# The default value is: YES.
+
+CLANG_ADD_INC_PATHS    = YES
+
 # If clang assisted parsing is enabled you can provide the compiler with command
 # line options that you would normally use when invoking the compiler. Note that
 # the include paths will already be set by doxygen for the files and directories
@@ -1078,10 +1124,13 @@ CLANG_ASSISTED_PARSING = NO
 CLANG_OPTIONS          =
 
 # If clang assisted parsing is enabled you can provide the clang parser with the
-# path to the compilation database (see:
-# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) used when the files
-# were built. This is equivalent to specifying the "-p" option to a clang tool,
-# such as clang-check. These options will then be passed to the parser.
+# path to the directory containing a file called compile_commands.json. This
+# file is the compilation database (see:
+# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) containing the
+# options used when the source files were built. This is equivalent to
+# specifying the -p option to a clang tool, such as clang-check. These options
+# will then be passed to the parser. Any options specified with CLANG_OPTIONS
+# will be added as well.
 # Note: The availability of this option depends on whether or not doxygen was
 # generated with the -Duse_libclang=ON option for CMake.
 
@@ -1098,13 +1147,6 @@ CLANG_DATABASE_PATH    =
 
 ALPHABETICAL_INDEX     = NO
 
-# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
-# which the alphabetical index list will be split.
-# Minimum value: 1, maximum value: 20, default value: 5.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-COLS_IN_ALPHA_INDEX    = 5
-
 # In case all classes in a project start with a common prefix, all classes will
 # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
 # can be used to specify a prefix (or a list of prefixes) that should be ignored
@@ -1243,9 +1285,9 @@ HTML_TIMESTAMP         = YES
 
 # If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
 # documentation will contain a main index with vertical navigation menus that
-# are dynamically created via Javascript. If disabled, the navigation index will
+# are dynamically created via JavaScript. If disabled, the navigation index will
 # consists of multiple levels of tabs that are statically embedded in every HTML
-# page. Disable this option to support browsers that do not have Javascript,
+# page. Disable this option to support browsers that do not have JavaScript,
 # like the Qt help browser.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_HTML is set to YES.
@@ -1275,10 +1317,11 @@ HTML_INDEX_NUM_ENTRIES = 100
 
 # If the GENERATE_DOCSET tag is set to YES, additional index files will be
 # generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see: https://developer.apple.com/xcode/), introduced with OSX
-# 10.5 (Leopard). To create a documentation set, doxygen will generate a
-# Makefile in the HTML output directory. Running make will produce the docset in
-# that directory and running make install will install the docset in
+# environment (see:
+# https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To
+# create a documentation set, doxygen will generate a Makefile in the HTML
+# output directory. Running make will produce the docset in that directory and
+# running make install will install the docset in
 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
 # startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
 # genXcode/_index.html for more information.
@@ -1320,8 +1363,8 @@ DOCSET_PUBLISHER_NAME  = Publisher
 # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
 # additional HTML index files: index.hhp, index.hhc, and index.hhk. The
 # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see: https://www.microsoft.com/en-us/download/details.aspx?id=21138) on
-# Windows.
+# (see:
+# https://www.microsoft.com/en-us/download/details.aspx?id=21138) on Windows.
 #
 # The HTML Help Workshop contains a compiler that can convert all HTML output
 # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
@@ -1351,7 +1394,7 @@ CHM_FILE               =
 HHC_LOCATION           =
 
 # The GENERATE_CHI flag controls if a separate .chi index file is generated
-# (YES) or that it should be included in the master .chm file (NO).
+# (YES) or that it should be included in the main .chm file (NO).
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
@@ -1396,7 +1439,8 @@ QCH_FILE               =
 
 # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
 # Project output. For more information please see Qt Help Project / Namespace
-# (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
+# (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
 # The default value is: org.doxygen.Project.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1404,8 +1448,8 @@ QHP_NAMESPACE          = org.doxygen.Project
 
 # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
 # Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-
-# folders).
+# Folders (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders).
 # The default value is: doc.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1413,16 +1457,16 @@ QHP_VIRTUAL_FOLDER     = doc
 
 # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
 # filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
-# filters).
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_NAME   =
 
 # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
 # custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
-# filters).
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_ATTRS  =
@@ -1434,9 +1478,9 @@ QHP_CUST_FILTER_ATTRS  =
 
 QHP_SECT_FILTER_ATTRS  =
 
-# The QHG_LOCATION tag can be used to specify the location of Qt's
-# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
-# generated .qhp file.
+# The QHG_LOCATION tag can be used to specify the location (absolute path
+# including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to
+# run qhelpgenerator on the generated .qhp file.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHG_LOCATION           =
@@ -1513,6 +1557,17 @@ TREEVIEW_WIDTH         = 250
 
 EXT_LINKS_IN_WINDOW    = NO
 
+# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
+# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
+# https://inkscape.org) to generate formulas as SVG images instead of PNGs for
+# the HTML output. These images will generally look nicer at scaled resolutions.
+# Possible values are: png (the default) and svg (looks nicer but requires the
+# pdf2svg or inkscape tool).
+# The default value is: png.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FORMULA_FORMAT    = png
+
 # Use this tag to change the font size of LaTeX formulas included as images in
 # the HTML documentation. When you change the font size after a successful
 # doxygen run you need to manually remove any form_*.png images from the HTML
@@ -1533,8 +1588,14 @@ FORMULA_FONTSIZE       = 10
 
 FORMULA_TRANSPARENT    = YES
 
+# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
+# to create new LaTeX commands to be used in formulas as building blocks. See
+# the section "Including formulas" for details.
+
+FORMULA_MACROFILE      =
+
 # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
-# https://www.mathjax.org) which uses client side Javascript for the rendering
+# https://www.mathjax.org) which uses client side JavaScript for the rendering
 # instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
 # installed or if you want to formulas look prettier in the HTML output. When
 # enabled you may also need to install MathJax separately and configure the path
@@ -1546,7 +1607,7 @@ USE_MATHJAX            = NO
 
 # When MathJax is enabled you can set the default output format to be used for
 # the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/latest/output.html) for more details.
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details.
 # Possible values are: HTML-CSS (which is slower, but has the best
 # compatibility), NativeMML (i.e. MathML) and SVG.
 # The default value is: HTML-CSS.
@@ -1562,7 +1623,7 @@ MATHJAX_FORMAT         = HTML-CSS
 # Content Delivery Network so you can quickly see the result without installing
 # MathJax. However, it is strongly recommended to install a local copy of
 # MathJax from https://www.mathjax.org before deployment.
-# The default value is: https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/.
+# The default value is: https://cdn.jsdelivr.net/npm/mathjax@2.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_RELPATH        = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/
@@ -1576,7 +1637,8 @@ MATHJAX_EXTENSIONS     =
 
 # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
 # of code that will be used on startup of the MathJax code. See the MathJax site
-# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an
 # example see the documentation.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
@@ -1604,7 +1666,7 @@ MATHJAX_CODEFILE       =
 SEARCHENGINE           = YES
 
 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using Javascript. There
+# implemented using a web server instead of a web client using JavaScript. There
 # are two flavors of web server based searching depending on the EXTERNAL_SEARCH
 # setting. When disabled, doxygen will generate a PHP script for searching and
 # an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
@@ -1623,7 +1685,8 @@ SERVER_BASED_SEARCH    = NO
 #
 # Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: https://xapian.org/).
+# Xapian (see:
+# https://xapian.org/).
 #
 # See the section "External Indexing and Searching" for details.
 # The default value is: NO.
@@ -1636,8 +1699,9 @@ EXTERNAL_SEARCH        = NO
 #
 # Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: https://xapian.org/). See the section "External Indexing and
-# Searching" for details.
+# Xapian (see:
+# https://xapian.org/). See the section "External Indexing and Searching" for
+# details.
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
 SEARCHENGINE_URL       =
@@ -1695,7 +1759,7 @@ LATEX_OUTPUT           = latex
 # the output language.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
-LATEX_CMD_NAME         = latex
+LATEX_CMD_NAME         = larex
 
 # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
 # index for LaTeX.
@@ -1715,7 +1779,7 @@ MAKEINDEX_CMD_NAME     = makeindex
 # The default value is: makeindex.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
-LATEX_MAKEINDEX_CMD    = \makeindex
+LATEX_MAKEINDEX_CMD    = makeindex
 
 # If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
 # documents. This may be useful for small projects and may help to save some
@@ -1732,7 +1796,7 @@ COMPACT_LATEX          = NO
 # The default value is: a4.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
-PAPER_TYPE             = a4wide
+PAPER_TYPE             = a4
 
 # The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
 # that should be included in the LaTeX output. The package can be specified just
@@ -1801,9 +1865,11 @@ LATEX_EXTRA_FILES      =
 
 PDF_HYPERLINKS         = YES
 
-# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
-# the PDF file directly from the LaTeX files. Set this option to YES, to get a
-# higher quality PDF documentation.
+# If the USE_PDFLATEX tag is set to YES, doxygen will use the engine as
+# specified with LATEX_CMD_NAME to generate the PDF file directly from the LaTeX
+# files. Set this option to YES, to get a higher quality PDF documentation.
+#
+# See also section LATEX_CMD_NAME for selecting the engine.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -2042,6 +2108,10 @@ DOCBOOK_PROGRAMLISTING = NO
 
 GENERATE_AUTOGEN_DEF   = NO
 
+#---------------------------------------------------------------------------
+# Configuration options related to Sqlite3 output
+#---------------------------------------------------------------------------
+
 #---------------------------------------------------------------------------
 # Configuration options related to the Perl module output
 #---------------------------------------------------------------------------
@@ -2314,10 +2384,32 @@ UML_LOOK               = YES
 # but if the number exceeds 15, the total amount of fields shown is limited to
 # 10.
 # Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
+# This tag requires that the tag UML_LOOK is set to YES.
 
 UML_LIMIT_NUM_FIELDS   = 10
 
+# If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
+# methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
+# tag is set to YES, doxygen will add type and arguments for attributes and
+# methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen
+# will not generate fields with class member information in the UML graphs. The
+# class diagrams will look similar to the default class diagrams but using UML
+# notation for the relationships.
+# Possible values are: NO, YES and NONE.
+# The default value is: NO.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+DOT_UML_DETAILS        = NO
+
+# The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
+# to display on a single line. If the actual line length exceeds this threshold
+# significantly it will wrapped across multiple lines. Some heuristics are apply
+# to avoid ugly line breaks.
+# Minimum value: 0, maximum value: 1000, default value: 17.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_WRAP_THRESHOLD     = 17
+
 # If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
 # collaboration graphs will show the relations between templates and their
 # instances.
@@ -2507,9 +2599,11 @@ DOT_MULTI_TARGETS      = NO
 
 GENERATE_LEGEND        = YES
 
-# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
 # files that are used to generate the various graphs.
+#
+# Note: This setting is not only used for dot files but also for msc and
+# plantuml temporary files.
 # The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_CLEANUP            = YES

From df9f534d12ab75fb0d16dfc6555783dd51458570 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 25 Jan 2021 11:37:19 +0100
Subject: [PATCH 1512/1774] doxyfile update

---
 doc/doxy/OPUS.doxyfile | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/doxy/OPUS.doxyfile b/doc/doxy/OPUS.doxyfile
index f43b06058..9a3f490dd 100644
--- a/doc/doxy/OPUS.doxyfile
+++ b/doc/doxy/OPUS.doxyfile
@@ -1759,7 +1759,7 @@ LATEX_OUTPUT           = latex
 # the output language.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
-LATEX_CMD_NAME         = larex
+LATEX_CMD_NAME         = pdflatex
 
 # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
 # index for LaTeX.
@@ -2327,7 +2327,7 @@ DOT_NUM_THREADS        = 0
 # The default value is: Helvetica.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-DOT_FONTNAME           = FreeSans
+DOT_FONTNAME           = Ubuntu
 
 # The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
 # dot graphs.
@@ -2386,7 +2386,7 @@ UML_LOOK               = YES
 # Minimum value: 0, maximum value: 100, default value: 10.
 # This tag requires that the tag UML_LOOK is set to YES.
 
-UML_LIMIT_NUM_FIELDS   = 10
+UML_LIMIT_NUM_FIELDS   = 15
 
 # If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
 # methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
@@ -2416,7 +2416,7 @@ DOT_WRAP_THRESHOLD     = 17
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-TEMPLATE_RELATIONS     = YES
+TEMPLATE_RELATIONS     = NO
 
 # If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
 # YES then doxygen will generate a graph for each documented file showing the

From 4dbd5a58e30dec3934230894422c645a68b488c3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 25 Jan 2021 13:09:39 +0100
Subject: [PATCH 1513/1774] local pool updates

---
 datapoollocal/AccessLocalPoolF.h       | 2 +-
 datapoollocal/LocalDataPoolManager.cpp | 2 +-
 datapoollocal/LocalDataPoolManager.h   | 6 +++---
 datapoollocal/LocalPoolDataSetBase.cpp | 2 +-
 datapoollocal/LocalPoolObjectBase.cpp  | 4 ++--
 5 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
index f68189f65..55f46e215 100644
--- a/datapoollocal/AccessLocalPoolF.h
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -18,7 +18,7 @@ public:
      * This function is protected because it should only be used by the
      * class imlementing the interface.
      */
-    virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+    virtual LocalDataPoolManager* getPoolManagerHandle() = 0;
 
 protected:
 
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index d2732582e..16a4aec28 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -906,6 +906,6 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 	}
 }
 
-LocalDataPoolManager* LocalDataPoolManager::getHkManagerHandle() {
+LocalDataPoolManager* LocalDataPoolManager::getPoolManagerHandle() {
 	return this;
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index f70474190..21a79c4a2 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -179,8 +179,6 @@ public:
             MessageQueueId_t targetQueueId,
             bool generateSnapshot) override;
 
-    MutexIF* getLocalPoolMutex() override;
-
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
 	 * than diagnostic packets.
@@ -264,7 +262,7 @@ public:
 
     object_id_t getCreatorObjectId() const;
 
-    virtual LocalDataPoolManager* getHkManagerHandle() override;
+    virtual LocalDataPoolManager* getPoolManagerHandle() override;
 private:
     localpool::DataPool localPoolMap;
     /** Every housekeeping data manager has a mutex to protect access
@@ -361,6 +359,8 @@ private:
      */
     ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
+    MutexIF* getLocalPoolMutex() override;
+
 	ReturnValue_t serializeHkPacketIntoStore(
 	        HousekeepingPacketDownlink& hkPacket,
 	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 4dae757eb..035ba6945 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -28,7 +28,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
 
     if(accessor != nullptr) {
-        poolManager = accessor->getHkManagerHandle();
+        poolManager = accessor->getPoolManagerHandle();
         mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
     }
 
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index a0bf57080..5b9bd34f6 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -22,7 +22,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkO
         return;
     }
     AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
-    hkManager = poolManAccessor->getHkManagerHandle();
+    hkManager = poolManAccessor->getPoolManagerHandle();
 
     if (dataSet != nullptr) {
         dataSet->registerVariable(this);
@@ -50,7 +50,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
 
     AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
     if(accessor != nullptr) {
-        hkManager = accessor->getHkManagerHandle();
+        hkManager = accessor->getPoolManagerHandle();
     }
 
     if(dataSet != nullptr) {

From 52c177479f1fcab811b833f594a32e07967e2b99 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 25 Jan 2021 13:44:21 +0100
Subject: [PATCH 1514/1774] some fixes, indentation with spaces now

---
 datapoollocal/LocalDataPoolManager.h       | 318 ++++++++++-----------
 unittest/tests/storagemanager/TestPool.cpp |   2 +-
 2 files changed, 160 insertions(+), 160 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 21a79c4a2..bbd59ee4b 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -53,16 +53,15 @@ class LocalDataPool;
  * @author 		R. Mueller
  */
 class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF,
-		public AccessPoolManagerIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-	//! Some classes using the pool manager directly need to access class internals of the
-	//! manager. The attorney provides granular control of access to these internals.
-	friend class LocalDpManagerAttorney;
+public AccessPoolManagerIF {
+    friend void (Factory::setStaticFrameworkObjectIds)();
+    //! Some classes using the pool manager directly need to access class internals of the
+    //! manager. The attorney provides granular control of access to these internals.
+    friend class LocalDpManagerAttorney;
 public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
+    static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
     static constexpr ReturnValue_t QUEUE_OR_DESTINATION_INVALID = MAKE_RETURN_CODE(0);
-
     static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(1);
     static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(2);
     static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(3);
@@ -81,29 +80,29 @@ public:
      * @param appendValidityBuffer Specify whether a buffer containing the
      * validity state is generated  when serializing or deserializing packets.
      */
-	LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
-	        bool appendValidityBuffer = true);
-	virtual~ LocalDataPoolManager();
+    LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+            bool appendValidityBuffer = true);
+    virtual~ LocalDataPoolManager();
 
-	/**
-	 * Assigns the queue to use. Make sure to call this in the #initialize
-	 * function of the owner.
-	 * @param queueToUse
-	 * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
-	 * @return
-	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse);
+    /**
+     * Assigns the queue to use. Make sure to call this in the #initialize
+     * function of the owner.
+     * @param queueToUse
+     * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
+     * @return
+     */
+    ReturnValue_t initialize(MessageQueueIF* queueToUse);
 
-	/**
-	 * Initializes the map by calling the map initialization function and
-	 * setting the periodic factor for non-diagnostic packets.
-	 * Don't forget to call this in the #initializeAfterTaskCreation call of
-	 * the owner, otherwise the map will be invalid!
-	 * @param nonDiagInvlFactor
-	 * @return
-	 */
-	ReturnValue_t initializeAfterTaskCreation(
-	        uint8_t nonDiagInvlFactor = 5);
+    /**
+     * Initializes the map by calling the map initialization function and
+     * setting the periodic factor for non-diagnostic packets.
+     * Don't forget to call this in the #initializeAfterTaskCreation call of
+     * the owner, otherwise the map will be invalid!
+     * @param nonDiagInvlFactor
+     * @return
+     */
+    ReturnValue_t initializeAfterTaskCreation(
+            uint8_t nonDiagInvlFactor = 5);
 
     /**
      * @brief   This should be called in the periodic handler of the owner.
@@ -116,49 +115,49 @@ public:
      */
     virtual ReturnValue_t performHkOperation();
 
-	/**
-	 * @brief   Subscribe for the generation of periodic packets.
-	 * @details
+    /**
+     * @brief   Subscribe for the generation of periodic packets.
+     * @details
      * This subscription mechanism will generally be used by the data creator
      * to generate housekeeping packets which are downlinked directly.
-	 * @return
-	 */
-	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
-			float collectionInterval, bool isDiagnostics,
-			object_id_t packetDestination = defaultHkDestination) override;
+     * @return
+     */
+    ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
+            float collectionInterval, bool isDiagnostics,
+            object_id_t packetDestination = defaultHkDestination) override;
 
-	/**
-	 * @brief   Subscribe for the  generation of packets if the dataset
-	 *          is marked as changed.
-	 * @details
-	 * This subscription mechanism will generally be used by the data creator.
-	 * @param sid
-	 * @param isDiagnostics
-	 * @param packetDestination
-	 * @return
-	 */
+    /**
+     * @brief   Subscribe for the  generation of packets if the dataset
+     *          is marked as changed.
+     * @details
+     * This subscription mechanism will generally be used by the data creator.
+     * @param sid
+     * @param isDiagnostics
+     * @param packetDestination
+     * @return
+     */
     ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool reportingEnabled,
             bool isDiagnostics,
             object_id_t packetDestination = defaultHkDestination) override;
 
-	/**
-	 * @brief   Subscribe for a notification message which will be sent
-	 *          if a dataset has changed.
-	 * @details
-	 * This subscription mechanism will generally be used internally by
-	 * other software components.
-	 * @param setId     Set ID of the set to receive update messages from.
-	 * @param destinationObject
-	 * @param targetQueueId
-	 * @param generateSnapshot If this is set to true, a copy of the current
-	 * data with a timestamp will be generated and sent via message.
-	 * Otherwise, only an notification message is sent.
-	 * @return
-	 */
-	ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
-	        object_id_t destinationObject,
-	        MessageQueueId_t targetQueueId,
-	        bool generateSnapshot) override;
+    /**
+     * @brief   Subscribe for a notification message which will be sent
+     *          if a dataset has changed.
+     * @details
+     * This subscription mechanism will generally be used internally by
+     * other software components.
+     * @param setId     Set ID of the set to receive update messages from.
+     * @param destinationObject
+     * @param targetQueueId
+     * @param generateSnapshot If this is set to true, a copy of the current
+     * data with a timestamp will be generated and sent via message.
+     * Otherwise, only an notification message is sent.
+     * @return
+     */
+    ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
+            object_id_t destinationObject,
+            MessageQueueId_t targetQueueId,
+            bool generateSnapshot) override;
 
     /**
      * @brief   Subscribe for an notification message which will be sent if a
@@ -179,16 +178,16 @@ public:
             MessageQueueId_t targetQueueId,
             bool generateSnapshot) override;
 
-	/**
-	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
-	 * than diagnostic packets.
-	 * A factor can be specified to determine the minimum sampling frequency
-	 * for non-diagnostic packets. The minimum sampling frequency of the
-	 * diagnostics packets,which is usually jusst the period of the
-	 * performOperation calls, is multiplied with that factor.
-	 * @param factor
-	 */
-	void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
+    /**
+     * Non-Diagnostics packets usually have a lower minimum sampling frequency
+     * than diagnostic packets.
+     * A factor can be specified to determine the minimum sampling frequency
+     * for non-diagnostic packets. The minimum sampling frequency of the
+     * diagnostics packets,which is usually jusst the period of the
+     * performOperation calls, is multiplied with that factor.
+     * @param factor
+     */
+    void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
 
     /**
      * @brief   The manager is also able to handle housekeeping messages.
@@ -204,18 +203,18 @@ public:
      */
     virtual ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
-	/**
-	 * Generate a housekeeping packet with a given SID.
-	 * @param sid
-	 * @return
-	 */
-	ReturnValue_t generateHousekeepingPacket(sid_t sid,
-			LocalPoolDataSetBase* dataSet, bool forDownlink,
-			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
+    /**
+     * Generate a housekeeping packet with a given SID.
+     * @param sid
+     * @return
+     */
+    ReturnValue_t generateHousekeepingPacket(sid_t sid,
+            LocalPoolDataSetBase* dataSet, bool forDownlink,
+            MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 
-	HasLocalDataPoolIF* getOwner();
+    HasLocalDataPoolIF* getOwner();
 
-	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
+    ReturnValue_t printPoolEntry(lp_id_t localPoolId);
 
     /**
      * Different types of housekeeping reporting are possible.
@@ -234,8 +233,8 @@ public:
         PERIODIC,
         //! Housekeeping packet will be generated if values have changed.
         UPDATE_HK,
-		//! Update notification will be sent out as message.
-		UPDATE_NOTIFICATION,
+        //! Update notification will be sent out as message.
+        UPDATE_NOTIFICATION,
         //! Notification will be sent out as message and a snapshot of the
         //! current data will be generated.
         UPDATE_SNAPSHOT,
@@ -245,8 +244,8 @@ public:
     requested for full datasets or for single pool variables. Periodic reporting is only possible
     for data sets. */
     enum class DataType: uint8_t {
-    	LOCAL_POOL_VARIABLE,
-		DATA_SET
+        LOCAL_POOL_VARIABLE,
+        DATA_SET
     };
 
     /* Copying forbidden */
@@ -262,6 +261,14 @@ public:
 
     object_id_t getCreatorObjectId() const;
 
+    /**
+     * Get the pointer to the mutex. Can be used to lock the data pool
+     * externally. Use with care and don't forget to unlock locked mutexes!
+     * For now, only friend classes can accss this function.
+     * @return
+     */
+    MutexIF* getMutexHandle();
+
     virtual LocalDataPoolManager* getPoolManagerHandle() override;
 private:
     localpool::DataPool localPoolMap;
@@ -274,9 +281,9 @@ private:
 
     uint8_t nonDiagnosticIntervalFactor = 0;
 
-	/** Default receiver for periodic HK packets */
-	static object_id_t defaultHkDestination;
-	MessageQueueId_t hkDestinationId = MessageQueueIF::NO_QUEUE;
+    /** Default receiver for periodic HK packets */
+    static object_id_t defaultHkDestination;
+    MessageQueueId_t hkDestinationId = MessageQueueIF::NO_QUEUE;
 
     union DataId {
         DataId(): sid() {};
@@ -286,10 +293,10 @@ private:
 
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
-		/** Object ID of receiver */
-		object_id_t objectId = objects::NO_OBJECT;
+        /** Object ID of receiver */
+        object_id_t objectId = objects::NO_OBJECT;
 
-		DataType dataType = DataType::DATA_SET;
+        DataType dataType = DataType::DATA_SET;
         DataId dataId;
 
         ReportingType reportingType = ReportingType::PERIODIC;
@@ -319,37 +326,30 @@ private:
      * of generated housekeeping packets. */
     bool appendValidityBuffer = true;
 
-	/**
-	 * @brief Queue used for communication, for example commands.
-	 * Is also used to send messages. Can be set either in the constructor
+    /**
+     * @brief Queue used for communication, for example commands.
+     * Is also used to send messages. Can be set either in the constructor
      * or in the initialize() function.
-	 */
-	MessageQueueIF* hkQueue = nullptr;
+     */
+    MessageQueueIF* hkQueue = nullptr;
 
-	/** Global IPC store is used to store all packets. */
-	StorageManagerIF* ipcStore = nullptr;
-	/**
-	 * Get the pointer to the mutex. Can be used to lock the data pool
-	 * externally. Use with care and don't forget to unlock locked mutexes!
-	 * For now, only friend classes can accss this function.
-	 * @return
-	 */
-	MutexIF* getMutexHandle();
+    /** Global IPC store is used to store all packets. */
+    StorageManagerIF* ipcStore = nullptr;
 
-	/**
-	 * Read a variable by supplying its local pool ID and assign the pool
-	 * entry to the supplied PoolEntry pointer. The type of the pool entry
-	 * is deduced automatically. This call is not thread-safe!
-	 * For now, only friend classes like LocalPoolVar may access this
-	 * function.
-	 * @tparam T Type of the pool entry
-	 * @param localPoolId Pool ID of the variable to read
-	 * @param poolVar [out] Corresponding pool entry will be assigned to the
-	 * 						supplied pointer.
-	 * @return
-	 */
-	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
-			PoolEntry<T> **poolEntry);
+    /**
+     * Read a variable by supplying its local pool ID and assign the pool
+     * entry to the supplied PoolEntry pointer. The type of the pool entry
+     * is deduced automatically. This call is not thread-safe!
+     * For now, only friend classes like LocalPoolVar may access this
+     * function.
+     * @tparam T Type of the pool entry
+     * @param localPoolId Pool ID of the variable to read
+     * @param poolVar [out] Corresponding pool entry will be assigned to the
+     * 						supplied pointer.
+     * @return
+     */
+    template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
+            PoolEntry<T> **poolEntry);
 
     /**
      * This function is used to fill the local data pool map with pool
@@ -361,55 +361,55 @@ private:
 
     MutexIF* getLocalPoolMutex() override;
 
-	ReturnValue_t serializeHkPacketIntoStore(
-	        HousekeepingPacketDownlink& hkPacket,
-	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
+    ReturnValue_t serializeHkPacketIntoStore(
+            HousekeepingPacketDownlink& hkPacket,
+            store_address_t& storeId, bool forDownlink, size_t* serializedSize);
 
-	void performPeriodicHkGeneration(HkReceiver& hkReceiver);
-	ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable,
-			bool isDiagnostics);
-	ReturnValue_t changeCollectionInterval(sid_t sid,
-			float newCollectionInterval, bool isDiagnostics);
-	ReturnValue_t generateSetStructurePacket(sid_t sid, bool isDiagnostics);
+    void performPeriodicHkGeneration(HkReceiver& hkReceiver);
+    ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable,
+            bool isDiagnostics);
+    ReturnValue_t changeCollectionInterval(sid_t sid,
+            float newCollectionInterval, bool isDiagnostics);
+    ReturnValue_t generateSetStructurePacket(sid_t sid, bool isDiagnostics);
 
-	void handleHkUpdateResetListInsertion(DataType dataType, DataId dataId);
-	void handleChangeResetLogic(DataType type,
-	        DataId dataId, MarkChangedIF* toReset);
-	void resetHkUpdateResetHelper();
+    void handleHkUpdateResetListInsertion(DataType dataType, DataId dataId);
+    void handleChangeResetLogic(DataType type,
+            DataId dataId, MarkChangedIF* toReset);
+    void resetHkUpdateResetHelper();
 
-	ReturnValue_t handleHkUpdate(HkReceiver& hkReceiver,
+    ReturnValue_t handleHkUpdate(HkReceiver& hkReceiver,
             ReturnValue_t& status);
-	ReturnValue_t handleNotificationUpdate(HkReceiver& hkReceiver,
-	        ReturnValue_t& status);
-	ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver,
+    ReturnValue_t handleNotificationUpdate(HkReceiver& hkReceiver,
             ReturnValue_t& status);
-	ReturnValue_t addUpdateToStore(HousekeepingSnapshot& updatePacket,
-	        store_address_t& storeId);
+    ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver,
+            ReturnValue_t& status);
+    ReturnValue_t addUpdateToStore(HousekeepingSnapshot& updatePacket,
+            store_address_t& storeId);
 
-	void printWarningOrError(sif::OutputTypes outputType,
-			const char* functionName,
-			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
-			const char* errorPrint = nullptr);
+    void printWarningOrError(sif::OutputTypes outputType,
+            const char* functionName,
+            ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+            const char* errorPrint = nullptr);
 };
 
 
 template<class T> inline
 ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
-		PoolEntry<T> **poolEntry) {
-	auto poolIter = localPoolMap.find(localPoolId);
-	if (poolIter == localPoolMap.end()) {
-    	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
-    			localpool::POOL_ENTRY_NOT_FOUND);
-		return localpool::POOL_ENTRY_NOT_FOUND;
-	}
+        PoolEntry<T> **poolEntry) {
+    auto poolIter = localPoolMap.find(localPoolId);
+    if (poolIter == localPoolMap.end()) {
+        printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
+                localpool::POOL_ENTRY_NOT_FOUND);
+        return localpool::POOL_ENTRY_NOT_FOUND;
+    }
 
-	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
-	if(*poolEntry == nullptr) {
-    	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
-    			localpool::POOL_ENTRY_TYPE_CONFLICT);
-		return localpool::POOL_ENTRY_TYPE_CONFLICT;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    *poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
+    if(*poolEntry == nullptr) {
+        printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
+                localpool::POOL_ENTRY_TYPE_CONFLICT);
+        return localpool::POOL_ENTRY_TYPE_CONFLICT;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 
diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
index 50bde01ab..d05a3dd6e 100644
--- a/unittest/tests/storagemanager/TestPool.cpp
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -276,7 +276,7 @@ TEST_CASE( "Local Pool Extended Tests [3 Pools]" , "[TestPool2]") {
 		CHECK(receptionArray[3] == 66);
 
 		// now clear first page
-		simplePool.clearPage(0);
+		simplePool.clearSubPool(0);
 		bytesWritten = 0;
 		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
 		// Second page full, median fill count is 33 %

From 31517604c921c97ec067d064bac36635539f9208 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 25 Jan 2021 15:03:39 +0100
Subject: [PATCH 1515/1774] indentation

---
 datapoollocal/LocalDataPoolManager.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index bbd59ee4b..d13dfbc30 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -52,8 +52,9 @@ class LocalDataPool;
  * Each pool entry has a valid state too.
  * @author 		R. Mueller
  */
-class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF,
-public AccessPoolManagerIF {
+class LocalDataPoolManager:
+        public ProvidesDataPoolSubscriptionIF,
+        public AccessPoolManagerIF {
     friend void (Factory::setStaticFrameworkObjectIds)();
     //! Some classes using the pool manager directly need to access class internals of the
     //! manager. The attorney provides granular control of access to these internals.

From 18fddf27556e0b7da229e3441ae6b5bb25356a42 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 25 Jan 2021 15:06:41 +0100
Subject: [PATCH 1516/1774] tested subscription interface

---
 unittest/tests/datapoollocal/LocalPoolManagerTest.cpp | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index b12d484f6..81e2fddcb 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -138,6 +138,10 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
     }
 
     SECTION("AdvancedTests") {
+        /* Acquire subscription interface */
+        ProvidesDataPoolSubscriptionIF* subscriptionIF = poolOwner->getSubscriptionInterface();
+        REQUIRE(subscriptionIF != nullptr);
+
         /* Subscribe for variable update */
         REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
                 retval::CATCH_OK);
@@ -155,8 +159,9 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
         CHECK(messageSent.getCommand() == static_cast<int>(
                 HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
-        /* Now subscribe for the dataset update (HK and update) again */
-        REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
+        /* Now subscribe for the dataset update (HK and update) again with subscription interface */
+        REQUIRE(subscriptionIF->subscribeForSetUpdateMessages(lpool::testSetId,
+                objects::NO_OBJECT, objects::HK_RECEIVER_MOCK, false) == retval::CATCH_OK);
         REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
 
         poolOwner->dataset.setChanged(true);

From 194a9eef64785cb2d3abc2d57308053b12cd1ea5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 25 Jan 2021 15:11:19 +0100
Subject: [PATCH 1517/1774] formatting

---
 unittest/tests/datapoollocal/LocalPoolManagerTest.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 81e2fddcb..c8b10442a 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -187,8 +187,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         CHECK(messageSent.getCommand() == static_cast<int>(
                 HousekeepingMessage::HK_REPORT));
         CommandMessageCleaner::clearCommandMessage(&messageSent);
-        REQUIRE(mqMock->receiveMessage(&messageSent) ==
-                static_cast<int>(MessageQueueIF::EMPTY));
+        REQUIRE(mqMock->receiveMessage(&messageSent) == static_cast<int>(MessageQueueIF::EMPTY));
     }
 
     /* we need to reset the subscription list because the pool owner

From a93984869cee6ad9837078c35fdd15543074fd00 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 26 Jan 2021 21:38:38 +0100
Subject: [PATCH 1518/1774] added start and end marker for framework objects

---
 objectmanager/frameworkObjects.h | 42 +++++++++++++++++---------------
 1 file changed, 22 insertions(+), 20 deletions(-)

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 8f8e93af7..9810e33b9 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -3,28 +3,30 @@
 
 namespace objects {
 enum framework_objects {
-	// Default verification reporter.
-	PUS_SERVICE_1_VERIFICATION = 0x53000001,
-	PUS_SERVICE_2_DEVICE_ACCESS = 0x53000002,
-	PUS_SERVICE_3_HOUSEKEEPING = 0x53000003,
-	PUS_SERVICE_5_EVENT_REPORTING = 0x53000005,
-	PUS_SERVICE_8_FUNCTION_MGMT = 0x53000008,
-	PUS_SERVICE_9_TIME_MGMT = 0x53000009,
-	PUS_SERVICE_17_TEST = 0x53000017,
-	PUS_SERVICE_200_MODE_MGMT = 0x53000200,
+    FSFW_OBJECTS_START = 0x53000000,
+    // Default verification reporter.
+    PUS_SERVICE_1_VERIFICATION = 0x53000001,
+    PUS_SERVICE_2_DEVICE_ACCESS = 0x53000002,
+    PUS_SERVICE_3_HOUSEKEEPING = 0x53000003,
+    PUS_SERVICE_5_EVENT_REPORTING = 0x53000005,
+    PUS_SERVICE_8_FUNCTION_MGMT = 0x53000008,
+    PUS_SERVICE_9_TIME_MGMT = 0x53000009,
+    PUS_SERVICE_17_TEST = 0x53000017,
+    PUS_SERVICE_200_MODE_MGMT = 0x53000200,
 
-	//Generic IDs for IPC, modes, health, events
-	HEALTH_TABLE = 0x53010000,
-//	MODE_STORE = 0x53010100,
-	EVENT_MANAGER = 0x53030000,
-	INTERNAL_ERROR_REPORTER = 0x53040000,
-	IPC_STORE = 0x534f0300,
-	//IDs for PUS Packet Communication
-	TC_STORE = 0x534f0100,
-	TM_STORE = 0x534f0200,
-	TIME_STAMPER = 0x53500010,
+    //Generic IDs for IPC, modes, health, events
+    HEALTH_TABLE = 0x53010000,
+    //	MODE_STORE = 0x53010100,
+    EVENT_MANAGER = 0x53030000,
+    INTERNAL_ERROR_REPORTER = 0x53040000,
+    IPC_STORE = 0x534f0300,
+    //IDs for PUS Packet Communication
+    TC_STORE = 0x534f0100,
+    TM_STORE = 0x534f0200,
+    TIME_STAMPER = 0x53500010,
 
-	NO_OBJECT = 0xFFFFFFFF
+    FSFW_OBJECTS_END = 0x53ffffff,
+    NO_OBJECT = 0xFFFFFFFF
 };
 }
 

From d1cd1805347e595ca27c8a0428321d80c4131195 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 26 Jan 2021 23:09:08 +0100
Subject: [PATCH 1519/1774] fixed warning for RTEMS

---
 osal/rtems/CpuUsage.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index 6655c69b6..89c01336a 100644
--- a/osal/rtems/CpuUsage.cpp
+++ b/osal/rtems/CpuUsage.cpp
@@ -164,7 +164,7 @@ ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if ((*size = *size - MAX_LENGTH_OF_THREAD_NAME) < 0) {
+	if (*size < MAX_LENGTH_OF_THREAD_NAME) {
 		return STREAM_TOO_SHORT;
 	}
 	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);

From 47698418fcfaccb0125e7f36a187e93fe8a59294 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 26 Jan 2021 23:12:14 +0100
Subject: [PATCH 1520/1774] some more warning fixes

---
 osal/rtems/MultiObjectTask.cpp | 6 ------
 osal/rtems/TaskBase.cpp        | 2 +-
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index b111f724c..0cc3c9221 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -62,12 +62,6 @@ void MultiObjectTask::taskFunctionality() {
 		}
 		rtems_status_code status = TaskBase::restartPeriod(periodTicks,periodId);
 		if (status == RTEMS_TIMEOUT) {
-			char nameSpace[8] = { 0 };
-			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
-					nameSpace);
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
-#endif
 			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index 6abfcca8d..7ad94b843 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -14,7 +14,7 @@ TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
 	}
 	//The task is created with the operating system's system call.
 	rtems_status_code status = RTEMS_UNSATISFIED;
-	if (set_priority >= 0 && set_priority <= 99) {
+	if (set_priority <= 99) {
 		 status = rtems_task_create(osalName,
 				(0xFF - 2 * set_priority), stack_size,
 				RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,

From de45e9b8a9c7fae16305e9cec80dbddd07b9dede Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 00:59:34 +0100
Subject: [PATCH 1521/1774] rtems multi object is now periodicTask

---
 osal/rtems/CMakeLists.txt                     |  4 +-
 osal/rtems/MultiObjectTask.cpp                | 86 -------------------
 osal/rtems/PeriodicTask.cpp                   | 80 +++++++++++++++++
 .../{MultiObjectTask.h => PeriodicTask.h}     | 18 ++--
 osal/rtems/PollingTask.cpp                    |  8 +-
 osal/rtems/PollingTask.h                      |  4 +-
 .../rtems/{TaskBase.cpp => RTEMSTaskBase.cpp} | 20 ++---
 osal/rtems/{TaskBase.h => RTEMSTaskBase.h}    | 12 +--
 osal/rtems/RtemsBasic.cpp                     |  1 +
 osal/rtems/RtemsBasic.h                       |  3 +-
 osal/rtems/TaskFactory.cpp                    |  4 +-
 11 files changed, 118 insertions(+), 122 deletions(-)
 delete mode 100644 osal/rtems/MultiObjectTask.cpp
 create mode 100644 osal/rtems/PeriodicTask.cpp
 rename osal/rtems/{MultiObjectTask.h => PeriodicTask.h} (90%)
 rename osal/rtems/{TaskBase.cpp => RTEMSTaskBase.cpp} (75%)
 rename osal/rtems/{TaskBase.h => RTEMSTaskBase.h} (84%)

diff --git a/osal/rtems/CMakeLists.txt b/osal/rtems/CMakeLists.txt
index bff031842..ba11a6b5a 100644
--- a/osal/rtems/CMakeLists.txt
+++ b/osal/rtems/CMakeLists.txt
@@ -5,13 +5,13 @@ target_sources(${LIB_FSFW_NAME}
 		InitTask.cpp
 		InternalErrorCodes.cpp
 		MessageQueue.cpp
-		MultiObjectTask.cpp
+		PeriodicTask.cpp
 		Mutex.cpp
 		MutexFactory.cpp
 		PollingTask.cpp
 		QueueFactory.cpp
 		RtemsBasic.cpp
-		TaskBase.cpp
+		RTEMSTaskBase.cpp
 		TaskFactory.cpp
 )
 
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
deleted file mode 100644
index 0cc3c9221..000000000
--- a/osal/rtems/MultiObjectTask.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * @file	MultiObjectTask.cpp
- * @brief	This file defines the MultiObjectTask class.
- * @date	30.01.2014
- * @author	baetz
- */
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tasks/ExecutableObjectIF.h"
-#include "MultiObjectTask.h"
-
-MultiObjectTask::MultiObjectTask(const char *name, rtems_task_priority setPriority,
-		size_t setStack, rtems_interval setPeriod, void (*setDeadlineMissedFunc)()) :
-		TaskBase(setPriority, setStack, name), periodTicks(
-				RtemsBasic::convertMsToTicks(setPeriod)), periodId(0), deadlineMissedFunc(
-				setDeadlineMissedFunc) {
-}
-
-MultiObjectTask::~MultiObjectTask(void) {
-	//Do not delete objects, we were responsible for ptrs only.
-	rtems_rate_monotonic_delete(periodId);
-}
-rtems_task MultiObjectTask::taskEntryPoint(rtems_task_argument argument) {
-	//The argument is re-interpreted as MultiObjectTask. The Task object is global, so it is found from any place.
-	MultiObjectTask *originalTask(reinterpret_cast<MultiObjectTask*>(argument));
-	originalTask->taskFunctionality();
-}
-
-ReturnValue_t MultiObjectTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
-			rtems_task_argument((void *) this));
-	if (status != RTEMS_SUCCESSFUL) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "ObjectTask::startTask for " << std::hex << this->getId()
-				<< std::dec << " failed." << std::endl;
-#endif
-	}
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ask started successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-/*		RTEMS_INVALID_ADDRESS - invalid task entry point
-		RTEMS_INVALID_ID - invalid task id
-		RTEMS_INCORRECT_STATE - task not in the dormant state
-		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t MultiObjectTask::sleepFor(uint32_t ms) {
-	return TaskBase::sleepFor(ms);
-}
-
-void MultiObjectTask::taskFunctionality() {
-	TaskBase::setAndStartPeriod(periodTicks,&periodId);
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
-		}
-		rtems_status_code status = TaskBase::restartPeriod(periodTicks,periodId);
-		if (status == RTEMS_TIMEOUT) {
-			if (this->deadlineMissedFunc != nullptr) {
-				this->deadlineMissedFunc();
-			}
-		}
-	}
-}
-
-ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	newObject->setTaskIF(this);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t MultiObjectTask::getPeriodMs() const {
-	return RtemsBasic::convertTicksToMs(periodTicks);
-}
diff --git a/osal/rtems/PeriodicTask.cpp b/osal/rtems/PeriodicTask.cpp
new file mode 100644
index 000000000..631fa8209
--- /dev/null
+++ b/osal/rtems/PeriodicTask.cpp
@@ -0,0 +1,80 @@
+#include "PeriodicTask.h"
+
+#include "../../serviceinterface/ServiceInterface.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+PeriodicTask::PeriodicTask(const char *name, rtems_task_priority setPriority,
+        size_t setStack, rtems_interval setPeriod, void (*setDeadlineMissedFunc)()) :
+        RTEMSTaskBase(setPriority, setStack, name),
+        periodTicks(RtemsBasic::convertMsToTicks(setPeriod)),
+        deadlineMissedFunc(setDeadlineMissedFunc) {
+}
+
+PeriodicTask::~PeriodicTask(void) {
+    /* Do not delete objects, we were responsible for pointers only. */
+    rtems_rate_monotonic_delete(periodId);
+}
+
+rtems_task PeriodicTask::taskEntryPoint(rtems_task_argument argument) {
+    /* The argument is re-interpreted as MultiObjectTask. The Task object is global,
+    so it is found from any place. */
+    PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
+    return originalTask->taskFunctionality();;
+}
+
+ReturnValue_t PeriodicTask::startTask() {
+    rtems_status_code status = rtems_task_start(id, PeriodicTask::taskEntryPoint,
+            rtems_task_argument((void *) this));
+    if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "ObjectTask::startTask for " << std::hex << this->getId()
+				        << std::dec << " failed." << std::endl;
+#endif
+    }
+    switch(status){
+    case RTEMS_SUCCESSFUL:
+        /* Task started successfully */
+        return HasReturnvaluesIF::RETURN_OK;
+    default:
+        /* RTEMS_INVALID_ADDRESS - invalid task entry point
+		RTEMS_INVALID_ID - invalid task id
+		RTEMS_INCORRECT_STATE - task not in the dormant state
+		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+}
+
+ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
+    return RTEMSTaskBase::sleepFor(ms);
+}
+
+void PeriodicTask::taskFunctionality() {
+    RTEMSTaskBase::setAndStartPeriod(periodTicks,&periodId);
+    /* The task's "infinite" inner loop is entered. */
+    while (1) {
+        for (const auto& object: objectList) {
+            object->performOperation();
+        }
+        rtems_status_code status = RTEMSTaskBase::restartPeriod(periodTicks,periodId);
+        if (status == RTEMS_TIMEOUT) {
+            if (this->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);
+    newObject->setTaskIF(this);
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t PeriodicTask::getPeriodMs() const {
+    return RtemsBasic::convertTicksToMs(periodTicks);
+}
diff --git a/osal/rtems/MultiObjectTask.h b/osal/rtems/PeriodicTask.h
similarity index 90%
rename from osal/rtems/MultiObjectTask.h
rename to osal/rtems/PeriodicTask.h
index 04d122a3d..2ecce457a 100644
--- a/osal/rtems/MultiObjectTask.h
+++ b/osal/rtems/PeriodicTask.h
@@ -1,10 +1,10 @@
-#ifndef FSFW_OSAL_RTEMS_MULTIOBJECTTASK_H_
-#define FSFW_OSAL_RTEMS_MULTIOBJECTTASK_H_
+#ifndef FSFW_OSAL_RTEMS_PERIODICTASK_H_
+#define FSFW_OSAL_RTEMS_PERIODICTASK_H_
 
+#include "RTEMSTaskBase.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../tasks/PeriodicTaskIF.h"
 
-#include "TaskBase.h"
 #include <vector>
 
 class ExecutableObjectIF;
@@ -18,7 +18,7 @@ class ExecutableObjectIF;
  * @author  baetz
  * @ingroup task_handling
  */
-class MultiObjectTask: public TaskBase, public PeriodicTaskIF {
+class PeriodicTask: public RTEMSTaskBase, public PeriodicTaskIF {
 public:
 	/**
 	 * @brief	Standard constructor of the class.
@@ -35,13 +35,13 @@ public:
 	 * @param setDeadlineMissedFunc	The function pointer to the deadline missed function
 	 * 								that shall be assigned.
 	 */
-	MultiObjectTask(const char *name, rtems_task_priority setPriority, size_t setStack, rtems_interval setPeriod,
-			void (*setDeadlineMissedFunc)());
+	PeriodicTask(const char *name, rtems_task_priority setPriority, size_t setStack,
+	        rtems_interval 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 ~MultiObjectTask(void);
+	virtual ~PeriodicTask(void);
 
 	/**
 	 * @brief	The method to start the task.
@@ -76,7 +76,7 @@ protected:
 	/**
 	 * @brief id of the associated OS period
 	 */
-	rtems_id periodId;
+	rtems_id periodId = 0;
 	/**
 	 * @brief	The pointer to the deadline-missed function.
 	 * @details	This pointer stores the function that is executed if the task's deadline is missed.
@@ -104,4 +104,4 @@ protected:
 	void taskFunctionality(void);
 };
 
-#endif /* FSFW_OSAL_RTEMS_MULTIOBJECTTASK_H_ */
+#endif /* FSFW_OSAL_RTEMS_PERIODICTASK_H_ */
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index 0ebf63e2e..3c9a994ca 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -20,7 +20,7 @@ uint32_t PollingTask::deadlineMissedCount = 0;
 PollingTask::PollingTask(const char *name, rtems_task_priority setPriority,
 		size_t setStack, uint32_t setOverallPeriod,
 		void (*setDeadlineMissedFunc)()) :
-		TaskBase(setPriority, setStack, name), periodId(0), pst(
+		RTEMSTaskBase(setPriority, setStack, name), periodId(0), pst(
 				setOverallPeriod) {
 	// All additional attributes are applied to the object.
 	this->deadlineMissedFunc = setDeadlineMissedFunc;
@@ -104,7 +104,7 @@ void PollingTask::taskFunctionality() {
 
 	//The start time for the first entry is read.
 	rtems_interval interval = RtemsBasic::convertMsToTicks(it->pollingTimeMs);
-	TaskBase::setAndStartPeriod(interval,&periodId);
+	RTEMSTaskBase::setAndStartPeriod(interval,&periodId);
 	//The task's "infinite" inner loop is entered.
 	while (1) {
 		if (pst.slotFollowsImmediately()) {
@@ -114,7 +114,7 @@ void PollingTask::taskFunctionality() {
 			interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
 			//The period is checked and restarted with the new interval.
 			//If the deadline was missed, the deadlineMissedFunc is called.
-			rtems_status_code status = TaskBase::restartPeriod(interval,periodId);
+			rtems_status_code status = RTEMSTaskBase::restartPeriod(interval,periodId);
 			if (status == RTEMS_TIMEOUT) {
 				if (this->deadlineMissedFunc != nullptr) {
 					this->deadlineMissedFunc();
@@ -127,5 +127,5 @@ void PollingTask::taskFunctionality() {
 }
 
 ReturnValue_t PollingTask::sleepFor(uint32_t ms){
-	return TaskBase::sleepFor(ms);
+	return RTEMSTaskBase::sleepFor(ms);
 };
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 42deaf09d..8646220d6 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -1,11 +1,11 @@
 #ifndef FSFW_OSAL_RTEMS_POLLINGTASK_H_
 #define FSFW_OSAL_RTEMS_POLLINGTASK_H_
 
+#include <fsfw/osal/rtems/RTEMSTaskBase.h>
 #include "../../tasks/FixedSlotSequence.h"
 #include "../../tasks/FixedTimeslotTaskIF.h"
-#include "TaskBase.h"
 
-class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
+class PollingTask: public RTEMSTaskBase, public FixedTimeslotTaskIF {
 	public:
 	/**
 	 * @brief	The standard constructor of the class.
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/RTEMSTaskBase.cpp
similarity index 75%
rename from osal/rtems/TaskBase.cpp
rename to osal/rtems/RTEMSTaskBase.cpp
index 7ad94b843..25d6d4981 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/RTEMSTaskBase.cpp
@@ -1,9 +1,9 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "TaskBase.h"
+#include <fsfw/osal/rtems/RTEMSTaskBase.h>
+#include "../../serviceinterface/ServiceInterface.h"
 
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE=RTEMS_MINIMUM_STACK_SIZE;
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = RTEMS_MINIMUM_STACK_SIZE;
 
-TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
+RTEMSTaskBase::RTEMSTaskBase(rtems_task_priority set_priority, size_t stack_size,
 		const char *name) {
 	rtems_name osalName = 0;
 	for (uint8_t i = 0; i < 4; i++) {
@@ -31,21 +31,21 @@ TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
 	}
 }
 
-TaskBase::~TaskBase() {
+RTEMSTaskBase::~RTEMSTaskBase() {
 	rtems_task_delete(id);
 }
 
-rtems_id TaskBase::getId() {
+rtems_id RTEMSTaskBase::getId() {
 	return this->id;
 }
 
-ReturnValue_t TaskBase::sleepFor(uint32_t ms) {
+ReturnValue_t RTEMSTaskBase::sleepFor(uint32_t ms) {
 	rtems_status_code status = rtems_task_wake_after(RtemsBasic::convertMsToTicks(ms));
 	return convertReturnCode(status);
 }
 
 
-ReturnValue_t TaskBase::convertReturnCode(rtems_status_code inValue) {
+ReturnValue_t RTEMSTaskBase::convertReturnCode(rtems_status_code inValue) {
 	switch (inValue) {
 	case RTEMS_SUCCESSFUL:
 		return HasReturnvaluesIF::RETURN_OK;
@@ -68,7 +68,7 @@ ReturnValue_t TaskBase::convertReturnCode(rtems_status_code inValue) {
 }
 
 
-ReturnValue_t TaskBase::setAndStartPeriod(rtems_interval period, rtems_id *periodId) {
+ReturnValue_t RTEMSTaskBase::setAndStartPeriod(rtems_interval period, rtems_id *periodId) {
 	rtems_name periodName = (('P' << 24) + ('e' << 16) + ('r' << 8) + 'd');
 	rtems_status_code status = rtems_rate_monotonic_create(periodName, periodId);
 	if (status == RTEMS_SUCCESSFUL) {
@@ -77,7 +77,7 @@ ReturnValue_t TaskBase::setAndStartPeriod(rtems_interval period, rtems_id *perio
 	return convertReturnCode(status);
 }
 
-rtems_status_code TaskBase::restartPeriod(rtems_interval period, rtems_id periodId){
+rtems_status_code RTEMSTaskBase::restartPeriod(rtems_interval period, rtems_id periodId){
 	//This is necessary to avoid a call with period = 0, which does not start the period.
 	rtems_status_code status = rtems_rate_monotonic_period(periodId, period + 1);
 	return status;
diff --git a/osal/rtems/TaskBase.h b/osal/rtems/RTEMSTaskBase.h
similarity index 84%
rename from osal/rtems/TaskBase.h
rename to osal/rtems/RTEMSTaskBase.h
index 0e186e671..0b8be3e90 100644
--- a/osal/rtems/TaskBase.h
+++ b/osal/rtems/RTEMSTaskBase.h
@@ -1,5 +1,5 @@
-#ifndef FSFW_OSAL_RTEMS_TASKBASE_H_
-#define FSFW_OSAL_RTEMS_TASKBASE_H_
+#ifndef FSFW_OSAL_RTEMS_RTEMSTASKBASE_H_
+#define FSFW_OSAL_RTEMS_RTEMSTASKBASE_H_
 
 #include "RtemsBasic.h"
 #include "../../tasks/PeriodicTaskIF.h"
@@ -9,7 +9,7 @@
  *
  * @details Task creation base class for rtems.
  */
-class TaskBase {
+class RTEMSTaskBase {
 protected:
 	/**
 	 * @brief	The class stores the task id it got assigned from the operating system in this attribute.
@@ -26,11 +26,11 @@ public:
 	 * @param stack_size	The stack size reserved by the operating system for the task.
 	 * @param nam			The name of the Task, as a null-terminated String. Currently max 4 chars supported (excluding Null-terminator), rest will be truncated
 	 */
-	TaskBase( rtems_task_priority priority, size_t stack_size, const char  *name);
+	RTEMSTaskBase( rtems_task_priority priority, size_t stack_size, const char  *name);
 	/**
 	 * @brief	In the destructor, the created task is deleted.
 	 */
-	virtual ~TaskBase();
+	virtual ~RTEMSTaskBase();
 	/**
 	 * @brief	This method returns the task id of this class.
 	 */
@@ -44,4 +44,4 @@ private:
 };
 
 
-#endif /* FSFW_OSAL_RTEMS_TASKBASE_H_ */
+#endif /* FSFW_OSAL_RTEMS_RTEMSTASKBASE_H_ */
diff --git a/osal/rtems/RtemsBasic.cpp b/osal/rtems/RtemsBasic.cpp
index 17cb3458b..8ab0ddcd6 100644
--- a/osal/rtems/RtemsBasic.cpp
+++ b/osal/rtems/RtemsBasic.cpp
@@ -1,5 +1,6 @@
 #include "RtemsBasic.h"
 
+// TODO: Can this be removed?
 
 //ReturnValue_t RtemsBasic::convertReturnCode(rtems_status_code inValue) {
 //	if (inValue == RTEMS_SUCCESSFUL) {
diff --git a/osal/rtems/RtemsBasic.h b/osal/rtems/RtemsBasic.h
index d0ca5abab..73f23186e 100644
--- a/osal/rtems/RtemsBasic.h
+++ b/osal/rtems/RtemsBasic.h
@@ -2,12 +2,13 @@
 #define FSFW_OSAL_RTEMS_RTEMSBASIC_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
+
 #include <rtems.h>
 #include <rtems/libio.h>
 #include <rtems/error.h>
 #include <rtems/stackchk.h>
-#include <stddef.h>
 
+#include <cstddef>
 
 class RtemsBasic {
 public:
diff --git a/osal/rtems/TaskFactory.cpp b/osal/rtems/TaskFactory.cpp
index bab48a44e..702ef8947 100644
--- a/osal/rtems/TaskFactory.cpp
+++ b/osal/rtems/TaskFactory.cpp
@@ -1,5 +1,5 @@
+#include <fsfw/osal/rtems/PeriodicTask.h>
 #include "../../tasks/TaskFactory.h"
-#include "MultiObjectTask.h"
 #include "PollingTask.h"
 #include "InitTask.h"
 #include "RtemsBasic.h"
@@ -18,7 +18,7 @@ TaskFactory* TaskFactory::instance() {
 PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
 	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
 
-	return static_cast<PeriodicTaskIF*>(new MultiObjectTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+	return static_cast<PeriodicTaskIF*>(new PeriodicTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
 }
 
 FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {

From 4136420685b28ea164b64eb843d3ff17599bc9d6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 11:42:24 +0100
Subject: [PATCH 1522/1774] additional common includes

---
 datapoollocal/StaticLocalDataSet.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index 4d1cc6378..08ef6de6a 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -2,6 +2,9 @@
 #define FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_
 
 #include "LocalPoolDataSetBase.h"
+#include "LocalPoolVariable.h"
+#include "LocalPoolVector.h"
+
 #include "../objectmanager/SystemObjectIF.h"
 #include <array>
 

From 686ae101eeb3a780aa05408e7192596a8e349e23 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 11:51:39 +0100
Subject: [PATCH 1523/1774] added enum type specification

---
 objectmanager/frameworkObjects.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 9810e33b9..a138b07ea 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -1,8 +1,10 @@
 #ifndef FSFW_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
 #define FSFW_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
 
+#include <fsfw/objectmanager/SystemObjectIF.h>
+
 namespace objects {
-enum framework_objects {
+enum framework_objects: object_id_t {
     FSFW_OBJECTS_START = 0x53000000,
     // Default verification reporter.
     PUS_SERVICE_1_VERIFICATION = 0x53000001,

From f40cdcf472fa49647fc26e405debf204153a14bb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 13:36:18 +0100
Subject: [PATCH 1524/1774] DHB adaptiosn and improvements, Srv8 update

service 8 does not finish immediately for data replies now
---
 devicehandlers/DeviceHandlerBase.cpp | 38 +++++++++++++---------------
 devicehandlers/DeviceHandlerBase.h   | 36 ++++++++++++++++----------
 pus/Service8FunctionManagement.cpp   |  1 +
 3 files changed, 40 insertions(+), 35 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 6092a89f8..ed5c8bda4 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1202,41 +1202,47 @@ ReturnValue_t DeviceHandlerBase::letChildHandleMessage(
 	return RETURN_FAILED;
 }
 
-void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
-		DeviceCommandId_t replyId, bool neverInDataPool, bool forceDirectTm) {
+void DeviceHandlerBase::handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId,
+        bool forceDirectTm = false) {
+    if(dataSet == nullptr) {
+        return;
+    }
+
 	DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
 	if (iter == deviceReplyMap.end()) {
 		triggerEvent(DEVICE_UNKNOWN_REPLY, replyId);
 		return;
 	}
-	DeviceTmReportingWrapper wrapper(getObjectId(), replyId, data);
-	//replies to a command
+
+	/* Regular 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 may fail, but we'll ignore the fault. */
+			actionHelper.reportData(queueId, replyId, dataSet);
 		}
 
 		//This check should make sure we get any TM but don't get anything doubled.
 		if (wiretappingMode == TM && (requestedRawTraffic != queueId)) {
+            DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataSet);
 			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
 		}
+
 		else if (forceDirectTm and (defaultRawReceiver != queueId) and
-					(defaultRawReceiver != MessageQueueIF::NO_QUEUE))
+		        (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);
+			actionHelper.reportData(defaultRawReceiver, replyId, dataSet, true);
 		}
 	}
-	//unrequested/aperiodic replies
+	/* Unrequested or aperiodic replies */
 	else
 	{
+	    DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataSet);
 		if (wiretappingMode == TM) {
 			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
 		}
@@ -1246,17 +1252,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 			// 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 (not neverInDataPool) {
-		LocalPoolDataSetBase* dataSet =
-				dynamic_cast<LocalPoolDataSetBase*>(data);
-		if (dataSet != nullptr) {
-			dataSet->setValidity(true, true);
-			dataSet->commit();
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper, true);
 		}
 	}
 }
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3a993aff0..52ec665fe 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -288,23 +288,29 @@ protected:
 	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
 
 	/**
-	 * @brief 	Build a device command packet from data supplied by a
-	 * 			direct command.
-	 *
+	 * @brief 	Build a device command packet from data supplied by a direct
+	 *          command (PUS Service 8)
 	 * @details
-	 * #rawPacket and #rawPacketLen should be set by this method to the packet
-	 * to be sent. The existence of the command in the command map and the
-	 * command size check against 0 are done by the base class.
+	 * This will be called if an functional command via PUS Service 8 is received and is
+	 * the primary interface for functional command instead of #executeAction for users. The
+	 * supplied ActionId_t action ID will be converted to a DeviceCommandId_t command ID after
+	 * an internal check whether the action ID is a key in the device command map.
 	 *
-	 * @param deviceCommand the command to build, already checked against
-	 * deviceCommandMap
-	 * @param commandData pointer to the data from the direct command
-	 * @param commandDataLen length of commandData
+	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
+	 * The existence of the command in the command map and the command size check against 0 are
+	 * done by the base class.
+	 *
+	 * @param deviceCommand     The command to build, already checked against deviceCommandMap
+	 * @param commandData       Pointer to the data from the direct command
+	 * @param commandDataLen    Length of commandData
 	 * @return
 	 *  - @c RETURN_OK to send command after #rawPacket and #rawPacketLen
 	 *       have been set.
-	 *  - Anything else triggers an event with the
-	 *    returnvalue as a parameter
+	 *  - @c HasActionsIF::EXECUTION_COMPLETE to generate a finish reply immediately. This can
+	 *       be used if no reply is expected. Otherwise, the developer can call #actionHelper.finish
+	 *       to finish the command handling.
+	 *  - Anything else triggers an event with the return code as a parameter as well as a
+	 *    step reply failed with the return code
 	 */
 	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
 			const uint8_t * commandData, size_t commandDataLen) = 0;
@@ -995,8 +1001,10 @@ protected:
 
 	bool isAwaitingReply();
 
-	void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t commandId,
-			bool neverInDataPool = false, bool forceDirectTm = false);
+	void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId,
+	        bool forceDirectTm = false);
+	void handleDeviceTM(uint8_t* data, size_t dataSize, DeviceCommandId_t replyId,
+	        bool forceDirectTm);
 
 	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
 			uint32_t *msToReachTheMode);
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 49fa6ebe4..e389b0b9e 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -104,6 +104,7 @@ ReturnValue_t Service8FunctionManagement::handleReply(
 		break;
 	}
 	case ActionMessage::DATA_REPLY: {
+	    *isStep = true;
 	    result = handleDataReply(reply, objectId, actionId);
 		break;
 	}

From 303679381436b1e5f5df41cc594001e99ca0e26d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 14:18:51 +0100
Subject: [PATCH 1525/1774] fsfw update

---
 action/ActionHelper.cpp              |  2 +-
 action/ActionHelper.h                |  2 +-
 devicehandlers/DeviceHandlerBase.cpp | 21 ++++++--
 devicehandlers/DeviceHandlerBase.h   | 78 +++++++++++++++-------------
 pus/Service8FunctionManagement.cpp   |  3 +-
 5 files changed, 62 insertions(+), 44 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 285579160..705b692bb 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -155,7 +155,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
         result = queueToUse->sendMessage(reportTo, &reply);
     }
 
-    if (result != HasReturnvaluesIF::RETURN_OK){
+    if (result != HasReturnvaluesIF::RETURN_OK) {
         ipcStore->deleteData(storeAddress);
     }
     return result;
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index a91722f39..d379e7161 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -99,7 +99,7 @@ public:
 	 */
 	void setQueueToUse(MessageQueueIF *queue);
 protected:
-	//!< Increase of value of this per step
+	//! Increase of value of this per step
 	static const uint8_t STEP_OFFSET = 1;
 	HasActionsIF* owner;//!< Pointer to the owner
 	//! Queue to be used as response sender, has to be set in ctor or with
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ed5c8bda4..ed5c1fa75 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1203,7 +1203,7 @@ ReturnValue_t DeviceHandlerBase::letChildHandleMessage(
 }
 
 void DeviceHandlerBase::handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId,
-        bool forceDirectTm = false) {
+        bool forceDirectTm) {
     if(dataSet == nullptr) {
         return;
     }
@@ -1224,7 +1224,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t r
 			actionHelper.reportData(queueId, replyId, dataSet);
 		}
 
-		//This check should make sure we get any TM but don't get anything doubled.
+		/* This check should make sure we get any TM but don't get anything doubled. */
 		if (wiretappingMode == TM && (requestedRawTraffic != queueId)) {
             DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataSet);
 			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
@@ -1246,9 +1246,14 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t r
 		if (wiretappingMode == TM) {
 			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
 		}
-		else if (forceDirectTm and defaultRawReceiver !=
-				MessageQueueIF::NO_QUEUE)
+		if (forceDirectTm and defaultRawReceiver != MessageQueueIF::NO_QUEUE)
 		{
+//		    sid_t setSid = sid_t(this->getObjectId(), replyId);
+//		    LocalPoolDataSetBase* dataset = getDataSetHandle(setSid);
+//		    if(dataset != nullptr) {
+//	            poolManager.generateHousekeepingPacket(setSid, dataset, true);
+//		    }
+
 			// hiding of sender needed so the service will handle it as
 			// unexpected Data, no matter what state (progress or completed)
 			// it is in
@@ -1527,3 +1532,11 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
 LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
     return &poolManager;
 }
+
+MessageQueueId_t DeviceHandlerBase::getCommanderId(DeviceCommandId_t replyId) const {
+    auto commandIter = deviceCommandMap.find(replyId);
+    if(commandIter == deviceCommandMap.end()) {
+        return MessageQueueIF::NO_QUEUE;
+    }
+    return commandIter->second.sendReplyTo;
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 52ec665fe..92dc9201a 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -189,6 +189,38 @@ public:
 	/** Destructor. */
 	virtual ~DeviceHandlerBase();
 
+
+    /**
+     * Implementation of ExecutableObjectIF function
+     * Used to setup the reference of the task, that executes this component
+     * @param task_ Pointer to the taskIF of this task
+     */
+    virtual  void setTaskIF(PeriodicTaskIF* task_) override;
+    virtual MessageQueueId_t getCommandQueue(void) const override;
+
+    /** Explicit interface implementation of getObjectId */
+    virtual object_id_t getObjectId() const override;
+
+    /**
+     * @param parentQueueId
+     */
+    virtual void setParentQueue(MessageQueueId_t parentQueueId);
+
+    /** @brief  Implementation required for HasActionIF */
+    ReturnValue_t executeAction(ActionId_t actionId,
+            MessageQueueId_t commandedBy, const uint8_t* data,
+            size_t size) override;
+
+    Mode_t getTransitionSourceMode() const;
+    Submode_t getTransitionSourceSubMode() const;
+    virtual void getMode(Mode_t *mode, Submode_t *submode);
+    HealthState getHealth();
+    ReturnValue_t setHealth(HealthState health);
+    virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+            ParameterWrapper *parameterWrapper,
+            const ParameterWrapper *newValues, uint16_t startAtIndex) override;
+
+
 protected:
 	/**
 	 * @brief 	This is used to let the child class handle the transition from
@@ -535,37 +567,6 @@ protected:
 	 */
 	virtual void performOperationHook();
 
-public:
-	/** Explicit interface implementation of getObjectId */
-	virtual object_id_t getObjectId() const override;
-
-	/**
-	 * @param parentQueueId
-	 */
-	virtual void setParentQueue(MessageQueueId_t parentQueueId);
-
-	/** @brief 	Implementation required for HasActionIF */
-	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data,
-			size_t size) override;
-
-	Mode_t getTransitionSourceMode() const;
-	Submode_t getTransitionSourceSubMode() const;
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-	HealthState getHealth();
-	ReturnValue_t setHealth(HealthState health);
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) override;
-	/**
-	 * Implementation of ExecutableObjectIF function
-	 *
-	 * Used to setup the reference of the task, that executes this component
-	 * @param task_ Pointer to the taskIF of this task
-	 */
-	virtual  void setTaskIF(PeriodicTaskIF* task_);
-	virtual MessageQueueId_t getCommandQueue(void) const;
-
 protected:
 	/**
 	 * The Returnvalues id of this class, required by HasReturnvaluesIF
@@ -573,16 +574,16 @@ protected:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
 
 	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(0xA0);
-	// Returnvalues for scanForReply()
+	/* Return codes for scanForReply */
 	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB0); //!< This is used to specify for replies from a device which are not replies to requests
 	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB1); //!< Ignore parts of the received packet
 	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB2); //!< Ignore full received packet
-	// Returnvalues for command building
+	/* Return codes for command building */
 	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0); //!< Return this if no command sending in required
 	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
-	// Returnvalues for getSwitches()
+	// Return codes for getSwitches */
 	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xD0);
-	// Mode handling error Codes
+	/* Mode handling error Codes */
 	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE0);
 	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE1);
 
@@ -769,6 +770,8 @@ protected:
 	 */
 	virtual void setNormalDatapoolEntriesInvalid();
 
+	MessageQueueId_t getCommanderId(DeviceCommandId_t replyId) const;
+
 	/**
 	 * Helper function to get pending command. This is useful for devices
 	 * like SPI sensors to identify the last sent command.
@@ -1003,8 +1006,8 @@ protected:
 
 	void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId,
 	        bool forceDirectTm = false);
-	void handleDeviceTM(uint8_t* data, size_t dataSize, DeviceCommandId_t replyId,
-	        bool forceDirectTm);
+//	void handleDeviceTM(uint8_t* data, size_t dataSize, DeviceCommandId_t replyId,
+//	        bool forceDirectTm);
 
 	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
 			uint32_t *msToReachTheMode);
@@ -1070,6 +1073,7 @@ protected:
 	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
 	 */
 	void commandSwitch(ReturnValue_t onOff);
+
 private:
 
 	/**
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index e389b0b9e..a2202abc1 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -104,13 +104,14 @@ ReturnValue_t Service8FunctionManagement::handleReply(
 		break;
 	}
 	case ActionMessage::DATA_REPLY: {
+	    /* Multiple data replies are possible, so declare data reply as step */
 	    *isStep = true;
 	    result = handleDataReply(reply, objectId, actionId);
 		break;
 	}
 	case ActionMessage::STEP_FAILED:
 		*isStep = true;
-		/*No break, falls through*/
+		/* No break, falls through */
 	case ActionMessage::COMPLETION_FAILED:
 		result = ActionMessage::getReturnCode(reply);
 		break;

From 942ecc89bd92e5e4bbfa61a441cad71bbd7f37fe Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 18:03:56 +0100
Subject: [PATCH 1526/1774] include updates

---
 monitoring/MonitoringMessageContent.h |  2 +-
 osal/rtems/PollingTask.cpp            | 14 ++++++++++----
 timemanager/Stopwatch.cpp             |  3 +++
 3 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index d830e3136..0314d7edc 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -10,7 +10,7 @@
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../serialize/SerializeElement.h"
 #include "../serialize/SerialLinkedListAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../timemanager/TimeStamperIF.h"
 
 namespace Factory{
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index 3c9a994ca..8cfec942d 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -1,18 +1,24 @@
+#include "PollingTask.h"
+#include "RtemsBasic.h"
+
 #include "../../tasks/FixedSequenceSlot.h"
 #include "../../objectmanager/SystemObjectIF.h"
 #include "../../objectmanager/ObjectManagerIF.h"
-#include "PollingTask.h"
-#include "RtemsBasic.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
+
 #include <rtems/bspIo.h>
 #include <rtems/rtems/ratemon.h>
 #include <rtems/rtems/status.h>
 #include <rtems/rtems/tasks.h>
 #include <rtems/rtems/types.h>
-#include <stddef.h>
 #include <sys/_stdint.h>
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 #include <iostream>
+#endif
+
+#include <cstddef>
 #include <list>
 
 uint32_t PollingTask::deadlineMissedCount = 0;
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 5d67e6c1f..04ccab726 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -1,6 +1,9 @@
 #include "Stopwatch.h"
 #include "../serviceinterface/ServiceInterface.h"
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 #include <iomanip>
+#endif
 
 Stopwatch::Stopwatch(bool displayOnDestruction,
         StopwatchDisplayMode displayMode): displayOnDestruction(

From 8a0431c5784145be98b4751331882711f437a04b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 18:12:12 +0100
Subject: [PATCH 1527/1774] renaming and cleaning up stuff

---
 ...{PollingTask.cpp => FixedTimeslotTask.cpp} | 41 ++++-----
 osal/rtems/FixedTimeslotTask.h                | 81 ++++++++++++++++++
 osal/rtems/MutexFactory.cpp                   |  5 +-
 osal/rtems/PollingTask.h                      | 85 -------------------
 osal/rtems/RTEMSTaskBase.cpp                  |  2 +-
 osal/rtems/TaskFactory.cpp                    | 21 +++--
 6 files changed, 120 insertions(+), 115 deletions(-)
 rename osal/rtems/{PollingTask.cpp => FixedTimeslotTask.cpp} (73%)
 create mode 100644 osal/rtems/FixedTimeslotTask.h
 delete mode 100644 osal/rtems/PollingTask.h

diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/FixedTimeslotTask.cpp
similarity index 73%
rename from osal/rtems/PollingTask.cpp
rename to osal/rtems/FixedTimeslotTask.cpp
index 8cfec942d..d31011626 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/FixedTimeslotTask.cpp
@@ -1,4 +1,4 @@
-#include "PollingTask.h"
+#include <fsfw/osal/rtems/FixedTimeslotTask.h>
 #include "RtemsBasic.h"
 
 #include "../../tasks/FixedSequenceSlot.h"
@@ -21,9 +21,9 @@
 #include <cstddef>
 #include <list>
 
-uint32_t PollingTask::deadlineMissedCount = 0;
+uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 
-PollingTask::PollingTask(const char *name, rtems_task_priority setPriority,
+FixedTimeslotTask::FixedTimeslotTask(const char *name, rtems_task_priority setPriority,
 		size_t setStack, uint32_t setOverallPeriod,
 		void (*setDeadlineMissedFunc)()) :
 		RTEMSTaskBase(setPriority, setStack, name), periodId(0), pst(
@@ -32,33 +32,34 @@ PollingTask::PollingTask(const char *name, rtems_task_priority setPriority,
 	this->deadlineMissedFunc = setDeadlineMissedFunc;
 }
 
-PollingTask::~PollingTask() {
+FixedTimeslotTask::~FixedTimeslotTask() {
 }
 
-rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
+rtems_task FixedTimeslotTask::taskEntryPoint(rtems_task_argument argument) {
 
 	//The argument is re-interpreted as PollingTask.
-	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
+	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
 	//The task's functionality is called.
-	originalTask->taskFunctionality();
+	return originalTask->taskFunctionality();
+	/* Should never be reached */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::debug << "Polling task " << originalTask->getId()
-			<< " returned from taskFunctionality." << std::endl;
+	sif::error << "Polling task " << originalTask->getId() << " returned from taskFunctionality." <<
+	        std::endl;
 #endif
 }
 
-void PollingTask::missedDeadlineCounter() {
-	PollingTask::deadlineMissedCount++;
-	if (PollingTask::deadlineMissedCount % 10 == 0) {
+void FixedTimeslotTask::missedDeadlineCounter() {
+	FixedTimeslotTask::deadlineMissedCount++;
+	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PST missed " << PollingTask::deadlineMissedCount
+		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
 #endif
 	}
 }
 
-ReturnValue_t PollingTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
+ReturnValue_t FixedTimeslotTask::startTask() {
+	rtems_status_code status = rtems_task_start(id, FixedTimeslotTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -79,7 +80,7 @@ ReturnValue_t PollingTask::startTask() {
 	}
 }
 
-ReturnValue_t PollingTask::addSlot(object_id_t componentId,
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	ExecutableObjectIF* object = objectManager->get<ExecutableObjectIF>(componentId);
 	if (object != nullptr) {
@@ -94,17 +95,17 @@ ReturnValue_t PollingTask::addSlot(object_id_t componentId,
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-uint32_t PollingTask::getPeriodMs() const {
+uint32_t FixedTimeslotTask::getPeriodMs() const {
 	return pst.getLengthMs();
 }
 
-ReturnValue_t PollingTask::checkSequence() const {
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
 	return pst.checkSequence();
 }
 
 #include <rtems/io.h>
 
-void PollingTask::taskFunctionality() {
+void FixedTimeslotTask::taskFunctionality() {
 	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
 	FixedSlotSequence::SlotListIter it = pst.current;
 
@@ -132,6 +133,6 @@ void PollingTask::taskFunctionality() {
 	}
 }
 
-ReturnValue_t PollingTask::sleepFor(uint32_t ms){
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms){
 	return RTEMSTaskBase::sleepFor(ms);
 };
diff --git a/osal/rtems/FixedTimeslotTask.h b/osal/rtems/FixedTimeslotTask.h
new file mode 100644
index 000000000..55f780883
--- /dev/null
+++ b/osal/rtems/FixedTimeslotTask.h
@@ -0,0 +1,81 @@
+#ifndef FSFW_OSAL_RTEMS_FIXEDTIMESLOTTASK_H_
+#define FSFW_OSAL_RTEMS_FIXEDTIMESLOTTASK_H_
+
+#include "RTEMSTaskBase.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+
+class FixedTimeslotTask: public RTEMSTaskBase, public FixedTimeslotTaskIF {
+public:
+    /**
+	 * @brief	The standard constructor of the class.
+	 * @details
+	 * This is the general constructor of the class. In addition to the TaskBase parameters,
+	 * the following variables are passed:
+	 * @param	setDeadlineMissedFunc   The function pointer to the deadline missed function
+	 *                                  that shall be assigned.
+	 * @param	getPst The object id of the completely initialized polling sequence.
+	 */
+	FixedTimeslotTask( const char *name, rtems_task_priority setPriority, size_t setStackSize,
+	        uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
+
+	/**
+	 * @brief	The destructor of the class.
+	 * @details
+	 * The destructor frees all heap memory that was allocated on thread initialization
+	 * for the PST andthe device handlers. This is done by calling the PST's destructor.
+	 */
+	virtual ~FixedTimeslotTask( void );
+
+	ReturnValue_t startTask( void );
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+	 */
+	static void missedDeadlineCounter();
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+
+	uint32_t getPeriodMs() const;
+
+	ReturnValue_t checkSequence() const;
+
+	ReturnValue_t sleepFor(uint32_t ms);
+protected:
+	/**
+	* @brief id of the associated OS period
+	*/
+	rtems_id periodId;
+
+	FixedSlotSequence pst;
+
+	/**
+	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
+	 *
+	 * @details
+	 * Another function may be announced to determine the actions to perform when a deadline
+	 * was missed. Currently, only one function for missing any deadline is allowed.
+	 * If not used, it shall be declared NULL.
+	 */
+	void ( *deadlineMissedFunc )( void ) = nullptr;
+	/**
+	 * @brief	This is the entry point in a new polling thread.
+	 * @details	This method is the entry point in the new thread
+	 */
+	static rtems_task taskEntryPoint( rtems_task_argument argument );
+
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 * @details
+	 * Holding the main functionality of the task, this method is most important.
+	 * It links the functionalities provided by FixedSlotSequence with the OS's system calls to
+	 * keep the timing of the periods.
+	 */
+	void taskFunctionality( void );
+};
+
+#endif /* FSFW_OSAL_RTEMS_FIXEDTIMESLOTTASK_H_ */
diff --git a/osal/rtems/MutexFactory.cpp b/osal/rtems/MutexFactory.cpp
index 24af5fa95..adc599e94 100644
--- a/osal/rtems/MutexFactory.cpp
+++ b/osal/rtems/MutexFactory.cpp
@@ -1,6 +1,7 @@
-#include "../../ipc/MutexFactory.h"
 #include "Mutex.h"
-#include "RtemsBasic.h"
+
+#include "../../ipc/MutexFactory.h"
+
 
 MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
 
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
deleted file mode 100644
index 8646220d6..000000000
--- a/osal/rtems/PollingTask.h
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef FSFW_OSAL_RTEMS_POLLINGTASK_H_
-#define FSFW_OSAL_RTEMS_POLLINGTASK_H_
-
-#include <fsfw/osal/rtems/RTEMSTaskBase.h>
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../tasks/FixedTimeslotTaskIF.h"
-
-class PollingTask: public RTEMSTaskBase, public FixedTimeslotTaskIF {
-	public:
-	/**
-	 * @brief	The standard constructor of the class.
-	 *
-	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
-	 * 			the following variables are passed:
-	 *
-	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
-	 *
-	 * @param	getPst The object id of the completely initialized polling sequence.
-	 */
-	PollingTask( const char *name, rtems_task_priority setPriority, size_t setStackSize, uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
-
-	/**
-	 * @brief	The destructor of the class.
-	 *
-	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
-	 * 			the device handlers. This is done by calling the PST's destructor.
-	 */
-	virtual ~PollingTask( void );
-
-	ReturnValue_t startTask( void );
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-	 */
-	static void missedDeadlineCounter();
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
-
-	uint32_t getPeriodMs() const;
-
-	ReturnValue_t checkSequence() const;
-
-	ReturnValue_t sleepFor(uint32_t ms);
-protected:
-	/**
-	* @brief id of the associated OS period
-	*/
-	rtems_id periodId;
-
-	FixedSlotSequence pst;
-
-	/**
-	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
-	 *
-	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
-	 * 			Currently, only one function for missing any deadline is allowed.
-	 * 			If not used, it shall be declared NULL.
-	 */
-	void ( *deadlineMissedFunc )( void );
-	/**
-	 * @brief	This is the entry point in a new polling thread.
-	 *
-	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
-	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
-	 * 			on success. If operation of the task is ended for some reason,
-	 * 			the destructor is called to free allocated memory.
-	 */
-	static rtems_task taskEntryPoint( rtems_task_argument argument );
-
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 *
-	 *
-	 * @details	Holding the main functionality of the task, this method is most important.
-	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
-	 * 			to keep the timing of the periods.
-	 */
-	void taskFunctionality( void );
-};
-
-#endif /* FSFW_OSAL_RTEMS_POLLINGTASK_H_ */
diff --git a/osal/rtems/RTEMSTaskBase.cpp b/osal/rtems/RTEMSTaskBase.cpp
index 25d6d4981..d0cdc8765 100644
--- a/osal/rtems/RTEMSTaskBase.cpp
+++ b/osal/rtems/RTEMSTaskBase.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/osal/rtems/RTEMSTaskBase.h>
+#include "RTEMSTaskBase.h"
 #include "../../serviceinterface/ServiceInterface.h"
 
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = RTEMS_MINIMUM_STACK_SIZE;
diff --git a/osal/rtems/TaskFactory.cpp b/osal/rtems/TaskFactory.cpp
index 702ef8947..5dad69fe5 100644
--- a/osal/rtems/TaskFactory.cpp
+++ b/osal/rtems/TaskFactory.cpp
@@ -1,8 +1,9 @@
-#include <fsfw/osal/rtems/PeriodicTask.h>
-#include "../../tasks/TaskFactory.h"
-#include "PollingTask.h"
+#include "FixedTimeslotTask.h"
+#include "PeriodicTask.h"
 #include "InitTask.h"
 #include "RtemsBasic.h"
+
+#include "../../tasks/TaskFactory.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 
 //TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
@@ -15,15 +16,21 @@ TaskFactory* TaskFactory::instance() {
 	return TaskFactory::factoryInstance;
 }
 
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_, TaskPriority taskPriority_,
+        TaskStackSize stackSize_,TaskPeriod periodInSeconds_,
+        TaskDeadlineMissedFunction deadLineMissedFunction_) {
 	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
 
-	return static_cast<PeriodicTaskIF*>(new PeriodicTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+	return static_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_, stackSize_,
+	        taskPeriod,deadLineMissedFunction_));
 }
 
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+        TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,
+        TaskDeadlineMissedFunction deadLineMissedFunction_) {
 	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
-	return static_cast<FixedTimeslotTaskIF*>(new PollingTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+	return static_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_, taskPriority_,
+	        stackSize_, taskPeriod, deadLineMissedFunction_));
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {

From 8b5abd1fd5ef2adc26df285facc369a5ec74ffb5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 18:12:48 +0100
Subject: [PATCH 1528/1774] corrected cmakelists.txt file

---
 osal/rtems/CMakeLists.txt        | 2 +-
 osal/rtems/FixedTimeslotTask.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/rtems/CMakeLists.txt b/osal/rtems/CMakeLists.txt
index ba11a6b5a..cd266125f 100644
--- a/osal/rtems/CMakeLists.txt
+++ b/osal/rtems/CMakeLists.txt
@@ -8,7 +8,7 @@ target_sources(${LIB_FSFW_NAME}
 		PeriodicTask.cpp
 		Mutex.cpp
 		MutexFactory.cpp
-		PollingTask.cpp
+		FixedTimeslotTask.cpp
 		QueueFactory.cpp
 		RtemsBasic.cpp
 		RTEMSTaskBase.cpp
diff --git a/osal/rtems/FixedTimeslotTask.cpp b/osal/rtems/FixedTimeslotTask.cpp
index d31011626..8b9354254 100644
--- a/osal/rtems/FixedTimeslotTask.cpp
+++ b/osal/rtems/FixedTimeslotTask.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/osal/rtems/FixedTimeslotTask.h>
+#include "FixedTimeslotTask.h"
 #include "RtemsBasic.h"
 
 #include "../../tasks/FixedSequenceSlot.h"

From a0e7b45d9427010ae4c631162af9034239f18040 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 18:15:54 +0100
Subject: [PATCH 1529/1774] printf support

---
 osal/rtems/Mutex.cpp | 12 +++++++-----
 osal/rtems/Mutex.h   |  2 +-
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index 7dd512fae..f65c1f55b 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -1,18 +1,20 @@
 #include "Mutex.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 uint8_t Mutex::count = 0;
 
-Mutex::Mutex() :
-		mutexId(0) {
+Mutex::Mutex() {
 	rtems_name mutexName = ('M' << 24) + ('T' << 16) + ('X' << 8) + count++;
 	rtems_status_code status = rtems_semaphore_create(mutexName, 1,
 	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
 			&mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
-				<< " failed with " << status << std::endl;
+		sif::error << "Mutex::Mutex: Creation with name, id " << mutexName << ", " << mutexId <<
+		        " failed with " << status << std::endl;
+#else
+		sif::printError("Mutex::Mutex: Creation with name, id %s, %d failed with %d\n", mutexName,
+		        static_cast<int>(mutexId), static_cast<int>(status));
 #endif
 	}
 }
diff --git a/osal/rtems/Mutex.h b/osal/rtems/Mutex.h
index 4c8613183..c4917e08a 100644
--- a/osal/rtems/Mutex.h
+++ b/osal/rtems/Mutex.h
@@ -11,7 +11,7 @@ public:
 	ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs = 0);
 	ReturnValue_t unlockMutex();
 private:
-	rtems_id mutexId;
+	rtems_id mutexId = 0;
 	static uint8_t count;
 };
 

From 73dcb78a65d0367d4a5ddaaf8ceba379d61a3990 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 20:04:16 +0100
Subject: [PATCH 1530/1774] additional nullptr checks

---
 objectmanager/ObjectManager.cpp | 4 +++-
 objectmanager/SystemObject.cpp  | 8 ++++++--
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 882d2762a..3c2be5321 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,5 +1,5 @@
 #include "ObjectManager.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 #include <iomanip>
@@ -75,6 +75,8 @@ void ObjectManager::initialize() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::initialize: Passed produceObjects "
 				"functions is nullptr!" << std::endl;
+#else
+		sif::printError("ObjectManager::initialize: Passed produceObjects functions is nullptr!\n");
 #endif
 		return;
 	}
diff --git a/objectmanager/SystemObject.cpp b/objectmanager/SystemObject.cpp
index 64330fbc9..9040002ca 100644
--- a/objectmanager/SystemObject.cpp
+++ b/objectmanager/SystemObject.cpp
@@ -5,13 +5,17 @@
 SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
 		objectId(setObjectId), registered(doRegister) {
 	if (registered) {
-		objectManager->insert(objectId, this);
+	    if(objectManager != nullptr) {
+	        objectManager->insert(objectId, this);
+	    }
 	}
 }
 
 SystemObject::~SystemObject() {
 	if (registered) {
-		objectManager->remove(objectId);
+	    if(objectManager != nullptr) {
+	        objectManager->remove(objectId);
+	    }
 	}
 }
 

From 2fce82db10f277d6a3f357fc1fef24da92ee0e32 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 22:51:50 +0100
Subject: [PATCH 1531/1774] bugfix for clock

---
 osal/rtems/Clock.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index 8bd7ac37e..9f4634cca 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -104,9 +104,13 @@ ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 }
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	// TIsn't this a bug? Are RTEMS ticks always microseconds?
+	/* For all but the last field, the struct will be filled with the correct values */
 	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
 	rtems_status_code status = rtems_clock_get_tod(timeRtems);
+	/* The last field now contains the RTEMS ticks of the seconds from 0
+    to rtems_clock_get_ticks_per_second() minus one. We calculate the microseconds accordingly */
+	timeRtems->ticks = static_cast<float>(timeRtems->ticks) /
+	        rtems_clock_get_ticks_per_second() * 1e6;
 	switch (status) {
 	case RTEMS_SUCCESSFUL:
 		return HasReturnvaluesIF::RETURN_OK;

From 3b7bebeb6f25c8d87b9448619db8b3fcb72a9bce Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 23:49:50 +0100
Subject: [PATCH 1532/1774] added init after task creation

---
 osal/rtems/PeriodicTask.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/osal/rtems/PeriodicTask.cpp b/osal/rtems/PeriodicTask.cpp
index 631fa8209..067983cb6 100644
--- a/osal/rtems/PeriodicTask.cpp
+++ b/osal/rtems/PeriodicTask.cpp
@@ -50,6 +50,9 @@ ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
 
 void PeriodicTask::taskFunctionality() {
     RTEMSTaskBase::setAndStartPeriod(periodTicks,&periodId);
+    for (const auto& object: objectList) {
+        object->initializeAfterTaskCreation();
+    }
     /* The task's "infinite" inner loop is entered. */
     while (1) {
         for (const auto& object: objectList) {

From f85ab2b300d7f605d000223b274db41912d75367 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 27 Jan 2021 23:52:09 +0100
Subject: [PATCH 1533/1774] emitting warning now

---
 datapoollocal/LocalDataPoolManager.cpp | 4 ++--
 datapoollocal/LocalDataPoolManager.h   | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 16a4aec28..2c5c4e0ea 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -890,7 +890,7 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
 		sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
-				owner->getObjectId(), errorPrint);
+				functionName, owner->getObjectId(), errorPrint);
 #endif
 	}
 	else if(outputType == sif::OutputTypes::OUT_ERROR) {
@@ -901,7 +901,7 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
 		sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
-				owner->getObjectId(), errorPrint);
+				functionName, owner->getObjectId(), errorPrint);
 #endif
 	}
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index d13dfbc30..05c6adfd6 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -399,14 +399,14 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
         PoolEntry<T> **poolEntry) {
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
-        printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
+        printWarningOrError(sif::OutputTypes::OUT_WARNING, "fetchPoolEntry",
                 localpool::POOL_ENTRY_NOT_FOUND);
         return localpool::POOL_ENTRY_NOT_FOUND;
     }
 
     *poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
     if(*poolEntry == nullptr) {
-        printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
+        printWarningOrError(sif::OutputTypes::OUT_WARNING, "fetchPoolEntry",
                 localpool::POOL_ENTRY_TYPE_CONFLICT);
         return localpool::POOL_ENTRY_TYPE_CONFLICT;
     }

From 5b0758638b6a81cd984036e910adaa4b39879961 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 28 Jan 2021 00:00:26 +0100
Subject: [PATCH 1534/1774] added missing function is fixed timeslot task

---
 osal/rtems/FixedTimeslotTask.cpp | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/osal/rtems/FixedTimeslotTask.cpp b/osal/rtems/FixedTimeslotTask.cpp
index 8b9354254..ce8eadcfc 100644
--- a/osal/rtems/FixedTimeslotTask.cpp
+++ b/osal/rtems/FixedTimeslotTask.cpp
@@ -8,6 +8,7 @@
 #include "../../serviceinterface/ServiceInterface.h"
 
 #include <rtems/bspIo.h>
+#include <rtems/io.h>
 #include <rtems/rtems/ratemon.h>
 #include <rtems/rtems/status.h>
 #include <rtems/rtems/tasks.h>
@@ -103,20 +104,23 @@ ReturnValue_t FixedTimeslotTask::checkSequence() const {
 	return pst.checkSequence();
 }
 
-#include <rtems/io.h>
-
 void FixedTimeslotTask::taskFunctionality() {
-	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
+	/* A local iterator for the Polling Sequence Table is created to find the start time for
+	the first entry. */
 	FixedSlotSequence::SlotListIter it = pst.current;
 
-	//The start time for the first entry is read.
+	/* Initialize the PST with the correct calling task */
+	pst.intializeSequenceAfterTaskCreation();
+
+	/* The start time for the first entry is read. */
 	rtems_interval interval = RtemsBasic::convertMsToTicks(it->pollingTimeMs);
 	RTEMSTaskBase::setAndStartPeriod(interval,&periodId);
 	//The task's "infinite" inner loop is entered.
 	while (1) {
 		if (pst.slotFollowsImmediately()) {
 			//Do nothing
-		} else {
+		}
+		else {
 			//The interval for the next polling slot is selected.
 			interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
 			//The period is checked and restarted with the new interval.

From dcb569a7c853cf7273a5504fab7f99479a155290 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 28 Jan 2021 00:15:13 +0100
Subject: [PATCH 1535/1774] indentation

---
 osal/rtems/FixedTimeslotTask.cpp | 142 +++++++++++++++----------------
 osal/rtems/FixedTimeslotTask.h   | 116 ++++++++++++-------------
 2 files changed, 128 insertions(+), 130 deletions(-)

diff --git a/osal/rtems/FixedTimeslotTask.cpp b/osal/rtems/FixedTimeslotTask.cpp
index ce8eadcfc..3a3be6b32 100644
--- a/osal/rtems/FixedTimeslotTask.cpp
+++ b/osal/rtems/FixedTimeslotTask.cpp
@@ -25,118 +25,116 @@
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 
 FixedTimeslotTask::FixedTimeslotTask(const char *name, rtems_task_priority setPriority,
-		size_t setStack, uint32_t setOverallPeriod,
-		void (*setDeadlineMissedFunc)()) :
-		RTEMSTaskBase(setPriority, setStack, name), periodId(0), pst(
-				setOverallPeriod) {
-	// All additional attributes are applied to the object.
-	this->deadlineMissedFunc = setDeadlineMissedFunc;
+        size_t setStack, uint32_t setOverallPeriod, void (*setDeadlineMissedFunc)(void)):
+		RTEMSTaskBase(setPriority, setStack, name), periodId(0), pst(setOverallPeriod) {
+    // All additional attributes are applied to the object.
+    this->deadlineMissedFunc = setDeadlineMissedFunc;
 }
 
 FixedTimeslotTask::~FixedTimeslotTask() {
 }
 
 rtems_task FixedTimeslotTask::taskEntryPoint(rtems_task_argument argument) {
-
-	//The argument is re-interpreted as PollingTask.
-	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
-	//The task's functionality is called.
-	return originalTask->taskFunctionality();
-	/* Should never be reached */
+    /* The argument is re-interpreted as a FixedTimeslotTask */
+    FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+    /* The task's functionality is called. */
+    return originalTask->taskFunctionality();
+    /* Should never be reached */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::error << "Polling task " << originalTask->getId() << " returned from taskFunctionality." <<
-	        std::endl;
+    sif::error << "Polling task " << originalTask->getId() << " returned from taskFunctionality." <<
+            std::endl;
 #endif
 }
 
 void FixedTimeslotTask::missedDeadlineCounter() {
-	FixedTimeslotTask::deadlineMissedCount++;
-	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+    FixedTimeslotTask::deadlineMissedCount++;
+    if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
-				<< " deadlines." << std::endl;
+        sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
+                << " deadlines." << std::endl;
 #endif
-	}
+    }
 }
 
 ReturnValue_t FixedTimeslotTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, FixedTimeslotTask::taskEntryPoint,
-			rtems_task_argument((void *) this));
-	if (status != RTEMS_SUCCESSFUL) {
+    rtems_status_code status = rtems_task_start(id, FixedTimeslotTask::taskEntryPoint,
+            rtems_task_argument((void *) this));
+    if (status != RTEMS_SUCCESSFUL) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PollingTask::startTask for " << std::hex << this->getId()
-				<< std::dec << " failed." << std::endl;
+        sif::error << "PollingTask::startTask for " << std::hex << this->getId()
+				        << std::dec << " failed." << std::endl;
 #endif
-	}
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ask started successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-/*		RTEMS_INVALID_ADDRESS - invalid task entry point
+    }
+    switch(status){
+    case RTEMS_SUCCESSFUL:
+        //ask started successfully
+        return HasReturnvaluesIF::RETURN_OK;
+    default:
+        /*
+	    RTEMS_INVALID_ADDRESS - invalid task entry point
 		RTEMS_INVALID_ID - invalid task id
 		RTEMS_INCORRECT_STATE - task not in the dormant state
 		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-	ExecutableObjectIF* object = objectManager->get<ExecutableObjectIF>(componentId);
-	if (object != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, object, this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+        uint32_t slotTimeMs, int8_t executionStep) {
+    ExecutableObjectIF* object = objectManager->get<ExecutableObjectIF>(componentId);
+    if (object != nullptr) {
+        pst.addSlot(componentId, slotTimeMs, executionStep, object, this);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
+    sif::error << "Component " << std::hex << componentId <<
+            " not found, not adding it to pst" << std::endl;
 #endif
-	return HasReturnvaluesIF::RETURN_FAILED;
+    return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 uint32_t FixedTimeslotTask::getPeriodMs() const {
-	return pst.getLengthMs();
+    return pst.getLengthMs();
 }
 
 ReturnValue_t FixedTimeslotTask::checkSequence() const {
-	return pst.checkSequence();
+    return pst.checkSequence();
 }
 
 void FixedTimeslotTask::taskFunctionality() {
-	/* A local iterator for the Polling Sequence Table is created to find the start time for
+    /* A local iterator for the Polling Sequence Table is created to find the start time for
 	the first entry. */
-	FixedSlotSequence::SlotListIter it = pst.current;
+    FixedSlotSequence::SlotListIter it = pst.current;
 
-	/* Initialize the PST with the correct calling task */
-	pst.intializeSequenceAfterTaskCreation();
+    /* Initialize the PST with the correct calling task */
+    pst.intializeSequenceAfterTaskCreation();
 
-	/* The start time for the first entry is read. */
-	rtems_interval interval = RtemsBasic::convertMsToTicks(it->pollingTimeMs);
-	RTEMSTaskBase::setAndStartPeriod(interval,&periodId);
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		}
-		else {
-			//The interval for the next polling slot is selected.
-			interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
-			//The period is checked and restarted with the new interval.
-			//If the deadline was missed, the deadlineMissedFunc is called.
-			rtems_status_code status = RTEMSTaskBase::restartPeriod(interval,periodId);
-			if (status == RTEMS_TIMEOUT) {
-				if (this->deadlineMissedFunc != nullptr) {
-					this->deadlineMissedFunc();
-				}
-			}
-		}
-		//The device handler for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-	}
+    /* The start time for the first entry is read. */
+    rtems_interval interval = RtemsBasic::convertMsToTicks(it->pollingTimeMs);
+    RTEMSTaskBase::setAndStartPeriod(interval,&periodId);
+    //The task's "infinite" inner loop is entered.
+    while (1) {
+        if (pst.slotFollowsImmediately()) {
+            /* Do nothing */
+        }
+        else {
+            /* The interval for the next polling slot is selected. */
+            interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
+            /* The period is checked and restarted with the new interval.
+			If the deadline was missed, the deadlineMissedFunc is called. */
+            rtems_status_code status = RTEMSTaskBase::restartPeriod(interval,periodId);
+            if (status == RTEMS_TIMEOUT) {
+                if (this->deadlineMissedFunc != nullptr) {
+                    this->deadlineMissedFunc();
+                }
+            }
+        }
+        /* The device handler for this slot is executed and the next one is chosen. */
+        this->pst.executeAndAdvance();
+    }
 }
 
 ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms){
-	return RTEMSTaskBase::sleepFor(ms);
+    return RTEMSTaskBase::sleepFor(ms);
 };
diff --git a/osal/rtems/FixedTimeslotTask.h b/osal/rtems/FixedTimeslotTask.h
index 55f780883..0d78c4748 100644
--- a/osal/rtems/FixedTimeslotTask.h
+++ b/osal/rtems/FixedTimeslotTask.h
@@ -8,74 +8,74 @@
 class FixedTimeslotTask: public RTEMSTaskBase, public FixedTimeslotTaskIF {
 public:
     /**
-	 * @brief	The standard constructor of the class.
-	 * @details
-	 * This is the general constructor of the class. In addition to the TaskBase parameters,
-	 * the following variables are passed:
-	 * @param	setDeadlineMissedFunc   The function pointer to the deadline missed function
-	 *                                  that shall be assigned.
-	 * @param	getPst The object id of the completely initialized polling sequence.
-	 */
-	FixedTimeslotTask( const char *name, rtems_task_priority setPriority, size_t setStackSize,
-	        uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
+     * @brief	The standard constructor of the class.
+     * @details
+     * This is the general constructor of the class. In addition to the TaskBase parameters,
+     * the following variables are passed:
+     * @param	setDeadlineMissedFunc   The function pointer to the deadline missed function
+     *                                  that shall be assigned.
+     * @param	getPst The object id of the completely initialized polling sequence.
+     */
+    FixedTimeslotTask( const char *name, rtems_task_priority setPriority, size_t setStackSize,
+            uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
 
-	/**
-	 * @brief	The destructor of the class.
-	 * @details
-	 * The destructor frees all heap memory that was allocated on thread initialization
-	 * for the PST andthe device handlers. This is done by calling the PST's destructor.
-	 */
-	virtual ~FixedTimeslotTask( void );
+    /**
+     * @brief	The destructor of the class.
+     * @details
+     * The destructor frees all heap memory that was allocated on thread initialization
+     * for the PST andthe device handlers. This is done by calling the PST's destructor.
+     */
+    virtual ~FixedTimeslotTask( void );
 
-	ReturnValue_t startTask( void );
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-	 */
-	static void missedDeadlineCounter();
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
+    ReturnValue_t startTask( void );
+    /**
+     * This static function can be used as #deadlineMissedFunc.
+     * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+     */
+    static void missedDeadlineCounter();
+    /**
+     * A helper variable to count missed deadlines.
+     */
+    static uint32_t deadlineMissedCount;
 
-	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+    ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
 
-	uint32_t getPeriodMs() const;
+    uint32_t getPeriodMs() const;
 
-	ReturnValue_t checkSequence() const;
+    ReturnValue_t checkSequence() const;
 
-	ReturnValue_t sleepFor(uint32_t ms);
+    ReturnValue_t sleepFor(uint32_t ms);
 protected:
-	/**
-	* @brief id of the associated OS period
-	*/
-	rtems_id periodId;
+    /**
+     * @brief id of the associated OS period
+     */
+    rtems_id periodId;
 
-	FixedSlotSequence pst;
+    FixedSlotSequence pst;
 
-	/**
-	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
-	 *
-	 * @details
-	 * Another function may be announced to determine the actions to perform when a deadline
-	 * was missed. Currently, only one function for missing any deadline is allowed.
-	 * If not used, it shall be declared NULL.
-	 */
-	void ( *deadlineMissedFunc )( void ) = nullptr;
-	/**
-	 * @brief	This is the entry point in a new polling thread.
-	 * @details	This method is the entry point in the new thread
-	 */
-	static rtems_task taskEntryPoint( rtems_task_argument argument );
+    /**
+     * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
+     *
+     * @details
+     * Another function may be announced to determine the actions to perform when a deadline
+     * was missed. Currently, only one function for missing any deadline is allowed.
+     * If not used, it shall be declared NULL.
+     */
+    void ( *deadlineMissedFunc )( void ) = nullptr;
+    /**
+     * @brief	This is the entry point in a new polling thread.
+     * @details	This method is the entry point in the new thread
+     */
+    static rtems_task taskEntryPoint( rtems_task_argument argument );
 
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 * @details
-	 * Holding the main functionality of the task, this method is most important.
-	 * It links the functionalities provided by FixedSlotSequence with the OS's system calls to
-	 * keep the timing of the periods.
-	 */
-	void taskFunctionality( void );
+    /**
+     * @brief	This function holds the main functionality of the thread.
+     * @details
+     * Holding the main functionality of the task, this method is most important.
+     * It links the functionalities provided by FixedSlotSequence with the OS's system calls to
+     * keep the timing of the periods.
+     */
+    void taskFunctionality( void );
 };
 
 #endif /* FSFW_OSAL_RTEMS_FIXEDTIMESLOTTASK_H_ */

From 17a1ae9d0e11e749cbe31012fe133c95ef9c7ae2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 28 Jan 2021 11:28:28 +0100
Subject: [PATCH 1536/1774] rtems bugfixes and updates only

---
 osal/rtems/CMakeLists.txt                     |   6 +-
 osal/rtems/Clock.cpp                          |   6 +-
 osal/rtems/CpuUsage.cpp                       |   2 +-
 osal/rtems/FixedTimeslotTask.cpp              | 140 ++++++++++++++++++
 osal/rtems/FixedTimeslotTask.h                |  81 ++++++++++
 osal/rtems/MultiObjectTask.cpp                |  92 ------------
 osal/rtems/Mutex.cpp                          |  12 +-
 osal/rtems/Mutex.h                            |   2 +-
 osal/rtems/MutexFactory.cpp                   |   5 +-
 osal/rtems/PeriodicTask.cpp                   |  83 +++++++++++
 .../{MultiObjectTask.h => PeriodicTask.h}     |  18 +--
 osal/rtems/PollingTask.cpp                    | 131 ----------------
 osal/rtems/PollingTask.h                      |  85 -----------
 osal/rtems/RTEMSTaskBase.cpp                  |  84 +++++++++++
 osal/rtems/RTEMSTaskBase.h                    |  47 ++++++
 osal/rtems/RtemsBasic.cpp                     |   1 +
 osal/rtems/RtemsBasic.h                       |   3 +-
 osal/rtems/TaskFactory.cpp                    |  21 ++-
 18 files changed, 481 insertions(+), 338 deletions(-)
 create mode 100644 osal/rtems/FixedTimeslotTask.cpp
 create mode 100644 osal/rtems/FixedTimeslotTask.h
 delete mode 100644 osal/rtems/MultiObjectTask.cpp
 create mode 100644 osal/rtems/PeriodicTask.cpp
 rename osal/rtems/{MultiObjectTask.h => PeriodicTask.h} (90%)
 delete mode 100644 osal/rtems/PollingTask.cpp
 delete mode 100644 osal/rtems/PollingTask.h
 create mode 100644 osal/rtems/RTEMSTaskBase.cpp
 create mode 100644 osal/rtems/RTEMSTaskBase.h

diff --git a/osal/rtems/CMakeLists.txt b/osal/rtems/CMakeLists.txt
index bff031842..cd266125f 100644
--- a/osal/rtems/CMakeLists.txt
+++ b/osal/rtems/CMakeLists.txt
@@ -5,13 +5,13 @@ target_sources(${LIB_FSFW_NAME}
 		InitTask.cpp
 		InternalErrorCodes.cpp
 		MessageQueue.cpp
-		MultiObjectTask.cpp
+		PeriodicTask.cpp
 		Mutex.cpp
 		MutexFactory.cpp
-		PollingTask.cpp
+		FixedTimeslotTask.cpp
 		QueueFactory.cpp
 		RtemsBasic.cpp
-		TaskBase.cpp
+		RTEMSTaskBase.cpp
 		TaskFactory.cpp
 )
 
diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index 8bd7ac37e..9f4634cca 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -104,9 +104,13 @@ ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 }
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	// TIsn't this a bug? Are RTEMS ticks always microseconds?
+	/* For all but the last field, the struct will be filled with the correct values */
 	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
 	rtems_status_code status = rtems_clock_get_tod(timeRtems);
+	/* The last field now contains the RTEMS ticks of the seconds from 0
+    to rtems_clock_get_ticks_per_second() minus one. We calculate the microseconds accordingly */
+	timeRtems->ticks = static_cast<float>(timeRtems->ticks) /
+	        rtems_clock_get_ticks_per_second() * 1e6;
 	switch (status) {
 	case RTEMS_SUCCESSFUL:
 		return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index 6655c69b6..89c01336a 100644
--- a/osal/rtems/CpuUsage.cpp
+++ b/osal/rtems/CpuUsage.cpp
@@ -164,7 +164,7 @@ ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if ((*size = *size - MAX_LENGTH_OF_THREAD_NAME) < 0) {
+	if (*size < MAX_LENGTH_OF_THREAD_NAME) {
 		return STREAM_TOO_SHORT;
 	}
 	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
diff --git a/osal/rtems/FixedTimeslotTask.cpp b/osal/rtems/FixedTimeslotTask.cpp
new file mode 100644
index 000000000..3a3be6b32
--- /dev/null
+++ b/osal/rtems/FixedTimeslotTask.cpp
@@ -0,0 +1,140 @@
+#include "FixedTimeslotTask.h"
+#include "RtemsBasic.h"
+
+#include "../../tasks/FixedSequenceSlot.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../serviceinterface/ServiceInterface.h"
+
+#include <rtems/bspIo.h>
+#include <rtems/io.h>
+#include <rtems/rtems/ratemon.h>
+#include <rtems/rtems/status.h>
+#include <rtems/rtems/tasks.h>
+#include <rtems/rtems/types.h>
+#include <sys/_stdint.h>
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+#include <iostream>
+#endif
+
+#include <cstddef>
+#include <list>
+
+uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
+
+FixedTimeslotTask::FixedTimeslotTask(const char *name, rtems_task_priority setPriority,
+        size_t setStack, uint32_t setOverallPeriod, void (*setDeadlineMissedFunc)(void)):
+		RTEMSTaskBase(setPriority, setStack, name), periodId(0), pst(setOverallPeriod) {
+    // All additional attributes are applied to the object.
+    this->deadlineMissedFunc = setDeadlineMissedFunc;
+}
+
+FixedTimeslotTask::~FixedTimeslotTask() {
+}
+
+rtems_task FixedTimeslotTask::taskEntryPoint(rtems_task_argument argument) {
+    /* The argument is re-interpreted as a FixedTimeslotTask */
+    FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+    /* The task's functionality is called. */
+    return originalTask->taskFunctionality();
+    /* Should never be reached */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "Polling task " << originalTask->getId() << " returned from taskFunctionality." <<
+            std::endl;
+#endif
+}
+
+void FixedTimeslotTask::missedDeadlineCounter() {
+    FixedTimeslotTask::deadlineMissedCount++;
+    if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
+                << " deadlines." << std::endl;
+#endif
+    }
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+    rtems_status_code status = rtems_task_start(id, FixedTimeslotTask::taskEntryPoint,
+            rtems_task_argument((void *) this));
+    if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "PollingTask::startTask for " << std::hex << this->getId()
+				        << std::dec << " failed." << std::endl;
+#endif
+    }
+    switch(status){
+    case RTEMS_SUCCESSFUL:
+        //ask started successfully
+        return HasReturnvaluesIF::RETURN_OK;
+    default:
+        /*
+	    RTEMS_INVALID_ADDRESS - invalid task entry point
+		RTEMS_INVALID_ID - invalid task id
+		RTEMS_INCORRECT_STATE - task not in the dormant state
+		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+        uint32_t slotTimeMs, int8_t executionStep) {
+    ExecutableObjectIF* object = objectManager->get<ExecutableObjectIF>(componentId);
+    if (object != nullptr) {
+        pst.addSlot(componentId, slotTimeMs, executionStep, object, this);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "Component " << std::hex << componentId <<
+            " not found, not adding it to pst" << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+    return pst.getLengthMs();
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+    return pst.checkSequence();
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+    /* A local iterator for the Polling Sequence Table is created to find the start time for
+	the first entry. */
+    FixedSlotSequence::SlotListIter it = pst.current;
+
+    /* Initialize the PST with the correct calling task */
+    pst.intializeSequenceAfterTaskCreation();
+
+    /* The start time for the first entry is read. */
+    rtems_interval interval = RtemsBasic::convertMsToTicks(it->pollingTimeMs);
+    RTEMSTaskBase::setAndStartPeriod(interval,&periodId);
+    //The task's "infinite" inner loop is entered.
+    while (1) {
+        if (pst.slotFollowsImmediately()) {
+            /* Do nothing */
+        }
+        else {
+            /* The interval for the next polling slot is selected. */
+            interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
+            /* The period is checked and restarted with the new interval.
+			If the deadline was missed, the deadlineMissedFunc is called. */
+            rtems_status_code status = RTEMSTaskBase::restartPeriod(interval,periodId);
+            if (status == RTEMS_TIMEOUT) {
+                if (this->deadlineMissedFunc != nullptr) {
+                    this->deadlineMissedFunc();
+                }
+            }
+        }
+        /* The device handler for this slot is executed and the next one is chosen. */
+        this->pst.executeAndAdvance();
+    }
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms){
+    return RTEMSTaskBase::sleepFor(ms);
+};
diff --git a/osal/rtems/FixedTimeslotTask.h b/osal/rtems/FixedTimeslotTask.h
new file mode 100644
index 000000000..0d78c4748
--- /dev/null
+++ b/osal/rtems/FixedTimeslotTask.h
@@ -0,0 +1,81 @@
+#ifndef FSFW_OSAL_RTEMS_FIXEDTIMESLOTTASK_H_
+#define FSFW_OSAL_RTEMS_FIXEDTIMESLOTTASK_H_
+
+#include "RTEMSTaskBase.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+
+class FixedTimeslotTask: public RTEMSTaskBase, public FixedTimeslotTaskIF {
+public:
+    /**
+     * @brief	The standard constructor of the class.
+     * @details
+     * This is the general constructor of the class. In addition to the TaskBase parameters,
+     * the following variables are passed:
+     * @param	setDeadlineMissedFunc   The function pointer to the deadline missed function
+     *                                  that shall be assigned.
+     * @param	getPst The object id of the completely initialized polling sequence.
+     */
+    FixedTimeslotTask( const char *name, rtems_task_priority setPriority, size_t setStackSize,
+            uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
+
+    /**
+     * @brief	The destructor of the class.
+     * @details
+     * The destructor frees all heap memory that was allocated on thread initialization
+     * for the PST andthe device handlers. This is done by calling the PST's destructor.
+     */
+    virtual ~FixedTimeslotTask( void );
+
+    ReturnValue_t startTask( void );
+    /**
+     * This static function can be used as #deadlineMissedFunc.
+     * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+     */
+    static void missedDeadlineCounter();
+    /**
+     * A helper variable to count missed deadlines.
+     */
+    static uint32_t deadlineMissedCount;
+
+    ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+
+    uint32_t getPeriodMs() const;
+
+    ReturnValue_t checkSequence() const;
+
+    ReturnValue_t sleepFor(uint32_t ms);
+protected:
+    /**
+     * @brief id of the associated OS period
+     */
+    rtems_id periodId;
+
+    FixedSlotSequence pst;
+
+    /**
+     * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
+     *
+     * @details
+     * Another function may be announced to determine the actions to perform when a deadline
+     * was missed. Currently, only one function for missing any deadline is allowed.
+     * If not used, it shall be declared NULL.
+     */
+    void ( *deadlineMissedFunc )( void ) = nullptr;
+    /**
+     * @brief	This is the entry point in a new polling thread.
+     * @details	This method is the entry point in the new thread
+     */
+    static rtems_task taskEntryPoint( rtems_task_argument argument );
+
+    /**
+     * @brief	This function holds the main functionality of the thread.
+     * @details
+     * Holding the main functionality of the task, this method is most important.
+     * It links the functionalities provided by FixedSlotSequence with the OS's system calls to
+     * keep the timing of the periods.
+     */
+    void taskFunctionality( void );
+};
+
+#endif /* FSFW_OSAL_RTEMS_FIXEDTIMESLOTTASK_H_ */
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
deleted file mode 100644
index b111f724c..000000000
--- a/osal/rtems/MultiObjectTask.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * @file	MultiObjectTask.cpp
- * @brief	This file defines the MultiObjectTask class.
- * @date	30.01.2014
- * @author	baetz
- */
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tasks/ExecutableObjectIF.h"
-#include "MultiObjectTask.h"
-
-MultiObjectTask::MultiObjectTask(const char *name, rtems_task_priority setPriority,
-		size_t setStack, rtems_interval setPeriod, void (*setDeadlineMissedFunc)()) :
-		TaskBase(setPriority, setStack, name), periodTicks(
-				RtemsBasic::convertMsToTicks(setPeriod)), periodId(0), deadlineMissedFunc(
-				setDeadlineMissedFunc) {
-}
-
-MultiObjectTask::~MultiObjectTask(void) {
-	//Do not delete objects, we were responsible for ptrs only.
-	rtems_rate_monotonic_delete(periodId);
-}
-rtems_task MultiObjectTask::taskEntryPoint(rtems_task_argument argument) {
-	//The argument is re-interpreted as MultiObjectTask. The Task object is global, so it is found from any place.
-	MultiObjectTask *originalTask(reinterpret_cast<MultiObjectTask*>(argument));
-	originalTask->taskFunctionality();
-}
-
-ReturnValue_t MultiObjectTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
-			rtems_task_argument((void *) this));
-	if (status != RTEMS_SUCCESSFUL) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "ObjectTask::startTask for " << std::hex << this->getId()
-				<< std::dec << " failed." << std::endl;
-#endif
-	}
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ask started successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-/*		RTEMS_INVALID_ADDRESS - invalid task entry point
-		RTEMS_INVALID_ID - invalid task id
-		RTEMS_INCORRECT_STATE - task not in the dormant state
-		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t MultiObjectTask::sleepFor(uint32_t ms) {
-	return TaskBase::sleepFor(ms);
-}
-
-void MultiObjectTask::taskFunctionality() {
-	TaskBase::setAndStartPeriod(periodTicks,&periodId);
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
-		}
-		rtems_status_code status = TaskBase::restartPeriod(periodTicks,periodId);
-		if (status == RTEMS_TIMEOUT) {
-			char nameSpace[8] = { 0 };
-			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
-					nameSpace);
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
-#endif
-			if (this->deadlineMissedFunc != nullptr) {
-				this->deadlineMissedFunc();
-			}
-		}
-	}
-}
-
-ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	newObject->setTaskIF(this);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t MultiObjectTask::getPeriodMs() const {
-	return RtemsBasic::convertTicksToMs(periodTicks);
-}
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index 7dd512fae..f65c1f55b 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -1,18 +1,20 @@
 #include "Mutex.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 uint8_t Mutex::count = 0;
 
-Mutex::Mutex() :
-		mutexId(0) {
+Mutex::Mutex() {
 	rtems_name mutexName = ('M' << 24) + ('T' << 16) + ('X' << 8) + count++;
 	rtems_status_code status = rtems_semaphore_create(mutexName, 1,
 	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
 			&mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
-				<< " failed with " << status << std::endl;
+		sif::error << "Mutex::Mutex: Creation with name, id " << mutexName << ", " << mutexId <<
+		        " failed with " << status << std::endl;
+#else
+		sif::printError("Mutex::Mutex: Creation with name, id %s, %d failed with %d\n", mutexName,
+		        static_cast<int>(mutexId), static_cast<int>(status));
 #endif
 	}
 }
diff --git a/osal/rtems/Mutex.h b/osal/rtems/Mutex.h
index 4c8613183..c4917e08a 100644
--- a/osal/rtems/Mutex.h
+++ b/osal/rtems/Mutex.h
@@ -11,7 +11,7 @@ public:
 	ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs = 0);
 	ReturnValue_t unlockMutex();
 private:
-	rtems_id mutexId;
+	rtems_id mutexId = 0;
 	static uint8_t count;
 };
 
diff --git a/osal/rtems/MutexFactory.cpp b/osal/rtems/MutexFactory.cpp
index 24af5fa95..adc599e94 100644
--- a/osal/rtems/MutexFactory.cpp
+++ b/osal/rtems/MutexFactory.cpp
@@ -1,6 +1,7 @@
-#include "../../ipc/MutexFactory.h"
 #include "Mutex.h"
-#include "RtemsBasic.h"
+
+#include "../../ipc/MutexFactory.h"
+
 
 MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
 
diff --git a/osal/rtems/PeriodicTask.cpp b/osal/rtems/PeriodicTask.cpp
new file mode 100644
index 000000000..067983cb6
--- /dev/null
+++ b/osal/rtems/PeriodicTask.cpp
@@ -0,0 +1,83 @@
+#include "PeriodicTask.h"
+
+#include "../../serviceinterface/ServiceInterface.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+PeriodicTask::PeriodicTask(const char *name, rtems_task_priority setPriority,
+        size_t setStack, rtems_interval setPeriod, void (*setDeadlineMissedFunc)()) :
+        RTEMSTaskBase(setPriority, setStack, name),
+        periodTicks(RtemsBasic::convertMsToTicks(setPeriod)),
+        deadlineMissedFunc(setDeadlineMissedFunc) {
+}
+
+PeriodicTask::~PeriodicTask(void) {
+    /* Do not delete objects, we were responsible for pointers only. */
+    rtems_rate_monotonic_delete(periodId);
+}
+
+rtems_task PeriodicTask::taskEntryPoint(rtems_task_argument argument) {
+    /* The argument is re-interpreted as MultiObjectTask. The Task object is global,
+    so it is found from any place. */
+    PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
+    return originalTask->taskFunctionality();;
+}
+
+ReturnValue_t PeriodicTask::startTask() {
+    rtems_status_code status = rtems_task_start(id, PeriodicTask::taskEntryPoint,
+            rtems_task_argument((void *) this));
+    if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "ObjectTask::startTask for " << std::hex << this->getId()
+				        << std::dec << " failed." << std::endl;
+#endif
+    }
+    switch(status){
+    case RTEMS_SUCCESSFUL:
+        /* Task started successfully */
+        return HasReturnvaluesIF::RETURN_OK;
+    default:
+        /* RTEMS_INVALID_ADDRESS - invalid task entry point
+		RTEMS_INVALID_ID - invalid task id
+		RTEMS_INCORRECT_STATE - task not in the dormant state
+		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+}
+
+ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
+    return RTEMSTaskBase::sleepFor(ms);
+}
+
+void PeriodicTask::taskFunctionality() {
+    RTEMSTaskBase::setAndStartPeriod(periodTicks,&periodId);
+    for (const auto& object: objectList) {
+        object->initializeAfterTaskCreation();
+    }
+    /* The task's "infinite" inner loop is entered. */
+    while (1) {
+        for (const auto& object: objectList) {
+            object->performOperation();
+        }
+        rtems_status_code status = RTEMSTaskBase::restartPeriod(periodTicks,periodId);
+        if (status == RTEMS_TIMEOUT) {
+            if (this->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);
+    newObject->setTaskIF(this);
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t PeriodicTask::getPeriodMs() const {
+    return RtemsBasic::convertTicksToMs(periodTicks);
+}
diff --git a/osal/rtems/MultiObjectTask.h b/osal/rtems/PeriodicTask.h
similarity index 90%
rename from osal/rtems/MultiObjectTask.h
rename to osal/rtems/PeriodicTask.h
index 04d122a3d..2ecce457a 100644
--- a/osal/rtems/MultiObjectTask.h
+++ b/osal/rtems/PeriodicTask.h
@@ -1,10 +1,10 @@
-#ifndef FSFW_OSAL_RTEMS_MULTIOBJECTTASK_H_
-#define FSFW_OSAL_RTEMS_MULTIOBJECTTASK_H_
+#ifndef FSFW_OSAL_RTEMS_PERIODICTASK_H_
+#define FSFW_OSAL_RTEMS_PERIODICTASK_H_
 
+#include "RTEMSTaskBase.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../tasks/PeriodicTaskIF.h"
 
-#include "TaskBase.h"
 #include <vector>
 
 class ExecutableObjectIF;
@@ -18,7 +18,7 @@ class ExecutableObjectIF;
  * @author  baetz
  * @ingroup task_handling
  */
-class MultiObjectTask: public TaskBase, public PeriodicTaskIF {
+class PeriodicTask: public RTEMSTaskBase, public PeriodicTaskIF {
 public:
 	/**
 	 * @brief	Standard constructor of the class.
@@ -35,13 +35,13 @@ public:
 	 * @param setDeadlineMissedFunc	The function pointer to the deadline missed function
 	 * 								that shall be assigned.
 	 */
-	MultiObjectTask(const char *name, rtems_task_priority setPriority, size_t setStack, rtems_interval setPeriod,
-			void (*setDeadlineMissedFunc)());
+	PeriodicTask(const char *name, rtems_task_priority setPriority, size_t setStack,
+	        rtems_interval 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 ~MultiObjectTask(void);
+	virtual ~PeriodicTask(void);
 
 	/**
 	 * @brief	The method to start the task.
@@ -76,7 +76,7 @@ protected:
 	/**
 	 * @brief id of the associated OS period
 	 */
-	rtems_id periodId;
+	rtems_id periodId = 0;
 	/**
 	 * @brief	The pointer to the deadline-missed function.
 	 * @details	This pointer stores the function that is executed if the task's deadline is missed.
@@ -104,4 +104,4 @@ protected:
 	void taskFunctionality(void);
 };
 
-#endif /* FSFW_OSAL_RTEMS_MULTIOBJECTTASK_H_ */
+#endif /* FSFW_OSAL_RTEMS_PERIODICTASK_H_ */
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
deleted file mode 100644
index 0ebf63e2e..000000000
--- a/osal/rtems/PollingTask.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-#include "../../tasks/FixedSequenceSlot.h"
-#include "../../objectmanager/SystemObjectIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "PollingTask.h"
-#include "RtemsBasic.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include <rtems/bspIo.h>
-#include <rtems/rtems/ratemon.h>
-#include <rtems/rtems/status.h>
-#include <rtems/rtems/tasks.h>
-#include <rtems/rtems/types.h>
-#include <stddef.h>
-#include <sys/_stdint.h>
-#include <iostream>
-#include <list>
-
-uint32_t PollingTask::deadlineMissedCount = 0;
-
-PollingTask::PollingTask(const char *name, rtems_task_priority setPriority,
-		size_t setStack, uint32_t setOverallPeriod,
-		void (*setDeadlineMissedFunc)()) :
-		TaskBase(setPriority, setStack, name), periodId(0), pst(
-				setOverallPeriod) {
-	// All additional attributes are applied to the object.
-	this->deadlineMissedFunc = setDeadlineMissedFunc;
-}
-
-PollingTask::~PollingTask() {
-}
-
-rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
-
-	//The argument is re-interpreted as PollingTask.
-	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::debug << "Polling task " << originalTask->getId()
-			<< " returned from taskFunctionality." << std::endl;
-#endif
-}
-
-void PollingTask::missedDeadlineCounter() {
-	PollingTask::deadlineMissedCount++;
-	if (PollingTask::deadlineMissedCount % 10 == 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PST missed " << PollingTask::deadlineMissedCount
-				<< " deadlines." << std::endl;
-#endif
-	}
-}
-
-ReturnValue_t PollingTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
-			rtems_task_argument((void *) this));
-	if (status != RTEMS_SUCCESSFUL) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PollingTask::startTask for " << std::hex << this->getId()
-				<< std::dec << " failed." << std::endl;
-#endif
-	}
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ask started successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-/*		RTEMS_INVALID_ADDRESS - invalid task entry point
-		RTEMS_INVALID_ID - invalid task id
-		RTEMS_INCORRECT_STATE - task not in the dormant state
-		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t PollingTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-	ExecutableObjectIF* object = objectManager->get<ExecutableObjectIF>(componentId);
-	if (object != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, object, this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
-#endif
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t PollingTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t PollingTask::checkSequence() const {
-	return pst.checkSequence();
-}
-
-#include <rtems/io.h>
-
-void PollingTask::taskFunctionality() {
-	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
-	FixedSlotSequence::SlotListIter it = pst.current;
-
-	//The start time for the first entry is read.
-	rtems_interval interval = RtemsBasic::convertMsToTicks(it->pollingTimeMs);
-	TaskBase::setAndStartPeriod(interval,&periodId);
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		} else {
-			//The interval for the next polling slot is selected.
-			interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
-			//The period is checked and restarted with the new interval.
-			//If the deadline was missed, the deadlineMissedFunc is called.
-			rtems_status_code status = TaskBase::restartPeriod(interval,periodId);
-			if (status == RTEMS_TIMEOUT) {
-				if (this->deadlineMissedFunc != nullptr) {
-					this->deadlineMissedFunc();
-				}
-			}
-		}
-		//The device handler for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-	}
-}
-
-ReturnValue_t PollingTask::sleepFor(uint32_t ms){
-	return TaskBase::sleepFor(ms);
-};
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
deleted file mode 100644
index 42deaf09d..000000000
--- a/osal/rtems/PollingTask.h
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef FSFW_OSAL_RTEMS_POLLINGTASK_H_
-#define FSFW_OSAL_RTEMS_POLLINGTASK_H_
-
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../tasks/FixedTimeslotTaskIF.h"
-#include "TaskBase.h"
-
-class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
-	public:
-	/**
-	 * @brief	The standard constructor of the class.
-	 *
-	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
-	 * 			the following variables are passed:
-	 *
-	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
-	 *
-	 * @param	getPst The object id of the completely initialized polling sequence.
-	 */
-	PollingTask( const char *name, rtems_task_priority setPriority, size_t setStackSize, uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
-
-	/**
-	 * @brief	The destructor of the class.
-	 *
-	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
-	 * 			the device handlers. This is done by calling the PST's destructor.
-	 */
-	virtual ~PollingTask( void );
-
-	ReturnValue_t startTask( void );
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-	 */
-	static void missedDeadlineCounter();
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
-
-	uint32_t getPeriodMs() const;
-
-	ReturnValue_t checkSequence() const;
-
-	ReturnValue_t sleepFor(uint32_t ms);
-protected:
-	/**
-	* @brief id of the associated OS period
-	*/
-	rtems_id periodId;
-
-	FixedSlotSequence pst;
-
-	/**
-	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
-	 *
-	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
-	 * 			Currently, only one function for missing any deadline is allowed.
-	 * 			If not used, it shall be declared NULL.
-	 */
-	void ( *deadlineMissedFunc )( void );
-	/**
-	 * @brief	This is the entry point in a new polling thread.
-	 *
-	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
-	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
-	 * 			on success. If operation of the task is ended for some reason,
-	 * 			the destructor is called to free allocated memory.
-	 */
-	static rtems_task taskEntryPoint( rtems_task_argument argument );
-
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 *
-	 *
-	 * @details	Holding the main functionality of the task, this method is most important.
-	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
-	 * 			to keep the timing of the periods.
-	 */
-	void taskFunctionality( void );
-};
-
-#endif /* FSFW_OSAL_RTEMS_POLLINGTASK_H_ */
diff --git a/osal/rtems/RTEMSTaskBase.cpp b/osal/rtems/RTEMSTaskBase.cpp
new file mode 100644
index 000000000..d0cdc8765
--- /dev/null
+++ b/osal/rtems/RTEMSTaskBase.cpp
@@ -0,0 +1,84 @@
+#include "RTEMSTaskBase.h"
+#include "../../serviceinterface/ServiceInterface.h"
+
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = RTEMS_MINIMUM_STACK_SIZE;
+
+RTEMSTaskBase::RTEMSTaskBase(rtems_task_priority set_priority, size_t stack_size,
+		const char *name) {
+	rtems_name osalName = 0;
+	for (uint8_t i = 0; i < 4; i++) {
+		if (name[i] == 0) {
+			break;
+		}
+		osalName += name[i] << (8 * (3 - i));
+	}
+	//The task is created with the operating system's system call.
+	rtems_status_code status = RTEMS_UNSATISFIED;
+	if (set_priority <= 99) {
+		 status = rtems_task_create(osalName,
+				(0xFF - 2 * set_priority), stack_size,
+				RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
+				RTEMS_FLOATING_POINT, &id);
+	}
+	ReturnValue_t result = convertReturnCode(status);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::error << "TaskBase::TaskBase: createTask with name " << std::hex
+				<< osalName << std::dec << " failed with return code "
+				<< (uint32_t) status << std::endl;
+#endif
+		this->id = 0;
+	}
+}
+
+RTEMSTaskBase::~RTEMSTaskBase() {
+	rtems_task_delete(id);
+}
+
+rtems_id RTEMSTaskBase::getId() {
+	return this->id;
+}
+
+ReturnValue_t RTEMSTaskBase::sleepFor(uint32_t ms) {
+	rtems_status_code status = rtems_task_wake_after(RtemsBasic::convertMsToTicks(ms));
+	return convertReturnCode(status);
+}
+
+
+ReturnValue_t RTEMSTaskBase::convertReturnCode(rtems_status_code inValue) {
+	switch (inValue) {
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_MP_NOT_CONFIGURED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_NAME:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_TOO_MANY:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_UNSATISFIED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_PRIORITY:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+}
+
+
+ReturnValue_t RTEMSTaskBase::setAndStartPeriod(rtems_interval period, rtems_id *periodId) {
+	rtems_name periodName = (('P' << 24) + ('e' << 16) + ('r' << 8) + 'd');
+	rtems_status_code status = rtems_rate_monotonic_create(periodName, periodId);
+	if (status == RTEMS_SUCCESSFUL) {
+		status = restartPeriod(period,*periodId);
+	}
+	return convertReturnCode(status);
+}
+
+rtems_status_code RTEMSTaskBase::restartPeriod(rtems_interval period, rtems_id periodId){
+	//This is necessary to avoid a call with period = 0, which does not start the period.
+	rtems_status_code status = rtems_rate_monotonic_period(periodId, period + 1);
+	return status;
+}
diff --git a/osal/rtems/RTEMSTaskBase.h b/osal/rtems/RTEMSTaskBase.h
new file mode 100644
index 000000000..0b8be3e90
--- /dev/null
+++ b/osal/rtems/RTEMSTaskBase.h
@@ -0,0 +1,47 @@
+#ifndef FSFW_OSAL_RTEMS_RTEMSTASKBASE_H_
+#define FSFW_OSAL_RTEMS_RTEMSTASKBASE_H_
+
+#include "RtemsBasic.h"
+#include "../../tasks/PeriodicTaskIF.h"
+
+/**
+ * @brief	This is the basic task handling class for rtems.
+ *
+ * @details Task creation base class for rtems.
+ */
+class RTEMSTaskBase {
+protected:
+	/**
+	 * @brief	The class stores the task id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the id is set to zero.
+	 */
+	rtems_id id;
+public:
+	/**
+	 * @brief	The constructor creates and initializes a task.
+	 * @details	This is accomplished by using the operating system call to create a task. The name is
+	 * 			created automatically with the help od taskCounter. Priority and stack size are
+	 * 			adjustable, all other attributes are set with default values.
+	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
+	 * @param stack_size	The stack size reserved by the operating system for the task.
+	 * @param nam			The name of the Task, as a null-terminated String. Currently max 4 chars supported (excluding Null-terminator), rest will be truncated
+	 */
+	RTEMSTaskBase( rtems_task_priority priority, size_t stack_size, const char  *name);
+	/**
+	 * @brief	In the destructor, the created task is deleted.
+	 */
+	virtual ~RTEMSTaskBase();
+	/**
+	 * @brief	This method returns the task id of this class.
+	 */
+	rtems_id getId();
+
+	ReturnValue_t sleepFor(uint32_t ms);
+	static ReturnValue_t setAndStartPeriod(rtems_interval period, rtems_id *periodId);
+	static rtems_status_code restartPeriod(rtems_interval period, rtems_id periodId);
+private:
+	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
+};
+
+
+#endif /* FSFW_OSAL_RTEMS_RTEMSTASKBASE_H_ */
diff --git a/osal/rtems/RtemsBasic.cpp b/osal/rtems/RtemsBasic.cpp
index 17cb3458b..8ab0ddcd6 100644
--- a/osal/rtems/RtemsBasic.cpp
+++ b/osal/rtems/RtemsBasic.cpp
@@ -1,5 +1,6 @@
 #include "RtemsBasic.h"
 
+// TODO: Can this be removed?
 
 //ReturnValue_t RtemsBasic::convertReturnCode(rtems_status_code inValue) {
 //	if (inValue == RTEMS_SUCCESSFUL) {
diff --git a/osal/rtems/RtemsBasic.h b/osal/rtems/RtemsBasic.h
index d0ca5abab..73f23186e 100644
--- a/osal/rtems/RtemsBasic.h
+++ b/osal/rtems/RtemsBasic.h
@@ -2,12 +2,13 @@
 #define FSFW_OSAL_RTEMS_RTEMSBASIC_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
+
 #include <rtems.h>
 #include <rtems/libio.h>
 #include <rtems/error.h>
 #include <rtems/stackchk.h>
-#include <stddef.h>
 
+#include <cstddef>
 
 class RtemsBasic {
 public:
diff --git a/osal/rtems/TaskFactory.cpp b/osal/rtems/TaskFactory.cpp
index bab48a44e..5dad69fe5 100644
--- a/osal/rtems/TaskFactory.cpp
+++ b/osal/rtems/TaskFactory.cpp
@@ -1,8 +1,9 @@
-#include "../../tasks/TaskFactory.h"
-#include "MultiObjectTask.h"
-#include "PollingTask.h"
+#include "FixedTimeslotTask.h"
+#include "PeriodicTask.h"
 #include "InitTask.h"
 #include "RtemsBasic.h"
+
+#include "../../tasks/TaskFactory.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 
 //TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
@@ -15,15 +16,21 @@ TaskFactory* TaskFactory::instance() {
 	return TaskFactory::factoryInstance;
 }
 
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_, TaskPriority taskPriority_,
+        TaskStackSize stackSize_,TaskPeriod periodInSeconds_,
+        TaskDeadlineMissedFunction deadLineMissedFunction_) {
 	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
 
-	return static_cast<PeriodicTaskIF*>(new MultiObjectTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+	return static_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_, stackSize_,
+	        taskPeriod,deadLineMissedFunction_));
 }
 
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+        TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,
+        TaskDeadlineMissedFunction deadLineMissedFunction_) {
 	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
-	return static_cast<FixedTimeslotTaskIF*>(new PollingTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+	return static_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_, taskPriority_,
+	        stackSize_, taskPeriod, deadLineMissedFunction_));
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {

From 76d81b5b494686cd64378d333ce85fca50d09bd2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 28 Jan 2021 11:38:45 +0100
Subject: [PATCH 1537/1774] replaced tab by spaces

---
 action/ActionHelper.cpp        | 164 ++++++++++++++--------------
 action/ActionHelper.h          | 176 +++++++++++++++---------------
 action/ActionMessage.cpp       |  86 +++++++--------
 action/ActionMessage.h         |  44 ++++----
 action/CommandActionHelper.cpp | 188 ++++++++++++++++-----------------
 action/CommandActionHelper.h   |  36 +++----
 action/CommandsActionsIF.h     |  28 ++---
 action/HasActionsIF.h          |  44 ++++----
 action/SimpleActionHelper.cpp  | 102 +++++++++---------
 action/SimpleActionHelper.h    |  30 +++---
 10 files changed, 449 insertions(+), 449 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 705b692bb..23c9d7329 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -6,120 +6,120 @@
 
 ActionHelper::ActionHelper(HasActionsIF* setOwner,
         MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue) {
+        owner(setOwner), queueToUse(useThisQueue) {
 }
 
 ActionHelper::~ActionHelper() {
 }
 
 ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
-	if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
-		ActionId_t currentAction = ActionMessage::getActionId(command);
-		prepareExecution(command->getSender(), currentAction,
-				ActionMessage::getStoreId(command));
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return CommandMessage::UNKNOWN_COMMAND;
-	}
+    if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
+        ActionId_t currentAction = ActionMessage::getActionId(command);
+        prepareExecution(command->getSender(), currentAction,
+                ActionMessage::getStoreId(command));
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return CommandMessage::UNKNOWN_COMMAND;
+    }
 }
 
 ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(queueToUse_ != nullptr) {
-		setQueueToUse(queueToUse_);
-	}
+    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if (ipcStore == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    if(queueToUse_ != nullptr) {
+        setQueueToUse(queueToUse_);
+    }
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo,
         ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
-	queueToUse->sendMessage(reportTo, &reply);
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
+    queueToUse->sendMessage(reportTo, &reply);
 }
 
 void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId,
         ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setCompletionReply(&reply, commandId, result);
-	queueToUse->sendMessage(reportTo, &reply);
+    CommandMessage reply;
+    ActionMessage::setCompletionReply(&reply, commandId, result);
+    queueToUse->sendMessage(reportTo, &reply);
 }
 
 void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
-	queueToUse = queue;
+    queueToUse = queue;
 }
 
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
         ActionId_t actionId, store_address_t dataAddress) {
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	if(result == HasActionsIF::EXECUTION_FINISHED) {
-		CommandMessage reply;
-		ActionMessage::setCompletionReply(&reply, actionId, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-	}
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
+    const uint8_t* dataPtr = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        CommandMessage reply;
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
+    result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+    ipcStore->deleteData(dataAddress);
+    if(result == HasActionsIF::EXECUTION_FINISHED) {
+        CommandMessage reply;
+        ActionMessage::setCompletionReply(&reply, actionId, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+    }
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        CommandMessage reply;
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
 }
 
 ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
-		ActionId_t replyId, SerializeIF* data, bool hideSender) {
-	CommandMessage reply;
-	store_address_t storeAddress;
-	uint8_t *dataPtr;
-	size_t maxSize = data->getSerializedSize();
-	if (maxSize == 0) {
-		//No error, there's simply nothing to report.
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
-			&dataPtr);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = data->serialize(&dataPtr, &size, maxSize,
-	        SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeAddress);
-		return result;
-	}
-	// We don't need to report the objectId, as we receive REQUESTED data
-	// before the completion success message.
-	// True aperiodic replies need to be reported with
-	// another dedicated message.
-	ActionMessage::setDataReply(&reply, replyId, storeAddress);
+        ActionId_t replyId, SerializeIF* data, bool hideSender) {
+    CommandMessage reply;
+    store_address_t storeAddress;
+    uint8_t *dataPtr;
+    size_t maxSize = data->getSerializedSize();
+    if (maxSize == 0) {
+        //No error, there's simply nothing to report.
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
+            &dataPtr);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = data->serialize(&dataPtr, &size, maxSize,
+            SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeAddress);
+        return result;
+    }
+    // We don't need to report the objectId, as we receive REQUESTED data
+    // before the completion success message.
+    // True aperiodic replies need to be reported with
+    // another dedicated message.
+    ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
     // If the sender needs to be hidden, for example to handle packet
     // as unrequested reply, this will be done here.
-	if (hideSender) {
-		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
-	}
-	else {
-		result = queueToUse->sendMessage(reportTo, &reply);
-	}
+    if (hideSender) {
+        result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+    }
+    else {
+        result = queueToUse->sendMessage(reportTo, &reply);
+    }
 
-	if (result != HasReturnvaluesIF::RETURN_OK){
-		ipcStore->deleteData(storeAddress);
-	}
-	return result;
+    if (result != HasReturnvaluesIF::RETURN_OK){
+        ipcStore->deleteData(storeAddress);
+    }
+    return result;
 }
 
 void ActionHelper::resetHelper() {
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index d379e7161..ae971d382 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -18,68 +18,68 @@ class HasActionsIF;
 
 class ActionHelper {
 public:
-	/**
-	 * Constructor of the action helper
-	 * @param setOwner Pointer to the owner of the interface
-	 * @param useThisQueue  messageQueue to be used, can be set during
-	 *                      initialize function as well.
-	 */
-	ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+    /**
+     * Constructor of the action helper
+     * @param setOwner Pointer to the owner of the interface
+     * @param useThisQueue  messageQueue to be used, can be set during
+     *                      initialize function as well.
+     */
+    ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
 
-	virtual ~ActionHelper();
-	/**
-	 * Function to be called from the owner with a new command message
-	 *
-	 * If the message is a valid action message the helper will use the
-	 * executeAction function from HasActionsIF.
-	 * If the message is invalid or the callback fails a message reply will be
-	 * send to the sender of the message automatically.
-	 *
-	 * @param command Pointer to a command message received by the owner
-	 * @return HasReturnvaluesIF::RETURN_OK if the message is a action message,
-	 *         CommandMessage::UNKNOW_COMMAND if this message ID is unkown
-	 */
-	ReturnValue_t handleActionMessage(CommandMessage* command);
-	/**
-	 * Helper initialize function. Must be called before use of any other
-	 * helper function
-	 * @param queueToUse_   Pointer to the messageQueue to be used, optional
-	 *                      if queue was set in constructor
-	 * @return Returns RETURN_OK if successful
-	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
-	/**
-	 * Function to be called from the owner to send a step message.
-	 * Success or failure will be determined by the result value.
-	 *
-	 * @param step Number of steps already done
-	 * @param reportTo The messageQueueId to report the step message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void step(uint8_t step, MessageQueueId_t reportTo,
-			ActionId_t commandId,
-			ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner to send a action completion message
-	 *
-	 * @param reportTo MessageQueueId_t to report the action completion message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void finish(MessageQueueId_t reportTo, ActionId_t commandId,
-	        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner if an action does report data.
-	 * Takes a SerializeIF* pointer and serializes it into the IPC store.
-	 * @param reportTo  MessageQueueId_t to report the action completion
-	 *                  message to
-	 * @param replyId ID of the executed command
-	 * @param data Pointer to the data
-	 * @return Returns RETURN_OK if successful, otherwise failure code
-	 */
-	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
-	        SerializeIF* data, bool hideSender = false);
+    virtual ~ActionHelper();
+    /**
+     * Function to be called from the owner with a new command message
+     *
+     * If the message is a valid action message the helper will use the
+     * executeAction function from HasActionsIF.
+     * If the message is invalid or the callback fails a message reply will be
+     * send to the sender of the message automatically.
+     *
+     * @param command Pointer to a command message received by the owner
+     * @return HasReturnvaluesIF::RETURN_OK if the message is a action message,
+     *         CommandMessage::UNKNOW_COMMAND if this message ID is unkown
+     */
+    ReturnValue_t handleActionMessage(CommandMessage* command);
+    /**
+     * Helper initialize function. Must be called before use of any other
+     * helper function
+     * @param queueToUse_   Pointer to the messageQueue to be used, optional
+     *                      if queue was set in constructor
+     * @return Returns RETURN_OK if successful
+     */
+    ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
+    /**
+     * Function to be called from the owner to send a step message.
+     * Success or failure will be determined by the result value.
+     *
+     * @param step Number of steps already done
+     * @param reportTo The messageQueueId to report the step message to
+     * @param commandId ID of the executed command
+     * @param result Result of the execution
+     */
+    void step(uint8_t step, MessageQueueId_t reportTo,
+            ActionId_t commandId,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    /**
+     * Function to be called by the owner to send a action completion message
+     *
+     * @param reportTo MessageQueueId_t to report the action completion message to
+     * @param commandId ID of the executed command
+     * @param result Result of the execution
+     */
+    void finish(MessageQueueId_t reportTo, ActionId_t commandId,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    /**
+     * Function to be called by the owner if an action does report data.
+     * Takes a SerializeIF* pointer and serializes it into the IPC store.
+     * @param reportTo  MessageQueueId_t to report the action completion
+     *                  message to
+     * @param replyId ID of the executed command
+     * @param data Pointer to the data
+     * @return Returns RETURN_OK if successful, otherwise failure code
+     */
+    ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
+            SerializeIF* data, bool hideSender = false);
     /**
      * Function to be called by the owner if an action does report data.
      * Takes the raw data and writes it into the IPC store.
@@ -91,35 +91,35 @@ public:
      */
     ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
             const uint8_t* data, size_t dataSize, bool hideSender = false);
-	/**
-	 * Function to setup the MessageQueueIF* of the helper. Can be used to
-	 * set the MessageQueueIF* if message queue is unavailable at construction
-	 * and initialize but must be setup before first call of other functions.
-	 * @param queue Queue to be used by the helper
-	 */
-	void setQueueToUse(MessageQueueIF *queue);
+    /**
+     * Function to setup the MessageQueueIF* of the helper. Can be used to
+     * set the MessageQueueIF* if message queue is unavailable at construction
+     * and initialize but must be setup before first call of other functions.
+     * @param queue Queue to be used by the helper
+     */
+    void setQueueToUse(MessageQueueIF *queue);
 protected:
-	//! Increase of value of this per step
-	static const uint8_t STEP_OFFSET = 1;
-	HasActionsIF* owner;//!< Pointer to the owner
-	//! Queue to be used as response sender, has to be set in ctor or with
-	//! setQueueToUse
-	MessageQueueIF* queueToUse;
-	//! Pointer to an IPC Store, initialized during construction or
-	StorageManagerIF* ipcStore = nullptr;
+    //! Increase of value of this per step
+    static const uint8_t STEP_OFFSET = 1;
+    HasActionsIF* owner;//!< Pointer to the owner
+    //! Queue to be used as response sender, has to be set in ctor or with
+    //! setQueueToUse
+    MessageQueueIF* queueToUse;
+    //! Pointer to an IPC Store, initialized during construction or
+    StorageManagerIF* ipcStore = nullptr;
 
-	/**
-	 * Internal function called by handleActionMessage
-	 * @param commandedBy MessageQueueID of Commander
-	 * @param actionId ID of action to be done
-	 * @param dataAddress Address of additional data in IPC Store
-	 */
-	virtual void prepareExecution(MessageQueueId_t commandedBy,
-	        ActionId_t actionId, store_address_t dataAddress);
-	/**
-	 * @brief Default implementation is empty.
-	 */
-	virtual void resetHelper();
+    /**
+     * Internal function called by handleActionMessage
+     * @param commandedBy MessageQueueID of Commander
+     * @param actionId ID of action to be done
+     * @param dataAddress Address of additional data in IPC Store
+     */
+    virtual void prepareExecution(MessageQueueId_t commandedBy,
+            ActionId_t actionId, store_address_t dataAddress);
+    /**
+     * @brief Default implementation is empty.
+     */
+    virtual void resetHelper();
 };
 
 #endif /* FSFW_ACTION_ACTIONHELPER_H_ */
diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index 1c00dee0f..c3eb47109 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -11,71 +11,71 @@ ActionMessage::~ActionMessage() {
 }
 
 void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
-		store_address_t parameters) {
-	message->setCommand(EXECUTE_ACTION);
-	message->setParameter(fid);
-	message->setParameter2(parameters.raw);
+        store_address_t parameters) {
+    message->setCommand(EXECUTE_ACTION);
+    message->setParameter(fid);
+    message->setParameter2(parameters.raw);
 }
 
 ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
-	return ActionId_t(message->getParameter());
+    return ActionId_t(message->getParameter());
 }
 
 store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
+    store_address_t temp;
+    temp.raw = message->getParameter2();
+    return temp;
 }
 
 void ActionMessage::setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
-		ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		message->setCommand(STEP_SUCCESS);
-	} else {
-		message->setCommand(STEP_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2((step << 16) + result);
+        ReturnValue_t result) {
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        message->setCommand(STEP_SUCCESS);
+    } else {
+        message->setCommand(STEP_FAILED);
+    }
+    message->setParameter(fid);
+    message->setParameter2((step << 16) + result);
 }
 
 uint8_t ActionMessage::getStep(const CommandMessage* message) {
-	return uint8_t((message->getParameter2() >> 16) & 0xFF);
+    return uint8_t((message->getParameter2() >> 16) & 0xFF);
 }
 
 ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
-	return message->getParameter2() & 0xFFFF;
+    return message->getParameter2() & 0xFFFF;
 }
 
 void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
-		store_address_t data) {
-	message->setCommand(DATA_REPLY);
-	message->setParameter(actionId);
-	message->setParameter2(data.raw);
+        store_address_t data) {
+    message->setCommand(DATA_REPLY);
+    message->setParameter(actionId);
+    message->setParameter2(data.raw);
 }
 
 void ActionMessage::setCompletionReply(CommandMessage* message,
-		ActionId_t fid, ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK or result == HasActionsIF::EXECUTION_FINISHED) {
-		message->setCommand(COMPLETION_SUCCESS);
-	} else {
-		message->setCommand(COMPLETION_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2(result);
+        ActionId_t fid, ReturnValue_t result) {
+    if (result == HasReturnvaluesIF::RETURN_OK or result == HasActionsIF::EXECUTION_FINISHED) {
+        message->setCommand(COMPLETION_SUCCESS);
+    } else {
+        message->setCommand(COMPLETION_FAILED);
+    }
+    message->setParameter(fid);
+    message->setParameter2(result);
 }
 
 void ActionMessage::clear(CommandMessage* message) {
-	switch(message->getCommand()) {
-	case EXECUTE_ACTION:
-	case DATA_REPLY: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
+    switch(message->getCommand()) {
+    case EXECUTE_ACTION:
+    case DATA_REPLY: {
+        StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+                objects::IPC_STORE);
+        if (ipcStore != NULL) {
+            ipcStore->deleteData(getStoreId(message));
+        }
+        break;
+    }
+    default:
+        break;
+    }
 }
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index deb110952..246ac601d 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -15,29 +15,29 @@ using ActionId_t = uint32_t;
  */
 class ActionMessage {
 private:
-	ActionMessage();
+    ActionMessage();
 public:
-	static const uint8_t MESSAGE_ID = messagetypes::ACTION;
-	static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
-	static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
-	static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
-	static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
-	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
-	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
-	virtual ~ActionMessage();
-	static void setCommand(CommandMessage* message, ActionId_t fid,
-			store_address_t parameters);
-	static ActionId_t getActionId(const CommandMessage* message );
-	static store_address_t getStoreId(const CommandMessage* message );
-	static void setStepReply(CommandMessage* message, ActionId_t fid,
-			uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static uint8_t getStep(const CommandMessage* message );
-	static ReturnValue_t getReturnCode(const CommandMessage* message );
-	static void setDataReply(CommandMessage* message, ActionId_t actionId,
-			store_address_t data);
-	static void setCompletionReply(CommandMessage* message, ActionId_t fid,
-			ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static void clear(CommandMessage* message);
+    static const uint8_t MESSAGE_ID = messagetypes::ACTION;
+    static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
+    static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
+    static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
+    static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
+    static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
+    static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
+    virtual ~ActionMessage();
+    static void setCommand(CommandMessage* message, ActionId_t fid,
+            store_address_t parameters);
+    static ActionId_t getActionId(const CommandMessage* message );
+    static store_address_t getStoreId(const CommandMessage* message );
+    static void setStepReply(CommandMessage* message, ActionId_t fid,
+            uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    static uint8_t getStep(const CommandMessage* message );
+    static ReturnValue_t getReturnCode(const CommandMessage* message );
+    static void setDataReply(CommandMessage* message, ActionId_t actionId,
+            store_address_t data);
+    static void setCompletionReply(CommandMessage* message, ActionId_t fid,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    static void clear(CommandMessage* message);
 };
 
 #endif /* FSFW_ACTION_ACTIONMESSAGE_H_ */
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index 4e88f3c34..148b36575 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -5,123 +5,123 @@
 #include "../objectmanager/ObjectManagerIF.h"
 
 CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
-		owner(setOwner), queueToUse(NULL), ipcStore(
-		NULL), commandCount(0), lastTarget(0) {
+        owner(setOwner), queueToUse(NULL), ipcStore(
+        NULL), commandCount(0), lastTarget(0) {
 }
 
 CommandActionHelper::~CommandActionHelper() {
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, SerializeIF *data) {
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	uint8_t *storePointer;
-	size_t maxSize = data->getSerializedSize();
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
-			&storePointer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	size_t size = 0;
-	result = data->serialize(&storePointer, &size, maxSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+        ActionId_t actionId, SerializeIF *data) {
+    HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+    if (receiver == NULL) {
+        return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+    }
+    store_address_t storeId;
+    uint8_t *storePointer;
+    size_t maxSize = data->getSerializedSize();
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
+            &storePointer);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    size_t size = 0;
+    result = data->serialize(&storePointer, &size, maxSize,
+            SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return sendCommand(receiver->getCommandQueue(), actionId, storeId);
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, const uint8_t *data, uint32_t size) {
-//	if (commandCount != 0) {
-//		return CommandsFunctionsIF::ALREADY_COMMANDING;
-//	}
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	ReturnValue_t result = ipcStore->addData(&storeId, data, size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+        ActionId_t actionId, const uint8_t *data, uint32_t size) {
+//    if (commandCount != 0) {
+//        return CommandsFunctionsIF::ALREADY_COMMANDING;
+//    }
+    HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+    if (receiver == NULL) {
+        return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+    }
+    store_address_t storeId;
+    ReturnValue_t result = ipcStore->addData(&storeId, data, size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return sendCommand(receiver->getCommandQueue(), actionId, storeId);
 }
 
 ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
-		ActionId_t actionId, store_address_t storeId) {
-	CommandMessage command;
-	ActionMessage::setCommand(&command, actionId, storeId);
-	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeId);
-	}
-	lastTarget = queueId;
-	commandCount++;
-	return result;
+        ActionId_t actionId, store_address_t storeId) {
+    CommandMessage command;
+    ActionMessage::setCommand(&command, actionId, storeId);
+    ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeId);
+    }
+    lastTarget = queueId;
+    commandCount++;
+    return result;
 }
 
 ReturnValue_t CommandActionHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if (ipcStore == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	queueToUse = owner->getCommandQueuePtr();
-	if (queueToUse == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    queueToUse = owner->getCommandQueuePtr();
+    if (queueToUse == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
-	if (reply->getSender() != lastTarget) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	switch (reply->getCommand()) {
-	case ActionMessage::COMPLETION_SUCCESS:
-		commandCount--;
-		owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::COMPLETION_FAILED:
-		commandCount--;
-		owner->completionFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_SUCCESS:
-		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_FAILED:
-		commandCount--;
-		owner->stepFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::DATA_REPLY:
-		extractDataForOwner(ActionMessage::getActionId(reply),
-				ActionMessage::getStoreId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    if (reply->getSender() != lastTarget) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    switch (reply->getCommand()) {
+    case ActionMessage::COMPLETION_SUCCESS:
+        commandCount--;
+        owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::COMPLETION_FAILED:
+        commandCount--;
+        owner->completionFailedReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getReturnCode(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::STEP_SUCCESS:
+        owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getStep(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::STEP_FAILED:
+        commandCount--;
+        owner->stepFailedReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getStep(reply),
+                ActionMessage::getReturnCode(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::DATA_REPLY:
+        extractDataForOwner(ActionMessage::getActionId(reply),
+                ActionMessage::getStoreId(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 uint8_t CommandActionHelper::getCommandCount() const {
-	return commandCount;
+    return commandCount;
 }
 
 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-	const uint8_t * data = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	owner->dataReceived(actionId, data, size);
-	ipcStore->deleteData(storeId);
+    const uint8_t * data = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return;
+    }
+    owner->dataReceived(actionId, data, size);
+    ipcStore->deleteData(storeId);
 }
diff --git a/action/CommandActionHelper.h b/action/CommandActionHelper.h
index cfed8c941..96ef1763a 100644
--- a/action/CommandActionHelper.h
+++ b/action/CommandActionHelper.h
@@ -11,26 +11,26 @@
 class CommandsActionsIF;
 
 class CommandActionHelper {
-	friend class CommandsActionsIF;
+    friend class CommandsActionsIF;
 public:
-	CommandActionHelper(CommandsActionsIF* owner);
-	virtual ~CommandActionHelper();
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, const uint8_t* data, uint32_t size);
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, SerializeIF* data);
-	ReturnValue_t initialize();
-	ReturnValue_t handleReply(CommandMessage* reply);
-	uint8_t getCommandCount() const;
+    CommandActionHelper(CommandsActionsIF* owner);
+    virtual ~CommandActionHelper();
+    ReturnValue_t commandAction(object_id_t commandTo,
+            ActionId_t actionId, const uint8_t* data, uint32_t size);
+    ReturnValue_t commandAction(object_id_t commandTo,
+            ActionId_t actionId, SerializeIF* data);
+    ReturnValue_t initialize();
+    ReturnValue_t handleReply(CommandMessage* reply);
+    uint8_t getCommandCount() const;
 private:
-	CommandsActionsIF* owner;
-	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore;
-	uint8_t commandCount;
-	MessageQueueId_t lastTarget;
-	void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
-	ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
-			store_address_t storeId);
+    CommandsActionsIF* owner;
+    MessageQueueIF* queueToUse;
+    StorageManagerIF* ipcStore;
+    uint8_t commandCount;
+    MessageQueueId_t lastTarget;
+    void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
+    ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
+            store_address_t storeId);
 };
 
 #endif /* COMMANDACTIONHELPER_H_ */
diff --git a/action/CommandsActionsIF.h b/action/CommandsActionsIF.h
index 491bfc703..fe7e856c2 100644
--- a/action/CommandsActionsIF.h
+++ b/action/CommandsActionsIF.h
@@ -15,22 +15,22 @@
  * - replyReceived(id, step, cause) (if cause == OK, it's a success).
  */
 class CommandsActionsIF {
-	friend class CommandActionHelper;
+    friend class CommandActionHelper;
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
-	static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
-	virtual ~CommandsActionsIF() {}
-	virtual MessageQueueIF* getCommandQueuePtr() = 0;
+    static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
+    static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
+    static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
+    virtual ~CommandsActionsIF() {}
+    virtual MessageQueueIF* getCommandQueuePtr() = 0;
 protected:
-	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
-	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
-			ReturnValue_t returnCode) = 0;
-	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
-			uint32_t size) = 0;
-	virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
-	virtual void completionFailedReceived(ActionId_t actionId,
-			ReturnValue_t returnCode) = 0;
+    virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
+    virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
+            ReturnValue_t returnCode) = 0;
+    virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
+            uint32_t size) = 0;
+    virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
+    virtual void completionFailedReceived(ActionId_t actionId,
+            ReturnValue_t returnCode) = 0;
 };
 
 
diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 690f03698..056e674c3 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -35,28 +35,28 @@
  */
 class HasActionsIF {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
-	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
-	virtual ~HasActionsIF() { }
-	/**
-	 * Function to get the MessageQueueId_t of the implementing object
-	 * @return MessageQueueId_t of the object
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	/**
-	 * Execute or initialize the execution of a certain function.
-	 * The ActionHelpers will execute this function and behave differently
-	 * depending on the returnvalue.
-	 *
-	 * @return
-	 * -@c EXECUTION_FINISHED Finish reply will be generated
-	 * -@c Not RETURN_OK Step failure reply will be generated
-	 */
-	virtual ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
+    static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
+    static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
+    static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
+    static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
+    static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
+    virtual ~HasActionsIF() { }
+    /**
+     * Function to get the MessageQueueId_t of the implementing object
+     * @return MessageQueueId_t of the object
+     */
+    virtual MessageQueueId_t getCommandQueue() const = 0;
+    /**
+     * Execute or initialize the execution of a certain function.
+     * The ActionHelpers will execute this function and behave differently
+     * depending on the returnvalue.
+     *
+     * @return
+     * -@c EXECUTION_FINISHED Finish reply will be generated
+     * -@c Not RETURN_OK Step failure reply will be generated
+     */
+    virtual ReturnValue_t executeAction(ActionId_t actionId,
+            MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
 };
 
 
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index af57736c8..f77d01473 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -2,74 +2,74 @@
 #include "SimpleActionHelper.h"
 
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
-		MessageQueueIF* useThisQueue) :
-		ActionHelper(setOwner, useThisQueue), isExecuting(false) {
+        MessageQueueIF* useThisQueue) :
+        ActionHelper(setOwner, useThisQueue), isExecuting(false) {
 }
 
 SimpleActionHelper::~SimpleActionHelper() {
 }
 
 void SimpleActionHelper::step(ReturnValue_t result) {
-	// STEP_OFFESET is subtracted to compensate for adding offset in base
-	// method, which is not necessary here.
-	ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
-			result);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		resetHelper();
-	}
+    // STEP_OFFESET is subtracted to compensate for adding offset in base
+    // method, which is not necessary here.
+    ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
+            result);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        resetHelper();
+    }
 }
 
 void SimpleActionHelper::finish(ReturnValue_t result) {
-	ActionHelper::finish(lastCommander, lastAction, result);
-	resetHelper();
+    ActionHelper::finish(lastCommander, lastAction, result);
+    resetHelper();
 }
 
 ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
-	return ActionHelper::reportData(lastCommander, lastAction, data);
+    return ActionHelper::reportData(lastCommander, lastAction, data);
 }
 
 void SimpleActionHelper::resetHelper() {
-	stepCount = 0;
-	isExecuting = false;
-	lastAction = 0;
-	lastCommander = 0;
+    stepCount = 0;
+    isExecuting = false;
+    lastAction = 0;
+    lastCommander = 0;
 }
 
 void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
-		ActionId_t actionId, store_address_t dataAddress) {
-	CommandMessage reply;
-	if (isExecuting) {
-		ipcStore->deleteData(dataAddress);
-		ActionMessage::setStepReply(&reply, actionId, 0,
-				HasActionsIF::IS_BUSY);
-		queueToUse->sendMessage(commandedBy, &reply);
-	}
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	lastCommander = commandedBy;
-	lastAction = actionId;
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	switch (result) {
-	case HasReturnvaluesIF::RETURN_OK:
-		isExecuting = true;
-		stepCount++;
-		break;
-	case HasActionsIF::EXECUTION_FINISHED:
-		ActionMessage::setCompletionReply(&reply, actionId,
-				HasReturnvaluesIF::RETURN_OK);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	default:
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	}
+        ActionId_t actionId, store_address_t dataAddress) {
+    CommandMessage reply;
+    if (isExecuting) {
+        ipcStore->deleteData(dataAddress);
+        ActionMessage::setStepReply(&reply, actionId, 0,
+                HasActionsIF::IS_BUSY);
+        queueToUse->sendMessage(commandedBy, &reply);
+    }
+    const uint8_t* dataPtr = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
+    lastCommander = commandedBy;
+    lastAction = actionId;
+    result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+    ipcStore->deleteData(dataAddress);
+    switch (result) {
+    case HasReturnvaluesIF::RETURN_OK:
+        isExecuting = true;
+        stepCount++;
+        break;
+    case HasActionsIF::EXECUTION_FINISHED:
+        ActionMessage::setCompletionReply(&reply, actionId,
+                HasReturnvaluesIF::RETURN_OK);
+        queueToUse->sendMessage(commandedBy, &reply);
+        break;
+    default:
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        break;
+    }
 
 }
diff --git a/action/SimpleActionHelper.h b/action/SimpleActionHelper.h
index 1f35d9fdf..7c6c4e00e 100644
--- a/action/SimpleActionHelper.h
+++ b/action/SimpleActionHelper.h
@@ -4,27 +4,27 @@
 #include "ActionHelper.h"
 
 /**
- * @brief	This is an action helper which is only able to service one action
- * 			at a time but remembers last commander and last action which
- * 			simplifies usage
+ * @brief    This is an action helper which is only able to service one action
+ *             at a time but remembers last commander and last action which
+ *             simplifies usage
  */
 class SimpleActionHelper: public ActionHelper {
 public:
-	SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-	virtual ~SimpleActionHelper();
-	void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	ReturnValue_t reportData(SerializeIF* data);
+    SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+    virtual ~SimpleActionHelper();
+    void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    ReturnValue_t reportData(SerializeIF* data);
 
 protected:
-	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-			store_address_t dataAddress);
-	virtual void resetHelper();
+    void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
+            store_address_t dataAddress);
+    virtual void resetHelper();
 private:
-	bool isExecuting;
-	MessageQueueId_t lastCommander = MessageQueueIF::NO_QUEUE;
-	ActionId_t lastAction = 0;
-	uint8_t stepCount = 0;
+    bool isExecuting;
+    MessageQueueId_t lastCommander = MessageQueueIF::NO_QUEUE;
+    ActionId_t lastAction = 0;
+    uint8_t stepCount = 0;
 };
 
 #endif /* SIMPLEACTIONHELPER_H_ */

From 98f89302c43c990b3eeb3df21cd15029de8a697b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 28 Jan 2021 11:44:49 +0100
Subject: [PATCH 1538/1774] tabs replaced by spaces

---
 container/ArrayList.h              |  398 +++++-----
 container/BinaryTree.h             |  234 +++---
 container/DynamicFIFO.h            |   64 +-
 container/FIFO.h                   |   48 +-
 container/FIFOBase.h               |  112 +--
 container/FIFOBase.tpp             |   82 +-
 container/FixedArrayList.h         |   38 +-
 container/FixedMap.h               |  354 ++++-----
 container/FixedOrderedMultimap.h   |  282 +++----
 container/FixedOrderedMultimap.tpp |  136 ++--
 container/HybridIterator.h         |  124 +--
 container/IndexedRingMemoryArray.h | 1178 ++++++++++++++--------------
 container/PlacementFactory.h       |   84 +-
 container/RingBufferBase.h         |  166 ++--
 container/SharedRingBuffer.cpp     |   40 +-
 container/SharedRingBuffer.h       |  122 +--
 container/SimpleRingBuffer.cpp     |  152 ++--
 container/SimpleRingBuffer.h       |  178 ++---
 container/SinglyLinkedList.h       |  176 ++---
 19 files changed, 1984 insertions(+), 1984 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 6bd5c1d5a..25e281a27 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -6,7 +6,7 @@
 #include "../serialize/SerializeIF.h"
 
 /**
- * @brief 	A List that stores its values in an array.
+ * @brief     A List that stores its values in an array.
  * @details
  * The underlying storage is an array that can be allocated by the class
  * itself or supplied via ctor.
@@ -15,237 +15,237 @@
  */
 template<typename T, typename count_t = uint8_t>
 class ArrayList {
-	template<typename U, typename count> friend class SerialArrayListAdapter;
+    template<typename U, typename count> friend class SerialArrayListAdapter;
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
+    static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
+    static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
 
-	/**
-	 * This is the allocating constructor.
-	 * It allocates an array of the specified size.
-	 * @param maxSize
-	 */
-	ArrayList(count_t maxSize) :
-		size(0), maxSize_(maxSize), allocated(true) {
-		entries = new T[maxSize];
-	}
+    /**
+     * This is the allocating constructor.
+     * It allocates an array of the specified size.
+     * @param maxSize
+     */
+    ArrayList(count_t maxSize) :
+        size(0), maxSize_(maxSize), allocated(true) {
+        entries = new T[maxSize];
+    }
 
-	/**
-	 * This is the non-allocating constructor
-	 *
-	 * It expects a pointer to an array of a certain size and initializes
-	 * itself to it.
-	 *
-	 * @param storage the array to use as backend
-	 * @param maxSize size of storage
-	 * @param size size of data already present in storage
-	 */
-	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
-		size(size), entries(storage), maxSize_(maxSize), allocated(false) {
-	}
+    /**
+     * This is the non-allocating constructor
+     *
+     * It expects a pointer to an array of a certain size and initializes
+     * itself to it.
+     *
+     * @param storage the array to use as backend
+     * @param maxSize size of storage
+     * @param size size of data already present in storage
+     */
+    ArrayList(T *storage, count_t maxSize, count_t size = 0) :
+        size(size), entries(storage), maxSize_(maxSize), allocated(false) {
+    }
 
-	/**
-	 * Copying is forbiden by declaring copy ctor and copy assignment deleted
-	 * It is too ambigous in this case.
-	 * (Allocate a new backend? Use the same? What to do in an modifying call?)
-	 */
-	ArrayList(const ArrayList& other) = delete;
-	const ArrayList& operator=(const ArrayList& other) = delete;
+    /**
+     * Copying is forbiden by declaring copy ctor and copy assignment deleted
+     * It is too ambigous in this case.
+     * (Allocate a new backend? Use the same? What to do in an modifying call?)
+     */
+    ArrayList(const ArrayList& other) = delete;
+    const ArrayList& operator=(const ArrayList& other) = delete;
 
-	/**
-	 * Number of Elements stored in this List
-	 */
-	count_t size;
+    /**
+     * Number of Elements stored in this List
+     */
+    count_t size;
 
 
-	/**
-	 * Destructor, if the allocating constructor was used, it deletes the array.
-	 */
-	virtual ~ArrayList() {
-		if (allocated) {
-			delete[] entries;
-		}
-	}
+    /**
+     * Destructor, if the allocating constructor was used, it deletes the array.
+     */
+    virtual ~ArrayList() {
+        if (allocated) {
+            delete[] entries;
+        }
+    }
 
-	/**
-	 * An Iterator to go trough an ArrayList
-	 *
-	 * It stores a pointer to an element and increments the
-	 * pointer when incremented itself.
-	 */
-	class Iterator {
-	public:
-		/**
-		 * Empty ctor, points to NULL
-		 */
-		Iterator(): value(0) {}
+    /**
+     * An Iterator to go trough an ArrayList
+     *
+     * It stores a pointer to an element and increments the
+     * pointer when incremented itself.
+     */
+    class Iterator {
+    public:
+        /**
+         * Empty ctor, points to NULL
+         */
+        Iterator(): value(0) {}
 
-		/**
-		 * Initializes the Iterator to point to an element
-		 *
-		 * @param initialize
-		 */
-		Iterator(T *initialize) {
-			value = initialize;
-		}
+        /**
+         * Initializes the Iterator to point to an element
+         *
+         * @param initialize
+         */
+        Iterator(T *initialize) {
+            value = initialize;
+        }
 
-		/**
-		 * The current element the iterator points to
-		 */
-		T *value;
+        /**
+         * The current element the iterator points to
+         */
+        T *value;
 
-		Iterator& operator++() {
-			value++;
-			return *this;
-		}
+        Iterator& operator++() {
+            value++;
+            return *this;
+        }
 
-		Iterator operator++(int) {
-			Iterator tmp(*this);
-			operator++();
-			return tmp;
-		}
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
 
-		Iterator& operator--() {
-			value--;
-			return *this;
-		}
+        Iterator& operator--() {
+            value--;
+            return *this;
+        }
 
-		Iterator operator--(int) {
-			Iterator tmp(*this);
-			operator--();
-			return tmp;
-		}
+        Iterator operator--(int) {
+            Iterator tmp(*this);
+            operator--();
+            return tmp;
+        }
 
-		T& operator*() {
-			return *value;
-		}
+        T& operator*() {
+            return *value;
+        }
 
-		const T& operator*() const {
-			return *value;
-		}
+        const T& operator*() const {
+            return *value;
+        }
 
-		T *operator->() {
-			return value;
-		}
+        T *operator->() {
+            return value;
+        }
 
-		const T *operator->() const {
-			return value;
-		}
-	};
+        const T *operator->() const {
+            return value;
+        }
+    };
 
-	friend bool operator==(const ArrayList::Iterator& lhs,
-			const ArrayList::Iterator& rhs) {
-		return (lhs.value == rhs.value);
-	}
+    friend bool operator==(const ArrayList::Iterator& lhs,
+            const ArrayList::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
 
-	friend bool operator!=(const ArrayList::Iterator& lhs,
-			const ArrayList::Iterator& rhs) {
-		return not (lhs.value == rhs.value);
-	}
+    friend bool operator!=(const ArrayList::Iterator& lhs,
+            const ArrayList::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
 
-	/**
-	 * Iterator pointing to the first stored elmement
-	 *
-	 * @return Iterator to the first element
-	 */
-	Iterator begin() const {
-		return Iterator(&entries[0]);
-	}
+    /**
+     * Iterator pointing to the first stored elmement
+     *
+     * @return Iterator to the first element
+     */
+    Iterator begin() const {
+        return Iterator(&entries[0]);
+    }
 
-	/**
-	 * returns an Iterator pointing to the element after the last stored entry
-	 *
-	 * @return Iterator to the element after the last entry
-	 */
-	Iterator end() const {
-		return Iterator(&entries[size]);
-	}
+    /**
+     * returns an Iterator pointing to the element after the last stored entry
+     *
+     * @return Iterator to the element after the last entry
+     */
+    Iterator end() const {
+        return Iterator(&entries[size]);
+    }
 
-	T & operator[](count_t i) const {
-		return entries[i];
-	}
+    T & operator[](count_t i) const {
+        return entries[i];
+    }
 
-	/**
-	 * The first element
-	 *
-	 * @return pointer to the first stored element
-	 */
-	T *front() {
-		return entries;
-	}
+    /**
+     * The first element
+     *
+     * @return pointer to the first stored element
+     */
+    T *front() {
+        return entries;
+    }
 
-	/**
-	 * The last element
-	 *
-	 * does not return a valid pointer if called on an empty list.
-	 *
-	 * @return pointer to the last stored element
-	 */
-	T *back() {
-		return &entries[size - 1];
-		//Alternative solution
-		//return const_cast<T*>(static_cast<const T*>(*this).back());
-	}
+    /**
+     * The last element
+     *
+     * does not return a valid pointer if called on an empty list.
+     *
+     * @return pointer to the last stored element
+     */
+    T *back() {
+        return &entries[size - 1];
+        //Alternative solution
+        //return const_cast<T*>(static_cast<const T*>(*this).back());
+    }
 
-	const T* back() const{
-		return &entries[size-1];
-	}
+    const T* back() const{
+        return &entries[size-1];
+    }
 
-	/**
-	 * The maximum number of elements this List can contain
-	 *
-	 * @return maximum number of elements
-	 */
-	size_t maxSize() const {
-		return this->maxSize_;
-	}
+    /**
+     * The maximum number of elements this List can contain
+     *
+     * @return maximum number of elements
+     */
+    size_t maxSize() const {
+        return this->maxSize_;
+    }
 
-	/**
-	 * Insert a new element into the list.
-	 *
-	 * The new element is inserted after the last stored element.
-	 *
-	 * @param entry
-	 * @return
-	 *          -@c FULL if the List is full
-	 *          -@c RETURN_OK else
-	 */
-	ReturnValue_t insert(T entry) {
-		if (size >= maxSize_) {
-			return FULL;
-		}
-		entries[size] = entry;
-		++size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    /**
+     * Insert a new element into the list.
+     *
+     * The new element is inserted after the last stored element.
+     *
+     * @param entry
+     * @return
+     *          -@c FULL if the List is full
+     *          -@c RETURN_OK else
+     */
+    ReturnValue_t insert(T entry) {
+        if (size >= maxSize_) {
+            return FULL;
+        }
+        entries[size] = entry;
+        ++size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	/**
-	 * clear the List
-	 *
-	 * This does not actually clear all entries, it only sets the size to 0.
-	 */
-	void clear() {
-		size = 0;
-	}
+    /**
+     * clear the List
+     *
+     * This does not actually clear all entries, it only sets the size to 0.
+     */
+    void clear() {
+        size = 0;
+    }
 
-	count_t remaining() {
-		return (maxSize_ - size);
-	}
+    count_t remaining() {
+        return (maxSize_ - size);
+    }
 
 protected:
-	/**
-	 * pointer to the array in which the entries are stored
-	 */
-	T *entries;
-	/**
-	 * remembering the maximum size
-	 */
-	size_t maxSize_;
+    /**
+     * pointer to the array in which the entries are stored
+     */
+    T *entries;
+    /**
+     * remembering the maximum size
+     */
+    size_t maxSize_;
 
-	/**
-	 * true if the array was allocated and needs to be deleted in the destructor.
-	 */
-	bool allocated;
+    /**
+     * true if the array was allocated and needs to be deleted in the destructor.
+     */
+    bool allocated;
 };
 
 
diff --git a/container/BinaryTree.h b/container/BinaryTree.h
index 73073dea3..6200cbb1f 100644
--- a/container/BinaryTree.h
+++ b/container/BinaryTree.h
@@ -7,65 +7,65 @@
 template<typename Tp>
 class BinaryNode {
 public:
-	BinaryNode(Tp* setValue) :
-			value(setValue), left(NULL), right(NULL), parent(NULL) {
-	}
-	Tp *value;
-	BinaryNode* left;
-	BinaryNode* right;
-	BinaryNode* parent;
+    BinaryNode(Tp* setValue) :
+            value(setValue), left(NULL), right(NULL), parent(NULL) {
+    }
+    Tp *value;
+    BinaryNode* left;
+    BinaryNode* right;
+    BinaryNode* parent;
 };
 
 template<typename Tp>
 class ExplicitNodeIterator {
 public:
-	typedef ExplicitNodeIterator<Tp> _Self;
-	typedef BinaryNode<Tp> _Node;
-	typedef Tp value_type;
-	typedef Tp* pointer;
-	typedef Tp& reference;
-	ExplicitNodeIterator() :
-			element(NULL) {
-	}
-	ExplicitNodeIterator(_Node* node) :
-			element(node) {
-	}
-	BinaryNode<Tp>* element;
-	_Self up() {
-		return _Self(element->parent);
-	}
-	_Self left() {
-		if (element != NULL) {
-			return _Self(element->left);
-		} else {
-			return _Self(NULL);
-		}
+    typedef ExplicitNodeIterator<Tp> _Self;
+    typedef BinaryNode<Tp> _Node;
+    typedef Tp value_type;
+    typedef Tp* pointer;
+    typedef Tp& reference;
+    ExplicitNodeIterator() :
+            element(NULL) {
+    }
+    ExplicitNodeIterator(_Node* node) :
+            element(node) {
+    }
+    BinaryNode<Tp>* element;
+    _Self up() {
+        return _Self(element->parent);
+    }
+    _Self left() {
+        if (element != NULL) {
+            return _Self(element->left);
+        } else {
+            return _Self(NULL);
+        }
 
-	}
-	_Self right() {
-		if (element != NULL) {
-			return _Self(element->right);
-		} else {
-			return _Self(NULL);
-		}
+    }
+    _Self right() {
+        if (element != NULL) {
+            return _Self(element->right);
+        } else {
+            return _Self(NULL);
+        }
 
-	}
-	bool operator==(const _Self& __x) const {
-		return element == __x.element;
-	}
-	bool operator!=(const _Self& __x) const {
-		return element != __x.element;
-	}
+    }
+    bool operator==(const _Self& __x) const {
+        return element == __x.element;
+    }
+    bool operator!=(const _Self& __x) const {
+        return element != __x.element;
+    }
     pointer
     operator->() const {
-    	if (element != NULL) {
-    		return element->value;
-    	} else {
-    		return NULL;
-    	}
+        if (element != NULL) {
+            return element->value;
+        } else {
+            return NULL;
+        }
     }
     pointer operator*() const {
-    	return this->operator->();
+        return this->operator->();
     }
 };
 
@@ -75,77 +75,77 @@ public:
 template<typename Tp>
 class BinaryTree {
 public:
-	typedef ExplicitNodeIterator<Tp> iterator;
-	typedef BinaryNode<Tp> Node;
-	typedef std::pair<iterator, iterator> children;
-	BinaryTree() :
-			rootNode(NULL) {
-	}
-	BinaryTree(Node* rootNode) :
-			rootNode(rootNode) {
-	}
-	iterator begin() const {
-		return iterator(rootNode);
-	}
-	static iterator end() {
-		return iterator(NULL);
-	}
-	iterator insert(bool insertLeft, iterator parentNode, Node* newNode ) {
-		newNode->parent = parentNode.element;
-		if (parentNode.element != NULL) {
-			if (insertLeft) {
-				parentNode.element->left = newNode;
-			} else {
-				parentNode.element->right = newNode;
-			}
-		} else {
-			//Insert first element.
-			rootNode = newNode;
-		}
-		return iterator(newNode);
-	}
-	//No recursion to children. Needs to be done externally.
-	children erase(iterator node) {
-		if (node.element == rootNode) {
-			//We're root node
-			rootNode = NULL;
-		} else {
-			//Delete parent's reference
-			if (node.up().left() == node) {
-				node.up().element->left = NULL;
-			} else {
-				node.up().element->right = NULL;
-			}
-		}
-		return children(node.element->left, node.element->right);
-	}
-	static uint32_t countLeft(iterator start) {
-		if (start == end()) {
-			return 0;
-		}
-		//We also count the start node itself.
-		uint32_t count = 1;
-		while (start.left() != end()) {
-			count++;
-			start = start.left();
-		}
-		return count;
-	}
-	static uint32_t countRight(iterator start) {
-		if (start == end()) {
-			return 0;
-		}
-		//We also count the start node itself.
-		uint32_t count = 1;
-		while (start.right() != end()) {
-			count++;
-			start = start.right();
-		}
-		return count;
-	}
+    typedef ExplicitNodeIterator<Tp> iterator;
+    typedef BinaryNode<Tp> Node;
+    typedef std::pair<iterator, iterator> children;
+    BinaryTree() :
+            rootNode(NULL) {
+    }
+    BinaryTree(Node* rootNode) :
+            rootNode(rootNode) {
+    }
+    iterator begin() const {
+        return iterator(rootNode);
+    }
+    static iterator end() {
+        return iterator(NULL);
+    }
+    iterator insert(bool insertLeft, iterator parentNode, Node* newNode ) {
+        newNode->parent = parentNode.element;
+        if (parentNode.element != NULL) {
+            if (insertLeft) {
+                parentNode.element->left = newNode;
+            } else {
+                parentNode.element->right = newNode;
+            }
+        } else {
+            //Insert first element.
+            rootNode = newNode;
+        }
+        return iterator(newNode);
+    }
+    //No recursion to children. Needs to be done externally.
+    children erase(iterator node) {
+        if (node.element == rootNode) {
+            //We're root node
+            rootNode = NULL;
+        } else {
+            //Delete parent's reference
+            if (node.up().left() == node) {
+                node.up().element->left = NULL;
+            } else {
+                node.up().element->right = NULL;
+            }
+        }
+        return children(node.element->left, node.element->right);
+    }
+    static uint32_t countLeft(iterator start) {
+        if (start == end()) {
+            return 0;
+        }
+        //We also count the start node itself.
+        uint32_t count = 1;
+        while (start.left() != end()) {
+            count++;
+            start = start.left();
+        }
+        return count;
+    }
+    static uint32_t countRight(iterator start) {
+        if (start == end()) {
+            return 0;
+        }
+        //We also count the start node itself.
+        uint32_t count = 1;
+        while (start.right() != end()) {
+            count++;
+            start = start.right();
+        }
+        return count;
+    }
 
 protected:
-	Node* rootNode;
+    Node* rootNode;
 };
 
 
diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 86d43f7d7..e1bc3ef2f 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -5,8 +5,8 @@
 #include <vector>
 
 /**
- * @brief 	Simple First-In-First-Out data structure. The maximum size
- * 			can be set in the constructor.
+ * @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!
@@ -17,39 +17,39 @@
 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());
-	};
+    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 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;
-	}
+    /**
+     * @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;
+    std::vector<T> fifoVector;
 };
 
 #endif /* FSFW_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index 701138520..79ead3139 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -5,8 +5,8 @@
 #include <array>
 
 /**
- * @brief 	Simple First-In-First-Out data structure with size fixed at
- * 			compile time
+ * @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.
@@ -16,32 +16,32 @@
 template<typename T, size_t capacity>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(): FIFOBase<T>(nullptr, capacity) {
-		this->setContainer(fifoArray.data());
-	};
+    FIFO(): FIFOBase<T>(nullptr, capacity) {
+        this->setContainer(fifoArray.data());
+    };
 
-	/**
-	 * @brief 	Custom copy constructor to set pointer correctly.
-	 * @param other
-	 */
-	FIFO(const FIFO& other): FIFOBase<T>(other) {
-		this->fifoArray = other.fifoArray;
-		this->setContainer(fifoArray.data());
-	}
+    /**
+     * @brief     Custom copy constructor to set pointer correctly.
+     * @param other
+     */
+    FIFO(const FIFO& other): FIFOBase<T>(other) {
+        this->fifoArray = other.fifoArray;
+        this->setContainer(fifoArray.data());
+    }
 
-	/**
-	 * @brief Custom assignment operator
-	 * @param other
-	 */
-	FIFO& operator=(const FIFO& other){
-		FIFOBase<T>::operator=(other);
-		this->fifoArray = other.fifoArray;
-		this->setContainer(fifoArray.data());
-		return *this;
-	}
+    /**
+     * @brief Custom assignment operator
+     * @param other
+     */
+    FIFO& operator=(const FIFO& other){
+        FIFOBase<T>::operator=(other);
+        this->fifoArray = other.fifoArray;
+        this->setContainer(fifoArray.data());
+        return *this;
+    }
 
 private:
-	std::array<T, capacity> fifoArray;
+    std::array<T, capacity> fifoArray;
 };
 
 #endif /* FSFW_CONTAINER_FIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index edd66d37a..eaa80346e 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -8,70 +8,70 @@
 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);
+    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);
+    /** Default ctor, takes pointer to first entry of underlying container
+     *  and maximum capacity */
+    FIFOBase(T* values, const size_t maxCapacity);
 
-	/**
-	 * Insert value into FIFO
-	 * @param value
-	 * @return RETURN_OK on success, FULL if full
-	 */
-	ReturnValue_t insert(T value);
-	/**
-	 * Retrieve item from FIFO. This removes the item from the FIFO.
-	 * @param value Must point to a valid T
-	 * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
-	 */
-	ReturnValue_t retrieve(T *value);
-	/**
-	 * Retrieve item from FIFO without removing it from FIFO.
-	 * @param value Must point to a valid T
-	 * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
-	 */
-	ReturnValue_t peek(T * value);
-	/**
-	 * Remove item from FIFO.
-	 * @return RETURN_OK on success, EMPTY if empty
-	 */
-	ReturnValue_t pop();
+    /**
+     * Insert value into FIFO
+     * @param value
+     * @return RETURN_OK on success, FULL if full
+     */
+    ReturnValue_t insert(T value);
+    /**
+     * Retrieve item from FIFO. This removes the item from the FIFO.
+     * @param value Must point to a valid T
+     * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
+     */
+    ReturnValue_t retrieve(T *value);
+    /**
+     * Retrieve item from FIFO without removing it from FIFO.
+     * @param value Must point to a valid T
+     * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
+     */
+    ReturnValue_t peek(T * value);
+    /**
+     * Remove item from FIFO.
+     * @return RETURN_OK on success, EMPTY if empty
+     */
+    ReturnValue_t pop();
 
-	/***
-	 * Check if FIFO is empty
-	 * @return True if empty, False if not
-	 */
-	bool empty();
-	/***
-	 * Check if FIFO is Full
-	 * @return True if full, False if not
-	 */
-	bool full();
-	/***
-	 *  Current used size (elements) used
-	 * @return size_t in elements
-	 */
-	size_t size();
-	/***
-	 * Get maximal capacity of fifo
-	 * @return size_t with max capacity of this fifo
-	 */
-	size_t getMaxCapacity() const;
+    /***
+     * Check if FIFO is empty
+     * @return True if empty, False if not
+     */
+    bool empty();
+    /***
+     * Check if FIFO is Full
+     * @return True if full, False if not
+     */
+    bool full();
+    /***
+     *  Current used size (elements) used
+     * @return size_t in elements
+     */
+    size_t size();
+    /***
+     * Get maximal capacity of fifo
+     * @return size_t with max capacity of this fifo
+     */
+    size_t getMaxCapacity() const;
 
 protected:
-	void setContainer(T* data);
-	size_t maxCapacity = 0;
+    void setContainer(T* data);
+    size_t maxCapacity = 0;
 
-	T* values;
+    T* values;
 
-	size_t readIndex = 0;
-	size_t writeIndex = 0;
-	size_t currentSize = 0;
+    size_t readIndex = 0;
+    size_t writeIndex = 0;
+    size_t currentSize = 0;
 
-	size_t next(size_t current);
+    size_t next(size_t current);
 };
 
 #include "FIFOBase.tpp"
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index 763004b6f..2e6a3829c 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -7,87 +7,87 @@
 
 template<typename T>
 inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
-		maxCapacity(maxCapacity), values(values){};
+        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;
-	}
+    if (full()) {
+        return FULL;
+    } else {
+        values[writeIndex] = value;
+        writeIndex = next(writeIndex);
+        ++currentSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 };
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
-	if (empty()) {
-		return EMPTY;
-	} else {
-		if (value == nullptr){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		*value = values[readIndex];
-		readIndex = next(readIndex);
-		--currentSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    if (empty()) {
+        return EMPTY;
+    } else {
+        if (value == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        *value = values[readIndex];
+        readIndex = next(readIndex);
+        --currentSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 };
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::peek(T* value) {
-	if(empty()) {
-		return EMPTY;
-	} else {
-		if (value == nullptr){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		*value = values[readIndex];
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    if(empty()) {
+        return EMPTY;
+    } else {
+        if (value == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        *value = values[readIndex];
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 };
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::pop() {
-	T value;
-	return this->retrieve(&value);
+    T value;
+    return this->retrieve(&value);
 };
 
 template<typename T>
 inline bool FIFOBase<T>::empty() {
-	return (currentSize == 0);
+    return (currentSize == 0);
 };
 
 template<typename T>
 inline bool FIFOBase<T>::full() {
-	return (currentSize == maxCapacity);
+    return (currentSize == maxCapacity);
 }
 
 template<typename T>
 inline size_t FIFOBase<T>::size() {
-	return currentSize;
+    return currentSize;
 }
 
 template<typename T>
 inline size_t FIFOBase<T>::next(size_t current) {
-	++current;
-	if (current == maxCapacity) {
-		current = 0;
-	}
-	return current;
+    ++current;
+    if (current == maxCapacity) {
+        current = 0;
+    }
+    return current;
 }
 
 template<typename T>
 inline size_t FIFOBase<T>::getMaxCapacity() const {
-	return maxCapacity;
+    return maxCapacity;
 }
 
 
 template<typename T>
 inline void FIFOBase<T>::setContainer(T *data) {
-	this->values = data;
+    this->values = data;
 }
 
 #endif
diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index e9e127cf0..89b76388a 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -8,30 +8,30 @@
  */
 template<typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList: public ArrayList<T, count_t> {
-	static_assert(MAX_SIZE <= (pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
+    static_assert(MAX_SIZE <= (pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
 private:
-	T data[MAX_SIZE];
+    T data[MAX_SIZE];
 public:
-	FixedArrayList() :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-	}
+    FixedArrayList() :
+            ArrayList<T, count_t>(data, MAX_SIZE) {
+    }
 
-	FixedArrayList(const FixedArrayList& other) :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		this->size = other.size;
-	}
+    FixedArrayList(const FixedArrayList& other) :
+            ArrayList<T, count_t>(data, MAX_SIZE) {
+        memcpy(this->data, other.data, sizeof(this->data));
+        this->entries = data;
+        this->size = other.size;
+    }
 
-	FixedArrayList& operator=(FixedArrayList other) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		this->size = other.size;
-		return *this;
-	}
+    FixedArrayList& operator=(FixedArrayList other) {
+        memcpy(this->data, other.data, sizeof(this->data));
+        this->entries = data;
+        this->size = other.size;
+        return *this;
+    }
 
-	virtual ~FixedArrayList() {
-	}
+    virtual ~FixedArrayList() {
+    }
 
 };
 
diff --git a/container/FixedMap.h b/container/FixedMap.h
index 7a5220faa..bd8e0f835 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -18,212 +18,212 @@
  */
 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");
+    static_assert (std::is_trivially_copyable<T>::value or
+            std::is_base_of<SerializeIF, T>::value,
+            "Types used in FixedMap must either be trivial copy-able or a "
+            "derived class from SerializeIF to be serialize-able");
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
+    static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+    static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
+    static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
 
 private:
-	static const key_t EMPTY_SLOT = -1;
-	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
+    static const key_t EMPTY_SLOT = -1;
+    ArrayList<std::pair<key_t, T>, uint32_t> theMap;
+    uint32_t _size;
 
-	uint32_t findIndex(key_t key) const {
-		if (_size == 0) {
-			return 1;
-		}
-		uint32_t i = 0;
-		for (i = 0; i < _size; ++i) {
-			if (theMap[i].first == key) {
-				return i;
-			}
-		}
-		return i;
-	}
+    uint32_t findIndex(key_t key) const {
+        if (_size == 0) {
+            return 1;
+        }
+        uint32_t i = 0;
+        for (i = 0; i < _size; ++i) {
+            if (theMap[i].first == key) {
+                return i;
+            }
+        }
+        return i;
+    }
 public:
-	FixedMap(uint32_t maxSize) :
-			theMap(maxSize), _size(0) {
-	}
+    FixedMap(uint32_t maxSize) :
+            theMap(maxSize), _size(0) {
+    }
 
-	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-	public:
-		Iterator() :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
-		}
+    class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
+    public:
+        Iterator() :
+                ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
+        }
 
-		Iterator(std::pair<key_t, T> *pair) :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
-		}
-	};
+        Iterator(std::pair<key_t, T> *pair) :
+                ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
+        }
+    };
 
-	friend bool operator==(const typename FixedMap::Iterator& lhs,
-			const typename FixedMap::Iterator& rhs) {
-		return (lhs.value == rhs.value);
-	}
+    friend bool operator==(const typename FixedMap::Iterator& lhs,
+            const typename FixedMap::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
 
-	friend bool operator!=(const typename FixedMap::Iterator& lhs,
-			const typename FixedMap::Iterator& rhs) {
-		return not (lhs.value == rhs.value);
-	}
+    friend bool operator!=(const typename FixedMap::Iterator& lhs,
+            const typename FixedMap::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
 
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
+    Iterator begin() const {
+        return Iterator(&theMap[0]);
+    }
 
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
+    Iterator end() const {
+        return Iterator(&theMap[_size]);
+    }
 
-	uint32_t size() const {
-		return _size;
-	}
+    uint32_t size() const {
+        return _size;
+    }
 
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
-		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
-			return KEY_ALREADY_EXISTS;
-		}
-		if (_size == theMap.maxSize()) {
-			return MAP_FULL;
-		}
-		theMap[_size].first = key;
-		theMap[_size].second = value;
-		if (storedValue != nullptr) {
-			*storedValue = Iterator(&theMap[_size]);
-		}
-		++_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
+        if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
+            return KEY_ALREADY_EXISTS;
+        }
+        if (_size == theMap.maxSize()) {
+            return MAP_FULL;
+        }
+        theMap[_size].first = key;
+        theMap[_size].second = value;
+        if (storedValue != nullptr) {
+            *storedValue = Iterator(&theMap[_size]);
+        }
+        ++_size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.first, pair.second);
-	}
+    ReturnValue_t insert(std::pair<key_t, T> pair) {
+        return insert(pair.first, pair.second);
+    }
 
-	ReturnValue_t exists(key_t key) const {
-		ReturnValue_t result = KEY_DOES_NOT_EXIST;
-		if (findIndex(key) < _size) {
-			result = HasReturnvaluesIF::RETURN_OK;
-		}
-		return result;
-	}
+    ReturnValue_t exists(key_t key) const {
+        ReturnValue_t result = KEY_DOES_NOT_EXIST;
+        if (findIndex(key) < _size) {
+            result = HasReturnvaluesIF::RETURN_OK;
+        }
+        return result;
+    }
 
-	ReturnValue_t erase(Iterator *iter) {
-		uint32_t i;
-		if ((i = findIndex((*iter).value->first)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		--((*iter).value);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t erase(Iterator *iter) {
+        uint32_t i;
+        if ((i = findIndex((*iter).value->first)) >= _size) {
+            return KEY_DOES_NOT_EXIST;
+        }
+        theMap[i] = theMap[_size - 1];
+        --_size;
+        --((*iter).value);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	ReturnValue_t erase(key_t key) {
-		uint32_t i;
-		if ((i = findIndex(key)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t erase(key_t key) {
+        uint32_t i;
+        if ((i = findIndex(key)) >= _size) {
+            return KEY_DOES_NOT_EXIST;
+        }
+        theMap[i] = theMap[_size - 1];
+        --_size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	T *findValue(key_t key) const {
-		return &theMap[findIndex(key)].second;
-	}
+    T *findValue(key_t key) const {
+        return &theMap[findIndex(key)].second;
+    }
 
-	Iterator find(key_t key) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findIndex(key)]);
-	}
+    Iterator find(key_t key) const {
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return end();
+        }
+        return Iterator(&theMap[findIndex(key)]);
+    }
 
-	ReturnValue_t find(key_t key, T **value) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		*value = &theMap[findIndex(key)].second;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t find(key_t key, T **value) const {
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        *value = &theMap[findIndex(key)].second;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	bool empty() {
-	    if(_size == 0) {
-	        return true;
-	    }
-	    else {
-	        return false;
-	    }
-	}
+    bool empty() {
+        if(_size == 0) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
 
-	bool full() {
-	    if(_size >= theMap.maxSize()) {
-	        return true;
-	    }
-	    else {
-	        return false;
-	    }
-	}
+    bool full() {
+        if(_size >= theMap.maxSize()) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
 
-	void clear() {
-		_size = 0;
-	}
+    void clear() {
+        _size = 0;
+    }
 
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
+    uint32_t maxSize() const {
+        return theMap.maxSize();
+    }
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
-				buffer, size, maxSize, streamEndianness);
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
-					size, maxSize, streamEndianness);
-			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		return result;
-	}
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const {
+        ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
+                buffer, size, maxSize, streamEndianness);
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+            result = SerializeAdapter::serialize(&theMap[i].first, buffer,
+                    size, maxSize, streamEndianness);
+            result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
+                    maxSize, streamEndianness);
+            ++i;
+        }
+        return result;
+    }
 
-	virtual size_t getSerializedSize() const {
-		uint32_t printSize = sizeof(_size);
-		uint32_t i = 0;
+    virtual size_t getSerializedSize() const {
+        uint32_t printSize = sizeof(_size);
+        uint32_t i = 0;
 
-		for (i = 0; i < _size; ++i) {
-			printSize += SerializeAdapter::getSerializedSize(
-					&theMap[i].first);
-			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
-		}
+        for (i = 0; i < _size; ++i) {
+            printSize += SerializeAdapter::getSerializedSize(
+                    &theMap[i].first);
+            printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
+        }
 
-		return printSize;
-	}
+        return printSize;
+    }
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
-				buffer, size, streamEndianness);
-		if (this->_size > theMap.maxSize()) {
-			return SerializeIF::TOO_MANY_ELEMENTS;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
-					size, streamEndianness);
-			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					streamEndianness);
-			++i;
-		}
-		return result;
-	}
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) {
+        ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
+                buffer, size, streamEndianness);
+        if (this->_size > theMap.maxSize()) {
+            return SerializeIF::TOO_MANY_ELEMENTS;
+        }
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+            result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
+                    size, streamEndianness);
+            result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
+                    streamEndianness);
+            ++i;
+        }
+        return result;
+    }
 
 };
 
diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index acf2368af..cb8abdcaf 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -34,172 +34,172 @@
 template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
 class FixedOrderedMultimap {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
+    static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
+    static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
 
-	/***
-	 * Constructor which needs a size_t for the maximum allowed size
-	 *
-	 * Can not be resized during runtime
-	 *
-	 * Allocates memory at construction
-	 * @param maxSize size_t of Maximum allowed size
-	 */
+    /***
+     * Constructor which needs a size_t for the maximum allowed size
+     *
+     * Can not be resized during runtime
+     *
+     * Allocates memory at construction
+     * @param maxSize size_t of Maximum allowed size
+     */
     FixedOrderedMultimap(size_t maxSize):theMap(maxSize), _size(0){
     }
 
-	/***
-	 * Virtual destructor frees Memory by deleting its member
-	 */
-	virtual ~FixedOrderedMultimap() {
-	}
+    /***
+     * Virtual destructor frees Memory by deleting its member
+     */
+    virtual ~FixedOrderedMultimap() {
+    }
 
-	/***
-	 * Special iterator for FixedOrderedMultimap
-	 */
-	class Iterator: public ArrayList<std::pair<key_t, T>, size_t>::Iterator {
-	public:
-		Iterator() :
-			ArrayList<std::pair<key_t, T>, size_t>::Iterator() {
-		}
+    /***
+     * Special iterator for FixedOrderedMultimap
+     */
+    class Iterator: public ArrayList<std::pair<key_t, T>, size_t>::Iterator {
+    public:
+        Iterator() :
+            ArrayList<std::pair<key_t, T>, size_t>::Iterator() {
+        }
 
-		Iterator(std::pair<key_t, T> *pair) :
-			ArrayList<std::pair<key_t, T>, size_t>::Iterator(pair) {
-		}
-	};
+        Iterator(std::pair<key_t, T> *pair) :
+            ArrayList<std::pair<key_t, T>, size_t>::Iterator(pair) {
+        }
+    };
 
-	/***
-	 * Returns an iterator pointing to the first element
-	 * @return Iterator pointing to first element
-	 */
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
+    /***
+     * Returns an iterator pointing to the first element
+     * @return Iterator pointing to first element
+     */
+    Iterator begin() const {
+        return Iterator(&theMap[0]);
+    }
 
-	/**
-	 * Returns an iterator pointing to one element past the end
-	 * @return Iterator pointing to one element past the end
-	 */
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
+    /**
+     * Returns an iterator pointing to one element past the end
+     * @return Iterator pointing to one element past the end
+     */
+    Iterator end() const {
+        return Iterator(&theMap[_size]);
+    }
 
-	/***
-	 * Returns the current size of the map (not maximum size!)
-	 * @return Current size
-	 */
-	size_t size() const{
-		return _size;
-	}
+    /***
+     * Returns the current size of the map (not maximum size!)
+     * @return Current size
+     */
+    size_t size() const{
+        return _size;
+    }
 
-	/**
-	 * Clears the map, does not deallocate any memory
-	 */
-	void clear(){
-		_size = 0;
-	}
+    /**
+     * Clears the map, does not deallocate any memory
+     */
+    void clear(){
+        _size = 0;
+    }
 
-	/**
-	 * Returns the maximum size of the map
-	 * @return Maximum size of the map
-	 */
-	size_t maxSize() const{
-		return theMap.maxSize();
-	}
+    /**
+     * Returns the maximum size of the map
+     * @return Maximum size of the map
+     */
+    size_t maxSize() const{
+        return theMap.maxSize();
+    }
 
-	/***
-	 * Used to insert a key and value separately.
-	 *
-	 * @param[in] key Key of the new element
-	 * @param[in] value Value of the new element
-	 * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a nullptr
-	 * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
-	 */
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
+    /***
+     * Used to insert a key and value separately.
+     *
+     * @param[in] key Key of the new element
+     * @param[in] value Value of the new element
+     * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a nullptr
+     * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+     */
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
 
-	/***
-	 * Used to insert new pair instead of single values
-	 *
-	 * @param pair Pair to be inserted
-	 * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
-	 */
-	ReturnValue_t insert(std::pair<key_t, T> pair);
+    /***
+     * Used to insert new pair instead of single values
+     *
+     * @param pair Pair to be inserted
+     * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+     */
+    ReturnValue_t insert(std::pair<key_t, T> pair);
 
-	/***
-	 * Can be used to check if a certain key is in the map
-	 * @param key Key to be checked
-	 * @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
-	 */
-	ReturnValue_t exists(key_t key) const;
+    /***
+     * Can be used to check if a certain key is in the map
+     * @param key Key to be checked
+     * @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
+     */
+    ReturnValue_t exists(key_t key) const;
 
-	/***
-	 * Used to delete the element in the iterator
-	 *
-	 * The iterator will point to the element before or begin(),
-	 *  but never to one element in front of the map.
-	 *
-	 * @warning The iterator needs to be valid and dereferenceable
-	 * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
-	 * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
-	 */
-	ReturnValue_t erase(Iterator *iter);
+    /***
+     * Used to delete the element in the iterator
+     *
+     * The iterator will point to the element before or begin(),
+     *  but never to one element in front of the map.
+     *
+     * @warning The iterator needs to be valid and dereferenceable
+     * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
+     * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+     */
+    ReturnValue_t erase(Iterator *iter);
 
-	/***
-	 * Used to erase by key
-	 * @param key Key to be erased
-	 * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
-	 */
-	ReturnValue_t erase(key_t key);
+    /***
+     * Used to erase by key
+     * @param key Key to be erased
+     * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+     */
+    ReturnValue_t erase(key_t key);
 
-	/***
-	 * Find returns the first appearance of the key
-	 *
-	 * If the key does not exist, it points to end()
-	 *
-	 * @param key Key to search for
-	 * @return Iterator pointing to the first entry of key
-	 */
-	Iterator find(key_t key) const{
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findFirstIndex(key)]);
-	};
+    /***
+     * Find returns the first appearance of the key
+     *
+     * If the key does not exist, it points to end()
+     *
+     * @param key Key to search for
+     * @return Iterator pointing to the first entry of key
+     */
+    Iterator find(key_t key) const{
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return end();
+        }
+        return Iterator(&theMap[findFirstIndex(key)]);
+    };
 
-	/***
-	 * Finds first entry of the given key and returns a
-	 * pointer to the value
-	 *
-	 * @param key Key to search for
-	 * @param value Found value
-	 * @return RETURN_OK if it points to the value,
-	 * KEY_DOES_NOT_EXIST if the key is not in the map
-	 */
-	ReturnValue_t find(key_t key, T **value) const;
+    /***
+     * Finds first entry of the given key and returns a
+     * pointer to the value
+     *
+     * @param key Key to search for
+     * @param value Found value
+     * @return RETURN_OK if it points to the value,
+     * KEY_DOES_NOT_EXIST if the key is not in the map
+     */
+    ReturnValue_t find(key_t key, T **value) const;
 
-	friend bool operator==(const typename FixedOrderedMultimap::Iterator& lhs,
-			const typename FixedOrderedMultimap::Iterator& rhs) {
-		return (lhs.value == rhs.value);
-	}
+    friend bool operator==(const typename FixedOrderedMultimap::Iterator& lhs,
+            const typename FixedOrderedMultimap::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
 
-	friend bool operator!=(const typename FixedOrderedMultimap::Iterator& lhs,
-			const typename FixedOrderedMultimap::Iterator& rhs) {
-		return not (lhs.value == rhs.value);
-	}
+    friend bool operator!=(const typename FixedOrderedMultimap::Iterator& lhs,
+            const typename FixedOrderedMultimap::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
 
 private:
-	typedef KEY_COMPARE compare;
-	compare myComp;
-	ArrayList<std::pair<key_t, T>, size_t> theMap;
-	size_t _size;
+    typedef KEY_COMPARE compare;
+    compare myComp;
+    ArrayList<std::pair<key_t, T>, size_t> theMap;
+    size_t _size;
 
-	size_t findFirstIndex(key_t key, size_t startAt = 0) const;
+    size_t findFirstIndex(key_t key, size_t startAt = 0) const;
 
-	size_t findNicePlace(key_t key) const;
+    size_t findNicePlace(key_t key) const;
 
-	void removeFromPosition(size_t position);
+    void removeFromPosition(size_t position);
 };
 
 #include "FixedOrderedMultimap.tpp"
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
index 4aa85e974..294a161fe 100644
--- a/container/FixedOrderedMultimap.tpp
+++ b/container/FixedOrderedMultimap.tpp
@@ -4,105 +4,105 @@
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
-	if (_size == theMap.maxSize()) {
-		return MAP_FULL;
-	}
-	size_t position = findNicePlace(key);
-	memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
-			(_size - position) * sizeof(std::pair<key_t,T>));
-	theMap[position].first = key;
-	theMap[position].second = value;
-	++_size;
-	if (storedValue != nullptr) {
-		*storedValue = Iterator(&theMap[position]);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    if (_size == theMap.maxSize()) {
+        return MAP_FULL;
+    }
+    size_t position = findNicePlace(key);
+    memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
+            (_size - position) * sizeof(std::pair<key_t,T>));
+    theMap[position].first = key;
+    theMap[position].second = value;
+    ++_size;
+    if (storedValue != nullptr) {
+        *storedValue = Iterator(&theMap[position]);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
-	return insert(pair.first, pair.second);
+    return insert(pair.first, pair.second);
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
-	ReturnValue_t result = KEY_DOES_NOT_EXIST;
-	if (findFirstIndex(key) < _size) {
-		result = HasReturnvaluesIF::RETURN_OK;
-	}
-	return result;
+    ReturnValue_t result = KEY_DOES_NOT_EXIST;
+    if (findFirstIndex(key) < _size) {
+        result = HasReturnvaluesIF::RETURN_OK;
+    }
+    return result;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
-	size_t i;
-	if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-		return KEY_DOES_NOT_EXIST;
-	}
-	removeFromPosition(i);
-	if (*iter != begin()) {
-		(*iter)--;
-	} else {
-		*iter = begin();
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    size_t i;
+    if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    removeFromPosition(i);
+    if (*iter != begin()) {
+        (*iter)--;
+    } else {
+        *iter = begin();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
-	size_t i;
-	if ((i = findFirstIndex(key)) >= _size) {
-		return KEY_DOES_NOT_EXIST;
-	}
-	do {
-		removeFromPosition(i);
-		i = findFirstIndex(key, i);
-	} while (i < _size);
-	return HasReturnvaluesIF::RETURN_OK;
+    size_t i;
+    if ((i = findFirstIndex(key)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    do {
+        removeFromPosition(i);
+        i = findFirstIndex(key, i);
+    } while (i < _size);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
-	ReturnValue_t result = exists(key);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	*value = &theMap[findFirstIndex(key)].second;
-	return HasReturnvaluesIF::RETURN_OK;
+    ReturnValue_t result = exists(key);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    *value = &theMap[findFirstIndex(key)].second;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
-	if (startAt >= _size) {
-		return startAt + 1;
-	}
-	size_t i = startAt;
-	for (i = startAt; i < _size; ++i) {
-		if (theMap[i].first == key) {
-			return i;
-		}
-	}
-	return i;
+    if (startAt >= _size) {
+        return startAt + 1;
+    }
+    size_t i = startAt;
+    for (i = startAt; i < _size; ++i) {
+        if (theMap[i].first == key) {
+            return i;
+        }
+    }
+    return i;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
-	size_t i = 0;
-	for (i = 0; i < _size; ++i) {
-		if (myComp(key, theMap[i].first)) {
-			return i;
-		}
-	}
-	return i;
+    size_t i = 0;
+    for (i = 0; i < _size; ++i) {
+        if (myComp(key, theMap[i].first)) {
+            return i;
+        }
+    }
+    return i;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
-	if (_size <= position) {
-		return;
-	}
-	memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
-			(_size - position - 1) * sizeof(std::pair<key_t,T>));
-	--_size;
+    if (_size <= position) {
+        return;
+    }
+    memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
+            (_size - position - 1) * sizeof(std::pair<key_t,T>));
+    --_size;
 }
 
 
diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index 8d020cb93..6e33e4611 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -6,85 +6,85 @@
 
 template<typename T, typename count_t = uint8_t>
 class HybridIterator: public LinkedElement<T>::Iterator,
-		public ArrayList<T, count_t>::Iterator {
+        public ArrayList<T, count_t>::Iterator {
 public:
-	HybridIterator() {}
+    HybridIterator() {}
 
-	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
-		LinkedElement<T>::Iterator(*iter), value(iter->value),
-		linked(true) {
+    HybridIterator(typename LinkedElement<T>::Iterator *iter) :
+        LinkedElement<T>::Iterator(*iter), value(iter->value),
+        linked(true) {
 
-	}
+    }
 
-	HybridIterator(LinkedElement<T> *start) :
-		LinkedElement<T>::Iterator(start), value(start->value),
-		linked(true) {
+    HybridIterator(LinkedElement<T> *start) :
+        LinkedElement<T>::Iterator(start), value(start->value),
+        linked(true) {
 
-	}
+    }
 
-	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
-			typename ArrayList<T, count_t>::Iterator end) :
-			ArrayList<T, count_t>::Iterator(start), value(start.value),
-			linked(false), end(end.value) {
-		if (value == this->end) {
-			value = NULL;
-		}
-	}
+    HybridIterator(typename ArrayList<T, count_t>::Iterator start,
+            typename ArrayList<T, count_t>::Iterator end) :
+            ArrayList<T, count_t>::Iterator(start), value(start.value),
+            linked(false), end(end.value) {
+        if (value == this->end) {
+            value = NULL;
+        }
+    }
 
-	HybridIterator(T *firstElement, T *lastElement) :
-			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
-			linked(false), end(++lastElement) {
-		if (value == end) {
-			value = NULL;
-		}
-	}
+    HybridIterator(T *firstElement, T *lastElement) :
+            ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
+            linked(false), end(++lastElement) {
+        if (value == end) {
+            value = NULL;
+        }
+    }
 
-	HybridIterator& operator++() {
-		if (linked) {
-			LinkedElement<T>::Iterator::operator++();
-			if (LinkedElement<T>::Iterator::value != nullptr) {
-				value = LinkedElement<T>::Iterator::value->value;
-			} else {
-				value = nullptr;
-			}
-		} else {
-			ArrayList<T, count_t>::Iterator::operator++();
-			value = ArrayList<T, count_t>::Iterator::value;
+    HybridIterator& operator++() {
+        if (linked) {
+            LinkedElement<T>::Iterator::operator++();
+            if (LinkedElement<T>::Iterator::value != nullptr) {
+                value = LinkedElement<T>::Iterator::value->value;
+            } else {
+                value = nullptr;
+            }
+        } else {
+            ArrayList<T, count_t>::Iterator::operator++();
+            value = ArrayList<T, count_t>::Iterator::value;
 
-			if (value == end) {
-				value = nullptr;
-			}
-		}
-		return *this;
-	}
+            if (value == end) {
+                value = nullptr;
+            }
+        }
+        return *this;
+    }
 
-	HybridIterator operator++(int) {
-		HybridIterator tmp(*this);
-		operator++();
-		return tmp;
-	}
+    HybridIterator operator++(int) {
+        HybridIterator tmp(*this);
+        operator++();
+        return tmp;
+    }
 
-	bool operator==(const HybridIterator& other) const {
-		return value == other.value;
-	}
+    bool operator==(const HybridIterator& other) const {
+        return value == other.value;
+    }
 
-	bool operator!=(const HybridIterator& other) const {
-		return !(*this == other);
-	}
+    bool operator!=(const HybridIterator& other) const {
+        return !(*this == other);
+    }
 
-	T operator*() {
-		return *value;
-	}
+    T operator*() {
+        return *value;
+    }
 
-	T *operator->() {
-		return value;
-	}
+    T *operator->() {
+        return value;
+    }
 
-	T* value = nullptr;
+    T* value = nullptr;
 
 private:
-	bool linked = false;
-	T *end = nullptr;
+    bool linked = false;
+    T *end = nullptr;
 };
 
 #endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 0d85b49bc..df8980f7e 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -10,687 +10,687 @@
 
 template<typename T>
 class Index: public SerializeIF{
-	/**
-	 * Index is the Type used for the list of indices. The template parameter is the type which describes the index, it needs to be a child of SerializeIF to be able to make it persistent
-	 */
-	static_assert(std::is_base_of<SerializeIF,T>::value,"Wrong Type for Index, Type must implement SerializeIF");
+    /**
+     * Index is the Type used for the list of indices. The template parameter is the type which describes the index, it needs to be a child of SerializeIF to be able to make it persistent
+     */
+    static_assert(std::is_base_of<SerializeIF,T>::value,"Wrong Type for Index, Type must implement SerializeIF");
 public:
-	Index():blockStartAddress(0),size(0),storedPackets(0){}
+    Index():blockStartAddress(0),size(0),storedPackets(0){}
 
-	Index(uint32_t startAddress):blockStartAddress(startAddress),size(0),storedPackets(0){
+    Index(uint32_t startAddress):blockStartAddress(startAddress),size(0),storedPackets(0){
 
-	}
+    }
 
-	void setBlockStartAddress(uint32_t newAddress){
-		this->blockStartAddress = newAddress;
-	}
+    void setBlockStartAddress(uint32_t newAddress){
+        this->blockStartAddress = newAddress;
+    }
 
-	uint32_t getBlockStartAddress() const {
-		return blockStartAddress;
-	}
+    uint32_t getBlockStartAddress() const {
+        return blockStartAddress;
+    }
 
-	const T* getIndexType() const {
-		return &indexType;
-	}
+    const T* getIndexType() const {
+        return &indexType;
+    }
 
-	T* modifyIndexType(){
-		return &indexType;
-	}
-	/**
-	 * Updates the index Type. Uses = operator
-	 * @param indexType Type to copy from
-	 */
-	void setIndexType(T* indexType) {
-		this->indexType = *indexType;
-	}
+    T* modifyIndexType(){
+        return &indexType;
+    }
+    /**
+     * Updates the index Type. Uses = operator
+     * @param indexType Type to copy from
+     */
+    void setIndexType(T* indexType) {
+        this->indexType = *indexType;
+    }
 
-	uint32_t getSize() const {
-		return size;
-	}
+    uint32_t getSize() const {
+        return size;
+    }
 
-	void setSize(uint32_t size) {
-		this->size = size;
-	}
+    void setSize(uint32_t size) {
+        this->size = size;
+    }
 
-	void addSize(uint32_t size){
-		this->size += size;
-	}
+    void addSize(uint32_t size){
+        this->size += size;
+    }
 
-	void setStoredPackets(uint32_t newStoredPackets){
-		this->storedPackets = newStoredPackets;
-	}
+    void setStoredPackets(uint32_t newStoredPackets){
+        this->storedPackets = newStoredPackets;
+    }
 
-	void addStoredPackets(uint32_t packets){
-		this->storedPackets += packets;
-	}
+    void addStoredPackets(uint32_t packets){
+        this->storedPackets += packets;
+    }
 
-	uint32_t getStoredPackets() const{
-		return this->storedPackets;
-	}
+    uint32_t getStoredPackets() const{
+        return this->storedPackets;
+    }
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+                size_t maxSize, Endianness streamEndianness) const {
+        ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = indexType.serialize(buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
+        return result;
+    }
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		return result;
-	}
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                Endianness streamEndianness){
+        ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = indexType.deSerialize(buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        return result;
+    }
 
-	size_t getSerializedSize() const {
-		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
-		size += indexType.getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
-		return size;
-	}
+    size_t getSerializedSize() const {
+        uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
+        size += indexType.getSerializedSize();
+        size += SerializeAdapter::getSerializedSize(&this->size);
+        size += SerializeAdapter::getSerializedSize(&this->storedPackets);
+        return size;
+    }
 
 
-	bool operator==(const Index<T>& other){
-		return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
-	}
+    bool operator==(const Index<T>& other){
+        return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
+    }
 
 private:
-	uint32_t blockStartAddress;
-	uint32_t size;
-	uint32_t storedPackets;
-	T indexType;
+    uint32_t blockStartAddress;
+    uint32_t size;
+    uint32_t storedPackets;
+    T indexType;
 };
 
 
 
 template<typename T>
 class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
-	/**
-	 * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest data comes in last
-	 * It uses the currentWriteBlock as pointer to the current writing position
-	 * The currentReadBlock must be set manually
-	 */
+    /**
+     * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest data comes in last
+     * It uses the currentWriteBlock as pointer to the current writing position
+     * The currentReadBlock must be set manually
+     */
 public:
-	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock, SerializeIF* additionalInfo,
-			bool overwriteOld) :ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld){
+    IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock, SerializeIF* additionalInfo,
+            bool overwriteOld) :ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld){
 
-		//Calculate the maximum number of indices needed for this blocksize
-		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
+        //Calculate the maximum number of indices needed for this blocksize
+        uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
 
-		//Calculate the Size needeed for the index itself
-		uint32_t serializedSize = 0;
-		if(additionalInfo!=NULL){
-			serializedSize += additionalInfo->getSerializedSize();
-		}
-		//Size of current iterator type
-		Index<T> tempIndex;
-		serializedSize += tempIndex.getSerializedSize();
+        //Calculate the Size needeed for the index itself
+        uint32_t serializedSize = 0;
+        if(additionalInfo!=NULL){
+            serializedSize += additionalInfo->getSerializedSize();
+        }
+        //Size of current iterator type
+        Index<T> tempIndex;
+        serializedSize += tempIndex.getSerializedSize();
 
-		//Add Size of Array
-		serializedSize += sizeof(uint32_t); //size of array
-		serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
-		serializedSize += sizeof(uint16_t); //size of crc
+        //Add Size of Array
+        serializedSize += sizeof(uint32_t); //size of array
+        serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
+        serializedSize += sizeof(uint16_t); //size of crc
 
-		//Calculate new size after index
-		if(serializedSize > totalSize){
-			error << "IndexedRingMemory: Store is too small for index" << std::endl;
-		}
-		uint32_t useableSize = totalSize - serializedSize;
-		//Update the totalSize for calculations
-		totalSize = useableSize;
+        //Calculate new size after index
+        if(serializedSize > totalSize){
+            error << "IndexedRingMemory: Store is too small for index" << std::endl;
+        }
+        uint32_t useableSize = totalSize - serializedSize;
+        //Update the totalSize for calculations
+        totalSize = useableSize;
 
-		//True StartAddress
-		uint32_t trueStartAddress = indexAddress + serializedSize;
+        //True StartAddress
+        uint32_t trueStartAddress = indexAddress + serializedSize;
 
-		//Calculate True number of Blocks and reset size of true Number of Blocks
-		uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
+        //Calculate True number of Blocks and reset size of true Number of Blocks
+        uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
 
-		//allocate memory now
-		this->entries = new Index<T>[trueNumberOfBlocks];
-		this->size = trueNumberOfBlocks;
-		this->maxSize_ = trueNumberOfBlocks;
-		this->allocated = true;
+        //allocate memory now
+        this->entries = new Index<T>[trueNumberOfBlocks];
+        this->size = trueNumberOfBlocks;
+        this->maxSize_ = trueNumberOfBlocks;
+        this->allocated = true;
 
-		//Check trueNumberOfBlocks
-		if(trueNumberOfBlocks<1){
-			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
-		}
+        //Check trueNumberOfBlocks
+        if(trueNumberOfBlocks<1){
+            error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
+        }
 
 
 
-		//Fill address into index
-		uint32_t address = trueStartAddress;
-		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
-			it->setBlockStartAddress(address);
-			it->setSize(0);
-			it->setStoredPackets(0);
-			address += bytesPerBlock;
-		}
+        //Fill address into index
+        uint32_t address = trueStartAddress;
+        for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
+            it->setBlockStartAddress(address);
+            it->setSize(0);
+            it->setStoredPackets(0);
+            address += bytesPerBlock;
+        }
 
 
-		//Initialize iterators
-		currentWriteBlock = this->begin();
-		currentReadBlock = this->begin();
-		lastBlockToRead = this->begin();
+        //Initialize iterators
+        currentWriteBlock = this->begin();
+        currentReadBlock = this->begin();
+        lastBlockToRead = this->begin();
 
-		//Check last blockSize
-		uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
-		if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
-			//remove the last Block so the second last block has more size
-			this->size -= 1;
-			debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
-		}
-	}
+        //Check last blockSize
+        uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
+        if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
+            //remove the last Block so the second last block has more size
+            this->size -= 1;
+            debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
+        }
+    }
 
-	/**
-	 * Resets the whole index, the iterators and executes the given reset function on every index type
-	 * @param typeResetFnc static reset function which accepts a pointer to the index Type
-	 */
-	void reset(void (*typeResetFnc)(T*)){
-		currentReadBlock = this->begin();
-		currentWriteBlock = this->begin();
-		lastBlockToRead = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = 0;
-		lastBlockToReadSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
-			it->setSize(0);
-			it->setStoredPackets(0);
-			(*typeResetFnc)(it->modifyIndexType());
-		}
-	}
+    /**
+     * Resets the whole index, the iterators and executes the given reset function on every index type
+     * @param typeResetFnc static reset function which accepts a pointer to the index Type
+     */
+    void reset(void (*typeResetFnc)(T*)){
+        currentReadBlock = this->begin();
+        currentWriteBlock = this->begin();
+        lastBlockToRead = this->begin();
+        currentReadSize = 0;
+        currentReadBlockSizeCached = 0;
+        lastBlockToReadSize = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
+            it->setSize(0);
+            it->setStoredPackets(0);
+            (*typeResetFnc)(it->modifyIndexType());
+        }
+    }
 
-	void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
-		it->setSize(0);
-		it->setStoredPackets(0);
-		(*typeResetFnc)(it->modifyIndexType());
-	}
+    void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
+        it->setSize(0);
+        it->setStoredPackets(0);
+        (*typeResetFnc)(it->modifyIndexType());
+    }
 
-	/*
-	 * Reading
-	 */
+    /*
+     * Reading
+     */
 
-	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
-		currentReadBlock = it;
-		currentReadBlockSizeCached = it->getSize();
-	}
+    void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
+        currentReadBlock = it;
+        currentReadBlockSizeCached = it->getSize();
+    }
 
-	void resetRead(){
-		currentReadBlock = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = this->begin()->getSize();
-		lastBlockToRead = currentWriteBlock;
-		lastBlockToReadSize = currentWriteBlock->getSize();
-	}
-	/**
-	 * Sets the last block to read to this iterator.
-	 * Can be used to dump until block x
-	 * @param it The iterator for the last read block
-	 */
-	void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
-		lastBlockToRead = it;
-		lastBlockToReadSize = it->getSize();
-	}
+    void resetRead(){
+        currentReadBlock = this->begin();
+        currentReadSize = 0;
+        currentReadBlockSizeCached = this->begin()->getSize();
+        lastBlockToRead = currentWriteBlock;
+        lastBlockToReadSize = currentWriteBlock->getSize();
+    }
+    /**
+     * Sets the last block to read to this iterator.
+     * Can be used to dump until block x
+     * @param it The iterator for the last read block
+     */
+    void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
+        lastBlockToRead = it;
+        lastBlockToReadSize = it->getSize();
+    }
 
-	/**
-	 * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
-	 * Can be the currentWriteBlock as well
-	 */
-	void readOldest(){
-		resetRead();
-		currentReadBlock = getNextNonEmptyBlock();
-		currentReadBlockSizeCached = currentReadBlock->getSize();
+    /**
+     * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
+     * Can be the currentWriteBlock as well
+     */
+    void readOldest(){
+        resetRead();
+        currentReadBlock = getNextNonEmptyBlock();
+        currentReadBlockSizeCached = currentReadBlock->getSize();
 
-	}
+    }
 
-	/**
-	 * Sets the current read iterator to the next Block and resets the current read size
-	 * The current size of the block will be cached to avoid race condition between write and read
-	 * If the end of the ring is reached the read pointer will be set to the begin
-	 */
-	void readNext(){
-		currentReadSize = 0;
-		if((this->size != 0) && (currentReadBlock.value ==this->back())){
-			currentReadBlock = this->begin();
-		}else{
-			currentReadBlock++;
-		}
+    /**
+     * Sets the current read iterator to the next Block and resets the current read size
+     * The current size of the block will be cached to avoid race condition between write and read
+     * If the end of the ring is reached the read pointer will be set to the begin
+     */
+    void readNext(){
+        currentReadSize = 0;
+        if((this->size != 0) && (currentReadBlock.value ==this->back())){
+            currentReadBlock = this->begin();
+        }else{
+            currentReadBlock++;
+        }
 
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-	}
+        currentReadBlockSizeCached = currentReadBlock->getSize();
+    }
 
-	/**
-	 * Returns the address which is currently read from
-	 * @return Address to read from
-	 */
-	uint32_t getCurrentReadAddress() const {
-		return getAddressOfCurrentReadBlock() + currentReadSize;
-	}
-	/**
-	 * Adds readSize to the current size and checks if the read has no more data left and advances the read block
-	 * @param readSize The size that was read
-	 * @return Returns true if the read can go on
-	 */
-	bool addReadSize(uint32_t readSize) {
-		if(currentReadBlock == lastBlockToRead){
-			//The current read block is the last to read
-			if((currentReadSize+readSize)<lastBlockToReadSize){
-				//the block has more data -> return true
-				currentReadSize += readSize;
-				return true;
-			}else{
-				//Reached end of read -> return false
-				currentReadSize = lastBlockToReadSize;
-				return false;
-			}
-		}else{
-			//We are not in the last Block
-			if((currentReadSize + readSize)<currentReadBlockSizeCached){
-				//The current Block has more data
-				currentReadSize += readSize;
-				return true;
-			}else{
-				//The current block is written completely
-				readNext();
-				if(currentReadBlockSizeCached==0){
-					//Next block is empty
-					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
-					//Search if any block between this and the last block is not empty
-					for(;it!=lastBlockToRead;++it){
-						if(it == this->end()){
-							//This is the end, next block is the begin
-							it = this->begin();
-							if(it == lastBlockToRead){
-								//Break if the begin is the lastBlockToRead
-								break;
-							}
-						}
-						if(it->getSize()!=0){
-							//This is a non empty block. Go on reading with this block
-							currentReadBlock = it;
-							currentReadBlockSizeCached = it->getSize();
-							return true;
-						}
-					}
-					//reached lastBlockToRead and every block was empty, check if the last block is also empty
-					if(lastBlockToReadSize!=0){
-						//go on with last Block
-						currentReadBlock = lastBlockToRead;
-						currentReadBlockSizeCached = lastBlockToReadSize;
-						return true;
-					}
-					//There is no non empty block left
-					return false;
-				}
-				//Size is larger than 0
-				return true;
-			}
-		}
-	}
-	uint32_t getRemainigSizeOfCurrentReadBlock() const{
-		if(currentReadBlock == lastBlockToRead){
-			return (lastBlockToReadSize - currentReadSize);
-		}else{
-			return (currentReadBlockSizeCached - currentReadSize);
-		}
-	}
+    /**
+     * Returns the address which is currently read from
+     * @return Address to read from
+     */
+    uint32_t getCurrentReadAddress() const {
+        return getAddressOfCurrentReadBlock() + currentReadSize;
+    }
+    /**
+     * Adds readSize to the current size and checks if the read has no more data left and advances the read block
+     * @param readSize The size that was read
+     * @return Returns true if the read can go on
+     */
+    bool addReadSize(uint32_t readSize) {
+        if(currentReadBlock == lastBlockToRead){
+            //The current read block is the last to read
+            if((currentReadSize+readSize)<lastBlockToReadSize){
+                //the block has more data -> return true
+                currentReadSize += readSize;
+                return true;
+            }else{
+                //Reached end of read -> return false
+                currentReadSize = lastBlockToReadSize;
+                return false;
+            }
+        }else{
+            //We are not in the last Block
+            if((currentReadSize + readSize)<currentReadBlockSizeCached){
+                //The current Block has more data
+                currentReadSize += readSize;
+                return true;
+            }else{
+                //The current block is written completely
+                readNext();
+                if(currentReadBlockSizeCached==0){
+                    //Next block is empty
+                    typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
+                    //Search if any block between this and the last block is not empty
+                    for(;it!=lastBlockToRead;++it){
+                        if(it == this->end()){
+                            //This is the end, next block is the begin
+                            it = this->begin();
+                            if(it == lastBlockToRead){
+                                //Break if the begin is the lastBlockToRead
+                                break;
+                            }
+                        }
+                        if(it->getSize()!=0){
+                            //This is a non empty block. Go on reading with this block
+                            currentReadBlock = it;
+                            currentReadBlockSizeCached = it->getSize();
+                            return true;
+                        }
+                    }
+                    //reached lastBlockToRead and every block was empty, check if the last block is also empty
+                    if(lastBlockToReadSize!=0){
+                        //go on with last Block
+                        currentReadBlock = lastBlockToRead;
+                        currentReadBlockSizeCached = lastBlockToReadSize;
+                        return true;
+                    }
+                    //There is no non empty block left
+                    return false;
+                }
+                //Size is larger than 0
+                return true;
+            }
+        }
+    }
+    uint32_t getRemainigSizeOfCurrentReadBlock() const{
+        if(currentReadBlock == lastBlockToRead){
+            return (lastBlockToReadSize - currentReadSize);
+        }else{
+            return (currentReadBlockSizeCached - currentReadSize);
+        }
+    }
 
-	uint32_t getAddressOfCurrentReadBlock() const {
-		return currentReadBlock->getBlockStartAddress();
-	}
+    uint32_t getAddressOfCurrentReadBlock() const {
+        return currentReadBlock->getBlockStartAddress();
+    }
 
-	/**
-	 * Gets the next non empty Block after the current write block,
-	 * @return Returns the iterator to the block. If there is non, the current write block is returned
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
-		for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
-				if(it == this->end()){
-					it = this->begin();
-					if(it == currentWriteBlock){
-						break;
-					}
-				}
-				if(it->getSize()!=0){
-					return it;
-				}
-		}
-		return currentWriteBlock;
-	}
+    /**
+     * Gets the next non empty Block after the current write block,
+     * @return Returns the iterator to the block. If there is non, the current write block is returned
+     */
+    typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
+        for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
+                if(it == this->end()){
+                    it = this->begin();
+                    if(it == currentWriteBlock){
+                        break;
+                    }
+                }
+                if(it->getSize()!=0){
+                    return it;
+                }
+        }
+        return currentWriteBlock;
+    }
 
-	/**
-	 * Returns a copy of the oldest Index type
-	 * @return Type of Index
-	 */
-	T* getOldest(){
-		return (getNextNonEmptyBlock()->modifyIndexType());
-	}
+    /**
+     * Returns a copy of the oldest Index type
+     * @return Type of Index
+     */
+    T* getOldest(){
+        return (getNextNonEmptyBlock()->modifyIndexType());
+    }
 
 
-	/*
-	 * Writing
-	 */
-	uint32_t getAddressOfCurrentWriteBlock() const{
-		return currentWriteBlock->getBlockStartAddress();
-	}
+    /*
+     * Writing
+     */
+    uint32_t getAddressOfCurrentWriteBlock() const{
+        return currentWriteBlock->getBlockStartAddress();
+    }
 
-	uint32_t getSizeOfCurrentWriteBlock() const{
-		return currentWriteBlock->getSize();
-	}
+    uint32_t getSizeOfCurrentWriteBlock() const{
+        return currentWriteBlock->getSize();
+    }
 
-	uint32_t getCurrentWriteAddress() const{
-		return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
-	}
+    uint32_t getCurrentWriteAddress() const{
+        return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
+    }
 
-	void clearCurrentWriteBlock(){
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-	}
+    void clearCurrentWriteBlock(){
+        currentWriteBlock->setSize(0);
+        currentWriteBlock->setStoredPackets(0);
+    }
 
-	void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
-		currentWriteBlock->addSize(size);
-		currentWriteBlock->addStoredPackets(storedPackets);
-	}
+    void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
+        currentWriteBlock->addSize(size);
+        currentWriteBlock->addStoredPackets(storedPackets);
+    }
 
-	T* modifyCurrentWriteBlockIndexType(){
-		return currentWriteBlock->modifyIndexType();
-	}
-	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
-		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
-		it->addSize(size);
-		it->addStoredPackets(storedPackets);
-	}
+    T* modifyCurrentWriteBlockIndexType(){
+        return currentWriteBlock->modifyIndexType();
+    }
+    void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
+        typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
+        it->addSize(size);
+        it->addStoredPackets(storedPackets);
+    }
 
 
-	/**
-	 * Checks if the block has enough space for sizeToWrite
-	 * @param sizeToWrite The data to be written in the Block
-	 * @return Returns true if size to write is smaller the remaining size of the block
-	 */
-	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
-		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
-		uint32_t addressOfNextBlock = next->getBlockStartAddress();
-		uint32_t availableSize = ((addressOfNextBlock+totalSize) - (getAddressOfCurrentWriteBlock()+getSizeOfCurrentWriteBlock()))%totalSize;
-		return (sizeToWrite < availableSize);
-	}
+    /**
+     * Checks if the block has enough space for sizeToWrite
+     * @param sizeToWrite The data to be written in the Block
+     * @return Returns true if size to write is smaller the remaining size of the block
+     */
+    bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
+        typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
+        uint32_t addressOfNextBlock = next->getBlockStartAddress();
+        uint32_t availableSize = ((addressOfNextBlock+totalSize) - (getAddressOfCurrentWriteBlock()+getSizeOfCurrentWriteBlock()))%totalSize;
+        return (sizeToWrite < availableSize);
+    }
 
-	/**
-	 * Checks if the store is full if overwrite old is false
-	 * @return Returns true if it is writeable and false if not
-	 */
-	bool isNextBlockWritable(){
-		//First check if this is the end of the list
-		typename IndexedRingMemoryArray<T>::Iterator next;
-		next = getNextWrite();
-		if((next->getSize()!=0) && (!overwriteOld)){
-			return false;
-		}
-		return true;
-	}
+    /**
+     * Checks if the store is full if overwrite old is false
+     * @return Returns true if it is writeable and false if not
+     */
+    bool isNextBlockWritable(){
+        //First check if this is the end of the list
+        typename IndexedRingMemoryArray<T>::Iterator next;
+        next = getNextWrite();
+        if((next->getSize()!=0) && (!overwriteOld)){
+            return false;
+        }
+        return true;
+    }
 
-	/**
-	 * Updates current write Block Index Type
-	 * @param infoOfNewBlock
-	 */
-	void updateCurrentBlock(T* infoOfNewBlock){
-		currentWriteBlock->setIndexType(infoOfNewBlock);
-	}
+    /**
+     * Updates current write Block Index Type
+     * @param infoOfNewBlock
+     */
+    void updateCurrentBlock(T* infoOfNewBlock){
+        currentWriteBlock->setIndexType(infoOfNewBlock);
+    }
 
 
-	/**
-	 * Succeed to next block, returns FAILED if overwrite is false and the store is full
-	 * @return
-	 */
-	ReturnValue_t writeNext(){
-		//Check Next Block
-		if(!isNextBlockWritable()){
-			//The Index is full and does not overwrite old
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		//Next block can be written, update Metadata
-		currentWriteBlock = getNextWrite();
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    /**
+     * Succeed to next block, returns FAILED if overwrite is false and the store is full
+     * @return
+     */
+    ReturnValue_t writeNext(){
+        //Check Next Block
+        if(!isNextBlockWritable()){
+            //The Index is full and does not overwrite old
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        //Next block can be written, update Metadata
+        currentWriteBlock = getNextWrite();
+        currentWriteBlock->setSize(0);
+        currentWriteBlock->setStoredPackets(0);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	/**
-	 * Serializes the Index and calculates the CRC.
-	 * Parameters according to HasSerializeIF
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param streamEndianness
-	 * @return
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const{
-		uint8_t* crcBuffer = *buffer;
-		uint32_t oldSize = *size;
-		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
-		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
+    /**
+     * Serializes the Index and calculates the CRC.
+     * Parameters according to HasSerializeIF
+     * @param buffer
+     * @param size
+     * @param maxSize
+     * @param streamEndianness
+     * @return
+     */
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+                size_t maxSize, Endianness streamEndianness) const{
+        uint8_t* crcBuffer = *buffer;
+        uint32_t oldSize = *size;
+        if(additionalInfo!=NULL){
+            additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
+        }
+        ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
 
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+            result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
+                    maxSize, streamEndianness);
+            ++i;
+        }
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
+        result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
+        return result;
+    }
 
 
-	/**
-	 * Get the serialized Size of the index
-	 * @return The serialized size of the index
-	 */
-	size_t getSerializedSize() const {
+    /**
+     * Get the serialized Size of the index
+     * @return The serialized size of the index
+     */
+    size_t getSerializedSize() const {
 
-		uint32_t size = 0;
-		if(additionalInfo!=NULL){
-			size += additionalInfo->getSerializedSize();
-		}
-		size += currentWriteBlock->getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += (this->entries[0].getSerializedSize()) * this->size;
-		uint16_t crc = 0;
-		size += SerializeAdapter::getSerializedSize(&crc);
-		return size;
-	}
-	/**
-	 * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
-	 * CRC Has to be checked before!
-	 * @param buffer
-	 * @param size
-	 * @param streamEndianness
-	 * @return
-	 */
+        uint32_t size = 0;
+        if(additionalInfo!=NULL){
+            size += additionalInfo->getSerializedSize();
+        }
+        size += currentWriteBlock->getSerializedSize();
+        size += SerializeAdapter::getSerializedSize(&this->size);
+        size += (this->entries[0].getSerializedSize()) * this->size;
+        uint16_t crc = 0;
+        size += SerializeAdapter::getSerializedSize(&crc);
+        return size;
+    }
+    /**
+     * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
+     * CRC Has to be checked before!
+     * @param buffer
+     * @param size
+     * @param streamEndianness
+     * @return
+     */
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                Endianness streamEndianness){
 
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
+        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+        if(additionalInfo!=NULL){
+            result = additionalInfo->deSerialize(buffer,size,streamEndianness);
+        }
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
 
-		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		uint32_t tempSize = 0;
-		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		if(this->size != tempSize){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::deSerialize(
-					&this->entries[i], buffer, size,
-					streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			if(*(cmp.value) == *(it.value)){
-				currentWriteBlock = it;
-				return HasReturnvaluesIF::RETURN_OK;
-			}
-		}
-		//Reached if current write block iterator is not found
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        Index<T> tempIndex;
+        result = tempIndex.deSerialize(buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        uint32_t tempSize = 0;
+        result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        if(this->size != tempSize){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+            result = SerializeAdapter::deSerialize(
+                    &this->entries[i], buffer, size,
+                    streamEndianness);
+            ++i;
+        }
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            if(*(cmp.value) == *(it.value)){
+                currentWriteBlock = it;
+                return HasReturnvaluesIF::RETURN_OK;
+            }
+        }
+        //Reached if current write block iterator is not found
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	uint32_t getIndexAddress() const {
-		return indexAddress;
-	}
+    uint32_t getIndexAddress() const {
+        return indexAddress;
+    }
 
 
-	/*
-	 * Statistics
-	 */
-	uint32_t getStoredPackets() const {
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getStoredPackets();
-		}
-		return size;
-	}
+    /*
+     * Statistics
+     */
+    uint32_t getStoredPackets() const {
+        uint32_t size = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            size += it->getStoredPackets();
+        }
+        return size;
+    }
 
-	uint32_t getTotalSize() const {
-		return totalSize;
-	}
+    uint32_t getTotalSize() const {
+        return totalSize;
+    }
 
-	uint32_t getCurrentSize() const{
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getSize();
-		}
-		return size;
-	}
+    uint32_t getCurrentSize() const{
+        uint32_t size = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            size += it->getSize();
+        }
+        return size;
+    }
 
-	bool isEmpty() const{
-		return getCurrentSize()==0;
-	}
+    bool isEmpty() const{
+        return getCurrentSize()==0;
+    }
 
-	double getPercentageFilled() const{
-		uint32_t filledSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			filledSize += it->getSize();
-		}
+    double getPercentageFilled() const{
+        uint32_t filledSize = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            filledSize += it->getSize();
+        }
 
-		return (double)filledSize/(double)this->totalSize;
-	}
+        return (double)filledSize/(double)this->totalSize;
+    }
 
-	typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
-		return currentWriteBlock;
-	}
-	/**
-	 * Get the next block of the currentWriteBlock.
-	 * Returns the first one if currentWriteBlock is the last one
-	 * @return Iterator pointing to the next block after currentWriteBlock
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
-		typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
-		if((this->size != 0) && (currentWriteBlock.value == this->back())){
-			next = this->begin();
-		}else{
-			++next;
-		}
-		return next;
-	}
-	/**
-	 * Get the block in front of the Iterator
-	 * Returns the last block if it is the first block
-	 * @param it iterator which you want the previous block from
-	 * @return pointing to the block before it
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
-		if(this->begin() == it){
-			typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
-			return next;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator next(it);
-		--next;
-		return next;
-	}
+    typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
+        return currentWriteBlock;
+    }
+    /**
+     * Get the next block of the currentWriteBlock.
+     * Returns the first one if currentWriteBlock is the last one
+     * @return Iterator pointing to the next block after currentWriteBlock
+     */
+    typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
+        typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
+        if((this->size != 0) && (currentWriteBlock.value == this->back())){
+            next = this->begin();
+        }else{
+            ++next;
+        }
+        return next;
+    }
+    /**
+     * Get the block in front of the Iterator
+     * Returns the last block if it is the first block
+     * @param it iterator which you want the previous block from
+     * @return pointing to the block before it
+     */
+    typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
+        if(this->begin() == it){
+            typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
+            return next;
+        }
+        typename IndexedRingMemoryArray<T>::Iterator next(it);
+        --next;
+        return next;
+    }
 private:
-	//The total size used by the blocks (without index)
-	uint32_t totalSize;
+    //The total size used by the blocks (without index)
+    uint32_t totalSize;
 
-	//The address of the index
-	const uint32_t indexAddress;
+    //The address of the index
+    const uint32_t indexAddress;
 
-	//The iterators for writing and reading
-	typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
-	typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
+    //The iterators for writing and reading
+    typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
+    typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
 
-	//How much of the current read block is read already
-	uint32_t currentReadSize;
+    //How much of the current read block is read already
+    uint32_t currentReadSize;
 
-	//Cached Size of current read block
-	uint32_t currentReadBlockSizeCached;
+    //Cached Size of current read block
+    uint32_t currentReadBlockSizeCached;
 
-	//Last block of current write (should be write block)
-	typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
-	//current size of last Block to read
-	uint32_t lastBlockToReadSize;
+    //Last block of current write (should be write block)
+    typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
+    //current size of last Block to read
+    uint32_t lastBlockToReadSize;
 
-	//Additional Info to be serialized with the index
-	SerializeIF* additionalInfo;
+    //Additional Info to be serialized with the index
+    SerializeIF* additionalInfo;
 
-	//Does it overwrite old blocks?
-	const bool overwriteOld;
+    //Does it overwrite old blocks?
+    const bool overwriteOld;
 
 };
 
diff --git a/container/PlacementFactory.h b/container/PlacementFactory.h
index a0aebb7d1..94b4aeefd 100644
--- a/container/PlacementFactory.h
+++ b/container/PlacementFactory.h
@@ -22,50 +22,50 @@
  */
 class PlacementFactory {
 public:
-	PlacementFactory(StorageManagerIF* backend) :
-			dataBackend(backend) {
-	}
+    PlacementFactory(StorageManagerIF* backend) :
+            dataBackend(backend) {
+    }
 
-	/***
-	 * Generates an object of type T in the backend storage.
-	 *
-	 * @warning Do not use with any Type that allocates memory internally!
-	 *
-	 * @tparam T Type of Object
-	 * @param args Constructor Arguments to be passed
-	 * @return A pointer to the new object or a nullptr in case of failure
-	 */
-	template<typename T, typename ... Args>
-	T* generate(Args&&... args) {
-		store_address_t tempId;
-		uint8_t* pData = nullptr;
-		ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
-				&pData);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return nullptr;
-		}
-		T* temp = new (pData) T(std::forward<Args>(args)...);
-		return temp;
-	}
-	/***
-	 * Function to destroy the object allocated with generate and free space in backend.
-	 * This must be called by the user.
-	 *
-	 * @param thisElement Element to be destroyed
-	 * @return RETURN_OK if the element was destroyed, different errors on failure
-	 */
-	template<typename T>
-	ReturnValue_t destroy(T* thisElement) {
-		if (thisElement == nullptr){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		//Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
-		thisElement->~T();
-		uint8_t* pointer = (uint8_t*) (thisElement);
-		return dataBackend->deleteData(pointer, sizeof(T));
-	}
+    /***
+     * Generates an object of type T in the backend storage.
+     *
+     * @warning Do not use with any Type that allocates memory internally!
+     *
+     * @tparam T Type of Object
+     * @param args Constructor Arguments to be passed
+     * @return A pointer to the new object or a nullptr in case of failure
+     */
+    template<typename T, typename ... Args>
+    T* generate(Args&&... args) {
+        store_address_t tempId;
+        uint8_t* pData = nullptr;
+        ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
+                &pData);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return nullptr;
+        }
+        T* temp = new (pData) T(std::forward<Args>(args)...);
+        return temp;
+    }
+    /***
+     * Function to destroy the object allocated with generate and free space in backend.
+     * This must be called by the user.
+     *
+     * @param thisElement Element to be destroyed
+     * @return RETURN_OK if the element was destroyed, different errors on failure
+     */
+    template<typename T>
+    ReturnValue_t destroy(T* thisElement) {
+        if (thisElement == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        //Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
+        thisElement->~T();
+        uint8_t* pointer = (uint8_t*) (thisElement);
+        return dataBackend->deleteData(pointer, sizeof(T));
+    }
 private:
-	StorageManagerIF* dataBackend;
+    StorageManagerIF* dataBackend;
 };
 
 #endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */
diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 886b9fab9..9277c50bf 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -7,107 +7,107 @@
 template<uint8_t N_READ_PTRS = 1>
 class RingBufferBase {
 public:
-	RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
-			start(startAddress), write(startAddress), size(size),
-			overwriteOld(overwriteOld) {
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = startAddress;
-		}
-	}
+    RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
+            start(startAddress), write(startAddress), size(size),
+            overwriteOld(overwriteOld) {
+        for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+            read[count] = startAddress;
+        }
+    }
 
-	virtual ~RingBufferBase() {}
+    virtual ~RingBufferBase() {}
 
-	bool isFull(uint8_t n = 0) {
-		return (availableWriteSpace(n) == 0);
-	}
-	bool isEmpty(uint8_t n = 0) {
-		return (getAvailableReadData(n) == 0);
-	}
+    bool isFull(uint8_t n = 0) {
+        return (availableWriteSpace(n) == 0);
+    }
+    bool isEmpty(uint8_t n = 0) {
+        return (getAvailableReadData(n) == 0);
+    }
 
-	size_t getAvailableReadData(uint8_t n = 0) const {
-		return ((write + size) - read[n]) % size;
-	}
-	size_t availableWriteSpace(uint8_t n = 0) const  {
-		//One less to avoid ambiguous full/empty problem.
-		return (((read[n] + size) - write - 1) % size);
-	}
+    size_t getAvailableReadData(uint8_t n = 0) const {
+        return ((write + size) - read[n]) % size;
+    }
+    size_t availableWriteSpace(uint8_t n = 0) const  {
+        //One less to avoid ambiguous full/empty problem.
+        return (((read[n] + size) - write - 1) % size);
+    }
 
-	bool overwritesOld() const {
-		return overwriteOld;
-	}
+    bool overwritesOld() const {
+        return overwriteOld;
+    }
 
-	size_t getMaxSize() const {
-		return size - 1;
-	}
+    size_t getMaxSize() const {
+        return size - 1;
+    }
 
-	void clear() {
-		write = start;
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = start;
-		}
-	}
+    void clear() {
+        write = start;
+        for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+            read[count] = start;
+        }
+    }
 
-	size_t writeTillWrap() {
-		return (start + size) - write;
-	}
+    size_t writeTillWrap() {
+        return (start + size) - write;
+    }
 
-	size_t readTillWrap(uint8_t n = 0) {
-		return (start + size) - read[n];
-	}
+    size_t readTillWrap(uint8_t n = 0) {
+        return (start + size) - read[n];
+    }
 
-	size_t getStart() const {
-		return start;
-	}
+    size_t getStart() const {
+        return start;
+    }
 
 protected:
-	const size_t start;
-	size_t write;
-	size_t read[N_READ_PTRS];
-	const size_t size;
-	const bool overwriteOld;
+    const size_t start;
+    size_t write;
+    size_t read[N_READ_PTRS];
+    const size_t size;
+    const bool overwriteOld;
 
-	void incrementWrite(uint32_t amount) {
-		write = ((write + amount - start) % size) + start;
-	}
-	void incrementRead(uint32_t amount, uint8_t n = 0) {
-		read[n] = ((read[n] + amount - start) % size) + start;
-	}
+    void incrementWrite(uint32_t amount) {
+        write = ((write + amount - start) % size) + start;
+    }
+    void incrementRead(uint32_t amount, uint8_t n = 0) {
+        read[n] = ((read[n] + amount - start) % size) + start;
+    }
 
-	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
-		if (getAvailableReadData(n) >= amount) {
-			incrementRead(amount, n);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
+    ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
+        if (getAvailableReadData(n) >= amount) {
+            incrementRead(amount, n);
+            return HasReturnvaluesIF::RETURN_OK;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
 
-	ReturnValue_t writeData(uint32_t amount) {
-		if (availableWriteSpace() >= amount or overwriteOld) {
-			incrementWrite(amount);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
+    ReturnValue_t writeData(uint32_t amount) {
+        if (availableWriteSpace() >= amount or overwriteOld) {
+            incrementWrite(amount);
+            return HasReturnvaluesIF::RETURN_OK;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
 
-	size_t getRead(uint8_t n = 0) const {
-		return read[n];
-	}
+    size_t getRead(uint8_t n = 0) const {
+        return read[n];
+    }
 
-	void setRead(uint32_t read, uint8_t n = 0) {
-		if (read >= start && read < (start+size)) {
-			this->read[n] = read;
-		}
-	}
+    void setRead(uint32_t read, uint8_t n = 0) {
+        if (read >= start && read < (start+size)) {
+            this->read[n] = read;
+        }
+    }
 
-	uint32_t getWrite() const {
-		return write;
-	}
+    uint32_t getWrite() const {
+        return write;
+    }
 
-	void setWrite(uint32_t write) {
-		this->write = write;
-	}
+    void setWrite(uint32_t write) {
+        this->write = write;
+    }
 };
 
 #endif /* FSFW_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 769ce0000..1681325d0 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -3,23 +3,23 @@
 #include "../ipc/MutexHelper.h"
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
-		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
+        bool overwriteOld, size_t maxExcessBytes):
+        SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
+        maxExcessBytes) {
+    mutex = MutexFactory::instance()->createMutex();
 }
 
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
-		const size_t size, bool overwriteOld, size_t maxExcessBytes):
-		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
+        const size_t size, bool overwriteOld, size_t maxExcessBytes):
+        SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
+        maxExcessBytes) {
+    mutex = MutexFactory::instance()->createMutex();
 }
 
 
 void SharedRingBuffer::setToUseReceiveSizeFIFO(size_t fifoDepth) {
-	this->fifoDepth = fifoDepth;
+    this->fifoDepth = fifoDepth;
 }
 
 ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
@@ -38,20 +38,20 @@ MutexIF* SharedRingBuffer::getMutexHandle() const {
 }
 
 ReturnValue_t SharedRingBuffer::initialize() {
-	if(fifoDepth > 0) {
-		receiveSizesFIFO = new DynamicFIFO<size_t>(fifoDepth);
-	}
-	return SystemObject::initialize();
+    if(fifoDepth > 0) {
+        receiveSizesFIFO = new DynamicFIFO<size_t>(fifoDepth);
+    }
+    return SystemObject::initialize();
 }
 
 DynamicFIFO<size_t>* SharedRingBuffer::getReceiveSizesFIFO() {
-	if(receiveSizesFIFO == nullptr) {
-		// Configuration error.
+    if(receiveSizesFIFO == nullptr) {
+        // Configuration error.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
-				<< " was not configured to have sizes FIFO, returning nullptr!"
-				<< std::endl;
+        sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
+                << " was not configured to have sizes FIFO, returning nullptr!"
+                << std::endl;
 #endif
-	}
-	return receiveSizesFIFO;
+    }
+    return receiveSizesFIFO;
 }
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 64d7ee291..43ab6e8fe 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -15,76 +15,76 @@
  * and unlock operations.
  */
 class SharedRingBuffer: public SystemObject,
-		public SimpleRingBuffer {
+        public SimpleRingBuffer {
 public:
-	/**
-	 * This constructor allocates a new internal buffer with the supplied size.
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes);
+    /**
+     * This constructor allocates a new internal buffer with the supplied size.
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+     */
+    SharedRingBuffer(object_id_t objectId, const size_t size,
+            bool overwriteOld, size_t maxExcessBytes);
 
-	/**
-	 * @brief	This function can be used to add an optional FIFO to the class
-	 * @details 
-	 * This FIFO will be allocated in the initialize function (and will
-	 * have a fixed maximum size after that). It can be used to store
-	 * values like packet sizes, for example for a shared ring buffer
-	 * used by producer/consumer tasks.
-	 */
-	void setToUseReceiveSizeFIFO(size_t fifoDepth);
+    /**
+     * @brief    This function can be used to add an optional FIFO to the class
+     * @details 
+     * This FIFO will be allocated in the initialize function (and will
+     * have a fixed maximum size after that). It can be used to store
+     * values like packet sizes, for example for a shared ring buffer
+     * used by producer/consumer tasks.
+     */
+    void setToUseReceiveSizeFIFO(size_t fifoDepth);
 
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes);
+    /**
+     * This constructor takes an external buffer with the specified size.
+     * @param buffer
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+     */
+    SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
+            bool overwriteOld, size_t maxExcessBytes);
 
-	/**
-	 * Unless a read-only constant value is read, all operations on the
-	 * shared ring buffer should be protected by calling this function.
-	 * @param timeoutType
-	 * @param timeout
-	 * @return
-	 */
-	virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
-	        dur_millis_t timeout);
-	/**
-	 * Any locked mutex also has to be unlocked, otherwise, access to the
-	 * shared ring buffer will be blocked.
-	 * @return
-	 */
-	virtual ReturnValue_t unlockRingBufferMutex();
+    /**
+     * Unless a read-only constant value is read, all operations on the
+     * shared ring buffer should be protected by calling this function.
+     * @param timeoutType
+     * @param timeout
+     * @return
+     */
+    virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
+            dur_millis_t timeout);
+    /**
+     * Any locked mutex also has to be unlocked, otherwise, access to the
+     * shared ring buffer will be blocked.
+     * @return
+     */
+    virtual ReturnValue_t unlockRingBufferMutex();
 
-	/**
-	 * The mutex handle can be accessed directly, for example to perform
-	 * the lock with the #MutexHelper for a RAII compliant lock operation.
-	 * @return
-	 */
-	MutexIF* getMutexHandle() const;
+    /**
+     * The mutex handle can be accessed directly, for example to perform
+     * the lock with the #MutexHelper for a RAII compliant lock operation.
+     * @return
+     */
+    MutexIF* getMutexHandle() const;
 
-	ReturnValue_t initialize() override;
+    ReturnValue_t initialize() override;
 
-	/**
-	 * If the shared ring buffer was configured to have a sizes FIFO, a handle
-	 * to that FIFO can be retrieved with this function.
-	 * Do not forget to protect access with a lock if required!
-	 * @return
-	 */
-	DynamicFIFO<size_t>* getReceiveSizesFIFO();
+    /**
+     * If the shared ring buffer was configured to have a sizes FIFO, a handle
+     * to that FIFO can be retrieved with this function.
+     * Do not forget to protect access with a lock if required!
+     * @return
+     */
+    DynamicFIFO<size_t>* getReceiveSizesFIFO();
 private:
-	MutexIF* mutex = nullptr;
+    MutexIF* mutex = nullptr;
 
-	size_t fifoDepth = 0;
-	DynamicFIFO<size_t>* receiveSizesFIFO = nullptr;
+    size_t fifoDepth = 0;
+    DynamicFIFO<size_t>* receiveSizesFIFO = nullptr;
 };
 
 
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 88c9290ef..8544acbf3 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -2,31 +2,31 @@
 #include <cstring>
 
 SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
-		size_t maxExcessBytes) :
-		RingBufferBase<>(0, size, overwriteOld),
-		maxExcessBytes(maxExcessBytes) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
-	buffer = new uint8_t[size + maxExcessBytes];
+        size_t maxExcessBytes) :
+        RingBufferBase<>(0, size, overwriteOld),
+        maxExcessBytes(maxExcessBytes) {
+    if(maxExcessBytes > size) {
+        this->maxExcessBytes = size;
+    }
+    else {
+        this->maxExcessBytes = maxExcessBytes;
+    }
+    buffer = new uint8_t[size + maxExcessBytes];
 }
 
 SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
+        bool overwriteOld, size_t maxExcessBytes):
         RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
+    if(maxExcessBytes > size) {
+        this->maxExcessBytes = size;
+    }
+    else {
+        this->maxExcessBytes = maxExcessBytes;
+    }
 }
 
 SimpleRingBuffer::~SimpleRingBuffer() {
-	delete[] buffer;
+    delete[] buffer;
 }
 
 ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
@@ -48,58 +48,58 @@ ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
 }
 
 void SimpleRingBuffer::confirmBytesWritten(size_t amount) {
-	if(getExcessBytes() > 0) {
-		moveExcessBytesToStart();
-	}
-	incrementWrite(amount);
+    if(getExcessBytes() > 0) {
+        moveExcessBytesToStart();
+    }
+    incrementWrite(amount);
 
 }
 
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
-		size_t amount) {
-	if (availableWriteSpace() >= amount or overwriteOld) {
-		size_t amountTillWrap = writeTillWrap();
-		if (amountTillWrap >= amount) {
-			// remaining size in buffer is sufficient to fit full amount.
-			memcpy(&buffer[write], data, amount);
-		}
-		else {
-			memcpy(&buffer[write], data, amountTillWrap);
-			memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
-		}
-		incrementWrite(amount);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        size_t amount) {
+    if (availableWriteSpace() >= amount or overwriteOld) {
+        size_t amountTillWrap = writeTillWrap();
+        if (amountTillWrap >= amount) {
+            // remaining size in buffer is sufficient to fit full amount.
+            memcpy(&buffer[write], data, amount);
+        }
+        else {
+            memcpy(&buffer[write], data, amountTillWrap);
+            memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
+        }
+        incrementWrite(amount);
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
-		bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
-	size_t availableData = getAvailableReadData(READ_PTR);
-	size_t amountTillWrap = readTillWrap(READ_PTR);
-	if (availableData < amount) {
-		if (readRemaining) {
-			// more data available than amount specified.
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	if (amountTillWrap >= amount) {
-		memcpy(data, &buffer[read[READ_PTR]], amount);
-	} else {
-		memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
-		memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
-	}
+        bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
+    size_t availableData = getAvailableReadData(READ_PTR);
+    size_t amountTillWrap = readTillWrap(READ_PTR);
+    if (availableData < amount) {
+        if (readRemaining) {
+            // more data available than amount specified.
+            amount = availableData;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    if (trueAmount != nullptr) {
+        *trueAmount = amount;
+    }
+    if (amountTillWrap >= amount) {
+        memcpy(data, &buffer[read[READ_PTR]], amount);
+    } else {
+        memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
+        memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
+    }
 
-	if(incrementReadPtr) {
-		deleteData(amount, readRemaining);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    if(incrementReadPtr) {
+        deleteData(amount, readRemaining);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 size_t SimpleRingBuffer::getExcessBytes() const {
@@ -114,18 +114,18 @@ void SimpleRingBuffer::moveExcessBytesToStart() {
 }
 
 ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
-		bool deleteRemaining, size_t* trueAmount) {
-	size_t availableData = getAvailableReadData(READ_PTR);
-	if (availableData < amount) {
-		if (deleteRemaining) {
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	incrementRead(amount, READ_PTR);
-	return HasReturnvaluesIF::RETURN_OK;
+        bool deleteRemaining, size_t* trueAmount) {
+    size_t availableData = getAvailableReadData(READ_PTR);
+    if (availableData < amount) {
+        if (deleteRemaining) {
+            amount = availableData;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    if (trueAmount != nullptr) {
+        *trueAmount = amount;
+    }
+    incrementRead(amount, READ_PTR);
+    return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 37ad5679f..6f31c5fba 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -5,7 +5,7 @@
 #include <cstddef>
 
 /**
- * @brief 	Circular buffer implementation, useful for buffering
+ * @brief     Circular buffer implementation, useful for buffering
  *          into data streams.
  * @details
  * Note that the deleteData() has to be called to increment the read pointer.
@@ -25,104 +25,104 @@ public:
      * with getFreeElement.
      *
      */
-	SimpleRingBuffer(const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
+    SimpleRingBuffer(const size_t size, bool overwriteOld,
+            size_t maxExcessBytes = 0);
+    /**
+     * This constructor takes an external buffer with the specified size.
+     * @param buffer
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
      * will be overwritten.
-	 * @param maxExcessBytes
-	 * If the buffer can accomodate additional bytes for contigous write
-	 * operations with getFreeElement, this is the maximum allowed additional
-	 * size
-	 */
-	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
+     * @param maxExcessBytes
+     * If the buffer can accomodate additional bytes for contigous write
+     * operations with getFreeElement, this is the maximum allowed additional
+     * size
+     */
+    SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
+            size_t maxExcessBytes = 0);
 
-	virtual ~SimpleRingBuffer();
+    virtual ~SimpleRingBuffer();
 
-	/**
-	 * Write to circular buffer and increment write pointer by amount.
-	 * @param data
-	 * @param amount
-	 * @return -@c RETURN_OK if write operation was successfull
-	 * -@c RETURN_FAILED if
-	 */
-	ReturnValue_t writeData(const uint8_t* data, size_t amount);
+    /**
+     * Write to circular buffer and increment write pointer by amount.
+     * @param data
+     * @param amount
+     * @return -@c RETURN_OK if write operation was successfull
+     * -@c RETURN_FAILED if
+     */
+    ReturnValue_t writeData(const uint8_t* data, size_t amount);
 
-	/**
-	 * Returns a pointer to a free element. If the remaining buffer is
-	 * not large enough, the data will be written past the actual size
-	 * and the amount of excess bytes will be cached. This function
-	 * does not increment the write pointer!
-	 * @param writePointer Pointer to a pointer which can be used to write
-	 * contiguous blocks into the ring buffer
-	 * @param amount
-	 * @return
-	 */
-	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
+    /**
+     * Returns a pointer to a free element. If the remaining buffer is
+     * not large enough, the data will be written past the actual size
+     * and the amount of excess bytes will be cached. This function
+     * does not increment the write pointer!
+     * @param writePointer Pointer to a pointer which can be used to write
+     * contiguous blocks into the ring buffer
+     * @param amount
+     * @return
+     */
+    ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
 
-	/**
-	 * This increments the write pointer and also copies the excess bytes
-	 * to the beginning. It should be called if the write operation
-	 * conducted after calling getFreeElement() was performed.
-	 * @return
-	 */
-	void confirmBytesWritten(size_t amount);
+    /**
+     * This increments the write pointer and also copies the excess bytes
+     * to the beginning. It should be called if the write operation
+     * conducted after calling getFreeElement() was performed.
+     * @return
+     */
+    void confirmBytesWritten(size_t amount);
 
-	virtual size_t getExcessBytes() const;
-	/**
-	 * Helper functions which moves any excess bytes to the start
-	 * of the ring buffer.
-	 * @return
-	 */
-	virtual void moveExcessBytesToStart();
+    virtual size_t getExcessBytes() const;
+    /**
+     * Helper functions which moves any excess bytes to the start
+     * of the ring buffer.
+     * @return
+     */
+    virtual void moveExcessBytesToStart();
 
-	/**
-	 * Read from circular buffer at read pointer.
-	 * @param data
-	 * @param amount
-	 * @param incrementReadPtr
-	 * If this is set to true, the read pointer will be incremented.
-	 * If readRemaining is set to true, the read pointer will be incremented
-	 * accordingly.
-	 * @param readRemaining
-	 * If this is set to true, the data will be read even if the amount
-	 * specified exceeds the read data available.
-	 * @param trueAmount [out]
-	 * If readRemaining was set to true, the true amount read will be assigned
-	 * to the passed value.
-	 * @return
-	 * - @c RETURN_OK if data was read successfully
-	 * - @c RETURN_FAILED if not enough data was available and readRemaining
-	 *      was set to false.
-	 */
-	ReturnValue_t readData(uint8_t* data, size_t amount,
-			bool incrementReadPtr = false, bool readRemaining = false,
-			size_t* trueAmount = nullptr);
+    /**
+     * Read from circular buffer at read pointer.
+     * @param data
+     * @param amount
+     * @param incrementReadPtr
+     * If this is set to true, the read pointer will be incremented.
+     * If readRemaining is set to true, the read pointer will be incremented
+     * accordingly.
+     * @param readRemaining
+     * If this is set to true, the data will be read even if the amount
+     * specified exceeds the read data available.
+     * @param trueAmount [out]
+     * If readRemaining was set to true, the true amount read will be assigned
+     * to the passed value.
+     * @return
+     * - @c RETURN_OK if data was read successfully
+     * - @c RETURN_FAILED if not enough data was available and readRemaining
+     *      was set to false.
+     */
+    ReturnValue_t readData(uint8_t* data, size_t amount,
+            bool incrementReadPtr = false, bool readRemaining = false,
+            size_t* trueAmount = nullptr);
 
-	/**
-	 * Delete data by incrementing read pointer.
-	 * @param amount
-	 * @param deleteRemaining
-	 * If the amount specified is larger than the remaing size to read and this
-	 * is set to true, the remaining amount will be deleted as well
-	 * @param trueAmount [out]
-	 * If deleteRemaining was set to true, the amount deleted will be assigned
-	 * to the passed value.
-	 * @return
-	 */
-	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
-	        size_t* trueAmount = nullptr);
+    /**
+     * Delete data by incrementing read pointer.
+     * @param amount
+     * @param deleteRemaining
+     * If the amount specified is larger than the remaing size to read and this
+     * is set to true, the remaining amount will be deleted as well
+     * @param trueAmount [out]
+     * If deleteRemaining was set to true, the amount deleted will be assigned
+     * to the passed value.
+     * @return
+     */
+    ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
+            size_t* trueAmount = nullptr);
 
 private:
-	static const uint8_t READ_PTR = 0;
-	uint8_t* buffer = nullptr;
-	size_t maxExcessBytes;
-	size_t excessBytes = 0;
+    static const uint8_t READ_PTR = 0;
+    uint8_t* buffer = nullptr;
+    size_t maxExcessBytes;
+    size_t excessBytes = 0;
 };
 
 #endif /* FSFW_CONTAINER_SIMPLERINGBUFFER_H_ */
diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index eb6ae276a..02d590c5c 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -5,71 +5,71 @@
 #include <cstdint>
 
 /**
- * @brief	Linked list data structure,
- * 			each entry has a pointer to the next entry (singly)
+ * @brief    Linked list data structure,
+ *             each entry has a pointer to the next entry (singly)
  * @ingroup container
  */
 template<typename T>
 class LinkedElement {
 public:
-	T *value;
-	class Iterator {
-	public:
-		LinkedElement<T> *value = nullptr;
-		Iterator() {}
+    T *value;
+    class Iterator {
+    public:
+        LinkedElement<T> *value = nullptr;
+        Iterator() {}
 
-		Iterator(LinkedElement<T> *element) :
-				value(element) {
-		}
+        Iterator(LinkedElement<T> *element) :
+                value(element) {
+        }
 
-		Iterator& operator++() {
-			value = value->getNext();
-			return *this;
-		}
+        Iterator& operator++() {
+            value = value->getNext();
+            return *this;
+        }
 
-		Iterator operator++(int) {
-			Iterator tmp(*this);
-			operator++();
-			return tmp;
-		}
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
 
-		bool operator==(Iterator other) {
-			return value == other.value;
-		}
+        bool operator==(Iterator other) {
+            return value == other.value;
+        }
 
-		bool operator!=(Iterator other) {
-			return !(*this == other);
-		}
-		T *operator->() {
-			return value->value;
-		}
-	};
+        bool operator!=(Iterator other) {
+            return !(*this == other);
+        }
+        T *operator->() {
+            return value->value;
+        }
+    };
 
-	LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
-	       value(setElement), next(setNext) {}
+    LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
+           value(setElement), next(setNext) {}
 
-	virtual ~LinkedElement(){}
+    virtual ~LinkedElement(){}
 
-	virtual LinkedElement* getNext() const {
-		return next;
-	}
+    virtual LinkedElement* getNext() const {
+        return next;
+    }
 
-	virtual void setNext(LinkedElement* next) {
-		this->next = next;
-	}
+    virtual void setNext(LinkedElement* next) {
+        this->next = next;
+    }
 
-	virtual void setEnd() {
-	    this->next = nullptr;
-	}
+    virtual void setEnd() {
+        this->next = nullptr;
+    }
 
-	LinkedElement* begin() {
-		return this;
-	}
-	LinkedElement* end() {
-		return nullptr;
-	}
+    LinkedElement* begin() {
+        return this;
+    }
+    LinkedElement* end() {
+        return nullptr;
+    }
 private:
-	LinkedElement *next;
+    LinkedElement *next;
 };
 
 template<typename T>
@@ -77,52 +77,52 @@ class SinglyLinkedList {
 public:
     using ElementIterator = typename LinkedElement<T>::Iterator;
 
-	SinglyLinkedList() {}
+    SinglyLinkedList() {}
 
-	SinglyLinkedList(ElementIterator start) :
-			start(start.value) {}
+    SinglyLinkedList(ElementIterator start) :
+            start(start.value) {}
 
-	SinglyLinkedList(LinkedElement<T>* startElement) :
-			start(startElement) {}
+    SinglyLinkedList(LinkedElement<T>* startElement) :
+            start(startElement) {}
 
-	ElementIterator begin() const {
-		return ElementIterator::Iterator(start);
-	}
+    ElementIterator begin() const {
+        return ElementIterator::Iterator(start);
+    }
 
-	/** Returns iterator to nulltr */
-	ElementIterator end() const {
-		return ElementIterator::Iterator();
-	}
+    /** Returns iterator to nulltr */
+    ElementIterator end() const {
+        return ElementIterator::Iterator();
+    }
 
-	/**
-	 * Returns last element in singly linked list.
-	 * @return
-	 */
-	ElementIterator back() const {
-	    LinkedElement<T> *element = start;
-	    while (element->getNext() != nullptr) {
-	        element = element->getNext();
-	    }
-	    return ElementIterator::Iterator(element);
-	}
+    /**
+     * Returns last element in singly linked list.
+     * @return
+     */
+    ElementIterator back() const {
+        LinkedElement<T> *element = start;
+        while (element->getNext() != nullptr) {
+            element = element->getNext();
+        }
+        return ElementIterator::Iterator(element);
+    }
 
-	size_t getSize() const {
-		size_t size = 0;
-		LinkedElement<T> *element = start;
-		while (element != nullptr) {
-			size++;
-			element = element->getNext();
-		}
-		return size;
-	}
-	void setStart(LinkedElement<T>* firstElement) {
-		start = firstElement;
-	}
+    size_t getSize() const {
+        size_t size = 0;
+        LinkedElement<T> *element = start;
+        while (element != nullptr) {
+            size++;
+            element = element->getNext();
+        }
+        return size;
+    }
+    void setStart(LinkedElement<T>* firstElement) {
+        start = firstElement;
+    }
 
-	void setNext(LinkedElement<T>* currentElement,
-	        LinkedElement<T>* nextElement) {
-	    currentElement->setNext(nextElement);
-	}
+    void setNext(LinkedElement<T>* currentElement,
+            LinkedElement<T>* nextElement) {
+        currentElement->setNext(nextElement);
+    }
 
     void setLast(LinkedElement<T>* lastElement) {
         lastElement->setEnd();
@@ -148,7 +148,7 @@ public:
     }
 
 protected:
-	LinkedElement<T> *start = nullptr;
+    LinkedElement<T> *start = nullptr;
 };
 
 #endif /* SINGLYLINKEDLIST_H_ */

From 6127bb5ea40cd9ef61cfaab39d97213b0c6f1aea Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 28 Jan 2021 11:47:28 +0100
Subject: [PATCH 1539/1774] tab replacements

---
 controller/CMakeLists.txt     |   4 +-
 controller/ControllerBase.cpp | 152 +++++++++++++++++-----------------
 controller/ControllerBase.h   |  90 ++++++++++----------
 3 files changed, 123 insertions(+), 123 deletions(-)

diff --git a/controller/CMakeLists.txt b/controller/CMakeLists.txt
index 6f6607388..b7624d989 100644
--- a/controller/CMakeLists.txt
+++ b/controller/CMakeLists.txt
@@ -1,4 +1,4 @@
 target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		ControllerBase.cpp
+    PRIVATE 
+        ControllerBase.cpp
 )
\ No newline at end of file
diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 2a4024680..89f0ff681 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -5,128 +5,128 @@
 #include "../action/HasActionsIF.h"
 
 ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
-		size_t commandQueueDepth) :
-		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
-		submode(SUBMODE_NONE), modeHelper(this),
-		healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(
-	        commandQueueDepth);
+        size_t commandQueueDepth) :
+        SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
+        submode(SUBMODE_NONE), modeHelper(this),
+        healthHelper(this, setObjectId) {
+    commandQueue = QueueFactory::instance()->createMessageQueue(
+            commandQueueDepth);
 }
 
 ControllerBase::~ControllerBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+    QueueFactory::instance()->deleteMessageQueue(commandQueue);
 }
 
 ReturnValue_t ControllerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
+    ReturnValue_t result = SystemObject::initialize();
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	MessageQueueId_t parentQueue = 0;
-	if (parentId != objects::NO_OBJECT) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == nullptr) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
+    MessageQueueId_t parentQueue = 0;
+    if (parentId != objects::NO_OBJECT) {
+        SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+        if (parent == nullptr) {
+            return RETURN_FAILED;
+        }
+        parentQueue = parent->getCommandQueue();
 
-		parent->registerChild(getObjectId());
-	}
+        parent->registerChild(getObjectId());
+    }
 
-	result = healthHelper.initialize(parentQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
+    result = healthHelper.initialize(parentQueue);
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	result = modeHelper.initialize(parentQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
+    result = modeHelper.initialize(parentQueue);
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	return RETURN_OK;
+    return RETURN_OK;
 }
 
 MessageQueueId_t ControllerBase::getCommandQueue() const {
-	return commandQueue->getId();
+    return commandQueue->getId();
 }
 
 void ControllerBase::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	for (result = commandQueue->receiveMessage(&command);
-	        result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
+    CommandMessage command;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    for (result = commandQueue->receiveMessage(&command);
+            result == RETURN_OK;
+            result = commandQueue->receiveMessage(&command)) {
 
-		result = modeHelper.handleModeCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
+        result = modeHelper.handleModeCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
 
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-		result = handleCommandMessage(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
+        result = healthHelper.handleHealthCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+        result = handleCommandMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+        command.setToUnknownCommand();
+        commandQueue->reply(&command);
+    }
 
 }
 
 void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
-	changeHK(this->mode, this->submode, false);
-	triggerEvent(CHANGING_MODE, mode, submode);
-	this->mode = mode;
-	this->submode = submode;
-	modeHelper.modeChanged(mode, submode);
-	modeChanged(mode, submode);
-	announceMode(false);
-	changeHK(this->mode, this->submode, true);
+    changeHK(this->mode, this->submode, false);
+    triggerEvent(CHANGING_MODE, mode, submode);
+    this->mode = mode;
+    this->submode = submode;
+    modeHelper.modeChanged(mode, submode);
+    modeChanged(mode, submode);
+    announceMode(false);
+    changeHK(this->mode, this->submode, true);
 }
 
 void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
+    *mode = this->mode;
+    *submode = this->submode;
 }
 
 void ControllerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
+    healthHelper.setHealth(EXTERNAL_CONTROL);
 }
 
 void ControllerBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
+    triggerEvent(MODE_INFO, mode, submode);
 }
 
 ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
-	handleQueue();
-	performControlOperation();
-	return RETURN_OK;
+    handleQueue();
+    performControlOperation();
+    return RETURN_OK;
 }
 
 void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
-	return;
+    return;
 }
 
 ReturnValue_t ControllerBase::setHealth(HealthState health) {
-	switch (health) {
-	case HEALTHY:
-	case EXTERNAL_CONTROL:
-		healthHelper.setHealth(health);
-		return RETURN_OK;
-	default:
-		return INVALID_HEALTH_STATE;
-	}
+    switch (health) {
+    case HEALTHY:
+    case EXTERNAL_CONTROL:
+        healthHelper.setHealth(health);
+        return RETURN_OK;
+    default:
+        return INVALID_HEALTH_STATE;
+    }
 }
 
 HasHealthIF::HealthState ControllerBase::getHealth() {
-	return healthHelper.getHealth();
+    return healthHelper.getHealth();
 }
 void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
-			executingTask = task_;
+            executingTask = task_;
 }
 
 void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 6e83fe80b..f583342fe 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -17,39 +17,39 @@
  * a mode and a health state. This avoids boilerplate code.
  */
 class ControllerBase: public HasModesIF,
-		public HasHealthIF,
-		public ExecutableObjectIF,
-		public SystemObject,
-		public HasReturnvaluesIF {
+        public HasHealthIF,
+        public ExecutableObjectIF,
+        public SystemObject,
+        public HasReturnvaluesIF {
 public:
-	static const Mode_t MODE_NORMAL = 2;
+    static const Mode_t MODE_NORMAL = 2;
 
-	ControllerBase(object_id_t setObjectId, object_id_t parentId,
-			size_t commandQueueDepth = 3);
-	virtual ~ControllerBase();
+    ControllerBase(object_id_t setObjectId, object_id_t parentId,
+            size_t commandQueueDepth = 3);
+    virtual ~ControllerBase();
 
-	/** SystemObject override */
-	virtual ReturnValue_t initialize() override;
+    /** SystemObject override */
+    virtual ReturnValue_t initialize() override;
 
-	virtual MessageQueueId_t getCommandQueue() const override;
+    virtual MessageQueueId_t getCommandQueue() const override;
 
-	/** HasHealthIF overrides */
-	virtual ReturnValue_t setHealth(HealthState health) override;
-	virtual HasHealthIF::HealthState getHealth() override;
+    /** HasHealthIF overrides */
+    virtual ReturnValue_t setHealth(HealthState health) override;
+    virtual HasHealthIF::HealthState getHealth() override;
 
-	/** ExecutableObjectIF overrides */
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-	virtual void setTaskIF(PeriodicTaskIF* task) override;
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
+    /** ExecutableObjectIF overrides */
+    virtual ReturnValue_t performOperation(uint8_t opCode) override;
+    virtual void setTaskIF(PeriodicTaskIF* task) override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
 
 protected:
 
-	/**
-	 * Implemented by child class. Handle command messages which are not
-	 * mode or health messages.
-	 * @param message
-	 * @return
-	 */
+    /**
+     * Implemented by child class. Handle command messages which are not
+     * mode or health messages.
+     * @param message
+     * @return
+     */
     virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
 
     /**
@@ -60,35 +60,35 @@ protected:
     virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
             uint32_t *msToReachTheMode) = 0;
 
-	const object_id_t parentId;
+    const object_id_t parentId;
 
-	Mode_t mode;
+    Mode_t mode;
 
-	Submode_t submode;
+    Submode_t submode;
 
-	MessageQueueIF* commandQueue = nullptr;
+    MessageQueueIF* commandQueue = nullptr;
 
-	ModeHelper modeHelper;
+    ModeHelper modeHelper;
 
-	HealthHelper healthHelper;
+    HealthHelper healthHelper;
 
-	/**
-	 * Pointer to the task which executes this component,
-	 * is invalid before setTaskIF was called.
-	 */
-	PeriodicTaskIF* executingTask = nullptr;
+    /**
+     * Pointer to the task which executes this component,
+     * is invalid before setTaskIF was called.
+     */
+    PeriodicTaskIF* executingTask = nullptr;
 
-	/** Handle mode and health messages */
-	virtual void handleQueue();
+    /** Handle mode and health messages */
+    virtual void handleQueue();
 
-	/** Mode helpers */
-	virtual void modeChanged(Mode_t mode, Submode_t submode);
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-	virtual void setToExternalControl();
-	virtual void announceMode(bool recursive);
-	/** HK helpers */
-	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
+    /** Mode helpers */
+    virtual void modeChanged(Mode_t mode, Submode_t submode);
+    virtual void startTransition(Mode_t mode, Submode_t submode);
+    virtual void getMode(Mode_t *mode, Submode_t *submode);
+    virtual void setToExternalControl();
+    virtual void announceMode(bool recursive);
+    /** HK helpers */
+    virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 };
 
 #endif /* FSFW_CONTROLLER_CONTROLLERBASE_H_ */

From ac6e34fc65693210bdebf836eb7467a9a972c64b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 28 Jan 2021 11:50:33 +0100
Subject: [PATCH 1540/1774] replaced tabs by spaces with sed script

---
 action/ActionHelper.cpp            |  166 ++--
 action/ActionHelper.h              |  176 ++---
 action/ActionMessage.cpp           |   86 +-
 action/ActionMessage.h             |   44 +-
 action/CommandActionHelper.cpp     |  188 ++---
 action/CommandActionHelper.h       |   36 +-
 action/CommandsActionsIF.h         |   28 +-
 action/HasActionsIF.h              |   44 +-
 action/SimpleActionHelper.cpp      |  102 +--
 action/SimpleActionHelper.h        |   30 +-
 container/ArrayList.h              |  398 +++++-----
 container/BinaryTree.h             |  234 +++---
 container/DynamicFIFO.h            |   64 +-
 container/FIFO.h                   |   48 +-
 container/FIFOBase.h               |  112 +--
 container/FIFOBase.tpp             |   82 +-
 container/FixedArrayList.h         |   38 +-
 container/FixedMap.h               |  354 ++++-----
 container/FixedOrderedMultimap.h   |  282 +++----
 container/FixedOrderedMultimap.tpp |  136 ++--
 container/HybridIterator.h         |  124 +--
 container/IndexedRingMemoryArray.h | 1178 ++++++++++++++--------------
 container/PlacementFactory.h       |   84 +-
 container/RingBufferBase.h         |  166 ++--
 container/SharedRingBuffer.cpp     |   40 +-
 container/SharedRingBuffer.h       |  122 +--
 container/SimpleRingBuffer.cpp     |  152 ++--
 container/SimpleRingBuffer.h       |  178 ++---
 container/SinglyLinkedList.h       |  176 ++---
 controller/CMakeLists.txt          |    4 +-
 controller/ControllerBase.cpp      |  152 ++--
 controller/ControllerBase.h        |   90 +--
 32 files changed, 2557 insertions(+), 2557 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 285579160..23c9d7329 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -6,120 +6,120 @@
 
 ActionHelper::ActionHelper(HasActionsIF* setOwner,
         MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue) {
+        owner(setOwner), queueToUse(useThisQueue) {
 }
 
 ActionHelper::~ActionHelper() {
 }
 
 ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
-	if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
-		ActionId_t currentAction = ActionMessage::getActionId(command);
-		prepareExecution(command->getSender(), currentAction,
-				ActionMessage::getStoreId(command));
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return CommandMessage::UNKNOWN_COMMAND;
-	}
+    if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
+        ActionId_t currentAction = ActionMessage::getActionId(command);
+        prepareExecution(command->getSender(), currentAction,
+                ActionMessage::getStoreId(command));
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return CommandMessage::UNKNOWN_COMMAND;
+    }
 }
 
 ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(queueToUse_ != nullptr) {
-		setQueueToUse(queueToUse_);
-	}
+    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if (ipcStore == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    if(queueToUse_ != nullptr) {
+        setQueueToUse(queueToUse_);
+    }
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo,
         ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
-	queueToUse->sendMessage(reportTo, &reply);
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
+    queueToUse->sendMessage(reportTo, &reply);
 }
 
 void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId,
         ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setCompletionReply(&reply, commandId, result);
-	queueToUse->sendMessage(reportTo, &reply);
+    CommandMessage reply;
+    ActionMessage::setCompletionReply(&reply, commandId, result);
+    queueToUse->sendMessage(reportTo, &reply);
 }
 
 void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
-	queueToUse = queue;
+    queueToUse = queue;
 }
 
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
         ActionId_t actionId, store_address_t dataAddress) {
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	if(result == HasActionsIF::EXECUTION_FINISHED) {
-		CommandMessage reply;
-		ActionMessage::setCompletionReply(&reply, actionId, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-	}
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
+    const uint8_t* dataPtr = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        CommandMessage reply;
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
+    result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+    ipcStore->deleteData(dataAddress);
+    if(result == HasActionsIF::EXECUTION_FINISHED) {
+        CommandMessage reply;
+        ActionMessage::setCompletionReply(&reply, actionId, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+    }
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        CommandMessage reply;
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
 }
 
 ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
-		ActionId_t replyId, SerializeIF* data, bool hideSender) {
-	CommandMessage reply;
-	store_address_t storeAddress;
-	uint8_t *dataPtr;
-	size_t maxSize = data->getSerializedSize();
-	if (maxSize == 0) {
-		//No error, there's simply nothing to report.
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
-			&dataPtr);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = data->serialize(&dataPtr, &size, maxSize,
-	        SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeAddress);
-		return result;
-	}
-	// We don't need to report the objectId, as we receive REQUESTED data
-	// before the completion success message.
-	// True aperiodic replies need to be reported with
-	// another dedicated message.
-	ActionMessage::setDataReply(&reply, replyId, storeAddress);
+        ActionId_t replyId, SerializeIF* data, bool hideSender) {
+    CommandMessage reply;
+    store_address_t storeAddress;
+    uint8_t *dataPtr;
+    size_t maxSize = data->getSerializedSize();
+    if (maxSize == 0) {
+        //No error, there's simply nothing to report.
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
+            &dataPtr);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = data->serialize(&dataPtr, &size, maxSize,
+            SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeAddress);
+        return result;
+    }
+    // We don't need to report the objectId, as we receive REQUESTED data
+    // before the completion success message.
+    // True aperiodic replies need to be reported with
+    // another dedicated message.
+    ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
     // If the sender needs to be hidden, for example to handle packet
     // as unrequested reply, this will be done here.
-	if (hideSender) {
-		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
-	}
-	else {
-		result = queueToUse->sendMessage(reportTo, &reply);
-	}
+    if (hideSender) {
+        result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+    }
+    else {
+        result = queueToUse->sendMessage(reportTo, &reply);
+    }
 
-	if (result != HasReturnvaluesIF::RETURN_OK){
-		ipcStore->deleteData(storeAddress);
-	}
-	return result;
+    if (result != HasReturnvaluesIF::RETURN_OK){
+        ipcStore->deleteData(storeAddress);
+    }
+    return result;
 }
 
 void ActionHelper::resetHelper() {
@@ -155,7 +155,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
         result = queueToUse->sendMessage(reportTo, &reply);
     }
 
-    if (result != HasReturnvaluesIF::RETURN_OK){
+    if (result != HasReturnvaluesIF::RETURN_OK) {
         ipcStore->deleteData(storeAddress);
     }
     return result;
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index a91722f39..ae971d382 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -18,68 +18,68 @@ class HasActionsIF;
 
 class ActionHelper {
 public:
-	/**
-	 * Constructor of the action helper
-	 * @param setOwner Pointer to the owner of the interface
-	 * @param useThisQueue  messageQueue to be used, can be set during
-	 *                      initialize function as well.
-	 */
-	ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+    /**
+     * Constructor of the action helper
+     * @param setOwner Pointer to the owner of the interface
+     * @param useThisQueue  messageQueue to be used, can be set during
+     *                      initialize function as well.
+     */
+    ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
 
-	virtual ~ActionHelper();
-	/**
-	 * Function to be called from the owner with a new command message
-	 *
-	 * If the message is a valid action message the helper will use the
-	 * executeAction function from HasActionsIF.
-	 * If the message is invalid or the callback fails a message reply will be
-	 * send to the sender of the message automatically.
-	 *
-	 * @param command Pointer to a command message received by the owner
-	 * @return HasReturnvaluesIF::RETURN_OK if the message is a action message,
-	 *         CommandMessage::UNKNOW_COMMAND if this message ID is unkown
-	 */
-	ReturnValue_t handleActionMessage(CommandMessage* command);
-	/**
-	 * Helper initialize function. Must be called before use of any other
-	 * helper function
-	 * @param queueToUse_   Pointer to the messageQueue to be used, optional
-	 *                      if queue was set in constructor
-	 * @return Returns RETURN_OK if successful
-	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
-	/**
-	 * Function to be called from the owner to send a step message.
-	 * Success or failure will be determined by the result value.
-	 *
-	 * @param step Number of steps already done
-	 * @param reportTo The messageQueueId to report the step message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void step(uint8_t step, MessageQueueId_t reportTo,
-			ActionId_t commandId,
-			ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner to send a action completion message
-	 *
-	 * @param reportTo MessageQueueId_t to report the action completion message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void finish(MessageQueueId_t reportTo, ActionId_t commandId,
-	        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner if an action does report data.
-	 * Takes a SerializeIF* pointer and serializes it into the IPC store.
-	 * @param reportTo  MessageQueueId_t to report the action completion
-	 *                  message to
-	 * @param replyId ID of the executed command
-	 * @param data Pointer to the data
-	 * @return Returns RETURN_OK if successful, otherwise failure code
-	 */
-	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
-	        SerializeIF* data, bool hideSender = false);
+    virtual ~ActionHelper();
+    /**
+     * Function to be called from the owner with a new command message
+     *
+     * If the message is a valid action message the helper will use the
+     * executeAction function from HasActionsIF.
+     * If the message is invalid or the callback fails a message reply will be
+     * send to the sender of the message automatically.
+     *
+     * @param command Pointer to a command message received by the owner
+     * @return HasReturnvaluesIF::RETURN_OK if the message is a action message,
+     *         CommandMessage::UNKNOW_COMMAND if this message ID is unkown
+     */
+    ReturnValue_t handleActionMessage(CommandMessage* command);
+    /**
+     * Helper initialize function. Must be called before use of any other
+     * helper function
+     * @param queueToUse_   Pointer to the messageQueue to be used, optional
+     *                      if queue was set in constructor
+     * @return Returns RETURN_OK if successful
+     */
+    ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
+    /**
+     * Function to be called from the owner to send a step message.
+     * Success or failure will be determined by the result value.
+     *
+     * @param step Number of steps already done
+     * @param reportTo The messageQueueId to report the step message to
+     * @param commandId ID of the executed command
+     * @param result Result of the execution
+     */
+    void step(uint8_t step, MessageQueueId_t reportTo,
+            ActionId_t commandId,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    /**
+     * Function to be called by the owner to send a action completion message
+     *
+     * @param reportTo MessageQueueId_t to report the action completion message to
+     * @param commandId ID of the executed command
+     * @param result Result of the execution
+     */
+    void finish(MessageQueueId_t reportTo, ActionId_t commandId,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    /**
+     * Function to be called by the owner if an action does report data.
+     * Takes a SerializeIF* pointer and serializes it into the IPC store.
+     * @param reportTo  MessageQueueId_t to report the action completion
+     *                  message to
+     * @param replyId ID of the executed command
+     * @param data Pointer to the data
+     * @return Returns RETURN_OK if successful, otherwise failure code
+     */
+    ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
+            SerializeIF* data, bool hideSender = false);
     /**
      * Function to be called by the owner if an action does report data.
      * Takes the raw data and writes it into the IPC store.
@@ -91,35 +91,35 @@ public:
      */
     ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
             const uint8_t* data, size_t dataSize, bool hideSender = false);
-	/**
-	 * Function to setup the MessageQueueIF* of the helper. Can be used to
-	 * set the MessageQueueIF* if message queue is unavailable at construction
-	 * and initialize but must be setup before first call of other functions.
-	 * @param queue Queue to be used by the helper
-	 */
-	void setQueueToUse(MessageQueueIF *queue);
+    /**
+     * Function to setup the MessageQueueIF* of the helper. Can be used to
+     * set the MessageQueueIF* if message queue is unavailable at construction
+     * and initialize but must be setup before first call of other functions.
+     * @param queue Queue to be used by the helper
+     */
+    void setQueueToUse(MessageQueueIF *queue);
 protected:
-	//!< Increase of value of this per step
-	static const uint8_t STEP_OFFSET = 1;
-	HasActionsIF* owner;//!< Pointer to the owner
-	//! Queue to be used as response sender, has to be set in ctor or with
-	//! setQueueToUse
-	MessageQueueIF* queueToUse;
-	//! Pointer to an IPC Store, initialized during construction or
-	StorageManagerIF* ipcStore = nullptr;
+    //! Increase of value of this per step
+    static const uint8_t STEP_OFFSET = 1;
+    HasActionsIF* owner;//!< Pointer to the owner
+    //! Queue to be used as response sender, has to be set in ctor or with
+    //! setQueueToUse
+    MessageQueueIF* queueToUse;
+    //! Pointer to an IPC Store, initialized during construction or
+    StorageManagerIF* ipcStore = nullptr;
 
-	/**
-	 * Internal function called by handleActionMessage
-	 * @param commandedBy MessageQueueID of Commander
-	 * @param actionId ID of action to be done
-	 * @param dataAddress Address of additional data in IPC Store
-	 */
-	virtual void prepareExecution(MessageQueueId_t commandedBy,
-	        ActionId_t actionId, store_address_t dataAddress);
-	/**
-	 * @brief Default implementation is empty.
-	 */
-	virtual void resetHelper();
+    /**
+     * Internal function called by handleActionMessage
+     * @param commandedBy MessageQueueID of Commander
+     * @param actionId ID of action to be done
+     * @param dataAddress Address of additional data in IPC Store
+     */
+    virtual void prepareExecution(MessageQueueId_t commandedBy,
+            ActionId_t actionId, store_address_t dataAddress);
+    /**
+     * @brief Default implementation is empty.
+     */
+    virtual void resetHelper();
 };
 
 #endif /* FSFW_ACTION_ACTIONHELPER_H_ */
diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index 1c00dee0f..c3eb47109 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -11,71 +11,71 @@ ActionMessage::~ActionMessage() {
 }
 
 void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
-		store_address_t parameters) {
-	message->setCommand(EXECUTE_ACTION);
-	message->setParameter(fid);
-	message->setParameter2(parameters.raw);
+        store_address_t parameters) {
+    message->setCommand(EXECUTE_ACTION);
+    message->setParameter(fid);
+    message->setParameter2(parameters.raw);
 }
 
 ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
-	return ActionId_t(message->getParameter());
+    return ActionId_t(message->getParameter());
 }
 
 store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
+    store_address_t temp;
+    temp.raw = message->getParameter2();
+    return temp;
 }
 
 void ActionMessage::setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
-		ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		message->setCommand(STEP_SUCCESS);
-	} else {
-		message->setCommand(STEP_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2((step << 16) + result);
+        ReturnValue_t result) {
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        message->setCommand(STEP_SUCCESS);
+    } else {
+        message->setCommand(STEP_FAILED);
+    }
+    message->setParameter(fid);
+    message->setParameter2((step << 16) + result);
 }
 
 uint8_t ActionMessage::getStep(const CommandMessage* message) {
-	return uint8_t((message->getParameter2() >> 16) & 0xFF);
+    return uint8_t((message->getParameter2() >> 16) & 0xFF);
 }
 
 ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
-	return message->getParameter2() & 0xFFFF;
+    return message->getParameter2() & 0xFFFF;
 }
 
 void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
-		store_address_t data) {
-	message->setCommand(DATA_REPLY);
-	message->setParameter(actionId);
-	message->setParameter2(data.raw);
+        store_address_t data) {
+    message->setCommand(DATA_REPLY);
+    message->setParameter(actionId);
+    message->setParameter2(data.raw);
 }
 
 void ActionMessage::setCompletionReply(CommandMessage* message,
-		ActionId_t fid, ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK or result == HasActionsIF::EXECUTION_FINISHED) {
-		message->setCommand(COMPLETION_SUCCESS);
-	} else {
-		message->setCommand(COMPLETION_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2(result);
+        ActionId_t fid, ReturnValue_t result) {
+    if (result == HasReturnvaluesIF::RETURN_OK or result == HasActionsIF::EXECUTION_FINISHED) {
+        message->setCommand(COMPLETION_SUCCESS);
+    } else {
+        message->setCommand(COMPLETION_FAILED);
+    }
+    message->setParameter(fid);
+    message->setParameter2(result);
 }
 
 void ActionMessage::clear(CommandMessage* message) {
-	switch(message->getCommand()) {
-	case EXECUTE_ACTION:
-	case DATA_REPLY: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
+    switch(message->getCommand()) {
+    case EXECUTE_ACTION:
+    case DATA_REPLY: {
+        StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+                objects::IPC_STORE);
+        if (ipcStore != NULL) {
+            ipcStore->deleteData(getStoreId(message));
+        }
+        break;
+    }
+    default:
+        break;
+    }
 }
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index deb110952..246ac601d 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -15,29 +15,29 @@ using ActionId_t = uint32_t;
  */
 class ActionMessage {
 private:
-	ActionMessage();
+    ActionMessage();
 public:
-	static const uint8_t MESSAGE_ID = messagetypes::ACTION;
-	static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
-	static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
-	static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
-	static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
-	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
-	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
-	virtual ~ActionMessage();
-	static void setCommand(CommandMessage* message, ActionId_t fid,
-			store_address_t parameters);
-	static ActionId_t getActionId(const CommandMessage* message );
-	static store_address_t getStoreId(const CommandMessage* message );
-	static void setStepReply(CommandMessage* message, ActionId_t fid,
-			uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static uint8_t getStep(const CommandMessage* message );
-	static ReturnValue_t getReturnCode(const CommandMessage* message );
-	static void setDataReply(CommandMessage* message, ActionId_t actionId,
-			store_address_t data);
-	static void setCompletionReply(CommandMessage* message, ActionId_t fid,
-			ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static void clear(CommandMessage* message);
+    static const uint8_t MESSAGE_ID = messagetypes::ACTION;
+    static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
+    static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
+    static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
+    static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
+    static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
+    static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
+    virtual ~ActionMessage();
+    static void setCommand(CommandMessage* message, ActionId_t fid,
+            store_address_t parameters);
+    static ActionId_t getActionId(const CommandMessage* message );
+    static store_address_t getStoreId(const CommandMessage* message );
+    static void setStepReply(CommandMessage* message, ActionId_t fid,
+            uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    static uint8_t getStep(const CommandMessage* message );
+    static ReturnValue_t getReturnCode(const CommandMessage* message );
+    static void setDataReply(CommandMessage* message, ActionId_t actionId,
+            store_address_t data);
+    static void setCompletionReply(CommandMessage* message, ActionId_t fid,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    static void clear(CommandMessage* message);
 };
 
 #endif /* FSFW_ACTION_ACTIONMESSAGE_H_ */
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index 4e88f3c34..148b36575 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -5,123 +5,123 @@
 #include "../objectmanager/ObjectManagerIF.h"
 
 CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
-		owner(setOwner), queueToUse(NULL), ipcStore(
-		NULL), commandCount(0), lastTarget(0) {
+        owner(setOwner), queueToUse(NULL), ipcStore(
+        NULL), commandCount(0), lastTarget(0) {
 }
 
 CommandActionHelper::~CommandActionHelper() {
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, SerializeIF *data) {
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	uint8_t *storePointer;
-	size_t maxSize = data->getSerializedSize();
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
-			&storePointer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	size_t size = 0;
-	result = data->serialize(&storePointer, &size, maxSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+        ActionId_t actionId, SerializeIF *data) {
+    HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+    if (receiver == NULL) {
+        return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+    }
+    store_address_t storeId;
+    uint8_t *storePointer;
+    size_t maxSize = data->getSerializedSize();
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
+            &storePointer);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    size_t size = 0;
+    result = data->serialize(&storePointer, &size, maxSize,
+            SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return sendCommand(receiver->getCommandQueue(), actionId, storeId);
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, const uint8_t *data, uint32_t size) {
-//	if (commandCount != 0) {
-//		return CommandsFunctionsIF::ALREADY_COMMANDING;
-//	}
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	ReturnValue_t result = ipcStore->addData(&storeId, data, size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+        ActionId_t actionId, const uint8_t *data, uint32_t size) {
+//    if (commandCount != 0) {
+//        return CommandsFunctionsIF::ALREADY_COMMANDING;
+//    }
+    HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+    if (receiver == NULL) {
+        return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+    }
+    store_address_t storeId;
+    ReturnValue_t result = ipcStore->addData(&storeId, data, size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return sendCommand(receiver->getCommandQueue(), actionId, storeId);
 }
 
 ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
-		ActionId_t actionId, store_address_t storeId) {
-	CommandMessage command;
-	ActionMessage::setCommand(&command, actionId, storeId);
-	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeId);
-	}
-	lastTarget = queueId;
-	commandCount++;
-	return result;
+        ActionId_t actionId, store_address_t storeId) {
+    CommandMessage command;
+    ActionMessage::setCommand(&command, actionId, storeId);
+    ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeId);
+    }
+    lastTarget = queueId;
+    commandCount++;
+    return result;
 }
 
 ReturnValue_t CommandActionHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if (ipcStore == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	queueToUse = owner->getCommandQueuePtr();
-	if (queueToUse == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    queueToUse = owner->getCommandQueuePtr();
+    if (queueToUse == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
-	if (reply->getSender() != lastTarget) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	switch (reply->getCommand()) {
-	case ActionMessage::COMPLETION_SUCCESS:
-		commandCount--;
-		owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::COMPLETION_FAILED:
-		commandCount--;
-		owner->completionFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_SUCCESS:
-		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_FAILED:
-		commandCount--;
-		owner->stepFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::DATA_REPLY:
-		extractDataForOwner(ActionMessage::getActionId(reply),
-				ActionMessage::getStoreId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    if (reply->getSender() != lastTarget) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    switch (reply->getCommand()) {
+    case ActionMessage::COMPLETION_SUCCESS:
+        commandCount--;
+        owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::COMPLETION_FAILED:
+        commandCount--;
+        owner->completionFailedReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getReturnCode(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::STEP_SUCCESS:
+        owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getStep(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::STEP_FAILED:
+        commandCount--;
+        owner->stepFailedReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getStep(reply),
+                ActionMessage::getReturnCode(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::DATA_REPLY:
+        extractDataForOwner(ActionMessage::getActionId(reply),
+                ActionMessage::getStoreId(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 uint8_t CommandActionHelper::getCommandCount() const {
-	return commandCount;
+    return commandCount;
 }
 
 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-	const uint8_t * data = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	owner->dataReceived(actionId, data, size);
-	ipcStore->deleteData(storeId);
+    const uint8_t * data = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return;
+    }
+    owner->dataReceived(actionId, data, size);
+    ipcStore->deleteData(storeId);
 }
diff --git a/action/CommandActionHelper.h b/action/CommandActionHelper.h
index cfed8c941..96ef1763a 100644
--- a/action/CommandActionHelper.h
+++ b/action/CommandActionHelper.h
@@ -11,26 +11,26 @@
 class CommandsActionsIF;
 
 class CommandActionHelper {
-	friend class CommandsActionsIF;
+    friend class CommandsActionsIF;
 public:
-	CommandActionHelper(CommandsActionsIF* owner);
-	virtual ~CommandActionHelper();
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, const uint8_t* data, uint32_t size);
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, SerializeIF* data);
-	ReturnValue_t initialize();
-	ReturnValue_t handleReply(CommandMessage* reply);
-	uint8_t getCommandCount() const;
+    CommandActionHelper(CommandsActionsIF* owner);
+    virtual ~CommandActionHelper();
+    ReturnValue_t commandAction(object_id_t commandTo,
+            ActionId_t actionId, const uint8_t* data, uint32_t size);
+    ReturnValue_t commandAction(object_id_t commandTo,
+            ActionId_t actionId, SerializeIF* data);
+    ReturnValue_t initialize();
+    ReturnValue_t handleReply(CommandMessage* reply);
+    uint8_t getCommandCount() const;
 private:
-	CommandsActionsIF* owner;
-	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore;
-	uint8_t commandCount;
-	MessageQueueId_t lastTarget;
-	void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
-	ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
-			store_address_t storeId);
+    CommandsActionsIF* owner;
+    MessageQueueIF* queueToUse;
+    StorageManagerIF* ipcStore;
+    uint8_t commandCount;
+    MessageQueueId_t lastTarget;
+    void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
+    ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
+            store_address_t storeId);
 };
 
 #endif /* COMMANDACTIONHELPER_H_ */
diff --git a/action/CommandsActionsIF.h b/action/CommandsActionsIF.h
index 491bfc703..fe7e856c2 100644
--- a/action/CommandsActionsIF.h
+++ b/action/CommandsActionsIF.h
@@ -15,22 +15,22 @@
  * - replyReceived(id, step, cause) (if cause == OK, it's a success).
  */
 class CommandsActionsIF {
-	friend class CommandActionHelper;
+    friend class CommandActionHelper;
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
-	static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
-	virtual ~CommandsActionsIF() {}
-	virtual MessageQueueIF* getCommandQueuePtr() = 0;
+    static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
+    static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
+    static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
+    virtual ~CommandsActionsIF() {}
+    virtual MessageQueueIF* getCommandQueuePtr() = 0;
 protected:
-	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
-	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
-			ReturnValue_t returnCode) = 0;
-	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
-			uint32_t size) = 0;
-	virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
-	virtual void completionFailedReceived(ActionId_t actionId,
-			ReturnValue_t returnCode) = 0;
+    virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
+    virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
+            ReturnValue_t returnCode) = 0;
+    virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
+            uint32_t size) = 0;
+    virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
+    virtual void completionFailedReceived(ActionId_t actionId,
+            ReturnValue_t returnCode) = 0;
 };
 
 
diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 690f03698..056e674c3 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -35,28 +35,28 @@
  */
 class HasActionsIF {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
-	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
-	virtual ~HasActionsIF() { }
-	/**
-	 * Function to get the MessageQueueId_t of the implementing object
-	 * @return MessageQueueId_t of the object
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	/**
-	 * Execute or initialize the execution of a certain function.
-	 * The ActionHelpers will execute this function and behave differently
-	 * depending on the returnvalue.
-	 *
-	 * @return
-	 * -@c EXECUTION_FINISHED Finish reply will be generated
-	 * -@c Not RETURN_OK Step failure reply will be generated
-	 */
-	virtual ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
+    static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
+    static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
+    static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
+    static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
+    static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
+    virtual ~HasActionsIF() { }
+    /**
+     * Function to get the MessageQueueId_t of the implementing object
+     * @return MessageQueueId_t of the object
+     */
+    virtual MessageQueueId_t getCommandQueue() const = 0;
+    /**
+     * Execute or initialize the execution of a certain function.
+     * The ActionHelpers will execute this function and behave differently
+     * depending on the returnvalue.
+     *
+     * @return
+     * -@c EXECUTION_FINISHED Finish reply will be generated
+     * -@c Not RETURN_OK Step failure reply will be generated
+     */
+    virtual ReturnValue_t executeAction(ActionId_t actionId,
+            MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
 };
 
 
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index af57736c8..f77d01473 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -2,74 +2,74 @@
 #include "SimpleActionHelper.h"
 
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
-		MessageQueueIF* useThisQueue) :
-		ActionHelper(setOwner, useThisQueue), isExecuting(false) {
+        MessageQueueIF* useThisQueue) :
+        ActionHelper(setOwner, useThisQueue), isExecuting(false) {
 }
 
 SimpleActionHelper::~SimpleActionHelper() {
 }
 
 void SimpleActionHelper::step(ReturnValue_t result) {
-	// STEP_OFFESET is subtracted to compensate for adding offset in base
-	// method, which is not necessary here.
-	ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
-			result);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		resetHelper();
-	}
+    // STEP_OFFESET is subtracted to compensate for adding offset in base
+    // method, which is not necessary here.
+    ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
+            result);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        resetHelper();
+    }
 }
 
 void SimpleActionHelper::finish(ReturnValue_t result) {
-	ActionHelper::finish(lastCommander, lastAction, result);
-	resetHelper();
+    ActionHelper::finish(lastCommander, lastAction, result);
+    resetHelper();
 }
 
 ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
-	return ActionHelper::reportData(lastCommander, lastAction, data);
+    return ActionHelper::reportData(lastCommander, lastAction, data);
 }
 
 void SimpleActionHelper::resetHelper() {
-	stepCount = 0;
-	isExecuting = false;
-	lastAction = 0;
-	lastCommander = 0;
+    stepCount = 0;
+    isExecuting = false;
+    lastAction = 0;
+    lastCommander = 0;
 }
 
 void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
-		ActionId_t actionId, store_address_t dataAddress) {
-	CommandMessage reply;
-	if (isExecuting) {
-		ipcStore->deleteData(dataAddress);
-		ActionMessage::setStepReply(&reply, actionId, 0,
-				HasActionsIF::IS_BUSY);
-		queueToUse->sendMessage(commandedBy, &reply);
-	}
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	lastCommander = commandedBy;
-	lastAction = actionId;
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	switch (result) {
-	case HasReturnvaluesIF::RETURN_OK:
-		isExecuting = true;
-		stepCount++;
-		break;
-	case HasActionsIF::EXECUTION_FINISHED:
-		ActionMessage::setCompletionReply(&reply, actionId,
-				HasReturnvaluesIF::RETURN_OK);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	default:
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	}
+        ActionId_t actionId, store_address_t dataAddress) {
+    CommandMessage reply;
+    if (isExecuting) {
+        ipcStore->deleteData(dataAddress);
+        ActionMessage::setStepReply(&reply, actionId, 0,
+                HasActionsIF::IS_BUSY);
+        queueToUse->sendMessage(commandedBy, &reply);
+    }
+    const uint8_t* dataPtr = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
+    lastCommander = commandedBy;
+    lastAction = actionId;
+    result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+    ipcStore->deleteData(dataAddress);
+    switch (result) {
+    case HasReturnvaluesIF::RETURN_OK:
+        isExecuting = true;
+        stepCount++;
+        break;
+    case HasActionsIF::EXECUTION_FINISHED:
+        ActionMessage::setCompletionReply(&reply, actionId,
+                HasReturnvaluesIF::RETURN_OK);
+        queueToUse->sendMessage(commandedBy, &reply);
+        break;
+    default:
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        break;
+    }
 
 }
diff --git a/action/SimpleActionHelper.h b/action/SimpleActionHelper.h
index 1f35d9fdf..7c6c4e00e 100644
--- a/action/SimpleActionHelper.h
+++ b/action/SimpleActionHelper.h
@@ -4,27 +4,27 @@
 #include "ActionHelper.h"
 
 /**
- * @brief	This is an action helper which is only able to service one action
- * 			at a time but remembers last commander and last action which
- * 			simplifies usage
+ * @brief    This is an action helper which is only able to service one action
+ *             at a time but remembers last commander and last action which
+ *             simplifies usage
  */
 class SimpleActionHelper: public ActionHelper {
 public:
-	SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-	virtual ~SimpleActionHelper();
-	void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	ReturnValue_t reportData(SerializeIF* data);
+    SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+    virtual ~SimpleActionHelper();
+    void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    ReturnValue_t reportData(SerializeIF* data);
 
 protected:
-	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-			store_address_t dataAddress);
-	virtual void resetHelper();
+    void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
+            store_address_t dataAddress);
+    virtual void resetHelper();
 private:
-	bool isExecuting;
-	MessageQueueId_t lastCommander = MessageQueueIF::NO_QUEUE;
-	ActionId_t lastAction = 0;
-	uint8_t stepCount = 0;
+    bool isExecuting;
+    MessageQueueId_t lastCommander = MessageQueueIF::NO_QUEUE;
+    ActionId_t lastAction = 0;
+    uint8_t stepCount = 0;
 };
 
 #endif /* SIMPLEACTIONHELPER_H_ */
diff --git a/container/ArrayList.h b/container/ArrayList.h
index 6bd5c1d5a..25e281a27 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -6,7 +6,7 @@
 #include "../serialize/SerializeIF.h"
 
 /**
- * @brief 	A List that stores its values in an array.
+ * @brief     A List that stores its values in an array.
  * @details
  * The underlying storage is an array that can be allocated by the class
  * itself or supplied via ctor.
@@ -15,237 +15,237 @@
  */
 template<typename T, typename count_t = uint8_t>
 class ArrayList {
-	template<typename U, typename count> friend class SerialArrayListAdapter;
+    template<typename U, typename count> friend class SerialArrayListAdapter;
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
+    static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
+    static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
 
-	/**
-	 * This is the allocating constructor.
-	 * It allocates an array of the specified size.
-	 * @param maxSize
-	 */
-	ArrayList(count_t maxSize) :
-		size(0), maxSize_(maxSize), allocated(true) {
-		entries = new T[maxSize];
-	}
+    /**
+     * This is the allocating constructor.
+     * It allocates an array of the specified size.
+     * @param maxSize
+     */
+    ArrayList(count_t maxSize) :
+        size(0), maxSize_(maxSize), allocated(true) {
+        entries = new T[maxSize];
+    }
 
-	/**
-	 * This is the non-allocating constructor
-	 *
-	 * It expects a pointer to an array of a certain size and initializes
-	 * itself to it.
-	 *
-	 * @param storage the array to use as backend
-	 * @param maxSize size of storage
-	 * @param size size of data already present in storage
-	 */
-	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
-		size(size), entries(storage), maxSize_(maxSize), allocated(false) {
-	}
+    /**
+     * This is the non-allocating constructor
+     *
+     * It expects a pointer to an array of a certain size and initializes
+     * itself to it.
+     *
+     * @param storage the array to use as backend
+     * @param maxSize size of storage
+     * @param size size of data already present in storage
+     */
+    ArrayList(T *storage, count_t maxSize, count_t size = 0) :
+        size(size), entries(storage), maxSize_(maxSize), allocated(false) {
+    }
 
-	/**
-	 * Copying is forbiden by declaring copy ctor and copy assignment deleted
-	 * It is too ambigous in this case.
-	 * (Allocate a new backend? Use the same? What to do in an modifying call?)
-	 */
-	ArrayList(const ArrayList& other) = delete;
-	const ArrayList& operator=(const ArrayList& other) = delete;
+    /**
+     * Copying is forbiden by declaring copy ctor and copy assignment deleted
+     * It is too ambigous in this case.
+     * (Allocate a new backend? Use the same? What to do in an modifying call?)
+     */
+    ArrayList(const ArrayList& other) = delete;
+    const ArrayList& operator=(const ArrayList& other) = delete;
 
-	/**
-	 * Number of Elements stored in this List
-	 */
-	count_t size;
+    /**
+     * Number of Elements stored in this List
+     */
+    count_t size;
 
 
-	/**
-	 * Destructor, if the allocating constructor was used, it deletes the array.
-	 */
-	virtual ~ArrayList() {
-		if (allocated) {
-			delete[] entries;
-		}
-	}
+    /**
+     * Destructor, if the allocating constructor was used, it deletes the array.
+     */
+    virtual ~ArrayList() {
+        if (allocated) {
+            delete[] entries;
+        }
+    }
 
-	/**
-	 * An Iterator to go trough an ArrayList
-	 *
-	 * It stores a pointer to an element and increments the
-	 * pointer when incremented itself.
-	 */
-	class Iterator {
-	public:
-		/**
-		 * Empty ctor, points to NULL
-		 */
-		Iterator(): value(0) {}
+    /**
+     * An Iterator to go trough an ArrayList
+     *
+     * It stores a pointer to an element and increments the
+     * pointer when incremented itself.
+     */
+    class Iterator {
+    public:
+        /**
+         * Empty ctor, points to NULL
+         */
+        Iterator(): value(0) {}
 
-		/**
-		 * Initializes the Iterator to point to an element
-		 *
-		 * @param initialize
-		 */
-		Iterator(T *initialize) {
-			value = initialize;
-		}
+        /**
+         * Initializes the Iterator to point to an element
+         *
+         * @param initialize
+         */
+        Iterator(T *initialize) {
+            value = initialize;
+        }
 
-		/**
-		 * The current element the iterator points to
-		 */
-		T *value;
+        /**
+         * The current element the iterator points to
+         */
+        T *value;
 
-		Iterator& operator++() {
-			value++;
-			return *this;
-		}
+        Iterator& operator++() {
+            value++;
+            return *this;
+        }
 
-		Iterator operator++(int) {
-			Iterator tmp(*this);
-			operator++();
-			return tmp;
-		}
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
 
-		Iterator& operator--() {
-			value--;
-			return *this;
-		}
+        Iterator& operator--() {
+            value--;
+            return *this;
+        }
 
-		Iterator operator--(int) {
-			Iterator tmp(*this);
-			operator--();
-			return tmp;
-		}
+        Iterator operator--(int) {
+            Iterator tmp(*this);
+            operator--();
+            return tmp;
+        }
 
-		T& operator*() {
-			return *value;
-		}
+        T& operator*() {
+            return *value;
+        }
 
-		const T& operator*() const {
-			return *value;
-		}
+        const T& operator*() const {
+            return *value;
+        }
 
-		T *operator->() {
-			return value;
-		}
+        T *operator->() {
+            return value;
+        }
 
-		const T *operator->() const {
-			return value;
-		}
-	};
+        const T *operator->() const {
+            return value;
+        }
+    };
 
-	friend bool operator==(const ArrayList::Iterator& lhs,
-			const ArrayList::Iterator& rhs) {
-		return (lhs.value == rhs.value);
-	}
+    friend bool operator==(const ArrayList::Iterator& lhs,
+            const ArrayList::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
 
-	friend bool operator!=(const ArrayList::Iterator& lhs,
-			const ArrayList::Iterator& rhs) {
-		return not (lhs.value == rhs.value);
-	}
+    friend bool operator!=(const ArrayList::Iterator& lhs,
+            const ArrayList::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
 
-	/**
-	 * Iterator pointing to the first stored elmement
-	 *
-	 * @return Iterator to the first element
-	 */
-	Iterator begin() const {
-		return Iterator(&entries[0]);
-	}
+    /**
+     * Iterator pointing to the first stored elmement
+     *
+     * @return Iterator to the first element
+     */
+    Iterator begin() const {
+        return Iterator(&entries[0]);
+    }
 
-	/**
-	 * returns an Iterator pointing to the element after the last stored entry
-	 *
-	 * @return Iterator to the element after the last entry
-	 */
-	Iterator end() const {
-		return Iterator(&entries[size]);
-	}
+    /**
+     * returns an Iterator pointing to the element after the last stored entry
+     *
+     * @return Iterator to the element after the last entry
+     */
+    Iterator end() const {
+        return Iterator(&entries[size]);
+    }
 
-	T & operator[](count_t i) const {
-		return entries[i];
-	}
+    T & operator[](count_t i) const {
+        return entries[i];
+    }
 
-	/**
-	 * The first element
-	 *
-	 * @return pointer to the first stored element
-	 */
-	T *front() {
-		return entries;
-	}
+    /**
+     * The first element
+     *
+     * @return pointer to the first stored element
+     */
+    T *front() {
+        return entries;
+    }
 
-	/**
-	 * The last element
-	 *
-	 * does not return a valid pointer if called on an empty list.
-	 *
-	 * @return pointer to the last stored element
-	 */
-	T *back() {
-		return &entries[size - 1];
-		//Alternative solution
-		//return const_cast<T*>(static_cast<const T*>(*this).back());
-	}
+    /**
+     * The last element
+     *
+     * does not return a valid pointer if called on an empty list.
+     *
+     * @return pointer to the last stored element
+     */
+    T *back() {
+        return &entries[size - 1];
+        //Alternative solution
+        //return const_cast<T*>(static_cast<const T*>(*this).back());
+    }
 
-	const T* back() const{
-		return &entries[size-1];
-	}
+    const T* back() const{
+        return &entries[size-1];
+    }
 
-	/**
-	 * The maximum number of elements this List can contain
-	 *
-	 * @return maximum number of elements
-	 */
-	size_t maxSize() const {
-		return this->maxSize_;
-	}
+    /**
+     * The maximum number of elements this List can contain
+     *
+     * @return maximum number of elements
+     */
+    size_t maxSize() const {
+        return this->maxSize_;
+    }
 
-	/**
-	 * Insert a new element into the list.
-	 *
-	 * The new element is inserted after the last stored element.
-	 *
-	 * @param entry
-	 * @return
-	 *          -@c FULL if the List is full
-	 *          -@c RETURN_OK else
-	 */
-	ReturnValue_t insert(T entry) {
-		if (size >= maxSize_) {
-			return FULL;
-		}
-		entries[size] = entry;
-		++size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    /**
+     * Insert a new element into the list.
+     *
+     * The new element is inserted after the last stored element.
+     *
+     * @param entry
+     * @return
+     *          -@c FULL if the List is full
+     *          -@c RETURN_OK else
+     */
+    ReturnValue_t insert(T entry) {
+        if (size >= maxSize_) {
+            return FULL;
+        }
+        entries[size] = entry;
+        ++size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	/**
-	 * clear the List
-	 *
-	 * This does not actually clear all entries, it only sets the size to 0.
-	 */
-	void clear() {
-		size = 0;
-	}
+    /**
+     * clear the List
+     *
+     * This does not actually clear all entries, it only sets the size to 0.
+     */
+    void clear() {
+        size = 0;
+    }
 
-	count_t remaining() {
-		return (maxSize_ - size);
-	}
+    count_t remaining() {
+        return (maxSize_ - size);
+    }
 
 protected:
-	/**
-	 * pointer to the array in which the entries are stored
-	 */
-	T *entries;
-	/**
-	 * remembering the maximum size
-	 */
-	size_t maxSize_;
+    /**
+     * pointer to the array in which the entries are stored
+     */
+    T *entries;
+    /**
+     * remembering the maximum size
+     */
+    size_t maxSize_;
 
-	/**
-	 * true if the array was allocated and needs to be deleted in the destructor.
-	 */
-	bool allocated;
+    /**
+     * true if the array was allocated and needs to be deleted in the destructor.
+     */
+    bool allocated;
 };
 
 
diff --git a/container/BinaryTree.h b/container/BinaryTree.h
index 73073dea3..6200cbb1f 100644
--- a/container/BinaryTree.h
+++ b/container/BinaryTree.h
@@ -7,65 +7,65 @@
 template<typename Tp>
 class BinaryNode {
 public:
-	BinaryNode(Tp* setValue) :
-			value(setValue), left(NULL), right(NULL), parent(NULL) {
-	}
-	Tp *value;
-	BinaryNode* left;
-	BinaryNode* right;
-	BinaryNode* parent;
+    BinaryNode(Tp* setValue) :
+            value(setValue), left(NULL), right(NULL), parent(NULL) {
+    }
+    Tp *value;
+    BinaryNode* left;
+    BinaryNode* right;
+    BinaryNode* parent;
 };
 
 template<typename Tp>
 class ExplicitNodeIterator {
 public:
-	typedef ExplicitNodeIterator<Tp> _Self;
-	typedef BinaryNode<Tp> _Node;
-	typedef Tp value_type;
-	typedef Tp* pointer;
-	typedef Tp& reference;
-	ExplicitNodeIterator() :
-			element(NULL) {
-	}
-	ExplicitNodeIterator(_Node* node) :
-			element(node) {
-	}
-	BinaryNode<Tp>* element;
-	_Self up() {
-		return _Self(element->parent);
-	}
-	_Self left() {
-		if (element != NULL) {
-			return _Self(element->left);
-		} else {
-			return _Self(NULL);
-		}
+    typedef ExplicitNodeIterator<Tp> _Self;
+    typedef BinaryNode<Tp> _Node;
+    typedef Tp value_type;
+    typedef Tp* pointer;
+    typedef Tp& reference;
+    ExplicitNodeIterator() :
+            element(NULL) {
+    }
+    ExplicitNodeIterator(_Node* node) :
+            element(node) {
+    }
+    BinaryNode<Tp>* element;
+    _Self up() {
+        return _Self(element->parent);
+    }
+    _Self left() {
+        if (element != NULL) {
+            return _Self(element->left);
+        } else {
+            return _Self(NULL);
+        }
 
-	}
-	_Self right() {
-		if (element != NULL) {
-			return _Self(element->right);
-		} else {
-			return _Self(NULL);
-		}
+    }
+    _Self right() {
+        if (element != NULL) {
+            return _Self(element->right);
+        } else {
+            return _Self(NULL);
+        }
 
-	}
-	bool operator==(const _Self& __x) const {
-		return element == __x.element;
-	}
-	bool operator!=(const _Self& __x) const {
-		return element != __x.element;
-	}
+    }
+    bool operator==(const _Self& __x) const {
+        return element == __x.element;
+    }
+    bool operator!=(const _Self& __x) const {
+        return element != __x.element;
+    }
     pointer
     operator->() const {
-    	if (element != NULL) {
-    		return element->value;
-    	} else {
-    		return NULL;
-    	}
+        if (element != NULL) {
+            return element->value;
+        } else {
+            return NULL;
+        }
     }
     pointer operator*() const {
-    	return this->operator->();
+        return this->operator->();
     }
 };
 
@@ -75,77 +75,77 @@ public:
 template<typename Tp>
 class BinaryTree {
 public:
-	typedef ExplicitNodeIterator<Tp> iterator;
-	typedef BinaryNode<Tp> Node;
-	typedef std::pair<iterator, iterator> children;
-	BinaryTree() :
-			rootNode(NULL) {
-	}
-	BinaryTree(Node* rootNode) :
-			rootNode(rootNode) {
-	}
-	iterator begin() const {
-		return iterator(rootNode);
-	}
-	static iterator end() {
-		return iterator(NULL);
-	}
-	iterator insert(bool insertLeft, iterator parentNode, Node* newNode ) {
-		newNode->parent = parentNode.element;
-		if (parentNode.element != NULL) {
-			if (insertLeft) {
-				parentNode.element->left = newNode;
-			} else {
-				parentNode.element->right = newNode;
-			}
-		} else {
-			//Insert first element.
-			rootNode = newNode;
-		}
-		return iterator(newNode);
-	}
-	//No recursion to children. Needs to be done externally.
-	children erase(iterator node) {
-		if (node.element == rootNode) {
-			//We're root node
-			rootNode = NULL;
-		} else {
-			//Delete parent's reference
-			if (node.up().left() == node) {
-				node.up().element->left = NULL;
-			} else {
-				node.up().element->right = NULL;
-			}
-		}
-		return children(node.element->left, node.element->right);
-	}
-	static uint32_t countLeft(iterator start) {
-		if (start == end()) {
-			return 0;
-		}
-		//We also count the start node itself.
-		uint32_t count = 1;
-		while (start.left() != end()) {
-			count++;
-			start = start.left();
-		}
-		return count;
-	}
-	static uint32_t countRight(iterator start) {
-		if (start == end()) {
-			return 0;
-		}
-		//We also count the start node itself.
-		uint32_t count = 1;
-		while (start.right() != end()) {
-			count++;
-			start = start.right();
-		}
-		return count;
-	}
+    typedef ExplicitNodeIterator<Tp> iterator;
+    typedef BinaryNode<Tp> Node;
+    typedef std::pair<iterator, iterator> children;
+    BinaryTree() :
+            rootNode(NULL) {
+    }
+    BinaryTree(Node* rootNode) :
+            rootNode(rootNode) {
+    }
+    iterator begin() const {
+        return iterator(rootNode);
+    }
+    static iterator end() {
+        return iterator(NULL);
+    }
+    iterator insert(bool insertLeft, iterator parentNode, Node* newNode ) {
+        newNode->parent = parentNode.element;
+        if (parentNode.element != NULL) {
+            if (insertLeft) {
+                parentNode.element->left = newNode;
+            } else {
+                parentNode.element->right = newNode;
+            }
+        } else {
+            //Insert first element.
+            rootNode = newNode;
+        }
+        return iterator(newNode);
+    }
+    //No recursion to children. Needs to be done externally.
+    children erase(iterator node) {
+        if (node.element == rootNode) {
+            //We're root node
+            rootNode = NULL;
+        } else {
+            //Delete parent's reference
+            if (node.up().left() == node) {
+                node.up().element->left = NULL;
+            } else {
+                node.up().element->right = NULL;
+            }
+        }
+        return children(node.element->left, node.element->right);
+    }
+    static uint32_t countLeft(iterator start) {
+        if (start == end()) {
+            return 0;
+        }
+        //We also count the start node itself.
+        uint32_t count = 1;
+        while (start.left() != end()) {
+            count++;
+            start = start.left();
+        }
+        return count;
+    }
+    static uint32_t countRight(iterator start) {
+        if (start == end()) {
+            return 0;
+        }
+        //We also count the start node itself.
+        uint32_t count = 1;
+        while (start.right() != end()) {
+            count++;
+            start = start.right();
+        }
+        return count;
+    }
 
 protected:
-	Node* rootNode;
+    Node* rootNode;
 };
 
 
diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 86d43f7d7..e1bc3ef2f 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -5,8 +5,8 @@
 #include <vector>
 
 /**
- * @brief 	Simple First-In-First-Out data structure. The maximum size
- * 			can be set in the constructor.
+ * @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!
@@ -17,39 +17,39 @@
 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());
-	};
+    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 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;
-	}
+    /**
+     * @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;
+    std::vector<T> fifoVector;
 };
 
 #endif /* FSFW_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index 701138520..79ead3139 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -5,8 +5,8 @@
 #include <array>
 
 /**
- * @brief 	Simple First-In-First-Out data structure with size fixed at
- * 			compile time
+ * @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.
@@ -16,32 +16,32 @@
 template<typename T, size_t capacity>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(): FIFOBase<T>(nullptr, capacity) {
-		this->setContainer(fifoArray.data());
-	};
+    FIFO(): FIFOBase<T>(nullptr, capacity) {
+        this->setContainer(fifoArray.data());
+    };
 
-	/**
-	 * @brief 	Custom copy constructor to set pointer correctly.
-	 * @param other
-	 */
-	FIFO(const FIFO& other): FIFOBase<T>(other) {
-		this->fifoArray = other.fifoArray;
-		this->setContainer(fifoArray.data());
-	}
+    /**
+     * @brief     Custom copy constructor to set pointer correctly.
+     * @param other
+     */
+    FIFO(const FIFO& other): FIFOBase<T>(other) {
+        this->fifoArray = other.fifoArray;
+        this->setContainer(fifoArray.data());
+    }
 
-	/**
-	 * @brief Custom assignment operator
-	 * @param other
-	 */
-	FIFO& operator=(const FIFO& other){
-		FIFOBase<T>::operator=(other);
-		this->fifoArray = other.fifoArray;
-		this->setContainer(fifoArray.data());
-		return *this;
-	}
+    /**
+     * @brief Custom assignment operator
+     * @param other
+     */
+    FIFO& operator=(const FIFO& other){
+        FIFOBase<T>::operator=(other);
+        this->fifoArray = other.fifoArray;
+        this->setContainer(fifoArray.data());
+        return *this;
+    }
 
 private:
-	std::array<T, capacity> fifoArray;
+    std::array<T, capacity> fifoArray;
 };
 
 #endif /* FSFW_CONTAINER_FIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index edd66d37a..eaa80346e 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -8,70 +8,70 @@
 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);
+    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);
+    /** Default ctor, takes pointer to first entry of underlying container
+     *  and maximum capacity */
+    FIFOBase(T* values, const size_t maxCapacity);
 
-	/**
-	 * Insert value into FIFO
-	 * @param value
-	 * @return RETURN_OK on success, FULL if full
-	 */
-	ReturnValue_t insert(T value);
-	/**
-	 * Retrieve item from FIFO. This removes the item from the FIFO.
-	 * @param value Must point to a valid T
-	 * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
-	 */
-	ReturnValue_t retrieve(T *value);
-	/**
-	 * Retrieve item from FIFO without removing it from FIFO.
-	 * @param value Must point to a valid T
-	 * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
-	 */
-	ReturnValue_t peek(T * value);
-	/**
-	 * Remove item from FIFO.
-	 * @return RETURN_OK on success, EMPTY if empty
-	 */
-	ReturnValue_t pop();
+    /**
+     * Insert value into FIFO
+     * @param value
+     * @return RETURN_OK on success, FULL if full
+     */
+    ReturnValue_t insert(T value);
+    /**
+     * Retrieve item from FIFO. This removes the item from the FIFO.
+     * @param value Must point to a valid T
+     * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
+     */
+    ReturnValue_t retrieve(T *value);
+    /**
+     * Retrieve item from FIFO without removing it from FIFO.
+     * @param value Must point to a valid T
+     * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
+     */
+    ReturnValue_t peek(T * value);
+    /**
+     * Remove item from FIFO.
+     * @return RETURN_OK on success, EMPTY if empty
+     */
+    ReturnValue_t pop();
 
-	/***
-	 * Check if FIFO is empty
-	 * @return True if empty, False if not
-	 */
-	bool empty();
-	/***
-	 * Check if FIFO is Full
-	 * @return True if full, False if not
-	 */
-	bool full();
-	/***
-	 *  Current used size (elements) used
-	 * @return size_t in elements
-	 */
-	size_t size();
-	/***
-	 * Get maximal capacity of fifo
-	 * @return size_t with max capacity of this fifo
-	 */
-	size_t getMaxCapacity() const;
+    /***
+     * Check if FIFO is empty
+     * @return True if empty, False if not
+     */
+    bool empty();
+    /***
+     * Check if FIFO is Full
+     * @return True if full, False if not
+     */
+    bool full();
+    /***
+     *  Current used size (elements) used
+     * @return size_t in elements
+     */
+    size_t size();
+    /***
+     * Get maximal capacity of fifo
+     * @return size_t with max capacity of this fifo
+     */
+    size_t getMaxCapacity() const;
 
 protected:
-	void setContainer(T* data);
-	size_t maxCapacity = 0;
+    void setContainer(T* data);
+    size_t maxCapacity = 0;
 
-	T* values;
+    T* values;
 
-	size_t readIndex = 0;
-	size_t writeIndex = 0;
-	size_t currentSize = 0;
+    size_t readIndex = 0;
+    size_t writeIndex = 0;
+    size_t currentSize = 0;
 
-	size_t next(size_t current);
+    size_t next(size_t current);
 };
 
 #include "FIFOBase.tpp"
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index 763004b6f..2e6a3829c 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -7,87 +7,87 @@
 
 template<typename T>
 inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
-		maxCapacity(maxCapacity), values(values){};
+        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;
-	}
+    if (full()) {
+        return FULL;
+    } else {
+        values[writeIndex] = value;
+        writeIndex = next(writeIndex);
+        ++currentSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 };
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
-	if (empty()) {
-		return EMPTY;
-	} else {
-		if (value == nullptr){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		*value = values[readIndex];
-		readIndex = next(readIndex);
-		--currentSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    if (empty()) {
+        return EMPTY;
+    } else {
+        if (value == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        *value = values[readIndex];
+        readIndex = next(readIndex);
+        --currentSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 };
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::peek(T* value) {
-	if(empty()) {
-		return EMPTY;
-	} else {
-		if (value == nullptr){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		*value = values[readIndex];
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    if(empty()) {
+        return EMPTY;
+    } else {
+        if (value == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        *value = values[readIndex];
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 };
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::pop() {
-	T value;
-	return this->retrieve(&value);
+    T value;
+    return this->retrieve(&value);
 };
 
 template<typename T>
 inline bool FIFOBase<T>::empty() {
-	return (currentSize == 0);
+    return (currentSize == 0);
 };
 
 template<typename T>
 inline bool FIFOBase<T>::full() {
-	return (currentSize == maxCapacity);
+    return (currentSize == maxCapacity);
 }
 
 template<typename T>
 inline size_t FIFOBase<T>::size() {
-	return currentSize;
+    return currentSize;
 }
 
 template<typename T>
 inline size_t FIFOBase<T>::next(size_t current) {
-	++current;
-	if (current == maxCapacity) {
-		current = 0;
-	}
-	return current;
+    ++current;
+    if (current == maxCapacity) {
+        current = 0;
+    }
+    return current;
 }
 
 template<typename T>
 inline size_t FIFOBase<T>::getMaxCapacity() const {
-	return maxCapacity;
+    return maxCapacity;
 }
 
 
 template<typename T>
 inline void FIFOBase<T>::setContainer(T *data) {
-	this->values = data;
+    this->values = data;
 }
 
 #endif
diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index e9e127cf0..89b76388a 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -8,30 +8,30 @@
  */
 template<typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList: public ArrayList<T, count_t> {
-	static_assert(MAX_SIZE <= (pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
+    static_assert(MAX_SIZE <= (pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
 private:
-	T data[MAX_SIZE];
+    T data[MAX_SIZE];
 public:
-	FixedArrayList() :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-	}
+    FixedArrayList() :
+            ArrayList<T, count_t>(data, MAX_SIZE) {
+    }
 
-	FixedArrayList(const FixedArrayList& other) :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		this->size = other.size;
-	}
+    FixedArrayList(const FixedArrayList& other) :
+            ArrayList<T, count_t>(data, MAX_SIZE) {
+        memcpy(this->data, other.data, sizeof(this->data));
+        this->entries = data;
+        this->size = other.size;
+    }
 
-	FixedArrayList& operator=(FixedArrayList other) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		this->size = other.size;
-		return *this;
-	}
+    FixedArrayList& operator=(FixedArrayList other) {
+        memcpy(this->data, other.data, sizeof(this->data));
+        this->entries = data;
+        this->size = other.size;
+        return *this;
+    }
 
-	virtual ~FixedArrayList() {
-	}
+    virtual ~FixedArrayList() {
+    }
 
 };
 
diff --git a/container/FixedMap.h b/container/FixedMap.h
index 7a5220faa..bd8e0f835 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -18,212 +18,212 @@
  */
 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");
+    static_assert (std::is_trivially_copyable<T>::value or
+            std::is_base_of<SerializeIF, T>::value,
+            "Types used in FixedMap must either be trivial copy-able or a "
+            "derived class from SerializeIF to be serialize-able");
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
+    static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+    static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
+    static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
 
 private:
-	static const key_t EMPTY_SLOT = -1;
-	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
+    static const key_t EMPTY_SLOT = -1;
+    ArrayList<std::pair<key_t, T>, uint32_t> theMap;
+    uint32_t _size;
 
-	uint32_t findIndex(key_t key) const {
-		if (_size == 0) {
-			return 1;
-		}
-		uint32_t i = 0;
-		for (i = 0; i < _size; ++i) {
-			if (theMap[i].first == key) {
-				return i;
-			}
-		}
-		return i;
-	}
+    uint32_t findIndex(key_t key) const {
+        if (_size == 0) {
+            return 1;
+        }
+        uint32_t i = 0;
+        for (i = 0; i < _size; ++i) {
+            if (theMap[i].first == key) {
+                return i;
+            }
+        }
+        return i;
+    }
 public:
-	FixedMap(uint32_t maxSize) :
-			theMap(maxSize), _size(0) {
-	}
+    FixedMap(uint32_t maxSize) :
+            theMap(maxSize), _size(0) {
+    }
 
-	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-	public:
-		Iterator() :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
-		}
+    class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
+    public:
+        Iterator() :
+                ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
+        }
 
-		Iterator(std::pair<key_t, T> *pair) :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
-		}
-	};
+        Iterator(std::pair<key_t, T> *pair) :
+                ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
+        }
+    };
 
-	friend bool operator==(const typename FixedMap::Iterator& lhs,
-			const typename FixedMap::Iterator& rhs) {
-		return (lhs.value == rhs.value);
-	}
+    friend bool operator==(const typename FixedMap::Iterator& lhs,
+            const typename FixedMap::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
 
-	friend bool operator!=(const typename FixedMap::Iterator& lhs,
-			const typename FixedMap::Iterator& rhs) {
-		return not (lhs.value == rhs.value);
-	}
+    friend bool operator!=(const typename FixedMap::Iterator& lhs,
+            const typename FixedMap::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
 
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
+    Iterator begin() const {
+        return Iterator(&theMap[0]);
+    }
 
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
+    Iterator end() const {
+        return Iterator(&theMap[_size]);
+    }
 
-	uint32_t size() const {
-		return _size;
-	}
+    uint32_t size() const {
+        return _size;
+    }
 
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
-		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
-			return KEY_ALREADY_EXISTS;
-		}
-		if (_size == theMap.maxSize()) {
-			return MAP_FULL;
-		}
-		theMap[_size].first = key;
-		theMap[_size].second = value;
-		if (storedValue != nullptr) {
-			*storedValue = Iterator(&theMap[_size]);
-		}
-		++_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
+        if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
+            return KEY_ALREADY_EXISTS;
+        }
+        if (_size == theMap.maxSize()) {
+            return MAP_FULL;
+        }
+        theMap[_size].first = key;
+        theMap[_size].second = value;
+        if (storedValue != nullptr) {
+            *storedValue = Iterator(&theMap[_size]);
+        }
+        ++_size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.first, pair.second);
-	}
+    ReturnValue_t insert(std::pair<key_t, T> pair) {
+        return insert(pair.first, pair.second);
+    }
 
-	ReturnValue_t exists(key_t key) const {
-		ReturnValue_t result = KEY_DOES_NOT_EXIST;
-		if (findIndex(key) < _size) {
-			result = HasReturnvaluesIF::RETURN_OK;
-		}
-		return result;
-	}
+    ReturnValue_t exists(key_t key) const {
+        ReturnValue_t result = KEY_DOES_NOT_EXIST;
+        if (findIndex(key) < _size) {
+            result = HasReturnvaluesIF::RETURN_OK;
+        }
+        return result;
+    }
 
-	ReturnValue_t erase(Iterator *iter) {
-		uint32_t i;
-		if ((i = findIndex((*iter).value->first)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		--((*iter).value);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t erase(Iterator *iter) {
+        uint32_t i;
+        if ((i = findIndex((*iter).value->first)) >= _size) {
+            return KEY_DOES_NOT_EXIST;
+        }
+        theMap[i] = theMap[_size - 1];
+        --_size;
+        --((*iter).value);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	ReturnValue_t erase(key_t key) {
-		uint32_t i;
-		if ((i = findIndex(key)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t erase(key_t key) {
+        uint32_t i;
+        if ((i = findIndex(key)) >= _size) {
+            return KEY_DOES_NOT_EXIST;
+        }
+        theMap[i] = theMap[_size - 1];
+        --_size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	T *findValue(key_t key) const {
-		return &theMap[findIndex(key)].second;
-	}
+    T *findValue(key_t key) const {
+        return &theMap[findIndex(key)].second;
+    }
 
-	Iterator find(key_t key) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findIndex(key)]);
-	}
+    Iterator find(key_t key) const {
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return end();
+        }
+        return Iterator(&theMap[findIndex(key)]);
+    }
 
-	ReturnValue_t find(key_t key, T **value) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		*value = &theMap[findIndex(key)].second;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t find(key_t key, T **value) const {
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        *value = &theMap[findIndex(key)].second;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	bool empty() {
-	    if(_size == 0) {
-	        return true;
-	    }
-	    else {
-	        return false;
-	    }
-	}
+    bool empty() {
+        if(_size == 0) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
 
-	bool full() {
-	    if(_size >= theMap.maxSize()) {
-	        return true;
-	    }
-	    else {
-	        return false;
-	    }
-	}
+    bool full() {
+        if(_size >= theMap.maxSize()) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
 
-	void clear() {
-		_size = 0;
-	}
+    void clear() {
+        _size = 0;
+    }
 
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
+    uint32_t maxSize() const {
+        return theMap.maxSize();
+    }
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
-				buffer, size, maxSize, streamEndianness);
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
-					size, maxSize, streamEndianness);
-			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		return result;
-	}
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const {
+        ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
+                buffer, size, maxSize, streamEndianness);
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+            result = SerializeAdapter::serialize(&theMap[i].first, buffer,
+                    size, maxSize, streamEndianness);
+            result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
+                    maxSize, streamEndianness);
+            ++i;
+        }
+        return result;
+    }
 
-	virtual size_t getSerializedSize() const {
-		uint32_t printSize = sizeof(_size);
-		uint32_t i = 0;
+    virtual size_t getSerializedSize() const {
+        uint32_t printSize = sizeof(_size);
+        uint32_t i = 0;
 
-		for (i = 0; i < _size; ++i) {
-			printSize += SerializeAdapter::getSerializedSize(
-					&theMap[i].first);
-			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
-		}
+        for (i = 0; i < _size; ++i) {
+            printSize += SerializeAdapter::getSerializedSize(
+                    &theMap[i].first);
+            printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
+        }
 
-		return printSize;
-	}
+        return printSize;
+    }
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
-				buffer, size, streamEndianness);
-		if (this->_size > theMap.maxSize()) {
-			return SerializeIF::TOO_MANY_ELEMENTS;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
-					size, streamEndianness);
-			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					streamEndianness);
-			++i;
-		}
-		return result;
-	}
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) {
+        ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
+                buffer, size, streamEndianness);
+        if (this->_size > theMap.maxSize()) {
+            return SerializeIF::TOO_MANY_ELEMENTS;
+        }
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+            result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
+                    size, streamEndianness);
+            result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
+                    streamEndianness);
+            ++i;
+        }
+        return result;
+    }
 
 };
 
diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index acf2368af..cb8abdcaf 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -34,172 +34,172 @@
 template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
 class FixedOrderedMultimap {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
+    static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
+    static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
 
-	/***
-	 * Constructor which needs a size_t for the maximum allowed size
-	 *
-	 * Can not be resized during runtime
-	 *
-	 * Allocates memory at construction
-	 * @param maxSize size_t of Maximum allowed size
-	 */
+    /***
+     * Constructor which needs a size_t for the maximum allowed size
+     *
+     * Can not be resized during runtime
+     *
+     * Allocates memory at construction
+     * @param maxSize size_t of Maximum allowed size
+     */
     FixedOrderedMultimap(size_t maxSize):theMap(maxSize), _size(0){
     }
 
-	/***
-	 * Virtual destructor frees Memory by deleting its member
-	 */
-	virtual ~FixedOrderedMultimap() {
-	}
+    /***
+     * Virtual destructor frees Memory by deleting its member
+     */
+    virtual ~FixedOrderedMultimap() {
+    }
 
-	/***
-	 * Special iterator for FixedOrderedMultimap
-	 */
-	class Iterator: public ArrayList<std::pair<key_t, T>, size_t>::Iterator {
-	public:
-		Iterator() :
-			ArrayList<std::pair<key_t, T>, size_t>::Iterator() {
-		}
+    /***
+     * Special iterator for FixedOrderedMultimap
+     */
+    class Iterator: public ArrayList<std::pair<key_t, T>, size_t>::Iterator {
+    public:
+        Iterator() :
+            ArrayList<std::pair<key_t, T>, size_t>::Iterator() {
+        }
 
-		Iterator(std::pair<key_t, T> *pair) :
-			ArrayList<std::pair<key_t, T>, size_t>::Iterator(pair) {
-		}
-	};
+        Iterator(std::pair<key_t, T> *pair) :
+            ArrayList<std::pair<key_t, T>, size_t>::Iterator(pair) {
+        }
+    };
 
-	/***
-	 * Returns an iterator pointing to the first element
-	 * @return Iterator pointing to first element
-	 */
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
+    /***
+     * Returns an iterator pointing to the first element
+     * @return Iterator pointing to first element
+     */
+    Iterator begin() const {
+        return Iterator(&theMap[0]);
+    }
 
-	/**
-	 * Returns an iterator pointing to one element past the end
-	 * @return Iterator pointing to one element past the end
-	 */
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
+    /**
+     * Returns an iterator pointing to one element past the end
+     * @return Iterator pointing to one element past the end
+     */
+    Iterator end() const {
+        return Iterator(&theMap[_size]);
+    }
 
-	/***
-	 * Returns the current size of the map (not maximum size!)
-	 * @return Current size
-	 */
-	size_t size() const{
-		return _size;
-	}
+    /***
+     * Returns the current size of the map (not maximum size!)
+     * @return Current size
+     */
+    size_t size() const{
+        return _size;
+    }
 
-	/**
-	 * Clears the map, does not deallocate any memory
-	 */
-	void clear(){
-		_size = 0;
-	}
+    /**
+     * Clears the map, does not deallocate any memory
+     */
+    void clear(){
+        _size = 0;
+    }
 
-	/**
-	 * Returns the maximum size of the map
-	 * @return Maximum size of the map
-	 */
-	size_t maxSize() const{
-		return theMap.maxSize();
-	}
+    /**
+     * Returns the maximum size of the map
+     * @return Maximum size of the map
+     */
+    size_t maxSize() const{
+        return theMap.maxSize();
+    }
 
-	/***
-	 * Used to insert a key and value separately.
-	 *
-	 * @param[in] key Key of the new element
-	 * @param[in] value Value of the new element
-	 * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a nullptr
-	 * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
-	 */
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
+    /***
+     * Used to insert a key and value separately.
+     *
+     * @param[in] key Key of the new element
+     * @param[in] value Value of the new element
+     * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a nullptr
+     * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+     */
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
 
-	/***
-	 * Used to insert new pair instead of single values
-	 *
-	 * @param pair Pair to be inserted
-	 * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
-	 */
-	ReturnValue_t insert(std::pair<key_t, T> pair);
+    /***
+     * Used to insert new pair instead of single values
+     *
+     * @param pair Pair to be inserted
+     * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+     */
+    ReturnValue_t insert(std::pair<key_t, T> pair);
 
-	/***
-	 * Can be used to check if a certain key is in the map
-	 * @param key Key to be checked
-	 * @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
-	 */
-	ReturnValue_t exists(key_t key) const;
+    /***
+     * Can be used to check if a certain key is in the map
+     * @param key Key to be checked
+     * @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
+     */
+    ReturnValue_t exists(key_t key) const;
 
-	/***
-	 * Used to delete the element in the iterator
-	 *
-	 * The iterator will point to the element before or begin(),
-	 *  but never to one element in front of the map.
-	 *
-	 * @warning The iterator needs to be valid and dereferenceable
-	 * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
-	 * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
-	 */
-	ReturnValue_t erase(Iterator *iter);
+    /***
+     * Used to delete the element in the iterator
+     *
+     * The iterator will point to the element before or begin(),
+     *  but never to one element in front of the map.
+     *
+     * @warning The iterator needs to be valid and dereferenceable
+     * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
+     * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+     */
+    ReturnValue_t erase(Iterator *iter);
 
-	/***
-	 * Used to erase by key
-	 * @param key Key to be erased
-	 * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
-	 */
-	ReturnValue_t erase(key_t key);
+    /***
+     * Used to erase by key
+     * @param key Key to be erased
+     * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+     */
+    ReturnValue_t erase(key_t key);
 
-	/***
-	 * Find returns the first appearance of the key
-	 *
-	 * If the key does not exist, it points to end()
-	 *
-	 * @param key Key to search for
-	 * @return Iterator pointing to the first entry of key
-	 */
-	Iterator find(key_t key) const{
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findFirstIndex(key)]);
-	};
+    /***
+     * Find returns the first appearance of the key
+     *
+     * If the key does not exist, it points to end()
+     *
+     * @param key Key to search for
+     * @return Iterator pointing to the first entry of key
+     */
+    Iterator find(key_t key) const{
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return end();
+        }
+        return Iterator(&theMap[findFirstIndex(key)]);
+    };
 
-	/***
-	 * Finds first entry of the given key and returns a
-	 * pointer to the value
-	 *
-	 * @param key Key to search for
-	 * @param value Found value
-	 * @return RETURN_OK if it points to the value,
-	 * KEY_DOES_NOT_EXIST if the key is not in the map
-	 */
-	ReturnValue_t find(key_t key, T **value) const;
+    /***
+     * Finds first entry of the given key and returns a
+     * pointer to the value
+     *
+     * @param key Key to search for
+     * @param value Found value
+     * @return RETURN_OK if it points to the value,
+     * KEY_DOES_NOT_EXIST if the key is not in the map
+     */
+    ReturnValue_t find(key_t key, T **value) const;
 
-	friend bool operator==(const typename FixedOrderedMultimap::Iterator& lhs,
-			const typename FixedOrderedMultimap::Iterator& rhs) {
-		return (lhs.value == rhs.value);
-	}
+    friend bool operator==(const typename FixedOrderedMultimap::Iterator& lhs,
+            const typename FixedOrderedMultimap::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
 
-	friend bool operator!=(const typename FixedOrderedMultimap::Iterator& lhs,
-			const typename FixedOrderedMultimap::Iterator& rhs) {
-		return not (lhs.value == rhs.value);
-	}
+    friend bool operator!=(const typename FixedOrderedMultimap::Iterator& lhs,
+            const typename FixedOrderedMultimap::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
 
 private:
-	typedef KEY_COMPARE compare;
-	compare myComp;
-	ArrayList<std::pair<key_t, T>, size_t> theMap;
-	size_t _size;
+    typedef KEY_COMPARE compare;
+    compare myComp;
+    ArrayList<std::pair<key_t, T>, size_t> theMap;
+    size_t _size;
 
-	size_t findFirstIndex(key_t key, size_t startAt = 0) const;
+    size_t findFirstIndex(key_t key, size_t startAt = 0) const;
 
-	size_t findNicePlace(key_t key) const;
+    size_t findNicePlace(key_t key) const;
 
-	void removeFromPosition(size_t position);
+    void removeFromPosition(size_t position);
 };
 
 #include "FixedOrderedMultimap.tpp"
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
index 4aa85e974..294a161fe 100644
--- a/container/FixedOrderedMultimap.tpp
+++ b/container/FixedOrderedMultimap.tpp
@@ -4,105 +4,105 @@
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
-	if (_size == theMap.maxSize()) {
-		return MAP_FULL;
-	}
-	size_t position = findNicePlace(key);
-	memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
-			(_size - position) * sizeof(std::pair<key_t,T>));
-	theMap[position].first = key;
-	theMap[position].second = value;
-	++_size;
-	if (storedValue != nullptr) {
-		*storedValue = Iterator(&theMap[position]);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    if (_size == theMap.maxSize()) {
+        return MAP_FULL;
+    }
+    size_t position = findNicePlace(key);
+    memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
+            (_size - position) * sizeof(std::pair<key_t,T>));
+    theMap[position].first = key;
+    theMap[position].second = value;
+    ++_size;
+    if (storedValue != nullptr) {
+        *storedValue = Iterator(&theMap[position]);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
-	return insert(pair.first, pair.second);
+    return insert(pair.first, pair.second);
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
-	ReturnValue_t result = KEY_DOES_NOT_EXIST;
-	if (findFirstIndex(key) < _size) {
-		result = HasReturnvaluesIF::RETURN_OK;
-	}
-	return result;
+    ReturnValue_t result = KEY_DOES_NOT_EXIST;
+    if (findFirstIndex(key) < _size) {
+        result = HasReturnvaluesIF::RETURN_OK;
+    }
+    return result;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
-	size_t i;
-	if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-		return KEY_DOES_NOT_EXIST;
-	}
-	removeFromPosition(i);
-	if (*iter != begin()) {
-		(*iter)--;
-	} else {
-		*iter = begin();
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    size_t i;
+    if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    removeFromPosition(i);
+    if (*iter != begin()) {
+        (*iter)--;
+    } else {
+        *iter = begin();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
-	size_t i;
-	if ((i = findFirstIndex(key)) >= _size) {
-		return KEY_DOES_NOT_EXIST;
-	}
-	do {
-		removeFromPosition(i);
-		i = findFirstIndex(key, i);
-	} while (i < _size);
-	return HasReturnvaluesIF::RETURN_OK;
+    size_t i;
+    if ((i = findFirstIndex(key)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    do {
+        removeFromPosition(i);
+        i = findFirstIndex(key, i);
+    } while (i < _size);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
-	ReturnValue_t result = exists(key);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	*value = &theMap[findFirstIndex(key)].second;
-	return HasReturnvaluesIF::RETURN_OK;
+    ReturnValue_t result = exists(key);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    *value = &theMap[findFirstIndex(key)].second;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
-	if (startAt >= _size) {
-		return startAt + 1;
-	}
-	size_t i = startAt;
-	for (i = startAt; i < _size; ++i) {
-		if (theMap[i].first == key) {
-			return i;
-		}
-	}
-	return i;
+    if (startAt >= _size) {
+        return startAt + 1;
+    }
+    size_t i = startAt;
+    for (i = startAt; i < _size; ++i) {
+        if (theMap[i].first == key) {
+            return i;
+        }
+    }
+    return i;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
-	size_t i = 0;
-	for (i = 0; i < _size; ++i) {
-		if (myComp(key, theMap[i].first)) {
-			return i;
-		}
-	}
-	return i;
+    size_t i = 0;
+    for (i = 0; i < _size; ++i) {
+        if (myComp(key, theMap[i].first)) {
+            return i;
+        }
+    }
+    return i;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
-	if (_size <= position) {
-		return;
-	}
-	memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
-			(_size - position - 1) * sizeof(std::pair<key_t,T>));
-	--_size;
+    if (_size <= position) {
+        return;
+    }
+    memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
+            (_size - position - 1) * sizeof(std::pair<key_t,T>));
+    --_size;
 }
 
 
diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index 8d020cb93..6e33e4611 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -6,85 +6,85 @@
 
 template<typename T, typename count_t = uint8_t>
 class HybridIterator: public LinkedElement<T>::Iterator,
-		public ArrayList<T, count_t>::Iterator {
+        public ArrayList<T, count_t>::Iterator {
 public:
-	HybridIterator() {}
+    HybridIterator() {}
 
-	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
-		LinkedElement<T>::Iterator(*iter), value(iter->value),
-		linked(true) {
+    HybridIterator(typename LinkedElement<T>::Iterator *iter) :
+        LinkedElement<T>::Iterator(*iter), value(iter->value),
+        linked(true) {
 
-	}
+    }
 
-	HybridIterator(LinkedElement<T> *start) :
-		LinkedElement<T>::Iterator(start), value(start->value),
-		linked(true) {
+    HybridIterator(LinkedElement<T> *start) :
+        LinkedElement<T>::Iterator(start), value(start->value),
+        linked(true) {
 
-	}
+    }
 
-	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
-			typename ArrayList<T, count_t>::Iterator end) :
-			ArrayList<T, count_t>::Iterator(start), value(start.value),
-			linked(false), end(end.value) {
-		if (value == this->end) {
-			value = NULL;
-		}
-	}
+    HybridIterator(typename ArrayList<T, count_t>::Iterator start,
+            typename ArrayList<T, count_t>::Iterator end) :
+            ArrayList<T, count_t>::Iterator(start), value(start.value),
+            linked(false), end(end.value) {
+        if (value == this->end) {
+            value = NULL;
+        }
+    }
 
-	HybridIterator(T *firstElement, T *lastElement) :
-			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
-			linked(false), end(++lastElement) {
-		if (value == end) {
-			value = NULL;
-		}
-	}
+    HybridIterator(T *firstElement, T *lastElement) :
+            ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
+            linked(false), end(++lastElement) {
+        if (value == end) {
+            value = NULL;
+        }
+    }
 
-	HybridIterator& operator++() {
-		if (linked) {
-			LinkedElement<T>::Iterator::operator++();
-			if (LinkedElement<T>::Iterator::value != nullptr) {
-				value = LinkedElement<T>::Iterator::value->value;
-			} else {
-				value = nullptr;
-			}
-		} else {
-			ArrayList<T, count_t>::Iterator::operator++();
-			value = ArrayList<T, count_t>::Iterator::value;
+    HybridIterator& operator++() {
+        if (linked) {
+            LinkedElement<T>::Iterator::operator++();
+            if (LinkedElement<T>::Iterator::value != nullptr) {
+                value = LinkedElement<T>::Iterator::value->value;
+            } else {
+                value = nullptr;
+            }
+        } else {
+            ArrayList<T, count_t>::Iterator::operator++();
+            value = ArrayList<T, count_t>::Iterator::value;
 
-			if (value == end) {
-				value = nullptr;
-			}
-		}
-		return *this;
-	}
+            if (value == end) {
+                value = nullptr;
+            }
+        }
+        return *this;
+    }
 
-	HybridIterator operator++(int) {
-		HybridIterator tmp(*this);
-		operator++();
-		return tmp;
-	}
+    HybridIterator operator++(int) {
+        HybridIterator tmp(*this);
+        operator++();
+        return tmp;
+    }
 
-	bool operator==(const HybridIterator& other) const {
-		return value == other.value;
-	}
+    bool operator==(const HybridIterator& other) const {
+        return value == other.value;
+    }
 
-	bool operator!=(const HybridIterator& other) const {
-		return !(*this == other);
-	}
+    bool operator!=(const HybridIterator& other) const {
+        return !(*this == other);
+    }
 
-	T operator*() {
-		return *value;
-	}
+    T operator*() {
+        return *value;
+    }
 
-	T *operator->() {
-		return value;
-	}
+    T *operator->() {
+        return value;
+    }
 
-	T* value = nullptr;
+    T* value = nullptr;
 
 private:
-	bool linked = false;
-	T *end = nullptr;
+    bool linked = false;
+    T *end = nullptr;
 };
 
 #endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 0d85b49bc..df8980f7e 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -10,687 +10,687 @@
 
 template<typename T>
 class Index: public SerializeIF{
-	/**
-	 * Index is the Type used for the list of indices. The template parameter is the type which describes the index, it needs to be a child of SerializeIF to be able to make it persistent
-	 */
-	static_assert(std::is_base_of<SerializeIF,T>::value,"Wrong Type for Index, Type must implement SerializeIF");
+    /**
+     * Index is the Type used for the list of indices. The template parameter is the type which describes the index, it needs to be a child of SerializeIF to be able to make it persistent
+     */
+    static_assert(std::is_base_of<SerializeIF,T>::value,"Wrong Type for Index, Type must implement SerializeIF");
 public:
-	Index():blockStartAddress(0),size(0),storedPackets(0){}
+    Index():blockStartAddress(0),size(0),storedPackets(0){}
 
-	Index(uint32_t startAddress):blockStartAddress(startAddress),size(0),storedPackets(0){
+    Index(uint32_t startAddress):blockStartAddress(startAddress),size(0),storedPackets(0){
 
-	}
+    }
 
-	void setBlockStartAddress(uint32_t newAddress){
-		this->blockStartAddress = newAddress;
-	}
+    void setBlockStartAddress(uint32_t newAddress){
+        this->blockStartAddress = newAddress;
+    }
 
-	uint32_t getBlockStartAddress() const {
-		return blockStartAddress;
-	}
+    uint32_t getBlockStartAddress() const {
+        return blockStartAddress;
+    }
 
-	const T* getIndexType() const {
-		return &indexType;
-	}
+    const T* getIndexType() const {
+        return &indexType;
+    }
 
-	T* modifyIndexType(){
-		return &indexType;
-	}
-	/**
-	 * Updates the index Type. Uses = operator
-	 * @param indexType Type to copy from
-	 */
-	void setIndexType(T* indexType) {
-		this->indexType = *indexType;
-	}
+    T* modifyIndexType(){
+        return &indexType;
+    }
+    /**
+     * Updates the index Type. Uses = operator
+     * @param indexType Type to copy from
+     */
+    void setIndexType(T* indexType) {
+        this->indexType = *indexType;
+    }
 
-	uint32_t getSize() const {
-		return size;
-	}
+    uint32_t getSize() const {
+        return size;
+    }
 
-	void setSize(uint32_t size) {
-		this->size = size;
-	}
+    void setSize(uint32_t size) {
+        this->size = size;
+    }
 
-	void addSize(uint32_t size){
-		this->size += size;
-	}
+    void addSize(uint32_t size){
+        this->size += size;
+    }
 
-	void setStoredPackets(uint32_t newStoredPackets){
-		this->storedPackets = newStoredPackets;
-	}
+    void setStoredPackets(uint32_t newStoredPackets){
+        this->storedPackets = newStoredPackets;
+    }
 
-	void addStoredPackets(uint32_t packets){
-		this->storedPackets += packets;
-	}
+    void addStoredPackets(uint32_t packets){
+        this->storedPackets += packets;
+    }
 
-	uint32_t getStoredPackets() const{
-		return this->storedPackets;
-	}
+    uint32_t getStoredPackets() const{
+        return this->storedPackets;
+    }
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+                size_t maxSize, Endianness streamEndianness) const {
+        ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = indexType.serialize(buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
+        return result;
+    }
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		return result;
-	}
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                Endianness streamEndianness){
+        ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = indexType.deSerialize(buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        return result;
+    }
 
-	size_t getSerializedSize() const {
-		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
-		size += indexType.getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
-		return size;
-	}
+    size_t getSerializedSize() const {
+        uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
+        size += indexType.getSerializedSize();
+        size += SerializeAdapter::getSerializedSize(&this->size);
+        size += SerializeAdapter::getSerializedSize(&this->storedPackets);
+        return size;
+    }
 
 
-	bool operator==(const Index<T>& other){
-		return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
-	}
+    bool operator==(const Index<T>& other){
+        return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
+    }
 
 private:
-	uint32_t blockStartAddress;
-	uint32_t size;
-	uint32_t storedPackets;
-	T indexType;
+    uint32_t blockStartAddress;
+    uint32_t size;
+    uint32_t storedPackets;
+    T indexType;
 };
 
 
 
 template<typename T>
 class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
-	/**
-	 * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest data comes in last
-	 * It uses the currentWriteBlock as pointer to the current writing position
-	 * The currentReadBlock must be set manually
-	 */
+    /**
+     * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest data comes in last
+     * It uses the currentWriteBlock as pointer to the current writing position
+     * The currentReadBlock must be set manually
+     */
 public:
-	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock, SerializeIF* additionalInfo,
-			bool overwriteOld) :ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld){
+    IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock, SerializeIF* additionalInfo,
+            bool overwriteOld) :ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld){
 
-		//Calculate the maximum number of indices needed for this blocksize
-		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
+        //Calculate the maximum number of indices needed for this blocksize
+        uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
 
-		//Calculate the Size needeed for the index itself
-		uint32_t serializedSize = 0;
-		if(additionalInfo!=NULL){
-			serializedSize += additionalInfo->getSerializedSize();
-		}
-		//Size of current iterator type
-		Index<T> tempIndex;
-		serializedSize += tempIndex.getSerializedSize();
+        //Calculate the Size needeed for the index itself
+        uint32_t serializedSize = 0;
+        if(additionalInfo!=NULL){
+            serializedSize += additionalInfo->getSerializedSize();
+        }
+        //Size of current iterator type
+        Index<T> tempIndex;
+        serializedSize += tempIndex.getSerializedSize();
 
-		//Add Size of Array
-		serializedSize += sizeof(uint32_t); //size of array
-		serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
-		serializedSize += sizeof(uint16_t); //size of crc
+        //Add Size of Array
+        serializedSize += sizeof(uint32_t); //size of array
+        serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
+        serializedSize += sizeof(uint16_t); //size of crc
 
-		//Calculate new size after index
-		if(serializedSize > totalSize){
-			error << "IndexedRingMemory: Store is too small for index" << std::endl;
-		}
-		uint32_t useableSize = totalSize - serializedSize;
-		//Update the totalSize for calculations
-		totalSize = useableSize;
+        //Calculate new size after index
+        if(serializedSize > totalSize){
+            error << "IndexedRingMemory: Store is too small for index" << std::endl;
+        }
+        uint32_t useableSize = totalSize - serializedSize;
+        //Update the totalSize for calculations
+        totalSize = useableSize;
 
-		//True StartAddress
-		uint32_t trueStartAddress = indexAddress + serializedSize;
+        //True StartAddress
+        uint32_t trueStartAddress = indexAddress + serializedSize;
 
-		//Calculate True number of Blocks and reset size of true Number of Blocks
-		uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
+        //Calculate True number of Blocks and reset size of true Number of Blocks
+        uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
 
-		//allocate memory now
-		this->entries = new Index<T>[trueNumberOfBlocks];
-		this->size = trueNumberOfBlocks;
-		this->maxSize_ = trueNumberOfBlocks;
-		this->allocated = true;
+        //allocate memory now
+        this->entries = new Index<T>[trueNumberOfBlocks];
+        this->size = trueNumberOfBlocks;
+        this->maxSize_ = trueNumberOfBlocks;
+        this->allocated = true;
 
-		//Check trueNumberOfBlocks
-		if(trueNumberOfBlocks<1){
-			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
-		}
+        //Check trueNumberOfBlocks
+        if(trueNumberOfBlocks<1){
+            error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
+        }
 
 
 
-		//Fill address into index
-		uint32_t address = trueStartAddress;
-		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
-			it->setBlockStartAddress(address);
-			it->setSize(0);
-			it->setStoredPackets(0);
-			address += bytesPerBlock;
-		}
+        //Fill address into index
+        uint32_t address = trueStartAddress;
+        for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
+            it->setBlockStartAddress(address);
+            it->setSize(0);
+            it->setStoredPackets(0);
+            address += bytesPerBlock;
+        }
 
 
-		//Initialize iterators
-		currentWriteBlock = this->begin();
-		currentReadBlock = this->begin();
-		lastBlockToRead = this->begin();
+        //Initialize iterators
+        currentWriteBlock = this->begin();
+        currentReadBlock = this->begin();
+        lastBlockToRead = this->begin();
 
-		//Check last blockSize
-		uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
-		if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
-			//remove the last Block so the second last block has more size
-			this->size -= 1;
-			debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
-		}
-	}
+        //Check last blockSize
+        uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
+        if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
+            //remove the last Block so the second last block has more size
+            this->size -= 1;
+            debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
+        }
+    }
 
-	/**
-	 * Resets the whole index, the iterators and executes the given reset function on every index type
-	 * @param typeResetFnc static reset function which accepts a pointer to the index Type
-	 */
-	void reset(void (*typeResetFnc)(T*)){
-		currentReadBlock = this->begin();
-		currentWriteBlock = this->begin();
-		lastBlockToRead = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = 0;
-		lastBlockToReadSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
-			it->setSize(0);
-			it->setStoredPackets(0);
-			(*typeResetFnc)(it->modifyIndexType());
-		}
-	}
+    /**
+     * Resets the whole index, the iterators and executes the given reset function on every index type
+     * @param typeResetFnc static reset function which accepts a pointer to the index Type
+     */
+    void reset(void (*typeResetFnc)(T*)){
+        currentReadBlock = this->begin();
+        currentWriteBlock = this->begin();
+        lastBlockToRead = this->begin();
+        currentReadSize = 0;
+        currentReadBlockSizeCached = 0;
+        lastBlockToReadSize = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
+            it->setSize(0);
+            it->setStoredPackets(0);
+            (*typeResetFnc)(it->modifyIndexType());
+        }
+    }
 
-	void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
-		it->setSize(0);
-		it->setStoredPackets(0);
-		(*typeResetFnc)(it->modifyIndexType());
-	}
+    void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
+        it->setSize(0);
+        it->setStoredPackets(0);
+        (*typeResetFnc)(it->modifyIndexType());
+    }
 
-	/*
-	 * Reading
-	 */
+    /*
+     * Reading
+     */
 
-	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
-		currentReadBlock = it;
-		currentReadBlockSizeCached = it->getSize();
-	}
+    void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
+        currentReadBlock = it;
+        currentReadBlockSizeCached = it->getSize();
+    }
 
-	void resetRead(){
-		currentReadBlock = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = this->begin()->getSize();
-		lastBlockToRead = currentWriteBlock;
-		lastBlockToReadSize = currentWriteBlock->getSize();
-	}
-	/**
-	 * Sets the last block to read to this iterator.
-	 * Can be used to dump until block x
-	 * @param it The iterator for the last read block
-	 */
-	void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
-		lastBlockToRead = it;
-		lastBlockToReadSize = it->getSize();
-	}
+    void resetRead(){
+        currentReadBlock = this->begin();
+        currentReadSize = 0;
+        currentReadBlockSizeCached = this->begin()->getSize();
+        lastBlockToRead = currentWriteBlock;
+        lastBlockToReadSize = currentWriteBlock->getSize();
+    }
+    /**
+     * Sets the last block to read to this iterator.
+     * Can be used to dump until block x
+     * @param it The iterator for the last read block
+     */
+    void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
+        lastBlockToRead = it;
+        lastBlockToReadSize = it->getSize();
+    }
 
-	/**
-	 * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
-	 * Can be the currentWriteBlock as well
-	 */
-	void readOldest(){
-		resetRead();
-		currentReadBlock = getNextNonEmptyBlock();
-		currentReadBlockSizeCached = currentReadBlock->getSize();
+    /**
+     * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
+     * Can be the currentWriteBlock as well
+     */
+    void readOldest(){
+        resetRead();
+        currentReadBlock = getNextNonEmptyBlock();
+        currentReadBlockSizeCached = currentReadBlock->getSize();
 
-	}
+    }
 
-	/**
-	 * Sets the current read iterator to the next Block and resets the current read size
-	 * The current size of the block will be cached to avoid race condition between write and read
-	 * If the end of the ring is reached the read pointer will be set to the begin
-	 */
-	void readNext(){
-		currentReadSize = 0;
-		if((this->size != 0) && (currentReadBlock.value ==this->back())){
-			currentReadBlock = this->begin();
-		}else{
-			currentReadBlock++;
-		}
+    /**
+     * Sets the current read iterator to the next Block and resets the current read size
+     * The current size of the block will be cached to avoid race condition between write and read
+     * If the end of the ring is reached the read pointer will be set to the begin
+     */
+    void readNext(){
+        currentReadSize = 0;
+        if((this->size != 0) && (currentReadBlock.value ==this->back())){
+            currentReadBlock = this->begin();
+        }else{
+            currentReadBlock++;
+        }
 
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-	}
+        currentReadBlockSizeCached = currentReadBlock->getSize();
+    }
 
-	/**
-	 * Returns the address which is currently read from
-	 * @return Address to read from
-	 */
-	uint32_t getCurrentReadAddress() const {
-		return getAddressOfCurrentReadBlock() + currentReadSize;
-	}
-	/**
-	 * Adds readSize to the current size and checks if the read has no more data left and advances the read block
-	 * @param readSize The size that was read
-	 * @return Returns true if the read can go on
-	 */
-	bool addReadSize(uint32_t readSize) {
-		if(currentReadBlock == lastBlockToRead){
-			//The current read block is the last to read
-			if((currentReadSize+readSize)<lastBlockToReadSize){
-				//the block has more data -> return true
-				currentReadSize += readSize;
-				return true;
-			}else{
-				//Reached end of read -> return false
-				currentReadSize = lastBlockToReadSize;
-				return false;
-			}
-		}else{
-			//We are not in the last Block
-			if((currentReadSize + readSize)<currentReadBlockSizeCached){
-				//The current Block has more data
-				currentReadSize += readSize;
-				return true;
-			}else{
-				//The current block is written completely
-				readNext();
-				if(currentReadBlockSizeCached==0){
-					//Next block is empty
-					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
-					//Search if any block between this and the last block is not empty
-					for(;it!=lastBlockToRead;++it){
-						if(it == this->end()){
-							//This is the end, next block is the begin
-							it = this->begin();
-							if(it == lastBlockToRead){
-								//Break if the begin is the lastBlockToRead
-								break;
-							}
-						}
-						if(it->getSize()!=0){
-							//This is a non empty block. Go on reading with this block
-							currentReadBlock = it;
-							currentReadBlockSizeCached = it->getSize();
-							return true;
-						}
-					}
-					//reached lastBlockToRead and every block was empty, check if the last block is also empty
-					if(lastBlockToReadSize!=0){
-						//go on with last Block
-						currentReadBlock = lastBlockToRead;
-						currentReadBlockSizeCached = lastBlockToReadSize;
-						return true;
-					}
-					//There is no non empty block left
-					return false;
-				}
-				//Size is larger than 0
-				return true;
-			}
-		}
-	}
-	uint32_t getRemainigSizeOfCurrentReadBlock() const{
-		if(currentReadBlock == lastBlockToRead){
-			return (lastBlockToReadSize - currentReadSize);
-		}else{
-			return (currentReadBlockSizeCached - currentReadSize);
-		}
-	}
+    /**
+     * Returns the address which is currently read from
+     * @return Address to read from
+     */
+    uint32_t getCurrentReadAddress() const {
+        return getAddressOfCurrentReadBlock() + currentReadSize;
+    }
+    /**
+     * Adds readSize to the current size and checks if the read has no more data left and advances the read block
+     * @param readSize The size that was read
+     * @return Returns true if the read can go on
+     */
+    bool addReadSize(uint32_t readSize) {
+        if(currentReadBlock == lastBlockToRead){
+            //The current read block is the last to read
+            if((currentReadSize+readSize)<lastBlockToReadSize){
+                //the block has more data -> return true
+                currentReadSize += readSize;
+                return true;
+            }else{
+                //Reached end of read -> return false
+                currentReadSize = lastBlockToReadSize;
+                return false;
+            }
+        }else{
+            //We are not in the last Block
+            if((currentReadSize + readSize)<currentReadBlockSizeCached){
+                //The current Block has more data
+                currentReadSize += readSize;
+                return true;
+            }else{
+                //The current block is written completely
+                readNext();
+                if(currentReadBlockSizeCached==0){
+                    //Next block is empty
+                    typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
+                    //Search if any block between this and the last block is not empty
+                    for(;it!=lastBlockToRead;++it){
+                        if(it == this->end()){
+                            //This is the end, next block is the begin
+                            it = this->begin();
+                            if(it == lastBlockToRead){
+                                //Break if the begin is the lastBlockToRead
+                                break;
+                            }
+                        }
+                        if(it->getSize()!=0){
+                            //This is a non empty block. Go on reading with this block
+                            currentReadBlock = it;
+                            currentReadBlockSizeCached = it->getSize();
+                            return true;
+                        }
+                    }
+                    //reached lastBlockToRead and every block was empty, check if the last block is also empty
+                    if(lastBlockToReadSize!=0){
+                        //go on with last Block
+                        currentReadBlock = lastBlockToRead;
+                        currentReadBlockSizeCached = lastBlockToReadSize;
+                        return true;
+                    }
+                    //There is no non empty block left
+                    return false;
+                }
+                //Size is larger than 0
+                return true;
+            }
+        }
+    }
+    uint32_t getRemainigSizeOfCurrentReadBlock() const{
+        if(currentReadBlock == lastBlockToRead){
+            return (lastBlockToReadSize - currentReadSize);
+        }else{
+            return (currentReadBlockSizeCached - currentReadSize);
+        }
+    }
 
-	uint32_t getAddressOfCurrentReadBlock() const {
-		return currentReadBlock->getBlockStartAddress();
-	}
+    uint32_t getAddressOfCurrentReadBlock() const {
+        return currentReadBlock->getBlockStartAddress();
+    }
 
-	/**
-	 * Gets the next non empty Block after the current write block,
-	 * @return Returns the iterator to the block. If there is non, the current write block is returned
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
-		for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
-				if(it == this->end()){
-					it = this->begin();
-					if(it == currentWriteBlock){
-						break;
-					}
-				}
-				if(it->getSize()!=0){
-					return it;
-				}
-		}
-		return currentWriteBlock;
-	}
+    /**
+     * Gets the next non empty Block after the current write block,
+     * @return Returns the iterator to the block. If there is non, the current write block is returned
+     */
+    typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
+        for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
+                if(it == this->end()){
+                    it = this->begin();
+                    if(it == currentWriteBlock){
+                        break;
+                    }
+                }
+                if(it->getSize()!=0){
+                    return it;
+                }
+        }
+        return currentWriteBlock;
+    }
 
-	/**
-	 * Returns a copy of the oldest Index type
-	 * @return Type of Index
-	 */
-	T* getOldest(){
-		return (getNextNonEmptyBlock()->modifyIndexType());
-	}
+    /**
+     * Returns a copy of the oldest Index type
+     * @return Type of Index
+     */
+    T* getOldest(){
+        return (getNextNonEmptyBlock()->modifyIndexType());
+    }
 
 
-	/*
-	 * Writing
-	 */
-	uint32_t getAddressOfCurrentWriteBlock() const{
-		return currentWriteBlock->getBlockStartAddress();
-	}
+    /*
+     * Writing
+     */
+    uint32_t getAddressOfCurrentWriteBlock() const{
+        return currentWriteBlock->getBlockStartAddress();
+    }
 
-	uint32_t getSizeOfCurrentWriteBlock() const{
-		return currentWriteBlock->getSize();
-	}
+    uint32_t getSizeOfCurrentWriteBlock() const{
+        return currentWriteBlock->getSize();
+    }
 
-	uint32_t getCurrentWriteAddress() const{
-		return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
-	}
+    uint32_t getCurrentWriteAddress() const{
+        return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
+    }
 
-	void clearCurrentWriteBlock(){
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-	}
+    void clearCurrentWriteBlock(){
+        currentWriteBlock->setSize(0);
+        currentWriteBlock->setStoredPackets(0);
+    }
 
-	void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
-		currentWriteBlock->addSize(size);
-		currentWriteBlock->addStoredPackets(storedPackets);
-	}
+    void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
+        currentWriteBlock->addSize(size);
+        currentWriteBlock->addStoredPackets(storedPackets);
+    }
 
-	T* modifyCurrentWriteBlockIndexType(){
-		return currentWriteBlock->modifyIndexType();
-	}
-	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
-		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
-		it->addSize(size);
-		it->addStoredPackets(storedPackets);
-	}
+    T* modifyCurrentWriteBlockIndexType(){
+        return currentWriteBlock->modifyIndexType();
+    }
+    void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
+        typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
+        it->addSize(size);
+        it->addStoredPackets(storedPackets);
+    }
 
 
-	/**
-	 * Checks if the block has enough space for sizeToWrite
-	 * @param sizeToWrite The data to be written in the Block
-	 * @return Returns true if size to write is smaller the remaining size of the block
-	 */
-	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
-		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
-		uint32_t addressOfNextBlock = next->getBlockStartAddress();
-		uint32_t availableSize = ((addressOfNextBlock+totalSize) - (getAddressOfCurrentWriteBlock()+getSizeOfCurrentWriteBlock()))%totalSize;
-		return (sizeToWrite < availableSize);
-	}
+    /**
+     * Checks if the block has enough space for sizeToWrite
+     * @param sizeToWrite The data to be written in the Block
+     * @return Returns true if size to write is smaller the remaining size of the block
+     */
+    bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
+        typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
+        uint32_t addressOfNextBlock = next->getBlockStartAddress();
+        uint32_t availableSize = ((addressOfNextBlock+totalSize) - (getAddressOfCurrentWriteBlock()+getSizeOfCurrentWriteBlock()))%totalSize;
+        return (sizeToWrite < availableSize);
+    }
 
-	/**
-	 * Checks if the store is full if overwrite old is false
-	 * @return Returns true if it is writeable and false if not
-	 */
-	bool isNextBlockWritable(){
-		//First check if this is the end of the list
-		typename IndexedRingMemoryArray<T>::Iterator next;
-		next = getNextWrite();
-		if((next->getSize()!=0) && (!overwriteOld)){
-			return false;
-		}
-		return true;
-	}
+    /**
+     * Checks if the store is full if overwrite old is false
+     * @return Returns true if it is writeable and false if not
+     */
+    bool isNextBlockWritable(){
+        //First check if this is the end of the list
+        typename IndexedRingMemoryArray<T>::Iterator next;
+        next = getNextWrite();
+        if((next->getSize()!=0) && (!overwriteOld)){
+            return false;
+        }
+        return true;
+    }
 
-	/**
-	 * Updates current write Block Index Type
-	 * @param infoOfNewBlock
-	 */
-	void updateCurrentBlock(T* infoOfNewBlock){
-		currentWriteBlock->setIndexType(infoOfNewBlock);
-	}
+    /**
+     * Updates current write Block Index Type
+     * @param infoOfNewBlock
+     */
+    void updateCurrentBlock(T* infoOfNewBlock){
+        currentWriteBlock->setIndexType(infoOfNewBlock);
+    }
 
 
-	/**
-	 * Succeed to next block, returns FAILED if overwrite is false and the store is full
-	 * @return
-	 */
-	ReturnValue_t writeNext(){
-		//Check Next Block
-		if(!isNextBlockWritable()){
-			//The Index is full and does not overwrite old
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		//Next block can be written, update Metadata
-		currentWriteBlock = getNextWrite();
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    /**
+     * Succeed to next block, returns FAILED if overwrite is false and the store is full
+     * @return
+     */
+    ReturnValue_t writeNext(){
+        //Check Next Block
+        if(!isNextBlockWritable()){
+            //The Index is full and does not overwrite old
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        //Next block can be written, update Metadata
+        currentWriteBlock = getNextWrite();
+        currentWriteBlock->setSize(0);
+        currentWriteBlock->setStoredPackets(0);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	/**
-	 * Serializes the Index and calculates the CRC.
-	 * Parameters according to HasSerializeIF
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param streamEndianness
-	 * @return
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const{
-		uint8_t* crcBuffer = *buffer;
-		uint32_t oldSize = *size;
-		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
-		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
+    /**
+     * Serializes the Index and calculates the CRC.
+     * Parameters according to HasSerializeIF
+     * @param buffer
+     * @param size
+     * @param maxSize
+     * @param streamEndianness
+     * @return
+     */
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+                size_t maxSize, Endianness streamEndianness) const{
+        uint8_t* crcBuffer = *buffer;
+        uint32_t oldSize = *size;
+        if(additionalInfo!=NULL){
+            additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
+        }
+        ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
 
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+            result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
+                    maxSize, streamEndianness);
+            ++i;
+        }
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
+        result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
+        return result;
+    }
 
 
-	/**
-	 * Get the serialized Size of the index
-	 * @return The serialized size of the index
-	 */
-	size_t getSerializedSize() const {
+    /**
+     * Get the serialized Size of the index
+     * @return The serialized size of the index
+     */
+    size_t getSerializedSize() const {
 
-		uint32_t size = 0;
-		if(additionalInfo!=NULL){
-			size += additionalInfo->getSerializedSize();
-		}
-		size += currentWriteBlock->getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += (this->entries[0].getSerializedSize()) * this->size;
-		uint16_t crc = 0;
-		size += SerializeAdapter::getSerializedSize(&crc);
-		return size;
-	}
-	/**
-	 * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
-	 * CRC Has to be checked before!
-	 * @param buffer
-	 * @param size
-	 * @param streamEndianness
-	 * @return
-	 */
+        uint32_t size = 0;
+        if(additionalInfo!=NULL){
+            size += additionalInfo->getSerializedSize();
+        }
+        size += currentWriteBlock->getSerializedSize();
+        size += SerializeAdapter::getSerializedSize(&this->size);
+        size += (this->entries[0].getSerializedSize()) * this->size;
+        uint16_t crc = 0;
+        size += SerializeAdapter::getSerializedSize(&crc);
+        return size;
+    }
+    /**
+     * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
+     * CRC Has to be checked before!
+     * @param buffer
+     * @param size
+     * @param streamEndianness
+     * @return
+     */
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                Endianness streamEndianness){
 
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
+        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+        if(additionalInfo!=NULL){
+            result = additionalInfo->deSerialize(buffer,size,streamEndianness);
+        }
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
 
-		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		uint32_t tempSize = 0;
-		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		if(this->size != tempSize){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::deSerialize(
-					&this->entries[i], buffer, size,
-					streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			if(*(cmp.value) == *(it.value)){
-				currentWriteBlock = it;
-				return HasReturnvaluesIF::RETURN_OK;
-			}
-		}
-		//Reached if current write block iterator is not found
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        Index<T> tempIndex;
+        result = tempIndex.deSerialize(buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        uint32_t tempSize = 0;
+        result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        if(this->size != tempSize){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+            result = SerializeAdapter::deSerialize(
+                    &this->entries[i], buffer, size,
+                    streamEndianness);
+            ++i;
+        }
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            if(*(cmp.value) == *(it.value)){
+                currentWriteBlock = it;
+                return HasReturnvaluesIF::RETURN_OK;
+            }
+        }
+        //Reached if current write block iterator is not found
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	uint32_t getIndexAddress() const {
-		return indexAddress;
-	}
+    uint32_t getIndexAddress() const {
+        return indexAddress;
+    }
 
 
-	/*
-	 * Statistics
-	 */
-	uint32_t getStoredPackets() const {
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getStoredPackets();
-		}
-		return size;
-	}
+    /*
+     * Statistics
+     */
+    uint32_t getStoredPackets() const {
+        uint32_t size = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            size += it->getStoredPackets();
+        }
+        return size;
+    }
 
-	uint32_t getTotalSize() const {
-		return totalSize;
-	}
+    uint32_t getTotalSize() const {
+        return totalSize;
+    }
 
-	uint32_t getCurrentSize() const{
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getSize();
-		}
-		return size;
-	}
+    uint32_t getCurrentSize() const{
+        uint32_t size = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            size += it->getSize();
+        }
+        return size;
+    }
 
-	bool isEmpty() const{
-		return getCurrentSize()==0;
-	}
+    bool isEmpty() const{
+        return getCurrentSize()==0;
+    }
 
-	double getPercentageFilled() const{
-		uint32_t filledSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			filledSize += it->getSize();
-		}
+    double getPercentageFilled() const{
+        uint32_t filledSize = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            filledSize += it->getSize();
+        }
 
-		return (double)filledSize/(double)this->totalSize;
-	}
+        return (double)filledSize/(double)this->totalSize;
+    }
 
-	typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
-		return currentWriteBlock;
-	}
-	/**
-	 * Get the next block of the currentWriteBlock.
-	 * Returns the first one if currentWriteBlock is the last one
-	 * @return Iterator pointing to the next block after currentWriteBlock
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
-		typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
-		if((this->size != 0) && (currentWriteBlock.value == this->back())){
-			next = this->begin();
-		}else{
-			++next;
-		}
-		return next;
-	}
-	/**
-	 * Get the block in front of the Iterator
-	 * Returns the last block if it is the first block
-	 * @param it iterator which you want the previous block from
-	 * @return pointing to the block before it
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
-		if(this->begin() == it){
-			typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
-			return next;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator next(it);
-		--next;
-		return next;
-	}
+    typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
+        return currentWriteBlock;
+    }
+    /**
+     * Get the next block of the currentWriteBlock.
+     * Returns the first one if currentWriteBlock is the last one
+     * @return Iterator pointing to the next block after currentWriteBlock
+     */
+    typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
+        typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
+        if((this->size != 0) && (currentWriteBlock.value == this->back())){
+            next = this->begin();
+        }else{
+            ++next;
+        }
+        return next;
+    }
+    /**
+     * Get the block in front of the Iterator
+     * Returns the last block if it is the first block
+     * @param it iterator which you want the previous block from
+     * @return pointing to the block before it
+     */
+    typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
+        if(this->begin() == it){
+            typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
+            return next;
+        }
+        typename IndexedRingMemoryArray<T>::Iterator next(it);
+        --next;
+        return next;
+    }
 private:
-	//The total size used by the blocks (without index)
-	uint32_t totalSize;
+    //The total size used by the blocks (without index)
+    uint32_t totalSize;
 
-	//The address of the index
-	const uint32_t indexAddress;
+    //The address of the index
+    const uint32_t indexAddress;
 
-	//The iterators for writing and reading
-	typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
-	typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
+    //The iterators for writing and reading
+    typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
+    typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
 
-	//How much of the current read block is read already
-	uint32_t currentReadSize;
+    //How much of the current read block is read already
+    uint32_t currentReadSize;
 
-	//Cached Size of current read block
-	uint32_t currentReadBlockSizeCached;
+    //Cached Size of current read block
+    uint32_t currentReadBlockSizeCached;
 
-	//Last block of current write (should be write block)
-	typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
-	//current size of last Block to read
-	uint32_t lastBlockToReadSize;
+    //Last block of current write (should be write block)
+    typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
+    //current size of last Block to read
+    uint32_t lastBlockToReadSize;
 
-	//Additional Info to be serialized with the index
-	SerializeIF* additionalInfo;
+    //Additional Info to be serialized with the index
+    SerializeIF* additionalInfo;
 
-	//Does it overwrite old blocks?
-	const bool overwriteOld;
+    //Does it overwrite old blocks?
+    const bool overwriteOld;
 
 };
 
diff --git a/container/PlacementFactory.h b/container/PlacementFactory.h
index a0aebb7d1..94b4aeefd 100644
--- a/container/PlacementFactory.h
+++ b/container/PlacementFactory.h
@@ -22,50 +22,50 @@
  */
 class PlacementFactory {
 public:
-	PlacementFactory(StorageManagerIF* backend) :
-			dataBackend(backend) {
-	}
+    PlacementFactory(StorageManagerIF* backend) :
+            dataBackend(backend) {
+    }
 
-	/***
-	 * Generates an object of type T in the backend storage.
-	 *
-	 * @warning Do not use with any Type that allocates memory internally!
-	 *
-	 * @tparam T Type of Object
-	 * @param args Constructor Arguments to be passed
-	 * @return A pointer to the new object or a nullptr in case of failure
-	 */
-	template<typename T, typename ... Args>
-	T* generate(Args&&... args) {
-		store_address_t tempId;
-		uint8_t* pData = nullptr;
-		ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
-				&pData);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return nullptr;
-		}
-		T* temp = new (pData) T(std::forward<Args>(args)...);
-		return temp;
-	}
-	/***
-	 * Function to destroy the object allocated with generate and free space in backend.
-	 * This must be called by the user.
-	 *
-	 * @param thisElement Element to be destroyed
-	 * @return RETURN_OK if the element was destroyed, different errors on failure
-	 */
-	template<typename T>
-	ReturnValue_t destroy(T* thisElement) {
-		if (thisElement == nullptr){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		//Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
-		thisElement->~T();
-		uint8_t* pointer = (uint8_t*) (thisElement);
-		return dataBackend->deleteData(pointer, sizeof(T));
-	}
+    /***
+     * Generates an object of type T in the backend storage.
+     *
+     * @warning Do not use with any Type that allocates memory internally!
+     *
+     * @tparam T Type of Object
+     * @param args Constructor Arguments to be passed
+     * @return A pointer to the new object or a nullptr in case of failure
+     */
+    template<typename T, typename ... Args>
+    T* generate(Args&&... args) {
+        store_address_t tempId;
+        uint8_t* pData = nullptr;
+        ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
+                &pData);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return nullptr;
+        }
+        T* temp = new (pData) T(std::forward<Args>(args)...);
+        return temp;
+    }
+    /***
+     * Function to destroy the object allocated with generate and free space in backend.
+     * This must be called by the user.
+     *
+     * @param thisElement Element to be destroyed
+     * @return RETURN_OK if the element was destroyed, different errors on failure
+     */
+    template<typename T>
+    ReturnValue_t destroy(T* thisElement) {
+        if (thisElement == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        //Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
+        thisElement->~T();
+        uint8_t* pointer = (uint8_t*) (thisElement);
+        return dataBackend->deleteData(pointer, sizeof(T));
+    }
 private:
-	StorageManagerIF* dataBackend;
+    StorageManagerIF* dataBackend;
 };
 
 #endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */
diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 886b9fab9..9277c50bf 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -7,107 +7,107 @@
 template<uint8_t N_READ_PTRS = 1>
 class RingBufferBase {
 public:
-	RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
-			start(startAddress), write(startAddress), size(size),
-			overwriteOld(overwriteOld) {
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = startAddress;
-		}
-	}
+    RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
+            start(startAddress), write(startAddress), size(size),
+            overwriteOld(overwriteOld) {
+        for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+            read[count] = startAddress;
+        }
+    }
 
-	virtual ~RingBufferBase() {}
+    virtual ~RingBufferBase() {}
 
-	bool isFull(uint8_t n = 0) {
-		return (availableWriteSpace(n) == 0);
-	}
-	bool isEmpty(uint8_t n = 0) {
-		return (getAvailableReadData(n) == 0);
-	}
+    bool isFull(uint8_t n = 0) {
+        return (availableWriteSpace(n) == 0);
+    }
+    bool isEmpty(uint8_t n = 0) {
+        return (getAvailableReadData(n) == 0);
+    }
 
-	size_t getAvailableReadData(uint8_t n = 0) const {
-		return ((write + size) - read[n]) % size;
-	}
-	size_t availableWriteSpace(uint8_t n = 0) const  {
-		//One less to avoid ambiguous full/empty problem.
-		return (((read[n] + size) - write - 1) % size);
-	}
+    size_t getAvailableReadData(uint8_t n = 0) const {
+        return ((write + size) - read[n]) % size;
+    }
+    size_t availableWriteSpace(uint8_t n = 0) const  {
+        //One less to avoid ambiguous full/empty problem.
+        return (((read[n] + size) - write - 1) % size);
+    }
 
-	bool overwritesOld() const {
-		return overwriteOld;
-	}
+    bool overwritesOld() const {
+        return overwriteOld;
+    }
 
-	size_t getMaxSize() const {
-		return size - 1;
-	}
+    size_t getMaxSize() const {
+        return size - 1;
+    }
 
-	void clear() {
-		write = start;
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = start;
-		}
-	}
+    void clear() {
+        write = start;
+        for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+            read[count] = start;
+        }
+    }
 
-	size_t writeTillWrap() {
-		return (start + size) - write;
-	}
+    size_t writeTillWrap() {
+        return (start + size) - write;
+    }
 
-	size_t readTillWrap(uint8_t n = 0) {
-		return (start + size) - read[n];
-	}
+    size_t readTillWrap(uint8_t n = 0) {
+        return (start + size) - read[n];
+    }
 
-	size_t getStart() const {
-		return start;
-	}
+    size_t getStart() const {
+        return start;
+    }
 
 protected:
-	const size_t start;
-	size_t write;
-	size_t read[N_READ_PTRS];
-	const size_t size;
-	const bool overwriteOld;
+    const size_t start;
+    size_t write;
+    size_t read[N_READ_PTRS];
+    const size_t size;
+    const bool overwriteOld;
 
-	void incrementWrite(uint32_t amount) {
-		write = ((write + amount - start) % size) + start;
-	}
-	void incrementRead(uint32_t amount, uint8_t n = 0) {
-		read[n] = ((read[n] + amount - start) % size) + start;
-	}
+    void incrementWrite(uint32_t amount) {
+        write = ((write + amount - start) % size) + start;
+    }
+    void incrementRead(uint32_t amount, uint8_t n = 0) {
+        read[n] = ((read[n] + amount - start) % size) + start;
+    }
 
-	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
-		if (getAvailableReadData(n) >= amount) {
-			incrementRead(amount, n);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
+    ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
+        if (getAvailableReadData(n) >= amount) {
+            incrementRead(amount, n);
+            return HasReturnvaluesIF::RETURN_OK;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
 
-	ReturnValue_t writeData(uint32_t amount) {
-		if (availableWriteSpace() >= amount or overwriteOld) {
-			incrementWrite(amount);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
+    ReturnValue_t writeData(uint32_t amount) {
+        if (availableWriteSpace() >= amount or overwriteOld) {
+            incrementWrite(amount);
+            return HasReturnvaluesIF::RETURN_OK;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
 
-	size_t getRead(uint8_t n = 0) const {
-		return read[n];
-	}
+    size_t getRead(uint8_t n = 0) const {
+        return read[n];
+    }
 
-	void setRead(uint32_t read, uint8_t n = 0) {
-		if (read >= start && read < (start+size)) {
-			this->read[n] = read;
-		}
-	}
+    void setRead(uint32_t read, uint8_t n = 0) {
+        if (read >= start && read < (start+size)) {
+            this->read[n] = read;
+        }
+    }
 
-	uint32_t getWrite() const {
-		return write;
-	}
+    uint32_t getWrite() const {
+        return write;
+    }
 
-	void setWrite(uint32_t write) {
-		this->write = write;
-	}
+    void setWrite(uint32_t write) {
+        this->write = write;
+    }
 };
 
 #endif /* FSFW_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 769ce0000..1681325d0 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -3,23 +3,23 @@
 #include "../ipc/MutexHelper.h"
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
-		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
+        bool overwriteOld, size_t maxExcessBytes):
+        SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
+        maxExcessBytes) {
+    mutex = MutexFactory::instance()->createMutex();
 }
 
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
-		const size_t size, bool overwriteOld, size_t maxExcessBytes):
-		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
+        const size_t size, bool overwriteOld, size_t maxExcessBytes):
+        SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
+        maxExcessBytes) {
+    mutex = MutexFactory::instance()->createMutex();
 }
 
 
 void SharedRingBuffer::setToUseReceiveSizeFIFO(size_t fifoDepth) {
-	this->fifoDepth = fifoDepth;
+    this->fifoDepth = fifoDepth;
 }
 
 ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
@@ -38,20 +38,20 @@ MutexIF* SharedRingBuffer::getMutexHandle() const {
 }
 
 ReturnValue_t SharedRingBuffer::initialize() {
-	if(fifoDepth > 0) {
-		receiveSizesFIFO = new DynamicFIFO<size_t>(fifoDepth);
-	}
-	return SystemObject::initialize();
+    if(fifoDepth > 0) {
+        receiveSizesFIFO = new DynamicFIFO<size_t>(fifoDepth);
+    }
+    return SystemObject::initialize();
 }
 
 DynamicFIFO<size_t>* SharedRingBuffer::getReceiveSizesFIFO() {
-	if(receiveSizesFIFO == nullptr) {
-		// Configuration error.
+    if(receiveSizesFIFO == nullptr) {
+        // Configuration error.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
-				<< " was not configured to have sizes FIFO, returning nullptr!"
-				<< std::endl;
+        sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
+                << " was not configured to have sizes FIFO, returning nullptr!"
+                << std::endl;
 #endif
-	}
-	return receiveSizesFIFO;
+    }
+    return receiveSizesFIFO;
 }
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 64d7ee291..43ab6e8fe 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -15,76 +15,76 @@
  * and unlock operations.
  */
 class SharedRingBuffer: public SystemObject,
-		public SimpleRingBuffer {
+        public SimpleRingBuffer {
 public:
-	/**
-	 * This constructor allocates a new internal buffer with the supplied size.
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes);
+    /**
+     * This constructor allocates a new internal buffer with the supplied size.
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+     */
+    SharedRingBuffer(object_id_t objectId, const size_t size,
+            bool overwriteOld, size_t maxExcessBytes);
 
-	/**
-	 * @brief	This function can be used to add an optional FIFO to the class
-	 * @details 
-	 * This FIFO will be allocated in the initialize function (and will
-	 * have a fixed maximum size after that). It can be used to store
-	 * values like packet sizes, for example for a shared ring buffer
-	 * used by producer/consumer tasks.
-	 */
-	void setToUseReceiveSizeFIFO(size_t fifoDepth);
+    /**
+     * @brief    This function can be used to add an optional FIFO to the class
+     * @details 
+     * This FIFO will be allocated in the initialize function (and will
+     * have a fixed maximum size after that). It can be used to store
+     * values like packet sizes, for example for a shared ring buffer
+     * used by producer/consumer tasks.
+     */
+    void setToUseReceiveSizeFIFO(size_t fifoDepth);
 
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes);
+    /**
+     * This constructor takes an external buffer with the specified size.
+     * @param buffer
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+     */
+    SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
+            bool overwriteOld, size_t maxExcessBytes);
 
-	/**
-	 * Unless a read-only constant value is read, all operations on the
-	 * shared ring buffer should be protected by calling this function.
-	 * @param timeoutType
-	 * @param timeout
-	 * @return
-	 */
-	virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
-	        dur_millis_t timeout);
-	/**
-	 * Any locked mutex also has to be unlocked, otherwise, access to the
-	 * shared ring buffer will be blocked.
-	 * @return
-	 */
-	virtual ReturnValue_t unlockRingBufferMutex();
+    /**
+     * Unless a read-only constant value is read, all operations on the
+     * shared ring buffer should be protected by calling this function.
+     * @param timeoutType
+     * @param timeout
+     * @return
+     */
+    virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
+            dur_millis_t timeout);
+    /**
+     * Any locked mutex also has to be unlocked, otherwise, access to the
+     * shared ring buffer will be blocked.
+     * @return
+     */
+    virtual ReturnValue_t unlockRingBufferMutex();
 
-	/**
-	 * The mutex handle can be accessed directly, for example to perform
-	 * the lock with the #MutexHelper for a RAII compliant lock operation.
-	 * @return
-	 */
-	MutexIF* getMutexHandle() const;
+    /**
+     * The mutex handle can be accessed directly, for example to perform
+     * the lock with the #MutexHelper for a RAII compliant lock operation.
+     * @return
+     */
+    MutexIF* getMutexHandle() const;
 
-	ReturnValue_t initialize() override;
+    ReturnValue_t initialize() override;
 
-	/**
-	 * If the shared ring buffer was configured to have a sizes FIFO, a handle
-	 * to that FIFO can be retrieved with this function.
-	 * Do not forget to protect access with a lock if required!
-	 * @return
-	 */
-	DynamicFIFO<size_t>* getReceiveSizesFIFO();
+    /**
+     * If the shared ring buffer was configured to have a sizes FIFO, a handle
+     * to that FIFO can be retrieved with this function.
+     * Do not forget to protect access with a lock if required!
+     * @return
+     */
+    DynamicFIFO<size_t>* getReceiveSizesFIFO();
 private:
-	MutexIF* mutex = nullptr;
+    MutexIF* mutex = nullptr;
 
-	size_t fifoDepth = 0;
-	DynamicFIFO<size_t>* receiveSizesFIFO = nullptr;
+    size_t fifoDepth = 0;
+    DynamicFIFO<size_t>* receiveSizesFIFO = nullptr;
 };
 
 
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 88c9290ef..8544acbf3 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -2,31 +2,31 @@
 #include <cstring>
 
 SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
-		size_t maxExcessBytes) :
-		RingBufferBase<>(0, size, overwriteOld),
-		maxExcessBytes(maxExcessBytes) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
-	buffer = new uint8_t[size + maxExcessBytes];
+        size_t maxExcessBytes) :
+        RingBufferBase<>(0, size, overwriteOld),
+        maxExcessBytes(maxExcessBytes) {
+    if(maxExcessBytes > size) {
+        this->maxExcessBytes = size;
+    }
+    else {
+        this->maxExcessBytes = maxExcessBytes;
+    }
+    buffer = new uint8_t[size + maxExcessBytes];
 }
 
 SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
+        bool overwriteOld, size_t maxExcessBytes):
         RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
+    if(maxExcessBytes > size) {
+        this->maxExcessBytes = size;
+    }
+    else {
+        this->maxExcessBytes = maxExcessBytes;
+    }
 }
 
 SimpleRingBuffer::~SimpleRingBuffer() {
-	delete[] buffer;
+    delete[] buffer;
 }
 
 ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
@@ -48,58 +48,58 @@ ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
 }
 
 void SimpleRingBuffer::confirmBytesWritten(size_t amount) {
-	if(getExcessBytes() > 0) {
-		moveExcessBytesToStart();
-	}
-	incrementWrite(amount);
+    if(getExcessBytes() > 0) {
+        moveExcessBytesToStart();
+    }
+    incrementWrite(amount);
 
 }
 
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
-		size_t amount) {
-	if (availableWriteSpace() >= amount or overwriteOld) {
-		size_t amountTillWrap = writeTillWrap();
-		if (amountTillWrap >= amount) {
-			// remaining size in buffer is sufficient to fit full amount.
-			memcpy(&buffer[write], data, amount);
-		}
-		else {
-			memcpy(&buffer[write], data, amountTillWrap);
-			memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
-		}
-		incrementWrite(amount);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        size_t amount) {
+    if (availableWriteSpace() >= amount or overwriteOld) {
+        size_t amountTillWrap = writeTillWrap();
+        if (amountTillWrap >= amount) {
+            // remaining size in buffer is sufficient to fit full amount.
+            memcpy(&buffer[write], data, amount);
+        }
+        else {
+            memcpy(&buffer[write], data, amountTillWrap);
+            memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
+        }
+        incrementWrite(amount);
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
-		bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
-	size_t availableData = getAvailableReadData(READ_PTR);
-	size_t amountTillWrap = readTillWrap(READ_PTR);
-	if (availableData < amount) {
-		if (readRemaining) {
-			// more data available than amount specified.
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	if (amountTillWrap >= amount) {
-		memcpy(data, &buffer[read[READ_PTR]], amount);
-	} else {
-		memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
-		memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
-	}
+        bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
+    size_t availableData = getAvailableReadData(READ_PTR);
+    size_t amountTillWrap = readTillWrap(READ_PTR);
+    if (availableData < amount) {
+        if (readRemaining) {
+            // more data available than amount specified.
+            amount = availableData;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    if (trueAmount != nullptr) {
+        *trueAmount = amount;
+    }
+    if (amountTillWrap >= amount) {
+        memcpy(data, &buffer[read[READ_PTR]], amount);
+    } else {
+        memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
+        memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
+    }
 
-	if(incrementReadPtr) {
-		deleteData(amount, readRemaining);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    if(incrementReadPtr) {
+        deleteData(amount, readRemaining);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 size_t SimpleRingBuffer::getExcessBytes() const {
@@ -114,18 +114,18 @@ void SimpleRingBuffer::moveExcessBytesToStart() {
 }
 
 ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
-		bool deleteRemaining, size_t* trueAmount) {
-	size_t availableData = getAvailableReadData(READ_PTR);
-	if (availableData < amount) {
-		if (deleteRemaining) {
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	incrementRead(amount, READ_PTR);
-	return HasReturnvaluesIF::RETURN_OK;
+        bool deleteRemaining, size_t* trueAmount) {
+    size_t availableData = getAvailableReadData(READ_PTR);
+    if (availableData < amount) {
+        if (deleteRemaining) {
+            amount = availableData;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    if (trueAmount != nullptr) {
+        *trueAmount = amount;
+    }
+    incrementRead(amount, READ_PTR);
+    return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 37ad5679f..6f31c5fba 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -5,7 +5,7 @@
 #include <cstddef>
 
 /**
- * @brief 	Circular buffer implementation, useful for buffering
+ * @brief     Circular buffer implementation, useful for buffering
  *          into data streams.
  * @details
  * Note that the deleteData() has to be called to increment the read pointer.
@@ -25,104 +25,104 @@ public:
      * with getFreeElement.
      *
      */
-	SimpleRingBuffer(const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
+    SimpleRingBuffer(const size_t size, bool overwriteOld,
+            size_t maxExcessBytes = 0);
+    /**
+     * This constructor takes an external buffer with the specified size.
+     * @param buffer
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
      * will be overwritten.
-	 * @param maxExcessBytes
-	 * If the buffer can accomodate additional bytes for contigous write
-	 * operations with getFreeElement, this is the maximum allowed additional
-	 * size
-	 */
-	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
+     * @param maxExcessBytes
+     * If the buffer can accomodate additional bytes for contigous write
+     * operations with getFreeElement, this is the maximum allowed additional
+     * size
+     */
+    SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
+            size_t maxExcessBytes = 0);
 
-	virtual ~SimpleRingBuffer();
+    virtual ~SimpleRingBuffer();
 
-	/**
-	 * Write to circular buffer and increment write pointer by amount.
-	 * @param data
-	 * @param amount
-	 * @return -@c RETURN_OK if write operation was successfull
-	 * -@c RETURN_FAILED if
-	 */
-	ReturnValue_t writeData(const uint8_t* data, size_t amount);
+    /**
+     * Write to circular buffer and increment write pointer by amount.
+     * @param data
+     * @param amount
+     * @return -@c RETURN_OK if write operation was successfull
+     * -@c RETURN_FAILED if
+     */
+    ReturnValue_t writeData(const uint8_t* data, size_t amount);
 
-	/**
-	 * Returns a pointer to a free element. If the remaining buffer is
-	 * not large enough, the data will be written past the actual size
-	 * and the amount of excess bytes will be cached. This function
-	 * does not increment the write pointer!
-	 * @param writePointer Pointer to a pointer which can be used to write
-	 * contiguous blocks into the ring buffer
-	 * @param amount
-	 * @return
-	 */
-	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
+    /**
+     * Returns a pointer to a free element. If the remaining buffer is
+     * not large enough, the data will be written past the actual size
+     * and the amount of excess bytes will be cached. This function
+     * does not increment the write pointer!
+     * @param writePointer Pointer to a pointer which can be used to write
+     * contiguous blocks into the ring buffer
+     * @param amount
+     * @return
+     */
+    ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
 
-	/**
-	 * This increments the write pointer and also copies the excess bytes
-	 * to the beginning. It should be called if the write operation
-	 * conducted after calling getFreeElement() was performed.
-	 * @return
-	 */
-	void confirmBytesWritten(size_t amount);
+    /**
+     * This increments the write pointer and also copies the excess bytes
+     * to the beginning. It should be called if the write operation
+     * conducted after calling getFreeElement() was performed.
+     * @return
+     */
+    void confirmBytesWritten(size_t amount);
 
-	virtual size_t getExcessBytes() const;
-	/**
-	 * Helper functions which moves any excess bytes to the start
-	 * of the ring buffer.
-	 * @return
-	 */
-	virtual void moveExcessBytesToStart();
+    virtual size_t getExcessBytes() const;
+    /**
+     * Helper functions which moves any excess bytes to the start
+     * of the ring buffer.
+     * @return
+     */
+    virtual void moveExcessBytesToStart();
 
-	/**
-	 * Read from circular buffer at read pointer.
-	 * @param data
-	 * @param amount
-	 * @param incrementReadPtr
-	 * If this is set to true, the read pointer will be incremented.
-	 * If readRemaining is set to true, the read pointer will be incremented
-	 * accordingly.
-	 * @param readRemaining
-	 * If this is set to true, the data will be read even if the amount
-	 * specified exceeds the read data available.
-	 * @param trueAmount [out]
-	 * If readRemaining was set to true, the true amount read will be assigned
-	 * to the passed value.
-	 * @return
-	 * - @c RETURN_OK if data was read successfully
-	 * - @c RETURN_FAILED if not enough data was available and readRemaining
-	 *      was set to false.
-	 */
-	ReturnValue_t readData(uint8_t* data, size_t amount,
-			bool incrementReadPtr = false, bool readRemaining = false,
-			size_t* trueAmount = nullptr);
+    /**
+     * Read from circular buffer at read pointer.
+     * @param data
+     * @param amount
+     * @param incrementReadPtr
+     * If this is set to true, the read pointer will be incremented.
+     * If readRemaining is set to true, the read pointer will be incremented
+     * accordingly.
+     * @param readRemaining
+     * If this is set to true, the data will be read even if the amount
+     * specified exceeds the read data available.
+     * @param trueAmount [out]
+     * If readRemaining was set to true, the true amount read will be assigned
+     * to the passed value.
+     * @return
+     * - @c RETURN_OK if data was read successfully
+     * - @c RETURN_FAILED if not enough data was available and readRemaining
+     *      was set to false.
+     */
+    ReturnValue_t readData(uint8_t* data, size_t amount,
+            bool incrementReadPtr = false, bool readRemaining = false,
+            size_t* trueAmount = nullptr);
 
-	/**
-	 * Delete data by incrementing read pointer.
-	 * @param amount
-	 * @param deleteRemaining
-	 * If the amount specified is larger than the remaing size to read and this
-	 * is set to true, the remaining amount will be deleted as well
-	 * @param trueAmount [out]
-	 * If deleteRemaining was set to true, the amount deleted will be assigned
-	 * to the passed value.
-	 * @return
-	 */
-	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
-	        size_t* trueAmount = nullptr);
+    /**
+     * Delete data by incrementing read pointer.
+     * @param amount
+     * @param deleteRemaining
+     * If the amount specified is larger than the remaing size to read and this
+     * is set to true, the remaining amount will be deleted as well
+     * @param trueAmount [out]
+     * If deleteRemaining was set to true, the amount deleted will be assigned
+     * to the passed value.
+     * @return
+     */
+    ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
+            size_t* trueAmount = nullptr);
 
 private:
-	static const uint8_t READ_PTR = 0;
-	uint8_t* buffer = nullptr;
-	size_t maxExcessBytes;
-	size_t excessBytes = 0;
+    static const uint8_t READ_PTR = 0;
+    uint8_t* buffer = nullptr;
+    size_t maxExcessBytes;
+    size_t excessBytes = 0;
 };
 
 #endif /* FSFW_CONTAINER_SIMPLERINGBUFFER_H_ */
diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index eb6ae276a..02d590c5c 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -5,71 +5,71 @@
 #include <cstdint>
 
 /**
- * @brief	Linked list data structure,
- * 			each entry has a pointer to the next entry (singly)
+ * @brief    Linked list data structure,
+ *             each entry has a pointer to the next entry (singly)
  * @ingroup container
  */
 template<typename T>
 class LinkedElement {
 public:
-	T *value;
-	class Iterator {
-	public:
-		LinkedElement<T> *value = nullptr;
-		Iterator() {}
+    T *value;
+    class Iterator {
+    public:
+        LinkedElement<T> *value = nullptr;
+        Iterator() {}
 
-		Iterator(LinkedElement<T> *element) :
-				value(element) {
-		}
+        Iterator(LinkedElement<T> *element) :
+                value(element) {
+        }
 
-		Iterator& operator++() {
-			value = value->getNext();
-			return *this;
-		}
+        Iterator& operator++() {
+            value = value->getNext();
+            return *this;
+        }
 
-		Iterator operator++(int) {
-			Iterator tmp(*this);
-			operator++();
-			return tmp;
-		}
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
 
-		bool operator==(Iterator other) {
-			return value == other.value;
-		}
+        bool operator==(Iterator other) {
+            return value == other.value;
+        }
 
-		bool operator!=(Iterator other) {
-			return !(*this == other);
-		}
-		T *operator->() {
-			return value->value;
-		}
-	};
+        bool operator!=(Iterator other) {
+            return !(*this == other);
+        }
+        T *operator->() {
+            return value->value;
+        }
+    };
 
-	LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
-	       value(setElement), next(setNext) {}
+    LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
+           value(setElement), next(setNext) {}
 
-	virtual ~LinkedElement(){}
+    virtual ~LinkedElement(){}
 
-	virtual LinkedElement* getNext() const {
-		return next;
-	}
+    virtual LinkedElement* getNext() const {
+        return next;
+    }
 
-	virtual void setNext(LinkedElement* next) {
-		this->next = next;
-	}
+    virtual void setNext(LinkedElement* next) {
+        this->next = next;
+    }
 
-	virtual void setEnd() {
-	    this->next = nullptr;
-	}
+    virtual void setEnd() {
+        this->next = nullptr;
+    }
 
-	LinkedElement* begin() {
-		return this;
-	}
-	LinkedElement* end() {
-		return nullptr;
-	}
+    LinkedElement* begin() {
+        return this;
+    }
+    LinkedElement* end() {
+        return nullptr;
+    }
 private:
-	LinkedElement *next;
+    LinkedElement *next;
 };
 
 template<typename T>
@@ -77,52 +77,52 @@ class SinglyLinkedList {
 public:
     using ElementIterator = typename LinkedElement<T>::Iterator;
 
-	SinglyLinkedList() {}
+    SinglyLinkedList() {}
 
-	SinglyLinkedList(ElementIterator start) :
-			start(start.value) {}
+    SinglyLinkedList(ElementIterator start) :
+            start(start.value) {}
 
-	SinglyLinkedList(LinkedElement<T>* startElement) :
-			start(startElement) {}
+    SinglyLinkedList(LinkedElement<T>* startElement) :
+            start(startElement) {}
 
-	ElementIterator begin() const {
-		return ElementIterator::Iterator(start);
-	}
+    ElementIterator begin() const {
+        return ElementIterator::Iterator(start);
+    }
 
-	/** Returns iterator to nulltr */
-	ElementIterator end() const {
-		return ElementIterator::Iterator();
-	}
+    /** Returns iterator to nulltr */
+    ElementIterator end() const {
+        return ElementIterator::Iterator();
+    }
 
-	/**
-	 * Returns last element in singly linked list.
-	 * @return
-	 */
-	ElementIterator back() const {
-	    LinkedElement<T> *element = start;
-	    while (element->getNext() != nullptr) {
-	        element = element->getNext();
-	    }
-	    return ElementIterator::Iterator(element);
-	}
+    /**
+     * Returns last element in singly linked list.
+     * @return
+     */
+    ElementIterator back() const {
+        LinkedElement<T> *element = start;
+        while (element->getNext() != nullptr) {
+            element = element->getNext();
+        }
+        return ElementIterator::Iterator(element);
+    }
 
-	size_t getSize() const {
-		size_t size = 0;
-		LinkedElement<T> *element = start;
-		while (element != nullptr) {
-			size++;
-			element = element->getNext();
-		}
-		return size;
-	}
-	void setStart(LinkedElement<T>* firstElement) {
-		start = firstElement;
-	}
+    size_t getSize() const {
+        size_t size = 0;
+        LinkedElement<T> *element = start;
+        while (element != nullptr) {
+            size++;
+            element = element->getNext();
+        }
+        return size;
+    }
+    void setStart(LinkedElement<T>* firstElement) {
+        start = firstElement;
+    }
 
-	void setNext(LinkedElement<T>* currentElement,
-	        LinkedElement<T>* nextElement) {
-	    currentElement->setNext(nextElement);
-	}
+    void setNext(LinkedElement<T>* currentElement,
+            LinkedElement<T>* nextElement) {
+        currentElement->setNext(nextElement);
+    }
 
     void setLast(LinkedElement<T>* lastElement) {
         lastElement->setEnd();
@@ -148,7 +148,7 @@ public:
     }
 
 protected:
-	LinkedElement<T> *start = nullptr;
+    LinkedElement<T> *start = nullptr;
 };
 
 #endif /* SINGLYLINKEDLIST_H_ */
diff --git a/controller/CMakeLists.txt b/controller/CMakeLists.txt
index 6f6607388..b7624d989 100644
--- a/controller/CMakeLists.txt
+++ b/controller/CMakeLists.txt
@@ -1,4 +1,4 @@
 target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		ControllerBase.cpp
+    PRIVATE 
+        ControllerBase.cpp
 )
\ No newline at end of file
diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 2a4024680..89f0ff681 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -5,128 +5,128 @@
 #include "../action/HasActionsIF.h"
 
 ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
-		size_t commandQueueDepth) :
-		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
-		submode(SUBMODE_NONE), modeHelper(this),
-		healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(
-	        commandQueueDepth);
+        size_t commandQueueDepth) :
+        SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
+        submode(SUBMODE_NONE), modeHelper(this),
+        healthHelper(this, setObjectId) {
+    commandQueue = QueueFactory::instance()->createMessageQueue(
+            commandQueueDepth);
 }
 
 ControllerBase::~ControllerBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+    QueueFactory::instance()->deleteMessageQueue(commandQueue);
 }
 
 ReturnValue_t ControllerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
+    ReturnValue_t result = SystemObject::initialize();
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	MessageQueueId_t parentQueue = 0;
-	if (parentId != objects::NO_OBJECT) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == nullptr) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
+    MessageQueueId_t parentQueue = 0;
+    if (parentId != objects::NO_OBJECT) {
+        SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+        if (parent == nullptr) {
+            return RETURN_FAILED;
+        }
+        parentQueue = parent->getCommandQueue();
 
-		parent->registerChild(getObjectId());
-	}
+        parent->registerChild(getObjectId());
+    }
 
-	result = healthHelper.initialize(parentQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
+    result = healthHelper.initialize(parentQueue);
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	result = modeHelper.initialize(parentQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
+    result = modeHelper.initialize(parentQueue);
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	return RETURN_OK;
+    return RETURN_OK;
 }
 
 MessageQueueId_t ControllerBase::getCommandQueue() const {
-	return commandQueue->getId();
+    return commandQueue->getId();
 }
 
 void ControllerBase::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	for (result = commandQueue->receiveMessage(&command);
-	        result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
+    CommandMessage command;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    for (result = commandQueue->receiveMessage(&command);
+            result == RETURN_OK;
+            result = commandQueue->receiveMessage(&command)) {
 
-		result = modeHelper.handleModeCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
+        result = modeHelper.handleModeCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
 
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-		result = handleCommandMessage(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
+        result = healthHelper.handleHealthCommand(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+        result = handleCommandMessage(&command);
+        if (result == RETURN_OK) {
+            continue;
+        }
+        command.setToUnknownCommand();
+        commandQueue->reply(&command);
+    }
 
 }
 
 void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
-	changeHK(this->mode, this->submode, false);
-	triggerEvent(CHANGING_MODE, mode, submode);
-	this->mode = mode;
-	this->submode = submode;
-	modeHelper.modeChanged(mode, submode);
-	modeChanged(mode, submode);
-	announceMode(false);
-	changeHK(this->mode, this->submode, true);
+    changeHK(this->mode, this->submode, false);
+    triggerEvent(CHANGING_MODE, mode, submode);
+    this->mode = mode;
+    this->submode = submode;
+    modeHelper.modeChanged(mode, submode);
+    modeChanged(mode, submode);
+    announceMode(false);
+    changeHK(this->mode, this->submode, true);
 }
 
 void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
+    *mode = this->mode;
+    *submode = this->submode;
 }
 
 void ControllerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
+    healthHelper.setHealth(EXTERNAL_CONTROL);
 }
 
 void ControllerBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
+    triggerEvent(MODE_INFO, mode, submode);
 }
 
 ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
-	handleQueue();
-	performControlOperation();
-	return RETURN_OK;
+    handleQueue();
+    performControlOperation();
+    return RETURN_OK;
 }
 
 void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
-	return;
+    return;
 }
 
 ReturnValue_t ControllerBase::setHealth(HealthState health) {
-	switch (health) {
-	case HEALTHY:
-	case EXTERNAL_CONTROL:
-		healthHelper.setHealth(health);
-		return RETURN_OK;
-	default:
-		return INVALID_HEALTH_STATE;
-	}
+    switch (health) {
+    case HEALTHY:
+    case EXTERNAL_CONTROL:
+        healthHelper.setHealth(health);
+        return RETURN_OK;
+    default:
+        return INVALID_HEALTH_STATE;
+    }
 }
 
 HasHealthIF::HealthState ControllerBase::getHealth() {
-	return healthHelper.getHealth();
+    return healthHelper.getHealth();
 }
 void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
-			executingTask = task_;
+            executingTask = task_;
 }
 
 void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 6e83fe80b..f583342fe 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -17,39 +17,39 @@
  * a mode and a health state. This avoids boilerplate code.
  */
 class ControllerBase: public HasModesIF,
-		public HasHealthIF,
-		public ExecutableObjectIF,
-		public SystemObject,
-		public HasReturnvaluesIF {
+        public HasHealthIF,
+        public ExecutableObjectIF,
+        public SystemObject,
+        public HasReturnvaluesIF {
 public:
-	static const Mode_t MODE_NORMAL = 2;
+    static const Mode_t MODE_NORMAL = 2;
 
-	ControllerBase(object_id_t setObjectId, object_id_t parentId,
-			size_t commandQueueDepth = 3);
-	virtual ~ControllerBase();
+    ControllerBase(object_id_t setObjectId, object_id_t parentId,
+            size_t commandQueueDepth = 3);
+    virtual ~ControllerBase();
 
-	/** SystemObject override */
-	virtual ReturnValue_t initialize() override;
+    /** SystemObject override */
+    virtual ReturnValue_t initialize() override;
 
-	virtual MessageQueueId_t getCommandQueue() const override;
+    virtual MessageQueueId_t getCommandQueue() const override;
 
-	/** HasHealthIF overrides */
-	virtual ReturnValue_t setHealth(HealthState health) override;
-	virtual HasHealthIF::HealthState getHealth() override;
+    /** HasHealthIF overrides */
+    virtual ReturnValue_t setHealth(HealthState health) override;
+    virtual HasHealthIF::HealthState getHealth() override;
 
-	/** ExecutableObjectIF overrides */
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-	virtual void setTaskIF(PeriodicTaskIF* task) override;
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
+    /** ExecutableObjectIF overrides */
+    virtual ReturnValue_t performOperation(uint8_t opCode) override;
+    virtual void setTaskIF(PeriodicTaskIF* task) override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
 
 protected:
 
-	/**
-	 * Implemented by child class. Handle command messages which are not
-	 * mode or health messages.
-	 * @param message
-	 * @return
-	 */
+    /**
+     * Implemented by child class. Handle command messages which are not
+     * mode or health messages.
+     * @param message
+     * @return
+     */
     virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
 
     /**
@@ -60,35 +60,35 @@ protected:
     virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
             uint32_t *msToReachTheMode) = 0;
 
-	const object_id_t parentId;
+    const object_id_t parentId;
 
-	Mode_t mode;
+    Mode_t mode;
 
-	Submode_t submode;
+    Submode_t submode;
 
-	MessageQueueIF* commandQueue = nullptr;
+    MessageQueueIF* commandQueue = nullptr;
 
-	ModeHelper modeHelper;
+    ModeHelper modeHelper;
 
-	HealthHelper healthHelper;
+    HealthHelper healthHelper;
 
-	/**
-	 * Pointer to the task which executes this component,
-	 * is invalid before setTaskIF was called.
-	 */
-	PeriodicTaskIF* executingTask = nullptr;
+    /**
+     * Pointer to the task which executes this component,
+     * is invalid before setTaskIF was called.
+     */
+    PeriodicTaskIF* executingTask = nullptr;
 
-	/** Handle mode and health messages */
-	virtual void handleQueue();
+    /** Handle mode and health messages */
+    virtual void handleQueue();
 
-	/** Mode helpers */
-	virtual void modeChanged(Mode_t mode, Submode_t submode);
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-	virtual void setToExternalControl();
-	virtual void announceMode(bool recursive);
-	/** HK helpers */
-	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
+    /** Mode helpers */
+    virtual void modeChanged(Mode_t mode, Submode_t submode);
+    virtual void startTransition(Mode_t mode, Submode_t submode);
+    virtual void getMode(Mode_t *mode, Submode_t *submode);
+    virtual void setToExternalControl();
+    virtual void announceMode(bool recursive);
+    /** HK helpers */
+    virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 };
 
 #endif /* FSFW_CONTROLLER_CONTROLLERBASE_H_ */

From 9266c874c15073b175ceb8958d75eff3758539da Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 28 Jan 2021 11:57:38 +0100
Subject: [PATCH 1541/1774] applied on cmakelists as well

---
 action/CMakeLists.txt | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/action/CMakeLists.txt b/action/CMakeLists.txt
index a62d4044b..f9ac451df 100644
--- a/action/CMakeLists.txt
+++ b/action/CMakeLists.txt
@@ -1,7 +1,7 @@
 target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		ActionHelper.cpp
-		ActionMessage.cpp
-		CommandActionHelper.cpp
-		SimpleActionHelper.cpp
+    PRIVATE 
+        ActionHelper.cpp
+        ActionMessage.cpp
+        CommandActionHelper.cpp
+        SimpleActionHelper.cpp
 )
\ No newline at end of file

From 7f47a10cbd422be23b62715ddbc930d2b08f212e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 28 Jan 2021 11:58:18 +0100
Subject: [PATCH 1542/1774] applied to cmakelists file

---
 container/CMakeLists.txt | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/container/CMakeLists.txt b/container/CMakeLists.txt
index 904cde55b..13eced1d0 100644
--- a/container/CMakeLists.txt
+++ b/container/CMakeLists.txt
@@ -1,5 +1,5 @@
 target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		SharedRingBuffer.cpp
-		SimpleRingBuffer.cpp
+    PRIVATE 
+        SharedRingBuffer.cpp
+        SimpleRingBuffer.cpp
 )
\ No newline at end of file

From 6b4bed8ca93614021da471437e8350cb2170369a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 29 Jan 2021 00:12:40 +0100
Subject: [PATCH 1543/1774] imrpoved windows includes

---
 osal/Endiness.h            | 3 ++-
 osal/host/Clock.cpp        | 2 +-
 osal/host/PeriodicTask.cpp | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/osal/Endiness.h b/osal/Endiness.h
index 9d3fdef0f..281b715b9 100644
--- a/osal/Endiness.h
+++ b/osal/Endiness.h
@@ -25,7 +25,8 @@
 #else
 
 #ifdef WIN32
-#include <Windows.h>
+#include <winsock2.h>
+#include <windows.h>
 #if REG_DWORD == REG_DWORD_LITTLE_ENDIAN
 #define BYTE_ORDER_SYSTEM LITTLE_ENDIAN
 #else
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 0b3063490..771474c7c 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -3,7 +3,7 @@
 
 #include <chrono>
 #if defined(WIN32)
-#include <windows.h>
+#include <sysinfoapi.h>
 #elif defined(LINUX)
 #include <fstream>
 #endif
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 1f4275464..7663d522d 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -9,7 +9,7 @@
 #include <chrono>
 
 #if defined(WIN32)
-#include <windows.h>
+#include <processthreadsapi.h>
 #elif defined(LINUX)
 #include <pthread.h>
 #endif

From bc722b5583b3a0b9b2ec517d1289081344927088 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 29 Jan 2021 02:35:08 +0100
Subject: [PATCH 1544/1774] clock and dhb update

---
 devicehandlers/DeviceHandlerBase.cpp | 16 ++++-----
 osal/host/Clock.cpp                  | 52 +++++++++++++---------------
 2 files changed, 32 insertions(+), 36 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ed5c1fa75..b0fdb310d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1286,18 +1286,17 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
 }
 
 void DeviceHandlerBase::buildInternalCommand(void) {
-//Neither Raw nor Direct could build a command
+    /* Neither raw nor direct could build a command */
 	ReturnValue_t result = NOTHING_TO_SEND;
 	DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
 	if (mode == MODE_NORMAL) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
-		    // so we can track misconfigurations
-			printWarningOrError(sif::OutputTypes::OUT_WARNING,
-					"buildInternalCommand",
-					HasReturnvaluesIF::RETURN_FAILED,
-					"Busy.");
-			result = NOTHING_TO_SEND; //no need to report this
+		    /* So we can track misconfigurations */
+			printWarningOrError(sif::OutputTypes::OUT_WARNING, "buildInternalCommand",
+					HasReturnvaluesIF::RETURN_FAILED, "Busy.");
+			/* No need to report this */
+			result = NOTHING_TO_SEND;
 		}
 	}
 	else if (mode == MODE_RAW) {
@@ -1319,7 +1318,8 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 				deviceCommandId);
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
-		} else if (iter->second.isExecuting) {
+		}
+		else if (iter->second.isExecuting) {
 #if FSFW_DISABLE_PRINTOUT == 0
 			char output[36];
 			sprintf(output, "Command 0x%08x is executing",
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 771474c7c..f0543c790 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -15,35 +15,34 @@ using SystemClock = std::chrono::system_clock;
 
 uint32_t Clock::getTicksPerSecond(void){
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << "Clock::getTicksPerSecond: not implemented yet" << std::endl;
+	sif::warning << "Clock::getTicksPerSecond: Not implemented for host OSAL" << std::endl;
+#else
+	sif::printWarning("Clock::getTicksPerSecond: Not implemented for host OSAL\n");
 #endif
-	return 0;
-	//return CLOCKS_PER_SEC;
-	//uint32_t ticks = sysconf(_SC_CLK_TCK);
-	//return ticks;
+	/* To avoid division by zero */
+	return 1;
 }
 
 ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-	// do some magic with chrono
+	/* I don't know why someone would need to set a clock which is probably perfectly fine on a
+	host system with internet access so this is not implemented for now. */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << "Clock::setClock: not implemented yet" << std::endl;
+    sif::warning << "Clock::setClock: Not implemented for host OSAL" << std::endl;
+#else
+    sif::printWarning("Clock::setClock: Not implemented for host OSAL\n");
 #endif
 	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
+    /* I don't know why someone would need to set a clock which is probably perfectly fine on a
+    host system with internet access so this is not implemented for now. */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+    sif::warning << "Clock::setClock: Not implemented for host OSAL" << std::endl;
+#else
+    sif::printWarning("Clock::setClock: Not implemented for host OSAL\n");
 #endif
-	return HasReturnvaluesIF::RETURN_FAILED;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getClock_timeval(timeval* time) {
@@ -76,10 +75,11 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 }
 
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	// do some magic with chrono
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << "Clock::gerClock_usecs: not implemented yet" << std::endl;
-#endif
+    if(time == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    using namespace std::chrono;
+    *time = duration_cast<microseconds>(system_clock::now().time_since_epoch()).count();
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -121,9 +121,9 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 
 
 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.
+	/* Do some magic with chrono (C++20!) */
+	/* Right now, the library doesn't have the new features to get the required values 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;
@@ -138,10 +138,6 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 	time->second = timeInfo->tm_sec;
 	auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
 	time->usecond = usecond.count();
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	//sif::warning << "Clock::getDateAndTime: not implemented yet" << std::endl;
-#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 

From 484f9b6b37c531e8a64a9767d9324f42d57475af Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 29 Jan 2021 17:16:34 +0100
Subject: [PATCH 1545/1774] some tweaks

---
 pus/Service17Test.cpp       |  2 +-
 tmtcservices/TmTcBridge.cpp | 18 +++++++++++-------
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/pus/Service17Test.cpp b/pus/Service17Test.cpp
index 2ef44490d..85a32e1e5 100644
--- a/pus/Service17Test.cpp
+++ b/pus/Service17Test.cpp
@@ -15,7 +15,7 @@ Service17Test::~Service17Test() {
 }
 
 ReturnValue_t Service17Test::handleRequest(uint8_t subservice) {
-	switch(subservice){
+	switch(subservice) {
 	case Subservice::CONNECTION_TEST: {
 		TmPacketStored connectionPacket(apid, serviceId,
 		        Subservice::CONNECTION_TEST_REPORT, packetSubCounter++);
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 2513071a5..12d163d16 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -1,7 +1,7 @@
 #include "TmTcBridge.h"
 
 #include "../ipc/QueueFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../globalfunctions/arrayprinter.h"
 
 TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
@@ -109,9 +109,8 @@ ReturnValue_t TmTcBridge::handleTm() {
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TmTcBridge::handleTm: Error handling TM queue with "
-		       << "error code 0x" << std::hex << result  << std::dec
-			   << "!" << std::endl;
+		sif::error << "TmTcBridge::handleTm: Error handling TM queue with error code 0x" <<
+		        std::hex << result  << std::dec << "!" << std::endl;
 #endif
 		status = result;
 	}
@@ -121,8 +120,7 @@ ReturnValue_t TmTcBridge::handleTm() {
 	    result = handleStoredTm();
 	    if(result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	        sif::error << "TmTcBridge::handleTm: Error handling stored TMs!"
-	                << std::endl;
+	        sif::error << "TmTcBridge::handleTm: Error handling stored TMs!" << std::endl;
 #endif
 	        status = result;
 	    }
@@ -140,9 +138,15 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 		 result == HasReturnvaluesIF::RETURN_OK;
 		 result = tmTcReceptionQueue->receiveMessage(&message))
 	{
+
+#if FSFW_VERBOSE_LEVEL >= 3
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	    //sif::info << (int) packetSentCounter << std::endl;
+	    sif::info << "Sent packet counter: " << static_cast<int>(packetSentCounter) << std::endl;
+#else
+	    sif::printInfo("Sent packet counter: %d\n", packetSentCounter);
 #endif
+#endif /* FSFW_VERBOSE_LEVEL >= 3 */
+
 		if(communicationLinkUp == false or
 		        packetSentCounter >= sentPacketsPerCycle) {
 			storeDownlinkData(&message);

From e65990feffc379a0b7e466a7674b6c44cb476c87 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 29 Jan 2021 22:28:38 +0100
Subject: [PATCH 1546/1774] getParameters: uint16_t -> uint8_t for unique
 identfiier

---
 parameters/HasParametersIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 19c12d81f..4bdd2e1b2 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -75,7 +75,7 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t getParameter(uint8_t domainId,
-	        uint16_t uniqueIdentifier, ParameterWrapper *parameterWrapper,
+	        uint8_t uniqueIdentifier, ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
 };
 

From 7f0db5b47cf9ff4dd78fbb267855cb112ab106c5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 29 Jan 2021 22:45:53 +0100
Subject: [PATCH 1547/1774] type and name change for HasParametersIF

---
 devicehandlers/DeviceHandlerBase.cpp             |  6 +++---
 devicehandlers/DeviceHandlerBase.h               |  2 +-
 devicehandlers/DeviceHandlerFailureIsolation.cpp | 12 ++++++------
 devicehandlers/DeviceHandlerFailureIsolation.h   |  6 +++---
 fdir/FaultCounter.cpp                            |  4 ++--
 fdir/FaultCounter.h                              |  2 +-
 monitoring/LimitMonitor.h                        | 10 +++++-----
 monitoring/MonitorReporter.h                     |  8 ++++----
 monitoring/TriplexMonitor.h                      |  8 ++++----
 parameters/HasParametersIF.h                     | 11 +++++------
 power/Fuse.cpp                                   |  6 +++---
 power/Fuse.h                                     |  6 +++---
 power/PowerComponent.cpp                         |  8 ++++----
 power/PowerComponent.h                           |  6 +++---
 power/PowerSensor.cpp                            |  6 +++---
 power/PowerSensor.h                              |  2 +-
 thermal/Heater.cpp                               |  6 +++---
 thermal/Heater.h                                 |  4 ++--
 thermal/TemperatureSensor.h                      |  6 +++---
 thermal/ThermalComponent.cpp                     |  6 +++---
 thermal/ThermalComponent.h                       |  2 +-
 thermal/ThermalComponentCore.cpp                 |  6 +++---
 thermal/ThermalComponentCore.h                   |  2 +-
 23 files changed, 67 insertions(+), 68 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index b0fdb310d..897d0595b 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1380,10 +1380,10 @@ void DeviceHandlerBase::doOffActivity() {
 }
 
 ReturnValue_t DeviceHandlerBase::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		uint8_t uniqueId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = fdirInstance->getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
+	ReturnValue_t result = fdirInstance->getParameter(domainId, uniqueId, parameterWrapper,
+	        newValues, startAtIndex);
 	if (result != INVALID_DOMAIN_ID) {
 		return result;
 	}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 92dc9201a..e75d2729d 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -216,7 +216,7 @@ public:
     virtual void getMode(Mode_t *mode, Submode_t *submode);
     HealthState getHealth();
     ReturnValue_t setHealth(HealthState health);
-    virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+    virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
             ParameterWrapper *parameterWrapper,
             const ParameterWrapper *newValues, uint16_t startAtIndex) override;
 
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 5f7ab89f6..ba118090b 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -209,20 +209,20 @@ void DeviceHandlerFailureIsolation::startRecovery(Event reason) {
 }
 
 ReturnValue_t DeviceHandlerFailureIsolation::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		uint8_t uniqueId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = strangeReplyCount.getParameter(domainId, parameterId,
+	ReturnValue_t result = strangeReplyCount.getParameter(domainId, uniqueId,
 			parameterWrapper, newValues, startAtIndex);
 	if (result != INVALID_DOMAIN_ID) {
 		return result;
 	}
-	result = missedReplyCount.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
+	result = missedReplyCount.getParameter(domainId, uniqueId, parameterWrapper, newValues,
+	        startAtIndex);
 	if (result != INVALID_DOMAIN_ID) {
 		return result;
 	}
-	result = recoveryCounter.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
+	result = recoveryCounter.getParameter(domainId, uniqueId, parameterWrapper, newValues,
+	        startAtIndex);
 	if (result != INVALID_DOMAIN_ID) {
 		return result;
 	}
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.h b/devicehandlers/DeviceHandlerFailureIsolation.h
index 8a3fd9dd9..016b18b3a 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.h
+++ b/devicehandlers/DeviceHandlerFailureIsolation.h
@@ -17,9 +17,9 @@ public:
 	ReturnValue_t initialize();
 	void triggerEvent(Event event, uint32_t parameter1 = 0,
 			uint32_t parameter2 = 0);bool isFdirActionInProgress();
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
+			ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+			uint16_t startAtIndex);
 
 protected:
 	FaultCounter strangeReplyCount;
diff --git a/fdir/FaultCounter.cpp b/fdir/FaultCounter.cpp
index 6519a3a88..53c1dd7de 100644
--- a/fdir/FaultCounter.cpp
+++ b/fdir/FaultCounter.cpp
@@ -58,14 +58,14 @@ FaultCounter::FaultCounter() :
 		parameterDomain(0), timer(), faultCount(0), failureThreshold(0) {
 }
 
-ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
+ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint8_t uniqueId,
 		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
 		uint16_t startAtIndex) {
 	if (domainId != parameterDomain) {
 		return INVALID_DOMAIN_ID;
 	}
 
-	switch (parameterId) {
+	switch (uniqueId) {
 	case 0:
 		parameterWrapper->set(failureThreshold);
 		break;
diff --git a/fdir/FaultCounter.h b/fdir/FaultCounter.h
index dc929debd..e0670c4b3 100644
--- a/fdir/FaultCounter.h
+++ b/fdir/FaultCounter.h
@@ -23,7 +23,7 @@ public:
 	void setFailureThreshold(uint32_t failureThreshold);
 	void setFaultDecrementTimeMs(uint32_t timeMs);
 
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex);
 
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index c4448ceda..cd8b8d130 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -37,16 +37,16 @@ public:
 		}
 	}
 
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
+			ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+			uint16_t startAtIndex) {
 		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
-				parameterId, parameterWrapper, newValues, startAtIndex);
+				uniqueId, parameterWrapper, newValues, startAtIndex);
 		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
 		if (result != this->INVALID_IDENTIFIER_ID) {
 			return result;
 		}
-		switch (parameterId) {
+		switch (uniqueId) {
 		case 10:
 			parameterWrapper->set(this->lowerLimit);
 			break;
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 7ce110e57..d155594d6 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -51,13 +51,13 @@ public:
 		return state;
 	}
 
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
+			ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+			uint16_t startAtIndex) {
 		if (domainId != monitorId) {
 			return INVALID_DOMAIN_ID;
 		}
-		switch (parameterId) {
+		switch (uniqueId) {
 		case 0:
 			parameterWrapper->set(this->confirmationLimit);
 			break;
diff --git a/monitoring/TriplexMonitor.h b/monitoring/TriplexMonitor.h
index c4b3c5375..d9ee83053 100644
--- a/monitoring/TriplexMonitor.h
+++ b/monitoring/TriplexMonitor.h
@@ -71,13 +71,13 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex) {
+	ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
+				ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+				uint16_t startAtIndex) {
 		if (domainId != this->domainId) {
 			return INVALID_DOMAIN_ID;
 		}
-		switch (parameterId) {
+		switch (uniqueId) {
 		case 0:
 			parameterWrapper->set(limit);
 			break;
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 4bdd2e1b2..84790be66 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -52,9 +52,8 @@ public:
 		return id;
 	}
 
-	static uint32_t getFullParameterId(uint8_t domainId,
-	        uint8_t uniqueIdentifier, uint16_t linearIndex) {
-		return (domainId << 24) + (uniqueIdentifier << 16) + linearIndex;
+	static uint32_t getFullParameterId(uint8_t domainId, uint8_t uniqueId, uint16_t linearIndex) {
+		return (domainId << 24) + (uniqueId << 16) + linearIndex;
 	}
 
 	virtual ~HasParametersIF() {}
@@ -74,9 +73,9 @@ public:
 	 * matrix indexes.
 	 * @return
 	 */
-	virtual ReturnValue_t getParameter(uint8_t domainId,
-	        uint8_t uniqueIdentifier, ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
+	        ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+	        uint16_t startAtIndex) = 0;
 };
 
 #endif /* FSFW_PARAMETERS_HASPARAMETERSIF_H_ */
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index b6e0a7f16..91da5388c 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -210,15 +210,15 @@ void Fuse::setDataPoolEntriesInvalid() {
 	set.commit();
 }
 
-ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
+ReturnValue_t Fuse::getParameter(uint8_t domainId, uint8_t uniqueId,
 		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
 		uint16_t startAtIndex) {
-	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
+	ReturnValue_t result = currentLimit.getParameter(domainId, uniqueId,
 			parameterWrapper, newValues, startAtIndex);
 	if (result != INVALID_DOMAIN_ID) {
 		return result;
 	}
-	result = powerMonitor.getParameter(domainId, parameterId, parameterWrapper,
+	result = powerMonitor.getParameter(domainId, uniqueId, parameterWrapper,
 			newValues, startAtIndex);
 	return result;
 }
diff --git a/power/Fuse.h b/power/Fuse.h
index b892611bc..1dc387212 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -62,9 +62,9 @@ public:
 	ReturnValue_t setHealth(HealthState health);
 	HasHealthIF::HealthState getHealth();
 
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
+	ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
+	        ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+			uint16_t startAtIndex);
 
 private:
 	uint8_t oldFuseState;
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index c31b9a85e..04f8658ea 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -61,13 +61,13 @@ ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
 	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
 }
 
-ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+ReturnValue_t PowerComponent::getParameter(uint8_t domainId, uint8_t uniqueId,
+        ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+        uint16_t startAtIndex) {
 	if (domainId != moduleId) {
 		return INVALID_DOMAIN_ID;
 	}
-	switch (parameterId) {
+	switch (uniqueId) {
 	case 0:
 		parameterWrapper->set<>(min);
 		break;
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index c1add3b91..659b68530 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -31,9 +31,9 @@ public:
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			Endianness streamEndianness) override;
 
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex);
+	ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
+	        ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+	        uint16_t startAtIndex);
 private:
 	const object_id_t deviceObjectId = objects::NO_OBJECT;
 	const uint8_t switchId1;
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index fb181d9f9..40d7afc61 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -119,15 +119,15 @@ HasHealthIF::HealthState PowerSensor::getHealth() {
 	return healthHelper.getHealth();
 }
 
-ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint16_t parameterId,
+ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint8_t uniqueId,
 		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
 		uint16_t startAtIndex) {
-	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
+	ReturnValue_t result = currentLimit.getParameter(domainId, uniqueId,
 			parameterWrapper, newValues, startAtIndex);
 	if (result != INVALID_DOMAIN_ID) {
 		return result;
 	}
-	result = voltageLimit.getParameter(domainId, parameterId, parameterWrapper,
+	result = voltageLimit.getParameter(domainId, uniqueId, parameterWrapper,
 			newValues, startAtIndex);
 	return result;
 }
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index a0ccb1ca7..5a21ab104 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -48,7 +48,7 @@ public:
 	float getPower();
 	ReturnValue_t setHealth(HealthState health);
 	HasHealthIF::HealthState getHealth();
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+	ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex);
 private:
diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index ce965d5ea..782ce2963 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -290,13 +290,13 @@ void Heater::handleQueue() {
 	}
 }
 
-ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+ReturnValue_t Heater::getParameter(uint8_t domainId, uint8_t uniqueId,
+        ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
 		uint16_t startAtIndex) {
 	if (domainId != DOMAIN_ID_BASE) {
 		return INVALID_DOMAIN_ID;
 	}
-	switch (parameterId) {
+	switch (uniqueId) {
 	case 0:
 		parameterWrapper->set(heaterOnCountdown.timeout);
 		break;
diff --git a/thermal/Heater.h b/thermal/Heater.h
index b034dfee5..f83957a2e 100644
--- a/thermal/Heater.h
+++ b/thermal/Heater.h
@@ -34,8 +34,8 @@ public:
 
 	MessageQueueId_t getCommandQueue() const;
 
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
+	ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
+	        ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex);
 
 protected:
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index f41b3761b..2b1fb1f07 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -183,10 +183,10 @@ public:
 
 	static const uint8_t DOMAIN_ID_SENSOR = 1;
 
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
+		ReturnValue_t result = sensorMonitor.getParameter(domainId, uniqueId,
 				parameterWrapper, newValues, startAtIndex);
 		if (result != INVALID_DOMAIN_ID) {
 			return result;
@@ -194,7 +194,7 @@ public:
 		if (domainId != this->DOMAIN_ID_BASE) {
 			return INVALID_DOMAIN_ID;
 		}
-		switch (parameterId) {
+		switch (uniqueId) {
 		case ADDRESS_A:
 			parameterWrapper->set(parameters.a);
 			break;
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 084201dd4..d42c34b33 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -148,14 +148,14 @@ ThermalComponentIF::State ThermalComponent::getIgnoredState(int8_t state) {
 }
 
 ReturnValue_t ThermalComponent::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		uint8_t uniqueId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = ThermalComponentCore::getParameter(domainId, parameterId,
+	ReturnValue_t result = ThermalComponentCore::getParameter(domainId, uniqueId,
 			parameterWrapper, newValues, startAtIndex);
 	if (result != INVALID_IDENTIFIER_ID) {
 		return result;
 	}
-	switch (parameterId) {
+	switch (uniqueId) {
 	case 12:
 		parameterWrapper->set(nopParameters.lowerNopLimit);
 		break;
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 0785a9141..3b6dd9cdd 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -58,7 +58,7 @@ public:
 
 	virtual ReturnValue_t setLimits( const uint8_t* data, size_t size);
 
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
 				ParameterWrapper *parameterWrapper,
 				const ParameterWrapper *newValues, uint16_t startAtIndex);
 
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index ba8750532..7df04b047 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -247,17 +247,17 @@ ThermalComponentCore::Parameters ThermalComponentCore::getParameters() {
 }
 
 ReturnValue_t ThermalComponentCore::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		uint8_t uniqueId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
 	ReturnValue_t result = temperatureMonitor.getParameter(domainId,
-			parameterId, parameterWrapper, newValues, startAtIndex);
+			uniqueId, parameterWrapper, newValues, startAtIndex);
 	if (result != INVALID_DOMAIN_ID) {
 		return result;
 	}
 	if (domainId != this->domainId) {
 		return INVALID_DOMAIN_ID;
 	}
-	switch (parameterId) {
+	switch (uniqueId) {
 	case 0:
 		parameterWrapper->set(parameters.heaterOn);
 		break;
diff --git a/thermal/ThermalComponentCore.h b/thermal/ThermalComponentCore.h
index da9424e68..a1fa594a5 100644
--- a/thermal/ThermalComponentCore.h
+++ b/thermal/ThermalComponentCore.h
@@ -68,7 +68,7 @@ public:
 
 	virtual void setOutputInvalid();
 
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex);
 

From cf945d4d34fc7cd99c17138d788ef1dc153e5b30 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 30 Jan 2021 20:29:23 +0100
Subject: [PATCH 1548/1774] added srv20 written by J. Gerhards

---
 objectmanager/frameworkObjects.h      |   1 +
 pus/CMakeLists.txt                    |  22 ++--
 pus/Service20ParameterManagement.cpp  | 181 ++++++++++++++++++++++++++
 pus/Service20ParameterManagement.h    |  58 +++++++++
 pus/servicepackets/Service20Packets.h |  91 +++++++++++++
 5 files changed, 342 insertions(+), 11 deletions(-)
 create mode 100644 pus/Service20ParameterManagement.cpp
 create mode 100644 pus/Service20ParameterManagement.h
 create mode 100644 pus/servicepackets/Service20Packets.h

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index a138b07ea..2174f829a 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -14,6 +14,7 @@ enum framework_objects: object_id_t {
     PUS_SERVICE_8_FUNCTION_MGMT = 0x53000008,
     PUS_SERVICE_9_TIME_MGMT = 0x53000009,
     PUS_SERVICE_17_TEST = 0x53000017,
+    PUS_SERVICE_20_PARAMETERS = 0x53000020,
     PUS_SERVICE_200_MODE_MGMT = 0x53000200,
 
     //Generic IDs for IPC, modes, health, events
diff --git a/pus/CMakeLists.txt b/pus/CMakeLists.txt
index c0e004481..8b55adf03 100644
--- a/pus/CMakeLists.txt
+++ b/pus/CMakeLists.txt
@@ -1,12 +1,12 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		CService200ModeCommanding.cpp
-		CService201HealthCommanding.cpp
-		Service17Test.cpp
-		Service1TelecommandVerification.cpp
-		Service2DeviceAccess.cpp
-		Service3Housekeeping.cpp
-		Service5EventReporting.cpp
-		Service8FunctionManagement.cpp
-		Service9TimeManagement.cpp
+target_sources(${LIB_FSFW_NAME} PRIVATE 
+    Service1TelecommandVerification.cpp
+    Service2DeviceAccess.cpp
+    Service3Housekeeping.cpp
+    Service5EventReporting.cpp
+    Service8FunctionManagement.cpp
+    Service9TimeManagement.cpp
+    Service17Test.cpp
+    Service20ParameterManagement.cpp
+    CService200ModeCommanding.cpp
+    CService201HealthCommanding.cpp
 )
\ No newline at end of file
diff --git a/pus/Service20ParameterManagement.cpp b/pus/Service20ParameterManagement.cpp
new file mode 100644
index 000000000..3b04bd4e0
--- /dev/null
+++ b/pus/Service20ParameterManagement.cpp
@@ -0,0 +1,181 @@
+#include "Service20ParameterManagement.h"
+#include "servicepackets/Service20Packets.h"
+
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/parameters/HasParametersIF.h>
+#include <fsfw/parameters/ParameterMessage.h>
+#include <fsfw/parameters/ReceivesParameterMessagesIF.h>
+#include <tmtc/pusIds.h>
+
+
+Service20ParameterManagement::Service20ParameterManagement(object_id_t objectId, uint16_t apid,
+        uint8_t serviceId, uint8_t numberOfParallelCommands, uint16_t commandTimeoutSeconds) :
+        CommandingServiceBase(objectId, apid, serviceId,
+                numberOfParallelCommands,commandTimeoutSeconds) {}
+
+Service20ParameterManagement::~Service20ParameterManagement() {}
+
+
+ReturnValue_t Service20ParameterManagement::isValidSubservice(
+        uint8_t subservice) {
+    switch(static_cast<Subservice>(subservice)) {
+    case Subservice::PARAMETER_LOAD:
+    case Subservice::PARAMETER_DUMP:
+        return HasReturnvaluesIF::RETURN_OK;
+    default:
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "Invalid Subservice for Service 20" << std::endl;
+#else
+        sif::printError("Invalid Subservice for Service 20\n");
+#endif
+        return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+    }
+}
+
+
+ReturnValue_t Service20ParameterManagement::getMessageQueueAndObject(
+        uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+        MessageQueueId_t* id, object_id_t* objectId) {
+    ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
+    if(result != RETURN_OK) {
+        return result;
+    }
+    return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+
+ReturnValue_t Service20ParameterManagement::checkAndAcquireTargetID(
+        object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) {
+    if(SerializeAdapter::deSerialize(objectIdToSet, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG) != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "Service20ParameterManagement::checkAndAcquireTargetID: "
+                << "Invalid data." << std::endl;
+#else
+        sif::printError("Service20ParameterManagement::"
+                "checkAndAcquireTargetID: Invalid data.\n");
+#endif
+        return CommandingServiceBase::INVALID_TC;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service20ParameterManagement::checkInterfaceAndAcquireMessageQueue(
+        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+    // check ReceivesParameterMessagesIF property of target
+    ReceivesParameterMessagesIF* possibleTarget =
+            objectManager->get<ReceivesParameterMessagesIF>(*objectId);
+    if(possibleTarget == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "Service20ParameterManagement::checkInterfaceAndAcquire"
+                <<"MessageQueue: Can't access object" << std::endl;
+        sif::error << "Object ID: " << std::hex << objectId << std::dec
+                << std::endl;
+        sif::error << "Make sure it implements ReceivesParameterMessagesIF!"
+                << std::endl;
+#else
+        sif::printError("Service20ParameterManagement::checkInterfaceAndAcquire"
+                "MessageQueue: Can't access object\n");
+        sif::printError("Object ID: 0x%08x\n", objectId);
+        sif::printError("Make sure it implements "
+                "ReceivesParameterMessagesIF!\n");
+#endif
+
+        return CommandingServiceBase::INVALID_OBJECT;
+    }
+    *messageQueueToSet = possibleTarget->getCommandQueue();
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service20ParameterManagement::prepareCommand(
+        CommandMessage* message, uint8_t subservice, const uint8_t* tcData,
+        size_t tcDataLen, uint32_t* state, object_id_t objectId) {
+    switch(static_cast<Subservice>(subservice)){
+    case Subservice::PARAMETER_DUMP: {
+        return prepareDumpCommand(message, tcData, tcDataLen);
+    }
+    break;
+    case Subservice::PARAMETER_LOAD: {
+        return prepareLoadCommand(message, tcData, tcDataLen);
+    }
+    break;
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+}
+
+ReturnValue_t Service20ParameterManagement::prepareDumpCommand(
+        CommandMessage* message, const uint8_t* tcData, size_t tcDataLen) {
+    //the first part is the objectId, but we have extracted that earlier
+    //and only need the parameterId
+    tcData += sizeof(object_id_t);
+    tcDataLen -= sizeof(object_id_t);
+    ParameterId_t parameterId;
+    if(SerializeAdapter::deSerialize(&parameterId, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG) != HasReturnvaluesIF::RETURN_OK) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    //Autodeserialize should have decremented size to 0 by this point
+    if(tcDataLen != 0) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+
+    ParameterMessage::setParameterDumpCommand(message, parameterId);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service20ParameterManagement::prepareLoadCommand(
+        CommandMessage* message, const uint8_t* tcData, size_t tcDataLen) {
+    if(tcDataLen < sizeof(object_id_t) + sizeof(ParameterId_t) +
+            sizeof(uint32_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+
+    uint8_t* storePointer = nullptr;
+    store_address_t storeAddress;
+    size_t parameterDataLen = tcDataLen - sizeof(object_id_t) -
+            sizeof(ParameterId_t) - sizeof(uint32_t);
+    ReturnValue_t result = IPCStore->getFreeElement(&storeAddress,
+            parameterDataLen, &storePointer);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    ParameterLoadCommand command(storePointer, parameterDataLen);
+    result = command.deSerialize(&tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    ParameterMessage::setParameterLoadCommand(message,
+            command.getParameterId(), storeAddress, command.getPtc(),
+            command.getPfc(), command.getRows(), command.getColumns());
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service20ParameterManagement::handleReply(
+        const CommandMessage* reply, Command_t previousCommand, uint32_t* state,
+        CommandMessage* optionalNextCommand, object_id_t objectId,
+        bool* isStep) {
+    Command_t replyId = reply->getCommand();
+
+    switch(replyId) {
+    case ParameterMessage::REPLY_PARAMETER_DUMP: {
+        ConstAccessorPair parameterData = IPCStore->getData(
+                ParameterMessage::getStoreId(reply));
+        if(parameterData.first != HasReturnvaluesIF::RETURN_OK) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        ParameterId_t parameterId = ParameterMessage::getParameterId(reply);
+        ParameterDumpReply parameterReply(objectId, parameterId,
+                parameterData.second.data(), parameterData.second.size());
+        sendTmPacket(static_cast<uint8_t>(
+                Subservice::PARAMETER_DUMP_REPLY), &parameterReply);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    default:
+        return CommandingServiceBase::INVALID_REPLY;
+    }
+}
diff --git a/pus/Service20ParameterManagement.h b/pus/Service20ParameterManagement.h
new file mode 100644
index 000000000..3e62bc147
--- /dev/null
+++ b/pus/Service20ParameterManagement.h
@@ -0,0 +1,58 @@
+#ifndef FSFW_PUS_SERVICE20PARAMETERMANAGEMENT_H_
+#define FSFW_PUS_SERVICE20PARAMETERMANAGEMENT_H_
+
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+
+/**
+ * @brief   PUS Service 20 Parameter Service implementation
+ * @details
+ * @author  J. Gerhards
+ *
+ */
+class Service20ParameterManagement : public CommandingServiceBase
+{
+public:
+    Service20ParameterManagement(object_id_t objectId, uint16_t apid, uint8_t serviceId,
+            uint8_t numberOfParallelCommands = 4, uint16_t commandTimeoutSeconds = 60);
+    virtual ~Service20ParameterManagement();
+
+    static constexpr uint8_t NUM_OF_PARALLEL_COMMANDS = 4;
+    static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+protected:
+    /* CommandingServiceBase (CSB) abstract functions. See CSB documentation. */
+    ReturnValue_t isValidSubservice(uint8_t subservice) override;
+    ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+            const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+            object_id_t *objectId) override;
+    ReturnValue_t prepareCommand(CommandMessage* message, uint8_t subservice,
+            const uint8_t *tcData, size_t tcDataLen, uint32_t *state,
+            object_id_t objectId) override;
+    ReturnValue_t handleReply(const CommandMessage* reply,
+            Command_t previousCommand, uint32_t *state,
+            CommandMessage* optionalNextCommand, object_id_t objectId,
+            bool *isStep) override;
+
+private:
+
+    ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+            const uint8_t* tcData, size_t tcDataLen);
+    ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+            MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
+    ReturnValue_t prepareDirectCommand(CommandMessage* message,
+            const uint8_t* tcData, size_t tcDataLen);
+
+    ReturnValue_t prepareDumpCommand(CommandMessage* message,
+            const uint8_t* tcData, size_t tcDataLen);
+    ReturnValue_t prepareLoadCommand(CommandMessage* message,
+            const uint8_t* tcData, size_t tcDataLen);
+
+    enum class Subservice {
+        PARAMETER_LOAD = 128, //!< [EXPORT] : Load a Parameter
+        PARAMETER_DUMP = 129, //!< [EXPORT] : Dump a Parameter
+        PARAMETER_DUMP_REPLY = 130, //!< [EXPORT] : Dump a Parameter
+    };
+
+};
+
+
+#endif /* FSFW_PUS_SERVICE20PARAMETERMANAGEMENT_H_ */
diff --git a/pus/servicepackets/Service20Packets.h b/pus/servicepackets/Service20Packets.h
new file mode 100644
index 000000000..cf65cdbff
--- /dev/null
+++ b/pus/servicepackets/Service20Packets.h
@@ -0,0 +1,91 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE20PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE20PACKETS_H_
+
+#include <fsfw/parameters/HasParametersIF.h>
+#include <fsfw/serialize/SerialBufferAdapter.h>
+#include <fsfw/serialize/SerializeElement.h>
+#include <fsfw/serialize/SerialLinkedListAdapter.h>
+
+/**
+ * @brief
+ * @details
+ * @author
+ */
+class ParameterCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128, 129, 130
+public:
+    ParameterCommand(uint8_t* storePointer, size_t parameterDataLen):
+        parameterBuffer(storePointer, parameterDataLen) {
+        setLinks();
+    }
+
+    ParameterCommand(object_id_t objectId, ParameterId_t parameterId,
+            const uint8_t* parameterBuffer, size_t parameterBufferSize):
+                objectId(objectId), parameterId(parameterId),
+                parameterBuffer(parameterBuffer, parameterBufferSize) {
+        setLinks();
+    }
+
+    ParameterId_t getParameterId() const {
+        return parameterId.entry;
+    }
+
+    const uint8_t* getParameterBuffer() {
+        return parameterBuffer.entry.getConstBuffer();
+    }
+
+    size_t getParameterBufferLen() const {
+        return parameterBuffer.getSerializedSize();
+    }
+
+    uint8_t getPtc() const {
+        return ccsdsType.entry >> 8 & 0xff;
+    }
+
+    uint8_t getPfc() const {
+        return ccsdsType.entry & 0xff;
+    }
+
+    uint8_t getRows() const {
+        return rows.entry;
+    }
+
+    uint8_t getColumns() const {
+        return columns.entry;
+    }
+
+private:
+    void setLinks() {
+        setStart(&objectId);
+        objectId.setNext(&parameterId);
+        parameterId.setNext(&ccsdsType);
+        ccsdsType.setNext(&rows);
+        rows.setNext(&columns);
+        columns.setNext(&parameterBuffer);
+    }
+
+    SerializeElement<object_id_t> objectId = 0;
+    SerializeElement<ParameterId_t> parameterId = 0;
+    //! [EXPORT] : [COMMENT] Type consisting of one byte PTC and one byte PFC.
+    SerializeElement<uint16_t> ccsdsType = 0;
+    SerializeElement<uint8_t> columns = 0;
+    SerializeElement<uint8_t> rows = 0;
+    SerializeElement<SerialBufferAdapter<uint8_t>> parameterBuffer;
+};
+
+class ParameterLoadCommand: public ParameterCommand {
+public:
+    ParameterLoadCommand(uint8_t* parameterPacket, size_t parameterDataLen):
+        ParameterCommand(parameterPacket, parameterDataLen) {
+    }
+};
+
+class ParameterDumpReply: public ParameterCommand {
+public:
+    ParameterDumpReply(object_id_t objectId, ParameterId_t parameterId,
+            const uint8_t* parameterBuffer, size_t parameterBufferSize):
+                ParameterCommand(objectId, parameterId, parameterBuffer,
+                        parameterBufferSize) {
+    }
+};
+
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE20PACKETS_H_ */

From 503de9ba898e2070d1d29a3334ed61623d428c55 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 31 Jan 2021 00:27:47 +0100
Subject: [PATCH 1549/1774] IMPORTant bugfix

---
 parameters/ParameterMessage.cpp      |  2 +-
 pus/Service20ParameterManagement.cpp | 15 ++++++---------
 2 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp
index af1f9ce83..88a45c808 100644
--- a/parameters/ParameterMessage.cpp
+++ b/parameters/ParameterMessage.cpp
@@ -38,7 +38,7 @@ void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
 store_address_t ParameterMessage::getParameterLoadCommand(
         const CommandMessage *message, ParameterId_t* parameterId, uint8_t *ptc,
         uint8_t *pfc, uint8_t *rows, uint8_t *columns) {
-    *parameterId = message->getParameter2();
+    *parameterId = message->getParameter();
     uint32_t packedParamSettings = message->getParameter3();
     *ptc = packedParamSettings >> 24 & 0xff;
     *pfc = packedParamSettings >> 16 & 0xff;
diff --git a/pus/Service20ParameterManagement.cpp b/pus/Service20ParameterManagement.cpp
index 3b04bd4e0..302b69b72 100644
--- a/pus/Service20ParameterManagement.cpp
+++ b/pus/Service20ParameterManagement.cpp
@@ -70,10 +70,8 @@ ReturnValue_t Service20ParameterManagement::checkInterfaceAndAcquireMessageQueue
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "Service20ParameterManagement::checkInterfaceAndAcquire"
                 <<"MessageQueue: Can't access object" << std::endl;
-        sif::error << "Object ID: " << std::hex << objectId << std::dec
-                << std::endl;
-        sif::error << "Make sure it implements ReceivesParameterMessagesIF!"
-                << std::endl;
+        sif::error << "Object ID: " << std::hex << objectId << std::dec << std::endl;
+        sif::error << "Make sure it implements ReceivesParameterMessagesIF!" << std::endl;
 #else
         sif::printError("Service20ParameterManagement::checkInterfaceAndAcquire"
                 "MessageQueue: Can't access object\n");
@@ -134,8 +132,8 @@ ReturnValue_t Service20ParameterManagement::prepareLoadCommand(
 
     uint8_t* storePointer = nullptr;
     store_address_t storeAddress;
-    size_t parameterDataLen = tcDataLen - sizeof(object_id_t) -
-            sizeof(ParameterId_t) - sizeof(uint32_t);
+    size_t parameterDataLen = tcDataLen - sizeof(object_id_t) - sizeof(ParameterId_t) -
+            sizeof(uint32_t);
     ReturnValue_t result = IPCStore->getFreeElement(&storeAddress,
             parameterDataLen, &storePointer);
     if(result != HasReturnvaluesIF::RETURN_OK) {
@@ -149,9 +147,8 @@ ReturnValue_t Service20ParameterManagement::prepareLoadCommand(
         return result;
     }
 
-    ParameterMessage::setParameterLoadCommand(message,
-            command.getParameterId(), storeAddress, command.getPtc(),
-            command.getPfc(), command.getRows(), command.getColumns());
+    ParameterMessage::setParameterLoadCommand(message, command.getParameterId(), storeAddress,
+            command.getPtc(), command.getPfc(), command.getRows(), command.getColumns());
     return HasReturnvaluesIF::RETURN_OK;
 }
 

From f067695353b77ccde7e33f17f0687df6838ce519 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 31 Jan 2021 17:40:20 +0100
Subject: [PATCH 1550/1774] printout, doc, bugfixes..

---
 parameters/ParameterWrapper.cpp      | 36 ++++++++++++++++++++++++----
 parameters/ParameterWrapper.h        | 36 +++++++++++++++++++++++-----
 pus/Service20ParameterManagement.cpp | 13 +++++++---
 pus/Service20ParameterManagement.h   |  2 ++
 4 files changed, 74 insertions(+), 13 deletions(-)

diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index d9f1ef685..124f2eda6 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -1,4 +1,6 @@
 #include "ParameterWrapper.h"
+#include <FSFWConfig.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
 
 ParameterWrapper::ParameterWrapper() :
 		pointsToStream(false), type(Type::UNKNOWN_TYPE) {
@@ -75,7 +77,7 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
 		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
 		break;
 	default:
-		result = UNKNOW_DATATYPE;
+		result = UNKNOWN_DATATYPE;
 		break;
 	}
 	return result;
@@ -220,22 +222,48 @@ ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
 
 ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		uint16_t startWritingAtIndex) {
-    // TODO: Optional diagnostic output (which can be disabled in FSFWConfig)
-    // to determined faulty implementations and configuration errors quickly.
 	if (data == nullptr) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	    sif::warning << "ParameterWrapper::copyFrom: Called on read-only variable!" << std::endl;
+#else
+	    sif::printWarning("ParameterWrapper::copyFrom: Called on read-only variable!\n");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 		return READONLY;
 	}
 
 	if (from->readonlyData == nullptr) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ParameterWrapper::copyFrom: Source not set!" << std::endl;
+#else
+        sif::printWarning("ParameterWrapper::copyFrom: Source not set!\n");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 		return SOURCE_NOT_SET;
 	}
 
 	if (type != from->type) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ParameterWrapper::copyFrom: Datatype missmatch!" << std::endl;
+#else
+        sif::printWarning("ParameterWrapper::copyFrom: Datatype missmatch!\n");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 		return DATATYPE_MISSMATCH;
 	}
 
 	// The smallest allowed value for rows and columns is one.
 	if(rows == 0 or columns == 0) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ParameterWrapper::copyFrom: Columns or rows zero!" << std::endl;
+#else
+        sif::printWarning("ParameterWrapper::copyFrom: Columns or rows zero!\n");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 	    return COLUMN_OR_ROWS_ZERO;
 	}
 
@@ -289,7 +317,7 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 					from->readonlyData, from->rows, from->columns);
 			break;
 		default:
-			result = UNKNOW_DATATYPE;
+			result = UNKNOWN_DATATYPE;
 			break;
 		}
 	}
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 168a535f2..b0ca210d0 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -8,14 +8,23 @@
 #include <cstddef>
 
 /**
- * @brief
+ * @brief       This wrapper encapsulates the access to parameters provided by HasParametersIF.
  * @details
+ * This wrapper is used by the ParameterHelper to interface with the on-board parameters
+ * exposed by the software via the HasParametersIF. A handle of this wrapper is passed
+ * to the user which then can be used to set or dump the parameters.
+ *
+ * The wrapper provides a set of setter functions. The user should call those setter functions,
+ * supplying an address to the local parameters. The user can also deserialize or
+ * serialize the parameter data. Please note that this will also serialize and deserialize
+ * the parameter information field (4 bytes) containing the ECSS PTC, PFC and rows and columns
+ * number.
  */
 class ParameterWrapper: public SerializeIF {
 	friend class DataPoolParameterWrapper;
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::PARAMETER_WRAPPER;
-	static const ReturnValue_t UNKNOW_DATATYPE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t UNKNOWN_DATATYPE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
 	static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
 	static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
@@ -26,8 +35,7 @@ public:
 
 	ParameterWrapper();
 	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
-	ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-			const void *data);
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, const void *data);
 	virtual ~ParameterWrapper();
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
@@ -77,11 +85,23 @@ public:
 		this->pointsToStream = false;
 	}
 
+	/**
+	 * Setter function for scalar non-const entries
+	 * @tparam T
+	 * @param member
+	 */
 	template<typename T>
 	void set(T& member) {
 		this->set(&member, 1, 1);
 	}
 
+	/**
+	 * Setter function for scalar const entries.
+	 * TODO: This is confusing, it should not be called set. Maybe we should call all functions
+	 * assign instead?
+	 * @tparam T
+	 * @param readonlyMember
+	 */
 	template<typename T>
 	void set(const T& readonlyMember) {
 		this->set(&readonlyMember, 1, 1);
@@ -89,12 +109,16 @@ public:
 
 	template<typename T>
 	void setVector(T& member) {
-		this->set(member, sizeof(member)/sizeof(member[0]), 1);
+	    /* For a vector entry, the number of rows will be one
+	    (left to right, top to bottom indexing) */
+		this->set(member, 1, sizeof(member) / sizeof(member[0]));
 	}
 
 	template<typename T>
 	void setVector(const T& member) {
-		this->set(member, 1, sizeof(member)/sizeof(member[0]));
+        /* For a vector entry, the number of rows will be one
+        (left to right, top to bottom indexing) */
+		this->set(member, 1, sizeof(member) / sizeof(member[0]));
 	}
 	template<typename T>
 	void setMatrix(T& member) {
diff --git a/pus/Service20ParameterManagement.cpp b/pus/Service20ParameterManagement.cpp
index 302b69b72..2d69f77a9 100644
--- a/pus/Service20ParameterManagement.cpp
+++ b/pus/Service20ParameterManagement.cpp
@@ -105,8 +105,8 @@ ReturnValue_t Service20ParameterManagement::prepareCommand(
 
 ReturnValue_t Service20ParameterManagement::prepareDumpCommand(
         CommandMessage* message, const uint8_t* tcData, size_t tcDataLen) {
-    //the first part is the objectId, but we have extracted that earlier
-    //and only need the parameterId
+    /* the first part is the objectId, but we have extracted that earlier
+    and only need the parameterId */
     tcData += sizeof(object_id_t);
     tcDataLen -= sizeof(object_id_t);
     ParameterId_t parameterId;
@@ -114,7 +114,7 @@ ReturnValue_t Service20ParameterManagement::prepareDumpCommand(
             SerializeIF::Endianness::BIG) != HasReturnvaluesIF::RETURN_OK) {
         return CommandingServiceBase::INVALID_TC;
     }
-    //Autodeserialize should have decremented size to 0 by this point
+    /* The length should have been decremented to 0 by this point */
     if(tcDataLen != 0) {
         return CommandingServiceBase::INVALID_TC;
     }
@@ -140,6 +140,13 @@ ReturnValue_t Service20ParameterManagement::prepareLoadCommand(
         return result;
     }
 
+    /* Following format is expected: The first 4 bytes in the TC data are the 4 byte
+    parameter ID (ParameterId_t). The second 4 bytes are the parameter information field,
+    containing the following 1 byte fields:
+     1. ECSS PTC field
+     2. ECSS PFC field
+     3. Number of rows
+     4. Number of columns */
     ParameterLoadCommand command(storePointer, parameterDataLen);
     result = command.deSerialize(&tcData, &tcDataLen,
             SerializeIF::Endianness::BIG);
diff --git a/pus/Service20ParameterManagement.h b/pus/Service20ParameterManagement.h
index 3e62bc147..488edfb5c 100644
--- a/pus/Service20ParameterManagement.h
+++ b/pus/Service20ParameterManagement.h
@@ -6,6 +6,8 @@
 /**
  * @brief   PUS Service 20 Parameter Service implementation
  * @details
+ * This service handles PUS service requests related to parameter management and forwards
+ * them to the internal software bus.
  * @author  J. Gerhards
  *
  */

From 8b90360b453aa0e7791654b64890eb78d262a09a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 31 Jan 2021 18:27:21 +0100
Subject: [PATCH 1551/1774] changed order

---
 pus/servicepackets/Service20Packets.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pus/servicepackets/Service20Packets.h b/pus/servicepackets/Service20Packets.h
index cf65cdbff..4a7c24f0c 100644
--- a/pus/servicepackets/Service20Packets.h
+++ b/pus/servicepackets/Service20Packets.h
@@ -67,8 +67,8 @@ private:
     SerializeElement<ParameterId_t> parameterId = 0;
     //! [EXPORT] : [COMMENT] Type consisting of one byte PTC and one byte PFC.
     SerializeElement<uint16_t> ccsdsType = 0;
-    SerializeElement<uint8_t> columns = 0;
     SerializeElement<uint8_t> rows = 0;
+    SerializeElement<uint8_t> columns = 0;
     SerializeElement<SerialBufferAdapter<uint8_t>> parameterBuffer;
 };
 

From 4522668066c7b402a7fcd1e76923b6c322647f3d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 31 Jan 2021 19:13:40 +0100
Subject: [PATCH 1552/1774] some form stuff

---
 pus/servicepackets/Service20Packets.h | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/pus/servicepackets/Service20Packets.h b/pus/servicepackets/Service20Packets.h
index 4a7c24f0c..d108dba44 100644
--- a/pus/servicepackets/Service20Packets.h
+++ b/pus/servicepackets/Service20Packets.h
@@ -75,17 +75,14 @@ private:
 class ParameterLoadCommand: public ParameterCommand {
 public:
     ParameterLoadCommand(uint8_t* parameterPacket, size_t parameterDataLen):
-        ParameterCommand(parameterPacket, parameterDataLen) {
-    }
+            ParameterCommand(parameterPacket, parameterDataLen) {}
 };
 
 class ParameterDumpReply: public ParameterCommand {
 public:
     ParameterDumpReply(object_id_t objectId, ParameterId_t parameterId,
             const uint8_t* parameterBuffer, size_t parameterBufferSize):
-                ParameterCommand(objectId, parameterId, parameterBuffer,
-                        parameterBufferSize) {
-    }
+            ParameterCommand(objectId, parameterId, parameterBuffer, parameterBufferSize) {}
 };
 
 #endif /* FSFW_PUS_SERVICEPACKETS_SERVICE20PACKETS_H_ */

From 5ac3762dc51752ba4538817d8ddd87dc50766ec7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 31 Jan 2021 20:53:25 +0100
Subject: [PATCH 1553/1774] srv20 improvements and bugfixes

---
 parameters/ParameterHelper.cpp        |  2 +-
 parameters/ParameterWrapper.cpp       |  8 ++--
 pus/Service20ParameterManagement.cpp  |  1 +
 pus/servicepackets/Service20Packets.h | 62 +++++++++++++++++++++++++--
 4 files changed, 64 insertions(+), 9 deletions(-)

diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 4ad5cdf25..24d0b2b1f 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -90,7 +90,7 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
         const ParameterWrapper* description) {
     size_t serializedSize = description->getSerializedSize();
 
-    uint8_t *storeElement;
+    uint8_t *storeElement = nullptr;
     store_address_t address;
 
     ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 124f2eda6..660d7db71 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -7,13 +7,13 @@ ParameterWrapper::ParameterWrapper() :
 }
 
 ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-		void *data) :
+		void *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) :
+		const void *data):
 		pointsToStream(false), type(type), rows(rows), columns(columns),
 		data(nullptr), readonlyData(data) {
 }
@@ -42,8 +42,8 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
 		return result;
 	}
 
-	//serialize uses readonlyData, as it is always valid
-	if (readonlyData == NULL) {
+	/* serialize uses readonlyData, as it is always valid */
+	if (readonlyData == nullptr) {
 		return NOT_SET;
 	}
 	switch (type) {
diff --git a/pus/Service20ParameterManagement.cpp b/pus/Service20ParameterManagement.cpp
index 2d69f77a9..bc3a9119b 100644
--- a/pus/Service20ParameterManagement.cpp
+++ b/pus/Service20ParameterManagement.cpp
@@ -172,6 +172,7 @@ ReturnValue_t Service20ParameterManagement::handleReply(
         if(parameterData.first != HasReturnvaluesIF::RETURN_OK) {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
+
         ParameterId_t parameterId = ParameterMessage::getParameterId(reply);
         ParameterDumpReply parameterReply(objectId, parameterId,
                 parameterData.second.data(), parameterData.second.size());
diff --git a/pus/servicepackets/Service20Packets.h b/pus/servicepackets/Service20Packets.h
index d108dba44..33bd153dd 100644
--- a/pus/servicepackets/Service20Packets.h
+++ b/pus/servicepackets/Service20Packets.h
@@ -1,28 +1,57 @@
 #ifndef FSFW_PUS_SERVICEPACKETS_SERVICE20PACKETS_H_
 #define FSFW_PUS_SERVICEPACKETS_SERVICE20PACKETS_H_
 
+#include <FSFWConfig.h>
 #include <fsfw/parameters/HasParametersIF.h>
 #include <fsfw/serialize/SerialBufferAdapter.h>
 #include <fsfw/serialize/SerializeElement.h>
 #include <fsfw/serialize/SerialLinkedListAdapter.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
 
 /**
- * @brief
+ * @brief   This class encapsulates the packets sent to the PUS service 20 or sent by the
+ *          PUS service 20
  * @details
+ * This command can be used to handle both load and dump commands as well.
  * @author
  */
 class ParameterCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128, 129, 130
 public:
+
+    /**
+     * This constructor is used for load replies. The data is expected in the correct formast
+     * in the store pointer.
+     * @param storePointer
+     * @param parameterDataLen
+     */
     ParameterCommand(uint8_t* storePointer, size_t parameterDataLen):
         parameterBuffer(storePointer, parameterDataLen) {
-        setLinks();
+#if FSFW_VERBOSE_LEVEL >= 1
+        if(parameterDataLen < sizeof(object_id_t) + sizeof(ParameterId_t) + 4) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::warning << "ParameterCommand: Parameter data length is less than 12!"
+                    << std::endl;
+#else
+            sif::printWarning("ParameterCommand: Parameter data length is less than 12!\n");
+#endif
+        }
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+        setLoadLinks();
     }
 
+    /**
+     * This constructor is used for dump replies. It is assumed the 4 byte parameter
+     * information field is located inside the parameter buffer.
+     * @param objectId
+     * @param parameterId
+     * @param parameterBuffer
+     * @param parameterBufferSize
+     */
     ParameterCommand(object_id_t objectId, ParameterId_t parameterId,
             const uint8_t* parameterBuffer, size_t parameterBufferSize):
                 objectId(objectId), parameterId(parameterId),
                 parameterBuffer(parameterBuffer, parameterBufferSize) {
-        setLinks();
+        setDumpReplyLinks();
     }
 
     ParameterId_t getParameterId() const {
@@ -37,6 +66,18 @@ public:
         return parameterBuffer.getSerializedSize();
     }
 
+    uint8_t getDomainId() const {
+        return (parameterId.entry >> 24) & 0xff;
+    }
+
+    uint8_t getUniqueId() const {
+        return (parameterId.entry >> 16) & 0xff;
+    }
+
+    uint16_t getLinearIndex() const {
+        return parameterId.entry & 0xffff;
+    }
+
     uint8_t getPtc() const {
         return ccsdsType.entry >> 8 & 0xff;
     }
@@ -54,7 +95,7 @@ public:
     }
 
 private:
-    void setLinks() {
+    void setLoadLinks() {
         setStart(&objectId);
         objectId.setNext(&parameterId);
         parameterId.setNext(&ccsdsType);
@@ -63,6 +104,19 @@ private:
         columns.setNext(&parameterBuffer);
     }
 
+    void setDumpReplyLinks() {
+        /* For a dump reply, the parameter information is contained in the parameter buffer
+        with the actual parameters */
+        setStart(&objectId);
+        objectId.setNext(&parameterId);
+        parameterId.setNext(&parameterBuffer);
+    }
+
+    void setDumpRequestLinks() {
+        setStart(&objectId);
+        objectId.setNext(&parameterId);
+    }
+
     SerializeElement<object_id_t> objectId = 0;
     SerializeElement<ParameterId_t> parameterId = 0;
     //! [EXPORT] : [COMMENT] Type consisting of one byte PTC and one byte PFC.

From a404bc881ef08d4f7c6b741b6bbe4ac7025379ec Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Feb 2021 13:28:31 +0100
Subject: [PATCH 1554/1774] removed hk switcher for now

---
 devicehandlers/DeviceHandlerBase.cpp | 2264 +++++++++++++-------------
 devicehandlers/DeviceHandlerBase.h   | 2113 ++++++++++++------------
 2 files changed, 2188 insertions(+), 2189 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 897d0595b..8650ec308 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -17,460 +17,458 @@ 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,
-		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
-		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
-		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
-		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		actionHelper(this, nullptr), poolManager(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,
-			MessageQueueMessage::MAX_MESSAGE_SIZE);
-	insertInCommandMap(RAW_COMMAND_ID);
-	cookieInfo.state = COOKIE_UNUSED;
-	cookieInfo.pendingCommand = deviceCommandMap.end();
-	if (comCookie == nullptr) {
-		printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
-				HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
-	}
-	if (this->fdirInstance == nullptr) {
-		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
-				defaultFdirParentId);
-	}
+DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+        CookieIF * comCookie, FailureIsolationBase* fdirInstance, size_t cmdQueueSize):
+		                SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
+		                wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
+		                deviceCommunicationId(deviceCommunication), comCookie(comCookie),
+		                healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
+		                actionHelper(this, nullptr), poolManager(this, nullptr),
+		                childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
+		                defaultFDIRUsed(fdirInstance == nullptr),
+		                switchOffWasReported(false), childTransitionDelay(5000),
+		                transitionSourceMode(_MODE_POWER_DOWN),
+		                transitionSourceSubMode(SUBMODE_NONE) {
+    commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
+            MessageQueueMessage::MAX_MESSAGE_SIZE);
+    insertInCommandMap(RAW_COMMAND_ID);
+    cookieInfo.state = COOKIE_UNUSED;
+    cookieInfo.pendingCommand = deviceCommandMap.end();
+    if (comCookie == nullptr) {
+        printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
+                HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
+    }
+    if (this->fdirInstance == nullptr) {
+        this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
+                defaultFdirParentId);
+    }
 }
 
 void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
-	this->hkDestination = hkDestination;
+    this->hkDestination = hkDestination;
 }
 
 void DeviceHandlerBase::setThermalStateRequestPoolIds(
-		lp_id_t thermalStatePoolId, lp_id_t heaterRequestPoolId,
-		uint32_t thermalSetId) {
-	thermalSet = new DeviceHandlerThermalSet(this, thermalSetId,
-			thermalStatePoolId, heaterRequestPoolId);
+        lp_id_t thermalStatePoolId, lp_id_t heaterRequestPoolId,
+        uint32_t thermalSetId) {
+    thermalSet = new DeviceHandlerThermalSet(this, thermalSetId,
+            thermalStatePoolId, heaterRequestPoolId);
 }
 
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-	delete comCookie;
-	if (defaultFDIRUsed) {
-		delete fdirInstance;
-	}
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+    delete comCookie;
+    if (defaultFDIRUsed) {
+        delete fdirInstance;
+    }
+    QueueFactory::instance()->deleteMessageQueue(commandQueue);
 }
 
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
-	this->pstStep = counter;
-	this->lastStep = this->pstStep;
+    this->pstStep = counter;
+    this->lastStep = this->pstStep;
 
-	if (getComAction() == CommunicationAction::NOTHING) {
-	    return HasReturnvaluesIF::RETURN_OK;
-	}
+    if (getComAction() == CommunicationAction::NOTHING) {
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	if (getComAction() == CommunicationAction::PERFORM_OPERATION) {
-		cookieInfo.state = COOKIE_UNUSED;
-		readCommandQueue();
-		doStateMachine();
-		checkSwitchState();
-		decrementDeviceReplyMap();
-		fdirInstance->checkForFailures();
-		hkSwitcher.performOperation();
-		performOperationHook();
-		return RETURN_OK;
-	}
+    if (getComAction() == CommunicationAction::PERFORM_OPERATION) {
+        cookieInfo.state = COOKIE_UNUSED;
+        readCommandQueue();
+        doStateMachine();
+        checkSwitchState();
+        decrementDeviceReplyMap();
+        fdirInstance->checkForFailures();
+        performOperationHook();
+        return RETURN_OK;
+    }
 
-	if (mode == MODE_OFF) {
-		return RETURN_OK;
-	}
+    if (mode == MODE_OFF) {
+        return RETURN_OK;
+    }
 
-	switch (getComAction()) {
-	case CommunicationAction::SEND_WRITE:
-		if (cookieInfo.state == COOKIE_UNUSED) {
-		    // if no external command was specified, build internal command.
-			buildInternalCommand();
-		}
-		doSendWrite();
-		break;
-	case CommunicationAction::GET_WRITE:
-		doGetWrite();
-		break;
-	case CommunicationAction::SEND_READ:
-		doSendRead();
-		break;
-	case CommunicationAction::GET_READ:
-		doGetRead();
-		// This will be performed after datasets have been updated by the
-		// custom device implementation.
-		poolManager.performHkOperation();
-		break;
-	default:
-		break;
-	}
-	return RETURN_OK;
+    switch (getComAction()) {
+    case CommunicationAction::SEND_WRITE:
+        if (cookieInfo.state == COOKIE_UNUSED) {
+            // if no external command was specified, build internal command.
+            buildInternalCommand();
+        }
+        doSendWrite();
+        break;
+    case CommunicationAction::GET_WRITE:
+        doGetWrite();
+        break;
+    case CommunicationAction::SEND_READ:
+        doSendRead();
+        break;
+    case CommunicationAction::GET_READ:
+        doGetRead();
+        // This will be performed after datasets have been updated by the
+        // custom device implementation.
+        poolManager.performHkOperation();
+        break;
+    default:
+        break;
+    }
+    return RETURN_OK;
 }
 
 ReturnValue_t DeviceHandlerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
+    ReturnValue_t result = SystemObject::initialize();
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	communicationInterface = objectManager->get<DeviceCommunicationIF>(
-			deviceCommunicationId);
-	if (communicationInterface == nullptr) {
-		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
-				ObjectManagerIF::CHILD_INIT_FAILED,
-				"Passed communication IF invalid");
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
+    communicationInterface = objectManager->get<DeviceCommunicationIF>(
+            deviceCommunicationId);
+    if (communicationInterface == nullptr) {
+        printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
+                ObjectManagerIF::CHILD_INIT_FAILED,
+                "Passed communication IF invalid");
+        return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
 
-	result = communicationInterface->initializeInterface(comCookie);
-	if (result != RETURN_OK) {
-		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
-				ObjectManagerIF::CHILD_INIT_FAILED,
-				"ComIF initialization failed");
-	    return result;
-	}
+    result = communicationInterface->initializeInterface(comCookie);
+    if (result != RETURN_OK) {
+        printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
+                ObjectManagerIF::CHILD_INIT_FAILED,
+                "ComIF initialization failed");
+        return result;
+    }
 
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (IPCStore == nullptr) {
-		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
-				ObjectManagerIF::CHILD_INIT_FAILED, "IPC Store not set up");
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
+    IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if (IPCStore == nullptr) {
+        printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
+                ObjectManagerIF::CHILD_INIT_FAILED, "IPC Store not set up");
+        return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
 
-	if(rawDataReceiverId != objects::NO_OBJECT) {
-		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
-				AcceptsDeviceResponsesIF>(rawDataReceiverId);
+    if(rawDataReceiverId != objects::NO_OBJECT) {
+        AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
+                AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
-		if (rawReceiver == nullptr) {
-			printWarningOrError(sif::OutputTypes::OUT_ERROR,
-					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
-					"Raw receiver object ID set but no valid object found.");
+        if (rawReceiver == nullptr) {
+            printWarningOrError(sif::OutputTypes::OUT_ERROR,
+                    "initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+                    "Raw receiver object ID set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "Make sure the raw receiver object is set up properly"
-					" and implements AcceptsDeviceResponsesIF" << std::endl;
+            sif::error << "Make sure the raw receiver object is set up properly"
+                    " and implements AcceptsDeviceResponsesIF" << std::endl;
 #else
-			sif::printError("Make sure the raw receiver object is set up "
-					"properly and implements AcceptsDeviceResponsesIF\n");
+            sif::printError("Make sure the raw receiver object is set up "
+                    "properly and implements AcceptsDeviceResponsesIF\n");
 #endif
-			return ObjectManagerIF::CHILD_INIT_FAILED;
-		}
-		defaultRawReceiver = rawReceiver->getDeviceQueue();
-	}
+            return ObjectManagerIF::CHILD_INIT_FAILED;
+        }
+        defaultRawReceiver = rawReceiver->getDeviceQueue();
+    }
 
-	if(powerSwitcherId != objects::NO_OBJECT) {
-		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
-		if (powerSwitcher == nullptr) {
-			printWarningOrError(sif::OutputTypes::OUT_ERROR,
-					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
-					"Power switcher set but no valid object found.");
+    if(powerSwitcherId != objects::NO_OBJECT) {
+        powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
+        if (powerSwitcher == nullptr) {
+            printWarningOrError(sif::OutputTypes::OUT_ERROR,
+                    "initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+                    "Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "Make sure the power switcher object is set up "
-					<< "properly and implements PowerSwitchIF" << std::endl;
+            sif::error << "Make sure the power switcher object is set up "
+                    << "properly and implements PowerSwitchIF" << std::endl;
 #else
-			sif::printError("Make sure the power switcher object is set up "
-					"properly and implements PowerSwitchIF\n");
+            sif::printError("Make sure the power switcher object is set up "
+                    "properly and implements PowerSwitchIF\n");
 #endif
-			return ObjectManagerIF::CHILD_INIT_FAILED;
-		}
-	}
+            return ObjectManagerIF::CHILD_INIT_FAILED;
+        }
+    }
 
-	result = healthHelper.initialize();
-	if (result != RETURN_OK) {
-	    return result;
-	}
+    result = healthHelper.initialize();
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	result = modeHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = actionHelper.initialize(commandQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = fdirInstance->initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    result = modeHelper.initialize();
+    if (result != RETURN_OK) {
+        return result;
+    }
+    result = actionHelper.initialize(commandQueue);
+    if (result != RETURN_OK) {
+        return result;
+    }
+    result = fdirInstance->initialize();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    result = parameterHelper.initialize();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	result = hkSwitcher.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    result = hkSwitcher.initialize();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	result = poolManager.initialize(commandQueue);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    result = poolManager.initialize(commandQueue);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	fillCommandAndReplyMap();
+    fillCommandAndReplyMap();
 
-	if(thermalSet != nullptr) {
-		//Set temperature target state to NON_OP.
-		result = thermalSet->read();
-		if(result == HasReturnvaluesIF::RETURN_OK) {
-			thermalSet->heaterRequest.value =
-					ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-			thermalSet->heaterRequest.setValid(true);
-			thermalSet->commit();
-		}
+    if(thermalSet != nullptr) {
+        //Set temperature target state to NON_OP.
+        result = thermalSet->read();
+        if(result == HasReturnvaluesIF::RETURN_OK) {
+            thermalSet->heaterRequest.value =
+                    ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+            thermalSet->heaterRequest.setValid(true);
+            thermalSet->commit();
+        }
 
-	}
+    }
 
-	return RETURN_OK;
+    return RETURN_OK;
 }
 
 void DeviceHandlerBase::decrementDeviceReplyMap() {
-	for (std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
-			deviceReplyMap.begin(); iter != deviceReplyMap.end(); iter++) {
-		if (iter->second.delayCycles != 0) {
-			iter->second.delayCycles--;
-			if (iter->second.delayCycles == 0) {
-				if (iter->second.periodic) {
-					iter->second.delayCycles = iter->second.maxDelayCycles;
-				}
-				replyToReply(iter, TIMEOUT);
-				missedReply(iter->first);
-			}
-		}
-	}
+    for (std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
+            deviceReplyMap.begin(); iter != deviceReplyMap.end(); iter++) {
+        if (iter->second.delayCycles != 0) {
+            iter->second.delayCycles--;
+            if (iter->second.delayCycles == 0) {
+                if (iter->second.periodic) {
+                    iter->second.delayCycles = iter->second.maxDelayCycles;
+                }
+                replyToReply(iter, TIMEOUT);
+                missedReply(iter->first);
+            }
+        }
+    }
 }
 
 void DeviceHandlerBase::readCommandQueue() {
 
-	if (dontCheckQueue()) {
-		return;
-	}
+    if (dontCheckQueue()) {
+        return;
+    }
 
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != RETURN_OK) {
-		return;
-	}
+    CommandMessage command;
+    ReturnValue_t result = commandQueue->receiveMessage(&command);
+    if (result != RETURN_OK) {
+        return;
+    }
 
-	result = healthHelper.handleHealthCommand(&command);
-	if (result == RETURN_OK) {
-	    return;
-	}
+    result = healthHelper.handleHealthCommand(&command);
+    if (result == RETURN_OK) {
+        return;
+    }
 
-	result = modeHelper.handleModeCommand(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
+    result = modeHelper.handleModeCommand(&command);
+    if (result == RETURN_OK) {
+        return;
+    }
 
-	result = actionHelper.handleActionMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
+    result = actionHelper.handleActionMessage(&command);
+    if (result == RETURN_OK) {
+        return;
+    }
 
-	result = parameterHelper.handleParameterMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
+    result = parameterHelper.handleParameterMessage(&command);
+    if (result == RETURN_OK) {
+        return;
+    }
 
-	result = poolManager.handleHousekeepingMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
+    result = poolManager.handleHousekeepingMessage(&command);
+    if (result == RETURN_OK) {
+        return;
+    }
 
-	result = handleDeviceHandlerMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
+    result = handleDeviceHandlerMessage(&command);
+    if (result == RETURN_OK) {
+        return;
+    }
 
-	result = letChildHandleMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
+    result = letChildHandleMessage(&command);
+    if (result == RETURN_OK) {
+        return;
+    }
 
-	replyReturnvalueToCommand(CommandMessage::UNKNOWN_COMMAND);
+    replyReturnvalueToCommand(CommandMessage::UNKNOWN_COMMAND);
 
 }
 
 void DeviceHandlerBase::doStateMachine() {
-	switch (mode) {
-	case _MODE_START_UP:
-	case _MODE_SHUT_DOWN:
-	case _MODE_TO_NORMAL:
-	case _MODE_TO_ON:
-	case _MODE_TO_RAW: {
-		Mode_t currentMode = mode;
-		callChildStatemachine();
-		//Only do timeout if child did not change anything
-		if (mode != currentMode) {
-			break;
-		}
-		uint32_t currentUptime;
-		Clock::getUptime(&currentUptime);
-		if (currentUptime - timeoutStart >= childTransitionDelay) {
-			triggerEvent(MODE_TRANSITION_FAILED, childTransitionFailure, 0);
-			setMode(transitionSourceMode, transitionSourceSubMode);
-			break;
-		}
-	}
-		break;
-	case _MODE_POWER_DOWN:
-		commandSwitch(PowerSwitchIF::SWITCH_OFF);
-		setMode(_MODE_WAIT_OFF);
-		break;
-	case _MODE_POWER_ON:
-		commandSwitch(PowerSwitchIF::SWITCH_ON);
-		setMode(_MODE_WAIT_ON);
-		break;
-	case _MODE_WAIT_ON: {
-		uint32_t currentUptime;
-		Clock::getUptime(&currentUptime);
-		if (powerSwitcher != nullptr and currentUptime - timeoutStart >=
-				powerSwitcher->getSwitchDelayMs()) {
-			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
-					0);
-			setMode(_MODE_POWER_DOWN);
-			callChildStatemachine();
-			break;
-		}
-		ReturnValue_t switchState = getStateOfSwitches();
-		if ((switchState == PowerSwitchIF::SWITCH_ON)
-				|| (switchState == NO_SWITCH)) {
-			//NOTE: TransitionSourceMode and -SubMode are set by handleCommandedModeTransition
-			childTransitionFailure = CHILD_TIMEOUT;
-			setMode(_MODE_START_UP);
-			callChildStatemachine();
-		}
-	}
-		break;
-	case _MODE_WAIT_OFF: {
-		uint32_t currentUptime;
-		Clock::getUptime(&currentUptime);
+    switch (mode) {
+    case _MODE_START_UP:
+    case _MODE_SHUT_DOWN:
+    case _MODE_TO_NORMAL:
+    case _MODE_TO_ON:
+    case _MODE_TO_RAW: {
+        Mode_t currentMode = mode;
+        callChildStatemachine();
+        //Only do timeout if child did not change anything
+        if (mode != currentMode) {
+            break;
+        }
+        uint32_t currentUptime;
+        Clock::getUptime(&currentUptime);
+        if (currentUptime - timeoutStart >= childTransitionDelay) {
+            triggerEvent(MODE_TRANSITION_FAILED, childTransitionFailure, 0);
+            setMode(transitionSourceMode, transitionSourceSubMode);
+            break;
+        }
+    }
+    break;
+    case _MODE_POWER_DOWN:
+        commandSwitch(PowerSwitchIF::SWITCH_OFF);
+        setMode(_MODE_WAIT_OFF);
+        break;
+    case _MODE_POWER_ON:
+        commandSwitch(PowerSwitchIF::SWITCH_ON);
+        setMode(_MODE_WAIT_ON);
+        break;
+    case _MODE_WAIT_ON: {
+        uint32_t currentUptime;
+        Clock::getUptime(&currentUptime);
+        if (powerSwitcher != nullptr and currentUptime - timeoutStart >=
+                powerSwitcher->getSwitchDelayMs()) {
+            triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
+                    0);
+            setMode(_MODE_POWER_DOWN);
+            callChildStatemachine();
+            break;
+        }
+        ReturnValue_t switchState = getStateOfSwitches();
+        if ((switchState == PowerSwitchIF::SWITCH_ON)
+                || (switchState == NO_SWITCH)) {
+            //NOTE: TransitionSourceMode and -SubMode are set by handleCommandedModeTransition
+            childTransitionFailure = CHILD_TIMEOUT;
+            setMode(_MODE_START_UP);
+            callChildStatemachine();
+        }
+    }
+    break;
+    case _MODE_WAIT_OFF: {
+        uint32_t currentUptime;
+        Clock::getUptime(&currentUptime);
 
-		if(powerSwitcher == nullptr) {
-		    setMode(MODE_OFF);
-		    break;
-		}
+        if(powerSwitcher == nullptr) {
+            setMode(MODE_OFF);
+            break;
+        }
 
-		if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
-			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
-					0);
-			setMode(MODE_ERROR_ON);
-			break;
-		}
-		ReturnValue_t switchState = getStateOfSwitches();
-		if ((switchState == PowerSwitchIF::SWITCH_OFF)
-				|| (switchState == NO_SWITCH)) {
-			setMode(_MODE_SWITCH_IS_OFF);
-		}
-	}
-		break;
-	case MODE_OFF:
-		doOffActivity();
-		break;
-	case MODE_ON:
-		doOnActivity();
-		break;
-	case MODE_RAW:
-	case MODE_NORMAL:
-	case MODE_ERROR_ON:
-		break;
-	case _MODE_SWITCH_IS_OFF:
-		setMode(MODE_OFF, SUBMODE_NONE);
-		break;
-	default:
-		triggerEvent(OBJECT_IN_INVALID_MODE, mode, submode);
-		setMode(_MODE_POWER_DOWN, 0);
-		break;
-	}
+        if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
+            triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
+                    0);
+            setMode(MODE_ERROR_ON);
+            break;
+        }
+        ReturnValue_t switchState = getStateOfSwitches();
+        if ((switchState == PowerSwitchIF::SWITCH_OFF)
+                || (switchState == NO_SWITCH)) {
+            setMode(_MODE_SWITCH_IS_OFF);
+        }
+    }
+    break;
+    case MODE_OFF:
+        doOffActivity();
+        break;
+    case MODE_ON:
+        doOnActivity();
+        break;
+    case MODE_RAW:
+    case MODE_NORMAL:
+    case MODE_ERROR_ON:
+        break;
+    case _MODE_SWITCH_IS_OFF:
+        setMode(MODE_OFF, SUBMODE_NONE);
+        break;
+    default:
+        triggerEvent(OBJECT_IN_INVALID_MODE, mode, submode);
+        setMode(_MODE_POWER_DOWN, 0);
+        break;
+    }
 }
 
 ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
-		Submode_t submode) {
-	switch (mode) {
-	case MODE_OFF:
-	case MODE_ON:
-	case MODE_NORMAL:
-	case MODE_RAW:
-		if (submode == SUBMODE_NONE) {
-			return RETURN_OK;
-		} else {
-			return INVALID_SUBMODE;
-		}
-	default:
-		return HasModesIF::INVALID_MODE;
-	}
+        Submode_t submode) {
+    switch (mode) {
+    case MODE_OFF:
+    case MODE_ON:
+    case MODE_NORMAL:
+    case MODE_RAW:
+        if (submode == SUBMODE_NONE) {
+            return RETURN_OK;
+        } else {
+            return INVALID_SUBMODE;
+        }
+    default:
+        return HasModesIF::INVALID_MODE;
+    }
 }
 
 ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
-		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-		LocalPoolDataSetBase* replyDataSet, 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) {
-		return insertInReplyMap(replyId, maxDelayCycles,
-		        replyDataSet, replyLen, periodic);
-	} else {
-		return insertInReplyMap(deviceCommand, maxDelayCycles,
-		        replyDataSet, replyLen, periodic);
-	}
+        DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
+        LocalPoolDataSetBase* replyDataSet, 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) {
+        return insertInReplyMap(replyId, maxDelayCycles,
+                replyDataSet, replyLen, periodic);
+    } else {
+        return insertInReplyMap(deviceCommand, maxDelayCycles,
+                replyDataSet, replyLen, periodic);
+    }
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet,
-		size_t replyLen, bool periodic) {
-	DeviceReplyInfo info;
-	info.maxDelayCycles = maxDelayCycles;
-	info.periodic = periodic;
-	info.delayCycles = 0;
-	info.replyLen = replyLen;
-	info.dataSet = dataSet;
-	info.command = deviceCommandMap.end();
-	auto resultPair = deviceReplyMap.emplace(replyId, info);
-	if (resultPair.second) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
+        uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet,
+        size_t replyLen, bool periodic) {
+    DeviceReplyInfo info;
+    info.maxDelayCycles = maxDelayCycles;
+    info.periodic = periodic;
+    info.delayCycles = 0;
+    info.replyLen = replyLen;
+    info.dataSet = dataSet;
+    info.command = deviceCommandMap.end();
+    auto resultPair = deviceReplyMap.emplace(replyId, info);
+    if (resultPair.second) {
+        return RETURN_OK;
+    } else {
+        return RETURN_FAILED;
+    }
 }
 
 ReturnValue_t DeviceHandlerBase::insertInCommandMap(
-		DeviceCommandId_t deviceCommand) {
-	DeviceCommandInfo info;
-	info.expectedReplies = 0;
-	info.isExecuting = false;
-	info.sendReplyTo = NO_COMMANDER;
-	auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
-	if (resultPair.second) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
+        DeviceCommandId_t deviceCommand) {
+    DeviceCommandInfo info;
+    info.expectedReplies = 0;
+    info.isExecuting = false;
+    info.sendReplyTo = NO_COMMANDER;
+    auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
+    if (resultPair.second) {
+        return RETURN_OK;
+    } else {
+        return RETURN_FAILED;
+    }
 }
 
 ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
-		uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
-	auto replyIter = deviceReplyMap.find(deviceReply);
-	if (replyIter == deviceReplyMap.end()) {
-		triggerEvent(INVALID_DEVICE_COMMAND, deviceReply);
-		return RETURN_FAILED;
-	} else {
-		DeviceReplyInfo *info = &(replyIter->second);
-		if (maxDelayCycles != 0) {
-			info->maxDelayCycles = maxDelayCycles;
-		}
-		info->delayCycles = delayCycles;
-		info->periodic = periodic;
-		return RETURN_OK;
-	}
+        uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
+    auto replyIter = deviceReplyMap.find(deviceReply);
+    if (replyIter == deviceReplyMap.end()) {
+        triggerEvent(INVALID_DEVICE_COMMAND, deviceReply);
+        return RETURN_FAILED;
+    } else {
+        DeviceReplyInfo *info = &(replyIter->second);
+        if (maxDelayCycles != 0) {
+            info->maxDelayCycles = maxDelayCycles;
+        }
+        info->delayCycles = delayCycles;
+        info->periodic = periodic;
+        return RETURN_OK;
+    }
 }
 
 
@@ -485,499 +483,501 @@ ReturnValue_t DeviceHandlerBase::setReplyDataset(DeviceCommandId_t replyId,
 }
 
 void DeviceHandlerBase::callChildStatemachine() {
-	if (mode == _MODE_START_UP) {
-		doStartUp();
-	} else if (mode == _MODE_SHUT_DOWN) {
-		doShutDown();
-	} else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
-		doTransition(transitionSourceMode, transitionSourceSubMode);
-	}
+    if (mode == _MODE_START_UP) {
+        doStartUp();
+    } else if (mode == _MODE_SHUT_DOWN) {
+        doShutDown();
+    } else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
+        doTransition(transitionSourceMode, transitionSourceSubMode);
+    }
 }
 
 void DeviceHandlerBase::setTransition(Mode_t modeTo, Submode_t submodeTo) {
-	triggerEvent(CHANGING_MODE, modeTo, submodeTo);
-	childTransitionDelay = getTransitionDelayMs(mode, modeTo);
-	transitionSourceMode = mode;
-	transitionSourceSubMode = submode;
-	childTransitionFailure = CHILD_TIMEOUT;
+    triggerEvent(CHANGING_MODE, modeTo, submodeTo);
+    childTransitionDelay = getTransitionDelayMs(mode, modeTo);
+    transitionSourceMode = mode;
+    transitionSourceSubMode = submode;
+    childTransitionFailure = CHILD_TIMEOUT;
 
-	// transitionTargetMode is set by setMode
-	setMode((modeTo | TRANSITION_MODE_CHILD_ACTION_MASK), submodeTo);
+    // transitionTargetMode is set by setMode
+    setMode((modeTo | TRANSITION_MODE_CHILD_ACTION_MASK), submodeTo);
 }
 
 void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
-	changeHK(mode, submode, false);
-	submode = newSubmode;
-	mode = newMode;
-	modeChanged();
-	setNormalDatapoolEntriesInvalid();
-	if (!isTransitionalMode()) {
-		modeHelper.modeChanged(newMode, newSubmode);
-		announceMode(false);
-	}
-	Clock::getUptime(&timeoutStart);
+    /* TODO: This will probably be done by the LocalDataPoolManager now */
+    //changeHK(mode, submode, false);
+    submode = newSubmode;
+    mode = newMode;
+    modeChanged();
+    setNormalDatapoolEntriesInvalid();
+    if (!isTransitionalMode()) {
+        modeHelper.modeChanged(newMode, newSubmode);
+        announceMode(false);
+    }
+    Clock::getUptime(&timeoutStart);
 
-	if (mode == MODE_OFF and thermalSet != nullptr) {
-		ReturnValue_t result = thermalSet->read();
-		if(result == HasReturnvaluesIF::RETURN_OK) {
-			if (thermalSet->heaterRequest.value !=
-					ThermalComponentIF::STATE_REQUEST_IGNORE) {
-				thermalSet->heaterRequest.value = ThermalComponentIF::
-						STATE_REQUEST_NON_OPERATIONAL;
-			}
-			thermalSet->heaterRequest.commit(PoolVariableIF::VALID);
-		}
+    if (mode == MODE_OFF and thermalSet != nullptr) {
+        ReturnValue_t result = thermalSet->read();
+        if(result == HasReturnvaluesIF::RETURN_OK) {
+            if (thermalSet->heaterRequest.value !=
+                    ThermalComponentIF::STATE_REQUEST_IGNORE) {
+                thermalSet->heaterRequest.value = ThermalComponentIF::
+                        STATE_REQUEST_NON_OPERATIONAL;
+            }
+            thermalSet->heaterRequest.commit(PoolVariableIF::VALID);
+        }
 
-	}
-	changeHK(mode, submode, true);
+    }
+    /* TODO: This will probably be done by the LocalDataPoolManager now */
+    //changeHK(mode, submode, true);
 }
 
 void DeviceHandlerBase::setMode(Mode_t newMode) {
-	setMode(newMode, submode);
+    setMode(newMode, submode);
 }
 
 void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
-		uint32_t parameter) {
-	//This is actually the reply protocol for raw and misc DH commands.
-	if (status == RETURN_OK) {
-		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, parameter);
-		commandQueue->reply(&reply);
-	} else {
-		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, parameter);
-		commandQueue->reply(&reply);
-	}
+        uint32_t parameter) {
+    //This is actually the reply protocol for raw and misc DH commands.
+    if (status == RETURN_OK) {
+        CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, parameter);
+        commandQueue->reply(&reply);
+    } else {
+        CommandMessage reply(CommandMessage::REPLY_REJECTED, status, parameter);
+        commandQueue->reply(&reply);
+    }
 }
 
 void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
-		uint32_t parameter) {
-	// Check if we reply to a raw command.
-	if (cookieInfo.pendingCommand->first == RAW_COMMAND_ID) {
-		if (status == NO_REPLY_EXPECTED) {
-			status = RETURN_OK;
-		}
-		replyReturnvalueToCommand(status, parameter);
-		// Always delete data from a raw command.
-		IPCStore->deleteData(storedRawData);
-		return;
-	}
-	// Check if we were externally commanded.
-	if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
-		MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
-		if (status == NO_REPLY_EXPECTED) {
-			actionHelper.finish(queueId, cookieInfo.pendingCommand->first,
-					RETURN_OK);
-		} else {
-			actionHelper.step(1, queueId, cookieInfo.pendingCommand->first,
-					status);
-		}
-	}
+        uint32_t parameter) {
+    // Check if we reply to a raw command.
+    if (cookieInfo.pendingCommand->first == RAW_COMMAND_ID) {
+        if (status == NO_REPLY_EXPECTED) {
+            status = RETURN_OK;
+        }
+        replyReturnvalueToCommand(status, parameter);
+        // Always delete data from a raw command.
+        IPCStore->deleteData(storedRawData);
+        return;
+    }
+    // Check if we were externally commanded.
+    if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
+        MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
+        if (status == NO_REPLY_EXPECTED) {
+            actionHelper.finish(queueId, cookieInfo.pendingCommand->first,
+                    RETURN_OK);
+        } else {
+            actionHelper.step(1, queueId, cookieInfo.pendingCommand->first,
+                    status);
+        }
+    }
 }
 
 void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
-		ReturnValue_t status) {
-	// No need to check if iter exists, as this is checked by callers.
-	// If someone else uses the method, add check.
-	if (iter->second.command == deviceCommandMap.end()) {
-		//Is most likely periodic reply. Silent return.
-		return;
-	}
-	// Check if more replies are expected. If so, do nothing.
-	DeviceCommandInfo* info = &(iter->second.command->second);
-	if (--info->expectedReplies == 0) {
-		// Check if it was transition or internal command.
-		// Don't send any replies in that case.
-		if (info->sendReplyTo != NO_COMMANDER) {
-			actionHelper.finish(info->sendReplyTo, iter->first, status);
-		}
-		info->isExecuting = false;
-	}
+        ReturnValue_t status) {
+    // No need to check if iter exists, as this is checked by callers.
+    // If someone else uses the method, add check.
+    if (iter->second.command == deviceCommandMap.end()) {
+        //Is most likely periodic reply. Silent return.
+        return;
+    }
+    // Check if more replies are expected. If so, do nothing.
+    DeviceCommandInfo* info = &(iter->second.command->second);
+    if (--info->expectedReplies == 0) {
+        // Check if it was transition or internal command.
+        // Don't send any replies in that case.
+        if (info->sendReplyTo != NO_COMMANDER) {
+            actionHelper.finish(info->sendReplyTo, iter->first, status);
+        }
+        info->isExecuting = false;
+    }
 }
 
 void DeviceHandlerBase::doSendWrite() {
-	if (cookieInfo.state == COOKIE_WRITE_READY) {
+    if (cookieInfo.state == COOKIE_WRITE_READY) {
 
-		ReturnValue_t result = communicationInterface->sendMessage(comCookie,
-				rawPacket, rawPacketLen);
+        ReturnValue_t result = communicationInterface->sendMessage(comCookie,
+                rawPacket, rawPacketLen);
 
-		if (result == RETURN_OK) {
-			cookieInfo.state = COOKIE_WRITE_SENT;
-		} else {
-			// always generate a failure event, so that FDIR knows what's up
-			triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
-					cookieInfo.pendingCommand->first);
-			replyToCommand(result);
-			cookieInfo.state = COOKIE_UNUSED;
-			cookieInfo.pendingCommand->second.isExecuting = false;
-		}
-	}
+        if (result == RETURN_OK) {
+            cookieInfo.state = COOKIE_WRITE_SENT;
+        } else {
+            // always generate a failure event, so that FDIR knows what's up
+            triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
+                    cookieInfo.pendingCommand->first);
+            replyToCommand(result);
+            cookieInfo.state = COOKIE_UNUSED;
+            cookieInfo.pendingCommand->second.isExecuting = false;
+        }
+    }
 }
 
 void DeviceHandlerBase::doGetWrite() {
-	if (cookieInfo.state != COOKIE_WRITE_SENT) {
-		return;
-	}
-	cookieInfo.state = COOKIE_UNUSED;
-	ReturnValue_t result = communicationInterface->getSendSuccess(comCookie);
-	if (result == RETURN_OK) {
-		if (wiretappingMode == RAW) {
-			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
-		}
+    if (cookieInfo.state != COOKIE_WRITE_SENT) {
+        return;
+    }
+    cookieInfo.state = COOKIE_UNUSED;
+    ReturnValue_t result = communicationInterface->getSendSuccess(comCookie);
+    if (result == RETURN_OK) {
+        if (wiretappingMode == RAW) {
+            replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
+        }
 
-		//We need to distinguish here, because a raw command never expects a reply.
-		//(Could be done in eRIRM, but then child implementations need to be careful.
-		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
-	} else {
-		//always generate a failure event, so that FDIR knows what's up
-		triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
-				cookieInfo.pendingCommand->first);
-	}
-	if (result != RETURN_OK) {
-		cookieInfo.pendingCommand->second.isExecuting = false;
-	}
-	replyToCommand(result);
+        //We need to distinguish here, because a raw command never expects a reply.
+        //(Could be done in eRIRM, but then child implementations need to be careful.
+        result = enableReplyInReplyMap(cookieInfo.pendingCommand);
+    } else {
+        //always generate a failure event, so that FDIR knows what's up
+        triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
+                cookieInfo.pendingCommand->first);
+    }
+    if (result != RETURN_OK) {
+        cookieInfo.pendingCommand->second.isExecuting = false;
+    }
+    replyToCommand(result);
 }
 
 void DeviceHandlerBase::doSendRead() {
-	ReturnValue_t result;
+    ReturnValue_t result;
 
-	size_t requestLen = 0;
-	if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
-		DeviceReplyIter iter = deviceReplyMap.find(
-				cookieInfo.pendingCommand->first);
-		if(iter != deviceReplyMap.end()) {
-			requestLen = iter->second.replyLen;
-		}
-	}
+    size_t requestLen = 0;
+    if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
+        DeviceReplyIter iter = deviceReplyMap.find(
+                cookieInfo.pendingCommand->first);
+        if(iter != deviceReplyMap.end()) {
+            requestLen = iter->second.replyLen;
+        }
+    }
 
-	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
+    result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
 
-	if (result == RETURN_OK) {
-		cookieInfo.state = COOKIE_READ_SENT;
-	} else {
-		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
-		//We can't inform anyone, because we don't know which command was sent last.
-		//So, we need to wait for a timeout.
-		//but I think we can allow to ignore one missedReply.
-		ignoreMissedRepliesCount++;
-		cookieInfo.state = COOKIE_UNUSED;
-	}
+    if (result == RETURN_OK) {
+        cookieInfo.state = COOKIE_READ_SENT;
+    } else {
+        triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
+        //We can't inform anyone, because we don't know which command was sent last.
+        //So, we need to wait for a timeout.
+        //but I think we can allow to ignore one missedReply.
+        ignoreMissedRepliesCount++;
+        cookieInfo.state = COOKIE_UNUSED;
+    }
 }
 
 void DeviceHandlerBase::doGetRead() {
-	size_t receivedDataLen = 0;
-	uint8_t *receivedData = nullptr;
+    size_t receivedDataLen = 0;
+    uint8_t *receivedData = nullptr;
 
-	if (cookieInfo.state != COOKIE_READ_SENT) {
-		cookieInfo.state = COOKIE_UNUSED;
-		return;
-	}
+    if (cookieInfo.state != COOKIE_READ_SENT) {
+        cookieInfo.state = COOKIE_UNUSED;
+        return;
+    }
 
-	cookieInfo.state = COOKIE_UNUSED;
+    cookieInfo.state = COOKIE_UNUSED;
 
-	ReturnValue_t result = communicationInterface->readReceivedMessage(
-			comCookie, &receivedData, &receivedDataLen);
+    ReturnValue_t result = communicationInterface->readReceivedMessage(
+            comCookie, &receivedData, &receivedDataLen);
 
-	if (result != RETURN_OK) {
-		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
-		//I think we can allow to ignore one missedReply.
-		ignoreMissedRepliesCount++;
-		return;
-	}
+    if (result != RETURN_OK) {
+        triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
+        //I think we can allow to ignore one missedReply.
+        ignoreMissedRepliesCount++;
+        return;
+    }
 
-	if (receivedDataLen == 0 or result == DeviceCommunicationIF::NO_REPLY_RECEIVED)
-		return;
+    if (receivedDataLen == 0 or result == DeviceCommunicationIF::NO_REPLY_RECEIVED)
+        return;
 
-	if (wiretappingMode == RAW) {
-		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
-	}
+    if (wiretappingMode == RAW) {
+        replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
+    }
 
-	if (mode == MODE_RAW) {
-		if (defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
-			replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
-		}
-	}
-	else {
-		parseReply(receivedData, receivedDataLen);
-	}
+    if (mode == MODE_RAW) {
+        if (defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
+            replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
+        }
+    }
+    else {
+        parseReply(receivedData, receivedDataLen);
+    }
 }
 
 void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
-		size_t receivedDataLen) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	DeviceCommandId_t foundId = DeviceHandlerIF::NO_COMMAND_ID;
-	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);
-			if(foundLen == 0) {
-				printWarningOrError(sif::OutputTypes::OUT_WARNING,
-						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
-						"Found length is one, parsing might be stuck");
-			}
-			break;
-		case APERIODIC_REPLY: {
-			result = interpretDeviceReply(foundId, receivedData);
-			if (result != RETURN_OK) {
-			    replyRawReplyIfnotWiretapped(receivedData, foundLen);
-			    triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
-			            foundId);
-			}
-			if(foundLen == 0) {
-				printWarningOrError(sif::OutputTypes::OUT_ERROR,
-						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
-						"Power switcher set but no valid object found.");
+        size_t receivedDataLen) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    DeviceCommandId_t foundId = DeviceHandlerIF::NO_COMMAND_ID;
+    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);
+            if(foundLen == 0) {
+                printWarningOrError(sif::OutputTypes::OUT_WARNING,
+                        "parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
+                        "Found length is one, parsing might be stuck");
+            }
+            break;
+        case APERIODIC_REPLY: {
+            result = interpretDeviceReply(foundId, receivedData);
+            if (result != RETURN_OK) {
+                replyRawReplyIfnotWiretapped(receivedData, foundLen);
+                triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
+                        foundId);
+            }
+            if(foundLen == 0) {
+                printWarningOrError(sif::OutputTypes::OUT_ERROR,
+                        "parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
+                        "Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
-			            " Packet parsing will be stuck." << std::endl;
+                sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+                        " Packet parsing will be stuck." << std::endl;
 #endif
-			}
-			break;
-		}
-		case IGNORE_REPLY_DATA:
-			continue;
-		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;
-		}
-	}
+            }
+            break;
+        }
+        case IGNORE_REPLY_DATA:
+            continue;
+        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);
+        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;
-	}
+    if (iter == deviceReplyMap.end()) {
+        replyRawReplyIfnotWiretapped(receivedData, foundLen);
+        triggerEvent(DEVICE_UNKNOWN_REPLY, foundId);
+        return;
+    }
 
-	DeviceReplyInfo *info = &(iter->second);
+    DeviceReplyInfo *info = &(iter->second);
 
-	if (info->delayCycles != 0) {
-	    result = interpretDeviceReply(foundId, receivedData);
+    if (info->delayCycles != 0) {
+        result = interpretDeviceReply(foundId, receivedData);
 
-	    if(result == IGNORE_REPLY_DATA) {
-	        return;
-	    }
+        if(result == IGNORE_REPLY_DATA) {
+            return;
+        }
 
-		if (info->periodic) {
-			info->delayCycles = info->maxDelayCycles;
-		}
-		else {
-			info->delayCycles = 0;
-		}
+        if (info->periodic) {
+            info->delayCycles = info->maxDelayCycles;
+        }
+        else {
+            info->delayCycles = 0;
+        }
 
-		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);
-		}
-	}
+        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) {
-	size_t lenTmp;
+        uint8_t** data, uint32_t * len) {
+    size_t lenTmp;
 
-	if (IPCStore == nullptr) {
-		*data = nullptr;
-		*len = 0;
-		return RETURN_FAILED;
-	}
-	ReturnValue_t result = IPCStore->modifyData(storageAddress, data, &lenTmp);
-	if (result == RETURN_OK) {
-		*len = lenTmp;
-		return RETURN_OK;
-	} else {
-		triggerEvent(StorageManagerIF::GET_DATA_FAILED, result,
-				storageAddress.raw);
-		*data = nullptr;
-		*len = 0;
-		return result;
-	}
+    if (IPCStore == nullptr) {
+        *data = nullptr;
+        *len = 0;
+        return RETURN_FAILED;
+    }
+    ReturnValue_t result = IPCStore->modifyData(storageAddress, data, &lenTmp);
+    if (result == RETURN_OK) {
+        *len = lenTmp;
+        return RETURN_OK;
+    } else {
+        triggerEvent(StorageManagerIF::GET_DATA_FAILED, result,
+                storageAddress.raw);
+        *data = nullptr;
+        *len = 0;
+        return result;
+    }
 }
 
 void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
-		MessageQueueId_t sendTo, bool isCommand) {
-	if (IPCStore == nullptr or len == 0 or sendTo == MessageQueueIF::NO_QUEUE) {
-		return;
-	}
-	store_address_t address;
-	ReturnValue_t result = IPCStore->addData(&address, data, len);
+        MessageQueueId_t sendTo, bool isCommand) {
+    if (IPCStore == nullptr or len == 0 or sendTo == MessageQueueIF::NO_QUEUE) {
+        return;
+    }
+    store_address_t address;
+    ReturnValue_t result = IPCStore->addData(&address, data, len);
 
-	if (result != RETURN_OK) {
-		triggerEvent(StorageManagerIF::STORE_DATA_FAILED, result);
-		return;
-	}
+    if (result != RETURN_OK) {
+        triggerEvent(StorageManagerIF::STORE_DATA_FAILED, result);
+        return;
+    }
 
-	CommandMessage command;
+    CommandMessage command;
 
-	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
-			getObjectId(), address, isCommand);
+    DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
+            getObjectId(), address, isCommand);
 
-	result = commandQueue->sendMessage(sendTo, &command);
+    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.
-	}
+    if (result != RETURN_OK) {
+        IPCStore->deleteData(address);
+        // Silently discard data, this indicates heavy TM traffic which
+        // should not be increased by additional events.
+    }
 }
 
 //Default child implementations
 DeviceHandlerIF::CommunicationAction DeviceHandlerBase::getComAction() {
-	switch (pstStep) {
-	case 0:
-		return CommunicationAction::PERFORM_OPERATION;
-		break;
-	case 1:
-	    return CommunicationAction::SEND_WRITE;
-	    break;
-	case 2:
-		return CommunicationAction::GET_WRITE;
-		break;
-	case 3:
-		return CommunicationAction::SEND_READ;
-		break;
-	case 4:
-		return CommunicationAction::GET_READ;
-		break;
-	default:
-		break;
-	}
-	return CommunicationAction::NOTHING;
+    switch (pstStep) {
+    case 0:
+        return CommunicationAction::PERFORM_OPERATION;
+        break;
+    case 1:
+        return CommunicationAction::SEND_WRITE;
+        break;
+    case 2:
+        return CommunicationAction::GET_WRITE;
+        break;
+    case 3:
+        return CommunicationAction::SEND_READ;
+        break;
+    case 4:
+        return CommunicationAction::GET_READ;
+        break;
+    default:
+        break;
+    }
+    return CommunicationAction::NOTHING;
 }
 
 MessageQueueId_t DeviceHandlerBase::getCommandQueue() const {
-	return commandQueue->getId();
+    return commandQueue->getId();
 }
 
 void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
-	storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
-	ReturnValue_t result = getStorageData(storedRawData, &rawPacket,
-			&rawPacketLen);
-	if (result != RETURN_OK) {
-		replyReturnvalueToCommand(result, RAW_COMMAND_ID);
-		storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
-	} else {
-		cookieInfo.pendingCommand = deviceCommandMap.find(
-				(DeviceCommandId_t) RAW_COMMAND_ID);
-		cookieInfo.pendingCommand->second.isExecuting = true;
-		cookieInfo.state = COOKIE_WRITE_READY;
-	}
+    storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
+    ReturnValue_t result = getStorageData(storedRawData, &rawPacket,
+            &rawPacketLen);
+    if (result != RETURN_OK) {
+        replyReturnvalueToCommand(result, RAW_COMMAND_ID);
+        storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
+    } else {
+        cookieInfo.pendingCommand = deviceCommandMap.find(
+                (DeviceCommandId_t) RAW_COMMAND_ID);
+        cookieInfo.pendingCommand->second.isExecuting = true;
+        cookieInfo.state = COOKIE_WRITE_READY;
+    }
 }
 
 void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
-	if(powerSwitcher == nullptr) {
-		return;
-	}
-	const uint8_t *switches;
-	uint8_t numberOfSwitches = 0;
-	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
-	if (result == RETURN_OK) {
-		while (numberOfSwitches > 0) {
-			powerSwitcher->sendSwitchCommand(switches[numberOfSwitches - 1],
-					onOff);
-			numberOfSwitches--;
-		}
-	}
+    if(powerSwitcher == nullptr) {
+        return;
+    }
+    const uint8_t *switches;
+    uint8_t numberOfSwitches = 0;
+    ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
+    if (result == RETURN_OK) {
+        while (numberOfSwitches > 0) {
+            powerSwitcher->sendSwitchCommand(switches[numberOfSwitches - 1],
+                    onOff);
+            numberOfSwitches--;
+        }
+    }
 }
 
 ReturnValue_t DeviceHandlerBase::getSwitches(const uint8_t **switches,
-		uint8_t *numberOfSwitches) {
-	return DeviceHandlerBase::NO_SWITCH;
+        uint8_t *numberOfSwitches) {
+    return DeviceHandlerBase::NO_SWITCH;
 }
 
 void DeviceHandlerBase::modeChanged(void) {
 }
 
 ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
-		DeviceCommandMap::iterator command, uint8_t expectedReplies,
-		bool useAlternativeId, DeviceCommandId_t alternativeReply) {
-	DeviceReplyMap::iterator iter;
-	if (useAlternativeId) {
-		iter = deviceReplyMap.find(alternativeReply);
-	} else {
-		iter = deviceReplyMap.find(command->first);
-	}
-	if (iter != deviceReplyMap.end()) {
-		DeviceReplyInfo *info = &(iter->second);
-		info->delayCycles = info->maxDelayCycles;
-		info->command = command;
-		command->second.expectedReplies = expectedReplies;
-		return RETURN_OK;
-	} else {
-		return NO_REPLY_EXPECTED;
-	}
+        DeviceCommandMap::iterator command, uint8_t expectedReplies,
+        bool useAlternativeId, DeviceCommandId_t alternativeReply) {
+    DeviceReplyMap::iterator iter;
+    if (useAlternativeId) {
+        iter = deviceReplyMap.find(alternativeReply);
+    } else {
+        iter = deviceReplyMap.find(command->first);
+    }
+    if (iter != deviceReplyMap.end()) {
+        DeviceReplyInfo *info = &(iter->second);
+        info->delayCycles = info->maxDelayCycles;
+        info->command = command;
+        command->second.expectedReplies = expectedReplies;
+        return RETURN_OK;
+    } else {
+        return NO_REPLY_EXPECTED;
+    }
 }
 
 void DeviceHandlerBase::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
-	setMode(getBaseMode(mode));
+    setMode(getBaseMode(mode));
 }
 
 ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
-	if(powerSwitcher == nullptr) {
-		return NO_SWITCH;
-	}
-	uint8_t numberOfSwitches = 0;
-	const uint8_t *switches;
+    if(powerSwitcher == nullptr) {
+        return NO_SWITCH;
+    }
+    uint8_t numberOfSwitches = 0;
+    const uint8_t *switches;
 
-	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
-	if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
-		while (numberOfSwitches > 0) {
-			if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1])
-					== PowerSwitchIF::SWITCH_OFF) {
-				return PowerSwitchIF::SWITCH_OFF;
-			}
-			numberOfSwitches--;
-		}
-		return PowerSwitchIF::SWITCH_ON;
-	}
+    ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
+    if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
+        while (numberOfSwitches > 0) {
+            if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1])
+                    == PowerSwitchIF::SWITCH_OFF) {
+                return PowerSwitchIF::SWITCH_OFF;
+            }
+            numberOfSwitches--;
+        }
+        return PowerSwitchIF::SWITCH_ON;
+    }
 
-	return NO_SWITCH;
+    return NO_SWITCH;
 }
 
 Mode_t DeviceHandlerBase::getBaseMode(Mode_t transitionMode) {
-	// only child action special modes are handled, as a child should
-	// never see any base action modes
-	if (transitionMode == _MODE_START_UP) {
-		return _MODE_TO_ON;
-	}
-	if (transitionMode == _MODE_SHUT_DOWN) {
-		return _MODE_POWER_DOWN;
-	}
-	return transitionMode
-			& ~(TRANSITION_MODE_BASE_ACTION_MASK
-					| TRANSITION_MODE_CHILD_ACTION_MASK);
+    // only child action special modes are handled, as a child should
+    // never see any base action modes
+    if (transitionMode == _MODE_START_UP) {
+        return _MODE_TO_ON;
+    }
+    if (transitionMode == _MODE_SHUT_DOWN) {
+        return _MODE_POWER_DOWN;
+    }
+    return transitionMode
+            & ~(TRANSITION_MODE_BASE_ACTION_MASK
+                    | TRANSITION_MODE_CHILD_ACTION_MASK);
 }
 
 //SHOULDDO: Allow transition from OFF to NORMAL to reduce complexity in assemblies. And, by the way, throw away DHB and write a new one:
@@ -985,127 +985,127 @@ Mode_t DeviceHandlerBase::getBaseMode(Mode_t transitionMode) {
 // - Don't use modes for state transitions, reduce FSM (Finte State Machine) complexity.
 // - Modularization?
 ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
-		Submode_t commandedSubmode, uint32_t* msToReachTheMode) {
-	if (isTransitionalMode()) {
-		return IN_TRANSITION;
-	}
-	if ((mode == MODE_ERROR_ON) && (commandedMode != MODE_OFF)) {
-		return TRANS_NOT_ALLOWED;
-	}
-	if ((commandedMode == MODE_NORMAL) && (mode == MODE_OFF)) {
-		return TRANS_NOT_ALLOWED;
-	}
+        Submode_t commandedSubmode, uint32_t* msToReachTheMode) {
+    if (isTransitionalMode()) {
+        return IN_TRANSITION;
+    }
+    if ((mode == MODE_ERROR_ON) && (commandedMode != MODE_OFF)) {
+        return TRANS_NOT_ALLOWED;
+    }
+    if ((commandedMode == MODE_NORMAL) && (mode == MODE_OFF)) {
+        return TRANS_NOT_ALLOWED;
+    }
 
-	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
-			and (thermalSet != nullptr)) {
-		ReturnValue_t result = thermalSet->read();
-		if(result == HasReturnvaluesIF::RETURN_OK) {
-			if((thermalSet->heaterRequest.value !=
-					ThermalComponentIF::STATE_REQUEST_IGNORE) and (not
-					ThermalComponentIF::isOperational(
-							thermalSet->thermalState.value))) {
-				triggerEvent(ThermalComponentIF::TEMP_NOT_IN_OP_RANGE,
-						thermalSet->thermalState.value);
-				return NON_OP_TEMPERATURE;
-			}
-		}
-	}
+    if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
+            and (thermalSet != nullptr)) {
+        ReturnValue_t result = thermalSet->read();
+        if(result == HasReturnvaluesIF::RETURN_OK) {
+            if((thermalSet->heaterRequest.value !=
+                    ThermalComponentIF::STATE_REQUEST_IGNORE) and (not
+                            ThermalComponentIF::isOperational(
+                                    thermalSet->thermalState.value))) {
+                triggerEvent(ThermalComponentIF::TEMP_NOT_IN_OP_RANGE,
+                        thermalSet->thermalState.value);
+                return NON_OP_TEMPERATURE;
+            }
+        }
+    }
 
-	return isModeCombinationValid(commandedMode, commandedSubmode);
+    return isModeCombinationValid(commandedMode, commandedSubmode);
 }
 
 void DeviceHandlerBase::startTransition(Mode_t commandedMode,
-		Submode_t commandedSubmode) {
-	switch (commandedMode) {
-	case MODE_ON:
-		handleTransitionToOnMode(commandedMode, commandedSubmode);
-		break;
-	case MODE_OFF:
-		if (mode == MODE_OFF) {
-			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-			setMode(_MODE_POWER_DOWN, commandedSubmode);
-		} else {
-			// already set the delay for the child transition
-			// so we don't need to call it twice
-			childTransitionDelay = getTransitionDelayMs(mode, _MODE_POWER_DOWN);
-			transitionSourceMode = _MODE_POWER_DOWN;
-			transitionSourceSubMode = commandedSubmode;
-			childTransitionFailure = CHILD_TIMEOUT;
-			setMode(_MODE_SHUT_DOWN, commandedSubmode);
-			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-		}
-		break;
-	case MODE_RAW:
-		if (mode != MODE_OFF) {
-			setTransition(MODE_RAW, commandedSubmode);
-		} else {
-			setMode(MODE_RAW, commandedSubmode);
-		}
-		break;
-	case MODE_NORMAL:
-		if (mode != MODE_OFF) {
-			setTransition(MODE_NORMAL, commandedSubmode);
-		} else {
-			replyReturnvalueToCommand(HasModesIF::TRANS_NOT_ALLOWED);
-		}
-		break;
-	}
+        Submode_t commandedSubmode) {
+    switch (commandedMode) {
+    case MODE_ON:
+        handleTransitionToOnMode(commandedMode, commandedSubmode);
+        break;
+    case MODE_OFF:
+        if (mode == MODE_OFF) {
+            triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
+            setMode(_MODE_POWER_DOWN, commandedSubmode);
+        } else {
+            // already set the delay for the child transition
+            // so we don't need to call it twice
+            childTransitionDelay = getTransitionDelayMs(mode, _MODE_POWER_DOWN);
+            transitionSourceMode = _MODE_POWER_DOWN;
+            transitionSourceSubMode = commandedSubmode;
+            childTransitionFailure = CHILD_TIMEOUT;
+            setMode(_MODE_SHUT_DOWN, commandedSubmode);
+            triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
+        }
+        break;
+    case MODE_RAW:
+        if (mode != MODE_OFF) {
+            setTransition(MODE_RAW, commandedSubmode);
+        } else {
+            setMode(MODE_RAW, commandedSubmode);
+        }
+        break;
+    case MODE_NORMAL:
+        if (mode != MODE_OFF) {
+            setTransition(MODE_NORMAL, commandedSubmode);
+        } else {
+            replyReturnvalueToCommand(HasModesIF::TRANS_NOT_ALLOWED);
+        }
+        break;
+    }
 }
 
 void DeviceHandlerBase::handleTransitionToOnMode(Mode_t commandedMode,
-		Submode_t commandedSubmode) {
-	if (mode == MODE_OFF) {
-		transitionSourceMode = _MODE_POWER_DOWN;
-		transitionSourceSubMode = SUBMODE_NONE;
-		setMode(_MODE_POWER_ON, commandedSubmode);
-		// already set the delay for the child transition so we don't
-		// need to call it twice
-		childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
-				MODE_ON);
-		triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-		if(thermalSet != nullptr) {
-			ReturnValue_t result = thermalSet->read();
-			if(result == HasReturnvaluesIF::RETURN_OK) {
-				if(thermalSet->heaterRequest !=
-						ThermalComponentIF::STATE_REQUEST_IGNORE) {
-					thermalSet->heaterRequest =
-							ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
-					thermalSet->commit();
-				}
-			}
-		}
-	} else {
-		setTransition(MODE_ON, commandedSubmode);
-	}
+        Submode_t commandedSubmode) {
+    if (mode == MODE_OFF) {
+        transitionSourceMode = _MODE_POWER_DOWN;
+        transitionSourceSubMode = SUBMODE_NONE;
+        setMode(_MODE_POWER_ON, commandedSubmode);
+        // already set the delay for the child transition so we don't
+        // need to call it twice
+        childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
+                MODE_ON);
+        triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
+        if(thermalSet != nullptr) {
+            ReturnValue_t result = thermalSet->read();
+            if(result == HasReturnvaluesIF::RETURN_OK) {
+                if(thermalSet->heaterRequest !=
+                        ThermalComponentIF::STATE_REQUEST_IGNORE) {
+                    thermalSet->heaterRequest =
+                            ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
+                    thermalSet->commit();
+                }
+            }
+        }
+    } else {
+        setTransition(MODE_ON, commandedSubmode);
+    }
 }
 
 void DeviceHandlerBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
+    *mode = this->mode;
+    *submode = this->submode;
 }
 
 void DeviceHandlerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
+    healthHelper.setHealth(EXTERNAL_CONTROL);
 }
 
 void DeviceHandlerBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
+    triggerEvent(MODE_INFO, mode, submode);
 }
 
 bool DeviceHandlerBase::dontCheckQueue() {
-	return false;
+    return false;
 }
 
 void DeviceHandlerBase::missedReply(DeviceCommandId_t id) {
-	if (ignoreMissedRepliesCount > 0) {
-		ignoreMissedRepliesCount--;
-	} else {
-		triggerEvent(DEVICE_MISSED_REPLY, id);
-	}
+    if (ignoreMissedRepliesCount > 0) {
+        ignoreMissedRepliesCount--;
+    } else {
+        triggerEvent(DEVICE_MISSED_REPLY, id);
+    }
 }
 
 HasHealthIF::HealthState DeviceHandlerBase::getHealth() {
-	return healthHelper.getHealth();
+    return healthHelper.getHealth();
 }
 
 ReturnValue_t DeviceHandlerBase::setHealth(HealthState health) {
@@ -1114,92 +1114,92 @@ ReturnValue_t DeviceHandlerBase::setHealth(HealthState health) {
 }
 
 void DeviceHandlerBase::checkSwitchState() {
-	if ((mode == MODE_ON || mode == MODE_NORMAL)) {
-		//We only check in ON and NORMAL, ignore RAW and ERROR_ON.
-		ReturnValue_t result = getStateOfSwitches();
-		if (result == PowerSwitchIF::SWITCH_OFF && !switchOffWasReported) {
-			triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
-			switchOffWasReported = true;
-		}
-	} else {
-		switchOffWasReported = false;
-	}
+    if ((mode == MODE_ON || mode == MODE_NORMAL)) {
+        //We only check in ON and NORMAL, ignore RAW and ERROR_ON.
+        ReturnValue_t result = getStateOfSwitches();
+        if (result == PowerSwitchIF::SWITCH_OFF && !switchOffWasReported) {
+            triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
+            switchOffWasReported = true;
+        }
+    } else {
+        switchOffWasReported = false;
+    }
 }
 
 void DeviceHandlerBase::doOnActivity() {
 }
 
 ReturnValue_t DeviceHandlerBase::acceptExternalDeviceCommands() {
-	if ((mode != MODE_ON) && (mode != MODE_NORMAL)) {
-		return WRONG_MODE_FOR_COMMAND;
-	}
-	return RETURN_OK;
+    if ((mode != MODE_ON) && (mode != MODE_NORMAL)) {
+        return WRONG_MODE_FOR_COMMAND;
+    }
+    return RETURN_OK;
 }
 
 void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
-		size_t len) {
-	if ((wiretappingMode == RAW)
-			&& (defaultRawReceiver == requestedRawTraffic)) {
-		//The raw packet was already sent by the wiretapping service
-	} else {
-		replyRawData(data, len, defaultRawReceiver);
-	}
+        size_t len) {
+    if ((wiretappingMode == RAW)
+            && (defaultRawReceiver == requestedRawTraffic)) {
+        //The raw packet was already sent by the wiretapping service
+    } else {
+        replyRawData(data, len, defaultRawReceiver);
+    }
 }
 
 ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
-		CommandMessage * message) {
-	switch (message->getCommand()) {
-	case DeviceHandlerMessage::CMD_WIRETAPPING:
-		switch (DeviceHandlerMessage::getWiretappingMode(message)) {
-		case RAW:
-			wiretappingMode = RAW;
-			requestedRawTraffic = commandQueue->getLastPartner();
-			break;
-		case TM:
-			wiretappingMode = TM;
-			requestedRawTraffic = commandQueue->getLastPartner();
-			break;
-		case OFF:
-			wiretappingMode = OFF;
-			break;
-		default:
-			replyReturnvalueToCommand(INVALID_COMMAND_PARAMETER);
-			wiretappingMode = OFF;
-			return RETURN_OK;
-		}
-		replyReturnvalueToCommand(RETURN_OK);
-		return RETURN_OK;
-	case DeviceHandlerMessage::CMD_RAW:
-		if ((mode != MODE_RAW)) {
-			DeviceHandlerMessage::clear(message);
-			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-		} else {
-			buildRawDeviceCommand(message);
-		}
-		return RETURN_OK;
-	default:
-		return RETURN_FAILED;
-	}
+        CommandMessage * message) {
+    switch (message->getCommand()) {
+    case DeviceHandlerMessage::CMD_WIRETAPPING:
+        switch (DeviceHandlerMessage::getWiretappingMode(message)) {
+        case RAW:
+            wiretappingMode = RAW;
+            requestedRawTraffic = commandQueue->getLastPartner();
+            break;
+        case TM:
+            wiretappingMode = TM;
+            requestedRawTraffic = commandQueue->getLastPartner();
+            break;
+        case OFF:
+            wiretappingMode = OFF;
+            break;
+        default:
+            replyReturnvalueToCommand(INVALID_COMMAND_PARAMETER);
+            wiretappingMode = OFF;
+            return RETURN_OK;
+        }
+        replyReturnvalueToCommand(RETURN_OK);
+        return RETURN_OK;
+        case DeviceHandlerMessage::CMD_RAW:
+            if ((mode != MODE_RAW)) {
+                DeviceHandlerMessage::clear(message);
+                replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
+            } else {
+                buildRawDeviceCommand(message);
+            }
+            return RETURN_OK;
+        default:
+            return RETURN_FAILED;
+    }
 }
 
 void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
-	modeHelper.setParentQueue(parentQueueId);
-	healthHelper.setParentQueue(parentQueueId);
+    modeHelper.setParentQueue(parentQueueId);
+    healthHelper.setParentQueue(parentQueueId);
 }
 
 bool DeviceHandlerBase::isAwaitingReply() {
-	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter;
-	for (iter = deviceReplyMap.begin(); iter != deviceReplyMap.end(); ++iter) {
-		if (iter->second.delayCycles != 0) {
-			return true;
-		}
-	}
-	return false;
+    std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter;
+    for (iter = deviceReplyMap.begin(); iter != deviceReplyMap.end(); ++iter) {
+        if (iter->second.delayCycles != 0) {
+            return true;
+        }
+    }
+    return false;
 }
 
 ReturnValue_t DeviceHandlerBase::letChildHandleMessage(
-		CommandMessage * message) {
-	return RETURN_FAILED;
+        CommandMessage * message) {
+    return RETURN_FAILED;
 }
 
 void DeviceHandlerBase::handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId,
@@ -1208,229 +1208,225 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t r
         return;
     }
 
-	DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
-	if (iter == deviceReplyMap.end()) {
-		triggerEvent(DEVICE_UNKNOWN_REPLY, replyId);
-		return;
-	}
+    DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
+    if (iter == deviceReplyMap.end()) {
+        triggerEvent(DEVICE_UNKNOWN_REPLY, replyId);
+        return;
+    }
 
-	/* Regular replies to a command */
-	if (iter->second.command != deviceCommandMap.end())
-	{
-		MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;
+    /* Regular 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, dataSet);
-		}
+        if (queueId != NO_COMMANDER) {
+            /* This may fail, but we'll ignore the fault. */
+            actionHelper.reportData(queueId, replyId, dataSet);
+        }
 
-		/* This check should make sure we get any TM but don't get anything doubled. */
-		if (wiretappingMode == TM && (requestedRawTraffic != queueId)) {
+        /* This check should make sure we get any TM but don't get anything doubled. */
+        if (wiretappingMode == TM && (requestedRawTraffic != queueId)) {
             DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataSet);
-			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
-		}
+            actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
+        }
 
-		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, dataSet, true);
-		}
-	}
-	/* Unrequested or aperiodic replies */
-	else
-	{
-	    DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataSet);
-		if (wiretappingMode == TM) {
-			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
-		}
-		if (forceDirectTm and defaultRawReceiver != MessageQueueIF::NO_QUEUE)
-		{
-//		    sid_t setSid = sid_t(this->getObjectId(), replyId);
-//		    LocalPoolDataSetBase* dataset = getDataSetHandle(setSid);
-//		    if(dataset != nullptr) {
-//	            poolManager.generateHousekeepingPacket(setSid, dataset, true);
-//		    }
+        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, dataSet, true);
+        }
+    }
+    /* Unrequested or aperiodic replies */
+    else
+    {
+        DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataSet);
+        if (wiretappingMode == TM) {
+            actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
+        }
+        if (forceDirectTm and defaultRawReceiver != MessageQueueIF::NO_QUEUE)
+        {
+            //		    sid_t setSid = sid_t(this->getObjectId(), replyId);
+            //		    LocalPoolDataSetBase* dataset = getDataSetHandle(setSid);
+            //		    if(dataset != nullptr) {
+            //	            poolManager.generateHousekeepingPacket(setSid, dataset, true);
+            //		    }
 
-			// 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);
-		}
-	}
+            // 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);
+        }
+    }
 }
 
 ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
-	ReturnValue_t result = acceptExternalDeviceCommands();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
-	if (iter == deviceCommandMap.end()) {
-		result = COMMAND_NOT_SUPPORTED;
-	} else if (iter->second.isExecuting) {
-		result = COMMAND_ALREADY_SENT;
-	} else {
-		result = buildCommandFromCommand(actionId, data, size);
-	}
-	if (result == RETURN_OK) {
-		iter->second.sendReplyTo = commandedBy;
-		iter->second.isExecuting = true;
-		cookieInfo.pendingCommand = iter;
-		cookieInfo.state = COOKIE_WRITE_READY;
-	}
-	return result;
+        MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
+    ReturnValue_t result = acceptExternalDeviceCommands();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
+    if (iter == deviceCommandMap.end()) {
+        result = COMMAND_NOT_SUPPORTED;
+    } else if (iter->second.isExecuting) {
+        result = COMMAND_ALREADY_SENT;
+    } else {
+        result = buildCommandFromCommand(actionId, data, size);
+    }
+    if (result == RETURN_OK) {
+        iter->second.sendReplyTo = commandedBy;
+        iter->second.isExecuting = true;
+        cookieInfo.pendingCommand = iter;
+        cookieInfo.state = COOKIE_WRITE_READY;
+    }
+    return result;
 }
 
 void DeviceHandlerBase::buildInternalCommand(void) {
     /* Neither raw nor direct could build a command */
-	ReturnValue_t result = NOTHING_TO_SEND;
-	DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
-	if (mode == MODE_NORMAL) {
-		result = buildNormalDeviceCommand(&deviceCommandId);
-		if (result == BUSY) {
-		    /* So we can track misconfigurations */
-			printWarningOrError(sif::OutputTypes::OUT_WARNING, "buildInternalCommand",
-					HasReturnvaluesIF::RETURN_FAILED, "Busy.");
-			/* No need to report this */
-			result = NOTHING_TO_SEND;
-		}
-	}
-	else if (mode == MODE_RAW) {
-		result = buildChildRawCommand();
-		deviceCommandId = RAW_COMMAND_ID;
-	}
-	else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
-		result = buildTransitionDeviceCommand(&deviceCommandId);
-	}
-	else {
-		return;
-	}
+    ReturnValue_t result = NOTHING_TO_SEND;
+    DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
+    if (mode == MODE_NORMAL) {
+        result = buildNormalDeviceCommand(&deviceCommandId);
+        if (result == BUSY) {
+            /* So we can track misconfigurations */
+            printWarningOrError(sif::OutputTypes::OUT_WARNING, "buildInternalCommand",
+                    HasReturnvaluesIF::RETURN_FAILED, "Busy.");
+            /* No need to report this */
+            result = NOTHING_TO_SEND;
+        }
+    }
+    else if (mode == MODE_RAW) {
+        result = buildChildRawCommand();
+        deviceCommandId = RAW_COMMAND_ID;
+    }
+    else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
+        result = buildTransitionDeviceCommand(&deviceCommandId);
+    }
+    else {
+        return;
+    }
 
-	if (result == NOTHING_TO_SEND) {
-		return;
-	}
-	if (result == RETURN_OK) {
-		DeviceCommandMap::iterator iter = deviceCommandMap.find(
-				deviceCommandId);
-		if (iter == deviceCommandMap.end()) {
-			result = COMMAND_NOT_SUPPORTED;
-		}
-		else if (iter->second.isExecuting) {
+    if (result == NOTHING_TO_SEND) {
+        return;
+    }
+    if (result == RETURN_OK) {
+        DeviceCommandMap::iterator iter = deviceCommandMap.find(
+                deviceCommandId);
+        if (iter == deviceCommandMap.end()) {
+            result = COMMAND_NOT_SUPPORTED;
+        }
+        else if (iter->second.isExecuting) {
 #if FSFW_DISABLE_PRINTOUT == 0
-			char output[36];
-			sprintf(output, "Command 0x%08x is executing",
-					static_cast<unsigned int>(deviceCommandId));
-			// so we can track misconfigurations
-			printWarningOrError(sif::OutputTypes::OUT_WARNING,
-					"buildInternalCommand",
-					HasReturnvaluesIF::RETURN_FAILED,
-					output);
+            char output[36];
+            sprintf(output, "Command 0x%08x is executing",
+                    static_cast<unsigned int>(deviceCommandId));
+            // so we can track misconfigurations
+            printWarningOrError(sif::OutputTypes::OUT_WARNING,
+                    "buildInternalCommand",
+                    HasReturnvaluesIF::RETURN_FAILED,
+                    output);
 #endif
-			// this is an internal command, no need to report a failure here,
-			// missed reply will track if a reply is too late, otherwise, it's ok
-			return;
-		} else {
-			iter->second.sendReplyTo = NO_COMMANDER;
-			iter->second.isExecuting = true;
-			cookieInfo.pendingCommand = iter;
-			cookieInfo.state = COOKIE_WRITE_READY;
-		}
-	}
-	if (result != RETURN_OK) {
-		triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
-	}
+            // this is an internal command, no need to report a failure here,
+            // missed reply will track if a reply is too late, otherwise, it's ok
+            return;
+        } else {
+            iter->second.sendReplyTo = NO_COMMANDER;
+            iter->second.isExecuting = true;
+            cookieInfo.pendingCommand = iter;
+            cookieInfo.state = COOKIE_WRITE_READY;
+        }
+    }
+    if (result != RETURN_OK) {
+        triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
+    }
 }
 
 ReturnValue_t DeviceHandlerBase::buildChildRawCommand() {
-	return NOTHING_TO_SEND;
+    return NOTHING_TO_SEND;
 }
 
 uint8_t DeviceHandlerBase::getReplyDelayCycles(
-		DeviceCommandId_t deviceCommand) {
-	DeviceReplyMap::iterator iter = deviceReplyMap.find(deviceCommand);
-	if (iter == deviceReplyMap.end()) {
-		return 0;
-	}
-	return iter->second.delayCycles;
+        DeviceCommandId_t deviceCommand) {
+    DeviceReplyMap::iterator iter = deviceReplyMap.find(deviceCommand);
+    if (iter == deviceReplyMap.end()) {
+        return 0;
+    }
+    return iter->second.delayCycles;
 }
 
 Mode_t DeviceHandlerBase::getTransitionSourceMode() const {
-	return transitionSourceMode;
+    return transitionSourceMode;
 }
 
 Submode_t DeviceHandlerBase::getTransitionSourceSubMode() const {
-	return transitionSourceSubMode;
+    return transitionSourceSubMode;
 }
 
 void DeviceHandlerBase::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	fdirInstance->triggerEvent(event, parameter1, parameter2);
+        uint32_t parameter2) {
+    fdirInstance->triggerEvent(event, parameter1, parameter2);
 }
 
 void DeviceHandlerBase::forwardEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) const {
-	fdirInstance->triggerEvent(event, parameter1, parameter2);
+        uint32_t parameter2) const {
+    fdirInstance->triggerEvent(event, parameter1, parameter2);
 }
 
 void DeviceHandlerBase::doOffActivity() {
 }
 
-ReturnValue_t DeviceHandlerBase::getParameter(uint8_t domainId,
-		uint8_t uniqueId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = fdirInstance->getParameter(domainId, uniqueId, parameterWrapper,
-	        newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	return INVALID_DOMAIN_ID;
+ReturnValue_t DeviceHandlerBase::getParameter(uint8_t domainId, uint8_t uniqueId,
+        ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+        uint16_t startAtIndex) {
+    ReturnValue_t result = fdirInstance->getParameter(domainId, uniqueId, parameterWrapper,
+            newValues, startAtIndex);
+    if (result != INVALID_DOMAIN_ID) {
+        return result;
+    }
+    return INVALID_DOMAIN_ID;
 
 }
 
 bool DeviceHandlerBase::isTransitionalMode() {
-	return ((mode
-			& (TRANSITION_MODE_BASE_ACTION_MASK
-					| TRANSITION_MODE_CHILD_ACTION_MASK)) != 0);
+    return ((mode
+            & (TRANSITION_MODE_BASE_ACTION_MASK
+                    | TRANSITION_MODE_CHILD_ACTION_MASK)) != 0);
 }
 
 bool DeviceHandlerBase::commandIsExecuting(DeviceCommandId_t commandId) {
-	auto iter = deviceCommandMap.find(commandId);
-	if (iter != deviceCommandMap.end()) {
-		return iter->second.isExecuting;
-	} else {
-		return false;
-	}
+    auto iter = deviceCommandMap.find(commandId);
+    if (iter != deviceCommandMap.end()) {
+        return iter->second.isExecuting;
+    } else {
+        return false;
+    }
 
 }
 
-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) {}
+        object_id_t objectId, uint32_t parameter) {}
 
 void DeviceHandlerBase::performOperationHook() {
 }
 
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
-		localpool::DataPool &localDataPoolMap,
+        localpool::DataPool &localDataPoolMap,
         LocalDataPoolManager& poolManager) {
-	if(thermalSet != nullptr) {
-		localDataPoolMap.emplace(thermalSet->thermalStatePoolId,
-				new PoolEntry<DeviceHandlerIF::dh_thermal_state_t>);
-		localDataPoolMap.emplace(thermalSet->heaterRequestPoolId,
-				new PoolEntry<DeviceHandlerIF::dh_heater_request_t>);
-	}
-	return RETURN_OK;
+    if(thermalSet != nullptr) {
+        localDataPoolMap.emplace(thermalSet->thermalStatePoolId,
+                new PoolEntry<DeviceHandlerIF::dh_thermal_state_t>);
+        localDataPoolMap.emplace(thermalSet->heaterRequestPoolId,
+                new PoolEntry<DeviceHandlerIF::dh_heater_request_t>);
+    }
+    return RETURN_OK;
 }
 
 ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
@@ -1448,13 +1444,13 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
 }
 
 LocalPoolDataSetBase* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
-	auto iter = deviceReplyMap.find(sid.ownerSetId);
-	if(iter != deviceReplyMap.end()) {
-		return iter->second.dataSet;
-	}
-	else {
-		return nullptr;
-	}
+    auto iter = deviceReplyMap.find(sid.ownerSetId);
+    if(iter != deviceReplyMap.end()) {
+        return iter->second.dataSet;
+    }
+    else {
+        return nullptr;
+    }
 }
 
 object_id_t DeviceHandlerBase::getObjectId() const {
@@ -1477,55 +1473,55 @@ DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
 }
 
 void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
-	for(const auto& reply: deviceReplyMap) {
-		if(reply.second.dataSet != nullptr) {
-			reply.second.dataSet->setValidity(false, true);
-		}
-	}
+    for(const auto& reply: deviceReplyMap) {
+        if(reply.second.dataSet != nullptr) {
+            reply.second.dataSet->setValidity(false, true);
+        }
+    }
 }
 
 void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
-		const char *functionName, ReturnValue_t errorCode,
-		const char *errorPrint) {
-	if(errorPrint == nullptr) {
-		if(errorCode == ObjectManagerIF::CHILD_INIT_FAILED) {
-			errorPrint = "Initialization error";
-		}
-		if(errorCode == HasReturnvaluesIF::RETURN_FAILED) {
-			if(errorType == sif::OutputTypes::OUT_WARNING) {
-				errorPrint = "Generic Warning";
-			}
-			else {
-				errorPrint = "Generic Error";
-			}
-		}
-		else {
-			errorPrint = "Unknown error";
-		}
-	}
+        const char *functionName, ReturnValue_t errorCode,
+        const char *errorPrint) {
+    if(errorPrint == nullptr) {
+        if(errorCode == ObjectManagerIF::CHILD_INIT_FAILED) {
+            errorPrint = "Initialization error";
+        }
+        if(errorCode == HasReturnvaluesIF::RETURN_FAILED) {
+            if(errorType == sif::OutputTypes::OUT_WARNING) {
+                errorPrint = "Generic Warning";
+            }
+            else {
+                errorPrint = "Generic Error";
+            }
+        }
+        else {
+            errorPrint = "Unknown error";
+        }
+    }
 
-	if(errorType == sif::OutputTypes::OUT_WARNING) {
+    if(errorType == sif::OutputTypes::OUT_WARNING) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "DeviceHandlerBase::" << functionName << ": Object ID "
-				<< std::hex << std::setw(8) << std::setfill('0')
-				<< this->getObjectId() << " | " << errorPrint << std::dec
-				<< std::setfill(' ') << std::endl;
+        sif::warning << "DeviceHandlerBase::" << functionName << ": Object ID "
+                << std::hex << std::setw(8) << std::setfill('0')
+                << this->getObjectId() << " | " << errorPrint << std::dec
+                << std::setfill(' ') << std::endl;
 #else
-		sif::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
-				this->getObjectId(), errorPrint);
+        sif::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+                this->getObjectId(), errorPrint);
 #endif
-	}
-	else if(errorType == sif::OutputTypes::OUT_ERROR) {
+    }
+    else if(errorType == sif::OutputTypes::OUT_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DeviceHandlerBase::" << functionName << ": Object ID "
-				<< std::hex << std::setw(8) << std::setfill('0')
-				<< this->getObjectId() << " | " << errorPrint << std::dec
-				<< std::setfill(' ') << std::endl;
+        sif::error << "DeviceHandlerBase::" << functionName << ": Object ID "
+                << std::hex << std::setw(8) << std::setfill('0')
+                << this->getObjectId() << " | " << errorPrint << std::dec
+                << std::setfill(' ') << std::endl;
 #else
-		sif::printError("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
-				this->getObjectId(), errorPrint);
+        sif::printError("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+                this->getObjectId(), errorPrint);
 #endif
-	}
+    }
 
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index e75d2729d..1d4a44248 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -20,7 +20,6 @@
 #include "../action/ActionHelper.h"
 #include "../health/HealthHelper.h"
 #include "../parameters/ParameterHelper.h"
-#include "../datapool/HkSwitchHelper.h"
 #include "../datapoollocal/HasLocalDataPoolIF.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 
@@ -80,114 +79,113 @@ class StorageManagerIF;
  * @ingroup devices
  */
 class DeviceHandlerBase: public DeviceHandlerIF,
-		public HasReturnvaluesIF,
-		public ExecutableObjectIF,
-		public SystemObject,
-		public HasModesIF,
-		public HasHealthIF,
-		public HasActionsIF,
-		public ReceivesParameterMessagesIF,
-		public HasLocalDataPoolIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
+public HasReturnvaluesIF,
+public ExecutableObjectIF,
+public SystemObject,
+public HasModesIF,
+public HasHealthIF,
+public HasActionsIF,
+public ReceivesParameterMessagesIF,
+public HasLocalDataPoolIF {
+    friend void (Factory::setStaticFrameworkObjectIds)();
 public:
-	/**
-	 * The constructor passes the objectId to the SystemObject().
-	 *
-	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param deviceCommuncation Communcation Interface object which is used
-	 * to implement communication functions
-	 * @param comCookie This object will be passed to the communication inter-
-	 * face and can contain user-defined information about the communication.
-	 * @param fdirInstance
-	 * @param cmdQueueSize
-	 */
-	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * comCookie, FailureIsolationBase* fdirInstance = nullptr,
-			size_t cmdQueueSize = 20);
+    /**
+     * The constructor passes the objectId to the SystemObject().
+     *
+     * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
+     * @param deviceCommuncation Communcation Interface object which is used
+     * to implement communication functions
+     * @param comCookie This object will be passed to the communication inter-
+     * face and can contain user-defined information about the communication.
+     * @param fdirInstance
+     * @param cmdQueueSize
+     */
+    DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+            CookieIF * comCookie, FailureIsolationBase* fdirInstance = nullptr,
+            size_t cmdQueueSize = 20);
 
-	void setHkDestination(object_id_t hkDestination);
+    void setHkDestination(object_id_t hkDestination);
 
-	/**
-	 * If the device handler is controlled by the FSFW thermal building blocks,
-	 * this function should be called to initialize all required components.
-	 * The device handler will then take care of creating local pool entries
-	 * for the device thermal state and device heating request.
-	 * Custom local pool IDs can be assigned as well.
-	 * @param thermalStatePoolId
-	 * @param thermalRequestPoolId
-	 */
-	void setThermalStateRequestPoolIds(lp_id_t thermalStatePoolId =
-			DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
-			lp_id_t thermalRequestPoolId =
-			DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID,
-			uint32_t thermalSetId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID);
-	/**
-	 * @brief   Helper function to ease device handler development.
-	 * This will instruct the transition to MODE_ON immediately
-	 * (leading to doStartUp() being called for the transition to the ON mode),
-	 * so external mode commanding is not necessary anymore.
-	 *
-	 * This has to be called before the task is started!
-	 * (e.g. in the task factory). This is only a helper function for
-	 * development. Regular mode commanding should be performed by commanding
-	 * the AssemblyBase or Subsystem objects resposible for the device handler.
-	 */
-	void setStartUpImmediately();
+    /**
+     * If the device handler is controlled by the FSFW thermal building blocks,
+     * this function should be called to initialize all required components.
+     * The device handler will then take care of creating local pool entries
+     * for the device thermal state and device heating request.
+     * Custom local pool IDs can be assigned as well.
+     * @param thermalStatePoolId
+     * @param thermalRequestPoolId
+     */
+    void setThermalStateRequestPoolIds(lp_id_t thermalStatePoolId =
+            DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
+            lp_id_t thermalRequestPoolId =
+                    DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID,
+                    uint32_t thermalSetId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID);
+    /**
+     * @brief   Helper function to ease device handler development.
+     * This will instruct the transition to MODE_ON immediately
+     * (leading to doStartUp() being called for the transition to the ON mode),
+     * so external mode commanding is not necessary anymore.
+     *
+     * This has to be called before the task is started!
+     * (e.g. in the task factory). This is only a helper function for
+     * development. Regular mode commanding should be performed by commanding
+     * the AssemblyBase or Subsystem objects resposible for the device handler.
+     */
+    void setStartUpImmediately();
 
-	/**
-	 * @brief 	This function is the device handler base core component and is
-	 * 			called periodically.
-	 * @details
-	 * General sequence, showing where abstract virtual functions are called:
-	 * If the State is SEND_WRITE:
-	 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
-	 *   2. Handles Device State Modes by calling doStateMachine().
-	 *      This function calls callChildStatemachine() which calls the
-	 *      abstract functions doStartUp() and doShutDown()
-	 *   3. Check switch states by calling checkSwitchStates()
-	 *   4. Decrements counter for timeout of replies by calling
-	 *      decrementDeviceReplyMap()
-	 *   5. Performs FDIR check for failures
-	 *   6. Calls hkSwitcher.performOperation()
-	 *   7. If the device mode is MODE_OFF, return RETURN_OK.
+    /**
+     * @brief 	This function is the device handler base core component and is
+     * 			called periodically.
+     * @details
+     * General sequence, showing where abstract virtual functions are called:
+     * If the State is SEND_WRITE:
+     *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
+     *   2. Handles Device State Modes by calling doStateMachine().
+     *      This function calls callChildStatemachine() which calls the
+     *      abstract functions doStartUp() and doShutDown()
+     *   3. Check switch states by calling checkSwitchStates()
+     *   4. Decrements counter for timeout of replies by calling
+     *      decrementDeviceReplyMap()
+     *   5. Performs FDIR check for failures
+     *   6. If the device mode is MODE_OFF, return RETURN_OK.
      *      Otherwise, perform the Action property and performs depending
      *      on value specified by input value counter (incremented in PST).
      *      The child class tells base class what to do by setting this value.
-	 *     - SEND_WRITE: Send data or commands to device by calling
-	 *       doSendWrite() which calls sendMessage function
-	 *       of #communicationInterface
-	 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
-	 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite()
-	 *       which calls getSendSuccess of #communicationInterface.
-	 *       Calls abstract functions scanForReply() and interpretDeviceReply().
-	 *     - SEND_READ: Request reading data from device by calling doSendRead()
-	 *       which calls requestReceiveMessage of #communcationInterface
-	 *     - GET_READ: Access requested reading data by calling doGetRead()
-	 *       which calls readReceivedMessage of #communicationInterface
-	 * @param counter Specifies which Action to perform
-	 * @return RETURN_OK for successful execution
-	 */
-	virtual ReturnValue_t performOperation(uint8_t counter);
+     *     - SEND_WRITE: Send data or commands to device by calling
+     *       doSendWrite() which calls sendMessage function
+     *       of #communicationInterface
+     *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
+     *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite()
+     *       which calls getSendSuccess of #communicationInterface.
+     *       Calls abstract functions scanForReply() and interpretDeviceReply().
+     *     - SEND_READ: Request reading data from device by calling doSendRead()
+     *       which calls requestReceiveMessage of #communcationInterface
+     *     - GET_READ: Access requested reading data by calling doGetRead()
+     *       which calls readReceivedMessage of #communicationInterface
+     * @param counter Specifies which Action to perform
+     * @return RETURN_OK for successful execution
+     */
+    virtual ReturnValue_t performOperation(uint8_t counter);
 
-	/**
-	 * @brief  Initializes the device handler
-	 * @details
-	 * Initialize Device Handler as system object and
-	 * initializes all important helper classes.
-	 * Calls fillCommandAndReplyMap().
-	 * @return
-	 */
-	virtual ReturnValue_t initialize();
+    /**
+     * @brief  Initializes the device handler
+     * @details
+     * Initialize Device Handler as system object and
+     * initializes all important helper classes.
+     * Calls fillCommandAndReplyMap().
+     * @return
+     */
+    virtual ReturnValue_t initialize();
 
-	/**
-	 * @brief   Intialization steps performed after all tasks have been created.
-	 *          This function will be called by the executing task.
-	 * @return
-	 */
+    /**
+     * @brief   Intialization steps performed after all tasks have been created.
+     *          This function will be called by the executing task.
+     * @return
+     */
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
-	/** Destructor. */
-	virtual ~DeviceHandlerBase();
+    /** Destructor. */
+    virtual ~DeviceHandlerBase();
 
 
     /**
@@ -222,1054 +220,1059 @@ public:
 
 
 protected:
-	/**
-	 * @brief 	This is used to let the child class handle the transition from
-	 * 			mode @c _MODE_START_UP to @c MODE_ON
-	 * @details
-	 * It is only called when the device handler is in mode @c _MODE_START_UP.
-	 * That means, the device switch(es) are already set to on.
-	 * Device handler commands are read and can be handled by the child class.
-	 * If the child class handles a command, it should also send
-	 * an reply accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE,
-	 * the base class handles rejecting the command and sends a reply.
-	 * The replies for mode transitions are handled by the base class.
-	 *
-	 *  - If the device is started and ready for operation, the mode should be
-	 *    set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
-	 *    use the to on transition if available.
-	 *  - If the power-up fails, the mode should be set to _MODE_POWER_DOWN
-	 *    which will lead to the device being powered off.
-	 *  - If the device does not change the mode, the mode will be changed
-	 *    to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay())
-	 *    has passed.
-	 *
-	 * #transitionFailure can be set to a failure code indicating the reason
-	 * for a failed transition
-	 */
-	virtual void doStartUp() = 0;
+    /**
+     * @brief 	This is used to let the child class handle the transition from
+     * 			mode @c _MODE_START_UP to @c MODE_ON
+     * @details
+     * It is only called when the device handler is in mode @c _MODE_START_UP.
+     * That means, the device switch(es) are already set to on.
+     * Device handler commands are read and can be handled by the child class.
+     * If the child class handles a command, it should also send
+     * an reply accordingly.
+     * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE,
+     * the base class handles rejecting the command and sends a reply.
+     * The replies for mode transitions are handled by the base class.
+     *
+     *  - If the device is started and ready for operation, the mode should be
+     *    set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
+     *    use the to on transition if available.
+     *  - If the power-up fails, the mode should be set to _MODE_POWER_DOWN
+     *    which will lead to the device being powered off.
+     *  - If the device does not change the mode, the mode will be changed
+     *    to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay())
+     *    has passed.
+     *
+     * #transitionFailure can be set to a failure code indicating the reason
+     * for a failed transition
+     */
+    virtual void doStartUp() = 0;
+    /**
+     * @brief 	This is used to let the child class handle the transition
+     * 			from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
+     * @details
+     * It is only called when the device handler is in mode @c _MODE_SHUT_DOWN.
+     * Device handler commands are read and can be handled by the child class.
+     * If the child class handles a command, it should also send an reply
+     * accordingly.
+     * If an Command is not handled (ie #DeviceHandlerCommand is not
+     * @c CMD_NONE, the base class handles rejecting the command and sends a
+     * reply. The replies for mode transitions are handled by the base class.
+     *
+     *  - If the device ready to be switched off,
+     *    the mode should be set to _MODE_POWER_DOWN.
+     *  - If the device should not be switched off, the mode can be changed to
+     *     _MODE_TO_ON (or MODE_ON if no transition is needed).
+     *  - If the device does not change the mode, the mode will be changed to
+     *    _MODE_POWER_DOWN, when the timeout (from getTransitionDelay())
+     *    has passed.
+     *
+     * #transitionFailure can be set to a failure code indicating the reason
+     * for a failed transition
+     */
+    virtual void doShutDown() = 0;
 
-	/**
-	 * @brief 	This is used to let the child class handle the transition
-	 * 			from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
-	 * @details
-	 * It is only called when the device handler is in mode @c _MODE_SHUT_DOWN.
-	 * Device handler commands are read and can be handled by the child class.
-	 * If the child class handles a command, it should also send an reply
-	 * accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not
-	 * @c CMD_NONE, the base class handles rejecting the command and sends a
-	 * reply. The replies for mode transitions are handled by the base class.
-	 *
-	 *  - If the device ready to be switched off,
-	 *    the mode should be set to _MODE_POWER_DOWN.
-	 *  - If the device should not be switched off, the mode can be changed to
-	 *     _MODE_TO_ON (or MODE_ON if no transition is needed).
-	 *  - If the device does not change the mode, the mode will be changed to
-	 *    _MODE_POWER_DOWN, when the timeout (from getTransitionDelay())
-	 *    has passed.
-	 *
-	 * #transitionFailure can be set to a failure code indicating the reason
-	 * for a failed transition
-	 */
-	virtual void doShutDown() = 0;
+    /* Command handling */
+    /**
+     * Build the device command to send for normal mode.
+     *
+     * This is only called in @c MODE_NORMAL. If multiple submodes for
+     * @c MODE_NORMAL are supported, different commands can built,
+     * depending on the submode.
+     *
+     * #rawPacket and #rawPacketLen must be set by this method to the
+     * packet to be sent. If variable command frequence is required, a counter
+     * can be used and the frequency in the reply map has to be set manually
+     * by calling updateReplyMap().
+     *
+     * @param[out] id the device command id that has been built
+     * @return
+     *  - @c RETURN_OK to send command after setting #rawPacket and
+     *    #rawPacketLen.
+     *  - @c NOTHING_TO_SEND when no command is to be sent.
+     *  - Anything else triggers an even with the returnvalue as a parameter.
+     */
+    virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
+    /**
+     * 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_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
+     * and filling them in doStartUp(), doShutDown() and doTransition() so no
+     * modes have to be checked here.
+     *
+     * #rawPacket and #rawPacketLen must be set by this method to the
+     * packet to be sent.
+     *
+     * @param[out] id the device command id built
+     * @return
+     *    - @c RETURN_OK when a command is to be sent
+     *    - @c NOTHING_TO_SEND when no command is to be sent
+     *    - Anything else triggers an even with the returnvalue as a parameter
+     */
+    virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
+    /**
+     * @brief 	Build a device command packet from data supplied by a direct
+     *          command (PUS Service 8)
+     * @details
+     * This will be called if an functional command via PUS Service 8 is received and is
+     * the primary interface for functional command instead of #executeAction for users. The
+     * supplied ActionId_t action ID will be converted to a DeviceCommandId_t command ID after
+     * an internal check whether the action ID is a key in the device command map.
+     *
+     * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
+     * The existence of the command in the command map and the command size check against 0 are
+     * done by the base class.
+     *
+     * @param deviceCommand     The command to build, already checked against deviceCommandMap
+     * @param commandData       Pointer to the data from the direct command
+     * @param commandDataLen    Length of commandData
+     * @return
+     *  - @c RETURN_OK to send command after #rawPacket and #rawPacketLen
+     *       have been set.
+     *  - @c HasActionsIF::EXECUTION_COMPLETE to generate a finish reply immediately. This can
+     *       be used if no reply is expected. Otherwise, the developer can call #actionHelper.finish
+     *       to finish the command handling.
+     *  - Anything else triggers an event with the return code as a parameter as well as a
+     *    step reply failed with the return code
+     */
+    virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+            const uint8_t * commandData, size_t commandDataLen) = 0;
 
-	/**
-	 * Build the device command to send for normal mode.
-	 *
-	 * This is only called in @c MODE_NORMAL. If multiple submodes for
-	 * @c MODE_NORMAL are supported, different commands can built,
-	 * depending on the submode.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the
-	 * packet to be sent. If variable command frequence is required, a counter
-	 * can be used and the frequency in the reply map has to be set manually
-	 * by calling updateReplyMap().
-	 *
-	 * @param[out] id the device command id that has been built
-	 * @return
-	 *  - @c RETURN_OK to send command after setting #rawPacket and
-	 *    #rawPacketLen.
-	 *  - @c NOTHING_TO_SEND when no command is to be sent.
-	 *  - Anything else triggers an even with the returnvalue as a parameter.
-	 */
-	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
+    /* Reply handling */
+    /**
+     * @brief   Scans a buffer for a valid reply.
+     * @details
+     * This is used by the base class to check the data received for valid packets.
+     * It only checks if a valid packet starts at @c start.
+     * It also only checks the structural validy of the packet,
+     * e.g. checksums lengths and protocol data. No information check is done,
+     * e.g. range checks etc.
+     *
+     * Errors should be reported directly, the base class does NOT report any
+     * errors based on the return value of this function.
+     *
+     * @param start start of remaining buffer to be scanned
+     * @param len length of remaining buffer to be scanned
+     * @param[out] foundId the id of the data found in the buffer.
+     * @param[out] foundLen length of the data found. Is to be set in function,
+     *                       buffer is scanned at previous position + foundLen.
+     * @return
+     *  - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
+     *  - @c RETURN_FAILED no reply could be found starting at @c start,
+     *    implies @c foundLen is not valid, base class will call scanForReply()
+     *    again with ++start
+     *  - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
+     *    e.g. checksum error, implies @c foundLen is valid, can be used to
+     *    skip some bytes
+     *  - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
+     *  - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of
+     *    the packet
+     *  - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
+     *  - @c APERIODIC_REPLY if a valid reply is received that has not been
+     *    requested by a command, but should be handled anyway
+     *    (@see also fillCommandAndCookieMap() )
+     */
+    virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+            DeviceCommandId_t *foundId, size_t *foundLen) = 0;
+    /**
+     * @brief   Interpret a reply from the device.
+     * @details
+     * This is called after scanForReply() found a valid packet, it can be
+     * assumed that the length and structure is valid.
+     * This routine extracts the data from the packet into a DataSet and then
+     * calls handleDeviceTM(), which either sends a TM packet or stores the
+     * data in the DataPool depending on whether it was an external command.
+     * No packet length is given, as it should be defined implicitly by the id.
+     *
+     * @param id the id found by scanForReply()
+     * @param packet
+     * @return
+     *     - @c RETURN_OK when the reply was interpreted.
+     *     - @c IGNORE_REPLY_DATA Ignore the reply and don't reset reply cycle
+     *          counter.
+     *     - @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;
+    MessageQueueId_t getCommanderId(DeviceCommandId_t replyId) const;
+    /**
+     * Helper function to get pending command. This is useful for devices
+     * like SPI sensors to identify the last sent command.
+     * This only returns the command sent in the last SEND_WRITE cycle.
+     * @return
+     */
+    DeviceCommandId_t getPendingCommand() const;
 
-	/**
-	 * 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_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
-	 * and filling them in doStartUp(), doShutDown() and doTransition() so no
-	 * modes have to be checked here.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the
-	 * packet to be sent.
-	 *
-	 * @param[out] id the device command id built
-	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - @c NOTHING_TO_SEND when no command is to be sent
-	 *    - Anything else triggers an even with the returnvalue as a parameter
-	 */
-	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
+    /* Specifying commands and replies */
+    /**
+     * @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.
+     * There are different scenarios regarding this:
+     *
+     *  - "Normal" commands. These are commands, that trigger a direct reply
+     *    from the device. In this case, the id of the command should be added
+     *    to the command map with a commandData_t where maxDelayCycles is set
+     *    to the maximum expected number of PST cycles the reply will take.
+     *    Then, scanForReply returns the id of the command and the base class
+     *    can handle time-out and missing replies.
+     *
+     *  - Periodic, unrequested replies. These are replies that, once enabled,
+     *    are sent by the device on its own in a defined interval.
+     *    In this case, the id of the reply or a placeholder id should be added
+     *    to the deviceCommandMap with a commandData_t where maxDelayCycles is
+     *    set to the maximum expected number of PST cycles between two replies
+     *    (also a tolerance should be added, as an FDIR message will be
+     *    generated if it is missed).
+     *    From then on, the base class handles the reception.
+     *    Then, scanForReply returns the id of the reply or the placeholder id
+     *    and the base class will take care of checking that all replies are
+     *    received and the interval is correct.
+     *
+     *  - Aperiodic, unrequested replies. These are replies that are sent
+     *    by the device without any preceding command and not in a defined
+     *    interval. These are not entered in the deviceCommandMap but
+     *    handled by returning @c APERIODIC_REPLY in scanForReply().
+     */
+    virtual void fillCommandAndReplyMap() = 0;
+    /**
+     * This is a helper method to facilitate inserting entries in the command map.
+     * @param deviceCommand	Identifier of the command to add.
+     * @param maxDelayCycles The maximum number of delay cycles the command
+     * waits until it times out.
+     * @param replyLen Will be supplied to the requestReceiveMessage call of
+     * the communication interface.
+     * @param periodic	Indicates if the command is periodic (i.e. it is sent
+     * by the device repeatedly without request) or not. Default is aperiodic (0)
+     * @return	- @c RETURN_OK when the command was successfully inserted,
+     *          - @c RETURN_FAILED else.
+     */
+    ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
+            uint16_t maxDelayCycles,
+            LocalPoolDataSetBase* replyDataSet = nullptr,
+            size_t replyLen = 0, bool periodic = false,
+            bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
+    /**
+     * @brief 	This is a helper method to insert replies in the reply map.
+     * @param deviceCommand	Identifier of the reply to add.
+     * @param maxDelayCycles The maximum number of delay cycles the reply waits
+     * until it times out.
+     * @param periodic	Indicates if the command is periodic (i.e. it is sent
+     * by the device repeatedly without request) or not. Default is aperiodic (0)
+     * @return	- @c RETURN_OK when the command was successfully inserted,
+     *          - @c RETURN_FAILED else.
+     */
+    ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
+            uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet = nullptr,
+            size_t replyLen = 0, bool periodic = false);
+    /**
+     * @brief 	A simple command to add a command to the commandList.
+     * @param deviceCommand The command to add
+     * @return - @c RETURN_OK when the command was successfully inserted,
+     *         - @c RETURN_FAILED else.
+     */
+    ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
+    /**
+     * @brief 	This is a helper method to facilitate updating entries
+     *        	in the reply map.
+     * @param deviceCommand	Identifier of the reply to update.
+     * @param delayCycles The current number of delay cycles to wait.
+     * As stated in #fillCommandAndCookieMap, to disable periodic commands,
+     * this is set to zero.
+     * @param maxDelayCycles The maximum number of delay cycles the reply waits
+     * until it times out. By passing 0 the entry remains untouched.
+     * @param periodic Indicates if the command is periodic (i.e. it is sent
+     * by the device repeatedly without request) or not.Default is aperiodic (0).
+     * Warning: The setting always overrides the value that was entered in the map.
+     * @return - @c RETURN_OK when the command was successfully inserted,
+     *         - @c RETURN_FAILED else.
+     */
+    ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
+            uint16_t delayCycles, uint16_t maxDelayCycles,
+            bool periodic = false);
+    /**
+     * @brief   Can be used to set the dataset corresponding to a reply ID manually.
+     * @details
+     * Used by the local data pool manager.
+     */
+    ReturnValue_t setReplyDataset(DeviceCommandId_t replyId,
+            LocalPoolDataSetBase* dataset);
 
-	/**
-	 * @brief 	Build a device command packet from data supplied by a direct
-	 *          command (PUS Service 8)
-	 * @details
-	 * This will be called if an functional command via PUS Service 8 is received and is
-	 * the primary interface for functional command instead of #executeAction for users. The
-	 * supplied ActionId_t action ID will be converted to a DeviceCommandId_t command ID after
-	 * an internal check whether the action ID is a key in the device command map.
-	 *
-	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
-	 * The existence of the command in the command map and the command size check against 0 are
-	 * done by the base class.
-	 *
-	 * @param deviceCommand     The command to build, already checked against deviceCommandMap
-	 * @param commandData       Pointer to the data from the direct command
-	 * @param commandDataLen    Length of commandData
-	 * @return
-	 *  - @c RETURN_OK to send command after #rawPacket and #rawPacketLen
-	 *       have been set.
-	 *  - @c HasActionsIF::EXECUTION_COMPLETE to generate a finish reply immediately. This can
-	 *       be used if no reply is expected. Otherwise, the developer can call #actionHelper.finish
-	 *       to finish the command handling.
-	 *  - Anything else triggers an event with the return code as a parameter as well as a
-	 *    step reply failed with the return code
-	 */
-	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-			const uint8_t * commandData, size_t commandDataLen) = 0;
+    /**
+     * Get the time needed to transit from modeFrom to modeTo.
+     *
+     * Used for the following transitions:
+     * modeFrom -> modeTo:
+     * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+     * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+     * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+     * _MODE_START_UP -> MODE_ON (do not include time to set the switches,
+     * the base class got you covered)
+     *
+     * The default implementation returns 0 !
+     * @param modeFrom
+     * @param modeTo
+     * @return time in ms
+     */
+    virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) = 0;
 
-	/**
-	 * @brief Scans a buffer for a valid reply.
-	 * @details
-	 * This is used by the base class to check the data received for valid packets.
-	 * It only checks if a valid packet starts at @c start.
-	 * It also only checks the structural validy of the packet,
-	 * e.g. checksums lengths and protocol data. No information check is done,
-	 * e.g. range checks etc.
-	 *
-	 * Errors should be reported directly, the base class does NOT report any
-	 * errors based on the return value of this function.
-	 *
-	 * @param start start of remaining buffer to be scanned
-	 * @param len length of remaining buffer to be scanned
-	 * @param[out] foundId the id of the data found in the buffer.
-	 * @param[out] foundLen length of the data found. Is to be set in function,
-	 *                       buffer is scanned at previous position + foundLen.
-	 * @return
-	 *  - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *  - @c RETURN_FAILED no reply could be found starting at @c start,
-	 *    implies @c foundLen is not valid, base class will call scanForReply()
-	 *    again with ++start
-	 *  - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
-	 *    e.g. checksum error, implies @c foundLen is valid, can be used to
-	 *    skip some bytes
-	 *  - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
-	 *  - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of
-	 *    the packet
-	 *  - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
-	 *  - @c APERIODIC_REPLY if a valid reply is received that has not been
-	 *    requested by a command, but should be handled anyway
-	 *    (@see also fillCommandAndCookieMap() )
-	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
-			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
+    /* Functions used by the local data pool manager */
+    /**
+     * This function is used to initialize the local housekeeping pool
+     * entries. The default implementation leaves the pool empty.
+     * @param localDataPoolMap
+     * @return
+     */
+    virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override;
+    /**
+     * @brief   Set all datapool variables that are update periodically in
+     *          normal mode invalid
+     * @details
+     * The default implementation will set all datasets which have been added
+     * in #fillCommandAndReplyMap to invalid. It will also set all pool
+     * variables inside the dataset to invalid. The user can override this
+     * method optionally.
+     */
+    virtual void setNormalDatapoolEntriesInvalid();
+    /**
+     * @brief   Get the dataset handle for a given SID.
+     * @details
+     * The default implementation will use the deviceCommandMap to look for the corresponding
+     * dataset handle. The user can override this function if this is not desired.
+     * @param sid
+     * @return
+     */
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 
-	/**
-	 * @brief Interpret a reply from the device.
-	 * @details
-	 * This is called after scanForReply() found a valid packet, it can be
-	 * assumed that the length and structure is valid.
-	 * This routine extracts the data from the packet into a DataSet and then
-	 * calls handleDeviceTM(), which either sends a TM packet or stores the
-	 * data in the DataPool depending on whether it was an external command.
-	 * No packet length is given, as it should be defined implicitly by the id.
-	 *
-	 * @param id the id found by scanForReply()
-	 * @param packet
-	 * @return
-	 *     - @c RETURN_OK when the reply was interpreted.
-	 *     - @c IGNORE_REPLY_DATA Ignore the reply and don't reset reply cycle
-	 *          counter.
-	 *     - @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;
+    /* HasModesIF overrides */
+    virtual void startTransition(Mode_t mode, Submode_t submode) override;
+    virtual void setToExternalControl() override;
+    virtual void announceMode(bool recursive) override;
+    /**
+     * @brief   Set the device handler mode
+     * @details
+     * Sets #timeoutStart with every call Also sets #transitionTargetMode if necessary so
+     * transitional states can be entered from everywhere without breaking the state machine
+     * (which relies on a correct #transitionTargetMode).
+     * The submode is left unchanged.
+     *
+     * @param newMode
+     */
+    void setMode(Mode_t newMode);
+    /**
+     * @overload
+     * @param submode
+     */
+    void setMode(Mode_t newMode, Submode_t submode);
+    /**
+     * @brief   Should be implemented properly by child class.
+     * @param mode
+     * @param submode
+     * @return
+     *    - @c RETURN_OK if valid
+     *    - @c RETURN_FAILED if invalid
+     */
+    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+            Submode_t submode);
+    /**
+     * @brief   Notify child about mode change.
+     * @details
+     * Can be overriden to be used like a callback.
+     */
+    virtual void modeChanged();
 
-	/**
-	 * @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.
-	 * There are different scenarios regarding this:
-	 *
-	 *  - "Normal" commands. These are commands, that trigger a direct reply
-	 *    from the device. In this case, the id of the command should be added
-	 *    to the command map with a commandData_t where maxDelayCycles is set
-	 *    to the maximum expected number of PST cycles the reply will take.
-	 *    Then, scanForReply returns the id of the command and the base class
-	 *    can handle time-out and missing replies.
-	 *
-	 *  - Periodic, unrequested replies. These are replies that, once enabled,
-	 *    are sent by the device on its own in a defined interval.
-	 *    In this case, the id of the reply or a placeholder id should be added
-	 *    to the deviceCommandMap with a commandData_t where maxDelayCycles is
-	 *    set to the maximum expected number of PST cycles between two replies
-	 *    (also a tolerance should be added, as an FDIR message will be
-	 *    generated if it is missed).
-	 *    From then on, the base class handles the reception.
-	 *    Then, scanForReply returns the id of the reply or the placeholder id
-	 *    and the base class will take care of checking that all replies are
-	 *    received and the interval is correct.
-	 *
-	 *  - Aperiodic, unrequested replies. These are replies that are sent
-	 *    by the device without any preceding command and not in a defined
-	 *    interval. These are not entered in the deviceCommandMap but
-	 *    handled by returning @c APERIODIC_REPLY in scanForReply().
-	 */
-	virtual void fillCommandAndReplyMap() = 0;
+    /* Power handling functions */
+    /**
+     * Return the switches connected to the device.
+     *
+     * The default implementation returns one switch set in the ctor.
+     *
+     * @param[out] switches pointer to an array of switches
+     * @param[out] numberOfSwitches length of returned array
+     * @return
+     *      - @c RETURN_OK if the parameters were set
+     *      - @c RETURN_FAILED if no switches exist
+     */
+    virtual ReturnValue_t getSwitches(const uint8_t **switches,
+            uint8_t *numberOfSwitches);
 
-	/**
-	 * This is a helper method to facilitate inserting entries in the command map.
-	 * @param deviceCommand	Identifier of the command to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the command
-	 * waits until it times out.
-	 * @param replyLen Will be supplied to the requestReceiveMessage call of
-	 * the communication interface.
-	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
-	 * by the device repeatedly without request) or not. Default is aperiodic (0)
-	 * @return	- @c RETURN_OK when the command was successfully inserted,
-	 *          - @c RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles,
-			LocalPoolDataSetBase* replyDataSet = nullptr,
-			size_t replyLen = 0, bool periodic = false,
-			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
+    /**
+     * @brief   Helper function to report a missed reply
+     * @details Can be overwritten by children to act on missed replies or to fake reporting Id.
+     * @param id of the missed reply
+     */
+    virtual void missedReply(DeviceCommandId_t id);
 
-	/**
-	 * @brief 	This is a helper method to insert replies in the reply map.
-	 * @param deviceCommand	Identifier of the reply to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
-	 * until it times out.
-	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
-	 * by the device repeatedly without request) or not. Default is aperiodic (0)
-	 * @return	- @c RETURN_OK when the command was successfully inserted,
-	 *          - @c RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet = nullptr,
-			size_t replyLen = 0, bool periodic = false);
-
-	/**
-	 * @brief 	A simple command to add a command to the commandList.
-	 * @param deviceCommand The command to add
-	 * @return - @c RETURN_OK when the command was successfully inserted,
-	 *         - @c RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
-	/**
-	 * @brief 	This is a helper method to facilitate updating entries
-	 *        	in the reply map.
-	 * @param deviceCommand	Identifier of the reply to update.
-	 * @param delayCycles The current number of delay cycles to wait.
-	 * As stated in #fillCommandAndCookieMap, to disable periodic commands,
-	 * this is set to zero.
-	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
-	 * until it times out. By passing 0 the entry remains untouched.
-	 * @param periodic Indicates if the command is periodic (i.e. it is sent
-	 * by the device repeatedly without request) or not.Default is aperiodic (0).
-	 * Warning: The setting always overrides the value that was entered in the map.
-	 * @return - @c RETURN_OK when the command was successfully inserted,
-	 *         - @c RETURN_FAILED else.
-	 */
-	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
-			uint16_t delayCycles, uint16_t maxDelayCycles,
-			bool periodic = false);
-
-	ReturnValue_t setReplyDataset(DeviceCommandId_t replyId,
-	        LocalPoolDataSetBase* dataset);
-
-	/**
-	 * @brief   Can be implemented by child handler to
-	 *          perform debugging
-	 * @details Example: Calling this in performOperation
-	 *          to track values like mode.
-	 * @param positionTracker Provide the child handler a way to know
-	 * where the debugInterface was called
-	 * @param objectId Provide the child handler object Id to
-	 * specify actions for spefic devices
-	 * @param parameter Supply a parameter of interest
-	 * Please delete all debugInterface calls in DHB after debugging is finished !
-	 */
-	virtual void debugInterface(uint8_t positionTracker = 0,
-			object_id_t objectId = 0, uint32_t parameter = 0);
-
-	/**
-	 * Get the time needed to transit from modeFrom to modeTo.
-	 *
-	 * Used for the following transitions:
-	 * modeFrom -> modeTo:
-	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches,
-	 * the base class got you covered)
-	 *
-	 * The default implementation returns 0 !
-	 * @param modeFrom
-	 * @param modeTo
-	 * @return time in ms
-	 */
-	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) = 0;
-
-	/**
-	 * Return the switches connected to the device.
-	 *
-	 * The default implementation returns one switch set in the ctor.
-	 *
-	 * @param[out] switches pointer to an array of switches
-	 * @param[out] numberOfSwitches length of returned array
-	 * @return
-	 *      - @c RETURN_OK if the parameters were set
-	 *      - @c RETURN_FAILED if no switches exist
-	 */
-	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 initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-				LocalDataPoolManager& poolManager) override;
-
-	/**
-	 * Required for HasLocalDataPoolIF, return a handle to the local pool manager.
-	 * @return
-	 */
-	LocalDataPoolManager* getHkManagerHandle() override;
-
-	/**
-	 * @brief 	Hook function for child handlers which is called once per
-	 * 			performOperation(). Default implementation is empty.
-	 */
-	virtual void performOperationHook();
+    /* Miscellaneous functions */
+    /**
+     * @brief 	Hook function for child handlers which is called once per
+     * 			performOperation(). Default implementation is empty.
+     */
+    virtual void performOperationHook();
+    /**
+     * @brief   Can be implemented by child handler to
+     *          perform debugging
+     * @details Example: Calling this in performOperation
+     *          to track values like mode.
+     * @param positionTracker Provide the child handler a way to know
+     * where the debugInterface was called
+     * @param objectId Provide the child handler object Id to
+     * specify actions for spefic devices
+     * @param parameter Supply a parameter of interest
+     * Please delete all debugInterface calls in DHB after debugging is finished !
+     */
+    virtual void debugInterface(uint8_t positionTracker = 0,
+            object_id_t objectId = 0, uint32_t parameter = 0);
 
 protected:
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
 
-	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(0xA0);
-	/* Return codes for scanForReply */
-	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB0); //!< This is used to specify for replies from a device which are not replies to requests
-	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB1); //!< Ignore parts of the received packet
-	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB2); //!< Ignore full received packet
-	/* Return codes for command building */
-	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0); //!< Return this if no command sending in required
-	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
-	// Return codes for getSwitches */
-	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xD0);
-	/* Mode handling error Codes */
-	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE1);
+    static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
 
-	static const MessageQueueId_t NO_COMMANDER = 0;
+    static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(0xA0);
+    /* Return codes for scanForReply */
+    //! This is used to specify for replies from a device which are not replies to requests
+    static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB0);
+    //! Ignore parts of the received packet
+    static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB1);
+    //! Ignore full received packet
+    static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB2);
+    /* Return codes for command building */
+    //! Return this if no command sending in required
+    static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0);
+    static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
+    // Return codes for getSwitches */
+    static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xD0);
+    /* Mode handling error Codes */
+    static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE0);
+    static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE1);
 
-	/** Pointer to the raw packet that will be sent.*/
-	uint8_t *rawPacket = nullptr;
-	/** Size of the #rawPacket. */
-	uint32_t rawPacketLen = 0;
+    static const MessageQueueId_t NO_COMMANDER = 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;
+    //! Pointer to the raw packet that will be sent.
+    uint8_t *rawPacket = nullptr;
+    //! Size of the #rawPacket.
+    uint32_t rawPacketLen = 0;
 
-	/** This is the counter value from performOperation(). */
-	uint8_t pstStep = 0;
-	uint8_t lastStep = 0;
-	uint32_t pstIntervalMs = 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;
 
-	/**
-	 * Wiretapping flag:
-	 *
-	 * 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;
-	/**
-	 * @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 erroneous replies
-	 */
-	MessageQueueId_t defaultRawReceiver = MessageQueueIF::NO_QUEUE;
-	store_address_t storedRawData;
+    /** This is the counter value from performOperation(). */
+    uint8_t pstStep = 0;
+    uint8_t lastStep = 0;
+    uint32_t pstIntervalMs = 0;
 
-	/**
-	 * @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;
+    /**
+     * Wiretapping flag:
+     *
+     * 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;
+    /**
+     * @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 erroneous replies
+     */
+    MessageQueueId_t defaultRawReceiver = MessageQueueIF::NO_QUEUE;
+    store_address_t storedRawData;
 
-	/**
-	 * Pointer to the IPCStore.
-	 * This caches the pointer received from the objectManager in the constructor.
-	 */
-	StorageManagerIF *IPCStore = nullptr;
-	/** The comIF object ID is cached for the intialize() function */
-	object_id_t deviceCommunicationId;
-	/** Communication object used for device communication */
-	DeviceCommunicationIF * communicationInterface = nullptr;
-	/** Cookie used for communication */
-	CookieIF * comCookie;
+    /**
+     * @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;
 
-	/** 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 poolManager;
+    /**
+     * Pointer to the IPCStore.
+     * This caches the pointer received from the objectManager in the constructor.
+     */
+    StorageManagerIF *IPCStore = nullptr;
+    /** The comIF object ID is cached for the intialize() function */
+    object_id_t deviceCommunicationId;
+    /** Communication object used for device communication */
+    DeviceCommunicationIF * communicationInterface = nullptr;
+    /** Cookie used for communication */
+    CookieIF * comCookie;
 
-	/**
-	 *  @brief Information about commands
-	 */
-	struct DeviceCommandInfo {
-		//! 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;
+    /** 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 poolManager;
 
-	/**
-	 * @brief Information about expected replies
-	 * This is used to keep track of pending replies.
-	 */
-	struct DeviceReplyInfo {
-		//! 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.
-		//! 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)
-		LocalPoolDataSetBase* dataSet = nullptr;
-		//! The command that expects this reply.
-		DeviceCommandMap::iterator command;
-	};
+    /**
+     *  @brief Information about commands
+     */
+    struct DeviceCommandInfo {
+        //! 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;
 
-	using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
-	using DeviceReplyIter = DeviceReplyMap::iterator;
-	/**
-	 * 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;
+    /**
+     * @brief Information about expected replies
+     * This is used to keep track of pending replies.
+     */
+    struct DeviceReplyInfo {
+        //! 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.
+        //! 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)
+        LocalPoolDataSetBase* dataSet = nullptr;
+        //! The command that expects this reply.
+        DeviceCommandMap::iterator command;
+    };
 
-	//! The MessageQueue used to receive device handler commands
-	//! and to send replies.
-	MessageQueueIF* commandQueue = nullptr;
+    using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
+    using DeviceReplyIter = DeviceReplyMap::iterator;
+    /**
+     * 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;
 
-	DeviceHandlerThermalSet* thermalSet = nullptr;
+    //! The MessageQueue used to receive device handler commands
+    //! and to send replies.
+    MessageQueueIF* commandQueue = nullptr;
 
-	/**
-	 * Optional Error code. Can be set in doStartUp(), doShutDown() and
-	 * doTransition() to signal cause for Transition failure.
-	 */
-	ReturnValue_t childTransitionFailure;
+    DeviceHandlerThermalSet* thermalSet = nullptr;
 
-	/** Counts if communication channel lost a reply, so some missed
-	 * replys can be ignored. */
-	uint32_t ignoreMissedRepliesCount = 0;
+    /**
+     * Optional Error code. Can be set in doStartUp(), doShutDown() and
+     * doTransition() to signal cause for Transition failure.
+     */
+    ReturnValue_t childTransitionFailure;
 
-	/** Pointer to the used FDIR instance. If not provided by child,
-	 * default class is instantiated. */
-	FailureIsolationBase* fdirInstance;
+    /** Counts if communication channel lost a reply, so some missed
+     * replys can be ignored. */
+    uint32_t ignoreMissedRepliesCount = 0;
 
-	HkSwitchHelper hkSwitcher;
+    /** Pointer to the used FDIR instance. If not provided by child,
+     * default class is instantiated. */
+    FailureIsolationBase* fdirInstance;
 
-	bool defaultFDIRUsed; //!< To correctly delete the default instance.
+    //! To correctly delete the default instance.
+    bool defaultFDIRUsed;
 
-	bool switchOffWasReported; //!< Indicates if SWITCH_WENT_OFF was already thrown.
+    //! Indicates if SWITCH_WENT_OFF was already thrown.
+    bool switchOffWasReported;
 
-	//! Pointer to the task which executes this component, is invalid
-	//! before setTaskIF was called.
-	PeriodicTaskIF* executingTask = nullptr;
+    /** Pointer to the task which executes this component,
+	is invalid before setTaskIF was called. */
+    PeriodicTaskIF* executingTask = nullptr;
 
-	//!< Object which switches power on and off.
-	static object_id_t powerSwitcherId;
+    //! Object which switches power on and off.
+    static object_id_t powerSwitcherId;
 
-	//!< Object which receives RAW data by default.
-	static object_id_t rawDataReceiverId;
+    //! Object which receives RAW data by default.
+    static object_id_t rawDataReceiverId;
 
-	//!< 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.
+    static object_id_t defaultFdirParentId;
 
-	/**
-	 * @brief   Set all datapool variables that are update periodically in
-	 *          normal mode invalid
-	 * @details
-	 * The default implementation will set all datasets which have been added
-	 * in #fillCommandAndReplyMap to invalid. It will also set all pool
-	 * variables inside the dataset to invalid. The user can override this
-	 * method optionally.
-	 */
-	virtual void setNormalDatapoolEntriesInvalid();
+    /**
+     * @brief   Send a reply to a received device handler command.
+     *
+     * This also resets #DeviceHandlerCommand to 0.
+     *
+     * @param reply the reply type
+     * @param parameter parameter for the reply
+     */
+    void replyReturnvalueToCommand(ReturnValue_t status, uint32_t parameter = 0);
+    /**
+     * TODO: Whats the difference between this and the upper command?
+     * @param status
+     * @param parameter
+     */
+    void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
 
-	MessageQueueId_t getCommanderId(DeviceCommandId_t replyId) const;
+    /**
+     * 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
+     * [_MODE_TO_ON, _MODE_TO_NORMAL, _MODE_TO_RAW]
+     *
+     * 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 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.
+     *
+     * 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 directly.
+     *
+     * #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 subModeFrom the subMode of modeFrom
+     */
+    virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
 
-	/**
-	 * Helper function to get pending command. This is useful for devices
-	 * like SPI sensors to identify the last sent command.
-	 * This only returns the command sent in the last SEND_WRITE cycle.
-	 * @return
-	 */
-	DeviceCommandId_t getPendingCommand() const;
+    /**
+     * Get the communication action for the current step.
+     * The step number can be read from #pstStep.
+     * @return The communication action to execute in this step
+     */
+    virtual CommunicationAction getComAction();
 
-	/**
-	 * Helper function to report a missed reply
-	 *
-	 * Can be overwritten by children to act on missed replies or to fake
-	 * reporting Id.
-	 *
-	 * @param id of the missed reply
-	 */
-	virtual void missedReply(DeviceCommandId_t id);
+    /**
+     * Checks state of switches in conjunction with mode and triggers an event
+     * if they don't fit.
+     */
+    virtual void checkSwitchState();
 
-	/**
-	 * Send a reply to a received device handler command.
-	 *
-	 * This also resets #DeviceHandlerCommand to 0.
-	 *
-	 * @param reply the reply type
-	 * @param parameter parameter for the reply
-	 */
-	void replyReturnvalueToCommand(ReturnValue_t status,
-			uint32_t parameter = 0);
+    /**
+     * Reserved for the rare case where a device needs to perform additional
+     * operation cyclically in OFF mode.
+     */
+    virtual void doOffActivity();
 
-	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
+    /**
+     * Reserved for the rare case where a device needs to perform additional
+     * operation cyclically in ON mode.
+     */
+    virtual void doOnActivity();
 
-	/**
-	 * Set the device handler mode
-	 *
-	 * Sets #timeoutStart with every call.
-	 *
-	 * Sets #transitionTargetMode if necessary so transitional states can be
-	 * entered from everywhere without breaking the state machine
-	 * (which relies on a correct #transitionTargetMode).
-	 *
-	 * The submode is left unchanged.
-	 *
-	 * @param newMode
-	 */
-	void setMode(Mode_t newMode);
+    /**
+     * Required for HasLocalDataPoolIF, return a handle to the local pool manager.
+     * @return
+     */
+    LocalDataPoolManager* getHkManagerHandle() override;
 
-	/**
-	 * @overload
-	 * @param submode
-	 */
-	void setMode(Mode_t newMode, Submode_t submode);
+    /**
+     * Returns the delay cycle count of a reply.
+     * A count != 0 indicates that the command is already executed.
+     * @param deviceCommand	The command to look for
+     * @return
+     * The current delay count. If the command does not exist  (should never
+     * happen) it returns 0.
+     */
+    uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
 
-	/**
-	 * 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
-	 * [_MODE_TO_ON, _MODE_TO_NORMAL, _MODE_TO_RAW]
-	 *
-	 * 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 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.
-	 *
-	 * 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 directly.
-	 *
-	 * #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 subModeFrom the subMode of modeFrom
-	 */
-	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
+    /**
+     * Calls replyRawData() with #defaultRawReceiver, but checks if wiretapping
+     * is active and if so, does not send the data as the wiretapping will have
+     * sent it already
+     */
+    void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
 
-	/**
-	 * @param mode
-	 * @param submode
-	 * @return
-	 *    - @c RETURN_OK if valid
-	 *    - @c RETURN_FAILED if invalid
-	 */
-	virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
-			Submode_t submode);
+    /**
+     * Enable the reply checking for a command
+     *
+     * Is only called, if the command was sent (i.e. the getWriteReply was
+     * successful). Must ensure that all replies are activated and correctly
+     * linked to the command that initiated it.
+     * The default implementation looks for a reply with the same id as the
+     * command id in the replyMap or uses the alternativeReplyId if flagged so.
+     * When found, copies maxDelayCycles to delayCycles in the reply information
+     * and sets the command to expect one reply.
+     *
+     * Can be overwritten by the child, if a command activates multiple replies
+     * or replyId differs from commandId.
+     * Notes for child implementations:
+     * 	- If the command was not found in the reply map,
+     * 	  NO_REPLY_EXPECTED MUST be returned.
+     * 	- A failure code may be returned if something went fundamentally wrong.
+     *
+     * @param deviceCommand
+     * @return 	- RETURN_OK if a reply was activated.
+     * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an
+     * 			  error case as many commands do not expect a reply.
+     */
+    virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
+            uint8_t expectedReplies = 1, bool useAlternateId = false,
+            DeviceCommandId_t alternateReplyID = 0);
 
-	/**
-	 * Get the communication action for the current step.
-	 * The step number can be read from #pstStep.
-	 * @return The communication action to execute in this step
-	 */
-	virtual CommunicationAction getComAction();
+    /**
+     * @brief   Build the device command to send for raw mode.
+     * @details
+     * This is only called in @c MODE_RAW. It is for the rare case that in
+     * raw mode packets are to be sent by the handler itself. It is NOT needed
+     * for the raw commanding service. Its only current use is in the STR
+     * handler which gets its raw packets from a different source.
+     * Also it can be used for transitional commands, to get the device ready
+     * for @c MODE_RAW
+     *
+     * As it is almost never used, there is a default implementation
+     * returning @c NOTHING_TO_SEND.
+     *
+     * #rawPacket and #rawPacketLen must be set by this method to the packet
+     * to be sent.
+     *
+     * @param[out] id the device command id built
+     * @return
+     *    - @c RETURN_OK when a command is to be sent
+     *    - not @c NOTHING_TO_SEND when no command is to be sent
+     */
+    virtual ReturnValue_t buildChildRawCommand();
 
-	/**
-	 * Build the device command to send for raw mode.
-	 *
-	 * This is only called in @c MODE_RAW. It is for the rare case that in
-	 * raw mode packets are to be sent by the handler itself. It is NOT needed
-	 * for the raw commanding service. Its only current use is in the STR
-	 * handler which gets its raw packets from a different source.
-	 * Also it can be used for transitional commands, to get the device ready
-	 * for @c MODE_RAW
-	 *
-	 * As it is almost never used, there is a default implementation
-	 * returning @c NOTHING_TO_SEND.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet
-	 * to be sent.
-	 *
-	 * @param[out] id the device command id built
-	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c NOTHING_TO_SEND when no command is to be sent
-	 */
-	virtual ReturnValue_t buildChildRawCommand();
+    /**
+     * @brief   Construct a command reply containing a raw reply.
+     * @details
+     * It gets space in the #IPCStore, copies data there, then sends a raw reply
+     * containing the store address. This method is virtual, as devices can have different channels
+     * to send raw replies
+     *
+     * @param data data to send
+     * @param len length of @c data
+     * @param sendTo the messageQueueId of the one to send to
+     * @param isCommand marks the raw data as a command, the message then
+     * will be of type raw_command
+     */
+    virtual void replyRawData(const uint8_t *data, size_t len,
+            MessageQueueId_t sendTo, bool isCommand = false);
 
-	/**
-	 * Returns the delay cycle count of a reply.
-	 * A count != 0 indicates that the command is already executed.
-	 * @param deviceCommand	The command to look for
-	 * @return
-	 * The current delay count. If the command does not exist  (should never
-	 * happen) it returns 0.
-	 */
-	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
+    /**
+     * Get the state of the PCDU switches in the local datapool
+     * @return
+     *  - @c PowerSwitchIF::SWITCH_ON if all switches specified
+     *       by #switches are on
+     *  - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by
+     *       #switches are off
+     *  - @c PowerSwitchIF::RETURN_FAILED if an error occured
+     */
+    ReturnValue_t getStateOfSwitches();
 
-	/**
-	 * Construct a command reply containing a raw reply.
-	 *
-	 * It gets space in the #IPCStore, copies data there, then sends a raw reply
-	 * containing the store address.
-	 *
-	 * This method is virtual, as devices can have different channels to send
-	 * raw replies
-	 *
-	 * @param data data to send
-	 * @param len length of @c data
-	 * @param sendTo the messageQueueId of the one to send to
-	 * @param isCommand marks the raw data as a command, the message then
-	 * will be of type raw_command
-	 */
-	virtual void replyRawData(const uint8_t *data, size_t len,
-			MessageQueueId_t sendTo, bool isCommand = false);
+    /**
+     * Children can overwrite this function to suppress checking of the
+     * command Queue
+     *
+     * This can be used when the child does not want to receive a command in
+     * a certain situation. Care must be taken that checking is not
+     * permanentely disabled as this would render the handler unusable.
+     *
+     * @return whether checking the queue should NOT be done
+     */
+    virtual bool dontCheckQueue();
 
-	/**
-	 * Calls replyRawData() with #defaultRawReceiver, but checks if wiretapping
-	 * is active and if so, does not send the data as the wiretapping will have
-	 * sent it already
-	 */
-	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
+    Mode_t getBaseMode(Mode_t transitionMode);
 
-	/**
-	 * @brief	Notify child about mode change.
-	 */
-	virtual void modeChanged(void);
+    bool isAwaitingReply();
 
-	/**
-	 * Enable the reply checking for a command
-	 *
-	 * Is only called, if the command was sent (i.e. the getWriteReply was
-	 * successful). Must ensure that all replies are activated and correctly
-	 * linked to the command that initiated it.
-	 * The default implementation looks for a reply with the same id as the
-	 * command id in the replyMap or uses the alternativeReplyId if flagged so.
-	 * When found, copies maxDelayCycles to delayCycles in the reply information
-	 * and sets the command to expect one reply.
-	 *
-	 * Can be overwritten by the child, if a command activates multiple replies
-	 * or replyId differs from commandId.
-	 * Notes for child implementations:
-	 * 	- If the command was not found in the reply map,
-	 * 	  NO_REPLY_EXPECTED MUST be returned.
-	 * 	- A failure code may be returned if something went fundamentally wrong.
-	 *
-	 * @param deviceCommand
-	 * @return 	- RETURN_OK if a reply was activated.
-	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an
-	 * 			  error case as many commands do not expect a reply.
-	 */
-	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
-			uint8_t expectedReplies = 1, bool useAlternateId = false,
-			DeviceCommandId_t alternateReplyID = 0);
+    void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId,
+            bool forceDirectTm = false);
+    //	void handleDeviceTM(uint8_t* data, size_t dataSize, DeviceCommandId_t replyId,
+    //	        bool forceDirectTm);
 
-	/**
-	 * Get the state of the PCDU switches in the local datapool
-	 * @return
-	 *  - @c PowerSwitchIF::SWITCH_ON if all switches specified
-	 *       by #switches are on
-	 *  - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by
-	 *       #switches are off
-	 *  - @c PowerSwitchIF::RETURN_FAILED if an error occured
-	 */
-	ReturnValue_t getStateOfSwitches(void);
+    virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+            uint32_t *msToReachTheMode);
 
-	/**
-	 * build a list of sids and pass it to the #hkSwitcher
-	 */
-	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
+    virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
-	/**
-	 * Children can overwrite this function to suppress checking of the
-	 * command Queue
-	 *
-	 * This can be used when the child does not want to receive a command in
-	 * a certain situation. Care must be taken that checking is not
-	 * permanentely disabled as this would render the handler unusable.
-	 *
-	 * @return whether checking the queue should NOT be done
-	 */
-	virtual bool dontCheckQueue();
+    /**
+     * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper"
+     * faster about executed events.
+     * This is a bit sneaky, but improves responsiveness of the device FDIR.
+     * @param event	The event to be thrown
+     * @param parameter1	Optional parameter 1
+     * @param parameter2	Optional parameter 2
+     */
+    void triggerEvent(Event event, uint32_t parameter1 = 0,
+            uint32_t parameter2 = 0);
+    /**
+     * Same as triggerEvent, but for forwarding if object is used as proxy.
+     */
+    virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
+            uint32_t parameter2 = 0) const;
 
-	Mode_t getBaseMode(Mode_t transitionMode);
+    /**
+     * Checks if current mode is transitional mode.
+     * @return true if mode is transitional, false else.
+     */
+    bool isTransitionalMode();
 
-	bool isAwaitingReply();
+    /**
+     * Checks if current handler state allows reception of external device commands.
+     * Default implementation allows commands only in plain MODE_ON and MODE_NORMAL.
+     * @return RETURN_OK if commands are accepted, anything else otherwise.
+     */
+    virtual ReturnValue_t acceptExternalDeviceCommands();
 
-	void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId,
-	        bool forceDirectTm = false);
-//	void handleDeviceTM(uint8_t* data, size_t dataSize, DeviceCommandId_t replyId,
-//	        bool forceDirectTm);
+    bool commandIsExecuting(DeviceCommandId_t commandId);
 
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode);
-
-	/* HasModesIF overrides */
-	virtual void startTransition(Mode_t mode, Submode_t submode) override;
-	virtual void setToExternalControl() override;
-	virtual void announceMode(bool recursive) override;
-
-	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
-
-	/**
-	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper"
-	 * faster about executed events.
-	 * This is a bit sneaky, but improves responsiveness of the device FDIR.
-	 * @param event	The event to be thrown
-	 * @param parameter1	Optional parameter 1
-	 * @param parameter2	Optional parameter 2
-	 */
-	void triggerEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);
-	/**
-	 * Same as triggerEvent, but for forwarding if object is used as proxy.
-	 */
-	virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0) const;
-	/**
-	 * Checks state of switches in conjunction with mode and triggers an event
-	 * if they don't fit.
-	 */
-	virtual void checkSwitchState();
-
-	/**
-	 * Reserved for the rare case where a device needs to perform additional
-	 * operation cyclically in OFF mode.
-	 */
-	virtual void doOffActivity();
-
-	/**
-	 * Reserved for the rare case where a device needs to perform additional
-	 * operation cyclically in ON mode.
-	 */
-	virtual void doOnActivity();
-
-	/**
-	 * Checks if current mode is transitional mode.
-	 * @return true if mode is transitional, false else.
-	 */
-	bool isTransitionalMode();
-
-	/**
-	 * Checks if current handler state allows reception of external device commands.
-	 * Default implementation allows commands only in plain MODE_ON and MODE_NORMAL.
-	 * @return RETURN_OK if commands are accepted, anything else otherwise.
-	 */
-	virtual ReturnValue_t acceptExternalDeviceCommands();
-
-	bool commandIsExecuting(DeviceCommandId_t commandId);
-
-	/**
-	 * set all switches returned by getSwitches()
-	 *
-	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
-	 */
-	void commandSwitch(ReturnValue_t onOff);
+    /**
+     * set all switches returned by getSwitches()
+     *
+     * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
+     */
+    void commandSwitch(ReturnValue_t onOff);
 
 private:
 
-	/**
-	 * State a cookie is in.
-	 *
-	 * Used to keep track of the state of the RMAP communication.
-	 */
-	enum CookieState_t {
-		COOKIE_UNUSED,    //!< The Cookie is unused
-		COOKIE_WRITE_READY, //!< There's data available to send.
-		COOKIE_READ_SENT, //!< A sendRead command was sent with this cookie
-		COOKIE_WRITE_SENT //!< A sendWrite command was sent with this cookie
-	};
-	/**
-	 * Information about a cookie.
-	 *
-	 * This is stored in a map for each cookie, to not only track the state,
-	 * but also information about the sent command. Tracking this information
-	 * is needed as the state of a commandId (waiting for reply) is done when a
-	 * write reply is received.
-	 */
-	struct CookieInfo {
-		CookieState_t state;
-		DeviceCommandMap::iterator pendingCommand;
-	};
+    /**
+     * State a cookie is in.
+     *
+     * Used to keep track of the state of the RMAP communication.
+     */
+    enum CookieState_t {
+        COOKIE_UNUSED,    //!< The Cookie is unused
+        COOKIE_WRITE_READY, //!< There's data available to send.
+        COOKIE_READ_SENT, //!< A sendRead command was sent with this cookie
+        COOKIE_WRITE_SENT //!< A sendWrite command was sent with this cookie
+    };
+    /**
+     * Information about a cookie.
+     *
+     * This is stored in a map for each cookie, to not only track the state,
+     * but also information about the sent command. Tracking this information
+     * is needed as the state of a commandId (waiting for reply) is done when a
+     * write reply is received.
+     */
+    struct CookieInfo {
+        CookieState_t state;
+        DeviceCommandMap::iterator pendingCommand;
+    };
 
-	/**
-	 * @brief   Info about the #cookie
-	 * Used to track the state of the communication
-	 */
-	CookieInfo cookieInfo;
+    /**
+     * @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;
+    /** the object used to set power switches */
+    PowerSwitchIF *powerSwitcher = nullptr;
 
-	/** HK destination can also be set individually */
-	object_id_t hkDestination = objects::NO_OBJECT;
+    /** HK destination can also be set individually */
+    object_id_t hkDestination = objects::NO_OBJECT;
 
-	/**
-	 * @brief   Used for timing out mode transitions.
-	 * Set when setMode() is called.
-	 */
-	uint32_t timeoutStart = 0;
+    /**
+     * @brief   Used for timing out mode transitions.
+     * Set when setMode() is called.
+     */
+    uint32_t timeoutStart = 0;
 
-	bool setStartupImmediately = false;
+    bool setStartupImmediately = false;
 
-	/**
-	 * Delay for the current mode transition, used for time out
-	 */
-	uint32_t childTransitionDelay;
+    /**
+     * Delay for the current mode transition, used for time out
+     */
+    uint32_t childTransitionDelay;
 
-	/**
-	 * @brief   The mode the current transition originated from
-	 *
-	 * This is private so the child can not change it and mess up the timeouts
-	 *
-	 * 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]
-	 */
-	Mode_t transitionSourceMode;
+    /**
+     * @brief   The mode the current transition originated from
+     *
+     * This is private so the child can not change it and mess up the timeouts
+     *
+     * 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]
+     */
+    Mode_t transitionSourceMode;
 
-	/**
-	 * the submode of the source mode during a transition
-	 */
-	Submode_t transitionSourceSubMode;
+    /**
+     * the submode of the source mode during a transition
+     */
+    Submode_t transitionSourceSubMode;
 
-	/**
-	 * read the command queue
-	 */
-	void readCommandQueue(void);
+    /**
+     * read the command queue
+     */
+    void readCommandQueue(void);
 
-	/**
-	 * Handle the device handler mode.
-	 *
-	 * - checks whether commands are valid for the current mode, rejects
-	 *   them accordingly
-	 * - checks whether commanded mode transitions are required and calls
-	 *   handleCommandedModeTransition()
-	 * - does the necessary action for the current mode or calls
-	 *   doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
-	 * - actions that happen in transitions (e.g. setting a timeout) are
-	 *   handled in setMode()
-	 */
-	void doStateMachine(void);
+    /**
+     * Handle the device handler mode.
+     *
+     * - checks whether commands are valid for the current mode, rejects
+     *   them accordingly
+     * - checks whether commanded mode transitions are required and calls
+     *   handleCommandedModeTransition()
+     * - does the necessary action for the current mode or calls
+     *   doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
+     * - actions that happen in transitions (e.g. setting a timeout) are
+     *   handled in setMode()
+     */
+    void doStateMachine(void);
 
-	void buildRawDeviceCommand(CommandMessage* message);
-	void buildInternalCommand(void);
+    void buildRawDeviceCommand(CommandMessage* message);
+    void buildInternalCommand(void);
 
-	/**
-	 * Decrement the counter for the timout of replies.
-	 *
-	 * This is called at the beginning of each cycle. It checks whether a
-	 * reply has timed out (that means a reply was expected but not received).
-	 */
-	void decrementDeviceReplyMap(void);
+    /**
+     * Decrement the counter for the timout of replies.
+     *
+     * This is called at the beginning of each cycle. It checks whether a
+     * reply has timed out (that means a reply was expected but not received).
+     */
+    void decrementDeviceReplyMap(void);
 
-	/**
-	 * Convenience function to handle a reply.
-	 *
-	 * Called after scanForReply() has found a packet. Checks if the found ID
-	 * is in the #deviceCommandMap, if so,  calls
-	 * #interpretDeviceReply for further action.
-	 *
-	 * It also resets the timeout counter for the command id.
-	 *
-	 * @param data the found packet
-	 * @param id the found id
-	 * @foundLen the length of the packet
-	 */
-	void handleReply(const uint8_t *data, DeviceCommandId_t id, uint32_t foundLen);
+    /**
+     * Convenience function to handle a reply.
+     *
+     * Called after scanForReply() has found a packet. Checks if the found ID
+     * is in the #deviceCommandMap, if so,  calls
+     * #interpretDeviceReply for further action.
+     *
+     * It also resets the timeout counter for the command id.
+     *
+     * @param data the found packet
+     * @param id the found id
+     * @foundLen the length of the packet
+     */
+    void handleReply(const uint8_t *data, DeviceCommandId_t id, uint32_t foundLen);
 
-	void replyToReply(DeviceReplyMap::iterator iter, ReturnValue_t status);
-	/**
-	 * Build and send a command to the device.
-	 *
-	 * This routine checks whether a raw or direct command has been received,
-	 * checks the content of the received command and calls
-	 * buildCommandFromCommand() for direct commands or sets #rawpacket
-	 * to the received raw packet.
-	 * If no external command is received or the received command is invalid and
-	 * the current mode is @c MODE_NORMAL or a transitional mode, it asks the
-	 * child class to build a command (via getNormalDeviceCommand() or
-	 * getTransitionalDeviceCommand() and buildCommand()) and
-	 * sends the command via RMAP.
-	 */
-	void doSendWrite(void);
+    void replyToReply(DeviceReplyMap::iterator iter, ReturnValue_t status);
+    /**
+     * Build and send a command to the device.
+     *
+     * This routine checks whether a raw or direct command has been received,
+     * checks the content of the received command and calls
+     * buildCommandFromCommand() for direct commands or sets #rawpacket
+     * to the received raw packet.
+     * If no external command is received or the received command is invalid and
+     * the current mode is @c MODE_NORMAL or a transitional mode, it asks the
+     * child class to build a command (via getNormalDeviceCommand() or
+     * getTransitionalDeviceCommand() and buildCommand()) and
+     * sends the command via RMAP.
+     */
+    void doSendWrite(void);
 
-	/**
-	 * Check if the RMAP sendWrite action was successful.
-	 *
-	 * Depending on the result, the following is done
-	 * - if the device command was external commanded, a reply is sent
-	 *   indicating the result
-	 * - if the action was successful, the reply timout counter is initialized
-	 */
-	void doGetWrite(void);
+    /**
+     * Check if the RMAP sendWrite action was successful.
+     *
+     * Depending on the result, the following is done
+     * - if the device command was external commanded, a reply is sent
+     *   indicating the result
+     * - if the action was successful, the reply timout counter is initialized
+     */
+    void doGetWrite(void);
 
-	/**
-	 * Send a RMAP getRead command.
-	 *
-	 * The size of the getRead command is #maxDeviceReplyLen.
-	 * This is always executed, independently from the current mode.
-	 */
-	void doSendRead(void);
+    /**
+     * Send a RMAP getRead command.
+     *
+     * The size of the getRead command is #maxDeviceReplyLen.
+     * This is always executed, independently from the current mode.
+     */
+    void doSendRead(void);
 
-	/**
-	 * Check the getRead reply and the contained data.
-	 *
-	 * If data was received scanForReply() and, if successful, handleReply()
-	 * are called. If the current mode is @c MODE_RAW, the received packet
-	 * is sent to the commanding object via commandQueue.
-	 */
-	void doGetRead(void);
+    /**
+     * Check the getRead reply and the contained data.
+     *
+     * If data was received scanForReply() and, if successful, handleReply()
+     * are called. If the current mode is @c MODE_RAW, the received packet
+     * is sent to the commanding object via commandQueue.
+     */
+    void doGetRead(void);
 
-	/**
-	 * Retrive data from the #IPCStore.
-	 *
-	 * @param storageAddress
-	 * @param[out] data
-	 * @param[out] len
-	 * @return
-	 *   - @c RETURN_OK @c data is valid
-	 *   - @c RETURN_FAILED IPCStore is nullptr
-	 *   - the return value from the IPCStore if it was not @c RETURN_OK
-	 */
-	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
-			uint32_t *len);
+    /**
+     * Retrive data from the #IPCStore.
+     *
+     * @param storageAddress
+     * @param[out] data
+     * @param[out] len
+     * @return
+     *   - @c RETURN_OK @c data is valid
+     *   - @c RETURN_FAILED IPCStore is nullptr
+     *   - the return value from the IPCStore if it was not @c RETURN_OK
+     */
+    ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
+            uint32_t *len);
 
-	/**
-	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW, nothing else!
-	 */
-	void setTransition(Mode_t modeTo, Submode_t submodeTo);
+    /**
+     * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW, nothing else!
+     */
+    void setTransition(Mode_t modeTo, Submode_t submodeTo);
 
-	/**
-	 * calls the right child function for the transitional submodes
-	 */
-	void callChildStatemachine();
+    /**
+     * Calls the right child function for the transitional submodes
+     */
+    void callChildStatemachine();
 
-	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
-
-	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+    ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
 
     void parseReply(const uint8_t* receivedData,
-                size_t receivedDataLen);
+            size_t receivedDataLen);
 
     void handleTransitionToOnMode(Mode_t commandedMode,
-    		Submode_t commandedSubmode);
+            Submode_t commandedSubmode);
 
+    /**
+     * Generic internal printer function which also handles printing the object ID.
+     * @param errorType
+     * @param functionName
+     * @param errorCode
+     * @param errorPrint
+     */
     void printWarningOrError(sif::OutputTypes errorType,
-    		const char* functionName,
-			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
-			const char* errorPrint = nullptr);
+            const char* functionName,
+            ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+            const char* errorPrint = nullptr);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */

From e27d4fd0607c3901b377ae3dbb7eb8fd22e71c9e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Feb 2021 13:30:04 +0100
Subject: [PATCH 1555/1774] small bugfix

---
 devicehandlers/DeviceHandlerBase.cpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 8650ec308..651442136 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -203,11 +203,6 @@ ReturnValue_t DeviceHandlerBase::initialize() {
         return result;
     }
 
-    result = hkSwitcher.initialize();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-
     result = poolManager.initialize(commandQueue);
     if (result != HasReturnvaluesIF::RETURN_OK) {
         return result;

From c0b490df653537a2827617548ee9bd28b2c2de9f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Feb 2021 13:32:14 +0100
Subject: [PATCH 1556/1774] indentation

---
 devicehandlers/DeviceHandlerBase.cpp | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 651442136..b2cc25da3 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -19,16 +19,16 @@ object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
         CookieIF * comCookie, FailureIsolationBase* fdirInstance, size_t cmdQueueSize):
-		                SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
-		                wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-		                deviceCommunicationId(deviceCommunication), comCookie(comCookie),
-		                healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		                actionHelper(this, nullptr), poolManager(this, nullptr),
-		                childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
-		                defaultFDIRUsed(fdirInstance == nullptr),
-		                switchOffWasReported(false), childTransitionDelay(5000),
-		                transitionSourceMode(_MODE_POWER_DOWN),
-		                transitionSourceSubMode(SUBMODE_NONE) {
+        SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
+        wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
+        deviceCommunicationId(deviceCommunication), comCookie(comCookie),
+        healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
+        actionHelper(this, nullptr), poolManager(this, nullptr),
+        childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
+        defaultFDIRUsed(fdirInstance == nullptr),
+        switchOffWasReported(false), childTransitionDelay(5000),
+        transitionSourceMode(_MODE_POWER_DOWN),
+        transitionSourceSubMode(SUBMODE_NONE) {
     commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
             MessageQueueMessage::MAX_MESSAGE_SIZE);
     insertInCommandMap(RAW_COMMAND_ID);
@@ -90,7 +90,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
     switch (getComAction()) {
     case CommunicationAction::SEND_WRITE:
         if (cookieInfo.state == COOKIE_UNUSED) {
-            // if no external command was specified, build internal command.
+            /* If no external command was specified, build internal command. */
             buildInternalCommand();
         }
         doSendWrite();
@@ -103,8 +103,8 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
         break;
     case CommunicationAction::GET_READ:
         doGetRead();
-        // This will be performed after datasets have been updated by the
-        // custom device implementation.
+        /* This will be performed after datasets have been updated by the
+        custom device implementation. */
         poolManager.performHkOperation();
         break;
     default:

From c1cb93baa9df763d08b6b7cd7c852b4400e537d1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Feb 2021 13:32:25 +0100
Subject: [PATCH 1557/1774] whitespace stuff

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index b2cc25da3..a1ad95483 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -18,7 +18,7 @@ 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, FailureIsolationBase* fdirInstance, size_t cmdQueueSize):
+        CookieIF* comCookie, FailureIsolationBase* fdirInstance, size_t cmdQueueSize):
         SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
         wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
         deviceCommunicationId(deviceCommunication), comCookie(comCookie),

From 093eb05269aa62f10edc25bba57da92c2dd469a6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Feb 2021 13:33:50 +0100
Subject: [PATCH 1558/1774] small formatting changes

---
 devicehandlers/DeviceHandlerBase.h | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 1d4a44248..f1dc99b91 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -716,15 +716,15 @@ protected:
     /** Cookie used for communication */
     CookieIF * comCookie;
 
-    /** Health helper for HasHealthIF */
+    /* Health helper for HasHealthIF */
     HealthHelper healthHelper;
-    /** Mode helper for HasModesIF */
+    /* Mode helper for HasModesIF */
     ModeHelper modeHelper;
-    /** Parameter helper for ReceivesParameterMessagesIF */
+    /* Parameter helper for ReceivesParameterMessagesIF */
     ParameterHelper parameterHelper;
-    /** Action helper for HasActionsIF */
+    /* Action helper for HasActionsIF */
     ActionHelper actionHelper;
-    /** Housekeeping Manager */
+    /* Housekeeping Manager */
     LocalDataPoolManager poolManager;
 
     /**
@@ -1161,7 +1161,6 @@ private:
 
     void buildRawDeviceCommand(CommandMessage* message);
     void buildInternalCommand(void);
-
     /**
      * Decrement the counter for the timout of replies.
      *
@@ -1169,7 +1168,6 @@ private:
      * reply has timed out (that means a reply was expected but not received).
      */
     void decrementDeviceReplyMap(void);
-
     /**
      * Convenience function to handle a reply.
      *
@@ -1184,8 +1182,8 @@ private:
      * @foundLen the length of the packet
      */
     void handleReply(const uint8_t *data, DeviceCommandId_t id, uint32_t foundLen);
-
     void replyToReply(DeviceReplyMap::iterator iter, ReturnValue_t status);
+
     /**
      * Build and send a command to the device.
      *
@@ -1200,7 +1198,6 @@ private:
      * sends the command via RMAP.
      */
     void doSendWrite(void);
-
     /**
      * Check if the RMAP sendWrite action was successful.
      *
@@ -1210,7 +1207,6 @@ private:
      * - if the action was successful, the reply timout counter is initialized
      */
     void doGetWrite(void);
-
     /**
      * Send a RMAP getRead command.
      *
@@ -1218,7 +1214,6 @@ private:
      * This is always executed, independently from the current mode.
      */
     void doSendRead(void);
-
     /**
      * Check the getRead reply and the contained data.
      *

From 6e5252b69e3c5837af96e5b4b772bff0cd9b80aa Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Feb 2021 13:35:10 +0100
Subject: [PATCH 1559/1774] some more small stuff

---
 devicehandlers/DeviceHandlerBase.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index f1dc99b91..a19e2cbc0 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -215,9 +215,8 @@ public:
     HealthState getHealth();
     ReturnValue_t setHealth(HealthState health);
     virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
-            ParameterWrapper *parameterWrapper,
-            const ParameterWrapper *newValues, uint16_t startAtIndex) override;
-
+            ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+            uint16_t startAtIndex) override;
 
 protected:
     /**

From 1446ce94bf9d96596ed89b23ced889c08bcb8894 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Feb 2021 16:31:03 +0100
Subject: [PATCH 1560/1774] small tweaks

---
 datapoollocal/LocalDataPoolManager.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 2c5c4e0ea..c8d1e30d6 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -848,7 +848,6 @@ MutexIF* LocalDataPoolManager::getLocalPoolMutex() {
 
 object_id_t LocalDataPoolManager::getCreatorObjectId() const {
 	return owner->getObjectId();
-	//return owner->getObjectId();
 }
 
 void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
@@ -885,7 +884,7 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 	if(outputType == sif::OutputTypes::OUT_WARNING) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalDataPoolManager::" << functionName
-				<< ": Object ID " << std::setw(8) << std::setfill('0')
+				<< ": Object ID 0x" << std::setw(8) << std::setfill('0')
 				<< std::hex << owner->getObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
@@ -896,7 +895,7 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 	else if(outputType == sif::OutputTypes::OUT_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalDataPoolManager::" << functionName
-				<< ": Object ID " << std::setw(8) << std::setfill('0')
+				<< ": Object ID 0x" << std::setw(8) << std::setfill('0')
 				<< std::hex << owner->getObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else

From 2bca40c527de985495220ee9ed734cb1f7bf6d2c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Feb 2021 18:04:55 +0100
Subject: [PATCH 1561/1774] printout improvements

---
 datapoollocal/LocalPoolDataSetBase.cpp |  2 +-
 pus/Service3Housekeeping.cpp           | 27 +++++++++++++++++---------
 2 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 035ba6945..d5c0556cf 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -83,7 +83,7 @@ ReturnValue_t LocalPoolDataSetBase::lockDataPool(
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
         size_t *size, size_t maxSize,
         SerializeIF::Endianness streamEndianness) const {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
     uint8_t validityMask[validityMaskSize];
     uint8_t validBufferIndex = 0;
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index ba7ff6ee4..16116ee6b 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -223,8 +223,11 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 
 	default:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "Service3Housekeeping::handleReply: Invalid reply with "
+		sif::warning << "Service3Housekeeping::handleReply: Invalid reply with "
 				<< "reply command " << command << "!" << std::endl;
+#else
+		sif::printWarning("Service3Housekeeping::handleReply: Invalid reply with "
+		        "reply command %hu!\n", command);
 #endif
 		return CommandingServiceBase::INVALID_REPLY;
 	}
@@ -250,20 +253,26 @@ void Service3Housekeeping::handleUnrequestedReply(
 		break;
 	}
 
-	default:
+	default: {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "Service3Housekeeping::handleUnrequestedReply: Invalid "
-		        << "reply with " << "reply command " << command << "!"
-		        << std::endl;
+        sif::warning << "Service3Housekeeping::handleUnrequestedReply: Invalid reply with reply "
+                "command " << command << "!" << std::endl;
+#else
+        sif::printWarning("Service3Housekeeping::handleUnrequestedReply: Invalid reply with "
+                "reply command %hu!\n", command);
 #endif
-		return;
+        return;
+	}
 	}
 
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-		// Configuration error
+		/* Configuration error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "Service3Housekeeping::handleUnrequestedReply:"
-				<< "Could not generate reply!" << std::endl;
+		sif::warning << "Service3Housekeeping::handleUnrequestedReply: Could not generate reply!" <<
+		        std::endl;
+#else
+		sif::printWarning("Service3Housekeeping::handleUnrequestedReply: "
+		        "Could not generate reply!\n");
 #endif
 	}
 }

From cdb012fe5a683a4bbd29c0ea1853971e2f0fdf69 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Feb 2021 22:09:22 +0100
Subject: [PATCH 1562/1774] important bugfix

---
 datapoollocal/LocalDataPoolManager.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index c8d1e30d6..48b4a0388 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -714,7 +714,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 		return;
 	}
 
-	if(periodicHelper->checkOpNecessary()) {
+	if(not periodicHelper->checkOpNecessary()) {
 		return;
 	}
 
@@ -723,11 +723,10 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		// configuration error
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalDataPoolManager::performHkOperation: "
-				<< "HK generation failed." << std::endl;
+		sif::warning << "LocalDataPoolManager::performHkOperation: HK generation failed." <<
+		        std::endl;
 #else
-		sif::printWarning("LocalDataPoolManager::performHkOperation: "
-				"HK generation failed.\n");
+		sif::printWarning("LocalDataPoolManager::performHkOperation: HK generation failed.\n");
 #endif
 	}
 }

From f7c1aae464ec533092ac0ea2906e9d06bb03a2ff Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Feb 2021 22:18:00 +0100
Subject: [PATCH 1563/1774] small tweak

---
 pus/Service3Housekeeping.cpp | 442 ++++++++++++++++++-----------------
 1 file changed, 225 insertions(+), 217 deletions(-)

diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index 16116ee6b..5456764d0 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -4,199 +4,199 @@
 
 
 Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid,
-			uint8_t serviceId):
-		CommandingServiceBase(objectId, apid, serviceId,
-		NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {}
+        uint8_t serviceId):
+        CommandingServiceBase(objectId, apid, serviceId,
+                NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {}
 
 Service3Housekeeping::~Service3Housekeeping() {}
 
 ReturnValue_t Service3Housekeeping::isValidSubservice(uint8_t subservice) {
-	switch(static_cast<Subservice>(subservice)) {
-	case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
-	case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
-	case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
-	case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
-	case Subservice::REPORT_HK_REPORT_STRUCTURES:
-	case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES :
-	case Subservice::GENERATE_ONE_PARAMETER_REPORT:
-	case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
-	case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
-	case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
-		return HasReturnvaluesIF::RETURN_OK;
-	// Telemetry or invalid subservice.
-	case Subservice::HK_DEFINITIONS_REPORT:
-	case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
-	case Subservice::HK_REPORT:
-	case Subservice::DIAGNOSTICS_REPORT:
-	default:
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
+    switch(static_cast<Subservice>(subservice)) {
+    case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
+    case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
+    case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+    case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+    case Subservice::REPORT_HK_REPORT_STRUCTURES:
+    case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES :
+    case Subservice::GENERATE_ONE_PARAMETER_REPORT:
+    case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
+    case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
+    case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
+        return HasReturnvaluesIF::RETURN_OK;
+        // Telemetry or invalid subservice.
+    case Subservice::HK_DEFINITIONS_REPORT:
+    case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
+    case Subservice::HK_REPORT:
+    case Subservice::DIAGNOSTICS_REPORT:
+    default:
+        return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+    }
 }
 
 ReturnValue_t Service3Housekeeping::getMessageQueueAndObject(uint8_t subservice,
-		const uint8_t *tcData, size_t tcDataLen,
-		MessageQueueId_t *id, object_id_t *objectId) {
-	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
-	if(result != RETURN_OK) {
-		return result;
-	}
-	return checkInterfaceAndAcquireMessageQueue(id,objectId);
+        const uint8_t *tcData, size_t tcDataLen,
+        MessageQueueId_t *id, object_id_t *objectId) {
+    ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
+    if(result != RETURN_OK) {
+        return result;
+    }
+    return checkInterfaceAndAcquireMessageQueue(id,objectId);
 }
 
 ReturnValue_t Service3Housekeeping::checkAndAcquireTargetID(
-		object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) {
-	if(SerializeAdapter::deSerialize(objectIdToSet, &tcData, &tcDataLen,
-	        SerializeIF::Endianness::BIG) != HasReturnvaluesIF::RETURN_OK) {
-		return CommandingServiceBase::INVALID_TC;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+        object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) {
+    if(SerializeAdapter::deSerialize(objectIdToSet, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG) != HasReturnvaluesIF::RETURN_OK) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Service3Housekeeping::checkInterfaceAndAcquireMessageQueue(
-		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-	// check HasLocalDataPoolIF property of target
-	HasLocalDataPoolIF* possibleTarget =
-			objectManager->get<HasLocalDataPoolIF>(*objectId);
-	if(possibleTarget == nullptr){
-		return CommandingServiceBase::INVALID_OBJECT;
-	}
-	*messageQueueToSet = possibleTarget->getCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
+        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+    // check HasLocalDataPoolIF property of target
+    HasLocalDataPoolIF* possibleTarget =
+            objectManager->get<HasLocalDataPoolIF>(*objectId);
+    if(possibleTarget == nullptr){
+        return CommandingServiceBase::INVALID_OBJECT;
+    }
+    *messageQueueToSet = possibleTarget->getCommandQueue();
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 
 ReturnValue_t Service3Housekeeping::prepareCommand(CommandMessage* message,
-		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-		uint32_t *state, object_id_t objectId) {
-	switch(static_cast<Subservice>(subservice)) {
-	case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
-		return prepareReportingTogglingCommand(message, objectId, true, false,
-				tcData, tcDataLen);
-	case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
-		return prepareReportingTogglingCommand(message, objectId, false, false,
-				tcData, tcDataLen);
-	case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
-		return prepareReportingTogglingCommand(message, objectId, true, true,
-				tcData, tcDataLen);
-	case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
-		return prepareReportingTogglingCommand(message, objectId, false, true,
-				tcData, tcDataLen);
-	case Subservice::REPORT_HK_REPORT_STRUCTURES:
-		return prepareStructureReportingCommand(message, objectId, false, tcData,
-				tcDataLen);
-	case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES:
-		return prepareStructureReportingCommand(message, objectId, true, tcData,
-				tcDataLen);
-	case Subservice::GENERATE_ONE_PARAMETER_REPORT:
-		return prepareOneShotReportCommand(message, objectId, false,
-				tcData, tcDataLen);
-	case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
-		return prepareOneShotReportCommand(message, objectId, true,
-				tcData, tcDataLen);
-	case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
-		return prepareCollectionIntervalModificationCommand(message, objectId,
-				false, tcData, tcDataLen);
-	case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
-		return prepareCollectionIntervalModificationCommand(message, objectId,
-				true, tcData, tcDataLen);
-	case Subservice::HK_DEFINITIONS_REPORT:
-	case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
-	case Subservice::HK_REPORT:
-	case Subservice::DIAGNOSTICS_REPORT:
-		// Those are telemetry packets.
-		return CommandingServiceBase::INVALID_TC;
-	default:
-		// should never happen, subservice was already checked.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+        uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+        uint32_t *state, object_id_t objectId) {
+    switch(static_cast<Subservice>(subservice)) {
+    case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
+        return prepareReportingTogglingCommand(message, objectId, true, false,
+                tcData, tcDataLen);
+    case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
+        return prepareReportingTogglingCommand(message, objectId, false, false,
+                tcData, tcDataLen);
+    case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+        return prepareReportingTogglingCommand(message, objectId, true, true,
+                tcData, tcDataLen);
+    case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+        return prepareReportingTogglingCommand(message, objectId, false, true,
+                tcData, tcDataLen);
+    case Subservice::REPORT_HK_REPORT_STRUCTURES:
+        return prepareStructureReportingCommand(message, objectId, false, tcData,
+                tcDataLen);
+    case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES:
+        return prepareStructureReportingCommand(message, objectId, true, tcData,
+                tcDataLen);
+    case Subservice::GENERATE_ONE_PARAMETER_REPORT:
+        return prepareOneShotReportCommand(message, objectId, false,
+                tcData, tcDataLen);
+    case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
+        return prepareOneShotReportCommand(message, objectId, true,
+                tcData, tcDataLen);
+    case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
+        return prepareCollectionIntervalModificationCommand(message, objectId,
+                false, tcData, tcDataLen);
+    case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
+        return prepareCollectionIntervalModificationCommand(message, objectId,
+                true, tcData, tcDataLen);
+    case Subservice::HK_DEFINITIONS_REPORT:
+    case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
+    case Subservice::HK_REPORT:
+    case Subservice::DIAGNOSTICS_REPORT:
+        // Those are telemetry packets.
+        return CommandingServiceBase::INVALID_TC;
+    default:
+        // should never happen, subservice was already checked.
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(
-		CommandMessage *command, object_id_t objectId,
-		bool enableReporting, bool isDiagnostics,
-		const uint8_t* tcData, size_t tcDataLen) {
-	if(tcDataLen < sizeof(sid_t)) {
-		// TC data should consist of object ID and set ID.
-		return CommandingServiceBase::INVALID_TC;
-	}
+        CommandMessage *command, object_id_t objectId,
+        bool enableReporting, bool isDiagnostics,
+        const uint8_t* tcData, size_t tcDataLen) {
+    if(tcDataLen < sizeof(sid_t)) {
+        // TC data should consist of object ID and set ID.
+        return CommandingServiceBase::INVALID_TC;
+    }
 
-	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
-	HousekeepingMessage::setToggleReportingCommand(command, targetSid,
-			enableReporting, isDiagnostics);
-	return HasReturnvaluesIF::RETURN_OK;
+    sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
+    HousekeepingMessage::setToggleReportingCommand(command, targetSid,
+            enableReporting, isDiagnostics);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Service3Housekeeping::prepareStructureReportingCommand(
-		CommandMessage *command, object_id_t objectId, bool isDiagnostics,
-		const uint8_t* tcData, size_t tcDataLen) {
-	if(tcDataLen < sizeof(sid_t)) {
-		// TC data should consist of object ID and set ID.
-		return CommandingServiceBase::INVALID_TC;
-	}
+        CommandMessage *command, object_id_t objectId, bool isDiagnostics,
+        const uint8_t* tcData, size_t tcDataLen) {
+    if(tcDataLen < sizeof(sid_t)) {
+        // TC data should consist of object ID and set ID.
+        return CommandingServiceBase::INVALID_TC;
+    }
 
-	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
-	HousekeepingMessage::setStructureReportingCommand(command, targetSid,
-			isDiagnostics);
-	return HasReturnvaluesIF::RETURN_OK;
+    sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
+    HousekeepingMessage::setStructureReportingCommand(command, targetSid,
+            isDiagnostics);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Service3Housekeeping::prepareOneShotReportCommand(
-		CommandMessage *command, object_id_t objectId, bool isDiagnostics,
-		const uint8_t *tcData, size_t tcDataLen) {
-	if(tcDataLen < sizeof(sid_t)) {
-		// TC data should consist of object ID and set ID.
-		return CommandingServiceBase::INVALID_TC;
-	}
+        CommandMessage *command, object_id_t objectId, bool isDiagnostics,
+        const uint8_t *tcData, size_t tcDataLen) {
+    if(tcDataLen < sizeof(sid_t)) {
+        // TC data should consist of object ID and set ID.
+        return CommandingServiceBase::INVALID_TC;
+    }
 
-	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
-	HousekeepingMessage::setOneShotReportCommand(command, targetSid,
-			isDiagnostics);
-	return HasReturnvaluesIF::RETURN_OK;
+    sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
+    HousekeepingMessage::setOneShotReportCommand(command, targetSid,
+            isDiagnostics);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand(
-		CommandMessage *command, object_id_t objectId, bool isDiagnostics,
-		const uint8_t *tcData, size_t tcDataLen) {
-	if(tcDataLen < sizeof(sid_t) + sizeof(float)) {
-		// SID plus the size of the new collection intervL.
-		return CommandingServiceBase::INVALID_TC;
-	}
+        CommandMessage *command, object_id_t objectId, bool isDiagnostics,
+        const uint8_t *tcData, size_t tcDataLen) {
+    if(tcDataLen < sizeof(sid_t) + sizeof(float)) {
+        // SID plus the size of the new collection intervL.
+        return CommandingServiceBase::INVALID_TC;
+    }
 
-	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
-	float newCollectionInterval = 0;
-	SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
-	HousekeepingMessage::setCollectionIntervalModificationCommand(command,
-			targetSid, newCollectionInterval, isDiagnostics);
-	return HasReturnvaluesIF::RETURN_OK;
+    sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
+    float newCollectionInterval = 0;
+    SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG);
+    HousekeepingMessage::setCollectionIntervalModificationCommand(command,
+            targetSid, newCollectionInterval, isDiagnostics);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 
 ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
-		Command_t previousCommand, uint32_t *state,
-		CommandMessage* optionalNextCommand, object_id_t objectId,
-		bool *isStep) {
-	Command_t command = reply->getCommand();
-	switch(command) {
+        Command_t previousCommand, uint32_t *state,
+        CommandMessage* optionalNextCommand, object_id_t objectId,
+        bool *isStep) {
+    Command_t command = reply->getCommand();
+    switch(command) {
 
-	case(HousekeepingMessage::HK_REPORT): {
-		ReturnValue_t result = generateHkReply(reply,
-				static_cast<uint8_t>(Subservice::HK_REPORT));
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return CommandingServiceBase::EXECUTION_COMPLETE;
-	}
+    case(HousekeepingMessage::HK_REPORT): {
+        ReturnValue_t result = generateHkReply(reply,
+                static_cast<uint8_t>(Subservice::HK_REPORT));
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        return CommandingServiceBase::EXECUTION_COMPLETE;
+    }
 
-	case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
-		ReturnValue_t result = generateHkReply(reply,
-				static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return CommandingServiceBase::EXECUTION_COMPLETE;
-	}
+    case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
+        ReturnValue_t result = generateHkReply(reply,
+                static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        return CommandingServiceBase::EXECUTION_COMPLETE;
+    }
 
     case(HousekeepingMessage::HK_DEFINITIONS_REPORT): {
         return generateHkReply(reply, static_cast<uint8_t>(
@@ -209,51 +209,59 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
         break;
     }
 
-	case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
-		return CommandingServiceBase::EXECUTION_COMPLETE;
-	}
+    case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
+        return CommandingServiceBase::EXECUTION_COMPLETE;
+    }
 
-	case(HousekeepingMessage::HK_REQUEST_FAILURE): {
-		failureParameter1 = objectId;
-		ReturnValue_t error = HasReturnvaluesIF::RETURN_FAILED;
-		HousekeepingMessage::getHkRequestFailureReply(reply,&error);
-		failureParameter2 = error;
-		return CommandingServiceBase::EXECUTION_COMPLETE;
-	}
+    case(HousekeepingMessage::HK_REQUEST_FAILURE): {
+        failureParameter1 = objectId;
+        ReturnValue_t error = HasReturnvaluesIF::RETURN_FAILED;
+        HousekeepingMessage::getHkRequestFailureReply(reply,&error);
+        failureParameter2 = error;
+        return CommandingServiceBase::EXECUTION_COMPLETE;
+    }
 
-	default:
+    default:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "Service3Housekeeping::handleReply: Invalid reply with "
-				<< "reply command " << command << "!" << std::endl;
+        sif::warning << "Service3Housekeeping::handleReply: Invalid reply with "
+        << "reply command " << command << "!" << std::endl;
 #else
-		sif::printWarning("Service3Housekeeping::handleReply: Invalid reply with "
-		        "reply command %hu!\n", command);
+        sif::printWarning("Service3Housekeeping::handleReply: Invalid reply with "
+                "reply command %hu!\n", command);
 #endif
-		return CommandingServiceBase::INVALID_REPLY;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+        return CommandingServiceBase::INVALID_REPLY;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void Service3Housekeeping::handleUnrequestedReply(
-		CommandMessage* reply) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	Command_t command = reply->getCommand();
+        CommandMessage* reply) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    Command_t command = reply->getCommand();
 
-	switch(command) {
+    switch(command) {
 
-	case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
-		result = generateHkReply(reply,
-				static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
-		break;
-	}
+    case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
+        result = generateHkReply(reply,
+                static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
+        break;
+    }
 
-	case(HousekeepingMessage::HK_REPORT): {
-		result = generateHkReply(reply,
-				static_cast<uint8_t>(Subservice::HK_REPORT));
-		break;
-	}
+    case(HousekeepingMessage::HK_REPORT): {
+        result = generateHkReply(reply,
+                static_cast<uint8_t>(Subservice::HK_REPORT));
+        break;
+    }
 
-	default: {
+    case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
+        break;
+    }
+
+    case(HousekeepingMessage::HK_REQUEST_FAILURE): {
+        break;
+    }
+
+    default: {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "Service3Housekeeping::handleUnrequestedReply: Invalid reply with reply "
                 "command " << command << "!" << std::endl;
@@ -262,49 +270,49 @@ void Service3Housekeeping::handleUnrequestedReply(
                 "reply command %hu!\n", command);
 #endif
         return;
-	}
-	}
+    }
+    }
 
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		/* Configuration error */
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        /* Configuration error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "Service3Housekeeping::handleUnrequestedReply: Could not generate reply!" <<
-		        std::endl;
+        sif::warning << "Service3Housekeeping::handleUnrequestedReply: Could not generate reply!" <<
+                std::endl;
 #else
-		sif::printWarning("Service3Housekeeping::handleUnrequestedReply: "
-		        "Could not generate reply!\n");
+        sif::printWarning("Service3Housekeeping::handleUnrequestedReply: "
+                "Could not generate reply!\n");
 #endif
-	}
+    }
 }
 
 MessageQueueId_t Service3Housekeeping::getHkQueue() const {
-	return commandQueue->getId();
+    return commandQueue->getId();
 }
 
 ReturnValue_t Service3Housekeeping::generateHkReply(
-		const CommandMessage* hkMessage, uint8_t subserviceId) {
-	store_address_t storeId;
+        const CommandMessage* hkMessage, uint8_t subserviceId) {
+    store_address_t storeId;
 
-	sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId);
-	auto resultPair = IPCStore->getData(storeId);
-	if(resultPair.first != HasReturnvaluesIF::RETURN_OK) {
-		return resultPair.first;
-	}
+    sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId);
+    auto resultPair = IPCStore->getData(storeId);
+    if(resultPair.first != HasReturnvaluesIF::RETURN_OK) {
+        return resultPair.first;
+    }
 
-	HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size());
-	return sendTmPacket(static_cast<uint8_t>(subserviceId),
-			hkPacket.hkData, hkPacket.hkSize, nullptr, 0);
+    HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size());
+    return sendTmPacket(static_cast<uint8_t>(subserviceId),
+            hkPacket.hkData, hkPacket.hkSize, nullptr, 0);
 }
 
 sid_t Service3Housekeeping::buildSid(object_id_t objectId,
-		const uint8_t** tcData, size_t* tcDataLen) {
-	sid_t targetSid;
-	targetSid.objectId = objectId;
-	// skip deserialization of object ID, was already done.
-	*tcData += sizeof(object_id_t);
-	*tcDataLen -= sizeof(object_id_t);
-	// size check is expected to be performed beforehand!
-	SerializeAdapter::deSerialize(&targetSid.ownerSetId, tcData, tcDataLen,
-			SerializeIF::Endianness::BIG);
-	return targetSid;
+        const uint8_t** tcData, size_t* tcDataLen) {
+    sid_t targetSid;
+    targetSid.objectId = objectId;
+    // skip deserialization of object ID, was already done.
+    *tcData += sizeof(object_id_t);
+    *tcDataLen -= sizeof(object_id_t);
+    // size check is expected to be performed beforehand!
+    SerializeAdapter::deSerialize(&targetSid.ownerSetId, tcData, tcDataLen,
+            SerializeIF::Endianness::BIG);
+    return targetSid;
 }

From 255d4a90a9861cc448a60be31e2e2f45f741d234 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Feb 2021 22:23:31 +0100
Subject: [PATCH 1564/1774] extended controller base

---
 controller/CMakeLists.txt             | 6 +++---
 controller/ExtendedControllerBase.cpp | 3 +++
 controller/ExtendedControllerBase.h   | 1 +
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/controller/CMakeLists.txt b/controller/CMakeLists.txt
index b7624d989..550acfcdd 100644
--- a/controller/CMakeLists.txt
+++ b/controller/CMakeLists.txt
@@ -1,4 +1,4 @@
-target_sources(${LIB_FSFW_NAME} 
-    PRIVATE 
-        ControllerBase.cpp
+target_sources(${LIB_FSFW_NAME} PRIVATE 
+    ControllerBase.cpp
+    ExtendedControllerBase.cpp
 )
\ No newline at end of file
diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 397c8c10f..cc93efa86 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -8,6 +8,9 @@ ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId,
         actionHelper(this, commandQueue) {
 }
 
+ExtendedControllerBase::~ExtendedControllerBase() {
+}
+
 ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
         MessageQueueId_t commandedBy, const uint8_t *data, size_t size) {
     // needs to be overriden and implemented by child class.
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index bcb414dd3..ae59b7588 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -22,6 +22,7 @@ class ExtendedControllerBase: public ControllerBase,
 public:
     ExtendedControllerBase(object_id_t objectId, object_id_t parentId,
             size_t commandQueueDepth = 3);
+    virtual ~ExtendedControllerBase();
 
     /** SystemObjectIF overrides */
     virtual ReturnValue_t initialize() override;

From 1829d9cf0a04b4ee9a01c3740db87a95e7568898 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 4 Feb 2021 01:31:46 +0100
Subject: [PATCH 1565/1774] lpid replaced by gpid

---
 controller/ExtendedControllerBase.h           | 10 +++----
 datapoollocal/HasLocalDataPoolIF.h            |  2 +-
 datapoollocal/LocalDataPoolManager.cpp        | 12 ++++----
 .../ProvidesDataPoolSubscriptionIF.h          |  4 +--
 housekeeping/HousekeepingMessage.cpp          | 30 ++++++++++++-------
 housekeeping/HousekeepingMessage.h            | 10 ++++---
 6 files changed, 39 insertions(+), 29 deletions(-)

diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index ae59b7588..f069819bc 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -24,12 +24,12 @@ public:
             size_t commandQueueDepth = 3);
     virtual ~ExtendedControllerBase();
 
-    /** SystemObjectIF overrides */
+    /* SystemObjectIF overrides */
     virtual ReturnValue_t initialize() override;
 
     virtual MessageQueueId_t getCommandQueue() const override;
 
-    /** ExecutableObjectIF overrides */
+    /* ExecutableObjectIF overrides */
     virtual ReturnValue_t performOperation(uint8_t opCode) override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
@@ -50,15 +50,15 @@ protected:
      */
     virtual void performControlOperation() = 0;
 
-    /** Handle the four messages mentioned above */
+    /* Handle the four messages mentioned above */
     void handleQueue() override;
 
-    /** HasActionsIF overrides */
+    /* HasActionsIF overrides */
     virtual ReturnValue_t executeAction(ActionId_t actionId,
             MessageQueueId_t commandedBy, const uint8_t* data,
             size_t size) override;
 
-    /** HasLocalDatapoolIF overrides */
+    /* HasLocalDatapoolIF overrides */
     virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual object_id_t getObjectId() const override;
     virtual ReturnValue_t initializeLocalDataPool(
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 1d87d47c9..055701750 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -80,7 +80,7 @@ public:
      * @param storeId If a snapshot was requested, data will be located inside
      * the IPC store with this store ID.
      */
-    virtual void handleChangedPoolVariable(lp_id_t poolId,
+    virtual void handleChangedPoolVariable(gp_id_t globPoolId,
             store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
         return;
     }
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 48b4a0388..dd0096846 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -166,7 +166,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
 			// prepare and send update notification.
 			CommandMessage notification;
 			HousekeepingMessage::setUpdateNotificationVariableCommand(&notification,
-					receiver.dataId.localPoolId);
+					gp_id_t(owner->getObjectId(), receiver.dataId.localPoolId));
 			ReturnValue_t result = hkQueue->sendMessage(
 					receiver.destinationQueue, &notification);
 			if(result != HasReturnvaluesIF::RETURN_OK) {
@@ -238,7 +238,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 
 		CommandMessage notification;
 		HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
-				receiver.dataId.localPoolId, storeId);
+				gp_id_t(owner->getObjectId(), receiver.dataId.localPoolId), storeId);
 		result = hkQueue->sendMessage(receiver.destinationQueue,
 				&notification);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -563,9 +563,9 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
-		lp_id_t locPoolId = HousekeepingMessage::
+		gp_id_t globPoolId = HousekeepingMessage::
 				getUpdateNotificationVariableCommand(message);
-		owner->handleChangedPoolVariable(locPoolId);
+		owner->handleChangedPoolVariable(globPoolId);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
@@ -576,9 +576,9 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 	}
 	case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
 		store_address_t storeId;
-		lp_id_t localPoolId = HousekeepingMessage::
+		gp_id_t globPoolId = HousekeepingMessage::
 				getUpdateSnapshotVariableCommand(message, &storeId);
-		owner->handleChangedPoolVariable(localPoolId, storeId);
+		owner->handleChangedPoolVariable(globPoolId, storeId);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index a0d73b93f..4a6cdb9f0 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -38,7 +38,6 @@ public:
             bool isDiagnostics,
             object_id_t packetDestination) = 0;
 
-
     /**
      * @brief   Subscribe for a notification message which will be sent
      *          if a dataset has changed.
@@ -54,8 +53,7 @@ public:
      * @return
      */
     virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
-            object_id_t destinationObject,
-            MessageQueueId_t targetQueueId,
+            object_id_t destinationObject, MessageQueueId_t targetQueueId,
             bool generateSnapshot) = 0;
 
     /**
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 5d7329610..d9803ef65 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -125,8 +125,10 @@ sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 	return sid;
 }
 
-void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
-	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
+gp_id_t HousekeepingMessage::getGpid(const CommandMessage* message) {
+    gp_id_t globalPoolId;
+    std::memcpy(&globalPoolId.raw, message->getData(), sizeof(globalPoolId.raw));
+    return globalPoolId;
 }
 
 void HousekeepingMessage::setHkStuctureReportReply(CommandMessage *reply,
@@ -169,9 +171,9 @@ void HousekeepingMessage::setUpdateNotificationSetCommand(
 }
 
 void HousekeepingMessage::setUpdateNotificationVariableCommand(
-        CommandMessage *command, lp_id_t localPoolId) {
+        CommandMessage *command, gp_id_t globalPoolId) {
     command->setCommand(UPDATE_NOTIFICATION_VARIABLE);
-    command->setParameter(localPoolId);
+    setGpid(command, globalPoolId);
 }
 
 void HousekeepingMessage::setUpdateSnapshotSetCommand(CommandMessage *command,
@@ -182,9 +184,9 @@ void HousekeepingMessage::setUpdateSnapshotSetCommand(CommandMessage *command,
 }
 
 void HousekeepingMessage::setUpdateSnapshotVariableCommand(
-        CommandMessage *command, lp_id_t localPoolId, store_address_t storeId) {
+        CommandMessage *command, gp_id_t globalPoolId, store_address_t storeId) {
     command->setCommand(UPDATE_SNAPSHOT_VARIABLE);
-    command->setParameter(localPoolId);
+    setGpid(command, globalPoolId);
     command->setParameter3(storeId.raw);
 }
 
@@ -193,9 +195,9 @@ sid_t HousekeepingMessage::getUpdateNotificationSetCommand(
     return getSid(command);
 }
 
-lp_id_t HousekeepingMessage::getUpdateNotificationVariableCommand(
+gp_id_t HousekeepingMessage::getUpdateNotificationVariableCommand(
         const CommandMessage *command) {
-    return command->getParameter();
+    return getGpid(command);
 }
 
 sid_t HousekeepingMessage::getUpdateSnapshotSetCommand(
@@ -206,10 +208,18 @@ sid_t HousekeepingMessage::getUpdateSnapshotSetCommand(
     return getSid(command);
 }
 
-lp_id_t HousekeepingMessage::getUpdateSnapshotVariableCommand(
+gp_id_t HousekeepingMessage::getUpdateSnapshotVariableCommand(
         const CommandMessage *command, store_address_t *storeId) {
     if(storeId != nullptr) {
         *storeId = command->getParameter3();
     }
-    return command->getParameter();
+    return getGpid(command);
+}
+
+void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
+    std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
+}
+
+void HousekeepingMessage::setGpid(CommandMessage *message, gp_id_t globalPoolId) {
+    std::memcpy(message->getData(), &globalPoolId.raw, sizeof(globalPoolId.raw));
 }
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 0c7680dc0..a38ff73fd 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -75,6 +75,7 @@ public:
 	//static constexpr Command_t UPDATE_HK_REPORT = MAKE_COMMAND_ID(134);
 
 	static sid_t getSid(const CommandMessage* message);
+	static gp_id_t getGpid(const CommandMessage* message);
 
 	/* Housekeeping Interface Messages */
 
@@ -123,26 +124,27 @@ public:
     static void setUpdateNotificationSetCommand(CommandMessage* command,
             sid_t sid);
     static void setUpdateNotificationVariableCommand(CommandMessage* command,
-            lp_id_t localPoolId);
+            gp_id_t globalPoolId);
 
     static void setUpdateSnapshotSetCommand(CommandMessage* command, sid_t sid,
             store_address_t storeId);
     static void setUpdateSnapshotVariableCommand(CommandMessage* command,
-            lp_id_t localPoolId, store_address_t storeId);
+            gp_id_t globalPoolId, store_address_t storeId);
 
     static sid_t getUpdateNotificationSetCommand(const CommandMessage* command);
-    static lp_id_t getUpdateNotificationVariableCommand(
+    static gp_id_t getUpdateNotificationVariableCommand(
             const CommandMessage* command);
 
     static sid_t getUpdateSnapshotSetCommand(const CommandMessage* command,
             store_address_t* storeId);
-    static lp_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command,
+    static gp_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command,
             store_address_t* storeId);
 
     /** Utility */
 	static void clear(CommandMessage* message);
 private:
 	static void setSid(CommandMessage* message, sid_t sid);
+	static void setGpid(CommandMessage* message, gp_id_t globalPoolId);
 };
 
 

From 6be6d593a32476fb811eeee983ae7ea61fe5c36c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 4 Feb 2021 13:46:27 +0100
Subject: [PATCH 1566/1774] minor tweaks

---
 datapoollocal/LocalDataPoolManager.cpp |  8 ++++++--
 datapoollocal/LocalPoolDataSetBase.cpp |  1 +
 devicehandlers/DeviceHandlerBase.cpp   | 17 +++++++----------
 osal/host/QueueMapManager.cpp          | 23 ++++++++++++++---------
 osal/host/QueueMapManager.h            |  2 +-
 5 files changed, 29 insertions(+), 22 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index dd0096846..e13337da4 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -881,6 +881,7 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 	}
 
 	if(outputType == sif::OutputTypes::OUT_WARNING) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalDataPoolManager::" << functionName
 				<< ": Object ID 0x" << std::setw(8) << std::setfill('0')
@@ -889,9 +890,11 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 #else
 		sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
 				functionName, owner->getObjectId(), errorPrint);
-#endif
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 	}
 	else if(outputType == sif::OutputTypes::OUT_ERROR) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalDataPoolManager::" << functionName
 				<< ": Object ID 0x" << std::setw(8) << std::setfill('0')
@@ -900,7 +903,8 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 #else
 		sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
 				functionName, owner->getObjectId(), errorPrint);
-#endif
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 	}
 }
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index d5c0556cf..00293645b 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -51,6 +51,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
         if(accessor != nullptr) {
             mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
+            poolManager = accessor->getPoolManagerHandle();
         }
     }
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index a1ad95483..35d34bf9b 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -435,8 +435,7 @@ 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;
@@ -701,13 +700,11 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
     ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
     DeviceCommandId_t foundId = DeviceHandlerIF::NO_COMMAND_ID;
     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.
+    /* 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);
+        result = scanForReply(receivedData, remainingLength, &foundId, &foundLen);
         switch (result) {
         case RETURN_OK:
             handleReply(receivedData, foundId, foundLen);
@@ -790,9 +787,9 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
         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.
+        /* 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);
         }
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 7ffd47583..9fb8b7a30 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -18,17 +18,19 @@ QueueMapManager* QueueMapManager::instance() {
 
 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
+	/* 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.
+		/* This should never happen for the atomic variable. */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "QueueMapManager: This ID is already inside the map!"
-				<< std::endl;
+		sif::error << "QueueMapManager::addMessageQueue This ID is already "
+		        "inside the map!" << std::endl;
+#else
+		sif::printError("QueueMapManager::addMessageQueue This ID is already "
+                "inside the map!\n");
 #endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -47,8 +49,11 @@ MessageQueueIF* QueueMapManager::getMessageQueue(
 	}
 	else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "QueueMapManager::getQueueHandle: The ID " <<
-				messageQueueId << " does not exists in the map" << std::endl;
+		sif::warning << "QueueMapManager::getQueueHandle: The ID " << messageQueueId <<
+		        " does not exists in the map!" << std::endl;
+#else
+		sif::printWarning("QueueMapManager::getQueueHandle: The ID %d does not exist in the map!\n",
+		        messageQueueId);
 #endif
 		return nullptr;
 	}
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
index d7d5c9154..3610ca638 100644
--- a/osal/host/QueueMapManager.h
+++ b/osal/host/QueueMapManager.h
@@ -36,7 +36,7 @@ public:
 private:
 	//! External instantiation is forbidden.
 	QueueMapManager();
-	uint32_t queueCounter = 1;
+	uint32_t queueCounter = 0;
 	MutexIF* mapLock;
 	QueueMap queueMap;
 	static QueueMapManager* mqManagerInstance;

From 3bd7ba961ea0980d081bd7f82d93c9e2fafac2ac Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 4 Feb 2021 15:04:52 +0100
Subject: [PATCH 1567/1774] just form stuff

---
 datapoollocal/LocalDataPoolManager.cpp        | 56 ++++++++-----------
 .../ProvidesDataPoolSubscriptionIF.h          | 24 ++++----
 2 files changed, 36 insertions(+), 44 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index e13337da4..447691632 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -102,7 +102,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
 		switch(receiver.reportingType) {
 		case(ReportingType::PERIODIC): {
 			if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-				// Periodic packets shall only be generated from datasets.
+				/* Periodic packets shall only be generated from datasets */
 				continue;
 			}
 			performPeriodicHkGeneration(receiver);
@@ -156,19 +156,17 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
 	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
 		LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
 				receiver.dataId.localPoolId);
-		//LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
 		if(poolObj == nullptr) {
 			printWarningOrError(sif::OutputTypes::OUT_WARNING,
 					"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
 			return POOLOBJECT_NOT_FOUND;
 		}
 		if(poolObj->hasChanged()) {
-			// prepare and send update notification.
+			/* Prepare and send update notification. */
 			CommandMessage notification;
 			HousekeepingMessage::setUpdateNotificationVariableCommand(&notification,
-					gp_id_t(owner->getObjectId(), receiver.dataId.localPoolId));
-			ReturnValue_t result = hkQueue->sendMessage(
-					receiver.destinationQueue, &notification);
+			        gp_id_t(owner->getObjectId(), receiver.dataId.localPoolId));
+			ReturnValue_t result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
 			if(result != HasReturnvaluesIF::RETURN_OK) {
 				status = result;
 			}
@@ -185,10 +183,10 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
 			return DATASET_NOT_FOUND;
 		}
 		if(dataSet->hasChanged()) {
-			// prepare and send update notification
+			/* Prepare and send update notification */
 			CommandMessage notification;
-			HousekeepingMessage::setUpdateNotificationSetCommand(
-					&notification, receiver.dataId.sid);
+			HousekeepingMessage::setUpdateNotificationSetCommand(&notification,
+			        receiver.dataId.sid);
 			ReturnValue_t result = hkQueue->sendMessage(
 					receiver.destinationQueue, &notification);
 			if(result != HasReturnvaluesIF::RETURN_OK) {
@@ -198,8 +196,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
 		}
 	}
 	if(toReset != nullptr) {
-		handleChangeResetLogic(receiver.dataType,
-				receiver.dataId, toReset);
+		handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -207,7 +204,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
 ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 		HkReceiver& receiver, ReturnValue_t& status) {
 	MarkChangedIF* toReset = nullptr;
-	// check whether data has changed and send messages in case it has.
+	/* Check whether data has changed and send messages in case it has */
 	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
 		LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
 				receiver.dataId.localPoolId);
@@ -221,14 +218,14 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 
-		// prepare and send update snapshot.
+		/* Prepare and send update snapshot */
 		timeval now;
 		Clock::getClock_timeval(&now);
 		CCSDSTime::CDS_short cds;
 		CCSDSTime::convertToCcsds(&cds, &now);
-		HousekeepingSnapshot updatePacket(reinterpret_cast<uint8_t*>(&cds),
-				sizeof(cds), HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
-						receiver.dataId.localPoolId));
+		HousekeepingSnapshot updatePacket(reinterpret_cast<uint8_t*>(&cds), sizeof(cds),
+		        HasLocalDpIFManagerAttorney::getPoolObjectHandle(
+		                owner,receiver.dataId.localPoolId));
 
 		store_address_t storeId;
 		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
@@ -259,7 +256,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 
-		// prepare and send update snapshot.
+		/* Prepare and send update snapshot */
 		timeval now;
 		Clock::getClock_timeval(&now);
 		CCSDSTime::CDS_short cds;
@@ -309,7 +306,7 @@ ReturnValue_t LocalDataPoolManager::addUpdateToStore(
 void LocalDataPoolManager::handleChangeResetLogic(
 		DataType type, DataId dataId, MarkChangedIF* toReset) {
 	if(hkUpdateResetList == nullptr) {
-		// config error!
+		/* Config error */
 		return;
 	}
 	HkUpdateResetList& listRef = *hkUpdateResetList;
@@ -326,16 +323,16 @@ void LocalDataPoolManager::handleChangeResetLogic(
 			continue;
 		}
 
-		// only one update recipient, we can reset changes status immediately.
+		/* Only one update recipient, we can reset changes status immediately */
 		if(changeInfo.updateCounter <= 1) {
 			toReset->setChanged(false);
 		}
-		// All recipients have been notified, reset the changed flag.
+		/* All recipients have been notified, reset the changed flag */
 		if(changeInfo.currentUpdateCounter <= 1) {
 			toReset->setChanged(false);
 			changeInfo.currentUpdateCounter = 0;
 		}
-		// Not all recipiens have been notified yet, decrement.
+		/* Not all recipiens have been notified yet, decrement */
 		else {
 			changeInfo.currentUpdateCounter--;
 		}
@@ -371,7 +368,6 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
 	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	if(dataSet != nullptr) {
 		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enableReporting);
 		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
@@ -557,14 +553,13 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 				dataSet, true);
 	}
 
-	// Notification handling.
+	/* Notification handling */
 	case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
 		owner->handleChangedDataset(sid);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
-		gp_id_t globPoolId = HousekeepingMessage::
-				getUpdateNotificationVariableCommand(message);
+		gp_id_t globPoolId = HousekeepingMessage::getUpdateNotificationVariableCommand(message);
 		owner->handleChangedPoolVariable(globPoolId);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -576,8 +571,8 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 	}
 	case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
 		store_address_t storeId;
-		gp_id_t globPoolId = HousekeepingMessage::
-				getUpdateSnapshotVariableCommand(message, &storeId);
+		gp_id_t globPoolId = HousekeepingMessage::getUpdateSnapshotVariableCommand(message,
+		        &storeId);
 		owner->handleChangedPoolVariable(globPoolId, storeId);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -693,7 +688,6 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 	sid_t sid = receiver.dataId.sid;
-	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
 	if(dataSet == nullptr) {
 		printWarningOrError(sif::OutputTypes::OUT_WARNING,
@@ -710,7 +704,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 			LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
 
 	if(periodicHelper == nullptr) {
-		// Configuration error.
+		/* Configuration error */
 		return;
 	}
 
@@ -721,7 +715,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 	ReturnValue_t result = generateHousekeepingPacket(
 			sid, dataSet, true);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-		// configuration error
+		/* Configuration error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalDataPoolManager::performHkOperation: HK generation failed." <<
 		        std::endl;
@@ -734,7 +728,6 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
 		bool enable, bool isDiagnostics) {
-	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
 	if((LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and not isDiagnostics) or
 			(not LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and isDiagnostics)) {
@@ -752,7 +745,6 @@ ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 		float newCollectionInterval, bool isDiagnostics) {
-	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
 	bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
 	if((targetIsDiagnostics and not isDiagnostics) or
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index 4a6cdb9f0..ead479cc2 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -44,12 +44,12 @@ public:
      * @details
      * This subscription mechanism will generally be used internally by
      * other software components.
-     * @param setId     Set ID of the set to receive update messages from.
-     * @param destinationObject
-     * @param targetQueueId
-     * @param generateSnapshot If this is set to true, a copy of the current
-     * data with a timestamp will be generated and sent via message.
-     * Otherwise, only an notification message is sent.
+     * @param setId                 Set ID of the set to receive update messages from.
+     * @param destinationObject     Object ID of the receiver.
+     * @param targetQueueId         Receiver queue ID
+     * @param generateSnapshot      If this is set to true, a copy of the current data with a
+     *                              timestamp will be generated and sent via message.
+     *                              Otherwise, only an notification message is sent.
      * @return
      */
     virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
@@ -62,12 +62,12 @@ public:
      * @details
      * This subscription mechanism will generally be used internally by
      * other software components.
-     * @param localPoolId Pool ID of the pool variable
-     * @param destinationObject
-     * @param targetQueueId
-     * @param generateSnapshot If this is set to true, a copy of the current
-     * data with a timestamp will be generated and sent via message.
-     * Otherwise, only an notification message is sent.
+     * @param localPoolId           Pool ID of the pool variable
+     * @param destinationObject     Object ID of the receiver
+     * @param targetQueueId         Receiver queue ID
+     * @param generateSnapshot      If this is set to true, a copy of the current data with a
+     *                              timestamp will be generated and sent via message. Otherwise,
+     *                              only an notification message is sent.
      * @return
      */
     virtual ReturnValue_t subscribeForVariableUpdateMessages(

From d736e9c8742029de0793fb783229ab700c35843d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 6 Feb 2021 14:15:56 +0100
Subject: [PATCH 1568/1774] deleted ctors

---
 datapool/PoolDataSetBase.cpp           | 18 ++++++++++++++++++
 datapool/PoolDataSetBase.h             | 14 ++++++++------
 datapoollocal/LocalPoolDataSetBase.cpp | 10 ++++++++++
 datapoollocal/LocalPoolDataSetBase.h   |  9 ++++++++-
 4 files changed, 44 insertions(+), 7 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 010697854..7d50a40af 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -1,5 +1,6 @@
 #include "PoolDataSetBase.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
 
 PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
         const size_t maxFillCount):
@@ -228,3 +229,20 @@ void PoolDataSetBase::setReadCommitProtectionBehaviour(
 	this->timeoutTypeForSingleVars = timeoutType;
 	this->mutexTimeoutForSingleVars = mutexTimeout;
 }
+
+/* We really should supply the container as a template argument instead of writing sth like this */
+//PoolDataSetBase::PoolDataSetBase(const PoolDataSetBase &otherSet):
+//          fillCount(otherSet.fillCount), state(otherSet.state),
+//          maxFillCount(otherSet.maxFillCount),
+//          protectEveryReadCommitCall(otherSet.protectEveryReadCommitCall),
+//          timeoutTypeForSingleVars(otherSet.timeoutTypeForSingleVars),
+//          mutexTimeoutForSingleVars(otherSet.mutexTimeoutForSingleVars) {
+//    if(registeredVariables != nullptr and otherSet.registeredVariables != nullptr) {
+//        std::memcpy(reinterpret_cast<void*>(*(this->registeredVariables)),
+//                reinterpret_cast<const void*>(*(otherSet.registeredVariables)),
+//                fillCount * sizeof(PoolVariableIF*));
+//    }
+//}
+//
+//const PoolDataSetBase& PoolDataSetBase::operator=(const PoolDataSetBase &otherSet) {
+//}
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 756541469..ab8954557 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -39,8 +39,12 @@ public:
 	 * 			supply a pointer to this dataset to PoolVariable
 	 * 			initializations to register pool variables.
 	 */
-	PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
-	        const size_t maxFillCount);
+	PoolDataSetBase(PoolVariableIF** registeredVariablesArray, const size_t maxFillCount);
+
+	/* Forbidden for now */
+	PoolDataSetBase(const PoolDataSetBase& otherSet) = delete;
+	const PoolDataSetBase& operator=(const PoolDataSetBase& otherSet) = delete;
+
 	virtual~ PoolDataSetBase();
 
 	/**
@@ -63,8 +67,7 @@ public:
 	 * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
 	 *      commit() in between
 	 */
-	virtual ReturnValue_t read(
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+	virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
 			uint32_t lockTimeout = 20) override;
 	/**
 	 * @brief	The commit call initializes writing back the registered variables.
@@ -84,8 +87,7 @@ public:
 	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
 	 * 			  contains non write-only variables
 	 */
-	virtual ReturnValue_t commit(
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+	virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
 			uint32_t lockTimeout = 20) override;
 
 	/**
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 00293645b..d1d95d8a8 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -67,9 +67,19 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(
 
 
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
+    /* We only delete objects which were created in the class constructor */
     if(periodicHelper != nullptr) {
         delete periodicHelper;
     }
+    /* In case set was read but not comitted, we commit all variables with an invalid state */
+    if(state == States::STATE_SET_WAS_READ) {
+        for (uint16_t count = 0; count < fillCount; count++) {
+            if(registeredVariables[count] != nullptr) {
+                registeredVariables[count]->setValid(false);
+                registeredVariables[count]->commit(MutexIF::TimeoutType::WAITING, 20);
+            }
+        }
+    }
 }
 
 ReturnValue_t LocalPoolDataSetBase::lockDataPool(
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index cc41b0eb2..ca9074311 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -97,12 +97,18 @@ public:
      * @brief	The destructor automatically manages writing the valid
      * 			information of variables.
      * @details
-     * In case the data set was read out, but not committed(indicated by state),
+     * In case the data set was read out, but not committed (indicated by state),
      * the destructor parses all variables that are still registered to the set.
      * For each, the valid flag in the data pool is set to "invalid".
      */
     ~LocalPoolDataSetBase();
 
+    /* The copy constructor and assingment constructor are forbidden for now.
+    The use-cases are limited and the first step would be to implement them properly for the
+    base class */
+    LocalPoolDataSetBase(const LocalPoolDataSetBase& otherSet) = delete;
+    const LocalPoolDataSetBase& operator=(const LocalPoolDataSetBase& otherSet) = delete;
+
     void setValidityBufferGeneration(bool withValidityBuffer);
 
     sid_t getSid() const;
@@ -153,6 +159,7 @@ public:
     bool hasChanged() const override;
 
     object_id_t getCreatorObjectId();
+
 protected:
     sid_t sid;
     //! This mutex is used if the data is created by one object only.

From 9b2772c12660f95a1977cb098a0f7b29ddf3c7d1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 8 Feb 2021 13:42:44 +0100
Subject: [PATCH 1569/1774] better diagnostic printout if case there are issues

---
 tmtcservices/CommandingServiceBase.cpp | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 259f2ccbc..8b6f7a097 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -7,6 +7,7 @@
 #include "../ipc/QueueFactory.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcpacket/pus/TmPacketStored.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
 object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
@@ -104,9 +105,27 @@ ReturnValue_t CommandingServiceBase::initialize() {
 void CommandingServiceBase::handleCommandQueue() {
 	CommandMessage reply;
 	ReturnValue_t result = RETURN_FAILED;
-	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&reply)) {
-		handleCommandMessage(&reply);
+	while(true) {
+	    result = commandQueue->receiveMessage(&reply);
+	    if (result == HasReturnvaluesIF::RETURN_OK) {
+	        handleCommandMessage(&reply);
+	        continue;
+	    }
+	    else if(result == MessageQueueIF::EMPTY) {
+	        break;
+	    }
+	    else {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	        sif::warning << "CommandingServiceBase::handleCommandQueue: Receiving message failed"
+	                "with code" << result << std::endl;
+#else
+	        sif::printWarning("CommandingServiceBase::handleCommandQueue: Receiving message "
+	                "failed with code %d\n", result);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+	        break;
+	    }
 	}
 }
 

From d4d3da60a914655de6ef3e65adca2f68f0c9234a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 8 Feb 2021 13:47:20 +0100
Subject: [PATCH 1570/1774] format improvements

---
 datapoollocal/LocalPoolObjectBase.h | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 797cf8b5a..3f7fb6ddf 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -20,12 +20,10 @@ class LocalPoolObjectBase: public PoolVariableIF,
         public HasReturnvaluesIF,
         public MarkChangedIF {
 public:
-    LocalPoolObjectBase(lp_id_t poolId,
-            HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+    LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
             pool_rwm_t setReadWriteMode);
 
-    LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
-            DataSetIF* dataSet = nullptr,
+    LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF* dataSet = nullptr,
             pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
     void setReadWriteMode(pool_rwm_t newReadWriteMode);

From 9998de086fc2e469dd370b4b36dcb854c5d233d8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 8 Feb 2021 14:20:36 +0100
Subject: [PATCH 1571/1774] added printouts for action helper

---
 action/ActionHelper.cpp | 36 +++++++++++++++++++++++-------------
 action/ActionHelper.h   |  3 ++-
 2 files changed, 25 insertions(+), 14 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 23c9d7329..e32be68b2 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -3,6 +3,7 @@
 
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 ActionHelper::ActionHelper(HasActionsIF* setOwner,
         MessageQueueIF* useThisQueue) :
@@ -86,13 +87,20 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
     uint8_t *dataPtr;
     size_t maxSize = data->getSerializedSize();
     if (maxSize == 0) {
-        //No error, there's simply nothing to report.
+        /* No error, there's simply nothing to report. */
         return HasReturnvaluesIF::RETURN_OK;
     }
     size_t size = 0;
     ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
             &dataPtr);
     if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ActionHelper::reportData: Getting free element from IPC store failed!" <<
+                std::endl;
+#else
+        sif::printWarning("ActionHelper::reportData: Getting free element from IPC "
+                "store failed!\n");
+#endif
         return result;
     }
     result = data->serialize(&dataPtr, &size, maxSize,
@@ -101,14 +109,13 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
         ipcStore->deleteData(storeAddress);
         return result;
     }
-    // We don't need to report the objectId, as we receive REQUESTED data
-    // before the completion success message.
-    // True aperiodic replies need to be reported with
-    // another dedicated message.
+
+    /* We don't need to report the objectId, as we receive REQUESTED data before the completion
+    success message. True aperiodic replies need to be reported with another dedicated message. */
     ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
-    // If the sender needs to be hidden, for example to handle packet
-    // as unrequested reply, this will be done here.
+    /* If the sender needs to be hidden, for example to handle packet
+    as unrequested reply, this will be done here. */
     if (hideSender) {
         result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
     }
@@ -132,6 +139,11 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
     store_address_t storeAddress;
     ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
     if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ActionHelper::reportData: Adding data to IPC store failed!" << std::endl;
+#else
+        sif::printWarning("ActionHelper::reportData: Adding data to IPC store failed!\n");
+#endif
         return result;
     }
 
@@ -140,14 +152,12 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
         return result;
     }
 
-    // We don't need to report the objectId, as we receive REQUESTED data
-    // before the completion success message.
-    // True aperiodic replies need to be reported with
-    // another dedicated message.
+    /* We don't need to report the objectId, as we receive REQUESTED data before the completion
+    success message. True aperiodic replies need to be reported with another dedicated message. */
     ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
-    // If the sender needs to be hidden, for example to handle packet
-    // as unrequested reply, this will be done here.
+    /* If the sender needs to be hidden, for example to handle packet
+    as unrequested reply, this will be done here. */
     if (hideSender) {
         result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
     }
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index ae971d382..35ac41d1c 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -101,7 +101,8 @@ public:
 protected:
     //! Increase of value of this per step
     static const uint8_t STEP_OFFSET = 1;
-    HasActionsIF* owner;//!< Pointer to the owner
+    //! Pointer to the owner
+    HasActionsIF* owner;
     //! Queue to be used as response sender, has to be set in ctor or with
     //! setQueueToUse
     MessageQueueIF* queueToUse;

From 16763202c1e6ba0cf83f1dea6bece23b894e0723 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 8 Feb 2021 14:22:34 +0100
Subject: [PATCH 1572/1774] taken over action folder

---
 action/ActionHelper.cpp        | 214 +++++++++++++++++----------------
 action/ActionHelper.h          | 177 +++++++++++++--------------
 action/ActionMessage.cpp       |  86 ++++++-------
 action/ActionMessage.h         |  44 +++----
 action/CommandActionHelper.cpp | 188 ++++++++++++++---------------
 action/CommandActionHelper.h   |  36 +++---
 action/CommandsActionsIF.h     |  28 ++---
 action/HasActionsIF.h          |  44 +++----
 action/SimpleActionHelper.cpp  | 102 ++++++++--------
 action/SimpleActionHelper.h    |  30 ++---
 10 files changed, 480 insertions(+), 469 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 285579160..e32be68b2 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -3,151 +3,119 @@
 
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 ActionHelper::ActionHelper(HasActionsIF* setOwner,
         MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue) {
+        owner(setOwner), queueToUse(useThisQueue) {
 }
 
 ActionHelper::~ActionHelper() {
 }
 
 ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
-	if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
-		ActionId_t currentAction = ActionMessage::getActionId(command);
-		prepareExecution(command->getSender(), currentAction,
-				ActionMessage::getStoreId(command));
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return CommandMessage::UNKNOWN_COMMAND;
-	}
+    if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
+        ActionId_t currentAction = ActionMessage::getActionId(command);
+        prepareExecution(command->getSender(), currentAction,
+                ActionMessage::getStoreId(command));
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return CommandMessage::UNKNOWN_COMMAND;
+    }
 }
 
 ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(queueToUse_ != nullptr) {
-		setQueueToUse(queueToUse_);
-	}
+    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if (ipcStore == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    if(queueToUse_ != nullptr) {
+        setQueueToUse(queueToUse_);
+    }
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo,
         ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
-	queueToUse->sendMessage(reportTo, &reply);
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
+    queueToUse->sendMessage(reportTo, &reply);
 }
 
 void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId,
         ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setCompletionReply(&reply, commandId, result);
-	queueToUse->sendMessage(reportTo, &reply);
+    CommandMessage reply;
+    ActionMessage::setCompletionReply(&reply, commandId, result);
+    queueToUse->sendMessage(reportTo, &reply);
 }
 
 void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
-	queueToUse = queue;
+    queueToUse = queue;
 }
 
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
         ActionId_t actionId, store_address_t dataAddress) {
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	if(result == HasActionsIF::EXECUTION_FINISHED) {
-		CommandMessage reply;
-		ActionMessage::setCompletionReply(&reply, actionId, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-	}
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
+    const uint8_t* dataPtr = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        CommandMessage reply;
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
+    result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+    ipcStore->deleteData(dataAddress);
+    if(result == HasActionsIF::EXECUTION_FINISHED) {
+        CommandMessage reply;
+        ActionMessage::setCompletionReply(&reply, actionId, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+    }
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        CommandMessage reply;
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
 }
 
 ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
-		ActionId_t replyId, SerializeIF* data, bool hideSender) {
-	CommandMessage reply;
-	store_address_t storeAddress;
-	uint8_t *dataPtr;
-	size_t maxSize = data->getSerializedSize();
-	if (maxSize == 0) {
-		//No error, there's simply nothing to report.
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
-			&dataPtr);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = data->serialize(&dataPtr, &size, maxSize,
-	        SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeAddress);
-		return result;
-	}
-	// We don't need to report the objectId, as we receive REQUESTED data
-	// before the completion success message.
-	// True aperiodic replies need to be reported with
-	// another dedicated message.
-	ActionMessage::setDataReply(&reply, replyId, storeAddress);
-
-    // If the sender needs to be hidden, for example to handle packet
-    // as unrequested reply, this will be done here.
-	if (hideSender) {
-		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
-	}
-	else {
-		result = queueToUse->sendMessage(reportTo, &reply);
-	}
-
-	if (result != HasReturnvaluesIF::RETURN_OK){
-		ipcStore->deleteData(storeAddress);
-	}
-	return result;
-}
-
-void ActionHelper::resetHelper() {
-}
-
-ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
-        ActionId_t replyId, const uint8_t *data, size_t dataSize,
-        bool hideSender) {
+        ActionId_t replyId, SerializeIF* data, bool hideSender) {
     CommandMessage reply;
     store_address_t storeAddress;
-    ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
+    uint8_t *dataPtr;
+    size_t maxSize = data->getSerializedSize();
+    if (maxSize == 0) {
+        /* No error, there's simply nothing to report. */
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
+            &dataPtr);
     if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ActionHelper::reportData: Getting free element from IPC store failed!" <<
+                std::endl;
+#else
+        sif::printWarning("ActionHelper::reportData: Getting free element from IPC "
+                "store failed!\n");
+#endif
         return result;
     }
-
+    result = data->serialize(&dataPtr, &size, maxSize,
+            SerializeIF::Endianness::BIG);
     if (result != HasReturnvaluesIF::RETURN_OK) {
         ipcStore->deleteData(storeAddress);
         return result;
     }
 
-    // We don't need to report the objectId, as we receive REQUESTED data
-    // before the completion success message.
-    // True aperiodic replies need to be reported with
-    // another dedicated message.
+    /* We don't need to report the objectId, as we receive REQUESTED data before the completion
+    success message. True aperiodic replies need to be reported with another dedicated message. */
     ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
-    // If the sender needs to be hidden, for example to handle packet
-    // as unrequested reply, this will be done here.
+    /* If the sender needs to be hidden, for example to handle packet
+    as unrequested reply, this will be done here. */
     if (hideSender) {
         result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
     }
@@ -160,3 +128,45 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
     }
     return result;
 }
+
+void ActionHelper::resetHelper() {
+}
+
+ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
+        ActionId_t replyId, const uint8_t *data, size_t dataSize,
+        bool hideSender) {
+    CommandMessage reply;
+    store_address_t storeAddress;
+    ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ActionHelper::reportData: Adding data to IPC store failed!" << std::endl;
+#else
+        sif::printWarning("ActionHelper::reportData: Adding data to IPC store failed!\n");
+#endif
+        return result;
+    }
+
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeAddress);
+        return result;
+    }
+
+    /* We don't need to report the objectId, as we receive REQUESTED data before the completion
+    success message. True aperiodic replies need to be reported with another dedicated message. */
+    ActionMessage::setDataReply(&reply, replyId, storeAddress);
+
+    /* If the sender needs to be hidden, for example to handle packet
+    as unrequested reply, this will be done here. */
+    if (hideSender) {
+        result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+    }
+    else {
+        result = queueToUse->sendMessage(reportTo, &reply);
+    }
+
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeAddress);
+    }
+    return result;
+}
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index a91722f39..35ac41d1c 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -18,68 +18,68 @@ class HasActionsIF;
 
 class ActionHelper {
 public:
-	/**
-	 * Constructor of the action helper
-	 * @param setOwner Pointer to the owner of the interface
-	 * @param useThisQueue  messageQueue to be used, can be set during
-	 *                      initialize function as well.
-	 */
-	ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+    /**
+     * Constructor of the action helper
+     * @param setOwner Pointer to the owner of the interface
+     * @param useThisQueue  messageQueue to be used, can be set during
+     *                      initialize function as well.
+     */
+    ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
 
-	virtual ~ActionHelper();
-	/**
-	 * Function to be called from the owner with a new command message
-	 *
-	 * If the message is a valid action message the helper will use the
-	 * executeAction function from HasActionsIF.
-	 * If the message is invalid or the callback fails a message reply will be
-	 * send to the sender of the message automatically.
-	 *
-	 * @param command Pointer to a command message received by the owner
-	 * @return HasReturnvaluesIF::RETURN_OK if the message is a action message,
-	 *         CommandMessage::UNKNOW_COMMAND if this message ID is unkown
-	 */
-	ReturnValue_t handleActionMessage(CommandMessage* command);
-	/**
-	 * Helper initialize function. Must be called before use of any other
-	 * helper function
-	 * @param queueToUse_   Pointer to the messageQueue to be used, optional
-	 *                      if queue was set in constructor
-	 * @return Returns RETURN_OK if successful
-	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
-	/**
-	 * Function to be called from the owner to send a step message.
-	 * Success or failure will be determined by the result value.
-	 *
-	 * @param step Number of steps already done
-	 * @param reportTo The messageQueueId to report the step message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void step(uint8_t step, MessageQueueId_t reportTo,
-			ActionId_t commandId,
-			ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner to send a action completion message
-	 *
-	 * @param reportTo MessageQueueId_t to report the action completion message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void finish(MessageQueueId_t reportTo, ActionId_t commandId,
-	        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner if an action does report data.
-	 * Takes a SerializeIF* pointer and serializes it into the IPC store.
-	 * @param reportTo  MessageQueueId_t to report the action completion
-	 *                  message to
-	 * @param replyId ID of the executed command
-	 * @param data Pointer to the data
-	 * @return Returns RETURN_OK if successful, otherwise failure code
-	 */
-	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
-	        SerializeIF* data, bool hideSender = false);
+    virtual ~ActionHelper();
+    /**
+     * Function to be called from the owner with a new command message
+     *
+     * If the message is a valid action message the helper will use the
+     * executeAction function from HasActionsIF.
+     * If the message is invalid or the callback fails a message reply will be
+     * send to the sender of the message automatically.
+     *
+     * @param command Pointer to a command message received by the owner
+     * @return HasReturnvaluesIF::RETURN_OK if the message is a action message,
+     *         CommandMessage::UNKNOW_COMMAND if this message ID is unkown
+     */
+    ReturnValue_t handleActionMessage(CommandMessage* command);
+    /**
+     * Helper initialize function. Must be called before use of any other
+     * helper function
+     * @param queueToUse_   Pointer to the messageQueue to be used, optional
+     *                      if queue was set in constructor
+     * @return Returns RETURN_OK if successful
+     */
+    ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
+    /**
+     * Function to be called from the owner to send a step message.
+     * Success or failure will be determined by the result value.
+     *
+     * @param step Number of steps already done
+     * @param reportTo The messageQueueId to report the step message to
+     * @param commandId ID of the executed command
+     * @param result Result of the execution
+     */
+    void step(uint8_t step, MessageQueueId_t reportTo,
+            ActionId_t commandId,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    /**
+     * Function to be called by the owner to send a action completion message
+     *
+     * @param reportTo MessageQueueId_t to report the action completion message to
+     * @param commandId ID of the executed command
+     * @param result Result of the execution
+     */
+    void finish(MessageQueueId_t reportTo, ActionId_t commandId,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    /**
+     * Function to be called by the owner if an action does report data.
+     * Takes a SerializeIF* pointer and serializes it into the IPC store.
+     * @param reportTo  MessageQueueId_t to report the action completion
+     *                  message to
+     * @param replyId ID of the executed command
+     * @param data Pointer to the data
+     * @return Returns RETURN_OK if successful, otherwise failure code
+     */
+    ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
+            SerializeIF* data, bool hideSender = false);
     /**
      * Function to be called by the owner if an action does report data.
      * Takes the raw data and writes it into the IPC store.
@@ -91,35 +91,36 @@ public:
      */
     ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
             const uint8_t* data, size_t dataSize, bool hideSender = false);
-	/**
-	 * Function to setup the MessageQueueIF* of the helper. Can be used to
-	 * set the MessageQueueIF* if message queue is unavailable at construction
-	 * and initialize but must be setup before first call of other functions.
-	 * @param queue Queue to be used by the helper
-	 */
-	void setQueueToUse(MessageQueueIF *queue);
+    /**
+     * Function to setup the MessageQueueIF* of the helper. Can be used to
+     * set the MessageQueueIF* if message queue is unavailable at construction
+     * and initialize but must be setup before first call of other functions.
+     * @param queue Queue to be used by the helper
+     */
+    void setQueueToUse(MessageQueueIF *queue);
 protected:
-	//!< Increase of value of this per step
-	static const uint8_t STEP_OFFSET = 1;
-	HasActionsIF* owner;//!< Pointer to the owner
-	//! Queue to be used as response sender, has to be set in ctor or with
-	//! setQueueToUse
-	MessageQueueIF* queueToUse;
-	//! Pointer to an IPC Store, initialized during construction or
-	StorageManagerIF* ipcStore = nullptr;
+    //! Increase of value of this per step
+    static const uint8_t STEP_OFFSET = 1;
+    //! Pointer to the owner
+    HasActionsIF* owner;
+    //! Queue to be used as response sender, has to be set in ctor or with
+    //! setQueueToUse
+    MessageQueueIF* queueToUse;
+    //! Pointer to an IPC Store, initialized during construction or
+    StorageManagerIF* ipcStore = nullptr;
 
-	/**
-	 * Internal function called by handleActionMessage
-	 * @param commandedBy MessageQueueID of Commander
-	 * @param actionId ID of action to be done
-	 * @param dataAddress Address of additional data in IPC Store
-	 */
-	virtual void prepareExecution(MessageQueueId_t commandedBy,
-	        ActionId_t actionId, store_address_t dataAddress);
-	/**
-	 * @brief Default implementation is empty.
-	 */
-	virtual void resetHelper();
+    /**
+     * Internal function called by handleActionMessage
+     * @param commandedBy MessageQueueID of Commander
+     * @param actionId ID of action to be done
+     * @param dataAddress Address of additional data in IPC Store
+     */
+    virtual void prepareExecution(MessageQueueId_t commandedBy,
+            ActionId_t actionId, store_address_t dataAddress);
+    /**
+     * @brief Default implementation is empty.
+     */
+    virtual void resetHelper();
 };
 
 #endif /* FSFW_ACTION_ACTIONHELPER_H_ */
diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index 1c00dee0f..c3eb47109 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -11,71 +11,71 @@ ActionMessage::~ActionMessage() {
 }
 
 void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
-		store_address_t parameters) {
-	message->setCommand(EXECUTE_ACTION);
-	message->setParameter(fid);
-	message->setParameter2(parameters.raw);
+        store_address_t parameters) {
+    message->setCommand(EXECUTE_ACTION);
+    message->setParameter(fid);
+    message->setParameter2(parameters.raw);
 }
 
 ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
-	return ActionId_t(message->getParameter());
+    return ActionId_t(message->getParameter());
 }
 
 store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
+    store_address_t temp;
+    temp.raw = message->getParameter2();
+    return temp;
 }
 
 void ActionMessage::setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
-		ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		message->setCommand(STEP_SUCCESS);
-	} else {
-		message->setCommand(STEP_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2((step << 16) + result);
+        ReturnValue_t result) {
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        message->setCommand(STEP_SUCCESS);
+    } else {
+        message->setCommand(STEP_FAILED);
+    }
+    message->setParameter(fid);
+    message->setParameter2((step << 16) + result);
 }
 
 uint8_t ActionMessage::getStep(const CommandMessage* message) {
-	return uint8_t((message->getParameter2() >> 16) & 0xFF);
+    return uint8_t((message->getParameter2() >> 16) & 0xFF);
 }
 
 ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
-	return message->getParameter2() & 0xFFFF;
+    return message->getParameter2() & 0xFFFF;
 }
 
 void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
-		store_address_t data) {
-	message->setCommand(DATA_REPLY);
-	message->setParameter(actionId);
-	message->setParameter2(data.raw);
+        store_address_t data) {
+    message->setCommand(DATA_REPLY);
+    message->setParameter(actionId);
+    message->setParameter2(data.raw);
 }
 
 void ActionMessage::setCompletionReply(CommandMessage* message,
-		ActionId_t fid, ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK or result == HasActionsIF::EXECUTION_FINISHED) {
-		message->setCommand(COMPLETION_SUCCESS);
-	} else {
-		message->setCommand(COMPLETION_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2(result);
+        ActionId_t fid, ReturnValue_t result) {
+    if (result == HasReturnvaluesIF::RETURN_OK or result == HasActionsIF::EXECUTION_FINISHED) {
+        message->setCommand(COMPLETION_SUCCESS);
+    } else {
+        message->setCommand(COMPLETION_FAILED);
+    }
+    message->setParameter(fid);
+    message->setParameter2(result);
 }
 
 void ActionMessage::clear(CommandMessage* message) {
-	switch(message->getCommand()) {
-	case EXECUTE_ACTION:
-	case DATA_REPLY: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
+    switch(message->getCommand()) {
+    case EXECUTE_ACTION:
+    case DATA_REPLY: {
+        StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+                objects::IPC_STORE);
+        if (ipcStore != NULL) {
+            ipcStore->deleteData(getStoreId(message));
+        }
+        break;
+    }
+    default:
+        break;
+    }
 }
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index deb110952..246ac601d 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -15,29 +15,29 @@ using ActionId_t = uint32_t;
  */
 class ActionMessage {
 private:
-	ActionMessage();
+    ActionMessage();
 public:
-	static const uint8_t MESSAGE_ID = messagetypes::ACTION;
-	static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
-	static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
-	static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
-	static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
-	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
-	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
-	virtual ~ActionMessage();
-	static void setCommand(CommandMessage* message, ActionId_t fid,
-			store_address_t parameters);
-	static ActionId_t getActionId(const CommandMessage* message );
-	static store_address_t getStoreId(const CommandMessage* message );
-	static void setStepReply(CommandMessage* message, ActionId_t fid,
-			uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static uint8_t getStep(const CommandMessage* message );
-	static ReturnValue_t getReturnCode(const CommandMessage* message );
-	static void setDataReply(CommandMessage* message, ActionId_t actionId,
-			store_address_t data);
-	static void setCompletionReply(CommandMessage* message, ActionId_t fid,
-			ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static void clear(CommandMessage* message);
+    static const uint8_t MESSAGE_ID = messagetypes::ACTION;
+    static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
+    static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
+    static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
+    static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
+    static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
+    static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
+    virtual ~ActionMessage();
+    static void setCommand(CommandMessage* message, ActionId_t fid,
+            store_address_t parameters);
+    static ActionId_t getActionId(const CommandMessage* message );
+    static store_address_t getStoreId(const CommandMessage* message );
+    static void setStepReply(CommandMessage* message, ActionId_t fid,
+            uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    static uint8_t getStep(const CommandMessage* message );
+    static ReturnValue_t getReturnCode(const CommandMessage* message );
+    static void setDataReply(CommandMessage* message, ActionId_t actionId,
+            store_address_t data);
+    static void setCompletionReply(CommandMessage* message, ActionId_t fid,
+            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    static void clear(CommandMessage* message);
 };
 
 #endif /* FSFW_ACTION_ACTIONMESSAGE_H_ */
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index 4e88f3c34..148b36575 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -5,123 +5,123 @@
 #include "../objectmanager/ObjectManagerIF.h"
 
 CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
-		owner(setOwner), queueToUse(NULL), ipcStore(
-		NULL), commandCount(0), lastTarget(0) {
+        owner(setOwner), queueToUse(NULL), ipcStore(
+        NULL), commandCount(0), lastTarget(0) {
 }
 
 CommandActionHelper::~CommandActionHelper() {
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, SerializeIF *data) {
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	uint8_t *storePointer;
-	size_t maxSize = data->getSerializedSize();
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
-			&storePointer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	size_t size = 0;
-	result = data->serialize(&storePointer, &size, maxSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+        ActionId_t actionId, SerializeIF *data) {
+    HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+    if (receiver == NULL) {
+        return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+    }
+    store_address_t storeId;
+    uint8_t *storePointer;
+    size_t maxSize = data->getSerializedSize();
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
+            &storePointer);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    size_t size = 0;
+    result = data->serialize(&storePointer, &size, maxSize,
+            SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return sendCommand(receiver->getCommandQueue(), actionId, storeId);
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, const uint8_t *data, uint32_t size) {
-//	if (commandCount != 0) {
-//		return CommandsFunctionsIF::ALREADY_COMMANDING;
-//	}
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	ReturnValue_t result = ipcStore->addData(&storeId, data, size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+        ActionId_t actionId, const uint8_t *data, uint32_t size) {
+//    if (commandCount != 0) {
+//        return CommandsFunctionsIF::ALREADY_COMMANDING;
+//    }
+    HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+    if (receiver == NULL) {
+        return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+    }
+    store_address_t storeId;
+    ReturnValue_t result = ipcStore->addData(&storeId, data, size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return sendCommand(receiver->getCommandQueue(), actionId, storeId);
 }
 
 ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
-		ActionId_t actionId, store_address_t storeId) {
-	CommandMessage command;
-	ActionMessage::setCommand(&command, actionId, storeId);
-	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeId);
-	}
-	lastTarget = queueId;
-	commandCount++;
-	return result;
+        ActionId_t actionId, store_address_t storeId) {
+    CommandMessage command;
+    ActionMessage::setCommand(&command, actionId, storeId);
+    ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeId);
+    }
+    lastTarget = queueId;
+    commandCount++;
+    return result;
 }
 
 ReturnValue_t CommandActionHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if (ipcStore == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	queueToUse = owner->getCommandQueuePtr();
-	if (queueToUse == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    queueToUse = owner->getCommandQueuePtr();
+    if (queueToUse == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
-	if (reply->getSender() != lastTarget) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	switch (reply->getCommand()) {
-	case ActionMessage::COMPLETION_SUCCESS:
-		commandCount--;
-		owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::COMPLETION_FAILED:
-		commandCount--;
-		owner->completionFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_SUCCESS:
-		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_FAILED:
-		commandCount--;
-		owner->stepFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::DATA_REPLY:
-		extractDataForOwner(ActionMessage::getActionId(reply),
-				ActionMessage::getStoreId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    if (reply->getSender() != lastTarget) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    switch (reply->getCommand()) {
+    case ActionMessage::COMPLETION_SUCCESS:
+        commandCount--;
+        owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::COMPLETION_FAILED:
+        commandCount--;
+        owner->completionFailedReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getReturnCode(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::STEP_SUCCESS:
+        owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getStep(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::STEP_FAILED:
+        commandCount--;
+        owner->stepFailedReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getStep(reply),
+                ActionMessage::getReturnCode(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::DATA_REPLY:
+        extractDataForOwner(ActionMessage::getActionId(reply),
+                ActionMessage::getStoreId(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 uint8_t CommandActionHelper::getCommandCount() const {
-	return commandCount;
+    return commandCount;
 }
 
 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-	const uint8_t * data = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	owner->dataReceived(actionId, data, size);
-	ipcStore->deleteData(storeId);
+    const uint8_t * data = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return;
+    }
+    owner->dataReceived(actionId, data, size);
+    ipcStore->deleteData(storeId);
 }
diff --git a/action/CommandActionHelper.h b/action/CommandActionHelper.h
index cfed8c941..96ef1763a 100644
--- a/action/CommandActionHelper.h
+++ b/action/CommandActionHelper.h
@@ -11,26 +11,26 @@
 class CommandsActionsIF;
 
 class CommandActionHelper {
-	friend class CommandsActionsIF;
+    friend class CommandsActionsIF;
 public:
-	CommandActionHelper(CommandsActionsIF* owner);
-	virtual ~CommandActionHelper();
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, const uint8_t* data, uint32_t size);
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, SerializeIF* data);
-	ReturnValue_t initialize();
-	ReturnValue_t handleReply(CommandMessage* reply);
-	uint8_t getCommandCount() const;
+    CommandActionHelper(CommandsActionsIF* owner);
+    virtual ~CommandActionHelper();
+    ReturnValue_t commandAction(object_id_t commandTo,
+            ActionId_t actionId, const uint8_t* data, uint32_t size);
+    ReturnValue_t commandAction(object_id_t commandTo,
+            ActionId_t actionId, SerializeIF* data);
+    ReturnValue_t initialize();
+    ReturnValue_t handleReply(CommandMessage* reply);
+    uint8_t getCommandCount() const;
 private:
-	CommandsActionsIF* owner;
-	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore;
-	uint8_t commandCount;
-	MessageQueueId_t lastTarget;
-	void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
-	ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
-			store_address_t storeId);
+    CommandsActionsIF* owner;
+    MessageQueueIF* queueToUse;
+    StorageManagerIF* ipcStore;
+    uint8_t commandCount;
+    MessageQueueId_t lastTarget;
+    void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
+    ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
+            store_address_t storeId);
 };
 
 #endif /* COMMANDACTIONHELPER_H_ */
diff --git a/action/CommandsActionsIF.h b/action/CommandsActionsIF.h
index 491bfc703..fe7e856c2 100644
--- a/action/CommandsActionsIF.h
+++ b/action/CommandsActionsIF.h
@@ -15,22 +15,22 @@
  * - replyReceived(id, step, cause) (if cause == OK, it's a success).
  */
 class CommandsActionsIF {
-	friend class CommandActionHelper;
+    friend class CommandActionHelper;
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
-	static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
-	virtual ~CommandsActionsIF() {}
-	virtual MessageQueueIF* getCommandQueuePtr() = 0;
+    static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
+    static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
+    static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
+    virtual ~CommandsActionsIF() {}
+    virtual MessageQueueIF* getCommandQueuePtr() = 0;
 protected:
-	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
-	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
-			ReturnValue_t returnCode) = 0;
-	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
-			uint32_t size) = 0;
-	virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
-	virtual void completionFailedReceived(ActionId_t actionId,
-			ReturnValue_t returnCode) = 0;
+    virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
+    virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
+            ReturnValue_t returnCode) = 0;
+    virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
+            uint32_t size) = 0;
+    virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
+    virtual void completionFailedReceived(ActionId_t actionId,
+            ReturnValue_t returnCode) = 0;
 };
 
 
diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 690f03698..056e674c3 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -35,28 +35,28 @@
  */
 class HasActionsIF {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
-	static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
-	virtual ~HasActionsIF() { }
-	/**
-	 * Function to get the MessageQueueId_t of the implementing object
-	 * @return MessageQueueId_t of the object
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	/**
-	 * Execute or initialize the execution of a certain function.
-	 * The ActionHelpers will execute this function and behave differently
-	 * depending on the returnvalue.
-	 *
-	 * @return
-	 * -@c EXECUTION_FINISHED Finish reply will be generated
-	 * -@c Not RETURN_OK Step failure reply will be generated
-	 */
-	virtual ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
+    static const uint8_t INTERFACE_ID = CLASS_ID::HAS_ACTIONS_IF;
+    static const ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
+    static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
+    static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
+    static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
+    virtual ~HasActionsIF() { }
+    /**
+     * Function to get the MessageQueueId_t of the implementing object
+     * @return MessageQueueId_t of the object
+     */
+    virtual MessageQueueId_t getCommandQueue() const = 0;
+    /**
+     * Execute or initialize the execution of a certain function.
+     * The ActionHelpers will execute this function and behave differently
+     * depending on the returnvalue.
+     *
+     * @return
+     * -@c EXECUTION_FINISHED Finish reply will be generated
+     * -@c Not RETURN_OK Step failure reply will be generated
+     */
+    virtual ReturnValue_t executeAction(ActionId_t actionId,
+            MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
 };
 
 
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index af57736c8..f77d01473 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -2,74 +2,74 @@
 #include "SimpleActionHelper.h"
 
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
-		MessageQueueIF* useThisQueue) :
-		ActionHelper(setOwner, useThisQueue), isExecuting(false) {
+        MessageQueueIF* useThisQueue) :
+        ActionHelper(setOwner, useThisQueue), isExecuting(false) {
 }
 
 SimpleActionHelper::~SimpleActionHelper() {
 }
 
 void SimpleActionHelper::step(ReturnValue_t result) {
-	// STEP_OFFESET is subtracted to compensate for adding offset in base
-	// method, which is not necessary here.
-	ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
-			result);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		resetHelper();
-	}
+    // STEP_OFFESET is subtracted to compensate for adding offset in base
+    // method, which is not necessary here.
+    ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
+            result);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        resetHelper();
+    }
 }
 
 void SimpleActionHelper::finish(ReturnValue_t result) {
-	ActionHelper::finish(lastCommander, lastAction, result);
-	resetHelper();
+    ActionHelper::finish(lastCommander, lastAction, result);
+    resetHelper();
 }
 
 ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
-	return ActionHelper::reportData(lastCommander, lastAction, data);
+    return ActionHelper::reportData(lastCommander, lastAction, data);
 }
 
 void SimpleActionHelper::resetHelper() {
-	stepCount = 0;
-	isExecuting = false;
-	lastAction = 0;
-	lastCommander = 0;
+    stepCount = 0;
+    isExecuting = false;
+    lastAction = 0;
+    lastCommander = 0;
 }
 
 void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
-		ActionId_t actionId, store_address_t dataAddress) {
-	CommandMessage reply;
-	if (isExecuting) {
-		ipcStore->deleteData(dataAddress);
-		ActionMessage::setStepReply(&reply, actionId, 0,
-				HasActionsIF::IS_BUSY);
-		queueToUse->sendMessage(commandedBy, &reply);
-	}
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	lastCommander = commandedBy;
-	lastAction = actionId;
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	switch (result) {
-	case HasReturnvaluesIF::RETURN_OK:
-		isExecuting = true;
-		stepCount++;
-		break;
-	case HasActionsIF::EXECUTION_FINISHED:
-		ActionMessage::setCompletionReply(&reply, actionId,
-				HasReturnvaluesIF::RETURN_OK);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	default:
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	}
+        ActionId_t actionId, store_address_t dataAddress) {
+    CommandMessage reply;
+    if (isExecuting) {
+        ipcStore->deleteData(dataAddress);
+        ActionMessage::setStepReply(&reply, actionId, 0,
+                HasActionsIF::IS_BUSY);
+        queueToUse->sendMessage(commandedBy, &reply);
+    }
+    const uint8_t* dataPtr = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
+    lastCommander = commandedBy;
+    lastAction = actionId;
+    result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+    ipcStore->deleteData(dataAddress);
+    switch (result) {
+    case HasReturnvaluesIF::RETURN_OK:
+        isExecuting = true;
+        stepCount++;
+        break;
+    case HasActionsIF::EXECUTION_FINISHED:
+        ActionMessage::setCompletionReply(&reply, actionId,
+                HasReturnvaluesIF::RETURN_OK);
+        queueToUse->sendMessage(commandedBy, &reply);
+        break;
+    default:
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        break;
+    }
 
 }
diff --git a/action/SimpleActionHelper.h b/action/SimpleActionHelper.h
index 1f35d9fdf..7c6c4e00e 100644
--- a/action/SimpleActionHelper.h
+++ b/action/SimpleActionHelper.h
@@ -4,27 +4,27 @@
 #include "ActionHelper.h"
 
 /**
- * @brief	This is an action helper which is only able to service one action
- * 			at a time but remembers last commander and last action which
- * 			simplifies usage
+ * @brief    This is an action helper which is only able to service one action
+ *             at a time but remembers last commander and last action which
+ *             simplifies usage
  */
 class SimpleActionHelper: public ActionHelper {
 public:
-	SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-	virtual ~SimpleActionHelper();
-	void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	ReturnValue_t reportData(SerializeIF* data);
+    SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
+    virtual ~SimpleActionHelper();
+    void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    ReturnValue_t reportData(SerializeIF* data);
 
 protected:
-	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-			store_address_t dataAddress);
-	virtual void resetHelper();
+    void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
+            store_address_t dataAddress);
+    virtual void resetHelper();
 private:
-	bool isExecuting;
-	MessageQueueId_t lastCommander = MessageQueueIF::NO_QUEUE;
-	ActionId_t lastAction = 0;
-	uint8_t stepCount = 0;
+    bool isExecuting;
+    MessageQueueId_t lastCommander = MessageQueueIF::NO_QUEUE;
+    ActionId_t lastAction = 0;
+    uint8_t stepCount = 0;
 };
 
 #endif /* SIMPLEACTIONHELPER_H_ */

From 10390de63bb4ed6ca629808a30f59e1f0752d227 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 9 Feb 2021 14:57:14 +0100
Subject: [PATCH 1573/1774] changelog update

---
 CHANGELOG | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG b/CHANGELOG
index 298ef0d41..fc46ee021 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -81,4 +81,7 @@ now
   For the fsfw, this can be done by checking the processor define FSFW_CPP_OSTREAM_ENABLED from FSFWConfig.h. 
   For mission code, developers need to replace sif:: calls by the printf counterparts, but only if the CPP stream are excluded. 
   If this is not the case, everything should work as usual.
-- 
\ No newline at end of file
+
+### PUS Parameter Service 20
+
+Added PUS parameter service 20 (only custom subservices available).
\ No newline at end of file

From dc884249102bdda89efea85e66bdd35c951dcc8d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 9 Feb 2021 15:00:10 +0100
Subject: [PATCH 1574/1774] deleted commented code

---
 datapool/PoolDataSetBase.cpp | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 7d50a40af..2fd519661 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -229,20 +229,3 @@ void PoolDataSetBase::setReadCommitProtectionBehaviour(
 	this->timeoutTypeForSingleVars = timeoutType;
 	this->mutexTimeoutForSingleVars = mutexTimeout;
 }
-
-/* We really should supply the container as a template argument instead of writing sth like this */
-//PoolDataSetBase::PoolDataSetBase(const PoolDataSetBase &otherSet):
-//          fillCount(otherSet.fillCount), state(otherSet.state),
-//          maxFillCount(otherSet.maxFillCount),
-//          protectEveryReadCommitCall(otherSet.protectEveryReadCommitCall),
-//          timeoutTypeForSingleVars(otherSet.timeoutTypeForSingleVars),
-//          mutexTimeoutForSingleVars(otherSet.mutexTimeoutForSingleVars) {
-//    if(registeredVariables != nullptr and otherSet.registeredVariables != nullptr) {
-//        std::memcpy(reinterpret_cast<void*>(*(this->registeredVariables)),
-//                reinterpret_cast<const void*>(*(otherSet.registeredVariables)),
-//                fillCount * sizeof(PoolVariableIF*));
-//    }
-//}
-//
-//const PoolDataSetBase& PoolDataSetBase::operator=(const PoolDataSetBase &otherSet) {
-//}

From e013ae954f35f978c1417d8669f6cb7c138e0ae3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 22 Feb 2021 18:00:23 +0100
Subject: [PATCH 1575/1774] removed missed deadline printout

---
 osal/linux/PeriodicPosixTask.cpp | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index a8f2de601..630dd8e0a 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -68,20 +68,6 @@ void PeriodicPosixTask::taskFunctionality(void) {
 		}
 
 		if(not PosixThread::delayUntil(&lastWakeTime, periodMs)){
-			char name[20] = {0};
-			int status = pthread_getname_np(pthread_self(), name, sizeof(name));
-			if(status == 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-				sif::error << "PeriodicPosixTask " << name << ": Deadline "
-						"missed." << std::endl;
-#endif
-			}
-			else {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
-						status << std::endl;
-#endif
-			}
 			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}

From 144375827441b80a601579fe4395e3bbc19df92c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 22 Feb 2021 18:43:09 +0100
Subject: [PATCH 1576/1774] added new static function to print missed deadline

---
 osal/FreeRTOS/TaskFactory.cpp |  6 ++++++
 osal/host/TaskFactory.cpp     |  5 +++++
 osal/linux/TaskFactory.cpp    | 21 +++++++++++++++++++++
 osal/rtems/TaskFactory.cpp    |  5 +++++
 tasks/TaskFactory.h           |  6 ++++++
 5 files changed, 43 insertions(+)

diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 3ac5cb495..5b64811ae 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -49,5 +49,11 @@ ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+void TaskFactory::printMissedDeadline() {
+    /* TODO: Implement */
+    return;
+}
+
+
 TaskFactory::TaskFactory() {
 }
diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
index bc65504c8..4fafd3491 100644
--- a/osal/host/TaskFactory.cpp
+++ b/osal/host/TaskFactory.cpp
@@ -48,4 +48,9 @@ ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+void TaskFactory::printMissedDeadline() {
+    /* TODO: Implement */
+    return;
+}
+
 
diff --git a/osal/linux/TaskFactory.cpp b/osal/linux/TaskFactory.cpp
index d18a03161..935646477 100644
--- a/osal/linux/TaskFactory.cpp
+++ b/osal/linux/TaskFactory.cpp
@@ -39,5 +39,26 @@ ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
 	return PosixThread::sleep(delayMs*1000000ull);
 }
 
+void TaskFactory::printMissedDeadline() {
+    char name[20] = {0};
+    int status = pthread_getname_np(pthread_self(), name, sizeof(name));
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    if(status == 0) {
+        sif::warning << "task::printMissedDeadline: " << name << "" << std::endl;
+    }
+    else {
+        sif::warning << "task::printMissedDeadline: Unknown task name" << status <<
+                std::endl;
+    }
+#else
+    if(status == 0) {
+        sif::printWarning("task::printMissedDeadline: %s\n", name);
+    }
+    else {
+        sif::printWarning("task::printMissedDeadline: Unknown task name\n", name);
+    }
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+}
+
 TaskFactory::TaskFactory() {
 }
diff --git a/osal/rtems/TaskFactory.cpp b/osal/rtems/TaskFactory.cpp
index 5dad69fe5..095e9a262 100644
--- a/osal/rtems/TaskFactory.cpp
+++ b/osal/rtems/TaskFactory.cpp
@@ -44,5 +44,10 @@ ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+void TaskFactory::printMissedDeadline() {
+    /* TODO: Implement */
+    return;
+}
+
 TaskFactory::TaskFactory() {
 }
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 85cdda900..03b5163c4 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -62,6 +62,12 @@ public:
 	 */
 	static ReturnValue_t delayTask(uint32_t delayMs);
 
+	/**
+	 * OS specific implementation to print deadline. In most cases, there is a OS specific
+	 * way to retrieve the task name and print it out as well.
+	 */
+	static void printMissedDeadline();
+
 private:
 	/**
 	 * External instantiation is not allowed.

From 671bab012e6da1cc3b86784242e6e3659e72207a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Feb 2021 11:30:11 +0100
Subject: [PATCH 1577/1774] mutex helper printf support and nullptr check

---
 ipc/MutexHelper.h | 49 +++++++++++++++++++++++++++++------------------
 1 file changed, 30 insertions(+), 19 deletions(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index befa69bcd..5a14249cf 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -2,33 +2,44 @@
 #define FRAMEWORK_IPC_MUTEXHELPER_H_
 
 #include "MutexFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 class MutexHelper {
 public:
-	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
-			internalMutex(mutex) {
-		ReturnValue_t status = mutex->lockMutex(timeoutType,
-		        timeoutMs);
-		if(status == MutexIF::MUTEX_TIMEOUT) {
+    MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0):
+            internalMutex(mutex) {
+        if(mutex == nullptr) {
+            return;
+        }
+        ReturnValue_t status = mutex->lockMutex(timeoutType,
+                timeoutMs);
+        if(status == MutexIF::MUTEX_TIMEOUT) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
-					<< timeoutMs << " milliseconds!" << std::endl;
+            sif::error << "MutexHelper: Lock of mutex failed with timeout of "
+                    << timeoutMs << " milliseconds!" << std::endl;
+#else
+            sif::printError("MutexHelper: Lock of mutex failed with timeout of %lu milliseconds\n",
+                    timeoutMs);
 #endif
-		}
-		else if(status != HasReturnvaluesIF::RETURN_OK){
+        }
+        else if(status != HasReturnvaluesIF::RETURN_OK){
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "MutexHelper: Lock of Mutex failed with code "
-			        << status << std::endl;
+            sif::error << "MutexHelper: Lock of Mutex failed with code "
+                    << status << std::endl;
+#else
+            sif::printError("MutexHelper: Lock of Mutex failed with code %d\n", status);
 #endif
-		}
-	}
+        }
+    }
 
-	~MutexHelper() {
-		internalMutex->unlockMutex();
-	}
+    ~MutexHelper() {
+        if(internalMutex != nullptr) {
+            internalMutex->unlockMutex();
+        }
+    }
 private:
-	MutexIF* internalMutex;
+    MutexIF* internalMutex;
 };
+
 #endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */

From 58e219981f179eed11e08f139d9cc1bdca2831f5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Feb 2021 14:09:55 +0100
Subject: [PATCH 1578/1774] updated mutex helper

---
 ipc/MutexHelper.h | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 5a14249cf..dd6eb9265 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -10,26 +10,37 @@ public:
             MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0):
             internalMutex(mutex) {
         if(mutex == nullptr) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::error << "MutexHelper: Passed mutex is invalid!" << std::endl;
+#else
+            sif::printError("MutexHelper: Passed mutex is invalid!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
             return;
         }
         ReturnValue_t status = mutex->lockMutex(timeoutType,
                 timeoutMs);
         if(status == MutexIF::MUTEX_TIMEOUT) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "MutexHelper: Lock of mutex failed with timeout of "
                     << timeoutMs << " milliseconds!" << std::endl;
 #else
             sif::printError("MutexHelper: Lock of mutex failed with timeout of %lu milliseconds\n",
                     timeoutMs);
-#endif
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
         }
-        else if(status != HasReturnvaluesIF::RETURN_OK){
+        else if(status != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "MutexHelper: Lock of Mutex failed with code "
                     << status << std::endl;
 #else
             sif::printError("MutexHelper: Lock of Mutex failed with code %d\n", status);
-#endif
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
         }
     }
 

From 06eadb55abe4debf9cf0d124778bcae148a4002e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Feb 2021 14:11:53 +0100
Subject: [PATCH 1579/1774] small stuff

---
 ipc/MutexHelper.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index dd6eb9265..7f81f2f46 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -35,8 +35,7 @@ public:
         else if(status != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "MutexHelper: Lock of Mutex failed with code "
-                    << status << std::endl;
+            sif::error << "MutexHelper: Lock of Mutex failed with code " << status << std::endl;
 #else
             sif::printError("MutexHelper: Lock of Mutex failed with code %d\n", status);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */

From ce770a67b2d577df8f02ddf16a9297c4bee9cd59 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Feb 2021 14:14:23 +0100
Subject: [PATCH 1580/1774] preprocessor define improved

---
 ipc/MutexHelper.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 7f81f2f46..76eadc00d 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -21,8 +21,8 @@ public:
         }
         ReturnValue_t status = mutex->lockMutex(timeoutType,
                 timeoutMs);
-        if(status == MutexIF::MUTEX_TIMEOUT) {
 #if FSFW_VERBOSE_LEVEL >= 1
+        if(status == MutexIF::MUTEX_TIMEOUT) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "MutexHelper: Lock of mutex failed with timeout of "
                     << timeoutMs << " milliseconds!" << std::endl;
@@ -30,7 +30,7 @@ public:
             sif::printError("MutexHelper: Lock of mutex failed with timeout of %lu milliseconds\n",
                     timeoutMs);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+
         }
         else if(status != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
@@ -39,8 +39,8 @@ public:
 #else
             sif::printError("MutexHelper: Lock of Mutex failed with code %d\n", status);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
         }
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
     }
 
     ~MutexHelper() {

From 94f9d1ee16b4d0249a2e6d60b3508c7de9da3c77 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Feb 2021 14:40:08 +0100
Subject: [PATCH 1581/1774] mutex helper update

---
 ipc/MutexHelper.h | 62 +++++++++++++++++++++++++++++++----------------
 1 file changed, 41 insertions(+), 21 deletions(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index befa69bcd..bc5730850 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -2,33 +2,53 @@
 #define FRAMEWORK_IPC_MUTEXHELPER_H_
 
 #include "MutexFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 class MutexHelper {
 public:
-	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
-			internalMutex(mutex) {
-		ReturnValue_t status = mutex->lockMutex(timeoutType,
-		        timeoutMs);
-		if(status == MutexIF::MUTEX_TIMEOUT) {
+    MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0):
+            internalMutex(mutex) {
+        if(mutex == nullptr) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
-					<< timeoutMs << " milliseconds!" << std::endl;
-#endif
-		}
-		else if(status != HasReturnvaluesIF::RETURN_OK){
+            sif::error << "MutexHelper: Passed mutex is invalid!" << std::endl;
+#else
+            sif::printError("MutexHelper: Passed mutex is invalid!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+            return;
+        }
+        ReturnValue_t status = mutex->lockMutex(timeoutType,
+                timeoutMs);
+#if FSFW_VERBOSE_LEVEL >= 1
+        if(status == MutexIF::MUTEX_TIMEOUT) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "MutexHelper: Lock of Mutex failed with code "
-			        << status << std::endl;
-#endif
-		}
-	}
+            sif::error << "MutexHelper: Lock of mutex failed with timeout of "
+                    << timeoutMs << " milliseconds!" << std::endl;
+#else
+            sif::printError("MutexHelper: Lock of mutex failed with timeout of %lu milliseconds\n",
+                    timeoutMs);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 
-	~MutexHelper() {
-		internalMutex->unlockMutex();
-	}
+        }
+        else if(status != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::error << "MutexHelper: Lock of Mutex failed with code " << status << std::endl;
+#else
+            sif::printError("MutexHelper: Lock of Mutex failed with code %d\n", status);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+        }
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+    }
+
+    ~MutexHelper() {
+        if(internalMutex != nullptr) {
+            internalMutex->unlockMutex();
+        }
+    }
 private:
-	MutexIF* internalMutex;
+    MutexIF* internalMutex;
 };
+
 #endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */

From c5ee2260d14008c2afd7f260ee86240011efb156 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 27 Feb 2021 12:59:37 +0100
Subject: [PATCH 1582/1774] renamed abstract function, removed plural

---
 datapoollocal/LocalDataPoolManager.cpp            | 2 +-
 datapoollocal/LocalDataPoolManager.h              | 2 +-
 datapoollocal/ProvidesDataPoolSubscriptionIF.h    | 2 +-
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 447691632..01c5bb9aa 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -380,7 +380,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 }
 
 
-ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
+ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(sid_t sid,
 		bool isDiagnostics, bool reportingEnabled,
 		object_id_t packetDestination) {
 	AcceptsHkPacketsIF* hkReceiverObject =
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 05c6adfd6..a53e45b58 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -137,7 +137,7 @@ public:
      * @param packetDestination
      * @return
      */
-    ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool reportingEnabled,
+    ReturnValue_t subscribeForUpdatePacket(sid_t sid, bool reportingEnabled,
             bool isDiagnostics,
             object_id_t packetDestination = defaultHkDestination) override;
 
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index ead479cc2..642e8ee1d 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -33,7 +33,7 @@ public:
      * @param packetDestination
      * @return
      */
-    virtual ReturnValue_t subscribeForUpdatePackets(sid_t sid,
+    virtual ReturnValue_t subscribeForUpdatePacket(sid_t sid,
             bool reportingEnabled,
             bool isDiagnostics,
             object_id_t packetDestination) = 0;
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 876ae5f5b..68bccbb81 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -174,7 +174,7 @@ public:
     }
 
     ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) {
-        return poolManager.subscribeForUpdatePackets(lpool::testSid, diagnostics,
+        return poolManager.subscribeForUpdatePacket(lpool::testSid, diagnostics,
                 false, objects::HK_RECEIVER_MOCK);
     }
 

From f45d19a9619ad787ee00efd6f46934f67b4785f0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 27 Feb 2021 13:06:55 +0100
Subject: [PATCH 1583/1774] better documentation

---
 housekeeping/HousekeepingPacketDownlink.h | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
index ae0cc988d..aeea16c3c 100644
--- a/housekeeping/HousekeepingPacketDownlink.h
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -10,7 +10,11 @@
  *          which are destined to be downlinked into the store.
  * @details
  * The housekeeping packets are stored into the IPC store and forwarded
- * to the designated housekeeping handler.
+ * to the designated housekeeping handler. The packet will consist of the following fields
+ *  - SID (8 byte): Structure ID, with the first 4 bytes being the object ID and the last four
+ *    bytes being the set ID
+ *  - Housekeeping Data: The rest of the packet will be the serialized housekeeping data. A validity
+ *    buffer might be appended at the end, depending on the set configuration.
  */
 class HousekeepingPacketDownlink: public SerialLinkedListAdapter<SerializeIF> {
 public:

From 788dbe4eca1bd8f2daa212ec14af95a6b333b4d9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 27 Feb 2021 13:56:48 +0100
Subject: [PATCH 1584/1774] removed plural

---
 datapoollocal/LocalDataPoolManager.cpp                | 4 ++--
 datapoollocal/LocalDataPoolManager.h                  | 4 ++--
 datapoollocal/ProvidesDataPoolSubscriptionIF.h        | 4 ++--
 unittest/tests/datapoollocal/LocalPoolManagerTest.cpp | 2 +-
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h     | 6 +++---
 5 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 01c5bb9aa..19e235881 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -410,7 +410,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(sid_t sid,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
+ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessage(
 		const uint32_t setId, object_id_t destinationObject,
 		MessageQueueId_t targetQueueId, bool generateSnapshot) {
 	struct HkReceiver hkReceiver;
@@ -431,7 +431,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessages(
+ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessage(
 		const lp_id_t localPoolId, object_id_t destinationObject,
 		MessageQueueId_t targetQueueId, bool generateSnapshot) {
 	struct HkReceiver hkReceiver;
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index a53e45b58..fdfd9d233 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -155,7 +155,7 @@ public:
      * Otherwise, only an notification message is sent.
      * @return
      */
-    ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
+    ReturnValue_t subscribeForSetUpdateMessage(const uint32_t setId,
             object_id_t destinationObject,
             MessageQueueId_t targetQueueId,
             bool generateSnapshot) override;
@@ -174,7 +174,7 @@ public:
      * Otherwise, only an notification message is sent.
      * @return
      */
-    ReturnValue_t subscribeForVariableUpdateMessages(const lp_id_t localPoolId,
+    ReturnValue_t subscribeForVariableUpdateMessage(const lp_id_t localPoolId,
             object_id_t destinationObject,
             MessageQueueId_t targetQueueId,
             bool generateSnapshot) override;
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index 642e8ee1d..3394c98bd 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -52,7 +52,7 @@ public:
      *                              Otherwise, only an notification message is sent.
      * @return
      */
-    virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
+    virtual ReturnValue_t subscribeForSetUpdateMessage(const uint32_t setId,
             object_id_t destinationObject, MessageQueueId_t targetQueueId,
             bool generateSnapshot) = 0;
 
@@ -70,7 +70,7 @@ public:
      *                              only an notification message is sent.
      * @return
      */
-    virtual ReturnValue_t subscribeForVariableUpdateMessages(
+    virtual ReturnValue_t subscribeForVariableUpdateMessage(
             const lp_id_t localPoolId,
             object_id_t destinationObject,
             MessageQueueId_t targetQueueId,
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index c8b10442a..e621f4d87 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -160,7 +160,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         CHECK(messageSent.getCommand() == static_cast<int>(
                 HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
         /* Now subscribe for the dataset update (HK and update) again with subscription interface */
-        REQUIRE(subscriptionIF->subscribeForSetUpdateMessages(lpool::testSetId,
+        REQUIRE(subscriptionIF->subscribeForSetUpdateMessage(lpool::testSetId,
                 objects::NO_OBJECT, objects::HK_RECEIVER_MOCK, false) == retval::CATCH_OK);
         REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
 
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 68bccbb81..acbb2b736 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -164,12 +164,12 @@ public:
     }
 
     ReturnValue_t subscribeWrapperSetUpdate() {
-        return poolManager.subscribeForSetUpdateMessages(lpool::testSetId,
+        return poolManager.subscribeForSetUpdateMessage(lpool::testSetId,
                 objects::NO_OBJECT, objects::HK_RECEIVER_MOCK, false);
     }
 
     ReturnValue_t subscribeWrapperSetUpdateSnapshot() {
-        return poolManager.subscribeForSetUpdateMessages(lpool::testSetId,
+        return poolManager.subscribeForSetUpdateMessage(lpool::testSetId,
                 objects::NO_OBJECT, objects::HK_RECEIVER_MOCK, true);
     }
 
@@ -179,7 +179,7 @@ public:
     }
 
     ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) {
-        return poolManager.subscribeForVariableUpdateMessages(localPoolId,
+        return poolManager.subscribeForVariableUpdateMessage(localPoolId,
                 MessageQueueIF::NO_QUEUE, objects::HK_RECEIVER_MOCK, false);
     }
 

From 110159eea1dfcbe74d9a91f6d8c2546d3a3b5019 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 27 Feb 2021 13:57:58 +0100
Subject: [PATCH 1585/1774] formatting

---
 .../ProvidesDataPoolSubscriptionIF.h          | 23 +++++--------------
 1 file changed, 6 insertions(+), 17 deletions(-)

diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index 3394c98bd..1c34099ac 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -17,12 +17,8 @@ public:
      * to generate housekeeping packets which are downlinked directly.
      * @return
      */
-    virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid,
-            bool enableReporting,
-            float collectionInterval, bool isDiagnostics,
-            object_id_t packetDestination) = 0;
-
-
+    virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
+            float collectionInterval, bool isDiagnostics, object_id_t packetDestination) = 0;
     /**
      * @brief   Subscribe for the  generation of packets if the dataset
      *          is marked as changed.
@@ -33,11 +29,8 @@ public:
      * @param packetDestination
      * @return
      */
-    virtual ReturnValue_t subscribeForUpdatePacket(sid_t sid,
-            bool reportingEnabled,
-            bool isDiagnostics,
-            object_id_t packetDestination) = 0;
-
+    virtual ReturnValue_t subscribeForUpdatePacket(sid_t sid, bool reportingEnabled,
+            bool isDiagnostics, object_id_t packetDestination) = 0;
     /**
      * @brief   Subscribe for a notification message which will be sent
      *          if a dataset has changed.
@@ -55,7 +48,6 @@ public:
     virtual ReturnValue_t subscribeForSetUpdateMessage(const uint32_t setId,
             object_id_t destinationObject, MessageQueueId_t targetQueueId,
             bool generateSnapshot) = 0;
-
     /**
      * @brief   Subscribe for an notification message which will be sent if a
      *          pool variable has changed.
@@ -70,12 +62,9 @@ public:
      *                              only an notification message is sent.
      * @return
      */
-    virtual ReturnValue_t subscribeForVariableUpdateMessage(
-            const lp_id_t localPoolId,
-            object_id_t destinationObject,
-            MessageQueueId_t targetQueueId,
+    virtual ReturnValue_t subscribeForVariableUpdateMessage(const lp_id_t localPoolId,
+            object_id_t destinationObject, MessageQueueId_t targetQueueId,
             bool generateSnapshot) = 0;
-
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_ */

From ea6ee7e79c546454ae60ef6c498a42bf5ef761ac Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 27 Feb 2021 14:08:30 +0100
Subject: [PATCH 1586/1774] added instructions on how to retrieve the interface

---
 datapoollocal/HasLocalDataPoolIF.h | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 055701750..3c31c5cd8 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -23,11 +23,20 @@ class LocalPoolObjectBase;
  * @details
  * Any class implementing this interface shall also have a LocalDataPoolManager member class which
  * contains the actual pool data structure and exposes the public interface for it.
+ *
  * The local data pool can be accessed using helper classes by using the
  * LocalPoolVariable, LocalPoolVector or LocalDataSet classes. Every local pool variable can
  * be uniquely identified by a global pool ID (gp_id_t) and every dataset tied
  * to a pool manager can be uniqely identified by a global structure ID (sid_t).
  *
+ * All software objects which want to use the local pool of another object shall also use this
+ * interface, for example to get a handle to the subscription interface.
+ * For example, the following line of code can be used to retrieve the interface
+ *
+ *    HasLocalDataPoolIF* poolIF = objectManager->get<HasLocalDataPoolIF>(objects::SOME_OBJECT);
+ *    if(poolIF != nullptr) {
+ *        doSomething()
+ *    }
  */
 class HasLocalDataPoolIF {
     friend class HasLocalDpIFManagerAttorney;

From fcff06c83fe6d8c0bcd864b9276b039fe6845f04 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 27 Feb 2021 14:09:44 +0100
Subject: [PATCH 1587/1774] some more details

---
 datapoollocal/HasLocalDataPoolIF.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 3c31c5cd8..49f2db7d3 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -30,7 +30,8 @@ class LocalPoolObjectBase;
  * to a pool manager can be uniqely identified by a global structure ID (sid_t).
  *
  * All software objects which want to use the local pool of another object shall also use this
- * interface, for example to get a handle to the subscription interface.
+ * interface, for example to get a handle to the subscription interface. The interface
+ * can be retrieved using the object manager, provided the target object is a SystemObject.
  * For example, the following line of code can be used to retrieve the interface
  *
  *    HasLocalDataPoolIF* poolIF = objectManager->get<HasLocalDataPoolIF>(objects::SOME_OBJECT);

From a65211be51be8d2c998396444649edb4eeef1719 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 13:48:53 +0100
Subject: [PATCH 1588/1774] new attorney for ReadCommitIF

---
 datapool/PoolDataSetBase.cpp    | 315 ++++++++++++++++----------------
 datapool/PoolDataSetBase.h      | 241 ++++++++++++------------
 datapool/PoolVariableIF.h       |  75 ++++----
 datapool/ReadCommitIF.h         |   8 +-
 datapool/ReadCommitIFAttorney.h |  32 ++++
 5 files changed, 354 insertions(+), 317 deletions(-)
 create mode 100644 datapool/ReadCommitIFAttorney.h

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 2fd519661..1474aff25 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -1,5 +1,8 @@
 #include "PoolDataSetBase.h"
+#include "ReadCommitIFAttorney.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
+
 #include <cstring>
 
 PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
@@ -12,61 +15,61 @@ PoolDataSetBase::~PoolDataSetBase() {}
 
 
 ReturnValue_t PoolDataSetBase::registerVariable(
-		PoolVariableIF *variable) {
-	if (state != States::STATE_SET_UNINITIALISED) {
+        PoolVariableIF *variable) {
+    if (state != States::STATE_SET_UNINITIALISED) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DataSet::registerVariable: "
-				"Call made in wrong position." << std::endl;
+        sif::error << "DataSet::registerVariable: "
+                "Call made in wrong position." << std::endl;
 #endif
-		return DataSetIF::DATA_SET_UNINITIALISED;
-	}
-	if (variable == nullptr) {
+        return DataSetIF::DATA_SET_UNINITIALISED;
+    }
+    if (variable == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DataSet::registerVariable: "
-				"Pool variable is nullptr." << std::endl;
+        sif::error << "DataSet::registerVariable: "
+                "Pool variable is nullptr." << std::endl;
 #endif
-		return DataSetIF::POOL_VAR_NULL;
-	}
-	if (fillCount >= maxFillCount) {
+        return DataSetIF::POOL_VAR_NULL;
+    }
+    if (fillCount >= maxFillCount) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DataSet::registerVariable: "
-				"DataSet is full." << std::endl;
+        sif::error << "DataSet::registerVariable: "
+                "DataSet is full." << std::endl;
 #endif
-		return DataSetIF::DATA_SET_FULL;
-	}
-	registeredVariables[fillCount] = variable;
-	fillCount++;
-	return HasReturnvaluesIF::RETURN_OK;
+        return DataSetIF::DATA_SET_FULL;
+    }
+    registeredVariables[fillCount] = variable;
+    fillCount++;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t PoolDataSetBase::read(MutexIF::TimeoutType timeoutType,
-		uint32_t lockTimeout) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	ReturnValue_t error = result;
-	if (state == States::STATE_SET_UNINITIALISED) {
-		lockDataPool(timeoutType, lockTimeout);
-		for (uint16_t count = 0; count < fillCount; count++) {
-			result = readVariable(count);
-			if(result != RETURN_OK) {
-				error = result;
-			}
-		}
-		state = States::STATE_SET_WAS_READ;
-		unlockDataPool();
-	}
-	else {
+        uint32_t lockTimeout) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    ReturnValue_t error = result;
+    if (state == States::STATE_SET_UNINITIALISED) {
+        lockDataPool(timeoutType, lockTimeout);
+        for (uint16_t count = 0; count < fillCount; count++) {
+            result = readVariable(count);
+            if(result != RETURN_OK) {
+                error = result;
+            }
+        }
+        state = States::STATE_SET_WAS_READ;
+        unlockDataPool();
+    }
+    else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DataSet::read(): "
-				"Call made in wrong position. Don't forget to commit"
-				" member datasets!" << std::endl;
+        sif::error << "DataSet::read(): "
+                "Call made in wrong position. Don't forget to commit"
+                " member datasets!" << std::endl;
 #endif
-		result = SET_WAS_ALREADY_READ;
-	}
+        result = SET_WAS_ALREADY_READ;
+    }
 
-	if(error != HasReturnvaluesIF::RETURN_OK) {
-		result = error;
-	}
-	return result;
+    if(error != HasReturnvaluesIF::RETURN_OK) {
+        result = error;
+    }
+    return result;
 }
 
 uint16_t PoolDataSetBase::getFillCount() const {
@@ -74,144 +77,144 @@ uint16_t PoolDataSetBase::getFillCount() const {
 }
 
 ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	if(registeredVariables[count] == nullptr) {
-	    // configuration error.
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    if(registeredVariables[count] == nullptr) {
+        /* Configuration error. */
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	// These checks are often performed by the respective
-	// variable implementation too, but I guess a double check does not hurt.
-	if (registeredVariables[count]->getReadWriteMode() !=
-				PoolVariableIF::VAR_WRITE and
-		registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER)
-	{
-		if(protectEveryReadCommitCall) {
-			result = registeredVariables[count]->read(
-					timeoutTypeForSingleVars,
-					mutexTimeoutForSingleVars);
-		}
-		else {
-			result = registeredVariables[count]->readWithoutLock();
-		}
+    /* These checks are often performed by the respective variable implementation too, but I guess
+    a double check does not hurt. */
+    if (registeredVariables[count]->getReadWriteMode() !=
+            PoolVariableIF::VAR_WRITE and
+            registeredVariables[count]->getDataPoolId()
+            != PoolVariableIF::NO_PARAMETER)
+    {
+        if(protectEveryReadCommitCall) {
+            result = registeredVariables[count]->read(
+                    timeoutTypeForSingleVars,
+                    mutexTimeoutForSingleVars);
+        }
+        else {
+            result = ReadCommitIFAttorney::readWithoutLock(registeredVariables[count]);
+        }
 
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			result = INVALID_PARAMETER_DEFINITION;
-		}
-	}
-	return result;
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            result = INVALID_PARAMETER_DEFINITION;
+        }
+    }
+    return result;
 }
 
 ReturnValue_t PoolDataSetBase::commit(MutexIF::TimeoutType timeoutType,
-		uint32_t lockTimeout) {
-	if (state == States::STATE_SET_WAS_READ) {
-		handleAlreadyReadDatasetCommit(timeoutType, lockTimeout);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return handleUnreadDatasetCommit(timeoutType, lockTimeout);
-	}
+        uint32_t lockTimeout) {
+    if (state == States::STATE_SET_WAS_READ) {
+        handleAlreadyReadDatasetCommit(timeoutType, lockTimeout);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+        return handleUnreadDatasetCommit(timeoutType, lockTimeout);
+    }
 }
 
 void PoolDataSetBase::handleAlreadyReadDatasetCommit(
-		MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
-	lockDataPool(timeoutType, lockTimeout);
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ
-				&& registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			if(protectEveryReadCommitCall) {
-				registeredVariables[count]->commit(
-						timeoutTypeForSingleVars,
-						mutexTimeoutForSingleVars);
-			}
-			else {
-				registeredVariables[count]->commitWithoutLock();
-			}
-		}
-	}
-	state = States::STATE_SET_UNINITIALISED;
-	unlockDataPool();
+        MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
+    lockDataPool(timeoutType, lockTimeout);
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if (registeredVariables[count]->getReadWriteMode()
+                != PoolVariableIF::VAR_READ
+                && registeredVariables[count]->getDataPoolId()
+                != PoolVariableIF::NO_PARAMETER) {
+            if(protectEveryReadCommitCall) {
+                registeredVariables[count]->commit(
+                        timeoutTypeForSingleVars,
+                        mutexTimeoutForSingleVars);
+            }
+            else {
+                ReadCommitIFAttorney::commitWithoutLock(registeredVariables[count]);
+            }
+        }
+    }
+    state = States::STATE_SET_UNINITIALISED;
+    unlockDataPool();
 }
 
 ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(
-		MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	lockDataPool(timeoutType, lockTimeout);
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				== PoolVariableIF::VAR_WRITE
-				&& registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			if(protectEveryReadCommitCall) {
-				result = registeredVariables[count]->commit(
-						timeoutTypeForSingleVars,
-						mutexTimeoutForSingleVars);
-			}
-			else {
-				result = registeredVariables[count]->commitWithoutLock();
-			}
+        MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    lockDataPool(timeoutType, lockTimeout);
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if (registeredVariables[count]->getReadWriteMode()
+                == PoolVariableIF::VAR_WRITE
+                && registeredVariables[count]->getDataPoolId()
+                != PoolVariableIF::NO_PARAMETER) {
+            if(protectEveryReadCommitCall) {
+                result = registeredVariables[count]->commit(
+                        timeoutTypeForSingleVars,
+                        mutexTimeoutForSingleVars);
+            }
+            else {
+                result = registeredVariables[count]->commitWithoutLock();
+            }
 
-		} else if (registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			if (result != COMMITING_WITHOUT_READING) {
+        } else if (registeredVariables[count]->getDataPoolId()
+                != PoolVariableIF::NO_PARAMETER) {
+            if (result != COMMITING_WITHOUT_READING) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-				sif::error << "DataSet::commit(): commit-without-read call made "
-						"with non write-only variable." << std::endl;
+                sif::error << "DataSet::commit(): commit-without-read call made "
+                        "with non write-only variable." << std::endl;
 #endif
-				result = COMMITING_WITHOUT_READING;
-			}
-		}
-	}
-	state = States::STATE_SET_UNINITIALISED;
-	unlockDataPool();
-	return result;
+                result = COMMITING_WITHOUT_READING;
+            }
+        }
+    }
+    state = States::STATE_SET_UNINITIALISED;
+    unlockDataPool();
+    return result;
 }
 
 
 ReturnValue_t PoolDataSetBase::lockDataPool(MutexIF::TimeoutType timeoutType,
-		uint32_t lockTimeout) {
-	return HasReturnvaluesIF::RETURN_OK;
+        uint32_t lockTimeout) {
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t PoolDataSetBase::unlockDataPool() {
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t PoolDataSetBase::serialize(uint8_t** buffer, size_t* size,
-		const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		result = registeredVariables[count]->serialize(buffer, size, maxSize,
-		        streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
+        const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        result = registeredVariables[count]->serialize(buffer, size, maxSize,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    return result;
 }
 
 ReturnValue_t PoolDataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
         SerializeIF::Endianness streamEndianness) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		result = registeredVariables[count]->deSerialize(buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        result = registeredVariables[count]->deSerialize(buffer, size,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    return result;
 }
 
 size_t PoolDataSetBase::getSerializedSize() const {
-	uint32_t size = 0;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		size += registeredVariables[count]->getSerializedSize();
-	}
-	return size;
+    uint32_t size = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        size += registeredVariables[count]->getSerializedSize();
+    }
+    return size;
 }
 
 void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
@@ -219,13 +222,13 @@ void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
 }
 
 PoolVariableIF** PoolDataSetBase::getContainer() const {
-	return registeredVariables;
+    return registeredVariables;
 }
 
 void PoolDataSetBase::setReadCommitProtectionBehaviour(
-		bool protectEveryReadCommit, MutexIF::TimeoutType timeoutType,
-		uint32_t mutexTimeout) {
-	this->protectEveryReadCommitCall = protectEveryReadCommit;
-	this->timeoutTypeForSingleVars = timeoutType;
-	this->mutexTimeoutForSingleVars = mutexTimeout;
+        bool protectEveryReadCommit, MutexIF::TimeoutType timeoutType,
+        uint32_t mutexTimeout) {
+    this->protectEveryReadCommitCall = protectEveryReadCommit;
+    this->timeoutTypeForSingleVars = timeoutType;
+    this->mutexTimeoutForSingleVars = mutexTimeout;
 }
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index ab8954557..043c860a7 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -29,98 +29,99 @@
  * @author	Bastian Baetz
  * @ingroup data_pool
  */
-class PoolDataSetBase: public PoolDataSetIF,
-		public SerializeIF,
-		public HasReturnvaluesIF {
+class PoolDataSetBase:
+        public PoolDataSetIF,
+        public SerializeIF,
+        public HasReturnvaluesIF {
 public:
 
-	/**
-	 * @brief	Creates an empty dataset. Use registerVariable or
-	 * 			supply a pointer to this dataset to PoolVariable
-	 * 			initializations to register pool variables.
-	 */
-	PoolDataSetBase(PoolVariableIF** registeredVariablesArray, const size_t maxFillCount);
+    /**
+     * @brief	Creates an empty dataset. Use registerVariable or
+     * 			supply a pointer to this dataset to PoolVariable
+     * 			initializations to register pool variables.
+     */
+    PoolDataSetBase(PoolVariableIF** registeredVariablesArray, const size_t maxFillCount);
 
-	/* Forbidden for now */
-	PoolDataSetBase(const PoolDataSetBase& otherSet) = delete;
-	const PoolDataSetBase& operator=(const PoolDataSetBase& otherSet) = delete;
+    /* Forbidden for now */
+    PoolDataSetBase(const PoolDataSetBase& otherSet) = delete;
+    const PoolDataSetBase& operator=(const PoolDataSetBase& otherSet) = delete;
 
-	virtual~ PoolDataSetBase();
+    virtual~ PoolDataSetBase();
 
-	/**
-	 * @brief	The read call initializes reading out all registered variables.
-	 * 			It is mandatory to call commit after every read call!
-	 * @details
-	 * It iterates through the list of registered variables and calls all read()
-	 * functions of the registered pool variables (which read out their values
-	 * from the data pool) which are not write-only.
-	 * In case of an error (e.g. a wrong data type, or an invalid data pool id),
-	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
-	 *
-	 * The data pool is locked during the whole read operation and
-	 * freed afterwards. It is mandatory to call commit after a read call,
-	 * even if the read operation is not successful!
-	 * @return
-	 * - @c RETURN_OK if all variables were read successfully.
-	 * - @c INVALID_PARAMETER_DEFINITION if a pool entry does not exist or there
-	 *      is a type conflict.
-	 * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
-	 *      commit() in between
-	 */
-	virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t lockTimeout = 20) override;
-	/**
-	 * @brief	The commit call initializes writing back the registered variables.
-	 * @details
-	 * It iterates through the list of registered variables and calls the
-	 * commit() method of the remaining registered variables (which write back
-	 * their values to the pool).
-	 *
-	 * The data pool is locked during the whole commit operation and
-	 * freed afterwards. The state changes to "was committed" after this operation.
-	 *
-	 * If the set does contain at least one variable which is not write-only
-	 * commit() can only be called after read(). If the set only contains
-	 * variables which are write only, commit() can be called without a
-	 * preceding read() call. Every read call must be followed by a commit call!
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
-	 * 			  contains non write-only variables
-	 */
-	virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t lockTimeout = 20) override;
+    /**
+     * @brief	The read call initializes reading out all registered variables.
+     * 			It is mandatory to call commit after every read call!
+     * @details
+     * It iterates through the list of registered variables and calls all read()
+     * functions of the registered pool variables (which read out their values
+     * from the data pool) which are not write-only.
+     * In case of an error (e.g. a wrong data type, or an invalid data pool id),
+     * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
+     *
+     * The data pool is locked during the whole read operation and
+     * freed afterwards. It is mandatory to call commit after a read call,
+     * even if the read operation is not successful!
+     * @return
+     * - @c RETURN_OK if all variables were read successfully.
+     * - @c INVALID_PARAMETER_DEFINITION if a pool entry does not exist or there
+     *      is a type conflict.
+     * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
+     *      commit() in between
+     */
+    virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t lockTimeout = 20) override;
+    /**
+     * @brief	The commit call initializes writing back the registered variables.
+     * @details
+     * It iterates through the list of registered variables and calls the
+     * commit() method of the remaining registered variables (which write back
+     * their values to the pool).
+     *
+     * The data pool is locked during the whole commit operation and
+     * freed afterwards. The state changes to "was committed" after this operation.
+     *
+     * If the set does contain at least one variable which is not write-only
+     * commit() can only be called after read(). If the set only contains
+     * variables which are write only, commit() can be called without a
+     * preceding read() call. Every read call must be followed by a commit call!
+     * @return	- @c RETURN_OK if all variables were read successfully.
+     * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
+     * 			  contains non write-only variables
+     */
+    virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t lockTimeout = 20) override;
 
-	/**
-	 * Register the passed pool variable instance into the data set.
-	 * @param variable
-	 * @return
-	 */
-	virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override;
+    /**
+     * Register the passed pool variable instance into the data set.
+     * @param variable
+     * @return
+     */
+    virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override;
 
-	/**
-	 * Provides the means to lock the underlying data structure to ensure
-	 * thread-safety. Default implementation is empty
-	 * @return Always returns -@c RETURN_OK
-	 */
-	virtual ReturnValue_t lockDataPool(
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20) override;
-	/**
-	 * Provides the means to unlock the underlying data structure to ensure
-	 * thread-safety. Default implementation is empty
-	 * @return Always returns -@c RETURN_OK
-	 */
-	virtual ReturnValue_t unlockDataPool() override;
+    /**
+     * Provides the means to lock the underlying data structure to ensure
+     * thread-safety. Default implementation is empty
+     * @return Always returns -@c RETURN_OK
+     */
+    virtual ReturnValue_t lockDataPool(
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
+    /**
+     * Provides the means to unlock the underlying data structure to ensure
+     * thread-safety. Default implementation is empty
+     * @return Always returns -@c RETURN_OK
+     */
+    virtual ReturnValue_t unlockDataPool() override;
 
-	virtual uint16_t getFillCount() const;
+    virtual uint16_t getFillCount() const;
 
-	/* SerializeIF implementations */
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const size_t maxSize,
-				SerializeIF::Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override;
+    /* SerializeIF implementations */
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            const size_t maxSize,
+            SerializeIF::Endianness streamEndianness) const override;
+    virtual size_t getSerializedSize() const override;
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            SerializeIF::Endianness streamEndianness) override;
 
     /**
      * Can be used to individually protect every read and commit call.
@@ -132,48 +133,48 @@ public:
             uint32_t mutexTimeout = 20);
 protected:
 
-	/**
-	 * @brief	The fill_count attribute ensures that the variables
-	 * 			register in the correct array position and that the maximum
-	 * 			number of variables is not exceeded.
-	 */
-	uint16_t fillCount = 0;
-	/**
-	 * States of the seet.
-	 */
-	enum class States {
-		STATE_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		STATE_SET_WAS_READ     //!< DATA_SET_WAS_READ
-	};
-	/**
-	 * @brief	state manages the internal state of the data set,
-	 *          which is important e.g. for the behavior on destruction.
-	 */
-	States state = States::STATE_SET_UNINITIALISED;
+    /**
+     * @brief	The fill_count attribute ensures that the variables
+     * 			register in the correct array position and that the maximum
+     * 			number of variables is not exceeded.
+     */
+    uint16_t fillCount = 0;
+    /**
+     * States of the seet.
+     */
+    enum class States {
+        STATE_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
+        STATE_SET_WAS_READ     //!< DATA_SET_WAS_READ
+    };
+    /**
+     * @brief	state manages the internal state of the data set,
+     *          which is important e.g. for the behavior on destruction.
+     */
+    States state = States::STATE_SET_UNINITIALISED;
 
-	/**
-	 * @brief	This array represents all pool variables registered in this set.
-	 * Child classes can use a static or dynamic container to create
-	 * an array of registered variables and assign the first entry here.
-	 */
-	PoolVariableIF** registeredVariables = nullptr;
-	const size_t maxFillCount = 0;
+    /**
+     * @brief	This array represents all pool variables registered in this set.
+     * Child classes can use a static or dynamic container to create
+     * an array of registered variables and assign the first entry here.
+     */
+    PoolVariableIF** registeredVariables = nullptr;
+    const size_t maxFillCount = 0;
 
-	void setContainer(PoolVariableIF** variablesContainer);
-	PoolVariableIF** getContainer() const;
+    void setContainer(PoolVariableIF** variablesContainer);
+    PoolVariableIF** getContainer() const;
 
 private:
-	bool protectEveryReadCommitCall = false;
-	MutexIF::TimeoutType timeoutTypeForSingleVars = MutexIF::TimeoutType::WAITING;
-	uint32_t mutexTimeoutForSingleVars = 20;
+    bool protectEveryReadCommitCall = false;
+    MutexIF::TimeoutType timeoutTypeForSingleVars = MutexIF::TimeoutType::WAITING;
+    uint32_t mutexTimeoutForSingleVars = 20;
 
-	ReturnValue_t readVariable(uint16_t count);
-	void handleAlreadyReadDatasetCommit(
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20);
-	ReturnValue_t handleUnreadDatasetCommit(
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20);
+    ReturnValue_t readVariable(uint16_t count);
+    void handleAlreadyReadDatasetCommit(
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20);
+    ReturnValue_t handleUnreadDatasetCommit(
+            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20);
 };
 
 #endif /* FSFW_DATAPOOL_POOLDATASETBASE_H_ */
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 444e19d00..dead6844a 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -1,9 +1,10 @@
 #ifndef FSFW_DATAPOOL_POOLVARIABLEIF_H_
 #define FSFW_DATAPOOL_POOLVARIABLEIF_H_
 
+#include "ReadCommitIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
-#include "ReadCommitIF.h"
+
 
 /**
  * @brief	This interface is used to control data pool
@@ -18,46 +19,46 @@
  * @author 	Bastian Baetz
  * @ingroup data_pool
  */
-class PoolVariableIF : public SerializeIF,
-		public ReadCommitIF {
-	friend class PoolDataSetBase;
-	friend class LocalPoolDataSetBase;
+class PoolVariableIF :
+        public SerializeIF,
+        public ReadCommitIF {
+
 public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
-	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
-	static constexpr ReturnValue_t INVALID_POOL_ENTRY = MAKE_RETURN_CODE(0xA1);
+    static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
+    static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
+    static constexpr ReturnValue_t INVALID_POOL_ENTRY = MAKE_RETURN_CODE(0xA1);
 
-	static constexpr bool VALID = 1;
-	static constexpr bool INVALID = 0;
-	static constexpr uint32_t NO_PARAMETER = 0xffffffff;
+    static constexpr bool VALID = 1;
+    static constexpr bool INVALID = 0;
+    static constexpr uint32_t NO_PARAMETER = 0xffffffff;
 
-	enum ReadWriteMode_t {
-		VAR_READ, VAR_WRITE, VAR_READ_WRITE
-	};
+    enum ReadWriteMode_t {
+        VAR_READ, VAR_WRITE, VAR_READ_WRITE
+    };
 
-	/**
-	 * @brief	This is an empty virtual destructor,
-	 * 			as it is proposed for C++ interfaces.
-	 */
-	virtual ~PoolVariableIF() {}
-	/**
-	 * @brief	This method returns if the variable is write-only,
-	 * 			read-write or read-only.
-	 */
-	virtual ReadWriteMode_t getReadWriteMode() const = 0;
-	/**
-	 * @brief	This operation shall return the data pool id of the variable.
-	 */
-	virtual uint32_t getDataPoolId() const = 0;
-	/**
-	 * @brief	With this call, the valid information of the
-	 * 			variable is returned.
-	 */
-	virtual bool isValid() const = 0;
-	/**
-	 * @brief	With this call, the valid information of the variable is set.
-	 */
-	virtual void setValid(bool validity) = 0;
+    /**
+     * @brief	This is an empty virtual destructor,
+     * 			as it is proposed for C++ interfaces.
+     */
+    virtual ~PoolVariableIF() {}
+    /**
+     * @brief	This method returns if the variable is write-only,
+     * 			read-write or read-only.
+     */
+    virtual ReadWriteMode_t getReadWriteMode() const = 0;
+    /**
+     * @brief	This operation shall return the data pool id of the variable.
+     */
+    virtual uint32_t getDataPoolId() const = 0;
+    /**
+     * @brief	With this call, the valid information of the
+     * 			variable is returned.
+     */
+    virtual bool isValid() const = 0;
+    /**
+     * @brief	With this call, the valid information of the variable is set.
+     */
+    virtual void setValid(bool validity) = 0;
 
 };
 
diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h
index e6355e824..d8bc5a66e 100644
--- a/datapool/ReadCommitIF.h
+++ b/datapool/ReadCommitIF.h
@@ -9,6 +9,7 @@
  * 			semantics.
  */
 class ReadCommitIF {
+    friend class ReadCommitIFAttorney;
 public:
 	virtual ~ReadCommitIF() {}
 	virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType,
@@ -16,11 +17,10 @@ public:
 	virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType,
 			uint32_t timeoutMs) = 0;
 
-protected:
+public:
 
-	//! Optional and protected because this is interesting for classes grouping
-	//! members with commit and read semantics where the lock is only necessary
-	//! once.
+	/* Optional and protected because this is interesting for classes grouping members with commit
+	and read semantics where the lock is only necessary once. */
 	virtual ReturnValue_t readWithoutLock()  {
 		return read(MutexIF::TimeoutType::WAITING, 20);
 	}
diff --git a/datapool/ReadCommitIFAttorney.h b/datapool/ReadCommitIFAttorney.h
new file mode 100644
index 000000000..0291cf5cc
--- /dev/null
+++ b/datapool/ReadCommitIFAttorney.h
@@ -0,0 +1,32 @@
+#ifndef FSFW_DATAPOOL_READCOMMITIFATTORNEY_H_
+#define FSFW_DATAPOOL_READCOMMITIFATTORNEY_H_
+
+#include <fsfw/datapool/ReadCommitIF.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+/**
+ * @brief   This class determines which members are allowed to access protected members
+ *          of the ReadCommitIF.
+ */
+class ReadCommitIFAttorney {
+private:
+    static ReturnValue_t readWithoutLock(ReadCommitIF* readCommitIF) {
+        if(readCommitIF == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        return readCommitIF->readWithoutLock();
+    }
+
+    static ReturnValue_t commitWithoutLock(ReadCommitIF* readCommitIF) {
+        if(readCommitIF == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        return readCommitIF->commitWithoutLock();
+    }
+
+    friend class PoolDataSetBase;
+};
+
+
+
+#endif /* FSFW_DATAPOOL_READCOMMITIFATTORNEY_H_ */

From 36039266ee703e86d828a8edf499895bc2d7529a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 13:52:07 +0100
Subject: [PATCH 1589/1774] some small formatting stuff

---
 datapool/PoolDataSetBase.cpp | 42 ++++++++++++++----------------------
 1 file changed, 16 insertions(+), 26 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 1474aff25..176676ce9 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -14,8 +14,7 @@ PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
 PoolDataSetBase::~PoolDataSetBase() {}
 
 
-ReturnValue_t PoolDataSetBase::registerVariable(
-        PoolVariableIF *variable) {
+ReturnValue_t PoolDataSetBase::registerVariable(PoolVariableIF *variable) {
     if (state != States::STATE_SET_UNINITIALISED) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "DataSet::registerVariable: "
@@ -59,10 +58,12 @@ ReturnValue_t PoolDataSetBase::read(MutexIF::TimeoutType timeoutType,
     }
     else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "DataSet::read(): "
-                "Call made in wrong position. Don't forget to commit"
+        sif::error << "DataSet::read(): Call made in wrong position. Don't forget to commit"
                 " member datasets!" << std::endl;
-#endif
+#else
+        sif::printError("DataSet::read(): Call made in wrong position. Don't forget to commit"
+                " member datasets!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         result = SET_WAS_ALREADY_READ;
     }
 
@@ -85,14 +86,10 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 
     /* These checks are often performed by the respective variable implementation too, but I guess
     a double check does not hurt. */
-    if (registeredVariables[count]->getReadWriteMode() !=
-            PoolVariableIF::VAR_WRITE and
-            registeredVariables[count]->getDataPoolId()
-            != PoolVariableIF::NO_PARAMETER)
-    {
+    if (registeredVariables[count]->getReadWriteMode() != PoolVariableIF::VAR_WRITE and
+            registeredVariables[count]->getDataPoolId() != PoolVariableIF::NO_PARAMETER) {
         if(protectEveryReadCommitCall) {
-            result = registeredVariables[count]->read(
-                    timeoutTypeForSingleVars,
+            result = registeredVariables[count]->read(timeoutTypeForSingleVars,
                     mutexTimeoutForSingleVars);
         }
         else {
@@ -121,13 +118,10 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(
         MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
     lockDataPool(timeoutType, lockTimeout);
     for (uint16_t count = 0; count < fillCount; count++) {
-        if (registeredVariables[count]->getReadWriteMode()
-                != PoolVariableIF::VAR_READ
-                && registeredVariables[count]->getDataPoolId()
-                != PoolVariableIF::NO_PARAMETER) {
+        if ((registeredVariables[count]->getReadWriteMode() != PoolVariableIF::VAR_READ) and
+                (registeredVariables[count]->getDataPoolId() != PoolVariableIF::NO_PARAMETER)) {
             if(protectEveryReadCommitCall) {
-                registeredVariables[count]->commit(
-                        timeoutTypeForSingleVars,
+                registeredVariables[count]->commit(timeoutTypeForSingleVars,
                         mutexTimeoutForSingleVars);
             }
             else {
@@ -144,13 +138,10 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     lockDataPool(timeoutType, lockTimeout);
     for (uint16_t count = 0; count < fillCount; count++) {
-        if (registeredVariables[count]->getReadWriteMode()
-                == PoolVariableIF::VAR_WRITE
-                && registeredVariables[count]->getDataPoolId()
-                != PoolVariableIF::NO_PARAMETER) {
+        if ((registeredVariables[count]->getReadWriteMode() == PoolVariableIF::VAR_WRITE) and
+                (registeredVariables[count]->getDataPoolId() != PoolVariableIF::NO_PARAMETER)) {
             if(protectEveryReadCommitCall) {
-                result = registeredVariables[count]->commit(
-                        timeoutTypeForSingleVars,
+                result = registeredVariables[count]->commit(timeoutTypeForSingleVars,
                         mutexTimeoutForSingleVars);
             }
             else {
@@ -187,8 +178,7 @@ ReturnValue_t PoolDataSetBase::serialize(uint8_t** buffer, size_t* size,
         const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
     for (uint16_t count = 0; count < fillCount; count++) {
-        result = registeredVariables[count]->serialize(buffer, size, maxSize,
-                streamEndianness);
+        result = registeredVariables[count]->serialize(buffer, size, maxSize, streamEndianness);
         if (result != HasReturnvaluesIF::RETURN_OK) {
             return result;
         }

From 35d8453b485b394b0add0883c3117cd37dbc7598 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 13:56:16 +0100
Subject: [PATCH 1590/1774] fixes for unit tests

---
 datapool/PoolDataSetBase.cpp                 | 2 +-
 osal/host/Clock.cpp                          | 2 +-
 osal/host/QueueMapManager.cpp                | 1 +
 unittest/tests/datapoollocal/DataSetTest.cpp | 3 +--
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 176676ce9..88470152d 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -1,7 +1,7 @@
 #include "PoolDataSetBase.h"
 #include "ReadCommitIFAttorney.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 #include <cstring>
 
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index f0543c790..c097f6199 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -1,4 +1,4 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../timemanager/Clock.h"
 
 #include <chrono>
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 9fb8b7a30..2a54f8134 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -1,5 +1,6 @@
 #include "QueueMapManager.h"
 
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../ipc/MutexFactory.h"
 #include "../../ipc/MutexHelper.h"
 
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 5c2428ae1..370a1e276 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -14,8 +14,7 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
             == retval::CATCH_OK);
     const uint32_t setId = 0;
     SECTION("BasicTest") {
-        StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>(
-                sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, setId));
+        StaticLocalDataSet<3> localSet(sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, setId));
     }
 }
 

From d79f0e1172fbf6c6702084777815660c573bceec Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 14:04:31 +0100
Subject: [PATCH 1591/1774] some more bugfixes for tests

---
 datapoollocal/LocalPoolObjectBase.cpp         |  4 ++-
 unittest/tests/datapoollocal/DataSetTest.cpp  |  4 +--
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 30 +++++++++++--------
 3 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 5b9bd34f6..7bc91dcb3 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,10 +1,12 @@
 #include "LocalPoolObjectBase.h"
 #include "LocalDataPoolManager.h"
-#include "internal/HasLocalDpIFUserAttorney.h"
+#include "AccessLocalPoolF.h"
 #include "HasLocalDataPoolIF.h"
+#include "internal/HasLocalDpIFUserAttorney.h"
 
 #include "../objectmanager/ObjectManagerIF.h"
 
+
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
         DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
         localPoolId(poolId), readWriteMode(setReadWriteMode) {
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 370a1e276..6ccb5122e 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -12,9 +12,9 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
     REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
     REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
             == retval::CATCH_OK);
-    const uint32_t setId = 0;
+    //const uint32_t setId = 0;
     SECTION("BasicTest") {
-        StaticLocalDataSet<3> localSet(sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, setId));
+        LocalPoolStaticTestDataSet localSet;
     }
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index acbb2b736..6b66f1f0a 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -31,6 +31,23 @@ static const gp_id_t uint64Vec2Id = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE,
 }
 
 
+class LocalPoolStaticTestDataSet: public StaticLocalDataSet<3> {
+public:
+    LocalPoolStaticTestDataSet():
+        StaticLocalDataSet(lpool::testSid) {
+    }
+
+    LocalPoolStaticTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
+        StaticLocalDataSet(owner, setId) {
+    }
+
+    lp_var_t<uint8_t> localPoolVarUint8 = lp_var_t<uint8_t>(lpool::uint8VarGpid, this);
+    lp_var_t<float> localPoolVarFloat = lp_var_t<float>(lpool::floatVarGpid, this);
+    lp_vec_t<uint16_t, 3> localPoolUint16Vec = lp_vec_t<uint16_t, 3>(lpool::uint16Vec3Gpid, this);
+
+private:
+};
+
 class LocalPoolTestDataSet: public LocalDataSet {
 public:
     LocalPoolTestDataSet():
@@ -41,19 +58,6 @@ public:
         LocalDataSet(owner, setId, lpool::dataSetMaxVariables) {
     }
 
-//    ReturnValue_t assignPointers() {
-//        PoolVariableIF** rawVarArray = getContainer();
-//        localPoolVarUint8 = dynamic_cast<lp_var_t<uint8_t>*>(rawVarArray[0]);
-//        localPoolVarFloat = dynamic_cast<lp_var_t<float>*>(rawVarArray[1]);
-//        localPoolUint16Vec = dynamic_cast<lp_vec_t<uint16_t, 3>*>(
-//                rawVarArray[2]);
-//        if(localPoolVarUint8 == nullptr or  localPoolVarFloat == nullptr or
-//                localPoolUint16Vec == nullptr) {
-//            return HasReturnvaluesIF::RETURN_FAILED;
-//        }
-//        return HasReturnvaluesIF::RETURN_OK;
-//    }
-
     lp_var_t<uint8_t> localPoolVarUint8 = lp_var_t<uint8_t>(lpool::uint8VarGpid, this);
     lp_var_t<float> localPoolVarFloat = lp_var_t<float>(lpool::floatVarGpid, this);
     lp_vec_t<uint16_t, 3> localPoolUint16Vec = lp_vec_t<uint16_t, 3>(lpool::uint16Vec3Gpid, this);

From 828115a566f69cfe99f64872f448585eab62ba28 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 14:35:10 +0100
Subject: [PATCH 1592/1774] test bugfixes and new reset function

---
 unittest/tests/datapoollocal/DataSetTest.cpp  | 44 +++++++++++++++++-
 .../datapoollocal/LocalPoolManagerTest.cpp    |  2 +-
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 46 +++++++++++++++++--
 .../datapoollocal/LocalPoolVariableTest.cpp   |  2 +
 4 files changed, 87 insertions(+), 7 deletions(-)

diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 6ccb5122e..7ba568775 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -1,8 +1,11 @@
 #include "LocalPoolOwnerBase.h"
 
 #include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_approx.hpp>
+
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/datapool/PoolReadHelper.h>
 #include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
@@ -12,10 +15,49 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
     REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
     REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
             == retval::CATCH_OK);
+    LocalPoolStaticTestDataSet localSet;
     //const uint32_t setId = 0;
     SECTION("BasicTest") {
-        LocalPoolStaticTestDataSet localSet;
+        {
+            PoolReadHelper readHelper(&localSet);
+            REQUIRE(readHelper.getReadResult() == retval::CATCH_OK);
+            CHECK(not localSet.isValid());
+            CHECK(localSet.localPoolVarUint8.value == 0);
+            CHECK(not localSet.localPoolVarUint8.isValid());
+            CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
+            CHECK(not localSet.localPoolVarUint8.isValid());
+            CHECK(localSet.localPoolUint16Vec.value[0] == 0);
+            CHECK(localSet.localPoolUint16Vec.value[1] == 0);
+            CHECK(localSet.localPoolUint16Vec.value[2] == 0);
+            CHECK(not localSet.localPoolVarUint8.isValid());
+
+            localSet.localPoolVarUint8 = 232;
+            localSet.localPoolVarFloat = -2324.322;
+            localSet.localPoolUint16Vec.value[0] = 232;
+            localSet.localPoolUint16Vec.value[1] = 23923;
+            localSet.localPoolUint16Vec.value[2] = 1;
+            localSet.setValidity(true, true);
+        }
+
+        {
+            PoolReadHelper readHelper(&localSet);
+            REQUIRE(readHelper.getReadResult() == retval::CATCH_OK);
+            CHECK(localSet.isValid());
+            CHECK(localSet.localPoolVarUint8.value == 232);
+            CHECK(localSet.localPoolVarUint8.isValid());
+            CHECK(localSet.localPoolVarFloat.value == Catch::Approx(-2324.322));
+            CHECK(localSet.localPoolVarUint8.isValid());
+            CHECK(localSet.localPoolUint16Vec.value[0] == 232);
+            CHECK(localSet.localPoolUint16Vec.value[1] == 23923);
+            CHECK(localSet.localPoolUint16Vec.value[2] == 1);
+            CHECK(localSet.localPoolVarUint8.isValid());
+        }
+
     }
+
+    /* we need to reset the subscription list because the pool owner
+    is a global object. */
+    CHECK(poolOwner->reset() == retval::CATCH_OK);
 }
 
 
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index e621f4d87..a10b44999 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -192,7 +192,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 
     /* we need to reset the subscription list because the pool owner
     is a global object. */
-    poolOwner->resetSubscriptionList();
+    CHECK(poolOwner->reset() == retval::CATCH_OK);
     mqMock->clearMessages(true);
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 6b66f1f0a..bb090e3b3 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -10,6 +10,7 @@
 #include <testcfg/objects/systemObjectList.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
+#include "../../../datapool/PoolReadHelper.h"
 
 namespace lpool {
 static constexpr lp_id_t uint8VarId = 0;
@@ -187,6 +188,43 @@ public:
                 MessageQueueIF::NO_QUEUE, objects::HK_RECEIVER_MOCK, false);
     }
 
+    ReturnValue_t reset() {
+        resetSubscriptionList();
+        ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+        {
+            PoolReadHelper readHelper(&dataset);
+            if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
+                status = readHelper.getReadResult();
+            }
+            dataset.localPoolVarUint8.value = 0;
+            dataset.localPoolVarFloat.value = 0.0;
+            dataset.localPoolUint16Vec.value[0] = 0;
+            dataset.localPoolUint16Vec.value[1] = 0;
+            dataset.localPoolUint16Vec.value[2] = 0;
+            dataset.setValidity(false, true);
+        }
+
+        {
+            PoolReadHelper readHelper(&testUint32);
+            if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
+                status = readHelper.getReadResult();
+            }
+            testUint32.value = 0;
+            testUint32.setValid(false);
+        }
+
+        {
+            PoolReadHelper readHelper(&testInt64Vec);
+            if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
+                status = readHelper.getReadResult();
+            }
+            testInt64Vec.value[0] = 0;
+            testInt64Vec.value[1] = 0;
+            testInt64Vec.setValid(false);
+        }
+        return status;
+    }
+
     void resetSubscriptionList() {
         poolManager.clearReceiversList();
     }
@@ -195,14 +233,12 @@ public:
     LocalPoolTestDataSet dataset;
 private:
 
-    lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId,
-            &dataset);
-    lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId,
-            &dataset);
+    lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
+    lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
     lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
 
     lp_vec_t<uint16_t, 3> testUint16Vec = lp_vec_t<uint16_t, 3>(this,
-            lpool::uint16Vec3Id, &dataset);
+            lpool::uint16Vec3Id);
     lp_vec_t<int64_t, 2> testInt64Vec = lp_vec_t<int64_t, 2>(this,
             lpool::int64Vec2Id);
 
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index eb99e58df..e5a5d3645 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -118,6 +118,8 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
                 lpool::uint8VarId);
     }
 
+    CHECK(poolOwner->reset() == retval::CATCH_OK);
+
 }
 
 

From fb5a1b93fce6c3e107050395d31303021928d79b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 14:38:01 +0100
Subject: [PATCH 1593/1774] unneeded variable removed

---
 unittest/tests/datapoollocal/DataSetTest.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 7ba568775..18503f05f 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -16,7 +16,7 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
     REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
             == retval::CATCH_OK);
     LocalPoolStaticTestDataSet localSet;
-    //const uint32_t setId = 0;
+
     SECTION("BasicTest") {
         {
             PoolReadHelper readHelper(&localSet);

From 68415853b5040733ff9f5d2739dd1bc704769bd1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 14:41:43 +0100
Subject: [PATCH 1594/1774] read commit IF functions protected again

---
 datapool/PoolDataSetBase.cpp | 5 ++++-
 datapool/ReadCommitIF.h      | 2 +-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 88470152d..e7572b27e 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -93,6 +93,7 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
                     mutexTimeoutForSingleVars);
         }
         else {
+            /* The readWithoutLock function is protected, so we use the attorney here */
             result = ReadCommitIFAttorney::readWithoutLock(registeredVariables[count]);
         }
 
@@ -125,6 +126,7 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(
                         mutexTimeoutForSingleVars);
             }
             else {
+                /* The commitWithoutLock function is protected, so we use the attorney here */
                 ReadCommitIFAttorney::commitWithoutLock(registeredVariables[count]);
             }
         }
@@ -145,7 +147,8 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(
                         mutexTimeoutForSingleVars);
             }
             else {
-                result = registeredVariables[count]->commitWithoutLock();
+                /* The commitWithoutLock function is protected, so we use the attorney here */
+                ReadCommitIFAttorney::commitWithoutLock(registeredVariables[count]);
             }
 
         } else if (registeredVariables[count]->getDataPoolId()
diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h
index d8bc5a66e..3ad2b3c02 100644
--- a/datapool/ReadCommitIF.h
+++ b/datapool/ReadCommitIF.h
@@ -17,7 +17,7 @@ public:
 	virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType,
 			uint32_t timeoutMs) = 0;
 
-public:
+protected:
 
 	/* Optional and protected because this is interesting for classes grouping members with commit
 	and read semantics where the lock is only necessary once. */

From 16566a5690159a84a88bdfb5f8a276feb1050da3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 14:45:09 +0100
Subject: [PATCH 1595/1774] nullptr check added

---
 datapoollocal/LocalPoolObjectBase.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 7bc91dcb3..a64ed2b4a 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -95,6 +95,10 @@ void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
 void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
         ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId) {
 #if FSFW_DISABLE_PRINTOUT == 0
+    const char* variablePrintout = variableType;
+    if(variablePrintout == nullptr) {
+        variablePrintout = "Unknown Type";
+    }
     const char* type = nullptr;
     if(read) {
         type = "read";
@@ -121,12 +125,12 @@ void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
     }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << variableType << ": " << type << " call | " << errMsg << " | Owner: 0x"
+    sif::warning << variablePrintout << ": " << type << " call | " << errMsg << " | Owner: 0x"
             << std::hex << std::setw(8) << std::setfill('0') << objectId << std::dec
             << " LPID: " << lpId << std::endl;
 #else
     sif::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
-            variableType, type, errMsg, objectId, lpId);
+            variablePrintout, type, errMsg, objectId, lpId);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_DISABLE_PRINTOUT == 0 */
 }

From 304773f7a7dbf84ab98c2b4c62c60f792cd07f1d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 14:54:03 +0100
Subject: [PATCH 1596/1774] added some failure test cases

---
 datapool/DataSetIF.h                         | 14 ++++++--------
 datapool/PoolDataSetBase.cpp                 | 15 +++++++++------
 unittest/tests/datapoollocal/DataSetTest.cpp |  8 ++++++++
 3 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index a6634a5c7..ea1a7126e 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -18,15 +18,13 @@ class PoolVariableIF;
 class DataSetIF {
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
-	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION =
-			MAKE_RETURN_CODE( 0x01 );
-	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
-	static constexpr ReturnValue_t COMMITING_WITHOUT_READING =
-			MAKE_RETURN_CODE(0x03);
+	static constexpr ReturnValue_t INVALID_PARAMETER_DEFINITION = MAKE_RETURN_CODE(1);
+	static constexpr ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t COMMITING_WITHOUT_READING = MAKE_RETURN_CODE(3);
 
-	static constexpr ReturnValue_t DATA_SET_UNINITIALISED = MAKE_RETURN_CODE( 0x04 );
-	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE( 0x05 );
-	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE( 0x06 );
+	static constexpr ReturnValue_t DATA_SET_UNINITIALISED = MAKE_RETURN_CODE(4);
+	static constexpr ReturnValue_t DATA_SET_FULL = MAKE_RETURN_CODE(5);
+	static constexpr ReturnValue_t POOL_VAR_NULL = MAKE_RETURN_CODE(6);
 
 	/**
 	 * @brief	This is an empty virtual destructor,
diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index e7572b27e..bdca22c3d 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -17,22 +17,25 @@ PoolDataSetBase::~PoolDataSetBase() {}
 ReturnValue_t PoolDataSetBase::registerVariable(PoolVariableIF *variable) {
     if (state != States::STATE_SET_UNINITIALISED) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "DataSet::registerVariable: "
-                "Call made in wrong position." << std::endl;
+        sif::error << "DataSet::registerVariable: Call made in wrong position." << std::endl;
+#else
+        sif::printError("DataSet::registerVariable: Call made in wrong position.");
 #endif
         return DataSetIF::DATA_SET_UNINITIALISED;
     }
     if (variable == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "DataSet::registerVariable: "
-                "Pool variable is nullptr." << std::endl;
+        sif::error << "DataSet::registerVariable: Pool variable is nullptr." << std::endl;
+#else
+        sif::printError("DataSet::registerVariable: Pool variable is nullptr.\n");
 #endif
         return DataSetIF::POOL_VAR_NULL;
     }
     if (fillCount >= maxFillCount) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "DataSet::registerVariable: "
-                "DataSet is full." << std::endl;
+        sif::error << "DataSet::registerVariable: DataSet is full." << std::endl;
+#else
+        sif::printError("DataSet::registerVariable: DataSet is full.\n");
 #endif
         return DataSetIF::DATA_SET_FULL;
     }
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 18503f05f..d829e7754 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -53,6 +53,14 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
             CHECK(localSet.localPoolVarUint8.isValid());
         }
 
+        /* Common fault test cases */
+        LocalPoolObjectBase* variableHandle = poolOwner->getPoolObjectHandle(lpool::uint32VarId);
+        CHECK(variableHandle != nullptr);
+        CHECK(localSet.registerVariable(variableHandle) ==
+                static_cast<int>(DataSetIF::DATA_SET_FULL));
+        variableHandle = nullptr;
+        REQUIRE(localSet.registerVariable(variableHandle) ==
+                static_cast<int>(DataSetIF::POOL_VAR_NULL));
     }
 
     /* we need to reset the subscription list because the pool owner

From 50ba3773809a170b858f4eece60f69ad1c65c7af Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 15:34:04 +0100
Subject: [PATCH 1597/1774] more set tests and new function to suppress commits

---
 datapool/PoolReadHelper.h                    | 13 ++++-
 datapoollocal/LocalPoolDataSetBase.cpp       |  2 +-
 unittest/tests/datapoollocal/DataSetTest.cpp | 55 ++++++++++++++++++++
 3 files changed, 68 insertions(+), 2 deletions(-)

diff --git a/datapool/PoolReadHelper.h b/datapool/PoolReadHelper.h
index 5c3153bb6..9825e83c1 100644
--- a/datapool/PoolReadHelper.h
+++ b/datapool/PoolReadHelper.h
@@ -32,8 +32,18 @@ public:
         return readResult;
     }
 
+    /**
+     * @brief   Can be used to suppress commit on destruction.
+     */
+    void setNoCommitMode(bool commit) {
+        this->noCommit = commit;
+    }
+
+    /**
+     * @brief   Default destructor which will take care of commiting changed values.
+     */
     ~PoolReadHelper() {
-        if(readObject != nullptr) {
+        if(readObject != nullptr and not noCommit) {
             readObject->commit(timeoutType, mutexTimeout);
         }
 
@@ -42,6 +52,7 @@ public:
 private:
     ReadCommitIF* readObject = nullptr;
     ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+    bool noCommit = false;
     MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
     uint32_t mutexTimeout = 20;
 };
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index d1d95d8a8..9f23fc6cb 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -173,7 +173,7 @@ ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
         size_t* size, size_t maxSize,SerializeIF::Endianness streamEndianness,
         bool serializeFillCount) const {
-    // Serialize as uint8_t
+    /* Serialize fill count as uint8_t */
     uint8_t fillCount = this->fillCount;
     if(serializeFillCount) {
         SerializeAdapter::serialize(&fillCount, buffer, size, maxSize,
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index d829e7754..eb8e9b603 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -18,7 +18,40 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
     LocalPoolStaticTestDataSet localSet;
 
     SECTION("BasicTest") {
+        /* Test some basic functions */
+        CHECK(localSet.getLocalPoolIdsSerializedSize(false) == 3 * sizeof(lp_id_t));
+        CHECK(localSet.getLocalPoolIdsSerializedSize(true) ==
+                3 * sizeof(lp_id_t) + sizeof(uint8_t));
+        CHECK(localSet.getSid() == lpool::testSid);
+        CHECK(localSet.getCreatorObjectId() == objects::TEST_LOCAL_POOL_OWNER_BASE);
+        size_t maxSize = localSet.getLocalPoolIdsSerializedSize(true);
+        uint8_t localPoolIdBuff[maxSize];
+        /* Skip size field */
+        lp_id_t* lpIds = reinterpret_cast<lp_id_t*>(localPoolIdBuff + 1);
+        size_t serSize = 0;
+        uint8_t *localPoolIdBuffPtr = reinterpret_cast<uint8_t*>(localPoolIdBuff);
+
+        /* Test local pool ID serialization */
+        CHECK(localSet.serializeLocalPoolIds(&localPoolIdBuffPtr, &serSize,
+                        maxSize, SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+        CHECK(serSize == maxSize);
+        CHECK(localPoolIdBuff[0] == 3);
+        CHECK(lpIds[0] == localSet.localPoolVarUint8.getDataPoolId());
+        CHECK(lpIds[1]  == localSet.localPoolVarFloat.getDataPoolId());
+        CHECK(lpIds[2]  == localSet.localPoolUint16Vec.getDataPoolId());
+        /* Now serialize without fill count */
+        lpIds = reinterpret_cast<lp_id_t*>(localPoolIdBuff);
+        localPoolIdBuffPtr = localPoolIdBuff;
+        serSize = 0;
+        CHECK(localSet.serializeLocalPoolIds(&localPoolIdBuffPtr, &serSize,
+                        maxSize, SerializeIF::Endianness::MACHINE, false) == retval::CATCH_OK);
+        CHECK(serSize == maxSize - sizeof(uint8_t));
+        CHECK(lpIds[0] == localSet.localPoolVarUint8.getDataPoolId());
+        CHECK(lpIds[1]  == localSet.localPoolVarFloat.getDataPoolId());
+        CHECK(lpIds[2]  == localSet.localPoolUint16Vec.getDataPoolId());
+
         {
+            /* Test read operation. Values should be all zeros */
             PoolReadHelper readHelper(&localSet);
             REQUIRE(readHelper.getReadResult() == retval::CATCH_OK);
             CHECK(not localSet.isValid());
@@ -31,6 +64,7 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
             CHECK(localSet.localPoolUint16Vec.value[2] == 0);
             CHECK(not localSet.localPoolVarUint8.isValid());
 
+            /* Now set new values, commit should be done by read helper automatically */
             localSet.localPoolVarUint8 = 232;
             localSet.localPoolVarFloat = -2324.322;
             localSet.localPoolUint16Vec.value[0] = 232;
@@ -51,6 +85,27 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
             CHECK(localSet.localPoolUint16Vec.value[1] == 23923);
             CHECK(localSet.localPoolUint16Vec.value[2] == 1);
             CHECK(localSet.localPoolVarUint8.isValid());
+
+            localSet.setValidityBufferGeneration(false);
+            maxSize = localSet.getSerializedSize();
+            CHECK(maxSize == sizeof(uint8_t) + sizeof(uint16_t) * 3 + sizeof(float));
+            serSize = 0;
+            uint8_t buffer[maxSize];
+            uint8_t* buffPtr = buffer;
+            CHECK(localSet.serialize(&buffPtr, &serSize, maxSize,
+                    SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+            uint8_t rawUint8 = buffer[0];
+            CHECK(rawUint8 == 232);
+            float rawFloat = 0.0;
+            std::memcpy(&rawFloat, buffer + sizeof(uint8_t), sizeof(float));
+            CHECK(rawFloat == Catch::Approx(-2324.322));
+
+            uint16_t rawUint16Vec[3];
+            std::memcpy(&rawUint16Vec, buffer + sizeof(uint8_t) + sizeof(float),
+                    3 * sizeof(uint16_t));
+            CHECK(rawUint16Vec[0] == 232);
+            CHECK(rawUint16Vec[1] == 23923);
+            CHECK(rawUint16Vec[2] == 1);
         }
 
         /* Common fault test cases */

From ffce336801d157c2ee9df2dc6feb682a5d125228 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 15:44:05 +0100
Subject: [PATCH 1598/1774] set tests continued

---
 unittest/tests/datapoollocal/DataSetTest.cpp | 35 ++++++++++++++++++--
 1 file changed, 32 insertions(+), 3 deletions(-)

diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index eb8e9b603..929e5d765 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -73,24 +73,32 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
             localSet.setValidity(true, true);
         }
 
+        /* Zero out some values for next test */
+        localSet.localPoolVarUint8 = 0;
+        localSet.localPoolVarFloat = 0;
+
         {
+            /* Now we read again and check whether our zeroed values were overwritten with
+            the values in the pool */
             PoolReadHelper readHelper(&localSet);
             REQUIRE(readHelper.getReadResult() == retval::CATCH_OK);
             CHECK(localSet.isValid());
             CHECK(localSet.localPoolVarUint8.value == 232);
             CHECK(localSet.localPoolVarUint8.isValid());
             CHECK(localSet.localPoolVarFloat.value == Catch::Approx(-2324.322));
-            CHECK(localSet.localPoolVarUint8.isValid());
+            CHECK(localSet.localPoolVarFloat.isValid());
             CHECK(localSet.localPoolUint16Vec.value[0] == 232);
             CHECK(localSet.localPoolUint16Vec.value[1] == 23923);
             CHECK(localSet.localPoolUint16Vec.value[2] == 1);
-            CHECK(localSet.localPoolVarUint8.isValid());
+            CHECK(localSet.localPoolUint16Vec.isValid());
 
+            /* Now we serialize these values into a buffer without the validity buffer */
             localSet.setValidityBufferGeneration(false);
             maxSize = localSet.getSerializedSize();
             CHECK(maxSize == sizeof(uint8_t) + sizeof(uint16_t) * 3 + sizeof(float));
             serSize = 0;
-            uint8_t buffer[maxSize];
+            /* Already reserve additional space for validity buffer, will be needed later */
+            uint8_t buffer[maxSize + 1];
             uint8_t* buffPtr = buffer;
             CHECK(localSet.serialize(&buffPtr, &serSize, maxSize,
                     SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
@@ -106,6 +114,27 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
             CHECK(rawUint16Vec[0] == 232);
             CHECK(rawUint16Vec[1] == 23923);
             CHECK(rawUint16Vec[2] == 1);
+
+            size_t sizeToDeserialize = maxSize;
+            /* Now we zeros out the raw entries and deserialize back into the dataset */
+            std::memset(buffer, 0, sizeof(buffer));
+            const uint8_t* constBuffPtr = buffer;
+            CHECK(localSet.deSerialize(&constBuffPtr, &sizeToDeserialize,
+                    SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+            /* Check whether deserialization was successfull */
+            CHECK(localSet.localPoolVarUint8.value == 0);
+            CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
+            CHECK(localSet.localPoolVarUint8.value == 0);
+            CHECK(localSet.localPoolUint16Vec.value[0] == 0);
+            CHECK(localSet.localPoolUint16Vec.value[1] == 0);
+            CHECK(localSet.localPoolUint16Vec.value[2] == 0);
+            /* Validity should be unchanged */
+            CHECK(localSet.localPoolVarUint8.isValid());
+            CHECK(localSet.localPoolVarFloat.isValid());
+            CHECK(localSet.localPoolUint16Vec.isValid());
+
+            /* Now we do the same process but with the validity buffer */
+            localSet.setValidityBufferGeneration(true);
         }
 
         /* Common fault test cases */

From 714f11f1170ac3669e155c9fdd68632349464d1d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 16:17:07 +0100
Subject: [PATCH 1599/1774] more tests and validity buffer bugfix

---
 datapoollocal/LocalPoolDataSetBase.cpp       | 77 ++++++++++----------
 datapoollocal/LocalPoolDataSetBase.h         | 14 ++--
 unittest/tests/datapoollocal/DataSetTest.cpp | 33 +++++++++
 3 files changed, 78 insertions(+), 46 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 9f23fc6cb..085ae2275 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -96,22 +96,22 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
         SerializeIF::Endianness streamEndianness) const {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-    uint8_t validityMask[validityMaskSize];
+    uint8_t validityMask[validityMaskSize] = {};
     uint8_t validBufferIndex = 0;
     uint8_t validBufferIndexBit = 0;
     for (uint16_t count = 0; count < fillCount; count++) {
         if(registeredVariables[count]->isValid()) {
-            // set validity buffer here.
-            this->bitSetter(validityMask + validBufferIndex,
-                    validBufferIndexBit);
-            if(validBufferIndexBit == 7) {
-                validBufferIndex ++;
-                validBufferIndexBit = 0;
-            }
-            else {
-                validBufferIndexBit ++;
-            }
+            /* Set bit at correct position */
+            this->bitSetter(validityMask + validBufferIndex, validBufferIndexBit);
         }
+        if(validBufferIndexBit == 7) {
+            validBufferIndex ++;
+            validBufferIndexBit = 0;
+        }
+        else {
+            validBufferIndexBit ++;
+        }
+
         result = registeredVariables[count]->serialize(buffer, size, maxSize,
                 streamEndianness);
         if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -246,21 +246,6 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
     }
 }
 
-void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
-    if(position > 7) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
-                << std::endl;
-#else
-        sif::printWarning("LocalPoolDataSetBase::bitSetter: "
-                "Invalid position!\n\r");
-#endif
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
-}
-
 void LocalPoolDataSetBase::setDiagnostic(bool isDiagnostics) {
     this->diagnostic = isDiagnostics;
 }
@@ -296,19 +281,6 @@ sid_t LocalPoolDataSetBase::getSid() const {
     return sid;
 }
 
-bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
-        uint8_t position) const {
-    if(position > 7) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "Pool Raw Access: Bit setting invalid position"
-                << std::endl;
-#endif
-        return false;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    return *byte & (1 << shiftNumber);
-}
-
 bool LocalPoolDataSetBase::isValid() const {
     return this->valid;
 }
@@ -328,3 +300,30 @@ object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
     }
     return objects::NO_OBJECT;
 }
+
+void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) {
+    if(position > 7) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
+                << std::endl;
+#else
+        sif::printWarning("LocalPoolDataSetBase::bitSetter: "
+                "Invalid position!\n\r");
+#endif
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1 << shiftNumber;
+}
+
+bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte, uint8_t position) {
+    if(position > 7) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::debug << "Pool Raw Access: Bit setting invalid position"
+                << std::endl;
+#endif
+        return false;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    return *byte & (1 << shiftNumber);
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index ca9074311..c676285c6 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -160,6 +160,13 @@ public:
 
     object_id_t getCreatorObjectId();
 
+    /* Static helper functions for manipulating validity buffers */
+    /**
+     * Set n-th bit of a byte, with n being the position from 0
+     * (most significant bit) to 7 (least significant bit)
+     */
+    static void bitSetter(uint8_t* byte, uint8_t position);
+    static bool bitGetter(const uint8_t* byte, uint8_t position);
 protected:
     sid_t sid;
     //! This mutex is used if the data is created by one object only.
@@ -218,13 +225,6 @@ protected:
      */
     ReturnValue_t unlockDataPool() override;
 
-    /**
-     * Set n-th bit of a byte, with n being the position from 0
-     * (most significant bit) to 7 (least significant bit)
-     */
-    void bitSetter(uint8_t* byte, uint8_t position) const;
-    bool bitGetter(const uint8_t* byte, uint8_t position) const;
-
     PeriodicHousekeepingHelper* periodicHelper = nullptr;
     LocalDataPoolManager* poolManager = nullptr;
 
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 929e5d765..7b2632c2c 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -134,7 +134,39 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
             CHECK(localSet.localPoolUint16Vec.isValid());
 
             /* Now we do the same process but with the validity buffer */
+            localSet.localPoolVarUint8 = 232;
+            localSet.localPoolVarFloat = -2324.322;
+            localSet.localPoolUint16Vec.value[0] = 232;
+            localSet.localPoolUint16Vec.value[1] = 23923;
+            localSet.localPoolUint16Vec.value[2] = 1;
+            localSet.localPoolVarUint8.setValid(true);
+            localSet.localPoolVarFloat.setValid(false);
+            localSet.localPoolUint16Vec.setValid(true);
             localSet.setValidityBufferGeneration(true);
+            maxSize = localSet.getSerializedSize();
+            CHECK(maxSize == sizeof(uint8_t) + sizeof(uint16_t) * 3 + sizeof(float) + 1);
+            serSize = 0;
+            buffPtr = buffer;
+            CHECK(localSet.serialize(&buffPtr, &serSize, maxSize,
+                    SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+            CHECK(rawUint8 == 232);
+            std::memcpy(&rawFloat, buffer + sizeof(uint8_t), sizeof(float));
+            CHECK(rawFloat == Catch::Approx(-2324.322));
+
+            std::memcpy(&rawUint16Vec, buffer + sizeof(uint8_t) + sizeof(float),
+                    3 * sizeof(uint16_t));
+            CHECK(rawUint16Vec[0] == 232);
+            CHECK(rawUint16Vec[1] == 23923);
+            CHECK(rawUint16Vec[2] == 1);
+            /* We can do it like this because the buffer only has one byte for
+            less than 8 variables */
+            uint8_t validityByte = buffer[sizeof(buffer) - 1];
+            CHECK(LocalPoolDataSetBase::bitGetter(&validityByte, 0) == true);
+            CHECK(LocalPoolDataSetBase::bitGetter(&validityByte, 1) == false);
+            CHECK(LocalPoolDataSetBase::bitGetter(&validityByte, 2) == true);
+
+            /* Now we manipulate the validity buffer for the deserialization */
+
         }
 
         /* Common fault test cases */
@@ -145,6 +177,7 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
         variableHandle = nullptr;
         REQUIRE(localSet.registerVariable(variableHandle) ==
                 static_cast<int>(DataSetIF::POOL_VAR_NULL));
+
     }
 
     /* we need to reset the subscription list because the pool owner

From 940bbf47e425dc0bdd70d1cba1c95a981d4d2db9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 16:34:11 +0100
Subject: [PATCH 1600/1774] set deser test complete

new bitutility file
---
 datapoollocal/LocalPoolDataSetBase.cpp       | 31 ++----------------
 datapoollocal/LocalPoolDataSetBase.h         |  7 -----
 globalfunctions/CMakeLists.txt               |  3 +-
 globalfunctions/bitutility.cpp               | 33 ++++++++++++++++++++
 globalfunctions/bitutility.h                 | 18 +++++++++++
 unittest/tests/datapoollocal/DataSetTest.cpp | 29 ++++++++++++++---
 6 files changed, 81 insertions(+), 40 deletions(-)
 create mode 100644 globalfunctions/bitutility.cpp
 create mode 100644 globalfunctions/bitutility.h

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 085ae2275..75a3ab7c2 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -3,6 +3,7 @@
 #include "internal/HasLocalDpIFUserAttorney.h"
 
 #include "../serviceinterface/ServiceInterface.h"
+#include "../globalfunctions/bitutility.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../housekeeping/PeriodicHousekeepingHelper.h"
 #include "../serialize/SerializeAdapter.h"
@@ -102,7 +103,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
     for (uint16_t count = 0; count < fillCount; count++) {
         if(registeredVariables[count]->isValid()) {
             /* Set bit at correct position */
-            this->bitSetter(validityMask + validBufferIndex, validBufferIndexBit);
+            bitutil::bitSet(validityMask + validBufferIndex, validBufferIndexBit);
         }
         if(validBufferIndexBit == 7) {
             validBufferIndex ++;
@@ -148,7 +149,7 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
     uint8_t validBufferIndexBit = 0;
     for (uint16_t count = 0; count < fillCount; count++) {
         // set validity buffer here.
-        bool nextVarValid = this->bitGetter(*buffer +
+        bool nextVarValid = bitutil::bitGet(*buffer +
                 validBufferIndex, validBufferIndexBit);
         registeredVariables[count]->setValid(nextVarValid);
 
@@ -301,29 +302,3 @@ object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
     return objects::NO_OBJECT;
 }
 
-void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) {
-    if(position > 7) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
-                << std::endl;
-#else
-        sif::printWarning("LocalPoolDataSetBase::bitSetter: "
-                "Invalid position!\n\r");
-#endif
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
-}
-
-bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte, uint8_t position) {
-    if(position > 7) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "Pool Raw Access: Bit setting invalid position"
-                << std::endl;
-#endif
-        return false;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    return *byte & (1 << shiftNumber);
-}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index c676285c6..8a3a63394 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -160,13 +160,6 @@ public:
 
     object_id_t getCreatorObjectId();
 
-    /* Static helper functions for manipulating validity buffers */
-    /**
-     * Set n-th bit of a byte, with n being the position from 0
-     * (most significant bit) to 7 (least significant bit)
-     */
-    static void bitSetter(uint8_t* byte, uint8_t position);
-    static bool bitGetter(const uint8_t* byte, uint8_t position);
 protected:
     sid_t sid;
     //! This mutex is used if the data is created by one object only.
diff --git a/globalfunctions/CMakeLists.txt b/globalfunctions/CMakeLists.txt
index 2b3dcf8ed..5ccd3c4cc 100644
--- a/globalfunctions/CMakeLists.txt
+++ b/globalfunctions/CMakeLists.txt
@@ -7,6 +7,7 @@ target_sources(${LIB_FSFW_NAME}
 		PeriodicOperationDivider.cpp
 		timevalOperations.cpp
 		Type.cpp
+		bitutility.cpp
 )
 
-add_subdirectory(math)
\ No newline at end of file
+add_subdirectory(math)
diff --git a/globalfunctions/bitutility.cpp b/globalfunctions/bitutility.cpp
new file mode 100644
index 000000000..5cc92dac5
--- /dev/null
+++ b/globalfunctions/bitutility.cpp
@@ -0,0 +1,33 @@
+#include "bitutility.h"
+
+void bitutil::bitSet(uint8_t *byte, uint8_t position) {
+    if(position > 7) {
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1 << shiftNumber;
+}
+
+void bitutil::bitToggle(uint8_t *byte, uint8_t position) {
+    if(position > 7) {
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte ^= 1 << shiftNumber;
+}
+
+void bitutil::bitClear(uint8_t *byte, uint8_t position) {
+    if(position > 7) {
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte &= ~(1 << shiftNumber);
+}
+
+bool bitutil::bitGet(const uint8_t *byte, uint8_t position) {
+    if(position > 7) {
+        return false;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    return *byte & (1 << shiftNumber);
+}
diff --git a/globalfunctions/bitutility.h b/globalfunctions/bitutility.h
new file mode 100644
index 000000000..1fc1290dc
--- /dev/null
+++ b/globalfunctions/bitutility.h
@@ -0,0 +1,18 @@
+#ifndef FSFW_GLOBALFUNCTIONS_BITUTIL_H_
+#define FSFW_GLOBALFUNCTIONS_BITUTIL_H_
+
+#include <cstdint>
+
+namespace bitutil {
+
+/* Helper functions for manipulating the individual bits of a byte.
+Position refers to n-th bit of a byte, going from 0 (most significant bit) to
+7 (least significant bit) */
+void bitSet(uint8_t* byte, uint8_t position);
+void bitToggle(uint8_t* byte, uint8_t position);
+void bitClear(uint8_t* byte, uint8_t position);
+bool bitGet(const uint8_t* byte, uint8_t position);
+
+}
+
+#endif /* FSFW_GLOBALFUNCTIONS_BITUTIL_H_ */
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 7b2632c2c..561345951 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -6,6 +6,8 @@
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/datapool/PoolReadHelper.h>
+#include <fsfw/globalfunctions/bitutility.h>
+
 #include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
@@ -160,12 +162,31 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
             CHECK(rawUint16Vec[2] == 1);
             /* We can do it like this because the buffer only has one byte for
             less than 8 variables */
-            uint8_t validityByte = buffer[sizeof(buffer) - 1];
-            CHECK(LocalPoolDataSetBase::bitGetter(&validityByte, 0) == true);
-            CHECK(LocalPoolDataSetBase::bitGetter(&validityByte, 1) == false);
-            CHECK(LocalPoolDataSetBase::bitGetter(&validityByte, 2) == true);
+            uint8_t* validityByte = buffer + sizeof(buffer) - 1;
+            CHECK(bitutil::bitGet(validityByte, 0) == true);
+            CHECK(bitutil::bitGet(validityByte, 1) == false);
+            CHECK(bitutil::bitGet(validityByte, 2) == true);
 
             /* Now we manipulate the validity buffer for the deserialization */
+            bitutil::bitClear(validityByte, 0);
+            bitutil::bitSet(validityByte, 1);
+            bitutil::bitClear(validityByte, 2);
+            /* Zero out everything except validity buffer */
+            std::memset(buffer, 0, sizeof(buffer) - 1);
+            sizeToDeserialize = maxSize;
+            constBuffPtr = buffer;
+            CHECK(localSet.deSerialize(&constBuffPtr, &sizeToDeserialize,
+                    SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+            /* Check whether deserialization was successfull */
+            CHECK(localSet.localPoolVarUint8.value == 0);
+            CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
+            CHECK(localSet.localPoolVarUint8.value == 0);
+            CHECK(localSet.localPoolUint16Vec.value[0] == 0);
+            CHECK(localSet.localPoolUint16Vec.value[1] == 0);
+            CHECK(localSet.localPoolUint16Vec.value[2] == 0);
+            CHECK(not localSet.localPoolVarUint8.isValid());
+            CHECK(localSet.localPoolVarFloat.isValid());
+            CHECK(not localSet.localPoolUint16Vec.isValid());
 
         }
 

From 5cf2197c06b15472eacb07eabc974d10491f49a8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 28 Feb 2021 17:33:54 +0100
Subject: [PATCH 1601/1774] minor formatting stuff

---
 datapool/PoolDataSetBase.h | 7 ++++---
 datapool/PoolDataSetIF.h   | 4 +++-
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index ab8954557..a551b815b 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -29,9 +29,10 @@
  * @author	Bastian Baetz
  * @ingroup data_pool
  */
-class PoolDataSetBase: public PoolDataSetIF,
-		public SerializeIF,
-		public HasReturnvaluesIF {
+class PoolDataSetBase:
+        public PoolDataSetIF,
+        public SerializeIF,
+        public HasReturnvaluesIF {
 public:
 
 	/**
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index 1f52871d9..9151f2f8e 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -8,7 +8,9 @@
  * @brief   Extendes the DataSetIF by adding abstract functions to lock
  *          and unlock a data pool and read/commit semantics.
  */
-class PoolDataSetIF: public DataSetIF, public ReadCommitIF {
+class PoolDataSetIF:
+        public DataSetIF,
+        public ReadCommitIF {
 public:
     virtual~ PoolDataSetIF() {};
 

From 2b6ccbc17f106a95a95fc04524c1334af10bd524 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 1 Mar 2021 12:26:16 +0100
Subject: [PATCH 1602/1774] renamed receivers list, functions protected

---
 datapoollocal/LocalDataPoolManager.cpp | 14 +++++++-------
 datapoollocal/LocalDataPoolManager.h   |  6 ++++--
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 19e235881..c15182d26 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -98,7 +98,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
 	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-	for(auto& receiver: hkReceiversMap) {
+	for(auto& receiver: hkReceivers) {
 		switch(receiver.reportingType) {
 		case(ReportingType::PERIODIC): {
 			if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
@@ -375,7 +375,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 				owner->getPeriodicOperationFrequency(), isDiagnostics);
 	}
 
-	hkReceiversMap.push_back(hkReceiver);
+	hkReceivers.push_back(hkReceiver);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -404,7 +404,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(sid_t sid,
 		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
 	}
 
-	hkReceiversMap.push_back(hkReceiver);
+	hkReceivers.push_back(hkReceiver);
 
 	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
 	return HasReturnvaluesIF::RETURN_OK;
@@ -425,7 +425,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessage(
 		hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
 	}
 
-	hkReceiversMap.push_back(hkReceiver);
+	hkReceivers.push_back(hkReceiver);
 
 	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
 	return HasReturnvaluesIF::RETURN_OK;
@@ -446,7 +446,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessage(
 		hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
 	}
 
-	hkReceiversMap.push_back(hkReceiver);
+	hkReceivers.push_back(hkReceiver);
 
 	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
 	return HasReturnvaluesIF::RETURN_OK;
@@ -829,8 +829,8 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 }
 
 void LocalDataPoolManager::clearReceiversList() {
-	// clear the vector completely and releases allocated memory.
-	HkReceivers().swap(hkReceiversMap);
+	/* Clear the vector completely and releases allocated memory. */
+	HkReceivers().swap(hkReceivers);
 }
 
 MutexIF* LocalDataPoolManager::getLocalPoolMutex() {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index fdfd9d233..241472581 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -271,7 +271,9 @@ public:
     MutexIF* getMutexHandle();
 
     virtual LocalDataPoolManager* getPoolManagerHandle() override;
-private:
+
+protected:
+
     localpool::DataPool localPoolMap;
     /** Every housekeeping data manager has a mutex to protect access
     to it's data pool. */
@@ -307,7 +309,7 @@ private:
     /** This vector will contain the list of HK receivers. */
     using HkReceivers = std::vector<struct HkReceiver>;
 
-    HkReceivers hkReceiversMap;
+    HkReceivers hkReceivers;
 
     struct HkUpdateResetHelper {
         DataType dataType = DataType::DATA_SET;

From 9f09c190bb09e5b368a6f4779b840264e15dfabd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 1 Mar 2021 12:32:54 +0100
Subject: [PATCH 1603/1774] formatting change

---
 datapoollocal/LocalDataPoolManager.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 241472581..2e673f977 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -397,8 +397,7 @@ protected:
 
 
 template<class T> inline
-ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
-        PoolEntry<T> **poolEntry) {
+ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
         printWarningOrError(sif::OutputTypes::OUT_WARNING, "fetchPoolEntry",

From 9e9113912b6f6f906adcce501a7c7f08461967f9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 1 Mar 2021 12:36:18 +0100
Subject: [PATCH 1604/1774] minor formatting stuff

---
 datapoollocal/LocalDataPoolManager.h          | 33 ++++++++-----------
 .../internal/LocalDpManagerAttorney.h         |  1 -
 datapoollocal/localPoolDefinitions.h          |  4 +--
 3 files changed, 15 insertions(+), 23 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 2e673f977..ff6edb95d 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -274,6 +274,7 @@ public:
 
 protected:
 
+    /** Core data structure for the actual pool data */
     localpool::DataPool localPoolMap;
     /** Every housekeeping data manager has a mutex to protect access
     to it's data pool. */
@@ -319,7 +320,8 @@ protected:
     };
 
     using HkUpdateResetList = std::vector<struct HkUpdateResetHelper>;
-    // Will only be created when needed.
+    /** This list is used to manage creating multiple update packets and only resetting
+    the update flag if all of them were created. Will only be created when needed. */
     HkUpdateResetList* hkUpdateResetList = nullptr;
 
     /** This is the map holding the actual data. Should only be initialized
@@ -343,16 +345,14 @@ protected:
      * Read a variable by supplying its local pool ID and assign the pool
      * entry to the supplied PoolEntry pointer. The type of the pool entry
      * is deduced automatically. This call is not thread-safe!
-     * For now, only friend classes like LocalPoolVar may access this
-     * function.
+     * For now, only classes designated by the LocalDpManagerAttorney may use this function.
      * @tparam T Type of the pool entry
      * @param localPoolId Pool ID of the variable to read
      * @param poolVar [out] Corresponding pool entry will be assigned to the
      * 						supplied pointer.
      * @return
      */
-    template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
-            PoolEntry<T> **poolEntry);
+    template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry);
 
     /**
      * This function is used to fill the local data pool map with pool
@@ -364,15 +364,13 @@ protected:
 
     MutexIF* getLocalPoolMutex() override;
 
-    ReturnValue_t serializeHkPacketIntoStore(
-            HousekeepingPacketDownlink& hkPacket,
+    ReturnValue_t serializeHkPacketIntoStore(HousekeepingPacketDownlink& hkPacket,
             store_address_t& storeId, bool forDownlink, size_t* serializedSize);
 
     void performPeriodicHkGeneration(HkReceiver& hkReceiver);
-    ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable,
+    ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable, bool isDiagnostics);
+    ReturnValue_t changeCollectionInterval(sid_t sid, float newCollectionInterval,
             bool isDiagnostics);
-    ReturnValue_t changeCollectionInterval(sid_t sid,
-            float newCollectionInterval, bool isDiagnostics);
     ReturnValue_t generateSetStructurePacket(sid_t sid, bool isDiagnostics);
 
     void handleHkUpdateResetListInsertion(DataType dataType, DataId dataId);
@@ -380,17 +378,12 @@ protected:
             DataId dataId, MarkChangedIF* toReset);
     void resetHkUpdateResetHelper();
 
-    ReturnValue_t handleHkUpdate(HkReceiver& hkReceiver,
-            ReturnValue_t& status);
-    ReturnValue_t handleNotificationUpdate(HkReceiver& hkReceiver,
-            ReturnValue_t& status);
-    ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver,
-            ReturnValue_t& status);
-    ReturnValue_t addUpdateToStore(HousekeepingSnapshot& updatePacket,
-            store_address_t& storeId);
+    ReturnValue_t handleHkUpdate(HkReceiver& hkReceiver, ReturnValue_t& status);
+    ReturnValue_t handleNotificationUpdate(HkReceiver& hkReceiver, ReturnValue_t& status);
+    ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver, ReturnValue_t& status);
+    ReturnValue_t addUpdateToStore(HousekeepingSnapshot& updatePacket, store_address_t& storeId);
 
-    void printWarningOrError(sif::OutputTypes outputType,
-            const char* functionName,
+    void printWarningOrError(sif::OutputTypes outputType, const char* functionName,
             ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
             const char* errorPrint = nullptr);
 };
diff --git a/datapoollocal/internal/LocalDpManagerAttorney.h b/datapoollocal/internal/LocalDpManagerAttorney.h
index bb64fb422..994f0613b 100644
--- a/datapoollocal/internal/LocalDpManagerAttorney.h
+++ b/datapoollocal/internal/LocalDpManagerAttorney.h
@@ -24,7 +24,6 @@ private:
         return manager.getMutexHandle();
     }
 
-
     template<typename T> friend class LocalPoolVariable;
     template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 };
diff --git a/datapoollocal/localPoolDefinitions.h b/datapoollocal/localPoolDefinitions.h
index ff44fb8e7..af8ce7115 100644
--- a/datapoollocal/localPoolDefinitions.h
+++ b/datapoollocal/localPoolDefinitions.h
@@ -21,8 +21,8 @@ static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
 static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
 
-//! This is the core data structure of the local data pools. Users should insert all desired
-//! pool variables, using the std::map interface.
+/** This is the core data structure of the local data pools. Users should insert all desired
+pool variables, using the std::map interface. */
 using DataPool =  std::map<lp_id_t, PoolEntryIF*>;
 using DataPoolMapIter = DataPool::iterator;
 

From cc84d542c8a1b44bf16650aa9aaf2343d848c817 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 1 Mar 2021 16:46:45 +0100
Subject: [PATCH 1605/1774] added static function to create command id

---
 ipc/CommandMessageIF.h | 93 ++++++++++++++++++++++--------------------
 1 file changed, 48 insertions(+), 45 deletions(-)

diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index aafa40ef8..898f69827 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -13,60 +13,63 @@ public:
     /**
      * Header consists of sender ID and command ID.
      */
-	static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
-			sizeof(Command_t);
-	/**
-	 * This minimum size is derived from the interface requirement to be able
+    static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
+    sizeof(Command_t);
+    /**
+     * This minimum size is derived from the interface requirement to be able
      * to set a rejected reply, which contains a returnvalue and the initial
      * command.
-	 */
-	static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
-	        CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
-	        sizeof(Command_t);
+     */
+    static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
+            sizeof(ReturnValue_t) + sizeof(Command_t);
 
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
-	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
+    static Command_t makeCommandId(uint8_t messageId, uint8_t uniqueId) {
+        return ((messageId << 8) | uniqueId);
+    }
 
-	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
-	//! Used internally, shall be ignored
-	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
-	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
-	//! Reply indicating that the current command was rejected,
-	//! par1 should contain the error code
-	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
+    static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
+    static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
 
-	virtual ~CommandMessageIF() {};
+    static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
+    //! Used internally, shall be ignored
+    static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
+    static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
+    //! Reply indicating that the current command was rejected,
+    //! par1 should contain the error code
+    static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
 
-	/**
-	 * A command message shall have a uint16_t command ID field.
-	 * @return
-	 */
-	virtual Command_t getCommand() const = 0;
-	/**
-	 * A command message shall have a uint8_t message type ID field.
-	 * @return
-	 */
-	virtual uint8_t getMessageType() const = 0;
+    virtual ~CommandMessageIF() {};
 
-	/**
-	 * A command message can be rejected and needs to offer a function
-	 * to set a rejected reply
-	 * @param reason
-	 * @param initialCommand
-	 */
-	virtual void setReplyRejected(ReturnValue_t reason,
-			Command_t initialCommand) = 0;
-	/**
-	 * Corrensonding getter function.
-	 * @param initialCommand
-	 * @return
-	 */
-	virtual ReturnValue_t getReplyRejectedReason(
-			Command_t* initialCommand = nullptr) const  = 0;
+    /**
+     * A command message shall have a uint16_t command ID field.
+     * @return
+     */
+    virtual Command_t getCommand() const = 0;
+    /**
+     * A command message shall have a uint8_t message type ID field.
+     * @return
+     */
+    virtual uint8_t getMessageType() const = 0;
 
-	virtual void setToUnknownCommand() = 0;
+    /**
+     * A command message can be rejected and needs to offer a function
+     * to set a rejected reply
+     * @param reason
+     * @param initialCommand
+     */
+    virtual void setReplyRejected(ReturnValue_t reason,
+            Command_t initialCommand) = 0;
+    /**
+     * Corrensonding getter function.
+     * @param initialCommand
+     * @return
+     */
+    virtual ReturnValue_t getReplyRejectedReason(
+            Command_t* initialCommand = nullptr) const  = 0;
 
-	virtual void clear() = 0;
+    virtual void setToUnknownCommand() = 0;
+
+    virtual void clear() = 0;
 
 };
 

From 1d3438bb7de151cbcc27663ffa58dc58e6821b39 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 2 Mar 2021 01:04:51 +0100
Subject: [PATCH 1606/1774] updated HasFileSystemIF

---
 memory/HasFileSystemIF.h  | 20 ++++++++++++--------
 returnvalues/FwClassIds.h |  1 +
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index dcec6346e..52360f0c7 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -16,17 +16,21 @@ class HasFileSystemIF {
 public:
     static constexpr uint8_t INTERFACE_ID = CLASS_ID::FILE_SYSTEM;
 
-    static constexpr ReturnValue_t FILE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x00);
-    static constexpr ReturnValue_t FILE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-    static constexpr ReturnValue_t FILE_LOCKED = MAKE_RETURN_CODE(0x02);
+    //! [EXPORT] : P1: Can be file system specific error code
+    static constexpr ReturnValue_t GENERIC_FILE_ERROR = MAKE_RETURN_CODE(0);
 
-    static constexpr ReturnValue_t DIRECTORY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
-    static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x04);
-    static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(0x05);
+    static constexpr ReturnValue_t FILE_DOES_NOT_EXIST = MAKE_RETURN_CODE(1);
+    static constexpr ReturnValue_t FILE_ALREADY_EXISTS = MAKE_RETURN_CODE(2);
+    static constexpr ReturnValue_t FILE_LOCKED = MAKE_RETURN_CODE(3);
 
+    static constexpr ReturnValue_t DIRECTORY_DOES_NOT_EXIST = MAKE_RETURN_CODE(4);
+    static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(5);
+    static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(6);
 
-    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_WRITE = MAKE_RETURN_CODE(0x06); //! P1: Sequence number missing
-    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_READ = MAKE_RETURN_CODE(0x07); //! P1: Sequence number missing
+    //! [EXPORT] : P1: Sequence number missing
+    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_WRITE = MAKE_RETURN_CODE(7);
+    //! [EXPORT] : P1: Sequence number missing
+    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_READ = MAKE_RETURN_CODE(8);
 
 	virtual ~HasFileSystemIF() {}
 	/**
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 53add6a0a..4c9f022ba 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -65,6 +65,7 @@ enum {
 	HOUSEKEEPING_MANAGER, //HKM 60
 	DLE_ENCODER, //DLEE 61
 	PUS_SERVICE_9, //PUS9 62
+	FILE_SYSTEM, //FILS 63
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 91db9c362eb214741b46969864bd63f8fd9fedfb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Mar 2021 12:35:19 +0100
Subject: [PATCH 1607/1774] added additional returnvalues

---
 memory/HasFileSystemIF.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 52360f0c7..cb4ca9309 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -32,6 +32,11 @@ public:
     //! [EXPORT] : P1: Sequence number missing
     static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_READ = MAKE_RETURN_CODE(8);
 
+    //! [EXPORT] : File system is currently busy
+    static constexpr ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(9);
+    //! [EXPORT] : Invalid parameters like file name or repository path
+    static constexpr ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(10);
+
 	virtual ~HasFileSystemIF() {}
 	/**
 	 * Function to get the MessageQueueId_t of the implementing object

From 3f47db9c18d35a6d01a7a087ad41759eb3f409a2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Mar 2021 12:36:13 +0100
Subject: [PATCH 1608/1774] reordered returnvalues

---
 memory/HasFileSystemIF.h | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index cb4ca9309..73c934105 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -18,24 +18,25 @@ public:
 
     //! [EXPORT] : P1: Can be file system specific error code
     static constexpr ReturnValue_t GENERIC_FILE_ERROR = MAKE_RETURN_CODE(0);
-
-    static constexpr ReturnValue_t FILE_DOES_NOT_EXIST = MAKE_RETURN_CODE(1);
-    static constexpr ReturnValue_t FILE_ALREADY_EXISTS = MAKE_RETURN_CODE(2);
-    static constexpr ReturnValue_t FILE_LOCKED = MAKE_RETURN_CODE(3);
-
-    static constexpr ReturnValue_t DIRECTORY_DOES_NOT_EXIST = MAKE_RETURN_CODE(4);
-    static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(5);
-    static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(6);
-
-    //! [EXPORT] : P1: Sequence number missing
-    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_WRITE = MAKE_RETURN_CODE(7);
-    //! [EXPORT] : P1: Sequence number missing
-    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_READ = MAKE_RETURN_CODE(8);
-
     //! [EXPORT] : File system is currently busy
-    static constexpr ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(9);
+    static constexpr ReturnValue_t IS_BUSY = MAKE_RETURN_CODE(1);
     //! [EXPORT] : Invalid parameters like file name or repository path
-    static constexpr ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(10);
+    static constexpr ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
+
+    static constexpr ReturnValue_t FILE_DOES_NOT_EXIST = MAKE_RETURN_CODE(5);
+    static constexpr ReturnValue_t FILE_ALREADY_EXISTS = MAKE_RETURN_CODE(6);
+    static constexpr ReturnValue_t FILE_LOCKED = MAKE_RETURN_CODE(7);
+
+    static constexpr ReturnValue_t DIRECTORY_DOES_NOT_EXIST = MAKE_RETURN_CODE(10);
+    static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(11);
+    static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(12);
+
+    //! [EXPORT] : P1: Sequence number missing
+    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_WRITE = MAKE_RETURN_CODE(15);
+    //! [EXPORT] : P1: Sequence number missing
+    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_READ = MAKE_RETURN_CODE(16);
+
+
 
 	virtual ~HasFileSystemIF() {}
 	/**

From 1caa45118b9bdeec471086b15da5893a23a82ca0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Mar 2021 14:58:49 +0100
Subject: [PATCH 1609/1774] makecommandid is constexpr now

---
 ipc/CommandMessageIF.h | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index 898f69827..468e24693 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -13,8 +13,7 @@ public:
     /**
      * Header consists of sender ID and command ID.
      */
-    static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
-    sizeof(Command_t);
+    static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE + sizeof(Command_t);
     /**
      * This minimum size is derived from the interface requirement to be able
      * to set a rejected reply, which contains a returnvalue and the initial
@@ -23,12 +22,12 @@ public:
     static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
             sizeof(ReturnValue_t) + sizeof(Command_t);
 
-    static Command_t makeCommandId(uint8_t messageId, uint8_t uniqueId) {
+    static constexpr Command_t makeCommandId(uint8_t messageId, uint8_t uniqueId) {
         return ((messageId << 8) | uniqueId);
     }
 
     static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
-    static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
+    static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(1);
 
     static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
     //! Used internally, shall be ignored

From 9a3cd1d7fc5b069c655ba1bf53a8273df34b9bc8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Mar 2021 15:13:03 +0100
Subject: [PATCH 1610/1774] success flag not explicitely expected for actions

---
 action/ActionHelper.cpp                    | 6 +++---
 action/ActionHelper.h                      | 4 ++--
 action/ActionMessage.cpp                   | 7 ++++---
 action/ActionMessage.h                     | 8 ++++++--
 action/SimpleActionHelper.cpp              | 2 +-
 devicehandlers/DeviceHandlerBase.cpp       | 8 ++++++--
 unittest/tests/action/TestActionHelper.cpp | 2 +-
 7 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index e32be68b2..42ee4022f 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -43,10 +43,10 @@ void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo,
     queueToUse->sendMessage(reportTo, &reply);
 }
 
-void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId,
+void ActionHelper::finish(bool success, MessageQueueId_t reportTo, ActionId_t commandId,
         ReturnValue_t result) {
     CommandMessage reply;
-    ActionMessage::setCompletionReply(&reply, commandId, result);
+    ActionMessage::setCompletionReply(success, &reply, commandId, result);
     queueToUse->sendMessage(reportTo, &reply);
 }
 
@@ -69,7 +69,7 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
     ipcStore->deleteData(dataAddress);
     if(result == HasActionsIF::EXECUTION_FINISHED) {
         CommandMessage reply;
-        ActionMessage::setCompletionReply(&reply, actionId, result);
+        ActionMessage::setCompletionReply(true, &reply, actionId, result);
         queueToUse->sendMessage(commandedBy, &reply);
     }
     if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index 35ac41d1c..c90247478 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -62,12 +62,12 @@ public:
             ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
     /**
      * Function to be called by the owner to send a action completion message
-     *
+     * @param success   Specify whether action was completed successfully or not.
      * @param reportTo MessageQueueId_t to report the action completion message to
      * @param commandId ID of the executed command
      * @param result Result of the execution
      */
-    void finish(MessageQueueId_t reportTo, ActionId_t commandId,
+    void finish(bool success, MessageQueueId_t reportTo, ActionId_t commandId,
             ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
     /**
      * Function to be called by the owner if an action does report data.
diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index c3eb47109..15b59b9dc 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -53,11 +53,12 @@ void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
     message->setParameter2(data.raw);
 }
 
-void ActionMessage::setCompletionReply(CommandMessage* message,
+void ActionMessage::setCompletionReply(bool success, CommandMessage* message,
         ActionId_t fid, ReturnValue_t result) {
-    if (result == HasReturnvaluesIF::RETURN_OK or result == HasActionsIF::EXECUTION_FINISHED) {
+    if (success) {
         message->setCommand(COMPLETION_SUCCESS);
-    } else {
+    }
+    else {
         message->setCommand(COMPLETION_FAILED);
     }
     message->setParameter(fid);
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index 246ac601d..df97485b9 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -24,19 +24,23 @@ public:
     static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
     static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
     static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
+
     virtual ~ActionMessage();
     static void setCommand(CommandMessage* message, ActionId_t fid,
             store_address_t parameters);
+
     static ActionId_t getActionId(const CommandMessage* message );
-    static store_address_t getStoreId(const CommandMessage* message );
+    static store_address_t getStoreId(const CommandMessage* message);
+
     static void setStepReply(CommandMessage* message, ActionId_t fid,
             uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
     static uint8_t getStep(const CommandMessage* message );
     static ReturnValue_t getReturnCode(const CommandMessage* message );
     static void setDataReply(CommandMessage* message, ActionId_t actionId,
             store_address_t data);
-    static void setCompletionReply(CommandMessage* message, ActionId_t fid,
+    static void setCompletionReply(bool success, CommandMessage* message, ActionId_t fid,
             ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+
     static void clear(CommandMessage* message);
 };
 
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index f77d01473..979ee3ad4 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -62,7 +62,7 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
         stepCount++;
         break;
     case HasActionsIF::EXECUTION_FINISHED:
-        ActionMessage::setCompletionReply(&reply, actionId,
+        ActionMessage::setCompletionReply(true, &reply, actionId,
                 HasReturnvaluesIF::RETURN_OK);
         queueToUse->sendMessage(commandedBy, &reply);
         break;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 35d34bf9b..15eac11f4 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -558,7 +558,7 @@ void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
     if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
         MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
         if (status == NO_REPLY_EXPECTED) {
-            actionHelper.finish(queueId, cookieInfo.pendingCommand->first,
+            actionHelper.finish(true, queueId, cookieInfo.pendingCommand->first,
                     RETURN_OK);
         } else {
             actionHelper.step(1, queueId, cookieInfo.pendingCommand->first,
@@ -581,7 +581,11 @@ void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
         // Check if it was transition or internal command.
         // Don't send any replies in that case.
         if (info->sendReplyTo != NO_COMMANDER) {
-            actionHelper.finish(info->sendReplyTo, iter->first, status);
+            bool success = false;
+            if(status == HasReturnvaluesIF::RETURN_OK) {
+                success = true;
+            }
+            actionHelper.finish(success, info->sendReplyTo, iter->first, status);
         }
         info->isExecuting = false;
     }
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index 2493a6b8e..a7adfc82d 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -70,7 +70,7 @@ TEST_CASE( "Action Helper" , "[ActionHelper]") {
 	SECTION("Handle finish"){
 		CHECK(not testMqMock.wasMessageSent());
 		ReturnValue_t status = 0x9876;
-		actionHelper.finish(testMqMock.getId(), testActionId, status);
+		actionHelper.finish(true, testMqMock.getId(), testActionId, status);
 		CHECK(testMqMock.wasMessageSent());
 		CommandMessage testMessage;
 		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));

From 6580aa73bf587afddcdfd908844dabe4add36489 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Mar 2021 17:13:37 +0100
Subject: [PATCH 1611/1774] updated clock module

---
 osal/FreeRTOS/Clock.cpp   | 214 +++++++++++++++++++-------------------
 timemanager/CCSDSTime.cpp |  16 ++-
 2 files changed, 119 insertions(+), 111 deletions(-)

diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index 9c0a02679..806edcc7c 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -16,56 +16,56 @@ uint16_t Clock::leapSeconds = 0;
 MutexIF* Clock::timeMutex = nullptr;
 
 uint32_t Clock::getTicksPerSecond(void) {
-	return 1000;
+    return 1000;
 }
 
 ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
 
-	timeval time_timeval;
+    timeval time_timeval;
 
-	ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
+    ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
+    if (result != HasReturnvaluesIF::RETURN_OK){
+        return result;
+    }
 
-	return setClock(&time_timeval);
+    return setClock(&time_timeval);
 }
 
 ReturnValue_t Clock::setClock(const timeval* time) {
-	timeval uptime = getUptime();
+    timeval uptime = getUptime();
 
-	timeval offset = *time - uptime;
+    timeval offset = *time - uptime;
 
-	Timekeeper::instance()->setOffset(offset);
+    Timekeeper::instance()->setOffset(offset);
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	timeval uptime = getUptime();
+    timeval uptime = getUptime();
 
-	timeval offset = Timekeeper::instance()->getOffset();
+    timeval offset = Timekeeper::instance()->getOffset();
 
-	*time = offset + uptime;
+    *time = offset + uptime;
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getUptime(timeval* uptime) {
-	*uptime = getUptime();
+    *uptime = getUptime();
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 timeval Clock::getUptime() {
-	TickType_t ticksSinceStart = xTaskGetTickCount();
-	return Timekeeper::ticksToTimeval(ticksSinceStart);
+    TickType_t ticksSinceStart = xTaskGetTickCount();
+    return Timekeeper::ticksToTimeval(ticksSinceStart);
 }
 
 ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	timeval uptime = getUptime();
-	*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
-	return HasReturnvaluesIF::RETURN_OK;
+    timeval uptime = getUptime();
+    *uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 
@@ -76,129 +76,129 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 
 
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval time_timeval;
-	ReturnValue_t result = getClock_timeval(&time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	*time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
-	return HasReturnvaluesIF::RETURN_OK;
+    timeval time_timeval;
+    ReturnValue_t result = getClock_timeval(&time_timeval);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    *time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	timeval time_timeval;
-	ReturnValue_t result = getClock_timeval(&time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	struct tm time_tm;
+    timeval time_timeval;
+    ReturnValue_t result = getClock_timeval(&time_timeval);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    struct tm time_tm;
 
-	gmtime_r(&time_timeval.tv_sec,&time_tm);
+    gmtime_r(&time_timeval.tv_sec,&time_tm);
 
-	time->year = time_tm.tm_year + 1900;
-	time->month = time_tm.tm_mon + 1;
-	time->day = time_tm.tm_mday;
+    time->year = time_tm.tm_year + 1900;
+    time->month = time_tm.tm_mon + 1;
+    time->day = time_tm.tm_mday;
 
-	time->hour = time_tm.tm_hour;
-	time->minute = time_tm.tm_min;
-	time->second = time_tm.tm_sec;
+    time->hour = time_tm.tm_hour;
+    time->minute = time_tm.tm_min;
+    time->second = time_tm.tm_sec;
 
-	time->usecond = time_timeval.tv_usec;
+    time->usecond = time_timeval.tv_usec;
 
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-	struct tm time_tm;
+        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_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_tm.tm_hour = from->hour;
+    time_tm.tm_min = from->minute;
+    time_tm.tm_sec = from->second;
 
-		time_t seconds = mktime(&time_tm);
+    time_t seconds = mktime(&time_tm);
 
-		to->tv_sec = seconds;
-		to->tv_usec = from->usecond;
-	//Fails in 2038..
-	return HasReturnvaluesIF::RETURN_OK;
+    to->tv_sec = seconds;
+    to->tv_usec = from->usecond;
+    //Fails in 2038..
+    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;
+    *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 == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    //SHOULDDO: works not for dates in the past (might have less leap seconds)
+    if (timeMutex == nullptr) {
+        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;
+    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 };
+    //initial offset between UTC and TAI
+    timeval UTCtoTAI1972 = { 10, 0 };
 
-	timeval TAItoTT = { 32, 184000 };
+    timeval TAItoTT = { 32, 184000 };
 
-	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+    *tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
 
-	return HasReturnvaluesIF::RETURN_OK;
+    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::TimeoutType::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	leapSeconds = leapSeconds_;
+    leapSeconds = leapSeconds_;
 
-	result = timeMutex->unlockMutex();
-	return result;
+    result = timeMutex->unlockMutex();
+    return result;
 }
 
 ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if (timeMutex == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    if (timeMutex == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	*leapSeconds_ = leapSeconds;
+    *leapSeconds_ = leapSeconds;
 
-	result = timeMutex->unlockMutex();
-	return result;
+    result = timeMutex->unlockMutex();
+    return result;
 }
 
 ReturnValue_t Clock::checkOrCreateClockMutex() {
-	if (timeMutex == NULL) {
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    if (timeMutex == NULL) {
+        MutexFactory* mutexFactory = MutexFactory::instance();
+        if (mutexFactory == NULL) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        timeMutex = mutexFactory->createMutex();
+        if (timeMutex == NULL) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index aefcac2eb..8f0d1c314 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -396,12 +396,20 @@ ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
 
 ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
 		size_t* foundLength, size_t maxLength) {
-	//We don't expect ascii here. SHOULDDO
+    if(maxLength >= 19) {
+        Clock::TimeOfDay_t timeOfDay;
+        /* Try to parse it as ASCII */
+        ReturnValue_t result = convertFromASCII(&timeOfDay, from, maxLength);
+        if (result == RETURN_OK) {
+            return Clock::convertTimeOfDayToTimeval(&timeOfDay, to);
+        }
+    }
+
 	uint8_t codeIdentification = (*from >> 4);
 	switch (codeIdentification) {
-	//unsupported, as Leap second correction would have to be applied
-//	case CUC_LEVEL1:
-//		return convertFromCUC(to, from, foundLength, maxLength);
+	/* Unsupported, as Leap second correction would have to be applied */
+	case CUC_LEVEL1:
+		return UNSUPPORTED_TIME_FORMAT;
 	case CDS:
 		return convertFromCDS(to, from, foundLength, maxLength);
 	case CCS:

From bff8d103ba77837b63b91577ff30c52926d625ef Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Mar 2021 22:45:44 +0100
Subject: [PATCH 1612/1774] form stuff and cleaning up

---
 datapoollocal/LocalDataPoolManager.cpp |  8 ++++----
 datapoollocal/LocalPoolVariable.tpp    | 10 ----------
 2 files changed, 4 insertions(+), 14 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index c15182d26..72873d993 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -42,15 +42,15 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
 	if(queueToUse == nullptr) {
-		// error, all destinations invalid
-		printWarningOrError(sif::OutputTypes::OUT_ERROR,
-				"initialize", QUEUE_OR_DESTINATION_INVALID);
+		/* Error, all destinations invalid */
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
+		        QUEUE_OR_DESTINATION_INVALID);
 	}
 	hkQueue = queueToUse;
 
 	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if(ipcStore == nullptr) {
-		// error, all destinations invalid
+		/* Error, all destinations invalid */
 		printWarningOrError(sif::OutputTypes::OUT_ERROR,
 				"initialize", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not set IPC store.");
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 35de4ebdf..aa789a6dd 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -43,7 +43,6 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
     PoolEntry<T>* poolEntry = nullptr;
     ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
             &poolEntry);
-    //ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
     if(result != RETURN_OK) {
         object_id_t ownerObjectId = hkManager->getCreatorObjectId();
         reportReadCommitError("LocalPoolVariable", result,
@@ -51,15 +50,6 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
         return result;
     }
 
-    // Actually this should never happen..
-    //	if(poolEntry->address == nullptr) {
-    //		result = PoolVariableIF::INVALID_POOL_ENTRY;
-    //		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-    //		reportReadCommitError("LocalPoolVariable", result,
-    //				false, ownerObjectId, localPoolId);
-    //		return result;
-    //	}
-
     this->value = *(poolEntry->getDataPtr());
     this->valid = poolEntry->getValid();
     return RETURN_OK;

From d8d18c93335f3e850deda56aa10ace757d8e6c2a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Mar 2021 23:49:27 +0100
Subject: [PATCH 1613/1774] fixed order

---
 controller/ExtendedControllerBase.cpp  | 8 +++++---
 datapoollocal/LocalPoolDataSetBase.cpp | 3 +--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index cc93efa86..95ba012eb 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -13,7 +13,7 @@ ExtendedControllerBase::~ExtendedControllerBase() {
 
 ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
         MessageQueueId_t commandedBy, const uint8_t *data, size_t size) {
-    // needs to be overriden and implemented by child class.
+    /* Needs to be overriden and implemented by child class. */
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -21,7 +21,7 @@ ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
 
 ReturnValue_t ExtendedControllerBase::initializeLocalDataPool(
         localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
-    // needs to be overriden and implemented by child class.
+    /* Needs to be overriden and implemented by child class. */
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -96,8 +96,10 @@ ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
 
 ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
     handleQueue();
-    poolManager.performHkOperation();
     performControlOperation();
+    /* We do this after performing control operation because variables will be set changed
+    in this function. */
+    poolManager.performHkOperation();
     return RETURN_OK;
 }
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 75a3ab7c2..d043d18f5 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -42,8 +42,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     }
 }
 
-LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
-        PoolVariableIF** registeredVariablesArray,
+LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
                 PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(

From dae4a5fa7447dbd9bf49242facbd4c20509e8dc4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 16:36:34 +0100
Subject: [PATCH 1614/1774] small form stuff

---
 datapoollocal/HasLocalDataPoolIF.h   | 4 ++--
 datapoollocal/LocalPoolDataSetBase.h | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 49f2db7d3..d52c72b6c 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -162,8 +162,8 @@ protected:
      */
     virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
-                << ". Returning nullptr!" << std::endl;
+        sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden. "
+                "Returning nullptr!" << std::endl;
 #else
         sif::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
                 "Not overriden. Returning nullptr!\n");
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 8a3a63394..9501f7821 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -59,7 +59,7 @@ public:
 
     /**
      * @brief	Constructor for users of the local pool data, which need
-     *          to access data created by one (!) HK manager.
+     *          to access data created by one HK manager.
      * @details
      * Unlike the first constructor, no component for periodic handling
      * will be initiated.

From 21a7fd621d69d1058a2a55ddc6a4867021b0fb85 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 16:38:35 +0100
Subject: [PATCH 1615/1774] renamed guard class

---
 datapool/{PoolReadHelper.h => PoolReadGuard.h}    | 6 +++---
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)
 rename datapool/{PoolReadHelper.h => PoolReadGuard.h} (94%)

diff --git a/datapool/PoolReadHelper.h b/datapool/PoolReadGuard.h
similarity index 94%
rename from datapool/PoolReadHelper.h
rename to datapool/PoolReadGuard.h
index 9825e83c1..eb014f1e7 100644
--- a/datapool/PoolReadHelper.h
+++ b/datapool/PoolReadGuard.h
@@ -8,9 +8,9 @@
 /**
  * @brief 	Helper class to read data sets or pool variables
  */
-class PoolReadHelper {
+class PoolReadGuard {
 public:
-    PoolReadHelper(ReadCommitIF* readObject,
+    PoolReadGuard(ReadCommitIF* readObject,
             MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
             uint32_t mutexTimeout = 20):
                 readObject(readObject), mutexTimeout(mutexTimeout) {
@@ -42,7 +42,7 @@ public:
     /**
      * @brief   Default destructor which will take care of commiting changed values.
      */
-    ~PoolReadHelper() {
+    ~PoolReadGuard() {
         if(readObject != nullptr and not noCommit) {
             readObject->commit(timeoutType, mutexTimeout);
         }
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index bb090e3b3..5c277850f 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -192,7 +192,7 @@ public:
         resetSubscriptionList();
         ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
         {
-            PoolReadHelper readHelper(&dataset);
+            PoolReadGuard readHelper(&dataset);
             if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
                 status = readHelper.getReadResult();
             }
@@ -205,7 +205,7 @@ public:
         }
 
         {
-            PoolReadHelper readHelper(&testUint32);
+            PoolReadGuard readHelper(&testUint32);
             if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
                 status = readHelper.getReadResult();
             }
@@ -214,7 +214,7 @@ public:
         }
 
         {
-            PoolReadHelper readHelper(&testInt64Vec);
+            PoolReadGuard readHelper(&testInt64Vec);
             if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
                 status = readHelper.getReadResult();
             }

From d66e486f166f3a9d926be4f270a22caf37f6243e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 16:44:17 +0100
Subject: [PATCH 1616/1774] whitespaces instead of tabs

---
 timemanager/CCSDSTime.cpp | 954 +++++++++++++++++++-------------------
 timemanager/CCSDSTime.h   | 370 +++++++--------
 2 files changed, 662 insertions(+), 662 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 8f0d1c314..192c1f57a 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -12,390 +12,390 @@ CCSDSTime::~CCSDSTime() {
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
-		const Clock::TimeOfDay_t* from) {
-	ReturnValue_t result = checkTimeOfDay(from);
-	if (result != RETURN_OK) {
-		return result;
-	}
+        const Clock::TimeOfDay_t* from) {
+    ReturnValue_t result = checkTimeOfDay(from);
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	to->pField = (CCS << 4);
+    to->pField = (CCS << 4);
 
-	to->yearMSB = (from->year >> 8);
-	to->yearLSB = from->year & 0xff;
-	to->month = from->month;
-	to->day = from->day;
-	to->hour = from->hour;
-	to->minute = from->minute;
-	to->second = from->second;
+    to->yearMSB = (from->year >> 8);
+    to->yearLSB = from->year & 0xff;
+    to->month = from->month;
+    to->day = from->day;
+    to->hour = from->hour;
+    to->minute = from->minute;
+    to->second = from->second;
 
-	return RETURN_OK;
+    return RETURN_OK;
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
-		const Clock::TimeOfDay_t* from) {
-	ReturnValue_t result = checkTimeOfDay(from);
-	if (result != RETURN_OK) {
-		return result;
-	}
+        const Clock::TimeOfDay_t* from) {
+    ReturnValue_t result = checkTimeOfDay(from);
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	to->pField = (CCS << 4) + 2;
+    to->pField = (CCS << 4) + 2;
 
-	to->yearMSB = (from->year >> 8);
-	to->yearLSB = from->year & 0xff;
-	to->month = from->month;
-	to->day = from->day;
-	to->hour = from->hour;
-	to->minute = from->minute;
-	to->second = from->second;
-	to->secondEminus2 = from->usecond / 10000;
-	to->secondEminus4 = (from->usecond % 10000) / 100;
+    to->yearMSB = (from->year >> 8);
+    to->yearLSB = from->year & 0xff;
+    to->month = from->month;
+    to->day = from->day;
+    to->hour = from->hour;
+    to->minute = from->minute;
+    to->second = from->second;
+    to->secondEminus2 = from->usecond / 10000;
+    to->secondEminus4 = (from->usecond % 10000) / 100;
 
-	return RETURN_OK;
+    return RETURN_OK;
 }
 
 ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to,
         const uint8_t* from, size_t length) {
-	ReturnValue_t result;
-	if (length > 0xFF) {
-		return LENGTH_MISMATCH;
-	}
-	result = convertFromASCII(to, from, length); //Try to parse it as ASCII
-	if (result == RETURN_OK) {
-		return RETURN_OK;
-	}
+    ReturnValue_t result;
+    if (length > 0xFF) {
+        return LENGTH_MISMATCH;
+    }
+    result = convertFromASCII(to, from, length); //Try to parse it as ASCII
+    if (result == RETURN_OK) {
+        return RETURN_OK;
+    }
 
-	//Seems to be no ascii, try the other formats
-	uint8_t codeIdentification = (*from >> 4);
-	switch (codeIdentification) {
-	case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can... <- see bug 1133
-		return convertFromCUC(to, from, length);
-	case CDS:
-		return convertFromCDS(to, from, length);
-	case CCS: {
-		size_t temp = 0;
-		return convertFromCCS(to, from, &temp, length);
-	}
+    //Seems to be no ascii, try the other formats
+    uint8_t codeIdentification = (*from >> 4);
+    switch (codeIdentification) {
+    case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can... <- see bug 1133
+        return convertFromCUC(to, from, length);
+    case CDS:
+        return convertFromCDS(to, from, length);
+    case CCS: {
+        size_t temp = 0;
+        return convertFromCCS(to, from, &temp, length);
+    }
 
-	default:
-		return UNSUPPORTED_TIME_FORMAT;
-	}
+    default:
+        return UNSUPPORTED_TIME_FORMAT;
+    }
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to,
         const uint8_t* from, uint8_t length) {
-	return UNSUPPORTED_TIME_FORMAT;
+    return UNSUPPORTED_TIME_FORMAT;
 }
 
 ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to,
         const uint8_t* from, uint8_t length) {
-	timeval time;
-	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return convertTimevalToTimeOfDay(to, &time);
+    timeval time;
+    ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return convertTimevalToTimeOfDay(to, &time);
 }
 
 ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to,
         const uint8_t* from, size_t* foundLength, size_t maxLength) {
-	uint8_t subsecondsLength = *from & 0b111;
-	uint32_t totalLength = subsecondsLength + 8;
-	if (maxLength < totalLength) {
-		return LENGTH_MISMATCH;
-	}
+    uint8_t subsecondsLength = *from & 0b111;
+    uint32_t totalLength = subsecondsLength + 8;
+    if (maxLength < totalLength) {
+        return LENGTH_MISMATCH;
+    }
 
-	*foundLength = totalLength;
+    *foundLength = totalLength;
 
-	ReturnValue_t result = checkCcs(from, maxLength);
+    ReturnValue_t result = checkCcs(from, maxLength);
 
-	if (result != RETURN_OK) {
-		return result;
-	}
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	Ccs_mseconds *temp = (Ccs_mseconds *) from;
+    Ccs_mseconds *temp = (Ccs_mseconds *) from;
 
-	to->year = (temp->yearMSB << 8) + temp->yearLSB;
-	to->hour = temp->hour;
-	to->minute = temp->minute;
-	to->second = temp->second;
+    to->year = (temp->yearMSB << 8) + temp->yearLSB;
+    to->hour = temp->hour;
+    to->minute = temp->minute;
+    to->second = temp->second;
 
-	if (temp->pField & (1 << 3)) { //day of year variation
-		uint16_t tempDay = (temp->month << 8) + temp->day;
-		result = convertDaysOfYear(tempDay, to->year,
-				&(temp->month), &(temp->day));
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
+    if (temp->pField & (1 << 3)) { //day of year variation
+        uint16_t tempDay = (temp->month << 8) + temp->day;
+        result = convertDaysOfYear(tempDay, to->year,
+                &(temp->month), &(temp->day));
+        if (result != RETURN_OK) {
+            return result;
+        }
+    }
 
-	to->month = temp->month;
-	to->day = temp->day;
+    to->month = temp->month;
+    to->day = temp->day;
 
-	to->usecond = 0;
-	if (subsecondsLength > 0) {
-		*foundLength += 1;
-		if (temp->secondEminus2 >= 100) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->usecond = temp->secondEminus2 * 10000;
-	}
+    to->usecond = 0;
+    if (subsecondsLength > 0) {
+        *foundLength += 1;
+        if (temp->secondEminus2 >= 100) {
+            return INVALID_TIME_FORMAT;
+        }
+        to->usecond = temp->secondEminus2 * 10000;
+    }
 
-	if (subsecondsLength > 1) {
-		*foundLength += 1;
-		if (temp->secondEminus4 >= 100) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->usecond += temp->secondEminus4 * 100;
-	}
+    if (subsecondsLength > 1) {
+        *foundLength += 1;
+        if (temp->secondEminus4 >= 100) {
+            return INVALID_TIME_FORMAT;
+        }
+        to->usecond += temp->secondEminus4 * 100;
+    }
 
-	return RETURN_OK;
+    return RETURN_OK;
 
 }
 
 ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to,
         const uint8_t* from, uint8_t length) {
-	if (length < 19) {
-		return RETURN_FAILED;
-	}
-// Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
-// Suggestion: use uint16 all the time. This should work on all systems.
+    if (length < 19) {
+        return RETURN_FAILED;
+    }
+    // Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
+    // Suggestion: use uint16 all the time. This should work on all systems.
 #if FSFW_NO_C99_IO == 1
-	uint16_t year;
-	uint16_t month;
-	uint16_t day;
-	uint16_t hour;
-	uint16_t minute;
-	float second;
-	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%"
-	        "2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &month, &day, &hour,
-	        &minute, &second);
-	if (count == 6) {
-		to->year = year;
-		to->month = month;
-		to->day = day;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
+    uint16_t year;
+    uint16_t month;
+    uint16_t day;
+    uint16_t hour;
+    uint16_t minute;
+    float second;
+    int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%"
+            "2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &month, &day, &hour,
+            &minute, &second);
+    if (count == 6) {
+        to->year = year;
+        to->month = month;
+        to->day = day;
+        to->hour = hour;
+        to->minute = minute;
+        to->second = second;
+        to->usecond = (second - floor(second)) * 1000000;
+        return RETURN_OK;
+    }
 
-	// try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%"
-	        "2" SCNu16 ":%fZ", &year, &day, &hour, &minute, &second);
-	if (count == 5) {
-		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
-				reinterpret_cast<uint8_t *>(&month),
-				reinterpret_cast<uint8_t *>(&tempDay));
-		if (result != RETURN_OK) {
-			return RETURN_FAILED;
-		}
-		to->year = year;
-		to->month = month;
-		to->day = tempDay;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-// Warning: Compiler/Linker fails ambiguously if library does not implement
-// C99 I/O
+    // try Code B (yyyy-ddd)
+    count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%"
+            "2" SCNu16 ":%fZ", &year, &day, &hour, &minute, &second);
+    if (count == 5) {
+        uint8_t tempDay;
+        ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
+                reinterpret_cast<uint8_t *>(&month),
+                reinterpret_cast<uint8_t *>(&tempDay));
+        if (result != RETURN_OK) {
+            return RETURN_FAILED;
+        }
+        to->year = year;
+        to->month = month;
+        to->day = tempDay;
+        to->hour = hour;
+        to->minute = minute;
+        to->second = second;
+        to->usecond = (second - floor(second)) * 1000000;
+        return RETURN_OK;
+    }
+    // Warning: Compiler/Linker fails ambiguously if library does not implement
+    // C99 I/O
 #else
-	uint16_t year;
-	uint8_t month;
-	uint16_t day;
-	uint8_t hour;
-	uint8_t minute;
-	float second;
+    uint16_t year;
+    uint8_t month;
+    uint16_t day;
+    uint8_t hour;
+    uint8_t minute;
+    float second;
     //try Code A (yyyy-mm-dd)
     int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16
             "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year, &month, &day,
             &hour, &minute, &second);
-	if (count == 6) {
-		to->year = year;
-		to->month = month;
-		to->day = day;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
+    if (count == 6) {
+        to->year = year;
+        to->month = month;
+        to->day = day;
+        to->hour = hour;
+        to->minute = minute;
+        to->second = second;
+        to->usecond = (second - floor(second)) * 1000000;
+        return RETURN_OK;
+    }
 
     //try Code B (yyyy-ddd)
     count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu8
             ":%2" SCNu8 ":%fZ", &year, &day, &hour, &minute, &second);
-	if (count == 5) {
-		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
-				&tempDay);
-		if (result != RETURN_OK) {
-			return RETURN_FAILED;
-		}
-		to->year = year;
-		to->month = month;
-		to->day = tempDay;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
+    if (count == 5) {
+        uint8_t tempDay;
+        ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
+                &tempDay);
+        if (result != RETURN_OK) {
+            return RETURN_FAILED;
+        }
+        to->year = year;
+        to->month = month;
+        to->day = tempDay;
+        to->hour = hour;
+        to->minute = minute;
+        to->second = second;
+        to->usecond = (second - floor(second)) * 1000000;
+        return RETURN_OK;
+    }
 #endif
 
-	return UNSUPPORTED_TIME_FORMAT;
+    return UNSUPPORTED_TIME_FORMAT;
 }
 
 ReturnValue_t CCSDSTime::checkCcs(const uint8_t* time, uint8_t length) {
-	Ccs_mseconds *time_struct = (Ccs_mseconds *) time;
+    Ccs_mseconds *time_struct = (Ccs_mseconds *) time;
 
-	uint8_t additionalBytes = time_struct->pField & 0b111;
-	if ((additionalBytes == 0b111) || (length < (additionalBytes + 8))) {
-		return INVALID_TIME_FORMAT;
-	}
+    uint8_t additionalBytes = time_struct->pField & 0b111;
+    if ((additionalBytes == 0b111) || (length < (additionalBytes + 8))) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	if (time_struct->pField & (1 << 3)) { //day of year variation
-		uint16_t day = (time_struct->month << 8) + time_struct->day;
-		if (day > 366) {
-			return INVALID_TIME_FORMAT;
-		}
-	} else {
-		if (time_struct->month > 12) {
-			return INVALID_TIME_FORMAT;
-		}
-		if (time_struct->day > 31) {
-			return INVALID_TIME_FORMAT;
-		}
-	}
-	if (time_struct->hour > 23) {
-		return INVALID_TIME_FORMAT;
-	}
-	if (time_struct->minute > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-	if (time_struct->second > 59) {
-		return INVALID_TIME_FORMAT;
-	}
+    if (time_struct->pField & (1 << 3)) { //day of year variation
+        uint16_t day = (time_struct->month << 8) + time_struct->day;
+        if (day > 366) {
+            return INVALID_TIME_FORMAT;
+        }
+    } else {
+        if (time_struct->month > 12) {
+            return INVALID_TIME_FORMAT;
+        }
+        if (time_struct->day > 31) {
+            return INVALID_TIME_FORMAT;
+        }
+    }
+    if (time_struct->hour > 23) {
+        return INVALID_TIME_FORMAT;
+    }
+    if (time_struct->minute > 59) {
+        return INVALID_TIME_FORMAT;
+    }
+    if (time_struct->second > 59) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	uint8_t *additionalByte = &time_struct->secondEminus2;
+    uint8_t *additionalByte = &time_struct->secondEminus2;
 
-	for (; additionalBytes != 0; additionalBytes--) {
-		if (*additionalByte++ > 99) {
-			return INVALID_TIME_FORMAT;
-		}
-	}
-	return RETURN_OK;
+    for (; additionalBytes != 0; additionalBytes--) {
+        if (*additionalByte++ > 99) {
+            return INVALID_TIME_FORMAT;
+        }
+    }
+    return RETURN_OK;
 }
 
 ReturnValue_t CCSDSTime::convertDaysOfYear(uint16_t dayofYear, uint16_t year,
-		uint8_t* month, uint8_t* day) {
-	if (isLeapYear(year)) {
-		if (dayofYear > 366) {
-			return INVALID_DAY_OF_YEAR;
-		}
-	} else {
-		if (dayofYear > 365) {
-			return INVALID_DAY_OF_YEAR;
-		}
-	}
-	*month = 1;
-	if (dayofYear <= 31) {
-		*day = dayofYear;
-		return RETURN_OK;
-	}
-	*month += 1;
-	dayofYear -= 31;
-	if (isLeapYear(year)) {
-		if (dayofYear <= 29) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 29;
-	} else {
-		if (dayofYear <= 28) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 28;
-	}
-	while (*month <= 12) {
-		if (dayofYear <= 31) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 31;
+        uint8_t* month, uint8_t* day) {
+    if (isLeapYear(year)) {
+        if (dayofYear > 366) {
+            return INVALID_DAY_OF_YEAR;
+        }
+    } else {
+        if (dayofYear > 365) {
+            return INVALID_DAY_OF_YEAR;
+        }
+    }
+    *month = 1;
+    if (dayofYear <= 31) {
+        *day = dayofYear;
+        return RETURN_OK;
+    }
+    *month += 1;
+    dayofYear -= 31;
+    if (isLeapYear(year)) {
+        if (dayofYear <= 29) {
+            *day = dayofYear;
+            return RETURN_OK;
+        }
+        *month += 1;
+        dayofYear -= 29;
+    } else {
+        if (dayofYear <= 28) {
+            *day = dayofYear;
+            return RETURN_OK;
+        }
+        *month += 1;
+        dayofYear -= 28;
+    }
+    while (*month <= 12) {
+        if (dayofYear <= 31) {
+            *day = dayofYear;
+            return RETURN_OK;
+        }
+        *month += 1;
+        dayofYear -= 31;
 
-		if (*month == 8) {
-			continue;
-		}
+        if (*month == 8) {
+            continue;
+        }
 
-		if (dayofYear <= 30) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 30;
-	}
-	return INVALID_DAY_OF_YEAR;
+        if (dayofYear <= 30) {
+            *day = dayofYear;
+            return RETURN_OK;
+        }
+        *month += 1;
+        dayofYear -= 30;
+    }
+    return INVALID_DAY_OF_YEAR;
 }
 
 bool CCSDSTime::isLeapYear(uint32_t year) {
-	if ((year % 400) == 0) {
-		return true;
-	}
-	if ((year % 100) == 0) {
-		return false;
-	}
-	if ((year % 4) == 0) {
-		return true;
-	}
-	return false;
+    if ((year % 400) == 0) {
+        return true;
+    }
+    if ((year % 100) == 0) {
+        return false;
+    }
+    if ((year % 4) == 0) {
+        return true;
+    }
+    return false;
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(CDS_short* to, const timeval* from) {
-	to->pField = (CDS << 4) + 0;
-	uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
-			+ DAYS_CCSDS_TO_UNIX_EPOCH;
-	if (days > (1 << 16)) {
-		//Date is beyond year 2137
-		return TIME_DOES_NOT_FIT_FORMAT;
-	}
-	to->dayMSB = (days & 0xFF00) >> 8;
-	to->dayLSB = (days & 0xFF);
-	uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
-			+ (from->tv_usec / 1000);
-	to->msDay_hh = (msDay & 0xFF000000) >> 24;
-	to->msDay_h = (msDay & 0xFF0000) >> 16;
-	to->msDay_l = (msDay & 0xFF00) >> 8;
-	to->msDay_ll = (msDay & 0xFF);
-	return RETURN_OK;
+    to->pField = (CDS << 4) + 0;
+    uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
+			        + DAYS_CCSDS_TO_UNIX_EPOCH;
+    if (days > (1 << 16)) {
+        //Date is beyond year 2137
+        return TIME_DOES_NOT_FIT_FORMAT;
+    }
+    to->dayMSB = (days & 0xFF00) >> 8;
+    to->dayLSB = (days & 0xFF);
+    uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
+			        + (from->tv_usec / 1000);
+    to->msDay_hh = (msDay & 0xFF000000) >> 24;
+    to->msDay_h = (msDay & 0xFF0000) >> 16;
+    to->msDay_l = (msDay & 0xFF00) >> 8;
+    to->msDay_ll = (msDay & 0xFF);
+    return RETURN_OK;
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
-	to->pFiled = (AGENCY_DEFINED << 4) + 5;
-	to->seconds_hh = (from->tv_sec >> 24) & 0xff;
-	to->seconds_h = (from->tv_sec >> 16) & 0xff;
-	to->seconds_l = (from->tv_sec >> 8) & 0xff;
-	to->seconds_ll = (from->tv_sec >> 0) & 0xff;
+    to->pFiled = (AGENCY_DEFINED << 4) + 5;
+    to->seconds_hh = (from->tv_sec >> 24) & 0xff;
+    to->seconds_h = (from->tv_sec >> 16) & 0xff;
+    to->seconds_l = (from->tv_sec >> 8) & 0xff;
+    to->seconds_ll = (from->tv_sec >> 0) & 0xff;
 
-	//convert the µs to 2E-16 seconds
-	uint64_t temp = from->tv_usec;
-	temp = temp << 16;
-	temp = temp / 1E6;
+    //convert the µs to 2E-16 seconds
+    uint64_t temp = from->tv_usec;
+    temp = temp << 16;
+    temp = temp / 1E6;
 
-	to->subsecondsMSB = (temp >> 8) & 0xff;
-	to->subsecondsLSB = temp & 0xff;
+    to->subsecondsMSB = (temp >> 8) & 0xff;
+    to->subsecondsLSB = temp & 0xff;
 
-	return RETURN_OK;
+    return RETURN_OK;
 }
 
 ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
-		size_t* foundLength, size_t maxLength) {
+        size_t* foundLength, size_t maxLength) {
     if(maxLength >= 19) {
         Clock::TimeOfDay_t timeOfDay;
         /* Try to parse it as ASCII */
@@ -405,210 +405,210 @@ ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
         }
     }
 
-	uint8_t codeIdentification = (*from >> 4);
-	switch (codeIdentification) {
-	/* Unsupported, as Leap second correction would have to be applied */
-	case CUC_LEVEL1:
-		return UNSUPPORTED_TIME_FORMAT;
-	case CDS:
-		return convertFromCDS(to, from, foundLength, maxLength);
-	case CCS:
-		return convertFromCCS(to, from, foundLength, maxLength);
-	default:
-		return UNSUPPORTED_TIME_FORMAT;
-	}
+    uint8_t codeIdentification = (*from >> 4);
+    switch (codeIdentification) {
+    /* Unsupported, as Leap second correction would have to be applied */
+    case CUC_LEVEL1:
+        return UNSUPPORTED_TIME_FORMAT;
+    case CDS:
+        return convertFromCDS(to, from, foundLength, maxLength);
+    case CCS:
+        return convertFromCCS(to, from, foundLength, maxLength);
+    default:
+        return UNSUPPORTED_TIME_FORMAT;
+    }
 
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
-		size_t* foundLength, size_t maxLength) {
-	if (maxLength < 1) {
-		return INVALID_TIME_FORMAT;
-	}
-	uint8_t pField = *from;
-	from++;
-	ReturnValue_t result = convertFromCUC(to, pField, from, foundLength,
-			maxLength - 1);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		if (foundLength != NULL) {
-			*foundLength += 1;
-		}
-	}
-	return result;
+        size_t* foundLength, size_t maxLength) {
+    if (maxLength < 1) {
+        return INVALID_TIME_FORMAT;
+    }
+    uint8_t pField = *from;
+    from++;
+    ReturnValue_t result = convertFromCUC(to, pField, from, foundLength,
+            maxLength - 1);
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        if (foundLength != NULL) {
+            *foundLength += 1;
+        }
+    }
+    return result;
 }
 
 ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
-	if ((time->month > 12) || (time->month == 0)) {
-		return INVALID_TIME_FORMAT;
-	}
+    if ((time->month > 12) || (time->month == 0)) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	if (time->day == 0) {
-		return INVALID_TIME_FORMAT;
-	}
-	switch (time->month) {
-	case 2:
-		if (isLeapYear(time->year)) {
-			if (time->day > 29) {
-				return INVALID_TIME_FORMAT;
-			}
-		} else {
-			if (time->day > 28) {
-				return INVALID_TIME_FORMAT;
-			}
-		}
-		break;
-	case 4:
-	case 6:
-	case 9:
-	case 11:
-		if (time->day > 30) {
-			return INVALID_TIME_FORMAT;
-		}
-		break;
-	default:
-		if (time->day > 31) {
-			return INVALID_TIME_FORMAT;
-		}
-		break;
-	}
+    if (time->day == 0) {
+        return INVALID_TIME_FORMAT;
+    }
+    switch (time->month) {
+    case 2:
+        if (isLeapYear(time->year)) {
+            if (time->day > 29) {
+                return INVALID_TIME_FORMAT;
+            }
+        } else {
+            if (time->day > 28) {
+                return INVALID_TIME_FORMAT;
+            }
+        }
+        break;
+    case 4:
+    case 6:
+    case 9:
+    case 11:
+        if (time->day > 30) {
+            return INVALID_TIME_FORMAT;
+        }
+        break;
+    default:
+        if (time->day > 31) {
+            return INVALID_TIME_FORMAT;
+        }
+        break;
+    }
 
-	if (time->hour > 23) {
-		return INVALID_TIME_FORMAT;
-	}
+    if (time->hour > 23) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	if (time->minute > 59) {
-		return INVALID_TIME_FORMAT;
-	}
+    if (time->minute > 59) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	if (time->second > 59) {
-		return INVALID_TIME_FORMAT;
-	}
+    if (time->second > 59) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	if (time->usecond > 999999) {
-		return INVALID_TIME_FORMAT;
-	}
+    if (time->usecond > 999999) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	return RETURN_OK;
+    return RETURN_OK;
 
 }
 
 ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
-		timeval* from) {
-//This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
-	return UNSUPPORTED_TIME_FORMAT;
+        timeval* from) {
+    //This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
+    return UNSUPPORTED_TIME_FORMAT;
 }
 
 ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
-		size_t* foundLength, size_t maxLength) {
-	uint8_t pField = *from;
-	from++;
-//Check epoch
-	if (pField & 0b1000) {
-		return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
-	}
-//Check length
-	uint8_t expectedLength = 7; //Including p-Field.
-	bool extendedDays = pField & 0b100;
-	if (extendedDays) {
-		expectedLength += 1;
-	}
-	if ((pField & 0b11) == 0b01) {
-		expectedLength += 2;
-	} else if ((pField & 0b11) == 0b10) {
-		expectedLength += 4;
-	}
-	if (foundLength != NULL) {
-		*foundLength = expectedLength;
-	}
-	if (expectedLength > maxLength) {
-		return LENGTH_MISMATCH;
-	}
-//Check and count days
-	uint32_t days = 0;
-	if (extendedDays) {
-		days = (from[0] << 16) + (from[1] << 8) + from[2];
-		from += 3;
-	} else {
-		days = (from[0] << 8) + from[1];
-		from += 2;
-	}
-//Move to POSIX epoch.
-	if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
-		return INVALID_TIME_FORMAT;
-	}
-	days -= DAYS_CCSDS_TO_UNIX_EPOCH;
-	to->tv_sec = days * SECONDS_PER_DAY;
-	uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
-			+ from[3];
-	from += 4;
-	to->tv_sec += (msDay / 1000);
-	to->tv_usec = (msDay % 1000) * 1000;
-	if ((pField & 0b11) == 0b01) {
-		uint16_t usecs = (from[0] << 16) + from[1];
-		from += 2;
-		if (usecs > 999) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->tv_usec += usecs;
-	} else if ((pField & 0b11) == 0b10) {
-		uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
-				+ from[3];
-		from += 4;
-		if (picosecs > 999999) {
-			return INVALID_TIME_FORMAT;
-		}
-		//Not very useful.
-		to->tv_usec += (picosecs / 1000);
-	}
-	return RETURN_OK;
+        size_t* foundLength, size_t maxLength) {
+    uint8_t pField = *from;
+    from++;
+    //Check epoch
+    if (pField & 0b1000) {
+        return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
+    }
+    //Check length
+    uint8_t expectedLength = 7; //Including p-Field.
+    bool extendedDays = pField & 0b100;
+    if (extendedDays) {
+        expectedLength += 1;
+    }
+    if ((pField & 0b11) == 0b01) {
+        expectedLength += 2;
+    } else if ((pField & 0b11) == 0b10) {
+        expectedLength += 4;
+    }
+    if (foundLength != NULL) {
+        *foundLength = expectedLength;
+    }
+    if (expectedLength > maxLength) {
+        return LENGTH_MISMATCH;
+    }
+    //Check and count days
+    uint32_t days = 0;
+    if (extendedDays) {
+        days = (from[0] << 16) + (from[1] << 8) + from[2];
+        from += 3;
+    } else {
+        days = (from[0] << 8) + from[1];
+        from += 2;
+    }
+    //Move to POSIX epoch.
+    if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
+        return INVALID_TIME_FORMAT;
+    }
+    days -= DAYS_CCSDS_TO_UNIX_EPOCH;
+    to->tv_sec = days * SECONDS_PER_DAY;
+    uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
+			        + from[3];
+    from += 4;
+    to->tv_sec += (msDay / 1000);
+    to->tv_usec = (msDay % 1000) * 1000;
+    if ((pField & 0b11) == 0b01) {
+        uint16_t usecs = (from[0] << 16) + from[1];
+        from += 2;
+        if (usecs > 999) {
+            return INVALID_TIME_FORMAT;
+        }
+        to->tv_usec += usecs;
+    } else if ((pField & 0b11) == 0b10) {
+        uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
+				        + from[3];
+        from += 4;
+        if (picosecs > 999999) {
+            return INVALID_TIME_FORMAT;
+        }
+        //Not very useful.
+        to->tv_usec += (picosecs / 1000);
+    }
+    return RETURN_OK;
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
-		const uint8_t* from, size_t* foundLength, size_t maxLength) {
-	uint32_t secs = 0;
-	uint32_t subSeconds = 0;
-	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
-	uint8_t nFine = (pField & 0b11);
-	size_t totalLength = nCoarse + nFine;
-	if (foundLength != NULL) {
-		*foundLength = totalLength;
-	}
-	if (totalLength > maxLength) {
-		return LENGTH_MISMATCH;
-	}
-	for (int count = 0; count < nCoarse; count++) {
-		secs += *from << ((nCoarse * 8 - 8) * (1 + count));
-		from++;
-	}
-	for (int count = 0; count < nFine; count++) {
-		subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
-		from++;
-	}
-	//Move to POSIX epoch.
-	to->tv_sec = secs;
-	if (pField & 0b10000) {
-		//CCSDS-Epoch
-		to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
-	}
-	to->tv_usec = subsecondsToMicroseconds(subSeconds);
-	return RETURN_OK;
+        const uint8_t* from, size_t* foundLength, size_t maxLength) {
+    uint32_t secs = 0;
+    uint32_t subSeconds = 0;
+    uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
+    uint8_t nFine = (pField & 0b11);
+    size_t totalLength = nCoarse + nFine;
+    if (foundLength != NULL) {
+        *foundLength = totalLength;
+    }
+    if (totalLength > maxLength) {
+        return LENGTH_MISMATCH;
+    }
+    for (int count = 0; count < nCoarse; count++) {
+        secs += *from << ((nCoarse * 8 - 8) * (1 + count));
+        from++;
+    }
+    for (int count = 0; count < nFine; count++) {
+        subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
+        from++;
+    }
+    //Move to POSIX epoch.
+    to->tv_sec = secs;
+    if (pField & 0b10000) {
+        //CCSDS-Epoch
+        to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
+    }
+    to->tv_usec = subsecondsToMicroseconds(subSeconds);
+    return RETURN_OK;
 }
 
 uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
-	uint64_t temp = (uint64_t) subseconds * 1000000
-			/ (1 << (sizeof(subseconds) * 8));
-	return temp;
+    uint64_t temp = (uint64_t) subseconds * 1000000
+            / (1 << (sizeof(subseconds) * 8));
+    return temp;
 }
 
 ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
-		size_t* foundLength, size_t maxLength) {
-	Clock::TimeOfDay_t tempTime;
-	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
-			maxLength);
-	if (result != RETURN_OK) {
-		return result;
-	}
+        size_t* foundLength, size_t maxLength) {
+    Clock::TimeOfDay_t tempTime;
+    ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
+            maxLength);
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	return Clock::convertTimeOfDayToTimeval(&tempTime, to);
+    return Clock::convertTimeOfDayToTimeval(&tempTime, to);
 
 }
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index d74adc61d..de151852a 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -21,215 +21,215 @@ bool operator==(const timeval& lhs, const timeval& rhs);
  */
 class CCSDSTime: public HasReturnvaluesIF {
 public:
-	/**
-	 * The Time code identifications, bits 4-6 in the P-Field
-	 */
-	enum TimeCodeIdentification {
-		CCS = 0b101,
-		CUC_LEVEL1 = 0b001,
-		CUC_LEVEL2 = 0b010,
-		CDS = 0b100,
-		AGENCY_DEFINED = 0b110
-	};
-	static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
-			+ 2;
-	static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
-			+ 2;
-	static const uint8_t P_FIELD_CDS_SHORT = (CDS << 4);
-	/**
-	 * Struct for CDS day-segmented format.
-	 */
-	struct CDS_short {
-		uint8_t pField;
-		uint8_t dayMSB;
-		uint8_t dayLSB;
-		uint8_t msDay_hh;
-		uint8_t msDay_h;
-		uint8_t msDay_l;
-		uint8_t msDay_ll;
-	};
-	/**
-	 * Struct for the CCS fromat in day of month variation with max resolution
-	 */
-	struct Ccs_seconds {
-		uint8_t pField;
-		uint8_t yearMSB;
-		uint8_t yearLSB;
-		uint8_t month;
-		uint8_t day;
-		uint8_t hour;
-		uint8_t minute;
-		uint8_t second;
-	};
+    /**
+     * The Time code identifications, bits 4-6 in the P-Field
+     */
+    enum TimeCodeIdentification {
+        CCS = 0b101,
+        CUC_LEVEL1 = 0b001,
+        CUC_LEVEL2 = 0b010,
+        CDS = 0b100,
+        AGENCY_DEFINED = 0b110
+    };
+    static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
+			        + 2;
+    static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
+			        + 2;
+    static const uint8_t P_FIELD_CDS_SHORT = (CDS << 4);
+    /**
+     * Struct for CDS day-segmented format.
+     */
+    struct CDS_short {
+        uint8_t pField;
+        uint8_t dayMSB;
+        uint8_t dayLSB;
+        uint8_t msDay_hh;
+        uint8_t msDay_h;
+        uint8_t msDay_l;
+        uint8_t msDay_ll;
+    };
+    /**
+     * Struct for the CCS fromat in day of month variation with max resolution
+     */
+    struct Ccs_seconds {
+        uint8_t pField;
+        uint8_t yearMSB;
+        uint8_t yearLSB;
+        uint8_t month;
+        uint8_t day;
+        uint8_t hour;
+        uint8_t minute;
+        uint8_t second;
+    };
 
-	/**
-	 * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
-	 */
-	struct Ccs_mseconds {
-		uint8_t pField;
-		uint8_t yearMSB;
-		uint8_t yearLSB;
-		uint8_t month;
-		uint8_t day;
-		uint8_t hour;
-		uint8_t minute;
-		uint8_t second;
-		uint8_t secondEminus2;
-		uint8_t secondEminus4;
-	};
+    /**
+     * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
+     */
+    struct Ccs_mseconds {
+        uint8_t pField;
+        uint8_t yearMSB;
+        uint8_t yearLSB;
+        uint8_t month;
+        uint8_t day;
+        uint8_t hour;
+        uint8_t minute;
+        uint8_t second;
+        uint8_t secondEminus2;
+        uint8_t secondEminus4;
+    };
 
-	struct OBT_FLP {
-		uint8_t pFiled;
-		uint8_t seconds_hh;
-		uint8_t seconds_h;
-		uint8_t seconds_l;
-		uint8_t seconds_ll;
-		uint8_t subsecondsMSB;
-		uint8_t subsecondsLSB;
-	};
+    struct OBT_FLP {
+        uint8_t pFiled;
+        uint8_t seconds_hh;
+        uint8_t seconds_h;
+        uint8_t seconds_l;
+        uint8_t seconds_ll;
+        uint8_t subsecondsMSB;
+        uint8_t subsecondsLSB;
+    };
 
-	struct TimevalLess {
-		bool operator()(const timeval& lhs, const timeval& rhs) const {
-			return (lhs < rhs);
-		}
-	};
+    struct TimevalLess {
+        bool operator()(const timeval& lhs, const timeval& rhs) const {
+            return (lhs < rhs);
+        }
+    };
 
-	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_TIME_HELPER_CLASS;
-	static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
-			MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
+    static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_TIME_HELPER_CLASS;
+    static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
+    static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
+            MAKE_RETURN_CODE(1);
+    static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
+    static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
+    static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
+    static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
 
-	/**
-	 * convert a TimeofDay struct to ccs with seconds resolution
-	 *
-	 * @param to pointer to a CCS struct
-	 * @param from pointer to a TimeOfDay Struct
-	 * @return
-	 * 		- @c RETURN_OK if OK
-	 * 		- @c INVALID_TIMECODE if not OK
-	 */
-	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
-			Clock::TimeOfDay_t const *from);
+    /**
+     * convert a TimeofDay struct to ccs with seconds resolution
+     *
+     * @param to pointer to a CCS struct
+     * @param from pointer to a TimeOfDay Struct
+     * @return
+     * 		- @c RETURN_OK if OK
+     * 		- @c INVALID_TIMECODE if not OK
+     */
+    static ReturnValue_t convertToCcsds(Ccs_seconds *to,
+            Clock::TimeOfDay_t const *from);
 
-	/**
-	 * Converts to CDS format from timeval.
-	 * @param to pointer to the CDS struct to generate
-	 * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
-	 * @return
-	 * 		- @c RETURN_OK as it assumes a valid timeval.
-	 */
-	static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
+    /**
+     * Converts to CDS format from timeval.
+     * @param to pointer to the CDS struct to generate
+     * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
+     * @return
+     * 		- @c RETURN_OK as it assumes a valid timeval.
+     */
+    static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
 
-	static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
+    static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
 
-	/**
-	 * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
-	 *
-	 * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
-	 *
-	 * @param to pointer to a CCS struct
-	 * @param from pointer to a TimeOfDay Struct
-	 * @return
-	 * 		- @c RETURN_OK if OK
-	 * 		- @c INVALID_TIMECODE if not OK
-	 */
-	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
-			Clock::TimeOfDay_t const *from);
+    /**
+     * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
+     *
+     * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
+     *
+     * @param to pointer to a CCS struct
+     * @param from pointer to a TimeOfDay Struct
+     * @return
+     * 		- @c RETURN_OK if OK
+     * 		- @c INVALID_TIMECODE if not OK
+     */
+    static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
+            Clock::TimeOfDay_t const *from);
 
-	/**
-	 * SHOULDDO: can this be modified to recognize padding?
-	 * Tries to interpret a Level 1 CCSDS time code
-	 *
-	 * It assumes binary formats contain a valid P Field and recognizes the ASCII format
-	 * by the lack of one.
-	 *
-	 * @param to an empty TimeOfDay struct
-	 * @param from pointer to an CCSDS Time code
-	 * @param length length of the Time code
-	 * @return
-	 * 		- @c RETURN_OK if successful
-	 * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
-	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
-	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
-	 */
-	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, size_t length);
+    /**
+     * SHOULDDO: can this be modified to recognize padding?
+     * Tries to interpret a Level 1 CCSDS time code
+     *
+     * It assumes binary formats contain a valid P Field and recognizes the ASCII format
+     * by the lack of one.
+     *
+     * @param to an empty TimeOfDay struct
+     * @param from pointer to an CCSDS Time code
+     * @param length length of the Time code
+     * @return
+     * 		- @c RETURN_OK if successful
+     * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
+     * 		- @c LENGTH_MISMATCH if the length does not match the P Field
+     * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
+     */
+    static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to,
+            uint8_t const *from, size_t length);
 
-	/**
-	 * not implemented yet
-	 *
-	 * @param to
-	 * @param from
-	 * @return
-	 */
-	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
-			size_t* foundLength, size_t maxLength);
+    /**
+     * not implemented yet
+     *
+     * @param to
+     * @param from
+     * @return
+     */
+    static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
+            size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, uint8_t length);
+    static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to,
+            uint8_t const *from, uint8_t length);
 
-	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
-			size_t* foundLength, size_t maxLength);
+    static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
+            size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
-			uint8_t const *from, size_t* foundLength, size_t maxLength);
+    static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
+            uint8_t const *from, size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
-			size_t* foundLength, size_t maxLength);
+    static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
+            size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
-			uint8_t const *from, size_t* foundLength, size_t maxLength);
+    static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
+            uint8_t const *from, size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, uint8_t length);
+    static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to,
+            uint8_t const *from, uint8_t length);
 
-	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
-			size_t* foundLength, size_t maxLength);
+    static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
+            size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, size_t* foundLength, size_t maxLength);
+    static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to,
+            uint8_t const *from, size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, uint8_t length);
+    static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to,
+            uint8_t const *from, uint8_t length);
 
-	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
+    static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
 private:
-	CCSDSTime();
-	virtual ~CCSDSTime();
-	/**
-	 * checks a ccs time stream for validity
-	 *
-	 * Stream may be longer than the actual timecode
-	 *
-	 * @param time pointer to an Ccs stream
-	 * @param length length of stream
-	 * @return
-	 */
-	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
+    CCSDSTime();
+    virtual ~CCSDSTime();
+    /**
+     * checks a ccs time stream for validity
+     *
+     * Stream may be longer than the actual timecode
+     *
+     * @param time pointer to an Ccs stream
+     * @param length length of stream
+     * @return
+     */
+    static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
 
-	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
+    static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
 
-	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
-	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
-	static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
-	static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
-			* SECONDS_PER_DAY;
-	/**
-	 * @param dayofYear
-	 * @param year
-	 * @param month
-	 * @param day
-	 */
-	static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
-			uint8_t *month, uint8_t *day);
+    static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
+    static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
+    static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
+    static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
+            * SECONDS_PER_DAY;
+    /**
+     * @param dayofYear
+     * @param year
+     * @param month
+     * @param day
+     */
+    static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
+            uint8_t *month, uint8_t *day);
 
-	static bool isLeapYear(uint32_t year);
-	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
-			timeval* from);
+    static bool isLeapYear(uint32_t year);
+    static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+            timeval* from);
 };
 
 #endif /* FSFW_TIMEMANAGER_CCSDSTIME_H_ */

From 4250c7e022ede038d756d4a88e7b206377d93d3d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 16:45:35 +0100
Subject: [PATCH 1617/1774] updated changelog

---
 CHANGELOG | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG b/CHANGELOG
index fc46ee021..bd41de5a1 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -82,6 +82,10 @@ now
   For mission code, developers need to replace sif:: calls by the printf counterparts, but only if the CPP stream are excluded. 
   If this is not the case, everything should work as usual.
 
+### ActionHelper
+
+- ActionHelper finish function now expects explicit information whether to report a success or failure message instead of deriving it implicitely from returnvalue
+
 ### PUS Parameter Service 20
 
-Added PUS parameter service 20 (only custom subservices available).
\ No newline at end of file
+Added PUS parameter service 20 (only custom subservices available).

From bd903b844776f80718ad74d6132c74046aae7607 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 16:46:39 +0100
Subject: [PATCH 1618/1774] changelog update

---
 CHANGELOG | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG b/CHANGELOG
index bd41de5a1..235ed7d37 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -22,7 +22,9 @@ a C file without issues
 
 ### Local Pool
 
-- Interface of LocalPools has changed. LocalPool is not a template anymore. Instead the size and bucket number of the pools per page and the number of pages are passed to the ctor instead of two ctor arguments and a template parameter
+- Interface of LocalPools has changed. LocalPool is not a template anymore. Instead the size and 
+bucket number of the pools per page and the number of pages are passed to the ctor instead of 
+two ctor arguments and a template parameter
 
 ### Parameter Service
 
@@ -40,7 +42,8 @@ important use-case)
    
 ### File System Interface
 
-- A new interfaces specifies the functions for a software object which exposes the file system of a given hardware to use message based file handling (e.g. PUS commanding)
+- A new interfaces specifies the functions for a software object which exposes the file system of 
+a given hardware to use message based file handling (e.g. PUS commanding)
 
 ### Internal Error Reporter
 
@@ -52,7 +55,8 @@ ID for now.
 ### Device Handler Base
 
 - There is an additional `PERFORM_OPERATION` step for the device handler base. It is important
-that DHB users adapt their polling sequence tables to perform this step. This steps allows for aclear distinction between operation and communication steps
+that DHB users adapt their polling sequence tables to perform this step. This steps allows for 
+a clear distinction between operation and communication steps
 - setNormalDatapoolEntriesInvalid is not an abstract method and a default implementation was provided
 - getTransitionDelayMs is now an abstract method
 
@@ -69,7 +73,8 @@ now
 
 ### Commanding Service Base
 
-- CSB uses the new fsfwconfig::FSFW_CSB_FIFO_DEPTH variable to determine  the FIFO depth for each CSB instance. This variable has to be set in the FSFWConfig.h file
+- CSB uses the new fsfwconfig::FSFW_CSB_FIFO_DEPTH variable to determine  the FIFO depth for each 
+CSB instance. This variable has to be set in the FSFWConfig.h file
 
 ### Service Interface
 
@@ -82,9 +87,11 @@ now
   For mission code, developers need to replace sif:: calls by the printf counterparts, but only if the CPP stream are excluded. 
   If this is not the case, everything should work as usual.
 
-### ActionHelper
+### ActionHelper and ActionMessage
 
-- ActionHelper finish function now expects explicit information whether to report a success or failure message instead of deriving it implicitely from returnvalue
+- ActionHelper finish function and ActionMessage::setCompletionReply now expects explicit 
+information whether to report a success or failure message instead of deriving it implicitely 
+from returnvalue
 
 ### PUS Parameter Service 20
 

From 043d47e5e43348a79fc50a7550ddcc0caeab2dba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 16:48:21 +0100
Subject: [PATCH 1619/1774] removing whitespaces

---
 CHANGELOG | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG b/CHANGELOG
index 235ed7d37..add8e1a5b 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -22,8 +22,8 @@ a C file without issues
 
 ### Local Pool
 
-- Interface of LocalPools has changed. LocalPool is not a template anymore. Instead the size and 
-bucket number of the pools per page and the number of pages are passed to the ctor instead of 
+- Interface of LocalPools has changed. LocalPool is not a template anymore. Instead the size and
+bucket number of the pools per page and the number of pages are passed to the ctor instead of
 two ctor arguments and a template parameter
 
 ### Parameter Service
@@ -42,7 +42,7 @@ important use-case)
    
 ### File System Interface
 
-- A new interfaces specifies the functions for a software object which exposes the file system of 
+- A new interfaces specifies the functions for a software object which exposes the file system of
 a given hardware to use message based file handling (e.g. PUS commanding)
 
 ### Internal Error Reporter

From 35825a6561379506e092a02266efe833743fc862 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 17:27:03 +0100
Subject: [PATCH 1620/1774] new functions to set all vars read only

---
 datapool/PoolVariableIF.h              |  3 ++-
 datapoollocal/LocalPoolDataSetBase.cpp |  7 ++++++-
 datapoollocal/LocalPoolDataSetBase.h   |  6 ++++++
 doc/README-localpools.md               | 26 ++++++++++++++++++++++++++
 4 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index dead6844a..dbb9db15c 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -46,6 +46,8 @@ public:
      * 			read-write or read-only.
      */
     virtual ReadWriteMode_t getReadWriteMode() const = 0;
+    virtual void setReadWriteMode(ReadWriteMode_t newMode) = 0;
+
     /**
      * @brief	This operation shall return the data pool id of the variable.
      */
@@ -59,7 +61,6 @@ public:
      * @brief	With this call, the valid information of the variable is set.
      */
     virtual void setValid(bool validity) = 0;
-
 };
 
 using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index d043d18f5..daa54fb33 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -288,7 +288,7 @@ bool LocalPoolDataSetBase::isValid() const {
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     if(setEntriesRecursively) {
         for(size_t idx = 0; idx < this->getFillCount(); idx++) {
-            registeredVariables[idx] -> setValid(valid);
+            registeredVariables[idx]->setValid(valid);
         }
     }
     this->valid = valid;
@@ -301,3 +301,8 @@ object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
     return objects::NO_OBJECT;
 }
 
+void LocalPoolDataSetBase::setAllVariablesReadOnly() {
+    for(size_t idx = 0; idx < this->getFillCount(); idx++) {
+        registeredVariables[idx]->setReadWriteMode(pool_rwm_t::VAR_READ);
+    }
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 9501f7821..404509ae5 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -109,6 +109,12 @@ public:
     LocalPoolDataSetBase(const LocalPoolDataSetBase& otherSet) = delete;
     const LocalPoolDataSetBase& operator=(const LocalPoolDataSetBase& otherSet) = delete;
 
+    /**
+     * Helper functions used to set all currently contained variables to read-only.
+     * It is recommended to call this in set constructors intended to be used
+     * by data consumers to prevent accidentally changing pool data.
+     */
+    void setAllVariablesReadOnly();
     void setValidityBufferGeneration(bool withValidityBuffer);
 
     sid_t getSid() const;
diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 8dd83385e..57a41aa14 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -1,3 +1,29 @@
 ## Local Data Pools
 
+The local data pools can be used to store data like sensor values so they can be used 
+by other software objects like controllers as well. If a class should have a local pool which
+can be used by other software objects as well, following steps have to be performed:
 
+1. Create a `LocalDataPoolManager` member class
+2. Implement the `HasLocalDataPoolIF`
+
+The local data pool manager is also able to process housekeeping service requests in form
+of messages, generate periodic housekeeping packet, generate notification and snapshots of changed
+variables and datasets and process notifications and snapshots coming from other objects.
+Two important framework classes already perform the two steps shown above so the steps required
+are altered slightly. 
+
+### Storing and Accessing pool data 
+
+The pool manager is responsible for thread-safe access of the pool data, but the actual
+access to the pool data is done via proxy classes like pool variable classes or dataset classes.
+Generally, a user will create a dataset class which in turn groups all cohesive pool variables.
+
+The user can then use this set class to `read` the variables and `commit` changed variables
+back into the pool.
+
+### Using the local data pools of the `DeviceHandlerBase`
+
+It is very common to store data generated by devices like a sensor into a pool which can 
+then be used by other objects. Therefore, the `DeviceHandlerBase` already has a
+local pool. The

From 8de33f13014f059f53767968eb11f8fe8a1ad32d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 17:46:42 +0100
Subject: [PATCH 1621/1774] added local pool doc

---
 doc/README-localpools.md | 134 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 130 insertions(+), 4 deletions(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 57a41aa14..9e7ddeacf 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -1,4 +1,4 @@
-## Local Data Pools
+## Local Data Pools Developer Information
 
 The local data pools can be used to store data like sensor values so they can be used 
 by other software objects like controllers as well. If a class should have a local pool which
@@ -20,10 +20,136 @@ access to the pool data is done via proxy classes like pool variable classes or
 Generally, a user will create a dataset class which in turn groups all cohesive pool variables.
 
 The user can then use this set class to `read` the variables and `commit` changed variables
-back into the pool.
+back into the pool. The general approach is that a user will create a header containing the set
+class. For example, the following code shows an implementation to access data from a Gyroscope:
 
-### Using the local data pools of the `DeviceHandlerBase`
+```cpp
+class GyroPrimaryDataset: public StaticLocalDataSet<3 * sizeof(float)> {
+public:
+    /**
+     * Constructor for data users
+     * @param gyroId
+     */
+    GyroPrimaryDataset(object_id_t gyroId):
+            StaticLocalDataSet(sid_t(gyroId, gyrodefs::GYRO_DATA_SET_ID)) {
+        setAllVariablesReadOnly();
+    }
+
+    lp_var_t<float> angVelocityX = lp_var_t<float>(sid.objectId,
+            gyrodefs::ANGULAR_VELOCITY_X, this);
+    lp_var_t<float> angVelocityY = lp_var_t<float>(sid.objectId,
+            gyrodefs::ANGULAR_VELOCITY_Y, this);
+    lp_var_t<float> angVelocityZ = lp_var_t<float>(sid.objectId,
+            gyrodefs::ANGULAR_VELOCITY_Z, this);
+private:
+
+    friend class GyroHandler;
+    /**
+     * Constructor for data creator
+     * @param hkOwner
+     */
+    GyroPrimaryDataset(HasLocalDataPoolIF* hkOwner):
+            StaticLocalDataSet(hkOwner, gyrodefs::GYRO_DATA_SET_ID) {}
+};
+```
+
+There is a constructor for users which sets all variables to read-only and there is the constructor
+for the GyroHandler data creator. Both the atittude controller and the `GyroHandler` can now
+use the same class definition to access the pool variables with `read` and `commit` semantics
+in a thread-safe way. Generally, each class requiring access will have the set class as a member
+class. The data creator will also be generally a `DeviceHandlerBase` subclass and some additional
+steps are necessary to expose the set for housekeeping purposes.
+
+### Using the local data pools in a `DeviceHandlerBase` subclass
 
 It is very common to store data generated by devices like a sensor into a pool which can 
 then be used by other objects. Therefore, the `DeviceHandlerBase` already has a
-local pool. The
+local pool. Using the aforementioned example, our `GyroHandler` will now have the set class
+as a member:
+
+```cpp
+class GyroHandler: ... {
+
+public:
+	...
+private:
+	...
+	GyroPrimaryDataset gyroData;
+	...
+};
+```
+
+The constructor used for the creators expects the owner class as a parameter, so we initialize
+the object in the `GyroHandler` constructor like this:
+
+```cpp
+GyroHandler::GyroHandler(object_id_t objectId, object_id_t comIF,
+        CookieIF *comCookie, uint8_t switchId):
+        DeviceHandlerBase(objectId, comIF, comCookie), switchId(switchId),
+		gyroData(this) {}
+```
+
+We need to assign the set to a reply ID used in the `DeviceHandlerBase`. 
+The combination of the `GyroHandler` object ID and the reply ID will be the 64-bit structure ID
+`sid_t` and is used to globally identify the set, for example when requesting housekeeping data or
+generating update messages. We need to assign our custom in some way so that the local pool manager
+can access the custom data sets as well.
+By default, the `getDataSetHandle` will take care of this tasks. The default implementation for a
+`DeviceHandlerBase` subclass will use the internal command map to retrieve 
+a handle to a dataset from a given reply ID. Therefore,
+we assign the set in the `fillCommandAndReplyMap` function:
+
+```cpp
+void GyroHandler::fillCommandAndReplyMap() {
+	...
+	this->insertInCommandAndReplyMap(gyrodefs::GYRO_DATA, 3, &gyroData);
+	...
+}
+```
+
+Now, we need to create the actual pool entries as well, using the `initializeLocalDataPool` 
+function. Here, we also immediately subscribe for periodic housekeeping packets 
+with an interval of 4 seconds. They are still disabled in this example and can be enabled 
+with a housekeeping service command.
+
+```cpp
+ReturnValue_t GyroHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+		LocalDataPoolManager &poolManager) {
+	localDataPoolMap.emplace(gyrodefs::ANGULAR_VELOCITY_X,
+			new PoolEntry<float>({0.0}));
+	localDataPoolMap.emplace(gyrodefs::ANGULAR_VELOCITY_Y,
+			new PoolEntry<float>({0.0}));
+	localDataPoolMap.emplace(gyrodefs::ANGULAR_VELOCITY_Z,
+			new PoolEntry<float>({0.0}));
+	localDataPoolMap.emplace(gyrodefs::GENERAL_CONFIG_REG42,
+			new PoolEntry<uint8_t>({0}));
+	localDataPoolMap.emplace(gyrodefs::RANGE_CONFIG_REG43,
+			new PoolEntry<uint8_t>({0}));
+
+	poolManager.subscribeForPeriodicPacket(gyroData.getSid(), false, 4.0, false);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+```
+
+Now, we have received some sensor data and converted them into the right format, 
+we can write it into the pool like this, using a guard class to ensure the set is commited back 
+in any case:
+
+```cpp
+PoolReadGuard readHelper(&gyroData);
+if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+	if(not gyroData.isValid()) {
+		gyroData.setValidity(true, true);
+	}
+
+	gyroData.angVelocityX = angularVelocityX;
+	gyroData.angVelocityY = angularVelocityY;
+	gyroData.angVelocityZ = angularVelocityZ;
+}
+```
+
+### Using the local data pools in a `ExtendedControllerBase` subclass
+
+Coming soon
+
+

From 23873f6bc60cdef68e022e6bfd9d2ddd65b1723e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 17:58:07 +0100
Subject: [PATCH 1622/1774] improved readme

---
 doc/README-localpools.md | 37 +++++++++++++++++++++++++------------
 1 file changed, 25 insertions(+), 12 deletions(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 9e7ddeacf..399400a4b 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -1,27 +1,37 @@
 ## Local Data Pools Developer Information
 
 The local data pools can be used to store data like sensor values so they can be used 
-by other software objects like controllers as well. If a class should have a local pool which
+by other software objects like controllers as well. If a custom class should have a local pool which 
 can be used by other software objects as well, following steps have to be performed:
 
-1. Create a `LocalDataPoolManager` member class
-2. Implement the `HasLocalDataPoolIF`
+1. Create a `LocalDataPoolManager` member object in the custom class
+2. Implement the `HasLocalDataPoolIF` with specifies the interface between the local pool manager
+and the class owning the local pool.
 
 The local data pool manager is also able to process housekeeping service requests in form
 of messages, generate periodic housekeeping packet, generate notification and snapshots of changed
 variables and datasets and process notifications and snapshots coming from other objects.
-Two important framework classes already perform the two steps shown above so the steps required
-are altered slightly. 
+The two former tasks are related to the external interface using telemetry and telecommands (TMTC)
+while the later two are related to data consumers like controllers only acting on data change 
+detected by the data creator instead of checking the data manually each cycle. Two important 
+framework classes `DeviceHandlerBase` and `ExtendedControllerBase` already perform the two steps 
+shown above so the steps required are altered slightly. 
 
 ### Storing and Accessing pool data 
 
 The pool manager is responsible for thread-safe access of the pool data, but the actual
-access to the pool data is done via proxy classes like pool variable classes or dataset classes.
-Generally, a user will create a dataset class which in turn groups all cohesive pool variables.
+access to the pool data from the point of a mission software developer is given in form of
+proxy classes like pool variable classes. These classes store a copy
+of the pool variable with the matching datatype and copy the actual data from the local pool
+on a `read` call. Changed variables can then be written to the local pool with a `commit` call.
+The `read` and `commit` calls are thread-safe and can be called concurrently from data creators
+and data consumers. Generally, a user will create a dataset class which in turn groups all 
+cohesive pool variables. These sets simply iterator over the list of variables and call the 
+`read` and `commit` functions of each variable.
 
-The user can then use this set class to `read` the variables and `commit` changed variables
-back into the pool. The general approach is that a user will create a header containing the set
-class. For example, the following code shows an implementation to access data from a Gyroscope:
+An example is shown for using the local data pools with a Gyroscope.
+For example, the following code shows an implementation to access data from a Gyroscope taken
+from the SOURCE CubeSat project:
 
 ```cpp
 class GyroPrimaryDataset: public StaticLocalDataSet<3 * sizeof(float)> {
@@ -53,8 +63,9 @@ private:
 };
 ```
 
-There is a constructor for users which sets all variables to read-only and there is the constructor
-for the GyroHandler data creator. Both the atittude controller and the `GyroHandler` can now
+There is a public constructor for users which sets all variables to read-only and there is a
+constructor for the GyroHandler data creator by makring it private and declaring the `GyroHandler`
+as a friend class. Both the atittude controller and the `GyroHandler` can now
 use the same class definition to access the pool variables with `read` and `commit` semantics
 in a thread-safe way. Generally, each class requiring access will have the set class as a member
 class. The data creator will also be generally a `DeviceHandlerBase` subclass and some additional
@@ -148,6 +159,8 @@ if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
 }
 ```
 
+The guard class will commit the changed data on destruction automatically.
+
 ### Using the local data pools in a `ExtendedControllerBase` subclass
 
 Coming soon

From a7878aaf0446b85a71da8522a7e3f6807407cbe1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:06:11 +0100
Subject: [PATCH 1623/1774] readme update

---
 doc/README-localpools.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 399400a4b..223b9d2b4 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -103,8 +103,8 @@ GyroHandler::GyroHandler(object_id_t objectId, object_id_t comIF,
 We need to assign the set to a reply ID used in the `DeviceHandlerBase`. 
 The combination of the `GyroHandler` object ID and the reply ID will be the 64-bit structure ID
 `sid_t` and is used to globally identify the set, for example when requesting housekeeping data or
-generating update messages. We need to assign our custom in some way so that the local pool manager
-can access the custom data sets as well.
+generating update messages. We need to assign our custom set class in some way so that the local 
+pool manager can access the custom data sets as well.
 By default, the `getDataSetHandle` will take care of this tasks. The default implementation for a
 `DeviceHandlerBase` subclass will use the internal command map to retrieve 
 a handle to a dataset from a given reply ID. Therefore,

From d84003d62a08ddc722e0363bf4cfe381d3f44785 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:07:10 +0100
Subject: [PATCH 1624/1774] updated READMe

---
 doc/README-localpools.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 223b9d2b4..8b1fc45bb 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -142,7 +142,7 @@ ReturnValue_t GyroHandler::initializeLocalDataPool(localpool::DataPool &localDat
 }
 ```
 
-Now, we have received some sensor data and converted them into the right format, 
+Now, if we receive some sensor data and converted them into the right format, 
 we can write it into the pool like this, using a guard class to ensure the set is commited back 
 in any case:
 

From 6df1abf570e57e134e46c50d1b8aeff2f6f6404d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:11:10 +0100
Subject: [PATCH 1625/1774] added graph

---
 doc/README-localpools.md        |   6 +++++-
 doc/images/PoolArchitecture.png | Bin 0 -> 53460 bytes
 2 files changed, 5 insertions(+), 1 deletion(-)
 create mode 100644 doc/images/PoolArchitecture.png

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 8b1fc45bb..041167975 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -15,7 +15,11 @@ The two former tasks are related to the external interface using telemetry and t
 while the later two are related to data consumers like controllers only acting on data change 
 detected by the data creator instead of checking the data manually each cycle. Two important 
 framework classes `DeviceHandlerBase` and `ExtendedControllerBase` already perform the two steps 
-shown above so the steps required are altered slightly. 
+shown above so the steps required are altered slightly. The following diagram shows the
+high-level architecture of the local data pools.
+
+<img align="center" src="./images/PoolArchitecture.png" width="50%">
+
 
 ### Storing and Accessing pool data 
 
diff --git a/doc/images/PoolArchitecture.png b/doc/images/PoolArchitecture.png
new file mode 100644
index 0000000000000000000000000000000000000000..13ea85c8886ee64629152d6ea4a2b3e58f7085be
GIT binary patch
literal 53460
zcmeFZ1yGe;`!|XrB?8hQZGe&jO2Y;PQ7I86q?GR3bZtuMP!!m-AfVFH(n!}Pq`SMj
z&)USJKCkcp%$#rL%$e_e&Nu_?ec$(5*Shj|{jS^liL^M*#VZ$4P*89lJrsS4f`Tdv
z{^w$z2Y(T#D>FnvaY1<`D)P)$Z9WRimPl;(2=&~BXGDr(q*hggHe#(-6I)v@H$9j{
z%28NjRV*+>M6u4_8z=J6F309ltEKbu!8~98mX`a%1kt6-mvKhuYu{dYxXLE?ME|QU
zpJ2xTr>P7Kg4h~)^flQbameyHEG(Ws4m=wC%MZaUICt_BMlB`s2Nz%0#^b-_ll{N)
zhcFjyR$g8^%;QCvxx9Z*)Klzp?Im0jkMLw+l(g*ZvexONPu>@N{`?sT4*YvbXf^v2
z>ucjJ0fOV-mp#8}h)f>;crWn({D>69|0m@z{Vp<6-~x(pAUI~b{PQR-+HXEHl4u36
z7X3s)F?f0Y0t$~S^7y7JBvjesMvd|F=rHfm83|}0Kk+#Iq^X%^<Lc~xd~hCq|FQv6
zcO&mBWzs?|T^s2zbA*9XG=EG{4C4JRJbBsU1uYZ>W$KAMb1kJREfn(}OAs%L3-l%v
zatT4a7e0~zl`rFcPmIkWPFhRp_5@oC7iE~T-UkgH4}KK+jK+b1Vuq_-<<{7W#^Fi(
z^E@0Ch38oJrvG<)yvpac49g$Qclq#O*4s(mF}bD5#U=Nb+ZUUyuN?};ZLp+n`1%pH
zlwA1P6Y+=CUo+kh$Hj-eE|GQGpmK}!nD$tkYR+N^hH@qKp$@E5T_X68i&kPA?|zSy
zeOmg-ZV92hweUTrYrjZ$Ejs&Wc1*}YHm!d7HtU%3GyRY1Ro>H4I`_7)hMZQZ5V74N
zyU!J8#XEHo!CP>MozUL%A#s)=nH@EO7<jzyEI*lODH}T0=PYj2U*|L`0{7jMh*Uwt
znSvr<hn-V6kMFjm>zS@gugQDni8dsTOYJ_NB`$HM-%Z)I|4`y?k%$|`nA@2Bbf}zm
z*NOe1a8xn*?`je$LjwD*SQ=N{%HP!9B@h)6)u6n}I)1mbq`)~9jfVNMA&xQovmp^)
z_6f}ryQK)QDJ4xEwApWexmjR?N^f=cifVP1<LWL0f9GNgQ6g;%!XNEQjC7XcrbX*#
zm|e=NnKul9(c=<`NP+fzBh3Sy`vft2qipA_Hg$eeZvj?l9cOTkZ-`T_B=fFWnP;01
zswR5cwnbIB69!y1!Sqp#ph<2in{)WgOuIh%UGnQ!^7b>tN|iD#M?A4}eBTkglXogM
zSjsI{^30N^f_%v2cefjHd4T$f#qvnkrZbqOH%nhe$A0pVYEQ0IB5J>W96~DCt?H<e
zet!e^oUu|N+Zz4B&a27;{;j3H5;kr5$M-DV)+rqqd1NfTr|FvBq`>ngYnQ~o1!%E%
zM6+u==(jR&BdHKNHOY_&Ef5!Y*@e3qSLH9tcE6XQ9B_X2j7Uq`1MZ=CXDg~8PB2lW
z5l?-emITWp3+f5sS1CkW6LjK}a({{wKqJshv9`9RJkbBRu>PICL?xpW^-{d*x<l`h
z#@i5Z0Nz6GG1Sa#tR8j2rBj*~4ZT(yj=YBw3vwG<!YP)GSA69QF9g>{<8A#kp_@O`
zpMpn|-R=)Ac$H3l$+#86Q+$9~+n=zXHwUY_nwr84f1xEyU`M*T`;&E*aZT`mw`o2z
zOKk5*?I1=^Hx0V^Q)$roCBk)@pj89EVYVQ->IFfC$NsG@26qU%t&n^!Gg-TdUw3RN
zM%&k~m92j9GU{vD)8w1KtSiLKeh)vWpkh6xV{O^gvnsCDSbS}BFmRp3-_u#}&Q0ql
zNe=u{RD5?KkQna8U2}z4!MPoqE4e;;Ls|NPdNe)upY*176Pl8()E9<gVROnaYShU4
zR;xo&+@}TBntZ#+TZJ@$6|!zw%^c`0u`kqQh~Kdlay797Dxq#apFoYbv2FBISEGj0
zS{HL~eMh*rEmb*Vai=d@ca!VO()HGD=a{XWJ&M79t(iKcAmy4;pS+1?v*l<DmXtoW
zG__#QdT(OUk=v&@wjhI{CFT7Yjn-zTT1SMvbL1QGz2}!&VFwi(MK>U9rA<S<dV714
zyCIf?N1klX!z}25it|r%SPUWV+Z99Vx2FY6+XM#R0S}{J<@-T*N54m=$mvHMPVdy^
ze^%1Z2$hwU^`<vl=QQ@lH60p@fv-I>v0f|-bB!xC3w3wEGsufS;H&5k&_tb8LIk!i
z>#_0Fs2>=}CWsBb78tC6jMCrOtXItKT<vMdOCKz;nHy}n6%k0qQ@zKD&Af?^6Y`?x
z+h#}QD;7_3OC6ym<!`vUO-{OLUU~>g#808VW!%$XG9eGgt|P?cDEb-1E8Pr_9EaD9
z-n~ve!m6xb)RAkG+Veam>?hl;*yxRY9vm6Tf-pG-=@l_?X9$5Rhy5y3u-Mc&|B0o~
z)@iLfij!5Io!8XbIc!B?5-cV=9pBS^Hi7$~uoMb6e|Bege7rTdjSzS2w=ig{GHHE~
zKQ}PABt0$kN^9<|AkAVO^W!0irULp>k<FZ%F+U-GW|a2|;fWZ$9Pf@WWm*cypWDk_
z8iVL2>T=`-^CcNe5=L>e4)W-ZM%o2WdUFT(K4*1LAjwN{(l&V(A&VY`w<uVv4D1qU
z%Jj7zb6bpGp|fg?gTX1HL$|Y0`3HXtLNL9U>4!KfgrILkL5_1MYjA?}qFw5UVVk@4
z=Rpx>!Hg-FZQffWqu35t=Upq?(hv7O=;<a_QGh4HBvMW7TE%@u9rjB{?cxzsN9J{b
zMH4^0<!~DA5GgO~<Tt|i!!S@>m=A?+5WhGL?2#qz?}3nf4<(Y=Ci1?|+RD_V{7@=d
zvFw})TZNT;(k)?-i0O3_o!SYWnxj#091{tG(kCe;=seBq%*!UBO2mnv?`>iVEd~1(
z_|y{w;@euaCPqL<U<#toX>t45;8lbi3O4VRH!kpXO*1=h+{*`<Nk6WX?^*J(i~ICS
zsIjBjP!;z%at7R}hZ0i!F%GhFWO74cSM+2;<hk<*7SLWV#XJthTvSMp$wk#%EEMZv
zCwWz0OZnF3WnhlhECIb5=YwXR^*Ophy%d$Jy9ox$&D|d|Z`l#{QMFds7Ebkzx;ie}
zwi`xVoY0PJ;LQUuHI*rMaj4)3!L4Sa{Sd)b1Y8@fK&(FgX_6y7BoYIh9?^?yZ+BG<
zezb|1Vuvp&Ev<G9vPPE1!W?8BL$hL+eXcJo8ZlT6?|`@x7eO6Uul->1XKspaUG|N(
z8v#HB4OVJGYc=Fe_G06zwT6~r*JiLh%|UeXz_`P5PbstiI<$Arsl_p`PmLD3i!0QA
zn6^1rqRNowru<|(dgeWy+;s@{=P5bj=x}a*wapo$PTiw`gIx@&0qgAUTHrc2s6^>E
z!#+F7J~5l_x<5+wH0C?~sOc9tiw!Kpp||?ZO5#^qO`B>M-;ua|to@-)(T@Qt5YBvN
zqO7kqYS^UojeOzH9_56h<dZs=v(@&;+=LKd65-WHez;RwVt4Pr1H`BGU0CtDMPg@`
zvzF5&tk<EBDM{=D$pH2AW<6p0x^uQojRPN7!B_8+z!!~11tMS2jhFQLlB{D~*-_O~
z_YC^_`eyg^#!PGAvzh+ag@SoL*Tn+=xxAw|Lgg4ijI#Ca;o*VcAGu^%vGAnN6X)xf
zZ=NNii)b7Q9;??}h0n5CGq#|DtM6&BE?hj#M_n9T8;L*eKcszfmeBTNYo%dMh@W>o
zOG$@;ki~97-dUMN@m>(QM**^z)B7rU9>$b|Pfs%8er%_I)bszpf3f|-^x&D+6y61q
zn;!n+fsGIp51MtP(t?^|Bmo`e$q(!`Jd_cPGg&=-`jp_Daa>$nC3~H72&wz+*Zxw-
z+NL)6;ow!I$H8#n<Dox?QpVB}llkF)`S%7Xj?l=+NL#GUtRga(*!wU8Q0$d`glIA`
zfs_ds#h@kT3iylJG@=`6(x}2zyK<=D54Z>9%E&#SeE$6s5^#mpv<wdT0?)dx5mFn^
z#o``(L6+X0hkmKZ$_eG?N6209`|z*zuP32{KTz&+=6=%vIT6q+VVvI|1MGYK=u(;C
zaM%SDlssWrwLG%qLYe(v{oPCR+p{lEjr3}L!2*L^OT>_+8`wek9sR2Tb)P@qv||VB
z;%LdkJlRR@;y_`;`&&N(st1c5#2-8eVOFx3X-lwR0N=V3YkKVTP=#L?6&2M`JNQxg
zq`t^u%(pZfH2Z-Ahr=xtz}GJP`dVwec-B~kLC4pcKpM82mW2#4j_-0ZU_A&6Q}D%)
zZ%&uv;?na?yMb6iMK(^<Tg;clySlNlk-{YZ90qu7i^tiw%4(aMijNNWdPKU59c=Vl
z+Y%(MVV8SO0SM;GslK6Hs5VS5t_~>UU(6p{pJ`v^aJ0omLHT@d=tQxEQBu^3!%H`-
zor6M&-S7}VC{okP$8|Ew?S`55q^0~ZT<h)P&0fP*4xH^}0PtKsdp=5*<<ejjmBZE$
z3}#}IRy1$1Ji?2D5{rJS*C>gK*?O|x1UJ(1M}1h7b88zM%kdPBpYJ7n_WTt}h;tDT
z$b1=vpnY~xBi`{dg51vbII7?Am6(5)+F?G^CHoRhG*Cpov%`6EDNCnG!?XXnf@+S#
zmWiE``S1@=oeN*sB{?qGQT%w!hJ`2UKlIRX+pTKZ!FjjMeUW<<*86yRa%Em6PJ0iC
z2Ho$*ax3PHkB>k5`pnz-lR~=MDhD``^0RfIT;t&6On&yI0=Gam{y|+sBR&lcLcVk+
zF#?xb;3gYb)n(>mxdB~%7aUB;Rt^jqb@-Am2@9jrH!Yws2Ll`BE`dV3UjCurY}3?B
z)zp9m(0ZNtYm|P8Qs;y2SFpL%yl5Wtduo$3^k$M{-9C~t<Jw>$Zl@l(tT>Y2CQUx|
z#e8j`uWxYZ&d6}NJNJMkq4EtOp_4mKpWabL%HDqWZkNgr+`~t~^mPrEw|5-&S89}W
zH`(@-)GmQ%pMA3*w{%#gz+xiTWPp*akkWAmXu;=maHe}ZZ&5H&`K)Fu1CC0M4wiJA
zBj1Lqo>#X=F6i_r6)2NtjpN;yU&=GEF<m(RDE#ar_f+M)5GI8He>bHpokzaQ2^ip^
zCmZ>Oo5qRZbz8sfI@iUtg30jpb<0*SHbHP>?bApzeMIhJ<K^qCS@R0mlt<o(1RgkA
z^0T9T#$!HOnVL6Pk6Yz@uuD9A{3-R>r$kD{_EtdX5+TgI7UK_(cjR^dMCZicf@7vD
z!}*!2tUwuz2ieakBJ;Qf{;kHMRk`Zpbh~|M6(72K0xMlDsx1>+R+w}V$6VT}p}U=W
zPC0{P_tZjeR`{x%Voa5CEOEUo_<0$y4d0+;Y>E%BAV)kG67N=Oq<}L&QAeNUt67?P
zYNCP{M5aCb>oa0tl;_*8Xs~yR)0|q2*zGww%qB%hlr4#*p;wh6jnk<a6P2fU(%#WL
zupCvook~Zd>9pQ@;-F+NWKp}d_-(X%>y~G~QS{qDF8w%3#c#C7yvNxo!w`-3zr{mb
zqor{vd0NudA)Dz%WezW2+-Ih5X-)DxaTEbp!!|B^=$z+^Y7D=d{50Wl3S=+zfSGNR
zEUfdgFP7f=&Z*Zr{i0;FbN~%x@auCXA*BI}29|w{&WhfNwCHn4S<#EfocmMola}A~
zTI0SxPyS}2pla3e=~1vEHn@M|3q^iq#`IyF<3rI|CqGlM6X91U1-B>3Y)!YiBV>UV
zOh*ekR9@ZWG#v3&r0JB)ie@N79@)w?C+hL}bJwX@SXhkS=tiuL-adbPuH`dY8?zlY
z{pJ|TFA^o;?3&f%6BCc96tN9;C6s77gEvC?Jh+iNWG8c?f8^1K1@gKujN?lY?R5pv
zDK&?MoZ8xlxu12K!j*H4T3J85Jh@QUFw<&+`qf3GiaG|AxVRjrfMo*5Vq8xmMB~MN
zcvyjsRKsa;_1F`Weo1|-RK4xqRe4grPRd-3$Q@kLYDTH0JkedRc5fDSz1!OrqT9ff
zGRbNq&js=NyzIPxIea83xVu}Cg6-~AR_&*WlH|D)mA7v&GWslx`QvlXCi~FpoQHFw
zaERjr*tA75$ID<;>*bi3OAaYHt|{Y#XFnB)MH(+~=%Q!^Tn*w4WcV(cU4s8HNcoz{
zgsz+QLT}wzCx=nQs3c(;fN3X$Coh==H;(W@AI9pd<gV1X3mtC4hSJpY52x-zmU^-o
zSne()B|unq^;#>py^Rk$ACx|hwM$&(1Q-vYgLaCutgu~LFEp#BS$gPQG?bnJ0y%1|
z<197Wew|}kQ0iNfRoA`Ie;L1sLl>+!juPzC<Q?xW4872$vFAg6X=PniM^H>?>14!R
zW0U94zT>Ap(4uM{jWBQ!S9Zc!BVSp<=hcO>!mLT_3WI7QB};wGjT}w9xV9T3Ikp=q
zHQ0lAQE8z>u8lp!n((nmL95M#8nw1`Wurld8Np0^riz~{(E(G4s4ju{hVBeKcjpfp
znqAQQpN9KV>XD{_ej=!_jd>sW$u_P;|G7Jhkf@`z5f?lKgsRiXK3e89*iWj7NrL(S
zk2O|%(bkmrLIy*~6Uaw^vF`p{<ovSqskm=5z<~2{>Eq1IxdOVU*-3;dx~#NFWk)?Z
zsz!TjF{TrgFl=;xcP(9GW>kjMSL_kiqvR5`DpAHcv(7JLNgUR?%rV7|00C&L&Z)>A
zZ6HRXuXtIRF1cBn3%Hq7n;r=Xtv4pv?u&+cQMVb@hT9ni>^onddq@)ell+=arK(Mj
zPn8h2D9dg;)*{L)f-|)|%>;lKj8+9A3$eDzB}_+5=uB0=4;)!2O*&xhY~wI&WL}tk
z@v5z&7qzz;VdzZaJLq^QwQ$u*qrU34$WNpBtBs@%Lj7`<Oq&IC1}k=aSPz?t#@Pgp
ztrO8odij?x&{go$4iIB{F#0^X1A0)RP7-t*-ruZ1SVFL{W4F_w!|YJd+;EsC{Y|Tv
zph<^yOs~2%Dc!Dj9D4t!h8f?jO=CG<(}wR<GE#;(65R7D@oUSvp0Mz3{k_88IeyxU
zNGm?gOya$gbOgoaQW~9Fj!;`)^<$6Oj{OJd7IW!PbRE7kDVdojA4b0sb!WCfR)FfO
z4W=GH%hzlk>)|lP%DV0-_L+%CQfUTpPPxT2Gc0^5XLwsR^@}?tLsL${2pn18m6^(6
zY@A%jR}~$$1}`YuEWNr{jsf_~ugL<1IL{<q3H(<4E&0jA_8myv{imhZoiL);S!Rk5
zNEr1Baf#M2l%HAE(0U-xDW*Hz<x%veoXHx!>i$>J=AOtz;s~EjfX7$%RVk<wM^k9f
z>qs+<KD~D0Q(<4Z_PVMi;Q8-|B@O-4^eWL;fmWvOSr5d7hV-l0>ep#QSRTH(UD9B?
zNyBi!C@sncCHyXPnMRe0i2q^fMTvvj-FdrJp*04CZt3h^H$kYHYg^+q=V?|QaJ3x1
zQ52-1EzKlI=pZ@nZxrB={6o1xmu;xTes3_<fjh~FBt0@!J%4cOyU^>packQvA^NqA
ztD!ihUd9&9Q_-YLb&EZgD<7f()&m`aGhOZFZ0D3hswKS)L$5E&&~YH4VB?s7;KrFs
zuI}&UpNJUREdqu8F7blD+GO`L+810mOxw~c-d&EOJ?#!`<nLa5|9i;6YEGGYO~eHC
z6=Jl9UtfWXcD5Bfn9_u=Mns=qcs}I!x^Cb4ljW{>Qo&Mlhnk(q!hVipD*$`LjkkvZ
zT33{`0=@s9uw_Q8GezkG<8zIJp3-?;yUZHQ=4>5iDCL4e7nP6NWOT{oO#i&f;5!?-
z^qq~S4MUdgm#&J2dcGfbaXZIm;dHUBQ-o)k%LU!ewR=GIrP7nKSe-3z0d!a<U7w=8
zl97VcG?LT2x#-cFG$miTayG%H$&!tj%t5xEGr!OeX%r2s&Fgk!<;56w*!)ad^UW=~
zb3Uo3OPrn=FLOmb*xk@Ps>d!8H%q)b)Anwx&`)<~d_yLi6h*_*AvVHUl_EZrH)J9!
z)VCUIfZ<{C9p-_c16@BhLFlUF*f;-;h#cx#O7j!gLClSF&W;Y9qb9MLSUv5s1UOP1
z|HdiN28E-8$Cf&aRTMb{T!{x{tx9_fKZWzg*edo{*H-Ns0wtWsS(2n94HOeUIuql&
zPrXs}M&?vlKxDVaL(du@y<(sN@~vlhxWrvDsV(mlf||P!*~X&a9_mSI#4+G_c*kVt
zm9KM_#!Lks>0^l|71gJow&IIR_qGd%+MSQax@pJ@Il7J3Oww(3h?#OYbj{EnbMDo)
z9mEU-6TA!iv<M;-ryvv{RbPe@q@A_Dl_arbg3RHhBD+Ztsf568ZJsx(e$`G6rR8Gs
zw>SB@7-MbtSgmF6?O+N-`T7eaw3s_4SFy`I&Bg}<{fJg-Iad1Eg$yk7ne_y$R;<yr
z+IhPGeFZH|PZ)n=-_h3Wk?6HPs)c9Go5@iB=1~RrDSGDzL>kCs6RF0vl)-eFdW-x}
zyK5Bq5XTjFJ<@TVDO{L!ezy5qlvBORakHdo`(xeyzT-?9XKym@hFwwMdcIB?YaPu!
zN2$jW)r*$~KX&_)z=vweW$;4yi7Wi%`kJbL%Wsc$K5Pd?%5~Bq#fXu}v?v-OSPJmT
zM2$0i^7Ds`$u4e0;S)=iOwbWBRnA%HcGaARWu7zktRpdPL^S9^4}hY9rq&N-9(Aew
z?Orv2Tl(O!aW+px_GQ^2I*FBg?jP+`&!zdU<*Yynoi4vd=Gq~^-Jo-94W%6s`&Pa#
z?CB=*CosCO@x=-L48AlkH>s!-7{$`tbJQftFZVessd;r1)dBZmDEy9{)uRw#gC87-
zIAE)egC7;)a(&_~NT<9vZv0y+{&u+0UhQEfN6q`WR9sVi1tjKa!GP1&7cZ35?C;AR
zJ|t~fr*|MWnLR(0Sqf0%QGE5ZwN*HTRZj3+gaL(WYi%Pi>ErYtoXAdaL3EBi_2EK>
z;+^jc)Aph2`EL)z4WG=%N^e<*^H~}=I}4fiZ;Y{KzINf;3+DZ!c@wHtyWer6P_RYn
z&Nn3ujr~f{pS39{ZTQR;-@UjdRIL#EY*2jjXymsB&hu=<(0`m&h7y~m&6|APP}(V@
z=G^Cf-Pb>FTz~5=NKf5wvyzPdqI*8k36ZTf!eqxOj%ef!zP6j8BvaJzQior1vRm>y
zuXfhqqi8;JgXT)!-nqIJ%lyJ0U(*#H9jvXb0&Ml8(^$tg2*#Ptd@Ic5@Xl<GP^;^P
zef7qT@X8t)UeLTWvR{b#VIcCfHBUTeNrCmyGE<M#fZ&NPj6-2*)q&mjaE>%>ip7XF
zZ%3KJ7`CPmx<6TLYK#42C}G~O6y;Ty5FgQ8eBfE}fQ$@;iFb{hwT|v<w-bWY-e~fk
z9EhPWkJ_CkycN1(-28*>vfs(wxj<n03Cwk`W3I;j8`Qhk8e|dcwx4T2U-JzY4PWdE
z%BH%(7{ku9*GV9Y3f`6+jiq<*_BrG--0u$(K08C=Jq^c`)=^PbzSkB|+Z>8kXVO<j
zHJKNqa74u&%6Xj`$hgG3@WiH%3bhYs-^EP;ZEt%Z>ZjeD=45&Ex1tgFJUUDQy_6Vf
z0SVwkQQ-}|!NCHYJFiPiY59C*c)SdEmo1S!p&LR^D4ytoY~sk6-)fXd-Ew^ETI-E?
zhEfhCOP!;)?bd0ewH-IAIQw%ABC_%EHQ`x?G*mvnN=l?2W4c|qGM7Y%Ac)kLVuBVr
z_iq4y&tMsI``gBGs}uHtAK3;fK(>JjHyHy7$JhqR=wq9!<JLMn(kt7}`J;O&?`S9L
zu3~%XX@Y$jSq(y$avP#Qasl1THm8a5`mYac8X~22)M+ZZTQs%Pzt*eF;dp2HTIO4i
zX<yQp*q^gDzfq;%b(FI2$L-+vO2F78QhmaAtGs66W0Sh7#n`BS(NsYs^l<T>p(9$o
z%O*a@)P>`Y#X~b4P?4YaKlS${L5==P9BP(od``EH-Wvdf-Uk~cs+o^U?r?O@?wr-4
zTw&leGb?tS|8})I?UZByVo4KT`dtg8Laopq-G<8GSNe9E5{K?9#5YlU#cLx8kI5m(
z<m2)MtUJhp{02|^3t^5f(0O0jYLcPkdm9pNEtEH%TMHUDUposrno>m_L`L?K+HSZ3
zHA`A33)@?)nj@27hgsF>GD6mBG9jV}PFQ45t^q~E$bn}dXjSi#sk?H-I(anm9@Aft
zp#o3jm%gE0hcbgU-L14GmXoebXmKj}6Ws+vQ_^PjmeTu-C5|ti*owUa33M=@S6J!y
zaYG#S23}>$yH{BxH*9Ifn4W|Woowc`t-eA4k_vM&{FCSWkYND5Q4Q8rT7z~|v&0->
z?SO;>)rBsnLTMG!yx8TY%3JpnA6k&;O(ii3+%;`0ns4txdmVb%X=-5E*Q#+Xc`B{b
zrloqk<AxIGb``y9MbCZMw+6a!qlQIQAdMRrx;GgqeBAaKq~ievF0Jbupzi^_`!bF%
z44s|UJa)0}hvUp_9NEt_NftmsD%j}1eL$R2gS=(<bA##&z8jKW($njK()0QcseFph
zC+s*~0&E_1;mMo#96^DKK<6O+$akdqd-Vh$1zITn*EI;TOg{Op8<4ABbyf^qv(RXT
z+3R0LE^t`pw>lAS$eJ7k?i8A8>3Adpeo_MeKlv1tl`6WpB0(+HyEByuiV$oKu)ylw
z=`3e5e*a_a93W-$CvX8!VTnwkgFn9^GI{f4&BxcrIJ2JsNJ<dDs0T<m{};COG)1QL
ze_D8w`Y9^aiKm$)i^Svq0j%<g=Gxg#;jTH)%=QzVKL!(kUsCbem?1qup<*_EbnE{K
zP_b6+uKOb8I2VuDeKmjQ*eWsEEULVG=DWo%dq{VGzO=Vf!_b+eUJEMYJdw$LRCqil
z8wZLD{fOYvcIECmHvFHG7XW$Qw8F?{$_NsJb+4@4-rj~C%&A*2VN!D4n-HN`y#6BE
znGWhz1waCqM%UZtJjFBD=X=(^Ca3Y)t$r#(aT(1JDxv-T3!dyr(otWZd_2$8T<J|X
zp^ZZ1xv_$F_E208EFJ+ryQ70GJM+bYsc4V~fiA)uMH=-W-cz*^4s-eOBkamu1Fv0X
z)$h;LF1gTk){tu9o+2cd>4%qZzuZ}!h~x3g&*v$?_{-HUx-m}jM4qx=pM4o}-jiCq
z-~vktWJ5~i7%QNaEE^dK1bqU4disu<slg7c3TRLcGylC4$e`^Qjx2dO4tKxVVn1&I
z6N>YH>{g~Z2BMy0@LZOhg;Tfry#wkn#@rY-hvzBOgGp#+yFKp9R&rVUtu26*Ck9cr
z%Xhck8c%TnjEW1C)IxTvbqr!k>qb4_#MI8AsQ+6U_YnxlkxHB>mMn?jz;~<Qu5)Fi
z{}xG0dzP+@EMd&Bd}`VCUmu#hD*zB~r9?)|L{(W|3r&K^gMPmbvi`5cVZWA9CI#AN
z=hnsbgYdaE@1o}!py_~pZWqLBh>BT1esKA9hP(LA@|fb88PH0`LLR&OZR(^{gU7`x
z0@*q*qLf`V@T93Z(@NA==MQABNPddQyyC8$<E8<Gi|pO~2nT&5*{h(Prbz6`HK*3?
zdYwi&@lm$pv4x6E3Wo{9-lG%FoZb3%iBHu>0^V#T(|e_1$1S$w``&RJJlO@A`^s}>
z+z+)Mo9qd9tDYeZ4U=#>uq}3EO(*38lL853j!no@Ip@6Qf4LLoI=5!=YCV&90Oii^
zT)J<FbQGW9_ON?6E6fdChWf9|Cg|ZmtR|0zWfo*oeT9^CYc9Q%WO_C@G<0jwVd;6w
z_LRZ_Z~k+p+bCnnij<6R??-IVuls&UQ9J>?UP_vnEXIns6A%zIM+-8sWnIF>3&<y*
zQ?(h`IM^EUwT{_9!tgZ#R8@s(;5N&ih%pR3^UtEV#+?x@Y>7x(rtor@kQ3k0npCua
z(jAVNhtkry&I2zfsnJ4Bs_Taov}aRPwVuS>HSAorQ8iDNAI5VZ!!Y}ODM7rK1v=AI
zDags|j5I<2tVkQE)jpp6;r>p;9{MHRK(~sBOrNdiH~i*)3|STLOhzDYLpU~uLBu0}
z6`Y&YG^rfYA<}-HA1vMrRd>cOO;gHxb0k6s%`LN3GWqTS-=*ZW(CSK4wO}GI*<Y2|
zY;13DpFk_KYovrw*Zg^;A1`o_-sxAPvG!PIKm?H6k(*KH(LhAX{`eM@9DuTR6CV`f
z;^S#Riz`1rAG8Q1mcAq;CT`Al%+)c(q^K5J1Ls4+rk0}m;>q@#7Zw()`Q~Ha0ptl_
z=<il@)z#IwWVc;Rb*Gx6?t9`Ix5kNqlDaR?^k^bfy*GciCrj6p*kXNJcJQj!qCfZG
zurFDAqEvgDHUTAdb$+o>P(jP+<`@Ge&$Hi!kVXfAK<MZ`YSq1q!;Ca7*?C|&-Ites
zXrIv(!HsBcCg}qw>h;qVy3wJ)$^SFGxlwX&;Q~{#ua(Vwce%1hqy8(mo7Bw$)DQum
zs)Y^L#@8f&**?w>PrRwU!8FxE(B%YsZjRs%?CGO{?U(akqT;&~w>)~dva-?;%BEgu
z&64~SoT`#$vV3Z#wTCPY1((rC#cL*ov`8VR-6)&EI*Ox}K$v7Ck2(0-kki({8Uli#
z&_zTWH_W1QfCk|BCkbZ73}JytI{{}~BHz9_R5&(^3B=jW<^Bx|y{thGXLe+BeF_(}
z`qJ}9FXoP2d*BD!q87ttt{mF+8Mu-&*$bfKI7+P9S*5)GpsKsXsqm-&TJ5#KjOxx*
zWnU7e<hiaY-AT7M|NY+8{uHFLwy09Dwjcb@(o}XpPqr-%gWA@GWwyV7^XR$hvq;bl
z&8!A?C(~D}j_bJIDlX>xp<`q29=Pwu?x&<A*m5}rkjj46JJ3{pe>jx^RDoL1{%4x%
zo;O4E%K<K<?pW1&CE&k@N}R?<M-52ZK$Fw7^gw>`S?y?*Z=vN30TtCi#;YG)Y7WM0
zlTG_|_b2bUZHzI@|7nu_BH+UwHOSt4)~cJtGA=ti`>LCp8?X#G%XhHAopk&7(F{&Q
z(UFLx-s(WeAy3@0+WEMu`q^D8I;hAG4W|HVK}LB}uhRL~*rY&J=~-B0<0>OeOYC-Z
zF4}L*-mucVt>3;`S6BBcmtg~+rpBZ3^#$LWKvJ_mTtojkg&Wpa-;=7i*-Q@>7Z%0F
zzO3-TGHTuEQb)i#D2S6p+|g6a!724tBZT(+?t=E{^K3;W)lyb1Rz2XzxBGCe+|dKd
zGLOe?v)B*fP9)pHP$@+D*>}qs{A&;9`wO6;OAMsxck@ohL_?@yUhunj9LBxb{uJDc
zpzjat3G^UGBUH2X-cGj{Ky^C_$jQlRXh6gtI$HjLN5~)z+UR^sSa57C642Qne&S8p
zo5KB3T@pzmC~yZ`|5oe_QiE}{P_KZ1&8}D78Ly05S@QZTkn6AU^CwnR{%5&|rVQPA
zrZnw5xq7odzw~Z`;L_QhqQq$&AMHuw9A-7wo`iSwp@0^KAAl8^t88t}1v?*95cG0o
zd*%EeQ6rLn`sWwIK11u?U{aMhhpoj!zHH;Z5Egq7nRn6;o9lIqQp$S4VR0LEmnnnZ
zlaIVyMT4g&IdiA@Q66CtaFO_-rKE_FywTKWU*7#>T>-%)%S0-IYoc_OO<Up1Q?c)P
z%q1xJFPNzzYX9<V7@Rtd!~7-A2ljSKbVH77I7>m{;a`m*j@xD+&r#Y_HZ87F-jDjw
z)UD{61JoPHIU+BE#z%e)u~d2_1im(N2f+@tr4+QcEOR*roLexdEehubyD(Uqz*-|`
z%7H5eH5rVTtz`SE`VA%~i9Q(6ci=l#C`^l1+9cTguiX9Ww6~ce6UAq>{Zz+lULjX%
zfe|gJ;ECp6MD=pFqLlRoXd5r|+yU^Wx-KglTlxe4D=GJz!tdfy@|1;s6U)rZ#D6_x
zA!t5&!F1h5o=Z~`ty8`$y`i~9LEXv9V^Wo?`s01iN`!qk>VSC-)vjSHISqA+P%wi`
z8X%n<9UdfzQJ3cnRmC0kVQo*{#py1EL6+(c`vvXSThzDt?p=c-jcD&KXyqHlAidLH
zl<AGtT&F6u>8{aGPeBm5@>sP$jotX$xinB{QEN1Wut>@)dah11aE`sYQUha=OZ1a>
z`bWx6X${hSMJv$`i(k}B4~w@3l|SACmdWacO8}i}o;Zl$GX8F}q}FO;W}DFlQsyI{
zoBNUnz<Ff*7P*T!H4d+t){M|hYjJUP-~q=vA-Ds*2`DNcAodKISNRaHO(CY#Rfsui
zAP04PUJFoK=*Ozjl`*tG!!&m$co@A@_<P3ZkAJ%M)PY=smG4tR!d-)(4;^HHp&2}4
zfWUOMIl1It8e7H8edBZj3(HRL?04Q<0Hm5Y_X}%9r3VY9MY@2r5Z172qv}LWEgnd{
z&|i?%y)7prXw{Qj<bl`?tC<=KkekQgL)-7rp4q)SRudT5QcDS%b4Le5NBVn2!jt#>
ztHx@uuQM<(sJVf5u{_#`Jp7ZCD{`;4zWzm?$pG+}z&>afClV$A*Fqwc_26)CDThr3
zf2uoEGZ`>N3awLD98w|yFU0$rYx$7X2VA_B5(C-NhIH7-U1nSwRQOnZ^PzgCemlMX
zThZ4Si4_rm51~(S1HK3BX$SRD7v&oe9(`-@o}mBpcuF%GPdu7QZtnK0Y4=HFZ40pv
zOTLEiFBNe@AnJo5x*0r<m$X>9xwkr%P5o~c-L`u1BHa4zb~fcyIR=g2O-H9^dtBeI
zLr2?VxQ84$_hfvh(NFX#_7bD%wd33^h<ErgPz7G|+taNjt;}THCXq$NY_H6>$!b+Z
zM*NE^G5CNb9)^X5?QYBs0ew!H*j^cn>r0ApuIGN5W6%Mzl>jRKT!RjuN7fz>CdnX2
z`%utuutn@G7P4`1g&5<I;@~26_|Ip`r>n8xqI14yQ&%%2rmh@aW)I=5W-HxqOHs-K
zan?)R`{w?(roH|5+`jj><QBiru^PvCRV+;l9PO|5ngGYU(3^t{`?<<mTGyfcGgXkw
zl)wQAlRq1LaGJuEr7myHORiR6v(?Ty_zho*kxP;`20nLXv<h5F6k7YX7J)cg$Qud^
zU{f#I2RqUj3<(WouwlH;&+h<i%E%DZk$t(wghM`P<qSMEcrEVreV7Ltj7W-H^T(x&
z=R#M3puJuxF*jn3ZwR6vC|!DjUL*5ac*6KNj{qb)43`j4Jv~cNl=YKDUGFMbrd`)%
z7bd5Kd_4c#F|#}EuH#>8cli=JgfbY>5>thuZMIM3dw+@Q<0{u#eZUGLXVX;i$7~gw
z0V^=muo^z-e#ne|(|s)Ik8~UysmXQ}!=>f<CdC`m2n`nw9_N488jBD5zjiRFm5?W2
zI9+t+pQ&HjfSxH}s5NkFeu#zmo~s|;zD45sc)UfY7z-%?K$pv>o&hno$dOYXYd4E5
z_EJEM#_yQ};6PFCrd>AU7c%X*GO`nq`S{nieq~xfLgGgVlzXoc$~pG?Iw=HXLS+~K
zbGaifhw`cUV6kuTGS2_&LCDgIcHk>9SZUevIr*{`x&J7eJ}Kvn{?~iIa@#z<H}xf&
zmuQrbs?k5<w(GJ8C@Hx$JKRT5Q(XQ-(wBvnkMAv1{?|vV0ved73rfMkW*^Ax*$ap-
zkrNOT-*|(EBwwAUyKzH|I&CDND^dNIcjOg){yRl9(BqF!LA3>D(3YPn_<gojt~ADU
zdxA+3NDYTwFXB32{4?WdeH|Je1(_B5dH=G<y>8p}+Wl)IIWr39{y4?6d9_Gxo1sg8
z<PHB!wwW%LkpJns&t~8T`<*!d)S9ztxuSwSoj=pJv%xky=vLFe)_FPtw>G&LQT|6^
zbT%wE)il6;|BMx*@%)J$#c5J?Ha!O}^}PJc@PAtc-GyIPb~dVKy6B84a%!Q!CiI#k
z3Tf{B-`pDTQE{CVyqHgD)j(ztkJwZD1m*MEmB0M`*T^4o7w&&p^zZv~|D*gk8yf_R
zGDZK(frZdEs2CW`f;wWN^NH{gGnvKTPRQ*VbZ>KkLdek;@P~Rdfmb#F-C&Er*!%x+
zMS)AtGq3(xl;a(UYcB$T>(Qe}U^*6mDuUp~W1cOub0Yt~2$cPvB}_z@V_=7NfM%zJ
zMr}X+5%55d#_NJD@b+AggOfaT(1L;j=wzd}uP>8wE;FPFc>EHOJc5LS@{V560$$RC
zt2<dQYyagsZtjz3Bk1DHnvJ{C27HK_#+|KEkb{|-3X}3_Dm{QxSpR`(ZRa`%2L~UY
zef|4eNis2$RNEe!T|bmuE7m0_{}3AM?QQ7vQ0b8$Ip=I=DpNFKz-CBLr!mYO1FxP*
z5rt#w$(0b3ZqQ#JLEs+US!v(2$?3AebnYGKF{vyS&n`*GahA<wFXf+fxO%AJ+nA7$
zfI}^i4{{WZ^Iw#*CP50o$-(g{+OZ;Y+bmc3)$WaeKTeaBY@gRlTt-HQhR5t>$JggO
zS&XXREkO}EiHL!Lilm`S?i^Udn>$ojefqh-rkC6g3ceg=cGz#Xsb$eTiEMzExSKaF
z1?)t7l`6h10QGVy@F*bo60CJgaSyx?3d*pWlP{RN@d=B;<4Ksa_t+mk3=JKI+ZNAh
zrFp*QP5>-2pnN^x5w)D4ah@<11P-Pu;y*b*S{sbXTkNxfr0>`vCI$7s=tEfc^hMg-
zz<^8M=eB#LK7=bXcL331dog&)7QG6$Exqa~<eQMg*CNDz-C9rjuF%CD=lZSDokmJQ
zxuJ3%A)6ZA#;x^GdWF0A&ozkKxpyTbcgPMp`^nJY4b9Ebyigq@qm(cj#%G^fK)S5m
z5Hc|})lke<Gvz@@a8t6h@^^(0nLO_f!GHxiFAtXk`ddG!>qqTCv29cBM-Bp^g#w{R
zOk>r-4e7y0{~E`1<ZDu<8YJ+Kc*i}{^;Kb;AbdJ&cJBEut^u6S@@sd>?dxkR1^hyq
zB}t`vM{Z!!al`*m&)!%LxzII^8d3k5E5TfeCXQS$LE|>So2s3^Adkk6A@b$Dzn(JD
z-ZYbZiXO;?L3y*21q!A%fRK_+qe&IfLnEtVSUbUpC|J|!fG5S;>40Yya=?=b_jtgQ
z<&Oc+Tlp!7ffaHv28hO?`(P5VbHjsz%-W^6y?4HX@Cyq1&5<9T6KPeiEGn?h6D6vT
z{^^lj%VXT@#32Cq*aLZ7%Y8iWB&rrPsS4#|Lf8^V^h9tMq$ktbQ>PT0NQj%{$v$rr
zm`oEZJS6`1CV?Vaz<veKW^x=}txYkPNBM5MkID&otQy)TLz_<Ro-$pY(gn=b!jr%d
zs{^Q%vvj1`2a}&CbJ;ErXJ_9jNY+0eZbtd~uNH~9-pXy<yFTj6CJ*@55W8T~J6NW0
zLdLSJ`7CXXR!>x+_wtlvoMu&_Ot_2uwU&%d61(%}SqDxl?UFJuY0l4ew5=r*o-Dg8
zz6sb6m7BeQJ@Fs2rjL$iO*;yYviRrfNEZG@tyqomrJiRMQttd{?<t&@G7x1Ke7G+#
zdKk3_f0oer_>q_Na+e$%wDm@u=N*b~I)mZYN@?o&-c=bnRC|$|cU9@{ZSQ068eQs|
z)?Nf4j$ERocR)aZpWirYk;OzkfF6|#EE1;U{dzsdF8uv$dgG_Y$1hll5X#h1wqqVs
zEW{kZupUjxwg@x9DaXPZd(vSS8jhZDg%V;LnKv~xmG`~igLUeS_7Ja}U4cRI?4#(-
zLcJ~|%dJ&+x!rxD>h*0XhpmuKE^}(yRKtq;?)<Gf%4BN7nz#<ua)EDCKLo|NV_+gN
z{v%iDprouSiuq=*Kz&u2bgMpug@Tln8_>M_`+b+Xls#p57W(o+Nr~c$1HKdQtGcTe
z9sn?c-8?hKSDwoizM$+{yP0$2@iRX0?dxyLyxELmPY@5J*CC-97)O&5xB)#{*j3Mb
z2<r1hl3VXZ2VWNn<@kQ8ca%X*f(u&bDz29*95M95=K#ksB#)*WN(+dcirMyy2AMt{
zEwr$bjk;l(OVNRF778Pk+ld2YPBQv6IbRvg?~F|YQ)(*Q*~d1Zkkd)H%@7jjM4RW?
zK*?{6L?$G~K?r;F_%WaPsK;k_)nzPC!N{W6%M0)I&|rjDauKrKC8f`aT7-Q3&#>&E
zg0f*md5AdMrW^g>+Y^pO>U7pfd|$xi0+Km*1@FLK?;o1Q*ZkNYX*4!yy;;#8+cR=1
z;{+o%y*A&biu+ibyu6y;>68O=KTI{%r*hCXYM@a5mJm19$jzpvE4t_P=-}P={;mYT
z464bd`9a-0yc5>*EqfPmhDz4EB?PHwS9(4pDob?dn};`NmRz$tl=EH=tmO$J=8c~Y
zJ&Id75L#M`7CLgPaz5uKcw<G;1TVAzfF5rHduBV5O+mwD@YUWhA+A<4nOomhp3nJS
z@l5kme6t~yV`|CDIXK;uslCL>q0eS$2u*6+nEc1{NiarjtX$xa)$V;iv^d&)b^6gt
zQw`c9u_5Y?5|W(l_Nut3y`UX1Q_7DMxY<Xh@nHkIYb|8IXrBvacrEqn4W|Y%s-qEK
z8e89$YggFr4t^`2?G2<WS>7VOWZxWdCy;wGvPu6%=ColF2r%Axri$6FdBT(Vje;wc
zgs#pP<o!i!Be5_|hK3j~>d{nHpEW=7>LVfhg6y1g;jS>oilKN#(eJTXM|3LM%?t%S
z1%Qy{b6BB@yD0d1AYii)Q<Fac=d-Thk@S!F;$ceIxfC#P2L`Hbv5($IaAhh~e|sK+
zP%ClT*eq7wGLi0aoG)V^gx`vVi?8SXYz)DX?<xuBNtw9q9xeIBPP20)rC_O%7=Hmi
z121CGl6KT#Z3!&<TF$`gsB<P;@9~2lVy8Wf^FL(aW1!)c0I<#dk*n9P30{Tr>RN<R
zE|Ug{dK4O|W<Kv5%+XQEM2<+i*mtfi-4S4)(2$PesS2guIe2JUH(i%5NpgU3r)0k2
zQ<R~lP>9{i#|<yiY(JXTsi(opn|b!d6*l@}d*E#bIQG;{JdC|g7T}-;vlQXV{4nD_
z{@%w}5p(Z;u5B302h+Gdcb8EKkmjLpmHtQ+9cXh_oMLm3k~P=$dlNFed-o1tjMu2=
z>Y390FozWWGTBRnob2tY+6!13_^!~`EGlZG3ur?ptG}u)wf)$VtVOS^WMOX`0mRg}
zkS*BGMWTAo2rw?7^v!T?{b*Y-$I=Mz|5n;Dr+Qf552!|$?5X=5R;oVr&-eQcknduO
zvC2;ttr^Q_HbiPb&L^YC<geqAI%dn=d_6Trb(Wc11UHfwC9*7Ujpo9wnqKbdPFg^r
zQ;l#!Qc{InBPC~#55MwD0b4WC?fOV~)*+x0+fJ<&Oy%ThZR-t-Yw+(sHJEhhEZo0G
zhh&Q!<paL#Wh&fxURr1A$AB|Njpsm{Ih}mue4`hxzw$sE&RMD*lf1^ftM^tf@JPW?
z@QD9#>>Z8W*cZYizz@CIyRouEy52*Uw!#2C4+A1EOj5t9)x7pwbrA3351j)^YaudI
zv(R>aDfZyO195Q~IL8Et97U*XIicDnj-e}YM{P3_J7TPSgYE2dW+bKpQC8tY<pYi~
zAwoHOUd@2l+66HYY~rTA0F(-F8WI=UcSAZgX0l(kix#RC?C*q>CQRndLpLB45jecC
zMFCR*>tRJeh1l3%IvFWe|8u1HWZ{6#dm*>K9Z`){b9EizHgfSFfT*A>LntrtpOkkr
z=<8X^%UU9P)1~n)Yv1;8NnBuX43Fhiz^Hdz6cc|X>7;28E2#7Wyf-16l&HjxQI#ev
zLA}_ySIDnmiA1$N%=6YYsA$Q1!OnMIB*JW)$au$E(mieCzcs>#zGd52r};_MMRZep
zlT`N!4owOkEF4cC&;4!s*sEssWDD$UP)gse^(>*0ZnT4}m-%j|U=4{D>+Sbboxf$x
z;%$Fq&9o=9nCu5vHwu5gN$?#cyn`GcXDd?Wft61=_>LAvqP<qQu5Y8u?-YZF;dpa*
zS~i4tO*urqD+_SE7j6U`Ed1xF@?g`HdW)`RKK&Co;pc&N8M}&1s$Jc3vtQ_<%F7FU
zc{;kfh)7;eE-raT=I{4jU!>x*RLnJk=O-pZXrTfNO9rJNE$_8p*N@=P@)_4Xx8eA;
zLT-(|sX-{JX%|oh)sJGCL2x4JQxdevDM3Y4QWNH|UA%~UVE?e_{;XV==swHctO@(q
zdDc>WVf2H~hynk0TW0F$VW4)#7}erp21th+m$NBekrZkU;I33BBT8ct)n@+R8qLoa
z$3BWB41l&ku-`C!F7p4!!HxIVJGz}@#{2oNe#?w2WF}KS0U|NsEW;&zu1{S@a|xlG
zInf)}<~Wbq2m91`0h?}mQ#el{+7=o30G%$g?zz;u(@zbH2JiwEJqPhVpyikR$hQp!
z6#51S<%h&8U)I1E{+N8;GK=;XgA;}o#d_CaF<}0Cb@AN=03A=o!omV0alt$qpp&+-
z*=I^4q+(gf7<~Ntp80pY(wU@pZdq4gUHP}NFLUSVXleNYNE1xUj0%5|PwfSWZ+n|h
z8VSkCJhg+i^zf1!{lVUr&FBbGER5um!kKq+YeYkb5LGV52st5(($?12w{PF>Z+`}Z
zbpS*Lm8;#3J>&5bDBtnAf~+q9il<BcZ>?Cq|EeWc1XRdI?TP+jP=M$ElaZ;|Q9VDN
zvzBh46n78_20Rbg;m*`)O`mq=Z_wb_mz;0DzbSi<^720!(5O?0(FNq|h6pI(ghq^_
zCOByS-h9|yL-{XH6BN<DDx`z%%QEPk)Cta`9$%ydk4OENS-s>k=?@DJXUyY6IT<4d
z7zZBRFHQLk^tq4uk3;$A9ZG}!2bX^t>2FZfFIeRd_~ifG`j{1k&1QvUMeV!NV!qB;
znQp=gI#jx?@;joX28Oxs3h<n3`_pizL7;z!d7h4u@$sc+$hq(9^n*}@AV5Jvlto-J
zGH>B^nK8WG|KnyD6&Smyce6hwCVs1Lj22W@LlHKAY4-Z!FSL!;F&6UVzJw<(m7;dE
z?I@PrIg~2ba$?3`HsQMLdMJ!T2bdoKcc)C21k=E|rbDc3=w+8Lr9E-|$4%pU;H_gA
zV3PA&r`(iwbSx?&L%DxD{~p>e&ABYpLi73KRWOGIESj|H%ae~4pw~xdbG{5hrt&+Y
zj!83(_wz}n*~mRv@@9vnVut_r6?_T`CdMBHppiWxjk1m5&h+e;4WW*p9=Kj1*jyX{
ze3Dy?*OrH?+FUsP@}MB_kG4K80iYOQ*n8jQFS{4&>FI&(G^mRzWxr=t-322Ls~1tW
z&;R9lj$p>`szKZoU}*#?pp=pR<$1$$$?`0+go4kL<pp7fMMbzMe1DOX$eW>4Le#mx
zJVtA~NzuPN^@S_>UoI^dJ>ydS?NZ6?Q!-VR+h2BirS0U#BANfvllSA3lekyz+@zx$
zneWM3{RZAP@WlPi;RzwCjO<^k@D9wKubJNkBipUE<F&|fUBIZ55|;xCAaWnZDX(dk
zEdTNny23xr7Vw6Idv(1zhS#oLlX!nK)2N4I@SDj1pHLf78tefq79Ar7p!m6<ne-rQ
z{OU1{=})Q9>1-_yl<u$kZd-w7uj40?$@i^8es>ue89^s@zZVHGHboeQ9ATMsT)b2^
ze3AH<pF?4xg_68Asow1>J+uOt6k3VT8ejzsS#_z#;RDhc`g9=8Wy)U$Q4j%W21S6I
z1p-8%;HILAO8<0gJnUdY;fsucfkC=jakS$qaxXTsKlMSo>ZvDqwE&QS`B=3T=zD=l
zZV=)8{r#zKzeE}O*&M|WjITFN%onui@=S*g8`w&-4OOfE&iN^H6dXdzP`KakL!A<6
zmREH>b0T5j=C%P+R#3CMVOj%}0^&#wp~d`V3Q(q<ogENTZ%Bj?dD2e-_D1XGtE4pm
z4L@`W=QfRwiemXr#cLrtTUM|;n+&I&RnWDdFNu1ot-3JFZ#_TEa&I#Gwm4BTnJ_qs
zbIzQd0795~T83WL1G?X^E@B|0!`nR0F7dxV63Gh^*DADLAYpm&K0KVybWmV{iQNyt
zg%60-Mj=8%&H!aI>`K#y<%4PZZ`A+~^ERpY{04_2*KDK$aO9+8gbtedm&W~%wre2t
z(vkU~EL$qsTilt7nercf6D{A_k(L%(P#4U=psG>shNeM`I*s=%>6NFet@`u0?$J}0
zS+GVR&G6-4$F1^6M`seen4$de@-aC`brhKMzJ%`?HOP~LkZmxIo3VOxp)bKCQk>e(
z<1P}oJ2KE7IIo^O#tD^w*|BD`qt01X*VI&H^TJgIaL3B9ep8Tl;HWc8D*!+9<x7Dg
z89+>ti4kI9u^)ED=#B#izNWtMpbF$BFFY14zU>p2gX!`2r?<a9NqN2s*#{&1%>@?_
z9AYIQxua^au3O&T-fu~Xh>G@C8}P&DDrfzD<baU9Dz;>D{DC`VH!K27g6(wqPL|~y
zKCNcDCzQy>*l+GNl4<1Y&twHQJ6H6<BtR)a5`wS@=`+N-)M0|h^d)qhD;d?Us2Bzm
zNaB!Jg-rdLdTNUDu%T6L<o*0i9(CuP8xCJ*W@c8;U$*SG-S@!wUAzD|>ro#8B-&t7
zy<@73?!TxqK}t$_WnHsDyq;#N=H2JYVp#aEk89IT=Pzz!QT#4Oz<C5>{DB8yW@~8y
z@5g{S_2wEkkO=OK2k$Es%bGW0!arDHJEoSr`hh+OnswK{!#$9(Dvb$OD}X4C-?;+)
zSENhR0=B(xrc&x$Tr^K`OlJxHPdW?Wgt1@KIu_n8cyEXu_MV6(Cl&}K_f!-pYbkH3
z*z9}Y{JvWg6V{{edZ0y<L-HXehAmC<ZD^=M`~#fMBxDB4C1s><WMm{dlBXgQ$x}`N
z&i(B6eEhG~oi;k~UvJ?N58zVqU3cbk`LByNK{6q`RG>I}%I}$#-p#!DjWpu$yZ|^P
z<XbN`ZmE|DWHBY0?{|SNydK++WNyX)a=NT<Cay6ZRV*V*;82i601#4%8K32wjkrw@
z<ADUhBR`ENi1+Eg<sTNsZ^NbE_6ZPQMyLJ!{2UK9x^kS_+S&jK`crW#(BGU-S@AOQ
zjJFw%C6<LGD)wdT#}~`>fW~|@9Da*$+a0;5i&c+gWR8a2@xqkX3Kw&YdY*nq*#I8W
z0dN|D@-jr*x>@yQymGg`r3*SNAaC{e^-WfN2>M?DAy+Ptqw^(YTLjs%rKRPMH#q8G
zA|6l}*L1Pr@h%lBs7B}hX%j}y)g4nlsQB@}$$cqJKB56I0%&i6zSaR?flX*X<F%ge
z1`r#ZHOw(Erwj*d{=$pMc=14=!}I3;Wgu<0oa>Z&QGbY7o{TV6D}lSI727`=Ad~FP
zb^=Yzu!ToXl}EyWa*w&bea`wnvLCE$o>8%OKxSi6$qyp$0IW15qoO1mc64YY3)Ug-
zM~0-%0PhBbz!BF{7Q&{UHX!}@aecOaJIKfLfjw@_b>#s<hN(56fyT)I*3`9&>IwmY
zfx1T%+asPdz!NG0j?*9^hq$Y7Ak9nCU)m_V4IK2FAYtFJH7c`aK>7)*&J+W@iH=-x
zF|o{Qppg0$8v^^wKk&oZ@^6!lvsJLWwp)XS&ZG>O+W)V2)1-w0_NY$fM4tATWQ<T$
zj>6Yxj|@U>fjTJVB}zrCs)Gnt@0<$W*#KT5lS@&8BI5JkRtD~c5Lmlp2m`*bTD=+c
zS85f&k+p3Of!J3A{8u$VLD$<P;ve`M43!AZfz?x$yjP;y`(P|r`1qVw0GTT_q>S~K
zmpDyNT}f($C%27Zr-Uqz6hJ2GWuwRTXcRo$9-Hsl-nPwjLVAV&>GD)pxWClK51_?%
zGKaA@9>1UN&6xvdsF0$_4m)%_ta?rd-KVceaqkww;1K_x_NZfm(>Stqi=4|SEZ2O0
zdj<ard@Ph_r}StKVjOe6mXiIvptFnWuW)&itlm4%65!gn;tK(9DKhEJe)QtH?8kd(
zolwyC?S1fQvgB~r@KCtzt|uMz(|=VzbdJ!72nX;Enr~ttEjIm~Q=~NzZ9jW!VW9gu
zoRAy81aJepQk5CLi%dSmpI$+o|BcdeoPb{@&@;cJl@`1FKy9?M4Ec&6Nl8h-qeQ+>
zsMBJ9+q`w5T?R5i@ddO}Ra8_!fuNjYU^NwG^FU84U<FWj0fzs2s|bW_4Nc9SPP5jR
zPcPW-qZIyvFi*-8V1SgGa7_@;*g)#W1o&><z+tLd0%CT~07$1Tx>RlS_ilH;0IbiV
zTx9^f0ha-=xTFOVKosx)zu0@rxU9A<e47xZRX{*M5GfT&MN&YKMhOv=?rxM$B?P2J
z8k7)eLAs@p2I=nZ?sq(}w|k#+{QlPe+y1d1*IKjZ9OJt0`4n<oZf<|<Z<jp1Eg?1v
zober%5*t{CFW`~|5D^8%#-0qAmZ!tWhAjx+(I);zUP%cLOf#^}CuKL$QWO^z?aMQc
z+?Bh7&e=aPQ$wWsfe5wE1}N_+;=<ts%{sqo1Ue7AIxoj0{TQ-0YT7E0O7A9SGC`*T
zrX7>y70A8LZo5fD94E&+<x}Jp_g=ny39xSZO&x#o2b1LIPAve@DMsnff8yW|2fk1a
zC?hhy_s2&EjnOWstEN~OKSP;f0|ViFG_5yOl$#g!JVh2b+dyu2l2c==&@9+yz?QB)
z-92nAgztD)vm-&&BJ~3EGcqKH^+C&4ueYAhvb7o}C$$PGzJ<Vy8Ooq2m*M~`$&sTN
zGBNY(c|bzn!?f6V^aylF52sxkIRLJOqf0OB$Pfw@1=+OBrZAQXM5%ySpF|`7)H{we
z8VtL8A1dKSh{GiuO|yOrU0hsrKAfPiXveyGSLgj8DREFtOiQNiErj_M(1|}w1-wt6
ze?ZJ*!_1AISu~#lOxv@AzH6weeUQVDm6d%wc0e%9gL;+V0+RFMP;sd0+gdtvbMtk~
z3fl3Bi75-!IEippXq*r7NKUYFRZ{u$+#p)R0|`tOY$+#SKRR__b~)IEtve8Y&7K;t
zCWBUi*KrDnOa%Bodjd^FU|cW0dj}Wk{I~C;@&3HGaY<tx0LET7s9*(BnqE52P00|)
z8rbvjySkHIE=&bE#Fy~#sWS1oPF>uTMB!Jt@qy(FDLYq=5s2VB^wwj4IaM;G_wD3&
zj|=8gQq3s&?Hih!N{;szrXDTKb|m_g(6(hkMiE?G3az+?ZD+38HeWimw;C1u$e>8;
zD`X{;ET0*(3)E;#d1i{BGrRQ)QaCDd7DT^bQoVvhe!{caCQu;br93$^11O^uV;049
zQ#e)T#d})X+H0g23B?iSPsRhZnG~3(A3FGR<mA}e_OZe0UU^pXv!tJjYuEvtYB7k8
z2Kc?+B*BFYSq-9&T#@(5N`<WO-!88h@W5Sig%?x)_Ng+=jDDqL!;gmyrw{<XoA0}%
zki$`@+f{w4iItM82_00<{)2)yQ&0ojoj&B$g{>e2UZ4Wonsu{H|2kD3mnP)k-C{y7
z7Wj5S><sv2hHPBj2)y;PSt8zPHzw+Yot-VmJ|!!w1srJB_f=3>FEpt+z}LV}=!un1
z-}AU~SAn|L?NE&7RBgkk13|)C)lnjztzXa9f0CoJUhuAIg2(;{5&Ly>8-6+}Mx#)W
zcoV<>?=Oo47p!{Cb|Uce3hLP;4&ao!1G@@FlDlGqRs+UxKw7tYXnwOih<bOkQ*z4J
z4qVE~=6EYzE7Q2#MvR^#Bs^y9fPDnj#rXlmiBAXC_{;+E2XCRLF3_9uN1W(QFNdkY
z21Wblhd?ZY2(Xh|taQg(7b^9xl&8pX+cvy(`ti#iBPq|x{X!?2fve-6cDV`&rX27f
zaX;|U0fmk$;Z%!2Sd^i$)#di6EUaBTw}3GlN3CG+>+9uyAM&$`CU;7ebG8Ak6CN~c
zP@;G!*xF_5p@&a^+NZgt<zqgY1VZ~$jW1cR&GrKh545I@8)4;2-#)_F_E^P{^E(}p
z3+>>b<gaU5dmGWZb3K`=?Uz`Qxv@-!ik=T+q6fe%fLPZp%yIMw^3qGLNWE(ywbi#h
zSjwMDKX(n$fUaizMbA?S9rOWrMxBNu(a{Xw$;*4*-kRgpUhA|jc&ZL-?n+80h+1|&
zblz@3<w?;nop>eqn7`Dl)Jer?cI)=``pb;bne!+Q?N+XPox6-JlYst?z}H=c8WUZl
z5MAcn!=eww$oj5&F6U5OiLb+KZ&${GPwUAE1oPd#zNY1}@)<{)kKrery4#D(k=Bjj
zqT&<Q$Qhc)i8#V@D%C$P`Mp55tRQM*>JnR<sd>S9Y1)Os3DE!B&r=A>KSp&Hm}@Gj
zO$rS=Y&<z8AcaNO9mcAY<|j%zI>h8ZDH(Mc+UNGr+!S%;Wh`~vU33re-2DxWG%|QB
z<9FRwMkfYN*TX9kVq)X@=V(S@b-MUq^OAGiYk-zKM(}38WfMFGO$)5Ib*3-H(1q`~
zagI{Wh8k>boP7<_^xY6OMm*7isN{2&fiLQ&Bxn-3i7-6Psvm`+^1g9Omg7@>AA+im
zi>}7|3}gC6pl5>wO_)zLBkkRg5Bo~gWM`j++n=bAMNEI8lI&7dAL0j(Z^IAZ!NnYr
z$&cL&ML6832rJ1}ujPp6YOu)Rx^Z5A@AL()NpKt)Tle-4C29@g7TLJU-_Ij3N|w7*
z`_q;Af?Ip5?3+Rn9#nS3>u+HUO3-*W306{)WkFp^J`6Re(MYqqG|eyC)^hqgj7UU5
zK3rOopqc;E?=U`}e%Hk+9mH#CJmIy!{(9|GWjJngVfNOInPFdLbu-<vpYO?Rtt2aK
zwnpVP8p!i?F8nEsCSWreD9mNGSf7v5aPGo|5ty^7g#9MDT^tp1^wwaeUrm2hzv?O-
z2krG#c{cex(pRBm;_KMRNQnVssEF!9{53=ROYM>NvgdUXw7?!s{j2c*-w*`yP@Hy{
z`A3p$w!<7hIj*D2Je=Hmp>Q5uz~#Cib?XI0Ek+ep6jO?@HQY51t+;eu<Z{CX^4L3f
z<|M{d6Lgs;>k@-B%;(T$9<Mv_b7)XDC1aJ4zL5>)!MDcvk5{0qcwFzIZmm{E`9F_F
z4AS}kCsxRnUt6vjcZZ|14Ej@^cgj0H*j!Ne^+1!u{1y7JjKP-oI${+3LL0_;m?9eE
zRea9l`WKgM<b5IJz@s}jsu8iFtq&MYj}M+WvP=#H&HUB*Mu#pXL`;Skh^wJ@ckPw6
zH1aAETHj>6O9k=(z6pz33j5>h43v^!jlf_~TYPudGvU*9HqMYMIVJJhz0Q>pvifl&
zgzGGS>UKUPJx)r~T@uHeSAs$#g>Qs9;fET$_&hd+6*~76+;Z5PhM4afO$Ygh-XSS}
zx9PXQ?3cjRKd|*9W51b_BKYs_|F5R_78m2c+0@W7);jchJ8dL>q}uyYEUq^9XXK~!
zOP*HfmdDrsPz`E=hB_JQx<)%GLjok&b4Ri(-{h-wO4;doxtty)VeCIi)3a$a%NzLY
zDp086#_9a$H;1We^j<Z5txKQ5{weB5%_ZuuOE1c(=CnGXI1{)v3<nM`>zu774TRVz
zYOIQNk795(?n^zfwfCN=Wfr!ou@n73U7FyLdoR8J!_vmVt&!l5?i37K49d$ZmA8dU
zSl-+h!uIOTwIC9WOKwP>yEW%kho8?hz?;_2Y~uF0)h$S@<Mnujm!<g(o(5PW^&U)B
zFui=p-{&IDAS9UK#p68fFu(V!*D=edmcd|){g~jP+@EHMv{}7LX{%b^<@KyG{?t!D
zAM!cxe4i#G3Vh9AXjGilFJ>Ip`RKkiN8$Z9{QaUUo5!6m8!LLwcU;RWFMeR$(C}0L
z)ibJoj=6NvG}gr~=6)O6ZEV9|+4mf7kq+1EQ0*;05_uJmHW?H2xZavbrJ{Xjugr)q
zK=4o9gI<Bf7L8jI?9LPkjju|Xx_s{wz0c5_!1;qcAT+XW{6oB!dd9+A<(G{;0_9)0
z$$Heu3>|htto0`(M-Cq=b}%Kfr?my#UslPDd~WfLY}&|XL#TzmC<!ZixD(5ZDB`(c
z?eZ-x!9UD=KfL>Y8Cb3@3NHVmA(xC|Q|l(pFZ-Oncp~F0w>p!|Cw%W}`$CoqR_&eo
zR;CEi<zCae7g_fi7)bK<9?f9Ls-Nu9uj*F~rtRot4U?bDKV;`Ss?+a3XuMe7_VM-Q
zg<e`q;ig1iuR1*a#%>zLzRwp*d1sG2R;&+o>u8@x<dmi|H0T;t(NHk8Uu4oSdt5(3
zd8E2bG5jEEkZL(bDBWk?!kH*&xSr$XMANtMMYDh_f2uwoyM>1Qr{tUsv1M;i@YZMj
zd%xzGiyb_lsNExd$&Dl6N7~t8zcn)9H@lAV?!;+dwLdZ@=&5tQ^>+2kyav-qCn|<?
z!#o{^32wih6}MZ<Qe+JAu~=M6IHt{MaXyb&Gj;A~wnyczjAX~=VX00o<o|KXxbouG
zs?R9Xaqq?jYh250ix(!Efj4jQiWaADS9Zbm2|}dJok5MvJttG+t+kJ0(C1#6(%Esd
z)8&6+)(k{;{<TfjFLJ(bGjDu>8m5wUeSb;l^iEnkfxA^}7xJ%ZQ9L-_pU9N+upY0#
z=nsjA+V6R!)l<{oS`*#rf0gz368Wz=;*wORuzh+&nHcv5*+E>eU|bb9t|7ZERMrdg
z>QVH5y_k<m9)&Iz$hSmq<*3<}&r$1j3@j2ksh?mdKG0+<y_U=9ZA`4hzB|r&tf+bZ
z;Bm8q4G|s_fvILSjPxx{4~c(`s|TMdyj`mq>+(psoi`7cFTU;};-?8^iq^VHTLxlU
zI03GubE%<M-q`bquBA_w*P}XcRX7~8(XDwkec3ZLC!tiOi@AyO-pFgA48Orb4c&)h
zOnXIxBkuPZN%G(M&TOc}eoxofsp$}^Eb~1mi(P-v*P6)Z6T?7Qr6l8kxAe2<qabby
z5s@xsXwVoc!QU(Y#rnZ>l==0cPqXcx@Gvj{>29LsxdUf$IGgP*le$uVczg$GYG$hQ
zV?A474h<cB((C5#G>ev1&c&#U7&rHQqxUR1O6)lnUf=JmLk#~n?{nV2Z@fBL`!kvT
zT2H1ghx0VgQgcI#zPUYCk=M5TD|*^=wc;CB{q8GZTb3K|`&uQcid{@2sNZ^oVv%`K
z@AB!QI!-!#RGV)4O`n<0^JzEHhm58tQmM7<>@nOL%l&<Z&PQuK@qxmUWE_`^*{x2d
zj}~Uq=uAhryOtA1sxt=5q^#p3Nd&R|Ufi{O@~i)Ad9A}YvnIvuOrIC*ELs|o3dWm}
z^#NPKX=Q_Y<KQ84k!O`Zd;z2aP7wI#<a`<$w~iwaklv>Ih~2q3+>Lpg3-cz?rQviA
zBbwN!UzR3mDo7e=U)>IXB}OYXO+~a6@0Iu^hWpOA<s++(-Ng>$7Tx5sg?g4;*vqVn
zTx%=Yt)cp)efbrSubuP-<{Hir=8;b8T#RV8gC3j_eKSm}c(mw;(t}AElTBpYvz93v
z8%kd`s#y-)wzC)1GI^t*zw(ZJ-HOlRwN{cn8dY?Hdr@;;RB*_~h~!D*m+wJz3v@3X
z3u~$^EiDmoEr`N>oFs02urrvYS+|RWxd!E72uhrtyTR1(A>l*9F7-YOv1ZL=oPR<6
z!1sh;!4W<@#v@y=k}gUn%<k;bDm0_~>DIAsHpQ8#>8v+yBlvOFg2A&wZz9HeF){gK
z<1Nt)XK*O>h{&iipWxlp=f2we1uaq}LGhkbdu-Bif-m&Cjrr#A(o5NQzc(Bd!N>|W
zKi;ZY$a<VXZgDGr*M;(IN9#~kd_>(Oo$*Cgd&9XusF6a-r{QN9d&|hzk+#xor=TwR
zh9`%=lAmRk?Wf$YFqchNc-;~;Zn{rgrj9O?c(Un3MM>-G=q36KmXA9O=8Hq$*uQD4
zu?I26R;7N)ygj_jb#Q;Vv)hg5a%EB8i8Z$|_D#}?GEJJoX9w!!?LAdxI+3$k#MAH2
z|03ld*IfHZB7&_gF2zsy+=9Z)196ynMl`Z&5{qq_b)dnwvb9I_L-kVXP^kfXw5rRa
z#e%8_*ES;~8&TE$-rH)_KaR7dXzI*R6`ehjH9g8R`GDwRVtV5+xFL2|biar*9<(Tf
z&o3iBUa)e|tpy*~g!`+bs0=Jo&U{n$OLq)qhbZRBbMJdUAyAUqU7BZ)FKege^mLyw
ztHQ(yb;zc^OBEav=$PG=6Q&X8tzy?NIa*(#H<6;Bx@jNNq3gYk|F{+!Kx?G5h>Tp?
z-_w3kq0oo>E-al|A}>C7Wr)q9(w?5?Ua#S-KsQXgW7quaWa^l7+Jpn&o_0w?VLa>c
zI`3<k?Ti?V>9J%LSsvaF=6*EZlN_J)B6IsYBfX|sfx_2;eJ76a_qL7W3~4@(WlRJX
z{NIF#A^IRjBu8=g53aL9#z;#|ed2B1req3WNw32;<hfH|@@=mbL!rm$iHc#o!u$Ch
z4L-)&J{cIU?!5S1y)0ob@NKu|u-v-7$dRspF&s5SZHTew?Fd$Et}Kce?!LF!^{t&j
z*xyF;9H(IA!I~w;fs6Rr;bzyvI&u;NCW}%lg0hP`q5FoEw>-OEy!_N}*TP&*H8lT9
z)6}-XrEld+`uiVa2FAh*2V+{SI_uUxul4yZemlPTA~Og2TWFY<We?X2Vf*K9ro<@c
z_FSqRDlmWd)hFxc=oWlbxT6jqxvy4*@_i#I#*&Sk!49?7>iMah=HeKqqm7M=rQR}r
zT0I?#!7oDZUsiA?NRwCKYnX4$@QPGgP`hUL_rn+WU0(nD^V5wO?1m1KhtoKy7&Lzl
zJbSZn-jnAt>*r3lGA05#(!XCenYvT1ffif-^4?NX2n)xZJHL$0`J$qH!=n->I~&p#
zf-_><te{D@#5|*+3x4&2Fo|;xT4iOWK~F}yuXZJjqg)UKYnO~%x?X?5jroGnsJwbh
zcU+Ir5Gjh+<^595;32e>Tnk&_Uc3ir5zk#VJN$o8zCv~zbK=mii?ZWov(w%5LZ$0n
zO#aYF#K@khvYBf3?-z#N7&bw_G>Hn)fcvYd%({l{hIzc3HQ$N0iZyQUp>!z}mQeNc
z-%pfmzs)aKTVZTSJbh=`GuW!hLrb~whHhAwBBIW?7NfMbw0D9FAps~)TH}U@+(SIG
z(Wab|Kj0#|I&N=8W@S{mVCGBn%?!PxjIV>){JC<BEA{)F3on1nevH5Nv2N7t%5>U_
zXRv5kV^cl#&UmwPd2)I_qPbu7a-KHH%+!=G1z(v)jd#D6PAHLz%^2v>V2Hx!XD^_3
z|6Y-nSW%_>6gKyj1`FfHXGy(tEgGR9;Uj@MT@hJ*!f<idoQyvqyf9ZPf9uGs!*36^
zgZ0w1o=?d~%pFE%4lFE#WnTU+7mdz%IfPu_UgZ7StV;-)(8G6^sm$2u&)uS7q4@UZ
z_vEvIU9APxho`3}Zl#kqh7#XR^p(8Nh&q*wghRHRo;H{p?*)rl-TJk(ozc9vxZIj%
zVT`|w4f&!ZYK?CG(<W|Dcpf|`MP!*iO$R|L6ViNZlT1)d6^3=Oiy5Rmc|*N>@iW%W
zUyEVCZ}Pgx*O2ci-_ngqRJ?8E(BE@L_cR7x<?!B!^(N*`QZ>W&g?B$Lr`aIpf#|PG
z%Es5M2*2Xmv%P<Aki^z5ZZDk2G(axJc>SBqb<Q@J?)+BxT8hw*ROd|%v2i=yi;R~%
zgNK-PkEFk;%zd+j*&gGG1B9JGmfuEuUpL3F2bZ4zEA2uoORzO7XP>iUOoT1lvu#ZJ
zfSKoyD3~9f1}c0^ZSosh^N4*-O^o1sK3eBU6o=Iov39V+nuSk8N1a5S$gy}wYG^D5
z*ND#z&P7oSwc1mD1bR+4bsYctj5@6*xyq<5;U9L1RV|`&sx<6tZf<VC)azT43PXx_
zra7|Cbei7dQ$)SE>F|Y(`bOUuVooZ&d!d6d>=rR&!pGfJgK*lYz8&f?{%ZYGkWZNU
zUx(h6H<QVeyrbB^7j`+;OQPp-xqVddad61QhS%3$yI-=le4+9wVz!6ES$nCFv(Po<
zJ<*1_t#JJ)-_lyL75;*z8Atf}@Y8lx=)<wZ<vtzUQ;02$#yG9KV4LB!vt?dNtn)z9
zT8HXoPc|G}eNywurwQM`thjx)k5Zc8dap_0w&1LXB^sjWP;u$^M={=&`mx14^Q~l-
z?YY^IT99Uaq<(YEvBJ|x<<I)st_H$m8t#TV>4jEPBy(c#MB6CdrM%45furXZmQ66<
z`N{M{IDs&jn0_AlIZjNLK{%gRMv;E5GODU2Uahoa9IDjhp80YL`cf{g$F2wE*Ldw%
zrU}U`+@(y}YgUy?Z43`nb<_NYNQ>_|B=2Q^t7I)dM;>&WeIMyGr1*@ee9J`9M<p0t
zQ0eun#&!V|k4?KA`M2vh1t>mPvcWi__tfbbIq=t}p5}79^IYzL?ZBj}#enxSMY6Y5
zU5|#kcb-|C4m|~)hTDy$v@IFlqZzN6t4(npder7pBt6LYbmH9<TqUX^xfn^z%3`OR
zlV_;pX>LTnpxy$r7`<R&&xM?`QQ&GV5MU6bJ`NcyD(m#Ol+5R>Z+(;bv~6i}q&wh4
zcSommX1paU|7JgPzD{?<*Ia3ga=IuU3yXmc<HdgCl(r-R_ND>;no@g=o22~1dyoHc
zCXXh)VmpwhzU*-~OSgmZ3k|vW;CH9iO{Y%OpJ*H=*p}QMSJXT;u>`m=SLWd4Eh_s&
zRIJcpjP>g6zN(VIjglQ}TyGJNi&Fm+_Zy^H;-V3z@(+4db0r|>)ndM8ng<#i9OdIn
zafkYJZ61cawMrj+Uef$pCiqz)rx%Hwp2+$QRe7lZ8=gQyy{ag}4wYAFif=UHG<KIO
zuN>xFcysPwr<~vM#lggtB!|`(1DhQ)N7wjO`IIyr{au-UJ@RSvu_5p6={rrv3I)jp
z`$CM=DtdD1S5xnm+(_ZSTj<}&oD^Moi;szqis9|BPI<Mv8_gfWmxDC-r`Ue<F>xI5
z40v`KspduBH=yeGS3TKXre6uluE8h#Zs>yNPuJ19hh3#~61xAr_UmhDh@d>`7(g7x
zYs1y=>T9ng*?kwntNc>(fTqC2tR9~dpX<r&!K3yIHvJHYVg0;u?zWZx4SAxW<_`%3
zT%BSQk))oy*M4pzVTi|E{C8i_9cOf<ED#sAqEOd;?i_ykIoxQN6>$`~(<xN-PAErv
zjj;P^<`?!fE!9XJm1ZNAc+LTb6SyNZ`pI2T9~k8Ay`!aiktoN=<f7Kt5x~LmX&A{7
znflHjB2=S{SzAaLEz_B_;qSX1XE5%obTG$V_FdtK$weHIbwlWI37W5mMMM=D^xvlK
zc4Ay6ledNV#Zm89ILk7<DOW>t3;P<jx;$2}`Get42leHkZBN4$b_Z2e{(E1xh~>UB
zYFsnE_g?SuTNR4xemW0{S8}$LYbb{I+>|5uS;>sOhOeYkkcKoe6G`1yoAHiL^9Xvy
zsy}*y^NUCz?~h%BW~l~eq3kxMK~x@N-%o?ypNt-to6RTaETQ_%<iZJ5?@@?#=cZLp
zc-dVWHV>1F@!=MxpNOB>(u|K7cIM)CQxA*BTp@QFAH^~B*3#Aa9^OUy$FQPx@&q4u
zcA`?ful4cHwG1`bP4;!La=zp=J{kU)M=EqLZp*U!`*wb;{lLp9h;zg<%!PI|moICn
zo(mq;E)YwLXHLu#Fzbw%-GXjqP_CrH{KaNYON9SVks{yyu||qsujYa%mc&+qA~Mxf
zZpCIB>+{Oie%a6#c_HeLNxL*;pIWuwFd}MIN$_bSmTMuu7s+O#ny1Vy&D>!1<MrD<
z=iKk!MlVZfW<Or<?%K|X)7o>Y+Ii_~<z4*gr(lgT#cY3x-I_Kb@)Sz%Q9rXOs-fqf
zhu>G&lh9OCo9S}U`KS`_{Az#p#MJO-UWZUlwWimFJaV-WPnj><(J7f)>VA(?e@)7E
z$3%xaj*oi5NsaC>X0?YXv(8%wmDa#kxG~2^KaG`&fyz$)p0vdy3o#kYbbaOTuT@OQ
zQz^MA(Wsv=9ynZO=*=;EX7ZF#fADZg2T!zb=8c=+1YwruLzF*uvge-mT-D3IQ?1z^
z5Q!Yj&FFvk#nX*0FAN%&ibTp3DY7K=E%kRHb~cR=0aQ;IHIqJ=l+ym)#82;(m`?Ea
z+wc2#I;c|0cV=3_-5A?W53T+<PcY)eAc}eM0mRsnb|N!;<zzogdIq`GmB}(>@Wt%H
zjNdP|RP#+e(?h@5j%QF4w(*O?_8&lE81|Le#Jw9%=Jwqy>gB`n394ecp-lJE+RPg0
z#98lp-&F<EYvobOPf8V^mpluMu`rqZaU5x7?Fs(aK_13%9e<zr)N{eHcV1wfsW6?X
z&HM4!jEhz@myIE)EHknN@Uv+7)h!(R(HuSxO#?f{XW5=-hn>f<x(6lZ3#9ubDTMj?
zHkrrv2^Jz10V@96apeu2-fmBWTF-Nz-*GPFW4~bW-Jn@y0wS!U1=NxG2g2M($CSu_
z3JY!tuJ=I%key+$+Q}(2JW$_h?DnMZpIU2v0nQua<hfUZ<z^eNn}+@&-Y%s|I%BHk
zFYn}Z41oZWk--<L=WUB8_gv1lu{P}Il4)&em+^?-?9cD>_h3ZRNi1={hM0Qv%0e2G
zi-W))hSa|^TmK5%{hy51|2=7^wr9%m5;*H6uK$&Ltl_z1kAx)UFZ%eQ>_2%(Bz`ur
z8YFdeq?_*8fBiMvcp$I6g6?`|1bE67fQyyGh1I9^hQW{?z2Gsbf=HSk-wqyd$d_L`
z+-SuQ9#eGH(%L=kL8$y(pmwLsj6m25fYq1-1=6Q`*PUx#gl){1>w!riXd#A5Z10XB
zmz-{CFSsb-Qt&!#G_!Y>Uj_Gzv0_N0y0*F%!o^*I#cgm0QyHqwX$T4z$x8{`v;ZGi
zG(E2l1f#=cq>71Mp|E0$DKW^Q*DHSo*$41LdnTjCr)xeE^*T`A-}s0>0G1icV;hu-
ziey7Lf^G?Dg~rY}oaaW1UGq;9%}4<?aMA)rRb$%6HITc4Bw@V^3F+cEsrvF-9fj`B
z_=@w1J-F$qB9~wyw&E9D2tYIg6ito8M@;~k4&lDGi{q&3CJ@xCiIJ%fq7mP{G5Y-M
zI|e14oScBG<&5o;`HKL!i{z5D>dM>$gpr2itx3L<y^E^n{(khqXUo8_x8Y()Hw8-`
zG||w|0H2lIE0tk6+eTSNU~>@><-kQ^kB|1LCTo&K;nyEqQeQ?eM|pTSrS?11;;uWV
zi9;kay8S|trXLbCNFOj&u1y1Gim)KoplCM(jBlLEc|{O$Fhd@Fy7~7Duas~#rN79E
z>wWwRs3`XlBpZygx8;u+G2&S=Kf^$ZsY|UI1Yb6l#p_(;U@r&y3n$W1oWF|tc29|V
zTI~xS63_b`56&WD!z@Q)*F=TV(?IqG7g94$A}`Lc<a0<DCrZ`*7;6o1KN@VwAhy3`
zNG27Bba&)z=980lqfw9&#uC;282<AIqtHrlTh>j}uU249Kw16_$>m<jy(WDkO|}c-
zxpq`%-@0SAI{MJ3vvF<?Y%|Nbkz6GH_c!@0aKGHJ6oVNMS?Ve`;d9wNIFB^arqz<=
zG6l}6<^KA{1}ZA5tpHmhC@_Hy9JfB_(#irJ2quIamebg`{Cs?<@&Wj6hAZlvgh{{|
zc?6In8QZZ+w6fMK!^G2@K3NfOq4cN0;tMX^;5h&?S=yE4mLK96yBO5rYpqUHFaRXH
zop;AB?2kZqSm*AzgopR2aeHN?b*Hd$p)%@w&5NrZ8zBWsDP3~)-9QgXv<!egOTN@@
z3*jaK#&-a|Hn||9!gYi7&rufsY6<K;ZmroAI~BV*8VMroL$_<(R*&_r@41wmyDguQ
zW=x%skPt8q)@ngzLL#obLQ>$zsZi!%tB?n_jAa8?REQ8?&kN4L0Bh@<(3tNfC&hGZ
zp13zADj2&P)dJJ+2)$@s(0vdp0G!wQHPo)14UL1jfqbSFGcLFjjS#LvG{tan=C>eq
zys~=D{XH3HP^rwY(}8hWaR8()vLp63W;TX0Rx_CE7;5br8S(>+LPJ7ohOpMB&H8in
zA;6&K%NS~qdnNl;tmF38AzLtP)M<@z1WMH69i05TQsv<iwRkYMjTl0;|EuW!A>m@o
zL>Q~OHzcZ*%*>eQ9QWsv8p=WV`AkFOhP>J4Y&+B(NWzc76!khAwTc-U<5~tBXd1G?
zYu4zYZk2stRMa4}<@S+FdZI!z1yLn1`*RoKAS~S6)HGR)<;>N@j@)?mKFsy?b%3Wu
z#^n>mLQDWG2lnpcp)SSrDTy*V6Xxjw8lhm7^_ed~Urh>u*<;}wkRSwF;l147oD(p?
zCb{>H-porKTZXWR7!hdNo$%)~7<jT=1Mau8`5Ad14cMHO(1G8kLj(491t{-bUMY>!
zQL}0-5)|*uiM~k3LG2mhU@oA0`c|YSfhzjUl1Fw)Pa?NL`San{p`5gRseyxo!`>sn
zX6IrPU@E<0YJ?L^oInB-Gt4ocM^Y`6r+3~sE*K0oH&KLw+qhjCAb#tP71vHnI=a#}
z;tYBKeGtU}(Fz0MGsXEq+nMO(<Yb53YiFbn5<vkb4qTncJf~b@!&10p#!<fn?mXXy
zt%q$rbJ|990%aeX1ozxo$bDyvE#nP^`o8j<Gi}fZluTFX<yO<5GCM2jF;P-dx~`xu
zpE54U<sK!Sr4xSK_0Q}E3(V8j0E2QqIT#V00FNcM+#A$1G=X5zV7%6k?4m(VQm=Tc
zL%dvOFh?K1P#GqB&;kXXd`U=X>-h!RlX~Zw)>ugsgaBobTuFoGe6s(*iu>LKt5Gj=
zu!@w$S*;q@tNO6I$9{w|NDuJ7nw9EM$v06pjwgm;q-A0c85@9~kT8|p&#wnjmlj*E
zd^w?c>3e9sz1TOo4OWN^OBEIT{Rp;eeFS0QYixKqzwVRFkENZ;Lvsuq9GcQx!=7nw
zm&h}MEb}Uh#yMMFJ`kWNapTy!1)UT;S;zyznQ;WiMO6cjq@%NQZeglEkSa&JA&6$O
z`~*a0+1c64Wd|k}kw@r8plHy>bS984DP<cZe=CNTKY|rp=gzEFfz+W0s=zYT0*uqa
zc^Cl(Nx?G+^>E=f+_^XJ53x=99&MuhVg@8$7g0SC5s^=sMB4&cgM)(*%?-_IYb}fg
zx?8RU+&?>HvNQy{H7<|Xs23fngz+%CfxhR%tr98hP89J+r?Y0chl<V!ShHsw0acxF
zTmZyXMkAw%wIY%OQgE9YEMfb0oX*EQhG52g!~UB7jNW@Mug|_#6Yi!Z%tKC0668dc
zU|=?vm8MFLWpsvtscyhNBa|hgW*+AMU*BPP)xPelSu(+Lxu}LmVzoRds>%f06m4I9
zef|6)D^mT#I=<t;=;-EtkVif7X^nZ%NOH^8)>g@f(1%H4Bl-gu;fnifcoT|f)26iE
zKpw-$g+bR-B+dyZx@8{j4ju1*CL{BeF9UACUC8zs7$QWXsGz==rdl5J3PzuwVeCD9
z87V1*w`-!Y7E>4KJPZb~FheWsU@N1ksaa^{-AFVIbDP&)xRljzMG7Nyr;?G@A4?m&
zsy59)@H%<G?{ylnuE^9MEMT$a1(`yOp})U>l1Hxb!2N&K*(%tQh1^n-{jkD(gPS|D
ztN_eI_R8M8fkA~Bi@U31`%LOjRKmbf4SaRKO2>Qb$MS^_VzEF0#S|12V8;AO(9(RB
zoV+Ev7xXHQ%Y%jeglbr4{egt*Ko8jaLaTL8*Zm3DKNT_-7YrFAuOdr4szR{TU(7T(
z%c?M7Xx_1Ol;QFNl}TWe^cS=HI40vtx=a%5{Yi$EAI<CRIr}(@i7KH}ya$Z^0bs?O
zpP;Io<`P3e2lmdV1IxDogK3W%$;s!erkkTUE$cT5A$AL9UHw*E>4zi7+w3sJ5S_*4
zb$`BTtBMOC_F5xF^QvJmXjl5a(<#OtXVsAxs|$<8l@rlai-pnOJakxwDf7B(<h5vo
z^C%?gVav2eiez{;XZ2j_yd|HZbalvdqTarlRY<-NbJQvy4e7<qOsumGQw5B2(sonj
zT&AW#D&dZm=RONRKTt9pmi>x<wL}AwVvzY)^MnEe3-cv_fNC<EcsEYr#Bu@MjFe|d
zxRDpsK}V6`Uh<HRx8^6T=7+%ff?~AMNcxeZ4`t#)9+C?PP@+oD--0o3(vxxRU<KUo
z6Xy<n226?>7#Ms<0_`eP98Lqz7Y?JVs~;OoA@22D+kx&C!ZiV3kgNUU$B&%o5-;m+
z4fH`mmk#%`2j6QzYtXzRD5}Q9dzu18{WJ<h`X~GrX;|SUVrB*pWx!-Kp>*+$1AK>>
zB9d6>=H@1BTC+kwi-Vz4qa5BdvR)tmvn}w=ad2Ei*r~&1!$AG+mOX-tGICT)Nb+V~
z2T-Ku+ZMVR*82@J*9KBC7i;QH=PjgqG!rcTWPE)5D#mB8MH_k?*NDFnQJn3ct`ik7
zAl+U?_(IFaVE{(S&MqDJ^LIgAlt%NAzE;2?p^v`Z4Hk@m5gGO0Md4?J@0Gm{n5^^h
zjB~F~djQz|!6m65|K~>p>ahP_tkHY7?~`TmpHIJuqL|Wkb)KpAC$jw-%h@K=0t)j9
zfwOX!AVAgM#Sg$5Bt&{W`q7|k{L246$lWQqn|1g*5U~GIbQc+7#;$pWKmJ~hNddsx
z?QzYsO~NEfJ{mt;0c-~K{^zw_@Y=070CxYg_yleYUGvKS`*3t9RWYIFluPOE88wVl
zSYeDTb*V@;wTI!KvPKmdfg*!o)d_K68~ivpUF=FUo+TKoh9YCTl-on@xG7!MmFiOZ
z;RdUN+6TSU9J*Z!GE&MI3#uCi(x*GDe-ow;y4ZgHDkyI{x^yo2`nug_0&?ZK>mm<-
z2P-yZgJ*o>-=n^{e&w->f6P7pFr;(0ZvKvn^5UN2i=-&{F4xiiiT>1`1)&AhP%b5W
z`W=DT<v5K%n4n7_y&?GUJAy&sc}lb5xMJ`Jy!j{gF>!`EQZgf>%SinWO*oL960z*(
zXptUbiv11&`y<i;y5k-d|MBsw=4VvxrT<TT^r|A795(iUWeab;PVF>SIxq*kMS5f^
z_<yVM*a!t#8+Ft7I9|G0I4kJ~&}N-PU*jo}1uU{H>pAXb>TElu<d;?K{Eipzeur9(
zK-B6@4HRD!0|FKfjpimcX~TFwA@T?2tB)6ldyoE2^c3v>l~-Y#-Fm3B(pK>~jU8Zv
zywnZHXt+%A&a#w}j*t!<m}{rr^KBnKQ~<<m%&Kw|K^c`k!HsU(3JUx_e08Oz%`_ve
z<Yv>+X0xQxS8?8#aZIZZe)mXk=td7EfR(-^DDkN)I(;`#zrNw;-b&Jm@r%!tsXgZd
zlO2;R><=tPL(@Xfad-1(92GRBhNp>(tC*-Xaw}LIeD3fwUI<E8V)C*}+X<y`YCn4&
z1MznkoaeDgjxvAuHlG{Nzb^rR&Hnf@KJ!J(5561h*>-TY-w2G^Oyv?lP^}bKu2d=|
z)6ahV)OA;`ZrN9vq)aw)&hf<`pV4;y3xrzn1!(b_57bnem{=ly5PlmG$8alTyW8`v
zb|}^AqCT_RA_E{6FISqq{rzIw^xrti%A#8a%={i*H^(O~onrxpT!4TDIk@69wXwDJ
zEmJ?9Kdf{5kp+iIu#3f0CJ*MTkyVevNXhRxKw?^yE|^iZfXw=)N#9K4W~f$>R)dpG
zPmzvczldKWNv<m41v$*9VdwqNu@@7m69XJ$AX(PB{{SFOs--mAPev7A3FB|{JdWYB
z<lS<(-B5Q5uI7_2=R&O5+B0D|ZlYzV4T$8tZT-^hnk5Ea0CncCrtTOITF=iW0}-LC
z(Ykn~&t$uZKs}eF4)7ZgFeYhakKQqGgz`_7uL5zyQvlh_;PGJSV9Gq|=AI{W6-z(N
z9c3fShsc~cV#pZRUTAE#%tA8+QQfv-$^3f`iF@ZSaH$%QcpT~Ka}p@{d#FuCa!(YW
z|I*`Y3gp{JTbp2{u#60=*D}KGWG0g3oSj*5(kXqPX82Nbz_&}T1#$!nOZ#f_{k?O;
zPtyVi<KrBM@d)r=S0#lI1kLBv4FT$_DlHWd5!DY_%`^#$X_2@t6As;7vf_grmE;Fp
z7YdmmAF8*LOp&rj4r%XU$0_9{a*@ZpB@@i5*4MU6WQ70NA($~Ff`=oji#~cVCHkVM
zo77BRNn_z-a&C-cK%K|=#>(wwWdx}L;zi=LE<}QgiD(+A+v*~Yb&HKk6&%fw?kXkV
zB)dhH(L@<GttKPt$0rzH*$o0x+dHGO@0Oz>vvy12t|89A=PgHt%zIuMXzsS`n{!fm
zl1Ea?%VVw2oX^YM+5ejTaPNHoO;stI`J5BMu<t09QAPjJ&2-f>R<Im{CF#CrNESIg
z8bGU50)&q-rnJ8Q7BrbIPS_TVVl(@;pFeA^5*UXq0G-?Y^bJ~rLn-+}u3FQZ!^1dY
zb404M*DlOQ>6)mbOpwg%dj<doBrGm+O7BnnP1439Qs!(e*pZ_2g>DJyePu@682lbP
zH4d@e^tr-xwxxCDb|t|0Wn&of6f9jQb!lW~Pu@u&zqmuZ+h5UJnw1u~7$D~~IHlQb
z<8ZPzEV)Iy!}!(WlHub&6w6pm>_IF^>D~QmSNzc9l7y>ssv~7=nZr@tSZ<tg`7sU)
zlYzl$J`W!a2b^bj$V>`(5vE9#<(F$%t}@8sOl3&71`OpzL@M|b!&UvO&}40X!3Kcj
zF7TWpxzewS-ff%qNe=YAF7CG!5o(mtnT!zG4*xiWXpAOZ$RUZ;YA-D&nR?WC_#UY;
zJ`G+Z`gjK!h(DOmeSN*3-)MS?45|}?HFNYgVL<*<dWX3*R(t>e91<3COoY>9?(!EM
zE+5ta`mcueAu5e*IbT(xKWj>BMoF}^(re40N@?&jM}HVWY{C#}AyL}#_n6prp#^n6
z>=-sYNFi4idm1u1UZ)JRN~BE+dS6+Mz;)w8JXD`8kCc?RKk>~$&C8Ws2=S19uV*o<
z)y-Qpr5CJGC4{&0a>82GL6{UDQoMwCQ+=+WYr6jsU_C)tqpw4z!Q|ZyS~a|B*1N3v
zjD7pl<s-kk{f+JiU6EK}j~<BJ_S9Z1zW=n8d@0vp|MpUorAJR3SCliF#MB}R`gX|j
z*fr1GEz<{kgsF5B3BJ(Hfu4`1x5~B>>u5-DJz)<ZR1ztv*s}O0P6O%X$`uUb6@%1k
z-_j8k`(DGZ63hPOL3Mx^Ez~P+{JUCmpV{d4w5D$|*Z#PW@RNr59a$OKoy-Lb(D|=$
zl&x$yzP){6Zb8&aeQU(;=;MO&b{}i^z)FqNesj18x>|_5Oy(>WS)4jdN$p7w*E}b3
zxB97`+S+3pM{T#<>n2{eK{vjKZ7Dl8R3%AvXFts+C_4Pfh6!-M#tlUuLu`1YnFtwk
z)!#W<J(t=|%?8w5@1m|Fbn<9H7USYENop8k4zGBODPKObZ}2Jm&+pa}biIQ5cHz9g
zF}v0A>>g%|_qjsxvn8>Dhj}g$hl|cX>esOX-zO!c2FWz}@(g;q?Z%SB5(mf3s;=HB
z_riKM!Sc?Z4L{YN)m?7B%In$n9fPB?*!{cEwsE#-SiBve`!ILc834G#PvShVNqS_u
zpZIF2C(};9>eAJQmK7hq)q%WMk$D~ayy@~>J{nlOcT@^}lvfR381>FFd+U)-8>{&~
z+b2NNTSE0@)<tvUd@WsFM@erntrXx7iWkzjcNk$8Xa%zT%P=u#+CTB-o7&4OF1cN&
z!;Mng0u6=9vDIBshDA*}yn~!uxA$IUAK%24*R&*@ruC4}TAD0)bvXs#Ux_DA6MdmA
z&JD?Ie%2fz+Rq-Z?+VQ6Wo~-y_=&z4vs&7QC_}kW$WTO!lHvP>W*tRiM6UNalc@Y8
z4&?!p?kz3me#rx!67ILp6-JV_#FpCYaw&vKMIX-Z#cf!!9o^>U^H|n}B4Jv>@K*D6
zdnPO?xbmL%K$ijCQjY($zbl!u6(vhokG_Ld{BgQ37m4kMUFF}qBjLmTsRJkLhH%Tk
zavCF(SGpZ1=(XMo!|kk#eCmTli~&Y}t>qgPS~r(vT;5b-@e~p+4VE<0F(&x}HVW*!
z=$h!&P}8rfEVk}{R|6#YIOeq4t^M4@omFm>1qMGq#4kmoINo|l@*JR?oX#%+;~;}+
zsg6-+I7K~fvD2|b{utvO^_y>!mFTd7TM(!qSFCG19P7!f&c<Egh+4I;R8@5(7uUMb
zr6`uqH3VZ<AL|xvd$8PJb%TZJyd8Qe7$Nyk$hqk0^tFZLnvlBRyFr~LQ1Yd@fRxR9
zw_u!gPv7d{nDxz*qs?;i7YBXemf;uuD+w#IzM5aFWf9iltMlNY`fG+D4~r5#*a{~%
zCPBYR^eI;BDV8W60%GEGJMF2Qab>MLT`CJH+AAKVgPRl+{r;N4Z)erjmp3Vr_R1as
zw!8!i428Q0U?U?jAg7v9jxFcIEmKK#Ujz(N&iuUqrZ1(iiFf{frjXFhldSqoa-S;-
zCiq*9U-bBzyIMr@HG<6jnEnyIAj*&(^zr@~0}WkP&O?{I>8gt21zVxt!z_Fjfd5z@
z?xaEi=ZA4fwgPbsRO%+6IRPm|Q**<VcjsS3ae`h{Q=Jap^t&RyUk?n7Kip3YwApF?
zYFa=oyrrIcF_-9u6d>9spvowv4IT6m7`SMjN^}XxIZxhaB`PR?BgDnuwW=T?zTK7d
zIWb_9u=H*O#2g-c&xX?V#|OW!c`7~K)kIN#9EjEJA;4zzisPcCEW?VPs0@>+_vB^W
zkPYG19{G<MzmH>r4oc?w={#1di!e_<-rx;OQqGTT1M+p>c<82XOX9WR1}eJpYX|8n
z>8~2SBeB#o2xwr3wT6Q~E0;v-#Z8TkV}-qJCfP3W-2*d)?AJ^mZxsm+X{TM&x7sS8
zX6;8cw}4)U9j%tEkMxnsqAu}7&JAfQP$I39T(sp$I2u~osxp*Ie|ZvmfLIv@-QhIS
ze-t0>L?=s~9iZ%M!f97cN>yKaUv;)JE^Vc=B<SwFpy7A!LB&l@bTcZsN8BgR@RttR
zCMD+CZz=zt*vrNyvbERC98SsT=KC%8c=UGtrnrNi(khpkaV|>@f*9cSp|0@JF@u}}
zhULCLPR@;$$3XebfnXxOTPTn^!iI<C7Vn(iWIF<53hz$Nf%WqJ(e_hrai`h4pDzpC
z0I1UGzZG6do8gu7h50>*ak~UN=ZV_$r`vQj6shF;@Xw+$hhw{Zl1GI{<pW;GPCGT$
z2kb=YA`j~eqCP7t%Kb|WYEI88Dn6Nhf1$%EL2~%$<Z!4p%?CtZ;s-uPiXkl}ty(rw
z5>5$0fgjfZipfUEz$zKdI-mBX&{#a7#;{y0?=NmUUfxcNW(dWdLo^zktrKtPde90y
zNx9dqqVR)-^HsJ}u*^Rg0Y(0e;GBC1rI<LWR8BCJ*(FK!V7k7PSJRIDV@m@CE72#8
zp7;kW0iqC=Q^JaJM4n`A;vDD#(hXYd+QD9<M`a=2*Bnd!P3L4jLr)IGoc3428>E0{
zTzX9X-e-m}`$`umTK~#MqrhAL*;z8)f5|C&J1vkp;qnuqO}n(7H!N5$syVj@Sc*e%
zXNG6iQP8tLJ6#O6lbl~O^LNd}`K8iPL&)3VQ3z+Hh&Ef4E5!kiic<lGrS$jQbS`uT
z@U6%U?$uJC-;=!`Nq->5MRSYhlhPXX;w3tmd>{;Q`wC)}Si5?AS(lvk@o@6CeHMkS
zxagsG$qZr@ACH^vBnkaz#OxMa(eK0)rEBMo2i?mL9p5CSGPCgJ$wJ_>40{-dO3jaj
zx}OU81M^*6MK*wnp`I3awAea@cFChy1Hnx#BvLR2i3mTvY|K(pjji#ghy}ex_{Z!F
z?W`*{@5XU!+P6U`vg9O!GvMZwXIk1Z#>1!Y85;O8aMd0q>0#zY);`pRPibq#Ol9%D
zG}xBu$KBrPs$~}QVjXzfvCMM*D=(V=YX1KSt;lKpy)P5%$=A`a49=!WOdhsdXUJ2B
z(}W^a_g({tW$ZWyPz|+W!$X*xE-!&{Z(D`OngzBLin~!h=>aN;nee|ND<*>dr$i$F
zu(4!Zwhnb`j<GAGvVCe|)b|@~KucxJjq$*U@7eINVV3R!;yt25VVzErw+W|nC>U|!
z@T<jPr&#QES?lI$3sul{r9aI#U#gqa<#<!_k37&}&^s-OCIumg;`mDt<p_c(BR&C?
z<A`s~c8L?Uef%EhakXo@J!kH?W(g5aR~8eg+NK<_#5O9kpnbqmqZbeQDrP!4HElZ@
z+A_>|_Bv$^dexAkclvE3oLVZ)A0C8rQj7k5aKrlRrCyZyFOQ~8**h@?5weJMD?6Gk
z%;>2>I~wWU)EYkS0|bONmQ!^w<*8c4+xt8-&-#e%pz!;-T9TJx_T^&-Y36&?Q)xkt
zcymVb3Qz2HNm4&ADrG%WJ#T*2A;jWZc3!J&_hlCdn1^2t2b+njp?49YJ$($@8;?~N
zSrCDd#Wm&i20TaCfv!&uZvjy<RV-rIdu3tr)C9Oaw=g#Vg<ciq2bU3N-}on5XCi1-
zr345iUG$xOxj?hIR`D!*P0MU=M)aF)4qbYsL0>^l^MZR!X^^wXD6m0tpZHaSh%Ux^
zwrplZtYC>O5;)q&E8b-`+v6~awxj44cch4h&?e9L$lTKYrunT5dmM2Jcf~+AgkV&-
z{M|i#1$5gz&>tr{;kWAj2tzZXCJ(#J4!{;j7w+wpg@INLF_cYF3jY-m%)e2r?)Me;
z;F$?3?NM_YAfZiFj%v4~Y0u<4{%O}Rpvom0^qyHb2aXQiExq~X6icu3=%0d;Q(HUf
zgd@FWN9wjX>@iXBFFk7&w#ydJ+gf~CE?n+aNAOC#4dN0F+*OHV;#=ayKieY04R@cJ
zMZ?@ga-2uZ`X5uGE3@#gqtD9_^6K3zM{^$uce*=Idc-==O&>Yj{i->QttUf?iVcGW
zBS%^$jLI4HBSIY%zx(zAYbBy<_Vi_NASM`k%~WCj>9fYIPVi+amR}<8P!j?6)w7i3
z{zB=?we~dtFWXGVtL9~kpRLbLW)7dE)KxtY`LMX9m-%)8H+$o5Tm$+MZ9w7g<$Jfl
zC^w@oqTmoBGyA2zk`yh~w@E*k@~=}UzJHiPGW6@_W_a5VzaOAhm6VAut590Js8TzH
zeLtC1>#Vc$OBjXYzd26)tU5vc$q32zb#T7GOly=RoQR8=tlA3%(~oOSMN~}wW3{Wd
z&nqR}cH&%Zgw2ytSiWlt1bcEK?;Pq;8mq3Gx3^9pG~P8)(g8&49)+Z^`xGq>`)G5=
z9D+%m2TywZy2m-T#+NNXiUDQHU6FNs0H5=>8lD%oP&q!r|AsSVcZ&*XDSgC)&S^(x
zNmY!iVrQ+{*<K&NNQOAwJG#o9fzpYb3xWx>Nd}pOJt|ol?vGPNOMOCJ$p=jC3?u*^
zzc`Z)%=~9x4~i&+0-4~OmC*Rw<6_u}ED_fqbr3<j{8rab1PtVAbYL#)6XIX#+?}r7
z7ps>#o#b4?<RloKVrFKhOkd_`^OqvGI9(~yAERx)RqhI*7Ln`m+Wklg+Qap>2&|RN
z{n)x{5XY!hQ^8+dTY!Y%iKZ6uG`2IEqS-{^8e!d>1Z>OtK(p)^vve24kU(<|t-_EC
z3FUt-_s?uYW>K6&QGeNKU^CJR^Fe(g;`Gmq%#xej<&i#GDZ&%OVOWvIZsI7Q*msgR
zKII?ZE%>^y97|O2`*36piLOU;LP-B5LKco2lWPITOgk4>$e$AF>13t>X}TRv8|gkN
zHh*P%1KTld0i<%>u$f?)TDk=QtUwHUc$@yC5h8D1i|@Qob@vgG)UZcS(G`_RvT6RK
zt(pz*Q9yhVG*)Hk$Cb<ScLM~zoQ}F~Mai<)>-D0?ZiEB@0d>68R2r%#K#)>r;&zug
zH#+sVFgkX5GN<R@vv;8RLAR~YIeE#a`yln#itg6?uC$uIDfDirsC{N(i==X8tZ~NQ
zySsma`uw5<FKz{t=<jK^QVhOqhQsWNRxg<mbzfRUp0`&nY|Vw~w<smR^TseFGFaR`
z)PsqJ0rkZ6lX|HW-{K2uJ&R)PY$zZ}m&Pw9zC#PMfgi9v6J@`3vjo!#6b}0u^-BM0
zj=vKRql8;_IXx+JsX2FB+xJ}F0Y2XrWr_;nRS9_AdwfMC=Cxi`d4_MPHKH~h$4Zjr
z6x+UL2yv82a+-gqw+9=!5S{dmC@woORiyBLF!q0P7=t&1qI$hbgY4Yz)7B8BuLr$m
zpkK3zQ}MJW`x3H$sdlbPjw1Vw6VtZlNEYLv-se1t@>tN+%sL|o?czizlg~a}&16J8
zxPlH^<A3`1@07~Ud`E2PtXFeuV-f>G0h|Y9Eqi&!Gm1(MHW($2PJ|F{9j<R|j;B8e
zU(_9`b=)lP3-2>F$ZcQgQ`e0mOe}Tk{weV~;NSiA?+Uv9<xI9~3w$iZHQGLcetT@F
zvd`-YZ?wdKE~suv5UN{WHtM@*Jvcfi&=E?@0J?=`5R{Us?JIN|X6Fq1vTelM7-|*_
zb3uY%s_qzN=WD={0yMdSB0~EFLDtz}nbst($Q(2a+JE)RzY|iII@i4#=P;UD8zn`>
zM7<?{7ASpCzDZA;`6;A1m0j`)<34ZBr`7LS_!lI}hRr#~cHGL#+U^`~k%sWP&2??B
z7&nl=xT@Z^@V0>D$O&;;U(z5kq-LQ%L$Fz|@(lgl=im(dBxLQhUESwMx+9qG<IPP_
zw=HmeMy&kGf6QvXze$R}5b228QUPosa(qm1zOuVGO4I~~M)u5p5z3LEsKnkvC>paN
zjJc0eb%c#W7GaxfldR1^J>O2^GcoxK5)Tf!2wWRb@{|$Gf3H@*vuNn=+zJ8iB^$H~
zXueV@QvTui=)+3xMvnBBO+j5oNO8gb8CkvU{zV<VGj#z~xereTrmA)#jsZ!tq0t8m
zJKsX6Z)#N_>__A@wWFd$!Ul@fGkI@)iIG&^ZLj?Fvqp99QTOkJM8!YpKAOv-w-K`%
z7-8V0AUb-742Wj8v?btsNwy7oK@W(q&oFv%yT>N4pcGBiMhp8NA<-rq$^>>A0mRPg
zFFfHR?r|D~n77@7ZXbqc$QUC3zfAW1zbCEg9y3p(Z4fYnbME2ocO~Qx^j-clbNc|O
z+pg6x$S)&F5nlak#n*<*R^yS8<{zp=9yUJ5Wk$CBm8lwg^qe+-&jih8I$Re86?ISU
z6E^Evz8V<`X_dQPm4$Gc;Lzt|M1%rRd7k8UH{s^y71Xjb_yh@Q)cPj*G_7QeMBO%+
zO|CgsSfA23NJvPBxFJ<az{i6<utZ&ViLGTB=`Q0LS&HN`^4TJ6pun7pR1q8=;r8en
zc_fN6iWc!!SzJp7g&Z|aDs0mG?=z8jy-!J()0dG><Kf}KwRRP?LSI4AD<?;&dcooH
zDT9NARIws;zX^weHwx$d8W`NJzpfzq=WE!il;q?Pp18dg#7w1|c&eEH{&#nq;EnHm
zy)}U<bYNTMJfj?tkje#`nRftX{w8e>E>;^|6*FhV2BLguRf7P+^#*K$0q+#J-yYtt
z$p82MRT2?FCk>*6tIH?zk;~kF7vd}7^sGjjk%$LCva!OaxYuc^u`G>P<Sf6*rkYYA
z$QY=@-D_g*oJ(go?TFCtUw*)}?5}yz{6i+a%=h<GZ(f-$IQt{-``>^3ivKq}>qz`h
zCDAoq{R<g>{!cjrnRN?@4MF?aw*>yudMDzD$N#J5@eq%P`}a81DqH}t%_d~ctFEpF
zYdnLLV-#>(qyDFDMZ!86YZbs~eRg&hg-&w-E@v-4IWq0`OH^>g`~4Zr*b?L(K&yg%
zD8h|5mzz}a>C+Z)!V@ZgT_cmu>-D=799R-D)YQ~&PMKf`s%>1n*V~()@gk*b=bzf%
zsF*~SdG-tpC?(3}r@pb~fwf1TUOVE${(?K8)2Y)ii_%b0y)`ZJtI3)I-%VZJjr5Ah
zfBJ}zYqG4Atr7q2f68K^CiCw<D1ohGXEO?d+1vvA%gJ(t^RAuUzOQ|eE8NX(y)qmv
zt5RU*x?<`6(^YgT3px3WTR}pypv-!oh>wrJlot?~azE><**4OhSEzt!=18cWR}Mi9
z{;7#7^Y_<GW&{6)jsxrom9y|~*0^mS!5Rx)m8s&*nBcJ6)PwP(-v_4AdnWQ<$--pG
zNdtbjnY4%r{8PY(Yps=Z!GHcva|v8*>0nI>!USzL#7*MG%AfzMe8T2er{BDNEBXUQ
z^ONJ!xi67;`1ply0L=Rcw4KA=x+Krqx#YdY@2v$Wq5tzj(A*&qU6lVpbhm-~-I?q3
z93;M{cS(K}@4w2*<K4(C92y&Y-?$%&_sC?>qLHD0;rYbGL?aO%DXI7gHR9448%@JM
zy%E$EVFX|x8#ZXgK{mM^#-jOR1q>hs6u4f^@|(cq5;AB4&Wr%c{#T2T*Jy_oZ?tfW
z{s7)f#Kg2e$7?VHu3v&sZ@n{ciy#+xq<~At!GFvR?!p!aeY&wz+kgCac`zW6`DVXk
zvacG{RqqV8hfhrWDfnUraj~%zl)=yQ#)%`sTt1Ibnv=PYBytEN{3=+*YRv!us{}r%
zjUn{bVA;sG(R3H}JT`~T>UDVxo--H?W<BYqDkVERu4WctKeEpZ;ver&o*cnl2q7UM
zuXl#5g9jqnO}{7)<eSo+ltO8I^7B2?D<;*Ae4Cfunm%L#m<kt|Px)XLf}t?nq?%Jx
z@fS;lghXERe>Hd2e^G5+f5?##1eK5&1SC{KT4}C`fKn0)0#Z^EN{Vy{1_A>j7<A_a
z0m&gH6j6~@NdtqF7-7(Nof*gLbD!rAcz@E*aLzt!uf6x$Yp=c5_p8*qPf+lM@x|qL
z+GAJ%CSGV-$0oy~#)kY?wyH%~Px}Z_cDjG%kS{^LTjDDmq#*Jt2fV-tgc}h{)sY=U
zgeA{r9x~!&T<)ueq{-^tS4fa!WfMQ!J!WTX>y-VLIq?FG5c4T)MQXYQF**DR=kMfj
zdMF(DE;K1hwo!4myb4H`s#h<htDmtmHy?9*^!C`EpG$Eeu#z9Hy~@{rH4R{omB$Vw
z2}<_l3ED}kK8l33kr<Bj3$mR9F(Ph%wl-95tsel&@2b|nD<di*GFx1Z>z6}voL_hW
z^toGut`2L8JyE*Xkj7pAnwZ9|M)7AGz<8k8j{rI^^Be;)UU{<u>hXH25w=C}9`@!l
z!kd084Gj&-3G^;f5;mfg4`DMv@*sLjp@Ms2DiTuilIv7NANc(9F`M?QsVm_||7;HA
zKSkHQcwx|Q(ctTbqbeZf+9LZRxxdU_Fn{=(Ab)dOF?0{v^aN{ZQzl-}k&^o+DR0w8
z-ERQ}3JubAsOO~m7G$5<M|Yx9v}dHZ{SA^e>^{o6NA0)Xo3jPOwB`13-n*Rgw7Waw
z)hcAxCNEIY|Btu1Z6Gn%`#C8w*ZH4q>{s((AF8UV0O&RTuFmcKQPI&}s%e`52n-<V
z#cmX7N69<fNf_qCz^eM@%~@Q#`MK-2Zt)(zBsj4jbHL8)Dwqld0Ez#LS^4O?HNfiL
zu?m2pD}YibNRISNZHxDVO#*6ZSjeL^At)iS@MCi!Wcr#gyx8iKiWb72r)A_YsIYwu
zIhvO&d0PT6d^k<#MH7|&JP6>1WnG8t(OC#;h-HH>P&E^1TLj3;RMGYKSNML<1OVb8
zmDO4Ly7oD906d0NRL!xTX2|Cs6MueAN^TuctV2K<FjXbaRN8|Xht+$CuxqD3DM1yy
z6~{VY(18L9XUQU~rX!m}gOZY(T3W-!W^vVt&3<E+ml@kDC_;YE8i#tng}zFbu;4FG
zXoS|9_PYu`f{fAcL6@l`4>$jIo*aUK=p;E-1S-UWmV1OpLo8}8Xg8Y;_SgHk25Y5J
z+VpvlcbLHYAJeYfdMt1Q5*%+&+{jl;`DQ`Z8O9OPn-B7ynF5$%`DO;@aLJF4eruo)
zEaW_(j3>vRm2w-C31;V|{<GP1z}K&cwATY)Lf3ET?4QyFfdMcqJA0T7dt%%6?eFE+
z4sP@MmB<X!m|e#GO-huYW0IJ~+Tv6@Avulak9G;+@Y%}vcQ?V#EZw`z{b#!jvqq%{
zg*lD(Lz*XF?{_is{@tv0$HnKEGo*8d{n3FR;l72Y%Go;3M2OXYbSD6LrJT972te!o
z31W6K;)Ahl<eH2A*RSk=Fq=G0M40`j1J(c;EB2NM8B1UzJ37q(YinNrFTo}<EsLrL
z*zMl`sr2T*8jM{FA<y<dgxzLYWD@nSHZhsH)kS~*OHcvtLet%l(E4YSst!<OvL7&F
zD_{qGIc(^-ra1ZAe4*4nk(Ve6rGxn;Fcdd#kcS!-+E2DYC{&WlFSVjj87t&TghJ)U
z{c_Y$I_XmK%fL9iyt`$X{C73cht98r#CtCelv&=Jpv9Ara6zvk4*0Jh?j!UBTvXQN
z{Q{NCh#5WDvOwvt+Q#y9?V&pUI6R7yjMR5Yp7Nt^<eZ9e*u2aaD2V*Z(dH;~Z?S=D
z96ZI!Eyf)xtjMp7J>A`qy-%C|@@vZi3sUv?bgf;2_(sb&f1ekrhwNzC$9kt8p{>9r
zuiR>3z|g^Ki;^mdmuziqM}iJTPp~4@flt@6#YwLv0;>0>)svUw0*;HXQ4%2RXmEE_
z95uY=&#E$mH+V9&kiry9MJ(TY9rtK40TCpwHUHk1MIWoD@1NfJzUeDKpjEpZDUdve
zwjg#Y)Um+2S>?`!s>Q)^#*hj3$Z}d27>x_6{cT#5@VXKe#>IP)%U_xh^vVE0#&LT@
zz^|{|iew}9bCLpobcQ-u+T&`o#~!><h9t3{2T1}`Ene(AOi1R1swKJ2^@WcXQIiYz
zXmPs=z&EVi;vn@nemlngY^%qDIzDq(f4Q|Pu1|`9lUdAF(<VxJnk3}~{4P6+VD_|d
zOjm4ta}9x(ZF2n*4~|KMsC3k?rsy#?B}*fAaZ8HJ+XxCbCm&Uynr}eo)s&I8w9H6t
z8RH4IsYn^m#GOFAx<d3s|E}Pf|9VOZzi68X>Gexjk{DGfPvK)vPRZk#tkJt5AAU60
ziKO@L2z~Ljy7$Qz_y<oSRT~eu*MAZUX4ew|f|cfrdjok4z{)yoX6`2HitpOre@m*=
zZL9G9WE4D%y}a^L>$|#wu!u;^#5f%xIciZ;4bs|^=b}wXath){j41i}`SDFxu7f|Z
zoc+=esJDZq1@O<x+J`A_!?B|VV>TrK4h{-CDXrTB@bwZQP`N7Azr>{wHc_$zx2+%&
zQFSdnadO40>*+D2pV46)6%OHe-o`w84DTX<ccY)W5sH9Kzm6*=O&QL`u*WCu&!1n`
zT0Te!l|eXT%7<D#PHnTMHio*O(crVcdLPPsa6Up6+ckyG36mIX_3%VSBm((j#;-3@
zq?^9cIdOt9L<#xc5x_WPwhj<jS*YgyUr%liQHpDa#{wTP1xIM$`7;=i=@hY_G@a%a
z4K<kvhRO`8cVV=S0P+q9E`<orTtpK5QM=Y|=S6glKG0m_ADEAeHIMq>>$#?i8UELk
zsY&)Y)?n*BQ18)h_GR)>9h0@6K%mdwKo$d9WZ2Y6!#3%QFW~3=u{bojo)s~nhHh>}
z+Wa)$v<ZYv9giqYz{ZHDp#vg`E3uYG<!yH~CX5De$<gZJB>+H&1lp)YAL9A0CLK*$
zRd1Nm-IXX+x1HK=TGH*|LEW56>hR<<q&v^4NQ3GgtuGHVKH3W}_MpWhFJdACM$}&#
z(aAS8(j0j`^(q!U6+I10P<Zhk#ZThoT-!z*ZcoKPAs9d>SiUgHS@9U;#fMtt7o`(O
z<L1NEyl)ZU+>+;n<H>65%IXiroZ1_h;N@QTo-NpJ5`m(c$<LtsE&fd%x+y~*)!_TD
z+3>K>-3a+nca+?6yWuDGu5SpqHqRb+Zbg(lxM&wtD}F0TT$EAO8|4mu)@ZOh9a&ae
zqus%8P_xLaPPZa|2Xl8I8(b<v28AT4A`MKWEq*qKgWyTwc?+3oN;^r0$QL+3+R!2n
zlU?+oqDW6qog~S_h-b`YB&bnHf^#w&Ttxa_JVkn@aX97xst-o5Cf$+rJ^L24$m7Xq
zhR~fvb)=G)!zXQJJPXx1;#y)PeUFb$MY#~IYK!tlMoeFVybQAwv5OJ3lgE$-J|>eI
z&|a+5Ho;${${?C-+g}o()9)EaVdPQB9#xZWLXzNJYqU_*R5X(sal<&JL+XMOz9UDD
zFiRn#4jm3;C0Uc*Du)WUs|HN269o_=31BoegI!+qL*eBS6-aB7-oJpa%~2xopn{2}
zTjo~-Tq*}HQxSqtKZxd-oAfIf^pbbm7uPB9`;ZoP9w)Vc9>E1Err&O)_~DNFk4d)3
z7-+D}if^DG5KUd70BNn-EvonEPA<?c3KJC(OHzb>8+xBaSTk3P2XT~TNPSkKOUE`w
zf+xPTPK`&CeWvHgvzY)7M^L5+CczPaZ}t>vSHz;`V2FNbIoWH#D<Cq&e<W-tJ3C!<
z{!9Frq{c|7FOO-KZt?s6b8TK(?t0PB8GKDFeU7H!61E`bk|AUGSj=^uL!o;qt@s9H
za$?L5#$I<aV0`wCDgxLqB*Vq{3(pzvqT0=1ejt~RZBLeoVbRG5k*vY+s+Ft#TS4i{
zHff^|U(bCVb$|4*(K;mltrt$(@q^^6Eqh<TAq86&h@LHZfCCy}aEZ>!Q=g}k<%T30
zrLYfbTtBJz?30p~UVWghBz5a_<Y81x;WTjD3`byfp#<u$3C<3lnHbF!D%5=q9bMhk
zjCZW1rKKBvd^irRgHT>SIUr@*u}xW|E)pjkBhkrn;HyBpKlmd7l*;^dPXK>(WlOzL
zlGL#1QD!aioCVhDsEZx+n<<jKbg0mge!B$MPl{J-&v93@sqo!|&7SY7d+ijh^3J+c
z+!asNnV8*cFV87~Gjk{>e{V=?YHGl#xcr5^XZsXvqk=>@z}l&m%pUGeZ?EKyQl#s`
zkfiOXgQLu6!|r3{YXN9RjturyL8vF*U=tAM&?@0WUv%n({c6X~fIZ9kX6Z>ODFt^r
z$DqP?we%?Wp<AbUcsqCwA>z&FqxnMud?YudDl$BFPA4FO<B5XL=Xden1Ma0SgFL#&
zkH5GRhhq@0RhwYykoYA)>DrpFGG=sku#X$a3at&zUPX5lwjx4zaKuIa4OO33LUlDY
zrVF!HKcNy8qJjXW0L*GR>#K~)_F1SE?f|LJH*tXq^b8EEgQ-}PPp(~}oyhw;xZ<ck
z3ThO3Z9)z9z$X8zp&^8XP&hrXvJNtm7(PIetg*#1gqmlAl+{**=tI90G}9)$7<T$R
zXl6ZVHs=96j~h~I)G%6h!~QwqhGu5Me_4AylZBd1-4iFiPBe$OxO{HB{H>^{Xr+HP
zG2<b)%g~)B0o#{PMLe3fYRtWYgK>i#wpv*{ACQXS`O_y)#^OSoXHV`zu^Wb<>#yT{
zGa5kEf5(~6B=7@6SP=vmx2nE<f)n7WQ;9e=86cO`-7a=nW8uc>6)7D}O-&;sBMpr<
zsGlq|*H}1S)&3^cF|BY2W1QcBX}U%^N&h26x*n^-x+4ggWix~RIosa9e_y!sLU;UL
z8X6i|Sy_NLRQ8-yGc<e&(6@;R37HZ*9I(6tYt+xwSgyMqODHTZE2~MnI-W33=LMmn
ziM!|Qy@M!13?GP~l+Qqaj%;OXVOV3NkSW*dqGTip=kC;`B*B?+AOnF}AMj{lQzzh5
zQdFNB%jdqEtN~i}!o8(u>x>pW^Av^Y)t+bS5#}@FwjYf}rir91uP7@7EpMv>kCXq`
zkwZ-qYHn_GKo|x^#L7Ur0(?lh`T4FG+0uf76sW0$P@Ox3PeqGMN~+ec1GUODpoAbn
zK#p{X?FSK-y3Av5hXFt3O0PClpH~liABoS+$$8g`#@v^*X#?0w_JgMlOiXf3d1bPb
z?%a8L8tSoMjor9$BX<kpD;4rX!^6dHiRk4jm?g?vfVN?*KFd?lcGk+u%G7iS>XVN^
zkO7<t<Gk)Y{07d>g(db7PYsA(@M`U^hH&1h%o|Dep`#Qrx}QrH^fuT~FKv)Tdn{H<
zN@(iD13fI&3J!%e{OXti!CZqu1g%8{Dt661AmRg5YeD<sl$K*m1qA;ZaV=rA7alcS
zJ;Hsws-{NAg|Wn#IsAMQSjppquv$9CRUnq@oUR&zYg&SU$em8udwYZ~M_4*DGzpjn
z@%1zeiQI)Ee_eGWBWz7nG&9CjHSS^1rtjdiQZMI;U7`4ypYj=-v#%+Rh9P5tlI875
zY3wid`ULEm0oJGkfd|jldIFf}@}6dd==94_;dp*pfKI)h;#?JwRDFf`A%Ly`XC$w+
z&<JpARbye6Bj^0lhxvJV2zx7lQ@A{UXhMZc31d=vdh>G5^tA2Z7f-&W7Aj`{z&c??
z#Z8DBi%CdWLu|z1j%6M)EHZL(X~7$x`WxUBSX=?)AUp0q6I)}x0K9Fv7lHljvvZ6j
zySG-!MoCEtKsKmpi~z;xeB(F0L8l2+!_}*_)rTr$nk<uVcLK7(Ojlen+ee$eb6Kbk
zP9I#?b)2l4ne?sGHkb#U0-RR>pTgnj<-uXaa5}~V$-p75TaPV+V9v<v!7H__247<l
z-X85|c5%w*t0VCRso%l`KNh;`j$O%v`eB#%JPt`!RWflut1I+Xz8@9i7k%>M{0g9y
z<}9raTbt=qeH8Av<sUJ4B`Dp%m}`e^e`g#<f(GVsmHZQGotYf%#1gjMAM6E$X-4XO
zicQWd8KS1I9vQWBY6+#-kfX4CqF`Ic2U$}NJu&Q--U;I@CtfUO0!B{21&=!OfzsiP
z^@Z~4*KjX!{27nm8=LCLZnZwNd82<t)%`2;b#88MHEn&W!-(nBT>uD!QZ_nY7n9|3
zAImu)e>3Ckt}ozJP~Gd>!Bt{)1{YW-!^9=mJMNTUmY?P`bY@6X;o_i)nf8opc@uQL
zR`!}QJ(vEj(AueWH2<*`H_G}XWZt}x;q4g#JE(+Xztkj<a;q&m<%myFm2R5<=meP8
z61ML!$xEj}wQ#)?0Qf;r#~uW5IKW-Fj|Ol9Ox0r;-v#n%NAteEl98+@{RCJJm2mQI
zKk+lngHk|xt`f9Sa=N0;t|1%`Vd<V%0|Umctu5c_Dg?&QtwJ@mMb4pp`yP)w32%--
z<g9SC@$y5L3KdDmkcP8SbwEUE>x$COGEH5AMalg6!~)%l7*+i(MDkjYJjGr#ZlT>s
z&z<3oA%2Hl=go=-aq0!}d%vISyMK7UuM_vx!_idN?zz`%r=53n+$?V~JXQx}hPji^
z<R_B4fC}=VQks;5j-};;3w1t*o`5RS|D#v>`DtC6KK&S;CE8-MCr_W6G&C7zs|Y#0
zrSt?oJYMV0>R|;!?^(f}G%a)Q;_e-Jb%io$CbY~Bu@vH9DNK!wvh*_h`;EXHYEAuh
zlS{sDhQa=aeBKsj)hoBsm3Kn39JW;tfaC!92{=F*O=Np>eBfph6grW@cUvm{Cq1`A
z5)A{}@m9FhoLByy=cuk8rUYz*U*0dl&Be&jP%;+F9|ud+RctqT1|&Ee&aEALh7e29
z0Gg4h8UG-S?ws5qrgoB~1J2`Kv#-(KEQsw_cUHny<mKhTU_HqI8xUX}3L{_p^T%dx
z&_IEqdBX>Y>a5|dpRvOAOl6m9uZgK?Q5dC%?N?8}On2)`Z+(WH=k%nW0LRvsCC%K<
z&STf&uqw>FN+NS`U6HT`AQ)gP;(mVo+}Qeow1^JqwcQ_H|4`nwUP{wb9<;Htgg44-
zYOzVV0iFQLlV&Dnu;<1_KG;eR!R5>9-6r6WZF+7E3T%W+4&I5^)z%?f)k6;X;WH52
zcl2On^nwl1C8Grs;inM4{;u>$q_3(?G^b|x-7Y^xYtAoFb8iy+dBz)9m>tfa&r|ZB
ziemqIgPJ_B+*j+u!zl|nmHZdsLTPsC=SteNWUr=zAquq;*vV3y$UdXiDWI8^nP~&t
zFE5ng3qEkdq$T1j16EyDYqJ;kj*X4cGI5Jo0<rRN8S|(rHe_|s>`GuWSKfSOG4<8M
z*H}KEJh8c@Gce2oV+(=Mi;s7k9e*FiZdD5j&BbqRj$H<jhnx>LrTgMT92iP{s~P&m
z_bvcJP_-C~eXz#Y<1Ydp+oZTUJ0Aw(x16t7UGapFJK~l_yA>F{SoC(GP|E2SJ3haA
ztPsC+oCQo_`c)>LBC9%}EL9FznFU_!SRTbSupaApjq#V+T1`CB%(+=v8oAMMj|-p;
zPxio(Gr2Vat^0JUJ=!F8gSH@E77p}t2xD1yw}D|l?}wwlzBNVMz?xa2m1O~Ja3<8=
zQt`{MVHIy)^ACJvaZl-TrSXwQcK4v5rj5>m$Qs}$d*%`X#Eb*eVe4TGN5DP_IyDVn
zOxX!QB1J|&;_Thb%Vl-7TSv;@X-bim{f*r&cIkM6tCLfAPtW0x_q_(bJOVU|_hk+9
zMt+sEB7vuiii`J67fcBM4WK^-H8n#;q6ZIFg=cHB0kdCK>8EDZdP%!Z#?5sr2W22X
zHEPnMH3D2Ge{h0yHLA^Yk`lVJEJqk*ygr-|O;fm-)l^YdruVkGHYcZJe17g6N!cC>
zHf4o{pWv=@Z3H*u!al9yl@`iOAc^S-bAlwMWo}bb6Znk<1+(B{iHVDkH~5urZ5c%G
z;o>@Q;K05wUq>q1gHJx?&qgRT6@kGK5Ssv!V&5SkVA~mxpbxrAGBGwj?QwF<2OON-
zTnB(!F*;*vx(4l?ned;J%k=9=>CM^LP5)*6w7{-!*Wk#o=cYjNW*hgL_XznV)p_7B
z4M3w%e}gL@dDy!Npw9^e0)UMGAFMK5Fdsf#S6^=~0dYk+<RlbbmOr1Gg{ZE0{2UF6
z?-nO=w5hk!*6w-uT;(1xBpVxh12$9>7Yap9I?KSp1@>7uE&V_L&s7_7F|j#Sh|JCM
zvzFD%_Ck;@<Ef8U3Jk?2^7GL!YBA+2K0;sNJctTSi$MOFv_(3GVi!Q3uH^t&I8@8y
zZC>z`_%S#LqC5}5!4DOB136Zr&ffh0_sW*)_04k%_V+KzgMcV)O}(RK8t20Q5973^
A;s5{u

literal 0
HcmV?d00001


From 69b428222ac26611acbf9ef8938516de0c0e6884 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:12:34 +0100
Subject: [PATCH 1626/1774] updated readme

---
 doc/README-localpools.md | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 041167975..2f9bba7f8 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -15,11 +15,7 @@ The two former tasks are related to the external interface using telemetry and t
 while the later two are related to data consumers like controllers only acting on data change 
 detected by the data creator instead of checking the data manually each cycle. Two important 
 framework classes `DeviceHandlerBase` and `ExtendedControllerBase` already perform the two steps 
-shown above so the steps required are altered slightly. The following diagram shows the
-high-level architecture of the local data pools.
-
-<img align="center" src="./images/PoolArchitecture.png" width="50%">
-
+shown above so the steps required are altered slightly.
 
 ### Storing and Accessing pool data 
 
@@ -31,7 +27,10 @@ on a `read` call. Changed variables can then be written to the local pool with a
 The `read` and `commit` calls are thread-safe and can be called concurrently from data creators
 and data consumers. Generally, a user will create a dataset class which in turn groups all 
 cohesive pool variables. These sets simply iterator over the list of variables and call the 
-`read` and `commit` functions of each variable.
+`read` and `commit` functions of each variable. The following diagram shows the
+high-level architecture of the local data pools.
+
+<img align="center" src="./images/PoolArchitecture.png" width="50%"> <br>
 
 An example is shown for using the local data pools with a Gyroscope.
 For example, the following code shows an implementation to access data from a Gyroscope taken

From e0d7363eed3bac2e2d1535be77c1b8f6e94025cc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:14:29 +0100
Subject: [PATCH 1627/1774] better entry text

---
 doc/README-localpools.md | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 2f9bba7f8..548fa2728 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -1,8 +1,9 @@
 ## Local Data Pools Developer Information
 
-The local data pools can be used to store data like sensor values so they can be used 
-by other software objects like controllers as well. If a custom class should have a local pool which 
-can be used by other software objects as well, following steps have to be performed:
+The following text is targeted towards mission software developers which would like
+to use the local data pools provided by the FSFW to store data like sensor values so they can be 
+used by other software objects like controllers as well. If a custom class should have a local 
+pool which  can be used by other software objects as well, following steps have to be performed:
 
 1. Create a `LocalDataPoolManager` member object in the custom class
 2. Implement the `HasLocalDataPoolIF` with specifies the interface between the local pool manager
@@ -67,7 +68,7 @@ private:
 ```
 
 There is a public constructor for users which sets all variables to read-only and there is a
-constructor for the GyroHandler data creator by makring it private and declaring the `GyroHandler`
+constructor for the GyroHandler data creator by marking it private and declaring the `GyroHandler`
 as a friend class. Both the atittude controller and the `GyroHandler` can now
 use the same class definition to access the pool variables with `read` and `commit` semantics
 in a thread-safe way. Generally, each class requiring access will have the set class as a member

From e501390d7be09ece647d829b63b81e2bc2dc6277 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:20:58 +0100
Subject: [PATCH 1628/1774] readme typo

---
 doc/README-localpools.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 548fa2728..4ac2a4d8b 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -21,7 +21,7 @@ shown above so the steps required are altered slightly.
 ### Storing and Accessing pool data 
 
 The pool manager is responsible for thread-safe access of the pool data, but the actual
-access to the pool data from the point of a mission software developer is given in form of
+access to the pool data from the point of view of a mission software developer is in form of
 proxy classes like pool variable classes. These classes store a copy
 of the pool variable with the matching datatype and copy the actual data from the local pool
 on a `read` call. Changed variables can then be written to the local pool with a `commit` call.

From a56cf4389754b577b86ca14d47a5dc7bf97ff2d1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:22:32 +0100
Subject: [PATCH 1629/1774] another rwadme update

---
 doc/README-localpools.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 4ac2a4d8b..96ae2d0af 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -21,8 +21,8 @@ shown above so the steps required are altered slightly.
 ### Storing and Accessing pool data 
 
 The pool manager is responsible for thread-safe access of the pool data, but the actual
-access to the pool data from the point of view of a mission software developer is in form of
-proxy classes like pool variable classes. These classes store a copy
+access to the pool data from the point of view of a mission software developer happens via proxy
+classes like pool variable classes. These classes store a copy
 of the pool variable with the matching datatype and copy the actual data from the local pool
 on a `read` call. Changed variables can then be written to the local pool with a `commit` call.
 The `read` and `commit` calls are thread-safe and can be called concurrently from data creators

From 227074fd4d165a8433d55a4baeac18b5ef84d6da Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:45:32 +0100
Subject: [PATCH 1630/1774] increaed exception safety

---
 datapoollocal/LocalPoolObjectBase.cpp | 13 +++++++++----
 datapoollocal/LocalPoolVariable.tpp   | 26 ++++++++++++++++++++++----
 2 files changed, 31 insertions(+), 8 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index a64ed2b4a..b6db06089 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -37,15 +37,20 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
     if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
+                "which is the NO_PARAMETER value!" << std::endl;
+#else
+        sif::printWarning("LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                "which is the NO_PARAMETER value!\n");
 #endif
     }
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(poolOwner);
     if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalPoolVariable: The supplied pool owner did not "
-                << "implement the correct interface"
-                << " HasLocalDataPoolIF!" << std::endl;
+        sif::error << "LocalPoolVariable: The supplied pool owner did not implement the correct "
+                "interface HasLocalDataPoolIF!" << std::endl;
+#else
+        sif::printError( "LocalPoolVariable: The supplied pool owner did not implement the correct "
+                "interface HasLocalDataPoolIF!\n");
 #endif
         return;
     }
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index aa789a6dd..ba7a413de 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -26,8 +26,17 @@ inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::read(
         MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-    return readWithoutLock();
+    if(hkManager == nullptr) {
+        return readWithoutLock();
+    }
+    MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
+    ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = readWithoutLock();
+    mutex->unlockMutex();
+    return result;
 }
 
 template<typename T>
@@ -65,8 +74,17 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commit(
         MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-    return commitWithoutLock();
+    if(hkManager == nullptr) {
+        return commitWithoutLock();
+    }
+    MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
+    ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = commitWithoutLock();
+    mutex->unlockMutex();
+    return result;
 }
 
 template<typename T>

From bc7d956899f382ad9012e4e132908d4b569ae653 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 19:45:13 +0100
Subject: [PATCH 1631/1774] tiny form stuff

---
 datapoollocal/LocalPoolDataSetBase.cpp | 2 +-
 datapoollocal/LocalPoolVariable.tpp    | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index daa54fb33..e5ea15983 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -36,7 +36,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
 
-    // Data creators get a periodic helper for periodic HK data generation.
+    /* Data creators get a periodic helper for periodic HK data generation. */
     if(periodicHandling) {
         periodicHelper = new PeriodicHousekeepingHelper(this);
     }
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index ba7a413de..9bb30611b 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -98,7 +98,6 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
     }
 
     PoolEntry<T>* poolEntry = nullptr;
-    //ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
     ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
             &poolEntry);
     if(result != RETURN_OK) {

From cb514e7493b8d6b0a56f93c41974d4245b9a529d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 20:43:08 +0100
Subject: [PATCH 1632/1774] small tweak to avoid warning

---
 ipc/MutexHelper.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index bc5730850..bc744d3f9 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -39,6 +39,9 @@ public:
             sif::printError("MutexHelper: Lock of Mutex failed with code %d\n", status);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         }
+#else
+        /* To avoid unused variable warning */
+        static_cast<void>(status);
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
     }
 

From 2d069896a59a642dd381205059f00fd692490f0b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 23:24:57 +0100
Subject: [PATCH 1633/1774] properly implemented getDataAndTime

---
 osal/rtems/Clock.cpp | 300 ++++++++++++++++++++++---------------------
 1 file changed, 154 insertions(+), 146 deletions(-)

diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index 9f4634cca..aef71fe15 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -10,201 +10,209 @@ uint16_t Clock::leapSeconds = 0;
 MutexIF* Clock::timeMutex = nullptr;
 
 uint32_t Clock::getTicksPerSecond(void){
-	rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-	return static_cast<uint32_t>(ticks_per_second);
+    rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+    return static_cast<uint32_t>(ticks_per_second);
 }
 
 ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-	rtems_time_of_day timeRtems;
-	timeRtems.year = time->year;
-	timeRtems.month = time->month;
-	timeRtems.day = time->day;
-	timeRtems.hour = time->hour;
-	timeRtems.minute  = time->minute;
-	timeRtems.second = time->second;
-	timeRtems.ticks = time->usecond * getTicksPerSecond() / 1e6;
-	rtems_status_code status = rtems_clock_set(&timeRtems);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_INVALID_ADDRESS:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_CLOCK:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    rtems_time_of_day timeRtems;
+    timeRtems.year = time->year;
+    timeRtems.month = time->month;
+    timeRtems.day = time->day;
+    timeRtems.hour = time->hour;
+    timeRtems.minute  = time->minute;
+    timeRtems.second = time->second;
+    timeRtems.ticks = time->usecond * getTicksPerSecond() / 1e6;
+    rtems_status_code status = rtems_clock_set(&timeRtems);
+    switch(status){
+    case RTEMS_SUCCESSFUL:
+        return HasReturnvaluesIF::RETURN_OK;
+    case RTEMS_INVALID_ADDRESS:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    case RTEMS_INVALID_CLOCK:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 ReturnValue_t Clock::setClock(const timeval* time) {
-	timespec newTime;
-	newTime.tv_sec = time->tv_sec;
-	if(time->tv_usec < 0) {
-		// better returnvalue.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
+    timespec newTime;
+    newTime.tv_sec = time->tv_sec;
+    if(time->tv_usec < 0) {
+        // better returnvalue.
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
 
-	ISR_lock_Context context;
-	_TOD_Lock();
-	_TOD_Acquire(&context);
-	Status_Control status = _TOD_Set(&newTime, &context);
-	_TOD_Unlock();
-	if(status == STATUS_SUCCESSFUL) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	// better returnvalue
-	return HasReturnvaluesIF::RETURN_FAILED;
+    ISR_lock_Context context;
+    _TOD_Lock();
+    _TOD_Acquire(&context);
+    Status_Control status = _TOD_Set(&newTime, &context);
+    _TOD_Unlock();
+    if(status == STATUS_SUCCESSFUL) {
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    // better returnvalue
+    return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	//Callable from ISR
-	rtems_status_code status = rtems_clock_get_tod_timeval(time);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_DEFINED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    //Callable from ISR
+    rtems_status_code status = rtems_clock_get_tod_timeval(time);
+    switch(status){
+    case RTEMS_SUCCESSFUL:
+        return HasReturnvaluesIF::RETURN_OK;
+    case RTEMS_NOT_DEFINED:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 ReturnValue_t Clock::getUptime(timeval* uptime) {
-	//According to docs.rtems.org for rtems 5 this method is more accurate than rtems_clock_get_ticks_since_boot
-	timespec time;
-	rtems_status_code status = rtems_clock_get_uptime(&time);
-	uptime->tv_sec = time.tv_sec;
-	time.tv_nsec = time.tv_nsec / 1000;
-	uptime->tv_usec = time.tv_nsec;
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    //According to docs.rtems.org for rtems 5 this method is more accurate than rtems_clock_get_ticks_since_boot
+    timespec time;
+    rtems_status_code status = rtems_clock_get_uptime(&time);
+    uptime->tv_sec = time.tv_sec;
+    time.tv_nsec = time.tv_nsec / 1000;
+    uptime->tv_usec = time.tv_nsec;
+    switch(status){
+    case RTEMS_SUCCESSFUL:
+        return HasReturnvaluesIF::RETURN_OK;
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	//This counter overflows after 50 days
-	*uptimeMs = rtems_clock_get_ticks_since_boot();
-	return HasReturnvaluesIF::RETURN_OK;
+    //This counter overflows after 50 days
+    *uptimeMs = rtems_clock_get_ticks_since_boot();
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval temp_time;
-	rtems_status_code returnValue = rtems_clock_get_tod_timeval(&temp_time);
-	*time = ((uint64_t) temp_time.tv_sec * 1000000) + temp_time.tv_usec;
-	switch(returnValue){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    timeval temp_time;
+    rtems_status_code returnValue = rtems_clock_get_tod_timeval(&temp_time);
+    *time = ((uint64_t) temp_time.tv_sec * 1000000) + temp_time.tv_usec;
+    switch(returnValue){
+    case RTEMS_SUCCESSFUL:
+        return HasReturnvaluesIF::RETURN_OK;
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	/* For all but the last field, the struct will be filled with the correct values */
-	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
-	rtems_status_code status = rtems_clock_get_tod(timeRtems);
-	/* The last field now contains the RTEMS ticks of the seconds from 0
-    to rtems_clock_get_ticks_per_second() minus one. We calculate the microseconds accordingly */
-	timeRtems->ticks = static_cast<float>(timeRtems->ticks) /
-	        rtems_clock_get_ticks_per_second() * 1e6;
-	switch (status) {
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_DEFINED:
-		//system date and time is not set
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		//time_buffer is NULL
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    /* For all but the last field, the struct will be filled with the correct values */
+    rtems_time_of_day timeRtems;
+    rtems_status_code status = rtems_clock_get_tod(&timeRtems);
+    switch (status) {
+    case RTEMS_SUCCESSFUL: {
+        /* The last field now contains the RTEMS ticks of the seconds from 0
+        to rtems_clock_get_ticks_per_second() minus one.
+        We calculate the microseconds accordingly */
+        time->day = timeRtems.day;
+        time->hour = timeRtems.hour;
+        time->minute = timeRtems.minute;
+        time->month = timeRtems.month;
+        time->second = timeRtems.second;
+        time->usecond = static_cast<float>(timeRtems.ticks) /
+                rtems_clock_get_ticks_per_second() * 1e6;
+        time->year = timeRtems.year;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case RTEMS_NOT_DEFINED:
+        /* System date and time is not set */
+        return HasReturnvaluesIF::RETURN_FAILED;
+    case RTEMS_INVALID_ADDRESS:
+        /* time_buffer is NULL */
+        return HasReturnvaluesIF::RETURN_FAILED;
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-	//Fails in 2038..
-	rtems_time_of_day timeRtems;
-	timeRtems.year = from->year;
-	timeRtems.month = from->month;
-	timeRtems.day = from->day;
-	timeRtems.hour = from->hour;
-	timeRtems.minute  = from->minute;
-	timeRtems.second = from->second;
-	timeRtems.ticks = from->usecond * getTicksPerSecond() / 1e6;
-	to->tv_sec = _TOD_To_seconds(&timeRtems);
-	to->tv_usec = from->usecond;
-	return HasReturnvaluesIF::RETURN_OK;
+        timeval* to) {
+    //Fails in 2038..
+    rtems_time_of_day timeRtems;
+    timeRtems.year = from->year;
+    timeRtems.month = from->month;
+    timeRtems.day = from->day;
+    timeRtems.hour = from->hour;
+    timeRtems.minute  = from->minute;
+    timeRtems.second = from->second;
+    timeRtems.ticks = from->usecond * getTicksPerSecond() / 1e6;
+    to->tv_sec = _TOD_To_seconds(&timeRtems);
+    to->tv_usec = from->usecond;
+    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;
+    *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 == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    //SHOULDDO: works not for dates in the past (might have less leap seconds)
+    if (timeMutex == nullptr) {
+        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;
+    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 };
+    //initial offset between UTC and TAI
+    timeval UTCtoTAI1972 = { 10, 0 };
 
-	timeval TAItoTT = { 32, 184000 };
+    timeval TAItoTT = { 32, 184000 };
 
-	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+    *tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
-	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	MutexHelper helper(timeMutex);
+    if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    MutexHelper helper(timeMutex);
 
 
-	leapSeconds = leapSeconds_;
+    leapSeconds = leapSeconds_;
 
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if(timeMutex==nullptr){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	MutexHelper helper(timeMutex);
+    if(timeMutex==nullptr){
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    MutexHelper helper(timeMutex);
 
-	*leapSeconds_ = leapSeconds;
+    *leapSeconds_ = leapSeconds;
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 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;
+    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;
 }

From b3ca7b8667efde7dfa25bcbf8fd5354ab8e8075c Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Fri, 5 Mar 2021 09:51:08 +0100
Subject: [PATCH 1634/1774] setCompletionReply ActionMessage

success flag is now third parameter
---
 action/ActionHelper.cpp       | 4 ++--
 action/ActionMessage.cpp      | 4 ++--
 action/ActionMessage.h        | 4 ++--
 action/SimpleActionHelper.cpp | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 42ee4022f..4b64a40ca 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -46,7 +46,7 @@ void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo,
 void ActionHelper::finish(bool success, MessageQueueId_t reportTo, ActionId_t commandId,
         ReturnValue_t result) {
     CommandMessage reply;
-    ActionMessage::setCompletionReply(success, &reply, commandId, result);
+    ActionMessage::setCompletionReply(&reply, commandId, success, result);
     queueToUse->sendMessage(reportTo, &reply);
 }
 
@@ -69,7 +69,7 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
     ipcStore->deleteData(dataAddress);
     if(result == HasActionsIF::EXECUTION_FINISHED) {
         CommandMessage reply;
-        ActionMessage::setCompletionReply(true, &reply, actionId, result);
+        ActionMessage::setCompletionReply(&reply, actionId, true, result);
         queueToUse->sendMessage(commandedBy, &reply);
     }
     if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index 15b59b9dc..66c7f0581 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -53,8 +53,8 @@ void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
     message->setParameter2(data.raw);
 }
 
-void ActionMessage::setCompletionReply(bool success, CommandMessage* message,
-        ActionId_t fid, ReturnValue_t result) {
+void ActionMessage::setCompletionReply(CommandMessage* message,
+        ActionId_t fid, bool success, ReturnValue_t result) {
     if (success) {
         message->setCommand(COMPLETION_SUCCESS);
     }
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index df97485b9..0c64588ca 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -38,8 +38,8 @@ public:
     static ReturnValue_t getReturnCode(const CommandMessage* message );
     static void setDataReply(CommandMessage* message, ActionId_t actionId,
             store_address_t data);
-    static void setCompletionReply(bool success, CommandMessage* message, ActionId_t fid,
-            ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+    static void setCompletionReply(CommandMessage* message, ActionId_t fid,
+            bool success, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
 
     static void clear(CommandMessage* message);
 };
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index 979ee3ad4..8d34f40f2 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -62,8 +62,8 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
         stepCount++;
         break;
     case HasActionsIF::EXECUTION_FINISHED:
-        ActionMessage::setCompletionReply(true, &reply, actionId,
-                HasReturnvaluesIF::RETURN_OK);
+        ActionMessage::setCompletionReply(&reply, actionId,
+                true, HasReturnvaluesIF::RETURN_OK);
         queueToUse->sendMessage(commandedBy, &reply);
         break;
     default:

From caa3cf538b5e6a1ba390c71d863ed9a85de0dc20 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Mar 2021 13:34:06 +0100
Subject: [PATCH 1635/1774] formatting correction

---
 devicehandlers/DeviceHandlerBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index a19e2cbc0..d61b0407d 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -119,7 +119,7 @@ public:
             DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
             lp_id_t thermalRequestPoolId =
                     DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID,
-                    uint32_t thermalSetId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID);
+            uint32_t thermalSetId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID);
     /**
      * @brief   Helper function to ease device handler development.
      * This will instruct the transition to MODE_ON immediately

From e7cd7c8dc30aaa87cf4a411cf1849c6424c1b2b2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 7 Mar 2021 01:35:55 +0100
Subject: [PATCH 1636/1774] MSVC FSFW almost compiling

---
 container/FixedArrayList.h             |  4 +++-
 datapool/PoolEntry.cpp                 |  2 +-
 datapoollocal/LocalPoolDataSetBase.cpp | 10 ++++++----
 osal/host/SemaphoreFactory.cpp         |  4 +---
 osal/windows/TcWinUdpPollingTask.cpp   |  4 ++++
 osal/windows/TcWinUdpPollingTask.h     |  2 +-
 osal/windows/TmTcWinUdpBridge.cpp      |  8 +++++++-
 power/PowerComponent.cpp               | 21 +++++++++++----------
 power/PowerComponent.h                 |  6 +++---
 storagemanager/LocalPool.h             |  1 +
 10 files changed, 38 insertions(+), 24 deletions(-)

diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index 89b76388a..7af636b67 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -8,7 +8,9 @@
  */
 template<typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList: public ArrayList<T, count_t> {
-    static_assert(MAX_SIZE <= (pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
+#if !defined(_MSC_VER)
+    static_assert(MAX_SIZE <= (std::pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
+#endif
 private:
     T data[MAX_SIZE];
 public:
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index a5867222b..6504e20c5 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -7,7 +7,7 @@
 
 template <typename T>
 PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, bool setValid ):
-		length(initValue.size()), valid(setValid) {
+		length(static_cast<uint8_t>(initValue.size())), valid(setValid) {
 	this->address = new T[this->length];
 	if(initValue.size() == 0) {
 		std::memset(this->address, 0, this->getByteSize());
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index e5ea15983..2d70712b2 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -95,14 +95,16 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
         size_t *size, size_t maxSize,
         SerializeIF::Endianness streamEndianness) const {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-    uint8_t validityMask[validityMaskSize] = {};
+    const uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+    /* Use a std::vector here because MSVC will (rightly) not create a fixed size array
+    with a non constant size specifier */
+    std::vector<uint8_t> validityMask(validityMaskSize);
     uint8_t validBufferIndex = 0;
     uint8_t validBufferIndexBit = 0;
     for (uint16_t count = 0; count < fillCount; count++) {
         if(registeredVariables[count]->isValid()) {
             /* Set bit at correct position */
-            bitutil::bitSet(validityMask + validBufferIndex, validBufferIndexBit);
+            bitutil::bitSet(validityMask.data() + validBufferIndex, validBufferIndexBit);
         }
         if(validBufferIndexBit == 7) {
             validBufferIndex ++;
@@ -123,7 +125,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
         return SerializeIF::BUFFER_TOO_SHORT;
     }
     // copy validity buffer to end
-    std::memcpy(*buffer, validityMask, validityMaskSize);
+    std::memcpy(*buffer, validityMask.data(), validityMaskSize);
     *size += validityMaskSize;
     return result;
 }
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index 3d3fe17f3..530b3e450 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -1,7 +1,5 @@
 #include "../../tasks/SemaphoreFactory.h"
-#include "../../osal/linux/BinarySemaphore.h"
-#include "../../osal/linux/CountingSemaphore.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 
diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 4fd88c937..f9b3753e6 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -4,6 +4,10 @@
 
 #include <winsock2.h>
 #include <windows.h>
+#if defined(_MSC_VER)
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
 
 TcWinUdpPollingTask::TcWinUdpPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,
diff --git a/osal/windows/TcWinUdpPollingTask.h b/osal/windows/TcWinUdpPollingTask.h
index 50d39d25f..063a783e1 100644
--- a/osal/windows/TcWinUdpPollingTask.h
+++ b/osal/windows/TcWinUdpPollingTask.h
@@ -23,7 +23,7 @@ class TcWinUdpPollingTask: public SystemObject,
 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};
+	static constexpr timeval DEFAULT_TIMEOUT = {0, 500};
 
 	TcWinUdpPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
 			size_t frameSize = 0, double timeoutSeconds = -1);
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 69a48f3ee..ac8901985 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -1,6 +1,12 @@
-#include <fsfw/ipc/MutexHelper.h>
 #include "TmTcWinUdpBridge.h"
 
+#include <fsfw/ipc/MutexHelper.h>
+
+#if defined(_MSC_VER)
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
 TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
         object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
         uint16_t serverPort, uint16_t clientPort):
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 04f8658ea..778d2b71f 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -1,6 +1,7 @@
 #include "PowerComponent.h"
 #include "../serialize/SerializeAdapter.h"
 
+
 PowerComponent::PowerComponent(): switchId1(0xFF), switchId2(0xFF),
         doIHaveTwoSwitches(false) {
 }
@@ -8,23 +9,23 @@ PowerComponent::PowerComponent(): switchId1(0xFF), switchId2(0xFF),
 PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min,
         float max, uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
 		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2),
-		doIHaveTwoSwitches(twoSwitches), min(min), max(max),
+		doIHaveTwoSwitches(twoSwitches), minVoltage(min), maxVoltage(max),
 		moduleId(moduleId) {
 }
 
 ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
 		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
+	ReturnValue_t result = SerializeAdapter::serialize(&minVoltage, buffer,
 			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
+	return SerializeAdapter::serialize(&maxVoltage, buffer, size, maxSize,
 			streamEndianness);
 }
 
 size_t PowerComponent::getSerializedSize() const {
-	return sizeof(min) + sizeof(max);
+	return sizeof(minVoltage) + sizeof(maxVoltage);
 }
 
 object_id_t PowerComponent::getDeviceObjectId() {
@@ -44,21 +45,21 @@ bool PowerComponent::hasTwoSwitches() {
 }
 
 float PowerComponent::getMin() {
-	return min;
+	return minVoltage;
 }
 
 float PowerComponent::getMax() {
-	return max;
+	return maxVoltage;
 }
 
 ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
         Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&minVoltage, buffer,
 			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
+	return SerializeAdapter::deSerialize(&maxVoltage, buffer, size, streamEndianness);
 }
 
 ReturnValue_t PowerComponent::getParameter(uint8_t domainId, uint8_t uniqueId,
@@ -69,10 +70,10 @@ ReturnValue_t PowerComponent::getParameter(uint8_t domainId, uint8_t uniqueId,
 	}
 	switch (uniqueId) {
 	case 0:
-		parameterWrapper->set<>(min);
+		parameterWrapper->set<>(minVoltage);
 		break;
 	case 1:
-		parameterWrapper->set<>(max);
+		parameterWrapper->set<>(maxVoltage);
 		break;
 	default:
 		return INVALID_IDENTIFIER_ID;
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 659b68530..68b07c329 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -9,7 +9,7 @@
 
 class PowerComponent: public PowerComponentIF {
 public:
-	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
+	PowerComponent(object_id_t setId, uint8_t moduleId, float minVoltage, float maxVoltage,
 	        uint8_t switchId1, bool twoSwitches = false,
 	        uint8_t switchId2 = 0xFF);
 
@@ -41,8 +41,8 @@ private:
 
 	const bool doIHaveTwoSwitches;
 
-	float min = 0.0;
-	float max = 0.0;
+	float minVoltage = 0.0;
+	float maxVoltage = 0.0;
 
 	uint8_t moduleId = 0;
 
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 6a6664853..55d492543 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -169,6 +169,7 @@ private:
      * Indicates that this element is free.
      * This value limits the maximum size of a pool.
      * Change to larger data type if increase is required.
+     * Brackets required for MSVC (nameclashes with min and max)
      */
     static const size_type STORAGE_FREE = std::numeric_limits<size_type>::max();
 	/**

From 331bbd14e7cb842e3113ca55ef25a91f6f5f587c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 8 Mar 2021 12:57:21 +0100
Subject: [PATCH 1637/1774] implemented explicit virt abstract propagation

---
 controller/ExtendedControllerBase.cpp | 16 ----------------
 controller/ExtendedControllerBase.h   |  8 ++++----
 2 files changed, 4 insertions(+), 20 deletions(-)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 95ba012eb..b5b8c6601 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -17,14 +17,6 @@ ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-
-
-ReturnValue_t ExtendedControllerBase::initializeLocalDataPool(
-        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
-    /* Needs to be overriden and implemented by child class. */
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
 object_id_t ExtendedControllerBase::getObjectId() const {
     return SystemObject::getObjectId();
 }
@@ -107,14 +99,6 @@ MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
     return commandQueue->getId();
 }
 
-LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
-            << " implementation provided, returning nullptr!" << std::endl;
-#endif
-    return nullptr;
-}
-
 LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() {
     return &poolManager;
 }
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index f069819bc..d5d43933b 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -61,11 +61,11 @@ protected:
     /* HasLocalDatapoolIF overrides */
     virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual object_id_t getObjectId() const override;
-    virtual ReturnValue_t initializeLocalDataPool(
-            localpool::DataPool& localDataPoolMap,
-            LocalDataPoolManager& poolManager) override;
     virtual uint32_t getPeriodicOperationFrequency() const override;
-    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+
+    virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override = 0;
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
 };
 
 

From 1966b336134b877e93ea6885478607bc3791b0ee Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 8 Mar 2021 14:08:31 +0100
Subject: [PATCH 1638/1774] typo

---
 pus/Service3Housekeeping.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index 5456764d0..c4f80c2a5 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -159,7 +159,7 @@ ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand
         CommandMessage *command, object_id_t objectId, bool isDiagnostics,
         const uint8_t *tcData, size_t tcDataLen) {
     if(tcDataLen < sizeof(sid_t) + sizeof(float)) {
-        // SID plus the size of the new collection intervL.
+        /* SID plus the size of the new collection interval. */
         return CommandingServiceBase::INVALID_TC;
     }
 

From bdd66072d120354ffe6f7cf8280d76eb3e36078d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 8 Mar 2021 14:21:20 +0100
Subject: [PATCH 1639/1774] removed obsolete comment

---
 storagemanager/LocalPool.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 55d492543..6a6664853 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -169,7 +169,6 @@ private:
      * Indicates that this element is free.
      * This value limits the maximum size of a pool.
      * Change to larger data type if increase is required.
-     * Brackets required for MSVC (nameclashes with min and max)
      */
     static const size_type STORAGE_FREE = std::numeric_limits<size_type>::max();
 	/**

From e67ff6a937c155659ee49118bf80ad238093cc3b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 8 Mar 2021 23:00:53 +0100
Subject: [PATCH 1640/1774] cleaner wiretapping handling

---
 osal/windows/CMakeLists.txt          | 15 +++++----
 osal/windows/TcWinTcpServer.cpp      | 46 ++++++++++++++++++++++++++++
 osal/windows/TcWinTcpServer.h        | 30 ++++++++++++++++++
 osal/windows/TcWinUdpPollingTask.cpp | 33 ++++++++++----------
 osal/windows/TcWinUdpPollingTask.h   |  6 ++--
 osal/windows/TmTcWinUdpBridge.cpp    | 40 ++++++++++++------------
 osal/windows/TmTcWinUdpBridge.h      |  5 ++-
 7 files changed, 127 insertions(+), 48 deletions(-)
 create mode 100644 osal/windows/TcWinTcpServer.cpp
 create mode 100644 osal/windows/TcWinTcpServer.h

diff --git a/osal/windows/CMakeLists.txt b/osal/windows/CMakeLists.txt
index b6e76d6a3..889ea3396 100644
--- a/osal/windows/CMakeLists.txt
+++ b/osal/windows/CMakeLists.txt
@@ -1,11 +1,10 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		TcWinUdpPollingTask.cpp
-		TmTcWinUdpBridge.cpp
+target_sources(${LIB_FSFW_NAME} PRIVATE 
+    TcWinUdpPollingTask.cpp
+    TmTcWinUdpBridge.cpp
+    TcWinTcpServer.cpp
 )
 
-target_link_libraries(${LIB_FSFW_NAME} 
-	PRIVATE
-		wsock32 
-		ws2_32
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    wsock32 
+    ws2_32
 )
\ No newline at end of file
diff --git a/osal/windows/TcWinTcpServer.cpp b/osal/windows/TcWinTcpServer.cpp
new file mode 100644
index 000000000..aebc0bee1
--- /dev/null
+++ b/osal/windows/TcWinTcpServer.cpp
@@ -0,0 +1,46 @@
+#include "TcWinTcpServer.h"
+#include "../../serviceinterface/ServiceInterface.h"
+#include <winsock2.h>
+
+TcWinTcpServer::TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge):
+        SystemObject(objectId) {
+    /* Open TCP socket */
+    serverTcpSocket = socket(AF_INET, SOCK_STREAM, 0);
+    if(serverTcpSocket == 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "TcWinTcpServer::TcWinTcpServer: Socket creation failed!" << std::endl;
+        handleSocketError();
+#endif
+    }
+
+    setsockopt(serverTcpSocket, SOL_SOCKET, SO_REUSEADDR | SO_BROADCAST,
+            &tcpSockOpt, sizeof(tcpSockOpt));
+}
+
+TcWinTcpServer::~TcWinTcpServer() {
+}
+
+void TcWinTcpServer::handleSocketError() {
+    int errCode = WSAGetLastError();
+    switch(errCode) {
+    case(WSANOTINITIALISED): {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: WSAStartup"
+                " call necessary" << std::endl;
+#endif
+        break;
+    }
+    default: {
+        /*
+        https://docs.microsoft.com/en-us/windows/win32/winsock/
+        windows-sockets-error-codes-2
+         */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "TmTcWinUdpBridge::handleSocketError: Error code: " << errCode << std::endl;
+#endif
+        break;
+    }
+    }
+}
+
+
diff --git a/osal/windows/TcWinTcpServer.h b/osal/windows/TcWinTcpServer.h
new file mode 100644
index 000000000..3a17336aa
--- /dev/null
+++ b/osal/windows/TcWinTcpServer.h
@@ -0,0 +1,30 @@
+#ifndef FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_
+#define FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_
+
+#include "../../objectmanager/SystemObject.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+#include <vector>
+
+class TcWinTcpServer:
+        public SystemObject,
+        public ExecutableObjectIF {
+public:
+    /* The ports chosen here should not be used by any other process. */
+    static constexpr uint16_t DEFAULT_TCP_SERVER_PORT = 7301;
+    static constexpr uint16_t DEFAULT_TCP_CLIENT_PORT = 7302;
+
+    TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge);
+    virtual~ TcWinTcpServer();
+
+private:
+
+    SOCKET serverTcpSocket = 0;
+
+    std::vector<uint8_t> receptionBuffer;
+    int tcpSockOpt = 0;
+
+    void handleSocketError();
+};
+
+#endif /* FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_ */
diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index f9b3753e6..32c217001 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -20,8 +20,8 @@ TcWinUdpPollingTask::TcWinUdpPollingTask(object_id_t objectId,
 		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!
+	/* 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);
 
@@ -36,7 +36,7 @@ TcWinUdpPollingTask::TcWinUdpPollingTask(object_id_t objectId,
 TcWinUdpPollingTask::~TcWinUdpPollingTask() {}
 
 ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
-	// Poll for new UDP datagrams in permanent loop.
+	/* Poll for new UDP datagrams in permanent loop. */
 	while(true) {
 		//! Sender Address is cached here.
 		struct sockaddr_in senderAddress;
@@ -46,7 +46,7 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 				receptionFlags, reinterpret_cast<sockaddr*>(&senderAddress),
 				&senderAddressSize);
 		if(bytesReceived == SOCKET_ERROR) {
-			// handle error
+			/* Handle error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcWinUdpPollingTask::performOperation: Reception"
 					" error." << std::endl;
@@ -54,9 +54,9 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 			handleReadError();
 			continue;
 		}
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		//sif::debug << "TcWinUdpPollingTask::performOperation: " << bytesReceived
-		//		<< " bytes received" << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_WIRETAPPING_ENABLED == 1
+		sif::debug << "TcWinUdpPollingTask::performOperation: " << bytesReceived <<
+		        " bytes received" << std::endl;
 #endif
 
 		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
@@ -74,12 +74,14 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 	store_address_t storeId;
 	ReturnValue_t result = tcStore->addData(&storeId,
 			receptionBuffer.data(), bytesRead);
-	// arrayprinter::print(receptionBuffer.data(), bytesRead);
+#if FSFW_UDP_WIRETAPPING_ENABLED == 1
+	arrayprinter::print(receptionBuffer.data(), bytesRead);#
+#endif
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
-				"storage failed" << std::endl;
-		sif::error << "Packet size: " << bytesRead << std::endl;
+		sif::warning<< "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+		        "storage failed" << std::endl;
+		sif::warning << "Packet size: " << bytesRead << std::endl;
 #endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -89,8 +91,7 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "Serial Polling: Sending message to queue failed"
-				<< std::endl;
+		sif::warning << "Serial Polling: Sending message to queue failed" << std::endl;
 #endif
 		tcStore->deleteData(storeId);
 	}
@@ -117,9 +118,9 @@ ReturnValue_t TcWinUdpPollingTask::initialize() {
 	}
 
 	serverUdpSocket = tmtcBridge->serverSocket;
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	//sif::info << "TcWinUdpPollingTask::initialize: Server UDP socket "
-	//        << serverUdpSocket << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_WIRETAPPING_ENABLED == 1
+	sif::info << "TcWinUdpPollingTask::initialize: Server UDP socket " << serverUdpSocket <<
+	        std::endl;
 #endif
 
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/windows/TcWinUdpPollingTask.h b/osal/windows/TcWinUdpPollingTask.h
index 063a783e1..8a9cf51f6 100644
--- a/osal/windows/TcWinUdpPollingTask.h
+++ b/osal/windows/TcWinUdpPollingTask.h
@@ -8,6 +8,9 @@
 
 #include <vector>
 
+//! Debugging preprocessor define.
+#define FSFW_UDP_RCV_WIRETAPPING_ENABLED    0
+
 /**
  * @brief 	This class can be used to implement the polling of a Unix socket,
  * 			using UDP for now.
@@ -51,8 +54,7 @@ private:
 	//! 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
+	//! Server socket, which is member of TMTC bridge and is assigned in constructor
 	SOCKET serverUdpSocket = 0;
 
 	std::vector<uint8_t> receptionBuffer;
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index ac8901985..dce88bb22 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -85,13 +85,12 @@ TmTcWinUdpBridge::~TmTcWinUdpBridge() {
 ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
     int flags = 0;
 
-    //clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
-    //clientAddressLen = sizeof(serverAddress);
-
-//  char ipAddress [15];
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-//  sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
-//                  &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
+    clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
+    clientAddressLen = sizeof(serverAddress);
+    char ipAddress [15];
+    sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+            &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 #endif
 
     ssize_t bytesSent = sendto(serverSocket,
@@ -104,9 +103,9 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 #endif
         handleSendError();
     }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-//  sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
-//          " sent." << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
+    sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+            " sent." << std::endl;
 #endif
     return HasReturnvaluesIF::RETURN_OK;
 }
@@ -114,16 +113,16 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
     MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
-//  char ipAddress [15];
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-//  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;
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
+    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;
 #endif
     registerCommConnect();
 
-    // Set new IP address if it has changed.
+    /* 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);
@@ -135,8 +134,8 @@ void TmTcWinUdpBridge::handleSocketError() {
     switch(errCode) {
     case(WSANOTINITIALISED): {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: "
-                << "WSAStartup(...) call necessary" << std::endl;
+        sif::warning << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: WSAStartup"
+                " call necessary" << std::endl;
 #endif
         break;
     }
@@ -146,8 +145,7 @@ void TmTcWinUdpBridge::handleSocketError() {
         windows-sockets-error-codes-2
          */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TmTcWinUdpBridge::handleSocketError: Error code: "
-                << errCode << std::endl;
+        sif::warning << "TmTcWinUdpBridge::handleSocketError: Error code: " << errCode << std::endl;
 #endif
         break;
     }
diff --git a/osal/windows/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
index 8188039c0..b51c8c7ac 100644
--- a/osal/windows/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -6,10 +6,13 @@
 #include <winsock2.h>
 #include <windows.h>
 
+//! Debugging preprocessor define.
+#define FSFW_UDP_SEND_WIRETAPPING_ENABLED    0
+
 class TmTcWinUdpBridge: public TmTcBridge {
     friend class TcWinUdpPollingTask;
 public:
-    // The ports chosen here should not be used by any other process.
+    /* The ports chosen here should not be used by any other process. */
     static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
     static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
 

From 4e5e6e145ecfe866b34a2ed1ef94de1e192a1053 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 8 Mar 2021 23:02:06 +0100
Subject: [PATCH 1641/1774] added win sock

---
 osal/windows/TmTcWinUdpBridge.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index dce88bb22..07fedd024 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -38,8 +38,9 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
         setClientPort = clientPort;
     }
 
-    // Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
-    //clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
+    /* Set up UDP socket:
+    https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-socket
+    */
     serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
     if(serverSocket == INVALID_SOCKET) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -52,7 +53,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
 
     serverAddress.sin_family = AF_INET;
 
-    // Accept packets from any interface. (potentially insecure).
+    /* Accept packets from any interface. (potentially insecure). */
     serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
     serverAddress.sin_port = htons(setServerPort);
     serverAddressLen = sizeof(serverAddress);

From 8be4f45969ea46b73f10973dde548af84d9a3621 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 8 Mar 2021 23:14:10 +0100
Subject: [PATCH 1642/1774] added generic error handler

---
 osal/windows/TcWinTcpServer.cpp   | 35 ++++++++++++++++++++-----------
 osal/windows/TcWinTcpServer.h     |  7 ++++++-
 osal/windows/TmTcWinUdpBridge.cpp | 19 +++++++++++------
 osal/windows/TmTcWinUdpBridge.h   |  5 +++++
 4 files changed, 47 insertions(+), 19 deletions(-)

diff --git a/osal/windows/TcWinTcpServer.cpp b/osal/windows/TcWinTcpServer.cpp
index aebc0bee1..756e77767 100644
--- a/osal/windows/TcWinTcpServer.cpp
+++ b/osal/windows/TcWinTcpServer.cpp
@@ -9,25 +9,39 @@ TcWinTcpServer::TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBrid
     if(serverTcpSocket == 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "TcWinTcpServer::TcWinTcpServer: Socket creation failed!" << std::endl;
-        handleSocketError();
+        handleError(ErrorSources::SOCKET_CALL);
 #endif
     }
 
-    setsockopt(serverTcpSocket, SOL_SOCKET, SO_REUSEADDR | SO_BROADCAST,
-            &tcpSockOpt, sizeof(tcpSockOpt));
+    int retval = setsockopt(serverTcpSocket, SOL_SOCKET, SO_REUSEADDR | SO_BROADCAST,
+            reinterpret_cast<const char*>(&tcpSockOpt), sizeof(tcpSockOpt));
+    if(retval != 0) {
+
+    }
 }
 
 TcWinTcpServer::~TcWinTcpServer() {
 }
 
-void TcWinTcpServer::handleSocketError() {
+void TcWinTcpServer::handleError(ErrorSources errorSrc) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     int errCode = WSAGetLastError();
+    std::string errorSrcString;
+    if(errorSrc == ErrorSources::SETSOCKOPT_CALL) {
+        errorSrcString = "setsockopt call";
+    }
+    else if(errorSrc == ErrorSources::SOCKET_CALL) {
+        errorSrcString = "socket call";
+    }
     switch(errCode) {
     case(WSANOTINITIALISED): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: WSAStartup"
-                " call necessary" << std::endl;
-#endif
+        sif::warning << "TmTcWinUdpBridge::handleError: " << errorSrcString << " | "
+                "WSANOTINITIALISED: WSAStartup call necessary" << std::endl;
+        break;
+    }
+    case(WSAEINVAL): {
+        sif::warning << "TmTcWinUdpBridge::handleError: " << errorSrcString << " | "
+                "WSAEINVAL: Invalid parameters" << std::endl;
         break;
     }
     default: {
@@ -35,12 +49,9 @@ void TcWinTcpServer::handleSocketError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
          */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "TmTcWinUdpBridge::handleSocketError: Error code: " << errCode << std::endl;
-#endif
         break;
     }
     }
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 }
-
-
diff --git a/osal/windows/TcWinTcpServer.h b/osal/windows/TcWinTcpServer.h
index 3a17336aa..4f53dda42 100644
--- a/osal/windows/TcWinTcpServer.h
+++ b/osal/windows/TcWinTcpServer.h
@@ -24,7 +24,12 @@ private:
     std::vector<uint8_t> receptionBuffer;
     int tcpSockOpt = 0;
 
-    void handleSocketError();
+    enum class ErrorSources {
+        SOCKET_CALL,
+        SETSOCKOPT_CALL
+    };
+
+    void handleError(ErrorSources errorSrc);
 };
 
 #endif /* FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_ */
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 07fedd024..375e45e7c 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -44,8 +44,8 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
     if(serverSocket == INVALID_SOCKET) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open"
-                " UDP socket!" << std::endl;
+        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open UDP socket!" <<
+                std::endl;
 #endif
         handleSocketError();
         return;
@@ -57,16 +57,23 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
     serverAddress.sin_port = htons(setServerPort);
     serverAddressLen = sizeof(serverAddress);
-    setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR,
+    int result = setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR,
             reinterpret_cast<const char*>(&serverSocketOptions),
             sizeof(serverSocketOptions));
+    if(result != 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not set socket options!" <<
+                std::endl;
+#endif
+        handleSocketError();
+    }
 
     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,
+    result = bind(serverSocket,
             reinterpret_cast<struct sockaddr*>(&serverAddress),
             serverAddressLen);
     if(result != 0) {
@@ -159,14 +166,14 @@ void TmTcWinUdpBridge::handleBindError() {
     case(WSANOTINITIALISED): {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleBindError: WSANOTINITIALISED: "
-                << "WSAStartup(...) call " << "necessary" << std::endl;
+                << "WSAStartup call necessary" << std::endl;
 #endif
         break;
     }
     case(WSAEADDRINUSE): {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     	sif::warning << "TmTcWinUdpBridge::handleBindError: WSAEADDRINUSE: "
-    			<< "Port is already in use!" << std::endl;
+    	        "Port is already in use!" << std::endl;
 #endif
     	break;
     }
diff --git a/osal/windows/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
index b51c8c7ac..143541398 100644
--- a/osal/windows/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -41,6 +41,11 @@ private:
     //! by another task.
     MutexIF* mutex;
 
+    enum class ErrorSources {
+        SOCKET_CALL,
+        SETSOCKOPT_CALL
+    };
+
     void handleSocketError();
     void handleBindError();
     void handleSendError();

From 494dd0db324af343e1596a295506bc1748ed584f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 8 Mar 2021 23:55:58 +0100
Subject: [PATCH 1643/1774] continued tcp server

---
 osal/windows/TcWinTcpServer.cpp   | 76 +++++++++++++++++++++++++++++--
 osal/windows/TcWinTcpServer.h     | 14 +++++-
 osal/windows/TmTcWinUdpBridge.cpp |  3 +-
 3 files changed, 87 insertions(+), 6 deletions(-)

diff --git a/osal/windows/TcWinTcpServer.cpp b/osal/windows/TcWinTcpServer.cpp
index 756e77767..d090df459 100644
--- a/osal/windows/TcWinTcpServer.cpp
+++ b/osal/windows/TcWinTcpServer.cpp
@@ -2,10 +2,32 @@
 #include "../../serviceinterface/ServiceInterface.h"
 #include <winsock2.h>
 
-TcWinTcpServer::TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge):
+
+TcWinTcpServer::TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+        uint16_t customTcpServerPort):
         SystemObject(objectId) {
-    /* Open TCP socket */
+    /* Initiates Winsock DLL. */
+    WSAData wsaData;
+    WORD wVersionRequested = MAKEWORD(2, 2);
+    int err = WSAStartup(wVersionRequested, &wsaData);
+    if (err != 0) {
+        /* Tell the user that we could not find a usable */
+        /* Winsock DLL.                                  */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge:"
+                "WSAStartup failed with error: " << err << std::endl;
+#endif
+        return;
+    }
+
+    /* Open TCP (stream) socket */
     serverTcpSocket = socket(AF_INET, SOCK_STREAM, 0);
+    uint16_t tcpPort = customTcpServerPort;
+
+    if(customTcpServerPort == 0xffff) {
+        tcpPort = DEFAULT_TCP_SERVER_PORT;
+    }
+
     if(serverTcpSocket == 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "TcWinTcpServer::TcWinTcpServer: Socket creation failed!" << std::endl;
@@ -16,11 +38,52 @@ TcWinTcpServer::TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBrid
     int retval = setsockopt(serverTcpSocket, SOL_SOCKET, SO_REUSEADDR | SO_BROADCAST,
             reinterpret_cast<const char*>(&tcpSockOpt), sizeof(tcpSockOpt));
     if(retval != 0) {
-
+        sif::warning << "TcWinTcpServer::TcWinTcpServer: Setting socket options failed!" <<
+                std::endl;
+        handleError(ErrorSources::SETSOCKOPT_CALL);
     }
+    tcpAddress.sin_family = AF_INET;
+    tcpAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+    tcpAddress.sin_port = htons(tcpPort);
+
+    retval = bind(serverTcpSocket, reinterpret_cast<const sockaddr*>(&tcpAddress),
+            tcpAddrLen);
+    if(retval != 0) {
+        sif::warning << "TcWinTcpServer::TcWinTcpServer: Binding socket failed!" <<
+                std::endl;
+        handleError(ErrorSources::BIND_CALL);
+    }
+
 }
 
 TcWinTcpServer::~TcWinTcpServer() {
+    closesocket(serverTcpSocket);
+    WSACleanup();
+}
+
+ReturnValue_t TcWinTcpServer::initialize() {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TcWinTcpServer::performOperation(uint8_t opCode) {
+    /* If a connection is accepted, the corresponding scoket will be assigned to the new socket */
+    SOCKET connectorSocket;
+    sockaddr_in connectorSockAddr;
+    int connectorSockAddrLen = 0;
+    /* Listen for connection requests permanently for lifetime of program */
+    while(true) {
+        int retval = listen(serverTcpSocket, backlog);
+        if(retval != 0) {
+            handleError(ErrorSources::LISTEN_CALL);
+        }
+
+        connectorSocket = accept(serverTcpSocket, reinterpret_cast<sockaddr*>(&connectorSockAddr),
+                &connectorSockAddrLen);
+
+        if(connectorSocket) {};
+
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void TcWinTcpServer::handleError(ErrorSources errorSrc) {
@@ -33,6 +96,13 @@ void TcWinTcpServer::handleError(ErrorSources errorSrc) {
     else if(errorSrc == ErrorSources::SOCKET_CALL) {
         errorSrcString = "socket call";
     }
+    else if(errorSrc == ErrorSources::LISTEN_CALL) {
+        errorSrcString = "listen call";
+    }
+    else if(errorSrc == ErrorSources::ACCEPT_CALL) {
+        errorSrcString = "accept call";
+    }
+
     switch(errCode) {
     case(WSANOTINITIALISED): {
         sif::warning << "TmTcWinUdpBridge::handleError: " << errorSrcString << " | "
diff --git a/osal/windows/TcWinTcpServer.h b/osal/windows/TcWinTcpServer.h
index 4f53dda42..45d92ff80 100644
--- a/osal/windows/TcWinTcpServer.h
+++ b/osal/windows/TcWinTcpServer.h
@@ -14,19 +14,29 @@ public:
     static constexpr uint16_t DEFAULT_TCP_SERVER_PORT = 7301;
     static constexpr uint16_t DEFAULT_TCP_CLIENT_PORT = 7302;
 
-    TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge);
+    TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+            uint16_t customTcpServerPort = 0xffff);
     virtual~ TcWinTcpServer();
 
+    ReturnValue_t initialize() override;
+    ReturnValue_t performOperation(uint8_t opCode) override;
+
 private:
 
     SOCKET serverTcpSocket = 0;
+    struct sockaddr_in tcpAddress;
+    int tcpAddrLen = sizeof(tcpAddress);
+    int backlog = 3;
 
     std::vector<uint8_t> receptionBuffer;
     int tcpSockOpt = 0;
 
     enum class ErrorSources {
         SOCKET_CALL,
-        SETSOCKOPT_CALL
+        SETSOCKOPT_CALL,
+        BIND_CALL,
+        LISTEN_CALL,
+        ACCEPT_CALL
     };
 
     void handleError(ErrorSources errorSrc);
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 375e45e7c..d4467e441 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -14,7 +14,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     mutex = MutexFactory::instance()->createMutex();
     communicationLinkUp = false;
 
-    // Initiates Winsock DLL.
+    /* Initiates Winsock DLL. */
     WSAData wsaData;
     WORD wVersionRequested = MAKEWORD(2, 2);
     int err = WSAStartup(wVersionRequested, &wsaData);
@@ -87,6 +87,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
 }
 
 TmTcWinUdpBridge::~TmTcWinUdpBridge() {
+    closesocket(serverSocket);
     WSACleanup();
 }
 

From b6952424205a5a656294450ae365c54d7c5079a0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 00:37:42 +0100
Subject: [PATCH 1644/1774] contiued tcp and improved udp task

---
 osal/windows/TcWinTcpServer.cpp      | 115 ++++++++++++++++++---------
 osal/windows/TcWinTcpServer.h        |  16 ++--
 osal/windows/TcWinUdpPollingTask.cpp |   7 +-
 3 files changed, 88 insertions(+), 50 deletions(-)

diff --git a/osal/windows/TcWinTcpServer.cpp b/osal/windows/TcWinTcpServer.cpp
index d090df459..1cf7ed1da 100644
--- a/osal/windows/TcWinTcpServer.cpp
+++ b/osal/windows/TcWinTcpServer.cpp
@@ -1,86 +1,120 @@
 #include "TcWinTcpServer.h"
 #include "../../serviceinterface/ServiceInterface.h"
 #include <winsock2.h>
+#include <ws2tcpip.h>
 
+const std::string TcWinTcpServer::DEFAULT_TCP_SERVER_PORT =  "7301";
+const std::string TcWinTcpServer::DEFAULT_TCP_CLIENT_PORT =  "7302";
 
 TcWinTcpServer::TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
-        uint16_t customTcpServerPort):
-        SystemObject(objectId) {
+        std::string customTcpServerPort):
+        SystemObject(objectId), tcpPort(customTcpServerPort) {
+    if(tcpPort == "") {
+        tcpPort = DEFAULT_TCP_SERVER_PORT;
+    }
+}
+
+ReturnValue_t TcWinTcpServer::initialize() {
+    int retval = 0;
+    struct addrinfo *addrResult = nullptr;
+    struct addrinfo hints;
     /* Initiates Winsock DLL. */
     WSAData wsaData;
     WORD wVersionRequested = MAKEWORD(2, 2);
     int err = WSAStartup(wVersionRequested, &wsaData);
     if (err != 0) {
-        /* Tell the user that we could not find a usable */
-        /* Winsock DLL.                                  */
+        /* Tell the user that we could not find a usable Winsock DLL. */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge:"
-                "WSAStartup failed with error: " << err << std::endl;
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: WSAStartup failed with error: " <<
+                err << std::endl;
 #endif
-        return;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    ZeroMemory(&hints, sizeof (hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_protocol = IPPROTO_TCP;
+    hints.ai_flags = AI_PASSIVE;
+
+    retval = getaddrinfo(nullptr, tcpPort.c_str(), &hints, &addrResult);
+    if (retval != 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "TcWinTcpServer::TcWinTcpServer: Retrieving address info failed!" <<
+                std::endl;
+#endif
+        handleError(ErrorSources::GETADDRINFO_CALL);
+        return HasReturnvaluesIF::RETURN_FAILED;
     }
 
     /* Open TCP (stream) socket */
-    serverTcpSocket = socket(AF_INET, SOCK_STREAM, 0);
-    uint16_t tcpPort = customTcpServerPort;
-
-    if(customTcpServerPort == 0xffff) {
-        tcpPort = DEFAULT_TCP_SERVER_PORT;
-    }
-
-    if(serverTcpSocket == 0) {
+    listenerTcpSocket = socket(addrResult->ai_family, addrResult->ai_socktype,
+            addrResult->ai_protocol);
+    if(listenerTcpSocket == INVALID_SOCKET) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "TcWinTcpServer::TcWinTcpServer: Socket creation failed!" << std::endl;
-        handleError(ErrorSources::SOCKET_CALL);
 #endif
+        freeaddrinfo(addrResult);
+        handleError(ErrorSources::SOCKET_CALL);
+        return HasReturnvaluesIF::RETURN_FAILED;
     }
 
-    int retval = setsockopt(serverTcpSocket, SOL_SOCKET, SO_REUSEADDR | SO_BROADCAST,
-            reinterpret_cast<const char*>(&tcpSockOpt), sizeof(tcpSockOpt));
-    if(retval != 0) {
-        sif::warning << "TcWinTcpServer::TcWinTcpServer: Setting socket options failed!" <<
-                std::endl;
-        handleError(ErrorSources::SETSOCKOPT_CALL);
-    }
-    tcpAddress.sin_family = AF_INET;
-    tcpAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-    tcpAddress.sin_port = htons(tcpPort);
+//    retval = setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEADDR | SO_BROADCAST,
+//            reinterpret_cast<const char*>(&tcpSockOpt), sizeof(tcpSockOpt));
+//    if(retval != 0) {
+//        sif::warning << "TcWinTcpServer::TcWinTcpServer: Setting socket options failed!" <<
+//                std::endl;
+//        handleError(ErrorSources::SETSOCKOPT_CALL);
+//        return HasReturnvaluesIF::RETURN_FAILED;
+//    }
+//    tcpAddress.sin_family = AF_INET;
+//    tcpAddress.sin_addr.s_addr = htonl(INADDR_ANY);
 
-    retval = bind(serverTcpSocket, reinterpret_cast<const sockaddr*>(&tcpAddress),
+    retval = bind(listenerTcpSocket, reinterpret_cast<const sockaddr*>(&tcpAddress),
             tcpAddrLen);
-    if(retval != 0) {
+    if(retval == SOCKET_ERROR) {
         sif::warning << "TcWinTcpServer::TcWinTcpServer: Binding socket failed!" <<
                 std::endl;
+        freeaddrinfo(addrResult);
         handleError(ErrorSources::BIND_CALL);
     }
 
+    freeaddrinfo(addrResult);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
+
 TcWinTcpServer::~TcWinTcpServer() {
-    closesocket(serverTcpSocket);
+    closesocket(listenerTcpSocket);
     WSACleanup();
 }
 
-ReturnValue_t TcWinTcpServer::initialize() {
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
 ReturnValue_t TcWinTcpServer::performOperation(uint8_t opCode) {
     /* If a connection is accepted, the corresponding scoket will be assigned to the new socket */
-    SOCKET connectorSocket;
-    sockaddr_in connectorSockAddr;
+    SOCKET clientSocket;
+    sockaddr_in clientSockAddr;
     int connectorSockAddrLen = 0;
+    int retval = 0;
     /* Listen for connection requests permanently for lifetime of program */
     while(true) {
-        int retval = listen(serverTcpSocket, backlog);
-        if(retval != 0) {
+        retval = listen(listenerTcpSocket, currentBacklog);
+        if(retval == SOCKET_ERROR) {
             handleError(ErrorSources::LISTEN_CALL);
+            continue;
         }
 
-        connectorSocket = accept(serverTcpSocket, reinterpret_cast<sockaddr*>(&connectorSockAddr),
+        clientSocket = accept(listenerTcpSocket, reinterpret_cast<sockaddr*>(&clientSockAddr),
                 &connectorSockAddrLen);
 
-        if(connectorSocket) {};
+        if(clientSocket == INVALID_SOCKET) {
+            handleError(ErrorSources::ACCEPT_CALL);
+            continue;
+        };
+
+        retval = recv(clientSocket, reinterpret_cast<char*>(receptionBuffer.data()),
+                receptionBuffer.size(), 0);
+#if FSFW_TCP_SERVER_WIRETAPPING_ENABLED == 1
+#endif
 
     }
     return HasReturnvaluesIF::RETURN_OK;
@@ -102,6 +136,9 @@ void TcWinTcpServer::handleError(ErrorSources errorSrc) {
     else if(errorSrc == ErrorSources::ACCEPT_CALL) {
         errorSrcString = "accept call";
     }
+    else if(errorSrc == ErrorSources::GETADDRINFO_CALL) {
+        errorSrcString = "getaddrinfo call";
+    }
 
     switch(errCode) {
     case(WSANOTINITIALISED): {
diff --git a/osal/windows/TcWinTcpServer.h b/osal/windows/TcWinTcpServer.h
index 45d92ff80..7b679106e 100644
--- a/osal/windows/TcWinTcpServer.h
+++ b/osal/windows/TcWinTcpServer.h
@@ -4,18 +4,22 @@
 #include "../../objectmanager/SystemObject.h"
 #include "../../tasks/ExecutableObjectIF.h"
 
+#include <string>
 #include <vector>
 
+//! Debugging preprocessor define.
+#define FSFW_TCP_SERVER_WIRETAPPING_ENABLED    0
+
 class TcWinTcpServer:
         public SystemObject,
         public ExecutableObjectIF {
 public:
     /* The ports chosen here should not be used by any other process. */
-    static constexpr uint16_t DEFAULT_TCP_SERVER_PORT = 7301;
-    static constexpr uint16_t DEFAULT_TCP_CLIENT_PORT = 7302;
+    static const std::string DEFAULT_TCP_SERVER_PORT;
+    static const std::string DEFAULT_TCP_CLIENT_PORT;
 
     TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
-            uint16_t customTcpServerPort = 0xffff);
+            std::string customTcpServerPort = "");
     virtual~ TcWinTcpServer();
 
     ReturnValue_t initialize() override;
@@ -23,15 +27,17 @@ public:
 
 private:
 
-    SOCKET serverTcpSocket = 0;
+    std::string tcpPort;
+    SOCKET listenerTcpSocket = 0;
     struct sockaddr_in tcpAddress;
     int tcpAddrLen = sizeof(tcpAddress);
-    int backlog = 3;
+    int currentBacklog = 3;
 
     std::vector<uint8_t> receptionBuffer;
     int tcpSockOpt = 0;
 
     enum class ErrorSources {
+        GETADDRINFO_CALL,
         SOCKET_CALL,
         SETSOCKOPT_CALL,
         BIND_CALL,
diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 32c217001..06e75bd5b 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -3,11 +3,6 @@
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 #include <winsock2.h>
-#include <windows.h>
-#if defined(_MSC_VER)
-#include <BaseTsd.h>
-typedef SSIZE_T ssize_t;
-#endif
 
 TcWinUdpPollingTask::TcWinUdpPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,
@@ -41,7 +36,7 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 		//! Sender Address is cached here.
 		struct sockaddr_in senderAddress;
 		int senderAddressSize = sizeof(senderAddress);
-		ssize_t bytesReceived = recvfrom(serverUdpSocket,
+		int bytesReceived = recvfrom(serverUdpSocket,
 				reinterpret_cast<char*>(receptionBuffer.data()), frameSize,
 				receptionFlags, reinterpret_cast<sockaddr*>(&senderAddress),
 				&senderAddressSize);

From d5a065eaa8c5e5e9472201c9914c8c932bcfdf36 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 00:42:50 +0100
Subject: [PATCH 1645/1774] continued tcp server

---
 osal/windows/TcWinTcpServer.cpp | 15 ++++++++++++++-
 osal/windows/TcWinTcpServer.h   |  5 +++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/osal/windows/TcWinTcpServer.cpp b/osal/windows/TcWinTcpServer.cpp
index 1cf7ed1da..f85147f04 100644
--- a/osal/windows/TcWinTcpServer.cpp
+++ b/osal/windows/TcWinTcpServer.cpp
@@ -1,5 +1,6 @@
 #include "TcWinTcpServer.h"
 #include "../../serviceinterface/ServiceInterface.h"
+
 #include <winsock2.h>
 #include <ws2tcpip.h>
 
@@ -90,7 +91,7 @@ TcWinTcpServer::~TcWinTcpServer() {
 }
 
 ReturnValue_t TcWinTcpServer::performOperation(uint8_t opCode) {
-    /* If a connection is accepted, the corresponding scoket will be assigned to the new socket */
+    /* If a connection is accepted, the corresponding socket will be assigned to the new socket */
     SOCKET clientSocket;
     sockaddr_in clientSockAddr;
     int connectorSockAddrLen = 0;
@@ -113,9 +114,21 @@ ReturnValue_t TcWinTcpServer::performOperation(uint8_t opCode) {
 
         retval = recv(clientSocket, reinterpret_cast<char*>(receptionBuffer.data()),
                 receptionBuffer.size(), 0);
+        if(retval > 0) {
 #if FSFW_TCP_SERVER_WIRETAPPING_ENABLED == 1
+            sif::info << "TcWinTcpServer::performOperation: Received " << retval << " bytes."
+                    std::endl;
 #endif
+        }
+        else if(retval == 0) {
 
+        }
+        else {
+
+        }
+
+        /* Done, shut down connection */
+        retval = shutdown(clientSocket, SD_SEND);
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/windows/TcWinTcpServer.h b/osal/windows/TcWinTcpServer.h
index 7b679106e..f8aebc530 100644
--- a/osal/windows/TcWinTcpServer.h
+++ b/osal/windows/TcWinTcpServer.h
@@ -10,6 +10,11 @@
 //! Debugging preprocessor define.
 #define FSFW_TCP_SERVER_WIRETAPPING_ENABLED    0
 
+/**
+ * @brief   Windows TCP server used to receive telecommands on a Windows Host
+ * @details
+ * Based on: https://docs.microsoft.com/en-us/windows/win32/winsock/complete-server-code
+ */
 class TcWinTcpServer:
         public SystemObject,
         public ExecutableObjectIF {

From da2f594a00f945f3c5dffa96d5539425cd4c5362 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 11:25:13 +0100
Subject: [PATCH 1646/1774] renamed mutex helper to mutex guard

---
 health/HealthTable.cpp              | 12 ++++++------
 ipc/{MutexHelper.h => MutexGuard.h} | 19 ++++++++++++-------
 osal/windows/TmTcWinUdpBridge.cpp   |  2 +-
 storagemanager/PoolManager.cpp      |  6 +++---
 4 files changed, 22 insertions(+), 17 deletions(-)
 rename ipc/{MutexHelper.h => MutexGuard.h} (79%)

diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 2b8b67127..98af5fb8a 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -31,7 +31,7 @@ ReturnValue_t HealthTable::registerObject(object_id_t object,
 
 void HealthTable::setHealth(object_id_t object,
 		HasHealthIF::HealthState newState) {
-    MutexHelper(mutex, timeoutType, mutexTimeoutMs);
+    MutexGuard(mutex, timeoutType, mutexTimeoutMs);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		iter->second = newState;
@@ -40,7 +40,7 @@ void HealthTable::setHealth(object_id_t object,
 
 HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	MutexHelper(mutex, timeoutType, mutexTimeoutMs);
+	MutexGuard(mutex, timeoutType, mutexTimeoutMs);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		state = iter->second;
@@ -49,7 +49,7 @@ HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 }
 
 bool HealthTable::hasHealth(object_id_t object) {
-	MutexHelper(mutex, timeoutType, mutexTimeoutMs);
+	MutexGuard(mutex, timeoutType, mutexTimeoutMs);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		return true;
@@ -58,14 +58,14 @@ bool HealthTable::hasHealth(object_id_t object) {
 }
 
 size_t HealthTable::getPrintSize() {
-    MutexHelper(mutex, timeoutType, mutexTimeoutMs);
+    MutexGuard(mutex, timeoutType, mutexTimeoutMs);
     uint32_t size = healthMap.size() * sizeof(object_id_t) +
             sizeof(HasHealthIF::HealthState) + sizeof(uint16_t);
     return size;
 }
 
 void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
-    MutexHelper(mutex, timeoutType, mutexTimeoutMs);
+    MutexGuard(mutex, timeoutType, mutexTimeoutMs);
 	size_t size = 0;
 	uint16_t count = healthMap.size();
 	SerializeAdapter::serialize(&count,
@@ -81,7 +81,7 @@ void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
 
 ReturnValue_t HealthTable::iterate(HealthEntry *value, bool reset) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	MutexHelper(mutex, timeoutType, mutexTimeoutMs);
+	MutexGuard(mutex, timeoutType, mutexTimeoutMs);
 	if (reset) {
 		mapIterator = healthMap.begin();
 	}
diff --git a/ipc/MutexHelper.h b/ipc/MutexGuard.h
similarity index 79%
rename from ipc/MutexHelper.h
rename to ipc/MutexGuard.h
index bc744d3f9..f0c955094 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexGuard.h
@@ -4,9 +4,9 @@
 #include "MutexFactory.h"
 #include "../serviceinterface/ServiceInterface.h"
 
-class MutexHelper {
+class MutexGuard {
 public:
-    MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
+    MutexGuard(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
             MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0):
             internalMutex(mutex) {
         if(mutex == nullptr) {
@@ -19,10 +19,10 @@ public:
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
             return;
         }
-        ReturnValue_t status = mutex->lockMutex(timeoutType,
+        result = mutex->lockMutex(timeoutType,
                 timeoutMs);
 #if FSFW_VERBOSE_LEVEL >= 1
-        if(status == MutexIF::MUTEX_TIMEOUT) {
+        if(result == MutexIF::MUTEX_TIMEOUT) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "MutexHelper: Lock of mutex failed with timeout of "
                     << timeoutMs << " milliseconds!" << std::endl;
@@ -32,9 +32,9 @@ public:
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 
         }
-        else if(status != HasReturnvaluesIF::RETURN_OK) {
+        else if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "MutexHelper: Lock of Mutex failed with code " << status << std::endl;
+            sif::error << "MutexHelper: Lock of Mutex failed with code " << result << std::endl;
 #else
             sif::printError("MutexHelper: Lock of Mutex failed with code %d\n", status);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
@@ -45,13 +45,18 @@ public:
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
     }
 
-    ~MutexHelper() {
+    ReturnValue_t getLockResult() const {
+        return result;
+    }
+
+    ~MutexGuard() {
         if(internalMutex != nullptr) {
             internalMutex->unlockMutex();
         }
     }
 private:
     MutexIF* internalMutex;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 };
 
 #endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 69a48f3ee..94805cdca 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -106,7 +106,7 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 }
 
 void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
-    MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+    MutexGuard lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //  char ipAddress [15];
 #if FSFW_CPP_OSTREAM_ENABLED == 1
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index 4e8014fd3..eec849078 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -15,7 +15,7 @@ PoolManager::~PoolManager(void) {
 
 ReturnValue_t PoolManager::reserveSpace(const size_t size,
         store_address_t* address, bool ignoreFault) {
-    MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+    MutexGuard mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
             mutexTimeoutMs);
     ReturnValue_t status = LocalPool::reserveSpace(size,
             address,ignoreFault);
@@ -32,7 +32,7 @@ ReturnValue_t PoolManager::deleteData(
            ". id is "<< storeId.packetIndex << std::endl;
 #endif
 #endif
-    MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+    MutexGuard mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
             mutexTimeoutMs);
     return LocalPool::deleteData(storeId);
 }
@@ -40,7 +40,7 @@ ReturnValue_t PoolManager::deleteData(
 
 ReturnValue_t PoolManager::deleteData(uint8_t* buffer,
         size_t size, store_address_t* storeId) {
-    MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    MutexGuard mutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
     ReturnValue_t status = LocalPool::deleteData(buffer,
             size, storeId);
     return status;

From cad302730ef129c0d4509ae7d0fa3185a15294ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 11:30:00 +0100
Subject: [PATCH 1647/1774] mutex guard instead of helpe

---
 container/SharedRingBuffer.cpp         | 2 +-
 container/SharedRingBuffer.h           | 2 +-
 datapoollocal/LocalDataPoolManager.cpp | 2 +-
 datapoollocal/LocalDataPoolManager.h   | 2 +-
 datapoollocal/LocalPoolVector.tpp      | 4 ++--
 health/HealthTable.cpp                 | 2 +-
 ipc/MutexGuard.h                       | 2 +-
 storagemanager/PoolManager.h           | 2 +-
 8 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 1681325d0..5e20bb6fe 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -1,6 +1,6 @@
 #include "SharedRingBuffer.h"
 #include "../ipc/MutexFactory.h"
-#include "../ipc/MutexHelper.h"
+#include "../ipc/MutexGuard.h"
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
         bool overwriteOld, size_t maxExcessBytes):
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 43ab6e8fe..66a119ab0 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -66,7 +66,7 @@ public:
 
     /**
      * The mutex handle can be accessed directly, for example to perform
-     * the lock with the #MutexHelper for a RAII compliant lock operation.
+     * the lock with the #MutexGuard for a RAII compliant lock operation.
      * @return
      */
     MutexIF* getMutexHandle() const;
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 72873d993..0c44ab7e5 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -10,7 +10,7 @@
 #include "../housekeeping/AcceptsHkPacketsIF.h"
 #include "../timemanager/CCSDSTime.h"
 #include "../ipc/MutexFactory.h"
-#include "../ipc/MutexHelper.h"
+#include "../ipc/MutexGuard.h"
 #include "../ipc/QueueFactory.h"
 
 #include <array>
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index ff6edb95d..d06cf2c6a 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -14,7 +14,7 @@
 #include "../ipc/MutexIF.h"
 #include "../ipc/CommandMessage.h"
 #include "../ipc/MessageQueueIF.h"
-#include "../ipc/MutexHelper.h"
+#include "../ipc/MutexGuard.h"
 
 #include <map>
 #include <vector>
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 5b2089b39..044b8fa72 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -25,7 +25,7 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
         MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
     return readWithoutLock();
 }
 template<typename T, uint16_t vectorSize>
@@ -64,7 +64,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
         MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
     return commitWithoutLock();
 }
 
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 98af5fb8a..5d720b191 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -1,5 +1,5 @@
 #include "HealthTable.h"
-#include "../ipc/MutexHelper.h"
+#include "../ipc/MutexGuard.h"
 #include "../ipc/MutexFactory.h"
 #include "../serialize/SerializeAdapter.h"
 
diff --git a/ipc/MutexGuard.h b/ipc/MutexGuard.h
index f0c955094..7eee47b5e 100644
--- a/ipc/MutexGuard.h
+++ b/ipc/MutexGuard.h
@@ -36,7 +36,7 @@ public:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "MutexHelper: Lock of Mutex failed with code " << result << std::endl;
 #else
-            sif::printError("MutexHelper: Lock of Mutex failed with code %d\n", status);
+            sif::printError("MutexHelper: Lock of Mutex failed with code %d\n", result);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         }
 #else
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 5786a2252..4dde3a23f 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -3,7 +3,7 @@
 
 #include "LocalPool.h"
 #include "StorageAccessor.h"
-#include "../ipc/MutexHelper.h"
+#include "../ipc/MutexGuard.h"
 
 
 /**

From 59028ccc3ff0421d5e35a1431e21897ebe5dc403 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 14:48:41 +0100
Subject: [PATCH 1648/1774] updated power component

---
 power/PowerComponent.cpp | 20 ++++++++++----------
 power/PowerComponent.h   |  4 ++--
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 778d2b71f..9ea84dadb 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -9,23 +9,23 @@ PowerComponent::PowerComponent(): switchId1(0xFF), switchId2(0xFF),
 PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min,
         float max, uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
 		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2),
-		doIHaveTwoSwitches(twoSwitches), minVoltage(min), maxVoltage(max),
+		doIHaveTwoSwitches(twoSwitches), minPower(min), maxPower(max),
 		moduleId(moduleId) {
 }
 
 ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
 		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&minVoltage, buffer,
+	ReturnValue_t result = SerializeAdapter::serialize(&minPower, buffer,
 			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter::serialize(&maxVoltage, buffer, size, maxSize,
+	return SerializeAdapter::serialize(&maxPower, buffer, size, maxSize,
 			streamEndianness);
 }
 
 size_t PowerComponent::getSerializedSize() const {
-	return sizeof(minVoltage) + sizeof(maxVoltage);
+	return sizeof(minPower) + sizeof(maxPower);
 }
 
 object_id_t PowerComponent::getDeviceObjectId() {
@@ -45,21 +45,21 @@ bool PowerComponent::hasTwoSwitches() {
 }
 
 float PowerComponent::getMin() {
-	return minVoltage;
+	return minPower;
 }
 
 float PowerComponent::getMax() {
-	return maxVoltage;
+	return maxPower;
 }
 
 ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
         Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&minVoltage, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&minPower, buffer,
 			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter::deSerialize(&maxVoltage, buffer, size, streamEndianness);
+	return SerializeAdapter::deSerialize(&maxPower, buffer, size, streamEndianness);
 }
 
 ReturnValue_t PowerComponent::getParameter(uint8_t domainId, uint8_t uniqueId,
@@ -70,10 +70,10 @@ ReturnValue_t PowerComponent::getParameter(uint8_t domainId, uint8_t uniqueId,
 	}
 	switch (uniqueId) {
 	case 0:
-		parameterWrapper->set<>(minVoltage);
+		parameterWrapper->set<>(minPower);
 		break;
 	case 1:
-		parameterWrapper->set<>(maxVoltage);
+		parameterWrapper->set<>(maxPower);
 		break;
 	default:
 		return INVALID_IDENTIFIER_ID;
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 68b07c329..ce45f142b 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -41,8 +41,8 @@ private:
 
 	const bool doIHaveTwoSwitches;
 
-	float minVoltage = 0.0;
-	float maxVoltage = 0.0;
+	float minPower = 0.0;
+	float maxPower = 0.0;
 
 	uint8_t moduleId = 0;
 

From 7b3616c41f9912d91b2ffcc959db84f99f38b4ba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 21:09:01 +0100
Subject: [PATCH 1649/1774] corrections

---
 power/PowerComponent.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index ce45f142b..6b9778a59 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -9,7 +9,7 @@
 
 class PowerComponent: public PowerComponentIF {
 public:
-	PowerComponent(object_id_t setId, uint8_t moduleId, float minVoltage, float maxVoltage,
+	PowerComponent(object_id_t setId, uint8_t moduleId, float minPower, float maxPower,
 	        uint8_t switchId1, bool twoSwitches = false,
 	        uint8_t switchId2 = 0xFF);
 

From 82d7b7ed6f62d0f3ca64b7bdc89781a6c242fd3c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 21:21:01 +0100
Subject: [PATCH 1650/1774] renamed mutex helper

---
 ipc/MutexGuard.h                 | 2 --
 osal/linux/TmTcUnixUdpBridge.cpp | 6 +++---
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/ipc/MutexGuard.h b/ipc/MutexGuard.h
index 7eee47b5e..4ad23012c 100644
--- a/ipc/MutexGuard.h
+++ b/ipc/MutexGuard.h
@@ -40,8 +40,6 @@ public:
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         }
 #else
-        /* To avoid unused variable warning */
-        static_cast<void>(status);
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
     }
 
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 0af1fc68b..7f110114d 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,6 +1,6 @@
 #include "TmTcUnixUdpBridge.h"
 #include "../../serviceinterface/ServiceInterface.h"
-#include "../../ipc/MutexHelper.h"
+#include "../../ipc/MutexGuard.h"
 
 #include <errno.h>
 #include <arpa/inet.h>
@@ -69,7 +69,7 @@ TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	int flags = 0;
 
-	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+	MutexGuard lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 	if(ipAddrAnySet){
 		clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
@@ -100,7 +100,7 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 }
 
 void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
-	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+	MutexGuard lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //	char ipAddress [15];
 #if FSFW_CPP_OSTREAM_ENABLED == 1

From a7bf9a6734d29f59a74024934886969c6572e9c6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 21:25:22 +0100
Subject: [PATCH 1651/1774] important replacements

---
 ipc/MutexGuard.h                  | 18 +++++++++---------
 osal/host/MessageQueue.cpp        |  6 +++---
 osal/host/QueueMapManager.cpp     |  4 ++--
 osal/rtems/Clock.cpp              |  6 +++---
 osal/windows/TmTcWinUdpBridge.cpp |  2 +-
 5 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/ipc/MutexGuard.h b/ipc/MutexGuard.h
index 4ad23012c..9ee68c81f 100644
--- a/ipc/MutexGuard.h
+++ b/ipc/MutexGuard.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_MUTEXHELPER_H_
-#define FRAMEWORK_IPC_MUTEXHELPER_H_
+#ifndef FRAMEWORK_IPC_MUTEXGUARD_H_
+#define FRAMEWORK_IPC_MUTEXGUARD_H_
 
 #include "MutexFactory.h"
 #include "../serviceinterface/ServiceInterface.h"
@@ -12,9 +12,9 @@ public:
         if(mutex == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "MutexHelper: Passed mutex is invalid!" << std::endl;
+            sif::error << "MutexGuard: Passed mutex is invalid!" << std::endl;
 #else
-            sif::printError("MutexHelper: Passed mutex is invalid!\n");
+            sif::printError("MutexGuard: Passed mutex is invalid!\n");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
             return;
@@ -24,19 +24,19 @@ public:
 #if FSFW_VERBOSE_LEVEL >= 1
         if(result == MutexIF::MUTEX_TIMEOUT) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "MutexHelper: Lock of mutex failed with timeout of "
+            sif::error << "MutexGuard: Lock of mutex failed with timeout of "
                     << timeoutMs << " milliseconds!" << std::endl;
 #else
-            sif::printError("MutexHelper: Lock of mutex failed with timeout of %lu milliseconds\n",
+            sif::printError("MutexGuard: Lock of mutex failed with timeout of %lu milliseconds\n",
                     timeoutMs);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 
         }
         else if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "MutexHelper: Lock of Mutex failed with code " << result << std::endl;
+            sif::error << "MutexGuard: Lock of Mutex failed with code " << result << std::endl;
 #else
-            sif::printError("MutexHelper: Lock of Mutex failed with code %d\n", result);
+            sif::printError("MutexGuard: Lock of Mutex failed with code %d\n", result);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         }
 #else
@@ -57,4 +57,4 @@ private:
     ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 };
 
-#endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */
+#endif /* FRAMEWORK_IPC_MUTEXGUARD_H_ */
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index dfc045e8d..fe7b8c08e 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -3,7 +3,7 @@
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../ipc/MutexFactory.h"
-#include "../../ipc/MutexHelper.h"
+#include "../../ipc/MutexGuard.h"
 
 MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		messageSize(maxMessageSize), messageDepth(messageDepth) {
@@ -65,7 +65,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	}
 	// not sure this will work..
 	//*message = std::move(messageQueue.front());
-	MutexHelper mutexLock(queueLock, MutexIF::TimeoutType::WAITING, 20);
+	MutexGuard mutexLock(queueLock, MutexIF::TimeoutType::WAITING, 20);
 	MessageQueueMessage* currentMessage = &messageQueue.front();
 	std::copy(currentMessage->getBuffer(),
 			currentMessage->getBuffer() + messageSize, message->getBuffer());
@@ -130,7 +130,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
-		MutexHelper mutexLock(targetQueue->queueLock,
+		MutexGuard mutexLock(targetQueue->queueLock,
 		        MutexIF::TimeoutType::WAITING, 20);
 		// not ideal, works for now though.
 		MessageQueueMessage* mqmMessage =
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 2a54f8134..b50d62dcf 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -2,7 +2,7 @@
 
 #include "../../serviceinterface/ServiceInterface.h"
 #include "../../ipc/MutexFactory.h"
-#include "../../ipc/MutexHelper.h"
+#include "../../ipc/MutexGuard.h"
 
 QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
 
@@ -43,7 +43,7 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 
 MessageQueueIF* QueueMapManager::getMessageQueue(
 		MessageQueueId_t messageQueueId) const {
-	MutexHelper(mapLock, MutexIF::TimeoutType::WAITING, 50);
+	MutexGuard(mapLock, MutexIF::TimeoutType::WAITING, 50);
 	auto queueIter = queueMap.find(messageQueueId);
 	if(queueIter != queueMap.end()) {
 		return queueIter->second;
diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index aef71fe15..b80786f74 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -1,7 +1,7 @@
 #include "RtemsBasic.h"
 
 #include "../../timemanager/Clock.h"
-#include "../../ipc/MutexHelper.h"
+#include "../../ipc/MutexGuard.h"
 
 #include <rtems/score/todimpl.h>
 #include <rtems/rtems/clockimpl.h>
@@ -183,7 +183,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
     if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
         return HasReturnvaluesIF::RETURN_FAILED;
     }
-    MutexHelper helper(timeMutex);
+    MutexGuard helper(timeMutex);
 
 
     leapSeconds = leapSeconds_;
@@ -196,7 +196,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
     if(timeMutex==nullptr){
         return HasReturnvaluesIF::RETURN_FAILED;
     }
-    MutexHelper helper(timeMutex);
+    MutexGuard helper(timeMutex);
 
     *leapSeconds_ = leapSeconds;
 
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 36bb9ad3e..d0de33d3c 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -1,6 +1,6 @@
 #include "TmTcWinUdpBridge.h"
 
-#include <fsfw/ipc/MutexHelper.h>
+#include <fsfw/ipc/MutexGuard.h>
 
 #if defined(_MSC_VER)
 #include <BaseTsd.h>

From 3e9c19ee11950e73a5d67276697add9f07521097 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 21:25:22 +0100
Subject: [PATCH 1652/1774] important replacements

---
 ipc/MutexGuard.h                  | 18 +++++++++---------
 osal/host/MessageQueue.cpp        |  6 +++---
 osal/host/QueueMapManager.cpp     |  4 ++--
 osal/rtems/Clock.cpp              |  6 +++---
 osal/windows/TmTcWinUdpBridge.cpp |  8 +++++++-
 5 files changed, 24 insertions(+), 18 deletions(-)

diff --git a/ipc/MutexGuard.h b/ipc/MutexGuard.h
index 7eee47b5e..00baa2da2 100644
--- a/ipc/MutexGuard.h
+++ b/ipc/MutexGuard.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_MUTEXHELPER_H_
-#define FRAMEWORK_IPC_MUTEXHELPER_H_
+#ifndef FRAMEWORK_IPC_MUTEXGUARD_H_
+#define FRAMEWORK_IPC_MUTEXGUARD_H_
 
 #include "MutexFactory.h"
 #include "../serviceinterface/ServiceInterface.h"
@@ -12,9 +12,9 @@ public:
         if(mutex == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "MutexHelper: Passed mutex is invalid!" << std::endl;
+            sif::error << "MutexGuard: Passed mutex is invalid!" << std::endl;
 #else
-            sif::printError("MutexHelper: Passed mutex is invalid!\n");
+            sif::printError("MutexGuard: Passed mutex is invalid!\n");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
             return;
@@ -24,19 +24,19 @@ public:
 #if FSFW_VERBOSE_LEVEL >= 1
         if(result == MutexIF::MUTEX_TIMEOUT) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "MutexHelper: Lock of mutex failed with timeout of "
+            sif::error << "MutexGuard: Lock of mutex failed with timeout of "
                     << timeoutMs << " milliseconds!" << std::endl;
 #else
-            sif::printError("MutexHelper: Lock of mutex failed with timeout of %lu milliseconds\n",
+            sif::printError("MutexGuard: Lock of mutex failed with timeout of %lu milliseconds\n",
                     timeoutMs);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 
         }
         else if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "MutexHelper: Lock of Mutex failed with code " << result << std::endl;
+            sif::error << "MutexGuard: Lock of Mutex failed with code " << result << std::endl;
 #else
-            sif::printError("MutexHelper: Lock of Mutex failed with code %d\n", result);
+            sif::printError("MutexGuard: Lock of Mutex failed with code %d\n", result);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         }
 #else
@@ -59,4 +59,4 @@ private:
     ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 };
 
-#endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */
+#endif /* FRAMEWORK_IPC_MUTEXGUARD_H_ */
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index dfc045e8d..fe7b8c08e 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -3,7 +3,7 @@
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../ipc/MutexFactory.h"
-#include "../../ipc/MutexHelper.h"
+#include "../../ipc/MutexGuard.h"
 
 MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		messageSize(maxMessageSize), messageDepth(messageDepth) {
@@ -65,7 +65,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	}
 	// not sure this will work..
 	//*message = std::move(messageQueue.front());
-	MutexHelper mutexLock(queueLock, MutexIF::TimeoutType::WAITING, 20);
+	MutexGuard mutexLock(queueLock, MutexIF::TimeoutType::WAITING, 20);
 	MessageQueueMessage* currentMessage = &messageQueue.front();
 	std::copy(currentMessage->getBuffer(),
 			currentMessage->getBuffer() + messageSize, message->getBuffer());
@@ -130,7 +130,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
-		MutexHelper mutexLock(targetQueue->queueLock,
+		MutexGuard mutexLock(targetQueue->queueLock,
 		        MutexIF::TimeoutType::WAITING, 20);
 		// not ideal, works for now though.
 		MessageQueueMessage* mqmMessage =
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 2a54f8134..b50d62dcf 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -2,7 +2,7 @@
 
 #include "../../serviceinterface/ServiceInterface.h"
 #include "../../ipc/MutexFactory.h"
-#include "../../ipc/MutexHelper.h"
+#include "../../ipc/MutexGuard.h"
 
 QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
 
@@ -43,7 +43,7 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 
 MessageQueueIF* QueueMapManager::getMessageQueue(
 		MessageQueueId_t messageQueueId) const {
-	MutexHelper(mapLock, MutexIF::TimeoutType::WAITING, 50);
+	MutexGuard(mapLock, MutexIF::TimeoutType::WAITING, 50);
 	auto queueIter = queueMap.find(messageQueueId);
 	if(queueIter != queueMap.end()) {
 		return queueIter->second;
diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index aef71fe15..b80786f74 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -1,7 +1,7 @@
 #include "RtemsBasic.h"
 
 #include "../../timemanager/Clock.h"
-#include "../../ipc/MutexHelper.h"
+#include "../../ipc/MutexGuard.h"
 
 #include <rtems/score/todimpl.h>
 #include <rtems/rtems/clockimpl.h>
@@ -183,7 +183,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
     if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
         return HasReturnvaluesIF::RETURN_FAILED;
     }
-    MutexHelper helper(timeMutex);
+    MutexGuard helper(timeMutex);
 
 
     leapSeconds = leapSeconds_;
@@ -196,7 +196,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
     if(timeMutex==nullptr){
         return HasReturnvaluesIF::RETURN_FAILED;
     }
-    MutexHelper helper(timeMutex);
+    MutexGuard helper(timeMutex);
 
     *leapSeconds_ = leapSeconds;
 
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 94805cdca..d0de33d3c 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -1,6 +1,12 @@
-#include <fsfw/ipc/MutexHelper.h>
 #include "TmTcWinUdpBridge.h"
 
+#include <fsfw/ipc/MutexGuard.h>
+
+#if defined(_MSC_VER)
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
 TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
         object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
         uint16_t serverPort, uint16_t clientPort):

From 7525c883925a2e0e9eae6932337eab459b061cfe Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 21:21:01 +0100
Subject: [PATCH 1653/1774] renamed mutex helper

---
 ipc/MutexGuard.h                 | 2 --
 osal/linux/TmTcUnixUdpBridge.cpp | 6 +++---
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/ipc/MutexGuard.h b/ipc/MutexGuard.h
index 00baa2da2..9ee68c81f 100644
--- a/ipc/MutexGuard.h
+++ b/ipc/MutexGuard.h
@@ -40,8 +40,6 @@ public:
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         }
 #else
-        /* To avoid unused variable warning */
-        static_cast<void>(status);
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
     }
 
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 0af1fc68b..7f110114d 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,6 +1,6 @@
 #include "TmTcUnixUdpBridge.h"
 #include "../../serviceinterface/ServiceInterface.h"
-#include "../../ipc/MutexHelper.h"
+#include "../../ipc/MutexGuard.h"
 
 #include <errno.h>
 #include <arpa/inet.h>
@@ -69,7 +69,7 @@ TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	int flags = 0;
 
-	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+	MutexGuard lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 	if(ipAddrAnySet){
 		clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
@@ -100,7 +100,7 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 }
 
 void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
-	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+	MutexGuard lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //	char ipAddress [15];
 #if FSFW_CPP_OSTREAM_ENABLED == 1

From 61affafecdd4777b84cd46c711e97aa696e951dc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 21:58:29 +0100
Subject: [PATCH 1654/1774] and now some test broke..

---
 osal/linux/TaskFactory.cpp                            | 1 +
 unittest/tests/datapoollocal/DataSetTest.cpp          | 6 +++---
 unittest/tests/datapoollocal/LocalPoolManagerTest.cpp | 4 ++--
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h     | 5 +++--
 4 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/osal/linux/TaskFactory.cpp b/osal/linux/TaskFactory.cpp
index 935646477..80bf47b7c 100644
--- a/osal/linux/TaskFactory.cpp
+++ b/osal/linux/TaskFactory.cpp
@@ -2,6 +2,7 @@
 #include "PeriodicPosixTask.h"
 
 #include "../../tasks/TaskFactory.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 
 //TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 561345951..920bbda22 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -5,7 +5,7 @@
 
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
-#include <fsfw/datapool/PoolReadHelper.h>
+#include <fsfw/datapool/PoolReadGuard.h>
 #include <fsfw/globalfunctions/bitutility.h>
 
 #include <unittest/core/CatchDefinitions.h>
@@ -54,7 +54,7 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
 
         {
             /* Test read operation. Values should be all zeros */
-            PoolReadHelper readHelper(&localSet);
+            PoolReadGuard readHelper(&localSet);
             REQUIRE(readHelper.getReadResult() == retval::CATCH_OK);
             CHECK(not localSet.isValid());
             CHECK(localSet.localPoolVarUint8.value == 0);
@@ -82,7 +82,7 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
         {
             /* Now we read again and check whether our zeroed values were overwritten with
             the values in the pool */
-            PoolReadHelper readHelper(&localSet);
+            PoolReadGuard readHelper(&localSet);
             REQUIRE(readHelper.getReadResult() == retval::CATCH_OK);
             CHECK(localSet.isValid());
             CHECK(localSet.localPoolVarUint8.value == 232);
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index a10b44999..cd3be9426 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -3,7 +3,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/catch_approx.hpp>
 
-#include <fsfw/datapool/PoolReadHelper.h>
+#include <fsfw/datapool/PoolReadGuard.h>
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/housekeeping/HousekeepingSnapshot.h>
@@ -75,7 +75,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
     SECTION("SnapshotUpdateTests") {
         /* Set the variables in the set to certain values. These are checked later. */
         {
-            PoolReadHelper readHelper(&poolOwner->dataset);
+            PoolReadGuard readHelper(&poolOwner->dataset);
             REQUIRE(readHelper.getReadResult() == retval::CATCH_OK);
             poolOwner->dataset.localPoolVarUint8.value = 5;
             poolOwner->dataset.localPoolVarFloat.value = -12.242;
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 5c277850f..8e6b07b00 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -1,16 +1,17 @@
 #ifndef FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
 #define FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
 
+#include <testcfg/objects/systemObjectList.h>
+
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/LocalDataSet.h>
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/datapoollocal/LocalPoolVariable.h>
 #include <fsfw/datapoollocal/LocalPoolVector.h>
 #include <fsfw/ipc/QueueFactory.h>
-#include <testcfg/objects/systemObjectList.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
-#include "../../../datapool/PoolReadHelper.h"
+#include <fsfw/datapool/PoolReadGuard.h>
 
 namespace lpool {
 static constexpr lp_id_t uint8VarId = 0;

From e5b3b6d75eaaa424f21aaf0120768ba0f94b18d3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 22:21:27 +0100
Subject: [PATCH 1655/1774] fixed unit test

---
 unittest/tests/action/TestActionHelper.cpp           | 2 +-
 unittest/tests/datapoollocal/LocalPoolVectorTest.cpp | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index a7adfc82d..d8bd58c99 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -70,7 +70,7 @@ TEST_CASE( "Action Helper" , "[ActionHelper]") {
 	SECTION("Handle finish"){
 		CHECK(not testMqMock.wasMessageSent());
 		ReturnValue_t status = 0x9876;
-		actionHelper.finish(true, testMqMock.getId(), testActionId, status);
+		actionHelper.finish(false, testMqMock.getId(), testActionId, status);
 		CHECK(testMqMock.wasMessageSent());
 		CommandMessage testMessage;
 		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
index 2bc47568f..db76fc00e 100644
--- a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -115,6 +115,7 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
         REQUIRE(readOnlyVec.commit() ==
                 static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
     }
+    poolOwner->reset();
 }
 
 

From bb5b7bed40eaf86293ebc9f631dc39ee2b844469 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Mar 2021 23:18:53 +0100
Subject: [PATCH 1656/1774] made getter public

---
 datapoollocal/LocalPoolDataSetBase.h         | 3 ++-
 unittest/tests/datapoollocal/DataSetTest.cpp | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 404509ae5..b9946aaf5 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -166,6 +166,8 @@ public:
 
     object_id_t getCreatorObjectId();
 
+    bool getReportingEnabled() const;
+
 protected:
     sid_t sid;
     //! This mutex is used if the data is created by one object only.
@@ -180,7 +182,6 @@ protected:
      */
     bool reportingEnabled = false;
     void setReportingEnabled(bool enabled);
-    bool getReportingEnabled() const;
 
     void initializePeriodicHelper(float collectionInterval,
             dur_millis_t minimumPeriodicInterval,
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 920bbda22..101116cb2 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -21,6 +21,7 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
 
     SECTION("BasicTest") {
         /* Test some basic functions */
+        CHECK(localSet.getReportingEnabled() == false);
         CHECK(localSet.getLocalPoolIdsSerializedSize(false) == 3 * sizeof(lp_id_t));
         CHECK(localSet.getLocalPoolIdsSerializedSize(true) ==
                 3 * sizeof(lp_id_t) + sizeof(uint8_t));

From 676c9ffcf39c648be8c5cb7fc7f630b585088365 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 16:32:24 +0100
Subject: [PATCH 1657/1774] added header amalagation

---
 datapoollocal/datapoollocal.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 datapoollocal/datapoollocal.h

diff --git a/datapoollocal/datapoollocal.h b/datapoollocal/datapoollocal.h
new file mode 100644
index 000000000..c5c470788
--- /dev/null
+++ b/datapoollocal/datapoollocal.h
@@ -0,0 +1,12 @@
+#ifndef FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_
+#define FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_
+
+/* Collected related headers */
+#include "LocalPoolVariable.h"
+#include "LocalPoolVector.h"
+#include "StaticLocalDataSet.h"
+#include "LocalDataSet.h"
+#include "SharedLocalDataSet.h"
+
+
+#endif /* FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_ */

From 9ba7fabdeab72b71f325a8cf57d11ea089455656 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 16:38:54 +0100
Subject: [PATCH 1658/1774] removed commented out code

---
 unittest/tests/mocks/MessageQueueMockBase.h | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/unittest/tests/mocks/MessageQueueMockBase.h b/unittest/tests/mocks/MessageQueueMockBase.h
index 7b810b41f..31146d34a 100644
--- a/unittest/tests/mocks/MessageQueueMockBase.h
+++ b/unittest/tests/mocks/MessageQueueMockBase.h
@@ -30,10 +30,7 @@ public:
 	}
 
 	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
-		//messageSent = true;
-		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
 		return sendMessage(myQueueId, message);
-		return HasReturnvaluesIF::RETURN_OK;
 	};
 	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom) {
@@ -61,21 +58,13 @@ public:
 	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault = false ) {
-		//messageSent = true;
-		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		//return HasReturnvaluesIF::RETURN_OK;
 		return sendMessage(sendTo, message);
 	}
 	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
 			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-		//messageSent = true;
-		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		//return HasReturnvaluesIF::RETURN_OK;
 		return sendMessage(myQueueId, message);
 	}
 	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
-		//messageSent = true;
-		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
 		return sendMessage(myQueueId, message);
 	}
 	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
@@ -114,7 +103,6 @@ public:
 
 private:
 	std::queue<MessageQueueMessage> messagesSentQueue;
-	//MessageQueueMessage lastMessage;
 };
 
 

From 1e73302ba27f4a9beb1a5084cd3c495b48481c7c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 17:45:22 +0100
Subject: [PATCH 1659/1774] corrected include

---
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 5c277850f..03b0d190c 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -10,7 +10,7 @@
 #include <testcfg/objects/systemObjectList.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
-#include "../../../datapool/PoolReadHelper.h"
+#include <fsfw/datapool/PoolReadGuard.h>
 
 namespace lpool {
 static constexpr lp_id_t uint8VarId = 0;

From 30910034f0af710d49f5f5d3746c4b41ef948137 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 17:46:36 +0100
Subject: [PATCH 1660/1774] tiny improvementst

---
 unittest/tests/datapoollocal/DataSetTest.cpp           | 2 +-
 unittest/tests/datapoollocal/LocalPoolVariableTest.cpp | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 101116cb2..eb587e3f9 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -10,7 +10,7 @@
 
 #include <unittest/core/CatchDefinitions.h>
 
-TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
+TEST_CASE("DataSetTest" , "[DataSetTest]") {
     LocalPoolOwnerBase* poolOwner = objectManager->
             get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
     REQUIRE(poolOwner != nullptr);
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index e5a5d3645..980ffda19 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -10,8 +10,7 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
             get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
     REQUIRE(poolOwner != nullptr);
     REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
-    REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
-            == retval::CATCH_OK);
+    REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() == retval::CATCH_OK);
 
     SECTION("Basic Tests") {
         /* very basic test. */

From 943495117b416d357fd7afa02fc02608b655f4af Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 17:50:10 +0100
Subject: [PATCH 1661/1774] moved preproc block

---
 datapoollocal/LocalDataPoolManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 0c44ab7e5..f572dc026 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -843,6 +843,7 @@ object_id_t LocalDataPoolManager::getCreatorObjectId() const {
 
 void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 		const char* functionName, ReturnValue_t error, const char* errorPrint) {
+#if FSFW_VERBOSE_LEVEL >= 1
 	if(errorPrint == nullptr) {
 		if(error == DATASET_NOT_FOUND) {
 			errorPrint = "Dataset not found";
@@ -873,7 +874,6 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 	}
 
 	if(outputType == sif::OutputTypes::OUT_WARNING) {
-#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalDataPoolManager::" << functionName
 				<< ": Object ID 0x" << std::setw(8) << std::setfill('0')

From 6501c16fd796e9fd2bb2d67dae60319603ca3b53 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 17:51:53 +0100
Subject: [PATCH 1662/1774] fixed preproc block

---
 datapoollocal/LocalDataPoolManager.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f572dc026..5c702f1b6 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -883,10 +883,8 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 		sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
 				functionName, owner->getObjectId(), errorPrint);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 	}
 	else if(outputType == sif::OutputTypes::OUT_ERROR) {
-#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalDataPoolManager::" << functionName
 				<< ": Object ID 0x" << std::setw(8) << std::setfill('0')
@@ -896,8 +894,8 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 		sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
 				functionName, owner->getObjectId(), errorPrint);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 	}
+#endif /* #if FSFW_VERBOSE_LEVEL >= 1 */
 }
 
 LocalDataPoolManager* LocalDataPoolManager::getPoolManagerHandle() {

From b2e4438811f19c72aa34cbead972bd8d33282ffa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 18:03:39 +0100
Subject: [PATCH 1663/1774] added some test, initial tick counter higher now

---
 housekeeping/PeriodicHousekeepingHelper.cpp  | 3 +++
 unittest/tests/datapoollocal/DataSetTest.cpp | 7 +++++++
 2 files changed, 10 insertions(+)

diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
index 365f00048..e73456777 100644
--- a/housekeeping/PeriodicHousekeepingHelper.cpp
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -16,6 +16,9 @@ void PeriodicHousekeepingHelper::initialize(float collectionInterval,
 				nonDiagIntervalFactor;
 	}
 	collectionIntervalTicks = intervalSecondsToInterval(collectionInterval);
+	/* This will cause a checkOpNecessary call to be true immediately. I think it's okay
+	if a HK packet is generated immediately instead of waiting one generation cycle. */
+	internalTickCounter = collectionIntervalTicks;
 }
 
 float PeriodicHousekeepingHelper::getCollectionIntervalInSeconds() {
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index eb587e3f9..9b4509e96 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -80,6 +80,13 @@ TEST_CASE("DataSetTest" , "[DataSetTest]") {
         localSet.localPoolVarUint8 = 0;
         localSet.localPoolVarFloat = 0;
 
+        localSet.setAllVariablesReadOnly();
+        CHECK(localSet.localPoolUint16Vec.getReadWriteMode() == pool_rwm_t::VAR_READ);
+        CHECK(localSet.localPoolVarUint8.getReadWriteMode() == pool_rwm_t::VAR_READ);
+        CHECK(localSet.localPoolVarFloat.getReadWriteMode() == pool_rwm_t::VAR_READ);
+        /* For code coverage */
+        localSet.initializePeriodicHelper(0.0, 0.4, false);
+
         {
             /* Now we read again and check whether our zeroed values were overwritten with
             the values in the pool */

From 3789663db7dac886393b2ad50437f63a86fba56e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 18:26:07 +0100
Subject: [PATCH 1664/1774] added some tests

---
 unittest/tests/datapoollocal/DataSetTest.cpp     |  2 --
 .../tests/datapoollocal/LocalPoolManagerTest.cpp | 16 ++++++++++++++++
 .../tests/datapoollocal/LocalPoolOwnerBase.h     |  6 +++++-
 3 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 9b4509e96..4def46bec 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -84,8 +84,6 @@ TEST_CASE("DataSetTest" , "[DataSetTest]") {
         CHECK(localSet.localPoolUint16Vec.getReadWriteMode() == pool_rwm_t::VAR_READ);
         CHECK(localSet.localPoolVarUint8.getReadWriteMode() == pool_rwm_t::VAR_READ);
         CHECK(localSet.localPoolVarFloat.getReadWriteMode() == pool_rwm_t::VAR_READ);
-        /* For code coverage */
-        localSet.initializePeriodicHelper(0.0, 0.4, false);
 
         {
             /* Now we read again and check whether our zeroed values were overwritten with
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index cd3be9426..fd2c78d70 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -28,6 +28,10 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 
 
     SECTION("BasicTest") {
+        auto owner = poolOwner->poolManager.getOwner();
+        REQUIRE(owner != nullptr);
+        CHECK(owner->getObjectId() == objects::TEST_LOCAL_POOL_OWNER_BASE);
+
         /* Subscribe for message generation on update. */
         REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
         /* Subscribe for an update message. */
@@ -190,6 +194,18 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         REQUIRE(mqMock->receiveMessage(&messageSent) == static_cast<int>(MessageQueueIF::EMPTY));
     }
 
+    SECTION("Periodic HK") {
+        /* Now we subcribe for a HK periodic generation. Even when it's difficult to simulate
+        the temporal behaviour correctly the HK manager should generate a HK packet
+        immediately and the periodic helper depends on HK op function calls anyway instead of
+        using the clock, so we could also just call performHkOperation multiple times */
+        REQUIRE(poolOwner->subscribePeriodicHk() == retval::CATCH_OK);
+        REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+        /* Now HK packet should be sent as message. */
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+    }
+
     /* we need to reset the subscription list because the pool owner
     is a global object. */
     CHECK(poolOwner->reset() == retval::CATCH_OK);
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 8e6b07b00..58ca445cf 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -130,7 +130,7 @@ public:
     }
 
     uint32_t getPeriodicOperationFrequency() const override {
-        return 0;
+        return 0.2;
     }
 
     /**
@@ -169,6 +169,10 @@ public:
         return dynamic_cast<MessageQueueMockBase*>(messageQueue);
     }
 
+    ReturnValue_t subscribePeriodicHk() {
+        return poolManager.subscribeForPeriodicPacket(lpool::testSid, true, 0.2, false);
+    }
+
     ReturnValue_t subscribeWrapperSetUpdate() {
         return poolManager.subscribeForSetUpdateMessage(lpool::testSetId,
                 objects::NO_OBJECT, objects::HK_RECEIVER_MOCK, false);

From 03936fc5c1929dfc152fecb5d06949e1b84a7564 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 19:15:05 +0100
Subject: [PATCH 1665/1774] snapshot test added, bugfix

---
 datapoollocal/LocalDataPoolManager.cpp        | 21 +++++----
 .../datapoollocal/LocalPoolManagerTest.cpp    | 45 ++++++++++++++++++-
 .../tests/datapoollocal/LocalPoolOwnerBase.h  |  5 +++
 3 files changed, 61 insertions(+), 10 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 5c702f1b6..a9668a32f 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -132,13 +132,16 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
 ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
 		ReturnValue_t& status) {
 	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-		// Update packets shall only be generated from datasets.
+		/* Update packets shall only be generated from datasets. */
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
 			receiver.dataId.sid);
+	if(dataSet == nullptr) {
+        return DATASET_NOT_FOUND;
+	}
 	if(dataSet->hasChanged()) {
-		// prepare and send update notification
+		/* Prepare and send update notification */
 		ReturnValue_t result = generateHousekeepingPacket(
 				receiver.dataId.sid, dataSet, true);
 		if(result != HasReturnvaluesIF::RETURN_OK) {
@@ -328,7 +331,7 @@ void LocalDataPoolManager::handleChangeResetLogic(
 			toReset->setChanged(false);
 		}
 		/* All recipients have been notified, reset the changed flag */
-		if(changeInfo.currentUpdateCounter <= 1) {
+		else if(changeInfo.currentUpdateCounter <= 1) {
 			toReset->setChanged(false);
 			changeInfo.currentUpdateCounter = 0;
 		}
@@ -398,7 +401,6 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(sid_t sid,
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
 	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	if(dataSet != nullptr) {
 		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, true);
 		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
@@ -616,7 +618,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 		LocalPoolDataSetBase* dataSet, bool forDownlink,
 		MessageQueueId_t destination) {
 	if(dataSet == nullptr) {
-		// Configuration error.
+		/* Configuration error. */
 		printWarningOrError(sif::OutputTypes::OUT_WARNING,
 				"generateHousekeepingPacket",
 				DATASET_NOT_FOUND);
@@ -632,7 +634,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 		return result;
 	}
 
-	// and now we set a HK message and send it the HK packet destination.
+	/* Now we set a HK message and send it the HK packet destination. */
 	CommandMessage hkMessage;
 	if(LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
 		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
@@ -642,7 +644,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	}
 
 	if(hkQueue == nullptr) {
-		// error, no queue available to send packet with.
+		/* Error, no queue available to send packet with. */
 		printWarningOrError(sif::OutputTypes::OUT_WARNING,
 				"generateHousekeepingPacket",
 				QUEUE_OR_DESTINATION_INVALID);
@@ -650,7 +652,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	}
 	if(destination == MessageQueueIF::NO_QUEUE) {
 		if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
-			// error, all destinations invalid
+			/* Error, all destinations invalid */
 			printWarningOrError(sif::OutputTypes::OUT_WARNING,
 					"generateHousekeepingPacket",
 					QUEUE_OR_DESTINATION_INVALID);
@@ -831,6 +833,9 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 void LocalDataPoolManager::clearReceiversList() {
 	/* Clear the vector completely and releases allocated memory. */
 	HkReceivers().swap(hkReceivers);
+	if(hkUpdateResetList != nullptr) {
+	    HkUpdateResetList().swap(*hkUpdateResetList);
+	}
 }
 
 MutexIF* LocalDataPoolManager::getLocalPoolMutex() {
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index fd2c78d70..685016ed5 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -76,7 +76,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 
     }
 
-    SECTION("SnapshotUpdateTests") {
+    SECTION("SetSnapshotUpdateTest") {
         /* Set the variables in the set to certain values. These are checked later. */
         {
             PoolReadGuard readHelper(&poolOwner->dataset);
@@ -141,7 +141,31 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         CHECK(cdsShort.msDay_ll == Catch::Approx(timeCdsNow.msDay_ll).margin(1));
     }
 
-    SECTION("AdvancedTests") {
+    SECTION("VariableSnapshotTest") {
+        /* Acquire subscription interface */
+        ProvidesDataPoolSubscriptionIF* subscriptionIF = poolOwner->getSubscriptionInterface();
+        REQUIRE(subscriptionIF != nullptr);
+
+        /* Subscribe for variable snapshot */
+        REQUIRE(poolOwner->subscribeWrapperVariableSnapshot(lpool::uint8VarId) == retval::CATCH_OK);
+        auto poolVar = dynamic_cast<lp_var_t<uint8_t>*>(
+                poolOwner->getPoolObjectHandle(lpool::uint8VarId));
+        REQUIRE(poolVar != nullptr);
+        poolVar->setChanged(true);
+        REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+
+        /* Check update snapshot was sent. */
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+
+        /* Should have been reset. */
+        CHECK(poolVar->hasChanged() == false);
+        REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+        CHECK(messageSent.getCommand() == static_cast<int>(
+                HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE));
+    }
+
+    SECTION("VariableUpdateTest") {
         /* Acquire subscription interface */
         ProvidesDataPoolSubscriptionIF* subscriptionIF = poolOwner->getSubscriptionInterface();
         REQUIRE(subscriptionIF != nullptr);
@@ -153,6 +177,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
                 poolOwner->getPoolObjectHandle(lpool::uint8VarId));
         REQUIRE(poolVar != nullptr);
         poolVar->setChanged(true);
+        REQUIRE(poolVar->hasChanged() == true);
         REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 
         /* Check update notification was sent. */
@@ -204,6 +229,22 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         /* Now HK packet should be sent as message. */
         REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
         CHECK(messagesSent == 1);
+
+        LocalPoolDataSetBase* setHandle = poolOwner->getDataSetHandle(lpool::testSid);
+        REQUIRE(setHandle != nullptr);
+        CHECK(poolOwner->poolManager.generateHousekeepingPacket(lpool::testSid,
+                setHandle, false) == retval::CATCH_OK);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+
+        CHECK(setHandle->getReportingEnabled() == true);
+        CommandMessage hkCmd;
+        HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, false);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        CHECK(setHandle->getReportingEnabled() == false);
+        HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true, false);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        CHECK(setHandle->getReportingEnabled() == true);
     }
 
     /* we need to reset the subscription list because the pool owner
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 58ca445cf..f74c47b5b 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -193,6 +193,11 @@ public:
                 MessageQueueIF::NO_QUEUE, objects::HK_RECEIVER_MOCK, false);
     }
 
+    ReturnValue_t subscribeWrapperVariableSnapshot(lp_id_t localPoolId) {
+        return poolManager.subscribeForVariableUpdateMessage(localPoolId,
+                MessageQueueIF::NO_QUEUE, objects::HK_RECEIVER_MOCK, true);
+    }
+
     ReturnValue_t reset() {
         resetSubscriptionList();
         ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;

From 7ad8763b14f200768438d6118de85b7a7de38882 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 19:18:52 +0100
Subject: [PATCH 1666/1774] added more nullptr checks

---
 datapoollocal/LocalDataPoolManager.cpp | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index a9668a32f..9f0eb779f 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -731,6 +731,12 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
 		bool enable, bool isDiagnostics) {
 	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+    if(dataSet == nullptr) {
+        printWarningOrError(sif::OutputTypes::OUT_WARNING, "togglePeriodicGeneration",
+                DATASET_NOT_FOUND);
+        return DATASET_NOT_FOUND;
+    }
+
 	if((LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and not isDiagnostics) or
 			(not LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
@@ -748,6 +754,12 @@ ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 		float newCollectionInterval, bool isDiagnostics) {
 	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	if(dataSet == nullptr) {
+        printWarningOrError(sif::OutputTypes::OUT_WARNING, "changeCollectionInterval",
+                DATASET_NOT_FOUND);
+	    return DATASET_NOT_FOUND;
+	}
+
 	bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
 	if((targetIsDiagnostics and not isDiagnostics) or
 			(not targetIsDiagnostics and isDiagnostics)) {
@@ -768,13 +780,11 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		bool isDiagnostics) {
-	// Get and check dataset first.
-	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	/* Get and check dataset first. */
 	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
 	if(dataSet == nullptr) {
 		printWarningOrError(sif::OutputTypes::OUT_WARNING,
-				"performPeriodicHkGeneration",
-				DATASET_NOT_FOUND);
+				"performPeriodicHkGeneration", DATASET_NOT_FOUND);
 		return DATASET_NOT_FOUND;
 	}
 
@@ -833,6 +843,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 void LocalDataPoolManager::clearReceiversList() {
 	/* Clear the vector completely and releases allocated memory. */
 	HkReceivers().swap(hkReceivers);
+	/* Also clear the reset helper if it exists */
 	if(hkUpdateResetList != nullptr) {
 	    HkUpdateResetList().swap(*hkUpdateResetList);
 	}

From 6c0972b2d5770d066f2b0666ad40a33caed364a8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 21:17:08 +0100
Subject: [PATCH 1667/1774] several bugfixes

---
 datapoollocal/HasLocalDataPoolIF.h            |  2 +-
 datapoollocal/LocalDataPoolManager.cpp        |  2 +-
 datapoollocal/LocalPoolDataSetBase.cpp        |  9 ++
 datapoollocal/LocalPoolDataSetBase.h          |  8 ++
 housekeeping/HousekeepingMessage.cpp          | 10 +-
 housekeeping/PeriodicHousekeepingHelper.cpp   | 94 +++++++++++++------
 housekeeping/PeriodicHousekeepingHelper.h     |  8 +-
 .../datapoollocal/LocalPoolManagerTest.cpp    |  7 ++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  |  4 +-
 9 files changed, 106 insertions(+), 38 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index d52c72b6c..ec25f082c 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -65,7 +65,7 @@ public:
      * usually be the period the pool owner performs its periodic operation.
      * @return
      */
-    virtual uint32_t getPeriodicOperationFrequency() const = 0;
+    virtual dur_millis_t getPeriodicOperationFrequency() const = 0;
 
     /**
      * @brief   This function will be called by the manager if an update
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 9f0eb779f..83e30e824 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -770,7 +770,7 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 			LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
 
 	if(periodicHelper == nullptr) {
-		// config error
+		/* Configuration error, set might not have a corresponding pool manager */
 		return PERIODIC_HELPER_INVALID;
 	}
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 2d70712b2..3abbf0dd2 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -308,3 +308,12 @@ void LocalPoolDataSetBase::setAllVariablesReadOnly() {
         registeredVariables[idx]->setReadWriteMode(pool_rwm_t::VAR_READ);
     }
 }
+
+float LocalPoolDataSetBase::getCollectionInterval() const {
+    if(periodicHelper != nullptr) {
+        return periodicHelper->getCollectionIntervalInSeconds();
+    }
+    else {
+        return 0.0;
+    }
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index b9946aaf5..39ea9f1ac 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -168,6 +168,14 @@ public:
 
     bool getReportingEnabled() const;
 
+    /**
+     * Returns the current periodic HK generation interval this set
+     * belongs to a HK manager and the interval is not 0. Otherwise,
+     * returns 0.0
+     * @return
+     */
+    float getCollectionInterval() const;
+
 protected:
     sid_t sid;
     //! This mutex is used if the data is created by one object only.
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index d9803ef65..58f8551d9 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -84,15 +84,21 @@ void HousekeepingMessage::setCollectionIntervalModificationCommand(
 	else {
 		command->setCommand(MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL);
 	}
-	command->setParameter3(collectionInterval);
+
+	/* Raw storage of the float in the message. Do not use setParameter3, does
+	implicit conversion to integer type! */
+	std::memcpy(command->getData() + 2 * sizeof(uint32_t), &collectionInterval,
+	        sizeof(collectionInterval));
 
 	setSid(command, sid);
 }
 
 sid_t HousekeepingMessage::getCollectionIntervalModificationCommand(
 		const CommandMessage* command, float* newCollectionInterval) {
+
 	if(newCollectionInterval != nullptr) {
-		*newCollectionInterval = command->getParameter3();
+	    std::memcpy(newCollectionInterval, command->getData() + 2 * sizeof(uint32_t),
+	            sizeof(*newCollectionInterval));
 	}
 
 	return getSid(command);
diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
index e73456777..b0dd8522f 100644
--- a/housekeeping/PeriodicHousekeepingHelper.cpp
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -4,49 +4,85 @@
 #include <cmath>
 
 PeriodicHousekeepingHelper::PeriodicHousekeepingHelper(
-		LocalPoolDataSetBase* owner): owner(owner) {}
+        LocalPoolDataSetBase* owner): owner(owner) {}
 
 
 void PeriodicHousekeepingHelper::initialize(float collectionInterval,
-		dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
-		uint8_t nonDiagIntervalFactor) {
-	this->minimumPeriodicInterval = minimumPeriodicInterval;
-	if(not isDiagnostics) {
-		this->minimumPeriodicInterval = this->minimumPeriodicInterval *
-				nonDiagIntervalFactor;
-	}
-	collectionIntervalTicks = intervalSecondsToInterval(collectionInterval);
-	/* This will cause a checkOpNecessary call to be true immediately. I think it's okay
+        dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
+        uint8_t nonDiagIntervalFactor) {
+    this->isDiagnostics = isDiagnostics;
+    this->minimumPeriodicInterval = minimumPeriodicInterval;
+    this->nonDiagIntervalFactor = nonDiagIntervalFactor;
+    collectionIntervalTicks = intervalSecondsToIntervalTicks(collectionInterval);
+    /* This will cause a checkOpNecessary call to be true immediately. I think it's okay
 	if a HK packet is generated immediately instead of waiting one generation cycle. */
-	internalTickCounter = collectionIntervalTicks;
+    internalTickCounter = collectionIntervalTicks;
 }
 
-float PeriodicHousekeepingHelper::getCollectionIntervalInSeconds() {
-	return intervalToIntervalSeconds(collectionIntervalTicks);
+float PeriodicHousekeepingHelper::getCollectionIntervalInSeconds() const {
+    return intervalTicksToSeconds(collectionIntervalTicks);
 }
 
 bool PeriodicHousekeepingHelper::checkOpNecessary() {
-	if(internalTickCounter >= collectionIntervalTicks) {
-		internalTickCounter = 1;
-		return true;
-	}
-	internalTickCounter++;
-	return false;
+    if(internalTickCounter >= collectionIntervalTicks) {
+        internalTickCounter = 1;
+        return true;
+    }
+    internalTickCounter++;
+    return false;
 }
 
-uint32_t PeriodicHousekeepingHelper::intervalSecondsToInterval(
-		float collectionIntervalSeconds) {
-        return std::ceil(collectionIntervalSeconds * 1000
-                / minimumPeriodicInterval);
+uint32_t PeriodicHousekeepingHelper::intervalSecondsToIntervalTicks(
+        float collectionIntervalSeconds) {
+    /* Avoid division by zero */
+    if(minimumPeriodicInterval == 0) {
+        if(isDiagnostics) {
+            /* Perform operation each cycle */
+            return 1;
+        }
+        else {
+            return nonDiagIntervalFactor;
+        }
+    }
+    else {
+        dur_millis_t intervalInMs = collectionIntervalSeconds * 1000;
+        uint32_t divisor = minimumPeriodicInterval;
+        if(not isDiagnostics) {
+            /* We need to multiply the divisor because non-diagnostics only
+            allow a multiple of the minimum periodic interval */
+            divisor *= nonDiagIntervalFactor;
+        }
+        uint32_t ticks = std::ceil(static_cast<float>(intervalInMs) / divisor);
+        if(not isDiagnostics) {
+            /* Now we need to multiply the calculated ticks with the factor as as well
+            because the minimum tick count to generate a non-diagnostic is
+            the factor.
+
+            Example calculation for non-diagnostic with
+            0.4 second interval and 0.2 second task interval.
+            Resultant tick count of 5 is equal to operation each second.
+
+            Examle calculation for non-diagnostic with  2.0 second interval and 0.2 second
+            task interval.
+            Resultant tick count of 10 is equal to operatin every 2 seconds.
+
+            Example calculation for diagnostic with 0.4 second interval and 0.3
+            second task interval. Resulting tick count of 2 is equal to operation
+            every 0.6 seconds. */
+            ticks *= nonDiagIntervalFactor;
+        }
+        return ticks;
+    }
 }
 
-float PeriodicHousekeepingHelper::intervalToIntervalSeconds(
-		uint32_t collectionInterval) {
-	return static_cast<float>(collectionInterval *
-			minimumPeriodicInterval);
+float PeriodicHousekeepingHelper::intervalTicksToSeconds(
+        uint32_t collectionInterval) const {
+    /* Number of ticks times the minimum interval is in milliseconds, so we divide by 1000 to get
+    the value in seconds */
+    return static_cast<float>(collectionInterval * minimumPeriodicInterval / 1000.0);
 }
 
 void PeriodicHousekeepingHelper::changeCollectionInterval(
-		float newIntervalSeconds) {
-	collectionIntervalTicks = intervalSecondsToInterval(newIntervalSeconds);
+        float newIntervalSeconds) {
+    collectionIntervalTicks = intervalSecondsToIntervalTicks(newIntervalSeconds);
 }
diff --git a/housekeeping/PeriodicHousekeepingHelper.h b/housekeeping/PeriodicHousekeepingHelper.h
index d96eae1d4..3e8d030e6 100644
--- a/housekeeping/PeriodicHousekeepingHelper.h
+++ b/housekeeping/PeriodicHousekeepingHelper.h
@@ -15,13 +15,15 @@ public:
 			uint8_t nonDiagIntervalFactor);
 
 	void changeCollectionInterval(float newInterval);
-	float getCollectionIntervalInSeconds();
+	float getCollectionIntervalInSeconds() const;
 	bool checkOpNecessary();
 private:
 	LocalPoolDataSetBase* owner = nullptr;
+	bool isDiagnostics = true;
+	uint8_t nonDiagIntervalFactor = 0;
 
-	uint32_t intervalSecondsToInterval(float collectionIntervalSeconds);
-	float intervalToIntervalSeconds(uint32_t collectionInterval);
+	uint32_t intervalSecondsToIntervalTicks(float collectionIntervalSeconds);
+	float intervalTicksToSeconds(uint32_t collectionInterval) const;
 
 	dur_millis_t minimumPeriodicInterval = 0;
 	uint32_t internalTickCounter = 1;
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 685016ed5..1ab871519 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -245,6 +245,13 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true, false);
         CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
         CHECK(setHandle->getReportingEnabled() == true);
+
+        HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd,
+                lpool::testSid, 0.4, false);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        /* For non-diagnostics and a specified minimum frequency of 0.2 seconds, the
+        resulting collection interval should be 1.0 second */
+        CHECK(poolOwner->dataset.getCollectionInterval() == 1.0);
     }
 
     /* we need to reset the subscription list because the pool owner
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index f74c47b5b..20c565ffc 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -129,8 +129,8 @@ public:
         return &poolManager;
     }
 
-    uint32_t getPeriodicOperationFrequency() const override {
-        return 0.2;
+    dur_millis_t getPeriodicOperationFrequency() const override {
+        return 200;
     }
 
     /**

From c59fa578c7aa7aabaf5aa58782c4bf425a226cdf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 21:18:47 +0100
Subject: [PATCH 1668/1774] format improvements

---
 housekeeping/PeriodicHousekeepingHelper.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
index b0dd8522f..5152706fa 100644
--- a/housekeeping/PeriodicHousekeepingHelper.cpp
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -55,8 +55,7 @@ uint32_t PeriodicHousekeepingHelper::intervalSecondsToIntervalTicks(
         uint32_t ticks = std::ceil(static_cast<float>(intervalInMs) / divisor);
         if(not isDiagnostics) {
             /* Now we need to multiply the calculated ticks with the factor as as well
-            because the minimum tick count to generate a non-diagnostic is
-            the factor.
+            because the minimum tick count to generate a non-diagnostic is the factor itself.
 
             Example calculation for non-diagnostic with
             0.4 second interval and 0.2 second task interval.

From 4f89fc62abfc5587dd84ebde3e2d040f5cbd0ecf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 21:38:13 +0100
Subject: [PATCH 1669/1774] continued tests

---
 .../datapoollocal/LocalPoolManagerTest.cpp    | 30 +++++++++++++++++--
 .../tests/datapoollocal/LocalPoolOwnerBase.h  |  4 +--
 2 files changed, 29 insertions(+), 5 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 1ab871519..4457e85bc 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -219,14 +219,14 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         REQUIRE(mqMock->receiveMessage(&messageSent) == static_cast<int>(MessageQueueIF::EMPTY));
     }
 
-    SECTION("Periodic HK") {
+    SECTION("PeriodicHKAndMessaging") {
         /* Now we subcribe for a HK periodic generation. Even when it's difficult to simulate
         the temporal behaviour correctly the HK manager should generate a HK packet
         immediately and the periodic helper depends on HK op function calls anyway instead of
         using the clock, so we could also just call performHkOperation multiple times */
-        REQUIRE(poolOwner->subscribePeriodicHk() == retval::CATCH_OK);
+        REQUIRE(poolOwner->subscribePeriodicHk(true) == retval::CATCH_OK);
         REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
-        /* Now HK packet should be sent as message. */
+        /* Now HK packet should be sent as message immediately. */
         REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
         CHECK(messagesSent == 1);
 
@@ -242,9 +242,19 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, false);
         CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
         CHECK(setHandle->getReportingEnabled() == false);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
         HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true, false);
         CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
         CHECK(setHandle->getReportingEnabled() == true);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+
+        HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, false);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        CHECK(setHandle->getReportingEnabled() == false);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
 
         HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd,
                 lpool::testSid, 0.4, false);
@@ -252,6 +262,20 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         /* For non-diagnostics and a specified minimum frequency of 0.2 seconds, the
         resulting collection interval should be 1.0 second */
         CHECK(poolOwner->dataset.getCollectionInterval() == 1.0);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+
+        HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, false);
+        REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        /* Now HK packet should be sent as message. */
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+
+        HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, false);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
     }
 
     /* we need to reset the subscription list because the pool owner
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 20c565ffc..eb6d8a5d8 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -169,8 +169,8 @@ public:
         return dynamic_cast<MessageQueueMockBase*>(messageQueue);
     }
 
-    ReturnValue_t subscribePeriodicHk() {
-        return poolManager.subscribeForPeriodicPacket(lpool::testSid, true, 0.2, false);
+    ReturnValue_t subscribePeriodicHk(bool enableReporting) {
+        return poolManager.subscribeForPeriodicPacket(lpool::testSid, enableReporting, 0.2, false);
     }
 
     ReturnValue_t subscribeWrapperSetUpdate() {

From dcde177fe38fc29ea6d02cf6024f31b7f8dcf7ba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 22:08:05 +0100
Subject: [PATCH 1670/1774] added additional tests for more than 8 variables

---
 unittest/tests/datapoollocal/DataSetTest.cpp | 45 ++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 4def46bec..c11c66c22 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -207,6 +207,51 @@ TEST_CASE("DataSetTest" , "[DataSetTest]") {
 
     }
 
+    SECTION("MorePoolVariables") {
+        LocalDataSet set(poolOwner, 2, 10);
+
+        /* Register same variables again to get more than 8 registered variables */
+        for(uint8_t idx = 0; idx < 8; idx ++) {
+            REQUIRE(set.registerVariable(&localSet.localPoolVarUint8) == retval::CATCH_OK);
+        }
+        REQUIRE(set.registerVariable(&localSet.localPoolVarUint8) == retval::CATCH_OK);
+        REQUIRE(set.registerVariable(&localSet.localPoolUint16Vec) == retval::CATCH_OK);
+
+        set.setValidityBufferGeneration(true);
+        {
+            PoolReadGuard readHelper(&localSet);
+            localSet.localPoolVarUint8.value = 42;
+            localSet.localPoolVarUint8.setValid(true);
+            localSet.localPoolUint16Vec.setValid(false);
+        }
+
+        size_t maxSize = set.getSerializedSize();
+        CHECK(maxSize == 9 + sizeof(uint16_t) * 3 + 2);
+        size_t serSize = 0;
+        /* Already reserve additional space for validity buffer, will be needed later */
+        uint8_t buffer[maxSize + 1];
+        uint8_t* buffPtr = buffer;
+        CHECK(set.serialize(&buffPtr, &serSize, maxSize,
+                SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+        std::array<uint8_t, 2> validityBuffer;
+        std::memcpy(validityBuffer.data(), buffer + 9 + sizeof(uint16_t) * 3, 2);
+        /* The first 9 variables should be valid */
+        CHECK(validityBuffer[0] == 0xff);
+        CHECK(bitutil::bitGet(validityBuffer.data() + 1, 0) == true);
+        CHECK(bitutil::bitGet(validityBuffer.data() + 1, 1) == false);
+
+        /* Now we invert the validity */
+        validityBuffer[0] = 0;
+        validityBuffer[1] = 0b0100'0000;
+        std::memcpy(buffer + 9 + sizeof(uint16_t) * 3, validityBuffer.data(), 2);
+        const uint8_t* constBuffPtr = buffer;
+        size_t sizeToDeSerialize = serSize;
+        CHECK(set.deSerialize(&constBuffPtr, &sizeToDeSerialize, SerializeIF::Endianness::MACHINE)
+                == retval::CATCH_OK);
+        CHECK(localSet.localPoolVarUint8.isValid() == false);
+        CHECK(localSet.localPoolUint16Vec.isValid() == true);
+    }
+
     /* we need to reset the subscription list because the pool owner
     is a global object. */
     CHECK(poolOwner->reset() == retval::CATCH_OK);

From 8d28bc4b6addfb9d48279ad5cf1e44d56fe1cab2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 22:19:55 +0100
Subject: [PATCH 1671/1774] added source file

---
 unittest/tests/datapoollocal/CMakeLists.txt   |   1 +
 .../datapoollocal/LocalPoolManagerTest.cpp    |   2 +
 .../datapoollocal/LocalPoolOwnerBase.cpp      |  91 ++++++++++++++++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 101 +++---------------
 4 files changed, 108 insertions(+), 87 deletions(-)
 create mode 100644 unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp

diff --git a/unittest/tests/datapoollocal/CMakeLists.txt b/unittest/tests/datapoollocal/CMakeLists.txt
index f196a080a..1c98e7dc2 100644
--- a/unittest/tests/datapoollocal/CMakeLists.txt
+++ b/unittest/tests/datapoollocal/CMakeLists.txt
@@ -3,4 +3,5 @@ target_sources(${TARGET_NAME} PRIVATE
 	LocalPoolVectorTest.cpp
 	DataSetTest.cpp
 	LocalPoolManagerTest.cpp
+	LocalPoolOwnerBase.cpp
 )
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 4457e85bc..cce55e1a5 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -276,6 +276,8 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
         REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
         CHECK(messagesSent == 1);
+
+        HousekeepingMessage::setUpdateNotificationSetCommand(&hkCmd, lpool::testSid);
     }
 
     /* we need to reset the subscription list because the pool owner
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp b/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp
new file mode 100644
index 000000000..7abbd4542
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp
@@ -0,0 +1,91 @@
+#include "LocalPoolOwnerBase.h"
+
+LocalPoolOwnerBase::LocalPoolOwnerBase(object_id_t objectId):
+        SystemObject(objectId), poolManager(this, messageQueue),
+        dataset(this, lpool::testSetId) {
+    messageQueue = new MessageQueueMockBase();
+}
+
+ReturnValue_t LocalPoolOwnerBase::initializeHkManager() {
+    if(not initialized) {
+        initialized = true;
+        return poolManager.initialize(messageQueue);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalPoolOwnerBase::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+        LocalDataPoolManager &poolManager) {
+
+    // Default initialization empty for now.
+    localDataPoolMap.emplace(lpool::uint8VarId,
+            new PoolEntry<uint8_t>({0}));
+    localDataPoolMap.emplace(lpool::floatVarId,
+            new PoolEntry<float>({0}));
+    localDataPoolMap.emplace(lpool::uint32VarId,
+            new PoolEntry<uint32_t>({0}));
+
+    localDataPoolMap.emplace(lpool::uint16Vec3Id,
+            new PoolEntry<uint16_t>({0, 0, 0}));
+    localDataPoolMap.emplace(lpool::int64Vec2Id,
+            new PoolEntry<int64_t>({0, 0}));
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+LocalPoolObjectBase* LocalPoolOwnerBase::getPoolObjectHandle(lp_id_t localPoolId) {
+    if(localPoolId == lpool::uint8VarId) {
+        return &testUint8;
+    }
+    else if(localPoolId == lpool::uint16Vec3Id) {
+        return &testUint16Vec;
+    }
+    else if(localPoolId == lpool::floatVarId) {
+        return &testFloat;
+    }
+    else if(localPoolId == lpool::int64Vec2Id) {
+        return &testInt64Vec;
+    }
+    else if(localPoolId == lpool::uint32VarId) {
+        return &testUint32;
+    }
+    else {
+        return &testUint8;
+    }
+}
+
+ReturnValue_t LocalPoolOwnerBase::reset() {
+    resetSubscriptionList();
+    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+    {
+        PoolReadGuard readHelper(&dataset);
+        if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
+            status = readHelper.getReadResult();
+        }
+        dataset.localPoolVarUint8.value = 0;
+        dataset.localPoolVarFloat.value = 0.0;
+        dataset.localPoolUint16Vec.value[0] = 0;
+        dataset.localPoolUint16Vec.value[1] = 0;
+        dataset.localPoolUint16Vec.value[2] = 0;
+        dataset.setValidity(false, true);
+    }
+
+    {
+        PoolReadGuard readHelper(&testUint32);
+        if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
+            status = readHelper.getReadResult();
+        }
+        testUint32.value = 0;
+        testUint32.setValid(false);
+    }
+
+    {
+        PoolReadGuard readHelper(&testInt64Vec);
+        if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
+            status = readHelper.getReadResult();
+        }
+        testInt64Vec.value[0] = 0;
+        testInt64Vec.value[1] = 0;
+        testInt64Vec.setValid(false);
+    }
+    return status;
+}
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index eb6d8a5d8..fc009544f 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -70,12 +70,7 @@ private:
 
 class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
 public:
-    LocalPoolOwnerBase(
-            object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE):
-                SystemObject(objectId), poolManager(this, messageQueue),
-                dataset(this, lpool::testSetId) {
-        messageQueue = new MessageQueueMockBase();
-    }
+    LocalPoolOwnerBase(object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE);
 
     ~LocalPoolOwnerBase() {
         QueueFactory::instance()->deleteMessageQueue(messageQueue);
@@ -85,13 +80,7 @@ public:
         return SystemObject::getObjectId();
     }
 
-    ReturnValue_t initializeHkManager() {
-        if(not initialized) {
-            initialized = true;
-            return poolManager.initialize(messageQueue);
-        }
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+    ReturnValue_t initializeHkManager();
 
     ReturnValue_t initializeHkManagerAfterTaskCreation() {
         if(not initializedAfterTaskCreation) {
@@ -107,23 +96,8 @@ public:
     }
 
     // This is called by initializeAfterTaskCreation of the HK manager.
-    virtual ReturnValue_t initializeLocalDataPool(
-            localpool::DataPool& localDataPoolMap,
-            LocalDataPoolManager& poolManager) {
-        // Default initialization empty for now.
-        localDataPoolMap.emplace(lpool::uint8VarId,
-                new PoolEntry<uint8_t>({0}));
-        localDataPoolMap.emplace(lpool::floatVarId,
-                new PoolEntry<float>({0}));
-        localDataPoolMap.emplace(lpool::uint32VarId,
-                new PoolEntry<uint32_t>({0}));
-
-        localDataPoolMap.emplace(lpool::uint16Vec3Id,
-                new PoolEntry<uint16_t>({0, 0, 0}));
-        localDataPoolMap.emplace(lpool::int64Vec2Id,
-                new PoolEntry<int64_t>({0, 0}));
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+    virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override;
 
     LocalDataPoolManager* getHkManagerHandle() override {
         return &poolManager;
@@ -143,27 +117,7 @@ public:
         return &dataset;
     }
 
-    virtual LocalPoolObjectBase* getPoolObjectHandle(
-            lp_id_t localPoolId) override {
-        if(localPoolId == lpool::uint8VarId) {
-            return &testUint8;
-        }
-        else if(localPoolId == lpool::uint16Vec3Id) {
-            return &testUint16Vec;
-        }
-        else if(localPoolId == lpool::floatVarId) {
-            return &testFloat;
-        }
-        else if(localPoolId == lpool::int64Vec2Id) {
-            return &testInt64Vec;
-        }
-        else if(localPoolId == lpool::uint32VarId) {
-            return &testUint32;
-        }
-        else {
-            return &testUint8;
-        }
-    }
+    virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) override;
 
     MessageQueueMockBase* getMockQueueHandle() const {
         return dynamic_cast<MessageQueueMockBase*>(messageQueue);
@@ -198,51 +152,24 @@ public:
                 MessageQueueIF::NO_QUEUE, objects::HK_RECEIVER_MOCK, true);
     }
 
-    ReturnValue_t reset() {
-        resetSubscriptionList();
-        ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-        {
-            PoolReadGuard readHelper(&dataset);
-            if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
-                status = readHelper.getReadResult();
-            }
-            dataset.localPoolVarUint8.value = 0;
-            dataset.localPoolVarFloat.value = 0.0;
-            dataset.localPoolUint16Vec.value[0] = 0;
-            dataset.localPoolUint16Vec.value[1] = 0;
-            dataset.localPoolUint16Vec.value[2] = 0;
-            dataset.setValidity(false, true);
-        }
-
-        {
-            PoolReadGuard readHelper(&testUint32);
-            if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
-                status = readHelper.getReadResult();
-            }
-            testUint32.value = 0;
-            testUint32.setValid(false);
-        }
-
-        {
-            PoolReadGuard readHelper(&testInt64Vec);
-            if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
-                status = readHelper.getReadResult();
-            }
-            testInt64Vec.value[0] = 0;
-            testInt64Vec.value[1] = 0;
-            testInt64Vec.setValid(false);
-        }
-        return status;
-    }
+    ReturnValue_t reset();
 
     void resetSubscriptionList() {
         poolManager.clearReceiversList();
     }
 
+    void handleChangedDataset(sid_t sid, store_address_t storeId) {
+        this->thisSidHasChanged = sid;
+        this->storeIdForChangedSid = storeId;
+    }
+
     LocalDataPoolManager poolManager;
     LocalPoolTestDataSet dataset;
 private:
 
+    sid_t thisSidHasChanged;
+    store_address_t storeIdForChangedSid;
+
     lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
     lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
     lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);

From 620b2ae79e551b110e37f45f8e9123100b326a89 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Mar 2021 23:16:47 +0100
Subject: [PATCH 1672/1774] weird bug

---
 datapoollocal/SharedLocalDataSet.cpp          | 13 ++++++
 datapoollocal/SharedLocalDataSet.h            |  9 +++-
 unittest/tests/datapoollocal/DataSetTest.cpp  |  6 +++
 .../datapoollocal/LocalPoolManagerTest.cpp    |  5 +++
 .../datapoollocal/LocalPoolOwnerBase.cpp      | 43 +++++++++++++++++++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 23 +++++-----
 6 files changed, 84 insertions(+), 15 deletions(-)

diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
index dd1bdcc40..9915628ea 100644
--- a/datapoollocal/SharedLocalDataSet.cpp
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -1,5 +1,6 @@
 #include "SharedLocalDataSet.h"
 
+
 SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
         const size_t maxSize): SystemObject(objectId),
         LocalPoolDataSetBase(sid, nullptr, maxSize) {
@@ -11,6 +12,18 @@ ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
     return datasetLock->lockMutex(MutexIF::TimeoutType::WAITING, mutexTimeout);
 }
 
+SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId,
+        HasLocalDataPoolIF *owner, uint32_t setId,
+        const size_t maxSize): SystemObject(objectId),
+        LocalPoolDataSetBase(owner, setId, nullptr, maxSize) {
+    this->setContainer(poolVarVector.data());
+    datasetLock = MutexFactory::instance()->createMutex();
+}
+
+SharedLocalDataSet::~SharedLocalDataSet() {
+    MutexFactory::instance()->deleteMutex(datasetLock);
+}
+
 ReturnValue_t SharedLocalDataSet::unlockDataset() {
     return datasetLock->unlockMutex();
 }
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index 83f2a72f1..bbb47da49 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -11,15 +11,20 @@
  * multiple threads. It provides a lock in addition to all other functionalities provided
  * by the LocalPoolDataSetBase class.
  *
- * TODO: override and protect read, commit and some other calls used by pool manager.
+ * The user is completely responsible for lockingand unlocking the dataset when using the
+ * shared dataset.
  */
 class SharedLocalDataSet:
         public SystemObject,
         public LocalPoolDataSetBase,
         public SharedDataSetIF {
 public:
-    SharedLocalDataSet(object_id_t objectId, sid_t sid,
+    SharedLocalDataSet(object_id_t objectId, HasLocalDataPoolIF* owner, uint32_t setId,
             const size_t maxSize);
+    SharedLocalDataSet(object_id_t objectId, sid_t sid, const size_t maxSize);
+
+    virtual~ SharedLocalDataSet();
+
     ReturnValue_t lockDataset(dur_millis_t mutexTimeout) override;
     ReturnValue_t unlockDataset() override;
 private:
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index c11c66c22..30b5bb059 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -6,6 +6,7 @@
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/datapoollocal/SharedLocalDataSet.h>
 #include <fsfw/globalfunctions/bitutility.h>
 
 #include <unittest/core/CatchDefinitions.h>
@@ -252,6 +253,11 @@ TEST_CASE("DataSetTest" , "[DataSetTest]") {
         CHECK(localSet.localPoolUint16Vec.isValid() == true);
     }
 
+    SECTION("SharedDataSet") {
+        object_id_t sharedSetId = objects::SHARED_SET_ID;
+        SharedLocalDataSet sharedSet(sharedSetId, poolOwner, 2, 5);
+    }
+
     /* we need to reset the subscription list because the pool owner
     is a global object. */
     CHECK(poolOwner->reset() == retval::CATCH_OK);
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index cce55e1a5..2d7294efa 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -278,6 +278,11 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         CHECK(messagesSent == 1);
 
         HousekeepingMessage::setUpdateNotificationSetCommand(&hkCmd, lpool::testSid);
+        sid_t sidToCheck;
+        store_address_t storeId;
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        CHECK(poolOwner->changedDataSetCallbackWasCalled(sidToCheck, storeId) == true);
+        CHECK(sidToCheck == lpool::testSid);
     }
 
     /* we need to reset the subscription list because the pool owner
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp b/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp
index 7abbd4542..0e2703a77 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp
@@ -89,3 +89,46 @@ ReturnValue_t LocalPoolOwnerBase::reset() {
     }
     return status;
 }
+
+bool LocalPoolOwnerBase::changedDataSetCallbackWasCalled(sid_t &sid, store_address_t &storeId) {
+    bool condition = false;
+    if(not this->changedDatasetSid.notSet()) {
+        condition = true;
+    }
+    sid = changedDatasetSid;
+    storeId = storeIdForChangedSet;
+    this->changedDatasetSid.raw = sid_t::INVALID_SID;
+    this->storeIdForChangedSet = storeId::INVALID_STORE_ADDRESS;
+    return condition;
+}
+
+void LocalPoolOwnerBase::handleChangedDataset(sid_t sid, store_address_t storeId) {
+    this->changedDatasetSid = sid;
+    this->storeIdForChangedSet = storeId;
+}
+
+bool LocalPoolOwnerBase::changedVariableCallbackWasCalled(gp_id_t &gpid, store_address_t &storeId) {
+    bool condition = false;
+    if(not this->changedPoolVariableGpid.notSet()) {
+        condition = true;
+    }
+    gpid = changedPoolVariableGpid;
+    storeId = storeIdForChangedVariable;
+    this->changedPoolVariableGpid.raw = gp_id_t::INVALID_GPID;
+    this->storeIdForChangedVariable = storeId::INVALID_STORE_ADDRESS;
+    return condition;
+}
+
+ReturnValue_t LocalPoolOwnerBase::initializeHkManagerAfterTaskCreation() {
+    if(not initializedAfterTaskCreation) {
+        initializedAfterTaskCreation = true;
+        return poolManager.initializeAfterTaskCreation();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+void LocalPoolOwnerBase::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId) {
+    this->changedPoolVariableGpid = globPoolId;
+    this->storeIdForChangedVariable = storeId;
+}
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index fc009544f..7915eeb4d 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -82,13 +82,7 @@ public:
 
     ReturnValue_t initializeHkManager();
 
-    ReturnValue_t initializeHkManagerAfterTaskCreation() {
-        if(not initializedAfterTaskCreation) {
-            initializedAfterTaskCreation = true;
-            return poolManager.initializeAfterTaskCreation();
-        }
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+    ReturnValue_t initializeHkManagerAfterTaskCreation();
 
     /** Command queue for housekeeping messages. */
     MessageQueueId_t getCommandQueue() const override {
@@ -158,17 +152,20 @@ public:
         poolManager.clearReceiversList();
     }
 
-    void handleChangedDataset(sid_t sid, store_address_t storeId) {
-        this->thisSidHasChanged = sid;
-        this->storeIdForChangedSid = storeId;
-    }
+    bool changedDataSetCallbackWasCalled(sid_t& sid, store_address_t& storeId);
+    bool changedVariableCallbackWasCalled(gp_id_t& gpid, store_address_t& storeId);
 
     LocalDataPoolManager poolManager;
     LocalPoolTestDataSet dataset;
 private:
 
-    sid_t thisSidHasChanged;
-    store_address_t storeIdForChangedSid;
+    void handleChangedDataset(sid_t sid, store_address_t storeId) override;
+    sid_t changedDatasetSid;
+    store_address_t storeIdForChangedSet;
+
+    void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId) override;
+    gp_id_t changedPoolVariableGpid;
+    store_address_t storeIdForChangedVariable;
 
     lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
     lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);

From 78b6a83285df57f1df6354a474cf774d45e30d9b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 00:18:17 +0100
Subject: [PATCH 1673/1774] issues with virtual inheritanc3

---
 datapool/PoolDataSetBase.cpp                   |  3 +--
 datapool/SharedDataSetIF.h                     |  7 +++++--
 datapoollocal/LocalPoolDataSetBase.cpp         |  2 +-
 datapoollocal/SharedLocalDataSet.cpp           | 18 +++++++++++++-----
 datapoollocal/SharedLocalDataSet.h             |  3 ++-
 unittest/tests/datapoollocal/DataSetTest.cpp   | 10 +++++++---
 .../tests/datapoollocal/LocalPoolOwnerBase.h   |  4 ++--
 7 files changed, 31 insertions(+), 16 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index bdca22c3d..73ec4bd70 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -8,8 +8,7 @@
 PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
         const size_t maxFillCount):
         registeredVariables(registeredVariablesArray),
-        maxFillCount(maxFillCount) {
-}
+        maxFillCount(maxFillCount) {}
 
 PoolDataSetBase::~PoolDataSetBase() {}
 
diff --git a/datapool/SharedDataSetIF.h b/datapool/SharedDataSetIF.h
index b8d98794d..da21f9cfc 100644
--- a/datapool/SharedDataSetIF.h
+++ b/datapool/SharedDataSetIF.h
@@ -1,13 +1,16 @@
 #ifndef FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_
 #define FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_
+
 #include "PoolDataSetIF.h"
 
-class SharedDataSetIF: public PoolDataSetIF {
+class SharedDataSetIF:
+        public PoolDataSetIF {
 public:
     virtual ~SharedDataSetIF() {};
 
 private:
-    virtual ReturnValue_t lockDataset(dur_millis_t mutexTimeout) = 0;
+    virtual ReturnValue_t lockDataset(MutexIF::TimeoutType timeoutType,
+            dur_millis_t mutexTimeout) = 0;
     virtual ReturnValue_t unlockDataset() = 0;
 };
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 3abbf0dd2..d93b926d2 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -44,7 +44,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
-                PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
     if(hkOwner != nullptr) {
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
index 9915628ea..abcf7da96 100644
--- a/datapoollocal/SharedLocalDataSet.cpp
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -8,10 +8,6 @@ SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
     datasetLock = MutexFactory::instance()->createMutex();
 }
 
-ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
-    return datasetLock->lockMutex(MutexIF::TimeoutType::WAITING, mutexTimeout);
-}
-
 SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId,
         HasLocalDataPoolIF *owner, uint32_t setId,
         const size_t maxSize): SystemObject(objectId),
@@ -20,10 +16,22 @@ SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId,
     datasetLock = MutexFactory::instance()->createMutex();
 }
 
+ReturnValue_t SharedLocalDataSet::lockDataset(MutexIF::TimeoutType timeoutType,
+        dur_millis_t mutexTimeout) {
+    if(datasetLock != nullptr) {
+        return datasetLock->lockMutex(timeoutType, mutexTimeout);
+    }
+    return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+
 SharedLocalDataSet::~SharedLocalDataSet() {
     MutexFactory::instance()->deleteMutex(datasetLock);
 }
 
 ReturnValue_t SharedLocalDataSet::unlockDataset() {
-    return datasetLock->unlockMutex();
+    if(datasetLock != nullptr) {
+        return datasetLock->unlockMutex();
+    }
+    return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index bbb47da49..8d12610a8 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -25,7 +25,8 @@ public:
 
     virtual~ SharedLocalDataSet();
 
-    ReturnValue_t lockDataset(dur_millis_t mutexTimeout) override;
+    ReturnValue_t lockDataset(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+            dur_millis_t mutexTimeout = 20) override;
     ReturnValue_t unlockDataset() override;
 private:
 
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 30b5bb059..ecc1921f1 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -4,9 +4,9 @@
 #include <catch2/catch_approx.hpp>
 
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/SharedLocalDataSet.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/datapool/PoolReadGuard.h>
-#include <fsfw/datapoollocal/SharedLocalDataSet.h>
 #include <fsfw/globalfunctions/bitutility.h>
 
 #include <unittest/core/CatchDefinitions.h>
@@ -254,8 +254,12 @@ TEST_CASE("DataSetTest" , "[DataSetTest]") {
     }
 
     SECTION("SharedDataSet") {
-        object_id_t sharedSetId = objects::SHARED_SET_ID;
-        SharedLocalDataSet sharedSet(sharedSetId, poolOwner, 2, 5);
+//        object_id_t sharedSetId = objects::SHARED_SET_ID;
+//        SharedLocalDataSet sharedSet(sharedSetId, poolOwner, 2, 5);
+//        CHECK(sharedSet.initialize() == retval::CATCH_OK);
+//        CHECK(sharedSet.lockDataset() == retval::CATCH_OK);
+//
+//        CHECK(sharedSet.unlockDataset() == retval::CATCH_OK);
     }
 
     /* we need to reset the subscription list because the pool owner
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 7915eeb4d..9a7639f84 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -36,11 +36,11 @@ static const gp_id_t uint64Vec2Id = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE,
 class LocalPoolStaticTestDataSet: public StaticLocalDataSet<3> {
 public:
     LocalPoolStaticTestDataSet():
-        StaticLocalDataSet(lpool::testSid) {
+            StaticLocalDataSet(lpool::testSid) {
     }
 
     LocalPoolStaticTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
-        StaticLocalDataSet(owner, setId) {
+            StaticLocalDataSet(owner, setId) {
     }
 
     lp_var_t<uint8_t> localPoolVarUint8 = lp_var_t<uint8_t>(lpool::uint8VarGpid, this);

From 824f272432b51fee59e9061f6118e4f0aa2f4e47 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 01:04:39 +0100
Subject: [PATCH 1674/1774] no virtual inhertience for now

---
 datapool/PoolDataSetIF.h                          |  4 ++--
 datapool/SharedDataSetIF.h                        |  3 +--
 unittest/tests/datapoollocal/DataSetTest.cpp      | 12 ++++++------
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h | 10 ++++++++--
 4 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index 9151f2f8e..f905cc4d7 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -9,8 +9,8 @@
  *          and unlock a data pool and read/commit semantics.
  */
 class PoolDataSetIF:
-        public DataSetIF,
-        public ReadCommitIF {
+        virtual public DataSetIF,
+        virtual public ReadCommitIF {
 public:
     virtual~ PoolDataSetIF() {};
 
diff --git a/datapool/SharedDataSetIF.h b/datapool/SharedDataSetIF.h
index da21f9cfc..4d23f87f5 100644
--- a/datapool/SharedDataSetIF.h
+++ b/datapool/SharedDataSetIF.h
@@ -3,8 +3,7 @@
 
 #include "PoolDataSetIF.h"
 
-class SharedDataSetIF:
-        public PoolDataSetIF {
+class SharedDataSetIF {
 public:
     virtual ~SharedDataSetIF() {};
 
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index ecc1921f1..06964d266 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -254,12 +254,12 @@ TEST_CASE("DataSetTest" , "[DataSetTest]") {
     }
 
     SECTION("SharedDataSet") {
-//        object_id_t sharedSetId = objects::SHARED_SET_ID;
-//        SharedLocalDataSet sharedSet(sharedSetId, poolOwner, 2, 5);
-//        CHECK(sharedSet.initialize() == retval::CATCH_OK);
-//        CHECK(sharedSet.lockDataset() == retval::CATCH_OK);
-//
-//        CHECK(sharedSet.unlockDataset() == retval::CATCH_OK);
+        object_id_t sharedSetId = objects::SHARED_SET_ID;
+        SharedLocalDataSet sharedSet(sharedSetId, poolOwner, 2, 5);
+        CHECK(sharedSet.initialize() == retval::CATCH_OK);
+        CHECK(sharedSet.lockDataset() == retval::CATCH_OK);
+
+        CHECK(sharedSet.unlockDataset() == retval::CATCH_OK);
     }
 
     /* we need to reset the subscription list because the pool owner
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 9a7639f84..f08b9eb94 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -36,7 +36,8 @@ static const gp_id_t uint64Vec2Id = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE,
 class LocalPoolStaticTestDataSet: public StaticLocalDataSet<3> {
 public:
     LocalPoolStaticTestDataSet():
-            StaticLocalDataSet(lpool::testSid) {
+        StaticLocalDataSet(lpool::testSid) {
+
     }
 
     LocalPoolStaticTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
@@ -53,7 +54,12 @@ private:
 class LocalPoolTestDataSet: public LocalDataSet {
 public:
     LocalPoolTestDataSet():
-        LocalDataSet(lpool::testSid, lpool::dataSetMaxVariables) {
+        LocalDataSet(lpool::testSid, lpool::dataSetMaxVariables),
+        localPoolVarUint8(lpool::uint8VarGpid, this),
+        localPoolVarFloat(lpool::floatVarGpid, this),
+        localPoolUint16Vec(lpool::uint16Vec3Gpid, this)
+
+    {
     }
 
     LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):

From 6f78c13dcfb8343563339c30d90f3cc5134ed38c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 11:06:23 +0100
Subject: [PATCH 1675/1774] added addtional nullptr check

---
 datapoollocal/LocalDataPoolManager.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index d06cf2c6a..2ec81f1cf 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -391,6 +391,10 @@ protected:
 
 template<class T> inline
 ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
+    if(poolEntry == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
         printWarningOrError(sif::OutputTypes::OUT_WARNING, "fetchPoolEntry",

From 3bacc8ec53b1370ce6829af7e3c69ae7a0b21b5d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 12:04:54 +0100
Subject: [PATCH 1676/1774] more tests and bugfixes

---
 datapoollocal/LocalDataPoolManager.cpp        | 20 ++++++--
 datapoollocal/LocalPoolDataSetBase.cpp        |  8 ++-
 datapoollocal/LocalPoolDataSetBase.h          |  5 +-
 .../internal/LocalPoolDataSetAttorney.h       |  5 +-
 housekeeping/PeriodicHousekeepingHelper.cpp   | 11 ++--
 housekeeping/PeriodicHousekeepingHelper.h     |  7 ++-
 .../datapoollocal/LocalPoolManagerTest.cpp    | 51 ++++++++++++++++++-
 .../datapoollocal/LocalPoolOwnerBase.cpp      |  5 ++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 15 ++----
 unittest/tests/mocks/MessageQueueMockBase.h   | 11 ++++
 10 files changed, 103 insertions(+), 35 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 83e30e824..cad54094e 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -38,7 +38,11 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQue
 	hkQueue = queueToUse;
 }
 
-LocalDataPoolManager::~LocalDataPoolManager() {}
+LocalDataPoolManager::~LocalDataPoolManager() {
+    if(mutex != nullptr) {
+        MutexFactory::instance()->deleteMutex(mutex);
+    }
+}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
 	if(queueToUse == nullptr) {
@@ -375,7 +379,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enableReporting);
 		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
 		LocalPoolDataSetAttorney::initializePeriodicHelper(*dataSet, collectionInterval,
-				owner->getPeriodicOperationFrequency(), isDiagnostics);
+				owner->getPeriodicOperationFrequency());
 	}
 
 	hkReceivers.push_back(hkReceiver);
@@ -518,11 +522,19 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 	}
 
 	case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES): {
-		return generateSetStructurePacket(sid, true);
+		result = generateSetStructurePacket(sid, true);
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+		    return result;
+		}
+		break;
 	}
 
 	case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
-		return generateSetStructurePacket(sid, false);
+		result = generateSetStructurePacket(sid, false);
+        if(result == HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        break;
 	}
 	case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
 	case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index d93b926d2..2a2444c48 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -264,11 +264,9 @@ bool LocalPoolDataSetBase::getReportingEnabled() const {
     return reportingEnabled;
 }
 
-void LocalPoolDataSetBase::initializePeriodicHelper(
-        float collectionInterval, dur_millis_t minimumPeriodicInterval,
-        bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
-    periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
-            isDiagnostics, nonDiagIntervalFactor);
+void LocalPoolDataSetBase::initializePeriodicHelper(float collectionInterval,
+        dur_millis_t minimumPeriodicInterval, uint8_t nonDiagIntervalFactor) {
+    periodicHelper->initialize(collectionInterval, minimumPeriodicInterval, nonDiagIntervalFactor);
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 39ea9f1ac..ab67dc3f9 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -191,9 +191,8 @@ protected:
     bool reportingEnabled = false;
     void setReportingEnabled(bool enabled);
 
-    void initializePeriodicHelper(float collectionInterval,
-            dur_millis_t minimumPeriodicInterval,
-            bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5);
+    void initializePeriodicHelper(float collectionInterval, dur_millis_t minimumPeriodicInterval,
+            uint8_t nonDiagIntervalFactor = 5);
 
     /**
      * If the valid state of a dataset is always relevant to the whole
diff --git a/datapoollocal/internal/LocalPoolDataSetAttorney.h b/datapoollocal/internal/LocalPoolDataSetAttorney.h
index 7a34e9c8e..f81428cd1 100644
--- a/datapoollocal/internal/LocalPoolDataSetAttorney.h
+++ b/datapoollocal/internal/LocalPoolDataSetAttorney.h
@@ -14,9 +14,8 @@ private:
     }
 
     static void initializePeriodicHelper(LocalPoolDataSetBase& set, float collectionInterval,
-            uint32_t minimumPeriodicIntervalMs,
-            bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5) {
-        set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs, isDiagnostics,
+            uint32_t minimumPeriodicIntervalMs, uint8_t nonDiagIntervalFactor = 5) {
+        set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs,
                 nonDiagIntervalFactor);
     }
 
diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
index 5152706fa..892eb354a 100644
--- a/housekeeping/PeriodicHousekeepingHelper.cpp
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -6,11 +6,8 @@
 PeriodicHousekeepingHelper::PeriodicHousekeepingHelper(
         LocalPoolDataSetBase* owner): owner(owner) {}
 
-
 void PeriodicHousekeepingHelper::initialize(float collectionInterval,
-        dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
-        uint8_t nonDiagIntervalFactor) {
-    this->isDiagnostics = isDiagnostics;
+        dur_millis_t minimumPeriodicInterval, uint8_t nonDiagIntervalFactor) {
     this->minimumPeriodicInterval = minimumPeriodicInterval;
     this->nonDiagIntervalFactor = nonDiagIntervalFactor;
     collectionIntervalTicks = intervalSecondsToIntervalTicks(collectionInterval);
@@ -34,6 +31,11 @@ bool PeriodicHousekeepingHelper::checkOpNecessary() {
 
 uint32_t PeriodicHousekeepingHelper::intervalSecondsToIntervalTicks(
         float collectionIntervalSeconds) {
+    if(owner == nullptr) {
+        return 0;
+    }
+    bool isDiagnostics = owner->isDiagnostics();
+
     /* Avoid division by zero */
     if(minimumPeriodicInterval == 0) {
         if(isDiagnostics) {
@@ -85,3 +87,4 @@ void PeriodicHousekeepingHelper::changeCollectionInterval(
         float newIntervalSeconds) {
     collectionIntervalTicks = intervalSecondsToIntervalTicks(newIntervalSeconds);
 }
+
diff --git a/housekeeping/PeriodicHousekeepingHelper.h b/housekeeping/PeriodicHousekeepingHelper.h
index 3e8d030e6..3256fbffa 100644
--- a/housekeeping/PeriodicHousekeepingHelper.h
+++ b/housekeeping/PeriodicHousekeepingHelper.h
@@ -10,16 +10,15 @@ class PeriodicHousekeepingHelper {
 public:
 	PeriodicHousekeepingHelper(LocalPoolDataSetBase* owner);
 
-	void initialize(float collectionInterval,
-			dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
-			uint8_t nonDiagIntervalFactor);
+	void initialize(float collectionInterval, dur_millis_t minimumPeriodicInterval,
+	        uint8_t nonDiagIntervalFactor);
 
 	void changeCollectionInterval(float newInterval);
 	float getCollectionIntervalInSeconds() const;
 	bool checkOpNecessary();
+
 private:
 	LocalPoolDataSetBase* owner = nullptr;
-	bool isDiagnostics = true;
 	uint8_t nonDiagIntervalFactor = 0;
 
 	uint32_t intervalSecondsToIntervalTicks(float collectionIntervalSeconds);
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 2d7294efa..c152078d9 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -229,6 +229,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         /* Now HK packet should be sent as message immediately. */
         REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
         CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
 
         LocalPoolDataSetBase* setHandle = poolOwner->getDataSetHandle(lpool::testSid);
         REQUIRE(setHandle != nullptr);
@@ -236,6 +237,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
                 setHandle, false) == retval::CATCH_OK);
         REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
         CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
 
         CHECK(setHandle->getReportingEnabled() == true);
         CommandMessage hkCmd;
@@ -244,17 +246,19 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         CHECK(setHandle->getReportingEnabled() == false);
         REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
         CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
+
         HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true, false);
         CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
         CHECK(setHandle->getReportingEnabled() == true);
         REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
-        CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
 
         HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, false);
         CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
         CHECK(setHandle->getReportingEnabled() == false);
         REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
-        CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
 
         HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd,
                 lpool::testSid, 0.4, false);
@@ -264,6 +268,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         CHECK(poolOwner->dataset.getCollectionInterval() == 1.0);
         REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
         CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
 
         HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, false);
         REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
@@ -271,11 +276,13 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         /* Now HK packet should be sent as message. */
         REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
         CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
 
         HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, false);
         CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
         REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
         CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
 
         HousekeepingMessage::setUpdateNotificationSetCommand(&hkCmd, lpool::testSid);
         sid_t sidToCheck;
@@ -283,6 +290,46 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
         CHECK(poolOwner->changedDataSetCallbackWasCalled(sidToCheck, storeId) == true);
         CHECK(sidToCheck == lpool::testSid);
+
+        /* Now we test the handling is the dataset is set to diagnostic */
+        poolOwner->dataset.setDiagnostic(true);
+
+        HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, false);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) ==
+                static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
+        /* We still expect a failure message being sent */
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
+
+        HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd,
+                lpool::testSid, 0.4, false);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) ==
+                static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
+
+        HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, false);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) ==
+                static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
+
+        HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, true);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
+
+        HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd, lpool::testSid, 0.4,
+                true);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
+
     }
 
     /* we need to reset the subscription list because the pool owner
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp b/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp
index 0e2703a77..7ccceb063 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp
@@ -6,6 +6,10 @@ LocalPoolOwnerBase::LocalPoolOwnerBase(object_id_t objectId):
     messageQueue = new MessageQueueMockBase();
 }
 
+LocalPoolOwnerBase::~LocalPoolOwnerBase() {
+    QueueFactory::instance()->deleteMessageQueue(messageQueue);
+}
+
 ReturnValue_t LocalPoolOwnerBase::initializeHkManager() {
     if(not initialized) {
         initialized = true;
@@ -132,3 +136,4 @@ void LocalPoolOwnerBase::handleChangedPoolVariable(gp_id_t globPoolId, store_add
     this->changedPoolVariableGpid = globPoolId;
     this->storeIdForChangedVariable = storeId;
 }
+
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index f08b9eb94..c045b6d39 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -54,13 +54,7 @@ private:
 class LocalPoolTestDataSet: public LocalDataSet {
 public:
     LocalPoolTestDataSet():
-        LocalDataSet(lpool::testSid, lpool::dataSetMaxVariables),
-        localPoolVarUint8(lpool::uint8VarGpid, this),
-        localPoolVarFloat(lpool::floatVarGpid, this),
-        localPoolUint16Vec(lpool::uint16Vec3Gpid, this)
-
-    {
-    }
+        LocalDataSet(lpool::testSid, lpool::dataSetMaxVariables) {}
 
     LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
         LocalDataSet(owner, setId, lpool::dataSetMaxVariables) {
@@ -70,6 +64,9 @@ public:
     lp_var_t<float> localPoolVarFloat = lp_var_t<float>(lpool::floatVarGpid, this);
     lp_vec_t<uint16_t, 3> localPoolUint16Vec = lp_vec_t<uint16_t, 3>(lpool::uint16Vec3Gpid, this);
 
+    void setDiagnostic(bool isDiagnostic) {
+        LocalPoolDataSetBase::setDiagnostic(isDiagnostic);
+    }
 private:
 };
 
@@ -78,9 +75,7 @@ class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
 public:
     LocalPoolOwnerBase(object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE);
 
-    ~LocalPoolOwnerBase() {
-        QueueFactory::instance()->deleteMessageQueue(messageQueue);
-    }
+    ~LocalPoolOwnerBase();
 
     object_id_t getObjectId() const override {
         return SystemObject::getObjectId();
diff --git a/unittest/tests/mocks/MessageQueueMockBase.h b/unittest/tests/mocks/MessageQueueMockBase.h
index 31146d34a..3000f7fb5 100644
--- a/unittest/tests/mocks/MessageQueueMockBase.h
+++ b/unittest/tests/mocks/MessageQueueMockBase.h
@@ -29,6 +29,16 @@ public:
 		return tempMessageSent;
 	}
 
+	/**
+	 * Pop a message, clearing it in the process.
+	 * @return
+	 */
+	ReturnValue_t popMessage() {
+	    CommandMessage message;
+	    message.clear();
+	    return receiveMessage(&message);
+	}
+
 	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
 		return sendMessage(myQueueId, message);
 	};
@@ -36,6 +46,7 @@ public:
 			MessageQueueId_t *receivedFrom) {
 		return receiveMessage(message);
 	}
+
 	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
 		if(messagesSentQueue.empty()) {
 			return MessageQueueIF::EMPTY;

From 8b83de6ca9fbd9b574a5a178a4b884267527bacc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 12:33:26 +0100
Subject: [PATCH 1677/1774] added way to automatically clear unhandled messages

---
 datapoollocal/HasLocalDataPoolIF.h            | 23 +++++++-----
 datapoollocal/LocalDataPoolManager.cpp        | 19 +++++++---
 housekeeping/HousekeepingMessage.cpp          |  3 +-
 .../datapoollocal/LocalPoolManagerTest.cpp    | 36 ++++++++++++++++++-
 .../datapoollocal/LocalPoolOwnerBase.cpp      |  6 ++--
 .../tests/datapoollocal/LocalPoolOwnerBase.h  |  5 +--
 6 files changed, 73 insertions(+), 19 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index ec25f082c..54856fac3 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -72,12 +72,15 @@ public:
      *          notification is received.
      * @details  HasLocalDataPoolIF
      * Can be overriden by the child class to handle changed datasets.
-     * @param sid
-     * @param storeId If a snapshot was requested, data will be located inside
+     * @param sid           SID of the updated set
+     * @param storeId       If a snapshot was requested, data will be located inside
      * the IPC store with this store ID.
+     * @param clearMessage  If this is set to true, the pool manager will take care of
+     *                      clearing the store automatically
      */
     virtual void handleChangedDataset(sid_t sid,
-            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
+            store_address_t storeId = storeId::INVALID_STORE_ADDRESS,
+            bool* clearMessage = nullptr) {
         return;
     }
 
@@ -85,13 +88,17 @@ public:
      * @brief   This function will be called by the manager if an update
      *          notification is received.
      * @details
-     * Can be overriden by the child class to handle changed pool IDs.
-     * @param sid
-     * @param storeId If a snapshot was requested, data will be located inside
+     * Can be overriden by the child class to handle changed pool variables.
+     * @param gpid          GPID of the updated variable.
+     * @param storeId       If a snapshot was requested, data will be located inside
      * the IPC store with this store ID.
+     * @param clearMessage  Relevant for snapshots. If the boolean this points to is set to true,
+     *                      the pool manager will take care of clearing the store automatically
+     *                      after the callback.
      */
-    virtual void handleChangedPoolVariable(gp_id_t globPoolId,
-            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
+    virtual void handleChangedPoolVariable(gp_id_t gpid,
+            store_address_t storeId = storeId::INVALID_STORE_ADDRESS,
+            bool* clearMessage = nullptr) {
         return;
     }
 
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index cad54094e..e9bb57c48 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -554,14 +554,15 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 	case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
 	case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
 		LocalPoolDataSetBase* dataSet =HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-		//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 		if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
 				and LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
-			return WRONG_HK_PACKET_TYPE;
+			result = WRONG_HK_PACKET_TYPE;
+			break;
 		}
 		else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
 				and not LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
-			return WRONG_HK_PACKET_TYPE;
+            result = WRONG_HK_PACKET_TYPE;
+            break;
 		}
 		return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
 				dataSet, true);
@@ -580,14 +581,22 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 	case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
 		store_address_t storeId;
 		HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
-		owner->handleChangedDataset(sid, storeId);
+		bool clearMessage = true;
+		owner->handleChangedDataset(sid, storeId, &clearMessage);
+		if(clearMessage) {
+	        message->clear();
+		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
 		store_address_t storeId;
 		gp_id_t globPoolId = HousekeepingMessage::getUpdateSnapshotVariableCommand(message,
 		        &storeId);
-		owner->handleChangedPoolVariable(globPoolId, storeId);
+        bool clearMessage = true;
+		owner->handleChangedPoolVariable(globPoolId, storeId, &clearMessage);
+		if(clearMessage) {
+	        message->clear();
+		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 58f8551d9..90ca73c8c 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -157,7 +157,8 @@ void HousekeepingMessage::clear(CommandMessage* message) {
     case(DIAGNOSTICS_REPORT):
     case(HK_DEFINITIONS_REPORT):
     case(DIAGNOSTICS_DEFINITION_REPORT):
-    case(UPDATE_SNAPSHOT_SET): {
+    case(UPDATE_SNAPSHOT_SET):
+    case(UPDATE_SNAPSHOT_VARIABLE): {
         store_address_t storeId;
         getHkDataReply(message, &storeId);
         StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index c152078d9..883327192 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -26,8 +26,11 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
     CommandMessage messageSent;
     uint8_t messagesSent = 0;
 
-
     SECTION("BasicTest") {
+        {
+            /* For code coverage, should not crash */
+            LocalDataPoolManager manager(nullptr, nullptr);
+        }
         auto owner = poolOwner->poolManager.getOwner();
         REQUIRE(owner != nullptr);
         CHECK(owner->getObjectId() == objects::TEST_LOCAL_POOL_OWNER_BASE);
@@ -330,6 +333,37 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         CHECK(messagesSent == 1);
         CHECK(mqMock->popMessage() == retval::CATCH_OK);
 
+        HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true, true);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
+
+        HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, true);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
+
+        HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, false);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) ==
+                static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
+
+        HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, true);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+        CHECK(messagesSent == 1);
+        CHECK(mqMock->popMessage() == retval::CATCH_OK);
+
+        HousekeepingMessage::setUpdateNotificationVariableCommand(&hkCmd, lpool::uint8VarGpid);
+        gp_id_t gpidToCheck;
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        CHECK(poolOwner->changedVariableCallbackWasCalled(gpidToCheck, storeId) == true);
+        CHECK(gpidToCheck == lpool::testSid);
+
     }
 
     /* we need to reset the subscription list because the pool owner
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp b/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp
index 7ccceb063..991314a9d 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.cpp
@@ -106,7 +106,8 @@ bool LocalPoolOwnerBase::changedDataSetCallbackWasCalled(sid_t &sid, store_addre
     return condition;
 }
 
-void LocalPoolOwnerBase::handleChangedDataset(sid_t sid, store_address_t storeId) {
+void LocalPoolOwnerBase::handleChangedDataset(sid_t sid, store_address_t storeId,
+        bool* clearMessage) {
     this->changedDatasetSid = sid;
     this->storeIdForChangedSet = storeId;
 }
@@ -132,7 +133,8 @@ ReturnValue_t LocalPoolOwnerBase::initializeHkManagerAfterTaskCreation() {
 
 }
 
-void LocalPoolOwnerBase::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId) {
+void LocalPoolOwnerBase::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
+        bool* clearMessage) {
     this->changedPoolVariableGpid = globPoolId;
     this->storeIdForChangedVariable = storeId;
 }
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index c045b6d39..8d2073b0e 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -160,11 +160,12 @@ public:
     LocalPoolTestDataSet dataset;
 private:
 
-    void handleChangedDataset(sid_t sid, store_address_t storeId) override;
+    void handleChangedDataset(sid_t sid, store_address_t storeId, bool* clearMessage) override;
     sid_t changedDatasetSid;
     store_address_t storeIdForChangedSet;
 
-    void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId) override;
+    void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
+            bool* clearMessage) override;
     gp_id_t changedPoolVariableGpid;
     store_address_t storeIdForChangedVariable;
 

From e55f74a00ef51047f4a450d1e826ef0e081615e7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 12:34:25 +0100
Subject: [PATCH 1678/1774] default auto clearance

---
 datapoollocal/HasLocalDataPoolIF.h | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 54856fac3..74e372c9e 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -81,7 +81,9 @@ public:
     virtual void handleChangedDataset(sid_t sid,
             store_address_t storeId = storeId::INVALID_STORE_ADDRESS,
             bool* clearMessage = nullptr) {
-        return;
+        if(clearMessage != nullptr) {
+            *clearMessage = true;
+        }
     }
 
     /**
@@ -99,7 +101,9 @@ public:
     virtual void handleChangedPoolVariable(gp_id_t gpid,
             store_address_t storeId = storeId::INVALID_STORE_ADDRESS,
             bool* clearMessage = nullptr) {
-        return;
+        if(clearMessage != nullptr) {
+            *clearMessage = true;
+        }
     }
 
     /**

From 33823b445c79c8e273527642f412eba650545b25 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 12:44:35 +0100
Subject: [PATCH 1679/1774] some more tests added

---
 datapoollocal/LocalDataPoolManager.cpp           |  2 +-
 datapoollocal/localPoolDefinitions.h             |  4 ++--
 globalfunctions/arrayprinter.cpp                 |  4 ++++
 .../tests/datapoollocal/LocalPoolManagerTest.cpp | 16 +++++++++++++++-
 4 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index e9bb57c48..94ee9c264 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -592,7 +592,7 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		store_address_t storeId;
 		gp_id_t globPoolId = HousekeepingMessage::getUpdateSnapshotVariableCommand(message,
 		        &storeId);
-        bool clearMessage = true;
+		bool clearMessage = true;
 		owner->handleChangedPoolVariable(globPoolId, storeId, &clearMessage);
 		if(clearMessage) {
 	        message->clear();
diff --git a/datapoollocal/localPoolDefinitions.h b/datapoollocal/localPoolDefinitions.h
index af8ce7115..daab8b9c0 100644
--- a/datapoollocal/localPoolDefinitions.h
+++ b/datapoollocal/localPoolDefinitions.h
@@ -96,11 +96,11 @@ union gp_id_t {
         return raw == INVALID_GPID;
     }
 
-    bool operator==(const sid_t& other) const {
+    bool operator==(const gp_id_t& other) const {
         return raw == other.raw;
     }
 
-    bool operator!=(const sid_t& other) const {
+    bool operator!=(const gp_id_t& other) const {
         return not (raw == other.raw);
     }
 };
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index 7dc056b08..20a64f5b6 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -67,7 +67,9 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
             }
         }
     }
+#if FSFW_DISABLE_PRINTOUT == 0
     printf("[%s]\n", printBuffer);
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
 #endif
 }
 
@@ -108,7 +110,9 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
             }
         }
     }
+#if FSFW_DISABLE_PRINTOUT == 0
     printf("[%s]\n", printBuffer);
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
 #endif
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 883327192..a98db6103 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -362,7 +362,21 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         gp_id_t gpidToCheck;
         CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
         CHECK(poolOwner->changedVariableCallbackWasCalled(gpidToCheck, storeId) == true);
-        CHECK(gpidToCheck == lpool::testSid);
+        CHECK(gpidToCheck == lpool::uint8VarGpid);
+
+        HousekeepingMessage::setUpdateSnapshotSetCommand(&hkCmd, lpool::testSid,
+                storeId::INVALID_STORE_ADDRESS);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        CHECK(poolOwner->changedDataSetCallbackWasCalled(sidToCheck, storeId) == true);
+        CHECK(sidToCheck == lpool::testSid);
+
+        HousekeepingMessage::setUpdateSnapshotVariableCommand(&hkCmd, lpool::uint8VarGpid,
+                storeId::INVALID_STORE_ADDRESS);
+        CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+        CHECK(poolOwner->changedVariableCallbackWasCalled(gpidToCheck, storeId) == true);
+        CHECK(gpidToCheck == lpool::uint8VarGpid);
+
+        poolOwner->poolManager.printPoolEntry(lpool::uint8VarId);
 
     }
 

From 9602a3ed6a9b451ae9b704ba8a3fbbd6e85c9afe Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 13:02:10 +0100
Subject: [PATCH 1680/1774] bugfix and a few more tests

---
 datapool/PoolDataSetBase.cpp                 |  4 ++++
 datapoollocal/SharedLocalDataSet.cpp         |  4 ++--
 unittest/tests/datapoollocal/DataSetTest.cpp | 20 ++++++++++++++++++--
 3 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 73ec4bd70..60f08b88c 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -14,6 +14,10 @@ PoolDataSetBase::~PoolDataSetBase() {}
 
 
 ReturnValue_t PoolDataSetBase::registerVariable(PoolVariableIF *variable) {
+    if(registeredVariables == nullptr) {
+        /* Underlying container invalid */
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
     if (state != States::STATE_SET_UNINITIALISED) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "DataSet::registerVariable: Call made in wrong position." << std::endl;
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
index abcf7da96..84c2d1c37 100644
--- a/datapoollocal/SharedLocalDataSet.cpp
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -3,7 +3,7 @@
 
 SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
         const size_t maxSize): SystemObject(objectId),
-        LocalPoolDataSetBase(sid, nullptr, maxSize) {
+        LocalPoolDataSetBase(sid, nullptr, maxSize), poolVarVector(maxSize) {
     this->setContainer(poolVarVector.data());
     datasetLock = MutexFactory::instance()->createMutex();
 }
@@ -11,7 +11,7 @@ SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
 SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId,
         HasLocalDataPoolIF *owner, uint32_t setId,
         const size_t maxSize): SystemObject(objectId),
-        LocalPoolDataSetBase(owner, setId, nullptr, maxSize) {
+        LocalPoolDataSetBase(owner, setId, nullptr, maxSize), poolVarVector(maxSize)  {
     this->setContainer(poolVarVector.data());
     datasetLock = MutexFactory::instance()->createMutex();
 }
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index 06964d266..ce4d9d437 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -255,11 +255,27 @@ TEST_CASE("DataSetTest" , "[DataSetTest]") {
 
     SECTION("SharedDataSet") {
         object_id_t sharedSetId = objects::SHARED_SET_ID;
-        SharedLocalDataSet sharedSet(sharedSetId, poolOwner, 2, 5);
+        SharedLocalDataSet sharedSet(sharedSetId, poolOwner, lpool::testSetId, 5);
+        localSet.localPoolVarUint8.setReadWriteMode(pool_rwm_t::VAR_WRITE);
+        localSet.localPoolUint16Vec.setReadWriteMode(pool_rwm_t::VAR_WRITE);
+        CHECK(sharedSet.registerVariable(&localSet.localPoolVarUint8) == retval::CATCH_OK);
+        CHECK(sharedSet.registerVariable(&localSet.localPoolUint16Vec) == retval::CATCH_OK);
         CHECK(sharedSet.initialize() == retval::CATCH_OK);
         CHECK(sharedSet.lockDataset() == retval::CATCH_OK);
-
         CHECK(sharedSet.unlockDataset() == retval::CATCH_OK);
+
+        {
+            //PoolReadGuard rg(&sharedSet);
+            //CHECK(rg.getReadResult() == retval::CATCH_OK);
+            localSet.localPoolVarUint8.value = 5;
+            localSet.localPoolUint16Vec.value[0] = 1;
+            localSet.localPoolUint16Vec.value[1] = 2;
+            localSet.localPoolUint16Vec.value[2] = 3;
+            CHECK(sharedSet.commit() == retval::CATCH_OK);
+        }
+
+        sharedSet.setReadCommitProtectionBehaviour(true);
+
     }
 
     /* we need to reset the subscription list because the pool owner

From c527391b106d49b0d4d72590fb6c88fb0ac03e34 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 13:14:49 +0100
Subject: [PATCH 1681/1774] removed unfisnihed stuff from PR

---
 osal/windows/CMakeLists.txt     |   1 -
 osal/windows/TcWinTcpServer.cpp | 177 --------------------------------
 osal/windows/TcWinTcpServer.h   |  56 ----------
 3 files changed, 234 deletions(-)
 delete mode 100644 osal/windows/TcWinTcpServer.cpp
 delete mode 100644 osal/windows/TcWinTcpServer.h

diff --git a/osal/windows/CMakeLists.txt b/osal/windows/CMakeLists.txt
index 889ea3396..a3a719e0a 100644
--- a/osal/windows/CMakeLists.txt
+++ b/osal/windows/CMakeLists.txt
@@ -1,7 +1,6 @@
 target_sources(${LIB_FSFW_NAME} PRIVATE 
     TcWinUdpPollingTask.cpp
     TmTcWinUdpBridge.cpp
-    TcWinTcpServer.cpp
 )
 
 target_link_libraries(${LIB_FSFW_NAME} PRIVATE
diff --git a/osal/windows/TcWinTcpServer.cpp b/osal/windows/TcWinTcpServer.cpp
deleted file mode 100644
index f85147f04..000000000
--- a/osal/windows/TcWinTcpServer.cpp
+++ /dev/null
@@ -1,177 +0,0 @@
-#include "TcWinTcpServer.h"
-#include "../../serviceinterface/ServiceInterface.h"
-
-#include <winsock2.h>
-#include <ws2tcpip.h>
-
-const std::string TcWinTcpServer::DEFAULT_TCP_SERVER_PORT =  "7301";
-const std::string TcWinTcpServer::DEFAULT_TCP_CLIENT_PORT =  "7302";
-
-TcWinTcpServer::TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
-        std::string customTcpServerPort):
-        SystemObject(objectId), tcpPort(customTcpServerPort) {
-    if(tcpPort == "") {
-        tcpPort = DEFAULT_TCP_SERVER_PORT;
-    }
-}
-
-ReturnValue_t TcWinTcpServer::initialize() {
-    int retval = 0;
-    struct addrinfo *addrResult = nullptr;
-    struct addrinfo hints;
-    /* Initiates Winsock DLL. */
-    WSAData wsaData;
-    WORD wVersionRequested = MAKEWORD(2, 2);
-    int err = WSAStartup(wVersionRequested, &wsaData);
-    if (err != 0) {
-        /* Tell the user that we could not find a usable Winsock DLL. */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: WSAStartup failed with error: " <<
-                err << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    ZeroMemory(&hints, sizeof (hints));
-    hints.ai_family = AF_INET;
-    hints.ai_socktype = SOCK_STREAM;
-    hints.ai_protocol = IPPROTO_TCP;
-    hints.ai_flags = AI_PASSIVE;
-
-    retval = getaddrinfo(nullptr, tcpPort.c_str(), &hints, &addrResult);
-    if (retval != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TcWinTcpServer::TcWinTcpServer: Retrieving address info failed!" <<
-                std::endl;
-#endif
-        handleError(ErrorSources::GETADDRINFO_CALL);
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    /* Open TCP (stream) socket */
-    listenerTcpSocket = socket(addrResult->ai_family, addrResult->ai_socktype,
-            addrResult->ai_protocol);
-    if(listenerTcpSocket == INVALID_SOCKET) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TcWinTcpServer::TcWinTcpServer: Socket creation failed!" << std::endl;
-#endif
-        freeaddrinfo(addrResult);
-        handleError(ErrorSources::SOCKET_CALL);
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-//    retval = setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEADDR | SO_BROADCAST,
-//            reinterpret_cast<const char*>(&tcpSockOpt), sizeof(tcpSockOpt));
-//    if(retval != 0) {
-//        sif::warning << "TcWinTcpServer::TcWinTcpServer: Setting socket options failed!" <<
-//                std::endl;
-//        handleError(ErrorSources::SETSOCKOPT_CALL);
-//        return HasReturnvaluesIF::RETURN_FAILED;
-//    }
-//    tcpAddress.sin_family = AF_INET;
-//    tcpAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-
-    retval = bind(listenerTcpSocket, reinterpret_cast<const sockaddr*>(&tcpAddress),
-            tcpAddrLen);
-    if(retval == SOCKET_ERROR) {
-        sif::warning << "TcWinTcpServer::TcWinTcpServer: Binding socket failed!" <<
-                std::endl;
-        freeaddrinfo(addrResult);
-        handleError(ErrorSources::BIND_CALL);
-    }
-
-    freeaddrinfo(addrResult);
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-TcWinTcpServer::~TcWinTcpServer() {
-    closesocket(listenerTcpSocket);
-    WSACleanup();
-}
-
-ReturnValue_t TcWinTcpServer::performOperation(uint8_t opCode) {
-    /* If a connection is accepted, the corresponding socket will be assigned to the new socket */
-    SOCKET clientSocket;
-    sockaddr_in clientSockAddr;
-    int connectorSockAddrLen = 0;
-    int retval = 0;
-    /* Listen for connection requests permanently for lifetime of program */
-    while(true) {
-        retval = listen(listenerTcpSocket, currentBacklog);
-        if(retval == SOCKET_ERROR) {
-            handleError(ErrorSources::LISTEN_CALL);
-            continue;
-        }
-
-        clientSocket = accept(listenerTcpSocket, reinterpret_cast<sockaddr*>(&clientSockAddr),
-                &connectorSockAddrLen);
-
-        if(clientSocket == INVALID_SOCKET) {
-            handleError(ErrorSources::ACCEPT_CALL);
-            continue;
-        };
-
-        retval = recv(clientSocket, reinterpret_cast<char*>(receptionBuffer.data()),
-                receptionBuffer.size(), 0);
-        if(retval > 0) {
-#if FSFW_TCP_SERVER_WIRETAPPING_ENABLED == 1
-            sif::info << "TcWinTcpServer::performOperation: Received " << retval << " bytes."
-                    std::endl;
-#endif
-        }
-        else if(retval == 0) {
-
-        }
-        else {
-
-        }
-
-        /* Done, shut down connection */
-        retval = shutdown(clientSocket, SD_SEND);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TcWinTcpServer::handleError(ErrorSources errorSrc) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    int errCode = WSAGetLastError();
-    std::string errorSrcString;
-    if(errorSrc == ErrorSources::SETSOCKOPT_CALL) {
-        errorSrcString = "setsockopt call";
-    }
-    else if(errorSrc == ErrorSources::SOCKET_CALL) {
-        errorSrcString = "socket call";
-    }
-    else if(errorSrc == ErrorSources::LISTEN_CALL) {
-        errorSrcString = "listen call";
-    }
-    else if(errorSrc == ErrorSources::ACCEPT_CALL) {
-        errorSrcString = "accept call";
-    }
-    else if(errorSrc == ErrorSources::GETADDRINFO_CALL) {
-        errorSrcString = "getaddrinfo call";
-    }
-
-    switch(errCode) {
-    case(WSANOTINITIALISED): {
-        sif::warning << "TmTcWinUdpBridge::handleError: " << errorSrcString << " | "
-                "WSANOTINITIALISED: WSAStartup call necessary" << std::endl;
-        break;
-    }
-    case(WSAEINVAL): {
-        sif::warning << "TmTcWinUdpBridge::handleError: " << errorSrcString << " | "
-                "WSAEINVAL: Invalid parameters" << std::endl;
-        break;
-    }
-    default: {
-        /*
-        https://docs.microsoft.com/en-us/windows/win32/winsock/
-        windows-sockets-error-codes-2
-         */
-        sif::warning << "TmTcWinUdpBridge::handleSocketError: Error code: " << errCode << std::endl;
-        break;
-    }
-    }
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-}
diff --git a/osal/windows/TcWinTcpServer.h b/osal/windows/TcWinTcpServer.h
deleted file mode 100644
index f8aebc530..000000000
--- a/osal/windows/TcWinTcpServer.h
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_
-#define FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_
-
-#include "../../objectmanager/SystemObject.h"
-#include "../../tasks/ExecutableObjectIF.h"
-
-#include <string>
-#include <vector>
-
-//! Debugging preprocessor define.
-#define FSFW_TCP_SERVER_WIRETAPPING_ENABLED    0
-
-/**
- * @brief   Windows TCP server used to receive telecommands on a Windows Host
- * @details
- * Based on: https://docs.microsoft.com/en-us/windows/win32/winsock/complete-server-code
- */
-class TcWinTcpServer:
-        public SystemObject,
-        public ExecutableObjectIF {
-public:
-    /* The ports chosen here should not be used by any other process. */
-    static const std::string DEFAULT_TCP_SERVER_PORT;
-    static const std::string DEFAULT_TCP_CLIENT_PORT;
-
-    TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
-            std::string customTcpServerPort = "");
-    virtual~ TcWinTcpServer();
-
-    ReturnValue_t initialize() override;
-    ReturnValue_t performOperation(uint8_t opCode) override;
-
-private:
-
-    std::string tcpPort;
-    SOCKET listenerTcpSocket = 0;
-    struct sockaddr_in tcpAddress;
-    int tcpAddrLen = sizeof(tcpAddress);
-    int currentBacklog = 3;
-
-    std::vector<uint8_t> receptionBuffer;
-    int tcpSockOpt = 0;
-
-    enum class ErrorSources {
-        GETADDRINFO_CALL,
-        SOCKET_CALL,
-        SETSOCKOPT_CALL,
-        BIND_CALL,
-        LISTEN_CALL,
-        ACCEPT_CALL
-    };
-
-    void handleError(ErrorSources errorSrc);
-};
-
-#endif /* FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_ */

From 36e524abe3217e7f2a31986d3f59dfb98448ecfa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 14:46:22 +0100
Subject: [PATCH 1682/1774] more tests

---
 housekeeping/HousekeepingSnapshot.h           | 18 +++++++--
 .../datapoollocal/LocalPoolManagerTest.cpp    | 40 ++++++++++++++++++-
 2 files changed, 54 insertions(+), 4 deletions(-)

diff --git a/housekeeping/HousekeepingSnapshot.h b/housekeeping/HousekeepingSnapshot.h
index 50afd4af5..45b40d379 100644
--- a/housekeeping/HousekeepingSnapshot.h
+++ b/housekeeping/HousekeepingSnapshot.h
@@ -11,7 +11,8 @@
  * @brief   This helper class will be used to serialize and deserialize update housekeeping packets
  *          into the store.
  */
-class HousekeepingSnapshot: public SerializeIF {
+class HousekeepingSnapshot:
+        public SerializeIF {
 public:
 
     /**
@@ -36,6 +37,17 @@ public:
                 timeStamp(timeStamp), timeStampSize(timeStampSize),
                 updateData(dataSetPtr) {};
 
+    /**
+     * Update packet constructor for pool variables.
+     * @param timeStamp
+     * @param timeStampSize
+     * @param dataSetPtr
+     */
+    HousekeepingSnapshot(CCSDSTime::CDS_short* cdsShort, LocalPoolObjectBase* dataSetPtr):
+            timeStamp(reinterpret_cast<uint8_t*>(cdsShort)),
+            timeStampSize(sizeof(CCSDSTime::CDS_short)), updateData(dataSetPtr) {};
+
+
     /**
      * Update packet constructor for pool variables.
      * @param timeStamp
@@ -47,8 +59,8 @@ public:
                 timeStamp(timeStamp), timeStampSize(timeStampSize),
                 updateData(dataSetPtr) {};
 
-    virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-            size_t maxSize, Endianness streamEndianness) const {
+    virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+            Endianness streamEndianness) const {
         if(timeStamp != nullptr) {
             /* Endianness will always be MACHINE, so we can simply use memcpy
             here. */
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index a98db6103..4df735cd2 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -20,7 +20,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
     REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
     REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
             == retval::CATCH_OK);
-    //REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK);
+
     MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
     REQUIRE(mqMock != nullptr);
     CommandMessage messageSent;
@@ -154,7 +154,21 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         auto poolVar = dynamic_cast<lp_var_t<uint8_t>*>(
                 poolOwner->getPoolObjectHandle(lpool::uint8VarId));
         REQUIRE(poolVar != nullptr);
+
+        {
+            PoolReadGuard rg(poolVar);
+            CHECK(rg.getReadResult() == retval::CATCH_OK);
+            poolVar->value = 25;
+        }
+
         poolVar->setChanged(true);
+
+        /* Store current time, we are going to check the (approximate) time equality later */
+        CCSDSTime::CDS_short timeCdsNow;
+        timeval now;
+        Clock::getClock_timeval(&now);
+        CCSDSTime::convertToCcsds(&timeCdsNow, &now);
+
         REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 
         /* Check update snapshot was sent. */
@@ -166,6 +180,30 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
         CHECK(messageSent.getCommand() == static_cast<int>(
                 HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE));
+        /* Now we deserialize the snapshot into a new dataset instance */
+        CCSDSTime::CDS_short cdsShort;
+        lp_var_t<uint8_t> varCopy = lp_var_t<uint8_t>(lpool::uint8VarGpid);
+        HousekeepingSnapshot snapshot(&cdsShort, &varCopy);
+        store_address_t storeId;
+        HousekeepingMessage::getUpdateSnapshotVariableCommand(&messageSent, &storeId);
+        ConstAccessorPair accessorPair = tglob::getIpcStoreHandle()->getData(storeId);
+        REQUIRE(accessorPair.first == retval::CATCH_OK);
+        const uint8_t* readOnlyPtr = accessorPair.second.data();
+        size_t sizeToDeserialize = accessorPair.second.size();
+        CHECK(varCopy.value == 0);
+        /* Fill the dataset and timestamp */
+        REQUIRE(snapshot.deSerialize(&readOnlyPtr, &sizeToDeserialize,
+                SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+        CHECK(varCopy.value == 25);
+
+        /* Now we check that both times are equal */
+        CHECK(cdsShort.pField == timeCdsNow.pField);
+        CHECK(cdsShort.dayLSB == Catch::Approx(timeCdsNow.dayLSB).margin(1));
+        CHECK(cdsShort.dayMSB == Catch::Approx(timeCdsNow.dayMSB).margin(1));
+        CHECK(cdsShort.msDay_h == Catch::Approx(timeCdsNow.msDay_h).margin(1));
+        CHECK(cdsShort.msDay_hh == Catch::Approx(timeCdsNow.msDay_hh).margin(1));
+        CHECK(cdsShort.msDay_l == Catch::Approx(timeCdsNow.msDay_l).margin(1));
+        CHECK(cdsShort.msDay_ll == Catch::Approx(timeCdsNow.msDay_ll).margin(1));
     }
 
     SECTION("VariableUpdateTest") {

From 9eefd5b95da305f63205f026258426299c803e98 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 14:47:47 +0100
Subject: [PATCH 1683/1774] added back tcp stuff

---
 osal/windows/CMakeLists.txt     |   1 +
 osal/windows/TcWinTcpServer.cpp | 177 ++++++++++++++++++++++++++++++++
 osal/windows/TcWinTcpServer.h   |  56 ++++++++++
 3 files changed, 234 insertions(+)
 create mode 100644 osal/windows/TcWinTcpServer.cpp
 create mode 100644 osal/windows/TcWinTcpServer.h

diff --git a/osal/windows/CMakeLists.txt b/osal/windows/CMakeLists.txt
index a3a719e0a..889ea3396 100644
--- a/osal/windows/CMakeLists.txt
+++ b/osal/windows/CMakeLists.txt
@@ -1,6 +1,7 @@
 target_sources(${LIB_FSFW_NAME} PRIVATE 
     TcWinUdpPollingTask.cpp
     TmTcWinUdpBridge.cpp
+    TcWinTcpServer.cpp
 )
 
 target_link_libraries(${LIB_FSFW_NAME} PRIVATE
diff --git a/osal/windows/TcWinTcpServer.cpp b/osal/windows/TcWinTcpServer.cpp
new file mode 100644
index 000000000..f85147f04
--- /dev/null
+++ b/osal/windows/TcWinTcpServer.cpp
@@ -0,0 +1,177 @@
+#include "TcWinTcpServer.h"
+#include "../../serviceinterface/ServiceInterface.h"
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+
+const std::string TcWinTcpServer::DEFAULT_TCP_SERVER_PORT =  "7301";
+const std::string TcWinTcpServer::DEFAULT_TCP_CLIENT_PORT =  "7302";
+
+TcWinTcpServer::TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+        std::string customTcpServerPort):
+        SystemObject(objectId), tcpPort(customTcpServerPort) {
+    if(tcpPort == "") {
+        tcpPort = DEFAULT_TCP_SERVER_PORT;
+    }
+}
+
+ReturnValue_t TcWinTcpServer::initialize() {
+    int retval = 0;
+    struct addrinfo *addrResult = nullptr;
+    struct addrinfo hints;
+    /* Initiates Winsock DLL. */
+    WSAData wsaData;
+    WORD wVersionRequested = MAKEWORD(2, 2);
+    int err = WSAStartup(wVersionRequested, &wsaData);
+    if (err != 0) {
+        /* Tell the user that we could not find a usable Winsock DLL. */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: WSAStartup failed with error: " <<
+                err << std::endl;
+#endif
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    ZeroMemory(&hints, sizeof (hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_protocol = IPPROTO_TCP;
+    hints.ai_flags = AI_PASSIVE;
+
+    retval = getaddrinfo(nullptr, tcpPort.c_str(), &hints, &addrResult);
+    if (retval != 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "TcWinTcpServer::TcWinTcpServer: Retrieving address info failed!" <<
+                std::endl;
+#endif
+        handleError(ErrorSources::GETADDRINFO_CALL);
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    /* Open TCP (stream) socket */
+    listenerTcpSocket = socket(addrResult->ai_family, addrResult->ai_socktype,
+            addrResult->ai_protocol);
+    if(listenerTcpSocket == INVALID_SOCKET) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "TcWinTcpServer::TcWinTcpServer: Socket creation failed!" << std::endl;
+#endif
+        freeaddrinfo(addrResult);
+        handleError(ErrorSources::SOCKET_CALL);
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+//    retval = setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEADDR | SO_BROADCAST,
+//            reinterpret_cast<const char*>(&tcpSockOpt), sizeof(tcpSockOpt));
+//    if(retval != 0) {
+//        sif::warning << "TcWinTcpServer::TcWinTcpServer: Setting socket options failed!" <<
+//                std::endl;
+//        handleError(ErrorSources::SETSOCKOPT_CALL);
+//        return HasReturnvaluesIF::RETURN_FAILED;
+//    }
+//    tcpAddress.sin_family = AF_INET;
+//    tcpAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+
+    retval = bind(listenerTcpSocket, reinterpret_cast<const sockaddr*>(&tcpAddress),
+            tcpAddrLen);
+    if(retval == SOCKET_ERROR) {
+        sif::warning << "TcWinTcpServer::TcWinTcpServer: Binding socket failed!" <<
+                std::endl;
+        freeaddrinfo(addrResult);
+        handleError(ErrorSources::BIND_CALL);
+    }
+
+    freeaddrinfo(addrResult);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+TcWinTcpServer::~TcWinTcpServer() {
+    closesocket(listenerTcpSocket);
+    WSACleanup();
+}
+
+ReturnValue_t TcWinTcpServer::performOperation(uint8_t opCode) {
+    /* If a connection is accepted, the corresponding socket will be assigned to the new socket */
+    SOCKET clientSocket;
+    sockaddr_in clientSockAddr;
+    int connectorSockAddrLen = 0;
+    int retval = 0;
+    /* Listen for connection requests permanently for lifetime of program */
+    while(true) {
+        retval = listen(listenerTcpSocket, currentBacklog);
+        if(retval == SOCKET_ERROR) {
+            handleError(ErrorSources::LISTEN_CALL);
+            continue;
+        }
+
+        clientSocket = accept(listenerTcpSocket, reinterpret_cast<sockaddr*>(&clientSockAddr),
+                &connectorSockAddrLen);
+
+        if(clientSocket == INVALID_SOCKET) {
+            handleError(ErrorSources::ACCEPT_CALL);
+            continue;
+        };
+
+        retval = recv(clientSocket, reinterpret_cast<char*>(receptionBuffer.data()),
+                receptionBuffer.size(), 0);
+        if(retval > 0) {
+#if FSFW_TCP_SERVER_WIRETAPPING_ENABLED == 1
+            sif::info << "TcWinTcpServer::performOperation: Received " << retval << " bytes."
+                    std::endl;
+#endif
+        }
+        else if(retval == 0) {
+
+        }
+        else {
+
+        }
+
+        /* Done, shut down connection */
+        retval = shutdown(clientSocket, SD_SEND);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TcWinTcpServer::handleError(ErrorSources errorSrc) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    int errCode = WSAGetLastError();
+    std::string errorSrcString;
+    if(errorSrc == ErrorSources::SETSOCKOPT_CALL) {
+        errorSrcString = "setsockopt call";
+    }
+    else if(errorSrc == ErrorSources::SOCKET_CALL) {
+        errorSrcString = "socket call";
+    }
+    else if(errorSrc == ErrorSources::LISTEN_CALL) {
+        errorSrcString = "listen call";
+    }
+    else if(errorSrc == ErrorSources::ACCEPT_CALL) {
+        errorSrcString = "accept call";
+    }
+    else if(errorSrc == ErrorSources::GETADDRINFO_CALL) {
+        errorSrcString = "getaddrinfo call";
+    }
+
+    switch(errCode) {
+    case(WSANOTINITIALISED): {
+        sif::warning << "TmTcWinUdpBridge::handleError: " << errorSrcString << " | "
+                "WSANOTINITIALISED: WSAStartup call necessary" << std::endl;
+        break;
+    }
+    case(WSAEINVAL): {
+        sif::warning << "TmTcWinUdpBridge::handleError: " << errorSrcString << " | "
+                "WSAEINVAL: Invalid parameters" << std::endl;
+        break;
+    }
+    default: {
+        /*
+        https://docs.microsoft.com/en-us/windows/win32/winsock/
+        windows-sockets-error-codes-2
+         */
+        sif::warning << "TmTcWinUdpBridge::handleSocketError: Error code: " << errCode << std::endl;
+        break;
+    }
+    }
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+}
diff --git a/osal/windows/TcWinTcpServer.h b/osal/windows/TcWinTcpServer.h
new file mode 100644
index 000000000..f8aebc530
--- /dev/null
+++ b/osal/windows/TcWinTcpServer.h
@@ -0,0 +1,56 @@
+#ifndef FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_
+#define FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_
+
+#include "../../objectmanager/SystemObject.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+#include <string>
+#include <vector>
+
+//! Debugging preprocessor define.
+#define FSFW_TCP_SERVER_WIRETAPPING_ENABLED    0
+
+/**
+ * @brief   Windows TCP server used to receive telecommands on a Windows Host
+ * @details
+ * Based on: https://docs.microsoft.com/en-us/windows/win32/winsock/complete-server-code
+ */
+class TcWinTcpServer:
+        public SystemObject,
+        public ExecutableObjectIF {
+public:
+    /* The ports chosen here should not be used by any other process. */
+    static const std::string DEFAULT_TCP_SERVER_PORT;
+    static const std::string DEFAULT_TCP_CLIENT_PORT;
+
+    TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+            std::string customTcpServerPort = "");
+    virtual~ TcWinTcpServer();
+
+    ReturnValue_t initialize() override;
+    ReturnValue_t performOperation(uint8_t opCode) override;
+
+private:
+
+    std::string tcpPort;
+    SOCKET listenerTcpSocket = 0;
+    struct sockaddr_in tcpAddress;
+    int tcpAddrLen = sizeof(tcpAddress);
+    int currentBacklog = 3;
+
+    std::vector<uint8_t> receptionBuffer;
+    int tcpSockOpt = 0;
+
+    enum class ErrorSources {
+        GETADDRINFO_CALL,
+        SOCKET_CALL,
+        SETSOCKOPT_CALL,
+        BIND_CALL,
+        LISTEN_CALL,
+        ACCEPT_CALL
+    };
+
+    void handleError(ErrorSources errorSrc);
+};
+
+#endif /* FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_ */

From 286a3649cf254508f478a280220c52f49e5c2ec5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 14:51:29 +0100
Subject: [PATCH 1684/1774] renamed tests

---
 unittest/tests/datapoollocal/LocalPoolManagerTest.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 4df735cd2..52485b011 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -206,7 +206,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
         CHECK(cdsShort.msDay_ll == Catch::Approx(timeCdsNow.msDay_ll).margin(1));
     }
 
-    SECTION("VariableUpdateTest") {
+    SECTION("VariableNotificationTest") {
         /* Acquire subscription interface */
         ProvidesDataPoolSubscriptionIF* subscriptionIF = poolOwner->getSubscriptionInterface();
         REQUIRE(subscriptionIF != nullptr);

From 67b05fee2e6171d2cab37919f2cabd6817af305d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Mar 2021 15:04:20 +0100
Subject: [PATCH 1685/1774] newline removed

---
 unittest/tests/datapoollocal/DataSetTest.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index ce4d9d437..d0b13e86f 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -275,7 +275,6 @@ TEST_CASE("DataSetTest" , "[DataSetTest]") {
         }
 
         sharedSet.setReadCommitProtectionBehaviour(true);
-
     }
 
     /* we need to reset the subscription list because the pool owner

From 6e5b032dbbc078c542d83325b214ec375cb04cd0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 00:34:30 +0100
Subject: [PATCH 1686/1774] trying new udp stuff

---
 osal/host/MutexFactory.cpp           |   4 +-
 osal/windows/TcWinTcpServer.cpp      |   3 +-
 osal/windows/TcWinUdpPollingTask.cpp |   2 +-
 osal/windows/TmTcWinUdpBridge.cpp    | 117 +++++++++++++++++----------
 osal/windows/TmTcWinUdpBridge.h      |  10 ++-
 5 files changed, 85 insertions(+), 51 deletions(-)

diff --git a/osal/host/MutexFactory.cpp b/osal/host/MutexFactory.cpp
index bf7707d11..f3b98fd1d 100644
--- a/osal/host/MutexFactory.cpp
+++ b/osal/host/MutexFactory.cpp
@@ -24,5 +24,7 @@ MutexIF* MutexFactory::createMutex() {
 }
 
 void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
+    if(mutex != nullptr) {
+        delete mutex;
+    }
 }
diff --git a/osal/windows/TcWinTcpServer.cpp b/osal/windows/TcWinTcpServer.cpp
index f85147f04..3cdd1d3fd 100644
--- a/osal/windows/TcWinTcpServer.cpp
+++ b/osal/windows/TcWinTcpServer.cpp
@@ -71,8 +71,7 @@ ReturnValue_t TcWinTcpServer::initialize() {
 //    tcpAddress.sin_family = AF_INET;
 //    tcpAddress.sin_addr.s_addr = htonl(INADDR_ANY);
 
-    retval = bind(listenerTcpSocket, reinterpret_cast<const sockaddr*>(&tcpAddress),
-            tcpAddrLen);
+    retval = bind(listenerTcpSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
     if(retval == SOCKET_ERROR) {
         sif::warning << "TcWinTcpServer::TcWinTcpServer: Binding socket failed!" <<
                 std::endl;
diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 06e75bd5b..c86fd03a9 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -33,7 +33,7 @@ TcWinUdpPollingTask::~TcWinUdpPollingTask() {}
 ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 	/* Poll for new UDP datagrams in permanent loop. */
 	while(true) {
-		//! Sender Address is cached here.
+		/* Sender Address is cached here. */
 		struct sockaddr_in senderAddress;
 		int senderAddressSize = sizeof(senderAddress);
 		int bytesReceived = recvfrom(serverUdpSocket,
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 03daa6d7b..eb5db0b3f 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -1,19 +1,34 @@
 #include "TmTcWinUdpBridge.h"
 
+#include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/ipc/MutexGuard.h>
+#include <ws2tcpip.h>
 
-#if defined(_MSC_VER)
-#include <BaseTsd.h>
-typedef SSIZE_T ssize_t;
-#endif
+const std::string TmTcWinUdpBridge::DEFAULT_UDP_SERVER_PORT =  "7301";
+const std::string TmTcWinUdpBridge::DEFAULT_UDP_CLIENT_PORT =  "7302";
 
 TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
         object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
-        uint16_t serverPort, uint16_t clientPort):
+        std::string udpServerPort, std::string udpClientPort):
         TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
+    if(udpServerPort == "") {
+        udpServerPort = DEFAULT_UDP_SERVER_PORT;
+    }
+    else {
+        this->udpServerPort = udpServerPort;
+    }
+    if(udpClientPort == "") {
+        udpClientPort = DEFAULT_UDP_CLIENT_PORT;
+    }
+    else {
+        this->udpClientPort = udpClientPort;
+    }
+
     mutex = MutexFactory::instance()->createMutex();
     communicationLinkUp = false;
+}
 
+ReturnValue_t TmTcWinUdpBridge::initialize() {
     /* Initiates Winsock DLL. */
     WSAData wsaData;
     WORD wVersionRequested = MAKEWORD(2, 2);
@@ -22,71 +37,85 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
         /* Tell the user that we could not find a usable */
         /* Winsock DLL.                                  */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge:"
-                "WSAStartup failed with error: " << err << std::endl;
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: WSAStartup failed with error: " <<
+                err << std::endl;
+#else
+        sif::printError("TmTcWinUdpBridge::TmTcWinUdpBridge: WSAStartup failed with error: %d\n",
+                err);
 #endif
-        return;
+        return HasReturnvaluesIF::RETURN_FAILED;
     }
 
-    uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
-    if(serverPort != 0xFFFF) {
-        setServerPort = serverPort;
-    }
+    struct addrinfo *addrResult = nullptr;
+    struct addrinfo hints;
 
-    uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
-    if(clientPort != 0xFFFF) {
-        setClientPort = clientPort;
-    }
+    ZeroMemory(&hints, sizeof (hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_DGRAM;
+    hints.ai_protocol = IPPROTO_UDP;
+    hints.ai_flags = AI_PASSIVE;
 
     /* Set up UDP socket:
-    https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-socket
+    https://en.wikipedia.org/wiki/Getaddrinfo
+    Passing nullptr as the first parameter and specifying AI_PASSIVE in hints will cause
+    getaddrinfo to assign the address 0.0.0.0 (any address)
     */
-    serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    int retval = getaddrinfo(nullptr, udpServerPort.c_str(), &hints, &addrResult);
+    if (retval != 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Retrieving address info failed!" <<
+                std::endl;
+#endif
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    serverSocket = socket(addrResult->ai_family, addrResult->ai_socktype, addrResult->ai_protocol);
     if(serverSocket == INVALID_SOCKET) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open UDP socket!" <<
                 std::endl;
 #endif
         handleSocketError();
-        return;
-    }
-
-    serverAddress.sin_family = AF_INET;
-
-    /* Accept packets from any interface. (potentially insecure). */
-    serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-    serverAddress.sin_port = htons(setServerPort);
-    serverAddressLen = sizeof(serverAddress);
-    int result = setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR,
-            reinterpret_cast<const char*>(&serverSocketOptions),
-            sizeof(serverSocketOptions));
-    if(result != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not set socket options!" <<
-                std::endl;
-#endif
-        handleSocketError();
+        return HasReturnvaluesIF::RETURN_FAILED;
     }
 
+//    serverAddress.sin_family = AF_INET;
+//
+//    /* Accept packets from any interface. (potentially insecure). */
+//    serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+//    serverAddress.sin_port = htons(setServerPort);
+//    serverAddressLen = sizeof(serverAddress);
+//    int result = setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR,
+//            reinterpret_cast<const char*>(&serverSocketOptions),
+//            sizeof(serverSocketOptions));
+//    if(result != 0) {
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not set socket options!" <<
+//                std::endl;
+//#endif
+//        handleSocketError();
+//    }
+//
     clientAddress.sin_family = AF_INET;
     clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-    clientAddress.sin_port = htons(setClientPort);
+    clientAddress.sin_port = htons(7302);
     clientAddressLen = sizeof(clientAddress);
 
-    result = bind(serverSocket,
-            reinterpret_cast<struct sockaddr*>(&serverAddress),
-            serverAddressLen);
-    if(result != 0) {
+    retval = bind(serverSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
+    if(retval != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
-                "local port " << setServerPort << " to server socket!"
-                << std::endl;
+                "local port " << udpServerPort << " to server socket!" << std::endl;
 #endif
         handleBindError();
     }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 TmTcWinUdpBridge::~TmTcWinUdpBridge() {
+    if(mutex != nullptr) {
+        MutexFactory::instance()->deleteMutex(mutex);
+    }
     closesocket(serverSocket);
     WSACleanup();
 }
@@ -102,7 +131,7 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
             &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 #endif
 
-    ssize_t bytesSent = sendto(serverSocket,
+    int bytesSent = sendto(serverSocket,
             reinterpret_cast<const char*>(data), dataLen, flags,
             reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
     if(bytesSent == SOCKET_ERROR) {
diff --git a/osal/windows/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
index 143541398..e32854b67 100644
--- a/osal/windows/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -13,14 +13,16 @@ class TmTcWinUdpBridge: public TmTcBridge {
     friend class TcWinUdpPollingTask;
 public:
     /* The ports chosen here should not be used by any other process. */
-    static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
-    static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
+    static const std::string DEFAULT_UDP_SERVER_PORT;
+    static const std::string DEFAULT_UDP_CLIENT_PORT;
 
     TmTcWinUdpBridge(object_id_t objectId, object_id_t tcDestination,
             object_id_t tmStoreId, object_id_t tcStoreId,
-            uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
+            std::string udpServerPort = "", std::string udpClientPort = "");
     virtual~ TmTcWinUdpBridge();
 
+    ReturnValue_t initialize() override;
+
     void checkAndSetClientAddress(sockaddr_in clientAddress);
 
 protected:
@@ -28,6 +30,8 @@ protected:
 
 private:
     SOCKET serverSocket = 0;
+    std::string udpServerPort;
+    std::string udpClientPort;
 
     const int serverSocketOptions = 0;
 

From df7434dae579cc5111c8692913860aa9a8227a2d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 00:45:32 +0100
Subject: [PATCH 1687/1774] somethings wrong

---
 osal/windows/TcWinUdpPollingTask.cpp | 4 ++--
 osal/windows/TmTcWinUdpBridge.cpp    | 5 +++++
 tmtcservices/TmTcBridge.cpp          | 3 +++
 3 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index c86fd03a9..38633388f 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -122,8 +122,8 @@ ReturnValue_t TcWinUdpPollingTask::initialize() {
 }
 
 ReturnValue_t TcWinUdpPollingTask::initializeAfterTaskCreation() {
-	// Initialize the destination after task creation. This ensures
-	// that the destination has already been set in the TMTC bridge.
+	/* Initialize the destination after task creation. This ensures
+	that the destination has already been set in the TMTC bridge. */
 	targetTcDestination = tmtcBridge->getRequestQueue();
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index eb5db0b3f..1a624355a 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -29,6 +29,11 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
 }
 
 ReturnValue_t TmTcWinUdpBridge::initialize() {
+    ReturnValue_t result = TmTcBridge::initialize();
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
     /* Initiates Winsock DLL. */
     WSAData wsaData;
     WORD wVersionRequested = MAKEWORD(2, 2);
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 12d163d16..228bf4f5d 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -173,6 +173,9 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	store_address_t storeId = 0;
+	if(tmFifo == nullptr) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	}
 
 	if(tmFifo->full()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1

From b071c850af1ec81e6a61997a1bcc42bc6e03aff5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 01:40:58 +0100
Subject: [PATCH 1688/1774] commit with old way

---
 osal/windows/TcWinUdpPollingTask.cpp |   9 +--
 osal/windows/TmTcWinUdpBridge.cpp    | 110 +++++++++++++++++++--------
 osal/windows/TmTcWinUdpBridge.h      |   4 +-
 3 files changed, 87 insertions(+), 36 deletions(-)

diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 38633388f..502b798fa 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -49,7 +49,7 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 			handleReadError();
 			continue;
 		}
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_WIRETAPPING_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
 		sif::debug << "TcWinUdpPollingTask::performOperation: " << bytesReceived <<
 		        " bytes received" << std::endl;
 #endif
@@ -58,7 +58,6 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 		if(result != HasReturnvaluesIF::RETURN_FAILED) {
 
 		}
-		tmtcBridge->registerCommConnect();
 		tmtcBridge->checkAndSetClientAddress(senderAddress);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
@@ -69,8 +68,8 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 	store_address_t storeId;
 	ReturnValue_t result = tcStore->addData(&storeId,
 			receptionBuffer.data(), bytesRead);
-#if FSFW_UDP_WIRETAPPING_ENABLED == 1
-	arrayprinter::print(receptionBuffer.data(), bytesRead);#
+#if FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
+	arrayprinter::print(receptionBuffer.data(), bytesRead);
 #endif
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -113,7 +112,7 @@ ReturnValue_t TcWinUdpPollingTask::initialize() {
 	}
 
 	serverUdpSocket = tmtcBridge->serverSocket;
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_WIRETAPPING_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
 	sif::info << "TcWinUdpPollingTask::initialize: Server UDP socket " << serverUdpSocket <<
 	        std::endl;
 #endif
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 1a624355a..346abcd44 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -12,13 +12,13 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
         std::string udpServerPort, std::string udpClientPort):
         TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
     if(udpServerPort == "") {
-        udpServerPort = DEFAULT_UDP_SERVER_PORT;
+         this->udpServerPort = DEFAULT_UDP_SERVER_PORT;
     }
     else {
         this->udpServerPort = udpServerPort;
     }
     if(udpClientPort == "") {
-        udpClientPort = DEFAULT_UDP_CLIENT_PORT;
+        this->udpClientPort = DEFAULT_UDP_CLIENT_PORT;
     }
     else {
         this->udpClientPort = udpClientPort;
@@ -60,11 +60,12 @@ ReturnValue_t TmTcWinUdpBridge::initialize() {
     hints.ai_protocol = IPPROTO_UDP;
     hints.ai_flags = AI_PASSIVE;
 
+    sif::info << udpServerPort << std::endl;
     /* Set up UDP socket:
-    https://en.wikipedia.org/wiki/Getaddrinfo
-    Passing nullptr as the first parameter and specifying AI_PASSIVE in hints will cause
-    getaddrinfo to assign the address 0.0.0.0 (any address)
-    */
+       https://en.wikipedia.org/wiki/Getaddrinfo
+       Passing nullptr as the first parameter and specifying AI_PASSIVE in hints will cause
+       getaddrinfo to assign the address 0.0.0.0 (any address)
+     */
     int retval = getaddrinfo(nullptr, udpServerPort.c_str(), &hints, &addrResult);
     if (retval != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -80,40 +81,22 @@ ReturnValue_t TmTcWinUdpBridge::initialize() {
         sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open UDP socket!" <<
                 std::endl;
 #endif
+        freeaddrinfo(addrResult);
         handleSocketError();
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
-//    serverAddress.sin_family = AF_INET;
-//
-//    /* Accept packets from any interface. (potentially insecure). */
-//    serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-//    serverAddress.sin_port = htons(setServerPort);
-//    serverAddressLen = sizeof(serverAddress);
-//    int result = setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR,
-//            reinterpret_cast<const char*>(&serverSocketOptions),
-//            sizeof(serverSocketOptions));
-//    if(result != 0) {
-//#if FSFW_CPP_OSTREAM_ENABLED == 1
-//        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not set socket options!" <<
-//                std::endl;
-//#endif
-//        handleSocketError();
-//    }
-//
-    clientAddress.sin_family = AF_INET;
-    clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-    clientAddress.sin_port = htons(7302);
-    clientAddressLen = sizeof(clientAddress);
-
     retval = bind(serverSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
     if(retval != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
                 "local port " << udpServerPort << " to server socket!" << std::endl;
 #endif
+        freeaddrinfo(addrResult);
         handleBindError();
     }
+    freeaddrinfo(addrResult);
+
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -126,6 +109,7 @@ TmTcWinUdpBridge::~TmTcWinUdpBridge() {
 }
 
 ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+    MutexGuard lock(mutex, MutexIF::TimeoutType::WAITING, 10);
     int flags = 0;
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
@@ -153,7 +137,7 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
     MutexGuard lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
@@ -167,7 +151,7 @@ void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
 
     /* 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;
+        clientAddress = newAddress;
         clientAddressLen = sizeof(clientAddress);
     }
 }
@@ -257,3 +241,69 @@ void TmTcWinUdpBridge::handleSendError() {
     }
 }
 
+ReturnValue_t TmTcWinUdpBridge::oldSetup() {
+    ReturnValue_t result = TmTcBridge::initialize();
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    // Initiates Winsock DLL.
+    WSAData wsaData;
+    WORD wVersionRequested = MAKEWORD(2, 2);
+    int err = WSAStartup(wVersionRequested, &wsaData);
+    if (err != 0) {
+        /* Tell the user that we could not find a usable */
+        /* Winsock DLL.                                  */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge:"
+                "WSAStartup failed with error: " << err << std::endl;
+#endif
+    }
+
+    uint16_t setServerPort = 7301;
+    uint16_t setClientPort = 7302;
+
+    // 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 == INVALID_SOCKET) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open"
+                " UDP socket!" << std::endl;
+#endif
+        handleSocketError();
+    }
+
+    serverAddress.sin_family = AF_INET;
+
+    // Accept packets from any interface. (potentially insecure).
+    serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+    serverAddress.sin_port = htons(setServerPort);
+    serverAddressLen = sizeof(serverAddress);
+
+//    sif::info << serverAddress.sin_addr.s_addr << std::endl;
+//    sif::info << serverAddress.sin_port << std::endl;
+
+    setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR,
+            reinterpret_cast<const char*>(&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 retval = bind(serverSocket,
+            reinterpret_cast<struct sockaddr*>(&serverAddress),
+            serverAddressLen);
+    if(retval != 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
+                "local port " << setServerPort << " to server socket!"
+                << std::endl;
+#endif
+        handleBindError();
+    }
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
diff --git a/osal/windows/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
index e32854b67..b433f6f1e 100644
--- a/osal/windows/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -23,7 +23,7 @@ public:
 
     ReturnValue_t initialize() override;
 
-    void checkAndSetClientAddress(sockaddr_in clientAddress);
+    void checkAndSetClientAddress(sockaddr_in& clientAddress);
 
 protected:
     virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
@@ -53,6 +53,8 @@ private:
     void handleSocketError();
     void handleBindError();
     void handleSendError();
+
+    ReturnValue_t oldSetup();
 };
 
 

From e92d3901f7c9283d7c57dbd156e0449d9047579e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 02:15:21 +0100
Subject: [PATCH 1689/1774] improved error handling

---
 osal/windows/CMakeLists.txt          |   1 +
 osal/windows/TcWinTcpServer.cpp      |  69 ++---------
 osal/windows/TcWinTcpServer.h        |  11 +-
 osal/windows/TcWinUdpPollingTask.cpp | 100 ++++++----------
 osal/windows/TcWinUdpPollingTask.h   |   7 +-
 osal/windows/TmTcWinUdpBridge.cpp    | 171 ++-------------------------
 osal/windows/TmTcWinUdpBridge.h      |  16 +--
 osal/windows/tcpipHelpers.cpp        |  92 ++++++++++++++
 osal/windows/tcpipHelpers.h          |  31 +++++
 9 files changed, 187 insertions(+), 311 deletions(-)
 create mode 100644 osal/windows/tcpipHelpers.cpp
 create mode 100644 osal/windows/tcpipHelpers.h

diff --git a/osal/windows/CMakeLists.txt b/osal/windows/CMakeLists.txt
index 889ea3396..a2b316880 100644
--- a/osal/windows/CMakeLists.txt
+++ b/osal/windows/CMakeLists.txt
@@ -2,6 +2,7 @@ target_sources(${LIB_FSFW_NAME} PRIVATE
     TcWinUdpPollingTask.cpp
     TmTcWinUdpBridge.cpp
     TcWinTcpServer.cpp
+    tcpipHelpers.cpp
 )
 
 target_link_libraries(${LIB_FSFW_NAME} PRIVATE
diff --git a/osal/windows/TcWinTcpServer.cpp b/osal/windows/TcWinTcpServer.cpp
index 3cdd1d3fd..49c278c5c 100644
--- a/osal/windows/TcWinTcpServer.cpp
+++ b/osal/windows/TcWinTcpServer.cpp
@@ -1,4 +1,5 @@
 #include "TcWinTcpServer.h"
+#include "tcpipHelpers.h"
 #include "../../serviceinterface/ServiceInterface.h"
 
 #include <winsock2.h>
@@ -16,6 +17,7 @@ TcWinTcpServer::TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBrid
 }
 
 ReturnValue_t TcWinTcpServer::initialize() {
+    using namespace tcpip;
     int retval = 0;
     struct addrinfo *addrResult = nullptr;
     struct addrinfo hints;
@@ -44,7 +46,7 @@ ReturnValue_t TcWinTcpServer::initialize() {
         sif::warning << "TcWinTcpServer::TcWinTcpServer: Retrieving address info failed!" <<
                 std::endl;
 #endif
-        handleError(ErrorSources::GETADDRINFO_CALL);
+        handleError(Protocol::TCP, ErrorSources::GETADDRINFO_CALL);
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
@@ -56,27 +58,16 @@ ReturnValue_t TcWinTcpServer::initialize() {
         sif::warning << "TcWinTcpServer::TcWinTcpServer: Socket creation failed!" << std::endl;
 #endif
         freeaddrinfo(addrResult);
-        handleError(ErrorSources::SOCKET_CALL);
+        handleError(Protocol::TCP, ErrorSources::SOCKET_CALL);
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
-//    retval = setsockopt(listenerTcpSocket, SOL_SOCKET, SO_REUSEADDR | SO_BROADCAST,
-//            reinterpret_cast<const char*>(&tcpSockOpt), sizeof(tcpSockOpt));
-//    if(retval != 0) {
-//        sif::warning << "TcWinTcpServer::TcWinTcpServer: Setting socket options failed!" <<
-//                std::endl;
-//        handleError(ErrorSources::SETSOCKOPT_CALL);
-//        return HasReturnvaluesIF::RETURN_FAILED;
-//    }
-//    tcpAddress.sin_family = AF_INET;
-//    tcpAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-
     retval = bind(listenerTcpSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
     if(retval == SOCKET_ERROR) {
         sif::warning << "TcWinTcpServer::TcWinTcpServer: Binding socket failed!" <<
                 std::endl;
         freeaddrinfo(addrResult);
-        handleError(ErrorSources::BIND_CALL);
+        handleError(Protocol::TCP, ErrorSources::BIND_CALL);
     }
 
     freeaddrinfo(addrResult);
@@ -90,16 +81,18 @@ TcWinTcpServer::~TcWinTcpServer() {
 }
 
 ReturnValue_t TcWinTcpServer::performOperation(uint8_t opCode) {
+    using namespace tcpip;
     /* If a connection is accepted, the corresponding socket will be assigned to the new socket */
     SOCKET clientSocket;
     sockaddr_in clientSockAddr;
     int connectorSockAddrLen = 0;
     int retval = 0;
+
     /* Listen for connection requests permanently for lifetime of program */
     while(true) {
         retval = listen(listenerTcpSocket, currentBacklog);
         if(retval == SOCKET_ERROR) {
-            handleError(ErrorSources::LISTEN_CALL);
+            handleError(Protocol::TCP, ErrorSources::LISTEN_CALL, 500);
             continue;
         }
 
@@ -107,17 +100,18 @@ ReturnValue_t TcWinTcpServer::performOperation(uint8_t opCode) {
                 &connectorSockAddrLen);
 
         if(clientSocket == INVALID_SOCKET) {
-            handleError(ErrorSources::ACCEPT_CALL);
+            handleError(Protocol::TCP, ErrorSources::ACCEPT_CALL, 500);
             continue;
         };
 
         retval = recv(clientSocket, reinterpret_cast<char*>(receptionBuffer.data()),
                 receptionBuffer.size(), 0);
         if(retval > 0) {
-#if FSFW_TCP_SERVER_WIRETAPPING_ENABLED == 1
+#if FSFW_TCP_RCV_WIRETAPPING_ENABLED == 1
             sif::info << "TcWinTcpServer::performOperation: Received " << retval << " bytes."
                     std::endl;
 #endif
+            handleError(Protocol::TCP, ErrorSources::RECV_CALL, 500);
         }
         else if(retval == 0) {
 
@@ -132,45 +126,4 @@ ReturnValue_t TcWinTcpServer::performOperation(uint8_t opCode) {
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void TcWinTcpServer::handleError(ErrorSources errorSrc) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    int errCode = WSAGetLastError();
-    std::string errorSrcString;
-    if(errorSrc == ErrorSources::SETSOCKOPT_CALL) {
-        errorSrcString = "setsockopt call";
-    }
-    else if(errorSrc == ErrorSources::SOCKET_CALL) {
-        errorSrcString = "socket call";
-    }
-    else if(errorSrc == ErrorSources::LISTEN_CALL) {
-        errorSrcString = "listen call";
-    }
-    else if(errorSrc == ErrorSources::ACCEPT_CALL) {
-        errorSrcString = "accept call";
-    }
-    else if(errorSrc == ErrorSources::GETADDRINFO_CALL) {
-        errorSrcString = "getaddrinfo call";
-    }
 
-    switch(errCode) {
-    case(WSANOTINITIALISED): {
-        sif::warning << "TmTcWinUdpBridge::handleError: " << errorSrcString << " | "
-                "WSANOTINITIALISED: WSAStartup call necessary" << std::endl;
-        break;
-    }
-    case(WSAEINVAL): {
-        sif::warning << "TmTcWinUdpBridge::handleError: " << errorSrcString << " | "
-                "WSAEINVAL: Invalid parameters" << std::endl;
-        break;
-    }
-    default: {
-        /*
-        https://docs.microsoft.com/en-us/windows/win32/winsock/
-        windows-sockets-error-codes-2
-         */
-        sif::warning << "TmTcWinUdpBridge::handleSocketError: Error code: " << errCode << std::endl;
-        break;
-    }
-    }
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-}
diff --git a/osal/windows/TcWinTcpServer.h b/osal/windows/TcWinTcpServer.h
index f8aebc530..bd9f35765 100644
--- a/osal/windows/TcWinTcpServer.h
+++ b/osal/windows/TcWinTcpServer.h
@@ -8,7 +8,7 @@
 #include <vector>
 
 //! Debugging preprocessor define.
-#define FSFW_TCP_SERVER_WIRETAPPING_ENABLED    0
+#define FSFW_TCP_RCV_WIRETAPPING_ENABLED    0
 
 /**
  * @brief   Windows TCP server used to receive telecommands on a Windows Host
@@ -41,16 +41,7 @@ private:
     std::vector<uint8_t> receptionBuffer;
     int tcpSockOpt = 0;
 
-    enum class ErrorSources {
-        GETADDRINFO_CALL,
-        SOCKET_CALL,
-        SETSOCKOPT_CALL,
-        BIND_CALL,
-        LISTEN_CALL,
-        ACCEPT_CALL
-    };
 
-    void handleError(ErrorSources errorSrc);
 };
 
 #endif /* FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_ */
diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 502b798fa..324547faf 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -1,4 +1,5 @@
 #include "TcWinUdpPollingTask.h"
+#include "tcpipHelpers.h"
 #include "../../globalfunctions/arrayprinter.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
@@ -31,22 +32,26 @@ TcWinUdpPollingTask::TcWinUdpPollingTask(object_id_t objectId,
 TcWinUdpPollingTask::~TcWinUdpPollingTask() {}
 
 ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
+    /* Sender Address is cached here. */
+    struct sockaddr_in senderAddress;
+    int senderAddressSize = sizeof(senderAddress);
+
 	/* Poll for new UDP datagrams in permanent loop. */
 	while(true) {
-		/* Sender Address is cached here. */
-		struct sockaddr_in senderAddress;
-		int senderAddressSize = sizeof(senderAddress);
-		int bytesReceived = recvfrom(serverUdpSocket,
-				reinterpret_cast<char*>(receptionBuffer.data()), frameSize,
-				receptionFlags, reinterpret_cast<sockaddr*>(&senderAddress),
-				&senderAddressSize);
+		int bytesReceived = recvfrom(
+		        serverUdpSocket,
+		        reinterpret_cast<char*>(receptionBuffer.data()),
+		        frameSize,
+				receptionFlags,
+				reinterpret_cast<sockaddr*>(&senderAddress),
+				&senderAddressSize
+		);
 		if(bytesReceived == SOCKET_ERROR) {
 			/* Handle error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "TcWinUdpPollingTask::performOperation: Reception"
-					" error." << std::endl;
+			sif::error << "TcWinUdpPollingTask::performOperation: Reception error." << std::endl;
 #endif
-			handleReadError();
+			tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::RECVFROM_CALL, 1000);
 			continue;
 		}
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
@@ -66,17 +71,20 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 
 ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 	store_address_t storeId;
-	ReturnValue_t result = tcStore->addData(&storeId,
-			receptionBuffer.data(), bytesRead);
+
 #if FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
-	arrayprinter::print(receptionBuffer.data(), bytesRead);
+    arrayprinter::print(receptionBuffer.data(), bytesRead);
 #endif
+
+	ReturnValue_t result = tcStore->addData(&storeId, receptionBuffer.data(), bytesRead);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning<< "TcSerialPollingTask::transferPusToSoftwareBus: Data "
-		        "storage failed" << std::endl;
+		sif::warning<< "TcWinUdpPollingTask::transferPusToSoftwareBus: Data storage failed." <<
+		        std::endl;
 		sif::warning << "Packet size: " << bytesRead << std::endl;
-#endif
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -84,9 +92,12 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 
 	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "Serial Polling: Sending message to queue failed" << std::endl;
-#endif
+		sif::warning << "TcWinUdpPollingTask::handleSuccessfullTcRead: "
+		        " Sending message to queue failed" << std::endl;
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 		tcStore->deleteData(storeId);
 	}
 	return result;
@@ -96,8 +107,7 @@ ReturnValue_t TcWinUdpPollingTask::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
-				<< std::endl;
+		sif::error << "TcWinUdpPollingTask::initialize: TC store uninitialized!" << std::endl;
 #endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
@@ -105,18 +115,11 @@ ReturnValue_t TcWinUdpPollingTask::initialize() {
 	tmtcBridge = objectManager->get<TmTcWinUdpBridge>(tmtcBridgeId);
 	if(tmtcBridge == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
-				" TMTC bridge object!" << std::endl;
+		sif::error << "TcWinUdpPollingTask::initialize: Invalid TMTC bridge object!" <<
+		        std::endl;
 #endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
-
-	serverUdpSocket = tmtcBridge->serverSocket;
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
-	sif::info << "TcWinUdpPollingTask::initialize: Server UDP socket " << serverUdpSocket <<
-	        std::endl;
-#endif
-
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -124,6 +127,9 @@ ReturnValue_t TcWinUdpPollingTask::initializeAfterTaskCreation() {
 	/* Initialize the destination after task creation. This ensures
 	that the destination has already been set in the TMTC bridge. */
 	targetTcDestination = tmtcBridge->getRequestQueue();
+	/* The server socket is set up in the bridge intialization. Calling this function here
+	ensures that it is set up properly in any case*/
+    serverUdpSocket = tmtcBridge->serverSocket;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -138,39 +144,3 @@ void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
 #endif
 	}
 }
-
-void TcWinUdpPollingTask::handleReadError() {
-    int error = WSAGetLastError();
-    switch(error) {
-    case(WSANOTINITIALISED): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TcWinUdpPollingTask::handleReadError: WSANOTINITIALISED: "
-                << "WSAStartup(...) call " << "necessary" << std::endl;
-#endif
-        break;
-    }
-    case(WSAEFAULT): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TcWinUdpPollingTask::handleReadError: WSADEFAULT: "
-                << "Bad address " << std::endl;
-#endif
-        break;
-    }
-    case(WSAEINVAL): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TcWinUdpPollingTask::handleReadError: WSAEINVAL: "
-                << "Invalid input parameters. " << std::endl;
-#endif
-        break;
-    }
-    default: {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TcWinUdpPollingTask::handleReadError: Error code: "
-                << error << std::endl;
-#endif
-        break;
-    }
-    }
-    // to prevent spam.
-    Sleep(1000);
-}
diff --git a/osal/windows/TcWinUdpPollingTask.h b/osal/windows/TcWinUdpPollingTask.h
index 8a9cf51f6..707ad2824 100644
--- a/osal/windows/TcWinUdpPollingTask.h
+++ b/osal/windows/TcWinUdpPollingTask.h
@@ -51,10 +51,12 @@ private:
 	object_id_t tmtcBridgeId = objects::NO_OBJECT;
 	TmTcWinUdpBridge* tmtcBridge = nullptr;
 	MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;
-	//! Reception flags: https://linux.die.net/man/2/recvfrom.
+
+	//! See: https://docs.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom
 	int receptionFlags = 0;
 
-	//! Server socket, which is member of TMTC bridge and is assigned in constructor
+	//! Server socket, which is member of TMTC bridge.
+	//! Will be cached shortly after SW intialization.
 	SOCKET serverUdpSocket = 0;
 
 	std::vector<uint8_t> receptionBuffer;
@@ -63,7 +65,6 @@ private:
 	timeval receptionTimeout;
 
 	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
-	void handleReadError();
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 346abcd44..204be0377 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -1,4 +1,5 @@
 #include "TmTcWinUdpBridge.h"
+#include "tcpipHelpers.h"
 
 #include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/ipc/MutexGuard.h>
@@ -31,6 +32,10 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
 ReturnValue_t TmTcWinUdpBridge::initialize() {
     ReturnValue_t result = TmTcBridge::initialize();
     if(result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "TmTcWinUdpBridge::initialize: TmTcBridge initialization failed!"
+                << std::endl;
+#endif
         return result;
     }
 
@@ -60,12 +65,10 @@ ReturnValue_t TmTcWinUdpBridge::initialize() {
     hints.ai_protocol = IPPROTO_UDP;
     hints.ai_flags = AI_PASSIVE;
 
-    sif::info << udpServerPort << std::endl;
     /* Set up UDP socket:
-       https://en.wikipedia.org/wiki/Getaddrinfo
-       Passing nullptr as the first parameter and specifying AI_PASSIVE in hints will cause
-       getaddrinfo to assign the address 0.0.0.0 (any address)
-     */
+    https://en.wikipedia.org/wiki/Getaddrinfo
+    Passing nullptr as the first parameter and specifying AI_PASSIVE in hints will cause
+    getaddrinfo to assign the address 0.0.0.0 (any address) */
     int retval = getaddrinfo(nullptr, udpServerPort.c_str(), &hints, &addrResult);
     if (retval != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -82,7 +85,7 @@ ReturnValue_t TmTcWinUdpBridge::initialize() {
                 std::endl;
 #endif
         freeaddrinfo(addrResult);
-        handleSocketError();
+        tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SOCKET_CALL);
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
@@ -93,10 +96,9 @@ ReturnValue_t TmTcWinUdpBridge::initialize() {
                 "local port " << udpServerPort << " to server socket!" << std::endl;
 #endif
         freeaddrinfo(addrResult);
-        handleBindError();
+        tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::BIND_CALL);
     }
     freeaddrinfo(addrResult);
-
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -128,7 +130,7 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
         sif::error << "TmTcWinUdpBridge::sendTm: Send operation failed."
                 << std::endl;
 #endif
-        handleSendError();
+        tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
     }
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
     sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
@@ -156,154 +158,3 @@ void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
     }
 }
 
-void TmTcWinUdpBridge::handleSocketError() {
-    int errCode = WSAGetLastError();
-    switch(errCode) {
-    case(WSANOTINITIALISED): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: WSAStartup"
-                " call necessary" << std::endl;
-#endif
-        break;
-    }
-    default: {
-        /*
-        https://docs.microsoft.com/en-us/windows/win32/winsock/
-        windows-sockets-error-codes-2
-         */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TmTcWinUdpBridge::handleSocketError: Error code: " << errCode << std::endl;
-#endif
-        break;
-    }
-    }
-}
-
-void TmTcWinUdpBridge::handleBindError() {
-    int errCode = WSAGetLastError();
-    switch(errCode) {
-    case(WSANOTINITIALISED): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TmTcWinUdpBridge::handleBindError: WSANOTINITIALISED: "
-                << "WSAStartup call necessary" << std::endl;
-#endif
-        break;
-    }
-    case(WSAEADDRINUSE): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    	sif::warning << "TmTcWinUdpBridge::handleBindError: WSAEADDRINUSE: "
-    	        "Port is already in use!" << std::endl;
-#endif
-    	break;
-    }
-    default: {
-        /*
-        https://docs.microsoft.com/en-us/windows/win32/winsock/
-        windows-sockets-error-codes-2
-        */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TmTcWinUdpBridge::handleBindError: Error code: "
-                << errCode << std::endl;
-#endif
-        break;
-    }
-    }
-}
-
-void TmTcWinUdpBridge::handleSendError() {
-    int errCode = WSAGetLastError();
-    switch(errCode) {
-    case(WSANOTINITIALISED): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TmTcWinUdpBridge::handleSendError: WSANOTINITIALISED: "
-                << "WSAStartup(...) call necessary" << std::endl;
-#endif
-        break;
-    }
-    case(WSAEADDRNOTAVAIL): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TmTcWinUdpBridge::handleSendError: WSAEADDRNOTAVAIL: "
-                << "Check target address. " << std::endl;
-#endif
-        break;
-    }
-    default: {
-        /*
-        https://docs.microsoft.com/en-us/windows/win32/winsock/
-        windows-sockets-error-codes-2
-        */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TmTcWinUdpBridge::handleSendError: Error code: "
-                << errCode << std::endl;
-#endif
-        break;
-    }
-    }
-}
-
-ReturnValue_t TmTcWinUdpBridge::oldSetup() {
-    ReturnValue_t result = TmTcBridge::initialize();
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    // Initiates Winsock DLL.
-    WSAData wsaData;
-    WORD wVersionRequested = MAKEWORD(2, 2);
-    int err = WSAStartup(wVersionRequested, &wsaData);
-    if (err != 0) {
-        /* Tell the user that we could not find a usable */
-        /* Winsock DLL.                                  */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge:"
-                "WSAStartup failed with error: " << err << std::endl;
-#endif
-    }
-
-    uint16_t setServerPort = 7301;
-    uint16_t setClientPort = 7302;
-
-    // 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 == INVALID_SOCKET) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open"
-                " UDP socket!" << std::endl;
-#endif
-        handleSocketError();
-    }
-
-    serverAddress.sin_family = AF_INET;
-
-    // Accept packets from any interface. (potentially insecure).
-    serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-    serverAddress.sin_port = htons(setServerPort);
-    serverAddressLen = sizeof(serverAddress);
-
-//    sif::info << serverAddress.sin_addr.s_addr << std::endl;
-//    sif::info << serverAddress.sin_port << std::endl;
-
-    setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR,
-            reinterpret_cast<const char*>(&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 retval = bind(serverSocket,
-            reinterpret_cast<struct sockaddr*>(&serverAddress),
-            serverAddressLen);
-    if(retval != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
-                "local port " << setServerPort << " to server socket!"
-                << std::endl;
-#endif
-        handleBindError();
-    }
-
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
diff --git a/osal/windows/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
index b433f6f1e..b381e2cc5 100644
--- a/osal/windows/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -41,23 +41,9 @@ private:
     struct sockaddr_in serverAddress;
     int serverAddressLen = 0;
 
-    //! Access to the client address is mutex protected as it is set
-    //! by another task.
+    //! Access to the client address is mutex protected as it is set by another task.
     MutexIF* mutex;
-
-    enum class ErrorSources {
-        SOCKET_CALL,
-        SETSOCKOPT_CALL
-    };
-
-    void handleSocketError();
-    void handleBindError();
-    void handleSendError();
-
-    ReturnValue_t oldSetup();
 };
 
-
-
 #endif /* FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_ */
 
diff --git a/osal/windows/tcpipHelpers.cpp b/osal/windows/tcpipHelpers.cpp
new file mode 100644
index 000000000..3ad4bc825
--- /dev/null
+++ b/osal/windows/tcpipHelpers.cpp
@@ -0,0 +1,92 @@
+#include "tcpipHelpers.h"
+#include <FSFWConfig.h>
+
+#include "../../serviceinterface/ServiceInterface.h"
+
+#include <winsock2.h>
+#include <string>
+
+void tcpip::handleError(Protocol protocol, ErrorSources errorSrc, dur_millis_t sleepDuration) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    int errCode = WSAGetLastError();
+    std::string protocolString;
+    if(protocol == Protocol::TCP) {
+        protocolString = "TCP";
+    }
+    else if(protocol == Protocol::UDP) {
+        protocolString = "UDP";
+    }
+    else {
+        protocolString = "Unknown protocol";
+    }
+
+    std::string errorSrcString;
+    if(errorSrc == ErrorSources::SETSOCKOPT_CALL) {
+        errorSrcString = "setsockopt call";
+    }
+    else if(errorSrc == ErrorSources::SOCKET_CALL) {
+        errorSrcString = "socket call";
+    }
+    else if(errorSrc == ErrorSources::LISTEN_CALL) {
+        errorSrcString = "listen call";
+    }
+    else if(errorSrc == ErrorSources::ACCEPT_CALL) {
+        errorSrcString = "accept call";
+    }
+    else if(errorSrc == ErrorSources::RECVFROM_CALL) {
+        errorSrcString = "recvfrom call";
+    }
+    else if(errorSrc == ErrorSources::GETADDRINFO_CALL) {
+        errorSrcString = "getaddrinfo call";
+    }
+    else {
+        errorSrcString = "unknown call";
+    }
+
+    std::string infoString;
+    switch(errCode) {
+    case(WSANOTINITIALISED): {
+        infoString = "WSANOTINITIALISED";
+        sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
+                " | " << infoString << std::endl;
+        break;
+    }
+    case(WSAEADDRINUSE): {
+        infoString = "WSAEADDRINUSE";
+        sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
+                " | " << infoString << std::endl;
+        break;
+    }
+    case(WSAEFAULT): {
+        infoString = "WSAEFAULT";
+        sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
+                " | " << infoString << std::endl;
+        break;
+    }
+    case(WSAEADDRNOTAVAIL): {
+        infoString = "WSAEADDRNOTAVAIL";
+        sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
+                " | " << infoString << std::endl;
+        break;
+    }
+    case(WSAEINVAL): {
+        infoString = "WSAEINVAL";
+        sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
+                " | " << infoString << std::endl;
+        break;
+    }
+    default: {
+        /*
+        https://docs.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2
+         */
+        sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
+                "Error code" << errCode << std::endl;
+        break;
+    }
+    }
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+    if(sleepDuration > 0) {
+        Sleep(sleepDuration);
+    }
+}
+
diff --git a/osal/windows/tcpipHelpers.h b/osal/windows/tcpipHelpers.h
new file mode 100644
index 000000000..a88b0479a
--- /dev/null
+++ b/osal/windows/tcpipHelpers.h
@@ -0,0 +1,31 @@
+#ifndef FSFW_OSAL_WINDOWS_TCPIPHELPERS_H_
+#define FSFW_OSAL_WINDOWS_TCPIPHELPERS_H_
+
+#include "../../timemanager/clockDefinitions.h"
+
+namespace tcpip {
+
+enum class Protocol {
+    UDP,
+    TCP
+};
+
+enum class ErrorSources {
+    GETADDRINFO_CALL,
+    SOCKET_CALL,
+    SETSOCKOPT_CALL,
+    BIND_CALL,
+    RECV_CALL,
+    RECVFROM_CALL,
+    LISTEN_CALL,
+    ACCEPT_CALL,
+    SENDTO_CALL
+};
+
+void handleError(Protocol protocol, ErrorSources errorSrc, dur_millis_t sleepDuration = 0);
+
+}
+
+
+
+#endif /* FSFW_OSAL_WINDOWS_TCPIPHELPERS_H_ */

From cf120e2d862f0080ee8e4efeeab08ea4dd57225e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 14:08:58 +0100
Subject: [PATCH 1690/1774] smaller improvementst

---
 osal/windows/TmTcWinUdpBridge.cpp | 2 +-
 osal/windows/TmTcWinUdpBridge.h   | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 204be0377..e4952f359 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -93,7 +93,7 @@ ReturnValue_t TmTcWinUdpBridge::initialize() {
     if(retval != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
-                "local port " << udpServerPort << " to server socket!" << std::endl;
+                "local port (" << udpServerPort << ") to server socket!" << std::endl;
 #endif
         freeaddrinfo(addrResult);
         tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::BIND_CALL);
diff --git a/osal/windows/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
index b381e2cc5..989b4f7b8 100644
--- a/osal/windows/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -4,7 +4,6 @@
 #include "../../tmtcservices/TmTcBridge.h"
 
 #include <winsock2.h>
-#include <windows.h>
 
 //! Debugging preprocessor define.
 #define FSFW_UDP_SEND_WIRETAPPING_ENABLED    0

From 7173d2ecfc7f9a5cde53e083b5267149a0cc7adc Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 16:47:55 +0100
Subject: [PATCH 1691/1774] revaming linux UDP stuff

---
 osal/linux/CMakeLists.txt   |  1 +
 osal/linux/tcpipHelpers.cpp |  5 +++++
 osal/linux/tcpipHelpers.h   | 29 +++++++++++++++++++++++++++++
 3 files changed, 35 insertions(+)
 create mode 100644 osal/linux/tcpipHelpers.cpp
 create mode 100644 osal/linux/tcpipHelpers.h

diff --git a/osal/linux/CMakeLists.txt b/osal/linux/CMakeLists.txt
index 474e548bf..6c3778448 100644
--- a/osal/linux/CMakeLists.txt
+++ b/osal/linux/CMakeLists.txt
@@ -16,6 +16,7 @@ target_sources(${LIB_FSFW_NAME}
 		TcUnixUdpPollingTask.cpp
 		TmTcUnixUdpBridge.cpp
 		Timer.cpp
+		tcpipHelpers.cpp
 )
 
 find_package(Threads REQUIRED)
diff --git a/osal/linux/tcpipHelpers.cpp b/osal/linux/tcpipHelpers.cpp
new file mode 100644
index 000000000..7d25752d1
--- /dev/null
+++ b/osal/linux/tcpipHelpers.cpp
@@ -0,0 +1,5 @@
+#include "tcpipHelpers.h"
+
+void tcpip::handleError(Protocol protocol, ErrorSources errorSrc, dur_millis_t sleepDuration = 0) {
+
+}
diff --git a/osal/linux/tcpipHelpers.h b/osal/linux/tcpipHelpers.h
new file mode 100644
index 000000000..269a10368
--- /dev/null
+++ b/osal/linux/tcpipHelpers.h
@@ -0,0 +1,29 @@
+#ifndef FSFW_OSAL_LINUX_TCPIPHELPERS_H_
+#define FSFW_OSAL_LINUX_TCPIPHELPERS_H_
+
+#include "../../timemanager/clockDefinitions.h"
+
+namespace tcpip {
+
+enum class Protocol {
+    UDP,
+    TCP
+};
+
+enum class ErrorSources {
+    GETADDRINFO_CALL,
+    SOCKET_CALL,
+    SETSOCKOPT_CALL,
+    BIND_CALL,
+    RECV_CALL,
+    RECVFROM_CALL,
+    LISTEN_CALL,
+    ACCEPT_CALL,
+    SENDTO_CALL
+};
+
+void handleError(Protocol protocol, ErrorSources errorSrc, dur_millis_t sleepDuration = 0);
+
+}
+
+#endif /* FSFW_OSAL_LINUX_TCPIPHELPERS_H_ */

From 8ab2044c30ca4c03d6aacfecb387ce22ba950a88 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 17:15:53 +0100
Subject: [PATCH 1692/1774] refactoring unix udp bridge

---
 osal/linux/TmTcUnixUdpBridge.cpp  | 142 +++++++++++++++++++++---------
 osal/linux/TmTcUnixUdpBridge.h    |  14 +--
 osal/windows/TmTcWinUdpBridge.cpp |   3 +
 osal/windows/TmTcWinUdpBridge.h   |   3 -
 4 files changed, 112 insertions(+), 50 deletions(-)

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 7f110114d..ae1ad781c 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,69 +1,127 @@
 #include "TmTcUnixUdpBridge.h"
+#include "tcpipHelpers.h"
 #include "../../serviceinterface/ServiceInterface.h"
 #include "../../ipc/MutexGuard.h"
 
 #include <errno.h>
 #include <arpa/inet.h>
+#include <unistd.h>
+#include <netdb.h>
 
+#include <cstring>
+
+//! Debugging preprocessor define.
+#define FSFW_UDP_RCV_WIRETAPPING_ENABLED    1
+
+const std::string TmTcUnixUdpBridge::DEFAULT_UDP_SERVER_PORT =  "7301";
+const std::string TmTcUnixUdpBridge::DEFAULT_UDP_CLIENT_PORT =  "7302";
 
 TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
-		uint16_t serverPort, uint16_t clientPort):
+		std::string udpServerPort, std::string udpClientPort):
 		TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
-	mutex = MutexFactory::instance()->createMutex();
+    if(udpServerPort == "") {
+         this->udpServerPort = DEFAULT_UDP_SERVER_PORT;
+    }
+    else {
+        this->udpServerPort = udpServerPort;
+    }
+    if(udpClientPort == "") {
+        this->udpClientPort = DEFAULT_UDP_CLIENT_PORT;
+    }
+    else {
+        this->udpClientPort = udpClientPort;
+    }
 
-	uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
-	if(serverPort != 0xFFFF) {
-		setServerPort = serverPort;
-	}
+    mutex = MutexFactory::instance()->createMutex();
+    communicationLinkUp = false;
+}
 
-	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
-	if(clientPort != 0xFFFF) {
-		setClientPort = clientPort;
-	}
+ReturnValue_t TmTcUnixUdpBridge::initialize() {
+    using namespace tcpip;
 
-	// 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) {
+    ReturnValue_t result = TmTcBridge::initialize();
+    if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
-				" UDP socket!" << std::endl;
+        sif::error << "TmTcUnixUdpBridge::initialize: TmTcBridge initialization failed!"
+                << std::endl;
 #endif
-		handleSocketError();
-		return;
-	}
+        return result;
+    }
 
-	serverAddress.sin_family = AF_INET;
+    struct addrinfo *addrResult = nullptr;
+    struct addrinfo hints;
 
-	// 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));
+    std::memset(hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_DGRAM;
+    hints.ai_protocol = IPPROTO_UDP;
+    hints.ai_flags = AI_PASSIVE;
 
-	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) {
+    /* Set up UDP socket:
+    https://man7.org/linux/man-pages/man3/getaddrinfo.3.html
+    Passing nullptr as the first parameter and specifying AI_PASSIVE in hints will cause
+    getaddrinfo to assign the address 0.0.0.0 (any address) */
+    int retval = getaddrinfo(nullptr, udpServerPort.c_str(), &hints, &addrResult);
+    if (retval != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
-				"local port " << setServerPort << " to server socket!"
-				<< std::endl;
+        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Retrieving address info failed!" <<
+                std::endl;
 #endif
-		handleBindError();
-		return;
-	}
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    /* Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html */
+    serverSocket = socket(addrResult->ai_family, addrResult->ai_socktype, addrResult->ai_protocol);
+    if(serverSocket < 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open UDP socket!" <<
+                std::endl;
+#else
+        sif::printError("TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open UDP socket!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+        freeaddrinfo(addrResult);
+        handleError(Protocol::UDP, ErrorSources::SOCKET_CALL);
+        handleSocketError();
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    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) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
+                "local port " << setServerPort << " to server socket!"
+                << std::endl;
+#endif
+        handleBindError();
+        return;
+    }
+
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
+    if(mutex != nullptr) {
+        MutexFactory::instance()->deleteMutex(mutex);
+    }
+    close(serverSocket);
 }
 
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index ae6f6adca..c45672b66 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -10,16 +10,18 @@
 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;
+	/* The ports chosen here should not be used by any other process.
+	List of used ports on Linux: /etc/services */
+	static const std::string DEFAULT_UDP_SERVER_PORT;
+    static const std::string DEFAULT_UDP_CLIENT_PORT;
 
 	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);
+			std::string serverPort = "", std::string clientPort = "");
 	virtual~ TmTcUnixUdpBridge();
 
+	ReturnValue_t initialize() override;
+
 	void checkAndSetClientAddress(sockaddr_in& clientAddress);
 
 	void setClientAddressToAny(bool ipAddrAnySet);
@@ -28,6 +30,8 @@ protected:
 
 private:
 	int serverSocket = 0;
+	std::string udpServerPort;
+	std::string udpClientPort;
 
 	const int serverSocketOptions = 0;
 
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index e4952f359..b857ba671 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -5,6 +5,9 @@
 #include <fsfw/ipc/MutexGuard.h>
 #include <ws2tcpip.h>
 
+//! Debugging preprocessor define.
+#define FSFW_UDP_SEND_WIRETAPPING_ENABLED    0
+
 const std::string TmTcWinUdpBridge::DEFAULT_UDP_SERVER_PORT =  "7301";
 const std::string TmTcWinUdpBridge::DEFAULT_UDP_CLIENT_PORT =  "7302";
 
diff --git a/osal/windows/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
index 989b4f7b8..762849f8b 100644
--- a/osal/windows/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -5,9 +5,6 @@
 
 #include <winsock2.h>
 
-//! Debugging preprocessor define.
-#define FSFW_UDP_SEND_WIRETAPPING_ENABLED    0
-
 class TmTcWinUdpBridge: public TmTcBridge {
     friend class TcWinUdpPollingTask;
 public:

From bceca86da68eae0627ba69dfa9054250e53e1b63 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 18:06:24 +0100
Subject: [PATCH 1693/1774] finsihed tcpip refactoring for linux udp

---
 osal/CMakeLists.txt                 |   4 +-
 osal/common/CMakeLists.txt          |   3 +
 osal/common/tcpipCommon.cpp         |  36 ++++++
 osal/common/tcpipCommon.h           |  33 ++++++
 osal/linux/TcUnixUdpPollingTask.cpp | 103 ++++++++---------
 osal/linux/TcUnixUdpPollingTask.h   |   2 +-
 osal/linux/TmTcUnixUdpBridge.cpp    | 171 +++++++---------------------
 osal/linux/TmTcUnixUdpBridge.h      |   4 -
 osal/linux/tcpipHelpers.cpp         | 105 ++++++++++++++++-
 osal/linux/tcpipHelpers.h           |  17 +--
 osal/windows/TmTcWinUdpBridge.cpp   |  14 ++-
 osal/windows/tcpipHelpers.cpp       |  61 +++-------
 osal/windows/tcpipHelpers.h         |  18 +--
 13 files changed, 294 insertions(+), 277 deletions(-)
 create mode 100644 osal/common/CMakeLists.txt
 create mode 100644 osal/common/tcpipCommon.cpp
 create mode 100644 osal/common/tcpipCommon.h

diff --git a/osal/CMakeLists.txt b/osal/CMakeLists.txt
index 02ff24057..e4f1de7c7 100644
--- a/osal/CMakeLists.txt
+++ b/osal/CMakeLists.txt
@@ -31,4 +31,6 @@ else()
 		message(FATAL_ERROR "The host OS could not be determined! Aborting.")
 	endif()
 
-endif()
\ No newline at end of file
+endif()
+
+add_subdirectory(common)
\ No newline at end of file
diff --git a/osal/common/CMakeLists.txt b/osal/common/CMakeLists.txt
new file mode 100644
index 000000000..b77985fbd
--- /dev/null
+++ b/osal/common/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE 
+    tcpipCommon.cpp
+)
diff --git a/osal/common/tcpipCommon.cpp b/osal/common/tcpipCommon.cpp
new file mode 100644
index 000000000..9a5e4647c
--- /dev/null
+++ b/osal/common/tcpipCommon.cpp
@@ -0,0 +1,36 @@
+#include "tcpipCommon.h"
+
+void tcpip::determineErrorStrings(Protocol protocol, ErrorSources errorSrc, std::string &protStr,
+        std::string &srcString) {
+    if(protocol == Protocol::TCP) {
+        protStr = "TCP";
+    }
+    else if(protocol == Protocol::UDP) {
+        protStr = "UDP";
+    }
+    else {
+        protStr = "Unknown protocol";
+    }
+
+    if(errorSrc == ErrorSources::SETSOCKOPT_CALL) {
+        srcString = "setsockopt call";
+    }
+    else if(errorSrc == ErrorSources::SOCKET_CALL) {
+        srcString = "socket call";
+    }
+    else if(errorSrc == ErrorSources::LISTEN_CALL) {
+        srcString = "listen call";
+    }
+    else if(errorSrc == ErrorSources::ACCEPT_CALL) {
+        srcString = "accept call";
+    }
+    else if(errorSrc == ErrorSources::RECVFROM_CALL) {
+        srcString = "recvfrom call";
+    }
+    else if(errorSrc == ErrorSources::GETADDRINFO_CALL) {
+        srcString = "getaddrinfo call";
+    }
+    else {
+        srcString = "unknown call";
+    }
+}
diff --git a/osal/common/tcpipCommon.h b/osal/common/tcpipCommon.h
new file mode 100644
index 000000000..b59981ed3
--- /dev/null
+++ b/osal/common/tcpipCommon.h
@@ -0,0 +1,33 @@
+#ifndef FSFW_OSAL_COMMON_TCPIPCOMMON_H_
+#define FSFW_OSAL_COMMON_TCPIPCOMMON_H_
+
+#include "../../timemanager/clockDefinitions.h"
+#include <string>
+
+namespace tcpip {
+
+enum class Protocol {
+    UDP,
+    TCP
+};
+
+enum class ErrorSources {
+    GETADDRINFO_CALL,
+    SOCKET_CALL,
+    SETSOCKOPT_CALL,
+    BIND_CALL,
+    RECV_CALL,
+    RECVFROM_CALL,
+    LISTEN_CALL,
+    ACCEPT_CALL,
+    SENDTO_CALL
+};
+
+void determineErrorStrings(Protocol protocol, ErrorSources errorSrc, std::string& protStr,
+        std::string& srcString);
+
+}
+
+
+
+#endif /* FSFW_OSAL_COMMON_TCPIPCOMMON_H_ */
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 11ed7fee6..71557069e 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,7 +1,9 @@
 #include "TcUnixUdpPollingTask.h"
+#include "tcpipHelpers.h"
+
 #include "../../globalfunctions/arrayprinter.h"
 
-#include <errno.h>
+#define FSFW_UDP_RCV_WIRETAPPING_ENABLED    0
 
 TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,
@@ -15,8 +17,8 @@ TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
 		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!
+	/* 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);
 
@@ -31,34 +33,37 @@ TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
 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 = sizeof(senderAddress);
-		ssize_t bytesReceived = recvfrom(serverUdpSocket,
-				receptionBuffer.data(), frameSize, receptionFlags,
-				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
-		if(bytesReceived < 0) {
-			// handle error
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "TcSocketPollingTask::performOperation: Reception"
-					"error." << std::endl;
-#endif
-			handleReadError();
+    /* Sender Address is cached here. */
+    struct sockaddr_in senderAddress;
+    socklen_t senderAddressSize = sizeof(senderAddress);
 
+	/* Poll for new UDP datagrams in permanent loop. */
+	while(true) {
+		ssize_t bytesReceived = recvfrom(
+		        serverUdpSocket,
+				receptionBuffer.data(),
+				frameSize,
+				receptionFlags,
+				reinterpret_cast<sockaddr*>(&senderAddress),
+				&senderAddressSize
+		);
+		if(bytesReceived < 0) {
+			/* Handle error */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+			sif::error << "TcSocketPollingTask::performOperation: Reception error." << std::endl;
+#endif
+			tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::RECVFROM_CALL, 500);
 			continue;
 		}
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-//		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
-//				<< " bytes received" << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
+		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
+		        << " bytes received" << std::endl;
 #endif
 
 		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
 		if(result != HasReturnvaluesIF::RETURN_FAILED) {
 
 		}
-		tmtcBridge->registerCommConnect();
 		tmtcBridge->checkAndSetClientAddress(senderAddress);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
@@ -67,15 +72,21 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 
 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 FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
+    arrayprinter::print(receptionBuffer.data(), bytesRead);
+#endif
+
+    ReturnValue_t result = tcStore->addData(&storeId, receptionBuffer.data(), bytesRead);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+		sif::error << "TcUnixUdpPollingTask::handleSuccessfullTcRead: Data "
 				"storage failed" << std::endl;
 		sif::error << "Packet size: " << bytesRead << std::endl;
-#endif
+#else
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -83,10 +94,13 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 
 	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "Serial Polling: Sending message to queue failed"
-				<< std::endl;
-#endif
+		sif::error << "TcUnixUdpPollingTask::handleSuccessfullTcRead: Sending message to queue "
+		        "failed" << std::endl;
+#else
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 		tcStore->deleteData(storeId);
 	}
 	return result;
@@ -111,15 +125,17 @@ ReturnValue_t TcUnixUdpPollingTask::initialize() {
 		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.
+    /* Initialize the destination after task creation. This ensures
+    that the destination has already been set in the TMTC bridge. */
 	targetTcDestination = tmtcBridge->getRequestQueue();
+    /* The server socket is set up in the bridge intialization. Calling this function here
+    ensures that it is set up properly in any case*/
+    serverUdpSocket = tmtcBridge->serverSocket;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -135,24 +151,3 @@ void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
 #endif
 	}
 }
-
-// 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.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcUnixUdpPollingTask::handleReadError: Timeout."
-				<< std::endl;
-#endif
-		break;
-	}
-	default: {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcUnixUdpPollingTask::handleReadError: "
-				<< strerror(errno) << std::endl;
-#endif
-	}
-	}
-}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index cc0325616..39ee0914d 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -48,6 +48,7 @@ private:
 	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;
 
@@ -61,7 +62,6 @@ private:
 	timeval receptionTimeout;
 
 	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
-	void handleReadError();
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index ae1ad781c..856985608 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -3,7 +3,6 @@
 #include "../../serviceinterface/ServiceInterface.h"
 #include "../../ipc/MutexGuard.h"
 
-#include <errno.h>
 #include <arpa/inet.h>
 #include <unistd.h>
 #include <netdb.h>
@@ -11,7 +10,7 @@
 #include <cstring>
 
 //! Debugging preprocessor define.
-#define FSFW_UDP_RCV_WIRETAPPING_ENABLED    1
+#define FSFW_UDP_SEND_WIRETAPPING_ENABLED   0
 
 const std::string TmTcUnixUdpBridge::DEFAULT_UDP_SERVER_PORT =  "7301";
 const std::string TmTcUnixUdpBridge::DEFAULT_UDP_CLIENT_PORT =  "7302";
@@ -52,7 +51,7 @@ ReturnValue_t TmTcUnixUdpBridge::initialize() {
     struct addrinfo *addrResult = nullptr;
     struct addrinfo hints;
 
-    std::memset(hints, 0, sizeof(hints));
+    std::memset(&hints, 0, sizeof(hints));
     hints.ai_family = AF_INET;
     hints.ai_socktype = SOCK_DGRAM;
     hints.ai_protocol = IPPROTO_UDP;
@@ -82,36 +81,18 @@ ReturnValue_t TmTcUnixUdpBridge::initialize() {
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         freeaddrinfo(addrResult);
         handleError(Protocol::UDP, ErrorSources::SOCKET_CALL);
-        handleSocketError();
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
-    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) {
+    retval = bind(serverSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
+    if(retval != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
-                "local port " << setServerPort << " to server socket!"
-                << std::endl;
+        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
+                "local port (" << udpServerPort << ") to server socket!" << std::endl;
 #endif
-        handleBindError();
-        return;
+        freeaddrinfo(addrResult);
+        handleError(Protocol::UDP, ErrorSources::BIND_CALL);
+        return HasReturnvaluesIF::RETURN_FAILED;
     }
 
     return HasReturnvaluesIF::RETURN_OK;
@@ -131,133 +112,57 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 
 	if(ipAddrAnySet){
 		clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
-		//clientAddress.sin_addr.s_addr = inet_addr("127.73.73.1");
+		// clientAddress.sin_addr.s_addr = inet_addr("127.73.73.1");
 		clientAddressLen = sizeof(serverAddress);
 	}
-
-//	char ipAddress [15];
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
-//					&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
+    char ipAddress [15];
+	sif::debug << "IP Address Sender: "<<
+	        inet_ntop(AF_INET,&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 #endif
 
-	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
-			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
+	ssize_t bytesSent = sendto(
+	        serverSocket,
+	        data,
+	        dataLen,
+	        flags,
+			reinterpret_cast<sockaddr*>(&clientAddress),
+			clientAddressLen
+	);
 	if(bytesSent < 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
-				<< std::endl;
+        sif::warning << "TmTcUnixUdpBridge::sendTm: Send operation failed." << std::endl;
 #endif
-		handleSendError();
+        tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
 	}
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-//	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
-//			" sent." << std::endl;
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
+	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+	        " sent." << std::endl;
 #endif
+
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
 	MutexGuard lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
-//	char ipAddress [15];
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-//	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;
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
+    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;
 #endif
+	registerCommConnect();
 
-	// Set new IP address if it has changed.
+	/* 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;
+	    clientAddress = newAddress;
 		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):
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TmTcUnixBridge::handleSocketError: Socket creation failed"
-				<< " with " << strerror(errno) << std::endl;
-#endif
-		break;
-	default:
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TmTcUnixBridge::handleSocketError: Unknown error"
-				<< std::endl;
-#endif
-		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
-		 */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		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;
-#endif
-	}
-	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): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TmTcUnixBridge::handleBindError: Socket creation failed"
-				<< " with " << strerror(errno) << std::endl;
-#endif
-		break;
-	}
-	default:
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TmTcUnixBridge::handleBindError: Unknown error"
-				<< std::endl;
-#endif
-		break;
-	}
-}
-
-void TmTcUnixUdpBridge::handleSendError() {
-	switch(errno) {
-	default: {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TmTcUnixBridge::handleSendError: "
-		        << strerror(errno) << std::endl;
-#else
-		sif::printError("TmTcUnixBridge::handleSendError: %s\n",
-				strerror(errno));
-#endif
-	}
-	}
-}
-
 void TmTcUnixUdpBridge::setClientAddressToAny(bool ipAddrAnySet){
 	this->ipAddrAnySet = ipAddrAnySet;
 }
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index c45672b66..f5e671388 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -46,10 +46,6 @@ private:
 	//! 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_ */
diff --git a/osal/linux/tcpipHelpers.cpp b/osal/linux/tcpipHelpers.cpp
index 7d25752d1..1c3807696 100644
--- a/osal/linux/tcpipHelpers.cpp
+++ b/osal/linux/tcpipHelpers.cpp
@@ -1,5 +1,108 @@
 #include "tcpipHelpers.h"
 
-void tcpip::handleError(Protocol protocol, ErrorSources errorSrc, dur_millis_t sleepDuration = 0) {
+#include "../../tasks/TaskFactory.h"
 
+#include <errno.h>
+#include <string>
+
+void tcpip::handleError(Protocol protocol, ErrorSources errorSrc, dur_millis_t sleepDuration) {
+    int errCode = errno;
+    std::string protocolString;
+    std::string errorSrcString;
+    determineErrorStrings(protocol, errorSrc, protocolString, errorSrcString);
+    std::string infoString;
+    switch(errCode) {
+    case(EACCES): {
+        infoString = "EACCES";
+        break;
+    }
+    case(EINVAL): {
+        infoString = "EINVAL";
+        break;
+    }
+    case(EAGAIN): {
+        infoString = "EAGAIN";
+        break;
+    }
+    case(EMFILE): {
+        infoString = "EMFILE";
+        break;
+    }
+    case(ENFILE): {
+        infoString = "ENFILE";
+        break;
+    }
+    case(EAFNOSUPPORT): {
+        infoString = "EAFNOSUPPORT";
+        break;
+    }
+    case(ENOBUFS): {
+        infoString = "ENOBUFS";
+        break;
+    }
+    case(ENOMEM): {
+        infoString = "ENOMEM";
+        break;
+    }
+    case(EPROTONOSUPPORT): {
+        infoString = "EPROTONOSUPPORT";
+        break;
+    }
+    case(EADDRINUSE): {
+        infoString = "EADDRINUSE";
+        break;
+    }
+    case(EBADF): {
+        infoString = "EBADF";
+        break;
+    }
+    case(ENOTSOCK): {
+        infoString = "ENOTSOCK";
+        break;
+    }
+    case(EADDRNOTAVAIL): {
+        infoString = "EADDRNOTAVAIL";
+        break;
+    }
+    case(EFAULT): {
+        infoString = "EFAULT";
+        break;
+    }
+    case(ELOOP): {
+        infoString = "ELOOP";
+        break;
+    }
+    case(ENAMETOOLONG): {
+        infoString = "ENAMETOOLONG";
+        break;
+    }
+    case(ENOENT): {
+        infoString = "ENOENT";
+        break;
+    }
+    case(ENOTDIR): {
+        infoString = "ENOTDIR";
+        break;
+    }
+    case(EROFS):  {
+        infoString = "EROFS";
+        break;
+    }
+
+    default: {
+        infoString = "Error code: " + std::to_string(errCode);
+    }
+    }
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
+            " | " << infoString << std::endl;
+#else
+    sif::printWarning("tcpip::handleError: %s | %s | %s\n", protocolString,
+            errorSrcString, infoString);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
+    if(sleepDuration > 0) {
+        TaskFactory::instance()->delayTask(sleepDuration);
+    }
 }
diff --git a/osal/linux/tcpipHelpers.h b/osal/linux/tcpipHelpers.h
index 269a10368..6b337c62d 100644
--- a/osal/linux/tcpipHelpers.h
+++ b/osal/linux/tcpipHelpers.h
@@ -2,25 +2,10 @@
 #define FSFW_OSAL_LINUX_TCPIPHELPERS_H_
 
 #include "../../timemanager/clockDefinitions.h"
+#include "../common/tcpipCommon.h"
 
 namespace tcpip {
 
-enum class Protocol {
-    UDP,
-    TCP
-};
-
-enum class ErrorSources {
-    GETADDRINFO_CALL,
-    SOCKET_CALL,
-    SETSOCKOPT_CALL,
-    BIND_CALL,
-    RECV_CALL,
-    RECVFROM_CALL,
-    LISTEN_CALL,
-    ACCEPT_CALL,
-    SENDTO_CALL
-};
 
 void handleError(Protocol protocol, ErrorSources errorSrc, dur_millis_t sleepDuration = 0);
 
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index b857ba671..113c98fb9 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -125,13 +125,17 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
             &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 #endif
 
-    int bytesSent = sendto(serverSocket,
-            reinterpret_cast<const char*>(data), dataLen, flags,
-            reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
+    int bytesSent = sendto(
+            serverSocket,
+            reinterpret_cast<const char*>(data),
+            dataLen,
+            flags,
+            reinterpret_cast<sockaddr*>(&clientAddress),
+            clientAddressLen
+    );
     if(bytesSent == SOCKET_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcWinUdpBridge::sendTm: Send operation failed."
-                << std::endl;
+        sif::warning << "TmTcWinUdpBridge::sendTm: Send operation failed." << std::endl;
 #endif
         tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
     }
diff --git a/osal/windows/tcpipHelpers.cpp b/osal/windows/tcpipHelpers.cpp
index 3ad4bc825..ef07f5ca8 100644
--- a/osal/windows/tcpipHelpers.cpp
+++ b/osal/windows/tcpipHelpers.cpp
@@ -1,92 +1,63 @@
 #include "tcpipHelpers.h"
 #include <FSFWConfig.h>
 
+#include "../../tasks/TaskFactory.h"
 #include "../../serviceinterface/ServiceInterface.h"
 
+
 #include <winsock2.h>
 #include <string>
 
 void tcpip::handleError(Protocol protocol, ErrorSources errorSrc, dur_millis_t sleepDuration) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+#if FSFW_VERBOSE_LEVEL >= 1
     int errCode = WSAGetLastError();
     std::string protocolString;
-    if(protocol == Protocol::TCP) {
-        protocolString = "TCP";
-    }
-    else if(protocol == Protocol::UDP) {
-        protocolString = "UDP";
-    }
-    else {
-        protocolString = "Unknown protocol";
-    }
-
     std::string errorSrcString;
-    if(errorSrc == ErrorSources::SETSOCKOPT_CALL) {
-        errorSrcString = "setsockopt call";
-    }
-    else if(errorSrc == ErrorSources::SOCKET_CALL) {
-        errorSrcString = "socket call";
-    }
-    else if(errorSrc == ErrorSources::LISTEN_CALL) {
-        errorSrcString = "listen call";
-    }
-    else if(errorSrc == ErrorSources::ACCEPT_CALL) {
-        errorSrcString = "accept call";
-    }
-    else if(errorSrc == ErrorSources::RECVFROM_CALL) {
-        errorSrcString = "recvfrom call";
-    }
-    else if(errorSrc == ErrorSources::GETADDRINFO_CALL) {
-        errorSrcString = "getaddrinfo call";
-    }
-    else {
-        errorSrcString = "unknown call";
-    }
+    determineErrorStrings(protocol, errorSrc, protocolString, errorSrcString);
 
     std::string infoString;
     switch(errCode) {
     case(WSANOTINITIALISED): {
         infoString = "WSANOTINITIALISED";
-        sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
-                " | " << infoString << std::endl;
         break;
     }
     case(WSAEADDRINUSE): {
         infoString = "WSAEADDRINUSE";
-        sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
-                " | " << infoString << std::endl;
         break;
     }
     case(WSAEFAULT): {
         infoString = "WSAEFAULT";
-        sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
-                " | " << infoString << std::endl;
         break;
     }
     case(WSAEADDRNOTAVAIL): {
         infoString = "WSAEADDRNOTAVAIL";
-        sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
-                " | " << infoString << std::endl;
         break;
     }
     case(WSAEINVAL): {
         infoString = "WSAEINVAL";
-        sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
-                " | " << infoString << std::endl;
         break;
     }
     default: {
         /*
         https://docs.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2
          */
-        sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
-                "Error code" << errCode << std::endl;
+        infoString = "Error code: " + std::to_string(errCode);
         break;
     }
     }
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
+            " | " << infoString << std::endl;
+#else
+    sif::printWarning("tcpip::handleError: %s | %s | %s\n", protocolString,
+            errorSrcString, infoString);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+
     if(sleepDuration > 0) {
-        Sleep(sleepDuration);
+        TaskFactory::instance()->delayTask(sleepDuration);
     }
 }
 
diff --git a/osal/windows/tcpipHelpers.h b/osal/windows/tcpipHelpers.h
index a88b0479a..01f009b93 100644
--- a/osal/windows/tcpipHelpers.h
+++ b/osal/windows/tcpipHelpers.h
@@ -2,26 +2,10 @@
 #define FSFW_OSAL_WINDOWS_TCPIPHELPERS_H_
 
 #include "../../timemanager/clockDefinitions.h"
+#include "../common/tcpipCommon.h"
 
 namespace tcpip {
 
-enum class Protocol {
-    UDP,
-    TCP
-};
-
-enum class ErrorSources {
-    GETADDRINFO_CALL,
-    SOCKET_CALL,
-    SETSOCKOPT_CALL,
-    BIND_CALL,
-    RECV_CALL,
-    RECVFROM_CALL,
-    LISTEN_CALL,
-    ACCEPT_CALL,
-    SENDTO_CALL
-};
-
 void handleError(Protocol protocol, ErrorSources errorSrc, dur_millis_t sleepDuration = 0);
 
 }

From c08e2f0bf7ce634ab41a3513efba950955828ce9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 18:07:18 +0100
Subject: [PATCH 1694/1774] removed commented code

---
 osal/linux/TmTcUnixUdpBridge.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 856985608..c8dc612cc 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -112,9 +112,9 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 
 	if(ipAddrAnySet){
 		clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
-		// clientAddress.sin_addr.s_addr = inet_addr("127.73.73.1");
 		clientAddressLen = sizeof(serverAddress);
 	}
+
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
     char ipAddress [15];
 	sif::debug << "IP Address Sender: "<<

From 76c571b969bdabce34b1bce5b30586e67536388b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 18:12:38 +0100
Subject: [PATCH 1695/1774] made mutex properties changeable

---
 osal/linux/TmTcUnixUdpBridge.cpp  | 11 +++++++++--
 osal/linux/TmTcUnixUdpBridge.h    | 10 ++++++++--
 osal/windows/TmTcWinUdpBridge.cpp | 12 ++++++++++--
 osal/windows/TmTcWinUdpBridge.h   |  7 +++++++
 4 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index c8dc612cc..8de62cabc 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -108,7 +108,8 @@ TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	int flags = 0;
 
-	MutexGuard lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+	/* The target address can be set by different threads so this lock ensures thread-safety */
+	MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
 
 	if(ipAddrAnySet){
 		clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
@@ -145,7 +146,7 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 }
 
 void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
-	MutexGuard lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+	MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
     char ipAddress [15];
@@ -163,6 +164,12 @@ void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
 	}
 }
 
+void TmTcUnixUdpBridge::setMutexProperties(MutexIF::TimeoutType timeoutType,
+        dur_millis_t timeoutMs) {
+    this->timeoutType = timeoutType;
+    this->mutexTimeoutMs = timeoutMs;
+}
+
 void TmTcUnixUdpBridge::setClientAddressToAny(bool ipAddrAnySet){
 	this->ipAddrAnySet = ipAddrAnySet;
 }
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index f5e671388..26b6f0f75 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -20,6 +20,11 @@ public:
 			std::string serverPort = "", std::string clientPort = "");
 	virtual~ TmTcUnixUdpBridge();
 
+	/**
+	 * Set properties of internal mutex.
+	 */
+	void setMutexProperties(MutexIF::TimeoutType timeoutType, dur_millis_t timeoutMs);
+
 	ReturnValue_t initialize() override;
 
 	void checkAndSetClientAddress(sockaddr_in& clientAddress);
@@ -43,8 +48,9 @@ private:
 
 	bool ipAddrAnySet = false;
 
-	//! Access to the client address is mutex protected as it is set
-	//! by another task.
+	//! Access to the client address is mutex protected as it is set by another task.
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	dur_millis_t mutexTimeoutMs = 20;
 	MutexIF* mutex;
 };
 
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 113c98fb9..d2b2b2ec1 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -114,9 +114,11 @@ TmTcWinUdpBridge::~TmTcWinUdpBridge() {
 }
 
 ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
-    MutexGuard lock(mutex, MutexIF::TimeoutType::WAITING, 10);
     int flags = 0;
 
+    /* The target address can be set by different threads so this lock ensures thread-safety */
+    MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
+
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
     clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
     clientAddressLen = sizeof(serverAddress);
@@ -147,7 +149,8 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 }
 
 void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
-    MutexGuard lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+    /* The target address can be set by different threads so this lock ensures thread-safety */
+    MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
     char ipAddress [15];
@@ -165,3 +168,8 @@ void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
     }
 }
 
+void TmTcWinUdpBridge::setMutexProperties(MutexIF::TimeoutType timeoutType,
+        dur_millis_t timeoutMs) {
+    this->timeoutType = timeoutType;
+    this->mutexTimeoutMs = timeoutMs;
+}
diff --git a/osal/windows/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
index 762849f8b..5cae308de 100644
--- a/osal/windows/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -17,6 +17,11 @@ public:
             std::string udpServerPort = "", std::string udpClientPort = "");
     virtual~ TmTcWinUdpBridge();
 
+    /**
+     * Set properties of internal mutex.
+     */
+    void setMutexProperties(MutexIF::TimeoutType timeoutType, dur_millis_t timeoutMs);
+
     ReturnValue_t initialize() override;
 
     void checkAndSetClientAddress(sockaddr_in& clientAddress);
@@ -38,6 +43,8 @@ private:
     int serverAddressLen = 0;
 
     //! Access to the client address is mutex protected as it is set by another task.
+    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+    dur_millis_t mutexTimeoutMs = 20;
     MutexIF* mutex;
 };
 

From 2684b0c68e22d10444371f10dadc98c988542d5d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 18:15:16 +0100
Subject: [PATCH 1696/1774] small doc improvement

---
 osal/linux/TmTcUnixUdpBridge.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 8de62cabc..cf3c80ecf 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -146,7 +146,8 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 }
 
 void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
-	MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
+    /* The target address can be set by different threads so this lock ensures thread-safety */
+    MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
     char ipAddress [15];

From 5eb6b277ba4b5b07221005c2b50362c9fadc98bf Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 18:20:54 +0100
Subject: [PATCH 1697/1774] removed unused fields

---
 osal/windows/TmTcWinUdpBridge.cpp | 13 +++----------
 osal/windows/TmTcWinUdpBridge.h   |  9 +--------
 2 files changed, 4 insertions(+), 18 deletions(-)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index d2b2b2ec1..8b19b59ee 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -11,22 +11,15 @@
 const std::string TmTcWinUdpBridge::DEFAULT_UDP_SERVER_PORT =  "7301";
 const std::string TmTcWinUdpBridge::DEFAULT_UDP_CLIENT_PORT =  "7302";
 
-TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
-        object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
-        std::string udpServerPort, std::string udpClientPort):
+TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId, object_id_t tcDestination,
+        object_id_t tmStoreId, object_id_t tcStoreId, std::string udpServerPort):
         TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
     if(udpServerPort == "") {
-         this->udpServerPort = DEFAULT_UDP_SERVER_PORT;
+        this->udpServerPort = DEFAULT_UDP_SERVER_PORT;
     }
     else {
         this->udpServerPort = udpServerPort;
     }
-    if(udpClientPort == "") {
-        this->udpClientPort = DEFAULT_UDP_CLIENT_PORT;
-    }
-    else {
-        this->udpClientPort = udpClientPort;
-    }
 
     mutex = MutexFactory::instance()->createMutex();
     communicationLinkUp = false;
diff --git a/osal/windows/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
index 5cae308de..603f2b08d 100644
--- a/osal/windows/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -13,8 +13,7 @@ public:
     static const std::string DEFAULT_UDP_CLIENT_PORT;
 
     TmTcWinUdpBridge(object_id_t objectId, object_id_t tcDestination,
-            object_id_t tmStoreId, object_id_t tcStoreId,
-            std::string udpServerPort = "", std::string udpClientPort = "");
+            object_id_t tmStoreId, object_id_t tcStoreId, std::string udpServerPort = "");
     virtual~ TmTcWinUdpBridge();
 
     /**
@@ -32,16 +31,10 @@ protected:
 private:
     SOCKET serverSocket = 0;
     std::string udpServerPort;
-    std::string udpClientPort;
-
-    const int serverSocketOptions = 0;
 
     struct sockaddr_in clientAddress;
     int clientAddressLen = 0;
 
-    struct sockaddr_in serverAddress;
-    int serverAddressLen = 0;
-
     //! Access to the client address is mutex protected as it is set by another task.
     MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
     dur_millis_t mutexTimeoutMs = 20;

From 7bc04014e8a7949c8adb1332d6647ff9e63aeca8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 18:21:50 +0100
Subject: [PATCH 1698/1774] removed more unused fields

---
 osal/windows/TmTcWinUdpBridge.cpp | 1 -
 osal/windows/TmTcWinUdpBridge.h   | 1 -
 2 files changed, 2 deletions(-)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 8b19b59ee..2dd5699bc 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -9,7 +9,6 @@
 #define FSFW_UDP_SEND_WIRETAPPING_ENABLED    0
 
 const std::string TmTcWinUdpBridge::DEFAULT_UDP_SERVER_PORT =  "7301";
-const std::string TmTcWinUdpBridge::DEFAULT_UDP_CLIENT_PORT =  "7302";
 
 TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId, object_id_t tcDestination,
         object_id_t tmStoreId, object_id_t tcStoreId, std::string udpServerPort):
diff --git a/osal/windows/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
index 603f2b08d..51dcfe99b 100644
--- a/osal/windows/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -10,7 +10,6 @@ class TmTcWinUdpBridge: public TmTcBridge {
 public:
     /* The ports chosen here should not be used by any other process. */
     static const std::string DEFAULT_UDP_SERVER_PORT;
-    static const std::string DEFAULT_UDP_CLIENT_PORT;
 
     TmTcWinUdpBridge(object_id_t objectId, object_id_t tcDestination,
             object_id_t tmStoreId, object_id_t tcStoreId, std::string udpServerPort = "");

From 703dfe98548398cc2ca52a96a4ecfcad14b4cbf7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 12 Mar 2021 18:30:36 +0100
Subject: [PATCH 1699/1774] cleaned up a bit, removed unused fields

---
 osal/common/tcpipCommon.h           |  3 ++
 osal/linux/TcUnixUdpPollingTask.cpp |  1 -
 osal/linux/TmTcUnixUdpBridge.cpp    | 82 +++++++++++++----------------
 osal/linux/TmTcUnixUdpBridge.h      | 60 ++++++++++-----------
 osal/windows/TmTcWinUdpBridge.cpp   |  2 +-
 5 files changed, 69 insertions(+), 79 deletions(-)

diff --git a/osal/common/tcpipCommon.h b/osal/common/tcpipCommon.h
index b59981ed3..9b38c9fba 100644
--- a/osal/common/tcpipCommon.h
+++ b/osal/common/tcpipCommon.h
@@ -6,6 +6,9 @@
 
 namespace tcpip {
 
+const char* const DEFAULT_UDP_SERVER_PORT = "7301";
+const char* const DEFAULT_TCP_SERVER_PORT = "7303";
+
 enum class Protocol {
     UDP,
     TCP
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 71557069e..37dadb765 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -125,7 +125,6 @@ ReturnValue_t TcUnixUdpPollingTask::initialize() {
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
-
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index cf3c80ecf..2f620849b 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -12,25 +12,17 @@
 //! Debugging preprocessor define.
 #define FSFW_UDP_SEND_WIRETAPPING_ENABLED   0
 
-const std::string TmTcUnixUdpBridge::DEFAULT_UDP_SERVER_PORT =  "7301";
-const std::string TmTcUnixUdpBridge::DEFAULT_UDP_CLIENT_PORT =  "7302";
+const std::string TmTcUnixUdpBridge::DEFAULT_UDP_SERVER_PORT =  tcpip::DEFAULT_UDP_SERVER_PORT;
 
-TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
-		object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
-		std::string udpServerPort, std::string udpClientPort):
+TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
+        object_id_t tmStoreId, object_id_t tcStoreId, std::string udpServerPort):
 		TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
     if(udpServerPort == "") {
-         this->udpServerPort = DEFAULT_UDP_SERVER_PORT;
+        this->udpServerPort = DEFAULT_UDP_SERVER_PORT;
     }
     else {
         this->udpServerPort = udpServerPort;
     }
-    if(udpClientPort == "") {
-        this->udpClientPort = DEFAULT_UDP_CLIENT_PORT;
-    }
-    else {
-        this->udpClientPort = udpClientPort;
-    }
 
     mutex = MutexFactory::instance()->createMutex();
     communicationLinkUp = false;
@@ -106,43 +98,43 @@ TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 }
 
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
-	int flags = 0;
+    int flags = 0;
 
-	/* The target address can be set by different threads so this lock ensures thread-safety */
-	MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
+    /* The target address can be set by different threads so this lock ensures thread-safety */
+    MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
 
-	if(ipAddrAnySet){
-		clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
-		clientAddressLen = sizeof(serverAddress);
-	}
+    if(ipAddrAnySet){
+        clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
+        clientAddressLen = sizeof(clientAddress);
+    }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
     char ipAddress [15];
-	sif::debug << "IP Address Sender: "<<
-	        inet_ntop(AF_INET,&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+    sif::debug << "IP Address Sender: "<<
+            inet_ntop(AF_INET,&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 #endif
 
-	ssize_t bytesSent = sendto(
-	        serverSocket,
-	        data,
-	        dataLen,
-	        flags,
-			reinterpret_cast<sockaddr*>(&clientAddress),
-			clientAddressLen
-	);
-	if(bytesSent < 0) {
+    ssize_t bytesSent = sendto(
+            serverSocket,
+            data,
+            dataLen,
+            flags,
+            reinterpret_cast<sockaddr*>(&clientAddress),
+            clientAddressLen
+    );
+    if(bytesSent < 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "TmTcUnixUdpBridge::sendTm: Send operation failed." << std::endl;
 #endif
         tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
-	}
+    }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
-	        " sent." << std::endl;
+    sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+            " sent." << std::endl;
 #endif
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
@@ -151,18 +143,18 @@ void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
     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;
+    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;
 #endif
-	registerCommConnect();
+    registerCommConnect();
 
-	/* Set new IP address if it has changed. */
-	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
-	    clientAddress = newAddress;
-		clientAddressLen = sizeof(clientAddress);
-	}
+    /* Set new IP address if it has changed. */
+    if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
+        clientAddress = newAddress;
+        clientAddressLen = sizeof(clientAddress);
+    }
 }
 
 void TmTcUnixUdpBridge::setMutexProperties(MutexIF::TimeoutType timeoutType,
@@ -172,6 +164,6 @@ void TmTcUnixUdpBridge::setMutexProperties(MutexIF::TimeoutType timeoutType,
 }
 
 void TmTcUnixUdpBridge::setClientAddressToAny(bool ipAddrAnySet){
-	this->ipAddrAnySet = ipAddrAnySet;
+    this->ipAddrAnySet = ipAddrAnySet;
 }
 
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index 26b6f0f75..3ab2118cc 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -7,51 +7,47 @@
 #include <netinet/in.h>
 #include <netinet/udp.h>
 
-class TmTcUnixUdpBridge: public TmTcBridge {
-	friend class TcUnixUdpPollingTask;
+class TmTcUnixUdpBridge:
+        public TmTcBridge {
+    friend class TcUnixUdpPollingTask;
 public:
-	/* The ports chosen here should not be used by any other process.
+
+    /* The ports chosen here should not be used by any other process.
 	List of used ports on Linux: /etc/services */
-	static const std::string DEFAULT_UDP_SERVER_PORT;
-    static const std::string DEFAULT_UDP_CLIENT_PORT;
+    static const std::string DEFAULT_UDP_SERVER_PORT;
 
-	TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
-			object_id_t tmStoreId, object_id_t tcStoreId,
-			std::string serverPort = "", std::string clientPort = "");
-	virtual~ TmTcUnixUdpBridge();
+    TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
+            object_id_t tmStoreId, object_id_t tcStoreId,
+            std::string serverPort = "");
+    virtual~ TmTcUnixUdpBridge();
 
-	/**
-	 * Set properties of internal mutex.
-	 */
-	void setMutexProperties(MutexIF::TimeoutType timeoutType, dur_millis_t timeoutMs);
+    /**
+     * Set properties of internal mutex.
+     */
+    void setMutexProperties(MutexIF::TimeoutType timeoutType, dur_millis_t timeoutMs);
 
-	ReturnValue_t initialize() override;
+    ReturnValue_t initialize() override;
 
-	void checkAndSetClientAddress(sockaddr_in& clientAddress);
+    void checkAndSetClientAddress(sockaddr_in& clientAddress);
+
+    void setClientAddressToAny(bool ipAddrAnySet);
 
-	void setClientAddressToAny(bool ipAddrAnySet);
 protected:
-	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
+    virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
 
 private:
-	int serverSocket = 0;
-	std::string udpServerPort;
-	std::string udpClientPort;
+    int serverSocket = 0;
+    std::string udpServerPort;
 
-	const int serverSocketOptions = 0;
+    struct sockaddr_in clientAddress;
+    socklen_t clientAddressLen = 0;
 
-	struct sockaddr_in clientAddress;
-	socklen_t clientAddressLen = 0;
+    bool ipAddrAnySet = false;
 
-	struct sockaddr_in serverAddress;
-	socklen_t serverAddressLen = 0;
-
-	bool ipAddrAnySet = false;
-
-	//! Access to the client address is mutex protected as it is set by another task.
-	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-	dur_millis_t mutexTimeoutMs = 20;
-	MutexIF* mutex;
+    //! Access to the client address is mutex protected as it is set by another task.
+    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+    dur_millis_t mutexTimeoutMs = 20;
+    MutexIF* mutex;
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 2dd5699bc..ca0fe2d1d 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -8,7 +8,7 @@
 //! Debugging preprocessor define.
 #define FSFW_UDP_SEND_WIRETAPPING_ENABLED    0
 
-const std::string TmTcWinUdpBridge::DEFAULT_UDP_SERVER_PORT =  "7301";
+const std::string TmTcWinUdpBridge::DEFAULT_UDP_SERVER_PORT =  tcpip::DEFAULT_UDP_SERVER_PORT;
 
 TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId, object_id_t tcDestination,
         object_id_t tmStoreId, object_id_t tcStoreId, std::string udpServerPort):

From 588f9471d8f4b730df5ddf6ff51c7e264ff4b142 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 15 Mar 2021 13:06:13 +0100
Subject: [PATCH 1700/1774] some stuff is buggy

---
 osal/windows/TcWinUdpPollingTask.cpp | 3 +++
 osal/windows/TcWinUdpPollingTask.h   | 3 ---
 osal/windows/TmTcWinUdpBridge.cpp    | 6 +++---
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 324547faf..ce77deb94 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -5,6 +5,9 @@
 
 #include <winsock2.h>
 
+//! Debugging preprocessor define.
+#define FSFW_UDP_RCV_WIRETAPPING_ENABLED    1
+
 TcWinUdpPollingTask::TcWinUdpPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,
 		double timeoutSeconds): SystemObject(objectId),
diff --git a/osal/windows/TcWinUdpPollingTask.h b/osal/windows/TcWinUdpPollingTask.h
index 707ad2824..35e3a701e 100644
--- a/osal/windows/TcWinUdpPollingTask.h
+++ b/osal/windows/TcWinUdpPollingTask.h
@@ -8,9 +8,6 @@
 
 #include <vector>
 
-//! Debugging preprocessor define.
-#define FSFW_UDP_RCV_WIRETAPPING_ENABLED    0
-
 /**
  * @brief 	This class can be used to implement the polling of a Unix socket,
  * 			using UDP for now.
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index ca0fe2d1d..c4c26e686 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -6,7 +6,7 @@
 #include <ws2tcpip.h>
 
 //! Debugging preprocessor define.
-#define FSFW_UDP_SEND_WIRETAPPING_ENABLED    0
+#define FSFW_UDP_SEND_WIRETAPPING_ENABLED    1
 
 const std::string TmTcWinUdpBridge::DEFAULT_UDP_SERVER_PORT =  tcpip::DEFAULT_UDP_SERVER_PORT;
 
@@ -112,8 +112,8 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
     MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-    clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
-    clientAddressLen = sizeof(serverAddress);
+    //clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
+    //clientAddressLen = sizeof(serverAddress);
     char ipAddress [15];
     sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
             &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;

From ca4a0b1bb80107f150250c2c5e7cb04279b65561 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 15 Mar 2021 21:33:45 +0100
Subject: [PATCH 1701/1774] wiretapping disabled again

---
 osal/windows/TcWinUdpPollingTask.cpp | 2 +-
 osal/windows/TmTcWinUdpBridge.cpp    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index ce77deb94..980404f9d 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -6,7 +6,7 @@
 #include <winsock2.h>
 
 //! Debugging preprocessor define.
-#define FSFW_UDP_RCV_WIRETAPPING_ENABLED    1
+#define FSFW_UDP_RCV_WIRETAPPING_ENABLED    0
 
 TcWinUdpPollingTask::TcWinUdpPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index c4c26e686..f9c97caaa 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -6,7 +6,7 @@
 #include <ws2tcpip.h>
 
 //! Debugging preprocessor define.
-#define FSFW_UDP_SEND_WIRETAPPING_ENABLED    1
+#define FSFW_UDP_SEND_WIRETAPPING_ENABLED    0
 
 const std::string TmTcWinUdpBridge::DEFAULT_UDP_SERVER_PORT =  tcpip::DEFAULT_UDP_SERVER_PORT;
 

From 1996f5949fbc1d3051d8aaa0f2c29e6b7700facf Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 16 Mar 2021 14:46:05 +0100
Subject: [PATCH 1702/1774] separate windows handling

---
 datapoollocal/LocalPoolDataSetBase.cpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 2a2444c48..16c6857d9 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -96,15 +96,22 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
         SerializeIF::Endianness streamEndianness) const {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     const uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+    uint8_t* validityPtr = nullptr;
+#ifdef _WIN32
     /* Use a std::vector here because MSVC will (rightly) not create a fixed size array
     with a non constant size specifier */
     std::vector<uint8_t> validityMask(validityMaskSize);
+    validityPtr = validityMask.data();
+#else
+    uint8_t validityMask[validityMaskSize];
+    validityPtr = validityMask;
+#endif
     uint8_t validBufferIndex = 0;
     uint8_t validBufferIndexBit = 0;
     for (uint16_t count = 0; count < fillCount; count++) {
         if(registeredVariables[count]->isValid()) {
             /* Set bit at correct position */
-            bitutil::bitSet(validityMask.data() + validBufferIndex, validBufferIndexBit);
+            bitutil::bitSet(validityMask + validBufferIndex, validBufferIndexBit);
         }
         if(validBufferIndexBit == 7) {
             validBufferIndex ++;
@@ -125,7 +132,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
         return SerializeIF::BUFFER_TOO_SHORT;
     }
     // copy validity buffer to end
-    std::memcpy(*buffer, validityMask.data(), validityMaskSize);
+    std::memcpy(*buffer, validityPtr, validityMaskSize);
     *size += validityMaskSize;
     return result;
 }

From 26ce8d718557b9627dfeda374ab67197afdcd1e2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 16 Mar 2021 14:49:51 +0100
Subject: [PATCH 1703/1774] msc stuff

---
 datapoollocal/LocalPoolDataSetBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 16c6857d9..6aa66f829 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -97,7 +97,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     const uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
     uint8_t* validityPtr = nullptr;
-#ifdef _WIN32
+#ifdef _MSC_VER
     /* Use a std::vector here because MSVC will (rightly) not create a fixed size array
     with a non constant size specifier */
     std::vector<uint8_t> validityMask(validityMaskSize);

From 8dec4c931147d7c3c39c812aaa985953f37380b2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 16 Mar 2021 14:53:17 +0100
Subject: [PATCH 1704/1774] updated pool data set base

---
 datapoollocal/LocalPoolDataSetBase.cpp | 30 +++++++++++++++++++-------
 datapoollocal/LocalPoolDataSetBase.h   | 16 ++++++++++----
 2 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 2d70712b2..6aa66f829 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -44,7 +44,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
-                PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
     if(hkOwner != nullptr) {
@@ -96,15 +96,22 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
         SerializeIF::Endianness streamEndianness) const {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     const uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+    uint8_t* validityPtr = nullptr;
+#ifdef _MSC_VER
     /* Use a std::vector here because MSVC will (rightly) not create a fixed size array
     with a non constant size specifier */
     std::vector<uint8_t> validityMask(validityMaskSize);
+    validityPtr = validityMask.data();
+#else
+    uint8_t validityMask[validityMaskSize];
+    validityPtr = validityMask;
+#endif
     uint8_t validBufferIndex = 0;
     uint8_t validBufferIndexBit = 0;
     for (uint16_t count = 0; count < fillCount; count++) {
         if(registeredVariables[count]->isValid()) {
             /* Set bit at correct position */
-            bitutil::bitSet(validityMask.data() + validBufferIndex, validBufferIndexBit);
+            bitutil::bitSet(validityMask + validBufferIndex, validBufferIndexBit);
         }
         if(validBufferIndexBit == 7) {
             validBufferIndex ++;
@@ -125,7 +132,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
         return SerializeIF::BUFFER_TOO_SHORT;
     }
     // copy validity buffer to end
-    std::memcpy(*buffer, validityMask.data(), validityMaskSize);
+    std::memcpy(*buffer, validityPtr, validityMaskSize);
     *size += validityMaskSize;
     return result;
 }
@@ -264,11 +271,9 @@ bool LocalPoolDataSetBase::getReportingEnabled() const {
     return reportingEnabled;
 }
 
-void LocalPoolDataSetBase::initializePeriodicHelper(
-        float collectionInterval, dur_millis_t minimumPeriodicInterval,
-        bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
-    periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
-            isDiagnostics, nonDiagIntervalFactor);
+void LocalPoolDataSetBase::initializePeriodicHelper(float collectionInterval,
+        dur_millis_t minimumPeriodicInterval, uint8_t nonDiagIntervalFactor) {
+    periodicHelper->initialize(collectionInterval, minimumPeriodicInterval, nonDiagIntervalFactor);
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
@@ -308,3 +313,12 @@ void LocalPoolDataSetBase::setAllVariablesReadOnly() {
         registeredVariables[idx]->setReadWriteMode(pool_rwm_t::VAR_READ);
     }
 }
+
+float LocalPoolDataSetBase::getCollectionInterval() const {
+    if(periodicHelper != nullptr) {
+        return periodicHelper->getCollectionIntervalInSeconds();
+    }
+    else {
+        return 0.0;
+    }
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 404509ae5..ab67dc3f9 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -166,6 +166,16 @@ public:
 
     object_id_t getCreatorObjectId();
 
+    bool getReportingEnabled() const;
+
+    /**
+     * Returns the current periodic HK generation interval this set
+     * belongs to a HK manager and the interval is not 0. Otherwise,
+     * returns 0.0
+     * @return
+     */
+    float getCollectionInterval() const;
+
 protected:
     sid_t sid;
     //! This mutex is used if the data is created by one object only.
@@ -180,11 +190,9 @@ protected:
      */
     bool reportingEnabled = false;
     void setReportingEnabled(bool enabled);
-    bool getReportingEnabled() const;
 
-    void initializePeriodicHelper(float collectionInterval,
-            dur_millis_t minimumPeriodicInterval,
-            bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5);
+    void initializePeriodicHelper(float collectionInterval, dur_millis_t minimumPeriodicInterval,
+            uint8_t nonDiagIntervalFactor = 5);
 
     /**
      * If the valid state of a dataset is always relevant to the whole

From 12f47fdd0d2b6e005471344b32476145935e5bd3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 16 Mar 2021 15:32:58 +0100
Subject: [PATCH 1705/1774] removed commented code

---
 osal/windows/TmTcWinUdpBridge.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index f9c97caaa..fd289ed8d 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -112,8 +112,6 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
     MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-    //clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
-    //clientAddressLen = sizeof(serverAddress);
     char ipAddress [15];
     sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
             &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;

From 3f8fae24ddd47fb5f90d0f3e13c9acb2a9232819 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 16 Mar 2021 15:34:13 +0100
Subject: [PATCH 1706/1774] smaller tweak

---
 datapoollocal/LocalPoolDataSetBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 6aa66f829..99c7a1cd2 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -111,7 +111,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
     for (uint16_t count = 0; count < fillCount; count++) {
         if(registeredVariables[count]->isValid()) {
             /* Set bit at correct position */
-            bitutil::bitSet(validityMask + validBufferIndex, validBufferIndexBit);
+            bitutil::bitSet(validityPtr + validBufferIndex, validBufferIndexBit);
         }
         if(validBufferIndexBit == 7) {
             validBufferIndex ++;

From 95096d83dec25af5f266fadb2dd73ce486bf3340 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 17 Mar 2021 15:43:01 +0100
Subject: [PATCH 1707/1774] fixed bug

---
 datapoollocal/LocalPoolDataSetBase.cpp | 2 +-
 osal/windows/TcWinTcpServer.cpp        | 2 ++
 osal/windows/TmTcWinUdpBridge.h        | 1 +
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 99c7a1cd2..d78940488 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -103,7 +103,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
     std::vector<uint8_t> validityMask(validityMaskSize);
     validityPtr = validityMask.data();
 #else
-    uint8_t validityMask[validityMaskSize];
+    uint8_t validityMask[validityMaskSize] = {};
     validityPtr = validityMask;
 #endif
     uint8_t validBufferIndex = 0;
diff --git a/osal/windows/TcWinTcpServer.cpp b/osal/windows/TcWinTcpServer.cpp
index 49c278c5c..f68edfba6 100644
--- a/osal/windows/TcWinTcpServer.cpp
+++ b/osal/windows/TcWinTcpServer.cpp
@@ -64,8 +64,10 @@ ReturnValue_t TcWinTcpServer::initialize() {
 
     retval = bind(listenerTcpSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
     if(retval == SOCKET_ERROR) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "TcWinTcpServer::TcWinTcpServer: Binding socket failed!" <<
                 std::endl;
+#endif
         freeaddrinfo(addrResult);
         handleError(Protocol::TCP, ErrorSources::BIND_CALL);
     }
diff --git a/osal/windows/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
index 51dcfe99b..c2f7d6aaa 100644
--- a/osal/windows/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -3,6 +3,7 @@
 
 #include "../../tmtcservices/TmTcBridge.h"
 
+#include <string>
 #include <winsock2.h>
 
 class TmTcWinUdpBridge: public TmTcBridge {

From 1b8878a81f039bb813c718006c48e01b53191803 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 17 Mar 2021 15:46:17 +0100
Subject: [PATCH 1708/1774] more explicit

---
 datapoollocal/LocalPoolDataSetBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index d78940488..7f181c930 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -103,7 +103,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
     std::vector<uint8_t> validityMask(validityMaskSize);
     validityPtr = validityMask.data();
 #else
-    uint8_t validityMask[validityMaskSize] = {};
+    uint8_t validityMask[validityMaskSize] = {0};
     validityPtr = validityMask;
 #endif
     uint8_t validBufferIndex = 0;

From b41eb518e74d2803fde93ef87687b8f7c5979431 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 17 Mar 2021 23:28:01 +0100
Subject: [PATCH 1709/1774] improved internal error reporter

---
 internalError/InternalErrorReporter.cpp | 187 ++++++++++++------------
 internalError/InternalErrorReporter.h   |  87 +++++------
 2 files changed, 137 insertions(+), 137 deletions(-)

diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 7e5a316ca..402071b2a 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -3,19 +3,20 @@
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
 #include "../serviceinterface/ServiceInterface.h"
+#include "../datapool/PoolReadGuard.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
         uint32_t messageQueueDepth): SystemObject(setObjectId),
-		commandQueue(QueueFactory::instance()->
-		        createMessageQueue(messageQueueDepth)),
-		poolManager(this, commandQueue),
-		internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
-		internalErrorDataset(this) {
-	mutex = MutexFactory::instance()->createMutex();
+        commandQueue(QueueFactory::instance()->
+                createMessageQueue(messageQueueDepth)),
+                poolManager(this, commandQueue),
+                internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
+                internalErrorDataset(this) {
+    mutex = MutexFactory::instance()->createMutex();
 }
 
 InternalErrorReporter::~InternalErrorReporter() {
-	MutexFactory::instance()->deleteMutex(mutex);
+    MutexFactory::instance()->deleteMutex(mutex);
 }
 
 void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
@@ -23,126 +24,127 @@ void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
 }
 
 ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
-    internalErrorDataset.read(timeoutType, timeoutMs);
+    CommandMessage message;
+    ReturnValue_t result = commandQueue->receiveMessage(&message);
+    if(result != MessageQueueIF::EMPTY) {
+        poolManager.handleHousekeepingMessage(&message);
+    }
 
-	uint32_t newQueueHits = getAndResetQueueHits();
-	uint32_t newTmHits = getAndResetTmHits();
-	uint32_t newStoreHits = getAndResetStoreHits();
+    uint32_t newQueueHits = getAndResetQueueHits();
+    uint32_t newTmHits = getAndResetTmHits();
+    uint32_t newStoreHits = getAndResetStoreHits();
 
-#if FSFW_VERBOSE_LEVEL == 1
-	if(diagnosticPrintout) {
-	    if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
+#if FSFW_VERBOSE_LEVEL >= 1
+    if(diagnosticPrintout) {
+        if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	        sif::debug << "InternalErrorReporter::performOperation: Errors "
-	                << "occured!" << std::endl;
-	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
-	        sif::debug << "TM errors: " << newTmHits << std::endl;
-	        sif::debug << "Store errors: " << newStoreHits << std::endl;
+            sif::debug << "InternalErrorReporter::performOperation: Errors "
+                    << "occured!" << std::endl;
+            sif::debug << "Queue errors: " << newQueueHits << std::endl;
+            sif::debug << "TM errors: " << newTmHits << std::endl;
+            sif::debug << "Store errors: " << newStoreHits << std::endl;
 #else
-	        sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
-	        sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
-	        sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
-	        sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
+            sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
+            sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
+            sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
+            sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
 #endif
-	    }
-	}
+        }
+    }
 #endif
 
-	internalErrorDataset.queueHits.value += newQueueHits;
-	internalErrorDataset.storeHits.value += newStoreHits;
-	internalErrorDataset.tmHits.value += newTmHits;
-	internalErrorDataset.setValidity(true, true);
-	internalErrorDataset.commit(timeoutType, timeoutMs);
+    PoolReadGuard readGuard(&internalErrorDataset);
+    internalErrorDataset.read(timeoutType, timeoutMs);
+    if(readGuard.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+        internalErrorDataset.queueHits.value += newQueueHits;
+        internalErrorDataset.storeHits.value += newStoreHits;
+        internalErrorDataset.tmHits.value += newTmHits;
+        internalErrorDataset.setValidity(true, true);
+    }
 
-	poolManager.performHkOperation();
-
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
-	if(result != MessageQueueIF::EMPTY) {
-	    poolManager.handleHousekeepingMessage(&message);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    poolManager.performHkOperation();
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void InternalErrorReporter::queueMessageNotSent() {
-	incrementQueueHits();
+    incrementQueueHits();
 }
 
 void InternalErrorReporter::lostTm() {
-	incrementTmHits();
+    incrementTmHits();
 }
 
 uint32_t InternalErrorReporter::getAndResetQueueHits() {
-	uint32_t value;
-	mutex->lockMutex(timeoutType, timeoutMs);
-	value = queueHits;
-	queueHits = 0;
-	mutex->unlockMutex();
-	return value;
+    uint32_t value;
+    mutex->lockMutex(timeoutType, timeoutMs);
+    value = queueHits;
+    queueHits = 0;
+    mutex->unlockMutex();
+    return value;
 }
 
 uint32_t InternalErrorReporter::getQueueHits() {
-	uint32_t value;
-	mutex->lockMutex(timeoutType, timeoutMs);
-	value = queueHits;
-	mutex->unlockMutex();
-	return value;
+    uint32_t value;
+    mutex->lockMutex(timeoutType, timeoutMs);
+    value = queueHits;
+    mutex->unlockMutex();
+    return value;
 }
 
 void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(timeoutType, timeoutMs);
-	queueHits++;
-	mutex->unlockMutex();
+    mutex->lockMutex(timeoutType, timeoutMs);
+    queueHits++;
+    mutex->unlockMutex();
 }
 
 uint32_t InternalErrorReporter::getAndResetTmHits() {
-	uint32_t value;
-	mutex->lockMutex(timeoutType, timeoutMs);
-	value = tmHits;
-	tmHits = 0;
-	mutex->unlockMutex();
-	return value;
+    uint32_t value;
+    mutex->lockMutex(timeoutType, timeoutMs);
+    value = tmHits;
+    tmHits = 0;
+    mutex->unlockMutex();
+    return value;
 }
 
 uint32_t InternalErrorReporter::getTmHits() {
-	uint32_t value;
-	mutex->lockMutex(timeoutType, timeoutMs);
-	value = tmHits;
-	mutex->unlockMutex();
-	return value;
+    uint32_t value;
+    mutex->lockMutex(timeoutType, timeoutMs);
+    value = tmHits;
+    mutex->unlockMutex();
+    return value;
 }
 
 void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(timeoutType, timeoutMs);
-	tmHits++;
-	mutex->unlockMutex();
+    mutex->lockMutex(timeoutType, timeoutMs);
+    tmHits++;
+    mutex->unlockMutex();
 }
 
 void InternalErrorReporter::storeFull() {
-	incrementStoreHits();
+    incrementStoreHits();
 }
 
 uint32_t InternalErrorReporter::getAndResetStoreHits() {
-	uint32_t value;
-	mutex->lockMutex(timeoutType, timeoutMs);
-	value = storeHits;
-	storeHits = 0;
-	mutex->unlockMutex();
-	return value;
+    uint32_t value;
+    mutex->lockMutex(timeoutType, timeoutMs);
+    value = storeHits;
+    storeHits = 0;
+    mutex->unlockMutex();
+    return value;
 }
 
 uint32_t InternalErrorReporter::getStoreHits() {
-	uint32_t value;
-	mutex->lockMutex(timeoutType, timeoutMs);
-	value = storeHits;
-	mutex->unlockMutex();
-	return value;
+    uint32_t value;
+    mutex->lockMutex(timeoutType, timeoutMs);
+    value = storeHits;
+    mutex->unlockMutex();
+    return value;
 }
 
 void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(timeoutType, timeoutMs);
-	storeHits++;
-	mutex->unlockMutex();
+    mutex->lockMutex(timeoutType, timeoutMs);
+    storeHits++;
+    mutex->unlockMutex();
 }
 
 object_id_t InternalErrorReporter::getObjectId() const {
@@ -155,14 +157,11 @@ MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
 
 ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
         localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
-    localDataPoolMap.emplace(errorPoolIds::TM_HITS,
-            new PoolEntry<uint32_t>());
-    localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS,
-            new PoolEntry<uint32_t>());
-    localDataPoolMap.emplace(errorPoolIds::STORE_HITS,
-            new PoolEntry<uint32_t>());
-    poolManager.subscribeForPeriodicPacket(internalErrorSid, false,
-            getPeriodicOperationFrequency(), true);
+    localDataPoolMap.emplace(errorPoolIds::TM_HITS, new PoolEntry<uint32_t>());
+    localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS, new PoolEntry<uint32_t>());
+    localDataPoolMap.emplace(errorPoolIds::STORE_HITS, new PoolEntry<uint32_t>());
+    poolManager.subscribeForPeriodicPacket(internalErrorSid, false, getPeriodicOperationFrequency(),
+            true);
     internalErrorDataset.setValidity(true, true);
     return HasReturnvaluesIF::RETURN_OK;
 }
@@ -192,9 +191,9 @@ ReturnValue_t InternalErrorReporter::initializeAfterTaskCreation() {
 }
 
 void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType,
-		uint32_t timeoutMs) {
-	this->timeoutType = timeoutType;
-	this->timeoutMs = timeoutMs;
+        uint32_t timeoutMs) {
+    this->timeoutType = timeoutType;
+    this->timeoutMs = timeoutMs;
 }
 
 LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() {
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index a237418ed..580cb8f6c 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -17,77 +17,78 @@
  * All functions were kept virtual so this class can be extended easily
  * to store custom internal errors (e.g. communication interface errors).
  */
-class InternalErrorReporter: public SystemObject,
-		public ExecutableObjectIF,
-		public InternalErrorReporterIF,
-		public HasLocalDataPoolIF {
+class InternalErrorReporter:
+        public SystemObject,
+        public ExecutableObjectIF,
+        public InternalErrorReporterIF,
+        public HasLocalDataPoolIF {
 public:
 
-	InternalErrorReporter(object_id_t setObjectId,
-	        uint32_t messageQueueDepth = 5);
+    InternalErrorReporter(object_id_t setObjectId,
+            uint32_t messageQueueDepth = 5);
 
-	/**
-	 * Enable diagnostic printout. Please note that this feature will
-	 * only work if DEBUG has been supplied to the build defines.
-	 * @param enable
-	 */
-	void setDiagnosticPrintout(bool enable);
+    /**
+     * Enable diagnostic printout. Please note that this feature will
+     * only work if DEBUG has been supplied to the build defines.
+     * @param enable
+     */
+    void setDiagnosticPrintout(bool enable);
 
-	void setMutexTimeout(MutexIF::TimeoutType timeoutType,
-			uint32_t timeoutMs);
+    void setMutexTimeout(MutexIF::TimeoutType timeoutType,
+            uint32_t timeoutMs);
 
-	virtual ~InternalErrorReporter();
+    virtual ~InternalErrorReporter();
 
     virtual object_id_t getObjectId() const override;
     virtual MessageQueueId_t getCommandQueue() const override;
     virtual ReturnValue_t initializeLocalDataPool(
-    		localpool::DataPool& localDataPoolMap,
+            localpool::DataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
-	LocalDataPoolManager* getHkManagerHandle() override;
+    LocalDataPoolManager* getHkManagerHandle() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+    virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
-	virtual void queueMessageNotSent();
+    virtual void queueMessageNotSent();
 
-	virtual void lostTm();
+    virtual void lostTm();
 
-	virtual void storeFull();
+    virtual void storeFull();
 
-	virtual void setTaskIF(PeriodicTaskIF* task) override;
+    virtual void setTaskIF(PeriodicTaskIF* task) override;
 protected:
-	MessageQueueIF* commandQueue;
-	LocalDataPoolManager poolManager;
+    MessageQueueIF* commandQueue;
+    LocalDataPoolManager poolManager;
 
-	PeriodicTaskIF* executingTask = nullptr;
+    PeriodicTaskIF* executingTask = nullptr;
 
-	MutexIF* mutex = nullptr;
-	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-	uint32_t timeoutMs = 20;
+    MutexIF* mutex = nullptr;
+    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+    uint32_t timeoutMs = 20;
 
-	sid_t internalErrorSid;
-	InternalErrorDataset internalErrorDataset;
+    sid_t internalErrorSid;
+    InternalErrorDataset internalErrorDataset;
 
-	bool diagnosticPrintout = true;
+    bool diagnosticPrintout = true;
 
-	uint32_t queueHits = 0;
-	uint32_t tmHits = 0;
-	uint32_t storeHits = 0;
+    uint32_t queueHits = 0;
+    uint32_t tmHits = 0;
+    uint32_t storeHits = 0;
 
-	uint32_t getAndResetQueueHits();
-	uint32_t getQueueHits();
-	void incrementQueueHits();
+    uint32_t getAndResetQueueHits();
+    uint32_t getQueueHits();
+    void incrementQueueHits();
 
-	uint32_t getAndResetTmHits();
-	uint32_t getTmHits();
-	void incrementTmHits();
+    uint32_t getAndResetTmHits();
+    uint32_t getTmHits();
+    void incrementTmHits();
 
-	uint32_t getAndResetStoreHits();
-	uint32_t getStoreHits();
-	void incrementStoreHits();
+    uint32_t getAndResetStoreHits();
+    uint32_t getStoreHits();
+    void incrementStoreHits();
 
 };
 

From a4ca61d8343dcc64fc4667d2ac3ad74045825059 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 18 Mar 2021 00:01:29 +0100
Subject: [PATCH 1710/1774] bugfix and printout improvement

---
 datapool/PoolDataSetBase.cpp            | 8 ++++----
 internalError/InternalErrorReporter.cpp | 1 -
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index bdca22c3d..cd4eb4265 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -61,11 +61,11 @@ ReturnValue_t PoolDataSetBase::read(MutexIF::TimeoutType timeoutType,
     }
     else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "DataSet::read(): Call made in wrong position. Don't forget to commit"
-                " member datasets!" << std::endl;
+        sif::warning << "PoolDataSetBase::read: Call made in wrong position. Don't forget to "
+                "commit member datasets!" << std::endl;
 #else
-        sif::printError("DataSet::read(): Call made in wrong position. Don't forget to commit"
-                " member datasets!\n");
+        sif::printWarning("PoolDataSetBase::read: Call made in wrong position. Don't forget to "
+                "commit member datasets!\n");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         result = SET_WAS_ALREADY_READ;
     }
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 402071b2a..af9acc0d0 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -54,7 +54,6 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 #endif
 
     PoolReadGuard readGuard(&internalErrorDataset);
-    internalErrorDataset.read(timeoutType, timeoutMs);
     if(readGuard.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
         internalErrorDataset.queueHits.value += newQueueHits;
         internalErrorDataset.storeHits.value += newStoreHits;

From aa849894c65309a269475dca704b6bddb07702b7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 18 Mar 2021 20:09:19 +0100
Subject: [PATCH 1711/1774] tiny form improvement

---
 datapoollocal/LocalPoolDataSetBase.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 7f181c930..a72e9db11 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -58,8 +58,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registere
     this->sid = sid;
 }
 
-LocalPoolDataSetBase::LocalPoolDataSetBase(
-        PoolVariableIF **registeredVariablesArray,
+LocalPoolDataSetBase::LocalPoolDataSetBase(PoolVariableIF **registeredVariablesArray,
         const size_t maxNumberOfVariables, bool protectEveryReadCommitCall):
 		        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
     this->setReadCommitProtectionBehaviour(protectEveryReadCommitCall);

From fe2b3a01cf73b2dec12699365a4e5bb9acb689c2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 20 Mar 2021 12:38:51 +0100
Subject: [PATCH 1712/1774] important bugfix

---
 osal/windows/TmTcWinUdpBridge.cpp | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index fd289ed8d..8755c84a2 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -58,6 +58,9 @@ ReturnValue_t TmTcWinUdpBridge::initialize() {
     hints.ai_family = AF_INET;
     hints.ai_socktype = SOCK_DGRAM;
     hints.ai_protocol = IPPROTO_UDP;
+    /* See:
+    https://docs.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo
+    for information about AI_PASSIVE. */
     hints.ai_flags = AI_PASSIVE;
 
     /* Set up UDP socket:
@@ -151,11 +154,9 @@ void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
 #endif
     registerCommConnect();
 
-    /* Set new IP address if it has changed. */
-    if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
-        clientAddress = newAddress;
-        clientAddressLen = sizeof(clientAddress);
-    }
+    /* Set new IP address to reply to */
+    clientAddress = newAddress;
+    clientAddressLen = sizeof(clientAddress);
 }
 
 void TmTcWinUdpBridge::setMutexProperties(MutexIF::TimeoutType timeoutType,

From e44f8bfea38f5e876328af9d26806dc4d94bf8e8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 20 Mar 2021 12:40:25 +0100
Subject: [PATCH 1713/1774] important bugfixes

---
 osal/linux/TmTcUnixUdpBridge.cpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 2f620849b..fa7913ea6 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -150,11 +150,9 @@ void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
 #endif
     registerCommConnect();
 
-    /* Set new IP address if it has changed. */
-    if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
-        clientAddress = newAddress;
-        clientAddressLen = sizeof(clientAddress);
-    }
+    /* Set new IP address to reply to. */
+    clientAddress = newAddress;
+    clientAddressLen = sizeof(clientAddress);
 }
 
 void TmTcUnixUdpBridge::setMutexProperties(MutexIF::TimeoutType timeoutType,

From 0da95b75a230e5e12dd0bb15f6ba8e4813f9f143 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 20 Mar 2021 12:49:15 +0100
Subject: [PATCH 1714/1774] fixed for hosted OSAL

---
 osal/host/MessageQueue.cpp        | 8 +++-----
 osal/host/QueueMapManager.cpp     | 4 ++--
 osal/windows/TmTcWinUdpBridge.cpp | 3 ++-
 3 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index dfc045e8d..18272a68a 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -3,7 +3,7 @@
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../ipc/MutexFactory.h"
-#include "../../ipc/MutexHelper.h"
+#include "../../ipc/MutexGuard.h"
 
 MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		messageSize(maxMessageSize), messageDepth(messageDepth) {
@@ -63,9 +63,7 @@ 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);
+	MutexGuard mutexLock(queueLock, MutexIF::TimeoutType::WAITING, 20);
 	MessageQueueMessage* currentMessage = &messageQueue.front();
 	std::copy(currentMessage->getBuffer(),
 			currentMessage->getBuffer() + messageSize, message->getBuffer());
@@ -130,7 +128,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
-		MutexHelper mutexLock(targetQueue->queueLock,
+		MutexGuard mutexLock(targetQueue->queueLock,
 		        MutexIF::TimeoutType::WAITING, 20);
 		// not ideal, works for now though.
 		MessageQueueMessage* mqmMessage =
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 2a54f8134..b50d62dcf 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -2,7 +2,7 @@
 
 #include "../../serviceinterface/ServiceInterface.h"
 #include "../../ipc/MutexFactory.h"
-#include "../../ipc/MutexHelper.h"
+#include "../../ipc/MutexGuard.h"
 
 QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
 
@@ -43,7 +43,7 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 
 MessageQueueIF* QueueMapManager::getMessageQueue(
 		MessageQueueId_t messageQueueId) const {
-	MutexHelper(mapLock, MutexIF::TimeoutType::WAITING, 50);
+	MutexGuard(mapLock, MutexIF::TimeoutType::WAITING, 50);
 	auto queueIter = queueMap.find(messageQueueId);
 	if(queueIter != queueMap.end()) {
 		return queueIter->second;
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 94805cdca..9e91db2ba 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -1,5 +1,6 @@
-#include <fsfw/ipc/MutexHelper.h>
 #include "TmTcWinUdpBridge.h"
+#include <fsfw/ipc/MutexGuard.h>
+
 
 TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
         object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,

From 8f17d6623af0a2d6448c8255c471820d2836a894 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 20 Mar 2021 12:54:05 +0100
Subject: [PATCH 1715/1774] removed duplicate include

---
 osal/windows/TmTcWinUdpBridge.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 67e908a08..a7201bb03 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -1,7 +1,6 @@
 #include "TmTcWinUdpBridge.h"
 #include "tcpipHelpers.h"
 
-#include <fsfw/ipc/MutexGuard.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/ipc/MutexGuard.h>
 

From 951eb40e96c933d3524114037113f68c455b5200 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 20 Mar 2021 13:14:30 +0100
Subject: [PATCH 1716/1774] relativ include

---
 osal/windows/TmTcWinUdpBridge.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 4959705a6..03ca52cdd 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -1,8 +1,8 @@
 #include "TmTcWinUdpBridge.h"
 #include "tcpipHelpers.h"
 
-#include <fsfw/serviceinterface/ServiceInterface.h>
-#include <fsfw/ipc/MutexGuard.h>
+#include "../../ipc/MutexGuard.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 #include <ws2tcpip.h>
 

From d625642abcc481b73c06a42c0b87fa614d36294b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 21 Mar 2021 00:30:33 +0100
Subject: [PATCH 1717/1774] created common OSAL stuff to unify UDP code

---
 osal/common/CMakeLists.txt                    | 19 +++++--
 osal/common/TcpIpBase.cpp                     | 52 +++++++++++++++++++
 osal/common/TcpIpBase.h                       | 49 +++++++++++++++++
 .../TcpTmTcServer.cpp}                        | 42 +++++++--------
 .../TcpTmTcServer.h}                          | 10 ++--
 .../UdpTcPollingTask.cpp}                     | 41 +++++++++------
 .../UdpTcPollingTask.h}                       | 12 +++--
 .../UdpTmTcBridge.cpp}                        | 50 +++++++++++-------
 .../UdpTmTcBridge.h}                          | 13 ++---
 osal/common/tcpipCommon.h                     |  3 +-
 osal/{windows => common}/tcpipHelpers.h       |  2 +-
 osal/windows/CMakeLists.txt                   |  8 ---
 osal/windows/tcpipHelpers.cpp                 |  2 +-
 13 files changed, 214 insertions(+), 89 deletions(-)
 create mode 100644 osal/common/TcpIpBase.cpp
 create mode 100644 osal/common/TcpIpBase.h
 rename osal/{windows/TcWinTcpServer.cpp => common/TcpTmTcServer.cpp} (73%)
 rename osal/{windows/TcWinTcpServer.h => common/TcpTmTcServer.h} (84%)
 rename osal/{windows/TcWinUdpPollingTask.cpp => common/UdpTcPollingTask.cpp} (75%)
 rename osal/{windows/TcWinUdpPollingTask.h => common/UdpTcPollingTask.h} (88%)
 rename osal/{windows/TmTcWinUdpBridge.cpp => common/UdpTmTcBridge.cpp} (77%)
 rename osal/{windows/TmTcWinUdpBridge.h => common/UdpTmTcBridge.h} (82%)
 rename osal/{windows => common}/tcpipHelpers.h (89%)

diff --git a/osal/common/CMakeLists.txt b/osal/common/CMakeLists.txt
index b77985fbd..af76484d3 100644
--- a/osal/common/CMakeLists.txt
+++ b/osal/common/CMakeLists.txt
@@ -1,3 +1,16 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
-    tcpipCommon.cpp
-)
+if(DEFINED WIN32 OR DEFINED UNIX)
+    target_sources(${LIB_FSFW_NAME} PRIVATE 
+        tcpipCommon.cpp
+        TcpIpBase.cpp
+        UdpTcPollingTask.cpp
+        UdpTmTcBridge.cpp
+        TcpTmTcServer.cpp
+    )
+endif()
+
+if(WIN32)
+    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+        wsock32 
+        ws2_32
+    )
+endif()
\ No newline at end of file
diff --git a/osal/common/TcpIpBase.cpp b/osal/common/TcpIpBase.cpp
new file mode 100644
index 000000000..03de81b17
--- /dev/null
+++ b/osal/common/TcpIpBase.cpp
@@ -0,0 +1,52 @@
+#include "TcpIpBase.h"
+
+#ifdef __unix__
+
+#include <unistd.h>
+
+#endif
+
+TcpIpBase::TcpIpBase() {
+    closeSocket(serverSocket);
+}
+
+TcpIpBase::~TcpIpBase() {
+#ifdef _WIN32
+    WSACleanup();
+#endif
+}
+
+
+int TcpIpBase::closeSocket(socket_t socket) {
+#ifdef _WIN32
+    return closesocket(socket);
+#elif defined(__unix__)
+    return close(socket)
+#endif
+}
+
+int TcpIpBase::getLastSocketError() {
+#ifdef _WIN32
+    return WSAGetLastError();
+#elif defined(__unix__)
+    return errno;
+#endif
+}
+
+ReturnValue_t TcpIpBase::initialize() {
+#ifdef _WIN32
+    /* Initiates Winsock DLL. */
+    WSAData wsaData;
+    WORD wVersionRequested = MAKEWORD(2, 2);
+    int err = WSAStartup(wVersionRequested, &wsaData);
+    if (err != 0) {
+        /* Tell the user that we could not find a usable Winsock DLL. */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: WSAStartup failed with error: " <<
+                err << std::endl;
+#endif
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+#endif
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/common/TcpIpBase.h b/osal/common/TcpIpBase.h
new file mode 100644
index 000000000..8da217bc3
--- /dev/null
+++ b/osal/common/TcpIpBase.h
@@ -0,0 +1,49 @@
+#ifndef FSFW_OSAL_COMMON_TCPIPIF_H_
+#define FSFW_OSAL_COMMON_TCPIPIF_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#ifdef _WIN32
+
+#include <winsock2.h>
+
+#elif defined(__unix__)
+
+
+#endif
+
+class TcpIpBase {
+protected:
+
+#ifdef _WIN32
+    static constexpr int SHUT_RECV = SD_RECEIVE;
+    static constexpr int SHUT_SEND = SD_SEND;
+    static constexpr int SHUT_BOTH = SD_BOTH;
+
+    using socket_t = SOCKET;
+#elif defined(__unix__)
+    using socket_t = int;
+
+    static constexpr int INVALID_SOCKET = -1;
+    static constexpr int SOCKET_ERROR = -1;
+
+    static constexpr int SHUT_RECV = SHUT_RD;
+    static constexpr int SHUT_SEND = SHUT_WR;
+    static constexpr int SHUT_BOTH = SHUT_RDWR;
+#endif
+
+    TcpIpBase();
+    virtual ~TcpIpBase();
+
+    ReturnValue_t initialize();
+
+    int closeSocket(socket_t socket);
+
+    int getLastSocketError();
+
+    socket_t serverSocket = 0;
+
+};
+
+
+#endif /* FSFW_OSAL_COMMON_TCPIPIF_H_ */
diff --git a/osal/windows/TcWinTcpServer.cpp b/osal/common/TcpTmTcServer.cpp
similarity index 73%
rename from osal/windows/TcWinTcpServer.cpp
rename to osal/common/TcpTmTcServer.cpp
index f68edfba6..320b937d5 100644
--- a/osal/windows/TcWinTcpServer.cpp
+++ b/osal/common/TcpTmTcServer.cpp
@@ -1,14 +1,16 @@
-#include "TcWinTcpServer.h"
+#include "TcpTmTcServer.h"
 #include "tcpipHelpers.h"
 #include "../../serviceinterface/ServiceInterface.h"
 
+#ifdef _WIN32
 #include <winsock2.h>
 #include <ws2tcpip.h>
+#endif
 
-const std::string TcWinTcpServer::DEFAULT_TCP_SERVER_PORT =  "7301";
-const std::string TcWinTcpServer::DEFAULT_TCP_CLIENT_PORT =  "7302";
+const std::string TcpTmTcServer::DEFAULT_TCP_SERVER_PORT =  "7301";
+const std::string TcpTmTcServer::DEFAULT_TCP_CLIENT_PORT =  "7302";
 
-TcWinTcpServer::TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+TcpTmTcServer::TcpTmTcServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
         std::string customTcpServerPort):
         SystemObject(objectId), tcpPort(customTcpServerPort) {
     if(tcpPort == "") {
@@ -16,23 +18,17 @@ TcWinTcpServer::TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBrid
     }
 }
 
-ReturnValue_t TcWinTcpServer::initialize() {
+ReturnValue_t TcpTmTcServer::initialize() {
     using namespace tcpip;
+
+    ReturnValue_t result = TcpIpBase::initialize();
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
     int retval = 0;
     struct addrinfo *addrResult = nullptr;
-    struct addrinfo hints;
-    /* Initiates Winsock DLL. */
-    WSAData wsaData;
-    WORD wVersionRequested = MAKEWORD(2, 2);
-    int err = WSAStartup(wVersionRequested, &wsaData);
-    if (err != 0) {
-        /* Tell the user that we could not find a usable Winsock DLL. */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: WSAStartup failed with error: " <<
-                err << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+    struct addrinfo hints = { 0 };
 
     ZeroMemory(&hints, sizeof (hints));
     hints.ai_family = AF_INET;
@@ -43,7 +39,7 @@ ReturnValue_t TcWinTcpServer::initialize() {
     retval = getaddrinfo(nullptr, tcpPort.c_str(), &hints, &addrResult);
     if (retval != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TcWinTcpServer::TcWinTcpServer: Retrieving address info failed!" <<
+        sif::warning << "TcWinTcpServer::TcpTmTcServer: Retrieving address info failed!" <<
                 std::endl;
 #endif
         handleError(Protocol::TCP, ErrorSources::GETADDRINFO_CALL);
@@ -65,7 +61,7 @@ ReturnValue_t TcWinTcpServer::initialize() {
     retval = bind(listenerTcpSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
     if(retval == SOCKET_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TcWinTcpServer::TcWinTcpServer: Binding socket failed!" <<
+        sif::warning << "TcWinTcpServer::TcpTmTcServer: Binding socket failed!" <<
                 std::endl;
 #endif
         freeaddrinfo(addrResult);
@@ -77,12 +73,12 @@ ReturnValue_t TcWinTcpServer::initialize() {
 }
 
 
-TcWinTcpServer::~TcWinTcpServer() {
+TcpTmTcServer::~TcpTmTcServer() {
     closesocket(listenerTcpSocket);
     WSACleanup();
 }
 
-ReturnValue_t TcWinTcpServer::performOperation(uint8_t opCode) {
+ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
     using namespace tcpip;
     /* If a connection is accepted, the corresponding socket will be assigned to the new socket */
     SOCKET clientSocket;
@@ -110,7 +106,7 @@ ReturnValue_t TcWinTcpServer::performOperation(uint8_t opCode) {
                 receptionBuffer.size(), 0);
         if(retval > 0) {
 #if FSFW_TCP_RCV_WIRETAPPING_ENABLED == 1
-            sif::info << "TcWinTcpServer::performOperation: Received " << retval << " bytes."
+            sif::info << "TcpTmTcServer::performOperation: Received " << retval << " bytes."
                     std::endl;
 #endif
             handleError(Protocol::TCP, ErrorSources::RECV_CALL, 500);
diff --git a/osal/windows/TcWinTcpServer.h b/osal/common/TcpTmTcServer.h
similarity index 84%
rename from osal/windows/TcWinTcpServer.h
rename to osal/common/TcpTmTcServer.h
index bd9f35765..ff6eb6108 100644
--- a/osal/windows/TcWinTcpServer.h
+++ b/osal/common/TcpTmTcServer.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_
 #define FSFW_OSAL_WINDOWS_TCWINTCPSERVER_H_
 
+#include "TcpIpBase.h"
 #include "../../objectmanager/SystemObject.h"
 #include "../../tasks/ExecutableObjectIF.h"
 
@@ -15,17 +16,18 @@
  * @details
  * Based on: https://docs.microsoft.com/en-us/windows/win32/winsock/complete-server-code
  */
-class TcWinTcpServer:
+class TcpTmTcServer:
         public SystemObject,
+        public TcpIpBase,
         public ExecutableObjectIF {
 public:
     /* The ports chosen here should not be used by any other process. */
     static const std::string DEFAULT_TCP_SERVER_PORT;
     static const std::string DEFAULT_TCP_CLIENT_PORT;
 
-    TcWinTcpServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+    TcpTmTcServer(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
             std::string customTcpServerPort = "");
-    virtual~ TcWinTcpServer();
+    virtual~ TcpTmTcServer();
 
     ReturnValue_t initialize() override;
     ReturnValue_t performOperation(uint8_t opCode) override;
@@ -33,7 +35,7 @@ public:
 private:
 
     std::string tcpPort;
-    SOCKET listenerTcpSocket = 0;
+    socket_t listenerTcpSocket = 0;
     struct sockaddr_in tcpAddress;
     int tcpAddrLen = sizeof(tcpAddress);
     int currentBacklog = 3;
diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/common/UdpTcPollingTask.cpp
similarity index 75%
rename from osal/windows/TcWinUdpPollingTask.cpp
rename to osal/common/UdpTcPollingTask.cpp
index 980404f9d..506f1c984 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/common/UdpTcPollingTask.cpp
@@ -1,4 +1,4 @@
-#include "TcWinUdpPollingTask.h"
+#include "UdpTcPollingTask.h"
 #include "tcpipHelpers.h"
 #include "../../globalfunctions/arrayprinter.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
@@ -8,7 +8,7 @@
 //! Debugging preprocessor define.
 #define FSFW_UDP_RCV_WIRETAPPING_ENABLED    0
 
-TcWinUdpPollingTask::TcWinUdpPollingTask(object_id_t objectId,
+UdpTcPollingTask::UdpTcPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,
 		double timeoutSeconds): SystemObject(objectId),
 		tmtcBridgeId(tmtcUnixUdpBridge) {
@@ -32,9 +32,9 @@ TcWinUdpPollingTask::TcWinUdpPollingTask(object_id_t objectId,
 	}
 }
 
-TcWinUdpPollingTask::~TcWinUdpPollingTask() {}
+UdpTcPollingTask::~UdpTcPollingTask() {}
 
-ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
+ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
     /* Sender Address is cached here. */
     struct sockaddr_in senderAddress;
     int senderAddressSize = sizeof(senderAddress);
@@ -52,13 +52,13 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 		if(bytesReceived == SOCKET_ERROR) {
 			/* Handle error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "TcWinUdpPollingTask::performOperation: Reception error." << std::endl;
+			sif::error << "UdpTcPollingTask::performOperation: Reception error." << std::endl;
 #endif
 			tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::RECVFROM_CALL, 1000);
 			continue;
 		}
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
-		sif::debug << "TcWinUdpPollingTask::performOperation: " << bytesReceived <<
+		sif::debug << "UdpTcPollingTask::performOperation: " << bytesReceived <<
 		        " bytes received" << std::endl;
 #endif
 
@@ -72,7 +72,7 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 }
 
 
-ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
+ReturnValue_t UdpTcPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 	store_address_t storeId;
 
 #if FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
@@ -83,7 +83,7 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning<< "TcWinUdpPollingTask::transferPusToSoftwareBus: Data storage failed." <<
+		sif::warning<< "UdpTcPollingTask::transferPusToSoftwareBus: Data storage failed." <<
 		        std::endl;
 		sif::warning << "Packet size: " << bytesRead << std::endl;
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
@@ -97,7 +97,7 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "TcWinUdpPollingTask::handleSuccessfullTcRead: "
+		sif::warning << "UdpTcPollingTask::handleSuccessfullTcRead: "
 		        " Sending message to queue failed" << std::endl;
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
@@ -106,37 +106,44 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 	return result;
 }
 
-ReturnValue_t TcWinUdpPollingTask::initialize() {
+ReturnValue_t UdpTcPollingTask::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcWinUdpPollingTask::initialize: TC store uninitialized!" << std::endl;
+		sif::error << "UdpTcPollingTask::initialize: TC store uninitialized!" << std::endl;
 #endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
-	tmtcBridge = objectManager->get<TmTcWinUdpBridge>(tmtcBridgeId);
+	tmtcBridge = objectManager->get<UdpTmTcBridge>(tmtcBridgeId);
 	if(tmtcBridge == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcWinUdpPollingTask::initialize: Invalid TMTC bridge object!" <<
+		sif::error << "UdpTcPollingTask::initialize: Invalid TMTC bridge object!" <<
 		        std::endl;
 #endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
+
+    ReturnValue_t result = TcpIpBase::initialize();
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t TcWinUdpPollingTask::initializeAfterTaskCreation() {
+ReturnValue_t UdpTcPollingTask::initializeAfterTaskCreation() {
 	/* Initialize the destination after task creation. This ensures
 	that the destination has already been set in the TMTC bridge. */
 	targetTcDestination = tmtcBridge->getRequestQueue();
 	/* The server socket is set up in the bridge intialization. Calling this function here
-	ensures that it is set up properly in any case*/
+	ensures that it is set up regardless of which class was initialized first */
     serverUdpSocket = tmtcBridge->serverSocket;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
+void UdpTcPollingTask::setTimeout(double timeoutSeconds) {
+#ifdef _WIN32
 	DWORD timeoutMs = timeoutSeconds * 1000.0;
 	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
 			reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
@@ -146,4 +153,6 @@ void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
 				"receive timeout failed with " << strerror(errno) << std::endl;
 #endif
 	}
+#elif defined(__unix__)
+#endif
 }
diff --git a/osal/windows/TcWinUdpPollingTask.h b/osal/common/UdpTcPollingTask.h
similarity index 88%
rename from osal/windows/TcWinUdpPollingTask.h
rename to osal/common/UdpTcPollingTask.h
index 35e3a701e..6b11cc5a9 100644
--- a/osal/windows/TcWinUdpPollingTask.h
+++ b/osal/common/UdpTcPollingTask.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_OSAL_WINDOWS_TCSOCKETPOLLINGTASK_H_
 #define FSFW_OSAL_WINDOWS_TCSOCKETPOLLINGTASK_H_
 
-#include "TmTcWinUdpBridge.h"
+#include "UdpTmTcBridge.h"
 #include "../../objectmanager/SystemObject.h"
 #include "../../tasks/ExecutableObjectIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
@@ -17,7 +17,9 @@
  * This class caches the IP address of the sender. It is assumed there
  * is only one sender for now.
  */
-class TcWinUdpPollingTask: public SystemObject,
+class UdpTcPollingTask:
+        public TcpIpBase,
+        public SystemObject,
 		public ExecutableObjectIF {
 	friend class TmTcWinUdpBridge;
 public:
@@ -25,9 +27,9 @@ public:
 	//! 0.5  default milliseconds timeout for now.
 	static constexpr timeval DEFAULT_TIMEOUT = {0, 500};
 
-	TcWinUdpPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+	UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
 			size_t frameSize = 0, double timeoutSeconds = -1);
-	virtual~ TcWinUdpPollingTask();
+	virtual~ UdpTcPollingTask();
 
 	/**
 	 * Turn on optional timeout for UDP polling. In the default mode,
@@ -46,7 +48,7 @@ protected:
 private:
 	//! TMTC bridge is cached.
 	object_id_t tmtcBridgeId = objects::NO_OBJECT;
-	TmTcWinUdpBridge* tmtcBridge = nullptr;
+	UdpTmTcBridge* tmtcBridge = nullptr;
 	MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;
 
 	//! See: https://docs.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/common/UdpTmTcBridge.cpp
similarity index 77%
rename from osal/windows/TmTcWinUdpBridge.cpp
rename to osal/common/UdpTmTcBridge.cpp
index 8755c84a2..be5867458 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/common/UdpTmTcBridge.cpp
@@ -1,16 +1,24 @@
-#include "TmTcWinUdpBridge.h"
 #include "tcpipHelpers.h"
 
 #include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/ipc/MutexGuard.h>
+#include <fsfw/osal/common/UdpTmTcBridge.h>
+
+#ifdef _WIN32
 #include <ws2tcpip.h>
 
+#elif defined(__unix__)
+
+#include <arap/inet.h>
+
+#endif
+
 //! Debugging preprocessor define.
 #define FSFW_UDP_SEND_WIRETAPPING_ENABLED    0
 
-const std::string TmTcWinUdpBridge::DEFAULT_UDP_SERVER_PORT =  tcpip::DEFAULT_UDP_SERVER_PORT;
+const std::string UdpTmTcBridge::DEFAULT_UDP_SERVER_PORT =  tcpip::DEFAULT_SERVER_PORT;
 
-TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId, object_id_t tcDestination,
+UdpTmTcBridge::UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
         object_id_t tmStoreId, object_id_t tcStoreId, std::string udpServerPort):
         TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
     if(udpServerPort == "") {
@@ -24,16 +32,18 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId, object_id_t tcDestinati
     communicationLinkUp = false;
 }
 
-ReturnValue_t TmTcWinUdpBridge::initialize() {
+ReturnValue_t UdpTmTcBridge::initialize() {
     ReturnValue_t result = TmTcBridge::initialize();
     if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcWinUdpBridge::initialize: TmTcBridge initialization failed!"
+        sif::error << "TmTcUdpBridge::initialize: TmTcBridge initialization failed!"
                 << std::endl;
 #endif
         return result;
     }
 
+
+#ifdef _WIN32
     /* Initiates Winsock DLL. */
     WSAData wsaData;
     WORD wVersionRequested = MAKEWORD(2, 2);
@@ -42,26 +52,28 @@ ReturnValue_t TmTcWinUdpBridge::initialize() {
         /* Tell the user that we could not find a usable */
         /* Winsock DLL.                                  */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: WSAStartup failed with error: " <<
+        sif::error << "TmTcUdpBridge::TmTcUdpBridge: WSAStartup failed with error: " <<
                 err << std::endl;
 #else
-        sif::printError("TmTcWinUdpBridge::TmTcWinUdpBridge: WSAStartup failed with error: %d\n",
+        sif::printError("TmTcUdpBridge::TmTcUdpBridge: WSAStartup failed with error: %d\n",
                 err);
 #endif
         return HasReturnvaluesIF::RETURN_FAILED;
     }
+#endif
 
     struct addrinfo *addrResult = nullptr;
-    struct addrinfo hints;
+    struct addrinfo hints = { 0 };
 
-    ZeroMemory(&hints, sizeof (hints));
     hints.ai_family = AF_INET;
     hints.ai_socktype = SOCK_DGRAM;
     hints.ai_protocol = IPPROTO_UDP;
+#ifdef _WIN32
     /* See:
     https://docs.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo
     for information about AI_PASSIVE. */
     hints.ai_flags = AI_PASSIVE;
+#endif
 
     /* Set up UDP socket:
     https://en.wikipedia.org/wiki/Getaddrinfo
@@ -70,7 +82,7 @@ ReturnValue_t TmTcWinUdpBridge::initialize() {
     int retval = getaddrinfo(nullptr, udpServerPort.c_str(), &hints, &addrResult);
     if (retval != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Retrieving address info failed!" <<
+        sif::warning << "TmTcUdpBridge::TmTcUdpBridge: Retrieving address info failed!" <<
                 std::endl;
 #endif
         return HasReturnvaluesIF::RETURN_FAILED;
@@ -79,7 +91,7 @@ ReturnValue_t TmTcWinUdpBridge::initialize() {
     serverSocket = socket(addrResult->ai_family, addrResult->ai_socktype, addrResult->ai_protocol);
     if(serverSocket == INVALID_SOCKET) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open UDP socket!" <<
+        sif::warning << "TmTcUdpBridge::TmTcUdpBridge: Could not open UDP socket!" <<
                 std::endl;
 #endif
         freeaddrinfo(addrResult);
@@ -90,7 +102,7 @@ ReturnValue_t TmTcWinUdpBridge::initialize() {
     retval = bind(serverSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
     if(retval != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
+        sif::error << "TmTcUdpBridge::TmTcUdpBridge: Could not bind "
                 "local port (" << udpServerPort << ") to server socket!" << std::endl;
 #endif
         freeaddrinfo(addrResult);
@@ -100,15 +112,13 @@ ReturnValue_t TmTcWinUdpBridge::initialize() {
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-TmTcWinUdpBridge::~TmTcWinUdpBridge() {
+UdpTmTcBridge::~UdpTmTcBridge() {
     if(mutex != nullptr) {
         MutexFactory::instance()->deleteMutex(mutex);
     }
-    closesocket(serverSocket);
-    WSACleanup();
 }
 
-ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
     int flags = 0;
 
     /* The target address can be set by different threads so this lock ensures thread-safety */
@@ -130,18 +140,18 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
     );
     if(bytesSent == SOCKET_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TmTcWinUdpBridge::sendTm: Send operation failed." << std::endl;
+        sif::warning << "TmTcUdpBridge::sendTm: Send operation failed." << std::endl;
 #endif
         tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
     }
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-    sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+    sif::debug << "TmTcUdpBridge::sendTm: " << bytesSent << " bytes were"
             " sent." << std::endl;
 #endif
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
+void UdpTmTcBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
     /* The target address can be set by different threads so this lock ensures thread-safety */
     MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
 
@@ -159,7 +169,7 @@ void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
     clientAddressLen = sizeof(clientAddress);
 }
 
-void TmTcWinUdpBridge::setMutexProperties(MutexIF::TimeoutType timeoutType,
+void UdpTmTcBridge::setMutexProperties(MutexIF::TimeoutType timeoutType,
         dur_millis_t timeoutMs) {
     this->timeoutType = timeoutType;
     this->mutexTimeoutMs = timeoutMs;
diff --git a/osal/windows/TmTcWinUdpBridge.h b/osal/common/UdpTmTcBridge.h
similarity index 82%
rename from osal/windows/TmTcWinUdpBridge.h
rename to osal/common/UdpTmTcBridge.h
index c2f7d6aaa..fcf2baec7 100644
--- a/osal/windows/TmTcWinUdpBridge.h
+++ b/osal/common/UdpTmTcBridge.h
@@ -1,20 +1,22 @@
 #ifndef FSFW_OSAL_WINDOWS_TMTCWINUDPBRIDGE_H_
 #define FSFW_OSAL_WINDOWS_TMTCWINUDPBRIDGE_H_
 
+#include "TcpIpBase.h"
 #include "../../tmtcservices/TmTcBridge.h"
 
 #include <string>
-#include <winsock2.h>
 
-class TmTcWinUdpBridge: public TmTcBridge {
-    friend class TcWinUdpPollingTask;
+class UdpTmTcBridge:
+        public TmTcBridge,
+        public TcpIpBase {
+    friend class UdpTcPollingTask;
 public:
     /* The ports chosen here should not be used by any other process. */
     static const std::string DEFAULT_UDP_SERVER_PORT;
 
-    TmTcWinUdpBridge(object_id_t objectId, object_id_t tcDestination,
+    UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
             object_id_t tmStoreId, object_id_t tcStoreId, std::string udpServerPort = "");
-    virtual~ TmTcWinUdpBridge();
+    virtual~ UdpTmTcBridge();
 
     /**
      * Set properties of internal mutex.
@@ -29,7 +31,6 @@ protected:
     virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
 
 private:
-    SOCKET serverSocket = 0;
     std::string udpServerPort;
 
     struct sockaddr_in clientAddress;
diff --git a/osal/common/tcpipCommon.h b/osal/common/tcpipCommon.h
index 9b38c9fba..dc5ada526 100644
--- a/osal/common/tcpipCommon.h
+++ b/osal/common/tcpipCommon.h
@@ -6,8 +6,7 @@
 
 namespace tcpip {
 
-const char* const DEFAULT_UDP_SERVER_PORT = "7301";
-const char* const DEFAULT_TCP_SERVER_PORT = "7303";
+const char* const DEFAULT_SERVER_PORT = "7301";
 
 enum class Protocol {
     UDP,
diff --git a/osal/windows/tcpipHelpers.h b/osal/common/tcpipHelpers.h
similarity index 89%
rename from osal/windows/tcpipHelpers.h
rename to osal/common/tcpipHelpers.h
index 01f009b93..9764a93fe 100644
--- a/osal/windows/tcpipHelpers.h
+++ b/osal/common/tcpipHelpers.h
@@ -2,7 +2,7 @@
 #define FSFW_OSAL_WINDOWS_TCPIPHELPERS_H_
 
 #include "../../timemanager/clockDefinitions.h"
-#include "../common/tcpipCommon.h"
+#include "tcpipCommon.h"
 
 namespace tcpip {
 
diff --git a/osal/windows/CMakeLists.txt b/osal/windows/CMakeLists.txt
index a2b316880..1bb39b37f 100644
--- a/osal/windows/CMakeLists.txt
+++ b/osal/windows/CMakeLists.txt
@@ -1,11 +1,3 @@
 target_sources(${LIB_FSFW_NAME} PRIVATE 
-    TcWinUdpPollingTask.cpp
-    TmTcWinUdpBridge.cpp
-    TcWinTcpServer.cpp
     tcpipHelpers.cpp
 )
-
-target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-    wsock32 
-    ws2_32
-)
\ No newline at end of file
diff --git a/osal/windows/tcpipHelpers.cpp b/osal/windows/tcpipHelpers.cpp
index ef07f5ca8..03278a92e 100644
--- a/osal/windows/tcpipHelpers.cpp
+++ b/osal/windows/tcpipHelpers.cpp
@@ -1,4 +1,4 @@
-#include "tcpipHelpers.h"
+#include "../common/tcpipHelpers.h"
 #include <FSFWConfig.h>
 
 #include "../../tasks/TaskFactory.h"

From 86577f4b80aa8566a5212edd2712e804b279d638 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 21 Mar 2021 12:51:28 +0100
Subject: [PATCH 1718/1774] fixed for linux

---
 osal/common/TcpIpBase.cpp           |   3 +-
 osal/common/TcpIpBase.h             |   1 +
 osal/common/TcpTmTcServer.cpp       |  20 +-
 osal/common/TcpTmTcServer.h         |   6 +-
 osal/common/UdpTcPollingTask.cpp    |  19 +-
 osal/common/UdpTcPollingTask.h      |   4 -
 osal/common/UdpTmTcBridge.cpp       |   8 +-
 osal/common/UdpTmTcBridge.h         |  10 +-
 osal/linux/CMakeLists.txt           |   2 -
 osal/linux/TcUnixUdpPollingTask.cpp | 304 ++++++++++++-------------
 osal/linux/TcUnixUdpPollingTask.h   | 134 +++++------
 osal/linux/TmTcUnixUdpBridge.cpp    | 334 ++++++++++++++--------------
 osal/linux/TmTcUnixUdpBridge.h      | 106 ++++-----
 13 files changed, 484 insertions(+), 467 deletions(-)

diff --git a/osal/common/TcpIpBase.cpp b/osal/common/TcpIpBase.cpp
index 03de81b17..35524743d 100644
--- a/osal/common/TcpIpBase.cpp
+++ b/osal/common/TcpIpBase.cpp
@@ -2,6 +2,7 @@
 
 #ifdef __unix__
 
+#include <errno.h>
 #include <unistd.h>
 
 #endif
@@ -21,7 +22,7 @@ int TcpIpBase::closeSocket(socket_t socket) {
 #ifdef _WIN32
     return closesocket(socket);
 #elif defined(__unix__)
-    return close(socket)
+    return close(socket);
 #endif
 }
 
diff --git a/osal/common/TcpIpBase.h b/osal/common/TcpIpBase.h
index 8da217bc3..652d791a1 100644
--- a/osal/common/TcpIpBase.h
+++ b/osal/common/TcpIpBase.h
@@ -9,6 +9,7 @@
 
 #elif defined(__unix__)
 
+#include <sys/socket.h>
 
 #endif
 
diff --git a/osal/common/TcpTmTcServer.cpp b/osal/common/TcpTmTcServer.cpp
index 320b937d5..2da5da954 100644
--- a/osal/common/TcpTmTcServer.cpp
+++ b/osal/common/TcpTmTcServer.cpp
@@ -5,6 +5,11 @@
 #ifdef _WIN32
 #include <winsock2.h>
 #include <ws2tcpip.h>
+
+#elif defined(__unix__)
+
+#include <netdb.h>
+
 #endif
 
 const std::string TcpTmTcServer::DEFAULT_TCP_SERVER_PORT =  "7301";
@@ -30,7 +35,6 @@ ReturnValue_t TcpTmTcServer::initialize() {
     struct addrinfo *addrResult = nullptr;
     struct addrinfo hints = { 0 };
 
-    ZeroMemory(&hints, sizeof (hints));
     hints.ai_family = AF_INET;
     hints.ai_socktype = SOCK_STREAM;
     hints.ai_protocol = IPPROTO_TCP;
@@ -74,16 +78,15 @@ ReturnValue_t TcpTmTcServer::initialize() {
 
 
 TcpTmTcServer::~TcpTmTcServer() {
-    closesocket(listenerTcpSocket);
-    WSACleanup();
+    closeSocket(listenerTcpSocket);
 }
 
 ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
     using namespace tcpip;
     /* If a connection is accepted, the corresponding socket will be assigned to the new socket */
-    SOCKET clientSocket;
-    sockaddr_in clientSockAddr;
-    int connectorSockAddrLen = 0;
+    socket_t clientSocket;
+    sockaddr clientSockAddr;
+    socklen_t connectorSockAddrLen = 0;
     int retval = 0;
 
     /* Listen for connection requests permanently for lifetime of program */
@@ -94,8 +97,7 @@ ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
             continue;
         }
 
-        clientSocket = accept(listenerTcpSocket, reinterpret_cast<sockaddr*>(&clientSockAddr),
-                &connectorSockAddrLen);
+        clientSocket = accept(listenerTcpSocket, &clientSockAddr, &connectorSockAddrLen);
 
         if(clientSocket == INVALID_SOCKET) {
             handleError(Protocol::TCP, ErrorSources::ACCEPT_CALL, 500);
@@ -119,7 +121,7 @@ ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
         }
 
         /* Done, shut down connection */
-        retval = shutdown(clientSocket, SD_SEND);
+        retval = shutdown(clientSocket, SHUT_SEND);
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/common/TcpTmTcServer.h b/osal/common/TcpTmTcServer.h
index ff6eb6108..4dcc77a2d 100644
--- a/osal/common/TcpTmTcServer.h
+++ b/osal/common/TcpTmTcServer.h
@@ -5,6 +5,10 @@
 #include "../../objectmanager/SystemObject.h"
 #include "../../tasks/ExecutableObjectIF.h"
 
+#ifdef __unix__
+#include <sys/socket.h>
+#endif
+
 #include <string>
 #include <vector>
 
@@ -36,7 +40,7 @@ private:
 
     std::string tcpPort;
     socket_t listenerTcpSocket = 0;
-    struct sockaddr_in tcpAddress;
+    struct sockaddr tcpAddress;
     int tcpAddrLen = sizeof(tcpAddress);
     int currentBacklog = 3;
 
diff --git a/osal/common/UdpTcPollingTask.cpp b/osal/common/UdpTcPollingTask.cpp
index 506f1c984..3d51e1189 100644
--- a/osal/common/UdpTcPollingTask.cpp
+++ b/osal/common/UdpTcPollingTask.cpp
@@ -3,8 +3,17 @@
 #include "../../globalfunctions/arrayprinter.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
+#ifdef _WIN32
+
 #include <winsock2.h>
 
+#else
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#endif
+
 //! Debugging preprocessor define.
 #define FSFW_UDP_RCV_WIRETAPPING_ENABLED    0
 
@@ -36,17 +45,17 @@ UdpTcPollingTask::~UdpTcPollingTask() {}
 
 ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
     /* Sender Address is cached here. */
-    struct sockaddr_in senderAddress;
-    int senderAddressSize = sizeof(senderAddress);
+    struct sockaddr senderAddress;
+    socklen_t senderAddressSize = sizeof(senderAddress);
 
 	/* Poll for new UDP datagrams in permanent loop. */
 	while(true) {
 		int bytesReceived = recvfrom(
-		        serverUdpSocket,
+		        this->serverSocket,
 		        reinterpret_cast<char*>(receptionBuffer.data()),
 		        frameSize,
 				receptionFlags,
-				reinterpret_cast<sockaddr*>(&senderAddress),
+				&senderAddress,
 				&senderAddressSize
 		);
 		if(bytesReceived == SOCKET_ERROR) {
@@ -138,7 +147,7 @@ ReturnValue_t UdpTcPollingTask::initializeAfterTaskCreation() {
 	targetTcDestination = tmtcBridge->getRequestQueue();
 	/* The server socket is set up in the bridge intialization. Calling this function here
 	ensures that it is set up regardless of which class was initialized first */
-    serverUdpSocket = tmtcBridge->serverSocket;
+    this->serverSocket = tmtcBridge->serverSocket;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/common/UdpTcPollingTask.h b/osal/common/UdpTcPollingTask.h
index 6b11cc5a9..4df62b942 100644
--- a/osal/common/UdpTcPollingTask.h
+++ b/osal/common/UdpTcPollingTask.h
@@ -54,10 +54,6 @@ private:
 	//! See: https://docs.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom
 	int receptionFlags = 0;
 
-	//! Server socket, which is member of TMTC bridge.
-	//! Will be cached shortly after SW intialization.
-	SOCKET serverUdpSocket = 0;
-
 	std::vector<uint8_t> receptionBuffer;
 
 	size_t frameSize = 0;
diff --git a/osal/common/UdpTmTcBridge.cpp b/osal/common/UdpTmTcBridge.cpp
index be5867458..a8975c0e0 100644
--- a/osal/common/UdpTmTcBridge.cpp
+++ b/osal/common/UdpTmTcBridge.cpp
@@ -5,11 +5,13 @@
 #include <fsfw/osal/common/UdpTmTcBridge.h>
 
 #ifdef _WIN32
+
 #include <ws2tcpip.h>
 
 #elif defined(__unix__)
 
-#include <arap/inet.h>
+#include <netdb.h>
+#include <arpa/inet.h>
 
 #endif
 
@@ -135,7 +137,7 @@ ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
             reinterpret_cast<const char*>(data),
             dataLen,
             flags,
-            reinterpret_cast<sockaddr*>(&clientAddress),
+            &clientAddress,
             clientAddressLen
     );
     if(bytesSent == SOCKET_ERROR) {
@@ -151,7 +153,7 @@ ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void UdpTmTcBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
+void UdpTmTcBridge::checkAndSetClientAddress(sockaddr& newAddress) {
     /* The target address can be set by different threads so this lock ensures thread-safety */
     MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
 
diff --git a/osal/common/UdpTmTcBridge.h b/osal/common/UdpTmTcBridge.h
index fcf2baec7..afc8ee98e 100644
--- a/osal/common/UdpTmTcBridge.h
+++ b/osal/common/UdpTmTcBridge.h
@@ -4,6 +4,10 @@
 #include "TcpIpBase.h"
 #include "../../tmtcservices/TmTcBridge.h"
 
+#ifdef __unix__
+#include <sys/socket.h>
+#endif
+
 #include <string>
 
 class UdpTmTcBridge:
@@ -25,7 +29,7 @@ public:
 
     ReturnValue_t initialize() override;
 
-    void checkAndSetClientAddress(sockaddr_in& clientAddress);
+    void checkAndSetClientAddress(sockaddr& clientAddress);
 
 protected:
     virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
@@ -33,8 +37,8 @@ protected:
 private:
     std::string udpServerPort;
 
-    struct sockaddr_in clientAddress;
-    int clientAddressLen = 0;
+    struct sockaddr clientAddress;
+    socklen_t clientAddressLen = 0;
 
     //! Access to the client address is mutex protected as it is set by another task.
     MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
diff --git a/osal/linux/CMakeLists.txt b/osal/linux/CMakeLists.txt
index 6c3778448..332fe2f49 100644
--- a/osal/linux/CMakeLists.txt
+++ b/osal/linux/CMakeLists.txt
@@ -13,8 +13,6 @@ target_sources(${LIB_FSFW_NAME}
 		QueueFactory.cpp
 		SemaphoreFactory.cpp
 		TaskFactory.cpp
-		TcUnixUdpPollingTask.cpp
-		TmTcUnixUdpBridge.cpp
 		Timer.cpp
 		tcpipHelpers.cpp
 )
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 37dadb765..ec3687b9c 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,152 +1,152 @@
-#include "TcUnixUdpPollingTask.h"
-#include "tcpipHelpers.h"
-
-#include "../../globalfunctions/arrayprinter.h"
-
-#define FSFW_UDP_RCV_WIRETAPPING_ENABLED    0
-
-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) {
-    /* Sender Address is cached here. */
-    struct sockaddr_in senderAddress;
-    socklen_t senderAddressSize = sizeof(senderAddress);
-
-	/* Poll for new UDP datagrams in permanent loop. */
-	while(true) {
-		ssize_t bytesReceived = recvfrom(
-		        serverUdpSocket,
-				receptionBuffer.data(),
-				frameSize,
-				receptionFlags,
-				reinterpret_cast<sockaddr*>(&senderAddress),
-				&senderAddressSize
-		);
-		if(bytesReceived < 0) {
-			/* Handle error */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "TcSocketPollingTask::performOperation: Reception error." << std::endl;
-#endif
-			tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::RECVFROM_CALL, 500);
-			continue;
-		}
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
-		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
-		        << " bytes received" << std::endl;
-#endif
-
-		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
-		if(result != HasReturnvaluesIF::RETURN_FAILED) {
-
-		}
-		tmtcBridge->checkAndSetClientAddress(senderAddress);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
-	store_address_t storeId;
-
-#if FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
-    arrayprinter::print(receptionBuffer.data(), bytesRead);
-#endif
-
-    ReturnValue_t result = tcStore->addData(&storeId, receptionBuffer.data(), bytesRead);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcUnixUdpPollingTask::handleSuccessfullTcRead: Data "
-				"storage failed" << std::endl;
-		sif::error << "Packet size: " << bytesRead << std::endl;
-#else
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	TmTcMessage message(storeId);
-
-	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcUnixUdpPollingTask::handleSuccessfullTcRead: Sending message to queue "
-		        "failed" << std::endl;
-#else
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-		tcStore->deleteData(storeId);
-	}
-	return result;
-}
-
-ReturnValue_t TcUnixUdpPollingTask::initialize() {
-	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-	if (tcStore == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
-				<< std::endl;
-#endif
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
-	if(tmtcBridge == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
-				" TMTC bridge object!" << std::endl;
-#endif
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TcUnixUdpPollingTask::initializeAfterTaskCreation() {
-    /* Initialize the destination after task creation. This ensures
-    that the destination has already been set in the TMTC bridge. */
-	targetTcDestination = tmtcBridge->getRequestQueue();
-    /* The server socket is set up in the bridge intialization. Calling this function here
-    ensures that it is set up properly in any case*/
-    serverUdpSocket = tmtcBridge->serverSocket;
-	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) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
-				"receive timeout failed with " << strerror(errno) << std::endl;
-#endif
-	}
-}
+//#include "TcUnixUdpPollingTask.h"
+//#include "tcpipHelpers.h"
+//
+//#include "../../globalfunctions/arrayprinter.h"
+//
+//#define FSFW_UDP_RCV_WIRETAPPING_ENABLED    0
+//
+//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) {
+//    /* Sender Address is cached here. */
+//    struct sockaddr_in senderAddress;
+//    socklen_t senderAddressSize = sizeof(senderAddress);
+//
+//	/* Poll for new UDP datagrams in permanent loop. */
+//	while(true) {
+//		ssize_t bytesReceived = recvfrom(
+//		        serverUdpSocket,
+//				receptionBuffer.data(),
+//				frameSize,
+//				receptionFlags,
+//				reinterpret_cast<sockaddr*>(&senderAddress),
+//				&senderAddressSize
+//		);
+//		if(bytesReceived < 0) {
+//			/* Handle error */
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//			sif::error << "TcSocketPollingTask::performOperation: Reception error." << std::endl;
+//#endif
+//			tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::RECVFROM_CALL, 500);
+//			continue;
+//		}
+//#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
+//		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
+//		        << " bytes received" << std::endl;
+//#endif
+//
+//		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
+//		if(result != HasReturnvaluesIF::RETURN_FAILED) {
+//
+//		}
+//		tmtcBridge->checkAndSetClientAddress(senderAddress);
+//	}
+//	return HasReturnvaluesIF::RETURN_OK;
+//}
+//
+//
+//ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
+//	store_address_t storeId;
+//
+//#if FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
+//    arrayprinter::print(receptionBuffer.data(), bytesRead);
+//#endif
+//
+//    ReturnValue_t result = tcStore->addData(&storeId, receptionBuffer.data(), bytesRead);
+//	if (result != HasReturnvaluesIF::RETURN_OK) {
+//#if FSFW_VERBOSE_LEVEL >= 1
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//		sif::error << "TcUnixUdpPollingTask::handleSuccessfullTcRead: Data "
+//				"storage failed" << std::endl;
+//		sif::error << "Packet size: " << bytesRead << std::endl;
+//#else
+//#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+//#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//
+//	TmTcMessage message(storeId);
+//
+//	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
+//	if (result != HasReturnvaluesIF::RETURN_OK) {
+//#if FSFW_VERBOSE_LEVEL >= 1
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//		sif::error << "TcUnixUdpPollingTask::handleSuccessfullTcRead: Sending message to queue "
+//		        "failed" << std::endl;
+//#else
+//#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+//#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+//		tcStore->deleteData(storeId);
+//	}
+//	return result;
+//}
+//
+//ReturnValue_t TcUnixUdpPollingTask::initialize() {
+//	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+//	if (tcStore == nullptr) {
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
+//				<< std::endl;
+//#endif
+//		return ObjectManagerIF::CHILD_INIT_FAILED;
+//	}
+//
+//	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
+//	if(tmtcBridge == nullptr) {
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
+//				" TMTC bridge object!" << std::endl;
+//#endif
+//		return ObjectManagerIF::CHILD_INIT_FAILED;
+//	}
+//
+//	return HasReturnvaluesIF::RETURN_OK;
+//}
+//
+//ReturnValue_t TcUnixUdpPollingTask::initializeAfterTaskCreation() {
+//    /* Initialize the destination after task creation. This ensures
+//    that the destination has already been set in the TMTC bridge. */
+//	targetTcDestination = tmtcBridge->getRequestQueue();
+//    /* The server socket is set up in the bridge intialization. Calling this function here
+//    ensures that it is set up properly in any case*/
+//    serverUdpSocket = tmtcBridge->serverSocket;
+//	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) {
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+//				"receive timeout failed with " << strerror(errno) << std::endl;
+//#endif
+//	}
+//}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index 39ee0914d..1040d1a24 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -1,67 +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);
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
+//#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);
+//};
+//
+//#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index fa7913ea6..c0cd68779 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,167 +1,167 @@
-#include "TmTcUnixUdpBridge.h"
-#include "tcpipHelpers.h"
-#include "../../serviceinterface/ServiceInterface.h"
-#include "../../ipc/MutexGuard.h"
-
-#include <arpa/inet.h>
-#include <unistd.h>
-#include <netdb.h>
-
-#include <cstring>
-
-//! Debugging preprocessor define.
-#define FSFW_UDP_SEND_WIRETAPPING_ENABLED   0
-
-const std::string TmTcUnixUdpBridge::DEFAULT_UDP_SERVER_PORT =  tcpip::DEFAULT_UDP_SERVER_PORT;
-
-TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
-        object_id_t tmStoreId, object_id_t tcStoreId, std::string udpServerPort):
-		TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
-    if(udpServerPort == "") {
-        this->udpServerPort = DEFAULT_UDP_SERVER_PORT;
-    }
-    else {
-        this->udpServerPort = udpServerPort;
-    }
-
-    mutex = MutexFactory::instance()->createMutex();
-    communicationLinkUp = false;
-}
-
-ReturnValue_t TmTcUnixUdpBridge::initialize() {
-    using namespace tcpip;
-
-    ReturnValue_t result = TmTcBridge::initialize();
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcUnixUdpBridge::initialize: TmTcBridge initialization failed!"
-                << std::endl;
-#endif
-        return result;
-    }
-
-    struct addrinfo *addrResult = nullptr;
-    struct addrinfo hints;
-
-    std::memset(&hints, 0, sizeof(hints));
-    hints.ai_family = AF_INET;
-    hints.ai_socktype = SOCK_DGRAM;
-    hints.ai_protocol = IPPROTO_UDP;
-    hints.ai_flags = AI_PASSIVE;
-
-    /* Set up UDP socket:
-    https://man7.org/linux/man-pages/man3/getaddrinfo.3.html
-    Passing nullptr as the first parameter and specifying AI_PASSIVE in hints will cause
-    getaddrinfo to assign the address 0.0.0.0 (any address) */
-    int retval = getaddrinfo(nullptr, udpServerPort.c_str(), &hints, &addrResult);
-    if (retval != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Retrieving address info failed!" <<
-                std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    /* Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html */
-    serverSocket = socket(addrResult->ai_family, addrResult->ai_socktype, addrResult->ai_protocol);
-    if(serverSocket < 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open UDP socket!" <<
-                std::endl;
-#else
-        sif::printError("TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open UDP socket!\n");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-        freeaddrinfo(addrResult);
-        handleError(Protocol::UDP, ErrorSources::SOCKET_CALL);
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    retval = bind(serverSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
-    if(retval != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
-                "local port (" << udpServerPort << ") to server socket!" << std::endl;
-#endif
-        freeaddrinfo(addrResult);
-        handleError(Protocol::UDP, ErrorSources::BIND_CALL);
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
-    if(mutex != nullptr) {
-        MutexFactory::instance()->deleteMutex(mutex);
-    }
-    close(serverSocket);
-}
-
-ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
-    int flags = 0;
-
-    /* The target address can be set by different threads so this lock ensures thread-safety */
-    MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
-
-    if(ipAddrAnySet){
-        clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
-        clientAddressLen = sizeof(clientAddress);
-    }
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-    char ipAddress [15];
-    sif::debug << "IP Address Sender: "<<
-            inet_ntop(AF_INET,&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
-#endif
-
-    ssize_t bytesSent = sendto(
-            serverSocket,
-            data,
-            dataLen,
-            flags,
-            reinterpret_cast<sockaddr*>(&clientAddress),
-            clientAddressLen
-    );
-    if(bytesSent < 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TmTcUnixUdpBridge::sendTm: Send operation failed." << std::endl;
-#endif
-        tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
-    }
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-    sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
-            " sent." << std::endl;
-#endif
-
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
-    /* The target address can be set by different threads so this lock ensures thread-safety */
-    MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
-    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;
-#endif
-    registerCommConnect();
-
-    /* Set new IP address to reply to. */
-    clientAddress = newAddress;
-    clientAddressLen = sizeof(clientAddress);
-}
-
-void TmTcUnixUdpBridge::setMutexProperties(MutexIF::TimeoutType timeoutType,
-        dur_millis_t timeoutMs) {
-    this->timeoutType = timeoutType;
-    this->mutexTimeoutMs = timeoutMs;
-}
-
-void TmTcUnixUdpBridge::setClientAddressToAny(bool ipAddrAnySet){
-    this->ipAddrAnySet = ipAddrAnySet;
-}
-
+//#include "TmTcUnixUdpBridge.h"
+//#include "tcpipHelpers.h"
+//#include "../../serviceinterface/ServiceInterface.h"
+//#include "../../ipc/MutexGuard.h"
+//
+//#include <arpa/inet.h>
+//#include <unistd.h>
+//#include <netdb.h>
+//
+//#include <cstring>
+//
+////! Debugging preprocessor define.
+//#define FSFW_UDP_SEND_WIRETAPPING_ENABLED   0
+//
+//const std::string TmTcUnixUdpBridge::DEFAULT_UDP_SERVER_PORT =  tcpip::DEFAULT_UDP_SERVER_PORT;
+//
+//TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
+//        object_id_t tmStoreId, object_id_t tcStoreId, std::string udpServerPort):
+//		TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
+//    if(udpServerPort == "") {
+//        this->udpServerPort = DEFAULT_UDP_SERVER_PORT;
+//    }
+//    else {
+//        this->udpServerPort = udpServerPort;
+//    }
+//
+//    mutex = MutexFactory::instance()->createMutex();
+//    communicationLinkUp = false;
+//}
+//
+//ReturnValue_t TmTcUnixUdpBridge::initialize() {
+//    using namespace tcpip;
+//
+//    ReturnValue_t result = TmTcBridge::initialize();
+//    if(result != HasReturnvaluesIF::RETURN_OK) {
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//        sif::error << "TmTcUnixUdpBridge::initialize: TmTcBridge initialization failed!"
+//                << std::endl;
+//#endif
+//        return result;
+//    }
+//
+//    struct addrinfo *addrResult = nullptr;
+//    struct addrinfo hints;
+//
+//    std::memset(&hints, 0, sizeof(hints));
+//    hints.ai_family = AF_INET;
+//    hints.ai_socktype = SOCK_DGRAM;
+//    hints.ai_protocol = IPPROTO_UDP;
+//    hints.ai_flags = AI_PASSIVE;
+//
+//    /* Set up UDP socket:
+//    https://man7.org/linux/man-pages/man3/getaddrinfo.3.html
+//    Passing nullptr as the first parameter and specifying AI_PASSIVE in hints will cause
+//    getaddrinfo to assign the address 0.0.0.0 (any address) */
+//    int retval = getaddrinfo(nullptr, udpServerPort.c_str(), &hints, &addrResult);
+//    if (retval != 0) {
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Retrieving address info failed!" <<
+//                std::endl;
+//#endif
+//        return HasReturnvaluesIF::RETURN_FAILED;
+//    }
+//
+//    /* Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html */
+//    serverSocket = socket(addrResult->ai_family, addrResult->ai_socktype, addrResult->ai_protocol);
+//    if(serverSocket < 0) {
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//        sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open UDP socket!" <<
+//                std::endl;
+//#else
+//        sif::printError("TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open UDP socket!\n");
+//#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+//        freeaddrinfo(addrResult);
+//        handleError(Protocol::UDP, ErrorSources::SOCKET_CALL);
+//        return HasReturnvaluesIF::RETURN_FAILED;
+//    }
+//
+//    retval = bind(serverSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
+//    if(retval != 0) {
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
+//                "local port (" << udpServerPort << ") to server socket!" << std::endl;
+//#endif
+//        freeaddrinfo(addrResult);
+//        handleError(Protocol::UDP, ErrorSources::BIND_CALL);
+//        return HasReturnvaluesIF::RETURN_FAILED;
+//    }
+//
+//    return HasReturnvaluesIF::RETURN_OK;
+//}
+//
+//TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
+//    if(mutex != nullptr) {
+//        MutexFactory::instance()->deleteMutex(mutex);
+//    }
+//    close(serverSocket);
+//}
+//
+//ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+//    int flags = 0;
+//
+//    /* The target address can be set by different threads so this lock ensures thread-safety */
+//    MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
+//
+//    if(ipAddrAnySet){
+//        clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
+//        clientAddressLen = sizeof(clientAddress);
+//    }
+//
+//#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
+//    char ipAddress [15];
+//    sif::debug << "IP Address Sender: "<<
+//            inet_ntop(AF_INET,&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+//#endif
+//
+//    ssize_t bytesSent = sendto(
+//            serverSocket,
+//            data,
+//            dataLen,
+//            flags,
+//            reinterpret_cast<sockaddr*>(&clientAddress),
+//            clientAddressLen
+//    );
+//    if(bytesSent < 0) {
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//        sif::warning << "TmTcUnixUdpBridge::sendTm: Send operation failed." << std::endl;
+//#endif
+//        tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
+//    }
+//
+//#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
+//    sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+//            " sent." << std::endl;
+//#endif
+//
+//    return HasReturnvaluesIF::RETURN_OK;
+//}
+//
+//void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
+//    /* The target address can be set by different threads so this lock ensures thread-safety */
+//    MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
+//
+//#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
+//    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;
+//#endif
+//    registerCommConnect();
+//
+//    /* Set new IP address to reply to. */
+//    clientAddress = newAddress;
+//    clientAddressLen = sizeof(clientAddress);
+//}
+//
+//void TmTcUnixUdpBridge::setMutexProperties(MutexIF::TimeoutType timeoutType,
+//        dur_millis_t timeoutMs) {
+//    this->timeoutType = timeoutType;
+//    this->mutexTimeoutMs = timeoutMs;
+//}
+//
+//void TmTcUnixUdpBridge::setClientAddressToAny(bool ipAddrAnySet){
+//    this->ipAddrAnySet = ipAddrAnySet;
+//}
+//
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index 3ab2118cc..b4b009506 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -1,53 +1,53 @@
-#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 const std::string DEFAULT_UDP_SERVER_PORT;
-
-    TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
-            object_id_t tmStoreId, object_id_t tcStoreId,
-            std::string serverPort = "");
-    virtual~ TmTcUnixUdpBridge();
-
-    /**
-     * Set properties of internal mutex.
-     */
-    void setMutexProperties(MutexIF::TimeoutType timeoutType, dur_millis_t timeoutMs);
-
-    ReturnValue_t initialize() override;
-
-    void checkAndSetClientAddress(sockaddr_in& clientAddress);
-
-    void setClientAddressToAny(bool ipAddrAnySet);
-
-protected:
-    virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
-
-private:
-    int serverSocket = 0;
-    std::string udpServerPort;
-
-    struct sockaddr_in clientAddress;
-    socklen_t clientAddressLen = 0;
-
-    bool ipAddrAnySet = false;
-
-    //! Access to the client address is mutex protected as it is set by another task.
-    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-    dur_millis_t mutexTimeoutMs = 20;
-    MutexIF* mutex;
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
+//#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 const std::string DEFAULT_UDP_SERVER_PORT;
+//
+//    TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
+//            object_id_t tmStoreId, object_id_t tcStoreId,
+//            std::string serverPort = "");
+//    virtual~ TmTcUnixUdpBridge();
+//
+//    /**
+//     * Set properties of internal mutex.
+//     */
+//    void setMutexProperties(MutexIF::TimeoutType timeoutType, dur_millis_t timeoutMs);
+//
+//    ReturnValue_t initialize() override;
+//
+//    void checkAndSetClientAddress(sockaddr_in& clientAddress);
+//
+//    void setClientAddressToAny(bool ipAddrAnySet);
+//
+//protected:
+//    virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
+//
+//private:
+//    int serverSocket = 0;
+//    std::string udpServerPort;
+//
+//    struct sockaddr_in clientAddress;
+//    socklen_t clientAddressLen = 0;
+//
+//    bool ipAddrAnySet = false;
+//
+//    //! Access to the client address is mutex protected as it is set by another task.
+//    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+//    dur_millis_t mutexTimeoutMs = 20;
+//    MutexIF* mutex;
+//};
+//
+//#endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */

From b5a14bb9dfbb57dbfcc89c8fab19a244c5396598 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 21 Mar 2021 13:02:14 +0100
Subject: [PATCH 1719/1774] deleted old linux code

---
 osal/common/UdpTcPollingTask.cpp    | 172 +++++++++++++++-------------
 osal/common/UdpTcPollingTask.h      |   4 +-
 osal/common/UdpTmTcBridge.cpp       |  14 ++-
 osal/linux/TcUnixUdpPollingTask.cpp | 152 ------------------------
 osal/linux/TcUnixUdpPollingTask.h   |  67 -----------
 osal/linux/TmTcUnixUdpBridge.cpp    | 167 ---------------------------
 osal/linux/TmTcUnixUdpBridge.h      |  53 ---------
 osal/linux/tcpipHelpers.cpp         |   2 +-
 osal/linux/tcpipHelpers.h           |  14 ---
 9 files changed, 102 insertions(+), 543 deletions(-)
 delete mode 100644 osal/linux/TcUnixUdpPollingTask.cpp
 delete mode 100644 osal/linux/TcUnixUdpPollingTask.h
 delete mode 100644 osal/linux/TmTcUnixUdpBridge.cpp
 delete mode 100644 osal/linux/TmTcUnixUdpBridge.h
 delete mode 100644 osal/linux/tcpipHelpers.h

diff --git a/osal/common/UdpTcPollingTask.cpp b/osal/common/UdpTcPollingTask.cpp
index 3d51e1189..bace593f3 100644
--- a/osal/common/UdpTcPollingTask.cpp
+++ b/osal/common/UdpTcPollingTask.cpp
@@ -18,27 +18,27 @@
 #define FSFW_UDP_RCV_WIRETAPPING_ENABLED    0
 
 UdpTcPollingTask::UdpTcPollingTask(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;
-	}
+        object_id_t tmtcUnixUdpBridge, size_t maxRecvSize,
+        double timeoutSeconds): SystemObject(objectId),
+        tmtcBridgeId(tmtcUnixUdpBridge) {
+    if(frameSize > 0) {
+        this->frameSize = frameSize;
+    }
+    else {
+        this->frameSize = DEFAULT_MAX_RECV_SIZE;
+    }
 
-	/* Set up reception buffer with specified 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);
+    receptionBuffer.reserve(this->frameSize);
+    receptionBuffer.resize(this->frameSize);
 
-	if(timeoutSeconds == -1) {
-		receptionTimeout = DEFAULT_TIMEOUT;
-	}
-	else {
-		receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
-	}
+    if(timeoutSeconds == -1) {
+        receptionTimeout = DEFAULT_TIMEOUT;
+    }
+    else {
+        receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
+    }
 }
 
 UdpTcPollingTask::~UdpTcPollingTask() {}
@@ -48,120 +48,130 @@ ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
     struct sockaddr senderAddress;
     socklen_t senderAddressSize = sizeof(senderAddress);
 
-	/* Poll for new UDP datagrams in permanent loop. */
-	while(true) {
-		int bytesReceived = recvfrom(
-		        this->serverSocket,
-		        reinterpret_cast<char*>(receptionBuffer.data()),
-		        frameSize,
-				receptionFlags,
-				&senderAddress,
-				&senderAddressSize
-		);
-		if(bytesReceived == SOCKET_ERROR) {
-			/* Handle error */
+    /* Poll for new UDP datagrams in permanent loop. */
+    while(true) {
+        int bytesReceived = recvfrom(
+                this->serverSocket,
+                reinterpret_cast<char*>(receptionBuffer.data()),
+                frameSize,
+                receptionFlags,
+                &senderAddress,
+                &senderAddressSize
+        );
+        if(bytesReceived == SOCKET_ERROR) {
+            /* Handle error */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "UdpTcPollingTask::performOperation: Reception error." << std::endl;
+            sif::error << "UdpTcPollingTask::performOperation: Reception error." << std::endl;
 #endif
-			tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::RECVFROM_CALL, 1000);
-			continue;
-		}
+            tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::RECVFROM_CALL, 1000);
+            continue;
+        }
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
-		sif::debug << "UdpTcPollingTask::performOperation: " << bytesReceived <<
-		        " bytes received" << std::endl;
+        sif::debug << "UdpTcPollingTask::performOperation: " << bytesReceived <<
+                " bytes received" << std::endl;
 #endif
 
-		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
-		if(result != HasReturnvaluesIF::RETURN_FAILED) {
+        ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
+        if(result != HasReturnvaluesIF::RETURN_FAILED) {
 
-		}
-		tmtcBridge->checkAndSetClientAddress(senderAddress);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+        }
+        tmtcBridge->checkAndSetClientAddress(senderAddress);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 
 ReturnValue_t UdpTcPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
-	store_address_t storeId;
+    store_address_t storeId;
 
 #if FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
     arrayprinter::print(receptionBuffer.data(), bytesRead);
 #endif
 
-	ReturnValue_t result = tcStore->addData(&storeId, receptionBuffer.data(), bytesRead);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
+    ReturnValue_t result = tcStore->addData(&storeId, receptionBuffer.data(), bytesRead);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning<< "UdpTcPollingTask::transferPusToSoftwareBus: Data storage failed." <<
-		        std::endl;
-		sif::warning << "Packet size: " << bytesRead << std::endl;
+        sif::warning<< "UdpTcPollingTask::transferPusToSoftwareBus: Data storage failed." <<
+                std::endl;
+        sif::warning << "Packet size: " << bytesRead << std::endl;
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	TmTcMessage message(storeId);
+    TmTcMessage message(storeId);
 
-	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
+    result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "UdpTcPollingTask::handleSuccessfullTcRead: "
-		        " Sending message to queue failed" << std::endl;
+        sif::warning << "UdpTcPollingTask::handleSuccessfullTcRead: "
+                " Sending message to queue failed" << std::endl;
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
-		tcStore->deleteData(storeId);
-	}
-	return result;
+        tcStore->deleteData(storeId);
+    }
+    return result;
 }
 
 ReturnValue_t UdpTcPollingTask::initialize() {
-	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-	if (tcStore == nullptr) {
+    tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+    if (tcStore == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "UdpTcPollingTask::initialize: TC store uninitialized!" << std::endl;
+        sif::error << "UdpTcPollingTask::initialize: TC store uninitialized!" << std::endl;
 #endif
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
+        return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
 
-	tmtcBridge = objectManager->get<UdpTmTcBridge>(tmtcBridgeId);
-	if(tmtcBridge == nullptr) {
+    tmtcBridge = objectManager->get<UdpTmTcBridge>(tmtcBridgeId);
+    if(tmtcBridge == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "UdpTcPollingTask::initialize: Invalid TMTC bridge object!" <<
-		        std::endl;
+        sif::error << "UdpTcPollingTask::initialize: Invalid TMTC bridge object!" <<
+                std::endl;
 #endif
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
+        return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
 
     ReturnValue_t result = TcpIpBase::initialize();
     if(result != HasReturnvaluesIF::RETURN_OK) {
         return result;
     }
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t UdpTcPollingTask::initializeAfterTaskCreation() {
-	/* Initialize the destination after task creation. This ensures
+    /* Initialize the destination after task creation. This ensures
 	that the destination has already been set in the TMTC bridge. */
-	targetTcDestination = tmtcBridge->getRequestQueue();
-	/* The server socket is set up in the bridge intialization. Calling this function here
+    targetTcDestination = tmtcBridge->getRequestQueue();
+    /* The server socket is set up in the bridge intialization. Calling this function here
 	ensures that it is set up regardless of which class was initialized first */
     this->serverSocket = tmtcBridge->serverSocket;
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void UdpTcPollingTask::setTimeout(double timeoutSeconds) {
 #ifdef _WIN32
-	DWORD timeoutMs = timeoutSeconds * 1000.0;
-	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
-			reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
-	if(result == -1) {
+    DWORD timeoutMs = timeoutSeconds * 1000.0;
+    int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+            reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
+    if(result == -1) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "TcWinUdpPollingTask::TcSocketPollingTask: Setting "
-				"receive timeout failed with " << strerror(errno) << std::endl;
+        sif::error << "TcWinUdpPollingTask::TcSocketPollingTask: Setting "
+                "receive timeout failed with " << strerror(errno) << std::endl;
 #endif
-	}
+    }
 #elif defined(__unix__)
+    timeval tval;
+    tval = timevalOperations::toTimeval(timeoutSeconds);
+    int result = setsockopt(serverSocket, SOL_SOCKET, SO_RCVTIMEO,
+            &tval, sizeof(receptionTimeout));
+    if(result == -1) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+                "receive timeout failed with " << strerror(errno) << std::endl;
+#endif
+    }
 #endif
 }
diff --git a/osal/common/UdpTcPollingTask.h b/osal/common/UdpTcPollingTask.h
index 4df62b942..ae1c4c442 100644
--- a/osal/common/UdpTcPollingTask.h
+++ b/osal/common/UdpTcPollingTask.h
@@ -23,12 +23,12 @@ class UdpTcPollingTask:
 		public ExecutableObjectIF {
 	friend class TmTcWinUdpBridge;
 public:
-	static constexpr size_t DEFAULT_MAX_FRAME_SIZE = 2048;
+	static constexpr size_t DEFAULT_MAX_RECV_SIZE = 1500;
 	//! 0.5  default milliseconds timeout for now.
 	static constexpr timeval DEFAULT_TIMEOUT = {0, 500};
 
 	UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
-			size_t frameSize = 0, double timeoutSeconds = -1);
+			size_t maxRecvSize = 0, double timeoutSeconds = -1);
 	virtual~ UdpTcPollingTask();
 
 	/**
diff --git a/osal/common/UdpTmTcBridge.cpp b/osal/common/UdpTmTcBridge.cpp
index a8975c0e0..ae74e94b1 100644
--- a/osal/common/UdpTmTcBridge.cpp
+++ b/osal/common/UdpTmTcBridge.cpp
@@ -70,12 +70,14 @@ ReturnValue_t UdpTmTcBridge::initialize() {
     hints.ai_family = AF_INET;
     hints.ai_socktype = SOCK_DGRAM;
     hints.ai_protocol = IPPROTO_UDP;
-#ifdef _WIN32
-    /* See:
-    https://docs.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo
-    for information about AI_PASSIVE. */
-    hints.ai_flags = AI_PASSIVE;
-#endif
+//#ifdef _WIN32
+//    /* See:
+//    https://docs.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo
+//    and
+//
+//    for information about AI_PASSIVE. */
+//    hints.ai_flags = AI_PASSIVE;
+//#endif
 
     /* Set up UDP socket:
     https://en.wikipedia.org/wiki/Getaddrinfo
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
deleted file mode 100644
index ec3687b9c..000000000
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-//#include "TcUnixUdpPollingTask.h"
-//#include "tcpipHelpers.h"
-//
-//#include "../../globalfunctions/arrayprinter.h"
-//
-//#define FSFW_UDP_RCV_WIRETAPPING_ENABLED    0
-//
-//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) {
-//    /* Sender Address is cached here. */
-//    struct sockaddr_in senderAddress;
-//    socklen_t senderAddressSize = sizeof(senderAddress);
-//
-//	/* Poll for new UDP datagrams in permanent loop. */
-//	while(true) {
-//		ssize_t bytesReceived = recvfrom(
-//		        serverUdpSocket,
-//				receptionBuffer.data(),
-//				frameSize,
-//				receptionFlags,
-//				reinterpret_cast<sockaddr*>(&senderAddress),
-//				&senderAddressSize
-//		);
-//		if(bytesReceived < 0) {
-//			/* Handle error */
-//#if FSFW_CPP_OSTREAM_ENABLED == 1
-//			sif::error << "TcSocketPollingTask::performOperation: Reception error." << std::endl;
-//#endif
-//			tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::RECVFROM_CALL, 500);
-//			continue;
-//		}
-//#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
-//		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
-//		        << " bytes received" << std::endl;
-//#endif
-//
-//		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
-//		if(result != HasReturnvaluesIF::RETURN_FAILED) {
-//
-//		}
-//		tmtcBridge->checkAndSetClientAddress(senderAddress);
-//	}
-//	return HasReturnvaluesIF::RETURN_OK;
-//}
-//
-//
-//ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
-//	store_address_t storeId;
-//
-//#if FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
-//    arrayprinter::print(receptionBuffer.data(), bytesRead);
-//#endif
-//
-//    ReturnValue_t result = tcStore->addData(&storeId, receptionBuffer.data(), bytesRead);
-//	if (result != HasReturnvaluesIF::RETURN_OK) {
-//#if FSFW_VERBOSE_LEVEL >= 1
-//#if FSFW_CPP_OSTREAM_ENABLED == 1
-//		sif::error << "TcUnixUdpPollingTask::handleSuccessfullTcRead: Data "
-//				"storage failed" << std::endl;
-//		sif::error << "Packet size: " << bytesRead << std::endl;
-//#else
-//#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-//#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-//		return HasReturnvaluesIF::RETURN_FAILED;
-//	}
-//
-//	TmTcMessage message(storeId);
-//
-//	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
-//	if (result != HasReturnvaluesIF::RETURN_OK) {
-//#if FSFW_VERBOSE_LEVEL >= 1
-//#if FSFW_CPP_OSTREAM_ENABLED == 1
-//		sif::error << "TcUnixUdpPollingTask::handleSuccessfullTcRead: Sending message to queue "
-//		        "failed" << std::endl;
-//#else
-//#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-//#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-//		tcStore->deleteData(storeId);
-//	}
-//	return result;
-//}
-//
-//ReturnValue_t TcUnixUdpPollingTask::initialize() {
-//	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-//	if (tcStore == nullptr) {
-//#if FSFW_CPP_OSTREAM_ENABLED == 1
-//		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
-//				<< std::endl;
-//#endif
-//		return ObjectManagerIF::CHILD_INIT_FAILED;
-//	}
-//
-//	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
-//	if(tmtcBridge == nullptr) {
-//#if FSFW_CPP_OSTREAM_ENABLED == 1
-//		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
-//				" TMTC bridge object!" << std::endl;
-//#endif
-//		return ObjectManagerIF::CHILD_INIT_FAILED;
-//	}
-//
-//	return HasReturnvaluesIF::RETURN_OK;
-//}
-//
-//ReturnValue_t TcUnixUdpPollingTask::initializeAfterTaskCreation() {
-//    /* Initialize the destination after task creation. This ensures
-//    that the destination has already been set in the TMTC bridge. */
-//	targetTcDestination = tmtcBridge->getRequestQueue();
-//    /* The server socket is set up in the bridge intialization. Calling this function here
-//    ensures that it is set up properly in any case*/
-//    serverUdpSocket = tmtcBridge->serverSocket;
-//	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) {
-//#if FSFW_CPP_OSTREAM_ENABLED == 1
-//		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
-//				"receive timeout failed with " << strerror(errno) << std::endl;
-//#endif
-//	}
-//}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
deleted file mode 100644
index 1040d1a24..000000000
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ /dev/null
@@ -1,67 +0,0 @@
-//#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);
-//};
-//
-//#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
deleted file mode 100644
index c0cd68779..000000000
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ /dev/null
@@ -1,167 +0,0 @@
-//#include "TmTcUnixUdpBridge.h"
-//#include "tcpipHelpers.h"
-//#include "../../serviceinterface/ServiceInterface.h"
-//#include "../../ipc/MutexGuard.h"
-//
-//#include <arpa/inet.h>
-//#include <unistd.h>
-//#include <netdb.h>
-//
-//#include <cstring>
-//
-////! Debugging preprocessor define.
-//#define FSFW_UDP_SEND_WIRETAPPING_ENABLED   0
-//
-//const std::string TmTcUnixUdpBridge::DEFAULT_UDP_SERVER_PORT =  tcpip::DEFAULT_UDP_SERVER_PORT;
-//
-//TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
-//        object_id_t tmStoreId, object_id_t tcStoreId, std::string udpServerPort):
-//		TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
-//    if(udpServerPort == "") {
-//        this->udpServerPort = DEFAULT_UDP_SERVER_PORT;
-//    }
-//    else {
-//        this->udpServerPort = udpServerPort;
-//    }
-//
-//    mutex = MutexFactory::instance()->createMutex();
-//    communicationLinkUp = false;
-//}
-//
-//ReturnValue_t TmTcUnixUdpBridge::initialize() {
-//    using namespace tcpip;
-//
-//    ReturnValue_t result = TmTcBridge::initialize();
-//    if(result != HasReturnvaluesIF::RETURN_OK) {
-//#if FSFW_CPP_OSTREAM_ENABLED == 1
-//        sif::error << "TmTcUnixUdpBridge::initialize: TmTcBridge initialization failed!"
-//                << std::endl;
-//#endif
-//        return result;
-//    }
-//
-//    struct addrinfo *addrResult = nullptr;
-//    struct addrinfo hints;
-//
-//    std::memset(&hints, 0, sizeof(hints));
-//    hints.ai_family = AF_INET;
-//    hints.ai_socktype = SOCK_DGRAM;
-//    hints.ai_protocol = IPPROTO_UDP;
-//    hints.ai_flags = AI_PASSIVE;
-//
-//    /* Set up UDP socket:
-//    https://man7.org/linux/man-pages/man3/getaddrinfo.3.html
-//    Passing nullptr as the first parameter and specifying AI_PASSIVE in hints will cause
-//    getaddrinfo to assign the address 0.0.0.0 (any address) */
-//    int retval = getaddrinfo(nullptr, udpServerPort.c_str(), &hints, &addrResult);
-//    if (retval != 0) {
-//#if FSFW_CPP_OSTREAM_ENABLED == 1
-//        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Retrieving address info failed!" <<
-//                std::endl;
-//#endif
-//        return HasReturnvaluesIF::RETURN_FAILED;
-//    }
-//
-//    /* Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html */
-//    serverSocket = socket(addrResult->ai_family, addrResult->ai_socktype, addrResult->ai_protocol);
-//    if(serverSocket < 0) {
-//#if FSFW_CPP_OSTREAM_ENABLED == 1
-//        sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open UDP socket!" <<
-//                std::endl;
-//#else
-//        sif::printError("TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open UDP socket!\n");
-//#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-//        freeaddrinfo(addrResult);
-//        handleError(Protocol::UDP, ErrorSources::SOCKET_CALL);
-//        return HasReturnvaluesIF::RETURN_FAILED;
-//    }
-//
-//    retval = bind(serverSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
-//    if(retval != 0) {
-//#if FSFW_CPP_OSTREAM_ENABLED == 1
-//        sif::warning << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
-//                "local port (" << udpServerPort << ") to server socket!" << std::endl;
-//#endif
-//        freeaddrinfo(addrResult);
-//        handleError(Protocol::UDP, ErrorSources::BIND_CALL);
-//        return HasReturnvaluesIF::RETURN_FAILED;
-//    }
-//
-//    return HasReturnvaluesIF::RETURN_OK;
-//}
-//
-//TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
-//    if(mutex != nullptr) {
-//        MutexFactory::instance()->deleteMutex(mutex);
-//    }
-//    close(serverSocket);
-//}
-//
-//ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
-//    int flags = 0;
-//
-//    /* The target address can be set by different threads so this lock ensures thread-safety */
-//    MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
-//
-//    if(ipAddrAnySet){
-//        clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
-//        clientAddressLen = sizeof(clientAddress);
-//    }
-//
-//#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-//    char ipAddress [15];
-//    sif::debug << "IP Address Sender: "<<
-//            inet_ntop(AF_INET,&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
-//#endif
-//
-//    ssize_t bytesSent = sendto(
-//            serverSocket,
-//            data,
-//            dataLen,
-//            flags,
-//            reinterpret_cast<sockaddr*>(&clientAddress),
-//            clientAddressLen
-//    );
-//    if(bytesSent < 0) {
-//#if FSFW_CPP_OSTREAM_ENABLED == 1
-//        sif::warning << "TmTcUnixUdpBridge::sendTm: Send operation failed." << std::endl;
-//#endif
-//        tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
-//    }
-//
-//#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-//    sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
-//            " sent." << std::endl;
-//#endif
-//
-//    return HasReturnvaluesIF::RETURN_OK;
-//}
-//
-//void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
-//    /* The target address can be set by different threads so this lock ensures thread-safety */
-//    MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
-//
-//#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
-//    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;
-//#endif
-//    registerCommConnect();
-//
-//    /* Set new IP address to reply to. */
-//    clientAddress = newAddress;
-//    clientAddressLen = sizeof(clientAddress);
-//}
-//
-//void TmTcUnixUdpBridge::setMutexProperties(MutexIF::TimeoutType timeoutType,
-//        dur_millis_t timeoutMs) {
-//    this->timeoutType = timeoutType;
-//    this->mutexTimeoutMs = timeoutMs;
-//}
-//
-//void TmTcUnixUdpBridge::setClientAddressToAny(bool ipAddrAnySet){
-//    this->ipAddrAnySet = ipAddrAnySet;
-//}
-//
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
deleted file mode 100644
index b4b009506..000000000
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ /dev/null
@@ -1,53 +0,0 @@
-//#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 const std::string DEFAULT_UDP_SERVER_PORT;
-//
-//    TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
-//            object_id_t tmStoreId, object_id_t tcStoreId,
-//            std::string serverPort = "");
-//    virtual~ TmTcUnixUdpBridge();
-//
-//    /**
-//     * Set properties of internal mutex.
-//     */
-//    void setMutexProperties(MutexIF::TimeoutType timeoutType, dur_millis_t timeoutMs);
-//
-//    ReturnValue_t initialize() override;
-//
-//    void checkAndSetClientAddress(sockaddr_in& clientAddress);
-//
-//    void setClientAddressToAny(bool ipAddrAnySet);
-//
-//protected:
-//    virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
-//
-//private:
-//    int serverSocket = 0;
-//    std::string udpServerPort;
-//
-//    struct sockaddr_in clientAddress;
-//    socklen_t clientAddressLen = 0;
-//
-//    bool ipAddrAnySet = false;
-//
-//    //! Access to the client address is mutex protected as it is set by another task.
-//    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-//    dur_millis_t mutexTimeoutMs = 20;
-//    MutexIF* mutex;
-//};
-//
-//#endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
diff --git a/osal/linux/tcpipHelpers.cpp b/osal/linux/tcpipHelpers.cpp
index 1c3807696..4c1b9a780 100644
--- a/osal/linux/tcpipHelpers.cpp
+++ b/osal/linux/tcpipHelpers.cpp
@@ -1,4 +1,4 @@
-#include "tcpipHelpers.h"
+#include "../common/tcpipHelpers.h"
 
 #include "../../tasks/TaskFactory.h"
 
diff --git a/osal/linux/tcpipHelpers.h b/osal/linux/tcpipHelpers.h
deleted file mode 100644
index 6b337c62d..000000000
--- a/osal/linux/tcpipHelpers.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifndef FSFW_OSAL_LINUX_TCPIPHELPERS_H_
-#define FSFW_OSAL_LINUX_TCPIPHELPERS_H_
-
-#include "../../timemanager/clockDefinitions.h"
-#include "../common/tcpipCommon.h"
-
-namespace tcpip {
-
-
-void handleError(Protocol protocol, ErrorSources errorSrc, dur_millis_t sleepDuration = 0);
-
-}
-
-#endif /* FSFW_OSAL_LINUX_TCPIPHELPERS_H_ */

From 078116c7be61cd5bd74e1b8c49c87950a6dab7ef Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 21 Mar 2021 14:38:28 +0100
Subject: [PATCH 1720/1774] generic windows udp bridge working as well

---
 osal/common/TcpIpBase.cpp        | 37 ++++++++++++++++----------------
 osal/common/UdpTcPollingTask.cpp |  2 +-
 osal/common/UdpTmTcBridge.cpp    | 10 +--------
 osal/common/UdpTmTcBridge.h      |  8 ++++++-
 4 files changed, 28 insertions(+), 29 deletions(-)

diff --git a/osal/common/TcpIpBase.cpp b/osal/common/TcpIpBase.cpp
index 35524743d..279fd1c46 100644
--- a/osal/common/TcpIpBase.cpp
+++ b/osal/common/TcpIpBase.cpp
@@ -8,32 +8,16 @@
 #endif
 
 TcpIpBase::TcpIpBase() {
-    closeSocket(serverSocket);
+
 }
 
 TcpIpBase::~TcpIpBase() {
+    closeSocket(serverSocket);
 #ifdef _WIN32
     WSACleanup();
 #endif
 }
 
-
-int TcpIpBase::closeSocket(socket_t socket) {
-#ifdef _WIN32
-    return closesocket(socket);
-#elif defined(__unix__)
-    return close(socket);
-#endif
-}
-
-int TcpIpBase::getLastSocketError() {
-#ifdef _WIN32
-    return WSAGetLastError();
-#elif defined(__unix__)
-    return errno;
-#endif
-}
-
 ReturnValue_t TcpIpBase::initialize() {
 #ifdef _WIN32
     /* Initiates Winsock DLL. */
@@ -51,3 +35,20 @@ ReturnValue_t TcpIpBase::initialize() {
 #endif
     return HasReturnvaluesIF::RETURN_OK;
 }
+
+int TcpIpBase::closeSocket(socket_t socket) {
+#ifdef _WIN32
+    return closesocket(socket);
+#elif defined(__unix__)
+    return close(socket);
+#endif
+}
+
+int TcpIpBase::getLastSocketError() {
+#ifdef _WIN32
+    return WSAGetLastError();
+#elif defined(__unix__)
+    return errno;
+#endif
+}
+
diff --git a/osal/common/UdpTcPollingTask.cpp b/osal/common/UdpTcPollingTask.cpp
index bace593f3..759cee057 100644
--- a/osal/common/UdpTcPollingTask.cpp
+++ b/osal/common/UdpTcPollingTask.cpp
@@ -154,7 +154,7 @@ ReturnValue_t UdpTcPollingTask::initializeAfterTaskCreation() {
 void UdpTcPollingTask::setTimeout(double timeoutSeconds) {
 #ifdef _WIN32
     DWORD timeoutMs = timeoutSeconds * 1000.0;
-    int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+    int result = setsockopt(serverSocket, SOL_SOCKET, SO_RCVTIMEO,
             reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
     if(result == -1) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
diff --git a/osal/common/UdpTmTcBridge.cpp b/osal/common/UdpTmTcBridge.cpp
index ae74e94b1..7f3dc9293 100644
--- a/osal/common/UdpTmTcBridge.cpp
+++ b/osal/common/UdpTmTcBridge.cpp
@@ -65,19 +65,11 @@ ReturnValue_t UdpTmTcBridge::initialize() {
 #endif
 
     struct addrinfo *addrResult = nullptr;
-    struct addrinfo hints = { 0 };
+    struct addrinfo hints = {};
 
     hints.ai_family = AF_INET;
     hints.ai_socktype = SOCK_DGRAM;
     hints.ai_protocol = IPPROTO_UDP;
-//#ifdef _WIN32
-//    /* See:
-//    https://docs.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo
-//    and
-//
-//    for information about AI_PASSIVE. */
-//    hints.ai_flags = AI_PASSIVE;
-//#endif
 
     /* Set up UDP socket:
     https://en.wikipedia.org/wiki/Getaddrinfo
diff --git a/osal/common/UdpTmTcBridge.h b/osal/common/UdpTmTcBridge.h
index afc8ee98e..6f38034e9 100644
--- a/osal/common/UdpTmTcBridge.h
+++ b/osal/common/UdpTmTcBridge.h
@@ -4,8 +4,14 @@
 #include "TcpIpBase.h"
 #include "../../tmtcservices/TmTcBridge.h"
 
-#ifdef __unix__
+#ifdef _WIN32
+
+#include <ws2tcpip.h>
+
+#elif defined(__unix__)
+
 #include <sys/socket.h>
+
 #endif
 
 #include <string>

From e3c44fd27f8a8a20ad25d291d7cc6e96e0e43114 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 21 Mar 2021 16:20:13 +0100
Subject: [PATCH 1721/1774] implemented deadlien missed print for host

---
 osal/host/PeriodicTask.cpp      |  33 ++------
 osal/host/TaskFactory.cpp       |  39 +++++++++-
 osal/linux/PosixThread.cpp      |  16 ++--
 osal/windows/CMakeLists.txt     |   1 +
 osal/windows/winTaskHelpers.cpp | 130 ++++++++++++++++++++++++++++++++
 osal/windows/winTaskHelpers.h   |  40 ++++++++++
 tasks/TaskFactory.h             |  16 +++-
 tasks/Typedef.h                 |   2 +-
 8 files changed, 236 insertions(+), 41 deletions(-)
 create mode 100644 osal/windows/winTaskHelpers.cpp
 create mode 100644 osal/windows/winTaskHelpers.h

diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 7663d522d..4c0bf338c 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -10,6 +10,7 @@
 
 #if defined(WIN32)
 #include <processthreadsapi.h>
+#include <fsfw/osal/windows/winTaskHelpers.h>
 #elif defined(LINUX)
 #include <pthread.h>
 #endif
@@ -22,33 +23,11 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
     // 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) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-#endif
-    }
-    result = SetThreadPriority(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            THREAD_PRIORITY_NORMAL);
-    if(result != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-#endif
-    }
-#elif defined(LINUX)
-    // we can just copy and paste the code from linux here.
+#if defined(_WIN32)
+	tasks::setTaskPriority(reinterpret_cast<HANDLE>(mainThread.native_handle()), setPriority);
+	tasks::insertTaskName(mainThread.get_id(), taskName);
+#elif defined(__unix__)
+    // TODO: We could reuse existing code here.
 #endif
 }
 
diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
index 4fafd3491..4ac44364e 100644
--- a/osal/host/TaskFactory.cpp
+++ b/osal/host/TaskFactory.cpp
@@ -1,14 +1,20 @@
+#include "../../tasks/TaskFactory.h"
 #include "../../osal/host/FixedTimeslotTask.h"
 #include "../../osal/host/PeriodicTask.h"
-#include "../../tasks/TaskFactory.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include "../../tasks/PeriodicTaskIF.h"
 
+#ifdef _WIN32
+
+#include "../windows/winTaskHelpers.h"
+
+#endif
+
 #include <chrono>
 
 TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
 
-// Will propably not be used for hosted implementation
+// Not used for the host implementation for now because C++ thread abstraction is used
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = 0;
 
 TaskFactory::TaskFactory() {
@@ -49,8 +55,33 @@ ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
 }
 
 void TaskFactory::printMissedDeadline() {
-    /* TODO: Implement */
-    return;
+#ifdef __unix__
+    char name[20] = {0};
+    int status = pthread_getname_np(pthread_self(), name, sizeof(name));
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    if(status == 0) {
+        sif::warning << "TaskFactory::printMissedDeadline: " << name << "" << std::endl;
+    }
+    else {
+        sif::warning << "TaskFactory::printMissedDeadline: Unknown task name" << status <<
+                std::endl;
+    }
+#else
+    if(status == 0) {
+        sif::printWarning("TaskFactory::printMissedDeadline: %s\n", name);
+    }
+    else {
+        sif::printWarning("TaskFactory::printMissedDeadline: Unknown task name\n", name);
+    }
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#elif defined(_WIN32)
+    std::string name = tasks::getTaskName(std::this_thread::get_id());
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "TaskFactory::printMissedDeadline: " << name << std::endl;
+#else
+    sif::printWarning("TaskFactory::printMissedDeadline: %s\n", name);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* defined(_WIN32) */
 }
 
 
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index bd8e72583..5296dfb53 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -6,7 +6,7 @@
 #include <errno.h>
 
 PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
-		thread(0),priority(priority_),stackSize(stackSize_) {
+		thread(0), priority(priority_), stackSize(stackSize_) {
     name[0] = '\0';
     std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
 }
@@ -75,18 +75,18 @@ bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
 
 	if (currentTime_ms < *prevoiusWakeTime_ms) {
 		/* 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. */
+		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 < *prevoiusWakeTime_ms)
 				&& (nextTimeToWake_ms > currentTime_ms)) {
 			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. */
+		/* 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 < *prevoiusWakeTime_ms)
 				|| (nextTimeToWake_ms > currentTime_ms)) {
 			shouldDelay = true;
diff --git a/osal/windows/CMakeLists.txt b/osal/windows/CMakeLists.txt
index 1bb39b37f..36a547658 100644
--- a/osal/windows/CMakeLists.txt
+++ b/osal/windows/CMakeLists.txt
@@ -1,3 +1,4 @@
 target_sources(${LIB_FSFW_NAME} PRIVATE 
     tcpipHelpers.cpp
+    winTaskHelpers.cpp
 )
diff --git a/osal/windows/winTaskHelpers.cpp b/osal/windows/winTaskHelpers.cpp
new file mode 100644
index 000000000..e96cd70ec
--- /dev/null
+++ b/osal/windows/winTaskHelpers.cpp
@@ -0,0 +1,130 @@
+#include <fsfw/osal/windows/winTaskHelpers.h>
+#include <mutex>
+
+std::mutex nameMapLock;
+std::map<std::thread::id, std::string> taskNameMap;
+
+TaskPriority tasks::makeWinPriority(PriorityClass prioClass, PriorityNumber prioNumber) {
+    return (static_cast<uint16_t>(prioClass) << 16) | static_cast<uint16_t> (prioNumber);
+}
+
+void tasks::getWinPriorityParameters(TaskPriority priority,
+        DWORD& priorityClass, int& priorityNumber) {
+    PriorityClass classInternal = static_cast<PriorityClass>(priority >> 16 & 0xff);
+    PriorityNumber numberInternal = static_cast<PriorityNumber>(priority & 0xff);
+    switch(classInternal) {
+    case(CLASS_IDLE): {
+        priorityClass = IDLE_PRIORITY_CLASS;
+        break;
+    }
+    case(CLASS_BELOW_NORMAL): {
+        priorityClass = BELOW_NORMAL_PRIORITY_CLASS;
+        break;
+    }
+    case(CLASS_NORMAL): {
+        priorityClass = NORMAL_PRIORITY_CLASS;
+        break;
+    }
+    case(CLASS_ABOVE_NORMAL): {
+        priorityClass = ABOVE_NORMAL_PRIORITY_CLASS;
+        break;
+    }
+    case(CLASS_HIGH): {
+        priorityClass = HIGH_PRIORITY_CLASS;
+        break;
+    }
+    case(CLASS_REALTIME): {
+        priorityClass = REALTIME_PRIORITY_CLASS;
+        break;
+    }
+    default: {
+        priorityClass = NORMAL_PRIORITY_CLASS;
+    }
+    }
+
+    switch(numberInternal) {
+    case(IDLE): {
+        priorityNumber = THREAD_PRIORITY_IDLE;
+        break;
+    }
+    case(LOWEST): {
+        priorityNumber = THREAD_PRIORITY_LOWEST;
+        break;
+    }
+    case(BELOW_NORMAL): {
+        priorityNumber = THREAD_PRIORITY_BELOW_NORMAL;
+        break;
+    }
+    case(NORMAL): {
+        priorityNumber = THREAD_PRIORITY_NORMAL;
+        break;
+    }
+    case(ABOVE_NORMAL): {
+        priorityNumber = THREAD_PRIORITY_ABOVE_NORMAL;
+        break;
+    }
+    case(HIGHEST): {
+        priorityNumber = THREAD_PRIORITY_HIGHEST;
+        break;
+    }
+    case(CRITICAL): {
+        priorityNumber = THREAD_PRIORITY_TIME_CRITICAL;
+        break;
+    }
+    default: {
+        priorityNumber = THREAD_PRIORITY_NORMAL;
+    }
+    }
+}
+
+ReturnValue_t tasks::setTaskPriority(HANDLE nativeHandle, TaskPriority priority) {
+    /* 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
+    */
+    DWORD dwPriorityClass = 0;
+    int nPriorityNumber = 0;
+    tasks::getWinPriorityParameters(priority, dwPriorityClass, nPriorityNumber);
+    int result = SetPriorityClass(
+            reinterpret_cast<HANDLE>(nativeHandle),
+            dwPriorityClass);
+    if(result != 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+#endif
+    }
+    result = SetThreadPriority(
+            reinterpret_cast<HANDLE>(nativeHandle),
+            nPriorityNumber);
+    if(result != 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+#endif
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t tasks::insertTaskName(std::thread::id threadId, std::string taskName) {
+    std::lock_guard<std::mutex> lg(nameMapLock);
+    auto returnPair = taskNameMap.emplace(threadId, taskName);
+    if(not returnPair.second) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+std::string tasks::getTaskName(std::thread::id threadId) {
+    std::lock_guard<std::mutex> lg(nameMapLock);
+    auto resultIter = taskNameMap.find(threadId);
+    if(resultIter != taskNameMap.end()) {
+        return resultIter->second;
+    }
+    else {
+        return "Unknown task";
+    }
+}
diff --git a/osal/windows/winTaskHelpers.h b/osal/windows/winTaskHelpers.h
new file mode 100644
index 000000000..d17b611a3
--- /dev/null
+++ b/osal/windows/winTaskHelpers.h
@@ -0,0 +1,40 @@
+#include "../../tasks/TaskFactory.h"
+
+#include <thread>
+#include <map>
+
+#ifdef _WIN32
+
+namespace tasks {
+
+enum PriorityClass: uint16_t {
+    CLASS_IDLE,
+    CLASS_BELOW_NORMAL,
+    CLASS_NORMAL,
+    CLASS_ABOVE_NORMAL,
+    CLASS_HIGH,
+    CLASS_REALTIME
+};
+enum PriorityNumber: uint16_t {
+    IDLE,
+    LOWEST,
+    BELOW_NORMAL,
+    NORMAL,
+    ABOVE_NORMAL,
+    HIGHEST,
+    CRITICAL
+};
+TaskPriority makeWinPriority(PriorityClass prioClass = PriorityClass::CLASS_NORMAL,
+        PriorityNumber prioNumber = PriorityNumber::NORMAL);
+void getWinPriorityParameters(TaskPriority priority, DWORD& priorityClass,
+        int& priorityNumber);
+
+ReturnValue_t setTaskPriority(HANDLE nativeHandle, TaskPriority priority);
+
+ReturnValue_t insertTaskName(std::thread::id threadId, std::string taskName);
+std::string getTaskName(std::thread::id threadId);
+
+}
+
+#endif
+
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 03b5163c4..4fba345f5 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -22,9 +22,23 @@ public:
 	/**
 	 * Creates a new periodic task and returns the interface pointer.
 	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
+	 * @param taskPriority_
+	 * Priority of the task. This value might have different ranges for the various OSALs.
+	 * Linux: Value ranging from 0 to 99 with 99 being the highest value.
+	 * Host: Value can be retrieved by using the #tasks::makeWinPriority function.
+	 * FreeRTOS: Value depends on the FreeRTOS configuration, higher number means higher priority
+	 * RTEMS: Values ranging from 0 to 99 with 99 being the highest value.
+	 *
 	 * @param stackSize_ Stack Size of the task
+	 * This value might have different recommended ranges for the various OSALs.
+	 * Linux: Lowest limit is the PeriodicTaskIF::MINIMUM_STACK_SIZE value
+	 * Host: Value is ignored for now because the C++ threading abstraction layer is used.
+	 * FreeRTOS: Stack size in bytes. It is recommended to specify at least 1kB of stack for
+	 * FSFW tasks, but the lowest possible size is specified in the FreeRTOSConfig.h file.
+	 * RTEMS: Lowest limit is the PeriodicTaskIF::MINIMUM_STACK_SIZE value.
+	 *
 	 * @param period_ Period of the task
+	 *
 	 * @param deadLineMissedFunction_ Function to be called if a deadline was missed
 	 * @return PeriodicTaskIF* Pointer to the newly created Task
 	 */
diff --git a/tasks/Typedef.h b/tasks/Typedef.h
index 07d96b00d..55f6bda26 100644
--- a/tasks/Typedef.h
+++ b/tasks/Typedef.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_TASKS_TYPEDEF_H_
 
 typedef const char* TaskName;
-typedef uint8_t TaskPriority;
+typedef uint32_t TaskPriority;
 typedef size_t TaskStackSize;
 typedef double TaskPeriod;
 typedef void (*TaskDeadlineMissedFunction)();

From 614d1ccb7c0cb99acfafef1e137247db44d3e989 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 21 Mar 2021 16:29:04 +0100
Subject: [PATCH 1722/1774] resorted functions

---
 osal/common/TcpIpBase.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/osal/common/TcpIpBase.cpp b/osal/common/TcpIpBase.cpp
index 279fd1c46..27384ecc7 100644
--- a/osal/common/TcpIpBase.cpp
+++ b/osal/common/TcpIpBase.cpp
@@ -11,13 +11,6 @@ TcpIpBase::TcpIpBase() {
 
 }
 
-TcpIpBase::~TcpIpBase() {
-    closeSocket(serverSocket);
-#ifdef _WIN32
-    WSACleanup();
-#endif
-}
-
 ReturnValue_t TcpIpBase::initialize() {
 #ifdef _WIN32
     /* Initiates Winsock DLL. */
@@ -36,6 +29,13 @@ ReturnValue_t TcpIpBase::initialize() {
     return HasReturnvaluesIF::RETURN_OK;
 }
 
+TcpIpBase::~TcpIpBase() {
+    closeSocket(serverSocket);
+#ifdef _WIN32
+    WSACleanup();
+#endif
+}
+
 int TcpIpBase::closeSocket(socket_t socket) {
 #ifdef _WIN32
     return closesocket(socket);

From 0c77ce4dcfc66384758971dab61d9086911bf125 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 22 Mar 2021 15:23:47 +0100
Subject: [PATCH 1723/1774] important bugfix

---
 controller/ExtendedControllerBase.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index d5d43933b..d7f87c981 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -65,7 +65,8 @@ protected:
 
     virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override = 0;
-    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid, store_address_t storeId,
+            bool* clearMessage = nullptr) override = 0;
 };
 
 

From f6afa36b1c1cbb987be63cd7ad9de24e71ec91ba Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 22 Mar 2021 15:24:25 +0100
Subject: [PATCH 1724/1774] small tweak

---
 controller/ExtendedControllerBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index d7f87c981..2c2030bf3 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -66,7 +66,7 @@ protected:
     virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override = 0;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid, store_address_t storeId,
-            bool* clearMessage = nullptr) override = 0;
+            bool* clearMessage) override = 0;
 };
 
 

From 31758833468a063e71854b0eb3046eae2eb17cdf Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 22 Mar 2021 15:28:36 +0100
Subject: [PATCH 1725/1774] oopsie

---
 controller/ExtendedControllerBase.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index 2c2030bf3..d5d43933b 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -65,8 +65,7 @@ protected:
 
     virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override = 0;
-    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid, store_address_t storeId,
-            bool* clearMessage) override = 0;
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
 };
 
 

From 1c021651d73259b61147cfbbf73b9eaca69b0cd8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Mar 2021 11:26:44 +0100
Subject: [PATCH 1726/1774] missing include added

---
 osal/host/TaskFactory.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
index 4ac44364e..1c40c99ac 100644
--- a/osal/host/TaskFactory.cpp
+++ b/osal/host/TaskFactory.cpp
@@ -3,6 +3,7 @@
 #include "../../osal/host/PeriodicTask.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include "../../tasks/PeriodicTaskIF.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 #ifdef _WIN32
 

From d4ab2c6cdbe66d3398720b5d621868fe6a0aa7fd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Mar 2021 11:32:35 +0100
Subject: [PATCH 1727/1774] corrected doc

---
 tasks/TaskFactory.h | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 4fba345f5..7990a9cee 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -24,18 +24,21 @@ public:
 	 * @param name_ Name of the task
 	 * @param taskPriority_
 	 * Priority of the task. This value might have different ranges for the various OSALs.
-	 * Linux: Value ranging from 0 to 99 with 99 being the highest value.
-	 * Host: Value can be retrieved by using the #tasks::makeWinPriority function.
-	 * FreeRTOS: Value depends on the FreeRTOS configuration, higher number means higher priority
-	 * RTEMS: Values ranging from 0 to 99 with 99 being the highest value.
+	 *  - Linux     Value ranging from 0 to 99 with 99 being the highest value.
+	 *  - Host      For Windows, the value can be retrieved by using the #tasks::makeWinPriority
+	 *              function. For Linux, same priority system as specified above. MacOS not tested
+	 *              yet
+	 *  - FreeRTOS  Value depends on the FreeRTOS configuration, higher number means higher priority
+	 *  - RTEMS     Values ranging from 0 to 99 with 99 being the highest value.
 	 *
 	 * @param stackSize_ Stack Size of the task
 	 * This value might have different recommended ranges for the various OSALs.
-	 * Linux: Lowest limit is the PeriodicTaskIF::MINIMUM_STACK_SIZE value
-	 * Host: Value is ignored for now because the C++ threading abstraction layer is used.
-	 * FreeRTOS: Stack size in bytes. It is recommended to specify at least 1kB of stack for
-	 * FSFW tasks, but the lowest possible size is specified in the FreeRTOSConfig.h file.
-	 * RTEMS: Lowest limit is the PeriodicTaskIF::MINIMUM_STACK_SIZE value.
+	 *  - Linux     Lowest limit is the PeriodicTaskIF::MINIMUM_STACK_SIZE value
+	 *  - Host      Value is ignored for now because the C++ threading abstraction layer is used.
+	 *  - FreeRTOS  Stack size in bytes. It is recommended to specify at least 1kB of stack for
+	 *              FSFW tasks, but the lowest possible size is specified in the
+	 *              FreeRTOSConfig.h file.
+	 *  - RTEMS     Lowest limit is specified the PeriodicTaskIF::MINIMUM_STACK_SIZE value.
 	 *
 	 * @param period_ Period of the task
 	 *

From 1d3d2be853232ab113e789cb61c07afff2e40194 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Mar 2021 11:33:40 +0100
Subject: [PATCH 1728/1774] more doc

---
 tasks/TaskFactory.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 7990a9cee..d4795202c 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -51,7 +51,8 @@ public:
 			TaskDeadlineMissedFunction deadLineMissedFunction_);
 
 	/**
-	 *
+	 * The meaning for the variables for fixed timeslot tasks is the same as for periodic tasks.
+	 * See #createPeriodicTask documentation.
 	 * @param name_ Name of the task
 	 * @param taskPriority_ Priority of the task
 	 * @param stackSize_ Stack Size of the task

From b1670decf73776e4742af39791583d5d35bb2e54 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Mar 2021 11:35:23 +0100
Subject: [PATCH 1729/1774] Using C++ way of zero initializing struct

---
 osal/common/TcpTmTcServer.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/common/TcpTmTcServer.cpp b/osal/common/TcpTmTcServer.cpp
index 2da5da954..296afad8e 100644
--- a/osal/common/TcpTmTcServer.cpp
+++ b/osal/common/TcpTmTcServer.cpp
@@ -33,7 +33,7 @@ ReturnValue_t TcpTmTcServer::initialize() {
 
     int retval = 0;
     struct addrinfo *addrResult = nullptr;
-    struct addrinfo hints = { 0 };
+    struct addrinfo hints = {};
 
     hints.ai_family = AF_INET;
     hints.ai_socktype = SOCK_STREAM;

From a5f44b858035d2d931ee79c622dfe7ab11c3a7f9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Mar 2021 14:25:50 +0100
Subject: [PATCH 1730/1774] doc updatedoc updatedd

---
 osal/common/UdpTcPollingTask.h | 9 ++-------
 osal/common/UdpTmTcBridge.h    | 4 ++++
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/osal/common/UdpTcPollingTask.h b/osal/common/UdpTcPollingTask.h
index ae1c4c442..052eced52 100644
--- a/osal/common/UdpTcPollingTask.h
+++ b/osal/common/UdpTcPollingTask.h
@@ -9,13 +9,8 @@
 #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.
+ * @brief   This class should be used with the UdpTmTcBridge to implement a UDP server
+ *          for receiving and sending PUS TMTC.
  */
 class UdpTcPollingTask:
         public TcpIpBase,
diff --git a/osal/common/UdpTmTcBridge.h b/osal/common/UdpTmTcBridge.h
index 6f38034e9..8b8d19491 100644
--- a/osal/common/UdpTmTcBridge.h
+++ b/osal/common/UdpTmTcBridge.h
@@ -16,6 +16,10 @@
 
 #include <string>
 
+/**
+ * @brief   This class should be used with the UdpTcPollingTask to implement a UDP server
+ *          for receiving and sending PUS TMTC.
+ */
 class UdpTmTcBridge:
         public TmTcBridge,
         public TcpIpBase {

From bdd9889718a26e130f43c9439033e68f28436cf1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Mar 2021 14:28:01 +0100
Subject: [PATCH 1731/1774] pool read guard in scope

---
 internalError/InternalErrorReporter.cpp | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index af9acc0d0..786184484 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -53,12 +53,14 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
     }
 #endif
 
-    PoolReadGuard readGuard(&internalErrorDataset);
-    if(readGuard.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
-        internalErrorDataset.queueHits.value += newQueueHits;
-        internalErrorDataset.storeHits.value += newStoreHits;
-        internalErrorDataset.tmHits.value += newTmHits;
-        internalErrorDataset.setValidity(true, true);
+    {
+        PoolReadGuard readGuard(&internalErrorDataset);
+        if(readGuard.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+            internalErrorDataset.queueHits.value += newQueueHits;
+            internalErrorDataset.storeHits.value += newStoreHits;
+            internalErrorDataset.tmHits.value += newTmHits;
+            internalErrorDataset.setValidity(true, true);
+        }
     }
 
     poolManager.performHkOperation();

From d781c6fcecceef0602a147ffbecf7255f24fdcfd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Mar 2021 14:40:30 +0100
Subject: [PATCH 1732/1774] name storage abstraction available for linux as
 well

---
 osal/host/CMakeLists.txt        |  1 +
 osal/host/PeriodicTask.cpp      |  1 +
 osal/host/TaskFactory.cpp       | 28 +---------------------------
 osal/host/taskHelpers.cpp       | 27 +++++++++++++++++++++++++++
 osal/host/taskHelpers.h         | 16 ++++++++++++++++
 osal/windows/winTaskHelpers.cpp | 23 -----------------------
 osal/windows/winTaskHelpers.h   |  3 ---
 7 files changed, 46 insertions(+), 53 deletions(-)
 create mode 100644 osal/host/taskHelpers.cpp
 create mode 100644 osal/host/taskHelpers.h

diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
index 367f721e0..2d29ce5df 100644
--- a/osal/host/CMakeLists.txt
+++ b/osal/host/CMakeLists.txt
@@ -10,6 +10,7 @@ target_sources(${LIB_FSFW_NAME}
 		QueueMapManager.cpp
 		SemaphoreFactory.cpp
 		TaskFactory.cpp
+		taskHelpers.cpp
 )
 
 if(UNIX)
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 4c0bf338c..4a02ee0df 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -1,5 +1,6 @@
 #include "Mutex.h"
 #include "PeriodicTask.h"
+#include "taskHelpers.h"
 
 #include "../../ipc/MutexFactory.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
index 1c40c99ac..71d0bf8b9 100644
--- a/osal/host/TaskFactory.cpp
+++ b/osal/host/TaskFactory.cpp
@@ -1,3 +1,4 @@
+#include "taskHelpers.h"
 #include "../../tasks/TaskFactory.h"
 #include "../../osal/host/FixedTimeslotTask.h"
 #include "../../osal/host/PeriodicTask.h"
@@ -5,12 +6,6 @@
 #include "../../tasks/PeriodicTaskIF.h"
 #include "../../serviceinterface/ServiceInterface.h"
 
-#ifdef _WIN32
-
-#include "../windows/winTaskHelpers.h"
-
-#endif
-
 #include <chrono>
 
 TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
@@ -56,33 +51,12 @@ ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
 }
 
 void TaskFactory::printMissedDeadline() {
-#ifdef __unix__
-    char name[20] = {0};
-    int status = pthread_getname_np(pthread_self(), name, sizeof(name));
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    if(status == 0) {
-        sif::warning << "TaskFactory::printMissedDeadline: " << name << "" << std::endl;
-    }
-    else {
-        sif::warning << "TaskFactory::printMissedDeadline: Unknown task name" << status <<
-                std::endl;
-    }
-#else
-    if(status == 0) {
-        sif::printWarning("TaskFactory::printMissedDeadline: %s\n", name);
-    }
-    else {
-        sif::printWarning("TaskFactory::printMissedDeadline: Unknown task name\n", name);
-    }
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#elif defined(_WIN32)
     std::string name = tasks::getTaskName(std::this_thread::get_id());
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "TaskFactory::printMissedDeadline: " << name << std::endl;
 #else
     sif::printWarning("TaskFactory::printMissedDeadline: %s\n", name);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* defined(_WIN32) */
 }
 
 
diff --git a/osal/host/taskHelpers.cpp b/osal/host/taskHelpers.cpp
new file mode 100644
index 000000000..be4c29adc
--- /dev/null
+++ b/osal/host/taskHelpers.cpp
@@ -0,0 +1,27 @@
+#include "taskHelpers.h"
+#include <map>
+#include <mutex>
+
+std::mutex nameMapLock;
+std::map<std::thread::id, std::string> taskNameMap;
+
+ReturnValue_t tasks::insertTaskName(std::thread::id threadId, std::string taskName) {
+    std::lock_guard<std::mutex> lg(nameMapLock);
+    auto returnPair = taskNameMap.emplace(threadId, taskName);
+    if(not returnPair.second) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+std::string tasks::getTaskName(std::thread::id threadId) {
+    std::lock_guard<std::mutex> lg(nameMapLock);
+    auto resultIter = taskNameMap.find(threadId);
+    if(resultIter != taskNameMap.end()) {
+        return resultIter->second;
+    }
+    else {
+        return "Unknown task";
+    }
+}
+
diff --git a/osal/host/taskHelpers.h b/osal/host/taskHelpers.h
new file mode 100644
index 000000000..fa00490fb
--- /dev/null
+++ b/osal/host/taskHelpers.h
@@ -0,0 +1,16 @@
+#ifndef FSFW_OSAL_HOST_TASKHELPERS_H_
+#define FSFW_OSAL_HOST_TASKHELPERS_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <thread>
+
+namespace tasks {
+
+ReturnValue_t insertTaskName(std::thread::id threadId, std::string taskName);
+std::string getTaskName(std::thread::id threadId);
+
+}
+
+
+
+#endif /* FSFW_OSAL_HOST_TASKHELPERS_H_ */
diff --git a/osal/windows/winTaskHelpers.cpp b/osal/windows/winTaskHelpers.cpp
index e96cd70ec..6765b952c 100644
--- a/osal/windows/winTaskHelpers.cpp
+++ b/osal/windows/winTaskHelpers.cpp
@@ -1,9 +1,6 @@
 #include <fsfw/osal/windows/winTaskHelpers.h>
 #include <mutex>
 
-std::mutex nameMapLock;
-std::map<std::thread::id, std::string> taskNameMap;
-
 TaskPriority tasks::makeWinPriority(PriorityClass prioClass, PriorityNumber prioNumber) {
     return (static_cast<uint16_t>(prioClass) << 16) | static_cast<uint16_t> (prioNumber);
 }
@@ -108,23 +105,3 @@ ReturnValue_t tasks::setTaskPriority(HANDLE nativeHandle, TaskPriority priority)
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
-
-ReturnValue_t tasks::insertTaskName(std::thread::id threadId, std::string taskName) {
-    std::lock_guard<std::mutex> lg(nameMapLock);
-    auto returnPair = taskNameMap.emplace(threadId, taskName);
-    if(not returnPair.second) {
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-std::string tasks::getTaskName(std::thread::id threadId) {
-    std::lock_guard<std::mutex> lg(nameMapLock);
-    auto resultIter = taskNameMap.find(threadId);
-    if(resultIter != taskNameMap.end()) {
-        return resultIter->second;
-    }
-    else {
-        return "Unknown task";
-    }
-}
diff --git a/osal/windows/winTaskHelpers.h b/osal/windows/winTaskHelpers.h
index d17b611a3..64e526722 100644
--- a/osal/windows/winTaskHelpers.h
+++ b/osal/windows/winTaskHelpers.h
@@ -31,9 +31,6 @@ void getWinPriorityParameters(TaskPriority priority, DWORD& priorityClass,
 
 ReturnValue_t setTaskPriority(HANDLE nativeHandle, TaskPriority priority);
 
-ReturnValue_t insertTaskName(std::thread::id threadId, std::string taskName);
-std::string getTaskName(std::thread::id threadId);
-
 }
 
 #endif

From aaceac81af9061892e8d25e66dec9bf963a21d65 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 23 Mar 2021 14:45:33 +0100
Subject: [PATCH 1733/1774] updated fixed timeslot task

---
 osal/host/FixedTimeslotTask.cpp | 36 +++++++--------------------------
 osal/host/PeriodicTask.cpp      |  4 ++--
 2 files changed, 9 insertions(+), 31 deletions(-)

diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 272d99b9a..3b169b5a2 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -1,9 +1,8 @@
+#include "taskHelpers.h"
 #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"
 
@@ -12,6 +11,7 @@
 
 #if defined(WIN32)
 #include <windows.h>
+#include "../windows/winTaskHelpers.h"
 #elif defined(LINUX)
 #include <pthread.h>
 #endif
@@ -24,34 +24,12 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
     // 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) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-#endif
-    }
-    result = SetThreadPriority(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            THREAD_PRIORITY_NORMAL);
-    if(result != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-#endif
-    }
-#elif defined(LINUX)
-    // TODO: we can just copy and paste the code from the linux OSAL here.
+#if defined(_WIN32)
+    tasks::setTaskPriority(reinterpret_cast<HANDLE>(mainThread.native_handle()), setPriority);
+#elif defined(__unix__)
+    // TODO: We could reuse existing code here.
 #endif
+    tasks::insertTaskName(mainThread.get_id(), taskName);
 }
 
 FixedTimeslotTask::~FixedTimeslotTask(void) {
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 4a02ee0df..d7abf9d0c 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -12,7 +12,7 @@
 #if defined(WIN32)
 #include <processthreadsapi.h>
 #include <fsfw/osal/windows/winTaskHelpers.h>
-#elif defined(LINUX)
+#elif defined(__unix__)
 #include <pthread.h>
 #endif
 
@@ -26,10 +26,10 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 	mainThread = std::thread(&PeriodicTask::taskEntryPoint, this, this);
 #if defined(_WIN32)
 	tasks::setTaskPriority(reinterpret_cast<HANDLE>(mainThread.native_handle()), setPriority);
-	tasks::insertTaskName(mainThread.get_id(), taskName);
 #elif defined(__unix__)
     // TODO: We could reuse existing code here.
 #endif
+    tasks::insertTaskName(mainThread.get_id(), taskName);
 }
 
 PeriodicTask::~PeriodicTask(void) {

From 9e559658a7ab16cc6d600cd0008802ae48069953 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 25 Mar 2021 15:35:05 +0100
Subject: [PATCH 1734/1774] added way to add additional include paths and
 libraries

---
 CMakeLists.txt | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3b0917fd2..6d6fd5ed9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -32,7 +32,9 @@ elseif(${OS_FSFW} STREQUAL linux)
 	set(OS_FSFW_NAME "Linux")
 elseif(${OS_FSFW} STREQUAL  freertos)
 	set(OS_FSFW_NAME "FreeRTOS")
-	target_link_libraries(${LIB_FSFW_NAME} ${LIB_OS_NAME})
+	target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+        ${LIB_OS_NAME}
+	)
 elseif(${OS_FSFW} STREQUAL rtems)
 	set(OS_FSFW_NAME "RTEMS")
 else()
@@ -107,6 +109,21 @@ else()
 	)
 endif()
 
+foreach(INCLUDE_PATH ${FSFW_ADDITIONAL_INC_PATH})
+    if(IS_ABSOLUTE ${INCLUDE_PATH})
+        set(CURR_ABS_INC_PATH "${FREERTOS_PATH}")
+    else()
+        get_filename_component(CURR_ABS_INC_PATH
+            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
+    endif()
+
+    if(CMAKE_VERBOSE)
+        message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
+    endif()
+
+    list(APPEND FSFW_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
+endforeach()
+
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     if(NOT DEFINED FSFW_WARNING_FLAGS)
 	   set(FSFW_WARNING_FLAGS
@@ -140,9 +157,14 @@ target_include_directories(${LIB_FSFW_NAME} INTERFACE
 target_include_directories(${LIB_FSFW_NAME} PRIVATE 
 	${CMAKE_SOURCE_DIR}
 	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_ADD_INC_PATHS_ABS}
 )
 
 target_compile_options(${LIB_FSFW_NAME} PRIVATE 
 	${FSFW_WARNING_FLAGS}
 	${COMPILER_FLAGS}
 )
+
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_ADDITIONAL_LINK_LIBS}
+)
\ No newline at end of file

From 581832e4f433b8e2b32418ab7a24f9ba256fb334 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 25 Mar 2021 18:05:18 +0100
Subject: [PATCH 1735/1774] added unittest folder

---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6d6fd5ed9..58ad644bc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -90,6 +90,7 @@ add_subdirectory(timemanager)
 add_subdirectory(tmstorage)
 add_subdirectory(tmtcpacket)
 add_subdirectory(tmtcservices)
+add_subdirectory(unittest)
 
 # The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
 # If this is not given, we include the default configuration and emit a warning.

From 1d818294e4b697a61f45831bc825793c66d9d40c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 25 Mar 2021 18:48:00 +0100
Subject: [PATCH 1736/1774] added option to remove unused code

---
 CMakeLists.txt | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 58ad644bc..f9f49794f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,13 @@
 cmake_minimum_required(VERSION 3.13)
 
+option(FSFW_GENERATE_SECTIONS
+    "Generate function and data sections. Required to remove unused code" ON
+)
+
+if(FSFW_GENERATE_SECTIONS)
+    option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
+endif()
+
 option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
 # Options to exclude parts of the FSFW from compilation.
 option(FSFW_USE_RMAP "Compile with RMAP" ON)
@@ -135,7 +143,20 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 		  -Wno-psabi
         )
     endif()
-        
+
+    if(FSFW_GENERATE_SECTIONS)
+        target_compile_options(${LIB_FSFW_NAME} PRIVATE
+            "-ffunction-sections"
+            "-fdata-sections"
+        )
+    endif()
+
+    if(FSFW_REMOVE_UNUSED_CODE)
+        target_link_options(${LIB_FSFW_NAME} PRIVATE
+            "Wl,--gc-sections"
+        )
+    endif()
+  
     if(FSFW_WARNING_SHADOW_LOCAL_GCC)
         list(APPEND WARNING_FLAGS "-Wshadow=local")
     endif()

From 3a90578780582e0fd8d06dab3bd44dbef066f012 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 27 Mar 2021 10:40:38 +0100
Subject: [PATCH 1737/1774] minor bridge improveements

---
 tmtcservices/TmTcBridge.cpp | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 228bf4f5d..f99b90516 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -4,6 +4,8 @@
 #include "../serviceinterface/ServiceInterface.h"
 #include "../globalfunctions/arrayprinter.h"
 
+#define TMTCBRIDGE_WIRETAPPING 0
+
 TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
 		object_id_t tmStoreId, object_id_t tcStoreId):
 		SystemObject(objectId),tmStoreId(tmStoreId), tcStoreId(tcStoreId),
@@ -234,17 +236,11 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 
 void TmTcBridge::registerCommConnect() {
 	if(not communicationLinkUp) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		//sif::info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
-#endif
 		communicationLinkUp = true;
 	}
 }
 
 void TmTcBridge::registerCommDisconnect() {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	//sif::info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
-#endif
 	if(communicationLinkUp) {
 		communicationLinkUp = false;
 	}

From eea482b4388dcfd9365a12015588dedc370dd2c1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 27 Mar 2021 21:27:46 +0100
Subject: [PATCH 1738/1774] added specific compile definitions

---
 CMakeLists.txt | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3b0917fd2..852c18b56 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -26,15 +26,20 @@ if(NOT OS_FSFW)
 
 endif()
 
+set(FSFW_OSAL_DEFINITION FSFW_HOST)
+
 if(${OS_FSFW} STREQUAL host)
 	set(OS_FSFW_NAME "Host")
 elseif(${OS_FSFW} STREQUAL linux)
 	set(OS_FSFW_NAME "Linux")
+	set(FSFW_OSAL_DEFINITION FSFW_LINUX)
 elseif(${OS_FSFW} STREQUAL  freertos)
 	set(OS_FSFW_NAME "FreeRTOS")
 	target_link_libraries(${LIB_FSFW_NAME} ${LIB_OS_NAME})
+	set(FSFW_OSAL_DEFINITION FSFW_FREERTOS)
 elseif(${OS_FSFW} STREQUAL rtems)
 	set(OS_FSFW_NAME "RTEMS")
+    set(FSFW_OSAL_DEFINITION FSFW_RTEMS)
 else()
 	message(WARNING 
 		"Invalid operating system for FSFW specified! Setting to host.."
@@ -43,6 +48,10 @@ else()
 	set(OS_FSFW "host")
 endif()
 
+target_compile_definitions(${LIB_FSFW_NAME} INTERFACE PRIVATE
+    ${FSFW_OSAL_DEFINITION}
+)
+
 message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
 
 add_subdirectory(action)

From 3a75be2683ac48ed7efa03e10f97e308fee99323 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 27 Mar 2021 21:51:04 +0100
Subject: [PATCH 1739/1774] this version is working

---
 CMakeLists.txt | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 73b6b8738..ff060d7be 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -58,7 +58,11 @@ else()
 	set(OS_FSFW "host")
 endif()
 
-target_compile_definitions(${LIB_FSFW_NAME} INTERFACE PRIVATE
+target_compile_definitions(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_OSAL_DEFINITION}
+)
+
+target_compile_definitions(${LIB_FSFW_NAME} INTERFACE
     ${FSFW_OSAL_DEFINITION}
 )
 

From 3429918f5e35ed9ed942c946fdf0d19ed6379f26 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 30 Mar 2021 00:25:22 +0200
Subject: [PATCH 1740/1774] fixed cmakelists for linux

---
 osal/CMakeLists.txt | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/osal/CMakeLists.txt b/osal/CMakeLists.txt
index e4f1de7c7..6cda0c88a 100644
--- a/osal/CMakeLists.txt
+++ b/osal/CMakeLists.txt
@@ -10,11 +10,6 @@ elseif(${OS_FSFW} STREQUAL "host")
 	if (WIN32)
 		add_subdirectory(windows)
 	elseif(UNIX)
-		target_sources(${LIB_FSFW_NAME}
-			PUBLIC
-				linux/TcUnixUdpPollingTask.cpp
-				linux/TmTcUnixUdpBridge.cpp
-		)
 	endif ()
 
 else()

From 435c6e641021ce450ba88b1cb57c960a5548f784 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 30 Mar 2021 00:37:10 +0200
Subject: [PATCH 1741/1774] bugfix for linux/host

---
 osal/CMakeLists.txt | 42 +++++++++++++++++++++++-------------------
 1 file changed, 23 insertions(+), 19 deletions(-)

diff --git a/osal/CMakeLists.txt b/osal/CMakeLists.txt
index 6cda0c88a..76b939b1a 100644
--- a/osal/CMakeLists.txt
+++ b/osal/CMakeLists.txt
@@ -1,30 +1,34 @@
 # Check the OS_FSFW variable
 if(${OS_FSFW} STREQUAL "freertos")
-	add_subdirectory(FreeRTOS)
+    add_subdirectory(FreeRTOS)
 elseif(${OS_FSFW} STREQUAL "rtems")
-	add_subdirectory(rtems)
+    add_subdirectory(rtems)
 elseif(${OS_FSFW} STREQUAL "linux")
-	add_subdirectory(linux)
+    add_subdirectory(linux)
 elseif(${OS_FSFW} STREQUAL "host")
-	add_subdirectory(host)
-	if (WIN32)
-		add_subdirectory(windows)
-	elseif(UNIX)
-	endif ()
+    add_subdirectory(host)
+    if (WIN32)
+        add_subdirectory(windows)
+    elseif(UNIX)
+        # We still need to pull in some Linux specific sources
+        target_sources(${LIB_FSFW_NAME} PUBLIC
+            linux/tcpipHelpers.cpp
+        )
+    endif ()
 
 else()
 
-	message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
-	# Not set. Assumuing this is a host build, try to determine host OS
-	if (WIN32)
-		add_subdirectory(host)
-		add_subdirectory(windows)
-	elseif (UNIX)
-		add_subdirectory(linux)
-	else ()
-		# MacOS or other OSes have not been tested yet / are not supported.
-		message(FATAL_ERROR "The host OS could not be determined! Aborting.")
-	endif()
+    message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
+    # Not set. Assumuing this is a host build, try to determine host OS
+    if (WIN32)
+        add_subdirectory(host)
+        add_subdirectory(windows)
+    elseif (UNIX)
+        add_subdirectory(linux)
+    else ()
+        # MacOS or other OSes have not been tested yet / are not supported.
+        message(FATAL_ERROR "The host OS could not be determined! Aborting.")
+    endif()
 
 endif()
 

From 6983ddc3e022bfcf1e78354998e4577b20e146b0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 8 Apr 2021 15:27:03 +0200
Subject: [PATCH 1742/1774] super evil bugfix

---
 osal/linux/MessageQueue.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 60d15dee7..b40ff29b4 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -190,13 +190,14 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
-	}else if(status==0){
+	}
+	else if(status==0) {
 		//Success but no message received
 		return MessageQueueIF::EMPTY;
 	} else {
 		//No message was received. Keep lastPartner anyway, I might send
 		//something later. But still, delete packet content.
-		memset(message->getData(), 0, message->getMaximumMessageSize());
+		memset(message->getBuffer(), 0, message->getMaximumMessageSize());
 		switch(errno){
 		case EAGAIN:
 			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages

From 23e3f2f34f1b68998a8aad6c01691d2e9c97ed65 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 8 Apr 2021 15:39:23 +0200
Subject: [PATCH 1743/1774] now fixed properly

---
 ipc/MessageQueueMessage.cpp | 4 ++++
 ipc/MessageQueueMessage.h   | 1 +
 ipc/MessageQueueMessageIF.h | 1 +
 osal/linux/MessageQueue.cpp | 7 ++++---
 4 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index e97778c3f..1958af54a 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -86,3 +86,7 @@ size_t MessageQueueMessage::getMaximumMessageSize() const {
     return this->MAX_MESSAGE_SIZE;
 }
 
+size_t MessageQueueMessage::getMaximumDataSize() const {
+    return this->MAX_DATA_SIZE;
+}
+
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 5234f64ff..111056caf 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -139,6 +139,7 @@ public:
 	virtual void setMessageSize(size_t messageSize) override;
 	virtual size_t getMinimumMessageSize() const override;
 	virtual size_t getMaximumMessageSize() const override;
+	virtual size_t getMaximumDataSize() const override;
 
 	/**
 	 * @brief	This is a debug method that prints the content.
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 33e01e7d0..893c30b5e 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -72,6 +72,7 @@ public:
     virtual void setMessageSize(size_t messageSize) = 0;
     virtual size_t getMinimumMessageSize() const = 0;
     virtual size_t getMaximumMessageSize() const = 0;
+    virtual size_t getMaximumDataSize() const = 0;
 
 };
 
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index b40ff29b4..8004c045b 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -191,13 +191,14 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	else if(status==0) {
+	else if (status==0) {
 		//Success but no message received
 		return MessageQueueIF::EMPTY;
-	} else {
+	}
+	else {
 		//No message was received. Keep lastPartner anyway, I might send
 		//something later. But still, delete packet content.
-		memset(message->getBuffer(), 0, message->getMaximumMessageSize());
+		memset(message->getData(), 0, message->getMaximumDataSize());
 		switch(errno){
 		case EAGAIN:
 			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages

From 10c3483fe51bfaac7f385332fb0fbc3d9ff1f57e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 8 Apr 2021 16:20:59 +0200
Subject: [PATCH 1744/1774] bugfix for RTEMS

---
 osal/rtems/MessageQueue.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index bfaf35690..717b80dd0 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -61,7 +61,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	} else {
 		//No message was received. Keep lastPartner anyway, I might send something later.
 		//But still, delete packet content.
-		memset(message->getData(), 0, message->getMaximumMessageSize());
+		memset(message->getData(), 0, message->getMaximumDataSize());
 	}
 	return convertReturnCode(status);
 }

From 5676969fe368187507d7a3bf90b153719931fdf3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 11 Apr 2021 21:13:43 +0200
Subject: [PATCH 1745/1774] typo fix

---
 ipc/MessageQueueIF.h           | 2 +-
 osal/FreeRTOS/MessageQueue.cpp | 2 +-
 osal/linux/MessageQueue.cpp    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 1c06521ca..74ccb29a2 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -27,7 +27,7 @@ public:
 	//! Returned if a reply method was called without partner
 	static const ReturnValue_t NO_REPLY_PARTNER = MAKE_RETURN_CODE(3);
 	//! Returned if the target destination is invalid.
-	static constexpr ReturnValue_t DESTINVATION_INVALID = MAKE_RETURN_CODE(4);
+	static constexpr ReturnValue_t DESTINATION_INVALID = MAKE_RETURN_CODE(4);
 
 	virtual ~MessageQueueIF() {}
 	/**
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index c0c82cf11..3a0f654ed 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -135,7 +135,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	QueueHandle_t destination = nullptr;
 
 	if(sendTo == MessageQueueIF::NO_QUEUE or sendTo == 0x00) {
-		return MessageQueueIF::DESTINVATION_INVALID;
+		return MessageQueueIF::DESTINATION_INVALID;
 	}
 	else  {
 		destination = reinterpret_cast<QueueHandle_t>(sendTo);
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 8004c045b..12774a58c 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -373,7 +373,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 					<<"mq_send to: " << sendTo << " sent from "
 					<< sentFrom << std::endl;
 #endif
-			return DESTINVATION_INVALID;
+			return DESTINATION_INVALID;
 		}
 		case EINTR:
 			//The call was interrupted by a signal.

From 01d0bd6c64c68d3a351573203945a35044e341f8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 11 Apr 2021 21:20:45 +0200
Subject: [PATCH 1746/1774] Small patch for CMakeLists file

This adds the additional includes to the interface as well
so libraries linking again fsfw get the additional includes
as well.
---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ff060d7be..8ba6a187e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -184,6 +184,7 @@ endif()
 target_include_directories(${LIB_FSFW_NAME} INTERFACE 
 	${CMAKE_SOURCE_DIR}
 	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_ADD_INC_PATHS_ABS}
 )
 
 # Includes path required to compile FSFW itself as well

From e50d0738ab08f75f7284a5788b8d3174d1e2dac7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 11 Apr 2021 21:22:58 +0200
Subject: [PATCH 1747/1774] bumped version to 1.0.0

---
 FSFWVersion.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/FSFWVersion.h b/FSFWVersion.h
index 11a608919..df2d49a51 100644
--- a/FSFWVersion.h
+++ b/FSFWVersion.h
@@ -3,9 +3,9 @@
 
 const char* const FSFW_VERSION_NAME = "ASTP";
 
-#define FSFW_VERSION 		0
-#define	FSFW_SUBVERSION 	0
-#define	FSFW_REVISION 	1
+#define FSFW_VERSION        1
+#define	FSFW_SUBVERSION     0
+#define	FSFW_REVISION       0
 
 
 

From b786b53c35dc64fe0743aec68cb8ef9bcfe2fcfb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 11 Apr 2021 21:54:48 +0200
Subject: [PATCH 1748/1774] added all coverity fixes

---
 action/ActionHelper.cpp                 |  5 -----
 container/SharedRingBuffer.cpp          |  3 +++
 container/SharedRingBuffer.h            | 23 +++++++++++++----------
 datapool/HkSwitchHelper.cpp             |  2 +-
 datapoollocal/LocalDataPoolManager.cpp  | 22 ++++++++++++----------
 devicehandlers/DeviceHandlerBase.cpp    |  9 ++++++---
 events/EventMessage.cpp                 |  2 +-
 events/EventMessage.h                   |  2 +-
 globalfunctions/arrayprinter.cpp        |  4 ++--
 health/HealthTable.cpp                  | 24 ++++++++++++++++++++----
 osal/FreeRTOS/Clock.cpp                 |  2 +-
 osal/common/TcpTmTcServer.cpp           |  7 +++++--
 osal/host/FixedTimeslotTask.cpp         | 10 ++++++----
 osal/host/PeriodicTask.cpp              |  1 -
 osal/host/QueueMapManager.cpp           |  4 ++++
 osal/host/QueueMapManager.h             |  2 ++
 pus/CService200ModeCommanding.cpp       |  3 +--
 pus/Service1TelecommandVerification.cpp |  4 +++-
 pus/Service20ParameterManagement.cpp    |  5 ++---
 pus/Service5EventReporting.cpp          |  4 +++-
 pus/Service8FunctionManagement.cpp      |  6 ++++--
 pus/servicepackets/Service8Packets.h    |  4 ++--
 tmtcservices/TmTcBridge.cpp             |  4 +++-
 23 files changed, 95 insertions(+), 57 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 4b64a40ca..b2374ed69 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -147,11 +147,6 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
         return result;
     }
 
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        ipcStore->deleteData(storeAddress);
-        return result;
-    }
-
     /* We don't need to report the objectId, as we receive REQUESTED data before the completion
     success message. True aperiodic replies need to be reported with another dedicated message. */
     ActionMessage::setDataReply(&reply, replyId, storeAddress);
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 5e20bb6fe..fe36341dd 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -17,6 +17,9 @@ SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
     mutex = MutexFactory::instance()->createMutex();
 }
 
+SharedRingBuffer::~SharedRingBuffer() {
+    MutexFactory::instance()->deleteMutex(mutex);
+}
 
 void SharedRingBuffer::setToUseReceiveSizeFIFO(size_t fifoDepth) {
     this->fifoDepth = fifoDepth;
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 66a119ab0..9d6ea56c2 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -26,6 +26,18 @@ public:
      */
     SharedRingBuffer(object_id_t objectId, const size_t size,
             bool overwriteOld, size_t maxExcessBytes);
+    /**
+     * This constructor takes an external buffer with the specified size.
+     * @param buffer
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+     */
+    SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
+            bool overwriteOld, size_t maxExcessBytes);
+
+    virtual~ SharedRingBuffer();
 
     /**
      * @brief    This function can be used to add an optional FIFO to the class
@@ -37,16 +49,7 @@ public:
      */
     void setToUseReceiveSizeFIFO(size_t fifoDepth);
 
-    /**
-     * This constructor takes an external buffer with the specified size.
-     * @param buffer
-     * @param size
-     * @param overwriteOld
-     * If the ring buffer is overflowing at a write operartion, the oldest data
-     * will be overwritten.
-     */
-    SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
-            bool overwriteOld, size_t maxExcessBytes);
+
 
     /**
      * Unless a read-only constant value is read, all operations on the
diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp
index 1a2a25eb9..21e37f59d 100644
--- a/datapool/HkSwitchHelper.cpp
+++ b/datapool/HkSwitchHelper.cpp
@@ -7,7 +7,7 @@ HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
 }
 
 HkSwitchHelper::~HkSwitchHelper() {
-	// TODO Auto-generated destructor stub
+    QueueFactory::instance()->deleteMessageQueue(actionQueue);
 }
 
 ReturnValue_t HkSwitchHelper::initialize() {
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 94ee9c264..dbe68ff14 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -909,27 +909,29 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 			errorPrint = "Unknown error";
 		}
 	}
+	object_id_t objectId = 0xffffffff;
+	if(owner != nullptr) {
+	    objectId = owner->getObjectId();
+	}
 
 	if(outputType == sif::OutputTypes::OUT_WARNING) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalDataPoolManager::" << functionName
-				<< ": Object ID 0x" << std::setw(8) << std::setfill('0')
-				<< std::hex << owner->getObjectId() << " | " << errorPrint
-				<< std::dec << std::setfill(' ') << std::endl;
+		sif::warning << "LocalDataPoolManager::" << functionName << ": Object ID 0x" <<
+		        std::setw(8) << std::setfill('0') << std::hex << objectId << " | " << errorPrint <<
+		        std::dec << std::setfill(' ') << std::endl;
 #else
 		sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
-				functionName, owner->getObjectId(), errorPrint);
+				functionName, objectId, errorPrint);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 	}
 	else if(outputType == sif::OutputTypes::OUT_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "LocalDataPoolManager::" << functionName
-				<< ": Object ID 0x" << std::setw(8) << std::setfill('0')
-				<< std::hex << owner->getObjectId() << " | " << errorPrint
-				<< std::dec << std::setfill(' ') << std::endl;
+		sif::error << "LocalDataPoolManager::" << functionName << ": Object ID 0x" <<
+		        std::setw(8) << std::setfill('0') << std::hex << objectId << " | " << errorPrint <<
+		        std::dec << std::setfill(' ') << std::endl;
 #else
 		sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
-				functionName, owner->getObjectId(), errorPrint);
+				functionName, objectId, errorPrint);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 	}
 #endif /* #if FSFW_VERBOSE_LEVEL >= 1 */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 15eac11f4..531a0642b 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1483,7 +1483,7 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
         if(errorCode == ObjectManagerIF::CHILD_INIT_FAILED) {
             errorPrint = "Initialization error";
         }
-        if(errorCode == HasReturnvaluesIF::RETURN_FAILED) {
+        else if(errorCode == HasReturnvaluesIF::RETURN_FAILED) {
             if(errorType == sif::OutputTypes::OUT_WARNING) {
                 errorPrint = "Generic Warning";
             }
@@ -1495,6 +1495,9 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
             errorPrint = "Unknown error";
         }
     }
+    if(functionName == nullptr) {
+        functionName = "unknown function";
+    }
 
     if(errorType == sif::OutputTypes::OUT_WARNING) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -1504,7 +1507,7 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
                 << std::setfill(' ') << std::endl;
 #else
         sif::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
-                this->getObjectId(), errorPrint);
+                functionName, this->getObjectId(), errorPrint);
 #endif
     }
     else if(errorType == sif::OutputTypes::OUT_ERROR) {
@@ -1515,7 +1518,7 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
                 << std::setfill(' ') << std::endl;
 #else
         sif::printError("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
-                this->getObjectId(), errorPrint);
+                functionName, this->getObjectId(), errorPrint);
 #endif
     }
 
diff --git a/events/EventMessage.cpp b/events/EventMessage.cpp
index bbc41e100..548b4f0f3 100644
--- a/events/EventMessage.cpp
+++ b/events/EventMessage.cpp
@@ -109,6 +109,6 @@ bool EventMessage::isClearedEventMessage() {
 	return getEvent() == INVALID_EVENT;
 }
 
-size_t EventMessage::getMinimumMessageSize() {
+size_t EventMessage::getMinimumMessageSize() const {
 	return EVENT_MESSAGE_SIZE;
 }
diff --git a/events/EventMessage.h b/events/EventMessage.h
index 4d003bd7b..f2f5ffb50 100644
--- a/events/EventMessage.h
+++ b/events/EventMessage.h
@@ -45,7 +45,7 @@ public:
 
 protected:
 	static const Event INVALID_EVENT = 0;
-	virtual size_t getMinimumMessageSize();
+	virtual size_t getMinimumMessageSize() const override;
 
 };
 
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index 20a64f5b6..0423360b9 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -51,7 +51,7 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 #else
     // General format: 0x01, 0x02, 0x03 so it is number of chars times 6
     // plus line break plus small safety margin.
-    char printBuffer[(size + 1) * 7 + 1];
+    char printBuffer[(size + 1) * 7 + 1] = {};
     size_t currentPos = 0;
     for(size_t i = 0; i < size; i++) {
         // To avoid buffer overflows.
@@ -94,7 +94,7 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
 #else
     // General format: 32, 243, -12 so it is number of chars times 5
     // plus line break plus small safety margin.
-    char printBuffer[(size + 1) * 5 + 1];
+    char printBuffer[(size + 1) * 5 + 1] = {};
     size_t currentPos = 0;
     for(size_t i = 0; i < size; i++) {
         // To avoid buffer overflows.
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 5d720b191..3fed1deb1 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -68,14 +68,30 @@ void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
     MutexGuard(mutex, timeoutType, mutexTimeoutMs);
 	size_t size = 0;
 	uint16_t count = healthMap.size();
-	SerializeAdapter::serialize(&count,
+	ReturnValue_t result = SerializeAdapter::serialize(&count,
 			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	    sif::warning << "HealthTable::printAll: Serialization of health table failed" << std::endl;
+#else
+	    sif::printWarning("HealthTable::printAll: Serialization of health table failed\n");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+	    return;
+	}
 	for (const auto& health: healthMap) {
-		SerializeAdapter::serialize(&health.first,
+		result = SerializeAdapter::serialize(&health.first,
 				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+		    return;
+		}
 		uint8_t healthValue = health.second;
-		SerializeAdapter::serialize(&healthValue, &pointer, &size,
+		result = SerializeAdapter::serialize(&healthValue, &pointer, &size,
 				maxSize, SerializeIF::Endianness::BIG);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return;
+        }
 	}
 }
 
@@ -86,7 +102,7 @@ ReturnValue_t HealthTable::iterate(HealthEntry *value, bool reset) {
 		mapIterator = healthMap.begin();
 	}
 	if (mapIterator == healthMap.end()) {
-		result = HasReturnvaluesIF::RETURN_FAILED;
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	*value = *mapIterator;
 	mapIterator++;
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index 806edcc7c..c15971fee 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -111,7 +111,7 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 
 ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
         timeval* to) {
-    struct tm time_tm;
+    struct tm time_tm = {};
 
     time_tm.tm_year = from->year - 1900;
     time_tm.tm_mon = from->month - 1;
diff --git a/osal/common/TcpTmTcServer.cpp b/osal/common/TcpTmTcServer.cpp
index 296afad8e..08a62ffb9 100644
--- a/osal/common/TcpTmTcServer.cpp
+++ b/osal/common/TcpTmTcServer.cpp
@@ -70,6 +70,7 @@ ReturnValue_t TcpTmTcServer::initialize() {
 #endif
         freeaddrinfo(addrResult);
         handleError(Protocol::TCP, ErrorSources::BIND_CALL);
+        return HasReturnvaluesIF::RETURN_FAILED;
     }
 
     freeaddrinfo(addrResult);
@@ -84,8 +85,8 @@ TcpTmTcServer::~TcpTmTcServer() {
 ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
     using namespace tcpip;
     /* If a connection is accepted, the corresponding socket will be assigned to the new socket */
-    socket_t clientSocket;
-    sockaddr clientSockAddr;
+    socket_t clientSocket = 0;
+    sockaddr clientSockAddr = {};
     socklen_t connectorSockAddrLen = 0;
     int retval = 0;
 
@@ -101,6 +102,7 @@ ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
 
         if(clientSocket == INVALID_SOCKET) {
             handleError(Protocol::TCP, ErrorSources::ACCEPT_CALL, 500);
+            closeSocket(clientSocket);
             continue;
         };
 
@@ -122,6 +124,7 @@ ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
 
         /* Done, shut down connection */
         retval = shutdown(clientSocket, SHUT_SEND);
+        closeSocket(clientSocket);
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 3b169b5a2..89daa2786 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -3,7 +3,7 @@
 #include "../../ipc/MutexFactory.h"
 #include "../../osal/host/Mutex.h"
 #include "../../osal/host/FixedTimeslotTask.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../tasks/ExecutableObjectIF.h"
 
 #include <thread>
@@ -38,7 +38,6 @@ FixedTimeslotTask::~FixedTimeslotTask(void) {
     if(mainThread.joinable()) {
         mainThread.join();
     }
-    delete this;
 }
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
@@ -119,8 +118,11 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
     }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "Component " << std::hex << componentId <<
-            " not found, not adding it to pst" << std::endl;
+    sif::error << "Component " << std::hex << "0x" << componentId << "not found, "
+            "not adding it to PST.." << std::dec << std::endl;
+#else
+    sif::printError("Component 0x%08x not found, not adding it to PST..\n",
+            static_cast<unsigned int>(componentId));
 #endif
     return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index d7abf9d0c..631264b74 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -38,7 +38,6 @@ PeriodicTask::~PeriodicTask(void) {
 	if(mainThread.joinable()) {
 		mainThread.join();
 	}
-	delete this;
 }
 
 void PeriodicTask::taskEntryPoint(void* argument) {
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index b50d62dcf..c9100fe9a 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -10,6 +10,10 @@ QueueMapManager::QueueMapManager() {
     mapLock = MutexFactory::instance()->createMutex();
 }
 
+QueueMapManager::~QueueMapManager() {
+    MutexFactory::instance()->deleteMutex(mapLock);
+}
+
 QueueMapManager* QueueMapManager::instance() {
 	if (mqManagerInstance == nullptr){
 		mqManagerInstance = new QueueMapManager();
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
index 3610ca638..90c39c2f0 100644
--- a/osal/host/QueueMapManager.h
+++ b/osal/host/QueueMapManager.h
@@ -36,6 +36,8 @@ public:
 private:
 	//! External instantiation is forbidden.
 	QueueMapManager();
+	~QueueMapManager();
+
 	uint32_t queueCounter = 0;
 	MutexIF* mapLock;
 	QueueMap queueMap;
diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index c4e99359b..70caadd10 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -61,8 +61,7 @@ ReturnValue_t CService200ModeCommanding::prepareCommand(
 		return result;
 	}
 
-	ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
-	        ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
+	ModeMessage::setModeMessage(message, ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
 	        modeCommandPacket.getSubmode());
 	return result;
 }
diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index 9e86c752a..7ce75478b 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -15,7 +15,9 @@ Service1TelecommandVerification::Service1TelecommandVerification(
 	tmQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }
 
-Service1TelecommandVerification::~Service1TelecommandVerification() {}
+Service1TelecommandVerification::~Service1TelecommandVerification() {
+    QueueFactory::instance()->deleteMessageQueue(tmQueue);
+}
 
 MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
 	return tmQueue->getId();
diff --git a/pus/Service20ParameterManagement.cpp b/pus/Service20ParameterManagement.cpp
index bc3a9119b..90e966500 100644
--- a/pus/Service20ParameterManagement.cpp
+++ b/pus/Service20ParameterManagement.cpp
@@ -75,9 +75,8 @@ ReturnValue_t Service20ParameterManagement::checkInterfaceAndAcquireMessageQueue
 #else
         sif::printError("Service20ParameterManagement::checkInterfaceAndAcquire"
                 "MessageQueue: Can't access object\n");
-        sif::printError("Object ID: 0x%08x\n", objectId);
-        sif::printError("Make sure it implements "
-                "ReceivesParameterMessagesIF!\n");
+        sif::printError("Object ID: 0x%08x\n", *objectId);
+        sif::printError("Make sure it implements ReceivesParameterMessagesIF!\n");
 #endif
 
         return CommandingServiceBase::INVALID_OBJECT;
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index 29eb7f20e..965a27ad6 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -15,7 +15,9 @@ Service5EventReporting::Service5EventReporting(object_id_t objectId,
 	eventQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }
 
-Service5EventReporting::~Service5EventReporting(){}
+Service5EventReporting::~Service5EventReporting() {
+    QueueFactory::instance()->deleteMessageQueue(eventQueue);
+}
 
 ReturnValue_t Service5EventReporting::performService() {
 	EventMessage message;
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index a2202abc1..54187a829 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -53,12 +53,14 @@ ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue(
 ReturnValue_t Service8FunctionManagement::prepareCommand(
 		CommandMessage* message, uint8_t subservice, const uint8_t* tcData,
 		size_t tcDataLen, uint32_t* state, object_id_t objectId) {
-	return prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
-				tcData, tcDataLen);
+	return prepareDirectCommand(message, tcData, tcDataLen);
 }
 
 ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
 		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
+    if(message == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
     if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
index b026edf52..a27cf8bb6 100644
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@@ -43,8 +43,8 @@ public:
 
 private:
 	DirectCommand(const DirectCommand &command);
-	object_id_t objectId;
-	ActionId_t actionId;
+	object_id_t objectId = 0;
+	ActionId_t actionId = 0;
 	uint32_t parametersSize; //!< [EXPORT] : [IGNORE]
 	const uint8_t * parameterBuffer; //!< [EXPORT] : [MAXSIZE] 65535 Bytes
 
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index f99b90516..dcffac41e 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -16,7 +16,9 @@ TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
             createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
 }
 
-TmTcBridge::~TmTcBridge() {}
+TmTcBridge::~TmTcBridge() {
+    QueueFactory::instance()->deleteMessageQueue(tmTcReceptionQueue);
+}
 
 ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 		uint8_t sentPacketsPerCycle) {

From 06d34efa749dab1e3b76b47a0fa28d7f52cfd0fb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Apr 2021 12:33:45 +0200
Subject: [PATCH 1749/1774] UDP and TCPIP smaller tweaks

Using AI_PASSIVE now so the UDP server listens to all
addresses (0.0.0.0) instead of just localhost.
Also implemented address print function properly
---
 osal/common/TcpTmTcServer.cpp    |  7 ++++--
 osal/common/UdpTcPollingTask.cpp |  9 +++++---
 osal/common/UdpTmTcBridge.cpp    | 22 ++++++++++--------
 osal/common/tcpipCommon.cpp      | 39 ++++++++++++++++++++++++++++++++
 osal/common/tcpipCommon.h        | 11 +++++++--
 5 files changed, 71 insertions(+), 17 deletions(-)

diff --git a/osal/common/TcpTmTcServer.cpp b/osal/common/TcpTmTcServer.cpp
index 296afad8e..08a62ffb9 100644
--- a/osal/common/TcpTmTcServer.cpp
+++ b/osal/common/TcpTmTcServer.cpp
@@ -70,6 +70,7 @@ ReturnValue_t TcpTmTcServer::initialize() {
 #endif
         freeaddrinfo(addrResult);
         handleError(Protocol::TCP, ErrorSources::BIND_CALL);
+        return HasReturnvaluesIF::RETURN_FAILED;
     }
 
     freeaddrinfo(addrResult);
@@ -84,8 +85,8 @@ TcpTmTcServer::~TcpTmTcServer() {
 ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
     using namespace tcpip;
     /* If a connection is accepted, the corresponding socket will be assigned to the new socket */
-    socket_t clientSocket;
-    sockaddr clientSockAddr;
+    socket_t clientSocket = 0;
+    sockaddr clientSockAddr = {};
     socklen_t connectorSockAddrLen = 0;
     int retval = 0;
 
@@ -101,6 +102,7 @@ ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
 
         if(clientSocket == INVALID_SOCKET) {
             handleError(Protocol::TCP, ErrorSources::ACCEPT_CALL, 500);
+            closeSocket(clientSocket);
             continue;
         };
 
@@ -122,6 +124,7 @@ ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
 
         /* Done, shut down connection */
         retval = shutdown(clientSocket, SHUT_SEND);
+        closeSocket(clientSocket);
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/common/UdpTcPollingTask.cpp b/osal/common/UdpTcPollingTask.cpp
index 759cee057..47f67b295 100644
--- a/osal/common/UdpTcPollingTask.cpp
+++ b/osal/common/UdpTcPollingTask.cpp
@@ -15,7 +15,7 @@
 #endif
 
 //! Debugging preprocessor define.
-#define FSFW_UDP_RCV_WIRETAPPING_ENABLED    0
+#define FSFW_UDP_RECV_WIRETAPPING_ENABLED    0
 
 UdpTcPollingTask::UdpTcPollingTask(object_id_t objectId,
         object_id_t tmtcUnixUdpBridge, size_t maxRecvSize,
@@ -66,10 +66,13 @@ ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
             tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::RECVFROM_CALL, 1000);
             continue;
         }
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
+#if FSFW_UDP_RECV_WIRETAPPING_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "UdpTcPollingTask::performOperation: " << bytesReceived <<
                 " bytes received" << std::endl;
+#else
 #endif
+#endif /* FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1 */
 
         ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
         if(result != HasReturnvaluesIF::RETURN_FAILED) {
@@ -84,7 +87,7 @@ ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
 ReturnValue_t UdpTcPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
     store_address_t storeId;
 
-#if FSFW_UDP_RCV_WIRETAPPING_ENABLED == 1
+#if FSFW_UDP_RECV_WIRETAPPING_ENABLED == 1
     arrayprinter::print(receptionBuffer.data(), bytesRead);
 #endif
 
diff --git a/osal/common/UdpTmTcBridge.cpp b/osal/common/UdpTmTcBridge.cpp
index 7f3dc9293..ba23f521b 100644
--- a/osal/common/UdpTmTcBridge.cpp
+++ b/osal/common/UdpTmTcBridge.cpp
@@ -70,6 +70,7 @@ ReturnValue_t UdpTmTcBridge::initialize() {
     hints.ai_family = AF_INET;
     hints.ai_socktype = SOCK_DGRAM;
     hints.ai_protocol = IPPROTO_UDP;
+    hints.ai_flags = AI_PASSIVE;
 
     /* Set up UDP socket:
     https://en.wikipedia.org/wiki/Getaddrinfo
@@ -95,6 +96,10 @@ ReturnValue_t UdpTmTcBridge::initialize() {
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
+#if FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
+    tcpip::printAddress(addrResult->ai_addr);
+#endif
+
     retval = bind(serverSocket, addrResult->ai_addr, static_cast<int>(addrResult->ai_addrlen));
     if(retval != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -103,6 +108,7 @@ ReturnValue_t UdpTmTcBridge::initialize() {
 #endif
         freeaddrinfo(addrResult);
         tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::BIND_CALL);
+        return HasReturnvaluesIF::RETURN_FAILED;
     }
     freeaddrinfo(addrResult);
     return HasReturnvaluesIF::RETURN_OK;
@@ -120,10 +126,8 @@ ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
     /* The target address can be set by different threads so this lock ensures thread-safety */
     MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
 
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-    char ipAddress [15];
-    sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
-            &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+#if FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
+    tcpip::printAddress(&clientAddress);
 #endif
 
     int bytesSent = sendto(
@@ -151,13 +155,11 @@ void UdpTmTcBridge::checkAndSetClientAddress(sockaddr& newAddress) {
     /* The target address can be set by different threads so this lock ensures thread-safety */
     MutexGuard lock(mutex, timeoutType, mutexTimeoutMs);
 
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-    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;
+#if FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
+    tcpip::printAddress(&newAddress);
+    tcpip::printAddress(&clientAddress);
 #endif
+
     registerCommConnect();
 
     /* Set new IP address to reply to */
diff --git a/osal/common/tcpipCommon.cpp b/osal/common/tcpipCommon.cpp
index 9a5e4647c..551e2a426 100644
--- a/osal/common/tcpipCommon.cpp
+++ b/osal/common/tcpipCommon.cpp
@@ -1,4 +1,9 @@
 #include "tcpipCommon.h"
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+#ifdef _WIN32
+#include <ws2tcpip.h>
+#endif
 
 void tcpip::determineErrorStrings(Protocol protocol, ErrorSources errorSrc, std::string &protStr,
         std::string &srcString) {
@@ -34,3 +39,37 @@ void tcpip::determineErrorStrings(Protocol protocol, ErrorSources errorSrc, std:
         srcString = "unknown call";
     }
 }
+
+void tcpip::printAddress(struct sockaddr* addr) {
+    char ipAddress[INET6_ADDRSTRLEN] = {};
+    const char* stringPtr = NULL;
+    switch(addr->sa_family) {
+    case AF_INET: {
+        struct sockaddr_in *addrIn = reinterpret_cast<struct sockaddr_in*>(addr);
+        stringPtr = inet_ntop(AF_INET, &(addrIn->sin_addr), ipAddress, INET_ADDRSTRLEN);
+        break;
+    }
+    case AF_INET6: {
+        struct sockaddr_in6 *addrIn = reinterpret_cast<struct sockaddr_in6*>(addr);
+        stringPtr = inet_ntop(AF_INET6, &(addrIn->sin6_addr), ipAddress, INET6_ADDRSTRLEN);
+        break;
+    }
+    }
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    if(stringPtr == NULL) {
+        sif::debug << "Could not convert IP address to text representation, error code "
+                << errno << std::endl;
+    }
+    else {
+        sif::debug << "IP Address Sender: " <<  ipAddress << std::endl;
+    }
+#else
+    if(stringPtr == NULL) {
+        sif::printDebug("Could not convert IP address to text representation, error code %d\n",
+                errno);
+    }
+    else {
+        sif::printDebug("IP Address Sender: %s\n", ipAddress);
+    }
+#endif
+}
diff --git a/osal/common/tcpipCommon.h b/osal/common/tcpipCommon.h
index dc5ada526..22b914dc1 100644
--- a/osal/common/tcpipCommon.h
+++ b/osal/common/tcpipCommon.h
@@ -4,6 +4,13 @@
 #include "../../timemanager/clockDefinitions.h"
 #include <string>
 
+#ifdef _WIN32
+#include <winsock2.h>
+#else
+#include <netdb.h>
+#include <arpa/inet.h>
+#endif
+
 namespace tcpip {
 
 const char* const DEFAULT_SERVER_PORT = "7301";
@@ -28,8 +35,8 @@ enum class ErrorSources {
 void determineErrorStrings(Protocol protocol, ErrorSources errorSrc, std::string& protStr,
         std::string& srcString);
 
+void printAddress(struct sockaddr* addr);
+
 }
 
-
-
 #endif /* FSFW_OSAL_COMMON_TCPIPCOMMON_H_ */

From 547538fbc5aa9b23d1128f01c100ad5a73b9a520 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Apr 2021 12:38:56 +0200
Subject: [PATCH 1750/1774] proper MQ implementation

---
 osal/host/MessageQueue.cpp | 29 ++++++++++-------------------
 osal/host/MessageQueue.h   |  2 +-
 2 files changed, 11 insertions(+), 20 deletions(-)

diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 18272a68a..41c55a3df 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -64,9 +64,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 		return MessageQueueIF::EMPTY;
 	}
 	MutexGuard mutexLock(queueLock, MutexIF::TimeoutType::WAITING, 20);
-	MessageQueueMessage* currentMessage = &messageQueue.front();
-	std::copy(currentMessage->getBuffer(),
-			currentMessage->getBuffer() + messageSize, message->getBuffer());
+	std::copy(messageQueue.front().data(), messageQueue.front().data() + messageSize,
+	        message->getBuffer());
 	messageQueue.pop();
 	// The last partner is the first uint32_t field in the message
 	this->lastPartner = message->getSender();
@@ -80,7 +79,7 @@ MessageQueueId_t MessageQueue::getLastPartner() const {
 ReturnValue_t MessageQueue::flush(uint32_t* count) {
 	*count = messageQueue.size();
 	// Clears the queue.
-	messageQueue = std::queue<MessageQueueMessage>();
+	messageQueue = std::queue<std::vector<uint8_t>>();
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -106,6 +105,9 @@ bool MessageQueue::isDefaultDestinationSet() const {
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
         bool ignoreFault) {
+    if(message == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 	message->setSender(sentFrom);
 	if(message->getMessageSize() > message->getMaximumMessageSize()) {
 		// Actually, this should never happen or an error will be emitted
@@ -128,21 +130,10 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
-		MutexGuard 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 {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "MessageQueue::sendMessageFromMessageQueue: Message"
-					"is not MessageQueueMessage!" << std::endl;
-#endif
-		}
-
+		MutexGuard mutexLock(targetQueue->queueLock, MutexIF::TimeoutType::WAITING, 20);
+		targetQueue->messageQueue.push(std::vector<uint8_t>(message->getMaximumMessageSize()));
+		memcpy(targetQueue->messageQueue.back().data(), message->getBuffer(),
+		        message->getMaximumMessageSize());
 	}
 	else {
 		return MessageQueueIF::FULL;
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
index 97a9e4915..e965123dc 100644
--- a/osal/host/MessageQueue.h
+++ b/osal/host/MessageQueue.h
@@ -212,7 +212,7 @@ protected:
 	//static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
 private:
-	std::queue<MessageQueueMessage> messageQueue;
+	std::queue<std::vector<uint8_t>> messageQueue;
 	/**
 	 * @brief	The class stores the queue id it got assigned.
 	 * 			If initialization fails, the queue id is set to zero.

From 4bb078c451ddf543e15e27073f5c8edf1642d38e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Apr 2021 12:40:59 +0200
Subject: [PATCH 1751/1774] thermal sensor update

---
 thermal/TemperatureSensor.h | 54 +++++++++++++++++++------------------
 1 file changed, 28 insertions(+), 26 deletions(-)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 2b1fb1f07..ceb8a8617 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -1,11 +1,14 @@
 #ifndef TEMPERATURESENSOR_H_
 #define TEMPERATURESENSOR_H_
 
-#include "../thermal/AbstractTemperatureSensor.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
+#include "tcsDefinitions.h"
+#include "AbstractTemperatureSensor.h"
+
+#include "../datapoollocal/LocalPoolDataSetBase.h"
+#include "../datapoollocal/LocalPoolVariable.h"
 #include "../monitoring/LimitMonitor.h"
 
+
 /**
  * @brief 	This building block handles non-linear value conversion and
  * 			range checks for analog temperature sensors.
@@ -57,27 +60,26 @@ public:
 
 	/**
 	 * Instantiate Temperature Sensor Object.
-	 * @param setObjectid objectId of the sensor object
-	 * @param inputValue Input value which is converted to a temperature
-	 * @param poolVariable Pool Variable to store the temperature value
-	 * @param vectorIndex Vector Index for the sensor monitor
-	 * @param parameters Calculation parameters, temperature limits, gradient limit
-	 * @param datapoolId Datapool ID of the output temperature
-	 * @param outputSet Output dataset for the output temperature to fetch it with read()
+	 * @param setObjectid   objectId of the sensor object
+	 * @param inputValue    Pointer to input value which is converted to a temperature
+	 * @param variableGpid  Global Pool ID of the output value
+	 * @param inputVariable Input variable handle
+	 * @param vectorIndex   Vector Index for the sensor monitor
+	 * @param parameters    Calculation parameters, temperature limits, gradient limit
+	 * @param outputSet     Output dataset for the output temperature to fetch it with read()
 	 * @param thermalModule respective thermal module, if it has one
 	 */
 	TemperatureSensor(object_id_t setObjectid,
-			inputType *inputValue, PoolVariableIF *poolVariable,
-			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
-			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+			inputType *inputValue, gp_id_t variableGpid, PoolVariableIF* inputVariable,
+			uint8_t vectorIndex, Parameters parameters = {0, 0, 0, 0, 0, 0},
+			LocalPoolDataSetBase *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
 			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
-			inputValue(inputValue), poolVariable(poolVariable),
-			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
-			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
-				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+			inputValue(inputValue), poolVariable(inputVariable),
+			outputTemperature(variableGpid, outputSet, PoolVariableIF::VAR_WRITE),
+			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR, poolVariable,
 				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
 				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
-			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
+			oldTemperature(20), uptimeOfOldTemperature({ thermal::INVALID_TEMPERATURE, 0 }) {
 	}
 
 
@@ -98,7 +100,7 @@ protected:
 
 private:
 	void setInvalid() {
-		outputTemperature = INVALID_TEMPERATURE;
+		outputTemperature = thermal::INVALID_TEMPERATURE;
 		outputTemperature.setValid(false);
 		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
 		sensorMonitor.setToInvalid();
@@ -108,11 +110,11 @@ protected:
 
 	UsedParameters parameters;
 
-	inputType * inputValue;
+	inputType* inputValue;
 
-	PoolVariableIF *poolVariable;
+	PoolVariableIF* poolVariable;
 
-	gp_float_t outputTemperature;
+	lp_var_t<float> outputTemperature;
 
 	LimitMonitor<limitType> sensorMonitor;
 
@@ -120,8 +122,8 @@ protected:
 	timeval uptimeOfOldTemperature;
 
 	void doChildOperation() {
-		if (!poolVariable->isValid()
-				|| !healthHelper.healthTable->isHealthy(getObjectId())) {
+		if ((not poolVariable->isValid()) or
+		        (not healthHelper.healthTable->isHealthy(getObjectId()))) {
 			setInvalid();
 			return;
 		}
@@ -152,13 +154,13 @@ protected:
 			}
 		}
 
-		//Check is done against raw limits. SHOULDDO: Why? Using �C would be more easy to handle.
+		//Check is done against raw limits. SHOULDDO: Why? Using C would be more easy to handle.
 		sensorMonitor.doCheck(outputTemperature.value);
 
 		if (sensorMonitor.isOutOfLimits()) {
 			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
 			outputTemperature.setValid(PoolVariableIF::INVALID);
-			outputTemperature = INVALID_TEMPERATURE;
+			outputTemperature = thermal::INVALID_TEMPERATURE;
 		} else {
 			oldTemperature = outputTemperature;
 			uptimeOfOldTemperature = uptime;

From 5124f314f497bcfa8758c7124f63c68fb24eb88c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Apr 2021 12:50:23 +0200
Subject: [PATCH 1752/1774] updated distributor modules

---
 tcdistribution/CCSDSDistributor.cpp |  31 +++++--
 tcdistribution/PUSDistributor.cpp   | 121 ++++++++++++++++------------
 2 files changed, 92 insertions(+), 60 deletions(-)

diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index b795854f2..62cbfbf2b 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -1,8 +1,10 @@
 #include "CCSDSDistributor.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../tmtcpacket/SpacePacketBase.h"
 
+#define CCSDS_DISTRIBUTOR_DEBUGGING     0
+
 CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
 		object_id_t setObjectId):
 		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
@@ -11,26 +13,36 @@ CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
 CCSDSDistributor::~CCSDSDistributor() {}
 
 TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
+#if CCSDS_DISTRIBUTOR_DEBUGGING == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
-//			this->currentMessage.getStorageId().pool_index << ", " <<
-//			this->currentMessage.getStorageId().packet_index << std::endl;
+	sif::debug << "CCSDSDistributor::selectDestination received: " <<
+			this->currentMessage.getStorageId().poolIndex << ", " <<
+			this->currentMessage.getStorageId().packetIndex << std::endl;
+#else
+	sif::printDebug("CCSDSDistributor::selectDestination received: %d, %d\n",
+	        currentMessage.getStorageId().poolIndex, currentMessage.getStorageId().packetIndex);
+#endif
 #endif
 	const uint8_t* packet = nullptr;
 	size_t size = 0;
 	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
 			&packet, &size );
 	if(result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
 				" store failed!" << std::endl;
+#else
+		sif::printError("CCSDSDistributor::selectDestination: Getting data from"
+                " store failed!\n");
+#endif
 #endif
 	}
 	SpacePacketBase currentPacket(packet);
 
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
-//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && CCSDS_DISTRIBUTOR_DEBUGGING == 1
+	sif::info << "CCSDSDistributor::selectDestination has packet with APID " << std::hex <<
+	        currentPacket.getAPID() << std::dec << std::endl;
 #endif
 	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
 	if ( position != this->queueMap.end() ) {
@@ -76,9 +88,14 @@ ReturnValue_t CCSDSDistributor::initialize() {
 	ReturnValue_t status = this->TcDistributor::initialize();
 	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
 	if (this->tcStore == nullptr) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CCSDSDistributor::initialize: Could not initialize"
 	            " TC store!" << std::endl;
+#else
+	    sif::printError("CCSDSDistributor::initialize: Could not initialize"
+                " TC store!\n");
+#endif
 #endif
 	    status = RETURN_FAILED;
 	}
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 00fd9029a..abdd1f8d3 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -1,22 +1,24 @@
 #include "CCSDSDistributorIF.h"
 #include "PUSDistributor.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcservices/PusVerificationReport.h"
 
+#define PUS_DISTRIBUTOR_DEBUGGING     0
+
 PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
-		object_id_t setPacketSource) :
-		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
-		tcStatus(RETURN_FAILED), packetSource(setPacketSource) {}
+        object_id_t setPacketSource) :
+        TcDistributor(setObjectId), checker(setApid), verifyChannel(),
+        tcStatus(RETURN_FAILED), packetSource(setPacketSource) {}
 
 PUSDistributor::~PUSDistributor() {}
 
 PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    // sif:: debug << "PUSDistributor::handlePacket received: "
-    //          << this->current_packet_id.store_index << ", "
-    //          << this->current_packet_id.packet_index << std::endl;
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && PUS_DISTRIBUTOR_DEBUGGING == 1
+    store_address_t storeId = this->currentMessage.getStorageId());
+    sif:: debug << "PUSDistributor::handlePacket received: " << storeId.poolIndex << ", " <<
+            storeId.packetIndex << std::endl;
 #endif
     TcMqMapIter queueMapIt = this->queueMap.end();
     if(this->currentPacket == nullptr) {
@@ -25,15 +27,17 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
     this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
     if (currentPacket->getWholeData() != nullptr) {
         tcStatus = checker.checkPacket(currentPacket);
-#ifdef DEBUG
         if(tcStatus != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::debug << "PUSDistributor::handlePacket: Packet format "
-                    << "invalid, code "<< static_cast<int>(tcStatus)
-                    << std::endl;
+            sif::debug << "PUSDistributor::handlePacket: Packet format invalid, code " <<
+                    static_cast<int>(tcStatus) << std::endl;
+#else
+            sif::printDebug("PUSDistributor::handlePacket: Packet format invalid, code %d\n",
+                    static_cast<int>(tcStatus));
+#endif
 #endif
         }
-#endif
         uint32_t queue_id = currentPacket->getService();
         queueMapIt = this->queueMap.find(queue_id);
     }
@@ -43,11 +47,12 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
 
     if (queueMapIt == this->queueMap.end()) {
         tcStatus = DESTINATION_NOT_FOUND;
-#ifdef DEBUG
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "PUSDistributor::handlePacket: Destination not found, "
-                << "code "<< static_cast<int>(tcStatus) << std::endl;
-#endif
+        sif::debug << "PUSDistributor::handlePacket: Destination not found" << std::endl;
+#else
+        sif::printDebug("PUSDistributor::handlePacket: Destination not found\n");
+#endif /* !FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif
     }
 
@@ -62,46 +67,54 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
 
 
 ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
-	uint16_t serviceId = service->getIdentifier();
+    uint16_t serviceId = service->getIdentifier();
+#if PUS_DISTRIBUTOR_DEBUGGING == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	// sif::info << "Service ID: " << (int)serviceId << std::endl;
+    sif::info << "Service ID: " << static_cast<int>(serviceId) << std::endl;
+#else
+    sif::printInfo("Service ID: %d\n", static_cast<int>(serviceId));
 #endif
-	MessageQueueId_t queue = service->getRequestQueue();
-	auto returnPair = queueMap.emplace(serviceId, queue);
-	if (not returnPair.second) {
+#endif
+    MessageQueueId_t queue = service->getRequestQueue();
+    auto returnPair = queueMap.emplace(serviceId, queue);
+    if (not returnPair.second) {
+#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PUSDistributor::registerService: Service ID already"
-				" exists in map." << std::endl;
+        sif::error << "PUSDistributor::registerService: Service ID already"
+                " exists in map" << std::endl;
+#else
+        sif::printError("PUSDistributor::registerService: Service ID already exists in map\n");
 #endif
-		return SERVICE_ID_ALREADY_EXISTS;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+#endif
+        return SERVICE_ID_ALREADY_EXISTS;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 MessageQueueId_t PUSDistributor::getRequestQueue() {
-	return tcQueue->getId();
+    return tcQueue->getId();
 }
 
 ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
-	if (queueStatus != RETURN_OK) {
-		tcStatus = queueStatus;
-	}
-	if (tcStatus != RETURN_OK) {
-		this->verifyChannel.sendFailureReport(tc_verification::ACCEPTANCE_FAILURE,
-				currentPacket, tcStatus);
-		// A failed packet is deleted immediately after reporting,
-		// otherwise it will block memory.
-		currentPacket->deletePacket();
-		return RETURN_FAILED;
-	} else {
-		this->verifyChannel.sendSuccessReport(tc_verification::ACCEPTANCE_SUCCESS,
-				currentPacket);
-		return RETURN_OK;
-	}
+    if (queueStatus != RETURN_OK) {
+        tcStatus = queueStatus;
+    }
+    if (tcStatus != RETURN_OK) {
+        this->verifyChannel.sendFailureReport(tc_verification::ACCEPTANCE_FAILURE,
+                currentPacket, tcStatus);
+        // A failed packet is deleted immediately after reporting,
+        // otherwise it will block memory.
+        currentPacket->deletePacket();
+        return RETURN_FAILED;
+    } else {
+        this->verifyChannel.sendSuccessReport(tc_verification::ACCEPTANCE_SUCCESS,
+                currentPacket);
+        return RETURN_OK;
+    }
 }
 
 uint16_t PUSDistributor::getIdentifier() {
-	return checker.getApid();
+    return checker.getApid();
 }
 
 ReturnValue_t PUSDistributor::initialize() {
@@ -111,15 +124,17 @@ ReturnValue_t PUSDistributor::initialize() {
         return ObjectManagerIF::CHILD_INIT_FAILED;
     }
 
-	CCSDSDistributorIF* ccsdsDistributor =
-			objectManager->get<CCSDSDistributorIF>(packetSource);
-	if (ccsdsDistributor == nullptr) {
+    CCSDSDistributorIF* ccsdsDistributor =
+            objectManager->get<CCSDSDistributorIF>(packetSource);
+    if (ccsdsDistributor == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PUSDistributor::initialize: Packet source invalid."
-		        << " Make sure it exists and implements CCSDSDistributorIF!"
-		        << std::endl;
+        sif::error << "PUSDistributor::initialize: Packet source invalid" << std::endl;
+        sif::error << " Make sure it exists and implements CCSDSDistributorIF!" << std::endl;
+#else
+        sif::printError("PUSDistributor::initialize: Packet source invalid\n");
+        sif::printError("Make sure it exists and implements CCSDSDistributorIF\n");
 #endif
-	    return RETURN_FAILED;
-	}
-	return ccsdsDistributor->registerApplication(this);
+        return RETURN_FAILED;
+    }
+    return ccsdsDistributor->registerApplication(this);
 }

From 98add88d143105f5c04d17629083d9bab2ee2916 Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Tue, 20 Apr 2021 13:01:24 +0200
Subject: [PATCH 1753/1774] Makes linux realtime optional

Adds new config variable FSFW_USE_REALTIME_FOR_LINUX
---
 defaultcfg/fsfwconfig/FSFWConfig.h | 4 ++++
 osal/host/PeriodicTask.cpp         | 2 +-
 osal/linux/PosixThread.cpp         | 9 ++++++---
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index ed86e6e1f..385808fe4 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -57,6 +57,10 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
 
 static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
+
+//! Defines if the real time scheduler for linux should be used.
+//! If set to 1 the binary needs "cap_sys_nice=eip" privileges to run
+#define FSFW_USE_REALTIME_FOR_LINUX 0
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 7663d522d..0a99b03a3 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -19,7 +19,7 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 		void (*setDeadlineMissedFunc)()) :
 		started(false), taskName(name), period(setPeriod),
 		deadlineMissedFunc(setDeadlineMissedFunc) {
-    // It is propably possible to set task priorities by using the native
+    // It is probably possible to set task priorities by using the native
     // task handles for Windows / Linux
 	mainThread = std::thread(&PeriodicTask::taskEntryPoint, this, this);
 #if defined(WIN32)
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index bd8e72583..ead32e873 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -184,8 +184,11 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 					strerror(status) << std::endl;
 #endif
 	}
-
-	// TODO FIFO -> This needs root privileges for the process
+#ifndef FSFW_USE_REALTIME_FOR_LINUX
+#error "Please define FSFW_USE_REALTIME_FOR_LINUX with either 0 or 1"
+#endif
+#if FSFW_USE_REALTIME_FOR_LINUX == 1
+	// FIFO -> This needs root privileges for the process
 	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
 	if(status != 0){
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -203,7 +206,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 				strerror(status) << std::endl;
 #endif
 	}
-
+#endif
 	//Set Signal Mask for suspend until startTask is called
 	sigset_t waitSignal;
 	sigemptyset(&waitSignal);

From 03095776f16a216edc5d12c0dbc81b7205abb874 Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Tue, 20 Apr 2021 13:31:15 +0200
Subject: [PATCH 1754/1774] Added a comment and corrected a mistake

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 385808fe4..8f82251bd 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -52,15 +52,18 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle
-//! simulataneously. This will increase the required RAM for
+//! Simultaneously. This will increase the required RAM for
 //! each CSB service !
 static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
 
 static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
 
 //! Defines if the real time scheduler for linux should be used.
+//! If set to 0, this will also disable priority settings for linux
+//! as most systems will not allow to set nice values without privileges
+//! For embedded linux system set this to 1.
 //! If set to 1 the binary needs "cap_sys_nice=eip" privileges to run
-#define FSFW_USE_REALTIME_FOR_LINUX 0
+#define FSFW_USE_REALTIME_FOR_LINUX 1
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

From 6873d2b8473469290a268149cb939a745e92e67f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 20 Apr 2021 14:46:59 +0200
Subject: [PATCH 1755/1774] temp sensor update

---
 thermal/TemperatureSensor.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index ceb8a8617..f1e17c559 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -122,6 +122,11 @@ protected:
 	timeval uptimeOfOldTemperature;
 
 	void doChildOperation() {
+		ReturnValue_t result = poolVariable->read(MutexIF::TimeoutType::WAITING, 20);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+
 		if ((not poolVariable->isValid()) or
 		        (not healthHelper.healthTable->isHealthy(getObjectId()))) {
 			setInvalid();

From 64efb8ec7f2cd64c188791043289e4a45d79ad87 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 20 Apr 2021 14:58:35 +0200
Subject: [PATCH 1756/1774] temperature sensor update

---
 thermal/TemperatureSensor.h | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index f1e17c559..abe446c0b 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -69,14 +69,14 @@ public:
 	 * @param outputSet     Output dataset for the output temperature to fetch it with read()
 	 * @param thermalModule respective thermal module, if it has one
 	 */
-	TemperatureSensor(object_id_t setObjectid,
-			inputType *inputValue, gp_id_t variableGpid, PoolVariableIF* inputVariable,
+	TemperatureSensor(object_id_t setObjectid,lp_var_t<limitType>* inputTemperature,
+			gp_id_t variableGpid, PoolVariableIF* inputVariable,
 			uint8_t vectorIndex, Parameters parameters = {0, 0, 0, 0, 0, 0},
-			LocalPoolDataSetBase *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+			LocalPoolDataSetBase *outputSet = nullptr, ThermalModuleIF *thermalModule = nullptr) :
 			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
-			inputValue(inputValue), poolVariable(inputVariable),
+			inputTemperature(inputTemperature),
 			outputTemperature(variableGpid, outputSet, PoolVariableIF::VAR_WRITE),
-			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR, poolVariable,
+			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR, variableGpid,
 				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
 				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
 			oldTemperature(20), uptimeOfOldTemperature({ thermal::INVALID_TEMPERATURE, 0 }) {
@@ -110,10 +110,7 @@ protected:
 
 	UsedParameters parameters;
 
-	inputType* inputValue;
-
-	PoolVariableIF* poolVariable;
-
+	lp_var_t<limitType>* inputTemperature;
 	lp_var_t<float> outputTemperature;
 
 	LimitMonitor<limitType> sensorMonitor;
@@ -122,18 +119,18 @@ protected:
 	timeval uptimeOfOldTemperature;
 
 	void doChildOperation() {
-		ReturnValue_t result = poolVariable->read(MutexIF::TimeoutType::WAITING, 20);
+		ReturnValue_t result = inputTemperature->read(MutexIF::TimeoutType::WAITING, 20);
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
 
-		if ((not poolVariable->isValid()) or
+		if ((not inputTemperature->isValid()) or
 		        (not healthHelper.healthTable->isHealthy(getObjectId()))) {
 			setInvalid();
 			return;
 		}
 
-		outputTemperature = calculateOutputTemperature(*inputValue);
+		outputTemperature = calculateOutputTemperature(inputTemperature->value);
 		outputTemperature.setValid(PoolVariableIF::VALID);
 
 		timeval uptime;

From e6a8371d4a6a54ad4091eb3bf48da6aea96d522e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 20 Apr 2021 15:00:59 +0200
Subject: [PATCH 1757/1774] temperature sensor update

---
 thermal/TemperatureSensor.h | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index abe446c0b..55138cc3b 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -137,9 +137,9 @@ protected:
 		Clock::getUptime(&uptime);
 
 		if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
-			//In theory, we could use an AbsValueMonitor to monitor the gradient.
-			//But this would require storing the maxGradient in DP and quite some overhead.
-			//The concept of delta limits is a bit strange anyway.
+			// In theory, we could use an AbsValueMonitor to monitor the gradient.
+			// But this would require storing the maxGradient in DP and quite some overhead.
+			// The concept of delta limits is a bit strange anyway.
 			float deltaTime;
 			float deltaTemp;
 
@@ -152,11 +152,10 @@ protected:
 			}
 			if (parameters.gradient < deltaTemp / deltaTime) {
 				triggerEvent(TEMP_SENSOR_GRADIENT);
-				//Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
+				// Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
 			}
 		}
 
-		//Check is done against raw limits. SHOULDDO: Why? Using C would be more easy to handle.
 		sensorMonitor.doCheck(outputTemperature.value);
 
 		if (sensorMonitor.isOutOfLimits()) {

From 153c44601b484fef84795456fa32c8749e574d55 Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Tue, 20 Apr 2021 15:04:42 +0200
Subject: [PATCH 1758/1774] refixed spelling

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 8f82251bd..e1e0ec644 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -52,7 +52,7 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle
-//! Simultaneously. This will increase the required RAM for
+//! simultaneously. This will increase the required RAM for
 //! each CSB service !
 static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
 

From 7b29583f8f34e96b23fd6202252f58146e17d978 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 20 Apr 2021 15:32:12 +0200
Subject: [PATCH 1759/1774] small improvements

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 13 +++++++------
 osal/linux/PosixThread.cpp         | 10 +++++++++-
 osal/linux/tcpipHelpers.cpp        |  1 +
 3 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index e1e0ec644..fe18a2f43 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -40,6 +40,13 @@
 //! Specify whether a special mode store is used for Subsystem components.
 #define FSFW_USE_MODESTORE          0
 
+//! Defines if the real time scheduler for linux should be used.
+//! If set to 0, this will also disable priority settings for linux
+//! as most systems will not allow to set nice values without privileges
+//! For embedded linux system set this to 1.
+//! If set to 1 the binary needs "cap_sys_nice=eip" privileges to run
+#define FSFW_USE_REALTIME_FOR_LINUX 1
+
 namespace fsfwconfig {
 //! Default timestamp size. The default timestamp will be an eight byte CDC
 //! short timestamp.
@@ -58,12 +65,6 @@ static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
 
 static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
 
-//! Defines if the real time scheduler for linux should be used.
-//! If set to 0, this will also disable priority settings for linux
-//! as most systems will not allow to set nice values without privileges
-//! For embedded linux system set this to 1.
-//! If set to 1 the binary needs "cap_sys_nice=eip" privileges to run
-#define FSFW_USE_REALTIME_FOR_LINUX 1
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index f1cff9925..72adfb140 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -223,8 +223,16 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	status = pthread_create(&thread,&attributes,fnc_,arg_);
 	if(status != 0){
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "Posix Thread create failed with: " <<
+		sif::error << "PosixThread::createTask: Failed with: " <<
 				strerror(status) << std::endl;
+		sif::error << "For FSFW_USE_REALTIME_FOR_LINUX == 1 make sure to call " <<
+		        "\"all sudo setcap 'cap_sys_nice=eip'\" on the application or set "
+		        "/etc/security/limit.conf" << std::endl;
+#else
+		sif::printError("PosixThread::createTask: Create failed with: %s\n", strerror(status));
+		sif::printError("For FSFW_USE_REALTIME_FOR_LINUX == 1 make sure to call "
+		        "\"all sudo setcap 'cap_sys_nice=eip'\" on the application or set "
+                "/etc/security/limit.conf\n");
 #endif
 	}
 
diff --git a/osal/linux/tcpipHelpers.cpp b/osal/linux/tcpipHelpers.cpp
index 4c1b9a780..3e8f60092 100644
--- a/osal/linux/tcpipHelpers.cpp
+++ b/osal/linux/tcpipHelpers.cpp
@@ -1,5 +1,6 @@
 #include "../common/tcpipHelpers.h"
 
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../tasks/TaskFactory.h"
 
 #include <errno.h>

From 524e50a6dd5649b9748c677b72e00bdb9e9a725e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 20 Apr 2021 15:54:44 +0200
Subject: [PATCH 1760/1774] comment block corrected

---
 thermal/TemperatureSensor.h | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 55138cc3b..b4ea45049 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -60,18 +60,17 @@ public:
 
 	/**
 	 * Instantiate Temperature Sensor Object.
-	 * @param setObjectid   objectId of the sensor object
-	 * @param inputValue    Pointer to input value which is converted to a temperature
-	 * @param variableGpid  Global Pool ID of the output value
-	 * @param inputVariable Input variable handle
-	 * @param vectorIndex   Vector Index for the sensor monitor
-	 * @param parameters    Calculation parameters, temperature limits, gradient limit
-	 * @param outputSet     Output dataset for the output temperature to fetch it with read()
-	 * @param thermalModule respective thermal module, if it has one
+	 * @param setObjectid       objectId of the sensor object
+	 * @param inputTemperature  Pointer to a raw input value which is converted to an floating
+	 *                          point C output temperature
+	 * @param variableGpid      Global Pool ID of the output value
+	 * @param vectorIndex       Vector Index for the sensor monitor
+	 * @param parameters        Calculation parameters, temperature limits, gradient limit
+	 * @param outputSet         Output dataset for the output temperature to fetch it with read()
+	 * @param thermalModule     Respective thermal module, if it has one
 	 */
 	TemperatureSensor(object_id_t setObjectid,lp_var_t<limitType>* inputTemperature,
-			gp_id_t variableGpid, PoolVariableIF* inputVariable,
-			uint8_t vectorIndex, Parameters parameters = {0, 0, 0, 0, 0, 0},
+			gp_id_t variableGpid, uint8_t vectorIndex, Parameters parameters = {0, 0, 0, 0, 0, 0},
 			LocalPoolDataSetBase *outputSet = nullptr, ThermalModuleIF *thermalModule = nullptr) :
 			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
 			inputTemperature(inputTemperature),

From 0c342ad7fcc715266a2562f65f2cec034d40e919 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 20 Apr 2021 15:57:11 +0200
Subject: [PATCH 1761/1774] minor changes

---
 thermal/TemperatureSensor.h | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index b4ea45049..69c16c7f6 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -1,5 +1,5 @@
-#ifndef TEMPERATURESENSOR_H_
-#define TEMPERATURESENSOR_H_
+#ifndef FSFW_THERMAL_TEMPERATURESENSOR_H_
+#define FSFW_THERMAL_TEMPERATURESENSOR_H_
 
 #include "tcsDefinitions.h"
 #include "AbstractTemperatureSensor.h"
@@ -151,7 +151,8 @@ protected:
 			}
 			if (parameters.gradient < deltaTemp / deltaTime) {
 				triggerEvent(TEMP_SENSOR_GRADIENT);
-				// Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
+				// Don't set invalid, as we did not recognize it as invalid with full authority,
+				// let FDIR handle it
 			}
 		}
 
@@ -181,7 +182,10 @@ public:
 	static const uint16_t ADDRESS_C = 2;
 	static const uint16_t ADDRESS_GRADIENT = 3;
 
-	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
+	//! Changed due to issue with later temperature checking even tough the sensor monitor was
+	//! confirming already (Was 10 before with comment = Correlates to a 10s confirmation time.
+	//! Chosen rather large, should not be so bad for components and helps survive glitches.)
+	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1;
 
 	static const uint8_t DOMAIN_ID_SENSOR = 1;
 
@@ -221,4 +225,4 @@ public:
 
 };
 
-#endif /* TEMPERATURESENSOR_H_ */
+#endif /* FSFW_THERMAL_TEMPERATURESENSOR_H_ */

From 38a5e7e618ebb7a9190b894b2ba6d302049aa042 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 20 Apr 2021 16:00:01 +0200
Subject: [PATCH 1762/1774] ctor variable better name

---
 thermal/TemperatureSensor.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 69c16c7f6..c7b9d771b 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -63,19 +63,19 @@ public:
 	 * @param setObjectid       objectId of the sensor object
 	 * @param inputTemperature  Pointer to a raw input value which is converted to an floating
 	 *                          point C output temperature
-	 * @param variableGpid      Global Pool ID of the output value
+	 * @param outputGpid        Global Pool ID of the output value
 	 * @param vectorIndex       Vector Index for the sensor monitor
 	 * @param parameters        Calculation parameters, temperature limits, gradient limit
 	 * @param outputSet         Output dataset for the output temperature to fetch it with read()
 	 * @param thermalModule     Respective thermal module, if it has one
 	 */
 	TemperatureSensor(object_id_t setObjectid,lp_var_t<limitType>* inputTemperature,
-			gp_id_t variableGpid, uint8_t vectorIndex, Parameters parameters = {0, 0, 0, 0, 0, 0},
+			gp_id_t outputGpid, uint8_t vectorIndex, Parameters parameters = {0, 0, 0, 0, 0, 0},
 			LocalPoolDataSetBase *outputSet = nullptr, ThermalModuleIF *thermalModule = nullptr) :
 			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
 			inputTemperature(inputTemperature),
-			outputTemperature(variableGpid, outputSet, PoolVariableIF::VAR_WRITE),
-			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR, variableGpid,
+			outputTemperature(outputGpid, outputSet, PoolVariableIF::VAR_WRITE),
+			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR, outputGpid,
 				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
 				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
 			oldTemperature(20), uptimeOfOldTemperature({ thermal::INVALID_TEMPERATURE, 0 }) {

From d792679d49d6e3cc1cf323e046abc1baf7d11c1a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 20 Apr 2021 16:09:50 +0200
Subject: [PATCH 1763/1774] calling empty ctor now (coverity)

---
 serialize/SerializeElement.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 470802927..db66f9cc2 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -25,7 +25,7 @@ public:
 
 	}
 	SerializeElement() :
-			LinkedElement<SerializeIF>(this) {
+			LinkedElement<SerializeIF>(this), entry() {
 	}
 
 	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,

From 54ff8f9341c4d7ea16296b9bd5c4167ddb19a2ee Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 20 Apr 2021 16:12:50 +0200
Subject: [PATCH 1764/1774] heater tweaks + coverity fix

---
 thermal/Heater.cpp | 596 +++++++++++++++++++++++----------------------
 thermal/Heater.h   | 115 ++++-----
 2 files changed, 359 insertions(+), 352 deletions(-)

diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index 782ce2963..8bfa030b9 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -1,350 +1,354 @@
-#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
 #include "Heater.h"
 
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
 #include "../power/Fuse.h"
 #include "../ipc/QueueFactory.h"
 
 Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) :
-		HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
-				NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(
-				false), timedOut(false), reactedToBeingFaulty(false), passive(
-				false), eventQueue(NULL), heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(
-				this), lastAction(CLEAR) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
+HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
+        NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(false), timedOut(false),
+        reactedToBeingFaulty(false), passive(false), eventQueue(NULL),
+        heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(this), lastAction(CLEAR) {
+    eventQueue = QueueFactory::instance()->createMessageQueue();
 }
 
 Heater::~Heater() {
-	QueueFactory::instance()->deleteMessageQueue(eventQueue);
+    QueueFactory::instance()->deleteMessageQueue(eventQueue);
 }
 
 ReturnValue_t Heater::set() {
-	passive = false;
-	//wait for clear before doing anything
-	if (internalState == STATE_WAIT) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	if (healthHelper.healthTable->isHealthy(getObjectId())) {
-		doAction(SET);
-		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		} else {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	} else {
-		if (healthHelper.healthTable->isFaulty(getObjectId())) {
-			if (!reactedToBeingFaulty) {
-				reactedToBeingFaulty = true;
-				doAction(CLEAR);
-			}
-		}
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    passive = false;
+    //wait for clear before doing anything
+    if (internalState == STATE_WAIT) {
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    if (healthHelper.healthTable->isHealthy(getObjectId())) {
+        doAction(SET);
+        if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        } else {
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+    } else {
+        if (healthHelper.healthTable->isFaulty(getObjectId())) {
+            if (!reactedToBeingFaulty) {
+                reactedToBeingFaulty = true;
+                doAction(CLEAR);
+            }
+        }
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 void Heater::clear(bool passive) {
-	this->passive = passive;
-	//Force switching off
-	if (internalState == STATE_WAIT) {
-		internalState = STATE_ON;
-	}
-	if (healthHelper.healthTable->isHealthy(getObjectId())) {
-		doAction(CLEAR);
-	} else if (healthHelper.healthTable->isFaulty(getObjectId())) {
-		if (!reactedToBeingFaulty) {
-			reactedToBeingFaulty = true;
-			doAction(CLEAR);
-		}
-	}
+    this->passive = passive;
+    //Force switching off
+    if (internalState == STATE_WAIT) {
+        internalState = STATE_ON;
+    }
+    if (healthHelper.healthTable->isHealthy(getObjectId())) {
+        doAction(CLEAR);
+    } else if (healthHelper.healthTable->isFaulty(getObjectId())) {
+        if (!reactedToBeingFaulty) {
+            reactedToBeingFaulty = true;
+            doAction(CLEAR);
+        }
+    }
 }
 
 void Heater::doAction(Action action) {
-	//only act if we are not in the right state or in a transition
-	if (action == SET) {
-		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
-				|| (internalState == STATE_EXTERNAL_CONTROL)) {
-			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-			internalState = STATE_WAIT_FOR_SWITCHES_ON;
-			powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
-			powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
-		}
-	} else { //clear
-		if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
-				|| (internalState == STATE_EXTERNAL_CONTROL)) {
-			internalState = STATE_WAIT_FOR_SWITCHES_OFF;
-			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-			powerSwitcher->sendSwitchCommand(switch0,
-					PowerSwitchIF::SWITCH_OFF);
-			powerSwitcher->sendSwitchCommand(switch1,
-					PowerSwitchIF::SWITCH_OFF);
-		}
-	}
+    //only act if we are not in the right state or in a transition
+    if (action == SET) {
+        if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
+                || (internalState == STATE_EXTERNAL_CONTROL)) {
+            switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+            internalState = STATE_WAIT_FOR_SWITCHES_ON;
+            powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
+            powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
+        }
+    } else { //clear
+        if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
+                || (internalState == STATE_EXTERNAL_CONTROL)) {
+            internalState = STATE_WAIT_FOR_SWITCHES_OFF;
+            switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+            powerSwitcher->sendSwitchCommand(switch0,
+                    PowerSwitchIF::SWITCH_OFF);
+            powerSwitcher->sendSwitchCommand(switch1,
+                    PowerSwitchIF::SWITCH_OFF);
+        }
+    }
 }
 
 void Heater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
-	this->powerSwitcher = powerSwitch;
+    this->powerSwitcher = powerSwitch;
 }
 
 ReturnValue_t Heater::performOperation(uint8_t opCode) {
-	handleQueue();
-	handleEventQueue();
+    handleQueue();
+    handleEventQueue();
 
-	if (!healthHelper.healthTable->isFaulty(getObjectId())) {
-		reactedToBeingFaulty = false;
-	}
+    if (!healthHelper.healthTable->isFaulty(getObjectId())) {
+        reactedToBeingFaulty = false;
+    }
 
-	switch (internalState) {
-	case STATE_ON:
-		if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
-				|| (powerSwitcher->getSwitchState(switch1)
-						== PowerSwitchIF::SWITCH_OFF)) {
-			//switch went off on its own
-			//trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
-			//do not trigger FD events when under external control
-			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
-				triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
-			} else {
-				internalState = STATE_EXTERNAL_CONTROL;
-			}
-		}
-		break;
-	case STATE_OFF:
-		//check if heater is on, ie both switches are on
-		//if so, just command it to off, to resolve the situation or force a switch stayed on event
-		//But, only do anything if not already faulty (state off is the stable point for being faulty)
-		if ((!healthHelper.healthTable->isFaulty(getObjectId()))
-				&& (powerSwitcher->getSwitchState(switch0)
-						== PowerSwitchIF::SWITCH_ON)
-				&& (powerSwitcher->getSwitchState(switch1)
-						== PowerSwitchIF::SWITCH_ON)) {
-			//do not trigger FD events when under external control
-			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
-				internalState = STATE_WAIT_FOR_SWITCHES_OFF;
-				switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-				powerSwitcher->sendSwitchCommand(switch0,
-						PowerSwitchIF::SWITCH_OFF);
-				powerSwitcher->sendSwitchCommand(switch1,
-						PowerSwitchIF::SWITCH_OFF);
-			} else {
-				internalState = STATE_EXTERNAL_CONTROL;
-			}
-		}
-		break;
-	case STATE_PASSIVE:
-		break;
-	case STATE_WAIT_FOR_SWITCHES_ON:
-		if (switchCountdown.hasTimedOut()) {
-			if ((powerSwitcher->getSwitchState(switch0)
-					== PowerSwitchIF::SWITCH_OFF)
-					|| (powerSwitcher->getSwitchState(switch1)
-							== PowerSwitchIF::SWITCH_OFF)) {
-				triggerEvent(HEATER_STAYED_OFF);
-				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
-			} else {
-				triggerEvent(HEATER_ON);
-				internalState = STATE_ON;
-			}
-		}
-		break;
-	case STATE_WAIT_FOR_SWITCHES_OFF:
-		if (switchCountdown.hasTimedOut()) {
-			//only check for both being on (ie heater still on)
-			if ((powerSwitcher->getSwitchState(switch0)
-					== PowerSwitchIF::SWITCH_ON)
-					&& (powerSwitcher->getSwitchState(switch1)
-							== PowerSwitchIF::SWITCH_ON)) {
-				if (healthHelper.healthTable->isFaulty(getObjectId())) {
-					if (passive) {
-						internalState = STATE_PASSIVE;
-					} else {
-						internalState = STATE_OFF; //just accept it
-					}
-					triggerEvent(HEATER_ON); //but throw an event to make it more visible
-					break;
-				}
-				triggerEvent(HEATER_STAYED_ON);
-				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
-			} else {
-				triggerEvent(HEATER_OFF);
-				if (passive) {
-					internalState = STATE_PASSIVE;
-				} else {
-					internalState = STATE_OFF;
-				}
-			}
-		}
-		break;
-	default:
-		break;
-	}
+    switch (internalState) {
+    case STATE_ON:
+        if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
+                || (powerSwitcher->getSwitchState(switch1)
+                        == PowerSwitchIF::SWITCH_OFF)) {
+            //switch went off on its own
+            //trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
+            //do not trigger FD events when under external control
+            if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
+                triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
+            } else {
+                internalState = STATE_EXTERNAL_CONTROL;
+            }
+        }
+        break;
+    case STATE_OFF:
+        //check if heater is on, ie both switches are on
+        //if so, just command it to off, to resolve the situation or force a switch stayed on event
+        //But, only do anything if not already faulty (state off is the stable point for being faulty)
+        if ((!healthHelper.healthTable->isFaulty(getObjectId()))
+                && (powerSwitcher->getSwitchState(switch0)
+                        == PowerSwitchIF::SWITCH_ON)
+                        && (powerSwitcher->getSwitchState(switch1)
+                                == PowerSwitchIF::SWITCH_ON)) {
+            //do not trigger FD events when under external control
+            if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
+                internalState = STATE_WAIT_FOR_SWITCHES_OFF;
+                switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+                powerSwitcher->sendSwitchCommand(switch0,
+                        PowerSwitchIF::SWITCH_OFF);
+                powerSwitcher->sendSwitchCommand(switch1,
+                        PowerSwitchIF::SWITCH_OFF);
+            } else {
+                internalState = STATE_EXTERNAL_CONTROL;
+            }
+        }
+        break;
+    case STATE_PASSIVE:
+        break;
+    case STATE_WAIT_FOR_SWITCHES_ON:
+        if (switchCountdown.hasTimedOut()) {
+            if ((powerSwitcher->getSwitchState(switch0)
+                    == PowerSwitchIF::SWITCH_OFF)
+                    || (powerSwitcher->getSwitchState(switch1)
+                            == PowerSwitchIF::SWITCH_OFF)) {
+                triggerEvent(HEATER_STAYED_OFF);
+                internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
+            } else {
+                triggerEvent(HEATER_ON);
+                internalState = STATE_ON;
+            }
+        }
+        break;
+    case STATE_WAIT_FOR_SWITCHES_OFF:
+        if (switchCountdown.hasTimedOut()) {
+            //only check for both being on (ie heater still on)
+            if ((powerSwitcher->getSwitchState(switch0)
+                    == PowerSwitchIF::SWITCH_ON)
+                    && (powerSwitcher->getSwitchState(switch1)
+                            == PowerSwitchIF::SWITCH_ON)) {
+                if (healthHelper.healthTable->isFaulty(getObjectId())) {
+                    if (passive) {
+                        internalState = STATE_PASSIVE;
+                    } else {
+                        internalState = STATE_OFF; //just accept it
+                    }
+                    triggerEvent(HEATER_ON); //but throw an event to make it more visible
+                    break;
+                }
+                triggerEvent(HEATER_STAYED_ON);
+                internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
+            } else {
+                triggerEvent(HEATER_OFF);
+                if (passive) {
+                    internalState = STATE_PASSIVE;
+                } else {
+                    internalState = STATE_OFF;
+                }
+            }
+        }
+        break;
+    default:
+        break;
+    }
 
-	if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
-			&& (powerSwitcher->getSwitchState(switch1)
-					== PowerSwitchIF::SWITCH_ON)) {
-		if (wasOn) {
-			if (heaterOnCountdown.hasTimedOut()) {
-				//SHOULDDO this means if a heater fails in single mode, the timeout will start again
-				//I am not sure if this is a bug, but atm I have no idea how to fix this and think
-				//it will be ok. whatcouldpossiblygowrongâ„¢
-				if (!timedOut) {
-					triggerEvent(HEATER_TIMEOUT);
-					timedOut = true;
-				}
-			}
-		} else {
-			wasOn = true;
-			heaterOnCountdown.resetTimer();
-			timedOut = false;
-		}
-	} else {
-		wasOn = false;
-	}
+    if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
+            && (powerSwitcher->getSwitchState(switch1)
+                    == PowerSwitchIF::SWITCH_ON)) {
+        if (wasOn) {
+            if (heaterOnCountdown.hasTimedOut()) {
+                //SHOULDDO this means if a heater fails in single mode, the timeout will start again
+                //I am not sure if this is a bug, but atm I have no idea how to fix this and think
+                //it will be ok. whatcouldpossiblygowrongâ„¢
+                if (!timedOut) {
+                    triggerEvent(HEATER_TIMEOUT);
+                    timedOut = true;
+                }
+            }
+        } else {
+            wasOn = true;
+            heaterOnCountdown.resetTimer();
+            timedOut = false;
+        }
+    } else {
+        wasOn = false;
+    }
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void Heater::setSwitch(uint8_t number, ReturnValue_t state,
-		uint32_t* uptimeOfSwitching) {
-	if (powerSwitcher == NULL) {
-		return;
-	}
-	if (powerSwitcher->getSwitchState(number) == state) {
-		*uptimeOfSwitching = INVALID_UPTIME;
-	} else {
-		if ((*uptimeOfSwitching == INVALID_UPTIME)) {
-			powerSwitcher->sendSwitchCommand(number, state);
-			Clock::getUptime(uptimeOfSwitching);
-		} else {
-			uint32_t currentUptime;
-			Clock::getUptime(&currentUptime);
-			if (currentUptime - *uptimeOfSwitching
-					> powerSwitcher->getSwitchDelayMs()) {
-				*uptimeOfSwitching = INVALID_UPTIME;
-				if (healthHelper.healthTable->isHealthy(getObjectId())) {
-					if (state == PowerSwitchIF::SWITCH_ON) {
-						triggerEvent(HEATER_STAYED_OFF);
-					} else {
-						triggerEvent(HEATER_STAYED_ON);
-					}
-				}
-				//SHOULDDO MiniOps during switch timeout leads to a faulty switch
-			}
-		}
-	}
+        uint32_t* uptimeOfSwitching) {
+    if (powerSwitcher == NULL) {
+        return;
+    }
+    if (powerSwitcher->getSwitchState(number) == state) {
+        *uptimeOfSwitching = INVALID_UPTIME;
+    } else {
+        if ((*uptimeOfSwitching == INVALID_UPTIME)) {
+            powerSwitcher->sendSwitchCommand(number, state);
+            Clock::getUptime(uptimeOfSwitching);
+        } else {
+            uint32_t currentUptime;
+            Clock::getUptime(&currentUptime);
+            if (currentUptime - *uptimeOfSwitching
+                    > powerSwitcher->getSwitchDelayMs()) {
+                *uptimeOfSwitching = INVALID_UPTIME;
+                if (healthHelper.healthTable->isHealthy(getObjectId())) {
+                    if (state == PowerSwitchIF::SWITCH_ON) {
+                        triggerEvent(HEATER_STAYED_OFF);
+                    } else {
+                        triggerEvent(HEATER_STAYED_ON);
+                    }
+                }
+                //SHOULDDO MiniOps during switch timeout leads to a faulty switch
+            }
+        }
+    }
 }
 
 MessageQueueId_t Heater::getCommandQueue() const {
-	return commandQueue->getId();
+    return commandQueue->getId();
 }
 
 ReturnValue_t Heater::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    ReturnValue_t result = SystemObject::initialize();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-			objects::EVENT_MANAGER);
-	if (manager == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	result = manager->registerListener(eventQueue->getId());
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    EventManagerIF* manager = objectManager->get<EventManagerIF>(
+            objects::EVENT_MANAGER);
+    if (manager == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    result = manager->registerListener(eventQueue->getId());
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
-			DeviceHandlerFailureIsolation::powerConfirmationId);
-	if (pcdu == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	pcduQueueId = pcdu->getEventReceptionQueue();
+    ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
+            DeviceHandlerFailureIsolation::powerConfirmationId);
+    if (pcdu == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    pcduQueueId = pcdu->getEventReceptionQueue();
 
-	result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
-			getObjectId());
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
+            getObjectId());
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    result = parameterHelper.initialize();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    result = healthHelper.initialize();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void Heater::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		parameterHelper.handleParameterMessage(&command);
-	}
+    CommandMessage command;
+    ReturnValue_t result = commandQueue->receiveMessage(&command);
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        result = healthHelper.handleHealthCommand(&command);
+        if (result == HasReturnvaluesIF::RETURN_OK) {
+            return;
+        }
+        result = parameterHelper.handleParameterMessage(&command);
+        if (result == HasReturnvaluesIF::RETURN_OK) {
+            return;
+        }
+    }
 }
 
 ReturnValue_t Heater::getParameter(uint8_t domainId, uint8_t uniqueId,
         ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	if (domainId != DOMAIN_ID_BASE) {
-		return INVALID_DOMAIN_ID;
-	}
-	switch (uniqueId) {
-	case 0:
-		parameterWrapper->set(heaterOnCountdown.timeout);
-		break;
-	default:
-		return INVALID_IDENTIFIER_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+        uint16_t startAtIndex) {
+    if (domainId != DOMAIN_ID_BASE) {
+        return INVALID_DOMAIN_ID;
+    }
+    switch (uniqueId) {
+    case 0:
+        parameterWrapper->set(heaterOnCountdown.timeout);
+        break;
+    default:
+        return INVALID_IDENTIFIER_ID;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void Heater::handleEventQueue() {
-	EventMessage event;
-	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
-			result == HasReturnvaluesIF::RETURN_OK;
-			result = eventQueue->receiveMessage(&event)) {
-		switch (event.getMessageId()) {
-		case EventMessage::EVENT_MESSAGE:
-			switch (event.getEvent()) {
-			case Fuse::FUSE_WENT_OFF:
-			case HEATER_STAYED_OFF:
-			case HEATER_STAYED_ON://Setting it faulty does not help, but we need to reach a stable state and can check for being faulty before throwing this event again.
-				if (healthHelper.healthTable->isCommandable(getObjectId())) {
-					healthHelper.setHealth(HasHealthIF::FAULTY);
-					internalState = STATE_FAULTY;
-				}
-				break;
-			case PowerSwitchIF::SWITCH_WENT_OFF:
-				internalState = STATE_WAIT;
-				event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
-				if (pcduQueueId != 0) {
-					eventQueue->sendMessage(pcduQueueId, &event);
-				} else {
-					healthHelper.setHealth(HasHealthIF::FAULTY);
-					internalState = STATE_FAULTY;
-				}
-				break;
-			default:
-				return;
-			}
-			break;
-		case EventMessage::YOUR_FAULT:
-			healthHelper.setHealth(HasHealthIF::FAULTY);
-			internalState = STATE_FAULTY;
-			break;
-		case EventMessage::MY_FAULT:
-			//do nothing, we are already in STATE_WAIT and wait for a clear()
-			break;
-		default:
-			return;
-		}
-	}
+    EventMessage event;
+    for (ReturnValue_t result = eventQueue->receiveMessage(&event);
+            result == HasReturnvaluesIF::RETURN_OK;
+            result = eventQueue->receiveMessage(&event)) {
+        switch (event.getMessageId()) {
+        case EventMessage::EVENT_MESSAGE:
+            switch (event.getEvent()) {
+            case Fuse::FUSE_WENT_OFF:
+            case HEATER_STAYED_OFF:
+            // Setting it faulty does not help, but we need to reach a stable state and can check
+            // for being faulty before throwing this event again.
+            case HEATER_STAYED_ON:
+                if (healthHelper.healthTable->isCommandable(getObjectId())) {
+                    healthHelper.setHealth(HasHealthIF::FAULTY);
+                    internalState = STATE_FAULTY;
+                }
+                break;
+            case PowerSwitchIF::SWITCH_WENT_OFF:
+                internalState = STATE_WAIT;
+                event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
+                if (pcduQueueId != 0) {
+                    eventQueue->sendMessage(pcduQueueId, &event);
+                } else {
+                    healthHelper.setHealth(HasHealthIF::FAULTY);
+                    internalState = STATE_FAULTY;
+                }
+                break;
+            default:
+                return;
+            }
+            break;
+            case EventMessage::YOUR_FAULT:
+                healthHelper.setHealth(HasHealthIF::FAULTY);
+                internalState = STATE_FAULTY;
+                break;
+            case EventMessage::MY_FAULT:
+                //do nothing, we are already in STATE_WAIT and wait for a clear()
+                break;
+            default:
+                return;
+        }
+    }
 }
diff --git a/thermal/Heater.h b/thermal/Heater.h
index f83957a2e..19f13c793 100644
--- a/thermal/Heater.h
+++ b/thermal/Heater.h
@@ -1,90 +1,93 @@
-#ifndef FRAMEWORK_THERMAL_HEATER_H_
-#define FRAMEWORK_THERMAL_HEATER_H_
+#ifndef FSFW_THERMAL_HEATER_H_
+#define FSFW_THERMAL_HEATER_H_
 
 #include "../devicehandlers/HealthDevice.h"
 #include "../parameters/ParameterHelper.h"
 #include "../power/PowerSwitchIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../timemanager/Countdown.h"
-#include <stdint.h>
-//class RedundantHeater;
+#include <cstdint>
+
 
 class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
-	friend class RedundantHeater;
+    friend class RedundantHeater;
 public:
 
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
-	static const Event HEATER_ON = MAKE_EVENT(0, severity::INFO);
-	static const Event HEATER_OFF = MAKE_EVENT(1, severity::INFO);
-	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, severity::LOW);
-	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, severity::LOW);
-	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, severity::LOW);
+    static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
+    static const Event HEATER_ON = MAKE_EVENT(0, severity::INFO);
+    static const Event HEATER_OFF = MAKE_EVENT(1, severity::INFO);
+    static const Event HEATER_TIMEOUT = MAKE_EVENT(2, severity::LOW);
+    static const Event HEATER_STAYED_ON = MAKE_EVENT(3, severity::LOW);
+    static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, severity::LOW);
 
-	Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
-	virtual ~Heater();
+    Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
+    virtual ~Heater();
 
-	ReturnValue_t performOperation(uint8_t opCode);
+    ReturnValue_t performOperation(uint8_t opCode);
 
-	ReturnValue_t initialize();
+    ReturnValue_t initialize();
 
-	ReturnValue_t set();
-	void clear(bool passive);
+    ReturnValue_t set();
+    void clear(bool passive);
 
-	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
+    void setPowerSwitcher(PowerSwitchIF *powerSwitch);
 
-	MessageQueueId_t getCommandQueue() const;
+    MessageQueueId_t getCommandQueue() const;
 
-	ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
-	        ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
+    ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
+            ParameterWrapper *parameterWrapper,
+            const ParameterWrapper *newValues, uint16_t startAtIndex);
 
 protected:
-	static const uint32_t INVALID_UPTIME = 0;
+    static const uint32_t INVALID_UPTIME = 0;
 
-	enum InternalState {
-		STATE_ON,
-		STATE_OFF,
-		STATE_PASSIVE,
-		STATE_WAIT_FOR_SWITCHES_ON,
-		STATE_WAIT_FOR_SWITCHES_OFF,
-		STATE_WAIT_FOR_FDIR, //used to avoid doing anything until fdir decided what to do
-		STATE_FAULTY,
-		STATE_WAIT, //used when waiting for system to recover from miniops
-		STATE_EXTERNAL_CONTROL //entered when under external control and a fdir reaction would be triggered. This is useful when leaving external control into an unknown state
-							   //if no fdir reaction is triggered under external control the state is still ok and no need for any special treatment is needed
-	} internalState;
+    enum InternalState {
+        STATE_ON,
+        STATE_OFF,
+        STATE_PASSIVE,
+        STATE_WAIT_FOR_SWITCHES_ON,
+        STATE_WAIT_FOR_SWITCHES_OFF,
+        STATE_WAIT_FOR_FDIR, // Used to avoid doing anything until fdir decided what to do
+        STATE_FAULTY,
+        STATE_WAIT, // Used when waiting for system to recover from miniops
+        // Entered when under external control and a fdir reaction would be triggered.
+        // This is useful when leaving external control into an unknown state
+        STATE_EXTERNAL_CONTROL
+        // If no fdir reaction is triggered under external control the state is still ok and
+        // no need for any special treatment is needed
+    } internalState;
 
-	PowerSwitchIF *powerSwitcher;
-	MessageQueueId_t pcduQueueId;
+    PowerSwitchIF *powerSwitcher;
+    MessageQueueId_t pcduQueueId;
 
-	uint8_t switch0;
-	uint8_t switch1;
+    uint8_t switch0;
+    uint8_t switch1;
 
-	bool wasOn;
+    bool wasOn;
 
-	bool timedOut;
+    bool timedOut;
 
-	bool reactedToBeingFaulty;
+    bool reactedToBeingFaulty;
 
-	bool passive;
+    bool passive;
 
-	MessageQueueIF* eventQueue;
-	Countdown heaterOnCountdown;
-	Countdown switchCountdown;
-	ParameterHelper parameterHelper;
+    MessageQueueIF* eventQueue;
+    Countdown heaterOnCountdown;
+    Countdown switchCountdown;
+    ParameterHelper parameterHelper;
 
-	enum Action {
-		SET, CLEAR
-	} lastAction;
+    enum Action {
+        SET, CLEAR
+    } lastAction;
 
-	void doAction(Action action);
+    void doAction(Action action);
 
-	void setSwitch(uint8_t number, ReturnValue_t state,
-			uint32_t *upTimeOfSwitching);
+    void setSwitch(uint8_t number, ReturnValue_t state,
+            uint32_t *upTimeOfSwitching);
 
-	void handleQueue();
+    void handleQueue();
 
-	void handleEventQueue();
+    void handleEventQueue();
 };
 
-#endif /* FRAMEWORK_THERMAL_HEATER_H_ */
+#endif /* FSFW_THERMAL_HEATER_H_ */

From 864621ee37892cef944e1384d6fde38aa5770e1d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 20 Apr 2021 16:15:30 +0200
Subject: [PATCH 1765/1774] small fix for linux printout

---
 osal/linux/tcpipHelpers.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/linux/tcpipHelpers.cpp b/osal/linux/tcpipHelpers.cpp
index 3e8f60092..d7c644ecb 100644
--- a/osal/linux/tcpipHelpers.cpp
+++ b/osal/linux/tcpipHelpers.cpp
@@ -99,8 +99,8 @@ void tcpip::handleError(Protocol protocol, ErrorSources errorSrc, dur_millis_t s
     sif::warning << "tcpip::handleError: " << protocolString << " | " << errorSrcString <<
             " | " << infoString << std::endl;
 #else
-    sif::printWarning("tcpip::handleError: %s | %s | %s\n", protocolString,
-            errorSrcString, infoString);
+    sif::printWarning("tcpip::handleError: %s | %s | %s\n", protocolString.c_str(),
+            errorSrcString.c_str(), infoString.c_str());
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 
     if(sleepDuration > 0) {

From a2ba3181b91a5f3657ee8f72b7638cadc27864a4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 20 Apr 2021 16:16:35 +0200
Subject: [PATCH 1766/1774] small coverity tweak

---
 devicehandlers/HealthDevice.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 418ed2576..e23dd5b69 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -16,9 +16,9 @@ ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
 	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		healthHelper.handleHealthCommand(&command);
+		result = healthHelper.handleHealthCommand(&command);
 	}
-	return HasReturnvaluesIF::RETURN_OK;
+	return result;
 }
 
 ReturnValue_t HealthDevice::initialize() {

From 0055d34d9a156f805edf63e9d5970562b372755a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 20 Apr 2021 16:17:37 +0200
Subject: [PATCH 1767/1774] bugfix found by coverity

---
 timemanager/TimeMessage.cpp | 2 +-
 timemanager/TimeMessage.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/timemanager/TimeMessage.cpp b/timemanager/TimeMessage.cpp
index a1042efe5..66aea0f4d 100644
--- a/timemanager/TimeMessage.cpp
+++ b/timemanager/TimeMessage.cpp
@@ -25,6 +25,6 @@ uint32_t TimeMessage::getCounterValue() {
 	return temp;
 }
 
-size_t TimeMessage::getMinimumMessageSize() {
+size_t TimeMessage::getMinimumMessageSize() const {
 	return this->MAX_SIZE;
 }
diff --git a/timemanager/TimeMessage.h b/timemanager/TimeMessage.h
index f5ac3e14d..00778fb7f 100644
--- a/timemanager/TimeMessage.h
+++ b/timemanager/TimeMessage.h
@@ -11,7 +11,7 @@ protected:
 	 * @brief	This call always returns the same fixed size of the message.
 	 * @return	Returns HEADER_SIZE + \c sizeof(timeval) + sizeof(uint32_t).
 	 */
-	size_t getMinimumMessageSize();
+	size_t getMinimumMessageSize() const override;
 public:
 
 	/**

From 4fb792447e037cabbd4800f40e4fabeb44d6c143 Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Tue, 20 Apr 2021 17:29:56 +0200
Subject: [PATCH 1768/1774] Small rearragenment in Heater.cpp

---
 thermal/Heater.cpp |  7 +++----
 thermal/Heater.h   | 16 ++++++++--------
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index 8bfa030b9..aeade8d1d 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -5,10 +5,9 @@
 #include "../ipc/QueueFactory.h"
 
 Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) :
-HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
-        NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(false), timedOut(false),
-        reactedToBeingFaulty(false), passive(false), eventQueue(NULL),
-        heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(this), lastAction(CLEAR) {
+HealthDevice(objectId, 0), internalState(STATE_OFF), switch0(switch0), switch1(switch1),
+        heaterOnCountdown(10800000)/*about two orbits*/,
+		parameterHelper(this) {
     eventQueue = QueueFactory::instance()->createMessageQueue();
 }
 
diff --git a/thermal/Heater.h b/thermal/Heater.h
index 19f13c793..2caddd852 100644
--- a/thermal/Heater.h
+++ b/thermal/Heater.h
@@ -57,28 +57,28 @@ protected:
         // no need for any special treatment is needed
     } internalState;
 
-    PowerSwitchIF *powerSwitcher;
-    MessageQueueId_t pcduQueueId;
+    PowerSwitchIF *powerSwitcher = nullptr;
+    MessageQueueId_t pcduQueueId = MessageQueueIF::NO_QUEUE;
 
     uint8_t switch0;
     uint8_t switch1;
 
-    bool wasOn;
+    bool wasOn = false;
 
-    bool timedOut;
+    bool timedOut = false;
 
-    bool reactedToBeingFaulty;
+    bool reactedToBeingFaulty = false;
 
-    bool passive;
+    bool passive = false;
 
-    MessageQueueIF* eventQueue;
+    MessageQueueIF* eventQueue = nullptr;
     Countdown heaterOnCountdown;
     Countdown switchCountdown;
     ParameterHelper parameterHelper;
 
     enum Action {
         SET, CLEAR
-    } lastAction;
+    } lastAction = CLEAR;
 
     void doAction(Action action);
 

From 629814bc9ba00112668d0edaa62e0690cb5ead98 Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Tue, 20 Apr 2021 17:35:28 +0200
Subject: [PATCH 1769/1774] Just comments

---
 thermal/Heater.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index aeade8d1d..770494385 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -224,7 +224,6 @@ void Heater::setSwitch(uint8_t number, ReturnValue_t state,
                         triggerEvent(HEATER_STAYED_ON);
                     }
                 }
-                //SHOULDDO MiniOps during switch timeout leads to a faulty switch
             }
         }
     }
@@ -317,7 +316,7 @@ void Heater::handleEventQueue() {
             switch (event.getEvent()) {
             case Fuse::FUSE_WENT_OFF:
             case HEATER_STAYED_OFF:
-            // Setting it faulty does not help, but we need to reach a stable state and can check
+            // HEATER_STAYED_ON is a setting if faulty does not help, but we need to reach a stable state and can check
             // for being faulty before throwing this event again.
             case HEATER_STAYED_ON:
                 if (healthHelper.healthTable->isCommandable(getObjectId())) {

From 03ef63302b681651daefde2f17421dabda4c6945 Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Tue, 20 Apr 2021 20:45:15 +0200
Subject: [PATCH 1770/1774] Replaced Magic Numbers

---
 subsystem/SubsystemBase.cpp | 9 ++++-----
 subsystem/SubsystemBase.h   | 4 ++--
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index bcfa4b0e3..565e0712d 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -5,8 +5,7 @@
 
 SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
 		Mode_t initialMode, uint16_t commandQueueDepth) :
-		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
-		childrenChangedMode(false),
+		SystemObject(setObjectId), mode(initialMode),
 		commandQueue(QueueFactory::instance()->createMessageQueue(
 		        commandQueueDepth, CommandMessage::MAX_MESSAGE_SIZE)),
 		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
@@ -167,16 +166,16 @@ MessageQueueId_t SubsystemBase::getCommandQueue() const {
 }
 
 ReturnValue_t SubsystemBase::initialize() {
-	MessageQueueId_t parentQueue = 0;
+	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
 	ReturnValue_t result = SystemObject::initialize();
 
 	if (result != RETURN_OK) {
 		return result;
 	}
 
-	if (parentId != 0) {
+	if (parentId != objects::NO_OBJECT) {
 		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
+		if (parent == nullptr) {
 			return RETURN_FAILED;
 		}
 		parentQueue = parent->getCommandQueue();
diff --git a/subsystem/SubsystemBase.h b/subsystem/SubsystemBase.h
index b8e4f9029..5d107701d 100644
--- a/subsystem/SubsystemBase.h
+++ b/subsystem/SubsystemBase.h
@@ -56,9 +56,9 @@ protected:
 
 	Mode_t mode;
 
-	Submode_t submode;
+	Submode_t submode = SUBMODE_NONE;
 
-	bool childrenChangedMode;
+	bool childrenChangedMode = false;
 
 	/**
 	 * Always check this against <=0, so you are robust against too many replies

From 06631d06a57c30946563d8726ea9ef9a7e6c1c84 Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Tue, 20 Apr 2021 22:01:56 +0200
Subject: [PATCH 1771/1774] Added comments in AssemblyBase and SubsystemBase

---
 devicehandlers/AssemblyBase.h | 22 +++++++++++++++++++---
 subsystem/SubsystemBase.h     | 11 +++++++++++
 2 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/devicehandlers/AssemblyBase.h b/devicehandlers/AssemblyBase.h
index 353d5f899..6cac81b49 100644
--- a/devicehandlers/AssemblyBase.h
+++ b/devicehandlers/AssemblyBase.h
@@ -24,6 +24,13 @@
  * 1. check logic when active-> checkChildrenStateOn
  * 2. transition logic to change the mode -> commandChildren
  *
+ * Important:
+ *
+ * The implementation must call registerChild(object_id_t child)
+ * for all commanded children during initialization.
+ * The implementation must call the initialization function of the base class.
+ * (This will call the function in SubsystemBase)
+ *
  */
 class AssemblyBase: public SubsystemBase {
 public:
@@ -41,9 +48,6 @@ public:
 	virtual ~AssemblyBase();
 
 protected:
-
-    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
-    // (or return internalState directly?)
     /**
      * Command children to reach [mode,submode] combination
      * Can be done by setting #commandsOutstanding correctly,
@@ -68,6 +72,18 @@ protected:
     virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
             Submode_t wantedSubmode) = 0;
 
+    /**
+     * Check whether a combination of mode and submode is valid.
+     *
+     * Ground Controller like precise return values from HasModesIF.
+     * So, please return any of them.
+     *
+     * @param mode The targeted mode
+     * @param submode The targeted submmode
+     * @return Any information why this combination is invalid from HasModesIF
+     * 			like HasModesIF::INVALID_SUBMODE.
+     * 			On success return HasReturnvaluesIF::RETURN_OK
+     */
     virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
             Submode_t submode) = 0;
 
diff --git a/subsystem/SubsystemBase.h b/subsystem/SubsystemBase.h
index 5d107701d..6b2e9b5fd 100644
--- a/subsystem/SubsystemBase.h
+++ b/subsystem/SubsystemBase.h
@@ -37,6 +37,17 @@ public:
 
 	virtual MessageQueueId_t getCommandQueue() const override;
 
+	/**
+	 * Function to register the child objects.
+	 * Performs a checks if the child does implement HasHealthIF and/or HasModesIF
+	 *
+	 * 	Also adds them to the internal childrenMap.
+	 *
+	 * @param objectId
+	 * @return RETURN_OK if successful
+	 * 		   CHILD_DOESNT_HAVE_MODES if Child is no HasHealthIF and no HasModesIF
+	 * 		   COULD_NOT_INSERT_CHILD If the Child could not be added to the ChildrenMap
+	 */
 	ReturnValue_t registerChild(object_id_t objectId);
 
 	virtual ReturnValue_t initialize() override;

From 87fee9bd0e8e59d762ae7885fb6918505072201c Mon Sep 17 00:00:00 2001
From: "Jakob.Meier" <meierj@irs.uni-stuttgart.de>
Date: Sun, 25 Apr 2021 11:40:04 +0200
Subject: [PATCH 1772/1774] dhb multiple replies support

---
 devicehandlers/DeviceHandlerBase.cpp | 36 ++++++++++++++++++----------
 devicehandlers/DeviceHandlerBase.h   | 18 ++++++++++++--
 2 files changed, 40 insertions(+), 14 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 531a0642b..4e4570167 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -308,6 +308,14 @@ void DeviceHandlerBase::doStateMachine() {
         uint32_t currentUptime;
         Clock::getUptime(&currentUptime);
         if (currentUptime - timeoutStart >= childTransitionDelay) {
+#if FSFW_VERBOSE_LEVEL >= 1
+            char printout[60];
+            sprintf(printout, "Transition timeout (%lu) occured !",
+                    static_cast<unsigned long>(childTransitionDelay));
+            /* Very common configuration error, so print it */
+            printWarningOrError(sif::OutputTypes::OUT_WARNING, "doStateMachine",
+                    RETURN_FAILED, printout);
+#endif
             triggerEvent(MODE_TRANSITION_FAILED, childTransitionFailure, 0);
             setMode(transitionSourceMode, transitionSourceSubMode);
             break;
@@ -448,6 +456,15 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
     }
 }
 
+size_t DeviceHandlerBase::getNextReplyLength(DeviceCommandId_t commandId){
+    DeviceReplyIter iter = deviceReplyMap.find(commandId);
+    if(iter != deviceReplyMap.end()) {
+        return iter->second.replyLen;
+    }else{
+        return 0;
+   }
+}
+
 ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
         uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
     auto replyIter = deviceReplyMap.find(deviceReply);
@@ -638,16 +655,12 @@ void DeviceHandlerBase::doGetWrite() {
 void DeviceHandlerBase::doSendRead() {
     ReturnValue_t result;
 
-    size_t requestLen = 0;
+    size_t replyLen = 0;
     if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
-        DeviceReplyIter iter = deviceReplyMap.find(
-                cookieInfo.pendingCommand->first);
-        if(iter != deviceReplyMap.end()) {
-            requestLen = iter->second.replyLen;
-        }
+        replyLen = getNextReplyLength(cookieInfo.pendingCommand->first);
     }
 
-    result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
+    result = communicationInterface->requestReceiveMessage(comCookie, replyLen);
 
     if (result == RETURN_OK) {
         cookieInfo.state = COOKIE_READ_SENT;
@@ -1501,10 +1514,9 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
 
     if(errorType == sif::OutputTypes::OUT_WARNING) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "DeviceHandlerBase::" << functionName << ": Object ID "
-                << std::hex << std::setw(8) << std::setfill('0')
-                << this->getObjectId() << " | " << errorPrint << std::dec
-                << std::setfill(' ') << std::endl;
+        sif::warning << "DeviceHandlerBase::" << functionName << ": Object ID 0x" << std::hex <<
+                std::setw(8) << std::setfill('0') << this->getObjectId() << " | " << errorPrint <<
+                std::dec << std::setfill(' ') << std::endl;
 #else
         sif::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
                 functionName, this->getObjectId(), errorPrint);
@@ -1512,7 +1524,7 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
     }
     else if(errorType == sif::OutputTypes::OUT_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "DeviceHandlerBase::" << functionName << ": Object ID "
+        sif::error << "DeviceHandlerBase::" << functionName << ": Object ID 0x"
                 << std::hex << std::setw(8) << std::setfill('0')
                 << this->getObjectId() << " | " << errorPrint << std::dec
                 << std::setfill(' ') << std::endl;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index d61b0407d..496c08ffd 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -471,13 +471,27 @@ protected:
     ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
             uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet = nullptr,
             size_t replyLen = 0, bool periodic = false);
+
     /**
-     * @brief 	A simple command to add a command to the commandList.
+     * @brief   A simple command to add a command to the commandList.
      * @param deviceCommand The command to add
      * @return - @c RETURN_OK when the command was successfully inserted,
      *         - @c RETURN_FAILED else.
      */
     ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
+
+    /**
+     * @brief   This function returns the reply length of the next reply to read.
+     *
+     * @param deviceCommand The command which triggered the device reply.
+     *
+     * @details The default implementation assumes only one reply is triggered by the command. In
+     *          case the command triggers multiple replies (e.g. one acknowledgment, one data,
+     *          and one execution status reply), this function can be overwritten to get the
+     *          reply length of the next reply to read.
+     */
+    virtual size_t getNextReplyLength(DeviceCommandId_t deviceCommand);
+
     /**
      * @brief 	This is a helper method to facilitate updating entries
      *        	in the reply map.
@@ -953,7 +967,7 @@ protected:
      * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an
      * 			  error case as many commands do not expect a reply.
      */
-    virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
+    virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator command,
             uint8_t expectedReplies = 1, bool useAlternateId = false,
             DeviceCommandId_t alternateReplyID = 0);
 

From 818634755d21e908c3e54e53ceb7907ac3999401 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 26 Apr 2021 15:47:49 +0200
Subject: [PATCH 1773/1774] checking returnvalue now

---
 parameters/ParameterHelper.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 24d0b2b1f..e80c2c47f 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -65,6 +65,9 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
         ParameterWrapper ownerWrapper;
         result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
                 &streamWrapper, linearIndex);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
 
         result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
         if (result != HasReturnvaluesIF::RETURN_OK) {

From 054de9781b28b511167cfc2a9d21c79831eef2b9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 27 Apr 2021 14:17:27 +0200
Subject: [PATCH 1774/1774] avoid duplicate printout

---
 devicehandlers/DeviceHandlerBase.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4e4570167..1623a1ac4 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -308,11 +308,11 @@ void DeviceHandlerBase::doStateMachine() {
         uint32_t currentUptime;
         Clock::getUptime(&currentUptime);
         if (currentUptime - timeoutStart >= childTransitionDelay) {
-#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_VERBOSE_LEVEL >= 1 && FSFW_OBJ_EVENT_TRANSLATION == 0
             char printout[60];
             sprintf(printout, "Transition timeout (%lu) occured !",
                     static_cast<unsigned long>(childTransitionDelay));
-            /* Very common configuration error, so print it */
+            /* Common configuration error for development, so print it */
             printWarningOrError(sif::OutputTypes::OUT_WARNING, "doStateMachine",
                     RETURN_FAILED, printout);
 #endif